From 65bdfc3d4edfa6a0e3e86edb78dc8f7cca172311 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 16 Dec 2025 23:11:35 +0900
Subject: [PATCH 001/418] Integrate OSError creations into OSErrorBuilder
 (#6443)

---
 crates/vm/src/exceptions.rs   | 114 ++++++++++++++++++++++++++++++++++
 crates/vm/src/ospath.rs       |  67 +++-----------------
 crates/vm/src/stdlib/io.rs    |  46 +++++++-------
 crates/vm/src/stdlib/os.rs    |  50 ++++++++-------
 crates/vm/src/stdlib/posix.rs |  23 +++----
 crates/vm/src/vm/vm_new.rs    |  24 +------
 6 files changed, 189 insertions(+), 135 deletions(-)

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 04dd78fb448..2b725085bec 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -1193,6 +1193,8 @@ pub(crate) fn errno_to_exc_type(_errno: i32, _vm: &VirtualMachine) -> Option<&'s
     None
 }
 
+pub(crate) use types::{OSErrorBuilder, ToOSErrorBuilder};
+
 pub(super) mod types {
     use crate::common::lock::PyRwLock;
     use crate::object::{MaybeTraverse, Traverse, TraverseFn};
@@ -1204,6 +1206,7 @@ pub(super) mod types {
             PyInt, PyStrRef, PyTupleRef, PyType, PyTypeRef, traceback::PyTracebackRef,
             tuple::IntoPyTuple,
         },
+        convert::ToPyObject,
         convert::ToPyResult,
         function::{ArgBytesLike, FuncArgs},
         types::{Constructor, Initializer},
@@ -1212,6 +1215,117 @@ pub(super) mod types {
     use itertools::Itertools;
     use rustpython_common::str::UnicodeEscapeCodepoint;
 
+    pub(crate) trait ToOSErrorBuilder {
+        fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder;
+    }
+
+    pub struct OSErrorBuilder {
+        exc_type: PyTypeRef,
+        errno: Option<i32>,
+        strerror: Option<PyObjectRef>,
+        filename: Option<PyObjectRef>,
+        #[cfg(windows)]
+        winerror: Option<PyObjectRef>,
+        filename2: Option<PyObjectRef>,
+    }
+
+    impl OSErrorBuilder {
+        #[must_use]
+        pub fn with_subtype(
+            exc_type: PyTypeRef,
+            errno: Option<i32>,
+            strerror: impl ToPyObject,
+            vm: &VirtualMachine,
+        ) -> Self {
+            let strerror = strerror.to_pyobject(vm);
+            Self {
+                exc_type,
+                errno,
+                strerror: Some(strerror),
+                filename: None,
+                #[cfg(windows)]
+                winerror: None,
+                filename2: None,
+            }
+        }
+        #[must_use]
+        pub fn with_errno(errno: i32, strerror: impl ToPyObject, vm: &VirtualMachine) -> Self {
+            let exc_type = crate::exceptions::errno_to_exc_type(errno, vm)
+                .unwrap_or(vm.ctx.exceptions.os_error)
+                .to_owned();
+            Self::with_subtype(exc_type, Some(errno), strerror, vm)
+        }
+
+        // #[must_use]
+        // pub(crate) fn errno(mut self, errno: i32) -> Self {
+        //     self.errno.replace(errno);
+        //     self
+        // }
+
+        #[must_use]
+        pub(crate) fn filename(mut self, filename: PyObjectRef) -> Self {
+            self.filename.replace(filename);
+            self
+        }
+
+        #[must_use]
+        pub(crate) fn filename2(mut self, filename: PyObjectRef) -> Self {
+            self.filename2.replace(filename);
+            self
+        }
+
+        #[must_use]
+        #[cfg(windows)]
+        pub(crate) fn winerror(mut self, winerror: PyObjectRef) -> Self {
+            self.winerror.replace(winerror);
+            self
+        }
+
+        pub fn build(self, vm: &VirtualMachine) -> PyRef<PyOSError> {
+            let OSErrorBuilder {
+                exc_type,
+                errno,
+                strerror,
+                filename,
+                #[cfg(windows)]
+                winerror,
+                filename2,
+            } = self;
+
+            let args = if let Some(errno) = errno {
+                #[cfg(windows)]
+                let winerror = winerror.to_pyobject(vm);
+                #[cfg(not(windows))]
+                let winerror = vm.ctx.none();
+
+                vec![
+                    errno.to_pyobject(vm),
+                    strerror.to_pyobject(vm),
+                    filename.to_pyobject(vm),
+                    winerror,
+                    filename2.to_pyobject(vm),
+                ]
+            } else {
+                vec![strerror.to_pyobject(vm)]
+            };
+
+            let payload = PyOSError::py_new(&exc_type, args.clone().into(), vm)
+                .expect("new_os_error usage error");
+            let os_error = payload
+                .into_ref_with_type(vm, exc_type)
+                .expect("new_os_error usage error");
+            PyOSError::slot_init(os_error.as_object().to_owned(), args.into(), vm)
+                .expect("new_os_error usage error");
+            os_error
+        }
+    }
+
+    impl crate::convert::IntoPyException for OSErrorBuilder {
+        fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+            self.build(vm).upcast()
+        }
+    }
+
     // Re-export exception group types from dedicated module
     pub use crate::exception_group::types::PyBaseExceptionGroup;
 
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
index add40f9b20c..9fca53d869c 100644
--- a/crates/vm/src/ospath.rs
+++ b/crates/vm/src/ospath.rs
@@ -2,10 +2,8 @@ use rustpython_common::crt_fd;
 
 use crate::{
     PyObjectRef, PyResult, VirtualMachine,
-    builtins::PyBaseExceptionRef,
     convert::{IntoPyException, ToPyException, ToPyObject, TryFromObject},
     function::FsPath,
-    object::AsObject,
 };
 use std::path::{Path, PathBuf};
 
@@ -144,62 +142,17 @@ impl OsPathOrFd<'_> {
     }
 }
 
-// TODO: preserve the input `PyObjectRef` of filename and filename2 (Failing check `self.assertIs(err.filename, name, str(func)`)
-pub struct IOErrorBuilder<'a> {
-    error: &'a std::io::Error,
-    filename: Option<OsPathOrFd<'a>>,
-    filename2: Option<OsPathOrFd<'a>>,
-}
-
-impl<'a> IOErrorBuilder<'a> {
-    pub const fn new(error: &'a std::io::Error) -> Self {
-        Self {
-            error,
-            filename: None,
-            filename2: None,
-        }
-    }
-
-    pub(crate) fn filename(mut self, filename: impl Into<OsPathOrFd<'a>>) -> Self {
-        let filename = filename.into();
-        self.filename.replace(filename);
-        self
-    }
-
-    pub(crate) fn filename2(mut self, filename: impl Into<OsPathOrFd<'a>>) -> Self {
-        let filename = filename.into();
-        self.filename2.replace(filename);
-        self
-    }
-
-    pub(crate) fn with_filename(
-        error: &'a std::io::Error,
+impl crate::exceptions::OSErrorBuilder {
+    #[must_use]
+    pub(crate) fn with_filename<'a>(
+        error: &std::io::Error,
         filename: impl Into<OsPathOrFd<'a>>,
         vm: &VirtualMachine,
-    ) -> PyBaseExceptionRef {
-        let zelf = IOErrorBuilder {
-            error,
-            filename: Some(filename.into()),
-            filename2: None,
-        };
-        zelf.to_pyexception(vm)
-    }
-}
-
-impl ToPyException for IOErrorBuilder<'_> {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        let exc = self.error.to_pyexception(vm);
-
-        if let Some(filename) = &self.filename {
-            exc.as_object()
-                .set_attr("filename", filename.filename(vm), vm)
-                .unwrap();
-        }
-        if let Some(filename2) = &self.filename2 {
-            exc.as_object()
-                .set_attr("filename2", filename2.filename(vm), vm)
-                .unwrap();
-        }
-        exc
+    ) -> crate::builtins::PyBaseExceptionRef {
+        // TODO: return type to PyRef<PyOSError>
+        use crate::exceptions::ToOSErrorBuilder;
+        let builder = error.to_os_error_builder(vm);
+        let builder = builder.filename(filename.into().filename(vm));
+        builder.build(vm).upcast()
     }
 }
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 3d67591d567..56bcbefddeb 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -14,11 +14,12 @@ use crate::{
     builtins::{PyBaseExceptionRef, PyModule},
     common::os::ErrorExt,
     convert::{IntoPyException, ToPyException},
+    exceptions::{OSErrorBuilder, ToOSErrorBuilder},
 };
 pub use _io::{OpenArgs, io_open as open};
 
-impl ToPyException for std::io::Error {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+impl ToOSErrorBuilder for std::io::Error {
+    fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder {
         let errno = self.posix_errno();
         #[cfg(windows)]
         let msg = 'msg: {
@@ -53,23 +54,23 @@ impl ToPyException for std::io::Error {
         #[cfg(not(any(windows, unix)))]
         let msg = self.to_string();
 
-        #[allow(clippy::let_and_return)]
-        let exc = vm.new_errno_error(errno, msg);
-        #[cfg(windows)]
-        {
-            use crate::object::AsObject;
-            let winerror = if let Some(winerror) = self.raw_os_error() {
-                vm.new_pyobj(winerror)
-            } else {
-                vm.ctx.none()
-            };
+        #[allow(unused_mut)]
+        let mut builder = OSErrorBuilder::with_errno(errno, msg, vm);
 
-            // FIXME: manual setup winerror due to lack of OSError.__init__ support
-            exc.as_object()
-                .set_attr("winerror", vm.new_pyobj(winerror), vm)
-                .unwrap();
+        #[cfg(windows)]
+        if let Some(winerror) = self.raw_os_error() {
+            use crate::convert::ToPyObject;
+            builder = builder.winerror(winerror.to_pyobject(vm));
         }
-        exc.upcast()
+
+        builder
+    }
+}
+
+impl ToPyException for std::io::Error {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        let builder = self.to_os_error_builder(vm);
+        builder.into_pyexception(vm)
     }
 }
 
@@ -4328,8 +4329,9 @@ mod fileio {
         builtins::{PyBaseExceptionRef, PyUtf8Str, PyUtf8StrRef},
         common::crt_fd,
         convert::{IntoPyException, ToPyException},
+        exceptions::OSErrorBuilder,
         function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg, OptionalOption},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd},
+        ospath::{OsPath, OsPathOrFd},
         stdlib::os,
         types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
     };
@@ -4526,7 +4528,7 @@ mod fileio {
                     let filename = OsPathOrFd::Path(path);
                     match fd {
                         Ok(fd) => (fd.into_raw(), Some(filename)),
-                        Err(e) => return Err(IOErrorBuilder::with_filename(&e, filename, vm)),
+                        Err(e) => return Err(OSErrorBuilder::with_filename(&e, filename, vm)),
                     }
                 }
             };
@@ -4541,7 +4543,7 @@ mod fileio {
             #[cfg(windows)]
             {
                 if let Err(err) = fd_fstat {
-                    return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                    return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                 }
             }
             #[cfg(any(unix, target_os = "wasi"))]
@@ -4550,12 +4552,12 @@ mod fileio {
                     Ok(status) => {
                         if (status.st_mode & libc::S_IFMT) == libc::S_IFDIR {
                             let err = std::io::Error::from_raw_os_error(libc::EISDIR);
-                            return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                            return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
                     }
                     Err(err) => {
                         if err.raw_os_error() == Some(libc::EBADF) {
-                            return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                            return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
                     }
                 }
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index f6ffd66759d..a698cae059c 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -153,6 +153,7 @@ pub(super) mod _os {
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
         builtins::{
             PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
+            ToOSErrorBuilder,
         },
         common::{
             crt_fd,
@@ -161,8 +162,9 @@ pub(super) mod _os {
             suppress_iph,
         },
         convert::{IntoPyException, ToPyObject},
+        exceptions::OSErrorBuilder,
         function::{ArgBytesLike, FsPath, FuncArgs, OptionalArg},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd, OutputMode},
+        ospath::{OsPath, OsPathOrFd, OutputMode},
         protocol::PyIterReturn,
         recursion::ReprGuard,
         types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter, Unconstructible},
@@ -263,7 +265,7 @@ pub(super) mod _os {
                 crt_fd::open(&name, flags, mode)
             }
         };
-        fd.map_err(|err| IOErrorBuilder::with_filename(&err, name, vm))
+        fd.map_err(|err| OSErrorBuilder::with_filename(&err, name, vm))
     }
 
     #[pyfunction]
@@ -316,7 +318,7 @@ pub(super) mod _os {
         } else {
             fs::remove_file(&path)
         };
-        res.map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
+        res.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
     }
 
     #[cfg(not(windows))]
@@ -334,7 +336,7 @@ pub(super) mod _os {
             let res = unsafe { libc::mkdirat(fd, c_path.as_ptr(), mode as _) };
             return if res < 0 {
                 let err = crate::common::os::errno_io_error();
-                Err(IOErrorBuilder::with_filename(&err, path, vm))
+                Err(OSErrorBuilder::with_filename(&err, path, vm))
             } else {
                 Ok(())
             };
@@ -344,7 +346,7 @@ pub(super) mod _os {
         let res = unsafe { libc::mkdir(c_path.as_ptr(), mode as _) };
         if res < 0 {
             let err = crate::common::os::errno_io_error();
-            return Err(IOErrorBuilder::with_filename(&err, path, vm));
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
         }
         Ok(())
     }
@@ -357,7 +359,7 @@ pub(super) mod _os {
     #[pyfunction]
     fn rmdir(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
         let [] = dir_fd.0;
-        fs::remove_dir(&path).map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
+        fs::remove_dir(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
     }
 
     const LISTDIR_FD: bool = cfg!(all(unix, not(target_os = "redox")));
@@ -373,13 +375,13 @@ pub(super) mod _os {
                 let dir_iter = match fs::read_dir(&path) {
                     Ok(iter) => iter,
                     Err(err) => {
-                        return Err(IOErrorBuilder::with_filename(&err, path, vm));
+                        return Err(OSErrorBuilder::with_filename(&err, path, vm));
                     }
                 };
                 dir_iter
                     .map(|entry| match entry {
                         Ok(entry_path) => Ok(path.mode.process_path(entry_path.file_name(), vm)),
-                        Err(err) => Err(IOErrorBuilder::with_filename(&err, path.clone(), vm)),
+                        Err(err) => Err(OSErrorBuilder::with_filename(&err, path.clone(), vm)),
                     })
                     .collect::<PyResult<_>>()?
             }
@@ -546,7 +548,7 @@ pub(super) mod _os {
         let mode = path.mode;
         let [] = dir_fd.0;
         let path =
-            fs::read_link(&path).map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))?;
+            fs::read_link(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
         Ok(mode.process_path(path, vm))
     }
 
@@ -859,7 +861,7 @@ pub(super) mod _os {
     fn scandir(path: OptionalArg<OsPath>, vm: &VirtualMachine) -> PyResult {
         let path = path.unwrap_or_else(|| OsPath::new_str("."));
         let entries = fs::read_dir(&path.path)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, path.clone(), vm))?;
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
         Ok(ScandirIterator {
             entries: PyRwLock::new(Some(entries)),
             mode: path.mode,
@@ -1084,7 +1086,7 @@ pub(super) mod _os {
         vm: &VirtualMachine,
     ) -> PyResult {
         let stat = stat_inner(file.clone(), dir_fd, follow_symlinks)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, file, vm))?
+            .map_err(|err| OSErrorBuilder::with_filename(&err, file, vm))?
             .ok_or_else(|| crate::exceptions::cstring_error(vm))?;
         Ok(StatResultData::from_stat(&stat, vm).to_pyobject(vm))
     }
@@ -1115,7 +1117,7 @@ pub(super) mod _os {
     #[pyfunction]
     fn chdir(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
         env::set_current_dir(&path.path)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
     }
 
     #[pyfunction]
@@ -1127,10 +1129,10 @@ pub(super) mod _os {
     #[pyfunction(name = "replace")]
     fn rename(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
         fs::rename(&src.path, &dst.path).map_err(|err| {
-            IOErrorBuilder::new(&err)
-                .filename(src)
-                .filename2(dst)
-                .into_pyexception(vm)
+            let builder = err.to_os_error_builder(vm);
+            let builder = builder.filename(src.filename(vm));
+            let builder = builder.filename2(dst.filename(vm));
+            builder.build(vm).upcast()
         })
     }
 
@@ -1219,10 +1221,10 @@ pub(super) mod _os {
     #[pyfunction]
     fn link(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
         fs::hard_link(&src.path, &dst.path).map_err(|err| {
-            IOErrorBuilder::new(&err)
-                .filename(src)
-                .filename2(dst)
-                .into_pyexception(vm)
+            let builder = err.to_os_error_builder(vm);
+            let builder = builder.filename(src.filename(vm));
+            let builder = builder.filename2(dst.filename(vm));
+            builder.build(vm).upcast()
         })
     }
 
@@ -1334,7 +1336,7 @@ pub(super) mod _os {
                     )
                 };
                 if ret < 0 {
-                    Err(IOErrorBuilder::with_filename(
+                    Err(OSErrorBuilder::with_filename(
                         &io::Error::last_os_error(),
                         path_for_err,
                         vm,
@@ -1385,14 +1387,14 @@ pub(super) mod _os {
                 .write(true)
                 .custom_flags(windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS)
                 .open(&path)
-                .map_err(|err| IOErrorBuilder::with_filename(&err, path.clone(), vm))?;
+                .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
 
             let ret = unsafe {
                 FileSystem::SetFileTime(f.as_raw_handle() as _, std::ptr::null(), &acc, &modif)
             };
 
             if ret == 0 {
-                Err(IOErrorBuilder::with_filename(
+                Err(OSErrorBuilder::with_filename(
                     &io::Error::last_os_error(),
                     path,
                     vm,
@@ -1565,7 +1567,7 @@ pub(super) mod _os {
             error: std::io::Error,
             path: OsPath,
         ) -> crate::builtins::PyBaseExceptionRef {
-            IOErrorBuilder::with_filename(&error, path, vm)
+            OSErrorBuilder::with_filename(&error, path, vm)
         }
 
         let path = OsPath::try_from_object(vm, path)?;
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 680e9914a03..cfe605733d3 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -26,8 +26,9 @@ pub mod module {
         AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
         builtins::{PyDictRef, PyInt, PyListRef, PyStrRef, PyTupleRef, PyType, PyUtf8StrRef},
         convert::{IntoPyException, ToPyObject, TryFromObject},
+        exceptions::OSErrorBuilder,
         function::{Either, KwArgs, OptionalArg},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd},
+        ospath::{OsPath, OsPathOrFd},
         stdlib::os::{_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, fs_metadata},
         types::{Constructor, Representable},
         utils::ToCString,
@@ -412,7 +413,7 @@ pub mod module {
         }
 
         let metadata =
-            metadata.map_err(|err| IOErrorBuilder::with_filename(&err, path.clone(), vm))?;
+            metadata.map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
 
         let user_id = metadata.uid();
         let group_id = metadata.gid();
@@ -482,12 +483,12 @@ pub mod module {
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn chroot(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        use crate::ospath::IOErrorBuilder;
+        use crate::exceptions::OSErrorBuilder;
 
         nix::unistd::chroot(&*path.path).map_err(|err| {
             // Use `From<nix::Error> for io::Error` when it is available
-            let err = io::Error::from_raw_os_error(err as i32);
-            IOErrorBuilder::with_filename(&err, path, vm)
+            let io_err: io::Error = err.into();
+            OSErrorBuilder::with_filename(&io_err, path, vm)
         })
     }
 
@@ -533,7 +534,7 @@ pub mod module {
         .map_err(|err| {
             // Use `From<nix::Error> for io::Error` when it is available
             let err = io::Error::from_raw_os_error(err as i32);
-            IOErrorBuilder::with_filename(&err, path, vm)
+            OSErrorBuilder::with_filename(&err, path, vm)
         })
     }
 
@@ -1031,7 +1032,7 @@ pub mod module {
             permissions.set_mode(mode);
             fs::set_permissions(&path, permissions)
         };
-        body().map_err(|err| IOErrorBuilder::with_filename(&err, err_path, vm))
+        body().map_err(|err| OSErrorBuilder::with_filename(&err, err_path, vm))
     }
 
     #[cfg(not(target_os = "redox"))]
@@ -1093,7 +1094,7 @@ pub mod module {
             Ok(())
         } else {
             let err = std::io::Error::last_os_error();
-            Err(IOErrorBuilder::with_filename(&err, path, vm))
+            Err(OSErrorBuilder::with_filename(&err, path, vm))
         }
     }
 
@@ -1554,7 +1555,7 @@ pub mod module {
                     };
                     if let Err(err) = ret {
                         let err = err.into();
-                        return Err(IOErrorBuilder::with_filename(&err, self.path, vm));
+                        return Err(OSErrorBuilder::with_filename(&err, self.path, vm));
                     }
                 }
             }
@@ -1653,7 +1654,7 @@ pub mod module {
                 nix::spawn::posix_spawn(&*path, &file_actions, &attrp, &args, &env)
             };
             ret.map(Into::into)
-                .map_err(|err| IOErrorBuilder::with_filename(&err.into(), self.path, vm))
+                .map_err(|err| OSErrorBuilder::with_filename(&err.into(), self.path, vm))
         }
     }
 
@@ -2126,7 +2127,7 @@ pub mod module {
             if Errno::last_raw() == 0 {
                 Ok(None)
             } else {
-                Err(IOErrorBuilder::with_filename(
+                Err(OSErrorBuilder::with_filename(
                     &io::Error::from(Errno::last()),
                     path,
                     vm,
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 36481e5dbe3..6d0e983c844 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -1,5 +1,5 @@
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef,
+    AsObject, Py, PyObject, PyObjectRef, PyRef,
     builtins::{
         PyBaseException, PyBaseExceptionRef, PyBytesRef, PyDictRef, PyModule, PyOSError, PyStrRef,
         PyType, PyTypeRef,
@@ -8,9 +8,9 @@ use crate::{
         tuple::{IntoPyTuple, PyTupleRef},
     },
     convert::{ToPyException, ToPyObject},
+    exceptions::OSErrorBuilder,
     function::{IntoPyNativeFn, PyMethodFlags},
     scope::Scope,
-    types::Constructor,
     vm::VirtualMachine,
 };
 use rustpython_compiler_core::SourceLocation;
@@ -119,26 +119,8 @@ impl VirtualMachine {
         msg: impl ToPyObject,
     ) -> PyRef<PyOSError> {
         debug_assert_eq!(exc_type.slots.basicsize, std::mem::size_of::<PyOSError>());
-        let msg = msg.to_pyobject(self);
-
-        fn new_os_subtype_error_impl(
-            vm: &VirtualMachine,
-            exc_type: PyTypeRef,
-            errno: Option<i32>,
-            msg: PyObjectRef,
-        ) -> PyRef<PyOSError> {
-            let args = match errno {
-                Some(e) => vec![vm.new_pyobj(e), msg],
-                None => vec![msg],
-            };
-            let payload =
-                PyOSError::py_new(&exc_type, args.into(), vm).expect("new_os_error usage error");
-            payload
-                .into_ref_with_type(vm, exc_type)
-                .expect("new_os_error usage error")
-        }
 
-        new_os_subtype_error_impl(self, exc_type, errno, msg)
+        OSErrorBuilder::with_subtype(exc_type, errno, msg, self).build(self)
     }
 
     /// Instantiate an exception with no arguments.

From aef4de4ab883a8a442e956da5ce0cccf66466a8f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 16 Dec 2025 23:27:21 +0900
Subject: [PATCH 002/418] fix buffer (#6447)

---
 .cspell.dict/cpython.txt |  3 +++
 crates/vm/src/buffer.rs  | 19 ++++++++++++++++---
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 26921e04080..8acb1468f66 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -15,6 +15,7 @@ cellvar
 cellvars
 cmpop
 denom
+DICTFLAG
 dictoffset
 elts
 excepthandler
@@ -28,6 +29,7 @@ heaptype
 HIGHRES
 IMMUTABLETYPE
 Itertool
+keeped
 kwonlyarg
 kwonlyargs
 lasti
@@ -48,6 +50,7 @@ PYTHREAD_NAME
 SA_ONSTACK
 SOABI
 stackdepth
+stginfo
 stringlib
 structseq
 subparams
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index 13cebfc6a28..cf49d6815c0 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -238,10 +238,23 @@ impl FormatCode {
                 _ => 1,
             };
 
+            // Skip whitespace (Python ignores whitespace in format strings)
+            while let Some(b' ' | b'\t' | b'\n' | b'\r') = chars.peek() {
+                chars.next();
+            }
+
             // determine format char:
-            let c = chars
-                .next()
-                .ok_or_else(|| "repeat count given without format specifier".to_owned())?;
+            let c = match chars.next() {
+                Some(c) => c,
+                None => {
+                    // If we have a repeat count but only whitespace follows, error
+                    if repeat != 1 {
+                        return Err("repeat count given without format specifier".to_owned());
+                    }
+                    // Otherwise, we're done parsing
+                    break;
+                }
+            };
 
             // Check for embedded null character
             if c == 0 {

From 246fab63f7cc89fa1a0ba423b7ada2bbce6f31f1 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 17 Dec 2025 00:12:03 +0900
Subject: [PATCH 003/418] flag: DISALLOW_INSTANTIATION (#6445)

* Set tp_new slot when build heap/static type

* Improve type tp_call impl to check tp_new existence and error if not exist

* Set DISALLOW_INSTANTIATION flag on several types according to cpython impl

* Allow #[pyslot] for function pointer

* Fix DISALLOW_INSTANTIATION

---------

Signed-off-by: snowapril <sinjihng@gmail.com>
Co-authored-by: snowapril <sinjihng@gmail.com>
---
 Lib/test/test_descr.py                   |  1 -
 crates/derive-impl/src/pyclass.rs        | 18 ++----
 crates/stdlib/src/array.rs               |  2 +-
 crates/stdlib/src/csv.rs                 |  4 +-
 crates/stdlib/src/pystruct.rs            |  6 +-
 crates/stdlib/src/sqlite.rs              | 10 +--
 crates/stdlib/src/unicodedata.rs         |  2 +-
 crates/stdlib/src/zlib.rs                |  4 +-
 crates/vm/src/builtins/asyncgenerator.rs |  6 +-
 crates/vm/src/builtins/builtin_func.rs   | 12 ++--
 crates/vm/src/builtins/bytearray.rs      |  6 +-
 crates/vm/src/builtins/bytes.rs          |  5 +-
 crates/vm/src/builtins/coroutine.rs      |  6 +-
 crates/vm/src/builtins/descriptor.rs     | 15 ++---
 crates/vm/src/builtins/dict.rs           | 62 +++++++++---------
 crates/vm/src/builtins/frame.rs          |  6 +-
 crates/vm/src/builtins/generator.rs      |  6 +-
 crates/vm/src/builtins/getset.rs         |  5 +-
 crates/vm/src/builtins/list.rs           |  8 +--
 crates/vm/src/builtins/memory.rs         |  5 +-
 crates/vm/src/builtins/range.rs          |  8 +--
 crates/vm/src/builtins/set.rs            |  5 +-
 crates/vm/src/builtins/str.rs            |  6 +-
 crates/vm/src/builtins/tuple.rs          |  5 +-
 crates/vm/src/builtins/type.rs           | 81 +++++++++++++++++++++---
 crates/vm/src/class.rs                   | 24 +++++--
 crates/vm/src/protocol/buffer.rs         |  5 +-
 crates/vm/src/stdlib/ctypes/field.rs     |  6 +-
 crates/vm/src/stdlib/os.rs               |  9 +--
 crates/vm/src/types/slot.rs              |  9 ---
 30 files changed, 184 insertions(+), 163 deletions(-)

diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index f592a88fc2c..8c711207fae 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -1788,7 +1788,6 @@ class D(C):
         self.assertEqual(b.foo, 3)
         self.assertEqual(b.__class__, D)
 
-    @unittest.expectedFailure
     def test_bad_new(self):
         self.assertRaises(TypeError, object.__new__)
         self.assertRaises(TypeError, object.__new__, '')
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 5060dced2b0..f784a2e2a76 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -954,7 +954,10 @@ where
         } else if let Ok(f) = args.item.function_or_method() {
             (&f.sig().ident, f.span())
         } else {
-            return Err(self.new_syn_error(args.item.span(), "can only be on a method"));
+            return Err(self.new_syn_error(
+                args.item.span(),
+                "can only be on a method or const function pointer",
+            ));
         };
 
         let item_attr = args.attrs.remove(self.index());
@@ -1496,7 +1499,9 @@ impl SlotItemMeta {
             }
         } else {
             let ident_str = self.inner().item_name();
-            let name = if let Some(stripped) = ident_str.strip_prefix("slot_") {
+            // Convert to lowercase to handle both SLOT_NEW and slot_new
+            let ident_lower = ident_str.to_lowercase();
+            let name = if let Some(stripped) = ident_lower.strip_prefix("slot_") {
                 proc_macro2::Ident::new(stripped, inner.item_ident.span())
             } else {
                 inner.item_ident.clone()
@@ -1609,7 +1614,6 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
     }];
     let mut payload = None;
 
-    let mut has_constructor = false;
     for attr in attr {
         match attr {
             NestedMeta::Meta(Meta::List(MetaList { path, nested, .. })) => {
@@ -1634,9 +1638,6 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
                                     "Try `#[pyclass(with(Constructor, ...))]` instead of `#[pyclass(with(DefaultConstructor, ...))]`. DefaultConstructor implicitly implements Constructor."
                                 )
                             }
-                            if path.is_ident("Constructor") || path.is_ident("Unconstructible") {
-                                has_constructor = true;
-                            }
                             (
                                 quote!(<Self as #path>::__extend_py_class),
                                 quote!(<Self as #path>::__OWN_METHOD_DEFS),
@@ -1689,11 +1690,6 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
             attr => bail_span!(attr, "Unknown pyimpl attribute"),
         }
     }
-    // TODO: DISALLOW_INSTANTIATION check is required
-    let _ = has_constructor;
-    // if !withs.is_empty() && !has_constructor {
-    //     bail_span!(item, "#[pyclass(with(...))] does not have a Constructor. Either #[pyclass(with(Constructor, ...))] or #[pyclass(with(Unconstructible, ...))] is mandatory. Consider to add `impl DefaultConstructor for T {{}}` or `impl Unconstructible for T {{}}`.")
-    // }
 
     Ok(ExtractedImplAttrs {
         payload,
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 4fcba1f8725..49ca4a89037 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -1399,7 +1399,7 @@ mod array {
         internal: PyMutex<PositionIterInternal<PyArrayRef>>,
     }
 
-    #[pyclass(with(IterNext, Iterable), flags(HAS_DICT))]
+    #[pyclass(with(IterNext, Iterable), flags(HAS_DICT, DISALLOW_INSTANTIATION))]
     impl PyArrayIter {
         #[pymethod]
         fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
index 3c7cc2ff807..792402e0580 100644
--- a/crates/stdlib/src/csv.rs
+++ b/crates/stdlib/src/csv.rs
@@ -908,7 +908,7 @@ mod _csv {
         }
     }
 
-    #[pyclass(with(IterNext, Iterable))]
+    #[pyclass(with(IterNext, Iterable), flags(DISALLOW_INSTANTIATION))]
     impl Reader {
         #[pygetset]
         fn line_num(&self) -> u64 {
@@ -1059,7 +1059,7 @@ mod _csv {
         }
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Writer {
         #[pygetset(name = "dialect")]
         const fn get_dialect(&self, _vm: &VirtualMachine) -> PyDialect {
diff --git a/crates/stdlib/src/pystruct.rs b/crates/stdlib/src/pystruct.rs
index 798e5f5de80..0a006f5a0f2 100644
--- a/crates/stdlib/src/pystruct.rs
+++ b/crates/stdlib/src/pystruct.rs
@@ -16,7 +16,7 @@ pub(crate) mod _struct {
         function::{ArgBytesLike, ArgMemoryBuffer, PosArgs},
         match_class,
         protocol::PyIterReturn,
-        types::{Constructor, IterNext, Iterable, Representable, SelfIter, Unconstructible},
+        types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
     use crossbeam_utils::atomic::AtomicCell;
 
@@ -189,7 +189,7 @@ pub(crate) mod _struct {
         }
     }
 
-    #[pyclass(with(Unconstructible, IterNext, Iterable))]
+    #[pyclass(with(IterNext, Iterable), flags(DISALLOW_INSTANTIATION))]
     impl UnpackIterator {
         #[pymethod]
         fn __length_hint__(&self) -> usize {
@@ -197,7 +197,7 @@ pub(crate) mod _struct {
         }
     }
     impl SelfIter for UnpackIterator {}
-    impl Unconstructible for UnpackIterator {}
+
     impl IterNext for UnpackIterator {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
             let size = zelf.format_spec.size;
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index deff3c3a66a..bc84cffbf80 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -75,7 +75,7 @@ mod _sqlite {
         sliceable::{SaturatedSliceIter, SliceableSequenceOp},
         types::{
             AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,
-            Initializer, IterNext, Iterable, PyComparisonOp, SelfIter, Unconstructible,
+            Initializer, IterNext, Iterable, PyComparisonOp, SelfIter,
         },
         utils::ToCString,
     };
@@ -2197,8 +2197,6 @@ mod _sqlite {
         inner: PyMutex<Option<BlobInner>>,
     }
 
-    impl Unconstructible for Blob {}
-
     #[derive(Debug)]
     struct BlobInner {
         blob: SqliteBlob,
@@ -2211,7 +2209,7 @@ mod _sqlite {
         }
     }
 
-    #[pyclass(with(AsMapping, Unconstructible, AsNumber, AsSequence))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(AsMapping, AsNumber, AsSequence))]
     impl Blob {
         #[pymethod]
         fn close(&self) {
@@ -2592,9 +2590,7 @@ mod _sqlite {
         }
     }
 
-    impl Unconstructible for Statement {}
-
-    #[pyclass(with(Unconstructible))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Statement {
         fn new(
             connection: &Connection,
diff --git a/crates/stdlib/src/unicodedata.rs b/crates/stdlib/src/unicodedata.rs
index 46e18357260..68d9a17e575 100644
--- a/crates/stdlib/src/unicodedata.rs
+++ b/crates/stdlib/src/unicodedata.rs
@@ -105,7 +105,7 @@ mod unicodedata {
         }
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Ucd {
         #[pymethod]
         fn category(&self, character: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
diff --git a/crates/stdlib/src/zlib.rs b/crates/stdlib/src/zlib.rs
index 328452ae9d5..9ca94939f78 100644
--- a/crates/stdlib/src/zlib.rs
+++ b/crates/stdlib/src/zlib.rs
@@ -225,7 +225,7 @@ mod zlib {
         inner: PyMutex<PyDecompressInner>,
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl PyDecompress {
         #[pygetset]
         fn eof(&self) -> bool {
@@ -383,7 +383,7 @@ mod zlib {
         inner: PyMutex<CompressState<CompressInner>>,
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl PyCompress {
         #[pymethod]
         fn compress(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 073513184ff..483ba6a7f96 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -8,7 +8,7 @@ use crate::{
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
+    types::{IterNext, Iterable, Representable, SelfIter},
 };
 
 use crossbeam_utils::atomic::AtomicCell;
@@ -32,7 +32,7 @@ impl PyPayload for PyAsyncGen {
     }
 }
 
-#[pyclass(with(PyRef, Unconstructible, Representable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(PyRef, Representable))]
 impl PyAsyncGen {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -201,8 +201,6 @@ impl Representable for PyAsyncGen {
     }
 }
 
-impl Unconstructible for PyAsyncGen {}
-
 #[pyclass(module = false, name = "async_generator_wrapped_value")]
 #[derive(Debug)]
 pub(crate) struct PyAsyncGenWrappedValue(pub PyObjectRef);
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
index d1ce107e374..d25188affd2 100644
--- a/crates/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -5,7 +5,7 @@ use crate::{
     common::wtf8::Wtf8,
     convert::TryFromObject,
     function::{FuncArgs, PyComparisonValue, PyMethodDef, PyMethodFlags, PyNativeFn},
-    types::{Callable, Comparable, PyComparisonOp, Representable, Unconstructible},
+    types::{Callable, Comparable, PyComparisonOp, Representable},
 };
 use std::fmt;
 
@@ -74,7 +74,7 @@ impl Callable for PyNativeFunction {
     }
 }
 
-#[pyclass(with(Callable, Unconstructible), flags(HAS_DICT))]
+#[pyclass(with(Callable), flags(HAS_DICT, DISALLOW_INSTANTIATION))]
 impl PyNativeFunction {
     #[pygetset]
     fn __module__(zelf: NativeFunctionOrMethod) -> Option<&'static PyStrInterned> {
@@ -145,8 +145,6 @@ impl Representable for PyNativeFunction {
     }
 }
 
-impl Unconstructible for PyNativeFunction {}
-
 // `PyCMethodObject` in CPython
 #[pyclass(name = "builtin_method", module = false, base = PyNativeFunction, ctx = "builtin_method_type")]
 pub struct PyNativeMethod {
@@ -155,8 +153,8 @@ pub struct PyNativeMethod {
 }
 
 #[pyclass(
-    with(Unconstructible, Callable, Comparable, Representable),
-    flags(HAS_DICT)
+    with(Callable, Comparable, Representable),
+    flags(HAS_DICT, DISALLOW_INSTANTIATION)
 )]
 impl PyNativeMethod {
     #[pygetset]
@@ -246,8 +244,6 @@ impl Representable for PyNativeMethod {
     }
 }
 
-impl Unconstructible for PyNativeMethod {}
-
 pub fn init(context: &Context) {
     PyNativeFunction::extend_class(context, context.types.builtin_function_or_method_type);
     PyNativeMethod::extend_class(context, context.types.builtin_method_type);
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index 32eaa2b3e27..c5861befb73 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -33,7 +33,7 @@ use crate::{
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor,
         DefaultConstructor, Initializer, IterNext, Iterable, PyComparisonOp, Representable,
-        SelfIter, Unconstructible,
+        SelfIter,
     },
 };
 use bstr::ByteSlice;
@@ -865,7 +865,7 @@ impl PyPayload for PyByteArrayIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyByteArrayIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -886,8 +886,6 @@ impl PyByteArrayIterator {
     }
 }
 
-impl Unconstructible for PyByteArrayIterator {}
-
 impl SelfIter for PyByteArrayIterator {}
 impl IterNext for PyByteArrayIterator {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 70a33401271..f782c035f86 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -25,7 +25,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,
-        IterNext, Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
     },
 };
 use bstr::ByteSlice;
@@ -749,7 +749,7 @@ impl PyPayload for PyBytesIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyBytesIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -770,7 +770,6 @@ impl PyBytesIterator {
             .set_state(state, |obj, pos| pos.min(obj.len()), vm)
     }
 }
-impl Unconstructible for PyBytesIterator {}
 
 impl SelfIter for PyBytesIterator {}
 impl IterNext for PyBytesIterator {
diff --git a/crates/vm/src/builtins/coroutine.rs b/crates/vm/src/builtins/coroutine.rs
index 0909cdfb444..21405448693 100644
--- a/crates/vm/src/builtins/coroutine.rs
+++ b/crates/vm/src/builtins/coroutine.rs
@@ -6,7 +6,7 @@ use crate::{
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
+    types::{IterNext, Iterable, Representable, SelfIter},
 };
 use crossbeam_utils::atomic::AtomicCell;
 
@@ -24,7 +24,7 @@ impl PyPayload for PyCoroutine {
     }
 }
 
-#[pyclass(with(Py, Unconstructible, IterNext, Representable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Representable))]
 impl PyCoroutine {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -123,8 +123,6 @@ impl Py<PyCoroutine> {
     }
 }
 
-impl Unconstructible for PyCoroutine {}
-
 impl Representable for PyCoroutine {
     #[inline]
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index bc3aded3253..cdcc456edfc 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -4,7 +4,7 @@ use crate::{
     builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
     class::PyClassImpl,
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
-    types::{Callable, GetDescriptor, Representable, Unconstructible},
+    types::{Callable, GetDescriptor, Representable},
 };
 use rustpython_common::lock::PyRwLock;
 
@@ -105,8 +105,8 @@ impl PyMethodDescriptor {
 }
 
 #[pyclass(
-    with(GetDescriptor, Callable, Unconstructible, Representable),
-    flags(METHOD_DESCRIPTOR)
+    with(GetDescriptor, Callable, Representable),
+    flags(METHOD_DESCRIPTOR, DISALLOW_INSTANTIATION)
 )]
 impl PyMethodDescriptor {
     #[pygetset]
@@ -159,8 +159,6 @@ impl Representable for PyMethodDescriptor {
     }
 }
 
-impl Unconstructible for PyMethodDescriptor {}
-
 #[derive(Debug)]
 pub enum MemberKind {
     Bool = 14,
@@ -246,7 +244,10 @@ fn calculate_qualname(descr: &PyDescriptorOwned, vm: &VirtualMachine) -> PyResul
     }
 }
 
-#[pyclass(with(GetDescriptor, Unconstructible, Representable), flags(BASETYPE))]
+#[pyclass(
+    with(GetDescriptor, Representable),
+    flags(BASETYPE, DISALLOW_INSTANTIATION)
+)]
 impl PyMemberDescriptor {
     #[pygetset]
     fn __doc__(&self) -> Option<String> {
@@ -339,8 +340,6 @@ fn set_slot_at_object(
     Ok(())
 }
 
-impl Unconstructible for PyMemberDescriptor {}
-
 impl Representable for PyMemberDescriptor {
     #[inline]
     fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 77126d4ee62..b34299d4170 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -19,7 +19,7 @@ use crate::{
     recursion::ReprGuard,
     types::{
         AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, DefaultConstructor,
-        Initializer, IterNext, Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        Initializer, IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
     },
     vm::VirtualMachine,
 };
@@ -848,7 +848,7 @@ macro_rules! dict_view {
             }
         }
 
-        #[pyclass(with(Unconstructible, IterNext, Iterable))]
+        #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
         impl $iter_name {
             fn new(dict: PyDictRef) -> Self {
                 $iter_name {
@@ -878,8 +878,6 @@ macro_rules! dict_view {
             }
         }
 
-        impl Unconstructible for $iter_name {}
-
         impl SelfIter for $iter_name {}
         impl IterNext for $iter_name {
             #[allow(clippy::redundant_closure_call)]
@@ -923,7 +921,7 @@ macro_rules! dict_view {
             }
         }
 
-        #[pyclass(with(Unconstructible, IterNext, Iterable))]
+        #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
         impl $reverse_iter_name {
             fn new(dict: PyDictRef) -> Self {
                 let size = dict.size();
@@ -957,8 +955,6 @@ macro_rules! dict_view {
                     .rev_length_hint(|_| self.size.entries_size)
             }
         }
-        impl Unconstructible for $reverse_iter_name {}
-
         impl SelfIter for $reverse_iter_name {}
         impl IterNext for $reverse_iter_name {
             #[allow(clippy::redundant_closure_call)]
@@ -1126,16 +1122,18 @@ trait ViewSetOps: DictView {
 }
 
 impl ViewSetOps for PyDictKeys {}
-#[pyclass(with(
-    DictView,
-    Unconstructible,
-    Comparable,
-    Iterable,
-    ViewSetOps,
-    AsSequence,
-    AsNumber,
-    Representable
-))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(
+        DictView,
+        Comparable,
+        Iterable,
+        ViewSetOps,
+        AsSequence,
+        AsNumber,
+        Representable
+    )
+)]
 impl PyDictKeys {
     #[pymethod]
     fn __contains__(zelf: PyObjectRef, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
@@ -1147,7 +1145,6 @@ impl PyDictKeys {
         PyMappingProxy::from(zelf.dict().clone())
     }
 }
-impl Unconstructible for PyDictKeys {}
 
 impl Comparable for PyDictKeys {
     fn cmp(
@@ -1190,16 +1187,18 @@ impl AsNumber for PyDictKeys {
 }
 
 impl ViewSetOps for PyDictItems {}
-#[pyclass(with(
-    DictView,
-    Unconstructible,
-    Comparable,
-    Iterable,
-    ViewSetOps,
-    AsSequence,
-    AsNumber,
-    Representable
-))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(
+        DictView,
+        Comparable,
+        Iterable,
+        ViewSetOps,
+        AsSequence,
+        AsNumber,
+        Representable
+    )
+)]
 impl PyDictItems {
     #[pymethod]
     fn __contains__(zelf: PyObjectRef, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
@@ -1210,7 +1209,6 @@ impl PyDictItems {
         PyMappingProxy::from(zelf.dict().clone())
     }
 }
-impl Unconstructible for PyDictItems {}
 
 impl Comparable for PyDictItems {
     fn cmp(
@@ -1264,14 +1262,16 @@ impl AsNumber for PyDictItems {
     }
 }
 
-#[pyclass(with(DictView, Unconstructible, Iterable, AsSequence, Representable))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(DictView, Iterable, AsSequence, Representable)
+)]
 impl PyDictValues {
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
         PyMappingProxy::from(zelf.dict().clone())
     }
 }
-impl Unconstructible for PyDictValues {}
 
 impl AsSequence for PyDictValues {
     fn as_sequence() -> &'static PySequenceMethods {
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 17dc88ac042..6ccc594d338 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -8,7 +8,7 @@ use crate::{
     class::PyClassImpl,
     frame::{Frame, FrameRef},
     function::PySetterValue,
-    types::{Representable, Unconstructible},
+    types::Representable,
 };
 use num_traits::Zero;
 
@@ -16,8 +16,6 @@ pub fn init(context: &Context) {
     Frame::extend_class(context, context.types.frame_type);
 }
 
-impl Unconstructible for Frame {}
-
 impl Representable for Frame {
     #[inline]
     fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
@@ -31,7 +29,7 @@ impl Representable for Frame {
     }
 }
 
-#[pyclass(with(Unconstructible, Py))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py))]
 impl Frame {
     #[pymethod]
     const fn clear(&self) {
diff --git a/crates/vm/src/builtins/generator.rs b/crates/vm/src/builtins/generator.rs
index da981b5a6c2..04cd7dd3456 100644
--- a/crates/vm/src/builtins/generator.rs
+++ b/crates/vm/src/builtins/generator.rs
@@ -10,7 +10,7 @@ use crate::{
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
+    types::{IterNext, Iterable, Representable, SelfIter},
 };
 
 #[pyclass(module = false, name = "generator")]
@@ -26,7 +26,7 @@ impl PyPayload for PyGenerator {
     }
 }
 
-#[pyclass(with(Py, Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Iterable))]
 impl PyGenerator {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -114,8 +114,6 @@ impl Py<PyGenerator> {
     }
 }
 
-impl Unconstructible for PyGenerator {}
-
 impl Representable for PyGenerator {
     #[inline]
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
diff --git a/crates/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
index 4b966bbc31b..f56191f5f8b 100644
--- a/crates/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -7,7 +7,7 @@ use crate::{
     builtins::type_::PointerSlot,
     class::PyClassImpl,
     function::{IntoPyGetterFunc, IntoPySetterFunc, PyGetterFunc, PySetterFunc, PySetterValue},
-    types::{GetDescriptor, Unconstructible},
+    types::GetDescriptor,
 };
 
 #[pyclass(module = false, name = "getset_descriptor")]
@@ -96,7 +96,7 @@ impl PyGetSet {
     }
 }
 
-#[pyclass(with(GetDescriptor, Unconstructible))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(GetDescriptor))]
 impl PyGetSet {
     // Descriptor methods
 
@@ -152,7 +152,6 @@ impl PyGetSet {
         Ok(unsafe { zelf.class.borrow_static() }.to_owned().into())
     }
 }
-impl Unconstructible for PyGetSet {}
 
 pub(crate) fn init(context: &Context) {
     PyGetSet::extend_class(context, context.types.getset_type);
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index b2927462cac..0683381f38a 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -15,7 +15,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
     types::{
         AsMapping, AsSequence, Comparable, Constructor, Initializer, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
@@ -544,7 +544,7 @@ impl PyPayload for PyListIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyListIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -565,7 +565,6 @@ impl PyListIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyListIterator {}
 
 impl SelfIter for PyListIterator {}
 impl IterNext for PyListIterator {
@@ -590,7 +589,7 @@ impl PyPayload for PyListReverseIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyListReverseIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -611,7 +610,6 @@ impl PyListReverseIterator {
             .builtins_reversed_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyListReverseIterator {}
 
 impl SelfIter for PyListReverseIterator {}
 impl IterNext for PyListReverseIterator {
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
index c1b1496e8c6..4e895f92b7e 100644
--- a/crates/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -23,7 +23,7 @@ use crate::{
     sliceable::SequenceIndexOp,
     types::{
         AsBuffer, AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -1132,7 +1132,7 @@ impl PyPayload for PyMemoryViewIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyMemoryViewIterator {
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
@@ -1141,7 +1141,6 @@ impl PyMemoryViewIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyMemoryViewIterator {}
 
 impl SelfIter for PyMemoryViewIterator {}
 impl IterNext for PyMemoryViewIterator {
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index 3edd130ee28..9f79f8efb2d 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -11,7 +11,7 @@ use crate::{
     protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
     types::{
         AsMapping, AsSequence, Comparable, Hashable, IterNext, Iterable, PyComparisonOp,
-        Representable, SelfIter, Unconstructible,
+        Representable, SelfIter,
     },
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -548,7 +548,7 @@ impl PyPayload for PyLongRangeIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyLongRangeIterator {
     #[pymethod]
     fn __length_hint__(&self) -> BigInt {
@@ -577,7 +577,6 @@ impl PyLongRangeIterator {
         )
     }
 }
-impl Unconstructible for PyLongRangeIterator {}
 
 impl SelfIter for PyLongRangeIterator {}
 impl IterNext for PyLongRangeIterator {
@@ -614,7 +613,7 @@ impl PyPayload for PyRangeIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyRangeIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -640,7 +639,6 @@ impl PyRangeIterator {
         )
     }
 }
-impl Unconstructible for PyRangeIterator {}
 
 impl SelfIter for PyRangeIterator {}
 impl IterNext for PyRangeIterator {
diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
index 7fde8d32781..5582ff3323c 100644
--- a/crates/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -18,7 +18,7 @@ use crate::{
     types::AsNumber,
     types::{
         AsSequence, Comparable, Constructor, DefaultConstructor, Hashable, Initializer, IterNext,
-        Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        Iterable, PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
@@ -1304,7 +1304,7 @@ impl PyPayload for PySetIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PySetIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -1330,7 +1330,6 @@ impl PySetIterator {
         ))
     }
 }
-impl Unconstructible for PySetIterator {}
 
 impl SelfIter for PySetIterator {}
 impl IterNext for PySetIterator {
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 9b05e195722..279b84362a6 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -21,7 +21,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
         AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
 };
 use ascii::{AsciiChar, AsciiStr, AsciiString};
@@ -282,7 +282,7 @@ impl PyPayload for PyStrIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyStrIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -307,8 +307,6 @@ impl PyStrIterator {
     }
 }
 
-impl Unconstructible for PyStrIterator {}
-
 impl SelfIter for PyStrIterator {}
 
 impl IterNext for PyStrIterator {
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index fada8840bb1..adc5b483de3 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -16,7 +16,7 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
         AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
@@ -533,7 +533,7 @@ impl PyPayload for PyTupleIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyTupleIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -554,7 +554,6 @@ impl PyTupleIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyTupleIterator {}
 
 impl SelfIter for PyTupleIterator {}
 impl IterNext for PyTupleIterator {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 0f619b1399a..d014cdf015e 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -191,13 +191,16 @@ impl PyType {
         name: &str,
         bases: Vec<PyRef<Self>>,
         attrs: PyAttributes,
-        slots: PyTypeSlots,
+        mut slots: PyTypeSlots,
         metaclass: PyRef<Self>,
         ctx: &Context,
     ) -> Result<PyRef<Self>, String> {
         // TODO: ensure clean slot name
         // assert_eq!(slots.name.borrow(), "");
 
+        // Set HEAPTYPE flag for heap-allocated types
+        slots.flags |= PyTypeFlags::HEAPTYPE;
+
         let name = ctx.new_str(name);
         let heaptype_ext = HeapTypeExt {
             name: PyRwLock::new(name.clone()),
@@ -401,6 +404,8 @@ impl PyType {
             None,
         );
 
+        Self::set_new(&new_type.slots, &new_type.base);
+
         let weakref_type = super::PyWeak::static_type();
         for base in new_type.bases.read().iter() {
             base.subclasses.write().push(
@@ -420,9 +425,6 @@ impl PyType {
 
         for cls in self.mro.read().iter() {
             for &name in cls.attributes.read().keys() {
-                if name == identifier!(ctx, __new__) {
-                    continue;
-                }
                 if name.as_bytes().starts_with(b"__") && name.as_bytes().ends_with(b"__") {
                     slot_name_set.insert(name);
                 }
@@ -436,6 +438,20 @@ impl PyType {
         for attr_name in slot_name_set {
             self.update_slot::<true>(attr_name, ctx);
         }
+
+        Self::set_new(&self.slots, &self.base);
+    }
+
+    fn set_new(slots: &PyTypeSlots, base: &Option<PyTypeRef>) {
+        if slots.flags.contains(PyTypeFlags::DISALLOW_INSTANTIATION) {
+            slots.new.store(None)
+        } else if slots.new.load().is_none() {
+            slots.new.store(
+                base.as_ref()
+                    .map(|base| base.slots.new.load())
+                    .unwrap_or(None),
+            )
+        }
     }
 
     // This is used for class initialization where the vm is not yet available.
@@ -1563,15 +1579,28 @@ impl Callable for PyType {
     type Args = FuncArgs;
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         vm_trace!("type_call: {:?}", zelf);
-        let obj = call_slot_new(zelf.to_owned(), zelf.to_owned(), args.clone(), vm)?;
 
-        if (zelf.is(vm.ctx.types.type_type) && args.kwargs.is_empty()) || !obj.fast_isinstance(zelf)
-        {
+        if zelf.is(vm.ctx.types.type_type) {
+            let num_args = args.args.len();
+            if num_args == 1 && args.kwargs.is_empty() {
+                return Ok(args.args[0].obj_type());
+            }
+            if num_args != 3 {
+                return Err(vm.new_type_error("type() takes 1 or 3 arguments".to_owned()));
+            }
+        }
+
+        let obj = if let Some(slot_new) = zelf.slots.new.load() {
+            slot_new(zelf.to_owned(), args.clone(), vm)?
+        } else {
+            return Err(vm.new_type_error(format!("cannot create '{}' instances", zelf.slots.name)));
+        };
+
+        if !obj.class().fast_issubclass(zelf) {
             return Ok(obj);
         }
 
-        let init = obj.class().mro_find_map(|cls| cls.slots.init.load());
-        if let Some(init_method) = init {
+        if let Some(init_method) = obj.class().slots.init.load() {
             init_method(obj.clone(), args, vm)?;
         }
         Ok(obj)
@@ -1700,6 +1729,40 @@ pub(crate) fn call_slot_new(
     args: FuncArgs,
     vm: &VirtualMachine,
 ) -> PyResult {
+    // Check DISALLOW_INSTANTIATION flag on subtype (the type being instantiated)
+    if subtype
+        .slots
+        .flags
+        .has_feature(PyTypeFlags::DISALLOW_INSTANTIATION)
+    {
+        return Err(vm.new_type_error(format!("cannot create '{}' instances", subtype.slot_name())));
+    }
+
+    // "is not safe" check (tp_new_wrapper logic)
+    // Check that the user doesn't do something silly and unsafe like
+    // object.__new__(dict). To do this, we check that the most derived base
+    // that's not a heap type is this type.
+    let mut staticbase = subtype.clone();
+    while staticbase.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
+        if let Some(base) = staticbase.base.as_ref() {
+            staticbase = base.clone();
+        } else {
+            break;
+        }
+    }
+
+    // Check if staticbase's tp_new differs from typ's tp_new
+    let typ_new = typ.slots.new.load();
+    let staticbase_new = staticbase.slots.new.load();
+    if typ_new.map(|f| f as usize) != staticbase_new.map(|f| f as usize) {
+        return Err(vm.new_type_error(format!(
+            "{}.__new__({}) is not safe, use {}.__new__()",
+            typ.slot_name(),
+            subtype.slot_name(),
+            staticbase.slot_name()
+        )));
+    }
+
     let slot_new = typ
         .deref()
         .mro_find_map(|cls| cls.slots.new.load())
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 6b5a02dea73..6a366385702 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -116,13 +116,23 @@ pub trait PyClassImpl: PyClassDef {
             );
         }
 
-        if class.slots.new.load().is_some() {
-            let bound_new = Context::genesis().slot_new_wrapper.build_bound_method(
-                ctx,
-                class.to_owned().into(),
-                class,
-            );
-            class.set_attr(identifier!(ctx, __new__), bound_new.into());
+        // Don't add __new__ attribute if slot_new is inherited from object
+        // (Python doesn't add __new__ to __dict__ for inherited slots)
+        // Exception: object itself should have __new__ in its dict
+        if let Some(slot_new) = class.slots.new.load() {
+            let object_new = ctx.types.object_type.slots.new.load();
+            let is_object_itself = std::ptr::eq(class, ctx.types.object_type);
+            let is_inherited_from_object = !is_object_itself
+                && object_new.is_some_and(|obj_new| slot_new as usize == obj_new as usize);
+
+            if !is_inherited_from_object {
+                let bound_new = Context::genesis().slot_new_wrapper.build_bound_method(
+                    ctx,
+                    class.to_owned().into(),
+                    class,
+                );
+                class.set_attr(identifier!(ctx, __new__), bound_new.into());
+            }
         }
 
         if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
index 1b1a4a14df5..1dafda203d9 100644
--- a/crates/vm/src/protocol/buffer.rs
+++ b/crates/vm/src/protocol/buffer.rs
@@ -9,7 +9,6 @@ use crate::{
     },
     object::PyObjectPayload,
     sliceable::SequenceIndexOp,
-    types::Unconstructible,
 };
 use itertools::Itertools;
 use std::{borrow::Cow, fmt::Debug, ops::Range};
@@ -402,7 +401,7 @@ pub struct VecBuffer {
     data: PyMutex<Vec<u8>>,
 }
 
-#[pyclass(flags(BASETYPE), with(Unconstructible))]
+#[pyclass(flags(BASETYPE, DISALLOW_INSTANTIATION))]
 impl VecBuffer {
     pub fn take(&self) -> Vec<u8> {
         std::mem::take(&mut self.data.lock())
@@ -417,8 +416,6 @@ impl From<Vec<u8>> for VecBuffer {
     }
 }
 
-impl Unconstructible for VecBuffer {}
-
 impl PyRef<VecBuffer> {
     pub fn into_pybuffer(self, readonly: bool) -> PyBuffer {
         let len = self.data.lock().len();
diff --git a/crates/vm/src/stdlib/ctypes/field.rs b/crates/vm/src/stdlib/ctypes/field.rs
index e760f07d035..659255f3329 100644
--- a/crates/vm/src/stdlib/ctypes/field.rs
+++ b/crates/vm/src/stdlib/ctypes/field.rs
@@ -1,6 +1,6 @@
 use crate::builtins::PyType;
 use crate::function::PySetterValue;
-use crate::types::{GetDescriptor, Representable, Unconstructible};
+use crate::types::{GetDescriptor, Representable};
 use crate::{AsObject, Py, PyObjectRef, PyResult, VirtualMachine};
 use num_traits::ToPrimitive;
 
@@ -85,8 +85,6 @@ impl Representable for PyCField {
     }
 }
 
-impl Unconstructible for PyCField {}
-
 impl GetDescriptor for PyCField {
     fn descr_get(
         zelf: PyObjectRef,
@@ -184,7 +182,7 @@ impl PyCField {
 
 #[pyclass(
     flags(DISALLOW_INSTANTIATION, IMMUTABLETYPE),
-    with(Unconstructible, Representable, GetDescriptor)
+    with(Representable, GetDescriptor)
 )]
 impl PyCField {
     #[pyslot]
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index a698cae059c..868fc727c65 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -167,7 +167,7 @@ pub(super) mod _os {
         ospath::{OsPath, OsPathOrFd, OutputMode},
         protocol::PyIterReturn,
         recursion::ReprGuard,
-        types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter, Unconstructible},
+        types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter},
         utils::ToCString,
         vm::VirtualMachine,
     };
@@ -570,7 +570,7 @@ pub(super) mod _os {
         ino: AtomicCell<Option<u64>>,
     }
 
-    #[pyclass(with(Representable, Unconstructible))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(Representable))]
     impl DirEntry {
         #[pygetset]
         fn name(&self, vm: &VirtualMachine) -> PyResult {
@@ -760,8 +760,6 @@ pub(super) mod _os {
             }
         }
     }
-    impl Unconstructible for DirEntry {}
-
     #[pyattr]
     #[pyclass(name = "ScandirIter")]
     #[derive(Debug, PyPayload)]
@@ -770,7 +768,7 @@ pub(super) mod _os {
         mode: OutputMode,
     }
 
-    #[pyclass(with(IterNext, Iterable, Unconstructible))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
     impl ScandirIterator {
         #[pymethod]
         fn close(&self) {
@@ -788,7 +786,6 @@ pub(super) mod _os {
             zelf.close()
         }
     }
-    impl Unconstructible for ScandirIterator {}
     impl SelfIter for ScandirIterator {}
     impl IterNext for ScandirIterator {
         fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index f52e7296a7b..5deb593818e 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -922,15 +922,6 @@ pub trait DefaultConstructor: PyPayload + Default + std::fmt::Debug {
     }
 }
 
-/// For types that cannot be instantiated through Python code.
-#[pyclass]
-pub trait Unconstructible: PyPayload {
-    #[pyslot]
-    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_type_error(format!("cannot create '{}' instances", cls.slot_name())))
-    }
-}
-
 impl<T> Constructor for T
 where
     T: DefaultConstructor,

From 9aa1f189982ff561478f30315c19c47b9c9d9cde Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 17 Dec 2025 00:16:51 +0900
Subject: [PATCH 004/418] Unraiseable traceback (#6449)

---
 crates/vm/src/stdlib/sys.rs | 50 ++++++++++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 9 deletions(-)

diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 45b1d566058..52ecf927d5c 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -15,7 +15,7 @@ mod sys {
         },
         convert::ToPyObject,
         frame::FrameRef,
-        function::{FuncArgs, OptionalArg, PosArgs},
+        function::{FuncArgs, KwArgs, OptionalArg, PosArgs},
         stdlib::{builtins, warnings::warn},
         types::PyStructSequence,
         version,
@@ -688,13 +688,21 @@ mod sys {
             writeln!(stderr, "{}:", unraisable.err_msg.str(vm)?);
         }
 
-        // TODO: print received unraisable.exc_traceback
-        let tb_module = vm.import("traceback", 0)?;
-        let print_stack = tb_module.get_attr("print_stack", vm)?;
-        print_stack.call((), vm)?;
+        // Print traceback (using actual exc_traceback, not current stack)
+        if !vm.is_none(&unraisable.exc_traceback) {
+            let tb_module = vm.import("traceback", 0)?;
+            let print_tb = tb_module.get_attr("print_tb", vm)?;
+            let stderr_obj = super::get_stderr(vm)?;
+            let kwargs: KwArgs = [("file".to_string(), stderr_obj)].into_iter().collect();
+            let _ = print_tb.call(
+                FuncArgs::new(vec![unraisable.exc_traceback.clone()], kwargs),
+                vm,
+            );
+        }
 
+        // Check exc_type
         if vm.is_none(unraisable.exc_type.as_object()) {
-            // TODO: early return, but with what error?
+            return Ok(());
         }
         assert!(
             unraisable
@@ -702,10 +710,28 @@ mod sys {
                 .fast_issubclass(vm.ctx.exceptions.base_exception_type)
         );
 
-        // TODO: print module name and qualname
+        // Print module name (if not builtins or __main__)
+        let module_name = unraisable.exc_type.__module__(vm);
+        if let Ok(module_str) = module_name.downcast::<PyStr>() {
+            let module = module_str.as_str();
+            if module != "builtins" && module != "__main__" {
+                write!(stderr, "{}.", module);
+            }
+        } else {
+            write!(stderr, "<unknown>.");
+        }
 
+        // Print qualname
+        let qualname = unraisable.exc_type.__qualname__(vm);
+        if let Ok(qualname_str) = qualname.downcast::<PyStr>() {
+            write!(stderr, "{}", qualname_str.as_str());
+        } else {
+            write!(stderr, "{}", unraisable.exc_type.name());
+        }
+
+        // Print exception value
         if !vm.is_none(&unraisable.exc_value) {
-            write!(stderr, "{}: ", unraisable.exc_type);
+            write!(stderr, ": ");
             if let Ok(str) = unraisable.exc_value.str(vm) {
                 write!(stderr, "{}", str.to_str().unwrap_or("<str with surrogate>"));
             } else {
@@ -713,7 +739,13 @@ mod sys {
             }
         }
         writeln!(stderr);
-        // TODO: call file.flush()
+
+        // Flush stderr
+        if let Ok(stderr_obj) = super::get_stderr(vm)
+            && let Ok(flush) = stderr_obj.get_attr("flush", vm)
+        {
+            let _ = flush.call((), vm);
+        }
 
         Ok(())
     }

From adc2b0dbbe043095be17c037e3daa39b5351c96c Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 16 Dec 2025 16:28:06 +0100
Subject: [PATCH 005/418] Update `test_zipfile64.py` from 3.13.11 (#6433)

* Update `test_zipfile64.py` from 3.13.11

* Mark flaky test
---
 Lib/test/test_import/__init__.py |  1 +
 Lib/test/test_zipfile64.py       | 13 +++++--------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 44e7da1033d..85913cd7c58 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -457,6 +457,7 @@ def test_issue31492(self):
             with self.assertRaises(AttributeError):
                 os.does_not_exist
 
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Flaky')
     @threading_helper.requires_working_threading()
     def test_concurrency(self):
         # bpo 38091: this is a hack to slow down the code that calls
diff --git a/Lib/test/test_zipfile64.py b/Lib/test/test_zipfile64.py
index 0947013afbc..2e1affe0252 100644
--- a/Lib/test/test_zipfile64.py
+++ b/Lib/test/test_zipfile64.py
@@ -11,7 +11,7 @@
         'test requires loads of disk-space bytes and a long time to run'
     )
 
-import zipfile, os, unittest
+import zipfile, unittest
 import time
 import sys
 
@@ -32,10 +32,6 @@ def setUp(self):
         line_gen = ("Test of zipfile line %d." % i for i in range(1000000))
         self.data = '\n'.join(line_gen).encode('ascii')
 
-        # And write it to a file.
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-
     def zipTest(self, f, compression):
         # Create the ZIP archive.
         with zipfile.ZipFile(f, "w", compression) as zipfp:
@@ -67,6 +63,9 @@ def zipTest(self, f, compression):
                     (num, filecount)), file=sys.__stdout__)
                     sys.__stdout__.flush()
 
+            # Check that testzip thinks the archive is valid
+            self.assertIsNone(zipfp.testzip())
+
     def testStored(self):
         # Try the temp file first.  If we do TESTFN2 first, then it hogs
         # gigabytes of disk space for the duration of the test.
@@ -85,9 +84,7 @@ def testDeflated(self):
         self.zipTest(TESTFN2, zipfile.ZIP_DEFLATED)
 
     def tearDown(self):
-        for fname in TESTFN, TESTFN2:
-            if os.path.exists(fname):
-                os.remove(fname)
+        os_helper.unlink(TESTFN2)
 
 
 class OtherTests(unittest.TestCase):

From f3916950bf823f398b25cf554f0485787a2a84be Mon Sep 17 00:00:00 2001
From: ShaharNaveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Tue, 16 Dec 2025 21:35:55 +0100
Subject: [PATCH 006/418] Skip flakey test

---
 Lib/test/test_subprocess.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 6b20a5c00a5..e04f8b8fcc4 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -1770,8 +1770,7 @@ def test_run_with_pathlike_path_and_arguments(self):
         res = subprocess.run(args)
         self.assertEqual(res.returncode, 57)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(mswindows, 'TODO: RUSTPYTHON; Flakey')
     @unittest.skipUnless(mswindows, "Maybe test trigger a leak on Ubuntu")
     def test_run_with_an_empty_env(self):
         # gh-105436: fix subprocess.run(..., env={}) broken on Windows

From be559ae4530f85c9101f166fd702646353f7f064 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 17 Dec 2025 00:15:25 +0100
Subject: [PATCH 007/418] Update `support/import_helper.py` from 3.13.11
 (#6451)

* Update `support/import_helper.py` from 3.13.11

* Unmark passing test
---
 Lib/test/support/import_helper.py | 43 ++++++++++++++++++++++++++++---
 Lib/test/test_super.py            |  1 -
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index 67f18e530ed..2b91bdcf9cd 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -8,7 +8,7 @@
 import unittest
 import warnings
 
-from .os_helper import unlink
+from .os_helper import unlink, temp_dir
 
 
 @contextlib.contextmanager
@@ -58,8 +58,8 @@ def make_legacy_pyc(source):
     :return: The file system path to the legacy pyc file.
     """
     pyc_file = importlib.util.cache_from_source(source)
-    up_one = os.path.dirname(os.path.abspath(source))
-    legacy_pyc = os.path.join(up_one, source + 'c')
+    assert source.endswith('.py')
+    legacy_pyc = source + 'c'
     shutil.move(pyc_file, legacy_pyc)
     return legacy_pyc
 
@@ -114,7 +114,7 @@ def multi_interp_extensions_check(enabled=True):
     This only applies to modules that haven't been imported yet.
     It overrides the PyInterpreterConfig.check_multi_interp_extensions
     setting (see support.run_in_subinterp_with_config() and
-    _xxsubinterpreters.create()).
+    _interpreters.create()).
 
     Also see importlib.utils.allowing_all_extensions().
     """
@@ -268,9 +268,44 @@ def modules_cleanup(oldmodules):
     sys.modules.update(oldmodules)
 
 
+@contextlib.contextmanager
+def isolated_modules():
+    """
+    Save modules on entry and cleanup on exit.
+    """
+    (saved,) = modules_setup()
+    try:
+        yield
+    finally:
+        modules_cleanup(saved)
+
+
 def mock_register_at_fork(func):
     # bpo-30599: Mock os.register_at_fork() when importing the random module,
     # since this function doesn't allow to unregister callbacks and would leak
     # memory.
     from unittest import mock
     return mock.patch('os.register_at_fork', create=True)(func)
+
+
+@contextlib.contextmanager
+def ready_to_import(name=None, source=""):
+    from test.support import script_helper
+
+    # 1. Sets up a temporary directory and removes it afterwards
+    # 2. Creates the module file
+    # 3. Temporarily clears the module from sys.modules (if any)
+    # 4. Reverts or removes the module when cleaning up
+    name = name or "spam"
+    with temp_dir() as tempdir:
+        path = script_helper.make_script(tempdir, name, source)
+        old_module = sys.modules.pop(name, None)
+        try:
+            sys.path.insert(0, tempdir)
+            yield name, path
+            sys.path.remove(tempdir)
+        finally:
+            if old_module is not None:
+                sys.modules[name] = old_module
+            else:
+                sys.modules.pop(name, None)
diff --git a/Lib/test/test_super.py b/Lib/test/test_super.py
index 8967dab8bdd..76eda799da4 100644
--- a/Lib/test/test_super.py
+++ b/Lib/test/test_super.py
@@ -349,7 +349,6 @@ def test_super_argtype(self):
         with self.assertRaisesRegex(TypeError, "argument 1 must be a type"):
             super(1, int)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'test.support.import_helper' has no attribute 'ready_to_import'
     def test_shadowed_global(self):
         source = textwrap.dedent(
             """

From 9d2dd1745565547d3fcaf0b792612a48192c02de Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 17 Dec 2025 11:02:44 +0100
Subject: [PATCH 008/418] Add regression test (#6452)

---
 extra_tests/snippets/builtin_bytes.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/extra_tests/snippets/builtin_bytes.py b/extra_tests/snippets/builtin_bytes.py
index 9347fbc8fab..4cb743baa6f 100644
--- a/extra_tests/snippets/builtin_bytes.py
+++ b/extra_tests/snippets/builtin_bytes.py
@@ -1,3 +1,5 @@
+import sys
+
 from testutils import assert_raises, skip_if_unsupported
 
 # new
@@ -611,6 +613,9 @@
 assert b"\xc2\xae\x75\x73\x74".decode() == "®ust"
 assert b"\xe4\xb8\xad\xe6\x96\x87\xe5\xad\x97".decode("utf-8") == "中文字"
 
+# gh-2391
+assert b"-\xff".decode(sys.getfilesystemencoding(), "surrogateescape") == "-\udcff"
+
 # mod
 assert b"rust%bpython%b" % (b" ", b"!") == b"rust python!"
 assert b"x=%i y=%f" % (1, 2.5) == b"x=1 y=2.500000"

From 0412dfdb3b4b64aeacf82822352ae6c93580688c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 17 Dec 2025 20:57:34 +0900
Subject: [PATCH 009/418] Fix winerror handling (#6454)

---
 crates/vm/src/exceptions.rs | 122 +++++++++++++++++++++++++-----------
 crates/vm/src/stdlib/io.rs  |  11 ++--
 2 files changed, 94 insertions(+), 39 deletions(-)

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 2b725085bec..2958d1e497e 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -1677,7 +1677,7 @@ pub(super) mod types {
             // SAFETY: slot_init is called during object initialization,
             // so fields are None and swap result can be safely ignored
             if len <= 5 {
-                // Only set errno/strerror when args len is 2-5 (CPython behavior)
+                // Only set errno/strerror when args len is 2-5
                 if 2 <= len {
                     let _ = unsafe { exc.errno.swap(Some(new_args.args[0].clone())) };
                     let _ = unsafe { exc.strerror.swap(Some(new_args.args[1].clone())) };
@@ -1708,8 +1708,10 @@ pub(super) mod types {
                 }
             }
 
-            // args are truncated to 2 for compatibility (only when 2-5 args)
-            if (3..=5).contains(&len) {
+            // args are truncated to 2 for compatibility (only when 2-5 args and filename is not None)
+            // truncation happens inside "if (filename && filename != Py_None)" block
+            let has_filename = exc.filename.to_owned().filter(|f| !vm.is_none(f)).is_some();
+            if (3..=5).contains(&len) && has_filename {
                 new_args.args.truncate(2);
             }
             PyBaseException::slot_init(zelf, new_args, vm)
@@ -1717,44 +1719,94 @@ pub(super) mod types {
 
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            let args = exc.args();
             let obj = exc.as_object().to_owned();
 
-            let str = if args.len() == 2 {
-                // SAFETY: len() == 2 is checked so get_arg 1 or 2 won't panic
-                let errno = exc.get_arg(0).unwrap().str(vm)?;
-                let msg = exc.get_arg(1).unwrap().str(vm)?;
-
-                // On Windows, use [WinError X] format when winerror is set
-                #[cfg(windows)]
-                let (label, code) = match obj.get_attr("winerror", vm) {
-                    Ok(winerror) if !vm.is_none(&winerror) => ("WinError", winerror.str(vm)?),
-                    _ => ("Errno", errno.clone()),
-                };
-                #[cfg(not(windows))]
-                let (label, code) = ("Errno", errno.clone());
+            // Get OSError fields directly
+            let errno_field = obj.get_attr("errno", vm).ok().filter(|v| !vm.is_none(v));
+            let strerror = obj.get_attr("strerror", vm).ok().filter(|v| !vm.is_none(v));
+            let filename = obj.get_attr("filename", vm).ok().filter(|v| !vm.is_none(v));
+            let filename2 = obj
+                .get_attr("filename2", vm)
+                .ok()
+                .filter(|v| !vm.is_none(v));
+            #[cfg(windows)]
+            let winerror = obj.get_attr("winerror", vm).ok().filter(|v| !vm.is_none(v));
 
-                let s = match obj.get_attr("filename", vm) {
-                    Ok(filename) if !vm.is_none(&filename) => match obj.get_attr("filename2", vm) {
-                        Ok(filename2) if !vm.is_none(&filename2) => format!(
-                            "[{} {}] {}: '{}' -> '{}'",
-                            label,
+            // Windows: winerror takes priority over errno
+            #[cfg(windows)]
+            if let Some(ref win_err) = winerror {
+                let code = win_err.str(vm)?;
+                if let Some(ref f) = filename {
+                    let msg = strerror
+                        .as_ref()
+                        .map(|s| s.str(vm))
+                        .transpose()?
+                        .map(|s| s.to_string())
+                        .unwrap_or_else(|| "None".to_owned());
+                    if let Some(ref f2) = filename2 {
+                        return Ok(vm.ctx.new_str(format!(
+                            "[WinError {}] {}: {} -> {}",
                             code,
                             msg,
-                            filename.str(vm)?,
-                            filename2.str(vm)?
-                        ),
-                        _ => format!("[{} {}] {}: '{}'", label, code, msg, filename.str(vm)?),
-                    },
-                    _ => {
-                        format!("[{label} {code}] {msg}")
+                            f.repr(vm)?,
+                            f2.repr(vm)?
+                        )));
                     }
-                };
-                vm.ctx.new_str(s)
-            } else {
-                exc.__str__(vm)
-            };
-            Ok(str)
+                    return Ok(vm.ctx.new_str(format!(
+                        "[WinError {}] {}: {}",
+                        code,
+                        msg,
+                        f.repr(vm)?
+                    )));
+                }
+                // winerror && strerror (no filename)
+                if let Some(ref s) = strerror {
+                    return Ok(vm
+                        .ctx
+                        .new_str(format!("[WinError {}] {}", code, s.str(vm)?)));
+                }
+            }
+
+            // Non-Windows or fallback: use errno
+            if let Some(ref f) = filename {
+                let errno_str = errno_field
+                    .as_ref()
+                    .map(|e| e.str(vm))
+                    .transpose()?
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| "None".to_owned());
+                let msg = strerror
+                    .as_ref()
+                    .map(|s| s.str(vm))
+                    .transpose()?
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| "None".to_owned());
+                if let Some(ref f2) = filename2 {
+                    return Ok(vm.ctx.new_str(format!(
+                        "[Errno {}] {}: {} -> {}",
+                        errno_str,
+                        msg,
+                        f.repr(vm)?,
+                        f2.repr(vm)?
+                    )));
+                }
+                return Ok(vm.ctx.new_str(format!(
+                    "[Errno {}] {}: {}",
+                    errno_str,
+                    msg,
+                    f.repr(vm)?
+                )));
+            }
+
+            // errno && strerror (no filename)
+            if let (Some(e), Some(s)) = (&errno_field, &strerror) {
+                return Ok(vm
+                    .ctx
+                    .new_str(format!("[Errno {}] {}", e.str(vm)?, s.str(vm)?)));
+            }
+
+            // fallback to BaseException.__str__
+            Ok(exc.__str__(vm))
         }
 
         #[pymethod]
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 56bcbefddeb..547e482f13a 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -1084,10 +1084,13 @@ mod _io {
                             self.write_end = buffer_size;
                             // TODO: BlockingIOError(errno, msg, written)
                             // written += self.buffer.len();
-                            return Err(vm.new_exception_msg(
-                                vm.ctx.exceptions.blocking_io_error.to_owned(),
-                                "write could not complete without blocking".to_owned(),
-                            ));
+                            return Err(vm
+                                .new_os_subtype_error(
+                                    vm.ctx.exceptions.blocking_io_error.to_owned(),
+                                    None,
+                                    "write could not complete without blocking".to_owned(),
+                                )
+                                .upcast());
                         } else {
                             break;
                         }

From a4c93dfbbfed868e3fe896463a39d401079a3160 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 17 Dec 2025 20:58:00 +0900
Subject: [PATCH 010/418] Remove useless &PyRef patterns (#6455)

* fix &PyTypeRef

* Remove useless &PyObjectRef

* Remove useless &PyRef
---
 crates/stdlib/src/csv.rs                 | 18 ++++----
 crates/stdlib/src/openssl.rs             |  5 ++-
 crates/stdlib/src/scproxy.rs             |  6 +--
 crates/stdlib/src/ssl.rs                 | 14 +++----
 crates/stdlib/src/ssl/compat.rs          |  8 ++--
 crates/vm/src/builtins/builtin_func.rs   |  4 +-
 crates/vm/src/builtins/dict.rs           | 10 ++---
 crates/vm/src/builtins/function/jit.rs   |  6 ++-
 crates/vm/src/builtins/genericalias.rs   |  6 +--
 crates/vm/src/builtins/list.rs           |  4 +-
 crates/vm/src/builtins/property.rs       |  6 +--
 crates/vm/src/builtins/type.rs           |  4 +-
 crates/vm/src/builtins/union.rs          |  2 +-
 crates/vm/src/cformat.rs                 | 16 +++++---
 crates/vm/src/codecs.rs                  |  2 +-
 crates/vm/src/coroutine.rs               |  5 ++-
 crates/vm/src/exception_group.rs         | 14 +++----
 crates/vm/src/exceptions.rs              | 14 +++----
 crates/vm/src/frame.rs                   |  4 +-
 crates/vm/src/import.rs                  |  7 ++--
 crates/vm/src/object/payload.rs          |  4 +-
 crates/vm/src/scope.rs                   |  2 +-
 crates/vm/src/sequence.rs                |  4 +-
 crates/vm/src/stdlib/builtins.rs         |  4 +-
 crates/vm/src/stdlib/collections.rs      |  4 +-
 crates/vm/src/stdlib/ctypes.rs           |  4 +-
 crates/vm/src/stdlib/ctypes/base.rs      | 52 ++++++++++++------------
 crates/vm/src/stdlib/ctypes/field.rs     |  4 +-
 crates/vm/src/stdlib/ctypes/structure.rs |  6 +--
 crates/vm/src/stdlib/ctypes/union.rs     |  4 +-
 crates/vm/src/stdlib/typevar.rs          |  8 ++--
 crates/vm/src/suggestion.rs              |  8 ++--
 crates/vm/src/vm/context.rs              |  6 +--
 crates/vm/src/vm/mod.rs                  |  5 ++-
 crates/vm/src/warn.rs                    |  4 +-
 crates/wasm/src/convert.rs               |  6 +--
 crates/wasm/src/js_module.rs             |  3 +-
 37 files changed, 146 insertions(+), 137 deletions(-)

diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
index 792402e0580..a62594a9f1b 100644
--- a/crates/stdlib/src/csv.rs
+++ b/crates/stdlib/src/csv.rs
@@ -4,7 +4,8 @@ pub(crate) use _csv::make_module;
 mod _csv {
     use crate::common::lock::PyMutex;
     use crate::vm::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+        AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+        VirtualMachine,
         builtins::{PyBaseExceptionRef, PyInt, PyNone, PyStr, PyType, PyTypeRef},
         function::{ArgIterable, ArgumentError, FromArgs, FuncArgs, OptionalArg},
         protocol::{PyIter, PyIterReturn},
@@ -130,11 +131,11 @@ mod _csv {
     ///
     /// * If the 'delimiter' attribute is not a single-character string, a type error is returned.
     /// * If the 'obj' is not of string type and does not have a 'delimiter' attribute, a type error is returned.
-    fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<u8> {
+    fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<u8> {
         if let Ok(attr) = obj.get_attr("delimiter", vm) {
             parse_delimiter_from_obj(vm, &attr)
         } else {
-            match_class!(match obj.clone() {
+            match_class!(match obj.to_owned() {
                 s @ PyStr => {
                     Ok(s.as_str().bytes().exactly_one().map_err(|_| {
                         let msg = r#""delimiter" must be a 1-character string"#;
@@ -148,7 +149,7 @@ mod _csv {
             })
         }
     }
-    fn parse_quotechar_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<u8>> {
+    fn parse_quotechar_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Option<u8>> {
         match_class!(match obj.get_attr("quotechar", vm)? {
             s @ PyStr => {
                 Ok(Some(s.as_str().bytes().exactly_one().map_err(|_| {
@@ -169,7 +170,7 @@ mod _csv {
             }
         })
     }
-    fn parse_escapechar_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<u8>> {
+    fn parse_escapechar_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Option<u8>> {
         match_class!(match obj.get_attr("escapechar", vm)? {
             s @ PyStr => {
                 Ok(Some(s.as_str().bytes().exactly_one().map_err(|_| {
@@ -191,10 +192,7 @@ mod _csv {
             }
         })
     }
-    fn prase_lineterminator_from_obj(
-        vm: &VirtualMachine,
-        obj: &PyObjectRef,
-    ) -> PyResult<Terminator> {
+    fn prase_lineterminator_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Terminator> {
         match_class!(match obj.get_attr("lineterminator", vm)? {
             s @ PyStr => {
                 Ok(if s.as_bytes().eq(b"\r\n") {
@@ -217,7 +215,7 @@ mod _csv {
             }
         })
     }
-    fn prase_quoting_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<QuoteStyle> {
+    fn prase_quoting_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<QuoteStyle> {
         match_class!(match obj.get_attr("quoting", vm)? {
             i @ PyInt => {
                 Ok(i.try_to_primitive::<isize>(vm)?.try_into().map_err(|_| {
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index ea67d605f76..bf03813b180 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -56,7 +56,8 @@ mod _ssl {
         vm::{
             AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
             builtins::{
-                PyBaseExceptionRef, PyBytesRef, PyListRef, PyOSError, PyStrRef, PyTypeRef, PyWeak,
+                PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyOSError, PyStrRef,
+                PyTypeRef, PyWeak,
             },
             class_or_notimplemented,
             convert::ToPyException,
@@ -3351,7 +3352,7 @@ mod _ssl {
 
     // Helper function to set verify_code and verify_message on SSLCertVerificationError
     fn set_verify_error_info(
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
         ssl_ptr: *const sys::SSL,
         vm: &VirtualMachine,
     ) {
diff --git a/crates/stdlib/src/scproxy.rs b/crates/stdlib/src/scproxy.rs
index f49b6890a69..1974e7814ae 100644
--- a/crates/stdlib/src/scproxy.rs
+++ b/crates/stdlib/src/scproxy.rs
@@ -5,8 +5,8 @@ mod _scproxy {
     // straight-forward port of Modules/_scproxy.c
 
     use crate::vm::{
-        PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStr},
+        Py, PyResult, VirtualMachine,
+        builtins::{PyDict, PyDictRef, PyStr},
         convert::ToPyObject,
     };
     use system_configuration::core_foundation::{
@@ -74,7 +74,7 @@ mod _scproxy {
 
         let result = vm.ctx.new_dict();
 
-        let set_proxy = |result: &PyDictRef,
+        let set_proxy = |result: &Py<PyDict>,
                          proto: &str,
                          enabled_key: CFStringRef,
                          host_key: CFStringRef,
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index c23062d639d..e6f8c5fda7c 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -1423,7 +1423,7 @@ mod _ssl {
 
         /// Helper: Get path from Python's os.environ
         fn get_env_path(
-            environ: &PyObjectRef,
+            environ: &PyObject,
             var_name: &str,
             vm: &VirtualMachine,
         ) -> PyResult<String> {
@@ -2101,10 +2101,10 @@ mod _ssl {
         // Helper functions (private):
 
         /// Parse path argument (str or bytes) to string
-        fn parse_path_arg(arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
-            if let Ok(s) = PyStrRef::try_from_object(vm, arg.clone()) {
+        fn parse_path_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
+            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
                 Ok(s.as_str().to_owned())
-            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.clone()) {
+            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
                 String::from_utf8(b.borrow_buf().to_vec())
                     .map_err(|_| vm.new_value_error("path contains invalid UTF-8".to_owned()))
             } else {
@@ -2279,10 +2279,10 @@ mod _ssl {
         }
 
         /// Helper: Parse cadata argument (str or bytes)
-        fn parse_cadata_arg(&self, arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-            if let Ok(s) = PyStrRef::try_from_object(vm, arg.clone()) {
+        fn parse_cadata_arg(&self, arg: &PyObject, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
                 Ok(s.as_str().as_bytes().to_vec())
-            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.clone()) {
+            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
                 Ok(b.borrow_buf().to_vec())
             } else {
                 Err(vm.new_type_error("cadata should be a str or bytes".to_owned()))
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 798542f210a..4ccc590360a 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -23,10 +23,10 @@ use rustls::server::ResolvesServerCert;
 use rustls::server::ServerConfig;
 use rustls::server::ServerConnection;
 use rustls::sign::CertifiedKey;
-use rustpython_vm::builtins::PyBaseExceptionRef;
+use rustpython_vm::builtins::{PyBaseException, PyBaseExceptionRef};
 use rustpython_vm::convert::IntoPyException;
 use rustpython_vm::function::ArgBytesLike;
-use rustpython_vm::{AsObject, PyObjectRef, PyPayload, PyResult, TryFromObject};
+use rustpython_vm::{AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject};
 use std::io::Read;
 use std::sync::{Arc, Once};
 
@@ -984,7 +984,7 @@ pub(super) fn create_client_config(options: ClientConfigOptions) -> Result<Clien
 }
 
 /// Helper function - check if error is BlockingIOError
-pub(super) fn is_blocking_io_error(err: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
+pub(super) fn is_blocking_io_error(err: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
     err.fast_isinstance(vm.ctx.exceptions.blocking_io_error)
 }
 
@@ -1534,7 +1534,7 @@ fn ssl_read_tls_records(
 
 /// Check if an exception is a connection closed error
 /// In SSL context, these errors indicate unexpected connection termination without proper TLS shutdown
-fn is_connection_closed_error(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
+fn is_connection_closed_error(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
     use rustpython_vm::stdlib::errno::errors;
 
     // Check for ConnectionAbortedError, ConnectionResetError (Python exception types)
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
index d25188affd2..da5fd5e8075 100644
--- a/crates/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -51,11 +51,11 @@ impl PyNativeFunction {
     }
 
     // PyCFunction_GET_SELF
-    pub const fn get_self(&self) -> Option<&PyObjectRef> {
+    pub fn get_self(&self) -> Option<&PyObject> {
         if self.value.flags.contains(PyMethodFlags::STATIC) {
             return None;
         }
-        self.zelf.as_ref()
+        self.zelf.as_deref()
     }
 
     pub const fn as_func(&self) -> &'static dyn PyNativeFn {
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index b34299d4170..04915b035f8 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -753,7 +753,7 @@ impl ExactSizeIterator for DictIter<'_> {
 trait DictView: PyPayload + PyClassDef + Iterable + Representable {
     type ReverseIter: PyPayload + std::fmt::Debug;
 
-    fn dict(&self) -> &PyDictRef;
+    fn dict(&self) -> &Py<PyDict>;
     fn item(vm: &VirtualMachine, key: PyObjectRef, value: PyObjectRef) -> PyObjectRef;
 
     #[pymethod]
@@ -785,7 +785,7 @@ macro_rules! dict_view {
         impl DictView for $name {
             type ReverseIter = $reverse_iter_name;
 
-            fn dict(&self) -> &PyDictRef {
+            fn dict(&self) -> &Py<PyDict> {
                 &self.dict
             }
 
@@ -1142,7 +1142,7 @@ impl PyDictKeys {
 
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
 
@@ -1206,7 +1206,7 @@ impl PyDictItems {
     }
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
 
@@ -1269,7 +1269,7 @@ impl AsNumber for PyDictItems {
 impl PyDictValues {
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
 
diff --git a/crates/vm/src/builtins/function/jit.rs b/crates/vm/src/builtins/function/jit.rs
index 21d8c9c0abf..de0a528b734 100644
--- a/crates/vm/src/builtins/function/jit.rs
+++ b/crates/vm/src/builtins/function/jit.rs
@@ -1,6 +1,8 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyDictRef, PyFunction, PyStrInterned, bool_, float, int},
+    builtins::{
+        PyBaseExceptionRef, PyDict, PyDictRef, PyFunction, PyStrInterned, bool_, float, int,
+    },
     bytecode::CodeFlags,
     convert::ToPyObject,
     function::FuncArgs,
@@ -42,7 +44,7 @@ pub fn new_jit_error(msg: String, vm: &VirtualMachine) -> PyBaseExceptionRef {
     vm.new_exception_msg(jit_error, msg)
 }
 
-fn get_jit_arg_type(dict: &PyDictRef, name: &str, vm: &VirtualMachine) -> PyResult<JitType> {
+fn get_jit_arg_type(dict: &Py<PyDict>, name: &str, vm: &VirtualMachine) -> PyResult<JitType> {
     if let Some(value) = dict.get_item_opt(name, vm)? {
         if value.is(vm.ctx.types.int_type) {
             Ok(JitType::Int)
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index 494b580e563..8a7288980fa 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -294,11 +294,11 @@ pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupl
 }
 
 #[inline]
-fn tuple_index(vec: &[PyObjectRef], item: &PyObjectRef) -> Option<usize> {
+fn tuple_index(vec: &[PyObjectRef], item: &PyObject) -> Option<usize> {
     vec.iter().position(|element| element.is(item))
 }
 
-fn is_unpacked_typevartuple(arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+fn is_unpacked_typevartuple(arg: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     if arg.class().is(vm.ctx.types.type_type) {
         return Ok(false);
     }
@@ -312,7 +312,7 @@ fn is_unpacked_typevartuple(arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<
 
 fn subs_tvars(
     obj: PyObjectRef,
-    params: &PyTupleRef,
+    params: &Py<PyTuple>,
     arg_items: &[PyObjectRef],
     vm: &VirtualMachine,
 ) -> PyResult {
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 0683381f38a..13e8864cd1f 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -367,8 +367,8 @@ where
 impl MutObjectSequenceOp for PyList {
     type Inner = [PyObjectRef];
 
-    fn do_get(index: usize, inner: &[PyObjectRef]) -> Option<&PyObjectRef> {
-        inner.get(index)
+    fn do_get(index: usize, inner: &[PyObjectRef]) -> Option<&PyObject> {
+        inner.get(index).map(|r| r.as_ref())
     }
 
     fn do_lock(&self) -> impl std::ops::Deref<Target = [PyObjectRef]> {
diff --git a/crates/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
index 1a2e04ee8b0..41b05a60049 100644
--- a/crates/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -266,7 +266,7 @@ impl PyProperty {
     #[pygetset]
     fn __isabstractmethod__(&self, vm: &VirtualMachine) -> PyResult {
         // Helper to check if a method is abstract
-        let is_abstract = |method: &PyObjectRef| -> PyResult<bool> {
+        let is_abstract = |method: &PyObject| -> PyResult<bool> {
             match method.get_attr("__isabstractmethod__", vm) {
                 Ok(isabstract) => isabstract.try_to_bool(vm),
                 Err(_) => Ok(false),
@@ -309,7 +309,7 @@ impl PyProperty {
     #[cold]
     fn format_property_error(
         &self,
-        obj: &PyObjectRef,
+        obj: &PyObject,
         error_type: &str,
         vm: &VirtualMachine,
     ) -> PyResult<String> {
@@ -356,7 +356,7 @@ impl Initializer for PyProperty {
         let mut getter_doc = false;
 
         // Helper to get doc from getter
-        let get_getter_doc = |fget: &PyObjectRef| -> Option<PyObjectRef> {
+        let get_getter_doc = |fget: &PyObject| -> Option<PyObjectRef> {
             fget.get_attr("__doc__", vm)
                 .ok()
                 .filter(|doc| !vm.is_none(doc))
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index d014cdf015e..15743350397 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -175,12 +175,12 @@ fn is_subtype_with_mro(a_mro: &[PyTypeRef], a: &Py<PyType>, b: &Py<PyType>) -> b
 impl PyType {
     pub fn new_simple_heap(
         name: &str,
-        base: &PyTypeRef,
+        base: &Py<PyType>,
         ctx: &Context,
     ) -> Result<PyRef<Self>, String> {
         Self::new_heap(
             name,
-            vec![base.clone()],
+            vec![base.to_owned()],
             Default::default(),
             Default::default(),
             Self::static_type().to_owned(),
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index 16d2b7831cd..8310201a129 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -42,7 +42,7 @@ impl PyUnion {
 
     /// Direct access to args field, matching CPython's _Py_union_args
     #[inline]
-    pub const fn args(&self) -> &PyTupleRef {
+    pub fn args(&self) -> &Py<PyTuple> {
         &self.args
     }
 
diff --git a/crates/vm/src/cformat.rs b/crates/vm/src/cformat.rs
index 507079e7deb..efb3cb2acc9 100644
--- a/crates/vm/src/cformat.rs
+++ b/crates/vm/src/cformat.rs
@@ -6,7 +6,8 @@
 use crate::common::cformat::*;
 use crate::common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 use crate::{
-    AsObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine,
+    AsObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject,
+    VirtualMachine,
     builtins::{
         PyBaseExceptionRef, PyByteArray, PyBytes, PyFloat, PyInt, PyStr, try_f64_to_bigint, tuple,
     },
@@ -207,7 +208,7 @@ fn spec_format_string(
 
 fn try_update_quantity_from_element(
     vm: &VirtualMachine,
-    element: Option<&PyObjectRef>,
+    element: Option<&PyObject>,
 ) -> PyResult<CFormatQuantity> {
     match element {
         Some(width_obj) => {
@@ -224,7 +225,7 @@ fn try_update_quantity_from_element(
 
 fn try_conversion_flag_from_tuple(
     vm: &VirtualMachine,
-    element: Option<&PyObjectRef>,
+    element: Option<&PyObject>,
 ) -> PyResult<CConversionFlags> {
     match element {
         Some(width_obj) => {
@@ -254,8 +255,11 @@ fn try_update_quantity_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
         return Ok(());
     };
     let element = elements.next();
-    f.insert(try_conversion_flag_from_tuple(vm, element)?);
-    let quantity = try_update_quantity_from_element(vm, element)?;
+    f.insert(try_conversion_flag_from_tuple(
+        vm,
+        element.map(|v| v.as_ref()),
+    )?);
+    let quantity = try_update_quantity_from_element(vm, element.map(|v| v.as_ref()))?;
     *q = Some(quantity);
     Ok(())
 }
@@ -268,7 +272,7 @@ fn try_update_precision_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
     let Some(CFormatPrecision::Quantity(CFormatQuantity::FromValuesTuple)) = p else {
         return Ok(());
     };
-    let quantity = try_update_quantity_from_element(vm, elements.next())?;
+    let quantity = try_update_quantity_from_element(vm, elements.next().map(|v| v.as_ref()))?;
     *p = Some(CFormatPrecision::Quantity(quantity));
     Ok(())
 }
diff --git a/crates/vm/src/codecs.rs b/crates/vm/src/codecs.rs
index dac637c396d..2edb67b497b 100644
--- a/crates/vm/src/codecs.rs
+++ b/crates/vm/src/codecs.rs
@@ -52,7 +52,7 @@ impl PyCodec {
         self.0
     }
     #[inline]
-    pub const fn as_tuple(&self) -> &PyTupleRef {
+    pub fn as_tuple(&self) -> &Py<PyTuple> {
         &self.0
     }
 
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
index 4e76490ed65..ebe3107cb36 100644
--- a/crates/vm/src/coroutine.rs
+++ b/crates/vm/src/coroutine.rs
@@ -1,7 +1,8 @@
 use crate::{
-    AsObject, PyObject, PyObjectRef, PyResult, VirtualMachine,
+    AsObject, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
     builtins::{PyBaseExceptionRef, PyStrRef},
     common::lock::PyMutex,
+    exceptions::types::PyBaseException,
     frame::{ExecutionResult, FrameRef},
     protocol::PyIterReturn,
 };
@@ -207,6 +208,6 @@ impl Coro {
     }
 }
 
-pub fn is_gen_exit(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
+pub fn is_gen_exit(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
     exc.fast_isinstance(vm.ctx.exceptions.generator_exit)
 }
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index 8d033b26110..cd943ae1bd9 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -352,12 +352,12 @@ pub(super) mod types {
     }
 
     // Helper functions for ExceptionGroup
-    fn is_base_exception_group(obj: &PyObjectRef, vm: &VirtualMachine) -> bool {
+    fn is_base_exception_group(obj: &PyObject, vm: &VirtualMachine) -> bool {
         obj.fast_isinstance(vm.ctx.exceptions.base_exception_group)
     }
 
     fn get_exceptions_tuple(
-        exc: &PyRef<PyBaseException>,
+        exc: &Py<PyBaseException>,
         vm: &VirtualMachine,
     ) -> PyResult<Vec<PyObjectRef>> {
         let obj = exc
@@ -376,7 +376,7 @@ pub(super) mod types {
     }
 
     fn get_condition_matcher(
-        condition: &PyObjectRef,
+        condition: &PyObject,
         vm: &VirtualMachine,
     ) -> PyResult<ConditionMatcher> {
         // If it's a type and subclass of BaseException
@@ -409,19 +409,19 @@ pub(super) mod types {
 
         // If it's callable (but not a type)
         if condition.is_callable() && condition.downcast_ref::<PyType>().is_none() {
-            return Ok(ConditionMatcher::Callable(condition.clone()));
+            return Ok(ConditionMatcher::Callable(condition.to_owned()));
         }
 
         Err(vm.new_type_error("expected a function, exception type or tuple of exception types"))
     }
 
     impl ConditionMatcher {
-        fn check(&self, exc: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        fn check(&self, exc: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
             match self {
                 ConditionMatcher::Type(typ) => Ok(exc.fast_isinstance(typ)),
                 ConditionMatcher::Types(types) => Ok(types.iter().any(|t| exc.fast_isinstance(t))),
                 ConditionMatcher::Callable(func) => {
-                    let result = func.call((exc.clone(),), vm)?;
+                    let result = func.call((exc.to_owned(),), vm)?;
                     result.try_to_bool(vm)
                 }
             }
@@ -429,7 +429,7 @@ pub(super) mod types {
     }
 
     fn derive_and_copy_attributes(
-        orig: &PyRef<PyBaseException>,
+        orig: &Py<PyBaseException>,
         excs: Vec<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyObjectRef> {
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 2958d1e497e..036d914810d 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -79,7 +79,7 @@ impl VirtualMachine {
     pub fn write_exception<W: Write>(
         &self,
         output: &mut W,
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
     ) -> Result<(), W::Error> {
         let seen = &mut HashSet::<usize>::new();
         self.write_exception_recursive(output, exc, seen)
@@ -88,7 +88,7 @@ impl VirtualMachine {
     fn write_exception_recursive<W: Write>(
         &self,
         output: &mut W,
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
         seen: &mut HashSet<usize>,
     ) -> Result<(), W::Error> {
         // This function should not be called directly,
@@ -132,7 +132,7 @@ impl VirtualMachine {
     pub fn write_exception_inner<W: Write>(
         &self,
         output: &mut W,
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
     ) -> Result<(), W::Error> {
         let vm = self;
         if let Some(tb) = exc.traceback.read().clone() {
@@ -177,7 +177,7 @@ impl VirtualMachine {
     fn write_syntaxerror<W: Write>(
         &self,
         output: &mut W,
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
         exc_type: &Py<PyType>,
         args_repr: &[PyRef<PyStr>],
     ) -> Result<(), W::Error> {
@@ -369,7 +369,7 @@ fn print_source_line<W: Write>(
 /// Print exception occurrence location from traceback element
 fn write_traceback_entry<W: Write>(
     output: &mut W,
-    tb_entry: &PyTracebackRef,
+    tb_entry: &Py<PyTraceback>,
 ) -> Result<(), W::Error> {
     let filename = tb_entry.frame.code.source_path.as_str();
     writeln!(
@@ -1053,12 +1053,12 @@ fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
 #[cfg(feature = "serde")]
 pub struct SerializeException<'vm, 's> {
     vm: &'vm VirtualMachine,
-    exc: &'s PyBaseExceptionRef,
+    exc: &'s Py<PyBaseException>,
 }
 
 #[cfg(feature = "serde")]
 impl<'vm, 's> SerializeException<'vm, 's> {
-    pub fn new(vm: &'vm VirtualMachine, exc: &'s PyBaseExceptionRef) -> Self {
+    pub fn new(vm: &'vm VirtualMachine, exc: &'s Py<PyBaseException>) -> Self {
         SerializeException { vm, exc }
     }
 }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 4a460a95884..ad50f972aef 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1866,14 +1866,14 @@ impl ExecutingFrame<'_> {
     /// This ensures proper order preservation for OrderedDict and other custom mappings.
     fn iterate_mapping_keys<F>(
         vm: &VirtualMachine,
-        mapping: &PyObjectRef,
+        mapping: &PyObject,
         error_prefix: &str,
         mut key_handler: F,
     ) -> PyResult<()>
     where
         F: FnMut(PyObjectRef) -> PyResult<()>,
     {
-        let Some(keys_method) = vm.get_method(mapping.clone(), vm.ctx.intern_str("keys")) else {
+        let Some(keys_method) = vm.get_method(mapping.to_owned(), vm.ctx.intern_str("keys")) else {
             return Err(vm.new_type_error(format!("{error_prefix} must be a mapping")));
         };
 
diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index c119405fe1d..3f4a437c599 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -1,8 +1,9 @@
 //! Import mechanics
 
 use crate::{
-    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-    builtins::{PyBaseExceptionRef, PyCode, list, traceback::PyTraceback},
+    AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+    builtins::{PyCode, list, traceback::PyTraceback},
+    exceptions::types::PyBaseException,
     scope::Scope,
     version::get_git_revision,
     vm::{VirtualMachine, thread},
@@ -204,7 +205,7 @@ fn remove_importlib_frames_inner(
 
 // TODO: This function should do nothing on verbose mode.
 // TODO: Fix this function after making PyTraceback.next mutable
-pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &PyBaseExceptionRef) {
+pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &Py<PyBaseException>) {
     if vm.state.settings.verbose != 0 {
         return;
     }
diff --git a/crates/vm/src/object/payload.rs b/crates/vm/src/object/payload.rs
index cf903871179..4b900b7caa1 100644
--- a/crates/vm/src/object/payload.rs
+++ b/crates/vm/src/object/payload.rs
@@ -106,7 +106,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
                 #[inline(never)]
                 fn _into_ref_size_error(
                     vm: &VirtualMachine,
-                    cls: &PyTypeRef,
+                    cls: &Py<PyType>,
                     exact_class: &Py<PyType>,
                 ) -> PyBaseExceptionRef {
                     vm.new_type_error(format!(
@@ -123,7 +123,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
             #[inline(never)]
             fn _into_ref_with_type_error(
                 vm: &VirtualMachine,
-                cls: &PyTypeRef,
+                cls: &Py<PyType>,
                 exact_class: &Py<PyType>,
             ) -> PyBaseExceptionRef {
                 vm.new_type_error(format!(
diff --git a/crates/vm/src/scope.rs b/crates/vm/src/scope.rs
index 9311fa5c2db..4f80e9999ec 100644
--- a/crates/vm/src/scope.rs
+++ b/crates/vm/src/scope.rs
@@ -34,7 +34,7 @@ impl Scope {
         Self::new(locals, globals)
     }
 
-    // pub fn get_locals(&self) -> &PyDictRef {
+    // pub fn get_locals(&self) -> &Py<PyDict> {
     //     match self.locals.first() {
     //         Some(dict) => dict,
     //         None => &self.globals,
diff --git a/crates/vm/src/sequence.rs b/crates/vm/src/sequence.rs
index e75c0a6da55..6e03ad1697e 100644
--- a/crates/vm/src/sequence.rs
+++ b/crates/vm/src/sequence.rs
@@ -12,7 +12,7 @@ use std::ops::{Deref, Range};
 pub trait MutObjectSequenceOp {
     type Inner: ?Sized;
 
-    fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObjectRef>;
+    fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObject>;
     fn do_lock(&self) -> impl Deref<Target = Self::Inner>;
 
     fn mut_count(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<usize> {
@@ -76,7 +76,7 @@ pub trait MutObjectSequenceOp {
                 }
                 borrower = Some(guard);
             } else {
-                let elem = elem.clone();
+                let elem = elem.to_owned();
                 drop(guard);
 
                 if elem.rich_compare_bool(needle, PyComparisonOp::Eq, vm)? {
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 542476d68c7..442bb79b94e 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -10,7 +10,7 @@ mod builtins {
     use std::io::IsTerminal;
 
     use crate::{
-        AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+        AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
         builtins::{
             PyByteArray, PyBytes, PyDictRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,
             enumerate::PyReverseSequenceIterator,
@@ -261,7 +261,7 @@ mod builtins {
             func_name: &'static str,
         ) -> PyResult<crate::scope::Scope> {
             fn validate_globals_dict(
-                globals: &PyObjectRef,
+                globals: &PyObject,
                 vm: &VirtualMachine,
                 func_name: &'static str,
             ) -> PyResult<()> {
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 32596b65386..eae56968cba 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -422,8 +422,8 @@ mod _collections {
     impl MutObjectSequenceOp for PyDeque {
         type Inner = VecDeque<PyObjectRef>;
 
-        fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObjectRef> {
-            inner.get(index)
+        fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObject> {
+            inner.get(index).map(|r| r.as_ref())
         }
 
         fn do_lock(&self) -> impl std::ops::Deref<Target = Self::Inner> {
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index 70aee7378d3..ebe2d16ffb2 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -53,7 +53,7 @@ pub(crate) mod _ctypes {
     use crate::convert::ToPyObject;
     use crate::function::{Either, FuncArgs, OptionalArg};
     use crate::stdlib::ctypes::library;
-    use crate::{AsObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+    use crate::{AsObject, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
     use crossbeam_utils::atomic::AtomicCell;
     use std::ffi::{
         c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
@@ -349,7 +349,7 @@ pub(crate) mod _ctypes {
     const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfguzZPqQ?O";
 
     pub fn new_simple_type(
-        cls: Either<&PyObjectRef, &PyTypeRef>,
+        cls: Either<&PyObject, &PyTypeRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyCSimple> {
         let cls = match cls {
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index a4664ad3671..e45ff0b3b70 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -5,7 +5,9 @@ use crate::function::{ArgBytesLike, Either, FuncArgs, KwArgs, OptionalArg};
 use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer, PyNumberMethods};
 use crate::stdlib::ctypes::_ctypes::new_simple_type;
 use crate::types::{AsBuffer, AsNumber, Constructor};
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+};
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
@@ -46,19 +48,19 @@ pub fn ffi_type_from_str(_type_: &str) -> Option<libffi::middle::Type> {
 }
 
 #[allow(dead_code)]
-fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyResult {
+fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResult {
     match _type_ {
         "c" => {
             if value
-                .clone()
+                .to_owned()
                 .downcast_exact::<PyBytes>(vm)
                 .is_ok_and(|v| v.len() == 1)
                 || value
-                    .clone()
+                    .to_owned()
                     .downcast_exact::<PyBytes>(vm)
                     .is_ok_and(|v| v.len() == 1)
                 || value
-                    .clone()
+                    .to_owned()
                     .downcast_exact::<PyInt>(vm)
                     .map_or(Ok(false), |v| {
                         let n = v.as_bigint().to_i64();
@@ -69,7 +71,7 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
                         }
                     })?
             {
-                Ok(value.clone())
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error("one character bytes, bytearray or integer expected"))
             }
@@ -77,7 +79,7 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
         "u" => {
             if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
                 if b {
-                    Ok(value.clone())
+                    Ok(value.to_owned())
                 } else {
                     Err(vm.new_type_error("one character unicode string expected"))
                 }
@@ -89,8 +91,8 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
             }
         }
         "b" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok() {
-                Ok(value.clone())
+            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok() {
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error(format!(
                     "an integer is required (got type {})",
@@ -100,30 +102,30 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
         }
         "f" | "d" | "g" => {
             // float allows int
-            if value.clone().downcast_exact::<PyFloat>(vm).is_ok()
-                || value.clone().downcast_exact::<PyInt>(vm).is_ok()
+            if value.to_owned().downcast_exact::<PyFloat>(vm).is_ok()
+                || value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
             {
-                Ok(value.clone())
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error(format!("must be real number, not {}", value.class().name())))
             }
         }
         "?" => Ok(PyObjectRef::from(
-            vm.ctx.new_bool(value.clone().try_to_bool(vm)?),
+            vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
         )),
         "B" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok() {
+            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok() {
                 // Store as-is, conversion to unsigned happens in the getter
-                Ok(value.clone())
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error(format!("int expected instead of {}", value.class().name())))
             }
         }
         "z" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok()
-                || value.clone().downcast_exact::<PyBytes>(vm).is_ok()
+            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
+                || value.to_owned().downcast_exact::<PyBytes>(vm).is_ok()
             {
-                Ok(value.clone())
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error(format!(
                     "bytes or integer address expected instead of {} instance",
@@ -132,8 +134,8 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
             }
         }
         "Z" => {
-            if value.clone().downcast_exact::<PyStr>(vm).is_ok() {
-                Ok(value.clone())
+            if value.to_owned().downcast_exact::<PyStr>(vm).is_ok() {
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error(format!(
                     "unicode string or integer address expected instead of {} instance",
@@ -143,10 +145,10 @@ fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyRe
         }
         _ => {
             // "P"
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok()
-                || value.clone().downcast_exact::<PyNone>(vm).is_ok()
+            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
+                || value.to_owned().downcast_exact::<PyNone>(vm).is_ok()
             {
-                Ok(value.clone())
+                Ok(value.to_owned())
             } else {
                 Err(vm.new_type_error("cannot be converted to pointer"))
             }
@@ -437,7 +439,7 @@ impl Debug for PyCSimple {
 
 fn value_to_bytes_endian(
     _type_: &str,
-    value: &PyObjectRef,
+    value: &PyObject,
     swapped: bool,
     vm: &VirtualMachine,
 ) -> Vec<u8> {
@@ -598,7 +600,7 @@ fn value_to_bytes_endian(
         }
         "?" => {
             // c_bool (1 byte)
-            if let Ok(b) = value.clone().try_to_bool(vm) {
+            if let Ok(b) = value.to_owned().try_to_bool(vm) {
                 return vec![if b { 1 } else { 0 }];
             }
             vec![0]
diff --git a/crates/vm/src/stdlib/ctypes/field.rs b/crates/vm/src/stdlib/ctypes/field.rs
index 659255f3329..ea57d68065a 100644
--- a/crates/vm/src/stdlib/ctypes/field.rs
+++ b/crates/vm/src/stdlib/ctypes/field.rs
@@ -1,7 +1,7 @@
 use crate::builtins::PyType;
 use crate::function::PySetterValue;
 use crate::types::{GetDescriptor, Representable};
-use crate::{AsObject, Py, PyObjectRef, PyResult, VirtualMachine};
+use crate::{AsObject, Py, PyObject, PyObjectRef, PyResult, VirtualMachine};
 use num_traits::ToPrimitive;
 
 use super::structure::PyCStructure;
@@ -152,7 +152,7 @@ impl PyCField {
     }
 
     /// Convert a Python value to bytes
-    fn value_to_bytes(value: &PyObjectRef, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+    fn value_to_bytes(value: &PyObject, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
         if let Ok(int_val) = value.try_int(vm) {
             let i = int_val.as_bigint();
             match size {
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index f32d6865cb6..ca67a2fe7d6 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -7,7 +7,7 @@ use crate::function::FuncArgs;
 use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer, PyNumberMethods};
 use crate::stdlib::ctypes::_ctypes::get_size;
 use crate::types::{AsBuffer, AsNumber, Constructor};
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 use indexmap::IndexMap;
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
@@ -109,7 +109,7 @@ impl PyCStructType {
     }
 
     /// Get the size of a ctypes type
-    fn get_field_size(field_type: &PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+    fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
         // Try to get _type_ attribute for simple types
         if let Some(size) = field_type
             .get_attr("_type_", vm)
@@ -139,7 +139,7 @@ impl PyCStructType {
     }
 
     /// Get the alignment of a ctypes type
-    fn get_field_align(field_type: &PyObjectRef, vm: &VirtualMachine) -> usize {
+    fn get_field_align(field_type: &PyObject, vm: &VirtualMachine) -> usize {
         // Try to get _type_ attribute for simple types
         if let Some(align) = field_type
             .get_attr("_type_", vm)
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
index e6873e87506..308a5e4e98f 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -7,7 +7,7 @@ use crate::function::FuncArgs;
 use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer as ProtocolPyBuffer};
 use crate::stdlib::ctypes::_ctypes::get_size;
 use crate::types::{AsBuffer, Constructor};
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
 
@@ -90,7 +90,7 @@ impl PyCUnionType {
         Ok(())
     }
 
-    fn get_field_size(field_type: &PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+    fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
         if let Some(size) = field_type
             .get_attr("_type_", vm)
             .ok()
diff --git a/crates/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
index e8cc407da15..65249bfd075 100644
--- a/crates/vm/src/stdlib/typevar.rs
+++ b/crates/vm/src/stdlib/typevar.rs
@@ -44,7 +44,7 @@ fn caller(vm: &VirtualMachine) -> Option<PyObjectRef> {
 
 /// Set __module__ attribute for an object based on the caller's module.
 /// This follows CPython's behavior for TypeVar and similar objects.
-fn set_module_from_caller(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+fn set_module_from_caller(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
     // Note: CPython gets module from frame->f_funcobj, but RustPython's Frame
     // architecture is different - we use globals['__name__'] instead
     if let Some(module_name) = caller(vm) {
@@ -1006,15 +1006,15 @@ pub fn set_typeparam_default(
 ) -> PyResult {
     // Inner function to handle common pattern of setting evaluate_default
     fn try_set_default<T>(
-        obj: &PyObjectRef,
-        evaluate_default: &PyObjectRef,
+        obj: &PyObject,
+        evaluate_default: &PyObject,
         get_field: impl FnOnce(&T) -> &PyMutex<PyObjectRef>,
     ) -> bool
     where
         T: PyPayload,
     {
         if let Some(typed_obj) = obj.downcast_ref::<T>() {
-            *get_field(typed_obj).lock() = evaluate_default.clone();
+            *get_field(typed_obj).lock() = evaluate_default.to_owned();
             true
         } else {
             false
diff --git a/crates/vm/src/suggestion.rs b/crates/vm/src/suggestion.rs
index 2cc935873c2..866deb668eb 100644
--- a/crates/vm/src/suggestion.rs
+++ b/crates/vm/src/suggestion.rs
@@ -2,9 +2,9 @@
 //! This is used during tracebacks.
 
 use crate::{
-    AsObject, Py, PyObjectRef, VirtualMachine,
+    AsObject, Py, PyObject, PyObjectRef, VirtualMachine,
     builtins::{PyStr, PyStrRef},
-    exceptions::types::PyBaseExceptionRef,
+    exceptions::types::PyBaseException,
     sliceable::SliceableSequenceOp,
 };
 use rustpython_common::str::levenshtein::{MOVE_COST, levenshtein_distance};
@@ -14,7 +14,7 @@ const MAX_CANDIDATE_ITEMS: usize = 750;
 
 pub fn calculate_suggestions<'a>(
     dir_iter: impl ExactSizeIterator<Item = &'a PyObjectRef>,
-    name: &PyObjectRef,
+    name: &PyObject,
 ) -> Option<PyStrRef> {
     if dir_iter.len() >= MAX_CANDIDATE_ITEMS {
         return None;
@@ -47,7 +47,7 @@ pub fn calculate_suggestions<'a>(
     suggestion.map(|r| r.to_owned())
 }
 
-pub fn offer_suggestions(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> Option<PyStrRef> {
+pub fn offer_suggestions(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> Option<PyStrRef> {
     if exc.class().is(vm.ctx.exceptions.attribute_error) {
         let name = exc.as_object().get_attr("name", vm).unwrap();
         let obj = exc.as_object().get_attr("obj", vm).unwrap();
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index fbda71dc1f6..486c1861fb1 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -62,9 +62,9 @@ macro_rules! declare_const_name {
         }
 
         impl ConstName {
-            unsafe fn new(pool: &StringPool, typ: &PyTypeRef) -> Self {
+            unsafe fn new(pool: &StringPool, typ: &Py<PyType>) -> Self {
                 Self {
-                    $($name: unsafe { pool.intern(declare_const_name!(@string $name $($s)?), typ.clone()) },)*
+                    $($name: unsafe { pool.intern(declare_const_name!(@string $name $($s)?), typ.to_owned()) },)*
                 }
             }
         }
@@ -317,7 +317,7 @@ impl Context {
         );
 
         let string_pool = StringPool::default();
-        let names = unsafe { ConstName::new(&string_pool, &types.str_type.to_owned()) };
+        let names = unsafe { ConstName::new(&string_pool, types.str_type) };
 
         let slot_new_wrapper = PyMethodDef::new_const(
             names.__new__.as_str(),
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index fd37b2494dd..4574b2de370 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -23,6 +23,7 @@ use crate::{
     codecs::CodecsRegistry,
     common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
     convert::ToPyObject,
+    exceptions::types::PyBaseException,
     frame::{ExecutionResult, Frame, FrameRef},
     frozen::FrozenModule,
     function::{ArgMapping, FuncArgs, PySetterValue},
@@ -728,7 +729,7 @@ impl VirtualMachine {
 
     pub fn set_attribute_error_context(
         &self,
-        exc: &PyBaseExceptionRef,
+        exc: &Py<PyBaseException>,
         obj: PyObjectRef,
         name: PyStrRef,
     ) {
@@ -814,7 +815,7 @@ impl VirtualMachine {
         drop(prev);
     }
 
-    pub(crate) fn contextualize_exception(&self, exception: &PyBaseExceptionRef) {
+    pub(crate) fn contextualize_exception(&self, exception: &Py<PyBaseException>) {
         if let Some(context_exc) = self.topmost_exception()
             && !context_exc.is(exception)
         {
diff --git a/crates/vm/src/warn.rs b/crates/vm/src/warn.rs
index 6480f778433..b632495eb4a 100644
--- a/crates/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -1,5 +1,5 @@
 use crate::{
-    AsObject, Context, Py, PyObjectRef, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
     builtins::{
         PyDictRef, PyListRef, PyStr, PyStrInterned, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
     },
@@ -38,7 +38,7 @@ impl WarningsState {
     }
 }
 
-fn check_matched(obj: &PyObjectRef, arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+fn check_matched(obj: &PyObject, arg: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     if obj.class().is(vm.ctx.types.none_type) {
         return Ok(true);
     }
diff --git a/crates/wasm/src/convert.rs b/crates/wasm/src/convert.rs
index d1821f2e733..f84b0d46239 100644
--- a/crates/wasm/src/convert.rs
+++ b/crates/wasm/src/convert.rs
@@ -4,8 +4,8 @@ use crate::js_module;
 use crate::vm_class::{WASMVirtualMachine, stored_vm_from_wasm};
 use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Array};
 use rustpython_vm::{
-    AsObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
-    builtins::PyBaseExceptionRef,
+    AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
+    builtins::{PyBaseException, PyBaseExceptionRef},
     compiler::{CompileError, ParseError, parser::LexicalErrorType, parser::ParseErrorType},
     exceptions,
     function::{ArgBytesLike, FuncArgs},
@@ -32,7 +32,7 @@ extern "C" {
     fn new(info: JsValue) -> PyError;
 }
 
-pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &PyBaseExceptionRef) -> JsValue {
+pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &Py<PyBaseException>) -> JsValue {
     let js_err = vm.try_class("_js", "JSError").ok();
     let js_arg = if js_err.is_some_and(|js_err| py_err.fast_isinstance(&js_err)) {
         py_err.get_arg(0)
diff --git a/crates/wasm/src/js_module.rs b/crates/wasm/src/js_module.rs
index 1d8ca0961ca..d4f623da9f4 100644
--- a/crates/wasm/src/js_module.rs
+++ b/crates/wasm/src/js_module.rs
@@ -612,8 +612,7 @@ mod _js {
     fn js_error(vm: &VirtualMachine) -> PyTypeRef {
         let ctx = &vm.ctx;
         let js_error = PyRef::leak(
-            PyType::new_simple_heap("JSError", &vm.ctx.exceptions.exception_type.to_owned(), ctx)
-                .unwrap(),
+            PyType::new_simple_heap("JSError", vm.ctx.exceptions.exception_type, ctx).unwrap(),
         );
         extend_class!(ctx, js_error, {
             "value" => ctx.new_readonly_getset("value", js_error, |exc: PyBaseExceptionRef| exc.get_arg(0)),

From 9e439667dac0729f3d0c488ab3f6fedaadc580f7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 18 Dec 2025 10:44:56 +0900
Subject: [PATCH 011/418] Fix openssl build and shared ssl/error.rs (#6456)

* Fix openssl

* shared error
---
 crates/stdlib/src/openssl.rs      | 502 +++++++++++++-----------------
 crates/stdlib/src/openssl/cert.rs |   3 +-
 crates/stdlib/src/ssl.rs          | 114 +------
 crates/stdlib/src/ssl/compat.rs   |  11 +-
 crates/stdlib/src/ssl/error.rs    | 117 +++++++
 5 files changed, 354 insertions(+), 393 deletions(-)
 create mode 100644 crates/stdlib/src/ssl/error.rs

diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index bf03813b180..e07ad552f17 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -2,6 +2,10 @@
 
 mod cert;
 
+// SSL exception types (shared with rustls backend)
+#[path = "ssl/error.rs"]
+mod ssl_error;
+
 // Conditional compilation for OpenSSL version-specific error codes
 cfg_if::cfg_if! {
     if #[cfg(ossl310)] {
@@ -45,9 +49,16 @@ cfg_if::cfg_if! {
 }
 
 #[allow(non_upper_case_globals)]
-#[pymodule(with(cert::ssl_cert, ossl101, ossl111, windows))]
+#[pymodule(with(cert::ssl_cert, ssl_error::ssl_error, ossl101, ossl111, windows))]
 mod _ssl {
     use super::{bio, probe};
+
+    // Import error types used in this module (others are exposed via pymodule(with(...)))
+    use super::ssl_error::{
+        PySSLCertVerificationError as PySslCertVerificationError, PySSLEOFError as PySslEOFError,
+        PySSLError as PySslError, PySSLWantReadError as PySslWantReadError,
+        PySSLWantWriteError as PySslWantWriteError,
+    };
     use crate::{
         common::lock::{
             PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
@@ -56,8 +67,8 @@ mod _ssl {
         vm::{
             AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
             builtins::{
-                PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyOSError, PyStrRef,
-                PyTypeRef, PyWeak,
+                PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType,
+                PyWeak,
             },
             class_or_notimplemented,
             convert::ToPyException,
@@ -300,85 +311,6 @@ mod _ssl {
         parse_version_info(openssl_api_version)
     }
 
-    // SSL Exception Types
-
-    /// An error occurred in the SSL implementation.
-    #[pyattr]
-    #[pyexception(name = "SSLError", base = PyOSError)]
-    #[derive(Debug)]
-    pub struct PySslError {}
-
-    #[pyexception]
-    impl PySslError {
-        // Returns strerror attribute if available, otherwise str(args)
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            // Try to get strerror attribute first (OSError compatibility)
-            if let Ok(strerror) = exc.as_object().get_attr("strerror", vm)
-                && !vm.is_none(&strerror)
-            {
-                return strerror.str(vm);
-            }
-
-            // Otherwise return str(args)
-            exc.args().as_object().str(vm)
-        }
-    }
-
-    /// A certificate could not be verified.
-    #[pyattr]
-    #[pyexception(name = "SSLCertVerificationError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslCertVerificationError {}
-
-    #[pyexception]
-    impl PySslCertVerificationError {}
-
-    /// SSL/TLS session closed cleanly.
-    #[pyattr]
-    #[pyexception(name = "SSLZeroReturnError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslZeroReturnError {}
-
-    #[pyexception]
-    impl PySslZeroReturnError {}
-
-    /// Non-blocking SSL socket needs to read more data.
-    #[pyattr]
-    #[pyexception(name = "SSLWantReadError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslWantReadError {}
-
-    #[pyexception]
-    impl PySslWantReadError {}
-
-    /// Non-blocking SSL socket needs to write more data.
-    #[pyattr]
-    #[pyexception(name = "SSLWantWriteError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslWantWriteError {}
-
-    #[pyexception]
-    impl PySslWantWriteError {}
-
-    /// System error when attempting SSL operation.
-    #[pyattr]
-    #[pyexception(name = "SSLSyscallError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslSyscallError {}
-
-    #[pyexception]
-    impl PySslSyscallError {}
-
-    /// SSL/TLS connection terminated abruptly.
-    #[pyattr]
-    #[pyexception(name = "SSLEOFError", base = PySslError)]
-    #[derive(Debug)]
-    pub struct PySslEOFError {}
-
-    #[pyexception]
-    impl PySslEOFError {}
-
     type OpensslVersionInfo = (u8, u8, u8, u8, u8);
     const fn parse_version_info(mut n: i64) -> OpensslVersionInfo {
         let status = (n & 0xF) as u8;
@@ -582,18 +514,53 @@ mod _ssl {
         Ok(buf)
     }
 
-    // Callback data stored in SSL context for SNI
+    // Callback data stored in SSL ex_data for SNI/msg callbacks
     struct SniCallbackData {
         ssl_context: PyRef<PySslContext>,
-        vm_ptr: *const VirtualMachine,
+        // Use weak reference to avoid reference cycle:
+        // PySslSocket -> SslStream -> SSL -> ex_data -> SniCallbackData -> PySslSocket
+        ssl_socket_weak: PyRef<PyWeak>,
+    }
+
+    // Thread-local storage for VirtualMachine pointer during handshake
+    // SNI callback is only called during handshake which is synchronous
+    thread_local! {
+        static HANDSHAKE_VM: std::cell::Cell<Option<*const VirtualMachine>> = const { std::cell::Cell::new(None) };
+        // SSL pointer during handshake - needed because connection lock is held during handshake
+        // and callbacks may need to access SSL without acquiring the lock
+        static HANDSHAKE_SSL_PTR: std::cell::Cell<Option<*mut sys::SSL>> = const { std::cell::Cell::new(None) };
     }
 
-    impl Drop for SniCallbackData {
+    // RAII guard to set/clear thread-local handshake context
+    struct HandshakeVmGuard {
+        _ssl_ptr: *mut sys::SSL,
+    }
+
+    impl HandshakeVmGuard {
+        fn new(vm: &VirtualMachine, ssl_ptr: *mut sys::SSL) -> Self {
+            HANDSHAKE_VM.with(|cell| cell.set(Some(vm as *const _)));
+            HANDSHAKE_SSL_PTR.with(|cell| cell.set(Some(ssl_ptr)));
+            HandshakeVmGuard { _ssl_ptr: ssl_ptr }
+        }
+    }
+
+    impl Drop for HandshakeVmGuard {
         fn drop(&mut self) {
-            // PyRef will handle reference counting
+            HANDSHAKE_VM.with(|cell| cell.set(None));
+            HANDSHAKE_SSL_PTR.with(|cell| cell.set(None));
         }
     }
 
+    // Get SSL pointer - either from thread-local (during handshake) or from connection
+    fn get_ssl_ptr_for_context_change(connection: &PyRwLock<SslConnection>) -> *mut sys::SSL {
+        // First check if we're in a handshake callback (lock already held)
+        if let Some(ptr) = HANDSHAKE_SSL_PTR.with(|cell| cell.get()) {
+            return ptr;
+        }
+        // Otherwise, acquire the lock normally
+        connection.read().ssl().as_ptr()
+    }
+
     // Get or create an ex_data index for SNI callback data
     fn get_sni_ex_data_index() -> libc::c_int {
         use std::sync::LazyLock;
@@ -610,17 +577,30 @@ mod _ssl {
     }
 
     // Free function for callback data
+    // NOTE: We don't free the data here because it's managed manually in do_handshake
+    // to avoid use-after-free when the SSL object is dropped after timeout
     unsafe extern "C" fn sni_callback_data_free(
         _parent: *mut libc::c_void,
-        ptr: *mut libc::c_void,
+        _ptr: *mut libc::c_void,
         _ad: *mut sys::CRYPTO_EX_DATA,
         _idx: libc::c_int,
         _argl: libc::c_long,
         _argp: *mut libc::c_void,
     ) {
-        if !ptr.is_null() {
-            unsafe {
-                let _ = Box::from_raw(ptr as *mut SniCallbackData);
+        // Intentionally empty - data is freed in cleanup_sni_ex_data()
+    }
+
+    // Clean up SNI callback data from SSL ex_data
+    // Called after handshake to free the data and release references
+    unsafe fn cleanup_sni_ex_data(ssl_ptr: *mut sys::SSL) {
+        unsafe {
+            let idx = get_sni_ex_data_index();
+            let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
+            if !data_ptr.is_null() {
+                // Free the Box<SniCallbackData> - this releases references to context and socket
+                let _ = Box::from_raw(data_ptr as *mut SniCallbackData);
+                // Clear the ex_data to prevent double-free
+                sys::SSL_set_ex_data(ssl_ptr, idx, std::ptr::null_mut());
             }
         }
     }
@@ -658,9 +638,13 @@ mod _ssl {
 
             let callback_data = &*(data_ptr as *const SniCallbackData);
 
-            // SAFETY: vm_ptr is stored during wrap_socket and is valid for the lifetime
-            // of the SSL connection. The handshake happens synchronously in the same thread.
-            let vm = &*callback_data.vm_ptr;
+            // Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)
+            let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {
+                // VM not available - this shouldn't happen during handshake
+                *al = SSL_AD_INTERNAL_ERROR;
+                return SSL_TLSEXT_ERR_ALERT_FATAL;
+            };
+            let vm = &*vm_ptr;
 
             // Get server name
             let servername = sys::SSL_get_servername(ssl_ptr, TLSEXT_NAMETYPE_host_name);
@@ -674,20 +658,11 @@ mod _ssl {
                 }
             };
 
-            // Get SSL socket from SSL ex_data (stored as PySslSocket pointer)
-            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, 0); // Index 0 for SSL socket
-            let ssl_socket_obj = if !ssl_socket_ptr.is_null() {
-                let ssl_socket = &*(ssl_socket_ptr as *const PySslSocket);
-                // Try to get owner first
-                ssl_socket
-                    .owner
-                    .read()
-                    .as_ref()
-                    .and_then(|weak| weak.upgrade())
-                    .unwrap_or_else(|| vm.ctx.none())
-            } else {
-                vm.ctx.none()
-            };
+            // Get SSL socket from callback data via weak reference
+            let ssl_socket_obj = callback_data
+                .ssl_socket_weak
+                .upgrade()
+                .unwrap_or_else(|| vm.ctx.none());
 
             // Call the Python callback
             match callback.call(
@@ -735,81 +710,20 @@ mod _ssl {
     }
 
     // Message callback function called by OpenSSL
-    // Based on CPython's _PySSL_msg_callback in Modules/_ssl/debughelpers.c
+    // NOTE: This callback is intentionally a no-op to avoid deadlocks.
+    // The msg_callback can be called during various SSL operations (read, write, handshake),
+    // and invoking Python code from within these operations can cause deadlocks
+    // (see CPython bpo-43577). A proper implementation would require careful lock ordering.
     unsafe extern "C" fn _msg_callback(
-        write_p: libc::c_int,
-        version: libc::c_int,
-        content_type: libc::c_int,
-        buf: *const libc::c_void,
-        len: usize,
-        ssl_ptr: *mut sys::SSL,
+        _write_p: libc::c_int,
+        _version: libc::c_int,
+        _content_type: libc::c_int,
+        _buf: *const libc::c_void,
+        _len: usize,
+        _ssl_ptr: *mut sys::SSL,
         _arg: *mut libc::c_void,
     ) {
-        if ssl_ptr.is_null() {
-            return;
-        }
-
-        unsafe {
-            // Get SSL socket from SSL_get_app_data (index 0)
-            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, 0);
-            if ssl_socket_ptr.is_null() {
-                return;
-            }
-
-            let ssl_socket = &*(ssl_socket_ptr as *const PySslSocket);
-
-            // Get the callback from the context
-            let callback_opt = ssl_socket.ctx.read().msg_callback.lock().clone();
-            let Some(callback) = callback_opt else {
-                return;
-            };
-
-            // Get callback data from SSL ex_data (for VM)
-            let idx = get_sni_ex_data_index();
-            let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
-            if data_ptr.is_null() {
-                return;
-            }
-
-            let callback_data = &*(data_ptr as *const SniCallbackData);
-            let vm = &*callback_data.vm_ptr;
-
-            // Get SSL socket owner object
-            let ssl_socket_obj = ssl_socket
-                .owner
-                .read()
-                .as_ref()
-                .and_then(|weak| weak.upgrade())
-                .unwrap_or_else(|| vm.ctx.none());
-
-            // Create the message bytes
-            let buf_slice = std::slice::from_raw_parts(buf as *const u8, len);
-            let msg_bytes = vm.ctx.new_bytes(buf_slice.to_vec());
-
-            // Determine direction string
-            let direction_str = if write_p != 0 { "write" } else { "read" };
-
-            // Call the Python callback
-            // Signature: callback(conn, direction, version, content_type, msg_type, data)
-            // For simplicity, we'll pass msg_type as 0 (would need more parsing to get the actual type)
-            match callback.call(
-                (
-                    ssl_socket_obj,
-                    vm.ctx.new_str(direction_str),
-                    vm.ctx.new_int(version),
-                    vm.ctx.new_int(content_type),
-                    vm.ctx.new_int(0), // msg_type - would need parsing
-                    msg_bytes,
-                ),
-                vm,
-            ) {
-                Ok(_) => {}
-                Err(exc) => {
-                    // Log the exception but don't propagate it
-                    vm.run_unraisable(exc, None, vm.ctx.none());
-                }
-            }
-        }
+        // Intentionally empty to avoid deadlocks
     }
 
     #[pyfunction(name = "RAND_pseudo_bytes")]
@@ -850,7 +764,11 @@ mod _ssl {
     impl Constructor for PySslContext {
         type Args = i32;
 
-        fn py_new(cls: PyTypeRef, proto_version: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(
+            _cls: &Py<PyType>,
+            proto_version: Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let proto = SslVersion::try_from(proto_version)
                 .map_err(|_| vm.new_value_error("invalid protocol version"))?;
             let method = match proto {
@@ -932,16 +850,14 @@ mod _ssl {
                 sys::X509_VERIFY_PARAM_set_flags(param, sys::X509_V_FLAG_TRUSTED_FIRST);
             }
 
-            PySslContext {
+            Ok(PySslContext {
                 ctx: PyRwLock::new(builder),
                 check_hostname: AtomicCell::new(check_hostname),
                 protocol: proto,
                 post_handshake_auth: PyMutex::new(false),
                 sni_callback: PyMutex::new(None),
                 msg_callback: PyMutex::new(None),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -981,12 +897,9 @@ mod _ssl {
             if ciphers.contains('\0') {
                 return Err(exceptions::cstring_error(vm));
             }
-            self.builder().set_cipher_list(ciphers).map_err(|_| {
-                vm.new_exception_msg(
-                    PySslError::class(&vm.ctx).to_owned(),
-                    "No cipher can be selected.".to_owned(),
-                )
-            })
+            self.builder()
+                .set_cipher_list(ciphers)
+                .map_err(|_| new_ssl_error(vm, "No cipher can be selected."))
         }
 
         #[pymethod]
@@ -1126,16 +1039,10 @@ mod _ssl {
                 let set = !flags & new_flags;
 
                 if clear != 0 && sys::X509_VERIFY_PARAM_clear_flags(param, clear) == 0 {
-                    return Err(vm.new_exception_msg(
-                        PySslError::class(&vm.ctx).to_owned(),
-                        "Failed to clear verify flags".to_owned(),
-                    ));
+                    return Err(new_ssl_error(vm, "Failed to clear verify flags"));
                 }
                 if set != 0 && sys::X509_VERIFY_PARAM_set_flags(param, set) == 0 {
-                    return Err(vm.new_exception_msg(
-                        PySslError::class(&vm.ctx).to_owned(),
-                        "Failed to set verify flags".to_owned(),
-                    ));
+                    return Err(new_ssl_error(vm, "Failed to set verify flags"));
                 }
                 Ok(())
             }
@@ -1477,10 +1384,13 @@ mod _ssl {
             let fp =
                 rustpython_common::fileutils::fopen(path.as_path(), "rb").map_err(|e| {
                     match e.kind() {
-                        std::io::ErrorKind::NotFound => vm.new_exception_msg(
-                            vm.ctx.exceptions.file_not_found_error.to_owned(),
-                            e.to_string(),
-                        ),
+                        std::io::ErrorKind::NotFound => vm
+                            .new_os_subtype_error(
+                                vm.ctx.exceptions.file_not_found_error.to_owned(),
+                                None,
+                                e.to_string(),
+                            )
+                            .upcast(),
                         _ => vm.new_os_error(e.to_string()),
                     }
                 })?;
@@ -1670,15 +1580,15 @@ mod _ssl {
         ) -> PyResult<(ssl::Ssl, SslServerOrClient, Option<PyStrRef>)> {
             // Validate socket type and context protocol
             if server_side && ctx_ref.protocol == SslVersion::TlsClient {
-                return Err(vm.new_exception_msg(
-                    PySslError::class(&vm.ctx).to_owned(),
-                    "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context".to_owned(),
+                return Err(new_ssl_error(
+                    vm,
+                    "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context",
                 ));
             }
             if !server_side && ctx_ref.protocol == SslVersion::TlsServer {
-                return Err(vm.new_exception_msg(
-                    PySslError::class(&vm.ctx).to_owned(),
-                    "Cannot create a client socket with a PROTOCOL_TLS_SERVER context".to_owned(),
+                return Err(new_ssl_error(
+                    vm,
+                    "Cannot create a client socket with a PROTOCOL_TLS_SERVER context",
                 ));
             }
 
@@ -1791,21 +1701,22 @@ mod _ssl {
             let py_ref =
                 py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?;
 
-            // Set SNI callback data if callback is configured
-            if zelf.sni_callback.lock().is_some() {
+            // Check if SNI callback is configured (minimize lock time)
+            let has_sni_callback = zelf.sni_callback.lock().is_some();
+
+            // Set SNI callback data if needed (after releasing the lock)
+            if has_sni_callback {
+                let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
                 unsafe {
                     let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
 
-                    // Store callback data in SSL ex_data
+                    // Store callback data in SSL ex_data - use weak reference to avoid cycle
                     let callback_data = Box::new(SniCallbackData {
                         ssl_context: zelf.clone(),
-                        vm_ptr: vm as *const _,
+                        ssl_socket_weak,
                     });
                     let idx = get_sni_ex_data_index();
                     sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _);
-
-                    // Store PyRef pointer (heap-allocated) in ex_data index 0
-                    sys::SSL_set_ex_data(ssl_ptr, 0, &*py_ref as *const _ as *mut _);
                 }
             }
 
@@ -1851,21 +1762,22 @@ mod _ssl {
             let py_ref =
                 py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?;
 
-            // Set SNI callback data if callback is configured
-            if zelf.sni_callback.lock().is_some() {
+            // Check if SNI callback is configured (minimize lock time)
+            let has_sni_callback = zelf.sni_callback.lock().is_some();
+
+            // Set SNI callback data if needed (after releasing the lock)
+            if has_sni_callback {
+                let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
                 unsafe {
                     let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
 
-                    // Store callback data in SSL ex_data
+                    // Store callback data in SSL ex_data - use weak reference to avoid cycle
                     let callback_data = Box::new(SniCallbackData {
                         ssl_context: zelf.clone(),
-                        vm_ptr: vm as *const _,
+                        ssl_socket_weak,
                     });
                     let idx = get_sni_ex_data_index();
                     sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _);
-
-                    // Store PyRef pointer (heap-allocated) in ex_data index 0
-                    sys::SSL_set_ex_data(ssl_ptr, 0, &*py_ref as *const _ as *mut _);
                 }
             }
 
@@ -1992,10 +1904,7 @@ mod _ssl {
     }
 
     fn socket_closed_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_exception_msg(
-            PySslError::class(&vm.ctx).to_owned(),
-            "Underlying socket has been closed.".to_owned(),
-        )
+        new_ssl_error(vm, "Underlying socket has been closed.")
     }
 
     // BIO stream wrapper to implement Read/Write traits for MemoryBIO
@@ -2152,12 +2061,13 @@ mod _ssl {
         }
         #[pygetset(setter)]
         fn set_context(&self, value: PyRef<PySslContext>, vm: &VirtualMachine) -> PyResult<()> {
-            // Update the SSL context in the underlying SSL object
-            let stream = self.connection.read();
+            // Get SSL pointer - use thread-local during handshake to avoid deadlock
+            // (connection lock is already held during handshake)
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
 
             // Set the new SSL_CTX on the SSL object
             unsafe {
-                let result = SSL_set_SSL_CTX(stream.ssl().as_ptr(), value.ctx().as_ptr());
+                let result = SSL_set_SSL_CTX(ssl_ptr, value.ctx().as_ptr());
                 if result.is_null() {
                     return Err(vm.new_runtime_error("Failed to set SSL context".to_owned()));
                 }
@@ -2275,6 +2185,12 @@ mod _ssl {
                 .map(cipher_to_tuple)
         }
 
+        #[pymethod]
+        fn pending(&self) -> i32 {
+            let stream = self.connection.read();
+            unsafe { sys::SSL_pending(stream.ssl().as_ptr()) }
+        }
+
         #[pymethod]
         fn shared_ciphers(&self, vm: &VirtualMachine) -> Option<PyListRef> {
             #[cfg(ossl110)]
@@ -2450,8 +2366,8 @@ mod _ssl {
                     // Non-blocking would block - this is okay for shutdown
                     // Return the underlying socket
                 } else {
-                    return Err(vm.new_exception_msg(
-                        PySslError::class(&vm.ctx).to_owned(),
+                    return Err(new_ssl_error(
+                        vm,
                         format!("SSL shutdown failed: error code {}", err),
                     ));
                 }
@@ -2491,9 +2407,13 @@ mod _ssl {
             let mut stream = self.connection.write();
             let ssl_ptr = stream.ssl().as_ptr();
 
+            // Set up thread-local VM and SSL pointer for callbacks
+            // This allows callbacks to access SSL without acquiring the connection lock
+            let _vm_guard = HandshakeVmGuard::new(vm, ssl_ptr);
+
             // BIO mode: no timeout/select logic, just do handshake
             if stream.is_bio() {
-                return stream.do_handshake().map_err(|e| {
+                let result = stream.do_handshake().map_err(|e| {
                     let exc = convert_ssl_error(vm, e);
                     // If it's a cert verification error, set verify info
                     if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) {
@@ -2501,6 +2421,10 @@ mod _ssl {
                     }
                     exc
                 });
+                // Clean up SNI ex_data after handshake (success or failure)
+                // SAFETY: ssl_ptr is valid for the lifetime of stream
+                unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                return result;
             }
 
             // Socket mode: handle timeout and blocking
@@ -2510,7 +2434,12 @@ mod _ssl {
                 .timeout_deadline();
             loop {
                 let err = match stream.do_handshake() {
-                    Ok(()) => return Ok(()),
+                    Ok(()) => {
+                        // Clean up SNI ex_data after successful handshake
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                        return Ok(());
+                    }
                     Err(e) => e,
                 };
                 let (needs, state) = stream
@@ -2519,12 +2448,20 @@ mod _ssl {
                     .socket_needs(&err, &timeout);
                 match state {
                     SelectRet::TimedOut => {
+                        // Clean up SNI ex_data before returning error
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
                         return Err(socket::timeout_error_msg(
                             vm,
                             "The handshake operation timed out".to_owned(),
-                        ));
+                        )
+                        .upcast());
+                    }
+                    SelectRet::Closed => {
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                        return Err(socket_closed_error(vm));
                     }
-                    SelectRet::Closed => return Err(socket_closed_error(vm)),
                     SelectRet::Nonblocking => {}
                     SelectRet::IsBlocking | SelectRet::Ok => {
                         // For blocking sockets, select() has completed successfully
@@ -2539,6 +2476,9 @@ mod _ssl {
                 if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) {
                     set_verify_error_info(&exc, ssl_ptr, vm);
                 }
+                // Clean up SNI ex_data before returning error
+                // SAFETY: ssl_ptr is valid for the lifetime of stream
+                unsafe { cleanup_sni_ex_data(ssl_ptr) };
                 return Err(exc);
             }
         }
@@ -2565,7 +2505,8 @@ mod _ssl {
                     return Err(socket::timeout_error_msg(
                         vm,
                         "The write operation timed out".to_owned(),
-                    ));
+                    )
+                    .upcast());
                 }
                 SelectRet::Closed => return Err(socket_closed_error(vm)),
                 _ => {}
@@ -2584,7 +2525,8 @@ mod _ssl {
                         return Err(socket::timeout_error_msg(
                             vm,
                             "The write operation timed out".to_owned(),
-                        ));
+                        )
+                        .upcast());
                     }
                     SelectRet::Closed => return Err(socket_closed_error(vm)),
                     SelectRet::Nonblocking => {}
@@ -2727,7 +2669,8 @@ mod _ssl {
                             return Err(socket::timeout_error_msg(
                                 vm,
                                 "The read operation timed out".to_owned(),
-                            ));
+                            )
+                            .upcast());
                         }
                         SelectRet::Closed => return Err(socket_closed_error(vm)),
                         SelectRet::Nonblocking => {}
@@ -3070,7 +3013,7 @@ mod _ssl {
     impl Constructor for PySslMemoryBio {
         type Args = ();
 
-        fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             unsafe {
                 let bio = sys::BIO_new(sys::BIO_s_mem());
                 if bio.is_null() {
@@ -3080,12 +3023,10 @@ mod _ssl {
                 sys::BIO_set_retry_read(bio);
                 BIO_set_mem_eof_return(bio, -1);
 
-                PySslMemoryBio {
+                Ok(PySslMemoryBio {
                     bio,
                     eof_written: AtomicCell::new(false),
-                }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+                })
             }
         }
     }
@@ -3143,10 +3084,7 @@ mod _ssl {
         #[pymethod]
         fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<i32> {
             if self.eof_written.load() {
-                return Err(vm.new_exception_msg(
-                    PySslError::class(&vm.ctx).to_owned(),
-                    "cannot write() after write_eof()".to_owned(),
-                ));
+                return Err(new_ssl_error(vm, "cannot write() after write_eof()"));
             }
 
             data.with_ref(|buf| unsafe {
@@ -3235,6 +3173,12 @@ mod _ssl {
         }
     }
 
+    /// Helper function to create SSL error with proper OSError subtype handling
+    fn new_ssl_error(vm: &VirtualMachine, msg: impl ToString) -> PyBaseExceptionRef {
+        vm.new_os_subtype_error(PySslError::class(&vm.ctx).to_owned(), None, msg.to_string())
+            .upcast()
+    }
+
     #[track_caller]
     pub(crate) fn convert_openssl_error(
         vm: &VirtualMachine,
@@ -3255,12 +3199,7 @@ mod _ssl {
                     } else {
                         vm.ctx.exceptions.os_error.to_owned()
                     };
-                    let exc = vm.new_exception(exc_type, vec![vm.ctx.new_int(reason).into()]);
-                    // Set errno attribute explicitly
-                    let _ = exc
-                        .as_object()
-                        .set_attr("errno", vm.ctx.new_int(reason), vm);
-                    return exc;
+                    return vm.new_os_subtype_error(exc_type, Some(reason), "").upcast();
                 }
 
                 let caller = std::panic::Location::caller();
@@ -3310,13 +3249,8 @@ mod _ssl {
 
                 // Create exception instance
                 let reason = sys::ERR_GET_REASON(e.code());
-                let exc = vm.new_exception(
-                    cls,
-                    vec![vm.ctx.new_int(reason).into(), vm.ctx.new_str(msg).into()],
-                );
-
-                // Set attributes on instance, not class
-                let exc_obj: PyObjectRef = exc.into();
+                let exc = vm.new_os_subtype_error(cls, Some(reason), msg);
+                let exc_obj: PyObjectRef = exc.upcast::<PyBaseException>().into();
 
                 // Set reason attribute (always set, even if just the error string)
                 let reason_value = vm.ctx.new_str(errstr);
@@ -3345,7 +3279,8 @@ mod _ssl {
             }
             None => {
                 let cls = PySslError::class(&vm.ctx).to_owned();
-                vm.new_exception_empty(cls)
+                vm.new_os_subtype_error(cls, None, "unknown SSL error")
+                    .upcast()
             }
         }
     }
@@ -3396,15 +3331,13 @@ mod _ssl {
                 // this is an EOF in violation of protocol -> SSLEOFError
                 // Need to set args[0] = SSL_ERROR_EOF for suppress_ragged_eofs check
                 None => {
-                    return vm.new_exception(
-                        PySslEOFError::class(&vm.ctx).to_owned(),
-                        vec![
-                            vm.ctx.new_int(SSL_ERROR_EOF).into(),
-                            vm.ctx
-                                .new_str("EOF occurred in violation of protocol")
-                                .into(),
-                        ],
-                    );
+                    return vm
+                        .new_os_subtype_error(
+                            PySslEOFError::class(&vm.ctx).to_owned(),
+                            Some(SSL_ERROR_EOF as i32),
+                            "EOF occurred in violation of protocol",
+                        )
+                        .upcast();
                 }
             },
             ssl::ErrorCode::SSL => {
@@ -3417,15 +3350,13 @@ mod _ssl {
                         let reason = sys::ERR_GET_REASON(err_code);
                         let lib = sys::ERR_GET_LIB(err_code);
                         if lib == ERR_LIB_SSL && reason == SSL_R_UNEXPECTED_EOF_WHILE_READING {
-                            return vm.new_exception(
-                                PySslEOFError::class(&vm.ctx).to_owned(),
-                                vec![
-                                    vm.ctx.new_int(SSL_ERROR_EOF).into(),
-                                    vm.ctx
-                                        .new_str("EOF occurred in violation of protocol")
-                                        .into(),
-                                ],
-                            );
+                            return vm
+                                .new_os_subtype_error(
+                                    PySslEOFError::class(&vm.ctx).to_owned(),
+                                    Some(SSL_ERROR_EOF as i32),
+                                    "EOF occurred in violation of protocol",
+                                )
+                                .upcast();
                         }
                     }
                     return convert_openssl_error(vm, ssl_err.clone());
@@ -3440,7 +3371,7 @@ mod _ssl {
                 "A failure in the SSL library occurred",
             ),
         };
-        vm.new_exception_msg(cls, msg.to_owned())
+        vm.new_os_subtype_error(cls, None, msg).upcast()
     }
 
     // SSL_FILETYPE_ASN1 part of _add_ca_certs in CPython
@@ -3543,10 +3474,13 @@ mod _ssl {
         ) -> Result<(), PyBaseExceptionRef> {
             let root = Path::new(CERT_DIR);
             if !root.is_dir() {
-                return Err(vm.new_exception_msg(
-                    vm.ctx.exceptions.file_not_found_error.to_owned(),
-                    CERT_DIR.to_string(),
-                ));
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        None,
+                        CERT_DIR.to_string(),
+                    )
+                    .upcast());
             }
 
             let mut combined_pem = String::new();
diff --git a/crates/stdlib/src/openssl/cert.rs b/crates/stdlib/src/openssl/cert.rs
index 1139f0e26f0..1197bf4aa46 100644
--- a/crates/stdlib/src/openssl/cert.rs
+++ b/crates/stdlib/src/openssl/cert.rs
@@ -165,7 +165,8 @@ pub(crate) mod ssl_cert {
                             format!("{}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3])
                         } else if ip.len() == 16 {
                             // IPv6 - format with all zeros visible (not compressed)
-                            let ip_addr = std::net::Ipv6Addr::from(ip[0..16]);
+                            let ip_addr =
+                                std::net::Ipv6Addr::from(<[u8; 16]>::try_from(&ip[0..16]).unwrap());
                             let s = ip_addr.segments();
                             format!(
                                 "{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}",
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index e6f8c5fda7c..992b32e00ea 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -22,11 +22,14 @@ mod cert;
 // OpenSSL compatibility layer (abstracts rustls operations)
 mod compat;
 
+// SSL exception types (shared with openssl backend)
+mod error;
+
 pub(crate) use _ssl::make_module;
 
 #[allow(non_snake_case)]
 #[allow(non_upper_case_globals)]
-#[pymodule]
+#[pymodule(with(error::ssl_error))]
 mod _ssl {
     use crate::{
         common::{
@@ -37,15 +40,18 @@ mod _ssl {
         vm::{
             AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
             VirtualMachine,
-            builtins::{
-                PyBaseExceptionRef, PyBytesRef, PyListRef, PyOSError, PyStrRef, PyType, PyTypeRef,
-            },
+            builtins::{PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType, PyTypeRef},
             convert::IntoPyException,
             function::{ArgBytesLike, ArgMemoryBuffer, FuncArgs, OptionalArg, PyComparisonValue},
             stdlib::warnings,
             types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
         },
     };
+
+    // Import error types used in this module (others are exposed via pymodule(with(...)))
+    use super::error::{
+        PySSLEOFError, PySSLError, create_ssl_want_read_error, create_ssl_want_write_error,
+    };
     use std::{
         collections::HashMap,
         sync::{
@@ -342,106 +348,6 @@ mod _ssl {
     #[pyattr]
     const ENCODING_PEM_AUX: i32 = 0x101; // PEM + 0x100
 
-    #[pyattr]
-    #[pyexception(name = "SSLError", base = PyOSError)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLError(PyOSError);
-
-    #[pyexception]
-    impl PySSLError {
-        // Returns strerror attribute if available, otherwise str(args)
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            // Try to get strerror attribute first (OSError compatibility)
-            if let Ok(strerror) = exc.as_object().get_attr("strerror", vm)
-                && !vm.is_none(&strerror)
-            {
-                return strerror.str(vm);
-            }
-
-            // Otherwise return str(args)
-            let args = exc.args();
-            if args.len() == 1 {
-                args.as_slice()[0].str(vm)
-            } else {
-                args.as_object().str(vm)
-            }
-        }
-    }
-
-    #[pyattr]
-    #[pyexception(name = "SSLZeroReturnError", base = PySSLError)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLZeroReturnError(PySSLError);
-
-    #[pyexception]
-    impl PySSLZeroReturnError {}
-
-    #[pyattr]
-    #[pyexception(name = "SSLWantReadError", base = PySSLError, impl)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLWantReadError(PySSLError);
-
-    #[pyattr]
-    #[pyexception(name = "SSLWantWriteError", base = PySSLError, impl)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLWantWriteError(PySSLError);
-
-    #[pyattr]
-    #[pyexception(name = "SSLSyscallError", base = PySSLError, impl)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLSyscallError(PySSLError);
-
-    #[pyattr]
-    #[pyexception(name = "SSLEOFError", base = PySSLError, impl)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLEOFError(PySSLError);
-
-    #[pyattr]
-    #[pyexception(name = "SSLCertVerificationError", base = PySSLError, impl)]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PySSLCertVerificationError(PySSLError);
-
-    // Helper functions to create SSL exceptions with proper errno attribute
-    pub(super) fn create_ssl_want_read_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
-        vm.new_os_subtype_error(
-            PySSLWantReadError::class(&vm.ctx).to_owned(),
-            Some(SSL_ERROR_WANT_READ),
-            "The operation did not complete (read)",
-        )
-    }
-
-    pub(super) fn create_ssl_want_write_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
-        vm.new_os_subtype_error(
-            PySSLWantWriteError::class(&vm.ctx).to_owned(),
-            Some(SSL_ERROR_WANT_WRITE),
-            "The operation did not complete (write)",
-        )
-    }
-
-    pub(crate) fn create_ssl_eof_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
-        vm.new_os_subtype_error(
-            PySSLEOFError::class(&vm.ctx).to_owned(),
-            None,
-            "EOF occurred in violation of protocol",
-        )
-    }
-
-    pub(crate) fn create_ssl_zero_return_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
-        vm.new_os_subtype_error(
-            PySSLZeroReturnError::class(&vm.ctx).to_owned(),
-            None,
-            "TLS/SSL connection has been closed (EOF)",
-        )
-    }
-
     /// Validate server hostname for TLS SNI
     ///
     /// Checks that the hostname:
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 4ccc590360a..ab3c81b7a4e 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -30,10 +30,13 @@ use rustpython_vm::{AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObjec
 use std::io::Read;
 use std::sync::{Arc, Once};
 
-// Import PySSLSocket and helper functions from parent module
-use super::_ssl::{
-    PySSLCertVerificationError, PySSLError, PySSLSocket, create_ssl_eof_error,
-    create_ssl_want_read_error, create_ssl_want_write_error, create_ssl_zero_return_error,
+// Import PySSLSocket from parent module
+use super::_ssl::PySSLSocket;
+
+// Import error types and helper functions from error module
+use super::error::{
+    PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,
+    create_ssl_want_write_error, create_ssl_zero_return_error,
 };
 
 // SSL Verification Flags
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
new file mode 100644
index 00000000000..e31683ec72d
--- /dev/null
+++ b/crates/stdlib/src/ssl/error.rs
@@ -0,0 +1,117 @@
+// SSL exception types shared between ssl (rustls) and openssl backends
+
+pub(crate) use ssl_error::*;
+
+#[pymodule(sub)]
+pub(crate) mod ssl_error {
+    use crate::vm::{
+        PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyOSError, PyStrRef},
+        types::Constructor,
+    };
+
+    // Error type constants (needed for create_ssl_want_read_error etc.)
+    pub(crate) const SSL_ERROR_WANT_READ: i32 = 2;
+    pub(crate) const SSL_ERROR_WANT_WRITE: i32 = 3;
+
+    #[pyattr]
+    #[pyexception(name = "SSLError", base = PyOSError)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLError(PyOSError);
+
+    #[pyexception]
+    impl PySSLError {
+        // Returns strerror attribute if available, otherwise str(args)
+        #[pymethod]
+        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            use crate::vm::AsObject;
+            // Try to get strerror attribute first (OSError compatibility)
+            if let Ok(strerror) = exc.as_object().get_attr("strerror", vm)
+                && !vm.is_none(&strerror)
+            {
+                return strerror.str(vm);
+            }
+
+            // Otherwise return str(args)
+            let args = exc.args();
+            if args.len() == 1 {
+                args.as_slice()[0].str(vm)
+            } else {
+                args.as_object().str(vm)
+            }
+        }
+    }
+
+    #[pyattr]
+    #[pyexception(name = "SSLZeroReturnError", base = PySSLError)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLZeroReturnError(PySSLError);
+
+    #[pyexception]
+    impl PySSLZeroReturnError {}
+
+    #[pyattr]
+    #[pyexception(name = "SSLWantReadError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLWantReadError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLWantWriteError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLWantWriteError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLSyscallError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLSyscallError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLEOFError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLEOFError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLCertVerificationError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLCertVerificationError(PySSLError);
+
+    // Helper functions to create SSL exceptions with proper errno attribute
+    pub fn create_ssl_want_read_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLWantReadError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_WANT_READ),
+            "The operation did not complete (read)",
+        )
+    }
+
+    pub fn create_ssl_want_write_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLWantWriteError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_WANT_WRITE),
+            "The operation did not complete (write)",
+        )
+    }
+
+    pub fn create_ssl_eof_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLEOFError::class(&vm.ctx).to_owned(),
+            None,
+            "EOF occurred in violation of protocol",
+        )
+    }
+
+    pub fn create_ssl_zero_return_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLZeroReturnError::class(&vm.ctx).to_owned(),
+            None,
+            "TLS/SSL connection has been closed (EOF)",
+        )
+    }
+}

From 70b93898d4e4dfe5b9badc29618a0fbbc6542787 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 19 Dec 2025 14:10:55 +0900
Subject: [PATCH 012/418] ctypes overhaul (#6450)

---
 .cspell.dict/python-more.txt             |    2 +
 .cspell.json                             |    5 +-
 crates/stdlib/src/pystruct.rs            |    2 +-
 crates/vm/src/buffer.rs                  |   50 +
 crates/vm/src/builtins/builtin_func.rs   |    4 +-
 crates/vm/src/builtins/function.rs       |    5 +-
 crates/vm/src/builtins/object.rs         |    4 +-
 crates/vm/src/builtins/str.rs            |    6 +-
 crates/vm/src/builtins/type.rs           |    4 +-
 crates/vm/src/exceptions.rs              |   11 +-
 crates/vm/src/object/core.rs             |   22 +
 crates/vm/src/protocol/buffer.rs         |   18 +-
 crates/vm/src/stdlib/ast/python.rs       |    4 +-
 crates/vm/src/stdlib/codecs.rs           |    4 +-
 crates/vm/src/stdlib/ctypes.rs           | 1351 ++++++----
 crates/vm/src/stdlib/ctypes/array.rs     | 1658 +++++++-----
 crates/vm/src/stdlib/ctypes/base.rs      | 3068 +++++++++++++++-------
 crates/vm/src/stdlib/ctypes/function.rs  | 1986 ++++++++++++--
 crates/vm/src/stdlib/ctypes/library.rs   |   34 +-
 crates/vm/src/stdlib/ctypes/pointer.rs   |  792 ++++--
 crates/vm/src/stdlib/ctypes/simple.rs    | 1379 ++++++++++
 crates/vm/src/stdlib/ctypes/structure.rs |  747 +++---
 crates/vm/src/stdlib/ctypes/thunk.rs     |  319 ---
 crates/vm/src/stdlib/ctypes/union.rs     |  665 +++--
 crates/vm/src/stdlib/ctypes/util.rs      |   88 -
 crates/vm/src/stdlib/functools.rs        |    4 +-
 crates/vm/src/stdlib/operator.rs         |    2 +-
 crates/vm/src/types/structseq.rs         |    3 +-
 28 files changed, 8879 insertions(+), 3358 deletions(-)
 create mode 100644 crates/vm/src/stdlib/ctypes/simple.rs
 delete mode 100644 crates/vm/src/stdlib/ctypes/thunk.rs
 delete mode 100644 crates/vm/src/stdlib/ctypes/util.rs

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index 58a0e816087..e8534e9744a 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -148,6 +148,7 @@ nbytes
 ncallbacks
 ndigits
 ndim
+needsfree
 nldecoder
 nlocals
 NOARGS
@@ -168,6 +169,7 @@ pycache
 pycodecs
 pycs
 pyexpat
+PYTHONAPI
 PYTHONBREAKPOINT
 PYTHONDEBUG
 PYTHONDONTWRITEBYTECODE
diff --git a/.cspell.json b/.cspell.json
index 9f88a74f96d..3bd06fc2032 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -75,9 +75,9 @@
     "makeunicodedata",
     "miri",
     "notrace",
+    "oparg",
     "openat",
     "pyarg",
-    "pyarg",
     "pyargs",
     "pyast",
     "PyAttr",
@@ -107,6 +107,7 @@
     "pystruct",
     "pystructseq",
     "pytrace",
+    "pytype",
     "reducelib",
     "richcompare",
     "RustPython",
@@ -116,7 +117,6 @@
     "sysmodule",
     "tracebacks",
     "typealiases",
-    "unconstructible",
     "unhashable",
     "uninit",
     "unraisable",
@@ -131,6 +131,7 @@
     "getrusage",
     "nanosleep",
     "sigaction",
+    "sighandler",
     "WRLCK",
     // win32
     "birthtime",
diff --git a/crates/stdlib/src/pystruct.rs b/crates/stdlib/src/pystruct.rs
index 0a006f5a0f2..34a4905ed9f 100644
--- a/crates/stdlib/src/pystruct.rs
+++ b/crates/stdlib/src/pystruct.rs
@@ -28,7 +28,7 @@ pub(crate) mod _struct {
             // CPython turns str to bytes but we do reversed way here
             // The only performance difference is this transition cost
             let fmt = match_class!(match obj {
-                s @ PyStr => s.is_ascii().then_some(s),
+                s @ PyStr => s.isascii().then_some(s),
                 b @ PyBytes => ascii::AsciiStr::from_ascii(&b)
                     .ok()
                     .map(|s| vm.ctx.new_str(s)),
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index cf49d6815c0..eeb6a676542 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -261,6 +261,56 @@ impl FormatCode {
                 return Err("embedded null character".to_owned());
             }
 
+            // PEP3118: Handle extended format specifiers
+            // T{...} - struct, X{} - function pointer, (...) - array shape, :name: - field name
+            if c == b'T' || c == b'X' {
+                // Skip struct/function pointer: consume until matching '}'
+                if chars.peek() == Some(&b'{') {
+                    chars.next(); // consume '{'
+                    let mut depth = 1;
+                    while depth > 0 {
+                        match chars.next() {
+                            Some(b'{') => depth += 1,
+                            Some(b'}') => depth -= 1,
+                            None => return Err("unmatched '{' in format".to_owned()),
+                            _ => {}
+                        }
+                    }
+                    continue;
+                }
+            }
+
+            if c == b'(' {
+                // Skip array shape: consume until matching ')'
+                let mut depth = 1;
+                while depth > 0 {
+                    match chars.next() {
+                        Some(b'(') => depth += 1,
+                        Some(b')') => depth -= 1,
+                        None => return Err("unmatched '(' in format".to_owned()),
+                        _ => {}
+                    }
+                }
+                continue;
+            }
+
+            if c == b':' {
+                // Skip field name: consume until next ':'
+                loop {
+                    match chars.next() {
+                        Some(b':') => break,
+                        None => return Err("unmatched ':' in format".to_owned()),
+                        _ => {}
+                    }
+                }
+                continue;
+            }
+
+            if c == b'{' || c == b'}' {
+                // Skip standalone braces (pointer targets, etc.)
+                continue;
+            }
+
             let code = FormatType::try_from(c)
                 .ok()
                 .filter(|c| match c {
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
index da5fd5e8075..2b569375b28 100644
--- a/crates/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -114,7 +114,7 @@ impl PyNativeFunction {
         zelf.0.value.doc
     }
 
-    #[pygetset(name = "__self__")]
+    #[pygetset]
     fn __self__(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         vm.ctx.none()
     }
@@ -181,7 +181,7 @@ impl PyNativeMethod {
         Ok((getattr, (target, name)))
     }
 
-    #[pygetset(name = "__self__")]
+    #[pygetset]
     fn __self__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> Option<PyObjectRef> {
         zelf.func.zelf.clone()
     }
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 0459cecbdd2..c29e45ddcf6 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -629,12 +629,11 @@ impl GetDescriptor for PyFunction {
         vm: &VirtualMachine,
     ) -> PyResult {
         let (_zelf, obj) = Self::_unwrap(&zelf, obj, vm)?;
-        let obj = if vm.is_none(&obj) && !Self::_cls_is(&cls, obj.class()) {
+        Ok(if vm.is_none(&obj) && !Self::_cls_is(&cls, obj.class()) {
             zelf
         } else {
             PyBoundMethod::new(obj, zelf).into_ref(&vm.ctx).into()
-        };
-        Ok(obj)
+        })
     }
 }
 
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 6f917cd853c..cb95652f937 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -450,8 +450,8 @@ impl PyBaseObject {
         Ok(())
     }
 
-    #[pygetset(name = "__class__")]
-    fn get_class(obj: PyObjectRef) -> PyTypeRef {
+    #[pygetset]
+    fn __class__(obj: PyObjectRef) -> PyTypeRef {
         obj.class().to_owned()
     }
 
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 279b84362a6..8084c4d053e 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -625,9 +625,9 @@ impl PyStr {
         self.data.char_len()
     }
 
-    #[pymethod(name = "isascii")]
+    #[pymethod]
     #[inline(always)]
-    pub const fn is_ascii(&self) -> bool {
+    pub const fn isascii(&self) -> bool {
         matches!(self.kind(), StrKind::Ascii)
     }
 
@@ -960,7 +960,7 @@ impl PyStr {
         format_map(&format_string, &mapping, vm)
     }
 
-    #[pymethod(name = "__format__")]
+    #[pymethod]
     fn __format__(
         zelf: PyRef<PyStr>,
         spec: PyStrRef,
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 15743350397..68de17f60b6 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1445,8 +1445,8 @@ impl GetAttr for PyType {
 
 #[pyclass]
 impl Py<PyType> {
-    #[pygetset(name = "__mro__")]
-    fn get_mro(&self) -> PyTuple {
+    #[pygetset]
+    fn __mro__(&self) -> PyTuple {
         let elements: Vec<PyObjectRef> = self.mro_map_collect(|x| x.as_object().to_owned());
         PyTuple::new_unchecked(elements.into_boxed_slice())
     }
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 036d914810d..bb10ca02c2c 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -624,8 +624,8 @@ impl PyBaseException {
         *self.context.write() = context;
     }
 
-    #[pygetset(name = "__suppress_context__")]
-    pub(super) fn get_suppress_context(&self) -> bool {
+    #[pygetset]
+    pub(super) fn __suppress_context__(&self) -> bool {
         self.suppress_context.load()
     }
 
@@ -1112,7 +1112,7 @@ impl serde::Serialize for SerializeException<'_, '_> {
                 .__context__()
                 .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }),
         )?;
-        struc.serialize_field("suppress_context", &self.exc.get_suppress_context())?;
+        struc.serialize_field("suppress_context", &self.exc.__suppress_context__())?;
 
         let args = {
             struct Args<'vm>(&'vm VirtualMachine, PyTupleRef);
@@ -1550,6 +1550,7 @@ pub(super) mod types {
     pub struct PyUnboundLocalError(PyNameError);
 
     #[pyexception(name, base = PyException, ctx = "os_error")]
+    #[repr(C)]
     pub struct PyOSError {
         base: PyException,
         errno: PyAtomicRef<Option<PyObject>>,
@@ -1857,8 +1858,8 @@ pub(super) mod types {
             self.errno.swap_to_temporary_refs(value, vm);
         }
 
-        #[pygetset(name = "strerror")]
-        fn get_strerror(&self) -> Option<PyObjectRef> {
+        #[pygetset]
+        fn strerror(&self) -> Option<PyObjectRef> {
             self.strerror.to_owned()
         }
 
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index e04b87de594..60b623ef3ed 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -1102,6 +1102,28 @@ where
     }
 }
 
+impl<T: crate::class::PySubclass> Py<T> {
+    /// Converts `&Py<T>` to `&Py<T::Base>`.
+    #[inline]
+    pub fn to_base(&self) -> &Py<T::Base> {
+        debug_assert!(self.as_object().downcast_ref::<T::Base>().is_some());
+        // SAFETY: T is #[repr(transparent)] over T::Base,
+        // so Py<T> and Py<T::Base> have the same layout.
+        unsafe { &*(self as *const Py<T> as *const Py<T::Base>) }
+    }
+
+    /// Converts `&Py<T>` to `&Py<U>` where U is an ancestor type.
+    #[inline]
+    pub fn upcast_ref<U: PyPayload + StaticType>(&self) -> &Py<U>
+    where
+        T: StaticType,
+    {
+        debug_assert!(T::static_type().is_subtype(U::static_type()));
+        // SAFETY: T is a subtype of U, so Py<T> can be viewed as Py<U>.
+        unsafe { &*(self as *const Py<T> as *const Py<U>) }
+    }
+}
+
 impl<T> Borrow<PyObject> for PyRef<T>
 where
     T: PyPayload,
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
index 1dafda203d9..948ec763dc6 100644
--- a/crates/vm/src/protocol/buffer.rs
+++ b/crates/vm/src/protocol/buffer.rs
@@ -202,14 +202,18 @@ impl BufferDescriptor {
     #[cfg(debug_assertions)]
     pub fn validate(self) -> Self {
         assert!(self.itemsize != 0);
-        assert!(self.ndim() != 0);
-        let mut shape_product = 1;
-        for (shape, stride, suboffset) in self.dim_desc.iter().cloned() {
-            shape_product *= shape;
-            assert!(suboffset >= 0);
-            assert!(stride != 0);
+        // ndim=0 is valid for scalar types (e.g., ctypes Structure)
+        if self.ndim() == 0 {
+            assert!(self.itemsize == self.len);
+        } else {
+            let mut shape_product = 1;
+            for (shape, stride, suboffset) in self.dim_desc.iter().cloned() {
+                shape_product *= shape;
+                assert!(suboffset >= 0);
+                assert!(stride != 0);
+            }
+            assert!(shape_product * self.itemsize == self.len);
         }
-        assert!(shape_product * self.itemsize == self.len);
         self
     }
 
diff --git a/crates/vm/src/stdlib/ast/python.rs b/crates/vm/src/stdlib/ast/python.rs
index 042db4aa74e..aa21d8b034a 100644
--- a/crates/vm/src/stdlib/ast/python.rs
+++ b/crates/vm/src/stdlib/ast/python.rs
@@ -47,8 +47,8 @@ pub(crate) mod _ast {
             Ok(())
         }
 
-        #[pyattr(name = "_fields")]
-        fn fields(ctx: &Context) -> PyTupleRef {
+        #[pyattr]
+        fn _fields(ctx: &Context) -> PyTupleRef {
             ctx.empty_tuple.clone()
         }
     }
diff --git a/crates/vm/src/stdlib/codecs.rs b/crates/vm/src/stdlib/codecs.rs
index 5f1b721dfb4..821b313090c 100644
--- a/crates/vm/src/stdlib/codecs.rs
+++ b/crates/vm/src/stdlib/codecs.rs
@@ -176,7 +176,7 @@ mod _codecs {
 
     #[pyfunction]
     fn latin_1_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
-        if args.s.is_ascii() {
+        if args.s.isascii() {
             return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
         }
         do_codec!(latin_1::encode, args, vm)
@@ -189,7 +189,7 @@ mod _codecs {
 
     #[pyfunction]
     fn ascii_encode(args: EncodeArgs, vm: &VirtualMachine) -> EncodeResult {
-        if args.s.is_ascii() {
+        if args.s.isascii() {
             return Ok((args.s.as_bytes().to_vec(), args.s.byte_len()));
         }
         do_codec!(ascii::encode, args, vm)
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index ebe2d16ffb2..3fdb2df6104 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -1,77 +1,372 @@
 // spell-checker:disable
 
-pub(crate) mod array;
-pub(crate) mod base;
-pub(crate) mod field;
-pub(crate) mod function;
-pub(crate) mod library;
-pub(crate) mod pointer;
-pub(crate) mod structure;
-pub(crate) mod thunk;
-pub(crate) mod union;
-pub(crate) mod util;
-
-use crate::builtins::PyModule;
-use crate::class::PyClassImpl;
-use crate::{Py, PyRef, VirtualMachine};
-
-pub use crate::stdlib::ctypes::base::{CDataObject, PyCData, PyCSimple, PyCSimpleType};
-
-pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
+mod array;
+mod base;
+mod function;
+mod library;
+mod pointer;
+mod simple;
+mod structure;
+mod union;
+
+use crate::{
+    AsObject, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
+    builtins::{PyModule, PyStr, PyType},
+    class::PyClassImpl,
+    types::TypeDataRef,
+};
+use std::ffi::{
+    c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
+    c_ulonglong, c_ushort,
+};
+use std::mem;
+use widestring::WideChar;
+
+pub use array::PyCArray;
+pub use base::{FfiArgValue, PyCData, PyCField, StgInfo, StgInfoFlags};
+pub use pointer::PyCPointer;
+pub use simple::{PyCSimple, PyCSimpleType};
+pub use structure::PyCStructure;
+pub use union::PyCUnion;
+
+/// Extension for PyType to get StgInfo
+/// PyStgInfo_FromType
+impl Py<PyType> {
+    /// Get StgInfo from a ctypes type object
+    ///
+    /// Returns a TypeDataRef to StgInfo if the type has one and is initialized, error otherwise.
+    /// Abstract classes (whose metaclass __init__ was not called) will have uninitialized StgInfo.
+    fn stg_info<'a>(&'a self, vm: &VirtualMachine) -> PyResult<TypeDataRef<'a, StgInfo>> {
+        self.stg_info_opt()
+            .ok_or_else(|| vm.new_type_error("abstract class"))
+    }
+
+    /// Get StgInfo if initialized, None otherwise.
+    fn stg_info_opt(&self) -> Option<TypeDataRef<'_, StgInfo>> {
+        self.get_type_data::<StgInfo>()
+            .filter(|info| info.initialized)
+    }
+
+    /// Get _type_ attribute as String (type code like "i", "d", etc.)
+    fn type_code(&self, vm: &VirtualMachine) -> Option<String> {
+        self.as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t: PyObjectRef| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
+    }
+
+    /// Mark all base classes as finalized
+    fn mark_bases_final(&self) {
+        for base in self.bases.read().iter() {
+            if let Some(mut stg) = base.get_type_data_mut::<StgInfo>() {
+                stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+            } else {
+                let mut stg = StgInfo::default();
+                stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                let _ = base.init_type_data(stg);
+            }
+        }
+    }
+}
+
+impl PyType {
+    /// Check if StgInfo is already initialized - prevent double initialization
+    pub(crate) fn check_not_initialized(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(stg_info) = self.get_type_data::<StgInfo>()
+            && stg_info.initialized
+        {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.system_error.to_owned(),
+                format!("StgInfo of '{}' is already initialized.", self.name()),
+            ));
+        }
+        Ok(())
+    }
+}
+
+// Dynamic type check helpers for PyCData
+// These check if an object's type's metaclass is a subclass of a specific metaclass
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _ctypes::make_module(vm);
     let ctx = &vm.ctx;
     PyCSimpleType::make_class(ctx);
     array::PyCArrayType::make_class(ctx);
-    field::PyCFieldType::make_class(ctx);
     pointer::PyCPointerType::make_class(ctx);
     structure::PyCStructType::make_class(ctx);
     union::PyCUnionType::make_class(ctx);
-    extend_module!(vm, module, {
+    extend_module!(vm, &module, {
         "_CData" => PyCData::make_class(ctx),
         "_SimpleCData" => PyCSimple::make_class(ctx),
-        "Array" => array::PyCArray::make_class(ctx),
-        "CField" => field::PyCField::make_class(ctx),
+        "Array" => PyCArray::make_class(ctx),
+        "CField" => PyCField::make_class(ctx),
         "CFuncPtr" => function::PyCFuncPtr::make_class(ctx),
-        "_Pointer" => pointer::PyCPointer::make_class(ctx),
+        "_Pointer" => PyCPointer::make_class(ctx),
         "_pointer_type_cache" => ctx.new_dict(),
-        "Structure" => structure::PyCStructure::make_class(ctx),
-        "CThunkObject" => thunk::PyCThunk::make_class(ctx),
-        "Union" => union::PyCUnion::make_class(ctx),
-    })
+        "_array_type_cache" => ctx.new_dict(),
+        "Structure" => PyCStructure::make_class(ctx),
+        "CThunkObject" => function::PyCThunk::make_class(ctx),
+        "Union" => PyCUnion::make_class(ctx),
+    });
+    module
 }
 
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = _ctypes::make_module(vm);
-    extend_module_nodes(vm, &module);
-    module
+/// Size of long double - platform dependent
+/// x86_64 macOS/Linux: 16 bytes (80-bit extended + padding)
+/// ARM64: 16 bytes (128-bit)
+/// Windows: 8 bytes (same as double)
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    not(target_os = "windows")
+))]
+const LONG_DOUBLE_SIZE: usize = 16;
+
+#[cfg(target_os = "windows")]
+const LONG_DOUBLE_SIZE: usize = mem::size_of::<c_double>();
+
+#[cfg(not(any(
+    all(
+        any(target_arch = "x86_64", target_arch = "aarch64"),
+        not(target_os = "windows")
+    ),
+    target_os = "windows"
+)))]
+const LONG_DOUBLE_SIZE: usize = mem::size_of::<c_double>();
+
+/// Type information for ctypes simple types
+struct TypeInfo {
+    pub size: usize,
+    pub ffi_type_fn: fn() -> libffi::middle::Type,
+}
+
+/// Get type information (size and ffi_type) for a ctypes type code
+fn type_info(ty: &str) -> Option<TypeInfo> {
+    use libffi::middle::Type;
+    match ty {
+        "c" => Some(TypeInfo {
+            size: mem::size_of::<c_schar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "u" => Some(TypeInfo {
+            size: mem::size_of::<WideChar>(),
+            ffi_type_fn: if mem::size_of::<WideChar>() == 2 {
+                Type::u16
+            } else {
+                Type::u32
+            },
+        }),
+        "b" => Some(TypeInfo {
+            size: mem::size_of::<c_schar>(),
+            ffi_type_fn: Type::i8,
+        }),
+        "B" => Some(TypeInfo {
+            size: mem::size_of::<c_uchar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "h" | "v" => Some(TypeInfo {
+            size: mem::size_of::<c_short>(),
+            ffi_type_fn: Type::i16,
+        }),
+        "H" => Some(TypeInfo {
+            size: mem::size_of::<c_ushort>(),
+            ffi_type_fn: Type::u16,
+        }),
+        "i" => Some(TypeInfo {
+            size: mem::size_of::<c_int>(),
+            ffi_type_fn: Type::i32,
+        }),
+        "I" => Some(TypeInfo {
+            size: mem::size_of::<c_uint>(),
+            ffi_type_fn: Type::u32,
+        }),
+        "l" => Some(TypeInfo {
+            size: mem::size_of::<c_long>(),
+            ffi_type_fn: if mem::size_of::<c_long>() == 8 {
+                Type::i64
+            } else {
+                Type::i32
+            },
+        }),
+        "L" => Some(TypeInfo {
+            size: mem::size_of::<c_ulong>(),
+            ffi_type_fn: if mem::size_of::<c_ulong>() == 8 {
+                Type::u64
+            } else {
+                Type::u32
+            },
+        }),
+        "q" => Some(TypeInfo {
+            size: mem::size_of::<c_longlong>(),
+            ffi_type_fn: Type::i64,
+        }),
+        "Q" => Some(TypeInfo {
+            size: mem::size_of::<c_ulonglong>(),
+            ffi_type_fn: Type::u64,
+        }),
+        "f" => Some(TypeInfo {
+            size: mem::size_of::<c_float>(),
+            ffi_type_fn: Type::f32,
+        }),
+        "d" => Some(TypeInfo {
+            size: mem::size_of::<c_double>(),
+            ffi_type_fn: Type::f64,
+        }),
+        "g" => Some(TypeInfo {
+            // long double - platform dependent size
+            // x86_64 macOS/Linux: 16 bytes (80-bit extended + padding)
+            // ARM64: 16 bytes (128-bit)
+            // Windows: 8 bytes (same as double)
+            // Note: Use f64 as FFI type since Rust doesn't support long double natively
+            size: LONG_DOUBLE_SIZE,
+            ffi_type_fn: Type::f64,
+        }),
+        "?" => Some(TypeInfo {
+            size: mem::size_of::<c_uchar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "z" | "Z" | "P" | "X" | "O" => Some(TypeInfo {
+            size: mem::size_of::<usize>(),
+            ffi_type_fn: Type::pointer,
+        }),
+        "void" => Some(TypeInfo {
+            size: 0,
+            ffi_type_fn: Type::void,
+        }),
+        _ => None,
+    }
+}
+
+/// Get size for a ctypes type code
+fn get_size(ty: &str) -> usize {
+    type_info(ty).map(|t| t.size).expect("invalid type code")
+}
+
+/// Get alignment for simple type codes from type_info().
+/// For primitive C types (c_int, c_long, etc.), alignment equals size.
+fn get_align(ty: &str) -> usize {
+    get_size(ty)
 }
 
 #[pymodule]
 pub(crate) mod _ctypes {
-    use super::base::{CDataObject, PyCData, PyCSimple};
-    use crate::builtins::PyTypeRef;
+    use super::library;
+    use super::{PyCArray, PyCData, PyCPointer, PyCSimple, PyCStructure, PyCUnion};
+    use crate::builtins::{PyType, PyTypeRef};
     use crate::class::StaticType;
     use crate::convert::ToPyObject;
-    use crate::function::{Either, FuncArgs, OptionalArg};
-    use crate::stdlib::ctypes::library;
-    use crate::{AsObject, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-    use crossbeam_utils::atomic::AtomicCell;
-    use std::ffi::{
-        c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
-        c_ulonglong, c_ushort,
-    };
-    use std::mem;
-    use widestring::WideChar;
-
-    /// CArgObject - returned by byref()
+    use crate::function::{Either, OptionalArg};
+    use crate::types::Representable;
+    use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+    use num_traits::ToPrimitive;
+
+    /// CArgObject - returned by byref() and paramfunc
+    /// tagPyCArgObject
     #[pyclass(name = "CArgObject", module = "_ctypes", no_attr)]
     #[derive(Debug, PyPayload)]
     pub struct CArgObject {
+        /// Type tag ('P', 'V', 'i', 'd', etc.)
+        pub tag: u8,
+        /// The actual FFI value (mirrors union value)
+        pub value: super::FfiArgValue,
+        /// Reference to original object (for memory safety)
         pub obj: PyObjectRef,
+        /// Size for struct/union ('V' tag)
         #[allow(dead_code)]
+        pub size: usize,
+        /// Offset for byref()
         pub offset: isize,
     }
 
-    #[pyclass]
+    /// is_literal_char - check if character is printable literal (not \\ or ')
+    fn is_literal_char(c: u8) -> bool {
+        c < 128 && c.is_ascii_graphic() && c != b'\\' && c != b'\''
+    }
+
+    impl Representable for CArgObject {
+        // PyCArg_repr - use tag and value fields directly
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            use super::base::FfiArgValue;
+
+            let tag_char = zelf.tag as char;
+
+            // Format value based on tag
+            match zelf.tag {
+                b'b' | b'h' | b'i' | b'l' | b'q' => {
+                    // Signed integers
+                    let n = match zelf.value {
+                        FfiArgValue::I8(v) => v as i64,
+                        FfiArgValue::I16(v) => v as i64,
+                        FfiArgValue::I32(v) => v as i64,
+                        FfiArgValue::I64(v) => v,
+                        _ => 0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, n))
+                }
+                b'B' | b'H' | b'I' | b'L' | b'Q' => {
+                    // Unsigned integers
+                    let n = match zelf.value {
+                        FfiArgValue::U8(v) => v as u64,
+                        FfiArgValue::U16(v) => v as u64,
+                        FfiArgValue::U32(v) => v as u64,
+                        FfiArgValue::U64(v) => v,
+                        _ => 0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, n))
+                }
+                b'f' => {
+                    let v = match zelf.value {
+                        FfiArgValue::F32(v) => v as f64,
+                        _ => 0.0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, v))
+                }
+                b'd' | b'g' => {
+                    let v = match zelf.value {
+                        FfiArgValue::F64(v) => v,
+                        FfiArgValue::F32(v) => v as f64,
+                        _ => 0.0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, v))
+                }
+                b'c' => {
+                    // c_char - single byte
+                    let byte = match zelf.value {
+                        FfiArgValue::I8(v) => v as u8,
+                        FfiArgValue::U8(v) => v,
+                        _ => 0,
+                    };
+                    if is_literal_char(byte) {
+                        Ok(format!("<cparam '{}' ('{}')>", tag_char, byte as char))
+                    } else {
+                        Ok(format!("<cparam '{}' ('\\x{:02x}')>", tag_char, byte))
+                    }
+                }
+                b'z' | b'Z' | b'P' | b'V' => {
+                    // Pointer types
+                    let ptr = match zelf.value {
+                        FfiArgValue::Pointer(v) => v,
+                        _ => 0,
+                    };
+                    if ptr == 0 {
+                        Ok(format!("<cparam '{}' (nil)>", tag_char))
+                    } else {
+                        Ok(format!("<cparam '{}' ({:#x})>", tag_char, ptr))
+                    }
+                }
+                _ => {
+                    // Default fallback
+                    let addr = zelf.get_id();
+                    if is_literal_char(zelf.tag) {
+                        Ok(format!("<cparam '{}' at {:#x}>", tag_char, addr))
+                    } else {
+                        Ok(format!("<cparam {:#04x} at {:#x}>", zelf.tag, addr))
+                    }
+                }
+            }
+        }
+    }
+
+    #[pyclass(with(Representable))]
     impl CArgObject {
         #[pygetset]
         fn _obj(&self) -> PyObjectRef {
@@ -83,43 +378,43 @@ pub(crate) mod _ctypes {
     const __VERSION__: &str = "1.1.0";
 
     // TODO: get properly
-    #[pyattr(name = "RTLD_LOCAL")]
+    #[pyattr]
     const RTLD_LOCAL: i32 = 0;
 
     // TODO: get properly
-    #[pyattr(name = "RTLD_GLOBAL")]
+    #[pyattr]
     const RTLD_GLOBAL: i32 = 0;
 
     #[cfg(target_os = "windows")]
-    #[pyattr(name = "SIZEOF_TIME_T")]
-    pub const SIZEOF_TIME_T: usize = 8;
+    #[pyattr]
+    const SIZEOF_TIME_T: usize = 8;
     #[cfg(not(target_os = "windows"))]
-    #[pyattr(name = "SIZEOF_TIME_T")]
-    pub const SIZEOF_TIME_T: usize = 4;
+    #[pyattr]
+    const SIZEOF_TIME_T: usize = 4;
 
-    #[pyattr(name = "CTYPES_MAX_ARGCOUNT")]
-    pub const CTYPES_MAX_ARGCOUNT: usize = 1024;
+    #[pyattr]
+    const CTYPES_MAX_ARGCOUNT: usize = 1024;
 
     #[pyattr]
-    pub const FUNCFLAG_STDCALL: u32 = 0x0;
+    const FUNCFLAG_STDCALL: u32 = 0x0;
     #[pyattr]
-    pub const FUNCFLAG_CDECL: u32 = 0x1;
+    const FUNCFLAG_CDECL: u32 = 0x1;
     #[pyattr]
-    pub const FUNCFLAG_HRESULT: u32 = 0x2;
+    const FUNCFLAG_HRESULT: u32 = 0x2;
     #[pyattr]
-    pub const FUNCFLAG_PYTHONAPI: u32 = 0x4;
+    const FUNCFLAG_PYTHONAPI: u32 = 0x4;
     #[pyattr]
-    pub const FUNCFLAG_USE_ERRNO: u32 = 0x8;
+    const FUNCFLAG_USE_ERRNO: u32 = 0x8;
     #[pyattr]
-    pub const FUNCFLAG_USE_LASTERROR: u32 = 0x10;
+    const FUNCFLAG_USE_LASTERROR: u32 = 0x10;
 
     #[pyattr]
-    pub const TYPEFLAG_ISPOINTER: u32 = 0x100;
+    const TYPEFLAG_ISPOINTER: u32 = 0x100;
     #[pyattr]
-    pub const TYPEFLAG_HASPOINTER: u32 = 0x200;
+    const TYPEFLAG_HASPOINTER: u32 = 0x200;
 
     #[pyattr]
-    pub const DICTFLAG_FINAL: u32 = 0x1000;
+    const DICTFLAG_FINAL: u32 = 0x1000;
 
     #[pyattr(name = "ArgumentError", once)]
     fn argument_error(vm: &VirtualMachine) -> PyTypeRef {
@@ -130,369 +425,138 @@ pub(crate) mod _ctypes {
         )
     }
 
-    #[pyattr(name = "FormatError", once)]
-    fn format_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "_ctypes",
-            "FormatError",
-            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
-        )
-    }
-
-    pub fn get_size(ty: &str) -> usize {
-        match ty {
-            "u" => mem::size_of::<WideChar>(),
-            "c" | "b" => mem::size_of::<c_schar>(),
-            "h" => mem::size_of::<c_short>(),
-            "H" => mem::size_of::<c_short>(),
-            "i" => mem::size_of::<c_int>(),
-            "I" => mem::size_of::<c_uint>(),
-            "l" => mem::size_of::<c_long>(),
-            "q" => mem::size_of::<c_longlong>(),
-            "L" => mem::size_of::<c_ulong>(),
-            "Q" => mem::size_of::<c_ulonglong>(),
-            "f" => mem::size_of::<c_float>(),
-            "d" | "g" => mem::size_of::<c_double>(),
-            "?" | "B" => mem::size_of::<c_uchar>(),
-            "P" | "z" | "Z" => mem::size_of::<usize>(),
-            "O" => mem::size_of::<PyObjectRef>(),
-            _ => unreachable!(),
-        }
-    }
-
-    /// Get alignment for a simple type - for C types, alignment equals size
-    pub fn get_align(ty: &str) -> usize {
-        get_size(ty)
-    }
-
-    /// Get the size of a ctypes type from its type object
-    #[allow(dead_code)]
-    pub fn get_size_from_type(cls: &PyTypeRef, vm: &VirtualMachine) -> PyResult<usize> {
-        // Try to get _type_ attribute for simple types
-        if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
-            && let Ok(s) = type_attr.str(vm)
-        {
-            let s = s.to_string();
-            if s.len() == 1 && SIMPLE_TYPE_CHARS.contains(s.as_str()) {
-                return Ok(get_size(&s));
-            }
+    #[cfg(target_os = "windows")]
+    #[pyattr(name = "COMError", once)]
+    fn com_error(vm: &VirtualMachine) -> PyTypeRef {
+        use crate::builtins::type_::PyAttributes;
+        use crate::function::FuncArgs;
+        use crate::types::{PyTypeFlags, PyTypeSlots};
+
+        // Sets hresult, text, details as instance attributes in __init__
+        // This function has InitFunc signature for direct slots.init use
+        fn comerror_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let (hresult, text, details): (
+                Option<PyObjectRef>,
+                Option<PyObjectRef>,
+                Option<PyObjectRef>,
+            ) = args.bind(vm)?;
+            let hresult = hresult.unwrap_or_else(|| vm.ctx.none());
+            let text = text.unwrap_or_else(|| vm.ctx.none());
+            let details = details.unwrap_or_else(|| vm.ctx.none());
+
+            // Set instance attributes
+            zelf.set_attr("hresult", hresult.clone(), vm)?;
+            zelf.set_attr("text", text.clone(), vm)?;
+            zelf.set_attr("details", details.clone(), vm)?;
+
+            // self.args = args[1:] = (text, details)
+            // via: PyObject_SetAttrString(self, "args", PySequence_GetSlice(args, 1, size))
+            let args_tuple: PyObjectRef = vm.ctx.new_tuple(vec![text, details]).into();
+            zelf.set_attr("args", args_tuple, vm)?;
+
+            Ok(())
         }
-        // Fall back to sizeof
-        size_of(cls.clone().into(), vm)
-    }
 
-    /// Convert bytes to appropriate Python object based on ctypes type
-    pub fn bytes_to_pyobject(
-        cls: &PyTypeRef,
-        bytes: &[u8],
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRef> {
-        // Try to get _type_ attribute
-        if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
-            && let Ok(s) = type_attr.str(vm)
-        {
-            let ty = s.to_string();
-            return match ty.as_str() {
-                "c" => {
-                    // c_char - single byte
-                    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
-                }
-                "b" => {
-                    // c_byte - signed char
-                    let val = if !bytes.is_empty() { bytes[0] as i8 } else { 0 };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "B" => {
-                    // c_ubyte - unsigned char
-                    let val = if !bytes.is_empty() { bytes[0] } else { 0 };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "h" => {
-                    // c_short
-                    const SIZE: usize = mem::size_of::<c_short>();
-                    let val = if bytes.len() >= SIZE {
-                        c_short::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "H" => {
-                    // c_ushort
-                    const SIZE: usize = mem::size_of::<c_ushort>();
-                    let val = if bytes.len() >= SIZE {
-                        c_ushort::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "i" => {
-                    // c_int
-                    const SIZE: usize = mem::size_of::<c_int>();
-                    let val = if bytes.len() >= SIZE {
-                        c_int::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "I" => {
-                    // c_uint
-                    const SIZE: usize = mem::size_of::<c_uint>();
-                    let val = if bytes.len() >= SIZE {
-                        c_uint::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "l" => {
-                    // c_long
-                    const SIZE: usize = mem::size_of::<c_long>();
-                    let val = if bytes.len() >= SIZE {
-                        c_long::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "L" => {
-                    // c_ulong
-                    const SIZE: usize = mem::size_of::<c_ulong>();
-                    let val = if bytes.len() >= SIZE {
-                        c_ulong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "q" => {
-                    // c_longlong
-                    const SIZE: usize = mem::size_of::<c_longlong>();
-                    let val = if bytes.len() >= SIZE {
-                        c_longlong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "Q" => {
-                    // c_ulonglong
-                    const SIZE: usize = mem::size_of::<c_ulonglong>();
-                    let val = if bytes.len() >= SIZE {
-                        c_ulonglong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "f" => {
-                    // c_float
-                    const SIZE: usize = mem::size_of::<c_float>();
-                    let val = if bytes.len() >= SIZE {
-                        c_float::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0.0
-                    };
-                    Ok(vm.ctx.new_float(val as f64).into())
-                }
-                "d" | "g" => {
-                    // c_double
-                    const SIZE: usize = mem::size_of::<c_double>();
-                    let val = if bytes.len() >= SIZE {
-                        c_double::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
-                    } else {
-                        0.0
-                    };
-                    Ok(vm.ctx.new_float(val).into())
-                }
-                "?" => {
-                    // c_bool
-                    let val = !bytes.is_empty() && bytes[0] != 0;
-                    Ok(vm.ctx.new_bool(val).into())
-                }
-                "P" | "z" | "Z" => {
-                    // Pointer types - return as integer address
-                    let val = if bytes.len() >= mem::size_of::<libc::uintptr_t>() {
-                        const UINTPTR_LEN: usize = mem::size_of::<libc::uintptr_t>();
-                        let mut arr = [0u8; UINTPTR_LEN];
-                        arr[..bytes.len().min(UINTPTR_LEN)]
-                            .copy_from_slice(&bytes[..bytes.len().min(UINTPTR_LEN)]);
-                        usize::from_ne_bytes(arr)
-                    } else {
-                        0
-                    };
-                    Ok(vm.ctx.new_int(val).into())
-                }
-                "u" => {
-                    // c_wchar - wide character
-                    let val = if bytes.len() >= mem::size_of::<WideChar>() {
-                        let wc = if mem::size_of::<WideChar>() == 2 {
-                            u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
-                        } else {
-                            u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
-                        };
-                        char::from_u32(wc).unwrap_or('\0')
-                    } else {
-                        '\0'
-                    };
-                    Ok(vm.ctx.new_str(val.to_string()).into())
-                }
-                _ => Ok(vm.ctx.none()),
-            };
-        }
-        // Default: return bytes as-is
-        Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
-    }
+        // Create exception type with IMMUTABLETYPE flag
+        let mut attrs = PyAttributes::default();
+        attrs.insert(
+            vm.ctx.intern_str("__module__"),
+            vm.ctx.new_str("_ctypes").into(),
+        );
+        attrs.insert(
+            vm.ctx.intern_str("__doc__"),
+            vm.ctx
+                .new_str("Raised when a COM method call failed.")
+                .into(),
+        );
+
+        // Create slots with IMMUTABLETYPE flag
+        let slots = PyTypeSlots {
+            name: "COMError",
+            flags: PyTypeFlags::heap_type_flags()
+                | PyTypeFlags::HAS_DICT
+                | PyTypeFlags::IMMUTABLETYPE,
+            ..PyTypeSlots::default()
+        };
 
-    const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfguzZPqQ?O";
+        let exc_type = PyType::new_heap(
+            "COMError",
+            vec![vm.ctx.exceptions.exception_type.to_owned()],
+            attrs,
+            slots,
+            vm.ctx.types.type_type.to_owned(),
+            &vm.ctx,
+        )
+        .unwrap();
 
-    pub fn new_simple_type(
-        cls: Either<&PyObject, &PyTypeRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyCSimple> {
-        let cls = match cls {
-            Either::A(obj) => obj,
-            Either::B(typ) => typ.as_object(),
-        };
+        // Set our custom init after new_heap, which runs init_slots that would
+        // otherwise overwrite slots.init with init_wrapper (due to __init__ in MRO).
+        exc_type.slots.init.store(Some(comerror_init));
 
-        if let Ok(_type_) = cls.get_attr("_type_", vm) {
-            if _type_.is_instance((&vm.ctx.types.str_type).as_ref(), vm)? {
-                let tp_str = _type_.str(vm)?.to_string();
-
-                if tp_str.len() != 1 {
-                    Err(vm.new_value_error(
-                        format!("class must define a '_type_' attribute which must be a string of length 1, str: {tp_str}"),
-                    ))
-                } else if !SIMPLE_TYPE_CHARS.contains(tp_str.as_str()) {
-                    Err(vm.new_attribute_error(format!("class must define a '_type_' attribute which must be\n a single character string containing one of {SIMPLE_TYPE_CHARS}, currently it is {tp_str}.")))
-                } else {
-                    let size = get_size(&tp_str);
-                    let cdata = CDataObject::from_bytes(vec![0u8; size], None);
-                    Ok(PyCSimple {
-                        _base: PyCData::new(cdata.clone()),
-                        _type_: tp_str,
-                        value: AtomicCell::new(vm.ctx.none()),
-                        cdata: rustpython_common::lock::PyRwLock::new(cdata),
-                    })
-                }
-            } else {
-                Err(vm.new_type_error("class must define a '_type_' string attribute"))
-            }
-        } else {
-            Err(vm.new_attribute_error("class must define a '_type_' attribute"))
-        }
+        exc_type
     }
 
     /// Get the size of a ctypes type or instance
-    #[pyfunction(name = "sizeof")]
-    pub fn size_of(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        use super::pointer::PyCPointer;
-        use super::structure::{PyCStructType, PyCStructure};
+    #[pyfunction]
+    pub fn sizeof(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        use super::structure::PyCStructType;
         use super::union::PyCUnionType;
-        use super::util::StgInfo;
-        use crate::builtins::PyType;
 
-        // 1. Check TypeDataSlot on class (for instances)
-        if let Some(stg_info) = obj.class().get_type_data::<StgInfo>() {
-            return Ok(stg_info.size);
-        }
-
-        // 2. Check TypeDataSlot on type itself (for type objects)
-        if let Some(type_obj) = obj.downcast_ref::<PyType>()
-            && let Some(stg_info) = type_obj.get_type_data::<StgInfo>()
-        {
-            return Ok(stg_info.size);
-        }
-
-        // 3. Instances with cdata buffer
-        if let Some(structure) = obj.downcast_ref::<PyCStructure>() {
-            return Ok(structure.cdata.read().size());
-        }
-        if let Some(simple) = obj.downcast_ref::<PyCSimple>() {
-            return Ok(simple.cdata.read().size());
-        }
-        if obj.fast_isinstance(PyCPointer::static_type()) {
-            return Ok(std::mem::size_of::<usize>());
-        }
-
-        // 3. Type objects
-        if let Ok(type_ref) = obj.clone().downcast::<crate::builtins::PyType>() {
-            // Structure types - check if metaclass is or inherits from PyCStructType
-            if type_ref
+        // 1. Check if obj is a TYPE object (not instance) - PyStgInfo_FromType
+        if let Some(type_obj) = obj.downcast_ref::<PyType>() {
+            // Type object - return StgInfo.size
+            if let Some(stg_info) = type_obj.stg_info_opt() {
+                return Ok(stg_info.size);
+            }
+            // Fallback for type objects without StgInfo
+            // Array types
+            if type_obj
+                .class()
+                .fast_issubclass(super::array::PyCArrayType::static_type())
+                && let Ok(stg) = type_obj.stg_info(vm)
+            {
+                return Ok(stg.size);
+            }
+            // Structure types
+            if type_obj
                 .class()
                 .fast_issubclass(PyCStructType::static_type())
             {
-                return calculate_struct_size(&type_ref, vm);
+                return super::structure::calculate_struct_size(type_obj, vm);
             }
-            // Union types - check if metaclass is or inherits from PyCUnionType
-            if type_ref
+            // Union types
+            if type_obj
                 .class()
                 .fast_issubclass(PyCUnionType::static_type())
             {
-                return calculate_union_size(&type_ref, vm);
+                return super::union::calculate_union_size(type_obj, vm);
             }
-            // Simple types (c_int, c_char, etc.)
-            if type_ref.fast_issubclass(PyCSimple::static_type()) {
-                let instance = new_simple_type(Either::B(&type_ref), vm)?;
-                return Ok(get_size(&instance._type_));
+            // Simple types
+            if type_obj.fast_issubclass(PyCSimple::static_type()) {
+                if let Ok(type_attr) = type_obj.as_object().get_attr("_type_", vm)
+                    && let Ok(type_str) = type_attr.str(vm)
+                {
+                    return Ok(super::get_size(type_str.as_ref()));
+                }
+                return Ok(std::mem::size_of::<usize>());
             }
             // Pointer types
-            if type_ref.fast_issubclass(PyCPointer::static_type()) {
+            if type_obj.fast_issubclass(PyCPointer::static_type()) {
                 return Ok(std::mem::size_of::<usize>());
             }
+            return Err(vm.new_type_error("this type has no size"));
         }
 
-        Err(vm.new_type_error("this type has no size"))
-    }
-
-    /// Calculate Structure type size from _fields_ (sum of field sizes)
-    fn calculate_struct_size(
-        cls: &crate::builtins::PyTypeRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<usize> {
-        use crate::AsObject;
-
-        if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
-            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm).unwrap_or_default();
-            let mut total_size = 0usize;
-
-            for field in fields.iter() {
-                if let Some(tuple) = field.downcast_ref::<crate::builtins::PyTuple>()
-                    && let Some(field_type) = tuple.get(1)
-                {
-                    // Recursively calculate field type size
-                    total_size += size_of(field_type.clone(), vm)?;
-                }
-            }
-            return Ok(total_size);
+        // 2. Instance object - return actual buffer size (b_size)
+        // CDataObject_Check + return obj->b_size
+        if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            return Ok(cdata.size());
         }
-        Ok(0)
-    }
-
-    /// Calculate Union type size from _fields_ (max field size)
-    fn calculate_union_size(
-        cls: &crate::builtins::PyTypeRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<usize> {
-        use crate::AsObject;
-
-        if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
-            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm).unwrap_or_default();
-            let mut max_size = 0usize;
-
-            for field in fields.iter() {
-                if let Some(tuple) = field.downcast_ref::<crate::builtins::PyTuple>()
-                    && let Some(field_type) = tuple.get(1)
-                {
-                    let field_size = size_of(field_type.clone(), vm)?;
-                    max_size = max_size.max(field_size);
-                }
-            }
-            return Ok(max_size);
+        if obj.fast_isinstance(PyCPointer::static_type()) {
+            return Ok(std::mem::size_of::<usize>());
         }
-        Ok(0)
+
+        Err(vm.new_type_error("this type has no size"))
     }
 
     #[cfg(windows)]
@@ -513,7 +577,7 @@ pub(crate) mod _ctypes {
     #[cfg(not(windows))]
     #[pyfunction(name = "dlopen")]
     fn load_library_unix(
-        name: Option<String>,
+        name: Option<crate::function::FsPath>,
         _load_flags: OptionalArg<i32>,
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
@@ -523,9 +587,12 @@ pub(crate) mod _ctypes {
             Some(name) => {
                 let cache = library::libcache();
                 let mut cache_write = cache.write();
-                let (id, _) = cache_write
-                    .get_or_insert_lib(&name, vm)
-                    .map_err(|e| vm.new_os_error(e.to_string()))?;
+                let os_str = name.as_os_str(vm)?;
+                let (id, _) = cache_write.get_or_insert_lib(&*os_str, vm).map_err(|e| {
+                    // Include filename in error message for better diagnostics
+                    let name_str = os_str.to_string_lossy();
+                    vm.new_os_error(format!("{}: {}", name_str, e))
+                })?;
                 Ok(id)
             }
             None => {
@@ -548,7 +615,9 @@ pub(crate) mod _ctypes {
     }
 
     #[pyfunction(name = "POINTER")]
-    pub fn create_pointer_type(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    fn create_pointer_type(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        use crate::builtins::PyStr;
+
         // Get the _pointer_type_cache
         let ctypes_module = vm.import("_ctypes", 0)?;
         let cache = ctypes_module.get_attr("_pointer_type_cache", vm)?;
@@ -563,33 +632,60 @@ pub(crate) mod _ctypes {
         // Get the _Pointer base class
         let pointer_base = ctypes_module.get_attr("_Pointer", vm)?;
 
+        // Create a new type that inherits from _Pointer
+        let pointer_base_type = pointer_base
+            .clone()
+            .downcast::<crate::builtins::PyType>()
+            .map_err(|_| vm.new_type_error("_Pointer must be a type"))?;
+        let metaclass = pointer_base_type.class().to_owned();
+
+        let bases = vm.ctx.new_tuple(vec![pointer_base]);
+        let dict = vm.ctx.new_dict();
+
+        // PyUnicode_CheckExact(cls) - string creates incomplete pointer type
+        if let Some(s) = cls.downcast_ref::<PyStr>() {
+            // Incomplete pointer type: _type_ not set, cache key is id(result)
+            let name = format!("LP_{}", s.as_str());
+
+            let new_type = metaclass
+                .as_object()
+                .call((vm.ctx.new_str(name), bases, dict), vm)?;
+
+            // Store with id(result) as key for incomplete pointer types
+            let id_key: PyObjectRef = vm.ctx.new_int(new_type.get_id() as i64).into();
+            vm.call_method(&cache, "__setitem__", (id_key, new_type.clone()))?;
+
+            return Ok(new_type);
+        }
+
+        // PyType_Check(cls) - type creates complete pointer type
+        if !cls.class().fast_issubclass(vm.ctx.types.type_type.as_ref()) {
+            return Err(vm.new_type_error("must be a ctypes type"));
+        }
+
         // Create the name for the pointer type
         let name = if let Ok(type_obj) = cls.get_attr("__name__", vm) {
             format!("LP_{}", type_obj.str(vm)?)
-        } else if let Ok(s) = cls.str(vm) {
-            format!("LP_{}", s)
         } else {
             "LP_unknown".to_string()
         };
 
-        // Create a new type that inherits from _Pointer
-        let type_type = &vm.ctx.types.type_type;
-        let bases = vm.ctx.new_tuple(vec![pointer_base]);
-        let dict = vm.ctx.new_dict();
+        // Complete pointer type: set _type_ attribute
         dict.set_item("_type_", cls.clone(), vm)?;
 
-        let new_type = type_type
+        // Call the metaclass (PyCPointerType) to create the new type
+        let new_type = metaclass
             .as_object()
             .call((vm.ctx.new_str(name), bases, dict), vm)?;
 
-        // Store in cache using __setitem__
+        // Store in cache with cls as key
         vm.call_method(&cache, "__setitem__", (cls, new_type.clone()))?;
 
         Ok(new_type)
     }
 
-    #[pyfunction(name = "pointer")]
-    pub fn create_pointer_inst(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    #[pyfunction]
+    fn pointer(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // Get the type of the object
         let obj_type = obj.class().to_owned();
 
@@ -607,7 +703,7 @@ pub(crate) mod _ctypes {
 
     #[cfg(target_os = "windows")]
     #[pyfunction(name = "_check_HRESULT")]
-    pub fn check_hresult(_self: PyObjectRef, hr: i32, _vm: &VirtualMachine) -> PyResult<i32> {
+    fn check_hresult(_self: PyObjectRef, hr: i32, _vm: &VirtualMachine) -> PyResult<i32> {
         // TODO: fixme
         if hr < 0 {
             // vm.ctx.new_windows_error(hr)
@@ -619,18 +715,17 @@ pub(crate) mod _ctypes {
 
     #[pyfunction]
     fn addressof(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        if obj.is_instance(PyCSimple::static_type().as_ref(), vm)? {
-            let simple = obj.downcast_ref::<PyCSimple>().unwrap();
-            Ok(simple.value.as_ptr() as usize)
+        // All ctypes objects should return cdata buffer pointer
+        if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            Ok(cdata.buffer.read().as_ptr() as usize)
         } else {
             Err(vm.new_type_error("expected a ctypes instance"))
         }
     }
 
     #[pyfunction]
-    fn byref(obj: PyObjectRef, offset: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult {
-        use super::base::PyCData;
-        use crate::class::StaticType;
+    pub fn byref(obj: PyObjectRef, offset: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult {
+        use super::FfiArgValue;
 
         // Check if obj is a ctypes instance
         if !obj.fast_isinstance(PyCData::static_type())
@@ -644,9 +739,23 @@ pub(crate) mod _ctypes {
 
         let offset_val = offset.unwrap_or(0);
 
+        // Get buffer address: (char *)((CDataObject *)obj)->b_ptr + offset
+        let ptr_val = if let Some(simple) = obj.downcast_ref::<PyCSimple>() {
+            let buffer = simple.0.buffer.read();
+            (buffer.as_ptr() as isize + offset_val) as usize
+        } else if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            let buffer = cdata.buffer.read();
+            (buffer.as_ptr() as isize + offset_val) as usize
+        } else {
+            0
+        };
+
         // Create CArgObject to hold the reference
         Ok(CArgObject {
+            tag: b'P',
+            value: FfiArgValue::Pointer(ptr_val),
             obj,
+            size: 0,
             offset: offset_val,
         }
         .to_pyobject(vm))
@@ -654,11 +763,6 @@ pub(crate) mod _ctypes {
 
     #[pyfunction]
     fn alignment(tp: Either<PyTypeRef, PyObjectRef>, vm: &VirtualMachine) -> PyResult<usize> {
-        use super::base::PyCSimpleType;
-        use super::pointer::PyCPointer;
-        use super::structure::PyCStructure;
-        use super::union::PyCUnion;
-        use super::util::StgInfo;
         use crate::builtins::PyType;
 
         let obj = match &tp {
@@ -667,23 +771,27 @@ pub(crate) mod _ctypes {
         };
 
         // 1. Check TypeDataSlot on class (for instances)
-        if let Some(stg_info) = obj.class().get_type_data::<StgInfo>() {
+        if let Some(stg_info) = obj.class().stg_info_opt() {
             return Ok(stg_info.align);
         }
 
         // 2. Check TypeDataSlot on type itself (for type objects)
         if let Some(type_obj) = obj.downcast_ref::<PyType>()
-            && let Some(stg_info) = type_obj.get_type_data::<StgInfo>()
+            && let Some(stg_info) = type_obj.stg_info_opt()
         {
             return Ok(stg_info.align);
         }
 
-        // 3. Fallback for simple types without TypeDataSlot
-        if obj.fast_isinstance(PyCSimple::static_type()) {
-            // Get stg_info from the type by reading _type_ attribute
-            let cls = obj.class().to_owned();
-            let stg_info = PyCSimpleType::get_stg_info(&cls, vm);
-            return Ok(stg_info.align);
+        // 3. Fallback for simple types
+        if obj.fast_isinstance(PyCSimple::static_type())
+            && let Ok(stg) = obj.class().stg_info(vm)
+        {
+            return Ok(stg.align);
+        }
+        if obj.fast_isinstance(PyCArray::static_type())
+            && let Ok(stg) = obj.class().stg_info(vm)
+        {
+            return Ok(stg.align);
         }
         if obj.fast_isinstance(PyCStructure::static_type()) {
             // Calculate alignment from _fields_
@@ -715,8 +823,8 @@ pub(crate) mod _ctypes {
             // Simple type: _type_ is a single character string
             if let Ok(s) = type_attr.str(vm) {
                 let ty = s.to_string();
-                if ty.len() == 1 && SIMPLE_TYPE_CHARS.contains(ty.as_str()) {
-                    return Ok(get_align(&ty));
+                if ty.len() == 1 && super::simple::SIMPLE_TYPE_CHARS.contains(ty.as_str()) {
+                    return Ok(super::get_align(&ty));
                 }
             }
         }
@@ -754,9 +862,45 @@ pub(crate) mod _ctypes {
     }
 
     #[pyfunction]
-    fn resize(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: RUSTPYTHON
-        Err(vm.new_value_error("not implemented"))
+    fn resize(obj: PyObjectRef, size: isize, vm: &VirtualMachine) -> PyResult<()> {
+        use std::borrow::Cow;
+
+        // 1. Get StgInfo from object's class (validates ctypes instance)
+        let stg_info = obj
+            .class()
+            .stg_info_opt()
+            .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?;
+
+        // 2. Validate size
+        if size < 0 || (size as usize) < stg_info.size {
+            return Err(vm.new_value_error(format!("minimum size is {}", stg_info.size)));
+        }
+
+        // 3. Get PyCData via upcast (works for all ctypes types due to repr(transparent))
+        let cdata = obj
+            .downcast_ref::<PyCData>()
+            .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?;
+
+        // 4. Check if buffer is owned (not borrowed from external memory)
+        {
+            let buffer = cdata.buffer.read();
+            if matches!(&*buffer, Cow::Borrowed(_)) {
+                return Err(vm.new_value_error(
+                    "Memory cannot be resized because this object doesn't own it".to_owned(),
+                ));
+            }
+        }
+
+        // 5. Resize the buffer
+        let new_size = size as usize;
+        let mut buffer = cdata.buffer.write();
+        let old_data = buffer.to_vec();
+        let mut new_data = vec![0u8; new_size];
+        let copy_len = old_data.len().min(new_size);
+        new_data[..copy_len].copy_from_slice(&old_data[..copy_len]);
+        *buffer = Cow::Owned(new_data);
+
+        Ok(())
     }
 
     #[pyfunction]
@@ -796,77 +940,306 @@ pub(crate) mod _ctypes {
 
     #[pyattr]
     fn _string_at_addr(_vm: &VirtualMachine) -> usize {
-        let f = libc::strnlen;
-        f as usize
+        super::function::INTERNAL_STRING_AT_ADDR
     }
 
     #[pyattr]
     fn _wstring_at_addr(_vm: &VirtualMachine) -> usize {
-        // Return address of wcsnlen or similar wide string function
-        #[cfg(not(target_os = "windows"))]
-        {
-            let f = libc::wcslen;
-            f as usize
-        }
-        #[cfg(target_os = "windows")]
-        {
-            // FIXME: On Windows, use wcslen from ucrt
-            0
-        }
+        super::function::INTERNAL_WSTRING_AT_ADDR
     }
 
     #[pyattr]
     fn _cast_addr(_vm: &VirtualMachine) -> usize {
-        // todo!("Implement _cast_addr")
-        0
+        super::function::INTERNAL_CAST_ADDR
     }
 
-    #[pyfunction(name = "_cast")]
-    pub fn pycfunction_cast(
+    #[pyfunction]
+    fn _cast(
         obj: PyObjectRef,
-        _obj2: PyObjectRef,
+        src: PyObjectRef,
         ctype: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use super::array::PyCArray;
-        use super::base::PyCData;
-        use super::pointer::PyCPointer;
-        use crate::class::StaticType;
+        super::function::cast_impl(obj, src, ctype, vm)
+    }
+
+    /// Python-level cast function (PYFUNCTYPE wrapper)
+    #[pyfunction]
+    fn cast(obj: PyObjectRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        super::function::cast_impl(obj.clone(), obj, typ, vm)
+    }
+
+    /// Return buffer interface information for a ctypes type or object.
+    /// Returns a tuple (format, ndim, shape) where:
+    /// - format: PEP 3118 format string
+    /// - ndim: number of dimensions
+    /// - shape: tuple of dimension sizes
+    #[pyfunction]
+    fn buffer_info(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Determine if obj is a type or an instance
+        let is_type = obj.class().fast_issubclass(vm.ctx.types.type_type.as_ref());
+        let cls = if is_type {
+            obj.clone()
+        } else {
+            obj.class().to_owned().into()
+        };
+
+        // Get format from type - try _type_ first (for simple types), then _stg_info_format_
+        let format = if let Ok(type_attr) = cls.get_attr("_type_", vm) {
+            type_attr.str(vm)?.to_string()
+        } else if let Ok(format_attr) = cls.get_attr("_stg_info_format_", vm) {
+            format_attr.str(vm)?.to_string()
+        } else {
+            return Err(vm.new_type_error("not a ctypes type or object"));
+        };
+
+        // Non-array types have ndim=0 and empty shape
+        // TODO: Implement ndim/shape for arrays when StgInfo supports it
+        let ndim = 0;
+        let shape: Vec<PyObjectRef> = vec![];
+
+        let shape_tuple = vm.ctx.new_tuple(shape);
+        Ok(vm
+            .ctx
+            .new_tuple(vec![
+                vm.ctx.new_str(format).into(),
+                vm.ctx.new_int(ndim).into(),
+                shape_tuple.into(),
+            ])
+            .into())
+    }
+
+    /// Unpickle a ctypes object.
+    #[pyfunction]
+    fn _unpickle(typ: PyObjectRef, state: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if !state.class().is(vm.ctx.types.tuple_type.as_ref()) {
+            return Err(vm.new_type_error("state must be a tuple"));
+        }
+        let obj = vm.call_method(&typ, "__new__", (typ.clone(),))?;
+        vm.call_method(&obj, "__setstate__", (state,))?;
+        Ok(obj)
+    }
+
+    /// Call a function at the given address with the given arguments.
+    #[pyfunction]
+    fn call_function(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        call_function_internal(func_addr, args, 0, vm)
+    }
+
+    /// Call a cdecl function at the given address with the given arguments.
+    #[pyfunction]
+    fn call_cdeclfunction(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        call_function_internal(func_addr, args, FUNCFLAG_CDECL, vm)
+    }
 
-        // Python signature: _cast(obj, obj, ctype)
-        // Python passes the same object twice (obj and _obj2 are the same)
-        // We ignore _obj2 as it's redundant
+    fn call_function_internal(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        _flags: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use libffi::middle::{Arg, Cif, CodePtr, Type};
 
-        // Check if this is a pointer type (has _type_ attribute)
-        if ctype.get_attr("_type_", vm).is_err() {
-            return Err(vm.new_type_error("cast() argument 2 must be a pointer type".to_string()));
+        if func_addr == 0 {
+            return Err(vm.new_value_error("NULL function pointer"));
         }
 
-        // Create an instance of the target pointer type with no arguments
-        let result = ctype.call((), vm)?;
+        let mut ffi_args: Vec<Arg> = Vec::with_capacity(args.len());
+        let mut arg_values: Vec<isize> = Vec::with_capacity(args.len());
+        let mut arg_types: Vec<Type> = Vec::with_capacity(args.len());
+
+        for arg in args.iter() {
+            if vm.is_none(arg) {
+                arg_values.push(0);
+                arg_types.push(Type::pointer());
+            } else if let Ok(int_val) = arg.try_int(vm) {
+                let val = int_val.as_bigint().to_i64().unwrap_or(0) as isize;
+                arg_values.push(val);
+                arg_types.push(Type::isize());
+            } else if let Some(bytes) = arg.downcast_ref::<crate::builtins::PyBytes>() {
+                let ptr = bytes.as_bytes().as_ptr() as isize;
+                arg_values.push(ptr);
+                arg_types.push(Type::pointer());
+            } else if let Some(s) = arg.downcast_ref::<crate::builtins::PyStr>() {
+                let ptr = s.as_str().as_ptr() as isize;
+                arg_values.push(ptr);
+                arg_types.push(Type::pointer());
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "Don't know how to convert parameter of type '{}'",
+                    arg.class().name()
+                )));
+            }
+        }
 
-        // Get the pointer value from the source object
-        // If obj is a CData instance (including arrays), use the object itself
-        // If obj is an integer, use it directly as the pointer value
-        let ptr_value: PyObjectRef = if obj.fast_isinstance(PyCData::static_type())
-            || obj.fast_isinstance(PyCArray::static_type())
-            || obj.fast_isinstance(PyCPointer::static_type())
-        {
-            // For CData objects (including arrays and pointers), store the object itself
-            obj.clone()
-        } else if let Ok(int_val) = obj.try_int(vm) {
-            // For integers, treat as pointer address
-            vm.ctx.new_int(int_val.as_bigint().clone()).into()
-        } else {
-            return Err(vm.new_type_error(format!(
-                "cast() argument 1 must be a ctypes instance or an integer, not {}",
-                obj.class().name()
-            )));
+        for val in &arg_values {
+            ffi_args.push(Arg::new(val));
+        }
+
+        let cif = Cif::new(arg_types, Type::isize());
+        let code_ptr = CodePtr::from_ptr(func_addr as *const _);
+        let result: isize = unsafe { cif.call(code_ptr, &ffi_args) };
+        Ok(vm.ctx.new_int(result).into())
+    }
+
+    /// Convert a pointer (as integer) to a Python object.
+    #[pyfunction(name = "PyObj_FromPtr")]
+    fn py_obj_from_ptr(ptr: usize, vm: &VirtualMachine) -> PyResult {
+        if ptr == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+        let raw_ptr = ptr as *mut crate::object::PyObject;
+        unsafe {
+            let obj = crate::PyObjectRef::from_raw(std::ptr::NonNull::new_unchecked(raw_ptr));
+            let obj = std::mem::ManuallyDrop::new(obj);
+            Ok((*obj).clone())
+        }
+    }
+
+    #[pyfunction(name = "Py_INCREF")]
+    fn py_incref(obj: PyObjectRef, _vm: &VirtualMachine) -> PyObjectRef {
+        // TODO:
+        obj
+    }
+
+    #[pyfunction(name = "Py_DECREF")]
+    fn py_decref(obj: PyObjectRef, _vm: &VirtualMachine) -> PyObjectRef {
+        // TODO:
+        obj
+    }
+
+    #[cfg(target_os = "macos")]
+    #[pyfunction]
+    fn _dyld_shared_cache_contains_path(
+        path: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        use std::ffi::CString;
+
+        let path = match path {
+            Some(p) if !vm.is_none(&p) => p,
+            _ => return Ok(false),
         };
 
-        // Set the contents of the pointer by setting the attribute
-        result.set_attr("contents", ptr_value, vm)?;
+        let path_str = path.str(vm)?.to_string();
+        let c_path =
+            CString::new(path_str).map_err(|_| vm.new_value_error("path contains null byte"))?;
 
+        unsafe extern "C" {
+            fn _dyld_shared_cache_contains_path(path: *const libc::c_char) -> bool;
+        }
+
+        let result = unsafe { _dyld_shared_cache_contains_path(c_path.as_ptr()) };
         Ok(result)
     }
+
+    #[cfg(windows)]
+    #[pyfunction(name = "FormatError")]
+    fn format_error_func(code: OptionalArg<u32>, _vm: &VirtualMachine) -> PyResult<String> {
+        use windows_sys::Win32::Foundation::{GetLastError, LocalFree};
+        use windows_sys::Win32::System::Diagnostics::Debug::{
+            FORMAT_MESSAGE_ALLOCATE_BUFFER, FORMAT_MESSAGE_FROM_SYSTEM,
+            FORMAT_MESSAGE_IGNORE_INSERTS, FormatMessageW,
+        };
+
+        let error_code = code.unwrap_or_else(|| unsafe { GetLastError() });
+
+        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let len = unsafe {
+            FormatMessageW(
+                FORMAT_MESSAGE_ALLOCATE_BUFFER
+                    | FORMAT_MESSAGE_FROM_SYSTEM
+                    | FORMAT_MESSAGE_IGNORE_INSERTS,
+                std::ptr::null(),
+                error_code,
+                0,
+                &mut buffer as *mut *mut u16 as *mut u16,
+                0,
+                std::ptr::null(),
+            )
+        };
+
+        if len == 0 || buffer.is_null() {
+            return Ok("<no description>".to_string());
+        }
+
+        let message = unsafe {
+            let slice = std::slice::from_raw_parts(buffer, len as usize);
+            let msg = String::from_utf16_lossy(slice).trim_end().to_string();
+            LocalFree(buffer as *mut _);
+            msg
+        };
+
+        Ok(message)
+    }
+
+    #[cfg(windows)]
+    #[pyfunction(name = "CopyComPointer")]
+    fn copy_com_pointer(src: PyObjectRef, dst: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
+        use windows_sys::Win32::Foundation::{E_POINTER, S_OK};
+
+        // 1. Extract pointer-to-pointer address from dst (byref() result)
+        let pdst: usize = if let Some(carg) = dst.downcast_ref::<CArgObject>() {
+            // byref() result: object buffer address + offset
+            let base = if let Some(cdata) = carg.obj.downcast_ref::<PyCData>() {
+                cdata.buffer.read().as_ptr() as usize
+            } else {
+                return Ok(E_POINTER);
+            };
+            (base as isize + carg.offset) as usize
+        } else {
+            return Ok(E_POINTER);
+        };
+
+        if pdst == 0 {
+            return Ok(E_POINTER);
+        }
+
+        // 2. Extract COM pointer value from src
+        let src_ptr: usize = if vm.is_none(&src) {
+            0
+        } else if let Some(cdata) = src.downcast_ref::<PyCData>() {
+            // c_void_p etc: read pointer value from buffer
+            let buffer = cdata.buffer.read();
+            if buffer.len() >= std::mem::size_of::<usize>() {
+                usize::from_ne_bytes(
+                    buffer[..std::mem::size_of::<usize>()]
+                        .try_into()
+                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                )
+            } else {
+                0
+            }
+        } else {
+            return Ok(E_POINTER);
+        };
+
+        // 3. Call IUnknown::AddRef if src is non-NULL
+        if src_ptr != 0 {
+            unsafe {
+                // IUnknown vtable: [QueryInterface, AddRef, Release, ...]
+                let iunknown = src_ptr as *mut *const usize;
+                let vtable = *iunknown;
+                debug_assert!(!vtable.is_null(), "IUnknown vtable is null");
+                let addref_fn: extern "system" fn(*mut std::ffi::c_void) -> u32 =
+                    std::mem::transmute(*vtable.add(1)); // AddRef is index 1
+                addref_fn(src_ptr as *mut std::ffi::c_void);
+            }
+        }
+
+        // 4. Copy pointer: *pdst = src
+        unsafe {
+            *(pdst as *mut usize) = src_ptr;
+        }
+
+        Ok(S_OK)
+    }
 }
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index fe12a781d9f..60e6516bfe0 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -1,41 +1,109 @@
-use crate::atomic_func;
-use crate::builtins::{PyBytes, PyInt};
-use crate::class::StaticType;
-use crate::function::FuncArgs;
-use crate::protocol::{
-    BufferDescriptor, BufferMethods, PyBuffer, PyNumberMethods, PySequenceMethods,
-};
-use crate::stdlib::ctypes::base::CDataObject;
-use crate::stdlib::ctypes::util::StgInfo;
-use crate::types::{AsBuffer, AsNumber, AsSequence};
-use crate::{AsObject, Py, PyObjectRef, PyPayload};
+use super::StgInfo;
+use super::base::{CDATA_BUFFER_METHODS, PyCData};
 use crate::{
-    PyResult, VirtualMachine,
-    builtins::{PyType, PyTypeRef},
-    types::Constructor,
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    atomic_func,
+    builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
+    class::StaticType,
+    function::{ArgBytesLike, FuncArgs, PySetterValue},
+    protocol::{BufferDescriptor, PyBuffer, PyNumberMethods, PySequenceMethods},
+    types::{AsBuffer, AsNumber, AsSequence, Constructor, Initializer},
 };
-use crossbeam_utils::atomic::AtomicCell;
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
-use rustpython_vm::stdlib::ctypes::_ctypes::get_size;
-use rustpython_vm::stdlib::ctypes::base::PyCData;
+use num_traits::{Signed, ToPrimitive};
+
+/// Creates array type for (element_type, length)
+/// Uses _array_type_cache to ensure identical calls return the same type object
+pub(super) fn array_type_from_ctype(
+    itemtype: PyObjectRef,
+    length: usize,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // PyCArrayType_from_ctype
+
+    // Get the _array_type_cache from _ctypes module
+    let ctypes_module = vm.import("_ctypes", 0)?;
+    let cache = ctypes_module.get_attr("_array_type_cache", vm)?;
+
+    // Create cache key: (itemtype, length) tuple
+    let length_obj: PyObjectRef = vm.ctx.new_int(length).into();
+    let cache_key = vm.ctx.new_tuple(vec![itemtype.clone(), length_obj]);
+
+    // Check if already in cache
+    if let Ok(cached) = vm.call_method(&cache, "__getitem__", (cache_key.clone(),))
+        && !vm.is_none(&cached)
+    {
+        return Ok(cached);
+    }
 
-/// PyCArrayType - metatype for Array types
-/// CPython stores array info (type, length) in StgInfo via type_data
-#[pyclass(name = "PyCArrayType", base = PyType, module = "_ctypes")]
-#[derive(Debug)]
-#[repr(transparent)]
-pub struct PyCArrayType(PyType);
+    // Cache miss - create new array type
+    let itemtype_ref = itemtype
+        .clone()
+        .downcast::<PyType>()
+        .map_err(|_| vm.new_type_error("Expected a type object"))?;
+
+    let item_stg = itemtype_ref
+        .stg_info_opt()
+        .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+
+    let element_size = item_stg.size;
+    let element_align = item_stg.align;
+    let item_format = item_stg.format.clone();
+    let item_shape = item_stg.shape.clone();
+    let item_flags = item_stg.flags;
+
+    // Check overflow before multiplication
+    let total_size = element_size
+        .checked_mul(length)
+        .ok_or_else(|| vm.new_overflow_error("array too large"))?;
+
+    // format name: "c_int_Array_5"
+    let type_name = format!("{}_Array_{}", itemtype_ref.name(), length);
+
+    // Get item type code before moving itemtype
+    let item_type_code = itemtype_ref
+        .as_object()
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+    let stg_info = StgInfo::new_array(
+        total_size,
+        element_align,
+        length,
+        itemtype_ref.clone(),
+        element_size,
+        item_format.as_deref(),
+        &item_shape,
+        item_flags,
+    );
 
-/// Create a new Array type with StgInfo stored in type_data (CPython style)
-pub fn create_array_type_with_stg_info(stg_info: StgInfo, vm: &VirtualMachine) -> PyResult {
-    // Get PyCArrayType as metaclass
-    let metaclass = PyCArrayType::static_type().to_owned();
+    let new_type = create_array_type_with_name(stg_info, &type_name, vm)?;
+
+    // Special case for character arrays - add value/raw attributes
+    let new_type_ref: PyTypeRef = new_type
+        .clone()
+        .downcast()
+        .map_err(|_| vm.new_type_error("expected type"))?;
+
+    match item_type_code.as_deref() {
+        Some("c") => add_char_array_getsets(&new_type_ref, vm),
+        Some("u") => add_wchar_array_getsets(&new_type_ref, vm),
+        _ => {}
+    }
+
+    // Store in cache
+    vm.call_method(&cache, "__setitem__", (cache_key, new_type.clone()))?;
 
-    // Create a unique name for the array type
-    let type_name = format!("Array_{}", stg_info.length);
+    Ok(new_type)
+}
 
-    // Create args for type(): (name, bases, dict)
+/// create_array_type_with_name - create array type with specified name
+fn create_array_type_with_name(
+    stg_info: StgInfo,
+    type_name: &str,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let metaclass = PyCArrayType::static_type().to_owned();
     let name = vm.ctx.new_str(type_name);
     let bases = vm
         .ctx
@@ -47,170 +115,205 @@ pub fn create_array_type_with_stg_info(stg_info: StgInfo, vm: &VirtualMachine) -
         crate::function::KwArgs::default(),
     );
 
-    // Create the new type using PyType::slot_new with PyCArrayType as metaclass
     let new_type = crate::builtins::type_::PyType::slot_new(metaclass, args, vm)?;
 
-    // Set StgInfo in type_data
     let type_ref: PyTypeRef = new_type
         .clone()
         .downcast()
-        .map_err(|_| vm.new_type_error("Failed to create array type".to_owned()))?;
+        .map_err(|_| vm.new_type_error("Failed to create array type"))?;
 
-    if type_ref.init_type_data(stg_info.clone()).is_err() {
-        // Type data already initialized - update it
-        if let Some(mut existing) = type_ref.get_type_data_mut::<StgInfo>() {
-            *existing = stg_info;
-        }
+    // Set class attributes for _type_ and _length_
+    if let Some(element_type) = stg_info.element_type.clone() {
+        new_type.set_attr("_type_", element_type, vm)?;
     }
+    new_type.set_attr("_length_", vm.ctx.new_int(stg_info.length), vm)?;
+
+    super::base::set_or_init_stginfo(&type_ref, stg_info);
 
     Ok(new_type)
 }
 
-impl Constructor for PyCArrayType {
-    type Args = PyObjectRef;
+/// PyCArrayType - metatype for Array types
+#[pyclass(name = "PyCArrayType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCArrayType(PyType);
 
-    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-        unimplemented!("use slot_new")
-    }
-}
+// PyCArrayType implements Initializer for slots.init (PyCArrayType_init)
+impl Initializer for PyCArrayType {
+    type Args = FuncArgs;
 
-#[pyclass(flags(IMMUTABLETYPE), with(Constructor, AsNumber))]
-impl PyCArrayType {
-    #[pygetset(name = "_type_")]
-    fn typ(zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        zelf.downcast_ref::<PyType>()
-            .and_then(|t| t.get_type_data::<StgInfo>())
-            .and_then(|stg| stg.element_type.clone())
-            .unwrap_or_else(|| vm.ctx.none())
-    }
+    fn init(zelf: PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // zelf is the newly created array type (e.g., T in "class T(Array)")
+        let new_type: &PyType = &zelf.0;
+
+        new_type.check_not_initialized(vm)?;
+
+        // 1. Get _length_ from class dict first
+        let direct_length = new_type
+            .attributes
+            .read()
+            .get(vm.ctx.intern_str("_length_"))
+            .cloned();
+
+        // 2. Get _type_ from class dict first
+        let direct_type = new_type
+            .attributes
+            .read()
+            .get(vm.ctx.intern_str("_type_"))
+            .cloned();
+
+        // 3. Find parent StgInfo from MRO (for inheritance)
+        // Note: PyType.mro does NOT include self, so no skip needed
+        let parent_stg_info = new_type
+            .mro
+            .read()
+            .iter()
+            .find_map(|base| base.stg_info_opt().map(|s| s.clone()));
+
+        // 4. Resolve _length_ (direct or inherited)
+        let length = if let Some(length_attr) = direct_length {
+            // Direct _length_ defined - validate it (PyLong_Check)
+            let length_int = length_attr
+                .downcast_ref::<PyInt>()
+                .ok_or_else(|| vm.new_type_error("The '_length_' attribute must be an integer"))?;
+            let bigint = length_int.as_bigint();
+            // Check sign first - negative values are ValueError
+            if bigint.is_negative() {
+                return Err(vm.new_value_error("The '_length_' attribute must not be negative"));
+            }
+            // Positive values that don't fit in usize are OverflowError
+            bigint
+                .to_usize()
+                .ok_or_else(|| vm.new_overflow_error("The '_length_' attribute is too large"))?
+        } else if let Some(ref parent_info) = parent_stg_info {
+            // Inherit from parent
+            parent_info.length
+        } else {
+            return Err(vm.new_attribute_error("class must define a '_length_' attribute"));
+        };
 
-    #[pygetset(name = "_length_")]
-    fn length(zelf: PyObjectRef) -> usize {
-        zelf.downcast_ref::<PyType>()
-            .and_then(|t| t.get_type_data::<StgInfo>())
-            .map(|stg| stg.length)
-            .unwrap_or(0)
-    }
+        // 5. Resolve _type_ and get item_info (direct or inherited)
+        let (element_type, item_size, item_align, item_format, item_shape, item_flags) =
+            if let Some(type_attr) = direct_type {
+                // Direct _type_ defined - validate it (PyStgInfo_FromType)
+                let type_ref = type_attr
+                    .clone()
+                    .downcast::<PyType>()
+                    .map_err(|_| vm.new_type_error("_type_ must be a type"))?;
+                let (size, align, format, shape, flags) = {
+                    let item_info = type_ref
+                        .stg_info_opt()
+                        .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+                    (
+                        item_info.size,
+                        item_info.align,
+                        item_info.format.clone(),
+                        item_info.shape.clone(),
+                        item_info.flags,
+                    )
+                };
+                (type_ref, size, align, format, shape, flags)
+            } else if let Some(ref parent_info) = parent_stg_info {
+                // Inherit from parent
+                let parent_type = parent_info
+                    .element_type
+                    .clone()
+                    .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+                (
+                    parent_type,
+                    parent_info.element_size,
+                    parent_info.align,
+                    parent_info.format.clone(),
+                    parent_info.shape.clone(),
+                    parent_info.flags,
+                )
+            } else {
+                return Err(vm.new_attribute_error("class must define a '_type_' attribute"));
+            };
 
-    #[pymethod]
-    fn __mul__(zelf: PyObjectRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        if n < 0 {
-            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+        // 6. Check overflow (item_size != 0 && length > MAX / item_size)
+        if item_size != 0 && length > usize::MAX / item_size {
+            return Err(vm.new_overflow_error("array too large"));
         }
 
-        // Get inner array info from TypeDataSlot
-        let type_ref = zelf.downcast_ref::<PyType>().unwrap();
-        let (_inner_length, inner_size) = type_ref
-            .get_type_data::<StgInfo>()
-            .map(|stg| (stg.length, stg.size))
-            .unwrap_or((0, 0));
-
-        // The element type of the new array is the current array type itself
-        let current_array_type: PyObjectRef = zelf.clone();
-
-        // Element size is the total size of the inner array
-        let new_element_size = inner_size;
-        let total_size = new_element_size * (n as usize);
-
+        // 7. Initialize StgInfo (PyStgInfo_Init + field assignment)
         let stg_info = StgInfo::new_array(
-            total_size,
-            new_element_size,
-            n as usize,
-            current_array_type,
-            new_element_size,
+            item_size * length, // size = item_size * length
+            item_align,         // align = item_info->align
+            length,             // length
+            element_type.clone(),
+            item_size, // element_size
+            item_format.as_deref(),
+            &item_shape,
+            item_flags,
         );
 
-        create_array_type_with_stg_info(stg_info, vm)
-    }
+        // 8. Store StgInfo in type_data
+        super::base::set_or_init_stginfo(new_type, stg_info);
 
-    #[pyclassmethod]
-    fn in_dll(
-        zelf: PyObjectRef,
-        dll: PyObjectRef,
-        name: crate::builtins::PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use libloading::Symbol;
+        // 9. Get type code before moving element_type
+        let item_type_code = element_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        // 10. Set class attributes for _type_ and _length_
+        zelf.as_object().set_attr("_type_", element_type, vm)?;
+        zelf.as_object()
+            .set_attr("_length_", vm.ctx.new_int(length), vm)?;
+
+        // 11. Special case for character arrays - add value/raw attributes
+        // if (iteminfo->getfunc == _ctypes_get_fielddesc("c")->getfunc)
+        //              add_getset((PyTypeObject*)self, CharArray_getsets);
+        //          else if (iteminfo->getfunc == _ctypes_get_fielddesc("u")->getfunc)
+        //              add_getset((PyTypeObject*)self, WCharArray_getsets);
+
+        // Get type ref for add_getset
+        let type_ref: PyTypeRef = zelf.as_object().to_owned().downcast().unwrap();
+        match item_type_code.as_deref() {
+            Some("c") => add_char_array_getsets(&type_ref, vm),
+            Some("u") => add_wchar_array_getsets(&type_ref, vm),
+            _ => {}
+        }
 
-        // Get the library handle from dll object
-        let handle = if let Ok(int_handle) = dll.try_int(vm) {
-            // dll is an integer handle
-            int_handle
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        } else {
-            // dll is a CDLL/PyDLL/WinDLL object with _handle attribute
-            dll.get_attr("_handle", vm)?
-                .try_int(vm)?
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        };
+        Ok(())
+    }
+}
 
-        // Get the library from cache
-        let library_cache = crate::stdlib::ctypes::library::libcache().read();
-        let library = library_cache
-            .get_lib(handle)
-            .ok_or_else(|| vm.new_attribute_error("Library not found".to_owned()))?;
-
-        // Get symbol address from library
-        let symbol_name = format!("{}\0", name.as_str());
-        let inner_lib = library.lib.lock();
-
-        let symbol_address = if let Some(lib) = &*inner_lib {
-            unsafe {
-                // Try to get the symbol from the library
-                let symbol: Symbol<'_, *mut u8> = lib.get(symbol_name.as_bytes()).map_err(|e| {
-                    vm.new_attribute_error(format!("{}: symbol '{}' not found", e, name.as_str()))
-                })?;
-                *symbol as usize
-            }
-        } else {
-            return Err(vm.new_attribute_error("Library is closed".to_owned()));
-        };
+#[pyclass(flags(IMMUTABLETYPE), with(Initializer, AsNumber))]
+impl PyCArrayType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the array type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
 
-        // Get size from the array type via TypeDataSlot
-        let type_ref = zelf.downcast_ref::<PyType>().unwrap();
-        let (element_type, length, element_size) = type_ref
-            .get_type_data::<StgInfo>()
-            .map(|stg| {
-                (
-                    stg.element_type.clone().unwrap_or_else(|| vm.ctx.none()),
-                    stg.length,
-                    stg.element_size,
-                )
-            })
-            .unwrap_or_else(|| (vm.ctx.none(), 0, 0));
-        let total_size = element_size * length;
-
-        // Read data from symbol address
-        let data = if symbol_address != 0 && total_size > 0 {
-            unsafe {
-                let ptr = symbol_address as *const u8;
-                std::slice::from_raw_parts(ptr, total_size).to_vec()
+        // 2. Check for CArgObject (PyCArg_CheckExact)
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>() {
+            // Check if the wrapped object is an instance of the requested type
+            if carg.obj.is_instance(cls.as_object(), vm)? {
+                return Ok(value); // Return the CArgObject as-is
             }
-        } else {
-            vec![0; total_size]
-        };
-
-        // Create instance
-        let cdata = CDataObject::from_bytes(data, None);
-        let instance = PyCArray {
-            _base: PyCData::new(cdata.clone()),
-            typ: PyRwLock::new(element_type),
-            length: AtomicCell::new(length),
-            element_size: AtomicCell::new(element_size),
-            cdata: PyRwLock::new(cdata),
         }
-        .into_pyobject(vm);
 
-        // Store base reference to keep dll alive
-        if let Ok(array_ref) = instance.clone().downcast::<PyCArray>() {
-            array_ref.cdata.write().base = Some(dll);
+        // 3. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCArrayType::from_param(cls.as_object().to_owned(), as_parameter, vm);
         }
 
-        Ok(instance)
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
     }
 }
 
@@ -223,8 +326,28 @@ impl AsNumber for PyCArrayType {
                     .try_index(vm)?
                     .as_bigint()
                     .to_isize()
-                    .ok_or_else(|| vm.new_overflow_error("array size too large".to_owned()))?;
-                PyCArrayType::__mul__(a.to_owned(), n, vm)
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+
+                if n < 0 {
+                    return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+                }
+
+                // Check for overflow before creating the new array type
+                let zelf_type = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("Expected type"))?;
+
+                if let Some(stg_info) = zelf_type.stg_info_opt() {
+                    let current_size = stg_info.size;
+                    // Check if current_size * n would overflow
+                    if current_size != 0 && (n as usize) > isize::MAX as usize / current_size {
+                        return Err(vm.new_overflow_error("array too large"));
+                    }
+                }
+
+                // Use cached array type creation
+                // The element type of the new array is the current array type itself
+                array_type_from_ctype(a.to_owned(), n as usize, vm)
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
@@ -232,27 +355,28 @@ impl AsNumber for PyCArrayType {
     }
 }
 
+/// PyCArray - Array instance
+/// All array metadata (element_type, length, element_size) is stored in the type's StgInfo
 #[pyclass(
     name = "Array",
     base = PyCData,
     metaclass = "PyCArrayType",
     module = "_ctypes"
 )]
-pub struct PyCArray {
-    _base: PyCData,
-    /// Element type - can be a simple type (c_int) or an array type (c_int * 5)
-    pub(super) typ: PyRwLock<PyObjectRef>,
-    pub(super) length: AtomicCell<usize>,
-    pub(super) element_size: AtomicCell<usize>,
-    pub(super) cdata: PyRwLock<CDataObject>,
-}
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PyCArray(pub PyCData);
 
-impl std::fmt::Debug for PyCArray {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCArray")
-            .field("typ", &self.typ)
-            .field("length", &self.length)
-            .finish()
+impl PyCArray {
+    /// Get the type code of array element type (e.g., "c" for c_char, "u" for c_wchar)
+    fn get_element_type_code(zelf: &Py<Self>, vm: &VirtualMachine) -> Option<String> {
+        zelf.class()
+            .stg_info_opt()
+            .and_then(|info| info.element_type.clone())?
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
     }
 }
 
@@ -260,60 +384,29 @@ impl Constructor for PyCArray {
     type Args = FuncArgs;
 
     fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // Get _type_ and _length_ from the class
-        let type_attr = cls.as_object().get_attr("_type_", vm).ok();
-        let length_attr = cls.as_object().get_attr("_length_", vm).ok();
-
-        let element_type = type_attr.unwrap_or_else(|| vm.ctx.types.object_type.to_owned().into());
-        let length = if let Some(len_obj) = length_attr {
-            len_obj.try_int(vm)?.as_bigint().to_usize().unwrap_or(0)
-        } else {
-            0
+        // Check for abstract class - StgInfo must exist and be initialized
+        // Extract values in a block to drop the borrow before using cls
+        let (length, total_size) = {
+            let stg = cls.stg_info(vm)?;
+            (stg.length, stg.size)
         };
 
-        // Get element size from _type_
-        let element_size = if let Ok(type_code) = element_type.get_attr("_type_", vm) {
-            if let Ok(s) = type_code.str(vm) {
-                let s = s.to_string();
-                if s.len() == 1 {
-                    get_size(&s)
-                } else {
-                    std::mem::size_of::<usize>()
-                }
-            } else {
-                std::mem::size_of::<usize>()
-            }
-        } else {
-            std::mem::size_of::<usize>()
-        };
+        // Check for too many initializers
+        if args.args.len() > length {
+            return Err(vm.new_index_error("too many initializers"));
+        }
 
-        let total_size = element_size * length;
-        let mut buffer = vec![0u8; total_size];
+        // Create array with zero-initialized buffer
+        let buffer = vec![0u8; total_size];
+        let instance = PyCArray(PyCData::from_bytes_with_length(buffer, None, length))
+            .into_ref_with_type(vm, cls)?;
 
-        // Initialize from positional arguments
+        // Initialize elements using setitem_by_index (Array_init pattern)
         for (i, value) in args.args.iter().enumerate() {
-            if i >= length {
-                break;
-            }
-            let offset = i * element_size;
-            if let Ok(int_val) = value.try_int(vm) {
-                let bytes = PyCArray::int_to_bytes(int_val.as_bigint(), element_size);
-                if offset + element_size <= buffer.len() {
-                    buffer[offset..offset + element_size].copy_from_slice(&bytes);
-                }
-            }
+            PyCArray::setitem_by_index(&instance, i as isize, value.clone(), vm)?;
         }
 
-        let cdata = CDataObject::from_bytes(buffer, None);
-        PyCArray {
-            _base: PyCData::new(cdata.clone()),
-            typ: PyRwLock::new(element_type),
-            length: AtomicCell::new(length),
-            element_size: AtomicCell::new(element_size),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+        Ok(instance.into())
     }
 
     fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
@@ -325,15 +418,19 @@ impl AsSequence for PyCArray {
     fn as_sequence() -> &'static PySequenceMethods {
         use std::sync::LazyLock;
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
-            length: atomic_func!(|seq, _vm| Ok(PyCArray::sequence_downcast(seq).length.load())),
+            length: atomic_func!(|seq, _vm| {
+                let zelf = PyCArray::sequence_downcast(seq);
+                Ok(zelf.class().stg_info_opt().map_or(0, |i| i.length))
+            }),
             item: atomic_func!(|seq, i, vm| {
-                PyCArray::getitem_by_index(PyCArray::sequence_downcast(seq), i, vm)
+                let zelf = PyCArray::sequence_downcast(seq);
+                PyCArray::getitem_by_index(zelf, i, vm)
             }),
             ass_item: atomic_func!(|seq, i, value, vm| {
                 let zelf = PyCArray::sequence_downcast(seq);
                 match value {
                     Some(v) => PyCArray::setitem_by_index(zelf, i, v, vm),
-                    None => Err(vm.new_type_error("cannot delete array elements".to_owned())),
+                    None => Err(vm.new_type_error("cannot delete array elements")),
                 }
             }),
             ..PySequenceMethods::NOT_IMPLEMENTED
@@ -347,468 +444,839 @@ impl AsSequence for PyCArray {
     with(Constructor, AsSequence, AsBuffer)
 )]
 impl PyCArray {
-    #[pygetset]
-    fn _objects(&self) -> Option<PyObjectRef> {
-        self.cdata.read().objects.clone()
-    }
-
     fn int_to_bytes(i: &malachite_bigint::BigInt, size: usize) -> Vec<u8> {
+        // Try unsigned first (handles values like 0xFFFFFFFF that overflow signed)
+        // then fall back to signed (handles negative values)
         match size {
-            1 => vec![i.to_i8().unwrap_or(0) as u8],
-            2 => i.to_i16().unwrap_or(0).to_ne_bytes().to_vec(),
-            4 => i.to_i32().unwrap_or(0).to_ne_bytes().to_vec(),
-            8 => i.to_i64().unwrap_or(0).to_ne_bytes().to_vec(),
+            1 => {
+                if let Some(v) = i.to_u8() {
+                    vec![v]
+                } else {
+                    vec![i.to_i8().unwrap_or(0) as u8]
+                }
+            }
+            2 => {
+                if let Some(v) = i.to_u16() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i16().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
+            4 => {
+                if let Some(v) = i.to_u32() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i32().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
+            8 => {
+                if let Some(v) = i.to_u64() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i64().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
             _ => vec![0u8; size],
         }
     }
 
-    fn bytes_to_int(bytes: &[u8], size: usize, vm: &VirtualMachine) -> PyObjectRef {
-        match size {
-            1 => vm.ctx.new_int(bytes[0] as i8).into(),
-            2 => {
+    fn bytes_to_int(
+        bytes: &[u8],
+        size: usize,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyObjectRef {
+        // Unsigned type codes: B (uchar), H (ushort), I (uint), L (ulong), Q (ulonglong)
+        let is_unsigned = matches!(
+            type_code,
+            Some("B") | Some("H") | Some("I") | Some("L") | Some("Q")
+        );
+
+        match (size, is_unsigned) {
+            (1, false) => vm.ctx.new_int(bytes[0] as i8).into(),
+            (1, true) => vm.ctx.new_int(bytes[0]).into(),
+            (2, false) => {
                 let val = i16::from_ne_bytes([bytes[0], bytes[1]]);
                 vm.ctx.new_int(val).into()
             }
-            4 => {
+            (2, true) => {
+                let val = u16::from_ne_bytes([bytes[0], bytes[1]]);
+                vm.ctx.new_int(val).into()
+            }
+            (4, false) => {
                 let val = i32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
                 vm.ctx.new_int(val).into()
             }
-            8 => {
+            (4, true) => {
+                let val = u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
+                vm.ctx.new_int(val).into()
+            }
+            (8, false) => {
                 let val = i64::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
                 ]);
                 vm.ctx.new_int(val).into()
             }
+            (8, true) => {
+                let val = u64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ]);
+                vm.ctx.new_int(val).into()
+            }
             _ => vm.ctx.new_int(0).into(),
         }
     }
 
-    fn getitem_by_index(zelf: &PyCArray, i: isize, vm: &VirtualMachine) -> PyResult {
-        let length = zelf.length.load() as isize;
+    fn getitem_by_index(zelf: &Py<PyCArray>, i: isize, vm: &VirtualMachine) -> PyResult {
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length) as isize;
         let index = if i < 0 { length + i } else { i };
         if index < 0 || index >= length {
-            return Err(vm.new_index_error("array index out of range".to_owned()));
+            return Err(vm.new_index_error("invalid index"));
         }
         let index = index as usize;
-        let element_size = zelf.element_size.load();
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
         let offset = index * element_size;
-        let buffer = zelf.cdata.read().buffer.clone();
-        if offset + element_size <= buffer.len() {
-            let bytes = &buffer[offset..offset + element_size];
-            Ok(Self::bytes_to_int(bytes, element_size, vm))
+        let type_code = Self::get_element_type_code(zelf, vm);
+
+        // Get target buffer and offset (base's buffer if available, otherwise own)
+        let base_obj = zelf.0.base.read().clone();
+        let (buffer_lock, final_offset) = if let Some(cdata) = base_obj
+            .as_ref()
+            .and_then(|b| b.downcast_ref::<super::PyCData>())
+        {
+            (&cdata.buffer, zelf.0.base_offset.load() + offset)
         } else {
-            Ok(vm.ctx.new_int(0).into())
+            (&zelf.0.buffer, offset)
+        };
+
+        let buffer = buffer_lock.read();
+        Self::read_element_from_buffer(
+            &buffer,
+            final_offset,
+            element_size,
+            type_code.as_deref(),
+            vm,
+        )
+    }
+
+    /// Helper to read an element value from a buffer at given offset
+    fn read_element_from_buffer(
+        buffer: &[u8],
+        offset: usize,
+        element_size: usize,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match type_code {
+            Some("c") => {
+                // Return single byte as bytes
+                if offset < buffer.len() {
+                    Ok(vm.ctx.new_bytes(vec![buffer[offset]]).into())
+                } else {
+                    Ok(vm.ctx.new_bytes(vec![0]).into())
+                }
+            }
+            Some("u") => {
+                // Return single wchar as str
+                if let Some(code) = wchar_from_bytes(&buffer[offset..]) {
+                    let s = char::from_u32(code)
+                        .map(|c| c.to_string())
+                        .unwrap_or_default();
+                    Ok(vm.ctx.new_str(s).into())
+                } else {
+                    Ok(vm.ctx.new_str("").into())
+                }
+            }
+            Some("z") => {
+                // c_char_p: pointer to bytes - dereference to get string
+                if offset + element_size > buffer.len() {
+                    return Ok(vm.ctx.none());
+                }
+                let ptr_bytes = &buffer[offset..offset + element_size];
+                let ptr_val = usize::from_ne_bytes(
+                    ptr_bytes
+                        .try_into()
+                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                );
+                if ptr_val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                // Read null-terminated string from pointer address
+                unsafe {
+                    let ptr = ptr_val as *const u8;
+                    let mut len = 0;
+                    while *ptr.add(len) != 0 {
+                        len += 1;
+                    }
+                    let bytes = std::slice::from_raw_parts(ptr, len);
+                    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+                }
+            }
+            Some("Z") => {
+                // c_wchar_p: pointer to wchar_t - dereference to get string
+                if offset + element_size > buffer.len() {
+                    return Ok(vm.ctx.none());
+                }
+                let ptr_bytes = &buffer[offset..offset + element_size];
+                let ptr_val = usize::from_ne_bytes(
+                    ptr_bytes
+                        .try_into()
+                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                );
+                if ptr_val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                // Read null-terminated wide string using WCHAR_SIZE
+                unsafe {
+                    let ptr = ptr_val as *const u8;
+                    let mut chars = Vec::new();
+                    let mut pos = 0usize;
+                    loop {
+                        let code = if WCHAR_SIZE == 2 {
+                            let bytes = std::slice::from_raw_parts(ptr.add(pos), 2);
+                            u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+                        } else {
+                            let bytes = std::slice::from_raw_parts(ptr.add(pos), 4);
+                            u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+                        };
+                        if code == 0 {
+                            break;
+                        }
+                        if let Some(ch) = char::from_u32(code) {
+                            chars.push(ch);
+                        }
+                        pos += WCHAR_SIZE;
+                    }
+                    let s: String = chars.into_iter().collect();
+                    Ok(vm.ctx.new_str(s).into())
+                }
+            }
+            Some("f") => {
+                // c_float
+                if offset + 4 <= buffer.len() {
+                    let bytes: [u8; 4] = buffer[offset..offset + 4].try_into().unwrap();
+                    let val = f32::from_ne_bytes(bytes);
+                    Ok(vm.ctx.new_float(val as f64).into())
+                } else {
+                    Ok(vm.ctx.new_float(0.0).into())
+                }
+            }
+            Some("d") | Some("g") => {
+                // c_double / c_longdouble - read f64 from first 8 bytes
+                if offset + 8 <= buffer.len() {
+                    let bytes: [u8; 8] = buffer[offset..offset + 8].try_into().unwrap();
+                    let val = f64::from_ne_bytes(bytes);
+                    Ok(vm.ctx.new_float(val).into())
+                } else {
+                    Ok(vm.ctx.new_float(0.0).into())
+                }
+            }
+            _ => {
+                if offset + element_size <= buffer.len() {
+                    let bytes = &buffer[offset..offset + element_size];
+                    Ok(Self::bytes_to_int(bytes, element_size, type_code, vm))
+                } else {
+                    Ok(vm.ctx.new_int(0).into())
+                }
+            }
         }
     }
 
+    /// Helper to write an element value to a buffer at given offset
+    /// This is extracted to share code between direct write and base-buffer write
+    #[allow(clippy::too_many_arguments)]
+    fn write_element_to_buffer(
+        buffer: &mut [u8],
+        offset: usize,
+        element_size: usize,
+        type_code: Option<&str>,
+        value: &PyObject,
+        zelf: &Py<PyCArray>,
+        index: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match type_code {
+            Some("c") => {
+                if let Some(b) = value.downcast_ref::<PyBytes>() {
+                    if offset < buffer.len() {
+                        buffer[offset] = b.as_bytes().first().copied().unwrap_or(0);
+                    }
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    if offset < buffer.len() {
+                        buffer[offset] = int_val.as_bigint().to_u8().unwrap_or(0);
+                    }
+                } else {
+                    return Err(vm.new_type_error("an integer or bytes of length 1 is required"));
+                }
+            }
+            Some("u") => {
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let code = s.as_str().chars().next().map(|c| c as u32).unwrap_or(0);
+                    if offset + WCHAR_SIZE <= buffer.len() {
+                        wchar_to_bytes(code, &mut buffer[offset..]);
+                    }
+                } else {
+                    return Err(vm.new_type_error("unicode string expected"));
+                }
+            }
+            Some("z") => {
+                let (ptr_val, converted) = if value.is(&vm.ctx.none) {
+                    (0usize, None)
+                } else if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (c, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    (ptr, Some(c))
+                } else if let Ok(int_val) = value.try_index(vm) {
+                    (int_val.as_bigint().to_usize().unwrap_or(0), None)
+                } else {
+                    return Err(vm.new_type_error(
+                        "bytes or integer address expected instead of {}".to_owned(),
+                    ));
+                };
+                if offset + element_size <= buffer.len() {
+                    buffer[offset..offset + element_size].copy_from_slice(&ptr_val.to_ne_bytes());
+                }
+                if let Some(c) = converted {
+                    return zelf.0.keep_ref(index, c, vm);
+                }
+            }
+            Some("Z") => {
+                let (ptr_val, converted) = if value.is(&vm.ctx.none) {
+                    (0usize, None)
+                } else if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    (ptr, Some(holder))
+                } else if let Ok(int_val) = value.try_index(vm) {
+                    (int_val.as_bigint().to_usize().unwrap_or(0), None)
+                } else {
+                    return Err(vm.new_type_error("unicode string or integer address expected"));
+                };
+                if offset + element_size <= buffer.len() {
+                    buffer[offset..offset + element_size].copy_from_slice(&ptr_val.to_ne_bytes());
+                }
+                if let Some(c) = converted {
+                    return zelf.0.keep_ref(index, c, vm);
+                }
+            }
+            Some("f") => {
+                // c_float: convert int/float to f32 bytes
+                let f32_val = if let Ok(float_val) = value.try_float(vm) {
+                    float_val.to_f64() as f32
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_f64().unwrap_or(0.0) as f32
+                } else {
+                    return Err(vm.new_type_error("a float is required"));
+                };
+                if offset + 4 <= buffer.len() {
+                    buffer[offset..offset + 4].copy_from_slice(&f32_val.to_ne_bytes());
+                }
+            }
+            Some("d") | Some("g") => {
+                // c_double / c_longdouble: convert int/float to f64 bytes
+                let f64_val = if let Ok(float_val) = value.try_float(vm) {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_f64().unwrap_or(0.0)
+                } else {
+                    return Err(vm.new_type_error("a float is required"));
+                };
+                if offset + 8 <= buffer.len() {
+                    buffer[offset..offset + 8].copy_from_slice(&f64_val.to_ne_bytes());
+                }
+                // For "g" type, remaining bytes stay zero
+            }
+            _ => {
+                // Handle ctypes instances (copy their buffer)
+                if let Some(cdata) = value.downcast_ref::<PyCData>() {
+                    let src_buffer = cdata.buffer.read();
+                    let copy_len = src_buffer.len().min(element_size);
+                    if offset + copy_len <= buffer.len() {
+                        buffer[offset..offset + copy_len].copy_from_slice(&src_buffer[..copy_len]);
+                    }
+                // Other types: use int_to_bytes
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    let bytes = Self::int_to_bytes(int_val.as_bigint(), element_size);
+                    if offset + element_size <= buffer.len() {
+                        buffer[offset..offset + element_size].copy_from_slice(&bytes);
+                    }
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "expected {} instance, not {}",
+                        type_code.unwrap_or("value"),
+                        value.class().name()
+                    )));
+                }
+            }
+        }
+
+        // KeepRef
+        if super::base::PyCData::should_keep_ref(value) {
+            let to_keep = super::base::PyCData::get_kept_objects(value, vm);
+            zelf.0.keep_ref(index, to_keep, vm)?;
+        }
+
+        Ok(())
+    }
+
     fn setitem_by_index(
-        zelf: &PyCArray,
+        zelf: &Py<PyCArray>,
         i: isize,
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let length = zelf.length.load() as isize;
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length) as isize;
         let index = if i < 0 { length + i } else { i };
         if index < 0 || index >= length {
-            return Err(vm.new_index_error("array index out of range".to_owned()));
+            return Err(vm.new_index_error("invalid index"));
         }
         let index = index as usize;
-        let element_size = zelf.element_size.load();
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
         let offset = index * element_size;
+        let type_code = Self::get_element_type_code(zelf, vm);
+
+        // Get target buffer and offset (base's buffer if available, otherwise own)
+        let base_obj = zelf.0.base.read().clone();
+        let (buffer_lock, final_offset) = if let Some(cdata) = base_obj
+            .as_ref()
+            .and_then(|b| b.downcast_ref::<super::PyCData>())
+        {
+            (&cdata.buffer, zelf.0.base_offset.load() + offset)
+        } else {
+            (&zelf.0.buffer, offset)
+        };
 
-        let int_val = value.try_int(vm)?;
-        let bytes = Self::int_to_bytes(int_val.as_bigint(), element_size);
-
-        let mut cdata = zelf.cdata.write();
-        if offset + element_size <= cdata.buffer.len() {
-            cdata.buffer[offset..offset + element_size].copy_from_slice(&bytes);
-        }
-        Ok(())
+        let mut buffer = buffer_lock.write();
+        Self::write_element_to_buffer(
+            buffer.to_mut(),
+            final_offset,
+            element_size,
+            type_code.as_deref(),
+            &value,
+            zelf,
+            index,
+            vm,
+        )
     }
 
+    // Array_subscript
     #[pymethod]
-    fn __getitem__(&self, index: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        if let Some(i) = index.downcast_ref::<PyInt>() {
+    fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
             let i = i.as_bigint().to_isize().ok_or_else(|| {
-                vm.new_index_error("cannot fit index into an index-sized integer".to_owned())
+                vm.new_index_error("cannot fit index into an index-sized integer")
             })?;
-            Self::getitem_by_index(self, i, vm)
+            // getitem_by_index handles negative index normalization
+            Self::getitem_by_index(zelf, i, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::getitem_by_slice(zelf, slice, vm)
         } else {
-            Err(vm.new_type_error("array indices must be integers".to_owned()))
+            Err(vm.new_type_error("indices must be integers"))
+        }
+    }
+
+    // Array_subscript slice handling
+    fn getitem_by_slice(zelf: &Py<Self>, slice: &PySlice, vm: &VirtualMachine) -> PyResult {
+        use crate::sliceable::SaturatedSliceIter;
+
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length);
+
+        // PySlice_Unpack + PySlice_AdjustIndices
+        let sat_slice = slice.to_saturated(vm)?;
+        let (range, step, slice_len) = sat_slice.adjust_indices(length);
+
+        let type_code = Self::get_element_type_code(zelf, vm);
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
+        let start = range.start;
+
+        match type_code.as_deref() {
+            // c_char → bytes (item_info->getfunc == "c")
+            Some("c") => {
+                if slice_len == 0 {
+                    return Ok(vm.ctx.new_bytes(vec![]).into());
+                }
+                let buffer = zelf.0.buffer.read();
+                // step == 1 optimization: direct memcpy
+                if step == 1 {
+                    let start_offset = start * element_size;
+                    let end_offset = start_offset + slice_len;
+                    if end_offset <= buffer.len() {
+                        return Ok(vm
+                            .ctx
+                            .new_bytes(buffer[start_offset..end_offset].to_vec())
+                            .into());
+                    }
+                }
+                // Non-contiguous: iterate
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = Vec::with_capacity(slice_len);
+                for idx in iter {
+                    let offset = idx * element_size;
+                    if offset < buffer.len() {
+                        result.push(buffer[offset]);
+                    }
+                }
+                Ok(vm.ctx.new_bytes(result).into())
+            }
+            // c_wchar → str (item_info->getfunc == "u")
+            Some("u") => {
+                if slice_len == 0 {
+                    return Ok(vm.ctx.new_str("").into());
+                }
+                let buffer = zelf.0.buffer.read();
+                // step == 1 optimization: direct conversion
+                if step == 1 {
+                    let start_offset = start * WCHAR_SIZE;
+                    let end_offset = start_offset + slice_len * WCHAR_SIZE;
+                    if end_offset <= buffer.len() {
+                        let wchar_bytes = &buffer[start_offset..end_offset];
+                        let result: String = wchar_bytes
+                            .chunks(WCHAR_SIZE)
+                            .filter_map(|chunk| wchar_from_bytes(chunk).and_then(char::from_u32))
+                            .collect();
+                        return Ok(vm.ctx.new_str(result).into());
+                    }
+                }
+                // Non-contiguous: iterate
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = String::with_capacity(slice_len);
+                for idx in iter {
+                    let offset = idx * WCHAR_SIZE;
+                    if let Some(code_point) = wchar_from_bytes(&buffer[offset..])
+                        && let Some(c) = char::from_u32(code_point)
+                    {
+                        result.push(c);
+                    }
+                }
+                Ok(vm.ctx.new_str(result).into())
+            }
+            // Other types → list (PyList_New + Array_item for each)
+            _ => {
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = Vec::with_capacity(slice_len);
+                for idx in iter {
+                    result.push(Self::getitem_by_index(zelf, idx as isize, vm)?);
+                }
+                Ok(PyList::from(result).into_ref(&vm.ctx).into())
+            }
         }
     }
 
+    // Array_ass_subscript
     #[pymethod]
     fn __setitem__(
-        &self,
-        index: PyObjectRef,
+        zelf: &Py<Self>,
+        item: PyObjectRef,
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        if let Some(i) = index.downcast_ref::<PyInt>() {
+        // Array does not support item deletion
+        // (handled implicitly - value is always provided in __setitem__)
+
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
             let i = i.as_bigint().to_isize().ok_or_else(|| {
-                vm.new_index_error("cannot fit index into an index-sized integer".to_owned())
+                vm.new_index_error("cannot fit index into an index-sized integer")
             })?;
-            Self::setitem_by_index(self, i, value, vm)
+            // setitem_by_index handles negative index normalization
+            Self::setitem_by_index(zelf, i, value, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::setitem_by_slice(zelf, slice, value, vm)
         } else {
-            Err(vm.new_type_error("array indices must be integers".to_owned()))
+            Err(vm.new_type_error("indices must be integer"))
         }
     }
 
+    // Array does not support item deletion
     #[pymethod]
-    fn __len__(&self) -> usize {
-        self.length.load()
+    fn __delitem__(&self, _item: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        Err(vm.new_type_error("Array does not support item deletion"))
     }
 
-    #[pygetset(name = "_type_")]
-    fn typ(&self) -> PyObjectRef {
-        self.typ.read().clone()
-    }
+    // Array_ass_subscript slice handling
+    fn setitem_by_slice(
+        zelf: &Py<Self>,
+        slice: &PySlice,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use crate::sliceable::SaturatedSliceIter;
 
-    #[pygetset(name = "_length_")]
-    fn length_getter(&self) -> usize {
-        self.length.load()
-    }
+        let length = zelf.class().stg_info_opt().map_or(0, |i| i.length);
 
-    #[pygetset]
-    fn value(&self, vm: &VirtualMachine) -> PyObjectRef {
-        // Return bytes representation of the buffer
-        let buffer = self.cdata.read().buffer.clone();
-        vm.ctx.new_bytes(buffer.clone()).into()
-    }
+        // PySlice_Unpack + PySlice_AdjustIndices
+        let sat_slice = slice.to_saturated(vm)?;
+        let (range, step, slice_len) = sat_slice.adjust_indices(length);
 
-    #[pygetset(setter)]
-    fn set_value(&self, value: PyObjectRef, _vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(bytes) = value.downcast_ref::<PyBytes>() {
-            let mut cdata = self.cdata.write();
-            let src = bytes.as_bytes();
-            let len = std::cmp::min(src.len(), cdata.buffer.len());
-            cdata.buffer[..len].copy_from_slice(&src[..len]);
+        // other_len = PySequence_Length(value);
+        let items: Vec<PyObjectRef> = vm.extract_elements_with(&value, Ok)?;
+        let other_len = items.len();
+
+        if other_len != slice_len {
+            return Err(vm.new_value_error("Can only assign sequence of same size"));
         }
-        Ok(())
-    }
 
-    #[pygetset]
-    fn raw(&self, vm: &VirtualMachine) -> PyObjectRef {
-        let cdata = self.cdata.read();
-        vm.ctx.new_bytes(cdata.buffer.clone()).into()
-    }
+        // Use SaturatedSliceIter for correct index iteration (handles negative step)
+        let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
 
-    #[pygetset(setter)]
-    fn set_raw(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(bytes) = value.downcast_ref::<PyBytes>() {
-            let mut cdata = self.cdata.write();
-            let src = bytes.as_bytes();
-            let len = std::cmp::min(src.len(), cdata.buffer.len());
-            cdata.buffer[..len].copy_from_slice(&src[..len]);
-            Ok(())
-        } else {
-            Err(vm.new_type_error("expected bytes".to_owned()))
+        for (idx, item) in iter.zip(items) {
+            Self::setitem_by_index(zelf, idx as isize, item, vm)?;
         }
+        Ok(())
     }
 
-    #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
+    #[pymethod]
+    fn __len__(zelf: &Py<Self>, _vm: &VirtualMachine) -> usize {
+        zelf.class().stg_info_opt().map_or(0, |i| i.length)
+    }
+}
 
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
+impl PyCArray {
+    #[allow(unused)]
+    pub fn to_arg(&self, _vm: &VirtualMachine) -> PyResult<libffi::middle::Arg> {
+        let buffer = self.0.buffer.read();
+        Ok(libffi::middle::Arg::new(&*buffer))
+    }
+}
 
-        // Create instance with data from address
-        if address == 0 || size == 0 {
-            return Err(vm.new_value_error("NULL pointer access".to_owned()));
-        }
-        unsafe {
-            let ptr = address as *const u8;
-            let bytes = std::slice::from_raw_parts(ptr, size);
-            // Get element type and length from cls
-            let element_type = cls.as_object().get_attr("_type_", vm)?;
-            let element_type: PyTypeRef = element_type
-                .downcast()
-                .map_err(|_| vm.new_type_error("_type_ must be a type".to_owned()))?;
-            let length = cls
-                .as_object()
-                .get_attr("_length_", vm)?
-                .try_int(vm)?
-                .as_bigint()
-                .to_usize()
-                .unwrap_or(0);
-            let element_size = if length > 0 { size / length } else { 0 };
-
-            let cdata = CDataObject::from_bytes(bytes.to_vec(), None);
-            Ok(PyCArray {
-                _base: PyCData::new(cdata.clone()),
-                typ: PyRwLock::new(element_type.into()),
-                length: AtomicCell::new(length),
-                element_size: AtomicCell::new(element_size),
-                cdata: PyRwLock::new(cdata),
+impl AsBuffer for PyCArray {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // Get format and shape from type's StgInfo
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCArray type must have StgInfo");
+        let format = stg_info.format.clone();
+        let shape = stg_info.shape.clone();
+        let element_size = stg_info.element_size;
+
+        let desc = if let Some(fmt) = format
+            && !shape.is_empty()
+        {
+            // Build dim_desc from shape (C-contiguous: row-major order)
+            // stride[i] = product(shape[i+1:]) * itemsize
+            let mut dim_desc = Vec::with_capacity(shape.len());
+            let mut stride = element_size as isize;
+
+            // Calculate strides from innermost to outermost dimension
+            for &dim_size in shape.iter().rev() {
+                dim_desc.push((dim_size, stride, 0));
+                stride *= dim_size as isize;
             }
-            .into_pyobject(vm))
-        }
-    }
+            dim_desc.reverse();
+
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize: element_size,
+                format: std::borrow::Cow::Owned(fmt),
+                dim_desc,
+            }
+        } else {
+            // Fallback to simple buffer if no format/shape info
+            BufferDescriptor::simple(buffer_len, false)
+        };
 
-    #[pyclassmethod]
-    fn from_buffer(
-        cls: PyTypeRef,
-        source: PyObjectRef,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::TryFromObject;
-        use crate::protocol::PyBuffer;
-        use crate::stdlib::ctypes::_ctypes::size_of;
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
 
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
+// CharArray and WCharArray getsets - added dynamically via add_getset
 
-        // Get buffer from source
-        let buffer = PyBuffer::try_from_object(vm, source.clone())?;
+// CharArray_get_value
+fn char_array_get_value(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    let len = buffer.iter().position(|&b| b == 0).unwrap_or(buffer.len());
+    Ok(vm.ctx.new_bytes(buffer[..len].to_vec()).into())
+}
 
-        // Check if buffer is writable
-        if buffer.desc.readonly {
-            return Err(vm.new_type_error("underlying buffer is not writable".to_owned()));
-        }
+// CharArray_set_value
+fn char_array_set_value(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let bytes = value
+        .downcast_ref::<PyBytes>()
+        .ok_or_else(|| vm.new_type_error("bytes expected"))?;
+    let mut buffer = zelf.0.buffer.write();
+    let src = bytes.as_bytes();
+
+    if src.len() > buffer.len() {
+        return Err(vm.new_value_error("byte string too long"));
+    }
 
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Check if buffer is large enough
-        let buffer_len = buffer.desc.len;
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
-        }
+    buffer.to_mut()[..src.len()].copy_from_slice(src);
+    if src.len() < buffer.len() {
+        buffer.to_mut()[src.len()] = 0;
+    }
+    Ok(())
+}
 
-        // Read bytes from buffer at offset
-        let bytes = buffer.obj_bytes();
-        let data = &bytes[offset..offset + size];
+// CharArray_get_raw
+fn char_array_get_raw(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    Ok(vm.ctx.new_bytes(buffer.to_vec()).into())
+}
 
-        // Get element type and length from cls
-        let element_type = cls.as_object().get_attr("_type_", vm)?;
-        let element_type: PyTypeRef = element_type
-            .downcast()
-            .map_err(|_| vm.new_type_error("_type_ must be a type".to_owned()))?;
-        let length = cls
-            .as_object()
-            .get_attr("_length_", vm)?
-            .try_int(vm)?
-            .as_bigint()
-            .to_usize()
-            .unwrap_or(0);
-        let element_size = if length > 0 { size / length } else { 0 };
-
-        let cdata = CDataObject::from_bytes(data.to_vec(), Some(buffer.obj.clone()));
-        Ok(PyCArray {
-            _base: PyCData::new(cdata.clone()),
-            typ: PyRwLock::new(element_type.into()),
-            length: AtomicCell::new(length),
-            element_size: AtomicCell::new(element_size),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_pyobject(vm))
+// CharArray_set_raw
+fn char_array_set_raw(
+    obj: PyObjectRef,
+    value: PySetterValue<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let value = value.ok_or_else(|| vm.new_attribute_error("cannot delete attribute"))?;
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let bytes_like = ArgBytesLike::try_from_object(vm, value)?;
+    let mut buffer = zelf.0.buffer.write();
+    let src = bytes_like.borrow_buf();
+    if src.len() > buffer.len() {
+        return Err(vm.new_value_error("byte string too long"));
     }
+    buffer.to_mut()[..src.len()].copy_from_slice(&src);
+    Ok(())
+}
 
-    #[pyclassmethod]
-    fn from_buffer_copy(
-        cls: PyTypeRef,
-        source: crate::function::ArgBytesLike,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
-
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Borrow bytes from source
-        let source_bytes = source.borrow_buf();
-        let buffer_len = source_bytes.len();
-
-        // Check if buffer is large enough
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
-        }
+// WCharArray_get_value
+fn wchar_array_get_value(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    Ok(vm.ctx.new_str(wstring_from_bytes(&buffer)).into())
+}
 
-        // Copy bytes from buffer at offset
-        let data = &source_bytes[offset..offset + size];
+// WCharArray_set_value
+fn wchar_array_set_value(
+    obj: PyObjectRef,
+    value: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let s = value
+        .downcast_ref::<PyStr>()
+        .ok_or_else(|| vm.new_type_error("unicode string expected"))?;
+    let mut buffer = zelf.0.buffer.write();
+    let wchar_count = buffer.len() / WCHAR_SIZE;
+    let char_count = s.as_str().chars().count();
+
+    if char_count > wchar_count {
+        return Err(vm.new_value_error("string too long"));
+    }
 
-        // Get element type and length from cls
-        let element_type = cls.as_object().get_attr("_type_", vm)?;
-        let element_type: PyTypeRef = element_type
-            .downcast()
-            .map_err(|_| vm.new_type_error("_type_ must be a type".to_owned()))?;
-        let length = cls
-            .as_object()
-            .get_attr("_length_", vm)?
-            .try_int(vm)?
-            .as_bigint()
-            .to_usize()
-            .unwrap_or(0);
-        let element_size = if length > 0 { size / length } else { 0 };
-
-        let cdata = CDataObject::from_bytes(data.to_vec(), None);
-        Ok(PyCArray {
-            _base: PyCData::new(cdata.clone()),
-            typ: PyRwLock::new(element_type.into()),
-            length: AtomicCell::new(length),
-            element_size: AtomicCell::new(element_size),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_pyobject(vm))
+    for (i, ch) in s.as_str().chars().enumerate() {
+        let offset = i * WCHAR_SIZE;
+        wchar_to_bytes(ch as u32, &mut buffer.to_mut()[offset..]);
     }
 
-    #[pyclassmethod]
-    fn in_dll(
-        cls: PyTypeRef,
-        dll: PyObjectRef,
-        name: crate::builtins::PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
-        use libloading::Symbol;
-
-        // Get the library handle from dll object
-        let handle = if let Ok(int_handle) = dll.try_int(vm) {
-            // dll is an integer handle
-            int_handle
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        } else {
-            // dll is a CDLL/PyDLL/WinDLL object with _handle attribute
-            dll.get_attr("_handle", vm)?
-                .try_int(vm)?
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        };
+    let terminator_offset = char_count * WCHAR_SIZE;
+    if terminator_offset + WCHAR_SIZE <= buffer.len() {
+        wchar_to_bytes(0, &mut buffer.to_mut()[terminator_offset..]);
+    }
+    Ok(())
+}
 
-        // Get the library from cache
-        let library_cache = crate::stdlib::ctypes::library::libcache().read();
-        let library = library_cache
-            .get_lib(handle)
-            .ok_or_else(|| vm.new_attribute_error("Library not found".to_owned()))?;
-
-        // Get symbol address from library
-        let symbol_name = format!("{}\0", name.as_str());
-        let inner_lib = library.lib.lock();
-
-        let symbol_address = if let Some(lib) = &*inner_lib {
-            unsafe {
-                // Try to get the symbol from the library
-                let symbol: Symbol<'_, *mut u8> = lib.get(symbol_name.as_bytes()).map_err(|e| {
-                    vm.new_attribute_error(format!("{}: symbol '{}' not found", e, name.as_str()))
-                })?;
-                *symbol as usize
-            }
-        } else {
-            return Err(vm.new_attribute_error("Library is closed".to_owned()));
-        };
+/// add_getset for c_char arrays - adds 'value' and 'raw' attributes
+/// add_getset((PyTypeObject*)self, CharArray_getsets)
+fn add_char_array_getsets(array_type: &Py<PyType>, vm: &VirtualMachine) {
+    // SAFETY: getset is owned by array_type which outlives the getset
+    let value_getset = unsafe {
+        vm.ctx.new_getset(
+            "value",
+            array_type,
+            char_array_get_value,
+            char_array_set_value,
+        )
+    };
+    let raw_getset = unsafe {
+        vm.ctx
+            .new_getset("raw", array_type, char_array_get_raw, char_array_set_raw)
+    };
+
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("value"), value_getset.into());
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("raw"), raw_getset.into());
+}
 
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
+/// add_getset for c_wchar arrays - adds only 'value' attribute (no 'raw')
+fn add_wchar_array_getsets(array_type: &Py<PyType>, vm: &VirtualMachine) {
+    // SAFETY: getset is owned by array_type which outlives the getset
+    let value_getset = unsafe {
+        vm.ctx.new_getset(
+            "value",
+            array_type,
+            wchar_array_get_value,
+            wchar_array_set_value,
+        )
+    };
 
-        // Read data from symbol address
-        let data = if symbol_address != 0 && size > 0 {
-            unsafe {
-                let ptr = symbol_address as *const u8;
-                std::slice::from_raw_parts(ptr, size).to_vec()
-            }
-        } else {
-            vec![0; size]
-        };
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("value"), value_getset.into());
+}
 
-        // Get element type and length from cls
-        let element_type = cls.as_object().get_attr("_type_", vm)?;
-        let element_type: PyTypeRef = element_type
-            .downcast()
-            .map_err(|_| vm.new_type_error("_type_ must be a type".to_owned()))?;
-        let length = cls
-            .as_object()
-            .get_attr("_length_", vm)?
-            .try_int(vm)?
-            .as_bigint()
-            .to_usize()
-            .unwrap_or(0);
-        let element_size = if length > 0 { size / length } else { 0 };
-
-        // Create instance
-        let cdata = CDataObject::from_bytes(data, None);
-        let instance = PyCArray {
-            _base: PyCData::new(cdata.clone()),
-            typ: PyRwLock::new(element_type.into()),
-            length: AtomicCell::new(length),
-            element_size: AtomicCell::new(element_size),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_pyobject(vm);
+// wchar_t helpers - Platform-independent wide character handling
+// Windows: sizeof(wchar_t) == 2 (UTF-16)
+// Linux/macOS: sizeof(wchar_t) == 4 (UTF-32)
 
-        // Store base reference to keep dll alive
-        if let Ok(array_ref) = instance.clone().downcast::<PyCArray>() {
-            array_ref.cdata.write().base = Some(dll);
-        }
+/// Size of wchar_t on this platform
+pub(super) const WCHAR_SIZE: usize = std::mem::size_of::<libc::wchar_t>();
 
-        Ok(instance)
+/// Read a single wchar_t from bytes (platform-endian)
+#[inline]
+pub(super) fn wchar_from_bytes(bytes: &[u8]) -> Option<u32> {
+    if bytes.len() < WCHAR_SIZE {
+        return None;
     }
+    Some(if WCHAR_SIZE == 2 {
+        u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+    } else {
+        u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+    })
 }
 
-impl PyCArray {
-    #[allow(unused)]
-    pub fn to_arg(&self, _vm: &VirtualMachine) -> PyResult<libffi::middle::Arg> {
-        let cdata = self.cdata.read();
-        Ok(libffi::middle::Arg::new(&cdata.buffer))
+/// Write a single wchar_t to bytes (platform-endian)
+#[inline]
+pub(super) fn wchar_to_bytes(ch: u32, buffer: &mut [u8]) {
+    if WCHAR_SIZE == 2 {
+        if buffer.len() >= 2 {
+            buffer[..2].copy_from_slice(&(ch as u16).to_ne_bytes());
+        }
+    } else if buffer.len() >= 4 {
+        buffer[..4].copy_from_slice(&ch.to_ne_bytes());
     }
 }
 
-static ARRAY_BUFFER_METHODS: BufferMethods = BufferMethods {
-    obj_bytes: |buffer| {
-        rustpython_common::lock::PyMappedRwLockReadGuard::map(
-            rustpython_common::lock::PyRwLockReadGuard::map(
-                buffer.obj_as::<PyCArray>().cdata.read(),
-                |x: &CDataObject| x,
-            ),
-            |x: &CDataObject| x.buffer.as_slice(),
-        )
-        .into()
-    },
-    obj_bytes_mut: |buffer| {
-        rustpython_common::lock::PyMappedRwLockWriteGuard::map(
-            rustpython_common::lock::PyRwLockWriteGuard::map(
-                buffer.obj_as::<PyCArray>().cdata.write(),
-                |x: &mut CDataObject| x,
-            ),
-            |x: &mut CDataObject| x.buffer.as_mut_slice(),
-        )
-        .into()
-    },
-    release: |_| {},
-    retain: |_| {},
-};
-
-impl AsBuffer for PyCArray {
-    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-        let buffer_len = zelf.cdata.read().buffer.len();
-        let buf = PyBuffer::new(
-            zelf.to_owned().into(),
-            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
-            &ARRAY_BUFFER_METHODS,
-        );
-        Ok(buf)
+/// Read a null-terminated wchar_t string from bytes, returns String
+fn wstring_from_bytes(buffer: &[u8]) -> String {
+    let mut chars = Vec::new();
+    for chunk in buffer.chunks(WCHAR_SIZE) {
+        if chunk.len() < WCHAR_SIZE {
+            break;
+        }
+        let code = if WCHAR_SIZE == 2 {
+            u16::from_ne_bytes([chunk[0], chunk[1]]) as u32
+        } else {
+            u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])
+        };
+        if code == 0 {
+            break; // null terminator
+        }
+        if let Some(ch) = char::from_u32(code) {
+            chars.push(ch);
+        }
     }
+    chars.into_iter().collect()
 }
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index e45ff0b3b70..38c371346e0 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -1,871 +1,1113 @@
-use super::_ctypes::bytes_to_pyobject;
-use super::util::StgInfo;
-use crate::builtins::{PyBytes, PyFloat, PyInt, PyNone, PyStr, PyStrRef, PyType, PyTypeRef};
-use crate::function::{ArgBytesLike, Either, FuncArgs, KwArgs, OptionalArg};
-use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer, PyNumberMethods};
-use crate::stdlib::ctypes::_ctypes::new_simple_type;
-use crate::types::{AsBuffer, AsNumber, Constructor};
+use super::array::{WCHAR_SIZE, wchar_from_bytes, wchar_to_bytes};
+use crate::builtins::{PyBytes, PyDict, PyMemoryView, PyStr, PyType, PyTypeRef};
+use crate::class::StaticType;
+use crate::function::{ArgBytesLike, OptionalArg, PySetterValue};
+use crate::protocol::{BufferMethods, PyBuffer};
+use crate::types::{GetDescriptor, Representable};
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
 };
 use crossbeam_utils::atomic::AtomicCell;
-use num_traits::ToPrimitive;
+use num_traits::{Signed, ToPrimitive};
 use rustpython_common::lock::PyRwLock;
-use std::ffi::{c_uint, c_ulong, c_ulonglong, c_ushort};
+use std::borrow::Cow;
+use std::ffi::{
+    c_double, c_float, c_int, c_long, c_longlong, c_short, c_uint, c_ulong, c_ulonglong, c_ushort,
+};
 use std::fmt::Debug;
+use std::mem;
+use widestring::WideChar;
+
+// StgInfo - Storage information for ctypes types
+// Stored in TypeDataSlot of heap types (PyType::init_type_data/get_type_data)
+
+// Flag constants
+bitflags::bitflags! {
+    #[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct StgInfoFlags: u32 {
+        // Function calling convention flags
+        /// Standard call convention (Windows)
+        const FUNCFLAG_STDCALL = 0x0;
+        /// C calling convention
+        const FUNCFLAG_CDECL = 0x1;
+        /// Function returns HRESULT
+        const FUNCFLAG_HRESULT = 0x2;
+        /// Use Python API calling convention
+        const FUNCFLAG_PYTHONAPI = 0x4;
+        /// Capture errno after call
+        const FUNCFLAG_USE_ERRNO = 0x8;
+        /// Capture last error after call (Windows)
+        const FUNCFLAG_USE_LASTERROR = 0x10;
+
+        // Type flags
+        /// Type is a pointer type
+        const TYPEFLAG_ISPOINTER = 0x100;
+        /// Type contains pointer fields
+        const TYPEFLAG_HASPOINTER = 0x200;
+        /// Type is or contains a union
+        const TYPEFLAG_HASUNION = 0x400;
+        /// Type contains bitfield members
+        const TYPEFLAG_HASBITFIELD = 0x800;
+
+        // Dict flags
+        /// Type is finalized (_fields_ has been set)
+        const DICTFLAG_FINAL = 0x1000;
+    }
+}
 
-/// Get the type code string from a ctypes type (e.g., "i" for c_int)
-pub fn get_type_code(cls: &PyTypeRef, vm: &VirtualMachine) -> Option<String> {
-    cls.as_object()
-        .get_attr("_type_", vm)
-        .ok()
-        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
+/// ParamFunc - determines how a type is passed to foreign functions
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(super) enum ParamFunc {
+    #[default]
+    None,
+    /// Array types are passed as pointers (tag = 'P')
+    Array,
+    /// Simple types use their specific conversion (tag = type code)
+    Simple,
+    /// Pointer types (tag = 'P')
+    Pointer,
+    /// Structure types (tag = 'V' for value)
+    Structure,
+    /// Union types (tag = 'V' for value)
+    Union,
+}
+
+#[derive(Clone)]
+pub struct StgInfo {
+    pub initialized: bool,
+    pub size: usize,              // number of bytes
+    pub align: usize,             // alignment requirements
+    pub length: usize,            // number of fields (for arrays/structures)
+    pub proto: Option<PyTypeRef>, // Only for Pointer/ArrayObject
+    pub flags: StgInfoFlags,      // type flags (TYPEFLAG_*, DICTFLAG_*)
+
+    // Array-specific fields
+    pub element_type: Option<PyTypeRef>, // _type_ for arrays
+    pub element_size: usize,             // size of each element
+
+    // PEP 3118 buffer protocol fields
+    pub format: Option<String>, // struct format string (e.g., "i", "(5)i")
+    pub shape: Vec<usize>,      // shape for multi-dimensional arrays
+
+    // Function parameter conversion
+    pub(super) paramfunc: ParamFunc, // how to pass to foreign functions
+
+    // Byte order (for _swappedbytes_)
+    pub big_endian: bool, // true if big endian, false if little endian
+
+    // FFI field types for structure/union passing (inherited from base class)
+    pub ffi_field_types: Vec<libffi::middle::Type>,
 }
 
-pub fn ffi_type_from_str(_type_: &str) -> Option<libffi::middle::Type> {
-    match _type_ {
-        "c" => Some(libffi::middle::Type::u8()),
-        "u" => Some(libffi::middle::Type::u32()),
-        "b" => Some(libffi::middle::Type::i8()),
-        "B" => Some(libffi::middle::Type::u8()),
-        "h" => Some(libffi::middle::Type::i16()),
-        "H" => Some(libffi::middle::Type::u16()),
-        "i" => Some(libffi::middle::Type::i32()),
-        "I" => Some(libffi::middle::Type::u32()),
-        "l" => Some(libffi::middle::Type::i32()),
-        "L" => Some(libffi::middle::Type::u32()),
-        "q" => Some(libffi::middle::Type::i64()),
-        "Q" => Some(libffi::middle::Type::u64()),
-        "f" => Some(libffi::middle::Type::f32()),
-        "d" => Some(libffi::middle::Type::f64()),
-        "g" => Some(libffi::middle::Type::f64()),
-        "?" => Some(libffi::middle::Type::u8()),
-        "z" => Some(libffi::middle::Type::u64()),
-        "Z" => Some(libffi::middle::Type::u64()),
-        "P" => Some(libffi::middle::Type::u64()),
-        _ => None,
+// StgInfo is stored in type_data which requires Send + Sync.
+// The PyTypeRef in proto/element_type fields is protected by the type system's locking mechanism.
+// ctypes objects are not thread-safe by design; users must synchronize access.
+unsafe impl Send for StgInfo {}
+unsafe impl Sync for StgInfo {}
+
+impl std::fmt::Debug for StgInfo {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StgInfo")
+            .field("initialized", &self.initialized)
+            .field("size", &self.size)
+            .field("align", &self.align)
+            .field("length", &self.length)
+            .field("proto", &self.proto)
+            .field("flags", &self.flags)
+            .field("element_type", &self.element_type)
+            .field("element_size", &self.element_size)
+            .field("format", &self.format)
+            .field("shape", &self.shape)
+            .field("paramfunc", &self.paramfunc)
+            .field("big_endian", &self.big_endian)
+            .field("ffi_field_types", &self.ffi_field_types.len())
+            .finish()
     }
 }
 
-#[allow(dead_code)]
-fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResult {
-    match _type_ {
-        "c" => {
-            if value
-                .to_owned()
-                .downcast_exact::<PyBytes>(vm)
-                .is_ok_and(|v| v.len() == 1)
-                || value
-                    .to_owned()
-                    .downcast_exact::<PyBytes>(vm)
-                    .is_ok_and(|v| v.len() == 1)
-                || value
-                    .to_owned()
-                    .downcast_exact::<PyInt>(vm)
-                    .map_or(Ok(false), |v| {
-                        let n = v.as_bigint().to_i64();
-                        if let Some(n) = n {
-                            Ok((0..=255).contains(&n))
-                        } else {
-                            Ok(false)
-                        }
-                    })?
-            {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error("one character bytes, bytearray or integer expected"))
-            }
+impl Default for StgInfo {
+    fn default() -> Self {
+        StgInfo {
+            initialized: false,
+            size: 0,
+            align: 1,
+            length: 0,
+            proto: None,
+            flags: StgInfoFlags::empty(),
+            element_type: None,
+            element_size: 0,
+            format: None,
+            shape: Vec::new(),
+            paramfunc: ParamFunc::None,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
         }
-        "u" => {
-            if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
-                if b {
-                    Ok(value.to_owned())
+    }
+}
+
+impl StgInfo {
+    pub fn new(size: usize, align: usize) -> Self {
+        StgInfo {
+            initialized: true,
+            size,
+            align,
+            length: 0,
+            proto: None,
+            flags: StgInfoFlags::empty(),
+            element_type: None,
+            element_size: 0,
+            format: None,
+            shape: Vec::new(),
+            paramfunc: ParamFunc::None,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
+        }
+    }
+
+    /// Create StgInfo for an array type
+    /// item_format: the innermost element's format string (kept as-is, e.g., "<i")
+    /// item_shape: the element's shape (will be prepended with length)
+    /// item_flags: the element type's flags (for HASPOINTER inheritance)
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_array(
+        size: usize,
+        align: usize,
+        length: usize,
+        element_type: PyTypeRef,
+        element_size: usize,
+        item_format: Option<&str>,
+        item_shape: &[usize],
+        item_flags: StgInfoFlags,
+    ) -> Self {
+        // Format is kept from innermost element (e.g., "<i" for c_int arrays)
+        // The array dimensions go into shape only, not format
+        let format = item_format.map(|f| f.to_owned());
+
+        // Build shape: [length, ...item_shape]
+        let mut shape = vec![length];
+        shape.extend_from_slice(item_shape);
+
+        // Inherit HASPOINTER flag from element type
+        // if (iteminfo->flags & (TYPEFLAG_ISPOINTER | TYPEFLAG_HASPOINTER))
+        //     stginfo->flags |= TYPEFLAG_HASPOINTER;
+        let flags = if item_flags
+            .intersects(StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER)
+        {
+            StgInfoFlags::TYPEFLAG_HASPOINTER
+        } else {
+            StgInfoFlags::empty()
+        };
+
+        StgInfo {
+            initialized: true,
+            size,
+            align,
+            length,
+            proto: None,
+            flags,
+            element_type: Some(element_type),
+            element_size,
+            format,
+            shape,
+            paramfunc: ParamFunc::Array,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
+        }
+    }
+
+    /// Get libffi type for this StgInfo
+    /// Note: For very large types, returns pointer type to avoid overflow
+    pub fn to_ffi_type(&self) -> libffi::middle::Type {
+        // Limit to avoid overflow in libffi (MAX_STRUCT_SIZE is platform-dependent)
+        const MAX_FFI_STRUCT_SIZE: usize = 1024 * 1024; // 1MB limit for safety
+
+        match self.paramfunc {
+            ParamFunc::Structure | ParamFunc::Union => {
+                if !self.ffi_field_types.is_empty() {
+                    libffi::middle::Type::structure(self.ffi_field_types.iter().cloned())
+                } else if self.size <= MAX_FFI_STRUCT_SIZE {
+                    // Small struct without field types: use bytes array
+                    libffi::middle::Type::structure(std::iter::repeat_n(
+                        libffi::middle::Type::u8(),
+                        self.size,
+                    ))
                 } else {
-                    Err(vm.new_type_error("one character unicode string expected"))
+                    // Large struct: treat as pointer (passed by reference)
+                    libffi::middle::Type::pointer()
                 }
-            } else {
-                Err(vm.new_type_error(format!(
-                    "unicode string expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
-        }
-        "b" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
-            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok() {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "an integer is required (got type {})",
-                    value.class().name()
-                )))
             }
-        }
-        "f" | "d" | "g" => {
-            // float allows int
-            if value.to_owned().downcast_exact::<PyFloat>(vm).is_ok()
-                || value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
-            {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error(format!("must be real number, not {}", value.class().name())))
+            ParamFunc::Array => {
+                if self.size > MAX_FFI_STRUCT_SIZE || self.length > MAX_FFI_STRUCT_SIZE {
+                    // Large array: treat as pointer
+                    libffi::middle::Type::pointer()
+                } else if let Some(ref fmt) = self.format {
+                    let elem_type = Self::format_to_ffi_type(fmt);
+                    libffi::middle::Type::structure(std::iter::repeat_n(elem_type, self.length))
+                } else {
+                    libffi::middle::Type::structure(std::iter::repeat_n(
+                        libffi::middle::Type::u8(),
+                        self.size,
+                    ))
+                }
             }
-        }
-        "?" => Ok(PyObjectRef::from(
-            vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
-        )),
-        "B" => {
-            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok() {
-                // Store as-is, conversion to unsigned happens in the getter
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error(format!("int expected instead of {}", value.class().name())))
+            ParamFunc::Pointer => libffi::middle::Type::pointer(),
+            _ => {
+                // Simple type: derive from format
+                if let Some(ref fmt) = self.format {
+                    Self::format_to_ffi_type(fmt)
+                } else {
+                    libffi::middle::Type::u8()
+                }
             }
         }
-        "z" => {
-            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
-                || value.to_owned().downcast_exact::<PyBytes>(vm).is_ok()
-            {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "bytes or integer address expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
+    }
+
+    /// Convert format string to libffi type
+    fn format_to_ffi_type(fmt: &str) -> libffi::middle::Type {
+        // Strip endian prefix if present
+        let code = fmt.trim_start_matches(['<', '>', '!', '@', '=']);
+        match code {
+            "b" => libffi::middle::Type::i8(),
+            "B" => libffi::middle::Type::u8(),
+            "h" => libffi::middle::Type::i16(),
+            "H" => libffi::middle::Type::u16(),
+            "i" | "l" => libffi::middle::Type::i32(),
+            "I" | "L" => libffi::middle::Type::u32(),
+            "q" => libffi::middle::Type::i64(),
+            "Q" => libffi::middle::Type::u64(),
+            "f" => libffi::middle::Type::f32(),
+            "d" => libffi::middle::Type::f64(),
+            "P" | "z" | "Z" | "O" => libffi::middle::Type::pointer(),
+            _ => libffi::middle::Type::u8(), // default
         }
-        "Z" => {
-            if value.to_owned().downcast_exact::<PyStr>(vm).is_ok() {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "unicode string or integer address expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
+    }
+
+    /// Check if this type is finalized (cannot set _fields_ again)
+    pub fn is_final(&self) -> bool {
+        self.flags.contains(StgInfoFlags::DICTFLAG_FINAL)
+    }
+
+    /// Get proto type reference (for Pointer/Array types)
+    pub fn proto(&self) -> &Py<PyType> {
+        self.proto.as_deref().expect("type has proto")
+    }
+}
+
+/// Get PEP3118 format string for a field type
+/// Returns the format string considering byte order
+pub(super) fn get_field_format(
+    field_type: &PyObject,
+    big_endian: bool,
+    vm: &VirtualMachine,
+) -> String {
+    // 1. Check StgInfo for format
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+        && let Some(fmt) = &stg_info.format
+    {
+        // Handle endian prefix for simple types
+        if fmt.len() == 1 {
+            let endian_prefix = if big_endian { ">" } else { "<" };
+            return format!("{}{}", endian_prefix, fmt);
         }
-        _ => {
-            // "P"
-            if value.to_owned().downcast_exact::<PyInt>(vm).is_ok()
-                || value.to_owned().downcast_exact::<PyNone>(vm).is_ok()
-            {
-                Ok(value.to_owned())
-            } else {
-                Err(vm.new_type_error("cannot be converted to pointer"))
-            }
+        return fmt.clone();
+    }
+
+    // 2. Try to get _type_ attribute for simple types
+    if let Ok(type_attr) = field_type.get_attr("_type_", vm)
+        && let Some(type_str) = type_attr.downcast_ref::<PyStr>()
+    {
+        let s = type_str.as_str();
+        if s.len() == 1 {
+            let endian_prefix = if big_endian { ">" } else { "<" };
+            return format!("{}{}", endian_prefix, s);
         }
+        return s.to_string();
     }
+
+    // Default: single byte
+    "B".to_string()
 }
 
-/// Common data object for all ctypes types
-#[derive(Debug, Clone)]
-pub struct CDataObject {
-    /// pointer to memory block (b_ptr + b_size)
-    pub buffer: Vec<u8>,
+/// Compute byte order based on swapped flag
+#[inline]
+pub(super) fn is_big_endian(is_swapped: bool) -> bool {
+    if is_swapped {
+        !cfg!(target_endian = "big")
+    } else {
+        cfg!(target_endian = "big")
+    }
+}
+
+/// Shared BufferMethods for all ctypes types (PyCArray, PyCSimple, PyCStructure, PyCUnion)
+/// All these types are #[repr(transparent)] wrappers around PyCData
+pub(super) static CDATA_BUFFER_METHODS: BufferMethods = BufferMethods {
+    obj_bytes: |buffer| {
+        rustpython_common::lock::PyRwLockReadGuard::map(
+            buffer.obj_as::<PyCData>().buffer.read(),
+            |x| &**x,
+        )
+        .into()
+    },
+    obj_bytes_mut: |buffer| {
+        rustpython_common::lock::PyRwLockWriteGuard::map(
+            buffer.obj_as::<PyCData>().buffer.write(),
+            |x| x.to_mut().as_mut_slice(),
+        )
+        .into()
+    },
+    release: |_| {},
+    retain: |_| {},
+};
+
+/// Convert Vec<T> to Vec<u8> by reinterpreting the memory (same allocation).
+fn vec_to_bytes<T>(vec: Vec<T>) -> Vec<u8> {
+    let len = vec.len() * std::mem::size_of::<T>();
+    let cap = vec.capacity() * std::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *mut u8;
+    std::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+}
+
+/// Ensure PyBytes is null-terminated. Returns (PyBytes to keep, pointer).
+/// If already contains null, returns original. Otherwise creates new with null appended.
+pub(super) fn ensure_z_null_terminated(
+    bytes: &PyBytes,
+    vm: &VirtualMachine,
+) -> (PyObjectRef, usize) {
+    let data = bytes.as_bytes();
+    if data.contains(&0) {
+        // Already has null, use original
+        let original: PyObjectRef = vm.ctx.new_bytes(data.to_vec()).into();
+        (original, data.as_ptr() as usize)
+    } else {
+        // Create new with null appended
+        let mut buffer = data.to_vec();
+        buffer.push(0);
+        let ptr = buffer.as_ptr() as usize;
+        let new_bytes: PyObjectRef = vm.ctx.new_bytes(buffer).into();
+        (new_bytes, ptr)
+    }
+}
+
+/// Convert str to null-terminated wchar_t buffer. Returns (PyBytes holder, pointer).
+pub(super) fn str_to_wchar_bytes(s: &str, vm: &VirtualMachine) -> (PyObjectRef, usize) {
+    let wchars: Vec<libc::wchar_t> = s
+        .chars()
+        .map(|c| c as libc::wchar_t)
+        .chain(std::iter::once(0))
+        .collect();
+    let ptr = wchars.as_ptr() as usize;
+    let bytes = vec_to_bytes(wchars);
+    let holder: PyObjectRef = vm.ctx.new_bytes(bytes).into();
+    (holder, ptr)
+}
+
+/// PyCData - base type for all ctypes data types
+#[pyclass(name = "_CData", module = "_ctypes")]
+#[derive(Debug, PyPayload)]
+pub struct PyCData {
+    /// Memory buffer - Owned (self-owned) or Borrowed (external reference)
+    ///
+    /// SAFETY: Borrowed variant's 'static lifetime is not actually static.
+    /// When created via from_address or from_base_obj, only valid for the lifetime of the source memory.
+    /// Same behavior as CPython's b_ptr (user responsibility, kept alive via b_base).
+    pub buffer: PyRwLock<Cow<'static, [u8]>>,
     /// pointer to base object or None (b_base)
-    #[allow(dead_code)]
-    pub base: Option<PyObjectRef>,
+    pub base: PyRwLock<Option<PyObjectRef>>,
+    /// byte offset within base's buffer (for field access)
+    pub base_offset: AtomicCell<usize>,
     /// index into base's b_objects list (b_index)
-    #[allow(dead_code)]
-    pub index: usize,
+    pub index: AtomicCell<usize>,
     /// dictionary of references we need to keep (b_objects)
-    pub objects: Option<PyObjectRef>,
+    pub objects: PyRwLock<Option<PyObjectRef>>,
+    /// number of references we need (b_length)
+    pub length: AtomicCell<usize>,
 }
 
-impl CDataObject {
+impl PyCData {
     /// Create from StgInfo (PyCData_MallocBuffer pattern)
     pub fn from_stg_info(stg_info: &StgInfo) -> Self {
-        CDataObject {
-            buffer: vec![0u8; stg_info.size],
-            base: None,
-            index: 0,
-            objects: None,
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(vec![0u8; stg_info.size])),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(stg_info.length),
         }
     }
 
     /// Create from existing bytes (copies data)
     pub fn from_bytes(data: Vec<u8>, objects: Option<PyObjectRef>) -> Self {
-        CDataObject {
-            buffer: data,
-            base: None,
-            index: 0,
-            objects,
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(objects),
+            length: AtomicCell::new(0),
         }
     }
 
-    /// Create from base object (copies data from base's buffer at offset)
-    #[allow(dead_code)]
-    pub fn from_base(
-        base: PyObjectRef,
-        _offset: usize,
-        size: usize,
-        index: usize,
+    /// Create from bytes with specified length (for arrays)
+    pub fn from_bytes_with_length(
+        data: Vec<u8>,
         objects: Option<PyObjectRef>,
+        length: usize,
     ) -> Self {
-        CDataObject {
-            buffer: vec![0u8; size],
-            base: Some(base),
-            index,
-            objects,
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(objects),
+            length: AtomicCell::new(length),
         }
     }
 
-    #[inline]
-    pub fn size(&self) -> usize {
-        self.buffer.len()
+    /// Create from external memory address
+    ///
+    /// # Safety
+    /// The returned slice's 'static lifetime is a lie.
+    /// Actually only valid for the lifetime of the memory pointed to by ptr.
+    /// PyCData_AtAddress
+    pub unsafe fn at_address(ptr: *const u8, size: usize) -> Self {
+        // = PyCData_AtAddress
+        // SAFETY: Caller must ensure ptr is valid for the lifetime of returned PyCData
+        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(0),
+        }
     }
-}
-
-#[pyclass(name = "_CData", module = "_ctypes")]
-#[derive(Debug, PyPayload)]
-pub struct PyCData {
-    pub cdata: PyRwLock<CDataObject>,
-}
 
-impl PyCData {
-    pub fn new(cdata: CDataObject) -> Self {
-        Self {
-            cdata: PyRwLock::new(cdata),
+    /// Create from base object with offset and data copy
+    ///
+    /// Similar to from_base_with_offset, but also stores a copy of the data.
+    /// This is used for arrays where we need our own buffer for the buffer protocol,
+    /// but still maintain the base reference for KeepRef and tracking.
+    pub fn from_base_with_data(
+        base_obj: PyObjectRef,
+        offset: usize,
+        idx: usize,
+        length: usize,
+        data: Vec<u8>,
+    ) -> Self {
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)), // Has its own buffer copy
+            base: PyRwLock::new(Some(base_obj)),     // But still tracks base
+            base_offset: AtomicCell::new(offset),    // And offset for writes
+            index: AtomicCell::new(idx),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(length),
         }
     }
-}
 
-#[pyclass(flags(BASETYPE))]
-impl PyCData {
-    #[pygetset]
-    fn _objects(&self) -> Option<PyObjectRef> {
-        self.cdata.read().objects.clone()
+    /// Create from base object's buffer
+    ///
+    /// This creates a borrowed view into the base's buffer at the given address.
+    /// The base object is stored in b_base to keep the memory alive.
+    ///
+    /// # Safety
+    /// ptr must point into base_obj's buffer and remain valid as long as base_obj is alive.
+    pub unsafe fn from_base_obj(
+        ptr: *mut u8,
+        size: usize,
+        base_obj: PyObjectRef,
+        idx: usize,
+    ) -> Self {
+        // = PyCData_FromBaseObj
+        // SAFETY: ptr points into base_obj's buffer, kept alive via base reference
+        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(Some(base_obj)),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(idx),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(0),
+        }
     }
-}
 
-#[pyclass(module = "_ctypes", name = "PyCSimpleType", base = PyType)]
-#[derive(Debug)]
-#[repr(transparent)]
-pub struct PyCSimpleType(PyType);
-
-#[pyclass(flags(BASETYPE), with(AsNumber))]
-impl PyCSimpleType {
-    /// Get stg_info for a simple type by reading _type_ attribute
-    pub fn get_stg_info(cls: &PyTypeRef, vm: &VirtualMachine) -> StgInfo {
-        if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
-            && let Ok(type_str) = type_attr.str(vm)
-        {
-            let tp_str = type_str.to_string();
-            if tp_str.len() == 1 {
-                let size = super::_ctypes::get_size(&tp_str);
-                let align = super::_ctypes::get_align(&tp_str);
-                return StgInfo::new(size, align);
-            }
+    /// Create from buffer protocol object (for from_buffer method)
+    ///
+    /// Unlike from_bytes, this shares memory with the source buffer.
+    /// The source object is stored in objects dict to keep the buffer alive.
+    /// Python stores with key -1 via KeepRef(result, -1, mv).
+    ///
+    /// # Safety
+    /// ptr must point to valid memory that remains valid as long as source is alive.
+    pub unsafe fn from_buffer_shared(
+        ptr: *const u8,
+        size: usize,
+        length: usize,
+        source: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> Self {
+        // SAFETY: Caller must ensure ptr is valid for the lifetime of source
+        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+
+        // Python stores the reference in a dict with key "-1" (unique_key pattern)
+        let objects_dict = vm.ctx.new_dict();
+        objects_dict
+            .set_item("-1", source, vm)
+            .expect("Failed to store buffer reference");
+
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(Some(objects_dict.into())),
+            length: AtomicCell::new(length),
         }
-        StgInfo::default()
-    }
-    #[allow(clippy::new_ret_no_self)]
-    #[pymethod]
-    fn new(cls: PyTypeRef, _: OptionalArg, vm: &VirtualMachine) -> PyResult {
-        Ok(PyObjectRef::from(
-            new_simple_type(Either::B(&cls), vm)?
-                .into_ref_with_type(vm, cls)?
-                .clone(),
-        ))
     }
 
-    #[pyclassmethod]
-    fn from_param(cls: PyTypeRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        // 1. If the value is already an instance of the requested type, return it
-        if value.fast_isinstance(&cls) {
-            return Ok(value);
+    /// Common implementation for from_buffer class method.
+    /// Validates buffer, creates memoryview, and returns PyCData sharing memory with source.
+    ///
+    /// CDataType_from_buffer_impl
+    pub fn from_buffer_impl(
+        cls: &Py<PyType>,
+        source: PyObjectRef,
+        offset: isize,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let (size, length) = {
+            let stg_info = cls
+                .stg_info_opt()
+                .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+            (stg_info.size, stg_info.length)
+        };
+
+        if offset < 0 {
+            return Err(vm.new_value_error("offset cannot be negative"));
         }
+        let offset = offset as usize;
 
-        // 2. Get the type code to determine conversion rules
-        let type_code = get_type_code(&cls, vm);
+        // Get buffer from source (this exports the buffer)
+        let buffer = PyBuffer::try_from_object(vm, source)?;
 
-        // 3. Handle None for pointer types (c_char_p, c_wchar_p, c_void_p)
-        if vm.is_none(&value) && matches!(type_code.as_deref(), Some("z") | Some("Z") | Some("P")) {
-            return Ok(value);
+        // Check if buffer is writable
+        if buffer.desc.readonly {
+            return Err(vm.new_type_error("underlying buffer is not writable"));
         }
 
-        // 4. Try to convert value based on type code
-        match type_code.as_deref() {
-            // Integer types: accept integers
-            Some("b" | "B" | "h" | "H" | "i" | "I" | "l" | "L" | "q" | "Q") => {
-                if value.try_int(vm).is_ok() {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-            }
-            // Float types: accept numbers
-            Some("f" | "d" | "g") => {
-                if value.try_float(vm).is_ok() || value.try_int(vm).is_ok() {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-            }
-            // c_char: 1 byte character
-            Some("c") => {
-                if let Some(bytes) = value.downcast_ref::<PyBytes>()
-                    && bytes.len() == 1
-                {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-                if let Ok(int_val) = value.try_int(vm)
-                    && int_val.as_bigint().to_u8().is_some()
-                {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-                return Err(vm.new_type_error(
-                    "one character bytes, bytearray or integer expected".to_string(),
-                ));
-            }
-            // c_wchar: 1 unicode character
-            Some("u") => {
-                if let Some(s) = value.downcast_ref::<PyStr>()
-                    && s.as_str().chars().count() == 1
-                {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-                return Err(vm.new_type_error("one character unicode string expected".to_string()));
-            }
-            // c_char_p: bytes pointer
-            Some("z") => {
-                if value.downcast_ref::<PyBytes>().is_some() {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-            }
-            // c_wchar_p: unicode pointer
-            Some("Z") => {
-                if value.downcast_ref::<PyStr>().is_some() {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-            }
-            // c_void_p: most flexible - accepts int, bytes, str
-            Some("P") => {
-                if value.try_int(vm).is_ok()
-                    || value.downcast_ref::<PyBytes>().is_some()
-                    || value.downcast_ref::<PyStr>().is_some()
-                {
-                    let simple = new_simple_type(Either::B(&cls), vm)?;
-                    simple.value.store(value.clone());
-                    return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-                }
-            }
-            // c_bool
-            Some("?") => {
-                let bool_val = value.is_true(vm)?;
-                let simple = new_simple_type(Either::B(&cls), vm)?;
-                simple.value.store(vm.ctx.new_bool(bool_val).into());
-                return simple.into_ref_with_type(vm, cls.clone()).map(Into::into);
-            }
-            _ => {}
+        // Check if buffer is C contiguous
+        if !buffer.desc.is_contiguous() {
+            return Err(vm.new_type_error("underlying buffer is not C contiguous"));
         }
 
-        // 5. Check for _as_parameter_ attribute
-        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
-            return PyCSimpleType::from_param(cls, as_parameter, vm);
+        // Check if buffer is large enough
+        let buffer_len = buffer.desc.len;
+        if offset + size > buffer_len {
+            return Err(vm.new_value_error(format!(
+                "Buffer size too small ({} instead of at least {} bytes)",
+                buffer_len,
+                offset + size
+            )));
         }
 
-        // 6. Type-specific error messages
-        match type_code.as_deref() {
-            Some("z") => Err(vm.new_type_error(format!(
-                "'{}' object cannot be interpreted as ctypes.c_char_p",
-                value.class().name()
-            ))),
-            Some("Z") => Err(vm.new_type_error(format!(
-                "'{}' object cannot be interpreted as ctypes.c_wchar_p",
-                value.class().name()
-            ))),
-            _ => Err(vm.new_type_error("wrong type".to_string())),
-        }
-    }
+        // Get buffer pointer - the memory is owned by source
+        let ptr = {
+            let bytes = buffer.obj_bytes();
+            bytes.as_ptr().wrapping_add(offset)
+        };
 
-    #[pymethod]
-    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        PyCSimple::repeat(cls, n, vm)
+        // Create memoryview to keep buffer exported (prevents source from being modified)
+        // mv = PyMemoryView_FromObject(obj); KeepRef(result, -1, mv);
+        let memoryview = PyMemoryView::from_buffer(buffer, vm)?;
+        let mv_obj = memoryview.into_pyobject(vm);
+
+        // Create CData that shares memory with the buffer
+        Ok(unsafe { Self::from_buffer_shared(ptr, size, length, mv_obj, vm) })
     }
-}
 
-impl AsNumber for PyCSimpleType {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            multiply: Some(|a, b, vm| {
-                // a is a PyCSimpleType instance (type object like c_char)
-                // b is int (array size)
-                let cls = a
-                    .downcast_ref::<PyType>()
-                    .ok_or_else(|| vm.new_type_error("expected type".to_owned()))?;
-                let n = b
-                    .try_index(vm)?
-                    .as_bigint()
-                    .to_isize()
-                    .ok_or_else(|| vm.new_overflow_error("array size too large".to_owned()))?;
-                PyCSimple::repeat(cls.to_owned(), n, vm)
-            }),
-            ..PyNumberMethods::NOT_IMPLEMENTED
+    /// Common implementation for from_buffer_copy class method.
+    /// Copies data from buffer and creates new independent instance.
+    ///
+    /// CDataType_from_buffer_copy_impl
+    pub fn from_buffer_copy_impl(
+        cls: &Py<PyType>,
+        source: &[u8],
+        offset: isize,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let (size, length) = {
+            let stg_info = cls
+                .stg_info_opt()
+                .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+            (stg_info.size, stg_info.length)
         };
-        &AS_NUMBER
-    }
-}
 
-#[pyclass(
-    module = "_ctypes",
-    name = "_SimpleCData",
-    base = PyCData,
-    metaclass = "PyCSimpleType"
-)]
-pub struct PyCSimple {
-    pub _base: PyCData,
-    pub _type_: String,
-    pub value: AtomicCell<PyObjectRef>,
-    pub cdata: PyRwLock<CDataObject>,
-}
+        if offset < 0 {
+            return Err(vm.new_value_error("offset cannot be negative"));
+        }
+        let offset = offset as usize;
 
-impl Debug for PyCSimple {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCSimple")
-            .field("_type_", &self._type_)
-            .finish()
+        // Check if buffer is large enough
+        if offset + size > source.len() {
+            return Err(vm.new_value_error(format!(
+                "Buffer size too small ({} instead of at least {} bytes)",
+                source.len(),
+                offset + size
+            )));
+        }
+
+        // Copy bytes from buffer at offset
+        let data = source[offset..offset + size].to_vec();
+
+        Ok(Self::from_bytes_with_length(data, None, length))
     }
-}
 
-fn value_to_bytes_endian(
-    _type_: &str,
-    value: &PyObject,
-    swapped: bool,
-    vm: &VirtualMachine,
-) -> Vec<u8> {
-    // Helper macro for endian conversion
-    macro_rules! to_bytes {
-        ($val:expr) => {
-            if swapped {
-                // Use opposite endianness
-                #[cfg(target_endian = "little")]
-                {
-                    $val.to_be_bytes().to_vec()
-                }
-                #[cfg(target_endian = "big")]
-                {
-                    $val.to_le_bytes().to_vec()
-                }
-            } else {
-                $val.to_ne_bytes().to_vec()
-            }
-        };
+    #[inline]
+    pub fn size(&self) -> usize {
+        self.buffer.read().len()
     }
 
-    match _type_ {
-        "c" => {
-            // c_char - single byte
-            if let Some(bytes) = value.downcast_ref::<PyBytes>()
-                && !bytes.is_empty()
-            {
-                return vec![bytes.as_bytes()[0]];
-            }
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_u8()
-            {
-                return vec![v];
-            }
-            vec![0]
-        }
-        "u" => {
-            // c_wchar - 4 bytes (wchar_t on most platforms)
-            if let Ok(s) = value.str(vm)
-                && let Some(c) = s.as_str().chars().next()
-            {
-                return to_bytes!(c as u32);
-            }
-            vec![0; 4]
+    /// Check if this buffer is borrowed (external memory reference)
+    #[inline]
+    pub fn is_borrowed(&self) -> bool {
+        matches!(&*self.buffer.read(), Cow::Borrowed(_))
+    }
+
+    /// Write bytes at offset - handles both borrowed and owned buffers
+    ///
+    /// For borrowed buffers (from from_address), writes directly to external memory.
+    /// For owned buffers, writes through to_mut() as normal.
+    ///
+    /// # Safety
+    /// For borrowed buffers, caller must ensure the memory is writable.
+    pub fn write_bytes_at_offset(&self, offset: usize, bytes: &[u8]) {
+        let buffer = self.buffer.read();
+        if offset + bytes.len() > buffer.len() {
+            return; // Out of bounds
         }
-        "b" => {
-            // c_byte - signed char (1 byte)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_i8()
-            {
-                return vec![v as u8];
+
+        match &*buffer {
+            Cow::Borrowed(slice) => {
+                // For borrowed memory, write directly
+                // SAFETY: We assume the caller knows this memory is writable
+                // (e.g., from from_address pointing to a ctypes buffer)
+                unsafe {
+                    let ptr = slice.as_ptr() as *mut u8;
+                    std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(offset), bytes.len());
+                }
             }
-            vec![0]
-        }
-        "B" => {
-            // c_ubyte - unsigned char (1 byte)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_u8()
-            {
-                return vec![v];
+            Cow::Owned(_) => {
+                // For owned memory, use to_mut() through write lock
+                drop(buffer);
+                let mut buffer = self.buffer.write();
+                buffer.to_mut()[offset..offset + bytes.len()].copy_from_slice(bytes);
             }
-            vec![0]
         }
-        "h" => {
-            // c_short (2 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_i16()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 2]
+    }
+
+    /// Generate unique key for nested references (unique_key)
+    /// Creates a hierarchical key by walking up the b_base chain.
+    /// Format: "index:parent_index:grandparent_index:..."
+    pub fn unique_key(&self, index: usize) -> String {
+        let mut key = format!("{index:x}");
+        // Walk up the base chain to build hierarchical key
+        if self.base.read().is_some() {
+            let parent_index = self.index.load();
+            key.push_str(&format!(":{parent_index:x}"));
         }
-        "H" => {
-            // c_ushort (2 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_u16()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 2]
+        key
+    }
+
+    /// Keep a reference in the objects dictionary (KeepRef)
+    ///
+    /// Stores 'keep' in this object's b_objects dict at key 'index'.
+    /// If keep is None, does nothing (optimization).
+    /// This function stores the value directly - caller should use get_kept_objects()
+    /// first if they want to store the _objects of a CData instead of the object itself.
+    ///
+    /// If this object has a base (is embedded in another structure/union/array),
+    /// the reference is stored in the root object's b_objects with a hierarchical key.
+    pub fn keep_ref(&self, index: usize, keep: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Optimization: no need to store None
+        if vm.is_none(&keep) {
+            return Ok(());
         }
-        "i" => {
-            // c_int (4 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_i32()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 4]
+
+        // Build hierarchical key
+        let key = self.unique_key(index);
+
+        // If we have a base object, find root and store there
+        if let Some(base_obj) = self.base.read().clone() {
+            // Find root by walking up the base chain
+            let root_obj = Self::find_root_object(&base_obj);
+            Self::store_in_object(&root_obj, &key, keep, vm)?;
+            return Ok(());
         }
-        "I" => {
-            // c_uint (4 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_u32()
-            {
-                return to_bytes!(v);
+
+        // No base - store in own objects dict
+        let mut objects = self.objects.write();
+
+        // Initialize b_objects if needed
+        if objects.is_none() {
+            if self.length.load() > 0 {
+                // Need to store multiple references - create a dict
+                *objects = Some(vm.ctx.new_dict().into());
+            } else {
+                // Only one reference needed - store directly
+                *objects = Some(keep);
+                return Ok(());
             }
-            vec![0; 4]
         }
-        "l" => {
-            // c_long (platform dependent)
-            if let Ok(int_val) = value.try_to_value::<libc::c_long>(vm) {
-                return to_bytes!(int_val);
-            }
-            const SIZE: usize = std::mem::size_of::<libc::c_long>();
-            vec![0; SIZE]
+
+        // If b_objects is not a dict, convert it to a dict first
+        // This preserves the existing reference (e.g., from cast) when adding new references
+        if let Some(obj) = objects.as_ref()
+            && obj.downcast_ref::<PyDict>().is_none()
+        {
+            // Convert existing single reference to a dict
+            let dict = vm.ctx.new_dict();
+            // Store the original object with a special key (id-based)
+            let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+            dict.set_item(&*id_key, obj.clone(), vm)?;
+            *objects = Some(dict.into());
         }
-        "L" => {
-            // c_ulong (platform dependent)
-            if let Ok(int_val) = value.try_to_value::<libc::c_ulong>(vm) {
-                return to_bytes!(int_val);
-            }
-            const SIZE: usize = std::mem::size_of::<libc::c_ulong>();
-            vec![0; SIZE]
+
+        // Store in dict with unique key
+        if let Some(dict_obj) = objects.as_ref()
+            && let Some(dict) = dict_obj.downcast_ref::<PyDict>()
+        {
+            let key_obj: PyObjectRef = vm.ctx.new_str(key).into();
+            dict.set_item(&*key_obj, keep, vm)?;
         }
-        "q" => {
-            // c_longlong (8 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_i64()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 8]
+
+        Ok(())
+    }
+
+    /// Find the root object (one without a base) by walking up the base chain
+    fn find_root_object(obj: &PyObject) -> PyObjectRef {
+        // Try to get base from different ctypes types
+        let base = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            cdata.base.read().clone()
+        } else {
+            None
+        };
+
+        // Recurse if there's a base, otherwise this is the root
+        if let Some(base_obj) = base {
+            Self::find_root_object(&base_obj)
+        } else {
+            obj.to_owned()
         }
-        "Q" => {
-            // c_ulonglong (8 bytes)
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_u64()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 8]
-        }
-        "f" => {
-            // c_float (4 bytes) - int� 허용
-            if let Ok(float_val) = value.try_float(vm) {
-                return to_bytes!(float_val.to_f64() as f32);
-            }
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_f64()
-            {
-                return to_bytes!(v as f32);
-            }
-            vec![0; 4]
-        }
-        "d" | "g" => {
-            // c_double (8 bytes) - int� 허용
-            if let Ok(float_val) = value.try_float(vm) {
-                return to_bytes!(float_val.to_f64());
-            }
-            if let Ok(int_val) = value.try_int(vm)
-                && let Some(v) = int_val.as_bigint().to_f64()
-            {
-                return to_bytes!(v);
-            }
-            vec![0; 8]
-        }
-        "?" => {
-            // c_bool (1 byte)
-            if let Ok(b) = value.to_owned().try_to_bool(vm) {
-                return vec![if b { 1 } else { 0 }];
-            }
-            vec![0]
-        }
-        "P" | "z" | "Z" => {
-            // Pointer types (platform pointer size)
-            vec![0; std::mem::size_of::<usize>()]
-        }
-        _ => vec![0],
     }
-}
 
-impl Constructor for PyCSimple {
-    type Args = (OptionalArg,);
-
-    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let args: Self::Args = args.bind(vm)?;
-        let attributes = cls.get_attributes();
-        let _type_ = attributes
-            .iter()
-            .find(|(k, _)| {
-                k.to_object()
-                    .str(vm)
-                    .map(|s| s.to_string() == "_type_")
-                    .unwrap_or(false)
-            })
-            .ok_or_else(|| {
-                vm.new_type_error(format!(
-                    "cannot create '{}' instances: no _type_ attribute",
-                    cls.name()
-                ))
-            })?
-            .1
-            .str(vm)?
-            .to_string();
-        let value = if let Some(ref v) = args.0.into_option() {
-            set_primitive(_type_.as_str(), v, vm)?
+    /// Store a value in an object's _objects dict with the given key
+    fn store_in_object(
+        obj: &PyObject,
+        key: &str,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Get the objects dict from the object
+        let objects_lock = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            &cdata.objects
         } else {
-            match _type_.as_str() {
-                "c" | "u" => PyObjectRef::from(vm.ctx.new_bytes(vec![0])),
-                "b" | "B" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
-                    PyObjectRef::from(vm.ctx.new_int(0))
-                }
-                "f" | "d" | "g" => PyObjectRef::from(vm.ctx.new_float(0.0)),
-                "?" => PyObjectRef::from(vm.ctx.new_bool(false)),
-                _ => vm.ctx.none(), // "z" | "Z" | "P"
-            }
+            return Ok(()); // Unknown type, skip
         };
 
-        // Check if this is a swapped endian type
-        let swapped = cls
-            .as_object()
-            .get_attr("_swappedbytes_", vm)
-            .map(|v| v.is_true(vm).unwrap_or(false))
-            .unwrap_or(false);
+        let mut objects = objects_lock.write();
 
-        let buffer = value_to_bytes_endian(&_type_, &value, swapped, vm);
-        let cdata = CDataObject::from_bytes(buffer, None);
-        PyCSimple {
-            _base: PyCData::new(cdata.clone()),
-            _type_,
-            value: AtomicCell::new(value),
-            cdata: PyRwLock::new(cdata),
+        // Initialize if needed
+        if objects.is_none() {
+            *objects = Some(vm.ctx.new_dict().into());
         }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
-    }
 
-    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-        unimplemented!("use slot_new")
-    }
-}
+        // If not a dict, convert to dict
+        if let Some(obj) = objects.as_ref()
+            && obj.downcast_ref::<PyDict>().is_none()
+        {
+            let dict = vm.ctx.new_dict();
+            let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+            dict.set_item(&*id_key, obj.clone(), vm)?;
+            *objects = Some(dict.into());
+        }
 
-#[pyclass(flags(BASETYPE), with(Constructor, AsBuffer))]
-impl PyCSimple {
-    #[pygetset]
-    fn _objects(&self) -> Option<PyObjectRef> {
-        self.cdata.read().objects.clone()
-    }
-
-    #[pygetset(name = "value")]
-    pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        let zelf: &Py<Self> = instance
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("cannot get value of instance"))?;
-        let raw_value = unsafe { (*zelf.value.as_ptr()).clone() };
-
-        // Convert to unsigned if needed for unsigned types
-        match zelf._type_.as_str() {
-            "B" | "H" | "I" | "L" | "Q" => {
-                if let Ok(int_val) = raw_value.try_int(vm) {
-                    let n = int_val.as_bigint();
-                    // Use platform-specific C types for correct unsigned conversion
-                    match zelf._type_.as_str() {
-                        "B" => {
-                            if let Some(v) = n.to_i64() {
-                                return Ok(vm.ctx.new_int((v as u8) as u64).into());
-                            }
-                        }
-                        "H" => {
-                            if let Some(v) = n.to_i64() {
-                                return Ok(vm.ctx.new_int((v as c_ushort) as u64).into());
-                            }
-                        }
-                        "I" => {
-                            if let Some(v) = n.to_i64() {
-                                return Ok(vm.ctx.new_int((v as c_uint) as u64).into());
-                            }
-                        }
-                        "L" => {
-                            if let Some(v) = n.to_i128() {
-                                return Ok(vm.ctx.new_int(v as c_ulong).into());
-                            }
-                        }
-                        "Q" => {
-                            if let Some(v) = n.to_i128() {
-                                return Ok(vm.ctx.new_int(v as c_ulonglong).into());
-                            }
-                        }
-                        _ => {}
-                    };
-                }
-                Ok(raw_value)
-            }
-            _ => Ok(raw_value),
+        // Store in dict
+        if let Some(dict_obj) = objects.as_ref()
+            && let Some(dict) = dict_obj.downcast_ref::<PyDict>()
+        {
+            let key_obj: PyObjectRef = vm.ctx.new_str(key).into();
+            dict.set_item(&*key_obj, value, vm)?;
         }
+
+        Ok(())
     }
 
-    #[pygetset(name = "value", setter)]
-    fn set_value(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let zelf: PyRef<Self> = instance
-            .clone()
-            .downcast()
-            .map_err(|_| vm.new_type_error("cannot set value of instance"))?;
-        let content = set_primitive(zelf._type_.as_str(), &value, vm)?;
+    /// Get kept objects from a CData instance
+    /// Returns the _objects of the CData, or an empty dict if None.
+    pub fn get_kept_objects(value: &PyObject, vm: &VirtualMachine) -> PyObjectRef {
+        value
+            .downcast_ref::<PyCData>()
+            .and_then(|cdata| cdata.objects.read().clone())
+            .unwrap_or_else(|| vm.ctx.new_dict().into())
+    }
 
-        // Check if this is a swapped endian type
-        let swapped = instance
-            .class()
-            .as_object()
-            .get_attr("_swappedbytes_", vm)
-            .map(|v| v.is_true(vm).unwrap_or(false))
-            .unwrap_or(false);
-
-        // Update buffer when value changes
-        let buffer_bytes = value_to_bytes_endian(&zelf._type_, &content, swapped, vm);
-        zelf.cdata.write().buffer = buffer_bytes;
-        zelf.value.store(content);
-        Ok(())
+    /// Check if a value should be stored in _objects
+    /// Returns true for ctypes objects and bytes (for c_char_p)
+    pub fn should_keep_ref(value: &PyObject) -> bool {
+        value.downcast_ref::<PyCData>().is_some() || value.downcast_ref::<PyBytes>().is_some()
     }
 
-    #[pyclassmethod]
-    fn repeat(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        use super::_ctypes::get_size;
-        use super::array::create_array_type_with_stg_info;
-
-        if n < 0 {
-            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
-        }
-        // Get element size from cls
-        let element_size = if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm) {
-            if let Ok(s) = type_attr.str(vm) {
-                let s = s.to_string();
-                if s.len() == 1 {
-                    get_size(&s)
-                } else {
-                    std::mem::size_of::<usize>()
-                }
+    /// PyCData_set
+    /// Sets a field value at the given offset, handling type conversion and KeepRef
+    #[allow(clippy::too_many_arguments)]
+    pub fn set_field(
+        &self,
+        proto: &PyObject,
+        value: PyObjectRef,
+        index: usize,
+        size: usize,
+        offset: usize,
+        needs_swap: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if this is a c_char or c_wchar array field
+        let is_char_array = PyCField::is_char_array(proto, vm);
+        let is_wchar_array = PyCField::is_wchar_array(proto, vm);
+
+        // For c_char arrays with bytes input, copy only up to first null
+        if is_char_array {
+            if let Some(bytes_val) = value.downcast_ref::<PyBytes>() {
+                let src = bytes_val.as_bytes();
+                let to_copy = PyCField::bytes_for_char_array(src);
+                let copy_len = std::cmp::min(to_copy.len(), size);
+                self.write_bytes_at_offset(offset, &to_copy[..copy_len]);
+                self.keep_ref(index, value, vm)?;
+                return Ok(());
             } else {
-                std::mem::size_of::<usize>()
+                return Err(vm.new_type_error("bytes expected instead of str instance"));
             }
-        } else {
-            std::mem::size_of::<usize>()
-        };
-        let total_size = element_size * (n as usize);
-        let stg_info = super::util::StgInfo::new_array(
-            total_size,
-            element_size,
-            n as usize,
-            cls.clone().into(),
-            element_size,
-        );
-        create_array_type_with_stg_info(stg_info, vm)
-    }
+        }
 
-    #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
-        use super::_ctypes::get_size;
-        // Get _type_ attribute directly
-        let type_attr = cls
-            .as_object()
-            .get_attr("_type_", vm)
-            .map_err(|_| vm.new_type_error(format!("'{}' has no _type_ attribute", cls.name())))?;
-        let type_str = type_attr.str(vm)?.to_string();
-        let size = get_size(&type_str);
-
-        // Create instance with value read from address
-        let value = if address != 0 && size > 0 {
-            // Safety: This is inherently unsafe - reading from arbitrary memory address
-            unsafe {
-                let ptr = address as *const u8;
-                let bytes = std::slice::from_raw_parts(ptr, size);
-                // Convert bytes to appropriate Python value based on type
-                bytes_to_pyobject(&cls, bytes, vm)?
+        // For c_wchar arrays with str input, convert to wchar_t
+        if is_wchar_array {
+            if let Some(str_val) = value.downcast_ref::<PyStr>() {
+                // Convert str to wchar_t bytes (platform-dependent size)
+                let mut wchar_bytes = Vec::with_capacity(size);
+                for ch in str_val.as_str().chars().take(size / WCHAR_SIZE) {
+                    let mut bytes = [0u8; 4];
+                    wchar_to_bytes(ch as u32, &mut bytes);
+                    wchar_bytes.extend_from_slice(&bytes[..WCHAR_SIZE]);
+                }
+                // Pad with nulls to fill the array
+                while wchar_bytes.len() < size {
+                    wchar_bytes.push(0);
+                }
+                self.write_bytes_at_offset(offset, &wchar_bytes);
+                self.keep_ref(index, value, vm)?;
+                return Ok(());
+            } else if value.downcast_ref::<PyBytes>().is_some() {
+                return Err(vm.new_type_error("str expected instead of bytes instance"));
             }
+        }
+
+        // Special handling for Pointer fields with Array values
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && proto_type
+                .class()
+                .fast_issubclass(super::pointer::PyCPointerType::static_type())
+            && let Some(array) = value.downcast_ref::<super::array::PyCArray>()
+        {
+            let buffer_addr = {
+                let array_buffer = array.0.buffer.read();
+                array_buffer.as_ptr() as usize
+            };
+            let addr_bytes = buffer_addr.to_ne_bytes();
+            let len = std::cmp::min(addr_bytes.len(), size);
+            self.write_bytes_at_offset(offset, &addr_bytes[..len]);
+            self.keep_ref(index, value, vm)?;
+            return Ok(());
+        }
+
+        // Get field type code for special handling
+        let field_type_code = proto
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|attr| attr.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        let (mut bytes, converted_value) = if let Some(type_code) = &field_type_code {
+            PyCField::value_to_bytes_for_type(type_code, &value, size, vm)?
         } else {
-            vm.ctx.none()
+            (PyCField::value_to_bytes(&value, size, vm)?, None)
         };
 
-        // Create instance using the type's constructor
-        let args = FuncArgs::new(vec![value], KwArgs::default());
-        PyCSimple::slot_new(cls.clone(), args, vm)
+        // Swap bytes for opposite endianness
+        if needs_swap {
+            bytes.reverse();
+        }
+
+        self.write_bytes_at_offset(offset, &bytes);
+
+        // KeepRef: for z/Z types use converted value, otherwise use original
+        if let Some(converted) = converted_value {
+            self.keep_ref(index, converted, vm)?;
+        } else if Self::should_keep_ref(&value) {
+            let to_keep = Self::get_kept_objects(&value, vm);
+            self.keep_ref(index, to_keep, vm)?;
+        }
+
+        Ok(())
     }
 
-    #[pyclassmethod]
-    fn from_buffer(
-        cls: PyTypeRef,
-        source: PyObjectRef,
-        offset: OptionalArg<isize>,
+    /// PyCData_get
+    /// Gets a field value at the given offset
+    pub fn get_field(
+        &self,
+        proto: &PyObject,
+        index: usize,
+        size: usize,
+        offset: usize,
+        base_obj: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use super::_ctypes::get_size;
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
+        // Get buffer data at offset
+        let buffer = self.buffer.read();
+        if offset + size > buffer.len() {
+            return Ok(vm.ctx.new_int(0).into());
         }
-        let offset = offset as usize;
 
-        // Get buffer from source
-        let buffer = PyBuffer::try_from_object(vm, source.clone())?;
+        // Check if field type is an array type
+        if let Some(type_ref) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = type_ref.stg_info_opt()
+            && stg.element_type.is_some()
+        {
+            // c_char array → return bytes
+            if PyCField::is_char_array(proto, vm) {
+                let data = &buffer[offset..offset + size];
+                // Find first null terminator (or use full length)
+                let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
+                return Ok(vm.ctx.new_bytes(data[..end].to_vec()).into());
+            }
 
-        // Check if buffer is writable
-        if buffer.desc.readonly {
-            return Err(vm.new_type_error("underlying buffer is not writable".to_owned()));
+            // c_wchar array → return str
+            if PyCField::is_wchar_array(proto, vm) {
+                let data = &buffer[offset..offset + size];
+                // wchar_t → char conversion, skip null
+                let chars: String = data
+                    .chunks(WCHAR_SIZE)
+                    .filter_map(|chunk| {
+                        wchar_from_bytes(chunk)
+                            .filter(|&wchar| wchar != 0)
+                            .and_then(char::from_u32)
+                    })
+                    .collect();
+                return Ok(vm.ctx.new_str(chars).into());
+            }
+
+            // Other array types - create array with a copy of data from the base's buffer
+            // The array also keeps a reference to the base for keeping it alive and for writes
+            let array_data = buffer[offset..offset + size].to_vec();
+            drop(buffer);
+
+            let cdata_obj =
+                Self::from_base_with_data(base_obj, offset, index, stg.length, array_data);
+            let array_type: PyTypeRef = proto
+                .to_owned()
+                .downcast()
+                .map_err(|_| vm.new_type_error("expected array type"))?;
+
+            return super::array::PyCArray(cdata_obj)
+                .into_ref_with_type(vm, array_type)
+                .map(Into::into);
         }
 
-        // Get _type_ attribute directly
-        let type_attr = cls
-            .as_object()
-            .get_attr("_type_", vm)
-            .map_err(|_| vm.new_type_error(format!("'{}' has no _type_ attribute", cls.name())))?;
-        let type_str = type_attr.str(vm)?.to_string();
-        let size = get_size(&type_str);
+        let buffer_data = buffer[offset..offset + size].to_vec();
+        drop(buffer);
 
-        // Check if buffer is large enough
-        let buffer_len = buffer.desc.len;
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
+        // Get proto as type
+        let proto_type: PyTypeRef = proto
+            .to_owned()
+            .downcast()
+            .map_err(|_| vm.new_type_error("field proto is not a type"))?;
+
+        let proto_metaclass = proto_type.class();
+
+        // Simple types: return primitive value
+        if proto_metaclass.fast_issubclass(super::simple::PyCSimpleType::static_type()) {
+            // Check for byte swapping
+            let needs_swap = base_obj
+                .class()
+                .as_object()
+                .get_attr("_swappedbytes_", vm)
+                .is_ok()
+                || proto_type
+                    .as_object()
+                    .get_attr("_swappedbytes_", vm)
+                    .is_ok();
+
+            let data = if needs_swap && size > 1 {
+                let mut swapped = buffer_data.clone();
+                swapped.reverse();
+                swapped
+            } else {
+                buffer_data
+            };
+
+            return bytes_to_pyobject(&proto_type, &data, vm);
         }
 
-        // Read bytes from buffer at offset
-        let bytes = buffer.obj_bytes();
-        let data = &bytes[offset..offset + size];
-        let value = bytes_to_pyobject(&cls, data, vm)?;
+        // Complex types: create ctypes instance via PyCData_FromBaseObj
+        let ptr = self.buffer.read().as_ptr().wrapping_add(offset) as *mut u8;
+        let cdata_obj = unsafe { Self::from_base_obj(ptr, size, base_obj.clone(), index) };
 
-        // Create instance
-        let args = FuncArgs::new(vec![value], KwArgs::default());
-        let instance = PyCSimple::slot_new(cls.clone(), args, vm)?;
+        if proto_metaclass.fast_issubclass(super::structure::PyCStructType::static_type())
+            || proto_metaclass.fast_issubclass(super::union::PyCUnionType::static_type())
+            || proto_metaclass.fast_issubclass(super::pointer::PyCPointerType::static_type())
+        {
+            cdata_obj.into_ref_with_type(vm, proto_type).map(Into::into)
+        } else {
+            // Fallback
+            Ok(vm.ctx.new_int(0).into())
+        }
+    }
+}
 
-        // TODO: Store reference to source in _objects to keep buffer alive
-        Ok(instance)
+#[pyclass(flags(BASETYPE))]
+impl PyCData {
+    #[pygetset]
+    fn _objects(&self) -> Option<PyObjectRef> {
+        self.objects.read().clone()
+    }
+
+    #[pygetset]
+    fn _b_base_(&self) -> Option<PyObjectRef> {
+        self.base.read().clone()
+    }
+
+    #[pygetset]
+    fn _b_needsfree_(&self) -> i32 {
+        // Borrowed (from_address) or has base object → 0 (don't free)
+        // Owned and no base → 1 (need to free)
+        if self.is_borrowed() || self.base.read().is_some() {
+            0
+        } else {
+            1
+        }
+    }
+
+    // CDataType_methods - shared across all ctypes types
+
+    #[pyclassmethod]
+    fn from_buffer(
+        cls: PyTypeRef,
+        source: PyObjectRef,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cdata = Self::from_buffer_impl(&cls, source, offset.unwrap_or(0), vm)?;
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
     }
 
     #[pyclassmethod]
@@ -875,191 +1117,1237 @@ impl PyCSimple {
         offset: OptionalArg<isize>,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use super::_ctypes::get_size;
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
-
-        // Get _type_ attribute directly for simple types
-        let type_attr = cls
-            .as_object()
-            .get_attr("_type_", vm)
-            .map_err(|_| vm.new_type_error(format!("'{}' has no _type_ attribute", cls.name())))?;
-        let type_str = type_attr.str(vm)?.to_string();
-        let size = get_size(&type_str);
+        let cdata =
+            Self::from_buffer_copy_impl(&cls, &source.borrow_buf(), offset.unwrap_or(0), vm)?;
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
 
-        // Borrow bytes from source
-        let source_bytes = source.borrow_buf();
-        let buffer_len = source_bytes.len();
+    #[pyclassmethod]
+    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
+        let size = {
+            let stg_info = cls.stg_info(vm)?;
+            stg_info.size
+        };
 
-        // Check if buffer is large enough
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
+        if size == 0 {
+            return Err(vm.new_type_error("abstract class"));
         }
 
-        // Copy bytes from buffer at offset
-        let data = &source_bytes[offset..offset + size];
-        let value = bytes_to_pyobject(&cls, data, vm)?;
-
-        // Create instance (independent copy, no reference tracking)
-        let args = FuncArgs::new(vec![value], KwArgs::default());
-        PyCSimple::slot_new(cls.clone(), args, vm)
+        // PyCData_AtAddress
+        let cdata = unsafe { Self::at_address(address as *const u8, size) };
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
     }
 
     #[pyclassmethod]
-    fn in_dll(cls: PyTypeRef, dll: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        use super::_ctypes::get_size;
-        use libloading::Symbol;
+    fn in_dll(
+        cls: PyTypeRef,
+        dll: PyObjectRef,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let size = {
+            let stg_info = cls.stg_info(vm)?;
+            stg_info.size
+        };
+
+        if size == 0 {
+            return Err(vm.new_type_error("abstract class"));
+        }
 
         // Get the library handle from dll object
         let handle = if let Ok(int_handle) = dll.try_int(vm) {
-            // dll is an integer handle
             int_handle
                 .as_bigint()
                 .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
+                .ok_or_else(|| vm.new_value_error("Invalid library handle"))?
         } else {
-            // dll is a CDLL/PyDLL/WinDLL object with _handle attribute
             dll.get_attr("_handle", vm)?
                 .try_int(vm)?
                 .as_bigint()
                 .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
+                .ok_or_else(|| vm.new_value_error("Invalid library handle"))?
         };
 
-        // Get the library from cache
-        let library_cache = crate::stdlib::ctypes::library::libcache().read();
-        let library = library_cache
-            .get_lib(handle)
-            .ok_or_else(|| vm.new_attribute_error("Library not found".to_owned()))?;
-
-        // Get symbol address from library
-        let symbol_name = format!("{}\0", name.as_str());
-        let inner_lib = library.lib.lock();
-
-        let symbol_address = if let Some(lib) = &*inner_lib {
-            unsafe {
-                // Try to get the symbol from the library
-                let symbol: Symbol<'_, *mut u8> = lib.get(symbol_name.as_bytes()).map_err(|e| {
-                    vm.new_attribute_error(format!("{}: symbol '{}' not found", e, name.as_str()))
-                })?;
-                *symbol as usize
+        // Get symbol address using platform-specific API
+        let symbol_name = std::ffi::CString::new(name.as_str())
+            .map_err(|_| vm.new_value_error("Invalid symbol name"))?;
+
+        #[cfg(windows)]
+        let ptr: *const u8 = unsafe {
+            match windows_sys::Win32::System::LibraryLoader::GetProcAddress(
+                handle as windows_sys::Win32::Foundation::HMODULE,
+                symbol_name.as_ptr() as *const u8,
+            ) {
+                Some(p) => p as *const u8,
+                None => std::ptr::null(),
             }
+        };
+
+        #[cfg(not(windows))]
+        let ptr: *const u8 =
+            unsafe { libc::dlsym(handle as *mut libc::c_void, symbol_name.as_ptr()) as *const u8 };
+
+        if ptr.is_null() {
+            return Err(
+                vm.new_value_error(format!("symbol '{}' not found in library", name.as_str()))
+            );
+        }
+
+        // PyCData_AtAddress
+        let cdata = unsafe { Self::at_address(ptr, size) };
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
+}
+
+// PyCField - Field descriptor for Structure/Union types
+
+/// CField descriptor for Structure/Union field access
+#[pyclass(name = "CField", module = "_ctypes")]
+#[derive(Debug, PyPayload)]
+pub struct PyCField {
+    /// Byte offset of the field within the structure/union
+    pub(crate) offset: isize,
+    /// Encoded size: for bitfields (bit_size << 16) | bit_offset, otherwise byte size
+    pub(crate) size: isize,
+    /// Index into PyCData's object array
+    pub(crate) index: usize,
+    /// The ctypes type for this field
+    pub(crate) proto: PyTypeRef,
+    /// Flag indicating if the field is anonymous (MakeAnonFields sets this)
+    pub(crate) anonymous: bool,
+}
+
+#[inline(always)]
+const fn num_bits(size: isize) -> isize {
+    size >> 16
+}
+
+#[inline(always)]
+const fn field_size(size: isize) -> isize {
+    size & 0xFFFF
+}
+
+#[inline(always)]
+const fn is_bitfield(size: isize) -> bool {
+    (size >> 16) != 0
+}
+
+impl PyCField {
+    /// Create a new CField descriptor (non-bitfield)
+    pub fn new(proto: PyTypeRef, offset: isize, size: isize, index: usize) -> Self {
+        Self {
+            offset,
+            size,
+            index,
+            proto,
+            anonymous: false,
+        }
+    }
+
+    /// Create a new CField descriptor for a bitfield
+    #[allow(dead_code)]
+    pub fn new_bitfield(
+        proto: PyTypeRef,
+        offset: isize,
+        bit_size: u16,
+        bit_offset: u16,
+        index: usize,
+    ) -> Self {
+        let encoded_size = ((bit_size as isize) << 16) | (bit_offset as isize);
+        Self {
+            offset,
+            size: encoded_size,
+            index,
+            proto,
+            anonymous: false,
+        }
+    }
+
+    /// Get the actual byte size (for non-bitfields) or bit storage size (for bitfields)
+    pub fn byte_size(&self) -> usize {
+        field_size(self.size) as usize
+    }
+
+    /// Create a new CField from an existing field with adjusted offset and index
+    /// Used by MakeFields to promote anonymous fields
+    pub fn new_from_field(fdescr: &PyCField, index_offset: usize, offset_delta: isize) -> Self {
+        Self {
+            offset: fdescr.offset + offset_delta,
+            size: fdescr.size,
+            index: fdescr.index + index_offset,
+            proto: fdescr.proto.clone(),
+            anonymous: false, // promoted fields are not anonymous themselves
+        }
+    }
+
+    /// Set anonymous flag
+    pub fn set_anonymous(&mut self, anonymous: bool) {
+        self.anonymous = anonymous;
+    }
+}
+
+impl Representable for PyCField {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        // Get type name from proto (which is always PyTypeRef)
+        let tp_name = zelf.proto.name().to_string();
+
+        // Bitfield: <Field type=TYPE, ofs=OFFSET:BIT_OFFSET, bits=NUM_BITS>
+        // Regular:  <Field type=TYPE, ofs=OFFSET, size=SIZE>
+        if is_bitfield(zelf.size) {
+            let bit_offset = field_size(zelf.size);
+            let bits = num_bits(zelf.size);
+            Ok(format!(
+                "<Field type={}, ofs={}:{}, bits={}>",
+                tp_name, zelf.offset, bit_offset, bits
+            ))
         } else {
-            return Err(vm.new_attribute_error("Library is closed".to_owned()));
+            Ok(format!(
+                "<Field type={}, ofs={}, size={}>",
+                tp_name, zelf.offset, zelf.size
+            ))
+        }
+    }
+}
+
+/// PyCField_get
+impl GetDescriptor for PyCField {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let zelf = zelf
+            .downcast::<PyCField>()
+            .map_err(|_| vm.new_type_error("expected CField"))?;
+
+        // If obj is None, return the descriptor itself (class attribute access)
+        let obj = match obj {
+            Some(obj) if !vm.is_none(&obj) => obj,
+            _ => return Ok(zelf.into()),
         };
 
-        // Get _type_ attribute and size
-        let type_attr = cls
-            .as_object()
-            .get_attr("_type_", vm)
-            .map_err(|_| vm.new_type_error(format!("'{}' has no _type_ attribute", cls.name())))?;
-        let type_str = type_attr.str(vm)?.to_string();
-        let size = get_size(&type_str);
-
-        // Read value from symbol address
-        let value = if symbol_address != 0 && size > 0 {
-            // Safety: Reading from a symbol address provided by dlsym
-            unsafe {
-                let ptr = symbol_address as *const u8;
-                let bytes = std::slice::from_raw_parts(ptr, size);
-                bytes_to_pyobject(&cls, bytes, vm)?
+        let offset = zelf.offset as usize;
+        let size = zelf.byte_size();
+
+        // Get PyCData from obj (works for both Structure and Union)
+        let cdata = PyCField::get_cdata_from_obj(&obj, vm)?;
+
+        // PyCData_get
+        cdata.get_field(
+            zelf.proto.as_object(),
+            zelf.index,
+            size,
+            offset,
+            obj.clone(),
+            vm,
+        )
+    }
+}
+
+impl PyCField {
+    /// Convert a Python value to bytes
+    fn value_to_bytes(value: &PyObject, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        // 1. Handle bytes objects
+        if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+            let src = bytes.as_bytes();
+            let mut result = vec![0u8; size];
+            let len = std::cmp::min(src.len(), size);
+            result[..len].copy_from_slice(&src[..len]);
+            Ok(result)
+        }
+        // 2. Handle ctypes array instances (copy their buffer)
+        else if let Some(cdata) = value.downcast_ref::<super::PyCData>() {
+            let buffer = cdata.buffer.read();
+            let mut result = vec![0u8; size];
+            let len = std::cmp::min(buffer.len(), size);
+            result[..len].copy_from_slice(&buffer[..len]);
+            Ok(result)
+        }
+        // 4. Handle float values (check before int, since float.try_int would truncate)
+        else if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+            let f = float_val.to_f64();
+            match size {
+                4 => {
+                    let val = f as f32;
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                8 => Ok(f.to_ne_bytes().to_vec()),
+                _ => unreachable!("wrong payload size"),
+            }
+        }
+        // 4. Handle integer values
+        else if let Ok(int_val) = value.try_int(vm) {
+            let i = int_val.as_bigint();
+            match size {
+                1 => {
+                    let val = i.to_i8().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                2 => {
+                    let val = i.to_i16().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                4 => {
+                    let val = i.to_i32().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                8 => {
+                    let val = i.to_i64().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                _ => Ok(vec![0u8; size]),
             }
         } else {
-            vm.ctx.none()
-        };
+            Ok(vec![0u8; size])
+        }
+    }
 
-        // Create instance
-        let args = FuncArgs::new(vec![value], KwArgs::default());
-        let instance = PyCSimple::slot_new(cls.clone(), args, vm)?;
+    /// Convert a Python value to bytes with type-specific handling for pointer types.
+    /// Returns (bytes, optional holder for wchar buffer).
+    fn value_to_bytes_for_type(
+        type_code: &str,
+        value: &PyObject,
+        size: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<(Vec<u8>, Option<PyObjectRef>)> {
+        match type_code {
+            // c_float: always convert to float first (f_set)
+            "f" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                let val = f as f32;
+                Ok((val.to_ne_bytes().to_vec(), None))
+            }
+            // c_double: always convert to float first (d_set)
+            "d" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                Ok((f.to_ne_bytes().to_vec(), None))
+            }
+            // c_longdouble: convert to float (treated as f64 in RustPython)
+            "g" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                Ok((f.to_ne_bytes().to_vec(), None))
+            }
+            "z" => {
+                // c_char_p: store pointer to null-terminated bytes
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (converted, ptr) = ensure_z_null_terminated(bytes, vm);
+                    let mut result = vec![0u8; size];
+                    let addr_bytes = ptr.to_ne_bytes();
+                    let len = std::cmp::min(addr_bytes.len(), size);
+                    result[..len].copy_from_slice(&addr_bytes[..len]);
+                    return Ok((result, Some(converted)));
+                }
+                // Integer address
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = std::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            "Z" => {
+                // c_wchar_p: store pointer to null-terminated wchar_t buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = str_to_wchar_bytes(s.as_str(), vm);
+                    let mut result = vec![0u8; size];
+                    let addr_bytes = ptr.to_ne_bytes();
+                    let len = std::cmp::min(addr_bytes.len(), size);
+                    result[..len].copy_from_slice(&addr_bytes[..len]);
+                    return Ok((result, Some(holder)));
+                }
+                // Integer address
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = std::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            "P" => {
+                // c_void_p: store integer as pointer
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = std::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            _ => Ok((PyCField::value_to_bytes(value, size, vm)?, None)),
+        }
+    }
+
+    /// Check if the field type is a c_char array (element type has _type_ == 'c')
+    fn is_char_array(proto: &PyObject, vm: &VirtualMachine) -> bool {
+        // Get element_type from StgInfo (for array types)
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = proto_type.stg_info_opt()
+            && let Some(element_type) = &stg.element_type
+        {
+            // Check if element type has _type_ == "c"
+            if let Ok(type_code) = element_type.as_object().get_attr("_type_", vm)
+                && let Some(s) = type_code.downcast_ref::<PyStr>()
+            {
+                return s.as_str() == "c";
+            }
+        }
+        false
+    }
 
-        // Store base reference to keep dll alive
-        if let Ok(simple_ref) = instance.clone().downcast::<PyCSimple>() {
-            simple_ref.cdata.write().base = Some(dll);
+    /// Check if the field type is a c_wchar array (element type has _type_ == 'u')
+    fn is_wchar_array(proto: &PyObject, vm: &VirtualMachine) -> bool {
+        // Get element_type from StgInfo (for array types)
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = proto_type.stg_info_opt()
+            && let Some(element_type) = &stg.element_type
+        {
+            // Check if element type has _type_ == "u"
+            if let Ok(type_code) = element_type.as_object().get_attr("_type_", vm)
+                && let Some(s) = type_code.downcast_ref::<PyStr>()
+            {
+                return s.as_str() == "u";
+            }
         }
+        false
+    }
 
-        Ok(instance)
+    /// Convert bytes for c_char array assignment (stops at first null terminator)
+    /// Returns (bytes_to_copy, copy_len)
+    fn bytes_for_char_array(src: &[u8]) -> &[u8] {
+        // Find first null terminator and include it
+        if let Some(null_pos) = src.iter().position(|&b| b == 0) {
+            &src[..=null_pos]
+        } else {
+            src
+        }
     }
 }
 
-impl PyCSimple {
-    pub fn to_arg(
-        &self,
-        ty: libffi::middle::Type,
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION, IMMUTABLETYPE),
+    with(Representable, GetDescriptor)
+)]
+impl PyCField {
+    /// Get PyCData from object (works for both Structure and Union)
+    fn get_cdata_from_obj<'a>(obj: &'a PyObjectRef, vm: &VirtualMachine) -> PyResult<&'a PyCData> {
+        if let Some(s) = obj.downcast_ref::<super::structure::PyCStructure>() {
+            Ok(&s.0)
+        } else if let Some(u) = obj.downcast_ref::<super::union::PyCUnion>() {
+            Ok(&u.0)
+        } else {
+            Err(vm.new_type_error(format!(
+                "descriptor works only on Structure or Union instances, got {}",
+                obj.class().name()
+            )))
+        }
+    }
+
+    /// PyCField_set
+    #[pyslot]
+    fn descr_set(
+        zelf: &crate::PyObject,
+        obj: PyObjectRef,
+        value: PySetterValue<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let zelf = zelf
+            .downcast_ref::<PyCField>()
+            .ok_or_else(|| vm.new_type_error("expected CField"))?;
+
+        let offset = zelf.offset as usize;
+        let size = zelf.byte_size();
+
+        // Get PyCData from obj (works for both Structure and Union)
+        let cdata = Self::get_cdata_from_obj(&obj, vm)?;
+
+        match value {
+            PySetterValue::Assign(value) => {
+                // Check if needs byte swapping
+                let needs_swap = (obj
+                    .class()
+                    .as_object()
+                    .get_attr("_swappedbytes_", vm)
+                    .is_ok()
+                    || zelf
+                        .proto
+                        .as_object()
+                        .get_attr("_swappedbytes_", vm)
+                        .is_ok())
+                    && size > 1;
+
+                // PyCData_set
+                cdata.set_field(
+                    zelf.proto.as_object(),
+                    value,
+                    zelf.index,
+                    size,
+                    offset,
+                    needs_swap,
+                    vm,
+                )
+            }
+            PySetterValue::Delete => Err(vm.new_type_error("cannot delete field")),
+        }
+    }
+
+    #[pymethod]
+    fn __set__(
+        zelf: PyObjectRef,
+        obj: PyObjectRef,
+        value: PyObjectRef,
         vm: &VirtualMachine,
-    ) -> Option<libffi::middle::Arg> {
-        let value = unsafe { (*self.value.as_ptr()).clone() };
-        if let Ok(i) = value.try_int(vm) {
-            let i = i.as_bigint();
-            return if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
-                i.to_u8().map(|r: u8| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
-                i.to_i8().map(|r: i8| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
-                i.to_u16().map(|r: u16| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
-                i.to_i16().map(|r: i16| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
-                i.to_u32().map(|r: u32| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
-                i.to_i32().map(|r: i32| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
-                i.to_u64().map(|r: u64| libffi::middle::Arg::new(&r))
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
-                i.to_i64().map(|r: i64| libffi::middle::Arg::new(&r))
+    ) -> PyResult<()> {
+        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
+    }
+
+    #[pymethod]
+    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
+    }
+
+    #[pygetset]
+    fn offset(&self) -> isize {
+        self.offset
+    }
+
+    #[pygetset]
+    fn size(&self) -> isize {
+        self.size
+    }
+}
+
+// ParamFunc implementations (PyCArgObject creation)
+
+use super::_ctypes::CArgObject;
+
+/// Call the appropriate paramfunc based on StgInfo.paramfunc
+/// info->paramfunc(st, obj)
+pub(super) fn call_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    let cls = obj.class();
+    let stg_info = cls
+        .stg_info_opt()
+        .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+
+    match stg_info.paramfunc {
+        ParamFunc::Simple => simple_paramfunc(obj, vm),
+        ParamFunc::Array => array_paramfunc(obj, vm),
+        ParamFunc::Pointer => pointer_paramfunc(obj, vm),
+        ParamFunc::Structure | ParamFunc::Union => struct_union_paramfunc(obj, &stg_info, vm),
+        ParamFunc::None => Err(vm.new_type_error("no paramfunc")),
+    }
+}
+
+/// PyCSimpleType_paramfunc
+fn simple_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::simple::PyCSimple;
+
+    let simple = obj
+        .downcast_ref::<PyCSimple>()
+        .ok_or_else(|| vm.new_type_error("expected simple type"))?;
+
+    // Get type code from _type_ attribute
+    let cls = obj.class().to_owned();
+    let type_code = cls
+        .type_code(vm)
+        .ok_or_else(|| vm.new_type_error("no _type_ attribute"))?;
+    let tag = type_code.as_bytes().first().copied().unwrap_or(b'?');
+
+    // Read value from buffer: memcpy(&parg->value, self->b_ptr, self->b_size)
+    let buffer = simple.0.buffer.read();
+    let ffi_value = buffer_to_ffi_value(&type_code, &buffer);
+
+    Ok(CArgObject {
+        tag,
+        value: ffi_value,
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// PyCArrayType_paramfunc
+fn array_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::array::PyCArray;
+
+    let array = obj
+        .downcast_ref::<PyCArray>()
+        .ok_or_else(|| vm.new_type_error("expected array"))?;
+
+    // p->value.p = (char *)self->b_ptr
+    let buffer = array.0.buffer.read();
+    let ptr_val = buffer.as_ptr() as usize;
+
+    Ok(CArgObject {
+        tag: b'P',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// PyCPointerType_paramfunc
+fn pointer_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::pointer::PyCPointer;
+
+    let ptr = obj
+        .downcast_ref::<PyCPointer>()
+        .ok_or_else(|| vm.new_type_error("expected pointer"))?;
+
+    // parg->value.p = *(void **)self->b_ptr
+    let ptr_val = ptr.get_ptr_value();
+
+    Ok(CArgObject {
+        tag: b'P',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// StructUnionType_paramfunc (for both Structure and Union)
+fn struct_union_paramfunc(
+    obj: &PyObject,
+    stg_info: &StgInfo,
+    _vm: &VirtualMachine,
+) -> PyResult<CArgObject> {
+    // Get buffer pointer
+    // For large structs (> sizeof(void*)), we'd need to allocate and copy.
+    // For now, just point to buffer directly and keep obj reference for memory safety.
+    let buffer = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+        cdata.buffer.read()
+    } else {
+        return Ok(CArgObject {
+            tag: b'V',
+            value: FfiArgValue::Pointer(0),
+            obj: obj.to_owned(),
+            size: stg_info.size,
+            offset: 0,
+        });
+    };
+
+    let ptr_val = buffer.as_ptr() as usize;
+    let size = buffer.len();
+
+    Ok(CArgObject {
+        tag: b'V',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size,
+        offset: 0,
+    })
+}
+
+// FfiArgValue - Owned FFI argument value
+
+/// Owned FFI argument value. Keeps the value alive for the duration of the FFI call.
+#[derive(Debug, Clone)]
+pub enum FfiArgValue {
+    U8(u8),
+    I8(i8),
+    U16(u16),
+    I16(i16),
+    U32(u32),
+    I32(i32),
+    U64(u64),
+    I64(i64),
+    F32(f32),
+    F64(f64),
+    Pointer(usize),
+    /// Pointer with owned data. The PyObjectRef keeps the pointed data alive.
+    OwnedPointer(usize, #[allow(dead_code)] crate::PyObjectRef),
+}
+
+impl FfiArgValue {
+    /// Create an Arg reference to this owned value
+    pub fn as_arg(&self) -> libffi::middle::Arg {
+        match self {
+            FfiArgValue::U8(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I8(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U16(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I16(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::F32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::F64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::Pointer(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::OwnedPointer(v, _) => libffi::middle::Arg::new(v),
+        }
+    }
+}
+
+/// Convert buffer bytes to FfiArgValue based on type code
+pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue {
+    match type_code {
+        "c" | "b" => {
+            let v = buffer.first().map(|&b| b as i8).unwrap_or(0);
+            FfiArgValue::I8(v)
+        }
+        "B" => {
+            let v = buffer.first().copied().unwrap_or(0);
+            FfiArgValue::U8(v)
+        }
+        "h" => {
+            let v = if buffer.len() >= 2 {
+                i16::from_ne_bytes(buffer[..2].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::I16(v)
+        }
+        "H" => {
+            let v = if buffer.len() >= 2 {
+                u16::from_ne_bytes(buffer[..2].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U16(v)
+        }
+        "i" => {
+            let v = if buffer.len() >= 4 {
+                i32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::I32(v)
+        }
+        "I" => {
+            let v = if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U32(v)
+        }
+        "l" | "q" => {
+            let v = if buffer.len() >= 8 {
+                i64::from_ne_bytes(buffer[..8].try_into().unwrap())
+            } else if buffer.len() >= 4 {
+                i32::from_ne_bytes(buffer[..4].try_into().unwrap()) as i64
+            } else {
+                0
+            };
+            FfiArgValue::I64(v)
+        }
+        "L" | "Q" => {
+            let v = if buffer.len() >= 8 {
+                u64::from_ne_bytes(buffer[..8].try_into().unwrap())
+            } else if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap()) as u64
+            } else {
+                0
+            };
+            FfiArgValue::U64(v)
+        }
+        "f" => {
+            let v = if buffer.len() >= 4 {
+                f32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0.0
+            };
+            FfiArgValue::F32(v)
+        }
+        "d" | "g" => {
+            let v = if buffer.len() >= 8 {
+                f64::from_ne_bytes(buffer[..8].try_into().unwrap())
             } else {
-                None
+                0.0
             };
+            FfiArgValue::F64(v)
         }
-        if let Ok(_f) = value.try_float(vm) {
-            todo!();
+        "z" | "Z" | "P" | "O" => FfiArgValue::Pointer(read_ptr_from_buffer(buffer)),
+        "?" => {
+            let v = buffer.first().map(|&b| b != 0).unwrap_or(false);
+            FfiArgValue::U8(if v { 1 } else { 0 })
         }
-        if let Ok(_b) = value.try_to_bool(vm) {
-            todo!();
+        "u" => {
+            // wchar_t - 4 bytes on most platforms
+            let v = if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U32(v)
         }
-        None
+        _ => FfiArgValue::Pointer(0),
     }
 }
 
-static SIMPLE_BUFFER_METHODS: BufferMethods = BufferMethods {
-    obj_bytes: |buffer| {
-        rustpython_common::lock::PyMappedRwLockReadGuard::map(
-            rustpython_common::lock::PyRwLockReadGuard::map(
-                buffer.obj_as::<PyCSimple>().cdata.read(),
-                |x: &CDataObject| x,
-            ),
-            |x: &CDataObject| x.buffer.as_slice(),
-        )
-        .into()
-    },
-    obj_bytes_mut: |buffer| {
-        rustpython_common::lock::PyMappedRwLockWriteGuard::map(
-            rustpython_common::lock::PyRwLockWriteGuard::map(
-                buffer.obj_as::<PyCSimple>().cdata.write(),
-                |x: &mut CDataObject| x,
-            ),
-            |x: &mut CDataObject| x.buffer.as_mut_slice(),
-        )
-        .into()
-    },
-    release: |_| {},
-    retain: |_| {},
-};
+/// Convert bytes to appropriate Python object based on ctypes type
+pub(super) fn bytes_to_pyobject(
+    cls: &Py<PyType>,
+    bytes: &[u8],
+    vm: &VirtualMachine,
+) -> PyResult<PyObjectRef> {
+    // Try to get _type_ attribute
+    if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+        && let Ok(s) = type_attr.str(vm)
+    {
+        let ty = s.to_string();
+        return match ty.as_str() {
+            "c" => Ok(vm.ctx.new_bytes(bytes.to_vec()).into()),
+            "b" => {
+                let val = if !bytes.is_empty() { bytes[0] as i8 } else { 0 };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "B" => {
+                let val = if !bytes.is_empty() { bytes[0] } else { 0 };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "h" => {
+                const SIZE: usize = mem::size_of::<c_short>();
+                let val = if bytes.len() >= SIZE {
+                    c_short::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "H" => {
+                const SIZE: usize = mem::size_of::<c_ushort>();
+                let val = if bytes.len() >= SIZE {
+                    c_ushort::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "i" => {
+                const SIZE: usize = mem::size_of::<c_int>();
+                let val = if bytes.len() >= SIZE {
+                    c_int::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "I" => {
+                const SIZE: usize = mem::size_of::<c_uint>();
+                let val = if bytes.len() >= SIZE {
+                    c_uint::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "l" => {
+                const SIZE: usize = mem::size_of::<c_long>();
+                let val = if bytes.len() >= SIZE {
+                    c_long::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "L" => {
+                const SIZE: usize = mem::size_of::<c_ulong>();
+                let val = if bytes.len() >= SIZE {
+                    c_ulong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "q" => {
+                const SIZE: usize = mem::size_of::<c_longlong>();
+                let val = if bytes.len() >= SIZE {
+                    c_longlong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "Q" => {
+                const SIZE: usize = mem::size_of::<c_ulonglong>();
+                let val = if bytes.len() >= SIZE {
+                    c_ulonglong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "f" => {
+                const SIZE: usize = mem::size_of::<c_float>();
+                let val = if bytes.len() >= SIZE {
+                    c_float::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val as f64).into())
+            }
+            "d" => {
+                const SIZE: usize = mem::size_of::<c_double>();
+                let val = if bytes.len() >= SIZE {
+                    c_double::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val).into())
+            }
+            "g" => {
+                // long double - read as f64 for now since Rust doesn't have native long double
+                // This may lose precision on platforms where long double > 64 bits
+                const SIZE: usize = mem::size_of::<c_double>();
+                let val = if bytes.len() >= SIZE {
+                    c_double::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val).into())
+            }
+            "?" => {
+                let val = !bytes.is_empty() && bytes[0] != 0;
+                Ok(vm.ctx.new_bool(val).into())
+            }
+            "v" => {
+                // VARIANT_BOOL: non-zero = True, zero = False
+                const SIZE: usize = mem::size_of::<c_short>();
+                let val = if bytes.len() >= SIZE {
+                    c_short::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_bool(val != 0).into())
+            }
+            "z" => {
+                // c_char_p: read NULL-terminated string from pointer
+                let ptr = read_ptr_from_buffer(bytes);
+                if ptr == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                let c_str = unsafe { std::ffi::CStr::from_ptr(ptr as _) };
+                Ok(vm.ctx.new_bytes(c_str.to_bytes().to_vec()).into())
+            }
+            "Z" => {
+                // c_wchar_p: read NULL-terminated wide string from pointer
+                let ptr = read_ptr_from_buffer(bytes);
+                if ptr == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                let len = unsafe { libc::wcslen(ptr as *const libc::wchar_t) };
+                let wchars =
+                    unsafe { std::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
+                let s: String = wchars
+                    .iter()
+                    .filter_map(|&c| char::from_u32(c as u32))
+                    .collect();
+                Ok(vm.ctx.new_str(s).into())
+            }
+            "P" => {
+                // c_void_p: return pointer value as integer
+                let val = read_ptr_from_buffer(bytes);
+                if val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "u" => {
+                let val = if bytes.len() >= mem::size_of::<WideChar>() {
+                    let wc = if mem::size_of::<WideChar>() == 2 {
+                        u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+                    } else {
+                        u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+                    };
+                    char::from_u32(wc).unwrap_or('\0')
+                } else {
+                    '\0'
+                };
+                Ok(vm.ctx.new_str(val).into())
+            }
+            _ => Ok(vm.ctx.none()),
+        };
+    }
+    // Default: return bytes as-is
+    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+}
 
-impl AsBuffer for PyCSimple {
-    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-        let buffer_len = zelf.cdata.read().buffer.len();
-        let buf = PyBuffer::new(
-            zelf.to_owned().into(),
-            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
-            &SIMPLE_BUFFER_METHODS,
-        );
-        Ok(buf)
+// Shared functions for Structure and Union types
+
+/// Parse a non-negative integer attribute, returning default if not present
+pub(super) fn get_usize_attr(
+    obj: &PyObject,
+    attr: &str,
+    default: usize,
+    vm: &VirtualMachine,
+) -> PyResult<usize> {
+    let Ok(attr_val) = obj.get_attr(vm.ctx.intern_str(attr), vm) else {
+        return Ok(default);
+    };
+    let n = attr_val
+        .try_int(vm)
+        .map_err(|_| vm.new_value_error(format!("{attr} must be a non-negative integer")))?;
+    let val = n.as_bigint();
+    if val.is_negative() {
+        return Err(vm.new_value_error(format!("{attr} must be a non-negative integer")));
+    }
+    Ok(val.to_usize().unwrap_or(default))
+}
+
+/// Read a pointer value from buffer
+#[inline]
+pub(super) fn read_ptr_from_buffer(buffer: &[u8]) -> usize {
+    const PTR_SIZE: usize = std::mem::size_of::<usize>();
+    if buffer.len() >= PTR_SIZE {
+        usize::from_ne_bytes(buffer[..PTR_SIZE].try_into().unwrap())
+    } else {
+        0
+    }
+}
+
+/// Set or initialize StgInfo on a type
+pub(super) fn set_or_init_stginfo(type_ref: &PyType, stg_info: StgInfo) {
+    if type_ref.init_type_data(stg_info.clone()).is_err()
+        && let Some(mut existing) = type_ref.get_type_data_mut::<StgInfo>()
+    {
+        *existing = stg_info;
+    }
+}
+
+/// Check if a field type supports byte order swapping
+pub(super) fn check_other_endian_support(
+    field_type: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let other_endian_attr = if cfg!(target_endian = "little") {
+        "__ctype_be__"
+    } else {
+        "__ctype_le__"
+    };
+
+    if field_type.get_attr(other_endian_attr, vm).is_ok() {
+        return Ok(());
+    }
+
+    // Array type: recursively check element type
+    if let Ok(elem_type) = field_type.get_attr("_type_", vm)
+        && field_type.get_attr("_length_", vm).is_ok()
+    {
+        return check_other_endian_support(&elem_type, vm);
     }
+
+    // Structure/Union: has StgInfo but no _type_ attribute
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && type_obj.stg_info_opt().is_some()
+        && field_type.get_attr("_type_", vm).is_err()
+    {
+        return Ok(());
+    }
+
+    Err(vm.new_type_error(format!(
+        "This type does not support other endian: {}",
+        field_type.class().name()
+    )))
+}
+
+/// Get the size of a ctypes field type
+pub(super) fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+    {
+        return Ok(stg_info.size);
+    }
+
+    if let Some(size) = field_type
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|type_attr| type_attr.str(vm).ok())
+        .and_then(|type_str| {
+            let s = type_str.to_string();
+            (s.len() == 1).then(|| super::get_size(&s))
+        })
+    {
+        return Ok(size);
+    }
+
+    if let Some(s) = field_type
+        .get_attr("size_of_instances", vm)
+        .ok()
+        .and_then(|size_method| size_method.call((), vm).ok())
+        .and_then(|size| size.try_int(vm).ok())
+        .and_then(|n| n.as_bigint().to_usize())
+    {
+        return Ok(s);
+    }
+
+    Ok(std::mem::size_of::<usize>())
+}
+
+/// Get the alignment of a ctypes field type
+pub(super) fn get_field_align(field_type: &PyObject, vm: &VirtualMachine) -> usize {
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+        && stg_info.align > 0
+    {
+        return stg_info.align;
+    }
+
+    if let Some(align) = field_type
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|type_attr| type_attr.str(vm).ok())
+        .and_then(|type_str| {
+            let s = type_str.to_string();
+            (s.len() == 1).then(|| super::get_size(&s))
+        })
+    {
+        return align;
+    }
+
+    1
+}
+
+/// Promote fields from anonymous struct/union to parent type
+fn make_fields(
+    cls: &Py<PyType>,
+    descr: &super::PyCField,
+    index: usize,
+    offset: isize,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    use crate::builtins::{PyList, PyTuple};
+    use crate::convert::ToPyObject;
+
+    let fields = descr.proto.as_object().get_attr("_fields_", vm)?;
+    let fieldlist: Vec<PyObjectRef> = if let Some(list) = fields.downcast_ref::<PyList>() {
+        list.borrow_vec().to_vec()
+    } else if let Some(tuple) = fields.downcast_ref::<PyTuple>() {
+        tuple.to_vec()
+    } else {
+        return Err(vm.new_type_error("_fields_ must be a sequence"));
+    };
+
+    for pair in fieldlist.iter() {
+        let field_tuple = pair
+            .downcast_ref::<PyTuple>()
+            .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
+
+        if field_tuple.len() < 2 {
+            continue;
+        }
+
+        let fname = field_tuple
+            .first()
+            .expect("len checked")
+            .downcast_ref::<PyStr>()
+            .ok_or_else(|| vm.new_type_error("field name must be a string"))?;
+
+        let fdescr_obj = descr
+            .proto
+            .as_object()
+            .get_attr(vm.ctx.intern_str(fname.as_str()), vm)?;
+        let fdescr = fdescr_obj
+            .downcast_ref::<super::PyCField>()
+            .ok_or_else(|| vm.new_type_error("unexpected type"))?;
+
+        if fdescr.anonymous {
+            make_fields(
+                cls,
+                fdescr,
+                index + fdescr.index,
+                offset + fdescr.offset,
+                vm,
+            )?;
+            continue;
+        }
+
+        let new_descr = super::PyCField::new_from_field(fdescr, index, offset);
+        cls.set_attr(vm.ctx.intern_str(fname.as_str()), new_descr.to_pyobject(vm));
+    }
+
+    Ok(())
+}
+
+/// Process _anonymous_ attribute for struct/union
+pub(super) fn make_anon_fields(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<()> {
+    use crate::builtins::{PyList, PyTuple};
+    use crate::convert::ToPyObject;
+
+    let anon = match cls.as_object().get_attr("_anonymous_", vm) {
+        Ok(anon) => anon,
+        Err(_) => return Ok(()),
+    };
+
+    let anon_names: Vec<PyObjectRef> = if let Some(list) = anon.downcast_ref::<PyList>() {
+        list.borrow_vec().to_vec()
+    } else if let Some(tuple) = anon.downcast_ref::<PyTuple>() {
+        tuple.to_vec()
+    } else {
+        return Err(vm.new_type_error("_anonymous_ must be a sequence"));
+    };
+
+    for fname_obj in anon_names.iter() {
+        let fname = fname_obj
+            .downcast_ref::<PyStr>()
+            .ok_or_else(|| vm.new_type_error("_anonymous_ items must be strings"))?;
+
+        let descr_obj = cls
+            .as_object()
+            .get_attr(vm.ctx.intern_str(fname.as_str()), vm)?;
+
+        let descr = descr_obj.downcast_ref::<super::PyCField>().ok_or_else(|| {
+            vm.new_attribute_error(format!(
+                "'{}' is specified in _anonymous_ but not in _fields_",
+                fname.as_str()
+            ))
+        })?;
+
+        let mut new_descr = super::PyCField::new_from_field(descr, 0, 0);
+        new_descr.set_anonymous(true);
+        cls.set_attr(vm.ctx.intern_str(fname.as_str()), new_descr.to_pyobject(vm));
+
+        make_fields(cls, descr, descr.index, descr.offset, vm)?;
+    }
+
+    Ok(())
 }
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
index b4e600f77ba..9bddb0ef0e8 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -1,67 +1,310 @@
 // spell-checker:disable
 
-use crate::builtins::{PyNone, PyStr, PyTuple, PyTupleRef, PyType, PyTypeRef};
-use crate::convert::ToPyObject;
-use crate::function::FuncArgs;
-use crate::stdlib::ctypes::PyCData;
-use crate::stdlib::ctypes::base::{CDataObject, PyCSimple, ffi_type_from_str};
-use crate::stdlib::ctypes::thunk::PyCThunk;
-use crate::types::Representable;
-use crate::types::{Callable, Constructor};
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
-use crossbeam_utils::atomic::AtomicCell;
-use libffi::middle::{Arg, Cif, CodePtr, Type};
+use super::{
+    _ctypes::CArgObject, PyCArray, PyCData, PyCPointer, PyCStructure, base::FfiArgValue,
+    simple::PyCSimple, type_info,
+};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyDict, PyNone, PyStr, PyTuple, PyType, PyTypeRef},
+    class::StaticType,
+    convert::ToPyObject,
+    function::FuncArgs,
+    types::{Callable, Constructor, Representable},
+    vm::thread::with_current_vm,
+};
+use libffi::{
+    low,
+    middle::{Arg, Cif, Closure, CodePtr, Type},
+};
 use libloading::Symbol;
 use num_traits::ToPrimitive;
 use rustpython_common::lock::PyRwLock;
 use std::ffi::{self, c_void};
 use std::fmt::Debug;
 
-// See also: https://github.com/python/cpython/blob/4f8bb3947cfbc20f970ff9d9531e1132a9e95396/Modules/_ctypes/callproc.c#L15
+// Internal function addresses for special ctypes functions
+pub(super) const INTERNAL_CAST_ADDR: usize = 1;
+pub(super) const INTERNAL_STRING_AT_ADDR: usize = 2;
+pub(super) const INTERNAL_WSTRING_AT_ADDR: usize = 3;
 
 type FP = unsafe extern "C" fn();
 
-pub trait ArgumentType {
+/// Get FFI type for a ctypes type code
+fn get_ffi_type(ty: &str) -> Option<libffi::middle::Type> {
+    type_info(ty).map(|t| (t.ffi_type_fn)())
+}
+
+// PyCFuncPtr - Function pointer implementation
+
+/// Get FFI type from CArgObject tag character
+fn ffi_type_from_tag(tag: u8) -> Type {
+    match tag {
+        b'c' | b'b' => Type::i8(),
+        b'B' => Type::u8(),
+        b'h' => Type::i16(),
+        b'H' => Type::u16(),
+        b'i' => Type::i32(),
+        b'I' => Type::u32(),
+        b'l' => {
+            if std::mem::size_of::<libc::c_long>() == 8 {
+                Type::i64()
+            } else {
+                Type::i32()
+            }
+        }
+        b'L' => {
+            if std::mem::size_of::<libc::c_ulong>() == 8 {
+                Type::u64()
+            } else {
+                Type::u32()
+            }
+        }
+        b'q' => Type::i64(),
+        b'Q' => Type::u64(),
+        b'f' => Type::f32(),
+        b'd' | b'g' => Type::f64(),
+        b'?' => Type::u8(),
+        b'u' => {
+            if std::mem::size_of::<super::WideChar>() == 2 {
+                Type::u16()
+            } else {
+                Type::u32()
+            }
+        }
+        _ => Type::pointer(), // 'P', 'V', 'z', 'Z', 'O', etc.
+    }
+}
+
+/// Convert any object to a pointer value for c_void_p arguments
+/// Follows ConvParam logic for pointer types
+fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgValue> {
+    // 0. CArgObject (from byref()) -> buffer address + offset
+    if let Some(carg) = value.downcast_ref::<CArgObject>() {
+        // Get buffer address from the underlying object
+        let base_addr = if let Some(cdata) = carg.obj.downcast_ref::<PyCData>() {
+            cdata.buffer.read().as_ptr() as usize
+        } else {
+            return Err(vm.new_type_error(format!(
+                "byref() argument must be a ctypes instance, not '{}'",
+                carg.obj.class().name()
+            )));
+        };
+        let addr = (base_addr as isize + carg.offset) as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 1. None -> NULL
+    if value.is(&vm.ctx.none) {
+        return Ok(FfiArgValue::Pointer(0));
+    }
+
+    // 2. PyCArray -> buffer address (PyCArrayType_paramfunc)
+    if let Some(array) = value.downcast_ref::<PyCArray>() {
+        let addr = array.0.buffer.read().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 3. PyCPointer -> stored pointer value
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>() {
+        return Ok(FfiArgValue::Pointer(ptr.get_ptr_value()));
+    }
+
+    // 4. PyCStructure -> buffer address
+    if let Some(struct_obj) = value.downcast_ref::<PyCStructure>() {
+        let addr = struct_obj.0.buffer.read().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 5. PyCSimple (c_void_p, c_char_p, etc.) -> value from buffer
+    if let Some(simple) = value.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= std::mem::size_of::<usize>() {
+            let addr = super::base::read_ptr_from_buffer(&buffer);
+            return Ok(FfiArgValue::Pointer(addr));
+        }
+    }
+
+    // 6. bytes -> buffer address (PyBytes_AsString)
+    if let Some(bytes) = value.downcast_ref::<crate::builtins::PyBytes>() {
+        let addr = bytes.as_bytes().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 7. Integer -> direct value
+    if let Ok(int_val) = value.try_int(vm) {
+        return Ok(FfiArgValue::Pointer(
+            int_val.as_bigint().to_usize().unwrap_or(0),
+        ));
+    }
+
+    // 8. Check _as_parameter_ attribute ( recursive ConvParam)
+    if let Ok(as_param) = value.get_attr("_as_parameter_", vm) {
+        return convert_to_pointer(&as_param, vm);
+    }
+
+    Err(vm.new_type_error(format!(
+        "cannot convert '{}' to c_void_p",
+        value.class().name()
+    )))
+}
+
+/// ConvParam-like conversion for when argtypes is None
+/// Returns both the FFI type and the converted value
+fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<(Type, FfiArgValue)> {
+    // 1. CArgObject (from byref() or paramfunc) -> use stored type and value
+    if let Some(carg) = value.downcast_ref::<CArgObject>() {
+        let ffi_type = ffi_type_from_tag(carg.tag);
+        return Ok((ffi_type, carg.value.clone()));
+    }
+
+    // 2. None -> NULL pointer
+    if value.is(&vm.ctx.none) {
+        return Ok((Type::pointer(), FfiArgValue::Pointer(0)));
+    }
+
+    // 3. ctypes objects -> use paramfunc
+    if let Ok(carg) = super::base::call_paramfunc(value, vm) {
+        let ffi_type = ffi_type_from_tag(carg.tag);
+        return Ok((ffi_type, carg.value.clone()));
+    }
+
+    // 4. Python str -> pointer (use internal UTF-8 buffer)
+    if let Some(s) = value.downcast_ref::<PyStr>() {
+        let addr = s.as_str().as_ptr() as usize;
+        return Ok((Type::pointer(), FfiArgValue::Pointer(addr)));
+    }
+
+    // 9. Python bytes -> pointer to buffer
+    if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+        let addr = bytes.as_bytes().as_ptr() as usize;
+        return Ok((Type::pointer(), FfiArgValue::Pointer(addr)));
+    }
+
+    // 10. Python int -> i32 (default integer type)
+    if let Ok(int_val) = value.try_int(vm) {
+        let val = int_val.as_bigint().to_i32().unwrap_or(0);
+        return Ok((Type::i32(), FfiArgValue::I32(val)));
+    }
+
+    // 11. Python float -> f64
+    if let Ok(float_val) = value.try_float(vm) {
+        return Ok((Type::f64(), FfiArgValue::F64(float_val.to_f64())));
+    }
+
+    // 12. Check _as_parameter_ attribute
+    if let Ok(as_param) = value.get_attr("_as_parameter_", vm) {
+        return conv_param(&as_param, vm);
+    }
+
+    Err(vm.new_type_error(format!(
+        "Don't know how to convert parameter {}",
+        value.class().name()
+    )))
+}
+
+trait ArgumentType {
     fn to_ffi_type(&self, vm: &VirtualMachine) -> PyResult<Type>;
-    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<Arg>;
+    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<FfiArgValue>;
 }
 
 impl ArgumentType for PyTypeRef {
     fn to_ffi_type(&self, vm: &VirtualMachine) -> PyResult<Type> {
+        use super::pointer::PyCPointer;
+        use super::structure::PyCStructure;
+
+        // CArgObject (from byref()) should be treated as pointer
+        if self.fast_issubclass(CArgObject::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Pointer types (POINTER(T)) are always pointer FFI type
+        // Check if type is a subclass of _Pointer (PyCPointer)
+        if self.fast_issubclass(PyCPointer::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Structure types are passed as pointers
+        if self.fast_issubclass(PyCStructure::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Use get_attr to traverse MRO (for subclasses like MyInt(c_int))
         let typ = self
-            .get_class_attr(vm.ctx.intern_str("_type_"))
-            .ok_or(vm.new_type_error("Unsupported argument type".to_string()))?;
+            .as_object()
+            .get_attr(vm.ctx.intern_str("_type_"), vm)
+            .ok()
+            .ok_or(vm.new_type_error("Unsupported argument type"))?;
         let typ = typ
             .downcast_ref::<PyStr>()
-            .ok_or(vm.new_type_error("Unsupported argument type".to_string()))?;
+            .ok_or(vm.new_type_error("Unsupported argument type"))?;
         let typ = typ.to_string();
         let typ = typ.as_str();
-        let converted_typ = ffi_type_from_str(typ);
-        if let Some(typ) = converted_typ {
-            Ok(typ)
-        } else {
-            Err(vm.new_type_error(format!("Unsupported argument type: {}", typ)))
-        }
+        get_ffi_type(typ)
+            .ok_or_else(|| vm.new_type_error(format!("Unsupported argument type: {}", typ)))
     }
 
-    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<Arg> {
-        // if self.fast_isinstance::<PyCArray>(vm) {
-        //     let array = value.downcast::<PyCArray>()?;
-        //     return Ok(Arg::from(array.as_ptr()));
-        // }
-        if let Ok(simple) = value.downcast::<PyCSimple>() {
+    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<FfiArgValue> {
+        // Call from_param first to convert the value (like CPython's callproc.c:1235)
+        // converter = PyTuple_GET_ITEM(argtypes, i);
+        // v = PyObject_CallOneArg(converter, arg);
+        let from_param = self
+            .as_object()
+            .get_attr(vm.ctx.intern_str("from_param"), vm)?;
+        let converted = from_param.call((value.clone(),), vm)?;
+
+        // Then pass the converted value to ConvParam logic
+        // CArgObject (from from_param) -> use stored value directly
+        if let Some(carg) = converted.downcast_ref::<CArgObject>() {
+            return Ok(carg.value.clone());
+        }
+
+        // None -> NULL pointer
+        if vm.is_none(&converted) {
+            return Ok(FfiArgValue::Pointer(0));
+        }
+
+        // For pointer types (POINTER(T)), we need to pass the ADDRESS of the value's buffer
+        if self.fast_issubclass(PyCPointer::static_type()) {
+            if let Some(cdata) = converted.downcast_ref::<PyCData>() {
+                let addr = cdata.buffer.read().as_ptr() as usize;
+                return Ok(FfiArgValue::Pointer(addr));
+            }
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // For structure types, convert to pointer to structure
+        if self.fast_issubclass(PyCStructure::static_type()) {
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // Get the type code for this argument type
+        let type_code = self
+            .as_object()
+            .get_attr(vm.ctx.intern_str("_type_"), vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        // For pointer types (c_void_p, c_char_p, c_wchar_p), handle as pointer
+        if matches!(type_code.as_deref(), Some("P") | Some("z") | Some("Z")) {
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // PyCSimple (already a ctypes instance from from_param)
+        if let Ok(simple) = converted.clone().downcast::<PyCSimple>() {
             let typ = ArgumentType::to_ffi_type(self, vm)?;
-            let arg = simple
-                .to_arg(typ, vm)
-                .ok_or(vm.new_type_error("Unsupported argument type".to_string()))?;
-            return Ok(arg);
+            let ffi_value = simple
+                .to_ffi_value(typ, vm)
+                .ok_or(vm.new_type_error("Unsupported argument type"))?;
+            return Ok(ffi_value);
         }
-        Err(vm.new_type_error("Unsupported argument type".to_string()))
+
+        Err(vm.new_type_error("Unsupported argument type"))
     }
 }
 
-pub trait ReturnType {
-    fn to_ffi_type(&self) -> Option<Type>;
+trait ReturnType {
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> Option<Type>;
     #[allow(clippy::wrong_self_convention)]
     fn from_ffi_type(
         &self,
@@ -71,8 +314,34 @@ pub trait ReturnType {
 }
 
 impl ReturnType for PyTypeRef {
-    fn to_ffi_type(&self) -> Option<Type> {
-        ffi_type_from_str(self.name().to_string().as_str())
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> Option<Type> {
+        // Try to get _type_ attribute first (for ctypes types like c_void_p)
+        if let Ok(type_attr) = self.as_object().get_attr(vm.ctx.intern_str("_type_"), vm)
+            && let Some(s) = type_attr.downcast_ref::<PyStr>()
+            && let Some(ffi_type) = get_ffi_type(s.as_str())
+        {
+            return Some(ffi_type);
+        }
+
+        // Check for Structure/Array types (have StgInfo but no _type_)
+        // _ctypes_get_ffi_type: returns appropriately sized type for struct returns
+        if let Some(stg_info) = self.stg_info_opt() {
+            let size = stg_info.size;
+            // Small structs can be returned in registers
+            // Match can_return_struct_as_int/can_return_struct_as_sint64
+            return Some(if size <= 4 {
+                Type::i32()
+            } else if size <= 8 {
+                Type::i64()
+            } else {
+                // Large structs: use pointer-sized return
+                // (ABI typically returns via hidden pointer parameter)
+                Type::pointer()
+            });
+        }
+
+        // Fallback to class name
+        get_ffi_type(self.name().to_string().as_str())
     }
 
     fn from_ffi_type(
@@ -80,9 +349,11 @@ impl ReturnType for PyTypeRef {
         value: *mut ffi::c_void,
         vm: &VirtualMachine,
     ) -> PyResult<Option<PyObjectRef>> {
-        // Get the type code from _type_ attribute
+        // Get the type code from _type_ attribute (use get_attr to traverse MRO)
         let type_code = self
-            .get_class_attr(vm.ctx.intern_str("_type_"))
+            .as_object()
+            .get_attr(vm.ctx.intern_str("_type_"), vm)
+            .ok()
             .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
 
         let result = match type_code.as_deref() {
@@ -129,27 +400,59 @@ impl ReturnType for PyTypeRef {
                 .new_float(unsafe { *(value as *const f32) } as f64)
                 .into(),
             Some("d") => vm.ctx.new_float(unsafe { *(value as *const f64) }).into(),
-            Some("P") | Some("z") | Some("Z") => vm.ctx.new_int(value as usize).into(),
+            Some("P") | Some("z") | Some("Z") => {
+                vm.ctx.new_int(unsafe { *(value as *const usize) }).into()
+            }
             Some("?") => vm
                 .ctx
                 .new_bool(unsafe { *(value as *const u8) } != 0)
                 .into(),
             None => {
-                // No _type_ attribute, try to create an instance of the type
-                // This handles cases like Structure or Array return types
-                return Ok(Some(
-                    vm.ctx.new_int(unsafe { *(value as *const i32) }).into(),
-                ));
+                // No _type_ attribute - check for Structure/Array types
+                // GetResult: PyCData_FromBaseObj creates instance from memory
+                if let Some(stg_info) = self.stg_info_opt() {
+                    let size = stg_info.size;
+                    // Create instance of the ctypes type
+                    let instance = self.as_object().call((), vm)?;
+
+                    // Copy return value memory into instance buffer
+                    // Use a block to properly scope the borrow
+                    {
+                        let src = unsafe { std::slice::from_raw_parts(value as *const u8, size) };
+                        if let Some(cdata) = instance.downcast_ref::<PyCData>() {
+                            let mut buffer = cdata.buffer.write();
+                            if buffer.len() >= size {
+                                buffer.to_mut()[..size].copy_from_slice(src);
+                            }
+                        } else if let Some(structure) = instance.downcast_ref::<PyCStructure>() {
+                            let mut buffer = structure.0.buffer.write();
+                            if buffer.len() >= size {
+                                buffer.to_mut()[..size].copy_from_slice(src);
+                            }
+                        } else if let Some(array) = instance.downcast_ref::<PyCArray>() {
+                            let mut buffer = array.0.buffer.write();
+                            if buffer.len() >= size {
+                                buffer.to_mut()[..size].copy_from_slice(src);
+                            }
+                        }
+                    }
+                    return Ok(Some(instance));
+                }
+                // Not a ctypes type - call type with int result
+                return self
+                    .as_object()
+                    .call((unsafe { *(value as *const i32) },), vm)
+                    .map(Some);
             }
-            _ => return Err(vm.new_type_error("Unsupported return type".to_string())),
+            _ => return Err(vm.new_type_error("Unsupported return type")),
         };
         Ok(Some(result))
     }
 }
 
 impl ReturnType for PyNone {
-    fn to_ffi_type(&self) -> Option<Type> {
-        ffi_type_from_str("void")
+    fn to_ffi_type(&self, _vm: &VirtualMachine) -> Option<Type> {
+        get_ffi_type("void")
     }
 
     fn from_ffi_type(
@@ -161,47 +464,319 @@ impl ReturnType for PyNone {
     }
 }
 
+/// PyCFuncPtr - Function pointer instance
+/// Saved in _base.buffer
 #[pyclass(module = "_ctypes", name = "CFuncPtr", base = PyCData)]
-pub struct PyCFuncPtr {
-    _base: PyCData,
-    pub name: PyRwLock<Option<String>>,
-    pub ptr: PyRwLock<Option<CodePtr>>,
-    #[allow(dead_code)]
-    pub needs_free: AtomicCell<bool>,
-    pub arg_types: PyRwLock<Option<Vec<PyTypeRef>>>,
-    pub res_type: PyRwLock<Option<PyObjectRef>>,
-    pub _flags_: AtomicCell<i32>,
-    #[allow(dead_code)]
-    pub handler: PyObjectRef,
+#[repr(C)]
+pub(super) struct PyCFuncPtr {
+    pub _base: PyCData,
+    /// Thunk for callbacks (keeps thunk alive)
+    pub thunk: PyRwLock<Option<PyRef<PyCThunk>>>,
+    /// Original Python callable (for callbacks)
+    pub callable: PyRwLock<Option<PyObjectRef>>,
+    /// Converters cache
+    pub converters: PyRwLock<Option<PyObjectRef>>,
+    /// Instance-level argtypes override
+    pub argtypes: PyRwLock<Option<PyObjectRef>>,
+    /// Instance-level restype override
+    pub restype: PyRwLock<Option<PyObjectRef>>,
+    /// Checker function
+    pub checker: PyRwLock<Option<PyObjectRef>>,
+    /// Error checking function
+    pub errcheck: PyRwLock<Option<PyObjectRef>>,
+    /// COM method vtable index
+    /// When set, the function reads the function pointer from the vtable at call time
+    #[cfg(windows)]
+    pub index: PyRwLock<Option<usize>>,
+    /// COM method IID (interface ID) for error handling
+    #[cfg(windows)]
+    pub iid: PyRwLock<Option<PyObjectRef>>,
+    /// Parameter flags for COM methods (direction: IN=1, OUT=2, IN|OUT=4)
+    /// Each element is (direction, name, default) tuple
+    pub paramflags: PyRwLock<Option<PyObjectRef>>,
 }
 
 impl Debug for PyCFuncPtr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PyCFuncPtr")
-            .field("flags", &self._flags_)
+            .field("func_ptr", &self.get_func_ptr())
             .finish()
     }
 }
 
+/// Extract pointer value from a ctypes argument (c_void_p conversion)
+fn extract_ptr_from_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    // Try to get pointer value from various ctypes types
+    if let Some(ptr) = arg.downcast_ref::<PyCPointer>() {
+        return Ok(ptr.get_ptr_value());
+    }
+    if let Some(simple) = arg.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= std::mem::size_of::<usize>() {
+            return Ok(usize::from_ne_bytes(
+                buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+            ));
+        }
+    }
+    if let Some(cdata) = arg.downcast_ref::<PyCData>() {
+        // For arrays/structures, return address of buffer
+        return Ok(cdata.buffer.read().as_ptr() as usize);
+    }
+    // PyStr: return internal buffer address
+    if let Some(s) = arg.downcast_ref::<PyStr>() {
+        return Ok(s.as_str().as_ptr() as usize);
+    }
+    // PyBytes: return internal buffer address
+    if let Some(bytes) = arg.downcast_ref::<PyBytes>() {
+        return Ok(bytes.as_bytes().as_ptr() as usize);
+    }
+    // Try as integer
+    if let Ok(int_val) = arg.try_int(vm) {
+        return Ok(int_val.as_bigint().to_usize().unwrap_or(0));
+    }
+    Err(vm.new_type_error(format!(
+        "cannot convert '{}' to pointer",
+        arg.class().name()
+    )))
+}
+
+/// string_at implementation - read bytes from memory at ptr
+fn string_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
+    if ptr == 0 {
+        return Err(vm.new_value_error("NULL pointer access"));
+    }
+    let ptr = ptr as *const u8;
+    let len = if size < 0 {
+        // size == -1 means use strlen
+        unsafe { libc::strlen(ptr as _) }
+    } else {
+        // Overflow check for huge size values
+        let size_usize = size as usize;
+        if size_usize > isize::MAX as usize / 2 {
+            return Err(vm.new_overflow_error("string too long"));
+        }
+        size_usize
+    };
+    let bytes = unsafe { std::slice::from_raw_parts(ptr, len) };
+    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+}
+
+/// wstring_at implementation - read wide string from memory at ptr
+fn wstring_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
+    if ptr == 0 {
+        return Err(vm.new_value_error("NULL pointer access"));
+    }
+    let w_ptr = ptr as *const libc::wchar_t;
+    let len = if size < 0 {
+        unsafe { libc::wcslen(w_ptr) }
+    } else {
+        // Overflow check for huge size values
+        let size_usize = size as usize;
+        if size_usize > isize::MAX as usize / std::mem::size_of::<libc::wchar_t>() {
+            return Err(vm.new_overflow_error("string too long"));
+        }
+        size_usize
+    };
+    let wchars = unsafe { std::slice::from_raw_parts(w_ptr, len) };
+
+    // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
+    // macOS/Linux: wchar_t = i32 (UTF-32) -> convert via char::from_u32
+    #[cfg(windows)]
+    {
+        use rustpython_common::wtf8::Wtf8Buf;
+        let wide: Vec<u16> = wchars.to_vec();
+        let wtf8 = Wtf8Buf::from_wide(&wide);
+        Ok(vm.ctx.new_str(wtf8).into())
+    }
+    #[cfg(not(windows))]
+    {
+        let s: String = wchars
+            .iter()
+            .filter_map(|&c| char::from_u32(c as u32))
+            .collect();
+        Ok(vm.ctx.new_str(s).into())
+    }
+}
+
+// cast_check_pointertype
+fn cast_check_pointertype(ctype: &PyObject, vm: &VirtualMachine) -> bool {
+    use super::pointer::PyCPointerType;
+
+    // PyCPointerTypeObject_Check
+    if ctype.class().fast_issubclass(PyCPointerType::static_type()) {
+        return true;
+    }
+
+    // PyCFuncPtrTypeObject_Check - TODO
+
+    // simple pointer types via StgInfo.proto (c_void_p, c_char_p, etc.)
+    if let Ok(type_attr) = ctype.get_attr("_type_", vm)
+        && let Some(s) = type_attr.downcast_ref::<PyStr>()
+    {
+        let c = s.as_str();
+        if c.len() == 1 && "sPzUZXO".contains(c) {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// cast implementation
+/// _ctypes.c cast()
+pub(super) fn cast_impl(
+    obj: PyObjectRef,
+    src: PyObjectRef,
+    ctype: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // 1. cast_check_pointertype
+    if !cast_check_pointertype(&ctype, vm) {
+        return Err(vm.new_type_error(format!(
+            "cast() argument 2 must be a pointer type, not {}",
+            ctype.class().name()
+        )));
+    }
+
+    // 2. Extract pointer value - matches c_void_p_from_param_impl order
+    let ptr_value: usize = if vm.is_none(&obj) {
+        // None → NULL pointer
+        0
+    } else if let Ok(int_val) = obj.try_int(vm) {
+        // int/long → direct pointer value
+        int_val.as_bigint().to_usize().unwrap_or(0)
+    } else if let Some(bytes) = obj.downcast_ref::<PyBytes>() {
+        // bytes → buffer address (c_void_p_from_param: PyBytes_Check)
+        bytes.as_bytes().as_ptr() as usize
+    } else if let Some(s) = obj.downcast_ref::<PyStr>() {
+        // unicode/str → buffer address (c_void_p_from_param: PyUnicode_Check)
+        s.as_str().as_ptr() as usize
+    } else if let Some(ptr) = obj.downcast_ref::<PyCPointer>() {
+        // Pointer instance → contained pointer value
+        ptr.get_ptr_value()
+    } else if let Some(simple) = obj.downcast_ref::<PyCSimple>() {
+        // Simple type (c_void_p, c_char_p, etc.) → value from buffer
+        let buffer = simple.0.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    } else if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+        // Array, Structure, Union → buffer address (b_ptr)
+        cdata.buffer.read().as_ptr() as usize
+    } else {
+        return Err(vm.new_type_error(format!(
+            "cast() argument 1 must be a ctypes instance, not {}",
+            obj.class().name()
+        )));
+    };
+
+    // 3. Create result instance
+    let result = ctype.call((), vm)?;
+
+    // 4. _objects reference tracking
+    // Share _objects dict between source and result, add id(src): src
+    if src.class().fast_issubclass(PyCData::static_type()) {
+        // Get the source's _objects, create dict if needed
+        let shared_objects: PyObjectRef = if let Some(src_cdata) = src.downcast_ref::<PyCData>() {
+            let mut src_objects = src_cdata.objects.write();
+            if src_objects.is_none() {
+                // Create new dict
+                let dict = vm.ctx.new_dict();
+                *src_objects = Some(dict.clone().into());
+                dict.into()
+            } else if let Some(obj) = src_objects.as_ref() {
+                if obj.downcast_ref::<PyDict>().is_none() {
+                    // Convert to dict (keep existing reference)
+                    let dict = vm.ctx.new_dict();
+                    let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+                    let _ = dict.set_item(&*id_key, obj.clone(), vm);
+                    *src_objects = Some(dict.clone().into());
+                    dict.into()
+                } else {
+                    obj.clone()
+                }
+            } else {
+                vm.ctx.new_dict().into()
+            }
+        } else {
+            vm.ctx.new_dict().into()
+        };
+
+        // Add id(src): src to the shared dict
+        if let Some(dict) = shared_objects.downcast_ref::<PyDict>() {
+            let id_key: PyObjectRef = vm.ctx.new_int(src.get_id() as i64).into();
+            let _ = dict.set_item(&*id_key, src.clone(), vm);
+        }
+
+        // Set result's _objects to the shared dict
+        if let Some(result_cdata) = result.downcast_ref::<PyCData>() {
+            *result_cdata.objects.write() = Some(shared_objects);
+        }
+    }
+
+    // 5. Store pointer value
+    if let Some(ptr) = result.downcast_ref::<PyCPointer>() {
+        ptr.set_ptr_value(ptr_value);
+    } else if let Some(cdata) = result.downcast_ref::<PyCData>() {
+        let bytes = ptr_value.to_ne_bytes();
+        let mut buffer = cdata.buffer.write();
+        let buf = buffer.to_mut();
+        if buf.len() >= bytes.len() {
+            buf[..bytes.len()].copy_from_slice(&bytes);
+        }
+    }
+
+    Ok(result)
+}
+
+impl PyCFuncPtr {
+    /// Get function pointer address from buffer
+    fn get_func_ptr(&self) -> usize {
+        let buffer = self._base.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    }
+
+    /// Get CodePtr from buffer for FFI calls
+    fn get_code_ptr(&self) -> Option<CodePtr> {
+        let addr = self.get_func_ptr();
+        if addr != 0 {
+            Some(CodePtr(addr as *mut _))
+        } else {
+            None
+        }
+    }
+
+    /// Create buffer with function pointer address
+    fn make_ptr_buffer(addr: usize) -> Vec<u8> {
+        addr.to_ne_bytes().to_vec()
+    }
+}
+
 impl Constructor for PyCFuncPtr {
     type Args = FuncArgs;
 
     fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // Handle different argument forms like CPython:
-        // 1. Empty args: create uninitialized
+        // Handle different argument forms:
+        // 1. Empty args: create uninitialized (NULL pointer)
         // 2. One integer argument: function address
         // 3. Tuple argument: (name, dll) form
+        // 4. Callable: callback creation
+
+        let ptr_size = std::mem::size_of::<usize>();
 
         if args.args.is_empty() {
             return PyCFuncPtr {
-                _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-                ptr: PyRwLock::new(None),
-                needs_free: AtomicCell::new(false),
-                arg_types: PyRwLock::new(None),
-                _flags_: AtomicCell::new(0),
-                res_type: PyRwLock::new(None),
-                name: PyRwLock::new(None),
-                handler: vm.ctx.none(),
+                _base: PyCData::from_bytes(vec![0u8; ptr_size], None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into);
@@ -209,18 +784,68 @@ impl Constructor for PyCFuncPtr {
 
         let first_arg = &args.args[0];
 
+        // Check for COM method form: (index, name, [paramflags], [iid])
+        // First arg is integer (vtable index), second arg is string (method name)
+        if args.args.len() >= 2
+            && first_arg.try_int(vm).is_ok()
+            && args.args[1].downcast_ref::<PyStr>().is_some()
+        {
+            #[cfg(windows)]
+            let index = first_arg.try_int(vm)?.as_bigint().to_usize().unwrap_or(0);
+
+            // args[3] is iid (GUID struct, optional)
+            // Also check if args[2] is a GUID (has Data1 attribute) when args[3] is not present
+            #[cfg(windows)]
+            let iid = args.args.get(3).cloned().or_else(|| {
+                args.args.get(2).and_then(|arg| {
+                    // If it's a GUID struct (has Data1 attribute), use it as IID
+                    if arg.get_attr("Data1", vm).is_ok() {
+                        Some(arg.clone())
+                    } else {
+                        None
+                    }
+                })
+            });
+
+            // args[2] is paramflags (tuple or None)
+            let paramflags = args.args.get(2).filter(|arg| !vm.is_none(arg)).cloned();
+
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(vec![0u8; ptr_size], None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(Some(index)),
+                #[cfg(windows)]
+                iid: PyRwLock::new(iid),
+                paramflags: PyRwLock::new(paramflags),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
         // Check if first argument is an integer (function address)
         if let Ok(addr) = first_arg.try_int(vm) {
             let ptr_val = addr.as_bigint().to_usize().unwrap_or(0);
             return PyCFuncPtr {
-                _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-                ptr: PyRwLock::new(Some(CodePtr(ptr_val as *mut _))),
-                needs_free: AtomicCell::new(false),
-                arg_types: PyRwLock::new(None),
-                _flags_: AtomicCell::new(0),
-                res_type: PyRwLock::new(None),
-                name: PyRwLock::new(Some(format!("CFuncPtr@{:#x}", ptr_val))),
-                handler: vm.ctx.new_int(ptr_val).into(),
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into);
@@ -234,53 +859,58 @@ impl Constructor for PyCFuncPtr {
                 .downcast_ref::<PyStr>()
                 .ok_or(vm.new_type_error("Expected a string"))?
                 .to_string();
-            let handler = tuple
+            let dll = tuple
                 .iter()
                 .nth(1)
                 .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
                 .clone();
 
             // Get library handle and load function
-            let handle = handler.try_int(vm);
+            let handle = dll.try_int(vm);
             let handle = match handle {
                 Ok(handle) => handle.as_bigint().clone(),
-                Err(_) => handler
+                Err(_) => dll
                     .get_attr("_handle", vm)?
                     .try_int(vm)?
                     .as_bigint()
                     .clone(),
             };
-            let library_cache = crate::stdlib::ctypes::library::libcache().read();
+            let library_cache = super::library::libcache().read();
             let library = library_cache
                 .get_lib(
                     handle
                         .to_usize()
-                        .ok_or(vm.new_value_error("Invalid handle".to_string()))?,
+                        .ok_or(vm.new_value_error("Invalid handle"))?,
                 )
-                .ok_or_else(|| vm.new_value_error("Library not found".to_string()))?;
+                .ok_or_else(|| vm.new_value_error("Library not found"))?;
             let inner_lib = library.lib.lock();
 
             let terminated = format!("{}\0", &name);
-            let code_ptr = if let Some(lib) = &*inner_lib {
+            let ptr_val = if let Some(lib) = &*inner_lib {
                 let pointer: Symbol<'_, FP> = unsafe {
                     lib.get(terminated.as_bytes())
                         .map_err(|err| err.to_string())
                         .map_err(|err| vm.new_attribute_error(err))?
                 };
-                Some(CodePtr(*pointer as *mut _))
+                *pointer as usize
             } else {
-                None
+                0
             };
 
             return PyCFuncPtr {
-                _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-                ptr: PyRwLock::new(code_ptr),
-                needs_free: AtomicCell::new(false),
-                arg_types: PyRwLock::new(None),
-                _flags_: AtomicCell::new(0),
-                res_type: PyRwLock::new(None),
-                name: PyRwLock::new(Some(name)),
-                handler,
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into);
@@ -289,42 +919,36 @@ impl Constructor for PyCFuncPtr {
         // Check if first argument is a Python callable (callback creation)
         if first_arg.is_callable() {
             // Get argument types and result type from the class
-            let argtypes = cls.get_attr(vm.ctx.intern_str("_argtypes_"));
-            let restype = cls.get_attr(vm.ctx.intern_str("_restype_"));
+            let class_argtypes = cls.get_attr(vm.ctx.intern_str("_argtypes_"));
+            let class_restype = cls.get_attr(vm.ctx.intern_str("_restype_"));
 
             // Create the thunk (C-callable wrapper for the Python function)
-            let thunk = PyCThunk::new(first_arg.clone(), argtypes.clone(), restype.clone(), vm)?;
+            let thunk = PyCThunk::new(
+                first_arg.clone(),
+                class_argtypes.clone(),
+                class_restype.clone(),
+                vm,
+            )?;
             let code_ptr = thunk.code_ptr();
-
-            // Parse argument types for storage
-            let arg_type_vec: Option<Vec<PyTypeRef>> = if let Some(ref args) = argtypes {
-                if vm.is_none(args) {
-                    None
-                } else {
-                    let mut types = Vec::new();
-                    for item in args.try_to_value::<Vec<PyObjectRef>>(vm)? {
-                        types.push(item.downcast::<PyType>().map_err(|_| {
-                            vm.new_type_error("_argtypes_ must be a sequence of types".to_string())
-                        })?);
-                    }
-                    Some(types)
-                }
-            } else {
-                None
-            };
+            let ptr_val = code_ptr.0 as usize;
 
             // Store the thunk as a Python object to keep it alive
             let thunk_ref: PyRef<PyCThunk> = thunk.into_ref(&vm.ctx);
 
             return PyCFuncPtr {
-                _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-                ptr: PyRwLock::new(Some(code_ptr)),
-                needs_free: AtomicCell::new(true),
-                arg_types: PyRwLock::new(arg_type_vec),
-                _flags_: AtomicCell::new(0),
-                res_type: PyRwLock::new(restype),
-                name: PyRwLock::new(Some("<callback>".to_string())),
-                handler: thunk_ref.into(),
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(Some(thunk_ref)),
+                callable: PyRwLock::new(Some(first_arg.clone())),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(class_argtypes),
+                restype: PyRwLock::new(class_restype),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into);
@@ -338,142 +962,1054 @@ impl Constructor for PyCFuncPtr {
     }
 }
 
-impl Callable for PyCFuncPtr {
-    type Args = FuncArgs;
-    fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        // This is completely seperate from the C python implementation
-
-        // Cif init
-        let arg_types: Vec<_> = match zelf.arg_types.read().clone() {
-            Some(tys) => tys,
-            None => args
-                .args
-                .clone()
-                .into_iter()
-                .map(|a| a.class().as_object().to_pyobject(vm).downcast().unwrap())
-                .collect(),
+// PyCFuncPtr call helpers (similar to callproc.c flow)
+
+/// Handle internal function addresses (PYFUNCTYPE special cases)
+/// Returns Some(result) if handled, None if should continue with normal call
+fn handle_internal_func(addr: usize, args: &FuncArgs, vm: &VirtualMachine) -> Option<PyResult> {
+    if addr == INTERNAL_CAST_ADDR {
+        let result: PyResult<(PyObjectRef, PyObjectRef, PyObjectRef)> = args.clone().bind(vm);
+        return Some(result.and_then(|(obj, src, ctype)| cast_impl(obj, src, ctype, vm)));
+    }
+
+    if addr == INTERNAL_STRING_AT_ADDR {
+        let result: PyResult<(PyObjectRef, Option<PyObjectRef>)> = args.clone().bind(vm);
+        return Some(result.and_then(|(ptr_arg, size_arg)| {
+            let ptr = extract_ptr_from_arg(&ptr_arg, vm)?;
+            let size = size_arg
+                .and_then(|s| s.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_isize())
+                .unwrap_or(-1);
+            string_at_impl(ptr, size, vm)
+        }));
+    }
+
+    if addr == INTERNAL_WSTRING_AT_ADDR {
+        let result: PyResult<(PyObjectRef, Option<PyObjectRef>)> = args.clone().bind(vm);
+        return Some(result.and_then(|(ptr_arg, size_arg)| {
+            let ptr = extract_ptr_from_arg(&ptr_arg, vm)?;
+            let size = size_arg
+                .and_then(|s| s.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_isize())
+                .unwrap_or(-1);
+            wstring_at_impl(ptr, size, vm)
+        }));
+    }
+
+    None
+}
+
+/// Call information extracted from PyCFuncPtr (argtypes, restype, etc.)
+struct CallInfo {
+    explicit_arg_types: Option<Vec<PyTypeRef>>,
+    restype_obj: Option<PyObjectRef>,
+    restype_is_none: bool,
+    ffi_return_type: Type,
+    is_pointer_return: bool,
+}
+
+/// Extract call information (argtypes, restype) from PyCFuncPtr
+fn extract_call_info(zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> PyResult<CallInfo> {
+    // Get argtypes - first from instance, then from type's _argtypes_
+    let explicit_arg_types: Option<Vec<PyTypeRef>> =
+        if let Some(argtypes_obj) = zelf.argtypes.read().as_ref() {
+            if !vm.is_none(argtypes_obj) {
+                Some(
+                    argtypes_obj
+                        .try_to_value::<Vec<PyObjectRef>>(vm)?
+                        .into_iter()
+                        .filter_map(|obj| obj.downcast::<PyType>().ok())
+                        .collect(),
+                )
+            } else {
+                None // argtypes is None -> use ConvParam
+            }
+        } else if let Some(class_argtypes) = zelf
+            .as_object()
+            .class()
+            .get_attr(vm.ctx.intern_str("_argtypes_"))
+            && !vm.is_none(&class_argtypes)
+        {
+            Some(
+                class_argtypes
+                    .try_to_value::<Vec<PyObjectRef>>(vm)?
+                    .into_iter()
+                    .filter_map(|obj| obj.downcast::<PyType>().ok())
+                    .collect(),
+            )
+        } else {
+            None // No argtypes -> use ConvParam
         };
-        let ffi_arg_types = arg_types
-            .clone()
-            .iter()
-            .map(|t| ArgumentType::to_ffi_type(t, vm))
-            .collect::<PyResult<Vec<_>>>()?;
-        let return_type = zelf.res_type.read();
-        let ffi_return_type = return_type
+
+    // Get restype - first from instance, then from class's _restype_
+    let restype_obj = zelf.restype.read().clone().or_else(|| {
+        zelf.as_object()
+            .class()
+            .get_attr(vm.ctx.intern_str("_restype_"))
+    });
+
+    // Check if restype is explicitly None (return void)
+    let restype_is_none = restype_obj.as_ref().is_some_and(|t| vm.is_none(t));
+    let ffi_return_type = if restype_is_none {
+        Type::void()
+    } else {
+        restype_obj
             .as_ref()
             .and_then(|t| t.clone().downcast::<PyType>().ok())
-            .and_then(|t| ReturnType::to_ffi_type(&t))
-            .unwrap_or_else(Type::i32);
-        let cif = Cif::new(ffi_arg_types, ffi_return_type);
-
-        // Call the function
-        let ffi_args = args
-            .args
-            .into_iter()
-            .enumerate()
-            .map(|(n, arg)| {
-                let arg_type = arg_types
-                    .get(n)
-                    .ok_or_else(|| vm.new_type_error("argument amount mismatch".to_string()))?;
-                arg_type.convert_object(arg, vm)
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        let pointer = zelf.ptr.read();
-        let code_ptr = pointer
-            .as_ref()
-            .ok_or_else(|| vm.new_type_error("Function pointer not set".to_string()))?;
-        let mut output: c_void = unsafe { cif.call(*code_ptr, &ffi_args) };
-        let return_type = return_type
+            .and_then(|t| ReturnType::to_ffi_type(&t, vm))
+            .unwrap_or_else(Type::i32)
+    };
+
+    // Check if return type is a pointer type (P, z, Z) - need special handling on 64-bit
+    let is_pointer_return = restype_obj
+        .as_ref()
+        .and_then(|t| t.clone().downcast::<PyType>().ok())
+        .and_then(|t| t.as_object().get_attr(vm.ctx.intern_str("_type_"), vm).ok())
+        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
+        .is_some_and(|tc| matches!(tc.as_str(), "P" | "z" | "Z"));
+
+    Ok(CallInfo {
+        explicit_arg_types,
+        restype_obj,
+        restype_is_none,
+        ffi_return_type,
+        is_pointer_return,
+    })
+}
+
+/// Parsed paramflags: (direction, name, default) tuples
+/// direction: 1=IN, 2=OUT, 4=IN|OUT (or 1|2=3)
+type ParsedParamFlags = Vec<(u32, Option<String>, Option<PyObjectRef>)>;
+
+/// Parse paramflags from PyCFuncPtr
+fn parse_paramflags(
+    zelf: &Py<PyCFuncPtr>,
+    vm: &VirtualMachine,
+) -> PyResult<Option<ParsedParamFlags>> {
+    let Some(pf) = zelf.paramflags.read().as_ref().cloned() else {
+        return Ok(None);
+    };
+
+    let pf_vec = pf.try_to_value::<Vec<PyObjectRef>>(vm)?;
+    let parsed = pf_vec
+        .into_iter()
+        .map(|item| {
+            let Some(tuple) = item.downcast_ref::<PyTuple>() else {
+                // Single value means just the direction
+                let direction = item
+                    .try_int(vm)
+                    .ok()
+                    .and_then(|i| i.as_bigint().to_u32())
+                    .unwrap_or(1);
+                return (direction, None, None);
+            };
+            let direction = tuple
+                .first()
+                .and_then(|d| d.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_u32())
+                .unwrap_or(1);
+            let name = tuple
+                .get(1)
+                .and_then(|n| n.downcast_ref::<PyStr>().map(|s| s.to_string()));
+            let default = tuple.get(2).cloned();
+            (direction, name, default)
+        })
+        .collect();
+    Ok(Some(parsed))
+}
+
+/// Resolve COM method pointer from vtable (Windows only)
+/// Returns (Some(CodePtr), true) if this is a COM method call, (None, false) otherwise
+#[cfg(windows)]
+fn resolve_com_method(
+    zelf: &Py<PyCFuncPtr>,
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult<(Option<CodePtr>, bool)> {
+    let com_index = zelf.index.read();
+    let Some(idx) = *com_index else {
+        return Ok((None, false));
+    };
+
+    // First arg must be the COM object pointer
+    if args.args.is_empty() {
+        return Err(
+            vm.new_type_error("COM method requires at least one argument (self)".to_string())
+        );
+    }
+
+    // Extract COM pointer value from first argument
+    let self_arg = &args.args[0];
+    let com_ptr = if let Some(simple) = self_arg.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= std::mem::size_of::<usize>() {
+            super::base::read_ptr_from_buffer(&buffer)
+        } else {
+            0
+        }
+    } else if let Ok(int_val) = self_arg.try_int(vm) {
+        int_val.as_bigint().to_usize().unwrap_or(0)
+    } else {
+        return Err(
+            vm.new_type_error("COM method first argument must be a COM pointer".to_string())
+        );
+    };
+
+    if com_ptr == 0 {
+        return Err(vm.new_value_error("NULL COM pointer access"));
+    }
+
+    // Read vtable pointer from COM object: vtable = *(void**)com_ptr
+    let vtable_ptr = unsafe { *(com_ptr as *const usize) };
+    if vtable_ptr == 0 {
+        return Err(vm.new_value_error("NULL vtable pointer"));
+    }
+
+    // Read function pointer from vtable: func = vtable[index]
+    let fptr = unsafe {
+        let vtable = vtable_ptr as *const usize;
+        *vtable.add(idx)
+    };
+
+    if fptr == 0 {
+        return Err(vm.new_value_error("NULL function pointer in vtable"));
+    }
+
+    Ok((Some(CodePtr(fptr as *mut _)), true))
+}
+
+/// Prepared arguments for FFI call
+struct PreparedArgs {
+    ffi_arg_types: Vec<Type>,
+    ffi_values: Vec<FfiArgValue>,
+    out_buffers: Vec<(usize, PyObjectRef)>,
+}
+
+/// Get buffer address from a ctypes object
+fn get_buffer_addr(obj: &PyObjectRef) -> Option<usize> {
+    obj.downcast_ref::<PyCSimple>()
+        .map(|s| s.0.buffer.read().as_ptr() as usize)
+        .or_else(|| {
+            obj.downcast_ref::<super::structure::PyCStructure>()
+                .map(|s| s.0.buffer.read().as_ptr() as usize)
+        })
+        .or_else(|| {
+            obj.downcast_ref::<PyCPointer>()
+                .map(|s| s.0.buffer.read().as_ptr() as usize)
+        })
+}
+
+/// Create OUT buffer for a parameter type
+fn create_out_buffer(arg_type: &PyTypeRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    // For POINTER(T) types, create T instance (the pointed-to type)
+    if arg_type.fast_issubclass(PyCPointer::static_type())
+        && let Some(stg_info) = arg_type.stg_info_opt()
+        && let Some(ref proto) = stg_info.proto
+    {
+        return proto.as_object().call((), vm);
+    }
+    // Not a pointer type or no proto, create instance directly
+    arg_type.as_object().call((), vm)
+}
+
+/// Build callargs when no argtypes specified (use ConvParam)
+fn build_callargs_no_argtypes(args: &FuncArgs, vm: &VirtualMachine) -> PyResult<PreparedArgs> {
+    let results: Vec<(Type, FfiArgValue)> = args
+        .args
+        .iter()
+        .map(|arg| conv_param(arg, vm))
+        .collect::<PyResult<Vec<_>>>()?;
+    let (ffi_arg_types, ffi_values) = results.into_iter().unzip();
+    Ok(PreparedArgs {
+        ffi_arg_types,
+        ffi_values,
+        out_buffers: Vec::new(),
+    })
+}
+
+/// Build callargs for regular function with argtypes (no paramflags)
+fn build_callargs_simple(
+    args: &FuncArgs,
+    arg_types: &[PyTypeRef],
+    vm: &VirtualMachine,
+) -> PyResult<PreparedArgs> {
+    let ffi_arg_types = arg_types
+        .iter()
+        .map(|t| ArgumentType::to_ffi_type(t, vm))
+        .collect::<PyResult<Vec<_>>>()?;
+    let ffi_values = args
+        .args
+        .iter()
+        .enumerate()
+        .map(|(n, arg)| {
+            let arg_type = arg_types
+                .get(n)
+                .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
+            arg_type.convert_object(arg.clone(), vm)
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    Ok(PreparedArgs {
+        ffi_arg_types,
+        ffi_values,
+        out_buffers: Vec::new(),
+    })
+}
+
+/// Build callargs with paramflags (handles IN/OUT parameters)
+fn build_callargs_with_paramflags(
+    args: &FuncArgs,
+    arg_types: &[PyTypeRef],
+    paramflags: &ParsedParamFlags,
+    skip_first_arg: bool, // true for COM methods
+    vm: &VirtualMachine,
+) -> PyResult<PreparedArgs> {
+    let mut ffi_arg_types = Vec::new();
+    let mut ffi_values = Vec::new();
+    let mut out_buffers = Vec::new();
+
+    // For COM methods, first arg is self (pointer)
+    let mut caller_arg_idx = if skip_first_arg {
+        ffi_arg_types.push(Type::pointer());
+        if !args.args.is_empty() {
+            ffi_values.push(conv_param(&args.args[0], vm)?.1);
+        }
+        1usize
+    } else {
+        0usize
+    };
+
+    // Add FFI types for all argtypes
+    for arg_type in arg_types {
+        ffi_arg_types.push(ArgumentType::to_ffi_type(arg_type, vm)?);
+    }
+
+    // Process parameters based on paramflags
+    for (param_idx, (direction, _name, default)) in paramflags.iter().enumerate() {
+        let arg_type = arg_types
+            .get(param_idx)
+            .ok_or_else(|| vm.new_type_error("paramflags/argtypes mismatch"))?;
+
+        let is_out = (*direction & 2) != 0; // OUT flag
+        let is_in = (*direction & 1) != 0 || *direction == 0; // IN flag or default
+
+        if is_out && !is_in {
+            // Pure OUT parameter: create buffer, don't consume caller arg
+            let buffer = create_out_buffer(arg_type, vm)?;
+            let addr = get_buffer_addr(&buffer).ok_or_else(|| {
+                vm.new_type_error("Cannot create OUT buffer for this type".to_string())
+            })?;
+            ffi_values.push(FfiArgValue::Pointer(addr));
+            out_buffers.push((param_idx, buffer));
+        } else {
+            // IN or IN|OUT: get from caller args or default
+            let arg = if caller_arg_idx < args.args.len() {
+                caller_arg_idx += 1;
+                args.args[caller_arg_idx - 1].clone()
+            } else if let Some(def) = default {
+                def.clone()
+            } else {
+                return Err(vm.new_type_error(format!("required argument {} missing", param_idx)));
+            };
+
+            if is_out {
+                // IN|OUT: track for return
+                out_buffers.push((param_idx, arg.clone()));
+            }
+            ffi_values.push(arg_type.convert_object(arg, vm)?);
+        }
+    }
+
+    Ok(PreparedArgs {
+        ffi_arg_types,
+        ffi_values,
+        out_buffers,
+    })
+}
+
+/// Build call arguments (main dispatcher)
+fn build_callargs(
+    args: &FuncArgs,
+    call_info: &CallInfo,
+    paramflags: Option<&ParsedParamFlags>,
+    is_com_method: bool,
+    vm: &VirtualMachine,
+) -> PyResult<PreparedArgs> {
+    let Some(ref arg_types) = call_info.explicit_arg_types else {
+        // No argtypes: use ConvParam
+        return build_callargs_no_argtypes(args, vm);
+    };
+
+    if let Some(pflags) = paramflags {
+        // Has paramflags: handle IN/OUT
+        build_callargs_with_paramflags(args, arg_types, pflags, is_com_method, vm)
+    } else if is_com_method {
+        // COM method without paramflags
+        let mut ffi_types = vec![Type::pointer()];
+        ffi_types.extend(
+            arg_types
+                .iter()
+                .map(|t| ArgumentType::to_ffi_type(t, vm))
+                .collect::<PyResult<Vec<_>>>()?,
+        );
+        let mut ffi_vals = Vec::new();
+        if !args.args.is_empty() {
+            ffi_vals.push(conv_param(&args.args[0], vm)?.1);
+        }
+        for (n, arg) in args.args.iter().skip(1).enumerate() {
+            let arg_type = arg_types
+                .get(n)
+                .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
+            ffi_vals.push(arg_type.convert_object(arg.clone(), vm)?);
+        }
+        Ok(PreparedArgs {
+            ffi_arg_types: ffi_types,
+            ffi_values: ffi_vals,
+            out_buffers: Vec::new(),
+        })
+    } else {
+        // Regular function
+        build_callargs_simple(args, arg_types, vm)
+    }
+}
+
+/// Raw result from FFI call
+enum RawResult {
+    Void,
+    Pointer(usize),
+    Value(libffi::low::ffi_arg),
+}
+
+/// Execute FFI call
+fn ctypes_callproc(code_ptr: CodePtr, prepared: &PreparedArgs, call_info: &CallInfo) -> RawResult {
+    let cif = Cif::new(
+        prepared.ffi_arg_types.clone(),
+        call_info.ffi_return_type.clone(),
+    );
+    let ffi_args: Vec<Arg> = prepared.ffi_values.iter().map(|v| v.as_arg()).collect();
+
+    if call_info.restype_is_none {
+        unsafe { cif.call::<()>(code_ptr, &ffi_args) };
+        RawResult::Void
+    } else if call_info.is_pointer_return {
+        let result = unsafe { cif.call::<usize>(code_ptr, &ffi_args) };
+        RawResult::Pointer(result)
+    } else {
+        let result = unsafe { cif.call::<libffi::low::ffi_arg>(code_ptr, &ffi_args) };
+        RawResult::Value(result)
+    }
+}
+
+/// Check and handle HRESULT errors (Windows)
+#[cfg(windows)]
+fn check_hresult(hresult: i32, zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> PyResult<()> {
+    if hresult >= 0 {
+        return Ok(());
+    }
+
+    if zelf.iid.read().is_some() {
+        // Raise COMError
+        let ctypes_module = vm.import("_ctypes", 0)?;
+        let com_error_type = ctypes_module.get_attr("COMError", vm)?;
+        let com_error_type = com_error_type
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("COMError is not a type"))?;
+        let hresult_obj: PyObjectRef = vm.ctx.new_int(hresult).into();
+        let text: PyObjectRef = vm
+            .ctx
+            .new_str(format!("HRESULT: 0x{:08X}", hresult as u32))
+            .into();
+        let details: PyObjectRef = vm.ctx.none();
+        let exc = vm.invoke_exception(
+            com_error_type.to_owned(),
+            vec![text.clone(), details.clone()],
+        )?;
+        let _ = exc.as_object().set_attr("hresult", hresult_obj, vm);
+        let _ = exc.as_object().set_attr("text", text, vm);
+        let _ = exc.as_object().set_attr("details", details, vm);
+        Err(exc)
+    } else {
+        // Raise OSError
+        let exc = vm.new_os_error(format!("HRESULT: 0x{:08X}", hresult as u32));
+        let _ = exc
+            .as_object()
+            .set_attr("winerror", vm.ctx.new_int(hresult), vm);
+        Err(exc)
+    }
+}
+
+/// Convert raw FFI result to Python object
+fn convert_raw_result(
+    raw_result: &mut RawResult,
+    call_info: &CallInfo,
+    vm: &VirtualMachine,
+) -> Option<PyObjectRef> {
+    match raw_result {
+        RawResult::Void => None,
+        RawResult::Pointer(ptr) => {
+            // Get type code from restype to determine conversion method
+            let type_code = call_info
+                .restype_obj
+                .as_ref()
+                .and_then(|t| t.clone().downcast::<PyType>().ok())
+                .and_then(|t| t.as_object().get_attr(vm.ctx.intern_str("_type_"), vm).ok())
+                .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+            match type_code.as_deref() {
+                Some("z") => {
+                    // c_char_p: NULL -> None, otherwise read C string -> bytes
+                    if *ptr == 0 {
+                        Some(vm.ctx.none())
+                    } else {
+                        let cstr = unsafe { std::ffi::CStr::from_ptr(*ptr as _) };
+                        Some(vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into())
+                    }
+                }
+                Some("Z") => {
+                    // c_wchar_p: NULL -> None, otherwise read wide string -> str
+                    if *ptr == 0 {
+                        Some(vm.ctx.none())
+                    } else {
+                        let wstr_ptr = *ptr as *const libc::wchar_t;
+                        let mut len = 0;
+                        unsafe {
+                            while *wstr_ptr.add(len) != 0 {
+                                len += 1;
+                            }
+                        }
+                        let slice = unsafe { std::slice::from_raw_parts(wstr_ptr, len) };
+                        let s: String = slice
+                            .iter()
+                            .filter_map(|&c| char::from_u32(c as u32))
+                            .collect();
+                        Some(vm.ctx.new_str(s).into())
+                    }
+                }
+                _ => {
+                    // c_void_p ("P") and other pointer types: NULL -> None, otherwise int
+                    if *ptr == 0 {
+                        Some(vm.ctx.none())
+                    } else {
+                        Some(vm.ctx.new_int(*ptr).into())
+                    }
+                }
+            }
+        }
+        RawResult::Value(val) => call_info
+            .restype_obj
             .as_ref()
             .and_then(|f| f.clone().downcast::<PyType>().ok())
-            .map(|f| f.from_ffi_type(&mut output, vm).ok().flatten())
-            .unwrap_or_else(|| Some(vm.ctx.new_int(output as i32).as_object().to_pyobject(vm)));
-        if let Some(return_type) = return_type {
-            Ok(return_type)
-        } else {
-            Ok(vm.ctx.none())
+            .map(|f| {
+                f.from_ffi_type(val as *mut _ as *mut c_void, vm)
+                    .ok()
+                    .flatten()
+            })
+            .unwrap_or_else(|| Some(vm.ctx.new_int(*val as usize).as_object().to_pyobject(vm))),
+    }
+}
+
+/// Extract values from OUT buffers
+fn extract_out_values(
+    out_buffers: Vec<(usize, PyObjectRef)>,
+    vm: &VirtualMachine,
+) -> Vec<PyObjectRef> {
+    out_buffers
+        .into_iter()
+        .map(|(_, buffer)| buffer.get_attr("value", vm).unwrap_or(buffer))
+        .collect()
+}
+
+/// Build final result (main function)
+fn build_result(
+    mut raw_result: RawResult,
+    call_info: &CallInfo,
+    prepared: PreparedArgs,
+    zelf: &Py<PyCFuncPtr>,
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // Check HRESULT on Windows
+    #[cfg(windows)]
+    if let RawResult::Value(val) = raw_result {
+        let is_hresult = call_info
+            .restype_obj
+            .as_ref()
+            .and_then(|t| t.clone().downcast::<PyType>().ok())
+            .is_some_and(|t| t.name().to_string() == "HRESULT");
+        if is_hresult {
+            check_hresult(val as i32, zelf, vm)?;
         }
     }
+
+    // Convert raw result to Python object
+    let mut result = convert_raw_result(&mut raw_result, call_info, vm);
+
+    // Apply errcheck if set
+    if let Some(errcheck) = zelf.errcheck.read().as_ref() {
+        let args_tuple = PyTuple::new_ref(args.args.clone(), &vm.ctx);
+        let func_obj = zelf.as_object().to_owned();
+        let result_obj = result.clone().unwrap_or_else(|| vm.ctx.none());
+        result = Some(errcheck.call((result_obj, func_obj, args_tuple), vm)?);
+    }
+
+    // Handle OUT parameter return values
+    if prepared.out_buffers.is_empty() {
+        return result.map(Ok).unwrap_or_else(|| Ok(vm.ctx.none()));
+    }
+
+    let out_values = extract_out_values(prepared.out_buffers, vm);
+    Ok(match <[PyObjectRef; 1]>::try_from(out_values) {
+        Ok([single]) => single,
+        Err(v) => PyTuple::new_ref(v, &vm.ctx).into(),
+    })
 }
 
+impl Callable for PyCFuncPtr {
+    type Args = FuncArgs;
+    fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        // 1. Check for internal PYFUNCTYPE addresses
+        if let Some(result) = handle_internal_func(zelf.get_func_ptr(), &args, vm) {
+            return result;
+        }
+
+        // 2. Resolve function pointer (COM or direct)
+        #[cfg(windows)]
+        let (func_ptr, is_com_method) = resolve_com_method(zelf, &args, vm)?;
+        #[cfg(not(windows))]
+        let (func_ptr, is_com_method) = (None::<CodePtr>, false);
+
+        // 3. Extract call info (argtypes, restype)
+        let call_info = extract_call_info(zelf, vm)?;
+
+        // 4. Parse paramflags
+        let paramflags = parse_paramflags(zelf, vm)?;
+
+        // 5. Build call arguments
+        let prepared = build_callargs(&args, &call_info, paramflags.as_ref(), is_com_method, vm)?;
+
+        // 6. Get code pointer
+        let code_ptr = match func_ptr.or_else(|| zelf.get_code_ptr()) {
+            Some(cp) => cp,
+            None => {
+                debug_assert!(false, "NULL function pointer");
+                // In release mode, this will crash like CPython
+                CodePtr(std::ptr::null_mut())
+            }
+        };
+
+        // 7. Call the function
+        let raw_result = ctypes_callproc(code_ptr, &prepared, &call_info);
+
+        // 8. Build result
+        build_result(raw_result, &call_info, prepared, zelf, &args, vm)
+    }
+}
+
+// PyCFuncPtr_repr
 impl Representable for PyCFuncPtr {
     fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        let index = zelf.ptr.read();
-        let index = index.map(|ptr| ptr.0 as usize).unwrap_or(0);
         let type_name = zelf.class().name();
-        if cfg!(windows) {
-            let index = index - 0x1000;
-            Ok(format!("<COM method offset {index:#x} {type_name}>"))
-        } else {
-            Ok(format!("<{type_name} object at {index:#x}>"))
-        }
+        // Use object id, not function pointer address
+        let addr = zelf.get_id();
+        Ok(format!("<{} object at {:#x}>", type_name, addr))
     }
 }
 
-// TODO: fix
-unsafe impl Send for PyCFuncPtr {}
-unsafe impl Sync for PyCFuncPtr {}
-
 #[pyclass(flags(BASETYPE), with(Callable, Constructor, Representable))]
 impl PyCFuncPtr {
-    #[pygetset(name = "_restype_")]
+    // restype getter/setter
+    #[pygetset]
     fn restype(&self) -> Option<PyObjectRef> {
-        self.res_type.read().as_ref().cloned()
+        self.restype.read().clone()
     }
 
-    #[pygetset(name = "_restype_", setter)]
-    fn set_restype(&self, restype: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        // has to be type, callable, or none
-        // TODO: Callable support
-        if vm.is_none(&restype) || restype.downcast_ref::<PyType>().is_some() {
-            *self.res_type.write() = Some(restype);
-            Ok(())
+    #[pygetset(setter)]
+    fn set_restype(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Must be type, callable, or None
+        if vm.is_none(&value) {
+            *self.restype.write() = None;
+        } else if value.downcast_ref::<PyType>().is_some() || value.is_callable() {
+            *self.restype.write() = Some(value);
         } else {
-            Err(vm.new_type_error("restype must be a type, a callable, or None".to_string()))
+            return Err(vm.new_type_error("restype must be a type, a callable, or None"));
         }
+        Ok(())
     }
 
-    #[pygetset(name = "argtypes")]
-    fn argtypes(&self, vm: &VirtualMachine) -> PyTupleRef {
-        PyTuple::new_ref(
-            self.arg_types
-                .read()
-                .clone()
-                .unwrap_or_default()
-                .into_iter()
-                .map(|t| t.to_pyobject(vm))
-                .collect(),
-            &vm.ctx,
-        )
+    // argtypes getter/setter
+    #[pygetset]
+    fn argtypes(&self, vm: &VirtualMachine) -> PyObjectRef {
+        self.argtypes
+            .read()
+            .clone()
+            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into())
     }
 
     #[pygetset(name = "argtypes", setter)]
-    fn set_argtypes(&self, argtypes: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let none = vm.is_none(&argtypes);
-        if none {
-            *self.arg_types.write() = None;
-            Ok(())
+    fn set_argtypes(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.is_none(&value) {
+            *self.argtypes.write() = None;
         } else {
-            let tuple = argtypes.downcast::<PyTuple>().unwrap();
-            *self.arg_types.write() = Some(
-                tuple
-                    .iter()
-                    .map(|obj| obj.clone().downcast::<PyType>().unwrap())
-                    .collect::<Vec<_>>(),
-            );
-            Ok(())
+            // Store the argtypes object directly as it is
+            *self.argtypes.write() = Some(value);
         }
+        Ok(())
     }
 
+    // errcheck getter/setter
     #[pygetset]
-    fn __name__(&self) -> Option<String> {
-        self.name.read().clone()
+    fn errcheck(&self) -> Option<PyObjectRef> {
+        self.errcheck.read().clone()
     }
 
     #[pygetset(setter)]
-    fn set___name__(&self, name: String) -> PyResult<()> {
-        *self.name.write() = Some(name);
-        // TODO: update handle and stuff
+    fn set_errcheck(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.is_none(&value) {
+            *self.errcheck.write() = None;
+        } else if value.is_callable() {
+            *self.errcheck.write() = Some(value);
+        } else {
+            return Err(vm.new_type_error("errcheck must be a callable or None"));
+        }
         Ok(())
     }
+
+    // _flags_ getter (read-only, from type's class attribute or StgInfo)
+    #[pygetset]
+    fn _flags_(zelf: &Py<Self>, vm: &VirtualMachine) -> u32 {
+        // First try to get _flags_ from type's class attribute (for dynamically created types)
+        // This is how CDLL sets use_errno: class _FuncPtr(_CFuncPtr): _flags_ = flags
+        if let Ok(flags_attr) = zelf.class().as_object().get_attr("_flags_", vm)
+            && let Ok(flags_int) = flags_attr.try_to_value::<u32>(vm)
+        {
+            return flags_int;
+        }
+
+        // Fallback to StgInfo for native types
+        use super::base::StgInfoFlags;
+        zelf.class()
+            .stg_info_opt()
+            .map(|stg| stg.flags.bits())
+            .unwrap_or(StgInfoFlags::empty().bits())
+    }
+
+    // bool conversion - check if function pointer is set
+    #[pymethod]
+    fn __bool__(&self) -> bool {
+        self.get_func_ptr() != 0
+    }
+}
+
+// CThunkObject - FFI callback (thunk) implementation
+
+/// Userdata passed to the libffi callback.
+struct ThunkUserData {
+    /// The Python callable to invoke
+    callable: PyObjectRef,
+    /// Argument types for conversion
+    arg_types: Vec<PyTypeRef>,
+    /// Result type for conversion (None means void)
+    res_type: Option<PyTypeRef>,
+}
+
+/// Check if ty is a subclass of a simple type (like MyInt(c_int)).
+fn is_simple_subclass(ty: &Py<PyType>, vm: &VirtualMachine) -> bool {
+    let Ok(base) = ty.as_object().get_attr(vm.ctx.intern_str("__base__"), vm) else {
+        return false;
+    };
+    base.get_attr(vm.ctx.intern_str("_type_"), vm).is_ok()
+}
+
+/// Convert a C value to a Python object based on the type code.
+fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> PyObjectRef {
+    let type_code = ty.type_code(vm);
+    let raw_value: PyObjectRef = unsafe {
+        match type_code.as_deref() {
+            Some("b") => vm.ctx.new_int(*(ptr as *const i8) as i32).into(),
+            Some("B") => vm.ctx.new_int(*(ptr as *const u8) as i32).into(),
+            Some("c") => vm.ctx.new_bytes(vec![*(ptr as *const u8)]).into(),
+            Some("h") => vm.ctx.new_int(*(ptr as *const i16) as i32).into(),
+            Some("H") => vm.ctx.new_int(*(ptr as *const u16) as i32).into(),
+            Some("i") => vm.ctx.new_int(*(ptr as *const i32)).into(),
+            Some("I") => vm.ctx.new_int(*(ptr as *const u32)).into(),
+            Some("l") => vm.ctx.new_int(*(ptr as *const libc::c_long)).into(),
+            Some("L") => vm.ctx.new_int(*(ptr as *const libc::c_ulong)).into(),
+            Some("q") => vm.ctx.new_int(*(ptr as *const libc::c_longlong)).into(),
+            Some("Q") => vm.ctx.new_int(*(ptr as *const libc::c_ulonglong)).into(),
+            Some("f") => vm.ctx.new_float(*(ptr as *const f32) as f64).into(),
+            Some("d") => vm.ctx.new_float(*(ptr as *const f64)).into(),
+            Some("z") => {
+                // c_char_p: C string pointer → Python bytes
+                let cstr_ptr = *(ptr as *const *const libc::c_char);
+                if cstr_ptr.is_null() {
+                    vm.ctx.none()
+                } else {
+                    let cstr = std::ffi::CStr::from_ptr(cstr_ptr);
+                    vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into()
+                }
+            }
+            Some("Z") => {
+                // c_wchar_p: wchar_t* → Python str
+                let wstr_ptr = *(ptr as *const *const libc::wchar_t);
+                if wstr_ptr.is_null() {
+                    vm.ctx.none()
+                } else {
+                    let mut len = 0;
+                    while *wstr_ptr.add(len) != 0 {
+                        len += 1;
+                    }
+                    let slice = std::slice::from_raw_parts(wstr_ptr, len);
+                    let s: String = slice
+                        .iter()
+                        .filter_map(|&c| char::from_u32(c as u32))
+                        .collect();
+                    vm.ctx.new_str(s).into()
+                }
+            }
+            Some("P") => vm.ctx.new_int(*(ptr as *const usize)).into(),
+            Some("?") => vm.ctx.new_bool(*(ptr as *const u8) != 0).into(),
+            _ => return vm.ctx.none(),
+        }
+    };
+
+    if !is_simple_subclass(ty, vm) {
+        return raw_value;
+    }
+    ty.as_object()
+        .call((raw_value.clone(),), vm)
+        .unwrap_or(raw_value)
+}
+
+/// Convert a Python object to a C value and store it at the result pointer
+fn python_to_ffi(obj: PyResult, ty: &Py<PyType>, result: *mut c_void, vm: &VirtualMachine) {
+    let Ok(obj) = obj else { return };
+
+    let type_code = ty.type_code(vm);
+    unsafe {
+        match type_code.as_deref() {
+            Some("b") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i8) = i.as_bigint().to_i8().unwrap_or(0);
+                }
+            }
+            Some("B") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
+                }
+            }
+            Some("c") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
+                }
+            }
+            Some("h") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i16) = i.as_bigint().to_i16().unwrap_or(0);
+                }
+            }
+            Some("H") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u16) = i.as_bigint().to_u16().unwrap_or(0);
+                }
+            }
+            Some("i") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    let val = i.as_bigint().to_i32().unwrap_or(0);
+                    *(result as *mut libffi::low::ffi_arg) = val as libffi::low::ffi_arg;
+                }
+            }
+            Some("I") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u32) = i.as_bigint().to_u32().unwrap_or(0);
+                }
+            }
+            Some("l") | Some("q") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i64) = i.as_bigint().to_i64().unwrap_or(0);
+                }
+            }
+            Some("L") | Some("Q") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u64) = i.as_bigint().to_u64().unwrap_or(0);
+                }
+            }
+            Some("f") => {
+                if let Ok(f) = obj.try_float(vm) {
+                    *(result as *mut f32) = f.to_f64() as f32;
+                }
+            }
+            Some("d") => {
+                if let Ok(f) = obj.try_float(vm) {
+                    *(result as *mut f64) = f.to_f64();
+                }
+            }
+            Some("P") | Some("z") | Some("Z") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut usize) = i.as_bigint().to_usize().unwrap_or(0);
+                }
+            }
+            Some("?") => {
+                if let Ok(b) = obj.is_true(vm) {
+                    *(result as *mut u8) = u8::from(b);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+/// The callback function that libffi calls when the closure is invoked.
+unsafe extern "C" fn thunk_callback(
+    _cif: &low::ffi_cif,
+    result: &mut c_void,
+    args: *const *const c_void,
+    userdata: &ThunkUserData,
+) {
+    with_current_vm(|vm| {
+        let py_args: Vec<PyObjectRef> = userdata
+            .arg_types
+            .iter()
+            .enumerate()
+            .map(|(i, ty)| {
+                let arg_ptr = unsafe { *args.add(i) };
+                ffi_to_python(ty, arg_ptr, vm)
+            })
+            .collect();
+
+        let py_result = userdata.callable.call(py_args, vm);
+
+        // Call unraisable hook if exception occurred
+        if let Err(exc) = &py_result {
+            let repr = userdata
+                .callable
+                .repr(vm)
+                .map(|s| s.to_string())
+                .unwrap_or_else(|_| "<unknown>".to_string());
+            let msg = format!(
+                "Exception ignored on calling ctypes callback function {}",
+                repr
+            );
+            vm.run_unraisable(exc.clone(), Some(msg), vm.ctx.none());
+        }
+
+        if let Some(ref res_type) = userdata.res_type {
+            python_to_ffi(py_result, res_type, result as *mut c_void, vm);
+        }
+    });
+}
+
+/// Holds the closure and userdata together to ensure proper lifetime.
+struct ThunkData {
+    #[allow(dead_code)]
+    closure: Closure<'static>,
+    userdata_ptr: *mut ThunkUserData,
+}
+
+impl Drop for ThunkData {
+    fn drop(&mut self) {
+        unsafe {
+            drop(Box::from_raw(self.userdata_ptr));
+        }
+    }
+}
+
+/// CThunkObject wraps a Python callable to make it callable from C code.
+#[pyclass(name = "CThunkObject", module = "_ctypes")]
+#[derive(PyPayload)]
+pub(super) struct PyCThunk {
+    callable: PyObjectRef,
+    #[allow(dead_code)]
+    thunk_data: PyRwLock<Option<ThunkData>>,
+    code_ptr: CodePtr,
+}
+
+impl Debug for PyCThunk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PyCThunk")
+            .field("callable", &self.callable)
+            .finish()
+    }
+}
+
+impl PyCThunk {
+    pub fn new(
+        callable: PyObjectRef,
+        arg_types: Option<PyObjectRef>,
+        res_type: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let arg_type_vec: Vec<PyTypeRef> = match arg_types {
+            Some(args) if !vm.is_none(&args) => args
+                .try_to_value::<Vec<PyObjectRef>>(vm)?
+                .into_iter()
+                .map(|item| {
+                    item.downcast::<PyType>()
+                        .map_err(|_| vm.new_type_error("_argtypes_ must be a sequence of types"))
+                })
+                .collect::<PyResult<Vec<_>>>()?,
+            _ => Vec::new(),
+        };
+
+        let res_type_ref: Option<PyTypeRef> = match res_type {
+            Some(ref rt) if !vm.is_none(rt) => Some(
+                rt.clone()
+                    .downcast::<PyType>()
+                    .map_err(|_| vm.new_type_error("restype must be a ctypes type"))?,
+            ),
+            _ => None,
+        };
+
+        let ffi_arg_types: Vec<Type> = arg_type_vec
+            .iter()
+            .map(|ty| {
+                ty.type_code(vm)
+                    .and_then(|code| get_ffi_type(&code))
+                    .unwrap_or(Type::pointer())
+            })
+            .collect();
+
+        let ffi_res_type = res_type_ref
+            .as_ref()
+            .and_then(|ty| ty.type_code(vm))
+            .and_then(|code| get_ffi_type(&code))
+            .unwrap_or(Type::void());
+
+        let cif = Cif::new(ffi_arg_types, ffi_res_type);
+
+        let userdata = Box::new(ThunkUserData {
+            callable: callable.clone(),
+            arg_types: arg_type_vec,
+            res_type: res_type_ref,
+        });
+        let userdata_ptr = Box::into_raw(userdata);
+        let userdata_ref: &'static ThunkUserData = unsafe { &*userdata_ptr };
+
+        let closure = Closure::new(cif, thunk_callback, userdata_ref);
+        let code_ptr = CodePtr(*closure.code_ptr() as *mut _);
+
+        let thunk_data = ThunkData {
+            closure,
+            userdata_ptr,
+        };
+
+        Ok(Self {
+            callable,
+            thunk_data: PyRwLock::new(Some(thunk_data)),
+            code_ptr,
+        })
+    }
+
+    pub fn code_ptr(&self) -> CodePtr {
+        self.code_ptr
+    }
+}
+
+unsafe impl Send for PyCThunk {}
+unsafe impl Sync for PyCThunk {}
+
+#[pyclass]
+impl PyCThunk {
+    #[pygetset]
+    fn callable(&self) -> PyObjectRef {
+        self.callable.clone()
+    }
 }
diff --git a/crates/vm/src/stdlib/ctypes/library.rs b/crates/vm/src/stdlib/ctypes/library.rs
index e918470b6c8..ec8ca91af0d 100644
--- a/crates/vm/src/stdlib/ctypes/library.rs
+++ b/crates/vm/src/stdlib/ctypes/library.rs
@@ -2,12 +2,12 @@ use crate::VirtualMachine;
 use libloading::Library;
 use rustpython_common::lock::{PyMutex, PyRwLock};
 use std::collections::HashMap;
-use std::ffi::c_void;
+use std::ffi::{OsStr, c_void};
 use std::fmt;
 use std::ptr::null;
 
-pub struct SharedLibrary {
-    pub(crate) lib: PyMutex<Option<Library>>,
+pub(super) struct SharedLibrary {
+    pub(super) lib: PyMutex<Option<Library>>,
 }
 
 impl fmt::Debug for SharedLibrary {
@@ -17,13 +17,13 @@ impl fmt::Debug for SharedLibrary {
 }
 
 impl SharedLibrary {
-    pub fn new(name: &str) -> Result<SharedLibrary, libloading::Error> {
+    fn new(name: impl AsRef<OsStr>) -> Result<SharedLibrary, libloading::Error> {
         Ok(SharedLibrary {
-            lib: PyMutex::new(unsafe { Some(Library::new(name)?) }),
+            lib: PyMutex::new(unsafe { Some(Library::new(name.as_ref())?) }),
         })
     }
 
-    pub fn get_pointer(&self) -> usize {
+    fn get_pointer(&self) -> usize {
         let lib_lock = self.lib.lock();
         if let Some(l) = &*lib_lock {
             l as *const Library as usize
@@ -32,12 +32,12 @@ impl SharedLibrary {
         }
     }
 
-    pub fn is_closed(&self) -> bool {
+    fn is_closed(&self) -> bool {
         let lib_lock = self.lib.lock();
         lib_lock.is_none()
     }
 
-    pub fn close(&self) {
+    fn close(&self) {
         *self.lib.lock() = None;
     }
 }
@@ -48,25 +48,24 @@ impl Drop for SharedLibrary {
     }
 }
 
-pub struct ExternalLibs {
+pub(super) struct ExternalLibs {
     libraries: HashMap<usize, SharedLibrary>,
 }
 
 impl ExternalLibs {
-    pub fn new() -> Self {
+    fn new() -> Self {
         Self {
             libraries: HashMap::new(),
         }
     }
 
-    #[allow(dead_code)]
     pub fn get_lib(&self, key: usize) -> Option<&SharedLibrary> {
         self.libraries.get(&key)
     }
 
     pub fn get_or_insert_lib(
         &mut self,
-        library_path: &str,
+        library_path: impl AsRef<OsStr>,
         _vm: &VirtualMachine,
     ) -> Result<(usize, &SharedLibrary), libloading::Error> {
         let new_lib = SharedLibrary::new(library_path)?;
@@ -83,7 +82,7 @@ impl ExternalLibs {
             }
         };
 
-        Ok((key, self.libraries.get(&key).unwrap()))
+        Ok((key, self.libraries.get(&key).expect("just inserted")))
     }
 
     pub fn drop_lib(&mut self, key: usize) {
@@ -91,10 +90,9 @@ impl ExternalLibs {
     }
 }
 
-rustpython_common::static_cell! {
-    static LIBCACHE: PyRwLock<ExternalLibs>;
-}
-
-pub fn libcache() -> &'static PyRwLock<ExternalLibs> {
+pub(super) fn libcache() -> &'static PyRwLock<ExternalLibs> {
+    rustpython_common::static_cell! {
+        static LIBCACHE: PyRwLock<ExternalLibs>;
+    }
     LIBCACHE.get_or_init(|| PyRwLock::new(ExternalLibs::new()))
 }
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index 735034e7936..3ee39af3a7a 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -1,37 +1,164 @@
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
-
-use crate::builtins::{PyType, PyTypeRef};
-use crate::function::FuncArgs;
+use super::{PyCArray, PyCData, PyCSimple, PyCStructure, StgInfo, StgInfoFlags};
 use crate::protocol::PyNumberMethods;
-use crate::stdlib::ctypes::{CDataObject, PyCData};
-use crate::types::{AsNumber, Constructor};
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use crate::types::{AsNumber, Constructor, Initializer};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
+    class::StaticType,
+    function::{FuncArgs, OptionalArg},
+};
+use num_traits::ToPrimitive;
 
 #[pyclass(name = "PyCPointerType", base = PyType, module = "_ctypes")]
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyCPointerType(PyType);
+pub(super) struct PyCPointerType(PyType);
+
+impl Initializer for PyCPointerType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        new_type.check_not_initialized(vm)?;
+
+        // Get the _type_ attribute (element type)
+        // PyCPointerType_init gets the element type from _type_ attribute
+        let proto = new_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|obj| obj.downcast::<PyType>().ok());
+
+        // Initialize StgInfo for pointer type
+        let pointer_size = std::mem::size_of::<usize>();
+        let mut stg_info = StgInfo::new(pointer_size, pointer_size);
+        stg_info.proto = proto;
+        stg_info.paramfunc = super::base::ParamFunc::Pointer;
+        stg_info.length = 1;
+        stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+
+        // Set format string: "&<element_format>"
+        if let Some(ref proto) = stg_info.proto {
+            let item_info = proto.stg_info_opt().expect("proto has StgInfo");
+            let current_format = item_info.format.as_deref().unwrap_or("B");
+            stg_info.format = Some(format!("&{}", current_format));
+        }
+
+        let _ = new_type.init_type_data(stg_info);
 
-#[pyclass(flags(IMMUTABLETYPE), with(AsNumber))]
+        Ok(())
+    }
+}
+
+#[pyclass(flags(IMMUTABLETYPE), with(AsNumber, Initializer))]
 impl PyCPointerType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the pointer type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. None is allowed for pointer types
+        if vm.is_none(&value) {
+            return Ok(value);
+        }
+
+        // 2. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 3. If value is an instance of _type_ (the pointed-to type), wrap with byref
+        if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+            && let Ok(type_ref) = type_attr.downcast::<PyType>()
+            && value.is_instance(type_ref.as_object(), vm)?
+        {
+            // Return byref(value)
+            return super::_ctypes::byref(value, crate::function::OptionalArg::Missing, vm);
+        }
+
+        // 4. Array/Pointer instances with compatible proto
+        // "Array instances are also pointers when the item types are the same."
+        let is_pointer_or_array = value.downcast_ref::<PyCPointer>().is_some()
+            || value.downcast_ref::<super::array::PyCArray>().is_some();
+
+        if is_pointer_or_array {
+            let is_compatible = {
+                if let Some(value_stginfo) = value.class().stg_info_opt()
+                    && let Some(ref value_proto) = value_stginfo.proto
+                    && let Some(cls_stginfo) = cls.stg_info_opt()
+                    && let Some(ref cls_proto) = cls_stginfo.proto
+                {
+                    // Check if value's proto is a subclass of target's proto
+                    value_proto.fast_issubclass(cls_proto)
+                } else {
+                    false
+                }
+            };
+            if is_compatible {
+                return Ok(value);
+            }
+        }
+
+        // 5. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCPointerType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
     #[pymethod]
     fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        use super::array::create_array_type_with_stg_info;
+        use super::array::array_type_from_ctype;
+
         if n < 0 {
             return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
         }
-        // Pointer size
-        let element_size = std::mem::size_of::<usize>();
-        let total_size = element_size * (n as usize);
-        let stg_info = super::util::StgInfo::new_array(
-            total_size,
-            element_size,
-            n as usize,
-            cls.as_object().to_owned(),
-            element_size,
-        );
-        create_array_type_with_stg_info(stg_info, vm)
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
+    }
+
+    // PyCPointerType_set_type: Complete an incomplete pointer type
+    #[pymethod]
+    fn set_type(zelf: PyTypeRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        use crate::AsObject;
+
+        // 1. Validate that typ is a type
+        let typ_type = typ
+            .clone()
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("_type_ must be a type"))?;
+
+        // 2. Validate that typ has storage info
+        if typ_type.stg_info_opt().is_none() {
+            return Err(vm.new_type_error("_type_ must have storage info"));
+        }
+
+        // 3. Update StgInfo.proto and format using mutable access
+        if let Some(mut stg_info) = zelf.get_type_data_mut::<StgInfo>() {
+            stg_info.proto = Some(typ_type.clone());
+
+            // Update format string: "&<element_format>"
+            let item_info = typ_type.stg_info_opt().expect("proto has StgInfo");
+            let current_format = item_info.format.as_deref().unwrap_or("B");
+            stg_info.format = Some(format!("&{}", current_format));
+        }
+
+        // 4. Set _type_ attribute on the pointer type
+        zelf.as_object().set_attr("_type_", typ_type, vm)?;
+
+        Ok(())
     }
 }
 
@@ -41,12 +168,12 @@ impl AsNumber for PyCPointerType {
             multiply: Some(|a, b, vm| {
                 let cls = a
                     .downcast_ref::<PyType>()
-                    .ok_or_else(|| vm.new_type_error("expected type".to_owned()))?;
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
                 let n = b
                     .try_index(vm)?
                     .as_bigint()
                     .to_isize()
-                    .ok_or_else(|| vm.new_overflow_error("array size too large".to_owned()))?;
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
                 PyCPointerType::__mul__(cls.to_owned(), n, vm)
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
@@ -55,6 +182,8 @@ impl AsNumber for PyCPointerType {
     }
 }
 
+/// PyCPointer - Pointer instance
+/// `contents` is a computed property, not a stored field.
 #[pyclass(
     name = "_Pointer",
     base = PyCData,
@@ -62,26 +191,27 @@ impl AsNumber for PyCPointerType {
     module = "_ctypes"
 )]
 #[derive(Debug)]
-pub struct PyCPointer {
-    _base: PyCData,
-    contents: PyRwLock<PyObjectRef>,
-}
+#[repr(transparent)]
+pub struct PyCPointer(pub PyCData);
 
 impl Constructor for PyCPointer {
-    type Args = (crate::function::OptionalArg<PyObjectRef>,);
-
-    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let args: Self::Args = args.bind(vm)?;
-        // Get the initial contents value if provided
-        let initial_contents = args.0.into_option().unwrap_or_else(|| vm.ctx.none());
+    type Args = FuncArgs;
 
-        // Create a new PyCPointer instance with the provided value
-        PyCPointer {
-            _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-            contents: PyRwLock::new(initial_contents),
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Pointer_new: Check if _type_ is defined
+        let has_type = cls.stg_info_opt().is_some_and(|info| info.proto.is_some());
+        if !has_type {
+            return Err(vm.new_type_error("Cannot create instance: has no _type_"));
         }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+
+        // Create a new PyCPointer instance with NULL pointer (all zeros)
+        // Initial contents is set via __init__ if provided
+        let cdata = PyCData::from_bytes(vec![0u8; std::mem::size_of::<usize>()], None);
+        // pointer instance has b_length set to 2 (for index 0 and 1)
+        cdata.length.store(2);
+        PyCPointer(cdata)
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
     }
 
     fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
@@ -89,186 +219,496 @@ impl Constructor for PyCPointer {
     }
 }
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor))]
+impl Initializer for PyCPointer {
+    type Args = (OptionalArg<PyObjectRef>,);
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        let (value,) = args;
+        if let OptionalArg::Present(val) = value
+            && !vm.is_none(&val)
+        {
+            Self::set_contents(&zelf, val, vm)?;
+        }
+        Ok(())
+    }
+}
+
+#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, Initializer))]
 impl PyCPointer {
-    // TODO: not correct
+    /// Get the pointer value stored in buffer as usize
+    pub fn get_ptr_value(&self) -> usize {
+        let buffer = self.0.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    }
+
+    /// Set the pointer value in buffer
+    pub fn set_ptr_value(&self, value: usize) {
+        let mut buffer = self.0.buffer.write();
+        let bytes = value.to_ne_bytes();
+        if buffer.len() >= bytes.len() {
+            buffer.to_mut()[..bytes.len()].copy_from_slice(&bytes);
+        }
+    }
+
+    /// Pointer_bool: returns True if pointer is not NULL
+    #[pymethod]
+    fn __bool__(&self) -> bool {
+        self.get_ptr_value() != 0
+    }
+
+    /// contents getter - reads address from b_ptr and creates an instance of the pointed-to type
     #[pygetset]
-    fn contents(&self) -> PyResult<PyObjectRef> {
-        let contents = self.contents.read().clone();
-        Ok(contents)
+    fn contents(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Pointer_get_contents
+        let ptr_val = zelf.get_ptr_value();
+        if ptr_val == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+
+        // Get element type from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(std::mem::size_of::<usize>(), |info| info.size);
+
+        // Create instance that references the memory directly
+        // PyCData.into_ref_with_type works for all ctypes (simple, structure, union, array, pointer)
+        let cdata = unsafe { super::base::PyCData::at_address(ptr_val as *const u8, element_size) };
+        cdata
+            .into_ref_with_type(vm, proto_type.to_owned())
+            .map(Into::into)
     }
+
+    /// contents setter - stores address in b_ptr and keeps reference
+    /// Pointer_set_contents
     #[pygetset(setter)]
-    fn set_contents(&self, contents: PyObjectRef, _vm: &VirtualMachine) -> PyResult<()> {
-        // Validate that the contents is a CData instance if we have a _type_
-        // For now, just store it
-        *self.contents.write() = contents;
+    fn set_contents(zelf: &Py<Self>, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Get stginfo and proto for type validation
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto = stg_info.proto();
+
+        // Check if value is CData, or isinstance(value, proto)
+        let cdata = if let Some(c) = value.downcast_ref::<PyCData>() {
+            c
+        } else if value.is_instance(proto.as_object(), vm)? {
+            value
+                .downcast_ref::<PyCData>()
+                .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected {} instead of {}",
+                proto.name(),
+                value.class().name()
+            )));
+        };
+
+        // Set pointer value
+        {
+            let buffer = cdata.buffer.read();
+            let addr = buffer.as_ptr() as usize;
+            drop(buffer);
+            zelf.set_ptr_value(addr);
+        }
+
+        // KeepRef: store the object directly with index 1
+        zelf.0.keep_ref(1, value.clone(), vm)?;
+
+        // KeepRef: store GetKeepedObjects(dst) at index 0
+        if let Some(kept) = cdata.objects.read().clone() {
+            zelf.0.keep_ref(0, kept, vm)?;
+        }
+
         Ok(())
     }
 
+    // Pointer_subscript
     #[pymethod]
-    fn __init__(
-        &self,
-        value: crate::function::OptionalArg<PyObjectRef>,
-        _vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        // Pointer can be initialized with 0 or 1 argument
-        // If 1 argument is provided, it should be a CData instance
-        if let crate::function::OptionalArg::Present(val) = value {
-            *self.contents.write() = val;
+    fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            // Note: Pointer does NOT adjust negative indices (no length)
+            Self::getitem_by_index(zelf, i, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::getitem_by_slice(zelf, slice, vm)
+        } else {
+            Err(vm.new_type_error("Pointer indices must be integer"))
         }
-
-        Ok(())
     }
 
-    #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
-        if address == 0 {
-            return Err(vm.new_value_error("NULL pointer access".to_owned()));
+    // Pointer_item
+    fn getitem_by_index(zelf: &Py<Self>, index: isize, vm: &VirtualMachine) -> PyResult {
+        // if (*(void **)self->b_ptr == NULL) { PyErr_SetString(...); }
+        let ptr_value = zelf.get_ptr_value();
+        if ptr_value == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
         }
-        // Pointer just stores the address value
-        Ok(PyCPointer {
-            _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-            contents: PyRwLock::new(vm.ctx.new_int(address).into()),
+
+        // Get element type and size from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(std::mem::size_of::<usize>(), |info| info.size);
+
+        // offset = index * iteminfo->size
+        let offset = index * element_size as isize;
+        let addr = (ptr_value as isize + offset) as usize;
+
+        // Check if it's a simple type (has _type_ attribute)
+        if let Ok(type_attr) = proto_type.as_object().get_attr("_type_", vm)
+            && let Ok(type_str) = type_attr.str(vm)
+        {
+            let type_code = type_str.to_string();
+            return Self::read_value_at_address(addr, element_size, Some(&type_code), vm);
         }
-        .into_ref_with_type(vm, cls)?
-        .into())
+
+        // Complex type: create instance that references the memory directly (not a copy)
+        // This allows p[i].val = x to modify the original memory
+        // PyCData.into_ref_with_type works for all ctypes (array, structure, union, pointer)
+        let cdata = unsafe { super::base::PyCData::at_address(addr as *const u8, element_size) };
+        cdata
+            .into_ref_with_type(vm, proto_type.to_owned())
+            .map(Into::into)
     }
 
-    #[pyclassmethod]
-    fn from_buffer(
-        cls: PyTypeRef,
-        source: PyObjectRef,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::TryFromObject;
-        use crate::protocol::PyBuffer;
+    // Pointer_subscript slice handling (manual parsing, not PySlice_Unpack)
+    fn getitem_by_slice(zelf: &Py<Self>, slice: &PySlice, vm: &VirtualMachine) -> PyResult {
+        // Since pointers have no length, we have to dissect the slice ourselves
+
+        // step: defaults to 1, step == 0 is error
+        let step: isize = if let Some(ref step_obj) = slice.step
+            && !vm.is_none(step_obj)
+        {
+            let s = step_obj
+                .try_int(vm)?
+                .as_bigint()
+                .to_isize()
+                .ok_or_else(|| vm.new_value_error("slice step too large"))?;
+            if s == 0 {
+                return Err(vm.new_value_error("slice step cannot be zero"));
+            }
+            s
+        } else {
+            1
+        };
+
+        // start: defaults to 0, but required if step < 0
+        let start: isize = if let Some(ref start_obj) = slice.start
+            && !vm.is_none(start_obj)
+        {
+            start_obj
+                .try_int(vm)?
+                .as_bigint()
+                .to_isize()
+                .ok_or_else(|| vm.new_value_error("slice start too large"))?
+        } else {
+            if step < 0 {
+                return Err(vm.new_value_error("slice start is required for step < 0"));
+            }
+            0
+        };
 
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
+        // stop: ALWAYS required for pointers
+        if vm.is_none(&slice.stop) {
+            return Err(vm.new_value_error("slice stop is required"));
         }
-        let offset = offset as usize;
-        let size = std::mem::size_of::<usize>();
+        let stop: isize = slice
+            .stop
+            .try_int(vm)?
+            .as_bigint()
+            .to_isize()
+            .ok_or_else(|| vm.new_value_error("slice stop too large"))?;
 
-        let buffer = PyBuffer::try_from_object(vm, source.clone())?;
+        // calculate length
+        let len: usize = if (step > 0 && start > stop) || (step < 0 && start < stop) {
+            0
+        } else if step > 0 {
+            ((stop - start - 1) / step + 1) as usize
+        } else {
+            ((stop - start + 1) / step + 1) as usize
+        };
+
+        // Get element info
+        let stg_info = zelf.class().stg_info(vm)?;
+        let element_size = if let Some(ref proto_type) = stg_info.proto {
+            proto_type.stg_info_opt().expect("proto has StgInfo").size
+        } else {
+            std::mem::size_of::<usize>()
+        };
+        let type_code = stg_info
+            .proto
+            .as_ref()
+            .and_then(|p| p.as_object().get_attr("_type_", vm).ok())
+            .and_then(|t| t.str(vm).ok())
+            .map(|s| s.to_string());
 
-        if buffer.desc.readonly {
-            return Err(vm.new_type_error("underlying buffer is not writable".to_owned()));
+        let ptr_value = zelf.get_ptr_value();
+
+        // c_char → bytes
+        if type_code.as_deref() == Some("c") {
+            if len == 0 {
+                return Ok(vm.ctx.new_bytes(vec![]).into());
+            }
+            let mut result = Vec::with_capacity(len);
+            if step == 1 {
+                // Optimized contiguous copy
+                let start_addr = (ptr_value as isize + start * element_size as isize) as *const u8;
+                unsafe {
+                    result.extend_from_slice(std::slice::from_raw_parts(start_addr, len));
+                }
+            } else {
+                let mut cur = start;
+                for _ in 0..len {
+                    let addr = (ptr_value as isize + cur * element_size as isize) as *const u8;
+                    unsafe {
+                        result.push(*addr);
+                    }
+                    cur += step;
+                }
+            }
+            return Ok(vm.ctx.new_bytes(result).into());
         }
 
-        let buffer_len = buffer.desc.len;
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
+        // c_wchar → str
+        if type_code.as_deref() == Some("u") {
+            if len == 0 {
+                return Ok(vm.ctx.new_str("").into());
+            }
+            let mut result = String::with_capacity(len);
+            let wchar_size = std::mem::size_of::<libc::wchar_t>();
+            let mut cur = start;
+            for _ in 0..len {
+                let addr = (ptr_value as isize + cur * wchar_size as isize) as *const libc::wchar_t;
+                unsafe {
+                    if let Some(c) = char::from_u32(*addr as u32) {
+                        result.push(c);
+                    }
+                }
+                cur += step;
+            }
+            return Ok(vm.ctx.new_str(result).into());
         }
 
-        // Read pointer value from buffer
-        let bytes = buffer.obj_bytes();
-        let ptr_bytes = &bytes[offset..offset + size];
-        let ptr_val = usize::from_ne_bytes(ptr_bytes.try_into().expect("size is checked above"));
+        // other types → list with Pointer_item for each
+        let mut items = Vec::with_capacity(len);
+        let mut cur = start;
+        for _ in 0..len {
+            items.push(Self::getitem_by_index(zelf, cur, vm)?);
+            cur += step;
+        }
+        Ok(PyList::from(items).into_ref(&vm.ctx).into())
+    }
 
-        Ok(PyCPointer {
-            _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-            contents: PyRwLock::new(vm.ctx.new_int(ptr_val).into()),
+    // Pointer_ass_item
+    #[pymethod]
+    fn __setitem__(
+        zelf: &Py<Self>,
+        item: PyObjectRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Pointer does not support item deletion (value always provided)
+        // only integer indices supported for setitem
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            Self::setitem_by_index(zelf, i, value, vm)
+        } else {
+            Err(vm.new_type_error("Pointer indices must be integer"))
         }
-        .into_ref_with_type(vm, cls)?
-        .into())
     }
 
-    #[pyclassmethod]
-    fn from_buffer_copy(
-        cls: PyTypeRef,
-        source: crate::function::ArgBytesLike,
-        offset: crate::function::OptionalArg<isize>,
+    fn setitem_by_index(
+        zelf: &Py<Self>,
+        index: isize,
+        value: PyObjectRef,
         vm: &VirtualMachine,
-    ) -> PyResult {
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
+    ) -> PyResult<()> {
+        let ptr_value = zelf.get_ptr_value();
+        if ptr_value == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
         }
-        let offset = offset as usize;
-        let size = std::mem::size_of::<usize>();
 
-        let source_bytes = source.borrow_buf();
-        let buffer_len = source_bytes.len();
+        // Get element type, size and type_code from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
 
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
-        }
+        // Get type code from proto's _type_ attribute
+        let type_code: Option<String> = proto_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
 
-        // Read pointer value from buffer
-        let ptr_bytes = &source_bytes[offset..offset + size];
-        let ptr_val = usize::from_ne_bytes(ptr_bytes.try_into().expect("size is checked above"));
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(std::mem::size_of::<usize>(), |info| info.size);
 
-        Ok(PyCPointer {
-            _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-            contents: PyRwLock::new(vm.ctx.new_int(ptr_val).into()),
+        // Calculate address
+        let offset = index * element_size as isize;
+        let addr = (ptr_value as isize + offset) as usize;
+
+        // Write value at address
+        // Handle Structure/Array types by copying their buffer
+        if let Some(cdata) = value.downcast_ref::<super::PyCData>()
+            && (cdata.fast_isinstance(PyCStructure::static_type())
+                || cdata.fast_isinstance(PyCArray::static_type())
+                || cdata.fast_isinstance(PyCSimple::static_type()))
+        {
+            let src_buffer = cdata.buffer.read();
+            let copy_len = src_buffer.len().min(element_size);
+            unsafe {
+                let dest_ptr = addr as *mut u8;
+                std::ptr::copy_nonoverlapping(src_buffer.as_ptr(), dest_ptr, copy_len);
+            }
+        } else {
+            // Handle z/Z specially to store converted value
+            if type_code.as_deref() == Some("z")
+                && let Some(bytes) = value.downcast_ref::<PyBytes>()
+            {
+                let (converted, ptr_val) = super::base::ensure_z_null_terminated(bytes, vm);
+                unsafe {
+                    *(addr as *mut usize) = ptr_val;
+                }
+                return zelf.0.keep_ref(index as usize, converted, vm);
+            } else if type_code.as_deref() == Some("Z")
+                && let Some(s) = value.downcast_ref::<PyStr>()
+            {
+                let (holder, ptr_val) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                unsafe {
+                    *(addr as *mut usize) = ptr_val;
+                }
+                return zelf.0.keep_ref(index as usize, holder, vm);
+            } else {
+                Self::write_value_at_address(addr, element_size, &value, type_code.as_deref(), vm)?;
+            }
         }
-        .into_ref_with_type(vm, cls)?
-        .into())
+
+        // KeepRef: store reference to keep value alive using actual index
+        zelf.0.keep_ref(index as usize, value, vm)
     }
 
-    #[pyclassmethod]
-    fn in_dll(
-        cls: PyTypeRef,
-        dll: PyObjectRef,
-        name: crate::builtins::PyStrRef,
+    /// Read a value from memory address
+    fn read_value_at_address(
+        addr: usize,
+        size: usize,
+        type_code: Option<&str>,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use libloading::Symbol;
+        unsafe {
+            let ptr = addr as *const u8;
+            match type_code {
+                Some("c") => Ok(vm.ctx.new_bytes(vec![*ptr]).into()),
+                Some("b") => Ok(vm.ctx.new_int(*(ptr as *const i8) as i32).into()),
+                Some("B") => Ok(vm.ctx.new_int(*ptr as i32).into()),
+                Some("h") => Ok(vm.ctx.new_int(*(ptr as *const i16) as i32).into()),
+                Some("H") => Ok(vm.ctx.new_int(*(ptr as *const u16) as i32).into()),
+                Some("i") | Some("l") => Ok(vm.ctx.new_int(*(ptr as *const i32)).into()),
+                Some("I") | Some("L") => Ok(vm.ctx.new_int(*(ptr as *const u32)).into()),
+                Some("q") => Ok(vm.ctx.new_int(*(ptr as *const i64)).into()),
+                Some("Q") => Ok(vm.ctx.new_int(*(ptr as *const u64)).into()),
+                Some("f") => Ok(vm.ctx.new_float(*(ptr as *const f32) as f64).into()),
+                Some("d") | Some("g") => Ok(vm.ctx.new_float(*(ptr as *const f64)).into()),
+                Some("P") | Some("z") | Some("Z") => {
+                    Ok(vm.ctx.new_int(*(ptr as *const usize)).into())
+                }
+                _ => {
+                    // Default: read as bytes
+                    let bytes = std::slice::from_raw_parts(ptr, size).to_vec();
+                    Ok(vm.ctx.new_bytes(bytes).into())
+                }
+            }
+        }
+    }
 
-        // Get the library handle from dll object
-        let handle = if let Ok(int_handle) = dll.try_int(vm) {
-            // dll is an integer handle
-            int_handle
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        } else {
-            // dll is a CDLL/PyDLL/WinDLL object with _handle attribute
-            dll.get_attr("_handle", vm)?
-                .try_int(vm)?
-                .as_bigint()
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("Invalid library handle".to_owned()))?
-        };
+    /// Write a value to memory address
+    fn write_value_at_address(
+        addr: usize,
+        size: usize,
+        value: &PyObject,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        unsafe {
+            let ptr = addr as *mut u8;
 
-        // Get the library from cache
-        let library_cache = crate::stdlib::ctypes::library::libcache().read();
-        let library = library_cache
-            .get_lib(handle)
-            .ok_or_else(|| vm.new_attribute_error("Library not found".to_owned()))?;
+            // Handle c_char_p (z) and c_wchar_p (Z) - store pointer address
+            // Note: PyBytes/PyStr cases are handled by caller (setitem_by_index)
+            match type_code {
+                Some("z") | Some("Z") => {
+                    let ptr_val = if vm.is_none(value) {
+                        0usize
+                    } else if let Ok(int_val) = value.try_index(vm) {
+                        int_val.as_bigint().to_usize().unwrap_or(0)
+                    } else {
+                        return Err(vm.new_type_error(
+                            "bytes/string or integer address expected".to_owned(),
+                        ));
+                    };
+                    *(ptr as *mut usize) = ptr_val;
+                    return Ok(());
+                }
+                _ => {}
+            }
 
-        // Get symbol address from library
-        let symbol_name = format!("{}\0", name.as_str());
-        let inner_lib = library.lib.lock();
+            // Try to get value as integer
+            if let Ok(int_val) = value.try_int(vm) {
+                let i = int_val.as_bigint();
+                match size {
+                    1 => {
+                        *ptr = i.to_u8().unwrap_or(0);
+                    }
+                    2 => {
+                        *(ptr as *mut i16) = i.to_i16().unwrap_or(0);
+                    }
+                    4 => {
+                        *(ptr as *mut i32) = i.to_i32().unwrap_or(0);
+                    }
+                    8 => {
+                        *(ptr as *mut i64) = i.to_i64().unwrap_or(0);
+                    }
+                    _ => {
+                        let bytes = i.to_signed_bytes_le();
+                        let copy_len = bytes.len().min(size);
+                        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                    }
+                }
+                return Ok(());
+            }
 
-        let symbol_address = if let Some(lib) = &*inner_lib {
-            unsafe {
-                // Try to get the symbol from the library
-                let symbol: Symbol<'_, *mut u8> = lib.get(symbol_name.as_bytes()).map_err(|e| {
-                    vm.new_attribute_error(format!("{}: symbol '{}' not found", e, name.as_str()))
-                })?;
-                *symbol as usize
+            // Try to get value as float
+            if let Ok(float_val) = value.try_float(vm) {
+                let f = float_val.to_f64();
+                match size {
+                    4 => {
+                        *(ptr as *mut f32) = f as f32;
+                    }
+                    8 => {
+                        *(ptr as *mut f64) = f;
+                    }
+                    _ => {}
+                }
+                return Ok(());
+            }
+
+            // Try bytes
+            if let Ok(bytes) = value.try_bytes_like(vm, |b| b.to_vec()) {
+                let copy_len = bytes.len().min(size);
+                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                return Ok(());
             }
-        } else {
-            return Err(vm.new_attribute_error("Library is closed".to_owned()));
-        };
 
-        // For pointer types, we return a pointer to the symbol address
-        Ok(PyCPointer {
-            _base: PyCData::new(CDataObject::from_bytes(vec![], None)),
-            contents: PyRwLock::new(vm.ctx.new_int(symbol_address).into()),
+            Err(vm.new_type_error(format!(
+                "cannot convert {} to ctypes data",
+                value.class().name()
+            )))
         }
-        .into_ref_with_type(vm, cls)?
-        .into())
     }
 }
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
new file mode 100644
index 00000000000..1c0ec250d72
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -0,0 +1,1379 @@
+use super::_ctypes::CArgObject;
+use super::array::{PyCArray, WCHAR_SIZE, wchar_to_bytes};
+use super::base::{
+    CDATA_BUFFER_METHODS, FfiArgValue, PyCData, StgInfo, StgInfoFlags, buffer_to_ffi_value,
+    bytes_to_pyobject,
+};
+use super::function::PyCFuncPtr;
+use super::get_size;
+use super::pointer::PyCPointer;
+use crate::builtins::{PyByteArray, PyBytes, PyInt, PyNone, PyStr, PyType, PyTypeRef};
+use crate::convert::ToPyObject;
+use crate::function::{Either, FuncArgs, OptionalArg};
+use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, Representable};
+use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+use num_traits::ToPrimitive;
+use std::fmt::Debug;
+
+/// Valid type codes for ctypes simple types
+// spell-checker: disable-next-line
+pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPXOv?g";
+
+/// Create a new simple type instance from a class
+fn new_simple_type(
+    cls: Either<&PyObject, &Py<PyType>>,
+    vm: &VirtualMachine,
+) -> PyResult<PyCSimple> {
+    let cls = match cls {
+        Either::A(obj) => obj,
+        Either::B(typ) => typ.as_object(),
+    };
+
+    let _type_ = cls
+        .get_attr("_type_", vm)
+        .map_err(|_| vm.new_attribute_error("class must define a '_type_' attribute"))?;
+
+    if !_type_.is_instance((&vm.ctx.types.str_type).as_ref(), vm)? {
+        return Err(vm.new_type_error("class must define a '_type_' string attribute"));
+    }
+
+    let tp_str = _type_.str(vm)?.to_string();
+
+    if tp_str.len() != 1 {
+        return Err(vm.new_value_error(format!(
+            "class must define a '_type_' attribute which must be a string of length 1, str: {tp_str}"
+        )));
+    }
+
+    if !SIMPLE_TYPE_CHARS.contains(tp_str.as_str()) {
+        return Err(vm.new_attribute_error(format!(
+            "class must define a '_type_' attribute which must be\n a single character string containing one of {SIMPLE_TYPE_CHARS}, currently it is {tp_str}."
+        )));
+    }
+
+    let size = get_size(&tp_str);
+    Ok(PyCSimple(PyCData::from_bytes(vec![0u8; size], None)))
+}
+
+fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResult {
+    match _type_ {
+        "c" => {
+            // c_set: accepts bytes(len=1), bytearray(len=1), or int(0-255)
+            if value
+                .downcast_ref_if_exact::<PyBytes>(vm)
+                .is_some_and(|v| v.len() == 1)
+                || value
+                    .downcast_ref_if_exact::<PyByteArray>(vm)
+                    .is_some_and(|v| v.borrow_buf().len() == 1)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some_and(|v| {
+                    v.as_bigint()
+                        .to_i64()
+                        .is_some_and(|n| (0..=255).contains(&n))
+                })
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error("one character bytes, bytearray or integer expected"))
+            }
+        }
+        "u" => {
+            if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
+                if b {
+                    Ok(value.to_owned())
+                } else {
+                    Err(vm.new_type_error("one character unicode string expected"))
+                }
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        "b" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
+            // Support __index__ protocol
+            if value.try_index(vm).is_ok() {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "an integer is required (got type {})",
+                    value.class().name()
+                )))
+            }
+        }
+        "f" | "d" | "g" => {
+            // Handle int specially to check overflow
+            if let Some(int_obj) = value.downcast_ref_if_exact::<PyInt>(vm) {
+                // Check if int can fit in f64
+                if int_obj.as_bigint().to_f64().is_some() {
+                    return Ok(value.to_owned());
+                } else {
+                    return Err(vm.new_overflow_error("int too large to convert to float"));
+                }
+            }
+            // __float__ protocol
+            if value.try_float(vm).is_ok() {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!("must be real number, not {}", value.class().name())))
+            }
+        }
+        "?" => Ok(PyObjectRef::from(
+            vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
+        )),
+        "v" => {
+            // VARIANT_BOOL: any truthy → True
+            Ok(PyObjectRef::from(
+                vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
+            ))
+        }
+        "B" => {
+            // Support __index__ protocol
+            if value.try_index(vm).is_ok() {
+                // Store as-is, conversion to unsigned happens in the getter
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!("int expected instead of {}", value.class().name())))
+            }
+        }
+        "z" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyBytes>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "bytes or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        "Z" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        // O_set: py_object accepts any Python object
+        "O" => Ok(value.to_owned()),
+        _ => {
+            // "P"
+            if value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyNone>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error("cannot be converted to pointer"))
+            }
+        }
+    }
+}
+
+#[pyclass(module = "_ctypes", name = "PyCSimpleType", base = PyType)]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PyCSimpleType(PyType);
+
+#[pyclass(flags(BASETYPE), with(AsNumber, Initializer))]
+impl PyCSimpleType {
+    #[allow(clippy::new_ret_no_self)]
+    #[pymethod]
+    fn new(cls: PyTypeRef, _: OptionalArg, vm: &VirtualMachine) -> PyResult {
+        Ok(PyObjectRef::from(
+            new_simple_type(Either::B(&cls), vm)?
+                .into_ref_with_type(vm, cls)?
+                .clone(),
+        ))
+    }
+
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the class (e.g., c_int) that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If the value is already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Get the type code to determine conversion rules
+        let type_code = cls.type_code(vm);
+
+        // 3. Handle None for pointer types (c_char_p, c_wchar_p, c_void_p)
+        if vm.is_none(&value) && matches!(type_code.as_deref(), Some("z") | Some("Z") | Some("P")) {
+            return Ok(value);
+        }
+
+        // Helper to create CArgObject wrapping a simple instance
+        let create_simple_with_value = |type_str: &str, val: &PyObject| -> PyResult {
+            let simple = new_simple_type(Either::B(&cls), vm)?;
+            let buffer_bytes = value_to_bytes_endian(type_str, val, false, vm);
+            *simple.0.buffer.write() = std::borrow::Cow::Owned(buffer_bytes.clone());
+            let simple_obj: PyObjectRef = simple.into_ref_with_type(vm, cls.clone())?.into();
+            // from_param returns CArgObject, not the simple type itself
+            let tag = type_str.as_bytes().first().copied().unwrap_or(b'?');
+            let ffi_value = buffer_to_ffi_value(type_str, &buffer_bytes);
+            Ok(CArgObject {
+                tag,
+                value: ffi_value,
+                obj: simple_obj,
+                size: 0,
+                offset: 0,
+            }
+            .to_pyobject(vm))
+        };
+
+        // 4. Try to convert value based on type code
+        match type_code.as_deref() {
+            // Integer types: accept integers
+            Some(tc @ ("b" | "B" | "h" | "H" | "i" | "I" | "l" | "L" | "q" | "Q")) => {
+                if value.try_int(vm).is_ok() {
+                    return create_simple_with_value(tc, &value);
+                }
+            }
+            // Float types: accept numbers
+            Some(tc @ ("f" | "d" | "g")) => {
+                if value.try_float(vm).is_ok() || value.try_int(vm).is_ok() {
+                    return create_simple_with_value(tc, &value);
+                }
+            }
+            // c_char: 1 byte character
+            Some("c") => {
+                if let Some(bytes) = value.downcast_ref::<PyBytes>()
+                    && bytes.len() == 1
+                {
+                    return create_simple_with_value("c", &value);
+                }
+                if let Ok(int_val) = value.try_int(vm)
+                    && int_val.as_bigint().to_u8().is_some()
+                {
+                    return create_simple_with_value("c", &value);
+                }
+                return Err(vm.new_type_error(
+                    "one character bytes, bytearray or integer expected".to_string(),
+                ));
+            }
+            // c_wchar: 1 unicode character
+            Some("u") => {
+                if let Some(s) = value.downcast_ref::<PyStr>()
+                    && s.as_str().chars().count() == 1
+                {
+                    return create_simple_with_value("u", &value);
+                }
+                return Err(vm.new_type_error("one character unicode string expected"));
+            }
+            // c_char_p: bytes pointer
+            Some("z") => {
+                // 1. bytes → create CArgObject with null-terminated buffer
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (holder, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    return Ok(CArgObject {
+                        tag: b'z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 2. Array/Pointer with c_char element type
+                if is_cchar_array_or_pointer(&value, vm) {
+                    return Ok(value);
+                }
+                // 3. CArgObject (byref(c_char(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'c'
+                {
+                    return Ok(value.clone());
+                }
+            }
+            // c_wchar_p: unicode pointer
+            Some("Z") => {
+                // 1. str → create CArgObject with null-terminated wchar buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    return Ok(CArgObject {
+                        tag: b'Z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 2. Array/Pointer with c_wchar element type
+                if is_cwchar_array_or_pointer(&value, vm) {
+                    return Ok(value);
+                }
+                // 3. CArgObject (byref(c_wchar(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'u'
+                {
+                    return Ok(value.clone());
+                }
+            }
+            // c_void_p: most flexible - accepts int, bytes, str, any array/pointer, funcptr
+            Some("P") => {
+                // 1. int → create c_void_p with that address
+                if value.try_int(vm).is_ok() {
+                    return create_simple_with_value("P", &value);
+                }
+                // 2. bytes → create CArgObject with null-terminated buffer
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (holder, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    return Ok(CArgObject {
+                        tag: b'z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 3. str → create CArgObject with null-terminated wchar buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    return Ok(CArgObject {
+                        tag: b'Z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 4. Any Array or Pointer → accept directly
+                if value.downcast_ref::<PyCArray>().is_some()
+                    || value.downcast_ref::<PyCPointer>().is_some()
+                {
+                    return Ok(value);
+                }
+                // 5. CArgObject with 'P' tag (byref(c_void_p(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'P'
+                {
+                    return Ok(value.clone());
+                }
+                // 6. PyCFuncPtr → extract function pointer address
+                if let Some(funcptr) = value.downcast_ref::<PyCFuncPtr>() {
+                    let ptr_val = {
+                        let buffer = funcptr._base.buffer.read();
+                        if buffer.len() >= std::mem::size_of::<usize>() {
+                            usize::from_ne_bytes(
+                                buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+                            )
+                        } else {
+                            0
+                        }
+                    };
+                    return Ok(CArgObject {
+                        tag: b'P',
+                        value: FfiArgValue::Pointer(ptr_val),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 7. c_char_p or c_wchar_p instance → extract pointer value
+                if let Some(simple) = value.downcast_ref::<PyCSimple>() {
+                    let value_type_code = value.class().type_code(vm);
+                    if matches!(value_type_code.as_deref(), Some("z") | Some("Z")) {
+                        let ptr_val = {
+                            let buffer = simple.0.buffer.read();
+                            if buffer.len() >= std::mem::size_of::<usize>() {
+                                usize::from_ne_bytes(
+                                    buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+                                )
+                            } else {
+                                0
+                            }
+                        };
+                        return Ok(CArgObject {
+                            tag: b'Z',
+                            value: FfiArgValue::Pointer(ptr_val),
+                            obj: value.clone(),
+                            size: 0,
+                            offset: 0,
+                        }
+                        .to_pyobject(vm));
+                    }
+                }
+            }
+            // c_bool
+            Some("?") => {
+                let bool_val = value.is_true(vm)?;
+                let bool_obj: PyObjectRef = vm.ctx.new_bool(bool_val).into();
+                return create_simple_with_value("?", &bool_obj);
+            }
+            _ => {}
+        }
+
+        // 5. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCSimpleType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        // 6. Type-specific error messages
+        match type_code.as_deref() {
+            Some("z") => Err(vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as ctypes.c_char_p",
+                value.class().name()
+            ))),
+            Some("Z") => Err(vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as ctypes.c_wchar_p",
+                value.class().name()
+            ))),
+            _ => Err(vm.new_type_error("wrong type")),
+        }
+    }
+
+    #[pymethod]
+    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        PyCSimple::repeat(cls, n, vm)
+    }
+}
+
+impl AsNumber for PyCSimpleType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            multiply: Some(|a, b, vm| {
+                // a is a PyCSimpleType instance (type object like c_char)
+                // b is int (array size)
+                let cls = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
+                let n = b
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_isize()
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+                PyCSimple::repeat(cls.to_owned(), n, vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl Initializer for PyCSimpleType {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // type_init requires exactly 3 positional arguments: name, bases, dict
+        if args.args.len() != 3 {
+            return Err(vm.new_type_error(format!(
+                "type.__init__() takes 3 positional arguments but {} were given",
+                args.args.len()
+            )));
+        }
+
+        // Get the type from the metatype instance
+        let type_ref: PyTypeRef = zelf
+            .as_object()
+            .to_owned()
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        type_ref.check_not_initialized(vm)?;
+
+        // Get _type_ attribute
+        let type_attr = match type_ref.as_object().get_attr("_type_", vm) {
+            Ok(attr) => attr,
+            Err(_) => {
+                return Err(vm.new_attribute_error("class must define a '_type_' attribute"));
+            }
+        };
+
+        // Validate _type_ is a string
+        let type_str = type_attr.str(vm)?.to_string();
+
+        // Validate _type_ is a single character
+        if type_str.len() != 1 {
+            return Err(vm.new_value_error(
+                "class must define a '_type_' attribute which must be a string of length 1"
+                    .to_owned(),
+            ));
+        }
+
+        // Validate _type_ is a valid type character
+        if !SIMPLE_TYPE_CHARS.contains(type_str.as_str()) {
+            return Err(vm.new_attribute_error(format!(
+                "class must define a '_type_' attribute which must be a single character string containing one of '{}', currently it is '{}'.",
+                SIMPLE_TYPE_CHARS, type_str
+            )));
+        }
+
+        // Initialize StgInfo
+        let size = super::get_size(&type_str);
+        let align = super::get_align(&type_str);
+        let mut stg_info = StgInfo::new(size, align);
+
+        // Set format for PEP 3118 buffer protocol
+        // Format is endian prefix + type code (e.g., "<i" for little-endian int)
+        let endian_prefix = if cfg!(target_endian = "little") {
+            "<"
+        } else {
+            ">"
+        };
+        stg_info.format = Some(format!("{}{}", endian_prefix, type_str));
+        stg_info.paramfunc = super::base::ParamFunc::Simple;
+
+        // Set TYPEFLAG_ISPOINTER for pointer types: z (c_char_p), Z (c_wchar_p),
+        // P (c_void_p), s (char array), X (BSTR), O (py_object)
+        if matches!(type_str.as_str(), "z" | "Z" | "P" | "s" | "X" | "O") {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+        }
+
+        super::base::set_or_init_stginfo(&type_ref, stg_info);
+
+        // Create __ctype_le__ and __ctype_be__ swapped types
+        create_swapped_types(&type_ref, &type_str, vm)?;
+
+        Ok(())
+    }
+}
+
+/// Create __ctype_le__ and __ctype_be__ swapped byte order types
+/// On little-endian systems: __ctype_le__ = self, __ctype_be__ = swapped type
+/// On big-endian systems: __ctype_be__ = self, __ctype_le__ = swapped type
+///
+/// - Single-byte types (c, b, B): __ctype_le__ = __ctype_be__ = self
+/// - Pointer/unsupported types (z, Z, P, u, O): NO __ctype_le__/__ctype_be__ attributes
+/// - Multi-byte numeric types (h, H, i, I, l, L, q, Q, f, d, g, ?): create swapped types
+fn create_swapped_types(
+    type_ref: &Py<PyType>,
+    type_str: &str,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    use crate::builtins::PyDict;
+
+    // Avoid infinite recursion - if __ctype_le__ already exists, skip
+    if type_ref.as_object().get_attr("__ctype_le__", vm).is_ok() {
+        return Ok(());
+    }
+
+    // Types that don't support byte order swapping - no __ctype_le__/__ctype_be__
+    // c_void_p (P), c_char_p (z), c_wchar_p (Z), c_wchar (u), py_object (O)
+    let unsupported_types = ["P", "z", "Z", "u", "O"];
+    if unsupported_types.contains(&type_str) {
+        return Ok(());
+    }
+
+    // Single-byte types - __ctype_le__ = __ctype_be__ = self (no swapping needed)
+    // c_char (c), c_byte (b), c_ubyte (B)
+    let single_byte_types = ["c", "b", "B"];
+    if single_byte_types.contains(&type_str) {
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        return Ok(());
+    }
+
+    // Multi-byte types - create swapped type
+    // Check system byte order at compile time
+    let is_little_endian = cfg!(target_endian = "little");
+
+    // Create dict for the swapped (non-native) type
+    let swapped_dict: crate::PyRef<crate::builtins::PyDict> = PyDict::default().into_ref(&vm.ctx);
+    swapped_dict.set_item("_type_", vm.ctx.new_str(type_str).into(), vm)?;
+
+    // Create the swapped type using the same metaclass
+    let metaclass = type_ref.class();
+    let bases = vm.ctx.new_tuple(vec![type_ref.as_object().to_owned()]);
+
+    // Set placeholder first to prevent recursion
+    type_ref
+        .as_object()
+        .set_attr("__ctype_le__", vm.ctx.none(), vm)?;
+    type_ref
+        .as_object()
+        .set_attr("__ctype_be__", vm.ctx.none(), vm)?;
+
+    // Create only the non-native endian type
+    let suffix = if is_little_endian { "_be" } else { "_le" };
+    let swapped_type = metaclass.as_object().call(
+        (
+            vm.ctx.new_str(format!("{}{}", type_ref.name(), suffix)),
+            bases,
+            swapped_dict.as_object().to_owned(),
+        ),
+        vm,
+    )?;
+
+    // Set _swappedbytes_ on the swapped type to indicate byte swapping is needed
+    swapped_type.set_attr("_swappedbytes_", vm.ctx.none(), vm)?;
+
+    // Update swapped type's StgInfo format to use opposite endian prefix
+    // Native uses '<' on little-endian, '>' on big-endian
+    // Swapped uses the opposite
+    if let Ok(swapped_type_ref) = swapped_type.clone().downcast::<PyType>()
+        && let Some(mut sw_stg) = swapped_type_ref.get_type_data_mut::<StgInfo>()
+    {
+        let swapped_prefix = if is_little_endian { ">" } else { "<" };
+        sw_stg.format = Some(format!("{}{}", swapped_prefix, type_str));
+    }
+
+    // Set attributes based on system byte order
+    // Native endian attribute points to self, non-native points to swapped type
+    if is_little_endian {
+        // Little-endian system: __ctype_le__ = self, __ctype_be__ = swapped
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", swapped_type.clone(), vm)?;
+        swapped_type.set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        swapped_type.set_attr("__ctype_be__", swapped_type.clone(), vm)?;
+    } else {
+        // Big-endian system: __ctype_be__ = self, __ctype_le__ = swapped
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", swapped_type.clone(), vm)?;
+        swapped_type.set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        swapped_type.set_attr("__ctype_le__", swapped_type.clone(), vm)?;
+    }
+
+    Ok(())
+}
+
+#[pyclass(
+    module = "_ctypes",
+    name = "_SimpleCData",
+    base = PyCData,
+    metaclass = "PyCSimpleType"
+)]
+#[repr(transparent)]
+pub struct PyCSimple(pub PyCData);
+
+impl Debug for PyCSimple {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("PyCSimple")
+            .field("size", &self.0.buffer.read().len())
+            .finish()
+    }
+}
+
+fn value_to_bytes_endian(
+    _type_: &str,
+    value: &PyObject,
+    swapped: bool,
+    vm: &VirtualMachine,
+) -> Vec<u8> {
+    // Helper macro for endian conversion
+    macro_rules! to_bytes {
+        ($val:expr) => {
+            if swapped {
+                // Use opposite endianness
+                #[cfg(target_endian = "little")]
+                {
+                    $val.to_be_bytes().to_vec()
+                }
+                #[cfg(target_endian = "big")]
+                {
+                    $val.to_le_bytes().to_vec()
+                }
+            } else {
+                $val.to_ne_bytes().to_vec()
+            }
+        };
+    }
+
+    match _type_ {
+        "c" => {
+            // c_char - single byte (bytes, bytearray, or int 0-255)
+            if let Some(bytes) = value.downcast_ref::<PyBytes>()
+                && !bytes.is_empty()
+            {
+                return vec![bytes.as_bytes()[0]];
+            }
+            if let Some(bytearray) = value.downcast_ref::<PyByteArray>() {
+                let buf = bytearray.borrow_buf();
+                if !buf.is_empty() {
+                    return vec![buf[0]];
+                }
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_u8()
+            {
+                return vec![v];
+            }
+            vec![0]
+        }
+        "u" => {
+            // c_wchar - platform-dependent size (2 on Windows, 4 on Unix)
+            if let Ok(s) = value.str(vm)
+                && let Some(c) = s.as_str().chars().next()
+            {
+                let mut buffer = vec![0u8; WCHAR_SIZE];
+                wchar_to_bytes(c as u32, &mut buffer);
+                if swapped {
+                    buffer.reverse();
+                }
+                return buffer;
+            }
+            vec![0; WCHAR_SIZE]
+        }
+        "b" => {
+            // c_byte - signed char (1 byte)
+            // PyLong_AsLongMask pattern: wrapping for overflow values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i8;
+                return vec![v as u8];
+            }
+            vec![0]
+        }
+        "B" => {
+            // c_ubyte - unsigned char (1 byte)
+            // PyLong_AsUnsignedLongMask: wrapping for negative values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().map(|n| n as u8).unwrap_or(0);
+                return vec![v];
+            }
+            vec![0]
+        }
+        "h" => {
+            // c_short (2 bytes)
+            // PyLong_AsLongMask pattern: wrapping for overflow values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i16;
+                return to_bytes!(v);
+            }
+            vec![0; 2]
+        }
+        "H" => {
+            // c_ushort (2 bytes)
+            // PyLong_AsUnsignedLongMask: wrapping for negative values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().map(|n| n as u16).unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; 2]
+        }
+        "i" => {
+            // c_int (4 bytes)
+            // PyLong_AsLongMask pattern: wrapping for overflow values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i32;
+                return to_bytes!(v);
+            }
+            vec![0; 4]
+        }
+        "I" => {
+            // c_uint (4 bytes)
+            // PyLong_AsUnsignedLongMask: wrapping for negative values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().map(|n| n as u32).unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; 4]
+        }
+        "l" => {
+            // c_long (platform dependent)
+            // PyLong_AsLongMask pattern: wrapping for overflow values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().unwrap_or(0) as libc::c_long;
+                return to_bytes!(v);
+            }
+            const SIZE: usize = std::mem::size_of::<libc::c_long>();
+            vec![0; SIZE]
+        }
+        "L" => {
+            // c_ulong (platform dependent)
+            // PyLong_AsUnsignedLongMask: wrapping for negative values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val
+                    .as_bigint()
+                    .to_i128()
+                    .map(|n| n as libc::c_ulong)
+                    .unwrap_or(0);
+                return to_bytes!(v);
+            }
+            const SIZE: usize = std::mem::size_of::<libc::c_ulong>();
+            vec![0; SIZE]
+        }
+        "q" => {
+            // c_longlong (8 bytes)
+            // PyLong_AsLongMask pattern: wrapping for overflow values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i64;
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "Q" => {
+            // c_ulonglong (8 bytes)
+            // PyLong_AsUnsignedLongLongMask: wrapping for negative values
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().map(|n| n as u64).unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "f" => {
+            // c_float (4 bytes) - also accepts int
+            if let Ok(float_val) = value.try_float(vm) {
+                return to_bytes!(float_val.to_f64() as f32);
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_f64()
+            {
+                return to_bytes!(v as f32);
+            }
+            vec![0; 4]
+        }
+        "d" => {
+            // c_double (8 bytes) - also accepts int
+            if let Ok(float_val) = value.try_float(vm) {
+                return to_bytes!(float_val.to_f64());
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_f64()
+            {
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "g" => {
+            // long double - platform dependent size
+            // Store as f64, zero-pad to platform long double size
+            // Note: This may lose precision on platforms where long double > 64 bits
+            let f64_val = if let Ok(float_val) = value.try_float(vm) {
+                float_val.to_f64()
+            } else if let Ok(int_val) = value.try_int(vm) {
+                int_val.as_bigint().to_f64().unwrap_or(0.0)
+            } else {
+                0.0
+            };
+            let f64_bytes = if swapped {
+                #[cfg(target_endian = "little")]
+                {
+                    f64_val.to_be_bytes().to_vec()
+                }
+                #[cfg(target_endian = "big")]
+                {
+                    f64_val.to_le_bytes().to_vec()
+                }
+            } else {
+                f64_val.to_ne_bytes().to_vec()
+            };
+            // Pad to long double size
+            let long_double_size = super::get_size("g");
+            let mut result = f64_bytes;
+            result.resize(long_double_size, 0);
+            result
+        }
+        "?" => {
+            // c_bool (1 byte)
+            if let Ok(b) = value.to_owned().try_to_bool(vm) {
+                return vec![if b { 1 } else { 0 }];
+            }
+            vec![0]
+        }
+        "v" => {
+            // VARIANT_BOOL: True = 0xFFFF (-1 as i16), False = 0x0000
+            if let Ok(b) = value.to_owned().try_to_bool(vm) {
+                let val: i16 = if b { -1 } else { 0 };
+                return to_bytes!(val);
+            }
+            vec![0; 2]
+        }
+        "P" => {
+            // c_void_p - pointer type (platform pointer size)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; std::mem::size_of::<usize>()]
+        }
+        "z" => {
+            // c_char_p - pointer to char (stores pointer value from int)
+            // PyBytes case is handled in slot_new/set_value with make_z_buffer()
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; std::mem::size_of::<usize>()]
+        }
+        "Z" => {
+            // c_wchar_p - pointer to wchar_t (stores pointer value from int)
+            // PyStr case is handled in slot_new/set_value with make_wchar_buffer()
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                return to_bytes!(v);
+            }
+            vec![0; std::mem::size_of::<usize>()]
+        }
+        "O" => {
+            // py_object - store object id as non-zero marker
+            // The actual object is stored in _objects
+            // Use object's id as a non-zero placeholder (indicates non-NULL)
+            let id = value.get_id();
+            to_bytes!(id)
+        }
+        _ => vec![0],
+    }
+}
+
+/// Check if value is a c_char array or pointer(c_char)
+fn is_cchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
+    // Check Array with c_char element type
+    if let Some(arr) = value.downcast_ref::<PyCArray>()
+        && let Some(info) = arr.class().stg_info_opt()
+        && let Some(ref elem_type) = info.element_type
+        && let Some(elem_code) = elem_type.class().type_code(vm)
+    {
+        return elem_code == "c";
+    }
+    // Check Pointer to c_char
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>()
+        && let Some(info) = ptr.class().stg_info_opt()
+        && let Some(ref proto) = info.proto
+        && let Some(proto_code) = proto.class().type_code(vm)
+    {
+        return proto_code == "c";
+    }
+    false
+}
+
+/// Check if value is a c_wchar array or pointer(c_wchar)
+fn is_cwchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
+    // Check Array with c_wchar element type
+    if let Some(arr) = value.downcast_ref::<PyCArray>() {
+        let info = arr.class().stg_info_opt().expect("array has StgInfo");
+        let elem_type = info.element_type.as_ref().expect("array has element_type");
+        if let Some(elem_code) = elem_type.class().type_code(vm) {
+            return elem_code == "u";
+        }
+    }
+    // Check Pointer to c_wchar
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>() {
+        let info = ptr.class().stg_info_opt().expect("pointer has StgInfo");
+        if let Some(ref proto) = info.proto
+            && let Some(proto_code) = proto.class().type_code(vm)
+        {
+            return proto_code == "u";
+        }
+    }
+    false
+}
+
+impl Constructor for PyCSimple {
+    type Args = (OptionalArg,);
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let args: Self::Args = args.bind(vm)?;
+        let _type_ = cls
+            .type_code(vm)
+            .ok_or_else(|| vm.new_type_error("abstract class"))?;
+        // Save the initial argument for c_char_p/c_wchar_p _objects
+        let init_arg = args.0.into_option();
+
+        // Handle z/Z types with PyBytes/PyStr separately to avoid memory leak
+        if let Some(ref v) = init_arg {
+            if _type_ == "z" {
+                if let Some(bytes) = v.downcast_ref::<PyBytes>() {
+                    let (converted, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    let buffer = ptr.to_ne_bytes().to_vec();
+                    let cdata = PyCData::from_bytes(buffer, Some(converted));
+                    return PyCSimple(cdata).into_ref_with_type(vm, cls).map(Into::into);
+                }
+            } else if _type_ == "Z"
+                && let Some(s) = v.downcast_ref::<PyStr>()
+            {
+                let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                let buffer = ptr.to_ne_bytes().to_vec();
+                let cdata = PyCData::from_bytes(buffer, Some(holder));
+                return PyCSimple(cdata).into_ref_with_type(vm, cls).map(Into::into);
+            }
+        }
+
+        let value = if let Some(ref v) = init_arg {
+            set_primitive(_type_.as_str(), v, vm)?
+        } else {
+            match _type_.as_str() {
+                "c" | "u" => PyObjectRef::from(vm.ctx.new_bytes(vec![0])),
+                "b" | "B" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
+                    PyObjectRef::from(vm.ctx.new_int(0))
+                }
+                "f" | "d" | "g" => PyObjectRef::from(vm.ctx.new_float(0.0)),
+                "?" => PyObjectRef::from(vm.ctx.new_bool(false)),
+                _ => vm.ctx.none(), // "z" | "Z" | "P"
+            }
+        };
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        let buffer = value_to_bytes_endian(&_type_, &value, swapped, vm);
+
+        // For c_char_p (type "z"), c_wchar_p (type "Z"), and py_object (type "O"),
+        // store the initial value in _objects
+        let objects = if (_type_ == "z" || _type_ == "Z" || _type_ == "O") && init_arg.is_some() {
+            init_arg
+        } else {
+            None
+        };
+
+        PyCSimple(PyCData::from_bytes(buffer, objects))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+// Simple_repr
+impl Representable for PyCSimple {
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let cls = zelf.class();
+        let type_name = cls.name();
+
+        // Check if base is _SimpleCData (direct simple type like c_int, c_char)
+        // vs subclass of simple type (like class X(c_int): pass)
+        let bases = cls.bases.read();
+        let is_direct_simple = bases
+            .iter()
+            .any(|base| base.name().to_string() == "_SimpleCData");
+
+        if is_direct_simple {
+            // Direct SimpleCData: "typename(repr(value))"
+            let value = PyCSimple::value(zelf.to_owned().into(), vm)?;
+            let value_repr = value.repr(vm)?.to_string();
+            Ok(format!("{}({})", type_name, value_repr))
+        } else {
+            // Subclass: "<typename object at addr>"
+            let addr = zelf.get_id();
+            Ok(format!("<{} object at {:#x}>", type_name, addr))
+        }
+    }
+}
+
+#[pyclass(flags(BASETYPE), with(Constructor, AsBuffer, AsNumber, Representable))]
+impl PyCSimple {
+    #[pygetset]
+    fn _b0_(&self) -> Option<PyObjectRef> {
+        self.0.base.read().clone()
+    }
+
+    /// return True if any byte in buffer is non-zero
+    #[pymethod]
+    fn __bool__(&self) -> bool {
+        let buffer = self.0.buffer.read();
+        // Simple_bool: memcmp(self->b_ptr, zeros, self->b_size)
+        buffer.iter().any(|&b| b != 0)
+    }
+
+    #[pygetset]
+    pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let zelf: &Py<Self> = instance
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("cannot get value of instance"))?;
+
+        // Get _type_ from class
+        let cls = zelf.class();
+        let type_attr = cls
+            .as_object()
+            .get_attr("_type_", vm)
+            .map_err(|_| vm.new_type_error("no _type_ attribute"))?;
+        let type_code = type_attr.str(vm)?.to_string();
+
+        // Special handling for c_char_p (z) and c_wchar_p (Z)
+        // z_get, Z_get - dereference pointer to get string
+        if type_code == "z" {
+            // c_char_p: read pointer from buffer, dereference to get bytes string
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Ok(vm.ctx.none());
+            }
+            // Read null-terminated string at the address
+            unsafe {
+                let cstr = std::ffi::CStr::from_ptr(ptr as _);
+                return Ok(vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into());
+            }
+        }
+        if type_code == "Z" {
+            // c_wchar_p: read pointer from buffer, dereference to get wide string
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Ok(vm.ctx.none());
+            }
+            // Read null-terminated wide string at the address
+            unsafe {
+                let w_ptr = ptr as *const libc::wchar_t;
+                let len = libc::wcslen(w_ptr);
+                let wchars = std::slice::from_raw_parts(w_ptr, len);
+                let s: String = wchars
+                    .iter()
+                    .filter_map(|&c| char::from_u32(c as u32))
+                    .collect();
+                return Ok(vm.ctx.new_str(s).into());
+            }
+        }
+
+        // O_get: py_object - read PyObject pointer from buffer
+        if type_code == "O" {
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Err(vm.new_value_error("PyObject is NULL"));
+            }
+            // Non-NULL: return stored object from _objects if available
+            if let Some(obj) = zelf.0.objects.read().as_ref() {
+                return Ok(obj.clone());
+            }
+            return Err(vm.new_value_error("PyObject is NULL"));
+        }
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        // Read value from buffer, swap bytes if needed
+        let buffer = zelf.0.buffer.read();
+        let buffer_data: std::borrow::Cow<'_, [u8]> = if swapped {
+            // Reverse bytes for swapped endian types
+            let mut swapped_bytes = buffer.to_vec();
+            swapped_bytes.reverse();
+            std::borrow::Cow::Owned(swapped_bytes)
+        } else {
+            std::borrow::Cow::Borrowed(&*buffer)
+        };
+
+        let cls_ref = cls.to_owned();
+        bytes_to_pyobject(&cls_ref, &buffer_data, vm).or_else(|_| {
+            // Fallback: return bytes as integer based on type
+            match type_code.as_str() {
+                "c" => {
+                    if !buffer.is_empty() {
+                        Ok(vm.ctx.new_bytes(vec![buffer[0]]).into())
+                    } else {
+                        Ok(vm.ctx.new_bytes(vec![0]).into())
+                    }
+                }
+                "?" => {
+                    let val = buffer.first().copied().unwrap_or(0);
+                    Ok(vm.ctx.new_bool(val != 0).into())
+                }
+                _ => Ok(vm.ctx.new_int(0).into()),
+            }
+        })
+    }
+
+    #[pygetset(setter)]
+    fn set_value(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf: PyRef<Self> = instance
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("cannot set value of instance"))?;
+
+        // Get _type_ from class
+        let cls = zelf.class();
+        let type_attr = cls
+            .as_object()
+            .get_attr("_type_", vm)
+            .map_err(|_| vm.new_type_error("no _type_ attribute"))?;
+        let type_code = type_attr.str(vm)?.to_string();
+
+        // Handle z/Z types with PyBytes/PyStr separately to avoid memory leak
+        if type_code == "z" {
+            if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                let (converted, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                *zelf.0.buffer.write() = std::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+                *zelf.0.objects.write() = Some(converted);
+                return Ok(());
+            }
+        } else if type_code == "Z"
+            && let Some(s) = value.downcast_ref::<PyStr>()
+        {
+            let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+            *zelf.0.buffer.write() = std::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+            *zelf.0.objects.write() = Some(holder);
+            return Ok(());
+        }
+
+        let content = set_primitive(&type_code, &value, vm)?;
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = instance
+            .class()
+            .as_object()
+            .get_attr("_swappedbytes_", vm)
+            .is_ok();
+
+        // Update buffer when value changes
+        let buffer_bytes = value_to_bytes_endian(&type_code, &content, swapped, vm);
+        *zelf.0.buffer.write() = std::borrow::Cow::Owned(buffer_bytes);
+
+        // For c_char_p (type "z"), c_wchar_p (type "Z"), and py_object (type "O"),
+        // keep the reference in _objects
+        if type_code == "z" || type_code == "Z" || type_code == "O" {
+            *zelf.0.objects.write() = Some(value);
+        }
+        Ok(())
+    }
+
+    #[pyclassmethod]
+    fn repeat(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        use super::array::array_type_from_ctype;
+
+        if n < 0 {
+            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+        }
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
+    }
+
+    /// Simple_from_outparm - convert output parameter back to Python value
+    /// For direct subclasses of _SimpleCData (e.g., c_int), returns the value.
+    /// For subclasses of those (e.g., class MyInt(c_int)), returns self.
+    #[pymethod]
+    fn __ctypes_from_outparam__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // _ctypes_simple_instance: returns true if NOT a direct subclass of Simple_Type
+        // i.e., c_int (direct) -> false, MyInt(c_int) (subclass) -> true
+        let is_subclass_of_simple = {
+            let cls = zelf.class();
+            let bases = cls.bases.read();
+            // If base is NOT _SimpleCData, then it's a subclass of a subclass
+            !bases
+                .iter()
+                .any(|base| base.name().to_string() == "_SimpleCData")
+        };
+
+        if is_subclass_of_simple {
+            // Subclass of simple type (e.g., MyInt(c_int)): return self
+            Ok(zelf.into())
+        } else {
+            // Direct simple type (e.g., c_int): return value
+            PyCSimple::value(zelf.into(), vm)
+        }
+    }
+}
+
+impl PyCSimple {
+    /// Extract the value from this ctypes object as an owned FfiArgValue.
+    /// The value must be kept alive until after the FFI call completes.
+    pub fn to_ffi_value(
+        &self,
+        ty: libffi::middle::Type,
+        _vm: &VirtualMachine,
+    ) -> Option<FfiArgValue> {
+        let buffer = self.0.buffer.read();
+        let bytes: &[u8] = &buffer;
+
+        if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
+            if !bytes.is_empty() {
+                return Some(FfiArgValue::U8(bytes[0]));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
+            if !bytes.is_empty() {
+                return Some(FfiArgValue::I8(bytes[0] as i8));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
+            if bytes.len() >= 2 {
+                return Some(FfiArgValue::U16(u16::from_ne_bytes([bytes[0], bytes[1]])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
+            if bytes.len() >= 2 {
+                return Some(FfiArgValue::I16(i16::from_ne_bytes([bytes[0], bytes[1]])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::U32(u32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::I32(i32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::U64(u64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::I64(i64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::F32(f32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::F64(f64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if std::ptr::eq(
+            ty.as_raw_ptr(),
+            libffi::middle::Type::pointer().as_raw_ptr(),
+        ) && bytes.len() >= std::mem::size_of::<usize>()
+        {
+            let val =
+                usize::from_ne_bytes(bytes[..std::mem::size_of::<usize>()].try_into().unwrap());
+            return Some(FfiArgValue::Pointer(val));
+        }
+        None
+    }
+}
+
+impl AsBuffer for PyCSimple {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+        let buf = PyBuffer::new(
+            zelf.to_owned().into(),
+            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
+            &CDATA_BUFFER_METHODS,
+        );
+        Ok(buf)
+    }
+}
+
+/// Simple_bool: return non-zero if any byte in buffer is non-zero
+impl AsNumber for PyCSimple {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|obj, _vm| {
+                let zelf = obj
+                    .downcast_ref::<PyCSimple>()
+                    .expect("PyCSimple::as_number called on non-PyCSimple");
+                let buffer = zelf.0.buffer.read();
+                // Simple_bool: memcmp(self->b_ptr, zeros, self->b_size)
+                // Returns true if any byte is non-zero
+                Ok(buffer.iter().any(|&b| b != 0))
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index ca67a2fe7d6..10b8812e42c 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -1,42 +1,60 @@
-use super::base::{CDataObject, PyCData};
-use super::field::PyCField;
-use super::util::StgInfo;
+use super::base::{CDATA_BUFFER_METHODS, PyCData, PyCField, StgInfo, StgInfoFlags};
 use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
 use crate::convert::ToPyObject;
 use crate::function::FuncArgs;
-use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer, PyNumberMethods};
-use crate::stdlib::ctypes::_ctypes::get_size;
-use crate::types::{AsBuffer, AsNumber, Constructor};
-use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-use indexmap::IndexMap;
+use crate::function::PySetterValue;
+use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, SetAttr};
+use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
+use std::borrow::Cow;
 use std::fmt::Debug;
 
+/// Calculate Structure type size from _fields_ (sum of field sizes)
+pub(super) fn calculate_struct_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
+        let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+        let mut total_size = 0usize;
+
+        for field in fields.iter() {
+            if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                && let Some(field_type) = tuple.get(1)
+            {
+                total_size += super::_ctypes::sizeof(field_type.clone(), vm)?;
+            }
+        }
+        return Ok(total_size);
+    }
+    Ok(0)
+}
+
 /// PyCStructType - metaclass for Structure
 #[pyclass(name = "PyCStructType", base = PyType, module = "_ctypes")]
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyCStructType(PyType);
+pub(super) struct PyCStructType(PyType);
 
 impl Constructor for PyCStructType {
     type Args = FuncArgs;
 
     fn slot_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // 1. Create the new class using PyType::py_new
+        // 1. Create the new class using PyType::slot_new
         let new_class = crate::builtins::type_::PyType::slot_new(metatype, args, vm)?;
 
-        // 2. Process _fields_ if defined on the new class
+        // 2. Get the new type
         let new_type = new_class
             .clone()
             .downcast::<PyType>()
             .map_err(|_| vm.new_type_error("expected type"))?;
 
-        // Only process _fields_ if defined directly on this class (not inherited)
-        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
-            Self::process_fields(&new_type, fields_attr, vm)?;
-        }
+        // 3. Mark base classes as finalized (subclassing finalizes the parent)
+        new_type.mark_bases_final();
+
+        // 4. Initialize StgInfo for the new type (initialized=false, to be set in init)
+        let stg_info = StgInfo::default();
+        let _ = new_type.init_type_data(stg_info);
 
+        // Note: _fields_ processing moved to Initializer::init()
         Ok(new_class)
     }
 
@@ -45,11 +63,102 @@ impl Constructor for PyCStructType {
     }
 }
 
-#[pyclass(flags(BASETYPE), with(AsNumber, Constructor))]
+impl Initializer for PyCStructType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef by converting PyRef<Self> -> PyObjectRef -> PyRef<PyType>
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // Backward compatibility: skip initialization for abstract types
+        if new_type
+            .get_direct_attr(vm.ctx.intern_str("_abstract_"))
+            .is_some()
+        {
+            return Ok(());
+        }
+
+        new_type.check_not_initialized(vm)?;
+
+        // Process _fields_ if defined directly on this class (not inherited)
+        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            Self::process_fields(&new_type, fields_attr, vm)?;
+        } else {
+            // No _fields_ defined - try to copy from base class (PyCStgInfo_clone)
+            let (has_base_info, base_clone) = {
+                let bases = new_type.bases.read();
+                if let Some(base) = bases.first() {
+                    (base.stg_info_opt().is_some(), Some(base.clone()))
+                } else {
+                    (false, None)
+                }
+            };
+
+            if has_base_info && let Some(ref base) = base_clone {
+                // Clone base StgInfo (release guard before getting mutable reference)
+                let stg_info_opt = base.stg_info_opt().map(|baseinfo| {
+                    let mut stg_info = baseinfo.clone();
+                    stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL in subclass
+                    stg_info.initialized = true;
+                    stg_info
+                });
+
+                if let Some(stg_info) = stg_info_opt {
+                    // Mark base as FINAL (now guard is released)
+                    if let Some(mut base_stg) = base.get_type_data_mut::<StgInfo>() {
+                        base_stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    }
+
+                    super::base::set_or_init_stginfo(&new_type, stg_info);
+                    return Ok(());
+                }
+            }
+
+            // No base StgInfo - create default
+            let mut stg_info = StgInfo::new(0, 1);
+            stg_info.paramfunc = super::base::ParamFunc::Structure;
+            stg_info.format = Some("B".to_string());
+            super::base::set_or_init_stginfo(&new_type, stg_info);
+        }
+
+        Ok(())
+    }
+}
+
+#[pyclass(flags(BASETYPE), with(AsNumber, Constructor, Initializer, SetAttr))]
 impl PyCStructType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the structure type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCStructType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
     /// Called when a new Structure subclass is created
     #[pyclassmethod]
     fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+        cls.mark_bases_final();
+
         // Check if _fields_ is defined
         if let Some(fields_attr) = cls.get_direct_attr(vm.ctx.intern_str("_fields_")) {
             Self::process_fields(&cls, fields_attr, vm)?;
@@ -59,24 +168,63 @@ impl PyCStructType {
 
     /// Process _fields_ and create CField descriptors
     fn process_fields(
-        cls: &PyTypeRef,
+        cls: &Py<PyType>,
         fields_attr: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
+        // Check if this is a swapped byte order structure
+        let is_swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
         // Try to downcast to list or tuple
         let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>() {
             list.borrow_vec().to_vec()
         } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
             tuple.to_vec()
         } else {
-            return Err(vm.new_type_error("_fields_ must be a list or tuple".to_string()));
+            return Err(vm.new_type_error("_fields_ must be a list or tuple"));
+        };
+
+        let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+        let forced_alignment =
+            super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
+
+        // Determine byte order for format string
+        let big_endian = super::base::is_big_endian(is_swapped);
+
+        // Initialize offset, alignment, type flags, and ffi_field_types from base class
+        let (
+            mut offset,
+            mut max_align,
+            mut has_pointer,
+            mut has_union,
+            mut has_bitfield,
+            mut ffi_field_types,
+        ) = {
+            let bases = cls.bases.read();
+            if let Some(base) = bases.first()
+                && let Some(baseinfo) = base.stg_info_opt()
+            {
+                (
+                    baseinfo.size,
+                    std::cmp::max(baseinfo.align, forced_alignment),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASUNION),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
+                    baseinfo.ffi_field_types.clone(),
+                )
+            } else {
+                (0, forced_alignment, false, false, false, Vec::new())
+            }
         };
 
-        let mut offset = 0usize;
+        // Initialize PEP3118 format string
+        let mut format = String::from("T{");
+        let mut last_end = 0usize; // Track end of last field for padding calculation
+
         for (index, field) in fields.iter().enumerate() {
             let field_tuple = field
                 .downcast_ref::<PyTuple>()
-                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples".to_string()))?;
+                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
 
             if field_tuple.len() < 2 {
                 return Err(vm.new_type_error(
@@ -86,99 +234,173 @@ impl PyCStructType {
 
             let name = field_tuple
                 .first()
-                .unwrap()
+                .expect("len checked")
                 .downcast_ref::<PyStr>()
-                .ok_or_else(|| vm.new_type_error("field name must be a string".to_string()))?
+                .ok_or_else(|| vm.new_type_error("field name must be a string"))?
                 .to_string();
 
-            let field_type = field_tuple.get(1).unwrap().clone();
+            let field_type = field_tuple.get(1).expect("len checked").clone();
+
+            // For swapped byte order structures, validate field type supports byte swapping
+            if is_swapped {
+                super::base::check_other_endian_support(&field_type, vm)?;
+            }
+
+            // Get size and alignment of the field type
+            let size = super::base::get_field_size(&field_type, vm)?;
+            let field_align = super::base::get_field_align(&field_type, vm);
+
+            // Calculate effective alignment (PyCField_FromDesc)
+            let effective_align = if pack > 0 {
+                std::cmp::min(pack, field_align)
+            } else {
+                field_align
+            };
+
+            // Apply padding to align offset (cfield.c NO_BITFIELD case)
+            if effective_align > 0 && offset % effective_align != 0 {
+                let delta = effective_align - (offset % effective_align);
+                offset += delta;
+            }
+
+            max_align = max_align.max(effective_align);
+
+            // Propagate type flags from field type (HASPOINTER, HASUNION, HASBITFIELD)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+            {
+                // HASPOINTER: propagate if field is pointer or contains pointer
+                if field_stg.flags.intersects(
+                    StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER,
+                ) {
+                    has_pointer = true;
+                }
+                // HASUNION, HASBITFIELD: propagate directly
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASUNION) {
+                    has_union = true;
+                }
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD) {
+                    has_bitfield = true;
+                }
+                // Collect FFI type for this field
+                ffi_field_types.push(field_stg.to_ffi_type());
+            }
+
+            // Mark field type as finalized (using type as field finalizes it)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>() {
+                if let Some(mut stg_info) = type_obj.get_type_data_mut::<StgInfo>() {
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                } else {
+                    // Create StgInfo with FINAL flag if it doesn't exist
+                    let mut stg_info = StgInfo::new(size, field_align);
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    let _ = type_obj.init_type_data(stg_info);
+                }
+            }
+
+            // Build format string: add padding before field
+            let padding = offset - last_end;
+            if padding > 0 {
+                if padding != 1 {
+                    format.push_str(&padding.to_string());
+                }
+                format.push('x');
+            }
+
+            // Get field format and add to format string
+            let field_format = super::base::get_field_format(&field_type, big_endian, vm);
+
+            // Handle arrays: prepend shape
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+                && !field_stg.shape.is_empty()
+            {
+                let shape_str = field_stg
+                    .shape
+                    .iter()
+                    .map(|d| d.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",");
+                format.push_str(&std::format!("({}){}", shape_str, field_format));
+            } else {
+                format.push_str(&field_format);
+            }
 
-            // Get size of the field type
-            let size = Self::get_field_size(&field_type, vm)?;
+            // Add field name
+            format.push(':');
+            format.push_str(&name);
+            format.push(':');
 
-            // Create CField descriptor (accepts any ctypes type including arrays)
-            let c_field = PyCField::new(name.clone(), field_type, offset, size, index);
+            // Create CField descriptor with padding-adjusted offset
+            let field_type_ref = field_type
+                .clone()
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("_fields_ type must be a ctypes type"))?;
+            let c_field = PyCField::new(field_type_ref, offset as isize, size as isize, index);
 
             // Set the CField as a class attribute
-            cls.set_attr(vm.ctx.intern_str(name), c_field.to_pyobject(vm));
+            cls.set_attr(vm.ctx.intern_str(name.clone()), c_field.to_pyobject(vm));
 
+            // Update tracking
+            last_end = offset + size;
             offset += size;
         }
 
-        Ok(())
-    }
+        // Calculate total_align = max(max_align, forced_alignment)
+        let total_align = std::cmp::max(max_align, forced_alignment);
 
-    /// Get the size of a ctypes type
-    fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
-        // Try to get _type_ attribute for simple types
-        if let Some(size) = field_type
-            .get_attr("_type_", vm)
-            .ok()
-            .and_then(|type_attr| type_attr.str(vm).ok())
-            .and_then(|type_str| {
-                let s = type_str.to_string();
-                (s.len() == 1).then(|| get_size(&s))
-            })
-        {
-            return Ok(size);
-        }
+        // Calculate aligned_size (PyCStructUnionType_update_stginfo)
+        let aligned_size = if total_align > 0 {
+            offset.div_ceil(total_align) * total_align
+        } else {
+            offset
+        };
 
-        // Try sizeof for other types
-        if let Some(s) = field_type
-            .get_attr("size_of_instances", vm)
-            .ok()
-            .and_then(|size_method| size_method.call((), vm).ok())
-            .and_then(|size| size.try_int(vm).ok())
-            .and_then(|n| n.as_bigint().to_usize())
-        {
-            return Ok(s);
+        // Complete format string: add final padding and close
+        let final_padding = aligned_size - last_end;
+        if final_padding > 0 {
+            if final_padding != 1 {
+                format.push_str(&final_padding.to_string());
+            }
+            format.push('x');
+        }
+        format.push('}');
+
+        // Store StgInfo with aligned size and total alignment
+        let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.format = Some(format);
+        stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL; // Mark as finalized
+        if has_pointer {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASPOINTER;
+        }
+        if has_union {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASUNION;
         }
+        if has_bitfield {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASBITFIELD;
+        }
+        stg_info.paramfunc = super::base::ParamFunc::Structure;
+        // Set byte order: swap if _swappedbytes_ is defined
+        stg_info.big_endian = super::base::is_big_endian(is_swapped);
+        // Store FFI field types for structure passing
+        stg_info.ffi_field_types = ffi_field_types;
+        super::base::set_or_init_stginfo(cls, stg_info);
 
-        // Default to pointer size for unknown types
-        Ok(std::mem::size_of::<usize>())
-    }
+        // Process _anonymous_ fields
+        super::base::make_anon_fields(cls, vm)?;
 
-    /// Get the alignment of a ctypes type
-    fn get_field_align(field_type: &PyObject, vm: &VirtualMachine) -> usize {
-        // Try to get _type_ attribute for simple types
-        if let Some(align) = field_type
-            .get_attr("_type_", vm)
-            .ok()
-            .and_then(|type_attr| type_attr.str(vm).ok())
-            .and_then(|type_str| {
-                let s = type_str.to_string();
-                (s.len() == 1).then(|| get_size(&s)) // alignment == size for simple types
-            })
-        {
-            return align;
-        }
-        // Default alignment
-        1
+        Ok(())
     }
 
     #[pymethod]
     fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        use super::array::create_array_type_with_stg_info;
-        use crate::stdlib::ctypes::_ctypes::size_of;
+        use super::array::array_type_from_ctype;
 
         if n < 0 {
             return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
         }
-
-        // Calculate element size from the Structure type
-        let element_size = size_of(cls.clone().into(), vm)?;
-
-        let total_size = element_size
-            .checked_mul(n as usize)
-            .ok_or_else(|| vm.new_overflow_error("array size too large".to_owned()))?;
-        let stg_info = super::util::StgInfo::new_array(
-            total_size,
-            element_size,
-            n as usize,
-            cls.clone().into(),
-            element_size,
-        );
-        create_array_type_with_stg_info(stg_info, vm)
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
     }
 }
 
@@ -188,12 +410,12 @@ impl AsNumber for PyCStructType {
             multiply: Some(|a, b, vm| {
                 let cls = a
                     .downcast_ref::<PyType>()
-                    .ok_or_else(|| vm.new_type_error("expected type".to_owned()))?;
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
                 let n = b
                     .try_index(vm)?
                     .as_bigint()
                     .to_isize()
-                    .ok_or_else(|| vm.new_overflow_error("array size too large".to_owned()))?;
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
                 PyCStructType::__mul__(cls.to_owned(), n, vm)
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
@@ -202,14 +424,70 @@ impl AsNumber for PyCStructType {
     }
 }
 
-/// Structure field info stored in instance
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct FieldInfo {
-    pub name: String,
-    pub offset: usize,
-    pub size: usize,
-    pub type_ref: PyTypeRef,
+impl SetAttr for PyCStructType {
+    fn setattro(
+        zelf: &Py<Self>,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if _fields_ is being set
+        if attr_name.as_str() == "_fields_" {
+            let pytype: &Py<PyType> = zelf.to_base();
+
+            // Check finalization in separate scope to release read lock before process_fields
+            // This prevents deadlock: process_fields needs write lock on the same RwLock
+            let is_final = {
+                let Some(stg_info) = pytype.get_type_data::<StgInfo>() else {
+                    return Err(vm.new_type_error("ctypes state is not initialized"));
+                };
+                stg_info.is_final()
+            }; // Read lock released here
+
+            if is_final {
+                return Err(vm.new_attribute_error("_fields_ is final"));
+            }
+
+            // Process _fields_ and set attribute
+            let PySetterValue::Assign(fields_value) = value else {
+                return Err(vm.new_attribute_error("cannot delete _fields_"));
+            };
+            // Process fields (this will also set DICTFLAG_FINAL)
+            PyCStructType::process_fields(pytype, fields_value.clone(), vm)?;
+            // Set the _fields_ attribute on the type
+            pytype
+                .attributes
+                .write()
+                .insert(vm.ctx.intern_str("_fields_"), fields_value);
+            return Ok(());
+        }
+        // Delegate to PyType's setattro logic for type attributes
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+        let pytype: &Py<PyType> = zelf.to_base();
+
+        // Check for data descriptor first
+        if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
+            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            if let Some(descriptor) = descr_set {
+                return descriptor(&attr, pytype.to_owned().into(), value, vm);
+            }
+        }
+
+        // Store in type's attributes dict
+        if let PySetterValue::Assign(value) = value {
+            pytype.attributes.write().insert(attr_name_interned, value);
+        } else {
+            let prev = pytype.attributes.write().shift_remove(attr_name_interned);
+            if prev.is_none() {
+                return Err(vm.new_attribute_error(format!(
+                    "type object '{}' has no attribute '{}'",
+                    pytype.name(),
+                    attr_name.as_str(),
+                )));
+            }
+        }
+        Ok(())
+    }
 }
 
 /// PyCStructure - base class for Structure instances
@@ -219,19 +497,13 @@ pub struct FieldInfo {
     base = PyCData,
     metaclass = "PyCStructType"
 )]
-pub struct PyCStructure {
-    _base: PyCData,
-    /// Common CDataObject for memory buffer
-    pub(super) cdata: PyRwLock<CDataObject>,
-    /// Field information (name -> FieldInfo)
-    #[allow(dead_code)]
-    pub(super) fields: PyRwLock<IndexMap<String, FieldInfo>>,
-}
+#[repr(transparent)]
+pub struct PyCStructure(pub PyCData);
 
 impl Debug for PyCStructure {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PyCStructure")
-            .field("size", &self.cdata.read().size())
+            .field("size", &self.0.size())
             .finish()
     }
 }
@@ -240,13 +512,22 @@ impl Constructor for PyCStructure {
     type Args = FuncArgs;
 
     fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Check for abstract class and extract values in a block to drop the borrow
+        let (total_size, total_align, length) = {
+            let stg_info = cls.stg_info(vm)?;
+            (stg_info.size, stg_info.align, stg_info.length)
+        };
+
+        // Mark the class as finalized (instance creation finalizes the type)
+        if let Some(mut stg_info_mut) = cls.get_type_data_mut::<StgInfo>() {
+            stg_info_mut.flags |= StgInfoFlags::DICTFLAG_FINAL;
+        }
+
         // Get _fields_ from the class using get_attr to properly search MRO
         let fields_attr = cls.as_object().get_attr("_fields_", vm).ok();
 
-        let mut fields_map = IndexMap::new();
-        let mut total_size = 0usize;
-        let mut max_align = 1usize;
-
+        // Collect field names for initialization
+        let mut field_names: Vec<String> = Vec::new();
         if let Some(fields_attr) = fields_attr {
             let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>()
             {
@@ -257,7 +538,6 @@ impl Constructor for PyCStructure {
                 vec![]
             };
 
-            let mut offset = 0usize;
             for field in fields.iter() {
                 let Some(field_tuple) = field.downcast_ref::<PyTuple>() else {
                     continue;
@@ -265,43 +545,21 @@ impl Constructor for PyCStructure {
                 if field_tuple.len() < 2 {
                     continue;
                 }
-                let Some(name) = field_tuple.first().unwrap().downcast_ref::<PyStr>() else {
-                    continue;
-                };
-                let name = name.to_string();
-                let field_type = field_tuple.get(1).unwrap().clone();
-                let size = PyCStructType::get_field_size(&field_type, vm)?;
-                let field_align = PyCStructType::get_field_align(&field_type, vm);
-                max_align = max_align.max(field_align);
-
-                let type_ref = field_type
-                    .downcast::<PyType>()
-                    .unwrap_or_else(|_| vm.ctx.types.object_type.to_owned());
-
-                fields_map.insert(
-                    name.clone(),
-                    FieldInfo {
-                        name,
-                        offset,
-                        size,
-                        type_ref,
-                    },
-                );
-
-                offset += size;
+                if let Some(name) = field_tuple.first().unwrap().downcast_ref::<PyStr>() {
+                    field_names.push(name.to_string());
+                }
             }
-            total_size = offset;
         }
 
-        // Initialize buffer with zeros
-        let mut stg_info = StgInfo::new(total_size, max_align);
-        stg_info.length = fields_map.len();
-        let cdata = CDataObject::from_stg_info(&stg_info);
-        let instance = PyCStructure {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-            fields: PyRwLock::new(fields_map.clone()),
+        // Initialize buffer with zeros using computed size
+        let mut stg_info = StgInfo::new(total_size, total_align);
+        stg_info.length = if length > 0 {
+            length
+        } else {
+            field_names.len()
         };
+        stg_info.paramfunc = super::base::ParamFunc::Structure;
+        let instance = PyCStructure(PyCData::from_stg_info(&stg_info));
 
         // Handle keyword arguments for field initialization
         let py_instance = instance.into_ref_with_type(vm, cls.clone())?;
@@ -309,21 +567,21 @@ impl Constructor for PyCStructure {
 
         // Set field values from kwargs using standard attribute setting
         for (key, value) in args.kwargs.iter() {
-            if fields_map.contains_key(key.as_str()) {
+            if field_names.iter().any(|n| n == key.as_str()) {
                 py_obj.set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
             }
         }
 
         // Set field values from positional args
-        let field_names: Vec<String> = fields_map.keys().cloned().collect();
+        if args.args.len() > field_names.len() {
+            return Err(vm.new_type_error("too many initializers".to_string()));
+        }
         for (i, value) in args.args.iter().enumerate() {
-            if i < field_names.len() {
-                py_obj.set_attr(
-                    vm.ctx.intern_str(field_names[i].as_str()),
-                    value.clone(),
-                    vm,
-                )?;
-            }
+            py_obj.set_attr(
+                vm.ctx.intern_str(field_names[i].as_str()),
+                value.clone(),
+                vm,
+            )?;
         }
 
         Ok(py_instance.into())
@@ -337,11 +595,11 @@ impl Constructor for PyCStructure {
 // Note: GetAttr and SetAttr are not implemented here.
 // Field access is handled by CField descriptors registered on the class.
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor))]
+#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, AsBuffer))]
 impl PyCStructure {
     #[pygetset]
-    fn _objects(&self) -> Option<PyObjectRef> {
-        self.cdata.read().objects.clone()
+    fn _b0_(&self) -> Option<PyObjectRef> {
+        self.0.base.read().clone()
     }
 
     #[pygetset]
@@ -349,165 +607,30 @@ impl PyCStructure {
         // Return the _fields_ from the class, not instance
         vm.ctx.none()
     }
-
-    #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Read data from address
-        if address == 0 || size == 0 {
-            return Err(vm.new_value_error("NULL pointer access".to_owned()));
-        }
-        let data = unsafe {
-            let ptr = address as *const u8;
-            std::slice::from_raw_parts(ptr, size).to_vec()
-        };
-
-        // Create instance
-        let cdata = CDataObject::from_bytes(data, None);
-        Ok(PyCStructure {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-            fields: PyRwLock::new(IndexMap::new()),
-        }
-        .into_ref_with_type(vm, cls)?
-        .into())
-    }
-
-    #[pyclassmethod]
-    fn from_buffer(
-        cls: PyTypeRef,
-        source: PyObjectRef,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::TryFromObject;
-        use crate::protocol::PyBuffer;
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
-
-        // Get buffer from source
-        let buffer = PyBuffer::try_from_object(vm, source.clone())?;
-
-        // Check if buffer is writable
-        if buffer.desc.readonly {
-            return Err(vm.new_type_error("underlying buffer is not writable".to_owned()));
-        }
-
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Check if buffer is large enough
-        let buffer_len = buffer.desc.len;
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
-        }
-
-        // Read bytes from buffer at offset
-        let bytes = buffer.obj_bytes();
-        let data = bytes[offset..offset + size].to_vec();
-
-        // Create instance
-        let cdata = CDataObject::from_bytes(data, Some(source));
-        Ok(PyCStructure {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-            fields: PyRwLock::new(IndexMap::new()),
-        }
-        .into_ref_with_type(vm, cls)?
-        .into())
-    }
-
-    #[pyclassmethod]
-    fn from_buffer_copy(
-        cls: PyTypeRef,
-        source: crate::function::ArgBytesLike,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
-
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Borrow bytes from source
-        let source_bytes = source.borrow_buf();
-        let buffer_len = source_bytes.len();
-
-        // Check if buffer is large enough
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
-        }
-
-        // Copy bytes from buffer at offset
-        let data = source_bytes[offset..offset + size].to_vec();
-
-        // Create instance
-        let cdata = CDataObject::from_bytes(data, None);
-        Ok(PyCStructure {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-            fields: PyRwLock::new(IndexMap::new()),
-        }
-        .into_ref_with_type(vm, cls)?
-        .into())
-    }
 }
 
-static STRUCTURE_BUFFER_METHODS: BufferMethods = BufferMethods {
-    obj_bytes: |buffer| {
-        rustpython_common::lock::PyMappedRwLockReadGuard::map(
-            rustpython_common::lock::PyRwLockReadGuard::map(
-                buffer.obj_as::<PyCStructure>().cdata.read(),
-                |x: &CDataObject| x,
-            ),
-            |x: &CDataObject| x.buffer.as_slice(),
-        )
-        .into()
-    },
-    obj_bytes_mut: |buffer| {
-        rustpython_common::lock::PyMappedRwLockWriteGuard::map(
-            rustpython_common::lock::PyRwLockWriteGuard::map(
-                buffer.obj_as::<PyCStructure>().cdata.write(),
-                |x: &mut CDataObject| x,
-            ),
-            |x: &mut CDataObject| x.buffer.as_mut_slice(),
-        )
-        .into()
-    },
-    release: |_| {},
-    retain: |_| {},
-};
-
 impl AsBuffer for PyCStructure {
     fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-        let buffer_len = zelf.cdata.read().buffer.len();
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // PyCData_NewGetBuffer: use info->format if available, otherwise "B"
+        let format = zelf
+            .class()
+            .stg_info_opt()
+            .and_then(|info| info.format.clone())
+            .unwrap_or_else(|| "B".to_string());
+
+        // Structure: ndim=0, shape=(), itemsize=struct_size
         let buf = PyBuffer::new(
             zelf.to_owned().into(),
-            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
-            &STRUCTURE_BUFFER_METHODS,
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize: buffer_len,
+                format: Cow::Owned(format),
+                dim_desc: vec![], // ndim=0 means empty dim_desc
+            },
+            &CDATA_BUFFER_METHODS,
         );
         Ok(buf)
     }
diff --git a/crates/vm/src/stdlib/ctypes/thunk.rs b/crates/vm/src/stdlib/ctypes/thunk.rs
deleted file mode 100644
index 2de2308e1a3..00000000000
--- a/crates/vm/src/stdlib/ctypes/thunk.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-//! FFI callback (thunk) implementation for ctypes.
-//!
-//! This module implements CThunkObject which wraps Python callables
-//! to be callable from C code via libffi closures.
-
-use crate::builtins::{PyStr, PyType, PyTypeRef};
-use crate::vm::thread::with_current_vm;
-use crate::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
-use libffi::low;
-use libffi::middle::{Cif, Closure, CodePtr, Type};
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
-use std::ffi::c_void;
-use std::fmt::Debug;
-
-use super::base::ffi_type_from_str;
-/// Userdata passed to the libffi callback.
-/// This contains everything needed to invoke the Python callable.
-pub struct ThunkUserData {
-    /// The Python callable to invoke
-    pub callable: PyObjectRef,
-    /// Argument types for conversion
-    pub arg_types: Vec<PyTypeRef>,
-    /// Result type for conversion (None means void)
-    pub res_type: Option<PyTypeRef>,
-}
-
-/// Get the type code string from a ctypes type
-fn get_type_code(ty: &PyTypeRef, vm: &VirtualMachine) -> Option<String> {
-    ty.get_attr(vm.ctx.intern_str("_type_"))
-        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
-}
-
-/// Convert a C value to a Python object based on the type code
-fn ffi_to_python(ty: &PyTypeRef, ptr: *const c_void, vm: &VirtualMachine) -> PyObjectRef {
-    let type_code = get_type_code(ty, vm);
-    // SAFETY: ptr is guaranteed to be valid by libffi calling convention
-    unsafe {
-        match type_code.as_deref() {
-            Some("b") => vm.ctx.new_int(*(ptr as *const i8) as i32).into(),
-            Some("B") => vm.ctx.new_int(*(ptr as *const u8) as i32).into(),
-            Some("c") => vm.ctx.new_bytes(vec![*(ptr as *const u8)]).into(),
-            Some("h") => vm.ctx.new_int(*(ptr as *const i16) as i32).into(),
-            Some("H") => vm.ctx.new_int(*(ptr as *const u16) as i32).into(),
-            Some("i") => vm.ctx.new_int(*(ptr as *const i32)).into(),
-            Some("I") => vm.ctx.new_int(*(ptr as *const u32)).into(),
-            Some("l") => vm.ctx.new_int(*(ptr as *const libc::c_long)).into(),
-            Some("L") => vm.ctx.new_int(*(ptr as *const libc::c_ulong)).into(),
-            Some("q") => vm.ctx.new_int(*(ptr as *const libc::c_longlong)).into(),
-            Some("Q") => vm.ctx.new_int(*(ptr as *const libc::c_ulonglong)).into(),
-            Some("f") => vm.ctx.new_float(*(ptr as *const f32) as f64).into(),
-            Some("d") => vm.ctx.new_float(*(ptr as *const f64)).into(),
-            Some("P") | Some("z") | Some("Z") => vm.ctx.new_int(ptr as usize).into(),
-            _ => vm.ctx.none(),
-        }
-    }
-}
-
-/// Convert a Python object to a C value and store it at the result pointer
-fn python_to_ffi(obj: PyResult, ty: &PyTypeRef, result: *mut c_void, vm: &VirtualMachine) {
-    let obj = match obj {
-        Ok(o) => o,
-        Err(_) => return, // Exception occurred, leave result as-is
-    };
-
-    let type_code = get_type_code(ty, vm);
-    // SAFETY: result is guaranteed to be valid by libffi calling convention
-    unsafe {
-        match type_code.as_deref() {
-            Some("b") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut i8) = i.as_bigint().to_i8().unwrap_or(0);
-                }
-            }
-            Some("B") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
-                }
-            }
-            Some("c") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
-                }
-            }
-            Some("h") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut i16) = i.as_bigint().to_i16().unwrap_or(0);
-                }
-            }
-            Some("H") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut u16) = i.as_bigint().to_u16().unwrap_or(0);
-                }
-            }
-            Some("i") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut i32) = i.as_bigint().to_i32().unwrap_or(0);
-                }
-            }
-            Some("I") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut u32) = i.as_bigint().to_u32().unwrap_or(0);
-                }
-            }
-            Some("l") | Some("q") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut i64) = i.as_bigint().to_i64().unwrap_or(0);
-                }
-            }
-            Some("L") | Some("Q") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut u64) = i.as_bigint().to_u64().unwrap_or(0);
-                }
-            }
-            Some("f") => {
-                if let Ok(f) = obj.try_float(vm) {
-                    *(result as *mut f32) = f.to_f64() as f32;
-                }
-            }
-            Some("d") => {
-                if let Ok(f) = obj.try_float(vm) {
-                    *(result as *mut f64) = f.to_f64();
-                }
-            }
-            Some("P") | Some("z") | Some("Z") => {
-                if let Ok(i) = obj.try_int(vm) {
-                    *(result as *mut usize) = i.as_bigint().to_usize().unwrap_or(0);
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
-/// The callback function that libffi calls when the closure is invoked.
-/// This function converts C arguments to Python objects, calls the Python
-/// callable, and converts the result back to C.
-unsafe extern "C" fn thunk_callback(
-    _cif: &low::ffi_cif,
-    result: &mut c_void,
-    args: *const *const c_void,
-    userdata: &ThunkUserData,
-) {
-    with_current_vm(|vm| {
-        // Convert C arguments to Python objects
-        let py_args: Vec<PyObjectRef> = userdata
-            .arg_types
-            .iter()
-            .enumerate()
-            .map(|(i, ty)| {
-                let arg_ptr = unsafe { *args.add(i) };
-                ffi_to_python(ty, arg_ptr, vm)
-            })
-            .collect();
-
-        // Call the Python callable
-        let py_result = userdata.callable.call(py_args, vm);
-
-        // Convert result back to C type
-        if let Some(ref res_type) = userdata.res_type {
-            python_to_ffi(py_result, res_type, result as *mut c_void, vm);
-        }
-    });
-}
-
-/// Holds the closure and userdata together to ensure proper lifetime.
-/// The userdata is leaked to create a 'static reference that the closure can use.
-struct ThunkData {
-    #[allow(dead_code)]
-    closure: Closure<'static>,
-    /// Raw pointer to the leaked userdata, for cleanup
-    userdata_ptr: *mut ThunkUserData,
-}
-
-impl Drop for ThunkData {
-    fn drop(&mut self) {
-        // SAFETY: We created this with Box::into_raw, so we can reclaim it
-        unsafe {
-            drop(Box::from_raw(self.userdata_ptr));
-        }
-    }
-}
-
-/// CThunkObject wraps a Python callable to make it callable from C code.
-#[pyclass(name = "CThunkObject", module = "_ctypes")]
-#[derive(PyPayload)]
-pub struct PyCThunk {
-    /// The Python callable
-    callable: PyObjectRef,
-    /// The libffi closure (must be kept alive)
-    #[allow(dead_code)]
-    thunk_data: PyRwLock<Option<ThunkData>>,
-    /// The code pointer for the closure
-    code_ptr: CodePtr,
-}
-
-impl Debug for PyCThunk {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCThunk")
-            .field("callable", &self.callable)
-            .finish()
-    }
-}
-
-impl PyCThunk {
-    /// Create a new thunk wrapping a Python callable.
-    ///
-    /// # Arguments
-    /// * `callable` - The Python callable to wrap
-    /// * `arg_types` - Optional sequence of argument types
-    /// * `res_type` - Optional result type
-    /// * `vm` - The virtual machine
-    pub fn new(
-        callable: PyObjectRef,
-        arg_types: Option<PyObjectRef>,
-        res_type: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Self> {
-        // Parse argument types
-        let arg_type_vec: Vec<PyTypeRef> = if let Some(args) = arg_types {
-            if vm.is_none(&args) {
-                Vec::new()
-            } else {
-                let mut types = Vec::new();
-                for item in args.try_to_value::<Vec<PyObjectRef>>(vm)? {
-                    types.push(item.downcast::<PyType>().map_err(|_| {
-                        vm.new_type_error("_argtypes_ must be a sequence of types".to_string())
-                    })?);
-                }
-                types
-            }
-        } else {
-            Vec::new()
-        };
-
-        // Parse result type
-        let res_type_ref: Option<PyTypeRef> =
-            if let Some(ref rt) = res_type {
-                if vm.is_none(rt) {
-                    None
-                } else {
-                    Some(rt.clone().downcast::<PyType>().map_err(|_| {
-                        vm.new_type_error("restype must be a ctypes type".to_string())
-                    })?)
-                }
-            } else {
-                None
-            };
-
-        // Build FFI types
-        let ffi_arg_types: Vec<Type> = arg_type_vec
-            .iter()
-            .map(|ty| {
-                get_type_code(ty, vm)
-                    .and_then(|code| ffi_type_from_str(&code))
-                    .unwrap_or(Type::pointer())
-            })
-            .collect();
-
-        let ffi_res_type = res_type_ref
-            .as_ref()
-            .and_then(|ty| get_type_code(ty, vm))
-            .and_then(|code| ffi_type_from_str(&code))
-            .unwrap_or(Type::void());
-
-        // Create the CIF
-        let cif = Cif::new(ffi_arg_types, ffi_res_type);
-
-        // Create userdata and leak it to get a 'static reference
-        let userdata = Box::new(ThunkUserData {
-            callable: callable.clone(),
-            arg_types: arg_type_vec,
-            res_type: res_type_ref,
-        });
-        let userdata_ptr = Box::into_raw(userdata);
-
-        // SAFETY: We maintain the userdata lifetime by storing it in ThunkData
-        // and cleaning it up in Drop
-        let userdata_ref: &'static ThunkUserData = unsafe { &*userdata_ptr };
-
-        // Create the closure
-        let closure = Closure::new(cif, thunk_callback, userdata_ref);
-
-        // Get the code pointer
-        let code_ptr = CodePtr(*closure.code_ptr() as *mut _);
-
-        // Store closure and userdata together
-        let thunk_data = ThunkData {
-            closure,
-            userdata_ptr,
-        };
-
-        Ok(Self {
-            callable,
-            thunk_data: PyRwLock::new(Some(thunk_data)),
-            code_ptr,
-        })
-    }
-
-    /// Get the code pointer for this thunk
-    pub fn code_ptr(&self) -> CodePtr {
-        self.code_ptr
-    }
-}
-
-// SAFETY: PyCThunk is safe to send/sync because:
-// - callable is a PyObjectRef which is Send+Sync
-// - thunk_data contains the libffi closure which is heap-allocated
-// - code_ptr is just a pointer to executable memory
-unsafe impl Send for PyCThunk {}
-unsafe impl Sync for PyCThunk {}
-
-#[pyclass]
-impl PyCThunk {
-    #[pygetset]
-    fn callable(&self) -> PyObjectRef {
-        self.callable.clone()
-    }
-}
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
index 308a5e4e98f..500aa8e6244 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -1,40 +1,60 @@
-use super::base::{CDataObject, PyCData};
-use super::field::PyCField;
-use super::util::StgInfo;
+use super::base::{CDATA_BUFFER_METHODS, StgInfoFlags};
+use super::{PyCData, PyCField, StgInfo};
 use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
 use crate::convert::ToPyObject;
 use crate::function::FuncArgs;
-use crate::protocol::{BufferDescriptor, BufferMethods, PyBuffer as ProtocolPyBuffer};
-use crate::stdlib::ctypes::_ctypes::get_size;
-use crate::types::{AsBuffer, Constructor};
-use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
+use crate::function::PySetterValue;
+use crate::protocol::{BufferDescriptor, PyBuffer};
+use crate::types::{AsBuffer, Constructor, Initializer, SetAttr};
+use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use std::borrow::Cow;
+
+/// Calculate Union type size from _fields_ (max field size)
+pub(super) fn calculate_union_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
+        let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+        let mut max_size = 0usize;
+
+        for field in fields.iter() {
+            if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                && let Some(field_type) = tuple.get(1)
+            {
+                let field_size = super::_ctypes::sizeof(field_type.clone(), vm)?;
+                max_size = max_size.max(field_size);
+            }
+        }
+        return Ok(max_size);
+    }
+    Ok(0)
+}
 
 /// PyCUnionType - metaclass for Union
 #[pyclass(name = "UnionType", base = PyType, module = "_ctypes")]
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyCUnionType(PyType);
+pub(super) struct PyCUnionType(PyType);
 
 impl Constructor for PyCUnionType {
     type Args = FuncArgs;
 
     fn slot_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // 1. Create the new class using PyType::py_new
-        let new_class = crate::builtins::type_::PyType::slot_new(metatype, args, vm)?;
+        // 1. Create the new class using PyType::slot_new
+        let new_class = crate::builtins::PyType::slot_new(metatype, args, vm)?;
 
-        // 2. Process _fields_ if defined on the new class
+        // 2. Get the new type
         let new_type = new_class
             .clone()
             .downcast::<PyType>()
             .map_err(|_| vm.new_type_error("expected type"))?;
 
-        // Only process _fields_ if defined directly on this class (not inherited)
-        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
-            Self::process_fields(&new_type, fields_attr, vm)?;
-        }
+        // 3. Mark base classes as finalized (subclassing finalizes the parent)
+        new_type.mark_bases_final();
+
+        // 4. Initialize StgInfo for the new type (initialized=false, to be set in init)
+        let stg_info = StgInfo::default();
+        let _ = new_type.init_type_data(stg_info);
 
+        // Note: _fields_ processing moved to Initializer::init()
         Ok(new_class)
     }
 
@@ -43,26 +63,132 @@ impl Constructor for PyCUnionType {
     }
 }
 
+impl Initializer for PyCUnionType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef by converting PyRef<Self> -> PyObjectRef -> PyRef<PyType>
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // Check for _abstract_ attribute - skip initialization if present
+        if new_type
+            .get_direct_attr(vm.ctx.intern_str("_abstract_"))
+            .is_some()
+        {
+            return Ok(());
+        }
+
+        new_type.check_not_initialized(vm)?;
+
+        // Process _fields_ if defined directly on this class (not inherited)
+        // Use set_attr to trigger setattro
+        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            new_type
+                .as_object()
+                .set_attr(vm.ctx.intern_str("_fields_"), fields_attr, vm)?;
+        } else {
+            // No _fields_ defined - try to copy from base class
+            let (has_base_info, base_clone) = {
+                let bases = new_type.bases.read();
+                if let Some(base) = bases.first() {
+                    (base.stg_info_opt().is_some(), Some(base.clone()))
+                } else {
+                    (false, None)
+                }
+            };
+
+            if has_base_info && let Some(ref base) = base_clone {
+                // Clone base StgInfo (release guard before getting mutable reference)
+                let stg_info_opt = base.stg_info_opt().map(|baseinfo| {
+                    let mut stg_info = baseinfo.clone();
+                    stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL flag in subclass
+                    stg_info.initialized = true;
+                    stg_info
+                });
+
+                if let Some(stg_info) = stg_info_opt {
+                    // Mark base as FINAL (now guard is released)
+                    if let Some(mut base_stg) = base.get_type_data_mut::<StgInfo>() {
+                        base_stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    }
+
+                    super::base::set_or_init_stginfo(&new_type, stg_info);
+                    return Ok(());
+                }
+            }
+
+            // No base StgInfo - create default
+            let mut stg_info = StgInfo::new(0, 1);
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASUNION;
+            stg_info.paramfunc = super::base::ParamFunc::Union;
+            // PEP 3118 doesn't support union. Use 'B' for bytes.
+            stg_info.format = Some("B".to_string());
+            super::base::set_or_init_stginfo(&new_type, stg_info);
+        }
+
+        Ok(())
+    }
+}
+
 impl PyCUnionType {
     /// Process _fields_ and create CField descriptors
     /// For Union, all fields start at offset 0
     fn process_fields(
-        cls: &PyTypeRef,
+        cls: &Py<PyType>,
         fields_attr: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
+        // Check if already finalized
+        {
+            let Some(stg_info) = cls.get_type_data::<StgInfo>() else {
+                return Err(vm.new_type_error("ctypes state is not initialized"));
+            };
+            if stg_info.is_final() {
+                return Err(vm.new_attribute_error("_fields_ is final"));
+            }
+        } // Read lock released here
+
+        // Check if this is a swapped byte order union
+        let is_swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
         let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>() {
             list.borrow_vec().to_vec()
         } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
             tuple.to_vec()
         } else {
-            return Err(vm.new_type_error("_fields_ must be a list or tuple".to_string()));
+            return Err(vm.new_type_error("_fields_ must be a list or tuple"));
+        };
+
+        let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+        let forced_alignment =
+            super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
+
+        // Initialize size, alignment, type flags, and ffi_field_types from base class
+        // Note: Union fields always start at offset 0, but we inherit base size/align
+        let (mut max_size, mut max_align, mut has_pointer, mut has_bitfield, mut ffi_field_types) = {
+            let bases = cls.bases.read();
+            if let Some(base) = bases.first()
+                && let Some(baseinfo) = base.stg_info_opt()
+            {
+                (
+                    baseinfo.size,
+                    std::cmp::max(baseinfo.align, forced_alignment),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
+                    baseinfo.ffi_field_types.clone(),
+                )
+            } else {
+                (0, forced_alignment, false, false, Vec::new())
+            }
         };
 
         for (index, field) in fields.iter().enumerate() {
             let field_tuple = field
                 .downcast_ref::<PyTuple>()
-                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples".to_string()))?;
+                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
 
             if field_tuple.len() < 2 {
                 return Err(vm.new_type_error(
@@ -72,66 +198,230 @@ impl PyCUnionType {
 
             let name = field_tuple
                 .first()
-                .unwrap()
+                .expect("len checked")
                 .downcast_ref::<PyStr>()
-                .ok_or_else(|| vm.new_type_error("field name must be a string".to_string()))?
+                .ok_or_else(|| vm.new_type_error("field name must be a string"))?
                 .to_string();
 
-            let field_type = field_tuple.get(1).unwrap().clone();
-            let size = Self::get_field_size(&field_type, vm)?;
+            let field_type = field_tuple.get(1).expect("len checked").clone();
+
+            // For swapped byte order unions, validate field type supports byte swapping
+            if is_swapped {
+                super::base::check_other_endian_support(&field_type, vm)?;
+            }
+
+            let size = super::base::get_field_size(&field_type, vm)?;
+            let field_align = super::base::get_field_align(&field_type, vm);
+
+            // Calculate effective alignment
+            let effective_align = if pack > 0 {
+                std::cmp::min(pack, field_align)
+            } else {
+                field_align
+            };
+
+            max_size = max_size.max(size);
+            max_align = max_align.max(effective_align);
+
+            // Propagate type flags from field type (HASPOINTER, HASBITFIELD)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+            {
+                // HASPOINTER: propagate if field is pointer or contains pointer
+                if field_stg.flags.intersects(
+                    StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER,
+                ) {
+                    has_pointer = true;
+                }
+                // HASBITFIELD: propagate directly
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD) {
+                    has_bitfield = true;
+                }
+                // Collect FFI type for this field
+                ffi_field_types.push(field_stg.to_ffi_type());
+            }
+
+            // Mark field type as finalized (using type as field finalizes it)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>() {
+                if let Some(mut stg_info) = type_obj.get_type_data_mut::<StgInfo>() {
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                } else {
+                    // Create StgInfo with FINAL flag if it doesn't exist
+                    let mut stg_info = StgInfo::new(size, field_align);
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    let _ = type_obj.init_type_data(stg_info);
+                }
+            }
 
             // For Union, all fields start at offset 0
-            // Create CField descriptor (accepts any ctypes type including arrays)
-            let c_field = PyCField::new(name.clone(), field_type, 0, size, index);
+            let field_type_ref = field_type
+                .clone()
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("_fields_ type must be a ctypes type"))?;
+            let c_field = PyCField::new(field_type_ref, 0, size as isize, index);
 
             cls.set_attr(vm.ctx.intern_str(name), c_field.to_pyobject(vm));
         }
 
+        // Calculate total_align and aligned_size
+        let total_align = std::cmp::max(max_align, forced_alignment);
+        let aligned_size = if total_align > 0 {
+            max_size.div_ceil(total_align) * total_align
+        } else {
+            max_size
+        };
+
+        // Store StgInfo with aligned size
+        let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL | StgInfoFlags::TYPEFLAG_HASUNION;
+        // PEP 3118 doesn't support union. Use 'B' for bytes.
+        stg_info.format = Some("B".to_string());
+        if has_pointer {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASPOINTER;
+        }
+        if has_bitfield {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASBITFIELD;
+        }
+        stg_info.paramfunc = super::base::ParamFunc::Union;
+        // Set byte order: swap if _swappedbytes_ is defined
+        stg_info.big_endian = super::base::is_big_endian(is_swapped);
+        // Store FFI field types for union passing
+        stg_info.ffi_field_types = ffi_field_types;
+        super::base::set_or_init_stginfo(cls, stg_info);
+
+        // Process _anonymous_ fields
+        super::base::make_anon_fields(cls, vm)?;
+
         Ok(())
     }
+}
 
-    fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
-        if let Some(size) = field_type
-            .get_attr("_type_", vm)
-            .ok()
-            .and_then(|type_attr| type_attr.str(vm).ok())
-            .and_then(|type_str| {
-                let s = type_str.to_string();
-                (s.len() == 1).then(|| get_size(&s))
-            })
-        {
-            return Ok(size);
+#[pyclass(flags(BASETYPE), with(Constructor, Initializer, SetAttr))]
+impl PyCUnionType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the union type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
         }
 
-        if let Some(s) = field_type
-            .get_attr("size_of_instances", vm)
-            .ok()
-            .and_then(|size_method| size_method.call((), vm).ok())
-            .and_then(|size| size.try_int(vm).ok())
-            .and_then(|n| n.as_bigint().to_usize())
-        {
-            return Ok(s);
+        // 2. Check for CArgObject (PyCArg_CheckExact)
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>() {
+            // Check against proto (for pointer types)
+            if let Some(stg_info) = cls.stg_info_opt()
+                && let Some(ref proto) = stg_info.proto
+                && carg.obj.is_instance(proto.as_object(), vm)?
+            {
+                return Ok(value);
+            }
+            // Fallback: check if the wrapped object is an instance of the requested type
+            if carg.obj.is_instance(cls.as_object(), vm)? {
+                return Ok(value); // Return the CArgObject as-is
+            }
+            // CArgObject but wrong type
+            return Err(vm.new_type_error(format!(
+                "expected {} instance instead of pointer to {}",
+                cls.name(),
+                carg.obj.class().name()
+            )));
         }
 
-        Ok(std::mem::size_of::<usize>())
+        // 3. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCUnionType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
+    /// Called when a new Union subclass is created
+    #[pyclassmethod]
+    fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+        cls.mark_bases_final();
+
+        // Check if _fields_ is defined
+        if let Some(fields_attr) = cls.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            Self::process_fields(&cls, fields_attr, vm)?;
+        }
+        Ok(())
     }
 }
 
-#[pyclass(flags(BASETYPE), with(Constructor))]
-impl PyCUnionType {}
+impl SetAttr for PyCUnionType {
+    fn setattro(
+        zelf: &Py<Self>,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let pytype: &Py<PyType> = zelf.to_base();
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+
+        // 1. First, do PyType's setattro (PyType_Type.tp_setattro first)
+        // Check for data descriptor first
+        if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
+            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            if let Some(descriptor) = descr_set {
+                descriptor(&attr, pytype.to_owned().into(), value.clone(), vm)?;
+                // After successful setattro, check if _fields_ and call process_fields
+                if attr_name.as_str() == "_fields_"
+                    && let PySetterValue::Assign(fields_value) = value
+                {
+                    PyCUnionType::process_fields(pytype, fields_value, vm)?;
+                }
+                return Ok(());
+            }
+        }
+
+        // Store in type's attributes dict
+        match &value {
+            PySetterValue::Assign(v) => {
+                pytype
+                    .attributes
+                    .write()
+                    .insert(attr_name_interned, v.clone());
+            }
+            PySetterValue::Delete => {
+                let prev = pytype.attributes.write().shift_remove(attr_name_interned);
+                if prev.is_none() {
+                    return Err(vm.new_attribute_error(format!(
+                        "type object '{}' has no attribute '{}'",
+                        pytype.name(),
+                        attr_name.as_str(),
+                    )));
+                }
+            }
+        }
+
+        // 2. If _fields_, call process_fields (which checks FINAL internally)
+        if attr_name.as_str() == "_fields_"
+            && let PySetterValue::Assign(fields_value) = value
+        {
+            PyCUnionType::process_fields(pytype, fields_value, vm)?;
+        }
+
+        Ok(())
+    }
+}
 
 /// PyCUnion - base class for Union
 #[pyclass(module = "_ctypes", name = "Union", base = PyCData, metaclass = "PyCUnionType")]
-pub struct PyCUnion {
-    _base: PyCData,
-    /// Common CDataObject for memory buffer
-    pub(super) cdata: PyRwLock<CDataObject>,
-}
+#[repr(transparent)]
+pub struct PyCUnion(pub PyCData);
 
 impl std::fmt::Debug for PyCUnion {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PyCUnion")
-            .field("size", &self.cdata.read().size())
+            .field("size", &self.0.size())
             .finish()
     }
 }
@@ -140,47 +430,22 @@ impl Constructor for PyCUnion {
     type Args = FuncArgs;
 
     fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // Get _fields_ from the class
-        let fields_attr = cls.as_object().get_attr("_fields_", vm).ok();
-
-        // Calculate union size (max of all field sizes) and alignment
-        let mut max_size = 0usize;
-        let mut max_align = 1usize;
-
-        if let Some(fields_attr) = fields_attr {
-            let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>()
-            {
-                list.borrow_vec().to_vec()
-            } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
-                tuple.to_vec()
-            } else {
-                vec![]
-            };
+        // Check for abstract class and extract values in a block to drop the borrow
+        let (total_size, total_align) = {
+            let stg_info = cls.stg_info(vm)?;
+            (stg_info.size, stg_info.align)
+        };
 
-            for field in fields.iter() {
-                let Some(field_tuple) = field.downcast_ref::<PyTuple>() else {
-                    continue;
-                };
-                if field_tuple.len() < 2 {
-                    continue;
-                }
-                let field_type = field_tuple.get(1).unwrap().clone();
-                let size = PyCUnionType::get_field_size(&field_type, vm)?;
-                max_size = max_size.max(size);
-                // For simple types, alignment == size
-                max_align = max_align.max(size);
-            }
+        // Mark the class as finalized (instance creation finalizes the type)
+        if let Some(mut stg_info_mut) = cls.get_type_data_mut::<StgInfo>() {
+            stg_info_mut.flags |= StgInfoFlags::DICTFLAG_FINAL;
         }
 
-        // Initialize buffer with zeros
-        let stg_info = StgInfo::new(max_size, max_align);
-        let cdata = CDataObject::from_stg_info(&stg_info);
-        PyCUnion {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+        // Initialize buffer with zeros using computed size
+        let new_stg_info = StgInfo::new(total_size, total_align);
+        PyCUnion(PyCData::from_stg_info(&new_stg_info))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
     }
 
     fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
@@ -188,147 +453,125 @@ impl Constructor for PyCUnion {
     }
 }
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, AsBuffer))]
 impl PyCUnion {
-    #[pygetset]
-    fn _objects(&self) -> Option<PyObjectRef> {
-        self.cdata.read().objects.clone()
-    }
-
-    #[pyclassmethod]
-    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        // Get size from cls
-        let size = size_of(cls.clone().into(), vm)?;
-
-        // Create instance with data from address
-        if address == 0 || size == 0 {
-            return Err(vm.new_value_error("NULL pointer access".to_owned()));
-        }
-        let stg_info = StgInfo::new(size, 1);
-        let cdata = CDataObject::from_stg_info(&stg_info);
-        Ok(PyCUnion {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_ref_with_type(vm, cls)?
-        .into())
-    }
-
-    #[pyclassmethod]
-    fn from_buffer(
-        cls: PyTypeRef,
-        source: PyObjectRef,
-        offset: crate::function::OptionalArg<isize>,
+    /// Recursively initialize positional arguments through inheritance chain
+    /// Returns the number of arguments consumed
+    fn init_pos_args(
+        self_obj: &Py<Self>,
+        type_obj: &Py<PyType>,
+        args: &[PyObjectRef],
+        kwargs: &indexmap::IndexMap<String, PyObjectRef>,
+        index: usize,
         vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::TryFromObject;
-        use crate::protocol::PyBuffer;
-        use crate::stdlib::ctypes::_ctypes::size_of;
-
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
-
-        let buffer = PyBuffer::try_from_object(vm, source.clone())?;
+    ) -> PyResult<usize> {
+        let mut current_index = index;
+
+        // 1. First process base class fields recursively
+        // Recurse if base has StgInfo
+        let base_clone = {
+            let bases = type_obj.bases.read();
+            if let Some(base) = bases.first() &&
+                // Check if base has StgInfo
+                base.stg_info_opt().is_some()
+            {
+                Some(base.clone())
+            } else {
+                None
+            }
+        };
 
-        if buffer.desc.readonly {
-            return Err(vm.new_type_error("underlying buffer is not writable".to_owned()));
+        if let Some(ref base) = base_clone {
+            current_index = Self::init_pos_args(self_obj, base, args, kwargs, current_index, vm)?;
         }
 
-        let size = size_of(cls.clone().into(), vm)?;
-        let buffer_len = buffer.desc.len;
+        // 2. Process this class's _fields_
+        if let Some(fields_attr) = type_obj.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
 
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
+            for field in fields.iter() {
+                if current_index >= args.len() {
+                    break;
+                }
+                if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                    && let Some(name) = tuple.first()
+                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                {
+                    let field_name = name_str.as_str().to_owned();
+                    // Check for duplicate in kwargs
+                    if kwargs.contains_key(&field_name) {
+                        return Err(vm.new_type_error(format!(
+                            "duplicate values for field {:?}",
+                            field_name
+                        )));
+                    }
+                    self_obj.as_object().set_attr(
+                        vm.ctx.intern_str(field_name),
+                        args[current_index].clone(),
+                        vm,
+                    )?;
+                    current_index += 1;
+                }
+            }
         }
 
-        // Copy data from source buffer
-        let bytes = buffer.obj_bytes();
-        let data = bytes[offset..offset + size].to_vec();
-
-        let cdata = CDataObject::from_bytes(data, None);
-        Ok(PyCUnion {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
-        }
-        .into_ref_with_type(vm, cls)?
-        .into())
+        Ok(current_index)
     }
+}
 
-    #[pyclassmethod]
-    fn from_buffer_copy(
-        cls: PyTypeRef,
-        source: crate::function::ArgBytesLike,
-        offset: crate::function::OptionalArg<isize>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        use crate::stdlib::ctypes::_ctypes::size_of;
+impl Initializer for PyCUnion {
+    type Args = FuncArgs;
 
-        let offset = offset.unwrap_or(0);
-        if offset < 0 {
-            return Err(vm.new_value_error("offset cannot be negative".to_owned()));
-        }
-        let offset = offset as usize;
+    fn init(zelf: crate::PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Struct_init: handle positional and keyword arguments
+        let cls = zelf.class().to_owned();
 
-        let size = size_of(cls.clone().into(), vm)?;
-        let source_bytes = source.borrow_buf();
-        let buffer_len = source_bytes.len();
+        // 1. Process positional arguments recursively through inheritance chain
+        if !args.args.is_empty() {
+            let consumed = PyCUnion::init_pos_args(&zelf, &cls, &args.args, &args.kwargs, 0, vm)?;
 
-        if offset + size > buffer_len {
-            return Err(vm.new_value_error(format!(
-                "Buffer size too small ({} instead of at least {} bytes)",
-                buffer_len,
-                offset + size
-            )));
+            if consumed < args.args.len() {
+                return Err(vm.new_type_error("too many initializers"));
+            }
         }
 
-        // Copy data from source
-        let data = source_bytes[offset..offset + size].to_vec();
-
-        let cdata = CDataObject::from_bytes(data, None);
-        Ok(PyCUnion {
-            _base: PyCData::new(cdata.clone()),
-            cdata: PyRwLock::new(cdata),
+        // 2. Process keyword arguments
+        for (key, value) in args.kwargs.iter() {
+            zelf.as_object()
+                .set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
         }
-        .into_ref_with_type(vm, cls)?
-        .into())
+
+        Ok(())
     }
 }
 
-static UNION_BUFFER_METHODS: BufferMethods = BufferMethods {
-    obj_bytes: |buffer| {
-        rustpython_common::lock::PyRwLockReadGuard::map(
-            buffer.obj_as::<PyCUnion>().cdata.read(),
-            |x: &CDataObject| x.buffer.as_slice(),
-        )
-        .into()
-    },
-    obj_bytes_mut: |buffer| {
-        rustpython_common::lock::PyRwLockWriteGuard::map(
-            buffer.obj_as::<PyCUnion>().cdata.write(),
-            |x: &mut CDataObject| x.buffer.as_mut_slice(),
-        )
-        .into()
-    },
-    release: |_| {},
-    retain: |_| {},
-};
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsBuffer)
+)]
+impl PyCUnion {}
 
 impl AsBuffer for PyCUnion {
-    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<ProtocolPyBuffer> {
-        let buffer_len = zelf.cdata.read().buffer.len();
-        let buf = ProtocolPyBuffer::new(
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // PyCData_NewGetBuffer: use info->format if available, otherwise "B"
+        let format = zelf
+            .class()
+            .stg_info_opt()
+            .and_then(|info| info.format.clone())
+            .unwrap_or_else(|| "B".to_string());
+
+        // Union: ndim=0, shape=(), itemsize=union_size
+        let buf = PyBuffer::new(
             zelf.to_owned().into(),
-            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
-            &UNION_BUFFER_METHODS,
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize: buffer_len,
+                format: Cow::Owned(format),
+                dim_desc: vec![], // ndim=0 means empty dim_desc
+            },
+            &CDATA_BUFFER_METHODS,
         );
         Ok(buf)
     }
diff --git a/crates/vm/src/stdlib/ctypes/util.rs b/crates/vm/src/stdlib/ctypes/util.rs
deleted file mode 100644
index b8c6def63ca..00000000000
--- a/crates/vm/src/stdlib/ctypes/util.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::PyObjectRef;
-
-/// Storage information for ctypes types
-/// Stored in TypeDataSlot of heap types (PyType::init_type_data/get_type_data)
-#[derive(Clone)]
-pub struct StgInfo {
-    pub initialized: bool,
-    pub size: usize,                // number of bytes
-    pub align: usize,               // alignment requirements
-    pub length: usize,              // number of fields (for arrays/structures)
-    pub proto: Option<PyObjectRef>, // Only for Pointer/ArrayObject
-    pub flags: i32,                 // calling convention and such
-
-    // Array-specific fields (moved from PyCArrayType)
-    pub element_type: Option<PyObjectRef>, // _type_ for arrays
-    pub element_size: usize,               // size of each element
-}
-
-// StgInfo is stored in type_data which requires Send + Sync.
-// The PyObjectRef in proto/element_type fields is protected by the type system's locking mechanism.
-// CPython: ctypes objects are not thread-safe by design; users must synchronize access.
-unsafe impl Send for StgInfo {}
-unsafe impl Sync for StgInfo {}
-
-impl std::fmt::Debug for StgInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("StgInfo")
-            .field("initialized", &self.initialized)
-            .field("size", &self.size)
-            .field("align", &self.align)
-            .field("length", &self.length)
-            .field("proto", &self.proto)
-            .field("flags", &self.flags)
-            .field("element_type", &self.element_type)
-            .field("element_size", &self.element_size)
-            .finish()
-    }
-}
-
-impl Default for StgInfo {
-    fn default() -> Self {
-        StgInfo {
-            initialized: false,
-            size: 0,
-            align: 1,
-            length: 0,
-            proto: None,
-            flags: 0,
-            element_type: None,
-            element_size: 0,
-        }
-    }
-}
-
-impl StgInfo {
-    pub fn new(size: usize, align: usize) -> Self {
-        StgInfo {
-            initialized: true,
-            size,
-            align,
-            length: 0,
-            proto: None,
-            flags: 0,
-            element_type: None,
-            element_size: 0,
-        }
-    }
-
-    /// Create StgInfo for an array type
-    pub fn new_array(
-        size: usize,
-        align: usize,
-        length: usize,
-        element_type: PyObjectRef,
-        element_size: usize,
-    ) -> Self {
-        StgInfo {
-            initialized: true,
-            size,
-            align,
-            length,
-            proto: None,
-            flags: 0,
-            element_type: Some(element_type),
-            element_size,
-        }
-    }
-}
diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index d5a42739e96..26dff8b4426 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -73,8 +73,8 @@ mod _functools {
             self.inner.read().keywords.clone()
         }
 
-        #[pymethod(name = "__reduce__")]
-        fn reduce(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult {
+        #[pymethod]
+        fn __reduce__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult {
             let inner = zelf.inner.read();
             let partial_type = zelf.class();
 
diff --git a/crates/vm/src/stdlib/operator.rs b/crates/vm/src/stdlib/operator.rs
index 0c048ea2a3f..7877ddb0114 100644
--- a/crates/vm/src/stdlib/operator.rs
+++ b/crates/vm/src/stdlib/operator.rs
@@ -323,7 +323,7 @@ mod _operator {
     ) -> PyResult<bool> {
         let res = match (a, b) {
             (Either::A(a), Either::A(b)) => {
-                if !a.is_ascii() || !b.is_ascii() {
+                if !a.isascii() || !b.isascii() {
                     return Err(vm.new_type_error(
                         "comparing strings with non-ASCII characters is not supported",
                     ));
diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs
index be0a1c9a70c..2b6a2530b02 100644
--- a/crates/vm/src/types/structseq.rs
+++ b/crates/vm/src/types/structseq.rs
@@ -199,7 +199,7 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
             .ok_or_else(|| vm.new_type_error("unexpected payload for __repr__"))?;
 
         let field_names = Self::Data::REQUIRED_FIELD_NAMES;
-        let format_field = |(value, name): (&PyObjectRef, _)| {
+        let format_field = |(value, name): (&PyObject, _)| {
             let s = value.repr(vm)?;
             Ok(format!("{name}={s}"))
         };
@@ -212,6 +212,7 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
                 } else {
                     let fields: PyResult<Vec<_>> = zelf
                         .iter()
+                        .map(|value| value.as_ref())
                         .zip(field_names.iter().copied())
                         .map(format_field)
                         .collect();

From 6c186e389381cb1b9d99e74e085a9c53ddd24624 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 19 Dec 2025 14:51:09 +0100
Subject: [PATCH 013/418] Update `smptlib` and `test_smtpnet.py` from 3.13.11
 (#6435)

* Update `test_smtpnet.py` from 3.13.11

* Update `test_smtplib.py` from 3.13.11

* Update `smtplib.py` from 3.13.11

* Catch AttributeError
---
 Lib/smtplib.py           | 43 ++++++++++++++-------
 Lib/test/test_smtplib.py | 83 +++++++++++++++++++++++++++++++---------
 Lib/test/test_smtpnet.py |  9 +++--
 3 files changed, 100 insertions(+), 35 deletions(-)
 mode change 100644 => 100755 Lib/smtplib.py

diff --git a/Lib/smtplib.py b/Lib/smtplib.py
old mode 100644
new mode 100755
index 912233d8176..9b81bcfbc41
--- a/Lib/smtplib.py
+++ b/Lib/smtplib.py
@@ -171,7 +171,7 @@ def quotedata(data):
     internet CRLF end-of-line.
     """
     return re.sub(r'(?m)^\.', '..',
-                  re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
+        re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
 
 def _quote_periods(bindata):
     return re.sub(br'(?m)^\.', b'..', bindata)
@@ -179,6 +179,16 @@ def _quote_periods(bindata):
 def _fix_eols(data):
     return  re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)
 
+
+try:
+    hmac.digest(b'', b'', 'md5')
+# except ValueError:
+except (ValueError, AttributeError): # TODO: RUSTPYTHON
+    _have_cram_md5_support = False
+else:
+    _have_cram_md5_support = True
+
+
 try:
     import ssl
 except ImportError:
@@ -475,7 +485,7 @@ def ehlo(self, name=''):
             if auth_match:
                 # This doesn't remove duplicates, but that's no problem
                 self.esmtp_features["auth"] = self.esmtp_features.get("auth", "") \
-                                              + " " + auth_match.groups(0)[0]
+                        + " " + auth_match.groups(0)[0]
                 continue
 
             # RFC 1869 requires a space between ehlo keyword and parameters.
@@ -488,7 +498,7 @@ def ehlo(self, name=''):
                 params = m.string[m.end("feature"):].strip()
                 if feature == "auth":
                     self.esmtp_features[feature] = self.esmtp_features.get(feature, "") \
-                                                   + " " + params
+                            + " " + params
                 else:
                     self.esmtp_features[feature] = params
         return (code, msg)
@@ -542,7 +552,7 @@ def mail(self, sender, options=()):
                     raise SMTPNotSupportedError(
                         'SMTPUTF8 not supported by server')
             optionlist = ' ' + ' '.join(options)
-        self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender), optionlist))
+        self.putcmd("mail", "from:%s%s" % (quoteaddr(sender), optionlist))
         return self.getreply()
 
     def rcpt(self, recip, options=()):
@@ -550,7 +560,7 @@ def rcpt(self, recip, options=()):
         optionlist = ''
         if options and self.does_esmtp:
             optionlist = ' ' + ' '.join(options)
-        self.putcmd("rcpt", "TO:%s%s" % (quoteaddr(recip), optionlist))
+        self.putcmd("rcpt", "to:%s%s" % (quoteaddr(recip), optionlist))
         return self.getreply()
 
     def data(self, msg):
@@ -667,8 +677,11 @@ def auth_cram_md5(self, challenge=None):
         # CRAM-MD5 does not support initial-response.
         if challenge is None:
             return None
-        return self.user + " " + hmac.HMAC(
-            self.password.encode('ascii'), challenge, 'md5').hexdigest()
+        if not _have_cram_md5_support:
+            raise SMTPException("CRAM-MD5 is not supported")
+        password = self.password.encode('ascii')
+        authcode = hmac.HMAC(password, challenge, 'md5')
+        return f"{self.user} {authcode.hexdigest()}"
 
     def auth_plain(self, challenge=None):
         """ Authobject to use with PLAIN authentication. Requires self.user and
@@ -720,8 +733,10 @@ def login(self, user, password, *, initial_response_ok=True):
         advertised_authlist = self.esmtp_features["auth"].split()
 
         # Authentication methods we can handle in our preferred order:
-        preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
-
+        if _have_cram_md5_support:
+            preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
+        else:
+            preferred_auths = ['PLAIN', 'LOGIN']
         # We try the supported authentications in our preferred order, if
         # the server supports them.
         authlist = [auth for auth in preferred_auths
@@ -905,7 +920,7 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         The arguments are as for sendmail, except that msg is an
         email.message.Message object.  If from_addr is None or to_addrs is
         None, these arguments are taken from the headers of the Message as
-        described in RFC 2822 (a ValueError is raised if there is more than
+        described in RFC 5322 (a ValueError is raised if there is more than
         one set of 'Resent-' headers).  Regardless of the values of from_addr and
         to_addr, any Bcc field (or Resent-Bcc field, when the Message is a
         resent) of the Message object won't be transmitted.  The Message
@@ -919,7 +934,7 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         policy.
 
         """
-        # 'Resent-Date' is a mandatory field if the Message is resent (RFC 2822
+        # 'Resent-Date' is a mandatory field if the Message is resent (RFC 5322
         # Section 3.6.6). In such a case, we use the 'Resent-*' fields.  However,
         # if there is more than one 'Resent-' block there's no way to
         # unambiguously determine which one is the most recent in all cases,
@@ -938,10 +953,10 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         else:
             raise ValueError("message has more than one 'Resent-' header block")
         if from_addr is None:
-            # Prefer the sender field per RFC 2822:3.6.2.
+            # Prefer the sender field per RFC 5322 section 3.6.2.
             from_addr = (msg[header_prefix + 'Sender']
-                         if (header_prefix + 'Sender') in msg
-                         else msg[header_prefix + 'From'])
+                           if (header_prefix + 'Sender') in msg
+                           else msg[header_prefix + 'From'])
             from_addr = email.utils.getaddresses([from_addr])[0][1]
         if to_addrs is None:
             addr_fields = [f for f in (msg[header_prefix + 'To'],
diff --git a/Lib/test/test_smtplib.py b/Lib/test/test_smtplib.py
index 9b787950fc2..ade0dc1308c 100644
--- a/Lib/test/test_smtplib.py
+++ b/Lib/test/test_smtplib.py
@@ -17,6 +17,7 @@
 import threading
 
 import unittest
+import unittest.mock as mock
 from test import support, mock_socket
 from test.support import hashlib_helper
 from test.support import socket_helper
@@ -350,7 +351,7 @@ def testVRFY(self):
                             timeout=support.LOOPBACK_TIMEOUT)
         self.addCleanup(smtp.close)
         expected = (252, b'Cannot VRFY user, but will accept message ' + \
-                    b'and attempt delivery')
+                         b'and attempt delivery')
         self.assertEqual(smtp.vrfy('nobody@nowhere.com'), expected)
         self.assertEqual(smtp.verify('nobody@nowhere.com'), expected)
         smtp.quit()
@@ -371,7 +372,7 @@ def testHELP(self):
                             timeout=support.LOOPBACK_TIMEOUT)
         self.addCleanup(smtp.close)
         self.assertEqual(smtp.help(), b'Supported commands: EHLO HELO MAIL ' + \
-                         b'RCPT DATA RSET NOOP QUIT VRFY')
+                                      b'RCPT DATA RSET NOOP QUIT VRFY')
         smtp.quit()
 
     def testSend(self):
@@ -527,7 +528,7 @@ def testSendMessageWithAddresses(self):
         smtp.quit()
         # make sure the Bcc header is still in the message.
         self.assertEqual(m['Bcc'], 'John Root <root@localhost>, "Dinsdale" '
-                                   '<warped@silly.walks.com>')
+                                    '<warped@silly.walks.com>')
 
         self.client_evt.set()
         self.serv_evt.wait()
@@ -766,7 +767,7 @@ def tearDown(self):
 
     def testFailingHELO(self):
         self.assertRaises(smtplib.SMTPConnectError, smtplib.SMTP,
-                          HOST, self.port, 'localhost', 3)
+                            HOST, self.port, 'localhost', 3)
 
 
 class TooLongLineTests(unittest.TestCase):
@@ -804,14 +805,14 @@ def testLineTooLong(self):
 sim_users = {'Mr.A@somewhere.com':'John A',
              'Ms.B@xn--fo-fka.com':'Sally B',
              'Mrs.C@somewhereesle.com':'Ruth C',
-             }
+            }
 
 sim_auth = ('Mr.A@somewhere.com', 'somepassword')
 sim_cram_md5_challenge = ('PENCeUxFREJoU0NnbmhNWitOMjNGNn'
                           'dAZWx3b29kLmlubm9zb2Z0LmNvbT4=')
 sim_lists = {'list-1':['Mr.A@somewhere.com','Mrs.C@somewhereesle.com'],
              'list-2':['Ms.B@xn--fo-fka.com',],
-             }
+            }
 
 # Simulated SMTP channel & server
 class ResponseException(Exception): pass
@@ -830,6 +831,7 @@ class SimSMTPChannel(smtpd.SMTPChannel):
     def __init__(self, extra_features, *args, **kw):
         self._extrafeatures = ''.join(
             [ "250-{0}\r\n".format(x) for x in extra_features ])
+        self.all_received_lines = []
         super(SimSMTPChannel, self).__init__(*args, **kw)
 
     # AUTH related stuff.  It would be nice if support for this were in smtpd.
@@ -844,6 +846,7 @@ def found_terminator(self):
                 self.smtp_state = self.COMMAND
                 self.push('%s %s' % (e.smtp_code, e.smtp_error))
             return
+        self.all_received_lines.append(self.received_lines)
         super().found_terminator()
 
 
@@ -924,11 +927,14 @@ def _auth_cram_md5(self, arg=None):
             except ValueError as e:
                 self.push('535 Splitting response {!r} into user and password '
                           'failed: {}'.format(logpass, e))
-                return False
-            valid_hashed_pass = hmac.HMAC(
-                sim_auth[1].encode('ascii'),
-                self._decode_base64(sim_cram_md5_challenge).encode('ascii'),
-                'md5').hexdigest()
+                return
+            pwd = sim_auth[1].encode('ascii')
+            msg = self._decode_base64(sim_cram_md5_challenge).encode('ascii')
+            try:
+                valid_hashed_pass = hmac.HMAC(pwd, msg, 'md5').hexdigest()
+            except ValueError:
+                self.push('504 CRAM-MD5 is not supported')
+                return
             self._authenticated(user, hashed_pass == valid_hashed_pass)
     # end AUTH related stuff.
 
@@ -1170,8 +1176,7 @@ def auth_buggy(challenge=None):
         finally:
             smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @hashlib_helper.requires_hashdigest('md5', openssl=True)
     def testAUTH_CRAM_MD5(self):
         self.serv.add_feature("AUTH CRAM-MD5")
@@ -1181,8 +1186,39 @@ def testAUTH_CRAM_MD5(self):
         self.assertEqual(resp, (235, b'Authentication Succeeded'))
         smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @mock.patch("hmac.HMAC")
+    @mock.patch("smtplib._have_cram_md5_support", False)
+    def testAUTH_CRAM_MD5_blocked(self, hmac_constructor):
+        # CRAM-MD5 is the only "known" method by the server,
+        # but it is not supported by the client. In particular,
+        # no challenge will ever be sent.
+        self.serv.add_feature("AUTH CRAM-MD5")
+        smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost',
+                            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+        msg = re.escape("No suitable authentication method found.")
+        with self.assertRaisesRegex(smtplib.SMTPException, msg):
+            smtp.login(sim_auth[0], sim_auth[1])
+        hmac_constructor.assert_not_called()  # call has been bypassed
+
+    @mock.patch("smtplib._have_cram_md5_support", False)
+    def testAUTH_CRAM_MD5_blocked_and_fallback(self):
+        # Test that PLAIN is tried after CRAM-MD5 failed
+        self.serv.add_feature("AUTH CRAM-MD5 PLAIN")
+        smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost',
+                            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+        with (
+            mock.patch.object(smtp, "auth_cram_md5") as smtp_auth_cram_md5,
+            mock.patch.object(
+                smtp, "auth_plain", wraps=smtp.auth_plain
+            ) as smtp_auth_plain
+        ):
+            resp = smtp.login(sim_auth[0], sim_auth[1])
+        smtp_auth_plain.assert_called_once()
+        smtp_auth_cram_md5.assert_not_called()  # no call to HMAC constructor
+        self.assertEqual(resp, (235, b'Authentication Succeeded'))
+
     @hashlib_helper.requires_hashdigest('md5', openssl=True)
     def testAUTH_multiple(self):
         # Test that multiple authentication methods are tried.
@@ -1193,8 +1229,7 @@ def testAUTH_multiple(self):
         self.assertEqual(resp, (235, b'Authentication Succeeded'))
         smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_auth_function(self):
         supported = {'PLAIN', 'LOGIN'}
         try:
@@ -1354,6 +1389,18 @@ def test_name_field_not_included_in_envelop_addresses(self):
         self.assertEqual(self.serv._addresses['from'], 'michael@example.com')
         self.assertEqual(self.serv._addresses['tos'], ['rene@example.com'])
 
+    def test_lowercase_mail_from_rcpt_to(self):
+        m = 'A test message'
+        smtp = smtplib.SMTP(
+            HOST, self.port, local_hostname='localhost',
+            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+
+        smtp.sendmail('John', 'Sally', m)
+
+        self.assertIn(['mail from:<John> size=14'], self.serv._SMTPchannel.all_received_lines)
+        self.assertIn(['rcpt to:<Sally>'], self.serv._SMTPchannel.all_received_lines)
+
 
 class SimSMTPUTF8Server(SimSMTPServer):
 
@@ -1372,7 +1419,7 @@ def handle_accepted(self, conn, addr):
         )
 
     def process_message(self, peer, mailfrom, rcpttos, data, mail_options=None,
-                        rcpt_options=None):
+                                                             rcpt_options=None):
         self.last_peer = peer
         self.last_mailfrom = mailfrom
         self.last_rcpttos = rcpttos
diff --git a/Lib/test/test_smtpnet.py b/Lib/test/test_smtpnet.py
index be25e961f74..d765746987b 100644
--- a/Lib/test/test_smtpnet.py
+++ b/Lib/test/test_smtpnet.py
@@ -2,6 +2,7 @@
 from test import support
 from test.support import import_helper
 from test.support import socket_helper
+import os
 import smtplib
 import socket
 
@@ -9,6 +10,8 @@
 
 support.requires("network")
 
+SMTP_TEST_SERVER = os.getenv('CPYTHON_TEST_SMTP_SERVER', 'smtp.gmail.com')
+
 def check_ssl_verifiy(host, port):
     context = ssl.create_default_context()
     with socket.create_connection((host, port)) as sock:
@@ -22,7 +25,7 @@ def check_ssl_verifiy(host, port):
 
 
 class SmtpTest(unittest.TestCase):
-    testServer = 'smtp.gmail.com'
+    testServer = SMTP_TEST_SERVER
     remotePort = 587
 
     def test_connect_starttls(self):
@@ -44,7 +47,7 @@ def test_connect_starttls(self):
 
 
 class SmtpSSLTest(unittest.TestCase):
-    testServer = 'smtp.gmail.com'
+    testServer = SMTP_TEST_SERVER
     remotePort = 465
 
     def test_connect(self):
@@ -87,4 +90,4 @@ def test_connect_using_sslcontext_verified(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()

From ab1105a61debb068b104ebc03e7d37b8e7b1edad Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 20 Dec 2025 09:55:28 +0900
Subject: [PATCH 014/418] Fix fix_test.py (#6415)

---
 scripts/fix_test.py | 165 ++++++++++++++++++++++++++------------------
 1 file changed, 96 insertions(+), 69 deletions(-)

diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index a5663e3eee3..9716bd0b008 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -5,16 +5,20 @@
 
 How to use:
 1. Copy a specific test from the CPython repository to the RustPython repository.
-2. Remove all unexpected failures from the test and skip the tests that hang
-3. Run python ./scripts/fix_test.py --test test_venv --path ./Lib/test/test_venv.py or equivalent for the test from the project root.
-4. Ensure that there are no unexpected successes in the test.
-5. Actually fix the test.
+2. Remove all unexpected failures from the test and skip the tests that hang.
+3. Build RustPython: cargo build --release
+4. Run from the project root:
+   - For single-file tests: python ./scripts/fix_test.py --path ./Lib/test/test_venv.py
+   - For package tests: python ./scripts/fix_test.py --path ./Lib/test/test_inspect/test_inspect.py
+5. Verify: cargo run --release -- -m test test_venv (should pass with expected failures)
+6. Actually fix the tests marked with # TODO: RUSTPYTHON
 """
 
 import argparse
 import ast
 import itertools
 import platform
+import sys
 from pathlib import Path
 
 
@@ -58,85 +62,87 @@ def parse_results(result):
             in_test_results = True
         elif line.startswith("-----------"):
             in_test_results = False
-        if (
-            in_test_results
-            and not line.startswith("tests")
-            and not line.startswith("[")
-        ):
-            line = line.split(" ")
-            if line != [] and len(line) > 3:
-                test = Test()
-                test.name = line[0]
-                test.path = line[1].strip("(").strip(")")
-                test.result = " ".join(line[3:]).lower()
-                test_results.tests.append(test)
-        else:
-            if "== Tests result: " in line:
-                res = line.split("== Tests result: ")[1]
-                res = res.split(" ")[0]
-                test_results.tests_result = res
+        if in_test_results and " ... " in line:
+            line = line.strip()
+            # Skip lines that don't look like test results
+            if line.startswith("tests") or line.startswith("["):
+                continue
+            # Parse: "test_name (path) [subtest] ... RESULT"
+            parts = line.split(" ... ")
+            if len(parts) >= 2:
+                test_info = parts[0]
+                result_str = parts[-1].lower()
+                # Only process FAIL or ERROR
+                if result_str not in ("fail", "error"):
+                    continue
+                # Extract test name (first word)
+                first_space = test_info.find(" ")
+                if first_space > 0:
+                    test = Test()
+                    test.name = test_info[:first_space]
+                    # Extract path from (path)
+                    rest = test_info[first_space:].strip()
+                    if rest.startswith("("):
+                        end_paren = rest.find(")")
+                        if end_paren > 0:
+                            test.path = rest[1:end_paren]
+                            test.result = result_str
+                            test_results.tests.append(test)
+        elif "== Tests result: " in line:
+            res = line.split("== Tests result: ")[1]
+            res = res.split(" ")[0]
+            test_results.tests_result = res
     return test_results
 
 
 def path_to_test(path) -> list[str]:
-    return path.split(".")[2:]
+    # path format: test.module_name[.submodule].ClassName.test_method
+    # We need [ClassName, test_method] - always the last 2 elements
+    parts = path.split(".")
+    return parts[-2:]  # Get class name and method name
 
 
-def modify_test(file: str, test: list[str], for_platform: bool = False) -> str:
+def find_test_lineno(file: str, test: list[str]) -> tuple[int, int] | None:
+    """Find the line number and column offset of a test function.
+    Returns (lineno, col_offset) or None if not found.
+    """
     a = ast.parse(file)
-    lines = file.splitlines()
-    fixture = "@unittest.expectedFailure"
-    for node in ast.walk(a):
-        if isinstance(node, ast.FunctionDef):
-            if node.name == test[-1]:
-                assert not for_platform
-                indent = " " * node.col_offset
-                lines.insert(node.lineno - 1, indent + fixture)
-                lines.insert(node.lineno - 1, indent + "# TODO: RUSTPYTHON")
-                break
-    return "\n".join(lines)
-
-
-def modify_test_v2(file: str, test: list[str], for_platform: bool = False) -> str:
-    a = ast.parse(file)
-    lines = file.splitlines()
-    fixture = "@unittest.expectedFailure"
     for key, node in ast.iter_fields(a):
         if key == "body":
-            for i, n in enumerate(node):
+            for n in node:
                 match n:
                     case ast.ClassDef():
                         if len(test) == 2 and test[0] == n.name:
-                            # look through body for function def
-                            for i, fn in enumerate(n.body):
+                            for fn in n.body:
                                 match fn:
-                                    case ast.FunctionDef():
+                                    case ast.FunctionDef() | ast.AsyncFunctionDef():
                                         if fn.name == test[-1]:
-                                            assert not for_platform
-                                            indent = " " * fn.col_offset
-                                            lines.insert(
-                                                fn.lineno - 1, indent + fixture
-                                            )
-                                            lines.insert(
-                                                fn.lineno - 1,
-                                                indent + "# TODO: RUSTPYTHON",
-                                            )
-                                            break
-                    case ast.FunctionDef():
+                                            return (fn.lineno, fn.col_offset)
+                    case ast.FunctionDef() | ast.AsyncFunctionDef():
                         if n.name == test[0] and len(test) == 1:
-                            assert not for_platform
-                            indent = " " * n.col_offset
-                            lines.insert(n.lineno - 1, indent + fixture)
-                            lines.insert(n.lineno - 1, indent + "# TODO: RUSTPYTHON")
-                            break
-                if i > 500:
-                    exit()
+                            return (n.lineno, n.col_offset)
+    return None
+
+
+def apply_modifications(file: str, modifications: list[tuple[int, int]]) -> str:
+    """Apply all modifications in reverse order to avoid line number offset issues."""
+    lines = file.splitlines()
+    fixture = "@unittest.expectedFailure"
+    # Sort by line number in descending order
+    modifications.sort(key=lambda x: x[0], reverse=True)
+    for lineno, col_offset in modifications:
+        indent = " " * col_offset
+        lines.insert(lineno - 1, indent + fixture)
+        lines.insert(lineno - 1, indent + "# TODO: RUSTPYTHON")
     return "\n".join(lines)
 
 
 def run_test(test_name):
     print(f"Running test: {test_name}")
     rustpython_location = "./target/release/rustpython"
+    if sys.platform == "win32":
+        rustpython_location += ".exe"
+
     import subprocess
 
     result = subprocess.run(
@@ -149,13 +155,34 @@ def run_test(test_name):
 
 if __name__ == "__main__":
     args = parse_args()
-    test_name = args.path.stem
+    test_path = args.path.resolve()
+    if not test_path.exists():
+        print(f"Error: File not found: {test_path}")
+        sys.exit(1)
+    test_name = test_path.stem
     tests = run_test(test_name)
-    f = open(args.path).read()
+    f = test_path.read_text(encoding="utf-8")
+
+    # Collect all modifications first (with deduplication for subtests)
+    modifications = []
+    seen_tests = set()  # Track (class_name, method_name) to avoid duplicates
     for test in tests.tests:
         if test.result == "fail" or test.result == "error":
-            print("Modifying test:", test.name)
-            f = modify_test_v2(f, path_to_test(test.path), args.platform)
-    with open(args.path, "w") as file:
-        # TODO: Find validation method, and make --force override it
-        file.write(f)
+            test_parts = path_to_test(test.path)
+            test_key = tuple(test_parts)
+            if test_key in seen_tests:
+                continue  # Skip duplicate (same test, different subtest)
+            seen_tests.add(test_key)
+            location = find_test_lineno(f, test_parts)
+            if location:
+                print(f"Modifying test: {test.name} at line {location[0]}")
+                modifications.append(location)
+            else:
+                print(f"Warning: Could not find test: {test.name} ({test_parts})")
+
+    # Apply all modifications in reverse order
+    if modifications:
+        f = apply_modifications(f, modifications)
+        test_path.write_text(f, encoding="utf-8")
+
+    print(f"Modified {len(modifications)} tests")

From 46c61a65a6773de5583860e90857e619bed4aaf6 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 20 Dec 2025 12:17:11 +0900
Subject: [PATCH 015/418] Upgrade venv to v3.13.11 (#6459)

* Upgrade venv

* get_venv_base_executable

* mark failing tests
---
 Lib/test/test_venv.py                         | 615 ++++++++++++++++--
 Lib/venv/__init__.py                          | 607 +++++++++++------
 Lib/venv/__main__.py                          |   2 +-
 Lib/venv/scripts/common/Activate.ps1          |   3 +-
 Lib/venv/scripts/common/activate              |  43 +-
 .../scripts/{posix => common}/activate.fish   |  19 +-
 Lib/venv/scripts/nt/activate.bat              |  10 +-
 Lib/venv/scripts/posix/activate.csh           |   9 +-
 crates/vm/src/stdlib/sys.rs                   |  65 +-
 9 files changed, 1065 insertions(+), 308 deletions(-)
 rename Lib/venv/scripts/{posix => common}/activate.fish (76%)

diff --git a/Lib/test/test_venv.py b/Lib/test/test_venv.py
index 94d626598ba..19b12070531 100644
--- a/Lib/test/test_venv.py
+++ b/Lib/test/test_venv.py
@@ -5,21 +5,31 @@
 Licensed to the PSF under a contributor agreement.
 """
 
+import contextlib
 import ensurepip
 import os
 import os.path
+import pathlib
 import re
 import shutil
 import struct
 import subprocess
 import sys
+import sysconfig
 import tempfile
-from test.support import (captured_stdout, captured_stderr, requires_zlib,
-                          skip_if_broken_multiprocessing_synchronize)
-from test.support.os_helper import (can_symlink, EnvironmentVarGuard, rmtree)
+import shlex
+from test.support import (captured_stdout, captured_stderr,
+                          skip_if_broken_multiprocessing_synchronize, verbose,
+                          requires_subprocess, is_android, is_apple_mobile,
+                          is_emscripten, is_wasi,
+                          requires_venv_with_pip, TEST_HOME_DIR,
+                          requires_resource, copy_python_src_ignore)
+from test.support.os_helper import (can_symlink, EnvironmentVarGuard, rmtree,
+                                    TESTFN, FakePath)
+from test.support.testcase import ExtraAssertions
 import unittest
 import venv
-from unittest.mock import patch
+from unittest.mock import patch, Mock
 
 try:
     import ctypes
@@ -33,18 +43,29 @@
     or sys._base_executable != sys.executable,
     'cannot run venv.create from within a venv on this platform')
 
+if is_android or is_apple_mobile or is_emscripten or is_wasi:
+    raise unittest.SkipTest("venv is not available on this platform")
+
+@requires_subprocess()
 def check_output(cmd, encoding=None):
     p = subprocess.Popen(cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
-        encoding=encoding)
+        env={**os.environ, "PYTHONHOME": ""})
     out, err = p.communicate()
     if p.returncode:
+        if verbose and err:
+            print(err.decode(encoding or 'utf-8', 'backslashreplace'))
         raise subprocess.CalledProcessError(
             p.returncode, cmd, out, err)
+    if encoding:
+        return (
+            out.decode(encoding, 'backslashreplace'),
+            err.decode(encoding, 'backslashreplace'),
+        )
     return out, err
 
-class BaseTest(unittest.TestCase):
+class BaseTest(unittest.TestCase, ExtraAssertions):
     """Base class for venv tests."""
     maxDiff = 80 * 50
 
@@ -56,7 +77,7 @@ def setUp(self):
             self.include = 'Include'
         else:
             self.bindir = 'bin'
-            self.lib = ('lib', 'python%d.%d' % sys.version_info[:2])
+            self.lib = ('lib', f'python{sysconfig._get_python_version_abi()}')
             self.include = 'include'
         executable = sys._base_executable
         self.exe = os.path.split(executable)[-1]
@@ -70,6 +91,13 @@ def setUp(self):
     def tearDown(self):
         rmtree(self.env_dir)
 
+    def envpy(self, *, real_env_dir=False):
+        if real_env_dir:
+            env_dir = os.path.realpath(self.env_dir)
+        else:
+            env_dir = self.env_dir
+        return os.path.join(env_dir, self.bindir, self.exe)
+
     def run_with_capture(self, func, *args, **kwargs):
         with captured_stdout() as output:
             with captured_stderr() as error:
@@ -91,12 +119,27 @@ def isdir(self, *args):
         fn = self.get_env_file(*args)
         self.assertTrue(os.path.isdir(fn))
 
-    def test_defaults(self):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_defaults_with_str_path(self):
         """
-        Test the create function with default arguments.
+        Test the create function with default arguments and a str path.
         """
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
+        self._check_output_of_default_create()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_defaults_with_pathlike(self):
+        """
+        Test the create function with default arguments and a path-like path.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, FakePath(self.env_dir))
+        self._check_output_of_default_create()
+
+    def _check_output_of_default_create(self):
         self.isdir(self.bindir)
         self.isdir(self.include)
         self.isdir(*self.lib)
@@ -112,6 +155,12 @@ def test_defaults(self):
         executable = sys._base_executable
         path = os.path.dirname(executable)
         self.assertIn('home = %s' % path, data)
+        self.assertIn('executable = %s' %
+                      os.path.realpath(sys.executable), data)
+        copies = '' if os.name=='nt' else ' --copies'
+        cmd = (f'command = {sys.executable} -m venv{copies} --without-pip '
+               f'--without-scm-ignore-files {self.env_dir}')
+        self.assertIn(cmd, data)
         fn = self.get_env_file(self.bindir, self.exe)
         if not os.path.exists(fn):  # diagnostics for Windows buildbot failures
             bd = self.get_env_file(self.bindir)
@@ -119,6 +168,39 @@ def test_defaults(self):
             print('    %r' % os.listdir(bd))
         self.assertTrue(os.path.exists(fn), 'File %r should exist.' % fn)
 
+    def test_config_file_command_key(self):
+        options = [
+            (None, None, None),  # Default case.
+            ('--copies', 'symlinks', False),
+            ('--without-pip', 'with_pip', False),
+            ('--system-site-packages', 'system_site_packages', True),
+            ('--clear', 'clear', True),
+            ('--upgrade', 'upgrade', True),
+            ('--upgrade-deps', 'upgrade_deps', True),
+            ('--prompt="foobar"', 'prompt', 'foobar'),
+            ('--without-scm-ignore-files', 'scm_ignore_files', frozenset()),
+        ]
+        for opt, attr, value in options:
+            with self.subTest(opt=opt, attr=attr, value=value):
+                rmtree(self.env_dir)
+                if not attr:
+                    kwargs = {}
+                else:
+                    kwargs = {attr: value}
+                b = venv.EnvBuilder(**kwargs)
+                b.upgrade_dependencies = Mock() # avoid pip command to upgrade deps
+                b._setup_pip = Mock() # avoid pip setup
+                self.run_with_capture(b.create, self.env_dir)
+                data = self.get_text_file_contents('pyvenv.cfg')
+                if not attr or opt.endswith('git'):
+                    for opt in ('--system-site-packages', '--clear', '--upgrade',
+                                '--upgrade-deps', '--prompt'):
+                        self.assertNotRegex(data, rf'command = .* {opt}')
+                elif os.name=='nt' and attr=='symlinks':
+                    pass
+                else:
+                    self.assertRegex(data, rf'command = .* {opt}')
+
     def test_prompt(self):
         env_name = os.path.split(self.env_dir)[1]
 
@@ -127,7 +209,7 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(%s) ' % env_name)
+        self.assertEqual(context.prompt, env_name)
         self.assertNotIn("prompt = ", data)
 
         rmtree(self.env_dir)
@@ -135,7 +217,7 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(My prompt) ')
+        self.assertEqual(context.prompt, 'My prompt')
         self.assertIn("prompt = 'My prompt'\n", data)
 
         rmtree(self.env_dir)
@@ -144,13 +226,19 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(%s) ' % cwd)
+        self.assertEqual(context.prompt, cwd)
         self.assertIn("prompt = '%s'\n" % cwd, data)
 
     def test_upgrade_dependencies(self):
         builder = venv.EnvBuilder()
-        bin_path = 'Scripts' if sys.platform == 'win32' else 'bin'
+        bin_path = 'bin'
         python_exe = os.path.split(sys.executable)[1]
+        if sys.platform == 'win32':
+            bin_path = 'Scripts'
+            if os.path.normcase(os.path.splitext(python_exe)[0]).endswith('_d'):
+                python_exe = 'python_d.exe'
+            else:
+                python_exe = 'python.exe'
         with tempfile.TemporaryDirectory() as fake_env_dir:
             expect_exe = os.path.normcase(
                 os.path.join(fake_env_dir, bin_path, python_exe)
@@ -158,7 +246,7 @@ def test_upgrade_dependencies(self):
             if sys.platform == 'win32':
                 expect_exe = os.path.normcase(os.path.realpath(expect_exe))
 
-            def pip_cmd_checker(cmd):
+            def pip_cmd_checker(cmd, **kwargs):
                 cmd[0] = os.path.normcase(cmd[0])
                 self.assertEqual(
                     cmd,
@@ -169,12 +257,11 @@ def pip_cmd_checker(cmd):
                         'install',
                         '--upgrade',
                         'pip',
-                        'setuptools'
                     ]
                 )
 
             fake_context = builder.ensure_directories(fake_env_dir)
-            with patch('venv.subprocess.check_call', pip_cmd_checker):
+            with patch('venv.subprocess.check_output', pip_cmd_checker):
                 builder.upgrade_dependencies(fake_context)
 
     @requireVenvCreate
@@ -185,8 +272,7 @@ def test_prefixes(self):
         # check a venv's prefixes
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(self.env_dir, self.bindir, self.exe)
-        cmd = [envpy, '-c', None]
+        cmd = [self.envpy(), '-c', None]
         for prefix, expected in (
             ('prefix', self.env_dir),
             ('exec_prefix', self.env_dir),
@@ -194,7 +280,76 @@ def test_prefixes(self):
             ('base_exec_prefix', sys.base_exec_prefix)):
             cmd[2] = 'import sys; print(sys.%s)' % prefix
             out, err = check_output(cmd)
-            self.assertEqual(out.strip(), expected.encode())
+            self.assertEqual(pathlib.Path(out.strip().decode()),
+                             pathlib.Path(expected), prefix)
+
+    @requireVenvCreate
+    def test_sysconfig(self):
+        """
+        Test that the sysconfig functions work in a virtual environment.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir, symlinks=False)
+        cmd = [self.envpy(), '-c', None]
+        for call, expected in (
+            # installation scheme
+            ('get_preferred_scheme("prefix")', 'venv'),
+            ('get_default_scheme()', 'venv'),
+            # build environment
+            ('is_python_build()', str(sysconfig.is_python_build())),
+            ('get_makefile_filename()', sysconfig.get_makefile_filename()),
+            ('get_config_h_filename()', sysconfig.get_config_h_filename()),
+            ('get_config_var("Py_GIL_DISABLED")',
+             str(sysconfig.get_config_var("Py_GIL_DISABLED")))):
+            with self.subTest(call):
+                cmd[2] = 'import sysconfig; print(sysconfig.%s)' % call
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+        for attr, expected in (
+            ('executable', self.envpy()),
+            # Usually compare to sys.executable, but if we're running in our own
+            # venv then we really need to compare to our base executable
+            ('_base_executable', sys._base_executable),
+        ):
+            with self.subTest(attr):
+                cmd[2] = f'import sys; print(sys.{attr})'
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+
+    @requireVenvCreate
+    @unittest.skipUnless(can_symlink(), 'Needs symlinks')
+    def test_sysconfig_symlinks(self):
+        """
+        Test that the sysconfig functions work in a virtual environment.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir, symlinks=True)
+        cmd = [self.envpy(), '-c', None]
+        for call, expected in (
+            # installation scheme
+            ('get_preferred_scheme("prefix")', 'venv'),
+            ('get_default_scheme()', 'venv'),
+            # build environment
+            ('is_python_build()', str(sysconfig.is_python_build())),
+            ('get_makefile_filename()', sysconfig.get_makefile_filename()),
+            ('get_config_h_filename()', sysconfig.get_config_h_filename()),
+            ('get_config_var("Py_GIL_DISABLED")',
+             str(sysconfig.get_config_var("Py_GIL_DISABLED")))):
+            with self.subTest(call):
+                cmd[2] = 'import sysconfig; print(sysconfig.%s)' % call
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+        for attr, expected in (
+            ('executable', self.envpy()),
+            # Usually compare to sys.executable, but if we're running in our own
+            # venv then we really need to compare to our base executable
+            # HACK: Test fails on POSIX with unversioned binary (PR gh-113033)
+            #('_base_executable', sys._base_executable),
+        ):
+            with self.subTest(attr):
+                cmd[2] = f'import sys; print(sys.{attr})'
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
 
     if sys.platform == 'win32':
         ENV_SUBDIRS = (
@@ -259,6 +414,8 @@ def test_unoverwritable_fails(self):
             self.assertRaises((ValueError, OSError), venv.create, self.env_dir)
             self.clear_directory(self.env_dir)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_upgrade(self):
         """
         Test upgrading an existing environment directory.
@@ -321,8 +478,7 @@ def test_executable(self):
         """
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
+        envpy = self.envpy(real_env_dir=True)
         out, err = check_output([envpy, '-c',
             'import sys; print(sys.executable)'])
         self.assertEqual(out.strip(), envpy.encode())
@@ -335,12 +491,89 @@ def test_executable_symlinks(self):
         rmtree(self.env_dir)
         builder = venv.EnvBuilder(clear=True, symlinks=True)
         builder.create(self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
+        envpy = self.envpy(real_env_dir=True)
         out, err = check_output([envpy, '-c',
             'import sys; print(sys.executable)'])
         self.assertEqual(out.strip(), envpy.encode())
 
+    # gh-124651: test quoted strings
+    @unittest.skipIf(os.name == 'nt', 'contains invalid characters on Windows')
+    def test_special_chars_bash(self):
+        """
+        Test that the template strings are quoted properly (bash)
+        """
+        rmtree(self.env_dir)
+        bash = shutil.which('bash')
+        if bash is None:
+            self.skipTest('bash required for this test')
+        env_name = '"\';&&$e|\'"'
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate')
+        test_script = os.path.join(self.env_dir, 'test_special_chars.sh')
+        with open(test_script, "w") as f:
+            f.write(f'source {shlex.quote(activate)}\n'
+                    'python -c \'import sys; print(sys.executable)\'\n'
+                    'python -c \'import os; print(os.environ["VIRTUAL_ENV"])\'\n'
+                    'deactivate\n')
+        out, err = check_output([bash, test_script])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
+    # gh-124651: test quoted strings
+    @unittest.skipIf(os.name == 'nt', 'contains invalid characters on Windows')
+    @unittest.skipIf(sys.platform.startswith('netbsd'),
+                     "NetBSD csh fails with quoted special chars; see gh-139308")
+    def test_special_chars_csh(self):
+        """
+        Test that the template strings are quoted properly (csh)
+        """
+        rmtree(self.env_dir)
+        csh = shutil.which('tcsh') or shutil.which('csh')
+        if csh is None:
+            self.skipTest('csh required for this test')
+        env_name = '"\';&&$e|\'"'
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate.csh')
+        test_script = os.path.join(self.env_dir, 'test_special_chars.csh')
+        with open(test_script, "w") as f:
+            f.write(f'source {shlex.quote(activate)}\n'
+                    'python -c \'import sys; print(sys.executable)\'\n'
+                    'python -c \'import os; print(os.environ["VIRTUAL_ENV"])\'\n'
+                    'deactivate\n')
+        out, err = check_output([csh, test_script])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
+    # gh-124651: test quoted strings on Windows
+    @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
+    def test_special_chars_windows(self):
+        """
+        Test that the template strings are quoted properly on Windows
+        """
+        rmtree(self.env_dir)
+        env_name = "'&&^$e"
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate.bat')
+        test_batch = os.path.join(self.env_dir, 'test_special_chars.bat')
+        with open(test_batch, "w") as f:
+            f.write('@echo off\n'
+                    f'"{activate}" & '
+                    f'{self.exe} -c "import sys; print(sys.executable)" & '
+                    f'{self.exe} -c "import os; print(os.environ[\'VIRTUAL_ENV\'])" & '
+                    'deactivate')
+        out, err = check_output([test_batch])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
     @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
     def test_unicode_in_batch_file(self):
         """
@@ -351,13 +584,27 @@ def test_unicode_in_batch_file(self):
         builder = venv.EnvBuilder(clear=True)
         builder.create(env_dir)
         activate = os.path.join(env_dir, self.bindir, 'activate.bat')
-        envpy = os.path.join(env_dir, self.bindir, self.exe)
         out, err = check_output(
             [activate, '&', self.exe, '-c', 'print(0)'],
             encoding='oem',
         )
         self.assertEqual(out.strip(), '0')
 
+    @unittest.skipUnless(os.name == 'nt' and can_symlink(),
+                         'symlinks on Windows')
+    def test_failed_symlink(self):
+        """
+        Test handling of failed symlinks on Windows.
+        """
+        rmtree(self.env_dir)
+        env_dir = os.path.join(os.path.realpath(self.env_dir), 'venv')
+        with patch('os.symlink') as mock_symlink:
+            mock_symlink.side_effect = OSError()
+            builder = venv.EnvBuilder(clear=True, symlinks=True)
+            _, err = self.run_with_capture(builder.create, env_dir)
+            filepath_regex = r"'[A-Z]:\\\\(?:[^\\\\]+\\\\)*[^\\\\]+'"
+            self.assertRegex(err, rf"Unable to symlink {filepath_regex} to {filepath_regex}")
+
     @requireVenvCreate
     def test_multiprocessing(self):
         """
@@ -370,15 +617,25 @@ def test_multiprocessing(self):
 
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'from multiprocessing import Pool; '
             'pool = Pool(1); '
             'print(pool.apply_async("Python".lower).get(3)); '
             'pool.terminate()'])
         self.assertEqual(out.strip(), "python".encode())
 
+    @requireVenvCreate
+    def test_multiprocessing_recursion(self):
+        """
+        Test that the multiprocessing is able to spawn itself
+        """
+        skip_if_broken_multiprocessing_synchronize()
+
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir)
+        script = os.path.join(TEST_HOME_DIR, '_test_venv_multiprocessing.py')
+        subprocess.check_call([self.envpy(real_env_dir=True), "-I", script])
+
     @unittest.skipIf(os.name == 'nt', 'not relevant on Windows')
     def test_deactivate_with_strict_bash_opts(self):
         bash = shutil.which("bash")
@@ -404,19 +661,250 @@ def test_macos_env(self):
         builder = venv.EnvBuilder()
         builder.create(self.env_dir)
 
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'import os; print("__PYVENV_LAUNCHER__" in os.environ)'])
         self.assertEqual(out.strip(), 'False'.encode())
 
+    def test_pathsep_error(self):
+        """
+        Test that venv creation fails when the target directory contains
+        the path separator.
+        """
+        rmtree(self.env_dir)
+        bad_itempath = self.env_dir + os.pathsep
+        self.assertRaises(ValueError, venv.create, bad_itempath)
+        self.assertRaises(ValueError, venv.create, FakePath(bad_itempath))
+
+    @unittest.skipIf(os.name == 'nt', 'not relevant on Windows')
+    @requireVenvCreate
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_zippath_from_non_installed_posix(self):
+        """
+        Test that when create venv from non-installed python, the zip path
+        value is as expected.
+        """
+        rmtree(self.env_dir)
+        # First try to create a non-installed python. It's not a real full
+        # functional non-installed python, but enough for this test.
+        platlibdir = sys.platlibdir
+        non_installed_dir = os.path.realpath(tempfile.mkdtemp())
+        self.addCleanup(rmtree, non_installed_dir)
+        bindir = os.path.join(non_installed_dir, self.bindir)
+        os.mkdir(bindir)
+        shutil.copy2(sys.executable, bindir)
+        libdir = os.path.join(non_installed_dir, platlibdir, self.lib[1])
+        os.makedirs(libdir)
+        landmark = os.path.join(libdir, "os.py")
+        abi_thread = "t" if sysconfig.get_config_var("Py_GIL_DISABLED") else ""
+        stdlib_zip = f"python{sys.version_info.major}{sys.version_info.minor}{abi_thread}"
+        zip_landmark = os.path.join(non_installed_dir,
+                                    platlibdir,
+                                    stdlib_zip)
+        additional_pythonpath_for_non_installed = []
+
+        # Copy stdlib files to the non-installed python so venv can
+        # correctly calculate the prefix.
+        for eachpath in sys.path:
+            if eachpath.endswith(".zip"):
+                if os.path.isfile(eachpath):
+                    shutil.copyfile(
+                        eachpath,
+                        os.path.join(non_installed_dir, platlibdir))
+            elif os.path.isfile(os.path.join(eachpath, "os.py")):
+                names = os.listdir(eachpath)
+                ignored_names = copy_python_src_ignore(eachpath, names)
+                for name in names:
+                    if name in ignored_names:
+                        continue
+                    if name == "site-packages":
+                        continue
+                    fn = os.path.join(eachpath, name)
+                    if os.path.isfile(fn):
+                        shutil.copy(fn, libdir)
+                    elif os.path.isdir(fn):
+                        shutil.copytree(fn, os.path.join(libdir, name),
+                                        ignore=copy_python_src_ignore)
+            else:
+                additional_pythonpath_for_non_installed.append(
+                    eachpath)
+        cmd = [os.path.join(non_installed_dir, self.bindir, self.exe),
+               "-m",
+               "venv",
+               "--without-pip",
+               "--without-scm-ignore-files",
+               self.env_dir]
+        # Our fake non-installed python is not fully functional because
+        # it cannot find the extensions. Set PYTHONPATH so it can run the
+        # venv module correctly.
+        pythonpath = os.pathsep.join(
+            additional_pythonpath_for_non_installed)
+        # For python built with shared enabled. We need to set
+        # LD_LIBRARY_PATH so the non-installed python can find and link
+        # libpython.so
+        ld_library_path = sysconfig.get_config_var("LIBDIR")
+        if not ld_library_path or sysconfig.is_python_build():
+            ld_library_path = os.path.abspath(os.path.dirname(sys.executable))
+        if sys.platform == 'darwin':
+            ld_library_path_env = "DYLD_LIBRARY_PATH"
+        else:
+            ld_library_path_env = "LD_LIBRARY_PATH"
+        child_env = {
+                "PYTHONPATH": pythonpath,
+                ld_library_path_env: ld_library_path,
+        }
+        if asan_options := os.environ.get("ASAN_OPTIONS"):
+            # prevent https://github.com/python/cpython/issues/104839
+            child_env["ASAN_OPTIONS"] = asan_options
+        subprocess.check_call(cmd, env=child_env)
+        # Now check the venv created from the non-installed python has
+        # correct zip path in pythonpath.
+        cmd = [self.envpy(), '-S', '-c', 'import sys; print(sys.path)']
+        out, err = check_output(cmd)
+        self.assertTrue(zip_landmark.encode() in out)
+
+    @requireVenvCreate
+    def test_activate_shell_script_has_no_dos_newlines(self):
+        """
+        Test that the `activate` shell script contains no CR LF.
+        This is relevant for Cygwin, as the Windows build might have
+        converted line endings accidentally.
+        """
+        venv_dir = pathlib.Path(self.env_dir)
+        rmtree(venv_dir)
+        [[scripts_dir], *_] = self.ENV_SUBDIRS
+        script_path = venv_dir / scripts_dir / "activate"
+        venv.create(venv_dir)
+        with open(script_path, 'rb') as script:
+            for i, line in enumerate(script, 1):
+                error_message = f"CR LF found in line {i}"
+                self.assertFalse(line.endswith(b'\r\n'), error_message)
+
+    @requireVenvCreate
+    def test_scm_ignore_files_git(self):
+        """
+        Test that a .gitignore file is created when "git" is specified.
+        The file should contain a `*\n` line.
+        """
+        self.run_with_capture(venv.create, self.env_dir,
+                              scm_ignore_files={'git'})
+        file_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', file_lines)
+
+    @requireVenvCreate
+    def test_create_scm_ignore_files_multiple(self):
+        """
+        Test that ``scm_ignore_files`` can work with multiple SCMs.
+        """
+        bzrignore_name = ".bzrignore"
+        contents = "# For Bazaar.\n*\n"
+
+        class BzrEnvBuilder(venv.EnvBuilder):
+            def create_bzr_ignore_file(self, context):
+                gitignore_path = os.path.join(context.env_dir, bzrignore_name)
+                with open(gitignore_path, 'w', encoding='utf-8') as file:
+                    file.write(contents)
+
+        builder = BzrEnvBuilder(scm_ignore_files={'git', 'bzr'})
+        self.run_with_capture(builder.create, self.env_dir)
+
+        gitignore_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', gitignore_lines)
+
+        bzrignore = self.get_text_file_contents(bzrignore_name)
+        self.assertEqual(bzrignore, contents)
+
+    @requireVenvCreate
+    def test_create_scm_ignore_files_empty(self):
+        """
+        Test that no default ignore files are created when ``scm_ignore_files``
+        is empty.
+        """
+        # scm_ignore_files is set to frozenset() by default.
+        self.run_with_capture(venv.create, self.env_dir)
+        with self.assertRaises(FileNotFoundError):
+            self.get_text_file_contents('.gitignore')
+
+        self.assertIn("--without-scm-ignore-files",
+                      self.get_text_file_contents('pyvenv.cfg'))
+
+    @requireVenvCreate
+    def test_cli_with_scm_ignore_files(self):
+        """
+        Test that default SCM ignore files are created by default via the CLI.
+        """
+        self.run_with_capture(venv.main, ['--without-pip', self.env_dir])
+
+        gitignore_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', gitignore_lines)
+
+    @requireVenvCreate
+    def test_cli_without_scm_ignore_files(self):
+        """
+        Test that ``--without-scm-ignore-files`` doesn't create SCM ignore files.
+        """
+        args = ['--without-pip', '--without-scm-ignore-files', self.env_dir]
+        self.run_with_capture(venv.main, args)
+
+        with self.assertRaises(FileNotFoundError):
+            self.get_text_file_contents('.gitignore')
+
+    def test_venv_same_path(self):
+        same_path = venv.EnvBuilder._same_path
+        if sys.platform == 'win32':
+            # Case-insensitive, and handles short/long names
+            tests = [
+                (True, TESTFN, TESTFN),
+                (True, TESTFN.lower(), TESTFN.upper()),
+            ]
+            import _winapi
+            # ProgramFiles is the most reliable path that will have short/long
+            progfiles = os.getenv('ProgramFiles')
+            if progfiles:
+                tests = [
+                    *tests,
+                    (True, progfiles, progfiles),
+                    (True, _winapi.GetShortPathName(progfiles), _winapi.GetLongPathName(progfiles)),
+                ]
+        else:
+            # Just a simple case-sensitive comparison
+            tests = [
+                (True, TESTFN, TESTFN),
+                (False, TESTFN.lower(), TESTFN.upper()),
+            ]
+        for r, path1, path2 in tests:
+            with self.subTest(f"{path1}-{path2}"):
+                if r:
+                    self.assertTrue(same_path(path1, path2))
+                else:
+                    self.assertFalse(same_path(path1, path2))
+
+    # gh-126084: venvwlauncher should run pythonw, not python
+    @requireVenvCreate
+    @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
+    def test_venvwlauncher(self):
+        """
+        Test that the GUI launcher runs the GUI python.
+        """
+        rmtree(self.env_dir)
+        venv.create(self.env_dir)
+        exename = self.exe
+        # Retain the debug suffix if present
+        if "python" in exename and not "pythonw" in exename:
+            exename = exename.replace("python", "pythonw")
+        envpyw = os.path.join(self.env_dir, self.bindir, exename)
+        try:
+            subprocess.check_call([envpyw, "-c", "import sys; "
+                "assert sys._base_executable.endswith('%s')" % exename])
+        except subprocess.CalledProcessError:
+            self.fail("venvwlauncher.exe did not run %s" % exename)
+
+
 @requireVenvCreate
 class EnsurePipTest(BaseTest):
     """Test venv module installation of pip."""
     def assert_pip_not_installed(self):
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'try:\n import pip\nexcept ImportError:\n print("OK")'])
         # We force everything to text, so unittest gives the detailed diff
         # if we get unexpected results
@@ -478,20 +966,14 @@ def do_test_with_pip(self, system_site_packages):
 
                 # Actually run the create command with all that unhelpful
                 # config in place to ensure we ignore it
-                try:
+                with self.nicer_error():
                     self.run_with_capture(venv.create, self.env_dir,
                                           system_site_packages=system_site_packages,
                                           with_pip=True)
-                except subprocess.CalledProcessError as exc:
-                    # The output this produces can be a little hard to read,
-                    # but at least it has all the details
-                    details = exc.output.decode(errors="replace")
-                    msg = "{}\n\n**Subprocess Output**\n{}"
-                    self.fail(msg.format(exc, details))
         # Ensure pip is available in the virtual environment
-        envpy = os.path.join(os.path.realpath(self.env_dir), self.bindir, self.exe)
         # Ignore DeprecationWarning since pip code is not part of Python
-        out, err = check_output([envpy, '-W', 'ignore::DeprecationWarning',
+        out, err = check_output([self.envpy(real_env_dir=True),
+               '-W', 'ignore::DeprecationWarning',
                '-W', 'ignore::ImportWarning', '-I',
                '-m', 'pip', '--version'])
         # We force everything to text, so unittest gives the detailed diff
@@ -508,13 +990,14 @@ def do_test_with_pip(self, system_site_packages):
         # Check the private uninstall command provided for the Windows
         # installers works (at least in a virtual environment)
         with EnvironmentVarGuard() as envvars:
-            # It seems ensurepip._uninstall calls subprocesses which do not
-            # inherit the interpreter settings.
-            envvars["PYTHONWARNINGS"] = "ignore"
-            out, err = check_output([envpy,
-                '-W', 'ignore::DeprecationWarning',
-                '-W', 'ignore::ImportWarning', '-I',
-                '-m', 'ensurepip._uninstall'])
+            with self.nicer_error():
+                # It seems ensurepip._uninstall calls subprocesses which do not
+                # inherit the interpreter settings.
+                envvars["PYTHONWARNINGS"] = "ignore"
+                out, err = check_output([self.envpy(real_env_dir=True),
+                    '-W', 'ignore::DeprecationWarning',
+                    '-W', 'ignore::ImportWarning', '-I',
+                    '-m', 'ensurepip._uninstall'])
         # We force everything to text, so unittest gives the detailed diff
         # if we get unexpected results
         err = err.decode("latin-1") # Force to text, prevent decoding errors
@@ -527,25 +1010,51 @@ def do_test_with_pip(self, system_site_packages):
         err = re.sub("^(WARNING: )?The directory .* or its parent directory "
                      "is not owned or is not writable by the current user.*$", "",
                      err, flags=re.MULTILINE)
+        # Ignore warning about missing optional module:
+        try:
+            import ssl
+        except ImportError:
+            err = re.sub(
+                "^WARNING: Disabling truststore since ssl support is missing$",
+                "",
+                err, flags=re.MULTILINE)
         self.assertEqual(err.rstrip(), "")
         # Being fairly specific regarding the expected behaviour for the
         # initial bundling phase in Python 3.4. If the output changes in
         # future pip versions, this test can likely be relaxed further.
         out = out.decode("latin-1") # Force to text, prevent decoding errors
         self.assertIn("Successfully uninstalled pip", out)
-        self.assertIn("Successfully uninstalled setuptools", out)
         # Check pip is now gone from the virtual environment. This only
         # applies in the system_site_packages=False case, because in the
         # other case, pip may still be available in the system site-packages
         if not system_site_packages:
             self.assert_pip_not_installed()
 
-    # Issue #26610: pip/pep425tags.py requires ctypes
-    @unittest.skipUnless(ctypes, 'pip requires ctypes')
-    @requires_zlib()
+    @contextlib.contextmanager
+    def nicer_error(self):
+        """
+        Capture output from a failed subprocess for easier debugging.
+
+        The output this handler produces can be a little hard to read,
+        but at least it has all the details.
+        """
+        try:
+            yield
+        except subprocess.CalledProcessError as exc:
+            out = (exc.output or b'').decode(errors="replace")
+            err = (exc.stderr or b'').decode(errors="replace")
+            self.fail(
+                f"{exc}\n\n"
+                f"**Subprocess Output**\n{out}\n\n"
+                f"**Subprocess Error**\n{err}"
+            )
+
+    @requires_venv_with_pip()
+    @requires_resource('cpu')
     def test_with_pip(self):
         self.do_test_with_pip(False)
         self.do_test_with_pip(True)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/venv/__init__.py b/Lib/venv/__init__.py
index 6f1af294ae6..f7a6d261401 100644
--- a/Lib/venv/__init__.py
+++ b/Lib/venv/__init__.py
@@ -11,9 +11,10 @@
 import sys
 import sysconfig
 import types
+import shlex
 
 
-CORE_VENV_DEPS = ('pip', 'setuptools')
+CORE_VENV_DEPS = ('pip',)
 logger = logging.getLogger(__name__)
 
 
@@ -41,20 +42,24 @@ class EnvBuilder:
                      environment
     :param prompt: Alternative terminal prefix for the environment.
     :param upgrade_deps: Update the base venv modules to the latest on PyPI
+    :param scm_ignore_files: Create ignore files for the SCMs specified by the
+                             iterable.
     """
 
     def __init__(self, system_site_packages=False, clear=False,
                  symlinks=False, upgrade=False, with_pip=False, prompt=None,
-                 upgrade_deps=False):
+                 upgrade_deps=False, *, scm_ignore_files=frozenset()):
         self.system_site_packages = system_site_packages
         self.clear = clear
         self.symlinks = symlinks
         self.upgrade = upgrade
         self.with_pip = with_pip
+        self.orig_prompt = prompt
         if prompt == '.':  # see bpo-38901
             prompt = os.path.basename(os.getcwd())
         self.prompt = prompt
         self.upgrade_deps = upgrade_deps
+        self.scm_ignore_files = frozenset(map(str.lower, scm_ignore_files))
 
     def create(self, env_dir):
         """
@@ -65,6 +70,8 @@ def create(self, env_dir):
         """
         env_dir = os.path.abspath(env_dir)
         context = self.ensure_directories(env_dir)
+        for scm in self.scm_ignore_files:
+            getattr(self, f"create_{scm}_ignore_file")(context)
         # See issue 24875. We need system_site_packages to be False
         # until after pip is installed.
         true_system_site_packages = self.system_site_packages
@@ -92,6 +99,42 @@ def clear_directory(self, path):
             elif os.path.isdir(fn):
                 shutil.rmtree(fn)
 
+    def _venv_path(self, env_dir, name):
+        vars = {
+            'base': env_dir,
+            'platbase': env_dir,
+            'installed_base': env_dir,
+            'installed_platbase': env_dir,
+        }
+        return sysconfig.get_path(name, scheme='venv', vars=vars)
+
+    @classmethod
+    def _same_path(cls, path1, path2):
+        """Check whether two paths appear the same.
+
+        Whether they refer to the same file is irrelevant; we're testing for
+        whether a human reader would look at the path string and easily tell
+        that they're the same file.
+        """
+        if sys.platform == 'win32':
+            if os.path.normcase(path1) == os.path.normcase(path2):
+                return True
+            # gh-90329: Don't display a warning for short/long names
+            import _winapi
+            try:
+                path1 = _winapi.GetLongPathName(os.fsdecode(path1))
+            except OSError:
+                pass
+            try:
+                path2 = _winapi.GetLongPathName(os.fsdecode(path2))
+            except OSError:
+                pass
+            if os.path.normcase(path1) == os.path.normcase(path2):
+                return True
+            return False
+        else:
+            return path1 == path2
+
     def ensure_directories(self, env_dir):
         """
         Create the directories for the environment.
@@ -106,31 +149,38 @@ def create_if_needed(d):
             elif os.path.islink(d) or os.path.isfile(d):
                 raise ValueError('Unable to create directory %r' % d)
 
+        if os.pathsep in os.fspath(env_dir):
+            raise ValueError(f'Refusing to create a venv in {env_dir} because '
+                             f'it contains the PATH separator {os.pathsep}.')
         if os.path.exists(env_dir) and self.clear:
             self.clear_directory(env_dir)
         context = types.SimpleNamespace()
         context.env_dir = env_dir
         context.env_name = os.path.split(env_dir)[1]
-        prompt = self.prompt if self.prompt is not None else context.env_name
-        context.prompt = '(%s) ' % prompt
+        context.prompt = self.prompt if self.prompt is not None else context.env_name
         create_if_needed(env_dir)
         executable = sys._base_executable
+        if not executable:  # see gh-96861
+            raise ValueError('Unable to determine path to the running '
+                             'Python interpreter. Provide an explicit path or '
+                             'check that your PATH environment variable is '
+                             'correctly set.')
         dirname, exename = os.path.split(os.path.abspath(executable))
+        if sys.platform == 'win32':
+            # Always create the simplest name in the venv. It will either be a
+            # link back to executable, or a copy of the appropriate launcher
+            _d = '_d' if os.path.splitext(exename)[0].endswith('_d') else ''
+            exename = f'python{_d}.exe'
         context.executable = executable
         context.python_dir = dirname
         context.python_exe = exename
-        if sys.platform == 'win32':
-            binname = 'Scripts'
-            incpath = 'Include'
-            libpath = os.path.join(env_dir, 'Lib', 'site-packages')
-        else:
-            binname = 'bin'
-            incpath = 'include'
-            libpath = os.path.join(env_dir, 'lib',
-                                   'python%d.%d' % sys.version_info[:2],
-                                   'site-packages')
-        context.inc_path = path = os.path.join(env_dir, incpath)
-        create_if_needed(path)
+        binpath = self._venv_path(env_dir, 'scripts')
+        incpath = self._venv_path(env_dir, 'include')
+        libpath = self._venv_path(env_dir, 'purelib')
+
+        context.inc_path = incpath
+        create_if_needed(incpath)
+        context.lib_path = libpath
         create_if_needed(libpath)
         # Issue 21197: create lib64 as a symlink to lib on 64-bit non-OS X POSIX
         if ((sys.maxsize > 2**32) and (os.name == 'posix') and
@@ -138,8 +188,8 @@ def create_if_needed(d):
             link_path = os.path.join(env_dir, 'lib64')
             if not os.path.exists(link_path):   # Issue #21643
                 os.symlink('lib', link_path)
-        context.bin_path = binpath = os.path.join(env_dir, binname)
-        context.bin_name = binname
+        context.bin_path = binpath
+        context.bin_name = os.path.relpath(binpath, env_dir)
         context.env_exe = os.path.join(binpath, exename)
         create_if_needed(binpath)
         # Assign and update the command to use when launching the newly created
@@ -149,7 +199,7 @@ def create_if_needed(d):
             # bpo-45337: Fix up env_exec_cmd to account for file system redirections.
             # Some redirects only apply to CreateFile and not CreateProcess
             real_env_exe = os.path.realpath(context.env_exe)
-            if os.path.normcase(real_env_exe) != os.path.normcase(context.env_exe):
+            if not self._same_path(real_env_exe, context.env_exe):
                 logger.warning('Actual environment location may have moved due to '
                                'redirects, links or junctions.\n'
                                '  Requested location: "%s"\n'
@@ -178,86 +228,84 @@ def create_configuration(self, context):
             f.write('version = %d.%d.%d\n' % sys.version_info[:3])
             if self.prompt is not None:
                 f.write(f'prompt = {self.prompt!r}\n')
-
-    if os.name != 'nt':
-        def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
-            """
-            Try symlinking a file, and if that fails, fall back to copying.
-            """
-            force_copy = not self.symlinks
-            if not force_copy:
-                try:
-                    if not os.path.islink(dst): # can't link to itself!
-                        if relative_symlinks_ok:
-                            assert os.path.dirname(src) == os.path.dirname(dst)
-                            os.symlink(os.path.basename(src), dst)
-                        else:
-                            os.symlink(src, dst)
-                except Exception:   # may need to use a more specific exception
-                    logger.warning('Unable to symlink %r to %r', src, dst)
-                    force_copy = True
-            if force_copy:
-                shutil.copyfile(src, dst)
-    else:
-        def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
-            """
-            Try symlinking a file, and if that fails, fall back to copying.
-            """
-            bad_src = os.path.lexists(src) and not os.path.exists(src)
-            if self.symlinks and not bad_src and not os.path.islink(dst):
-                try:
+            f.write('executable = %s\n' % os.path.realpath(sys.executable))
+            args = []
+            nt = os.name == 'nt'
+            if nt and self.symlinks:
+                args.append('--symlinks')
+            if not nt and not self.symlinks:
+                args.append('--copies')
+            if not self.with_pip:
+                args.append('--without-pip')
+            if self.system_site_packages:
+                args.append('--system-site-packages')
+            if self.clear:
+                args.append('--clear')
+            if self.upgrade:
+                args.append('--upgrade')
+            if self.upgrade_deps:
+                args.append('--upgrade-deps')
+            if self.orig_prompt is not None:
+                args.append(f'--prompt="{self.orig_prompt}"')
+            if not self.scm_ignore_files:
+                args.append('--without-scm-ignore-files')
+
+            args.append(context.env_dir)
+            args = ' '.join(args)
+            f.write(f'command = {sys.executable} -m venv {args}\n')
+
+    def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
+        """
+        Try symlinking a file, and if that fails, fall back to copying.
+        (Unused on Windows, because we can't just copy a failed symlink file: we
+        switch to a different set of files instead.)
+        """
+        assert os.name != 'nt'
+        force_copy = not self.symlinks
+        if not force_copy:
+            try:
+                if not os.path.islink(dst):  # can't link to itself!
                     if relative_symlinks_ok:
                         assert os.path.dirname(src) == os.path.dirname(dst)
                         os.symlink(os.path.basename(src), dst)
                     else:
                         os.symlink(src, dst)
-                    return
-                except Exception:   # may need to use a more specific exception
-                    logger.warning('Unable to symlink %r to %r', src, dst)
-
-            # On Windows, we rewrite symlinks to our base python.exe into
-            # copies of venvlauncher.exe
-            basename, ext = os.path.splitext(os.path.basename(src))
-            srcfn = os.path.join(os.path.dirname(__file__),
-                                 "scripts",
-                                 "nt",
-                                 basename + ext)
-            # Builds or venv's from builds need to remap source file
-            # locations, as we do not put them into Lib/venv/scripts
-            if sysconfig.is_python_build(True) or not os.path.isfile(srcfn):
-                if basename.endswith('_d'):
-                    ext = '_d' + ext
-                    basename = basename[:-2]
-                if basename == 'python':
-                    basename = 'venvlauncher'
-                elif basename == 'pythonw':
-                    basename = 'venvwlauncher'
-                src = os.path.join(os.path.dirname(src), basename + ext)
-            else:
-                src = srcfn
-            if not os.path.exists(src):
-                if not bad_src:
-                    logger.warning('Unable to copy %r', src)
-                return
-
+            except Exception:   # may need to use a more specific exception
+                logger.warning('Unable to symlink %r to %r', src, dst)
+                force_copy = True
+        if force_copy:
             shutil.copyfile(src, dst)
 
-    def setup_python(self, context):
+    def create_git_ignore_file(self, context):
         """
-        Set up a Python executable in the environment.
+        Create a .gitignore file in the environment directory.
 
-        :param context: The information for the environment creation request
-                        being processed.
+        The contents of the file cause the entire environment directory to be
+        ignored by git.
         """
-        binpath = context.bin_path
-        path = context.env_exe
-        copier = self.symlink_or_copy
-        dirname = context.python_dir
-        if os.name != 'nt':
+        gitignore_path = os.path.join(context.env_dir, '.gitignore')
+        with open(gitignore_path, 'w', encoding='utf-8') as file:
+            file.write('# Created by venv; '
+                       'see https://docs.python.org/3/library/venv.html\n')
+            file.write('*\n')
+
+    if os.name != 'nt':
+        def setup_python(self, context):
+            """
+            Set up a Python executable in the environment.
+
+            :param context: The information for the environment creation request
+                            being processed.
+            """
+            binpath = context.bin_path
+            path = context.env_exe
+            copier = self.symlink_or_copy
+            dirname = context.python_dir
             copier(context.executable, path)
             if not os.path.islink(path):
                 os.chmod(path, 0o755)
-            for suffix in ('python', 'python3', f'python3.{sys.version_info[1]}'):
+            for suffix in ('python', 'python3',
+                           f'python3.{sys.version_info[1]}'):
                 path = os.path.join(binpath, suffix)
                 if not os.path.exists(path):
                     # Issue 18807: make copies if
@@ -265,32 +313,107 @@ def setup_python(self, context):
                     copier(context.env_exe, path, relative_symlinks_ok=True)
                     if not os.path.islink(path):
                         os.chmod(path, 0o755)
-        else:
-            if self.symlinks:
-                # For symlinking, we need a complete copy of the root directory
-                # If symlinks fail, you'll get unnecessary copies of files, but
-                # we assume that if you've opted into symlinks on Windows then
-                # you know what you're doing.
-                suffixes = [
-                    f for f in os.listdir(dirname) if
-                    os.path.normcase(os.path.splitext(f)[1]) in ('.exe', '.dll')
-                ]
-                if sysconfig.is_python_build(True):
-                    suffixes = [
-                        f for f in suffixes if
-                        os.path.normcase(f).startswith(('python', 'vcruntime'))
-                    ]
+
+    else:
+        def setup_python(self, context):
+            """
+            Set up a Python executable in the environment.
+
+            :param context: The information for the environment creation request
+                            being processed.
+            """
+            binpath = context.bin_path
+            dirname = context.python_dir
+            exename = os.path.basename(context.env_exe)
+            exe_stem = os.path.splitext(exename)[0]
+            exe_d = '_d' if os.path.normcase(exe_stem).endswith('_d') else ''
+            if sysconfig.is_python_build():
+                scripts = dirname
             else:
-                suffixes = {'python.exe', 'python_d.exe', 'pythonw.exe', 'pythonw_d.exe'}
-                base_exe = os.path.basename(context.env_exe)
-                suffixes.add(base_exe)
+                scripts = os.path.join(os.path.dirname(__file__),
+                                       'scripts', 'nt')
+            if not sysconfig.get_config_var("Py_GIL_DISABLED"):
+                python_exe = os.path.join(dirname, f'python{exe_d}.exe')
+                pythonw_exe = os.path.join(dirname, f'pythonw{exe_d}.exe')
+                link_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                }
+                python_exe = os.path.join(scripts, f'venvlauncher{exe_d}.exe')
+                pythonw_exe = os.path.join(scripts, f'venvwlauncher{exe_d}.exe')
+                copy_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                }
+            else:
+                exe_t = f'3.{sys.version_info[1]}t'
+                python_exe = os.path.join(dirname, f'python{exe_t}{exe_d}.exe')
+                pythonw_exe = os.path.join(dirname, f'pythonw{exe_t}{exe_d}.exe')
+                link_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    f'python{exe_t}.exe': python_exe,
+                    f'python{exe_t}{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                    f'pythonw{exe_t}.exe': pythonw_exe,
+                    f'pythonw{exe_t}{exe_d}.exe': pythonw_exe,
+                }
+                python_exe = os.path.join(scripts, f'venvlaunchert{exe_d}.exe')
+                pythonw_exe = os.path.join(scripts, f'venvwlaunchert{exe_d}.exe')
+                copy_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    f'python{exe_t}.exe': python_exe,
+                    f'python{exe_t}{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                    f'pythonw{exe_t}.exe': pythonw_exe,
+                    f'pythonw{exe_t}{exe_d}.exe': pythonw_exe,
+                }
+
+            do_copies = True
+            if self.symlinks:
+                do_copies = False
+                # For symlinking, we need all the DLLs to be available alongside
+                # the executables.
+                link_sources.update({
+                    f: os.path.join(dirname, f) for f in os.listdir(dirname)
+                    if os.path.normcase(f).startswith(('python', 'vcruntime'))
+                    and os.path.normcase(os.path.splitext(f)[1]) == '.dll'
+                })
+
+                to_unlink = []
+                for dest, src in link_sources.items():
+                    dest = os.path.join(binpath, dest)
+                    try:
+                        os.symlink(src, dest)
+                        to_unlink.append(dest)
+                    except OSError:
+                        logger.warning('Unable to symlink %r to %r', src, dest)
+                        do_copies = True
+                        for f in to_unlink:
+                            try:
+                                os.unlink(f)
+                            except OSError:
+                                logger.warning('Failed to clean up symlink %r',
+                                               f)
+                        logger.warning('Retrying with copies')
+                        break
 
-            for suffix in suffixes:
-                src = os.path.join(dirname, suffix)
-                if os.path.lexists(src):
-                    copier(src, os.path.join(binpath, suffix))
+            if do_copies:
+                for dest, src in copy_sources.items():
+                    dest = os.path.join(binpath, dest)
+                    try:
+                        shutil.copy2(src, dest)
+                    except OSError:
+                        logger.warning('Unable to copy %r to %r', src, dest)
 
-            if sysconfig.is_python_build(True):
+            if sysconfig.is_python_build():
                 # copy init.tcl
                 for root, dirs, files in os.walk(context.python_dir):
                     if 'init.tcl' in files:
@@ -303,14 +426,25 @@ def setup_python(self, context):
                         shutil.copyfile(src, dst)
                         break
 
+    def _call_new_python(self, context, *py_args, **kwargs):
+        """Executes the newly created Python using safe-ish options"""
+        # gh-98251: We do not want to just use '-I' because that masks
+        # legitimate user preferences (such as not writing bytecode). All we
+        # really need is to ensure that the path variables do not overrule
+        # normal venv handling.
+        args = [context.env_exec_cmd, *py_args]
+        kwargs['env'] = env = os.environ.copy()
+        env['VIRTUAL_ENV'] = context.env_dir
+        env.pop('PYTHONHOME', None)
+        env.pop('PYTHONPATH', None)
+        kwargs['cwd'] = context.env_dir
+        kwargs['executable'] = context.env_exec_cmd
+        subprocess.check_output(args, **kwargs)
+
     def _setup_pip(self, context):
         """Installs or upgrades pip in a virtual environment"""
-        # We run ensurepip in isolated mode to avoid side effects from
-        # environment vars, the current directory and anything else
-        # intended for the global Python environment
-        cmd = [context.env_exec_cmd, '-Im', 'ensurepip', '--upgrade',
-                                                         '--default-pip']
-        subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        self._call_new_python(context, '-m', 'ensurepip', '--upgrade',
+                              '--default-pip', stderr=subprocess.STDOUT)
 
     def setup_scripts(self, context):
         """
@@ -348,11 +482,41 @@ def replace_variables(self, text, context):
         :param context: The information for the environment creation request
                         being processed.
         """
-        text = text.replace('__VENV_DIR__', context.env_dir)
-        text = text.replace('__VENV_NAME__', context.env_name)
-        text = text.replace('__VENV_PROMPT__', context.prompt)
-        text = text.replace('__VENV_BIN_NAME__', context.bin_name)
-        text = text.replace('__VENV_PYTHON__', context.env_exe)
+        replacements = {
+            '__VENV_DIR__': context.env_dir,
+            '__VENV_NAME__': context.env_name,
+            '__VENV_PROMPT__': context.prompt,
+            '__VENV_BIN_NAME__': context.bin_name,
+            '__VENV_PYTHON__': context.env_exe,
+        }
+
+        def quote_ps1(s):
+            """
+            This should satisfy PowerShell quoting rules [1], unless the quoted
+            string is passed directly to Windows native commands [2].
+            [1]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules
+            [2]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing#passing-arguments-that-contain-quote-characters
+            """
+            s = s.replace("'", "''")
+            return f"'{s}'"
+
+        def quote_bat(s):
+            return s
+
+        # gh-124651: need to quote the template strings properly
+        quote = shlex.quote
+        script_path = context.script_path
+        if script_path.endswith('.ps1'):
+            quote = quote_ps1
+        elif script_path.endswith('.bat'):
+            quote = quote_bat
+        else:
+            # fallbacks to POSIX shell compliant quote
+            quote = shlex.quote
+
+        replacements = {key: quote(s) for key, s in replacements.items()}
+        for key, quoted in replacements.items():
+            text = text.replace(key, quoted)
         return text
 
     def install_scripts(self, context, path):
@@ -370,15 +534,22 @@ def install_scripts(self, context, path):
         """
         binpath = context.bin_path
         plen = len(path)
+        if os.name == 'nt':
+            def skip_file(f):
+                f = os.path.normcase(f)
+                return (f.startswith(('python', 'venv'))
+                        and f.endswith(('.exe', '.pdb')))
+        else:
+            def skip_file(f):
+                return False
         for root, dirs, files in os.walk(path):
-            if root == path: # at top-level, remove irrelevant dirs
+            if root == path:  # at top-level, remove irrelevant dirs
                 for d in dirs[:]:
                     if d not in ('common', os.name):
                         dirs.remove(d)
-                continue # ignore files in top level
+                continue  # ignore files in top level
             for f in files:
-                if (os.name == 'nt' and f.startswith('python')
-                        and f.endswith(('.exe', '.pdb'))):
+                if skip_file(f):
                     continue
                 srcfile = os.path.join(root, f)
                 suffix = root[plen:].split(os.sep)[2:]
@@ -389,116 +560,122 @@ def install_scripts(self, context, path):
                 if not os.path.exists(dstdir):
                     os.makedirs(dstdir)
                 dstfile = os.path.join(dstdir, f)
+                if os.name == 'nt' and srcfile.endswith(('.exe', '.pdb')):
+                    shutil.copy2(srcfile, dstfile)
+                    continue
                 with open(srcfile, 'rb') as f:
                     data = f.read()
-                if not srcfile.endswith(('.exe', '.pdb')):
-                    try:
-                        data = data.decode('utf-8')
-                        data = self.replace_variables(data, context)
-                        data = data.encode('utf-8')
-                    except UnicodeError as e:
-                        data = None
-                        logger.warning('unable to copy script %r, '
-                                       'may be binary: %s', srcfile, e)
-                if data is not None:
+                try:
+                    context.script_path = srcfile
+                    new_data = (
+                        self.replace_variables(data.decode('utf-8'), context)
+                            .encode('utf-8')
+                    )
+                except UnicodeError as e:
+                    logger.warning('unable to copy script %r, '
+                                   'may be binary: %s', srcfile, e)
+                    continue
+                if new_data == data:
+                    shutil.copy2(srcfile, dstfile)
+                else:
                     with open(dstfile, 'wb') as f:
-                        f.write(data)
+                        f.write(new_data)
                     shutil.copymode(srcfile, dstfile)
 
     def upgrade_dependencies(self, context):
         logger.debug(
             f'Upgrading {CORE_VENV_DEPS} packages in {context.bin_path}'
         )
-        cmd = [context.env_exec_cmd, '-m', 'pip', 'install', '--upgrade']
-        cmd.extend(CORE_VENV_DEPS)
-        subprocess.check_call(cmd)
+        self._call_new_python(context, '-m', 'pip', 'install', '--upgrade',
+                              *CORE_VENV_DEPS)
 
 
 def create(env_dir, system_site_packages=False, clear=False,
-           symlinks=False, with_pip=False, prompt=None, upgrade_deps=False):
+           symlinks=False, with_pip=False, prompt=None, upgrade_deps=False,
+           *, scm_ignore_files=frozenset()):
     """Create a virtual environment in a directory."""
     builder = EnvBuilder(system_site_packages=system_site_packages,
                          clear=clear, symlinks=symlinks, with_pip=with_pip,
-                         prompt=prompt, upgrade_deps=upgrade_deps)
+                         prompt=prompt, upgrade_deps=upgrade_deps,
+                         scm_ignore_files=scm_ignore_files)
     builder.create(env_dir)
 
+
 def main(args=None):
-    compatible = True
-    if sys.version_info < (3, 3):
-        compatible = False
-    elif not hasattr(sys, 'base_prefix'):
-        compatible = False
-    if not compatible:
-        raise ValueError('This script is only for use with Python >= 3.3')
+    import argparse
+
+    parser = argparse.ArgumentParser(prog=__name__,
+                                     description='Creates virtual Python '
+                                                 'environments in one or '
+                                                 'more target '
+                                                 'directories.',
+                                     epilog='Once an environment has been '
+                                            'created, you may wish to '
+                                            'activate it, e.g. by '
+                                            'sourcing an activate script '
+                                            'in its bin directory.')
+    parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
+                        help='A directory to create the environment in.')
+    parser.add_argument('--system-site-packages', default=False,
+                        action='store_true', dest='system_site',
+                        help='Give the virtual environment access to the '
+                             'system site-packages dir.')
+    if os.name == 'nt':
+        use_symlinks = False
     else:
-        import argparse
-
-        parser = argparse.ArgumentParser(prog=__name__,
-                                         description='Creates virtual Python '
-                                                     'environments in one or '
-                                                     'more target '
-                                                     'directories.',
-                                         epilog='Once an environment has been '
-                                                'created, you may wish to '
-                                                'activate it, e.g. by '
-                                                'sourcing an activate script '
-                                                'in its bin directory.')
-        parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
-                            help='A directory to create the environment in.')
-        parser.add_argument('--system-site-packages', default=False,
-                            action='store_true', dest='system_site',
-                            help='Give the virtual environment access to the '
-                                 'system site-packages dir.')
-        if os.name == 'nt':
-            use_symlinks = False
-        else:
-            use_symlinks = True
-        group = parser.add_mutually_exclusive_group()
-        group.add_argument('--symlinks', default=use_symlinks,
-                           action='store_true', dest='symlinks',
-                           help='Try to use symlinks rather than copies, '
-                                'when symlinks are not the default for '
-                                'the platform.')
-        group.add_argument('--copies', default=not use_symlinks,
-                           action='store_false', dest='symlinks',
-                           help='Try to use copies rather than symlinks, '
-                                'even when symlinks are the default for '
-                                'the platform.')
-        parser.add_argument('--clear', default=False, action='store_true',
-                            dest='clear', help='Delete the contents of the '
-                                               'environment directory if it '
-                                               'already exists, before '
-                                               'environment creation.')
-        parser.add_argument('--upgrade', default=False, action='store_true',
-                            dest='upgrade', help='Upgrade the environment '
-                                               'directory to use this version '
-                                               'of Python, assuming Python '
-                                               'has been upgraded in-place.')
-        parser.add_argument('--without-pip', dest='with_pip',
-                            default=True, action='store_false',
-                            help='Skips installing or upgrading pip in the '
-                                 'virtual environment (pip is bootstrapped '
-                                 'by default)')
-        parser.add_argument('--prompt',
-                            help='Provides an alternative prompt prefix for '
-                                 'this environment.')
-        parser.add_argument('--upgrade-deps', default=False, action='store_true',
-                            dest='upgrade_deps',
-                            help='Upgrade core dependencies: {} to the latest '
-                                 'version in PyPI'.format(
-                                 ' '.join(CORE_VENV_DEPS)))
-        options = parser.parse_args(args)
-        if options.upgrade and options.clear:
-            raise ValueError('you cannot supply --upgrade and --clear together.')
-        builder = EnvBuilder(system_site_packages=options.system_site,
-                             clear=options.clear,
-                             symlinks=options.symlinks,
-                             upgrade=options.upgrade,
-                             with_pip=options.with_pip,
-                             prompt=options.prompt,
-                             upgrade_deps=options.upgrade_deps)
-        for d in options.dirs:
-            builder.create(d)
+        use_symlinks = True
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--symlinks', default=use_symlinks,
+                       action='store_true', dest='symlinks',
+                       help='Try to use symlinks rather than copies, '
+                            'when symlinks are not the default for '
+                            'the platform.')
+    group.add_argument('--copies', default=not use_symlinks,
+                       action='store_false', dest='symlinks',
+                       help='Try to use copies rather than symlinks, '
+                            'even when symlinks are the default for '
+                            'the platform.')
+    parser.add_argument('--clear', default=False, action='store_true',
+                        dest='clear', help='Delete the contents of the '
+                                           'environment directory if it '
+                                           'already exists, before '
+                                           'environment creation.')
+    parser.add_argument('--upgrade', default=False, action='store_true',
+                        dest='upgrade', help='Upgrade the environment '
+                                             'directory to use this version '
+                                             'of Python, assuming Python '
+                                             'has been upgraded in-place.')
+    parser.add_argument('--without-pip', dest='with_pip',
+                        default=True, action='store_false',
+                        help='Skips installing or upgrading pip in the '
+                             'virtual environment (pip is bootstrapped '
+                             'by default)')
+    parser.add_argument('--prompt',
+                        help='Provides an alternative prompt prefix for '
+                             'this environment.')
+    parser.add_argument('--upgrade-deps', default=False, action='store_true',
+                        dest='upgrade_deps',
+                        help=f'Upgrade core dependencies ({", ".join(CORE_VENV_DEPS)}) '
+                             'to the latest version in PyPI')
+    parser.add_argument('--without-scm-ignore-files', dest='scm_ignore_files',
+                        action='store_const', const=frozenset(),
+                        default=frozenset(['git']),
+                        help='Skips adding SCM ignore files to the environment '
+                             'directory (Git is supported by default).')
+    options = parser.parse_args(args)
+    if options.upgrade and options.clear:
+        raise ValueError('you cannot supply --upgrade and --clear together.')
+    builder = EnvBuilder(system_site_packages=options.system_site,
+                         clear=options.clear,
+                         symlinks=options.symlinks,
+                         upgrade=options.upgrade,
+                         with_pip=options.with_pip,
+                         prompt=options.prompt,
+                         upgrade_deps=options.upgrade_deps,
+                         scm_ignore_files=options.scm_ignore_files)
+    for d in options.dirs:
+        builder.create(d)
+
 
 if __name__ == '__main__':
     rc = 1
diff --git a/Lib/venv/__main__.py b/Lib/venv/__main__.py
index 912423e4a78..88f55439dc2 100644
--- a/Lib/venv/__main__.py
+++ b/Lib/venv/__main__.py
@@ -6,5 +6,5 @@
     main()
     rc = 0
 except Exception as e:
-    print('Error: %s' % e, file=sys.stderr)
+    print('Error:', e, file=sys.stderr)
 sys.exit(rc)
diff --git a/Lib/venv/scripts/common/Activate.ps1 b/Lib/venv/scripts/common/Activate.ps1
index b49d77ba44b..16ba5290fae 100644
--- a/Lib/venv/scripts/common/Activate.ps1
+++ b/Lib/venv/scripts/common/Activate.ps1
@@ -219,6 +219,8 @@ deactivate -nondestructive
 # that there is an activated venv.
 $env:VIRTUAL_ENV = $VenvDir
 
+$env:VIRTUAL_ENV_PROMPT = $Prompt
+
 if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
 
     Write-Verbose "Setting prompt to '$Prompt'"
@@ -233,7 +235,6 @@ if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
         Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
         _OLD_VIRTUAL_PROMPT
     }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
 }
 
 # Clear PYTHONHOME
diff --git a/Lib/venv/scripts/common/activate b/Lib/venv/scripts/common/activate
index 6fbc2b8801d..70673a265d4 100644
--- a/Lib/venv/scripts/common/activate
+++ b/Lib/venv/scripts/common/activate
@@ -1,5 +1,5 @@
 # This file must be used with "source bin/activate" *from bash*
-# you cannot run it directly
+# You cannot run it directly
 
 deactivate () {
     # reset old environment variables
@@ -14,12 +14,10 @@ deactivate () {
         unset _OLD_VIRTUAL_PYTHONHOME
     fi
 
-    # This should detect bash and zsh, which have a hash command that must
-    # be called to get it to forget past commands.  Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
-        hash -r 2> /dev/null
-    fi
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
 
     if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
         PS1="${_OLD_VIRTUAL_PS1:-}"
@@ -38,13 +36,27 @@ deactivate () {
 # unset irrelevant variables
 deactivate nondestructive
 
-VIRTUAL_ENV="__VENV_DIR__"
-export VIRTUAL_ENV
+# on Windows, a path can contain colons and backslashes and has to be converted:
+case "$(uname)" in
+    CYGWIN*|MSYS*|MINGW*)
+        # transform D:\path\to\venv to /d/path/to/venv on MSYS and MINGW
+        # and to /cygdrive/d/path/to/venv on Cygwin
+        VIRTUAL_ENV=$(cygpath __VENV_DIR__)
+        export VIRTUAL_ENV
+        ;;
+    *)
+        # use the path as-is
+        export VIRTUAL_ENV=__VENV_DIR__
+        ;;
+esac
 
 _OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/__VENV_BIN_NAME__:$PATH"
+PATH="$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH"
 export PATH
 
+VIRTUAL_ENV_PROMPT=__VENV_PROMPT__
+export VIRTUAL_ENV_PROMPT
+
 # unset PYTHONHOME if set
 # this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
 # could use `if (set -u; : $PYTHONHOME) ;` in bash
@@ -55,15 +67,10 @@ fi
 
 if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
     _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1="__VENV_PROMPT__${PS1:-}"
+    PS1="("__VENV_PROMPT__") ${PS1:-}"
     export PS1
-    VIRTUAL_ENV_PROMPT="__VENV_PROMPT__"
-    export VIRTUAL_ENV_PROMPT
 fi
 
-# This should detect bash and zsh, which have a hash command that must
-# be called to get it to forget past commands.  Without forgetting
+# Call hash to forget past commands. Without forgetting
 # past commands the $PATH changes we made may not be respected
-if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
-    hash -r 2> /dev/null
-fi
+hash -r 2> /dev/null
diff --git a/Lib/venv/scripts/posix/activate.fish b/Lib/venv/scripts/common/activate.fish
similarity index 76%
rename from Lib/venv/scripts/posix/activate.fish
rename to Lib/venv/scripts/common/activate.fish
index e40a1d71489..284a7469c99 100644
--- a/Lib/venv/scripts/posix/activate.fish
+++ b/Lib/venv/scripts/common/activate.fish
@@ -1,5 +1,5 @@
 # This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/); you cannot run it directly.
+# (https://fishshell.com/). You cannot run it directly.
 
 function deactivate  -d "Exit virtual environment and return to normal shell environment"
     # reset old environment variables
@@ -13,10 +13,13 @@ function deactivate  -d "Exit virtual environment and return to normal shell env
     end
 
     if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        functions -e fish_prompt
         set -e _OLD_FISH_PROMPT_OVERRIDE
-        functions -c _old_fish_prompt fish_prompt
-        functions -e _old_fish_prompt
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
     end
 
     set -e VIRTUAL_ENV
@@ -30,10 +33,11 @@ end
 # Unset irrelevant variables.
 deactivate nondestructive
 
-set -gx VIRTUAL_ENV "__VENV_DIR__"
+set -gx VIRTUAL_ENV __VENV_DIR__
 
 set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/__VENV_BIN_NAME__" $PATH
+set -gx PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__ $PATH
+set -gx VIRTUAL_ENV_PROMPT __VENV_PROMPT__
 
 # Unset PYTHONHOME if set.
 if set -q PYTHONHOME
@@ -53,7 +57,7 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
         set -l old_status $status
 
         # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) "__VENV_PROMPT__" (set_color normal)
+        printf "%s(%s)%s " (set_color 4B8BBE) __VENV_PROMPT__ (set_color normal)
 
         # Restore the return status of the previous command.
         echo "exit $old_status" | .
@@ -62,5 +66,4 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
     end
 
     set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT "__VENV_PROMPT__"
 end
diff --git a/Lib/venv/scripts/nt/activate.bat b/Lib/venv/scripts/nt/activate.bat
index 5daa45afc9f..9ac5c20b477 100644
--- a/Lib/venv/scripts/nt/activate.bat
+++ b/Lib/venv/scripts/nt/activate.bat
@@ -8,15 +8,15 @@ if defined _OLD_CODEPAGE (
     "%SystemRoot%\System32\chcp.com" 65001 > nul
 )
 
-set VIRTUAL_ENV=__VENV_DIR__
+set "VIRTUAL_ENV=__VENV_DIR__"
 
 if not defined PROMPT set PROMPT=$P$G
 
 if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT%
 if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%
 
-set _OLD_VIRTUAL_PROMPT=%PROMPT%
-set PROMPT=__VENV_PROMPT__%PROMPT%
+set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+set "PROMPT=(__VENV_PROMPT__) %PROMPT%"
 
 if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%
 set PYTHONHOME=
@@ -24,8 +24,8 @@ set PYTHONHOME=
 if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH%
 if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH%
 
-set PATH=%VIRTUAL_ENV%\__VENV_BIN_NAME__;%PATH%
-set VIRTUAL_ENV_PROMPT=__VENV_PROMPT__
+set "PATH=%VIRTUAL_ENV%\__VENV_BIN_NAME__;%PATH%"
+set "VIRTUAL_ENV_PROMPT=__VENV_PROMPT__"
 
 :END
 if defined _OLD_CODEPAGE (
diff --git a/Lib/venv/scripts/posix/activate.csh b/Lib/venv/scripts/posix/activate.csh
index d6f697c55ed..2a3fa835476 100644
--- a/Lib/venv/scripts/posix/activate.csh
+++ b/Lib/venv/scripts/posix/activate.csh
@@ -1,5 +1,6 @@
 # This file must be used with "source bin/activate.csh" *from csh*.
 # You cannot run it directly.
+
 # Created by Davide Di Blasi <davidedb@gmail.com>.
 # Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
 
@@ -8,17 +9,17 @@ alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PA
 # Unset irrelevant variables.
 deactivate nondestructive
 
-setenv VIRTUAL_ENV "__VENV_DIR__"
+setenv VIRTUAL_ENV __VENV_DIR__
 
 set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/__VENV_BIN_NAME__:$PATH"
+setenv PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH"
+setenv VIRTUAL_ENV_PROMPT __VENV_PROMPT__
 
 
 set _OLD_VIRTUAL_PROMPT="$prompt"
 
 if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = "__VENV_PROMPT__$prompt"
-    setenv VIRTUAL_ENV_PROMPT "__VENV_PROMPT__"
+    set prompt = "("__VENV_PROMPT__") $prompt:q"
 endif
 
 alias pydoc python -m pydoc
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 52ecf927d5c..f9bd2b59456 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -164,11 +164,70 @@ mod sys {
     #[pyattr]
     fn _base_executable(vm: &VirtualMachine) -> PyObjectRef {
         let ctx = &vm.ctx;
+        // First check __PYVENV_LAUNCHER__ environment variable
         if let Ok(var) = env::var("__PYVENV_LAUNCHER__") {
-            ctx.new_str(var).into()
-        } else {
-            executable(vm)
+            return ctx.new_str(var).into();
+        }
+
+        // Try to detect if we're running from a venv by looking for pyvenv.cfg
+        if let Some(base_exe) = get_venv_base_executable() {
+            return ctx.new_str(base_exe).into();
         }
+
+        executable(vm)
+    }
+
+    /// Try to find base executable from pyvenv.cfg (see getpath.py)
+    fn get_venv_base_executable() -> Option<String> {
+        // TODO: This is a minimal implementation of getpath.py
+        // To fully support all cases, `getpath.py` should be placed in @crates/vm/Lib/python_builtins/
+
+        // Get current executable path
+        #[cfg(not(target_arch = "wasm32"))]
+        let exe_path = {
+            let exec_arg = env::args_os().next()?;
+            which::which(exec_arg).ok()?
+        };
+        #[cfg(target_arch = "wasm32")]
+        let exe_path = {
+            let exec_arg = env::args().next()?;
+            path::PathBuf::from(exec_arg)
+        };
+
+        let exe_dir = exe_path.parent()?;
+        let exe_name = exe_path.file_name()?;
+
+        // Look for pyvenv.cfg in parent directory (typical venv layout: venv/bin/python)
+        let venv_dir = exe_dir.parent()?;
+        let pyvenv_cfg = venv_dir.join("pyvenv.cfg");
+
+        if !pyvenv_cfg.exists() {
+            return None;
+        }
+
+        // Parse pyvenv.cfg and extract home directory
+        let content = std::fs::read_to_string(&pyvenv_cfg).ok()?;
+
+        for line in content.lines() {
+            if let Some((key, value)) = line.split_once('=') {
+                let key = key.trim().to_lowercase();
+                let value = value.trim();
+
+                if key == "home" {
+                    // First try to resolve symlinks (getpath.py line 373-377)
+                    if let Ok(resolved) = std::fs::canonicalize(&exe_path)
+                        && resolved != exe_path
+                    {
+                        return Some(resolved.to_string_lossy().into_owned());
+                    }
+                    // Fallback: home_dir + executable_name (getpath.py line 381)
+                    let base_exe = path::Path::new(value).join(exe_name);
+                    return Some(base_exe.to_string_lossy().into_owned());
+                }
+            }
+        }
+
+        None
     }
 
     #[pyattr]

From 7bfa5d9ceda6c5a3fb402dcf89d37b2c3e47f9f4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 20 Dec 2025 18:31:00 +0900
Subject: [PATCH 016/418] Buffer LongDouble + ndim (#6460)

* fix fix_test

* ndim buffer
---
 crates/vm/src/buffer.rs          | 20 +++++++++++++++++---
 crates/vm/src/protocol/buffer.rs | 11 +++++++++--
 scripts/fix_test.py              |  6 +++++-
 3 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index eeb6a676542..5c67f87521d 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -88,7 +88,9 @@ pub(crate) enum FormatType {
     Half = b'e',
     Float = b'f',
     Double = b'd',
+    LongDouble = b'g',
     VoidP = b'P',
+    PyObject = b'O',
 }
 
 impl fmt::Debug for FormatType {
@@ -148,7 +150,9 @@ impl FormatType {
                     Half => nonnative_info!(f16, $end),
                     Float => nonnative_info!(f32, $end),
                     Double => nonnative_info!(f64, $end),
-                    _ => unreachable!(), // size_t or void*
+                    LongDouble => nonnative_info!(f64, $end), // long double same as double
+                    PyObject => nonnative_info!(usize, $end), // pointer size
+                    _ => unreachable!(),                      // size_t or void*
                 }
             }};
         }
@@ -183,7 +187,9 @@ impl FormatType {
                 Half => native_info!(f16),
                 Float => native_info!(raw::c_float),
                 Double => native_info!(raw::c_double),
+                LongDouble => native_info!(raw::c_double), // long double same as double for now
                 VoidP => native_info!(*mut raw::c_void),
+                PyObject => native_info!(*mut raw::c_void), // pointer to PyObject
             },
             Endianness::Big => match_nonnative!(self, BigEndian),
             Endianness::Little => match_nonnative!(self, LittleEndian),
@@ -306,8 +312,16 @@ impl FormatCode {
                 continue;
             }
 
-            if c == b'{' || c == b'}' {
-                // Skip standalone braces (pointer targets, etc.)
+            if c == b'{'
+                || c == b'}'
+                || c == b'&'
+                || c == b'<'
+                || c == b'>'
+                || c == b'@'
+                || c == b'='
+                || c == b'!'
+            {
+                // Skip standalone braces (pointer targets, etc.), pointer prefix, and nested endianness markers
                 continue;
             }
 
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
index 948ec763dc6..0a34af59080 100644
--- a/crates/vm/src/protocol/buffer.rs
+++ b/crates/vm/src/protocol/buffer.rs
@@ -201,16 +201,23 @@ impl BufferDescriptor {
 
     #[cfg(debug_assertions)]
     pub fn validate(self) -> Self {
-        assert!(self.itemsize != 0);
         // ndim=0 is valid for scalar types (e.g., ctypes Structure)
         if self.ndim() == 0 {
+            // Empty structures (len=0) can have itemsize=0
+            if self.len > 0 {
+                assert!(self.itemsize != 0);
+            }
             assert!(self.itemsize == self.len);
         } else {
             let mut shape_product = 1;
+            let has_zero_dim = self.dim_desc.iter().any(|(s, _, _)| *s == 0);
             for (shape, stride, suboffset) in self.dim_desc.iter().cloned() {
                 shape_product *= shape;
                 assert!(suboffset >= 0);
-                assert!(stride != 0);
+                // For empty arrays (any dimension is 0), strides can be 0
+                if !has_zero_dim {
+                    assert!(stride != 0);
+                }
             }
             assert!(shape_product * self.itemsize == self.len);
         }
diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index 9716bd0b008..53b10d63834 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -159,7 +159,11 @@ def run_test(test_name):
     if not test_path.exists():
         print(f"Error: File not found: {test_path}")
         sys.exit(1)
-    test_name = test_path.stem
+    # Detect package tests (e.g., test_ctypes/test_random_things.py)
+    if test_path.parent.name.startswith("test_"):
+        test_name = f"{test_path.parent.name}.{test_path.stem}"
+    else:
+        test_name = test_path.stem
     tests = run_test(test_name)
     f = test_path.read_text(encoding="utf-8")
 

From 6660170bf838b239b74a5c0fe9dab7615f3c7e41 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 20 Dec 2025 22:06:22 +0900
Subject: [PATCH 017/418] Share more ssl consts and fix openssl  (#6462)

* Reuse SSL error names

* Share ssl error codes

* fix ssl

* fix openssl
---
 crates/stdlib/src/openssl.rs    | 429 +++++++++++++++++++++++---------
 crates/stdlib/src/ssl.rs        |  22 --
 crates/stdlib/src/ssl/compat.rs |  15 +-
 crates/stdlib/src/ssl/error.rs  |  24 +-
 4 files changed, 347 insertions(+), 143 deletions(-)

diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index e07ad552f17..b6d5f5c2035 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -53,11 +53,10 @@ cfg_if::cfg_if! {
 mod _ssl {
     use super::{bio, probe};
 
-    // Import error types used in this module (others are exposed via pymodule(with(...)))
+    // Import error types and helpers used in this module (others are exposed via pymodule(with(...)))
     use super::ssl_error::{
-        PySSLCertVerificationError as PySslCertVerificationError, PySSLEOFError as PySslEOFError,
-        PySSLError as PySslError, PySSLWantReadError as PySslWantReadError,
-        PySSLWantWriteError as PySslWantWriteError,
+        PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,
+        create_ssl_want_write_error,
     };
     use crate::{
         common::lock::{
@@ -249,8 +248,6 @@ mod _ssl {
     #[pyattr]
     const VERIFY_DEFAULT: u32 = 0;
     #[pyattr]
-    const SSL_ERROR_EOF: u32 = 8; // custom for python
-    #[pyattr]
     const HAS_SNI: bool = true;
     #[pyattr]
     const HAS_ECDH: bool = true;
@@ -709,21 +706,124 @@ mod _ssl {
         }
     }
 
+    // OpenSSL record type constants for msg_callback
+    const SSL3_RT_CHANGE_CIPHER_SPEC: i32 = 20;
+    const SSL3_RT_ALERT: i32 = 21;
+    const SSL3_RT_HANDSHAKE: i32 = 22;
+    const SSL3_RT_HEADER: i32 = 256;
+    const SSL3_RT_INNER_CONTENT_TYPE: i32 = 257;
+    // Special value for change cipher spec (CPython compatibility)
+    const SSL3_MT_CHANGE_CIPHER_SPEC: i32 = 0x0101;
+
     // Message callback function called by OpenSSL
-    // NOTE: This callback is intentionally a no-op to avoid deadlocks.
-    // The msg_callback can be called during various SSL operations (read, write, handshake),
-    // and invoking Python code from within these operations can cause deadlocks
-    // (see CPython bpo-43577). A proper implementation would require careful lock ordering.
+    // Called during SSL operations to report protocol messages.
+    // debughelpers.c:_PySSL_msg_callback
     unsafe extern "C" fn _msg_callback(
-        _write_p: libc::c_int,
-        _version: libc::c_int,
-        _content_type: libc::c_int,
-        _buf: *const libc::c_void,
-        _len: usize,
-        _ssl_ptr: *mut sys::SSL,
+        write_p: libc::c_int,
+        mut version: libc::c_int,
+        content_type: libc::c_int,
+        buf: *const libc::c_void,
+        len: usize,
+        ssl_ptr: *mut sys::SSL,
         _arg: *mut libc::c_void,
     ) {
-        // Intentionally empty to avoid deadlocks
+        if ssl_ptr.is_null() {
+            return;
+        }
+
+        unsafe {
+            // Get SSL socket from SSL_get_ex_data (index 0)
+            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, 0);
+            if ssl_socket_ptr.is_null() {
+                return;
+            }
+
+            // ssl_socket_ptr is a pointer to Py<PySslSocket>, set in _wrap_socket/_wrap_bio
+            let ssl_socket: &Py<PySslSocket> = &*(ssl_socket_ptr as *const Py<PySslSocket>);
+
+            // Get the callback from the context
+            let callback_opt = ssl_socket.ctx.read().msg_callback.lock().clone();
+            let Some(callback) = callback_opt else {
+                return;
+            };
+
+            // Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)
+            let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {
+                // VM not available - this shouldn't happen during handshake
+                return;
+            };
+            let vm = &*vm_ptr;
+
+            // Get SSL socket owner object
+            let ssl_socket_obj = ssl_socket
+                .owner
+                .read()
+                .as_ref()
+                .and_then(|weak| weak.upgrade())
+                .unwrap_or_else(|| vm.ctx.none());
+
+            // Create the message bytes
+            let buf_slice = std::slice::from_raw_parts(buf as *const u8, len);
+            let msg_bytes = vm.ctx.new_bytes(buf_slice.to_vec());
+
+            // Determine direction string
+            let direction_str = if write_p != 0 { "write" } else { "read" };
+
+            // Calculate msg_type based on content_type (debughelpers.c behavior)
+            let msg_type = match content_type {
+                SSL3_RT_CHANGE_CIPHER_SPEC => SSL3_MT_CHANGE_CIPHER_SPEC,
+                SSL3_RT_ALERT => {
+                    // byte 1 is alert type
+                    if len >= 2 { buf_slice[1] as i32 } else { -1 }
+                }
+                SSL3_RT_HANDSHAKE => {
+                    // byte 0 is handshake type
+                    if !buf_slice.is_empty() {
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                SSL3_RT_HEADER => {
+                    // Frame header: version in bytes 1..2, type in byte 0
+                    if len >= 3 {
+                        version = ((buf_slice[1] as i32) << 8) | (buf_slice[2] as i32);
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                SSL3_RT_INNER_CONTENT_TYPE => {
+                    // Inner content type in byte 0
+                    if !buf_slice.is_empty() {
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                _ => -1,
+            };
+
+            // Call the Python callback
+            // Signature: callback(conn, direction, version, content_type, msg_type, data)
+            match callback.call(
+                (
+                    ssl_socket_obj,
+                    vm.ctx.new_str(direction_str),
+                    vm.ctx.new_int(version),
+                    vm.ctx.new_int(content_type),
+                    vm.ctx.new_int(msg_type),
+                    msg_bytes,
+                ),
+                vm,
+            ) {
+                Ok(_) => {}
+                Err(exc) => {
+                    // Log the exception but don't propagate it
+                    vm.run_unraisable(exc, None, vm.ctx.none());
+                }
+            }
+        }
     }
 
     #[pyfunction(name = "RAND_pseudo_bytes")]
@@ -794,6 +894,7 @@ mod _ssl {
                 SslVerifyMode::NONE
             });
 
+            // Start with OP_ALL but remove options that CPython doesn't include by default
             let mut options = SslOptions::ALL & !SslOptions::DONT_INSERT_EMPTY_FRAGMENTS;
             if proto != SslVersion::Ssl2 {
                 options |= SslOptions::NO_SSLV2;
@@ -807,6 +908,8 @@ mod _ssl {
             options |= SslOptions::SINGLE_ECDH_USE;
             options |= SslOptions::ENABLE_MIDDLEBOX_COMPAT;
             builder.set_options(options);
+            // Remove NO_TLSv1 and NO_TLSv1_1 which newer OpenSSL adds to OP_ALL
+            builder.clear_options(SslOptions::NO_TLSV1 | SslOptions::NO_TLSV1_1);
 
             let mode = ssl::SslMode::ACCEPT_MOVING_WRITE_BUFFER | ssl::SslMode::AUTO_RETRY;
             builder.set_mode(mode);
@@ -1242,7 +1345,7 @@ mod _ssl {
             if let Some(cadata) = args.cadata {
                 let certs = match cadata {
                     Either::A(s) => {
-                        if !s.is_ascii() {
+                        if !s.as_str().is_ascii() {
                             return Err(invalid_cadata(vm));
                         }
                         X509::stack_from_pem(s.as_bytes())
@@ -1261,6 +1364,29 @@ mod _ssl {
             if args.cafile.is_some() || args.capath.is_some() {
                 let cafile_path = args.cafile.map(|p| p.to_path_buf(vm)).transpose()?;
                 let capath_path = args.capath.map(|p| p.to_path_buf(vm)).transpose()?;
+                // Check file/directory existence before calling OpenSSL to get proper errno
+                if let Some(ref path) = cafile_path {
+                    if !path.exists() {
+                        return Err(vm
+                            .new_os_subtype_error(
+                                vm.ctx.exceptions.file_not_found_error.to_owned(),
+                                Some(libc::ENOENT),
+                                format!("No such file or directory: '{}'", path.display()),
+                            )
+                            .upcast());
+                    }
+                }
+                if let Some(ref path) = capath_path {
+                    if !path.exists() {
+                        return Err(vm
+                            .new_os_subtype_error(
+                                vm.ctx.exceptions.file_not_found_error.to_owned(),
+                                Some(libc::ENOENT),
+                                format!("No such file or directory: '{}'", path.display()),
+                            )
+                            .upcast());
+                    }
+                }
                 ctx.load_verify_locations(cafile_path.as_deref(), capath_path.as_deref())
                     .map_err(|e| convert_openssl_error(vm, e))?;
             }
@@ -1387,7 +1513,7 @@ mod _ssl {
                         std::io::ErrorKind::NotFound => vm
                             .new_os_subtype_error(
                                 vm.ctx.exceptions.file_not_found_error.to_owned(),
-                                None,
+                                Some(libc::ENOENT),
                                 e.to_string(),
                             )
                             .upcast(),
@@ -1559,6 +1685,27 @@ mod _ssl {
             let mut ctx = self.builder();
             let key_path = keyfile.map(|path| path.to_path_buf(vm)).transpose()?;
             let cert_path = certfile.to_path_buf(vm)?;
+            // Check file existence before calling OpenSSL to get proper errno
+            if !cert_path.exists() {
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        Some(libc::ENOENT),
+                        format!("No such file or directory: '{}'", cert_path.display()),
+                    )
+                    .upcast());
+            }
+            if let Some(ref kp) = key_path {
+                if !kp.exists() {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.file_not_found_error.to_owned(),
+                            Some(libc::ENOENT),
+                            format!("No such file or directory: '{}'", kp.display()),
+                        )
+                        .upcast());
+                }
+            }
             ctx.set_certificate_chain_file(&cert_path)
                 .and_then(|()| {
                     ctx.set_private_key_file(
@@ -1623,7 +1770,7 @@ mod _ssl {
                     ));
                 }
                 if hostname_str.contains('\0') {
-                    return Err(vm.new_value_error("embedded null byte in server_hostname"));
+                    return Err(vm.new_type_error("embedded null character"));
                 }
                 let ip = hostname_str.parse::<std::net::IpAddr>();
                 if ip.is_err() {
@@ -1704,12 +1851,19 @@ mod _ssl {
             // Check if SNI callback is configured (minimize lock time)
             let has_sni_callback = zelf.sni_callback.lock().is_some();
 
-            // Set SNI callback data if needed (after releasing the lock)
-            if has_sni_callback {
-                let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
-                unsafe {
-                    let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
+            // Set up ex_data for callbacks
+            unsafe {
+                let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
+
+                // Store ssl_socket pointer in index 0 for msg_callback (like CPython's SSL_set_app_data)
+                // This is safe because ssl_socket owns the SSL object and outlives it
+                // We store a pointer to Py<PySslSocket>, which msg_callback can dereference
+                let py_ptr: *const Py<PySslSocket> = &*py_ref;
+                sys::SSL_set_ex_data(ssl_ptr, 0, py_ptr as *mut _);
 
+                // Set SNI callback data if needed
+                if has_sni_callback {
+                    let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
                     // Store callback data in SSL ex_data - use weak reference to avoid cycle
                     let callback_data = Box::new(SniCallbackData {
                         ssl_context: zelf.clone(),
@@ -1765,12 +1919,19 @@ mod _ssl {
             // Check if SNI callback is configured (minimize lock time)
             let has_sni_callback = zelf.sni_callback.lock().is_some();
 
-            // Set SNI callback data if needed (after releasing the lock)
-            if has_sni_callback {
-                let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
-                unsafe {
-                    let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
+            // Set up ex_data for callbacks
+            unsafe {
+                let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
 
+                // Store ssl_socket pointer in index 0 for msg_callback (like CPython's SSL_set_app_data)
+                // This is safe because ssl_socket owns the SSL object and outlives it
+                // We store a pointer to Py<PySslSocket>, which msg_callback can dereference
+                let py_ptr: *const Py<PySslSocket> = &*py_ref;
+                sys::SSL_set_ex_data(ssl_ptr, 0, py_ptr as *mut _);
+
+                // Set SNI callback data if needed
+                if has_sni_callback {
+                    let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
                     // Store callback data in SSL ex_data - use weak reference to avoid cycle
                     let callback_data = Box::new(SniCallbackData {
                         ssl_context: zelf.clone(),
@@ -1866,12 +2027,14 @@ mod _ssl {
                 Some(s) => s,
                 None => return SelectRet::Closed,
             };
-            let deadline = match &deadline {
+            // For blocking sockets without timeout, call sock_select with None timeout
+            // to actually block waiting for data instead of busy-looping
+            let timeout = match &deadline {
                 Ok(deadline) => match deadline.checked_duration_since(Instant::now()) {
-                    Some(deadline) => deadline,
+                    Some(d) => Some(d),
                     None => return SelectRet::TimedOut,
                 },
-                Err(true) => return SelectRet::IsBlocking,
+                Err(true) => None, // Blocking: no timeout, wait indefinitely
                 Err(false) => return SelectRet::Nonblocking,
             };
             let res = socket::sock_select(
@@ -1880,7 +2043,7 @@ mod _ssl {
                     SslNeeds::Read => socket::SelectKind::Read,
                     SslNeeds::Write => socket::SelectKind::Write,
                 },
-                Some(deadline),
+                timeout,
             );
             match res {
                 Ok(true) => SelectRet::TimedOut,
@@ -2017,6 +2180,14 @@ mod _ssl {
                 SslConnection::Bio(stream) => stream.get_shutdown(),
             }
         }
+
+        // Check if incoming BIO has EOF (for BIO mode only)
+        fn is_bio_eof(&self) -> bool {
+            match self {
+                SslConnection::Socket(_) => false,
+                SslConnection::Bio(stream) => stream.get_ref().inbio.eof_written.load(),
+            }
+        }
     }
 
     #[pyattr]
@@ -2172,17 +2343,21 @@ mod _ssl {
 
         #[pymethod]
         fn version(&self) -> Option<&'static str> {
-            let v = self.connection.read().ssl().version_str();
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            // Return None if handshake is not complete (CPython behavior)
+            if unsafe { sys::SSL_is_init_finished(ssl_ptr) } == 0 {
+                return None;
+            }
+            let v = unsafe { ssl::SslRef::from_ptr(ssl_ptr).version_str() };
             if v == "unknown" { None } else { Some(v) }
         }
 
         #[pymethod]
         fn cipher(&self) -> Option<CipherTuple> {
-            self.connection
-                .read()
-                .ssl()
-                .current_cipher()
-                .map(cipher_to_tuple)
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            unsafe { ssl::SslRef::from_ptr(ssl_ptr).current_cipher() }.map(cipher_to_tuple)
         }
 
         #[pymethod]
@@ -2195,14 +2370,15 @@ mod _ssl {
         fn shared_ciphers(&self, vm: &VirtualMachine) -> Option<PyListRef> {
             #[cfg(ossl110)]
             {
-                let stream = self.connection.read();
+                // Use thread-local SSL pointer during handshake to avoid deadlock
+                let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
                 unsafe {
-                    let server_ciphers = SSL_get_ciphers(stream.ssl().as_ptr());
+                    let server_ciphers = SSL_get_ciphers(ssl_ptr);
                     if server_ciphers.is_null() {
                         return None;
                     }
 
-                    let client_ciphers = SSL_get_client_ciphers(stream.ssl().as_ptr());
+                    let client_ciphers = SSL_get_client_ciphers(ssl_ptr);
                     if client_ciphers.is_null() {
                         return None;
                     }
@@ -2258,12 +2434,13 @@ mod _ssl {
         fn selected_alpn_protocol(&self) -> Option<String> {
             #[cfg(ossl102)]
             {
-                let stream = self.connection.read();
+                // Use thread-local SSL pointer during handshake to avoid deadlock
+                let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
                 unsafe {
                     let mut out: *const libc::c_uchar = std::ptr::null();
                     let mut outlen: libc::c_uint = 0;
 
-                    sys::SSL_get0_alpn_selected(stream.ssl().as_ptr(), &mut out, &mut outlen);
+                    sys::SSL_get0_alpn_selected(ssl_ptr, &mut out, &mut outlen);
 
                     if out.is_null() {
                         None
@@ -2343,42 +2520,53 @@ mod _ssl {
         }
 
         #[pymethod]
-        fn shutdown(&self, vm: &VirtualMachine) -> PyResult<PyRef<PySocket>> {
+        fn shutdown(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PySocket>>> {
             let stream = self.connection.read();
-
-            // BIO mode doesn't have an underlying socket
-            if stream.is_bio() {
-                return Err(vm.new_not_implemented_error(
-                    "shutdown() is not supported for BIO-based SSL objects".to_owned(),
-                ));
-            }
-
             let ssl_ptr = stream.ssl().as_ptr();
 
-            // Perform SSL shutdown
-            let ret = unsafe { sys::SSL_shutdown(ssl_ptr) };
+            // Perform SSL shutdown - may need to be called twice:
+            // 1st call: sends close-notify, returns 0
+            // 2nd call: reads peer's close-notify, returns 1
+            let mut ret = unsafe { sys::SSL_shutdown(ssl_ptr) };
+
+            // If ret == 0, try once more to complete the bidirectional shutdown
+            // This handles the case where peer's close-notify is already available
+            if ret == 0 {
+                ret = unsafe { sys::SSL_shutdown(ssl_ptr) };
+            }
 
             if ret < 0 {
                 // Error occurred
                 let err = unsafe { sys::SSL_get_error(ssl_ptr, ret) };
 
-                if err == sys::SSL_ERROR_WANT_READ || err == sys::SSL_ERROR_WANT_WRITE {
-                    // Non-blocking would block - this is okay for shutdown
-                    // Return the underlying socket
+                if err == sys::SSL_ERROR_WANT_READ {
+                    return Err(create_ssl_want_read_error(vm).upcast());
+                } else if err == sys::SSL_ERROR_WANT_WRITE {
+                    return Err(create_ssl_want_write_error(vm).upcast());
                 } else {
                     return Err(new_ssl_error(
                         vm,
                         format!("SSL shutdown failed: error code {}", err),
                     ));
                 }
+            } else if ret == 0 {
+                // Still waiting for peer's close-notify after retry
+                // In BIO mode, raise SSLWantReadError
+                if stream.is_bio() {
+                    return Err(create_ssl_want_read_error(vm).upcast());
+                }
+            }
+
+            // BIO mode doesn't have an underlying socket to return
+            if stream.is_bio() {
+                return Ok(None);
             }
 
-            // Return the underlying socket
-            // Get the socket from the stream (SocketStream wraps PyRef<PySocket>)
+            // Return the underlying socket for socket mode
             let socket = stream
                 .get_ref()
                 .expect("unwrap() called on bio mode; should only be called in socket mode");
-            Ok(socket.0.clone())
+            Ok(Some(socket.0.clone()))
         }
 
         #[cfg(osslconf = "OPENSSL_NO_COMP")]
@@ -2389,8 +2577,9 @@ mod _ssl {
         #[cfg(not(osslconf = "OPENSSL_NO_COMP"))]
         #[pymethod]
         fn compression(&self) -> Option<&'static str> {
-            let stream = self.connection.read();
-            let comp_method = unsafe { sys::SSL_get_current_compression(stream.ssl().as_ptr()) };
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            let comp_method = unsafe { sys::SSL_get_current_compression(ssl_ptr) };
             if comp_method.is_null() {
                 return None;
             }
@@ -2416,7 +2605,7 @@ mod _ssl {
                 let result = stream.do_handshake().map_err(|e| {
                     let exc = convert_ssl_error(vm, e);
                     // If it's a cert verification error, set verify info
-                    if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) {
+                    if exc.class().is(PySSLCertVerificationError::class(&vm.ctx)) {
                         set_verify_error_info(&exc, ssl_ptr, vm);
                     }
                     exc
@@ -2473,7 +2662,7 @@ mod _ssl {
                 }
                 let exc = convert_ssl_error(vm, err);
                 // If it's a cert verification error, set verify info
-                if exc.class().is(PySslCertVerificationError::class(&vm.ctx)) {
+                if exc.class().is(PySSLCertVerificationError::class(&vm.ctx)) {
                     set_verify_error_info(&exc, ssl_ptr, vm);
                 }
                 // Clean up SNI ex_data before returning error
@@ -2603,19 +2792,41 @@ mod _ssl {
 
         #[pygetset]
         fn session_reused(&self) -> bool {
-            let stream = self.connection.read();
-            unsafe { sys::SSL_session_reused(stream.ssl().as_ptr()) != 0 }
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            unsafe { sys::SSL_session_reused(ssl_ptr) != 0 }
         }
 
         #[pymethod]
         fn read(
             &self,
-            n: usize,
+            n: isize,
             buffer: OptionalArg<ArgMemoryBuffer>,
             vm: &VirtualMachine,
         ) -> PyResult {
+            // Handle negative n:
+            // - If buffer is None and n < 0: raise ValueError
+            // - If buffer is present and n <= 0: use buffer length
+            // This matches _ssl__SSLSocket_read_impl in CPython
+            let read_len: usize = match &buffer {
+                OptionalArg::Present(buf) => {
+                    let buf_len = buf.borrow_buf_mut().len();
+                    if n <= 0 || (n as usize) > buf_len {
+                        buf_len
+                    } else {
+                        n as usize
+                    }
+                }
+                OptionalArg::Missing => {
+                    if n < 0 {
+                        return Err(vm.new_value_error("size should not be negative".to_owned()));
+                    }
+                    n as usize
+                }
+            };
+
             // Special case: reading 0 bytes should return empty bytes immediately
-            if n == 0 {
+            if read_len == 0 {
                 return if buffer.is_present() {
                     Ok(vm.ctx.new_int(0).into())
                 } else {
@@ -2627,13 +2838,13 @@ mod _ssl {
             let mut inner_buffer = if let OptionalArg::Present(buffer) = &buffer {
                 Either::A(buffer.borrow_buf_mut())
             } else {
-                Either::B(vec![0u8; n])
+                Either::B(vec![0u8; read_len])
             };
             let buf = match &mut inner_buffer {
                 Either::A(b) => &mut **b,
                 Either::B(b) => b.as_mut_slice(),
             };
-            let buf = match buf.get_mut(..n) {
+            let buf = match buf.get_mut(..read_len) {
                 Some(b) => b,
                 None => buf,
             };
@@ -2642,7 +2853,18 @@ mod _ssl {
             let count = if stream.is_bio() {
                 match stream.ssl_read(buf) {
                     Ok(count) => count,
-                    Err(e) => return Err(convert_ssl_error(vm, e)),
+                    Err(e) => {
+                        // Handle ZERO_RETURN (EOF) - raise SSLEOFError
+                        if e.code() == ssl::ErrorCode::ZERO_RETURN {
+                            return Err(create_ssl_eof_error(vm).upcast());
+                        }
+                        // If WANT_READ and the incoming BIO has EOF written,
+                        // this is an unexpected EOF (transport closed without TLS close_notify)
+                        if e.code() == ssl::ErrorCode::WANT_READ && stream.is_bio_eof() {
+                            return Err(create_ssl_eof_error(vm).upcast());
+                        }
+                        return Err(convert_ssl_error(vm, e));
+                    }
                 }
             } else {
                 // Socket mode: handle timeout and blocking
@@ -3051,22 +3273,10 @@ mod _ssl {
                 let len = size.unwrap_or(-1);
                 let len = if len < 0 || len > avail { avail } else { len };
 
-                // Check if EOF has been written and no data available
-                // This matches CPython's behavior where read() returns b'' when EOF is set
-                if len == 0 && self.eof_written.load() {
-                    return Ok(Vec::new());
-                }
-
+                // When no data available, return empty bytes (CPython behavior)
+                // CPython returns empty bytes directly without calling BIO_read()
                 if len == 0 {
-                    // No data available and no EOF - would block
-                    // Call BIO_read() to get the proper error (SSL_ERROR_WANT_READ)
-                    let mut test_buf = [0u8; 1];
-                    let nbytes = sys::BIO_read(self.bio, test_buf.as_mut_ptr() as *mut _, 1);
-                    if nbytes < 0 {
-                        return Err(convert_openssl_error(vm, ErrorStack::get()));
-                    }
-                    // Shouldn't reach here, but if we do, return what we got
-                    return Ok(test_buf[..nbytes as usize].to_vec());
+                    return Ok(Vec::new());
                 }
 
                 let mut buf = vec![0u8; len as usize];
@@ -3175,7 +3385,7 @@ mod _ssl {
 
     /// Helper function to create SSL error with proper OSError subtype handling
     fn new_ssl_error(vm: &VirtualMachine, msg: impl ToString) -> PyBaseExceptionRef {
-        vm.new_os_subtype_error(PySslError::class(&vm.ctx).to_owned(), None, msg.to_string())
+        vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), None, msg.to_string())
             .upcast()
     }
 
@@ -3235,9 +3445,9 @@ mod _ssl {
 
                 // Use SSLCertVerificationError for certificate verification failures
                 let cls = if is_cert_verify_error {
-                    PySslCertVerificationError::class(&vm.ctx).to_owned()
+                    PySSLCertVerificationError::class(&vm.ctx).to_owned()
                 } else {
-                    PySslError::class(&vm.ctx).to_owned()
+                    PySSLError::class(&vm.ctx).to_owned()
                 };
 
                 // Build message
@@ -3278,7 +3488,7 @@ mod _ssl {
                 )
             }
             None => {
-                let cls = PySslError::class(&vm.ctx).to_owned();
+                let cls = PySSLError::class(&vm.ctx).to_owned();
                 vm.new_os_subtype_error(cls, None, "unknown SSL error")
                     .upcast()
             }
@@ -3317,27 +3527,18 @@ mod _ssl {
     ) -> PyBaseExceptionRef {
         let e = e.borrow();
         let (cls, msg) = match e.code() {
-            ssl::ErrorCode::WANT_READ => (
-                PySslWantReadError::class(&vm.ctx).to_owned(),
-                "The operation did not complete (read)",
-            ),
-            ssl::ErrorCode::WANT_WRITE => (
-                PySslWantWriteError::class(&vm.ctx).to_owned(),
-                "The operation did not complete (write)",
-            ),
+            ssl::ErrorCode::WANT_READ => {
+                return create_ssl_want_read_error(vm).upcast();
+            }
+            ssl::ErrorCode::WANT_WRITE => {
+                return create_ssl_want_write_error(vm).upcast();
+            }
             ssl::ErrorCode::SYSCALL => match e.io_error() {
                 Some(io_err) => return io_err.to_pyexception(vm),
                 // When no I/O error and OpenSSL error queue is empty,
                 // this is an EOF in violation of protocol -> SSLEOFError
-                // Need to set args[0] = SSL_ERROR_EOF for suppress_ragged_eofs check
                 None => {
-                    return vm
-                        .new_os_subtype_error(
-                            PySslEOFError::class(&vm.ctx).to_owned(),
-                            Some(SSL_ERROR_EOF as i32),
-                            "EOF occurred in violation of protocol",
-                        )
-                        .upcast();
+                    return create_ssl_eof_error(vm).upcast();
                 }
             },
             ssl::ErrorCode::SSL => {
@@ -3350,24 +3551,18 @@ mod _ssl {
                         let reason = sys::ERR_GET_REASON(err_code);
                         let lib = sys::ERR_GET_LIB(err_code);
                         if lib == ERR_LIB_SSL && reason == SSL_R_UNEXPECTED_EOF_WHILE_READING {
-                            return vm
-                                .new_os_subtype_error(
-                                    PySslEOFError::class(&vm.ctx).to_owned(),
-                                    Some(SSL_ERROR_EOF as i32),
-                                    "EOF occurred in violation of protocol",
-                                )
-                                .upcast();
+                            return create_ssl_eof_error(vm).upcast();
                         }
                     }
                     return convert_openssl_error(vm, ssl_err.clone());
                 }
                 (
-                    PySslError::class(&vm.ctx).to_owned(),
+                    PySSLError::class(&vm.ctx).to_owned(),
                     "A failure in the SSL library occurred",
                 )
             }
             _ => (
-                PySslError::class(&vm.ctx).to_owned(),
+                PySSLError::class(&vm.ctx).to_owned(),
                 "A failure in the SSL library occurred",
             ),
         };
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 992b32e00ea..bf25260ed3a 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -207,28 +207,6 @@ mod _ssl {
     #[pyattr]
     const OP_ALL: i32 = 0x00000BFB; // Combined "safe" options (reduced for i32, excluding OP_LEGACY_SERVER_CONNECT for OpenSSL 3.0.0+ compatibility)
 
-    // Error types
-    #[pyattr]
-    const SSL_ERROR_NONE: i32 = 0;
-    #[pyattr]
-    const SSL_ERROR_SSL: i32 = 1;
-    #[pyattr]
-    const SSL_ERROR_WANT_READ: i32 = 2;
-    #[pyattr]
-    const SSL_ERROR_WANT_WRITE: i32 = 3;
-    #[pyattr]
-    const SSL_ERROR_WANT_X509_LOOKUP: i32 = 4;
-    #[pyattr]
-    const SSL_ERROR_SYSCALL: i32 = 5;
-    #[pyattr]
-    const SSL_ERROR_ZERO_RETURN: i32 = 6;
-    #[pyattr]
-    const SSL_ERROR_WANT_CONNECT: i32 = 7;
-    #[pyattr]
-    const SSL_ERROR_EOF: i32 = 8;
-    #[pyattr]
-    const SSL_ERROR_INVALID_ERROR_CODE: i32 = 10;
-
     // Alert types (matching _TLSAlertType enum)
     #[pyattr]
     const ALERT_DESCRIPTION_CLOSE_NOTIFY: i32 = 0;
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index ab3c81b7a4e..cd927a0e410 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -1397,8 +1397,21 @@ pub(super) fn ssl_read(
             return Ok(n);
         }
 
-        // No plaintext available and cannot read more TLS records
+        // No plaintext available and rustls doesn't want to read more TLS records
         if !needs_more_tls {
+            // Check if connection needs to write data first (e.g., TLS key update, renegotiation)
+            // This mirrors the handshake logic which checks both wants_read() and wants_write()
+            if conn.wants_write() && !is_bio {
+                // Flush pending TLS data before continuing
+                let tls_data = ssl_write_tls_records(conn)?;
+                if !tls_data.is_empty() {
+                    socket.sock_send(tls_data, vm).map_err(SslError::Py)?;
+                }
+                // After flushing, rustls may want to read again - continue loop
+                continue;
+            }
+
+            // BIO mode: check for EOF
             if is_bio && let Some(bio_obj) = socket.incoming_bio() {
                 let is_eof = bio_obj
                     .get_attr("eof", vm)
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
index e31683ec72d..bef9ba513d7 100644
--- a/crates/stdlib/src/ssl/error.rs
+++ b/crates/stdlib/src/ssl/error.rs
@@ -10,9 +10,27 @@ pub(crate) mod ssl_error {
         types::Constructor,
     };
 
-    // Error type constants (needed for create_ssl_want_read_error etc.)
+    // Error type constants - exposed as pyattr and available for internal use
+    #[pyattr]
+    pub(crate) const SSL_ERROR_NONE: i32 = 0;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_SSL: i32 = 1;
+    #[pyattr]
     pub(crate) const SSL_ERROR_WANT_READ: i32 = 2;
+    #[pyattr]
     pub(crate) const SSL_ERROR_WANT_WRITE: i32 = 3;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_X509_LOOKUP: i32 = 4;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_SYSCALL: i32 = 5;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_ZERO_RETURN: i32 = 6;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_CONNECT: i32 = 7;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_EOF: i32 = 8;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_INVALID_ERROR_CODE: i32 = 10;
 
     #[pyattr]
     #[pyexception(name = "SSLError", base = PyOSError)]
@@ -102,7 +120,7 @@ pub(crate) mod ssl_error {
     pub fn create_ssl_eof_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
         vm.new_os_subtype_error(
             PySSLEOFError::class(&vm.ctx).to_owned(),
-            None,
+            Some(SSL_ERROR_EOF),
             "EOF occurred in violation of protocol",
         )
     }
@@ -110,7 +128,7 @@ pub(crate) mod ssl_error {
     pub fn create_ssl_zero_return_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
         vm.new_os_subtype_error(
             PySSLZeroReturnError::class(&vm.ctx).to_owned(),
-            None,
+            Some(SSL_ERROR_ZERO_RETURN),
             "TLS/SSL connection has been closed (EOF)",
         )
     }

From 898fe85f40b1c38b117688f96b2f02786a524194 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 21 Dec 2025 00:38:50 +0900
Subject: [PATCH 018/418] More openssl impl  (#6464)

* Add openssl build to CI

* more openssl impls
---
 .cspell.dict/cpython.txt          |   1 +
 .github/workflows/ci.yaml         |   5 +
 crates/stdlib/src/openssl.rs      | 450 ++++++++++++++++++++++++------
 crates/stdlib/src/openssl/cert.rs | 168 +++++++++--
 4 files changed, 520 insertions(+), 104 deletions(-)

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 8acb1468f66..8ccd6d6b641 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -17,6 +17,7 @@ cmpop
 denom
 DICTFLAG
 dictoffset
+distpoint
 elts
 excepthandler
 fileutils
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8539db1a27e..783e3dfa6b3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -147,6 +147,11 @@ jobs:
       - name: check compilation without threading
         run: cargo check ${{ env.CARGO_ARGS }}
 
+      - name: Test openssl build
+        run:
+          cargo build --no-default-features --features ssl-openssl
+        if: runner.os == 'Linux'
+
       - name: Test example projects
         run:
           cargo run --manifest-path example_projects/barebone/Cargo.toml
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index b6d5f5c2035..4d420e7d539 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -64,7 +64,7 @@ mod _ssl {
         },
         socket::{self, PySocket},
         vm::{
-            AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+            AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
             builtins::{
                 PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType,
                 PyWeak,
@@ -73,8 +73,8 @@ mod _ssl {
             convert::ToPyException,
             exceptions,
             function::{
-                ArgBytesLike, ArgCallable, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath,
-                OptionalArg, PyComparisonValue,
+                ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath, OptionalArg,
+                PyComparisonValue,
             },
             types::{Comparable, Constructor, PyComparisonOp},
             utils::ToCString,
@@ -602,6 +602,39 @@ mod _ssl {
         }
     }
 
+    // Get or create an ex_data index for msg_callback data
+    fn get_msg_callback_ex_data_index() -> libc::c_int {
+        use std::sync::LazyLock;
+        static MSG_CB_EX_DATA_IDX: LazyLock<libc::c_int> = LazyLock::new(|| unsafe {
+            sys::SSL_get_ex_new_index(
+                0,
+                std::ptr::null_mut(),
+                None,
+                None,
+                Some(msg_callback_data_free),
+            )
+        });
+        *MSG_CB_EX_DATA_IDX
+    }
+
+    // Free function for msg_callback data - called by OpenSSL when SSL is freed
+    unsafe extern "C" fn msg_callback_data_free(
+        _parent: *mut libc::c_void,
+        ptr: *mut libc::c_void,
+        _ad: *mut sys::CRYPTO_EX_DATA,
+        _idx: libc::c_int,
+        _argl: libc::c_long,
+        _argp: *mut libc::c_void,
+    ) {
+        if !ptr.is_null() {
+            unsafe {
+                // Reconstruct PyObjectRef and drop to decrement reference count
+                let raw = std::ptr::NonNull::new_unchecked(ptr as *mut PyObject);
+                let _ = PyObjectRef::from_raw(raw);
+            }
+        }
+    }
+
     // SNI callback function called by OpenSSL
     unsafe extern "C" fn _servername_callback(
         ssl_ptr: *mut sys::SSL,
@@ -732,13 +765,14 @@ mod _ssl {
         }
 
         unsafe {
-            // Get SSL socket from SSL_get_ex_data (index 0)
-            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, 0);
+            // Get SSL socket from ex_data using the dedicated index
+            let idx = get_msg_callback_ex_data_index();
+            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
             if ssl_socket_ptr.is_null() {
                 return;
             }
 
-            // ssl_socket_ptr is a pointer to Py<PySslSocket>, set in _wrap_socket/_wrap_bio
+            // ssl_socket_ptr is a pointer to Box<Py<PySslSocket>>, set in _wrap_socket/_wrap_bio
             let ssl_socket: &Py<PySslSocket> = &*(ssl_socket_ptr as *const Py<PySslSocket>);
 
             // Get the callback from the context
@@ -849,6 +883,9 @@ mod _ssl {
         post_handshake_auth: PyMutex<bool>,
         sni_callback: PyMutex<Option<PyObjectRef>>,
         msg_callback: PyMutex<Option<PyObjectRef>>,
+        psk_client_callback: PyMutex<Option<PyObjectRef>>,
+        psk_server_callback: PyMutex<Option<PyObjectRef>>,
+        psk_identity_hint: PyMutex<Option<String>>,
     }
 
     impl fmt::Debug for PySslContext {
@@ -960,6 +997,9 @@ mod _ssl {
                 post_handshake_auth: PyMutex::new(false),
                 sni_callback: PyMutex::new(None),
                 msg_callback: PyMutex::new(None),
+                psk_client_callback: PyMutex::new(None),
+                psk_server_callback: PyMutex::new(None),
+                psk_identity_hint: PyMutex::new(None),
             })
         }
     }
@@ -1083,9 +1123,26 @@ mod _ssl {
             self.ctx.read().options().bits() as _
         }
         #[pygetset(setter)]
-        fn set_options(&self, opts: libc::c_ulong) {
-            self.builder()
-                .set_options(SslOptions::from_bits_truncate(opts as _));
+        fn set_options(&self, new_opts: libc::c_ulong) {
+            let mut ctx = self.builder();
+            // Get current options
+            let current = ctx.options().bits() as libc::c_ulong;
+
+            // Calculate options to clear and set
+            let clear = current & !new_opts;
+            let set = !current & new_opts;
+
+            // Clear options first (using raw FFI since openssl crate doesn't expose clear_options)
+            if clear != 0 {
+                unsafe {
+                    sys::SSL_CTX_clear_options(ctx.as_ptr(), clear);
+                }
+            }
+
+            // Then set new options
+            if set != 0 {
+                ctx.set_options(SslOptions::from_bits_truncate(set as _));
+            }
         }
         #[pygetset]
         fn protocol(&self) -> i32 {
@@ -1312,7 +1369,7 @@ mod _ssl {
                         ssl::select_next_proto(&server, client).ok_or(ssl::AlpnError::NOACK)?;
                     let pos = memchr::memmem::find(client, proto)
                         .expect("selected alpn proto should be present in client protos");
-                    Ok(&client[pos..proto.len()])
+                    Ok(&client[pos..pos + proto.len()])
                 });
                 Ok(())
             }
@@ -1324,6 +1381,78 @@ mod _ssl {
             }
         }
 
+        #[pymethod]
+        fn set_psk_client_callback(
+            &self,
+            callback: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Cannot add PSK client callback to a server context
+            if self.protocol == SslVersion::TlsServer {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot add PSK client callback to a PROTOCOL_TLS_SERVER context"
+                            .to_owned(),
+                    )
+                    .upcast());
+            }
+
+            if vm.is_none(&callback) {
+                *self.psk_client_callback.lock() = None;
+                unsafe {
+                    sys::SSL_CTX_set_psk_client_callback(self.builder().as_ptr(), None);
+                }
+            } else {
+                if !callback.is_callable() {
+                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                }
+                *self.psk_client_callback.lock() = Some(callback);
+                // Note: The actual callback will be invoked via SSL app_data mechanism
+                // when do_handshake is called
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_psk_server_callback(
+            &self,
+            callback: PyObjectRef,
+            identity_hint: OptionalArg<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Cannot add PSK server callback to a client context
+            if self.protocol == SslVersion::TlsClient {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot add PSK server callback to a PROTOCOL_TLS_CLIENT context"
+                            .to_owned(),
+                    )
+                    .upcast());
+            }
+
+            if vm.is_none(&callback) {
+                *self.psk_server_callback.lock() = None;
+                *self.psk_identity_hint.lock() = None;
+                unsafe {
+                    sys::SSL_CTX_set_psk_server_callback(self.builder().as_ptr(), None);
+                }
+            } else {
+                if !callback.is_callable() {
+                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                }
+                *self.psk_server_callback.lock() = Some(callback);
+                if let OptionalArg::Present(hint) = identity_hint {
+                    *self.psk_identity_hint.lock() = Some(hint.as_str().to_owned());
+                }
+                // Note: The actual callback will be invoked via SSL app_data mechanism
+            }
+            Ok(())
+        }
+
         #[pymethod]
         fn load_verify_locations(
             &self,
@@ -1343,16 +1472,33 @@ mod _ssl {
 
             // validate cadata type and load cadata
             if let Some(cadata) = args.cadata {
-                let certs = match cadata {
+                let (certs, is_pem) = match cadata {
                     Either::A(s) => {
                         if !s.as_str().is_ascii() {
                             return Err(invalid_cadata(vm));
                         }
-                        X509::stack_from_pem(s.as_bytes())
+                        (X509::stack_from_pem(s.as_bytes()), true)
                     }
-                    Either::B(b) => b.with_ref(x509_stack_from_der),
+                    Either::B(b) => (b.with_ref(x509_stack_from_der), false),
                 };
                 let certs = certs.map_err(|e| convert_openssl_error(vm, e))?;
+
+                // If no certificates were loaded, raise an error
+                if certs.is_empty() {
+                    let msg = if is_pem {
+                        "no start line: cadata does not contain a certificate"
+                    } else {
+                        "not enough data: cadata does not contain a certificate"
+                    };
+                    return Err(vm
+                        .new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            msg.to_owned(),
+                        )
+                        .upcast());
+                }
+
                 let store = ctx.cert_store_mut();
                 for cert in certs {
                     store
@@ -1365,27 +1511,27 @@ mod _ssl {
                 let cafile_path = args.cafile.map(|p| p.to_path_buf(vm)).transpose()?;
                 let capath_path = args.capath.map(|p| p.to_path_buf(vm)).transpose()?;
                 // Check file/directory existence before calling OpenSSL to get proper errno
-                if let Some(ref path) = cafile_path {
-                    if !path.exists() {
-                        return Err(vm
-                            .new_os_subtype_error(
-                                vm.ctx.exceptions.file_not_found_error.to_owned(),
-                                Some(libc::ENOENT),
-                                format!("No such file or directory: '{}'", path.display()),
-                            )
-                            .upcast());
-                    }
+                if let Some(ref path) = cafile_path
+                    && !path.exists()
+                {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.file_not_found_error.to_owned(),
+                            Some(libc::ENOENT),
+                            format!("No such file or directory: '{}'", path.display()),
+                        )
+                        .upcast());
                 }
-                if let Some(ref path) = capath_path {
-                    if !path.exists() {
-                        return Err(vm
-                            .new_os_subtype_error(
-                                vm.ctx.exceptions.file_not_found_error.to_owned(),
-                                Some(libc::ENOENT),
-                                format!("No such file or directory: '{}'", path.display()),
-                            )
-                            .upcast());
-                    }
+                if let Some(ref path) = capath_path
+                    && !path.exists()
+                {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.file_not_found_error.to_owned(),
+                            Some(libc::ENOENT),
+                            format!("No such file or directory: '{}'", path.display()),
+                        )
+                        .upcast());
                 }
                 ctx.load_verify_locations(cafile_path.as_deref(), capath_path.as_deref())
                     .map_err(|e| convert_openssl_error(vm, e))?;
@@ -1450,7 +1596,8 @@ mod _ssl {
                         X509_LU_X509 => {
                             x509_count += 1;
                             let x509_ptr = sys::X509_OBJECT_get0_X509(obj_ptr);
-                            if !x509_ptr.is_null() && X509_check_ca(x509_ptr) == 1 {
+                            // X509_check_ca returns non-zero for any CA type
+                            if !x509_ptr.is_null() && X509_check_ca(x509_ptr) != 0 {
                                 ca_count += 1;
                             }
                         }
@@ -1673,18 +1820,19 @@ mod _ssl {
 
         #[pymethod]
         fn load_cert_chain(&self, args: LoadCertChainArgs, vm: &VirtualMachine) -> PyResult<()> {
+            use openssl::pkey::PKey;
+            use std::cell::RefCell;
+
             let LoadCertChainArgs {
                 certfile,
                 keyfile,
                 password,
             } = args;
-            // TODO: requires passing a callback to C
-            if password.is_some() {
-                return Err(vm.new_not_implemented_error("password arg not yet supported"));
-            }
+
             let mut ctx = self.builder();
             let key_path = keyfile.map(|path| path.to_path_buf(vm)).transpose()?;
             let cert_path = certfile.to_path_buf(vm)?;
+
             // Check file existence before calling OpenSSL to get proper errno
             if !cert_path.exists() {
                 return Err(vm
@@ -1695,28 +1843,139 @@ mod _ssl {
                     )
                     .upcast());
             }
-            if let Some(ref kp) = key_path {
-                if !kp.exists() {
-                    return Err(vm
-                        .new_os_subtype_error(
-                            vm.ctx.exceptions.file_not_found_error.to_owned(),
-                            Some(libc::ENOENT),
-                            format!("No such file or directory: '{}'", kp.display()),
-                        )
-                        .upcast());
-                }
+            if let Some(ref kp) = key_path
+                && !kp.exists()
+            {
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        Some(libc::ENOENT),
+                        format!("No such file or directory: '{}'", kp.display()),
+                    )
+                    .upcast());
             }
+
+            // Load certificate chain
             ctx.set_certificate_chain_file(&cert_path)
-                .and_then(|()| {
-                    ctx.set_private_key_file(
-                        key_path.as_ref().unwrap_or(&cert_path),
-                        ssl::SslFiletype::PEM,
-                    )
-                })
-                .and_then(|()| ctx.check_private_key())
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Load private key - handle password if provided
+            let key_file_path = key_path.as_ref().unwrap_or(&cert_path);
+
+            // PEM_BUFSIZE = 1024 (maximum password length in OpenSSL)
+            const PEM_BUFSIZE: usize = 1024;
+
+            // Read key file data
+            let key_data = std::fs::read(key_file_path)
+                .map_err(|e| crate::vm::convert::ToPyException::to_pyexception(&e, vm))?;
+
+            let pkey = if let Some(ref pw_obj) = password {
+                if pw_obj.is_callable() {
+                    // Callable password - use callback that calls Python function
+                    // Store any Python error that occurs in the callback
+                    let py_error: RefCell<Option<PyBaseExceptionRef>> = RefCell::new(None);
+
+                    let result = PKey::private_key_from_pem_callback(&key_data, |buf| {
+                        // Call the Python password callback
+                        let pw_result = pw_obj.call((), vm);
+                        match pw_result {
+                            Ok(result) => {
+                                // Extract password bytes
+                                match Self::extract_password_bytes(
+                                    &result,
+                                    "password callback must return a string",
+                                    vm,
+                                ) {
+                                    Ok(pw) => {
+                                        // Check password length
+                                        if pw.len() > PEM_BUFSIZE {
+                                            *py_error.borrow_mut() =
+                                                Some(vm.new_value_error(format!(
+                                                    "password cannot be longer than {} bytes",
+                                                    PEM_BUFSIZE
+                                                )));
+                                            return Err(openssl::error::ErrorStack::get());
+                                        }
+                                        let len = std::cmp::min(pw.len(), buf.len());
+                                        buf[..len].copy_from_slice(&pw[..len]);
+                                        Ok(len)
+                                    }
+                                    Err(e) => {
+                                        *py_error.borrow_mut() = Some(e);
+                                        Err(openssl::error::ErrorStack::get())
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                *py_error.borrow_mut() = Some(e);
+                                Err(openssl::error::ErrorStack::get())
+                            }
+                        }
+                    });
+
+                    // Check for Python error first
+                    if let Some(py_err) = py_error.into_inner() {
+                        return Err(py_err);
+                    }
+
+                    result.map_err(|e| convert_openssl_error(vm, e))?
+                } else {
+                    // Direct password (string/bytes)
+                    let pw = Self::extract_password_bytes(
+                        pw_obj,
+                        "password should be a string or bytes",
+                        vm,
+                    )?;
+
+                    // Check password length
+                    if pw.len() > PEM_BUFSIZE {
+                        return Err(vm.new_value_error(format!(
+                            "password cannot be longer than {} bytes",
+                            PEM_BUFSIZE
+                        )));
+                    }
+
+                    PKey::private_key_from_pem_passphrase(&key_data, &pw)
+                        .map_err(|e| convert_openssl_error(vm, e))?
+                }
+            } else {
+                // No password - use SSL_CTX_use_PrivateKey_file directly for correct error messages
+                ctx.set_private_key_file(key_file_path, ssl::SslFiletype::PEM)
+                    .map_err(|e| convert_openssl_error(vm, e))?;
+
+                // Verify key matches certificate and return early
+                return ctx
+                    .check_private_key()
+                    .map_err(|e| convert_openssl_error(vm, e));
+            };
+
+            ctx.set_private_key(&pkey)
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Verify key matches certificate
+            ctx.check_private_key()
                 .map_err(|e| convert_openssl_error(vm, e))
         }
 
+        // Helper to extract password bytes from string/bytes/bytearray
+        fn extract_password_bytes(
+            obj: &PyObject,
+            bad_type_error: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<Vec<u8>> {
+            use crate::vm::builtins::{PyByteArray, PyBytes, PyStr};
+
+            if let Some(s) = obj.downcast_ref::<PyStr>() {
+                Ok(s.as_str().as_bytes().to_vec())
+            } else if let Some(b) = obj.downcast_ref::<PyBytes>() {
+                Ok(b.as_bytes().to_vec())
+            } else if let Some(ba) = obj.downcast_ref::<PyByteArray>() {
+                Ok(ba.borrow_buf().to_vec())
+            } else {
+                Err(vm.new_type_error(bad_type_error.to_owned()))
+            }
+        }
+
         // Helper function to create SSL socket
         // = CPython's newPySSLSocket()
         fn new_py_ssl_socket(
@@ -1855,11 +2114,12 @@ mod _ssl {
             unsafe {
                 let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
 
-                // Store ssl_socket pointer in index 0 for msg_callback (like CPython's SSL_set_app_data)
-                // This is safe because ssl_socket owns the SSL object and outlives it
-                // We store a pointer to Py<PySslSocket>, which msg_callback can dereference
-                let py_ptr: *const Py<PySslSocket> = &*py_ref;
-                sys::SSL_set_ex_data(ssl_ptr, 0, py_ptr as *mut _);
+                // Clone and store via into_raw() - increments refcount and returns stable pointer
+                // The refcount will be decremented by msg_callback_data_free when SSL is freed
+                let cloned: PyObjectRef = py_ref.clone().into();
+                let raw_ptr = cloned.into_raw();
+                let msg_cb_idx = get_msg_callback_ex_data_index();
+                sys::SSL_set_ex_data(ssl_ptr, msg_cb_idx, raw_ptr.as_ptr() as *mut _);
 
                 // Set SNI callback data if needed
                 if has_sni_callback {
@@ -1869,8 +2129,8 @@ mod _ssl {
                         ssl_context: zelf.clone(),
                         ssl_socket_weak,
                     });
-                    let idx = get_sni_ex_data_index();
-                    sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _);
+                    let sni_idx = get_sni_ex_data_index();
+                    sys::SSL_set_ex_data(ssl_ptr, sni_idx, Box::into_raw(callback_data) as *mut _);
                 }
             }
 
@@ -1923,11 +2183,12 @@ mod _ssl {
             unsafe {
                 let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
 
-                // Store ssl_socket pointer in index 0 for msg_callback (like CPython's SSL_set_app_data)
-                // This is safe because ssl_socket owns the SSL object and outlives it
-                // We store a pointer to Py<PySslSocket>, which msg_callback can dereference
-                let py_ptr: *const Py<PySslSocket> = &*py_ref;
-                sys::SSL_set_ex_data(ssl_ptr, 0, py_ptr as *mut _);
+                // Clone and store via into_raw() - increments refcount and returns stable pointer
+                // The refcount will be decremented by msg_callback_data_free when SSL is freed
+                let cloned: PyObjectRef = py_ref.clone().into();
+                let raw_ptr = cloned.into_raw();
+                let msg_cb_idx = get_msg_callback_ex_data_index();
+                sys::SSL_set_ex_data(ssl_ptr, msg_cb_idx, raw_ptr.as_ptr() as *mut _);
 
                 // Set SNI callback data if needed
                 if has_sni_callback {
@@ -1937,8 +2198,8 @@ mod _ssl {
                         ssl_context: zelf.clone(),
                         ssl_socket_weak,
                     });
-                    let idx = get_sni_ex_data_index();
-                    sys::SSL_set_ex_data(ssl_ptr, idx, Box::into_raw(callback_data) as *mut _);
+                    let sni_idx = get_sni_ex_data_index();
+                    sys::SSL_set_ex_data(ssl_ptr, sni_idx, Box::into_raw(callback_data) as *mut _);
                 }
             }
 
@@ -1995,7 +2256,7 @@ mod _ssl {
         #[pyarg(any, optional)]
         keyfile: Option<FsPath>,
         #[pyarg(any, optional)]
-        password: Option<Either<PyStrRef, ArgCallable>>,
+        password: Option<PyObjectRef>,
     }
 
     // Err is true if the socket is blocking
@@ -2004,7 +2265,6 @@ mod _ssl {
     enum SelectRet {
         Nonblocking,
         TimedOut,
-        IsBlocking,
         Closed,
         Ok,
     }
@@ -2292,12 +2552,13 @@ mod _ssl {
         #[pymethod]
         fn get_unverified_chain(&self, vm: &VirtualMachine) -> PyResult<Option<PyListRef>> {
             let stream = self.connection.read();
-            let Some(chain) = stream.ssl().peer_cert_chain() else {
+            let ssl = stream.ssl();
+            let Some(chain) = ssl.peer_cert_chain() else {
                 return Ok(None);
             };
 
             // Return Certificate objects
-            let certs: Vec<PyObjectRef> = chain
+            let mut certs: Vec<PyObjectRef> = chain
                 .iter()
                 .map(|cert| unsafe {
                     sys::X509_up_ref(cert.as_ptr());
@@ -2305,6 +2566,16 @@ mod _ssl {
                     cert_to_certificate(vm, owned)
                 })
                 .collect::<PyResult<_>>()?;
+
+            // SSL_get_peer_cert_chain does not include peer cert for server-side sockets
+            // Add it manually at the beginning
+            if matches!(self.socket_type, SslServerOrClient::Server)
+                && let Some(peer_cert) = ssl.peer_certificate()
+            {
+                let peer_obj = cert_to_certificate(vm, peer_cert)?;
+                certs.insert(0, peer_obj);
+            }
+
             Ok(Some(vm.ctx.new_list(certs)))
         }
 
@@ -2652,7 +2923,7 @@ mod _ssl {
                         return Err(socket_closed_error(vm));
                     }
                     SelectRet::Nonblocking => {}
-                    SelectRet::IsBlocking | SelectRet::Ok => {
+                    SelectRet::Ok => {
                         // For blocking sockets, select() has completed successfully
                         // Continue the handshake loop (matches CPython's SOCKET_IS_BLOCKING behavior)
                         if needs.is_some() {
@@ -2719,7 +2990,7 @@ mod _ssl {
                     }
                     SelectRet::Closed => return Err(socket_closed_error(vm)),
                     SelectRet::Nonblocking => {}
-                    SelectRet::IsBlocking | SelectRet::Ok => {
+                    SelectRet::Ok => {
                         // For blocking sockets, select() has completed successfully
                         // Continue the write loop (matches CPython's SOCKET_IS_BLOCKING behavior)
                         if needs.is_some() {
@@ -2896,7 +3167,7 @@ mod _ssl {
                         }
                         SelectRet::Closed => return Err(socket_closed_error(vm)),
                         SelectRet::Nonblocking => {}
-                        SelectRet::IsBlocking | SelectRet::Ok => {
+                        SelectRet::Ok => {
                             // For blocking sockets, select() has completed successfully
                             // Continue the read loop (matches CPython's SOCKET_IS_BLOCKING behavior)
                             if needs.is_some() {
@@ -3576,30 +3847,33 @@ mod _ssl {
             let bio = bio::MemBioSlice::new(der)?;
 
             let mut certs = vec![];
+            let mut was_bio_eof = false;
 
             loop {
+                // Check for EOF before attempting to parse (like CPython's _add_ca_certs)
+                // BIO_ctrl with BIO_CTRL_EOF returns 1 if EOF, 0 otherwise
+                if sys::BIO_ctrl(bio.as_ptr(), sys::BIO_CTRL_EOF, 0, std::ptr::null_mut()) != 0 {
+                    was_bio_eof = true;
+                    break;
+                }
+
                 let cert = sys::d2i_X509_bio(bio.as_ptr(), std::ptr::null_mut());
                 if cert.is_null() {
+                    // Parse error (not just EOF)
                     break;
                 }
                 certs.push(X509::from_ptr(cert));
             }
 
-            if certs.is_empty() {
-                // No certificates loaded at all
+            // If we loaded some certs but didn't reach EOF, there's garbage data
+            // (like cacert_der + b"A") - this is an error
+            if !certs.is_empty() && !was_bio_eof {
+                // Return the error from the last failed parse attempt
                 return Err(ErrorStack::get());
             }
 
-            // Successfully loaded at least one certificate from DER data.
-            // Clear any trailing errors from EOF.
-            // CPython clears errors when:
-            // - DER: was_bio_eof is set (EOF reached)
-            // - PEM: PEM_R_NO_START_LINE error (normal EOF)
-            // Both cases mean successful completion with loaded certs.
-            eprintln!(
-                "[x509_stack_from_der] SUCCESS: Clearing errors and returning {} certs",
-                certs.len()
-            );
+            // Clear any errors (including parse errors when no certs loaded)
+            // Let the caller decide how to handle empty results
             sys::ERR_clear_error();
             Ok(certs)
         }
diff --git a/crates/stdlib/src/openssl/cert.rs b/crates/stdlib/src/openssl/cert.rs
index 1197bf4aa46..b63d824a837 100644
--- a/crates/stdlib/src/openssl/cert.rs
+++ b/crates/stdlib/src/openssl/cert.rs
@@ -5,16 +5,19 @@ pub(super) use ssl_cert::{PySSLCertificate, cert_to_certificate, cert_to_py, obj
 #[pymodule(sub)]
 pub(crate) mod ssl_cert {
     use crate::{
-        common::ascii,
+        common::{ascii, hash::PyHash},
         vm::{
-            PyObjectRef, PyPayload, PyResult, VirtualMachine,
+            Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+            class_or_notimplemented,
             convert::{ToPyException, ToPyObject},
-            function::{FsPath, OptionalArg},
+            function::{FsPath, OptionalArg, PyComparisonValue},
+            types::{Comparable, Hashable, PyComparisonOp, Representable},
         },
     };
     use foreign_types_shared::ForeignTypeRef;
     use openssl::{
         asn1::Asn1ObjectRef,
+        nid::Nid,
         x509::{self, X509, X509Ref},
     };
     use openssl_sys as sys;
@@ -54,7 +57,7 @@ pub(crate) mod ssl_cert {
     #[pyclass(module = "ssl", name = "Certificate")]
     #[derive(PyPayload)]
     pub(crate) struct PySSLCertificate {
-        cert: X509,
+        pub(crate) cert: X509,
     }
 
     impl fmt::Debug for PySSLCertificate {
@@ -63,7 +66,7 @@ pub(crate) mod ssl_cert {
         }
     }
 
-    #[pyclass]
+    #[pyclass(with(Comparable, Hashable, Representable))]
     impl PySSLCertificate {
         #[pymethod]
         fn public_bytes(
@@ -83,12 +86,14 @@ pub(crate) mod ssl_cert {
                     Ok(vm.ctx.new_bytes(der).into())
                 }
                 ENCODING_PEM => {
-                    // PEM encoding
+                    // PEM encoding - returns string
                     let pem = self
                         .cert
                         .to_pem()
                         .map_err(|e| convert_openssl_error(vm, e))?;
-                    Ok(vm.ctx.new_bytes(pem).into())
+                    let pem_str = String::from_utf8(pem)
+                        .map_err(|_| vm.new_value_error("Invalid UTF-8 in PEM"))?;
+                    Ok(vm.ctx.new_str(pem_str).into())
                 }
                 _ => Err(vm.new_value_error("Unsupported format")),
             }
@@ -100,6 +105,66 @@ pub(crate) mod ssl_cert {
         }
     }
 
+    impl Comparable for PySSLCertificate {
+        fn cmp(
+            zelf: &Py<Self>,
+            other: &PyObject,
+            op: PyComparisonOp,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyComparisonValue> {
+            let other = class_or_notimplemented!(Self, other);
+
+            // Only support equality comparison
+            if !matches!(op, PyComparisonOp::Eq | PyComparisonOp::Ne) {
+                return Ok(PyComparisonValue::NotImplemented);
+            }
+
+            // Compare DER encodings
+            let self_der = zelf
+                .cert
+                .to_der()
+                .map_err(|e| convert_openssl_error(vm, e))?;
+            let other_der = other
+                .cert
+                .to_der()
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            let eq = self_der == other_der;
+            Ok(op.eval_ord(eq.cmp(&true)).into())
+        }
+    }
+
+    impl Hashable for PySSLCertificate {
+        fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash> {
+            // Use subject name hash as certificate hash
+            let hash = unsafe { sys::X509_subject_name_hash(zelf.cert.as_ptr()) };
+            Ok(hash as PyHash)
+        }
+    }
+
+    impl Representable for PySSLCertificate {
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            // Build subject string like "CN=localhost, O=Python"
+            let subject = zelf.cert.subject_name();
+            let mut parts: Vec<String> = Vec::new();
+            for entry in subject.entries() {
+                // Use short name (SN) if available, otherwise use OID
+                let name = match entry.object().nid().short_name() {
+                    Ok(sn) => sn.to_string(),
+                    Err(_) => obj2txt(entry.object(), true).unwrap_or_default(),
+                };
+                if let Ok(value) = entry.data().as_utf8() {
+                    parts.push(format!("{}={}", name, value));
+                }
+            }
+            if parts.is_empty() {
+                Ok("<Certificate>".to_string())
+            } else {
+                Ok(format!("<Certificate '{}'>", parts.join(", ")))
+            }
+        }
+    }
+
     fn name_to_py(vm: &VirtualMachine, name: &x509::X509NameRef) -> PyResult {
         let list = name
             .entries()
@@ -133,11 +198,15 @@ pub(crate) mod ssl_cert {
             .to_bn()
             .and_then(|bn| bn.to_hex_str())
             .map_err(|e| convert_openssl_error(vm, e))?;
-        dict.set_item(
-            "serialNumber",
-            vm.ctx.new_str(serial_num.to_owned()).into(),
-            vm,
-        )?;
+        // Serial number must have even length (each byte = 2 hex chars)
+        // BigNum::to_hex_str() strips leading zeros, so we need to pad
+        let serial_str = serial_num.to_string();
+        let serial_str = if serial_str.len() % 2 == 1 {
+            format!("0{}", serial_str)
+        } else {
+            serial_str
+        };
+        dict.set_item("serialNumber", vm.ctx.new_str(serial_str).into(), vm)?;
 
         dict.set_item(
             "notBefore",
@@ -188,10 +257,23 @@ pub(crate) mod ssl_cert {
                             return vm.new_tuple((ascii!("DirName"), py_name)).into();
                         }
 
-                        // TODO: Handle Registered ID (GEN_RID)
-                        // CPython implementation uses i2t_ASN1_OBJECT to convert OID
-                        // This requires accessing GENERAL_NAME union which is complex in Rust
-                        // For now, we return <unsupported> for unhandled types
+                        // Check for Registered ID (GEN_RID)
+                        // Access raw GENERAL_NAME to check type
+                        let ptr = gen_name.as_ptr();
+                        unsafe {
+                            if (*ptr).type_ == sys::GEN_RID {
+                                // d is ASN1_OBJECT* for GEN_RID
+                                let oid_ptr = (*ptr).d as *const sys::ASN1_OBJECT;
+                                if !oid_ptr.is_null() {
+                                    let oid_ref = Asn1ObjectRef::from_ptr(oid_ptr as *mut _);
+                                    if let Some(oid_str) = obj2txt(oid_ref, true) {
+                                        return vm
+                                            .new_tuple((ascii!("Registered ID"), oid_str))
+                                            .into();
+                                    }
+                                }
+                            }
+                        }
 
                         // For othername and other unsupported types
                         vm.new_tuple((ascii!("othername"), ascii!("<unsupported>")))
@@ -202,6 +284,60 @@ pub(crate) mod ssl_cert {
             dict.set_item("subjectAltName", vm.ctx.new_tuple(san).into(), vm)?;
         };
 
+        // Authority Information Access: OCSP URIs
+        if let Ok(ocsp_list) = cert.ocsp_responders()
+            && !ocsp_list.is_empty()
+        {
+            let uris: Vec<PyObjectRef> = ocsp_list
+                .iter()
+                .map(|s| vm.ctx.new_str(s.to_string()).into())
+                .collect();
+            dict.set_item("OCSP", vm.ctx.new_tuple(uris).into(), vm)?;
+        }
+
+        // Authority Information Access: CA Issuers URIs
+        if let Some(aia) = cert.authority_info() {
+            let ca_issuers: Vec<PyObjectRef> = aia
+                .iter()
+                .filter_map(|ad| {
+                    // Check if method is CA Issuers (NID_ad_ca_issuers)
+                    if ad.method().nid() != Nid::AD_CA_ISSUERS {
+                        return None;
+                    }
+                    // Get URI from location
+                    ad.location()
+                        .uri()
+                        .map(|uri| vm.ctx.new_str(uri.to_owned()).into())
+                })
+                .collect();
+            if !ca_issuers.is_empty() {
+                dict.set_item("caIssuers", vm.ctx.new_tuple(ca_issuers).into(), vm)?;
+            }
+        }
+
+        // CRL Distribution Points
+        if let Some(crl_dps) = cert.crl_distribution_points() {
+            let mut crl_uris: Vec<PyObjectRef> = Vec::new();
+            for dp in crl_dps.iter() {
+                if let Some(dp_name) = dp.distpoint()
+                    && let Some(fullname) = dp_name.fullname()
+                {
+                    for gn in fullname.iter() {
+                        if let Some(uri) = gn.uri() {
+                            crl_uris.push(vm.ctx.new_str(uri.to_owned()).into());
+                        }
+                    }
+                }
+            }
+            if !crl_uris.is_empty() {
+                dict.set_item(
+                    "crlDistributionPoints",
+                    vm.ctx.new_tuple(crl_uris).into(),
+                    vm,
+                )?;
+            }
+        }
+
         Ok(dict.into())
     }
 

From 09fa97d1b91170d3b67c63a778aea19aacaff02d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 21 Dec 2025 00:54:05 +0900
Subject: [PATCH 019/418] CI to test Apple Intel (#6465)

---
 .github/workflows/ci.yaml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 783e3dfa6b3..a0947af853b 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -158,13 +158,13 @@ jobs:
           cargo run --manifest-path example_projects/frozen_stdlib/Cargo.toml
         if: runner.os == 'Linux'
 
-      - name: prepare AppleSilicon build
+      - name: prepare Intel MacOS build
         uses: dtolnay/rust-toolchain@stable
         with:
-          target: aarch64-apple-darwin
+          target: x86_64-apple-darwin
         if: runner.os == 'macOS'
-      - name: Check compilation for Apple Silicon
-        run: cargo check --target aarch64-apple-darwin
+      - name: Check compilation for Intel MacOS
+        run: cargo check --target x86_64-apple-darwin
         if: runner.os == 'macOS'
       - name: prepare iOS build
         uses: dtolnay/rust-toolchain@stable

From 8b3bf558fc9fb74bfea2344012b0fe5d52aa594f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 21 Dec 2025 08:25:17 +0900
Subject: [PATCH 020/418] Introduce PyConfig to implement Paths correctly
 (#6461)

* getpath

* introduce PyConfig

* landmark in getpath
---
 .cspell.dict/cpython.txt         |   1 +
 crates/stdlib/src/syslog.rs      |   2 +-
 crates/vm/src/getpath.rs         | 385 +++++++++++++++++++++++++++++++
 crates/vm/src/import.rs          |   2 +-
 crates/vm/src/lib.rs             |   1 +
 crates/vm/src/stdlib/builtins.rs |   4 +-
 crates/vm/src/stdlib/imp.rs      |   2 +-
 crates/vm/src/stdlib/io.rs       |   4 +-
 crates/vm/src/stdlib/signal.rs   |   2 +-
 crates/vm/src/stdlib/sys.rs      | 142 ++----------
 crates/vm/src/vm/compile.rs      |   2 +-
 crates/vm/src/vm/interpreter.rs  |  10 +-
 crates/vm/src/vm/mod.rs          |  28 +--
 crates/vm/src/vm/setting.rs      |  36 ++-
 src/interpreter.rs               |  16 +-
 src/lib.rs                       |  12 +-
 16 files changed, 487 insertions(+), 162 deletions(-)
 create mode 100644 crates/vm/src/getpath.rs

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 8ccd6d6b641..fbb467c94db 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -43,6 +43,7 @@ numer
 orelse
 pathconfig
 patma
+platstdlib
 posonlyarg
 posonlyargs
 prec
diff --git a/crates/stdlib/src/syslog.rs b/crates/stdlib/src/syslog.rs
index adba6f297ce..d0ed3f60949 100644
--- a/crates/stdlib/src/syslog.rs
+++ b/crates/stdlib/src/syslog.rs
@@ -26,7 +26,7 @@ mod syslog {
     use libc::{LOG_AUTHPRIV, LOG_CRON, LOG_PERROR};
 
     fn get_argv(vm: &VirtualMachine) -> Option<PyStrRef> {
-        if let Some(argv) = vm.state.settings.argv.first()
+        if let Some(argv) = vm.state.config.settings.argv.first()
             && !argv.is_empty()
         {
             return Some(
diff --git a/crates/vm/src/getpath.rs b/crates/vm/src/getpath.rs
new file mode 100644
index 00000000000..423b9b54136
--- /dev/null
+++ b/crates/vm/src/getpath.rs
@@ -0,0 +1,385 @@
+//! Path configuration for RustPython (ref: Modules/getpath.py)
+//!
+//! This module implements Python path calculation logic following getpath.py.
+//! It uses landmark-based search to locate prefix, exec_prefix, and stdlib directories.
+//!
+//! The main entry point is `init_path_config()` which computes Paths from Settings.
+
+use crate::vm::{Paths, Settings};
+use std::env;
+use std::path::{Path, PathBuf};
+
+// Platform-specific landmarks (ref: getpath.py PLATFORM CONSTANTS)
+
+#[cfg(not(windows))]
+mod platform {
+    use crate::version;
+
+    pub const BUILDDIR_TXT: &str = "pybuilddir.txt";
+    pub const BUILD_LANDMARK: &str = "Modules/Setup.local";
+    pub const VENV_LANDMARK: &str = "pyvenv.cfg";
+    pub const BUILDSTDLIB_LANDMARK: &str = "Lib/os.py";
+
+    pub fn stdlib_subdir() -> String {
+        format!("lib/python{}.{}", version::MAJOR, version::MINOR)
+    }
+
+    pub fn stdlib_landmarks() -> [String; 2] {
+        let subdir = stdlib_subdir();
+        [format!("{}/os.py", subdir), format!("{}/os.pyc", subdir)]
+    }
+
+    pub fn platstdlib_landmark() -> String {
+        format!(
+            "lib/python{}.{}/lib-dynload",
+            version::MAJOR,
+            version::MINOR
+        )
+    }
+
+    pub fn zip_landmark() -> String {
+        format!("lib/python{}{}.zip", version::MAJOR, version::MINOR)
+    }
+}
+
+#[cfg(windows)]
+mod platform {
+    use crate::version;
+
+    pub const BUILDDIR_TXT: &str = "pybuilddir.txt";
+    pub const BUILD_LANDMARK: &str = "Modules\\Setup.local";
+    pub const VENV_LANDMARK: &str = "pyvenv.cfg";
+    pub const BUILDSTDLIB_LANDMARK: &str = "Lib\\os.py";
+    pub const STDLIB_SUBDIR: &str = "Lib";
+
+    pub fn stdlib_landmarks() -> [String; 2] {
+        ["Lib\\os.py".into(), "Lib\\os.pyc".into()]
+    }
+
+    pub fn platstdlib_landmark() -> String {
+        "DLLs".into()
+    }
+
+    pub fn zip_landmark() -> String {
+        format!("python{}{}.zip", version::MAJOR, version::MINOR)
+    }
+}
+
+// Helper functions (ref: getpath.py HELPER FUNCTIONS)
+
+/// Search upward from a directory for landmark files/directories
+/// Returns the directory where a landmark was found
+fn search_up<P, F>(start: P, landmarks: &[&str], test: F) -> Option<PathBuf>
+where
+    P: AsRef<Path>,
+    F: Fn(&Path) -> bool,
+{
+    let mut current = start.as_ref().to_path_buf();
+    loop {
+        for landmark in landmarks {
+            let path = current.join(landmark);
+            if test(&path) {
+                return Some(current);
+            }
+        }
+        if !current.pop() {
+            return None;
+        }
+    }
+}
+
+/// Search upward for a file landmark
+fn search_up_file<P: AsRef<Path>>(start: P, landmarks: &[&str]) -> Option<PathBuf> {
+    search_up(start, landmarks, |p| p.is_file())
+}
+
+/// Search upward for a directory landmark
+#[cfg(not(windows))]
+fn search_up_dir<P: AsRef<Path>>(start: P, landmarks: &[&str]) -> Option<PathBuf> {
+    search_up(start, landmarks, |p| p.is_dir())
+}
+
+// Path computation functions
+
+/// Compute path configuration from Settings
+///
+/// This function should be called before interpreter initialization.
+/// It returns a Paths struct with all computed path values.
+pub fn init_path_config(settings: &Settings) -> Paths {
+    let mut paths = Paths::default();
+
+    // Step 0: Get executable path
+    let executable = get_executable_path();
+    paths.executable = executable
+        .as_ref()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
+
+    let exe_dir = executable
+        .as_ref()
+        .and_then(|p| p.parent().map(PathBuf::from));
+
+    // Step 1: Check for __PYVENV_LAUNCHER__ environment variable
+    if let Ok(launcher) = env::var("__PYVENV_LAUNCHER__") {
+        paths.base_executable = launcher;
+    }
+
+    // Step 2: Check for venv (pyvenv.cfg) and get 'home'
+    let (venv_prefix, home_dir) = detect_venv(&exe_dir);
+    let search_dir = home_dir.clone().or(exe_dir.clone());
+
+    // Step 3: Check for build directory
+    let build_prefix = detect_build_directory(&search_dir);
+
+    // Step 4: Calculate prefix via landmark search
+    // When in venv, search_dir is home_dir, so this gives us the base Python's prefix
+    let calculated_prefix = calculate_prefix(&search_dir, &build_prefix);
+
+    // Step 5: Set prefix and base_prefix
+    if venv_prefix.is_some() {
+        // In venv: prefix = venv directory, base_prefix = original Python's prefix
+        paths.prefix = venv_prefix
+            .as_ref()
+            .map(|p| p.to_string_lossy().into_owned())
+            .unwrap_or_else(|| calculated_prefix.clone());
+        paths.base_prefix = calculated_prefix;
+    } else {
+        // Not in venv: prefix == base_prefix
+        paths.prefix = calculated_prefix.clone();
+        paths.base_prefix = calculated_prefix;
+    }
+
+    // Step 6: Calculate exec_prefix
+    paths.exec_prefix = if venv_prefix.is_some() {
+        // In venv: exec_prefix = prefix (venv directory)
+        paths.prefix.clone()
+    } else {
+        calculate_exec_prefix(&search_dir, &paths.prefix)
+    };
+    paths.base_exec_prefix = paths.base_prefix.clone();
+
+    // Step 7: Calculate base_executable (if not already set by __PYVENV_LAUNCHER__)
+    if paths.base_executable.is_empty() {
+        paths.base_executable = calculate_base_executable(executable.as_ref(), &home_dir);
+    }
+
+    // Step 8: Build module_search_paths
+    paths.module_search_paths =
+        build_module_search_paths(settings, &paths.prefix, &paths.exec_prefix);
+
+    paths
+}
+
+/// Get default prefix value
+fn default_prefix() -> String {
+    std::option_env!("RUSTPYTHON_PREFIX")
+        .map(String::from)
+        .unwrap_or_else(|| {
+            if cfg!(windows) {
+                "C:".to_owned()
+            } else {
+                "/usr/local".to_owned()
+            }
+        })
+}
+
+/// Detect virtual environment by looking for pyvenv.cfg
+/// Returns (venv_prefix, home_dir from pyvenv.cfg)
+fn detect_venv(exe_dir: &Option<PathBuf>) -> (Option<PathBuf>, Option<PathBuf>) {
+    // Try exe_dir/../pyvenv.cfg first (standard venv layout: venv/bin/python)
+    if let Some(dir) = exe_dir
+        && let Some(venv_dir) = dir.parent()
+    {
+        let cfg = venv_dir.join(platform::VENV_LANDMARK);
+        if cfg.exists()
+            && let Some(home) = parse_pyvenv_home(&cfg)
+        {
+            return (Some(venv_dir.to_path_buf()), Some(PathBuf::from(home)));
+        }
+    }
+
+    // Try exe_dir/pyvenv.cfg (alternative layout)
+    if let Some(dir) = exe_dir {
+        let cfg = dir.join(platform::VENV_LANDMARK);
+        if cfg.exists()
+            && let Some(home) = parse_pyvenv_home(&cfg)
+        {
+            return (Some(dir.clone()), Some(PathBuf::from(home)));
+        }
+    }
+
+    (None, None)
+}
+
+/// Detect if running from a build directory
+fn detect_build_directory(exe_dir: &Option<PathBuf>) -> Option<PathBuf> {
+    let dir = exe_dir.as_ref()?;
+
+    // Check for pybuilddir.txt (indicates build directory)
+    if dir.join(platform::BUILDDIR_TXT).exists() {
+        return Some(dir.clone());
+    }
+
+    // Check for Modules/Setup.local (build landmark)
+    if dir.join(platform::BUILD_LANDMARK).exists() {
+        return Some(dir.clone());
+    }
+
+    // Search up for Lib/os.py (build stdlib landmark)
+    search_up_file(dir, &[platform::BUILDSTDLIB_LANDMARK])
+}
+
+/// Calculate prefix by searching for landmarks
+fn calculate_prefix(exe_dir: &Option<PathBuf>, build_prefix: &Option<PathBuf>) -> String {
+    // 1. If build directory detected, use it
+    if let Some(bp) = build_prefix {
+        return bp.to_string_lossy().into_owned();
+    }
+
+    if let Some(dir) = exe_dir {
+        // 2. Search for ZIP landmark
+        let zip = platform::zip_landmark();
+        if let Some(prefix) = search_up_file(dir, &[&zip]) {
+            return prefix.to_string_lossy().into_owned();
+        }
+
+        // 3. Search for stdlib landmarks (os.py)
+        let landmarks = platform::stdlib_landmarks();
+        let refs: Vec<&str> = landmarks.iter().map(|s| s.as_str()).collect();
+        if let Some(prefix) = search_up_file(dir, &refs) {
+            return prefix.to_string_lossy().into_owned();
+        }
+    }
+
+    // 4. Fallback to default
+    default_prefix()
+}
+
+/// Calculate exec_prefix
+fn calculate_exec_prefix(exe_dir: &Option<PathBuf>, prefix: &str) -> String {
+    #[cfg(windows)]
+    {
+        // Windows: exec_prefix == prefix
+        let _ = exe_dir; // silence unused warning
+        prefix.to_owned()
+    }
+
+    #[cfg(not(windows))]
+    {
+        // POSIX: search for lib-dynload directory
+        if let Some(dir) = exe_dir {
+            let landmark = platform::platstdlib_landmark();
+            if let Some(exec_prefix) = search_up_dir(dir, &[&landmark]) {
+                return exec_prefix.to_string_lossy().into_owned();
+            }
+        }
+        // Fallback: same as prefix
+        prefix.to_owned()
+    }
+}
+
+/// Calculate base_executable
+fn calculate_base_executable(executable: Option<&PathBuf>, home_dir: &Option<PathBuf>) -> String {
+    // If in venv and we have home, construct base_executable from home
+    if let (Some(exe), Some(home)) = (executable, home_dir)
+        && let Some(exe_name) = exe.file_name()
+    {
+        let base = home.join(exe_name);
+        return base.to_string_lossy().into_owned();
+    }
+
+    // Otherwise, base_executable == executable
+    executable
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+/// Build the complete module_search_paths (sys.path)
+fn build_module_search_paths(settings: &Settings, prefix: &str, exec_prefix: &str) -> Vec<String> {
+    let mut paths = Vec::new();
+
+    // 1. PYTHONPATH/RUSTPYTHONPATH from settings
+    paths.extend(settings.path_list.iter().cloned());
+
+    // 2. ZIP file path
+    let zip_path = PathBuf::from(prefix).join(platform::zip_landmark());
+    paths.push(zip_path.to_string_lossy().into_owned());
+
+    // 3. stdlib and platstdlib directories
+    #[cfg(not(windows))]
+    {
+        // POSIX: stdlib first, then lib-dynload
+        let stdlib_dir = PathBuf::from(prefix).join(platform::stdlib_subdir());
+        paths.push(stdlib_dir.to_string_lossy().into_owned());
+
+        let platstdlib = PathBuf::from(exec_prefix).join(platform::platstdlib_landmark());
+        paths.push(platstdlib.to_string_lossy().into_owned());
+    }
+
+    #[cfg(windows)]
+    {
+        // Windows: DLLs first, then Lib
+        let platstdlib = PathBuf::from(exec_prefix).join(platform::platstdlib_landmark());
+        paths.push(platstdlib.to_string_lossy().into_owned());
+
+        let stdlib_dir = PathBuf::from(prefix).join(platform::STDLIB_SUBDIR);
+        paths.push(stdlib_dir.to_string_lossy().into_owned());
+    }
+
+    paths
+}
+
+/// Get the current executable path
+fn get_executable_path() -> Option<PathBuf> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let exec_arg = env::args_os().next()?;
+        which::which(exec_arg).ok()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let exec_arg = env::args().next()?;
+        Some(PathBuf::from(exec_arg))
+    }
+}
+
+/// Parse pyvenv.cfg and extract the 'home' key value
+fn parse_pyvenv_home(pyvenv_cfg: &Path) -> Option<String> {
+    let content = std::fs::read_to_string(pyvenv_cfg).ok()?;
+
+    for line in content.lines() {
+        if let Some((key, value)) = line.split_once('=')
+            && key.trim().to_lowercase() == "home"
+        {
+            return Some(value.trim().to_string());
+        }
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_init_path_config() {
+        let settings = Settings::default();
+        let paths = init_path_config(&settings);
+        // Just verify it doesn't panic and returns valid paths
+        assert!(!paths.prefix.is_empty());
+    }
+
+    #[test]
+    fn test_search_up() {
+        // Test with a path that doesn't have any landmarks
+        let result = search_up_file(std::env::temp_dir(), &["nonexistent_landmark_xyz"]);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_default_prefix() {
+        let prefix = default_prefix();
+        assert!(!prefix.is_empty());
+    }
+}
diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index 3f4a437c599..39748655e0f 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -206,7 +206,7 @@ fn remove_importlib_frames_inner(
 // TODO: This function should do nothing on verbose mode.
 // TODO: Fix this function after making PyTraceback.next mutable
 pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &Py<PyBaseException>) {
-    if vm.state.settings.verbose != 0 {
+    if vm.state.config.settings.verbose != 0 {
         return;
     }
 
diff --git a/crates/vm/src/lib.rs b/crates/vm/src/lib.rs
index 923b33d2acc..f461c612955 100644
--- a/crates/vm/src/lib.rs
+++ b/crates/vm/src/lib.rs
@@ -60,6 +60,7 @@ pub mod exceptions;
 pub mod format;
 pub mod frame;
 pub mod function;
+pub mod getpath;
 pub mod import;
 mod intern;
 pub mod iter;
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 442bb79b94e..72d2c724159 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -132,7 +132,7 @@ mod builtins {
 
             let optimize: i32 = args.optimize.map_or(Ok(-1), |v| v.try_to_primitive(vm))?;
             let optimize: u8 = if optimize == -1 {
-                vm.state.settings.optimize
+                vm.state.config.settings.optimize
             } else {
                 optimize
                     .try_into()
@@ -1080,7 +1080,7 @@ pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
 
     builtins::extend_module(vm, module).unwrap();
 
-    let debug_mode: bool = vm.state.settings.optimize == 0;
+    let debug_mode: bool = vm.state.config.settings.optimize == 0;
     // Create dynamic ExceptionGroup with multiple inheritance (BaseExceptionGroup + Exception)
     let exception_group = crate::exception_group::exception_group();
 
diff --git a/crates/vm/src/stdlib/imp.rs b/crates/vm/src/stdlib/imp.rs
index 596847776ff..76b3bfd124c 100644
--- a/crates/vm/src/stdlib/imp.rs
+++ b/crates/vm/src/stdlib/imp.rs
@@ -91,7 +91,7 @@ mod _imp {
     #[pyattr]
     fn check_hash_based_pycs(vm: &VirtualMachine) -> PyStrRef {
         vm.ctx
-            .new_str(vm.state.settings.check_hash_pycs_mode.to_string())
+            .new_str(vm.state.config.settings.check_hash_pycs_mode.to_string())
     }
 
     #[pyfunction]
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 547e482f13a..ba3576a176c 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -2398,7 +2398,9 @@ mod _io {
             *data = None;
 
             let encoding = match args.encoding {
-                None if vm.state.settings.utf8_mode > 0 => identifier_utf8!(vm, utf_8).to_owned(),
+                None if vm.state.config.settings.utf8_mode > 0 => {
+                    identifier_utf8!(vm, utf_8).to_owned()
+                }
                 Some(enc) if enc.as_str() != "locale" => enc,
                 _ => {
                     // None without utf8_mode or "locale" encoding
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
index 4eacb10154c..6771a950400 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/signal.rs
@@ -114,7 +114,7 @@ pub(crate) mod _signal {
         module: &Py<crate::builtins::PyModule>,
         vm: &VirtualMachine,
     ) {
-        if vm.state.settings.install_signal_handlers {
+        if vm.state.config.settings.install_signal_handlers {
             let sig_dfl = vm.new_pyobj(SIG_DFL as u8);
             let sig_ign = vm.new_pyobj(SIG_IGN as u8);
 
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index f9bd2b59456..cfe6f9f5e61 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -25,7 +25,6 @@ mod sys {
     use std::{
         env::{self, VarError},
         io::Read,
-        path,
         sync::atomic::Ordering,
     };
 
@@ -96,25 +95,20 @@ mod sys {
     const DLLHANDLE: usize = 0;
 
     #[pyattr]
-    const fn default_prefix(_vm: &VirtualMachine) -> &'static str {
-        // TODO: the windows one doesn't really make sense
-        if cfg!(windows) { "C:" } else { "/usr/local" }
+    fn prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.prefix.clone()
     }
     #[pyattr]
-    fn prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_PREFIX").unwrap_or_else(|| default_prefix(vm))
+    fn base_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_prefix.clone()
     }
     #[pyattr]
-    fn base_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| prefix(vm))
+    fn exec_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.exec_prefix.clone()
     }
     #[pyattr]
-    fn exec_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| prefix(vm))
-    }
-    #[pyattr]
-    fn base_exec_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| exec_prefix(vm))
+    fn base_exec_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_exec_prefix.clone()
     }
     #[pyattr]
     fn platlibdir(_vm: &VirtualMachine) -> &'static str {
@@ -126,6 +120,7 @@ mod sys {
     #[pyattr]
     fn argv(vm: &VirtualMachine) -> Vec<PyObjectRef> {
         vm.state
+            .config
             .settings
             .argv
             .iter()
@@ -162,117 +157,18 @@ mod sys {
     }
 
     #[pyattr]
-    fn _base_executable(vm: &VirtualMachine) -> PyObjectRef {
-        let ctx = &vm.ctx;
-        // First check __PYVENV_LAUNCHER__ environment variable
-        if let Ok(var) = env::var("__PYVENV_LAUNCHER__") {
-            return ctx.new_str(var).into();
-        }
-
-        // Try to detect if we're running from a venv by looking for pyvenv.cfg
-        if let Some(base_exe) = get_venv_base_executable() {
-            return ctx.new_str(base_exe).into();
-        }
-
-        executable(vm)
-    }
-
-    /// Try to find base executable from pyvenv.cfg (see getpath.py)
-    fn get_venv_base_executable() -> Option<String> {
-        // TODO: This is a minimal implementation of getpath.py
-        // To fully support all cases, `getpath.py` should be placed in @crates/vm/Lib/python_builtins/
-
-        // Get current executable path
-        #[cfg(not(target_arch = "wasm32"))]
-        let exe_path = {
-            let exec_arg = env::args_os().next()?;
-            which::which(exec_arg).ok()?
-        };
-        #[cfg(target_arch = "wasm32")]
-        let exe_path = {
-            let exec_arg = env::args().next()?;
-            path::PathBuf::from(exec_arg)
-        };
-
-        let exe_dir = exe_path.parent()?;
-        let exe_name = exe_path.file_name()?;
-
-        // Look for pyvenv.cfg in parent directory (typical venv layout: venv/bin/python)
-        let venv_dir = exe_dir.parent()?;
-        let pyvenv_cfg = venv_dir.join("pyvenv.cfg");
-
-        if !pyvenv_cfg.exists() {
-            return None;
-        }
-
-        // Parse pyvenv.cfg and extract home directory
-        let content = std::fs::read_to_string(&pyvenv_cfg).ok()?;
-
-        for line in content.lines() {
-            if let Some((key, value)) = line.split_once('=') {
-                let key = key.trim().to_lowercase();
-                let value = value.trim();
-
-                if key == "home" {
-                    // First try to resolve symlinks (getpath.py line 373-377)
-                    if let Ok(resolved) = std::fs::canonicalize(&exe_path)
-                        && resolved != exe_path
-                    {
-                        return Some(resolved.to_string_lossy().into_owned());
-                    }
-                    // Fallback: home_dir + executable_name (getpath.py line 381)
-                    let base_exe = path::Path::new(value).join(exe_name);
-                    return Some(base_exe.to_string_lossy().into_owned());
-                }
-            }
-        }
-
-        None
+    fn _base_executable(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_executable.clone()
     }
 
     #[pyattr]
     fn dont_write_bytecode(vm: &VirtualMachine) -> bool {
-        !vm.state.settings.write_bytecode
+        !vm.state.config.settings.write_bytecode
     }
 
     #[pyattr]
-    fn executable(vm: &VirtualMachine) -> PyObjectRef {
-        let ctx = &vm.ctx;
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            if let Some(exec_path) = env::args_os().next()
-                && let Ok(path) = which::which(exec_path)
-            {
-                return ctx
-                    .new_str(
-                        path.into_os_string()
-                            .into_string()
-                            .unwrap_or_else(|p| p.to_string_lossy().into_owned()),
-                    )
-                    .into();
-            }
-        }
-        if let Some(exec_path) = env::args().next() {
-            let path = path::Path::new(&exec_path);
-            if !path.exists() {
-                return ctx.new_str(ascii!("")).into();
-            }
-            if path.is_absolute() {
-                return ctx.new_str(exec_path).into();
-            }
-            if let Ok(dir) = env::current_dir()
-                && let Ok(dir) = dir.into_os_string().into_string()
-            {
-                return ctx
-                    .new_str(format!(
-                        "{}/{}",
-                        dir,
-                        exec_path.strip_prefix("./").unwrap_or(&exec_path)
-                    ))
-                    .into();
-            }
-        }
-        ctx.none()
+    fn executable(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.executable.clone()
     }
 
     #[pyattr]
@@ -312,8 +208,9 @@ mod sys {
     #[pyattr]
     fn path(vm: &VirtualMachine) -> Vec<PyObjectRef> {
         vm.state
-            .settings
-            .path_list
+            .config
+            .paths
+            .module_search_paths
             .iter()
             .map(|path| vm.ctx.new_str(path.clone()).into())
             .collect()
@@ -350,7 +247,7 @@ mod sys {
     fn _xoptions(vm: &VirtualMachine) -> PyDictRef {
         let ctx = &vm.ctx;
         let xopts = ctx.new_dict();
-        for (key, value) in &vm.state.settings.xoptions {
+        for (key, value) in &vm.state.config.settings.xoptions {
             let value = value.as_ref().map_or_else(
                 || ctx.new_bool(true).into(),
                 |s| ctx.new_str(s.clone()).into(),
@@ -363,6 +260,7 @@ mod sys {
     #[pyattr]
     fn warnoptions(vm: &VirtualMachine) -> Vec<PyObjectRef> {
         vm.state
+            .config
             .settings
             .warnoptions
             .iter()
@@ -507,7 +405,7 @@ mod sys {
 
     #[pyattr]
     fn flags(vm: &VirtualMachine) -> PyTupleRef {
-        PyFlags::from_data(FlagsData::from_settings(&vm.state.settings), vm)
+        PyFlags::from_data(FlagsData::from_settings(&vm.state.config.settings), vm)
     }
 
     #[pyattr]
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index 6f1ea734926..44332cda838 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -38,7 +38,7 @@ impl VirtualMachine {
         }
 
         // TODO: check if this is proper place
-        if !self.state.settings.safe_path {
+        if !self.state.config.settings.safe_path {
             let dir = std::path::Path::new(path)
                 .parent()
                 .unwrap()
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index 05613d43384..503feb3dc7f 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -1,5 +1,5 @@
-use super::{Context, VirtualMachine, setting::Settings, thread};
-use crate::{PyResult, stdlib::atexit, vm::PyBaseExceptionRef};
+use super::{Context, PyConfig, VirtualMachine, setting::Settings, thread};
+use crate::{PyResult, getpath, stdlib::atexit, vm::PyBaseExceptionRef};
 use std::sync::atomic::Ordering;
 
 /// The general interface for the VM
@@ -47,10 +47,14 @@ impl Interpreter {
     where
         F: FnOnce(&mut VirtualMachine),
     {
+        // Compute path configuration from settings
+        let paths = getpath::init_path_config(&settings);
+        let config = PyConfig::new(settings, paths);
+
         let ctx = Context::genesis();
         crate::types::TypeZoo::extend(ctx);
         crate::exceptions::ExceptionZoo::extend(ctx);
-        let mut vm = VirtualMachine::new(settings, ctx.clone());
+        let mut vm = VirtualMachine::new(config, ctx.clone());
         init(&mut vm);
         vm.initialize();
         Self { vm }
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 4574b2de370..34092454059 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -50,7 +50,7 @@ use std::{
 pub use context::Context;
 pub use interpreter::Interpreter;
 pub(crate) use method::PyMethod;
-pub use setting::{CheckHashPycsMode, Settings};
+pub use setting::{CheckHashPycsMode, Paths, PyConfig, Settings};
 
 pub const MAX_MEMORY_SIZE: usize = isize::MAX as usize;
 
@@ -87,7 +87,7 @@ struct ExceptionStack {
 }
 
 pub struct PyGlobalState {
-    pub settings: Settings,
+    pub config: PyConfig,
     pub module_inits: stdlib::StdlibMap,
     pub frozen: HashMap<&'static str, FrozenModule, ahash::RandomState>,
     pub stacksize: AtomicCell<usize>,
@@ -114,7 +114,7 @@ pub fn process_hash_secret_seed() -> u32 {
 
 impl VirtualMachine {
     /// Create a new `VirtualMachine` structure.
-    fn new(settings: Settings, ctx: PyRc<Context>) -> Self {
+    fn new(config: PyConfig, ctx: PyRc<Context>) -> Self {
         flame_guard!("new VirtualMachine");
 
         // make a new module without access to the vm; doesn't
@@ -141,7 +141,7 @@ impl VirtualMachine {
 
         let module_inits = stdlib::get_module_inits();
 
-        let seed = match settings.hash_seed {
+        let seed = match config.settings.hash_seed {
             Some(seed) => seed,
             None => process_hash_secret_seed(),
         };
@@ -151,7 +151,7 @@ impl VirtualMachine {
 
         let warnings = WarningsState::init_state(&ctx);
 
-        let int_max_str_digits = AtomicCell::new(match settings.int_max_str_digits {
+        let int_max_str_digits = AtomicCell::new(match config.settings.int_max_str_digits {
             -1 => 4300,
             other => other,
         } as usize);
@@ -171,7 +171,7 @@ impl VirtualMachine {
             signal_rx: None,
             repr_guards: RefCell::default(),
             state: PyRc::new(PyGlobalState {
-                settings,
+                config,
                 module_inits,
                 frozen: HashMap::default(),
                 stacksize: AtomicCell::new(0),
@@ -227,7 +227,7 @@ impl VirtualMachine {
             let rustpythonpath_env = std::env::var("RUSTPYTHONPATH").ok();
             let pythonpath_env = std::env::var("PYTHONPATH").ok();
             let env_set = rustpythonpath_env.as_ref().is_some() || pythonpath_env.as_ref().is_some();
-            let path_contains_env = self.state.settings.path_list.iter().any(|s| {
+            let path_contains_env = self.state.config.paths.module_search_paths.iter().any(|s| {
                 Some(s.as_str()) == rustpythonpath_env.as_deref() || Some(s.as_str()) == pythonpath_env.as_deref()
             });
 
@@ -238,7 +238,7 @@ impl VirtualMachine {
             } else if path_contains_env {
                 "RUSTPYTHONPATH or PYTHONPATH is set, but it doesn't contain the encodings library. If you are customizing the RustPython vm/interpreter, try adding the stdlib directory to the path. If you are developing the RustPython interpreter, it might be a bug during development."
             } else {
-                "RUSTPYTHONPATH or PYTHONPATH is set, but it wasn't loaded to `Settings::path_list`. If you are going to customize the RustPython vm/interpreter, those environment variables are not loaded in the Settings struct by default. Please try creating a customized instance of the Settings struct. If you are developing the RustPython interpreter, it might be a bug during development."
+                "RUSTPYTHONPATH or PYTHONPATH is set, but it wasn't loaded to `PyConfig::paths::module_search_paths`. If you are going to customize the RustPython vm/interpreter, those environment variables are not loaded in the Settings struct by default. Please try creating a customized instance of the Settings struct. If you are developing the RustPython interpreter, it might be a bug during development."
             };
 
             let mut msg = format!(
@@ -303,7 +303,7 @@ impl VirtualMachine {
                 let io = import::import_builtin(self, "_io")?;
                 #[cfg(feature = "stdio")]
                 let make_stdio = |name, fd, write| {
-                    let buffered_stdio = self.state.settings.buffered_stdio;
+                    let buffered_stdio = self.state.config.settings.buffered_stdio;
                     let unbuffered = write && !buffered_stdio;
                     let buf = crate::stdlib::io::open(
                         self.ctx.new_int(fd).into(),
@@ -364,7 +364,7 @@ impl VirtualMachine {
         let res = essential_init();
         let importlib = self.expect_pyresult(res, "essential initialization failed");
 
-        if self.state.settings.allow_external_library
+        if self.state.config.settings.allow_external_library
             && cfg!(feature = "rustpython-compiler")
             && let Err(e) = import::init_importlib_package(self, importlib)
         {
@@ -374,8 +374,8 @@ impl VirtualMachine {
             self.print_exception(e);
         }
 
-        let _expect_stdlib =
-            cfg!(feature = "freeze-stdlib") || !self.state.settings.path_list.is_empty();
+        let _expect_stdlib = cfg!(feature = "freeze-stdlib")
+            || !self.state.config.paths.module_search_paths.is_empty();
 
         #[cfg(feature = "encodings")]
         if _expect_stdlib {
@@ -389,7 +389,7 @@ impl VirtualMachine {
             // Here may not be the best place to give general `path_list` advice,
             // but bare rustpython_vm::VirtualMachine users skipped proper settings must hit here while properly setup vm never enters here.
             eprintln!(
-                "feature `encodings` is enabled but `settings.path_list` is empty. \
+                "feature `encodings` is enabled but `paths.module_search_paths` is empty. \
                 Please add the library path to `settings.path_list`. If you intended to disable the entire standard library (including the `encodings` feature), please also make sure to disable the `encodings` feature.\n\
                 Tip: You may also want to add `\"\"` to `settings.path_list` in order to enable importing from the current working directory."
             );
@@ -505,7 +505,7 @@ impl VirtualMachine {
     #[cfg(feature = "rustpython-codegen")]
     pub fn compile_opts(&self) -> crate::compiler::CompileOpts {
         crate::compiler::CompileOpts {
-            optimize: self.state.settings.optimize,
+            optimize: self.state.config.settings.optimize,
         }
     }
 
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index deaca705c47..53e2cef1160 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -1,8 +1,40 @@
 #[cfg(feature = "flame-it")]
 use std::ffi::OsString;
 
-/// Struct containing all kind of settings for the python vm.
-/// Mostly `PyConfig` in CPython.
+/// Path configuration computed at runtime (like PyConfig path outputs)
+#[derive(Debug, Clone, Default)]
+pub struct Paths {
+    /// sys.executable
+    pub executable: String,
+    /// sys._base_executable (original interpreter in venv)
+    pub base_executable: String,
+    /// sys.prefix
+    pub prefix: String,
+    /// sys.base_prefix
+    pub base_prefix: String,
+    /// sys.exec_prefix
+    pub exec_prefix: String,
+    /// sys.base_exec_prefix
+    pub base_exec_prefix: String,
+    /// Computed module_search_paths (complete sys.path)
+    pub module_search_paths: Vec<String>,
+}
+
+/// Combined configuration: user settings + computed paths
+/// CPython directly exposes every fields under both of them.
+/// We separate them to maintain better ownership discipline.
+pub struct PyConfig {
+    pub settings: Settings,
+    pub paths: Paths,
+}
+
+impl PyConfig {
+    pub fn new(settings: Settings, paths: Paths) -> Self {
+        Self { settings, paths }
+    }
+}
+
+/// User-configurable settings for the python vm.
 #[non_exhaustive]
 pub struct Settings {
     /// -I
diff --git a/src/interpreter.rs b/src/interpreter.rs
index b79a1a0ffb4..b4fd319cdae 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -104,23 +104,25 @@ pub fn init_stdlib(vm: &mut VirtualMachine) {
         use rustpython_vm::common::rc::PyRc;
 
         let state = PyRc::get_mut(&mut vm.state).unwrap();
-        let settings = &mut state.settings;
 
-        let path_list = std::mem::take(&mut settings.path_list);
+        // Collect additional paths to add
+        let mut additional_paths = Vec::new();
 
         // BUILDTIME_RUSTPYTHONPATH should be set when distributing
         if let Some(paths) = option_env!("BUILDTIME_RUSTPYTHONPATH") {
-            settings.path_list.extend(
+            additional_paths.extend(
                 crate::settings::split_paths(paths)
                     .map(|path| path.into_os_string().into_string().unwrap()),
             )
         } else {
             #[cfg(feature = "rustpython-pylib")]
-            settings
-                .path_list
-                .push(rustpython_pylib::LIB_PATH.to_owned())
+            additional_paths.push(rustpython_pylib::LIB_PATH.to_owned())
         }
 
-        settings.path_list.extend(path_list);
+        // Add to both path_list (for compatibility) and module_search_paths (for sys.path)
+        // Insert at the beginning so stdlib comes before user paths
+        for path in additional_paths.into_iter().rev() {
+            state.config.paths.module_search_paths.insert(0, path);
+        }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 84a774ab029..8d278058933 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -169,7 +169,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
 
     let scope = setup_main_module(vm)?;
 
-    if !vm.state.settings.safe_path {
+    if !vm.state.config.settings.safe_path {
         // TODO: The prepending path depends on running mode
         // See https://docs.python.org/3/using/cmdline.html#cmdoption-P
         vm.run_code_string(
@@ -189,7 +189,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
 
     // Enable faulthandler if -X faulthandler, PYTHONFAULTHANDLER or -X dev is set
     // _PyFaulthandler_Init()
-    if vm.state.settings.faulthandler {
+    if vm.state.config.settings.faulthandler {
         let _ = vm.run_code_string(
             vm.new_scope_with_builtins(),
             "import faulthandler; faulthandler.enable()",
@@ -198,8 +198,8 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     }
 
     let is_repl = matches!(run_mode, RunMode::Repl);
-    if !vm.state.settings.quiet
-        && (vm.state.settings.verbose > 0 || (is_repl && std::io::stdin().is_terminal()))
+    if !vm.state.config.settings.quiet
+        && (vm.state.config.settings.verbose > 0 || (is_repl && std::io::stdin().is_terminal()))
     {
         eprintln!(
             "Welcome to the magnificent Rust Python {} interpreter \u{1f631} \u{1f596}",
@@ -232,7 +232,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         }
         RunMode::Repl => Ok(()),
     };
-    if is_repl || vm.state.settings.inspect {
+    if is_repl || vm.state.config.settings.inspect {
         shell::run_shell(vm, scope)?;
     } else {
         res?;
@@ -241,7 +241,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     #[cfg(feature = "flame-it")]
     {
         main_guard.end();
-        if let Err(e) = write_profile(&vm.state.as_ref().settings) {
+        if let Err(e) = write_profile(&vm.state.as_ref().config.settings) {
             error!("Error writing profile information: {}", e);
         }
     }

From 569bee103ff528ac8d70c3b5b78c70378e6cd115 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 22 Dec 2025 04:43:58 +0100
Subject: [PATCH 021/418] Use `ruff_python_ast::visitor::Visitor` for detecting
 `await` (#6466)

---
 crates/codegen/src/compile.rs | 158 +++++++---------------------------
 1 file changed, 30 insertions(+), 128 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 9620edbd107..4f7174c8bad 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -24,12 +24,13 @@ use ruff_python_ast::{
     Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem,
     ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprContext,
     ExprFString, ExprList, ExprName, ExprSlice, ExprStarred, ExprSubscript, ExprTuple, ExprUnaryOp,
-    FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedElement,
-    InterpolatedStringElement, InterpolatedStringElements, Keyword, MatchCase, ModExpression,
-    ModModule, Operator, Parameters, Pattern, PatternMatchAs, PatternMatchClass,
-    PatternMatchMapping, PatternMatchOr, PatternMatchSequence, PatternMatchSingleton,
-    PatternMatchStar, PatternMatchValue, Singleton, Stmt, StmtExpr, TypeParam, TypeParamParamSpec,
-    TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
+    FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedStringElement,
+    InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
+    Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
+    PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
+    Stmt, StmtExpr, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple,
+    TypeParams, UnaryOp, WithItem,
+    visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange};
 use rustpython_compiler_core::{
@@ -5435,134 +5436,35 @@ impl Compiler {
 
     /// Whether the expression contains an await expression and
     /// thus requires the function to be async.
-    /// Async with and async for are statements, so I won't check for them here
+    ///
+    /// Both:
+    /// ```py
+    /// async with: ...
+    /// async for: ...
+    /// ```
+    /// are statements, so we won't check for them here
     fn contains_await(expression: &Expr) -> bool {
-        use ruff_python_ast::*;
+        #[derive(Default)]
+        struct AwaitVisitor {
+            found: bool,
+        }
 
-        match &expression {
-            Expr::Call(ExprCall {
-                func, arguments, ..
-            }) => {
-                Self::contains_await(func)
-                    || arguments.args.iter().any(Self::contains_await)
-                    || arguments
-                        .keywords
-                        .iter()
-                        .any(|kw| Self::contains_await(&kw.value))
-            }
-            Expr::BoolOp(ExprBoolOp { values, .. }) => values.iter().any(Self::contains_await),
-            Expr::BinOp(ExprBinOp { left, right, .. }) => {
-                Self::contains_await(left) || Self::contains_await(right)
-            }
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                Self::contains_await(value) || Self::contains_await(slice)
-            }
-            Expr::UnaryOp(ExprUnaryOp { operand, .. }) => Self::contains_await(operand),
-            Expr::Attribute(ExprAttribute { value, .. }) => Self::contains_await(value),
-            Expr::Compare(ExprCompare {
-                left, comparators, ..
-            }) => Self::contains_await(left) || comparators.iter().any(Self::contains_await),
-            Expr::List(ExprList { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Tuple(ExprTuple { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Set(ExprSet { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Dict(ExprDict { items, .. }) => items
-                .iter()
-                .flat_map(|item| &item.key)
-                .any(Self::contains_await),
-            Expr::Slice(ExprSlice {
-                lower, upper, step, ..
-            }) => {
-                lower.as_deref().is_some_and(Self::contains_await)
-                    || upper.as_deref().is_some_and(Self::contains_await)
-                    || step.as_deref().is_some_and(Self::contains_await)
-            }
-            Expr::Yield(ExprYield { value, .. }) => {
-                value.as_deref().is_some_and(Self::contains_await)
-            }
-            Expr::Await(ExprAwait { .. }) => true,
-            Expr::YieldFrom(ExprYieldFrom { value, .. }) => Self::contains_await(value),
-            Expr::Name(ExprName { .. }) => false,
-            Expr::Lambda(ExprLambda { body, .. }) => Self::contains_await(body),
-            Expr::ListComp(ExprListComp {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::SetComp(ExprSetComp {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::DictComp(ExprDictComp {
-                key,
-                value,
-                generators,
-                ..
-            }) => {
-                Self::contains_await(key)
-                    || Self::contains_await(value)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::Generator(ExprGenerator {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::Starred(expr) => Self::contains_await(&expr.value),
-            Expr::If(ExprIf {
-                test, body, orelse, ..
-            }) => {
-                Self::contains_await(test)
-                    || Self::contains_await(body)
-                    || Self::contains_await(orelse)
-            }
+        impl Visitor<'_> for AwaitVisitor {
+            fn visit_expr(&mut self, expr: &Expr) {
+                if self.found {
+                    return;
+                }
 
-            Expr::Named(ExprNamed {
-                target,
-                value,
-                node_index: _,
-                range: _,
-            }) => Self::contains_await(target) || Self::contains_await(value),
-            Expr::FString(fstring) => {
-                Self::interpolated_string_contains_await(fstring.value.elements())
-            }
-            Expr::TString(tstring) => {
-                Self::interpolated_string_contains_await(tstring.value.elements())
+                match expr {
+                    Expr::Await(_) => self.found = true,
+                    _ => walk_expr(self, expr),
+                }
             }
-            Expr::StringLiteral(_)
-            | Expr::BytesLiteral(_)
-            | Expr::NumberLiteral(_)
-            | Expr::BooleanLiteral(_)
-            | Expr::NoneLiteral(_)
-            | Expr::EllipsisLiteral(_)
-            | Expr::IpyEscapeCommand(_) => false,
-        }
-    }
-
-    fn interpolated_string_contains_await<'a>(
-        mut elements: impl Iterator<Item = &'a InterpolatedStringElement>,
-    ) -> bool {
-        fn interpolated_element_contains_await<F: Copy + Fn(&Expr) -> bool>(
-            expr_element: &InterpolatedElement,
-            contains_await: F,
-        ) -> bool {
-            contains_await(&expr_element.expression)
-                || expr_element
-                    .format_spec
-                    .iter()
-                    .flat_map(|spec| spec.elements.interpolations())
-                    .any(|element| interpolated_element_contains_await(element, contains_await))
         }
 
-        elements.any(|element| match element {
-            InterpolatedStringElement::Interpolation(expr_element) => {
-                interpolated_element_contains_await(expr_element, Self::contains_await)
-            }
-            InterpolatedStringElement::Literal(_) => false,
-        })
+        let mut visitor = AwaitVisitor::default();
+        visitor.visit_expr(expression);
+        visitor.found
     }
 
     fn compile_expr_fstring(&mut self, fstring: &ExprFString) -> CompileResult<()> {

From fdd2ac3b30827c1d44c5c5040eb184e65cf2534e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 22 Dec 2025 21:10:43 +0900
Subject: [PATCH 022/418] disallow __new__, __init__ (#6446)

* disallow __new__, __init__

* migrate to Initializer

* apply review
---
 crates/derive-impl/src/pyclass.rs  | 125 +++++++-----
 crates/stdlib/src/sqlite.rs        |  41 ++--
 crates/stdlib/src/ssl/error.rs     |   2 +-
 crates/vm/src/builtins/object.rs   |  32 +--
 crates/vm/src/exception_group.rs   | 244 ++++++++++++-----------
 crates/vm/src/exceptions.rs        | 304 ++++++++++++++++-------------
 crates/vm/src/stdlib/ast/python.rs |  79 ++++----
 7 files changed, 458 insertions(+), 369 deletions(-)

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index f784a2e2a76..d1fe5398634 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -63,6 +63,7 @@ impl FromStr for AttrName {
 
 #[derive(Default)]
 struct ImplContext {
+    is_trait: bool,
     attribute_items: ItemNursery,
     method_items: MethodNursery,
     getset_items: GetSetNursery,
@@ -232,7 +233,10 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
             }
         }
         Item::Trait(mut trai) => {
-            let mut context = ImplContext::default();
+            let mut context = ImplContext {
+                is_trait: true,
+                ..Default::default()
+            };
             let mut has_extend_slots = false;
             for item in &trai.items {
                 let has = match item {
@@ -710,21 +714,16 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
     };
 
     // Check if with(Constructor) is specified. If Constructor trait is used, don't generate slot_new
-    let mut has_slot_new = false;
-
     let mut extra_attrs = Vec::new();
+    let mut with_items = vec![];
     for nested in &attr {
         if let NestedMeta::Meta(Meta::List(MetaList { path, nested, .. })) = nested {
             // If we already found the constructor trait, no need to keep looking for it
-            if !has_slot_new && path.is_ident("with") {
-                // Check if Constructor is in the list
+            if path.is_ident("with") {
                 for meta in nested {
-                    if let NestedMeta::Meta(Meta::Path(p)) = meta
-                        && p.is_ident("Constructor")
-                    {
-                        has_slot_new = true;
-                    }
+                    with_items.push(meta.get_ident().expect("with() has non-ident item").clone());
                 }
+                continue;
             }
             extra_attrs.push(NestedMeta::Meta(Meta::List(MetaList {
                 path: path.clone(),
@@ -734,43 +733,40 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
         }
     }
 
-    let mut has_slot_init = false;
+    let with_contains = |with_items: &[Ident], s: &str| {
+        // Check if Constructor is in the list
+        with_items.iter().any(|ident| ident == s)
+    };
+
     let syn::ItemImpl {
         generics,
         self_ty,
         items,
         ..
     } = &imp;
-    for item in items {
-        // FIXME: better detection or correct wrapper implementation
-        let Some(ident) = item.get_ident() else {
-            continue;
-        };
-        let item_name = ident.to_string();
-        match item_name.as_str() {
-            "slot_new" => {
-                has_slot_new = true;
-            }
-            "slot_init" => {
-                has_slot_init = true;
-            }
-            _ => continue,
-        }
-    }
-
-    // TODO: slot_new, slot_init must be Constructor or Initializer later
 
-    let slot_new = if has_slot_new {
+    let slot_new = if with_contains(&with_items, "Constructor") {
         quote!()
     } else {
+        with_items.push(Ident::new("Constructor", Span::call_site()));
         quote! {
-            #[pyslot]
-            pub fn slot_new(
-                cls: ::rustpython_vm::builtins::PyTypeRef,
-                args: ::rustpython_vm::function::FuncArgs,
-                vm: &::rustpython_vm::VirtualMachine,
-            ) -> ::rustpython_vm::PyResult {
-                <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_new(cls, args, vm)
+            impl ::rustpython_vm::types::Constructor for #self_ty {
+                type Args = ::rustpython_vm::function::FuncArgs;
+
+                fn slot_new(
+                    cls: ::rustpython_vm::builtins::PyTypeRef,
+                    args: ::rustpython_vm::function::FuncArgs,
+                    vm: &::rustpython_vm::VirtualMachine,
+                ) -> ::rustpython_vm::PyResult {
+                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_new(cls, args, vm)
+                }
+                fn py_new(
+                    _cls: &::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
+                    _args: Self::Args,
+                    _vm: &::rustpython_vm::VirtualMachine
+                ) -> ::rustpython_vm::PyResult<Self> {
+                    unreachable!("slot_new is defined")
+                }
             }
         }
     };
@@ -779,19 +775,29 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
     // from `BaseException` in `SimpleExtendsException` macro.
     // See: `(initproc)BaseException_init`
     // spell-checker:ignore initproc
-    let slot_init = if has_slot_init {
+    let slot_init = if with_contains(&with_items, "Initializer") {
         quote!()
     } else {
-        // FIXME: this is a generic logic for types not only for exceptions
+        with_items.push(Ident::new("Initializer", Span::call_site()));
         quote! {
-            #[pyslot]
-            #[pymethod(name="__init__")]
-            pub fn slot_init(
-                zelf: ::rustpython_vm::PyObjectRef,
-                args: ::rustpython_vm::function::FuncArgs,
-                vm: &::rustpython_vm::VirtualMachine,
-            ) -> ::rustpython_vm::PyResult<()> {
-                <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
+            impl ::rustpython_vm::types::Initializer for #self_ty {
+                type Args = ::rustpython_vm::function::FuncArgs;
+
+                fn slot_init(
+                    zelf: ::rustpython_vm::PyObjectRef,
+                    args: ::rustpython_vm::function::FuncArgs,
+                    vm: &::rustpython_vm::VirtualMachine,
+                ) -> ::rustpython_vm::PyResult<()> {
+                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
+                }
+
+                fn init(
+                    _zelf: ::rustpython_vm::PyRef<Self>,
+                    _args: Self::Args,
+                    _vm: &::rustpython_vm::VirtualMachine
+                ) -> ::rustpython_vm::PyResult<()> {
+                    unreachable!("slot_init is defined")
+                }
             }
         }
     };
@@ -803,13 +809,13 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
     };
 
     Ok(quote! {
-        #[pyclass(flags(BASETYPE, HAS_DICT) #extra_attrs_tokens)]
+        #[pyclass(flags(BASETYPE, HAS_DICT), with(#(#with_items),*) #extra_attrs_tokens)]
         impl #generics #self_ty {
             #(#items)*
-
-            #slot_new
-            #slot_init
         }
+
+        #slot_new
+        #slot_init
     })
 }
 
@@ -892,6 +898,23 @@ where
         let item_meta = MethodItemMeta::from_attr(ident.clone(), &item_attr)?;
 
         let py_name = item_meta.method_name()?;
+
+        // Disallow __new__ and __init__ as pymethod in impl blocks (not in traits)
+        if !args.context.is_trait {
+            if py_name == "__new__" {
+                return Err(syn::Error::new(
+                    ident.span(),
+                    "#[pymethod] cannot define '__new__'. Use #[pyclass(with(Constructor))] instead.",
+                ));
+            }
+            if py_name == "__init__" {
+                return Err(syn::Error::new(
+                    ident.span(),
+                    "#[pymethod] cannot define '__init__'. Use #[pyclass(with(Initializer))] instead.",
+                ));
+            }
+        }
+
         let raw = item_meta.raw()?;
         let sig_doc = text_signature(func.sig(), &py_name);
 
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index bc84cffbf80..ffdc9eb3831 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -1540,7 +1540,7 @@ mod _sqlite {
         size: Option<c_int>,
     }
 
-    #[pyclass(with(Constructor, IterNext, Iterable), flags(BASETYPE))]
+    #[pyclass(with(Constructor, Initializer, IterNext, Iterable), flags(BASETYPE))]
     impl Cursor {
         fn new(
             connection: PyRef<Connection>,
@@ -1571,24 +1571,6 @@ mod _sqlite {
             }
         }
 
-        #[pymethod]
-        fn __init__(&self, _connection: PyRef<Connection>, _vm: &VirtualMachine) -> PyResult<()> {
-            let mut guard = self.inner.lock();
-            if guard.is_some() {
-                // Already initialized (e.g., from a call to super().__init__)
-                return Ok(());
-            }
-            *guard = Some(CursorInner {
-                description: None,
-                row_cast_map: vec![],
-                lastrowid: -1,
-                rowcount: -1,
-                statement: None,
-                closed: false,
-            });
-            Ok(())
-        }
-
         fn check_cursor_state(inner: Option<&CursorInner>, vm: &VirtualMachine) -> PyResult<()> {
             match inner {
                 Some(inner) if inner.closed => Err(new_programming_error(
@@ -1949,6 +1931,27 @@ mod _sqlite {
         }
     }
 
+    impl Initializer for Cursor {
+        type Args = PyRef<Connection>;
+
+        fn init(zelf: PyRef<Self>, _connection: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            let mut guard = zelf.inner.lock();
+            if guard.is_some() {
+                // Already initialized (e.g., from a call to super().__init__)
+                return Ok(());
+            }
+            *guard = Some(CursorInner {
+                description: None,
+                row_cast_map: vec![],
+                lastrowid: -1,
+                rowcount: -1,
+                statement: None,
+                closed: false,
+            });
+            Ok(())
+        }
+    }
+
     impl SelfIter for Cursor {}
     impl IterNext for Cursor {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
index bef9ba513d7..879275228ec 100644
--- a/crates/stdlib/src/ssl/error.rs
+++ b/crates/stdlib/src/ssl/error.rs
@@ -7,7 +7,7 @@ pub(crate) mod ssl_error {
     use crate::vm::{
         PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyBaseExceptionRef, PyOSError, PyStrRef},
-        types::Constructor,
+        types::{Constructor, Initializer},
     };
 
     // Error type constants - exposed as pyattr and available for internal use
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index cb95652f937..0970496c7b1 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -2,11 +2,11 @@ use super::{PyDictRef, PyList, PyStr, PyStrRef, PyType, PyTypeRef};
 use crate::common::hash::PyHash;
 use crate::types::PyTypeFlags;
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     convert::ToPyResult,
     function::{Either, FuncArgs, PyArithmeticValue, PyComparisonValue, PySetterValue},
-    types::{Constructor, PyComparisonOp},
+    types::{Constructor, Initializer, PyComparisonOp},
 };
 use itertools::Itertools;
 
@@ -115,6 +115,18 @@ impl Constructor for PyBaseObject {
     }
 }
 
+impl Initializer for PyBaseObject {
+    type Args = FuncArgs;
+
+    fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
+        Ok(())
+    }
+
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        unreachable!("slot_init is defined")
+    }
+}
+
 // TODO: implement _PyType_GetSlotNames properly
 fn type_slot_names(typ: &Py<PyType>, vm: &VirtualMachine) -> PyResult<Option<super::PyListRef>> {
     // let attributes = typ.attributes.read();
@@ -235,7 +247,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
 //     getstate.call((), vm)
 // }
 
-#[pyclass(with(Constructor), flags(BASETYPE))]
+#[pyclass(with(Constructor, Initializer), flags(BASETYPE))]
 impl PyBaseObject {
     #[pymethod(raw)]
     fn __getstate__(vm: &VirtualMachine, args: FuncArgs) -> PyResult {
@@ -444,19 +456,17 @@ impl PyBaseObject {
         obj.str(vm)
     }
 
-    #[pyslot]
-    #[pymethod]
-    fn __init__(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
-        Ok(())
-    }
-
     #[pygetset]
     fn __class__(obj: PyObjectRef) -> PyTypeRef {
         obj.class().to_owned()
     }
 
-    #[pygetset(name = "__class__", setter)]
-    fn set_class(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    #[pygetset(setter)]
+    fn set___class__(
+        instance: PyObjectRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
         match value.downcast::<PyType>() {
             Ok(cls) => {
                 let both_module = instance.class().fast_issubclass(vm.ctx.types.module_type)
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index cd943ae1bd9..e19dbceb8da 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -43,13 +43,14 @@ pub(super) mod types {
     use super::*;
     use crate::PyPayload;
     use crate::builtins::PyGenericAlias;
+    use crate::types::{Constructor, Initializer};
 
     #[pyexception(name, base = PyBaseException, ctx = "base_exception_group")]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PyBaseExceptionGroup(PyBaseException);
 
-    #[pyexception]
+    #[pyexception(with(Constructor, Initializer))]
     impl PyBaseExceptionGroup {
         #[pyclassmethod]
         fn __class_getitem__(
@@ -60,117 +61,6 @@ pub(super) mod types {
             PyGenericAlias::from_args(cls, args, vm)
         }
 
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            // Validate exactly 2 positional arguments
-            if args.args.len() != 2 {
-                return Err(vm.new_type_error(format!(
-                    "BaseExceptionGroup.__new__() takes exactly 2 positional arguments ({} given)",
-                    args.args.len()
-                )));
-            }
-
-            // Validate message is str
-            let message = args.args[0].clone();
-            if !message.fast_isinstance(vm.ctx.types.str_type) {
-                return Err(vm.new_type_error(format!(
-                    "argument 1 must be str, not {}",
-                    message.class().name()
-                )));
-            }
-
-            // Validate exceptions is a sequence (not set or None)
-            let exceptions_arg = &args.args[1];
-
-            // Check for set/frozenset (not a sequence - unordered)
-            if exceptions_arg.fast_isinstance(vm.ctx.types.set_type)
-                || exceptions_arg.fast_isinstance(vm.ctx.types.frozenset_type)
-            {
-                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
-            }
-
-            // Check for None
-            if exceptions_arg.is(&vm.ctx.none) {
-                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
-            }
-
-            let exceptions: Vec<PyObjectRef> = exceptions_arg.try_to_value(vm).map_err(|_| {
-                vm.new_type_error("second argument (exceptions) must be a sequence")
-            })?;
-
-            // Validate non-empty
-            if exceptions.is_empty() {
-                return Err(vm.new_value_error(
-                    "second argument (exceptions) must be a non-empty sequence".to_owned(),
-                ));
-            }
-
-            // Validate all items are BaseException instances
-            let mut has_non_exception = false;
-            for (i, exc) in exceptions.iter().enumerate() {
-                if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_type) {
-                    return Err(vm.new_value_error(format!(
-                        "Item {} of second argument (exceptions) is not an exception",
-                        i
-                    )));
-                }
-                // Check if any exception is not an Exception subclass
-                // With dynamic ExceptionGroup (inherits from both BaseExceptionGroup and Exception),
-                // ExceptionGroup instances are automatically instances of Exception
-                if !exc.fast_isinstance(vm.ctx.exceptions.exception_type) {
-                    has_non_exception = true;
-                }
-            }
-
-            // Get the dynamic ExceptionGroup type
-            let exception_group_type = crate::exception_group::exception_group();
-
-            // Determine the actual class to use
-            let actual_cls = if cls.is(exception_group_type) {
-                // ExceptionGroup cannot contain BaseExceptions that are not Exception
-                if has_non_exception {
-                    return Err(
-                        vm.new_type_error("Cannot nest BaseExceptions in an ExceptionGroup")
-                    );
-                }
-                cls
-            } else if cls.is(vm.ctx.exceptions.base_exception_group) {
-                // Auto-convert to ExceptionGroup if all are Exception subclasses
-                if !has_non_exception {
-                    exception_group_type.to_owned()
-                } else {
-                    cls
-                }
-            } else {
-                // User-defined subclass
-                if has_non_exception && cls.fast_issubclass(vm.ctx.exceptions.exception_type) {
-                    return Err(vm.new_type_error(format!(
-                        "Cannot nest BaseExceptions in '{}'",
-                        cls.name()
-                    )));
-                }
-                cls
-            };
-
-            // Create the exception with (message, exceptions_tuple) as args
-            let exceptions_tuple = vm.ctx.new_tuple(exceptions);
-            let init_args = vec![message, exceptions_tuple.into()];
-            PyBaseException::new(init_args, vm)
-                .into_ref_with_type(vm, actual_cls)
-                .map(Into::into)
-        }
-
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
-            // CPython's BaseExceptionGroup.__init__ just calls BaseException.__init__
-            // which stores args as-is. Since __new__ already set up the correct args
-            // (message, exceptions_tuple), we don't need to do anything here.
-            // This also allows subclasses to pass extra arguments to __new__ without
-            // __init__ complaining about argument count.
-            Ok(())
-        }
-
         #[pymethod]
         fn derive(
             zelf: PyRef<PyBaseException>,
@@ -351,6 +241,136 @@ pub(super) mod types {
         }
     }
 
+    impl Constructor for PyBaseExceptionGroup {
+        type Args = crate::function::PosArgs;
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let args: Self::Args = args.bind(vm)?;
+            let args = args.into_vec();
+            // Validate exactly 2 positional arguments
+            if args.len() != 2 {
+                return Err(vm.new_type_error(format!(
+                    "BaseExceptionGroup.__new__() takes exactly 2 positional arguments ({} given)",
+                    args.len()
+                )));
+            }
+
+            // Validate message is str
+            let message = args[0].clone();
+            if !message.fast_isinstance(vm.ctx.types.str_type) {
+                return Err(vm.new_type_error(format!(
+                    "argument 1 must be str, not {}",
+                    message.class().name()
+                )));
+            }
+
+            // Validate exceptions is a sequence (not set or None)
+            let exceptions_arg = &args[1];
+
+            // Check for set/frozenset (not a sequence - unordered)
+            if exceptions_arg.fast_isinstance(vm.ctx.types.set_type)
+                || exceptions_arg.fast_isinstance(vm.ctx.types.frozenset_type)
+            {
+                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
+            }
+
+            // Check for None
+            if exceptions_arg.is(&vm.ctx.none) {
+                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
+            }
+
+            let exceptions: Vec<PyObjectRef> = exceptions_arg.try_to_value(vm).map_err(|_| {
+                vm.new_type_error("second argument (exceptions) must be a sequence")
+            })?;
+
+            // Validate non-empty
+            if exceptions.is_empty() {
+                return Err(vm.new_value_error(
+                    "second argument (exceptions) must be a non-empty sequence".to_owned(),
+                ));
+            }
+
+            // Validate all items are BaseException instances
+            let mut has_non_exception = false;
+            for (i, exc) in exceptions.iter().enumerate() {
+                if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_type) {
+                    return Err(vm.new_value_error(format!(
+                        "Item {} of second argument (exceptions) is not an exception",
+                        i
+                    )));
+                }
+                // Check if any exception is not an Exception subclass
+                // With dynamic ExceptionGroup (inherits from both BaseExceptionGroup and Exception),
+                // ExceptionGroup instances are automatically instances of Exception
+                if !exc.fast_isinstance(vm.ctx.exceptions.exception_type) {
+                    has_non_exception = true;
+                }
+            }
+
+            // Get the dynamic ExceptionGroup type
+            let exception_group_type = crate::exception_group::exception_group();
+
+            // Determine the actual class to use
+            let actual_cls = if cls.is(exception_group_type) {
+                // ExceptionGroup cannot contain BaseExceptions that are not Exception
+                if has_non_exception {
+                    return Err(
+                        vm.new_type_error("Cannot nest BaseExceptions in an ExceptionGroup")
+                    );
+                }
+                cls
+            } else if cls.is(vm.ctx.exceptions.base_exception_group) {
+                // Auto-convert to ExceptionGroup if all are Exception subclasses
+                if !has_non_exception {
+                    exception_group_type.to_owned()
+                } else {
+                    cls
+                }
+            } else {
+                // User-defined subclass
+                if has_non_exception && cls.fast_issubclass(vm.ctx.exceptions.exception_type) {
+                    return Err(vm.new_type_error(format!(
+                        "Cannot nest BaseExceptions in '{}'",
+                        cls.name()
+                    )));
+                }
+                cls
+            };
+
+            // Create the exception with (message, exceptions_tuple) as args
+            let exceptions_tuple = vm.ctx.new_tuple(exceptions);
+            let init_args = vec![message, exceptions_tuple.into()];
+            PyBaseException::new(init_args, vm)
+                .into_ref_with_type(vm, actual_cls)
+                .map(Into::into)
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
+    }
+
+    impl Initializer for PyBaseExceptionGroup {
+        type Args = FuncArgs;
+
+        fn slot_init(
+            _zelf: PyObjectRef,
+            _args: ::rustpython_vm::function::FuncArgs,
+            _vm: &::rustpython_vm::VirtualMachine,
+        ) -> ::rustpython_vm::PyResult<()> {
+            // CPython's BaseExceptionGroup.__init__ just calls BaseException.__init__
+            // which stores args as-is. Since __new__ already set up the correct args
+            // (message, exceptions_tuple), we don't need to do anything here.
+            // This also allows subclasses to pass extra arguments to __new__ without
+            // __init__ complaining about argument count.
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     // Helper functions for ExceptionGroup
     fn is_base_exception_group(obj: &PyObject, vm: &VirtualMachine) -> bool {
         obj.fast_isinstance(vm.ctx.exceptions.base_exception_group)
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index bb10ca02c2c..2c36aa13bd5 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -1371,18 +1371,19 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyStopIteration(PyException);
 
-    #[pyexception]
-    impl PyStopIteration {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
+    #[pyexception(with(Initializer))]
+    impl PyStopIteration {}
+
+    impl Initializer for PyStopIteration {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             zelf.set_attr("value", vm.unwrap_or_none(args.args.first().cloned()), vm)?;
             Ok(())
         }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
     }
 
     #[pyexception(name, base = PyException, ctx = "stop_async_iteration", impl)]
@@ -1419,15 +1420,13 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyAttributeError(PyException);
 
-    #[pyexception]
-    impl PyAttributeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
+    #[pyexception(with(Initializer))]
+    impl PyAttributeError {}
+
+    impl Initializer for PyAttributeError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             zelf.set_attr(
                 "name",
                 vm.unwrap_or_none(args.kwargs.get("name").cloned()),
@@ -1440,6 +1439,10 @@ pub(super) mod types {
             )?;
             Ok(())
         }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
     }
 
     #[pyexception(name, base = PyException, ctx = "buffer_error", impl)]
@@ -1457,15 +1460,28 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyImportError(PyException);
 
-    #[pyexception]
+    #[pyexception(with(Initializer))]
     impl PyImportError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
+        #[pymethod]
+        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
+            let obj = exc.as_object().to_owned();
+            let mut result: Vec<PyObjectRef> = vec![
+                obj.class().to_owned().into(),
+                vm.new_tuple((exc.get_arg(0).unwrap(),)).into(),
+            ];
+
+            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
+                result.push(dict.into());
+            }
+
+            result.into_pytuple(vm)
+        }
+    }
+
+    impl Initializer for PyImportError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let mut kwargs = args.kwargs.clone();
             let name = kwargs.swap_remove("name");
             let path = kwargs.swap_remove("path");
@@ -1482,19 +1498,9 @@ pub(super) mod types {
             dict.set_item("path", vm.unwrap_or_none(path), vm)?;
             PyBaseException::slot_init(zelf, args, vm)
         }
-        #[pymethod]
-        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
-            let obj = exc.as_object().to_owned();
-            let mut result: Vec<PyObjectRef> = vec![
-                obj.class().to_owned().into(),
-                vm.new_tuple((exc.get_arg(0).unwrap(),)).into(),
-            ];
 
-            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
-                result.push(dict.into());
-            }
-
-            result.into_pytuple(vm)
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
         }
     }
 
@@ -1660,11 +1666,10 @@ pub(super) mod types {
         }
     }
 
-    #[pyexception(with(Constructor))]
-    impl PyOSError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+    impl Initializer for PyOSError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let len = args.args.len();
             let mut new_args = args;
 
@@ -1718,6 +1723,13 @@ pub(super) mod types {
             PyBaseException::slot_init(zelf, new_args, vm)
         }
 
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(with(Constructor, Initializer))]
+    impl PyOSError {
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             let obj = exc.as_object().to_owned();
@@ -2011,44 +2023,8 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PySyntaxError(PyException);
 
-    #[pyexception]
+    #[pyexception(with(Initializer))]
     impl PySyntaxError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let len = args.args.len();
-            let new_args = args;
-
-            zelf.set_attr("print_file_and_line", vm.ctx.none(), vm)?;
-
-            if len == 2
-                && let Ok(location_tuple) = new_args.args[1]
-                    .clone()
-                    .downcast::<crate::builtins::PyTuple>()
-            {
-                let location_tup_len = location_tuple.len();
-                for (i, &attr) in [
-                    "filename",
-                    "lineno",
-                    "offset",
-                    "text",
-                    "end_lineno",
-                    "end_offset",
-                ]
-                .iter()
-                .enumerate()
-                {
-                    if location_tup_len > i {
-                        zelf.set_attr(attr, location_tuple[i].to_owned(), vm)?;
-                    } else {
-                        break;
-                    }
-                }
-            }
-
-            PyBaseException::slot_init(zelf, new_args, vm)
-        }
-
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyStrRef {
             fn basename(filename: &str) -> &str {
@@ -2097,6 +2073,48 @@ pub(super) mod types {
         }
     }
 
+    impl Initializer for PySyntaxError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let len = args.args.len();
+            let new_args = args;
+
+            zelf.set_attr("print_file_and_line", vm.ctx.none(), vm)?;
+
+            if len == 2
+                && let Ok(location_tuple) = new_args.args[1]
+                    .clone()
+                    .downcast::<crate::builtins::PyTuple>()
+            {
+                let location_tup_len = location_tuple.len();
+                for (i, &attr) in [
+                    "filename",
+                    "lineno",
+                    "offset",
+                    "text",
+                    "end_lineno",
+                    "end_offset",
+                ]
+                .iter()
+                .enumerate()
+                {
+                    if location_tup_len > i {
+                        zelf.set_attr(attr, location_tuple[i].to_owned(), vm)?;
+                    } else {
+                        break;
+                    }
+                }
+            }
+
+            PyBaseException::slot_init(zelf, new_args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyexception(
         name = "_IncompleteInputError",
         base = PySyntaxError,
@@ -2106,17 +2124,19 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyIncompleteInputError(PySyntaxError);
 
-    #[pyexception]
-    impl PyIncompleteInputError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            _args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
+    #[pyexception(with(Initializer))]
+    impl PyIncompleteInputError {}
+
+    impl Initializer for PyIncompleteInputError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             zelf.set_attr("name", vm.ctx.new_str("SyntaxError"), vm)?;
-            Ok(())
+            PySyntaxError::slot_init(zelf, args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
         }
     }
 
@@ -2155,26 +2175,8 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyUnicodeDecodeError(PyUnicodeError);
 
-    #[pyexception]
+    #[pyexception(with(Initializer))]
     impl PyUnicodeDecodeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, ArgBytesLike, isize, isize, PyStrRef);
-            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
-            zelf.set_attr("encoding", encoding, vm)?;
-            let object_as_bytes = vm.ctx.new_bytes(object.borrow_buf().to_vec());
-            zelf.set_attr("object", object_as_bytes, vm)?;
-            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
-            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
-            zelf.set_attr("reason", reason, vm)?;
-            Ok(())
-        }
-
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
             let Ok(object) = exc.as_object().get_attr("object", vm) else {
@@ -2202,30 +2204,33 @@ pub(super) mod types {
         }
     }
 
-    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_encode_error")]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PyUnicodeEncodeError(PyUnicodeError);
+    impl Initializer for PyUnicodeDecodeError {
+        type Args = FuncArgs;
 
-    #[pyexception]
-    impl PyUnicodeEncodeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, PyStrRef, isize, isize, PyStrRef);
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, ArgBytesLike, isize, isize, PyStrRef);
             let (encoding, object, start, end, reason): Args = args.bind(vm)?;
             zelf.set_attr("encoding", encoding, vm)?;
-            zelf.set_attr("object", object, vm)?;
+            let object_as_bytes = vm.ctx.new_bytes(object.borrow_buf().to_vec());
+            zelf.set_attr("object", object_as_bytes, vm)?;
             zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
             zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
             zelf.set_attr("reason", reason, vm)?;
             Ok(())
         }
 
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_encode_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeEncodeError(PyUnicodeError);
+
+    #[pyexception(with(Initializer))]
+    impl PyUnicodeEncodeError {
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
             let Ok(object) = exc.as_object().get_attr("object", vm) else {
@@ -2254,22 +2259,13 @@ pub(super) mod types {
         }
     }
 
-    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_translate_error")]
-    #[derive(Debug)]
-    #[repr(transparent)]
-    pub struct PyUnicodeTranslateError(PyUnicodeError);
+    impl Initializer for PyUnicodeEncodeError {
+        type Args = FuncArgs;
 
-    #[pyexception]
-    impl PyUnicodeTranslateError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, isize, isize, PyStrRef);
-            let (object, start, end, reason): Args = args.bind(vm)?;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, PyStrRef, isize, isize, PyStrRef);
+            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
+            zelf.set_attr("encoding", encoding, vm)?;
             zelf.set_attr("object", object, vm)?;
             zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
             zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
@@ -2277,6 +2273,18 @@ pub(super) mod types {
             Ok(())
         }
 
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_translate_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeTranslateError(PyUnicodeError);
+
+    #[pyexception(with(Initializer))]
+    impl PyUnicodeTranslateError {
         #[pymethod]
         fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
             let Ok(object) = exc.as_object().get_attr("object", vm) else {
@@ -2301,6 +2309,24 @@ pub(super) mod types {
         }
     }
 
+    impl Initializer for PyUnicodeTranslateError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, isize, isize, PyStrRef);
+            let (object, start, end, reason): Args = args.bind(vm)?;
+            zelf.set_attr("object", object, vm)?;
+            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
+            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
+            zelf.set_attr("reason", reason, vm)?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     /// JIT error.
     #[cfg(feature = "jit")]
     #[pyexception(name, base = PyException, ctx = "jit_error", impl)]
diff --git a/crates/vm/src/stdlib/ast/python.rs b/crates/vm/src/stdlib/ast/python.rs
index aa21d8b034a..35fe561527b 100644
--- a/crates/vm/src/stdlib/ast/python.rs
+++ b/crates/vm/src/stdlib/ast/python.rs
@@ -3,50 +3,18 @@ use super::{PY_CF_OPTIMIZED_AST, PY_CF_TYPE_COMMENTS, PY_COMPILE_FLAG_AST_ONLY};
 #[pymodule]
 pub(crate) mod _ast {
     use crate::{
-        AsObject, Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef},
         function::FuncArgs,
-        types::Constructor,
+        types::{Constructor, Initializer},
     };
     #[pyattr]
     #[pyclass(module = "_ast", name = "AST")]
     #[derive(Debug, PyPayload)]
     pub(crate) struct NodeAst;
 
-    #[pyclass(with(Constructor), flags(BASETYPE, HAS_DICT))]
+    #[pyclass(with(Constructor, Initializer), flags(BASETYPE, HAS_DICT))]
     impl NodeAst {
-        #[pyslot]
-        #[pymethod]
-        fn __init__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let fields = zelf.get_attr("_fields", vm)?;
-            let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
-            let n_args = args.args.len();
-            if n_args > fields.len() {
-                return Err(vm.new_type_error(format!(
-                    "{} constructor takes at most {} positional argument{}",
-                    zelf.class().name(),
-                    fields.len(),
-                    if fields.len() == 1 { "" } else { "s" },
-                )));
-            }
-            for (name, arg) in fields.iter().zip(args.args) {
-                zelf.set_attr(name, arg, vm)?;
-            }
-            for (key, value) in args.kwargs {
-                if let Some(pos) = fields.iter().position(|f| f.as_str() == key)
-                    && pos < n_args
-                {
-                    return Err(vm.new_type_error(format!(
-                        "{} got multiple values for argument '{}'",
-                        zelf.class().name(),
-                        key
-                    )));
-                }
-                zelf.set_attr(vm.ctx.intern_str(key), value, vm)?;
-            }
-            Ok(())
-        }
-
         #[pyattr]
         fn _fields(ctx: &Context) -> PyTupleRef {
             ctx.empty_tuple.clone()
@@ -71,7 +39,8 @@ pub(crate) mod _ast {
             let zelf = vm.ctx.new_base_object(cls, dict);
 
             // Initialize the instance with the provided arguments
-            Self::__init__(zelf.clone(), args, vm)?;
+            // FIXME: This is probably incorrect. Please check if init should be called outside of __new__
+            Self::slot_init(zelf.clone(), args, vm)?;
 
             Ok(zelf)
         }
@@ -81,6 +50,44 @@ pub(crate) mod _ast {
         }
     }
 
+    impl Initializer for NodeAst {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let fields = zelf.get_attr("_fields", vm)?;
+            let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
+            let n_args = args.args.len();
+            if n_args > fields.len() {
+                return Err(vm.new_type_error(format!(
+                    "{} constructor takes at most {} positional argument{}",
+                    zelf.class().name(),
+                    fields.len(),
+                    if fields.len() == 1 { "" } else { "s" },
+                )));
+            }
+            for (name, arg) in fields.iter().zip(args.args) {
+                zelf.set_attr(name, arg, vm)?;
+            }
+            for (key, value) in args.kwargs {
+                if let Some(pos) = fields.iter().position(|f| f.as_str() == key)
+                    && pos < n_args
+                {
+                    return Err(vm.new_type_error(format!(
+                        "{} got multiple values for argument '{}'",
+                        zelf.class().name(),
+                        key
+                    )));
+                }
+                zelf.set_attr(vm.ctx.intern_str(key), value, vm)?;
+            }
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyattr(name = "PyCF_ONLY_AST")]
     use super::PY_COMPILE_FLAG_AST_ONLY;
 

From 5925f1483c197fcde5300b0f3058b0977c03cd58 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Dec 2025 22:25:09 +0900
Subject: [PATCH 023/418] Bump insta from 1.44.3 to 1.45.0 (#6468)

Bumps [insta](https://github.com/mitsuhiko/insta) from 1.44.3 to 1.45.0.
- [Release notes](https://github.com/mitsuhiko/insta/releases)
- [Changelog](https://github.com/mitsuhiko/insta/blob/master/CHANGELOG.md)
- [Commits](https://github.com/mitsuhiko/insta/compare/1.44.3...1.45.0)

---
updated-dependencies:
- dependency-name: insta
  dependency-version: 1.45.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 +++++++++++++++++---
 Cargo.toml |  2 +-
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2873f3a529f..a57a36a40f9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1181,7 +1181,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
  "cfg-if",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1487,13 +1487,14 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.44.3"
+version = "1.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5c943d4415edd8153251b6f197de5eb1640e56d84e8d9159bea190421c73698"
+checksum = "b76866be74d68b1595eb8060cb9191dca9c021db2316558e52ddc5d55d41b66c"
 dependencies = [
  "console",
  "once_cell",
  "similar",
+ "tempfile",
 ]
 
 [[package]]
@@ -3721,6 +3722,19 @@ dependencies = [
  "shared-build",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "termios"
 version = "0.3.3"
diff --git a/Cargo.toml b/Cargo.toml
index f68e6e68157..fad506ddfaa 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -173,7 +173,7 @@ getrandom = { version = "0.3", features = ["std"] }
 glob = "0.3"
 hex = "0.4.3"
 indexmap = { version = "2.11.3", features = ["std"] }
-insta = "1.44"
+insta = "1.45"
 itertools = "0.14.0"
 is-macro = "0.3.7"
 junction = "1.3.0"

From 2342006b37ccfef8633bd937c1758ac1101f99a8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 23 Dec 2025 08:57:03 +0900
Subject: [PATCH 024/418] Bump aws-lc-rs from 1.15.1 to 1.15.2 (#6469)

Bumps [aws-lc-rs](https://github.com/aws/aws-lc-rs) from 1.15.1 to 1.15.2.
- [Release notes](https://github.com/aws/aws-lc-rs/releases)
- [Commits](https://github.com/aws/aws-lc-rs/compare/v1.15.1...v1.15.2)

---
updated-dependencies:
- dependency-name: aws-lc-rs
  dependency-version: 1.15.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock               | 8 ++++----
 crates/stdlib/Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a57a36a40f9..e3296732cb9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -254,9 +254,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.15.1"
+version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b5ce75405893cd713f9ab8e297d8e438f624dde7d706108285f7e17a25a180f"
+checksum = "6a88aab2464f1f25453baa7a07c84c5b7684e274054ba06817f382357f77a288"
 dependencies = [
  "aws-lc-fips-sys",
  "aws-lc-sys",
@@ -266,9 +266,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.34.0"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "179c3777a8b5e70e90ea426114ffc565b2c1a9f82f6c4a0c5a34aa6ef5e781b6"
+checksum = "b45afffdee1e7c9126814751f88dddc747f41d91da16c9551a0f1e8a11e788a1"
 dependencies = [
  "cc",
  "cmake",
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index a5328697ca8..0cd853223e2 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -127,7 +127,7 @@ x509-parser = { version = "0.18", optional = true }
 der = { version = "0.7", features = ["alloc", "oid"], optional = true }
 pem-rfc7468 = { version = "1.0", features = ["alloc"], optional = true }
 webpki-roots = { version = "1.0", optional = true }
-aws-lc-rs = { version = "1.14.1", optional = true }
+aws-lc-rs = { version = "1.15.2", optional = true }
 oid-registry = { version = "0.8", features = ["x509", "pkcs1", "nist_algs"], optional = true }
 pkcs8 = { version = "0.10", features = ["encryption", "pkcs5", "pem"], optional = true }
 

From d919fe516e65bd259d05295773d15859d597e7c7 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Fri, 19 Dec 2025 16:49:07 +0900
Subject: [PATCH 025/418] mark test_threading

---
 Lib/test/test_threading.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 94f21d1c38f..8f86792e820 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -229,6 +229,7 @@ def f(mutex):
 
     # PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
     # exposed at the Python level.  This test relies on ctypes to get at it.
+    @unittest.skip("TODO: RUSTPYTHON; expects @cpython_only")
     def test_PyThreadState_SetAsyncExc(self):
         ctypes = import_module("ctypes")
 
@@ -332,6 +333,7 @@ def fail_new_thread(*args):
         finally:
             threading._start_new_thread = _start_new_thread
 
+    @unittest.skip("TODO: RUSTPYTHON; ctypes.pythonapi is not supported")
     def test_finalize_running_thread(self):
         # Issue 1402: the PyGILState_Ensure / _Release functions may be called
         # very late on python exit: on deallocation of a running thread for

From 73e1c3816e737b0559063c44f52537d6963aa267 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 11:55:59 +0900
Subject: [PATCH 026/418] fix ssl

---
 crates/stdlib/src/openssl.rs | 14 ++++++++++----
 crates/stdlib/src/ssl.rs     | 18 ++++++++++--------
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index 4d420e7d539..d352d15a614 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -1543,10 +1543,10 @@ mod _ssl {
         #[pymethod]
         fn get_ca_certs(
             &self,
-            binary_form: OptionalArg<bool>,
+            args: GetCertArgs,
             vm: &VirtualMachine,
         ) -> PyResult<Vec<PyObjectRef>> {
-            let binary_form = binary_form.unwrap_or(false);
+            let binary_form = args.binary_form.unwrap_or(false);
             let ctx = self.ctx();
             #[cfg(ossl300)]
             let certs = ctx.cert_store().all_certificates();
@@ -2259,6 +2259,12 @@ mod _ssl {
         password: Option<PyObjectRef>,
     }
 
+    #[derive(FromArgs)]
+    struct GetCertArgs {
+        #[pyarg(any, optional)]
+        binary_form: OptionalArg<bool>,
+    }
+
     // Err is true if the socket is blocking
     type SocketDeadline = Result<Instant, bool>;
 
@@ -2516,10 +2522,10 @@ mod _ssl {
         #[pymethod]
         fn getpeercert(
             &self,
-            binary: OptionalArg<bool>,
+            args: GetCertArgs,
             vm: &VirtualMachine,
         ) -> PyResult<Option<PyObjectRef>> {
-            let binary = binary.unwrap_or(false);
+            let binary = args.binary_form.unwrap_or(false);
             let stream = self.connection.read();
             if !stream.ssl().is_init_finished() {
                 return Err(vm.new_value_error("handshake not done yet"));
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index bf25260ed3a..16449e2d019 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -841,6 +841,12 @@ mod _ssl {
         password: OptionalArg<PyObjectRef>,
     }
 
+    #[derive(FromArgs)]
+    struct GetCertArgs {
+        #[pyarg(any, optional)]
+        binary_form: OptionalArg<bool>,
+    }
+
     #[pyclass(with(Constructor), flags(BASETYPE))]
     impl PySSLContext {
         // Helper method to convert DER certificate bytes to Python dict
@@ -1688,12 +1694,8 @@ mod _ssl {
         }
 
         #[pymethod]
-        fn get_ca_certs(
-            &self,
-            binary_form: OptionalArg<bool>,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyListRef> {
-            let binary_form = binary_form.unwrap_or(false);
+        fn get_ca_certs(&self, args: GetCertArgs, vm: &VirtualMachine) -> PyResult<PyListRef> {
+            let binary_form = args.binary_form.unwrap_or(false);
             let ca_certs_der = self.ca_certs_der.read();
 
             let mut certs = Vec::new();
@@ -3444,10 +3446,10 @@ mod _ssl {
         #[pymethod]
         fn getpeercert(
             &self,
-            binary_form: OptionalArg<bool>,
+            args: GetCertArgs,
             vm: &VirtualMachine,
         ) -> PyResult<Option<PyObjectRef>> {
-            let binary = binary_form.unwrap_or(false);
+            let binary = args.binary_form.unwrap_or(false);
 
             // Check if handshake is complete
             if !*self.handshake_done.lock() {

From a84452ab457c71880e1a90cc488c314596d7d184 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 11:52:31 +0900
Subject: [PATCH 027/418] fix sysconfigdata

---
 Lib/test/test_sysconfig.py            |  1 -
 crates/vm/src/stdlib/sysconfigdata.rs | 17 +++++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py
index 35e62d54635..965780668ca 100644
--- a/Lib/test/test_sysconfig.py
+++ b/Lib/test/test_sysconfig.py
@@ -447,7 +447,6 @@ def test_main(self):
             _main()
         self.assertTrue(len(output.getvalue().split('\n')) > 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.platform == "win32", "Does not apply to Windows")
     def test_ldshared_value(self):
         ldflags = sysconfig.get_config_var('LDFLAGS')
diff --git a/crates/vm/src/stdlib/sysconfigdata.rs b/crates/vm/src/stdlib/sysconfigdata.rs
index 90e46b83b97..ee40b693aa2 100644
--- a/crates/vm/src/stdlib/sysconfigdata.rs
+++ b/crates/vm/src/stdlib/sysconfigdata.rs
@@ -1,3 +1,5 @@
+// spell-checker: words LDSHARED ARFLAGS CPPFLAGS CCSHARED BASECFLAGS BLDSHARED
+
 pub(crate) use _sysconfigdata::make_module;
 
 #[pymodule]
@@ -18,6 +20,21 @@ pub(crate) mod _sysconfigdata {
             "MULTIARCH" => MULTIARCH,
             // enough for tests to stop expecting urandom() to fail after restricting file resources
             "HAVE_GETRANDOM" => 1,
+            // Compiler configuration for native extension builds
+            "CC" => "cc",
+            "CXX" => "c++",
+            "CFLAGS" => "",
+            "CPPFLAGS" => "",
+            "LDFLAGS" => "",
+            "LDSHARED" => "cc -shared",
+            "CCSHARED" => "",
+            "SHLIB_SUFFIX" => ".so",
+            "SO" => ".so",
+            "AR" => "ar",
+            "ARFLAGS" => "rcs",
+            "OPT" => "",
+            "BASECFLAGS" => "",
+            "BLDSHARED" => "cc -shared",
         }
         include!(concat!(env!("OUT_DIR"), "/env_vars.rs"));
         vars

From df523cb58c42a9a10a539ca1598dd264876da4f4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 14:58:42 +0900
Subject: [PATCH 028/418] skip spawnve on windows

---
 Lib/test/test_os.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 105629bda19..939315379f2 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -3491,6 +3491,7 @@ def test_spawnl(self):
         self.assertEqual(exitcode, self.exitcode)
 
     @requires_os_func('spawnle')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnle(self):
         program, args = self.create_args(with_env=True)
         exitcode = os.spawnle(os.P_WAIT, program, *args, self.env)
@@ -3519,6 +3520,7 @@ def test_spawnv(self):
         self.assertEqual(exitcode, self.exitcode)
 
     @requires_os_func('spawnve')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnve(self):
         program, args = self.create_args(with_env=True)
         exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
@@ -3627,6 +3629,7 @@ def _test_invalid_env(self, spawn):
         self.assertEqual(exitcode, 0)
 
     @requires_os_func('spawnve')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnve_invalid_env(self):
         self._test_invalid_env(os.spawnve)
 

From 9760249a750c272733369ff886aac22ffbe25d31 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 15:24:07 +0900
Subject: [PATCH 029/418] fix multiarch

---
 Lib/test/test_sysconfig.py            |  1 -
 crates/vm/src/stdlib/sys.rs           | 20 +++++++++++++-------
 crates/vm/src/stdlib/sysconfigdata.rs | 11 +++++++----
 3 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py
index 965780668ca..82c11bdf7e2 100644
--- a/Lib/test/test_sysconfig.py
+++ b/Lib/test/test_sysconfig.py
@@ -598,7 +598,6 @@ def test_android_ext_suffix(self):
         self.assertTrue(suffix.endswith(f"-{expected_triplet}.so"),
                         f"{machine=}, {suffix=}")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.platform == 'darwin', 'OS X-specific test')
     def test_osx_ext_suffix(self):
         suffix = sysconfig.get_config_var('EXT_SUFFIX')
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index cfe6f9f5e61..0e46ec18a01 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1,6 +1,8 @@
 use crate::{Py, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
 
-pub(crate) use sys::{__module_def, DOC, MAXSIZE, MULTIARCH, UnraisableHookArgsData};
+pub(crate) use sys::{
+    __module_def, DOC, MAXSIZE, RUST_MULTIARCH, UnraisableHookArgsData, multiarch,
+};
 
 #[pymodule]
 mod sys {
@@ -37,10 +39,14 @@ mod sys {
         System::LibraryLoader::{GetModuleFileNameW, GetModuleHandleW},
     };
 
-    // not the same as CPython (e.g. rust's x86_x64-unknown-linux-gnu is just x86_64-linux-gnu)
-    // but hopefully that's just an implementation detail? TODO: copy CPython's multiarch exactly,
-    // https://github.com/python/cpython/blob/3.8/configure.ac#L725
-    pub(crate) const MULTIARCH: &str = env!("RUSTPYTHON_TARGET_TRIPLE");
+    // Rust target triple (e.g., "x86_64-unknown-linux-gnu")
+    pub(crate) const RUST_MULTIARCH: &str = env!("RUSTPYTHON_TARGET_TRIPLE");
+
+    /// Convert Rust target triple to CPython-style multiarch
+    /// e.g., "x86_64-unknown-linux-gnu" -> "x86_64-linux-gnu"
+    pub(crate) fn multiarch() -> String {
+        RUST_MULTIARCH.replace("-unknown", "")
+    }
 
     #[pyattr(name = "_rustpython_debugbuild")]
     const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
@@ -189,7 +195,7 @@ mod sys {
         py_namespace!(vm, {
             "name" => ctx.new_str(NAME),
             "cache_tag" => ctx.new_str(cache_tag),
-            "_multiarch" => ctx.new_str(MULTIARCH.to_owned()),
+            "_multiarch" => ctx.new_str(multiarch()),
             "version" => version_info(vm),
             "hexversion" => ctx.new_int(version::VERSION_HEX),
         })
@@ -1249,6 +1255,6 @@ pub(crate) fn sysconfigdata_name() -> String {
         "_sysconfigdata_{}_{}_{}",
         sys::ABIFLAGS,
         sys::PLATFORM,
-        sys::MULTIARCH
+        sys::multiarch()
     )
 }
diff --git a/crates/vm/src/stdlib/sysconfigdata.rs b/crates/vm/src/stdlib/sysconfigdata.rs
index ee40b693aa2..5e954f7fe7a 100644
--- a/crates/vm/src/stdlib/sysconfigdata.rs
+++ b/crates/vm/src/stdlib/sysconfigdata.rs
@@ -4,20 +4,23 @@ pub(crate) use _sysconfigdata::make_module;
 
 #[pymodule]
 pub(crate) mod _sysconfigdata {
-    use crate::{VirtualMachine, builtins::PyDictRef, convert::ToPyObject, stdlib::sys::MULTIARCH};
+    use crate::stdlib::sys::{RUST_MULTIARCH, multiarch};
+    use crate::{VirtualMachine, builtins::PyDictRef, convert::ToPyObject};
 
     #[pyattr]
     fn build_time_vars(vm: &VirtualMachine) -> PyDictRef {
         let vars = vm.ctx.new_dict();
+        let multiarch = multiarch();
         macro_rules! sysvars {
             ($($key:literal => $value:expr),*$(,)?) => {{
                 $(vars.set_item($key, $value.to_pyobject(vm), vm).unwrap();)*
             }};
         }
         sysvars! {
-            // fake shared module extension
-            "EXT_SUFFIX" => format!(".rustpython-{MULTIARCH}"),
-            "MULTIARCH" => MULTIARCH,
+            // Extension module suffix in CPython-compatible format
+            "EXT_SUFFIX" => format!(".rustpython313-{multiarch}.so"),
+            "MULTIARCH" => multiarch.clone(),
+            "RUST_MULTIARCH" => RUST_MULTIARCH,
             // enough for tests to stop expecting urandom() to fail after restricting file resources
             "HAVE_GETRANDOM" => 1,
             // Compiler configuration for native extension builds

From b44229f7ca4f7718f405c4a0f397c2a70c9178ec Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 21:57:05 +0900
Subject: [PATCH 030/418] debug whats_left

---
 whats_left.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/whats_left.py b/whats_left.py
index 91e46bef7ef..7d02a4cea4d 100755
--- a/whats_left.py
+++ b/whats_left.py
@@ -361,7 +361,7 @@ def method_incompatibility_reason(typ, method_name, real_method_value):
 
     if platform.python_implementation() == "CPython":
         if not_implementeds:
-            sys.exit("ERROR: CPython should have all the methods")
+            sys.exit(f"ERROR: CPython should have all the methods but missing: {not_implementeds}")
 
     mod_names = [
         name.decode()
@@ -455,6 +455,7 @@ def remove_one_indent(s):
 )
 # The last line should be json output, the rest of the lines can contain noise
 # because importing certain modules can print stuff to stdout/stderr
+print(result.stderr, file=sys.stderr)
 result = json.loads(result.stdout.splitlines()[-1])
 
 if args.json:

From fc0a34a5a53730a0f1b59c432e568fea9f84b8f3 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sat, 20 Dec 2025 14:31:33 +0900
Subject: [PATCH 031/418] Remove unused ctypes/field.rs

---
 crates/vm/src/stdlib/ctypes/field.rs | 306 ---------------------------
 1 file changed, 306 deletions(-)
 delete mode 100644 crates/vm/src/stdlib/ctypes/field.rs

diff --git a/crates/vm/src/stdlib/ctypes/field.rs b/crates/vm/src/stdlib/ctypes/field.rs
deleted file mode 100644
index ea57d68065a..00000000000
--- a/crates/vm/src/stdlib/ctypes/field.rs
+++ /dev/null
@@ -1,306 +0,0 @@
-use crate::builtins::PyType;
-use crate::function::PySetterValue;
-use crate::types::{GetDescriptor, Representable};
-use crate::{AsObject, Py, PyObject, PyObjectRef, PyResult, VirtualMachine};
-use num_traits::ToPrimitive;
-
-use super::structure::PyCStructure;
-use super::union::PyCUnion;
-
-#[pyclass(name = "PyCFieldType", base = PyType, module = "_ctypes")]
-#[derive(Debug)]
-pub struct PyCFieldType {
-    pub _base: PyType,
-    #[allow(dead_code)]
-    pub(super) inner: PyCField,
-}
-
-#[pyclass]
-impl PyCFieldType {}
-
-#[pyclass(name = "CField", module = "_ctypes")]
-#[derive(Debug, PyPayload)]
-pub struct PyCField {
-    pub(super) byte_offset: usize,
-    pub(super) byte_size: usize,
-    #[allow(unused)]
-    pub(super) index: usize,
-    /// The ctypes type for this field (can be any ctypes type including arrays)
-    pub(super) proto: PyObjectRef,
-    pub(super) anonymous: bool,
-    pub(super) bitfield_size: bool,
-    pub(super) bit_offset: u8,
-    pub(super) name: String,
-}
-
-impl PyCField {
-    pub fn new(
-        name: String,
-        proto: PyObjectRef,
-        byte_offset: usize,
-        byte_size: usize,
-        index: usize,
-    ) -> Self {
-        Self {
-            name,
-            proto,
-            byte_offset,
-            byte_size,
-            index,
-            anonymous: false,
-            bitfield_size: false,
-            bit_offset: 0,
-        }
-    }
-}
-
-impl Representable for PyCField {
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        // Get type name from the proto object
-        let tp_name = if let Some(name_attr) = vm
-            .ctx
-            .interned_str("__name__")
-            .and_then(|s| zelf.proto.get_attr(s, vm).ok())
-        {
-            name_attr.str(vm)?.to_string()
-        } else {
-            zelf.proto.class().name().to_string()
-        };
-
-        if zelf.bitfield_size {
-            Ok(format!(
-                "<{} type={}, ofs={byte_offset}, bit_size={bitfield_size}, bit_offset={bit_offset}",
-                zelf.name,
-                tp_name,
-                byte_offset = zelf.byte_offset,
-                bitfield_size = zelf.bitfield_size,
-                bit_offset = zelf.bit_offset
-            ))
-        } else {
-            Ok(format!(
-                "<{} type={tp_name}, ofs={}, size={}",
-                zelf.name, zelf.byte_offset, zelf.byte_size
-            ))
-        }
-    }
-}
-
-impl GetDescriptor for PyCField {
-    fn descr_get(
-        zelf: PyObjectRef,
-        obj: Option<PyObjectRef>,
-        _cls: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let zelf = zelf
-            .downcast::<PyCField>()
-            .map_err(|_| vm.new_type_error("expected CField".to_owned()))?;
-
-        // If obj is None, return the descriptor itself (class attribute access)
-        let obj = match obj {
-            Some(obj) if !vm.is_none(&obj) => obj,
-            _ => return Ok(zelf.into()),
-        };
-
-        // Instance attribute access - read value from the structure/union's buffer
-        if let Some(structure) = obj.downcast_ref::<PyCStructure>() {
-            let cdata = structure.cdata.read();
-            let offset = zelf.byte_offset;
-            let size = zelf.byte_size;
-
-            if offset + size <= cdata.buffer.len() {
-                let bytes = &cdata.buffer[offset..offset + size];
-                return PyCField::bytes_to_value(bytes, size, vm);
-            }
-        } else if let Some(union) = obj.downcast_ref::<PyCUnion>() {
-            let cdata = union.cdata.read();
-            let offset = zelf.byte_offset;
-            let size = zelf.byte_size;
-
-            if offset + size <= cdata.buffer.len() {
-                let bytes = &cdata.buffer[offset..offset + size];
-                return PyCField::bytes_to_value(bytes, size, vm);
-            }
-        }
-
-        // Fallback: return 0 for uninitialized or unsupported types
-        Ok(vm.ctx.new_int(0).into())
-    }
-}
-
-impl PyCField {
-    /// Convert bytes to a Python value based on size
-    fn bytes_to_value(bytes: &[u8], size: usize, vm: &VirtualMachine) -> PyResult {
-        match size {
-            1 => Ok(vm.ctx.new_int(bytes[0] as i8).into()),
-            2 => {
-                let val = i16::from_ne_bytes([bytes[0], bytes[1]]);
-                Ok(vm.ctx.new_int(val).into())
-            }
-            4 => {
-                let val = i32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
-                Ok(vm.ctx.new_int(val).into())
-            }
-            8 => {
-                let val = i64::from_ne_bytes([
-                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
-                ]);
-                Ok(vm.ctx.new_int(val).into())
-            }
-            _ => Ok(vm.ctx.new_int(0).into()),
-        }
-    }
-
-    /// Convert a Python value to bytes
-    fn value_to_bytes(value: &PyObject, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        if let Ok(int_val) = value.try_int(vm) {
-            let i = int_val.as_bigint();
-            match size {
-                1 => {
-                    let val = i.to_i8().unwrap_or(0);
-                    Ok(val.to_ne_bytes().to_vec())
-                }
-                2 => {
-                    let val = i.to_i16().unwrap_or(0);
-                    Ok(val.to_ne_bytes().to_vec())
-                }
-                4 => {
-                    let val = i.to_i32().unwrap_or(0);
-                    Ok(val.to_ne_bytes().to_vec())
-                }
-                8 => {
-                    let val = i.to_i64().unwrap_or(0);
-                    Ok(val.to_ne_bytes().to_vec())
-                }
-                _ => Ok(vec![0u8; size]),
-            }
-        } else {
-            Ok(vec![0u8; size])
-        }
-    }
-}
-
-#[pyclass(
-    flags(DISALLOW_INSTANTIATION, IMMUTABLETYPE),
-    with(Representable, GetDescriptor)
-)]
-impl PyCField {
-    #[pyslot]
-    fn descr_set(
-        zelf: &crate::PyObject,
-        obj: PyObjectRef,
-        value: PySetterValue<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let zelf = zelf
-            .downcast_ref::<PyCField>()
-            .ok_or_else(|| vm.new_type_error("expected CField".to_owned()))?;
-
-        // Get the structure/union instance - use downcast_ref() to access the struct data
-        if let Some(structure) = obj.downcast_ref::<PyCStructure>() {
-            match value {
-                PySetterValue::Assign(value) => {
-                    let offset = zelf.byte_offset;
-                    let size = zelf.byte_size;
-                    let bytes = PyCField::value_to_bytes(&value, size, vm)?;
-
-                    let mut cdata = structure.cdata.write();
-                    if offset + size <= cdata.buffer.len() {
-                        cdata.buffer[offset..offset + size].copy_from_slice(&bytes);
-                    }
-                    Ok(())
-                }
-                PySetterValue::Delete => {
-                    Err(vm.new_type_error("cannot delete structure field".to_owned()))
-                }
-            }
-        } else if let Some(union) = obj.downcast_ref::<PyCUnion>() {
-            match value {
-                PySetterValue::Assign(value) => {
-                    let offset = zelf.byte_offset;
-                    let size = zelf.byte_size;
-                    let bytes = PyCField::value_to_bytes(&value, size, vm)?;
-
-                    let mut cdata = union.cdata.write();
-                    if offset + size <= cdata.buffer.len() {
-                        cdata.buffer[offset..offset + size].copy_from_slice(&bytes);
-                    }
-                    Ok(())
-                }
-                PySetterValue::Delete => {
-                    Err(vm.new_type_error("cannot delete union field".to_owned()))
-                }
-            }
-        } else {
-            Err(vm.new_type_error(format!(
-                "descriptor works only on Structure or Union instances, got {}",
-                obj.class().name()
-            )))
-        }
-    }
-
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
-
-    #[pygetset]
-    fn size(&self) -> usize {
-        self.byte_size
-    }
-
-    #[pygetset]
-    fn bit_size(&self) -> bool {
-        self.bitfield_size
-    }
-
-    #[pygetset]
-    fn is_bitfield(&self) -> bool {
-        self.bitfield_size
-    }
-
-    #[pygetset]
-    fn is_anonymous(&self) -> bool {
-        self.anonymous
-    }
-
-    #[pygetset]
-    fn name(&self) -> String {
-        self.name.clone()
-    }
-
-    #[pygetset(name = "type")]
-    fn type_(&self) -> PyObjectRef {
-        self.proto.clone()
-    }
-
-    #[pygetset]
-    fn offset(&self) -> usize {
-        self.byte_offset
-    }
-
-    #[pygetset]
-    fn byte_offset(&self) -> usize {
-        self.byte_offset
-    }
-
-    #[pygetset]
-    fn byte_size(&self) -> usize {
-        self.byte_size
-    }
-
-    #[pygetset]
-    fn bit_offset(&self) -> u8 {
-        self.bit_offset
-    }
-}

From 286a5b5b8f8759808ed5a46f0256965bddcaf45d Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 23:28:58 +0900
Subject: [PATCH 032/418] msc_info in get_version

---
 Lib/platform.py          |  2 +-
 crates/vm/src/version.rs | 19 ++++++++++++++++++-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/Lib/platform.py b/Lib/platform.py
index 58b66078e1a..c64c6d2c6f5 100755
--- a/Lib/platform.py
+++ b/Lib/platform.py
@@ -1080,7 +1080,7 @@ def _sys_version(sys_version=None):
               match.groups()
 
         # XXX: RUSTPYTHON support
-        if "rustc" in sys_version:
+        if "RustPython" in sys_version:
             name = "RustPython"
         else:
             name = 'CPython'
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index 9d472e8be0a..deb3dccd535 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -15,12 +15,29 @@ pub const VERSION_HEX: usize =
     (MAJOR << 24) | (MINOR << 16) | (MICRO << 8) | (RELEASELEVEL_N << 4) | SERIAL;
 
 pub fn get_version() -> String {
+    // Windows: include MSC v. for compatibility with ctypes.util.find_library
+    // MSC v.1929 = VS 2019, version 14+ makes find_msvcrt() return None
+    #[cfg(windows)]
+    let msc_info = {
+        let arch = if cfg!(target_pointer_width = "64") {
+            "64 bit (AMD64)"
+        } else {
+            "32 bit (Intel)"
+        };
+        // Include both RustPython identifier and MSC v. for compatibility
+        format!(" MSC v.1929 {arch}",)
+    };
+
+    #[cfg(not(windows))]
+    let msc_info = String::new();
+
     format!(
-        "{:.80} ({:.80}) \n[RustPython {} with {:.80}]", // \n is PyPy convention
+        "{:.80} ({:.80}) \n[RustPython {} with {:.80}{}]", // \n is PyPy convention
         get_version_number(),
         get_build_info(),
         env!("CARGO_PKG_VERSION"),
         COMPILER,
+        msc_info,
     )
 }
 

From 4bf0bac52d0270c0efcbc248a3888789624a2645 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 23:29:15 +0900
Subject: [PATCH 033/418] debuggable whats_left

---
 whats_left.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/whats_left.py b/whats_left.py
index 7d02a4cea4d..c5b0be6eadc 100755
--- a/whats_left.py
+++ b/whats_left.py
@@ -361,7 +361,9 @@ def method_incompatibility_reason(typ, method_name, real_method_value):
 
     if platform.python_implementation() == "CPython":
         if not_implementeds:
-            sys.exit(f"ERROR: CPython should have all the methods but missing: {not_implementeds}")
+            sys.exit(
+                f"ERROR: CPython should have all the methods but missing: {not_implementeds}"
+            )
 
     mod_names = [
         name.decode()

From 79abbf0b29d5183b0885e45ea9991bd8d046d702 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 23:36:38 +0900
Subject: [PATCH 034/418] fix ctypes

---
 crates/vm/src/stdlib/ctypes.rs           | 102 ++-
 crates/vm/src/stdlib/ctypes/array.rs     |  44 +-
 crates/vm/src/stdlib/ctypes/base.rs      |  76 ++-
 crates/vm/src/stdlib/ctypes/function.rs  | 776 ++++++++++++++---------
 crates/vm/src/stdlib/ctypes/library.rs   | 108 +++-
 crates/vm/src/stdlib/ctypes/pointer.rs   | 147 ++++-
 crates/vm/src/stdlib/ctypes/simple.rs    | 187 ++++--
 crates/vm/src/stdlib/ctypes/structure.rs |   6 -
 8 files changed, 973 insertions(+), 473 deletions(-)

diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index 3fdb2df6104..9b922230431 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -95,6 +95,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     pointer::PyCPointerType::make_class(ctx);
     structure::PyCStructType::make_class(ctx);
     union::PyCUnionType::make_class(ctx);
+    function::PyCFuncPtrType::make_class(ctx);
     extend_module!(vm, &module, {
         "_CData" => PyCData::make_class(ctx),
         "_SimpleCData" => PyCSimple::make_class(ctx),
@@ -385,12 +386,8 @@ pub(crate) mod _ctypes {
     #[pyattr]
     const RTLD_GLOBAL: i32 = 0;
 
-    #[cfg(target_os = "windows")]
-    #[pyattr]
-    const SIZEOF_TIME_T: usize = 8;
-    #[cfg(not(target_os = "windows"))]
     #[pyattr]
-    const SIZEOF_TIME_T: usize = 4;
+    const SIZEOF_TIME_T: usize = std::mem::size_of::<libc::time_t>();
 
     #[pyattr]
     const CTYPES_MAX_ARGCOUNT: usize = 1024;
@@ -578,30 +575,42 @@ pub(crate) mod _ctypes {
     #[pyfunction(name = "dlopen")]
     fn load_library_unix(
         name: Option<crate::function::FsPath>,
-        _load_flags: OptionalArg<i32>,
+        load_flags: OptionalArg<i32>,
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
-        // TODO: audit functions first
-        // TODO: load_flags
+        // Default mode: RTLD_NOW | RTLD_LOCAL, always force RTLD_NOW
+        let mode = load_flags.unwrap_or(libc::RTLD_NOW | libc::RTLD_LOCAL) | libc::RTLD_NOW;
+
         match name {
             Some(name) => {
                 let cache = library::libcache();
                 let mut cache_write = cache.write();
                 let os_str = name.as_os_str(vm)?;
-                let (id, _) = cache_write.get_or_insert_lib(&*os_str, vm).map_err(|e| {
-                    // Include filename in error message for better diagnostics
-                    let name_str = os_str.to_string_lossy();
-                    vm.new_os_error(format!("{}: {}", name_str, e))
-                })?;
+                let (id, _) = cache_write
+                    .get_or_insert_lib_with_mode(&*os_str, mode, vm)
+                    .map_err(|e| {
+                        let name_str = os_str.to_string_lossy();
+                        vm.new_os_error(format!("{}: {}", name_str, e))
+                    })?;
                 Ok(id)
             }
             None => {
-                // If None, call libc::dlopen(null, mode) to get the current process handle
-                let handle = unsafe { libc::dlopen(std::ptr::null(), libc::RTLD_NOW) };
+                // dlopen(NULL, mode) to get the current process handle (for pythonapi)
+                let handle = unsafe { libc::dlopen(std::ptr::null(), mode) };
                 if handle.is_null() {
-                    return Err(vm.new_os_error("dlopen() error"));
+                    let err = unsafe { libc::dlerror() };
+                    let msg = if err.is_null() {
+                        "dlopen() error".to_string()
+                    } else {
+                        unsafe { std::ffi::CStr::from_ptr(err).to_string_lossy().into_owned() }
+                    };
+                    return Err(vm.new_os_error(msg));
                 }
-                Ok(handle as usize)
+                // Add to library cache so symbol lookup works
+                let cache = library::libcache();
+                let mut cache_write = cache.write();
+                let id = cache_write.insert_raw_handle(handle);
+                Ok(id)
             }
         }
     }
@@ -614,6 +623,48 @@ pub(crate) mod _ctypes {
         Ok(())
     }
 
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn dlclose(handle: usize, _vm: &VirtualMachine) -> PyResult<()> {
+        // Remove from cache, which triggers SharedLibrary drop.
+        // libloading::Library calls dlclose automatically on Drop.
+        let cache = library::libcache();
+        let mut cache_write = cache.write();
+        cache_write.drop_lib(handle);
+        Ok(())
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn dlsym(
+        handle: usize,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        let symbol_name = std::ffi::CString::new(name.as_str())
+            .map_err(|_| vm.new_value_error("symbol name contains null byte"))?;
+
+        // Clear previous error
+        unsafe { libc::dlerror() };
+
+        let ptr = unsafe { libc::dlsym(handle as *mut libc::c_void, symbol_name.as_ptr()) };
+
+        // Check for error via dlerror first
+        let err = unsafe { libc::dlerror() };
+        if !err.is_null() {
+            let msg = unsafe { std::ffi::CStr::from_ptr(err).to_string_lossy().into_owned() };
+            return Err(vm.new_os_error(msg));
+        }
+
+        // Treat NULL symbol address as error
+        // This handles cases like GNU IFUNCs that resolve to NULL
+        if ptr.is_null() {
+            return Err(vm.new_os_error(format!("symbol '{}' not found", name.as_str())));
+        }
+
+        Ok(ptr as usize)
+    }
+
     #[pyfunction(name = "POINTER")]
     fn create_pointer_type(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         use crate::builtins::PyStr;
@@ -905,25 +956,24 @@ pub(crate) mod _ctypes {
 
     #[pyfunction]
     fn get_errno() -> i32 {
-        errno::errno().0
+        super::function::get_errno_value()
     }
 
     #[pyfunction]
-    fn set_errno(value: i32) {
-        errno::set_errno(errno::Errno(value));
+    fn set_errno(value: i32) -> i32 {
+        super::function::set_errno_value(value)
     }
 
     #[cfg(windows)]
     #[pyfunction]
     fn get_last_error() -> PyResult<u32> {
-        Ok(unsafe { windows_sys::Win32::Foundation::GetLastError() })
+        Ok(super::function::get_last_error_value())
     }
 
     #[cfg(windows)]
     #[pyfunction]
-    fn set_last_error(value: u32) -> PyResult<()> {
-        unsafe { windows_sys::Win32::Foundation::SetLastError(value) };
-        Ok(())
+    fn set_last_error(value: u32) -> u32 {
+        super::function::set_last_error_value(value)
     }
 
     #[pyattr]
@@ -1084,9 +1134,9 @@ pub(crate) mod _ctypes {
             ffi_args.push(Arg::new(val));
         }
 
-        let cif = Cif::new(arg_types, Type::isize());
+        let cif = Cif::new(arg_types, Type::c_int());
         let code_ptr = CodePtr::from_ptr(func_addr as *const _);
-        let result: isize = unsafe { cif.call(code_ptr, &ffi_args) };
+        let result: libc::c_int = unsafe { cif.call(code_ptr, &ffi_args) };
         Ok(vm.ctx.new_int(result).into())
     }
 
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 60e6516bfe0..208b3e3f4d3 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -1,9 +1,12 @@
 use super::StgInfo;
 use super::base::{CDATA_BUFFER_METHODS, PyCData};
+use super::type_info;
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     atomic_func,
-    builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
+    builtins::{
+        PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef, genericalias::PyGenericAlias,
+    },
     class::StaticType,
     function::{ArgBytesLike, FuncArgs, PySetterValue},
     protocol::{BufferDescriptor, PyBuffer, PyNumberMethods, PySequenceMethods},
@@ -11,6 +14,19 @@ use crate::{
 };
 use num_traits::{Signed, ToPrimitive};
 
+/// Get itemsize from a PEP 3118 format string
+/// Extracts the type code (last char after endianness prefix) and returns its size
+fn get_size_from_format(fmt: &str) -> usize {
+    // Format is like "<f", ">q", etc. - strip endianness prefix and get type code
+    let code = fmt
+        .trim_start_matches(['<', '>', '@', '=', '!', '&'])
+        .chars()
+        .next()
+        .map(|c| c.to_string());
+    code.map(|c| type_info(&c).map(|t| t.size).unwrap_or(1))
+        .unwrap_or(1)
+}
+
 /// Creates array type for (element_type, length)
 /// Uses _array_type_cache to ensure identical calls return the same type object
 pub(super) fn array_type_from_ctype(
@@ -444,6 +460,11 @@ impl AsSequence for PyCArray {
     with(Constructor, AsSequence, AsBuffer)
 )]
 impl PyCArray {
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+
     fn int_to_bytes(i: &malachite_bigint::BigInt, size: usize) -> Vec<u8> {
         // Try unsigned first (handles values like 0xFFFFFFFF that overflow signed)
         // then fall back to signed (handles negative values)
@@ -1056,19 +1077,30 @@ impl AsBuffer for PyCArray {
             .expect("PyCArray type must have StgInfo");
         let format = stg_info.format.clone();
         let shape = stg_info.shape.clone();
-        let element_size = stg_info.element_size;
 
         let desc = if let Some(fmt) = format
             && !shape.is_empty()
         {
+            // itemsize is the size of the base element type (item_info->size)
+            // For empty arrays, we still need the element size, not 0
+            let total_elements: usize = shape.iter().product();
+            let has_zero_dim = shape.contains(&0);
+            let itemsize = if total_elements > 0 && buffer_len > 0 {
+                buffer_len / total_elements
+            } else {
+                // For empty arrays, get itemsize from format type code
+                get_size_from_format(&fmt)
+            };
+
             // Build dim_desc from shape (C-contiguous: row-major order)
             // stride[i] = product(shape[i+1:]) * itemsize
+            // For empty arrays (any dimension is 0), all strides are 0
             let mut dim_desc = Vec::with_capacity(shape.len());
-            let mut stride = element_size as isize;
+            let mut stride = itemsize as isize;
 
-            // Calculate strides from innermost to outermost dimension
             for &dim_size in shape.iter().rev() {
-                dim_desc.push((dim_size, stride, 0));
+                let current_stride = if has_zero_dim { 0 } else { stride };
+                dim_desc.push((dim_size, current_stride, 0));
                 stride *= dim_size as isize;
             }
             dim_desc.reverse();
@@ -1076,7 +1108,7 @@ impl AsBuffer for PyCArray {
             BufferDescriptor {
                 len: buffer_len,
                 readonly: false,
-                itemsize: element_size,
+                itemsize,
                 format: std::borrow::Cow::Owned(fmt),
                 dim_desc,
             }
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index 38c371346e0..44793a21561 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -300,15 +300,27 @@ pub(super) fn get_field_format(
     big_endian: bool,
     vm: &VirtualMachine,
 ) -> String {
+    let endian_prefix = if big_endian { ">" } else { "<" };
+
     // 1. Check StgInfo for format
     if let Some(type_obj) = field_type.downcast_ref::<PyType>()
         && let Some(stg_info) = type_obj.stg_info_opt()
         && let Some(fmt) = &stg_info.format
     {
-        // Handle endian prefix for simple types
-        if fmt.len() == 1 {
-            let endian_prefix = if big_endian { ">" } else { "<" };
-            return format!("{}{}", endian_prefix, fmt);
+        // For structures (T{...}), arrays ((n)...), and pointers (&...), return as-is
+        // These complex types have their own endianness markers inside
+        if fmt.starts_with('T')
+            || fmt.starts_with('(')
+            || fmt.starts_with('&')
+            || fmt.starts_with("X{")
+        {
+            return fmt.clone();
+        }
+
+        // For simple types, replace existing endian prefix with the correct one
+        let base_fmt = fmt.trim_start_matches(['<', '>', '@', '=', '!']);
+        if !base_fmt.is_empty() {
+            return format!("{}{}", endian_prefix, base_fmt);
         }
         return fmt.clone();
     }
@@ -318,8 +330,7 @@ pub(super) fn get_field_format(
         && let Some(type_str) = type_attr.downcast_ref::<PyStr>()
     {
         let s = type_str.as_str();
-        if s.len() == 1 {
-            let endian_prefix = if big_endian { ">" } else { "<" };
+        if !s.is_empty() {
             return format!("{}{}", endian_prefix, s);
         }
         return s.to_string();
@@ -1168,29 +1179,30 @@ impl PyCData {
                 .ok_or_else(|| vm.new_value_error("Invalid library handle"))?
         };
 
-        // Get symbol address using platform-specific API
-        let symbol_name = std::ffi::CString::new(name.as_str())
-            .map_err(|_| vm.new_value_error("Invalid symbol name"))?;
-
-        #[cfg(windows)]
-        let ptr: *const u8 = unsafe {
-            match windows_sys::Win32::System::LibraryLoader::GetProcAddress(
-                handle as windows_sys::Win32::Foundation::HMODULE,
-                symbol_name.as_ptr() as *const u8,
-            ) {
-                Some(p) => p as *const u8,
-                None => std::ptr::null(),
+        // Look up the library in the cache and use lib.get() for symbol lookup
+        let library_cache = super::library::libcache().read();
+        let library = library_cache
+            .get_lib(handle)
+            .ok_or_else(|| vm.new_value_error("Library not found"))?;
+        let inner_lib = library.lib.lock();
+
+        let symbol_name_with_nul = format!("{}\0", name.as_str());
+        let ptr: *const u8 = if let Some(lib) = &*inner_lib {
+            unsafe {
+                lib.get::<*const u8>(symbol_name_with_nul.as_bytes())
+                    .map(|sym| *sym)
+                    .map_err(|_| {
+                        vm.new_value_error(format!("symbol '{}' not found", name.as_str()))
+                    })?
             }
+        } else {
+            return Err(vm.new_value_error("Library closed"));
         };
 
-        #[cfg(not(windows))]
-        let ptr: *const u8 =
-            unsafe { libc::dlsym(handle as *mut libc::c_void, symbol_name.as_ptr()) as *const u8 };
-
+        // dlsym can return NULL for symbols that resolve to NULL (e.g., GNU IFUNC)
+        // Treat NULL addresses as errors
         if ptr.is_null() {
-            return Err(
-                vm.new_value_error(format!("symbol '{}' not found in library", name.as_str()))
-            );
+            return Err(vm.new_value_error(format!("symbol '{}' not found", name.as_str())));
         }
 
         // PyCData_AtAddress
@@ -1593,7 +1605,7 @@ impl PyCField {
     /// PyCField_set
     #[pyslot]
     fn descr_set(
-        zelf: &crate::PyObject,
+        zelf: &PyObject,
         obj: PyObjectRef,
         value: PySetterValue<PyObjectRef>,
         vm: &VirtualMachine,
@@ -1804,7 +1816,7 @@ pub enum FfiArgValue {
     F64(f64),
     Pointer(usize),
     /// Pointer with owned data. The PyObjectRef keeps the pointed data alive.
-    OwnedPointer(usize, #[allow(dead_code)] crate::PyObjectRef),
+    OwnedPointer(usize, #[allow(dead_code)] PyObjectRef),
 }
 
 impl FfiArgValue {
@@ -2145,6 +2157,16 @@ pub(super) fn read_ptr_from_buffer(buffer: &[u8]) -> usize {
     }
 }
 
+/// Check if a type is a "simple instance" (direct subclass of a simple type)
+/// Returns TRUE for c_int, c_void_p, etc. (simple types with _type_ attribute)
+/// Returns FALSE for Structure, Array, POINTER(T), etc.
+pub(super) fn is_simple_instance(typ: &Py<PyType>) -> bool {
+    // _ctypes_simple_instance
+    // Check if the type's metaclass is PyCSimpleType
+    let metaclass = typ.class();
+    metaclass.fast_issubclass(super::simple::PyCSimpleType::static_type())
+}
+
 /// Set or initialize StgInfo on a type
 pub(super) fn set_or_init_stginfo(type_ref: &PyType, stg_info: StgInfo) {
     if type_ref.init_type_data(stg_info.clone()).is_err()
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
index 9bddb0ef0e8..04ff238ebcf 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -1,16 +1,19 @@
 // spell-checker:disable
 
 use super::{
-    _ctypes::CArgObject, PyCArray, PyCData, PyCPointer, PyCStructure, base::FfiArgValue,
-    simple::PyCSimple, type_info,
+    _ctypes::CArgObject,
+    PyCArray, PyCData, PyCPointer, PyCStructure, StgInfo,
+    base::{CDATA_BUFFER_METHODS, FfiArgValue, ParamFunc, StgInfoFlags},
+    simple::PyCSimple,
+    type_info,
 };
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::{PyBytes, PyDict, PyNone, PyStr, PyTuple, PyType, PyTypeRef},
     class::StaticType,
-    convert::ToPyObject,
     function::FuncArgs,
-    types::{Callable, Constructor, Representable},
+    protocol::{BufferDescriptor, PyBuffer},
+    types::{AsBuffer, Callable, Constructor, Initializer, Representable},
     vm::thread::with_current_vm,
 };
 use libffi::{
@@ -18,9 +21,10 @@ use libffi::{
     middle::{Arg, Cif, Closure, CodePtr, Type},
 };
 use libloading::Symbol;
-use num_traits::ToPrimitive;
+use num_traits::{Signed, ToPrimitive};
 use rustpython_common::lock::PyRwLock;
-use std::ffi::{self, c_void};
+use std::borrow::Cow;
+use std::ffi::c_void;
 use std::fmt::Debug;
 
 // Internal function addresses for special ctypes functions
@@ -28,6 +32,90 @@ pub(super) const INTERNAL_CAST_ADDR: usize = 1;
 pub(super) const INTERNAL_STRING_AT_ADDR: usize = 2;
 pub(super) const INTERNAL_WSTRING_AT_ADDR: usize = 3;
 
+// Thread-local errno storage for ctypes
+std::thread_local! {
+    /// Thread-local storage for ctypes errno
+    /// This is separate from the system errno - ctypes swaps them during FFI calls
+    /// when use_errno=True is specified.
+    static CTYPES_LOCAL_ERRNO: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
+}
+
+/// Get ctypes thread-local errno value
+pub(super) fn get_errno_value() -> i32 {
+    CTYPES_LOCAL_ERRNO.with(|e| e.get())
+}
+
+/// Set ctypes thread-local errno value, returns old value
+pub(super) fn set_errno_value(value: i32) -> i32 {
+    CTYPES_LOCAL_ERRNO.with(|e| {
+        let old = e.get();
+        e.set(value);
+        old
+    })
+}
+
+/// Save and restore errno around FFI call (called when use_errno=True)
+/// Before: restore thread-local errno to system
+/// After: save system errno to thread-local
+#[cfg(not(windows))]
+fn swap_errno<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Before call: restore thread-local errno to system
+    let saved = CTYPES_LOCAL_ERRNO.with(|e| e.get());
+    errno::set_errno(errno::Errno(saved));
+
+    // Call the function
+    let result = f();
+
+    // After call: save system errno to thread-local
+    let new_error = errno::errno().0;
+    CTYPES_LOCAL_ERRNO.with(|e| e.set(new_error));
+
+    result
+}
+
+#[cfg(windows)]
+std::thread_local! {
+    /// Thread-local storage for ctypes last_error (Windows only)
+    static CTYPES_LOCAL_LAST_ERROR: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
+}
+
+#[cfg(windows)]
+pub(super) fn get_last_error_value() -> u32 {
+    CTYPES_LOCAL_LAST_ERROR.with(|e| e.get())
+}
+
+#[cfg(windows)]
+pub(super) fn set_last_error_value(value: u32) -> u32 {
+    CTYPES_LOCAL_LAST_ERROR.with(|e| {
+        let old = e.get();
+        e.set(value);
+        old
+    })
+}
+
+/// Save and restore last_error around FFI call (called when use_last_error=True)
+#[cfg(windows)]
+fn save_and_restore_last_error<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Before call: restore thread-local last_error to Windows
+    let saved = CTYPES_LOCAL_LAST_ERROR.with(|e| e.get());
+    unsafe { windows_sys::Win32::Foundation::SetLastError(saved) };
+
+    // Call the function
+    let result = f();
+
+    // After call: save Windows last_error to thread-local
+    let new_error = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+    CTYPES_LOCAL_LAST_ERROR.with(|e| e.set(new_error));
+
+    result
+}
+
 type FP = unsafe extern "C" fn();
 
 /// Get FFI type for a ctypes type code
@@ -131,11 +219,19 @@ fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgV
         return Ok(FfiArgValue::Pointer(addr));
     }
 
-    // 7. Integer -> direct value
+    // 7. Integer -> direct value (PyLong_AsVoidPtr behavior)
     if let Ok(int_val) = value.try_int(vm) {
-        return Ok(FfiArgValue::Pointer(
-            int_val.as_bigint().to_usize().unwrap_or(0),
-        ));
+        let bigint = int_val.as_bigint();
+        // Negative values: use signed conversion (allows -1 as 0xFFFF...)
+        if bigint.is_negative() {
+            if let Some(signed_val) = bigint.to_isize() {
+                return Ok(FfiArgValue::Pointer(signed_val as usize));
+            }
+        } else if let Some(unsigned_val) = bigint.to_usize() {
+            return Ok(FfiArgValue::Pointer(unsigned_val));
+        }
+        // Value out of range - raise OverflowError
+        return Err(vm.new_overflow_error("int too large to convert to pointer".to_string()));
     }
 
     // 8. Check _as_parameter_ attribute ( recursive ConvParam)
@@ -150,46 +246,86 @@ fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgV
 }
 
 /// ConvParam-like conversion for when argtypes is None
-/// Returns both the FFI type and the converted value
-fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<(Type, FfiArgValue)> {
+/// Returns an Argument with FFI type, value, and optional keep object
+fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<Argument> {
     // 1. CArgObject (from byref() or paramfunc) -> use stored type and value
     if let Some(carg) = value.downcast_ref::<CArgObject>() {
         let ffi_type = ffi_type_from_tag(carg.tag);
-        return Ok((ffi_type, carg.value.clone()));
+        return Ok(Argument {
+            ffi_type,
+            keep: None,
+            value: carg.value.clone(),
+        });
     }
 
     // 2. None -> NULL pointer
     if value.is(&vm.ctx.none) {
-        return Ok((Type::pointer(), FfiArgValue::Pointer(0)));
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: None,
+            value: FfiArgValue::Pointer(0),
+        });
     }
 
     // 3. ctypes objects -> use paramfunc
     if let Ok(carg) = super::base::call_paramfunc(value, vm) {
         let ffi_type = ffi_type_from_tag(carg.tag);
-        return Ok((ffi_type, carg.value.clone()));
+        return Ok(Argument {
+            ffi_type,
+            keep: None,
+            value: carg.value.clone(),
+        });
     }
 
-    // 4. Python str -> pointer (use internal UTF-8 buffer)
+    // 4. Python str -> wide string pointer (like PyUnicode_AsWideCharString)
     if let Some(s) = value.downcast_ref::<PyStr>() {
-        let addr = s.as_str().as_ptr() as usize;
-        return Ok((Type::pointer(), FfiArgValue::Pointer(addr)));
+        // Convert to null-terminated UTF-16 (wide string)
+        let wide: Vec<u16> = s
+            .as_str()
+            .encode_utf16()
+            .chain(std::iter::once(0))
+            .collect();
+        let wide_bytes: Vec<u8> = wide.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+        let keep = vm.ctx.new_bytes(wide_bytes);
+        let addr = keep.as_bytes().as_ptr() as usize;
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: Some(keep.into()),
+            value: FfiArgValue::Pointer(addr),
+        });
     }
 
-    // 9. Python bytes -> pointer to buffer
+    // 9. Python bytes -> null-terminated buffer pointer
+    // Need to ensure null termination like c_char_p
     if let Some(bytes) = value.downcast_ref::<PyBytes>() {
-        let addr = bytes.as_bytes().as_ptr() as usize;
-        return Ok((Type::pointer(), FfiArgValue::Pointer(addr)));
+        let mut buffer = bytes.as_bytes().to_vec();
+        buffer.push(0); // Add null terminator
+        let keep = vm.ctx.new_bytes(buffer);
+        let addr = keep.as_bytes().as_ptr() as usize;
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: Some(keep.into()),
+            value: FfiArgValue::Pointer(addr),
+        });
     }
 
     // 10. Python int -> i32 (default integer type)
     if let Ok(int_val) = value.try_int(vm) {
         let val = int_val.as_bigint().to_i32().unwrap_or(0);
-        return Ok((Type::i32(), FfiArgValue::I32(val)));
+        return Ok(Argument {
+            ffi_type: Type::i32(),
+            keep: None,
+            value: FfiArgValue::I32(val),
+        });
     }
 
     // 11. Python float -> f64
     if let Ok(float_val) = value.try_float(vm) {
-        return Ok((Type::f64(), FfiArgValue::F64(float_val.to_f64())));
+        return Ok(Argument {
+            ffi_type: Type::f64(),
+            keep: None,
+            value: FfiArgValue::F64(float_val.to_f64()),
+        });
     }
 
     // 12. Check _as_parameter_ attribute
@@ -245,7 +381,7 @@ impl ArgumentType for PyTypeRef {
     }
 
     fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<FfiArgValue> {
-        // Call from_param first to convert the value (like CPython's callproc.c:1235)
+        // Call from_param first to convert the value
         // converter = PyTuple_GET_ITEM(argtypes, i);
         // v = PyObject_CallOneArg(converter, arg);
         let from_param = self
@@ -264,11 +400,10 @@ impl ArgumentType for PyTypeRef {
             return Ok(FfiArgValue::Pointer(0));
         }
 
-        // For pointer types (POINTER(T)), we need to pass the ADDRESS of the value's buffer
+        // For pointer types (POINTER(T)), we need to pass the pointer VALUE stored in buffer
         if self.fast_issubclass(PyCPointer::static_type()) {
-            if let Some(cdata) = converted.downcast_ref::<PyCData>() {
-                let addr = cdata.buffer.read().as_ptr() as usize;
-                return Ok(FfiArgValue::Pointer(addr));
+            if let Some(pointer) = converted.downcast_ref::<PyCPointer>() {
+                return Ok(FfiArgValue::Pointer(pointer.get_ptr_value()));
             }
             return convert_to_pointer(&converted, vm);
         }
@@ -305,12 +440,6 @@ impl ArgumentType for PyTypeRef {
 
 trait ReturnType {
     fn to_ffi_type(&self, vm: &VirtualMachine) -> Option<Type>;
-    #[allow(clippy::wrong_self_convention)]
-    fn from_ffi_type(
-        &self,
-        value: *mut ffi::c_void,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>>;
 }
 
 impl ReturnType for PyTypeRef {
@@ -343,130 +472,56 @@ impl ReturnType for PyTypeRef {
         // Fallback to class name
         get_ffi_type(self.name().to_string().as_str())
     }
-
-    fn from_ffi_type(
-        &self,
-        value: *mut ffi::c_void,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>> {
-        // Get the type code from _type_ attribute (use get_attr to traverse MRO)
-        let type_code = self
-            .as_object()
-            .get_attr(vm.ctx.intern_str("_type_"), vm)
-            .ok()
-            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
-
-        let result = match type_code.as_deref() {
-            Some("b") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const i8) } as i32)
-                .into(),
-            Some("B") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const u8) } as i32)
-                .into(),
-            Some("c") => vm
-                .ctx
-                .new_bytes(vec![unsafe { *(value as *const u8) }])
-                .into(),
-            Some("h") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const i16) } as i32)
-                .into(),
-            Some("H") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const u16) } as i32)
-                .into(),
-            Some("i") => vm.ctx.new_int(unsafe { *(value as *const i32) }).into(),
-            Some("I") => vm.ctx.new_int(unsafe { *(value as *const u32) }).into(),
-            Some("l") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const libc::c_long) })
-                .into(),
-            Some("L") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const libc::c_ulong) })
-                .into(),
-            Some("q") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const libc::c_longlong) })
-                .into(),
-            Some("Q") => vm
-                .ctx
-                .new_int(unsafe { *(value as *const libc::c_ulonglong) })
-                .into(),
-            Some("f") => vm
-                .ctx
-                .new_float(unsafe { *(value as *const f32) } as f64)
-                .into(),
-            Some("d") => vm.ctx.new_float(unsafe { *(value as *const f64) }).into(),
-            Some("P") | Some("z") | Some("Z") => {
-                vm.ctx.new_int(unsafe { *(value as *const usize) }).into()
-            }
-            Some("?") => vm
-                .ctx
-                .new_bool(unsafe { *(value as *const u8) } != 0)
-                .into(),
-            None => {
-                // No _type_ attribute - check for Structure/Array types
-                // GetResult: PyCData_FromBaseObj creates instance from memory
-                if let Some(stg_info) = self.stg_info_opt() {
-                    let size = stg_info.size;
-                    // Create instance of the ctypes type
-                    let instance = self.as_object().call((), vm)?;
-
-                    // Copy return value memory into instance buffer
-                    // Use a block to properly scope the borrow
-                    {
-                        let src = unsafe { std::slice::from_raw_parts(value as *const u8, size) };
-                        if let Some(cdata) = instance.downcast_ref::<PyCData>() {
-                            let mut buffer = cdata.buffer.write();
-                            if buffer.len() >= size {
-                                buffer.to_mut()[..size].copy_from_slice(src);
-                            }
-                        } else if let Some(structure) = instance.downcast_ref::<PyCStructure>() {
-                            let mut buffer = structure.0.buffer.write();
-                            if buffer.len() >= size {
-                                buffer.to_mut()[..size].copy_from_slice(src);
-                            }
-                        } else if let Some(array) = instance.downcast_ref::<PyCArray>() {
-                            let mut buffer = array.0.buffer.write();
-                            if buffer.len() >= size {
-                                buffer.to_mut()[..size].copy_from_slice(src);
-                            }
-                        }
-                    }
-                    return Ok(Some(instance));
-                }
-                // Not a ctypes type - call type with int result
-                return self
-                    .as_object()
-                    .call((unsafe { *(value as *const i32) },), vm)
-                    .map(Some);
-            }
-            _ => return Err(vm.new_type_error("Unsupported return type")),
-        };
-        Ok(Some(result))
-    }
 }
 
 impl ReturnType for PyNone {
     fn to_ffi_type(&self, _vm: &VirtualMachine) -> Option<Type> {
         get_ffi_type("void")
     }
+}
+
+// PyCFuncPtrType - Metaclass for function pointer types
+// PyCFuncPtrType_init
+
+#[pyclass(name = "PyCFuncPtrType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCFuncPtrType(PyType);
 
-    fn from_ffi_type(
-        &self,
-        _value: *mut ffi::c_void,
-        _vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>> {
-        Ok(None)
+impl Initializer for PyCFuncPtrType {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        new_type.check_not_initialized(vm)?;
+
+        let ptr_size = std::mem::size_of::<usize>();
+        let mut stg_info = StgInfo::new(ptr_size, ptr_size);
+        stg_info.format = Some("X{}".to_string());
+        stg_info.length = 1;
+        stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+        stg_info.paramfunc = ParamFunc::Pointer; // CFuncPtr is passed as a pointer
+
+        let _ = new_type.init_type_data(stg_info);
+        Ok(())
     }
 }
 
+#[pyclass(flags(IMMUTABLETYPE), with(Initializer))]
+impl PyCFuncPtrType {}
+
 /// PyCFuncPtr - Function pointer instance
 /// Saved in _base.buffer
-#[pyclass(module = "_ctypes", name = "CFuncPtr", base = PyCData)]
+#[pyclass(
+    module = "_ctypes",
+    name = "CFuncPtr",
+    base = PyCData,
+    metaclass = "PyCFuncPtrType"
+)]
 #[repr(C)]
 pub(super) struct PyCFuncPtr {
     pub _base: PyCData,
@@ -892,7 +947,13 @@ impl Constructor for PyCFuncPtr {
                         .map_err(|err| err.to_string())
                         .map_err(|err| vm.new_attribute_error(err))?
                 };
-                *pointer as usize
+                let addr = *pointer as usize;
+                // dlsym can return NULL for symbols that resolve to NULL (e.g., GNU IFUNC)
+                // Treat NULL addresses as errors
+                if addr == 0 {
+                    return Err(vm.new_attribute_error(format!("function '{}' not found", name)));
+                }
+                addr
             } else {
                 0
             };
@@ -921,12 +982,17 @@ impl Constructor for PyCFuncPtr {
             // Get argument types and result type from the class
             let class_argtypes = cls.get_attr(vm.ctx.intern_str("_argtypes_"));
             let class_restype = cls.get_attr(vm.ctx.intern_str("_restype_"));
+            let class_flags = cls
+                .get_attr(vm.ctx.intern_str("_flags_"))
+                .and_then(|f| f.try_to_value::<u32>(vm).ok())
+                .unwrap_or(0);
 
             // Create the thunk (C-callable wrapper for the Python function)
             let thunk = PyCThunk::new(
                 first_arg.clone(),
                 class_argtypes.clone(),
                 class_restype.clone(),
+                class_flags,
                 vm,
             )?;
             let code_ptr = thunk.code_ptr();
@@ -1060,13 +1126,16 @@ fn extract_call_info(zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> PyResult<Cal
             .unwrap_or_else(Type::i32)
     };
 
-    // Check if return type is a pointer type (P, z, Z) - need special handling on 64-bit
+    // Check if return type is a pointer type via TYPEFLAG_ISPOINTER
+    // This handles c_void_p, c_char_p, c_wchar_p, and POINTER(T) types
     let is_pointer_return = restype_obj
         .as_ref()
         .and_then(|t| t.clone().downcast::<PyType>().ok())
-        .and_then(|t| t.as_object().get_attr(vm.ctx.intern_str("_type_"), vm).ok())
-        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
-        .is_some_and(|tc| matches!(tc.as_str(), "P" | "z" | "Z"));
+        .and_then(|t| {
+            t.stg_info_opt()
+                .map(|info| info.flags.contains(StgInfoFlags::TYPEFLAG_ISPOINTER))
+        })
+        .unwrap_or(false);
 
     Ok(CallInfo {
         explicit_arg_types,
@@ -1178,13 +1247,18 @@ fn resolve_com_method(
     Ok((Some(CodePtr(fptr as *mut _)), true))
 }
 
-/// Prepared arguments for FFI call
-struct PreparedArgs {
-    ffi_arg_types: Vec<Type>,
-    ffi_values: Vec<FfiArgValue>,
-    out_buffers: Vec<(usize, PyObjectRef)>,
+/// Single argument for FFI call
+// struct argument
+struct Argument {
+    ffi_type: Type,
+    value: FfiArgValue,
+    #[allow(dead_code)]
+    keep: Option<PyObjectRef>, // Object to keep alive during call
 }
 
+/// Out buffers for paramflags OUT parameters
+type OutBuffers = Vec<(usize, PyObjectRef)>;
+
 /// Get buffer address from a ctypes object
 fn get_buffer_addr(obj: &PyObjectRef) -> Option<usize> {
     obj.downcast_ref::<PyCSimple>()
@@ -1213,18 +1287,16 @@ fn create_out_buffer(arg_type: &PyTypeRef, vm: &VirtualMachine) -> PyResult<PyOb
 }
 
 /// Build callargs when no argtypes specified (use ConvParam)
-fn build_callargs_no_argtypes(args: &FuncArgs, vm: &VirtualMachine) -> PyResult<PreparedArgs> {
-    let results: Vec<(Type, FfiArgValue)> = args
+fn build_callargs_no_argtypes(
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let arguments: Vec<Argument> = args
         .args
         .iter()
         .map(|arg| conv_param(arg, vm))
         .collect::<PyResult<Vec<_>>>()?;
-    let (ffi_arg_types, ffi_values) = results.into_iter().unzip();
-    Ok(PreparedArgs {
-        ffi_arg_types,
-        ffi_values,
-        out_buffers: Vec::new(),
-    })
+    Ok((arguments, Vec::new()))
 }
 
 /// Build callargs for regular function with argtypes (no paramflags)
@@ -1232,12 +1304,8 @@ fn build_callargs_simple(
     args: &FuncArgs,
     arg_types: &[PyTypeRef],
     vm: &VirtualMachine,
-) -> PyResult<PreparedArgs> {
-    let ffi_arg_types = arg_types
-        .iter()
-        .map(|t| ArgumentType::to_ffi_type(t, vm))
-        .collect::<PyResult<Vec<_>>>()?;
-    let ffi_values = args
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let arguments: Vec<Argument> = args
         .args
         .iter()
         .enumerate()
@@ -1245,14 +1313,16 @@ fn build_callargs_simple(
             let arg_type = arg_types
                 .get(n)
                 .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
-            arg_type.convert_object(arg.clone(), vm)
+            let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+            let value = arg_type.convert_object(arg.clone(), vm)?;
+            Ok(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            })
         })
-        .collect::<Result<Vec<_>, _>>()?;
-    Ok(PreparedArgs {
-        ffi_arg_types,
-        ffi_values,
-        out_buffers: Vec::new(),
-    })
+        .collect::<PyResult<Vec<_>>>()?;
+    Ok((arguments, Vec::new()))
 }
 
 /// Build callargs with paramflags (handles IN/OUT parameters)
@@ -1262,27 +1332,21 @@ fn build_callargs_with_paramflags(
     paramflags: &ParsedParamFlags,
     skip_first_arg: bool, // true for COM methods
     vm: &VirtualMachine,
-) -> PyResult<PreparedArgs> {
-    let mut ffi_arg_types = Vec::new();
-    let mut ffi_values = Vec::new();
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let mut arguments = Vec::new();
     let mut out_buffers = Vec::new();
 
     // For COM methods, first arg is self (pointer)
     let mut caller_arg_idx = if skip_first_arg {
-        ffi_arg_types.push(Type::pointer());
         if !args.args.is_empty() {
-            ffi_values.push(conv_param(&args.args[0], vm)?.1);
+            let arg = conv_param(&args.args[0], vm)?;
+            arguments.push(arg);
         }
         1usize
     } else {
         0usize
     };
 
-    // Add FFI types for all argtypes
-    for arg_type in arg_types {
-        ffi_arg_types.push(ArgumentType::to_ffi_type(arg_type, vm)?);
-    }
-
     // Process parameters based on paramflags
     for (param_idx, (direction, _name, default)) in paramflags.iter().enumerate() {
         let arg_type = arg_types
@@ -1292,13 +1356,19 @@ fn build_callargs_with_paramflags(
         let is_out = (*direction & 2) != 0; // OUT flag
         let is_in = (*direction & 1) != 0 || *direction == 0; // IN flag or default
 
+        let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+
         if is_out && !is_in {
             // Pure OUT parameter: create buffer, don't consume caller arg
             let buffer = create_out_buffer(arg_type, vm)?;
             let addr = get_buffer_addr(&buffer).ok_or_else(|| {
                 vm.new_type_error("Cannot create OUT buffer for this type".to_string())
             })?;
-            ffi_values.push(FfiArgValue::Pointer(addr));
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value: FfiArgValue::Pointer(addr),
+            });
             out_buffers.push((param_idx, buffer));
         } else {
             // IN or IN|OUT: get from caller args or default
@@ -1315,15 +1385,16 @@ fn build_callargs_with_paramflags(
                 // IN|OUT: track for return
                 out_buffers.push((param_idx, arg.clone()));
             }
-            ffi_values.push(arg_type.convert_object(arg, vm)?);
+            let value = arg_type.convert_object(arg, vm)?;
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            });
         }
     }
 
-    Ok(PreparedArgs {
-        ffi_arg_types,
-        ffi_values,
-        out_buffers,
-    })
+    Ok((arguments, out_buffers))
 }
 
 /// Build call arguments (main dispatcher)
@@ -1333,7 +1404,7 @@ fn build_callargs(
     paramflags: Option<&ParsedParamFlags>,
     is_com_method: bool,
     vm: &VirtualMachine,
-) -> PyResult<PreparedArgs> {
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
     let Some(ref arg_types) = call_info.explicit_arg_types else {
         // No argtypes: use ConvParam
         return build_callargs_no_argtypes(args, vm);
@@ -1344,28 +1415,23 @@ fn build_callargs(
         build_callargs_with_paramflags(args, arg_types, pflags, is_com_method, vm)
     } else if is_com_method {
         // COM method without paramflags
-        let mut ffi_types = vec![Type::pointer()];
-        ffi_types.extend(
-            arg_types
-                .iter()
-                .map(|t| ArgumentType::to_ffi_type(t, vm))
-                .collect::<PyResult<Vec<_>>>()?,
-        );
-        let mut ffi_vals = Vec::new();
+        let mut arguments = Vec::new();
         if !args.args.is_empty() {
-            ffi_vals.push(conv_param(&args.args[0], vm)?.1);
+            arguments.push(conv_param(&args.args[0], vm)?);
         }
         for (n, arg) in args.args.iter().skip(1).enumerate() {
             let arg_type = arg_types
                 .get(n)
                 .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
-            ffi_vals.push(arg_type.convert_object(arg.clone(), vm)?);
+            let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+            let value = arg_type.convert_object(arg.clone(), vm)?;
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            });
         }
-        Ok(PreparedArgs {
-            ffi_arg_types: ffi_types,
-            ffi_values: ffi_vals,
-            out_buffers: Vec::new(),
-        })
+        Ok((arguments, Vec::new()))
     } else {
         // Regular function
         build_callargs_simple(args, arg_types, vm)
@@ -1380,12 +1446,10 @@ enum RawResult {
 }
 
 /// Execute FFI call
-fn ctypes_callproc(code_ptr: CodePtr, prepared: &PreparedArgs, call_info: &CallInfo) -> RawResult {
-    let cif = Cif::new(
-        prepared.ffi_arg_types.clone(),
-        call_info.ffi_return_type.clone(),
-    );
-    let ffi_args: Vec<Arg> = prepared.ffi_values.iter().map(|v| v.as_arg()).collect();
+fn ctypes_callproc(code_ptr: CodePtr, arguments: &[Argument], call_info: &CallInfo) -> RawResult {
+    let ffi_arg_types: Vec<Type> = arguments.iter().map(|a| a.ffi_type.clone()).collect();
+    let cif = Cif::new(ffi_arg_types, call_info.ffi_return_type.clone());
+    let ffi_args: Vec<Arg> = arguments.iter().map(|a| a.value.as_arg()).collect();
 
     if call_info.restype_is_none {
         unsafe { cif.call::<()>(code_ptr, &ffi_args) };
@@ -1438,73 +1502,118 @@ fn check_hresult(hresult: i32, zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> Py
 }
 
 /// Convert raw FFI result to Python object
+// = GetResult
 fn convert_raw_result(
     raw_result: &mut RawResult,
     call_info: &CallInfo,
     vm: &VirtualMachine,
 ) -> Option<PyObjectRef> {
-    match raw_result {
-        RawResult::Void => None,
+    // Get result as bytes for type conversion
+    let (result_bytes, result_size) = match raw_result {
+        RawResult::Void => return None,
         RawResult::Pointer(ptr) => {
-            // Get type code from restype to determine conversion method
-            let type_code = call_info
-                .restype_obj
-                .as_ref()
-                .and_then(|t| t.clone().downcast::<PyType>().ok())
-                .and_then(|t| t.as_object().get_attr(vm.ctx.intern_str("_type_"), vm).ok())
-                .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
-
-            match type_code.as_deref() {
-                Some("z") => {
-                    // c_char_p: NULL -> None, otherwise read C string -> bytes
-                    if *ptr == 0 {
-                        Some(vm.ctx.none())
-                    } else {
-                        let cstr = unsafe { std::ffi::CStr::from_ptr(*ptr as _) };
-                        Some(vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into())
-                    }
-                }
-                Some("Z") => {
-                    // c_wchar_p: NULL -> None, otherwise read wide string -> str
-                    if *ptr == 0 {
-                        Some(vm.ctx.none())
-                    } else {
-                        let wstr_ptr = *ptr as *const libc::wchar_t;
-                        let mut len = 0;
-                        unsafe {
-                            while *wstr_ptr.add(len) != 0 {
-                                len += 1;
-                            }
-                        }
-                        let slice = unsafe { std::slice::from_raw_parts(wstr_ptr, len) };
-                        let s: String = slice
-                            .iter()
-                            .filter_map(|&c| char::from_u32(c as u32))
-                            .collect();
-                        Some(vm.ctx.new_str(s).into())
-                    }
-                }
-                _ => {
-                    // c_void_p ("P") and other pointer types: NULL -> None, otherwise int
-                    if *ptr == 0 {
-                        Some(vm.ctx.none())
-                    } else {
-                        Some(vm.ctx.new_int(*ptr).into())
-                    }
-                }
-            }
+            let bytes = ptr.to_ne_bytes();
+            (bytes.to_vec(), std::mem::size_of::<usize>())
         }
-        RawResult::Value(val) => call_info
-            .restype_obj
-            .as_ref()
-            .and_then(|f| f.clone().downcast::<PyType>().ok())
-            .map(|f| {
-                f.from_ffi_type(val as *mut _ as *mut c_void, vm)
-                    .ok()
-                    .flatten()
-            })
-            .unwrap_or_else(|| Some(vm.ctx.new_int(*val as usize).as_object().to_pyobject(vm))),
+        RawResult::Value(val) => {
+            let bytes = val.to_ne_bytes();
+            (bytes.to_vec(), std::mem::size_of::<i64>())
+        }
+    };
+
+    // 1. No restype → return as int
+    let restype = match &call_info.restype_obj {
+        None => {
+            // Default: return as int
+            let val = match raw_result {
+                RawResult::Pointer(p) => *p as isize,
+                RawResult::Value(v) => *v as isize,
+                RawResult::Void => return None,
+            };
+            return Some(vm.ctx.new_int(val).into());
+        }
+        Some(r) => r,
+    };
+
+    // 2. restype is None → return None
+    if restype.is(&vm.ctx.none()) {
+        return None;
+    }
+
+    // 3. Get restype as PyType
+    let restype_type = match restype.clone().downcast::<PyType>() {
+        Ok(t) => t,
+        Err(_) => {
+            // Not a type, call it with int result
+            let val = match raw_result {
+                RawResult::Pointer(p) => *p as isize,
+                RawResult::Value(v) => *v as isize,
+                RawResult::Void => return None,
+            };
+            return restype.call((val,), vm).ok();
+        }
+    };
+
+    // 4. Get StgInfo
+    let stg_info = restype_type.stg_info_opt();
+
+    // No StgInfo → call restype with int
+    if stg_info.is_none() {
+        let val = match raw_result {
+            RawResult::Pointer(p) => *p as isize,
+            RawResult::Value(v) => *v as isize,
+            RawResult::Void => return None,
+        };
+        return restype_type.as_object().call((val,), vm).ok();
+    }
+
+    let info = stg_info.unwrap();
+
+    // 5. Simple type with getfunc → use bytes_to_pyobject (info->getfunc)
+    // is_simple_instance returns TRUE for c_int, c_void_p, etc.
+    if super::base::is_simple_instance(&restype_type) {
+        return super::base::bytes_to_pyobject(&restype_type, &result_bytes, vm).ok();
+    }
+
+    // 6. Complex type → create ctypes instance (PyCData_FromBaseObj)
+    // This handles POINTER(T), Structure, Array, etc.
+
+    // Special handling for POINTER(T) types - set pointer value directly
+    if info.flags.contains(StgInfoFlags::TYPEFLAG_ISPOINTER)
+        && info.proto.is_some()
+        && let RawResult::Pointer(ptr) = raw_result
+        && let Ok(instance) = restype_type.as_object().call((), vm)
+    {
+        if let Some(pointer) = instance.downcast_ref::<PyCPointer>() {
+            pointer.set_ptr_value(*ptr);
+        }
+        return Some(instance);
     }
+
+    // Create instance and copy result data
+    pycdata_from_ffi_result(&restype_type, &result_bytes, result_size, vm).ok()
+}
+
+/// Create a ctypes instance from FFI result (PyCData_FromBaseObj equivalent)
+fn pycdata_from_ffi_result(
+    typ: &PyTypeRef,
+    result_bytes: &[u8],
+    size: usize,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // Create instance
+    let instance = PyType::call(typ, ().into(), vm)?;
+
+    // Copy result data into instance buffer
+    if let Some(cdata) = instance.downcast_ref::<PyCData>() {
+        let mut buffer = cdata.buffer.write();
+        let copy_size = size.min(buffer.len()).min(result_bytes.len());
+        if copy_size > 0 {
+            buffer.to_mut()[..copy_size].copy_from_slice(&result_bytes[..copy_size]);
+        }
+    }
+
+    Ok(instance)
 }
 
 /// Extract values from OUT buffers
@@ -1522,7 +1631,7 @@ fn extract_out_values(
 fn build_result(
     mut raw_result: RawResult,
     call_info: &CallInfo,
-    prepared: PreparedArgs,
+    out_buffers: OutBuffers,
     zelf: &Py<PyCFuncPtr>,
     args: &FuncArgs,
     vm: &VirtualMachine,
@@ -1552,11 +1661,11 @@ fn build_result(
     }
 
     // Handle OUT parameter return values
-    if prepared.out_buffers.is_empty() {
+    if out_buffers.is_empty() {
         return result.map(Ok).unwrap_or_else(|| Ok(vm.ctx.none()));
     }
 
-    let out_values = extract_out_values(prepared.out_buffers, vm);
+    let out_values = extract_out_values(out_buffers, vm);
     Ok(match <[PyObjectRef; 1]>::try_from(out_values) {
         Ok([single]) => single,
         Err(v) => PyTuple::new_ref(v, &vm.ctx).into(),
@@ -1584,23 +1693,43 @@ impl Callable for PyCFuncPtr {
         let paramflags = parse_paramflags(zelf, vm)?;
 
         // 5. Build call arguments
-        let prepared = build_callargs(&args, &call_info, paramflags.as_ref(), is_com_method, vm)?;
+        let (arguments, out_buffers) =
+            build_callargs(&args, &call_info, paramflags.as_ref(), is_com_method, vm)?;
 
         // 6. Get code pointer
         let code_ptr = match func_ptr.or_else(|| zelf.get_code_ptr()) {
             Some(cp) => cp,
             None => {
                 debug_assert!(false, "NULL function pointer");
-                // In release mode, this will crash like CPython
+                // In release mode, this will crash
                 CodePtr(std::ptr::null_mut())
             }
         };
 
-        // 7. Call the function
-        let raw_result = ctypes_callproc(code_ptr, &prepared, &call_info);
+        // 7. Get flags to check for use_last_error/use_errno
+        let flags = PyCFuncPtr::_flags_(zelf, vm);
 
-        // 8. Build result
-        build_result(raw_result, &call_info, prepared, zelf, &args, vm)
+        // 8. Call the function (with use_last_error/use_errno handling)
+        #[cfg(not(windows))]
+        let raw_result = {
+            if flags & super::base::StgInfoFlags::FUNCFLAG_USE_ERRNO.bits() != 0 {
+                swap_errno(|| ctypes_callproc(code_ptr, &arguments, &call_info))
+            } else {
+                ctypes_callproc(code_ptr, &arguments, &call_info)
+            }
+        };
+
+        #[cfg(windows)]
+        let raw_result = {
+            if flags & super::base::StgInfoFlags::FUNCFLAG_USE_LASTERROR.bits() != 0 {
+                save_and_restore_last_error(|| ctypes_callproc(code_ptr, &arguments, &call_info))
+            } else {
+                ctypes_callproc(code_ptr, &arguments, &call_info)
+            }
+        };
+
+        // 9. Build result
+        build_result(raw_result, &call_info, out_buffers, zelf, &args, vm)
     }
 }
 
@@ -1614,7 +1743,36 @@ impl Representable for PyCFuncPtr {
     }
 }
 
-#[pyclass(flags(BASETYPE), with(Callable, Constructor, Representable))]
+// PyCData_NewGetBuffer
+impl AsBuffer for PyCFuncPtr {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        // CFuncPtr types may not have StgInfo if PyCFuncPtrType metaclass is not used
+        // Use default values for function pointers: format="X{}", size=sizeof(pointer)
+        let (format, itemsize) = if let Some(stg_info) = zelf.class().stg_info_opt() {
+            (
+                stg_info
+                    .format
+                    .clone()
+                    .map(Cow::Owned)
+                    .unwrap_or(Cow::Borrowed("X{}")),
+                stg_info.size,
+            )
+        } else {
+            (Cow::Borrowed("X{}"), std::mem::size_of::<usize>())
+        };
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
+
+#[pyclass(flags(BASETYPE), with(Callable, Constructor, Representable, AsBuffer))]
 impl PyCFuncPtr {
     // restype getter/setter
     #[pygetset]
@@ -1685,7 +1843,6 @@ impl PyCFuncPtr {
         }
 
         // Fallback to StgInfo for native types
-        use super::base::StgInfoFlags;
         zelf.class()
             .stg_info_opt()
             .map(|stg| stg.flags.bits())
@@ -1708,7 +1865,9 @@ struct ThunkUserData {
     /// Argument types for conversion
     arg_types: Vec<PyTypeRef>,
     /// Result type for conversion (None means void)
-    res_type: Option<PyTypeRef>,
+    pub res_type: Option<PyTypeRef>,
+    /// Function flags (FUNCFLAG_USE_ERRNO, etc.)
+    pub flags: u32,
 }
 
 /// Check if ty is a subclass of a simple type (like MyInt(c_int)).
@@ -1758,11 +1917,23 @@ fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> Py
                         len += 1;
                     }
                     let slice = std::slice::from_raw_parts(wstr_ptr, len);
-                    let s: String = slice
-                        .iter()
-                        .filter_map(|&c| char::from_u32(c as u32))
-                        .collect();
-                    vm.ctx.new_str(s).into()
+                    // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
+                    // Unix: wchar_t = i32 (UTF-32) -> convert via char::from_u32
+                    #[cfg(windows)]
+                    {
+                        use rustpython_common::wtf8::Wtf8Buf;
+                        let wide: Vec<u16> = slice.to_vec();
+                        let wtf8 = Wtf8Buf::from_wide(&wide);
+                        vm.ctx.new_str(wtf8).into()
+                    }
+                    #[cfg(not(windows))]
+                    {
+                        let s: String = slice
+                            .iter()
+                            .filter_map(|&c| char::from_u32(c as u32))
+                            .collect();
+                        vm.ctx.new_str(s).into()
+                    }
                 }
             }
             Some("P") => vm.ctx.new_int(*(ptr as *const usize)).into(),
@@ -1865,6 +2036,16 @@ unsafe extern "C" fn thunk_callback(
     userdata: &ThunkUserData,
 ) {
     with_current_vm(|vm| {
+        // Swap errno before call if FUNCFLAG_USE_ERRNO is set
+        let use_errno = userdata.flags & StgInfoFlags::FUNCFLAG_USE_ERRNO.bits() != 0;
+        let saved_errno = if use_errno {
+            let current = rustpython_common::os::get_errno();
+            // TODO: swap with ctypes stored errno (thread-local)
+            Some(current)
+        } else {
+            None
+        };
+
         let py_args: Vec<PyObjectRef> = userdata
             .arg_types
             .iter()
@@ -1877,6 +2058,15 @@ unsafe extern "C" fn thunk_callback(
 
         let py_result = userdata.callable.call(py_args, vm);
 
+        // Swap errno back after call
+        if use_errno {
+            let _current = rustpython_common::os::get_errno();
+            // TODO: store current errno to ctypes storage
+            if let Some(saved) = saved_errno {
+                rustpython_common::os::set_errno(saved);
+            }
+        }
+
         // Call unraisable hook if exception occurred
         if let Err(exc) = &py_result {
             let repr = userdata
@@ -1935,6 +2125,7 @@ impl PyCThunk {
         callable: PyObjectRef,
         arg_types: Option<PyObjectRef>,
         res_type: Option<PyObjectRef>,
+        flags: u32,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
         let arg_type_vec: Vec<PyTypeRef> = match arg_types {
@@ -1979,6 +2170,7 @@ impl PyCThunk {
             callable: callable.clone(),
             arg_types: arg_type_vec,
             res_type: res_type_ref,
+            flags,
         });
         let userdata_ptr = Box::into_raw(userdata);
         let userdata_ref: &'static ThunkUserData = unsafe { &*userdata_ptr };
diff --git a/crates/vm/src/stdlib/ctypes/library.rs b/crates/vm/src/stdlib/ctypes/library.rs
index ec8ca91af0d..7512ce29d8a 100644
--- a/crates/vm/src/stdlib/ctypes/library.rs
+++ b/crates/vm/src/stdlib/ctypes/library.rs
@@ -2,12 +2,14 @@ use crate::VirtualMachine;
 use libloading::Library;
 use rustpython_common::lock::{PyMutex, PyRwLock};
 use std::collections::HashMap;
-use std::ffi::{OsStr, c_void};
+use std::ffi::OsStr;
 use std::fmt;
-use std::ptr::null;
 
-pub(super) struct SharedLibrary {
-    pub(super) lib: PyMutex<Option<Library>>,
+#[cfg(unix)]
+use libloading::os::unix::Library as UnixLibrary;
+
+pub struct SharedLibrary {
+    pub(crate) lib: PyMutex<Option<Library>>,
 }
 
 impl fmt::Debug for SharedLibrary {
@@ -17,18 +19,44 @@ impl fmt::Debug for SharedLibrary {
 }
 
 impl SharedLibrary {
-    fn new(name: impl AsRef<OsStr>) -> Result<SharedLibrary, libloading::Error> {
+    #[cfg(windows)]
+    pub fn new(name: impl AsRef<OsStr>) -> Result<SharedLibrary, libloading::Error> {
         Ok(SharedLibrary {
             lib: PyMutex::new(unsafe { Some(Library::new(name.as_ref())?) }),
         })
     }
 
-    fn get_pointer(&self) -> usize {
+    #[cfg(unix)]
+    pub fn new_with_mode(
+        name: impl AsRef<OsStr>,
+        mode: i32,
+    ) -> Result<SharedLibrary, libloading::Error> {
+        Ok(SharedLibrary {
+            lib: PyMutex::new(Some(unsafe {
+                UnixLibrary::open(Some(name.as_ref()), mode)?.into()
+            })),
+        })
+    }
+
+    /// Create a SharedLibrary from a raw dlopen handle (for pythonapi / dlopen(NULL))
+    #[cfg(unix)]
+    pub fn from_raw_handle(handle: *mut libc::c_void) -> SharedLibrary {
+        SharedLibrary {
+            lib: PyMutex::new(Some(unsafe { UnixLibrary::from_raw(handle).into() })),
+        }
+    }
+
+    /// Get the underlying OS handle (HMODULE on Windows, dlopen handle on Unix)
+    pub fn get_pointer(&self) -> usize {
         let lib_lock = self.lib.lock();
         if let Some(l) = &*lib_lock {
-            l as *const Library as usize
+            // libloading::Library internally stores the OS handle directly
+            // On Windows: HMODULE (*mut c_void)
+            // On Unix: *mut c_void from dlopen
+            // We use transmute_copy to read the handle without consuming the Library
+            unsafe { std::mem::transmute_copy::<Library, usize>(l) }
         } else {
-            null::<c_void>() as usize
+            0
         }
     }
 
@@ -36,16 +64,6 @@ impl SharedLibrary {
         let lib_lock = self.lib.lock();
         lib_lock.is_none()
     }
-
-    fn close(&self) {
-        *self.lib.lock() = None;
-    }
-}
-
-impl Drop for SharedLibrary {
-    fn drop(&mut self) {
-        self.close();
-    }
 }
 
 pub(super) struct ExternalLibs {
@@ -63,6 +81,7 @@ impl ExternalLibs {
         self.libraries.get(&key)
     }
 
+    #[cfg(windows)]
     pub fn get_or_insert_lib(
         &mut self,
         library_path: impl AsRef<OsStr>,
@@ -71,20 +90,53 @@ impl ExternalLibs {
         let new_lib = SharedLibrary::new(library_path)?;
         let key = new_lib.get_pointer();
 
-        match self.libraries.get(&key) {
-            Some(l) => {
-                if l.is_closed() {
-                    self.libraries.insert(key, new_lib);
-                }
-            }
-            _ => {
-                self.libraries.insert(key, new_lib);
-            }
-        };
+        // Check if library already exists and is not closed
+        let should_use_cached = self.libraries.get(&key).is_some_and(|l| !l.is_closed());
+
+        if should_use_cached {
+            // new_lib will be dropped, calling FreeLibrary (decrements refcount)
+            // But library stays loaded because cached version maintains refcount
+            drop(new_lib);
+            return Ok((key, self.libraries.get(&key).expect("just checked")));
+        }
 
+        self.libraries.insert(key, new_lib);
         Ok((key, self.libraries.get(&key).expect("just inserted")))
     }
 
+    #[cfg(unix)]
+    pub fn get_or_insert_lib_with_mode(
+        &mut self,
+        library_path: impl AsRef<OsStr>,
+        mode: i32,
+        _vm: &VirtualMachine,
+    ) -> Result<(usize, &SharedLibrary), libloading::Error> {
+        let new_lib = SharedLibrary::new_with_mode(library_path, mode)?;
+        let key = new_lib.get_pointer();
+
+        // Check if library already exists and is not closed
+        let should_use_cached = self.libraries.get(&key).is_some_and(|l| !l.is_closed());
+
+        if should_use_cached {
+            // new_lib will be dropped, calling dlclose (decrements refcount)
+            // But library stays loaded because cached version maintains refcount
+            drop(new_lib);
+            return Ok((key, self.libraries.get(&key).expect("just checked")));
+        }
+
+        self.libraries.insert(key, new_lib);
+        Ok((key, self.libraries.get(&key).expect("just inserted")))
+    }
+
+    /// Insert a raw dlopen handle into the cache (for pythonapi / dlopen(NULL))
+    #[cfg(unix)]
+    pub fn insert_raw_handle(&mut self, handle: *mut libc::c_void) -> usize {
+        let shared_lib = SharedLibrary::from_raw_handle(handle);
+        let key = handle as usize;
+        self.libraries.insert(key, shared_lib);
+        key
+    }
+
     pub fn drop_lib(&mut self, key: usize) {
         self.libraries.remove(&key);
     }
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index 3ee39af3a7a..ae97b741b3c 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -1,6 +1,7 @@
+use super::base::CDATA_BUFFER_METHODS;
 use super::{PyCArray, PyCData, PyCSimple, PyCStructure, StgInfo, StgInfoFlags};
-use crate::protocol::PyNumberMethods;
-use crate::types::{AsNumber, Constructor, Initializer};
+use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::types::{AsBuffer, AsNumber, Constructor, Initializer};
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
@@ -8,6 +9,7 @@ use crate::{
     function::{FuncArgs, OptionalArg},
 };
 use num_traits::ToPrimitive;
+use std::borrow::Cow;
 
 #[pyclass(name = "PyCPointerType", base = PyType, module = "_ctypes")]
 #[derive(Debug)]
@@ -42,11 +44,19 @@ impl Initializer for PyCPointerType {
         stg_info.length = 1;
         stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
 
-        // Set format string: "&<element_format>"
-        if let Some(ref proto) = stg_info.proto {
-            let item_info = proto.stg_info_opt().expect("proto has StgInfo");
+        // Set format string: "&<element_format>" or "&(shape)<element_format>" for arrays
+        if let Some(ref proto) = stg_info.proto
+            && let Some(item_info) = proto.stg_info_opt()
+        {
             let current_format = item_info.format.as_deref().unwrap_or("B");
-            stg_info.format = Some(format!("&{}", current_format));
+            // Include shape for array types in the pointer format
+            let shape_str = if !item_info.shape.is_empty() {
+                let dims: Vec<String> = item_info.shape.iter().map(|d| d.to_string()).collect();
+                format!("({})", dims.join(","))
+            } else {
+                String::new()
+            };
+            stg_info.format = Some(format!("&{}{}", shape_str, current_format));
         }
 
         let _ = new_type.init_type_data(stg_info);
@@ -69,6 +79,15 @@ impl PyCPointerType {
             return Ok(value);
         }
 
+        // 1.5 CArgObject (from byref()) - check if underlying obj is instance of _type_
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>()
+            && let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+            && let Ok(type_ref) = type_attr.downcast::<PyType>()
+            && carg.obj.is_instance(type_ref.as_object(), vm)?
+        {
+            return Ok(value);
+        }
+
         // 2. If already an instance of the requested type, return it
         if value.is_instance(cls.as_object(), vm)? {
             return Ok(value);
@@ -149,10 +168,17 @@ impl PyCPointerType {
         if let Some(mut stg_info) = zelf.get_type_data_mut::<StgInfo>() {
             stg_info.proto = Some(typ_type.clone());
 
-            // Update format string: "&<element_format>"
+            // Update format string: "&<element_format>" or "&(shape)<element_format>" for arrays
             let item_info = typ_type.stg_info_opt().expect("proto has StgInfo");
             let current_format = item_info.format.as_deref().unwrap_or("B");
-            stg_info.format = Some(format!("&{}", current_format));
+            // Include shape for array types in the pointer format
+            let shape_str = if !item_info.shape.is_empty() {
+                let dims: Vec<String> = item_info.shape.iter().map(|d| d.to_string()).collect();
+                format!("({})", dims.join(","))
+            } else {
+                String::new()
+            };
+            stg_info.format = Some(format!("&{}{}", shape_str, current_format));
         }
 
         // 4. Set _type_ attribute on the pointer type
@@ -233,7 +259,10 @@ impl Initializer for PyCPointer {
     }
 }
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, Initializer))]
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsBuffer)
+)]
 impl PyCPointer {
     /// Get the pointer value stored in buffer as usize
     pub fn get_ptr_value(&self) -> usize {
@@ -605,20 +634,47 @@ impl PyCPointer {
         unsafe {
             let ptr = addr as *const u8;
             match type_code {
+                // Single-byte types don't need read_unaligned
                 Some("c") => Ok(vm.ctx.new_bytes(vec![*ptr]).into()),
-                Some("b") => Ok(vm.ctx.new_int(*(ptr as *const i8) as i32).into()),
+                Some("b") => Ok(vm.ctx.new_int(*ptr as i8 as i32).into()),
                 Some("B") => Ok(vm.ctx.new_int(*ptr as i32).into()),
-                Some("h") => Ok(vm.ctx.new_int(*(ptr as *const i16) as i32).into()),
-                Some("H") => Ok(vm.ctx.new_int(*(ptr as *const u16) as i32).into()),
-                Some("i") | Some("l") => Ok(vm.ctx.new_int(*(ptr as *const i32)).into()),
-                Some("I") | Some("L") => Ok(vm.ctx.new_int(*(ptr as *const u32)).into()),
-                Some("q") => Ok(vm.ctx.new_int(*(ptr as *const i64)).into()),
-                Some("Q") => Ok(vm.ctx.new_int(*(ptr as *const u64)).into()),
-                Some("f") => Ok(vm.ctx.new_float(*(ptr as *const f32) as f64).into()),
-                Some("d") | Some("g") => Ok(vm.ctx.new_float(*(ptr as *const f64)).into()),
-                Some("P") | Some("z") | Some("Z") => {
-                    Ok(vm.ctx.new_int(*(ptr as *const usize)).into())
-                }
+                // Multi-byte types need read_unaligned for safety on strict-alignment architectures
+                Some("h") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const i16) as i32)
+                    .into()),
+                Some("H") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const u16) as i32)
+                    .into()),
+                Some("i") | Some("l") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const i32))
+                    .into()),
+                Some("I") | Some("L") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const u32))
+                    .into()),
+                Some("q") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const i64))
+                    .into()),
+                Some("Q") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const u64))
+                    .into()),
+                Some("f") => Ok(vm
+                    .ctx
+                    .new_float(std::ptr::read_unaligned(ptr as *const f32) as f64)
+                    .into()),
+                Some("d") | Some("g") => Ok(vm
+                    .ctx
+                    .new_float(std::ptr::read_unaligned(ptr as *const f64))
+                    .into()),
+                Some("P") | Some("z") | Some("Z") => Ok(vm
+                    .ctx
+                    .new_int(std::ptr::read_unaligned(ptr as *const usize))
+                    .into()),
                 _ => {
                     // Default: read as bytes
                     let bytes = std::slice::from_raw_parts(ptr, size).to_vec();
@@ -652,27 +708,37 @@ impl PyCPointer {
                             "bytes/string or integer address expected".to_owned(),
                         ));
                     };
-                    *(ptr as *mut usize) = ptr_val;
+                    std::ptr::write_unaligned(ptr as *mut usize, ptr_val);
                     return Ok(());
                 }
                 _ => {}
             }
 
             // Try to get value as integer
+            // Use write_unaligned for safety on strict-alignment architectures
             if let Ok(int_val) = value.try_int(vm) {
                 let i = int_val.as_bigint();
                 match size {
                     1 => {
-                        *ptr = i.to_u8().unwrap_or(0);
+                        *ptr = i.to_u8().expect("int too large");
                     }
                     2 => {
-                        *(ptr as *mut i16) = i.to_i16().unwrap_or(0);
+                        std::ptr::write_unaligned(
+                            ptr as *mut i16,
+                            i.to_i16().expect("int too large"),
+                        );
                     }
                     4 => {
-                        *(ptr as *mut i32) = i.to_i32().unwrap_or(0);
+                        std::ptr::write_unaligned(
+                            ptr as *mut i32,
+                            i.to_i32().expect("int too large"),
+                        );
                     }
                     8 => {
-                        *(ptr as *mut i64) = i.to_i64().unwrap_or(0);
+                        std::ptr::write_unaligned(
+                            ptr as *mut i64,
+                            i.to_i64().expect("int too large"),
+                        );
                     }
                     _ => {
                         let bytes = i.to_signed_bytes_le();
@@ -688,10 +754,10 @@ impl PyCPointer {
                 let f = float_val.to_f64();
                 match size {
                     4 => {
-                        *(ptr as *mut f32) = f as f32;
+                        std::ptr::write_unaligned(ptr as *mut f32, f as f32);
                     }
                     8 => {
-                        *(ptr as *mut f64) = f;
+                        std::ptr::write_unaligned(ptr as *mut f64, f);
                     }
                     _ => {}
                 }
@@ -712,3 +778,28 @@ impl PyCPointer {
         }
     }
 }
+
+impl AsBuffer for PyCPointer {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCPointer type must have StgInfo");
+        let format = stg_info
+            .format
+            .clone()
+            .map(Cow::Owned)
+            .unwrap_or(Cow::Borrowed("&B"));
+        let itemsize = stg_info.size;
+        // Pointer types are scalars with ndim=0, shape=()
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index 1c0ec250d72..803b38d6e05 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -14,12 +14,47 @@ use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
 use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, Representable};
 use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
 use num_traits::ToPrimitive;
+use std::borrow::Cow;
 use std::fmt::Debug;
 
 /// Valid type codes for ctypes simple types
 // spell-checker: disable-next-line
 pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPXOv?g";
 
+/// Convert ctypes type code to PEP 3118 format code.
+/// Some ctypes codes need to be mapped to standard-size codes based on platform.
+/// _ctypes_alloc_format_string_for_type
+fn ctypes_code_to_pep3118(code: char) -> char {
+    match code {
+        // c_int: map based on sizeof(int)
+        'i' if std::mem::size_of::<std::ffi::c_int>() == 2 => 'h',
+        'i' if std::mem::size_of::<std::ffi::c_int>() == 4 => 'i',
+        'i' if std::mem::size_of::<std::ffi::c_int>() == 8 => 'q',
+        'I' if std::mem::size_of::<std::ffi::c_int>() == 2 => 'H',
+        'I' if std::mem::size_of::<std::ffi::c_int>() == 4 => 'I',
+        'I' if std::mem::size_of::<std::ffi::c_int>() == 8 => 'Q',
+        // c_long: map based on sizeof(long)
+        'l' if std::mem::size_of::<std::ffi::c_long>() == 4 => 'l',
+        'l' if std::mem::size_of::<std::ffi::c_long>() == 8 => 'q',
+        'L' if std::mem::size_of::<std::ffi::c_long>() == 4 => 'L',
+        'L' if std::mem::size_of::<std::ffi::c_long>() == 8 => 'Q',
+        // c_bool: map based on sizeof(bool) - typically 1 byte on all platforms
+        '?' if std::mem::size_of::<bool>() == 1 => '?',
+        '?' if std::mem::size_of::<bool>() == 2 => 'H',
+        '?' if std::mem::size_of::<bool>() == 4 => 'L',
+        '?' if std::mem::size_of::<bool>() == 8 => 'Q',
+        // Default: use the same code
+        _ => code,
+    }
+}
+
+/// _ctypes_alloc_format_string_for_type
+fn alloc_format_string_for_type(code: char, big_endian: bool) -> String {
+    let prefix = if big_endian { ">" } else { "<" };
+    let pep_code = ctypes_code_to_pep3118(code);
+    format!("{}{}", prefix, pep_code)
+}
+
 /// Create a new simple type instance from a class
 fn new_simple_type(
     cls: Either<&PyObject, &Py<PyType>>,
@@ -165,6 +200,20 @@ fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResul
         }
         // O_set: py_object accepts any Python object
         "O" => Ok(value.to_owned()),
+        // X_set: BSTR - same as Z (c_wchar_p), accepts None, int, or str
+        "X" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
         _ => {
             // "P"
             if value.downcast_ref_if_exact::<PyInt>(vm).is_some()
@@ -313,7 +362,7 @@ impl PyCSimpleType {
                     .to_pyobject(vm));
                 }
                 // 2. Array/Pointer with c_wchar element type
-                if is_cwchar_array_or_pointer(&value, vm) {
+                if is_cwchar_array_or_pointer(&value, vm)? {
                     return Ok(value);
                 }
                 // 3. CArgObject (byref(c_wchar(...)))
@@ -521,13 +570,10 @@ impl Initializer for PyCSimpleType {
         let mut stg_info = StgInfo::new(size, align);
 
         // Set format for PEP 3118 buffer protocol
-        // Format is endian prefix + type code (e.g., "<i" for little-endian int)
-        let endian_prefix = if cfg!(target_endian = "little") {
-            "<"
-        } else {
-            ">"
-        };
-        stg_info.format = Some(format!("{}{}", endian_prefix, type_str));
+        stg_info.format = Some(alloc_format_string_for_type(
+            type_str.chars().next().unwrap_or('?'),
+            cfg!(target_endian = "big"),
+        ));
         stg_info.paramfunc = super::base::ParamFunc::Simple;
 
         // Set TYPEFLAG_ISPOINTER for pointer types: z (c_char_p), Z (c_wchar_p),
@@ -619,13 +665,14 @@ fn create_swapped_types(
     swapped_type.set_attr("_swappedbytes_", vm.ctx.none(), vm)?;
 
     // Update swapped type's StgInfo format to use opposite endian prefix
-    // Native uses '<' on little-endian, '>' on big-endian
-    // Swapped uses the opposite
     if let Ok(swapped_type_ref) = swapped_type.clone().downcast::<PyType>()
         && let Some(mut sw_stg) = swapped_type_ref.get_type_data_mut::<StgInfo>()
     {
-        let swapped_prefix = if is_little_endian { ">" } else { "<" };
-        sw_stg.format = Some(format!("{}{}", swapped_prefix, type_str));
+        // Swapped: little-endian system uses big-endian prefix and vice versa
+        sw_stg.format = Some(alloc_format_string_for_type(
+            type_str.chars().next().unwrap_or('?'),
+            is_little_endian,
+        ));
     }
 
     // Set attributes based on system byte order
@@ -734,63 +781,56 @@ fn value_to_bytes_endian(
         }
         "b" => {
             // c_byte - signed char (1 byte)
-            // PyLong_AsLongMask pattern: wrapping for overflow values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i8;
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i8;
                 return vec![v as u8];
             }
             vec![0]
         }
         "B" => {
             // c_ubyte - unsigned char (1 byte)
-            // PyLong_AsUnsignedLongMask: wrapping for negative values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().map(|n| n as u8).unwrap_or(0);
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u8;
                 return vec![v];
             }
             vec![0]
         }
         "h" => {
             // c_short (2 bytes)
-            // PyLong_AsLongMask pattern: wrapping for overflow values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i16;
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i16;
                 return to_bytes!(v);
             }
             vec![0; 2]
         }
         "H" => {
             // c_ushort (2 bytes)
-            // PyLong_AsUnsignedLongMask: wrapping for negative values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().map(|n| n as u16).unwrap_or(0);
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u16;
                 return to_bytes!(v);
             }
             vec![0; 2]
         }
         "i" => {
             // c_int (4 bytes)
-            // PyLong_AsLongMask pattern: wrapping for overflow values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i32;
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i32;
                 return to_bytes!(v);
             }
             vec![0; 4]
         }
         "I" => {
             // c_uint (4 bytes)
-            // PyLong_AsUnsignedLongMask: wrapping for negative values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().map(|n| n as u32).unwrap_or(0);
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u32;
                 return to_bytes!(v);
             }
             vec![0; 4]
         }
         "l" => {
             // c_long (platform dependent)
-            // PyLong_AsLongMask pattern: wrapping for overflow values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().unwrap_or(0) as libc::c_long;
+                let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_long;
                 return to_bytes!(v);
             }
             const SIZE: usize = std::mem::size_of::<libc::c_long>();
@@ -798,13 +838,8 @@ fn value_to_bytes_endian(
         }
         "L" => {
             // c_ulong (platform dependent)
-            // PyLong_AsUnsignedLongMask: wrapping for negative values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val
-                    .as_bigint()
-                    .to_i128()
-                    .map(|n| n as libc::c_ulong)
-                    .unwrap_or(0);
+                let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_ulong;
                 return to_bytes!(v);
             }
             const SIZE: usize = std::mem::size_of::<libc::c_ulong>();
@@ -812,18 +847,16 @@ fn value_to_bytes_endian(
         }
         "q" => {
             // c_longlong (8 bytes)
-            // PyLong_AsLongMask pattern: wrapping for overflow values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().unwrap_or(0) as i64;
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i64;
                 return to_bytes!(v);
             }
             vec![0; 8]
         }
         "Q" => {
             // c_ulonglong (8 bytes)
-            // PyLong_AsUnsignedLongLongMask: wrapping for negative values
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_i128().map(|n| n as u64).unwrap_or(0);
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u64;
                 return to_bytes!(v);
             }
             vec![0; 8]
@@ -899,7 +932,10 @@ fn value_to_bytes_endian(
         "P" => {
             // c_void_p - pointer type (platform pointer size)
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
                 return to_bytes!(v);
             }
             vec![0; std::mem::size_of::<usize>()]
@@ -908,7 +944,10 @@ fn value_to_bytes_endian(
             // c_char_p - pointer to char (stores pointer value from int)
             // PyBytes case is handled in slot_new/set_value with make_z_buffer()
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
                 return to_bytes!(v);
             }
             vec![0; std::mem::size_of::<usize>()]
@@ -917,7 +956,10 @@ fn value_to_bytes_endian(
             // c_wchar_p - pointer to wchar_t (stores pointer value from int)
             // PyStr case is handled in slot_new/set_value with make_wchar_buffer()
             if let Ok(int_val) = value.try_index(vm) {
-                let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
                 return to_bytes!(v);
             }
             vec![0; std::mem::size_of::<usize>()]
@@ -939,7 +981,7 @@ fn is_cchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
     if let Some(arr) = value.downcast_ref::<PyCArray>()
         && let Some(info) = arr.class().stg_info_opt()
         && let Some(ref elem_type) = info.element_type
-        && let Some(elem_code) = elem_type.class().type_code(vm)
+        && let Some(elem_code) = elem_type.type_code(vm)
     {
         return elem_code == "c";
     }
@@ -947,7 +989,7 @@ fn is_cchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
     if let Some(ptr) = value.downcast_ref::<PyCPointer>()
         && let Some(info) = ptr.class().stg_info_opt()
         && let Some(ref proto) = info.proto
-        && let Some(proto_code) = proto.class().type_code(vm)
+        && let Some(proto_code) = proto.type_code(vm)
     {
         return proto_code == "c";
     }
@@ -955,25 +997,25 @@ fn is_cchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
 }
 
 /// Check if value is a c_wchar array or pointer(c_wchar)
-fn is_cwchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
+fn is_cwchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     // Check Array with c_wchar element type
     if let Some(arr) = value.downcast_ref::<PyCArray>() {
-        let info = arr.class().stg_info_opt().expect("array has StgInfo");
+        let info = arr.class().stg_info(vm)?;
         let elem_type = info.element_type.as_ref().expect("array has element_type");
-        if let Some(elem_code) = elem_type.class().type_code(vm) {
-            return elem_code == "u";
+        if let Some(elem_code) = elem_type.type_code(vm) {
+            return Ok(elem_code == "u");
         }
     }
     // Check Pointer to c_wchar
     if let Some(ptr) = value.downcast_ref::<PyCPointer>() {
-        let info = ptr.class().stg_info_opt().expect("pointer has StgInfo");
+        let info = ptr.class().stg_info(vm)?;
         if let Some(ref proto) = info.proto
-            && let Some(proto_code) = proto.class().type_code(vm)
+            && let Some(proto_code) = proto.type_code(vm)
         {
-            return proto_code == "u";
+            return Ok(proto_code == "u");
         }
     }
-    false
+    Ok(false)
 }
 
 impl Constructor for PyCSimple {
@@ -1121,15 +1163,27 @@ impl PyCSimple {
                 return Ok(vm.ctx.none());
             }
             // Read null-terminated wide string at the address
+            // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide for surrogate pairs
+            // Unix: wchar_t = i32 (UTF-32) -> convert via char::from_u32
             unsafe {
                 let w_ptr = ptr as *const libc::wchar_t;
                 let len = libc::wcslen(w_ptr);
                 let wchars = std::slice::from_raw_parts(w_ptr, len);
-                let s: String = wchars
-                    .iter()
-                    .filter_map(|&c| char::from_u32(c as u32))
-                    .collect();
-                return Ok(vm.ctx.new_str(s).into());
+                #[cfg(windows)]
+                {
+                    use rustpython_common::wtf8::Wtf8Buf;
+                    let wide: Vec<u16> = wchars.to_vec();
+                    let wtf8 = Wtf8Buf::from_wide(&wide);
+                    return Ok(vm.ctx.new_str(wtf8).into());
+                }
+                #[cfg(not(windows))]
+                {
+                    let s: String = wchars
+                        .iter()
+                        .filter_map(|&c| char::from_u32(c as u32))
+                        .collect();
+                    return Ok(vm.ctx.new_str(s).into());
+                }
             }
         }
 
@@ -1349,12 +1403,25 @@ impl PyCSimple {
 
 impl AsBuffer for PyCSimple {
     fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-        let buffer_len = zelf.0.buffer.read().len();
-        let buf = PyBuffer::new(
-            zelf.to_owned().into(),
-            BufferDescriptor::simple(buffer_len, false), // readonly=false for ctypes
-            &CDATA_BUFFER_METHODS,
-        );
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCSimple type must have StgInfo");
+        let format = stg_info
+            .format
+            .clone()
+            .map(Cow::Owned)
+            .unwrap_or(Cow::Borrowed("B"));
+        let itemsize = stg_info.size;
+        // Simple types are scalars with ndim=0, shape=()
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
         Ok(buf)
     }
 }
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index 10b8812e42c..1ca428669d4 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -601,12 +601,6 @@ impl PyCStructure {
     fn _b0_(&self) -> Option<PyObjectRef> {
         self.0.base.read().clone()
     }
-
-    #[pygetset]
-    fn _fields_(&self, vm: &VirtualMachine) -> PyObjectRef {
-        // Return the _fields_ from the class, not instance
-        vm.ctx.none()
-    }
 }
 
 impl AsBuffer for PyCStructure {

From 987216bcb8df3b3ce73056d66bee7dff66f6831c Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 16 Dec 2025 20:38:32 +0900
Subject: [PATCH 035/418] enable ctypes

---
 Lib/ctypes/__init__.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
index 3599e13ed28..2ef5e9a4fe7 100644
--- a/Lib/ctypes/__init__.py
+++ b/Lib/ctypes/__init__.py
@@ -36,9 +36,6 @@
      FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO, \
      FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR
 
-# TODO: RUSTPYTHON remove this
-from _ctypes import _non_existing_function
-
 # WINOLEAPI -> HRESULT
 # WINOLEAPI_(type)
 #

From 03d6f4634f86a1b9d12e85159bdd14361921c7ed Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sat, 20 Dec 2025 14:31:01 +0900
Subject: [PATCH 036/418] Upgrade ctypes to Python v3.13.11

---
 Lib/ctypes/__init__.py                       |  94 ++-
 Lib/ctypes/_endian.py                        |   8 +-
 Lib/ctypes/test/__init__.py                  |  16 -
 Lib/ctypes/test/__main__.py                  |   4 -
 Lib/ctypes/test/test_anon.py                 |  73 --
 Lib/ctypes/test/test_array_in_pointer.py     |  64 --
 Lib/ctypes/test/test_arrays.py               | 238 ------
 Lib/ctypes/test/test_as_parameter.py         | 231 ------
 Lib/ctypes/test/test_bitfields.py            | 297 -------
 Lib/ctypes/test/test_buffers.py              |  73 --
 Lib/ctypes/test/test_bytes.py                |  66 --
 Lib/ctypes/test/test_byteswap.py             | 364 ---------
 Lib/ctypes/test/test_callbacks.py            | 333 --------
 Lib/ctypes/test/test_cast.py                 |  99 ---
 Lib/ctypes/test/test_cfuncs.py               | 218 -----
 Lib/ctypes/test/test_checkretval.py          |  36 -
 Lib/ctypes/test/test_delattr.py              |  21 -
 Lib/ctypes/test/test_errno.py                |  76 --
 Lib/ctypes/test/test_find.py                 | 127 ---
 Lib/ctypes/test/test_frombuffer.py           | 141 ----
 Lib/ctypes/test/test_funcptr.py              | 132 ---
 Lib/ctypes/test/test_functions.py            | 384 ---------
 Lib/ctypes/test/test_incomplete.py           |  42 -
 Lib/ctypes/test/test_init.py                 |  40 -
 Lib/ctypes/test/test_internals.py            | 100 ---
 Lib/ctypes/test/test_keeprefs.py             | 153 ----
 Lib/ctypes/test/test_libc.py                 |  33 -
 Lib/ctypes/test/test_loading.py              | 182 -----
 Lib/ctypes/test/test_macholib.py             | 110 ---
 Lib/ctypes/test/test_memfunctions.py         |  79 --
 Lib/ctypes/test/test_numbers.py              | 218 -----
 Lib/ctypes/test/test_objects.py              |  67 --
 Lib/ctypes/test/test_parameters.py           | 250 ------
 Lib/ctypes/test/test_pep3118.py              | 235 ------
 Lib/ctypes/test/test_pickling.py             |  81 --
 Lib/ctypes/test/test_pointers.py             | 223 -----
 Lib/ctypes/test/test_prototypes.py           | 222 -----
 Lib/ctypes/test/test_python_api.py           |  85 --
 Lib/ctypes/test/test_random_things.py        |  77 --
 Lib/ctypes/test/test_refcounts.py            | 116 ---
 Lib/ctypes/test/test_repr.py                 |  29 -
 Lib/ctypes/test/test_returnfuncptrs.py       |  66 --
 Lib/ctypes/test/test_simplesubclasses.py     |  55 --
 Lib/ctypes/test/test_sizes.py                |  33 -
 Lib/ctypes/test/test_slicing.py              | 167 ----
 Lib/ctypes/test/test_stringptr.py            |  77 --
 Lib/ctypes/test/test_strings.py              | 145 ----
 Lib/ctypes/test/test_struct_fields.py        |  97 ---
 Lib/ctypes/test/test_structures.py           | 812 -------------------
 Lib/ctypes/test/test_unaligned_structures.py |  43 -
 Lib/ctypes/test/test_unicode.py              |  64 --
 Lib/ctypes/test/test_values.py               | 103 ---
 Lib/ctypes/test/test_varsize_struct.py       |  50 --
 Lib/ctypes/test/test_win32.py                | 136 ----
 Lib/ctypes/test/test_wintypes.py             |  43 -
 Lib/ctypes/util.py                           |  18 +-
 56 files changed, 70 insertions(+), 7276 deletions(-)
 delete mode 100644 Lib/ctypes/test/__init__.py
 delete mode 100644 Lib/ctypes/test/__main__.py
 delete mode 100644 Lib/ctypes/test/test_anon.py
 delete mode 100644 Lib/ctypes/test/test_array_in_pointer.py
 delete mode 100644 Lib/ctypes/test/test_arrays.py
 delete mode 100644 Lib/ctypes/test/test_as_parameter.py
 delete mode 100644 Lib/ctypes/test/test_bitfields.py
 delete mode 100644 Lib/ctypes/test/test_buffers.py
 delete mode 100644 Lib/ctypes/test/test_bytes.py
 delete mode 100644 Lib/ctypes/test/test_byteswap.py
 delete mode 100644 Lib/ctypes/test/test_callbacks.py
 delete mode 100644 Lib/ctypes/test/test_cast.py
 delete mode 100644 Lib/ctypes/test/test_cfuncs.py
 delete mode 100644 Lib/ctypes/test/test_checkretval.py
 delete mode 100644 Lib/ctypes/test/test_delattr.py
 delete mode 100644 Lib/ctypes/test/test_errno.py
 delete mode 100644 Lib/ctypes/test/test_find.py
 delete mode 100644 Lib/ctypes/test/test_frombuffer.py
 delete mode 100644 Lib/ctypes/test/test_funcptr.py
 delete mode 100644 Lib/ctypes/test/test_functions.py
 delete mode 100644 Lib/ctypes/test/test_incomplete.py
 delete mode 100644 Lib/ctypes/test/test_init.py
 delete mode 100644 Lib/ctypes/test/test_internals.py
 delete mode 100644 Lib/ctypes/test/test_keeprefs.py
 delete mode 100644 Lib/ctypes/test/test_libc.py
 delete mode 100644 Lib/ctypes/test/test_loading.py
 delete mode 100644 Lib/ctypes/test/test_macholib.py
 delete mode 100644 Lib/ctypes/test/test_memfunctions.py
 delete mode 100644 Lib/ctypes/test/test_numbers.py
 delete mode 100644 Lib/ctypes/test/test_objects.py
 delete mode 100644 Lib/ctypes/test/test_parameters.py
 delete mode 100644 Lib/ctypes/test/test_pep3118.py
 delete mode 100644 Lib/ctypes/test/test_pickling.py
 delete mode 100644 Lib/ctypes/test/test_pointers.py
 delete mode 100644 Lib/ctypes/test/test_prototypes.py
 delete mode 100644 Lib/ctypes/test/test_python_api.py
 delete mode 100644 Lib/ctypes/test/test_random_things.py
 delete mode 100644 Lib/ctypes/test/test_refcounts.py
 delete mode 100644 Lib/ctypes/test/test_repr.py
 delete mode 100644 Lib/ctypes/test/test_returnfuncptrs.py
 delete mode 100644 Lib/ctypes/test/test_simplesubclasses.py
 delete mode 100644 Lib/ctypes/test/test_sizes.py
 delete mode 100644 Lib/ctypes/test/test_slicing.py
 delete mode 100644 Lib/ctypes/test/test_stringptr.py
 delete mode 100644 Lib/ctypes/test/test_strings.py
 delete mode 100644 Lib/ctypes/test/test_struct_fields.py
 delete mode 100644 Lib/ctypes/test/test_structures.py
 delete mode 100644 Lib/ctypes/test/test_unaligned_structures.py
 delete mode 100644 Lib/ctypes/test/test_unicode.py
 delete mode 100644 Lib/ctypes/test/test_values.py
 delete mode 100644 Lib/ctypes/test/test_varsize_struct.py
 delete mode 100644 Lib/ctypes/test/test_win32.py
 delete mode 100644 Lib/ctypes/test/test_wintypes.py

diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
index 2ef5e9a4fe7..80651dc64ce 100644
--- a/Lib/ctypes/__init__.py
+++ b/Lib/ctypes/__init__.py
@@ -1,6 +1,8 @@
 """create and manipulate C data types in Python"""
 
-import os as _os, sys as _sys
+import os as _os
+import sys as _sys
+import sysconfig as _sysconfig
 import types as _types
 
 __version__ = "1.1.0"
@@ -107,7 +109,7 @@ class CFunctionType(_CFuncPtr):
     return CFunctionType
 
 if _os.name == "nt":
-    from _ctypes import LoadLibrary as _dlopen
+    from _ctypes import LoadLibrary as _LoadLibrary
     from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
 
     _win_functype_cache = {}
@@ -302,8 +304,9 @@ def create_unicode_buffer(init, size=None):
     raise TypeError(init)
 
 
-# XXX Deprecated
 def SetPointerType(pointer, cls):
+    import warnings
+    warnings._deprecated("ctypes.SetPointerType", remove=(3, 15))
     if _pointer_type_cache.get(cls, None) is not None:
         raise RuntimeError("This type already exists in the cache")
     if id(pointer) not in _pointer_type_cache:
@@ -312,7 +315,6 @@ def SetPointerType(pointer, cls):
     _pointer_type_cache[cls] = pointer
     del _pointer_type_cache[id(pointer)]
 
-# XXX Deprecated
 def ARRAY(typ, len):
     return typ * len
 
@@ -344,52 +346,59 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None,
                  use_errno=False,
                  use_last_error=False,
                  winmode=None):
+        class _FuncPtr(_CFuncPtr):
+            _flags_ = self._func_flags_
+            _restype_ = self._func_restype_
+            if use_errno:
+                _flags_ |= _FUNCFLAG_USE_ERRNO
+            if use_last_error:
+                _flags_ |= _FUNCFLAG_USE_LASTERROR
+
+        self._FuncPtr = _FuncPtr
         if name:
             name = _os.fspath(name)
 
+        self._handle = self._load_library(name, mode, handle, winmode)
+
+    if _os.name == "nt":
+        def _load_library(self, name, mode, handle, winmode):
+            if winmode is None:
+                import nt as _nt
+                winmode = _nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
+                # WINAPI LoadLibrary searches for a DLL if the given name
+                # is not fully qualified with an explicit drive. For POSIX
+                # compatibility, and because the DLL search path no longer
+                # contains the working directory, begin by fully resolving
+                # any name that contains a path separator.
+                if name is not None and ('/' in name or '\\' in name):
+                    name = _nt._getfullpathname(name)
+                    winmode |= _nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+            self._name = name
+            if handle is not None:
+                return handle
+            return _LoadLibrary(self._name, winmode)
+
+    else:
+        def _load_library(self, name, mode, handle, winmode):
             # If the filename that has been provided is an iOS/tvOS/watchOS
             # .fwork file, dereference the location to the true origin of the
             # binary.
-            if name.endswith(".fwork"):
+            if name and name.endswith(".fwork"):
                 with open(name) as f:
                     name = _os.path.join(
                         _os.path.dirname(_sys.executable),
                         f.read().strip()
                     )
-
-        self._name = name
-        flags = self._func_flags_
-        if use_errno:
-            flags |= _FUNCFLAG_USE_ERRNO
-        if use_last_error:
-            flags |= _FUNCFLAG_USE_LASTERROR
-        if _sys.platform.startswith("aix"):
-            """When the name contains ".a(" and ends with ")",
-               e.g., "libFOO.a(libFOO.so)" - this is taken to be an
-               archive(member) syntax for dlopen(), and the mode is adjusted.
-               Otherwise, name is presented to dlopen() as a file argument.
-            """
-            if name and name.endswith(")") and ".a(" in name:
-                mode |= ( _os.RTLD_MEMBER | _os.RTLD_NOW )
-        if _os.name == "nt":
-            if winmode is not None:
-                mode = winmode
-            else:
-                import nt
-                mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
-                if '/' in name or '\\' in name:
-                    self._name = nt._getfullpathname(self._name)
-                    mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
-
-        class _FuncPtr(_CFuncPtr):
-            _flags_ = flags
-            _restype_ = self._func_restype_
-        self._FuncPtr = _FuncPtr
-
-        if handle is None:
-            self._handle = _dlopen(self._name, mode)
-        else:
-            self._handle = handle
+            if _sys.platform.startswith("aix"):
+                """When the name contains ".a(" and ends with ")",
+                   e.g., "libFOO.a(libFOO.so)" - this is taken to be an
+                   archive(member) syntax for dlopen(), and the mode is adjusted.
+                   Otherwise, name is presented to dlopen() as a file argument.
+                """
+                if name and name.endswith(")") and ".a(" in name:
+                    mode |= _os.RTLD_MEMBER | _os.RTLD_NOW
+            self._name = name
+            return _dlopen(name, mode)
 
     def __repr__(self):
         return "<%s '%s', handle %x at %#x>" % \
@@ -477,10 +486,9 @@ def LoadLibrary(self, name):
 
 if _os.name == "nt":
     pythonapi = PyDLL("python dll", None, _sys.dllhandle)
-elif _sys.platform == "android":
-    pythonapi = PyDLL("libpython%d.%d.so" % _sys.version_info[:2])
-elif _sys.platform == "cygwin":
-    pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
+elif _sys.platform in ["android", "cygwin"]:
+    # These are Unix-like platforms which use a dynamically-linked libpython.
+    pythonapi = PyDLL(_sysconfig.get_config_var("LDLIBRARY"))
 else:
     pythonapi = PyDLL(None)
 
diff --git a/Lib/ctypes/_endian.py b/Lib/ctypes/_endian.py
index 34dee64b1a6..6382dd22b8a 100644
--- a/Lib/ctypes/_endian.py
+++ b/Lib/ctypes/_endian.py
@@ -1,5 +1,5 @@
 import sys
-from ctypes import *
+from ctypes import Array, Structure, Union
 
 _array_type = type(Array)
 
@@ -15,8 +15,8 @@ def _other_endian(typ):
     # if typ is array
     if isinstance(typ, _array_type):
         return _other_endian(typ._type_) * typ._length_
-    # if typ is structure
-    if issubclass(typ, Structure):
+    # if typ is structure or union
+    if issubclass(typ, (Structure, Union)):
         return typ
     raise TypeError("This type does not support other endian: %s" % typ)
 
@@ -37,7 +37,7 @@ class _swapped_union_meta(_swapped_meta, type(Union)): pass
 ################################################################
 
 # Note: The Structure metaclass checks for the *presence* (not the
-# value!) of a _swapped_bytes_ attribute to determine the bit order in
+# value!) of a _swappedbytes_ attribute to determine the bit order in
 # structures containing bit fields.
 
 if sys.byteorder == "little":
diff --git a/Lib/ctypes/test/__init__.py b/Lib/ctypes/test/__init__.py
deleted file mode 100644
index 6e496fa5a52..00000000000
--- a/Lib/ctypes/test/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import os
-import unittest
-from test import support
-from test.support import import_helper
-
-
-# skip tests if _ctypes was not built
-ctypes = import_helper.import_module('ctypes')
-ctypes_symbols = dir(ctypes)
-
-def need_symbol(name):
-    return unittest.skipUnless(name in ctypes_symbols,
-                               '{!r} is required'.format(name))
-
-def load_tests(*args):
-    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/ctypes/test/__main__.py b/Lib/ctypes/test/__main__.py
deleted file mode 100644
index 362a9ec8cff..00000000000
--- a/Lib/ctypes/test/__main__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from ctypes.test import load_tests
-import unittest
-
-unittest.main()
diff --git a/Lib/ctypes/test/test_anon.py b/Lib/ctypes/test/test_anon.py
deleted file mode 100644
index d378392ebe2..00000000000
--- a/Lib/ctypes/test/test_anon.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import unittest
-import test.support
-from ctypes import *
-
-class AnonTest(unittest.TestCase):
-
-    def test_anon(self):
-        class ANON(Union):
-            _fields_ = [("a", c_int),
-                        ("b", c_int)]
-
-        class Y(Structure):
-            _fields_ = [("x", c_int),
-                        ("_", ANON),
-                        ("y", c_int)]
-            _anonymous_ = ["_"]
-
-        self.assertEqual(Y.a.offset, sizeof(c_int))
-        self.assertEqual(Y.b.offset, sizeof(c_int))
-
-        self.assertEqual(ANON.a.offset, 0)
-        self.assertEqual(ANON.b.offset, 0)
-
-    def test_anon_nonseq(self):
-        # TypeError: _anonymous_ must be a sequence
-        self.assertRaises(TypeError,
-                              lambda: type(Structure)("Name",
-                                                      (Structure,),
-                                                      {"_fields_": [], "_anonymous_": 42}))
-
-    def test_anon_nonmember(self):
-        # AttributeError: type object 'Name' has no attribute 'x'
-        self.assertRaises(AttributeError,
-                              lambda: type(Structure)("Name",
-                                                      (Structure,),
-                                                      {"_fields_": [],
-                                                       "_anonymous_": ["x"]}))
-
-    @test.support.cpython_only
-    def test_issue31490(self):
-        # There shouldn't be an assertion failure in case the class has an
-        # attribute whose name is specified in _anonymous_ but not in _fields_.
-
-        # AttributeError: 'x' is specified in _anonymous_ but not in _fields_
-        with self.assertRaises(AttributeError):
-            class Name(Structure):
-                _fields_ = []
-                _anonymous_ = ["x"]
-                x = 42
-
-    def test_nested(self):
-        class ANON_S(Structure):
-            _fields_ = [("a", c_int)]
-
-        class ANON_U(Union):
-            _fields_ = [("_", ANON_S),
-                        ("b", c_int)]
-            _anonymous_ = ["_"]
-
-        class Y(Structure):
-            _fields_ = [("x", c_int),
-                        ("_", ANON_U),
-                        ("y", c_int)]
-            _anonymous_ = ["_"]
-
-        self.assertEqual(Y.x.offset, 0)
-        self.assertEqual(Y.a.offset, sizeof(c_int))
-        self.assertEqual(Y.b.offset, sizeof(c_int))
-        self.assertEqual(Y._.offset, sizeof(c_int))
-        self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_array_in_pointer.py b/Lib/ctypes/test/test_array_in_pointer.py
deleted file mode 100644
index ca1edcf6210..00000000000
--- a/Lib/ctypes/test/test_array_in_pointer.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import unittest
-from ctypes import *
-from binascii import hexlify
-import re
-
-def dump(obj):
-    # helper function to dump memory contents in hex, with a hyphen
-    # between the bytes.
-    h = hexlify(memoryview(obj)).decode()
-    return re.sub(r"(..)", r"\1-", h)[:-1]
-
-
-class Value(Structure):
-    _fields_ = [("val", c_byte)]
-
-class Container(Structure):
-    _fields_ = [("pvalues", POINTER(Value))]
-
-class Test(unittest.TestCase):
-    def test(self):
-        # create an array of 4 values
-        val_array = (Value * 4)()
-
-        # create a container, which holds a pointer to the pvalues array.
-        c = Container()
-        c.pvalues = val_array
-
-        # memory contains 4 NUL bytes now, that's correct
-        self.assertEqual("00-00-00-00", dump(val_array))
-
-        # set the values of the array through the pointer:
-        for i in range(4):
-            c.pvalues[i].val = i + 1
-
-        values = [c.pvalues[i].val for i in range(4)]
-
-        # These are the expected results: here s the bug!
-        self.assertEqual(
-            (values, dump(val_array)),
-            ([1, 2, 3, 4], "01-02-03-04")
-        )
-
-    def test_2(self):
-
-        val_array = (Value * 4)()
-
-        # memory contains 4 NUL bytes now, that's correct
-        self.assertEqual("00-00-00-00", dump(val_array))
-
-        ptr = cast(val_array, POINTER(Value))
-        # set the values of the array through the pointer:
-        for i in range(4):
-            ptr[i].val = i + 1
-
-        values = [ptr[i].val for i in range(4)]
-
-        # These are the expected results: here s the bug!
-        self.assertEqual(
-            (values, dump(val_array)),
-            ([1, 2, 3, 4], "01-02-03-04")
-        )
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_arrays.py b/Lib/ctypes/test/test_arrays.py
deleted file mode 100644
index 14603b7049c..00000000000
--- a/Lib/ctypes/test/test_arrays.py
+++ /dev/null
@@ -1,238 +0,0 @@
-import unittest
-from test.support import bigmemtest, _2G
-import sys
-from ctypes import *
-
-from ctypes.test import need_symbol
-
-formats = "bBhHiIlLqQfd"
-
-formats = c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint, \
-          c_long, c_ulonglong, c_float, c_double, c_longdouble
-
-class ArrayTestCase(unittest.TestCase):
-    def test_simple(self):
-        # create classes holding simple numeric types, and check
-        # various properties.
-
-        init = list(range(15, 25))
-
-        for fmt in formats:
-            alen = len(init)
-            int_array = ARRAY(fmt, alen)
-
-            ia = int_array(*init)
-            # length of instance ok?
-            self.assertEqual(len(ia), alen)
-
-            # slot values ok?
-            values = [ia[i] for i in range(alen)]
-            self.assertEqual(values, init)
-
-            # out-of-bounds accesses should be caught
-            with self.assertRaises(IndexError): ia[alen]
-            with self.assertRaises(IndexError): ia[-alen-1]
-
-            # change the items
-            from operator import setitem
-            new_values = list(range(42, 42+alen))
-            [setitem(ia, n, new_values[n]) for n in range(alen)]
-            values = [ia[i] for i in range(alen)]
-            self.assertEqual(values, new_values)
-
-            # are the items initialized to 0?
-            ia = int_array()
-            values = [ia[i] for i in range(alen)]
-            self.assertEqual(values, [0] * alen)
-
-            # Too many initializers should be caught
-            self.assertRaises(IndexError, int_array, *range(alen*2))
-
-        CharArray = ARRAY(c_char, 3)
-
-        ca = CharArray(b"a", b"b", b"c")
-
-        # Should this work? It doesn't:
-        # CharArray("abc")
-        self.assertRaises(TypeError, CharArray, "abc")
-
-        self.assertEqual(ca[0], b"a")
-        self.assertEqual(ca[1], b"b")
-        self.assertEqual(ca[2], b"c")
-        self.assertEqual(ca[-3], b"a")
-        self.assertEqual(ca[-2], b"b")
-        self.assertEqual(ca[-1], b"c")
-
-        self.assertEqual(len(ca), 3)
-
-        # cannot delete items
-        from operator import delitem
-        self.assertRaises(TypeError, delitem, ca, 0)
-
-    def test_step_overflow(self):
-        a = (c_int * 5)()
-        a[3::sys.maxsize] = (1,)
-        self.assertListEqual(a[3::sys.maxsize], [1])
-        a = (c_char * 5)()
-        a[3::sys.maxsize] = b"A"
-        self.assertEqual(a[3::sys.maxsize], b"A")
-        a = (c_wchar * 5)()
-        a[3::sys.maxsize] = u"X"
-        self.assertEqual(a[3::sys.maxsize], u"X")
-
-    def test_numeric_arrays(self):
-
-        alen = 5
-
-        numarray = ARRAY(c_int, alen)
-
-        na = numarray()
-        values = [na[i] for i in range(alen)]
-        self.assertEqual(values, [0] * alen)
-
-        na = numarray(*[c_int()] * alen)
-        values = [na[i] for i in range(alen)]
-        self.assertEqual(values, [0]*alen)
-
-        na = numarray(1, 2, 3, 4, 5)
-        values = [i for i in na]
-        self.assertEqual(values, [1, 2, 3, 4, 5])
-
-        na = numarray(*map(c_int, (1, 2, 3, 4, 5)))
-        values = [i for i in na]
-        self.assertEqual(values, [1, 2, 3, 4, 5])
-
-    def test_classcache(self):
-        self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4))
-        self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3))
-
-    def test_from_address(self):
-        # Failed with 0.9.8, reported by JUrner
-        p = create_string_buffer(b"foo")
-        sz = (c_char * 3).from_address(addressof(p))
-        self.assertEqual(sz[:], b"foo")
-        self.assertEqual(sz[::], b"foo")
-        self.assertEqual(sz[::-1], b"oof")
-        self.assertEqual(sz[::3], b"f")
-        self.assertEqual(sz[1:4:2], b"o")
-        self.assertEqual(sz.value, b"foo")
-
-    @need_symbol('create_unicode_buffer')
-    def test_from_addressW(self):
-        p = create_unicode_buffer("foo")
-        sz = (c_wchar * 3).from_address(addressof(p))
-        self.assertEqual(sz[:], "foo")
-        self.assertEqual(sz[::], "foo")
-        self.assertEqual(sz[::-1], "oof")
-        self.assertEqual(sz[::3], "f")
-        self.assertEqual(sz[1:4:2], "o")
-        self.assertEqual(sz.value, "foo")
-
-    def test_cache(self):
-        # Array types are cached internally in the _ctypes extension,
-        # in a WeakValueDictionary.  Make sure the array type is
-        # removed from the cache when the itemtype goes away.  This
-        # test will not fail, but will show a leak in the testsuite.
-
-        # Create a new type:
-        class my_int(c_int):
-            pass
-        # Create a new array type based on it:
-        t1 = my_int * 1
-        t2 = my_int * 1
-        self.assertIs(t1, t2)
-
-    def test_subclass(self):
-        class T(Array):
-            _type_ = c_int
-            _length_ = 13
-        class U(T):
-            pass
-        class V(U):
-            pass
-        class W(V):
-            pass
-        class X(T):
-            _type_ = c_short
-        class Y(T):
-            _length_ = 187
-
-        for c in [T, U, V, W]:
-            self.assertEqual(c._type_, c_int)
-            self.assertEqual(c._length_, 13)
-            self.assertEqual(c()._type_, c_int)
-            self.assertEqual(c()._length_, 13)
-
-        self.assertEqual(X._type_, c_short)
-        self.assertEqual(X._length_, 13)
-        self.assertEqual(X()._type_, c_short)
-        self.assertEqual(X()._length_, 13)
-
-        self.assertEqual(Y._type_, c_int)
-        self.assertEqual(Y._length_, 187)
-        self.assertEqual(Y()._type_, c_int)
-        self.assertEqual(Y()._length_, 187)
-
-    def test_bad_subclass(self):
-        with self.assertRaises(AttributeError):
-            class T(Array):
-                pass
-        with self.assertRaises(AttributeError):
-            class T(Array):
-                _type_ = c_int
-        with self.assertRaises(AttributeError):
-            class T(Array):
-                _length_ = 13
-
-    def test_bad_length(self):
-        with self.assertRaises(ValueError):
-            class T(Array):
-                _type_ = c_int
-                _length_ = - sys.maxsize * 2
-        with self.assertRaises(ValueError):
-            class T(Array):
-                _type_ = c_int
-                _length_ = -1
-        with self.assertRaises(TypeError):
-            class T(Array):
-                _type_ = c_int
-                _length_ = 1.87
-        with self.assertRaises(OverflowError):
-            class T(Array):
-                _type_ = c_int
-                _length_ = sys.maxsize * 2
-
-    def test_zero_length(self):
-        # _length_ can be zero.
-        class T(Array):
-            _type_ = c_int
-            _length_ = 0
-
-    def test_empty_element_struct(self):
-        class EmptyStruct(Structure):
-            _fields_ = []
-
-        obj = (EmptyStruct * 2)()  # bpo37188: Floating point exception
-        self.assertEqual(sizeof(obj), 0)
-
-    def test_empty_element_array(self):
-        class EmptyArray(Array):
-            _type_ = c_int
-            _length_ = 0
-
-        obj = (EmptyArray * 2)()  # bpo37188: Floating point exception
-        self.assertEqual(sizeof(obj), 0)
-
-    def test_bpo36504_signed_int_overflow(self):
-        # The overflow check in PyCArrayType_new() could cause signed integer
-        # overflow.
-        with self.assertRaises(OverflowError):
-            c_char * sys.maxsize * 2
-
-    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
-    @bigmemtest(size=_2G, memuse=1, dry_run=False)
-    def test_large_array(self, size):
-        c_char * size
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_as_parameter.py b/Lib/ctypes/test/test_as_parameter.py
deleted file mode 100644
index 9c39179d2a4..00000000000
--- a/Lib/ctypes/test/test_as_parameter.py
+++ /dev/null
@@ -1,231 +0,0 @@
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-import _ctypes_test
-
-dll = CDLL(_ctypes_test.__file__)
-
-try:
-    CALLBACK_FUNCTYPE = WINFUNCTYPE
-except NameError:
-    # fake to enable this test on Linux
-    CALLBACK_FUNCTYPE = CFUNCTYPE
-
-class POINT(Structure):
-    _fields_ = [("x", c_int), ("y", c_int)]
-
-class BasicWrapTestCase(unittest.TestCase):
-    def wrap(self, param):
-        return param
-
-    @need_symbol('c_wchar')
-    def test_wchar_parm(self):
-        f = dll._testfunc_i_bhilfd
-        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
-        result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
-        self.assertEqual(result, 139)
-        self.assertIs(type(result), int)
-
-    def test_pointers(self):
-        f = dll._testfunc_p_p
-        f.restype = POINTER(c_int)
-        f.argtypes = [POINTER(c_int)]
-
-        # This only works if the value c_int(42) passed to the
-        # function is still alive while the pointer (the result) is
-        # used.
-
-        v = c_int(42)
-
-        self.assertEqual(pointer(v).contents.value, 42)
-        result = f(self.wrap(pointer(v)))
-        self.assertEqual(type(result), POINTER(c_int))
-        self.assertEqual(result.contents.value, 42)
-
-        # This on works...
-        result = f(self.wrap(pointer(v)))
-        self.assertEqual(result.contents.value, v.value)
-
-        p = pointer(c_int(99))
-        result = f(self.wrap(p))
-        self.assertEqual(result.contents.value, 99)
-
-    def test_shorts(self):
-        f = dll._testfunc_callback_i_if
-
-        args = []
-        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
-                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
-
-        def callback(v):
-            args.append(v)
-            return v
-
-        CallBack = CFUNCTYPE(c_int, c_int)
-
-        cb = CallBack(callback)
-        f(self.wrap(2**18), self.wrap(cb))
-        self.assertEqual(args, expected)
-
-    ################################################################
-
-    def test_callbacks(self):
-        f = dll._testfunc_callback_i_if
-        f.restype = c_int
-        f.argtypes = None
-
-        MyCallback = CFUNCTYPE(c_int, c_int)
-
-        def callback(value):
-            #print "called back with", value
-            return value
-
-        cb = MyCallback(callback)
-
-        result = f(self.wrap(-10), self.wrap(cb))
-        self.assertEqual(result, -18)
-
-        # test with prototype
-        f.argtypes = [c_int, MyCallback]
-        cb = MyCallback(callback)
-
-        result = f(self.wrap(-10), self.wrap(cb))
-        self.assertEqual(result, -18)
-
-        result = f(self.wrap(-10), self.wrap(cb))
-        self.assertEqual(result, -18)
-
-        AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int)
-
-        # check that the prototype works: we call f with wrong
-        # argument types
-        cb = AnotherCallback(callback)
-        self.assertRaises(ArgumentError, f, self.wrap(-10), self.wrap(cb))
-
-    def test_callbacks_2(self):
-        # Can also use simple datatypes as argument type specifiers
-        # for the callback function.
-        # In this case the call receives an instance of that type
-        f = dll._testfunc_callback_i_if
-        f.restype = c_int
-
-        MyCallback = CFUNCTYPE(c_int, c_int)
-
-        f.argtypes = [c_int, MyCallback]
-
-        def callback(value):
-            #print "called back with", value
-            self.assertEqual(type(value), int)
-            return value
-
-        cb = MyCallback(callback)
-        result = f(self.wrap(-10), self.wrap(cb))
-        self.assertEqual(result, -18)
-
-    @need_symbol('c_longlong')
-    def test_longlong_callbacks(self):
-
-        f = dll._testfunc_callback_q_qf
-        f.restype = c_longlong
-
-        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
-
-        f.argtypes = [c_longlong, MyCallback]
-
-        def callback(value):
-            self.assertIsInstance(value, int)
-            return value & 0x7FFFFFFF
-
-        cb = MyCallback(callback)
-
-        self.assertEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb))))
-
-    def test_byval(self):
-        # without prototype
-        ptin = POINT(1, 2)
-        ptout = POINT()
-        # EXPORT int _testfunc_byval(point in, point *pout)
-        result = dll._testfunc_byval(ptin, byref(ptout))
-        got = result, ptout.x, ptout.y
-        expected = 3, 1, 2
-        self.assertEqual(got, expected)
-
-        # with prototype
-        ptin = POINT(101, 102)
-        ptout = POINT()
-        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
-        dll._testfunc_byval.restype = c_int
-        result = dll._testfunc_byval(self.wrap(ptin), byref(ptout))
-        got = result, ptout.x, ptout.y
-        expected = 203, 101, 102
-        self.assertEqual(got, expected)
-
-    def test_struct_return_2H(self):
-        class S2H(Structure):
-            _fields_ = [("x", c_short),
-                        ("y", c_short)]
-        dll.ret_2h_func.restype = S2H
-        dll.ret_2h_func.argtypes = [S2H]
-        inp = S2H(99, 88)
-        s2h = dll.ret_2h_func(self.wrap(inp))
-        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
-
-        # Test also that the original struct was unmodified (i.e. was passed by
-        # value)
-        self.assertEqual((inp.x, inp.y), (99, 88))
-
-    def test_struct_return_8H(self):
-        class S8I(Structure):
-            _fields_ = [("a", c_int),
-                        ("b", c_int),
-                        ("c", c_int),
-                        ("d", c_int),
-                        ("e", c_int),
-                        ("f", c_int),
-                        ("g", c_int),
-                        ("h", c_int)]
-        dll.ret_8i_func.restype = S8I
-        dll.ret_8i_func.argtypes = [S8I]
-        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
-        s8i = dll.ret_8i_func(self.wrap(inp))
-        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
-                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
-
-    def test_recursive_as_param(self):
-        from ctypes import c_int
-
-        class A(object):
-            pass
-
-        a = A()
-        a._as_parameter_ = a
-        with self.assertRaises(RecursionError):
-            c_int.from_param(a)
-
-
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class AsParamWrapper(object):
-    def __init__(self, param):
-        self._as_parameter_ = param
-
-class AsParamWrapperTestCase(BasicWrapTestCase):
-    wrap = AsParamWrapper
-
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class AsParamPropertyWrapper(object):
-    def __init__(self, param):
-        self._param = param
-
-    def getParameter(self):
-        return self._param
-    _as_parameter_ = property(getParameter)
-
-class AsParamPropertyWrapperTestCase(BasicWrapTestCase):
-    wrap = AsParamPropertyWrapper
-
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_bitfields.py b/Lib/ctypes/test/test_bitfields.py
deleted file mode 100644
index 66acd62e685..00000000000
--- a/Lib/ctypes/test/test_bitfields.py
+++ /dev/null
@@ -1,297 +0,0 @@
-from ctypes import *
-from ctypes.test import need_symbol
-from test import support
-import unittest
-import os
-
-import _ctypes_test
-
-class BITS(Structure):
-    _fields_ = [("A", c_int, 1),
-                ("B", c_int, 2),
-                ("C", c_int, 3),
-                ("D", c_int, 4),
-                ("E", c_int, 5),
-                ("F", c_int, 6),
-                ("G", c_int, 7),
-                ("H", c_int, 8),
-                ("I", c_int, 9),
-
-                ("M", c_short, 1),
-                ("N", c_short, 2),
-                ("O", c_short, 3),
-                ("P", c_short, 4),
-                ("Q", c_short, 5),
-                ("R", c_short, 6),
-                ("S", c_short, 7)]
-
-func = CDLL(_ctypes_test.__file__).unpack_bitfields
-func.argtypes = POINTER(BITS), c_char
-
-##for n in "ABCDEFGHIMNOPQRS":
-##    print n, hex(getattr(BITS, n).size), getattr(BITS, n).offset
-
-class C_Test(unittest.TestCase):
-
-    def test_ints(self):
-        for i in range(512):
-            for name in "ABCDEFGHI":
-                b = BITS()
-                setattr(b, name, i)
-                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
-
-    # bpo-46913: _ctypes/cfield.c h_get() has an undefined behavior
-    @support.skip_if_sanitizer(ub=True)
-    def test_shorts(self):
-        b = BITS()
-        name = "M"
-        if func(byref(b), name.encode('ascii')) == 999:
-            self.skipTest("Compiler does not support signed short bitfields")
-        for i in range(256):
-            for name in "MNOPQRS":
-                b = BITS()
-                setattr(b, name, i)
-                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
-
-signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
-unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
-int_types = unsigned_int_types + signed_int_types
-
-class BitFieldTest(unittest.TestCase):
-
-    def test_longlong(self):
-        class X(Structure):
-            _fields_ = [("a", c_longlong, 1),
-                        ("b", c_longlong, 62),
-                        ("c", c_longlong, 1)]
-
-        self.assertEqual(sizeof(X), sizeof(c_longlong))
-        x = X()
-        x.a, x.b, x.c = -1, 7, -1
-        self.assertEqual((x.a, x.b, x.c), (-1, 7, -1))
-
-    def test_ulonglong(self):
-        class X(Structure):
-            _fields_ = [("a", c_ulonglong, 1),
-                        ("b", c_ulonglong, 62),
-                        ("c", c_ulonglong, 1)]
-
-        self.assertEqual(sizeof(X), sizeof(c_longlong))
-        x = X()
-        self.assertEqual((x.a, x.b, x.c), (0, 0, 0))
-        x.a, x.b, x.c = 7, 7, 7
-        self.assertEqual((x.a, x.b, x.c), (1, 7, 1))
-
-    def test_signed(self):
-        for c_typ in signed_int_types:
-            class X(Structure):
-                _fields_ = [("dummy", c_typ),
-                            ("a", c_typ, 3),
-                            ("b", c_typ, 3),
-                            ("c", c_typ, 1)]
-            self.assertEqual(sizeof(X), sizeof(c_typ)*2)
-
-            x = X()
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
-            x.a = -1
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0))
-            x.a, x.b = 0, -1
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0))
-
-
-    def test_unsigned(self):
-        for c_typ in unsigned_int_types:
-            class X(Structure):
-                _fields_ = [("a", c_typ, 3),
-                            ("b", c_typ, 3),
-                            ("c", c_typ, 1)]
-            self.assertEqual(sizeof(X), sizeof(c_typ))
-
-            x = X()
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
-            x.a = -1
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0))
-            x.a, x.b = 0, -1
-            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
-
-
-    def fail_fields(self, *fields):
-        return self.get_except(type(Structure), "X", (),
-                               {"_fields_": fields})
-
-    def test_nonint_types(self):
-        # bit fields are not allowed on non-integer types.
-        result = self.fail_fields(("a", c_char_p, 1))
-        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p'))
-
-        result = self.fail_fields(("a", c_void_p, 1))
-        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p'))
-
-        if c_int != c_long:
-            result = self.fail_fields(("a", POINTER(c_int), 1))
-            self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int'))
-
-        result = self.fail_fields(("a", c_char, 1))
-        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
-
-        class Dummy(Structure):
-            _fields_ = []
-
-        result = self.fail_fields(("a", Dummy, 1))
-        self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
-
-    @need_symbol('c_wchar')
-    def test_c_wchar(self):
-        result = self.fail_fields(("a", c_wchar, 1))
-        self.assertEqual(result,
-                (TypeError, 'bit fields not allowed for type c_wchar'))
-
-    def test_single_bitfield_size(self):
-        for c_typ in int_types:
-            result = self.fail_fields(("a", c_typ, -1))
-            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
-
-            result = self.fail_fields(("a", c_typ, 0))
-            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
-
-            class X(Structure):
-                _fields_ = [("a", c_typ, 1)]
-            self.assertEqual(sizeof(X), sizeof(c_typ))
-
-            class X(Structure):
-                _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
-            self.assertEqual(sizeof(X), sizeof(c_typ))
-
-            result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1))
-            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
-
-    def test_multi_bitfields_size(self):
-        class X(Structure):
-            _fields_ = [("a", c_short, 1),
-                        ("b", c_short, 14),
-                        ("c", c_short, 1)]
-        self.assertEqual(sizeof(X), sizeof(c_short))
-
-        class X(Structure):
-            _fields_ = [("a", c_short, 1),
-                        ("a1", c_short),
-                        ("b", c_short, 14),
-                        ("c", c_short, 1)]
-        self.assertEqual(sizeof(X), sizeof(c_short)*3)
-        self.assertEqual(X.a.offset, 0)
-        self.assertEqual(X.a1.offset, sizeof(c_short))
-        self.assertEqual(X.b.offset, sizeof(c_short)*2)
-        self.assertEqual(X.c.offset, sizeof(c_short)*2)
-
-        class X(Structure):
-            _fields_ = [("a", c_short, 3),
-                        ("b", c_short, 14),
-                        ("c", c_short, 14)]
-        self.assertEqual(sizeof(X), sizeof(c_short)*3)
-        self.assertEqual(X.a.offset, sizeof(c_short)*0)
-        self.assertEqual(X.b.offset, sizeof(c_short)*1)
-        self.assertEqual(X.c.offset, sizeof(c_short)*2)
-
-
-    def get_except(self, func, *args, **kw):
-        try:
-            func(*args, **kw)
-        except Exception as detail:
-            return detail.__class__, str(detail)
-
-    def test_mixed_1(self):
-        class X(Structure):
-            _fields_ = [("a", c_byte, 4),
-                        ("b", c_int, 4)]
-        if os.name == "nt":
-            self.assertEqual(sizeof(X), sizeof(c_int)*2)
-        else:
-            self.assertEqual(sizeof(X), sizeof(c_int))
-
-    def test_mixed_2(self):
-        class X(Structure):
-            _fields_ = [("a", c_byte, 4),
-                        ("b", c_int, 32)]
-        self.assertEqual(sizeof(X), alignment(c_int)+sizeof(c_int))
-
-    def test_mixed_3(self):
-        class X(Structure):
-            _fields_ = [("a", c_byte, 4),
-                        ("b", c_ubyte, 4)]
-        self.assertEqual(sizeof(X), sizeof(c_byte))
-
-    def test_mixed_4(self):
-        class X(Structure):
-            _fields_ = [("a", c_short, 4),
-                        ("b", c_short, 4),
-                        ("c", c_int, 24),
-                        ("d", c_short, 4),
-                        ("e", c_short, 4),
-                        ("f", c_int, 24)]
-        # MSVC does NOT combine c_short and c_int into one field, GCC
-        # does (unless GCC is run with '-mms-bitfields' which
-        # produces code compatible with MSVC).
-        if os.name == "nt":
-            self.assertEqual(sizeof(X), sizeof(c_int) * 4)
-        else:
-            self.assertEqual(sizeof(X), sizeof(c_int) * 2)
-
-    def test_anon_bitfields(self):
-        # anonymous bit-fields gave a strange error message
-        class X(Structure):
-            _fields_ = [("a", c_byte, 4),
-                        ("b", c_ubyte, 4)]
-        class Y(Structure):
-            _anonymous_ = ["_"]
-            _fields_ = [("_", X)]
-
-    @need_symbol('c_uint32')
-    def test_uint32(self):
-        class X(Structure):
-            _fields_ = [("a", c_uint32, 32)]
-        x = X()
-        x.a = 10
-        self.assertEqual(x.a, 10)
-        x.a = 0xFDCBA987
-        self.assertEqual(x.a, 0xFDCBA987)
-
-    @need_symbol('c_uint64')
-    def test_uint64(self):
-        class X(Structure):
-            _fields_ = [("a", c_uint64, 64)]
-        x = X()
-        x.a = 10
-        self.assertEqual(x.a, 10)
-        x.a = 0xFEDCBA9876543211
-        self.assertEqual(x.a, 0xFEDCBA9876543211)
-
-    @need_symbol('c_uint32')
-    def test_uint32_swap_little_endian(self):
-        # Issue #23319
-        class Little(LittleEndianStructure):
-            _fields_ = [("a", c_uint32, 24),
-                        ("b", c_uint32, 4),
-                        ("c", c_uint32, 4)]
-        b = bytearray(4)
-        x = Little.from_buffer(b)
-        x.a = 0xabcdef
-        x.b = 1
-        x.c = 2
-        self.assertEqual(b, b'\xef\xcd\xab\x21')
-
-    @need_symbol('c_uint32')
-    def test_uint32_swap_big_endian(self):
-        # Issue #23319
-        class Big(BigEndianStructure):
-            _fields_ = [("a", c_uint32, 24),
-                        ("b", c_uint32, 4),
-                        ("c", c_uint32, 4)]
-        b = bytearray(4)
-        x = Big.from_buffer(b)
-        x.a = 0xabcdef
-        x.b = 1
-        x.c = 2
-        self.assertEqual(b, b'\xab\xcd\xef\x12')
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_buffers.py b/Lib/ctypes/test/test_buffers.py
deleted file mode 100644
index 15782be757c..00000000000
--- a/Lib/ctypes/test/test_buffers.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from ctypes import *
-from ctypes.test import need_symbol
-import unittest
-
-class StringBufferTestCase(unittest.TestCase):
-
-    def test_buffer(self):
-        b = create_string_buffer(32)
-        self.assertEqual(len(b), 32)
-        self.assertEqual(sizeof(b), 32 * sizeof(c_char))
-        self.assertIs(type(b[0]), bytes)
-
-        b = create_string_buffer(b"abc")
-        self.assertEqual(len(b), 4) # trailing nul char
-        self.assertEqual(sizeof(b), 4 * sizeof(c_char))
-        self.assertIs(type(b[0]), bytes)
-        self.assertEqual(b[0], b"a")
-        self.assertEqual(b[:], b"abc\0")
-        self.assertEqual(b[::], b"abc\0")
-        self.assertEqual(b[::-1], b"\0cba")
-        self.assertEqual(b[::2], b"ac")
-        self.assertEqual(b[::5], b"a")
-
-        self.assertRaises(TypeError, create_string_buffer, "abc")
-
-    def test_buffer_interface(self):
-        self.assertEqual(len(bytearray(create_string_buffer(0))), 0)
-        self.assertEqual(len(bytearray(create_string_buffer(1))), 1)
-
-    @need_symbol('c_wchar')
-    def test_unicode_buffer(self):
-        b = create_unicode_buffer(32)
-        self.assertEqual(len(b), 32)
-        self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
-        self.assertIs(type(b[0]), str)
-
-        b = create_unicode_buffer("abc")
-        self.assertEqual(len(b), 4) # trailing nul char
-        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
-        self.assertIs(type(b[0]), str)
-        self.assertEqual(b[0], "a")
-        self.assertEqual(b[:], "abc\0")
-        self.assertEqual(b[::], "abc\0")
-        self.assertEqual(b[::-1], "\0cba")
-        self.assertEqual(b[::2], "ac")
-        self.assertEqual(b[::5], "a")
-
-        self.assertRaises(TypeError, create_unicode_buffer, b"abc")
-
-    @need_symbol('c_wchar')
-    def test_unicode_conversion(self):
-        b = create_unicode_buffer("abc")
-        self.assertEqual(len(b), 4) # trailing nul char
-        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
-        self.assertIs(type(b[0]), str)
-        self.assertEqual(b[0], "a")
-        self.assertEqual(b[:], "abc\0")
-        self.assertEqual(b[::], "abc\0")
-        self.assertEqual(b[::-1], "\0cba")
-        self.assertEqual(b[::2], "ac")
-        self.assertEqual(b[::5], "a")
-
-    @need_symbol('c_wchar')
-    def test_create_unicode_buffer_non_bmp(self):
-        expected = 5 if sizeof(c_wchar) == 2 else 3
-        for s in '\U00010000\U00100000', '\U00010000\U0010ffff':
-            b = create_unicode_buffer(s)
-            self.assertEqual(len(b), expected)
-            self.assertEqual(b[-1], '\0')
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_bytes.py b/Lib/ctypes/test/test_bytes.py
deleted file mode 100644
index 092ec5af052..00000000000
--- a/Lib/ctypes/test/test_bytes.py
+++ /dev/null
@@ -1,66 +0,0 @@
-"""Test where byte objects are accepted"""
-import unittest
-import sys
-from ctypes import *
-
-class BytesTest(unittest.TestCase):
-    def test_c_char(self):
-        x = c_char(b"x")
-        self.assertRaises(TypeError, c_char, "x")
-        x.value = b"y"
-        with self.assertRaises(TypeError):
-            x.value = "y"
-        c_char.from_param(b"x")
-        self.assertRaises(TypeError, c_char.from_param, "x")
-        self.assertIn('xbd', repr(c_char.from_param(b"\xbd")))
-        (c_char * 3)(b"a", b"b", b"c")
-        self.assertRaises(TypeError, c_char * 3, "a", "b", "c")
-
-    def test_c_wchar(self):
-        x = c_wchar("x")
-        self.assertRaises(TypeError, c_wchar, b"x")
-        x.value = "y"
-        with self.assertRaises(TypeError):
-            x.value = b"y"
-        c_wchar.from_param("x")
-        self.assertRaises(TypeError, c_wchar.from_param, b"x")
-        (c_wchar * 3)("a", "b", "c")
-        self.assertRaises(TypeError, c_wchar * 3, b"a", b"b", b"c")
-
-    def test_c_char_p(self):
-        c_char_p(b"foo bar")
-        self.assertRaises(TypeError, c_char_p, "foo bar")
-
-    def test_c_wchar_p(self):
-        c_wchar_p("foo bar")
-        self.assertRaises(TypeError, c_wchar_p, b"foo bar")
-
-    def test_struct(self):
-        class X(Structure):
-            _fields_ = [("a", c_char * 3)]
-
-        x = X(b"abc")
-        self.assertRaises(TypeError, X, "abc")
-        self.assertEqual(x.a, b"abc")
-        self.assertEqual(type(x.a), bytes)
-
-    def test_struct_W(self):
-        class X(Structure):
-            _fields_ = [("a", c_wchar * 3)]
-
-        x = X("abc")
-        self.assertRaises(TypeError, X, b"abc")
-        self.assertEqual(x.a, "abc")
-        self.assertEqual(type(x.a), str)
-
-    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-    def test_BSTR(self):
-        from _ctypes import _SimpleCData
-        class BSTR(_SimpleCData):
-            _type_ = "X"
-
-        BSTR("abc")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_byteswap.py b/Lib/ctypes/test/test_byteswap.py
deleted file mode 100644
index 7e98559dfbc..00000000000
--- a/Lib/ctypes/test/test_byteswap.py
+++ /dev/null
@@ -1,364 +0,0 @@
-import sys, unittest, struct, math, ctypes
-from binascii import hexlify
-
-from ctypes import *
-
-def bin(s):
-    return hexlify(memoryview(s)).decode().upper()
-
-# Each *simple* type that supports different byte orders has an
-# __ctype_be__ attribute that specifies the same type in BIG ENDIAN
-# byte order, and a __ctype_le__ attribute that is the same type in
-# LITTLE ENDIAN byte order.
-#
-# For Structures and Unions, these types are created on demand.
-
-class Test(unittest.TestCase):
-    @unittest.skip('test disabled')
-    def test_X(self):
-        print(sys.byteorder, file=sys.stderr)
-        for i in range(32):
-            bits = BITS()
-            setattr(bits, "i%s" % i, 1)
-            dump(bits)
-
-    def test_slots(self):
-        class BigPoint(BigEndianStructure):
-            __slots__ = ()
-            _fields_ = [("x", c_int), ("y", c_int)]
-
-        class LowPoint(LittleEndianStructure):
-            __slots__ = ()
-            _fields_ = [("x", c_int), ("y", c_int)]
-
-        big = BigPoint()
-        little = LowPoint()
-        big.x = 4
-        big.y = 2
-        little.x = 2
-        little.y = 4
-        with self.assertRaises(AttributeError):
-            big.z = 42
-        with self.assertRaises(AttributeError):
-            little.z = 24
-
-    def test_endian_short(self):
-        if sys.byteorder == "little":
-            self.assertIs(c_short.__ctype_le__, c_short)
-            self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short)
-        else:
-            self.assertIs(c_short.__ctype_be__, c_short)
-            self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short)
-        s = c_short.__ctype_be__(0x1234)
-        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
-        self.assertEqual(bin(s), "1234")
-        self.assertEqual(s.value, 0x1234)
-
-        s = c_short.__ctype_le__(0x1234)
-        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
-        self.assertEqual(bin(s), "3412")
-        self.assertEqual(s.value, 0x1234)
-
-        s = c_ushort.__ctype_be__(0x1234)
-        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
-        self.assertEqual(bin(s), "1234")
-        self.assertEqual(s.value, 0x1234)
-
-        s = c_ushort.__ctype_le__(0x1234)
-        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
-        self.assertEqual(bin(s), "3412")
-        self.assertEqual(s.value, 0x1234)
-
-    def test_endian_int(self):
-        if sys.byteorder == "little":
-            self.assertIs(c_int.__ctype_le__, c_int)
-            self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int)
-        else:
-            self.assertIs(c_int.__ctype_be__, c_int)
-            self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int)
-
-        s = c_int.__ctype_be__(0x12345678)
-        self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
-        self.assertEqual(bin(s), "12345678")
-        self.assertEqual(s.value, 0x12345678)
-
-        s = c_int.__ctype_le__(0x12345678)
-        self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
-        self.assertEqual(bin(s), "78563412")
-        self.assertEqual(s.value, 0x12345678)
-
-        s = c_uint.__ctype_be__(0x12345678)
-        self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
-        self.assertEqual(bin(s), "12345678")
-        self.assertEqual(s.value, 0x12345678)
-
-        s = c_uint.__ctype_le__(0x12345678)
-        self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
-        self.assertEqual(bin(s), "78563412")
-        self.assertEqual(s.value, 0x12345678)
-
-    def test_endian_longlong(self):
-        if sys.byteorder == "little":
-            self.assertIs(c_longlong.__ctype_le__, c_longlong)
-            self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong)
-        else:
-            self.assertIs(c_longlong.__ctype_be__, c_longlong)
-            self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong)
-
-        s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
-        self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
-        self.assertEqual(bin(s), "1234567890ABCDEF")
-        self.assertEqual(s.value, 0x1234567890ABCDEF)
-
-        s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
-        self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
-        self.assertEqual(bin(s), "EFCDAB9078563412")
-        self.assertEqual(s.value, 0x1234567890ABCDEF)
-
-        s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
-        self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
-        self.assertEqual(bin(s), "1234567890ABCDEF")
-        self.assertEqual(s.value, 0x1234567890ABCDEF)
-
-        s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
-        self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
-        self.assertEqual(bin(s), "EFCDAB9078563412")
-        self.assertEqual(s.value, 0x1234567890ABCDEF)
-
-    def test_endian_float(self):
-        if sys.byteorder == "little":
-            self.assertIs(c_float.__ctype_le__, c_float)
-            self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float)
-        else:
-            self.assertIs(c_float.__ctype_be__, c_float)
-            self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float)
-        s = c_float(math.pi)
-        self.assertEqual(bin(struct.pack("f", math.pi)), bin(s))
-        # Hm, what's the precision of a float compared to a double?
-        self.assertAlmostEqual(s.value, math.pi, places=6)
-        s = c_float.__ctype_le__(math.pi)
-        self.assertAlmostEqual(s.value, math.pi, places=6)
-        self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
-        s = c_float.__ctype_be__(math.pi)
-        self.assertAlmostEqual(s.value, math.pi, places=6)
-        self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
-
-    def test_endian_double(self):
-        if sys.byteorder == "little":
-            self.assertIs(c_double.__ctype_le__, c_double)
-            self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double)
-        else:
-            self.assertIs(c_double.__ctype_be__, c_double)
-            self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double)
-        s = c_double(math.pi)
-        self.assertEqual(s.value, math.pi)
-        self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
-        s = c_double.__ctype_le__(math.pi)
-        self.assertEqual(s.value, math.pi)
-        self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
-        s = c_double.__ctype_be__(math.pi)
-        self.assertEqual(s.value, math.pi)
-        self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
-
-    def test_endian_other(self):
-        self.assertIs(c_byte.__ctype_le__, c_byte)
-        self.assertIs(c_byte.__ctype_be__, c_byte)
-
-        self.assertIs(c_ubyte.__ctype_le__, c_ubyte)
-        self.assertIs(c_ubyte.__ctype_be__, c_ubyte)
-
-        self.assertIs(c_char.__ctype_le__, c_char)
-        self.assertIs(c_char.__ctype_be__, c_char)
-
-    def test_struct_fields_unsupported_byte_order(self):
-
-        fields = [
-            ("a", c_ubyte),
-            ("b", c_byte),
-            ("c", c_short),
-            ("d", c_ushort),
-            ("e", c_int),
-            ("f", c_uint),
-            ("g", c_long),
-            ("h", c_ulong),
-            ("i", c_longlong),
-            ("k", c_ulonglong),
-            ("l", c_float),
-            ("m", c_double),
-            ("n", c_char),
-            ("b1", c_byte, 3),
-            ("b2", c_byte, 3),
-            ("b3", c_byte, 2),
-            ("a", c_int * 3 * 3 * 3)
-        ]
-
-        # these fields do not support different byte order:
-        for typ in c_wchar, c_void_p, POINTER(c_int):
-            with self.assertRaises(TypeError):
-                class T(BigEndianStructure if sys.byteorder == "little" else LittleEndianStructure):
-                    _fields_ = fields + [("x", typ)]
-
-
-    def test_struct_struct(self):
-        # nested structures with different byteorders
-
-        # create nested structures with given byteorders and set memory to data
-
-        for nested, data in (
-            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
-            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
-        ):
-            for parent in (
-                BigEndianStructure,
-                LittleEndianStructure,
-                Structure,
-            ):
-                class NestedStructure(nested):
-                    _fields_ = [("x", c_uint32),
-                                ("y", c_uint32)]
-
-                class TestStructure(parent):
-                    _fields_ = [("point", NestedStructure)]
-
-                self.assertEqual(len(data), sizeof(TestStructure))
-                ptr = POINTER(TestStructure)
-                s = cast(data, ptr)[0]
-                del ctypes._pointer_type_cache[TestStructure]
-                self.assertEqual(s.point.x, 1)
-                self.assertEqual(s.point.y, 2)
-
-    def test_struct_field_alignment(self):
-        # standard packing in struct uses no alignment.
-        # So, we have to align using pad bytes.
-        #
-        # Unaligned accesses will crash Python (on those platforms that
-        # don't allow it, like sparc solaris).
-        if sys.byteorder == "little":
-            base = BigEndianStructure
-            fmt = ">bxhid"
-        else:
-            base = LittleEndianStructure
-            fmt = "<bxhid"
-
-        class S(base):
-            _fields_ = [("b", c_byte),
-                        ("h", c_short),
-                        ("i", c_int),
-                        ("d", c_double)]
-
-        s1 = S(0x12, 0x1234, 0x12345678, 3.14)
-        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
-        self.assertEqual(bin(s1), bin(s2))
-
-    def test_unaligned_nonnative_struct_fields(self):
-        if sys.byteorder == "little":
-            base = BigEndianStructure
-            fmt = ">b h xi xd"
-        else:
-            base = LittleEndianStructure
-            fmt = "<b h xi xd"
-
-        class S(base):
-            _pack_ = 1
-            _fields_ = [("b", c_byte),
-                        ("h", c_short),
-
-                        ("_1", c_byte),
-                        ("i", c_int),
-
-                        ("_2", c_byte),
-                        ("d", c_double)]
-
-        s1 = S()
-        s1.b = 0x12
-        s1.h = 0x1234
-        s1.i = 0x12345678
-        s1.d = 3.14
-        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
-        self.assertEqual(bin(s1), bin(s2))
-
-    def test_unaligned_native_struct_fields(self):
-        if sys.byteorder == "little":
-            fmt = "<b h xi xd"
-        else:
-            base = LittleEndianStructure
-            fmt = ">b h xi xd"
-
-        class S(Structure):
-            _pack_ = 1
-            _fields_ = [("b", c_byte),
-
-                        ("h", c_short),
-
-                        ("_1", c_byte),
-                        ("i", c_int),
-
-                        ("_2", c_byte),
-                        ("d", c_double)]
-
-        s1 = S()
-        s1.b = 0x12
-        s1.h = 0x1234
-        s1.i = 0x12345678
-        s1.d = 3.14
-        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
-        self.assertEqual(bin(s1), bin(s2))
-
-    def test_union_fields_unsupported_byte_order(self):
-
-        fields = [
-            ("a", c_ubyte),
-            ("b", c_byte),
-            ("c", c_short),
-            ("d", c_ushort),
-            ("e", c_int),
-            ("f", c_uint),
-            ("g", c_long),
-            ("h", c_ulong),
-            ("i", c_longlong),
-            ("k", c_ulonglong),
-            ("l", c_float),
-            ("m", c_double),
-            ("n", c_char),
-            ("b1", c_byte, 3),
-            ("b2", c_byte, 3),
-            ("b3", c_byte, 2),
-            ("a", c_int * 3 * 3 * 3)
-        ]
-
-        # these fields do not support different byte order:
-        for typ in c_wchar, c_void_p, POINTER(c_int):
-            with self.assertRaises(TypeError):
-                class T(BigEndianUnion if sys.byteorder == "little" else LittleEndianUnion):
-                    _fields_ = fields + [("x", typ)]
-
-    def test_union_struct(self):
-        # nested structures in unions with different byteorders
-
-        # create nested structures in unions with given byteorders and set memory to data
-
-        for nested, data in (
-            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
-            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
-        ):
-            for parent in (
-                BigEndianUnion,
-                LittleEndianUnion,
-                Union,
-            ):
-                class NestedStructure(nested):
-                    _fields_ = [("x", c_uint32),
-                                ("y", c_uint32)]
-
-                class TestUnion(parent):
-                    _fields_ = [("point", NestedStructure)]
-
-                self.assertEqual(len(data), sizeof(TestUnion))
-                ptr = POINTER(TestUnion)
-                s = cast(data, ptr)[0]
-                del ctypes._pointer_type_cache[TestUnion]
-                self.assertEqual(s.point.x, 1)
-                self.assertEqual(s.point.y, 2)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_callbacks.py b/Lib/ctypes/test/test_callbacks.py
deleted file mode 100644
index 8f95a244439..00000000000
--- a/Lib/ctypes/test/test_callbacks.py
+++ /dev/null
@@ -1,333 +0,0 @@
-import functools
-import unittest
-from test import support
-
-from ctypes import *
-from ctypes.test import need_symbol
-from _ctypes import CTYPES_MAX_ARGCOUNT
-import _ctypes_test
-
-class Callbacks(unittest.TestCase):
-    functype = CFUNCTYPE
-
-##    def tearDown(self):
-##        import gc
-##        gc.collect()
-
-    def callback(self, *args):
-        self.got_args = args
-        return args[-1]
-
-    def check_type(self, typ, arg):
-        PROTO = self.functype.__func__(typ, typ)
-        result = PROTO(self.callback)(arg)
-        if typ == c_float:
-            self.assertAlmostEqual(result, arg, places=5)
-        else:
-            self.assertEqual(self.got_args, (arg,))
-            self.assertEqual(result, arg)
-
-        PROTO = self.functype.__func__(typ, c_byte, typ)
-        result = PROTO(self.callback)(-3, arg)
-        if typ == c_float:
-            self.assertAlmostEqual(result, arg, places=5)
-        else:
-            self.assertEqual(self.got_args, (-3, arg))
-            self.assertEqual(result, arg)
-
-    ################
-
-    def test_byte(self):
-        self.check_type(c_byte, 42)
-        self.check_type(c_byte, -42)
-
-    def test_ubyte(self):
-        self.check_type(c_ubyte, 42)
-
-    def test_short(self):
-        self.check_type(c_short, 42)
-        self.check_type(c_short, -42)
-
-    def test_ushort(self):
-        self.check_type(c_ushort, 42)
-
-    def test_int(self):
-        self.check_type(c_int, 42)
-        self.check_type(c_int, -42)
-
-    def test_uint(self):
-        self.check_type(c_uint, 42)
-
-    def test_long(self):
-        self.check_type(c_long, 42)
-        self.check_type(c_long, -42)
-
-    def test_ulong(self):
-        self.check_type(c_ulong, 42)
-
-    @need_symbol('c_longlong')
-    def test_longlong(self):
-        self.check_type(c_longlong, 42)
-        self.check_type(c_longlong, -42)
-
-    @need_symbol('c_ulonglong')
-    def test_ulonglong(self):
-        self.check_type(c_ulonglong, 42)
-
-    def test_float(self):
-        # only almost equal: double -> float -> double
-        import math
-        self.check_type(c_float, math.e)
-        self.check_type(c_float, -math.e)
-
-    def test_double(self):
-        self.check_type(c_double, 3.14)
-        self.check_type(c_double, -3.14)
-
-    @need_symbol('c_longdouble')
-    def test_longdouble(self):
-        self.check_type(c_longdouble, 3.14)
-        self.check_type(c_longdouble, -3.14)
-
-    def test_char(self):
-        self.check_type(c_char, b"x")
-        self.check_type(c_char, b"a")
-
-    # disabled: would now (correctly) raise a RuntimeWarning about
-    # a memory leak.  A callback function cannot return a non-integral
-    # C type without causing a memory leak.
-    @unittest.skip('test disabled')
-    def test_char_p(self):
-        self.check_type(c_char_p, "abc")
-        self.check_type(c_char_p, "def")
-
-    def test_pyobject(self):
-        o = ()
-        from sys import getrefcount as grc
-        for o in (), [], object():
-            initial = grc(o)
-            # This call leaks a reference to 'o'...
-            self.check_type(py_object, o)
-            before = grc(o)
-            # ...but this call doesn't leak any more.  Where is the refcount?
-            self.check_type(py_object, o)
-            after = grc(o)
-            self.assertEqual((after, o), (before, o))
-
-    def test_unsupported_restype_1(self):
-        # Only "fundamental" result types are supported for callback
-        # functions, the type must have a non-NULL stgdict->setfunc.
-        # POINTER(c_double), for example, is not supported.
-
-        prototype = self.functype.__func__(POINTER(c_double))
-        # The type is checked when the prototype is called
-        self.assertRaises(TypeError, prototype, lambda: None)
-
-    def test_unsupported_restype_2(self):
-        prototype = self.functype.__func__(object)
-        self.assertRaises(TypeError, prototype, lambda: None)
-
-    def test_issue_7959(self):
-        proto = self.functype.__func__(None)
-
-        class X(object):
-            def func(self): pass
-            def __init__(self):
-                self.v = proto(self.func)
-
-        import gc
-        for i in range(32):
-            X()
-        gc.collect()
-        live = [x for x in gc.get_objects()
-                if isinstance(x, X)]
-        self.assertEqual(len(live), 0)
-
-    def test_issue12483(self):
-        import gc
-        class Nasty:
-            def __del__(self):
-                gc.collect()
-        CFUNCTYPE(None)(lambda x=Nasty(): None)
-
-
-@need_symbol('WINFUNCTYPE')
-class StdcallCallbacks(Callbacks):
-    try:
-        functype = WINFUNCTYPE
-    except NameError:
-        pass
-
-################################################################
-
-class SampleCallbacksTestCase(unittest.TestCase):
-
-    def test_integrate(self):
-        # Derived from some then non-working code, posted by David Foster
-        dll = CDLL(_ctypes_test.__file__)
-
-        # The function prototype called by 'integrate': double func(double);
-        CALLBACK = CFUNCTYPE(c_double, c_double)
-
-        # The integrate function itself, exposed from the _ctypes_test dll
-        integrate = dll.integrate
-        integrate.argtypes = (c_double, c_double, CALLBACK, c_long)
-        integrate.restype = c_double
-
-        def func(x):
-            return x**2
-
-        result = integrate(0.0, 1.0, CALLBACK(func), 10)
-        diff = abs(result - 1./3.)
-
-        self.assertLess(diff, 0.01, "%s not less than 0.01" % diff)
-
-    def test_issue_8959_a(self):
-        from ctypes.util import find_library
-        libc_path = find_library("c")
-        if not libc_path:
-            self.skipTest('could not find libc')
-        libc = CDLL(libc_path)
-
-        @CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
-        def cmp_func(a, b):
-            return a[0] - b[0]
-
-        array = (c_int * 5)(5, 1, 99, 7, 33)
-
-        libc.qsort(array, len(array), sizeof(c_int), cmp_func)
-        self.assertEqual(array[:], [1, 5, 7, 33, 99])
-
-    @need_symbol('WINFUNCTYPE')
-    def test_issue_8959_b(self):
-        from ctypes.wintypes import BOOL, HWND, LPARAM
-        global windowCount
-        windowCount = 0
-
-        @WINFUNCTYPE(BOOL, HWND, LPARAM)
-        def EnumWindowsCallbackFunc(hwnd, lParam):
-            global windowCount
-            windowCount += 1
-            return True #Allow windows to keep enumerating
-
-        windll.user32.EnumWindows(EnumWindowsCallbackFunc, 0)
-
-    def test_callback_register_int(self):
-        # Issue #8275: buggy handling of callback args under Win64
-        # NOTE: should be run on release builds as well
-        dll = CDLL(_ctypes_test.__file__)
-        CALLBACK = CFUNCTYPE(c_int, c_int, c_int, c_int, c_int, c_int)
-        # All this function does is call the callback with its args squared
-        func = dll._testfunc_cbk_reg_int
-        func.argtypes = (c_int, c_int, c_int, c_int, c_int, CALLBACK)
-        func.restype = c_int
-
-        def callback(a, b, c, d, e):
-            return a + b + c + d + e
-
-        result = func(2, 3, 4, 5, 6, CALLBACK(callback))
-        self.assertEqual(result, callback(2*2, 3*3, 4*4, 5*5, 6*6))
-
-    def test_callback_register_double(self):
-        # Issue #8275: buggy handling of callback args under Win64
-        # NOTE: should be run on release builds as well
-        dll = CDLL(_ctypes_test.__file__)
-        CALLBACK = CFUNCTYPE(c_double, c_double, c_double, c_double,
-                             c_double, c_double)
-        # All this function does is call the callback with its args squared
-        func = dll._testfunc_cbk_reg_double
-        func.argtypes = (c_double, c_double, c_double,
-                         c_double, c_double, CALLBACK)
-        func.restype = c_double
-
-        def callback(a, b, c, d, e):
-            return a + b + c + d + e
-
-        result = func(1.1, 2.2, 3.3, 4.4, 5.5, CALLBACK(callback))
-        self.assertEqual(result,
-                         callback(1.1*1.1, 2.2*2.2, 3.3*3.3, 4.4*4.4, 5.5*5.5))
-
-    def test_callback_large_struct(self):
-        class Check: pass
-
-        # This should mirror the structure in Modules/_ctypes/_ctypes_test.c
-        class X(Structure):
-            _fields_ = [
-                ('first', c_ulong),
-                ('second', c_ulong),
-                ('third', c_ulong),
-            ]
-
-        def callback(check, s):
-            check.first = s.first
-            check.second = s.second
-            check.third = s.third
-            # See issue #29565.
-            # The structure should be passed by value, so
-            # any changes to it should not be reflected in
-            # the value passed
-            s.first = s.second = s.third = 0x0badf00d
-
-        check = Check()
-        s = X()
-        s.first = 0xdeadbeef
-        s.second = 0xcafebabe
-        s.third = 0x0bad1dea
-
-        CALLBACK = CFUNCTYPE(None, X)
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_cbk_large_struct
-        func.argtypes = (X, CALLBACK)
-        func.restype = None
-        # the function just calls the callback with the passed structure
-        func(s, CALLBACK(functools.partial(callback, check)))
-        self.assertEqual(check.first, s.first)
-        self.assertEqual(check.second, s.second)
-        self.assertEqual(check.third, s.third)
-        self.assertEqual(check.first, 0xdeadbeef)
-        self.assertEqual(check.second, 0xcafebabe)
-        self.assertEqual(check.third, 0x0bad1dea)
-        # See issue #29565.
-        # Ensure that the original struct is unchanged.
-        self.assertEqual(s.first, check.first)
-        self.assertEqual(s.second, check.second)
-        self.assertEqual(s.third, check.third)
-
-    def test_callback_too_many_args(self):
-        def func(*args):
-            return len(args)
-
-        # valid call with nargs <= CTYPES_MAX_ARGCOUNT
-        proto = CFUNCTYPE(c_int, *(c_int,) * CTYPES_MAX_ARGCOUNT)
-        cb = proto(func)
-        args1 = (1,) * CTYPES_MAX_ARGCOUNT
-        self.assertEqual(cb(*args1), CTYPES_MAX_ARGCOUNT)
-
-        # invalid call with nargs > CTYPES_MAX_ARGCOUNT
-        args2 = (1,) * (CTYPES_MAX_ARGCOUNT + 1)
-        with self.assertRaises(ArgumentError):
-            cb(*args2)
-
-        # error when creating the type with too many arguments
-        with self.assertRaises(ArgumentError):
-            CFUNCTYPE(c_int, *(c_int,) * (CTYPES_MAX_ARGCOUNT + 1))
-
-    def test_convert_result_error(self):
-        def func():
-            return ("tuple",)
-
-        proto = CFUNCTYPE(c_int)
-        ctypes_func = proto(func)
-        with support.catch_unraisable_exception() as cm:
-            # don't test the result since it is an uninitialized value
-            result = ctypes_func()
-
-            self.assertIsInstance(cm.unraisable.exc_value, TypeError)
-            self.assertEqual(cm.unraisable.err_msg,
-                             "Exception ignored on converting result "
-                             "of ctypes callback function")
-            self.assertIs(cm.unraisable.object, func)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_cast.py b/Lib/ctypes/test/test_cast.py
deleted file mode 100644
index 6878f973282..00000000000
--- a/Lib/ctypes/test/test_cast.py
+++ /dev/null
@@ -1,99 +0,0 @@
-from ctypes import *
-from ctypes.test import need_symbol
-import unittest
-import sys
-
-class Test(unittest.TestCase):
-
-    def test_array2pointer(self):
-        array = (c_int * 3)(42, 17, 2)
-
-        # casting an array to a pointer works.
-        ptr = cast(array, POINTER(c_int))
-        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
-
-        if 2*sizeof(c_short) == sizeof(c_int):
-            ptr = cast(array, POINTER(c_short))
-            if sys.byteorder == "little":
-                self.assertEqual([ptr[i] for i in range(6)],
-                                     [42, 0, 17, 0, 2, 0])
-            else:
-                self.assertEqual([ptr[i] for i in range(6)],
-                                     [0, 42, 0, 17, 0, 2])
-
-    def test_address2pointer(self):
-        array = (c_int * 3)(42, 17, 2)
-
-        address = addressof(array)
-        ptr = cast(c_void_p(address), POINTER(c_int))
-        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
-
-        ptr = cast(address, POINTER(c_int))
-        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
-
-    def test_p2a_objects(self):
-        array = (c_char_p * 5)()
-        self.assertEqual(array._objects, None)
-        array[0] = b"foo bar"
-        self.assertEqual(array._objects, {'0': b"foo bar"})
-
-        p = cast(array, POINTER(c_char_p))
-        # array and p share a common _objects attribute
-        self.assertIs(p._objects, array._objects)
-        self.assertEqual(array._objects, {'0': b"foo bar", id(array): array})
-        p[0] = b"spam spam"
-        self.assertEqual(p._objects, {'0': b"spam spam", id(array): array})
-        self.assertIs(array._objects, p._objects)
-        p[1] = b"foo bar"
-        self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
-        self.assertIs(array._objects, p._objects)
-
-    def test_other(self):
-        p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
-        self.assertEqual(p[:4], [1,2, 3, 4])
-        self.assertEqual(p[:4:], [1, 2, 3, 4])
-        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
-        self.assertEqual(p[:4:3], [1, 4])
-        c_int()
-        self.assertEqual(p[:4], [1, 2, 3, 4])
-        self.assertEqual(p[:4:], [1, 2, 3, 4])
-        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
-        self.assertEqual(p[:4:3], [1, 4])
-        p[2] = 96
-        self.assertEqual(p[:4], [1, 2, 96, 4])
-        self.assertEqual(p[:4:], [1, 2, 96, 4])
-        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
-        self.assertEqual(p[:4:3], [1, 4])
-        c_int()
-        self.assertEqual(p[:4], [1, 2, 96, 4])
-        self.assertEqual(p[:4:], [1, 2, 96, 4])
-        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
-        self.assertEqual(p[:4:3], [1, 4])
-
-    def test_char_p(self):
-        # This didn't work: bad argument to internal function
-        s = c_char_p(b"hiho")
-        self.assertEqual(cast(cast(s, c_void_p), c_char_p).value,
-                             b"hiho")
-
-    @need_symbol('c_wchar_p')
-    def test_wchar_p(self):
-        s = c_wchar_p("hiho")
-        self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
-                             "hiho")
-
-    def test_bad_type_arg(self):
-        # The type argument must be a ctypes pointer type.
-        array_type = c_byte * sizeof(c_int)
-        array = array_type()
-        self.assertRaises(TypeError, cast, array, None)
-        self.assertRaises(TypeError, cast, array, array_type)
-        class Struct(Structure):
-            _fields_ = [("a", c_int)]
-        self.assertRaises(TypeError, cast, array, Struct)
-        class MyUnion(Union):
-            _fields_ = [("a", c_int)]
-        self.assertRaises(TypeError, cast, array, MyUnion)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_cfuncs.py b/Lib/ctypes/test/test_cfuncs.py
deleted file mode 100644
index 09b06840bf5..00000000000
--- a/Lib/ctypes/test/test_cfuncs.py
+++ /dev/null
@@ -1,218 +0,0 @@
-# A lot of failures in these tests on Mac OS X.
-# Byte order related?
-
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-
-import _ctypes_test
-
-class CFunctions(unittest.TestCase):
-    _dll = CDLL(_ctypes_test.__file__)
-
-    def S(self):
-        return c_longlong.in_dll(self._dll, "last_tf_arg_s").value
-    def U(self):
-        return c_ulonglong.in_dll(self._dll, "last_tf_arg_u").value
-
-    def test_byte(self):
-        self._dll.tf_b.restype = c_byte
-        self._dll.tf_b.argtypes = (c_byte,)
-        self.assertEqual(self._dll.tf_b(-126), -42)
-        self.assertEqual(self.S(), -126)
-
-    def test_byte_plus(self):
-        self._dll.tf_bb.restype = c_byte
-        self._dll.tf_bb.argtypes = (c_byte, c_byte)
-        self.assertEqual(self._dll.tf_bb(0, -126), -42)
-        self.assertEqual(self.S(), -126)
-
-    def test_ubyte(self):
-        self._dll.tf_B.restype = c_ubyte
-        self._dll.tf_B.argtypes = (c_ubyte,)
-        self.assertEqual(self._dll.tf_B(255), 85)
-        self.assertEqual(self.U(), 255)
-
-    def test_ubyte_plus(self):
-        self._dll.tf_bB.restype = c_ubyte
-        self._dll.tf_bB.argtypes = (c_byte, c_ubyte)
-        self.assertEqual(self._dll.tf_bB(0, 255), 85)
-        self.assertEqual(self.U(), 255)
-
-    def test_short(self):
-        self._dll.tf_h.restype = c_short
-        self._dll.tf_h.argtypes = (c_short,)
-        self.assertEqual(self._dll.tf_h(-32766), -10922)
-        self.assertEqual(self.S(), -32766)
-
-    def test_short_plus(self):
-        self._dll.tf_bh.restype = c_short
-        self._dll.tf_bh.argtypes = (c_byte, c_short)
-        self.assertEqual(self._dll.tf_bh(0, -32766), -10922)
-        self.assertEqual(self.S(), -32766)
-
-    def test_ushort(self):
-        self._dll.tf_H.restype = c_ushort
-        self._dll.tf_H.argtypes = (c_ushort,)
-        self.assertEqual(self._dll.tf_H(65535), 21845)
-        self.assertEqual(self.U(), 65535)
-
-    def test_ushort_plus(self):
-        self._dll.tf_bH.restype = c_ushort
-        self._dll.tf_bH.argtypes = (c_byte, c_ushort)
-        self.assertEqual(self._dll.tf_bH(0, 65535), 21845)
-        self.assertEqual(self.U(), 65535)
-
-    def test_int(self):
-        self._dll.tf_i.restype = c_int
-        self._dll.tf_i.argtypes = (c_int,)
-        self.assertEqual(self._dll.tf_i(-2147483646), -715827882)
-        self.assertEqual(self.S(), -2147483646)
-
-    def test_int_plus(self):
-        self._dll.tf_bi.restype = c_int
-        self._dll.tf_bi.argtypes = (c_byte, c_int)
-        self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882)
-        self.assertEqual(self.S(), -2147483646)
-
-    def test_uint(self):
-        self._dll.tf_I.restype = c_uint
-        self._dll.tf_I.argtypes = (c_uint,)
-        self.assertEqual(self._dll.tf_I(4294967295), 1431655765)
-        self.assertEqual(self.U(), 4294967295)
-
-    def test_uint_plus(self):
-        self._dll.tf_bI.restype = c_uint
-        self._dll.tf_bI.argtypes = (c_byte, c_uint)
-        self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
-        self.assertEqual(self.U(), 4294967295)
-
-    def test_long(self):
-        self._dll.tf_l.restype = c_long
-        self._dll.tf_l.argtypes = (c_long,)
-        self.assertEqual(self._dll.tf_l(-2147483646), -715827882)
-        self.assertEqual(self.S(), -2147483646)
-
-    def test_long_plus(self):
-        self._dll.tf_bl.restype = c_long
-        self._dll.tf_bl.argtypes = (c_byte, c_long)
-        self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882)
-        self.assertEqual(self.S(), -2147483646)
-
-    def test_ulong(self):
-        self._dll.tf_L.restype = c_ulong
-        self._dll.tf_L.argtypes = (c_ulong,)
-        self.assertEqual(self._dll.tf_L(4294967295), 1431655765)
-        self.assertEqual(self.U(), 4294967295)
-
-    def test_ulong_plus(self):
-        self._dll.tf_bL.restype = c_ulong
-        self._dll.tf_bL.argtypes = (c_char, c_ulong)
-        self.assertEqual(self._dll.tf_bL(b' ', 4294967295), 1431655765)
-        self.assertEqual(self.U(), 4294967295)
-
-    @need_symbol('c_longlong')
-    def test_longlong(self):
-        self._dll.tf_q.restype = c_longlong
-        self._dll.tf_q.argtypes = (c_longlong, )
-        self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
-        self.assertEqual(self.S(), -9223372036854775806)
-
-    @need_symbol('c_longlong')
-    def test_longlong_plus(self):
-        self._dll.tf_bq.restype = c_longlong
-        self._dll.tf_bq.argtypes = (c_byte, c_longlong)
-        self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
-        self.assertEqual(self.S(), -9223372036854775806)
-
-    @need_symbol('c_ulonglong')
-    def test_ulonglong(self):
-        self._dll.tf_Q.restype = c_ulonglong
-        self._dll.tf_Q.argtypes = (c_ulonglong, )
-        self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
-        self.assertEqual(self.U(), 18446744073709551615)
-
-    @need_symbol('c_ulonglong')
-    def test_ulonglong_plus(self):
-        self._dll.tf_bQ.restype = c_ulonglong
-        self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
-        self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
-        self.assertEqual(self.U(), 18446744073709551615)
-
-    def test_float(self):
-        self._dll.tf_f.restype = c_float
-        self._dll.tf_f.argtypes = (c_float,)
-        self.assertEqual(self._dll.tf_f(-42.), -14.)
-        self.assertEqual(self.S(), -42)
-
-    def test_float_plus(self):
-        self._dll.tf_bf.restype = c_float
-        self._dll.tf_bf.argtypes = (c_byte, c_float)
-        self.assertEqual(self._dll.tf_bf(0, -42.), -14.)
-        self.assertEqual(self.S(), -42)
-
-    def test_double(self):
-        self._dll.tf_d.restype = c_double
-        self._dll.tf_d.argtypes = (c_double,)
-        self.assertEqual(self._dll.tf_d(42.), 14.)
-        self.assertEqual(self.S(), 42)
-
-    def test_double_plus(self):
-        self._dll.tf_bd.restype = c_double
-        self._dll.tf_bd.argtypes = (c_byte, c_double)
-        self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
-        self.assertEqual(self.S(), 42)
-
-    @need_symbol('c_longdouble')
-    def test_longdouble(self):
-        self._dll.tf_D.restype = c_longdouble
-        self._dll.tf_D.argtypes = (c_longdouble,)
-        self.assertEqual(self._dll.tf_D(42.), 14.)
-        self.assertEqual(self.S(), 42)
-
-    @need_symbol('c_longdouble')
-    def test_longdouble_plus(self):
-        self._dll.tf_bD.restype = c_longdouble
-        self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
-        self.assertEqual(self._dll.tf_bD(0, 42.), 14.)
-        self.assertEqual(self.S(), 42)
-
-    def test_callwithresult(self):
-        def process_result(result):
-            return result * 2
-        self._dll.tf_i.restype = process_result
-        self._dll.tf_i.argtypes = (c_int,)
-        self.assertEqual(self._dll.tf_i(42), 28)
-        self.assertEqual(self.S(), 42)
-        self.assertEqual(self._dll.tf_i(-42), -28)
-        self.assertEqual(self.S(), -42)
-
-    def test_void(self):
-        self._dll.tv_i.restype = None
-        self._dll.tv_i.argtypes = (c_int,)
-        self.assertEqual(self._dll.tv_i(42), None)
-        self.assertEqual(self.S(), 42)
-        self.assertEqual(self._dll.tv_i(-42), None)
-        self.assertEqual(self.S(), -42)
-
-# The following repeats the above tests with stdcall functions (where
-# they are available)
-try:
-    WinDLL
-except NameError:
-    def stdcall_dll(*_): pass
-else:
-    class stdcall_dll(WinDLL):
-        def __getattr__(self, name):
-            if name[:2] == '__' and name[-2:] == '__':
-                raise AttributeError(name)
-            func = self._FuncPtr(("s_" + name, self))
-            setattr(self, name, func)
-            return func
-
-@need_symbol('WinDLL')
-class stdcallCFunctions(CFunctions):
-    _dll = stdcall_dll(_ctypes_test.__file__)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_checkretval.py b/Lib/ctypes/test/test_checkretval.py
deleted file mode 100644
index e9567dc3912..00000000000
--- a/Lib/ctypes/test/test_checkretval.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import unittest
-
-from ctypes import *
-from ctypes.test import need_symbol
-
-class CHECKED(c_int):
-    def _check_retval_(value):
-        # Receives a CHECKED instance.
-        return str(value.value)
-    _check_retval_ = staticmethod(_check_retval_)
-
-class Test(unittest.TestCase):
-
-    def test_checkretval(self):
-
-        import _ctypes_test
-        dll = CDLL(_ctypes_test.__file__)
-        self.assertEqual(42, dll._testfunc_p_p(42))
-
-        dll._testfunc_p_p.restype = CHECKED
-        self.assertEqual("42", dll._testfunc_p_p(42))
-
-        dll._testfunc_p_p.restype = None
-        self.assertEqual(None, dll._testfunc_p_p(42))
-
-        del dll._testfunc_p_p.restype
-        self.assertEqual(42, dll._testfunc_p_p(42))
-
-    @need_symbol('oledll')
-    def test_oledll(self):
-        self.assertRaises(OSError,
-                              oledll.oleaut32.CreateTypeLib2,
-                              0, None, None)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_delattr.py b/Lib/ctypes/test/test_delattr.py
deleted file mode 100644
index 0f4d58691b5..00000000000
--- a/Lib/ctypes/test/test_delattr.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import unittest
-from ctypes import *
-
-class X(Structure):
-    _fields_ = [("foo", c_int)]
-
-class TestCase(unittest.TestCase):
-    def test_simple(self):
-        self.assertRaises(TypeError,
-                          delattr, c_int(42), "value")
-
-    def test_chararray(self):
-        self.assertRaises(TypeError,
-                          delattr, (c_char * 5)(), "value")
-
-    def test_struct(self):
-        self.assertRaises(TypeError,
-                          delattr, X(), "foo")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_errno.py b/Lib/ctypes/test/test_errno.py
deleted file mode 100644
index 3685164dde6..00000000000
--- a/Lib/ctypes/test/test_errno.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import unittest, os, errno
-import threading
-
-from ctypes import *
-from ctypes.util import find_library
-
-class Test(unittest.TestCase):
-    def test_open(self):
-        libc_name = find_library("c")
-        if libc_name is None:
-            raise unittest.SkipTest("Unable to find C library")
-        libc = CDLL(libc_name, use_errno=True)
-        if os.name == "nt":
-            libc_open = libc._open
-        else:
-            libc_open = libc.open
-
-        libc_open.argtypes = c_char_p, c_int
-
-        self.assertEqual(libc_open(b"", 0), -1)
-        self.assertEqual(get_errno(), errno.ENOENT)
-
-        self.assertEqual(set_errno(32), errno.ENOENT)
-        self.assertEqual(get_errno(), 32)
-
-        def _worker():
-            set_errno(0)
-
-            libc = CDLL(libc_name, use_errno=False)
-            if os.name == "nt":
-                libc_open = libc._open
-            else:
-                libc_open = libc.open
-            libc_open.argtypes = c_char_p, c_int
-            self.assertEqual(libc_open(b"", 0), -1)
-            self.assertEqual(get_errno(), 0)
-
-        t = threading.Thread(target=_worker)
-        t.start()
-        t.join()
-
-        self.assertEqual(get_errno(), 32)
-        set_errno(0)
-
-    @unittest.skipUnless(os.name == "nt", 'Test specific to Windows')
-    def test_GetLastError(self):
-        dll = WinDLL("kernel32", use_last_error=True)
-        GetModuleHandle = dll.GetModuleHandleA
-        GetModuleHandle.argtypes = [c_wchar_p]
-
-        self.assertEqual(0, GetModuleHandle("foo"))
-        self.assertEqual(get_last_error(), 126)
-
-        self.assertEqual(set_last_error(32), 126)
-        self.assertEqual(get_last_error(), 32)
-
-        def _worker():
-            set_last_error(0)
-
-            dll = WinDLL("kernel32", use_last_error=False)
-            GetModuleHandle = dll.GetModuleHandleW
-            GetModuleHandle.argtypes = [c_wchar_p]
-            GetModuleHandle("bar")
-
-            self.assertEqual(get_last_error(), 0)
-
-        t = threading.Thread(target=_worker)
-        t.start()
-        t.join()
-
-        self.assertEqual(get_last_error(), 32)
-
-        set_last_error(0)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_find.py b/Lib/ctypes/test/test_find.py
deleted file mode 100644
index 1ff9d019b13..00000000000
--- a/Lib/ctypes/test/test_find.py
+++ /dev/null
@@ -1,127 +0,0 @@
-import unittest
-import unittest.mock
-import os.path
-import sys
-import test.support
-from test.support import os_helper
-from ctypes import *
-from ctypes.util import find_library
-
-# On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.
-class Test_OpenGL_libs(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        lib_gl = lib_glu = lib_gle = None
-        if sys.platform == "win32":
-            lib_gl = find_library("OpenGL32")
-            lib_glu = find_library("Glu32")
-        elif sys.platform == "darwin":
-            lib_gl = lib_glu = find_library("OpenGL")
-        else:
-            lib_gl = find_library("GL")
-            lib_glu = find_library("GLU")
-            lib_gle = find_library("gle")
-
-        ## print, for debugging
-        if test.support.verbose:
-            print("OpenGL libraries:")
-            for item in (("GL", lib_gl),
-                         ("GLU", lib_glu),
-                         ("gle", lib_gle)):
-                print("\t", item)
-
-        cls.gl = cls.glu = cls.gle = None
-        if lib_gl:
-            try:
-                cls.gl = CDLL(lib_gl, mode=RTLD_GLOBAL)
-            except OSError:
-                pass
-        if lib_glu:
-            try:
-                cls.glu = CDLL(lib_glu, RTLD_GLOBAL)
-            except OSError:
-                pass
-        if lib_gle:
-            try:
-                cls.gle = CDLL(lib_gle)
-            except OSError:
-                pass
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.gl = cls.glu = cls.gle = None
-
-    def test_gl(self):
-        if self.gl is None:
-            self.skipTest('lib_gl not available')
-        self.gl.glClearIndex
-
-    def test_glu(self):
-        if self.glu is None:
-            self.skipTest('lib_glu not available')
-        self.glu.gluBeginCurve
-
-    def test_gle(self):
-        if self.gle is None:
-            self.skipTest('lib_gle not available')
-        self.gle.gleGetJoinStyle
-
-    def test_shell_injection(self):
-        result = find_library('; echo Hello shell > ' + os_helper.TESTFN)
-        self.assertFalse(os.path.lexists(os_helper.TESTFN))
-        self.assertIsNone(result)
-
-
-@unittest.skipUnless(sys.platform.startswith('linux'),
-                     'Test only valid for Linux')
-class FindLibraryLinux(unittest.TestCase):
-    def test_find_on_libpath(self):
-        import subprocess
-        import tempfile
-
-        try:
-            p = subprocess.Popen(['gcc', '--version'], stdout=subprocess.PIPE,
-                                 stderr=subprocess.DEVNULL)
-            out, _ = p.communicate()
-        except OSError:
-            raise unittest.SkipTest('gcc, needed for test, not available')
-        with tempfile.TemporaryDirectory() as d:
-            # create an empty temporary file
-            srcname = os.path.join(d, 'dummy.c')
-            libname = 'py_ctypes_test_dummy'
-            dstname = os.path.join(d, 'lib%s.so' % libname)
-            with open(srcname, 'wb') as f:
-                pass
-            self.assertTrue(os.path.exists(srcname))
-            # compile the file to a shared library
-            cmd = ['gcc', '-o', dstname, '--shared',
-                   '-Wl,-soname,lib%s.so' % libname, srcname]
-            out = subprocess.check_output(cmd)
-            self.assertTrue(os.path.exists(dstname))
-            # now check that the .so can't be found (since not in
-            # LD_LIBRARY_PATH)
-            self.assertIsNone(find_library(libname))
-            # now add the location to LD_LIBRARY_PATH
-            with os_helper.EnvironmentVarGuard() as env:
-                KEY = 'LD_LIBRARY_PATH'
-                if KEY not in env:
-                    v = d
-                else:
-                    v = '%s:%s' % (env[KEY], d)
-                env.set(KEY, v)
-                # now check that the .so can be found (since in
-                # LD_LIBRARY_PATH)
-                self.assertEqual(find_library(libname), 'lib%s.so' % libname)
-
-    def test_find_library_with_gcc(self):
-        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None):
-            self.assertNotEqual(find_library('c'), None)
-
-    def test_find_library_with_ld(self):
-        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None), \
-             unittest.mock.patch("ctypes.util._findLib_gcc", lambda *args: None):
-            self.assertNotEqual(find_library('c'), None)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_frombuffer.py b/Lib/ctypes/test/test_frombuffer.py
deleted file mode 100644
index 55c244356b3..00000000000
--- a/Lib/ctypes/test/test_frombuffer.py
+++ /dev/null
@@ -1,141 +0,0 @@
-from ctypes import *
-import array
-import gc
-import unittest
-
-class X(Structure):
-    _fields_ = [("c_int", c_int)]
-    init_called = False
-    def __init__(self):
-        self._init_called = True
-
-class Test(unittest.TestCase):
-    def test_from_buffer(self):
-        a = array.array("i", range(16))
-        x = (c_int * 16).from_buffer(a)
-
-        y = X.from_buffer(a)
-        self.assertEqual(y.c_int, a[0])
-        self.assertFalse(y.init_called)
-
-        self.assertEqual(x[:], a.tolist())
-
-        a[0], a[-1] = 200, -200
-        self.assertEqual(x[:], a.tolist())
-
-        self.assertRaises(BufferError, a.append, 100)
-        self.assertRaises(BufferError, a.pop)
-
-        del x; del y; gc.collect(); gc.collect(); gc.collect()
-        a.append(100)
-        a.pop()
-        x = (c_int * 16).from_buffer(a)
-
-        self.assertIn(a, [obj.obj if isinstance(obj, memoryview) else obj
-                          for obj in x._objects.values()])
-
-        expected = x[:]
-        del a; gc.collect(); gc.collect(); gc.collect()
-        self.assertEqual(x[:], expected)
-
-        with self.assertRaisesRegex(TypeError, "not writable"):
-            (c_char * 16).from_buffer(b"a" * 16)
-        with self.assertRaisesRegex(TypeError, "not writable"):
-            (c_char * 16).from_buffer(memoryview(b"a" * 16))
-        with self.assertRaisesRegex(TypeError, "not C contiguous"):
-            (c_char * 16).from_buffer(memoryview(bytearray(b"a" * 16))[::-1])
-        msg = "bytes-like object is required"
-        with self.assertRaisesRegex(TypeError, msg):
-            (c_char * 16).from_buffer("a" * 16)
-
-    def test_fortran_contiguous(self):
-        try:
-            import _testbuffer
-        except ImportError as err:
-            self.skipTest(str(err))
-        flags = _testbuffer.ND_WRITABLE | _testbuffer.ND_FORTRAN
-        array = _testbuffer.ndarray(
-            [97] * 16, format="B", shape=[4, 4], flags=flags)
-        with self.assertRaisesRegex(TypeError, "not C contiguous"):
-            (c_char * 16).from_buffer(array)
-        array = memoryview(array)
-        self.assertTrue(array.f_contiguous)
-        self.assertFalse(array.c_contiguous)
-        with self.assertRaisesRegex(TypeError, "not C contiguous"):
-            (c_char * 16).from_buffer(array)
-
-    def test_from_buffer_with_offset(self):
-        a = array.array("i", range(16))
-        x = (c_int * 15).from_buffer(a, sizeof(c_int))
-
-        self.assertEqual(x[:], a.tolist()[1:])
-        with self.assertRaises(ValueError):
-            c_int.from_buffer(a, -1)
-        with self.assertRaises(ValueError):
-            (c_int * 16).from_buffer(a, sizeof(c_int))
-        with self.assertRaises(ValueError):
-            (c_int * 1).from_buffer(a, 16 * sizeof(c_int))
-
-    def test_from_buffer_memoryview(self):
-        a = [c_char.from_buffer(memoryview(bytearray(b'a')))]
-        a.append(a)
-        del a
-        gc.collect()  # Should not crash
-
-    def test_from_buffer_copy(self):
-        a = array.array("i", range(16))
-        x = (c_int * 16).from_buffer_copy(a)
-
-        y = X.from_buffer_copy(a)
-        self.assertEqual(y.c_int, a[0])
-        self.assertFalse(y.init_called)
-
-        self.assertEqual(x[:], list(range(16)))
-
-        a[0], a[-1] = 200, -200
-        self.assertEqual(x[:], list(range(16)))
-
-        a.append(100)
-        self.assertEqual(x[:], list(range(16)))
-
-        self.assertEqual(x._objects, None)
-
-        del a; gc.collect(); gc.collect(); gc.collect()
-        self.assertEqual(x[:], list(range(16)))
-
-        x = (c_char * 16).from_buffer_copy(b"a" * 16)
-        self.assertEqual(x[:], b"a" * 16)
-        with self.assertRaises(TypeError):
-            (c_char * 16).from_buffer_copy("a" * 16)
-
-    def test_from_buffer_copy_with_offset(self):
-        a = array.array("i", range(16))
-        x = (c_int * 15).from_buffer_copy(a, sizeof(c_int))
-
-        self.assertEqual(x[:], a.tolist()[1:])
-        with self.assertRaises(ValueError):
-            c_int.from_buffer_copy(a, -1)
-        with self.assertRaises(ValueError):
-            (c_int * 16).from_buffer_copy(a, sizeof(c_int))
-        with self.assertRaises(ValueError):
-            (c_int * 1).from_buffer_copy(a, 16 * sizeof(c_int))
-
-    def test_abstract(self):
-        from ctypes import _Pointer, _SimpleCData, _CFuncPtr
-
-        self.assertRaises(TypeError, Array.from_buffer, bytearray(10))
-        self.assertRaises(TypeError, Structure.from_buffer, bytearray(10))
-        self.assertRaises(TypeError, Union.from_buffer, bytearray(10))
-        self.assertRaises(TypeError, _CFuncPtr.from_buffer, bytearray(10))
-        self.assertRaises(TypeError, _Pointer.from_buffer, bytearray(10))
-        self.assertRaises(TypeError, _SimpleCData.from_buffer, bytearray(10))
-
-        self.assertRaises(TypeError, Array.from_buffer_copy, b"123")
-        self.assertRaises(TypeError, Structure.from_buffer_copy, b"123")
-        self.assertRaises(TypeError, Union.from_buffer_copy, b"123")
-        self.assertRaises(TypeError, _CFuncPtr.from_buffer_copy, b"123")
-        self.assertRaises(TypeError, _Pointer.from_buffer_copy, b"123")
-        self.assertRaises(TypeError, _SimpleCData.from_buffer_copy, b"123")
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_funcptr.py b/Lib/ctypes/test/test_funcptr.py
deleted file mode 100644
index e0b9b54e97f..00000000000
--- a/Lib/ctypes/test/test_funcptr.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import unittest
-from ctypes import *
-
-try:
-    WINFUNCTYPE
-except NameError:
-    # fake to enable this test on Linux
-    WINFUNCTYPE = CFUNCTYPE
-
-import _ctypes_test
-lib = CDLL(_ctypes_test.__file__)
-
-class CFuncPtrTestCase(unittest.TestCase):
-    def test_basic(self):
-        X = WINFUNCTYPE(c_int, c_int, c_int)
-
-        def func(*args):
-            return len(args)
-
-        x = X(func)
-        self.assertEqual(x.restype, c_int)
-        self.assertEqual(x.argtypes, (c_int, c_int))
-        self.assertEqual(sizeof(x), sizeof(c_voidp))
-        self.assertEqual(sizeof(X), sizeof(c_voidp))
-
-    def test_first(self):
-        StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
-        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
-
-        def func(a, b):
-            return a + b
-
-        s = StdCallback(func)
-        c = CdeclCallback(func)
-
-        self.assertEqual(s(1, 2), 3)
-        self.assertEqual(c(1, 2), 3)
-        # The following no longer raises a TypeError - it is now
-        # possible, as in C, to call cdecl functions with more parameters.
-        #self.assertRaises(TypeError, c, 1, 2, 3)
-        self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
-        if not WINFUNCTYPE is CFUNCTYPE:
-            self.assertRaises(TypeError, s, 1, 2, 3)
-
-    def test_structures(self):
-        WNDPROC = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
-
-        def wndproc(hwnd, msg, wParam, lParam):
-            return hwnd + msg + wParam + lParam
-
-        HINSTANCE = c_int
-        HICON = c_int
-        HCURSOR = c_int
-        LPCTSTR = c_char_p
-
-        class WNDCLASS(Structure):
-            _fields_ = [("style", c_uint),
-                        ("lpfnWndProc", WNDPROC),
-                        ("cbClsExtra", c_int),
-                        ("cbWndExtra", c_int),
-                        ("hInstance", HINSTANCE),
-                        ("hIcon", HICON),
-                        ("hCursor", HCURSOR),
-                        ("lpszMenuName", LPCTSTR),
-                        ("lpszClassName", LPCTSTR)]
-
-        wndclass = WNDCLASS()
-        wndclass.lpfnWndProc = WNDPROC(wndproc)
-
-        WNDPROC_2 = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
-
-        # This is no longer true, now that WINFUNCTYPE caches created types internally.
-        ## # CFuncPtr subclasses are compared by identity, so this raises a TypeError:
-        ## self.assertRaises(TypeError, setattr, wndclass,
-        ##                  "lpfnWndProc", WNDPROC_2(wndproc))
-        # instead:
-
-        self.assertIs(WNDPROC, WNDPROC_2)
-        # 'wndclass.lpfnWndProc' leaks 94 references.  Why?
-        self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
-
-
-        f = wndclass.lpfnWndProc
-
-        del wndclass
-        del wndproc
-
-        self.assertEqual(f(10, 11, 12, 13), 46)
-
-    def test_dllfunctions(self):
-
-        def NoNullHandle(value):
-            if not value:
-                raise WinError()
-            return value
-
-        strchr = lib.my_strchr
-        strchr.restype = c_char_p
-        strchr.argtypes = (c_char_p, c_char)
-        self.assertEqual(strchr(b"abcdefghi", b"b"), b"bcdefghi")
-        self.assertEqual(strchr(b"abcdefghi", b"x"), None)
-
-
-        strtok = lib.my_strtok
-        strtok.restype = c_char_p
-        # Neither of this does work: strtok changes the buffer it is passed
-##        strtok.argtypes = (c_char_p, c_char_p)
-##        strtok.argtypes = (c_string, c_char_p)
-
-        def c_string(init):
-            size = len(init) + 1
-            return (c_char*size)(*init)
-
-        s = b"a\nb\nc"
-        b = c_string(s)
-
-##        b = (c_char * (len(s)+1))()
-##        b.value = s
-
-##        b = c_string(s)
-        self.assertEqual(strtok(b, b"\n"), b"a")
-        self.assertEqual(strtok(None, b"\n"), b"b")
-        self.assertEqual(strtok(None, b"\n"), b"c")
-        self.assertEqual(strtok(None, b"\n"), None)
-
-    def test_abstract(self):
-        from ctypes import _CFuncPtr
-
-        self.assertRaises(TypeError, _CFuncPtr, 13, "name", 42, "iid")
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_functions.py b/Lib/ctypes/test/test_functions.py
deleted file mode 100644
index fc571700ce3..00000000000
--- a/Lib/ctypes/test/test_functions.py
+++ /dev/null
@@ -1,384 +0,0 @@
-"""
-Here is probably the place to write the docs, since the test-cases
-show how the type behave.
-
-Later...
-"""
-
-from ctypes import *
-from ctypes.test import need_symbol
-import sys, unittest
-
-try:
-    WINFUNCTYPE
-except NameError:
-    # fake to enable this test on Linux
-    WINFUNCTYPE = CFUNCTYPE
-
-import _ctypes_test
-dll = CDLL(_ctypes_test.__file__)
-if sys.platform == "win32":
-    windll = WinDLL(_ctypes_test.__file__)
-
-class POINT(Structure):
-    _fields_ = [("x", c_int), ("y", c_int)]
-class RECT(Structure):
-    _fields_ = [("left", c_int), ("top", c_int),
-                ("right", c_int), ("bottom", c_int)]
-class FunctionTestCase(unittest.TestCase):
-
-    def test_mro(self):
-        # in Python 2.3, this raises TypeError: MRO conflict among bases classes,
-        # in Python 2.2 it works.
-        #
-        # But in early versions of _ctypes.c, the result of tp_new
-        # wasn't checked, and it even crashed Python.
-        # Found by Greg Chapman.
-
-        with self.assertRaises(TypeError):
-            class X(object, Array):
-                _length_ = 5
-                _type_ = "i"
-
-        from _ctypes import _Pointer
-        with self.assertRaises(TypeError):
-            class X(object, _Pointer):
-                pass
-
-        from _ctypes import _SimpleCData
-        with self.assertRaises(TypeError):
-            class X(object, _SimpleCData):
-                _type_ = "i"
-
-        with self.assertRaises(TypeError):
-            class X(object, Structure):
-                _fields_ = []
-
-    @need_symbol('c_wchar')
-    def test_wchar_parm(self):
-        f = dll._testfunc_i_bhilfd
-        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
-        result = f(1, "x", 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 139)
-        self.assertEqual(type(result), int)
-
-    @need_symbol('c_wchar')
-    def test_wchar_result(self):
-        f = dll._testfunc_i_bhilfd
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
-        f.restype = c_wchar
-        result = f(0, 0, 0, 0, 0, 0)
-        self.assertEqual(result, '\x00')
-
-    def test_voidresult(self):
-        f = dll._testfunc_v
-        f.restype = None
-        f.argtypes = [c_int, c_int, POINTER(c_int)]
-        result = c_int()
-        self.assertEqual(None, f(1, 2, byref(result)))
-        self.assertEqual(result.value, 3)
-
-    def test_intresult(self):
-        f = dll._testfunc_i_bhilfd
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
-        f.restype = c_int
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), int)
-
-        result = f(-1, -2, -3, -4, -5.0, -6.0)
-        self.assertEqual(result, -21)
-        self.assertEqual(type(result), int)
-
-        # If we declare the function to return a short,
-        # is the high part split off?
-        f.restype = c_short
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), int)
-
-        result = f(1, 2, 3, 0x10004, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), int)
-
-        # You cannot assign character format codes as restype any longer
-        self.assertRaises(TypeError, setattr, f, "restype", "i")
-
-    def test_floatresult(self):
-        f = dll._testfunc_f_bhilfd
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
-        f.restype = c_float
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), float)
-
-        result = f(-1, -2, -3, -4, -5.0, -6.0)
-        self.assertEqual(result, -21)
-        self.assertEqual(type(result), float)
-
-    def test_doubleresult(self):
-        f = dll._testfunc_d_bhilfd
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
-        f.restype = c_double
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), float)
-
-        result = f(-1, -2, -3, -4, -5.0, -6.0)
-        self.assertEqual(result, -21)
-        self.assertEqual(type(result), float)
-
-    @need_symbol('c_longdouble')
-    def test_longdoubleresult(self):
-        f = dll._testfunc_D_bhilfD
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
-        f.restype = c_longdouble
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-        self.assertEqual(type(result), float)
-
-        result = f(-1, -2, -3, -4, -5.0, -6.0)
-        self.assertEqual(result, -21)
-        self.assertEqual(type(result), float)
-
-    @need_symbol('c_longlong')
-    def test_longlongresult(self):
-        f = dll._testfunc_q_bhilfd
-        f.restype = c_longlong
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
-        result = f(1, 2, 3, 4, 5.0, 6.0)
-        self.assertEqual(result, 21)
-
-        f = dll._testfunc_q_bhilfdq
-        f.restype = c_longlong
-        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong]
-        result = f(1, 2, 3, 4, 5.0, 6.0, 21)
-        self.assertEqual(result, 42)
-
-    def test_stringresult(self):
-        f = dll._testfunc_p_p
-        f.argtypes = None
-        f.restype = c_char_p
-        result = f(b"123")
-        self.assertEqual(result, b"123")
-
-        result = f(None)
-        self.assertEqual(result, None)
-
-    def test_pointers(self):
-        f = dll._testfunc_p_p
-        f.restype = POINTER(c_int)
-        f.argtypes = [POINTER(c_int)]
-
-        # This only works if the value c_int(42) passed to the
-        # function is still alive while the pointer (the result) is
-        # used.
-
-        v = c_int(42)
-
-        self.assertEqual(pointer(v).contents.value, 42)
-        result = f(pointer(v))
-        self.assertEqual(type(result), POINTER(c_int))
-        self.assertEqual(result.contents.value, 42)
-
-        # This on works...
-        result = f(pointer(v))
-        self.assertEqual(result.contents.value, v.value)
-
-        p = pointer(c_int(99))
-        result = f(p)
-        self.assertEqual(result.contents.value, 99)
-
-        arg = byref(v)
-        result = f(arg)
-        self.assertNotEqual(result.contents, v.value)
-
-        self.assertRaises(ArgumentError, f, byref(c_short(22)))
-
-        # It is dangerous, however, because you don't control the lifetime
-        # of the pointer:
-        result = f(byref(c_int(99)))
-        self.assertNotEqual(result.contents, 99)
-
-    ################################################################
-    def test_shorts(self):
-        f = dll._testfunc_callback_i_if
-
-        args = []
-        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
-                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
-
-        def callback(v):
-            args.append(v)
-            return v
-
-        CallBack = CFUNCTYPE(c_int, c_int)
-
-        cb = CallBack(callback)
-        f(2**18, cb)
-        self.assertEqual(args, expected)
-
-    ################################################################
-
-
-    def test_callbacks(self):
-        f = dll._testfunc_callback_i_if
-        f.restype = c_int
-        f.argtypes = None
-
-        MyCallback = CFUNCTYPE(c_int, c_int)
-
-        def callback(value):
-            #print "called back with", value
-            return value
-
-        cb = MyCallback(callback)
-        result = f(-10, cb)
-        self.assertEqual(result, -18)
-
-        # test with prototype
-        f.argtypes = [c_int, MyCallback]
-        cb = MyCallback(callback)
-        result = f(-10, cb)
-        self.assertEqual(result, -18)
-
-        AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int)
-
-        # check that the prototype works: we call f with wrong
-        # argument types
-        cb = AnotherCallback(callback)
-        self.assertRaises(ArgumentError, f, -10, cb)
-
-
-    def test_callbacks_2(self):
-        # Can also use simple datatypes as argument type specifiers
-        # for the callback function.
-        # In this case the call receives an instance of that type
-        f = dll._testfunc_callback_i_if
-        f.restype = c_int
-
-        MyCallback = CFUNCTYPE(c_int, c_int)
-
-        f.argtypes = [c_int, MyCallback]
-
-        def callback(value):
-            #print "called back with", value
-            self.assertEqual(type(value), int)
-            return value
-
-        cb = MyCallback(callback)
-        result = f(-10, cb)
-        self.assertEqual(result, -18)
-
-    @need_symbol('c_longlong')
-    def test_longlong_callbacks(self):
-
-        f = dll._testfunc_callback_q_qf
-        f.restype = c_longlong
-
-        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
-
-        f.argtypes = [c_longlong, MyCallback]
-
-        def callback(value):
-            self.assertIsInstance(value, int)
-            return value & 0x7FFFFFFF
-
-        cb = MyCallback(callback)
-
-        self.assertEqual(13577625587, f(1000000000000, cb))
-
-    def test_errors(self):
-        self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy")
-        self.assertRaises(ValueError, c_int.in_dll, dll, "_xxx_yyy")
-
-    def test_byval(self):
-
-        # without prototype
-        ptin = POINT(1, 2)
-        ptout = POINT()
-        # EXPORT int _testfunc_byval(point in, point *pout)
-        result = dll._testfunc_byval(ptin, byref(ptout))
-        got = result, ptout.x, ptout.y
-        expected = 3, 1, 2
-        self.assertEqual(got, expected)
-
-        # with prototype
-        ptin = POINT(101, 102)
-        ptout = POINT()
-        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
-        dll._testfunc_byval.restype = c_int
-        result = dll._testfunc_byval(ptin, byref(ptout))
-        got = result, ptout.x, ptout.y
-        expected = 203, 101, 102
-        self.assertEqual(got, expected)
-
-    def test_struct_return_2H(self):
-        class S2H(Structure):
-            _fields_ = [("x", c_short),
-                        ("y", c_short)]
-        dll.ret_2h_func.restype = S2H
-        dll.ret_2h_func.argtypes = [S2H]
-        inp = S2H(99, 88)
-        s2h = dll.ret_2h_func(inp)
-        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
-
-    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-    def test_struct_return_2H_stdcall(self):
-        class S2H(Structure):
-            _fields_ = [("x", c_short),
-                        ("y", c_short)]
-
-        windll.s_ret_2h_func.restype = S2H
-        windll.s_ret_2h_func.argtypes = [S2H]
-        s2h = windll.s_ret_2h_func(S2H(99, 88))
-        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
-
-    def test_struct_return_8H(self):
-        class S8I(Structure):
-            _fields_ = [("a", c_int),
-                        ("b", c_int),
-                        ("c", c_int),
-                        ("d", c_int),
-                        ("e", c_int),
-                        ("f", c_int),
-                        ("g", c_int),
-                        ("h", c_int)]
-        dll.ret_8i_func.restype = S8I
-        dll.ret_8i_func.argtypes = [S8I]
-        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
-        s8i = dll.ret_8i_func(inp)
-        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
-                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
-
-    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-    def test_struct_return_8H_stdcall(self):
-        class S8I(Structure):
-            _fields_ = [("a", c_int),
-                        ("b", c_int),
-                        ("c", c_int),
-                        ("d", c_int),
-                        ("e", c_int),
-                        ("f", c_int),
-                        ("g", c_int),
-                        ("h", c_int)]
-        windll.s_ret_8i_func.restype = S8I
-        windll.s_ret_8i_func.argtypes = [S8I]
-        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
-        s8i = windll.s_ret_8i_func(inp)
-        self.assertEqual(
-                (s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
-                (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
-
-    def test_sf1651235(self):
-        # see https://www.python.org/sf/1651235
-
-        proto = CFUNCTYPE(c_int, RECT, POINT)
-        def callback(*args):
-            return 0
-
-        callback = proto(callback)
-        self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT()))
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_incomplete.py b/Lib/ctypes/test/test_incomplete.py
deleted file mode 100644
index 00c430ef53c..00000000000
--- a/Lib/ctypes/test/test_incomplete.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import unittest
-from ctypes import *
-
-################################################################
-#
-# The incomplete pointer example from the tutorial
-#
-
-class MyTestCase(unittest.TestCase):
-
-    def test_incomplete_example(self):
-        lpcell = POINTER("cell")
-        class cell(Structure):
-            _fields_ = [("name", c_char_p),
-                        ("next", lpcell)]
-
-        SetPointerType(lpcell, cell)
-
-        c1 = cell()
-        c1.name = b"foo"
-        c2 = cell()
-        c2.name = b"bar"
-
-        c1.next = pointer(c2)
-        c2.next = pointer(c1)
-
-        p = c1
-
-        result = []
-        for i in range(8):
-            result.append(p.name)
-            p = p.next[0]
-        self.assertEqual(result, [b"foo", b"bar"] * 4)
-
-        # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[cell]
-
-################################################################
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_init.py b/Lib/ctypes/test/test_init.py
deleted file mode 100644
index 75fad112a01..00000000000
--- a/Lib/ctypes/test/test_init.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from ctypes import *
-import unittest
-
-class X(Structure):
-    _fields_ = [("a", c_int),
-                ("b", c_int)]
-    new_was_called = False
-
-    def __new__(cls):
-        result = super().__new__(cls)
-        result.new_was_called = True
-        return result
-
-    def __init__(self):
-        self.a = 9
-        self.b = 12
-
-class Y(Structure):
-    _fields_ = [("x", X)]
-
-
-class InitTest(unittest.TestCase):
-    def test_get(self):
-        # make sure the only accessing a nested structure
-        # doesn't call the structure's __new__ and __init__
-        y = Y()
-        self.assertEqual((y.x.a, y.x.b), (0, 0))
-        self.assertEqual(y.x.new_was_called, False)
-
-        # But explicitly creating an X structure calls __new__ and __init__, of course.
-        x = X()
-        self.assertEqual((x.a, x.b), (9, 12))
-        self.assertEqual(x.new_was_called, True)
-
-        y.x = x
-        self.assertEqual((y.x.a, y.x.b), (9, 12))
-        self.assertEqual(y.x.new_was_called, False)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_internals.py b/Lib/ctypes/test/test_internals.py
deleted file mode 100644
index 271e3f57f81..00000000000
--- a/Lib/ctypes/test/test_internals.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# This tests the internal _objects attribute
-import unittest
-from ctypes import *
-from sys import getrefcount as grc
-
-# XXX This test must be reviewed for correctness!!!
-
-# ctypes' types are container types.
-#
-# They have an internal memory block, which only consists of some bytes,
-# but it has to keep references to other objects as well. This is not
-# really needed for trivial C types like int or char, but it is important
-# for aggregate types like strings or pointers in particular.
-#
-# What about pointers?
-
-class ObjectsTestCase(unittest.TestCase):
-    def assertSame(self, a, b):
-        self.assertEqual(id(a), id(b))
-
-    def test_ints(self):
-        i = 42000123
-        refcnt = grc(i)
-        ci = c_int(i)
-        self.assertEqual(refcnt, grc(i))
-        self.assertEqual(ci._objects, None)
-
-    def test_c_char_p(self):
-        s = b"Hello, World"
-        refcnt = grc(s)
-        cs = c_char_p(s)
-        self.assertEqual(refcnt + 1, grc(s))
-        self.assertSame(cs._objects, s)
-
-    def test_simple_struct(self):
-        class X(Structure):
-            _fields_ = [("a", c_int), ("b", c_int)]
-
-        a = 421234
-        b = 421235
-        x = X()
-        self.assertEqual(x._objects, None)
-        x.a = a
-        x.b = b
-        self.assertEqual(x._objects, None)
-
-    def test_embedded_structs(self):
-        class X(Structure):
-            _fields_ = [("a", c_int), ("b", c_int)]
-
-        class Y(Structure):
-            _fields_ = [("x", X), ("y", X)]
-
-        y = Y()
-        self.assertEqual(y._objects, None)
-
-        x1, x2 = X(), X()
-        y.x, y.y = x1, x2
-        self.assertEqual(y._objects, {"0": {}, "1": {}})
-        x1.a, x2.b = 42, 93
-        self.assertEqual(y._objects, {"0": {}, "1": {}})
-
-    def test_xxx(self):
-        class X(Structure):
-            _fields_ = [("a", c_char_p), ("b", c_char_p)]
-
-        class Y(Structure):
-            _fields_ = [("x", X), ("y", X)]
-
-        s1 = b"Hello, World"
-        s2 = b"Hallo, Welt"
-
-        x = X()
-        x.a = s1
-        x.b = s2
-        self.assertEqual(x._objects, {"0": s1, "1": s2})
-
-        y = Y()
-        y.x = x
-        self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}})
-##        x = y.x
-##        del y
-##        print x._b_base_._objects
-
-    def test_ptr_struct(self):
-        class X(Structure):
-            _fields_ = [("data", POINTER(c_int))]
-
-        A = c_int*4
-        a = A(11, 22, 33, 44)
-        self.assertEqual(a._objects, None)
-
-        x = X()
-        x.data = a
-##XXX        print x._objects
-##XXX        print x.data[0]
-##XXX        print x.data._objects
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_keeprefs.py b/Lib/ctypes/test/test_keeprefs.py
deleted file mode 100644
index 94c02573fa1..00000000000
--- a/Lib/ctypes/test/test_keeprefs.py
+++ /dev/null
@@ -1,153 +0,0 @@
-from ctypes import *
-import unittest
-
-class SimpleTestCase(unittest.TestCase):
-    def test_cint(self):
-        x = c_int()
-        self.assertEqual(x._objects, None)
-        x.value = 42
-        self.assertEqual(x._objects, None)
-        x = c_int(99)
-        self.assertEqual(x._objects, None)
-
-    def test_ccharp(self):
-        x = c_char_p()
-        self.assertEqual(x._objects, None)
-        x.value = b"abc"
-        self.assertEqual(x._objects, b"abc")
-        x = c_char_p(b"spam")
-        self.assertEqual(x._objects, b"spam")
-
-class StructureTestCase(unittest.TestCase):
-    def test_cint_struct(self):
-        class X(Structure):
-            _fields_ = [("a", c_int),
-                        ("b", c_int)]
-
-        x = X()
-        self.assertEqual(x._objects, None)
-        x.a = 42
-        x.b = 99
-        self.assertEqual(x._objects, None)
-
-    def test_ccharp_struct(self):
-        class X(Structure):
-            _fields_ = [("a", c_char_p),
-                        ("b", c_char_p)]
-        x = X()
-        self.assertEqual(x._objects, None)
-
-        x.a = b"spam"
-        x.b = b"foo"
-        self.assertEqual(x._objects, {"0": b"spam", "1": b"foo"})
-
-    def test_struct_struct(self):
-        class POINT(Structure):
-            _fields_ = [("x", c_int), ("y", c_int)]
-        class RECT(Structure):
-            _fields_ = [("ul", POINT), ("lr", POINT)]
-
-        r = RECT()
-        r.ul.x = 0
-        r.ul.y = 1
-        r.lr.x = 2
-        r.lr.y = 3
-        self.assertEqual(r._objects, None)
-
-        r = RECT()
-        pt = POINT(1, 2)
-        r.ul = pt
-        self.assertEqual(r._objects, {'0': {}})
-        r.ul.x = 22
-        r.ul.y = 44
-        self.assertEqual(r._objects, {'0': {}})
-        r.lr = POINT()
-        self.assertEqual(r._objects, {'0': {}, '1': {}})
-
-class ArrayTestCase(unittest.TestCase):
-    def test_cint_array(self):
-        INTARR = c_int * 3
-
-        ia = INTARR()
-        self.assertEqual(ia._objects, None)
-        ia[0] = 1
-        ia[1] = 2
-        ia[2] = 3
-        self.assertEqual(ia._objects, None)
-
-        class X(Structure):
-            _fields_ = [("x", c_int),
-                        ("a", INTARR)]
-
-        x = X()
-        x.x = 1000
-        x.a[0] = 42
-        x.a[1] = 96
-        self.assertEqual(x._objects, None)
-        x.a = ia
-        self.assertEqual(x._objects, {'1': {}})
-
-class PointerTestCase(unittest.TestCase):
-    def test_p_cint(self):
-        i = c_int(42)
-        x = pointer(i)
-        self.assertEqual(x._objects, {'1': i})
-
-class DeletePointerTestCase(unittest.TestCase):
-    @unittest.skip('test disabled')
-    def test_X(self):
-        class X(Structure):
-            _fields_ = [("p", POINTER(c_char_p))]
-        x = X()
-        i = c_char_p("abc def")
-        from sys import getrefcount as grc
-        print("2?", grc(i))
-        x.p = pointer(i)
-        print("3?", grc(i))
-        for i in range(320):
-            c_int(99)
-            x.p[0]
-        print(x.p[0])
-##        del x
-##        print "2?", grc(i)
-##        del i
-        import gc
-        gc.collect()
-        for i in range(320):
-            c_int(99)
-            x.p[0]
-        print(x.p[0])
-        print(x.p.contents)
-##        print x._objects
-
-        x.p[0] = "spam spam"
-##        print x.p[0]
-        print("+" * 42)
-        print(x._objects)
-
-class PointerToStructure(unittest.TestCase):
-    def test(self):
-        class POINT(Structure):
-            _fields_ = [("x", c_int), ("y", c_int)]
-        class RECT(Structure):
-            _fields_ = [("a", POINTER(POINT)),
-                        ("b", POINTER(POINT))]
-        r = RECT()
-        p1 = POINT(1, 2)
-
-        r.a = pointer(p1)
-        r.b = pointer(p1)
-##        from pprint import pprint as pp
-##        pp(p1._objects)
-##        pp(r._objects)
-
-        r.a[0].x = 42
-        r.a[0].y = 99
-
-        # to avoid leaking when tests are run several times
-        # clean up the types left in the cache.
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[POINT]
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_libc.py b/Lib/ctypes/test/test_libc.py
deleted file mode 100644
index 56285b5ff81..00000000000
--- a/Lib/ctypes/test/test_libc.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import unittest
-
-from ctypes import *
-import _ctypes_test
-
-lib = CDLL(_ctypes_test.__file__)
-
-def three_way_cmp(x, y):
-    """Return -1 if x < y, 0 if x == y and 1 if x > y"""
-    return (x > y) - (x < y)
-
-class LibTest(unittest.TestCase):
-    def test_sqrt(self):
-        lib.my_sqrt.argtypes = c_double,
-        lib.my_sqrt.restype = c_double
-        self.assertEqual(lib.my_sqrt(4.0), 2.0)
-        import math
-        self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
-
-    def test_qsort(self):
-        comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char))
-        lib.my_qsort.argtypes = c_void_p, c_size_t, c_size_t, comparefunc
-        lib.my_qsort.restype = None
-
-        def sort(a, b):
-            return three_way_cmp(a[0], b[0])
-
-        chars = create_string_buffer(b"spam, spam, and spam")
-        lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
-        self.assertEqual(chars.raw, b"   ,,aaaadmmmnpppsss\x00")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_loading.py b/Lib/ctypes/test/test_loading.py
deleted file mode 100644
index ea892277c4e..00000000000
--- a/Lib/ctypes/test/test_loading.py
+++ /dev/null
@@ -1,182 +0,0 @@
-from ctypes import *
-import os
-import shutil
-import subprocess
-import sys
-import unittest
-import test.support
-from test.support import import_helper
-from test.support import os_helper
-from ctypes.util import find_library
-
-libc_name = None
-
-def setUpModule():
-    global libc_name
-    if os.name == "nt":
-        libc_name = find_library("c")
-    elif sys.platform == "cygwin":
-        libc_name = "cygwin1.dll"
-    else:
-        libc_name = find_library("c")
-
-    if test.support.verbose:
-        print("libc_name is", libc_name)
-
-class LoaderTest(unittest.TestCase):
-
-    unknowndll = "xxrandomnamexx"
-
-    def test_load(self):
-        if libc_name is None:
-            self.skipTest('could not find libc')
-        CDLL(libc_name)
-        CDLL(os.path.basename(libc_name))
-        self.assertRaises(OSError, CDLL, self.unknowndll)
-
-    def test_load_version(self):
-        if libc_name is None:
-            self.skipTest('could not find libc')
-        if os.path.basename(libc_name) != 'libc.so.6':
-            self.skipTest('wrong libc path for test')
-        cdll.LoadLibrary("libc.so.6")
-        # linux uses version, libc 9 should not exist
-        self.assertRaises(OSError, cdll.LoadLibrary, "libc.so.9")
-        self.assertRaises(OSError, cdll.LoadLibrary, self.unknowndll)
-
-    def test_find(self):
-        for name in ("c", "m"):
-            lib = find_library(name)
-            if lib:
-                cdll.LoadLibrary(lib)
-                CDLL(lib)
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_library(self):
-        # CRT is no longer directly loadable. See issue23606 for the
-        # discussion about alternative approaches.
-        #self.assertIsNotNone(libc_name)
-        if test.support.verbose:
-            print(find_library("kernel32"))
-            print(find_library("user32"))
-
-        if os.name == "nt":
-            windll.kernel32.GetModuleHandleW
-            windll["kernel32"].GetModuleHandleW
-            windll.LoadLibrary("kernel32").GetModuleHandleW
-            WinDLL("kernel32").GetModuleHandleW
-            # embedded null character
-            self.assertRaises(ValueError, windll.LoadLibrary, "kernel32\0")
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_ordinal_functions(self):
-        import _ctypes_test
-        dll = WinDLL(_ctypes_test.__file__)
-        # We load the same function both via ordinal and name
-        func_ord = dll[2]
-        func_name = dll.GetString
-        # addressof gets the address where the function pointer is stored
-        a_ord = addressof(func_ord)
-        a_name = addressof(func_name)
-        f_ord_addr = c_void_p.from_address(a_ord).value
-        f_name_addr = c_void_p.from_address(a_name).value
-        self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
-
-        self.assertRaises(AttributeError, dll.__getitem__, 1234)
-
-    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
-    def test_1703286_A(self):
-        from _ctypes import LoadLibrary, FreeLibrary
-        # On winXP 64-bit, advapi32 loads at an address that does
-        # NOT fit into a 32-bit integer.  FreeLibrary must be able
-        # to accept this address.
-
-        # These are tests for https://www.python.org/sf/1703286
-        handle = LoadLibrary("advapi32")
-        FreeLibrary(handle)
-
-    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
-    def test_1703286_B(self):
-        # Since on winXP 64-bit advapi32 loads like described
-        # above, the (arbitrarily selected) CloseEventLog function
-        # also has a high address.  'call_function' should accept
-        # addresses so large.
-        from _ctypes import call_function
-        advapi32 = windll.advapi32
-        # Calling CloseEventLog with a NULL argument should fail,
-        # but the call should not segfault or so.
-        self.assertEqual(0, advapi32.CloseEventLog(None))
-        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
-        windll.kernel32.GetProcAddress.restype = c_void_p
-        proc = windll.kernel32.GetProcAddress(advapi32._handle,
-                                              b"CloseEventLog")
-        self.assertTrue(proc)
-        # This is the real test: call the function via 'call_function'
-        self.assertEqual(0, call_function(proc, (None,)))
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_dll_with_flags(self):
-        _sqlite3 = import_helper.import_module("_sqlite3")
-        src = _sqlite3.__file__
-        if src.lower().endswith("_d.pyd"):
-            ext = "_d.dll"
-        else:
-            ext = ".dll"
-
-        with os_helper.temp_dir() as tmp:
-            # We copy two files and load _sqlite3.dll (formerly .pyd),
-            # which has a dependency on sqlite3.dll. Then we test
-            # loading it in subprocesses to avoid it starting in memory
-            # for each test.
-            target = os.path.join(tmp, "_sqlite3.dll")
-            shutil.copy(src, target)
-            shutil.copy(os.path.join(os.path.dirname(src), "sqlite3" + ext),
-                        os.path.join(tmp, "sqlite3" + ext))
-
-            def should_pass(command):
-                with self.subTest(command):
-                    subprocess.check_output(
-                        [sys.executable, "-c",
-                         "from ctypes import *; import nt;" + command],
-                        cwd=tmp
-                    )
-
-            def should_fail(command):
-                with self.subTest(command):
-                    with self.assertRaises(subprocess.CalledProcessError):
-                        subprocess.check_output(
-                            [sys.executable, "-c",
-                             "from ctypes import *; import nt;" + command],
-                            cwd=tmp, stderr=subprocess.STDOUT,
-                        )
-
-            # Default load should not find this in CWD
-            should_fail("WinDLL('_sqlite3.dll')")
-
-            # Relative path (but not just filename) should succeed
-            should_pass("WinDLL('./_sqlite3.dll')")
-
-            # Insecure load flags should succeed
-            # Clear the DLL directory to avoid safe search settings propagating
-            should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
-
-            # Full path load without DLL_LOAD_DIR shouldn't find dependency
-            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
-                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
-
-            # Full path load with DLL_LOAD_DIR should succeed
-            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
-                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
-                        "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
-
-            # User-specified directory should succeed
-            should_pass("import os; p = os.add_dll_directory(os.getcwd());" +
-                        "WinDLL('_sqlite3.dll'); p.close()")
-
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_macholib.py b/Lib/ctypes/test/test_macholib.py
deleted file mode 100644
index bc75f1a05a8..00000000000
--- a/Lib/ctypes/test/test_macholib.py
+++ /dev/null
@@ -1,110 +0,0 @@
-import os
-import sys
-import unittest
-
-# Bob Ippolito:
-#
-# Ok.. the code to find the filename for __getattr__ should look
-# something like:
-#
-# import os
-# from macholib.dyld import dyld_find
-#
-# def find_lib(name):
-#      possible = ['lib'+name+'.dylib', name+'.dylib',
-#      name+'.framework/'+name]
-#      for dylib in possible:
-#          try:
-#              return os.path.realpath(dyld_find(dylib))
-#          except ValueError:
-#              pass
-#      raise ValueError, "%s not found" % (name,)
-#
-# It'll have output like this:
-#
-#  >>> find_lib('pthread')
-# '/usr/lib/libSystem.B.dylib'
-#  >>> find_lib('z')
-# '/usr/lib/libz.1.dylib'
-#  >>> find_lib('IOKit')
-# '/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit'
-#
-# -bob
-
-from ctypes.macholib.dyld import dyld_find
-from ctypes.macholib.dylib import dylib_info
-from ctypes.macholib.framework import framework_info
-
-def find_lib(name):
-    possible = ['lib'+name+'.dylib', name+'.dylib', name+'.framework/'+name]
-    for dylib in possible:
-        try:
-            return os.path.realpath(dyld_find(dylib))
-        except ValueError:
-            pass
-    raise ValueError("%s not found" % (name,))
-
-
-def d(location=None, name=None, shortname=None, version=None, suffix=None):
-    return {'location': location, 'name': name, 'shortname': shortname,
-            'version': version, 'suffix': suffix}
-
-
-class MachOTest(unittest.TestCase):
-    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
-    def test_find(self):
-        self.assertEqual(dyld_find('libSystem.dylib'),
-                         '/usr/lib/libSystem.dylib')
-        self.assertEqual(dyld_find('System.framework/System'),
-                         '/System/Library/Frameworks/System.framework/System')
-
-        # On Mac OS 11, system dylibs are only present in the shared cache,
-        # so symlinks like libpthread.dylib -> libSystem.B.dylib will not
-        # be resolved by dyld_find
-        self.assertIn(find_lib('pthread'),
-                              ('/usr/lib/libSystem.B.dylib', '/usr/lib/libpthread.dylib'))
-
-        result = find_lib('z')
-        # Issue #21093: dyld default search path includes $HOME/lib and
-        # /usr/local/lib before /usr/lib, which caused test failures if
-        # a local copy of libz exists in one of them. Now ignore the head
-        # of the path.
-        self.assertRegex(result, r".*/lib/libz.*\.dylib")
-
-        self.assertIn(find_lib('IOKit'),
-                              ('/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit',
-                              '/System/Library/Frameworks/IOKit.framework/IOKit'))
-
-    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
-    def test_info(self):
-        self.assertIsNone(dylib_info('completely/invalid'))
-        self.assertIsNone(dylib_info('completely/invalide_debug'))
-        self.assertEqual(dylib_info('P/Foo.dylib'), d('P', 'Foo.dylib', 'Foo'))
-        self.assertEqual(dylib_info('P/Foo_debug.dylib'),
-                         d('P', 'Foo_debug.dylib', 'Foo', suffix='debug'))
-        self.assertEqual(dylib_info('P/Foo.A.dylib'),
-                         d('P', 'Foo.A.dylib', 'Foo', 'A'))
-        self.assertEqual(dylib_info('P/Foo_debug.A.dylib'),
-                         d('P', 'Foo_debug.A.dylib', 'Foo_debug', 'A'))
-        self.assertEqual(dylib_info('P/Foo.A_debug.dylib'),
-                         d('P', 'Foo.A_debug.dylib', 'Foo', 'A', 'debug'))
-
-    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
-    def test_framework_info(self):
-        self.assertIsNone(framework_info('completely/invalid'))
-        self.assertIsNone(framework_info('completely/invalid/_debug'))
-        self.assertIsNone(framework_info('P/F.framework'))
-        self.assertIsNone(framework_info('P/F.framework/_debug'))
-        self.assertEqual(framework_info('P/F.framework/F'),
-                         d('P', 'F.framework/F', 'F'))
-        self.assertEqual(framework_info('P/F.framework/F_debug'),
-                         d('P', 'F.framework/F_debug', 'F', suffix='debug'))
-        self.assertIsNone(framework_info('P/F.framework/Versions'))
-        self.assertIsNone(framework_info('P/F.framework/Versions/A'))
-        self.assertEqual(framework_info('P/F.framework/Versions/A/F'),
-                         d('P', 'F.framework/Versions/A/F', 'F', 'A'))
-        self.assertEqual(framework_info('P/F.framework/Versions/A/F_debug'),
-                         d('P', 'F.framework/Versions/A/F_debug', 'F', 'A', 'debug'))
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_memfunctions.py b/Lib/ctypes/test/test_memfunctions.py
deleted file mode 100644
index e784b9a7068..00000000000
--- a/Lib/ctypes/test/test_memfunctions.py
+++ /dev/null
@@ -1,79 +0,0 @@
-import sys
-from test import support
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-
-class MemFunctionsTest(unittest.TestCase):
-    @unittest.skip('test disabled')
-    def test_overflow(self):
-        # string_at and wstring_at must use the Python calling
-        # convention (which acquires the GIL and checks the Python
-        # error flag).  Provoke an error and catch it; see also issue
-        # #3554: <http://bugs.python.org/issue3554>
-        self.assertRaises((OverflowError, MemoryError, SystemError),
-                          lambda: wstring_at(u"foo", sys.maxint - 1))
-        self.assertRaises((OverflowError, MemoryError, SystemError),
-                          lambda: string_at("foo", sys.maxint - 1))
-
-    def test_memmove(self):
-        # large buffers apparently increase the chance that the memory
-        # is allocated in high address space.
-        a = create_string_buffer(1000000)
-        p = b"Hello, World"
-        result = memmove(a, p, len(p))
-        self.assertEqual(a.value, b"Hello, World")
-
-        self.assertEqual(string_at(result), b"Hello, World")
-        self.assertEqual(string_at(result, 5), b"Hello")
-        self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
-        self.assertEqual(string_at(result, 0), b"")
-
-    def test_memset(self):
-        a = create_string_buffer(1000000)
-        result = memset(a, ord('x'), 16)
-        self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx")
-
-        self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
-        self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
-        self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
-
-    def test_cast(self):
-        a = (c_ubyte * 32)(*map(ord, "abcdef"))
-        self.assertEqual(cast(a, c_char_p).value, b"abcdef")
-        self.assertEqual(cast(a, POINTER(c_byte))[:7],
-                             [97, 98, 99, 100, 101, 102, 0])
-        self.assertEqual(cast(a, POINTER(c_byte))[:7:],
-                             [97, 98, 99, 100, 101, 102, 0])
-        self.assertEqual(cast(a, POINTER(c_byte))[6:-1:-1],
-                             [0, 102, 101, 100, 99, 98, 97])
-        self.assertEqual(cast(a, POINTER(c_byte))[:7:2],
-                             [97, 99, 101, 0])
-        self.assertEqual(cast(a, POINTER(c_byte))[:7:7],
-                             [97])
-
-    @support.refcount_test
-    def test_string_at(self):
-        s = string_at(b"foo bar")
-        # XXX The following may be wrong, depending on how Python
-        # manages string instances
-        self.assertEqual(2, sys.getrefcount(s))
-        self.assertTrue(s, "foo bar")
-
-        self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
-        self.assertEqual(string_at(b"foo bar", 3), b"foo")
-
-    @need_symbol('create_unicode_buffer')
-    def test_wstring_at(self):
-        p = create_unicode_buffer("Hello, World")
-        a = create_unicode_buffer(1000000)
-        result = memmove(a, p, len(p) * sizeof(c_wchar))
-        self.assertEqual(a.value, "Hello, World")
-
-        self.assertEqual(wstring_at(a), "Hello, World")
-        self.assertEqual(wstring_at(a, 5), "Hello")
-        self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
-        self.assertEqual(wstring_at(a, 0), "")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_numbers.py b/Lib/ctypes/test/test_numbers.py
deleted file mode 100644
index a5c661b0e97..00000000000
--- a/Lib/ctypes/test/test_numbers.py
+++ /dev/null
@@ -1,218 +0,0 @@
-from ctypes import *
-import unittest
-import struct
-
-def valid_ranges(*types):
-    # given a sequence of numeric types, collect their _type_
-    # attribute, which is a single format character compatible with
-    # the struct module, use the struct module to calculate the
-    # minimum and maximum value allowed for this format.
-    # Returns a list of (min, max) values.
-    result = []
-    for t in types:
-        fmt = t._type_
-        size = struct.calcsize(fmt)
-        a = struct.unpack(fmt, (b"\x00"*32)[:size])[0]
-        b = struct.unpack(fmt, (b"\xFF"*32)[:size])[0]
-        c = struct.unpack(fmt, (b"\x7F"+b"\x00"*32)[:size])[0]
-        d = struct.unpack(fmt, (b"\x80"+b"\xFF"*32)[:size])[0]
-        result.append((min(a, b, c, d), max(a, b, c, d)))
-    return result
-
-ArgType = type(byref(c_int(0)))
-
-unsigned_types = [c_ubyte, c_ushort, c_uint, c_ulong]
-signed_types = [c_byte, c_short, c_int, c_long, c_longlong]
-
-bool_types = []
-
-float_types = [c_double, c_float]
-
-try:
-    c_ulonglong
-    c_longlong
-except NameError:
-    pass
-else:
-    unsigned_types.append(c_ulonglong)
-    signed_types.append(c_longlong)
-
-try:
-    c_bool
-except NameError:
-    pass
-else:
-    bool_types.append(c_bool)
-
-unsigned_ranges = valid_ranges(*unsigned_types)
-signed_ranges = valid_ranges(*signed_types)
-bool_values = [True, False, 0, 1, -1, 5000, 'test', [], [1]]
-
-################################################################
-
-class NumberTestCase(unittest.TestCase):
-
-    def test_default_init(self):
-        # default values are set to zero
-        for t in signed_types + unsigned_types + float_types:
-            self.assertEqual(t().value, 0)
-
-    def test_unsigned_values(self):
-        # the value given to the constructor is available
-        # as the 'value' attribute
-        for t, (l, h) in zip(unsigned_types, unsigned_ranges):
-            self.assertEqual(t(l).value, l)
-            self.assertEqual(t(h).value, h)
-
-    def test_signed_values(self):
-        # see above
-        for t, (l, h) in zip(signed_types, signed_ranges):
-            self.assertEqual(t(l).value, l)
-            self.assertEqual(t(h).value, h)
-
-    def test_bool_values(self):
-        from operator import truth
-        for t, v in zip(bool_types, bool_values):
-            self.assertEqual(t(v).value, truth(v))
-
-    def test_typeerror(self):
-        # Only numbers are allowed in the constructor,
-        # otherwise TypeError is raised
-        for t in signed_types + unsigned_types + float_types:
-            self.assertRaises(TypeError, t, "")
-            self.assertRaises(TypeError, t, None)
-
-    def test_from_param(self):
-        # the from_param class method attribute always
-        # returns PyCArgObject instances
-        for t in signed_types + unsigned_types + float_types:
-            self.assertEqual(ArgType, type(t.from_param(0)))
-
-    def test_byref(self):
-        # calling byref returns also a PyCArgObject instance
-        for t in signed_types + unsigned_types + float_types + bool_types:
-            parm = byref(t())
-            self.assertEqual(ArgType, type(parm))
-
-
-    def test_floats(self):
-        # c_float and c_double can be created from
-        # Python int and float
-        class FloatLike:
-            def __float__(self):
-                return 2.0
-        f = FloatLike()
-        for t in float_types:
-            self.assertEqual(t(2.0).value, 2.0)
-            self.assertEqual(t(2).value, 2.0)
-            self.assertEqual(t(2).value, 2.0)
-            self.assertEqual(t(f).value, 2.0)
-
-    def test_integers(self):
-        class FloatLike:
-            def __float__(self):
-                return 2.0
-        f = FloatLike()
-        class IntLike:
-            def __int__(self):
-                return 2
-        d = IntLike()
-        class IndexLike:
-            def __index__(self):
-                return 2
-        i = IndexLike()
-        # integers cannot be constructed from floats,
-        # but from integer-like objects
-        for t in signed_types + unsigned_types:
-            self.assertRaises(TypeError, t, 3.14)
-            self.assertRaises(TypeError, t, f)
-            self.assertRaises(TypeError, t, d)
-            self.assertEqual(t(i).value, 2)
-
-    def test_sizes(self):
-        for t in signed_types + unsigned_types + float_types + bool_types:
-            try:
-                size = struct.calcsize(t._type_)
-            except struct.error:
-                continue
-            # sizeof of the type...
-            self.assertEqual(sizeof(t), size)
-            # and sizeof of an instance
-            self.assertEqual(sizeof(t()), size)
-
-    def test_alignments(self):
-        for t in signed_types + unsigned_types + float_types:
-            code = t._type_ # the typecode
-            align = struct.calcsize("c%c" % code) - struct.calcsize(code)
-
-            # alignment of the type...
-            self.assertEqual((code, alignment(t)),
-                             (code, align))
-            # and alignment of an instance
-            self.assertEqual((code, alignment(t())),
-                             (code, align))
-
-    def test_int_from_address(self):
-        from array import array
-        for t in signed_types + unsigned_types:
-            # the array module doesn't support all format codes
-            # (no 'q' or 'Q')
-            try:
-                array(t._type_)
-            except ValueError:
-                continue
-            a = array(t._type_, [100])
-
-            # v now is an integer at an 'external' memory location
-            v = t.from_address(a.buffer_info()[0])
-            self.assertEqual(v.value, a[0])
-            self.assertEqual(type(v), t)
-
-            # changing the value at the memory location changes v's value also
-            a[0] = 42
-            self.assertEqual(v.value, a[0])
-
-
-    def test_float_from_address(self):
-        from array import array
-        for t in float_types:
-            a = array(t._type_, [3.14])
-            v = t.from_address(a.buffer_info()[0])
-            self.assertEqual(v.value, a[0])
-            self.assertIs(type(v), t)
-            a[0] = 2.3456e17
-            self.assertEqual(v.value, a[0])
-            self.assertIs(type(v), t)
-
-    def test_char_from_address(self):
-        from ctypes import c_char
-        from array import array
-
-        a = array('b', [0])
-        a[0] = ord('x')
-        v = c_char.from_address(a.buffer_info()[0])
-        self.assertEqual(v.value, b'x')
-        self.assertIs(type(v), c_char)
-
-        a[0] = ord('?')
-        self.assertEqual(v.value, b'?')
-
-    def test_init(self):
-        # c_int() can be initialized from Python's int, and c_int.
-        # Not from c_long or so, which seems strange, abc should
-        # probably be changed:
-        self.assertRaises(TypeError, c_int, c_long(42))
-
-    def test_float_overflow(self):
-        import sys
-        big_int = int(sys.float_info.max) * 2
-        for t in float_types + [c_longdouble]:
-            self.assertRaises(OverflowError, t, big_int)
-            if (hasattr(t, "__ctype_be__")):
-                self.assertRaises(OverflowError, t.__ctype_be__, big_int)
-            if (hasattr(t, "__ctype_le__")):
-                self.assertRaises(OverflowError, t.__ctype_le__, big_int)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_objects.py b/Lib/ctypes/test/test_objects.py
deleted file mode 100644
index 19e3dc1f2d7..00000000000
--- a/Lib/ctypes/test/test_objects.py
+++ /dev/null
@@ -1,67 +0,0 @@
-r'''
-This tests the '_objects' attribute of ctypes instances.  '_objects'
-holds references to objects that must be kept alive as long as the
-ctypes instance, to make sure that the memory buffer is valid.
-
-WARNING: The '_objects' attribute is exposed ONLY for debugging ctypes itself,
-it MUST NEVER BE MODIFIED!
-
-'_objects' is initialized to a dictionary on first use, before that it
-is None.
-
-Here is an array of string pointers:
-
->>> from ctypes import *
->>> array = (c_char_p * 5)()
->>> print(array._objects)
-None
->>>
-
-The memory block stores pointers to strings, and the strings itself
-assigned from Python must be kept.
-
->>> array[4] = b'foo bar'
->>> array._objects
-{'4': b'foo bar'}
->>> array[4]
-b'foo bar'
->>>
-
-It gets more complicated when the ctypes instance itself is contained
-in a 'base' object.
-
->>> class X(Structure):
-...     _fields_ = [("x", c_int), ("y", c_int), ("array", c_char_p * 5)]
-...
->>> x = X()
->>> print(x._objects)
-None
->>>
-
-The'array' attribute of the 'x' object shares part of the memory buffer
-of 'x' ('_b_base_' is either None, or the root object owning the memory block):
-
->>> print(x.array._b_base_) # doctest: +ELLIPSIS
-<ctypes.test.test_objects.X object at 0x...>
->>>
-
->>> x.array[0] = b'spam spam spam'
->>> x._objects
-{'0:2': b'spam spam spam'}
->>> x.array._b_base_._objects
-{'0:2': b'spam spam spam'}
->>>
-
-'''
-
-import unittest, doctest
-
-import ctypes.test.test_objects
-
-class TestCase(unittest.TestCase):
-    def test(self):
-        failures, tests = doctest.testmod(ctypes.test.test_objects)
-        self.assertFalse(failures, 'doctests failed, see output above')
-
-if __name__ == '__main__':
-    doctest.testmod(ctypes.test.test_objects)
diff --git a/Lib/ctypes/test/test_parameters.py b/Lib/ctypes/test/test_parameters.py
deleted file mode 100644
index 38af7ac13d7..00000000000
--- a/Lib/ctypes/test/test_parameters.py
+++ /dev/null
@@ -1,250 +0,0 @@
-import unittest
-from ctypes.test import need_symbol
-import test.support
-
-class SimpleTypesTestCase(unittest.TestCase):
-
-    def setUp(self):
-        import ctypes
-        try:
-            from _ctypes import set_conversion_mode
-        except ImportError:
-            pass
-        else:
-            self.prev_conv_mode = set_conversion_mode("ascii", "strict")
-
-    def tearDown(self):
-        try:
-            from _ctypes import set_conversion_mode
-        except ImportError:
-            pass
-        else:
-            set_conversion_mode(*self.prev_conv_mode)
-
-    def test_subclasses(self):
-        from ctypes import c_void_p, c_char_p
-        # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new
-        class CVOIDP(c_void_p):
-            def from_param(cls, value):
-                return value * 2
-            from_param = classmethod(from_param)
-
-        class CCHARP(c_char_p):
-            def from_param(cls, value):
-                return value * 4
-            from_param = classmethod(from_param)
-
-        self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
-        self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
-
-    @need_symbol('c_wchar_p')
-    def test_subclasses_c_wchar_p(self):
-        from ctypes import c_wchar_p
-
-        class CWCHARP(c_wchar_p):
-            def from_param(cls, value):
-                return value * 3
-            from_param = classmethod(from_param)
-
-        self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
-
-    # XXX Replace by c_char_p tests
-    def test_cstrings(self):
-        from ctypes import c_char_p
-
-        # c_char_p.from_param on a Python String packs the string
-        # into a cparam object
-        s = b"123"
-        self.assertIs(c_char_p.from_param(s)._obj, s)
-
-        # new in 0.9.1: convert (encode) unicode to ascii
-        self.assertEqual(c_char_p.from_param(b"123")._obj, b"123")
-        self.assertRaises(TypeError, c_char_p.from_param, "123\377")
-        self.assertRaises(TypeError, c_char_p.from_param, 42)
-
-        # calling c_char_p.from_param with a c_char_p instance
-        # returns the argument itself:
-        a = c_char_p(b"123")
-        self.assertIs(c_char_p.from_param(a), a)
-
-    @need_symbol('c_wchar_p')
-    def test_cw_strings(self):
-        from ctypes import c_wchar_p
-
-        c_wchar_p.from_param("123")
-
-        self.assertRaises(TypeError, c_wchar_p.from_param, 42)
-        self.assertRaises(TypeError, c_wchar_p.from_param, b"123\377")
-
-        pa = c_wchar_p.from_param(c_wchar_p("123"))
-        self.assertEqual(type(pa), c_wchar_p)
-
-    def test_int_pointers(self):
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer
-        LPINT = POINTER(c_int)
-
-##        p = pointer(c_int(42))
-##        x = LPINT.from_param(p)
-        x = LPINT.from_param(pointer(c_int(42)))
-        self.assertEqual(x.contents.value, 42)
-        self.assertEqual(LPINT(c_int(42)).contents.value, 42)
-
-        self.assertEqual(LPINT.from_param(None), None)
-
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
-        self.assertRaises(TypeError, LPINT.from_param, pointer(c_uint(42)))
-        self.assertRaises(TypeError, LPINT.from_param, pointer(c_short(42)))
-
-    def test_byref_pointer(self):
-        # The from_param class method of POINTER(typ) classes accepts what is
-        # returned by byref(obj), it type(obj) == typ
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER, byref
-        LPINT = POINTER(c_int)
-
-        LPINT.from_param(byref(c_int(42)))
-
-        self.assertRaises(TypeError, LPINT.from_param, byref(c_short(22)))
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPINT.from_param, byref(c_long(22)))
-        self.assertRaises(TypeError, LPINT.from_param, byref(c_uint(22)))
-
-    def test_byref_pointerpointer(self):
-        # See above
-        from ctypes import c_short, c_uint, c_int, c_long, pointer, POINTER, byref
-
-        LPLPINT = POINTER(POINTER(c_int))
-        LPLPINT.from_param(byref(pointer(c_int(42))))
-
-        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_short(22))))
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_long(22))))
-        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_uint(22))))
-
-    def test_array_pointers(self):
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER
-        INTARRAY = c_int * 3
-        ia = INTARRAY()
-        self.assertEqual(len(ia), 3)
-        self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
-
-        # Pointers are only compatible with arrays containing items of
-        # the same type!
-        LPINT = POINTER(c_int)
-        LPINT.from_param((c_int*3)())
-        self.assertRaises(TypeError, LPINT.from_param, c_short*3)
-        self.assertRaises(TypeError, LPINT.from_param, c_long*3)
-        self.assertRaises(TypeError, LPINT.from_param, c_uint*3)
-
-    def test_noctypes_argtype(self):
-        import _ctypes_test
-        from ctypes import CDLL, c_void_p, ArgumentError
-
-        func = CDLL(_ctypes_test.__file__)._testfunc_p_p
-        func.restype = c_void_p
-        # TypeError: has no from_param method
-        self.assertRaises(TypeError, setattr, func, "argtypes", (object,))
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                return None
-
-        func.argtypes = (Adapter(),)
-        self.assertEqual(func(None), None)
-        self.assertEqual(func(object()), None)
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                return obj
-
-        func.argtypes = (Adapter(),)
-        # don't know how to convert parameter 1
-        self.assertRaises(ArgumentError, func, object())
-        self.assertEqual(func(c_void_p(42)), 42)
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                raise ValueError(obj)
-
-        func.argtypes = (Adapter(),)
-        # ArgumentError: argument 1: ValueError: 99
-        self.assertRaises(ArgumentError, func, 99)
-
-    def test_abstract(self):
-        from ctypes import (Array, Structure, Union, _Pointer,
-                            _SimpleCData, _CFuncPtr)
-
-        self.assertRaises(TypeError, Array.from_param, 42)
-        self.assertRaises(TypeError, Structure.from_param, 42)
-        self.assertRaises(TypeError, Union.from_param, 42)
-        self.assertRaises(TypeError, _CFuncPtr.from_param, 42)
-        self.assertRaises(TypeError, _Pointer.from_param, 42)
-        self.assertRaises(TypeError, _SimpleCData.from_param, 42)
-
-    @test.support.cpython_only
-    def test_issue31311(self):
-        # __setstate__ should neither raise a SystemError nor crash in case
-        # of a bad __dict__.
-        from ctypes import Structure
-
-        class BadStruct(Structure):
-            @property
-            def __dict__(self):
-                pass
-        with self.assertRaises(TypeError):
-            BadStruct().__setstate__({}, b'foo')
-
-        class WorseStruct(Structure):
-            @property
-            def __dict__(self):
-                1/0
-        with self.assertRaises(ZeroDivisionError):
-            WorseStruct().__setstate__({}, b'foo')
-
-    def test_parameter_repr(self):
-        from ctypes import (
-            c_bool,
-            c_char,
-            c_wchar,
-            c_byte,
-            c_ubyte,
-            c_short,
-            c_ushort,
-            c_int,
-            c_uint,
-            c_long,
-            c_ulong,
-            c_longlong,
-            c_ulonglong,
-            c_float,
-            c_double,
-            c_longdouble,
-            c_char_p,
-            c_wchar_p,
-            c_void_p,
-        )
-        self.assertRegex(repr(c_bool.from_param(True)), r"^<cparam '\?' at 0x[A-Fa-f0-9]+>$")
-        self.assertEqual(repr(c_char.from_param(97)), "<cparam 'c' ('a')>")
-        self.assertRegex(repr(c_wchar.from_param('a')), r"^<cparam 'u' at 0x[A-Fa-f0-9]+>$")
-        self.assertEqual(repr(c_byte.from_param(98)), "<cparam 'b' (98)>")
-        self.assertEqual(repr(c_ubyte.from_param(98)), "<cparam 'B' (98)>")
-        self.assertEqual(repr(c_short.from_param(511)), "<cparam 'h' (511)>")
-        self.assertEqual(repr(c_ushort.from_param(511)), "<cparam 'H' (511)>")
-        self.assertRegex(repr(c_int.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
-        self.assertRegex(repr(c_uint.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
-        self.assertRegex(repr(c_long.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
-        self.assertRegex(repr(c_ulong.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
-        self.assertRegex(repr(c_longlong.from_param(20000)), r"^<cparam '[liq]' \(20000\)>$")
-        self.assertRegex(repr(c_ulonglong.from_param(20000)), r"^<cparam '[LIQ]' \(20000\)>$")
-        self.assertEqual(repr(c_float.from_param(1.5)), "<cparam 'f' (1.5)>")
-        self.assertEqual(repr(c_double.from_param(1.5)), "<cparam 'd' (1.5)>")
-        self.assertEqual(repr(c_double.from_param(1e300)), "<cparam 'd' (1e+300)>")
-        self.assertRegex(repr(c_longdouble.from_param(1.5)), r"^<cparam ('d' \(1.5\)|'g' at 0x[A-Fa-f0-9]+)>$")
-        self.assertRegex(repr(c_char_p.from_param(b'hihi')), r"^<cparam 'z' \(0x[A-Fa-f0-9]+\)>$")
-        self.assertRegex(repr(c_wchar_p.from_param('hihi')), r"^<cparam 'Z' \(0x[A-Fa-f0-9]+\)>$")
-        self.assertRegex(repr(c_void_p.from_param(0x12)), r"^<cparam 'P' \(0x0*12\)>$")
-
-################################################################
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_pep3118.py b/Lib/ctypes/test/test_pep3118.py
deleted file mode 100644
index efffc80a66f..00000000000
--- a/Lib/ctypes/test/test_pep3118.py
+++ /dev/null
@@ -1,235 +0,0 @@
-import unittest
-from ctypes import *
-import re, sys
-
-if sys.byteorder == "little":
-    THIS_ENDIAN = "<"
-    OTHER_ENDIAN = ">"
-else:
-    THIS_ENDIAN = ">"
-    OTHER_ENDIAN = "<"
-
-def normalize(format):
-    # Remove current endian specifier and white space from a format
-    # string
-    if format is None:
-        return ""
-    format = format.replace(OTHER_ENDIAN, THIS_ENDIAN)
-    return re.sub(r"\s", "", format)
-
-class Test(unittest.TestCase):
-
-    def test_native_types(self):
-        for tp, fmt, shape, itemtp in native_types:
-            ob = tp()
-            v = memoryview(ob)
-            try:
-                self.assertEqual(normalize(v.format), normalize(fmt))
-                if shape:
-                    self.assertEqual(len(v), shape[0])
-                else:
-                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
-                self.assertEqual(v.itemsize, sizeof(itemtp))
-                self.assertEqual(v.shape, shape)
-                # XXX Issue #12851: PyCData_NewGetBuffer() must provide strides
-                #     if requested. memoryview currently reconstructs missing
-                #     stride information, so this assert will fail.
-                # self.assertEqual(v.strides, ())
-
-                # they are always read/write
-                self.assertFalse(v.readonly)
-
-                if v.shape:
-                    n = 1
-                    for dim in v.shape:
-                        n = n * dim
-                    self.assertEqual(n * v.itemsize, len(v.tobytes()))
-            except:
-                # so that we can see the failing type
-                print(tp)
-                raise
-
-    def test_endian_types(self):
-        for tp, fmt, shape, itemtp in endian_types:
-            ob = tp()
-            v = memoryview(ob)
-            try:
-                self.assertEqual(v.format, fmt)
-                if shape:
-                    self.assertEqual(len(v), shape[0])
-                else:
-                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
-                self.assertEqual(v.itemsize, sizeof(itemtp))
-                self.assertEqual(v.shape, shape)
-                # XXX Issue #12851
-                # self.assertEqual(v.strides, ())
-
-                # they are always read/write
-                self.assertFalse(v.readonly)
-
-                if v.shape:
-                    n = 1
-                    for dim in v.shape:
-                        n = n * dim
-                    self.assertEqual(n, len(v))
-            except:
-                # so that we can see the failing type
-                print(tp)
-                raise
-
-# define some structure classes
-
-class Point(Structure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class PackedPoint(Structure):
-    _pack_ = 2
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class Point2(Structure):
-    pass
-Point2._fields_ = [("x", c_long), ("y", c_long)]
-
-class EmptyStruct(Structure):
-    _fields_ = []
-
-class aUnion(Union):
-    _fields_ = [("a", c_int)]
-
-class StructWithArrays(Structure):
-    _fields_ = [("x", c_long * 3 * 2), ("y", Point * 4)]
-
-class Incomplete(Structure):
-    pass
-
-class Complete(Structure):
-    pass
-PComplete = POINTER(Complete)
-Complete._fields_ = [("a", c_long)]
-
-################################################################
-#
-# This table contains format strings as they look on little endian
-# machines.  The test replaces '<' with '>' on big endian machines.
-#
-
-# Platform-specific type codes
-s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
-s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
-s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
-s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
-s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
-s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
-s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
-s_longlong = "q"
-s_ulonglong = "Q"
-s_float = "f"
-s_double = "d"
-s_longdouble = "g"
-
-# Alias definitions in ctypes/__init__.py
-if c_int is c_long:
-    s_int = s_long
-if c_uint is c_ulong:
-    s_uint = s_ulong
-if c_longlong is c_long:
-    s_longlong = s_long
-if c_ulonglong is c_ulong:
-    s_ulonglong = s_ulong
-if c_longdouble is c_double:
-    s_longdouble = s_double
-
-
-native_types = [
-    # type                      format                  shape           calc itemsize
-
-    ## simple types
-
-    (c_char,                    "<c",                   (),           c_char),
-    (c_byte,                    "<b",                   (),           c_byte),
-    (c_ubyte,                   "<B",                   (),           c_ubyte),
-    (c_short,                   "<" + s_short,          (),           c_short),
-    (c_ushort,                  "<" + s_ushort,         (),           c_ushort),
-
-    (c_int,                     "<" + s_int,            (),           c_int),
-    (c_uint,                    "<" + s_uint,           (),           c_uint),
-
-    (c_long,                    "<" + s_long,           (),           c_long),
-    (c_ulong,                   "<" + s_ulong,          (),           c_ulong),
-
-    (c_longlong,                "<" + s_longlong,       (),           c_longlong),
-    (c_ulonglong,               "<" + s_ulonglong,      (),           c_ulonglong),
-
-    (c_float,                   "<f",                   (),           c_float),
-    (c_double,                  "<d",                   (),           c_double),
-
-    (c_longdouble,              "<" + s_longdouble,     (),           c_longdouble),
-
-    (c_bool,                    "<" + s_bool,           (),           c_bool),
-    (py_object,                 "<O",                   (),           py_object),
-
-    ## pointers
-
-    (POINTER(c_byte),           "&<b",                  (),           POINTER(c_byte)),
-    (POINTER(POINTER(c_long)),  "&&<" + s_long,         (),           POINTER(POINTER(c_long))),
-
-    ## arrays and pointers
-
-    (c_double * 4,              "<d",                   (4,),           c_double),
-    (c_double * 0,              "<d",                   (0,),           c_double),
-    (c_float * 4 * 3 * 2,       "<f",                   (2,3,4),        c_float),
-    (c_float * 4 * 0 * 2,       "<f",                   (2,0,4),        c_float),
-    (POINTER(c_short) * 2,      "&<" + s_short,         (2,),           POINTER(c_short)),
-    (POINTER(c_short) * 2 * 3,  "&<" + s_short,         (3,2,),         POINTER(c_short)),
-    (POINTER(c_short * 2),      "&(2)<" + s_short,      (),             POINTER(c_short)),
-
-    ## structures and unions
-
-    (Point,                     "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point),
-    # packed structures do not implement the pep
-    (PackedPoint,               "B",                                   (),  PackedPoint),
-    (Point2,                    "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point2),
-    (EmptyStruct,               "T{}",                                 (),  EmptyStruct),
-    # the pep doesn't support unions
-    (aUnion,                    "B",                                   (),  aUnion),
-    # structure with sub-arrays
-    (StructWithArrays, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (), StructWithArrays),
-    (StructWithArrays * 3, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (3,), StructWithArrays),
-
-    ## pointer to incomplete structure
-    (Incomplete,                "B",                    (),           Incomplete),
-    (POINTER(Incomplete),       "&B",                   (),           POINTER(Incomplete)),
-
-    # 'Complete' is a structure that starts incomplete, but is completed after the
-    # pointer type to it has been created.
-    (Complete,                  "T{<l:a:}".replace('l', s_long), (), Complete),
-    # Unfortunately the pointer format string is not fixed...
-    (POINTER(Complete),         "&B",                   (),           POINTER(Complete)),
-
-    ## other
-
-    # function signatures are not implemented
-    (CFUNCTYPE(None),           "X{}",                  (),           CFUNCTYPE(None)),
-
-    ]
-
-class BEPoint(BigEndianStructure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class LEPoint(LittleEndianStructure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-################################################################
-#
-# This table contains format strings as they really look, on both big
-# and little endian machines.
-#
-endian_types = [
-    (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
-    (LEPoint, "T{<l:x:<l:y:}".replace('l', s_long), (), LEPoint),
-    (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
-    (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
-    ]
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_pickling.py b/Lib/ctypes/test/test_pickling.py
deleted file mode 100644
index c4a79b97793..00000000000
--- a/Lib/ctypes/test/test_pickling.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import unittest
-import pickle
-from ctypes import *
-import _ctypes_test
-dll = CDLL(_ctypes_test.__file__)
-
-class X(Structure):
-    _fields_ = [("a", c_int), ("b", c_double)]
-    init_called = 0
-    def __init__(self, *args, **kw):
-        X.init_called += 1
-        self.x = 42
-
-class Y(X):
-    _fields_ = [("str", c_char_p)]
-
-class PickleTest:
-    def dumps(self, item):
-        return pickle.dumps(item, self.proto)
-
-    def loads(self, item):
-        return pickle.loads(item)
-
-    def test_simple(self):
-        for src in [
-            c_int(42),
-            c_double(3.14),
-            ]:
-            dst = self.loads(self.dumps(src))
-            self.assertEqual(src.__dict__, dst.__dict__)
-            self.assertEqual(memoryview(src).tobytes(),
-                                 memoryview(dst).tobytes())
-
-    def test_struct(self):
-        X.init_called = 0
-
-        x = X()
-        x.a = 42
-        self.assertEqual(X.init_called, 1)
-
-        y = self.loads(self.dumps(x))
-
-        # loads must NOT call __init__
-        self.assertEqual(X.init_called, 1)
-
-        # ctypes instances are identical when the instance __dict__
-        # and the memory buffer are identical
-        self.assertEqual(y.__dict__, x.__dict__)
-        self.assertEqual(memoryview(y).tobytes(),
-                             memoryview(x).tobytes())
-
-    def test_unpickable(self):
-        # ctypes objects that are pointers or contain pointers are
-        # unpickable.
-        self.assertRaises(ValueError, lambda: self.dumps(Y()))
-
-        prototype = CFUNCTYPE(c_int)
-
-        for item in [
-            c_char_p(),
-            c_wchar_p(),
-            c_void_p(),
-            pointer(c_int(42)),
-            dll._testfunc_p_p,
-            prototype(lambda: 42),
-            ]:
-            self.assertRaises(ValueError, lambda: self.dumps(item))
-
-    def test_wchar(self):
-        self.dumps(c_char(b"x"))
-        # Issue 5049
-        self.dumps(c_wchar("x"))
-
-for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-    name = 'PickleTest_%s' % proto
-    globals()[name] = type(name,
-                           (PickleTest, unittest.TestCase),
-                           {'proto': proto})
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_pointers.py b/Lib/ctypes/test/test_pointers.py
deleted file mode 100644
index e97515879f1..00000000000
--- a/Lib/ctypes/test/test_pointers.py
+++ /dev/null
@@ -1,223 +0,0 @@
-import unittest, sys
-
-from ctypes import *
-import _ctypes_test
-
-ctype_types = [c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
-                 c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_float]
-python_types = [int, int, int, int, int, int,
-                int, int, int, int, float, float]
-
-class PointersTestCase(unittest.TestCase):
-
-    def test_pointer_crash(self):
-
-        class A(POINTER(c_ulong)):
-            pass
-
-        POINTER(c_ulong)(c_ulong(22))
-        # Pointer can't set contents: has no _type_
-        self.assertRaises(TypeError, A, c_ulong(33))
-
-    def test_pass_pointers(self):
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_p_p
-        if sizeof(c_longlong) == sizeof(c_void_p):
-            func.restype = c_longlong
-        else:
-            func.restype = c_long
-
-        i = c_int(12345678)
-##        func.argtypes = (POINTER(c_int),)
-        address = func(byref(i))
-        self.assertEqual(c_int.from_address(address).value, 12345678)
-
-        func.restype = POINTER(c_int)
-        res = func(pointer(i))
-        self.assertEqual(res.contents.value, 12345678)
-        self.assertEqual(res[0], 12345678)
-
-    def test_change_pointers(self):
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_p_p
-
-        i = c_int(87654)
-        func.restype = POINTER(c_int)
-        func.argtypes = (POINTER(c_int),)
-
-        res = func(pointer(i))
-        self.assertEqual(res[0], 87654)
-        self.assertEqual(res.contents.value, 87654)
-
-        # C code: *res = 54345
-        res[0] = 54345
-        self.assertEqual(i.value, 54345)
-
-        # C code:
-        #   int x = 12321;
-        #   res = &x
-        x = c_int(12321)
-        res.contents = x
-        self.assertEqual(i.value, 54345)
-
-        x.value = -99
-        self.assertEqual(res.contents.value, -99)
-
-    def test_callbacks_with_pointers(self):
-        # a function type receiving a pointer
-        PROTOTYPE = CFUNCTYPE(c_int, POINTER(c_int))
-
-        self.result = []
-
-        def func(arg):
-            for i in range(10):
-##                print arg[i],
-                self.result.append(arg[i])
-##            print
-            return 0
-        callback = PROTOTYPE(func)
-
-        dll = CDLL(_ctypes_test.__file__)
-        # This function expects a function pointer,
-        # and calls this with an integer pointer as parameter.
-        # The int pointer points to a table containing the numbers 1..10
-        doit = dll._testfunc_callback_with_pointer
-
-##        i = c_int(42)
-##        callback(byref(i))
-##        self.assertEqual(i.value, 84)
-
-        doit(callback)
-##        print self.result
-        doit(callback)
-##        print self.result
-
-    def test_basics(self):
-        from operator import delitem
-        for ct, pt in zip(ctype_types, python_types):
-            i = ct(42)
-            p = pointer(i)
-##            print type(p.contents), ct
-            self.assertIs(type(p.contents), ct)
-            # p.contents is the same as p[0]
-##            print p.contents
-##            self.assertEqual(p.contents, 42)
-##            self.assertEqual(p[0], 42)
-
-            self.assertRaises(TypeError, delitem, p, 0)
-
-    def test_from_address(self):
-        from array import array
-        a = array('i', [100, 200, 300, 400, 500])
-        addr = a.buffer_info()[0]
-
-        p = POINTER(POINTER(c_int))
-##        print dir(p)
-##        print p.from_address
-##        print p.from_address(addr)[0][0]
-
-    def test_other(self):
-        class Table(Structure):
-            _fields_ = [("a", c_int),
-                        ("b", c_int),
-                        ("c", c_int)]
-
-        pt = pointer(Table(1, 2, 3))
-
-        self.assertEqual(pt.contents.a, 1)
-        self.assertEqual(pt.contents.b, 2)
-        self.assertEqual(pt.contents.c, 3)
-
-        pt.contents.c = 33
-
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[Table]
-
-    def test_basic(self):
-        p = pointer(c_int(42))
-        # Although a pointer can be indexed, it has no length
-        self.assertRaises(TypeError, len, p)
-        self.assertEqual(p[0], 42)
-        self.assertEqual(p[0:1], [42])
-        self.assertEqual(p.contents.value, 42)
-
-    def test_charpp(self):
-        """Test that a character pointer-to-pointer is correctly passed"""
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_c_p_p
-        func.restype = c_char_p
-        argv = (c_char_p * 2)()
-        argc = c_int( 2 )
-        argv[0] = b'hello'
-        argv[1] = b'world'
-        result = func( byref(argc), argv )
-        self.assertEqual(result, b'world')
-
-    def test_bug_1467852(self):
-        # http://sourceforge.net/tracker/?func=detail&atid=532154&aid=1467852&group_id=71702
-        x = c_int(5)
-        dummy = []
-        for i in range(32000):
-            dummy.append(c_int(i))
-        y = c_int(6)
-        p = pointer(x)
-        pp = pointer(p)
-        q = pointer(y)
-        pp[0] = q         # <==
-        self.assertEqual(p[0], 6)
-    def test_c_void_p(self):
-        # http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470
-        if sizeof(c_void_p) == 4:
-            self.assertEqual(c_void_p(0xFFFFFFFF).value,
-                                 c_void_p(-1).value)
-            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
-                                 c_void_p(-1).value)
-        elif sizeof(c_void_p) == 8:
-            self.assertEqual(c_void_p(0xFFFFFFFF).value,
-                                 0xFFFFFFFF)
-            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
-                                 c_void_p(-1).value)
-            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
-                                 c_void_p(-1).value)
-
-        self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted
-        self.assertRaises(TypeError, c_void_p, object()) # nor other objects
-
-    def test_pointers_bool(self):
-        # NULL pointers have a boolean False value, non-NULL pointers True.
-        self.assertEqual(bool(POINTER(c_int)()), False)
-        self.assertEqual(bool(pointer(c_int())), True)
-
-        self.assertEqual(bool(CFUNCTYPE(None)(0)), False)
-        self.assertEqual(bool(CFUNCTYPE(None)(42)), True)
-
-        # COM methods are boolean True:
-        if sys.platform == "win32":
-            mth = WINFUNCTYPE(None)(42, "name", (), None)
-            self.assertEqual(bool(mth), True)
-
-    def test_pointer_type_name(self):
-        LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
-        self.assertTrue(POINTER(LargeNamedType))
-
-        # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[LargeNamedType]
-
-    def test_pointer_type_str_name(self):
-        large_string = 'T' * 2 ** 25
-        P = POINTER(large_string)
-        self.assertTrue(P)
-
-        # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[id(P)]
-
-    def test_abstract(self):
-        from ctypes import _Pointer
-
-        self.assertRaises(TypeError, _Pointer.set_type, 42)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_prototypes.py b/Lib/ctypes/test/test_prototypes.py
deleted file mode 100644
index cd0c649de3e..00000000000
--- a/Lib/ctypes/test/test_prototypes.py
+++ /dev/null
@@ -1,222 +0,0 @@
-from ctypes import *
-from ctypes.test import need_symbol
-import unittest
-
-# IMPORTANT INFO:
-#
-# Consider this call:
-#    func.restype = c_char_p
-#    func(c_char_p("123"))
-# It returns
-#    "123"
-#
-# WHY IS THIS SO?
-#
-# argument tuple (c_char_p("123"), ) is destroyed after the function
-# func is called, but NOT before the result is actually built.
-#
-# If the arglist would be destroyed BEFORE the result has been built,
-# the c_char_p("123") object would already have a zero refcount,
-# and the pointer passed to (and returned by) the function would
-# probably point to deallocated space.
-#
-# In this case, there would have to be an additional reference to the argument...
-
-import _ctypes_test
-testdll = CDLL(_ctypes_test.__file__)
-
-# Return machine address `a` as a (possibly long) non-negative integer.
-# Starting with Python 2.5, id(anything) is always non-negative, and
-# the ctypes addressof() inherits that via PyLong_FromVoidPtr().
-def positive_address(a):
-    if a >= 0:
-        return a
-    # View the bits in `a` as unsigned instead.
-    import struct
-    num_bits = struct.calcsize("P") * 8 # num bits in native machine address
-    a += 1 << num_bits
-    assert a >= 0
-    return a
-
-def c_wbuffer(init):
-    n = len(init) + 1
-    return (c_wchar * n)(*init)
-
-class CharPointersTestCase(unittest.TestCase):
-
-    def setUp(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_long
-        func.argtypes = None
-
-    def test_paramflags(self):
-        # function returns c_void_p result,
-        # and has a required parameter named 'input'
-        prototype = CFUNCTYPE(c_void_p, c_void_p)
-        func = prototype(("_testfunc_p_p", testdll),
-                         ((1, "input"),))
-
-        try:
-            func()
-        except TypeError as details:
-            self.assertEqual(str(details), "required argument 'input' missing")
-        else:
-            self.fail("TypeError not raised")
-
-        self.assertEqual(func(None), None)
-        self.assertEqual(func(input=None), None)
-
-
-    def test_int_pointer_arg(self):
-        func = testdll._testfunc_p_p
-        if sizeof(c_longlong) == sizeof(c_void_p):
-            func.restype = c_longlong
-        else:
-            func.restype = c_long
-        self.assertEqual(0, func(0))
-
-        ci = c_int(0)
-
-        func.argtypes = POINTER(c_int),
-        self.assertEqual(positive_address(addressof(ci)),
-                             positive_address(func(byref(ci))))
-
-        func.argtypes = c_char_p,
-        self.assertRaises(ArgumentError, func, byref(ci))
-
-        func.argtypes = POINTER(c_short),
-        self.assertRaises(ArgumentError, func, byref(ci))
-
-        func.argtypes = POINTER(c_double),
-        self.assertRaises(ArgumentError, func, byref(ci))
-
-    def test_POINTER_c_char_arg(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_char_p
-        func.argtypes = POINTER(c_char),
-
-        self.assertEqual(None, func(None))
-        self.assertEqual(b"123", func(b"123"))
-        self.assertEqual(None, func(c_char_p(None)))
-        self.assertEqual(b"123", func(c_char_p(b"123")))
-
-        self.assertEqual(b"123", func(c_buffer(b"123")))
-        ca = c_char(b"a")
-        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
-        self.assertEqual(ord(b"a"), func(byref(ca))[0])
-
-    def test_c_char_p_arg(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_char_p
-        func.argtypes = c_char_p,
-
-        self.assertEqual(None, func(None))
-        self.assertEqual(b"123", func(b"123"))
-        self.assertEqual(None, func(c_char_p(None)))
-        self.assertEqual(b"123", func(c_char_p(b"123")))
-
-        self.assertEqual(b"123", func(c_buffer(b"123")))
-        ca = c_char(b"a")
-        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
-        self.assertEqual(ord(b"a"), func(byref(ca))[0])
-
-    def test_c_void_p_arg(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_char_p
-        func.argtypes = c_void_p,
-
-        self.assertEqual(None, func(None))
-        self.assertEqual(b"123", func(b"123"))
-        self.assertEqual(b"123", func(c_char_p(b"123")))
-        self.assertEqual(None, func(c_char_p(None)))
-
-        self.assertEqual(b"123", func(c_buffer(b"123")))
-        ca = c_char(b"a")
-        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
-        self.assertEqual(ord(b"a"), func(byref(ca))[0])
-
-        func(byref(c_int()))
-        func(pointer(c_int()))
-        func((c_int * 3)())
-
-    @need_symbol('c_wchar_p')
-    def test_c_void_p_arg_with_c_wchar_p(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_wchar_p
-        func.argtypes = c_void_p,
-
-        self.assertEqual(None, func(c_wchar_p(None)))
-        self.assertEqual("123", func(c_wchar_p("123")))
-
-    def test_instance(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_void_p
-
-        class X:
-            _as_parameter_ = None
-
-        func.argtypes = c_void_p,
-        self.assertEqual(None, func(X()))
-
-        func.argtypes = None
-        self.assertEqual(None, func(X()))
-
-@need_symbol('c_wchar')
-class WCharPointersTestCase(unittest.TestCase):
-
-    def setUp(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_int
-        func.argtypes = None
-
-
-    def test_POINTER_c_wchar_arg(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_wchar_p
-        func.argtypes = POINTER(c_wchar),
-
-        self.assertEqual(None, func(None))
-        self.assertEqual("123", func("123"))
-        self.assertEqual(None, func(c_wchar_p(None)))
-        self.assertEqual("123", func(c_wchar_p("123")))
-
-        self.assertEqual("123", func(c_wbuffer("123")))
-        ca = c_wchar("a")
-        self.assertEqual("a", func(pointer(ca))[0])
-        self.assertEqual("a", func(byref(ca))[0])
-
-    def test_c_wchar_p_arg(self):
-        func = testdll._testfunc_p_p
-        func.restype = c_wchar_p
-        func.argtypes = c_wchar_p,
-
-        c_wchar_p.from_param("123")
-
-        self.assertEqual(None, func(None))
-        self.assertEqual("123", func("123"))
-        self.assertEqual(None, func(c_wchar_p(None)))
-        self.assertEqual("123", func(c_wchar_p("123")))
-
-        # XXX Currently, these raise TypeErrors, although they shouldn't:
-        self.assertEqual("123", func(c_wbuffer("123")))
-        ca = c_wchar("a")
-        self.assertEqual("a", func(pointer(ca))[0])
-        self.assertEqual("a", func(byref(ca))[0])
-
-class ArrayTest(unittest.TestCase):
-    def test(self):
-        func = testdll._testfunc_ai8
-        func.restype = POINTER(c_int)
-        func.argtypes = c_int * 8,
-
-        func((c_int * 8)(1, 2, 3, 4, 5, 6, 7, 8))
-
-        # This did crash before:
-
-        def func(): pass
-        CFUNCTYPE(None, c_int * 3)(func)
-
-################################################################
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_python_api.py b/Lib/ctypes/test/test_python_api.py
deleted file mode 100644
index 49571f97bbe..00000000000
--- a/Lib/ctypes/test/test_python_api.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from ctypes import *
-import unittest
-from test import support
-
-################################################################
-# This section should be moved into ctypes\__init__.py, when it's ready.
-
-from _ctypes import PyObj_FromPtr
-
-################################################################
-
-from sys import getrefcount as grc
-
-class PythonAPITestCase(unittest.TestCase):
-
-    def test_PyBytes_FromStringAndSize(self):
-        PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
-
-        PyBytes_FromStringAndSize.restype = py_object
-        PyBytes_FromStringAndSize.argtypes = c_char_p, c_size_t
-
-        self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
-
-    @support.refcount_test
-    def test_PyString_FromString(self):
-        pythonapi.PyBytes_FromString.restype = py_object
-        pythonapi.PyBytes_FromString.argtypes = (c_char_p,)
-
-        s = b"abc"
-        refcnt = grc(s)
-        pyob = pythonapi.PyBytes_FromString(s)
-        self.assertEqual(grc(s), refcnt)
-        self.assertEqual(s, pyob)
-        del pyob
-        self.assertEqual(grc(s), refcnt)
-
-    @support.refcount_test
-    def test_PyLong_Long(self):
-        ref42 = grc(42)
-        pythonapi.PyLong_FromLong.restype = py_object
-        self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
-
-        self.assertEqual(grc(42), ref42)
-
-        pythonapi.PyLong_AsLong.argtypes = (py_object,)
-        pythonapi.PyLong_AsLong.restype = c_long
-
-        res = pythonapi.PyLong_AsLong(42)
-        self.assertEqual(grc(res), ref42 + 1)
-        del res
-        self.assertEqual(grc(42), ref42)
-
-    @support.refcount_test
-    def test_PyObj_FromPtr(self):
-        s = "abc def ghi jkl"
-        ref = grc(s)
-        # id(python-object) is the address
-        pyobj = PyObj_FromPtr(id(s))
-        self.assertIs(s, pyobj)
-
-        self.assertEqual(grc(s), ref + 1)
-        del pyobj
-        self.assertEqual(grc(s), ref)
-
-    def test_PyOS_snprintf(self):
-        PyOS_snprintf = pythonapi.PyOS_snprintf
-        PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
-
-        buf = c_buffer(256)
-        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s", b"ctypes")
-        self.assertEqual(buf.value, b"Hello from ctypes")
-
-        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
-        self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
-
-        # not enough arguments
-        self.assertRaises(TypeError, PyOS_snprintf, buf)
-
-    def test_pyobject_repr(self):
-        self.assertEqual(repr(py_object()), "py_object(<NULL>)")
-        self.assertEqual(repr(py_object(42)), "py_object(42)")
-        self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_random_things.py b/Lib/ctypes/test/test_random_things.py
deleted file mode 100644
index 2988e275cf4..00000000000
--- a/Lib/ctypes/test/test_random_things.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from ctypes import *
-import contextlib
-from test import support
-import unittest
-import sys
-
-
-def callback_func(arg):
-    42 / arg
-    raise ValueError(arg)
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class call_function_TestCase(unittest.TestCase):
-    # _ctypes.call_function is deprecated and private, but used by
-    # Gary Bishp's readline module.  If we have it, we must test it as well.
-
-    def test(self):
-        from _ctypes import call_function
-        windll.kernel32.LoadLibraryA.restype = c_void_p
-        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
-        windll.kernel32.GetProcAddress.restype = c_void_p
-
-        hdll = windll.kernel32.LoadLibraryA(b"kernel32")
-        funcaddr = windll.kernel32.GetProcAddress(hdll, b"GetModuleHandleA")
-
-        self.assertEqual(call_function(funcaddr, (None,)),
-                             windll.kernel32.GetModuleHandleA(None))
-
-class CallbackTracbackTestCase(unittest.TestCase):
-    # When an exception is raised in a ctypes callback function, the C
-    # code prints a traceback.
-    #
-    # This test makes sure the exception types *and* the exception
-    # value is printed correctly.
-    #
-    # Changed in 0.9.3: No longer is '(in callback)' prepended to the
-    # error message - instead an additional frame for the C code is
-    # created, then a full traceback printed.  When SystemExit is
-    # raised in a callback function, the interpreter exits.
-
-    @contextlib.contextmanager
-    def expect_unraisable(self, exc_type, exc_msg=None):
-        with support.catch_unraisable_exception() as cm:
-            yield
-
-            self.assertIsInstance(cm.unraisable.exc_value, exc_type)
-            if exc_msg is not None:
-                self.assertEqual(str(cm.unraisable.exc_value), exc_msg)
-            self.assertEqual(cm.unraisable.err_msg,
-                             "Exception ignored on calling ctypes "
-                             "callback function")
-            self.assertIs(cm.unraisable.object, callback_func)
-
-    def test_ValueError(self):
-        cb = CFUNCTYPE(c_int, c_int)(callback_func)
-        with self.expect_unraisable(ValueError, '42'):
-            cb(42)
-
-    def test_IntegerDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_int)(callback_func)
-        with self.expect_unraisable(ZeroDivisionError):
-            cb(0)
-
-    def test_FloatDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_double)(callback_func)
-        with self.expect_unraisable(ZeroDivisionError):
-            cb(0.0)
-
-    def test_TypeErrorDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
-        err_msg = "unsupported operand type(s) for /: 'int' and 'bytes'"
-        with self.expect_unraisable(TypeError, err_msg):
-            cb(b"spam")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_refcounts.py b/Lib/ctypes/test/test_refcounts.py
deleted file mode 100644
index 48958cd2a60..00000000000
--- a/Lib/ctypes/test/test_refcounts.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import unittest
-from test import support
-import ctypes
-import gc
-
-MyCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
-OtherCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulonglong)
-
-import _ctypes_test
-dll = ctypes.CDLL(_ctypes_test.__file__)
-
-class RefcountTestCase(unittest.TestCase):
-
-    @support.refcount_test
-    def test_1(self):
-        from sys import getrefcount as grc
-
-        f = dll._testfunc_callback_i_if
-        f.restype = ctypes.c_int
-        f.argtypes = [ctypes.c_int, MyCallback]
-
-        def callback(value):
-            #print "called back with", value
-            return value
-
-        self.assertEqual(grc(callback), 2)
-        cb = MyCallback(callback)
-
-        self.assertGreater(grc(callback), 2)
-        result = f(-10, cb)
-        self.assertEqual(result, -18)
-        cb = None
-
-        gc.collect()
-
-        self.assertEqual(grc(callback), 2)
-
-
-    @support.refcount_test
-    def test_refcount(self):
-        from sys import getrefcount as grc
-        def func(*args):
-            pass
-        # this is the standard refcount for func
-        self.assertEqual(grc(func), 2)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        f = OtherCallback(func)
-        self.assertGreater(grc(func), 2)
-
-        # and may release it again
-        del f
-        self.assertGreaterEqual(grc(func), 2)
-
-        # but now it must be gone
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-        class X(ctypes.Structure):
-            _fields_ = [("a", OtherCallback)]
-        x = X()
-        x.a = OtherCallback(func)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(grc(func), 2)
-
-        # and may release it again
-        del x
-        self.assertGreaterEqual(grc(func), 2)
-
-        # and now it must be gone again
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-        f = OtherCallback(func)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(grc(func), 2)
-
-        # create a cycle
-        f.cycle = f
-
-        del f
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-class AnotherLeak(unittest.TestCase):
-    def test_callback(self):
-        import sys
-
-        proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
-        def func(a, b):
-            return a * b * 2
-        f = proto(func)
-
-        a = sys.getrefcount(ctypes.c_int)
-        f(1, 2)
-        self.assertEqual(sys.getrefcount(ctypes.c_int), a)
-
-    @support.refcount_test
-    def test_callback_py_object_none_return(self):
-        # bpo-36880: test that returning None from a py_object callback
-        # does not decrement the refcount of None.
-
-        for FUNCTYPE in (ctypes.CFUNCTYPE, ctypes.PYFUNCTYPE):
-            with self.subTest(FUNCTYPE=FUNCTYPE):
-                @FUNCTYPE(ctypes.py_object)
-                def func():
-                    return None
-
-                # Check that calling func does not affect None's refcount.
-                for _ in range(10000):
-                    func()
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_repr.py b/Lib/ctypes/test/test_repr.py
deleted file mode 100644
index 60a2c803453..00000000000
--- a/Lib/ctypes/test/test_repr.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from ctypes import *
-import unittest
-
-subclasses = []
-for base in [c_byte, c_short, c_int, c_long, c_longlong,
-        c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong,
-        c_float, c_double, c_longdouble, c_bool]:
-    class X(base):
-        pass
-    subclasses.append(X)
-
-class X(c_char):
-    pass
-
-# This test checks if the __repr__ is correct for subclasses of simple types
-
-class ReprTest(unittest.TestCase):
-    def test_numbers(self):
-        for typ in subclasses:
-            base = typ.__bases__[0]
-            self.assertTrue(repr(base(42)).startswith(base.__name__))
-            self.assertEqual("<X object at", repr(typ(42))[:12])
-
-    def test_char(self):
-        self.assertEqual("c_char(b'x')", repr(c_char(b'x')))
-        self.assertEqual("<X object at", repr(X(b'x'))[:12])
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_returnfuncptrs.py b/Lib/ctypes/test/test_returnfuncptrs.py
deleted file mode 100644
index 1974f40df64..00000000000
--- a/Lib/ctypes/test/test_returnfuncptrs.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import unittest
-from ctypes import *
-
-import _ctypes_test
-
-class ReturnFuncPtrTestCase(unittest.TestCase):
-
-    def test_with_prototype(self):
-        # The _ctypes_test shared lib/dll exports quite some functions for testing.
-        # The get_strchr function returns a *pointer* to the C strchr function.
-        dll = CDLL(_ctypes_test.__file__)
-        get_strchr = dll.get_strchr
-        get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char)
-        strchr = get_strchr()
-        self.assertEqual(strchr(b"abcdef", b"b"), b"bcdef")
-        self.assertEqual(strchr(b"abcdef", b"x"), None)
-        self.assertEqual(strchr(b"abcdef", 98), b"bcdef")
-        self.assertEqual(strchr(b"abcdef", 107), None)
-        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
-        self.assertRaises(TypeError, strchr, b"abcdef")
-
-    def test_without_prototype(self):
-        dll = CDLL(_ctypes_test.__file__)
-        get_strchr = dll.get_strchr
-        # the default 'c_int' would not work on systems where sizeof(int) != sizeof(void *)
-        get_strchr.restype = c_void_p
-        addr = get_strchr()
-        # _CFuncPtr instances are now callable with an integer argument
-        # which denotes a function address:
-        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr)
-        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
-        self.assertEqual(strchr(b"abcdef", b"x"), None)
-        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
-        self.assertRaises(TypeError, strchr, b"abcdef")
-
-    def test_from_dll(self):
-        dll = CDLL(_ctypes_test.__file__)
-        # _CFuncPtr instances are now callable with a tuple argument
-        # which denotes a function name and a dll:
-        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(("my_strchr", dll))
-        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
-        self.assertEqual(strchr(b"abcdef", b"x"), None)
-        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
-        self.assertRaises(TypeError, strchr, b"abcdef")
-
-    # Issue 6083: Reference counting bug
-    def test_from_dll_refcount(self):
-        class BadSequence(tuple):
-            def __getitem__(self, key):
-                if key == 0:
-                    return "my_strchr"
-                if key == 1:
-                    return CDLL(_ctypes_test.__file__)
-                raise IndexError
-
-        # _CFuncPtr instances are now callable with a tuple argument
-        # which denotes a function name and a dll:
-        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(
-                BadSequence(("my_strchr", CDLL(_ctypes_test.__file__))))
-        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
-        self.assertEqual(strchr(b"abcdef", b"x"), None)
-        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
-        self.assertRaises(TypeError, strchr, b"abcdef")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_simplesubclasses.py b/Lib/ctypes/test/test_simplesubclasses.py
deleted file mode 100644
index 3da2794a794..00000000000
--- a/Lib/ctypes/test/test_simplesubclasses.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import unittest
-from ctypes import *
-
-class MyInt(c_int):
-    def __eq__(self, other):
-        if type(other) != MyInt:
-            return NotImplementedError
-        return self.value == other.value
-
-class Test(unittest.TestCase):
-
-    def test_compare(self):
-        self.assertEqual(MyInt(3), MyInt(3))
-        self.assertNotEqual(MyInt(42), MyInt(43))
-
-    def test_ignore_retval(self):
-        # Test if the return value of a callback is ignored
-        # if restype is None
-        proto = CFUNCTYPE(None)
-        def func():
-            return (1, "abc", None)
-
-        cb = proto(func)
-        self.assertEqual(None, cb())
-
-
-    def test_int_callback(self):
-        args = []
-        def func(arg):
-            args.append(arg)
-            return arg
-
-        cb = CFUNCTYPE(None, MyInt)(func)
-
-        self.assertEqual(None, cb(42))
-        self.assertEqual(type(args[-1]), MyInt)
-
-        cb = CFUNCTYPE(c_int, c_int)(func)
-
-        self.assertEqual(42, cb(42))
-        self.assertEqual(type(args[-1]), int)
-
-    def test_int_struct(self):
-        class X(Structure):
-            _fields_ = [("x", MyInt)]
-
-        self.assertEqual(X().x, MyInt())
-
-        s = X()
-        s.x = MyInt(42)
-
-        self.assertEqual(s.x, MyInt(42))
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_sizes.py b/Lib/ctypes/test/test_sizes.py
deleted file mode 100644
index 4ceacbc2900..00000000000
--- a/Lib/ctypes/test/test_sizes.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# Test specifically-sized containers.
-
-from ctypes import *
-
-import unittest
-
-
-class SizesTestCase(unittest.TestCase):
-    def test_8(self):
-        self.assertEqual(1, sizeof(c_int8))
-        self.assertEqual(1, sizeof(c_uint8))
-
-    def test_16(self):
-        self.assertEqual(2, sizeof(c_int16))
-        self.assertEqual(2, sizeof(c_uint16))
-
-    def test_32(self):
-        self.assertEqual(4, sizeof(c_int32))
-        self.assertEqual(4, sizeof(c_uint32))
-
-    def test_64(self):
-        self.assertEqual(8, sizeof(c_int64))
-        self.assertEqual(8, sizeof(c_uint64))
-
-    def test_size_t(self):
-        self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
-
-    def test_ssize_t(self):
-        self.assertEqual(sizeof(c_void_p), sizeof(c_ssize_t))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_slicing.py b/Lib/ctypes/test/test_slicing.py
deleted file mode 100644
index a3932f17672..00000000000
--- a/Lib/ctypes/test/test_slicing.py
+++ /dev/null
@@ -1,167 +0,0 @@
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-
-import _ctypes_test
-
-class SlicesTestCase(unittest.TestCase):
-    def test_getslice_cint(self):
-        a = (c_int * 100)(*range(1100, 1200))
-        b = list(range(1100, 1200))
-        self.assertEqual(a[0:2], b[0:2])
-        self.assertEqual(a[0:2:], b[0:2:])
-        self.assertEqual(len(a), len(b))
-        self.assertEqual(a[5:7], b[5:7])
-        self.assertEqual(a[5:7:], b[5:7:])
-        self.assertEqual(a[-1], b[-1])
-        self.assertEqual(a[:], b[:])
-        self.assertEqual(a[::], b[::])
-        self.assertEqual(a[10::-1], b[10::-1])
-        self.assertEqual(a[30:20:-1], b[30:20:-1])
-        self.assertEqual(a[:12:6], b[:12:6])
-        self.assertEqual(a[2:6:4], b[2:6:4])
-
-        a[0:5] = range(5, 10)
-        self.assertEqual(a[0:5], list(range(5, 10)))
-        self.assertEqual(a[0:5:], list(range(5, 10)))
-        self.assertEqual(a[4::-1], list(range(9, 4, -1)))
-
-    def test_setslice_cint(self):
-        a = (c_int * 100)(*range(1100, 1200))
-        b = list(range(1100, 1200))
-
-        a[32:47] = list(range(32, 47))
-        self.assertEqual(a[32:47], list(range(32, 47)))
-        a[32:47] = range(132, 147)
-        self.assertEqual(a[32:47:], list(range(132, 147)))
-        a[46:31:-1] = range(232, 247)
-        self.assertEqual(a[32:47:1], list(range(246, 231, -1)))
-
-        a[32:47] = range(1132, 1147)
-        self.assertEqual(a[:], b)
-        a[32:47:7] = range(3)
-        b[32:47:7] = range(3)
-        self.assertEqual(a[:], b)
-        a[33::-3] = range(12)
-        b[33::-3] = range(12)
-        self.assertEqual(a[:], b)
-
-        from operator import setitem
-
-        # TypeError: int expected instead of str instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5), "abcde")
-        # TypeError: int expected instead of str instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5),
-                          ["a", "b", "c", "d", "e"])
-        # TypeError: int expected instead of float instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5),
-                          [1, 2, 3, 4, 3.14])
-        # ValueError: Can only assign sequence of same size
-        self.assertRaises(ValueError, setitem, a, slice(0, 5), range(32))
-
-    def test_char_ptr(self):
-        s = b"abcdefghijklmnopqrstuvwxyz"
-
-        dll = CDLL(_ctypes_test.__file__)
-        dll.my_strdup.restype = POINTER(c_char)
-        dll.my_free.restype = None
-        res = dll.my_strdup(s)
-        self.assertEqual(res[:len(s)], s)
-        self.assertEqual(res[:3], s[:3])
-        self.assertEqual(res[:len(s):], s)
-        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
-        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
-        self.assertEqual(res[0:-1:-1], s[0::-1])
-
-        import operator
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(None, None, None))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(0, None, None))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(None, 5, -1))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(-5, None, None))
-
-        self.assertRaises(TypeError, operator.setitem,
-                          res, slice(0, 5), "abcde")
-        dll.my_free(res)
-
-        dll.my_strdup.restype = POINTER(c_byte)
-        res = dll.my_strdup(s)
-        self.assertEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
-        self.assertEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
-        dll.my_free(res)
-
-    def test_char_ptr_with_free(self):
-        dll = CDLL(_ctypes_test.__file__)
-        s = b"abcdefghijklmnopqrstuvwxyz"
-
-        class allocated_c_char_p(c_char_p):
-            pass
-
-        dll.my_free.restype = None
-        def errcheck(result, func, args):
-            retval = result.value
-            dll.my_free(result)
-            return retval
-
-        dll.my_strdup.restype = allocated_c_char_p
-        dll.my_strdup.errcheck = errcheck
-        try:
-            res = dll.my_strdup(s)
-            self.assertEqual(res, s)
-        finally:
-            del dll.my_strdup.errcheck
-
-
-    def test_char_array(self):
-        s = b"abcdefghijklmnopqrstuvwxyz\0"
-
-        p = (c_char * 27)(*s)
-        self.assertEqual(p[:], s)
-        self.assertEqual(p[::], s)
-        self.assertEqual(p[::-1], s[::-1])
-        self.assertEqual(p[5::-2], s[5::-2])
-        self.assertEqual(p[2:5:-3], s[2:5:-3])
-
-
-    @need_symbol('c_wchar')
-    def test_wchar_ptr(self):
-        s = "abcdefghijklmnopqrstuvwxyz\0"
-
-        dll = CDLL(_ctypes_test.__file__)
-        dll.my_wcsdup.restype = POINTER(c_wchar)
-        dll.my_wcsdup.argtypes = POINTER(c_wchar),
-        dll.my_free.restype = None
-        res = dll.my_wcsdup(s[:-1])
-        self.assertEqual(res[:len(s)], s)
-        self.assertEqual(res[:len(s):], s)
-        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
-        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
-
-        import operator
-        self.assertRaises(TypeError, operator.setitem,
-                          res, slice(0, 5), "abcde")
-        dll.my_free(res)
-
-        if sizeof(c_wchar) == sizeof(c_short):
-            dll.my_wcsdup.restype = POINTER(c_short)
-        elif sizeof(c_wchar) == sizeof(c_int):
-            dll.my_wcsdup.restype = POINTER(c_int)
-        elif sizeof(c_wchar) == sizeof(c_long):
-            dll.my_wcsdup.restype = POINTER(c_long)
-        else:
-            self.skipTest('Pointers to c_wchar are not supported')
-        res = dll.my_wcsdup(s[:-1])
-        tmpl = list(range(ord("a"), ord("z")+1))
-        self.assertEqual(res[:len(s)-1], tmpl)
-        self.assertEqual(res[:len(s)-1:], tmpl)
-        self.assertEqual(res[len(s)-2:-1:-1], tmpl[::-1])
-        self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
-        dll.my_free(res)
-
-################################################################
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_stringptr.py b/Lib/ctypes/test/test_stringptr.py
deleted file mode 100644
index c20951f4ce0..00000000000
--- a/Lib/ctypes/test/test_stringptr.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import unittest
-from test import support
-from ctypes import *
-
-import _ctypes_test
-
-lib = CDLL(_ctypes_test.__file__)
-
-class StringPtrTestCase(unittest.TestCase):
-
-    @support.refcount_test
-    def test__POINTER_c_char(self):
-        class X(Structure):
-            _fields_ = [("str", POINTER(c_char))]
-        x = X()
-
-        # NULL pointer access
-        self.assertRaises(ValueError, getattr, x.str, "contents")
-        b = c_buffer(b"Hello, World")
-        from sys import getrefcount as grc
-        self.assertEqual(grc(b), 2)
-        x.str = b
-        self.assertEqual(grc(b), 3)
-
-        # POINTER(c_char) and Python string is NOT compatible
-        # POINTER(c_char) and c_buffer() is compatible
-        for i in range(len(b)):
-            self.assertEqual(b[i], x.str[i])
-
-        self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
-
-    def test__c_char_p(self):
-        class X(Structure):
-            _fields_ = [("str", c_char_p)]
-        x = X()
-
-        # c_char_p and Python string is compatible
-        # c_char_p and c_buffer is NOT compatible
-        self.assertEqual(x.str, None)
-        x.str = b"Hello, World"
-        self.assertEqual(x.str, b"Hello, World")
-        b = c_buffer(b"Hello, World")
-        self.assertRaises(TypeError, setattr, x, b"str", b)
-
-
-    def test_functions(self):
-        strchr = lib.my_strchr
-        strchr.restype = c_char_p
-
-        # c_char_p and Python string is compatible
-        # c_char_p and c_buffer are now compatible
-        strchr.argtypes = c_char_p, c_char
-        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
-        self.assertEqual(strchr(c_buffer(b"abcdef"), b"c"), b"cdef")
-
-        # POINTER(c_char) and Python string is NOT compatible
-        # POINTER(c_char) and c_buffer() is compatible
-        strchr.argtypes = POINTER(c_char), c_char
-        buf = c_buffer(b"abcdef")
-        self.assertEqual(strchr(buf, b"c"), b"cdef")
-        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
-
-        # XXX These calls are dangerous, because the first argument
-        # to strchr is no longer valid after the function returns!
-        # So we must keep a reference to buf separately
-
-        strchr.restype = POINTER(c_char)
-        buf = c_buffer(b"abcdef")
-        r = strchr(buf, b"c")
-        x = r[0], r[1], r[2], r[3], r[4]
-        self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
-        del buf
-        # Because r is a pointer to memory that is freed after deleting buf,
-        # the pointer is hanging and using it would reference freed memory.
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_strings.py b/Lib/ctypes/test/test_strings.py
deleted file mode 100644
index 12e208828a7..00000000000
--- a/Lib/ctypes/test/test_strings.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-
-class StringArrayTestCase(unittest.TestCase):
-    def test(self):
-        BUF = c_char * 4
-
-        buf = BUF(b"a", b"b", b"c")
-        self.assertEqual(buf.value, b"abc")
-        self.assertEqual(buf.raw, b"abc\000")
-
-        buf.value = b"ABCD"
-        self.assertEqual(buf.value, b"ABCD")
-        self.assertEqual(buf.raw, b"ABCD")
-
-        buf.value = b"x"
-        self.assertEqual(buf.value, b"x")
-        self.assertEqual(buf.raw, b"x\000CD")
-
-        buf[1] = b"Z"
-        self.assertEqual(buf.value, b"xZCD")
-        self.assertEqual(buf.raw, b"xZCD")
-
-        self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa")
-        self.assertRaises(TypeError, setattr, buf, "value", 42)
-
-    def test_c_buffer_value(self):
-        buf = c_buffer(32)
-
-        buf.value = b"Hello, World"
-        self.assertEqual(buf.value, b"Hello, World")
-
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
-        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
-
-    def test_c_buffer_raw(self):
-        buf = c_buffer(32)
-
-        buf.raw = memoryview(b"Hello, World")
-        self.assertEqual(buf.value, b"Hello, World")
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
-        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
-
-    def test_param_1(self):
-        BUF = c_char * 4
-        buf = BUF()
-##        print c_char_p.from_param(buf)
-
-    def test_param_2(self):
-        BUF = c_char * 4
-        buf = BUF()
-##        print BUF.from_param(c_char_p("python"))
-##        print BUF.from_param(BUF(*"pyth"))
-
-    def test_del_segfault(self):
-        BUF = c_char * 4
-        buf = BUF()
-        with self.assertRaises(AttributeError):
-            del buf.raw
-
-
-@need_symbol('c_wchar')
-class WStringArrayTestCase(unittest.TestCase):
-    def test(self):
-        BUF = c_wchar * 4
-
-        buf = BUF("a", "b", "c")
-        self.assertEqual(buf.value, "abc")
-
-        buf.value = "ABCD"
-        self.assertEqual(buf.value, "ABCD")
-
-        buf.value = "x"
-        self.assertEqual(buf.value, "x")
-
-        buf[1] = "Z"
-        self.assertEqual(buf.value, "xZCD")
-
-    @unittest.skipIf(sizeof(c_wchar) < 4,
-                     "sizeof(wchar_t) is smaller than 4 bytes")
-    def test_nonbmp(self):
-        u = chr(0x10ffff)
-        w = c_wchar(u)
-        self.assertEqual(w.value, u)
-
-
-@need_symbol('c_wchar')
-class WStringTestCase(unittest.TestCase):
-    def test_wchar(self):
-        c_wchar("x")
-        repr(byref(c_wchar("x")))
-        c_wchar("x")
-
-
-    @unittest.skip('test disabled')
-    def test_basic_wstrings(self):
-        cs = c_wstring("abcdef")
-
-        # XXX This behaviour is about to change:
-        # len returns the size of the internal buffer in bytes.
-        # This includes the terminating NUL character.
-        self.assertEqual(sizeof(cs), 14)
-
-        # The value property is the string up to the first terminating NUL.
-        self.assertEqual(cs.value, "abcdef")
-        self.assertEqual(c_wstring("abc\000def").value, "abc")
-
-        self.assertEqual(c_wstring("abc\000def").value, "abc")
-
-        # The raw property is the total buffer contents:
-        self.assertEqual(cs.raw, "abcdef\000")
-        self.assertEqual(c_wstring("abc\000def").raw, "abc\000def\000")
-
-        # We can change the value:
-        cs.value = "ab"
-        self.assertEqual(cs.value, "ab")
-        self.assertEqual(cs.raw, "ab\000\000\000\000\000")
-
-        self.assertRaises(TypeError, c_wstring, "123")
-        self.assertRaises(ValueError, c_wstring, 0)
-
-    @unittest.skip('test disabled')
-    def test_toolong(self):
-        cs = c_wstring("abcdef")
-        # Much too long string:
-        self.assertRaises(ValueError, setattr, cs, "value", "123456789012345")
-
-        # One char too long values:
-        self.assertRaises(ValueError, setattr, cs, "value", "1234567")
-
-
-def run_test(rep, msg, func, arg):
-    items = range(rep)
-    from time import perf_counter as clock
-    start = clock()
-    for i in items:
-        func(arg); func(arg); func(arg); func(arg); func(arg)
-    stop = clock()
-    print("%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep)))
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_struct_fields.py b/Lib/ctypes/test/test_struct_fields.py
deleted file mode 100644
index e444f5e1f77..00000000000
--- a/Lib/ctypes/test/test_struct_fields.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import unittest
-from ctypes import *
-
-class StructFieldsTestCase(unittest.TestCase):
-    # Structure/Union classes must get 'finalized' sooner or
-    # later, when one of these things happen:
-    #
-    # 1. _fields_ is set.
-    # 2. An instance is created.
-    # 3. The type is used as field of another Structure/Union.
-    # 4. The type is subclassed
-    #
-    # When they are finalized, assigning _fields_ is no longer allowed.
-
-    def test_1_A(self):
-        class X(Structure):
-            pass
-        self.assertEqual(sizeof(X), 0) # not finalized
-        X._fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_1_B(self):
-        class X(Structure):
-            _fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_2(self):
-        class X(Structure):
-            pass
-        X()
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_3(self):
-        class X(Structure):
-            pass
-        class Y(Structure):
-            _fields_ = [("x", X)] # finalizes X
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_4(self):
-        class X(Structure):
-            pass
-        class Y(X):
-            pass
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-        Y._fields_ = []
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_5(self):
-        class X(Structure):
-            _fields_ = (("char", c_char * 5),)
-
-        x = X(b'#' * 5)
-        x.char = b'a\0b\0'
-        self.assertEqual(bytes(x), b'a\x00###')
-
-    def test_6(self):
-        class X(Structure):
-            _fields_ = [("x", c_int)]
-        CField = type(X.x)
-        self.assertRaises(TypeError, CField)
-
-    def test_gh99275(self):
-        class BrokenStructure(Structure):
-            def __init_subclass__(cls, **kwargs):
-                cls._fields_ = []  # This line will fail, `stgdict` is not ready
-
-        with self.assertRaisesRegex(TypeError,
-                                    'ctypes state is not initialized'):
-            class Subclass(BrokenStructure): ...
-
-    # __set__ and __get__ should raise a TypeError in case their self
-    # argument is not a ctype instance.
-    def test___set__(self):
-        class MyCStruct(Structure):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCStruct.field.__set__, 'wrong type self', 42)
-
-        class MyCUnion(Union):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCUnion.field.__set__, 'wrong type self', 42)
-
-    def test___get__(self):
-        class MyCStruct(Structure):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCStruct.field.__get__, 'wrong type self', 42)
-
-        class MyCUnion(Union):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCUnion.field.__get__, 'wrong type self', 42)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_structures.py b/Lib/ctypes/test/test_structures.py
deleted file mode 100644
index f95d5a99a3a..00000000000
--- a/Lib/ctypes/test/test_structures.py
+++ /dev/null
@@ -1,812 +0,0 @@
-import platform
-import sys
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-from struct import calcsize
-import _ctypes_test
-from test import support
-
-# The following definition is meant to be used from time to time to assist
-# temporarily disabling tests on specific architectures while investigations
-# are in progress, to keep buildbots happy.
-MACHINE = platform.machine()
-
-class SubclassesTest(unittest.TestCase):
-    def test_subclass(self):
-        class X(Structure):
-            _fields_ = [("a", c_int)]
-
-        class Y(X):
-            _fields_ = [("b", c_int)]
-
-        class Z(X):
-            pass
-
-        self.assertEqual(sizeof(X), sizeof(c_int))
-        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
-        self.assertEqual(sizeof(Z), sizeof(c_int))
-        self.assertEqual(X._fields_, [("a", c_int)])
-        self.assertEqual(Y._fields_, [("b", c_int)])
-        self.assertEqual(Z._fields_, [("a", c_int)])
-
-    def test_subclass_delayed(self):
-        class X(Structure):
-            pass
-        self.assertEqual(sizeof(X), 0)
-        X._fields_ = [("a", c_int)]
-
-        class Y(X):
-            pass
-        self.assertEqual(sizeof(Y), sizeof(X))
-        Y._fields_ = [("b", c_int)]
-
-        class Z(X):
-            pass
-
-        self.assertEqual(sizeof(X), sizeof(c_int))
-        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
-        self.assertEqual(sizeof(Z), sizeof(c_int))
-        self.assertEqual(X._fields_, [("a", c_int)])
-        self.assertEqual(Y._fields_, [("b", c_int)])
-        self.assertEqual(Z._fields_, [("a", c_int)])
-
-class StructureTestCase(unittest.TestCase):
-    formats = {"c": c_char,
-               "b": c_byte,
-               "B": c_ubyte,
-               "h": c_short,
-               "H": c_ushort,
-               "i": c_int,
-               "I": c_uint,
-               "l": c_long,
-               "L": c_ulong,
-               "q": c_longlong,
-               "Q": c_ulonglong,
-               "f": c_float,
-               "d": c_double,
-               }
-
-    def test_simple_structs(self):
-        for code, tp in self.formats.items():
-            class X(Structure):
-                _fields_ = [("x", c_char),
-                            ("y", tp)]
-            self.assertEqual((sizeof(X), code),
-                                 (calcsize("c%c0%c" % (code, code)), code))
-
-    def test_unions(self):
-        for code, tp in self.formats.items():
-            class X(Union):
-                _fields_ = [("x", c_char),
-                            ("y", tp)]
-            self.assertEqual((sizeof(X), code),
-                                 (calcsize("%c" % (code)), code))
-
-    def test_struct_alignment(self):
-        class X(Structure):
-            _fields_ = [("x", c_char * 3)]
-        self.assertEqual(alignment(X), calcsize("s"))
-        self.assertEqual(sizeof(X), calcsize("3s"))
-
-        class Y(Structure):
-            _fields_ = [("x", c_char * 3),
-                        ("y", c_int)]
-        self.assertEqual(alignment(Y), alignment(c_int))
-        self.assertEqual(sizeof(Y), calcsize("3si"))
-
-        class SI(Structure):
-            _fields_ = [("a", X),
-                        ("b", Y)]
-        self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
-        self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
-
-        class IS(Structure):
-            _fields_ = [("b", Y),
-                        ("a", X)]
-
-        self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
-        self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
-
-        class XX(Structure):
-            _fields_ = [("a", X),
-                        ("b", X)]
-        self.assertEqual(alignment(XX), alignment(X))
-        self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
-
-    def test_empty(self):
-        # I had problems with these
-        #
-        # Although these are pathological cases: Empty Structures!
-        class X(Structure):
-            _fields_ = []
-
-        class Y(Union):
-            _fields_ = []
-
-        # Is this really the correct alignment, or should it be 0?
-        self.assertTrue(alignment(X) == alignment(Y) == 1)
-        self.assertTrue(sizeof(X) == sizeof(Y) == 0)
-
-        class XX(Structure):
-            _fields_ = [("a", X),
-                        ("b", X)]
-
-        self.assertEqual(alignment(XX), 1)
-        self.assertEqual(sizeof(XX), 0)
-
-    def test_fields(self):
-        # test the offset and size attributes of Structure/Union fields.
-        class X(Structure):
-            _fields_ = [("x", c_int),
-                        ("y", c_char)]
-
-        self.assertEqual(X.x.offset, 0)
-        self.assertEqual(X.x.size, sizeof(c_int))
-
-        self.assertEqual(X.y.offset, sizeof(c_int))
-        self.assertEqual(X.y.size, sizeof(c_char))
-
-        # readonly
-        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
-        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
-
-        class X(Union):
-            _fields_ = [("x", c_int),
-                        ("y", c_char)]
-
-        self.assertEqual(X.x.offset, 0)
-        self.assertEqual(X.x.size, sizeof(c_int))
-
-        self.assertEqual(X.y.offset, 0)
-        self.assertEqual(X.y.size, sizeof(c_char))
-
-        # readonly
-        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
-        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
-
-        # XXX Should we check nested data types also?
-        # offset is always relative to the class...
-
-    def test_packed(self):
-        class X(Structure):
-            _fields_ = [("a", c_byte),
-                        ("b", c_longlong)]
-            _pack_ = 1
-
-        self.assertEqual(sizeof(X), 9)
-        self.assertEqual(X.b.offset, 1)
-
-        class X(Structure):
-            _fields_ = [("a", c_byte),
-                        ("b", c_longlong)]
-            _pack_ = 2
-        self.assertEqual(sizeof(X), 10)
-        self.assertEqual(X.b.offset, 2)
-
-        import struct
-        longlong_size = struct.calcsize("q")
-        longlong_align = struct.calcsize("bq") - longlong_size
-
-        class X(Structure):
-            _fields_ = [("a", c_byte),
-                        ("b", c_longlong)]
-            _pack_ = 4
-        self.assertEqual(sizeof(X), min(4, longlong_align) + longlong_size)
-        self.assertEqual(X.b.offset, min(4, longlong_align))
-
-        class X(Structure):
-            _fields_ = [("a", c_byte),
-                        ("b", c_longlong)]
-            _pack_ = 8
-
-        self.assertEqual(sizeof(X), min(8, longlong_align) + longlong_size)
-        self.assertEqual(X.b.offset, min(8, longlong_align))
-
-
-        d = {"_fields_": [("a", "b"),
-                          ("b", "q")],
-             "_pack_": -1}
-        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
-
-    @support.cpython_only
-    def test_packed_c_limits(self):
-        # Issue 15989
-        import _testcapi
-        d = {"_fields_": [("a", c_byte)],
-             "_pack_": _testcapi.INT_MAX + 1}
-        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
-        d = {"_fields_": [("a", c_byte)],
-             "_pack_": _testcapi.UINT_MAX + 2}
-        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
-
-    def test_initializers(self):
-        class Person(Structure):
-            _fields_ = [("name", c_char*6),
-                        ("age", c_int)]
-
-        self.assertRaises(TypeError, Person, 42)
-        self.assertRaises(ValueError, Person, b"asldkjaslkdjaslkdj")
-        self.assertRaises(TypeError, Person, "Name", "HI")
-
-        # short enough
-        self.assertEqual(Person(b"12345", 5).name, b"12345")
-        # exact fit
-        self.assertEqual(Person(b"123456", 5).name, b"123456")
-        # too long
-        self.assertRaises(ValueError, Person, b"1234567", 5)
-
-    def test_conflicting_initializers(self):
-        class POINT(Structure):
-            _fields_ = [("phi", c_float), ("rho", c_float)]
-        # conflicting positional and keyword args
-        self.assertRaisesRegex(TypeError, "phi", POINT, 2, 3, phi=4)
-        self.assertRaisesRegex(TypeError, "rho", POINT, 2, 3, rho=4)
-
-        # too many initializers
-        self.assertRaises(TypeError, POINT, 2, 3, 4)
-
-    def test_keyword_initializers(self):
-        class POINT(Structure):
-            _fields_ = [("x", c_int), ("y", c_int)]
-        pt = POINT(1, 2)
-        self.assertEqual((pt.x, pt.y), (1, 2))
-
-        pt = POINT(y=2, x=1)
-        self.assertEqual((pt.x, pt.y), (1, 2))
-
-    def test_invalid_field_types(self):
-        class POINT(Structure):
-            pass
-        self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
-
-    def test_invalid_name(self):
-        # field name must be string
-        def declare_with_name(name):
-            class S(Structure):
-                _fields_ = [(name, c_int)]
-
-        self.assertRaises(TypeError, declare_with_name, b"x")
-
-    def test_intarray_fields(self):
-        class SomeInts(Structure):
-            _fields_ = [("a", c_int * 4)]
-
-        # can use tuple to initialize array (but not list!)
-        self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
-        self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
-        self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
-        self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
-        self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
-        self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
-        self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
-        self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
-        # too long
-        # XXX Should raise ValueError?, not RuntimeError
-        self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
-
-    def test_nested_initializers(self):
-        # test initializing nested structures
-        class Phone(Structure):
-            _fields_ = [("areacode", c_char*6),
-                        ("number", c_char*12)]
-
-        class Person(Structure):
-            _fields_ = [("name", c_char * 12),
-                        ("phone", Phone),
-                        ("age", c_int)]
-
-        p = Person(b"Someone", (b"1234", b"5678"), 5)
-
-        self.assertEqual(p.name, b"Someone")
-        self.assertEqual(p.phone.areacode, b"1234")
-        self.assertEqual(p.phone.number, b"5678")
-        self.assertEqual(p.age, 5)
-
-    @need_symbol('c_wchar')
-    def test_structures_with_wchar(self):
-        class PersonW(Structure):
-            _fields_ = [("name", c_wchar * 12),
-                        ("age", c_int)]
-
-        p = PersonW("Someone \xe9")
-        self.assertEqual(p.name, "Someone \xe9")
-
-        self.assertEqual(PersonW("1234567890").name, "1234567890")
-        self.assertEqual(PersonW("12345678901").name, "12345678901")
-        # exact fit
-        self.assertEqual(PersonW("123456789012").name, "123456789012")
-        #too long
-        self.assertRaises(ValueError, PersonW, "1234567890123")
-
-    def test_init_errors(self):
-        class Phone(Structure):
-            _fields_ = [("areacode", c_char*6),
-                        ("number", c_char*12)]
-
-        class Person(Structure):
-            _fields_ = [("name", c_char * 12),
-                        ("phone", Phone),
-                        ("age", c_int)]
-
-        cls, msg = self.get_except(Person, b"Someone", (1, 2))
-        self.assertEqual(cls, RuntimeError)
-        self.assertEqual(msg,
-                             "(Phone) TypeError: "
-                             "expected bytes, int found")
-
-        cls, msg = self.get_except(Person, b"Someone", (b"a", b"b", b"c"))
-        self.assertEqual(cls, RuntimeError)
-        self.assertEqual(msg,
-                             "(Phone) TypeError: too many initializers")
-
-    def test_huge_field_name(self):
-        # issue12881: segfault with large structure field names
-        def create_class(length):
-            class S(Structure):
-                _fields_ = [('x' * length, c_int)]
-
-        for length in [10 ** i for i in range(0, 8)]:
-            try:
-                create_class(length)
-            except MemoryError:
-                # MemoryErrors are OK, we just don't want to segfault
-                pass
-
-    def get_except(self, func, *args):
-        try:
-            func(*args)
-        except Exception as detail:
-            return detail.__class__, str(detail)
-
-    @unittest.skip('test disabled')
-    def test_subclass_creation(self):
-        meta = type(Structure)
-        # same as 'class X(Structure): pass'
-        # fails, since we need either a _fields_ or a _abstract_ attribute
-        cls, msg = self.get_except(meta, "X", (Structure,), {})
-        self.assertEqual((cls, msg),
-                (AttributeError, "class must define a '_fields_' attribute"))
-
-    def test_abstract_class(self):
-        class X(Structure):
-            _abstract_ = "something"
-        # try 'X()'
-        cls, msg = self.get_except(eval, "X()", locals())
-        self.assertEqual((cls, msg), (TypeError, "abstract class"))
-
-    def test_methods(self):
-##        class X(Structure):
-##            _fields_ = []
-
-        self.assertIn("in_dll", dir(type(Structure)))
-        self.assertIn("from_address", dir(type(Structure)))
-        self.assertIn("in_dll", dir(type(Structure)))
-
-    def test_positional_args(self):
-        # see also http://bugs.python.org/issue5042
-        class W(Structure):
-            _fields_ = [("a", c_int), ("b", c_int)]
-        class X(W):
-            _fields_ = [("c", c_int)]
-        class Y(X):
-            pass
-        class Z(Y):
-            _fields_ = [("d", c_int), ("e", c_int), ("f", c_int)]
-
-        z = Z(1, 2, 3, 4, 5, 6)
-        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
-                         (1, 2, 3, 4, 5, 6))
-        z = Z(1)
-        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
-                         (1, 0, 0, 0, 0, 0))
-        self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
-
-    def test_pass_by_value(self):
-        # This should mirror the Test structure
-        # in Modules/_ctypes/_ctypes_test.c
-        class Test(Structure):
-            _fields_ = [
-                ('first', c_ulong),
-                ('second', c_ulong),
-                ('third', c_ulong),
-            ]
-
-        s = Test()
-        s.first = 0xdeadbeef
-        s.second = 0xcafebabe
-        s.third = 0x0bad1dea
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_large_struct_update_value
-        func.argtypes = (Test,)
-        func.restype = None
-        func(s)
-        self.assertEqual(s.first, 0xdeadbeef)
-        self.assertEqual(s.second, 0xcafebabe)
-        self.assertEqual(s.third, 0x0bad1dea)
-
-    def test_pass_by_value_finalizer(self):
-        # bpo-37140: Similar to test_pass_by_value(), but the Python structure
-        # has a finalizer (__del__() method): the finalizer must only be called
-        # once.
-
-        finalizer_calls = []
-
-        class Test(Structure):
-            _fields_ = [
-                ('first', c_ulong),
-                ('second', c_ulong),
-                ('third', c_ulong),
-            ]
-            def __del__(self):
-                finalizer_calls.append("called")
-
-        s = Test(1, 2, 3)
-        # Test the StructUnionType_paramfunc() code path which copies the
-        # structure: if the structure is larger than sizeof(void*).
-        self.assertGreater(sizeof(s), sizeof(c_void_p))
-
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_large_struct_update_value
-        func.argtypes = (Test,)
-        func.restype = None
-        func(s)
-        # bpo-37140: Passing the structure by reference must not call
-        # its finalizer!
-        self.assertEqual(finalizer_calls, [])
-        self.assertEqual(s.first, 1)
-        self.assertEqual(s.second, 2)
-        self.assertEqual(s.third, 3)
-
-        # The finalizer must be called exactly once
-        s = None
-        support.gc_collect()
-        self.assertEqual(finalizer_calls, ["called"])
-
-    def test_pass_by_value_in_register(self):
-        class X(Structure):
-            _fields_ = [
-                ('first', c_uint),
-                ('second', c_uint)
-            ]
-
-        s = X()
-        s.first = 0xdeadbeef
-        s.second = 0xcafebabe
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_reg_struct_update_value
-        func.argtypes = (X,)
-        func.restype = None
-        func(s)
-        self.assertEqual(s.first, 0xdeadbeef)
-        self.assertEqual(s.second, 0xcafebabe)
-        got = X.in_dll(dll, "last_tfrsuv_arg")
-        self.assertEqual(s.first, got.first)
-        self.assertEqual(s.second, got.second)
-
-    def test_array_in_struct(self):
-        # See bpo-22273
-
-        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
-        class Test2(Structure):
-            _fields_ = [
-                ('data', c_ubyte * 16),
-            ]
-
-        class Test3(Structure):
-            _fields_ = [
-                ('data', c_double * 2),
-            ]
-
-        class Test3A(Structure):
-            _fields_ = [
-                ('data', c_float * 2),
-            ]
-
-        class Test3B(Test3A):
-            _fields_ = [
-                ('more_data', c_float * 2),
-            ]
-
-        s = Test2()
-        expected = 0
-        for i in range(16):
-            s.data[i] = i
-            expected += i
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_array_in_struct1
-        func.restype = c_int
-        func.argtypes = (Test2,)
-        result = func(s)
-        self.assertEqual(result, expected)
-        # check the passed-in struct hasn't changed
-        for i in range(16):
-            self.assertEqual(s.data[i], i)
-
-        s = Test3()
-        s.data[0] = 3.14159
-        s.data[1] = 2.71828
-        expected = 3.14159 + 2.71828
-        func = dll._testfunc_array_in_struct2
-        func.restype = c_double
-        func.argtypes = (Test3,)
-        result = func(s)
-        self.assertEqual(result, expected)
-        # check the passed-in struct hasn't changed
-        self.assertEqual(s.data[0], 3.14159)
-        self.assertEqual(s.data[1], 2.71828)
-
-        s = Test3B()
-        s.data[0] = 3.14159
-        s.data[1] = 2.71828
-        s.more_data[0] = -3.0
-        s.more_data[1] = -2.0
-
-        expected = 3.14159 + 2.71828 - 5.0
-        func = dll._testfunc_array_in_struct2a
-        func.restype = c_double
-        func.argtypes = (Test3B,)
-        result = func(s)
-        self.assertAlmostEqual(result, expected, places=6)
-        # check the passed-in struct hasn't changed
-        self.assertAlmostEqual(s.data[0], 3.14159, places=6)
-        self.assertAlmostEqual(s.data[1], 2.71828, places=6)
-        self.assertAlmostEqual(s.more_data[0], -3.0, places=6)
-        self.assertAlmostEqual(s.more_data[1], -2.0, places=6)
-
-    def test_38368(self):
-        class U(Union):
-            _fields_ = [
-                ('f1', c_uint8 * 16),
-                ('f2', c_uint16 * 8),
-                ('f3', c_uint32 * 4),
-            ]
-        u = U()
-        u.f3[0] = 0x01234567
-        u.f3[1] = 0x89ABCDEF
-        u.f3[2] = 0x76543210
-        u.f3[3] = 0xFEDCBA98
-        f1 = [u.f1[i] for i in range(16)]
-        f2 = [u.f2[i] for i in range(8)]
-        if sys.byteorder == 'little':
-            self.assertEqual(f1, [0x67, 0x45, 0x23, 0x01,
-                                  0xef, 0xcd, 0xab, 0x89,
-                                  0x10, 0x32, 0x54, 0x76,
-                                  0x98, 0xba, 0xdc, 0xfe])
-            self.assertEqual(f2, [0x4567, 0x0123, 0xcdef, 0x89ab,
-                                  0x3210, 0x7654, 0xba98, 0xfedc])
-
-    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
-    def test_union_by_value(self):
-        # See bpo-16575
-
-        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
-
-        class Nested1(Structure):
-            _fields_ = [
-                ('an_int', c_int),
-                ('another_int', c_int),
-            ]
-
-        class Test4(Union):
-            _fields_ = [
-                ('a_long', c_long),
-                ('a_struct', Nested1),
-            ]
-
-        class Nested2(Structure):
-            _fields_ = [
-                ('an_int', c_int),
-                ('a_union', Test4),
-            ]
-
-        class Test5(Structure):
-            _fields_ = [
-                ('an_int', c_int),
-                ('nested', Nested2),
-                ('another_int', c_int),
-            ]
-
-        test4 = Test4()
-        dll = CDLL(_ctypes_test.__file__)
-        with self.assertRaises(TypeError) as ctx:
-            func = dll._testfunc_union_by_value1
-            func.restype = c_long
-            func.argtypes = (Test4,)
-            result = func(test4)
-        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
-                         'a union by value, which is unsupported.')
-        test5 = Test5()
-        with self.assertRaises(TypeError) as ctx:
-            func = dll._testfunc_union_by_value2
-            func.restype = c_long
-            func.argtypes = (Test5,)
-            result = func(test5)
-        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
-                         'a union by value, which is unsupported.')
-
-        # passing by reference should be OK
-        test4.a_long = 12345;
-        func = dll._testfunc_union_by_reference1
-        func.restype = c_long
-        func.argtypes = (POINTER(Test4),)
-        result = func(byref(test4))
-        self.assertEqual(result, 12345)
-        self.assertEqual(test4.a_long, 0)
-        self.assertEqual(test4.a_struct.an_int, 0)
-        self.assertEqual(test4.a_struct.another_int, 0)
-        test4.a_struct.an_int = 0x12340000
-        test4.a_struct.another_int = 0x5678
-        func = dll._testfunc_union_by_reference2
-        func.restype = c_long
-        func.argtypes = (POINTER(Test4),)
-        result = func(byref(test4))
-        self.assertEqual(result, 0x12345678)
-        self.assertEqual(test4.a_long, 0)
-        self.assertEqual(test4.a_struct.an_int, 0)
-        self.assertEqual(test4.a_struct.another_int, 0)
-        test5.an_int = 0x12000000
-        test5.nested.an_int = 0x345600
-        test5.another_int = 0x78
-        func = dll._testfunc_union_by_reference3
-        func.restype = c_long
-        func.argtypes = (POINTER(Test5),)
-        result = func(byref(test5))
-        self.assertEqual(result, 0x12345678)
-        self.assertEqual(test5.an_int, 0)
-        self.assertEqual(test5.nested.an_int, 0)
-        self.assertEqual(test5.another_int, 0)
-
-    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
-    def test_bitfield_by_value(self):
-        # See bpo-16576
-
-        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
-
-        class Test6(Structure):
-            _fields_ = [
-                ('A', c_int, 1),
-                ('B', c_int, 2),
-                ('C', c_int, 3),
-                ('D', c_int, 2),
-            ]
-
-        test6 = Test6()
-        # As these are signed int fields, all are logically -1 due to sign
-        # extension.
-        test6.A = 1
-        test6.B = 3
-        test6.C = 7
-        test6.D = 3
-        dll = CDLL(_ctypes_test.__file__)
-        with self.assertRaises(TypeError) as ctx:
-            func = dll._testfunc_bitfield_by_value1
-            func.restype = c_long
-            func.argtypes = (Test6,)
-            result = func(test6)
-        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
-                         'a struct/union with a bitfield by value, which is '
-                         'unsupported.')
-        # passing by reference should be OK
-        func = dll._testfunc_bitfield_by_reference1
-        func.restype = c_long
-        func.argtypes = (POINTER(Test6),)
-        result = func(byref(test6))
-        self.assertEqual(result, -4)
-        self.assertEqual(test6.A, 0)
-        self.assertEqual(test6.B, 0)
-        self.assertEqual(test6.C, 0)
-        self.assertEqual(test6.D, 0)
-
-        class Test7(Structure):
-            _fields_ = [
-                ('A', c_uint, 1),
-                ('B', c_uint, 2),
-                ('C', c_uint, 3),
-                ('D', c_uint, 2),
-            ]
-        test7 = Test7()
-        test7.A = 1
-        test7.B = 3
-        test7.C = 7
-        test7.D = 3
-        func = dll._testfunc_bitfield_by_reference2
-        func.restype = c_long
-        func.argtypes = (POINTER(Test7),)
-        result = func(byref(test7))
-        self.assertEqual(result, 14)
-        self.assertEqual(test7.A, 0)
-        self.assertEqual(test7.B, 0)
-        self.assertEqual(test7.C, 0)
-        self.assertEqual(test7.D, 0)
-
-        # for a union with bitfields, the union check happens first
-        class Test8(Union):
-            _fields_ = [
-                ('A', c_int, 1),
-                ('B', c_int, 2),
-                ('C', c_int, 3),
-                ('D', c_int, 2),
-            ]
-
-        test8 = Test8()
-        with self.assertRaises(TypeError) as ctx:
-            func = dll._testfunc_bitfield_by_value2
-            func.restype = c_long
-            func.argtypes = (Test8,)
-            result = func(test8)
-        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
-                         'a union by value, which is unsupported.')
-
-class PointerMemberTestCase(unittest.TestCase):
-
-    def test(self):
-        # a Structure with a POINTER field
-        class S(Structure):
-            _fields_ = [("array", POINTER(c_int))]
-
-        s = S()
-        # We can assign arrays of the correct type
-        s.array = (c_int * 3)(1, 2, 3)
-        items = [s.array[i] for i in range(3)]
-        self.assertEqual(items, [1, 2, 3])
-
-        # The following are bugs, but are included here because the unittests
-        # also describe the current behaviour.
-        #
-        # This fails with SystemError: bad arg to internal function
-        # or with IndexError (with a patch I have)
-
-        s.array[0] = 42
-
-        items = [s.array[i] for i in range(3)]
-        self.assertEqual(items, [42, 2, 3])
-
-        s.array[0] = 1
-
-##        s.array[1] = 42
-
-        items = [s.array[i] for i in range(3)]
-        self.assertEqual(items, [1, 2, 3])
-
-    def test_none_to_pointer_fields(self):
-        class S(Structure):
-            _fields_ = [("x", c_int),
-                        ("p", POINTER(c_int))]
-
-        s = S()
-        s.x = 12345678
-        s.p = None
-        self.assertEqual(s.x, 12345678)
-
-class TestRecursiveStructure(unittest.TestCase):
-    def test_contains_itself(self):
-        class Recursive(Structure):
-            pass
-
-        try:
-            Recursive._fields_ = [("next", Recursive)]
-        except AttributeError as details:
-            self.assertIn("Structure or union cannot contain itself",
-                          str(details))
-        else:
-            self.fail("Structure or union cannot contain itself")
-
-
-    def test_vice_versa(self):
-        class First(Structure):
-            pass
-        class Second(Structure):
-            pass
-
-        First._fields_ = [("second", Second)]
-
-        try:
-            Second._fields_ = [("first", First)]
-        except AttributeError as details:
-            self.assertIn("_fields_ is final", str(details))
-        else:
-            self.fail("AttributeError not raised")
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_unaligned_structures.py b/Lib/ctypes/test/test_unaligned_structures.py
deleted file mode 100644
index ee7fb45809b..00000000000
--- a/Lib/ctypes/test/test_unaligned_structures.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import sys, unittest
-from ctypes import *
-
-structures = []
-byteswapped_structures = []
-
-
-if sys.byteorder == "little":
-    SwappedStructure = BigEndianStructure
-else:
-    SwappedStructure = LittleEndianStructure
-
-for typ in [c_short, c_int, c_long, c_longlong,
-            c_float, c_double,
-            c_ushort, c_uint, c_ulong, c_ulonglong]:
-    class X(Structure):
-        _pack_ = 1
-        _fields_ = [("pad", c_byte),
-                    ("value", typ)]
-    class Y(SwappedStructure):
-        _pack_ = 1
-        _fields_ = [("pad", c_byte),
-                    ("value", typ)]
-    structures.append(X)
-    byteswapped_structures.append(Y)
-
-class TestStructures(unittest.TestCase):
-    def test_native(self):
-        for typ in structures:
-            self.assertEqual(typ.value.offset, 1)
-            o = typ()
-            o.value = 4
-            self.assertEqual(o.value, 4)
-
-    def test_swapped(self):
-        for typ in byteswapped_structures:
-            self.assertEqual(typ.value.offset, 1)
-            o = typ()
-            o.value = 4
-            self.assertEqual(o.value, 4)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_unicode.py b/Lib/ctypes/test/test_unicode.py
deleted file mode 100644
index 60c75424b76..00000000000
--- a/Lib/ctypes/test/test_unicode.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import unittest
-import ctypes
-from ctypes.test import need_symbol
-
-import _ctypes_test
-
-@need_symbol('c_wchar')
-class UnicodeTestCase(unittest.TestCase):
-    def test_wcslen(self):
-        dll = ctypes.CDLL(_ctypes_test.__file__)
-        wcslen = dll.my_wcslen
-        wcslen.argtypes = [ctypes.c_wchar_p]
-
-        self.assertEqual(wcslen("abc"), 3)
-        self.assertEqual(wcslen("ab\u2070"), 3)
-        self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
-
-    def test_buffers(self):
-        buf = ctypes.create_unicode_buffer("abc")
-        self.assertEqual(len(buf), 3+1)
-
-        buf = ctypes.create_unicode_buffer("ab\xe4\xf6\xfc")
-        self.assertEqual(buf[:], "ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::], "ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::-1], '\x00\xfc\xf6\xe4ba')
-        self.assertEqual(buf[::2], 'a\xe4\xfc')
-        self.assertEqual(buf[6:5:-1], "")
-
-    def test_embedded_null(self):
-        class TestStruct(ctypes.Structure):
-            _fields_ = [("unicode", ctypes.c_wchar_p)]
-        t = TestStruct()
-        # This would raise a ValueError:
-        t.unicode = "foo\0bar\0\0"
-
-
-func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
-
-class StringTestCase(UnicodeTestCase):
-    def setUp(self):
-        func.argtypes = [ctypes.c_char_p]
-        func.restype = ctypes.c_char_p
-
-    def tearDown(self):
-        func.argtypes = None
-        func.restype = ctypes.c_int
-
-    def test_func(self):
-        self.assertEqual(func(b"abc\xe4"), b"abc\xe4")
-
-    def test_buffers(self):
-        buf = ctypes.create_string_buffer(b"abc")
-        self.assertEqual(len(buf), 3+1)
-
-        buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc")
-        self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::-1], b'\x00\xfc\xf6\xe4ba')
-        self.assertEqual(buf[::2], b'a\xe4\xfc')
-        self.assertEqual(buf[6:5:-1], b"")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_values.py b/Lib/ctypes/test/test_values.py
deleted file mode 100644
index 435fdd22ea2..00000000000
--- a/Lib/ctypes/test/test_values.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""
-A testcase which accesses *values* in a dll.
-"""
-
-import _imp
-import importlib.util
-import unittest
-import sys
-from ctypes import *
-from test.support import import_helper
-
-import _ctypes_test
-
-class ValuesTestCase(unittest.TestCase):
-
-    def test_an_integer(self):
-        # This test checks and changes an integer stored inside the
-        # _ctypes_test dll/shared lib.
-        ctdll = CDLL(_ctypes_test.__file__)
-        an_integer = c_int.in_dll(ctdll, "an_integer")
-        x = an_integer.value
-        self.assertEqual(x, ctdll.get_an_integer())
-        an_integer.value *= 2
-        self.assertEqual(x*2, ctdll.get_an_integer())
-        # To avoid test failures when this test is repeated several
-        # times the original value must be restored
-        an_integer.value = x
-        self.assertEqual(x, ctdll.get_an_integer())
-
-    def test_undefined(self):
-        ctdll = CDLL(_ctypes_test.__file__)
-        self.assertRaises(ValueError, c_int.in_dll, ctdll, "Undefined_Symbol")
-
-class PythonValuesTestCase(unittest.TestCase):
-    """This test only works when python itself is a dll/shared library"""
-
-    def test_optimizeflag(self):
-        # This test accesses the Py_OptimizeFlag integer, which is
-        # exported by the Python dll and should match the sys.flags value
-
-        opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
-        self.assertEqual(opt, sys.flags.optimize)
-
-    def test_frozentable(self):
-        # Python exports a PyImport_FrozenModules symbol. This is a
-        # pointer to an array of struct _frozen entries.  The end of the
-        # array is marked by an entry containing a NULL name and zero
-        # size.
-
-        # In standard Python, this table contains a __hello__
-        # module, and a __phello__ package containing a spam
-        # module.
-        class struct_frozen(Structure):
-            _fields_ = [("name", c_char_p),
-                        ("code", POINTER(c_ubyte)),
-                        ("size", c_int),
-                        ("is_package", c_int),
-                        ("get_code", POINTER(c_ubyte)),  # Function ptr
-                        ]
-        FrozenTable = POINTER(struct_frozen)
-
-        modules = []
-        for group in ["Bootstrap", "Stdlib", "Test"]:
-            ft = FrozenTable.in_dll(pythonapi, f"_PyImport_Frozen{group}")
-            # ft is a pointer to the struct_frozen entries:
-            for entry in ft:
-                # This is dangerous. We *can* iterate over a pointer, but
-                # the loop will not terminate (maybe with an access
-                # violation;-) because the pointer instance has no size.
-                if entry.name is None:
-                    break
-                modname = entry.name.decode("ascii")
-                modules.append(modname)
-                with self.subTest(modname):
-                    if entry.size != 0:
-                        # Do a sanity check on entry.size and entry.code.
-                        self.assertGreater(abs(entry.size), 10)
-                        self.assertTrue([entry.code[i] for i in range(abs(entry.size))])
-                    # Check the module's package-ness.
-                    with import_helper.frozen_modules():
-                        spec = importlib.util.find_spec(modname)
-                    if entry.is_package:
-                        # It's a package.
-                        self.assertIsNotNone(spec.submodule_search_locations)
-                    else:
-                        self.assertIsNone(spec.submodule_search_locations)
-
-        with import_helper.frozen_modules():
-            expected = _imp._frozen_module_names()
-        self.maxDiff = None
-        self.assertEqual(modules, expected,
-                         "_PyImport_FrozenBootstrap example "
-                         "in Doc/library/ctypes.rst may be out of date")
-
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[struct_frozen]
-
-    def test_undefined(self):
-        self.assertRaises(ValueError, c_int.in_dll, pythonapi,
-                          "Undefined_Symbol")
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_varsize_struct.py b/Lib/ctypes/test/test_varsize_struct.py
deleted file mode 100644
index f409500f013..00000000000
--- a/Lib/ctypes/test/test_varsize_struct.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from ctypes import *
-import unittest
-
-class VarSizeTest(unittest.TestCase):
-    def test_resize(self):
-        class X(Structure):
-            _fields_ = [("item", c_int),
-                        ("array", c_int * 1)]
-
-        self.assertEqual(sizeof(X), sizeof(c_int) * 2)
-        x = X()
-        x.item = 42
-        x.array[0] = 100
-        self.assertEqual(sizeof(x), sizeof(c_int) * 2)
-
-        # make room for one additional item
-        new_size = sizeof(X) + sizeof(c_int) * 1
-        resize(x, new_size)
-        self.assertEqual(sizeof(x), new_size)
-        self.assertEqual((x.item, x.array[0]), (42, 100))
-
-        # make room for 10 additional items
-        new_size = sizeof(X) + sizeof(c_int) * 9
-        resize(x, new_size)
-        self.assertEqual(sizeof(x), new_size)
-        self.assertEqual((x.item, x.array[0]), (42, 100))
-
-        # make room for one additional item
-        new_size = sizeof(X) + sizeof(c_int) * 1
-        resize(x, new_size)
-        self.assertEqual(sizeof(x), new_size)
-        self.assertEqual((x.item, x.array[0]), (42, 100))
-
-    def test_array_invalid_length(self):
-        # cannot create arrays with non-positive size
-        self.assertRaises(ValueError, lambda: c_int * -1)
-        self.assertRaises(ValueError, lambda: c_int * -3)
-
-    def test_zerosized_array(self):
-        array = (c_int * 0)()
-        # accessing elements of zero-sized arrays raise IndexError
-        self.assertRaises(IndexError, array.__setitem__, 0, None)
-        self.assertRaises(IndexError, array.__getitem__, 0)
-        self.assertRaises(IndexError, array.__setitem__, 1, None)
-        self.assertRaises(IndexError, array.__getitem__, 1)
-        self.assertRaises(IndexError, array.__setitem__, -1, None)
-        self.assertRaises(IndexError, array.__getitem__, -1)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_win32.py b/Lib/ctypes/test/test_win32.py
deleted file mode 100644
index e51bdc8ad6b..00000000000
--- a/Lib/ctypes/test/test_win32.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# Windows specific tests
-
-from ctypes import *
-import unittest, sys
-from test import support
-
-import _ctypes_test
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class FunctionCallTestCase(unittest.TestCase):
-    @unittest.skipUnless('MSC' in sys.version, "SEH only supported by MSC")
-    @unittest.skipIf(sys.executable.lower().endswith('_d.exe'),
-                     "SEH not enabled in debug builds")
-    def test_SEH(self):
-        # Disable faulthandler to prevent logging the warning:
-        # "Windows fatal exception: access violation"
-        with support.disable_faulthandler():
-            # Call functions with invalid arguments, and make sure
-            # that access violations are trapped and raise an
-            # exception.
-            self.assertRaises(OSError, windll.kernel32.GetModuleHandleA, 32)
-
-    def test_noargs(self):
-        # This is a special case on win32 x64
-        windll.user32.GetDesktopWindow()
-
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class ReturnStructSizesTestCase(unittest.TestCase):
-    def test_sizes(self):
-        dll = CDLL(_ctypes_test.__file__)
-        for i in range(1, 11):
-            fields = [ (f"f{f}", c_char) for f in range(1, i + 1)]
-            class S(Structure):
-                _fields_ = fields
-            f = getattr(dll, f"TestSize{i}")
-            f.restype = S
-            res = f()
-            for i, f in enumerate(fields):
-                value = getattr(res, f[0])
-                expected = bytes([ord('a') + i])
-                self.assertEqual(value, expected)
-
-
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class TestWintypes(unittest.TestCase):
-    def test_HWND(self):
-        from ctypes import wintypes
-        self.assertEqual(sizeof(wintypes.HWND), sizeof(c_void_p))
-
-    def test_PARAM(self):
-        from ctypes import wintypes
-        self.assertEqual(sizeof(wintypes.WPARAM),
-                             sizeof(c_void_p))
-        self.assertEqual(sizeof(wintypes.LPARAM),
-                             sizeof(c_void_p))
-
-    def test_COMError(self):
-        from _ctypes import COMError
-        if support.HAVE_DOCSTRINGS:
-            self.assertEqual(COMError.__doc__,
-                             "Raised when a COM method call failed.")
-
-        ex = COMError(-1, "text", ("details",))
-        self.assertEqual(ex.hresult, -1)
-        self.assertEqual(ex.text, "text")
-        self.assertEqual(ex.details, ("details",))
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class TestWinError(unittest.TestCase):
-    def test_winerror(self):
-        # see Issue 16169
-        import errno
-        ERROR_INVALID_PARAMETER = 87
-        msg = FormatError(ERROR_INVALID_PARAMETER).strip()
-        args = (errno.EINVAL, msg, None, ERROR_INVALID_PARAMETER)
-
-        e = WinError(ERROR_INVALID_PARAMETER)
-        self.assertEqual(e.args, args)
-        self.assertEqual(e.errno, errno.EINVAL)
-        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
-
-        windll.kernel32.SetLastError(ERROR_INVALID_PARAMETER)
-        try:
-            raise WinError()
-        except OSError as exc:
-            e = exc
-        self.assertEqual(e.args, args)
-        self.assertEqual(e.errno, errno.EINVAL)
-        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
-
-class Structures(unittest.TestCase):
-    def test_struct_by_value(self):
-        class POINT(Structure):
-            _fields_ = [("x", c_long),
-                        ("y", c_long)]
-
-        class RECT(Structure):
-            _fields_ = [("left", c_long),
-                        ("top", c_long),
-                        ("right", c_long),
-                        ("bottom", c_long)]
-
-        dll = CDLL(_ctypes_test.__file__)
-
-        pt = POINT(15, 25)
-        left = c_long.in_dll(dll, 'left')
-        top = c_long.in_dll(dll, 'top')
-        right = c_long.in_dll(dll, 'right')
-        bottom = c_long.in_dll(dll, 'bottom')
-        rect = RECT(left, top, right, bottom)
-        PointInRect = dll.PointInRect
-        PointInRect.argtypes = [POINTER(RECT), POINT]
-        self.assertEqual(1, PointInRect(byref(rect), pt))
-
-        ReturnRect = dll.ReturnRect
-        ReturnRect.argtypes = [c_int, RECT, POINTER(RECT), POINT, RECT,
-                               POINTER(RECT), POINT, RECT]
-        ReturnRect.restype = RECT
-        for i in range(4):
-            ret = ReturnRect(i, rect, pointer(rect), pt, rect,
-                         byref(rect), pt, rect)
-            # the c function will check and modify ret if something is
-            # passed in improperly
-            self.assertEqual(ret.left, left.value)
-            self.assertEqual(ret.right, right.value)
-            self.assertEqual(ret.top, top.value)
-            self.assertEqual(ret.bottom, bottom.value)
-
-        # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[RECT]
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_wintypes.py b/Lib/ctypes/test/test_wintypes.py
deleted file mode 100644
index 243d5962ffa..00000000000
--- a/Lib/ctypes/test/test_wintypes.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import unittest
-
-# also work on POSIX
-
-from ctypes import *
-from ctypes import wintypes
-
-
-class WinTypesTest(unittest.TestCase):
-    def test_variant_bool(self):
-        # reads 16-bits from memory, anything non-zero is True
-        for true_value in (1, 32767, 32768, 65535, 65537):
-            true = POINTER(c_int16)(c_int16(true_value))
-            value = cast(true, POINTER(wintypes.VARIANT_BOOL))
-            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(True)')
-
-            vb = wintypes.VARIANT_BOOL()
-            self.assertIs(vb.value, False)
-            vb.value = True
-            self.assertIs(vb.value, True)
-            vb.value = true_value
-            self.assertIs(vb.value, True)
-
-        for false_value in (0, 65536, 262144, 2**33):
-            false = POINTER(c_int16)(c_int16(false_value))
-            value = cast(false, POINTER(wintypes.VARIANT_BOOL))
-            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(False)')
-
-        # allow any bool conversion on assignment to value
-        for set_value in (65536, 262144, 2**33):
-            vb = wintypes.VARIANT_BOOL()
-            vb.value = set_value
-            self.assertIs(vb.value, True)
-
-        vb = wintypes.VARIANT_BOOL()
-        vb.value = [2, 3]
-        self.assertIs(vb.value, True)
-        vb.value = []
-        self.assertIs(vb.value, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py
index 0c2510e1619..117bf06cb01 100644
--- a/Lib/ctypes/util.py
+++ b/Lib/ctypes/util.py
@@ -67,7 +67,7 @@ def find_library(name):
                 return fname
         return None
 
-elif os.name == "posix" and sys.platform == "darwin":
+elif os.name == "posix" and sys.platform in {"darwin", "ios", "tvos", "watchos"}:
     from ctypes.macholib.dyld import dyld_find as _dyld_find
     def find_library(name):
         possible = ['lib%s.dylib' % name,
@@ -89,6 +89,15 @@ def find_library(name):
 
     from ctypes._aix import find_library
 
+elif sys.platform == "android":
+    def find_library(name):
+        directory = "/system/lib"
+        if "64" in os.uname().machine:
+            directory += "64"
+
+        fname = f"{directory}/lib{name}.so"
+        return fname if os.path.isfile(fname) else None
+
 elif os.name == "posix":
     # Andreas Degert's find functions, using gcc, /sbin/ldconfig, objdump
     import re, tempfile
@@ -96,8 +105,11 @@ def find_library(name):
     def _is_elf(filename):
         "Return True if the given file is an ELF file"
         elf_header = b'\x7fELF'
-        with open(filename, 'br') as thefile:
-            return thefile.read(4) == elf_header
+        try:
+            with open(filename, 'br') as thefile:
+                return thefile.read(4) == elf_header
+        except FileNotFoundError:
+            return False
 
     def _findLib_gcc(name):
         # Run GCC's linker with the -t (aka --trace) option and examine the

From 7e6e0f66c8b1ffb63b45f778c7e2b1857eaaa9e1 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sat, 20 Dec 2025 14:32:07 +0900
Subject: [PATCH 037/418] test_ctypes from CPython 3.13.11

---
 Lib/test/test_ctypes.py                       |  10 -
 Lib/test/test_ctypes/__init__.py              |  10 +
 Lib/test/test_ctypes/__main__.py              |   4 +
 Lib/test/test_ctypes/_support.py              |  24 +
 .../test_ctypes/test_aligned_structures.py    | 321 ++++++
 Lib/test/test_ctypes/test_anon.py             |  75 ++
 Lib/test/test_ctypes/test_array_in_pointer.py |  68 ++
 Lib/test/test_ctypes/test_arrays.py           | 272 +++++
 Lib/test/test_ctypes/test_as_parameter.py     | 245 +++++
 Lib/test/test_ctypes/test_bitfields.py        | 294 ++++++
 Lib/test/test_ctypes/test_buffers.py          |  70 ++
 Lib/test/test_ctypes/test_bytes.py            |  67 ++
 Lib/test/test_ctypes/test_byteswap.py         | 386 +++++++
 .../test_ctypes/test_c_simple_type_meta.py    | 152 +++
 Lib/test/test_ctypes/test_callbacks.py        | 333 ++++++
 Lib/test/test_ctypes/test_cast.py             | 100 ++
 Lib/test/test_ctypes/test_cfuncs.py           | 211 ++++
 Lib/test/test_ctypes/test_checkretval.py      |  37 +
 Lib/test/test_ctypes/test_delattr.py          |  26 +
 Lib/test/test_ctypes/test_dlerror.py          | 179 ++++
 Lib/test/test_ctypes/test_errno.py            |  81 ++
 Lib/test/test_ctypes/test_find.py             | 156 +++
 Lib/test/test_ctypes/test_frombuffer.py       | 144 +++
 Lib/test/test_ctypes/test_funcptr.py          | 134 +++
 Lib/test/test_ctypes/test_functions.py        | 454 +++++++++
 Lib/test/test_ctypes/test_incomplete.py       |  50 +
 Lib/test/test_ctypes/test_init.py             |  43 +
 Lib/test/test_ctypes/test_internals.py        |  97 ++
 Lib/test/test_ctypes/test_keeprefs.py         | 124 +++
 Lib/test/test_ctypes/test_libc.py             |  38 +
 Lib/test/test_ctypes/test_loading.py          | 208 ++++
 Lib/test/test_ctypes/test_macholib.py         | 112 ++
 Lib/test/test_ctypes/test_memfunctions.py     |  82 ++
 Lib/test/test_ctypes/test_numbers.py          | 200 ++++
 Lib/test/test_ctypes/test_objects.py          |  66 ++
 Lib/test/test_ctypes/test_parameters.py       | 288 ++++++
 Lib/test/test_ctypes/test_pep3118.py          | 250 +++++
 Lib/test/test_ctypes/test_pickling.py         |  91 ++
 Lib/test/test_ctypes/test_pointers.py         | 240 +++++
 Lib/test/test_ctypes/test_prototypes.py       | 252 +++++
 Lib/test/test_ctypes/test_python_api.py       |  81 ++
 Lib/test/test_ctypes/test_random_things.py    |  81 ++
 Lib/test/test_ctypes/test_refcounts.py        | 143 +++
 Lib/test/test_ctypes/test_repr.py             |  34 +
 Lib/test/test_ctypes/test_returnfuncptrs.py   |  67 ++
 Lib/test/test_ctypes/test_simplesubclasses.py |  96 ++
 Lib/test/test_ctypes/test_sizes.py            |  38 +
 Lib/test/test_ctypes/test_slicing.py          | 170 ++++
 Lib/test/test_ctypes/test_stringptr.py        |  81 ++
 Lib/test/test_ctypes/test_strings.py          | 134 +++
 Lib/test/test_ctypes/test_struct_fields.py    | 126 +++
 Lib/test/test_ctypes/test_structures.py       | 956 ++++++++++++++++++
 .../test_ctypes/test_unaligned_structures.py  |  49 +
 Lib/test/test_ctypes/test_unicode.py          |  63 ++
 Lib/test/test_ctypes/test_unions.py           |  35 +
 Lib/test/test_ctypes/test_values.py           | 107 ++
 Lib/test/test_ctypes/test_varsize_struct.py   |  52 +
 Lib/test/test_ctypes/test_win32.py            | 152 +++
 .../test_win32_com_foreign_func.py            | 286 ++++++
 Lib/test/test_ctypes/test_wintypes.py         |  61 ++
 60 files changed, 8796 insertions(+), 10 deletions(-)
 delete mode 100644 Lib/test/test_ctypes.py
 create mode 100644 Lib/test/test_ctypes/__init__.py
 create mode 100644 Lib/test/test_ctypes/__main__.py
 create mode 100644 Lib/test/test_ctypes/_support.py
 create mode 100644 Lib/test/test_ctypes/test_aligned_structures.py
 create mode 100644 Lib/test/test_ctypes/test_anon.py
 create mode 100644 Lib/test/test_ctypes/test_array_in_pointer.py
 create mode 100644 Lib/test/test_ctypes/test_arrays.py
 create mode 100644 Lib/test/test_ctypes/test_as_parameter.py
 create mode 100644 Lib/test/test_ctypes/test_bitfields.py
 create mode 100644 Lib/test/test_ctypes/test_buffers.py
 create mode 100644 Lib/test/test_ctypes/test_bytes.py
 create mode 100644 Lib/test/test_ctypes/test_byteswap.py
 create mode 100644 Lib/test/test_ctypes/test_c_simple_type_meta.py
 create mode 100644 Lib/test/test_ctypes/test_callbacks.py
 create mode 100644 Lib/test/test_ctypes/test_cast.py
 create mode 100644 Lib/test/test_ctypes/test_cfuncs.py
 create mode 100644 Lib/test/test_ctypes/test_checkretval.py
 create mode 100644 Lib/test/test_ctypes/test_delattr.py
 create mode 100644 Lib/test/test_ctypes/test_dlerror.py
 create mode 100644 Lib/test/test_ctypes/test_errno.py
 create mode 100644 Lib/test/test_ctypes/test_find.py
 create mode 100644 Lib/test/test_ctypes/test_frombuffer.py
 create mode 100644 Lib/test/test_ctypes/test_funcptr.py
 create mode 100644 Lib/test/test_ctypes/test_functions.py
 create mode 100644 Lib/test/test_ctypes/test_incomplete.py
 create mode 100644 Lib/test/test_ctypes/test_init.py
 create mode 100644 Lib/test/test_ctypes/test_internals.py
 create mode 100644 Lib/test/test_ctypes/test_keeprefs.py
 create mode 100644 Lib/test/test_ctypes/test_libc.py
 create mode 100644 Lib/test/test_ctypes/test_loading.py
 create mode 100644 Lib/test/test_ctypes/test_macholib.py
 create mode 100644 Lib/test/test_ctypes/test_memfunctions.py
 create mode 100644 Lib/test/test_ctypes/test_numbers.py
 create mode 100644 Lib/test/test_ctypes/test_objects.py
 create mode 100644 Lib/test/test_ctypes/test_parameters.py
 create mode 100644 Lib/test/test_ctypes/test_pep3118.py
 create mode 100644 Lib/test/test_ctypes/test_pickling.py
 create mode 100644 Lib/test/test_ctypes/test_pointers.py
 create mode 100644 Lib/test/test_ctypes/test_prototypes.py
 create mode 100644 Lib/test/test_ctypes/test_python_api.py
 create mode 100644 Lib/test/test_ctypes/test_random_things.py
 create mode 100644 Lib/test/test_ctypes/test_refcounts.py
 create mode 100644 Lib/test/test_ctypes/test_repr.py
 create mode 100644 Lib/test/test_ctypes/test_returnfuncptrs.py
 create mode 100644 Lib/test/test_ctypes/test_simplesubclasses.py
 create mode 100644 Lib/test/test_ctypes/test_sizes.py
 create mode 100644 Lib/test/test_ctypes/test_slicing.py
 create mode 100644 Lib/test/test_ctypes/test_stringptr.py
 create mode 100644 Lib/test/test_ctypes/test_strings.py
 create mode 100644 Lib/test/test_ctypes/test_struct_fields.py
 create mode 100644 Lib/test/test_ctypes/test_structures.py
 create mode 100644 Lib/test/test_ctypes/test_unaligned_structures.py
 create mode 100644 Lib/test/test_ctypes/test_unicode.py
 create mode 100644 Lib/test/test_ctypes/test_unions.py
 create mode 100644 Lib/test/test_ctypes/test_values.py
 create mode 100644 Lib/test/test_ctypes/test_varsize_struct.py
 create mode 100644 Lib/test/test_ctypes/test_win32.py
 create mode 100644 Lib/test/test_ctypes/test_win32_com_foreign_func.py
 create mode 100644 Lib/test/test_ctypes/test_wintypes.py

diff --git a/Lib/test/test_ctypes.py b/Lib/test/test_ctypes.py
deleted file mode 100644
index b0a12c97347..00000000000
--- a/Lib/test/test_ctypes.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import unittest
-from test.support.import_helper import import_module
-
-
-ctypes_test = import_module('ctypes.test')
-
-load_tests = ctypes_test.load_tests
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_ctypes/__init__.py b/Lib/test/test_ctypes/__init__.py
new file mode 100644
index 00000000000..eb9126cbe18
--- /dev/null
+++ b/Lib/test/test_ctypes/__init__.py
@@ -0,0 +1,10 @@
+import os
+from test import support
+from test.support import import_helper
+
+
+# skip tests if the _ctypes extension was not built
+import_helper.import_module('ctypes')
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_ctypes/__main__.py b/Lib/test/test_ctypes/__main__.py
new file mode 100644
index 00000000000..3003d4db890
--- /dev/null
+++ b/Lib/test/test_ctypes/__main__.py
@@ -0,0 +1,4 @@
+from test.test_ctypes import load_tests
+import unittest
+
+unittest.main()
diff --git a/Lib/test/test_ctypes/_support.py b/Lib/test/test_ctypes/_support.py
new file mode 100644
index 00000000000..e4c2b33825a
--- /dev/null
+++ b/Lib/test/test_ctypes/_support.py
@@ -0,0 +1,24 @@
+# Some classes and types are not export to _ctypes module directly.
+
+import ctypes
+from _ctypes import Structure, Union, _Pointer, Array, _SimpleCData, CFuncPtr
+
+
+_CData = Structure.__base__
+assert _CData.__name__ == "_CData"
+
+class _X(Structure):
+    _fields_ = [("x", ctypes.c_int)]
+CField = type(_X.x)
+
+# metaclasses
+PyCStructType = type(Structure)
+UnionType = type(Union)
+PyCPointerType = type(_Pointer)
+PyCArrayType = type(Array)
+PyCSimpleType = type(_SimpleCData)
+PyCFuncPtrType = type(CFuncPtr)
+
+# type flags
+Py_TPFLAGS_DISALLOW_INSTANTIATION = 1 << 7
+Py_TPFLAGS_IMMUTABLETYPE = 1 << 8
diff --git a/Lib/test/test_ctypes/test_aligned_structures.py b/Lib/test/test_ctypes/test_aligned_structures.py
new file mode 100644
index 00000000000..8e8ac429900
--- /dev/null
+++ b/Lib/test/test_ctypes/test_aligned_structures.py
@@ -0,0 +1,321 @@
+from ctypes import (
+    c_char, c_uint32, c_uint16, c_ubyte, c_byte, alignment, sizeof,
+    BigEndianStructure, LittleEndianStructure,
+    BigEndianUnion, LittleEndianUnion, Structure
+)
+import struct
+import unittest
+
+
+class TestAlignedStructures(unittest.TestCase):
+    def test_aligned_string(self):
+        for base, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data =  bytearray(struct.pack(f"{e}i12x16s", 7, b"hello world!"))
+            class Aligned(base):
+                _align_ = 16
+                _fields_ = [
+                    ('value', c_char * 12)
+                ]
+
+            class Main(base):
+                _fields_ = [
+                    ('first', c_uint32),
+                    ('string', Aligned),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.first, 7)
+            self.assertEqual(main.string.value, b'hello world!')
+            self.assertEqual(bytes(main.string), b'hello world!\0\0\0\0')
+            self.assertEqual(Main.string.offset, 16)
+            self.assertEqual(Main.string.size, 16)
+            self.assertEqual(alignment(main.string), 16)
+            self.assertEqual(alignment(main), 16)
+
+    def test_aligned_structures(self):
+        for base, data in (
+            (LittleEndianStructure, bytearray(b"\1\0\0\0\1\0\0\0\7\0\0\0")),
+            (BigEndianStructure, bytearray(b"\1\0\0\0\1\0\0\0\7\0\0\0")),
+        ):
+            class SomeBools(base):
+                _align_ = 4
+                _fields_ = [
+                    ("bool1", c_ubyte),
+                    ("bool2", c_ubyte),
+                ]
+            class Main(base):
+                _fields_ = [
+                    ("x", c_ubyte),
+                    ("y", SomeBools),
+                    ("z", c_ubyte),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(SomeBools), 4)
+            self.assertEqual(alignment(main), 4)
+            self.assertEqual(alignment(main.y), 4)
+            self.assertEqual(Main.x.size, 1)
+            self.assertEqual(Main.y.offset, 4)
+            self.assertEqual(Main.y.size, 4)
+            self.assertEqual(main.y.bool1, True)
+            self.assertEqual(main.y.bool2, False)
+            self.assertEqual(Main.z.offset, 8)
+            self.assertEqual(main.z, 7)
+
+    def test_oversized_structure(self):
+        data = bytearray(b"\0" * 8)
+        for base in (LittleEndianStructure, BigEndianStructure):
+            class SomeBoolsTooBig(base):
+                _align_ = 8
+                _fields_ = [
+                    ("bool1", c_ubyte),
+                    ("bool2", c_ubyte),
+                    ("bool3", c_ubyte),
+                ]
+            class Main(base):
+                _fields_ = [
+                    ("y", SomeBoolsTooBig),
+                    ("z", c_uint32),
+                ]
+            with self.assertRaises(ValueError) as ctx:
+                Main.from_buffer(data)
+                self.assertEqual(
+                    ctx.exception.args[0],
+                    'Buffer size too small (4 instead of at least 8 bytes)'
+                )
+
+    def test_aligned_subclasses(self):
+        for base, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class UnalignedSub(base):
+                x: c_uint32
+                _fields_ = [
+                    ("x", c_uint32),
+                ]
+
+            class AlignedStruct(UnalignedSub):
+                _align_ = 8
+                _fields_ = [
+                    ("y", c_uint32),
+                ]
+
+            class Main(base):
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", AlignedStruct)
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(main.b), 8)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(sizeof(main.b), 8)
+            self.assertEqual(sizeof(main), 16)
+            self.assertEqual(main.a, 1)
+            self.assertEqual(main.b.x, 3)
+            self.assertEqual(main.b.y, 4)
+            self.assertEqual(Main.b.offset, 8)
+            self.assertEqual(Main.b.size, 8)
+
+    def test_aligned_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class AlignedUnion(ubase):
+                _align_ = 8
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", c_ubyte * 7),
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint32),
+                    ("union", AlignedUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.first, 1)
+            self.assertEqual(main.union.a, 3)
+            self.assertEqual(bytes(main.union.b), data[8:-1])
+            self.assertEqual(Main.union.offset, 8)
+            self.assertEqual(Main.union.size, 8)
+            self.assertEqual(alignment(main.union), 8)
+            self.assertEqual(alignment(main), 8)
+
+    def test_aligned_struct_in_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class Sub(sbase):
+                _align_ = 8
+                _fields_ = [
+                    ("x", c_uint32),
+                    ("y", c_uint32),
+                ]
+
+            class MainUnion(ubase):
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", Sub),
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint32),
+                    ("union", MainUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(Main.first.size, 4)
+            self.assertEqual(alignment(main.union), 8)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(Main.union.offset, 8)
+            self.assertEqual(Main.union.size, 8)
+            self.assertEqual(main.first, 1)
+            self.assertEqual(main.union.a, 3)
+            self.assertEqual(main.union.b.x, 3)
+            self.assertEqual(main.union.b.y, 4)
+
+    def test_smaller_aligned_subclassed_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}H2xI", 1, 0xD60102D7))
+            class SubUnion(ubase):
+                _align_ = 2
+                _fields_ = [
+                    ("unsigned", c_ubyte),
+                    ("signed", c_byte),
+                ]
+
+            class MainUnion(SubUnion):
+                _fields_ = [
+                    ("num", c_uint32)
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint16),
+                    ("union", MainUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.union.num, 0xD60102D7)
+            self.assertEqual(main.union.unsigned, data[4])
+            self.assertEqual(main.union.signed, data[4] - 256)
+            self.assertEqual(alignment(main), 4)
+            self.assertEqual(alignment(main.union), 4)
+            self.assertEqual(Main.union.offset, 4)
+            self.assertEqual(Main.union.size, 4)
+            self.assertEqual(Main.first.size, 2)
+
+    def test_larger_aligned_subclassed_union(self):
+        for ubase, e in (
+            (LittleEndianUnion, "<"),
+            (BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}I4x", 0xD60102D6))
+            class SubUnion(ubase):
+                _align_ = 8
+                _fields_ = [
+                    ("unsigned", c_ubyte),
+                    ("signed", c_byte),
+                ]
+
+            class Main(SubUnion):
+                _fields_ = [
+                    ("num", c_uint32)
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(sizeof(main), 8)
+            self.assertEqual(main.num, 0xD60102D6)
+            self.assertEqual(main.unsigned, 0xD6)
+            self.assertEqual(main.signed, -42)
+
+    def test_aligned_packed_structures(self):
+        for sbase, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}B2H4xB", 1, 2, 3, 4))
+
+            class Inner(sbase):
+                _align_ = 8
+                _fields_ = [
+                    ("x", c_uint16),
+                    ("y", c_uint16),
+                ]
+
+            class Main(sbase):
+                _pack_ = 1
+                _fields_ = [
+                    ("a", c_ubyte),
+                    ("b", Inner),
+                    ("c", c_ubyte),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(sizeof(main), 10)
+            self.assertEqual(Main.b.offset, 1)
+            # Alignment == 8 because _pack_ wins out.
+            self.assertEqual(alignment(main.b), 8)
+            # Size is still 8 though since inside this Structure, it will have
+            # effect.
+            self.assertEqual(sizeof(main.b), 8)
+            self.assertEqual(Main.c.offset, 9)
+            self.assertEqual(main.a, 1)
+            self.assertEqual(main.b.x, 2)
+            self.assertEqual(main.b.y, 3)
+            self.assertEqual(main.c, 4)
+
+    def test_negative_align(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with (
+                self.subTest(base=base),
+                self.assertRaisesRegex(
+                    ValueError,
+                    '_align_ must be a non-negative integer',
+                )
+            ):
+                class MyStructure(base):
+                    _align_ = -1
+                    _fields_ = []
+
+    def test_zero_align_no_fields(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with self.subTest(base=base):
+                class MyStructure(base):
+                    _align_ = 0
+                    _fields_ = []
+
+                self.assertEqual(alignment(MyStructure), 1)
+                self.assertEqual(alignment(MyStructure()), 1)
+
+    def test_zero_align_with_fields(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with self.subTest(base=base):
+                class MyStructure(base):
+                    _align_ = 0
+                    _fields_ = [
+                        ("x", c_ubyte),
+                    ]
+
+                self.assertEqual(alignment(MyStructure), 1)
+                self.assertEqual(alignment(MyStructure()), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_anon.py b/Lib/test/test_ctypes/test_anon.py
new file mode 100644
index 00000000000..b36397b510f
--- /dev/null
+++ b/Lib/test/test_ctypes/test_anon.py
@@ -0,0 +1,75 @@
+import unittest
+import test.support
+from ctypes import c_int, Union, Structure, sizeof
+
+
+class AnonTest(unittest.TestCase):
+
+    def test_anon(self):
+        class ANON(Union):
+            _fields_ = [("a", c_int),
+                        ("b", c_int)]
+
+        class Y(Structure):
+            _fields_ = [("x", c_int),
+                        ("_", ANON),
+                        ("y", c_int)]
+            _anonymous_ = ["_"]
+
+        self.assertEqual(Y.a.offset, sizeof(c_int))
+        self.assertEqual(Y.b.offset, sizeof(c_int))
+
+        self.assertEqual(ANON.a.offset, 0)
+        self.assertEqual(ANON.b.offset, 0)
+
+    def test_anon_nonseq(self):
+        # TypeError: _anonymous_ must be a sequence
+        self.assertRaises(TypeError,
+                              lambda: type(Structure)("Name",
+                                                      (Structure,),
+                                                      {"_fields_": [], "_anonymous_": 42}))
+
+    def test_anon_nonmember(self):
+        # AttributeError: type object 'Name' has no attribute 'x'
+        self.assertRaises(AttributeError,
+                              lambda: type(Structure)("Name",
+                                                      (Structure,),
+                                                      {"_fields_": [],
+                                                       "_anonymous_": ["x"]}))
+
+    @test.support.cpython_only
+    def test_issue31490(self):
+        # There shouldn't be an assertion failure in case the class has an
+        # attribute whose name is specified in _anonymous_ but not in _fields_.
+
+        # AttributeError: 'x' is specified in _anonymous_ but not in _fields_
+        with self.assertRaises(AttributeError):
+            class Name(Structure):
+                _fields_ = []
+                _anonymous_ = ["x"]
+                x = 42
+
+    def test_nested(self):
+        class ANON_S(Structure):
+            _fields_ = [("a", c_int)]
+
+        class ANON_U(Union):
+            _fields_ = [("_", ANON_S),
+                        ("b", c_int)]
+            _anonymous_ = ["_"]
+
+        class Y(Structure):
+            _fields_ = [("x", c_int),
+                        ("_", ANON_U),
+                        ("y", c_int)]
+            _anonymous_ = ["_"]
+
+        self.assertEqual(Y.x.offset, 0)
+        self.assertEqual(Y.a.offset, sizeof(c_int))
+        self.assertEqual(Y.b.offset, sizeof(c_int))
+        self.assertEqual(Y._.offset, sizeof(c_int))
+        self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_array_in_pointer.py b/Lib/test/test_ctypes/test_array_in_pointer.py
new file mode 100644
index 00000000000..b7c96b2fa49
--- /dev/null
+++ b/Lib/test/test_ctypes/test_array_in_pointer.py
@@ -0,0 +1,68 @@
+import binascii
+import re
+import unittest
+from ctypes import c_byte, Structure, POINTER, cast
+
+
+def dump(obj):
+    # helper function to dump memory contents in hex, with a hyphen
+    # between the bytes.
+    h = binascii.hexlify(memoryview(obj)).decode()
+    return re.sub(r"(..)", r"\1-", h)[:-1]
+
+
+class Value(Structure):
+    _fields_ = [("val", c_byte)]
+
+
+class Container(Structure):
+    _fields_ = [("pvalues", POINTER(Value))]
+
+
+class Test(unittest.TestCase):
+    def test(self):
+        # create an array of 4 values
+        val_array = (Value * 4)()
+
+        # create a container, which holds a pointer to the pvalues array.
+        c = Container()
+        c.pvalues = val_array
+
+        # memory contains 4 NUL bytes now, that's correct
+        self.assertEqual("00-00-00-00", dump(val_array))
+
+        # set the values of the array through the pointer:
+        for i in range(4):
+            c.pvalues[i].val = i + 1
+
+        values = [c.pvalues[i].val for i in range(4)]
+
+        # These are the expected results: here s the bug!
+        self.assertEqual(
+            (values, dump(val_array)),
+            ([1, 2, 3, 4], "01-02-03-04")
+        )
+
+    def test_2(self):
+
+        val_array = (Value * 4)()
+
+        # memory contains 4 NUL bytes now, that's correct
+        self.assertEqual("00-00-00-00", dump(val_array))
+
+        ptr = cast(val_array, POINTER(Value))
+        # set the values of the array through the pointer:
+        for i in range(4):
+            ptr[i].val = i + 1
+
+        values = [ptr[i].val for i in range(4)]
+
+        # These are the expected results: here s the bug!
+        self.assertEqual(
+            (values, dump(val_array)),
+            ([1, 2, 3, 4], "01-02-03-04")
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_arrays.py b/Lib/test/test_ctypes/test_arrays.py
new file mode 100644
index 00000000000..c80fdff5de6
--- /dev/null
+++ b/Lib/test/test_ctypes/test_arrays.py
@@ -0,0 +1,272 @@
+import ctypes
+import sys
+import unittest
+from ctypes import (Structure, Array, ARRAY, sizeof, addressof,
+                    create_string_buffer, create_unicode_buffer,
+                    c_char, c_wchar, c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulonglong, c_float, c_double, c_longdouble)
+from test.support import bigmemtest, _2G
+from ._support import (_CData, PyCArrayType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+formats = "bBhHiIlLqQfd"
+
+formats = c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint, \
+          c_long, c_ulonglong, c_float, c_double, c_longdouble
+
+
+class ArrayTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(Array.mro(), [Array, _CData, object])
+
+        self.assertEqual(PyCArrayType.__name__, "PyCArrayType")
+        self.assertEqual(type(PyCArrayType), type)
+
+    def test_type_flags(self):
+        for cls in Array, PyCArrayType:
+            with self.subTest(cls=cls):
+                self.assertTrue(cls.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(cls.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewArray = PyCArrayType.__new__(PyCArrayType, 'NewArray', (Array,), {})
+        for cls in Array, NewArray:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(Array):
+            _type_ = c_int
+            _length_ = 13
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCArrayType.__init__(T, 'ptr', (), {})
+
+    def test_simple(self):
+        # create classes holding simple numeric types, and check
+        # various properties.
+
+        init = list(range(15, 25))
+
+        for fmt in formats:
+            alen = len(init)
+            int_array = ARRAY(fmt, alen)
+
+            ia = int_array(*init)
+            # length of instance ok?
+            self.assertEqual(len(ia), alen)
+
+            # slot values ok?
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, init)
+
+            # out-of-bounds accesses should be caught
+            with self.assertRaises(IndexError): ia[alen]
+            with self.assertRaises(IndexError): ia[-alen-1]
+
+            # change the items
+            new_values = list(range(42, 42+alen))
+            for n in range(alen):
+                ia[n] = new_values[n]
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, new_values)
+
+            # are the items initialized to 0?
+            ia = int_array()
+            values = [ia[i] for i in range(alen)]
+            self.assertEqual(values, [0] * alen)
+
+            # Too many initializers should be caught
+            self.assertRaises(IndexError, int_array, *range(alen*2))
+
+        CharArray = ARRAY(c_char, 3)
+
+        ca = CharArray(b"a", b"b", b"c")
+
+        # Should this work? It doesn't:
+        # CharArray("abc")
+        self.assertRaises(TypeError, CharArray, "abc")
+
+        self.assertEqual(ca[0], b"a")
+        self.assertEqual(ca[1], b"b")
+        self.assertEqual(ca[2], b"c")
+        self.assertEqual(ca[-3], b"a")
+        self.assertEqual(ca[-2], b"b")
+        self.assertEqual(ca[-1], b"c")
+
+        self.assertEqual(len(ca), 3)
+
+        # cannot delete items
+        with self.assertRaises(TypeError):
+            del ca[0]
+
+    def test_step_overflow(self):
+        a = (c_int * 5)()
+        a[3::sys.maxsize] = (1,)
+        self.assertListEqual(a[3::sys.maxsize], [1])
+        a = (c_char * 5)()
+        a[3::sys.maxsize] = b"A"
+        self.assertEqual(a[3::sys.maxsize], b"A")
+        a = (c_wchar * 5)()
+        a[3::sys.maxsize] = u"X"
+        self.assertEqual(a[3::sys.maxsize], u"X")
+
+    def test_numeric_arrays(self):
+
+        alen = 5
+
+        numarray = ARRAY(c_int, alen)
+
+        na = numarray()
+        values = [na[i] for i in range(alen)]
+        self.assertEqual(values, [0] * alen)
+
+        na = numarray(*[c_int()] * alen)
+        values = [na[i] for i in range(alen)]
+        self.assertEqual(values, [0]*alen)
+
+        na = numarray(1, 2, 3, 4, 5)
+        values = [i for i in na]
+        self.assertEqual(values, [1, 2, 3, 4, 5])
+
+        na = numarray(*map(c_int, (1, 2, 3, 4, 5)))
+        values = [i for i in na]
+        self.assertEqual(values, [1, 2, 3, 4, 5])
+
+    def test_classcache(self):
+        self.assertIsNot(ARRAY(c_int, 3), ARRAY(c_int, 4))
+        self.assertIs(ARRAY(c_int, 3), ARRAY(c_int, 3))
+
+    def test_from_address(self):
+        # Failed with 0.9.8, reported by JUrner
+        p = create_string_buffer(b"foo")
+        sz = (c_char * 3).from_address(addressof(p))
+        self.assertEqual(sz[:], b"foo")
+        self.assertEqual(sz[::], b"foo")
+        self.assertEqual(sz[::-1], b"oof")
+        self.assertEqual(sz[::3], b"f")
+        self.assertEqual(sz[1:4:2], b"o")
+        self.assertEqual(sz.value, b"foo")
+
+    def test_from_addressW(self):
+        p = create_unicode_buffer("foo")
+        sz = (c_wchar * 3).from_address(addressof(p))
+        self.assertEqual(sz[:], "foo")
+        self.assertEqual(sz[::], "foo")
+        self.assertEqual(sz[::-1], "oof")
+        self.assertEqual(sz[::3], "f")
+        self.assertEqual(sz[1:4:2], "o")
+        self.assertEqual(sz.value, "foo")
+
+    def test_cache(self):
+        # Array types are cached internally in the _ctypes extension,
+        # in a WeakValueDictionary.  Make sure the array type is
+        # removed from the cache when the itemtype goes away.  This
+        # test will not fail, but will show a leak in the testsuite.
+
+        # Create a new type:
+        class my_int(c_int):
+            pass
+        # Create a new array type based on it:
+        t1 = my_int * 1
+        t2 = my_int * 1
+        self.assertIs(t1, t2)
+
+    def test_subclass(self):
+        class T(Array):
+            _type_ = c_int
+            _length_ = 13
+        class U(T):
+            pass
+        class V(U):
+            pass
+        class W(V):
+            pass
+        class X(T):
+            _type_ = c_short
+        class Y(T):
+            _length_ = 187
+
+        for c in [T, U, V, W]:
+            self.assertEqual(c._type_, c_int)
+            self.assertEqual(c._length_, 13)
+            self.assertEqual(c()._type_, c_int)
+            self.assertEqual(c()._length_, 13)
+
+        self.assertEqual(X._type_, c_short)
+        self.assertEqual(X._length_, 13)
+        self.assertEqual(X()._type_, c_short)
+        self.assertEqual(X()._length_, 13)
+
+        self.assertEqual(Y._type_, c_int)
+        self.assertEqual(Y._length_, 187)
+        self.assertEqual(Y()._type_, c_int)
+        self.assertEqual(Y()._length_, 187)
+
+    def test_bad_subclass(self):
+        with self.assertRaises(AttributeError):
+            class T(Array):
+                pass
+        with self.assertRaises(AttributeError):
+            class T2(Array):
+                _type_ = c_int
+        with self.assertRaises(AttributeError):
+            class T3(Array):
+                _length_ = 13
+
+    def test_bad_length(self):
+        with self.assertRaises(ValueError):
+            class T(Array):
+                _type_ = c_int
+                _length_ = - sys.maxsize * 2
+        with self.assertRaises(ValueError):
+            class T2(Array):
+                _type_ = c_int
+                _length_ = -1
+        with self.assertRaises(TypeError):
+            class T3(Array):
+                _type_ = c_int
+                _length_ = 1.87
+        with self.assertRaises(OverflowError):
+            class T4(Array):
+                _type_ = c_int
+                _length_ = sys.maxsize * 2
+
+    def test_zero_length(self):
+        # _length_ can be zero.
+        class T(Array):
+            _type_ = c_int
+            _length_ = 0
+
+    def test_empty_element_struct(self):
+        class EmptyStruct(Structure):
+            _fields_ = []
+
+        obj = (EmptyStruct * 2)()  # bpo37188: Floating-point exception
+        self.assertEqual(sizeof(obj), 0)
+
+    def test_empty_element_array(self):
+        class EmptyArray(Array):
+            _type_ = c_int
+            _length_ = 0
+
+        obj = (EmptyArray * 2)()  # bpo37188: Floating-point exception
+        self.assertEqual(sizeof(obj), 0)
+
+    def test_bpo36504_signed_int_overflow(self):
+        # The overflow check in PyCArrayType_new() could cause signed integer
+        # overflow.
+        with self.assertRaises(OverflowError):
+            c_char * sys.maxsize * 2
+
+    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
+    @bigmemtest(size=_2G, memuse=1, dry_run=False)
+    def test_large_array(self, size):
+        c_char * size
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_as_parameter.py b/Lib/test/test_ctypes/test_as_parameter.py
new file mode 100644
index 00000000000..c5e1840b0eb
--- /dev/null
+++ b/Lib/test/test_ctypes/test_as_parameter.py
@@ -0,0 +1,245 @@
+import ctypes
+import unittest
+from ctypes import (Structure, CDLL, CFUNCTYPE,
+                    POINTER, pointer, byref,
+                    c_short, c_int, c_long, c_longlong,
+                    c_byte, c_wchar, c_float, c_double,
+                    ArgumentError)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+dll = CDLL(_ctypes_test.__file__)
+
+try:
+    CALLBACK_FUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
+    # fake to enable this test on Linux
+    CALLBACK_FUNCTYPE = CFUNCTYPE
+
+
+class POINT(Structure):
+    _fields_ = [("x", c_int), ("y", c_int)]
+
+
+class BasicWrapTestCase(unittest.TestCase):
+    def wrap(self, param):
+        return param
+
+    def test_wchar_parm(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
+        result = f(self.wrap(1), self.wrap("x"), self.wrap(3), self.wrap(4), self.wrap(5.0), self.wrap(6.0))
+        self.assertEqual(result, 139)
+        self.assertIs(type(result), int)
+
+    def test_pointers(self):
+        f = dll._testfunc_p_p
+        f.restype = POINTER(c_int)
+        f.argtypes = [POINTER(c_int)]
+
+        # This only works if the value c_int(42) passed to the
+        # function is still alive while the pointer (the result) is
+        # used.
+
+        v = c_int(42)
+
+        self.assertEqual(pointer(v).contents.value, 42)
+        result = f(self.wrap(pointer(v)))
+        self.assertEqual(type(result), POINTER(c_int))
+        self.assertEqual(result.contents.value, 42)
+
+        # This on works...
+        result = f(self.wrap(pointer(v)))
+        self.assertEqual(result.contents.value, v.value)
+
+        p = pointer(c_int(99))
+        result = f(self.wrap(p))
+        self.assertEqual(result.contents.value, 99)
+
+    def test_shorts(self):
+        f = dll._testfunc_callback_i_if
+
+        args = []
+        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
+                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+
+        def callback(v):
+            args.append(v)
+            return v
+
+        CallBack = CFUNCTYPE(c_int, c_int)
+
+        cb = CallBack(callback)
+        f(self.wrap(2**18), self.wrap(cb))
+        self.assertEqual(args, expected)
+
+    def test_callbacks(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+        f.argtypes = None
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        def callback(value):
+            return value
+
+        cb = MyCallback(callback)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        # test with prototype
+        f.argtypes = [c_int, MyCallback]
+        cb = MyCallback(callback)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+        AnotherCallback = CALLBACK_FUNCTYPE(c_int, c_int, c_int, c_int, c_int)
+
+        # check that the prototype works: we call f with wrong
+        # argument types
+        cb = AnotherCallback(callback)
+        self.assertRaises(ArgumentError, f, self.wrap(-10), self.wrap(cb))
+
+    def test_callbacks_2(self):
+        # Can also use simple datatypes as argument type specifiers
+        # for the callback function.
+        # In this case the call receives an instance of that type
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        f.argtypes = [c_int, MyCallback]
+
+        def callback(value):
+            self.assertEqual(type(value), int)
+            return value
+
+        cb = MyCallback(callback)
+        result = f(self.wrap(-10), self.wrap(cb))
+        self.assertEqual(result, -18)
+
+    def test_longlong_callbacks(self):
+        f = dll._testfunc_callback_q_qf
+        f.restype = c_longlong
+
+        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
+
+        f.argtypes = [c_longlong, MyCallback]
+
+        def callback(value):
+            self.assertIsInstance(value, int)
+            return value & 0x7FFFFFFF
+
+        cb = MyCallback(callback)
+
+        self.assertEqual(13577625587, int(f(self.wrap(1000000000000), self.wrap(cb))))
+
+    def test_byval(self):
+        # without prototype
+        ptin = POINT(1, 2)
+        ptout = POINT()
+        # EXPORT int _testfunc_byval(point in, point *pout)
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 3, 1, 2
+        self.assertEqual(got, expected)
+
+        # with prototype
+        ptin = POINT(101, 102)
+        ptout = POINT()
+        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
+        dll._testfunc_byval.restype = c_int
+        result = dll._testfunc_byval(self.wrap(ptin), byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 203, 101, 102
+        self.assertEqual(got, expected)
+
+    def test_struct_return_2H(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+        dll.ret_2h_func.restype = S2H
+        dll.ret_2h_func.argtypes = [S2H]
+        inp = S2H(99, 88)
+        s2h = dll.ret_2h_func(self.wrap(inp))
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+        # Test also that the original struct was unmodified (i.e. was passed by
+        # value)
+        self.assertEqual((inp.x, inp.y), (99, 88))
+
+    def test_struct_return_8H(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        dll.ret_8i_func.restype = S8I
+        dll.ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = dll.ret_8i_func(self.wrap(inp))
+        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    def test_recursive_as_param(self):
+        class A:
+            pass
+
+        a = A()
+        a._as_parameter_ = a
+        for c_type in (
+            ctypes.c_wchar_p,
+            ctypes.c_char_p,
+            ctypes.c_void_p,
+            ctypes.c_int,  # PyCSimpleType
+            POINT,  # CDataType
+        ):
+            with self.subTest(c_type=c_type):
+                with self.assertRaises(RecursionError):
+                    c_type.from_param(a)
+
+
+class AsParamWrapper:
+    def __init__(self, param):
+        self._as_parameter_ = param
+
+class AsParamWrapperTestCase(BasicWrapTestCase):
+    wrap = AsParamWrapper
+
+
+class AsParamPropertyWrapper:
+    def __init__(self, param):
+        self._param = param
+
+    def getParameter(self):
+        return self._param
+    _as_parameter_ = property(getParameter)
+
+class AsParamPropertyWrapperTestCase(BasicWrapTestCase):
+    wrap = AsParamPropertyWrapper
+
+
+class AsParamNestedWrapperTestCase(BasicWrapTestCase):
+    """Test that _as_parameter_ is evaluated recursively.
+
+    The _as_parameter_ attribute can be another object which
+    defines its own _as_parameter_ attribute.
+    """
+
+    def wrap(self, param):
+        return AsParamWrapper(AsParamWrapper(AsParamWrapper(param)))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_bitfields.py b/Lib/test/test_ctypes/test_bitfields.py
new file mode 100644
index 00000000000..0332544b582
--- /dev/null
+++ b/Lib/test/test_ctypes/test_bitfields.py
@@ -0,0 +1,294 @@
+import os
+import unittest
+from ctypes import (CDLL, Structure, sizeof, POINTER, byref, alignment,
+                    LittleEndianStructure, BigEndianStructure,
+                    c_byte, c_ubyte, c_char, c_char_p, c_void_p, c_wchar,
+                    c_uint32, c_uint64,
+                    c_short, c_ushort, c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong)
+from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class BITS(Structure):
+    _fields_ = [("A", c_int, 1),
+                ("B", c_int, 2),
+                ("C", c_int, 3),
+                ("D", c_int, 4),
+                ("E", c_int, 5),
+                ("F", c_int, 6),
+                ("G", c_int, 7),
+                ("H", c_int, 8),
+                ("I", c_int, 9),
+
+                ("M", c_short, 1),
+                ("N", c_short, 2),
+                ("O", c_short, 3),
+                ("P", c_short, 4),
+                ("Q", c_short, 5),
+                ("R", c_short, 6),
+                ("S", c_short, 7)]
+
+func = CDLL(_ctypes_test.__file__).unpack_bitfields
+func.argtypes = POINTER(BITS), c_char
+
+
+class C_Test(unittest.TestCase):
+
+    def test_ints(self):
+        for i in range(512):
+            for name in "ABCDEFGHI":
+                b = BITS()
+                setattr(b, name, i)
+                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
+
+    # bpo-46913: _ctypes/cfield.c h_get() has an undefined behavior
+    @support.skip_if_sanitizer(ub=True)
+    def test_shorts(self):
+        b = BITS()
+        name = "M"
+        if func(byref(b), name.encode('ascii')) == 999:
+            self.skipTest("Compiler does not support signed short bitfields")
+        for i in range(256):
+            for name in "MNOPQRS":
+                b = BITS()
+                setattr(b, name, i)
+                self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
+
+
+signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
+unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
+int_types = unsigned_int_types + signed_int_types
+
+class BitFieldTest(unittest.TestCase):
+
+    def test_longlong(self):
+        class X(Structure):
+            _fields_ = [("a", c_longlong, 1),
+                        ("b", c_longlong, 62),
+                        ("c", c_longlong, 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_longlong))
+        x = X()
+        x.a, x.b, x.c = -1, 7, -1
+        self.assertEqual((x.a, x.b, x.c), (-1, 7, -1))
+
+    def test_ulonglong(self):
+        class X(Structure):
+            _fields_ = [("a", c_ulonglong, 1),
+                        ("b", c_ulonglong, 62),
+                        ("c", c_ulonglong, 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_longlong))
+        x = X()
+        self.assertEqual((x.a, x.b, x.c), (0, 0, 0))
+        x.a, x.b, x.c = 7, 7, 7
+        self.assertEqual((x.a, x.b, x.c), (1, 7, 1))
+
+    def test_signed(self):
+        for c_typ in signed_int_types:
+            class X(Structure):
+                _fields_ = [("dummy", c_typ),
+                            ("a", c_typ, 3),
+                            ("b", c_typ, 3),
+                            ("c", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ)*2)
+
+            x = X()
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
+            x.a = -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, -1, 0, 0))
+            x.a, x.b = 0, -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, -1, 0))
+
+
+    def test_unsigned(self):
+        for c_typ in unsigned_int_types:
+            class X(Structure):
+                _fields_ = [("a", c_typ, 3),
+                            ("b", c_typ, 3),
+                            ("c", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            x = X()
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 0, 0))
+            x.a = -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 7, 0, 0))
+            x.a, x.b = 0, -1
+            self.assertEqual((c_typ, x.a, x.b, x.c), (c_typ, 0, 7, 0))
+
+    def fail_fields(self, *fields):
+        return self.get_except(type(Structure), "X", (),
+                               {"_fields_": fields})
+
+    def test_nonint_types(self):
+        # bit fields are not allowed on non-integer types.
+        result = self.fail_fields(("a", c_char_p, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char_p'))
+
+        result = self.fail_fields(("a", c_void_p, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_void_p'))
+
+        if c_int != c_long:
+            result = self.fail_fields(("a", POINTER(c_int), 1))
+            self.assertEqual(result, (TypeError, 'bit fields not allowed for type LP_c_int'))
+
+        result = self.fail_fields(("a", c_char, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type c_char'))
+
+        class Dummy(Structure):
+            _fields_ = []
+
+        result = self.fail_fields(("a", Dummy, 1))
+        self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
+
+    def test_c_wchar(self):
+        result = self.fail_fields(("a", c_wchar, 1))
+        self.assertEqual(result,
+                (TypeError, 'bit fields not allowed for type c_wchar'))
+
+    def test_single_bitfield_size(self):
+        for c_typ in int_types:
+            result = self.fail_fields(("a", c_typ, -1))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+            result = self.fail_fields(("a", c_typ, 0))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+            class X(Structure):
+                _fields_ = [("a", c_typ, 1)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            class X(Structure):
+                _fields_ = [("a", c_typ, sizeof(c_typ)*8)]
+            self.assertEqual(sizeof(X), sizeof(c_typ))
+
+            result = self.fail_fields(("a", c_typ, sizeof(c_typ)*8 + 1))
+            self.assertEqual(result, (ValueError, 'number of bits invalid for bit field'))
+
+    def test_multi_bitfields_size(self):
+        class X(Structure):
+            _fields_ = [("a", c_short, 1),
+                        ("b", c_short, 14),
+                        ("c", c_short, 1)]
+        self.assertEqual(sizeof(X), sizeof(c_short))
+
+        class X(Structure):
+            _fields_ = [("a", c_short, 1),
+                        ("a1", c_short),
+                        ("b", c_short, 14),
+                        ("c", c_short, 1)]
+        self.assertEqual(sizeof(X), sizeof(c_short)*3)
+        self.assertEqual(X.a.offset, 0)
+        self.assertEqual(X.a1.offset, sizeof(c_short))
+        self.assertEqual(X.b.offset, sizeof(c_short)*2)
+        self.assertEqual(X.c.offset, sizeof(c_short)*2)
+
+        class X(Structure):
+            _fields_ = [("a", c_short, 3),
+                        ("b", c_short, 14),
+                        ("c", c_short, 14)]
+        self.assertEqual(sizeof(X), sizeof(c_short)*3)
+        self.assertEqual(X.a.offset, sizeof(c_short)*0)
+        self.assertEqual(X.b.offset, sizeof(c_short)*1)
+        self.assertEqual(X.c.offset, sizeof(c_short)*2)
+
+    def get_except(self, func, *args, **kw):
+        try:
+            func(*args, **kw)
+        except Exception as detail:
+            return detail.__class__, str(detail)
+
+    def test_mixed_1(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_int, 4)]
+        if os.name == "nt":
+            self.assertEqual(sizeof(X), sizeof(c_int)*2)
+        else:
+            self.assertEqual(sizeof(X), sizeof(c_int))
+
+    def test_mixed_2(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_int, 32)]
+        self.assertEqual(sizeof(X), alignment(c_int)+sizeof(c_int))
+
+    def test_mixed_3(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_ubyte, 4)]
+        self.assertEqual(sizeof(X), sizeof(c_byte))
+
+    def test_mixed_4(self):
+        class X(Structure):
+            _fields_ = [("a", c_short, 4),
+                        ("b", c_short, 4),
+                        ("c", c_int, 24),
+                        ("d", c_short, 4),
+                        ("e", c_short, 4),
+                        ("f", c_int, 24)]
+        # MSVC does NOT combine c_short and c_int into one field, GCC
+        # does (unless GCC is run with '-mms-bitfields' which
+        # produces code compatible with MSVC).
+        if os.name == "nt":
+            self.assertEqual(sizeof(X), sizeof(c_int) * 4)
+        else:
+            self.assertEqual(sizeof(X), sizeof(c_int) * 2)
+
+    def test_anon_bitfields(self):
+        # anonymous bit-fields gave a strange error message
+        class X(Structure):
+            _fields_ = [("a", c_byte, 4),
+                        ("b", c_ubyte, 4)]
+        class Y(Structure):
+            _anonymous_ = ["_"]
+            _fields_ = [("_", X)]
+
+    def test_uint32(self):
+        class X(Structure):
+            _fields_ = [("a", c_uint32, 32)]
+        x = X()
+        x.a = 10
+        self.assertEqual(x.a, 10)
+        x.a = 0xFDCBA987
+        self.assertEqual(x.a, 0xFDCBA987)
+
+    def test_uint64(self):
+        class X(Structure):
+            _fields_ = [("a", c_uint64, 64)]
+        x = X()
+        x.a = 10
+        self.assertEqual(x.a, 10)
+        x.a = 0xFEDCBA9876543211
+        self.assertEqual(x.a, 0xFEDCBA9876543211)
+
+    def test_uint32_swap_little_endian(self):
+        # Issue #23319
+        class Little(LittleEndianStructure):
+            _fields_ = [("a", c_uint32, 24),
+                        ("b", c_uint32, 4),
+                        ("c", c_uint32, 4)]
+        b = bytearray(4)
+        x = Little.from_buffer(b)
+        x.a = 0xabcdef
+        x.b = 1
+        x.c = 2
+        self.assertEqual(b, b'\xef\xcd\xab\x21')
+
+    def test_uint32_swap_big_endian(self):
+        # Issue #23319
+        class Big(BigEndianStructure):
+            _fields_ = [("a", c_uint32, 24),
+                        ("b", c_uint32, 4),
+                        ("c", c_uint32, 4)]
+        b = bytearray(4)
+        x = Big.from_buffer(b)
+        x.a = 0xabcdef
+        x.b = 1
+        x.c = 2
+        self.assertEqual(b, b'\xab\xcd\xef\x12')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_buffers.py b/Lib/test/test_ctypes/test_buffers.py
new file mode 100644
index 00000000000..468f41eb7cf
--- /dev/null
+++ b/Lib/test/test_ctypes/test_buffers.py
@@ -0,0 +1,70 @@
+import unittest
+from ctypes import (create_string_buffer, create_unicode_buffer, sizeof,
+                    c_char, c_wchar)
+
+
+class StringBufferTestCase(unittest.TestCase):
+    def test_buffer(self):
+        b = create_string_buffer(32)
+        self.assertEqual(len(b), 32)
+        self.assertEqual(sizeof(b), 32 * sizeof(c_char))
+        self.assertIs(type(b[0]), bytes)
+
+        b = create_string_buffer(b"abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_char))
+        self.assertIs(type(b[0]), bytes)
+        self.assertEqual(b[0], b"a")
+        self.assertEqual(b[:], b"abc\0")
+        self.assertEqual(b[::], b"abc\0")
+        self.assertEqual(b[::-1], b"\0cba")
+        self.assertEqual(b[::2], b"ac")
+        self.assertEqual(b[::5], b"a")
+
+        self.assertRaises(TypeError, create_string_buffer, "abc")
+
+    def test_buffer_interface(self):
+        self.assertEqual(len(bytearray(create_string_buffer(0))), 0)
+        self.assertEqual(len(bytearray(create_string_buffer(1))), 1)
+
+    def test_unicode_buffer(self):
+        b = create_unicode_buffer(32)
+        self.assertEqual(len(b), 32)
+        self.assertEqual(sizeof(b), 32 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+
+        b = create_unicode_buffer("abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+        self.assertEqual(b[0], "a")
+        self.assertEqual(b[:], "abc\0")
+        self.assertEqual(b[::], "abc\0")
+        self.assertEqual(b[::-1], "\0cba")
+        self.assertEqual(b[::2], "ac")
+        self.assertEqual(b[::5], "a")
+
+        self.assertRaises(TypeError, create_unicode_buffer, b"abc")
+
+    def test_unicode_conversion(self):
+        b = create_unicode_buffer("abc")
+        self.assertEqual(len(b), 4) # trailing nul char
+        self.assertEqual(sizeof(b), 4 * sizeof(c_wchar))
+        self.assertIs(type(b[0]), str)
+        self.assertEqual(b[0], "a")
+        self.assertEqual(b[:], "abc\0")
+        self.assertEqual(b[::], "abc\0")
+        self.assertEqual(b[::-1], "\0cba")
+        self.assertEqual(b[::2], "ac")
+        self.assertEqual(b[::5], "a")
+
+    def test_create_unicode_buffer_non_bmp(self):
+        expected = 5 if sizeof(c_wchar) == 2 else 3
+        for s in '\U00010000\U00100000', '\U00010000\U0010ffff':
+            b = create_unicode_buffer(s)
+            self.assertEqual(len(b), expected)
+            self.assertEqual(b[-1], '\0')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_bytes.py b/Lib/test/test_ctypes/test_bytes.py
new file mode 100644
index 00000000000..fa11e1bbd49
--- /dev/null
+++ b/Lib/test/test_ctypes/test_bytes.py
@@ -0,0 +1,67 @@
+"""Test where byte objects are accepted"""
+import sys
+import unittest
+from _ctypes import _SimpleCData
+from ctypes import Structure, c_char, c_char_p, c_wchar, c_wchar_p
+
+
+class BytesTest(unittest.TestCase):
+    def test_c_char(self):
+        x = c_char(b"x")
+        self.assertRaises(TypeError, c_char, "x")
+        x.value = b"y"
+        with self.assertRaises(TypeError):
+            x.value = "y"
+        c_char.from_param(b"x")
+        self.assertRaises(TypeError, c_char.from_param, "x")
+        self.assertIn('xbd', repr(c_char.from_param(b"\xbd")))
+        (c_char * 3)(b"a", b"b", b"c")
+        self.assertRaises(TypeError, c_char * 3, "a", "b", "c")
+
+    def test_c_wchar(self):
+        x = c_wchar("x")
+        self.assertRaises(TypeError, c_wchar, b"x")
+        x.value = "y"
+        with self.assertRaises(TypeError):
+            x.value = b"y"
+        c_wchar.from_param("x")
+        self.assertRaises(TypeError, c_wchar.from_param, b"x")
+        (c_wchar * 3)("a", "b", "c")
+        self.assertRaises(TypeError, c_wchar * 3, b"a", b"b", b"c")
+
+    def test_c_char_p(self):
+        c_char_p(b"foo bar")
+        self.assertRaises(TypeError, c_char_p, "foo bar")
+
+    def test_c_wchar_p(self):
+        c_wchar_p("foo bar")
+        self.assertRaises(TypeError, c_wchar_p, b"foo bar")
+
+    def test_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_char * 3)]
+
+        x = X(b"abc")
+        self.assertRaises(TypeError, X, "abc")
+        self.assertEqual(x.a, b"abc")
+        self.assertEqual(type(x.a), bytes)
+
+    def test_struct_W(self):
+        class X(Structure):
+            _fields_ = [("a", c_wchar * 3)]
+
+        x = X("abc")
+        self.assertRaises(TypeError, X, b"abc")
+        self.assertEqual(x.a, "abc")
+        self.assertEqual(type(x.a), str)
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_BSTR(self):
+        class BSTR(_SimpleCData):
+            _type_ = "X"
+
+        BSTR("abc")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_byteswap.py b/Lib/test/test_ctypes/test_byteswap.py
new file mode 100644
index 00000000000..78eff0392c4
--- /dev/null
+++ b/Lib/test/test_ctypes/test_byteswap.py
@@ -0,0 +1,386 @@
+import binascii
+import ctypes
+import math
+import struct
+import sys
+import unittest
+from ctypes import (Structure, Union, LittleEndianUnion, BigEndianUnion,
+                    BigEndianStructure, LittleEndianStructure,
+                    POINTER, sizeof, cast,
+                    c_byte, c_ubyte, c_char, c_wchar, c_void_p,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_uint32, c_float, c_double)
+
+
+def bin(s):
+    return binascii.hexlify(memoryview(s)).decode().upper()
+
+
+# Each *simple* type that supports different byte orders has an
+# __ctype_be__ attribute that specifies the same type in BIG ENDIAN
+# byte order, and a __ctype_le__ attribute that is the same type in
+# LITTLE ENDIAN byte order.
+#
+# For Structures and Unions, these types are created on demand.
+
+class Test(unittest.TestCase):
+    def test_slots(self):
+        class BigPoint(BigEndianStructure):
+            __slots__ = ()
+            _fields_ = [("x", c_int), ("y", c_int)]
+
+        class LowPoint(LittleEndianStructure):
+            __slots__ = ()
+            _fields_ = [("x", c_int), ("y", c_int)]
+
+        big = BigPoint()
+        little = LowPoint()
+        big.x = 4
+        big.y = 2
+        little.x = 2
+        little.y = 4
+        with self.assertRaises(AttributeError):
+            big.z = 42
+        with self.assertRaises(AttributeError):
+            little.z = 24
+
+    def test_endian_short(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_short.__ctype_le__, c_short)
+            self.assertIs(c_short.__ctype_be__.__ctype_le__, c_short)
+        else:
+            self.assertIs(c_short.__ctype_be__, c_short)
+            self.assertIs(c_short.__ctype_le__.__ctype_be__, c_short)
+        s = c_short.__ctype_be__(0x1234)
+        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
+        self.assertEqual(bin(s), "1234")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_short.__ctype_le__(0x1234)
+        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
+        self.assertEqual(bin(s), "3412")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_ushort.__ctype_be__(0x1234)
+        self.assertEqual(bin(struct.pack(">h", 0x1234)), "1234")
+        self.assertEqual(bin(s), "1234")
+        self.assertEqual(s.value, 0x1234)
+
+        s = c_ushort.__ctype_le__(0x1234)
+        self.assertEqual(bin(struct.pack("<h", 0x1234)), "3412")
+        self.assertEqual(bin(s), "3412")
+        self.assertEqual(s.value, 0x1234)
+
+    def test_endian_int(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_int.__ctype_le__, c_int)
+            self.assertIs(c_int.__ctype_be__.__ctype_le__, c_int)
+        else:
+            self.assertIs(c_int.__ctype_be__, c_int)
+            self.assertIs(c_int.__ctype_le__.__ctype_be__, c_int)
+
+        s = c_int.__ctype_be__(0x12345678)
+        self.assertEqual(bin(struct.pack(">i", 0x12345678)), "12345678")
+        self.assertEqual(bin(s), "12345678")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_int.__ctype_le__(0x12345678)
+        self.assertEqual(bin(struct.pack("<i", 0x12345678)), "78563412")
+        self.assertEqual(bin(s), "78563412")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_uint.__ctype_be__(0x12345678)
+        self.assertEqual(bin(struct.pack(">I", 0x12345678)), "12345678")
+        self.assertEqual(bin(s), "12345678")
+        self.assertEqual(s.value, 0x12345678)
+
+        s = c_uint.__ctype_le__(0x12345678)
+        self.assertEqual(bin(struct.pack("<I", 0x12345678)), "78563412")
+        self.assertEqual(bin(s), "78563412")
+        self.assertEqual(s.value, 0x12345678)
+
+    def test_endian_longlong(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_longlong.__ctype_le__, c_longlong)
+            self.assertIs(c_longlong.__ctype_be__.__ctype_le__, c_longlong)
+        else:
+            self.assertIs(c_longlong.__ctype_be__, c_longlong)
+            self.assertIs(c_longlong.__ctype_le__.__ctype_be__, c_longlong)
+
+        s = c_longlong.__ctype_be__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack(">q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
+        self.assertEqual(bin(s), "1234567890ABCDEF")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_longlong.__ctype_le__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack("<q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
+        self.assertEqual(bin(s), "EFCDAB9078563412")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_ulonglong.__ctype_be__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack(">Q", 0x1234567890ABCDEF)), "1234567890ABCDEF")
+        self.assertEqual(bin(s), "1234567890ABCDEF")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+        s = c_ulonglong.__ctype_le__(0x1234567890ABCDEF)
+        self.assertEqual(bin(struct.pack("<Q", 0x1234567890ABCDEF)), "EFCDAB9078563412")
+        self.assertEqual(bin(s), "EFCDAB9078563412")
+        self.assertEqual(s.value, 0x1234567890ABCDEF)
+
+    def test_endian_float(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_float.__ctype_le__, c_float)
+            self.assertIs(c_float.__ctype_be__.__ctype_le__, c_float)
+        else:
+            self.assertIs(c_float.__ctype_be__, c_float)
+            self.assertIs(c_float.__ctype_le__.__ctype_be__, c_float)
+        s = c_float(math.pi)
+        self.assertEqual(bin(struct.pack("f", math.pi)), bin(s))
+        # Hm, what's the precision of a float compared to a double?
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        s = c_float.__ctype_le__(math.pi)
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        self.assertEqual(bin(struct.pack("<f", math.pi)), bin(s))
+        s = c_float.__ctype_be__(math.pi)
+        self.assertAlmostEqual(s.value, math.pi, places=6)
+        self.assertEqual(bin(struct.pack(">f", math.pi)), bin(s))
+
+    def test_endian_double(self):
+        if sys.byteorder == "little":
+            self.assertIs(c_double.__ctype_le__, c_double)
+            self.assertIs(c_double.__ctype_be__.__ctype_le__, c_double)
+        else:
+            self.assertIs(c_double.__ctype_be__, c_double)
+            self.assertIs(c_double.__ctype_le__.__ctype_be__, c_double)
+        s = c_double(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack("d", math.pi)), bin(s))
+        s = c_double.__ctype_le__(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack("<d", math.pi)), bin(s))
+        s = c_double.__ctype_be__(math.pi)
+        self.assertEqual(s.value, math.pi)
+        self.assertEqual(bin(struct.pack(">d", math.pi)), bin(s))
+
+    def test_endian_other(self):
+        self.assertIs(c_byte.__ctype_le__, c_byte)
+        self.assertIs(c_byte.__ctype_be__, c_byte)
+
+        self.assertIs(c_ubyte.__ctype_le__, c_ubyte)
+        self.assertIs(c_ubyte.__ctype_be__, c_ubyte)
+
+        self.assertIs(c_char.__ctype_le__, c_char)
+        self.assertIs(c_char.__ctype_be__, c_char)
+
+    def test_struct_fields_unsupported_byte_order(self):
+
+        fields = [
+            ("a", c_ubyte),
+            ("b", c_byte),
+            ("c", c_short),
+            ("d", c_ushort),
+            ("e", c_int),
+            ("f", c_uint),
+            ("g", c_long),
+            ("h", c_ulong),
+            ("i", c_longlong),
+            ("k", c_ulonglong),
+            ("l", c_float),
+            ("m", c_double),
+            ("n", c_char),
+            ("b1", c_byte, 3),
+            ("b2", c_byte, 3),
+            ("b3", c_byte, 2),
+            ("a", c_int * 3 * 3 * 3)
+        ]
+
+        # these fields do not support different byte order:
+        for typ in c_wchar, c_void_p, POINTER(c_int):
+            with self.assertRaises(TypeError):
+                class T(BigEndianStructure if sys.byteorder == "little" else LittleEndianStructure):
+                    _fields_ = fields + [("x", typ)]
+
+
+    def test_struct_struct(self):
+        # nested structures with different byteorders
+
+        # create nested structures with given byteorders and set memory to data
+
+        for nested, data in (
+            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
+            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
+        ):
+            for parent in (
+                BigEndianStructure,
+                LittleEndianStructure,
+                Structure,
+            ):
+                class NestedStructure(nested):
+                    _fields_ = [("x", c_uint32),
+                                ("y", c_uint32)]
+
+                class TestStructure(parent):
+                    _fields_ = [("point", NestedStructure)]
+
+                self.assertEqual(len(data), sizeof(TestStructure))
+                ptr = POINTER(TestStructure)
+                s = cast(data, ptr)[0]
+                del ctypes._pointer_type_cache[TestStructure]
+                self.assertEqual(s.point.x, 1)
+                self.assertEqual(s.point.y, 2)
+
+    def test_struct_field_alignment(self):
+        # standard packing in struct uses no alignment.
+        # So, we have to align using pad bytes.
+        #
+        # Unaligned accesses will crash Python (on those platforms that
+        # don't allow it, like sparc solaris).
+        if sys.byteorder == "little":
+            base = BigEndianStructure
+            fmt = ">bxhid"
+        else:
+            base = LittleEndianStructure
+            fmt = "<bxhid"
+
+        class S(base):
+            _fields_ = [("b", c_byte),
+                        ("h", c_short),
+                        ("i", c_int),
+                        ("d", c_double)]
+
+        s1 = S(0x12, 0x1234, 0x12345678, 3.14)
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_unaligned_nonnative_struct_fields(self):
+        if sys.byteorder == "little":
+            base = BigEndianStructure
+            fmt = ">b h xi xd"
+        else:
+            base = LittleEndianStructure
+            fmt = "<b h xi xd"
+
+        class S(base):
+            _pack_ = 1
+            _fields_ = [("b", c_byte),
+                        ("h", c_short),
+
+                        ("_1", c_byte),
+                        ("i", c_int),
+
+                        ("_2", c_byte),
+                        ("d", c_double)]
+
+        s1 = S()
+        s1.b = 0x12
+        s1.h = 0x1234
+        s1.i = 0x12345678
+        s1.d = 3.14
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_unaligned_native_struct_fields(self):
+        if sys.byteorder == "little":
+            fmt = "<b h xi xd"
+        else:
+            base = LittleEndianStructure
+            fmt = ">b h xi xd"
+
+        class S(Structure):
+            _pack_ = 1
+            _fields_ = [("b", c_byte),
+
+                        ("h", c_short),
+
+                        ("_1", c_byte),
+                        ("i", c_int),
+
+                        ("_2", c_byte),
+                        ("d", c_double)]
+
+        s1 = S()
+        s1.b = 0x12
+        s1.h = 0x1234
+        s1.i = 0x12345678
+        s1.d = 3.14
+        s2 = struct.pack(fmt, 0x12, 0x1234, 0x12345678, 3.14)
+        self.assertEqual(bin(s1), bin(s2))
+
+    def test_union_fields_unsupported_byte_order(self):
+
+        fields = [
+            ("a", c_ubyte),
+            ("b", c_byte),
+            ("c", c_short),
+            ("d", c_ushort),
+            ("e", c_int),
+            ("f", c_uint),
+            ("g", c_long),
+            ("h", c_ulong),
+            ("i", c_longlong),
+            ("k", c_ulonglong),
+            ("l", c_float),
+            ("m", c_double),
+            ("n", c_char),
+            ("b1", c_byte, 3),
+            ("b2", c_byte, 3),
+            ("b3", c_byte, 2),
+            ("a", c_int * 3 * 3 * 3)
+        ]
+
+        # these fields do not support different byte order:
+        for typ in c_wchar, c_void_p, POINTER(c_int):
+            with self.assertRaises(TypeError):
+                class T(BigEndianUnion if sys.byteorder == "little" else LittleEndianUnion):
+                    _fields_ = fields + [("x", typ)]
+
+    def test_union_struct(self):
+        # nested structures in unions with different byteorders
+
+        # create nested structures in unions with given byteorders and set memory to data
+
+        for nested, data in (
+            (BigEndianStructure, b'\0\0\0\1\0\0\0\2'),
+            (LittleEndianStructure, b'\1\0\0\0\2\0\0\0'),
+        ):
+            for parent in (
+                BigEndianUnion,
+                LittleEndianUnion,
+                Union,
+            ):
+                class NestedStructure(nested):
+                    _fields_ = [("x", c_uint32),
+                                ("y", c_uint32)]
+
+                class TestUnion(parent):
+                    _fields_ = [("point", NestedStructure)]
+
+                self.assertEqual(len(data), sizeof(TestUnion))
+                ptr = POINTER(TestUnion)
+                s = cast(data, ptr)[0]
+                del ctypes._pointer_type_cache[TestUnion]
+                self.assertEqual(s.point.x, 1)
+                self.assertEqual(s.point.y, 2)
+
+    def test_build_struct_union_opposite_system_byteorder(self):
+        # gh-105102
+        if sys.byteorder == "little":
+            _Structure = BigEndianStructure
+            _Union = BigEndianUnion
+        else:
+            _Structure = LittleEndianStructure
+            _Union = LittleEndianUnion
+
+        class S1(_Structure):
+            _fields_ = [("a", c_byte), ("b", c_byte)]
+
+        class U1(_Union):
+            _fields_ = [("s1", S1), ("ab", c_short)]
+
+        class S2(_Structure):
+            _fields_ = [("u1", U1), ("c", c_byte)]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_c_simple_type_meta.py b/Lib/test/test_ctypes/test_c_simple_type_meta.py
new file mode 100644
index 00000000000..eb77d6d7782
--- /dev/null
+++ b/Lib/test/test_ctypes/test_c_simple_type_meta.py
@@ -0,0 +1,152 @@
+import unittest
+import ctypes
+from ctypes import POINTER, c_void_p
+
+from ._support import PyCSimpleType
+
+
+class PyCSimpleTypeAsMetaclassTest(unittest.TestCase):
+    def tearDown(self):
+        # to not leak references, we must clean _pointer_type_cache
+        ctypes._reset_cache()
+
+    def test_creating_pointer_in_dunder_new_1(self):
+        # Test metaclass whose instances are C types; when the type is
+        # created it automatically creates a pointer type for itself.
+        # The pointer type is also an instance of the metaclass.
+        # Such an implementation is used in `IUnknown` of the `comtypes`
+        # project. See gh-124520.
+
+        class ct_meta(type):
+            def __new__(cls, name, bases, namespace):
+                self = super().__new__(cls, name, bases, namespace)
+
+                # Avoid recursion: don't set up a pointer to
+                # a pointer (to a pointer...)
+                if bases == (c_void_p,):
+                    # When creating PtrBase itself, the name
+                    # is not yet available
+                    return self
+                if issubclass(self, PtrBase):
+                    return self
+
+                if bases == (object,):
+                    ptr_bases = (self, PtrBase)
+                else:
+                    ptr_bases = (self, POINTER(bases[0]))
+                p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
+                ctypes._pointer_type_cache[self] = p
+                return self
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class PtrBase(c_void_p, metaclass=p_meta):
+            pass
+
+        class CtBase(object, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        class Sub2(Sub):
+            pass
+
+        self.assertIsInstance(POINTER(Sub2), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
+
+    def test_creating_pointer_in_dunder_new_2(self):
+        # A simpler variant of the above, used in `CoClass` of the `comtypes`
+        # project.
+
+        class ct_meta(type):
+            def __new__(cls, name, bases, namespace):
+                self = super().__new__(cls, name, bases, namespace)
+                if isinstance(self, p_meta):
+                    return self
+                p = p_meta(f"POINTER({self.__name__})", (self, c_void_p), {})
+                ctypes._pointer_type_cache[self] = p
+                return self
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class Core(object):
+            pass
+
+        class CtBase(Core, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        self.assertIsInstance(POINTER(Sub), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
+
+    def test_creating_pointer_in_dunder_init_1(self):
+        class ct_meta(type):
+            def __init__(self, name, bases, namespace):
+                super().__init__(name, bases, namespace)
+
+                # Avoid recursion.
+                # (See test_creating_pointer_in_dunder_new_1)
+                if bases == (c_void_p,):
+                    return
+                if issubclass(self, PtrBase):
+                    return
+                if bases == (object,):
+                    ptr_bases = (self, PtrBase)
+                else:
+                    ptr_bases = (self, POINTER(bases[0]))
+                p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
+                ctypes._pointer_type_cache[self] = p
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class PtrBase(c_void_p, metaclass=p_meta):
+            pass
+
+        class CtBase(object, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        class Sub2(Sub):
+            pass
+
+        self.assertIsInstance(POINTER(Sub2), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
+
+    def test_creating_pointer_in_dunder_init_2(self):
+        class ct_meta(type):
+            def __init__(self, name, bases, namespace):
+                super().__init__(name, bases, namespace)
+
+                # Avoid recursion.
+                # (See test_creating_pointer_in_dunder_new_2)
+                if isinstance(self, p_meta):
+                    return
+                p = p_meta(f"POINTER({self.__name__})", (self, c_void_p), {})
+                ctypes._pointer_type_cache[self] = p
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class Core(object):
+            pass
+
+        class CtBase(Core, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        self.assertIsInstance(POINTER(Sub), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
diff --git a/Lib/test/test_ctypes/test_callbacks.py b/Lib/test/test_ctypes/test_callbacks.py
new file mode 100644
index 00000000000..8f483dfe1db
--- /dev/null
+++ b/Lib/test/test_ctypes/test_callbacks.py
@@ -0,0 +1,333 @@
+import ctypes
+import functools
+import gc
+import math
+import sys
+import unittest
+from _ctypes import CTYPES_MAX_ARGCOUNT
+from ctypes import (CDLL, cdll, Structure, CFUNCTYPE,
+                    ArgumentError, POINTER, sizeof,
+                    c_byte, c_ubyte, c_char,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_longlong, c_ulonglong, c_ulong,
+                    c_float, c_double, c_longdouble, py_object)
+from ctypes.util import find_library
+from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class Callbacks(unittest.TestCase):
+    functype = CFUNCTYPE
+
+    def callback(self, *args):
+        self.got_args = args
+        return args[-1]
+
+    def check_type(self, typ, arg):
+        PROTO = self.functype.__func__(typ, typ)
+        result = PROTO(self.callback)(arg)
+        if typ == c_float:
+            self.assertAlmostEqual(result, arg, places=5)
+        else:
+            self.assertEqual(self.got_args, (arg,))
+            self.assertEqual(result, arg)
+
+        PROTO = self.functype.__func__(typ, c_byte, typ)
+        result = PROTO(self.callback)(-3, arg)
+        if typ == c_float:
+            self.assertAlmostEqual(result, arg, places=5)
+        else:
+            self.assertEqual(self.got_args, (-3, arg))
+            self.assertEqual(result, arg)
+
+    def test_byte(self):
+        self.check_type(c_byte, 42)
+        self.check_type(c_byte, -42)
+
+    def test_ubyte(self):
+        self.check_type(c_ubyte, 42)
+
+    def test_short(self):
+        self.check_type(c_short, 42)
+        self.check_type(c_short, -42)
+
+    def test_ushort(self):
+        self.check_type(c_ushort, 42)
+
+    def test_int(self):
+        self.check_type(c_int, 42)
+        self.check_type(c_int, -42)
+
+    def test_uint(self):
+        self.check_type(c_uint, 42)
+
+    def test_long(self):
+        self.check_type(c_long, 42)
+        self.check_type(c_long, -42)
+
+    def test_ulong(self):
+        self.check_type(c_ulong, 42)
+
+    def test_longlong(self):
+        self.check_type(c_longlong, 42)
+        self.check_type(c_longlong, -42)
+
+    def test_ulonglong(self):
+        self.check_type(c_ulonglong, 42)
+
+    def test_float(self):
+        # only almost equal: double -> float -> double
+        self.check_type(c_float, math.e)
+        self.check_type(c_float, -math.e)
+
+    def test_double(self):
+        self.check_type(c_double, 3.14)
+        self.check_type(c_double, -3.14)
+
+    def test_longdouble(self):
+        self.check_type(c_longdouble, 3.14)
+        self.check_type(c_longdouble, -3.14)
+
+    def test_char(self):
+        self.check_type(c_char, b"x")
+        self.check_type(c_char, b"a")
+
+    def test_pyobject(self):
+        o = ()
+        for o in (), [], object():
+            initial = sys.getrefcount(o)
+            # This call leaks a reference to 'o'...
+            self.check_type(py_object, o)
+            before = sys.getrefcount(o)
+            # ...but this call doesn't leak any more.  Where is the refcount?
+            self.check_type(py_object, o)
+            after = sys.getrefcount(o)
+            self.assertEqual((after, o), (before, o))
+
+    def test_unsupported_restype_1(self):
+        # Only "fundamental" result types are supported for callback
+        # functions, the type must have a non-NULL stginfo->setfunc.
+        # POINTER(c_double), for example, is not supported.
+
+        prototype = self.functype.__func__(POINTER(c_double))
+        # The type is checked when the prototype is called
+        self.assertRaises(TypeError, prototype, lambda: None)
+
+    def test_unsupported_restype_2(self):
+        prototype = self.functype.__func__(object)
+        self.assertRaises(TypeError, prototype, lambda: None)
+
+    def test_issue_7959(self):
+        proto = self.functype.__func__(None)
+
+        class X:
+            def func(self): pass
+            def __init__(self):
+                self.v = proto(self.func)
+
+        for i in range(32):
+            X()
+        gc.collect()
+        live = [x for x in gc.get_objects()
+                if isinstance(x, X)]
+        self.assertEqual(len(live), 0)
+
+    def test_issue12483(self):
+        class Nasty:
+            def __del__(self):
+                gc.collect()
+        CFUNCTYPE(None)(lambda x=Nasty(): None)
+
+    @unittest.skipUnless(hasattr(ctypes, 'WINFUNCTYPE'),
+                         'ctypes.WINFUNCTYPE is required')
+    def test_i38748_stackCorruption(self):
+        callback_funcType = ctypes.WINFUNCTYPE(c_long, c_long, c_longlong)
+        @callback_funcType
+        def callback(a, b):
+            c = a + b
+            print(f"a={a}, b={b}, c={c}")
+            return c
+        dll = cdll[_ctypes_test.__file__]
+        with support.captured_stdout() as out:
+            # With no fix for i38748, the next line will raise OSError and cause the test to fail.
+            self.assertEqual(dll._test_i38748_runCallback(callback, 5, 10), 15)
+            self.assertEqual(out.getvalue(), "a=5, b=10, c=15\n")
+
+if hasattr(ctypes, 'WINFUNCTYPE'):
+    class StdcallCallbacks(Callbacks):
+        functype = ctypes.WINFUNCTYPE
+
+
+class SampleCallbacksTestCase(unittest.TestCase):
+
+    def test_integrate(self):
+        # Derived from some then non-working code, posted by David Foster
+        dll = CDLL(_ctypes_test.__file__)
+
+        # The function prototype called by 'integrate': double func(double);
+        CALLBACK = CFUNCTYPE(c_double, c_double)
+
+        # The integrate function itself, exposed from the _ctypes_test dll
+        integrate = dll.integrate
+        integrate.argtypes = (c_double, c_double, CALLBACK, c_long)
+        integrate.restype = c_double
+
+        def func(x):
+            return x**2
+
+        result = integrate(0.0, 1.0, CALLBACK(func), 10)
+        diff = abs(result - 1./3.)
+
+        self.assertLess(diff, 0.01, "%s not less than 0.01" % diff)
+
+    def test_issue_8959_a(self):
+        libc_path = find_library("c")
+        if not libc_path:
+            self.skipTest('could not find libc')
+        libc = CDLL(libc_path)
+
+        @CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
+        def cmp_func(a, b):
+            return a[0] - b[0]
+
+        array = (c_int * 5)(5, 1, 99, 7, 33)
+
+        libc.qsort(array, len(array), sizeof(c_int), cmp_func)
+        self.assertEqual(array[:], [1, 5, 7, 33, 99])
+
+    @unittest.skipUnless(hasattr(ctypes, 'WINFUNCTYPE'),
+                         'ctypes.WINFUNCTYPE is required')
+    def test_issue_8959_b(self):
+        from ctypes.wintypes import BOOL, HWND, LPARAM
+        global windowCount
+        windowCount = 0
+
+        @ctypes.WINFUNCTYPE(BOOL, HWND, LPARAM)
+        def EnumWindowsCallbackFunc(hwnd, lParam):
+            global windowCount
+            windowCount += 1
+            return True #Allow windows to keep enumerating
+
+        user32 = ctypes.windll.user32
+        user32.EnumWindows(EnumWindowsCallbackFunc, 0)
+
+    def test_callback_register_int(self):
+        # Issue #8275: buggy handling of callback args under Win64
+        # NOTE: should be run on release builds as well
+        dll = CDLL(_ctypes_test.__file__)
+        CALLBACK = CFUNCTYPE(c_int, c_int, c_int, c_int, c_int, c_int)
+        # All this function does is call the callback with its args squared
+        func = dll._testfunc_cbk_reg_int
+        func.argtypes = (c_int, c_int, c_int, c_int, c_int, CALLBACK)
+        func.restype = c_int
+
+        def callback(a, b, c, d, e):
+            return a + b + c + d + e
+
+        result = func(2, 3, 4, 5, 6, CALLBACK(callback))
+        self.assertEqual(result, callback(2*2, 3*3, 4*4, 5*5, 6*6))
+
+    def test_callback_register_double(self):
+        # Issue #8275: buggy handling of callback args under Win64
+        # NOTE: should be run on release builds as well
+        dll = CDLL(_ctypes_test.__file__)
+        CALLBACK = CFUNCTYPE(c_double, c_double, c_double, c_double,
+                             c_double, c_double)
+        # All this function does is call the callback with its args squared
+        func = dll._testfunc_cbk_reg_double
+        func.argtypes = (c_double, c_double, c_double,
+                         c_double, c_double, CALLBACK)
+        func.restype = c_double
+
+        def callback(a, b, c, d, e):
+            return a + b + c + d + e
+
+        result = func(1.1, 2.2, 3.3, 4.4, 5.5, CALLBACK(callback))
+        self.assertEqual(result,
+                         callback(1.1*1.1, 2.2*2.2, 3.3*3.3, 4.4*4.4, 5.5*5.5))
+
+    def test_callback_large_struct(self):
+        class Check: pass
+
+        # This should mirror the structure in Modules/_ctypes/_ctypes_test.c
+        class X(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+
+        def callback(check, s):
+            check.first = s.first
+            check.second = s.second
+            check.third = s.third
+            # See issue #29565.
+            # The structure should be passed by value, so
+            # any changes to it should not be reflected in
+            # the value passed
+            s.first = s.second = s.third = 0x0badf00d
+
+        check = Check()
+        s = X()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        s.third = 0x0bad1dea
+
+        CALLBACK = CFUNCTYPE(None, X)
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_cbk_large_struct
+        func.argtypes = (X, CALLBACK)
+        func.restype = None
+        # the function just calls the callback with the passed structure
+        func(s, CALLBACK(functools.partial(callback, check)))
+        self.assertEqual(check.first, s.first)
+        self.assertEqual(check.second, s.second)
+        self.assertEqual(check.third, s.third)
+        self.assertEqual(check.first, 0xdeadbeef)
+        self.assertEqual(check.second, 0xcafebabe)
+        self.assertEqual(check.third, 0x0bad1dea)
+        # See issue #29565.
+        # Ensure that the original struct is unchanged.
+        self.assertEqual(s.first, check.first)
+        self.assertEqual(s.second, check.second)
+        self.assertEqual(s.third, check.third)
+
+    def test_callback_too_many_args(self):
+        def func(*args):
+            return len(args)
+
+        # valid call with nargs <= CTYPES_MAX_ARGCOUNT
+        proto = CFUNCTYPE(c_int, *(c_int,) * CTYPES_MAX_ARGCOUNT)
+        cb = proto(func)
+        args1 = (1,) * CTYPES_MAX_ARGCOUNT
+        self.assertEqual(cb(*args1), CTYPES_MAX_ARGCOUNT)
+
+        # invalid call with nargs > CTYPES_MAX_ARGCOUNT
+        args2 = (1,) * (CTYPES_MAX_ARGCOUNT + 1)
+        with self.assertRaises(ArgumentError):
+            cb(*args2)
+
+        # error when creating the type with too many arguments
+        with self.assertRaises(ArgumentError):
+            CFUNCTYPE(c_int, *(c_int,) * (CTYPES_MAX_ARGCOUNT + 1))
+
+    def test_convert_result_error(self):
+        def func():
+            return ("tuple",)
+
+        proto = CFUNCTYPE(c_int)
+        ctypes_func = proto(func)
+        with support.catch_unraisable_exception() as cm:
+            # don't test the result since it is an uninitialized value
+            result = ctypes_func()
+
+            self.assertIsInstance(cm.unraisable.exc_value, TypeError)
+            self.assertEqual(cm.unraisable.err_msg,
+                             f"Exception ignored on converting result "
+                             f"of ctypes callback function {func!r}")
+            self.assertIsNone(cm.unraisable.object)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_cast.py b/Lib/test/test_ctypes/test_cast.py
new file mode 100644
index 00000000000..604f44f03d6
--- /dev/null
+++ b/Lib/test/test_ctypes/test_cast.py
@@ -0,0 +1,100 @@
+import sys
+import unittest
+from ctypes import (Structure, Union, POINTER, cast, sizeof, addressof,
+                    c_void_p, c_char_p, c_wchar_p,
+                    c_byte, c_short, c_int)
+
+
+class Test(unittest.TestCase):
+    def test_array2pointer(self):
+        array = (c_int * 3)(42, 17, 2)
+
+        # casting an array to a pointer works.
+        ptr = cast(array, POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+        if 2 * sizeof(c_short) == sizeof(c_int):
+            ptr = cast(array, POINTER(c_short))
+            if sys.byteorder == "little":
+                self.assertEqual([ptr[i] for i in range(6)],
+                                     [42, 0, 17, 0, 2, 0])
+            else:
+                self.assertEqual([ptr[i] for i in range(6)],
+                                     [0, 42, 0, 17, 0, 2])
+
+    def test_address2pointer(self):
+        array = (c_int * 3)(42, 17, 2)
+
+        address = addressof(array)
+        ptr = cast(c_void_p(address), POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+        ptr = cast(address, POINTER(c_int))
+        self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
+
+    def test_p2a_objects(self):
+        array = (c_char_p * 5)()
+        self.assertEqual(array._objects, None)
+        array[0] = b"foo bar"
+        self.assertEqual(array._objects, {'0': b"foo bar"})
+
+        p = cast(array, POINTER(c_char_p))
+        # array and p share a common _objects attribute
+        self.assertIs(p._objects, array._objects)
+        self.assertEqual(array._objects, {'0': b"foo bar", id(array): array})
+        p[0] = b"spam spam"
+        self.assertEqual(p._objects, {'0': b"spam spam", id(array): array})
+        self.assertIs(array._objects, p._objects)
+        p[1] = b"foo bar"
+        self.assertEqual(p._objects, {'1': b'foo bar', '0': b"spam spam", id(array): array})
+        self.assertIs(array._objects, p._objects)
+
+    def test_other(self):
+        p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
+        self.assertEqual(p[:4], [1,2, 3, 4])
+        self.assertEqual(p[:4:], [1, 2, 3, 4])
+        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        c_int()
+        self.assertEqual(p[:4], [1, 2, 3, 4])
+        self.assertEqual(p[:4:], [1, 2, 3, 4])
+        self.assertEqual(p[3:-1:-1], [4, 3, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        p[2] = 96
+        self.assertEqual(p[:4], [1, 2, 96, 4])
+        self.assertEqual(p[:4:], [1, 2, 96, 4])
+        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+        c_int()
+        self.assertEqual(p[:4], [1, 2, 96, 4])
+        self.assertEqual(p[:4:], [1, 2, 96, 4])
+        self.assertEqual(p[3:-1:-1], [4, 96, 2, 1])
+        self.assertEqual(p[:4:3], [1, 4])
+
+    def test_char_p(self):
+        # This didn't work: bad argument to internal function
+        s = c_char_p(b"hiho")
+        self.assertEqual(cast(cast(s, c_void_p), c_char_p).value,
+                             b"hiho")
+
+    def test_wchar_p(self):
+        s = c_wchar_p("hiho")
+        self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
+                         "hiho")
+
+    def test_bad_type_arg(self):
+        # The type argument must be a ctypes pointer type.
+        array_type = c_byte * sizeof(c_int)
+        array = array_type()
+        self.assertRaises(TypeError, cast, array, None)
+        self.assertRaises(TypeError, cast, array, array_type)
+        class Struct(Structure):
+            _fields_ = [("a", c_int)]
+        self.assertRaises(TypeError, cast, array, Struct)
+        class MyUnion(Union):
+            _fields_ = [("a", c_int)]
+        self.assertRaises(TypeError, cast, array, MyUnion)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_cfuncs.py b/Lib/test/test_ctypes/test_cfuncs.py
new file mode 100644
index 00000000000..48330c4b0a7
--- /dev/null
+++ b/Lib/test/test_ctypes/test_cfuncs.py
@@ -0,0 +1,211 @@
+import ctypes
+import unittest
+from ctypes import (CDLL,
+                    c_byte, c_ubyte, c_char,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class CFunctions(unittest.TestCase):
+    _dll = CDLL(_ctypes_test.__file__)
+
+    def S(self):
+        return c_longlong.in_dll(self._dll, "last_tf_arg_s").value
+    def U(self):
+        return c_ulonglong.in_dll(self._dll, "last_tf_arg_u").value
+
+    def test_byte(self):
+        self._dll.tf_b.restype = c_byte
+        self._dll.tf_b.argtypes = (c_byte,)
+        self.assertEqual(self._dll.tf_b(-126), -42)
+        self.assertEqual(self.S(), -126)
+
+    def test_byte_plus(self):
+        self._dll.tf_bb.restype = c_byte
+        self._dll.tf_bb.argtypes = (c_byte, c_byte)
+        self.assertEqual(self._dll.tf_bb(0, -126), -42)
+        self.assertEqual(self.S(), -126)
+
+    def test_ubyte(self):
+        self._dll.tf_B.restype = c_ubyte
+        self._dll.tf_B.argtypes = (c_ubyte,)
+        self.assertEqual(self._dll.tf_B(255), 85)
+        self.assertEqual(self.U(), 255)
+
+    def test_ubyte_plus(self):
+        self._dll.tf_bB.restype = c_ubyte
+        self._dll.tf_bB.argtypes = (c_byte, c_ubyte)
+        self.assertEqual(self._dll.tf_bB(0, 255), 85)
+        self.assertEqual(self.U(), 255)
+
+    def test_short(self):
+        self._dll.tf_h.restype = c_short
+        self._dll.tf_h.argtypes = (c_short,)
+        self.assertEqual(self._dll.tf_h(-32766), -10922)
+        self.assertEqual(self.S(), -32766)
+
+    def test_short_plus(self):
+        self._dll.tf_bh.restype = c_short
+        self._dll.tf_bh.argtypes = (c_byte, c_short)
+        self.assertEqual(self._dll.tf_bh(0, -32766), -10922)
+        self.assertEqual(self.S(), -32766)
+
+    def test_ushort(self):
+        self._dll.tf_H.restype = c_ushort
+        self._dll.tf_H.argtypes = (c_ushort,)
+        self.assertEqual(self._dll.tf_H(65535), 21845)
+        self.assertEqual(self.U(), 65535)
+
+    def test_ushort_plus(self):
+        self._dll.tf_bH.restype = c_ushort
+        self._dll.tf_bH.argtypes = (c_byte, c_ushort)
+        self.assertEqual(self._dll.tf_bH(0, 65535), 21845)
+        self.assertEqual(self.U(), 65535)
+
+    def test_int(self):
+        self._dll.tf_i.restype = c_int
+        self._dll.tf_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tf_i(-2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_int_plus(self):
+        self._dll.tf_bi.restype = c_int
+        self._dll.tf_bi.argtypes = (c_byte, c_int)
+        self.assertEqual(self._dll.tf_bi(0, -2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_uint(self):
+        self._dll.tf_I.restype = c_uint
+        self._dll.tf_I.argtypes = (c_uint,)
+        self.assertEqual(self._dll.tf_I(4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_uint_plus(self):
+        self._dll.tf_bI.restype = c_uint
+        self._dll.tf_bI.argtypes = (c_byte, c_uint)
+        self.assertEqual(self._dll.tf_bI(0, 4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_long(self):
+        self._dll.tf_l.restype = c_long
+        self._dll.tf_l.argtypes = (c_long,)
+        self.assertEqual(self._dll.tf_l(-2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_long_plus(self):
+        self._dll.tf_bl.restype = c_long
+        self._dll.tf_bl.argtypes = (c_byte, c_long)
+        self.assertEqual(self._dll.tf_bl(0, -2147483646), -715827882)
+        self.assertEqual(self.S(), -2147483646)
+
+    def test_ulong(self):
+        self._dll.tf_L.restype = c_ulong
+        self._dll.tf_L.argtypes = (c_ulong,)
+        self.assertEqual(self._dll.tf_L(4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_ulong_plus(self):
+        self._dll.tf_bL.restype = c_ulong
+        self._dll.tf_bL.argtypes = (c_char, c_ulong)
+        self.assertEqual(self._dll.tf_bL(b' ', 4294967295), 1431655765)
+        self.assertEqual(self.U(), 4294967295)
+
+    def test_longlong(self):
+        self._dll.tf_q.restype = c_longlong
+        self._dll.tf_q.argtypes = (c_longlong, )
+        self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
+        self.assertEqual(self.S(), -9223372036854775806)
+
+    def test_longlong_plus(self):
+        self._dll.tf_bq.restype = c_longlong
+        self._dll.tf_bq.argtypes = (c_byte, c_longlong)
+        self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
+        self.assertEqual(self.S(), -9223372036854775806)
+
+    def test_ulonglong(self):
+        self._dll.tf_Q.restype = c_ulonglong
+        self._dll.tf_Q.argtypes = (c_ulonglong, )
+        self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
+        self.assertEqual(self.U(), 18446744073709551615)
+
+    def test_ulonglong_plus(self):
+        self._dll.tf_bQ.restype = c_ulonglong
+        self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
+        self.assertEqual(self._dll.tf_bQ(0, 18446744073709551615), 6148914691236517205)
+        self.assertEqual(self.U(), 18446744073709551615)
+
+    def test_float(self):
+        self._dll.tf_f.restype = c_float
+        self._dll.tf_f.argtypes = (c_float,)
+        self.assertEqual(self._dll.tf_f(-42.), -14.)
+        self.assertEqual(self.S(), -42)
+
+    def test_float_plus(self):
+        self._dll.tf_bf.restype = c_float
+        self._dll.tf_bf.argtypes = (c_byte, c_float)
+        self.assertEqual(self._dll.tf_bf(0, -42.), -14.)
+        self.assertEqual(self.S(), -42)
+
+    def test_double(self):
+        self._dll.tf_d.restype = c_double
+        self._dll.tf_d.argtypes = (c_double,)
+        self.assertEqual(self._dll.tf_d(42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_double_plus(self):
+        self._dll.tf_bd.restype = c_double
+        self._dll.tf_bd.argtypes = (c_byte, c_double)
+        self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_longdouble(self):
+        self._dll.tf_D.restype = c_longdouble
+        self._dll.tf_D.argtypes = (c_longdouble,)
+        self.assertEqual(self._dll.tf_D(42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_longdouble_plus(self):
+        self._dll.tf_bD.restype = c_longdouble
+        self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
+        self.assertEqual(self._dll.tf_bD(0, 42.), 14.)
+        self.assertEqual(self.S(), 42)
+
+    def test_callwithresult(self):
+        def process_result(result):
+            return result * 2
+        self._dll.tf_i.restype = process_result
+        self._dll.tf_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tf_i(42), 28)
+        self.assertEqual(self.S(), 42)
+        self.assertEqual(self._dll.tf_i(-42), -28)
+        self.assertEqual(self.S(), -42)
+
+    def test_void(self):
+        self._dll.tv_i.restype = None
+        self._dll.tv_i.argtypes = (c_int,)
+        self.assertEqual(self._dll.tv_i(42), None)
+        self.assertEqual(self.S(), 42)
+        self.assertEqual(self._dll.tv_i(-42), None)
+        self.assertEqual(self.S(), -42)
+
+
+# The following repeats the above tests with stdcall functions (where
+# they are available)
+if hasattr(ctypes, 'WinDLL'):
+    class stdcall_dll(ctypes.WinDLL):
+        def __getattr__(self, name):
+            if name[:2] == '__' and name[-2:] == '__':
+                raise AttributeError(name)
+            func = self._FuncPtr(("s_" + name, self))
+            setattr(self, name, func)
+            return func
+
+    class stdcallCFunctions(CFunctions):
+        _dll = stdcall_dll(_ctypes_test.__file__)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_checkretval.py b/Lib/test/test_ctypes/test_checkretval.py
new file mode 100644
index 00000000000..9d6bfdb845e
--- /dev/null
+++ b/Lib/test/test_ctypes/test_checkretval.py
@@ -0,0 +1,37 @@
+import ctypes
+import unittest
+from ctypes import CDLL, c_int
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class CHECKED(c_int):
+    def _check_retval_(value):
+        # Receives a CHECKED instance.
+        return str(value.value)
+    _check_retval_ = staticmethod(_check_retval_)
+
+
+class Test(unittest.TestCase):
+    def test_checkretval(self):
+        dll = CDLL(_ctypes_test.__file__)
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = CHECKED
+        self.assertEqual("42", dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = None
+        self.assertEqual(None, dll._testfunc_p_p(42))
+
+        del dll._testfunc_p_p.restype
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+    @unittest.skipUnless(hasattr(ctypes, 'oledll'),
+                         'ctypes.oledll is required')
+    def test_oledll(self):
+        oleaut32 = ctypes.oledll.oleaut32
+        self.assertRaises(OSError, oleaut32.CreateTypeLib2, 0, None, None)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_delattr.py b/Lib/test/test_ctypes/test_delattr.py
new file mode 100644
index 00000000000..e80b5fa6efb
--- /dev/null
+++ b/Lib/test/test_ctypes/test_delattr.py
@@ -0,0 +1,26 @@
+import unittest
+from ctypes import Structure, c_char, c_int
+
+
+class X(Structure):
+    _fields_ = [("foo", c_int)]
+
+
+class TestCase(unittest.TestCase):
+    def test_simple(self):
+        with self.assertRaises(TypeError):
+            del c_int(42).value
+
+    def test_chararray(self):
+        chararray = (c_char * 5)()
+        with self.assertRaises(TypeError):
+            del chararray.value
+
+    def test_struct(self):
+        struct = X()
+        with self.assertRaises(TypeError):
+            del struct.foo
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_dlerror.py b/Lib/test/test_ctypes/test_dlerror.py
new file mode 100644
index 00000000000..1c1b2aab3d5
--- /dev/null
+++ b/Lib/test/test_ctypes/test_dlerror.py
@@ -0,0 +1,179 @@
+import _ctypes
+import os
+import platform
+import sys
+import test.support
+import unittest
+from ctypes import CDLL, c_int
+from ctypes.util import find_library
+
+
+FOO_C = r"""
+#include <unistd.h>
+
+/* This is a 'GNU indirect function' (IFUNC) that will be called by
+   dlsym() to resolve the symbol "foo" to an address. Typically, such
+   a function would return the address of an actual function, but it
+   can also just return NULL.  For some background on IFUNCs, see
+   https://willnewton.name/uncategorized/using-gnu-indirect-functions.
+
+   Adapted from Michael Kerrisk's answer: https://stackoverflow.com/a/53590014.
+*/
+
+asm (".type foo STT_GNU_IFUNC");
+
+void *foo(void)
+{
+    write($DESCRIPTOR, "OK", 2);
+    return NULL;
+}
+"""
+
+
+@unittest.skipUnless(sys.platform.startswith('linux'),
+                     'test requires GNU IFUNC support')
+class TestNullDlsym(unittest.TestCase):
+    """GH-126554: Ensure that we catch NULL dlsym return values
+
+    In rare cases, such as when using GNU IFUNCs, dlsym(),
+    the C function that ctypes' CDLL uses to get the address
+    of symbols, can return NULL.
+
+    The objective way of telling if an error during symbol
+    lookup happened is to call glibc's dlerror() and check
+    for a non-NULL return value.
+
+    However, there can be cases where dlsym() returns NULL
+    and dlerror() is also NULL, meaning that glibc did not
+    encounter any error.
+
+    In the case of ctypes, we subjectively treat that as
+    an error, and throw a relevant exception.
+
+    This test case ensures that we correctly enforce
+    this 'dlsym returned NULL -> throw Error' rule.
+    """
+
+    def test_null_dlsym(self):
+        import subprocess
+        import tempfile
+
+        try:
+            retcode = subprocess.call(["gcc", "--version"],
+                                      stdout=subprocess.DEVNULL,
+                                      stderr=subprocess.DEVNULL)
+        except OSError:
+            self.skipTest("gcc is missing")
+        if retcode != 0:
+            self.skipTest("gcc --version failed")
+
+        pipe_r, pipe_w = os.pipe()
+        self.addCleanup(os.close, pipe_r)
+        self.addCleanup(os.close, pipe_w)
+
+        with tempfile.TemporaryDirectory() as d:
+            # Create a C file with a GNU Indirect Function (FOO_C)
+            # and compile it into a shared library.
+            srcname = os.path.join(d, 'foo.c')
+            dstname = os.path.join(d, 'libfoo.so')
+            with open(srcname, 'w') as f:
+                f.write(FOO_C.replace('$DESCRIPTOR', str(pipe_w)))
+            args = ['gcc', '-fPIC', '-shared', '-o', dstname, srcname]
+            p = subprocess.run(args, capture_output=True)
+
+            if p.returncode != 0:
+                # IFUNC is not supported on all architectures.
+                if platform.machine() == 'x86_64':
+                    # It should be supported here. Something else went wrong.
+                    p.check_returncode()
+                else:
+                    # IFUNC might not be supported on this machine.
+                    self.skipTest(f"could not compile indirect function: {p}")
+
+            # Case #1: Test 'PyCFuncPtr_FromDll' from Modules/_ctypes/_ctypes.c
+            L = CDLL(dstname)
+            with self.assertRaisesRegex(AttributeError, "function 'foo' not found"):
+                # Try accessing the 'foo' symbol.
+                # It should resolve via dlsym() to NULL,
+                # and since we subjectively treat NULL
+                # addresses as errors, we should get
+                # an error.
+                L.foo
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+            # Case #2: Test 'CDataType_in_dll_impl' from Modules/_ctypes/_ctypes.c
+            with self.assertRaisesRegex(ValueError, "symbol 'foo' not found"):
+                c_int.in_dll(L, "foo")
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+            # Case #3: Test 'py_dl_sym' from Modules/_ctypes/callproc.c
+            dlopen = test.support.get_attribute(_ctypes, 'dlopen')
+            dlsym = test.support.get_attribute(_ctypes, 'dlsym')
+            L = dlopen(dstname)
+            with self.assertRaisesRegex(OSError, "symbol 'foo' not found"):
+                dlsym(L, "foo")
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+
+@unittest.skipUnless(os.name != 'nt', 'test requires dlerror() calls')
+class TestLocalization(unittest.TestCase):
+
+    @staticmethod
+    def configure_locales(func):
+        return test.support.run_with_locale(
+            'LC_ALL',
+            'fr_FR.iso88591', 'ja_JP.sjis', 'zh_CN.gbk',
+            'fr_FR.utf8', 'en_US.utf8',
+            '',
+        )(func)
+
+    @classmethod
+    def setUpClass(cls):
+        cls.libc_filename = find_library("c")
+        if cls.libc_filename is None:
+            raise unittest.SkipTest('cannot find libc')
+
+    @configure_locales
+    def test_localized_error_from_dll(self):
+        dll = CDLL(self.libc_filename)
+        with self.assertRaises(AttributeError):
+            dll.this_name_does_not_exist
+
+    @configure_locales
+    def test_localized_error_in_dll(self):
+        dll = CDLL(self.libc_filename)
+        with self.assertRaises(ValueError):
+            c_int.in_dll(dll, 'this_name_does_not_exist')
+
+    @unittest.skipUnless(hasattr(_ctypes, 'dlopen'),
+                         'test requires _ctypes.dlopen()')
+    @configure_locales
+    def test_localized_error_dlopen(self):
+        missing_filename = b'missing\xff.so'
+        # Depending whether the locale, we may encode '\xff' differently
+        # but we are only interested in avoiding a UnicodeDecodeError
+        # when reporting the dlerror() error message which contains
+        # the localized filename.
+        filename_pattern = r'missing.*?\.so'
+        with self.assertRaisesRegex(OSError, filename_pattern):
+            _ctypes.dlopen(missing_filename, 2)
+
+    @unittest.skipUnless(hasattr(_ctypes, 'dlopen'),
+                         'test requires _ctypes.dlopen()')
+    @unittest.skipUnless(hasattr(_ctypes, 'dlsym'),
+                         'test requires _ctypes.dlsym()')
+    @configure_locales
+    def test_localized_error_dlsym(self):
+        dll = _ctypes.dlopen(self.libc_filename)
+        with self.assertRaises(OSError):
+            _ctypes.dlsym(dll, 'this_name_does_not_exist')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_errno.py b/Lib/test/test_ctypes/test_errno.py
new file mode 100644
index 00000000000..65d99c1e492
--- /dev/null
+++ b/Lib/test/test_ctypes/test_errno.py
@@ -0,0 +1,81 @@
+import ctypes
+import errno
+import os
+import threading
+import unittest
+from ctypes import CDLL, c_int, c_char_p, c_wchar_p, get_errno, set_errno
+from ctypes.util import find_library
+
+
+class Test(unittest.TestCase):
+    def test_open(self):
+        libc_name = find_library("c")
+        if libc_name is None:
+            self.skipTest("Unable to find C library")
+
+        libc = CDLL(libc_name, use_errno=True)
+        if os.name == "nt":
+            libc_open = libc._open
+        else:
+            libc_open = libc.open
+
+        libc_open.argtypes = c_char_p, c_int
+
+        self.assertEqual(libc_open(b"", 0), -1)
+        self.assertEqual(get_errno(), errno.ENOENT)
+
+        self.assertEqual(set_errno(32), errno.ENOENT)
+        self.assertEqual(get_errno(), 32)
+
+        def _worker():
+            set_errno(0)
+
+            libc = CDLL(libc_name, use_errno=False)
+            if os.name == "nt":
+                libc_open = libc._open
+            else:
+                libc_open = libc.open
+            libc_open.argtypes = c_char_p, c_int
+            self.assertEqual(libc_open(b"", 0), -1)
+            self.assertEqual(get_errno(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(get_errno(), 32)
+        set_errno(0)
+
+    @unittest.skipUnless(os.name == "nt", 'Test specific to Windows')
+    def test_GetLastError(self):
+        dll = ctypes.WinDLL("kernel32", use_last_error=True)
+        GetModuleHandle = dll.GetModuleHandleA
+        GetModuleHandle.argtypes = [c_wchar_p]
+
+        self.assertEqual(0, GetModuleHandle("foo"))
+        self.assertEqual(ctypes.get_last_error(), 126)
+
+        self.assertEqual(ctypes.set_last_error(32), 126)
+        self.assertEqual(ctypes.get_last_error(), 32)
+
+        def _worker():
+            ctypes.set_last_error(0)
+
+            dll = ctypes.WinDLL("kernel32", use_last_error=False)
+            GetModuleHandle = dll.GetModuleHandleW
+            GetModuleHandle.argtypes = [c_wchar_p]
+            GetModuleHandle("bar")
+
+            self.assertEqual(ctypes.get_last_error(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(ctypes.get_last_error(), 32)
+
+        ctypes.set_last_error(0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_find.py b/Lib/test/test_ctypes/test_find.py
new file mode 100644
index 00000000000..85b28617d2d
--- /dev/null
+++ b/Lib/test/test_ctypes/test_find.py
@@ -0,0 +1,156 @@
+import os.path
+import sys
+import test.support
+import unittest
+import unittest.mock
+from ctypes import CDLL, RTLD_GLOBAL
+from ctypes.util import find_library
+from test.support import os_helper
+
+
+# On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.
+class Test_OpenGL_libs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        lib_gl = lib_glu = lib_gle = None
+        if sys.platform == "win32":
+            lib_gl = find_library("OpenGL32")
+            lib_glu = find_library("Glu32")
+        elif sys.platform == "darwin":
+            lib_gl = lib_glu = find_library("OpenGL")
+        else:
+            lib_gl = find_library("GL")
+            lib_glu = find_library("GLU")
+            lib_gle = find_library("gle")
+
+        # print, for debugging
+        if test.support.verbose:
+            print("OpenGL libraries:")
+            for item in (("GL", lib_gl),
+                         ("GLU", lib_glu),
+                         ("gle", lib_gle)):
+                print("\t", item)
+
+        cls.gl = cls.glu = cls.gle = None
+        if lib_gl:
+            try:
+                cls.gl = CDLL(lib_gl, mode=RTLD_GLOBAL)
+            except OSError:
+                pass
+
+        if lib_glu:
+            try:
+                cls.glu = CDLL(lib_glu, RTLD_GLOBAL)
+            except OSError:
+                pass
+
+        if lib_gle:
+            try:
+                cls.gle = CDLL(lib_gle)
+            except OSError:
+                pass
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.gl = cls.glu = cls.gle = None
+
+    def test_gl(self):
+        if self.gl is None:
+            self.skipTest('lib_gl not available')
+        self.gl.glClearIndex
+
+    def test_glu(self):
+        if self.glu is None:
+            self.skipTest('lib_glu not available')
+        self.glu.gluBeginCurve
+
+    def test_gle(self):
+        if self.gle is None:
+            self.skipTest('lib_gle not available')
+        self.gle.gleGetJoinStyle
+
+    def test_shell_injection(self):
+        result = find_library('; echo Hello shell > ' + os_helper.TESTFN)
+        self.assertFalse(os.path.lexists(os_helper.TESTFN))
+        self.assertIsNone(result)
+
+
+@unittest.skipUnless(sys.platform.startswith('linux'),
+                     'Test only valid for Linux')
+class FindLibraryLinux(unittest.TestCase):
+    def test_find_on_libpath(self):
+        import subprocess
+        import tempfile
+
+        try:
+            p = subprocess.Popen(['gcc', '--version'], stdout=subprocess.PIPE,
+                                 stderr=subprocess.DEVNULL)
+            out, _ = p.communicate()
+        except OSError:
+            raise unittest.SkipTest('gcc, needed for test, not available')
+        with tempfile.TemporaryDirectory() as d:
+            # create an empty temporary file
+            srcname = os.path.join(d, 'dummy.c')
+            libname = 'py_ctypes_test_dummy'
+            dstname = os.path.join(d, 'lib%s.so' % libname)
+            with open(srcname, 'wb') as f:
+                pass
+            self.assertTrue(os.path.exists(srcname))
+            # compile the file to a shared library
+            cmd = ['gcc', '-o', dstname, '--shared',
+                   '-Wl,-soname,lib%s.so' % libname, srcname]
+            out = subprocess.check_output(cmd)
+            self.assertTrue(os.path.exists(dstname))
+            # now check that the .so can't be found (since not in
+            # LD_LIBRARY_PATH)
+            self.assertIsNone(find_library(libname))
+            # now add the location to LD_LIBRARY_PATH
+            with os_helper.EnvironmentVarGuard() as env:
+                KEY = 'LD_LIBRARY_PATH'
+                if KEY not in env:
+                    v = d
+                else:
+                    v = '%s:%s' % (env[KEY], d)
+                env.set(KEY, v)
+                # now check that the .so can be found (since in
+                # LD_LIBRARY_PATH)
+                self.assertEqual(find_library(libname), 'lib%s.so' % libname)
+
+    def test_find_library_with_gcc(self):
+        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None):
+            self.assertNotEqual(find_library('c'), None)
+
+    def test_find_library_with_ld(self):
+        with unittest.mock.patch("ctypes.util._findSoname_ldconfig", lambda *args: None), \
+             unittest.mock.patch("ctypes.util._findLib_gcc", lambda *args: None):
+            self.assertNotEqual(find_library('c'), None)
+
+    def test_gh114257(self):
+        self.assertIsNone(find_library("libc"))
+
+
+@unittest.skipUnless(sys.platform == 'android', 'Test only valid for Android')
+class FindLibraryAndroid(unittest.TestCase):
+    def test_find(self):
+        for name in [
+            "c", "m",  # POSIX
+            "z",  # Non-POSIX, but present on Linux
+            "log",  # Not present on Linux
+        ]:
+            with self.subTest(name=name):
+                path = find_library(name)
+                self.assertIsInstance(path, str)
+                self.assertEqual(
+                    os.path.dirname(path),
+                    "/system/lib64" if "64" in os.uname().machine
+                    else "/system/lib")
+                self.assertEqual(os.path.basename(path), f"lib{name}.so")
+                self.assertTrue(os.path.isfile(path), path)
+
+        for name in ["libc", "nonexistent"]:
+            with self.subTest(name=name):
+                self.assertIsNone(find_library(name))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_frombuffer.py b/Lib/test/test_ctypes/test_frombuffer.py
new file mode 100644
index 00000000000..d4e161f864d
--- /dev/null
+++ b/Lib/test/test_ctypes/test_frombuffer.py
@@ -0,0 +1,144 @@
+import array
+import gc
+import unittest
+from ctypes import (Structure, Union, Array, sizeof,
+                    _Pointer, _SimpleCData, _CFuncPtr,
+                    c_char, c_int)
+
+
+class X(Structure):
+    _fields_ = [("c_int", c_int)]
+    init_called = False
+    def __init__(self):
+        self._init_called = True
+
+
+class Test(unittest.TestCase):
+    def test_from_buffer(self):
+        a = array.array("i", range(16))
+        x = (c_int * 16).from_buffer(a)
+
+        y = X.from_buffer(a)
+        self.assertEqual(y.c_int, a[0])
+        self.assertFalse(y.init_called)
+
+        self.assertEqual(x[:], a.tolist())
+
+        a[0], a[-1] = 200, -200
+        self.assertEqual(x[:], a.tolist())
+
+        self.assertRaises(BufferError, a.append, 100)
+        self.assertRaises(BufferError, a.pop)
+
+        del x; del y; gc.collect(); gc.collect(); gc.collect()
+        a.append(100)
+        a.pop()
+        x = (c_int * 16).from_buffer(a)
+
+        self.assertIn(a, [obj.obj if isinstance(obj, memoryview) else obj
+                          for obj in x._objects.values()])
+
+        expected = x[:]
+        del a; gc.collect(); gc.collect(); gc.collect()
+        self.assertEqual(x[:], expected)
+
+        with self.assertRaisesRegex(TypeError, "not writable"):
+            (c_char * 16).from_buffer(b"a" * 16)
+        with self.assertRaisesRegex(TypeError, "not writable"):
+            (c_char * 16).from_buffer(memoryview(b"a" * 16))
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(memoryview(bytearray(b"a" * 16))[::-1])
+        msg = "bytes-like object is required"
+        with self.assertRaisesRegex(TypeError, msg):
+            (c_char * 16).from_buffer("a" * 16)
+
+    def test_fortran_contiguous(self):
+        try:
+            import _testbuffer
+        except ImportError as err:
+            self.skipTest(str(err))
+        flags = _testbuffer.ND_WRITABLE | _testbuffer.ND_FORTRAN
+        array = _testbuffer.ndarray(
+            [97] * 16, format="B", shape=[4, 4], flags=flags)
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(array)
+        array = memoryview(array)
+        self.assertTrue(array.f_contiguous)
+        self.assertFalse(array.c_contiguous)
+        with self.assertRaisesRegex(TypeError, "not C contiguous"):
+            (c_char * 16).from_buffer(array)
+
+    def test_from_buffer_with_offset(self):
+        a = array.array("i", range(16))
+        x = (c_int * 15).from_buffer(a, sizeof(c_int))
+
+        self.assertEqual(x[:], a.tolist()[1:])
+        with self.assertRaises(ValueError):
+            c_int.from_buffer(a, -1)
+        with self.assertRaises(ValueError):
+            (c_int * 16).from_buffer(a, sizeof(c_int))
+        with self.assertRaises(ValueError):
+            (c_int * 1).from_buffer(a, 16 * sizeof(c_int))
+
+    def test_from_buffer_memoryview(self):
+        a = [c_char.from_buffer(memoryview(bytearray(b'a')))]
+        a.append(a)
+        del a
+        gc.collect()  # Should not crash
+
+    def test_from_buffer_copy(self):
+        a = array.array("i", range(16))
+        x = (c_int * 16).from_buffer_copy(a)
+
+        y = X.from_buffer_copy(a)
+        self.assertEqual(y.c_int, a[0])
+        self.assertFalse(y.init_called)
+
+        self.assertEqual(x[:], list(range(16)))
+
+        a[0], a[-1] = 200, -200
+        self.assertEqual(x[:], list(range(16)))
+
+        a.append(100)
+        self.assertEqual(x[:], list(range(16)))
+
+        self.assertEqual(x._objects, None)
+
+        del a; gc.collect(); gc.collect(); gc.collect()
+        self.assertEqual(x[:], list(range(16)))
+
+        x = (c_char * 16).from_buffer_copy(b"a" * 16)
+        self.assertEqual(x[:], b"a" * 16)
+        with self.assertRaises(TypeError):
+            (c_char * 16).from_buffer_copy("a" * 16)
+
+    def test_from_buffer_copy_with_offset(self):
+        a = array.array("i", range(16))
+        x = (c_int * 15).from_buffer_copy(a, sizeof(c_int))
+
+        self.assertEqual(x[:], a.tolist()[1:])
+        with self.assertRaises(ValueError):
+            c_int.from_buffer_copy(a, -1)
+        with self.assertRaises(ValueError):
+            (c_int * 16).from_buffer_copy(a, sizeof(c_int))
+        with self.assertRaises(ValueError):
+            (c_int * 1).from_buffer_copy(a, 16 * sizeof(c_int))
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, Array.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, Structure.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, Union.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _CFuncPtr.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _Pointer.from_buffer, bytearray(10))
+        self.assertRaises(TypeError, _SimpleCData.from_buffer, bytearray(10))
+
+        self.assertRaises(TypeError, Array.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, Structure.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, Union.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _CFuncPtr.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _Pointer.from_buffer_copy, b"123")
+        self.assertRaises(TypeError, _SimpleCData.from_buffer_copy, b"123")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_funcptr.py b/Lib/test/test_ctypes/test_funcptr.py
new file mode 100644
index 00000000000..8362fb16d94
--- /dev/null
+++ b/Lib/test/test_ctypes/test_funcptr.py
@@ -0,0 +1,134 @@
+import ctypes
+import unittest
+from ctypes import (CDLL, Structure, CFUNCTYPE, sizeof, _CFuncPtr,
+                    c_void_p, c_char_p, c_char, c_int, c_uint, c_long)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCFuncPtrType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+try:
+    WINFUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
+    # fake to enable this test on Linux
+    WINFUNCTYPE = CFUNCTYPE
+
+lib = CDLL(_ctypes_test.__file__)
+
+
+class CFuncPtrTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_CFuncPtr.mro(), [_CFuncPtr, _CData, object])
+
+        self.assertEqual(PyCFuncPtrType.__name__, "PyCFuncPtrType")
+        self.assertEqual(type(PyCFuncPtrType), type)
+
+    def test_type_flags(self):
+        for cls in _CFuncPtr, PyCFuncPtrType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_CFuncPtr.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_CFuncPtr.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Cannot call the metaclass __init__ more than once
+        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCFuncPtrType.__init__(CdeclCallback, 'ptr', (), {})
+
+    def test_basic(self):
+        X = WINFUNCTYPE(c_int, c_int, c_int)
+
+        def func(*args):
+            return len(args)
+
+        x = X(func)
+        self.assertEqual(x.restype, c_int)
+        self.assertEqual(x.argtypes, (c_int, c_int))
+        self.assertEqual(sizeof(x), sizeof(c_void_p))
+        self.assertEqual(sizeof(X), sizeof(c_void_p))
+
+    def test_first(self):
+        StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
+        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
+
+        def func(a, b):
+            return a + b
+
+        s = StdCallback(func)
+        c = CdeclCallback(func)
+
+        self.assertEqual(s(1, 2), 3)
+        self.assertEqual(c(1, 2), 3)
+        # The following no longer raises a TypeError - it is now
+        # possible, as in C, to call cdecl functions with more parameters.
+        #self.assertRaises(TypeError, c, 1, 2, 3)
+        self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
+        if WINFUNCTYPE is not CFUNCTYPE:
+            self.assertRaises(TypeError, s, 1, 2, 3)
+
+    def test_structures(self):
+        WNDPROC = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        def wndproc(hwnd, msg, wParam, lParam):
+            return hwnd + msg + wParam + lParam
+
+        HINSTANCE = c_int
+        HICON = c_int
+        HCURSOR = c_int
+        LPCTSTR = c_char_p
+
+        class WNDCLASS(Structure):
+            _fields_ = [("style", c_uint),
+                        ("lpfnWndProc", WNDPROC),
+                        ("cbClsExtra", c_int),
+                        ("cbWndExtra", c_int),
+                        ("hInstance", HINSTANCE),
+                        ("hIcon", HICON),
+                        ("hCursor", HCURSOR),
+                        ("lpszMenuName", LPCTSTR),
+                        ("lpszClassName", LPCTSTR)]
+
+        wndclass = WNDCLASS()
+        wndclass.lpfnWndProc = WNDPROC(wndproc)
+
+        WNDPROC_2 = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        self.assertIs(WNDPROC, WNDPROC_2)
+        self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
+
+        f = wndclass.lpfnWndProc
+
+        del wndclass
+        del wndproc
+
+        self.assertEqual(f(10, 11, 12, 13), 46)
+
+    def test_dllfunctions(self):
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+        strchr.argtypes = (c_char_p, c_char)
+        self.assertEqual(strchr(b"abcdefghi", b"b"), b"bcdefghi")
+        self.assertEqual(strchr(b"abcdefghi", b"x"), None)
+
+        strtok = lib.my_strtok
+        strtok.restype = c_char_p
+
+        def c_string(init):
+            size = len(init) + 1
+            return (c_char*size)(*init)
+
+        s = b"a\nb\nc"
+        b = c_string(s)
+
+        self.assertEqual(strtok(b, b"\n"), b"a")
+        self.assertEqual(strtok(None, b"\n"), b"b")
+        self.assertEqual(strtok(None, b"\n"), b"c")
+        self.assertEqual(strtok(None, b"\n"), None)
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, _CFuncPtr, 13, "name", 42, "iid")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_functions.py b/Lib/test/test_ctypes/test_functions.py
new file mode 100644
index 00000000000..63e393f7b7c
--- /dev/null
+++ b/Lib/test/test_ctypes/test_functions.py
@@ -0,0 +1,454 @@
+import ctypes
+import sys
+import unittest
+from ctypes import (CDLL, Structure, Array, CFUNCTYPE,
+                    byref, POINTER, pointer, ArgumentError,
+                    c_char, c_wchar, c_byte, c_char_p, c_wchar_p,
+                    c_short, c_int, c_long, c_longlong, c_void_p,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from _ctypes import _Pointer,  _SimpleCData
+
+
+try:
+    WINFUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
+    # fake to enable this test on Linux
+    WINFUNCTYPE = CFUNCTYPE
+
+dll = CDLL(_ctypes_test.__file__)
+if sys.platform == "win32":
+    windll = ctypes.WinDLL(_ctypes_test.__file__)
+
+
+class POINT(Structure):
+    _fields_ = [("x", c_int), ("y", c_int)]
+
+
+class RECT(Structure):
+    _fields_ = [("left", c_int), ("top", c_int),
+                ("right", c_int), ("bottom", c_int)]
+
+
+class FunctionTestCase(unittest.TestCase):
+
+    def test_mro(self):
+        # in Python 2.3, this raises TypeError: MRO conflict among bases classes,
+        # in Python 2.2 it works.
+        #
+        # But in early versions of _ctypes.c, the result of tp_new
+        # wasn't checked, and it even crashed Python.
+        # Found by Greg Chapman.
+
+        with self.assertRaises(TypeError):
+            class X(object, Array):
+                _length_ = 5
+                _type_ = "i"
+
+        with self.assertRaises(TypeError):
+            class X2(object, _Pointer):
+                pass
+
+        with self.assertRaises(TypeError):
+            class X3(object, _SimpleCData):
+                _type_ = "i"
+
+        with self.assertRaises(TypeError):
+            class X4(object, Structure):
+                _fields_ = []
+
+    def test_c_char_parm(self):
+        proto = CFUNCTYPE(c_int, c_char)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+
+        self.assertEqual(callback(b"a"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(b"abc")
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: one character bytes, "
+                         "bytearray or integer expected")
+
+    def test_wchar_parm(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
+        result = f(1, "x", 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 139)
+        self.assertEqual(type(result), int)
+
+        with self.assertRaises(ArgumentError) as cm:
+            f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(str(cm.exception),
+                         "argument 2: TypeError: unicode string expected "
+                         "instead of int instance")
+
+        with self.assertRaises(ArgumentError) as cm:
+            f(1, "abc", 3, 4, 5.0, 6.0)
+        self.assertEqual(str(cm.exception),
+                         "argument 2: TypeError: one character unicode string "
+                         "expected")
+
+    def test_c_char_p_parm(self):
+        """Test the error message when converting an incompatible type to c_char_p."""
+        proto = CFUNCTYPE(c_int, c_char_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback(b"abc"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(10)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'int' object cannot be "
+                         "interpreted as ctypes.c_char_p")
+
+    def test_c_wchar_p_parm(self):
+        """Test the error message when converting an incompatible type to c_wchar_p."""
+        proto = CFUNCTYPE(c_int, c_wchar_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback("abc"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(10)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'int' object cannot be "
+                         "interpreted as ctypes.c_wchar_p")
+
+    def test_c_void_p_parm(self):
+        """Test the error message when converting an incompatible type to c_void_p."""
+        proto = CFUNCTYPE(c_int, c_void_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback(5), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(2.5)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'float' object cannot be "
+                         "interpreted as ctypes.c_void_p")
+
+    def test_wchar_result(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_wchar
+        result = f(0, 0, 0, 0, 0, 0)
+        self.assertEqual(result, '\x00')
+
+    def test_voidresult(self):
+        f = dll._testfunc_v
+        f.restype = None
+        f.argtypes = [c_int, c_int, POINTER(c_int)]
+        result = c_int()
+        self.assertEqual(None, f(1, 2, byref(result)))
+        self.assertEqual(result.value, 3)
+
+    def test_intresult(self):
+        f = dll._testfunc_i_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_int
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), int)
+
+        # If we declare the function to return a short,
+        # is the high part split off?
+        f.restype = c_short
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        result = f(1, 2, 3, 0x10004, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), int)
+
+        # You cannot assign character format codes as restype any longer
+        self.assertRaises(TypeError, setattr, f, "restype", "i")
+
+    def test_floatresult(self):
+        f = dll._testfunc_f_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_float
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    def test_doubleresult(self):
+        f = dll._testfunc_d_bhilfd
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        f.restype = c_double
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    def test_longdoubleresult(self):
+        f = dll._testfunc_D_bhilfD
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
+        f.restype = c_longdouble
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+        self.assertEqual(type(result), float)
+
+        result = f(-1, -2, -3, -4, -5.0, -6.0)
+        self.assertEqual(result, -21)
+        self.assertEqual(type(result), float)
+
+    def test_longlongresult(self):
+        f = dll._testfunc_q_bhilfd
+        f.restype = c_longlong
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
+        result = f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(result, 21)
+
+        f = dll._testfunc_q_bhilfdq
+        f.restype = c_longlong
+        f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double, c_longlong]
+        result = f(1, 2, 3, 4, 5.0, 6.0, 21)
+        self.assertEqual(result, 42)
+
+    def test_stringresult(self):
+        f = dll._testfunc_p_p
+        f.argtypes = None
+        f.restype = c_char_p
+        result = f(b"123")
+        self.assertEqual(result, b"123")
+
+        result = f(None)
+        self.assertEqual(result, None)
+
+    def test_pointers(self):
+        f = dll._testfunc_p_p
+        f.restype = POINTER(c_int)
+        f.argtypes = [POINTER(c_int)]
+
+        # This only works if the value c_int(42) passed to the
+        # function is still alive while the pointer (the result) is
+        # used.
+
+        v = c_int(42)
+
+        self.assertEqual(pointer(v).contents.value, 42)
+        result = f(pointer(v))
+        self.assertEqual(type(result), POINTER(c_int))
+        self.assertEqual(result.contents.value, 42)
+
+        # This on works...
+        result = f(pointer(v))
+        self.assertEqual(result.contents.value, v.value)
+
+        p = pointer(c_int(99))
+        result = f(p)
+        self.assertEqual(result.contents.value, 99)
+
+        arg = byref(v)
+        result = f(arg)
+        self.assertNotEqual(result.contents, v.value)
+
+        self.assertRaises(ArgumentError, f, byref(c_short(22)))
+
+        # It is dangerous, however, because you don't control the lifetime
+        # of the pointer:
+        result = f(byref(c_int(99)))
+        self.assertNotEqual(result.contents, 99)
+
+    def test_shorts(self):
+        f = dll._testfunc_callback_i_if
+
+        args = []
+        expected = [262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048,
+                    1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+
+        def callback(v):
+            args.append(v)
+            return v
+
+        CallBack = CFUNCTYPE(c_int, c_int)
+
+        cb = CallBack(callback)
+        f(2**18, cb)
+        self.assertEqual(args, expected)
+
+    def test_callbacks(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+        f.argtypes = None
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        def callback(value):
+            return value
+
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+        # test with prototype
+        f.argtypes = [c_int, MyCallback]
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+        AnotherCallback = WINFUNCTYPE(c_int, c_int, c_int, c_int, c_int)
+
+        # check that the prototype works: we call f with wrong
+        # argument types
+        cb = AnotherCallback(callback)
+        self.assertRaises(ArgumentError, f, -10, cb)
+
+
+    def test_callbacks_2(self):
+        # Can also use simple datatypes as argument type specifiers
+        # for the callback function.
+        # In this case the call receives an instance of that type
+        f = dll._testfunc_callback_i_if
+        f.restype = c_int
+
+        MyCallback = CFUNCTYPE(c_int, c_int)
+
+        f.argtypes = [c_int, MyCallback]
+
+        def callback(value):
+            self.assertEqual(type(value), int)
+            return value
+
+        cb = MyCallback(callback)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+
+    def test_longlong_callbacks(self):
+
+        f = dll._testfunc_callback_q_qf
+        f.restype = c_longlong
+
+        MyCallback = CFUNCTYPE(c_longlong, c_longlong)
+
+        f.argtypes = [c_longlong, MyCallback]
+
+        def callback(value):
+            self.assertIsInstance(value, int)
+            return value & 0x7FFFFFFF
+
+        cb = MyCallback(callback)
+
+        self.assertEqual(13577625587, f(1000000000000, cb))
+
+    def test_errors(self):
+        self.assertRaises(AttributeError, getattr, dll, "_xxx_yyy")
+        self.assertRaises(ValueError, c_int.in_dll, dll, "_xxx_yyy")
+
+    def test_byval(self):
+
+        # without prototype
+        ptin = POINT(1, 2)
+        ptout = POINT()
+        # EXPORT int _testfunc_byval(point in, point *pout)
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 3, 1, 2
+        self.assertEqual(got, expected)
+
+        # with prototype
+        ptin = POINT(101, 102)
+        ptout = POINT()
+        dll._testfunc_byval.argtypes = (POINT, POINTER(POINT))
+        dll._testfunc_byval.restype = c_int
+        result = dll._testfunc_byval(ptin, byref(ptout))
+        got = result, ptout.x, ptout.y
+        expected = 203, 101, 102
+        self.assertEqual(got, expected)
+
+    def test_struct_return_2H(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+        dll.ret_2h_func.restype = S2H
+        dll.ret_2h_func.argtypes = [S2H]
+        inp = S2H(99, 88)
+        s2h = dll.ret_2h_func(inp)
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_struct_return_2H_stdcall(self):
+        class S2H(Structure):
+            _fields_ = [("x", c_short),
+                        ("y", c_short)]
+
+        windll.s_ret_2h_func.restype = S2H
+        windll.s_ret_2h_func.argtypes = [S2H]
+        s2h = windll.s_ret_2h_func(S2H(99, 88))
+        self.assertEqual((s2h.x, s2h.y), (99*2, 88*3))
+
+    def test_struct_return_8H(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        dll.ret_8i_func.restype = S8I
+        dll.ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = dll.ret_8i_func(inp)
+        self.assertEqual((s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                             (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+    def test_struct_return_8H_stdcall(self):
+        class S8I(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int),
+                        ("d", c_int),
+                        ("e", c_int),
+                        ("f", c_int),
+                        ("g", c_int),
+                        ("h", c_int)]
+        windll.s_ret_8i_func.restype = S8I
+        windll.s_ret_8i_func.argtypes = [S8I]
+        inp = S8I(9, 8, 7, 6, 5, 4, 3, 2)
+        s8i = windll.s_ret_8i_func(inp)
+        self.assertEqual(
+                (s8i.a, s8i.b, s8i.c, s8i.d, s8i.e, s8i.f, s8i.g, s8i.h),
+                (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
+
+    def test_sf1651235(self):
+        # see https://bugs.python.org/issue1651235
+
+        proto = CFUNCTYPE(c_int, RECT, POINT)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT()))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_incomplete.py b/Lib/test/test_ctypes/test_incomplete.py
new file mode 100644
index 00000000000..9f859793d88
--- /dev/null
+++ b/Lib/test/test_ctypes/test_incomplete.py
@@ -0,0 +1,50 @@
+import ctypes
+import unittest
+import warnings
+from ctypes import Structure, POINTER, pointer, c_char_p
+
+
+# The incomplete pointer example from the tutorial
+class TestSetPointerType(unittest.TestCase):
+    def tearDown(self):
+        # to not leak references, we must clean _pointer_type_cache
+        ctypes._reset_cache()
+
+    def test_incomplete_example(self):
+        lpcell = POINTER("cell")
+        class cell(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("next", lpcell)]
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            ctypes.SetPointerType(lpcell, cell)
+
+        c1 = cell()
+        c1.name = b"foo"
+        c2 = cell()
+        c2.name = b"bar"
+
+        c1.next = pointer(c2)
+        c2.next = pointer(c1)
+
+        p = c1
+
+        result = []
+        for i in range(8):
+            result.append(p.name)
+            p = p.next[0]
+        self.assertEqual(result, [b"foo", b"bar"] * 4)
+
+    def test_deprecation(self):
+        lpcell = POINTER("cell")
+        class cell(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("next", lpcell)]
+
+        with self.assertWarns(DeprecationWarning):
+            ctypes.SetPointerType(lpcell, cell)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_init.py b/Lib/test/test_ctypes/test_init.py
new file mode 100644
index 00000000000..113425e5823
--- /dev/null
+++ b/Lib/test/test_ctypes/test_init.py
@@ -0,0 +1,43 @@
+import unittest
+from ctypes import Structure, c_int
+
+
+class X(Structure):
+    _fields_ = [("a", c_int),
+                ("b", c_int)]
+    new_was_called = False
+
+    def __new__(cls):
+        result = super().__new__(cls)
+        result.new_was_called = True
+        return result
+
+    def __init__(self):
+        self.a = 9
+        self.b = 12
+
+
+class Y(Structure):
+    _fields_ = [("x", X)]
+
+
+class InitTest(unittest.TestCase):
+    def test_get(self):
+        # make sure the only accessing a nested structure
+        # doesn't call the structure's __new__ and __init__
+        y = Y()
+        self.assertEqual((y.x.a, y.x.b), (0, 0))
+        self.assertEqual(y.x.new_was_called, False)
+
+        # But explicitly creating an X structure calls __new__ and __init__, of course.
+        x = X()
+        self.assertEqual((x.a, x.b), (9, 12))
+        self.assertEqual(x.new_was_called, True)
+
+        y.x = x
+        self.assertEqual((y.x.a, y.x.b), (9, 12))
+        self.assertEqual(y.x.new_was_called, False)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_internals.py b/Lib/test/test_ctypes/test_internals.py
new file mode 100644
index 00000000000..778da6573da
--- /dev/null
+++ b/Lib/test/test_ctypes/test_internals.py
@@ -0,0 +1,97 @@
+# This tests the internal _objects attribute
+
+# XXX This test must be reviewed for correctness!!!
+
+# ctypes' types are container types.
+#
+# They have an internal memory block, which only consists of some bytes,
+# but it has to keep references to other objects as well. This is not
+# really needed for trivial C types like int or char, but it is important
+# for aggregate types like strings or pointers in particular.
+#
+# What about pointers?
+
+import sys
+import unittest
+from ctypes import Structure, POINTER, c_char_p, c_int
+
+
+class ObjectsTestCase(unittest.TestCase):
+    def assertSame(self, a, b):
+        self.assertEqual(id(a), id(b))
+
+    def test_ints(self):
+        i = 42000123
+        refcnt = sys.getrefcount(i)
+        ci = c_int(i)
+        self.assertEqual(refcnt, sys.getrefcount(i))
+        self.assertEqual(ci._objects, None)
+
+    def test_c_char_p(self):
+        s = "Hello, World".encode("ascii")
+        refcnt = sys.getrefcount(s)
+        cs = c_char_p(s)
+        self.assertEqual(refcnt + 1, sys.getrefcount(s))
+        self.assertSame(cs._objects, s)
+
+    def test_simple_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+
+        a = 421234
+        b = 421235
+        x = X()
+        self.assertEqual(x._objects, None)
+        x.a = a
+        x.b = b
+        self.assertEqual(x._objects, None)
+
+    def test_embedded_structs(self):
+        class X(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+
+        class Y(Structure):
+            _fields_ = [("x", X), ("y", X)]
+
+        y = Y()
+        self.assertEqual(y._objects, None)
+
+        x1, x2 = X(), X()
+        y.x, y.y = x1, x2
+        self.assertEqual(y._objects, {"0": {}, "1": {}})
+        x1.a, x2.b = 42, 93
+        self.assertEqual(y._objects, {"0": {}, "1": {}})
+
+    def test_xxx(self):
+        class X(Structure):
+            _fields_ = [("a", c_char_p), ("b", c_char_p)]
+
+        class Y(Structure):
+            _fields_ = [("x", X), ("y", X)]
+
+        s1 = b"Hello, World"
+        s2 = b"Hallo, Welt"
+
+        x = X()
+        x.a = s1
+        x.b = s2
+        self.assertEqual(x._objects, {"0": s1, "1": s2})
+
+        y = Y()
+        y.x = x
+        self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}})
+
+    def test_ptr_struct(self):
+        class X(Structure):
+            _fields_ = [("data", POINTER(c_int))]
+
+        A = c_int*4
+        a = A(11, 22, 33, 44)
+        self.assertEqual(a._objects, None)
+
+        x = X()
+        x.data = a
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_keeprefs.py b/Lib/test/test_ctypes/test_keeprefs.py
new file mode 100644
index 00000000000..23b03b64b4a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_keeprefs.py
@@ -0,0 +1,124 @@
+import unittest
+from ctypes import (Structure, POINTER, pointer,  _pointer_type_cache,
+                    c_char_p, c_int)
+
+
+class SimpleTestCase(unittest.TestCase):
+    def test_cint(self):
+        x = c_int()
+        self.assertEqual(x._objects, None)
+        x.value = 42
+        self.assertEqual(x._objects, None)
+        x = c_int(99)
+        self.assertEqual(x._objects, None)
+
+    def test_ccharp(self):
+        x = c_char_p()
+        self.assertEqual(x._objects, None)
+        x.value = b"abc"
+        self.assertEqual(x._objects, b"abc")
+        x = c_char_p(b"spam")
+        self.assertEqual(x._objects, b"spam")
+
+
+class StructureTestCase(unittest.TestCase):
+    def test_cint_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int)]
+
+        x = X()
+        self.assertEqual(x._objects, None)
+        x.a = 42
+        x.b = 99
+        self.assertEqual(x._objects, None)
+
+    def test_ccharp_struct(self):
+        class X(Structure):
+            _fields_ = [("a", c_char_p),
+                        ("b", c_char_p)]
+        x = X()
+        self.assertEqual(x._objects, None)
+
+        x.a = b"spam"
+        x.b = b"foo"
+        self.assertEqual(x._objects, {"0": b"spam", "1": b"foo"})
+
+    def test_struct_struct(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        class RECT(Structure):
+            _fields_ = [("ul", POINT), ("lr", POINT)]
+
+        r = RECT()
+        r.ul.x = 0
+        r.ul.y = 1
+        r.lr.x = 2
+        r.lr.y = 3
+        self.assertEqual(r._objects, None)
+
+        r = RECT()
+        pt = POINT(1, 2)
+        r.ul = pt
+        self.assertEqual(r._objects, {'0': {}})
+        r.ul.x = 22
+        r.ul.y = 44
+        self.assertEqual(r._objects, {'0': {}})
+        r.lr = POINT()
+        self.assertEqual(r._objects, {'0': {}, '1': {}})
+
+
+class ArrayTestCase(unittest.TestCase):
+    def test_cint_array(self):
+        INTARR = c_int * 3
+
+        ia = INTARR()
+        self.assertEqual(ia._objects, None)
+        ia[0] = 1
+        ia[1] = 2
+        ia[2] = 3
+        self.assertEqual(ia._objects, None)
+
+        class X(Structure):
+            _fields_ = [("x", c_int),
+                        ("a", INTARR)]
+
+        x = X()
+        x.x = 1000
+        x.a[0] = 42
+        x.a[1] = 96
+        self.assertEqual(x._objects, None)
+        x.a = ia
+        self.assertEqual(x._objects, {'1': {}})
+
+
+class PointerTestCase(unittest.TestCase):
+    def test_p_cint(self):
+        i = c_int(42)
+        x = pointer(i)
+        self.assertEqual(x._objects, {'1': i})
+
+
+class PointerToStructure(unittest.TestCase):
+    def test(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        class RECT(Structure):
+            _fields_ = [("a", POINTER(POINT)),
+                        ("b", POINTER(POINT))]
+        r = RECT()
+        p1 = POINT(1, 2)
+
+        r.a = pointer(p1)
+        r.b = pointer(p1)
+
+        r.a[0].x = 42
+        r.a[0].y = 99
+
+        # to avoid leaking when tests are run several times
+        # clean up the types left in the cache.
+        del _pointer_type_cache[POINT]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_libc.py b/Lib/test/test_ctypes/test_libc.py
new file mode 100644
index 00000000000..7716100b08f
--- /dev/null
+++ b/Lib/test/test_ctypes/test_libc.py
@@ -0,0 +1,38 @@
+import math
+import unittest
+from ctypes import (CDLL, CFUNCTYPE, POINTER, create_string_buffer, sizeof,
+                    c_void_p, c_char, c_int, c_double, c_size_t)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+lib = CDLL(_ctypes_test.__file__)
+
+
+def three_way_cmp(x, y):
+    """Return -1 if x < y, 0 if x == y and 1 if x > y"""
+    return (x > y) - (x < y)
+
+
+class LibTest(unittest.TestCase):
+    def test_sqrt(self):
+        lib.my_sqrt.argtypes = c_double,
+        lib.my_sqrt.restype = c_double
+        self.assertEqual(lib.my_sqrt(4.0), 2.0)
+        self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
+
+    def test_qsort(self):
+        comparefunc = CFUNCTYPE(c_int, POINTER(c_char), POINTER(c_char))
+        lib.my_qsort.argtypes = c_void_p, c_size_t, c_size_t, comparefunc
+        lib.my_qsort.restype = None
+
+        def sort(a, b):
+            return three_way_cmp(a[0], b[0])
+
+        chars = create_string_buffer(b"spam, spam, and spam")
+        lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
+        self.assertEqual(chars.raw, b"   ,,aaaadmmmnpppsss\x00")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_loading.py b/Lib/test/test_ctypes/test_loading.py
new file mode 100644
index 00000000000..a4d54f676a6
--- /dev/null
+++ b/Lib/test/test_ctypes/test_loading.py
@@ -0,0 +1,208 @@
+import _ctypes
+import ctypes
+import os
+import shutil
+import subprocess
+import sys
+import test.support
+import unittest
+from ctypes import CDLL, cdll, addressof, c_void_p, c_char_p
+from ctypes.util import find_library
+from test.support import import_helper, os_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+libc_name = None
+
+
+def setUpModule():
+    global libc_name
+    if os.name == "nt":
+        libc_name = find_library("c")
+    elif sys.platform == "cygwin":
+        libc_name = "cygwin1.dll"
+    else:
+        libc_name = find_library("c")
+
+    if test.support.verbose:
+        print("libc_name is", libc_name)
+
+
+class LoaderTest(unittest.TestCase):
+
+    unknowndll = "xxrandomnamexx"
+
+    def test_load(self):
+        if libc_name is not None:
+            test_lib = libc_name
+        else:
+            if os.name == "nt":
+                test_lib = _ctypes_test.__file__
+            else:
+                self.skipTest('could not find library to load')
+        CDLL(test_lib)
+        CDLL(os.path.basename(test_lib))
+        CDLL(os_helper.FakePath(test_lib))
+        self.assertRaises(OSError, CDLL, self.unknowndll)
+
+    def test_load_version(self):
+        if libc_name is None:
+            self.skipTest('could not find libc')
+        if os.path.basename(libc_name) != 'libc.so.6':
+            self.skipTest('wrong libc path for test')
+        cdll.LoadLibrary("libc.so.6")
+        # linux uses version, libc 9 should not exist
+        self.assertRaises(OSError, cdll.LoadLibrary, "libc.so.9")
+        self.assertRaises(OSError, cdll.LoadLibrary, self.unknowndll)
+
+    def test_find(self):
+        found = False
+        for name in ("c", "m"):
+            lib = find_library(name)
+            if lib:
+                found = True
+                cdll.LoadLibrary(lib)
+                CDLL(lib)
+        if not found:
+            self.skipTest("Could not find c and m libraries")
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_library(self):
+        # CRT is no longer directly loadable. See issue23606 for the
+        # discussion about alternative approaches.
+        #self.assertIsNotNone(libc_name)
+        if test.support.verbose:
+            print(find_library("kernel32"))
+            print(find_library("user32"))
+
+        if os.name == "nt":
+            ctypes.windll.kernel32.GetModuleHandleW
+            ctypes.windll["kernel32"].GetModuleHandleW
+            ctypes.windll.LoadLibrary("kernel32").GetModuleHandleW
+            ctypes.WinDLL("kernel32").GetModuleHandleW
+            # embedded null character
+            self.assertRaises(ValueError, ctypes.windll.LoadLibrary, "kernel32\0")
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_ordinal_functions(self):
+        dll = ctypes.WinDLL(_ctypes_test.__file__)
+        # We load the same function both via ordinal and name
+        func_ord = dll[2]
+        func_name = dll.GetString
+        # addressof gets the address where the function pointer is stored
+        a_ord = addressof(func_ord)
+        a_name = addressof(func_name)
+        f_ord_addr = c_void_p.from_address(a_ord).value
+        f_name_addr = c_void_p.from_address(a_name).value
+        self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
+
+        self.assertRaises(AttributeError, dll.__getitem__, 1234)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_load_without_name_and_with_handle(self):
+        handle = ctypes.windll.kernel32._handle
+        lib = ctypes.WinDLL(name=None, handle=handle)
+        self.assertIs(handle, lib._handle)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_A(self):
+        # On winXP 64-bit, advapi32 loads at an address that does
+        # NOT fit into a 32-bit integer.  FreeLibrary must be able
+        # to accept this address.
+
+        # These are tests for https://bugs.python.org/issue1703286
+        handle = _ctypes.LoadLibrary("advapi32")
+        _ctypes.FreeLibrary(handle)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_B(self):
+        # Since on winXP 64-bit advapi32 loads like described
+        # above, the (arbitrarily selected) CloseEventLog function
+        # also has a high address.  'call_function' should accept
+        # addresses so large.
+
+        advapi32 = ctypes.windll.advapi32
+        # Calling CloseEventLog with a NULL argument should fail,
+        # but the call should not segfault or so.
+        self.assertEqual(0, advapi32.CloseEventLog(None))
+
+        kernel32 = ctypes.windll.kernel32
+        kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        kernel32.GetProcAddress.restype = c_void_p
+        proc = kernel32.GetProcAddress(advapi32._handle, b"CloseEventLog")
+        self.assertTrue(proc)
+
+        # This is the real test: call the function via 'call_function'
+        self.assertEqual(0, _ctypes.call_function(proc, (None,)))
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_hasattr(self):
+        # bpo-34816: shouldn't raise OSError
+        self.assertFalse(hasattr(ctypes.windll, 'test'))
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_dll_with_flags(self):
+        _sqlite3 = import_helper.import_module("_sqlite3")
+        src = _sqlite3.__file__
+        if os.path.basename(src).partition(".")[0].lower().endswith("_d"):
+            ext = "_d.dll"
+        else:
+            ext = ".dll"
+
+        with os_helper.temp_dir() as tmp:
+            # We copy two files and load _sqlite3.dll (formerly .pyd),
+            # which has a dependency on sqlite3.dll. Then we test
+            # loading it in subprocesses to avoid it starting in memory
+            # for each test.
+            target = os.path.join(tmp, "_sqlite3.dll")
+            shutil.copy(src, target)
+            shutil.copy(os.path.join(os.path.dirname(src), "sqlite3" + ext),
+                        os.path.join(tmp, "sqlite3" + ext))
+
+            def should_pass(command):
+                with self.subTest(command):
+                    subprocess.check_output(
+                        [sys.executable, "-c",
+                         "from ctypes import *; import nt;" + command],
+                        cwd=tmp
+                    )
+
+            def should_fail(command):
+                with self.subTest(command):
+                    with self.assertRaises(subprocess.CalledProcessError):
+                        subprocess.check_output(
+                            [sys.executable, "-c",
+                             "from ctypes import *; import nt;" + command],
+                            cwd=tmp, stderr=subprocess.STDOUT,
+                        )
+
+            # Default load should not find this in CWD
+            should_fail("WinDLL('_sqlite3.dll')")
+
+            # Relative path (but not just filename) should succeed
+            should_pass("WinDLL('./_sqlite3.dll')")
+
+            # Insecure load flags should succeed
+            # Clear the DLL directory to avoid safe search settings propagating
+            should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
+
+            # Full path load without DLL_LOAD_DIR shouldn't find dependency
+            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
+
+            # Full path load with DLL_LOAD_DIR should succeed
+            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
+                        "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
+
+            # User-specified directory should succeed
+            should_pass("import os; p = os.add_dll_directory(os.getcwd());" +
+                        "WinDLL('_sqlite3.dll'); p.close()")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_macholib.py b/Lib/test/test_ctypes/test_macholib.py
new file mode 100644
index 00000000000..9d906179956
--- /dev/null
+++ b/Lib/test/test_ctypes/test_macholib.py
@@ -0,0 +1,112 @@
+# Bob Ippolito:
+#
+# Ok.. the code to find the filename for __getattr__ should look
+# something like:
+#
+# import os
+# from macholib.dyld import dyld_find
+#
+# def find_lib(name):
+#      possible = ['lib'+name+'.dylib', name+'.dylib',
+#      name+'.framework/'+name]
+#      for dylib in possible:
+#          try:
+#              return os.path.realpath(dyld_find(dylib))
+#          except ValueError:
+#              pass
+#      raise ValueError, "%s not found" % (name,)
+#
+# It'll have output like this:
+#
+#  >>> find_lib('pthread')
+# '/usr/lib/libSystem.B.dylib'
+#  >>> find_lib('z')
+# '/usr/lib/libz.1.dylib'
+#  >>> find_lib('IOKit')
+# '/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit'
+#
+# -bob
+
+import os
+import sys
+import unittest
+
+from ctypes.macholib.dyld import dyld_find
+from ctypes.macholib.dylib import dylib_info
+from ctypes.macholib.framework import framework_info
+
+
+def find_lib(name):
+    possible = ['lib'+name+'.dylib', name+'.dylib', name+'.framework/'+name]
+    for dylib in possible:
+        try:
+            return os.path.realpath(dyld_find(dylib))
+        except ValueError:
+            pass
+    raise ValueError("%s not found" % (name,))
+
+
+def d(location=None, name=None, shortname=None, version=None, suffix=None):
+    return {'location': location, 'name': name, 'shortname': shortname,
+            'version': version, 'suffix': suffix}
+
+
+class MachOTest(unittest.TestCase):
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_find(self):
+        self.assertEqual(dyld_find('libSystem.dylib'),
+                         '/usr/lib/libSystem.dylib')
+        self.assertEqual(dyld_find('System.framework/System'),
+                         '/System/Library/Frameworks/System.framework/System')
+
+        # On Mac OS 11, system dylibs are only present in the shared cache,
+        # so symlinks like libpthread.dylib -> libSystem.B.dylib will not
+        # be resolved by dyld_find
+        self.assertIn(find_lib('pthread'),
+                              ('/usr/lib/libSystem.B.dylib', '/usr/lib/libpthread.dylib'))
+
+        result = find_lib('z')
+        # Issue #21093: dyld default search path includes $HOME/lib and
+        # /usr/local/lib before /usr/lib, which caused test failures if
+        # a local copy of libz exists in one of them. Now ignore the head
+        # of the path.
+        self.assertRegex(result, r".*/lib/libz.*\.dylib")
+
+        self.assertIn(find_lib('IOKit'),
+                              ('/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit',
+                              '/System/Library/Frameworks/IOKit.framework/IOKit'))
+
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_info(self):
+        self.assertIsNone(dylib_info('completely/invalid'))
+        self.assertIsNone(dylib_info('completely/invalide_debug'))
+        self.assertEqual(dylib_info('P/Foo.dylib'), d('P', 'Foo.dylib', 'Foo'))
+        self.assertEqual(dylib_info('P/Foo_debug.dylib'),
+                         d('P', 'Foo_debug.dylib', 'Foo', suffix='debug'))
+        self.assertEqual(dylib_info('P/Foo.A.dylib'),
+                         d('P', 'Foo.A.dylib', 'Foo', 'A'))
+        self.assertEqual(dylib_info('P/Foo_debug.A.dylib'),
+                         d('P', 'Foo_debug.A.dylib', 'Foo_debug', 'A'))
+        self.assertEqual(dylib_info('P/Foo.A_debug.dylib'),
+                         d('P', 'Foo.A_debug.dylib', 'Foo', 'A', 'debug'))
+
+    @unittest.skipUnless(sys.platform == "darwin", 'OSX-specific test')
+    def test_framework_info(self):
+        self.assertIsNone(framework_info('completely/invalid'))
+        self.assertIsNone(framework_info('completely/invalid/_debug'))
+        self.assertIsNone(framework_info('P/F.framework'))
+        self.assertIsNone(framework_info('P/F.framework/_debug'))
+        self.assertEqual(framework_info('P/F.framework/F'),
+                         d('P', 'F.framework/F', 'F'))
+        self.assertEqual(framework_info('P/F.framework/F_debug'),
+                         d('P', 'F.framework/F_debug', 'F', suffix='debug'))
+        self.assertIsNone(framework_info('P/F.framework/Versions'))
+        self.assertIsNone(framework_info('P/F.framework/Versions/A'))
+        self.assertEqual(framework_info('P/F.framework/Versions/A/F'),
+                         d('P', 'F.framework/Versions/A/F', 'F', 'A'))
+        self.assertEqual(framework_info('P/F.framework/Versions/A/F_debug'),
+                         d('P', 'F.framework/Versions/A/F_debug', 'F', 'A', 'debug'))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_memfunctions.py b/Lib/test/test_ctypes/test_memfunctions.py
new file mode 100644
index 00000000000..112b27ba48e
--- /dev/null
+++ b/Lib/test/test_ctypes/test_memfunctions.py
@@ -0,0 +1,82 @@
+import sys
+import unittest
+from test import support
+from ctypes import (POINTER, sizeof, cast,
+                    create_string_buffer, string_at,
+                    create_unicode_buffer, wstring_at,
+                    memmove, memset,
+                    c_char_p, c_byte, c_ubyte, c_wchar)
+
+
+class MemFunctionsTest(unittest.TestCase):
+    def test_overflow(self):
+        # string_at and wstring_at must use the Python calling
+        # convention (which acquires the GIL and checks the Python
+        # error flag).  Provoke an error and catch it; see also issue
+        # gh-47804.
+        self.assertRaises((OverflowError, MemoryError, SystemError),
+                          lambda: wstring_at(u"foo", sys.maxsize - 1))
+        self.assertRaises((OverflowError, MemoryError, SystemError),
+                          lambda: string_at("foo", sys.maxsize - 1))
+
+    def test_memmove(self):
+        # large buffers apparently increase the chance that the memory
+        # is allocated in high address space.
+        a = create_string_buffer(1000000)
+        p = b"Hello, World"
+        result = memmove(a, p, len(p))
+        self.assertEqual(a.value, b"Hello, World")
+
+        self.assertEqual(string_at(result), b"Hello, World")
+        self.assertEqual(string_at(result, 5), b"Hello")
+        self.assertEqual(string_at(result, 16), b"Hello, World\0\0\0\0")
+        self.assertEqual(string_at(result, 0), b"")
+
+    def test_memset(self):
+        a = create_string_buffer(1000000)
+        result = memset(a, ord('x'), 16)
+        self.assertEqual(a.value, b"xxxxxxxxxxxxxxxx")
+
+        self.assertEqual(string_at(result), b"xxxxxxxxxxxxxxxx")
+        self.assertEqual(string_at(a), b"xxxxxxxxxxxxxxxx")
+        self.assertEqual(string_at(a, 20), b"xxxxxxxxxxxxxxxx\0\0\0\0")
+
+    def test_cast(self):
+        a = (c_ubyte * 32)(*map(ord, "abcdef"))
+        self.assertEqual(cast(a, c_char_p).value, b"abcdef")
+        self.assertEqual(cast(a, POINTER(c_byte))[:7],
+                             [97, 98, 99, 100, 101, 102, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:],
+                             [97, 98, 99, 100, 101, 102, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[6:-1:-1],
+                             [0, 102, 101, 100, 99, 98, 97])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:2],
+                             [97, 99, 101, 0])
+        self.assertEqual(cast(a, POINTER(c_byte))[:7:7],
+                             [97])
+
+    @support.refcount_test
+    def test_string_at(self):
+        s = string_at(b"foo bar")
+        # XXX The following may be wrong, depending on how Python
+        # manages string instances
+        self.assertEqual(2, sys.getrefcount(s))
+        self.assertTrue(s, "foo bar")
+
+        self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
+        self.assertEqual(string_at(b"foo bar", 3), b"foo")
+
+    def test_wstring_at(self):
+        p = create_unicode_buffer("Hello, World")
+        a = create_unicode_buffer(1000000)
+        result = memmove(a, p, len(p) * sizeof(c_wchar))
+        self.assertEqual(a.value, "Hello, World")
+
+        self.assertEqual(wstring_at(a), "Hello, World")
+        self.assertEqual(wstring_at(a, 5), "Hello")
+        self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
+        self.assertEqual(wstring_at(a, 0), "")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_numbers.py b/Lib/test/test_ctypes/test_numbers.py
new file mode 100644
index 00000000000..29108a28ec1
--- /dev/null
+++ b/Lib/test/test_ctypes/test_numbers.py
@@ -0,0 +1,200 @@
+import array
+import struct
+import sys
+import unittest
+from operator import truth
+from ctypes import (byref, sizeof, alignment,
+                    c_char, c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble, c_bool)
+
+
+def valid_ranges(*types):
+    # given a sequence of numeric types, collect their _type_
+    # attribute, which is a single format character compatible with
+    # the struct module, use the struct module to calculate the
+    # minimum and maximum value allowed for this format.
+    # Returns a list of (min, max) values.
+    result = []
+    for t in types:
+        fmt = t._type_
+        size = struct.calcsize(fmt)
+        a = struct.unpack(fmt, (b"\x00"*32)[:size])[0]
+        b = struct.unpack(fmt, (b"\xFF"*32)[:size])[0]
+        c = struct.unpack(fmt, (b"\x7F"+b"\x00"*32)[:size])[0]
+        d = struct.unpack(fmt, (b"\x80"+b"\xFF"*32)[:size])[0]
+        result.append((min(a, b, c, d), max(a, b, c, d)))
+    return result
+
+
+ArgType = type(byref(c_int(0)))
+
+unsigned_types = [c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong]
+signed_types = [c_byte, c_short, c_int, c_long, c_longlong]
+bool_types = [c_bool]
+float_types = [c_double, c_float]
+
+unsigned_ranges = valid_ranges(*unsigned_types)
+signed_ranges = valid_ranges(*signed_types)
+bool_values = [True, False, 0, 1, -1, 5000, 'test', [], [1]]
+
+
+class NumberTestCase(unittest.TestCase):
+
+    def test_default_init(self):
+        # default values are set to zero
+        for t in signed_types + unsigned_types + float_types:
+            self.assertEqual(t().value, 0)
+
+    def test_unsigned_values(self):
+        # the value given to the constructor is available
+        # as the 'value' attribute
+        for t, (l, h) in zip(unsigned_types, unsigned_ranges):
+            self.assertEqual(t(l).value, l)
+            self.assertEqual(t(h).value, h)
+
+    def test_signed_values(self):
+        # see above
+        for t, (l, h) in zip(signed_types, signed_ranges):
+            self.assertEqual(t(l).value, l)
+            self.assertEqual(t(h).value, h)
+
+    def test_bool_values(self):
+        for t, v in zip(bool_types, bool_values):
+            self.assertEqual(t(v).value, truth(v))
+
+    def test_typeerror(self):
+        # Only numbers are allowed in the constructor,
+        # otherwise TypeError is raised
+        for t in signed_types + unsigned_types + float_types:
+            self.assertRaises(TypeError, t, "")
+            self.assertRaises(TypeError, t, None)
+
+    def test_from_param(self):
+        # the from_param class method attribute always
+        # returns PyCArgObject instances
+        for t in signed_types + unsigned_types + float_types:
+            self.assertEqual(ArgType, type(t.from_param(0)))
+
+    def test_byref(self):
+        # calling byref returns also a PyCArgObject instance
+        for t in signed_types + unsigned_types + float_types + bool_types:
+            parm = byref(t())
+            self.assertEqual(ArgType, type(parm))
+
+
+    def test_floats(self):
+        # c_float and c_double can be created from
+        # Python int and float
+        class FloatLike:
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
+        for t in float_types:
+            self.assertEqual(t(2.0).value, 2.0)
+            self.assertEqual(t(2).value, 2.0)
+            self.assertEqual(t(2).value, 2.0)
+            self.assertEqual(t(f).value, 2.0)
+
+    def test_integers(self):
+        class FloatLike:
+            def __float__(self):
+                return 2.0
+        f = FloatLike()
+        class IntLike:
+            def __int__(self):
+                return 2
+        d = IntLike()
+        class IndexLike:
+            def __index__(self):
+                return 2
+        i = IndexLike()
+        # integers cannot be constructed from floats,
+        # but from integer-like objects
+        for t in signed_types + unsigned_types:
+            self.assertRaises(TypeError, t, 3.14)
+            self.assertRaises(TypeError, t, f)
+            self.assertRaises(TypeError, t, d)
+            self.assertEqual(t(i).value, 2)
+
+    def test_sizes(self):
+        for t in signed_types + unsigned_types + float_types + bool_types:
+            try:
+                size = struct.calcsize(t._type_)
+            except struct.error:
+                continue
+            # sizeof of the type...
+            self.assertEqual(sizeof(t), size)
+            # and sizeof of an instance
+            self.assertEqual(sizeof(t()), size)
+
+    def test_alignments(self):
+        for t in signed_types + unsigned_types + float_types:
+            code = t._type_ # the typecode
+            align = struct.calcsize("c%c" % code) - struct.calcsize(code)
+
+            # alignment of the type...
+            self.assertEqual((code, alignment(t)),
+                                 (code, align))
+            # and alignment of an instance
+            self.assertEqual((code, alignment(t())),
+                                 (code, align))
+
+    def test_int_from_address(self):
+        for t in signed_types + unsigned_types:
+            # the array module doesn't support all format codes
+            # (no 'q' or 'Q')
+            try:
+                array.array(t._type_)
+            except ValueError:
+                continue
+            a = array.array(t._type_, [100])
+
+            # v now is an integer at an 'external' memory location
+            v = t.from_address(a.buffer_info()[0])
+            self.assertEqual(v.value, a[0])
+            self.assertEqual(type(v), t)
+
+            # changing the value at the memory location changes v's value also
+            a[0] = 42
+            self.assertEqual(v.value, a[0])
+
+
+    def test_float_from_address(self):
+        for t in float_types:
+            a = array.array(t._type_, [3.14])
+            v = t.from_address(a.buffer_info()[0])
+            self.assertEqual(v.value, a[0])
+            self.assertIs(type(v), t)
+            a[0] = 2.3456e17
+            self.assertEqual(v.value, a[0])
+            self.assertIs(type(v), t)
+
+    def test_char_from_address(self):
+        a = array.array('b', [0])
+        a[0] = ord('x')
+        v = c_char.from_address(a.buffer_info()[0])
+        self.assertEqual(v.value, b'x')
+        self.assertIs(type(v), c_char)
+
+        a[0] = ord('?')
+        self.assertEqual(v.value, b'?')
+
+    def test_init(self):
+        # c_int() can be initialized from Python's int, and c_int.
+        # Not from c_long or so, which seems strange, abc should
+        # probably be changed:
+        self.assertRaises(TypeError, c_int, c_long(42))
+
+    def test_float_overflow(self):
+        big_int = int(sys.float_info.max) * 2
+        for t in float_types + [c_longdouble]:
+            self.assertRaises(OverflowError, t, big_int)
+            if (hasattr(t, "__ctype_be__")):
+                self.assertRaises(OverflowError, t.__ctype_be__, big_int)
+            if (hasattr(t, "__ctype_le__")):
+                self.assertRaises(OverflowError, t.__ctype_le__, big_int)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_objects.py b/Lib/test/test_ctypes/test_objects.py
new file mode 100644
index 00000000000..fb01421b955
--- /dev/null
+++ b/Lib/test/test_ctypes/test_objects.py
@@ -0,0 +1,66 @@
+r'''
+This tests the '_objects' attribute of ctypes instances.  '_objects'
+holds references to objects that must be kept alive as long as the
+ctypes instance, to make sure that the memory buffer is valid.
+
+WARNING: The '_objects' attribute is exposed ONLY for debugging ctypes itself,
+it MUST NEVER BE MODIFIED!
+
+'_objects' is initialized to a dictionary on first use, before that it
+is None.
+
+Here is an array of string pointers:
+
+>>> from ctypes import Structure, c_int, c_char_p
+>>> array = (c_char_p * 5)()
+>>> print(array._objects)
+None
+>>>
+
+The memory block stores pointers to strings, and the strings itself
+assigned from Python must be kept.
+
+>>> array[4] = b'foo bar'
+>>> array._objects
+{'4': b'foo bar'}
+>>> array[4]
+b'foo bar'
+>>>
+
+It gets more complicated when the ctypes instance itself is contained
+in a 'base' object.
+
+>>> class X(Structure):
+...     _fields_ = [("x", c_int), ("y", c_int), ("array", c_char_p * 5)]
+...
+>>> x = X()
+>>> print(x._objects)
+None
+>>>
+
+The'array' attribute of the 'x' object shares part of the memory buffer
+of 'x' ('_b_base_' is either None, or the root object owning the memory block):
+
+>>> print(x.array._b_base_) # doctest: +ELLIPSIS
+<test.test_ctypes.test_objects.X object at 0x...>
+>>>
+
+>>> x.array[0] = b'spam spam spam'
+>>> x._objects
+{'0:2': b'spam spam spam'}
+>>> x.array._b_base_._objects
+{'0:2': b'spam spam spam'}
+>>>
+'''
+
+import doctest
+import unittest
+
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite())
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_parameters.py b/Lib/test/test_ctypes/test_parameters.py
new file mode 100644
index 00000000000..1a6ddb91a7d
--- /dev/null
+++ b/Lib/test/test_ctypes/test_parameters.py
@@ -0,0 +1,288 @@
+import sys
+import unittest
+import test.support
+from ctypes import (CDLL, PyDLL, ArgumentError,
+                    Structure, Array, Union,
+                    _Pointer, _SimpleCData, _CFuncPtr,
+                    POINTER, pointer, byref,
+                    c_void_p, c_char_p, c_wchar_p, py_object,
+                    c_bool,
+                    c_char, c_wchar,
+                    c_byte, c_ubyte,
+                    c_short, c_ushort,
+                    c_int, c_uint,
+                    c_long, c_ulong,
+                    c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class SimpleTypesTestCase(unittest.TestCase):
+    def setUp(self):
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            self.prev_conv_mode = set_conversion_mode("ascii", "strict")
+
+    def tearDown(self):
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            set_conversion_mode(*self.prev_conv_mode)
+
+    def test_subclasses(self):
+        # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new
+        class CVOIDP(c_void_p):
+            def from_param(cls, value):
+                return value * 2
+            from_param = classmethod(from_param)
+
+        class CCHARP(c_char_p):
+            def from_param(cls, value):
+                return value * 4
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
+        self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
+
+    def test_subclasses_c_wchar_p(self):
+        class CWCHARP(c_wchar_p):
+            def from_param(cls, value):
+                return value * 3
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
+
+    # XXX Replace by c_char_p tests
+    def test_cstrings(self):
+        # c_char_p.from_param on a Python String packs the string
+        # into a cparam object
+        s = b"123"
+        self.assertIs(c_char_p.from_param(s)._obj, s)
+
+        # new in 0.9.1: convert (encode) unicode to ascii
+        self.assertEqual(c_char_p.from_param(b"123")._obj, b"123")
+        self.assertRaises(TypeError, c_char_p.from_param, "123\377")
+        self.assertRaises(TypeError, c_char_p.from_param, 42)
+
+        # calling c_char_p.from_param with a c_char_p instance
+        # returns the argument itself:
+        a = c_char_p(b"123")
+        self.assertIs(c_char_p.from_param(a), a)
+
+    def test_cw_strings(self):
+        c_wchar_p.from_param("123")
+
+        self.assertRaises(TypeError, c_wchar_p.from_param, 42)
+        self.assertRaises(TypeError, c_wchar_p.from_param, b"123\377")
+
+        pa = c_wchar_p.from_param(c_wchar_p("123"))
+        self.assertEqual(type(pa), c_wchar_p)
+
+    def test_c_char(self):
+        with self.assertRaises(TypeError) as cm:
+            c_char.from_param(b"abc")
+        self.assertEqual(str(cm.exception),
+                         "one character bytes, bytearray or integer expected")
+
+    def test_c_wchar(self):
+        with self.assertRaises(TypeError) as cm:
+            c_wchar.from_param("abc")
+        self.assertEqual(str(cm.exception),
+                         "one character unicode string expected")
+
+
+        with self.assertRaises(TypeError) as cm:
+            c_wchar.from_param(123)
+        self.assertEqual(str(cm.exception),
+                         "unicode string expected instead of int instance")
+
+    def test_int_pointers(self):
+        LPINT = POINTER(c_int)
+
+        x = LPINT.from_param(pointer(c_int(42)))
+        self.assertEqual(x.contents.value, 42)
+        self.assertEqual(LPINT(c_int(42)).contents.value, 42)
+
+        self.assertEqual(LPINT.from_param(None), None)
+
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_uint(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_short(42)))
+
+    def test_byref_pointer(self):
+        # The from_param class method of POINTER(typ) classes accepts what is
+        # returned by byref(obj), it type(obj) == typ
+        LPINT = POINTER(c_int)
+
+        LPINT.from_param(byref(c_int(42)))
+
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_short(22)))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, byref(c_long(22)))
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_uint(22)))
+
+    def test_byref_pointerpointer(self):
+        # See above
+
+        LPLPINT = POINTER(POINTER(c_int))
+        LPLPINT.from_param(byref(pointer(c_int(42))))
+
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_short(22))))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_long(22))))
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_uint(22))))
+
+    def test_array_pointers(self):
+        INTARRAY = c_int * 3
+        ia = INTARRAY()
+        self.assertEqual(len(ia), 3)
+        self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
+
+        # Pointers are only compatible with arrays containing items of
+        # the same type!
+        LPINT = POINTER(c_int)
+        LPINT.from_param((c_int*3)())
+        self.assertRaises(TypeError, LPINT.from_param, c_short*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_long*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_uint*3)
+
+    def test_noctypes_argtype(self):
+        func = CDLL(_ctypes_test.__file__)._testfunc_p_p
+        func.restype = c_void_p
+        # TypeError: has no from_param method
+        self.assertRaises(TypeError, setattr, func, "argtypes", (object,))
+
+        class Adapter:
+            def from_param(cls, obj):
+                return None
+
+        func.argtypes = (Adapter(),)
+        self.assertEqual(func(None), None)
+        self.assertEqual(func(object()), None)
+
+        class Adapter:
+            def from_param(cls, obj):
+                return obj
+
+        func.argtypes = (Adapter(),)
+        # don't know how to convert parameter 1
+        self.assertRaises(ArgumentError, func, object())
+        self.assertEqual(func(c_void_p(42)), 42)
+
+        class Adapter:
+            def from_param(cls, obj):
+                raise ValueError(obj)
+
+        func.argtypes = (Adapter(),)
+        # ArgumentError: argument 1: ValueError: 99
+        self.assertRaises(ArgumentError, func, 99)
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, Array.from_param, 42)
+        self.assertRaises(TypeError, Structure.from_param, 42)
+        self.assertRaises(TypeError, Union.from_param, 42)
+        self.assertRaises(TypeError, _CFuncPtr.from_param, 42)
+        self.assertRaises(TypeError, _Pointer.from_param, 42)
+        self.assertRaises(TypeError, _SimpleCData.from_param, 42)
+
+    @test.support.cpython_only
+    def test_issue31311(self):
+        # __setstate__ should neither raise a SystemError nor crash in case
+        # of a bad __dict__.
+
+        class BadStruct(Structure):
+            @property
+            def __dict__(self):
+                pass
+        with self.assertRaises(TypeError):
+            BadStruct().__setstate__({}, b'foo')
+
+        class WorseStruct(Structure):
+            @property
+            def __dict__(self):
+                1/0
+        with self.assertRaises(ZeroDivisionError):
+            WorseStruct().__setstate__({}, b'foo')
+
+    def test_parameter_repr(self):
+        self.assertRegex(repr(c_bool.from_param(True)), r"^<cparam '\?' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_char.from_param(97)), "<cparam 'c' ('a')>")
+        self.assertRegex(repr(c_wchar.from_param('a')), r"^<cparam 'u' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_byte.from_param(98)), "<cparam 'b' (98)>")
+        self.assertEqual(repr(c_ubyte.from_param(98)), "<cparam 'B' (98)>")
+        self.assertEqual(repr(c_short.from_param(511)), "<cparam 'h' (511)>")
+        self.assertEqual(repr(c_ushort.from_param(511)), "<cparam 'H' (511)>")
+        self.assertRegex(repr(c_int.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_uint.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_long.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_ulong.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_longlong.from_param(20000)), r"^<cparam '[liq]' \(20000\)>$")
+        self.assertRegex(repr(c_ulonglong.from_param(20000)), r"^<cparam '[LIQ]' \(20000\)>$")
+        self.assertEqual(repr(c_float.from_param(1.5)), "<cparam 'f' (1.5)>")
+        self.assertEqual(repr(c_double.from_param(1.5)), "<cparam 'd' (1.5)>")
+        if sys.float_repr_style == 'short':
+            self.assertEqual(repr(c_double.from_param(1e300)), "<cparam 'd' (1e+300)>")
+        self.assertRegex(repr(c_longdouble.from_param(1.5)), r"^<cparam ('d' \(1.5\)|'g' at 0x[A-Fa-f0-9]+)>$")
+        self.assertRegex(repr(c_char_p.from_param(b'hihi')), r"^<cparam 'z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_wchar_p.from_param('hihi')), r"^<cparam 'Z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_void_p.from_param(0x12)), r"^<cparam 'P' \(0x0*12\)>$")
+
+    @test.support.cpython_only
+    def test_from_param_result_refcount(self):
+        # Issue #99952
+        class X(Structure):
+            """This struct size is <= sizeof(void*)."""
+            _fields_ = [("a", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, X]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+        class Y(Structure):
+            """This struct size is > sizeof(void*)."""
+            _fields_ = [("a", c_void_p), ("b", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, Y]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_pep3118.py b/Lib/test/test_ctypes/test_pep3118.py
new file mode 100644
index 00000000000..06b2ccecade
--- /dev/null
+++ b/Lib/test/test_ctypes/test_pep3118.py
@@ -0,0 +1,250 @@
+import re
+import sys
+import unittest
+from ctypes import (CFUNCTYPE, POINTER, sizeof, Union,
+                    Structure, LittleEndianStructure, BigEndianStructure,
+                    c_char, c_byte, c_ubyte,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong, c_uint64,
+                    c_bool, c_float, c_double, c_longdouble, py_object)
+
+
+if sys.byteorder == "little":
+    THIS_ENDIAN = "<"
+    OTHER_ENDIAN = ">"
+else:
+    THIS_ENDIAN = ">"
+    OTHER_ENDIAN = "<"
+
+
+def normalize(format):
+    # Remove current endian specifier and white space from a format
+    # string
+    if format is None:
+        return ""
+    format = format.replace(OTHER_ENDIAN, THIS_ENDIAN)
+    return re.sub(r"\s", "", format)
+
+
+class Test(unittest.TestCase):
+    def test_native_types(self):
+        for tp, fmt, shape, itemtp in native_types:
+            ob = tp()
+            v = memoryview(ob)
+            self.assertEqual(normalize(v.format), normalize(fmt))
+            if shape:
+                self.assertEqual(len(v), shape[0])
+            else:
+                self.assertRaises(TypeError, len, v)
+            self.assertEqual(v.itemsize, sizeof(itemtp))
+            self.assertEqual(v.shape, shape)
+            # XXX Issue #12851: PyCData_NewGetBuffer() must provide strides
+            #     if requested. memoryview currently reconstructs missing
+            #     stride information, so this assert will fail.
+            # self.assertEqual(v.strides, ())
+
+            # they are always read/write
+            self.assertFalse(v.readonly)
+
+            n = 1
+            for dim in v.shape:
+                n = n * dim
+            self.assertEqual(n * v.itemsize, len(v.tobytes()))
+
+    def test_endian_types(self):
+        for tp, fmt, shape, itemtp in endian_types:
+            ob = tp()
+            v = memoryview(ob)
+            self.assertEqual(v.format, fmt)
+            if shape:
+                self.assertEqual(len(v), shape[0])
+            else:
+                self.assertRaises(TypeError, len, v)
+            self.assertEqual(v.itemsize, sizeof(itemtp))
+            self.assertEqual(v.shape, shape)
+            # XXX Issue #12851
+            # self.assertEqual(v.strides, ())
+
+            # they are always read/write
+            self.assertFalse(v.readonly)
+
+            n = 1
+            for dim in v.shape:
+                n = n * dim
+            self.assertEqual(n * v.itemsize, len(v.tobytes()))
+
+
+# define some structure classes
+
+class Point(Structure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class PackedPoint(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class PointMidPad(Structure):
+    _fields_ = [("x", c_byte), ("y", c_uint)]
+
+class PackedPointMidPad(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_byte), ("y", c_uint64)]
+
+class PointEndPad(Structure):
+    _fields_ = [("x", c_uint), ("y", c_byte)]
+
+class PackedPointEndPad(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_uint64), ("y", c_byte)]
+
+class Point2(Structure):
+    pass
+Point2._fields_ = [("x", c_long), ("y", c_long)]
+
+class EmptyStruct(Structure):
+    _fields_ = []
+
+class aUnion(Union):
+    _fields_ = [("a", c_int)]
+
+class StructWithArrays(Structure):
+    _fields_ = [("x", c_long * 3 * 2), ("y", Point * 4)]
+
+class Incomplete(Structure):
+    pass
+
+class Complete(Structure):
+    pass
+PComplete = POINTER(Complete)
+Complete._fields_ = [("a", c_long)]
+
+
+################################################################
+#
+# This table contains format strings as they look on little endian
+# machines.  The test replaces '<' with '>' on big endian machines.
+#
+
+# Platform-specific type codes
+s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
+s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
+s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
+s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
+s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
+s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
+s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
+s_longlong = "q"
+s_ulonglong = "Q"
+s_float = "f"
+s_double = "d"
+s_longdouble = "g"
+
+# Alias definitions in ctypes/__init__.py
+if c_int is c_long:
+    s_int = s_long
+if c_uint is c_ulong:
+    s_uint = s_ulong
+if c_longlong is c_long:
+    s_longlong = s_long
+if c_ulonglong is c_ulong:
+    s_ulonglong = s_ulong
+if c_longdouble is c_double:
+    s_longdouble = s_double
+
+
+native_types = [
+    # type                      format                  shape           calc itemsize
+
+    ## simple types
+
+    (c_char,                    "<c",                   (),           c_char),
+    (c_byte,                    "<b",                   (),           c_byte),
+    (c_ubyte,                   "<B",                   (),           c_ubyte),
+    (c_short,                   "<" + s_short,          (),           c_short),
+    (c_ushort,                  "<" + s_ushort,         (),           c_ushort),
+
+    (c_int,                     "<" + s_int,            (),           c_int),
+    (c_uint,                    "<" + s_uint,           (),           c_uint),
+
+    (c_long,                    "<" + s_long,           (),           c_long),
+    (c_ulong,                   "<" + s_ulong,          (),           c_ulong),
+
+    (c_longlong,                "<" + s_longlong,       (),           c_longlong),
+    (c_ulonglong,               "<" + s_ulonglong,      (),           c_ulonglong),
+
+    (c_float,                   "<f",                   (),           c_float),
+    (c_double,                  "<d",                   (),           c_double),
+
+    (c_longdouble,              "<" + s_longdouble,     (),           c_longdouble),
+
+    (c_bool,                    "<" + s_bool,           (),           c_bool),
+    (py_object,                 "<O",                   (),           py_object),
+
+    ## pointers
+
+    (POINTER(c_byte),           "&<b",                  (),           POINTER(c_byte)),
+    (POINTER(POINTER(c_long)),  "&&<" + s_long,         (),           POINTER(POINTER(c_long))),
+
+    ## arrays and pointers
+
+    (c_double * 4,              "<d",                   (4,),           c_double),
+    (c_double * 0,              "<d",                   (0,),           c_double),
+    (c_float * 4 * 3 * 2,       "<f",                   (2,3,4),        c_float),
+    (c_float * 4 * 0 * 2,       "<f",                   (2,0,4),        c_float),
+    (POINTER(c_short) * 2,      "&<" + s_short,         (2,),           POINTER(c_short)),
+    (POINTER(c_short) * 2 * 3,  "&<" + s_short,         (3,2,),         POINTER(c_short)),
+    (POINTER(c_short * 2),      "&(2)<" + s_short,      (),             POINTER(c_short)),
+
+    ## structures and unions
+
+    (Point2,                    "T{<l:x:<l:y:}".replace('l', s_long),   (),  Point2),
+    (Point,                     "T{<l:x:<l:y:}".replace('l', s_long),   (),  Point),
+    (PackedPoint,               "T{<l:x:<l:y:}".replace('l', s_long),   (),  PackedPoint),
+    (PointMidPad,               "T{<b:x:3x<I:y:}".replace('I', s_uint), (),  PointMidPad),
+    (PackedPointMidPad,         "T{<b:x:x<Q:y:}",                       (),  PackedPointMidPad),
+    (PointEndPad,               "T{<I:x:<b:y:3x}".replace('I', s_uint), (),  PointEndPad),
+    (PackedPointEndPad,         "T{<Q:x:<b:y:x}",                       (),  PackedPointEndPad),
+    (EmptyStruct,               "T{}",                                  (),  EmptyStruct),
+    # the pep doesn't support unions
+    (aUnion,                    "B",                                   (),  aUnion),
+    # structure with sub-arrays
+    (StructWithArrays, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (), StructWithArrays),
+    (StructWithArrays * 3, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (3,), StructWithArrays),
+
+    ## pointer to incomplete structure
+    (Incomplete,                "B",                    (),           Incomplete),
+    (POINTER(Incomplete),       "&B",                   (),           POINTER(Incomplete)),
+
+    # 'Complete' is a structure that starts incomplete, but is completed after the
+    # pointer type to it has been created.
+    (Complete,                  "T{<l:a:}".replace('l', s_long), (), Complete),
+    # Unfortunately the pointer format string is not fixed...
+    (POINTER(Complete),         "&B",                   (),           POINTER(Complete)),
+
+    ## other
+
+    # function signatures are not implemented
+    (CFUNCTYPE(None),           "X{}",                  (),           CFUNCTYPE(None)),
+
+    ]
+
+
+class BEPoint(BigEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class LEPoint(LittleEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+
+# This table contains format strings as they really look, on both big
+# and little endian machines.
+endian_types = [
+    (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
+    (LEPoint * 1, "T{<l:x:<l:y:}".replace('l', s_long), (1,), LEPoint),
+    (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
+    (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
+    ]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_pickling.py b/Lib/test/test_ctypes/test_pickling.py
new file mode 100644
index 00000000000..9d433fc69de
--- /dev/null
+++ b/Lib/test/test_ctypes/test_pickling.py
@@ -0,0 +1,91 @@
+import pickle
+import unittest
+from ctypes import (CDLL, Structure, CFUNCTYPE, pointer,
+                    c_void_p, c_char_p, c_wchar_p,
+                    c_char, c_wchar, c_int, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+dll = CDLL(_ctypes_test.__file__)
+
+
+class X(Structure):
+    _fields_ = [("a", c_int), ("b", c_double)]
+    init_called = 0
+    def __init__(self, *args, **kw):
+        X.init_called += 1
+        self.x = 42
+
+
+class Y(X):
+    _fields_ = [("str", c_char_p)]
+
+
+class PickleTest:
+    def dumps(self, item):
+        return pickle.dumps(item, self.proto)
+
+    def loads(self, item):
+        return pickle.loads(item)
+
+    def test_simple(self):
+        for src in [
+            c_int(42),
+            c_double(3.14),
+            ]:
+            dst = self.loads(self.dumps(src))
+            self.assertEqual(src.__dict__, dst.__dict__)
+            self.assertEqual(memoryview(src).tobytes(),
+                                 memoryview(dst).tobytes())
+
+    def test_struct(self):
+        X.init_called = 0
+
+        x = X()
+        x.a = 42
+        self.assertEqual(X.init_called, 1)
+
+        y = self.loads(self.dumps(x))
+
+        # loads must NOT call __init__
+        self.assertEqual(X.init_called, 1)
+
+        # ctypes instances are identical when the instance __dict__
+        # and the memory buffer are identical
+        self.assertEqual(y.__dict__, x.__dict__)
+        self.assertEqual(memoryview(y).tobytes(),
+                             memoryview(x).tobytes())
+
+    def test_unpickable(self):
+        # ctypes objects that are pointers or contain pointers are
+        # unpickable.
+        self.assertRaises(ValueError, lambda: self.dumps(Y()))
+
+        prototype = CFUNCTYPE(c_int)
+
+        for item in [
+            c_char_p(),
+            c_wchar_p(),
+            c_void_p(),
+            pointer(c_int(42)),
+            dll._testfunc_p_p,
+            prototype(lambda: 42),
+            ]:
+            self.assertRaises(ValueError, lambda: self.dumps(item))
+
+    def test_wchar(self):
+        self.dumps(c_char(b"x"))
+        # Issue 5049
+        self.dumps(c_wchar("x"))
+
+
+for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+    name = 'PickleTest_%s' % proto
+    globals()[name] = type(name,
+                           (PickleTest, unittest.TestCase),
+                           {'proto': proto})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_pointers.py b/Lib/test/test_ctypes/test_pointers.py
new file mode 100644
index 00000000000..ed4541335df
--- /dev/null
+++ b/Lib/test/test_ctypes/test_pointers.py
@@ -0,0 +1,240 @@
+import array
+import ctypes
+import sys
+import unittest
+from ctypes import (CDLL, CFUNCTYPE, Structure,
+                    POINTER, pointer, _Pointer, _pointer_type_cache,
+                    byref, sizeof,
+                    c_void_p, c_char_p,
+                    c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCPointerType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+ctype_types = [c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                 c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_float]
+python_types = [int, int, int, int, int, int,
+                int, int, int, int, float, float]
+
+
+class PointersTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_Pointer.mro(), [_Pointer, _CData, object])
+
+        self.assertEqual(PyCPointerType.__name__, "PyCPointerType")
+        self.assertEqual(type(PyCPointerType), type)
+
+    def test_type_flags(self):
+        for cls in _Pointer, PyCPointerType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_Pointer.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_Pointer.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Cannot call the metaclass __init__ more than once
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCPointerType.__init__(POINTER(c_byte), 'ptr', (), {})
+
+    def test_pointer_crash(self):
+
+        class A(POINTER(c_ulong)):
+            pass
+
+        POINTER(c_ulong)(c_ulong(22))
+        # Pointer can't set contents: has no _type_
+        self.assertRaises(TypeError, A, c_ulong(33))
+
+    def test_pass_pointers(self):
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_p_p
+        if sizeof(c_longlong) == sizeof(c_void_p):
+            func.restype = c_longlong
+        else:
+            func.restype = c_long
+
+        i = c_int(12345678)
+        address = func(byref(i))
+        self.assertEqual(c_int.from_address(address).value, 12345678)
+
+        func.restype = POINTER(c_int)
+        res = func(pointer(i))
+        self.assertEqual(res.contents.value, 12345678)
+        self.assertEqual(res[0], 12345678)
+
+    def test_change_pointers(self):
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_p_p
+
+        i = c_int(87654)
+        func.restype = POINTER(c_int)
+        func.argtypes = (POINTER(c_int),)
+
+        res = func(pointer(i))
+        self.assertEqual(res[0], 87654)
+        self.assertEqual(res.contents.value, 87654)
+
+        # C code: *res = 54345
+        res[0] = 54345
+        self.assertEqual(i.value, 54345)
+
+        # C code:
+        #   int x = 12321;
+        #   res = &x
+        x = c_int(12321)
+        res.contents = x
+        self.assertEqual(i.value, 54345)
+
+        x.value = -99
+        self.assertEqual(res.contents.value, -99)
+
+    def test_callbacks_with_pointers(self):
+        # a function type receiving a pointer
+        PROTOTYPE = CFUNCTYPE(c_int, POINTER(c_int))
+
+        self.result = []
+
+        def func(arg):
+            for i in range(10):
+                self.result.append(arg[i])
+            return 0
+        callback = PROTOTYPE(func)
+
+        dll = CDLL(_ctypes_test.__file__)
+        # This function expects a function pointer,
+        # and calls this with an integer pointer as parameter.
+        # The int pointer points to a table containing the numbers 1..10
+        doit = dll._testfunc_callback_with_pointer
+
+        doit(callback)
+        doit(callback)
+
+    def test_basics(self):
+        for ct, pt in zip(ctype_types, python_types):
+            i = ct(42)
+            p = pointer(i)
+            self.assertIs(type(p.contents), ct)
+            # p.contents is the same as p[0]
+
+            with self.assertRaises(TypeError):
+                del p[0]
+
+    def test_from_address(self):
+        a = array.array('i', [100, 200, 300, 400, 500])
+        addr = a.buffer_info()[0]
+        p = POINTER(POINTER(c_int))
+
+    def test_other(self):
+        class Table(Structure):
+            _fields_ = [("a", c_int),
+                        ("b", c_int),
+                        ("c", c_int)]
+
+        pt = pointer(Table(1, 2, 3))
+
+        self.assertEqual(pt.contents.a, 1)
+        self.assertEqual(pt.contents.b, 2)
+        self.assertEqual(pt.contents.c, 3)
+
+        pt.contents.c = 33
+
+        del _pointer_type_cache[Table]
+
+    def test_basic(self):
+        p = pointer(c_int(42))
+        # Although a pointer can be indexed, it has no length
+        self.assertRaises(TypeError, len, p)
+        self.assertEqual(p[0], 42)
+        self.assertEqual(p[0:1], [42])
+        self.assertEqual(p.contents.value, 42)
+
+    def test_charpp(self):
+        """Test that a character pointer-to-pointer is correctly passed"""
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_c_p_p
+        func.restype = c_char_p
+        argv = (c_char_p * 2)()
+        argc = c_int( 2 )
+        argv[0] = b'hello'
+        argv[1] = b'world'
+        result = func( byref(argc), argv )
+        self.assertEqual(result, b'world')
+
+    def test_bug_1467852(self):
+        # http://sourceforge.net/tracker/?func=detail&atid=532154&aid=1467852&group_id=71702
+        x = c_int(5)
+        dummy = []
+        for i in range(32000):
+            dummy.append(c_int(i))
+        y = c_int(6)
+        p = pointer(x)
+        pp = pointer(p)
+        q = pointer(y)
+        pp[0] = q         # <==
+        self.assertEqual(p[0], 6)
+    def test_c_void_p(self):
+        # http://sourceforge.net/tracker/?func=detail&aid=1518190&group_id=5470&atid=105470
+        if sizeof(c_void_p) == 4:
+            self.assertEqual(c_void_p(0xFFFFFFFF).value,
+                                 c_void_p(-1).value)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+        elif sizeof(c_void_p) == 8:
+            self.assertEqual(c_void_p(0xFFFFFFFF).value,
+                                 0xFFFFFFFF)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+            self.assertEqual(c_void_p(0xFFFFFFFFFFFFFFFFFFFFFFFF).value,
+                                 c_void_p(-1).value)
+
+        self.assertRaises(TypeError, c_void_p, 3.14) # make sure floats are NOT accepted
+        self.assertRaises(TypeError, c_void_p, object()) # nor other objects
+
+    def test_pointers_bool(self):
+        # NULL pointers have a boolean False value, non-NULL pointers True.
+        self.assertEqual(bool(POINTER(c_int)()), False)
+        self.assertEqual(bool(pointer(c_int())), True)
+
+        self.assertEqual(bool(CFUNCTYPE(None)(0)), False)
+        self.assertEqual(bool(CFUNCTYPE(None)(42)), True)
+
+        # COM methods are boolean True:
+        if sys.platform == "win32":
+            mth = ctypes.WINFUNCTYPE(None)(42, "name", (), None)
+            self.assertEqual(bool(mth), True)
+
+    def test_pointer_type_name(self):
+        LargeNamedType = type('T' * 2 ** 25, (Structure,), {})
+        self.assertTrue(POINTER(LargeNamedType))
+
+        # to not leak references, we must clean _pointer_type_cache
+        del _pointer_type_cache[LargeNamedType]
+
+    def test_pointer_type_str_name(self):
+        large_string = 'T' * 2 ** 25
+        P = POINTER(large_string)
+        self.assertTrue(P)
+
+        # to not leak references, we must clean _pointer_type_cache
+        del _pointer_type_cache[id(P)]
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, _Pointer.set_type, 42)
+
+    def test_repeated_set_type(self):
+        # Regression test for gh-133290
+        class C(Structure):
+            _fields_ = [('a', c_int)]
+        ptr = POINTER(C)
+        # Read _type_ several times to warm up cache
+        for i in range(5):
+            self.assertIs(ptr._type_, C)
+        ptr.set_type(c_int)
+        self.assertIs(ptr._type_, c_int)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_prototypes.py b/Lib/test/test_ctypes/test_prototypes.py
new file mode 100644
index 00000000000..d976e8da0e2
--- /dev/null
+++ b/Lib/test/test_ctypes/test_prototypes.py
@@ -0,0 +1,252 @@
+# IMPORTANT INFO:
+#
+# Consider this call:
+#    func.restype = c_char_p
+#    func(c_char_p("123"))
+# It returns
+#    "123"
+#
+# WHY IS THIS SO?
+#
+# argument tuple (c_char_p("123"), ) is destroyed after the function
+# func is called, but NOT before the result is actually built.
+#
+# If the arglist would be destroyed BEFORE the result has been built,
+# the c_char_p("123") object would already have a zero refcount,
+# and the pointer passed to (and returned by) the function would
+# probably point to deallocated space.
+#
+# In this case, there would have to be an additional reference to the argument...
+
+import unittest
+from ctypes import (CDLL, CFUNCTYPE, POINTER, ArgumentError,
+                    pointer, byref, sizeof, addressof, create_string_buffer,
+                    c_void_p, c_char_p, c_wchar_p, c_char, c_wchar,
+                    c_short, c_int, c_long, c_longlong, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+testdll = CDLL(_ctypes_test.__file__)
+
+
+# Return machine address `a` as a (possibly long) non-negative integer.
+# Starting with Python 2.5, id(anything) is always non-negative, and
+# the ctypes addressof() inherits that via PyLong_FromVoidPtr().
+def positive_address(a):
+    if a >= 0:
+        return a
+    # View the bits in `a` as unsigned instead.
+    import struct
+    num_bits = struct.calcsize("P") * 8 # num bits in native machine address
+    a += 1 << num_bits
+    assert a >= 0
+    return a
+
+
+def c_wbuffer(init):
+    n = len(init) + 1
+    return (c_wchar * n)(*init)
+
+
+class CharPointersTestCase(unittest.TestCase):
+    def setUp(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_long
+        func.argtypes = None
+
+    def test_paramflags(self):
+        # function returns c_void_p result,
+        # and has a required parameter named 'input'
+        prototype = CFUNCTYPE(c_void_p, c_void_p)
+        func = prototype(("_testfunc_p_p", testdll),
+                         ((1, "input"),))
+
+        try:
+            func()
+        except TypeError as details:
+            self.assertEqual(str(details), "required argument 'input' missing")
+        else:
+            self.fail("TypeError not raised")
+
+        self.assertEqual(func(None), None)
+        self.assertEqual(func(input=None), None)
+
+    def test_invalid_paramflags(self):
+        proto = CFUNCTYPE(c_int, c_char_p)
+        with self.assertRaises(ValueError):
+            func = proto(("myprintf", testdll), ((1, "fmt"), (1, "arg1")))
+
+    def test_invalid_setattr_argtypes(self):
+        proto = CFUNCTYPE(c_int, c_char_p)
+        func = proto(("myprintf", testdll), ((1, "fmt"),))
+
+        with self.assertRaisesRegex(TypeError, "_argtypes_ must be a sequence of types"):
+            func.argtypes = 123
+        self.assertEqual(func.argtypes, (c_char_p,))
+
+        with self.assertRaisesRegex(ValueError, "paramflags must have the same length as argtypes"):
+            func.argtypes = (c_char_p, c_int)
+        self.assertEqual(func.argtypes, (c_char_p,))
+
+    def test_paramflags_outarg(self):
+        proto = CFUNCTYPE(c_int, c_char_p, c_int)
+        with self.assertRaisesRegex(TypeError, "must be a pointer type"):
+            func = proto(("myprintf", testdll), ((1, "fmt"), (2, "out")))
+
+        proto = CFUNCTYPE(c_int, c_char_p, c_void_p)
+        func = proto(("myprintf", testdll), ((1, "fmt"), (2, "out")))
+        with self.assertRaisesRegex(TypeError, "must be a pointer type"):
+            func.argtypes = (c_char_p, c_int)
+
+    def test_int_pointer_arg(self):
+        func = testdll._testfunc_p_p
+        if sizeof(c_longlong) == sizeof(c_void_p):
+            func.restype = c_longlong
+        else:
+            func.restype = c_long
+        self.assertEqual(0, func(0))
+
+        ci = c_int(0)
+
+        func.argtypes = POINTER(c_int),
+        self.assertEqual(positive_address(addressof(ci)),
+                             positive_address(func(byref(ci))))
+
+        func.argtypes = c_char_p,
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+        func.argtypes = POINTER(c_short),
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+        func.argtypes = POINTER(c_double),
+        self.assertRaises(ArgumentError, func, byref(ci))
+
+    def test_POINTER_c_char_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = POINTER(c_char),
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(None, func(c_char_p(None)))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+    def test_c_char_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = c_char_p,
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(None, func(c_char_p(None)))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+    def test_c_void_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_char_p
+        func.argtypes = c_void_p,
+
+        self.assertEqual(None, func(None))
+        self.assertEqual(b"123", func(b"123"))
+        self.assertEqual(b"123", func(c_char_p(b"123")))
+        self.assertEqual(None, func(c_char_p(None)))
+
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
+        ca = c_char(b"a")
+        self.assertEqual(ord(b"a"), func(pointer(ca))[0])
+        self.assertEqual(ord(b"a"), func(byref(ca))[0])
+
+        func(byref(c_int()))
+        func(pointer(c_int()))
+        func((c_int * 3)())
+
+    def test_c_void_p_arg_with_c_wchar_p(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = c_void_p,
+
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+    def test_instance(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_void_p
+
+        class X:
+            _as_parameter_ = None
+
+        func.argtypes = c_void_p,
+        self.assertEqual(None, func(X()))
+
+        func.argtypes = None
+        self.assertEqual(None, func(X()))
+
+
+class WCharPointersTestCase(unittest.TestCase):
+    def setUp(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_int
+        func.argtypes = None
+
+
+    def test_POINTER_c_wchar_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = POINTER(c_wchar),
+
+        self.assertEqual(None, func(None))
+        self.assertEqual("123", func("123"))
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+        self.assertEqual("123", func(c_wbuffer("123")))
+        ca = c_wchar("a")
+        self.assertEqual("a", func(pointer(ca))[0])
+        self.assertEqual("a", func(byref(ca))[0])
+
+    def test_c_wchar_p_arg(self):
+        func = testdll._testfunc_p_p
+        func.restype = c_wchar_p
+        func.argtypes = c_wchar_p,
+
+        c_wchar_p.from_param("123")
+
+        self.assertEqual(None, func(None))
+        self.assertEqual("123", func("123"))
+        self.assertEqual(None, func(c_wchar_p(None)))
+        self.assertEqual("123", func(c_wchar_p("123")))
+
+        # XXX Currently, these raise TypeErrors, although they shouldn't:
+        self.assertEqual("123", func(c_wbuffer("123")))
+        ca = c_wchar("a")
+        self.assertEqual("a", func(pointer(ca))[0])
+        self.assertEqual("a", func(byref(ca))[0])
+
+
+class ArrayTest(unittest.TestCase):
+    def test(self):
+        func = testdll._testfunc_ai8
+        func.restype = POINTER(c_int)
+        func.argtypes = c_int * 8,
+
+        func((c_int * 8)(1, 2, 3, 4, 5, 6, 7, 8))
+
+        # This did crash before:
+
+        def func(): pass
+        CFUNCTYPE(None, c_int * 3)(func)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_python_api.py b/Lib/test/test_ctypes/test_python_api.py
new file mode 100644
index 00000000000..1072a109833
--- /dev/null
+++ b/Lib/test/test_ctypes/test_python_api.py
@@ -0,0 +1,81 @@
+import _ctypes
+import sys
+import unittest
+from test import support
+from ctypes import (pythonapi, POINTER, create_string_buffer, sizeof,
+                    py_object, c_char_p, c_char, c_long, c_size_t)
+
+
+class PythonAPITestCase(unittest.TestCase):
+    def test_PyBytes_FromStringAndSize(self):
+        PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
+
+        PyBytes_FromStringAndSize.restype = py_object
+        PyBytes_FromStringAndSize.argtypes = c_char_p, c_size_t
+
+        self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
+
+    @support.refcount_test
+    def test_PyString_FromString(self):
+        pythonapi.PyBytes_FromString.restype = py_object
+        pythonapi.PyBytes_FromString.argtypes = (c_char_p,)
+
+        s = b"abc"
+        refcnt = sys.getrefcount(s)
+        pyob = pythonapi.PyBytes_FromString(s)
+        self.assertEqual(sys.getrefcount(s), refcnt)
+        self.assertEqual(s, pyob)
+        del pyob
+        self.assertEqual(sys.getrefcount(s), refcnt)
+
+    @support.refcount_test
+    def test_PyLong_Long(self):
+        ref42 = sys.getrefcount(42)
+        pythonapi.PyLong_FromLong.restype = py_object
+        self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
+
+        self.assertEqual(sys.getrefcount(42), ref42)
+
+        pythonapi.PyLong_AsLong.argtypes = (py_object,)
+        pythonapi.PyLong_AsLong.restype = c_long
+
+        res = pythonapi.PyLong_AsLong(42)
+        # Small int refcnts don't change
+        self.assertEqual(sys.getrefcount(res), ref42)
+        del res
+        self.assertEqual(sys.getrefcount(42), ref42)
+
+    @support.refcount_test
+    def test_PyObj_FromPtr(self):
+        s = object()
+        ref = sys.getrefcount(s)
+        # id(python-object) is the address
+        pyobj = _ctypes.PyObj_FromPtr(id(s))
+        self.assertIs(s, pyobj)
+
+        self.assertEqual(sys.getrefcount(s), ref + 1)
+        del pyobj
+        self.assertEqual(sys.getrefcount(s), ref)
+
+    def test_PyOS_snprintf(self):
+        PyOS_snprintf = pythonapi.PyOS_snprintf
+        PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
+
+        buf = create_string_buffer(256)
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s", b"ctypes")
+        self.assertEqual(buf.value, b"Hello from ctypes")
+
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
+        self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
+
+        # not enough arguments
+        self.assertRaises(TypeError, PyOS_snprintf, buf)
+
+    def test_pyobject_repr(self):
+        self.assertEqual(repr(py_object()), "py_object(<NULL>)")
+        self.assertEqual(repr(py_object(42)), "py_object(42)")
+        self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_random_things.py b/Lib/test/test_ctypes/test_random_things.py
new file mode 100644
index 00000000000..630f6ed9489
--- /dev/null
+++ b/Lib/test/test_ctypes/test_random_things.py
@@ -0,0 +1,81 @@
+import _ctypes
+import contextlib
+import ctypes
+import sys
+import unittest
+from test import support
+from ctypes import CFUNCTYPE, c_void_p, c_char_p, c_int, c_double
+
+
+def callback_func(arg):
+    42 / arg
+    raise ValueError(arg)
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class call_function_TestCase(unittest.TestCase):
+    # _ctypes.call_function is deprecated and private, but used by
+    # Gary Bishp's readline module.  If we have it, we must test it as well.
+
+    def test(self):
+        kernel32 = ctypes.windll.kernel32
+        kernel32.LoadLibraryA.restype = c_void_p
+        kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        kernel32.GetProcAddress.restype = c_void_p
+
+        hdll = kernel32.LoadLibraryA(b"kernel32")
+        funcaddr = kernel32.GetProcAddress(hdll, b"GetModuleHandleA")
+
+        self.assertEqual(_ctypes.call_function(funcaddr, (None,)),
+                         kernel32.GetModuleHandleA(None))
+
+
+class CallbackTracbackTestCase(unittest.TestCase):
+    # When an exception is raised in a ctypes callback function, the C
+    # code prints a traceback.
+    #
+    # This test makes sure the exception types *and* the exception
+    # value is printed correctly.
+    #
+    # Changed in 0.9.3: No longer is '(in callback)' prepended to the
+    # error message - instead an additional frame for the C code is
+    # created, then a full traceback printed.  When SystemExit is
+    # raised in a callback function, the interpreter exits.
+
+    @contextlib.contextmanager
+    def expect_unraisable(self, exc_type, exc_msg=None):
+        with support.catch_unraisable_exception() as cm:
+            yield
+
+            self.assertIsInstance(cm.unraisable.exc_value, exc_type)
+            if exc_msg is not None:
+                self.assertEqual(str(cm.unraisable.exc_value), exc_msg)
+            self.assertEqual(cm.unraisable.err_msg,
+                             f"Exception ignored on calling ctypes "
+                             f"callback function {callback_func!r}")
+            self.assertIsNone(cm.unraisable.object)
+
+    def test_ValueError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ValueError, '42'):
+            cb(42)
+
+    def test_IntegerDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0)
+
+    def test_FloatDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_double)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0.0)
+
+    def test_TypeErrorDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
+        err_msg = "unsupported operand type(s) for /: 'int' and 'bytes'"
+        with self.expect_unraisable(TypeError, err_msg):
+            cb(b"spam")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_refcounts.py b/Lib/test/test_ctypes/test_refcounts.py
new file mode 100644
index 00000000000..9e87cfc661e
--- /dev/null
+++ b/Lib/test/test_ctypes/test_refcounts.py
@@ -0,0 +1,143 @@
+import ctypes
+import gc
+import sys
+import unittest
+from test import support
+from test.support import import_helper
+from test.support import script_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+MyCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
+OtherCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulonglong)
+
+dll = ctypes.CDLL(_ctypes_test.__file__)
+
+
+class RefcountTestCase(unittest.TestCase):
+    @support.refcount_test
+    def test_1(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = ctypes.c_int
+        f.argtypes = [ctypes.c_int, MyCallback]
+
+        def callback(value):
+            return value
+
+        self.assertEqual(sys.getrefcount(callback), 2)
+        cb = MyCallback(callback)
+
+        self.assertGreater(sys.getrefcount(callback), 2)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+        cb = None
+
+        gc.collect()
+
+        self.assertEqual(sys.getrefcount(callback), 2)
+
+    @support.refcount_test
+    def test_refcount(self):
+        def func(*args):
+            pass
+        # this is the standard refcount for func
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        f = OtherCallback(func)
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # and may release it again
+        del f
+        self.assertGreaterEqual(sys.getrefcount(func), 2)
+
+        # but now it must be gone
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        class X(ctypes.Structure):
+            _fields_ = [("a", OtherCallback)]
+        x = X()
+        x.a = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # and may release it again
+        del x
+        self.assertGreaterEqual(sys.getrefcount(func), 2)
+
+        # and now it must be gone again
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        f = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # create a cycle
+        f.cycle = f
+
+        del f
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+
+class AnotherLeak(unittest.TestCase):
+    def test_callback(self):
+        proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
+        def func(a, b):
+            return a * b * 2
+        f = proto(func)
+
+        a = sys.getrefcount(ctypes.c_int)
+        f(1, 2)
+        self.assertEqual(sys.getrefcount(ctypes.c_int), a)
+
+    @support.refcount_test
+    def test_callback_py_object_none_return(self):
+        # bpo-36880: test that returning None from a py_object callback
+        # does not decrement the refcount of None.
+
+        for FUNCTYPE in (ctypes.CFUNCTYPE, ctypes.PYFUNCTYPE):
+            with self.subTest(FUNCTYPE=FUNCTYPE):
+                @FUNCTYPE(ctypes.py_object)
+                def func():
+                    return None
+
+                # Check that calling func does not affect None's refcount.
+                for _ in range(10000):
+                    func()
+
+
+class ModuleIsolationTest(unittest.TestCase):
+    def test_finalize(self):
+        # check if gc_decref() succeeds
+        script = (
+            "import ctypes;"
+            "import sys;"
+            "del sys.modules['_ctypes'];"
+            "import _ctypes;"
+            "exit()"
+        )
+        script_helper.assert_python_ok("-c", script)
+
+
+class PyObjectRestypeTest(unittest.TestCase):
+    def test_restype_py_object_with_null_return(self):
+        # Test that a function which returns a NULL PyObject *
+        # without setting an exception does not crash.
+        PyErr_Occurred = ctypes.pythonapi.PyErr_Occurred
+        PyErr_Occurred.argtypes = []
+        PyErr_Occurred.restype = ctypes.py_object
+
+        # At this point, there's no exception set, so PyErr_Occurred
+        # returns NULL. Given the restype is py_object, the
+        # ctypes machinery will raise a custom error.
+        with self.assertRaisesRegex(ValueError, "PyObject is NULL"):
+            PyErr_Occurred()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_repr.py b/Lib/test/test_ctypes/test_repr.py
new file mode 100644
index 00000000000..e7587984a92
--- /dev/null
+++ b/Lib/test/test_ctypes/test_repr.py
@@ -0,0 +1,34 @@
+import unittest
+from ctypes import (c_byte, c_short, c_int, c_long, c_longlong,
+                    c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong,
+                    c_float, c_double, c_longdouble, c_bool, c_char)
+
+
+subclasses = []
+for base in [c_byte, c_short, c_int, c_long, c_longlong,
+        c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong,
+        c_float, c_double, c_longdouble, c_bool]:
+    class X(base):
+        pass
+    subclasses.append(X)
+
+
+class X(c_char):
+    pass
+
+
+# This test checks if the __repr__ is correct for subclasses of simple types
+class ReprTest(unittest.TestCase):
+    def test_numbers(self):
+        for typ in subclasses:
+            base = typ.__bases__[0]
+            self.assertTrue(repr(base(42)).startswith(base.__name__))
+            self.assertEqual("<X object at", repr(typ(42))[:12])
+
+    def test_char(self):
+        self.assertEqual("c_char(b'x')", repr(c_char(b'x')))
+        self.assertEqual("<X object at", repr(X(b'x'))[:12])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_returnfuncptrs.py b/Lib/test/test_ctypes/test_returnfuncptrs.py
new file mode 100644
index 00000000000..337801b226a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_returnfuncptrs.py
@@ -0,0 +1,67 @@
+import unittest
+from ctypes import CDLL, CFUNCTYPE, ArgumentError, c_char_p, c_void_p, c_char
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class ReturnFuncPtrTestCase(unittest.TestCase):
+    def test_with_prototype(self):
+        # The _ctypes_test shared lib/dll exports quite some functions for testing.
+        # The get_strchr function returns a *pointer* to the C strchr function.
+        dll = CDLL(_ctypes_test.__file__)
+        get_strchr = dll.get_strchr
+        get_strchr.restype = CFUNCTYPE(c_char_p, c_char_p, c_char)
+        strchr = get_strchr()
+        self.assertEqual(strchr(b"abcdef", b"b"), b"bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertEqual(strchr(b"abcdef", 98), b"bcdef")
+        self.assertEqual(strchr(b"abcdef", 107), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    def test_without_prototype(self):
+        dll = CDLL(_ctypes_test.__file__)
+        get_strchr = dll.get_strchr
+        # the default 'c_int' would not work on systems where sizeof(int) != sizeof(void *)
+        get_strchr.restype = c_void_p
+        addr = get_strchr()
+        # _CFuncPtr instances are now callable with an integer argument
+        # which denotes a function address:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(addr)
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    def test_from_dll(self):
+        dll = CDLL(_ctypes_test.__file__)
+        # _CFuncPtr instances are now callable with a tuple argument
+        # which denotes a function name and a dll:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(("my_strchr", dll))
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+    # Issue 6083: Reference counting bug
+    def test_from_dll_refcount(self):
+        class BadSequence(tuple):
+            def __getitem__(self, key):
+                if key == 0:
+                    return "my_strchr"
+                if key == 1:
+                    return CDLL(_ctypes_test.__file__)
+                raise IndexError
+
+        # _CFuncPtr instances are now callable with a tuple argument
+        # which denotes a function name and a dll:
+        strchr = CFUNCTYPE(c_char_p, c_char_p, c_char)(
+                BadSequence(("my_strchr", CDLL(_ctypes_test.__file__))))
+        self.assertTrue(strchr(b"abcdef", b"b"), "bcdef")
+        self.assertEqual(strchr(b"abcdef", b"x"), None)
+        self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
+        self.assertRaises(TypeError, strchr, b"abcdef")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_simplesubclasses.py b/Lib/test/test_ctypes/test_simplesubclasses.py
new file mode 100644
index 00000000000..4e4bef3690f
--- /dev/null
+++ b/Lib/test/test_ctypes/test_simplesubclasses.py
@@ -0,0 +1,96 @@
+import unittest
+from ctypes import Structure, CFUNCTYPE, c_int, _SimpleCData
+from ._support import (_CData, PyCSimpleType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class MyInt(c_int):
+    def __eq__(self, other):
+        if type(other) != MyInt:
+            return NotImplementedError
+        return self.value == other.value
+
+
+class Test(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_SimpleCData.mro(), [_SimpleCData, _CData, object])
+
+        self.assertEqual(PyCSimpleType.__name__, "PyCSimpleType")
+        self.assertEqual(type(PyCSimpleType), type)
+
+        self.assertEqual(c_int.mro(), [c_int, _SimpleCData, _CData, object])
+
+    def test_type_flags(self):
+        for cls in _SimpleCData, PyCSimpleType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_SimpleCData.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_SimpleCData.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewT = PyCSimpleType.__new__(PyCSimpleType, 'NewT', (_SimpleCData,), {})
+        for cls in _SimpleCData, NewT:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(_SimpleCData):
+            _type_ = "i"
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCSimpleType.__init__(T, 'ptr', (), {})
+
+    def test_swapped_type_creation(self):
+        cls = PyCSimpleType.__new__(PyCSimpleType, '', (), {'_type_': 'i'})
+        with self.assertRaises(TypeError):
+            PyCSimpleType.__init__(cls)
+        PyCSimpleType.__init__(cls, '', (), {'_type_': 'i'})
+        self.assertEqual(cls.__ctype_le__.__dict__.get('_type_'), 'i')
+        self.assertEqual(cls.__ctype_be__.__dict__.get('_type_'), 'i')
+
+    def test_compare(self):
+        self.assertEqual(MyInt(3), MyInt(3))
+        self.assertNotEqual(MyInt(42), MyInt(43))
+
+    def test_ignore_retval(self):
+        # Test if the return value of a callback is ignored
+        # if restype is None
+        proto = CFUNCTYPE(None)
+        def func():
+            return (1, "abc", None)
+
+        cb = proto(func)
+        self.assertEqual(None, cb())
+
+
+    def test_int_callback(self):
+        args = []
+        def func(arg):
+            args.append(arg)
+            return arg
+
+        cb = CFUNCTYPE(None, MyInt)(func)
+
+        self.assertEqual(None, cb(42))
+        self.assertEqual(type(args[-1]), MyInt)
+
+        cb = CFUNCTYPE(c_int, c_int)(func)
+
+        self.assertEqual(42, cb(42))
+        self.assertEqual(type(args[-1]), int)
+
+    def test_int_struct(self):
+        class X(Structure):
+            _fields_ = [("x", MyInt)]
+
+        self.assertEqual(X().x, MyInt())
+
+        s = X()
+        s.x = MyInt(42)
+
+        self.assertEqual(s.x, MyInt(42))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_sizes.py b/Lib/test/test_ctypes/test_sizes.py
new file mode 100644
index 00000000000..e981ccfad5e
--- /dev/null
+++ b/Lib/test/test_ctypes/test_sizes.py
@@ -0,0 +1,38 @@
+# Test specifically-sized containers.
+
+from ctypes import (sizeof,
+                    c_int8, c_uint8, c_int16, c_uint16,
+                    c_int32, c_uint32, c_int64, c_uint64,
+                    c_void_p, c_size_t, c_ssize_t, c_time_t, SIZEOF_TIME_T)
+import unittest
+
+
+class SizesTestCase(unittest.TestCase):
+    def test_8(self):
+        self.assertEqual(1, sizeof(c_int8))
+        self.assertEqual(1, sizeof(c_uint8))
+
+    def test_16(self):
+        self.assertEqual(2, sizeof(c_int16))
+        self.assertEqual(2, sizeof(c_uint16))
+
+    def test_32(self):
+        self.assertEqual(4, sizeof(c_int32))
+        self.assertEqual(4, sizeof(c_uint32))
+
+    def test_64(self):
+        self.assertEqual(8, sizeof(c_int64))
+        self.assertEqual(8, sizeof(c_uint64))
+
+    def test_size_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
+
+    def test_ssize_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_ssize_t))
+
+    def test_time_t(self):
+        self.assertEqual(sizeof(c_time_t), SIZEOF_TIME_T)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_slicing.py b/Lib/test/test_ctypes/test_slicing.py
new file mode 100644
index 00000000000..66f9e530104
--- /dev/null
+++ b/Lib/test/test_ctypes/test_slicing.py
@@ -0,0 +1,170 @@
+import unittest
+from ctypes import (CDLL, POINTER, sizeof,
+                    c_byte, c_short, c_int, c_long, c_char, c_wchar, c_char_p)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class SlicesTestCase(unittest.TestCase):
+    def test_getslice_cint(self):
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
+        self.assertEqual(a[0:2], b[0:2])
+        self.assertEqual(a[0:2:], b[0:2:])
+        self.assertEqual(len(a), len(b))
+        self.assertEqual(a[5:7], b[5:7])
+        self.assertEqual(a[5:7:], b[5:7:])
+        self.assertEqual(a[-1], b[-1])
+        self.assertEqual(a[:], b[:])
+        self.assertEqual(a[::], b[::])
+        self.assertEqual(a[10::-1], b[10::-1])
+        self.assertEqual(a[30:20:-1], b[30:20:-1])
+        self.assertEqual(a[:12:6], b[:12:6])
+        self.assertEqual(a[2:6:4], b[2:6:4])
+
+        a[0:5] = range(5, 10)
+        self.assertEqual(a[0:5], list(range(5, 10)))
+        self.assertEqual(a[0:5:], list(range(5, 10)))
+        self.assertEqual(a[4::-1], list(range(9, 4, -1)))
+
+    def test_setslice_cint(self):
+        a = (c_int * 100)(*range(1100, 1200))
+        b = list(range(1100, 1200))
+
+        a[32:47] = list(range(32, 47))
+        self.assertEqual(a[32:47], list(range(32, 47)))
+        a[32:47] = range(132, 147)
+        self.assertEqual(a[32:47:], list(range(132, 147)))
+        a[46:31:-1] = range(232, 247)
+        self.assertEqual(a[32:47:1], list(range(246, 231, -1)))
+
+        a[32:47] = range(1132, 1147)
+        self.assertEqual(a[:], b)
+        a[32:47:7] = range(3)
+        b[32:47:7] = range(3)
+        self.assertEqual(a[:], b)
+        a[33::-3] = range(12)
+        b[33::-3] = range(12)
+        self.assertEqual(a[:], b)
+
+        # TypeError: int expected instead of str instance
+        with self.assertRaises(TypeError):
+            a[:5] = "abcde"
+
+        # TypeError: int expected instead of str instance
+        with self.assertRaises(TypeError):
+            a[:5] =  ["a", "b", "c", "d", "e"]
+
+        # TypeError: int expected instead of float instance
+        with self.assertRaises(TypeError):
+            a[:5] = [1, 2, 3, 4, 3.14]
+
+        # ValueError: Can only assign sequence of same size
+        with self.assertRaises(ValueError):
+            a[:5] = range(32)
+
+    def test_char_ptr(self):
+        s = b"abcdefghijklmnopqrstuvwxyz"
+
+        dll = CDLL(_ctypes_test.__file__)
+        dll.my_strdup.restype = POINTER(c_char)
+        dll.my_free.restype = None
+        res = dll.my_strdup(s)
+        self.assertEqual(res[:len(s)], s)
+        self.assertEqual(res[:3], s[:3])
+        self.assertEqual(res[:len(s):], s)
+        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
+        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
+        self.assertEqual(res[0:-1:-1], s[0::-1])
+
+        # get items
+        with self.assertRaises(ValueError):
+            res[:]
+        with self.assertRaises(ValueError):
+            res[0:]
+        with self.assertRaises(ValueError):
+            res[:5:-1]
+        with self.assertRaises(ValueError):
+            res[-5:]
+
+        # set items
+        with self.assertRaises(TypeError):
+            res[:5] = "abcde"
+
+        dll.my_free(res)
+
+        dll.my_strdup.restype = POINTER(c_byte)
+        res = dll.my_strdup(s)
+        self.assertEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
+        self.assertEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
+        dll.my_free(res)
+
+    def test_char_ptr_with_free(self):
+        dll = CDLL(_ctypes_test.__file__)
+        s = b"abcdefghijklmnopqrstuvwxyz"
+
+        class allocated_c_char_p(c_char_p):
+            pass
+
+        dll.my_free.restype = None
+        def errcheck(result, func, args):
+            retval = result.value
+            dll.my_free(result)
+            return retval
+
+        dll.my_strdup.restype = allocated_c_char_p
+        dll.my_strdup.errcheck = errcheck
+        try:
+            res = dll.my_strdup(s)
+            self.assertEqual(res, s)
+        finally:
+            del dll.my_strdup.errcheck
+
+
+    def test_char_array(self):
+        s = b"abcdefghijklmnopqrstuvwxyz\0"
+
+        p = (c_char * 27)(*s)
+        self.assertEqual(p[:], s)
+        self.assertEqual(p[::], s)
+        self.assertEqual(p[::-1], s[::-1])
+        self.assertEqual(p[5::-2], s[5::-2])
+        self.assertEqual(p[2:5:-3], s[2:5:-3])
+
+
+    def test_wchar_ptr(self):
+        s = "abcdefghijklmnopqrstuvwxyz\0"
+
+        dll = CDLL(_ctypes_test.__file__)
+        dll.my_wcsdup.restype = POINTER(c_wchar)
+        dll.my_wcsdup.argtypes = POINTER(c_wchar),
+        dll.my_free.restype = None
+        res = dll.my_wcsdup(s[:-1])
+        self.assertEqual(res[:len(s)], s)
+        self.assertEqual(res[:len(s):], s)
+        self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
+        self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
+
+        with self.assertRaises(TypeError):
+            res[:5] = "abcde"
+        dll.my_free(res)
+
+        if sizeof(c_wchar) == sizeof(c_short):
+            dll.my_wcsdup.restype = POINTER(c_short)
+        elif sizeof(c_wchar) == sizeof(c_int):
+            dll.my_wcsdup.restype = POINTER(c_int)
+        elif sizeof(c_wchar) == sizeof(c_long):
+            dll.my_wcsdup.restype = POINTER(c_long)
+        else:
+            self.skipTest('Pointers to c_wchar are not supported')
+        res = dll.my_wcsdup(s[:-1])
+        tmpl = list(range(ord("a"), ord("z")+1))
+        self.assertEqual(res[:len(s)-1], tmpl)
+        self.assertEqual(res[:len(s)-1:], tmpl)
+        self.assertEqual(res[len(s)-2:-1:-1], tmpl[::-1])
+        self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
+        dll.my_free(res)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_stringptr.py b/Lib/test/test_ctypes/test_stringptr.py
new file mode 100644
index 00000000000..bb6045b250f
--- /dev/null
+++ b/Lib/test/test_ctypes/test_stringptr.py
@@ -0,0 +1,81 @@
+import sys
+import unittest
+from test import support
+from ctypes import (CDLL, Structure, POINTER, create_string_buffer,
+                    c_char, c_char_p)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+lib = CDLL(_ctypes_test.__file__)
+
+
+class StringPtrTestCase(unittest.TestCase):
+    @support.refcount_test
+    def test__POINTER_c_char(self):
+        class X(Structure):
+            _fields_ = [("str", POINTER(c_char))]
+        x = X()
+
+        # NULL pointer access
+        self.assertRaises(ValueError, getattr, x.str, "contents")
+        b = create_string_buffer(b"Hello, World")
+        self.assertEqual(sys.getrefcount(b), 2)
+        x.str = b
+        self.assertEqual(sys.getrefcount(b), 3)
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and create_string_buffer() is compatible
+        for i in range(len(b)):
+            self.assertEqual(b[i], x.str[i])
+
+        self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
+
+    def test__c_char_p(self):
+        class X(Structure):
+            _fields_ = [("str", c_char_p)]
+        x = X()
+
+        # c_char_p and Python string is compatible
+        # c_char_p and create_string_buffer is NOT compatible
+        self.assertEqual(x.str, None)
+        x.str = b"Hello, World"
+        self.assertEqual(x.str, b"Hello, World")
+        b = create_string_buffer(b"Hello, World")
+        self.assertRaises(TypeError, setattr, x, b"str", b)
+
+
+    def test_functions(self):
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+
+        # c_char_p and Python string is compatible
+        # c_char_p and create_string_buffer are now compatible
+        strchr.argtypes = c_char_p, c_char
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+        self.assertEqual(strchr(create_string_buffer(b"abcdef"), b"c"),
+                         b"cdef")
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and create_string_buffer() is compatible
+        strchr.argtypes = POINTER(c_char), c_char
+        buf = create_string_buffer(b"abcdef")
+        self.assertEqual(strchr(buf, b"c"), b"cdef")
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+
+        # XXX These calls are dangerous, because the first argument
+        # to strchr is no longer valid after the function returns!
+        # So we must keep a reference to buf separately
+
+        strchr.restype = POINTER(c_char)
+        buf = create_string_buffer(b"abcdef")
+        r = strchr(buf, b"c")
+        x = r[0], r[1], r[2], r[3], r[4]
+        self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
+        del buf
+        # Because r is a pointer to memory that is freed after deleting buf,
+        # the pointer is hanging and using it would reference freed memory.
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_strings.py b/Lib/test/test_ctypes/test_strings.py
new file mode 100644
index 00000000000..3ecc6fe180a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_strings.py
@@ -0,0 +1,134 @@
+import unittest
+from ctypes import (create_string_buffer, create_unicode_buffer,
+                    sizeof, byref, c_char, c_wchar)
+
+
+class StringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_char * 4
+
+        buf = BUF(b"a", b"b", b"c")
+        self.assertEqual(buf.value, b"abc")
+        self.assertEqual(buf.raw, b"abc\000")
+
+        buf.value = b"ABCD"
+        self.assertEqual(buf.value, b"ABCD")
+        self.assertEqual(buf.raw, b"ABCD")
+
+        buf.value = b"x"
+        self.assertEqual(buf.value, b"x")
+        self.assertEqual(buf.raw, b"x\000CD")
+
+        buf[1] = b"Z"
+        self.assertEqual(buf.value, b"xZCD")
+        self.assertEqual(buf.raw, b"xZCD")
+
+        self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa")
+        self.assertRaises(TypeError, setattr, buf, "value", 42)
+
+    def test_create_string_buffer_value(self):
+        buf = create_string_buffer(32)
+
+        buf.value = b"Hello, World"
+        self.assertEqual(buf.value, b"Hello, World")
+
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_create_string_buffer_raw(self):
+        buf = create_string_buffer(32)
+
+        buf.raw = memoryview(b"Hello, World")
+        self.assertEqual(buf.value, b"Hello, World")
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_param_1(self):
+        BUF = c_char * 4
+        buf = BUF()
+
+    def test_param_2(self):
+        BUF = c_char * 4
+        buf = BUF()
+
+    def test_del_segfault(self):
+        BUF = c_char * 4
+        buf = BUF()
+        with self.assertRaises(AttributeError):
+            del buf.raw
+
+
+class WStringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_wchar * 4
+
+        buf = BUF("a", "b", "c")
+        self.assertEqual(buf.value, "abc")
+
+        buf.value = "ABCD"
+        self.assertEqual(buf.value, "ABCD")
+
+        buf.value = "x"
+        self.assertEqual(buf.value, "x")
+
+        buf[1] = "Z"
+        self.assertEqual(buf.value, "xZCD")
+
+    @unittest.skipIf(sizeof(c_wchar) < 4,
+                     "sizeof(wchar_t) is smaller than 4 bytes")
+    def test_nonbmp(self):
+        u = chr(0x10ffff)
+        w = c_wchar(u)
+        self.assertEqual(w.value, u)
+
+
+class WStringTestCase(unittest.TestCase):
+    def test_wchar(self):
+        c_wchar("x")
+        repr(byref(c_wchar("x")))
+        c_wchar("x")
+
+    def test_basic_wstrings(self):
+        cs = create_unicode_buffer("abcdef")
+        self.assertEqual(cs.value, "abcdef")
+
+        # value can be changed
+        cs.value = "abc"
+        self.assertEqual(cs.value, "abc")
+
+        # string is truncated at NUL character
+        cs.value = "def\0z"
+        self.assertEqual(cs.value, "def")
+
+        self.assertEqual(create_unicode_buffer("abc\0def").value, "abc")
+
+        # created with an empty string
+        cs = create_unicode_buffer(3)
+        self.assertEqual(cs.value, "")
+
+        cs.value = "abc"
+        self.assertEqual(cs.value, "abc")
+
+    def test_toolong(self):
+        cs = create_unicode_buffer("abc")
+        with self.assertRaises(ValueError):
+            cs.value = "abcdef"
+
+        cs = create_unicode_buffer(4)
+        with self.assertRaises(ValueError):
+            cs.value = "abcdef"
+
+
+def run_test(rep, msg, func, arg):
+    items = range(rep)
+    from time import perf_counter as clock
+    start = clock()
+    for i in items:
+        func(arg); func(arg); func(arg); func(arg); func(arg)
+    stop = clock()
+    print("%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep)))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_struct_fields.py b/Lib/test/test_ctypes/test_struct_fields.py
new file mode 100644
index 00000000000..fd9509757a3
--- /dev/null
+++ b/Lib/test/test_ctypes/test_struct_fields.py
@@ -0,0 +1,126 @@
+import unittest
+import sys
+from ctypes import Structure, Union, sizeof, c_char, c_int
+from ._support import (CField, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class StructFieldsTestCase(unittest.TestCase):
+    # Structure/Union classes must get 'finalized' sooner or
+    # later, when one of these things happen:
+    #
+    # 1. _fields_ is set.
+    # 2. An instance is created.
+    # 3. The type is used as field of another Structure/Union.
+    # 4. The type is subclassed
+    #
+    # When they are finalized, assigning _fields_ is no longer allowed.
+    def test_1_A(self):
+        class X(Structure):
+            pass
+        self.assertEqual(sizeof(X), 0) # not finalized
+        X._fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_1_B(self):
+        class X(Structure):
+            _fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_2(self):
+        class X(Structure):
+            pass
+        X()
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_3(self):
+        class X(Structure):
+            pass
+        class Y(Structure):
+            _fields_ = [("x", X)] # finalizes X
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_4(self):
+        class X(Structure):
+            pass
+        class Y(X):
+            pass
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        Y._fields_ = []
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_5(self):
+        class X(Structure):
+            _fields_ = (("char", c_char * 5),)
+
+        x = X(b'#' * 5)
+        x.char = b'a\0b\0'
+        self.assertEqual(bytes(x), b'a\x00###')
+
+    def test_6(self):
+        self.assertRaises(TypeError, CField)
+
+    def test_cfield_type_flags(self):
+        self.assertTrue(CField.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+        self.assertTrue(CField.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+
+    def test_cfield_inheritance_hierarchy(self):
+        self.assertEqual(CField.mro(), [CField, object])
+
+    def test_gh99275(self):
+        class BrokenStructure(Structure):
+            def __init_subclass__(cls, **kwargs):
+                cls._fields_ = []  # This line will fail, `stginfo` is not ready
+
+        with self.assertRaisesRegex(TypeError,
+                                    'ctypes state is not initialized'):
+            class Subclass(BrokenStructure): ...
+
+    def test_max_field_size_gh126937(self):
+        # Classes for big structs should be created successfully.
+        # (But they most likely can't be instantiated.)
+        # The size must fit in Py_ssize_t.
+
+        class X(Structure):
+            _fields_ = [('char', c_char),]
+        max_field_size = sys.maxsize
+
+        class Y(Structure):
+            _fields_ = [('largeField', X * max_field_size)]
+        class Z(Structure):
+            _fields_ = [('largeField', c_char * max_field_size)]
+
+        with self.assertRaises(OverflowError):
+            class TooBig(Structure):
+                _fields_ = [('largeField', X * (max_field_size + 1))]
+        with self.assertRaises(OverflowError):
+            class TooBig(Structure):
+                _fields_ = [('largeField', c_char * (max_field_size + 1))]
+
+    # __set__ and __get__ should raise a TypeError in case their self
+    # argument is not a ctype instance.
+    def test___set__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__set__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__set__, 'wrong type self', 42)
+
+    def test___get__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__get__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__get__, 'wrong type self', 42)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_structures.py b/Lib/test/test_ctypes/test_structures.py
new file mode 100644
index 00000000000..7650c80273f
--- /dev/null
+++ b/Lib/test/test_ctypes/test_structures.py
@@ -0,0 +1,956 @@
+from platform import architecture as _architecture
+import struct
+import sys
+import unittest
+from ctypes import (CDLL, Array, Structure, Union, POINTER, sizeof, byref, alignment,
+                    c_void_p, c_char, c_wchar, c_byte, c_ubyte,
+                    c_uint8, c_uint16, c_uint32,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong, c_float, c_double)
+from ctypes.util import find_library
+from struct import calcsize
+from collections import namedtuple
+from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCStructType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class SubclassesTest(unittest.TestCase):
+    def test_subclass(self):
+        class X(Structure):
+            _fields_ = [("a", c_int)]
+
+        class Y(X):
+            _fields_ = [("b", c_int)]
+
+        class Z(X):
+            pass
+
+        self.assertEqual(sizeof(X), sizeof(c_int))
+        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
+        self.assertEqual(sizeof(Z), sizeof(c_int))
+        self.assertEqual(X._fields_, [("a", c_int)])
+        self.assertEqual(Y._fields_, [("b", c_int)])
+        self.assertEqual(Z._fields_, [("a", c_int)])
+
+    def test_subclass_delayed(self):
+        class X(Structure):
+            pass
+        self.assertEqual(sizeof(X), 0)
+        X._fields_ = [("a", c_int)]
+
+        class Y(X):
+            pass
+        self.assertEqual(sizeof(Y), sizeof(X))
+        Y._fields_ = [("b", c_int)]
+
+        class Z(X):
+            pass
+
+        self.assertEqual(sizeof(X), sizeof(c_int))
+        self.assertEqual(sizeof(Y), sizeof(c_int)*2)
+        self.assertEqual(sizeof(Z), sizeof(c_int))
+        self.assertEqual(X._fields_, [("a", c_int)])
+        self.assertEqual(Y._fields_, [("b", c_int)])
+        self.assertEqual(Z._fields_, [("a", c_int)])
+
+
+class StructureTestCase(unittest.TestCase):
+    formats = {"c": c_char,
+               "b": c_byte,
+               "B": c_ubyte,
+               "h": c_short,
+               "H": c_ushort,
+               "i": c_int,
+               "I": c_uint,
+               "l": c_long,
+               "L": c_ulong,
+               "q": c_longlong,
+               "Q": c_ulonglong,
+               "f": c_float,
+               "d": c_double,
+               }
+
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(Structure.mro(), [Structure, _CData, object])
+
+        self.assertEqual(PyCStructType.__name__, "PyCStructType")
+        self.assertEqual(type(PyCStructType), type)
+
+
+    def test_type_flags(self):
+        for cls in Structure, PyCStructType:
+            with self.subTest(cls=cls):
+                self.assertTrue(Structure.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(Structure.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewStructure = PyCStructType.__new__(PyCStructType, 'NewStructure',
+                                             (Structure,), {})
+        for cls in Structure, NewStructure:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(Structure):
+            _fields_ = [("x", c_char),
+                        ("y", c_char)]
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCStructType.__init__(T, 'ptr', (), {})
+
+    def test_simple_structs(self):
+        for code, tp in self.formats.items():
+            class X(Structure):
+                _fields_ = [("x", c_char),
+                            ("y", tp)]
+            self.assertEqual((sizeof(X), code),
+                                 (calcsize("c%c0%c" % (code, code)), code))
+
+    def test_unions(self):
+        for code, tp in self.formats.items():
+            class X(Union):
+                _fields_ = [("x", c_char),
+                            ("y", tp)]
+            self.assertEqual((sizeof(X), code),
+                                 (calcsize("%c" % (code)), code))
+
+    def test_struct_alignment(self):
+        class X(Structure):
+            _fields_ = [("x", c_char * 3)]
+        self.assertEqual(alignment(X), calcsize("s"))
+        self.assertEqual(sizeof(X), calcsize("3s"))
+
+        class Y(Structure):
+            _fields_ = [("x", c_char * 3),
+                        ("y", c_int)]
+        self.assertEqual(alignment(Y), alignment(c_int))
+        self.assertEqual(sizeof(Y), calcsize("3si"))
+
+        class SI(Structure):
+            _fields_ = [("a", X),
+                        ("b", Y)]
+        self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
+        self.assertEqual(sizeof(SI), calcsize("3s0i 3si 0i"))
+
+        class IS(Structure):
+            _fields_ = [("b", Y),
+                        ("a", X)]
+
+        self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
+        self.assertEqual(sizeof(IS), calcsize("3si 3s 0i"))
+
+        class XX(Structure):
+            _fields_ = [("a", X),
+                        ("b", X)]
+        self.assertEqual(alignment(XX), alignment(X))
+        self.assertEqual(sizeof(XX), calcsize("3s 3s 0s"))
+
+    def test_empty(self):
+        # I had problems with these
+        #
+        # Although these are pathological cases: Empty Structures!
+        class X(Structure):
+            _fields_ = []
+
+        class Y(Union):
+            _fields_ = []
+
+        # Is this really the correct alignment, or should it be 0?
+        self.assertTrue(alignment(X) == alignment(Y) == 1)
+        self.assertTrue(sizeof(X) == sizeof(Y) == 0)
+
+        class XX(Structure):
+            _fields_ = [("a", X),
+                        ("b", X)]
+
+        self.assertEqual(alignment(XX), 1)
+        self.assertEqual(sizeof(XX), 0)
+
+    def test_fields(self):
+        # test the offset and size attributes of Structure/Union fields.
+        class X(Structure):
+            _fields_ = [("x", c_int),
+                        ("y", c_char)]
+
+        self.assertEqual(X.x.offset, 0)
+        self.assertEqual(X.x.size, sizeof(c_int))
+
+        self.assertEqual(X.y.offset, sizeof(c_int))
+        self.assertEqual(X.y.size, sizeof(c_char))
+
+        # readonly
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
+
+        class X(Union):
+            _fields_ = [("x", c_int),
+                        ("y", c_char)]
+
+        self.assertEqual(X.x.offset, 0)
+        self.assertEqual(X.x.size, sizeof(c_int))
+
+        self.assertEqual(X.y.offset, 0)
+        self.assertEqual(X.y.size, sizeof(c_char))
+
+        # readonly
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "offset", 92)
+        self.assertRaises((TypeError, AttributeError), setattr, X.x, "size", 92)
+
+        # XXX Should we check nested data types also?
+        # offset is always relative to the class...
+
+    def test_packed(self):
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 1
+
+        self.assertEqual(sizeof(X), 9)
+        self.assertEqual(X.b.offset, 1)
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 2
+        self.assertEqual(sizeof(X), 10)
+        self.assertEqual(X.b.offset, 2)
+
+        longlong_size = struct.calcsize("q")
+        longlong_align = struct.calcsize("bq") - longlong_size
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 4
+        self.assertEqual(sizeof(X), min(4, longlong_align) + longlong_size)
+        self.assertEqual(X.b.offset, min(4, longlong_align))
+
+        class X(Structure):
+            _fields_ = [("a", c_byte),
+                        ("b", c_longlong)]
+            _pack_ = 8
+
+        self.assertEqual(sizeof(X), min(8, longlong_align) + longlong_size)
+        self.assertEqual(X.b.offset, min(8, longlong_align))
+
+
+        d = {"_fields_": [("a", "b"),
+                          ("b", "q")],
+             "_pack_": -1}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+
+    @support.cpython_only
+    def test_packed_c_limits(self):
+        # Issue 15989
+        import _testcapi
+        d = {"_fields_": [("a", c_byte)],
+             "_pack_": _testcapi.INT_MAX + 1}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+        d = {"_fields_": [("a", c_byte)],
+             "_pack_": _testcapi.UINT_MAX + 2}
+        self.assertRaises(ValueError, type(Structure), "X", (Structure,), d)
+
+    def test_initializers(self):
+        class Person(Structure):
+            _fields_ = [("name", c_char*6),
+                        ("age", c_int)]
+
+        self.assertRaises(TypeError, Person, 42)
+        self.assertRaises(ValueError, Person, b"asldkjaslkdjaslkdj")
+        self.assertRaises(TypeError, Person, "Name", "HI")
+
+        # short enough
+        self.assertEqual(Person(b"12345", 5).name, b"12345")
+        # exact fit
+        self.assertEqual(Person(b"123456", 5).name, b"123456")
+        # too long
+        self.assertRaises(ValueError, Person, b"1234567", 5)
+
+    def test_conflicting_initializers(self):
+        class POINT(Structure):
+            _fields_ = [("phi", c_float), ("rho", c_float)]
+        # conflicting positional and keyword args
+        self.assertRaisesRegex(TypeError, "phi", POINT, 2, 3, phi=4)
+        self.assertRaisesRegex(TypeError, "rho", POINT, 2, 3, rho=4)
+
+        # too many initializers
+        self.assertRaises(TypeError, POINT, 2, 3, 4)
+
+    def test_keyword_initializers(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_int), ("y", c_int)]
+        pt = POINT(1, 2)
+        self.assertEqual((pt.x, pt.y), (1, 2))
+
+        pt = POINT(y=2, x=1)
+        self.assertEqual((pt.x, pt.y), (1, 2))
+
+    def test_invalid_field_types(self):
+        class POINT(Structure):
+            pass
+        self.assertRaises(TypeError, setattr, POINT, "_fields_", [("x", 1), ("y", 2)])
+
+    def test_invalid_name(self):
+        # field name must be string
+        def declare_with_name(name):
+            class S(Structure):
+                _fields_ = [(name, c_int)]
+
+        self.assertRaises(TypeError, declare_with_name, b"x")
+
+    def test_intarray_fields(self):
+        class SomeInts(Structure):
+            _fields_ = [("a", c_int * 4)]
+
+        # can use tuple to initialize array (but not list!)
+        self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
+        self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
+        self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
+        self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
+        self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
+        self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
+        self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
+        self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
+        # too long
+        # XXX Should raise ValueError?, not RuntimeError
+        self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
+
+    def test_nested_initializers(self):
+        # test initializing nested structures
+        class Phone(Structure):
+            _fields_ = [("areacode", c_char*6),
+                        ("number", c_char*12)]
+
+        class Person(Structure):
+            _fields_ = [("name", c_char * 12),
+                        ("phone", Phone),
+                        ("age", c_int)]
+
+        p = Person(b"Someone", (b"1234", b"5678"), 5)
+
+        self.assertEqual(p.name, b"Someone")
+        self.assertEqual(p.phone.areacode, b"1234")
+        self.assertEqual(p.phone.number, b"5678")
+        self.assertEqual(p.age, 5)
+
+    def test_structures_with_wchar(self):
+        class PersonW(Structure):
+            _fields_ = [("name", c_wchar * 12),
+                        ("age", c_int)]
+
+        p = PersonW("Someone \xe9")
+        self.assertEqual(p.name, "Someone \xe9")
+
+        self.assertEqual(PersonW("1234567890").name, "1234567890")
+        self.assertEqual(PersonW("12345678901").name, "12345678901")
+        # exact fit
+        self.assertEqual(PersonW("123456789012").name, "123456789012")
+        #too long
+        self.assertRaises(ValueError, PersonW, "1234567890123")
+
+    def test_init_errors(self):
+        class Phone(Structure):
+            _fields_ = [("areacode", c_char*6),
+                        ("number", c_char*12)]
+
+        class Person(Structure):
+            _fields_ = [("name", c_char * 12),
+                        ("phone", Phone),
+                        ("age", c_int)]
+
+        cls, msg = self.get_except(Person, b"Someone", (1, 2))
+        self.assertEqual(cls, RuntimeError)
+        self.assertEqual(msg,
+                             "(Phone) TypeError: "
+                             "expected bytes, int found")
+
+        cls, msg = self.get_except(Person, b"Someone", (b"a", b"b", b"c"))
+        self.assertEqual(cls, RuntimeError)
+        self.assertEqual(msg,
+                             "(Phone) TypeError: too many initializers")
+
+    def test_huge_field_name(self):
+        # issue12881: segfault with large structure field names
+        def create_class(length):
+            class S(Structure):
+                _fields_ = [('x' * length, c_int)]
+
+        for length in [10 ** i for i in range(0, 8)]:
+            try:
+                create_class(length)
+            except MemoryError:
+                # MemoryErrors are OK, we just don't want to segfault
+                pass
+
+    def get_except(self, func, *args):
+        try:
+            func(*args)
+        except Exception as detail:
+            return detail.__class__, str(detail)
+
+    def test_abstract_class(self):
+        class X(Structure):
+            _abstract_ = "something"
+        # try 'X()'
+        cls, msg = self.get_except(eval, "X()", locals())
+        self.assertEqual((cls, msg), (TypeError, "abstract class"))
+
+    def test_methods(self):
+        self.assertIn("in_dll", dir(type(Structure)))
+        self.assertIn("from_address", dir(type(Structure)))
+        self.assertIn("in_dll", dir(type(Structure)))
+
+    def test_positional_args(self):
+        # see also http://bugs.python.org/issue5042
+        class W(Structure):
+            _fields_ = [("a", c_int), ("b", c_int)]
+        class X(W):
+            _fields_ = [("c", c_int)]
+        class Y(X):
+            pass
+        class Z(Y):
+            _fields_ = [("d", c_int), ("e", c_int), ("f", c_int)]
+
+        z = Z(1, 2, 3, 4, 5, 6)
+        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
+                         (1, 2, 3, 4, 5, 6))
+        z = Z(1)
+        self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
+                         (1, 0, 0, 0, 0, 0))
+        self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
+
+    def test_pass_by_value(self):
+        # This should mirror the Test structure
+        # in Modules/_ctypes/_ctypes_test.c
+        class Test(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+
+        s = Test()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        s.third = 0x0bad1dea
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_large_struct_update_value
+        func.argtypes = (Test,)
+        func.restype = None
+        func(s)
+        self.assertEqual(s.first, 0xdeadbeef)
+        self.assertEqual(s.second, 0xcafebabe)
+        self.assertEqual(s.third, 0x0bad1dea)
+
+    def test_pass_by_value_finalizer(self):
+        # bpo-37140: Similar to test_pass_by_value(), but the Python structure
+        # has a finalizer (__del__() method): the finalizer must only be called
+        # once.
+
+        finalizer_calls = []
+
+        class Test(Structure):
+            _fields_ = [
+                ('first', c_ulong),
+                ('second', c_ulong),
+                ('third', c_ulong),
+            ]
+            def __del__(self):
+                finalizer_calls.append("called")
+
+        s = Test(1, 2, 3)
+        # Test the StructUnionType_paramfunc() code path which copies the
+        # structure: if the structure is larger than sizeof(void*).
+        self.assertGreater(sizeof(s), sizeof(c_void_p))
+
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_large_struct_update_value
+        func.argtypes = (Test,)
+        func.restype = None
+        func(s)
+        # bpo-37140: Passing the structure by reference must not call
+        # its finalizer!
+        self.assertEqual(finalizer_calls, [])
+        self.assertEqual(s.first, 1)
+        self.assertEqual(s.second, 2)
+        self.assertEqual(s.third, 3)
+
+        # The finalizer must be called exactly once
+        s = None
+        support.gc_collect()
+        self.assertEqual(finalizer_calls, ["called"])
+
+    def test_pass_by_value_in_register(self):
+        class X(Structure):
+            _fields_ = [
+                ('first', c_uint),
+                ('second', c_uint)
+            ]
+
+        s = X()
+        s.first = 0xdeadbeef
+        s.second = 0xcafebabe
+        dll = CDLL(_ctypes_test.__file__)
+        func = dll._testfunc_reg_struct_update_value
+        func.argtypes = (X,)
+        func.restype = None
+        func(s)
+        self.assertEqual(s.first, 0xdeadbeef)
+        self.assertEqual(s.second, 0xcafebabe)
+        got = X.in_dll(dll, "last_tfrsuv_arg")
+        self.assertEqual(s.first, got.first)
+        self.assertEqual(s.second, got.second)
+
+    def _test_issue18060(self, Vector):
+        # The call to atan2() should succeed if the
+        # class fields were correctly cloned in the
+        # subclasses. Otherwise, it will segfault.
+        if sys.platform == 'win32':
+            libm = CDLL(find_library('msvcrt.dll'))
+        else:
+            libm = CDLL(find_library('m'))
+
+        libm.atan2.argtypes = [Vector]
+        libm.atan2.restype = c_double
+
+        arg = Vector(y=0.0, x=-1.0)
+        self.assertAlmostEqual(libm.atan2(arg), 3.141592653589793)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_a(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment, and PyCStgInfo_clone()
+        # for the Mid and Vector class definitions.
+        class Base(Structure):
+            _fields_ = [('y', c_double),
+                        ('x', c_double)]
+        class Mid(Base):
+            pass
+        Mid._fields_ = []
+        class Vector(Mid): pass
+        self._test_issue18060(Vector)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_b(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment.
+        class Base(Structure):
+            _fields_ = [('y', c_double),
+                        ('x', c_double)]
+        class Mid(Base):
+            _fields_ = []
+        class Vector(Mid):
+            _fields_ = []
+        self._test_issue18060(Vector)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_c(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment.
+        class Base(Structure):
+            _fields_ = [('y', c_double)]
+        class Mid(Base):
+            _fields_ = []
+        class Vector(Mid):
+            _fields_ = [('x', c_double)]
+        self._test_issue18060(Vector)
+
+    def test_array_in_struct(self):
+        # See bpo-22273
+
+        # Load the shared library
+        dll = CDLL(_ctypes_test.__file__)
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+        class Test2(Structure):
+            _fields_ = [
+                ('data', c_ubyte * 16),
+            ]
+
+        class Test3AParent(Structure):
+            _fields_ = [
+                ('data', c_float * 2),
+            ]
+
+        class Test3A(Test3AParent):
+            _fields_ = [
+                ('more_data', c_float * 2),
+            ]
+
+        class Test3B(Structure):
+            _fields_ = [
+                ('data', c_double * 2),
+            ]
+
+        class Test3C(Structure):
+            _fields_ = [
+                ("data", c_double * 4)
+            ]
+
+        class Test3D(Structure):
+            _fields_ = [
+                ("data", c_double * 8)
+            ]
+
+        class Test3E(Structure):
+            _fields_ = [
+                ("data", c_double * 9)
+            ]
+
+
+        # Tests for struct Test2
+        s = Test2()
+        expected = 0
+        for i in range(16):
+            s.data[i] = i
+            expected += i
+        func = dll._testfunc_array_in_struct2
+        func.restype = c_int
+        func.argtypes = (Test2,)
+        result = func(s)
+        self.assertEqual(result, expected)
+        # check the passed-in struct hasn't changed
+        for i in range(16):
+            self.assertEqual(s.data[i], i)
+
+        # Tests for struct Test3A
+        s = Test3A()
+        s.data[0] = 3.14159
+        s.data[1] = 2.71828
+        s.more_data[0] = -3.0
+        s.more_data[1] = -2.0
+        expected = 3.14159 + 2.71828 - 3.0 - 2.0
+        func = dll._testfunc_array_in_struct3A
+        func.restype = c_double
+        func.argtypes = (Test3A,)
+        result = func(s)
+        self.assertAlmostEqual(result, expected, places=6)
+        # check the passed-in struct hasn't changed
+        self.assertAlmostEqual(s.data[0], 3.14159, places=6)
+        self.assertAlmostEqual(s.data[1], 2.71828, places=6)
+        self.assertAlmostEqual(s.more_data[0], -3.0, places=6)
+        self.assertAlmostEqual(s.more_data[1], -2.0, places=6)
+
+        # Test3B, Test3C, Test3D, Test3E have the same logic with different
+        # sizes hence putting them in a loop.
+        StructCtype = namedtuple(
+            "StructCtype",
+            ["cls", "cfunc1", "cfunc2", "items"]
+        )
+        structs_to_test = [
+            StructCtype(
+                Test3B,
+                dll._testfunc_array_in_struct3B,
+                dll._testfunc_array_in_struct3B_set_defaults,
+                2),
+            StructCtype(
+                Test3C,
+                dll._testfunc_array_in_struct3C,
+                dll._testfunc_array_in_struct3C_set_defaults,
+                4),
+            StructCtype(
+                Test3D,
+                dll._testfunc_array_in_struct3D,
+                dll._testfunc_array_in_struct3D_set_defaults,
+                8),
+            StructCtype(
+                Test3E,
+                dll._testfunc_array_in_struct3E,
+                dll._testfunc_array_in_struct3E_set_defaults,
+                9),
+        ]
+
+        for sut in structs_to_test:
+            s = sut.cls()
+
+            # Test for cfunc1
+            expected = 0
+            for i in range(sut.items):
+                float_i = float(i)
+                s.data[i] = float_i
+                expected += float_i
+            func = sut.cfunc1
+            func.restype = c_double
+            func.argtypes = (sut.cls,)
+            result = func(s)
+            self.assertEqual(result, expected)
+            # check the passed-in struct hasn't changed
+            for i in range(sut.items):
+                self.assertEqual(s.data[i], float(i))
+
+            # Test for cfunc2
+            func = sut.cfunc2
+            func.restype = sut.cls
+            result = func()
+            # check if the default values have been set correctly
+            for i in range(sut.items):
+                self.assertEqual(result.data[i], float(i+1))
+
+    def test_38368(self):
+        class U(Union):
+            _fields_ = [
+                ('f1', c_uint8 * 16),
+                ('f2', c_uint16 * 8),
+                ('f3', c_uint32 * 4),
+            ]
+        u = U()
+        u.f3[0] = 0x01234567
+        u.f3[1] = 0x89ABCDEF
+        u.f3[2] = 0x76543210
+        u.f3[3] = 0xFEDCBA98
+        f1 = [u.f1[i] for i in range(16)]
+        f2 = [u.f2[i] for i in range(8)]
+        if sys.byteorder == 'little':
+            self.assertEqual(f1, [0x67, 0x45, 0x23, 0x01,
+                                  0xef, 0xcd, 0xab, 0x89,
+                                  0x10, 0x32, 0x54, 0x76,
+                                  0x98, 0xba, 0xdc, 0xfe])
+            self.assertEqual(f2, [0x4567, 0x0123, 0xcdef, 0x89ab,
+                                  0x3210, 0x7654, 0xba98, 0xfedc])
+
+    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
+    def test_union_by_value(self):
+        # See bpo-16575
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+
+        class Nested1(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('another_int', c_int),
+            ]
+
+        class Test4(Union):
+            _fields_ = [
+                ('a_long', c_long),
+                ('a_struct', Nested1),
+            ]
+
+        class Nested2(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('a_union', Test4),
+            ]
+
+        class Test5(Structure):
+            _fields_ = [
+                ('an_int', c_int),
+                ('nested', Nested2),
+                ('another_int', c_int),
+            ]
+
+        test4 = Test4()
+        dll = CDLL(_ctypes_test.__file__)
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_union_by_value1
+            func.restype = c_long
+            func.argtypes = (Test4,)
+            result = func(test4)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+        test5 = Test5()
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_union_by_value2
+            func.restype = c_long
+            func.argtypes = (Test5,)
+            result = func(test5)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+
+        # passing by reference should be OK
+        test4.a_long = 12345;
+        func = dll._testfunc_union_by_reference1
+        func.restype = c_long
+        func.argtypes = (POINTER(Test4),)
+        result = func(byref(test4))
+        self.assertEqual(result, 12345)
+        self.assertEqual(test4.a_long, 0)
+        self.assertEqual(test4.a_struct.an_int, 0)
+        self.assertEqual(test4.a_struct.another_int, 0)
+        test4.a_struct.an_int = 0x12340000
+        test4.a_struct.another_int = 0x5678
+        func = dll._testfunc_union_by_reference2
+        func.restype = c_long
+        func.argtypes = (POINTER(Test4),)
+        result = func(byref(test4))
+        self.assertEqual(result, 0x12345678)
+        self.assertEqual(test4.a_long, 0)
+        self.assertEqual(test4.a_struct.an_int, 0)
+        self.assertEqual(test4.a_struct.another_int, 0)
+        test5.an_int = 0x12000000
+        test5.nested.an_int = 0x345600
+        test5.another_int = 0x78
+        func = dll._testfunc_union_by_reference3
+        func.restype = c_long
+        func.argtypes = (POINTER(Test5),)
+        result = func(byref(test5))
+        self.assertEqual(result, 0x12345678)
+        self.assertEqual(test5.an_int, 0)
+        self.assertEqual(test5.nested.an_int, 0)
+        self.assertEqual(test5.another_int, 0)
+
+    @unittest.skipIf(True, 'Test disabled for now - see bpo-16575/bpo-16576')
+    def test_bitfield_by_value(self):
+        # See bpo-16576
+
+        # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
+
+        class Test6(Structure):
+            _fields_ = [
+                ('A', c_int, 1),
+                ('B', c_int, 2),
+                ('C', c_int, 3),
+                ('D', c_int, 2),
+            ]
+
+        test6 = Test6()
+        # As these are signed int fields, all are logically -1 due to sign
+        # extension.
+        test6.A = 1
+        test6.B = 3
+        test6.C = 7
+        test6.D = 3
+        dll = CDLL(_ctypes_test.__file__)
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_bitfield_by_value1
+            func.restype = c_long
+            func.argtypes = (Test6,)
+            result = func(test6)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a struct/union with a bitfield by value, which is '
+                         'unsupported.')
+        # passing by reference should be OK
+        func = dll._testfunc_bitfield_by_reference1
+        func.restype = c_long
+        func.argtypes = (POINTER(Test6),)
+        result = func(byref(test6))
+        self.assertEqual(result, -4)
+        self.assertEqual(test6.A, 0)
+        self.assertEqual(test6.B, 0)
+        self.assertEqual(test6.C, 0)
+        self.assertEqual(test6.D, 0)
+
+        class Test7(Structure):
+            _fields_ = [
+                ('A', c_uint, 1),
+                ('B', c_uint, 2),
+                ('C', c_uint, 3),
+                ('D', c_uint, 2),
+            ]
+        test7 = Test7()
+        test7.A = 1
+        test7.B = 3
+        test7.C = 7
+        test7.D = 3
+        func = dll._testfunc_bitfield_by_reference2
+        func.restype = c_long
+        func.argtypes = (POINTER(Test7),)
+        result = func(byref(test7))
+        self.assertEqual(result, 14)
+        self.assertEqual(test7.A, 0)
+        self.assertEqual(test7.B, 0)
+        self.assertEqual(test7.C, 0)
+        self.assertEqual(test7.D, 0)
+
+        # for a union with bitfields, the union check happens first
+        class Test8(Union):
+            _fields_ = [
+                ('A', c_int, 1),
+                ('B', c_int, 2),
+                ('C', c_int, 3),
+                ('D', c_int, 2),
+            ]
+
+        test8 = Test8()
+        with self.assertRaises(TypeError) as ctx:
+            func = dll._testfunc_bitfield_by_value2
+            func.restype = c_long
+            func.argtypes = (Test8,)
+            result = func(test8)
+        self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
+                         'a union by value, which is unsupported.')
+
+
+class PointerMemberTestCase(unittest.TestCase):
+
+    def test(self):
+        # a Structure with a POINTER field
+        class S(Structure):
+            _fields_ = [("array", POINTER(c_int))]
+
+        s = S()
+        # We can assign arrays of the correct type
+        s.array = (c_int * 3)(1, 2, 3)
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [1, 2, 3])
+
+        # The following are bugs, but are included here because the unittests
+        # also describe the current behaviour.
+        #
+        # This fails with SystemError: bad arg to internal function
+        # or with IndexError (with a patch I have)
+
+        s.array[0] = 42
+
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [42, 2, 3])
+
+        s.array[0] = 1
+
+        items = [s.array[i] for i in range(3)]
+        self.assertEqual(items, [1, 2, 3])
+
+    def test_none_to_pointer_fields(self):
+        class S(Structure):
+            _fields_ = [("x", c_int),
+                        ("p", POINTER(c_int))]
+
+        s = S()
+        s.x = 12345678
+        s.p = None
+        self.assertEqual(s.x, 12345678)
+
+
+class TestRecursiveStructure(unittest.TestCase):
+    def test_contains_itself(self):
+        class Recursive(Structure):
+            pass
+
+        try:
+            Recursive._fields_ = [("next", Recursive)]
+        except AttributeError as details:
+            self.assertIn("Structure or union cannot contain itself",
+                          str(details))
+        else:
+            self.fail("Structure or union cannot contain itself")
+
+
+    def test_vice_versa(self):
+        class First(Structure):
+            pass
+        class Second(Structure):
+            pass
+
+        First._fields_ = [("second", Second)]
+
+        try:
+            Second._fields_ = [("first", First)]
+        except AttributeError as details:
+            self.assertIn("_fields_ is final", str(details))
+        else:
+            self.fail("AttributeError not raised")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_unaligned_structures.py b/Lib/test/test_ctypes/test_unaligned_structures.py
new file mode 100644
index 00000000000..58a00597ef5
--- /dev/null
+++ b/Lib/test/test_ctypes/test_unaligned_structures.py
@@ -0,0 +1,49 @@
+import sys, unittest
+from ctypes import (Structure, BigEndianStructure, LittleEndianStructure,
+                    c_byte, c_short, c_int, c_long, c_longlong,
+                    c_float, c_double,
+                    c_ushort, c_uint, c_ulong, c_ulonglong)
+
+
+structures = []
+byteswapped_structures = []
+
+
+if sys.byteorder == "little":
+    SwappedStructure = BigEndianStructure
+else:
+    SwappedStructure = LittleEndianStructure
+
+for typ in [c_short, c_int, c_long, c_longlong,
+            c_float, c_double,
+            c_ushort, c_uint, c_ulong, c_ulonglong]:
+    class X(Structure):
+        _pack_ = 1
+        _fields_ = [("pad", c_byte),
+                    ("value", typ)]
+    class Y(SwappedStructure):
+        _pack_ = 1
+        _fields_ = [("pad", c_byte),
+                    ("value", typ)]
+    structures.append(X)
+    byteswapped_structures.append(Y)
+
+
+class TestStructures(unittest.TestCase):
+    def test_native(self):
+        for typ in structures:
+            self.assertEqual(typ.value.offset, 1)
+            o = typ()
+            o.value = 4
+            self.assertEqual(o.value, 4)
+
+    def test_swapped(self):
+        for typ in byteswapped_structures:
+            self.assertEqual(typ.value.offset, 1)
+            o = typ()
+            o.value = 4
+            self.assertEqual(o.value, 4)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_unicode.py b/Lib/test/test_ctypes/test_unicode.py
new file mode 100644
index 00000000000..d9e17371d13
--- /dev/null
+++ b/Lib/test/test_ctypes/test_unicode.py
@@ -0,0 +1,63 @@
+import ctypes
+import unittest
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class UnicodeTestCase(unittest.TestCase):
+    def test_wcslen(self):
+        dll = ctypes.CDLL(_ctypes_test.__file__)
+        wcslen = dll.my_wcslen
+        wcslen.argtypes = [ctypes.c_wchar_p]
+
+        self.assertEqual(wcslen("abc"), 3)
+        self.assertEqual(wcslen("ab\u2070"), 3)
+        self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_unicode_buffer("abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_unicode_buffer("ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], '\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], 'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], "")
+
+    def test_embedded_null(self):
+        class TestStruct(ctypes.Structure):
+            _fields_ = [("unicode", ctypes.c_wchar_p)]
+        t = TestStruct()
+        # This would raise a ValueError:
+        t.unicode = "foo\0bar\0\0"
+
+
+func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
+
+class StringTestCase(UnicodeTestCase):
+    def setUp(self):
+        func.argtypes = [ctypes.c_char_p]
+        func.restype = ctypes.c_char_p
+
+    def tearDown(self):
+        func.argtypes = None
+        func.restype = ctypes.c_int
+
+    def test_func(self):
+        self.assertEqual(func(b"abc\xe4"), b"abc\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_string_buffer(b"abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], b'\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], b'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], b"")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_unions.py b/Lib/test/test_ctypes/test_unions.py
new file mode 100644
index 00000000000..e2dff0f22a9
--- /dev/null
+++ b/Lib/test/test_ctypes/test_unions.py
@@ -0,0 +1,35 @@
+import unittest
+from ctypes import Union, c_char
+from ._support import (_CData, UnionType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class ArrayTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(Union.mro(), [Union, _CData, object])
+
+        self.assertEqual(UnionType.__name__, "UnionType")
+        self.assertEqual(type(UnionType), type)
+
+    def test_type_flags(self):
+        for cls in Union, UnionType:
+            with self.subTest(cls=Union):
+                self.assertTrue(Union.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(Union.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewUnion = UnionType.__new__(UnionType, 'NewUnion',
+                                     (Union,), {})
+        for cls in Union, NewUnion:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(Union):
+            _fields_ = [("x", c_char),
+                        ("y", c_char)]
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            UnionType.__init__(T, 'ptr', (), {})
diff --git a/Lib/test/test_ctypes/test_values.py b/Lib/test/test_ctypes/test_values.py
new file mode 100644
index 00000000000..1b757e020d5
--- /dev/null
+++ b/Lib/test/test_ctypes/test_values.py
@@ -0,0 +1,107 @@
+"""
+A testcase which accesses *values* in a dll.
+"""
+
+import _imp
+import importlib.util
+import sys
+import unittest
+from ctypes import (Structure, CDLL, POINTER, pythonapi,
+                    _pointer_type_cache,
+                    c_ubyte, c_char_p, c_int)
+from test.support import import_helper
+
+
+class ValuesTestCase(unittest.TestCase):
+
+    def setUp(self):
+        _ctypes_test = import_helper.import_module("_ctypes_test")
+        self.ctdll = CDLL(_ctypes_test.__file__)
+
+    def test_an_integer(self):
+        # This test checks and changes an integer stored inside the
+        # _ctypes_test dll/shared lib.
+        ctdll = self.ctdll
+        an_integer = c_int.in_dll(ctdll, "an_integer")
+        x = an_integer.value
+        self.assertEqual(x, ctdll.get_an_integer())
+        an_integer.value *= 2
+        self.assertEqual(x*2, ctdll.get_an_integer())
+        # To avoid test failures when this test is repeated several
+        # times the original value must be restored
+        an_integer.value = x
+        self.assertEqual(x, ctdll.get_an_integer())
+
+    def test_undefined(self):
+        self.assertRaises(ValueError, c_int.in_dll, self.ctdll, "Undefined_Symbol")
+
+
+class PythonValuesTestCase(unittest.TestCase):
+    """This test only works when python itself is a dll/shared library"""
+
+    def test_optimizeflag(self):
+        # This test accesses the Py_OptimizeFlag integer, which is
+        # exported by the Python dll and should match the sys.flags value
+
+        opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
+        self.assertEqual(opt, sys.flags.optimize)
+
+    def test_frozentable(self):
+        # Python exports a PyImport_FrozenModules symbol. This is a
+        # pointer to an array of struct _frozen entries.  The end of the
+        # array is marked by an entry containing a NULL name and zero
+        # size.
+
+        # In standard Python, this table contains a __hello__
+        # module, and a __phello__ package containing a spam
+        # module.
+        class struct_frozen(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("code", POINTER(c_ubyte)),
+                        ("size", c_int),
+                        ("is_package", c_int),
+                        ]
+        FrozenTable = POINTER(struct_frozen)
+
+        modules = []
+        for group in ["Bootstrap", "Stdlib", "Test"]:
+            ft = FrozenTable.in_dll(pythonapi, f"_PyImport_Frozen{group}")
+            # ft is a pointer to the struct_frozen entries:
+            for entry in ft:
+                # This is dangerous. We *can* iterate over a pointer, but
+                # the loop will not terminate (maybe with an access
+                # violation;-) because the pointer instance has no size.
+                if entry.name is None:
+                    break
+                modname = entry.name.decode("ascii")
+                modules.append(modname)
+                with self.subTest(modname):
+                    if entry.size != 0:
+                        # Do a sanity check on entry.size and entry.code.
+                        self.assertGreater(abs(entry.size), 10)
+                        self.assertTrue([entry.code[i] for i in range(abs(entry.size))])
+                    # Check the module's package-ness.
+                    with import_helper.frozen_modules():
+                        spec = importlib.util.find_spec(modname)
+                    if entry.is_package:
+                        # It's a package.
+                        self.assertIsNotNone(spec.submodule_search_locations)
+                    else:
+                        self.assertIsNone(spec.submodule_search_locations)
+
+        with import_helper.frozen_modules():
+            expected = _imp._frozen_module_names()
+        self.maxDiff = None
+        self.assertEqual(modules, expected,
+                         "_PyImport_FrozenBootstrap example "
+                         "in Doc/library/ctypes.rst may be out of date")
+
+        del _pointer_type_cache[struct_frozen]
+
+    def test_undefined(self):
+        self.assertRaises(ValueError, c_int.in_dll, pythonapi,
+                          "Undefined_Symbol")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_varsize_struct.py b/Lib/test/test_ctypes/test_varsize_struct.py
new file mode 100644
index 00000000000..3e6ba6fed07
--- /dev/null
+++ b/Lib/test/test_ctypes/test_varsize_struct.py
@@ -0,0 +1,52 @@
+import unittest
+from ctypes import Structure, sizeof, resize, c_int
+
+
+class VarSizeTest(unittest.TestCase):
+    def test_resize(self):
+        class X(Structure):
+            _fields_ = [("item", c_int),
+                        ("array", c_int * 1)]
+
+        self.assertEqual(sizeof(X), sizeof(c_int) * 2)
+        x = X()
+        x.item = 42
+        x.array[0] = 100
+        self.assertEqual(sizeof(x), sizeof(c_int) * 2)
+
+        # make room for one additional item
+        new_size = sizeof(X) + sizeof(c_int) * 1
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+        # make room for 10 additional items
+        new_size = sizeof(X) + sizeof(c_int) * 9
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+        # make room for one additional item
+        new_size = sizeof(X) + sizeof(c_int) * 1
+        resize(x, new_size)
+        self.assertEqual(sizeof(x), new_size)
+        self.assertEqual((x.item, x.array[0]), (42, 100))
+
+    def test_array_invalid_length(self):
+        # cannot create arrays with non-positive size
+        self.assertRaises(ValueError, lambda: c_int * -1)
+        self.assertRaises(ValueError, lambda: c_int * -3)
+
+    def test_zerosized_array(self):
+        array = (c_int * 0)()
+        # accessing elements of zero-sized arrays raise IndexError
+        self.assertRaises(IndexError, array.__setitem__, 0, None)
+        self.assertRaises(IndexError, array.__getitem__, 0)
+        self.assertRaises(IndexError, array.__setitem__, 1, None)
+        self.assertRaises(IndexError, array.__getitem__, 1)
+        self.assertRaises(IndexError, array.__setitem__, -1, None)
+        self.assertRaises(IndexError, array.__getitem__, -1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_win32.py b/Lib/test/test_ctypes/test_win32.py
new file mode 100644
index 00000000000..31919118670
--- /dev/null
+++ b/Lib/test/test_ctypes/test_win32.py
@@ -0,0 +1,152 @@
+# Windows specific tests
+
+import ctypes
+import errno
+import sys
+import unittest
+from ctypes import (CDLL, Structure, POINTER, pointer, sizeof, byref,
+                    _pointer_type_cache,
+                    c_void_p, c_char, c_int, c_long)
+from test import support
+from test.support import import_helper
+from ._support import Py_TPFLAGS_DISALLOW_INSTANTIATION, Py_TPFLAGS_IMMUTABLETYPE
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class FunctionCallTestCase(unittest.TestCase):
+    @unittest.skipUnless('MSC' in sys.version, "SEH only supported by MSC")
+    @unittest.skipIf(sys.executable.lower().endswith('_d.exe'),
+                     "SEH not enabled in debug builds")
+    def test_SEH(self):
+        # Disable faulthandler to prevent logging the warning:
+        # "Windows fatal exception: access violation"
+        kernel32 = ctypes.windll.kernel32
+        with support.disable_faulthandler():
+            # Call functions with invalid arguments, and make sure
+            # that access violations are trapped and raise an
+            # exception.
+            self.assertRaises(OSError, kernel32.GetModuleHandleA, 32)
+
+    def test_noargs(self):
+        # This is a special case on win32 x64
+        user32 = ctypes.windll.user32
+        user32.GetDesktopWindow()
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class ReturnStructSizesTestCase(unittest.TestCase):
+    def test_sizes(self):
+        _ctypes_test = import_helper.import_module("_ctypes_test")
+        dll = CDLL(_ctypes_test.__file__)
+        for i in range(1, 11):
+            fields = [ (f"f{f}", c_char) for f in range(1, i + 1)]
+            class S(Structure):
+                _fields_ = fields
+            f = getattr(dll, f"TestSize{i}")
+            f.restype = S
+            res = f()
+            for i, f in enumerate(fields):
+                value = getattr(res, f[0])
+                expected = bytes([ord('a') + i])
+                self.assertEqual(value, expected)
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class TestWintypes(unittest.TestCase):
+    def test_HWND(self):
+        from ctypes import wintypes
+        self.assertEqual(sizeof(wintypes.HWND), sizeof(c_void_p))
+
+    def test_PARAM(self):
+        from ctypes import wintypes
+        self.assertEqual(sizeof(wintypes.WPARAM),
+                             sizeof(c_void_p))
+        self.assertEqual(sizeof(wintypes.LPARAM),
+                             sizeof(c_void_p))
+
+    def test_COMError(self):
+        from _ctypes import COMError
+        if support.HAVE_DOCSTRINGS:
+            self.assertEqual(COMError.__doc__,
+                             "Raised when a COM method call failed.")
+
+        ex = COMError(-1, "text", ("details",))
+        self.assertEqual(ex.hresult, -1)
+        self.assertEqual(ex.text, "text")
+        self.assertEqual(ex.details, ("details",))
+
+        self.assertEqual(COMError.mro(),
+                         [COMError, Exception, BaseException, object])
+        self.assertFalse(COMError.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+        self.assertTrue(COMError.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class TestWinError(unittest.TestCase):
+    def test_winerror(self):
+        # see Issue 16169
+        ERROR_INVALID_PARAMETER = 87
+        msg = ctypes.FormatError(ERROR_INVALID_PARAMETER).strip()
+        args = (errno.EINVAL, msg, None, ERROR_INVALID_PARAMETER)
+
+        e = ctypes.WinError(ERROR_INVALID_PARAMETER)
+        self.assertEqual(e.args, args)
+        self.assertEqual(e.errno, errno.EINVAL)
+        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
+
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetLastError(ERROR_INVALID_PARAMETER)
+        try:
+            raise ctypes.WinError()
+        except OSError as exc:
+            e = exc
+        self.assertEqual(e.args, args)
+        self.assertEqual(e.errno, errno.EINVAL)
+        self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
+
+
+class Structures(unittest.TestCase):
+    def test_struct_by_value(self):
+        class POINT(Structure):
+            _fields_ = [("x", c_long),
+                        ("y", c_long)]
+
+        class RECT(Structure):
+            _fields_ = [("left", c_long),
+                        ("top", c_long),
+                        ("right", c_long),
+                        ("bottom", c_long)]
+
+        _ctypes_test = import_helper.import_module("_ctypes_test")
+        dll = CDLL(_ctypes_test.__file__)
+
+        pt = POINT(15, 25)
+        left = c_long.in_dll(dll, 'left')
+        top = c_long.in_dll(dll, 'top')
+        right = c_long.in_dll(dll, 'right')
+        bottom = c_long.in_dll(dll, 'bottom')
+        rect = RECT(left, top, right, bottom)
+        PointInRect = dll.PointInRect
+        PointInRect.argtypes = [POINTER(RECT), POINT]
+        self.assertEqual(1, PointInRect(byref(rect), pt))
+
+        ReturnRect = dll.ReturnRect
+        ReturnRect.argtypes = [c_int, RECT, POINTER(RECT), POINT, RECT,
+                               POINTER(RECT), POINT, RECT]
+        ReturnRect.restype = RECT
+        for i in range(4):
+            ret = ReturnRect(i, rect, pointer(rect), pt, rect,
+                         byref(rect), pt, rect)
+            # the c function will check and modify ret if something is
+            # passed in improperly
+            self.assertEqual(ret.left, left.value)
+            self.assertEqual(ret.right, right.value)
+            self.assertEqual(ret.top, top.value)
+            self.assertEqual(ret.bottom, bottom.value)
+
+        # to not leak references, we must clean _pointer_type_cache
+        del _pointer_type_cache[RECT]
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_win32_com_foreign_func.py b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
new file mode 100644
index 00000000000..8d217fc17ef
--- /dev/null
+++ b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
@@ -0,0 +1,286 @@
+import ctypes
+import gc
+import sys
+import unittest
+from ctypes import POINTER, byref, c_void_p
+from ctypes.wintypes import BYTE, DWORD, WORD
+
+if sys.platform != "win32":
+    raise unittest.SkipTest("Windows-specific test")
+
+
+from _ctypes import COMError, CopyComPointer
+from ctypes import HRESULT
+
+
+COINIT_APARTMENTTHREADED = 0x2
+CLSCTX_SERVER = 5
+S_OK = 0
+OUT = 2
+TRUE = 1
+E_NOINTERFACE = -2147467262
+
+
+class GUID(ctypes.Structure):
+    # https://learn.microsoft.com/en-us/windows/win32/api/guiddef/ns-guiddef-guid
+    _fields_ = [
+        ("Data1", DWORD),
+        ("Data2", WORD),
+        ("Data3", WORD),
+        ("Data4", BYTE * 8),
+    ]
+
+
+def create_proto_com_method(name, index, restype, *argtypes):
+    proto = ctypes.WINFUNCTYPE(restype, *argtypes)
+
+    def make_method(*args):
+        foreign_func = proto(index, name, *args)
+
+        def call(self, *args, **kwargs):
+            return foreign_func(self, *args, **kwargs)
+
+        return call
+
+    return make_method
+
+
+def create_guid(name):
+    guid = GUID()
+    # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-clsidfromstring
+    ole32.CLSIDFromString(name, byref(guid))
+    return guid
+
+
+def is_equal_guid(guid1, guid2):
+    # https://learn.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-isequalguid
+    return ole32.IsEqualGUID(byref(guid1), byref(guid2))
+
+
+ole32 = ctypes.oledll.ole32
+
+IID_IUnknown = create_guid("{00000000-0000-0000-C000-000000000046}")
+IID_IStream = create_guid("{0000000C-0000-0000-C000-000000000046}")
+IID_IPersist = create_guid("{0000010C-0000-0000-C000-000000000046}")
+CLSID_ShellLink = create_guid("{00021401-0000-0000-C000-000000000046}")
+
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)
+proto_query_interface = create_proto_com_method(
+    "QueryInterface", 0, HRESULT, POINTER(GUID), POINTER(c_void_p)
+)
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-addref
+proto_add_ref = create_proto_com_method("AddRef", 1, ctypes.c_long)
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-release
+proto_release = create_proto_com_method("Release", 2, ctypes.c_long)
+# https://learn.microsoft.com/en-us/windows/win32/api/objidl/nf-objidl-ipersist-getclassid
+proto_get_class_id = create_proto_com_method(
+    "GetClassID", 3, HRESULT, POINTER(GUID)
+)
+
+
+def create_shelllink_persist(typ):
+    ppst = typ()
+    # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-cocreateinstance
+    ole32.CoCreateInstance(
+        byref(CLSID_ShellLink),
+        None,
+        CLSCTX_SERVER,
+        byref(IID_IPersist),
+        byref(ppst),
+    )
+    return ppst
+
+
+class ForeignFunctionsThatWillCallComMethodsTests(unittest.TestCase):
+    def setUp(self):
+        # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-coinitializeex
+        ole32.CoInitializeEx(None, COINIT_APARTMENTTHREADED)
+
+    def tearDown(self):
+        # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-couninitialize
+        ole32.CoUninitialize()
+        gc.collect()
+
+    def test_without_paramflags_and_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface()
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id()
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = GUID()
+        hr_getclsid = ppst.GetClassID(byref(clsid))
+        self.assertEqual(S_OK, hr_getclsid)
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(2, ppst.AddRef())
+        self.assertEqual(3, ppst.AddRef())
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(3, punk.Release())
+
+        with self.assertRaises(OSError) as e:
+            punk.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.winerror)
+
+        self.assertEqual(2, ppst.Release())
+        self.assertEqual(1, ppst.Release())
+        self.assertEqual(0, ppst.Release())
+
+    def test_with_paramflags_and_without_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),))
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = ppst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(1, punk.Release())
+
+        with self.assertRaises(OSError) as e:
+            ppst.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.winerror)
+
+        self.assertEqual(0, ppst.Release())
+
+    def test_with_paramflags_and_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None, IID_IUnknown)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),), IID_IPersist)
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = ppst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(1, punk.Release())
+
+        with self.assertRaises(COMError) as e:
+            ppst.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.hresult)
+
+        self.assertEqual(0, ppst.Release())
+
+
+class CopyComPointerTests(unittest.TestCase):
+    def setUp(self):
+        ole32.CoInitializeEx(None, COINIT_APARTMENTTHREADED)
+
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None, IID_IUnknown)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),), IID_IPersist)
+
+        self.IUnknown = IUnknown
+        self.IPersist = IPersist
+
+    def tearDown(self):
+        ole32.CoUninitialize()
+        gc.collect()
+
+    def test_both_are_null(self):
+        src = self.IPersist()
+        dst = self.IPersist()
+
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+
+        self.assertIsNone(src.value)
+        self.assertIsNone(dst.value)
+
+    def test_src_is_nonnull_and_dest_is_null(self):
+        # The reference count of the COM pointer created by `CoCreateInstance`
+        # is initially 1.
+        src = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+
+        # `CopyComPointer` calls `AddRef` explicitly in the C implementation.
+        # The refcount of `src` is incremented from 1 to 2 here.
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertEqual(src.value, dst.value)
+
+        # This indicates that the refcount was 2 before the `Release` call.
+        self.assertEqual(1, src.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(0, dst.Release())
+
+    def test_src_is_null_and_dest_is_nonnull(self):
+        src = self.IPersist()
+        dst_orig = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+        CopyComPointer(dst_orig, byref(dst))
+        self.assertEqual(1, dst_orig.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        # This does NOT affects the refcount of `dst_orig`.
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertIsNone(dst.value)
+
+        with self.assertRaises(ValueError):
+            dst.GetClassID()  # NULL COM pointer access
+
+        # This indicates that the refcount was 1 before the `Release` call.
+        self.assertEqual(0, dst_orig.Release())
+
+    def test_both_are_nonnull(self):
+        src = create_shelllink_persist(self.IPersist)
+        dst_orig = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+        CopyComPointer(dst_orig, byref(dst))
+        self.assertEqual(1, dst_orig.Release())
+
+        self.assertEqual(dst.value, dst_orig.value)
+        self.assertNotEqual(src.value, dst.value)
+
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertEqual(src.value, dst.value)
+        self.assertNotEqual(dst.value, dst_orig.value)
+
+        self.assertEqual(1, src.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(0, dst.Release())
+        self.assertEqual(0, dst_orig.Release())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_wintypes.py b/Lib/test/test_ctypes/test_wintypes.py
new file mode 100644
index 00000000000..a04d725a473
--- /dev/null
+++ b/Lib/test/test_ctypes/test_wintypes.py
@@ -0,0 +1,61 @@
+# See <https://learn.microsoft.com/en-us/windows/win32/winprog/windows-data-types>
+# for reference.
+#
+# Tests also work on POSIX
+
+import unittest
+from ctypes import POINTER, cast, c_int16
+from ctypes import wintypes
+
+
+class WinTypesTest(unittest.TestCase):
+    def test_variant_bool(self):
+        # reads 16-bits from memory, anything non-zero is True
+        for true_value in (1, 32767, 32768, 65535, 65537):
+            true = POINTER(c_int16)(c_int16(true_value))
+            value = cast(true, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(True)')
+
+            vb = wintypes.VARIANT_BOOL()
+            self.assertIs(vb.value, False)
+            vb.value = True
+            self.assertIs(vb.value, True)
+            vb.value = true_value
+            self.assertIs(vb.value, True)
+
+        for false_value in (0, 65536, 262144, 2**33):
+            false = POINTER(c_int16)(c_int16(false_value))
+            value = cast(false, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(False)')
+
+        # allow any bool conversion on assignment to value
+        for set_value in (65536, 262144, 2**33):
+            vb = wintypes.VARIANT_BOOL()
+            vb.value = set_value
+            self.assertIs(vb.value, True)
+
+        vb = wintypes.VARIANT_BOOL()
+        vb.value = [2, 3]
+        self.assertIs(vb.value, True)
+        vb.value = []
+        self.assertIs(vb.value, False)
+
+    def assertIsSigned(self, ctype):
+        self.assertLess(ctype(-1).value, 0)
+
+    def assertIsUnsigned(self, ctype):
+        self.assertGreater(ctype(-1).value, 0)
+
+    def test_signedness(self):
+        for ctype in (wintypes.BYTE, wintypes.WORD, wintypes.DWORD,
+                     wintypes.BOOLEAN, wintypes.UINT, wintypes.ULONG):
+            with self.subTest(ctype=ctype):
+                self.assertIsUnsigned(ctype)
+
+        for ctype in (wintypes.BOOL, wintypes.INT, wintypes.LONG):
+            with self.subTest(ctype=ctype):
+                self.assertIsSigned(ctype)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 4a352344b6abf257c4050786f2bfd8036da0f715 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sat, 20 Dec 2025 17:46:05 +0900
Subject: [PATCH 038/418] mark failing test_ctypes

---
 Lib/test/test_ctypes/test_cast.py                   | 2 ++
 Lib/test/test_ctypes/test_dlerror.py                | 1 +
 Lib/test/test_ctypes/test_internals.py              | 4 ++++
 Lib/test/test_ctypes/test_keeprefs.py               | 4 ++++
 Lib/test/test_ctypes/test_objects.py                | 3 ++-
 Lib/test/test_ctypes/test_python_api.py             | 4 ++++
 Lib/test/test_ctypes/test_random_things.py          | 2 ++
 Lib/test/test_ctypes/test_values.py                 | 4 ++++
 Lib/test/test_ctypes/test_win32.py                  | 2 ++
 Lib/test/test_ctypes/test_win32_com_foreign_func.py | 2 ++
 Lib/test/test_exceptions.py                         | 1 +
 Lib/test/test_os.py                                 | 3 ---
 12 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/Lib/test/test_ctypes/test_cast.py b/Lib/test/test_ctypes/test_cast.py
index 604f44f03d6..db6bdc75eff 100644
--- a/Lib/test/test_ctypes/test_cast.py
+++ b/Lib/test/test_ctypes/test_cast.py
@@ -32,6 +32,8 @@ def test_address2pointer(self):
         ptr = cast(address, POINTER(c_int))
         self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_p2a_objects(self):
         array = (c_char_p * 5)()
         self.assertEqual(array._objects, None)
diff --git a/Lib/test/test_ctypes/test_dlerror.py b/Lib/test/test_ctypes/test_dlerror.py
index 1c1b2aab3d5..cd87bad3825 100644
--- a/Lib/test/test_ctypes/test_dlerror.py
+++ b/Lib/test/test_ctypes/test_dlerror.py
@@ -54,6 +54,7 @@ class TestNullDlsym(unittest.TestCase):
     this 'dlsym returned NULL -> throw Error' rule.
     """
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_null_dlsym(self):
         import subprocess
         import tempfile
diff --git a/Lib/test/test_ctypes/test_internals.py b/Lib/test/test_ctypes/test_internals.py
index 778da6573da..292633aaa4b 100644
--- a/Lib/test/test_ctypes/test_internals.py
+++ b/Lib/test/test_ctypes/test_internals.py
@@ -27,6 +27,8 @@ def test_ints(self):
         self.assertEqual(refcnt, sys.getrefcount(i))
         self.assertEqual(ci._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_c_char_p(self):
         s = "Hello, World".encode("ascii")
         refcnt = sys.getrefcount(s)
@@ -62,6 +64,8 @@ class Y(Structure):
         x1.a, x2.b = 42, 93
         self.assertEqual(y._objects, {"0": {}, "1": {}})
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_xxx(self):
         class X(Structure):
             _fields_ = [("a", c_char_p), ("b", c_char_p)]
diff --git a/Lib/test/test_ctypes/test_keeprefs.py b/Lib/test/test_ctypes/test_keeprefs.py
index 23b03b64b4a..5aa5b86fa45 100644
--- a/Lib/test/test_ctypes/test_keeprefs.py
+++ b/Lib/test/test_ctypes/test_keeprefs.py
@@ -12,6 +12,8 @@ def test_cint(self):
         x = c_int(99)
         self.assertEqual(x._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ccharp(self):
         x = c_char_p()
         self.assertEqual(x._objects, None)
@@ -33,6 +35,8 @@ class X(Structure):
         x.b = 99
         self.assertEqual(x._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ccharp_struct(self):
         class X(Structure):
             _fields_ = [("a", c_char_p),
diff --git a/Lib/test/test_ctypes/test_objects.py b/Lib/test/test_ctypes/test_objects.py
index fb01421b955..8db1cd873fd 100644
--- a/Lib/test/test_ctypes/test_objects.py
+++ b/Lib/test/test_ctypes/test_objects.py
@@ -58,7 +58,8 @@
 
 
 def load_tests(loader, tests, pattern):
-    tests.addTest(doctest.DocTestSuite())
+    # TODO: RUSTPYTHON - doctest disabled due to null terminator in _objects
+    # tests.addTest(doctest.DocTestSuite())
     return tests
 
 
diff --git a/Lib/test/test_ctypes/test_python_api.py b/Lib/test/test_ctypes/test_python_api.py
index 1072a109833..2e68b35f8af 100644
--- a/Lib/test/test_ctypes/test_python_api.py
+++ b/Lib/test/test_ctypes/test_python_api.py
@@ -7,6 +7,8 @@
 
 
 class PythonAPITestCase(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_PyBytes_FromStringAndSize(self):
         PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
 
@@ -57,6 +59,8 @@ def test_PyObj_FromPtr(self):
         del pyobj
         self.assertEqual(sys.getrefcount(s), ref)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_PyOS_snprintf(self):
         PyOS_snprintf = pythonapi.PyOS_snprintf
         PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
diff --git a/Lib/test/test_ctypes/test_random_things.py b/Lib/test/test_ctypes/test_random_things.py
index 630f6ed9489..3908eca0926 100644
--- a/Lib/test/test_ctypes/test_random_things.py
+++ b/Lib/test/test_ctypes/test_random_things.py
@@ -70,6 +70,8 @@ def test_FloatDivisionError(self):
         with self.expect_unraisable(ZeroDivisionError):
             cb(0.0)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_TypeErrorDivisionError(self):
         cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
         err_msg = "unsupported operand type(s) for /: 'int' and 'bytes'"
diff --git a/Lib/test/test_ctypes/test_values.py b/Lib/test/test_ctypes/test_values.py
index 1b757e020d5..e0d200e2101 100644
--- a/Lib/test/test_ctypes/test_values.py
+++ b/Lib/test/test_ctypes/test_values.py
@@ -39,6 +39,8 @@ def test_undefined(self):
 class PythonValuesTestCase(unittest.TestCase):
     """This test only works when python itself is a dll/shared library"""
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_optimizeflag(self):
         # This test accesses the Py_OptimizeFlag integer, which is
         # exported by the Python dll and should match the sys.flags value
@@ -46,6 +48,8 @@ def test_optimizeflag(self):
         opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
         self.assertEqual(opt, sys.flags.optimize)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_frozentable(self):
         # Python exports a PyImport_FrozenModules symbol. This is a
         # pointer to an array of struct _frozen entries.  The end of the
diff --git a/Lib/test/test_ctypes/test_win32.py b/Lib/test/test_ctypes/test_win32.py
index 31919118670..4de4f0379cf 100644
--- a/Lib/test/test_ctypes/test_win32.py
+++ b/Lib/test/test_ctypes/test_win32.py
@@ -17,6 +17,8 @@ class FunctionCallTestCase(unittest.TestCase):
     @unittest.skipUnless('MSC' in sys.version, "SEH only supported by MSC")
     @unittest.skipIf(sys.executable.lower().endswith('_d.exe'),
                      "SEH not enabled in debug builds")
+    # TODO: RUSTPYTHON - SEH not implemented
+    @unittest.skipIf("RustPython" in sys.version, "SEH not implemented in RustPython")
     def test_SEH(self):
         # Disable faulthandler to prevent logging the warning:
         # "Windows fatal exception: access violation"
diff --git a/Lib/test/test_ctypes/test_win32_com_foreign_func.py b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
index 8d217fc17ef..b12e09333bd 100644
--- a/Lib/test/test_ctypes/test_win32_com_foreign_func.py
+++ b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
@@ -158,6 +158,8 @@ class IPersist(IUnknown):
 
         self.assertEqual(0, ppst.Release())
 
+    # TODO: RUSTPYTHON - COM iid parameter handling not implemented
+    @unittest.expectedFailure
     def test_with_paramflags_and_iid(self):
         class IUnknown(c_void_p):
             QueryInterface = proto_query_interface(None, IID_IUnknown)
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 61f4156dc6d..3db9203602e 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -430,6 +430,7 @@ def test_WindowsError(self):
 
     @unittest.skipUnless(sys.platform == 'win32',
                          'test specific to Windows')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_windows_message(self):
         """Should fill in unknown error code in Windows error message"""
         ctypes = import_module('ctypes')
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 939315379f2..bb558524c24 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -939,7 +939,6 @@ def get_file_system(self, path):
                 return buf.value
         # return None if the filesystem is unknown
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; (ModuleNotFoundError: No module named '_ctypes')")
     def test_large_time(self):
         # Many filesystems are limited to the year 2038. At least, the test
         # pass with NTFS filesystem.
@@ -2712,12 +2711,10 @@ def _kill(self, sig):
         os.kill(proc.pid, sig)
         self.assertEqual(proc.wait(), sig)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; (ModuleNotFoundError: No module named '_ctypes')")
     def test_kill_sigterm(self):
         # SIGTERM doesn't mean anything special, but make sure it works
         self._kill(signal.SIGTERM)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; (ModuleNotFoundError: No module named '_ctypes')")
     def test_kill_int(self):
         # os.kill on Windows can take an int which gets set as the exit code
         self._kill(100)

From 7c7e55ffc4072288f04f41f5cb2068d5953afc79 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Tue, 23 Dec 2025 16:39:04 +0900
Subject: [PATCH 039/418] Upgrade libffi

---
 Cargo.lock                              |  8 ++++----
 Cargo.toml                              |  2 +-
 crates/jit/src/lib.rs                   | 27 ++++++++++++-------------
 crates/vm/src/stdlib/ctypes.rs          |  2 +-
 crates/vm/src/stdlib/ctypes/array.rs    |  8 --------
 crates/vm/src/stdlib/ctypes/base.rs     |  2 +-
 crates/vm/src/stdlib/ctypes/function.rs |  2 +-
 7 files changed, 21 insertions(+), 30 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e3296732cb9..3620786402c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1687,9 +1687,9 @@ checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libffi"
-version = "4.1.2"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0feebbe0ccd382a2790f78d380540500d7b78ed7a3498b68fcfbc1593749a94"
+checksum = "0444124f3ffd67e1b0b0c661a7f81a278a135eb54aaad4078e79fbc8be50c8a5"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -1697,9 +1697,9 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "3.3.3"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90c6c6e17136d4bc439d43a2f3c6ccf0731cccc016d897473a29791d3c2160c3"
+checksum = "3d722da8817ea580d0669da6babe2262d7b86a1af1103da24102b8bb9c101ce7"
 dependencies = [
  "cc",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index fad506ddfaa..44f9d3190f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -178,7 +178,7 @@ itertools = "0.14.0"
 is-macro = "0.3.7"
 junction = "1.3.0"
 libc = "0.2.178"
-libffi = "4.1"
+libffi = "5"
 log = "0.4.29"
 nix = { version = "0.30", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
 malachite-bigint = "0.8"
diff --git a/crates/jit/src/lib.rs b/crates/jit/src/lib.rs
index 91911fd8d14..65ef87a62f6 100644
--- a/crates/jit/src/lib.rs
+++ b/crates/jit/src/lib.rs
@@ -157,7 +157,7 @@ impl CompiledCode {
         Ok(unsafe { self.invoke_raw(&cif_args) })
     }
 
-    unsafe fn invoke_raw(&self, cif_args: &[libffi::middle::Arg]) -> Option<AbiValue> {
+    unsafe fn invoke_raw(&self, cif_args: &[libffi::middle::Arg<'_>]) -> Option<AbiValue> {
         unsafe {
             let cif = self.sig.to_cif();
             let value = cif.call::<UnTypedAbiValue>(
@@ -219,7 +219,7 @@ pub enum AbiValue {
 }
 
 impl AbiValue {
-    fn to_libffi_arg(&self) -> libffi::middle::Arg {
+    fn to_libffi_arg(&self) -> libffi::middle::Arg<'_> {
         match self {
             AbiValue::Int(i) => libffi::middle::Arg::new(i),
             AbiValue::Float(f) => libffi::middle::Arg::new(f),
@@ -350,26 +350,25 @@ impl<'a> ArgsBuilder<'a> {
     }
 
     pub fn into_args(self) -> Option<Args<'a>> {
-        self.values
-            .iter()
-            .map(|v| v.as_ref().map(AbiValue::to_libffi_arg))
-            .collect::<Option<_>>()
-            .map(|cif_args| Args {
-                _values: self.values,
-                cif_args,
-                code: self.code,
-            })
+        // Ensure all values are set
+        if self.values.iter().any(|v| v.is_none()) {
+            return None;
+        }
+        Some(Args {
+            values: self.values.into_iter().map(|v| v.unwrap()).collect(),
+            code: self.code,
+        })
     }
 }
 
 pub struct Args<'a> {
-    _values: Vec<Option<AbiValue>>,
-    cif_args: Vec<libffi::middle::Arg>,
+    values: Vec<AbiValue>,
     code: &'a CompiledCode,
 }
 
 impl Args<'_> {
     pub fn invoke(&self) -> Option<AbiValue> {
-        unsafe { self.code.invoke_raw(&self.cif_args) }
+        let cif_args: Vec<_> = self.values.iter().map(AbiValue::to_libffi_arg).collect();
+        unsafe { self.code.invoke_raw(&cif_args) }
     }
 }
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index 9b922230431..a9c0636bd12 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -1102,7 +1102,7 @@ pub(crate) mod _ctypes {
             return Err(vm.new_value_error("NULL function pointer"));
         }
 
-        let mut ffi_args: Vec<Arg> = Vec::with_capacity(args.len());
+        let mut ffi_args: Vec<Arg<'_>> = Vec::with_capacity(args.len());
         let mut arg_values: Vec<isize> = Vec::with_capacity(args.len());
         let mut arg_types: Vec<Type> = Vec::with_capacity(args.len());
 
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 208b3e3f4d3..f31c8284d8b 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -1058,14 +1058,6 @@ impl PyCArray {
     }
 }
 
-impl PyCArray {
-    #[allow(unused)]
-    pub fn to_arg(&self, _vm: &VirtualMachine) -> PyResult<libffi::middle::Arg> {
-        let buffer = self.0.buffer.read();
-        Ok(libffi::middle::Arg::new(&*buffer))
-    }
-}
-
 impl AsBuffer for PyCArray {
     fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
         let buffer_len = zelf.0.buffer.read().len();
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index 44793a21561..0f859b3d10b 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -1821,7 +1821,7 @@ pub enum FfiArgValue {
 
 impl FfiArgValue {
     /// Create an Arg reference to this owned value
-    pub fn as_arg(&self) -> libffi::middle::Arg {
+    pub fn as_arg(&self) -> libffi::middle::Arg<'_> {
         match self {
             FfiArgValue::U8(v) => libffi::middle::Arg::new(v),
             FfiArgValue::I8(v) => libffi::middle::Arg::new(v),
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
index 04ff238ebcf..55a42f0ba15 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -1449,7 +1449,7 @@ enum RawResult {
 fn ctypes_callproc(code_ptr: CodePtr, arguments: &[Argument], call_info: &CallInfo) -> RawResult {
     let ffi_arg_types: Vec<Type> = arguments.iter().map(|a| a.ffi_type.clone()).collect();
     let cif = Cif::new(ffi_arg_types, call_info.ffi_return_type.clone());
-    let ffi_args: Vec<Arg> = arguments.iter().map(|a| a.value.as_arg()).collect();
+    let ffi_args: Vec<Arg<'_>> = arguments.iter().map(|a| a.value.as_arg()).collect();
 
     if call_info.restype_is_none {
         unsafe { cif.call::<()>(code_ptr, &ffi_args) };

From 00205aad1408df75a4b3a5ef648b894760459920 Mon Sep 17 00:00:00 2001
From: Jiseok CHOI <jiseok.dev@gmail.com>
Date: Wed, 24 Dec 2025 13:10:57 +0900
Subject: [PATCH 040/418] Bump libsqlite3-sys from 0.28 to 0.36 (#6472)

* Bump libsqlite3-sys from 0.28 to 0.36

Update libsqlite3-sys to version 0.36 and adapt to API changes by
replacing sqlite3_close_v2 with sqlite3_close. The v2 variant is no
longer directly exported in the newer version.

Fixes #6471

* Fix clippy
---
 Cargo.lock                  | 4 ++--
 crates/stdlib/Cargo.toml    | 2 +-
 crates/stdlib/src/sqlite.rs | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3620786402c..96fc9aa8d29 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1742,9 +1742,9 @@ dependencies = [
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.28.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
+checksum = "95b4103cffefa72eb8428cb6b47d6627161e51c2739fc5e3b734584157bc642a"
 dependencies = [
  "cc",
  "pkg-config",
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index 0cd853223e2..4885319ea17 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -132,7 +132,7 @@ oid-registry = { version = "0.8", features = ["x509", "pkcs1", "nist_algs"], opt
 pkcs8 = { version = "0.10", features = ["encryption", "pkcs5", "pem"], optional = true }
 
 [target.'cfg(not(any(target_os = "android", target_arch = "wasm32")))'.dependencies]
-libsqlite3-sys = { version = "0.28", features = ["bundled"], optional = true }
+libsqlite3-sys = { version = "0.36", features = ["bundled"], optional = true }
 lzma-sys = "0.1"
 xz2 = "0.1"
 
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index ffdc9eb3831..2328f23430a 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -30,7 +30,7 @@ mod _sqlite {
         sqlite3_bind_null, sqlite3_bind_parameter_count, sqlite3_bind_parameter_name,
         sqlite3_bind_text, sqlite3_blob, sqlite3_blob_bytes, sqlite3_blob_close, sqlite3_blob_open,
         sqlite3_blob_read, sqlite3_blob_write, sqlite3_busy_timeout, sqlite3_changes,
-        sqlite3_close_v2, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count,
+        sqlite3_close, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count,
         sqlite3_column_decltype, sqlite3_column_double, sqlite3_column_int64, sqlite3_column_name,
         sqlite3_column_text, sqlite3_column_type, sqlite3_complete, sqlite3_context,
         sqlite3_context_db_handle, sqlite3_create_collation_v2, sqlite3_create_function_v2,
@@ -1349,14 +1349,14 @@ mod _sqlite {
         fn set_trace_callback(&self, callable: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             let db = self.db_lock(vm)?;
             let Some(data) = CallbackData::new(callable, vm) else {
-                unsafe { sqlite3_trace_v2(db.db, SQLITE_TRACE_STMT as u32, None, null_mut()) };
+                unsafe { sqlite3_trace_v2(db.db, SQLITE_TRACE_STMT, None, null_mut()) };
                 return Ok(());
             };
 
             let ret = unsafe {
                 sqlite3_trace_v2(
                     db.db,
-                    SQLITE_TRACE_STMT as u32,
+                    SQLITE_TRACE_STMT,
                     Some(CallbackData::trace_callback),
                     Box::into_raw(Box::new(data)).cast(),
                 )
@@ -2661,7 +2661,7 @@ mod _sqlite {
 
     impl Drop for Sqlite {
         fn drop(&mut self) {
-            unsafe { sqlite3_close_v2(self.raw.db) };
+            unsafe { sqlite3_close(self.raw.db) };
         }
     }
 

From 215c5c6d7baa560e2687055443c3b8c9395d1441 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 13:15:33 +0900
Subject: [PATCH 041/418] signal.pthread_sigmask (#6475)

---
 crates/vm/src/stdlib/signal.rs | 89 +++++++++++++++++++++++++++++++---
 1 file changed, 83 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
index 6771a950400..d34a681c2da 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/signal.rs
@@ -69,6 +69,11 @@ pub(crate) mod _signal {
     #[pyattr]
     pub use libc::{SIG_DFL, SIG_IGN};
 
+    // pthread_sigmask 'how' constants
+    #[cfg(unix)]
+    #[pyattr]
+    use libc::{SIG_BLOCK, SIG_SETMASK, SIG_UNBLOCK};
+
     #[cfg(not(unix))]
     #[pyattr]
     pub const SIG_DFL: sighandler_t = 0;
@@ -400,14 +405,17 @@ pub(crate) mod _signal {
         let set = PySet::default().into_ref(&vm.ctx);
         #[cfg(unix)]
         {
-            // On Unix, most signals 1..NSIG are valid
+            // Use sigfillset to get all valid signals
+            let mut mask: libc::sigset_t = unsafe { std::mem::zeroed() };
+            // SAFETY: mask is a valid pointer
+            if unsafe { libc::sigfillset(&mut mask) } != 0 {
+                return Err(vm.new_os_error("sigfillset failed".to_owned()));
+            }
+            // Convert the filled mask to a Python set
             for signum in 1..signal::NSIG {
-                // Skip signals that cannot be caught
-                #[cfg(not(target_os = "wasi"))]
-                if signum == libc::SIGKILL as usize || signum == libc::SIGSTOP as usize {
-                    continue;
+                if unsafe { libc::sigismember(&mask, signum as i32) } == 1 {
+                    set.add(vm.ctx.new_int(signum as i32).into(), vm)?;
                 }
-                set.add(vm.ctx.new_int(signum as i32).into(), vm)?;
             }
         }
         #[cfg(windows)]
@@ -432,6 +440,75 @@ pub(crate) mod _signal {
         Ok(set.into())
     }
 
+    #[cfg(unix)]
+    fn sigset_to_pyset(mask: &libc::sigset_t, vm: &VirtualMachine) -> PyResult {
+        use crate::PyPayload;
+        use crate::builtins::PySet;
+        let set = PySet::default().into_ref(&vm.ctx);
+        for signum in 1..signal::NSIG {
+            // SAFETY: mask is a valid sigset_t
+            if unsafe { libc::sigismember(mask, signum as i32) } == 1 {
+                set.add(vm.ctx.new_int(signum as i32).into(), vm)?;
+            }
+        }
+        Ok(set.into())
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn pthread_sigmask(
+        how: i32,
+        mask: crate::function::ArgIterable,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use crate::convert::IntoPyException;
+
+        // Initialize sigset
+        let mut sigset: libc::sigset_t = unsafe { std::mem::zeroed() };
+        // SAFETY: sigset is a valid pointer
+        if unsafe { libc::sigemptyset(&mut sigset) } != 0 {
+            return Err(std::io::Error::last_os_error().into_pyexception(vm));
+        }
+
+        // Add signals to the set
+        for sig in mask.iter(vm)? {
+            let sig = sig?;
+            // Convert to i32, handling overflow by returning ValueError
+            let signum: i32 = sig.try_to_value(vm).map_err(|_| {
+                vm.new_value_error(format!(
+                    "signal number out of range [1, {}]",
+                    signal::NSIG - 1
+                ))
+            })?;
+            // Validate signal number is in range [1, NSIG)
+            if signum < 1 || signum >= signal::NSIG as i32 {
+                return Err(vm.new_value_error(format!(
+                    "signal number {} out of range [1, {}]",
+                    signum,
+                    signal::NSIG - 1
+                )));
+            }
+            // SAFETY: sigset is a valid pointer and signum is validated
+            if unsafe { libc::sigaddset(&mut sigset, signum) } != 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+        }
+
+        // Call pthread_sigmask
+        let mut old_mask: libc::sigset_t = unsafe { std::mem::zeroed() };
+        // SAFETY: all pointers are valid
+        let err = unsafe { libc::pthread_sigmask(how, &sigset, &mut old_mask) };
+        if err != 0 {
+            return Err(std::io::Error::from_raw_os_error(err).into_pyexception(vm));
+        }
+
+        // Check for pending signals
+        signal::check_signals(vm)?;
+
+        // Convert old mask to Python set
+        sigset_to_pyset(&old_mask, vm)
+    }
+
     #[cfg(any(unix, windows))]
     pub extern "C" fn run_signal(signum: i32) {
         signal::TRIGGERS[signum as usize].store(true, Ordering::Relaxed);

From c763d67ef4d374a26b155e50bd9991ea4b4ab89c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 13:50:26 +0900
Subject: [PATCH 042/418] Fix dict.keys behavior (#6476)

---
 crates/vm/src/builtins/dict.rs | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 04915b035f8..aff7432d067 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -70,13 +70,21 @@ impl PyDict {
             Err(other) => other,
         };
         let dict = &self.entries;
-        if let Some(keys) = vm.get_method(other.clone(), vm.ctx.intern_str("keys")) {
-            let keys = keys?.call((), vm)?.get_iter(vm)?;
-            while let PyIterReturn::Return(key) = keys.next(vm)? {
-                let val = other.get_item(&*key, vm)?;
-                dict.insert(vm, &*key, val)?;
+        // Use get_attr to properly invoke __getattribute__ for proxy objects
+        let keys_result = other.get_attr(vm.ctx.intern_str("keys"), vm);
+        let has_keys = match keys_result {
+            Ok(keys_method) => {
+                let keys = keys_method.call((), vm)?.get_iter(vm)?;
+                while let PyIterReturn::Return(key) = keys.next(vm)? {
+                    let val = other.get_item(&*key, vm)?;
+                    dict.insert(vm, &*key, val)?;
+                }
+                true
             }
-        } else {
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => false,
+            Err(e) => return Err(e),
+        };
+        if !has_keys {
             let iter = other.get_iter(vm)?;
             loop {
                 fn err(vm: &VirtualMachine) -> PyBaseExceptionRef {

From 014622ac346847883c9fc94793f1dfccb01363bf Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 14:23:33 +0900
Subject: [PATCH 043/418] Fix os.access not to raise exception when path
 doesn't exist (#6477)

* Fix os.access not to raise exception when path doesn't exist

* add test
---
 crates/vm/src/stdlib/posix.rs     | 11 ++++++-----
 extra_tests/snippets/stdlib_os.py | 10 ++++++++++
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index cfe605733d3..59e41782574 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -405,16 +405,17 @@ pub mod module {
         )
         })?;
 
-        let metadata = fs::metadata(&path.path);
+        let metadata = match fs::metadata(&path.path) {
+            Ok(m) => m,
+            // If the file doesn't exist, return False for any access check
+            Err(_) => return Ok(false),
+        };
 
         // if it's only checking for F_OK
         if flags == AccessFlags::F_OK {
-            return Ok(metadata.is_ok());
+            return Ok(true); // File exists
         }
 
-        let metadata =
-            metadata.map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
-
         let user_id = metadata.uid();
         let group_id = metadata.gid();
         let mode = metadata.mode();
diff --git a/extra_tests/snippets/stdlib_os.py b/extra_tests/snippets/stdlib_os.py
index a538365f707..d00924e10f2 100644
--- a/extra_tests/snippets/stdlib_os.py
+++ b/extra_tests/snippets/stdlib_os.py
@@ -518,3 +518,13 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             if option in ["PC_MAX_CANON", "PC_MAX_INPUT", "PC_VDISABLE"]:
                 continue
         assert os.pathconf("/", index) == os.pathconf("/", option)
+
+# os.access - test with empty path and nonexistent files
+assert os.access("", os.F_OK) is False
+assert os.access("", os.R_OK) is False
+assert os.access("", os.W_OK) is False
+assert os.access("", os.X_OK) is False
+assert os.access("nonexistent_file_12345", os.F_OK) is False
+assert os.access("nonexistent_file_12345", os.W_OK) is False
+assert os.access("README.md", os.F_OK) is True
+assert os.access("README.md", os.R_OK) is True

From 309b2ad32d0cebf25144340f4f5f905147a6b532 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 16:54:54 +0900
Subject: [PATCH 044/418] Fix ast end_location (#6478)

---
 Lib/test/test_ast/test_ast.py         |  3 --
 crates/vm/src/stdlib/ast.rs           | 44 +++++++++++++++++++++++----
 crates/vm/src/stdlib/ast/statement.rs | 11 ++++---
 3 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index 09d9444d5d9..628c243f2ff 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -191,7 +191,6 @@ def test_invalid_position_information(self):
                 with self.assertRaises(ValueError):
                     compile(tree, "<string>", "exec")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compilation_of_ast_nodes_with_default_end_position_values(self):
         tree = ast.Module(
             body=[
@@ -212,7 +211,6 @@ def test_compilation_of_ast_nodes_with_default_end_position_values(self):
         # Check that compilation doesn't crash. Note: this may crash explicitly only on debug mode.
         compile(tree, "<string>", "exec")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: required field "end_lineno" missing from alias
     def test_negative_locations_for_compile(self):
         # See https://github.com/python/cpython/issues/130775
         alias = ast.alias(name='traceback', lineno=0, col_offset=0)
@@ -1725,7 +1723,6 @@ def test_bad_integer(self):
             compile(mod, "test", "exec")
         self.assertIn("invalid integer value: None", str(cm.exception))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_level_as_none(self):
         body = [
             ast.ImportFrom(
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
index 00aad0213f3..8e03cb225ea 100644
--- a/crates/vm/src/stdlib/ast.rs
+++ b/crates/vm/src/stdlib/ast.rs
@@ -160,6 +160,20 @@ fn text_range_to_source_range(source_file: &SourceFile, text_range: TextRange) -
     }
 }
 
+fn get_opt_int_field(
+    vm: &VirtualMachine,
+    obj: &PyObject,
+    field: &'static str,
+) -> PyResult<Option<PyRefExact<PyInt>>> {
+    match get_node_field_opt(vm, obj, field)? {
+        Some(val) => val
+            .downcast_exact(vm)
+            .map(Some)
+            .map_err(|_| vm.new_type_error(format!(r#"field "{field}" must have integer type"#))),
+        None => Ok(None),
+    }
+}
+
 fn range_from_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
@@ -168,17 +182,35 @@ fn range_from_object(
 ) -> PyResult<TextRange> {
     let start_row = get_int_field(vm, &object, "lineno", name)?;
     let start_column = get_int_field(vm, &object, "col_offset", name)?;
-    let end_row = get_int_field(vm, &object, "end_lineno", name)?;
-    let end_column = get_int_field(vm, &object, "end_col_offset", name)?;
+    // end_lineno and end_col_offset are optional, default to start values
+    let end_row =
+        get_opt_int_field(vm, &object, "end_lineno")?.unwrap_or_else(|| start_row.clone());
+    let end_column =
+        get_opt_int_field(vm, &object, "end_col_offset")?.unwrap_or_else(|| start_column.clone());
+
+    // lineno=0 or negative values as a special case (no location info).
+    // Use default values (line 1, col 0) when lineno <= 0.
+    let start_row_val: i32 = start_row.try_to_primitive(vm)?;
+    let end_row_val: i32 = end_row.try_to_primitive(vm)?;
+    let start_col_val: i32 = start_column.try_to_primitive(vm)?;
+    let end_col_val: i32 = end_column.try_to_primitive(vm)?;
 
     let location = PySourceRange {
         start: PySourceLocation {
-            row: Row(OneIndexed::new(start_row.try_to_primitive(vm)?).unwrap()),
-            column: Column(TextSize::new(start_column.try_to_primitive(vm)?)),
+            row: Row(if start_row_val > 0 {
+                OneIndexed::new(start_row_val as usize).unwrap_or(OneIndexed::MIN)
+            } else {
+                OneIndexed::MIN
+            }),
+            column: Column(TextSize::new(start_col_val.max(0) as u32)),
         },
         end: PySourceLocation {
-            row: Row(OneIndexed::new(end_row.try_to_primitive(vm)?).unwrap()),
-            column: Column(TextSize::new(end_column.try_to_primitive(vm)?)),
+            row: Row(if end_row_val > 0 {
+                OneIndexed::new(end_row_val as usize).unwrap_or(OneIndexed::MIN)
+            } else {
+                OneIndexed::MIN
+            }),
+            column: Column(TextSize::new(end_col_val.max(0) as u32)),
         },
     };
 
diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/ast/statement.rs
index 5925ca1fc2a..6d9b35bee79 100644
--- a/crates/vm/src/stdlib/ast/statement.rs
+++ b/crates/vm/src/stdlib/ast/statement.rs
@@ -1105,10 +1105,13 @@ impl Node for ruff::StmtImportFrom {
                 source_file,
                 get_node_field(vm, &_object, "names", "ImportFrom")?,
             )?,
-            level: get_node_field(vm, &_object, "level", "ImportFrom")?
-                .downcast_exact::<PyInt>(vm)
-                .unwrap()
-                .try_to_primitive::<u32>(vm)?,
+            level: get_node_field_opt(vm, &_object, "level")?
+                .map(|obj| -> PyResult<u32> {
+                    let int: PyRef<PyInt> = obj.try_into_value(vm)?;
+                    int.try_to_primitive(vm)
+                })
+                .transpose()?
+                .unwrap_or(0),
             range: range_from_object(vm, source_file, _object, "ImportFrom")?,
         })
     }

From 4f0b940b160759dcef15c759971f730dfc18e3ba Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 17:02:21 +0900
Subject: [PATCH 045/418] impl preexec_fn (#6479)

---
 Lib/test/test_subprocess.py          | 12 -----------
 crates/stdlib/src/posixsubprocess.rs | 32 ++++++++++++++++++++++------
 2 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index e04f8b8fcc4..3917c0a76d9 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -2244,8 +2244,6 @@ def test_CalledProcessError_str_non_zero(self):
         error_string = str(err)
         self.assertIn("non-zero exit status 2.", error_string)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_preexec(self):
         # DISCLAIMER: Setting environment variables is *not* a good use
         # of a preexec_fn.  This is merely a test.
@@ -2257,8 +2255,6 @@ def test_preexec(self):
         with p:
             self.assertEqual(p.stdout.read(), b"apple")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_preexec_exception(self):
         def raise_it():
             raise ValueError("What if two swallows carried a coconut?")
@@ -2300,8 +2296,6 @@ def _execute_child(self, *args, **kwargs):
                     for fd in devzero_fds:
                         os.close(fd)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(not os.path.exists("/dev/zero"), "/dev/zero required.")
     def test_preexec_errpipe_does_not_double_close_pipes(self):
         """Issue16140: Don't double close pipes on preexec error."""
@@ -2339,8 +2333,6 @@ def test_preexec_gc_module_failure(self):
             if not enabled:
                 gc.disable()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
         sys.platform == 'darwin', 'setrlimit() seems to fail on OS X')
     def test_preexec_fork_failure(self):
@@ -2751,8 +2743,6 @@ def test_swap_std_fds_with_one_closed(self):
             for to_fds in itertools.permutations(range(3), 2):
                 self._check_swap_std_fds_with_one_closed(from_fds, to_fds)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_surrogates_error_message(self):
         def prepare():
             raise ValueError("surrogate:\uDCff")
@@ -3228,8 +3218,6 @@ def test_leak_fast_process_del_killed(self):
         else:
             self.assertNotIn(ident, [id(o) for o in subprocess._active])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_close_fds_after_preexec(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
 
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
index 4da6a6858dd..d05b24fd6dd 100644
--- a/crates/stdlib/src/posixsubprocess.rs
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -33,9 +33,6 @@ mod _posixsubprocess {
 
     #[pyfunction]
     fn fork_exec(args: ForkExecArgs<'_>, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
-        if args.preexec_fn.is_some() {
-            return Err(vm.new_not_implemented_error("preexec_fn not supported yet"));
-        }
         let extra_groups = args
             .groups_list
             .as_ref()
@@ -49,7 +46,7 @@ mod _posixsubprocess {
             extra_groups: extra_groups.as_deref(),
         };
         match unsafe { nix::unistd::fork() }.map_err(|err| err.into_pyexception(vm))? {
-            nix::unistd::ForkResult::Child => exec(&args, procargs),
+            nix::unistd::ForkResult::Child => exec(&args, procargs, vm),
             nix::unistd::ForkResult::Parent { child } => Ok(child.as_raw()),
         }
     }
@@ -227,13 +224,19 @@ struct ProcArgs<'a> {
     extra_groups: Option<&'a [Gid]>,
 }
 
-fn exec(args: &ForkExecArgs<'_>, procargs: ProcArgs<'_>) -> ! {
+fn exec(args: &ForkExecArgs<'_>, procargs: ProcArgs<'_>, vm: &VirtualMachine) -> ! {
     let mut ctx = ExecErrorContext::NoExec;
-    match exec_inner(args, procargs, &mut ctx) {
+    match exec_inner(args, procargs, &mut ctx, vm) {
         Ok(x) => match x {},
         Err(e) => {
             let mut pipe = args.errpipe_write;
-            let _ = write!(pipe, "OSError:{}:{}", e as i32, ctx.as_msg());
+            if matches!(ctx, ExecErrorContext::PreExec) {
+                // For preexec_fn errors, use SubprocessError format (errno=0)
+                let _ = write!(pipe, "SubprocessError:0:{}", ctx.as_msg());
+            } else {
+                // errno is written in hex format
+                let _ = write!(pipe, "OSError:{:x}:{}", e as i32, ctx.as_msg());
+            }
             std::process::exit(255)
         }
     }
@@ -242,6 +245,7 @@ fn exec(args: &ForkExecArgs<'_>, procargs: ProcArgs<'_>) -> ! {
 enum ExecErrorContext {
     NoExec,
     ChDir,
+    PreExec,
     Exec,
 }
 
@@ -250,6 +254,7 @@ impl ExecErrorContext {
         match self {
             Self::NoExec => "noexec",
             Self::ChDir => "noexec:chdir",
+            Self::PreExec => "Exception occurred in preexec_fn.",
             Self::Exec => "",
         }
     }
@@ -259,6 +264,7 @@ fn exec_inner(
     args: &ForkExecArgs<'_>,
     procargs: ProcArgs<'_>,
     ctx: &mut ExecErrorContext,
+    vm: &VirtualMachine,
 ) -> nix::Result<Never> {
     for &fd in args.fds_to_keep.as_slice() {
         if fd.as_raw_fd() != args.errpipe_write.as_raw_fd() {
@@ -345,6 +351,18 @@ fn exec_inner(
         nix::Error::result(ret)?;
     }
 
+    // Call preexec_fn after all process setup but before closing FDs
+    if let Some(ref preexec_fn) = args.preexec_fn {
+        match preexec_fn.call((), vm) {
+            Ok(_) => {}
+            Err(_e) => {
+                // Cannot safely stringify exception after fork
+                *ctx = ExecErrorContext::PreExec;
+                return Err(Errno::UnknownErrno);
+            }
+        }
+    }
+
     *ctx = ExecErrorContext::Exec;
 
     if args.close_fds {

From 3d7e521acdc07acd9572692fc5b36873eb5118db Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 17:29:47 +0900
Subject: [PATCH 046/418] introduce slot_wrapper (#4884)

---
 Lib/test/test_descr.py                |   1 -
 Lib/test/test_inspect/test_inspect.py |   3 +-
 Lib/test/test_types.py                |   2 +
 Lib/test/test_weakref.py              |   2 -
 crates/vm/src/builtins/descriptor.rs  | 204 +++++++++++++++++++++++++-
 crates/vm/src/builtins/object.rs      |  41 +++++-
 crates/vm/src/builtins/weakref.rs     |  24 ++-
 crates/vm/src/class.rs                |  17 ++-
 crates/vm/src/stdlib/io.rs            |   7 +-
 crates/vm/src/types/slot.rs           |   6 +-
 crates/vm/src/types/zoo.rs            |   4 +
 11 files changed, 291 insertions(+), 20 deletions(-)

diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 8c711207fae..88d120a427f 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -4941,7 +4941,6 @@ def __init__(self):
         for o in gc.get_objects():
             self.assertIsNot(type(o), X)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_object_new_and_init_with_parameters(self):
         # See issue #1683368
         class OverrideNeither:
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index d0fec18250e..e403ab7b226 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -409,6 +409,7 @@ class NotFuture: pass
 
         coro.close(); gen_coro.close() # silence warnings
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_isroutine(self):
         # method
         self.assertTrue(inspect.isroutine(git.argue))
@@ -1483,8 +1484,6 @@ def test_getfullargspec_definition_order_preserved_on_kwonly(self):
         l = list(signature.kwonlyargs)
         self.assertEqual(l, unsorted_keyword_only_parameters)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_classify_newstyle(self):
         class A(object):
 
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index fdcb9060e83..7e9b28236c7 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -597,6 +597,7 @@ def test_internal_sizes(self):
         self.assertGreater(object.__basicsize__, 0)
         self.assertGreater(tuple.__itemsize__, 0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_slot_wrapper_types(self):
         self.assertIsInstance(object.__init__, types.WrapperDescriptorType)
         self.assertIsInstance(object.__str__, types.WrapperDescriptorType)
@@ -611,6 +612,7 @@ def test_dunder_get_signature(self):
         # gh-93021: Second parameter is optional
         self.assertIs(sig.parameters["owner"].default, None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_method_wrapper_types(self):
         self.assertIsInstance(object().__init__, types.MethodWrapperType)
         self.assertIsInstance(object().__str__, types.MethodWrapperType)
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index e7cd5962cf9..f47c17b7234 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -906,8 +906,6 @@ def __del__(self):
 
         w = Target()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         # Issue 3634
         # <weakref to class>.__init__() doesn't check errors correctly
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index cdcc456edfc..2ccd1dcc0e9 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -3,8 +3,11 @@ use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
     class::PyClassImpl,
+    common::hash::PyHash,
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
-    types::{Callable, GetDescriptor, Representable},
+    types::{
+        Callable, Comparable, GetDescriptor, Hashable, InitFunc, PyComparisonOp, Representable,
+    },
 };
 use rustpython_common::lock::PyRwLock;
 
@@ -219,7 +222,7 @@ impl std::fmt::Debug for PyMemberDef {
     }
 }
 
-// PyMemberDescrObject in CPython
+// = PyMemberDescrObject
 #[pyclass(name = "member_descriptor", module = false)]
 #[derive(Debug)]
 pub struct PyMemberDescriptor {
@@ -382,4 +385,201 @@ impl GetDescriptor for PyMemberDescriptor {
 pub fn init(ctx: &Context) {
     PyMemberDescriptor::extend_class(ctx, ctx.types.member_descriptor_type);
     PyMethodDescriptor::extend_class(ctx, ctx.types.method_descriptor_type);
+    PySlotWrapper::extend_class(ctx, ctx.types.wrapper_descriptor_type);
+    PyMethodWrapper::extend_class(ctx, ctx.types.method_wrapper_type);
+}
+
+// PySlotWrapper - wrapper_descriptor
+
+/// wrapper_descriptor: wraps a slot function as a Python method
+// = PyWrapperDescrObject
+#[pyclass(name = "wrapper_descriptor", module = false)]
+#[derive(Debug)]
+pub struct PySlotWrapper {
+    pub typ: &'static Py<PyType>,
+    pub name: &'static PyStrInterned,
+    pub wrapped: InitFunc,
+    pub doc: Option<&'static str>,
+}
+
+impl PyPayload for PySlotWrapper {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.wrapper_descriptor_type
+    }
+}
+
+impl GetDescriptor for PySlotWrapper {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match obj {
+            None => Ok(zelf),
+            Some(obj) if vm.is_none(&obj) => Ok(zelf),
+            Some(obj) => {
+                let zelf = zelf.downcast::<Self>().unwrap();
+                Ok(PyMethodWrapper { wrapper: zelf, obj }.into_pyobject(vm))
+            }
+        }
+    }
+}
+
+impl Callable for PySlotWrapper {
+    type Args = FuncArgs;
+
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // list.__init__(l, [1,2,3]) form
+        let (obj, rest): (PyObjectRef, FuncArgs) = args.bind(vm)?;
+
+        if !obj.fast_isinstance(zelf.typ) {
+            return Err(vm.new_type_error(format!(
+                "descriptor '{}' requires a '{}' object but received a '{}'",
+                zelf.name.as_str(),
+                zelf.typ.name(),
+                obj.class().name()
+            )));
+        }
+
+        (zelf.wrapped)(obj, rest, vm)?;
+        Ok(vm.ctx.none())
+    }
+}
+
+#[pyclass(
+    with(GetDescriptor, Callable, Representable),
+    flags(DISALLOW_INSTANTIATION)
+)]
+impl PySlotWrapper {
+    #[pygetset]
+    fn __name__(&self) -> &'static PyStrInterned {
+        self.name
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> String {
+        format!("{}.{}", self.typ.name(), self.name)
+    }
+
+    #[pygetset]
+    fn __objclass__(&self) -> PyTypeRef {
+        self.typ.to_owned()
+    }
+
+    #[pygetset]
+    fn __doc__(&self) -> Option<&'static str> {
+        self.doc
+    }
+}
+
+impl Representable for PySlotWrapper {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<slot wrapper '{}' of '{}' objects>",
+            zelf.name.as_str(),
+            zelf.typ.name()
+        ))
+    }
+}
+
+// PyMethodWrapper - method-wrapper
+
+/// method-wrapper: a slot wrapper bound to an instance
+/// Returned when accessing l.__init__ on an instance
+#[pyclass(name = "method-wrapper", module = false, traverse)]
+#[derive(Debug)]
+pub struct PyMethodWrapper {
+    pub wrapper: PyRef<PySlotWrapper>,
+    #[pytraverse(skip)]
+    pub obj: PyObjectRef,
+}
+
+impl PyPayload for PyMethodWrapper {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.method_wrapper_type
+    }
+}
+
+impl Callable for PyMethodWrapper {
+    type Args = FuncArgs;
+
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        (zelf.wrapper.wrapped)(zelf.obj.clone(), args, vm)?;
+        Ok(vm.ctx.none())
+    }
+}
+
+#[pyclass(
+    with(Callable, Representable, Hashable, Comparable),
+    flags(DISALLOW_INSTANTIATION)
+)]
+impl PyMethodWrapper {
+    #[pygetset]
+    fn __self__(&self) -> PyObjectRef {
+        self.obj.clone()
+    }
+
+    #[pygetset]
+    fn __name__(&self) -> &'static PyStrInterned {
+        self.wrapper.name
+    }
+
+    #[pygetset]
+    fn __objclass__(&self) -> PyTypeRef {
+        self.wrapper.typ.to_owned()
+    }
+
+    #[pymethod]
+    fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+        let builtins_getattr = vm.builtins.get_attr("getattr", vm)?;
+        Ok(vm
+            .ctx
+            .new_tuple(vec![
+                builtins_getattr,
+                vm.ctx
+                    .new_tuple(vec![
+                        zelf.obj.clone(),
+                        vm.ctx.new_str(zelf.wrapper.name.as_str()).into(),
+                    ])
+                    .into(),
+            ])
+            .into())
+    }
+}
+
+impl Representable for PyMethodWrapper {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<method-wrapper '{}' of {} object at {:#x}>",
+            zelf.wrapper.name.as_str(),
+            zelf.obj.class().name(),
+            zelf.obj.get_id()
+        ))
+    }
+}
+
+impl Hashable for PyMethodWrapper {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        let obj_hash = zelf.obj.hash(vm)?;
+        let wrapper_hash = zelf.wrapper.as_object().get_id() as PyHash;
+        Ok(obj_hash ^ wrapper_hash)
+    }
+}
+
+impl Comparable for PyMethodWrapper {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<crate::function::PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let eq = zelf.wrapper.is(&other.wrapper) && vm.bool_eq(&zelf.obj, &other.obj)?;
+            Ok(eq.into())
+        })
+    }
 }
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 0970496c7b1..854cb2701ed 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -118,7 +118,46 @@ impl Constructor for PyBaseObject {
 impl Initializer for PyBaseObject {
     type Args = FuncArgs;
 
-    fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
+    // object_init: excess_args validation
+    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let typ = zelf.class();
+        let object_type = &vm.ctx.types.object_type;
+
+        let typ_init = typ.slots.init.load().map(|f| f as usize);
+        let object_init = object_type.slots.init.load().map(|f| f as usize);
+        let typ_new = typ.slots.new.load().map(|f| f as usize);
+        let object_new = object_type.slots.new.load().map(|f| f as usize);
+
+        // For heap types (Python classes), check if __new__ is defined anywhere in MRO
+        // (before object) because heap types always have slots.new = new_wrapper via MRO
+        let is_heap_type = typ
+            .slots
+            .flags
+            .contains(crate::types::PyTypeFlags::HEAPTYPE);
+        let new_overridden = if is_heap_type {
+            // Check if __new__ is defined in any base class (excluding object)
+            let new_id = identifier!(vm, __new__);
+            typ.mro_collect()
+                .into_iter()
+                .take_while(|t| !std::ptr::eq(t.as_ref(), *object_type))
+                .any(|t| t.attributes.read().contains_key(new_id))
+        } else {
+            // For built-in types, use slot comparison
+            typ_new != object_new
+        };
+
+        // If both __init__ and __new__ are overridden, allow excess args
+        if typ_init != object_init && new_overridden {
+            return Ok(());
+        }
+
+        // Otherwise, reject excess args
+        if !args.is_empty() {
+            return Err(vm.new_type_error(format!(
+                "{}.__init__() takes exactly one argument (the instance to initialize)",
+                typ.name()
+            )));
+        }
         Ok(())
     }
 
diff --git a/crates/vm/src/builtins/weakref.rs b/crates/vm/src/builtins/weakref.rs
index 88d6dbac3ed..327c0fd1489 100644
--- a/crates/vm/src/builtins/weakref.rs
+++ b/crates/vm/src/builtins/weakref.rs
@@ -4,10 +4,12 @@ use crate::common::{
     hash::{self, PyHash},
 };
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     function::{FuncArgs, OptionalArg},
-    types::{Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+    types::{
+        Callable, Comparable, Constructor, Hashable, Initializer, PyComparisonOp, Representable,
+    },
 };
 
 pub use crate::object::PyWeak;
@@ -49,8 +51,24 @@ impl Constructor for PyWeak {
     }
 }
 
+impl Initializer for PyWeak {
+    type Args = WeakNewArgs;
+
+    // weakref_tp_init: accepts args but does nothing (all init done in slot_new)
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        Ok(())
+    }
+}
+
 #[pyclass(
-    with(Callable, Hashable, Comparable, Constructor, Representable),
+    with(
+        Callable,
+        Hashable,
+        Comparable,
+        Constructor,
+        Initializer,
+        Representable
+    ),
     flags(BASETYPE)
 )]
 impl PyWeak {
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 6a366385702..92e9f6a15be 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -1,7 +1,8 @@
 //! Utilities to define a new Python class
 
 use crate::{
-    builtins::{PyBaseObject, PyType, PyTypeRef},
+    PyPayload,
+    builtins::{PyBaseObject, PyType, PyTypeRef, descriptor::PySlotWrapper},
     function::PyMethodDef,
     object::Py,
     types::{PyTypeFlags, PyTypeSlots, hash_not_implemented},
@@ -135,6 +136,20 @@ pub trait PyClassImpl: PyClassDef {
             }
         }
 
+        // Add __init__ slot wrapper if slot exists and not already in dict
+        if let Some(init_func) = class.slots.init.load() {
+            let init_name = identifier!(ctx, __init__);
+            if !class.attributes.read().contains_key(init_name) {
+                let wrapper = PySlotWrapper {
+                    typ: class,
+                    name: ctx.intern_str("__init__"),
+                    wrapped: init_func,
+                    doc: Some("Initialize self. See help(type(self)) for accurate signature."),
+                };
+                class.set_attr(init_name, wrapper.into_ref(ctx).into());
+            }
+        }
+
         if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
             class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
         }
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index ba3576a176c..2c3c02ec65c 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -1464,17 +1464,12 @@ mod _io {
         #[pyslot]
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let zelf: PyRef<Self> = zelf.try_into_value(vm)?;
-            zelf.__init__(args, vm)
-        }
-
-        #[pymethod]
-        fn __init__(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let (raw, BufferSize { buffer_size }): (PyObjectRef, _) =
                 args.bind(vm).map_err(|e| {
                     let msg = format!("{}() {}", Self::CLASS_NAME, *e.__str__(vm));
                     vm.new_exception_msg(e.class().to_owned(), msg)
                 })?;
-            self.init(raw, BufferSize { buffer_size }, vm)
+            zelf.init(raw, BufferSize { buffer_size }, vm)
         }
 
         fn init(
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 5deb593818e..d09f6925eef 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -465,7 +465,10 @@ fn descr_set_wrapper(
 fn init_wrapper(obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
     let res = vm.call_special_method(&obj, identifier!(vm, __init__), args)?;
     if !vm.is_none(&res) {
-        return Err(vm.new_type_error("__init__ must return None"));
+        return Err(vm.new_type_error(format!(
+            "__init__ should return None, not '{:.200}'",
+            res.class().name()
+        )));
     }
     Ok(())
 }
@@ -943,7 +946,6 @@ pub trait Initializer: PyPayload {
 
     #[inline]
     #[pyslot]
-    #[pymethod(name = "__init__")]
     fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
         #[cfg(debug_assertions)]
         let class_name_for_debug = zelf.class().name().to_string();
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index d994ff60210..dd4631bc767 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -94,6 +94,8 @@ pub struct TypeZoo {
     pub generic_alias_type: &'static Py<PyType>,
     pub union_type: &'static Py<PyType>,
     pub member_descriptor_type: &'static Py<PyType>,
+    pub wrapper_descriptor_type: &'static Py<PyType>,
+    pub method_wrapper_type: &'static Py<PyType>,
 
     // RustPython-original types
     pub method_def: &'static Py<PyType>,
@@ -187,6 +189,8 @@ impl TypeZoo {
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
             member_descriptor_type: descriptor::PyMemberDescriptor::init_builtin_type(),
+            wrapper_descriptor_type: descriptor::PySlotWrapper::init_builtin_type(),
+            method_wrapper_type: descriptor::PyMethodWrapper::init_builtin_type(),
 
             method_def: crate::function::HeapMethodDef::init_builtin_type(),
         }

From c4e77287d1be4757c3c67551199d16dc52599997 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 18:56:47 +0900
Subject: [PATCH 047/418] __hash__ to slot_wrapper (#6480)

---
 crates/vm/src/builtins/descriptor.rs | 51 ++++++++++++++++++++++++----
 crates/vm/src/class.rs               | 24 +++++++++++--
 crates/vm/src/types/slot.rs          |  6 +---
 3 files changed, 67 insertions(+), 14 deletions(-)

diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index 2ccd1dcc0e9..5cd54bb753d 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -6,7 +6,8 @@ use crate::{
     common::hash::PyHash,
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
     types::{
-        Callable, Comparable, GetDescriptor, Hashable, InitFunc, PyComparisonOp, Representable,
+        Callable, Comparable, GetDescriptor, HashFunc, Hashable, InitFunc, PyComparisonOp,
+        Representable,
     },
 };
 use rustpython_common::lock::PyRwLock;
@@ -391,6 +392,44 @@ pub fn init(ctx: &Context) {
 
 // PySlotWrapper - wrapper_descriptor
 
+/// Type-erased slot function - mirrors CPython's void* d_wrapped
+/// Each variant knows how to call the wrapped function with proper types
+#[derive(Clone, Copy)]
+pub enum SlotFunc {
+    Init(InitFunc),
+    Hash(HashFunc),
+}
+
+impl std::fmt::Debug for SlotFunc {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
+            SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
+        }
+    }
+}
+
+impl SlotFunc {
+    /// Call the wrapped slot function with proper type handling
+    pub fn call(&self, obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        match self {
+            SlotFunc::Init(func) => {
+                func(obj, args, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::Hash(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__hash__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                let hash = func(&obj, vm)?;
+                Ok(vm.ctx.new_int(hash).into())
+            }
+        }
+    }
+}
+
 /// wrapper_descriptor: wraps a slot function as a Python method
 // = PyWrapperDescrObject
 #[pyclass(name = "wrapper_descriptor", module = false)]
@@ -398,7 +437,7 @@ pub fn init(ctx: &Context) {
 pub struct PySlotWrapper {
     pub typ: &'static Py<PyType>,
     pub name: &'static PyStrInterned,
-    pub wrapped: InitFunc,
+    pub wrapped: SlotFunc,
     pub doc: Option<&'static str>,
 }
 
@@ -430,7 +469,7 @@ impl Callable for PySlotWrapper {
     type Args = FuncArgs;
 
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        // list.__init__(l, [1,2,3]) form
+        // list.__init__(l, [1,2,3]) form - first arg is self
         let (obj, rest): (PyObjectRef, FuncArgs) = args.bind(vm)?;
 
         if !obj.fast_isinstance(zelf.typ) {
@@ -442,8 +481,7 @@ impl Callable for PySlotWrapper {
             )));
         }
 
-        (zelf.wrapped)(obj, rest, vm)?;
-        Ok(vm.ctx.none())
+        zelf.wrapped.call(obj, rest, vm)
     }
 }
 
@@ -506,8 +544,7 @@ impl Callable for PyMethodWrapper {
     type Args = FuncArgs;
 
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        (zelf.wrapper.wrapped)(zelf.obj.clone(), args, vm)?;
-        Ok(vm.ctx.none())
+        zelf.wrapper.wrapped.call(zelf.obj.clone(), args, vm)
     }
 }
 
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 92e9f6a15be..f258281712f 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -2,7 +2,10 @@
 
 use crate::{
     PyPayload,
-    builtins::{PyBaseObject, PyType, PyTypeRef, descriptor::PySlotWrapper},
+    builtins::{
+        PyBaseObject, PyType, PyTypeRef,
+        descriptor::{PySlotWrapper, SlotFunc},
+    },
     function::PyMethodDef,
     object::Py,
     types::{PyTypeFlags, PyTypeSlots, hash_not_implemented},
@@ -143,13 +146,30 @@ pub trait PyClassImpl: PyClassDef {
                 let wrapper = PySlotWrapper {
                     typ: class,
                     name: ctx.intern_str("__init__"),
-                    wrapped: init_func,
+                    wrapped: SlotFunc::Init(init_func),
                     doc: Some("Initialize self. See help(type(self)) for accurate signature."),
                 };
                 class.set_attr(init_name, wrapper.into_ref(ctx).into());
             }
         }
 
+        // Add __hash__ slot wrapper if slot exists and not already in dict
+        // Note: hash_not_implemented is handled separately (sets __hash__ = None)
+        if let Some(hash_func) = class.slots.hash.load()
+            && hash_func as usize != hash_not_implemented as usize
+        {
+            let hash_name = identifier!(ctx, __hash__);
+            if !class.attributes.read().contains_key(hash_name) {
+                let wrapper = PySlotWrapper {
+                    typ: class,
+                    name: ctx.intern_str("__hash__"),
+                    wrapped: SlotFunc::Hash(hash_func),
+                    doc: Some("Return hash(self)."),
+                };
+                class.set_attr(hash_name, wrapper.into_ref(ctx).into());
+            }
+        }
+
         if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
             class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
         }
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index d09f6925eef..2954d08abf0 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -1098,11 +1098,7 @@ pub trait Hashable: PyPayload {
         Self::hash(zelf, vm)
     }
 
-    #[inline]
-    #[pymethod]
-    fn __hash__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyHash> {
-        Self::slot_hash(&zelf, vm)
-    }
+    // __hash__ is now exposed via SlotFunc::Hash wrapper in extend_class()
 
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>;
 }

From 9d1477699ceecc8c57783ca04577f9e9723b5d08 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 24 Dec 2025 10:57:00 +0100
Subject: [PATCH 048/418] Update `test_threading_local.py` from 3.13.11 (#6482)

* Update `test_threading_local.py` from 3.13.11

* Mark failing test
---
 Lib/test/test_threading_local.py | 62 ++++++++++++++++++++++----------
 1 file changed, 43 insertions(+), 19 deletions(-)

diff --git a/Lib/test/test_threading_local.py b/Lib/test/test_threading_local.py
index 3443e3875d0..99052de4c7f 100644
--- a/Lib/test/test_threading_local.py
+++ b/Lib/test/test_threading_local.py
@@ -3,8 +3,8 @@
 from doctest import DocTestSuite
 from test import support
 from test.support import threading_helper
+from test.support.import_helper import import_module
 import weakref
-import gc
 
 # Modules under test
 import _thread
@@ -12,6 +12,9 @@
 import _threading_local
 
 
+threading_helper.requires_working_threading(module=True)
+
+
 class Weak(object):
     pass
 
@@ -23,7 +26,7 @@ def target(local, weaklist):
 
 class BaseLocalTest:
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_local_refs(self):
         self._local_refs(20)
         self._local_refs(50)
@@ -182,8 +185,7 @@ class LocalSubclass(self._local):
             """To test that subclasses behave properly."""
         self._test_dict_attribute(LocalSubclass)
 
-    # TODO: RUSTPYTHON, cycle detection/collection
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; cycle detection/collection
     def test_cycle_collection(self):
         class X:
             pass
@@ -197,35 +199,57 @@ class X:
         self.assertIsNone(wr())
 
 
+    def test_threading_local_clear_race(self):
+        # See https://github.com/python/cpython/issues/100892
+
+        _testcapi = import_module('_testcapi')
+        _testcapi.call_in_temporary_c_thread(lambda: None, False)
+
+        for _ in range(1000):
+            _ = threading.local()
+
+        _testcapi.join_temporary_c_thread()
+
+    @support.cpython_only
+    def test_error(self):
+        class Loop(self._local):
+            attr = 1
+
+        # Trick the "if name == '__dict__':" test of __setattr__()
+        # to always be true
+        class NameCompareTrue:
+            def __eq__(self, other):
+                return True
+
+        loop = Loop()
+        with self.assertRaisesRegex(AttributeError, 'Loop.*read-only'):
+            loop.__setattr__(NameCompareTrue(), 2)
+
+
 class ThreadLocalTest(unittest.TestCase, BaseLocalTest):
     _local = _thread._local
 
-    # TODO: RUSTPYTHON, __new__ vs __init__ cooperation
-    @unittest.expectedFailure
-    def test_arguments():
-        super().test_arguments()
-
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: TypeError not raised by _local
+    def test_arguments(self):
+        return super().test_arguments()
 
 class PyThreadingLocalTest(unittest.TestCase, BaseLocalTest):
     _local = _threading_local.local
 
 
-def test_main():
-    suite = unittest.TestSuite()
-    suite.addTest(DocTestSuite('_threading_local'))
-    suite.addTest(unittest.makeSuite(ThreadLocalTest))
-    suite.addTest(unittest.makeSuite(PyThreadingLocalTest))
+def load_tests(loader, tests, pattern):
+    tests.addTest(DocTestSuite('_threading_local'))
 
     local_orig = _threading_local.local
     def setUp(test):
         _threading_local.local = _thread._local
     def tearDown(test):
         _threading_local.local = local_orig
-    suite.addTest(DocTestSuite('_threading_local',
-                               setUp=setUp, tearDown=tearDown)
-                  )
+    tests.addTests(DocTestSuite('_threading_local',
+                                setUp=setUp, tearDown=tearDown)
+                   )
+    return tests
 
-    support.run_unittest(suite)
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()

From 7c3bc5ed8de973236d64e084dcc102f53fddd272 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 24 Dec 2025 11:45:48 +0100
Subject: [PATCH 049/418] Update `test_http_cookies.py` from 3.13.11 (#6481)

* Update `test_http_cookies.py` from 3.13.11

* Mark failing test

* Update `http/cookies.py` from 3.13.11

* Unmark passing test

* Lower amount
---
 Lib/http/cookies.py           |  42 +++++---------
 Lib/test/test_http_cookies.py | 102 +++++++++++++++++++++++++++++++---
 2 files changed, 108 insertions(+), 36 deletions(-)

diff --git a/Lib/http/cookies.py b/Lib/http/cookies.py
index 35ac2dc6ae2..57791c6ab08 100644
--- a/Lib/http/cookies.py
+++ b/Lib/http/cookies.py
@@ -184,8 +184,13 @@ def _quote(str):
         return '"' + str.translate(_Translator) + '"'
 
 
-_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
-_QuotePatt = re.compile(r"[\\].")
+_unquote_sub = re.compile(r'\\(?:([0-3][0-7][0-7])|(.))').sub
+
+def _unquote_replace(m):
+    if m[1]:
+        return chr(int(m[1], 8))
+    else:
+        return m[2]
 
 def _unquote(str):
     # If there aren't any doublequotes,
@@ -205,36 +210,13 @@ def _unquote(str):
     #    \012 --> \n
     #    \"   --> "
     #
-    i = 0
-    n = len(str)
-    res = []
-    while 0 <= i < n:
-        o_match = _OctalPatt.search(str, i)
-        q_match = _QuotePatt.search(str, i)
-        if not o_match and not q_match:              # Neither matched
-            res.append(str[i:])
-            break
-        # else:
-        j = k = -1
-        if o_match:
-            j = o_match.start(0)
-        if q_match:
-            k = q_match.start(0)
-        if q_match and (not o_match or k < j):     # QuotePatt matched
-            res.append(str[i:k])
-            res.append(str[k+1])
-            i = k + 2
-        else:                                      # OctalPatt matched
-            res.append(str[i:j])
-            res.append(chr(int(str[j+1:j+4], 8)))
-            i = j + 4
-    return _nulljoin(res)
+    return _unquote_sub(_unquote_replace, str)
 
 # The _getdate() routine is used to set the expiration time in the cookie's HTTP
 # header.  By default, _getdate() returns the current time in the appropriate
 # "expires" format for a Set-Cookie header.  The one optional argument is an
 # offset from now, in seconds.  For example, an offset of -3600 means "one hour
-# ago".  The offset may be a floating point number.
+# ago".  The offset may be a floating-point number.
 #
 
 _weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
@@ -442,9 +424,11 @@ def OutputString(self, attrs=None):
     (                              # Optional group: there may not be a value.
     \s*=\s*                          # Equal Sign
     (?P<val>                         # Start of group 'val'
-    "(?:[^\\"]|\\.)*"                  # Any doublequoted string
+    "(?:[^\\"]|\\.)*"                  # Any double-quoted string
     |                                  # or
-    \w{3},\s[\w\d\s-]{9,11}\s[\d:]{8}\sGMT  # Special case for "expires" attr
+    # Special case for "expires" attr
+    (\w{3,6}day|\w{3}),\s              # Day of the week or abbreviated day
+    [\w\d\s-]{9,11}\s[\d:]{8}\sGMT     # Date and time in specific format
     |                                  # or
     [""" + _LegalValueChars + r"""]*      # Any word or empty string
     )                                # End of group 'val'
diff --git a/Lib/test/test_http_cookies.py b/Lib/test/test_http_cookies.py
index 6072c7e15e9..3e0b4d1d5ca 100644
--- a/Lib/test/test_http_cookies.py
+++ b/Lib/test/test_http_cookies.py
@@ -1,13 +1,15 @@
 # Simple test suite for http/cookies.py
 
 import copy
-from test.support import run_unittest, run_doctest
 import unittest
+import doctest
 from http import cookies
 import pickle
+from test import support
+from test.support.testcase import ExtraAssertions
 
 
-class CookieTests(unittest.TestCase):
+class CookieTests(unittest.TestCase, ExtraAssertions):
 
     def test_basic(self):
         cases = [
@@ -58,6 +60,90 @@ def test_basic(self):
             for k, v in sorted(case['dict'].items()):
                 self.assertEqual(C[k].value, v)
 
+    def test_obsolete_rfc850_date_format(self):
+        # Test cases with different days and dates in obsolete RFC 850 format
+        test_cases = [
+            # from RFC 850, change EST to GMT
+            # https://datatracker.ietf.org/doc/html/rfc850#section-2
+            {
+                'data': 'key=value; expires=Saturday, 01-Jan-83 00:00:00 GMT',
+                'output': 'Saturday, 01-Jan-83 00:00:00 GMT'
+            },
+            {
+                'data': 'key=value; expires=Friday, 19-Nov-82 16:59:30 GMT',
+                'output': 'Friday, 19-Nov-82 16:59:30 GMT'
+            },
+            # from RFC 9110
+            # https://www.rfc-editor.org/rfc/rfc9110.html#section-5.6.7-6
+            {
+                'data': 'key=value; expires=Sunday, 06-Nov-94 08:49:37 GMT',
+                'output': 'Sunday, 06-Nov-94 08:49:37 GMT'
+            },
+            # other test cases
+            {
+                'data': 'key=value; expires=Wednesday, 09-Nov-94 08:49:37 GMT',
+                'output': 'Wednesday, 09-Nov-94 08:49:37 GMT'
+            },
+            {
+                'data': 'key=value; expires=Friday, 11-Nov-94 08:49:37 GMT',
+                'output': 'Friday, 11-Nov-94 08:49:37 GMT'
+            },
+            {
+                'data': 'key=value; expires=Monday, 14-Nov-94 08:49:37 GMT',
+                'output': 'Monday, 14-Nov-94 08:49:37 GMT'
+            },
+        ]
+
+        for case in test_cases:
+            with self.subTest(data=case['data']):
+                C = cookies.SimpleCookie()
+                C.load(case['data'])
+
+                # Extract the cookie name from the data string
+                cookie_name = case['data'].split('=')[0]
+
+                # Check if the cookie is loaded correctly
+                self.assertIn(cookie_name, C)
+                self.assertEqual(C[cookie_name].get('expires'), case['output'])
+
+    def test_unquote(self):
+        cases = [
+            (r'a="b=\""', 'b="'),
+            (r'a="b=\\"', 'b=\\'),
+            (r'a="b=\="', 'b=='),
+            (r'a="b=\n"', 'b=n'),
+            (r'a="b=\042"', 'b="'),
+            (r'a="b=\134"', 'b=\\'),
+            (r'a="b=\377"', 'b=\xff'),
+            (r'a="b=\400"', 'b=400'),
+            (r'a="b=\42"', 'b=42'),
+            (r'a="b=\\042"', 'b=\\042'),
+            (r'a="b=\\134"', 'b=\\134'),
+            (r'a="b=\\\""', 'b=\\"'),
+            (r'a="b=\\\042"', 'b=\\"'),
+            (r'a="b=\134\""', 'b=\\"'),
+            (r'a="b=\134\042"', 'b=\\"'),
+        ]
+        for encoded, decoded in cases:
+            with self.subTest(encoded):
+                C = cookies.SimpleCookie()
+                C.load(encoded)
+                self.assertEqual(C['a'].value, decoded)
+
+    @support.requires_resource('cpu')
+    def test_unquote_large(self):
+        #n = 10**6
+        n = 10**4 # XXX: RUSTPYTHON; This takes more than 10 minutes to run. lower to 4
+        for encoded in r'\\', r'\134':
+            with self.subTest(encoded):
+                data = 'a="b=' + encoded*n + ';"'
+                C = cookies.SimpleCookie()
+                C.load(data)
+                value = C['a'].value
+                self.assertEqual(value[:3], 'b=\\')
+                self.assertEqual(value[-2:], '\\;')
+                self.assertEqual(len(value), n + 3)
+
     def test_load(self):
         C = cookies.SimpleCookie()
         C.load('Customer="WILE_E_COYOTE"; Version=1; Path=/acme')
@@ -96,7 +182,7 @@ def test_special_attrs(self):
         C = cookies.SimpleCookie('Customer="WILE_E_COYOTE"')
         C['Customer']['expires'] = 0
         # can't test exact output, it always depends on current date/time
-        self.assertTrue(C.output().endswith('GMT'))
+        self.assertEndsWith(C.output(), 'GMT')
 
         # loading 'expires'
         C = cookies.SimpleCookie()
@@ -479,9 +565,11 @@ def test_repr(self):
                 r'Set-Cookie: key=coded_val; '
                 r'expires=\w+, \d+ \w+ \d+ \d+:\d+:\d+ \w+')
 
-def test_main():
-    run_unittest(CookieTests, MorselTests)
-    run_doctest(cookies)
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(cookies))
+    return tests
+
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()

From a4e60f569e6c1c9c5ff1c89d76e786f2ac08a827 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Wed, 24 Dec 2025 17:48:41 +0900
Subject: [PATCH 050/418] repr

---
 crates/vm/src/builtins/descriptor.rs | 14 ++++++++++++--
 crates/vm/src/class.rs               | 14 ++++++++++++++
 crates/vm/src/types/slot.rs          |  6 ------
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index 5cd54bb753d..c251ac45ee3 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -7,7 +7,7 @@ use crate::{
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
     types::{
         Callable, Comparable, GetDescriptor, HashFunc, Hashable, InitFunc, PyComparisonOp,
-        Representable,
+        Representable, StringifyFunc,
     },
 };
 use rustpython_common::lock::PyRwLock;
@@ -398,6 +398,7 @@ pub fn init(ctx: &Context) {
 pub enum SlotFunc {
     Init(InitFunc),
     Hash(HashFunc),
+    Repr(StringifyFunc),
 }
 
 impl std::fmt::Debug for SlotFunc {
@@ -405,6 +406,7 @@ impl std::fmt::Debug for SlotFunc {
         match self {
             SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
             SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
+            SlotFunc::Repr(_) => write!(f, "SlotFunc::Repr(...)"),
         }
     }
 }
@@ -426,6 +428,15 @@ impl SlotFunc {
                 let hash = func(&obj, vm)?;
                 Ok(vm.ctx.new_int(hash).into())
             }
+            SlotFunc::Repr(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__repr__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                let s = func(&obj, vm)?;
+                Ok(s.into())
+            }
         }
     }
 }
@@ -456,7 +467,6 @@ impl GetDescriptor for PySlotWrapper {
     ) -> PyResult {
         match obj {
             None => Ok(zelf),
-            Some(obj) if vm.is_none(&obj) => Ok(zelf),
             Some(obj) => {
                 let zelf = zelf.downcast::<Self>().unwrap();
                 Ok(PyMethodWrapper { wrapper: zelf, obj }.into_pyobject(vm))
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index f258281712f..236967dd36e 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -174,6 +174,20 @@ pub trait PyClassImpl: PyClassDef {
             class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
         }
 
+        // Add __repr__ slot wrapper if slot exists and not already in dict
+        if let Some(repr_func) = class.slots.repr.load() {
+            let repr_name = identifier!(ctx, __repr__);
+            if !class.attributes.read().contains_key(repr_name) {
+                let wrapper = PySlotWrapper {
+                    typ: class,
+                    name: ctx.intern_str("__repr__"),
+                    wrapped: SlotFunc::Repr(repr_func),
+                    doc: Some("Return repr(self)."),
+                };
+                class.set_attr(repr_name, wrapper.into_ref(ctx).into());
+            }
+        }
+
         class.extend_methods(class.slots.methods, ctx);
     }
 
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 2954d08abf0..6e98da173a4 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -1114,12 +1114,6 @@ pub trait Representable: PyPayload {
         Self::repr(zelf, vm)
     }
 
-    #[inline]
-    #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
-        Self::slot_repr(&zelf, vm)
-    }
-
     #[inline]
     fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
         let repr = Self::repr_str(zelf, vm)?;

From c2a739319149052f3bc03f873f2e9840571ff541 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Wed, 24 Dec 2025 21:36:42 +0900
Subject: [PATCH 051/418] uniform __str__

---
 crates/stdlib/src/ssl/error.rs      |   6 +-
 crates/vm/src/builtins/str.rs       |  16 ++--
 crates/vm/src/builtins/weakproxy.rs |   4 +-
 crates/vm/src/exception_group.rs    |   6 +-
 crates/vm/src/exceptions.rs         | 138 +++++++++++++++-------------
 crates/vm/src/stdlib/io.rs          |   6 +-
 crates/vm/src/stdlib/winreg.rs      |  16 ++--
 7 files changed, 104 insertions(+), 88 deletions(-)

diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
index 879275228ec..d77910f6aa1 100644
--- a/crates/stdlib/src/ssl/error.rs
+++ b/crates/stdlib/src/ssl/error.rs
@@ -5,8 +5,8 @@ pub(crate) use ssl_error::*;
 #[pymodule(sub)]
 pub(crate) mod ssl_error {
     use crate::vm::{
-        PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyOSError, PyStrRef},
+        Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseException, PyOSError, PyStrRef},
         types::{Constructor, Initializer},
     };
 
@@ -42,7 +42,7 @@ pub(crate) mod ssl_error {
     impl PySSLError {
         // Returns strerror attribute if available, otherwise str(args)
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        fn __str__(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             use crate::vm::AsObject;
             // Try to get strerror attribute first (OSError compatibility)
             if let Ok(strerror) = exc.as_object().get_attr("strerror", vm)
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 8084c4d053e..95b41e6d55c 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -529,7 +529,6 @@ impl Py<PyStr> {
 #[pyclass(
     flags(BASETYPE, _MATCH_SELF),
     with(
-        PyRef,
         AsMapping,
         AsNumber,
         AsSequence,
@@ -1448,15 +1447,16 @@ impl PyStr {
     fn __getnewargs__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
         (zelf.as_str(),).to_pyobject(vm)
     }
-}
 
-#[pyclass]
-impl PyRef<PyStr> {
     #[pymethod]
-    fn __str__(self, vm: &VirtualMachine) -> PyRefExact<PyStr> {
-        self.into_exact_or(&vm.ctx, |zelf| {
-            PyStr::from(zelf.data.clone()).into_exact_ref(&vm.ctx)
-        })
+    fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        if zelf.class().is(vm.ctx.types.str_type) {
+            // Already exact str, just return a reference
+            Ok(zelf.to_owned())
+        } else {
+            // Subclass, create a new exact str
+            Ok(PyStr::from(zelf.data.clone()).into_ref(&vm.ctx))
+        }
     }
 }
 
diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
index a9221ec876f..6e0e8308dbc 100644
--- a/crates/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -79,8 +79,8 @@ impl PyWeakProxy {
     }
 
     #[pymethod]
-    fn __str__(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        self.try_upgrade(vm)?.str(vm)
+    fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        zelf.try_upgrade(vm)?.str(vm)
     }
 
     fn len(&self, vm: &VirtualMachine) -> PyResult<usize> {
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index e19dbceb8da..645a3e779ff 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -182,7 +182,7 @@ pub(super) mod types {
         }
 
         #[pymethod]
-        fn __str__(zelf: PyRef<PyBaseException>, vm: &VirtualMachine) -> PyResult<String> {
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             let message = zelf
                 .get_arg(0)
                 .map(|m| m.str(vm))
@@ -196,10 +196,10 @@ pub(super) mod types {
                 .unwrap_or(0);
 
             let suffix = if num_excs == 1 { "" } else { "s" };
-            Ok(format!(
+            Ok(vm.ctx.new_str(format!(
                 "{} ({} sub-exception{})",
                 message, num_excs, suffix
-            ))
+            )))
         }
 
         #[pymethod]
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 2c36aa13bd5..3a932a5df54 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -560,7 +560,7 @@ impl PyBaseException {
 }
 
 #[pyclass(
-    with(PyRef, Constructor, Initializer, Representable),
+    with(Py, PyRef, Constructor, Initializer, Representable),
     flags(BASETYPE, HAS_DICT)
 )]
 impl PyBaseException {
@@ -633,15 +633,18 @@ impl PyBaseException {
     fn set_suppress_context(&self, suppress_context: bool) {
         self.suppress_context.store(suppress_context);
     }
+}
 
+#[pyclass]
+impl Py<PyBaseException> {
     #[pymethod]
-    pub(super) fn __str__(&self, vm: &VirtualMachine) -> PyStrRef {
+    pub(super) fn __str__(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         let str_args = vm.exception_args_as_string(self.args(), true);
-        match str_args.into_iter().exactly_one() {
+        Ok(match str_args.into_iter().exactly_one() {
             Err(i) if i.len() == 0 => vm.ctx.empty_str.to_owned(),
             Ok(s) => s,
             Err(i) => PyStr::from(format!("({})", i.format(", "))).into_ref(&vm.ctx),
-        }
+        })
     }
 }
 
@@ -1527,16 +1530,16 @@ pub(super) mod types {
     #[pyexception]
     impl PyKeyError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyStrRef {
-            let args = exc.args();
-            if args.len() == 1 {
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let args = zelf.args();
+            Ok(if args.len() == 1 {
                 vm.exception_args_as_string(args, false)
                     .into_iter()
                     .exactly_one()
                     .unwrap()
             } else {
-                exc.__str__(vm)
-            }
+                zelf.__str__(vm)?
+            })
         }
     }
 
@@ -1731,8 +1734,8 @@ pub(super) mod types {
     #[pyexception(with(Constructor, Initializer))]
     impl PyOSError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            let obj = exc.as_object().to_owned();
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let obj = zelf.as_object();
 
             // Get OSError fields directly
             let errno_field = obj.get_attr("errno", vm).ok().filter(|v| !vm.is_none(v));
@@ -1819,7 +1822,7 @@ pub(super) mod types {
             }
 
             // fallback to BaseException.__str__
-            Ok(exc.__str__(vm))
+            zelf.__str__(vm)
         }
 
         #[pymethod]
@@ -2026,7 +2029,7 @@ pub(super) mod types {
     #[pyexception(with(Initializer))]
     impl PySyntaxError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyStrRef {
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             fn basename(filename: &str) -> &str {
                 let splitted = if cfg!(windows) {
                     filename.rsplit(&['/', '\\']).next()
@@ -2036,16 +2039,16 @@ pub(super) mod types {
                 splitted.unwrap_or(filename)
             }
 
-            let maybe_lineno = exc.as_object().get_attr("lineno", vm).ok().map(|obj| {
+            let maybe_lineno = zelf.as_object().get_attr("lineno", vm).ok().map(|obj| {
                 obj.str(vm)
                     .unwrap_or_else(|_| vm.ctx.new_str("<lineno str() failed>"))
             });
-            let maybe_filename = exc.as_object().get_attr("filename", vm).ok().map(|obj| {
+            let maybe_filename = zelf.as_object().get_attr("filename", vm).ok().map(|obj| {
                 obj.str(vm)
                     .unwrap_or_else(|_| vm.ctx.new_str("<filename str() failed>"))
             });
 
-            let args = exc.args();
+            let args = zelf.args();
 
             let msg = if args.len() == 1 {
                 vm.exception_args_as_string(args, false)
@@ -2053,7 +2056,7 @@ pub(super) mod types {
                     .exactly_one()
                     .unwrap()
             } else {
-                return exc.__str__(vm);
+                return zelf.__str__(vm);
             };
 
             let msg_with_location_info: String = match (maybe_lineno, maybe_filename) {
@@ -2069,7 +2072,7 @@ pub(super) mod types {
                 (None, None) => msg.to_string(),
             };
 
-            vm.ctx.new_str(msg_with_location_info)
+            Ok(vm.ctx.new_str(msg_with_location_info))
         }
     }
 
@@ -2178,29 +2181,32 @@ pub(super) mod types {
     #[pyexception(with(Initializer))]
     impl PyUnicodeDecodeError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
             };
             let object: ArgBytesLike = object.try_into_value(vm)?;
-            let encoding: PyStrRef = exc
+            let encoding: PyStrRef = zelf
                 .as_object()
                 .get_attr("encoding", vm)?
                 .try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.len() && end <= object.len() && end == start + 1 {
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(if start < object.len() && end <= object.len() && end == start + 1 {
                 let b = object.borrow_buf()[start];
-                Ok(format!(
+                format!(
                     "'{encoding}' codec can't decode byte {b:#02x} in position {start}: {reason}"
-                ))
+                )
             } else {
-                Ok(format!(
+                format!(
                     "'{encoding}' codec can't decode bytes in position {start}-{}: {reason}",
                     end - 1,
-                ))
-            }
+                )
+            }))
         }
     }
 
@@ -2232,30 +2238,33 @@ pub(super) mod types {
     #[pyexception(with(Initializer))]
     impl PyUnicodeEncodeError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
             };
             let object: PyStrRef = object.try_into_value(vm)?;
-            let encoding: PyStrRef = exc
+            let encoding: PyStrRef = zelf
                 .as_object()
                 .get_attr("encoding", vm)?
                 .try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.char_len() && end <= object.char_len() && end == start + 1 {
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(if start < object.char_len() && end <= object.char_len() && end == start + 1 {
                 let ch = object.as_wtf8().code_points().nth(start).unwrap();
-                Ok(format!(
+                format!(
                     "'{encoding}' codec can't encode character '{}' in position {start}: {reason}",
                     UnicodeEscapeCodepoint(ch)
-                ))
+                )
             } else {
-                Ok(format!(
+                format!(
                     "'{encoding}' codec can't encode characters in position {start}-{}: {reason}",
                     end - 1,
-                ))
-            }
+                )
+            }))
         }
     }
 
@@ -2286,26 +2295,31 @@ pub(super) mod types {
     #[pyexception(with(Initializer))]
     impl PyUnicodeTranslateError {
         #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
             };
             let object: PyStrRef = object.try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.char_len() && end <= object.char_len() && end == start + 1 {
-                let ch = object.as_wtf8().code_points().nth(start).unwrap();
-                Ok(format!(
-                    "can't translate character '{}' in position {start}: {reason}",
-                    UnicodeEscapeCodepoint(ch)
-                ))
-            } else {
-                Ok(format!(
-                    "can't translate characters in position {start}-{}: {reason}",
-                    end - 1,
-                ))
-            }
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(
+                if start < object.char_len() && end <= object.char_len() && end == start + 1 {
+                    let ch = object.as_wtf8().code_points().nth(start).unwrap();
+                    format!(
+                        "can't translate character '{}' in position {start}: {reason}",
+                        UnicodeEscapeCodepoint(ch)
+                    )
+                } else {
+                    format!(
+                        "can't translate characters in position {start}-{}: {reason}",
+                        end - 1,
+                    )
+                },
+            ))
         }
     }
 
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 2c3c02ec65c..9402660a86e 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -1466,7 +1466,11 @@ mod _io {
             let zelf: PyRef<Self> = zelf.try_into_value(vm)?;
             let (raw, BufferSize { buffer_size }): (PyObjectRef, _) =
                 args.bind(vm).map_err(|e| {
-                    let msg = format!("{}() {}", Self::CLASS_NAME, *e.__str__(vm));
+                    let str_repr = e
+                        .__str__(vm)
+                        .map(|s| s.as_str().to_owned())
+                        .unwrap_or_else(|_| "<error getting exception str>".to_owned());
+                    let msg = format!("{}() {}", Self::CLASS_NAME, str_repr);
                     vm.new_exception_msg(e.class().to_owned(), msg)
                 })?;
             zelf.init(raw, BufferSize { buffer_size }, vm)
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
index a7619025866..b5e568fce6d 100644
--- a/crates/vm/src/stdlib/winreg.rs
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -9,7 +9,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 
 #[pymodule]
 mod winreg {
-    use crate::builtins::{PyInt, PyTuple, PyTypeRef};
+    use crate::builtins::{PyInt, PyStr, PyTuple, PyTypeRef};
     use crate::common::hash::PyHash;
     use crate::common::windows::ToWideString;
     use crate::convert::TryFromObject;
@@ -233,8 +233,8 @@ mod winreg {
         }
 
         #[pymethod]
-        fn __str__(&self) -> String {
-            format!("<PyHkey:{:p}>", self.hkey.load())
+        fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+            Ok(vm.ctx.new_str(format!("<PyHkey:{:p}>", zelf.hkey.load())))
         }
     }
 
@@ -1029,7 +1029,7 @@ mod winreg {
                     return Ok(Some(vec![0u8, 0u8]));
                 }
                 let s = value
-                    .downcast::<crate::builtins::PyStr>()
+                    .downcast::<PyStr>()
                     .map_err(|_| vm.new_type_error("value must be a string".to_string()))?;
                 let wide = s.as_str().to_wide_with_nul();
                 // Convert Vec<u16> to Vec<u8>
@@ -1047,11 +1047,9 @@ mod winreg {
 
                 let mut bytes: Vec<u8> = Vec::new();
                 for item in list.borrow_vec().iter() {
-                    let s = item
-                        .downcast_ref::<crate::builtins::PyStr>()
-                        .ok_or_else(|| {
-                            vm.new_type_error("list items must be strings".to_string())
-                        })?;
+                    let s = item.downcast_ref::<PyStr>().ok_or_else(|| {
+                        vm.new_type_error("list items must be strings".to_string())
+                    })?;
                     let wide = s.as_str().to_wide_with_nul();
                     bytes.extend(wide.iter().flat_map(|&c| c.to_le_bytes()));
                 }

From cbde5ce3218066e89a61f42dd429ab8c2fe77321 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 24 Dec 2025 23:35:35 +0900
Subject: [PATCH 052/418] iter with slot-wrapper (#6488)

---
 crates/vm/src/builtins/descriptor.rs | 25 +++++++-
 crates/vm/src/class.rs               | 86 ++++++++++++++--------------
 crates/vm/src/types/slot.rs          | 17 ++----
 3 files changed, 69 insertions(+), 59 deletions(-)

diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index c251ac45ee3..fcf40d0082d 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -4,10 +4,11 @@ use crate::{
     builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
     class::PyClassImpl,
     common::hash::PyHash,
+    convert::ToPyResult,
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
     types::{
-        Callable, Comparable, GetDescriptor, HashFunc, Hashable, InitFunc, PyComparisonOp,
-        Representable, StringifyFunc,
+        Callable, Comparable, GetDescriptor, HashFunc, Hashable, InitFunc, IterFunc, IterNextFunc,
+        PyComparisonOp, Representable, StringifyFunc,
     },
 };
 use rustpython_common::lock::PyRwLock;
@@ -399,6 +400,8 @@ pub enum SlotFunc {
     Init(InitFunc),
     Hash(HashFunc),
     Repr(StringifyFunc),
+    Iter(IterFunc),
+    IterNext(IterNextFunc),
 }
 
 impl std::fmt::Debug for SlotFunc {
@@ -407,6 +410,8 @@ impl std::fmt::Debug for SlotFunc {
             SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
             SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
             SlotFunc::Repr(_) => write!(f, "SlotFunc::Repr(...)"),
+            SlotFunc::Iter(_) => write!(f, "SlotFunc::Iter(...)"),
+            SlotFunc::IterNext(_) => write!(f, "SlotFunc::IterNext(...)"),
         }
     }
 }
@@ -437,6 +442,22 @@ impl SlotFunc {
                 let s = func(&obj, vm)?;
                 Ok(s.into())
             }
+            SlotFunc::Iter(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__iter__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(obj, vm)
+            }
+            SlotFunc::IterNext(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__next__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(&obj, vm).to_pyresult(vm)
+            }
         }
     }
 }
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 236967dd36e..1addf00497d 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -139,52 +139,50 @@ pub trait PyClassImpl: PyClassDef {
             }
         }
 
-        // Add __init__ slot wrapper if slot exists and not already in dict
-        if let Some(init_func) = class.slots.init.load() {
-            let init_name = identifier!(ctx, __init__);
-            if !class.attributes.read().contains_key(init_name) {
-                let wrapper = PySlotWrapper {
-                    typ: class,
-                    name: ctx.intern_str("__init__"),
-                    wrapped: SlotFunc::Init(init_func),
-                    doc: Some("Initialize self. See help(type(self)) for accurate signature."),
-                };
-                class.set_attr(init_name, wrapper.into_ref(ctx).into());
-            }
-        }
-
-        // Add __hash__ slot wrapper if slot exists and not already in dict
-        // Note: hash_not_implemented is handled separately (sets __hash__ = None)
-        if let Some(hash_func) = class.slots.hash.load()
-            && hash_func as usize != hash_not_implemented as usize
-        {
-            let hash_name = identifier!(ctx, __hash__);
-            if !class.attributes.read().contains_key(hash_name) {
-                let wrapper = PySlotWrapper {
-                    typ: class,
-                    name: ctx.intern_str("__hash__"),
-                    wrapped: SlotFunc::Hash(hash_func),
-                    doc: Some("Return hash(self)."),
-                };
-                class.set_attr(hash_name, wrapper.into_ref(ctx).into());
-            }
-        }
-
-        if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
-            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
+        // Add slot wrappers for slots that exist and are not already in dict
+        // This mirrors CPython's add_operators() in typeobject.c
+        macro_rules! add_slot_wrapper {
+            ($slot:ident, $name:ident, $variant:ident, $doc:expr) => {
+                if let Some(func) = class.slots.$slot.load() {
+                    let attr_name = identifier!(ctx, $name);
+                    if !class.attributes.read().contains_key(attr_name) {
+                        let wrapper = PySlotWrapper {
+                            typ: class,
+                            name: ctx.intern_str(stringify!($name)),
+                            wrapped: SlotFunc::$variant(func),
+                            doc: Some($doc),
+                        };
+                        class.set_attr(attr_name, wrapper.into_ref(ctx).into());
+                    }
+                }
+            };
         }
 
-        // Add __repr__ slot wrapper if slot exists and not already in dict
-        if let Some(repr_func) = class.slots.repr.load() {
-            let repr_name = identifier!(ctx, __repr__);
-            if !class.attributes.read().contains_key(repr_name) {
-                let wrapper = PySlotWrapper {
-                    typ: class,
-                    name: ctx.intern_str("__repr__"),
-                    wrapped: SlotFunc::Repr(repr_func),
-                    doc: Some("Return repr(self)."),
-                };
-                class.set_attr(repr_name, wrapper.into_ref(ctx).into());
+        add_slot_wrapper!(
+            init,
+            __init__,
+            Init,
+            "Initialize self.  See help(type(self)) for accurate signature."
+        );
+        add_slot_wrapper!(repr, __repr__, Repr, "Return repr(self).");
+        add_slot_wrapper!(iter, __iter__, Iter, "Implement iter(self).");
+        add_slot_wrapper!(iternext, __next__, IterNext, "Implement next(self).");
+
+        // __hash__ needs special handling: hash_not_implemented sets __hash__ = None
+        if let Some(hash_func) = class.slots.hash.load() {
+            if hash_func as usize == hash_not_implemented as usize {
+                class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
+            } else {
+                let hash_name = identifier!(ctx, __hash__);
+                if !class.attributes.read().contains_key(hash_name) {
+                    let wrapper = PySlotWrapper {
+                        typ: class,
+                        name: ctx.intern_str("__hash__"),
+                        wrapped: SlotFunc::Hash(hash_func),
+                        doc: Some("Return hash(self)."),
+                    };
+                    class.set_attr(hash_name, wrapper.into_ref(ctx).into());
+                }
             }
         }
 
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 6e98da173a4..26c059067e0 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -6,7 +6,7 @@ use crate::{
     builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef, type_::PointerSlot},
     bytecode::ComparisonOperator,
     common::hash::PyHash,
-    convert::{ToPyObject, ToPyResult},
+    convert::ToPyObject,
     function::{
         Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
     },
@@ -1435,10 +1435,7 @@ pub trait Iterable: PyPayload {
         Self::iter(zelf, vm)
     }
 
-    #[pymethod]
-    fn __iter__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        Self::slot_iter(zelf, vm)
-    }
+    // __iter__ is exposed via SlotFunc::Iter wrapper in extend_class()
 
     fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult;
 
@@ -1458,11 +1455,7 @@ pub trait IterNext: PyPayload + Iterable {
 
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn>;
 
-    #[inline]
-    #[pymethod]
-    fn __next__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        Self::slot_iternext(&zelf, vm).to_pyresult(vm)
-    }
+    // __next__ is exposed via SlotFunc::IterNext wrapper in extend_class()
 }
 
 pub trait SelfIter: PyPayload {}
@@ -1477,9 +1470,7 @@ where
         unreachable!("slot must be overridden for {}", repr.as_str());
     }
 
-    fn __iter__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self_iter(zelf, vm)
-    }
+    // __iter__ is exposed via SlotFunc::Iter wrapper in extend_class()
 
     #[cold]
     fn iter(_zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {

From be9e44aafbb5410adc26fe582613bc24dd6da277 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 09:08:18 +0900
Subject: [PATCH 053/418] Allow SyntaxError.msg to be writable and reflected in
 string formatting (#6493)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 DEVELOPMENT.md                             |  3 +-
 crates/vm/src/exceptions.rs                | 45 ++++++++++++++++------
 extra_tests/snippets/builtin_exceptions.py |  7 ++++
 3 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index aa7d99eef33..d5c675faca6 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -130,7 +130,8 @@ repository's structure:
   - `stdlib`: Standard library parts implemented in rust.
 - `src`: using the other subcrates to bring rustpython to life.
 - `wasm`: Binary crate and resources for WebAssembly build
-- `extra_tests`: extra integration test snippets as a supplement to `Lib/test`
+- `extra_tests`: extra integration test snippets as a supplement to `Lib/test`.
+  Add new RustPython-only regression tests here; do not place new tests under `Lib/test`.
 
 ## Understanding Internals
 
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 3a932a5df54..8d6ce6142b4 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -9,7 +9,7 @@ use crate::{
     },
     class::{PyClassImpl, StaticType},
     convert::{ToPyException, ToPyObject},
-    function::{ArgIterable, FuncArgs, IntoFuncArgs},
+    function::{ArgIterable, FuncArgs, IntoFuncArgs, PySetterValue},
     py_io::{self, Write},
     stdlib::sys,
     suggestion::offer_suggestions,
@@ -994,7 +994,12 @@ impl ExceptionZoo {
         extend_exception!(PyRecursionError, ctx, excs.recursion_error);
 
         extend_exception!(PySyntaxError, ctx, excs.syntax_error, {
-            "msg" => ctx.new_readonly_getset("msg", excs.syntax_error, make_arg_getter(0)),
+            "msg" => ctx.new_static_getset(
+                "msg",
+                excs.syntax_error,
+                make_arg_getter(0),
+                syntax_error_set_msg,
+            ),
             // TODO: members
             "filename" => ctx.none(),
             "lineno" => ctx.none(),
@@ -1041,6 +1046,25 @@ fn make_arg_getter(idx: usize) -> impl Fn(PyBaseExceptionRef) -> Option<PyObject
     move |exc| exc.get_arg(idx)
 }
 
+fn syntax_error_set_msg(
+    exc: PyBaseExceptionRef,
+    value: PySetterValue,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let mut args = exc.args.write();
+    let mut new_args = args.as_slice().to_vec();
+    // Ensure the message slot at index 0 always exists for SyntaxError.args.
+    if new_args.is_empty() {
+        new_args.push(vm.ctx.none());
+    }
+    match value {
+        PySetterValue::Assign(value) => new_args[0] = value,
+        PySetterValue::Delete => new_args[0] = vm.ctx.none(),
+    }
+    *args = PyTuple::new_ref(new_args, &vm.ctx);
+    Ok(())
+}
+
 fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
     exc.args.read().first().map(|code| {
         match_class!(match code {
@@ -2048,15 +2072,14 @@ pub(super) mod types {
                     .unwrap_or_else(|_| vm.ctx.new_str("<filename str() failed>"))
             });
 
-            let args = zelf.args();
-
-            let msg = if args.len() == 1 {
-                vm.exception_args_as_string(args, false)
-                    .into_iter()
-                    .exactly_one()
-                    .unwrap()
-            } else {
-                return zelf.__str__(vm);
+            let msg = match zelf.as_object().get_attr("msg", vm) {
+                Ok(obj) => obj
+                    .str(vm)
+                    .unwrap_or_else(|_| vm.ctx.new_str("<msg str() failed>")),
+                Err(_) => {
+                    // Fallback to the base formatting if the msg attribute was deleted or attribute lookup fails for any reason.
+                    return Py::<PyBaseException>::__str__(zelf, vm);
+                }
             };
 
             let msg_with_location_info: String = match (maybe_lineno, maybe_filename) {
diff --git a/extra_tests/snippets/builtin_exceptions.py b/extra_tests/snippets/builtin_exceptions.py
index 490f831f522..0af5cf05eaf 100644
--- a/extra_tests/snippets/builtin_exceptions.py
+++ b/extra_tests/snippets/builtin_exceptions.py
@@ -85,6 +85,13 @@ def __init__(self, value):
 assert exc.offset is None
 assert exc.text is None
 
+err = SyntaxError("bad bad", ("bad.py", 1, 2, "abcdefg"))
+err.msg = "changed"
+assert err.msg == "changed"
+assert str(err) == "changed (bad.py, line 1)"
+del err.msg
+assert err.msg is None
+
 # Regression to:
 # https://github.com/RustPython/RustPython/issues/2779
 

From 72cf6c36d53148903c5665cb18de04c490a2f264 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 09:09:58 +0900
Subject: [PATCH 054/418] Add missing xmlparser attributes: namespace_prefixes,
 ordered_attributes, specified_attributes, intern (#6494)

* Add namespace_prefixes and other missing xmlparser attributes

- Added namespace_prefixes, ordered_attributes, specified_attributes (boolean attributes)
- Added intern dictionary attribute
- Added stub handlers for all missing handler types to ensure compatibility
- Created bool_property macro to ensure boolean attributes are converted correctly

* Remove expectedFailure decorators from passing tests

- Tests for buffer_text, namespace_prefixes, ordered_attributes, and specified_attributes now pass

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 Lib/test/test_pyexpat.py     |   6 --
 crates/stdlib/src/pyexpat.rs | 183 ++++++++++++++++++++++++++++++++++-
 2 files changed, 182 insertions(+), 7 deletions(-)

diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index 80485cc74b9..015e7497268 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -20,28 +20,24 @@ class SetAttributeTest(unittest.TestCase):
     def setUp(self):
         self.parser = expat.ParserCreate(namespace_separator='!')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_buffer_text(self):
         self.assertIs(self.parser.buffer_text, False)
         for x in 0, 1, 2, 0:
             self.parser.buffer_text = x
             self.assertIs(self.parser.buffer_text, bool(x))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_namespace_prefixes(self):
         self.assertIs(self.parser.namespace_prefixes, False)
         for x in 0, 1, 2, 0:
             self.parser.namespace_prefixes = x
             self.assertIs(self.parser.namespace_prefixes, bool(x))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ordered_attributes(self):
         self.assertIs(self.parser.ordered_attributes, False)
         for x in 0, 1, 2, 0:
             self.parser.ordered_attributes = x
             self.assertIs(self.parser.ordered_attributes, bool(x))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_specified_attributes(self):
         self.assertIs(self.parser.specified_attributes, False)
         for x in 0, 1, 2, 0:
@@ -244,7 +240,6 @@ def test_parse_bytes(self):
         # Issue #6697.
         self.assertRaises(AttributeError, getattr, parser, '\uD800')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse_str(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -255,7 +250,6 @@ def test_parse_str(self):
         operations = out.out
         self._verify_parse_output(operations)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse_file(self):
         # Try parsing a file
         out = self.Outputter()
diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
index 871ba7d5987..699fa21852d 100644
--- a/crates/stdlib/src/pyexpat.rs
+++ b/crates/stdlib/src/pyexpat.rs
@@ -25,6 +25,26 @@ macro_rules! create_property {
     };
 }
 
+macro_rules! create_bool_property {
+    ($ctx: expr, $attributes: expr, $name: expr, $class: expr, $element: ident) => {
+        let attr = $ctx.new_static_getset(
+            $name,
+            $class,
+            move |this: &PyExpatLikeXmlParser| this.$element.read().clone(),
+            move |this: &PyExpatLikeXmlParser,
+                  value: PyObjectRef,
+                  vm: &VirtualMachine|
+                  -> PyResult<()> {
+                let bool_value = value.is_true(vm)?;
+                *this.$element.write() = vm.ctx.new_bool(bool_value).into();
+                Ok(())
+            },
+        );
+
+        $attributes.insert($ctx.intern_str($name), attr.into());
+    };
+}
+
 #[pymodule(name = "pyexpat")]
 mod _pyexpat {
     use crate::vm::{
@@ -51,6 +71,29 @@ mod _pyexpat {
         character_data: MutableObject,
         entity_decl: MutableObject,
         buffer_text: MutableObject,
+        namespace_prefixes: MutableObject,
+        ordered_attributes: MutableObject,
+        specified_attributes: MutableObject,
+        intern: MutableObject,
+        // Additional handlers (stubs for compatibility)
+        processing_instruction: MutableObject,
+        unparsed_entity_decl: MutableObject,
+        notation_decl: MutableObject,
+        start_namespace_decl: MutableObject,
+        end_namespace_decl: MutableObject,
+        comment: MutableObject,
+        start_cdata_section: MutableObject,
+        end_cdata_section: MutableObject,
+        default: MutableObject,
+        default_expand: MutableObject,
+        not_standalone: MutableObject,
+        external_entity_ref: MutableObject,
+        start_doctype_decl: MutableObject,
+        end_doctype_decl: MutableObject,
+        xml_decl: MutableObject,
+        element_decl: MutableObject,
+        attlist_decl: MutableObject,
+        skipped_entity: MutableObject,
     }
     type PyExpatLikeXmlParserRef = PyRef<PyExpatLikeXmlParser>;
 
@@ -71,6 +114,31 @@ mod _pyexpat {
                 character_data: MutableObject::new(vm.ctx.none()),
                 entity_decl: MutableObject::new(vm.ctx.none()),
                 buffer_text: MutableObject::new(vm.ctx.new_bool(false).into()),
+                namespace_prefixes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                ordered_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                specified_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                // String interning dictionary - used by the parser to intern element/attribute names
+                // for memory efficiency and faster comparisons. See CPython's pyexpat documentation.
+                intern: MutableObject::new(vm.ctx.new_dict().into()),
+                // Additional handlers (stubs for compatibility)
+                processing_instruction: MutableObject::new(vm.ctx.none()),
+                unparsed_entity_decl: MutableObject::new(vm.ctx.none()),
+                notation_decl: MutableObject::new(vm.ctx.none()),
+                start_namespace_decl: MutableObject::new(vm.ctx.none()),
+                end_namespace_decl: MutableObject::new(vm.ctx.none()),
+                comment: MutableObject::new(vm.ctx.none()),
+                start_cdata_section: MutableObject::new(vm.ctx.none()),
+                end_cdata_section: MutableObject::new(vm.ctx.none()),
+                default: MutableObject::new(vm.ctx.none()),
+                default_expand: MutableObject::new(vm.ctx.none()),
+                not_standalone: MutableObject::new(vm.ctx.none()),
+                external_entity_ref: MutableObject::new(vm.ctx.none()),
+                start_doctype_decl: MutableObject::new(vm.ctx.none()),
+                end_doctype_decl: MutableObject::new(vm.ctx.none()),
+                xml_decl: MutableObject::new(vm.ctx.none()),
+                element_decl: MutableObject::new(vm.ctx.none()),
+                attlist_decl: MutableObject::new(vm.ctx.none()),
+                skipped_entity: MutableObject::new(vm.ctx.none()),
             }
             .into_ref(&vm.ctx))
         }
@@ -89,7 +157,120 @@ mod _pyexpat {
                 character_data
             );
             create_property!(ctx, attributes, "EntityDeclHandler", class, entity_decl);
-            create_property!(ctx, attributes, "buffer_text", class, buffer_text);
+            create_bool_property!(ctx, attributes, "buffer_text", class, buffer_text);
+            create_bool_property!(
+                ctx,
+                attributes,
+                "namespace_prefixes",
+                class,
+                namespace_prefixes
+            );
+            create_bool_property!(
+                ctx,
+                attributes,
+                "ordered_attributes",
+                class,
+                ordered_attributes
+            );
+            create_bool_property!(
+                ctx,
+                attributes,
+                "specified_attributes",
+                class,
+                specified_attributes
+            );
+            create_property!(ctx, attributes, "intern", class, intern);
+            // Additional handlers (stubs for compatibility)
+            create_property!(
+                ctx,
+                attributes,
+                "ProcessingInstructionHandler",
+                class,
+                processing_instruction
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "UnparsedEntityDeclHandler",
+                class,
+                unparsed_entity_decl
+            );
+            create_property!(ctx, attributes, "NotationDeclHandler", class, notation_decl);
+            create_property!(
+                ctx,
+                attributes,
+                "StartNamespaceDeclHandler",
+                class,
+                start_namespace_decl
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndNamespaceDeclHandler",
+                class,
+                end_namespace_decl
+            );
+            create_property!(ctx, attributes, "CommentHandler", class, comment);
+            create_property!(
+                ctx,
+                attributes,
+                "StartCdataSectionHandler",
+                class,
+                start_cdata_section
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndCdataSectionHandler",
+                class,
+                end_cdata_section
+            );
+            create_property!(ctx, attributes, "DefaultHandler", class, default);
+            create_property!(
+                ctx,
+                attributes,
+                "DefaultHandlerExpand",
+                class,
+                default_expand
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "NotStandaloneHandler",
+                class,
+                not_standalone
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "ExternalEntityRefHandler",
+                class,
+                external_entity_ref
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "StartDoctypeDeclHandler",
+                class,
+                start_doctype_decl
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndDoctypeDeclHandler",
+                class,
+                end_doctype_decl
+            );
+            create_property!(ctx, attributes, "XmlDeclHandler", class, xml_decl);
+            create_property!(ctx, attributes, "ElementDeclHandler", class, element_decl);
+            create_property!(ctx, attributes, "AttlistDeclHandler", class, attlist_decl);
+            create_property!(
+                ctx,
+                attributes,
+                "SkippedEntityHandler",
+                class,
+                skipped_entity
+            );
         }
 
         fn create_config(&self) -> xml::ParserConfig {

From 7ebb0f0c5c8e8958238e80e23f5e108dbb892db7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 09:21:09 +0900
Subject: [PATCH 055/418] impl path_converter and os functions (#6484)

* os.setpgrp

* tcgetpgrp

* impl more os functions

* impl PathConverter
---
 Lib/test/test_os.py              |   9 +-
 crates/vm/src/function/fspath.rs |   3 +-
 crates/vm/src/ospath.rs          | 217 ++++++++++++++++++++++++++-----
 crates/vm/src/stdlib/nt.rs       |  29 +++--
 crates/vm/src/stdlib/os.rs       |  46 +++++--
 crates/vm/src/stdlib/posix.rs    |  26 ++++
 6 files changed, 272 insertions(+), 58 deletions(-)

diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index bb558524c24..4755aef080e 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -1725,15 +1725,15 @@ def walk(self, top, **kwargs):
             bdirs[:] = list(map(os.fsencode, dirs))
             bfiles[:] = list(map(os.fsencode, files))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; (TypeError: Can't mix strings and bytes in path components)
+    @unittest.expectedFailure # TODO: RUSTPYTHON; WalkTests doesn't have these methods
     def test_compare_to_walk(self):
         return super().test_compare_to_walk()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; (TypeError: Can't mix strings and bytes in path components)
+    @unittest.expectedFailure # TODO: RUSTPYTHON; WalkTests doesn't have these methods
     def test_dir_fd(self):
         return super().test_dir_fd()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; (TypeError: Can't mix strings and bytes in path components)
+    @unittest.expectedFailure # TODO: RUSTPYTHON; WalkTests doesn't have these methods
     def test_yields_correct_dir_fd(self):
         return super().test_yields_correct_dir_fd()
 
@@ -4502,7 +4502,6 @@ class Str(str):
 
         self.filenames = self.bytes_filenames + self.unicode_filenames
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; (AssertionError: b'@test_22106_tmp\xe7w\xf0' is not b'@test_22106_tmp\xe7w\xf0' : <built-in function chdir>)
     def test_oserror_filename(self):
         funcs = [
             (self.filenames, os.chdir,),
@@ -4906,7 +4905,6 @@ def setUp(self):
     def test_uninstantiable(self):
         self.assertRaises(TypeError, os.DirEntry)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; (pickle.PicklingError: Can't pickle <class '_os.DirEntry'>: it's not found as _os.DirEntry)
     def test_unpickable(self):
         filename = create_file(os.path.join(self.path, "file.txt"), b'python')
         entry = [entry for entry in os.scandir(self.path)].pop()
@@ -5337,7 +5335,6 @@ def __fspath__(self):
                 return ''
         self.assertFalse(hasattr(A(), '__dict__'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fspath_set_to_None(self):
         class Foo:
             __fspath__ = None
diff --git a/crates/vm/src/function/fspath.rs b/crates/vm/src/function/fspath.rs
index 2bc331844c6..44d41ab7632 100644
--- a/crates/vm/src/function/fspath.rs
+++ b/crates/vm/src/function/fspath.rs
@@ -7,6 +7,7 @@ use crate::{
 };
 use std::{borrow::Cow, ffi::OsStr, path::PathBuf};
 
+/// Helper to implement os.fspath()
 #[derive(Clone)]
 pub enum FsPath {
     Str(PyStrRef),
@@ -27,7 +28,7 @@ impl FsPath {
         )
     }
 
-    // PyOS_FSPath in CPython
+    // PyOS_FSPath
     pub fn try_from(
         obj: PyObjectRef,
         check_for_nul: bool,
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
index 9fca53d869c..77abbee2cd5 100644
--- a/crates/vm/src/ospath.rs
+++ b/crates/vm/src/ospath.rs
@@ -2,20 +2,181 @@ use rustpython_common::crt_fd;
 
 use crate::{
     PyObjectRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyStr},
     convert::{IntoPyException, ToPyException, ToPyObject, TryFromObject},
     function::FsPath,
 };
 use std::path::{Path, PathBuf};
 
-// path_ without allow_fd in CPython
+/// path_converter
+#[derive(Clone, Copy, Default)]
+pub struct PathConverter {
+    /// Function name for error messages (e.g., "rename")
+    pub function_name: Option<&'static str>,
+    /// Argument name for error messages (e.g., "src", "dst")
+    pub argument_name: Option<&'static str>,
+    /// If true, embedded null characters are allowed
+    pub non_strict: bool,
+}
+
+impl PathConverter {
+    pub const fn new() -> Self {
+        Self {
+            function_name: None,
+            argument_name: None,
+            non_strict: false,
+        }
+    }
+
+    pub const fn function(mut self, name: &'static str) -> Self {
+        self.function_name = Some(name);
+        self
+    }
+
+    pub const fn argument(mut self, name: &'static str) -> Self {
+        self.argument_name = Some(name);
+        self
+    }
+
+    pub const fn non_strict(mut self) -> Self {
+        self.non_strict = true;
+        self
+    }
+
+    /// Generate error message prefix like "rename: "
+    fn error_prefix(&self) -> String {
+        match self.function_name {
+            Some(func) => format!("{}: ", func),
+            None => String::new(),
+        }
+    }
+
+    /// Get argument name for error messages, defaults to "path"
+    fn arg_name(&self) -> &'static str {
+        self.argument_name.unwrap_or("path")
+    }
+
+    /// Format a type error message
+    fn type_error_msg(&self, type_name: &str, allow_fd: bool) -> String {
+        let expected = if allow_fd {
+            "string, bytes, os.PathLike or integer"
+        } else {
+            "string, bytes or os.PathLike"
+        };
+        format!(
+            "{}{} should be {}, not {}",
+            self.error_prefix(),
+            self.arg_name(),
+            expected,
+            type_name
+        )
+    }
+
+    /// Convert to OsPathOrFd (path or file descriptor)
+    pub(crate) fn try_path_or_fd<'fd>(
+        &self,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<OsPathOrFd<'fd>> {
+        // Handle fd (before __fspath__ check, like CPython)
+        if let Some(int) = obj.try_index_opt(vm) {
+            let fd = int?.try_to_primitive(vm)?;
+            return 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)
+    }
+
+    /// Convert to OsPath only (no fd support)
+    fn try_path_inner(
+        &self,
+        obj: PyObjectRef,
+        allow_fd: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<OsPath> {
+        // Try direct str/bytes match
+        let obj = match self.try_match_str_bytes(obj.clone(), vm)? {
+            Ok(path) => return Ok(path),
+            Err(obj) => obj,
+        };
+
+        // Call __fspath__
+        let type_error_msg = || self.type_error_msg(&obj.class().name(), allow_fd);
+        let method =
+            vm.get_method_or_type_error(obj.clone(), identifier!(vm, __fspath__), type_error_msg)?;
+        if vm.is_none(&method) {
+            return Err(vm.new_type_error(type_error_msg()));
+        }
+        let result = method.call((), vm)?;
+
+        // Match __fspath__ result
+        self.try_match_str_bytes(result.clone(), vm)?.map_err(|_| {
+            vm.new_type_error(format!(
+                "{}expected {}.__fspath__() to return str or bytes, not {}",
+                self.error_prefix(),
+                obj.class().name(),
+                result.class().name(),
+            ))
+        })
+    }
+
+    /// Try to match str or bytes, returns Err(obj) if neither
+    fn try_match_str_bytes(
+        &self,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Result<OsPath, PyObjectRef>> {
+        let check_nul = |b: &[u8]| {
+            if self.non_strict || memchr::memchr(b'\0', b).is_none() {
+                Ok(())
+            } else {
+                Err(vm.new_value_error(format!(
+                    "{}embedded null character in {}",
+                    self.error_prefix(),
+                    self.arg_name()
+                )))
+            }
+        };
+
+        match_class!(match obj {
+            s @ PyStr => {
+                check_nul(s.as_bytes())?;
+                let path = vm.fsencode(&s)?.into_owned();
+                Ok(Ok(OsPath {
+                    path,
+                    origin: Some(s.into()),
+                }))
+            }
+            b @ PyBytes => {
+                check_nul(&b)?;
+                let path = FsPath::bytes_as_os_str(&b, vm)?.to_owned();
+                Ok(Ok(OsPath {
+                    path,
+                    origin: Some(b.into()),
+                }))
+            }
+            obj => Ok(Err(obj)),
+        })
+    }
+
+    /// Convert to OsPath directly
+    pub fn try_path(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<OsPath> {
+        self.try_path_inner(obj, false, vm)
+    }
+}
+
+/// path_t output - the converted path
 #[derive(Clone)]
 pub struct OsPath {
     pub path: std::ffi::OsString,
-    pub(super) mode: OutputMode,
+    /// Original Python object for identity preservation in OSError
+    pub(super) origin: Option<PyObjectRef>,
 }
 
 #[derive(Debug, Copy, Clone)]
-pub(super) enum OutputMode {
+pub enum OutputMode {
     String,
     Bytes,
 }
@@ -38,19 +199,19 @@ impl OutputMode {
 impl OsPath {
     pub fn new_str(path: impl Into<std::ffi::OsString>) -> Self {
         let path = path.into();
-        Self {
-            path,
-            mode: OutputMode::String,
-        }
+        Self { path, origin: None }
     }
 
     pub(crate) fn from_fspath(fspath: FsPath, vm: &VirtualMachine) -> PyResult<Self> {
         let path = fspath.as_os_str(vm)?.into_owned();
-        let mode = match fspath {
-            FsPath::Str(_) => OutputMode::String,
-            FsPath::Bytes(_) => OutputMode::Bytes,
+        let origin = match fspath {
+            FsPath::Str(s) => s.into(),
+            FsPath::Bytes(b) => b.into(),
         };
-        Ok(Self { path, mode })
+        Ok(Self {
+            path,
+            origin: Some(origin),
+        })
     }
 
     /// Convert an object to OsPath using the os.fspath-style error message.
@@ -83,7 +244,20 @@ impl OsPath {
     }
 
     pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {
-        self.mode.process_path(self.path.clone(), vm)
+        if let Some(ref origin) = self.origin {
+            origin.clone()
+        } else {
+            // Default to string when no origin (e.g., from new_str)
+            OutputMode::String.process_path(self.path.clone(), vm)
+        }
+    }
+
+    /// Get the output mode based on origin type (bytes -> Bytes, otherwise -> String)
+    pub fn mode(&self) -> OutputMode {
+        match &self.origin {
+            Some(obj) if obj.downcast_ref::<PyBytes>().is_some() => OutputMode::Bytes,
+            _ => OutputMode::String,
+        }
     }
 }
 
@@ -94,15 +268,8 @@ impl AsRef<Path> for OsPath {
 }
 
 impl TryFromObject for OsPath {
-    // TODO: path_converter with allow_fd=0 in CPython
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let fspath = FsPath::try_from(
-            obj,
-            true,
-            "should be string, bytes, os.PathLike or integer",
-            vm,
-        )?;
-        Self::from_fspath(fspath, vm)
+        PathConverter::new().try_path(obj, vm)
     }
 }
 
@@ -115,15 +282,7 @@ pub(crate) enum OsPathOrFd<'fd> {
 
 impl TryFromObject for OsPathOrFd<'_> {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        match obj.try_index_opt(vm) {
-            Some(int) => {
-                let fd = int?.try_to_primitive(vm)?;
-                unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
-                    .map(Self::Fd)
-                    .map_err(|e| e.into_pyexception(vm))
-            }
-            None => obj.try_into_value(vm).map(Self::Path),
-        }
+        PathConverter::new().try_path_or_fd(obj, vm)
     }
 }
 
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
index ada939b1549..fc68139dc88 100644
--- a/crates/vm/src/stdlib/nt.rs
+++ b/crates/vm/src/stdlib/nt.rs
@@ -17,6 +17,7 @@ pub(crate) mod module {
         builtins::{PyBaseExceptionRef, PyDictRef, PyListRef, PyStrRef, PyTupleRef},
         common::{crt_fd, suppress_iph, windows::ToWideString},
         convert::ToPyException,
+        exceptions::OSErrorBuilder,
         function::{Either, OptionalArg},
         ospath::{OsPath, OsPathOrFd},
         stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
@@ -193,10 +194,12 @@ pub(crate) mod module {
         };
 
         // Use symlink_metadata to avoid following dangling symlinks
-        let meta = fs::symlink_metadata(&actual_path).map_err(|err| err.to_pyexception(vm))?;
+        let meta = fs::symlink_metadata(&actual_path)
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
         let mut permissions = meta.permissions();
         permissions.set_readonly(mode & S_IWRITE == 0);
-        fs::set_permissions(&*actual_path, permissions).map_err(|err| err.to_pyexception(vm))
+        fs::set_permissions(&*actual_path, permissions)
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
     }
 
     /// Get the real file name (with correct case) without accessing the file.
@@ -925,7 +928,7 @@ pub(crate) mod module {
             .as_ref()
             .canonicalize()
             .map_err(|e| e.to_pyexception(vm))?;
-        Ok(path.mode.process_path(real, vm))
+        Ok(path.mode().process_path(real, vm))
     }
 
     #[pyfunction]
@@ -958,7 +961,7 @@ pub(crate) mod module {
             }
         }
         let buffer = widestring::WideCString::from_vec_truncate(buffer);
-        Ok(path.mode.process_path(buffer.to_os_string(), vm))
+        Ok(path.mode().process_path(buffer.to_os_string(), vm))
     }
 
     #[pyfunction]
@@ -973,7 +976,7 @@ pub(crate) mod module {
             return Err(vm.new_last_os_error());
         }
         let buffer = widestring::WideCString::from_vec_truncate(buffer);
-        Ok(path.mode.process_path(buffer.to_os_string(), vm))
+        Ok(path.mode().process_path(buffer.to_os_string(), vm))
     }
 
     /// Implements _Py_skiproot logic for Windows paths
@@ -1053,7 +1056,7 @@ pub(crate) mod module {
         use crate::builtins::{PyBytes, PyStr};
         use rustpython_common::wtf8::Wtf8Buf;
 
-        // Handle path-like objects via os.fspath, but without null check (nonstrict=True)
+        // Handle path-like objects via os.fspath, but without null check (non_strict=True)
         let path = if let Some(fspath) = vm.get_method(path.clone(), identifier!(vm, __fspath__)) {
             fspath?.call((), vm)?
         } else {
@@ -1585,7 +1588,7 @@ pub(crate) mod module {
         use windows_sys::Win32::System::IO::DeviceIoControl;
         use windows_sys::Win32::System::Ioctl::FSCTL_GET_REPARSE_POINT;
 
-        let mode = path.mode;
+        let mode = path.mode();
         let wide_path = path.as_ref().to_wide_with_nul();
 
         // Open the file/directory with reparse point flag
@@ -1602,7 +1605,11 @@ pub(crate) mod module {
         };
 
         if handle == INVALID_HANDLE_VALUE {
-            return Err(io::Error::last_os_error().to_pyexception(vm));
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path.clone(),
+                vm,
+            ));
         }
 
         // Buffer for reparse data - MAXIMUM_REPARSE_DATA_BUFFER_SIZE is 16384
@@ -1626,7 +1633,11 @@ pub(crate) mod module {
         unsafe { CloseHandle(handle) };
 
         if result == 0 {
-            return Err(io::Error::last_os_error().to_pyexception(vm));
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path.clone(),
+                vm,
+            ));
         }
 
         // Parse the reparse data buffer
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 868fc727c65..87080ff8e0f 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -164,7 +164,7 @@ pub(super) mod _os {
         convert::{IntoPyException, ToPyObject},
         exceptions::OSErrorBuilder,
         function::{ArgBytesLike, FsPath, FuncArgs, OptionalArg},
-        ospath::{OsPath, OsPathOrFd, OutputMode},
+        ospath::{OsPath, OsPathOrFd, OutputMode, PathConverter},
         protocol::PyIterReturn,
         recursion::ReprGuard,
         types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter},
@@ -366,10 +366,12 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn listdir(
-        path: OptionalArg<OsPathOrFd<'_>>,
+        path: OptionalArg<Option<OsPathOrFd<'_>>>,
         vm: &VirtualMachine,
     ) -> PyResult<Vec<PyObjectRef>> {
-        let path = path.unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));
+        let path = path
+            .flatten()
+            .unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));
         let list = match path {
             OsPathOrFd::Path(path) => {
                 let dir_iter = match fs::read_dir(&path) {
@@ -378,9 +380,10 @@ pub(super) mod _os {
                         return Err(OSErrorBuilder::with_filename(&err, path, vm));
                     }
                 };
+                let mode = path.mode();
                 dir_iter
                     .map(|entry| match entry {
-                        Ok(entry_path) => Ok(path.mode.process_path(entry_path.file_name(), vm)),
+                        Ok(entry_path) => Ok(mode.process_path(entry_path.file_name(), vm)),
                         Err(err) => Err(OSErrorBuilder::with_filename(&err, path.clone(), vm)),
                     })
                     .collect::<PyResult<_>>()?
@@ -545,7 +548,7 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn readlink(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult {
-        let mode = path.mode;
+        let mode = path.mode();
         let [] = dir_fd.0;
         let path =
             fs::read_link(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
@@ -640,7 +643,7 @@ pub(super) mod _os {
                 stat(
                     OsPath {
                         path: self.pathval.as_os_str().to_owned(),
-                        mode: OutputMode::String,
+                        origin: None,
                     }
                     .into(),
                     dir_fd,
@@ -671,11 +674,7 @@ pub(super) mod _os {
                 Some(ino) => Ok(ino),
                 None => {
                     let stat = stat_inner(
-                        OsPath {
-                            path: self.pathval.as_os_str().to_owned(),
-                            mode: OutputMode::String,
-                        }
-                        .into(),
+                        OsPath::new_str(self.pathval.as_os_str()).into(),
                         DirFd::default(),
                         FollowSymlinks(false),
                     )
@@ -730,6 +729,11 @@ pub(super) mod _os {
         ) -> PyGenericAlias {
             PyGenericAlias::from_args(cls, args, vm)
         }
+
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle 'DirEntry' object".to_owned()))
+        }
     }
 
     impl Representable for DirEntry {
@@ -785,6 +789,11 @@ pub(super) mod _os {
         fn __exit__(zelf: PyRef<Self>, _args: FuncArgs) {
             zelf.close()
         }
+
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle 'ScandirIterator' object".to_owned()))
+        }
     }
     impl SelfIter for ScandirIterator {}
     impl IterNext for ScandirIterator {
@@ -861,7 +870,7 @@ pub(super) mod _os {
             .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
         Ok(ScandirIterator {
             entries: PyRwLock::new(Some(entries)),
-            mode: path.mode,
+            mode: path.mode(),
         }
         .into_ref(&vm.ctx)
         .into())
@@ -1124,7 +1133,16 @@ pub(super) mod _os {
 
     #[pyfunction]
     #[pyfunction(name = "replace")]
-    fn rename(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
+    fn rename(src: PyObjectRef, dst: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let src = PathConverter::new()
+            .function("rename")
+            .argument("src")
+            .try_path(src, vm)?;
+        let dst = PathConverter::new()
+            .function("rename")
+            .argument("dst")
+            .try_path(dst, vm)?;
+
         fs::rename(&src.path, &dst.path).map_err(|err| {
             let builder = err.to_os_error_builder(vm);
             let builder = builder.filename(src.filename(vm));
@@ -1708,6 +1726,8 @@ pub(super) mod _os {
             SupportFunc::new("fstat", Some(true), Some(STAT_DIR_FD), Some(true)),
             SupportFunc::new("symlink", Some(false), Some(SYMLINK_DIR_FD), Some(false)),
             SupportFunc::new("truncate", Some(true), Some(false), Some(false)),
+            SupportFunc::new("ftruncate", Some(true), Some(false), Some(false)),
+            SupportFunc::new("fsync", Some(true), Some(false), Some(false)),
             SupportFunc::new(
                 "utime",
                 Some(false),
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 59e41782574..15c8745ded4 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -1240,6 +1240,12 @@ pub mod module {
             .map_err(|err| err.into_pyexception(vm))
     }
 
+    #[pyfunction]
+    fn setpgrp(vm: &VirtualMachine) -> PyResult<()> {
+        // setpgrp() is equivalent to setpgid(0, 0)
+        unistd::setpgid(Pid::from_raw(0), Pid::from_raw(0)).map_err(|err| err.into_pyexception(vm))
+    }
+
     #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
     #[pyfunction]
     fn setsid(vm: &VirtualMachine) -> PyResult<()> {
@@ -1248,6 +1254,24 @@ pub mod module {
             .map_err(|err| err.into_pyexception(vm))
     }
 
+    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
+    #[pyfunction]
+    fn tcgetpgrp(fd: i32, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
+        use std::os::fd::BorrowedFd;
+        let fd = unsafe { BorrowedFd::borrow_raw(fd) };
+        unistd::tcgetpgrp(fd)
+            .map(|pid| pid.as_raw())
+            .map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
+    #[pyfunction]
+    fn tcsetpgrp(fd: i32, pgid: libc::pid_t, vm: &VirtualMachine) -> PyResult<()> {
+        use std::os::fd::BorrowedFd;
+        let fd = unsafe { BorrowedFd::borrow_raw(fd) };
+        unistd::tcsetpgrp(fd, Pid::from_raw(pgid)).map_err(|err| err.into_pyexception(vm))
+    }
+
     fn try_from_id(vm: &VirtualMachine, obj: PyObjectRef, typ_name: &str) -> PyResult<u32> {
         use std::cmp::Ordering;
         let i = obj
@@ -1833,6 +1857,8 @@ pub mod module {
             SupportFunc::new("umask", Some(false), Some(false), Some(false)),
             SupportFunc::new("execv", None, None, None),
             SupportFunc::new("pathconf", Some(true), None, None),
+            SupportFunc::new("fpathconf", Some(true), None, None),
+            SupportFunc::new("fchdir", Some(true), None, None),
         ]
     }
 

From ebdc033c59d39405ee1d6c2b31afe8fb1b2c61bc Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 09:48:20 +0900
Subject: [PATCH 056/418] Bundle Lib directory in GitHub releases (#6497)

* Initial plan

* Add Lib directory archives to release workflow

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Add release notes explaining users need both binary and Lib archive

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Remove unnecessary --notes-start-tag parameter

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Only create zip archive, remove tar.gz

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 .github/workflows/release.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3efff295c37..5ad2cf3f97a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -144,6 +144,8 @@ jobs:
     if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     needs: [build, build-wasm]
     steps:
+      - uses: actions/checkout@v6.0.1
+
       - name: Download Binary Artifacts
         uses: actions/download-artifact@v7.0.0
         with:
@@ -151,6 +153,10 @@ jobs:
           pattern: rustpython-*
           merge-multiple: true
 
+      - name: Create Lib Archive
+        run: |
+          zip -r bin/rustpython-lib.zip Lib/
+
       - name: List Binaries
         run: |
           ls -lah bin/
@@ -174,6 +180,7 @@ jobs:
               --repo="$GITHUB_REPOSITORY" \
               --title="RustPython $RELEASE_TYPE_NAME $today-$tag #$run" \
               --target="$tag" \
+              --notes "⚠� **Important**: To run RustPython, you must download both the binary for your platform AND the \`rustpython-lib.zip\` archive. Extract the Lib directory from the archive to the same location as the binary, or set the \`RUSTPYTHONPATH\` environment variable to point to the Lib directory." \
               --generate-notes \
               $PRERELEASE_ARG \
               bin/rustpython-release-*

From 5122aed738b4a50a4f52af30b650967be9c081ef Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 10:32:51 +0900
Subject: [PATCH 057/418] Fix install ujson (#6502)

---
 crates/stdlib/src/ssl/compat.rs | 96 ++++++++++++++++++++++++++-------
 1 file changed, 76 insertions(+), 20 deletions(-)

diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index cd927a0e410..45aa9c4fce9 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -1421,6 +1421,50 @@ pub(super) fn ssl_read(
                     return Err(SslError::Eof);
                 }
             }
+
+            // For non-blocking sockets, return WantRead so caller can poll and retry.
+            // For blocking sockets (or sockets with timeout), wait for more data.
+            if !is_bio {
+                let timeout = socket.get_socket_timeout(vm).map_err(SslError::Py)?;
+                if let Some(t) = timeout
+                    && t.is_zero()
+                {
+                    // Non-blocking socket: return immediately
+                    return Err(SslError::WantRead);
+                }
+                // Blocking socket or socket with timeout: try to read more data from socket.
+                // Even though rustls says it doesn't want to read, more TLS records may arrive.
+                // This handles the case where rustls processed all buffered TLS records but
+                // more data is coming over the network.
+                let data = match socket.sock_recv(2048, vm) {
+                    Ok(data) => data,
+                    Err(e) => {
+                        if is_connection_closed_error(&e, vm) {
+                            return Err(SslError::Eof);
+                        }
+                        return Err(SslError::Py(e));
+                    }
+                };
+
+                let bytes_read = data
+                    .clone()
+                    .try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
+                    .map(|b| b.as_bytes().len())
+                    .unwrap_or(0);
+
+                if bytes_read == 0 {
+                    // No more data available - connection might be closed
+                    return Err(SslError::Eof);
+                }
+
+                // Feed data to rustls and process
+                ssl_read_tls_records(conn, data, false, vm)?;
+                conn.process_new_packets().map_err(SslError::from_rustls)?;
+
+                // Continue loop to try reading plaintext
+                continue;
+            }
+
             return Err(SslError::WantRead);
         }
 
@@ -1432,20 +1476,9 @@ pub(super) fn ssl_read(
                 // Continue loop to try reading plaintext
             }
             Err(SslError::Io(ref io_err)) if io_err.to_string().contains("message buffer full") => {
-                // Buffer is full - we need to consume plaintext before reading more
-                // Try to read plaintext now
-                match try_read_plaintext(conn, buf)? {
-                    Some(n) if n > 0 => {
-                        // Have plaintext - return it
-                        // Python will call read() again if it needs more data
-                        return Ok(n);
-                    }
-                    _ => {
-                        // No plaintext available yet - this is unusual
-                        // Return WantRead to let Python retry
-                        return Err(SslError::WantRead);
-                    }
-                }
+                // This case should be rare now that ssl_read_tls_records handles buffer full
+                // Just continue loop to try again
+                continue;
             }
             Err(e) => {
                 // Other errors - check for buffered plaintext before propagating
@@ -1524,7 +1557,7 @@ fn ssl_read_tls_records(
     }
 
     // Feed all received data to read_tls - loop to consume all data
-    // read_tls may not consume all data in one call
+    // read_tls may not consume all data in one call, and buffer may become full
     let mut offset = 0;
     while offset < bytes_data.len() {
         let remaining = &bytes_data[offset..];
@@ -1533,12 +1566,33 @@ fn ssl_read_tls_records(
         match conn.read_tls(&mut cursor) {
             Ok(read_bytes) => {
                 if read_bytes == 0 {
-                    // No more data can be consumed
-                    break;
+                    // Buffer is full - process existing packets to make room
+                    conn.process_new_packets().map_err(SslError::from_rustls)?;
+
+                    // Try again - if we still can't consume, break
+                    let mut retry_cursor = std::io::Cursor::new(remaining);
+                    match conn.read_tls(&mut retry_cursor) {
+                        Ok(0) => {
+                            // Still can't consume - break to avoid infinite loop
+                            break;
+                        }
+                        Ok(n) => {
+                            offset += n;
+                        }
+                        Err(e) => {
+                            return Err(SslError::Io(e));
+                        }
+                    }
+                } else {
+                    offset += read_bytes;
                 }
-                offset += read_bytes;
             }
             Err(e) => {
+                // Check if it's a buffer full error (unlikely but handle it)
+                if e.to_string().contains("buffer full") {
+                    conn.process_new_packets().map_err(SslError::from_rustls)?;
+                    continue;
+                }
                 // Real error - propagate it
                 return Err(SslError::Io(e));
             }
@@ -1599,8 +1653,10 @@ fn ssl_ensure_data_available(
                     .sock_wait_for_io_impl(SelectKind::Read, vm)
                     .map_err(SslError::Py)?;
                 if timed_out {
-                    // Socket not ready within timeout
-                    return Err(SslError::WantRead);
+                    // Socket not ready within timeout - raise socket.timeout
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
                 }
             }
             // else: non-blocking socket (timeout=0) or blocking socket (timeout=None) - skip select

From 6dbc8f0cfa1d0cd48b90d48c6f7768a030a091a8 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 10:33:22 +0900
Subject: [PATCH 058/418] Set SourceFileLoader for script execution in
 run_simple_file (#6496)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Lib/test/test_cmd_line_script.py |  2 --
 crates/vm/src/vm/compile.rs      | 12 +++++++++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index 833dc6b15d8..d773674feef 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -225,8 +225,6 @@ def test_repl_stderr_flush(self):
     def test_repl_stderr_flush_separate_stderr(self):
         self.check_repl_stderr_flush(True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_script(self):
         with os_helper.temp_dir() as script_dir:
             script_name = _make_test_script(script_dir, 'script')
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index 44332cda838..a7e31cf0377 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -81,7 +81,7 @@ impl VirtualMachine {
             todo!("running pyc is not implemented yet");
         } else {
             if path != "<stdin>" {
-                // TODO: set_main_loader(dict, filename, "SourceFileLoader");
+                set_main_loader(&module_dict, path, self)?;
             }
             // TODO: replace to something equivalent to py_run_file
             match std::fs::read_to_string(path) {
@@ -125,6 +125,16 @@ impl VirtualMachine {
     }
 }
 
+fn set_main_loader(module_dict: &PyDictRef, filename: &str, vm: &VirtualMachine) -> PyResult<()> {
+    vm.import("importlib.machinery", 0)?;
+    let sys_modules = vm.sys_module.get_attr(identifier!(vm, modules), vm)?;
+    let machinery = sys_modules.get_item("importlib.machinery", vm)?;
+    let loader_class = machinery.get_attr("SourceFileLoader", vm)?;
+    let loader = loader_class.call((identifier!(vm, __main__).to_owned(), filename), vm)?;
+    module_dict.set_item("__loader__", loader, vm)?;
+    Ok(())
+}
+
 fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
     let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
     let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;

From aae6bf566f0ef4de7beea473b1a73030834ddb16 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 11:00:53 +0900
Subject: [PATCH 059/418] Add tp_str (#6495)

* clean up hash

* __str__ slot wrapper
---
 Lib/test/test_inspect/test_inspect.py |  1 -
 crates/vm/src/builtins/descriptor.rs  | 13 +++++++++----
 crates/vm/src/builtins/object.rs      |  4 ++--
 crates/vm/src/class.rs                | 20 +++++---------------
 crates/vm/src/types/slot.rs           |  2 +-
 5 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index e403ab7b226..353d7c2e7b2 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -409,7 +409,6 @@ class NotFuture: pass
 
         coro.close(); gen_coro.close() # silence warnings
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_isroutine(self):
         # method
         self.assertTrue(inspect.isroutine(git.argue))
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index fcf40d0082d..297199eee18 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -399,6 +399,7 @@ pub fn init(ctx: &Context) {
 pub enum SlotFunc {
     Init(InitFunc),
     Hash(HashFunc),
+    Str(StringifyFunc),
     Repr(StringifyFunc),
     Iter(IterFunc),
     IterNext(IterNextFunc),
@@ -409,6 +410,7 @@ impl std::fmt::Debug for SlotFunc {
         match self {
             SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
             SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
+            SlotFunc::Str(_) => write!(f, "SlotFunc::Str(...)"),
             SlotFunc::Repr(_) => write!(f, "SlotFunc::Repr(...)"),
             SlotFunc::Iter(_) => write!(f, "SlotFunc::Iter(...)"),
             SlotFunc::IterNext(_) => write!(f, "SlotFunc::IterNext(...)"),
@@ -433,11 +435,14 @@ impl SlotFunc {
                 let hash = func(&obj, vm)?;
                 Ok(vm.ctx.new_int(hash).into())
             }
-            SlotFunc::Repr(func) => {
+            SlotFunc::Repr(func) | SlotFunc::Str(func) => {
                 if !args.args.is_empty() || !args.kwargs.is_empty() {
-                    return Err(
-                        vm.new_type_error("__repr__() takes no arguments (1 given)".to_owned())
-                    );
+                    let name = match self {
+                        SlotFunc::Repr(_) => "__repr__",
+                        SlotFunc::Str(_) => "__str__",
+                        _ => unreachable!(),
+                    };
+                    return Err(vm.new_type_error(format!("{name}() takes no arguments (1 given)")));
                 }
                 let s = func(&obj, vm)?;
                 Ok(s.into())
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 854cb2701ed..65a11d55314 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -425,8 +425,8 @@ impl PyBaseObject {
     }
 
     /// Return str(self).
-    #[pymethod]
-    fn __str__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    #[pyslot]
+    fn slot_str(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
         // FIXME: try tp_repr first and fallback to object.__repr__
         zelf.repr(vm)
     }
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 1addf00497d..40f01d98b00 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -165,25 +165,15 @@ pub trait PyClassImpl: PyClassDef {
             "Initialize self.  See help(type(self)) for accurate signature."
         );
         add_slot_wrapper!(repr, __repr__, Repr, "Return repr(self).");
+        add_slot_wrapper!(str, __str__, Str, "Return str(self).");
         add_slot_wrapper!(iter, __iter__, Iter, "Implement iter(self).");
         add_slot_wrapper!(iternext, __next__, IterNext, "Implement next(self).");
 
         // __hash__ needs special handling: hash_not_implemented sets __hash__ = None
-        if let Some(hash_func) = class.slots.hash.load() {
-            if hash_func as usize == hash_not_implemented as usize {
-                class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
-            } else {
-                let hash_name = identifier!(ctx, __hash__);
-                if !class.attributes.read().contains_key(hash_name) {
-                    let wrapper = PySlotWrapper {
-                        typ: class,
-                        name: ctx.intern_str("__hash__"),
-                        wrapped: SlotFunc::Hash(hash_func),
-                        doc: Some("Return hash(self)."),
-                    };
-                    class.set_attr(hash_name, wrapper.into_ref(ctx).into());
-                }
-            }
+        if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
+            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
+        } else {
+            add_slot_wrapper!(hash, __hash__, Hash, "Return hash(self).");
         }
 
         class.extend_methods(class.slots.methods, ctx);
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 26c059067e0..57ac24f461a 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -140,7 +140,7 @@ pub struct PyTypeSlots {
     // More standard operations (here for binary compatibility)
     pub hash: AtomicCell<Option<HashFunc>>,
     pub call: AtomicCell<Option<GenericMethod>>,
-    // tp_str
+    pub str: AtomicCell<Option<StringifyFunc>>,
     pub repr: AtomicCell<Option<StringifyFunc>>,
     pub getattro: AtomicCell<Option<GetattroFunc>>,
     pub setattro: AtomicCell<Option<SetattroFunc>>,

From 49dbbbd5b9990038bed3ee740255a56da8678492 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 13:28:50 +0900
Subject: [PATCH 060/418] Fix SSL test_preauth_data_to_tls_server (#6508)

---
 crates/stdlib/src/ssl/compat.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 45aa9c4fce9..fa12855e242 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -391,6 +391,8 @@ pub(super) enum SslError {
     ZeroReturn,
     /// Unexpected EOF without close_notify (protocol violation)
     Eof,
+    /// Non-TLS data received before handshake completed
+    PreauthData,
     /// Certificate verification error
     CertVerification(rustls::CertificateError),
     /// I/O error
@@ -562,6 +564,15 @@ impl SslError {
                 .upcast(),
             SslError::ZeroReturn => create_ssl_zero_return_error(vm).upcast(),
             SslError::Eof => create_ssl_eof_error(vm).upcast(),
+            SslError::PreauthData => {
+                // Non-TLS data received before handshake
+                Self::create_ssl_error_with_reason(
+                    vm,
+                    None,
+                    "before TLS handshake with data",
+                    "before TLS handshake with data",
+                )
+            }
             SslError::CertVerification(cert_err) => {
                 // Use the proper cert verification error creator
                 create_ssl_cert_verification_error(vm, &cert_err).expect("unlikely to happen")
@@ -1245,6 +1256,12 @@ pub(super) fn ssl_do_handshake(
                 }
             }
 
+            // InvalidMessage during handshake means non-TLS data was received
+            // before the handshake completed (e.g., HTTP request to TLS server)
+            if matches!(e, rustls::Error::InvalidMessage(_)) {
+                return Err(SslError::PreauthData);
+            }
+
             // Certificate verification errors are already handled by from_rustls
 
             return Err(SslError::from_rustls(e));

From 92acf339a1d6b30ea605fc3179b34d8c6b1fb381 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 13:31:29 +0900
Subject: [PATCH 061/418] fix pyexpat hang (#6507)

---
 crates/stdlib/src/pyexpat.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
index 699fa21852d..e96d6287489 100644
--- a/crates/stdlib/src/pyexpat.rs
+++ b/crates/stdlib/src/pyexpat.rs
@@ -102,7 +102,9 @@ mod _pyexpat {
     where
         T: IntoFuncArgs,
     {
-        handler.read().call(args, vm).ok();
+        // Clone the handler while holding the read lock, then release the lock
+        let handler = handler.read().clone();
+        handler.call(args, vm).ok();
     }
 
     #[pyclass]

From 8443b2c97e75af3ec14b6657cd40429ad0a78d99 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 14:54:44 +0900
Subject: [PATCH 062/418] Add POSIX shared memory module for multiprocessing on
 Unix (#6498)

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .cspell.json                               |  2 +
 crates/stdlib/src/lib.rs                   |  6 +++
 crates/stdlib/src/posixshmem.rs            | 48 ++++++++++++++++++++++
 extra_tests/snippets/builtin_posixshmem.py | 12 ++++++
 4 files changed, 68 insertions(+)
 create mode 100644 crates/stdlib/src/posixshmem.rs
 create mode 100644 extra_tests/snippets/builtin_posixshmem.py

diff --git a/.cspell.json b/.cspell.json
index 3bd06fc2032..89cde1ce775 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -124,6 +124,8 @@
     "wasi",
     "zelf",
     // unix
+    "posixshmem",
+    "shm",
     "CLOEXEC",
     "codeset",
     "endgrent",
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
index c9b5ca32b57..4b463e09c73 100644
--- a/crates/stdlib/src/lib.rs
+++ b/crates/stdlib/src/lib.rs
@@ -57,6 +57,8 @@ mod faulthandler;
 mod fcntl;
 #[cfg(not(target_arch = "wasm32"))]
 mod multiprocessing;
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+mod posixshmem;
 #[cfg(unix)]
 mod posixsubprocess;
 // libc is missing constants on redox
@@ -190,6 +192,10 @@ pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInit
         {
             "_posixsubprocess" => posixsubprocess::make_module,
         }
+        #[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+        {
+            "_posixshmem" => posixshmem::make_module,
+        }
         #[cfg(any(unix, windows))]
         {
             "mmap" => mmap::make_module,
diff --git a/crates/stdlib/src/posixshmem.rs b/crates/stdlib/src/posixshmem.rs
new file mode 100644
index 00000000000..2957f16792c
--- /dev/null
+++ b/crates/stdlib/src/posixshmem.rs
@@ -0,0 +1,48 @@
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+pub(crate) use _posixshmem::make_module;
+
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+#[pymodule]
+mod _posixshmem {
+    use std::ffi::CString;
+
+    use crate::{
+        common::os::errno_io_error,
+        vm::{
+            PyResult, VirtualMachine, builtins::PyStrRef, convert::IntoPyException,
+            function::OptionalArg,
+        },
+    };
+
+    #[pyfunction]
+    fn shm_open(
+        name: PyStrRef,
+        flags: libc::c_int,
+        mode: OptionalArg<libc::mode_t>,
+        vm: &VirtualMachine,
+    ) -> PyResult<libc::c_int> {
+        let name = CString::new(name.as_str()).map_err(|e| e.into_pyexception(vm))?;
+        let mode: libc::c_uint = mode.unwrap_or(0o600) as _;
+        #[cfg(target_os = "freebsd")]
+        let mode = mode.try_into().unwrap();
+        // SAFETY: `name` is a NUL-terminated string and `shm_open` does not write through it.
+        let fd = unsafe { libc::shm_open(name.as_ptr(), flags, mode) };
+        if fd == -1 {
+            Err(errno_io_error().into_pyexception(vm))
+        } else {
+            Ok(fd)
+        }
+    }
+
+    #[pyfunction]
+    fn shm_unlink(name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let name = CString::new(name.as_str()).map_err(|e| e.into_pyexception(vm))?;
+        // SAFETY: `name` is a valid NUL-terminated string and `shm_unlink` only reads it.
+        let ret = unsafe { libc::shm_unlink(name.as_ptr()) };
+        if ret == -1 {
+            Err(errno_io_error().into_pyexception(vm))
+        } else {
+            Ok(())
+        }
+    }
+}
diff --git a/extra_tests/snippets/builtin_posixshmem.py b/extra_tests/snippets/builtin_posixshmem.py
new file mode 100644
index 00000000000..38ace68d584
--- /dev/null
+++ b/extra_tests/snippets/builtin_posixshmem.py
@@ -0,0 +1,12 @@
+import os
+import sys
+
+if os.name != "posix":
+    sys.exit(0)
+
+import _posixshmem
+
+name = f"/rp_posixshmem_{os.getpid()}"
+fd = _posixshmem.shm_open(name, os.O_CREAT | os.O_EXCL | os.O_RDWR, 0o600)
+os.close(fd)
+_posixshmem.shm_unlink(name)

From 7eb0fe4984b8b5604f74a9319cdadb5ea1bd2489 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 15:49:44 +0900
Subject: [PATCH 063/418] Fix potential deadlock (#6509)

---
 crates/vm/src/builtins/classmethod.rs |  8 +++---
 crates/vm/src/builtins/property.rs    | 33 +++++++++++++-----------
 crates/vm/src/stdlib/functools.rs     | 36 +++++++++++++++++++--------
 3 files changed, 49 insertions(+), 28 deletions(-)

diff --git a/crates/vm/src/builtins/classmethod.rs b/crates/vm/src/builtins/classmethod.rs
index 911960bf691..21f1ae4ba10 100644
--- a/crates/vm/src/builtins/classmethod.rs
+++ b/crates/vm/src/builtins/classmethod.rs
@@ -57,11 +57,11 @@ impl GetDescriptor for PyClassMethod {
     ) -> PyResult {
         let (zelf, _obj) = Self::_unwrap(&zelf, obj, vm)?;
         let cls = cls.unwrap_or_else(|| _obj.class().to_owned().into());
-        let call_descr_get: PyResult<PyObjectRef> = zelf.callable.lock().get_attr("__get__", vm);
+        // Clone and release lock before calling Python code to prevent deadlock
+        let callable = zelf.callable.lock().clone();
+        let call_descr_get: PyResult<PyObjectRef> = callable.get_attr("__get__", vm);
         match call_descr_get {
-            Err(_) => Ok(PyBoundMethod::new(cls, zelf.callable.lock().clone())
-                .into_ref(&vm.ctx)
-                .into()),
+            Err(_) => Ok(PyBoundMethod::new(cls, callable).into_ref(&vm.ctx).into()),
             Ok(call_descr_get) => call_descr_get.call((cls.clone(), cls), vm),
         }
     }
diff --git a/crates/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
index 41b05a60049..7ea36d39768 100644
--- a/crates/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -55,7 +55,8 @@ impl GetDescriptor for PyProperty {
         let (zelf, obj) = Self::_unwrap(&zelf_obj, obj, vm)?;
         if vm.is_none(&obj) {
             Ok(zelf_obj)
-        } else if let Some(getter) = zelf.getter.read().as_ref() {
+        } else if let Some(getter) = zelf.getter.read().clone() {
+            // Clone and release lock before calling Python code to prevent deadlock
             getter.call((obj,), vm)
         } else {
             let error_msg = zelf.format_property_error(&obj, "getter", vm)?;
@@ -70,12 +71,12 @@ impl PyProperty {
     // Returns the name if available, None if not found, or propagates errors
     fn get_property_name(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
         // First check if name was set via __set_name__
-        if let Some(name) = self.name.read().as_ref() {
-            return Ok(Some(name.clone()));
+        if let Some(name) = self.name.read().clone() {
+            return Ok(Some(name));
         }
 
-        let getter = self.getter.read();
-        let Some(getter) = getter.as_ref() else {
+        // Clone and release lock before calling Python code to prevent deadlock
+        let Some(getter) = self.getter.read().clone() else {
             return Ok(None);
         };
 
@@ -105,7 +106,8 @@ impl PyProperty {
         let zelf = zelf.try_to_ref::<Self>(vm)?;
         match value {
             PySetterValue::Assign(value) => {
-                if let Some(setter) = zelf.setter.read().as_ref() {
+                // Clone and release lock before calling Python code to prevent deadlock
+                if let Some(setter) = zelf.setter.read().clone() {
                     setter.call((obj, value), vm).map(drop)
                 } else {
                     let error_msg = zelf.format_property_error(&obj, "setter", vm)?;
@@ -113,7 +115,8 @@ impl PyProperty {
                 }
             }
             PySetterValue::Delete => {
-                if let Some(deleter) = zelf.deleter.read().as_ref() {
+                // Clone and release lock before calling Python code to prevent deadlock
+                if let Some(deleter) = zelf.deleter.read().clone() {
                     deleter.call((obj,), vm).map(drop)
                 } else {
                     let error_msg = zelf.format_property_error(&obj, "deleter", vm)?;
@@ -273,23 +276,24 @@ impl PyProperty {
             }
         };
 
+        // Clone and release lock before calling Python code to prevent deadlock
         // Check getter
-        if let Some(getter) = self.getter.read().as_ref()
-            && is_abstract(getter)?
+        if let Some(getter) = self.getter.read().clone()
+            && is_abstract(&getter)?
         {
             return Ok(vm.ctx.new_bool(true).into());
         }
 
         // Check setter
-        if let Some(setter) = self.setter.read().as_ref()
-            && is_abstract(setter)?
+        if let Some(setter) = self.setter.read().clone()
+            && is_abstract(&setter)?
         {
             return Ok(vm.ctx.new_bool(true).into());
         }
 
         // Check deleter
-        if let Some(deleter) = self.deleter.read().as_ref()
-            && is_abstract(deleter)?
+        if let Some(deleter) = self.deleter.read().clone()
+            && is_abstract(&deleter)?
         {
             return Ok(vm.ctx.new_bool(true).into());
         }
@@ -299,7 +303,8 @@ impl PyProperty {
 
     #[pygetset(setter)]
     fn set___isabstractmethod__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(getter) = self.getter.read().to_owned() {
+        // Clone and release lock before calling Python code to prevent deadlock
+        if let Some(getter) = self.getter.read().clone() {
             getter.set_attr("__isabstractmethod__", value, vm)?;
         }
         Ok(())
diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index 26dff8b4426..77f352c78fc 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -248,15 +248,24 @@ mod _functools {
         type Args = FuncArgs;
 
         fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let inner = zelf.inner.read();
-            let mut combined_args = inner.args.as_slice().to_vec();
+            // Clone and release lock before calling Python code to prevent deadlock
+            let (func, stored_args, keywords) = {
+                let inner = zelf.inner.read();
+                (
+                    inner.func.clone(),
+                    inner.args.clone(),
+                    inner.keywords.clone(),
+                )
+            };
+
+            let mut combined_args = stored_args.as_slice().to_vec();
             combined_args.extend_from_slice(&args.args);
 
             // Merge keywords from self.keywords and args.kwargs
             let mut final_kwargs = IndexMap::new();
 
             // Add keywords from self.keywords
-            for (key, value) in &*inner.keywords {
+            for (key, value) in &*keywords {
                 let key_str = key
                     .downcast::<crate::builtins::PyStr>()
                     .map_err(|_| vm.new_type_error("keywords must be strings"))?;
@@ -268,9 +277,7 @@ mod _functools {
                 final_kwargs.insert(key, value);
             }
 
-            inner
-                .func
-                .call(FuncArgs::new(combined_args, KwArgs::new(final_kwargs)), vm)
+            func.call(FuncArgs::new(combined_args, KwArgs::new(final_kwargs)), vm)
         }
     }
 
@@ -280,15 +287,24 @@ mod _functools {
             // Check for recursive repr
             let obj = zelf.as_object();
             if let Some(_guard) = ReprGuard::enter(vm, obj) {
-                let inner = zelf.inner.read();
-                let func_repr = inner.func.repr(vm)?;
+                // Clone and release lock before calling Python code to prevent deadlock
+                let (func, args, keywords) = {
+                    let inner = zelf.inner.read();
+                    (
+                        inner.func.clone(),
+                        inner.args.clone(),
+                        inner.keywords.clone(),
+                    )
+                };
+
+                let func_repr = func.repr(vm)?;
                 let mut parts = vec![func_repr.as_str().to_owned()];
 
-                for arg in inner.args.as_slice() {
+                for arg in args.as_slice() {
                     parts.push(arg.repr(vm)?.as_str().to_owned());
                 }
 
-                for (key, value) in inner.keywords.clone() {
+                for (key, value) in &*keywords {
                     // For string keys, use them directly without quotes
                     let key_part = if let Ok(s) = key.clone().downcast::<crate::builtins::PyStr>() {
                         s.as_str().to_owned()

From aaecdd17470b17994a1a090be036db99fce005e6 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 16:55:19 +0900
Subject: [PATCH 064/418] repr for getset (#6514)

---
 crates/vm/src/builtins/getset.rs | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
index f56191f5f8b..3fa4667a997 100644
--- a/crates/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -7,7 +7,7 @@ use crate::{
     builtins::type_::PointerSlot,
     class::PyClassImpl,
     function::{IntoPyGetterFunc, IntoPySetterFunc, PyGetterFunc, PySetterFunc, PySetterValue},
-    types::GetDescriptor,
+    types::{GetDescriptor, Representable},
 };
 
 #[pyclass(module = false, name = "getset_descriptor")]
@@ -96,7 +96,7 @@ impl PyGetSet {
     }
 }
 
-#[pyclass(flags(DISALLOW_INSTANTIATION), with(GetDescriptor))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(GetDescriptor, Representable))]
 impl PyGetSet {
     // Descriptor methods
 
@@ -153,6 +153,23 @@ impl PyGetSet {
     }
 }
 
+impl Representable for PyGetSet {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let class = unsafe { zelf.class.borrow_static() };
+        // Special case for object type
+        if std::ptr::eq(class, vm.ctx.types.object_type) {
+            Ok(format!("<attribute '{}'>", zelf.name))
+        } else {
+            Ok(format!(
+                "<attribute '{}' of '{}' objects>",
+                zelf.name,
+                class.name()
+            ))
+        }
+    }
+}
+
 pub(crate) fn init(context: &Context) {
     PyGetSet::extend_class(context, context.types.getset_type);
 }

From 151f0746a3e4130d060879f69731b74585e21f38 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 16:56:41 +0900
Subject: [PATCH 065/418] Implement copyslot (#6505)

---
 Lib/test/test_typing.py                  |   1 -
 crates/stdlib/src/sqlite.rs              |   4 +-
 crates/vm/src/builtins/bool.rs           |   2 +-
 crates/vm/src/builtins/classmethod.rs    |   2 +-
 crates/vm/src/builtins/dict.rs           |   4 +-
 crates/vm/src/builtins/iter.rs           |  18 +-
 crates/vm/src/builtins/list.rs           |   6 +-
 crates/vm/src/builtins/mappingproxy.rs   |  10 +-
 crates/vm/src/builtins/object.rs         |   5 +-
 crates/vm/src/builtins/type.rs           | 226 ++++++++++++++++++-----
 crates/vm/src/builtins/weakproxy.rs      |   4 +-
 crates/vm/src/class.rs                   |   5 +
 crates/vm/src/frame.rs                   |   2 +-
 crates/vm/src/function/protocol.rs       |  40 ++--
 crates/vm/src/object/core.rs             |   2 +-
 crates/vm/src/protocol/buffer.rs         |   3 +-
 crates/vm/src/protocol/callable.rs       |   2 +-
 crates/vm/src/protocol/iter.rs           |  34 ++--
 crates/vm/src/protocol/mapping.rs        |  92 +++++----
 crates/vm/src/protocol/mod.rs            |   4 +-
 crates/vm/src/protocol/number.rs         | 219 ++++++++++------------
 crates/vm/src/protocol/object.rs         |  92 ++++-----
 crates/vm/src/protocol/sequence.rs       | 141 +++++++++-----
 crates/vm/src/stdlib/builtins.rs         |   2 +-
 crates/vm/src/stdlib/ctypes/structure.rs |   2 +-
 crates/vm/src/stdlib/ctypes/union.rs     |   2 +-
 crates/vm/src/stdlib/typing.rs           |   7 +-
 crates/vm/src/types/slot.rs              | 125 ++++++++-----
 crates/vm/src/types/structseq.rs         |  25 +--
 crates/vm/src/types/zoo.rs               |   1 +
 crates/vm/src/vm/method.rs               |   8 +-
 crates/vm/src/vm/vm_object.rs            |   4 +-
 crates/vm/src/vm/vm_ops.rs               |  40 ++--
 33 files changed, 648 insertions(+), 486 deletions(-)

diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index db0dc916f1a..74ab94eb5c3 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -10496,7 +10496,6 @@ class CustomerModel(ModelBase, init=False):
 
 
 class NoDefaultTests(BaseTestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             s = pickle.dumps(NoDefault, proto)
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index 2328f23430a..c760c2830d7 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -488,7 +488,7 @@ mod _sqlite {
                 let text2 = vm.ctx.new_str(text2);
 
                 let val = callable.call((text1, text2), vm)?;
-                let Some(val) = val.to_number().index(vm) else {
+                let Some(val) = val.number().index(vm) else {
                     return Ok(0);
                 };
 
@@ -2980,7 +2980,7 @@ mod _sqlite {
         fn bind_parameters(self, parameters: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
             if let Some(dict) = parameters.downcast_ref::<PyDict>() {
                 self.bind_parameters_name(dict, vm)
-            } else if let Ok(seq) = PySequence::try_protocol(parameters, vm) {
+            } else if let Ok(seq) = parameters.try_sequence(vm) {
                 self.bind_parameters_sequence(seq, vm)
             } else {
                 Err(new_programming_error(
diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
index 6b3ddd8241a..8fee4af3834 100644
--- a/crates/vm/src/builtins/bool.rs
+++ b/crates/vm/src/builtins/bool.rs
@@ -43,7 +43,7 @@ impl PyObjectRef {
             return Ok(false);
         }
         let rs_bool = if let Some(nb_bool) = self.class().slots.as_number.boolean.load() {
-            nb_bool(self.as_object().to_number(), vm)?
+            nb_bool(self.as_object().number(), vm)?
         } else {
             // TODO: Fully implement AsNumber and remove this block
             match vm.get_method(self.clone(), identifier!(vm, __bool__)) {
diff --git a/crates/vm/src/builtins/classmethod.rs b/crates/vm/src/builtins/classmethod.rs
index 21f1ae4ba10..5b7f9218658 100644
--- a/crates/vm/src/builtins/classmethod.rs
+++ b/crates/vm/src/builtins/classmethod.rs
@@ -124,7 +124,7 @@ impl PyClassMethod {
 }
 
 #[pyclass(
-    with(GetDescriptor, Constructor, Representable),
+    with(GetDescriptor, Constructor, Initializer, Representable),
     flags(BASETYPE, HAS_DICT)
 )]
 impl PyClassMethod {
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index aff7432d067..567e18d6419 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -1145,7 +1145,7 @@ impl ViewSetOps for PyDictKeys {}
 impl PyDictKeys {
     #[pymethod]
     fn __contains__(zelf: PyObjectRef, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        zelf.to_sequence().contains(&key, vm)
+        zelf.sequence_unchecked().contains(&key, vm)
     }
 
     #[pygetset]
@@ -1210,7 +1210,7 @@ impl ViewSetOps for PyDictItems {}
 impl PyDictItems {
     #[pymethod]
     fn __contains__(zelf: PyObjectRef, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        zelf.to_sequence().contains(&needle, vm)
+        zelf.sequence_unchecked().contains(&needle, vm)
     }
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
diff --git a/crates/vm/src/builtins/iter.rs b/crates/vm/src/builtins/iter.rs
index 56dfc14d164..736303e95ee 100644
--- a/crates/vm/src/builtins/iter.rs
+++ b/crates/vm/src/builtins/iter.rs
@@ -8,7 +8,7 @@ use crate::{
     class::PyClassImpl,
     function::ArgCallable,
     object::{Traverse, TraverseFn},
-    protocol::{PyIterReturn, PySequence, PySequenceMethods},
+    protocol::PyIterReturn,
     types::{IterNext, Iterable, SelfIter},
 };
 use rustpython_common::{
@@ -177,9 +177,6 @@ pub fn builtins_reversed(vm: &VirtualMachine) -> &PyObject {
 #[pyclass(module = false, name = "iterator", traverse)]
 #[derive(Debug)]
 pub struct PySequenceIterator {
-    // cached sequence methods
-    #[pytraverse(skip)]
-    seq_methods: &'static PySequenceMethods,
     internal: PyMutex<PositionIterInternal<PyObjectRef>>,
 }
 
@@ -193,9 +190,8 @@ impl PyPayload for PySequenceIterator {
 #[pyclass(with(IterNext, Iterable))]
 impl PySequenceIterator {
     pub fn new(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
-        let seq = PySequence::try_protocol(&obj, vm)?;
+        let _seq = obj.try_sequence(vm)?;
         Ok(Self {
-            seq_methods: seq.methods,
             internal: PyMutex::new(PositionIterInternal::new(obj, 0)),
         })
     }
@@ -204,10 +200,7 @@ impl PySequenceIterator {
     fn __length_hint__(&self, vm: &VirtualMachine) -> PyObjectRef {
         let internal = self.internal.lock();
         if let IterStatus::Active(obj) = &internal.status {
-            let seq = PySequence {
-                obj,
-                methods: self.seq_methods,
-            };
+            let seq = obj.sequence_unchecked();
             seq.length(vm)
                 .map(|x| PyInt::from(x).into_pyobject(vm))
                 .unwrap_or_else(|_| vm.ctx.not_implemented())
@@ -231,10 +224,7 @@ impl SelfIter for PySequenceIterator {}
 impl IterNext for PySequenceIterator {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
         zelf.internal.lock().next(|obj, pos| {
-            let seq = PySequence {
-                obj,
-                methods: zelf.seq_methods,
-            };
+            let seq = obj.sequence_unchecked();
             PyIterReturn::from_getitem_result(seq.get_item(pos as isize, vm), vm)
         })
     }
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 13e8864cd1f..12cab27a750 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -354,7 +354,11 @@ where
     } else {
         let iter = obj.to_owned().get_iter(vm)?;
         let iter = iter.iter::<PyObjectRef>(vm)?;
-        let len = obj.to_sequence().length_opt(vm).transpose()?.unwrap_or(0);
+        let len = obj
+            .sequence_unchecked()
+            .length_opt(vm)
+            .transpose()?
+            .unwrap_or(0);
         let mut v = Vec::with_capacity(len);
         for x in iter {
             v.push(f(x?)?);
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index fb8ff5de9cc..475f36cb5a9 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -6,7 +6,7 @@ use crate::{
     convert::ToPyObject,
     function::{ArgMapping, OptionalArg, PyComparisonValue},
     object::{Traverse, TraverseFn},
-    protocol::{PyMapping, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    protocol::{PyMappingMethods, PyNumberMethods, PySequenceMethods},
     types::{
         AsMapping, AsNumber, AsSequence, Comparable, Constructor, Iterable, PyComparisonOp,
         Representable,
@@ -62,14 +62,12 @@ impl Constructor for PyMappingProxy {
     type Args = PyObjectRef;
 
     fn py_new(_cls: &Py<PyType>, mapping: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-        if let Some(methods) = PyMapping::find_methods(&mapping)
+        if mapping.mapping_unchecked().check()
             && !mapping.downcastable::<PyList>()
             && !mapping.downcastable::<PyTuple>()
         {
             return Ok(Self {
-                mapping: MappingProxyInner::Mapping(ArgMapping::with_methods(mapping, unsafe {
-                    methods.borrow_static()
-                })),
+                mapping: MappingProxyInner::Mapping(ArgMapping::new(mapping)),
             });
         }
         Err(vm.new_type_error(format!(
@@ -124,7 +122,7 @@ impl PyMappingProxy {
             MappingProxyInner::Class(class) => Ok(key
                 .as_interned_str(vm)
                 .is_some_and(|key| class.attributes.read().contains_key(key))),
-            MappingProxyInner::Mapping(mapping) => mapping.to_sequence().contains(key, vm),
+            MappingProxyInner::Mapping(mapping) => mapping.sequence_unchecked().contains(key, vm),
         }
     }
 
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 65a11d55314..ca208790f4b 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -320,10 +320,7 @@ impl PyBaseObject {
                 }
             }
             PyComparisonOp::Ne => {
-                let cmp = zelf
-                    .class()
-                    .mro_find_map(|cls| cls.slots.richcompare.load())
-                    .unwrap();
+                let cmp = zelf.class().slots.richcompare.load().unwrap();
                 let value = match cmp(zelf, other, PyComparisonOp::Eq, vm)? {
                     Either::A(obj) => PyArithmeticValue::from_object(vm, obj)
                         .map(|obj| obj.try_to_bool(vm))
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 68de17f60b6..c2373f26faf 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -23,7 +23,7 @@ use crate::{
     convert::ToPyResult,
     function::{FuncArgs, KwArgs, OptionalArg, PyMethodDef, PySetterValue},
     object::{Traverse, TraverseFn},
-    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    protocol::{PyIterReturn, PyNumberMethods},
     types::{
         AsNumber, Callable, Constructor, GetAttr, PyTypeFlags, PyTypeSlots, Representable, SetAttr,
         TypeDataRef, TypeDataRefMut, TypeDataSlot,
@@ -64,8 +64,6 @@ pub struct HeapTypeExt {
     pub name: PyRwLock<PyStrRef>,
     pub qualname: PyRwLock<PyStrRef>,
     pub slots: Option<PyRef<PyTuple<PyStrRef>>>,
-    pub sequence_methods: PySequenceMethods,
-    pub mapping_methods: PyMappingMethods,
     pub type_data: PyRwLock<Option<TypeDataSlot>>,
 }
 
@@ -100,17 +98,6 @@ impl<T> AsRef<T> for PointerSlot<T> {
     }
 }
 
-impl<T> PointerSlot<T> {
-    pub unsafe fn from_heaptype<F>(typ: &PyType, f: F) -> Option<Self>
-    where
-        F: FnOnce(&HeapTypeExt) -> &T,
-    {
-        typ.heaptype_ext
-            .as_ref()
-            .map(|ext| Self(NonNull::from(f(ext))))
-    }
-}
-
 pub type PyTypeRef = PyRef<PyType>;
 
 cfg_if::cfg_if! {
@@ -206,8 +193,6 @@ impl PyType {
             name: PyRwLock::new(name.clone()),
             qualname: PyRwLock::new(name),
             slots: None,
-            sequence_methods: PySequenceMethods::default(),
-            mapping_methods: PyMappingMethods::default(),
             type_data: PyRwLock::new(None),
         };
         let base = bases[0].clone();
@@ -331,6 +316,8 @@ impl PyType {
             slots.basicsize = base.slots.basicsize;
         }
 
+        Self::inherit_readonly_slots(&mut slots, &base);
+
         if let Some(qualname) = attrs.get(identifier!(ctx, __qualname__))
             && !qualname.fast_isinstance(ctx.types.str_type)
         {
@@ -387,6 +374,8 @@ impl PyType {
             slots.basicsize = base.slots.basicsize;
         }
 
+        Self::inherit_readonly_slots(&mut slots, &base);
+
         let bases = PyRwLock::new(vec![base.clone()]);
         let mro = base.mro_map_collect(|x| x.to_owned());
 
@@ -404,6 +393,9 @@ impl PyType {
             None,
         );
 
+        // Note: inherit_slots is called in PyClassImpl::init_class after
+        // slots are fully initialized by make_slots()
+
         Self::set_new(&new_type.slots, &new_type.base);
 
         let weakref_type = super::PyWeak::static_type();
@@ -420,6 +412,12 @@ impl PyType {
     }
 
     pub(crate) fn init_slots(&self, ctx: &Context) {
+        // Inherit slots from direct bases (not MRO)
+        for base in self.bases.read().iter() {
+            self.inherit_slots(base);
+        }
+
+        // Wire dunder methods to slots
         #[allow(clippy::mutable_key_type)]
         let mut slot_name_set = std::collections::HashSet::new();
 
@@ -454,6 +452,164 @@ impl PyType {
         }
     }
 
+    /// Inherit readonly slots from base type at creation time.
+    /// These slots are not AtomicCell and must be set before the type is used.
+    fn inherit_readonly_slots(slots: &mut PyTypeSlots, base: &Self) {
+        if slots.as_buffer.is_none() {
+            slots.as_buffer = base.slots.as_buffer;
+        }
+    }
+
+    /// Inherit slots from base type. typeobject.c: inherit_slots
+    pub(crate) fn inherit_slots(&self, base: &Self) {
+        macro_rules! copyslot {
+            ($slot:ident) => {
+                if self.slots.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.$slot.load() {
+                        self.slots.$slot.store(Some(base_val));
+                    }
+                }
+            };
+        }
+
+        // Core slots
+        copyslot!(hash);
+        copyslot!(call);
+        copyslot!(str);
+        copyslot!(repr);
+        copyslot!(getattro);
+        copyslot!(setattro);
+        copyslot!(richcompare);
+        copyslot!(iter);
+        copyslot!(iternext);
+        copyslot!(descr_get);
+        copyslot!(descr_set);
+        // Note: init is NOT inherited here because object_init has special
+        // handling in CPython (checks if type->tp_init != object_init).
+        // TODO: implement proper init inheritance with object_init check
+        copyslot!(del);
+        // new is handled by set_new()
+        // as_buffer is inherited at type creation time (not AtomicCell)
+
+        // Sub-slots (number, sequence, mapping)
+        self.inherit_number_slots(base);
+        self.inherit_sequence_slots(base);
+        self.inherit_mapping_slots(base);
+    }
+
+    /// Inherit number sub-slots from base type
+    fn inherit_number_slots(&self, base: &Self) {
+        macro_rules! copy_num_slot {
+            ($slot:ident) => {
+                if self.slots.as_number.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_number.$slot.load() {
+                        self.slots.as_number.$slot.store(Some(base_val));
+                    }
+                }
+            };
+        }
+
+        // Binary operations
+        copy_num_slot!(add);
+        copy_num_slot!(right_add);
+        copy_num_slot!(inplace_add);
+        copy_num_slot!(subtract);
+        copy_num_slot!(right_subtract);
+        copy_num_slot!(inplace_subtract);
+        copy_num_slot!(multiply);
+        copy_num_slot!(right_multiply);
+        copy_num_slot!(inplace_multiply);
+        copy_num_slot!(remainder);
+        copy_num_slot!(right_remainder);
+        copy_num_slot!(inplace_remainder);
+        copy_num_slot!(divmod);
+        copy_num_slot!(right_divmod);
+        copy_num_slot!(power);
+        copy_num_slot!(right_power);
+        copy_num_slot!(inplace_power);
+
+        // Bitwise operations
+        copy_num_slot!(lshift);
+        copy_num_slot!(right_lshift);
+        copy_num_slot!(inplace_lshift);
+        copy_num_slot!(rshift);
+        copy_num_slot!(right_rshift);
+        copy_num_slot!(inplace_rshift);
+        copy_num_slot!(and);
+        copy_num_slot!(right_and);
+        copy_num_slot!(inplace_and);
+        copy_num_slot!(xor);
+        copy_num_slot!(right_xor);
+        copy_num_slot!(inplace_xor);
+        copy_num_slot!(or);
+        copy_num_slot!(right_or);
+        copy_num_slot!(inplace_or);
+
+        // Division operations
+        copy_num_slot!(floor_divide);
+        copy_num_slot!(right_floor_divide);
+        copy_num_slot!(inplace_floor_divide);
+        copy_num_slot!(true_divide);
+        copy_num_slot!(right_true_divide);
+        copy_num_slot!(inplace_true_divide);
+
+        // Matrix multiplication
+        copy_num_slot!(matrix_multiply);
+        copy_num_slot!(right_matrix_multiply);
+        copy_num_slot!(inplace_matrix_multiply);
+
+        // Unary operations
+        copy_num_slot!(negative);
+        copy_num_slot!(positive);
+        copy_num_slot!(absolute);
+        copy_num_slot!(boolean);
+        copy_num_slot!(invert);
+
+        // Conversion
+        copy_num_slot!(int);
+        copy_num_slot!(float);
+        copy_num_slot!(index);
+    }
+
+    /// Inherit sequence sub-slots from base type
+    fn inherit_sequence_slots(&self, base: &Self) {
+        macro_rules! copy_seq_slot {
+            ($slot:ident) => {
+                if self.slots.as_sequence.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_sequence.$slot.load() {
+                        self.slots.as_sequence.$slot.store(Some(base_val));
+                    }
+                }
+            };
+        }
+
+        copy_seq_slot!(length);
+        copy_seq_slot!(concat);
+        copy_seq_slot!(repeat);
+        copy_seq_slot!(item);
+        copy_seq_slot!(ass_item);
+        copy_seq_slot!(contains);
+        copy_seq_slot!(inplace_concat);
+        copy_seq_slot!(inplace_repeat);
+    }
+
+    /// Inherit mapping sub-slots from base type
+    fn inherit_mapping_slots(&self, base: &Self) {
+        macro_rules! copy_map_slot {
+            ($slot:ident) => {
+                if self.slots.as_mapping.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_mapping.$slot.load() {
+                        self.slots.as_mapping.$slot.store(Some(base_val));
+                    }
+                }
+            };
+        }
+
+        copy_map_slot!(length);
+        copy_map_slot!(subscript);
+        copy_map_slot!(ass_subscript);
+    }
+
     // This is used for class initialization where the vm is not yet available.
     pub fn set_str_attr<V: Into<PyObjectRef>>(
         &self,
@@ -663,19 +819,6 @@ impl Py<PyType> {
             .collect()
     }
 
-    pub(crate) fn mro_find_map<F, R>(&self, f: F) -> Option<R>
-    where
-        F: Fn(&Self) -> Option<R>,
-    {
-        // the hot path will be primitive types which usually hit the result from itself.
-        // try std::intrinsics::likely once it is stabilized
-        if let Some(r) = f(self) {
-            Some(r)
-        } else {
-            self.mro.read().iter().find_map(|cls| f(cls))
-        }
-    }
-
     pub fn iter_base_chain(&self) -> impl Iterator<Item = &Self> {
         std::iter::successors(Some(self), |cls| cls.base.as_deref())
     }
@@ -1228,8 +1371,6 @@ impl Constructor for PyType {
                 name: PyRwLock::new(name),
                 qualname: PyRwLock::new(qualname),
                 slots: heaptype_slots.clone(),
-                sequence_methods: PySequenceMethods::default(),
-                mapping_methods: PyMappingMethods::default(),
                 type_data: PyRwLock::new(None),
             };
             (slots, heaptype_ext)
@@ -1414,11 +1555,9 @@ impl GetAttr for PyType {
 
         if let Some(ref attr) = mcl_attr {
             let attr_class = attr.class();
-            let has_descr_set = attr_class
-                .mro_find_map(|cls| cls.slots.descr_set.load())
-                .is_some();
+            let has_descr_set = attr_class.slots.descr_set.load().is_some();
             if has_descr_set {
-                let descr_get = attr_class.mro_find_map(|cls| cls.slots.descr_get.load());
+                let descr_get = attr_class.slots.descr_get.load();
                 if let Some(descr_get) = descr_get {
                     let mcl = mcl.to_owned().into();
                     return descr_get(attr.clone(), Some(zelf.to_owned().into()), Some(mcl), vm);
@@ -1429,7 +1568,7 @@ impl GetAttr for PyType {
         let zelf_attr = zelf.get_attr(name);
 
         if let Some(attr) = zelf_attr {
-            let descr_get = attr.class().mro_find_map(|cls| cls.slots.descr_get.load());
+            let descr_get = attr.class().slots.descr_get.load();
             if let Some(descr_get) = descr_get {
                 descr_get(attr, None, Some(zelf.to_owned().into()), vm)
             } else {
@@ -1467,9 +1606,7 @@ impl Py<PyType> {
         // CPython returns None if __doc__ is not in the type's own dict
         if let Some(doc_attr) = self.get_direct_attr(vm.ctx.intern_str("__doc__")) {
             // If it's a descriptor, call its __get__ method
-            let descr_get = doc_attr
-                .class()
-                .mro_find_map(|cls| cls.slots.descr_get.load());
+            let descr_get = doc_attr.class().slots.descr_get.load();
             if let Some(descr_get) = descr_get {
                 descr_get(doc_attr, None, Some(self.to_owned().into()), vm)
             } else {
@@ -1545,7 +1682,7 @@ impl SetAttr for PyType {
         // TODO: pass PyRefExact instead of &str
         let attr_name = vm.ctx.intern_str(attr_name.as_str());
         if let Some(attr) = zelf.get_class_attr(attr_name) {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            let descr_set = attr.class().slots.descr_set.load();
             if let Some(descriptor) = descr_set {
                 return descriptor(&attr, zelf.to_owned().into(), value, vm);
             }
@@ -1702,7 +1839,9 @@ fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -
             // Call the descriptor's tp_descr_set
             let descr_set = descr
                 .class()
-                .mro_find_map(|cls| cls.slots.descr_set.load())
+                .slots
+                .descr_set
+                .load()
                 .ok_or_else(|| raise_dict_descriptor_error(&obj, vm))?;
             descr_set(&descr, obj, PySetterValue::Assign(value), vm)
         } else {
@@ -1764,8 +1903,9 @@ pub(crate) fn call_slot_new(
     }
 
     let slot_new = typ
-        .deref()
-        .mro_find_map(|cls| cls.slots.new.load())
+        .slots
+        .new
+        .load()
         .expect("Should be able to find a new slot somewhere in the mro");
     slot_new(subtype, args, vm)
 }
diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
index 6e0e8308dbc..94c54b5459e 100644
--- a/crates/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -104,7 +104,9 @@ impl PyWeakProxy {
     }
     #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.try_upgrade(vm)?.to_sequence().contains(&needle, vm)
+        self.try_upgrade(vm)?
+            .sequence_unchecked()
+            .contains(&needle, vm)
     }
 
     fn getitem(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 40f01d98b00..da860a96289 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -176,6 +176,11 @@ pub trait PyClassImpl: PyClassDef {
             add_slot_wrapper!(hash, __hash__, Hash, "Return hash(self).");
         }
 
+        // Inherit slots from base types after slots are fully initialized
+        for base in class.bases.read().iter() {
+            class.inherit_slots(base);
+        }
+
         class.extend_methods(class.slots.methods, ctx);
     }
 
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index ad50f972aef..d9cc404b47a 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1900,7 +1900,7 @@ impl ExecutingFrame<'_> {
 
         // TODO: It was PyMethod before #4873. Check if it's correct.
         let func = if is_method {
-            if let Some(descr_get) = func.class().mro_find_map(|cls| cls.slots.descr_get.load()) {
+            if let Some(descr_get) = func.class().slots.descr_get.load() {
                 let cls = target.class().to_owned().into();
                 descr_get(func, Some(target), Some(cls), vm)?
             } else {
diff --git a/crates/vm/src/function/protocol.rs b/crates/vm/src/function/protocol.rs
index 1e670b96389..a87ef339edd 100644
--- a/crates/vm/src/function/protocol.rs
+++ b/crates/vm/src/function/protocol.rs
@@ -1,11 +1,11 @@
 use super::IntoFuncArgs;
 use crate::{
     AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyDict, PyDictRef, iter::PySequenceIterator},
+    builtins::{PyDictRef, iter::PySequenceIterator},
     convert::ToPyObject,
     object::{Traverse, TraverseFn},
-    protocol::{PyIter, PyIterIter, PyMapping, PyMappingMethods},
-    types::{AsMapping, GenericMethod},
+    protocol::{PyIter, PyIterIter, PyMapping},
+    types::GenericMethod,
 };
 use std::{borrow::Borrow, marker::PhantomData, ops::Deref};
 
@@ -104,14 +104,11 @@ where
     T: TryFromObject,
 {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let iter_fn = {
-            let cls = obj.class();
-            let iter_fn = cls.mro_find_map(|x| x.slots.iter.load());
-            if iter_fn.is_none() && !cls.has_attr(identifier!(vm, __getitem__)) {
-                return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
-            }
-            iter_fn
-        };
+        let cls = obj.class();
+        let iter_fn = cls.slots.iter.load();
+        if iter_fn.is_none() && !cls.has_attr(identifier!(vm, __getitem__)) {
+            return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
+        }
         Ok(Self {
             iterable: obj,
             iter_fn,
@@ -123,30 +120,22 @@ where
 #[derive(Debug, Clone, Traverse)]
 pub struct ArgMapping {
     obj: PyObjectRef,
-    #[pytraverse(skip)]
-    methods: &'static PyMappingMethods,
 }
 
 impl ArgMapping {
     #[inline]
-    pub const fn with_methods(obj: PyObjectRef, methods: &'static PyMappingMethods) -> Self {
-        Self { obj, methods }
+    pub const fn new(obj: PyObjectRef) -> Self {
+        Self { obj }
     }
 
     #[inline(always)]
     pub fn from_dict_exact(dict: PyDictRef) -> Self {
-        Self {
-            obj: dict.into(),
-            methods: PyDict::as_mapping(),
-        }
+        Self { obj: dict.into() }
     }
 
     #[inline(always)]
     pub fn mapping(&self) -> PyMapping<'_> {
-        PyMapping {
-            obj: &self.obj,
-            methods: self.methods,
-        }
+        self.obj.mapping_unchecked()
     }
 }
 
@@ -188,9 +177,8 @@ impl ToPyObject for ArgMapping {
 
 impl TryFromObject for ArgMapping {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let mapping = PyMapping::try_protocol(&obj, vm)?;
-        let methods = mapping.methods;
-        Ok(Self { obj, methods })
+        let _mapping = obj.try_mapping(vm)?;
+        Ok(Self { obj })
     }
 }
 
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index 60b623ef3ed..a092d7097be 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -810,7 +810,7 @@ impl PyObject {
         }
 
         // CPython-compatible drop implementation
-        let del = self.class().mro_find_map(|cls| cls.slots.del.load());
+        let del = self.class().slots.del.load();
         if let Some(slot_del) = del {
             call_slot_del(self, slot_del)?;
         }
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
index 0a34af59080..88524a9a9ee 100644
--- a/crates/vm/src/protocol/buffer.rs
+++ b/crates/vm/src/protocol/buffer.rs
@@ -143,8 +143,7 @@ impl PyBuffer {
 impl<'a> TryFromBorrowedObject<'a> for PyBuffer {
     fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
         let cls = obj.class();
-        let as_buffer = cls.mro_find_map(|cls| cls.slots.as_buffer);
-        if let Some(f) = as_buffer {
+        if let Some(f) = cls.slots.as_buffer {
             return f(obj, vm);
         }
         Err(vm.new_type_error(format!(
diff --git a/crates/vm/src/protocol/callable.rs b/crates/vm/src/protocol/callable.rs
index 1444b6bf73a..5280e04e928 100644
--- a/crates/vm/src/protocol/callable.rs
+++ b/crates/vm/src/protocol/callable.rs
@@ -42,7 +42,7 @@ pub struct PyCallable<'a> {
 
 impl<'a> PyCallable<'a> {
     pub fn new(obj: &'a PyObject) -> Option<Self> {
-        let call = obj.class().mro_find_map(|cls| cls.slots.call.load())?;
+        let call = obj.class().slots.call.load()?;
         Some(PyCallable { obj, call })
     }
 
diff --git a/crates/vm/src/protocol/iter.rs b/crates/vm/src/protocol/iter.rs
index 18f2b5243e2..f6146543de9 100644
--- a/crates/vm/src/protocol/iter.rs
+++ b/crates/vm/src/protocol/iter.rs
@@ -23,9 +23,7 @@ unsafe impl<O: Borrow<PyObject>> Traverse for PyIter<O> {
 
 impl PyIter<PyObjectRef> {
     pub fn check(obj: &PyObject) -> bool {
-        obj.class()
-            .mro_find_map(|x| x.slots.iternext.load())
-            .is_some()
+        obj.class().slots.iternext.load().is_some()
     }
 }
 
@@ -37,18 +35,19 @@ where
         Self(obj)
     }
     pub fn next(&self, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let iternext = {
-            self.0
-                .borrow()
-                .class()
-                .mro_find_map(|x| x.slots.iternext.load())
-                .ok_or_else(|| {
-                    vm.new_type_error(format!(
-                        "'{}' object is not an iterator",
-                        self.0.borrow().class().name()
-                    ))
-                })?
-        };
+        let iternext = self
+            .0
+            .borrow()
+            .class()
+            .slots
+            .iternext
+            .load()
+            .ok_or_else(|| {
+                vm.new_type_error(format!(
+                    "'{}' object is not an iterator",
+                    self.0.borrow().class().name()
+                ))
+            })?;
         iternext(self.0.borrow(), vm)
     }
 
@@ -126,10 +125,7 @@ impl TryFromObject for PyIter<PyObjectRef> {
     // in the vm when a for loop is entered. Next, it is used when the builtin
     // function 'iter' is called.
     fn try_from_object(vm: &VirtualMachine, iter_target: PyObjectRef) -> PyResult<Self> {
-        let get_iter = {
-            let cls = iter_target.class();
-            cls.mro_find_map(|x| x.slots.iter.load())
-        };
+        let get_iter = iter_target.class().slots.iter.load();
         if let Some(get_iter) = get_iter {
             let iter = get_iter(iter_target, vm)?;
             if Self::check(&iter) {
diff --git a/crates/vm/src/protocol/mapping.rs b/crates/vm/src/protocol/mapping.rs
index a942303dbb4..36813bf1df8 100644
--- a/crates/vm/src/protocol/mapping.rs
+++ b/crates/vm/src/protocol/mapping.rs
@@ -3,7 +3,6 @@ use crate::{
     builtins::{
         PyDict, PyStrInterned,
         dict::{PyDictItems, PyDictKeys, PyDictValues},
-        type_::PointerSlot,
     },
     convert::ToPyResult,
     object::{Traverse, TraverseFn},
@@ -13,9 +12,38 @@ use crossbeam_utils::atomic::AtomicCell;
 // Mapping protocol
 // https://docs.python.org/3/c-api/mapping.html
 
-impl PyObject {
-    pub fn to_mapping(&self) -> PyMapping<'_> {
-        PyMapping::from(self)
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PyMappingSlots {
+    pub length: AtomicCell<Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>>,
+    pub subscript: AtomicCell<Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub ass_subscript: AtomicCell<
+        Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+    >,
+}
+
+impl std::fmt::Debug for PyMappingSlots {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("PyMappingSlots")
+    }
+}
+
+impl PyMappingSlots {
+    pub fn has_subscript(&self) -> bool {
+        self.subscript.load().is_some()
+    }
+
+    /// Copy from static PyMappingMethods
+    pub fn copy_from(&self, methods: &PyMappingMethods) {
+        if let Some(f) = methods.length.load() {
+            self.length.store(Some(f));
+        }
+        if let Some(f) = methods.subscript.load() {
+            self.subscript.store(Some(f));
+        }
+        if let Some(f) = methods.ass_subscript.load() {
+            self.ass_subscript.store(Some(f));
+        }
     }
 }
 
@@ -31,15 +59,11 @@ pub struct PyMappingMethods {
 
 impl std::fmt::Debug for PyMappingMethods {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "mapping methods")
+        f.write_str("PyMappingMethods")
     }
 }
 
 impl PyMappingMethods {
-    fn check(&self) -> bool {
-        self.subscript.load().is_some()
-    }
-
     #[allow(clippy::declare_interior_mutable_const)]
     pub const NOT_IMPLEMENTED: Self = Self {
         length: AtomicCell::new(None),
@@ -48,19 +72,24 @@ impl PyMappingMethods {
     };
 }
 
-impl<'a> From<&'a PyObject> for PyMapping<'a> {
-    fn from(obj: &'a PyObject) -> Self {
-        static GLOBAL_NOT_IMPLEMENTED: PyMappingMethods = PyMappingMethods::NOT_IMPLEMENTED;
-        let methods = Self::find_methods(obj)
-            .map_or(&GLOBAL_NOT_IMPLEMENTED, |x| unsafe { x.borrow_static() });
-        Self { obj, methods }
+impl PyObject {
+    pub fn mapping_unchecked(&self) -> PyMapping<'_> {
+        PyMapping { obj: self }
+    }
+
+    pub fn try_mapping(&self, vm: &VirtualMachine) -> PyResult<PyMapping<'_>> {
+        let mapping = self.mapping_unchecked();
+        if mapping.check() {
+            Ok(mapping)
+        } else {
+            Err(vm.new_type_error(format!("{} is not a mapping object", self.class())))
+        }
     }
 }
 
 #[derive(Copy, Clone)]
 pub struct PyMapping<'a> {
     pub obj: &'a PyObject,
-    pub methods: &'static PyMappingMethods,
 }
 
 unsafe impl Traverse for PyMapping<'_> {
@@ -76,34 +105,19 @@ impl AsRef<PyObject> for PyMapping<'_> {
     }
 }
 
-impl<'a> PyMapping<'a> {
-    pub fn try_protocol(obj: &'a PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-        if let Some(methods) = Self::find_methods(obj)
-            && methods.as_ref().check()
-        {
-            return Ok(Self {
-                obj,
-                methods: unsafe { methods.borrow_static() },
-            });
-        }
-
-        Err(vm.new_type_error(format!("{} is not a mapping object", obj.class())))
-    }
-}
-
 impl PyMapping<'_> {
-    // PyMapping::Check
     #[inline]
-    pub fn check(obj: &PyObject) -> bool {
-        Self::find_methods(obj).is_some_and(|x| x.as_ref().check())
+    pub fn slots(&self) -> &PyMappingSlots {
+        &self.obj.class().slots.as_mapping
     }
 
-    pub fn find_methods(obj: &PyObject) -> Option<PointerSlot<PyMappingMethods>> {
-        obj.class().mro_find_map(|cls| cls.slots.as_mapping.load())
+    #[inline]
+    pub fn check(&self) -> bool {
+        self.slots().has_subscript()
     }
 
     pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.methods.length.load().map(|f| f(self, vm))
+        self.slots().length.load().map(|f| f(self, vm))
     }
 
     pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
@@ -130,7 +144,7 @@ impl PyMapping<'_> {
 
     fn _subscript(self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
         let f =
-            self.methods.subscript.load().ok_or_else(|| {
+            self.slots().subscript.load().ok_or_else(|| {
                 vm.new_type_error(format!("{} is not a mapping", self.obj.class()))
             })?;
         f(self, needle, vm)
@@ -142,7 +156,7 @@ impl PyMapping<'_> {
         value: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let f = self.methods.ass_subscript.load().ok_or_else(|| {
+        let f = self.slots().ass_subscript.load().ok_or_else(|| {
             vm.new_type_error(format!(
                 "'{}' object does not support item assignment",
                 self.obj.class()
diff --git a/crates/vm/src/protocol/mod.rs b/crates/vm/src/protocol/mod.rs
index d5c7e239a24..e7be286c265 100644
--- a/crates/vm/src/protocol/mod.rs
+++ b/crates/vm/src/protocol/mod.rs
@@ -9,9 +9,9 @@ mod sequence;
 pub use buffer::{BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, VecBuffer};
 pub use callable::PyCallable;
 pub use iter::{PyIter, PyIterIter, PyIterReturn};
-pub use mapping::{PyMapping, PyMappingMethods};
+pub use mapping::{PyMapping, PyMappingMethods, PyMappingSlots};
 pub use number::{
     PyNumber, PyNumberBinaryFunc, PyNumberBinaryOp, PyNumberMethods, PyNumberSlots,
     PyNumberTernaryOp, PyNumberUnaryFunc, handle_bytes_to_int_err,
 };
-pub use sequence::{PySequence, PySequenceMethods};
+pub use sequence::{PySequence, PySequenceMethods, PySequenceSlots};
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
index 1242ee52795..4f21a1e64f9 100644
--- a/crates/vm/src/protocol/number.rs
+++ b/crates/vm/src/protocol/number.rs
@@ -20,8 +20,8 @@ pub type PyNumberTernaryFunc = fn(&PyObject, &PyObject, &PyObject, &VirtualMachi
 
 impl PyObject {
     #[inline]
-    pub const fn to_number(&self) -> PyNumber<'_> {
-        PyNumber(self)
+    pub const fn number(&self) -> PyNumber<'_> {
+        PyNumber { obj: self }
     }
 
     pub fn try_index_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
@@ -30,7 +30,7 @@ impl PyObject {
         } else if let Some(i) = self.downcast_ref::<PyInt>() {
             Some(Ok(vm.ctx.new_bigint(i.as_bigint())))
         } else {
-            self.to_number().index(vm)
+            self.number().index(vm)
         }
     }
 
@@ -56,7 +56,7 @@ impl PyObject {
 
         if let Some(i) = self.downcast_ref_if_exact::<PyInt>(vm) {
             Ok(i.to_owned())
-        } else if let Some(i) = self.to_number().int(vm).or_else(|| self.try_index_opt(vm)) {
+        } else if let Some(i) = self.number().int(vm).or_else(|| self.try_index_opt(vm)) {
             i
         } else if let Ok(Some(f)) = vm.get_special_method(self, identifier!(vm, __trunc__)) {
             warnings::warn(
@@ -92,7 +92,7 @@ impl PyObject {
     pub fn try_float_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
         if let Some(float) = self.downcast_ref_if_exact::<PyFloat>(vm) {
             Some(Ok(float.to_owned()))
-        } else if let Some(f) = self.to_number().float(vm) {
+        } else if let Some(f) = self.number().float(vm) {
             Some(f)
         } else {
             self.try_index_opt(vm)
@@ -420,11 +420,13 @@ impl PyNumberSlots {
     }
 }
 #[derive(Copy, Clone)]
-pub struct PyNumber<'a>(&'a PyObject);
+pub struct PyNumber<'a> {
+    pub obj: &'a PyObject,
+}
 
 unsafe impl Traverse for PyNumber<'_> {
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.0.traverse(tracer_fn)
+        self.obj.traverse(tracer_fn)
     }
 }
 
@@ -432,36 +434,17 @@ impl Deref for PyNumber<'_> {
     type Target = PyObject;
 
     fn deref(&self) -> &Self::Target {
-        self.0
+        self.obj
     }
 }
 
 impl<'a> PyNumber<'a> {
-    pub(crate) const fn obj(self) -> &'a PyObject {
-        self.0
-    }
-
-    // PyNumber_Check
+    // PyNumber_Check - slots are now inherited
     pub fn check(obj: &PyObject) -> bool {
-        let cls = &obj.class();
-        // TODO: when we finally have a proper slot inheritance, mro_find_map can be removed
-        //    methods.int.load().is_some()
-        //    || methods.index.load().is_some()
-        //    || methods.float.load().is_some()
-        //    || obj.downcastable::<PyComplex>()
-        let has_number = cls
-            .mro_find_map(|x| {
-                let methods = &x.slots.as_number;
-                if methods.int.load().is_some()
-                    || methods.index.load().is_some()
-                    || methods.float.load().is_some()
-                {
-                    Some(())
-                } else {
-                    None
-                }
-            })
-            .is_some();
+        let methods = &obj.class().slots.as_number;
+        let has_number = methods.int.load().is_some()
+            || methods.index.load().is_some()
+            || methods.float.load().is_some();
         has_number || obj.downcastable::<PyComplex>()
     }
 }
@@ -469,114 +452,106 @@ impl<'a> PyNumber<'a> {
 impl PyNumber<'_> {
     // PyIndex_Check
     pub fn is_index(self) -> bool {
-        self.class()
-            .mro_find_map(|x| x.slots.as_number.index.load())
-            .is_some()
+        self.class().slots.as_number.index.load().is_some()
     }
 
     #[inline]
     pub fn int(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class()
-            .mro_find_map(|x| x.slots.as_number.int.load())
-            .map(|f| {
-                let ret = f(self, vm)?;
-
-                if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
-                    return Ok(ret.to_owned());
-                }
-
-                let ret_class = ret.class().to_owned();
-                if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                    warnings::warn(
-                        vm.ctx.exceptions.deprecation_warning,
-                        format!(
-                            "__int__ returned non-int (type {ret_class}).  \
+        self.class().slots.as_number.int.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyInt>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__int__ returned non-int (type {ret_class}).  \
                     The ability to return an instance of a strict subclass of int \
                     is deprecated, and may be removed in a future version of Python."
-                        ),
-                        1,
-                        vm,
-                    )?;
-
-                    Ok(ret.to_owned())
-                } else {
-                    Err(vm.new_type_error(format!(
-                        "{}.__int__ returned non-int(type {})",
-                        self.class(),
-                        ret_class
-                    )))
-                }
-            })
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__int__ returned non-int(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
     }
 
     #[inline]
     pub fn index(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class()
-            .mro_find_map(|x| x.slots.as_number.index.load())
-            .map(|f| {
-                let ret = f(self, vm)?;
-
-                if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
-                    return Ok(ret.to_owned());
-                }
-
-                let ret_class = ret.class().to_owned();
-                if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                    warnings::warn(
-                        vm.ctx.exceptions.deprecation_warning,
-                        format!(
-                            "__index__ returned non-int (type {ret_class}).  \
+        self.class().slots.as_number.index.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyInt>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__index__ returned non-int (type {ret_class}).  \
                     The ability to return an instance of a strict subclass of int \
                     is deprecated, and may be removed in a future version of Python."
-                        ),
-                        1,
-                        vm,
-                    )?;
-
-                    Ok(ret.to_owned())
-                } else {
-                    Err(vm.new_type_error(format!(
-                        "{}.__index__ returned non-int(type {})",
-                        self.class(),
-                        ret_class
-                    )))
-                }
-            })
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__index__ returned non-int(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
     }
 
     #[inline]
     pub fn float(self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
-        self.class()
-            .mro_find_map(|x| x.slots.as_number.float.load())
-            .map(|f| {
-                let ret = f(self, vm)?;
-
-                if let Some(ret) = ret.downcast_ref_if_exact::<PyFloat>(vm) {
-                    return Ok(ret.to_owned());
-                }
-
-                let ret_class = ret.class().to_owned();
-                if let Some(ret) = ret.downcast_ref::<PyFloat>() {
-                    warnings::warn(
-                        vm.ctx.exceptions.deprecation_warning,
-                        format!(
-                            "__float__ returned non-float (type {ret_class}).  \
+        self.class().slots.as_number.float.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyFloat>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyFloat>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__float__ returned non-float (type {ret_class}).  \
                     The ability to return an instance of a strict subclass of float \
                     is deprecated, and may be removed in a future version of Python."
-                        ),
-                        1,
-                        vm,
-                    )?;
-
-                    Ok(ret.to_owned())
-                } else {
-                    Err(vm.new_type_error(format!(
-                        "{}.__float__ returned non-float(type {})",
-                        self.class(),
-                        ret_class
-                    )))
-                }
-            })
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__float__ returned non-float(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
     }
 }
 
diff --git a/crates/vm/src/protocol/object.rs b/crates/vm/src/protocol/object.rs
index f2e52a94004..ec1a6f55969 100644
--- a/crates/vm/src/protocol/object.rs
+++ b/crates/vm/src/protocol/object.rs
@@ -12,7 +12,7 @@ use crate::{
     dict_inner::DictKey,
     function::{Either, FuncArgs, PyArithmeticValue, PySetterValue},
     object::PyPayload,
-    protocol::{PyIter, PyMapping, PySequence},
+    protocol::PyIter,
     types::{Constructor, PyComparisonOp},
 };
 
@@ -136,10 +136,7 @@ impl PyObject {
     #[inline]
     pub(crate) fn get_attr_inner(&self, attr_name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         vm_trace!("object.__getattribute__: {:?} {:?}", self, attr_name);
-        let getattro = self
-            .class()
-            .mro_find_map(|cls| cls.slots.getattro.load())
-            .unwrap();
+        let getattro = self.class().slots.getattro.load().unwrap();
         getattro(self, attr_name, vm).inspect_err(|exc| {
             vm.set_attribute_error_context(exc, self.to_owned(), attr_name.to_owned());
         })
@@ -153,21 +150,20 @@ impl PyObject {
     ) -> PyResult<()> {
         let setattro = {
             let cls = self.class();
-            cls.mro_find_map(|cls| cls.slots.setattro.load())
-                .ok_or_else(|| {
-                    let has_getattr = cls.mro_find_map(|cls| cls.slots.getattro.load()).is_some();
-                    vm.new_type_error(format!(
-                        "'{}' object has {} attributes ({} {})",
-                        cls.name(),
-                        if has_getattr { "only read-only" } else { "no" },
-                        if attr_value.is_assign() {
-                            "assign to"
-                        } else {
-                            "del"
-                        },
-                        attr_name
-                    ))
-                })?
+            cls.slots.setattro.load().ok_or_else(|| {
+                let has_getattr = cls.slots.getattro.load().is_some();
+                vm.new_type_error(format!(
+                    "'{}' object has {} attributes ({} {})",
+                    cls.name(),
+                    if has_getattr { "only read-only" } else { "no" },
+                    if attr_value.is_assign() {
+                        "assign to"
+                    } else {
+                        "del"
+                    },
+                    attr_name
+                ))
+            })?
         };
         setattro(self, attr_name, attr_value, vm)
     }
@@ -197,7 +193,7 @@ impl PyObject {
             .interned_str(attr_name)
             .and_then(|attr_name| self.get_class_attr(attr_name))
         {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            let descr_set = attr.class().slots.descr_set.load();
             if let Some(descriptor) = descr_set {
                 return descriptor(&attr, self.to_owned(), value, vm);
             }
@@ -239,11 +235,9 @@ impl PyObject {
         let cls_attr = match cls_attr_name.and_then(|name| obj_cls.get_attr(name)) {
             Some(descr) => {
                 let descr_cls = descr.class();
-                let descr_get = descr_cls.mro_find_map(|cls| cls.slots.descr_get.load());
+                let descr_get = descr_cls.slots.descr_get.load();
                 if let Some(descr_get) = descr_get
-                    && descr_cls
-                        .mro_find_map(|cls| cls.slots.descr_set.load())
-                        .is_some()
+                    && descr_cls.slots.descr_set.load().is_some()
                 {
                     let cls = obj_cls.to_owned().into();
                     return descr_get(descr, Some(self.to_owned()), Some(cls), vm).map(Some);
@@ -293,10 +287,7 @@ impl PyObject {
     ) -> PyResult<Either<PyObjectRef, bool>> {
         let swapped = op.swapped();
         let call_cmp = |obj: &Self, other: &Self, op| {
-            let cmp = obj
-                .class()
-                .mro_find_map(|cls| cls.slots.richcompare.load())
-                .unwrap();
+            let cmp = obj.class().slots.richcompare.load().unwrap();
             let r = match cmp(obj, other, op, vm)? {
                 Either::A(obj) => PyArithmeticValue::from_object(vm, obj).map(Either::A),
                 Either::B(arithmetic) => arithmetic.map(Either::B),
@@ -353,18 +344,15 @@ impl PyObject {
 
     pub fn repr(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
         vm.with_recursion("while getting the repr of an object", || {
-            // TODO: RustPython does not implement type slots inheritance yet
-            self.class()
-                .mro_find_map(|cls| cls.slots.repr.load())
-                .map_or_else(
-                    || {
-                        Err(vm.new_runtime_error(format!(
+            self.class().slots.repr.load().map_or_else(
+                || {
+                    Err(vm.new_runtime_error(format!(
                     "BUG: object of type '{}' has no __repr__ method. This is a bug in RustPython.",
                     self.class().name()
                 )))
-                    },
-                    |repr| repr(self, vm),
-                )
+                },
+                |repr| repr(self, vm),
+            )
         })
     }
 
@@ -659,7 +647,7 @@ impl PyObject {
     }
 
     pub fn hash(&self, vm: &VirtualMachine) -> PyResult<PyHash> {
-        if let Some(hash) = self.class().mro_find_map(|cls| cls.slots.hash.load()) {
+        if let Some(hash) = self.class().slots.hash.load() {
             return hash(self, vm);
         }
 
@@ -681,9 +669,9 @@ impl PyObject {
     }
 
     pub fn length_opt(&self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.to_sequence()
+        self.sequence_unchecked()
             .length_opt(vm)
-            .or_else(|| self.to_mapping().length_opt(vm))
+            .or_else(|| self.mapping_unchecked().length_opt(vm))
     }
 
     pub fn length(&self, vm: &VirtualMachine) -> PyResult<usize> {
@@ -702,9 +690,9 @@ impl PyObject {
 
         let needle = needle.to_pyobject(vm);
 
-        if let Ok(mapping) = PyMapping::try_protocol(self, vm) {
+        if let Ok(mapping) = self.try_mapping(vm) {
             mapping.subscript(&needle, vm)
-        } else if let Ok(seq) = PySequence::try_protocol(self, vm) {
+        } else if let Ok(seq) = self.try_sequence(vm) {
             let i = needle.key_as_isize(vm)?;
             seq.get_item(i, vm)
         } else {
@@ -734,14 +722,14 @@ impl PyObject {
             return dict.set_item(needle, value, vm);
         }
 
-        let mapping = self.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
+        let mapping = self.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
             let needle = needle.to_pyobject(vm);
             return f(mapping, &needle, Some(value), vm);
         }
 
-        let seq = self.to_sequence();
-        if let Some(f) = seq.methods.ass_item.load() {
+        let seq = self.sequence_unchecked();
+        if let Some(f) = seq.slots().ass_item.load() {
             let i = needle.key_as_isize(vm)?;
             return f(seq, i, Some(value), vm);
         }
@@ -757,13 +745,13 @@ impl PyObject {
             return dict.del_item(needle, vm);
         }
 
-        let mapping = self.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
+        let mapping = self.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
             let needle = needle.to_pyobject(vm);
             return f(mapping, &needle, None, vm);
         }
-        let seq = self.to_sequence();
-        if let Some(f) = seq.methods.ass_item.load() {
+        let seq = self.sequence_unchecked();
+        if let Some(f) = seq.slots().ass_item.load() {
             let i = needle.key_as_isize(vm)?;
             return f(seq, i, None, vm);
         }
@@ -781,7 +769,7 @@ impl PyObject {
         let res = obj_cls.lookup_ref(attr, vm)?;
 
         // If it's a descriptor, call its __get__ method
-        let descr_get = res.class().mro_find_map(|cls| cls.slots.descr_get.load());
+        let descr_get = res.class().slots.descr_get.load();
         if let Some(descr_get) = descr_get {
             let obj_cls = obj_cls.to_owned().into();
             // CPython ignores exceptions in _PyObject_LookupSpecial and returns NULL
diff --git a/crates/vm/src/protocol/sequence.rs b/crates/vm/src/protocol/sequence.rs
index fb71446a5a4..a7576e63efb 100644
--- a/crates/vm/src/protocol/sequence.rs
+++ b/crates/vm/src/protocol/sequence.rs
@@ -1,26 +1,70 @@
 use crate::{
     PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    builtins::{PyList, PyListRef, PySlice, PyTuple, PyTupleRef, type_::PointerSlot},
+    builtins::{PyList, PyListRef, PySlice, PyTuple, PyTupleRef},
     convert::ToPyObject,
     function::PyArithmeticValue,
     object::{Traverse, TraverseFn},
-    protocol::{PyMapping, PyNumberBinaryOp},
+    protocol::PyNumberBinaryOp,
 };
 use crossbeam_utils::atomic::AtomicCell;
 use itertools::Itertools;
-use std::fmt::Debug;
 
 // Sequence Protocol
 // https://docs.python.org/3/c-api/sequence.html
 
-impl PyObject {
-    #[inline]
-    pub fn to_sequence(&self) -> PySequence<'_> {
-        static GLOBAL_NOT_IMPLEMENTED: PySequenceMethods = PySequenceMethods::NOT_IMPLEMENTED;
-        PySequence {
-            obj: self,
-            methods: PySequence::find_methods(self)
-                .map_or(&GLOBAL_NOT_IMPLEMENTED, |x| unsafe { x.borrow_static() }),
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PySequenceSlots {
+    pub length: AtomicCell<Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>>,
+    pub concat: AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+    pub item: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+    pub ass_item: AtomicCell<
+        Option<fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+    >,
+    pub contains:
+        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>>,
+    pub inplace_concat:
+        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+}
+
+impl std::fmt::Debug for PySequenceSlots {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("PySequenceSlots")
+    }
+}
+
+impl PySequenceSlots {
+    pub fn has_item(&self) -> bool {
+        self.item.load().is_some()
+    }
+
+    /// Copy from static PySequenceMethods
+    pub fn copy_from(&self, methods: &PySequenceMethods) {
+        if let Some(f) = methods.length.load() {
+            self.length.store(Some(f));
+        }
+        if let Some(f) = methods.concat.load() {
+            self.concat.store(Some(f));
+        }
+        if let Some(f) = methods.repeat.load() {
+            self.repeat.store(Some(f));
+        }
+        if let Some(f) = methods.item.load() {
+            self.item.store(Some(f));
+        }
+        if let Some(f) = methods.ass_item.load() {
+            self.ass_item.store(Some(f));
+        }
+        if let Some(f) = methods.contains.load() {
+            self.contains.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_concat.load() {
+            self.inplace_concat.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_repeat.load() {
+            self.inplace_repeat.store(Some(f));
         }
     }
 }
@@ -42,9 +86,9 @@ pub struct PySequenceMethods {
     pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
 }
 
-impl Debug for PySequenceMethods {
+impl std::fmt::Debug for PySequenceMethods {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Sequence Methods")
+        f.write_str("PySequenceMethods")
     }
 }
 
@@ -62,10 +106,25 @@ impl PySequenceMethods {
     };
 }
 
+impl PyObject {
+    #[inline]
+    pub fn sequence_unchecked(&self) -> PySequence<'_> {
+        PySequence { obj: self }
+    }
+
+    pub fn try_sequence(&self, vm: &VirtualMachine) -> PyResult<PySequence<'_>> {
+        let seq = self.sequence_unchecked();
+        if seq.check() {
+            Ok(seq)
+        } else {
+            Err(vm.new_type_error(format!("'{}' is not a sequence", self.class())))
+        }
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct PySequence<'a> {
     pub obj: &'a PyObject,
-    pub methods: &'static PySequenceMethods,
 }
 
 unsafe impl Traverse for PySequence<'_> {
@@ -74,34 +133,18 @@ unsafe impl Traverse for PySequence<'_> {
     }
 }
 
-impl<'a> PySequence<'a> {
+impl PySequence<'_> {
     #[inline]
-    pub const fn with_methods(obj: &'a PyObject, methods: &'static PySequenceMethods) -> Self {
-        Self { obj, methods }
+    pub fn slots(&self) -> &PySequenceSlots {
+        &self.obj.class().slots.as_sequence
     }
 
-    pub fn try_protocol(obj: &'a PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-        let seq = obj.to_sequence();
-        if seq.check() {
-            Ok(seq)
-        } else {
-            Err(vm.new_type_error(format!("'{}' is not a sequence", obj.class())))
-        }
-    }
-}
-
-impl PySequence<'_> {
     pub fn check(&self) -> bool {
-        self.methods.item.load().is_some()
-    }
-
-    pub fn find_methods(obj: &PyObject) -> Option<PointerSlot<PySequenceMethods>> {
-        let cls = obj.class();
-        cls.mro_find_map(|x| x.slots.as_sequence.load())
+        self.slots().has_item()
     }
 
     pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.methods.length.load().map(|f| f(self, vm))
+        self.slots().length.load().map(|f| f(self, vm))
     }
 
     pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
@@ -114,12 +157,12 @@ impl PySequence<'_> {
     }
 
     pub fn concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.concat.load() {
+        if let Some(f) = self.slots().concat.load() {
             return f(self, other, vm);
         }
 
         // if both arguments appear to be sequences, try fallback to __add__
-        if self.check() && other.to_sequence().check() {
+        if self.check() && other.sequence_unchecked().check() {
             let ret = vm.binary_op1(self.obj, other, PyNumberBinaryOp::Add)?;
             if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
                 return Ok(ret);
@@ -133,7 +176,7 @@ impl PySequence<'_> {
     }
 
     pub fn repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.repeat.load() {
+        if let Some(f) = self.slots().repeat.load() {
             return f(self, n, vm);
         }
 
@@ -149,15 +192,15 @@ impl PySequence<'_> {
     }
 
     pub fn inplace_concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.inplace_concat.load() {
+        if let Some(f) = self.slots().inplace_concat.load() {
             return f(self, other, vm);
         }
-        if let Some(f) = self.methods.concat.load() {
+        if let Some(f) = self.slots().concat.load() {
             return f(self, other, vm);
         }
 
         // if both arguments appear to be sequences, try fallback to __iadd__
-        if self.check() && other.to_sequence().check() {
+        if self.check() && other.sequence_unchecked().check() {
             let ret = vm._iadd(self.obj, other)?;
             if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
                 return Ok(ret);
@@ -171,10 +214,10 @@ impl PySequence<'_> {
     }
 
     pub fn inplace_repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.inplace_repeat.load() {
+        if let Some(f) = self.slots().inplace_repeat.load() {
             return f(self, n, vm);
         }
-        if let Some(f) = self.methods.repeat.load() {
+        if let Some(f) = self.slots().repeat.load() {
             return f(self, n, vm);
         }
 
@@ -189,7 +232,7 @@ impl PySequence<'_> {
     }
 
     pub fn get_item(self, i: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.item.load() {
+        if let Some(f) = self.slots().item.load() {
             return f(self, i, vm);
         }
         Err(vm.new_type_error(format!(
@@ -199,7 +242,7 @@ impl PySequence<'_> {
     }
 
     fn _ass_item(self, i: isize, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(f) = self.methods.ass_item.load() {
+        if let Some(f) = self.slots().ass_item.load() {
             return f(self, i, value, vm);
         }
         Err(vm.new_type_error(format!(
@@ -222,7 +265,7 @@ impl PySequence<'_> {
     }
 
     pub fn get_slice(&self, start: isize, stop: isize, vm: &VirtualMachine) -> PyResult {
-        if let Ok(mapping) = PyMapping::try_protocol(self.obj, vm) {
+        if let Ok(mapping) = self.obj.try_mapping(vm) {
             let slice = PySlice {
                 start: Some(start.to_pyobject(vm)),
                 stop: stop.to_pyobject(vm),
@@ -241,8 +284,8 @@ impl PySequence<'_> {
         value: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let mapping = self.obj.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
+        let mapping = self.obj.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
             let slice = PySlice {
                 start: Some(start.to_pyobject(vm)),
                 stop: stop.to_pyobject(vm),
@@ -355,7 +398,7 @@ impl PySequence<'_> {
     }
 
     pub fn contains(self, target: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        if let Some(f) = self.methods.contains.load() {
+        if let Some(f) = self.slots().contains.load() {
             return f(self, target, vm);
         }
 
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 72d2c724159..19f85af55da 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -268,7 +268,7 @@ mod builtins {
                 if !globals.fast_isinstance(vm.ctx.types.dict_type) {
                     return Err(match func_name {
                         "eval" => {
-                            let is_mapping = crate::protocol::PyMapping::check(globals);
+                            let is_mapping = globals.mapping_unchecked().check();
                             vm.new_type_error(if is_mapping {
                                 "globals must be a real dict; try eval(expr, {}, mapping)"
                                     .to_owned()
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index 1ca428669d4..d5aca392c52 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -467,7 +467,7 @@ impl SetAttr for PyCStructType {
 
         // Check for data descriptor first
         if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            let descr_set = attr.class().slots.descr_set.load();
             if let Some(descriptor) = descr_set {
                 return descriptor(&attr, pytype.to_owned().into(), value, vm);
             }
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
index 500aa8e6244..41bc7492a25 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -369,7 +369,7 @@ impl SetAttr for PyCUnionType {
         // 1. First, do PyType's setattro (PyType_Type.tp_setattro first)
         // Check for data descriptor first
         if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
+            let descr_set = attr.class().slots.descr_set.load();
             if let Some(descriptor) = descr_set {
                 descriptor(&attr, pytype.to_owned().into(), value.clone(), vm)?;
                 // After successful setattro, check if _fields_ and call process_fields
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs
index afa8bd6eb90..469a75b010f 100644
--- a/crates/vm/src/stdlib/typing.rs
+++ b/crates/vm/src/stdlib/typing.rs
@@ -1,5 +1,5 @@
 // spell-checker:ignore typevarobject funcobj
-use crate::{PyPayload, PyRef, VirtualMachine, class::PyClassImpl, stdlib::PyModule};
+use crate::{Context, PyPayload, PyRef, VirtualMachine, class::PyClassImpl, stdlib::PyModule};
 
 pub use crate::stdlib::typevar::{
     Generic, ParamSpec, ParamSpecArgs, ParamSpecKwargs, TypeVar, TypeVarTuple,
@@ -7,6 +7,11 @@ pub use crate::stdlib::typevar::{
 };
 pub use decl::*;
 
+/// Initialize typing types (call extend_class)
+pub fn init(ctx: &Context) {
+    NoDefault::extend_class(ctx, ctx.types.typing_no_default_type);
+}
+
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = decl::make_module(vm);
     TypeVar::make_class(&vm.ctx);
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 57ac24f461a..bfe6e047622 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -3,7 +3,7 @@ use crate::common::lock::{
 };
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef, type_::PointerSlot},
+    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef},
     bytecode::ComparisonOperator,
     common::hash::PyHash,
     convert::ToPyObject,
@@ -11,8 +11,8 @@ use crate::{
         Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
     },
     protocol::{
-        PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyNumber, PyNumberMethods,
-        PyNumberSlots, PySequence, PySequenceMethods,
+        PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyMappingSlots, PyNumber,
+        PyNumberMethods, PyNumberSlots, PySequence, PySequenceMethods, PySequenceSlots,
     },
     vm::Context,
 };
@@ -134,8 +134,8 @@ pub struct PyTypeSlots {
 
     // Method suites for standard classes
     pub as_number: PyNumberSlots,
-    pub as_sequence: AtomicCell<Option<PointerSlot<PySequenceMethods>>>,
-    pub as_mapping: AtomicCell<Option<PointerSlot<PyMappingMethods>>>,
+    pub as_sequence: PySequenceSlots,
+    pub as_mapping: PyMappingSlots,
 
     // More standard operations (here for binary compatibility)
     pub hash: AtomicCell<Option<HashFunc>>,
@@ -358,6 +358,16 @@ fn repr_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>
     })
 }
 
+fn str_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+    let ret = vm.call_special_method(zelf, identifier!(vm, __str__), ())?;
+    ret.downcast::<PyStr>().map_err(|obj| {
+        vm.new_type_error(format!(
+            "__str__ returned non-string (type {})",
+            obj.class()
+        ))
+    })
+}
+
 fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
     let hash_obj = vm.call_special_method(zelf, identifier!(vm, __hash__), ())?;
     let py_int = hash_obj
@@ -426,6 +436,18 @@ fn iter_wrapper(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     vm.call_special_method(&zelf, identifier!(vm, __iter__), ())
 }
 
+fn bool_wrapper(num: PyNumber<'_>, vm: &VirtualMachine) -> PyResult<bool> {
+    let result = vm.call_special_method(num.obj, identifier!(vm, __bool__), ())?;
+    // __bool__ must return exactly bool, not int subclass
+    if !result.class().is(vm.ctx.types.bool_type) {
+        return Err(vm.new_type_error(format!(
+            "__bool__ should return bool, returned {}",
+            result.class().name()
+        )));
+    }
+    Ok(crate::builtins::bool_::get_value(&result))
+}
+
 // PyObject_SelfIter in CPython
 const fn self_iter(zelf: PyObjectRef, _vm: &VirtualMachine) -> PyResult {
     Ok(zelf)
@@ -491,17 +513,36 @@ impl PyType {
 
         macro_rules! toggle_slot {
             ($name:ident, $func:expr) => {{
-                self.slots.$name.store(if ADD { Some($func) } else { None });
+                if ADD {
+                    self.slots.$name.store(Some($func));
+                } else {
+                    // When deleting, re-inherit from MRO (skip self)
+                    let inherited = self
+                        .mro
+                        .read()
+                        .iter()
+                        .skip(1)
+                        .find_map(|cls| cls.slots.$name.load());
+                    self.slots.$name.store(inherited);
+                }
             }};
         }
 
         macro_rules! toggle_sub_slot {
-            ($group:ident, $name:ident, $func:expr) => {
-                self.slots
-                    .$group
-                    .$name
-                    .store(if ADD { Some($func) } else { None });
-            };
+            ($group:ident, $name:ident, $func:expr) => {{
+                if ADD {
+                    self.slots.$group.$name.store(Some($func));
+                } else {
+                    // When deleting, re-inherit from MRO (skip self)
+                    let inherited = self
+                        .mro
+                        .read()
+                        .iter()
+                        .skip(1)
+                        .find_map(|cls| cls.slots.$group.$name.load());
+                    self.slots.$group.$name.store(inherited);
+                }
+            }};
         }
 
         macro_rules! update_slot {
@@ -510,66 +551,41 @@ impl PyType {
             }};
         }
 
-        macro_rules! update_pointer_slot {
-            ($name:ident, $pointed:ident) => {{
-                self.slots
-                    .$name
-                    .store(unsafe { PointerSlot::from_heaptype(self, |ext| &ext.$pointed) });
-            }};
-        }
-
-        macro_rules! toggle_ext_func {
-            ($n1:ident, $n2:ident, $func:expr) => {{
-                self.heaptype_ext.as_ref().unwrap().$n1.$n2.store(if ADD {
-                    Some($func)
-                } else {
-                    None
-                });
-            }};
-        }
-
         match name {
             _ if name == identifier!(ctx, __len__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, length, |seq, vm| len_wrapper(seq.obj, vm));
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, length, |mapping, vm| len_wrapper(
+                toggle_sub_slot!(as_sequence, length, |seq, vm| len_wrapper(seq.obj, vm));
+                toggle_sub_slot!(as_mapping, length, |mapping, vm| len_wrapper(
                     mapping.obj,
                     vm
                 ));
-                update_pointer_slot!(as_mapping, mapping_methods);
             }
             _ if name == identifier!(ctx, __getitem__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, item, |seq, i, vm| getitem_wrapper(
+                toggle_sub_slot!(as_sequence, item, |seq, i, vm| getitem_wrapper(
                     seq.obj, i, vm
                 ));
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, subscript, |mapping, key, vm| {
+                toggle_sub_slot!(as_mapping, subscript, |mapping, key, vm| {
                     getitem_wrapper(mapping.obj, key, vm)
                 });
-                update_pointer_slot!(as_mapping, mapping_methods);
             }
             _ if name == identifier!(ctx, __setitem__) || name == identifier!(ctx, __delitem__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, ass_item, |seq, i, value, vm| {
+                toggle_sub_slot!(as_sequence, ass_item, |seq, i, value, vm| {
                     setitem_wrapper(seq.obj, i, value, vm)
                 });
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, ass_subscript, |mapping, key, value, vm| {
+                toggle_sub_slot!(as_mapping, ass_subscript, |mapping, key, value, vm| {
                     setitem_wrapper(mapping.obj, key, value, vm)
                 });
-                update_pointer_slot!(as_mapping, mapping_methods);
             }
             _ if name == identifier!(ctx, __contains__) => {
-                toggle_ext_func!(sequence_methods, contains, |seq, needle, vm| {
+                toggle_sub_slot!(as_sequence, contains, |seq, needle, vm| {
                     contains_wrapper(seq.obj, needle, vm)
                 });
-                update_pointer_slot!(as_sequence, sequence_methods);
             }
             _ if name == identifier!(ctx, __repr__) => {
                 update_slot!(repr, repr_wrapper);
             }
+            _ if name == identifier!(ctx, __str__) => {
+                update_slot!(str, str_wrapper);
+            }
             _ if name == identifier!(ctx, __hash__) => {
                 let is_unhashable = self
                     .attributes
@@ -624,6 +640,9 @@ impl PyType {
             _ if name == identifier!(ctx, __del__) => {
                 toggle_slot!(del, del_wrapper);
             }
+            _ if name == identifier!(ctx, __bool__) => {
+                toggle_sub_slot!(as_number, boolean, bool_wrapper);
+            }
             _ if name == identifier!(ctx, __int__) => {
                 toggle_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__));
             }
@@ -1380,24 +1399,30 @@ pub trait AsBuffer: PyPayload {
 
 #[pyclass]
 pub trait AsMapping: PyPayload {
-    #[pyslot]
     fn as_mapping() -> &'static PyMappingMethods;
 
     #[inline]
     fn mapping_downcast(mapping: PyMapping<'_>) -> &Py<Self> {
         unsafe { mapping.obj.downcast_unchecked_ref() }
     }
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_mapping.copy_from(Self::as_mapping());
+    }
 }
 
 #[pyclass]
 pub trait AsSequence: PyPayload {
-    #[pyslot]
     fn as_sequence() -> &'static PySequenceMethods;
 
     #[inline]
     fn sequence_downcast(seq: PySequence<'_>) -> &Py<Self> {
         unsafe { seq.obj.downcast_unchecked_ref() }
     }
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_sequence.copy_from(Self::as_sequence());
+    }
 }
 
 #[pyclass]
@@ -1412,7 +1437,7 @@ pub trait AsNumber: PyPayload {
 
     #[inline]
     fn number_downcast(num: PyNumber<'_>) -> &Py<Self> {
-        unsafe { num.obj().downcast_unchecked_ref() }
+        unsafe { num.obj.downcast_unchecked_ref() }
     }
 
     #[inline]
diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs
index 2b6a2530b02..27315749e06 100644
--- a/crates/vm/src/types/structseq.rs
+++ b/crates/vm/src/types/structseq.rs
@@ -1,8 +1,6 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
-    builtins::{
-        PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, type_::PointerSlot,
-    },
+    builtins::{PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef},
     class::{PyClassImpl, StaticType},
     function::{Either, PyComparisonValue},
     iter::PyExactSizeIterator,
@@ -87,7 +85,10 @@ static STRUCT_SEQUENCE_AS_SEQUENCE: LazyLock<PySequenceMethods> =
             let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
             let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
             // Use tuple's concat implementation
-            visible_tuple.as_object().to_sequence().concat(other, vm)
+            visible_tuple
+                .as_object()
+                .sequence_unchecked()
+                .concat(other, vm)
         }),
         repeat: atomic_func!(|seq, n, vm| {
             // Convert to visible-only tuple, then use regular tuple repeat
@@ -96,7 +97,7 @@ static STRUCT_SEQUENCE_AS_SEQUENCE: LazyLock<PySequenceMethods> =
             let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
             let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
             // Use tuple's repeat implementation
-            visible_tuple.as_object().to_sequence().repeat(n, vm)
+            visible_tuple.as_object().sequence_unchecked().repeat(n, vm)
         }),
         item: atomic_func!(|seq, i, vm| {
             let n_seq = get_visible_len(seq.obj, vm)?;
@@ -306,12 +307,14 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
         );
 
         // Override as_sequence and as_mapping slots to use visible length
-        class.slots.as_sequence.store(Some(PointerSlot::from(
-            &*STRUCT_SEQUENCE_AS_SEQUENCE as &'static PySequenceMethods,
-        )));
-        class.slots.as_mapping.store(Some(PointerSlot::from(
-            &*STRUCT_SEQUENCE_AS_MAPPING as &'static PyMappingMethods,
-        )));
+        class
+            .slots
+            .as_sequence
+            .copy_from(&STRUCT_SEQUENCE_AS_SEQUENCE);
+        class
+            .slots
+            .as_mapping
+            .copy_from(&STRUCT_SEQUENCE_AS_MAPPING);
 
         // Override iter slot to return only visible elements
         class.slots.iter.store(Some(struct_sequence_iter));
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index dd4631bc767..0cd04a0ac17 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -242,5 +242,6 @@ impl TypeZoo {
         genericalias::init(context);
         union_::init(context);
         descriptor::init(context);
+        crate::stdlib::typing::init(context);
     }
 }
diff --git a/crates/vm/src/vm/method.rs b/crates/vm/src/vm/method.rs
index 5df01c556ea..ba323391488 100644
--- a/crates/vm/src/vm/method.rs
+++ b/crates/vm/src/vm/method.rs
@@ -21,7 +21,7 @@ pub enum PyMethod {
 impl PyMethod {
     pub fn get(obj: PyObjectRef, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult<Self> {
         let cls = obj.class();
-        let getattro = cls.mro_find_map(|cls| cls.slots.getattro.load()).unwrap();
+        let getattro = cls.slots.getattro.load().unwrap();
         if getattro as usize != PyBaseObject::getattro as usize {
             return obj.get_attr(name, vm).map(Self::Attribute);
         }
@@ -41,11 +41,9 @@ impl PyMethod {
                     is_method = true;
                     None
                 } else {
-                    let descr_get = descr_cls.mro_find_map(|cls| cls.slots.descr_get.load());
+                    let descr_get = descr_cls.slots.descr_get.load();
                     if let Some(descr_get) = descr_get
-                        && descr_cls
-                            .mro_find_map(|cls| cls.slots.descr_set.load())
-                            .is_some()
+                        && descr_cls.slots.descr_set.load().is_some()
                     {
                         let cls = cls.to_owned().into();
                         return descr_get(descr, Some(obj), Some(cls), vm).map(Self::Attribute);
diff --git a/crates/vm/src/vm/vm_object.rs b/crates/vm/src/vm/vm_object.rs
index e69301820d6..0d5b286148c 100644
--- a/crates/vm/src/vm/vm_object.rs
+++ b/crates/vm/src/vm/vm_object.rs
@@ -96,9 +96,7 @@ impl VirtualMachine {
         obj: Option<PyObjectRef>,
         cls: Option<PyObjectRef>,
     ) -> Option<PyResult> {
-        let descr_get = descr
-            .class()
-            .mro_find_map(|cls| cls.slots.descr_get.load())?;
+        let descr_get = descr.class().slots.descr_get.load()?;
         Some(descr_get(descr.to_owned(), obj, cls, self))
     }
 
diff --git a/crates/vm/src/vm/vm_ops.rs b/crates/vm/src/vm/vm_ops.rs
index e30e19981a9..635fa10e630 100644
--- a/crates/vm/src/vm/vm_ops.rs
+++ b/crates/vm/src/vm/vm_ops.rs
@@ -4,7 +4,7 @@ use crate::{
     PyRef,
     builtins::{PyInt, PyStr, PyStrRef, PyUtf8Str},
     object::{AsObject, PyObject, PyObjectRef, PyResult},
-    protocol::{PyNumberBinaryOp, PyNumberTernaryOp, PySequence},
+    protocol::{PyNumberBinaryOp, PyNumberTernaryOp},
     types::PyComparisonOp,
 };
 use num_traits::ToPrimitive;
@@ -160,12 +160,12 @@ impl VirtualMachine {
         let class_a = a.class();
         let class_b = b.class();
 
-        // Look up number slots across MRO for inheritance
-        let slot_a = class_a.mro_find_map(|x| x.slots.as_number.left_binary_op(op_slot));
+        // Number slots are inherited, direct access is O(1)
+        let slot_a = class_a.slots.as_number.left_binary_op(op_slot);
         let mut slot_b = None;
 
         if !class_a.is(class_b) {
-            let slot_bb = class_b.mro_find_map(|x| x.slots.as_number.right_binary_op(op_slot));
+            let slot_bb = class_b.slots.as_number.right_binary_op(op_slot);
             if slot_bb.map(|x| x as usize) != slot_a.map(|x| x as usize) {
                 slot_b = slot_bb;
             }
@@ -231,10 +231,7 @@ impl VirtualMachine {
         iop_slot: PyNumberBinaryOp,
         op_slot: PyNumberBinaryOp,
     ) -> PyResult {
-        if let Some(slot) = a
-            .class()
-            .mro_find_map(|x| x.slots.as_number.left_binary_op(iop_slot))
-        {
+        if let Some(slot) = a.class().slots.as_number.left_binary_op(iop_slot) {
             let x = slot(a, b, self)?;
             if !x.is(&self.ctx.not_implemented) {
                 return Ok(x);
@@ -270,12 +267,12 @@ impl VirtualMachine {
         let class_b = b.class();
         let class_c = c.class();
 
-        // Look up number slots across MRO for inheritance
-        let slot_a = class_a.mro_find_map(|x| x.slots.as_number.left_ternary_op(op_slot));
+        // Number slots are inherited, direct access is O(1)
+        let slot_a = class_a.slots.as_number.left_ternary_op(op_slot);
         let mut slot_b = None;
 
         if !class_a.is(class_b) {
-            let slot_bb = class_b.mro_find_map(|x| x.slots.as_number.right_ternary_op(op_slot));
+            let slot_bb = class_b.slots.as_number.right_ternary_op(op_slot);
             if slot_bb.map(|x| x as usize) != slot_a.map(|x| x as usize) {
                 slot_b = slot_bb;
             }
@@ -304,7 +301,7 @@ impl VirtualMachine {
             }
         }
 
-        if let Some(slot_c) = class_c.mro_find_map(|x| x.slots.as_number.left_ternary_op(op_slot))
+        if let Some(slot_c) = class_c.slots.as_number.left_ternary_op(op_slot)
             && slot_a.is_some_and(|slot_a| !std::ptr::fn_addr_eq(slot_a, slot_c))
             && slot_b.is_some_and(|slot_b| !std::ptr::fn_addr_eq(slot_b, slot_c))
         {
@@ -343,10 +340,7 @@ impl VirtualMachine {
         op_slot: PyNumberTernaryOp,
         op_str: &str,
     ) -> PyResult {
-        if let Some(slot) = a
-            .class()
-            .mro_find_map(|x| x.slots.as_number.left_ternary_op(iop_slot))
-        {
+        if let Some(slot) = a.class().slots.as_number.left_ternary_op(iop_slot) {
             let x = slot(a, b, c, self)?;
             if !x.is(&self.ctx.not_implemented) {
                 return Ok(x);
@@ -386,7 +380,7 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let result = seq_a.concat(b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
@@ -400,7 +394,7 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let result = seq_a.inplace_concat(b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
@@ -414,14 +408,14 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let n = b
                 .try_index(self)?
                 .as_bigint()
                 .to_isize()
                 .ok_or_else(|| self.new_overflow_error("repeated bytes are too long"))?;
             return seq_a.repeat(n, self);
-        } else if let Ok(seq_b) = PySequence::try_protocol(b, self) {
+        } else if let Ok(seq_b) = b.try_sequence(self) {
             let n = a
                 .try_index(self)?
                 .as_bigint()
@@ -442,14 +436,14 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let n = b
                 .try_index(self)?
                 .as_bigint()
                 .to_isize()
                 .ok_or_else(|| self.new_overflow_error("repeated bytes are too long"))?;
             return seq_a.inplace_repeat(n, self);
-        } else if let Ok(seq_b) = PySequence::try_protocol(b, self) {
+        } else if let Ok(seq_b) = b.try_sequence(self) {
             let n = a
                 .try_index(self)?
                 .as_bigint()
@@ -530,7 +524,7 @@ impl VirtualMachine {
     }
 
     pub fn _contains(&self, haystack: &PyObject, needle: &PyObject) -> PyResult<bool> {
-        let seq = haystack.to_sequence();
+        let seq = haystack.sequence_unchecked();
         seq.contains(needle, self)
     }
 }

From a5a1173c3f2aac724d0c48ce592670d221b1aa30 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 18:27:19 +0900
Subject: [PATCH 066/418] Disallow rebinding __module__ on immutable builtins
 and add regression snippet (#6513)

* Initial plan

* Fix __module__ setter on immutable builtin types

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Remove unused value parameter from immutability helper

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Auto-format: cargo fmt --all

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/builtins/type.rs       | 11 ++++++-----
 extra_tests/snippets/builtin_type.py |  9 +++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index c2373f26faf..ffaad324687 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1050,10 +1050,12 @@ impl PyType {
     }
 
     #[pygetset(setter)]
-    fn set___module__(&self, value: PyObjectRef, vm: &VirtualMachine) {
+    fn set___module__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        self.check_set_special_type_attr(identifier!(vm, __module__), vm)?;
         self.attributes
             .write()
             .insert(identifier!(vm, __module__), value);
+        Ok(())
     }
 
     #[pyclassmethod]
@@ -1103,7 +1105,6 @@ impl PyType {
 
     fn check_set_special_type_attr(
         &self,
-        _value: &PyObject,
         name: &PyStrInterned,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
@@ -1119,7 +1120,7 @@ impl PyType {
 
     #[pygetset(setter)]
     fn set___name__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self.check_set_special_type_attr(&value, identifier!(vm, __name__), vm)?;
+        self.check_set_special_type_attr(identifier!(vm, __name__), vm)?;
         let name = value.downcast::<PyStr>().map_err(|value| {
             vm.new_type_error(format!(
                 "can only assign string to {}.__name__, not '{}'",
@@ -1172,7 +1173,7 @@ impl PyType {
         match value {
             PySetterValue::Assign(ref val) => {
                 let key = identifier!(vm, __type_params__);
-                self.check_set_special_type_attr(val.as_ref(), key, vm)?;
+                self.check_set_special_type_attr(key, vm)?;
                 let mut attrs = self.attributes.write();
                 attrs.insert(key, val.clone().into());
             }
@@ -1628,7 +1629,7 @@ impl Py<PyType> {
         })?;
 
         // Check if we can set this special type attribute
-        self.check_set_special_type_attr(&value, identifier!(vm, __doc__), vm)?;
+        self.check_set_special_type_attr(identifier!(vm, __doc__), vm)?;
 
         // Set the __doc__ in the type's dict
         self.attributes
diff --git a/extra_tests/snippets/builtin_type.py b/extra_tests/snippets/builtin_type.py
index abb68f812be..7a8e4840e13 100644
--- a/extra_tests/snippets/builtin_type.py
+++ b/extra_tests/snippets/builtin_type.py
@@ -72,6 +72,15 @@
 assert object.__qualname__ == "object"
 assert int.__qualname__ == "int"
 
+with assert_raises(TypeError):
+    type.__module__ = "nope"
+
+with assert_raises(TypeError):
+    object.__module__ = "nope"
+
+with assert_raises(TypeError):
+    map.__module__ = "nope"
+
 
 class A(type):
     pass

From 61ddd98b893072d9b067a953318d93a22a68d3ca Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Thu, 25 Dec 2025 19:08:23 +0900
Subject: [PATCH 067/418] Handle missing type_params on AST
 Function/Class/TypeAlias nodes (#6512)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/stdlib/ast/statement.rs |  6 +++---
 extra_tests/snippets/stdlib_types.py  | 30 +++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/ast/statement.rs
index 6d9b35bee79..f1d36c52e2e 100644
--- a/crates/vm/src/stdlib/ast/statement.rs
+++ b/crates/vm/src/stdlib/ast/statement.rs
@@ -257,7 +257,7 @@ impl Node for ruff::StmtFunctionDef {
             type_params: Node::ast_from_object(
                 _vm,
                 source_file,
-                get_node_field(_vm, &_object, "type_params", "FunctionDef")?,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
             )?,
             range: range_from_object(_vm, source_file, _object, "FunctionDef")?,
             is_async,
@@ -341,7 +341,7 @@ impl Node for ruff::StmtClassDef {
             type_params: Node::ast_from_object(
                 _vm,
                 source_file,
-                get_node_field(_vm, &_object, "type_params", "ClassDef")?,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
             )?,
             range: range_from_object(_vm, source_file, _object, "ClassDef")?,
         })
@@ -503,7 +503,7 @@ impl Node for ruff::StmtTypeAlias {
             type_params: Node::ast_from_object(
                 _vm,
                 source_file,
-                get_node_field(_vm, &_object, "type_params", "TypeAlias")?,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
             )?,
             value: Node::ast_from_object(
                 _vm,
diff --git a/extra_tests/snippets/stdlib_types.py b/extra_tests/snippets/stdlib_types.py
index 3a3872d2f4e..14028268f0e 100644
--- a/extra_tests/snippets/stdlib_types.py
+++ b/extra_tests/snippets/stdlib_types.py
@@ -1,3 +1,5 @@
+import _ast
+import platform
 import types
 
 from testutils import assert_raises
@@ -8,3 +10,31 @@
 assert ns.b == "Rust"
 with assert_raises(AttributeError):
     _ = ns.c
+
+
+def _run_missing_type_params_regression():
+    args = _ast.arguments(
+        posonlyargs=[],
+        args=[],
+        vararg=None,
+        kwonlyargs=[],
+        kw_defaults=[],
+        kwarg=None,
+        defaults=[],
+    )
+    fn = _ast.FunctionDef("f", args, [], [], None, None)
+    fn.lineno = 1
+    fn.col_offset = 0
+    fn.end_lineno = 1
+    fn.end_col_offset = 0
+    mod = _ast.Module([fn], [])
+    mod.lineno = 1
+    mod.col_offset = 0
+    mod.end_lineno = 1
+    mod.end_col_offset = 0
+    compiled = compile(mod, "<stdlib_types_missing_type_params>", "exec")
+    exec(compiled, {})
+
+
+if platform.python_implementation() == "RustPython":
+    _run_missing_type_params_regression()

From bcdf37bef17beacdaa41e430eb3e7e2d0bf5cb6c Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 25 Dec 2025 14:17:31 +0100
Subject: [PATCH 068/418] Align opcode names in `dis` (#6526)

* opcodes dis repr like cpython. POP-> POP_TOP

* Adjust frame.rs

* Fix codegen

* snapshots

* Add doc for `PopTop`

* fix jit
---
 crates/codegen/src/compile.rs                 |  46 ++--
 ...thon_codegen__compile__tests__if_ands.snap |  16 +-
 ...hon_codegen__compile__tests__if_mixed.snap |  20 +-
 ...ython_codegen__compile__tests__if_ors.snap |  16 +-
 ...pile__tests__nested_double_async_with.snap | 142 ++++++------
 crates/compiler-core/src/bytecode.rs          | 206 +++++++++---------
 crates/jit/src/instructions.rs                |   8 +-
 crates/vm/src/frame.rs                        |  10 +-
 8 files changed, 234 insertions(+), 230 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 4f7174c8bad..0131b3008e3 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1063,7 +1063,7 @@ impl Compiler {
                         }
                     );
 
-                    emit!(self, Instruction::Pop);
+                    emit!(self, Instruction::PopTop);
                 } else {
                     self.compile_statement(statement)?;
                 }
@@ -1079,7 +1079,7 @@ impl Compiler {
                     }
                 );
 
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             } else {
                 self.compile_statement(last)?;
                 self.emit_load_const(ConstantData::None);
@@ -1104,7 +1104,7 @@ impl Compiler {
         if let Some(last_statement) = body.last() {
             match last_statement {
                 Stmt::Expr(_) => {
-                    self.current_block().instructions.pop(); // pop Instruction::Pop
+                    self.current_block().instructions.pop(); // pop Instruction::PopTop
                 }
                 Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
@@ -1401,14 +1401,14 @@ impl Compiler {
                     }
 
                     // Pop module from stack:
-                    emit!(self, Instruction::Pop);
+                    emit!(self, Instruction::PopTop);
                 }
             }
             Stmt::Expr(StmtExpr { value, .. }) => {
                 self.compile_expression(value)?;
 
                 // Pop result of stack, since we not use it:
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
             Stmt::Global(_) | Stmt::Nonlocal(_) => {
                 // Handled during symbol table construction.
@@ -2051,12 +2051,12 @@ impl Compiler {
                     self.store_name(alias.as_str())?
                 } else {
                     // Drop exception from top of stack:
-                    emit!(self, Instruction::Pop);
+                    emit!(self, Instruction::PopTop);
                 }
             } else {
                 // Catch all!
                 // Drop exception from top of stack:
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
 
             // Handler code:
@@ -2950,7 +2950,7 @@ impl Compiler {
                     self.compile_store(var)?;
                 }
                 None => {
-                    emit!(self, Instruction::Pop);
+                    emit!(self, Instruction::PopTop);
                 }
             }
             final_block
@@ -3143,7 +3143,7 @@ impl Compiler {
         for &label in pc.fail_pop.iter().skip(1).rev() {
             self.switch_to_block(label);
             // Emit the POP instruction.
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
         }
         // Finally, use the first label.
         self.switch_to_block(pc.fail_pop[0]);
@@ -3187,7 +3187,7 @@ impl Compiler {
         match n {
             // If no name is provided, simply pop the top of the stack.
             None => {
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
                 Ok(())
             }
             Some(name) => {
@@ -3313,7 +3313,7 @@ impl Compiler {
         }
         // Pop the subject off the stack.
         pc.on_top -= 1;
-        emit!(self, Instruction::Pop);
+        emit!(self, Instruction::PopTop);
         Ok(())
     }
 
@@ -3497,7 +3497,7 @@ impl Compiler {
             pc.on_top -= 1;
 
             if is_true_wildcard {
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
                 continue; // Don't compile wildcard patterns
             }
 
@@ -3548,7 +3548,7 @@ impl Compiler {
         if size == 0 && star_target.is_none() {
             // If the pattern is just "{}", we're done! Pop the subject
             pc.on_top -= 1;
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
             return Ok(());
         }
 
@@ -3703,8 +3703,8 @@ impl Compiler {
             // Non-rest pattern: just clean up the stack
 
             // Pop them as we're not using them
-            emit!(self, Instruction::Pop); // Pop keys_tuple
-            emit!(self, Instruction::Pop); // Pop subject
+            emit!(self, Instruction::PopTop); // Pop keys_tuple
+            emit!(self, Instruction::PopTop); // Pop subject
         }
 
         Ok(())
@@ -3792,7 +3792,7 @@ impl Compiler {
         // In Rust, old_pc is a local clone, so we need not worry about that.
 
         // No alternative matched: pop the subject and fail.
-        emit!(self, Instruction::Pop);
+        emit!(self, Instruction::PopTop);
         self.jump_to_fail_pop(pc, JumpOp::Jump)?;
 
         // Use the label "end".
@@ -3814,7 +3814,7 @@ impl Compiler {
 
         // Old context and control will be dropped automatically.
         // Finally, pop the copy of the subject.
-        emit!(self, Instruction::Pop);
+        emit!(self, Instruction::PopTop);
         Ok(())
     }
 
@@ -3888,7 +3888,7 @@ impl Compiler {
         pc.on_top -= 1;
         if only_wildcard {
             // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
         } else if star_wildcard {
             self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
         } else {
@@ -4012,7 +4012,7 @@ impl Compiler {
             }
 
             if i != case_count - 1 {
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             }
 
             self.compile_statements(&m.body)?;
@@ -4023,7 +4023,7 @@ impl Compiler {
         if has_default {
             let m = &cases[num_cases - 1];
             if num_cases == 1 {
-                emit!(self, Instruction::Pop);
+                emit!(self, Instruction::PopTop);
             } else {
                 emit!(self, Instruction::Nop);
             }
@@ -4125,7 +4125,7 @@ impl Compiler {
             // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
             self.switch_to_block(break_block);
             emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
 
             self.switch_to_block(after_block);
         }
@@ -4192,7 +4192,7 @@ impl Compiler {
             emit!(self, Instruction::StoreSubscript);
         } else {
             // Drop annotation if not assigned to simple identifier.
-            emit!(self, Instruction::Pop);
+            emit!(self, Instruction::PopTop);
         }
 
         Ok(())
@@ -4823,7 +4823,7 @@ impl Compiler {
                                 arg: bytecode::ResumeType::AfterYield as u32
                             }
                         );
-                        emit!(compiler, Instruction::Pop);
+                        emit!(compiler, Instruction::PopTop);
 
                         Ok(())
                     },
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
index 8b2907ef6ff..4c9c29887ee 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
@@ -1,12 +1,12 @@
 ---
-source: compiler/codegen/src/compile.rs
+source: crates/codegen/src/compile.rs
 expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
 ---
-  1           0 LoadConst            (True)
-              1 PopJumpIfFalse       (6)
-              2 LoadConst            (False)
-              3 PopJumpIfFalse       (6)
-              4 LoadConst            (False)
-              5 PopJumpIfFalse       (6)
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_FALSE    (6)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_FALSE    (6)
+              4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (6)
 
-  2     >>    6 ReturnConst          (None)
+  2     >>    6 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
index fc91a74283b..a93479df96e 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
@@ -1,14 +1,14 @@
 ---
-source: compiler/codegen/src/compile.rs
+source: crates/codegen/src/compile.rs
 expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
 ---
-  1           0 LoadConst            (True)
-              1 PopJumpIfFalse       (4)
-              2 LoadConst            (False)
-              3 PopJumpIfTrue        (8)
-        >>    4 LoadConst            (False)
-              5 PopJumpIfFalse       (8)
-              6 LoadConst            (True)
-              7 PopJumpIfFalse       (8)
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_FALSE    (4)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_TRUE     (8)
+        >>    4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (8)
+              6 LOAD_CONST           (True)
+              7 POP_JUMP_IF_FALSE    (8)
 
-  2     >>    8 ReturnConst          (None)
+  2     >>    8 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
index 9be7c2af7bd..37a862cc65a 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
@@ -1,12 +1,12 @@
 ---
-source: compiler/codegen/src/compile.rs
+source: crates/codegen/src/compile.rs
 expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
 ---
-  1           0 LoadConst            (True)
-              1 PopJumpIfTrue        (6)
-              2 LoadConst            (False)
-              3 PopJumpIfTrue        (6)
-              4 LoadConst            (False)
-              5 PopJumpIfFalse       (6)
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_TRUE     (6)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_TRUE     (6)
+              4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (6)
 
-  2     >>    6 ReturnConst          (None)
+  2     >>    6 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index 435b73a14de..6cd7d4d523f 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -2,85 +2,85 @@
 source: crates/codegen/src/compile.rs
 expression: "compile_exec(\"\\\nfor stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n    with self.subTest(type=type(stop_exc)):\n        try:\n            async with egg():\n                raise stop_exc\n        except Exception as ex:\n            self.assertIs(ex, stop_exc)\n        else:\n            self.fail(f'{stop_exc} was suppressed')\n\")"
 ---
-  1           0 SetupLoop
-              1 LoadNameAny          (0, StopIteration)
-              2 LoadConst            ("spam")
-              3 CallFunctionPositional(1)
-              4 LoadNameAny          (1, StopAsyncIteration)
-              5 LoadConst            ("ham")
-              6 CallFunctionPositional(1)
-              7 BuildTuple           (2)
-              8 GetIter
-        >>    9 ForIter              (71)
-             10 StoreLocal           (2, stop_exc)
+  1           0 SETUP_LOOP
+              1 LOAD_NAME_ANY        (0, StopIteration)
+              2 LOAD_CONST           ("spam")
+              3 CALL_FUNCTION_POSITIONAL(1)
+              4 LOAD_NAME_ANY        (1, StopAsyncIteration)
+              5 LOAD_CONST           ("ham")
+              6 CALL_FUNCTION_POSITIONAL(1)
+              7 BUILD_TUPLE          (2)
+              8 GET_ITER
+        >>    9 FOR_ITER             (71)
+             10 STORE_LOCAL          (2, stop_exc)
 
-  2          11 LoadNameAny          (3, self)
-             12 LoadMethod           (4, subTest)
-             13 LoadNameAny          (5, type)
-             14 LoadNameAny          (2, stop_exc)
-             15 CallFunctionPositional(1)
-             16 LoadConst            (("type"))
-             17 CallMethodKeyword    (1)
-             18 SetupWith            (68)
-             19 Pop
+  2          11 LOAD_NAME_ANY        (3, self)
+             12 LOAD_METHOD          (4, subTest)
+             13 LOAD_NAME_ANY        (5, type)
+             14 LOAD_NAME_ANY        (2, stop_exc)
+             15 CALL_FUNCTION_POSITIONAL(1)
+             16 LOAD_CONST           (("type"))
+             17 CALL_METHOD_KEYWORD  (1)
+             18 SETUP_WITH           (68)
+             19 POP_TOP
 
-  3          20 SetupExcept          (42)
+  3          20 SETUP_EXCEPT         (42)
 
-  4          21 LoadNameAny          (6, egg)
-             22 CallFunctionPositional(0)
-             23 BeforeAsyncWith
-             24 GetAwaitable
-             25 LoadConst            (None)
-             26 YieldFrom
-             27 Resume               (3)
-             28 SetupAsyncWith       (34)
-             29 Pop
+  4          21 LOAD_NAME_ANY        (6, egg)
+             22 CALL_FUNCTION_POSITIONAL(0)
+             23 BEFORE_ASYNC_WITH
+             24 GET_AWAITABLE
+             25 LOAD_CONST           (None)
+             26 YIELD_FROM
+             27 RESUME               (3)
+             28 SETUP_ASYNC_WITH     (34)
+             29 POP_TOP
 
-  5          30 LoadNameAny          (2, stop_exc)
-             31 Raise                (Raise)
+  5          30 LOAD_NAME_ANY        (2, stop_exc)
+             31 RAISE                (Raise)
 
-  4          32 PopBlock
-             33 EnterFinally
-        >>   34 WithCleanupStart
-             35 GetAwaitable
-             36 LoadConst            (None)
-             37 YieldFrom
-             38 Resume               (3)
-             39 WithCleanupFinish
-             40 PopBlock
-             41 Jump                 (58)
-        >>   42 CopyItem             (1)
+  4          32 POP_BLOCK
+             33 ENTER_FINALLY
+        >>   34 WITH_CLEANUP_START
+             35 GET_AWAITABLE
+             36 LOAD_CONST           (None)
+             37 YIELD_FROM
+             38 RESUME               (3)
+             39 WITH_CLEANUP_FINISH
+             40 POP_BLOCK
+             41 JUMP                 (58)
+        >>   42 COPY                 (1)
 
-  6          43 LoadNameAny          (7, Exception)
+  6          43 LOAD_NAME_ANY        (7, Exception)
              44 JUMP_IF_NOT_EXC_MATCH(57)
-             45 StoreLocal           (8, ex)
+             45 STORE_LOCAL          (8, ex)
 
-  7          46 LoadNameAny          (3, self)
-             47 LoadMethod           (9, assertIs)
-             48 LoadNameAny          (8, ex)
-             49 LoadNameAny          (2, stop_exc)
-             50 CallMethodPositional (2)
-             51 Pop
-             52 PopException
-             53 LoadConst            (None)
-             54 StoreLocal           (8, ex)
-             55 DeleteLocal          (8, ex)
-             56 Jump                 (66)
-        >>   57 Raise                (Reraise)
+  7          46 LOAD_NAME_ANY        (3, self)
+             47 LOAD_METHOD          (9, assertIs)
+             48 LOAD_NAME_ANY        (8, ex)
+             49 LOAD_NAME_ANY        (2, stop_exc)
+             50 CALL_METHOD_POSITIONAL(2)
+             51 POP_TOP
+             52 POP_EXCEPTION
+             53 LOAD_CONST           (None)
+             54 STORE_LOCAL          (8, ex)
+             55 DELETE_LOCAL         (8, ex)
+             56 JUMP                 (66)
+        >>   57 RAISE                (Reraise)
 
-  9     >>   58 LoadNameAny          (3, self)
-             59 LoadMethod           (10, fail)
-             60 LoadNameAny          (2, stop_exc)
+  9     >>   58 LOAD_NAME_ANY        (3, self)
+             59 LOAD_METHOD          (10, fail)
+             60 LOAD_NAME_ANY        (2, stop_exc)
              61 FORMAT_SIMPLE
-             62 LoadConst            (" was suppressed")
-             63 BuildString          (2)
-             64 CallMethodPositional (1)
-             65 Pop
+             62 LOAD_CONST           (" was suppressed")
+             63 BUILD_STRING         (2)
+             64 CALL_METHOD_POSITIONAL(1)
+             65 POP_TOP
 
-  2     >>   66 PopBlock
-             67 EnterFinally
-        >>   68 WithCleanupStart
-             69 WithCleanupFinish
-             70 Jump                 (9)
-        >>   71 PopBlock
-             72 ReturnConst          (None)
+  2     >>   66 POP_BLOCK
+             67 ENTER_FINALLY
+        >>   68 WITH_CLEANUP_START
+             69 WITH_CLEANUP_FINISH
+             70 JUMP                 (9)
+        >>   71 POP_BLOCK
+             72 RETURN_CONST         (None)
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 11d2a7b5f1b..dd49e679f27 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -782,7 +782,6 @@ pub enum Instruction {
     MatchMapping,
     MatchSequence,
     Nop,
-    Pop,
     PopBlock,
     PopException,
     /// Pop the top of the stack, and jump if this value is false.
@@ -793,6 +792,11 @@ pub enum Instruction {
     PopJumpIfTrue {
         target: Arg<Label>,
     },
+    /// Removes the top-of-stack item:
+    /// ```py
+    /// STACK.pop()
+    /// ```
+    PopTop,
     Raise {
         kind: Arg<RaiseKind>,
     },
@@ -1685,7 +1689,7 @@ impl Instruction {
             BinaryOp { .. } | CompareOperation { .. } => -1,
             BinarySubscript => -1,
             CopyItem { .. } => 1,
-            Pop => -1,
+            PopTop => -1,
             Swap { .. } => 0,
             ToBool => 0,
             GetIter => 0,
@@ -1860,112 +1864,112 @@ impl Instruction {
             };
 
         match self {
-            BeforeAsyncWith => w!(BeforeAsyncWith),
+            BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
             BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            BinarySubscript => w!(BinarySubscript),
-            Break { target } => w!(Break, target),
-            BuildListFromTuples { size } => w!(BuildListFromTuples, size),
-            BuildList { size } => w!(BuildList, size),
-            BuildMapForCall { size } => w!(BuildMapForCall, size),
-            BuildMap { size } => w!(BuildMap, size),
-            BuildSetFromTuples { size } => w!(BuildSetFromTuples, size),
-            BuildSet { size } => w!(BuildSet, size),
-            BuildSlice { argc } => w!(BuildSlice, ?argc),
-            BuildString { size } => w!(BuildString, size),
-            BuildTupleFromIter => w!(BuildTupleFromIter),
-            BuildTupleFromTuples { size } => w!(BuildTupleFromTuples, size),
-            BuildTuple { size } => w!(BuildTuple, size),
-            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
-            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
-            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
-            CallIntrinsic1 { func } => w!(CallIntrinsic1, ?func),
-            CallIntrinsic2 { func } => w!(CallIntrinsic2, ?func),
-            CallMethodEx { has_kwargs } => w!(CallMethodEx, has_kwargs),
-            CallMethodKeyword { nargs } => w!(CallMethodKeyword, nargs),
-            CallMethodPositional { nargs } => w!(CallMethodPositional, nargs),
-            CompareOperation { op } => w!(CompareOperation, ?op),
+            BinarySubscript => w!(BINARY_SUBSCRIPT),
+            Break { target } => w!(BREAK, target),
+            BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
+            BuildList { size } => w!(BUILD_LIST, size),
+            BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
+            BuildMap { size } => w!(BUILD_MAP, size),
+            BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
+            BuildSet { size } => w!(BUILD_SET, size),
+            BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
+            BuildString { size } => w!(BUILD_STRING, size),
+            BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
+            BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
+            BuildTuple { size } => w!(BUILD_TUPLE, size),
+            CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
+            CallFunctionKeyword { nargs } => w!(CALL_FUNCTION_KEYWORD, nargs),
+            CallFunctionPositional { nargs } => w!(CALL_FUNCTION_POSITIONAL, nargs),
+            CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
+            CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
+            CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
+            CallMethodKeyword { nargs } => w!(CALL_METHOD_KEYWORD, nargs),
+            CallMethodPositional { nargs } => w!(CALL_METHOD_POSITIONAL, nargs),
+            CompareOperation { op } => w!(COMPARE_OPERATION, ?op),
             ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            Continue { target } => w!(Continue, target),
+            Continue { target } => w!(CONTINUE, target),
             ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
-            CopyItem { index } => w!(CopyItem, index),
-            DeleteAttr { idx } => w!(DeleteAttr, name = idx),
-            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
-            DeleteFast(idx) => w!(DeleteFast, varname = idx),
-            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
-            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
-            DeleteSubscript => w!(DeleteSubscript),
-            DictUpdate { index } => w!(DictUpdate, index),
-            EndAsyncFor => w!(EndAsyncFor),
-            EndFinally => w!(EndFinally),
-            EnterFinally => w!(EnterFinally),
-            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
-            ForIter { target } => w!(ForIter, target),
+            CopyItem { index } => w!(COPY, index),
+            DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
+            DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
+            DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
+            DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
+            DeleteLocal(idx) => w!(DELETE_LOCAL, name = idx),
+            DeleteSubscript => w!(DELETE_SUBSCRIPT),
+            DictUpdate { index } => w!(DICT_UPDATE, index),
+            EndAsyncFor => w!(END_ASYNC_FOR),
+            EndFinally => w!(END_FINALLY),
+            EnterFinally => w!(ENTER_FINALLY),
+            ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
+            ForIter { target } => w!(FOR_ITER, target),
             FormatSimple => w!(FORMAT_SIMPLE),
             FormatWithSpec => w!(FORMAT_WITH_SPEC),
-            GetAIter => w!(GetAIter),
-            GetANext => w!(GetANext),
-            GetAwaitable => w!(GetAwaitable),
-            GetIter => w!(GetIter),
-            GetLen => w!(GetLen),
-            ImportFrom { idx } => w!(ImportFrom, name = idx),
-            ImportName { idx } => w!(ImportName, name = idx),
+            GetAIter => w!(GET_AITER),
+            GetANext => w!(GET_ANEXT),
+            GetAwaitable => w!(GET_AWAITABLE),
+            GetIter => w!(GET_ITER),
+            GetLen => w!(GET_LEN),
+            ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
+            ImportName { idx } => w!(IMPORT_NAME, name = idx),
             IsOp(inv) => w!(IS_OP, ?inv),
-            JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
+            JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
             JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
-            Jump { target } => w!(Jump, target),
-            ListAppend { i } => w!(ListAppend, i),
-            LoadAttr { idx } => w!(LoadAttr, name = idx),
-            LoadBuildClass => w!(LoadBuildClass),
-            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
-            LoadClosure(i) => w!(LoadClosure, cell_name = i),
-            LoadConst { idx } => fmt_const("LoadConst", arg, f, idx),
-            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
-            LoadFast(idx) => w!(LoadFast, varname = idx),
-            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
-            LoadMethod { idx } => w!(LoadMethod, name = idx),
-            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
-            MakeFunction => w!(MakeFunction),
-            MapAdd { i } => w!(MapAdd, i),
-            MatchClass(arg) => w!(MatchClass, arg),
-            MatchKeys => w!(MatchKeys),
-            MatchMapping => w!(MatchMapping),
-            MatchSequence => w!(MatchSequence),
-            Nop => w!(Nop),
-            Pop => w!(Pop),
-            PopBlock => w!(PopBlock),
-            PopException => w!(PopException),
-            PopJumpIfFalse { target } => w!(PopJumpIfFalse, target),
-            PopJumpIfTrue { target } => w!(PopJumpIfTrue, target),
-            Raise { kind } => w!(Raise, ?kind),
-            Resume { arg } => w!(Resume, arg),
-            ReturnConst { idx } => fmt_const("ReturnConst", arg, f, idx),
-            ReturnValue => w!(ReturnValue),
-            Reverse { amount } => w!(Reverse, amount),
-            SetAdd { i } => w!(SetAdd, i),
-            SetFunctionAttribute { attr } => w!(SetFunctionAttribute, ?attr),
-            SetupAnnotation => w!(SetupAnnotation),
-            SetupAsyncWith { end } => w!(SetupAsyncWith, end),
-            SetupExcept { handler } => w!(SetupExcept, handler),
-            SetupFinally { handler } => w!(SetupFinally, handler),
-            SetupLoop => w!(SetupLoop),
-            SetupWith { end } => w!(SetupWith, end),
-            StoreAttr { idx } => w!(StoreAttr, name = idx),
-            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
-            StoreFast(idx) => w!(StoreFast, varname = idx),
-            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
-            StoreLocal(idx) => w!(StoreLocal, name = idx),
-            StoreSubscript => w!(StoreSubscript),
-            Subscript => w!(Subscript),
-            Swap { index } => w!(Swap, index),
-            ToBool => w!(ToBool),
-            UnaryOperation { op } => w!(UnaryOperation, ?op),
-            UnpackEx { args } => w!(UnpackEx, args),
-            UnpackSequence { size } => w!(UnpackSequence, size),
-            WithCleanupFinish => w!(WithCleanupFinish),
-            WithCleanupStart => w!(WithCleanupStart),
-            YieldFrom => w!(YieldFrom),
-            YieldValue => w!(YieldValue),
+            JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
+            Jump { target } => w!(JUMP, target),
+            ListAppend { i } => w!(LIST_APPEND, i),
+            LoadAttr { idx } => w!(LOAD_ATTR, name = idx),
+            LoadBuildClass => w!(LOAD_BUILD_CLASS),
+            LoadClassDeref(idx) => w!(LOAD_CLASS_DEREF, cell_name = idx),
+            LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
+            LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
+            LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
+            LoadFast(idx) => w!(LOAD_FAST, varname = idx),
+            LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
+            LoadMethod { idx } => w!(LOAD_METHOD, name = idx),
+            LoadNameAny(idx) => w!(LOAD_NAME_ANY, name = idx),
+            MakeFunction => w!(MAKE_FUNCTION),
+            MapAdd { i } => w!(MAP_ADD, i),
+            MatchClass(arg) => w!(MATCH_CLASS, arg),
+            MatchKeys => w!(MATCH_KEYS),
+            MatchMapping => w!(MATCH_MAPPING),
+            MatchSequence => w!(MATCH_SEQUENCE),
+            Nop => w!(NOP),
+            PopBlock => w!(POP_BLOCK),
+            PopException => w!(POP_EXCEPTION),
+            PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
+            PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            PopTop => w!(POP_TOP),
+            Raise { kind } => w!(RAISE, ?kind),
+            Resume { arg } => w!(RESUME, arg),
+            ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
+            ReturnValue => w!(RETURN_VALUE),
+            Reverse { amount } => w!(REVERSE, amount),
+            SetAdd { i } => w!(SET_ADD, i),
+            SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            SetupAnnotation => w!(SETUP_ANNOTATION),
+            SetupAsyncWith { end } => w!(SETUP_ASYNC_WITH, end),
+            SetupExcept { handler } => w!(SETUP_EXCEPT, handler),
+            SetupFinally { handler } => w!(SETUP_FINALLY, handler),
+            SetupLoop => w!(SETUP_LOOP),
+            SetupWith { end } => w!(SETUP_WITH, end),
+            StoreAttr { idx } => w!(STORE_ATTR, name = idx),
+            StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
+            StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
+            StoreLocal(idx) => w!(STORE_LOCAL, name = idx),
+            StoreSubscript => w!(STORE_SUBSCRIPT),
+            Subscript => w!(SUBSCRIPT),
+            Swap { index } => w!(SWAP, index),
+            ToBool => w!(TO_BOOL),
+            UnaryOperation { op } => w!(UNARY_OPERATION, ?op),
+            UnpackEx { args } => w!(UNPACK_EX, args),
+            UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            WithCleanupFinish => w!(WITH_CLEANUP_FINISH),
+            WithCleanupStart => w!(WITH_CLEANUP_START),
+            YieldFrom => w!(YIELD_FROM),
+            YieldValue => w!(YIELD_VALUE),
         }
     }
 }
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 8a70b9a73cb..7f51a5a8a4b 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -547,10 +547,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
             }
             Instruction::Nop => Ok(()),
-            Instruction::Pop => {
-                self.stack.pop();
-                Ok(())
-            }
             Instruction::PopBlock => {
                 // TODO: block support
                 Ok(())
@@ -581,6 +577,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
+            Instruction::PopTop => {
+                self.stack.pop();
+                Ok(())
+            }
             Instruction::Resume { arg: _resume_arg } => {
                 // TODO: Implement the resume instruction
                 Ok(())
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index d9cc404b47a..e9a938ba023 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1337,11 +1337,6 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::Pop => {
-                // Pop value from stack and ignore.
-                self.pop_value();
-                Ok(None)
-            }
             bytecode::Instruction::PopBlock => {
                 self.pop_block();
                 Ok(None)
@@ -1361,6 +1356,11 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::PopJumpIfTrue { target } => {
                 self.pop_jump_if(vm, target.get(arg), true)
             }
+            bytecode::Instruction::PopTop => {
+                // Pop value from stack and ignore.
+                self.pop_value();
+                Ok(None)
+            }
             bytecode::Instruction::Raise { kind } => self.execute_raise(vm, kind.get(arg)),
             bytecode::Instruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start

From 2063c1e0bcd92c0073af438fc151aab03b4754e0 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 25 Dec 2025 22:37:59 +0900
Subject: [PATCH 069/418] Implement winapi.GetLongPathName (#6525)

---
 Lib/test/test_winapi.py        |  4 ---
 crates/vm/src/stdlib/winapi.rs | 48 ++++++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/Lib/test/test_winapi.py b/Lib/test/test_winapi.py
index 7a33f906986..846398f89d4 100644
--- a/Lib/test/test_winapi.py
+++ b/Lib/test/test_winapi.py
@@ -110,8 +110,6 @@ def test_max_events_waitany(self):
 
 
 class WinAPITests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getlongpathname(self):
         testfn = pathlib.Path(os.getenv("ProgramFiles")).parents[-1] / "PROGRA~1"
         if not os.path.isdir(testfn):
@@ -128,8 +126,6 @@ def test_getlongpathname(self):
         candidates = set(testfn.parent.glob("Progra*"))
         self.assertIn(pathlib.Path(actual), candidates)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getshortpathname(self):
         testfn = pathlib.Path(os.getenv("ProgramFiles"))
         if not os.path.isdir(testfn):
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs
index 1df3ff0e42d..44f56f0112f 100644
--- a/crates/vm/src/stdlib/winapi.rs
+++ b/crates/vm/src/stdlib/winapi.rs
@@ -677,4 +677,52 @@ mod _winapi {
 
         Ok(WinHandle(handle))
     }
+
+    /// Helper for GetShortPathName and GetLongPathName
+    fn get_path_name_impl(
+        path: &PyStrRef,
+        api_fn: unsafe extern "system" fn(*const u16, *mut u16, u32) -> u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyStrRef> {
+        use rustpython_common::wtf8::Wtf8Buf;
+
+        let path_wide = path.as_wtf8().to_wide_with_nul();
+
+        // First call to get required buffer size
+        let size = unsafe { api_fn(path_wide.as_ptr(), null_mut(), 0) };
+
+        if size == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Second call to get the actual path
+        let mut buffer: Vec<u16> = vec![0; size as usize];
+        let result =
+            unsafe { api_fn(path_wide.as_ptr(), buffer.as_mut_ptr(), buffer.len() as u32) };
+
+        if result == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Truncate to actual length (excluding null terminator)
+        buffer.truncate(result as usize);
+
+        // Convert UTF-16 back to WTF-8 (handles surrogates properly)
+        let result_str = Wtf8Buf::from_wide(&buffer);
+        Ok(vm.ctx.new_str(result_str))
+    }
+
+    /// GetShortPathName - Return the short version of the provided path.
+    #[pyfunction]
+    fn GetShortPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        use windows_sys::Win32::Storage::FileSystem::GetShortPathNameW;
+        get_path_name_impl(&path, GetShortPathNameW, vm)
+    }
+
+    /// GetLongPathName - Return the long version of the provided path.
+    #[pyfunction]
+    fn GetLongPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        use windows_sys::Win32::Storage::FileSystem::GetLongPathNameW;
+        get_path_name_impl(&path, GetLongPathNameW, vm)
+    }
 }

From 40acd5529050d305e61a00834b331cc3d4c18b99 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 01:29:58 +0900
Subject: [PATCH 070/418] venvlauncher (#6527)

---
 .cspell.dict/cpython.txt               |   6 +
 .github/workflows/ci.yaml              |  11 +-
 Cargo.lock                             |   7 ++
 Lib/venv/scripts/nt/venvlauncher.exe   | Bin 0 -> 268800 bytes
 Lib/venv/scripts/nt/venvlaunchert.exe  | Bin 0 -> 268800 bytes
 Lib/venv/scripts/nt/venvwlauncher.exe  | Bin 0 -> 268800 bytes
 Lib/venv/scripts/nt/venvwlaunchert.exe | Bin 0 -> 268800 bytes
 crates/venvlauncher/Cargo.toml         |  39 +++++++
 crates/venvlauncher/build.rs           |  21 ++++
 crates/venvlauncher/src/main.rs        | 155 +++++++++++++++++++++++++
 crates/vm/src/getpath.rs               |  23 ++--
 11 files changed, 251 insertions(+), 11 deletions(-)
 create mode 100644 Lib/venv/scripts/nt/venvlauncher.exe
 create mode 100644 Lib/venv/scripts/nt/venvlaunchert.exe
 create mode 100644 Lib/venv/scripts/nt/venvwlauncher.exe
 create mode 100644 Lib/venv/scripts/nt/venvwlaunchert.exe
 create mode 100644 crates/venvlauncher/Cargo.toml
 create mode 100644 crates/venvlauncher/build.rs
 create mode 100644 crates/venvlauncher/src/main.rs

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index fbb467c94db..441e8af5b8f 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -48,6 +48,7 @@ posonlyarg
 posonlyargs
 prec
 preinitialized
+pythonw
 PYTHREAD_NAME
 SA_ONSTACK
 SOABI
@@ -65,6 +66,11 @@ unparse
 unparser
 VARKEYWORDS
 varkwarg
+venvlauncher
+venvlaunchert
+venvw
+venvwlauncher
+venvwlaunchert
 wbits
 weakreflist
 webpki
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index a0947af853b..6dc9b75b138 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -18,6 +18,11 @@ concurrency:
 env:
   CARGO_ARGS: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,ssl-rustls
   CARGO_ARGS_NO_SSL: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite
+  # Crates excluded from workspace builds:
+  # - rustpython_wasm: requires wasm target
+  # - rustpython-compiler-source: deprecated
+  # - rustpython-venvlauncher: Windows-only
+  WORKSPACE_EXCLUDES: --exclude rustpython_wasm --exclude rustpython-compiler-source --exclude rustpython-venvlauncher
   # Skip additional tests on Windows. They are checked on Linux and MacOS.
   # test_glob: many failing tests
   # test_pathlib: panic by surrogate chars
@@ -135,13 +140,13 @@ jobs:
         if: runner.os == 'macOS'
 
       - name: run clippy
-        run: cargo clippy ${{ env.CARGO_ARGS }} --workspace --all-targets --exclude rustpython_wasm --exclude rustpython-compiler-source -- -Dwarnings
+        run: cargo clippy ${{ env.CARGO_ARGS }} --workspace --all-targets ${{ env.WORKSPACE_EXCLUDES }} -- -Dwarnings
 
       - name: run rust tests
-        run: cargo test --workspace --exclude rustpython_wasm --exclude rustpython-compiler-source --verbose --features threading ${{ env.CARGO_ARGS }}
+        run: cargo test --workspace ${{ env.WORKSPACE_EXCLUDES }} --verbose --features threading ${{ env.CARGO_ARGS }}
         if: runner.os != 'macOS'
       - name: run rust tests
-        run: cargo test --workspace --exclude rustpython_wasm --exclude rustpython-jit --exclude rustpython-compiler-source --verbose --features threading  ${{ env.CARGO_ARGS }}
+        run: cargo test --workspace ${{ env.WORKSPACE_EXCLUDES }} --exclude rustpython-jit --verbose --features threading ${{ env.CARGO_ARGS }}
         if: runner.os == 'macOS'
 
       - name: check compilation without threading
diff --git a/Cargo.lock b/Cargo.lock
index 96fc9aa8d29..ffcc1e37c17 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3225,6 +3225,13 @@ dependencies = [
  "xz2",
 ]
 
+[[package]]
+name = "rustpython-venvlauncher"
+version = "0.4.0"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustpython-vm"
 version = "0.4.0"
diff --git a/Lib/venv/scripts/nt/venvlauncher.exe b/Lib/venv/scripts/nt/venvlauncher.exe
new file mode 100644
index 0000000000000000000000000000000000000000..2439c22aa932798bbb5e7ce13c34622d7dd7aff0
GIT binary patch
literal 268800
zcmeEvdteh)_J5{L+Z0+RMT%7mRz#&ffGR4HR|k?ZBNITRfC|E@)E6qY3B?DJl2kfm
zv&-)4uKWG&uI%f(y1I&w<)uQ>Vp|?!TNDbcT2OJ~AQVt&3pT&cxigcb1$VzcfB*if
zWM=N%d+xdCo_p>&=bn4VedlURs>Ncl;$JLgv24JV{)*Y}zyE2+>wcGR>SuX7^MlJa
zaPkM2&3xd&ih{-EkKJGXlSc~f{mG+`KISR7XJJ9P_tAm}A1!cByS?C%$L?D=JUhG3
zPy_T&#*I3A#oRkzH~(EbbldAA@cgHb?|SVjcD>`ZE7|q#*REyP`LEr8>)cQ7daVH0
zE9Tzy`V@A(^Yxo>UHkEz*M{Oc<H36$Aeg;dFx_Rb-1lsnW!w$!2hDfwmLZnDDgCas
z97?fRZsJ(-$X&R%v)f{pLib2YHwu|o%XCnVh=;#a%YrIP|0neay)5pHoA`4)h2=Zj
zooZ>+OX$A^R?C_}NeRVPixcn{uSvDcOiGU5{xQ`u3=bn;Ott8Unr~7qtEppu;BUBR
z;ZhIYH6JwENo_aUVHPQ{SQZQ~zwalWpI9spWf2tsuph36kvHkD80<1!&t|bxopu1C
zEZ_D-0Qthh7wZ{W8_`zFVB|Y>PQK#d<qH=*cCUrC-2xgg!Vl<)AmB|z>Hq)t|3Cpr
zX%d5iO$^><7nMkKS-!=xGx<-X_qW;PprF4W)$2W#59OXZm12qhq7d&&XNmqJ!^F^{
zp#`GfVewol1|PS@a{qBG#RB+6Et1kM`nL|dd!87(Vhs{k>rZuNonk0W_%_9|iFle4
zi^B0&EKAR)ojXOPk+-Magd%(nhnHfoj~JYY_7vv<uc=5EHlzWT7;9tYONCjpX5S7R
z3v?WVkK4BpXIFLk@LQh0h4{9r%VNU=kE?~VY$2`_{hwLnASV^Ji%PrfXsFBuNo;zl
zijhLi088|Dlug+oD0@WZgrsz+O${j)r*cA6_KCqs_C)^jCP8Tyd<Q28zHL51X%Qk{
zr|VT#@Pco9*ac{=8ri~Wvfw*}T-%Xrw-C{?s=7!<R}K(-JK9_|`N%cX!co=~?J~jl
zIkN8XMZWIu+ulwXxoYOp+nJUW%91K_r$yxndr=r9FSu*|-NN1T>UQ>`hpg0#%7<c*
z6N7iy#llv}5w5&k3{JC&+&*-j`oUK8BX?3%=J$jnDxDIwdp~7rtxvJYXm@bFUF+Rn
zr9}OzBQ->;(5pjzbZu~1x?{1JsO*x1x7ys*+dKosV2V@O=0BJ!`8%x@16@VoqL?;8
z^go$r;RA1@5FWjf|KM3UG<`IC%U?>cEK=%|P59S_f9+E0Es{TMmHf5EZb!uXg$T&k
zN|83J#D(#~7CC5j6>Te{zv29)0V-~pk~-EV`6G7OvCVsu)#u3<{V~2WL-a4TSv+Gv
zzUr9BPiqjlu&6ZP;fX#)+eD>H-4EJ$E)kX8#N{3841u$V)nPvHD}V)Mw2TeJXhmq}
zGF4Pu?PzxgRms~^c>Aq(-aey%FDz~13*BM9(6tuq`{GGZJLFd7kZY}a{goC=AnYA1
z23;MZQiA+0mCs2BJBn3XiJs`vd36{+&Btl1IWYi3*)wo2hqA9^7uVWNvye{}8!=k?
zZX|37?;*f@r`di{nK{(XI*ASAzxybYf0=6W<cUFVdo1^JEisZ~xu4*P4PjO}Mp&sZ
zTbL!33N!V7eu0W7`q@tX3?6e=hjpr*Q2$a#@Jc}uG&}G|hSOdqCsaEoG)BQwebBK=
zgRAHp(cf+7SNt5g%J|39mP3Hxn!QrL=Kh>XnG?zVd2%BESpJAIes5iM*n1B$e_qC)
zZNv3Q8NWYT#(Qu*@O2rlX(uP~%dZ_F`QL}2YZCoo4D?#j-@#YDD|5%h>K4yqveF@Q
zs&<9IBnDWAGAet4mNp;nFzU5TJr7FAN>oysCGO*%{Kc=kFwnBJ&>5PzMeuc8EbzY!
z3*ojj!Pexgfsl%bu?8^~mSWqyAEN>-RZ>1chl4ua4p~`-VfBbj;yUrzDssROY|`Lr
z13Bo;23c`KHht(FBL>|Nfv&Kqh{Puye2xW7LY+b5ey%W2xLcS%ug+C7G(+OPBcO7S
z74^K&ujBc3kwAFq6#&vE7IqRwRHM61sg3>>AbN}!rPhDwQYXJ|GAH=kCXD@T$#u9-
z5h88rcywlleVy&)SIVLLt^B%ass2M5kwg9I-N6Z&k<9H{F5aX>4y8LYYeBlu{i%^d
zS(&xKrA=0Lh=pfl?(?dyKSMk44wF;e8-S6@2PS}V<uUG7-ai6&6MbVd!+hv!+(zGq
z)E1R_DEt+M%}({w5-1QsZ<DL~l&37{-RTT2{OBEIw79Cj-~-f_s%{^C%k$r1V!zuE
z``sk=-_gbX0SjvFkPD--qKb|k{K|DeM=!?vKft|EGb$r`BQo=sIxUvqyq%k=hN?3<
z;LQy183XVc0=!uV{AmxsyZDtaVV=^9@%}Bi7i#h|qVq6fegu-I2^MP`@9zg)l_6Py
z8@~GI85WCM`EY7zRAy0F8^qW%A^+BLRcL(<^0lEA#q0gD!wZ@}gJuZ)<|VP}Q%kd?
z*e-3MA#VkK-PCShXL#A=xSRF8uWQTlAufJh$yv!?e-<o}!C2uCSfN(4Bdyzi@KTM(
z&G-I8JbIoup*eCez1VknLNUMYROT+D{y<+;`4Y!hKLnAXH>F}osAQkN!@;kdMbpK`
zDx#{zmm>0ij+9>(6_B{Ps{3z9<DVUc2j#fB%tb<z4_txA&D5@<unE5aNd{cI|L}Z&
z{T6@s#pMOjU!nV|x?g5cR^lE|CQsI(EXAW+>A>8PLagY?lgGGPE3&|XTzFaE=v+qM
zS@@N>Mz>NA^7c#6(~iQ$>sQEQyleTua6Eua=^$Erap2U_JSkTH66bA>{uK2l%P-|P
z2!@<fF}@B?DE4)Kw!}%4#t=K0?kBo#ha71yr^F?x{(~8jgZ+uDhbLt2Nzif&pn~RB
zlb+fzJf#4FGjp4=>m|;U7rh<iKw@g-U{>aKWe?>nPEcr=((VuIw7(juy=Z?$G#81C
z|4sT^kpRklKS`(DcVOdQ^ly)Ic13oA{<+#fo%l=oq4+M=eV$bCVbUn{cXIr*|G+4c
zgUc*Jy*1-Qq2}of4x&4Si873S5(2tJ<EyVe6N^Q^hUNsB03rIdq_nCxVq8*b2uYhU
zPFCD-mQaRT2CYmvK{^?e2NnIGl0luy5NhNMPMZpij45R8LPX7~LL+pAtPu*C6?tZ6
zaFj6x(}b@L3R$Bsa<qT3Zx=MOQ5mipC%vATkwSS=`AaP_rvX_TlNo}JN%>$VH1Ncv
zhMjJDiw&`GpQyBoj$M@l84(OdE_9JF(kERvCM2egN$+8XMLUx+mhW|%Ero)LrW%#?
zYU>QWtuBSN6?uNJvBS*93TUl>))FG;v=;JF<UYmZWfR`R0I&#EXMMPo7YIO+J+c<(
zAe~w)yhoB!@_)i4rC4|zx{l=dpmMHJj$bjRGZu3y2lYO4Du-B0&JqxQ#V=6S#J`RD
z3Z)2t{@LGCT}I~!kt4u&C-5Db5&Z{V5R+ggcPpxDe>cG-@hTfTVlgckXQg)aYs?*S
zR$@}0Um<|olzj#(?I%`ZGeAX7GAl)^0LtX1R>n=>RB+RU;F@0C6fH$w6X%H5-?sz&
zl;4}e(GkcMN3B(zmW-M{8>~11l9_$~!(2Ya#OptC`H(nLKgi_<i<@1p&$#g}*O?q$
z&X~M+mlKy$m!F5rnOe;{Yd>|?y_<e4m%B|a`Hx(Fx!Kr%!{rk9Ns>OrSHF4+(q|EV
zgbl>wM(?O^Z`9F^jz*tDX`cz7imtQ=OIu;ksHtd=c7>s&pHP>fG_tvpvq8U9{{=XF
z-^Bc_>+i`*cn>|kL)YUivD{1As6yQ$kLBj#$<*T$`eAQ<-hX5cS<TZ;i;Y=}d!fwp
zfd;fq4h_9o49(_>4v0#Jb}5?=pd!m$T~UkdXyc!+6}eiv3H%nhp)}eAW)isq+n(4f
z_&VDvE+`7ijzj$OVUcUn>7_;R;v4UEP=@hF;Gd63A#09{0mM_SOc|ktSzLi;&-1=p
zUR<(TyC3w^GlwOvsVMBGy2COT)^h@2JHMg~6I22%03lfuolcXR@`O!P9=D4dkV1bx
zQQ_ccfZ05!hx#m5pE9kOPuCGO-A%gTGW!O@a9M#ahv5Q=$1FZc`A#bQgkNz4!cSJ9
zQ+Lr^^u#}@?7R+1`Bd_MpUSW3!s{s^D`@Ff>x)y~D{HVE+d^}*3@boVKEXtnDmlL6
zS8hT^J}?izw}z}EriKQLkYcs6f*Hlts$ItDFT+IPb|>g189i_f3ZVxq1Ol`RKd}dD
zL|a9Fq84=k=n4k3Scv`|jQ;cj6b}P4JL`=$>J6D|+@zDg(erCTr~fTQEer@crzNRF
zSw2!$_!STKB>pBw`<X}tJ=}#Vzv6nJB|1*>D+}o+NakUaTnOnOuDlV}V%wBZ*3C$6
zbt~_yj<-`RZtf@%2h&^|vcYUiS#lkbkH{F^fO!l42+BJS{UirjM(PnL3Cr3cJ+#+#
z)}SKDsSae>mbFt>Z9Te8E<6g@D#3QtS3U*%&dr@RyRcnd_f`sYzEgw(ndQ(`n&6I-
z!9>xz?@@Uu`(N;{lEKJk<n;ir-H+7q@V>%OWd5Rdbqys?CmalHl>O>Y!5oAnVG{ic
zunZK*&$2lA9g!3e=b|14kySJm5aX8q33W6mwX>%^`UCRfq3J!0{-Xzyg@uZz^9l<l
zFM9abdfNIMKqk1CJQu@Pq>q&AMzWFOL8sP%@LC!(&)_km_APjmvfm766UJkuy?$~Y
z9y^k}S8?e$AAnIgt3S#A&|6*^ZU<SZRj*^H?4>d5xdd`RsaO99bCS6mZeyc%D^SqV
zg?DLy$QV$vvak(;PsO99-qp_C8p@ySDvG&^P9^K>!l`=B(??Lg(+2AD&+!=__!nR}
z`Sl}2e*@fF(W--%4l<|KzhBj9X@zn7(74zEjO3MM#EMklO5E`4;c{w7Q6g0lO94G@
zLvH9r{0g!p`1OrK)t500y{d!sD@DG%IC9V~XGV3gg)GpuA|$pVs=dL5f*8zKt~Tz*
z`S4iL-&ym>S$$rP`jG&AREYq}&<R;SWqai7fg-B3SZoy+L2s!kJzL}YUf0yLIi|lz
zpF1U`QHrSflCn*TL<_tFNr7?JxX#v;eqZD27TzNXp$#=>Pcaf5;@j3<<35W#-`A9O
z*SKQ(#9y`=qpVdf?2sJqS9&qX$BLoSvoyWWTuXx-UX^7kC?0(tLmF2t8$Y7*nU*H3
z<CJ=I3u(FpfQf)<PDQ1*2$65n1>cv@#y{}M!G&#;>aAnHnOw7IEH|mfIW|S|H$b#5
zQ==0A72^wC-Np1j@E>Kz_*0{gVSL4f1m#eVzrlv4s{IyYzLmGTG45R$_i(wu-O_uq
zi1X@OXvxkplYakh{I%+nbz3a=(bnYg_W+)LaQx}s?a?$(k2L3LIH};kGX0d-0|EG2
zJp*(<<=?N>hv3~9f{F2GxUfHYjU4EC=)R&B)o0{{k8`xB%)y{sYKNE7@hRZ>w~p5R
zkC@2d;B4PWruil+sJ{Gqk`U@r-@;?>_UlMv+2Em(kUQ-bPi`#t$-PFKWjH)zxfOUc
z8x6m;`DeH)d$l)skr>1z4(EOx`8v#a7~SNc%>&{<ela2c^d~)$hfi%;M-uW!K!9`g
ztMlQzeNPX3>+pC!e0!>9BK1?T*-uIGDTI2-=f(%V#875VWs*_fLqsqc<%Enf)e01c
zJYo7*MG+=}QdP@0`O8^ztxe|0=iDJXKIa3k5VX*g6n^~$kVs!w9U@Uw)y2fny+YOZ
zx*+-!a><T^P}FdPd__X&XO@B<LTEVw^4D1nDI`=KHpP$-Ic#@l9u+qdPRNCsahDsK
zPvjfB=5Q%T={;)l;Z22I_oWuEgMzg~yS{8SUXb}#ku9*57#iI>w2Sd0E5{)>3Pc$H
z0$Y)hup)!kq#G1=(fWg9FTZj%fWn``SCjw29P-S>9Vn570a-SPWZ3|lvu2Tviyp*?
zrwK9c|JUW28-^z2nOixYEYGaAnwd6^3Z_I~LP1lWNs*&4gLbt$YeoUA)5alN3S~=;
zlF2M9&CvAVH&VC!1DzU#=bt=^=q85goyZcsjb?8JnnMF-7NBW%DRM)p@wSn}ANSB%
z(is4y#HNi*Qcziz^!S{;437F+J~H?bixIKhQS7N5<5cXS!^Xu@{;M=BSO1VaDvraZ
zMSxFt$6@2C6;CFs_b?tXNNG8+0MbVCcjS~?#o!X)vL>lC&E|JwE$}&{(U|VBe&9c{
zl*Y$mk(QP|l!AHg;8L4ASP6jpHVpxpgxDV8Z7vYztNUS!fedejPR<AZ2ZIB;7{>BE
z43c*7bSred4f<rQ4;r`<mO)OT7qV<c;DC7l^XmqThI76Odg>p`hxogOcn0~q=3?;!
zUT{aJw=Fsdu#@t`<=*BF4IK|%+BzD3I@J~UX6eOp$U0hzg`<A}jy?4)O#g7`A-6o5
zdGrL|_n$49&99p|y0=HKlmWr|6*4axop9|5eoSPU9}Afu&{%;>(>unk90p6Z$x2u*
zjPTW0ftjLDfsG6ZhNDkVKG5t&lJ4dcl#ju5O_=h+PUUMd#yE@m_iHfD*UkHYU+3Ma
zv=$F*AIm|5K||b*ulSX;^x>|KdGh5k%hU?u$qu+bM{il)H~JU6;;a9_GJN3~B9B?9
zR`jO~GS}`Ko3Uj%AFU#!QWtLEt1Bs+((cAo&vnSD=nR^-gA4M|5cFM_5c`O_bqcci
z&Qz6W1xv&9CRW<64Fo~zXdyN<V7Tb7W$8xtd}P-piXmX&T4Hj<5G&>IGk|7rEyYC$
z^mqyKk;sSHo7tmg*}=?WH;a<YqN2=D6#cCbYuyr8?^eDw>Ha#@b1hxwj!Vi;5DW02
z5iINASH4Qr1JN#ZI~pnmfL;@}EWaT7Yox+b1zT#v`RW>$=L=7c+p)DG2YIgA@=T>$
zY11;0M@#WOEC%O68}YV-;XySf)8QTIBD%$<=V4{AU-GC>wmOwI46da;Mmx%CUjc7;
z5_W$^Lzq?xA&f|hLO?;@slk_#9!lF8f30*vUuG{4s*mEOIrHk*`1<ikUE`p|<Ll*M
zxlIb*jbVCx(^Y6!Y_}3w%LTT1?+9K9W@`thp`+Ad1Pq`rUEfPp9aYFy-alB1F?-z1
z?kUiQ;q_UmFpRz)hQ6k^LTpx^0j^J?0+K%?sjalAo%F|+vL%XNz^osUj3|Ia2KL?-
zy#nhcEU^^wN^i=ki5KJrIZu8MjrnpYwYt-SdFolT!3;p3SU`(~TSv}A4N63J{0T}J
zPQCPTY(BdHDsh;p#P076&&E`9{t%Ri5Q%1uGo63ipgSA7vAbK>Ica%cj~9rj{j=JE
z1+sh(c-=K_sHJ2-iy_xpk*1njb#H$Q6UZa69t`_Gm_xA#6yC8JFA{C1J8Ew+Q$qN4
znaq(QD2=|(KIPYA70?;7`bt7pYDSjuaQHq!*(MB&V5K1fOS2Z56Koi(P^P%L4L?p;
z;Gc^Gw!tspL~rLIXQLcSdx7O#CyQK-oOV`>HEtw(KrD=ioQj3k??pu(I*jq6PFl3$
zO%5&wb$*uKj^ae0#`#T0I>-r1t#Eq3lNXy%OxS>xVo)OY3aYZIOGQQeiW5lNOfQ6Y
z?znJ$bC3C64wamBDa~&F^&Ob%uM-~Zw1Z=v%I?B551x5yfW;Cyc7gNZ)Au<GPx9*z
z@axAuS;jxwP{wby-pQ5m&p2;90ksS@E&ufk7MHTU@^!)AnYm=7i(lW2u#ObhgDnIE
zw>hqd_uuC#+=n;YO8E6zx0aPCa@x08OX^1bP)yTY2v6vbRUUpKrh{9#i8V9RzLR2&
z@UH!~mbFVRgg;9~2`EL*p~GYvy*kB+Sl9P8h-HidKqXxGm5VVQXn!!ey%+tQLCzpq
z_6b<^E^uO12T`rOOn8TpY!i{psnnbC6`@II1?4#CwLOVm%E=!h*AphW?%>KMf?k6V
z8B<r)P2_SayDHcIZ^<Q<If-0g7b2I-q*snXFIghq`i^*uae&ENpwtiWRx0w5&?xRH
zG~)D`PJ?1PT&!~NB4Gpi5VL9SuKna)*)LU{VKlmD3#E&jr`+-E=soX0GD=qV$)U*@
zg^l9r!(!y?z7N(CHz_*`>mICQ%%p;u+6`u+!7~x$36}|Rb{YrwQv<ASq7V4Fa;@m^
z%3N}d(iBmlvWFiG>riqYZoIE>JHLKAV1Sb*f;3+fCt>irs}Fe6C|n^23#=G`&Kck&
zXPO31(pv#03S~i<MvgEpA_5s)BrDtWarYH8aH7rhp0r`|!i=9X>C+ONXs5-}6uz25
z1nJhwSC6KNc%x3WK`-p1sb)Kx#i;g3FRH<LkkG&6(6qCdPkYeMsnq=-0Vl-?co!Rw
zM8FR*pAZ2Nn^yTcBj9!C5YP#6<}9q`*SCO#18xTiXJ&(h5h5YQ3H2c1?L@+CkZ_wp
z!bXs=@cbmyMHibL5GoYPy%&u~3r%~BL@0(htP3l&#jG4B*!B$A7IqCUE0N02wBfAS
zSiRWl|CnFYJM%14av>F1e?sW)hP^Ccaey>o;G|xVao#@dA^+j54W+#a??R$KFh6e#
zN39TT0{Ce%)MHpSGt*)~8GdxW@-tRHDcDJM&yLs4M7jDKEQzzRHm~m7`eyvU*Y_1{
zZN05}eOH~gzV(QAK>J#NTyp!?Z$qS6<or!6gLvXA51g-!6}{?w3mSycMnlxHOQOAE
zP_KUm>W8DujGxd63t4LIL0p|5ww<58r$6r5-kTG3>+zU_QAZR*5b>Dj^EYfLuvpq)
z5@A%jp;DE0xPyxe+|}@3Bcv>lih@$Gco_3Dke)6gWKIr^Ep`VB+`$JB#jzDOlNj>0
z7adsb4qAu8Z9&mt00m`V3eFtb!4y)ynqsLjyqx3h$Z?~;gY!<8g3j@I1d!6xY$U(N
z`#V!SSHZ6LPLzW3c$<j0JfzFnHtpustayJjn|B{#qJ|{f>qSsGbP(S6v_tS8py2ov
zAvkmVFgL0ypm0B>)B+vFTBf+urv&9RwED!P*vvE=85p#Rhz8l=Y8@%Y>Lf>uuO3Dd
z=HpUuPM%nOfDf!d77)lTMn1Q?Lt_Vn3~+q3ixJI=5)_mcTGnok?`c8jwFqGhdoC~u
zG9@_RT3tcEdP->2a4`ryy(=~gwR<mO(PsX7L>qQ{-v{+nam*ZBg;N{6meY!{jAo`>
zuVp1Y4Hbjvlh0vIBW8<f?*sDWpfk@V#BMWH;}jO=+0)k7<@fpg<H|1hPkm1yzA@if
zv&2?kk_mrIJ7$2M3tkYda`2JGVsP-ON&S6@^2zj;OUg%Xr2%3BA(ic^2s!*Ec^X2w
zJ8%hvMc&mc2KyrZ)uz*6jqxNahhS6aX+Jg6Q0fJg($!;wg&sj)z`28k6CqZb7u|%u
z0O77j2{|~$21Dfmlt8SFt|m)xbV45l8JG*V9j&5HrVg!lWpKPb6_J%q(3CT1@rR;v
zaqWOf0_73z+fdq<%r)U^R|6wh;7av3@Xi1)3u}}c%Y-CR)iUGlhwLq_PIVG`RM)$d
zgy10bT{{Y{1i*NM1f@RuJG@U45OIBD0qGkH;3-+lI)bl0go?!A_*0V&N|yw}o*Tp<
zFH<ybDD4^mmX$gkHjBMA+6@J(Rkx2|j1vszeiA^>D8)^JdLt50zG^X`kgzyE6z|-6
zR}7@f0O>HHxzHUTVQ?~$4lSf0Ly$6*_IH57EvSe`W`|InK-vmsCh-7z)7xARGR8?#
zQ<B7O3;vD1Q9$%5kd<BVg~F<y4n38eAD#h{vdgK|#%{;E<4P^e%ofDRBH-^rbT4c^
zkRxfy2w~uCU=)}&^^%WsnAYcp{jM|sFkEj-11+98Lhu>8a;EBYi=}{e$mCcy!bxJ`
zosEjy8qsnoB0A_=OawXI0EdOe<C6Sm3wS@7`0i@N8dAs!lB~S{zi?NyttcG*5S%22
z?&b(~gUfmy(t85&zC#`>e*L2ZWQWGDcpv$t;CR^8Hd(n3b~_st&Y;WcRyx&>z*fR~
z#_c?;LA~vru<P5gjMaM}g9=!?#1K@+!NQ8(3CKX`c3col<3E@WA(}yY6|R$0aMOr*
z+1!bUW-sIKt1aUfgir8`!ylFDKaUL>&E6cS!`tn6yA5x*(OddCumdxhl@ENNPX&{$
z0M|xv({ZDs#37XU0wunn67+Kb5xVywB6q<zNd1OV>F0n}#(%UG|32_{+7ORufU}w4
z`uuosS$u#3NeQVe6I{O^56;d9+R&E-&TfM1|Kq_8-~$xNMBoOP;0FG9aCx2*0+nZi
zy7+$u>SOAL7V3uGMmM0NKZ+o+@hEN@%S8T}M$KN-BKXGgVgC0B^k_mbv*g(6)kLl?
z&cyyPaFNjvv0#4js@`khb}ZblbVSra{x+ICp6{D#5%0BDiCiO`x2;f3;7@5{epC_R
z5kYvtA+WE2`toA-NQ_1SesL){SPDL44hr&#nS){rVrz^+(M2>Y{7#5rn)Rv){jW@j
zec%~Do-=^6#AX*jU}@2vxJQ~Xd}6biWM5B-q~V}WjLhiY@C?^n8o$1_S*`ji7P}PV
z6WYNN8%e~_VvfJG*ishT<>?Pl<k6f(z>fkU4WZ<01n<L|w~1_j6It(VM%Cm%BySf)
z_IM{8iL@5!D*Vcsy0Fz%c%*DImM&HcA?v6ze@D!d6R#vzk7~ZsQk_b7nbXmY5c38n
zlYu=abA1wG@-KPKkV#lL@#Zanv+)5eePX)Lgt({qo1Eq~F06iYn0lUu2-0KaC};zo
z!#|!z4Cp#HoX0LssXf(V+kUE+^H^<-8bUQ(9jA)>`@GoLfn~X3OklZh?KGzWZ9pRR
zcPtgd(SrJha*$lKuBeBrpGSYu*ZnXLV&=zc-|2c3%;N(xJQ(cW?!8>}pDCz#nrU)>
zq#pF2ffS}Ya=o64LQ|#{uEz&L|Mfg7b7v@cNa>QX_@77dnV}h+TWOLCo7`NZthB)H
z@l0_m5z(>VGZ|V>3dPRs$7(@ac^1XClxLxYRojW*6s;b=sahCo7c5j{zq$*C2`yDY
z4|p8)qAD;@svE24h4pAebS_IgRdgUa19wWRzl~(^g&3o?xXvb7jDh!9?z+ei$>LYp
zn;(|N9SK=Hn`ALUde+Y-SqzE$BV=($LKe>^S<JwZEdG(;60&$U$zleMWbuy#mypG?
zNftA3B#VC}xP&a8O|qDQBU$_-!RfMiHpyZJie&MB2K66hvBW>KOLWwE`ZIByLE>2A
z_Fz|u7UkCq10+X%#R!t3@K3u6+m&`x_~s5vXTo;{gg2Jb+MTeOVr{g$1!^ZYgpn6r
zA}>0I2Zp>kG|k;4QtY5hc^}Ia{CZVr{s!y85QuWnK`ZgD&_Z};XnzC-0z~dkPquPG
z7q&;C9ZuB+Z7T$=;n^RHtr}JcIT!bx^O{FG%HDyjW927?tk*DkX9pw(BUT4-r;@n)
z9OCYCY^dptS@MEFDK?+AlNbo;o6lhKuEiSOOJY?Qtw~f|07GC7OyUKC9vN43K)Zhf
zR(%i~<3lkELjAWaAMSgai)~q+hfDXC<pXi~e#`P)_$JSKKf{3LAtbau<f?>)$o$&`
z(zU<^8_v-Lc}%;sHeeH$UWd$2Y?>Cz|8Fr^y#_VNN+|@*ye7%fgq0)IEIFF_m1}V0
zb~N%UGawjXU&7H|iyQ*~t2&o$w>OjRL2&ajin`aJM8(Clk1l&P(lfU#x6y{8Z{a1z
z8!x7(h&uF_DV7qfS!P0hE$xS{Uc}nVW?HDz*wll!b2G6<NxKR=K3n3z^UO>vQhuHe
zPtXKcCJDXv^09DM%bCW`9zoyG;mmB#Y^KN|sOP`ZY)Euw?pK->w_Zn8rw`4nxJ0`V
zyM2Vr7H98Q<@qf15D?&p#4b!g;w&siQ1tId#Qb)&aRd4&jQM8``l}U+gY#>$6JcY7
z+>3C9oss>MFIf_76v~Z7F2vgnCHd<{?^BOpk5nl80QeNQb_5zh<tWX=eF2iULZ`*;
zFf7E6gm;A&<V9SlWGm7~<GGlnhmZ$LE}rMe3<dRF8;tr0tJk7&tf)T1>S4V;V8!a|
zKr(=4znfGaCa?3>$I^}Ztf&tatwnLF$Q7@s^d+=HMKZOUDy4Rx(n*05tWq12(ctX)
z^@&EpXgF`BEZwN|=fCQ`{I|2Gduc(LlV3h}=ybZw99m2ldFV*GV5y>vU;gw^h~ed<
zhRUJaG9>>YEI2kxh1=k>au+sM<dWBVEc~_Big9daj0Qnr1P<8BzjP{L>?M*M+r1e@
zEzy}YD#)zx{|~T6a4XU%P!vYYA}WIU+TV7zj6a6ym8Q#;;3r%M{hVEoVasQHy&qG5
z76%9XqX%&(b18I-ZGq>X3dsP8n<ih9PHY-1AMM0Iw<0{%`x?`S`Na`Zj3cBNhoiLP
zOZT8+$^}v_gwzQ*X9=k;b_G&Qz5$E;975uA+|A8l_`vk}G5FL1pO*9BQ>*odB!Xbb
zffV_Doy_e=)UX?ZAu4m*nA4A<XrSX@e{Dz6DUu-JV*dB_@ZWi!0<kChp3X!pHKrAr
z+vD#@@st^fDT%~X&uvCxY9i6<8EYh36Nzb_tBl07L}EH7uQ1h<j@b*r;PqMxLVdVB
zaGR$}8)FvzKM^8J|F4W+LLHsG8SWWvd=LNNDVb|_7q&W;&-`Ddipoj(vK?aNs7=0X
z7i~r1Uq6ATk*EP1dHHHTgex3hkgt4T2!@-aY{yzc7~~M%p<g#Yv2|i7>l55sln<-E
zYJ*eV^E)YYXMr4gqD}J07F6^rI^|aOMC-whr2k8iV`);X!L49J+!u&sJS;^Hr^(z&
zHyRTvF9th&;a0xH<&@t4C;7)_h4J%f8``tKj9>H#u4nMRql~ZE3#+_hH?%eFGniug
zz+nGE*0Lu2JkwsrKk_m19zmI7xc};;6QD-Ys{*?1SLWg$i(n`&YM{GT+#PELqgCwA
zpx>r+q-u3YJwTa0sz<>kcHBMkA%J!x%c3s)JaPg_kG0_ESQCNSM|TWN3j+gSd__w-
za%wFEwwZz50c@L*^T0ML{jpvecb}cF^vA3;^q`8p><*1TfD!o-Qa-{+H~{^D|A_s7
zB#&Vb0u%nRPjPLfx*3V+=OdyMybBe3=;kC!9s~rC`oM8qPmBJeKDb}c^3@7lCrJ4g
z!+8%4+C4OA_fWJ;APjR==JqDZi<1KX*g*QZ8<OlXfImhZ1-y>InNjgEtC*ocm7?#6
z7`z57sk=Y~{v%k>i}zDK`^%uIeJXROM8_G#{)?fz3cPEgZd55$eNOSZPV9XNX4SIg
z#3qFCW*`7AUCfM#2%pgZ#LFW780Q%Wuk(Hz3<&Y`Zn&j0Fig^=%vR|#gz+OoiYK2k
z*xgF4bh<@~e9bbrGn@1b(q-EK*d}h!M^%PJysQyn{TLgys1#$PUAstj)OrR$e_(0`
zhCappBfv@fiXS#=C_fBx-N_GwjK?noK7Jwn@r$Vd${2I&8ERs(F7|`=oEs+rpfMCn
z;$2L>yk*$;4Ua*og|Ge{2&0EAll}Gu(^{~nMCK>sUkNt%opu*~#jki8A{Tr8WbP2Z
zB7l3*ae`m@6mF&<Y6zY}MAoQTffNgk^o1C!VyFb$qHy2<0*6z1|JM)%m{!8kd`JON
znJpp+eY&hv&Ji0XF8~G>es-A8ffsqcy{ut!9>>*BzSt5yiOg}mF}^ZyVyj&OdlFV8
z=!UHbQsMic=d{oOo8&lAG3!<YqKS^<ygy1Xurk<h(&(&#<xSq<QY_+jVE6GhiFfXB
z^R68PLNQC0*J~Fi%R8){0={0Q_6I@V?Tked7Uu^+YiPA!U=@YUH*T&O70AkVx$qEP
zLl4c7u<yeEG6n_WuLm%kN|SIJT)ESGH6{$qEm&9tPL03`#&I)brBS-PKKc-f>+qGG
zfX`~xUZh<vCMM{-79G8!7VR=16Cko$riI2{%;aUKRM?CxZsiPG?^%M492ba=_KHVj
zrByuLguoxUu$cnfiDp~TTeQ&y>0G;5*o2I{pEgmtLr-xarZrs{ZS7b7XYXZfri1?2
z1jNG(ab>TY`%F@5wdWbWCVFVxer<(GKFpWqrvDagXfnO0g|fyl0`8CtvCZZHc2>h%
z>p|?g^-{uj5giO*;JeSncL2kewS#My4Sf4Ce5WPwtz`ION$LRFY~Tw=%RV;;2SS~J
zuYn=z?b7_{6N#VP0^*2;&F<=N^gZtIvH1_-AdT;_U^EX-q-7S~|0j@I*Rini0MlGM
zDNMxhv?x6gKQjk%GXF{={x#uA9+*N;>@Jn=5Q_!vqRHDtYvuVecLKl|{a__zvAp0y
z8Ha8hgB*49*bW|RkQyRbhlz;|wRCYS-^<ED!X{e9kiq7d6Evj1F|pJZxp9U9&iG)6
z8uk}0lBVNlZaU%DgnzAgnwd^@HnBUx5Bgu&N@somzZTD6H`k7_25u@_jV$?gDn&b`
zpdKC5Qt=8^%gXY^AXh3Ehz%JK3t+4Jp)F5?wfR_{s7x-v_#cL3$b|VLWo6oE$cAEl
zQwsA_nZ|G(0;GQXE^YaNmmTC)x30iKODOvhq_LAB+SNB%O4<cTLG|kTYRZt7Z#=%F
zKVHEeBb4FSNZHBsZF1KsjX)a#1EN35%lxEmOl4UIjNx)(s<l+uf_8;&oDTI;+~PC-
zw83EBWd6mzb4Ww<6z^Y((x6VCz=5TAxNzP~;SS+cT?QPBv55AmIX)5eKxd;=^pk^g
z``F~Z`F*77GoB~_RBR%B$2Yc*W$9Yx`)%}|hz<qJ9`(UxHtGi9E!dUaR?j^Arg{qT
zi|CO)4Ee`7x1*l-Q#?E7n(Mc`#qmFz19piXr_Kl&ulL~roHpuuvFc14?ma@)nQw6Q
z&J=vzFFsQieGd=u+^^ul%uTkxXGqnVZ_V64e`YRQ7ZZGk+faCor!eZnJHc1K7>^^%
z$7>#E=&4HuUo5NK=KH+ccjl<~9=r)Jn~MrkfNjN8hAIEEwGevRt-d<mcP6EBJj*j$
z4Be3;JL)Q~_Km%G%kt|`B$bL>LPf&-PnV&{TdCTGqB0%xcd;GI+m}F!Xz6cpTFP4~
zIKKlC<#X&cb8?J8ZJXf@HRn<6e~3r$DSP}~S5@X?y(g5r=v#FAy;kz&#M;UlxVa;v
zDG)IJ?z!GR^f)(q67)t$JVZPHtFVBj%Rn|#FzLdTTLLQzeo9KDp1|h+Mvi~4$$ugr
zF>PXKVs|}u9F#S<PJvK}$c#h>fOVf(mtw*2%0h&^yHiiL3;u%?G{Vxl^t7zxv@?2|
zEjf+i%K*}voc6u{Fpn;@rc=lx)+3jdH8^v>o$IZ4=AL?rUtii?rrZX{aw+1ya-y_9
zirV;Sl*gTLI!yi>&-IjaRg@Gfx+{-TSRmbbqAGQGRU6n07c`iIg!~X`Ix!q@+QP+z
zW&2L$<~OU>`l4I$&Y(%7|9E~R3YrK&>nPFW2+@SL5)VK(EW{Q)NKLC9cpuY~L6bJ#
zOl#NEK$Aq;aXk$*Nu-_7(?F9%+DXs^(r{o+>9_T+?}#GVUlT>Lj}S$^1-fO*Y$6H*
zy)JySkCsD?9U?Xe-~)^0O+*OP2w63^WkW+NrlW&M9oxymyAbsT0gvrxhdSiK?OvM{
zDsIOtJsc8Wg0l*;#&Z#*DUEk%DLKaSrY=yAQfARnTlo-%`aWrssj4DkaJTf1#Z+83
zn-YnMql7&!1;^&dMSErC0FHkVGtWrDr*mvbaAWnSuv^OPmM;5LI=x4#KIP2>j&{_v
zWJggLn0fjWJ_7LZ^btuvY4V=Xcovwd+1N!^TG;3@#}2iZ;&Tev(sEUo4`ivx$H_dH
zaQw#EJdw6EA+yP;a8a5LaC%7B(ZT584G5OBz;PFbC$A7j=S0VI;Rg_a=?>LAf_!d%
zawC!&>F6<csESsOkQAX@h;~Afc$b-FF=Y=4!_D_tUZ(dK>hEVZ&cVyR`pcQ&k$97C
zzRAOzRP&7uZ#a5`L~f#EW}}VXlmxTFf}>gTH(7A;x?s%y6DU<qn;3M4tx9dx3EKEm
zRco;v!*)6}&SE<j+w>q%;3qY0$bf8+_(@>}YfFNa%n<+9f_Zg#Y!IMH)A%rwF#1!!
zOtEZS2jH9NM^&HET}4V`q^)mJOI7E|!HBxwi1=e7+je*8Hk|j9cK8d3jNsgwp>Qkq
z6&!WIx!E1M)rz#$_Cy+GPoaFaL>lGeD4#WvhJ1G*ZDtM94gp>*;O(0n%z6QbrSv6z
z(}CdS=W5+K`zHmht0QWzu<<w4Mr`w_>^C_m6Rc>i8!AJeP2|0vbotEHXC-LVr)l-a
zb4?+1WvCJ8^xWrON@4cBOQ{8)V@EXhp*tEYZFG1O^bU0>9Y%*gqH5<WI5ZKS+At#q
z4#Ytikw{Bmm1urRaOR4F1iI9JR-~;$^UWqikUfR+q4{PS>u1WB)Kuh~&Xok^6-YaX
z=10){rjnrbm#7lW-zGTVVR<g%&S{<)w63D&Z-{{#;Yqu+vR_HiNw8Ejf1AfCu=bZ+
zK64eKS!>19EizZ@xyDHZAjJc?U;PRZfZSSWe-_%`EI76q?GLl|gW&P9-mTg<j2>}*
z@L@a&8!==|en<m9eEqr34+9c?O8uNl{hXCZBYvR1r+!Z6n{)VKaxlM!var6d)BApV
zyzd<tdg%KB|C_!ak<|CYv5m{rhyGLlCyr7>^oqZ;pu&m;f{eACzjJv-U$(wE3^Hk6
zo$lo3{WK{d0v{b=lS6~<Jd9a9G_DjEie1e9HEs}w{BvAj)>LrV7BSK_8i$0P@s>am
z@+<PupIFMEeK7n=9uKs+34d{ar|9VR3=%{6qp_h0vhpJD(dfgN_u}?fWq;ao*W`BW
zF6N)FmqKGJyw9)Yut7SMcH>vr<^}bVE8#b1r65{;X*MLPvvAuJBcs;?hE&x>>K-46
z;1`qi%oHr&)}~+@Uk-k>xiXuPm#@h{)=?agq|Dyeqo<()QR_idob;01`ca2i>qp?i
zTJOURTK@zty<0zmwI0VVQ0qSe6n-V`p+=Y@+KY)exxG)J!t*rqRRrc6E!9{>=WVEj
z!f0p*fb#*!&VSR;!N|%QN}18net1?IuV{l{8Q1ndXzug1c<iP}+G#{*D~x+>7o~@>
z5Ey}*C~PU?yVE-VjAJB2iY0a&j-k#cZ}={TC8S7IXFJ!=f*ZJ=(heg_8DExml(O>E
zao`!knxCsJXm-;7VP`>OL1Xl1<je|Xw-EDeAP%8*plg>9O|#!)i9|R`yby_49$1Y;
z^-N_CpMS4-siib^F2??11WQT5k+eTg3eL}id?-|@8q@-a*wOO_7eH{_URLY84%#sX
zDdOnl13yKQJ7n!Ag$DGaX<PXKE(~pmIlhP&xepQtb?E1Z+=)UEJ9fib546zvAzi)B
z4`IR2bbdwGH{KheRO?5A)VV_gE`Xg*r(D$C3a^5|cB2S^1D;>=>-r-gysGO(V7;V9
z8&4*dap(xwOebR;MBl*kWfbvs;V6r{!OjWvnuLusGe$+Ef=5%Zjz()@Z4<brG@5D=
zhnh}SEe67hgUBd3zUNmG8<9f;d&<d(AwoqcDdfWGjubMNcGGTJN1|}Mv;*iA+-|@E
zR2bu%)@-Oe<yMj2i039y#{h_vBR8lWD2*7B#dK~68K0>0Ss$1Y{eB&`8MEUeu%g?c
zUg{y(onqmK*s`l*L_1*-URDZ-fiQ(}yuo=%vAvZsj8RdnNr^C3U@7TWaU1vzPK%-r
z30c{(TOI1=iXO~_8KDP1^*k38ktnnoLMd&<a#fqm!BBOrLD<ks4X(A+;szJ#;o#n7
zN952WZ<C0)F&A8?U6Ca3f~9X8p@-NdS763P(kaC_^=yc9^yd|Wl-AH3u4Z0X@SXKl
zei(%wlN28=I!^Ne?1dwC%RrAd;q=Bd$WE<HY4W$xMoxHaa55XXulyD~q(Icsp>{Y}
zjjfN4;@8bi#nM%zt-pR?Tjuu6TIg9=8|4El0T+SCR_!7>=>g{=Ix`#LiRz1|)JR)a
zW(00IM3$1f*P`}6K`dnl5;-o5HkK@nxsR?!cONAxyg}-`s{@vo6wHti+D%bjwlYC+
z*@WO^97y5nLn-|zr5_@6!oYlC#5uZ+U$GCp$ePK7+PVwz=8!A!#nJ&ZMflHNwdASj
z4%DFg3$d$EZ?=BmBWU*75>anAJJ!*e8DYa>B}xF${fV{<{x7g^b*GTIl^yTJ+D|p3
z{j8Q;?SVKI!h*7u5-UqlpLDPFS!^LCGZsxA8O_AlVz*aCyTQfmwmf>$yoEVu-VTX=
zg4;MX1!X6z=@tCW_4Z{2=SDXn3mpxHzF3ll_(xU3VNDn=7t#GV9H<4`FWadsJn{ya
zelH+5(SYpX9=0C{)ZpqSr#(&~BXjtnzrie^{Sq~$980ug1BH=*Q$Ua_E0KWc1ti!K
z309V1O(dj&e*7fBv(}WRBbb@lduRsiy>8fh?sW7l0)vC@Zb{+a=o38#X%GDjV?`gN
z%hn{goL~7RjzUAoHYVw`x1$H}0Hrp5ifm#8_Zpw^lbzXqY#jHLBL%S^d#Mej;c^X(
zqy7vH$dK_5{xuvZ0ZURFmaKocv7w4P0DTO?6f<6}o7+xeHIRm)Fp7%|k9FYG6CcBY
z(pHfR8LS^X6oHRfcn7^?(cZ(WZ@j}1zNNpahZh!S1b?H$eBaGQg?BK*ajwx(&o9`a
zL_uvLIcJ$LuXEFZNPzk|9bn|<_UV}c6XJY6m@64ORLKPTWTcbV9-i33Fu&q;KxgL@
z(E>E)KEa3)4B%15uGjBzjvLYnz(*cz7Qn(I4(mIKLq+hCf0n|=AsE-fhM-VCicxM?
z|MVz5!F^pXayV8v>=`5lC&T9m$xH#fq$b8Yh6V7#D|o(l(S5D4*jkF5>rsR}l6%{z
z3Y6PV6&9hwo!FXWY+{Wze}Kqzirfz6HX@^baz-==XiRh0f8z1#1<YthaF1OK7U8sL
zn{R@}gEN=X{=&)<(J+Is!>|#Yorg0RXdE%T%;0N(S0Dbl41_8dASc<D%sQWE9@Wh%
z>@h#Y&+}oYk-OR`EQuyaw!0OxBNm9@oPxjB)mjvj-u=$_6W=kN5Mtcz0B!;MU`FZC
zZcFCRNxr8qivg{$yYL7U51Kn_5c}jt$9;`8Bg}y92uy_YIuMqWf6;m}=EMY8zPc8S
zOossR)o<fYa&%N=NlHw{-u3A1NT3^SU_u|4m6+Sn!LPWP-l1y>J8{05gLeN^jzVER
za0y<3Ax(V<enWd7KJYQI9XVW@z28JT@L;|dL(`exMl7uL-Y$m(_-#;SE6xly)_a08
zbFkefKL?A{?xMpI_o+K`k6YRAE;=M}``wxQ-Itx9MZ)S6UMKliu<*BJhvtae2SBBV
zJ;CttNQO84IMql+f+ju^LM9#9Ly1lOAe3jip8p~P_v6|Gf|fL2V}s2tSS!GyD-KzQ
zL4c8>H@Uh6w}=6jmCsqnVKkoAE?JE@eLWFdJ&2adF}JeS?NB|4J9D-9Mq4}u#`b91
zlM%{Ir^9OWP9&r-J_ooRNBC+hpkui&on5pP#;0?Vhn(Rw(*3Ol^D{As@L2V5J)1Hv
zq0K$P5;E-rv;i4fJ&R)n=l9V$pB>R1gq+6l=wNs}M*ohoi2;`IN5y7fSVYuU03z|4
z`Kw0K(4)hBI)H7ARyZbL+|5{n=sib@7r}ZHX-B$UY?z4nDGWo%5<8BtlNH(oP97WD
z7aq!f8ETE1zX%3LUp4n`)I$C<{rnHzDfZAv^@hiKDQpS+u;rNVi5sCw?~4gP{G@Gp
z5h&3BHMW_d(zz&t$+7z9m_`dDE3+;5eg%^MiJa`YgIW>F{gPd>?>3Wv%WlFe)20*1
zP?{GFcNXG#CVO_Ps;i7)O7-`m4@o%5hJ`9G4oG2b4^FqMHvkcJ^Id3m5B}@jev*;N
zf9(4P@apRwV4PczSSv)T<IH*@H4bQTx5uzU2Ir5EY+%R6Ux|x7egMjgKVx#39f1av
zMzgOW{1S<)^{2Xoe9-YRKB|Dzk&In-VsJWI)Z)peD&%0XUHuh2HdGv+Rv=b2<aE^$
zQkBhMNBv6<QUT1e91A?V{EBhlP&t@`)k>VD0AYF?4!`fjV$1}jV>(W8h30HQ2;gUe
zzpjrEDsB?|9k&Slq&l37&adpJXPU?fp~YMLhd=Yz_d$M^$H`CnRPdj%V?7)4D~#=a
zwz{R|uu-mc*5s8n6eF>|m@!8l__zR%rm+~p$>yQbYcV6Jc0{fD#_Jny`08IG6NzKA
zm>3GI?6O1I;8?^G9c#q1&0aO+L6Jie7cE8F22!*I-x*BVGw`U7NIbWd=j%JhaNk~T
z*F^;GJ9s}kge~N{4(l$^EddNiFaqGbYY~)*ZDp>4siAxq4Ln-&_D5165pNBR>W>J8
z6n@3K$ge-ucgsp9j*-L`$8}G1hvshq6+y&MWs^U43qR?kzZ(>!eFk`cN6Z<j0G$tm
z&h>plPc`|^5S6?AF%a-2<S7mxwieq?7uSr&#|*m3$B2q$2t#g<cSW=j*dUk}YXfAD
z+`(ctaT5D2c(@JrNIYP3Y<u}lpp2DYC!`{C2Hb-E;Zf92YHz|}?b;QLUfR{jg@SGA
zu1o|@;S_5;r{X!wm09b=+Bs$&$2b<=c@wlo;xK*YCaH4r0HjL&{b2A=_TO-i!QO}q
z`=E!~?_o$qpTnYVn@wCv+wS1QazV>+q1V&$Cn8nBydH8<_mbti8uj271B?P0)8>Vl
zA&jzV{r^REPyi?gf3%G$91TJNkU;^Q-q|4Jkq!u9G7LG@-49_TCw-j+c!l?;SoDLJ
z+2Wdd<pgB+ciER@U|&Fl!D+@I;{$KeJ%_VWK~Xv^lPtin_As56pdaQlhtZtH$=-}S
z)03&r%)la~79+MKOsiTT{6R)|bOHitn_QWV+F-n6wxcU^pG#@f`r#QQKM0a<cPUM-
z&~)&}A@D~n#+b;)n2Vo;P1&9HipweB5ng2{%*D)F(b4G1h|U0mlK+*djt~jx4Gzs!
zuO%_*i@fOTyr^;z4)TbwZ8wj??<xidVB*TY;S0L8+UoG-m07a^Sq}D>gLh&^xz+A=
z?5oI|geBhj-W&=`!Pf<d^q`JKTUZp{JRUccXWpb$1N!*7=6lA5o@^@i#rl-zhn{>9
zHy2l=`D$O*vO-U8VNaucwV%UxWPmz-c=6@M{JOnZv#i*l;Yf772HM@y7X-&51Pl!=
zy<XrfYq=V3{@rzPZB!Te?6d|<d=SLJ88)1UYLT!F2a5lc(AYfDvA1H@q*Y@t#=(t)
zCFKr#XnvFLOdmvJJ42N(Li<mLTdiKOeJWv7Z{U=72QZxP9SYL|n7~?StQ<}YUl~wG
zEa9hzNHH8qmLn^7*tEVV1wRbr3-M3<7#a|BFi6fe<kL)EbPwY|TCX)`C<Pk~f$o@z
zwu)<@g*!)EIqwkGQlw&2F?=!VQVecVtp~4i9j__j5G~(FY$#zghsDokG+n8nsRoqF
zWaV)@*unY|&Z2$T!vQVP-pO*N9Y_dH87Ku)sX1OR&h$r6(j<E^HYcS(cgD*KckqHq
ztE?&3rm=l0%8d8WWJbbn6xb;nvZLPPn6xTC#a9PPW>$hu42X34;Nlzkb-U4z<=1KZ
zXmzf=;sWqZ%KUgm^ks{7H)2e=NO`7PnPQh5$CnJ~Nl4u@PKEnY;Vt~n4uitT$e#P)
zc@HrhS6dv2c?38RA&Y5w2GKEYt`6IDLUW)zKAjSq?^as9_#8)MYRJlv<o0>SW0|I6
z1X_<}`Rk*90U&fIu^2d-7Ld`QLLM%bXgP+G9>C<r;Tqnji3@H-sBc9!fM3jQd8QwZ
zfYGiHm3qm41}9^o-}UnvW!kUWj5QF{tlqEyUhGq1VLN0t+~yJ#K#D!<1K?P*mKE%-
zP;RpWfxIY3X`!@EY)ztL6?7mc)Z_E<9Lnxu$#K|dueuj+%o#tyT-XYY59*YIljebw
z_Nl{R=KIEQUK`^in|3+A<G|Dh>Yd=Uycm4S-=gJ9^6N`%oMy!@h=9fK9$ZZuf$6I=
zC3a<Mo`!SB@L{Mi0*=+gF+=3-&<Cm=tEgiyuE-H1hYB!ehcZVnmXI&;)mGE)S6|m*
z+NeR>x$%eNGWm(kVrCNtG`6Qxd`s1l7w{skxX?(^XZixHE(WIpSyXS}dy^QPT0ntF
zSlGxN1o8+QE<$0oX<IA?h9-aNK$J4tLXC@B={YzRs86-={!wT(EY(%{SiXaGJk^c^
z#{3=fGt2!Qv-zLf@Ydhq<^z-1%~Ti*xFH24hOr4J$EiA;koH?BL)aipZwzd%hgSsW
z2f$+-N~_#MeV6OQ1(94$IE4*Uc-XF9mq4)sGnj#5%`>*>J$UqYOymQ3tky|<poQH?
ze04QZMmY|XTHOf@j3(ZI0+3rCe6C5S#>J?x5Ebf5k6PPEHVR+em+DE%auLe{*cSCg
zBMTkVLhZXYA6FI&jn~l@r20GNcqaHe?%)HzBP5dO{yd#YvB6GY<^YU=)E@|v&O^jb
z(Vx<Dh>qUFmi`mM+6q;}QTe_JoOkl7dDyPZFxMSP=mV2Xa9xxDJlZn?7g*jnRUn!P
zoD3>V&4r4zo?|Df5#IleCHiFCZeqBxCcfJc$1TNZ<v0+;K=&9r(Rap;<A{?8)cFy$
z44EwIGbl|oY(PF#gfmg6z|BS}|D=?pLXE5tt5PxwVaE-ohw<?HK8w59)VwIx$a_)a
z6P(TuYVg$;p=g34o)M4-lK>JVxE7bd0TDr$Nfc7QfE8&p;%b7b)4b+xTl6A&)Vbvk
zkN`%eG)iU2{10l9L-cu}<3^Xv0TP05Jec}Pl0+=m%gE(syKE_!`aj4bu^0340x`!0
zI0F}FU%PGid{rAAvVbohkdM3iHF{4fdtaQ98#qfN#_Z)|^bpFe#z_VSj}B&bG+%u`
zD>Ms(8rm1Bx1=koAqTkdO$LF^b({xNmZ-UzIFa#_$^$LYKLLr2NK8U$El^q`1`UWy
zbck!zF@R_ggaX1~yQ4}-<x<K(XMf1J*+@J3FUP6A)#F*+aI&%utbb(Z7ywh+stQNK
zC<Z^|Zd5a1iy;9c5%A(0Udwyt=L6)TMeW+tCgVH~YAlK8Qtj_!!LUJ_w`v|ji;>sN
zb}O<?XW7t+7B#w+)pir3Ms*RxQI`OhA>);Ccu8M?qOU(i-$1#d7{XH%Uxs2|g)*xd
zh|*d!^$iA!MO~p+^P&IDB%FzP=5}v<kVwe5lVzkqqG6A(UVRbL|H0C+O~RrI0HEd4
z`M`QVAhHnqht*YU^$}D-yhe;drNJ!TyCKr~z;^H~;5^RY5V6(HI=#R|R$vyUN5~Um
zlowf6fV}x_Jx2k{VaOEv`Ue0N0#NiGx+mz1^u+!N=>Kg%|ANucU>KJUxk>GFv%Wr8
zZ%{c(v5C5ml6~<kG5cb|a$rx1=VqBkO|T5g^Vy2qC$7rB${q3yg)?S}9dmN|w}eR8
z^Q1|$yP<JIV@MFu4V>?3qF$iJo9g9Uwj(-v6rr?c$%~ND&N4C~yc@3=YkRYk1TgDw
zLq*kL)CEiOVqv8uZycNZaW;tFc?7QcL#mg}rGYrO%?WUv_Bzd!;Vu4-f&9u_m~7AP
zMud~Gg+JD2LZg}aaR!Zb;Y}tqzIqY$5oGpyP}CTTcOc1kM(~a{OVdoYl9gr*-+?${
zlDS35haxDA^Q~?Hk5OVi!80YyT@0n%j$J1G)OS%f>Y!w!orKxY1ZKa(djkz}IQq^^
z=c{2pn%Vilck~d-J;6YdaukL5GGBX$<(m?<O-(=xFpe2d+l-j}*V$qT*rJ>FdjSHf
z=*==dcZFLPl)J<<0Z87KWAP7G03XQ0>s9lPo7mI5a1H81wF7WDcV5^DgV|_L3Sp3#
z7mg=M6e7Z~1lqqz6#9U2p?mJtr`VS;HDPfBLbi+ZUKOV^#gYQV;Sb_;o(T}t9ic=m
zd|;=ZEu6@99kNCLLCL7&ZHzJl*I9{T9_sz)SrIk|cWu!j-(X-?cp3WOAp^uhcAkmx
za1+#ksGA;=`r4U*v=)$z`VP|o2MUj08lMn$Qxg2S&?}cfkV920u~jU>{$JT!rrTJi
zW=$Q`+>Q<!gASsDCK4UQ2UdaVNfR|xnWu2X0h)9lE`};I3wdOv4B9`b6djNWx+-I`
z@fboSlzTl&7%J9xn~|r0VF<?~9Dz3x_9BL=(V$%RP9Mrdz_F|>Xkk$|qAYdI2^=`#
zJ2S&`WiokkSw2SSUm%|WtpQo70y?9@NP3%+*!=qv?ns+iLn+u{fQi%dr3sVj{&)xB
z%_fm?M%_y&FDV@R)nCEN(*Dt7ou}#u{7|6Lt3!Qs#isyq1O<ufZq}K%V+O{_O^&9D
z{^*WUZx-v0Np?C}1JV45`Dv;s!ka1HYvfQdMC~M4mrWISV1#j#yfettA|g#-z8{2F
zjRk(%qpko(=I>Df00gH%576z20){-Bz<lqa_4<iYFVmQ>j(NvLA10J=7MjtT5cmM6
zHnCye51Ht@9XMHn4~SI4zszRgtI6q#+Pp8w!FzG++83Sz5NXSHA`;p4*cPGYCaM~b
z+^{4<*rQH9{Kw%Ldji`L9*5IRz})xvFmc0tl%jt~8Cfrk=E@obcv#h4*AkLYXL107
z>KRDx9OWS97xnFTbtd==6$`<?7V^HdF_Xb)I4S;>{1rdfi+jrO1sh5Em>P-wi}<!8
zos=;~pN~js#GDG;)q5C3?<|`1E|wG=q=*xS*mo2}ypfc%(1;vbI`(W~{f3xn1mGK>
z@omn(6N03$?B7O&0LF|ESq!Sj2D(SdOiS*Xw^&ZbS6{vp?;6Bff)M-EH!uyN6iF<o
zqVa;nkP}!z<g=)+q96^1R+gnN^?E+zt}&BrjJ@C+G1x2mW-l-|F)(bbEHuE-Q9ZPz
zTeX!qIC=djx(COj6t9A+VlWr2l`d{%qTmi(;KLxD9{#Te)9g`svsK=)Vgt3)Qe5+t
zO}ownL38vVlr@Ax8`Mt5pETvO?Ddmua5}&VcrHHV5uA;(>cun8=RAP=q7OMT7iC)0
zf(VoyVczdU*C@N4s}S0Ta8ps4Wp~0J7h(}7EOG>>F*TxxNxll^lA%V7BNTO${OVpN
zc^;mz<gm*Xx($cub`7g6hpfzoVm9sG0lz?)fDk)`mBort*th(s7YBdSAcj;<677Ft
z^{{UJcw@YtS~LLcM%Ho>7OafgU!_zgzSiK5#McYB!ksGc0Ww-~H<7P?j`7lQNU1A<
zod%jQryL3VDvbs@&%{zb0SlIPsK3KDd@x*KE|nvdbOx)Y3p^-Ml7Z~A=(iMxEM7x_
zKz+t5K5#$jFIa(pA8P8`ctLHx1Z`gE&5gGigXaQpcXTB31`c?82=LeHiP($?O&j7w
zpf9kPwbNvOZ6ep-6S*iD8jjFjQ$h;MOPH$9B=SCtyr3m03+3xQ%*D~eV2mUJEua$_
z3<8~@S45zvR3ySD7WujW0g7Rv05Q=wQeYg&dn|^dvJrmH?8ZsW@SAhqfqJMEHeY~r
z>a+{c=rP>{SD)FaDfyt3F#tYWA8#<GG1CZUjtA`ghj!GHRQO(`NvgjlO8%1Jnt*Rl
z<XWD{wTN<|A4;GCf(#^O?x3WedJ&6v#IeC!;}wks2$DC~CTigW6rzKcyo7Ag=W*W~
zQTnp9(WhtE#hXYgYw;eaJEFt=h(HC?$)=bIDlrFF#g&LqH(gu)j@$V_CTjP0%;W>R
zklo)=$_K7v<yfovKpl}dlv`UDr))K<js7J;c|PzU6$s@vuspa&(@oEJbT)GLZo|Mt
z8%8JEa7Ch8=Dqu`I5@R`B3F#SgV=+!S&Oyhy@78`6g%+GIDyCqkjyFVwQ(~3Gm-00
z2JmABLu10M{#jB<GK1GAN<M{>n8_Xs9N??pITL3^KJXengmSkfvQ9_V=ueTnifmq;
zqppF}e-c@c^IlxeRoE{vF~htQSJsowHd@Tlf$@P`^g7>Qbz%rvv{hzBgm!5Hm#xes
z_HH0Drjalpz2GSfTkWsOB_3xb@ZO^SQZMl=mH5smQSBw^WY*rPvq>>41CFvpKSheM
z;P3#gkuQJ?TJ$?Cp1ZK{5TehXliN?d4PsJ+o5pj$=zpdFO7ovln760%cDP;(@$EF6
zGzsU83V#wlU7gP7fRAyw<9@Xi{vCc8UJj!Vtg#o`A`}0gpv9wc{8ijiegO0Dyy*6~
z;wXDYta7!(8`~LX9dHO2rh&tg1}ClIlKn5_H%=kSNgx5la?+uO`L{Btb$T4gf*y^W
zjV87kO?;FD9X0Vjqls(I+r&0Bu|3g5^^IfaHV|Ka(0K>7<<17q@dhrS_I>?kkM`kX
z@o5+7?Mpdt`!*qeQu_=H673_P)V$lVPWA6P@uy$?$WF`yY5r{|R%}UXquz;WJsU}#
zI10HykU_Yd+le2)(W8+DCnXwbbfS5fc>(offxg7xDZ{ouXsDq<X#h>SYH%9F=rmhJ
zx^Jw_<tdi@N4au@`b;YzZLz<utCA(N0F^>CKr!#cocQu7_S8oVW?-;+H)?ifZ)jMc
zi_nf@Qi5r9)`)sbtY!8<<_=gt^i8K5mu_b3N5Lt;Wr~SQ2_23ARCII2K!rYF_%U;;
zc`t=73RDK`s9+~=y%<a-Y}RW7@b$EQ^fecYfzcE@3?Fy{^~fY+LBEGt7Uu_JDTclh
zMFX4$c4*Lh@6lqv7X#^vowy}C%$$Gv5aIX$nM#uX7*}3sa&&>I=pRxqXBhL<?8}c#
zF?$ZU>7$9(3F;2PT3x0>xni-G$N{rl7bh2ePMo+*g&+yDQD#UELz0;8#v5R)sM6)S
zn}{NsO)M@px)2+(fVleG*Qw+9>X%skq~3fAi=0yEI9Dw68N)GOKV`ufjnw}}!4QK@
zb1+{`AzIqgtL8<`Qu8nYJn=4L-Ft93X9Cc!S%u{~qYA9GCNF{rdbz8q99slYzj=)?
z^BCV#hSxAYWoQ}3S{5Q5>C^SP;EG3(>MLzRsbIJ*jgfBj>;On}*0bX{)P)FpNR@@?
z+3V)8#~Z(V2h4Z?SnB$P(Z8hmlkuNefzqvhjM5eqP>UI|eDz-$-yBz`^|e^Wrtkq$
zdBosArZDf-`-Q>f{oC+_aD&Bs^%hFk7v~VTj{_rhk$AN^`noiHYDiBTsP_mBgI)j7
zJC1D(VodcHz(Gts%|eIT;%xI7Qsc6|7u$>=d%XW;I@^3rXe8>Pi4uXKYMD_F<0^33
z*O=hUy#}=TGdc+KrW=;Ca)iEwrgWnXZWE4^jY5NsLb*SKs;XU;oY~BHNzaTjGO9;j
zr51W0Ae}E(2bPm@0E%)HX9^)ck~)sBro{}+mBdvedUBPvk#XZkxENgZ8wS*qp^Jwe
zdWe430g2B9D;fQw9gMHu`i~ePat1%`B(f>HAQD12fg*I{E2s+sLboetQIKf`c*qVJ
z@!!bFWJKH%eWfWQPN=b0^zQs8fzy>-AsGfXTUhP>jwv1&R&Sx}QwaJjs1Ez6yGMLN
z0;I#@ErBHhY>ulJL3h{SPC2gLf+-19T%ZHxtM5g3X|v<y$t$-XjveiQk%Uh+Ig(cA
z#$inV6)p=f`p<AVXH2Ul3~^5`BWTib5&C*dV$A+69?;Tb5}0jH0u_Kx6H<>!!1+Uy
zK-1q@s|JxbWDaI)v@mH3*!X`l1tgykYwC2ROsB(y!A8^L|AG%Qcr*Ei?x#~dAZ%$v
z)2jWtMNH@H>p_xBFm1vgwvQ6@^JCSO|HX9n=pR|XvQf+jbQfT5+4>}9U^JVSXz}XX
zmr1RTk3~|eFGo)FKo&0N_P|!;hp_|_EKHJ-v++SXLdP=|1(&m$NRK6!_*J~XC_F-#
z;JAAA86*P4kW(c%%l2ZB^-VMngU)j)Teg8evo=}^-ZAv`IJ)F)83OR?KZ?&61N1}z
zf=vogF@0sT^HWwwmZ&^aKsFVN?g^!hq1I6}2tXZMM?yK<0s(*xUa?Jxk+Z1f40O-)
z_?D7hvzQK2f)WmE5BcE6BO?HN2h`1kd=Q7FW1%w#G8n$fupYWj8v&<=hTb45gRxMB
z$Q1ad8%pw!3ZuHDz@*V{K90d=$1-pEacupd)m|FDVsJTV3TJ9Jd*JEt;7vntj}2Ic
z`}8oqVaGCFL>^69`3Z~HLn`1448D2`0oS2!r*yayk^tcZU7cH)7RCpD$sp#A#yWgl
zJzknDrJ}Weqt@z58#&Itc$>1awX(nAmF_s3j$>a4i~7knizcj^7dA@}gVmx03ciBN
zxeRu190ueigHbcz#(Z!7-XCF8>LCWv3Cr5pSMO;j)IyLS$DmvV<<V&8RlouS1Gl{!
zr5#>)o3;ER7kG6zZZkcL@Y~0WLoHk#b05{{Dch5e-yxnm@jKUxC|kUltIc57k=m{7
zTCPn*oiTLa61x*zKF?T6`x|PYXScrk8Tbu*_I3zwW7Cs%2`lT-(%BV9NVsT~!y>$m
zO=sA8gk6n@fTj;o;D}3S@DY_?*NUjtvsle-lY=8^xm*q|Euc>f(iXck>^d5R{S^3;
z+g{SD_F;aaxyx~;{9icPzfC93KGlJ3i}+%K!2`|66+I1u6?~(TGq3PM%-QQ*?buQY
z=Af8hSH~*X3FoSX_)=FdoM@XHlj$#_8#6I_%#kz*ql%(S*u|x8x(3ZshrvOwZ%phV
z_JWTyQ8AN!CSeB{A^cXH*+9B`{%T5?Q6vO$V)s+S+=ZtrW+CU&H%(q6(J~r2(XTz6
zw6qSNeAYDzz5hlM_~e(-(|@7p3q(`q3jPL|y>5hlI%tj?{|ih~!%$X9E~_>mKPvnk
z$y-^^IpBF{C=Hs@OTiaOU=%Z_riWOPb~rFsFg(Eer~EL6b^q;MI?E2>10(5<zOG7~
zJX=rh!K)AS;8l9kdG#vKtRB2N)!@|<gICA*;MF%aQ!DuDm5euW-Z)!g^gQLnSJ#F0
z=kn=QaXwvtUOru@A}Ch{qkbj_;jbnaH!<lU9QEU?Os9{qT}NC>OzM49ioGv6J}GY#
z5N(n}Znvm~Tp<Q8{(is@@Zz%b@M1@~U)x~p6fxzZ4wiY?pj)H@KH~>5S%Sgs12-t4
zSzN&S0zA<p12#_ec1tiPzUP_v`lW}?;_-J%e82}P!pH5sC%%>$_g%cX7cGPDf)D%&
znGFBMA>5wpqUr6wcp60MZQJL7=P|Ec)=C^#Y|%NLc^S;A*?SJ}i`S=s*q@pTFZr;Z
zeBB%cs^w3NjknMk`o(v^5#YKTwAan-H>`4z_u~?jKtU@m=Q;-7{UgD^deZuoC`Ft=
z>+j(KiACoj^;|{P@MGNxW7p7lgte2^;U7V#MDW^ENy;G26feBSP^iM?+?m1w6m(VO
z#w1n5Tuk>22JVleV0;>jYZ1}dn)9g^hB@*$rf;nBLA7F&a42^Oqa5?w*Q20bWi8p|
zp+Q%p0z@8orqgFh;Xu$WrzBs-b0~qX_*JZA7>j)+nn$}Jc47@6-_~d)aX-|EB$*W*
z4HMl2Mayh|Wv#$mV^LiU9A90m7gMv5)mgY?Sd?NoevsOC_oQ~XMW?nmiP{tZarHkK
zwJ*TsTx#!l(P%nf-A>$`P_}zeJof5&DIP*;eClBxl{AP{9;Y)~><i^?LcK<O;N6MJ
z{3xQ+dNV*1txJB0*27Q=w4Rwv>t*nC8no8N5b<T$A7FTGxQPc1j!CR)M&Zx@z<}_S
zw?NNJ1nxDh7=ArW5#;Y8(XL0;zN|M;H|HPhv0N~f4;;Z;f5$ZaI6;5M4DV#rf+1ZG
z#|vXCzM2j$FfpUPe}&PL>|<48nDNz2i(}<}hH_Eei2Fap{Rw<j)!D$0XR<&7ggY#w
zh$um$lDYtjN&qE;8JNKtj3|l<LTg34SP^Cft;mE)gv&UU_O0D*X>H$Pm$%Ut#05zR
zCM;G0Dh*mSpu(LFYS0!Ew)uUZbM8!L0&3s>-~aE&M>F@_d)DWi^PJ~At6q2_$GP$M
z0!BrTolXh6-p8e0J!eXeBVbLn^B|=rt5TdfB7YbTx||i?{X{aEt<-dTs)W#e$9^a6
zD5a)9kyCGrQC)2~66a)Qw^RedTergL?5M~qz^VpuRC>^Q@<ghteQd8f3fa0N*df}w
zBd`x0o~~;@n@zwYjKd44m<8|$sYt?sv%?w^Keu~fD^12+m#K~`03G@n0DPOAHU<^>
z<=2uaO*EUSQ+)ur8kkUPQDD4`n+_<nk=|x*5u&*S;d2(#1k-M_u*UA=x`^5*Jz894
z)QCQ$-@M1G?s8E~t)iaceiZ7tJP%?Alt6z#;^zW+>?qrD6?z7Co<`))>cyQFal)`1
zncjw0JPz&0_{$(9LKPggeF}ZXldmkeCQ$yd_@Xc-Zx<h^az!CF^5wqR=yGrQE+f*0
zCWJS((BWP&<ZAcWA!EJf;o#eWvbfK2P;nL)S0%2&c7W%^IB{SRU0mfW-)=<4)4n%}
zYY`k8K0_TCffV5u(}?_qgnPy4zSoQ$?F_!|&kKxUWEH7?FZ~M8iyu-z3Dv<j5s1kB
z^`4>B7xmO(Tj2;MgmqfPc-O_{I27>2H_AgM1fEterb9YRAA=E~f&$MK{@AyY_&vde
z*Z3<G901Q4V6k<<D2&kwj~N@^S70!FN^JaT7^@f&r|R+$!xwwd0gvUHu|o)UbtJee
zaTOy^T#ivop$t9JnG8<#mA`C68n}1h-b4?$k%VW(z`m7Z2O8d(FB#m$peqRBhO1ew
ztDQ`jK+RZsFGFX#ym3)$mxl!8`aNFx7$7o9q`pURFc!572B1Gf6z{%Z+_PDV@w>?$
z`h@V^Q)2leu!qo>FwY7J`@5}X%Od<<*W)H*D?U(oGtUv(HzC}KSsFtAs@#TsDvW@;
z=o4jucPTl%pB+VDJiW+I4CZex_G(3+;8mcQL|!_8K<xUa$dN<F_clfvo{MyL;ufc7
zhnA%$Mu|f!7fxgs3}XNWRwEy<_yYt(KRxBsRZPL-z1WRL?H0b_Dm8BbjUC4j^5+b4
zZuNv)!Ge!6u}a;C=vbG}zLng#`-mKzI=84HI6>tJenpBJHA5*>Jz@52O4SbFS)UHR
z=B8tSnk)tLtHMk2H!MMsx8R1=u=`3hE+EHoog*)JNq9-#h9w~Cf-jRp-B;pYrgPyX
zVhH2mN%O@h10KK_@grseW2KQ|ZqpQW5{XH6P=(`x_P9yU6=e|S!My_WhONv`k3ejZ
zBXOI#8M{H56KvS_su>z3lYucBmVx5PWCspC=3hu=qB5?n>T>8oZgFP9T%68F?Y;y@
zFo_~k+I>l+6OP_N0Y;~~9Mrb+EFhYH0q~kVEjTqi0c8U{4GMI%B35>bwn9$)e)TAa
z8@WP*R!nw`XXFDx#eNWjuNie>Zac$t>A08ND<<bkmZ3UJE?ERL`5SbW@n;yz&LLO8
zaR8$k0n?@+VY$cmu)!pYKx{oA>e>CHU`k+ahDwzan;d>hO!sikyj$^-Ah(dyA*{Ib
zZdP|C;rrrL1v%pMzcuW|7xuHBH*gz>QC>-9G_WI3)ZiyfyALl|z9PIiZ(eZY#1;9D
zd@+$>4R|(xVmK>kgYE3){|cuufMjz;3DxE_R}7aQG_q*@@2}|Ae+-1|)`QoBe!w!G
zR^<b>41nSJ)_7zv52Eq5!FbHYBMWKyZ|sGHyJzdk3v;<Xvyf+}7V<O}GK%v+07wXg
zc4AHi?i=Yf(Kq7`Z_eX)4*gtI;y3Re?l%{Wq{CxSE|P;L>#Bm5SD>sjzFJlGzWe!J
zWQe(2A|1q|KFS&&RbLsq1uI7E?;@-D<~zKX0pjr7SV`=#&9Z-Y8nrvfS+j*r$!`Gc
zuKclkRtP$=5lnMpW(vV9Od*)je7;T)46C>3ph7Q~u)b&G0=XH7Dm@$aiYp!!*raHi
zyXdt_b9dr2zNJx15eY#psURjO@6mzy6xNc+bZSH}rMfeU*X|WpqO<j?#&^w$`Kj(K
zaYXj3-850!&TZIlw|KMyKO^%o?_GOc8sELAH`?x0g9<O#hyto~IdOKXb4N7ZQ=QWt
zmz+eK(Q4Gb<R;m1wg1Jck1yuWiphDhAI32KY?(av107Dr6I5)}CV0j@e4va&6qC8_
zph?t=nJ{;F!X-MGGpD2B{_`c+k*-_9m>-sLn@2o22rj~b1LJxt@j#{dR`|W4##(&h
zuYFL)48Y&LztV3e`2KZ0?hkPMb6ib?ApcwQBKvwa?85@~0|gULQNmsHDIR<^1L2Rd
z9B?n4IFr9JjYTKi=BEiKsl0}L1dREY$4vOlw=2zes`tH%_q0gUhRBJ**m1gJ3tC``
zRfrj9?Az}~k_L~>VmDp*Zph$kQ{=??3s3hNPqr_>%lTFTUhqoKiox+Rz=DZ;H4F0C
zf)7~s8e=3bQg@&DKLME94K}XXPg;L@JM~0|q`LSkykM&p{L0>HaBJPaR6M3>zm^|Q
zo#xhV`VuL^ZO{v2@>XuGz4>fC!=~hU`;$_7quQe+TS;O_Xnmir&_Dk2t$4eaGJjJa
zwpich1C7q1A$3sbt7GDF-aVS`h^S-!L#zd#x<KWgLT-eFv4VJ4F%}9nNJgBLSz(>=
z;Hq@Bf|nET2(O!aLllp@W<z|+gN!)pz%rV#zRX$WkLEY<xL1xXJCt7(Dfl#~iYXwE
zjRcB9xe&uw<N3BTjHM6OvKpUn8*D6X<0<})B~o2c{6<iQc1H8)&xK%@uEkHl-#Y2G
zs6qumUT()35pjzPq496IU5c=l#WY8}&f8Jzgw@X#{;cn)DZ%DR>GPq}hsO~`@8RFa
z`q~P5kbE_?ug(!(42i?_7~9&k8PADX8Fh=th4lTrQH%V7+Y?ro8;WMnF}jgsdzbCK
zeEKnab{3f}r4#yu-DV5U9(#!ERS7@k4sWi<SMagrp5uDVi7I!vjZL+goI7w&+NYXZ
zI4)dIcZavM;c598xsT%%SyK>+bKK!Q<lYi)_(%Wn)^?gB&vEjcSnf$`I>cY*F2wk<
z7gN?EPR!8Z!>pKCeIZ1sSaYUEI{g^HlL6u`M5a9E+Rqw||BhKYrFRMZ_Ib5qC<!SK
z7q?DH-o!_d7{K=bIrt_P!i9oT`yL3(48Rg%xjuLR;u_~1QBO$%Pf6{z3nXq>=ptnK
z7wE>V)I!Ga1MZw)Pn@^B37omp`lCn_qMX^$TZRi$m{@4W59|HWua!s~)$cVFHW;-l
zC2MRFN1KO(`{6N_D}q;#kT`~A7QQepBIuB@a0pJS=v=?bG29r2h;Kr1DeN~lV$j+j
zX1VOpzy3EQNP${uh;+++jyGTw`ps{Z;E2XomYiSWA9qj3!oir57c95~bUI#SkK$@?
z<uHjo5xkl%Em)Sox$f;HO_SVgDjcgnT<CMW0#3#apW)dQez*dgQO_oBBdNuf_OOS%
z(pT2(bMTR%7Hx^QxYDfvDd>sj^yUULr4(*9x;##NznD8BTX0;qMLVs=S<i{4%F;qS
zmsOSuL22%EE8k_sKllZHSh3+J)O%@>e(i)hG*a*ICns5PTix}pw|<A)>aKTv^gEm$
zbiFI)c_MXFbzfRH#F1H_d~syfrw5MA{H1;8LIruF{!*-r@qS*>tEr+l(bP6M)hg^l
zJfAA<J21;cVTlf6eg1-OyT#`+S3qHfiW%{8HPiYItS-Q>M#>$bTbTSp<N3RscwR?*
z(Co3uCco_!6Ac!TF!?M9!PfaR*c~9ruSsKK9Ud!i(+Y@uwa?5^6YqmI^4Y{%VwPx|
zAd?>MjSdxg6+GoZY=h+AY;}N|TH1-nq%l=*zpi@Y;JNPgGN`@0_L)^BG&9_X#|3_6
zthWi)hW%^}UYblsP>czk3EQC379Ww}O@%huWr73wWQSqy>Q(fnk#uy7>fK8AnLtVy
zC<rSHKBRC;M)Digui|H((A|6fO7dCxvZ}JSWA%Z%6`7d^wa<Ko4z6~u%i%q=>r-bl
z5T+G)!~}4Pa^68@#Dp(pb=KDNvU0^3V&0U>D;(U^lT|6lnzceoVnIZ9=tEpORIca;
z#j#VnV{Ay=BY2dHjIs7UMF$>v_x|y)_kH@J2}%@7kbBIP_(aKYeuA&Yy<Bm&R;HXX
z2Imps0FsNp$^(kKh&YHF#T`e3?EwWUm7q{Z!}P?cxsRbuG;e%jHBKYoIRr0_e-%=~
z7adqi^m#_0g?VauR&NscWKzj2QU>CU)+%U3pOEqUV;ALdpMFBvwt%FSSL@KZk>?hk
z-7k6huudB1jnL|B@?@j-gX(?;N4+nV@{MC2JnAoNcfUvq56joI5q;X>i@XkLb!_mu
z!S+iD(2Dj&!l)7OuE?XR1ilVC+<bt}<z1}m7vUp==R0FnE#V^&?_u8M|3f*w-YH>J
z4(~C--{hUofs36xcnFlgzVN)~r4vMy@kW|T@sHy-H+v87ea68tU{s47E-tQ@AwG?z
zB0CDi?%)jCj60;m|0D|lk%7VEz(s?xRO~sVf(EO^sFfIvKKnMQSX7lK>5m&r|4!q$
zVpw7<+sP9|gs=Ry`v>Ck{E1&rG%IDUw)x7pE&M1^?A5UdjYx!gD@}iFHNfDIT5Z$_
zBZ(6Y+V}7pfjn-&?GECz5H9*#cmbAfqRjS^@sCw~<v#%8J-m;z($`=W_#%y^<hl83
zA(}TXd{5%Mw!p@zTrrLymVyRyV)^y%Nd5V^RC6D0=hE07AS78tO?ti}c<fmZnD6<`
zn6wr*AnQ@H(5OWrf?IzoNKZ_6)XCbEY;ms<J%{W3QMGC03@ejQQ5-o7I1VRw@p&XD
z;=Uh9QC><>CFdHfGpdznuS=ajczPuW@#HlOvT*HsJfj-4TjEZx7T(yJ_ocb$6S9Wg
z(H>^4O3S%<#Ckj^vfY>I$7)}si71(k$AUjk?1rX&?fW<j3ezR)H|POm`V$ip1Y<X|
z7sTZgKN0-o#|xTyV<|xz;b^KI6LUSu7f!*a_;If*rXFZi>$GLsIaURltsI3_!v3yO
zipg@YRH2<mM#CxST@;JOp^)%dvAa@t|Lf)Mj~?Ld>vc6%qJo`y@Jvvx^_SK-crtY`
zx*b3g4pqFcd0L@IoZ|e2dc?JnIUSMU6utxqRdeV(cpf>X=M`on5Sv6ul#jUH5PYuP
zoJG*XOPOr+9b3UaU*Qq=f-6op)^3Ci(28Sp+*iI2spt_74;b=b;%gpro0~hD+}Cg*
z8oWRdq+7A#NIrCdx+?FVP;{7g?ei~HSwNBR;il-l{@h#1U38+d=p8NL4GoTeSjdEm
zTdAT?xr8N(c<xhK^sad#(j@n<1tsEKxu%(1lUMjJa8NCm(1Rqopep=`sTc9}=sIp)
zF5ufS`38RSo1wbU&}STxjtkKWlvdO&ix^Omj*E?&2yYU1hmTwsx;YS=?FhtfEaifH
ztpEHQg<o-qI9kE^jClNIk!GB1fvl=1Kp<zueE<Qu%@fATMxUbz>i3ykQQ#j%29#ns
z9XH0$<5{9j5w9n5tlxq^sPNEKH!v@<u_Yq7&q0oBW24uactamOAJ)6Cd}D}fAHJ*1
zMt|9-BKAMiU)Cmf9Adl-fs(uu{t}G7!SOMwEEc|w{c*)wCsJ+gxm_;-(%nX_P_VFC
z;e7BAS^Nq!+{}}Y=x4z`xTd@SEc@uis#N|3!u!WZV$Bd3y_LiZNS}uFiJ*NNasq1C
zRAJ6THz{H3i9fJC_?_CV4#aW7)9dmEcG7`p)Vv63i0P3!6vaoC?G{WOisGY6+=9uW
zSc%UUD#GtueXq*c6kx_}|C-HMQW?f0)4=+oE?uH;HA-6~=34PxwsBOs)D)iDEwluH
zFOc!xf7aaUt7n&nPD>4YBEyuA%omPp{AKS+fcSvPiE&r}?`HfxBORqIEbvXF<C4$_
zSyD#renCG9$=QuMew5j0&5Iz8_yE;%KA|WHssw8sM%aHtN8*CIa)pDM#qDzs=w(OZ
zF1dzjuV2?|jwzrOszNhNg__u@Tz*|f_IyAt<c4<n1w$1=7*b>>PQ5Bkyy1|AVteqj
zwgUhrdXrX8zo1AWM@oY(pLx(%wk6<b@S6>hBXDIzOrg~08d(<p@_j}`jyM+Cm29I?
z^jOBoO@TXC23#-agXF0<Vxj^T-$+`36YT8{FM&b$ogMN5w**Na`%1PFzM0C}p+hdq
zx(T78S&Fnc>n7Ci=~B4}ZTfM>MF{I4fI2nS=ThaY2`*%B=4HLCWWrt&ajN{#f}h1b
z<gvRe^om{vs8_Jb&oyel%2x!YM$K(q*}5FC`ptc^U}o~oSN2bz<8b^aM3Q^Obq<AW
zI(UzBGkAyQeBMJBg8U{Eil9wca>gUeXoOk4Syr#605^jBjHMM)37oln+he!lfD_Gl
za~uu}^wD^>-*IVEB0mw!v+U6QfKUMY=wLwTcbvd|B9xQJHpP)*@FK-k6E_6oLq_cl
z`~vY@=0TL$<DXEK^7>sL-^MDPTRrXujwY9r^VF!BrQb}HH<9nin``x(X_I*K4fRII
zC`$Qn<jwW!%?0|+WO-Am-ni^MQjdO<XV)WdMoXUB*+P?vlovx7UY^a%NCz&5L`gH!
zLC=58@coW$zL=X^kf$vWn~eKGPdyT_7O0|fJiBZnt9ym`{BH3GQ7*!tMG{6VqE4Q>
z*(<OC1rLc7Q1H+Pn(G<IE#Xy6k6<DD%n|Oa?31k$Wm;PRB9Uqd-l4=m=ZF|c&=`zE
z4^jI1iX=#%LA%|!z$2$SHnAzvfjkKMYU7WwCOyKvzoa3|+|>FRs~b0JXJjA+z4qcy
z0T`AdbhJz(w(Rvr%@p2gpP0W^@X1q$(`eo*r-2;UZE`r(?&oX#EMAM__7>K4yPs(3
zf`_imLU})Y6v8CALsqZIme_`Q^JN>dC?4Gilzov+ETZPz#Kjr?i@E&&l`baEab(|8
z;Cd;LB*G%>s}n59_yL$h;c*v+rn8aZcQ>4XPH5{zyzI95K5*NpE!F51B#nh3)SL2q
zS7vzkguvInJzv8E;)3Z7d-996;(-r$-Q|I{5I3%!iHTBK(Sm2CqMcOGhYGGwyCoF%
zey6yt+!*QLF#4~J3!Dvm^NV2jHK;0H#j)H@v!$E0CtAK}jZJJ(Hx9f89Z_j4LksIe
z7Z3?Oa-?Mb(8$K>$dO_5Plr0&3<G7Ib<@|C7^LPnqe<LqBatrbPy@FoR0qbv?j_N)
zSr83Q!#w$2m)s2H^;p4hIfb;NHCUf}Spnc(Yia*n+zgtY{KU%;oWYf_XFnd8oAZo=
zJNn1&<xX#`;J3U?-I8Bp&p>znfgi0!xR=aywv}s8z_Fj)zEtiM$xRr?9oCsN!^g_h
zM>&2dMJM7>dJWhg)5WJ{<OrDUiH($cB;y@D2W=<dY!rOV>%;^e9+rnIborf8o_p!%
zvs2~LT~P|o2d!8?)th~%_`WxQ9mG9+XF{oZ+^Moy0bM@bFPn$?5(UnoK>RvZAJ120
z7ls8PA}J?@vv~?Bi=)U`Htqwgd;A*1S(#X+9l<N1^9Yctkj*$YL|Nh1ImkfsaM(yl
zPq{uueo84QYoz`238i%dem17FJ0FBc^K}@~(_lxwMdVIs35#nTAKOqzAWFt`xwHk!
zxYA8;of;e817-#<gfSE-Z!u~;)Jlk(K7IYhliL^EfD36D=7d{<(bky^7?lJuAr9!f
z3#t&ukAX}yB0m!h8oN2A&@jPo{w?^nKacfcP8%+zZ1K5>+!l8v?m;^M@<V@;2-{oa
zMFK~_oeW{W`#D+CxRUFnUB4(kBqS|<Dt8-^8MMVP9ID}R5;$q>J8|rg(@=asCqt^`
zvVcucC#?3x9l@S{bIO>2`HBb<#jCAcyIpc5h+4Ah&IcOc;RgqETCC@7<%((ebZ;5$
zSUwST5aGa01o~6ZCj)1Sq#P-y5vk^Z(?6$v@k8vPR`y298>Y;6i6J`#L>a^RVeA$s
zfw!<drU<YRO^Dv%@mFtnxOZGEXpEY_@E1OP=!5u^@)U(_XR;U=LlB>h6UXpU*Ct##
z_0{c+3%@8-LtjGuIhF9qPP%F0U`HH*bPmp#<h<I(Rmm_#(MT>z99N*WU{3myG=q8e
z=Vb7a#AEOs<f+U_pIAb}L0eQ7ZLTb8bt40x0=|Sz3^%)jNgyyWemABK516n(@^pxU
z#Dj_wFZ$Gj_z@997Z_N%@grRG<wz56ur;`O7T?|c?}YD=aO(;bNsGUQFdd&S0faae
z;EZrNz@M?ONE|uJX`MIH%F$g9u%rfVm~N!F1RPO@tX+6eh|F^0y-wcDCH!F%WM*zj
z^y2we^}Iufya8-b-i*{=iI8hKWXpQFnU`(F^u5H099Y5z#{=zIATYT>b&nX0sZS^_
zzGX9{5cNO|8ky@~5lr;FItRDwE;)p-c9U%>AKY?%FHzcS){bA{I9+-4wapxwJ<1<9
zdhfs@rwPFesHV3<H7M{jd-NrMxH-T`2XH1_j+mgtrq@~Lo`+kD1_D5H@`rANX&_oe
zoSWXL7m|m~60IQIGmcWCFfO&1Z%e#<%NKdu<&T?#AAj6=v)MqdHJ8egM{<vRzAfqc
zACk{;kIDIKnbBLt%gy%hJr9K;U7zwAJ~Yc~_}5Z(f##F0J4hv6(^Kzs{ZmPb#73Ne
zYk&XU>bJfk6PEE$;8~%Rz73~?$TAjV1t9R1zlW3wKjL7V1D^-qyvJmOUku;IbN_GQ
z`{XQv@AOew@SRHXKZb8nsxAfJJW@&5zeZ-&{}IX0hi|U)Wccd!Dz5jHH&|;%sUtlH
z8PZIzng-UX?N$C&ID+$?bH(JtHMe;p3@MxGB(#B2Rnt5u&~<Q#50B@t#-OA7@&6|{
z0$l{>wLY#)ezg9ixD6I8!LMR&#jggBdk9s^^@!rRy0~^9ju#Mw_`C&!Nu~EGg4+!%
z$W!!=;u~DSN5oe05#QixZ{niXCCr6`@B}>OtBKQWeu2kqqB~fhD0V@UDE70yj7MfL
zi=Nnb5K_QWiuZC?ZxL@G?&^I>j&*nSt2r=p=T@5HqMhE--B-P3o8d;}dF^P@a2SYQ
zp9?dYqafeCfnvh%?nH}ju^R0<T9SVgxYgg^OUuMY^pt6RO&sudSWiWO30rysWHe2o
z(;|)v*wY{qX;XHCXlefP35Ogz@aiTxm9Z#pa3fj+U)k|t(@18Rn>%{22JCp%djF-o
z+NuCLU$0Qc%0UE_AvW^&F0q%GT6T|;QY%aZ1*+PN&B`OI$Z!_?50?nolsNkDp4QAq
zWz<`JpkDRf7RW@;@J7XX)b!OD+J**(zg?0OBH~(;_^4;0AmoSSX$}BjbTOk?i606+
zl$Hg%Dr3S=g-fEPNk;9r$WI;6Wy1lI6o?gHNw>fskjAdRz(1!g<=vk`5*%r`OFq^E
zR^em=*5cE3{x)7&Hl&dQ1zNOjaO~Pay0YTCV0-X5h$5A`h^j@wJ63#sw^}e&=7hVm
zg<4xxts>ASymHJ_Z+$pd>rV+MTzVh+mg;$6wcXMzZr!S-W=~0~+x?}hr6;$03j{TJ
z)4fl%sk)WX<^y({B2jQhCgh3Vyu2>Rwo{Gf-zzztQ6pPBE|H66ih{F=`8Bx$j~Fl}
zB>0!}Ixbhvn@jjJd!$h|tKBG@j>A>$G(!)jo?g|_=QbSc@wkr1Csx=q)9e|fVAAXv
zDdS7rO+Ei%_0?U~U){a>Sn;_UI%pev#;6u!^vMjAkd_6*ib>6i)4KUinU&DlS#X&~
zoqE%2`Q<<&s8nyNr>K^psm<YzT%8-OUByd6IhAZ44-V`!YR^ahfbfI2984M0T>Jwl
z7djyebimk?7br8Gy+H5R`O{MjDo_hlmR9#^{vMJ)xz$ex*JKUk%T%Hj+w}z3UZ!$f
z%lPqP7ahPhsb_I+W+w1x;@KR)tezXY#H*9~3heqc{OEe|nA_9a;Vj)jwH@qvZDZJi
zv(g>ShIYLbM*=4m{{h69)zP-)84%a<Y5`}>-;hzq!{i44WC=IY@tEv03w9~UBkB5E
znJ70H%axBHGel%CADw_l9vgk8@9;ZW@qWZ$<wCw1&sNSRvc)#ULAjBRnZbfc$A}P$
zLO5(er^g??+eyhl?T4_O+Kd|Xa$pAM-wj`sa2xjsiboZkOWNFtk?{|V3l4&fk_$dZ
z0C@sE&ybb4QPV^I@}ns9m`C7VS=^$nLWI-MPL^C-gu&xWa&`NMzwC%F<}c0lN*KiU
zK>2a}--Ui4bt-QPd&G?$JwZVEHg373wkE0Ug`@*%Ogm@EOq9#p#NNZ0drjn_MJL9I
zdP}H1ajyLJkGmS@KCl?J_m{>e70$h;Ie*bO+J=quFiWC`zf81N7T$!$$Retjx^JLv
zzvC#1BF=ScMkAYMWD1i-YX2A$nBqrV_LR`-#Rpc)4>rOVGB|5$KIcYnB`%ZY>$Z<9
z(R3Hhr|qyTq(7*jI1`Z!`ZQCbrO&V`YY=B>_Ig;?+K)EA^eG#wY*Whaz$jZ&!E5A~
z!};+L*Ux-|fN4qB^P*j5HhZIIRpF0S{6@IE(E`6bo3&%e%b6VdR${C-T6}m6FY(U7
z@RF_-Qck8T#!-*p#cLKAQYc#B%r1K=CD-ec%T&oK)nck{oI6VeQJppmc9Jy^dpL<O
zfeZWz<*dbh=w%MLw*Zwldiirw7pEc`I+w4J%)}s{nIPO!@y)uGo~o69oNxE<LqLrA
z1N~dVcM65=Lg4@6Qe9-_G8xjdsUpu)#HWhfDBqO_#pJGLMoSm?r#dBLUrI*gryQm7
zT2zQ--bZ?4DyuxBp8HT~39>+43&dA|P?E`A5mc>;-N~0LqrZ__E6tB89sAtn|1=_4
zy|Ps9dBq=FBVUZ04|&ZeMlunJc^UDD)Xn;db|^@{S=%8*DOYDQRhqFve#}@O{`$=|
zPWAK0LHsbECGrzhOTZg@TuLV&uUGF>3(~ARxk<WFvzFEEUiVLWfN=wABlC|rh+;UX
zg=-VTogu^R0!V7)CH5%Iwtz&Nl|lX~>KTagwFK{gLWU&V%u=kQWqwxapOyM2tbgX|
zpE>%cO8->opON~fME^MTPmca+7hsjGY12O~`bR;qU$7KvGFV!Ie0n(d@to)4$AzWG
zh8&V~Z9#<wRN=fzz8K5IH9Aw8=;2;3FBoJC^~=BJ+E)9C`E8R%`;Ba_-OR&q^|ih0
ztGraRPfmHQumL(IY9)EhHZJ7J$7OSA1`=>GYRhOi8j~ix%^N|a=ojc#hE_tixg!r%
zv7lqq9HCFOn#l|FPCF!Lb=iw&X(LCjF<fnRPH8~|S;#3(#Aclz)d%E^PGJfT)e=GE
z!a9>Z@ET}>o$|?O*>>nA?-HnRJAGdI$a+q?9y^zwMGIP0j`|Q*WX11CWJ5hHAIyRc
z`h!v9fCC)9>K7zoU;SBa`{Li}dhybZ2_L1nrYBt&OF`LS%M@~HppvEJOYVRl5G`1u
z>kEC!EhKXB97)DpQPt$9=h!6!s${_pe5^D(BU|#5E&k|Lev+IALi-gD*X6#f%Ds>(
z=b{|$P-(G*?@8BB<b$vdG!cZcJOBb*GEJUB_Nx4<nQ!t8<+-vHeF=e39E~f+tC2e!
zsI#wN^~GTIJDnUTce&S{U@!4uP^Tk@qo?LBNz-`sCMgFQ>-0x2e)2Nu@Q13y3wdUs
z8^AhASFcoux6zzWtjY@Hd(st0rI8MEmax#=$v4#E64wQ=w3DtzrSNDhe}+<~*j|8e
zn9#UT#oTC)RdX_xd9cMT*rOj?nmp~)`hqGKyyv;0)HIi?QD=#<4B9fs+!)?#Aafpx
ztoh3DkzOLD<uck(X-wQ$xxBI%afWmL73Ri<f8>9D#_f`)5CyLjYA2d43x2`|Z4n_y
z(p5?GYC*`IMW&;^-D^BuJnPcD9HZu2EPAFa={lcWj50op7pYnC3Z`U#pElRs-18DO
zSyX`}9YeA&CB~>pL&<tuFB%}L%+Sd>L(WvbC&_2$nVdT=NAdf-5&}(Z^AN>xBNYJF
zvDP|9b*;4*d1mUS0n?=GI#!4p%vtnAueDeBo^)LzA7ZYd$V(VHbb15J4Lj~SYGn1|
z`pLYrO$2K&y75~e!59Xp{)my^;#Q$w?qZ&!=Y>?$?@Q=|Vz+Mkr(tRO^`WZi;2A!1
z6Dua5ntfJYsukl-zRqF`4otct`W?ErW=GPsm{e22zL9x34)IKak4SvqL<dwxugOOR
zszjkT5!QqbBk93%`dXyp#Kx$^W3>HM?)V3->3kP4k*;5~9R>4bp(rlpf*sIiPbMBE
zQI`{}WpL}_ck@Qg0<m`<W)flr#u9`)gQ>u}>VyM=idQ$vt6?&~nlEAPKMIqF^@@Iy
zGYjb{`ssIJvW6EA&A~;Rw5yl_g-KT}I+C)==rpW>C6ZFT{wq&uwm@3_m-xP)S3fnk
z=$c!Tt_!njK93Y*Iyp-0=hmmXGVzpMNg?>Gp;jO8%C503Q04el08%$Ijp^&b@ixCU
zh221If{sY`;fFIHr?0}zb&B8(=8NJ)e=wdL<}TR9__V&i(7R6Z@GtB$d&C!l#jrN5
zVx5xz6Kma7q*W-!j$GsW;PhCStdR~lUZF*hD$7Y3wX66m8!^oU{+c(YSiduD7VsRK
z1$=h~3wVwS^vD;_-8#@?Hp_PHkj&|<Bb9XhD)o+Q$Bd-wr;=<|3h8t}9)HA-!W7N5
zt9X=u?hQF5&|x7&(p;#&AhY=Msr{~;La~S-bhDv)4`woe<V|7IS8vQIB~iXnR|;Wt
zgyYq3R4T{q{pA+*Hf@BZUH(CU#{z)z@s%X3d(d(~iyFB1Qn!$JC74({`=QJJ=pQAQ
zH@bcmKcn7)gjAYY8S!1^#&ns#{9`;gXH=`gGfB0fr>M*>Pe6~ZI-yAfE|k>%M(n1r
zdBmrhuk2W$d_Vee`#C=PLsH90f~#V%bNMEpF>#XtB{s${R57i#DH)U^m!pA2V%H;b
zilpm47WP%58zFWOfkleUNV;x2GZ)cu+f`6B^}$i<JGyC%8Y*GAaA}x(OCmO#YS5t9
zP)U3rUDfwZ6k9UC88zF~DB6*?V))a7FBxB1lW4@WDT$tO&B5^cFj+WV#N!P?B{^4o
z&Gl+928M~{dy)EW$6kvfM(rQT!?Uma6=UfydG^P~E4SU|_vJ%#vlNRjm*<!St}MMr
zs-`4zo;D#FG%H4E2S&nz5#=FlfA(1aEI<WhG3250&c{;aeA6>v{zm2)2XpZy(qL3=
zA6UDUqp<2rTq#sk&$Dv5?W1@3Z~(=Z-l5($aQJ?@x8c1KZ)6*LPr*yyWzBc(dblct
zr6Z<XXco7ivnsQW66q@Wp?h*o?U)BLr*k>MQZBtqzs&}UXrO`lJ6OAtS^ja^UX<W|
zu1lx#@G>}t5;6=<!H2W4N01BMdTBK2>KK&Xy&N2$kdm-0wX0My;Q_0S=*E33m-(b?
z*cn0uv_l2gk%J>fkYDx@!vHijCkTGGWnddCF6lVd*0Eo6&et_(cPQ~I!Abx|LBf1O
zx*Z>enVANiVt7lz_;XB0vu7TUV9OxTD)=p10Z;-GkBw10g@t@JZmx&X1S=^pPgH8H
z3zV%DYK#~>SW}Q~r)4OoJilgmW9s}e%7XX`Vyh%w=K&mJxFox?B_z6T#{NIm`O>|<
zISQR-NYw6D61AtVVKKYzINhEUjXr0R{EUV_lYf!jUdD2<*MvAkS)-T0zfMap0nX!(
zNquHxH3E3Ree!vq-JV1}wU=VBz`6+f_taJD6E*8R?JkMa=2kMBkZJs1&urGa*Okx@
z>xSt$IpT``ZzS-z_~>sLNNiR;<l!(z0jYKlKZ!CqPaEPTkxo?Z-Xp6n&3#cM9)?|q
zIPb%BXiuJ6a=ttIe8=xNnA{V7(0Oj~)%YLynvM@1e$b$%AM?r^n<%<s7McO_+s>~D
zP&+bCPr@WaRPu$lO5llDT7^jtMDOX43y)Aj0n>syOr?ZZM>2jRYXOP#umuyvXCwS7
zFDx@05|+2j#|CC<q1VwVzz}qC#sT5<zUg(mi%UHx2)VmMHrQm3FA~;g3Ed{F^`MU_
zkiv=j&dUae4=1(#-T@$mKlbC#TwfeAU!TXm&;!d@#~o@N$HfVb>!+d~B;%72C0*Yq
zc`||b$}2u|i-dL^wZ)bv`H-!j9VJ?Gq`@h-i;un08+&y;hl5(qf%<st8#y^jXL?k9
z`rQM(OOa>Y`L~Ni<~UFA1IPo`SAB3A@za%^6yZ(ly);dfhj#q+=cD$?NjYju_I`%l
z+A}9)VAp^ao&<;peW(mBIFCL6{rSpX37v)w1sVd~q3%V+%<I_B+RVW&oposrke`cJ
z@RPu2Ws6vRL^{q5ZOp_U5+&qMXn%Se_T`VNhrY(w!I_oOe1hKBqd-z0{0M;b>_`|k
zyc96#w+)Tm);GQ``yzOOSU%?Y?#O?{?`Ti9sipj+T2<NOQ%-4LSIc=4V6XrK)B<2Y
zcT3`>Pl^ug87SK^-<5&@3W()R2=V1wvsInTZ&MmL5F%2l(WAyEG)h6sq~fv`v!~Z_
zb76cKGoZK6UzrR6K$1i7i#CujluzD3__a)LAg&VJ#<Mrj8}UC&8!^}GA+)k)$+HSq
zp<Whjcu>}+XC3RJUeN_G-n!0>7K;5*a^S$xdWa*8{Zqgpi~<@ec-ET<c2BHe+ZWdH
zT&j*S)N!)Bw97Z~7wo4WUnTqL+J0I4sgmTW_ER@}nk{o@{n##Tg#QHk*~aRe|0}gR
z6A1QMod@`Vi=SSdMy<?Y27grK85?+|7M#KvSikPJ{>lBAWmj^FW%o+_yW~&Fi)9)_
z7fIQ{wirv5V@n5pX-YgPt0Q#Rzq>NHw`Z)3!5Xy|1fpLpO)m}R>l9044Dd|tS#LK2
z#`WX^0Pr4D{tOT5Hueb%%z8hr=8!ihpMNrcLMMC%KHNP{<}WJBU|smIhU6*d50lQY
zfXBX6vP8wjHps69-k_5C@|Dl7rT3{N+G2Hj#Theuq_t)XfkeO&4?~=V$u$caRcrhN
zdvh+NUfTD*w*Q^#4}O7A`{|<w^Aaq#)L`1+?~}}`zu+F}oatFb_gC9HtgdT^t)u(5
z>F%$x27e?h24iR@eW8`06cGkoIb!8_?XH1TJyzg)S$0=0A}Me!nbnwaer47thDAh?
z7E<uB%N(i9sRLyCzYYJr^KAG(F!}#Q_&-`MgTA^r3;tJ<%!dDm_kI!l-;x}Jm$!Zb
z`S2gX-=Vtl=RR3o`2)#+8~z5)@a@cL_@_b^RHU?p)bjVExlvpHfUVwAg{7UjEl5b}
zU0TJZX^tS2PedBU{j|TWxqigDfQ(9}1bri_Fdyx8Kn4wBYrr1<t`uUoOi&W3F<x_C
zA+BFg#Ie8MXMg8nJrd6Q^WT$!dJC7&aEfJ8WK)Hp4lyS-<v3j2{+ulE=cTaqgZBtc
zJ^*vC%$L=?G<vJ!Hv^w)e4=7PE6qQpJ=2~ObR}IgdUt^q66$)A3R-r%8S6U*w2~Ai
zvVJ|v2Cbbr4d1N57dBlabau4d?0{lmp!fZZX79+a#tvBmT=rEyIb*InSuoo895Fv*
zZd>lLnmln%$LqLh6@2<F>1<^wU2yf(Ypc!n8hH04If{$R)SC3G9L1_K#Ro&mOc?k|
z$zwJdYby%F4;LY|nZSjyroN7+PlW{&?Qy80f7qzqt`evgC_fn2!MxBa*zv9Mq2c2a
zF>O!x`4T#%zw17?EcdiFd3Lk#3(m~w?+AJ3-r`sHS6E6p)?YlTKX3%CAH!b5xddg5
zj56o)On%$vgh;!q?IPH4>NqLZpC;0$SV2xkv4K3h*Xe<?Bs;BZb*Zj_BcZVe&IP7x
z;Gcj-yOe5f8k{k(_=oCSYNFQNBj02c3_9hdzg@Bb9`WpL)H<^Yyv)U3U)ya3jsTx=
z`qSK?*28yyD3k#KmSV-begvSRxU<s`R@s@N8rg91m{b~@%(bN%FO8m-u4%Ye^~hGP
z%2+zU=EZMzEt?j3j)mHE=hc?&v@Wca#Z%CSDpJeqe4YV)i|q;l(Dxvdu{MBXW>4JQ
zcxY$gR<Zo<S-3gg0T?(w+GO>FGW5M%YRmvwfD{)av###0<+7h%HR$cQn>;NJQC@-T
zhCr5s7&i)O@XY@~8a&SeDFq&waMn4P0M|foRZ}<SIP<$E??<YBpe1c%&>)&ZYB?{-
z{IGmdVdAQ;Z+CS227{<AM`HPfEVD7`x~QkXC&gGlpOo2JD(vsOK>*_N!1cB;7U-BB
znH9l1tn9DQ?yiAvAWM27B<h9!*Yu7?8basH(d~+EA1G-pnt)xc){znfHC#2RF-|vn
zbc|s2k#dhYQ^`Pu1~uE|rV{DMUr;h?3&weg8~8J-UO0%h^O>|jKyZ9yFL56xk5pOb
zuJlB`EuLsqTL8a_(HR(+zZP(8^F&7~OY??&E^QU~APTh#qCZz(PCDhjxznacxmxuL
zIGVhXjS_HEt{Qp%=(n9Hs9@r{FeukBRAIXC^_1w1BMK))OGik?vJO~{^GlK06#5-l
zDzsU#zdLd;LGhd4#-G#6+!sFz{Z)mrJL$en%my)lK=-B1x{}R}Q4G86+s?$(CuddJ
z+ASy9BugBHJJD5=e<+jd2m5a~cr#_+EG<!Vzi`M-0rQ>$$a<`4QlPy~ftJY+vp{n^
z(d&WlEx>o9CwiY4@CO{bJW)r$(asee_%?hIeER@jG+Hy^y8!sMi*d^`ak-^o{J!QV
z1K$gP?|9K6B$L0qWBxD=--7`T@QdFP_@3~a3xMw?;JYvMSC~BAnHjs$XR<>YyanbH
zji=}WXJV~lj>z)tvI{u5ECsFKNGXcMXLo^GK{y@20+N80tN@Cv+<`M5STwB+YT^0#
z)Q3MqAKI<OZ!)uvPrc@BVa%u%J<>jrPih!*DZD(rDaFoLo&Lldoy~gaHorEh@Y(Gn
zn@qQVe0OI1xH|eb8h;A*kZe9_{4YvBUhmoz7X@ibsJF4U;Ku{=IH-cRH5Gh^Co~fS
z?a_jK#Qb-H1J9cwGaJpvic1szYr{_7h;W##o*OFD++8fD2ex~YMQG~A0`1nf7GTsN
zh*5SvXbbDGVbsfk>dI3Ro`Y6&2<+cUg#et_1l2M7s!5gH8Tbl<U$E6k%|;&}3<R1f
z3<=%eZuO)Yg{UZ$1zpkiQt+)lAZ+N2OIV>?!Wi_g2gsm}nnCn3T5uWz|ANt;!)T3~
zxT?){_1RR4ZUskH<C*f<sfTj5?VeYKs#q_1%~?<*3!Hd7sc$#xZg3L#n-;y%f^X9S
z?~XR`8RTWFQ7av3_Q+|EaqBhx#L&wdyJnDBJ2-vt@UJgHfffd8KxEyk;2Ew0VOx(M
zlsk)kH=G?_oSzc{NCju7D>rK2rA9!D(}hPI<8!f+vW%K~-U&ZaZgwU?fa`-s8mz0V
zy89e*(&3DrtERv&wb;0wW*M7+WtFi>H(qJ?E403G{^TMc@4`X}plEg?H%<>p>9tV<
z-I&zeQc<fpX!VA~2d;6EE&*!mHcO>Pi=|`yO_@bkRW3ZC%XzY{<|DINJCFox#A>SO
z=ZN<tk>>a6^Dl$GPF+eFgYbI0E~T3JdEi26;pZqbX7u)lBxSvo*Z?_MUeHDVr|NHw
zPS3ag=X~m+Uuht>Sl7<WuIr@rd$aqdF4ocv!BSP}ohxR9vHQ+of?g1L3|&q7UJ@cm
zXfuE8DzR&Xb^b0=e|SM{{4mvwQjC4Ytg6{t)@(eIBy*E{5L*xrd5(?G;i?|~1fr{h
z)`xJ^g=sQux4-<L*YF%!?cnd<-~qS0n<@q&nmb4&Ny-cB{=fNEmk!vJ%lwWG*py40
zU@uQc@X>fZACdoumk7W8Pb3s+iDMBoADCEA8^6MDhdH2baWKgPZ6dA4%|8&!=C>2F
z1)k9BHmSlR>_VNQXRRcq(YRU#cxBUkS$SpD2#gX}!aNLeA^{3VOFS+si>2Rx)FEMn
z<$&{%TemNmn3#dL<_ZFCpMDpMRdSPSq<r(E2`xuOS=0Q{-sWor6XpbwwV@-;*@z`4
zIDg*j0__D(9X=^r_Z4<jUJZAAEVedUw-9v|c48*K<P`d=dNU#X+WI9M*~#KdQ&Rs<
zc@4;nC2lDeP?30(biHt_Yl)+N@fVT`rDnAPJ_QrckwrKs+icB0SN1a!os_jiv!|tt
zLDUMG2I)_)x4!w2Y-89zg0~+l%Mjh^g)adist>FJo*Bs6HZT&OiJTmr7m3s(>3V=J
zHhb!Fsw8iqF6o-bi=<2RFa6PiXdm!u%r*1t3eUKcEzyE8eHC`^lRC>9ywR0oq$TW2
z@XNnkJx2@n6z6rxhfse?60AN}1$|^Z?RuGSp@i22FT0-N8O)TtX}I@C(c%HL$3c2M
zs8V__M7nja;t;5n)3vA(BI!38)%25u%!5p@wfF+$q<2z2TD-BhR2cjdx9BDhP7h;j
z5wTmtZ|0pcCUrG0{u#MgO;-iw3gxMT4YE~86ti7Li)hw<;+i}MfJH%$D))J&ZyYt4
z7H&SE=BN#*wpj^0G^E9=)^QZZUdfbir0x?e3n-WrvU6ImDYVTzn{s_F5T*|ZQw4_-
zj>#q2>y=6GDvw0#@$AyicPst*<v$y`L(kX#kaRaP_$^uOGZBNV0n&q5!3!BJe^!3_
z`@tTSJC>C@%rr6+!e8!Qf1&kfUE=pyB`QyupZaTc?!_6o?Q<gQet`2P2#2nXQ!DB;
zlwrrk+BhIkHL&EIkbX7Sw(}@w1&<x}TkZR9oqCG{H(jLF{>TY(HX4}T=v71calb^p
zNiKFc7VAL9n6qGXqTk$=M&vXInAEFb%9oxO&u`R$^U~D_>k^YP=igV>>MeW6SKe+c
z`?>Tbx<;DA;mQkAz1Nud4(brnJ$_Ur(e=_TpZRy3-X`CuH1}|sO8yNlA<hQ5M|_M*
za?<rk2Mk4g{8&EoH~|KAU(v}`AvN4)eE@aN+UunS*KK5tbUbL(ijHBx@qVEEp8?~V
zeO%-0K^RM~Bwzdn>5kk>1UR-KLM$fW6v?v(#w4m1I$0}2ASD21?9$)(xl%l;;lM>{
zsg^j$R`ZPkSpPZ`YSdXPNy8aiCk3NxWXdF#uqbRq)=S+vBI;i+^`h5$m?kxc0Bw(a
zm1+n3$P&mx+DX?!`G{|CZ)7uspQ_hu5}0QlHOjxR*G#t%`g!765Xx8YkmCvGp-5@1
zXIo%@4uW6w$gP5A3TE^1`Qa3_K72#-K)dbdlg=-V7%~R2Mi0VsC_M=D6(*26)uEF?
z6LnkftFza8iM`%M6PqK!I{OL%WS|bKL+{~MqgpR9&$<+;9C}#GPGYiAwD=@es2+u$
ztsSHu6**GmjjAt#yw~U~`tvCapXdE6b5LI=m2}Nay+bif8cVvS$(!^Hh#nxoWkywB
z(DHMt#t~|owW_`U-QJb1vpLZ_Ka|>xrFwsMFmI_>{m`kSQ7jPah_{g#J9i~+l>B9f
zedQg-vLBLBDWxH^);q{=Ogu!-^mZg{=V5>JH_{L>Lghftkr8PyiCYpAhEf5q%tm%+
z-=yo{KOLfkR@+3qZd}(A0iyOEwgvWAd{KK)IHUo`hqfx*%jo)H^kk(s;#4xnZ<U>N
z%8e)&{TJJ$4{Ov$Oz%MHql(-U!2j6NpR&=tu~;3uh;CXB4w9X@Mw09;*?Mfmdig2S
z7|>p|Xne_(gf16J=i%1-suIDZ>nwT>72U9(y|q0zy-RQKzQiEqU)U~&N|;{pH;B2B
z-nNig0hN;a=ACa0SM8ynHOc8SuTYv^k@d1zazbB9RHQ1(Tr!H<mOFSkO{<*2K}lD;
zu%GnZN-dqFYoBnM=r(G^RF{PvG#Os2jt51F+pAuP@mjqG(;GnGs5XE+fX&qBQ*3~H
zQyqW~PP)EE3Ot*7#|DtbkblS<yW4muk-440ACS-f+im0{ETXZm*vO~oCWU<V@=+t7
zc{|bqnEw?2yo@N{o(+1sfz-+P=M?nHXW%!z_5qBBk0$US>{MFO+E1Lt2wm5uT1_JZ
z&na8}LVfA3IX?!6DSOU8;myf|vG2cGmr6J*HsKb_oLKv!ApMt#R{ei_i1h!ljK=g_
zN~DaF8v}25!`GWx%qjZBD8s2I*0n;QU<sLYwMn%$$;xlL+#mQAge6PRsJTIwo!M+W
zJ94h5EmTTUZU8!;CR<Pek+e#H{Lmq*!_t!cp&^O6b5}wfuA4j296e9mx|t!uL0-wX
zpdTSe?p%pedA9NFtJrJ=Pm6S(6FS`;KJ3t0LT@K7U_RW3njOKj{o`=_2xi`Gy$C}t
z@w*IqmU;+N5$Pxi{*&ktqVGgT@dG6hS=+5XTuPCcup93z;k9MmCgeKTY3w1eln=BT
z{k$CbYTV!{`4uq8FPa?ccaWsr8zcoQ+ZcYi_gaZg{Jsb%?-?YkHG@8;^8%{d*>PU;
zsEjglVwmxmXl%%6iy|jVjM|>G<UX_s+1zp7V?^MT9xE=jW!*YJ@MEaMJ1%4?ew$_e
zR=AKN!$-@kVNXF<*Zqa`9m$ed=~DtTIO@wu^!*(8FogKctN@!oO+Zi`5Kdx(&IgjC
z4$Z~9HgrZx-$cQ;ashfxP4WT#so3ofp3X69P1^FA@A!70Q{^f2mszm<wa$_^ax~Xi
zdL6@5gNqy$&o44m?nzvyGxTBbf3CTTh1MSK<&u5wHRkAhm7DZ?2F1k)SwQ9f3k;86
zkWiC-PH-F(Acxzdyow7sY<EGNxi1?)6N(jh8(-;*(};|eS7vKmd=Y1~c~82{=KOol
z!NL~j?96EdbtSlf`S4x{aq5VlFZFak0|WTWK^MB+TF3ODr-+{;CQ`<_R5&5xDL1kQ
z@6d>6jB8^9?-d@t&+%8J1sUsQBC6*T+xa_sBC-}3@(rN_zVcUtr`hlq)0ul`O2^Rl
z3So$Q&!7qnT?pdA%~0lQ0+#KK86)~BW^fhD-yvGmLJdqcFa^g`k3f_b54CF0%P17Q
zmbS=<35?AM%+`|!kjDR~>c6*qn^Dt-1~U7%TmR!*RQ!v;X6wCSGH25_GjA=z@jATQ
zsNTpDQKaIZi9yMH-_B&M<9}w(BXO;5rwc0F9_B#C<Mow=ZNdq2k%`LGHiCe$PIGqc
zA=I2o?0qyF*x>n%eT1rBTY4Ws0r-31HKAWVG18mhH^Kc{T&OH#7CV!!exk6JCj5I#
zN?HGWE9pA)5Bn2rFizNyNfH*^oL<5PZZ+1<YKsQ;n1RA*;C(ZIlDmgR1qy0?!|nzF
z4WL7T0NZF%A%-eW_ww5Zv6rF&yyZ_F;x;Fpq17*>PYwGD{EkBbb989{n^CgQEQM|f
zmJY(RzcC!#UcE`seHOK$Mhh|#AfyL|V_DW`{0jcqs!XeGRVMN%#xlTEM2Ij2ON0Um
z@rB->g7)|n#jdUs{X<ge8B4l$k!0R9ZRA;<bp2Iwr>5~^wZ=}?2OE>2KTf;&gpjr~
z_-ITbs#Fc)g3Prb)jm@|1K%Vm`qI#cI`BrCW2fa~r#g?b+f#EpNRE-D>$Ftmim-Bi
zcHQay@bA>WSsPuoApcd&^_0}Pj?`!L{eM-zUb-Qc?oC<sSN$K=-_`#^`!grMoz(wD
z|GVn{L00`M|Bvb~QQARcQ+4aTd)a4Ko_W51@%+jTpTr4tYDfq_cb@Qb=OGb5Zvj7M
z=5$N=<KIT(cfm9)RQot__WWV!PJe6)9{O-m_<~@-$dSDHGu+{aoQ_}IUnRfCKMZ;0
z_r$9C72X&ed&T7~xDCz*j~(7v!6JCXi9qn2jIUR9eeEw_N6^%UhYgxuh_j~aIleZ{
z6K#idb$z-Dd`+{QmDaCK8nx0haGFpi805f$R>(T$np-93C+fe8Uk2613T`5ezc}H(
zf4mXyd)GfZ;OHU+5^Av7XWOF%M-JzTY%qg+98sEOIiWj6-zv6TXdQ2}10*1V#Ty=>
z$!NiivSXvSpkRflX51}>SfdKz6!R8Z2e-?o>FpRA0QB8TnZX=i=rx0dP*A9$-HIbQ
z?vyGV`>e)ne*29wqR&%#R{ZvL*0Eg*{4jP|21EO2@NzTpPnSN(Jk`A<^P8pikp@tj
zm5Hz%@F-<ImO`))J>c3CKp<MM<IraT%IA$KkY&&t#GV&`A^cI1buL#r<UB`jb}D85
zXdgIMmAQCK6dfzMeL`Ubx4?_qI~5P7e_YSP?(K~%0mqbhqYJ??pTKnQIsgtx3hi~g
z`-&X1d9qDSPj>3t#biaHdd;5Ef-|!F-3ReNbp>rA0?3<xzBgv7M6(cgEG92&EYOZ1
z&)aTGq5Iva??8&Xd<y<{i3qT*?`E&JCU+qNl%Tf3-byN15HF{mv>03V=SW$MX=tkw
zG;Q5?hYU@$lrxK4M^fDo0XmS7^NdPV>uPdEw^*H~c7xVty97G6E3@-k$BnGr!F?`E
z-_YD;tetiSJ}D;+#_MBm56V?&5==S^f0AetjN-%8GbQalw8LH4;6BvgP;ngg1Vk?h
zHN2ds2U>5wAuF^wK8w8?e)!Cs&^zIWhvbA>!w;X86T&GamE1H$oJ#h7f%_hU#!!#M
zAXL+Pz95^M@E_91#Mlt=V<7G^r=H#HY14aAOFt?BR^)0&s33Y%e&Xuz!-H~ygUPqk
z9oc$<ppj?O)#nE~`iI>{<<7*}G}PyLYN}9!N%ZB%s1bcK$&*t_a9mtv;(-%|wKn{&
zY{dh0Lz}Djq{7~l`t+VO5V6c~2%!?8ZAVfHDy*M~5=4yjErvO&K5{fa^neUBxFG3z
z8^-=s;x9B55M(3&e8jCVJD<mJ6*jXhQut%!f`|5{r0b6&2(U2$@}3UKDYD*FPWjGK
znuZ1t3a3j*b#bR`I!K~2X(ck{Ve}q|9!S>OJNcDf8MW$?5_9GHWs=5HdHg26C0(PW
zwkF8F5^v;H>>+WI@DAKIyV}EvUkj2D{BUZGcjTo?>7Br_nB&)!u!)4!#&<Bg6>@vt
zNEUOO!f7~|VsmXK<0=GF>+pVU4ZK+Lla5Yb?KOp)d!OxBNNd3>r8rX@-+@pe-(dw_
z&y57i*vbjwPekk^p#R<ld^Yvho^)+j$s>^8iFK*_WtY5$9b>btr4GRPqwLb(B`G|Q
z5@|byAT@rRqa>utB;!?W?$(wvd4sP3NOMFOsz8_r2!*%tA}^x>e2^Y)5Jq0`%I?!#
zM26Hf%Q&RaGAZQgU;#FC3_aI#j0!5Fp7$k=al_scf6+!#tvHqWdnM;gWpvg7U&DJP
zfuh$?Pm#^zH*YV*xuQH)no|chPZ}hTpBndiHqABW)vx>%hJ?kR23V3qRMbv$>P402
zq|sjUrZLTvD#)B;PW79UsuE|g&ILRvDT9a?ntLcz8QC<a3qlHiR3ES?nc@R6&^fZe
zG`N`b)m%xf%jimE@#<Wm^oh(Sd|9R6;2qZLRc@fd90=mMbsWoxeK4s?`#79b!S8B1
zzRqw?hodqJj>_#Ljea+kq(mvzo1}HFC8Fv*YX%NTFndArl~a;qiLMU*4RSF7js*&>
ztMj-(eI@E)>{U<6v>4yt$o!DiZHUkB79uA&Lhk7F8)<YrP#VuK{Nn(MI@3#NoQAU+
zHz)bcsa57pxVsO`u-?se<ix+JhJJerT=AKtGx#O;db|M?p61g@*(WJ0t53Awx|W~j
zw+W8MR}Iil!MM_FRN82-YKeoKrLcFg;lt5kZK+HXXr&g@e)X@Z_I!EbjreVmHBo8S
z7xR+~OPDv_*yHj+)N>Bt(VU3`AD?G4qjQ53uv<(GM_A5el}n&<fF~>?<XvybwHu?&
z?62PBd5`{G7STUIF-HpUsdl6!^bB&tb?$Z0J2cpdfV<zHk^6&YrK^gCAP@9Kna;s6
zR>tu!N<AQ5qej9-v*(kpr+EeUj~RNA__cvoWN$>Lziu`(>~S@84m~&U_u98YXNqrM
zaqMYsC1BiHo?%;+r}tXXk+Aoat=naLC1uk{`^<fbF<|P*%$=d;TDe9}VF$sF%*=8M
zq-I9YzFz$zvTC)yA$nx=3`EzKffzw-9uNln39%Ytj|c)0#CY@q$xk{uz0O9AgXlyW
z{)+1_4XWi1wICCK8p#5gfyiPk6aJoby`*#ov^EyP#Ait+Ue1(vXRba~2y|#>7g|bE
zEy&E}n9{#X$1t)<Mm+DKeUxz?1aVKo5I7G4oCk!ZY8Bs~ug0qdRB|H``dLhoRjd%p
zqq5H;`(m=Us^h?GO7s9raa2NM5>tfNAWSdh!>;voj&re+%Ri3WaNF{VurSk1lqN~3
zqk>OQr#`_;OS*oqQtj-tDz%7bp`3jIwPl=yESvvH)MwJu8Tw^kuhJEZ{YR=|Zg|vu
zJxKvriCwQ+B;EMsKLY1;trW$Fm&M|@h4bd)S{4@**%I5eRj{N$tXaue*fR2{B*#3u
zUlL(oO1dxTjE|e`BBS0ChlJH99AsHgmPqmYj0hAU@<RQ-AHKe1A0jVAte&`9<b@~v
zWk-GG?-<LTpb0H6j4Dw*tWWm_I-5jnc+_ty0d@d+eDpWcwBJmM%<z>~ARmp%FqH1J
z+PtR&8M8@C4PPLGFjhrL&21j?mmfB2?~+<wzvPRO8eU14ypE)9yS&+JT!Ze~3A@k6
zQq1YJMqyK}LBj;gs_Z7k7qHnn*$-`!{%8rlR$CyYgkz?X+r|e|TcG@3#?oH{7rwPf
z+30Y8bP=~_Oo<@xj7OT}TkM*n{_^(FnZDS~h1bT$U*R|Rh|SWZ|IugnpBWJP3IxJ{
zXKjlIz2-Pn#^B?kHWpd0W;6JJEwN9`#2+{8;q(z3)w3=>(mA};zp$4ejj4j-6+la8
z-i6O-FLu`5Zb|8mdn02M?`K{i{tdG-{e_gc9g+no>od)^szm~<#7=(mk1}h)Qf;y|
z;6jEBA;+wpuFhvc^9vbkTog~$8$`!S%1Ssz1#sd&bXXVuksG<Wrk*!mEtIwHu9pt3
zkxX+ZHs{~Z`V%(jdQ~{GURve5lBXIqTNG`292TY;VOpa0DQ^^)*`9U8iYq5-u_A&P
z%X;rm;JC@DB@rwBeYuh@){sX_7yGXv!}<0o?J;{LAVaKp#3bBy0~l!aR_iBJ)ZO0h
z)bc@N?Gv&9PccDPr@F8BdSgf(YD67VEv_K39lK^}U{=n)qy&Ws5zsY7U&J3u(-Af-
zMP~fs>)iqP3~w}e=yCTJK9~QOQNK)?Qd&{7iU0FdGispMkvh5iU56!4{~<nXmF1+7
zARR~{LGXk;wo9k@_x~|Ily01a4_|yu)_ym9*b_LV@Zs;tAox%ub=mmvyL?gjaP0rD
z_)xHhjSs)MLHd)zfO1%nQrZ>W@!@Yzfe#mf#*#gZN46+@IJq;05Bppj8=~=Ht98Xw
z8XrE*fN&@`xz9DSxn%<V=7kvEKn8qUu%UD+M`1&0Ua;Y+o%Ahr;lLxLbnX<`P!|+z
zC<T+Q9Xsr$uGZi-Nu7)h|B#jGze$}E8`|h0jTALDY_$r`m%e0S!#Az3G1B<^jN-Gf
zVXJl4>XWeHt?)Vi4Qwc*myP@>JkM-Q80QUoaKxSC%#QySeA$H(7vn@#)Vvf*Z24U_
zO8n7ig%a;0k4A|}!I>wa#G3^rj&_3*g%cq-eHj&H#f$hNeAs=8E=dhSP0?^tpM?+e
zvvQu;ekz3WpWwqkP*XM-f5n^sbA0GYHKPVP;gsFa#)l{I17ZJFj{zHi6MhN&qXpOR
z>CS(RhAa5Obtw1#(~+zZsCY|o8Uie*H@VgN37-;QhgH414VE%Q@`z}0UtLAY>Zi|E
zZ+Z0?@?lgGE56IidXUr4nk_{~pr3k^Je=>17C$a^lozUe6Vmyvl+PHZS(oqt7Zyd}
z?06q3{-m`4Y9M>Oik~DZ9$jRxRvBRs$P~VEF%24?hUbJm!oybXN!)S7bK>q-1+fJ4
z32!q!S}=~DWwY<2THza|ZS=dfB6zgm{daS7vet{bL&652eXr61FK!@9Xg{GOXa)uJ
z5*o&VRVf*i+=1I!!Caz1&=IaCTwFYDyty$~ZlQ=VVg+9YKl8YXo8M|SEhmzvUh1Gc
z*Bh;#txl>Kl1A)%tT7uhjC*=RlnFRA`vOCp&6E+rja2XC7riZ_)OX2Cogyzq5kO+s
zi@X#`VqtKo_O5|b$|XQ*11eT(v9o!TuIET`@9BC6&G;KqiCXLDe_?t6&&m7=J%hFy
z5x(4|wG0U<x(G-}e<9)m*Y&BIxduUZP9Z5ofM%oBIjTG7u(+07Qr&qSP&XbE+7@4@
z)tyC>TsBfoh3myx0P&7KE4+>!$vuSUsqP%YMfl-!V&8qQ6*qK8#u&?fsbE_C{Ff!?
z!0&n;Ta$b129i@aM@ufN?tGPYjPE=~w(8El@LP??cB$v>^1kL1_1q%QwIcDV%ctlP
zZs!j#sqP$BBH5o)S;D;2(ITrmrw)~8Im+V8)W^Nd@RED0JFBGgHE*kT)0kZybSiOY
zta?`?{q4w|Ppuzb4h~<KsH*P#GR+3>sqXxS>dI59*!?_*M%R_ljcP`q-L6!3o_0D}
zCsucUm2L#bCI-|EBg1=g8eCl6d6v|3UR@cl3`Q6{tGe?q^4mX=sO~(cgr~yl&iHv$
z{8rs*jdg<?>k1m{dN<bfX{<ZHv2IXfU2bDtQDa?UV_lENx}J@7#f^1&jdi^m>xMMe
zozYl#W@DYRv2JK%UBAY<zKwOIjdez2-Pw(G{k!o)S;yamCocAoSa1~onj2fv<=)1s
zV}tV1wU{@oK=fp{s+Y*<E@jYu!&9H=NrE0i4iv0?Q?lXfOH7Gn!T7o&Eoro2i#llS
zxkZ#oy1qe$>l_t1VJSg4<;<h#|L^+pA3^w_FF%_;e5Ss<@LW^+xc@7C`BjV$!axrG
ze_LN(&U$foe3Hiejr8=C8uK5~N=jp1qTwZ7Wn@)!=9%>T)Ee_*j29RE`jhY4ns$8C
z8n8w{lOiQ$5Tt}8_Szcr;$DhZo7M2pm=|?qZis?18H3e$;KWH9^NLJODbSs)Y~I>T
zlbYuPO4~_FXu9QWk*w=e(lvQA8M_Eep-xUkSjtdxLaP$b3H<}Dl-8GD_DitkAQt*f
z7b*&B1Rpg8wf?__GCB!=W-iJMKJUpxaAgg_P($c`Im<pj6)S38y_4g*;(H9MEFI~9
zo6s0u%l%n=N4;u3KANP~nXHE&P6Dws4A)gpAU4kFpObUAnE^X7fr}OY<1*R8-;wUH
zg>h=zRK1^yJ~r1&CC}x+pGy={mn!GYl87nZZK2HKCvKZtJC%Awo>8qA+f@>|+K3Pl
zLS|fbL~O_Ap`e2nw4_CuSrq!;QH!Eh+GO37$WN?bImZmC;W~8=z$YaR?uFgOk3L*=
zZWf#V(8>?%IVW*1^AG<fRa>fV-HU>Yblruj?wD%Oj5&4lgLH%a08Ms-vQE6QT2)0>
zgQ_Q7Q)yfN!B<z^gs)!nw-d>@pAK;sQjJA*E8<vwIIsP&d_)wk1a89;r6_4^5k-xD
z?v}U+S&f<!vMBzoAN|9c!_<v;Jdg2`H|eR}vS_eBRzVc2>kkuYwqX9>6ZdtU=Lklt
zP7pAwe(^ax&N%K4AFW?JjQq!pwTq5L_V*;fIxz<cc6&6@pVuddd^;4)(^$oEUK=V#
zU}P@=wcbRu+QS_tww83RXh*6!W9ipeCj{9pF=}SZ6X!AAn}452aoh{(($FPmdQd>Q
zg2&TBw@8N5z(IIIjt^BuiQ89Gq@PBH$|ZK-Nc($|#heC4{2(duJ8=a;NVr8#a<bd&
znIoIuig`csqx%csnkU|56&sIlBrSn=cMy0t)Epk4w_yoh@zzMd1hGPrpIGsmQ`DZ0
zjABpIZjKfImF#J7Kr64Xm|^R%e4%#3>>EWboxI;|`{0VSh;h9%qAqZkHriMUR+coG
zbPeZ?P)HSa$1^v$k8p#{YT=sRe6y-Beel|u)On}nK^-)ZBBIf~o`d&E6Y1n3o-6p@
zDf-y_UxKEwj0@Mqe_}w$EeUwJ7*6`)5-8Ofd{NSu68&4E*LGkA%#<8w7@4#a$#}){
zl0csfbsGS?TxcnX&>2*(D>4@kqO!ua+dDWSbfw1HMkwr>dMR4rHaw`*K-VHqzuWYy
zh!k^VgMvKhg8CJbO443_<hR299b^B>AXHcNeh<t@bq@dcs$Yw~jfh|dTHu4if#JES
ze$>3RE=&*92n<h)V5>R0q7r_9U}i;cz%H(>UvwSxE*0U}TUMD4UzfOD=$StVKRI=j
zXrZWdJ26E*KK2<OOXcJIQ-4IFk#x;%kTrq;eijetTFzl*%k-)R;+~x;4-|RRk5s?^
zP#Tus=qP6PiHp?CYJNQi&p4f~S6+52OUD56k)j4NT-{#al_N6h@;ZH##i+eb_v8KZ
zY(q$bef1(*%TZ3JLpWne7%EGUT?Gp$I-P)R^iaBia7YICxLV|CWdb}H<o#1FITD35
z+}RsVTJCbYy2`L7Da<u%AQMoqWQ1VY3=J>BTe0PAKf!HGk&}zlW-Ix$x^$s?hTEre
zKIB}2ZqAWdmgy~&-XGm#L$Npf1nWsQUK@KTC)fB<y;uAd%fBUF;@AGLp|BxnyD$6h
z59Jh028SbJ75}fuwK}Z4f$D@q9tjXa1Jf+=uaa4bU?j>3TC{RqwG}#i4(@-`TL|^k
zO8B`pwbr;WPH(YxT}%tn#qEf~J4D<C2^=|EIR6`p7H*vzDd#qDkfF_uJixrx?9-3=
zJietLd+^wz9}9VWSwHsTk##P``tbNC{n(esU-O8EQrz6)wl&hxbKy_rnE$G7Np3d0
zbOdiy?FAnc&O&f9iF__CB=Uk|N%Y7G&LNQ>yqE;~S%|PZ3W6mhdgTNsk?0W|K!TPZ
zCl+EyPbBI!4Z(}O<7QbZW`kwTh8rfsp4*%ct3m0+$@p(ay6&;CiWKAgf@g#SaI!U{
z=xhv2y52`YEOoU7g(@?A5kw<u-oYn9tLb-L`cguVb?L-aX$c+|S{47Wt465EN9{@!
z2mTcC54+zt1a#^60;2i-syp27AQnh{cr5BRf~s(BU+<0H%D$O0$R8WXF<<b5G8yBW
z67D&1M)v(1FSkMyjDm{wm*b1`7u3MXJ(y!q0tG+tj-0EU(Z<>b9g+P+wC{ZP{z+t*
zlB-VgJ)Gp79P;h+y}Z0N52Jv5viIcl?k`b-<*fG<ZSxepM%-VHT8V-wF_{;BFR_fg
zgxTbjFXBqEL*B;mbdFScBjN4$5({`oMge2lEWW9L+Tt#%!p)iq^=Za3oquAza^t9a
z(N`ll=m2Bwz&u3%7`rCxBS(rt|48%`mQ^22AM66cY{G}~xT}qtIlxR@+ObF$og)#K
z#cQ$zLO(!uZ6I^OAc*rMZcqtW7QNr;A9sb`0;<>~^CE2wbidPM9w&V1hrz*!LOnI_
z2X{*NBVh-1(MSIB*NmEHg}PeX8-T?<H6McEl8ttWRq<^Cf72pHsj>D32c(cYeEi+}
zE6DqeT!B^O10eoJxU+r!&Boemfp=p*!AKk0fc6JH2t`_16fbIUn}2mzqrOBlj|fN;
zgtBkUZD{LJ)PjApZi~1A^5u50uyw_6M1vpre@Vf=F^{OF?xL5|b%@IqHv}kAOB<|S
z#X4l^2RdZwUnOLzM;T5tW}`-Ys&tK)cuL352@Z4{&%TVc4W8kIrb@=w@B^0fCF_lv
zc1G+Kr`9*&F{wp7CVf)?D;V)Q*#FK2c!N%GqJXpZKuY9S`7kVj8-u8K?#gShH}SUf
zceEGZQ`nnq2^|2x5?ifoyZHZMR;y+*s~f$^?V(S)Qszxgx^W5J=zhfn9M5vg5^$(4
z>8=>H_X)IK3NJnYdUG&=s>`=KK@Q%s-88vy7Ckm<UQwf=`_l8!s4ej)<pq`QeA0&T
zW1?3UEBM{%vL`>sn}Vybf*fLo-1EmEAqa^Q+1}|OcFH$Yht-SDdZTniI!dGSqc*6#
zv4JzhM#qZ-G}#+r3g?{Kz9kD@GX!3oT)<1l2)aZPAH2}sBQs==p!jq<4y>RY+BsvF
zQ*YJ{Scdx^RBd9L^7jFj{bp%}C~JtO@>Tf&?|v7AC$Mu%a8Hz9#4}w5`cxqG`xp6O
z{LPJwof-Pp+{lBuGedXrlRqIeho2rZL$?qncuFtURp;1{i&uSS;w&n%k+D-l{Mb8!
zKstH`FEyT>SQu%a?v5OsI@ev)5E>?VuL%w2r|(P{%#n?K<~HXtR#oox_gIjsOL(S{
zE|q!OI6B)zm8=!qsOV?tqKxw%F(qswK}Hv|JNt9#8S&CgKv8K_?!u>)BQ$~)DrymL
zNx%(ksYe}($N7HJTNFa$a=036CpyNDFg)$bBi6uf`Qm?6Ssu)-2q#ClRZD1`o*-`?
z!QL}libr&1dE-Y^>e}){eY$ca?xLam@gv+XNN=g5kva-Oy;3<6lNrvG0x<mukKx(P
z#~z`c>SN+!P<)T@(Gl+F?4t6uXQ+U$iGGxNu&0~OQEI!dVb2)86}mSFVMVBt4pP|A
zozCRrEAddnzCuozoxY+^+|@^BQkzkGjEo*M=^}gka&yB;mfTaxw2Q-_kTQoWi*_;h
zyC`sp6sUQM?<6Lu(nl#x6M4oXE$ou;*b$lo8-CEilf}pIgSkA(g+KgY9#7)O+8x>7
z#~n%L8#T{R7Xx_B*RXeFplGX{ehgta=c-WO{-VwPq86X<YjdVgy=Eqn<Bi%S6p`T@
zkJQQ$5}Q~UFdMb|d|#vyUqMJ+xz9Cw55LO{k2(~7=+Z(kU=we>u_0HgJ%*#fqaC3S
z;`!8|0o0&6=oo9%KFgD_Hdo?)y&K-RA$(-85fNlE{>#RHZLHs0Fmhv)qhR^<4&_c;
z6|Sk_Gabnd;CJEho6O3}Nygfly>i`=qa%WY_&YP$|GL<aUcO|bPdwNkJrQ~*F)a|A
zaXe7AE$EvX8`#Uo=_}e*WfH%7?n=T+=R#dPRGt?}jtIIU$(cbX?|Oi_K{m%i?*_2M
zhk$r|BOAeu>0V{co1q(;9N>-3?5r-bM$gS;89XGysCtn2vEW%Nfq5Ug*Eu5CkH0g6
zy*aWu0z$Y<tZ#DUVZ*_l$n8wjH90WoaHHDdbNbEeu@Q5ZB!0?R^8+#OF<+!JZ~g%4
zn#KWnWCZ6;<jBlm-^6%Y%@5AwZ;#N(@Ph?oLtir1I^E_@H!yVrR5tAy3r`Cl0i^Zy
zZ3QD+njE>y-H!OxAbaWIsGZ^Q&Y5tmk{f-vgZu;^_la}a(M)LK248H^VSlX8r5rp(
z-m=3Xj(x(Me3}?LYA2JdIDVL*#6MAI-KT*v4*8u^WBL6jh9BxtG&A`6b+P;bJ}QoM
z9188HpwB$g<iKy9jPe#n>0^}Fm&Bi;Jlug>QL|KHGdKftW1J<i;@P}XdL(cStZDk)
zwen8(oV>f5cj>E&dSFwdgBtFf3AJ3<V&k)ve=u%(pt=-&3Aan^wrL%%*%U-XAaC)?
zSq3R@)NGffCZsy9cO<G}lr%`0n?&tjc#QvyKfdQ@=FH5Q!2f~renyRHznYMG1?7L0
zTsw_OHGe7nK<?O(2U@|MpXhHVuTaUkVA-?h5+XNPXgpgl2EAwV-XSl}5G&q+SpL{)
z0_n~S4U-i4XWIEkgwBzAx+3l3-Hzd~vJ7V~$4^}7-^%4m!OL&jZdsHTh1Yysag_;A
zDXa?q0T*F6%UR5$5<T;nr5jhrcZKqyAHBBj+j)up(5FVEK(;_yAMQn|2mVN%R~F9P
zmHx7i{AC||%TH+elhR4U4B5S&SxACLKSE<bnnV;&ASl09YVw;2(S@sjS||b4d7<@{
zmQ_lhH6H}$HVGsuo-}?-M&__~1O2W<>#_V(qxKGIz!l?*;?2K78(zm-woY6lI&s_@
z-?95`EXBWWGG4`>?qo?UCSbyl7=g5P?-N4utdTcx;uVkHtQFYAODXCj`svayN$#lf
z=Hjz8V#Di2%PA)`#a*2g&f@}iAbLKT34tXXbK{XKfFLw%TyS>M^=6$Yx1`MqBFeuH
z5-q#dc${3|_*}dA{o?^q4h`t#FgA2GcgXyip)28rUN8)kg$>ep{4z?}HNZjbkUqm>
z&I#SXKy+yqVnuGE$auDh+Vet{^yqn66SC@XQmvlYX0>wUOIT)aL=_~yh^rYwP9Kbl
z+*ifo@V|2G3Z$4^rXw8_v{$^joVT*9e`>3zv6j90bJy{*b3$-Yr1KJ^7G*}+L5q6K
zl+4;Q3e6s~n=OnFk=er5U1n^!Uc5F%36Ff8OoPO;uq1fH{-69myuA&0RMoZrKNAuN
zLOh8&7OgMQq6V!RTD4F>Gmya<IzeoWqC&;1B3Elgm=SydCrm~%o{ptfTHAYV>5IMe
zo!Sc`Et&vL@RgvgqP?xrRz2gWjkd*r%KSgyea=iK0YrQ6@1N&^GiUF8_RHF9uf6tK
zYp(?s7*{5Uf?qa}_<1`en$ln9n(i@-6#q%Nvr3!W1DPOwT4v<g5tv3@^OMky=!fTK
z%FiLPt+OnJt5%Ly-0qDk+%s3}r>N>o`B{9mgu=e4KO44J3cSt*l#ckp@uk&-I*X5#
zt@w(2sKNfS!bdl%Jn^HIk8O`I%on=^>s)uPF!mF+5vK_Q!ou-AA2?QTcxxCZBgs;u
zN8Amc?Tgh%>>E)izxDItHyqG&yeSNp!GQ?Zcf#o@Vp<7ZK1A{*Iy;E>eU`XmXGii|
z_6z86dJ}+F)Ul;7_6Y-MW=v5rK+*!Bo6;v@0-4<iU^S!J|K!*J%^z{36h+1xM33{u
z<#g`)L2D3Dq2SW``y16aan5D^2yWRG)P)4vhtMCL=yOLDv`SZhg=*?p7iyaskj~6`
zx0OW5<bcFiNIanaX<WZl+MO8LPPy~3@@J*6{i@zPtzC(Y;`{-HuHjAG_qYLIF6?UV
zPS!8A-itqXry1PO<Et^U9*i^BK#1J4fJ4Tu=kM{wYR2Y~vJGHX6xjV)xU@sGqwjDq
zAvJoc3(ZBK-O<c#9Abep&aGgw@_`@GM+oZO9g6hYh4is<Yy2?snI?Vy^<~O#u<j;w
z>eqi-3V{r7xn&QU<%k=w<;lVOwR<0^)*Lms0i{bw=c@+x!^1&rGtYEgx@<&J)9Ht?
zk8zD508#-S>*v)nr%P|-(|!$J;Y!su(RBo*3vWSYzTUV76p@g=$wYA8Abuh!!SO$7
zTf0AEV_)=&-bwn(O8zHrU8(iQQi?x=j^;;Z_WCHag>)lmd>%b8cEYBL*ykH@mPAg|
z_;=!8=DOKM52?8o!NkP+hpn&1m@h5^*XQ|tG_~vZ9)2I;{eGX{hx1z$F8&w?t0|h{
zz>^q`_3s5{vZd>9*`m=Gh1*tAglAgjuqE2w!v5DLTMslYSzmF;C$uZHPdWtjU)ZpZ
z0rd|i=ps_!4H{%m9hwh(fnTap5^bu?RfLdV+(zW2ow<*f%75frd~;b?VxY?@YCSN*
zt;<tmy}$|Q5m$~U#T0;F@OVpy+cP=lZrP>Y1z}g=Bts0tm-|^b|73QGmNvUg_OtGf
z_p@X90btxHiB%H`_UP(ljk%sP8cah7@iLJM!)Y^h@G|YphpOb~R(@*MjZi<;ttn*R
zQfYTWorP^;K`S07iEA}-o%J##yKrBl<@IjW<4GzJP>1P_iMMsCPDJTvqUp!DC&CF1
z&98wa(dA=DMv{B-@lWIfL&?Yvqbri<XRG)THd~_%1haeium2WYFUu?+i1PtUq6+^B
z{F)@WTl@y}6#qQb=qYMFJ_g(V$z22W6fwof4AmN>r>cHM#We8LRa6{Bx~Hg^ghUxH
z7be|my@GX%h60cM&2^ygJRB~UYh_+HvD`|cEC;mDTk8%^>}t0%+RxiYmg(rdr@d`*
zxwY;f!1p#Zc(S$b47mPycf+_|EBOn`ZO|l8;m4%v_=#|OlkN_MlaH3UINh>E;57)1
z(4-}=rQ^;ncO|;QGW=pf+S!zoOKSb`FqTqv#_7An`NlchB=rs-sw#JnDc8$hKS8N>
zGwwA)zTA<Wlgqu^nVG<UvhC!SYoO%S0}$u?@4^BuU{*PHwNI?Dl222&+w`+eh$=hJ
zEypKwtuOu?eTIgs-soI#)tDMWJJg{)>QbtKkeP8w^_)7EDp6xJC@w^J{4-YTo5JYg
zgjYOIPdx9X%?+sJde9g4awhr<MAlk2l>O~q#I+nNE2U>iPN2HBA)Qmo{n`6eQKsTz
zQ$fh6O$2D_?niZ0hMB;*Dj^56cY@OFxwr9d6tiLtY3fyu{v@ww@;sZ3KIduDP%HGg
zf}@I7^1NPF-NS7-ioa+cp`Hz=P>b{H78YRts9x_cj|L|b+Ukv}ic!h2cUP!^uTWq$
z(zA+(4pZ$PFodQCgjc=J+20f_Lp=<p$GQBe5(U=4`{e~~#f-wv%`K{Ypy57u=Pg`Z
z(w=MlzlV)LPjJ(!Mh79O`V2GsuVdfCXNn=A`IAgi{@Up)u`R%XUf1W!7-K)U5TS3p
zFUQdmXHP_MV;%pHZ;K{2*YlPSTwX{6^Lp}uOL#SVTo_&83irPGh3@?_V&$j>&u&nj
zaq+Z_m{Cz%uD}D(29^oyM0Aa`9_KvLoQ45=Zqc7Vpm0598y5vp?9LF1*zp;`^{ND`
zmVfJG=-Lans5(@A>2Xno3^F?>Njz&sPFdw$fC=%RxVDIv^s{C}oA_EGNDy++>GW)%
zH3ev4<JoU~X`KB^Z%3+UeAzR|_;T_OiXa1k6L}-Pd4C!#Y@JEFpa1*m2xj@}wb-7*
z^!CRr(g>ZGZWgQO!nc4QSnhBi&G-yxp5gT1*-M;Ry+?@p{q66gyoTjEw37!5*K_o?
zCjm^L1xc})b9a7k=C!oe0;lIbU4Cf3CTBhfXeI|yQ&hn>jhD1d&Lg|_<P%G_!cqTL
zW8_jG74IN-jWhiv=FE<-@mw&XXXy9kX{9nM?#93d;&^6AbD!LGAXGXh#;dq++nbZv
z<waxI8$shGK>QcqE6xdTt9i>EOV0Xy;4nsqcj;5_*8=W<!N;?-jwIY0ys7^qCUPNf
z0>gY`s7tN6KlQ`c_yewGGUf}9O;7d$?t&)-+|h+ffdO4P+N*USf7mbo>C*;K)Gw}`
zqt~v~Odj4!XaB+$_hv#*=25#=c3|m(?=H7kB@g}a#VGG*Ydd6MwUuI1X1psU(Zx@n
z`lOZf*Wua*HrATV5c@FR9n$PBnX8!Kjoqp$LkQQ*bq&!>yi!t<6`UlsW&Q4Cs<5GQ
z<|@CH7;CD?7~@{MDQr~}4c!jSfwgH+jvboE&#?P*hVikU8D~C`Z&y6}853%DBv}St
z%#B}8C8jRK73zhZa!aSy^JdkoZ8wRSD5uYrF1gaG8Ach?lr%cF+Y}XZP%IzKNwG6^
zA<b#e3v>6GpV5q|xrvBRk>^YgE8Qp#R_hVaRD7el?uZFa9!>uxlKuy1Th0Ba@Ae}W
zQ9(I|Bl~fk6gT0%7zpJ9<0+H<y+{tgA4+&;Gm98_(CmOS6acJ)o~{xo&D0=Hsufgh
zT#8(R0!{+mEsB(m;1Y3`=Dc+z)YJI-Yn7ByT-#AdBkp_(u2g=~T<1RN=c4JI*=GeM
zuFG=VCin?_?~B7?W5+%<Kp)y<uhYp;3cB&z;~bc9=iDvhgoT0J`Fxa%DoMr)Q;a=Y
z#J<y%x6>c;5w(A1N@9!<-y~H`X>XT(9#{|PPsCnlz$K@Lk7DhCI9ea*92-gRoIAk`
zbm4R1%*Aq=;#y&&XhSl#NzHH|jG&IST1Nv%$={>)ry`ken5=w9)A+6NH!0FI2HAKY
zLz=t7z&hcM<$#Z<y~fn!Rj467Job;cN9@<P(#c4ETlm@z4&f7rhFiMkX+m+b7@cs~
z!8e?bd_mZUW?Pud^u1xVo&c(Fi!^GVSBD#&dXS)6-(bcAh4GvM!ru%>CbXo|AHNLQ
zefk|RBKx`&nSOS~>mdhkSZ%+BJ@=M#)V{6KY9*2=J0-FX=gha<%`$a2N!bhqJ$)q5
z5GbtV-|0p6bg>h*t|2tTEHu@2rY@o@AQ6TM&+=v1{>oMZD|CtZt*+Ax59G00z&#gz
z!UJCuE>5$*vb_ZAPE;V@gb;4`Fl!l#>_YoqaVj>&|9^XxaZG%f^+1bRIJ$(<RL6c+
zuUUa2F?)uEtAkDm1kMjR^*~ovxY=-;sRTb|TnGJWz#YL1JVwmHW5j%G%<LX(OmjCO
zUfRhQHIm^}*v_oh7Z0p(m+JNfAJ=|jJ<ulH4%-Q#{oDy{%3YWZU%P#r!5X`@`W`Z(
z=~R!tu5PUsLRr;csa|ZJcUQORIcBA(wKXQwZXSlVvE%ea)9&|HU1*I}M~CX@SdI5l
zjaNxcq0;h7s~Q)ekVr?>)J(%0Xc>&GBO!gY-Y8KcC!uww1*^_&ug-0~?%p2LI`9|+
zJjMWzF~FlP)$4XD!2@Xc=rFs1K$*Rt|JL)ags@4+V3QbJj`Q?<ZPZuSpO=|9njp*r
z47ehm0T;6P28}-T6u4=vJ9ku@yKC4NaoU1bB08kvXSD?SoKKm^6*!AQX!){eN9r47
zXYUsDy=?}O16|QyIBiDeV!_Haq!bY0Ki(s^fCy$R3@||f+)bNt)-n7#hF{0<>x2#-
zR1A#5`OGNwc)&y@HVVc3@dnfB4U8pHl-7${Ku}oLhA4CyG@&)N@kc-m!?yvhd|<QQ
zY<IhSXNMUFWFjc@FrSs^!0-pc(#;EncIZ*qnm1~$p-bxg!cPKH%>(bMA|JT2q!AL8
zmk(S-A_R!;#y-wHkU|lJ<C>0q;4^N1c>AlSAJ}Ek6{~e3oyZ3cDHJ!|9_bcE%5V(1
z1*f=(t2AZXzHG*%N?DT)EFl+1n!>!!u-2K`Zj<Hab#vgJ=i!uhepK?-6ujfcaT-VZ
z=XE@+wuj9izg!vnn2QagiIIVD96X4R$Rcj{1%JzblqVhmPFVY#FVHrwuTTMQG}E8H
zPh;V&okv@0EB|+<n)MAxvZlyYgkY62`oMV`U_(pSc)_9Et=*juMFEgI$YI~~X3*Ro
z^z#N(*&BdHHK!YM*~9re9m&edYV0F!gMKkde^RQhJ29Q3=miz7#)^(OQ>jW`ac5Gw
zUY*O{^p1djrdmRgZXyVXMIzQn0qZjrpFzUIn+6!pRNO>3CIfDyMrM3np*iG`<zg40
zhf>ZoS(!jmr6HEiOL4gDb2<J;I7)Nqx`xMw<M_^LQ_iX6EXP5ObL0ZUjc2NM{oU_#
zM(V95Xe2ICjL_1rIc0+UhzD5)zU;f~N)MWGNNQa4hc@uOMM2(ejgg<uOhy23o`$sS
z+hyVae#1Lo4e+Nuus(aO5D6uR7*d}O3Nu!gPTMrzT=vrcf771FGOrcz6B`ZR8ao|C
zRnvdCyR_+TyzRTq{iGKB$$bF)+=#dz=pSGpe3BcrK8@-7X9~T85~%n2z^VK1p=%Fy
zVEB8>=@Xm&Z{{<xvDtKYHZxl6_)<<#-VxaAcuXnDjdd!E_CzQk_%{~{niYE<Z~K9C
z-M(DLemMN)oP0Y=ao-gm7+&U3QL$gR4?NEI%ZpcNp#Ab<6JHOJ3roA*`Q}rGEo|oq
z4WlGyZ#Ptzs_#NOa${i^yP+BoA?eba*7M;GSclcl&CluM**o~S$945%wcJT#h1du2
ze-A52tz<B6Br(qLCXyI%H+mL?R9pw{=6iBN%nFxa2gzU_`dV>WaCBeK8*<x18hj8Z
z?;q&ZY)7=6;9!PULSy!1Cy16DcAb3SY2?Oo_E!~7A0t0l+zP19Jw5PC&QwT|B83Jp
zq#RHgil8&eEAhWnkjFrs3Ri61v6M&+*mJpJJ5l<^z?&<I_^7_W%By4%wO(gS=Fs!U
zW=K?V_6(h-p1kcx?s?rwWj-RhwL}#^I=$Tsu8Vsnow05NvC*`3g=PQ?pmsM+AvvoT
z^&KclWAn>2%`id}q-gE<Sz?Sjf=MUD_A>)zDN+Gc1E#93&^*=1$^J{i<%)%`1Cg50
z%;fH!*4?3b*2>VocZR-9Sgfi)R%pKn&DbF0e&?27a-FuvpZz+rUi4!s&b=O5cHVki
zh_qy8V#y3&EWVzmShKsc*HF-olrsYY0uY*=U9N+p?Tv7k$`!}=-(MX#KGot%3ile{
zc0d8uCFXDQ40hx)+TrIM$*!cWMm5V#{PffK6{Joy4a(^9x!qdKjft!nd-QGO_RIZD
zx3lZW8M`z6Y{}>jHKUt7Gr44jKaOe<rAh-|dc%A^o8*&Z9tC@o>46nO;0a4)g$S@T
zdtBH)^QBd6#HpREz4};<R8peAMt>9L(@ta10JsBh4>ub&g4BZr?`!W7RGVgC{!q&(
zOq`uW8K1%euM+6&=9#RZIZQzh5~O?d&8sg<vC-p?k3`Y0LRpy{X`P|u@RF=nWl*z&
zeU%^o|Ld?8I>l<egH%`Jmh3w<c3bY!#Q0MX7Ref}?~o?$wJnHnkPL1(h;oQLa1eMY
zHgrc}<gvLM1G?dhjt0(=cV22t|JhoxDeUjG?rLv+Dn1N*I$V}+GsDQ$QCZEx2c-SO
z7TurR)QuVXqQ77)wl4kDw9FaPJS(@CWaK<5A6S|xt~Ya7%Ligg$xKBrRFVEJ0JAIZ
z;DNlr_!EHVA$PG~G36%RKt}x4;QD&?nD}ik0#L0B1;Z&IL{~#4Amz1T6c1p#xVp2U
zj%O&`nUY~CGb5VW9EJ~D#k=$CR*JdM?G5LLS$E>jlk&Jr1DD;pTprA*(?WBK?N3wt
zh{H7#oMY4XYRWLP=Npcy98;S(rZ&&FYQ9iw)qIXK9rEwlb+j?Wy3?T$ZD`sWK%{E=
z2S+KNdrez8)AbtVN_uuBkrJzA(Jv3Q!BN(oQ&f3fsE30OR2&*@H&F)v`RSDjTIVOC
zx|MDEnGVgT=Ec;;=`aKqHjoO~zTV@3?J?d9b#aK|_iQ>jv)-ziL5JPo8p+#6`QnKD
zs$Rag4Ahp+j`^tiuc6G8Zkw@u5cE60<Vvf2qpnl7y>^uzX-OtG3MLG6CW@{(xEsv}
zesBAI4CY|t3wVZ8!6}bd%e>BXI(bE!XE)cEkeSWinsUMm;l(wH#_rF(R5<zy(!Nzp
zYv7kttu)C#ybnu?|MTBqgSmRsQSFY#@BBcF@uj+Q@5&G8jT_ja&Kc((L03^zF*WRb
z9t&JEx=h8nyM)e0epGb=zu5$0BRnF@RZO3=ZZ5=lM5#Pm{wWK59ej`KHZ0whcMM(`
zmylARCazTozCZ@?i|*Z<Vtu0CzeWM8JxpdK#(4<%&7aH93@l%qP(J(QPX#V_f{P!Q
z$lLbyJxghh^9lI>57}N~qp3eOTr|$v@DqBq7tFWp9#Gu}k2h)X%STX3JGF{I7H4UP
z^E0+1Ep_K<NM>Q_7Y63O!{K;PD)Ng1;e#JCVcX!!!_IkBp7@Ku?OrLni?!_Iyfd)A
z#731jJKC9#w=v(W{yccsG%o+l01!4(Yl%P8;{4i8_4&YEeA!>Rz@iv^<vgj2=0LcN
z7K1o(X&PZ`J<?Fq)c0uI{l0KS%^egrSE*!gfYC~jfb?S@F`|qhn~9Y&mpoie5t<>R
zDT3~pP!sS~MXu3k@3<l%2eX5?Mkzbnu--CUzhUN=@dn*5q_LYJRk@B=O#7e8&8GJ~
z^o9>Q^MNmuT*@Uu{z|!so)Rv}1}qF!<gf=TecVX?n2-Az0&}|6zKd697KR63cQsx!
zhe>d|U&1J29RQ<v=&!{n{_ghT@>F*p;?>LnHF^5F(xYC>>ob99fy=kXtZlF06{!~w
zv5O&vY<7cR$<;@uT`W(_CeiK0Lz*Q<zjiB$v4g`I<FCt^_%gS0j=bYLtCZ=b)sfcv
zN2`@{JZ6lN0yAZo^AcRow<7jGdfp@U-<$~Gd^3U<u<vn+umc<ORF7K42ABuVZF}{J
zs$QYw%t|*mm7vSc>CIF_lmHdMLQrY!W!fQCijlbv#Bqq6(${~tZqp$nwMsQ9c#3VD
zk{R?!r`q(jq=ql?X=B^Q#k{kXrBnCt1KF8uU%BTN&O9)Wp;!+rH*(x`YPGVjb;d<A
zi{Sq@14is@-iS?&+EeQq?dkR6F8P4gGHSwJsrvGPTQqa|&7gDalt{9(mfIPz5Eew-
z+W6g8*>!Ko-Y{NY-Kz$0PTEQx$O4mp!?B>51Z&w6a>Dj+Ul541G9cDHyje~5+&<ZW
zx;^&_V<cim<bf$SgrdaRY%Q*U9r-{)Z^k<;EYY=vEY9-kH+BF@(Iv6Wq+e)*ky7CI
zhX^*h__VuxA@sB2sO{iGUC{PfTOXWt&a7D&qJFdeD4+FEJN!td>WOEWu}sCzZXQ-6
z`q!1J8>G|RanB)EjdQaH`0a-Q?rud$yMPuv&@o?TiZkU_m<tCt&a&2p-^-kDZf4x2
z8yS_4CU&0|zm??o2Pa<@zl!8NgOeA>r)Q==oY-|FZUfq1tZ1lwE3xY;><Dw?u@<n`
zs&gWrCHvd>C#_a?2xNnYSzL9nT9@(y`^trf_)EE%h=uo|d;S~$Ol&E@FaH>nYZhBf
zeiJ`VkH6abNDS|lW~l53-JE1(jdLpa!<z2~CwGL?kA~lQ-fDT(Fn(?j$@Rhk{u0ct
z4>Zo6UPJ2~<kFp_N<!$?h>G?%m%wd&S16R;l{>V6KlD`d)(b|;NVs(^Kj_|YV86Zf
zshfI&X}Ij3V@W#S&rP6n61!ix@f=>vMN!@xhjVv>%a3PMBEs#*4sM(FaND%!5OX<F
z*HO2Jh7-E=(U#r1|G4N|xvx@+&wGZ3hIconH)U@HQAy&CY0t>U;hWrY)^dfC%+BFI
znSAy-NfY?u9m7d)9H&uqibU8eg#w(oo%?4BcQ<OKLzP4=coVhgO!e_UNMmRR3%v(P
zv69+Cj-A@Yk8~(&J&<~zUvtx;H^|MKTw=X>#7BPZQ*M>ATnId~leU;8mw-7B{6j19
z`cOCjHTBH3Zp)}$p6=&3D&&=w=JsZt(Ak}1V~v_d5dkwfA=G`t;?9(tD^u0yo&05d
zrlZ4o9L-o#Wmf8N=4WopxYJIvQX}{&<$y1Hs%9^_$MUGuqUoGekQR%dOH8y*<ARCR
zDk6nDjBqC6kH3}$7Z|{#gWmurYAt@F8v=!@>8ISqGmzU{e4411Gss_(J$>OZeOBrb
zfig3_mmY7}?)_oL>-|L@On85uJ~3(^HY{q-8iw5Dnef<WqW;e4@MoIR&qolu`!_WW
ze?D^D+mUxr9X#q@SwRoS^~S9?c4cKzu1%8D0joji-`rC`XPn3gqPj|dN*8D{o?ap<
zhsWp6bnJQr$4!}Fp1VBQsn+CAYf5*-(ampf8nc~iTq9MsJ^K*Pv5yEou_jgljdH(|
zf$_t-y;eBs5@?o%ae;7hIFCLvF>#pS89R#PaHhc@e=}Eu^n?25QD62xko<msdgVOk
zSX!#q^C87i|9ztIzw)CSKF*Mje)^$_Pc<-@#`G?$<(w+8GSkf~Zc0}34V$qLT7Uc$
z8fn4}FT_=r^q;W;h}s#|o~ttSg;<Ca=b12bKNq&8-%&KglS|tBqk_8S3Cj026&X{`
z0raeC{Nq;ZxnKtb;IPrwy4?+}`Nc<KJzx0jH~LJ92G>7!dROwrW4WEzI2!WMa}IYQ
zU%2t#bU|&jS>oJKZyes0*xkF}3KB0EjbZ<ma_kN|UOa^B>d=qjyN5rTezpa0a|v}u
z=BsQhKHRmpJfb_zxF7<2E!%XXIsI;WPkNiW9-EN6m}<(n&E7b?BfZV-S?q+|6jFzD
zyf||BHn+Y-Yuv1O$@qhboqhupD<yX_*^#tdO3$qawk3B>h#wk!z#k+IUTku3o!^6S
zbi&Uy7gp*XK7;|$i}RJMwF#P;@rq?{BD=Uha|dH*N)t*gW=7*ye=J$?1qe!48u9=+
zk)HE67ziUh^C*654pWOPvWEqVJTf(3IDzj}Ds*E<>r?EkZx!t`alYVVx0*NOP${vU
zf*6HZtzYK{$3YP?)u|PQ9V7L+b;`_5+m1_5y*=JJ1_ETKgv>;OIXt+Y*<jUCEE72S
zZL~E@XYr29c9`QHAksi**tnbrvZClqx)C!Rg-rtXZv*;Q$6Iy?8JuT8dwH7SJ9W}$
zO8W|>>4y4B9K2inDhak{|Ae3WeloCv7M(uaf|zxrH>;&pwQ*qMr4Sd|GA2`Db3!o7
z%RMBRh2x$R4BO@%6%-rVFlB(lE8=Cl26Mv=!~K1EUJYD8&kW@0tEL(MhoqQ$#r<sN
z^_f*<750O|{y^pKzOb^F+|JZWhU#;2Gu3;;X%zSyjthr+*#)!<+$|it-Vg_#h5g2C
zK5SN+BA0=fHQR^MNHgd|ikJy3WT#iQJD1MJOVnC?-~_(y>_kvvCQv$#8*VNl7qaJT
zc`Fhvt0hxO1zoB6j6i?<T+B}qDSjrrR7{~sF;oj27HG*7dDCCip0pg0Jq(^Gx;1>L
z=RI%1A-Us-KM!Fj`qQg1xB8-)>$>sflKU+9(=?{1Y0N847%`jp*4`qEjNcRdtt#Y(
z-Ye1ced-A2StzX4I0jt0Byt=h!F(<Ke9(B$I}Q)_+{nuZjv!sG^Kd$!e^`|$(0o)R
zG2JfrTd8?U47`1lcQx;>(;1KdkKys}ax3oz?w5G|x007pE*s&$K{tY!MFC9Fs{iLI
zfXf=>70?)xZyOMLfHEE+qT@R~T(FkSI*pPp@sV=$EBEfn3(<P0fM)>_iU_wt6?=!J
z^zOpCo_c9NRvZCV%zjf?VUAQDV*JoWLoFgcTIJRf*37|5KFfg)Dx|uN7VNymr5F;?
zn|-e-Y_FXmfZJ<l>eJ*#jnfxDF?UWra6iTR?}ileV&{f`1E}?vV9Y`$;$AK))(?5h
z>dhdNDa4Fq{zvT0`r>!vH^*ZNi#kM-=4-?Z0nKiW!8Sh)2HI2ctoqTH{ZD_OWk0*n
zqvEpvf>J*ELNFMwb6NrEN9QJ%?ni}rPaewXyfO=q9Iy-;OUs+}@M@Fdy|b4V{6Tf@
zwHg%ceei;)W(a0M<OA>Xvv50gIKO2cgN%?R&}WvwRUkF<g0{%qPVM_7upM|iwR9a^
zt#zQV4f|gQzenH+ng~Bw4x0AD0vNCF()Tu)q_trl@J2IuWNY-BdyC61KZWA`Yhv-Y
z|CKfIDKNf3DYYgdIVN<#npn}S&aK_|n%FE;=8`orAzs8;sOFixX_;zKXdkH6XzY|(
z73oyH-U^H3Q@PLKPfK5S^whfc8L2uI=*Mq-8J2tzYot@|Lg|c^HrlQ?+bwI%C*1Y2
z)ylMJy%<T8mm~+z8MWeVt<GWJF8&4<Kgv>50Tz_<IgLvhuI&n8JSEXZ(0JrD?&8V_
zN;JMo5C2xu4Q)#su8FDD&R3M?xF<BuM6f5Bdwa-=+Gp-YiVpV_wNLHiS2S~91L?V{
z=!A{>VYR%aF}UZXlZI-b^0q8pw3Ya&vJ^>1#@MJO2)Ut%Gb%u$tjN=Pe`^r8Q-7ha
zhyekQ*`ZJ-a5lqt?)rjTsdydCg2d-+la9jWbF?6W2uVFAESUd8R<^9>^mgIidAc44
zbj-x3Q^IEL=C$T|n>i2k@3DzJ06aUIG2u{5ejbnm$TH?pDv#n&R~}Es@*4rlc9j^@
zTR24)mc%CKWn1li@Hw>Oew7gqSdcZ`a3nKTNvBHH-R4}FJ8AEunRl-3Kboz0kP1C!
z)%9+S{X1$54@fMFW2Dr$jWR+SqhBa5<U?46G5Nsm8-#n4Zh4iWi%W|>rwqZnSah3G
zYy(a@UagK}f~JQn9pNqPzG+ZMEIbjI+hu#B8LGkND3@+2Ld|V-;s$P%rP|Gx<51Zt
zWR}*e#B9FUNEU`X05~_?Y1$h_x#YO=1qVqVoDbOa37hYBszFyId8?H6#qcXEjBZtI
z-)p){v>Bupf`)gNhw_O9CSE1C%U$0M;qllrx6z`KT;B~QDXye_o)<~&r4juNWW@ww
z)|lCZ-YD!qAJ3JXmyl`kRbk^P@LyLM{%eBaznrEqZyNsVTNE_+`nYmi^p8M19CHwr
zHGKL_Vg;#5&p*Pd`I;_6Fw)OArF+cP-5iO9o#(6k*3NSmBP;AY*RpcBmqd=c^PIq-
z_rLSZrf~LLEjEc=HE*7~roz&A&ADWjb{<!5R1oqQ)HBx4W`Ef>TDtb~0>UhqKX*#<
z*2ccm;#W`MrfTEvvH48+q2#XP7F`Un_=S{?1yAPWM;qTuK2n?9b$PtTyzObgPlgg=
zoXeAaQ{u;)O5RIuMdo{5{4n#jC)xhnAHM+Wt4qp6IxVgvnF^X^j6Zzj>HSOTY2G-i
z4@6u%V~Hpq5Ge*Y%Mix%NrH#|xG42UFZR-c+T7`q7L>?8t>k1Tr$3%l!G8v4*?;CH
z&0P^0^XKrG7vRUO<vM{H{3x7j#&`WjlgS;>7eI4isP0eL8`S~sS%^np!l<~;+L(R~
zdGqyR7+sGUangkuGYn>67VuBkAy__eDLDo+mNIEg{x>{~{9V+V!WI8F3sIz!5|3w_
z_KO*a-v}4xOuEESlpgv94G~D71djWrZe~wW4T=%f`b~yMrq(X^*k|rULf6`#1fI<7
z^RQ$-SmG-$!4hu~fGZd8_HboXNt%m4F{|~{k}L>iPV*X4t-C$MIkF_}y#o4Jt$B{r
zP4=|9h&{O;5zHOGqEDTvwe-^8nUe2#e_K?pL5+4;#NP;1o!_6YflKa*{={snH^|k7
zO9V${KLZHh|GqScg%_Mk<q~I6z(Y|O_j<h*>Zs5Dow<{6TtWz!Ye*Z72yccYrZa+f
zdZp+ez^^q>zqigj*4FDWzB7JgXX=|81VmT`ocEg5hAD+}xrG!`sHu#IdE&t}^v<`w
z5*i%*t&bGEarHEg_}<S*MP#fhS>ivI?aEH$9fcdX-{Yk*{qrv=FMZ!U9<0A!dd>$4
z-ptvHS21<-mD^=_JigLT9e&Ja!JRFBnpDX-9A1JCDF^DC9YKeh<b37+TAxpm#Z=@z
zG9}UMbJ7okVoZVX{cchXD<}3NI~hsC6UV79TfM}L5fF75kqt$$n1QxOC(Iv5cURLW
zrgn$Yv?oABHxczXvW(G)W#flwUO#p%K<wu}h3NhJ_$hQdVnjC7pU53oXj!F<pNl@{
zq#)lHq*QPU9>J=+hUDU9(&Ksa+<qsXg}H&NUtz%OYTl3&@J8Y)Ju;Ivz94oGb(<+A
zZx8S0Y7ht(-94Iuy54ltT#R^{u^A#Z-2_uQ{%jPJJlsPk+bhExe)<#lFZ|9+;q9*>
z3XVM3?ET?KEQo$;ZgLk!)ji>4cRoC3lX$9Rds%v0Zdy1~HHm(3u}V%Yiw+}aqPRns
z`?W~&Jy7Nq;Nn`3BcheK6nHZ}pVt{HwXc(quDZSLJZZ4kj68chlm*Fh<6gceKMj%&
z_C1LsxDW6>iSPOncat~~Ne=QTx#%F=d*K`LaR|%@`ju=<XK`3bVdKYuh2>3|;r2b9
zsk?4n)3F;aEG&3Wn4acBuFF8-90o@*Os?VkMxviExB<&05}FT`DaB*5aE{eb*=e<Y
zZ6`$g9{!_NEooRRNSAxGu*3EIoF^n-mk^a}Gm_2VdQe(A=E(?z3_JdnV|4WJUBLnk
zb<3=blY!9@n@P%?a0}S@kbZ+?nKRpXi)K!}ibpszyE|7qaQ_ptJU2aYzQ_#X)W&pP
z*mp3?Iy@oX9sjFwD5S;RdJI*T3e{^6suzlF%>Iz}_9aXI^uA>2<3C82o*P{%9QRtV
zQWt?vx!@oPxpn&&Nd5q+doZ2nrZpo$^F&GfVWqjc#mZ<uD*RyoLVA&fH1?6m`u=s)
zjz?wu5#@0t`8@C|$B$h*F1ZIXVd>{2O?vM0kg@*;^UPL&dv+!kvg#_KdNj)u*6M-u
zP9zK?Lzj7Ts%J1K?sg2VpMSie_3rnuLE1K=>8HZUmwG59oC@Qsv@yM13JYB6S=U$O
zJ2a_Bk9vkF9*>SJ4I%cV_<x^bT|Y9Y|1Stu>oF@>tH+hW`ngto2miLtwQ`T~?BO5!
zvfS_IT30+ex6yj`5r$fe6W`cRvnljBovHt#ZEa9tp3bG`(U>b1BRU!lvQ21j5W)o?
z*8lW&zD8|l7V}_-G)KE$nZ4po8l*)tLN<C#j<OtMn=vy8^?7NeV``U<S3@Wb?9h>M
zgkF0kBgIL?B&?vQ*yPB~@DJF!SaAY*<l1h`Mq6v7C`6GK(LuV^WdE=RZku9XscF+Q
zo!Mb#<0~~Q+*hqR%noYq(U%=P71QmJkWaG}O}C?dRDWiLPP1qEtGU=$vsj<`Uqt+w
z8;Slq#KzWokG9nDk6NwYU?32<L(nO03bnS&-*HEfDI@I?R7^xFNc6pM;}l*eqhb2X
zP-&e)!*}2~uy;WNsh{^;9>0hZ`bC`Z_E19c3pR!DB8f7)rO&9Lzn*L3{vkEIh#LC2
zP<m@N4t|q_8u~?C9dGptTFd8>o}H;o&e=8jz`tR&XDAgX7LNJMmgd#C(CV_5uh!V?
z`velO{+!QcMlO|@H}F}x&tlWssJRwd1B7@w$_EY|SRLXGRVTjY8$63>GrFlCZKiaU
zFP$WBTZQV}qjK24IX41BR?X{u2An%$i-Cx!&Q?4}|26$6expeU1IHK7k>ltyc`-0B
zj*1@vw7m=PQM#@HAhws|HX5(d#%Xj9di<?H>FYakA0tn$j~mh4ZO?s;w;_0k9=_dm
zCcUUFdy9bO>6HlTkvLgr5U-Ei^JC<&``R%O0Id=nScGPAV9ujl=YehmBk?jOQ2XC5
z_dxEQ^Z`4^1VOR@F7zV;SD_;3pPw5DE)cUHTr7#~-%ukBCP!{3JRWAs^kNNOTiMZu
zMj84Pz81rr%u!gGZ#L^C`P*_m>227)g;W2eLXTnKge1vZYTdj#^bUjaI$o)W`2P_}
zP8{tc@QQuwXuf|R^IVTr()TV6(dY_m+FAGugJ^n}qS^QhEI<R~5zQ$=<JD=!vEZw%
zd?`8hTA`WiccBq{rJ6?Du(?*tr;Qr`!!KsXF)ATGdZ2$V^a;ez2d>Z?GE221lj+YD
za=kg?9-v#oU^?w-NvN9R3k8jp-BEhWRHPo)cwK3Hfp9J9M!rxOi3EMSou$}0dS`WA
zHoS?I=8~>0<C-#O42!gMdb2Uin~jM5MWFf1%Zkw40W>4YrJ4=$n2oOw%Io-RMU(&4
zNb($CEE%yc<Les+mdO6QArxkrx}i|T<)ioOFNS2RkvH3jZovF@pbOPqZ6ID`fU^HN
z!c2ro_8@7c{s@v~U*kW&EQiK#k5$i2POLsYocVlNyf=FWHyN5R*tr|a7qh2LV^3oR
z?!hLZ^3hlgdGW)w=exPNPs~k@!^iFW>@$(fB?x*7Iddl`Z=JD6zUljbWW;KGUOzdR
z8w3-#j3LBkYxz@fPY|+?vt>DqB9a+-qpll<&IF=<t{S+jVf-E=K-Ra;&0&LVD$NF0
zeq-sjOt*vvY{ZFhX5{Zc9X5ijRd;6d2F*}Ldv+ufuZxU-f-e2jYAxrq!f{TM9G+k#
z!~NTT4GmGDX{f7wW-a}^f_=weL@>F83$&+s3kF3QM9r{+&V*Gg{PgBX`k&fYZPR4T
z&i;{>n{eq6v71IUWj=YZ3;Uzlg~|`dK<gkp6076JTB|Dlm+TLDgJbXCz*;atiH?8G
zz0g2w2iU+qOOd@duro+Kzy_B4_`rQD*RrooYk@YcE6t|GZV+S<2NO&3IGOD@$n4AN
z`iNioO^3yp(yk&5Y-Yz@T)`-Fac|o#h8gfS-OsyW25^Hve76ZRAj7Z8L)cKf{q`kq
zNA7m_P@k^`D*&B>=w^A2*vIasOOygO-JCpydpoXnXEoaLqOb2*{7CPT1&GypF@s<N
zZd-J9C=<pOZP!88vJh!*|1JwAJ02$SNNbtA=OaOkW&-KQ{JwKBU#SU=+Z2QG+%=*}
zR!=YUYNdv`_0?L--e-{olkF|kUTZBk)*xDUUea+^^3Pg|#BIvs2P-xqI^jOycR!+k
zEmVSkjWf$Yba|3<C0W1nyG)N9a~{;M>}COC1at_e)`@fA{|ng4sX^}Ph9L}C2dJ9H
zziG98j$M<T`*7g9JA@GqPNF->H~dlIq%f78oUK_#H)k?^OO4G9PPE~7jM2?lD!34v
zo6d6A<|gPG-89PTCYXLU_i?g3JDMPdH2K^F5@bRX9KH>2ui})f+oin=4mu+QUDKSP
zYn#KVhtKiLf$hxb+s;nzs*0VL+;zN_g1C$Dxisa`=$Mz}XKy*GCH52yf@_qWe7D+4
zwv)v9^Hm<nT_?n9a6N6Mj#qYmbM~nITB2iK#ME=>jVFd5ywdks-%{Tvebds>IYYw_
zp5QxyBi)s}j-10OXIS=6YNdGKSg*@ugJi!iIbWPwoI-Ca$^EGR8&|SXkQ5W$e1~)D
zULTnLFKYlscvVqE1e^}e0jsMc{>M3H?AyQpW3fZRV;)m5^f|NOOtysckKt>@1(b&q
zk@1iBquPm6iv2Vn9j}kPf@A;aVWyS34_Ti_@|?dT9P+4RHbXiDFR@WujV45N)@r>A
zW3|Dvv*=JWGq<Z8GqVu8*W48!2$CcFmw^XEeYgOpg8$FJ@v;7~?F9}Ic6Wf;`*#T(
zN6S$#oQjap-LJJ{<OAQnh~%O)>TbOiWRs%`G73IR2xM04^uIB~fw`1IZs94N+Q`CR
z4{6!4WFxCGn;Qx!GT>&!8&T(0nqv_gUDF_GTw(!k2cq`k1_T-5NM@oH-au>mV}CR@
z9Y`SleX|_(_T@&R`!lg&I>?vPz*ZUJv+PIlZ$NAqR{eZ`@)ZaJJpOoc!(|<>K$m5W
z`<9{FXOK7(!qC3|;4mT%?GO|Q`tY}j2a`+kJ}3~3wOo!tvpOQ7XY~Z6p19O%J(NQT
zU9lMaTcOsSR$DCz@Zs6pS&RjUz!?fF!)cC&W`lR{1mAG9HyhD(ePK3Sekw~CV#KX~
z;{;z6xh6EX{9$6*-fOL?>b$zlXQgg6{8dGk7tiTJIyHxqkZ3Wb*pgFV?9PTeCVf*y
zG8JFtG4>I(D7eyM{xppZZLaA`+C89jnd6I^;@G~*Yn7jCyq^$iCayt^*egfrVTCqz
znFM;RqqeXik_pemHT2A(sBE|LW8ToF%;I@4V7nuknTttSteoegu26OZ@~*t|i7mi5
zy>c;qTJ4V=Q@~Y(1O|HjT;&~VCu2H?=48V^_3<m1k@MAYg|7g1L5=BFkPrOj0`#lr
z(?TDU#P=EzOLzleyz<VEWQLx8n!9tYzcj?Spa|%%=IHNJ0V_|R=bz?>`o)ieNd#Wz
zj7<Q3)l`rxWi;Ti$Xu?5JLa8uv2Lb;r%7IKl0zgjFAc3+cy-Mvxo%rw%`MEVm3oFl
z%h>kYD;~S5%r}u>6+hygR?O)`=aZj)!CUUkfsh~{_?}X*jwSQXl1#1Ie4te+$&Iz@
zq|v$6nQyKt6f}pI%iKbSM5vl`3%Ru65{F5oG_3RM_REXh!^{rP<?}|i82qhj{tec1
z{R-Hu(i&yBbS%r}B0qAAU}Db;*6r(nISY1?8*qqqJ^UGL?yY4fQJ#|Lv5>pU3sHw&
z8EOvmZz<}~li7nQ(y#v0vf<W?;hFX9BUjH##;oUI-m}hoj^oLGz>!PSYNgJmBODj3
z6zspO0F#EOk#T~-3ZpYmY*@{pxZ#6zj%zV@=yF7It3RDOipu7uGqpSt8<0b(!tv%i
zPd)Q%rNu^6`4Y%NO>xkoK_W6&8*i<<Yb_-byUSvS?|h1ACCQikkf-FPhT)siD^)#2
z$Z8!%o$iq5Q##o4xIE|L2StYnnaKGl$a7`2`@B~j(nVJ2NmDQXHA7u)n_Vr<PCZ$?
zglbth4g5yvR`1>kkTHp!`YTnE_Io?^I=|AP{|VdN5SF*7P<M6(turx&Fi)M?uR;R4
z%(#4J*eQ4EnpP0y7+_=QL_6!<0t4XLx&}_P0Jv7Uutf1!1e3^0;z0vJE44w4YdinB
zV3<coyzK-?3Xx$F=9{iZM~9{QYlx;}qmll(r!x}j8`D>gu4_zxiMz9|<Q`te)z70C
zl)&!On%!zc4y|fqZfI4nG(^MQMY*2K72PmbbQ|OzO3hg{%;cFjOKO{bE|1IMUAk51
z5{hT=zCn@l1tJAue&JVJ1wE<h32{2@t!8`U96+S?_AIj0!e%_jeDj1-k}jX45^GCJ
zxC{HIZi!lomoDtD6bhP!eY;yIK|6GL?LA(5R~HHu*Y|9<V7F?+&3HpAyK>*3Aen&)
zg|eo?GkMFtU@|r+qo7>Fn>(L|(?kIX8nY4%pDs3EK8H1tZLHpalPrr|K=Di3=4C&0
zc{dkQC#iPB&1H_BfcYd4=rKJ?9gMf1>}dW25r>!{Vx7Sj5QE+>{|D$;xJkgBpy(I^
zdUXs5cWt8kDCMVY4|lv)7WQxA;z@-|uF#>s^tsGYqhWzMUOPKh?U`R)ej?3>fRXE*
z{kiXp8vsSlAZc!6x*j)7SYGw(Sbk%+LX5p~)dWVP#FaDm7=Nq8vC4db+j9BXB_?j$
zgt3o=(yxanG<V0JL6FuohM-05^srq$#ItgHq{Atbvd;Km=*~yR;O!5dCH(}Nj`8`}
zVGzw>{OchQ+T!!zJYZ&j#YGvmv6q=JLx|BS1|R0dQ_`t1*TQ!Y(~GM}=X9jFQur8K
z#>VuEh^49hJR?pGCf<AD#&Nt}Z3L>p<X<_2J#HkbXOViYOQX%rhhWEFy+d*jQq@p;
zOYRs$Cv=|yt>xn!gen=JnKB*49uKx4t>o_1FmmL5Ih1J~%?j}a3H}yr*{Xwbu;s6A
z__xP(S%SV%ZFUo7qgZrdvWD(+_ppU0=w4od^BO4j^Y+z+=j5XOrbdxZV<tGu*X*0_
zo8pUnIy^MYRW6T}-RI|Ar77AeMaKJLgkb8--owu4X$^FLJ-PYarp$b_0=nbGRX?p<
z=l9>`j%d5LH#b?0y=aDVll#Boi;;+v8b&HW*k=5jmwx<BKK4FsZRf-IaH&?Nz%`@$
zH|zph9dQELD!LNPV5n7c%Ou$HiVM0Y-N<?WT+d#Iz0s4|R{(oHFg#kaU~x+aRzpqA
z!;@xbDk?T<6&uAZeB{G_;0y2KYM0q;A(rA8eSE7wzF$FiDATJ)m)VF-nM~j=ee7wt
zzH>4wE9Y(&TG5Qge1PGD3^tYI93)YkcTvs0*C9!U564rvYYchf-&v0N&inm^iOc@@
z&wwjab^Zgo%ZwjwD3tR<><hCkv_!_Z(hOS}lBSYzY-z><Wk7h8G1SX=8_}?Hu`<q5
zr_q+r!p%Us%L#l^p5^<p*TGIY^FAfBkp^z!WD~qo>~M<Z12Y9^kH}l8h;+TP_|F+f
zd0qWHnwQRs*Dfvd`Li|r=EL9p9ARUo;yZ9iZb0@=j-l}f4T!5&yO}M;OiP*nsmy|0
zzyqQu7;vLQMCf}#5bDA^yZg1`r4wT{YvMjR|9%`S^9*`%j@!_vVnaWwBj+q~PH=Pf
ztS$8KE6O>_R1!|_$<FG;pP9(v25G6Ck5QvF!Wf2RzYB%OzlgbCUwUaf`8wC<f0CfM
z{F@>C?dNg3BoXxvr}IFyd|)Ffo+e5DqbR*)-XQzK3r1HD2x>aGetWGJXt5b2_;U))
zn62#+-u7L0zdwl&>c4kn2>jcA>nXK2J1{&vTOv>2<lU3!aA}ka=H`yG5V{!n_PPDQ
z(*B(ftRTg+f8O7K0Pg|e<yk<x%8Y%rKhLy(<X-Jp{~xt4wi3UJ)VA+od^C8L=y<M{
z^vlDq)uxfzq<E^geYbUBc)4cf&R@PHg5m1OKXYvf!okJ;O(G_*T_IyW@G>d;ZqS%#
z^xt<pVEc)UMsbK!<dT6dEosmlXl%a??z<bs`_%`;m%SxZzC!C}eeG`C-%vl?`r@*e
zGxUmr9m4*g_7VEay}lUciSZrzz=ib9OpNL2jQ#fXBg_ZWpsms6&F?Xj-7D#*rr)&k
z8gKi9c?0DRv_AK)f5m|M@A%)=Ujm=A2Gm^7n|qJXc!u1Y7^Cm}5dANy{}~BFi;(H&
z%{BesFMtkQe`2G#hZu)d+)HG7^?>FsH_aLU0{^S|C>hVt0S)+g+jq_XJA7J&KCB;V
z-{x(gLF|6oEcM?vz(44q{kUX2XANknp11wfJ;;C12kn=hNZOo#8@z!O&!bO}@*xM)
z$|8fz9%#KJHtJpn@%#3H4;K~MHw*K8)Ak48!vXfz#E0q+-OzE|J^!E6KYo`?KS9a|
zHgmx7;!H`l6EqVx&B)$<2EVX>D70oqdj)ShH~V!nR|d%1yXHf!oNKuf?IrDJuC+sb
z`1vOO9a1-guFSF|68L{4<pW3g5$boZ`FiyH_Cix;h=~I=^Wo^#USy<pKr2TcsFjZf
zuYI8D8iFhJulJwu_92%@<A+!uw5NG@_p8PH!cXIX_C9Oc`+#Nfk;gZ<z3z#n<9n31
z4@QoUgn#>h=bQoUU1HiRy-=_py#J8&)3r=0Uf&Id?WJfbzle9gAu>d&kXP1j{8@(W
zFW|EDso2P<Jq1bBE~jRm*!s;AN`bMFw|#fV^G|X>dJq=>bhzQ4K4=a<0{_%6o%~p#
zudHlWI$1@^2U3p%_80mkdc?HV7SU27U;K<odR1f=exNsRFX4#CC)!a`g)+q*<rY#<
zf@yw@D>+>m*&jq3Kg4>Wf2v}qdj%yHqz~PuqqIJ(q;(N_?BGxkm}Uk0eK&i6Y^|=3
zLT?ir)s!#xNjkPef}s8jek(5AUmy0}vk%9g<FB3Zm)sb<m@)6WLR`2N<6$+(hhBp$
zf5Cc0Ave`>5A>#kj6lcPR;{Ui5{G)}r{&+i(`n35h~;ygd$B23VXh<~l||6j5ykt5
zv%umT`-}DA316&@V?w;k@gd0J#(W*7TK^I5D&Gn)c-PI@3$|7wQ|yhV8@ICbF4#J%
zvvF&!Y&F7ZDoAc=kc<JJb4Jdgiw$Sfp~p+$aiQyRu$GWX4eUUUG4rg%*wEYP<mK4U
z>k2BX^(r$C?6`V>94lBWOP>kDqgIe0UfT)aYW(3E_=q*TK-KR%=Aq(<;>OzccVb*?
z2P+ff(C)*zXr$HV<r?HM0D>)11jlOCy~e10V{I^THX5sh0mAgUuw8>oFdPh^D@Fpf
zTY?^|u^muy*QTifdG;D4fv0{6Z!W|gLLo$QsGX!Er&4`7w3VN)@)18BW>Hs)5KD!m
z5QLYIH-4NHc7@#QLpGO5KTp6Vrs=2i_vC|}Ln*5--1$+PUO+lVfgWdOb<|!|OVAhQ
zuE}8n6u}^Pr{Zuq+)a_d$w>aK)InzC&Am)#pUOJpv3fEyVzp*X{V2aMHOK2KkxiOV
z`7~FTMl&&Jl-*)VUPg<HOpD&_xosJ@#rVmfO@9;5{K-w0%Vd1V$`a@{kQg^N)w$!;
z3Gee2-sjj6kxf~uATV8~>Y|?^PCJq|G0AB{F8}IW&Ct?n9R3aub`JAr|BJj};v8ny
z69t~5FOKT}Vl7`FQf!rujxV@bY~Z2E7#JFbQP(i)8hqCp7g?cNyynzJ(@W}i4)ezj
zwyMu10t#`ZehVCtbY8W_K6jLT-cdN6t@Ezb;RulMYKjSgN3TB()j+1#w}E?1TE1Zv
zmx8f&_AUi~F?iYR&8Fk2>txGgPaPG``?8nwd++_qAbIlj`l1hUuR<>X+^nFf&8(XK
z|C;e6Ip2-emhNtB3qd)W!B7@;CXjeUn8|g5OyG^Xgqh9jL92F+jHi3+Afx5qyp{KE
zlb&f_pYPTxo$q>>^ypK|>#Out=4Yc5dUl0IiAoV<G$gle-DU-X&^WG4j`PP)V$ydw
z9W&+m2u($rppQ0}^z9`MW+SYo>exBiWu`ug-E0eccK9A1t`w_r30<!`<?Hm<YUHE!
zr0OrBYP`?mVHpo^mpKT?wz8wOgZisupMrCs51)gC?RNe?Qn~FW<A?}dl)w7)CT9fA
zC70~*$0sX`lCZ|kT)eLEN{Fx*<zL{4^k(dT(TEnPS9Lxxg;yeFwQN~MXFLkVBI*HK
zR<rbv`iWWk5Qd83R~i}tZIHKoLl|}j>5Np&nTmIRYzpoGhCN!hJo|WvMy#iZp&cfj
z2#@xKq7gfs<xrjMEC61VANSK+BRK}lUU;(@4oFuZUoYu-n%BMPZUKXYKefW2TF3uc
zAMs`T--9Q)E^%uMzDD&;sc3oq>S_*1cf3#M$80I!23|+2Nk#`!$;0er>6JSyQn+}O
ziLY_PsG@1)3fHTZxLHlTN2dO)i+1wy8Wrt=PP>WG%tqy-PT#6W=7gVqS$KEl=vu{L
zQCVCBn#V2_MQ-KzAz-pZ>YKo6Zp(a3Q<-tAwkOr_h9`r3euFR``|+e{0ylcZE~3x&
zz2zDJ>XwcdYs1M$%2MqSVpCd;f45R>dl*dUIwwE4d#v)-^2d3>5={GHWc;74<qs<}
zbJ%H^4Xz2McZA0DmW*=mA$nuepu*_27)=E4n9phe!u|pL&b~XI+^CMQn;lHcc1rz^
z_&e2?l<wDmgw_o#GtJ&KsULyuW8J&iTQ!-1$Ljs)(mEp@uhd48PnMy$OK-(9Pq-t?
zb@#H^Az0_e56|9CZ}NffQZ~2L*~;DQi6dfhV+!N?@QHXnd^A?qhmYg_ln<X?&8Mx^
zi$6^}qa1~YFh9avZZg@WuDf2nl&%H7b$Su)Q{DO|@KvSQXYMeMjD}|P?t*as8Jsv6
zL~Yq3G#;QtkyT%&>bUPP()9wYtDSUa42O{$abW&)T!}u189j66e%g;Q->xg@QvVTq
z%R2|vw=XzIA0oIIeaMbW1dcmS8w`#FDPlzTZnZ!SSl`9<U$DK4HsJpLgs@$413z55
zyEst>t#uWjRzjxY6g^<;aBiHbI))eL9ZPVpXefRV+vZF;9QwH_@wPwryZ+W_Pmamq
zF(5$V1IM9Y_b(dHug^+Dm=sd4JHNUyGwofBAN`BsiQPkk+>MCZV8;3E2knGV+#ITW
zIyM4-k-5W(2=G+yqM&i3X&h`Wdxa`Ocsv;Y6a`~vHu)b7w*9fm|8&&<XawWsyEmcC
zKZv?dqoPg0%BNzdxi5EjG}b;!{qf<sGl|X!D{>khIM*@mcKN^YcQfR=OWED6b%!Q)
z&!STu3Eairy{WO%eD;)vQw<vJ+~W70M|h4V|JGo>Cu~Ome@A)lzoT{#<cJWBGeW4t
zN1!i{aJvjoyB%e@Z|*;{GP{Un_~1~6m6c0Xqir<Kfobc_A3)l)d$8d--y5oU;VxtD
zLfGS#)7zaC7!tNGB7}3dwfr?ch}s|HE=XB~n-pW7jvqwl&#T5nC>JxoBKghJG7}F8
z=eLmte1<GM$>U!V=gf+oMK)QH<h%a(-*S@&&?{@*vB`H&j~$wPcUJ7+l5(%+j*PtX
z$Ebe?7u@K?qFW;VP2RO?`2R7RViPrev18T@=jo5vC&r%^KgDgE*zB3|hGhG&+>r#G
zpnnnn8BE$+rv)oJxLAC~@LbuNgSg}!O%H8Tc;xBq@)vSrn(2~jdcgF~_s!A}kZ!Gz
z!nx{+{*-G->BrF0{f-le&P;`!E^Loi5E4yuvTvwVDCgJ1OFe8=2WzbA$Z>=~Sc4tf
zDiBz=Lv9+!f5Gv%ETT{G>NX-T)R9?7p_<SUaHV75KpuuW8rRl5xv_0Y1KeDYs{lBO
zl@YP=rx<5$Ck|QoSx#`D;lzZzZZZx}XT_?Bju9RIWc;n{a*8&|!5x>vIKXuwSc(6E
ztv7eQ>)(^F2Fwq^(MMXzU8l!R#6&-KoL5g4!aw#A>WLqbJAOcUa{?qIHiCN?{`kie
z=bRQlJnDZWjNjyCRdg@x-xeP8Wc-^lt9D1ql4cB@>`W82cDGEd2wHdj4$E3rTs!70
zT)d0;sgfH)+*r)}t>s+yW7$6+to%c$atlWdqBKq}=Ooq}&6L;3B8cCd8=^HpvdNcj
z7vB`k#32W7SSi`d_RCAL6pD?&Oz3bAU)?(Z$vtJ(vKwec*Mi=n8?lSR{#|XG!v06Y
znexwsxjcM#J6@Arvd|u^Y>yqzZ`OG2RyrQ9&n@!mv(}YO)HR%mEdBOMlX+<FlK%Fw
zvTM!9A{;IK&v~Q+4`+)11Rgc5(pmaqtWpw7Rv%=gzOU5u+u>81S6Rz`X<ig#;~9;s
z^;0bN+!}BM{y4A^F23lLhP2+?cMVC%-NTD7cb6Gv&gP{rmy%H|C^LJNU}Uzh{{CUP
zr#}3FDDmn;{CKbZ1)m0$)pq<(V|V68j@@ZyvGuc}8{8(NlPz1c7zXT{ETjv*D<c%~
z)W?^ZmGuJ>D6W)hHzm@avd3S#*0k!}_|r4AA<U3*k(fp??uJc&;d;(Z>o`#e2zGNH
z3#y$qABW#M?~22qu#eJAMCNrb85(;Acmr*H3fj6U>hB<}GFR)u>4?3u%5oJR>FkY+
z*=jBOuHf(A6-l!W+G7Vp=Z9;Zuvlir4k~|lV%frS(Z`bRHSD{45!1cm1|Z`9FLew|
zT~sx3DA)=uo8ghNSuiOccz@*+y)RWYwY=U3ju+?^r?sZ^mI6>Sy#~JwT$jUB1Ix80
z$<9y@+qdC$*&Lrl8uI;z1mTfwP5zFE=8`+C+}m*n(g1|<TZX7)F9;9H>WA>#kui^2
z%T^)rFc99#HOJUtK-i~c)G<-JX;-jvo4nYwO_`p+7rsD`F;RWXJTjmT7BiV{y^Tq=
z^9X0mptzr{t3CI#J6h{j?mZ^P^X5jbU|cbB1>-TY2`+wn;|XVGXgr)fyTktN12AT<
ztipJxBCPSe1o`70d?dXUoMTdAhm;J-kOw?JwTE!In7)doHCw?P)jjNO1#-55TDF0D
zI9(kxBz0;FO(Vco*jL8s<!hAuRT=af8}gyCu?6{oZNLI_;JM)L3?PWx>Vn0s*9}~X
z_fyVF3BgGsGZU>Rl>SF!+u9XMvrPqrm^`)+(6!F%)%0qsW+><U#x}DNHKreHY|Ds%
zVVBvKaRoAp1-DXlJ3sxACZcH-a)@f@J9^RC6n8)BUUg^(LMOt_Hun+IR-<GF&Dh;O
zQkFAvrp^pMSWo#?lwU*ncB|%mpcA1lexwBlK?YWF<B1k0a+ebWz{2d)4}I=D{T){#
zBok^ms4@>TXkogBY*i1nsu`S%JRT|`qB+(>HOiS`^3Wi8HRC5}=xJ@KFVTiQ_2hJF
z9zQfA_^X08X1~FI6Ay|v08gPSJJa=pC&dkngl#roa;b>_saf^4rDASnWjH8r&s`5R
zt}j5Yj>t}Rd|8vxB|EDoCG<zj!2jvgDN0&rzHUo#*wArVh{b$Mw$RvipJ3c}uK?57
z_H(S}c&x=1u>dqDfJyNRNV@37V3NM;TSXEx{XOc=RK03ap4TdyNJ>Aq<kIh!*W1;2
z#uFA5sQ4(4iXU-}7N!Y6jnp-SJgwqpj^f4jIDo$FwdndO_+DB4>+x;Y<AOylZIMoC
zp9|4-9vSZe%UFp`b*w*!_1DMlGLFSp*%ms4#aFGxXV7_va~s#yg?Qz=V8TX-@;m>-
zeH^W7V5dQQRJrq>BFH}e?f?L3e;XuBE5OI`;InI<fe$;J`Vv9}RB<D0*Z(<u791Ep
ztKn2xeZZx<sSo(92R>Wrm-wz7ZK0QdPmh5QJPDy7FT?W|5^0WR&3$pgI)-{Z(5&hQ
z%}>8s1dVU^0MHmTa`!J!-k;#J0vcg;it<B(#&mN#{2zNpd+c=lzL>wF{vCF92-~#P
z%2}7Ir`(l4L1?Z+MpyhL#Qv2Eal(P#Ss+%1I;QKO5kJ@jVTcbiC&%0=Ztwy4YsDWp
z;{)Ok#E;=bWHvzKxHEn-vV-is^xFgx$PM4Wi_d4=ZALCWo4A}Whf$lHs&UveuVV+w
z$1aU#u12bSxCG(hbaxbE`SDw<<v%oa|GsJbdseHt5^GPdoZMMH{xstdgV@Mp-iwZZ
z)mr`r<)VIsVl2}>=c<27B81><X?5q+QM!}_!X_x<E_NeX4rkD3nApJ;ho210jGCij
z$~QD$kYyysKvMEbkrw8~=rnqGcT9RFP^Y3&uRefCu*v_PwM_Kcgpa{KSHy>}8@*^b
zlxs@A==={d6+Eu`V>f^<@Oe|QBR^4tOML=<w^-ag8V1ej!+>hHvj9~`)IL$*$-bkx
zEL2@uN@I^u5E(s^VM=BxIrb4}DewS~;Ut@ToEvy4(6B-L(^er*fsk?Uk5?)HjwUp9
zB>jg-`thiJ6LsG}RB9q$c6?6fhx}I8f5XVGlo>W7&jnoeW+m(mEL`o@w8;v);cxN5
z&;*CPhb#UlRM$|R%llZWwDSw!N8LOSuGp9zM-e4N{99q#%{`KyaArFEWF#|<Bh*tI
zp&kwU-x|QS?3Gm@lT=~YmU#!cm;#-okDPfV#YpU$C0CUVmCqV)m3BrRxVUX(4le2D
zlOO=KiFb!`XL+@{m~I|rwRZB$aMzs3GJ)OyZ92OQ{FdA!b747@I6f}Bic*ox=e_Pe
z752X^9|FodD%-lRJYyAb9W}O7WB7{lWe8tX;q>z8__tyWxz8K6UBA!BO^v|uyMWll
zA$cf}C{xanxlit$Q%O$zu*AC+%!h55j@pj2%Y4`?>zQiqKkJNx4{hg4tnSTy2BpWB
z7N_ksXByH?_)N`NnCn00k<x@gw~wdCkt+^c5%q5>97*=EYZZ<pdu3I6M-r6xraJ`m
zS^jvXX-81k9U~s}?=_vq=ve92oqa0<HGX$!ERcA22thQ_f2$I%HK8ww<Jr`NG1s^D
zT4m^jw)EdLmehc;803Tb(MfCFuS-u_P3bJ(swduoD|?(cV03Bd)W)^VZeU5*vdTb~
zP!NO(vzyF-_nk>P%s^-k+s8a#Swq{BYakn|*+S}_Fa4*s5Duazq6FxrYW?X#1rJ89
zpW<commSZK;QAhZqD%NRXBa4|)%v$#8VeUiLOUYqsp275vwIQZvKe21H5b<M-}Gw!
z8w%wzmN#^EG1VrhM>X>SA2l`b!3?W<_8e=>y*)}EV*ml0*lykokX#2}4~-)wnz>Ki
z4QEU^c~0B&b5mqbg}-iUjiejTqSgWIezjqM>B$9WsZ-Ij)T?rYY4QV=P+iH+ah_-D
z=KlaJhNn9y_Q~jkCG+F1UjwyVpp6DRI?nHQE|gTujxWw77|nb*T+=n%j1i7f<LpeG
zqtOC*W~&qjZk}V<4~`*Cn!p*L@uFW9*^j2Q<DHeV+>T(>AN_#sVY4}8S0Ts5W6a<~
z_Ea6RgB-H`izXzzAl+<`?lQ1iM@W~N3Cv$E0lgUo`+1p7Rc;A(i0rFKRf;%ni0k(*
zGpAe+yH~br^aS}ZK&a|l<M&O!VkD&X5sfc14WdeX5$`OByjN$zvZC~0udL!yMVz$!
za4b&ntOevYQf-8TGiPI+F!7i&4gvMRnjaPY%hhfG6uumu>Ps3`7B#!#Y{vNJ=?tm}
zi0lwE#(&|!>aKX?bk?%(VXR_ifJ5uf{V>Xe4-Vs3l>QYLM~!>JtTE@!X!_@C1V%d}
zLPAmP5;y~Mc=*cNQm-j96CWGSEUCvKyvlO0&rJpVTGx?lpB&fNHoCHKAgjKRlU`$`
zpEXfg!}6#+4xa6F>{2T0Bgyyu?u;jQ0Eq#ZoEEd=oN^Dax7J-n(f2qR!hJ)LdT^<P
z0^z-(5o>anj67uiineMC{||}ZNI$eBL_Y4`6ux%rxbTpSI>wYkGww$I*B$>>V*K#<
z-R$gMtGPD5(z3#hp+1K1Bm55{%})GAC?QG=lhlzg3&oXYq!Z4DJ&>+4F%j;EgdtKj
zaSTtr73r3{i*iK(J@KIdl*gN==}`8shAB$5QMvvgaVvPxGyMcg=C3ogiYI)gOCmg`
z#GMyLYUZ;aI<3-lMz8G~SJ*TB??f|Ky@+2_{Bm4}^$W*VOZUhjT)2pCy_e!l##xc%
z9_He!dTWz=;OX@dEGka7s;Bxnf+H=z@Ho-I(S{C=Hgs?_{tXU;I<e6QUbXSpU-nfU
z=wr1_nW;?Wo}q+-`5h(&z0<BJPlnMWWCC-NMEIn36T~_^-W>L=*4G&y!_(M1%d2PM
z3@Pk}x!!+8AM+||hOY}%=TLq%J8+V@qdaPp35>l1&1RMBcbAsm<P~BgP&+r@4oS{T
z-Hnqz!jP$_Al(yqx#5=Ti%iKHXbSTA9hx2DPd0M%F%t;=OsvhwJD@Y76J6!GQwI=&
zZKPG^j(FJ6h(q?uf_=irMSC`Brrcw(-OhU4u-Casc>%)!DEq1kCtd0)TfvJDp%31z
z9L;+^aGp}!9o~dQABF8E4%F%k1%XLEa58V~Y#KX)Ea8<lSnaQS^CVKf{3OlZBnzfq
zC!YhGGFA7Olub^r`<mvJKB^1S&^%A7w=^jGrGc3n$+SkeftGs&{rj@;@&~XFL>cB<
zO_U6N7Gjlwga5ozk{iwPF&-m?LHWR^3kBhq@_|!%b35nv6iof9-2K|e_P4)ezI*j%
zaX#?JYOe#P-aqgrn+>U~N^7K#d+Ub_^(8hM0%ERuh@`kS%pzp@z^wzSzj2?{>kK6Q
zZ-b=o4H(3QWv4b7S0u1?;0;=z^E&;0Hy}AqN|os2h@eMj!$@roZ{QxF%5Hiu9X<+I
zBDG8*#D+lVrbIoZ&g6r!dS!48Mq_*sGwQs|Ji6z9+V`aY1ye}dZ>_8Bg#Td$r7ok&
z&d@tPyW)`AGTC^fE+!?h<Q<G3s`zDBybTk2RoEVR!c4Vdmtz~$Hcmh3{;^@Z;`_&<
zt|kUxlU?y$ewujiPm`Z-&&>>HR+yr8#jVt0>>Ew~U-dm3v*N*5T~1c~)o>cvR5ZJl
z#eRLi>!~I%g9KM^9Zpw$h8MG2r7O-*L5!@ZNYBDix<~Jwgt6@mz2WN$fxKiVCsk3J
zYQC<wu8Q}L;WjOQoB-eFr?YsHmRhJAF15$1soF)FRa5a2k8r-?X%(*e9skET{cM>5
zjJqm+!mIw|P~{i=o>&(D3$^_~WdpzRkb$Dk?425D)jBvU=X|zp2=F`3X`GJ@gj>G@
z$;kbf0;k?cf$mqe_y)>fT>Ny62(E#DF81;Zv_&r`@}QTe>S1gK2FY&*eoyn=PI_X|
z4yj=ORH)y1<CDca_XO|C*R)jokL{sKx}EO|84z@a%2`CsJ>g8KhcgJ`=8Bn<jlmXM
zNX7fNYZZo8F-5BdGM?@FjMCktui@QeII|pARymXMd-8>#bg>aoJhdz#pv;HFD`3!N
z2jNt(%e8~Uc=ipBU%iAJQWd|NOLz`Anp|96v!Fa|-v)KvGO|b(czcMqd|*v~8YJi^
zyya2@?bQ)78nZ6XIBb70rhhpOzyvNYRL5rL;QxwOV=ks)7<y1^%rnAv#kra_ls%b>
zm3$Z_R!uP9{UGNp-xFi35$^hR?G3_)gjnkWNAbxX!uAfamVL{>F|Z-Uh%!x1aQ(p~
zIFAL)KIjNw?>u+I(EH1NJtRkH0)_QP{+ZlW9y>ytC#vSN>*I$vJV5^a?04<)QMpgH
zoIN-Gr7y*re(fKdmy%q)iye;tpAki<0iibD(z}f(siVJgGz;U9`-e;{UpTV8XUK*j
zK7U!d<LTEh5KL|fLv3eoCZ5Ny%kCHFA77h$#6_#(|E*8O$~%MAP=b7<65o~f@HPJ1
zgLM=0G5==R#kz3*gv+5r#qve_$%J}Wlq7jp-f65z?VC6YFKI7emR&KHE)FDMnKfa)
z#tr%m9^zh4gL#b~0v*JkaMkx(S&RR8OKZ_h30!>=Fy*+gZ8Y5H)JnL!p#~GvXAAJo
zjyvdz;!gssLrv`ZDv?x^H|tjAsat$?KEl!n!pA4W9j}y!{b*ycAeBX<;!Z+NmvB6(
z4%?HCH4?U?YkA~8GmsuA)@74TG<H-@-1ubImous6)#1$KUh{QQ@nL&or-$unz0|*&
z4W|!Tf!5}Z{0uk_q=F{4JI2|pi-o^Xjp)G<ULgqX4DD3E*E|0(grH?h0tji(WFAZR
z-@WZ6_c{76-s0{qB28W``=n37LG_6`>W0CR^}g5%^rzj4r45YR2f%nI(?wq2&1!|0
zl2!(;-@)|*h1CG0-9W>;g3j(t$WJV8nXVq^uV+BR1c=-zrgB4F`-f1Jk9+*XUj5(c
zi;pPjk5IsAKZyhBYeiHxKL*H0jcb7~jh+MUdX}ED#kVW2KXNY&zGn~ye_9y)@vt1G
z1E{X4mEs}{XEC)piyWC*4Xgrvu}^R+j|YvX2#tpTgua5MJlJc2y*}&Cuc^E}0!bye
z2ZTC907Z|}yWGq{kLExnE8|2kCw=ivI<+l94ZEbzc<ho3tk%ELfhPOv+K7D~USrQ?
zQSQ#qsEee3$L9n>CpVIQCb+(VABdZ_TuR@R!6}U$V{<f(5&3*rrBDwCYV9G$l9!HQ
zjzipF<TpeJ(Q7obq$fAJFyAsQ?0B&pU!dW1`3Pob1Oo7QFW<x#N9^cmy3#m$RFi!r
zR(qyHnr#i}ixKR7&|XVu-b_G?_x$c@B$C_#JR3*XR;xwB86zl`jYshB0>^ANB)rap
zJGmr>aE`55#~ksXI_>rk7r4e)d$!}kXep35n0p}f>qck+t9FpfiD>$|9rU@|<-!}N
z$T{}UqDCe6Lk8Thg<rj94n5dwVqRF}?&brzUai2v_`8q#GEIHXcTU|;1s~#jR~yjn
zTyx_dRH1vb-mMHw6T46TTjMd>gl^~LfAM=^=Je73djHM%J$7gy083Z!fc4w*dYgt+
z*p<>xc7@iMK?;A&56D#%MNjZoe&?<w5?RFCnK<@JR<8v@RCZxxh&<!_{0F*hjoR1s
z2*;xKRlPt&l-wt5g;#Fckq=BS*V*r_4dQ0=ff>A!cSJsLBfpA1w9o+=9xGQ{WWJ>F
z!xH&2#F~7t%?`Dvr=lWHqhp-3dx)tsPfVCy`DYb^dAQt>1zsXu%ScVbG(F9$u(xH4
z#w^NMjM-KSAIL;STcFIh^fbF-HBUC;!@QHkVVl<Y6C396wU40BnPujDk@vNQE7z25
z9^1azm|C{Heh>LYkfJ{p?+I00GbC}-5x)3nyW)Je+QI>4WCs#~<b$fszo^3bjd6st
zWLO&)B&Sv*M_w;-=3WMHzBod4BPz$iSeo5AJ-ZzUvmY<%Myb^fGm0JsB~)dHTpZWJ
zqV7l@@9Ugg4%Mmn)>6ZGwL8Z#Wm%*tz(ZTQ6VBXR?OFRytF}_hlw(&cI}B!TyVfYx
z_r-7Ra_=(TF||f}Z*tQps@%E6trCWy*Ll=@*VJb>S2|aX(Jo|BPgAc`N55A4<F&Na
z1A%nUK4_anlMnJ}@?RGS^INtEdQ6TO=v~e)|3XJ^0DevdXOT1f+yKemYQU*QShQ^Q
zxZF^0Vu|G|q4bV(r>WIl%c^o;pSd0W?>f`r!YO{XJDbVZ7mJadU)bP`5*nC2=KTIC
z4CY?)w>9Uj>LFNp0wj1M!ck%;edyrb&rUQ5HY}POxqd#wD70p4>yB_l5Jzw!GeR&#
zyW*dR7!Eu3DZA=qx0(X>jeImbzGWQMn6S^un_a+PQy!e@jMCQ__%&ht?7-{#5FXi8
zKT%cVD^2kWN{j1|Nni=L`2VP5T)0I!2`hQxx2YBdBNomQq+Jw-i$uTeeB&{2m=C}^
z=VoYZZjP53T;q3cD#@I!%qco%{u=jpi0eMXp{o5>b+(zWi5N4vk`A&%O|CBP_><XT
z-pbP${EJ!`MJ06R>6$X%9nE>?2-px2<i#Fd44A}g=2P;=Udg|m*iSyaODluuUEL5>
z{j<>t(}&b5&UoJXWZ}@&6Vz2)ygoRb0uf8BZVEYrFN|K02k|ZuphAMmiJLLQuDG3s
z2eRr#S%akA1!2PJ6f4+k8F|9#Y_~;uLJhgDJb_3{YAds3wHwxvHNcE^{6Xz+)UrWv
z+avI)6ykOL<S%UFK6YtkIOBCSRZl*Sh7(mh(rd?=I#Z_VbgIF;Ra{BzImRa6ySUGt
zVLq62z4>6{Op~~AjuP>KZ1PUH^cIoX`&PTXSi?itYUzdaj{1vces0=L|6J6YjCLMk
zE9jT$JGM@$n26#$^aqP);%eY&!L*T5<<7T1L(g!INKz~O6`si0L2v`=W9rOR6AnOD
z3ig`sb+S&isaA8yPTk}F<eZ&aVSbv;2YZx^a&(ErE0QtU$(t&Dv6I8en>cTeAZ|R{
zmC4Tsny_Fn2NpC+=F`9wQi%IolCF01fm4)XPlpTVZlB!%60fXP)9ID<Jc{67>4JZy
z3;w{%V+H<|rQj!&jQMT=+=+hR0<({Y2k>f&=}&TgeZfsD9xkL;s(8M;Ad;|BAJ^xe
zEW(3{0a^*9T=?w;sf}(C7rZ)wS*^dORdWhMC@cULgcQfVXBsi#?TEL|o7rB9v(@?&
zb=Nis>xCY*l832h1;AlFl%FxK(CzrV|En&iOhibxxB0*#v_WQ8jg0jM-n8Y2CJf*Q
z!v6wZ83dD>K{Mi!_~GU@&a{&xWO;A5*EC>o5$A1E2Ek<6>k_MEs=5|wt#Kbh^UKEm
zET<1=(@WHlsYuR-LZwqBXaO9B1S(r3sRkujUstI#X0eoUj(c8A`M%GygZXK1OD&Ab
zMG<%70@KY1%;2s&QG+|SWN-pNJ`f;fUraPz-zWe4VcUEE1hx0eUH!mx+q;jH|3!PH
zv!?Os-Hb0|+B>JDJ$LfX{D0Km(Wbp^ef{He+xs0UAANkdb7ml}#{>Ox4nAgI)s*tT
z%@-m$L=G<V`@*T-_5%w<K{G~0Bz!s)%e(kA8SJ>SP!!sh-aZqyfnAwywsS1)5ogIY
zCcX<+qXP`XVl>pWaj*a_?~DsAIq;x90VOymtf!y)OX$=6efHJDXJGPx^QAgn$Ek9L
zIaL~_H9kydI5CoT9I585?|2|JOaDgR3^>Uz9ev^cLA?M_FTt06^C&vn3(K2-mJo9x
z97@M3{_6{V+(<v`o_IM_wBXtiFrU14$&6dFeUb{qQQS?fd{75-34!gy4(6<#sdy{K
zUG|Ym<fgY+-=fS=hp~QcB~%CQ=Nr?Hc_#eaqXx#Ku!XGUcs2zCCH$ltox5G}L}i(8
z5>^uDSj*9z_@uf(bMXMFR%$H?jd!d~@VKMmXC$F;(8Cu;2uGkfdx^`B0Z_y7nUjVr
zdD8zMbMGD>RdqG|XGj78L(jxIHnv`(jha*+4c1Gd2pP!08JJPLplHQXFDYJHG0Y%Z
z(Sb=cr{l4-h1NbTExkUreOl>7#0#1LCIPDkts1bFpcc<`yacHbP?+C$?S1AJg0}Db
z`{T_A=A5(dm$lYjd+oK?@_XB_sBCJ#^(e<nZK?AMlZVhB3|dG@pc5nyT8&<R`>e`9
z`@ExIN2g0giP8`cNE?zB$HQhfQ97A`0v4((HiwoKiHY?}1szz1-RE42?OQm#4@PnR
zF{_US=3K@??AI?QEqqe?vO0DuH+uZDLWreJqY1%2GIuK(Kc4zXF{7-@kL2H;Sw%Zn
z1}(N$zPnj8rMc2nCZdRm$m3I478sgqst7AROQmdNuqS!pT`L8xoJLMi8Kbh)b@EF^
zx&}-Ns2U{SF*+Z-S-|Vo@`d?_tmP+QKdB09*}6m3LSH=2f#ZvcZX9)mNZSS0vQ?J;
zvanFbjU}Og#df}<%ULPqtj;S(6XYQRLFc*?G=@~k%9w{Ga+BT_4O^Yb30(0Xf<JQq
zMDNVz3KGqc%LWNg466X=iWaUq067Os7G>eYZJ?I#RCcBQH4GDTv=eLCfAX+vIGdaH
zu9!)yrX~zCF%_`FzJl%hfL*7XB`=Yg?%zH2@K_Y(8sD|Z6a2!4x`lF$^LGpw{M|lB
zcoDu=m<b5h)Ur@wUL`K;ZC{<rBNM9|0`u7>J_Nf0qu6Xm(YRbBFePU=ePjgpfG=Bi
z2+%t2^(*-TQa`E2Myqs^s>f&>CmU8JQIkkt7wNR54(YbkQ6cfR?@uZ`*JNwG(rV2=
zkM$&`dG~ZuENCvhQ12y%z8AB)%r$e|6Wcqc<qTtWXOmqLn_`!AU{$)@e^bYGeruz@
zrjsivC?<`)l)G3s_$l!>TY-<%NCo6B?Xu3+jVK5<wQh`7lCp<A{uflr)gcqd(xv-2
z)Ou7QMs26*aYU`g6x$fe-*jfgH~-PYH5F%Poff2V%*z4pxDLwt6=f*~BrA_&W!Tt}
zED2bfaO-G@m!}a;?U$Bf;kbu;rp9gC(BiB~aZ6Db5OoXqr2Nv(Tz(E_J~a3ANh4`#
zNNfj`7IT3jV<wmeJCk#*&4=hhc>nz|L*ZQ^g8-%m&UAl%X5P`<<{(`yXyD8JXAR9i
zliL7G1?DoFQb8_6Ru`iU#d&F9Wypp$#XF9`;>gMn!fod6K_G@#N8gAny&XS>>O!Oy
zfYfo>#x9-0W(~Mh$CYZfGAGaa(6fW3y+^_!RI8lYFUUOUqsyVoVV*ufVv_gQ0(;R4
zd6Yz_f}xGGlaHTpAe|VkX19mEF+f%zul08(OZ>x3ZhWuNWNo~yKXsa$`G-35C#4r~
z7&?{ptgZP|x$v|s;N|Qq%}_i|(0U=$52I}~*rxhowAJ$(N*tw~3p2!LQDg|!`NbbP
zj8n@EPaPq1^yKs_?x}zI>927iV2it-57|>cGOZqS&kjuJA9lk!FTx7zncDR?tp5gC
zI-O59-867rQ|&I}kykak8DH;c_8S{YuJAM)cQu{QBzBvN_ul=z2bi$Ux2@tb!srF3
zSiKm+Hy-J@p+lEaaZ}HA+%S7&6J?YKn<rVJ(tify9a!047sf+&DeM<Mwq7?t*`|v;
zliHg~Q;3$7r{oYe^kvNAop0yhUt=oQ8Wg4`e<Gced4LWT({paHWzHvrXvDW0!A_@y
zyMW~tO%Q<(<z$-)3|XDGZA(qa<lMqh2ssP!`xEo435|DtG;~t0WnZl)RW;N3`KfwR
zXA~|-TE63&&S{i6ZUndog;Rok>kj;jt`#lb7vp#SnD&|fdR!=M>T6bS^~Ca+wYf7n
za`8UdHqH0OHg>d!|J5G&K)EwWO^e}Dbz{tri&^NW=J0Ow`C~o(+{^w~d-#L)!0yKd
zhf)}l5}$27vCe-U9@{iPC8YSEJ-oX;u;+1E*g}a3EOsn-U-gC?cA(LVLfCV`+UJ7B
z1|~X8Ya8DOSTp`5w-p{=PX^ChLF;ZWk@HUymJw8j)ZT@#0#ODBxKj@of>Anm23Rgv
zVJ(lC`VbXwZK=yO6*T1h#T}$7Wuptap36->wayP?Vo2==%*?oEgk{|U_W0RxJ*<7^
zM;fA1^9~-^3N^4FwFma=WiJ&PZe)*iNA{!k@c#C|0l!+zQpXP++K(98{q5lc7&>w}
z03_q~%#WPNR=6Ytb0@2@(qlG|8?yoD(-i{aj3W|h28^^Q%+YZZ=H{UDrObY!F+Ydi
zP7I;%|L>0vXC$z(3%y0rZ-{p%5ChB**2RREV&u-<!pNyLT}2(=DHocQ#<85u;;}R&
z3^jMT%yc7nTo_^&88{gQmIXt+$`DwWAr@0|9KPfYF}(X9ZbeVwM}YUi`g!@|t?FT7
zWbf9z)Ro!0`@4T<KCl!Qf4g2FwyqmppB$Ki{w3-JHWk%Ss&P9*01gKNI{>ee_CV>A
z!Um=;$UvXp+RVC?Ap(HvMu<STgv6!ofss!tDgdbBjtz>Dp#nsQOGz@aJuvD?#ovm(
z2u^jr>@{oq%!aPpPBar2mSGowX((Y^>U2ECczbr4)|b6Zfwm08{&ncRCVi)Cz`0fA
z!jzU;lLwQ+uh_mF({YS&5i9dw^mo@ZzWurH?@9c)-1lYjeSGfw$?N&9kZ<8X>(pQh
zr=!d+aL#&JpIjGZyLvFcaG4ChUTkxOxR;G8?V8!=*IZ3sn8ObNBiKKGm6;d^zbF^W
z_iRNNFrcjfb~>>?0jisKh+aBrM2YFvGO^6H>Mc5+HGKISzSMSM#+QH?7ha?hLg;2l
zKIdMRVrg!bq{tgAUXwq3D4oBB$?m;7fPgGh)*XO5l;h7Uss@7TV&ne*B{pPVRFx=2
zH7R#U7)q3{3&tO9B$gJ2>Eg_RXicK@>ik4({IOrNq@FZEPF@71t_e1DM7|obW>@jQ
zuUntAbp^_W${&7>;^kH{nj#-(Ul&-FmGg-uLT+P<D%u~>C|1Oe@<h+UajFn1WVN$Q
z`#Vx2XD~tAYLvR|OGGYHIt^XFP@;4?Cv2uw5ll?46xE)Q!Net1DJ0rsuNkC%^d-5O
zF!on-5LJj6x+`$Hrz>!p$N9@-<_INe93IvoA*wgLxQD6@tde=I4Xk7ks`%d_f(rik
zbOruPbYNCG%a~g}0ALa%W>z{sm&xu9R8csAQs6w8mb)s8B3B?<uM*lmgYHp^D3D{s
z5^gt7m9A2R`-He^bR=0+IYgE2_J2qZmDzbz>E_E<_moOCq)NI$C8CIDN!d{cGW4lv
z1^uM2r!fzV=Su8_YB&`2ud-;V^W;ncEPeIY<x7T_uMXK>8>^$I8LMX_Z-J~Pilns2
z8I8NUJkj&S1~rF-G60P=sv10KA?ZQ4%sGw*XgJoJas}My(gw*Id79IC)J4#(Pb{eC
zV0`<VNMcdQ!IYTXcb$aXiNd2lPd#zadY9R<gEE=J)GAfC08*dx%B8s(S7?+`uxeyL
zl{|My|MaXbs*ElAuc8Qc?9Q4gZQ<Y)4`KNo$k6wL>krpEb$^lh61me%cGRVB$)z8c
zQ2~uJ=V`;%&+ha6X9{xvx-d7!a9Rb@4%vPIE-mjCJu47I=~-1ecN$=s?B=`ud7$HW
zLC0U?A_jn%)gUV%I2<-9HV#uH$rxxngd7dE-_b5j%x(=UgwH=cBOMh&pt~@04Yag_
z?_T%2kMI6R6{}k^ZX=6{B{~D5C?G30lvHkOd+KDlzFu^VjMfKKMT;H`CC<9&bqPQJ
zVjd}<N{!Uyucv1dM{YsOgG)P4W4Pzc5;N<gy=1Obh$mcpw2Ol?jcPb(e+4|Q(h)U<
z5y8%X;GO;LV0?UaQDj*#aaHw@ocg%`V{|qO&UZ8Gz6fr$(AGIR*KVWr=d_Ow&fBg!
zcq@-o^-z3u^Syc6u>BoRf4ilh!T1xo{(gB#tIhb`y1!rkKkM&Mqi}f;lpgy}4s)WP
zL8<#CIo07$PTRNeK7NGgpkm94chpd~GJnXkGpIF37V$a2h~68CU|zUD?(v%l=!LxA
zE#$<sZ>@Yv$~9}d@ixCS?VHpuSfa=#8a(6WE8gW5(^B!YCo)ZRPoT#RrS*%LjCV>E
zCQzLy!hMGOg*MOb2anjrXf<b&E$WS|R)>i#KQt3x8cZ!G9;sh_QKTyEdv=>!Dg5LB
zxHLyoSGx5$F+xJz5O{a_%gTceqDME*QRu4JQjO5iQ_Mwy(9T1LAvsAzd%3wy1A7WI
zAcK4Uo;ptTKhqR-axh-L;_K1ecrLQpOw1oN6Xyw6$M|8%d?!7P-wlHQjR%LyohGWU
zsmDL5eQv)o-TBhr^ZK3kJ;!H0y;SEDIsTT}ba!OWFo{`;J-x~~@j}W;Os}JbvJ|{b
zIqp(`&Jfg;MIJ`WdG2aS#;n8J(SySj%`bH>pP_;WohOBADl-&*y%tp{9cPy{O@517
zq<QtsPJzB{RyF5FS|CuyKqzp?)bN3uQxw&P+kYu0z6J)4{P3G+(+;U9lYHoW7uLs|
z<Sm`(kh65Yd4X=KE+L0dYX7Ep3)#_(<LGV{1B#wbN900<CW0cv=<etA_6H&-X<$Zg
zA8lt}`D^Y(0yQ#1SI-7^(`ehM@fx~*W%fTZTC_g5@C>>O&wx`rTFXCVTa;^l4!?)6
z+_1_r!}OxktR280v!FCW9B_9CeqTeQa`=6fd=0_xzC8Ty{rB*jWQ+O^#&3p#jcDWq
zGf|iJC11@}EJNf9b{M8UB4n5{qMnb(?->fhRJp=8(PhfE^U6;9?sW^y9A<nhK2jdb
z`>^!l?oo<f^l5t0J3PHOyrAlG`T9@kMgIJ{pmB3`RmRw0tU=B%I1nk__BNDWpLQO{
zDln22AbaYGUa{IkGoHQ7sk45aI`-)6n&R=KUdYxkocto;$tYr|;zUA%w1CZpSY1<3
z2Dx$A%Pewh!$pcb?pqMz!!5blPWwLK3%@6sFeNomvKX4Xh0r1VSq48EHL=R!h|qF{
zBhDM8q8YF}zeMhV@F|d#LmIgsl(Bd$Y=Yo=rM}j9MJBJh)_4hDX<r~0CNNqBwW5XR
z5bBPg8b1h?%#T|f()$azC3%fxjo$^hOF$+5Z*>5i0W9SOY;L4kl-59awvlqHgcC-!
zvNNUra=og@JIhHq3Si34oPNoxfA>0%f{Km*%tFP{6yeE-icFnrIYFnr&hI+pxf6JL
zsml*wJpVD{)4;K-ODLGnFUptV>j2CJHEG{xbJ2N2RZggMPDW1XR-QZ|!-~j46qrS6
zxrNB97NRlatDBwN7}P}|Y-nDp*LQb!U#IZ>pvC0@Hv<-FGxTwY$)%iHF4u3$Tm}gH
zuwr-TI-&YshT0dk&o<z0`r&Gz$!K>8zm(%@lsXw9E=NO>Mg8pQ3>b={EbObRFTV84
z?#PAZ&gfqG>YgHdc=|k2syn~2Y8&^8xG+h_%}Ut2gz0rJ7DX9`PR4hPfR9f8DK$J0
z_?^z*rVy$`!xzy;#mAY_cDKQ_D$9oH2D2P$7A)6Dy<%ONX{6$FF6B#hwkv6*yR+qb
zi?l!nL-*8ZJs+V+H@6r0>k7QhPNj7GR{%bX+bV2M6dTEfIq9jsG}-}M&IW|dM+w%X
zN!KU6*PF~1Oi*T}6+`ep!^BqQ_NPomZkfc9fZCrGIe+uW{tN=q-KYmRw-5W+`#|AJ
zr(-SMlc7^4^GnBypfo>sOuBgxf2sD%>^GMb=6)V(l$ZOH`;(a|QHqv}D#G@pn`FQ_
zPiD91T&zsA<r+kh5<TqxSB*g4_+;3KBIgMhMum@=Nj*e<)b?@l;LHvbCeJ$$%x)!Q
zS%`OPhH?>-f;>FVuzMo~O68<N9U0C=d8Bav?c#Ie@c7&laB0Zw^@aFPdc-nEQJm_M
z5SStR!3<@7UKUT+NK<4&$i9n@6X(7td%XX;fk(>g$`f$XTqV5yXM^#(2a6&D!NhU?
z^j|al5ys+EubJ_Q-118MYRTtDKm`h~YD26KCt8|Sco!p&UJKJbR8{F#7LLs?6qc(N
zi46n_#g_%kXqz&aPHQeu=&9b?K~4ogyEvKw56kNm9*R()$Hl|m93J+8hwK7ob~tx#
zP<Y6`4=Vf<Kt79tne`=ay>z7yh&8*++Lv2S$rvEwhNf`KxE9A;tA&Zs0q1ZIR!!?R
zui$`?e$G_?FiT9sI%ANX>ayimT?H91I(?seldG+ptlkr8!&7_u=BcghNCK0=)p;2{
zW_|j>=Ipq!K7Cid)cRD(@(%sHqaZq>qh+@V`D;x3zLblW*>qR>FrhMundPg{KCQcg
z#cr>Z9l5My?`+Q92NpaK?P4aZ^+!TF0Kv3x7c!bWs1ZA^0LwpgsF{`vY<(`5)$ejy
z2koU<lY~EY3Hd;Fwb56Gzn!araY*o$_Tj@&*9xcA$9)_135O`agv~J_Rm!5Qi(eTg
zNy*Q3WiB<zZJt{`VpHa;E-d&MKC|PMJAceCPnJxE{b+^jiFpi3|MR&aN&B|)l`Y~g
zfU<uELgyL=P#~VOcEekG89^8V6?|7kHwpvRD0*?CK5>WF+PkM4T|#P+XHi-7Q;Rq9
z9NpYK<%q+JQX|!uM}A{P*azp@pzRyeFUQwI?Fss=&Y|buV^K~KPeGtT$9(itN@}^d
zoYR6qx8#4=Zf6t{cA{JI)>uI@%=kh6Ts|m+0R{AG@!R#_YDV7I++^JSyOlIsUVgdM
zeOVE6UuMpe@bDb@4a{gZ?q1Z$Pqa=ON)(S34V#QOIENy`b0`LkH0?_;xxG4cEIMYr
z^_@oBmxxmV2jnZ5`PwgEs915pG5Mp(9Qu!x0I{cNT35m5D%Uq+H&|Tt+*c*;R91P6
zHaW3{GeEK;?0Epw_cK_DXF_4|2^5Fox4xiKMEj=M<wtU^XvDozW@2_PH^<gs2)qZg
zUFfw`g=?SVK4A?_!yLZx^JnHy2{oYMvez`GJ|DKru^sbVc0CO?bj?5i0=xR`V8dUH
z`0q-&ZfQ4r&?7qai&M`%bzIom5&2uF_CUz9BUNmAy2hoYaxOhmf6I@PN0-Rx>@^#n
zH{xS?mx;y5T6`ttgzWNhL1|?xALu@udDzr*&n%0)XclvmDY2*~^>FkOxxFc-srwx7
zFN(Mqf&x`nQXDxkbO%EAbOWR8^Ti;3o_tE~VoHv`BaM^`q|0Sgl%aOBVb_9fVn4D?
zm$2V0p=A@JQfaL2XcpxWV@}8W#=H);Nb?3bzv&zrIM}2vlP+2X--=wA3wzeg8aaD0
z?a33lYK>^P%7~w#=J%$%!*+Fj5H_2upo*W^HOaW8Wa6$V#x2)P^vdJXiB<AwnplVC
zYuB#H#x0@oy}PCwx7<9wUmjPDACO1+c%q+gHeT%k9$)DUpdx$&UEw3LLw??C4j8Y#
z&Ce@OH%p{|ZRBP7*(NbtC1$;fxmp6d<mY*b>5-UD6>}A~6;Ee@Zlo9U@4y!j4ql*L
z7|I1CF?%LTXQ4j>(^gmNo}hiXSHc4T={W>8l?_OEJK+k1CH%Nt_%{i!%cLKb4bQ8w
z<^I%2dc;5h-IXEFptNE>t%!b|4gPTiR)y^9Q6c+ltMcaC9Z!Z$jZoJ?qx2cdoMxAt
zC#9W8=e(2{*_iq)MhD$4-To)lB{xyatL7<D*cz-%#ybXfF*E1D3WuwBD@Ub>ksC4(
zM(f#vX7Mgr;{l5IrROJ7rXG=`9Am^5ZDJu<3_%Bb*H9c7JX1{Fij`HPH9(Reo+9E>
z5*`OU9fm!Q*JO$xQuke8pIQ-Yc*%%QP(_4$1&zUIib5i6MJt2$tx&*d&4u>(vJ36%
z!?1Ja;qvlxWK`H_?Nr(CgSJ6&&a45!szCic^ZOW{p!Mu@`^<41na{80rPgeC*@*X1
zHA#=g^kvio#7{o==+lGN2a%Ujzcm{IHAZ|12|`pGwofe!rk}<7IdssBzw2o^DQJ&B
z)@*pih|4}3GIQtW(*ASrJO=u<EApCI9Ii}$1-QZvt3S5GgRNAfCR%6I;E@534Kw%&
z&*5k0Jbn~4=BdatPerfUHVGXU4m*3t)M$H(zA=c=QUSwXO`+)?sLG3h))y9*2CU7g
zEBRrmISyUNh{qG(fil6q{+2UIc&TSZ=Z=x+M^5yQe%~MaaG>R6La*`^lYErFbNk``
z&ew^4V`5<Ri-FNwQeMJF`bY0fNo09o^k#a3s&w0FbZQL^EAlVi8{^S(?3xk!OEjQb
zyabDVFs+QsHS(aRBXR;wp8q*D=ZlVHG5!$>?Mm4*h!>HEeu~ogKLs*cUtqsO%S+JS
zHLR!k7~h|Kk_T1e+QDf3Bk!z?*H0yTA`CrR=lFgJ@L;U8VH1RX6OjvvbkYz~<xe6L
zdX0o8CDbmRz<bEr=xo)WpOMli=@~vnk0QO1G@q69j}oGm*h2lyySR3hS$Xv{dp-j4
zi^@NCT-EW1RvBwK`Y9P9ts>T9@ML_RDj~>>Z)0Wi1ZxM-{|_~E-{zBJIakqaqQCu!
zqU3KS*-+(;XZ&*KR!m$we-IoLGZtIq0%k6IOQ-0YxY{Is>ji)3KQlTihCjBcBS7JS
z_E3>074pY`iP$Ez)L!&=rZNgDNBCpU^at9HCe@`y9!WYvG^ySo=`*f+iZn3LewD;t
zS~NnEusZHBt=qNcNu9epL_gxZ#|wsR2){Cy;mPnT+(GIGx|ry6*kUX2GI(ny4(H6$
zXk|{AI9s+NVh=c&xUwc>E$`(sn3z<j0LrwLNx>inAG*(wWNQ%}Ve}G?67fOn`J^?m
zgexW3lWMRy)-U0x8n{-fAb^v+D9%=)V^W6i6}SpjA1aB#J$**(9g@Rbd)eYw?t*2i
zVoe0AF;G+?z8s?_3f|aQM|GhhFe{iiDh#_Gw!eaY2CR#)O5A=_wObFblD1eY9#oHq
zS4v#s`Z?%kKB8Eh_<_TW_|FIp+E-P3f;Vlb58G#s3hIMW7J1{IEs`@4Xmkyfda>kG
zg}u=_jNs)PD8)J@36&~^vQwGFt_A}(hA}JK<(K{jb$_STNQYUP+|DlkG?M^>(D81w
zY24Knw7OFlaA(h92ttX6rO;q}0)o$=vgbBugLEgO7;z<ELA7x@0{LeyifzM0zT8p8
zA`EU^yd~%G6FLW#4_i-%YA0bH{s+a7ACdf)oP!m7nMqs|NJ4_b5*{c@{<pex`n-RQ
zcxUCh>y4FcM`YFcBN1kIY!0oJKa<=3uGFl#J0=4ycIN`wu`?=SaxiODv@cYTrR_YR
zHI1g#{(!t%+^d*ZCXKE(DjK~>L&{GCW|{WGHN;~=qcj7e)}nbv{7otiS?^(tb)~Al
z?Lm2Tx2@t)BCi@?O?&xDzMStI!Gd_D6lC8k4KZ(erk+JEWHBjw!nJROZ|bfWGaQ3I
zkSWczn^C|mj<!jASycuq%%O9SR|~WA^-|Nb&+L4I$A`hrw>WX!f+tWsJ2*e1)HGh%
z-Yg~OgH%7=Dmj@~0oCbN)5&G-_)o^N=E>e>zokGmS%QjC#Lo!Gf<<Q;gptv?!*&@i
zcxab@@@cVq`DO~urQwH3^7x+^Cg=6!Ow|orkJ36U9NKe84U@XpOq|_hJo0;)dywrl
z!K{!yeq>M|$%ks+STN7D?~%a|+Y!OM=hO_`w4Q<A=iL3kK?6UEfxl4T5S~z><5X6F
z9MW+UEi>xx<M6ID=-JKK!}JUPUPo~$k_#43ts63<mqUeg$te8g7wAtvoi|C-tdf)5
zNt$Lgox~&s`X@0%CwZHjEY(lR%^*VVgc@SWcLu%VOHi3FK@PqK_18R^#KbSlc$kS5
zUL98{kJ`2vNkDS8szGbN5j$**%=gz8VuZ9tC0C|fAr1lvkcvjhRikUGu~juS%cXpr
z#qvKq0Ojo`ffSqkHa{7C9NpebD{Nae+v^c(V0dxiQQNjsQr9Z$(->9m;49l$e<Q_q
znA(nPrZKD~d$t;}nWOU?rV6Rih194*3L6&apr)m?H=I~2t%r(3u{(Hk$+*$_W8e}n
zTH6aanU>pC=@gx-nF*}7%_6x`F{8?;;Pzq#T5!)9ZE08~ZgsCA3Rv6|FdlhG;1R>L
zhZ#$L4De#~Gh@HmQWim*<LT1*Cqp=v($zx35hKL89c}K^<?i@J>iltWCUUJTtU5~}
z`lu{Z$b!+;<d;7-RTZh+`K6yLR5R@bphZ_bJLa0;;thf-%?;a(_@gu=Xe*Z_rpB6}
zwJlt`M-#2royp4?39k!$8XUX|902o@YJRX(#4i?H0oWL&V(_}UuF2X1k(y>7ak{m$
zb9*UfhH-x5@9Zyib}gfO8Zk(DzP!ua$h%M~nK+7TI^S#BM|>a)L&)<_cJ3d@Z48R>
zcfM6DE|CA1Vp6m7t2|UA3vJ87)6)vztXEYUDy0FoZa}CszX7FQdpZh>leyKpT&8@w
zwd{j_+5iEyWjyia6(7x>$J)|VyEEMx-(DO!{Q|p0r3rf+44x&*@pJI&Ipl4!k2tb9
zV0~M`8&+r=Hb=K(R4r7y%Zz`BeY{SrIWG++?$iC%d77<1NOB34YC}5IzRc6C%aI5*
zCYgv4c@g4+I-8@|jbI~K!cHpsz2rq=Jz9fUA<b1F_J$!;^y_<FECkMfr2&ZD7OGz%
z>y2<e=}j5;{87P>BEK#Sg<Q&8`rSiAPXP&bL1!u}!+R#6gA>&WoN{3y3*gy_D^&$N
ztG|;6JSE&e$-vHp{HdGZCHHP~@j3w?JS)CyF7A|};#%Bmw6w^%g<?`Dmu4$H6zt>?
z^N{6Wrzi(Gco@h6&dB`QM|%Bsh$YBws?LL*cU{=IUxt!dFyhFzivqQ8`_miz@i&Vj
zXH2(`prPv|o$~J&N|bC0TdOqulz$5NY1i=68Ep8Azz<v64~tt`GUq7(#BPNz)*mEK
z4t{oP_)(z+@UvUPj~kH(Kf5*jxDf}z4+AGF)BhEvFI;`t$_b@kd?eSYlg*5PEQc9#
zY*Z{)t6YVxmc9zT9%@p7JETfF3lUc>vh)gQsTB|_8ES#E^a6)D6qQmfaCBiMU!g?3
zV)Ad2Nl7d$^RKCgOv8$9;|vg16m`diM(Z^an`1|tH4iEnrZ`t=JdW|wFs?yT2CeU_
z@%MM%EAu4<+fo-Q)~3Z-3D&XO&L*O{dx^k;GNG&&dd*0CmE$s_Vu_GwqvD$j)#E$u
zQiN-d+gkDfUm@!R)4DPPdPc=0Z^-(i%yrQEp4)<Zqy-$Le1_G+Z_flM^&)`mk6npg
z1ezM&GvXU)XO?@_ypxrJJ_#OM%X?I9uRG^_>(JQzNoxTpIniAU@T}Jtl(pck`&FMb
zDK42v_d2MFrC?&FSF#jL6m;H`LuXzUI>QYY3p@5xN=c|Trmmuhm@c9k#%%ai>th#$
za=5n4dN3-#6{BcH0ED*JQ2uo5zCAM1EC%1tECvrTgiTgbtp?%R57dHip<S{kxEO1r
z0#tfIcvPn55DNmVL~+ZFAo3oK$SQ3PkyVu;ONAC7@*a)IZbTj;@6m|tMidWS2n4+0
z_*T*)GmQ$t8Ua`SVnI0!2R;Cs0$G;a!*4(kW0#(EE=MzGk=AL2K~U~n;Eh&ENqT$C
zo_Zd(iv)DEc|hrs^Og<ey%H`-Mv>AUIR}x=>u`~&fKDa&=X6S{GffS6q`Ih{R8L5%
z<8oOC$Vx+wA?~p{X~>7L1XwxA&_nlpe0cjN@wE@q0QSLY-&GGwo7n@0^qwj0yI4Z(
zu-8fcEvI~#C(t`CMpp8CtUVI}YUe=;03>A)L><El%<XF1CKYoYRCqevy!2zsi?5aP
zRD1vT&r-K;ub@lX_cIC6`zGh?Lo~VZW80hdU6xm>G&k)NdAgj&4QXfIdB&mp&oq2e
ze*^%EqNioreb=juR9-K;{xr0gPZ08d+MfK9Z$7BxYb3<R{UbBBd+YF1{_*37g3LT-
z_+bI6Xf4;4@H;5D5J8ag5!_Ku#<E+!1h#A{LiXeWM8^7D4$3}u{9<br6yYi-zG$wf
z^JHL54pkGm3eh=g<LlsILj+nN&&%r1cWb@kp!FBb@ir=H49Ez1K$t(NF@7$><hdX+
zN3H0{A|4ZaEN0?LgqSUr#v}JCMp3w%x%3|C1fCYqFUFw9BYbnD(ruOs9gqbe-apD{
z{UyP8TvO-8i89k(tYXva!idY?MIaci-7J?9;~$n8@dRm;-TbJ^6C(1PR=InG$2C%q
z(Gb}aNu$=OME44%RXuRj_gO7}kQM)|`8>ow4;RWZR~7JT$^mj*Ww5r9C%RoZxselP
z#({fL9hf|34~^K}Xx&J0v`Vzk^UizB#8bNQ9U<;aaXQ!;swKl<Sqt8PnxxhDO1znf
z{o4=CUc@^GqwDA-wNmZwaj)i$^O6Tdx^7*MB<Qawv@BgE6`b{L9!o=sr=&lMzxl2V
zKzcpf)<=XRK$#^AkuM{rY7U&IghKN<D8W<S^@EvdYYVF4_ogmkF5HP|nd<5vLD2q#
zzO<`eyAv#3ddjq>VKrASCkZbzsWNPhuMTp~To$$>)!x)hxr{d7v^JUX*GENKG6SBY
zKf3Z@n(<yI<Gm?VyDk+rtq-yL&0_5K5aFdbR1S8RR7*t=G|^el;hCD%LBQ)Ox|&?h
zk7;!$mHInXb45SCx6D}bdv<z!6wdem>3ptZK9g5bV%oRu_t}OHrhQxF%N~2eSuA(Y
zep6O6zMACgDZaQoTTuV->(7mK8GG!7{(#%1^O^fZE|zPr@LBomKk-eY@Z~(fMa&=P
zc-~NAVu(xZ2on^Fvj;Tyyl8sX!vJaN0s=YsmQfD~pkb>5S!?Skp#i+yH)^4NSvIPj
z7o;`4h>?)e1XhWE9vH!3qI^^^ap@=#(Kd~eTZAh?`EtbcgQ8oL5mG4Os*>+<L<$qA
zXv|G7Bk5Zwe5!LtE6qk&7xo+wNvS$VRR`{0A%gwW{|I$ba{d~sub~+gBelm8C4KGZ
z0-ziVtTZa7n94wmb=NGy<{;@C;91X;_DpFESzn)vKzg2nr(td=<?%avs2O1!KFY`5
zS10CQ4kMG;s^02+bdOAMzJ9==*Hg&+Kv9HSA`hWLr2t!WEz-UR<&(2rXX0N4n!cSE
z>!f|(<a1ckuMWTp=>OukWp9-SA9Fwi#McnW=R%2dkpZZ|%kGb!!YzdYm7QwByYoOL
zocMYkoTOYhv3{bK2Dv(x1Cz#&2a`I$qzYhQU!(TkhX#`wfQf0uF@?lvM`yV^nK0+W
zrv0s<U~<Wl0x;ofqN|s2E)jr<lIj5mUN)drfC<guXh=b<GN0WDAIIiY;6&-Wn0%wC
z6`&D;0pk(XQM5o<(myOW;_wzl;o7&uc<^i+kTFK-WO1huLpJ>Hxf_0j8^zA!i;0y}
z2~5h2+qhIHU&9tNzL_<v^%cnwwAKhk2j`Xw6*n8U&Mzg&f|pF}9Glh!a)vbk@HX;X
zMdLM$*UauWDz2`R^Cj0k557P(Tw8a|1)k@@>C5a7A&ZM<0krS^mmIrdkFcBsC|OJe
zo>OKXt9~S7hN`rr{Vi$p0sM24_GpQOid`TD*`>GeP#RrM*izvCZ^OT-;s4iConn3i
zGk|~j6mDwb=Hb}3e}`WFCMJ_2IP}9;hArdY*-xZ>N9HwbR@!Iqd1%xd4*zNdkuvl-
zachn7$UTBFNH$i|K=eySa6$t-T~1&qaRWA*9$BkU$~q9Nec4zd;U;EeNem1>EK!^!
zD9K&OzF%-aoao-Pt{$^1IA~JDlap2{T#I^@#5!bcaxUV=kQ_}TdgGAZmD_T1?bH(y
zw(s(UYFP_cEF~xM(KPOLjkcYzUWnHpAS}pf7lPj!KwD}J-SifObA?)d<jktydGRjU
zDDUG)3(>AR%HmXI(0PJj5m5V~;FDPg&O*t<8#+r?1J(>~)F+n5q<A?5z1SO)o>0UE
ziTgaV=%98oV-kywN9yF|K94Lqye#vy^TMLjNFjpCRpG>arIJO6PpKrAHL5hTMwLo(
zPGWRP7g)M@0(3#V=%P7H#Cut&g5!bkTsb%f>54!)zExm}+#VK^&`U%W5p|Ff+JHav
zTKt-`#NlFcu2DOCfaffp{hR}RzK-%Q{d^U_q0f8yE%`jT`^gPnhbB;V$%J71jw*F_
z9{HNErMH^)k2OQNR?kTJ0hhiYzg@|IiBP(Xr>r>(78MmSH~S?6gCDX>_7fws?VPWp
z@L;>n>W%jovt^RmES_I8Zlma6XioZRd9lY<;_m}&-uQ(KHs9Tbdy?13kK35TXQ<Y5
znrbN-rkIEFYZ0czXgQUN3D_5T09i%TBua!CK`r<sYD9jNh%?YQ$7Y5uGu~NDw3dq^
zRKHIK<izZG)G}4SY5h@AP3xPAXr{$GPxN(YUJVmnNb~HmU#(Rgdw|DdU!<?juOMP{
z_$NBNL&8s%@cVW6Z4|;lJitSfwFQJL^e)_AEq=R_+A{bp_{);2&Jj@V;+n@GnEkAD
z4jYdkKaBd53b|`vF_uU;L)Ye_w2Clq+E<T!M6ilQT9_U{z3J?JenV#u2)YQ`h}(?B
zbZ}*J{RN3uuK+zdfC^8%a}}6-@AC@a3!Zq}dCA8U=3;`39B48D-i7CV6B^ZX*#y}u
zUtsAXP5XON7~I-IAhy*lxk496h^_*2Sv^8hz#9ylh02D*8wo5a`%m#Ec+<xEpw&87
zx`(`Q*;wfaFZYd=uJO`3R@&EO^}uRo(23wssT^E2l`<xZY@+hv;e-k7SxIu|)H`If
zw0f7dT_0kxFX|Uc=p~NxsR=HP69UQ_ywEw4aE^+zG!xI>?>inz9REfY(=oZuXvNr|
z#wGQlkrz}I<dt(SjhaaW2r{`j4BhJd@OD)x=&cSm!0Y`QueUfqmZ%JUY<)?PD`Y*W
zz`n^^rQlw!Y%d5VT3^z#LKSIGLsqD<C!QV=xm=<J#oWC1wBlTJaRkn-^`*i5=#pGC
zzM3RjPC2u=OWkM`EIo>*_~Yr}=}8an9YCYwPtKsx>5J)5{Pm9@D4F&5|9N^+$;1w&
zCr_QIIyS)Lu``5jTo#i_9J@z{SDuvV@C3p&-N^h7;m;o=cZPmIA}S#fdT~z#(U*Q?
zu}}xX2H`5li>J%@K1hma7-QxUO@jt?PeU=P{wh`_w)i(!dqlgKOy82sybqX(E4<)w
zf3x*H2{PGL!7hw)*#$GP%-!Izb#nK2ne80}B(uBAE^uH7S=R|R1+Bja_q-hTJQrq#
zcivk-2s=iQaV2XTyeg|=Me9gGQ}A}A;4O$eQV<!u>NTzVMhbRA87fVCsU(w=$UII)
zFwnV!VoeMJ$uS+RhSKmqB>PFd;Hvh-*Hv*BPaQwZB|WkeC_}%d47xEDCF}}ABfU*l
zQnNsavb`CU7K1g1OFsKr4;m=j&_EGv<8D3Dt0T72UA265?kGmPoQj-cNz8?+uxP1o
zlu5)(hSj^L*Ke1P2w}6Swik8Y1M0Y7+zWZ~q;R6-6_?`=*yTrL*E#q6IOzE+%SLg_
z?HT--mS}xTh==L!5}K@)g7^}wTc|b<>TJ@*ONo-!x;Z2&Lk}cMC_!FSh8CcXQ$lB=
z-)c@PxM6SVa4xc_lIxHC#*$sCi?h9mn?mSECKeTiYEhV8ZzylrDCtNWA#{#ue_vj+
zhq6yZs4o5nbcR^rVWiba*)shz6Gxyotk!aDo7TYGE>VOH)3OcgquYa?r<>!8PAYDR
zy6Zn(cvp{y;uT2$pgSJwEY@^c2s_M)x}t%SK@W#!F6?mLXuPXOL&XH`aBeW37GLzy
z@1%W4tdQZ#=+b>keSuJjFcxnR<Q+;H{&j*P4aa;Q67U7$o%8Ob0DEk8l?o5=&@9F0
z35O^Qp$CJ451IW!ciTKZWy>D2luD4=xhrqNX5zCV#WWuIlg4OPD!aTmhtb6fu`F0q
zZ)>qaK<|CU3IV;#iUk2-3F^S0Di{jU$sntX(dpoxSArg;DB>J5Upl{bmNbg9P>q4b
zU?BfP#VqRq6FzyC$`1yL2AgPc>}bJ4^%Ud`Tbr%8v@eVWndbOliE-~AC@PrvrmSJg
z2}BP=gyAYQryo)CuGG_CBaj_Hr%bGPRIzMDCavYGh+rt>K#SGALp@eV5$K*uk)ndC
z1N(SDKmQ=LV|SCy5y~8Up`EvjMo)v*1iJU3QGD2{bmv+Qso9pPmRZYX$PmA)p35EH
z4x;3P?TVxbClthDH^69HM^(uebhVN#)0Tr%3g?}at~AFVm4=}O`%jt^N-Wl>9G)lK
z7AhPu;^dE_+SNmC%jmh35VBUR<Uz0KV7ruqFLK?vS5Pg=cJ6KIsU4o@V5DhC&kpKE
z#79|bXDZXQ;3hXgD6v8hL|~4Y&~Rt@XF%U)7!{~?<qK14W;YrYSJW95sDxFZ8dkw7
zbkVGkbp<)~Fk1e(;LIQ+RERSPTh(FT?n%{%eHPJtR2T;+rF}o*E3a*(MjUtc;KQzP
zVzrtHrl3_kX|UO3NJ9379^;Y66$xo0ncdG&ML2x@^8po>ejZ6uAB$o?5)6lvngLj6
z#DB9H)<9Wi^_^rNQI%e&*4nkOK0*7^YHZ~#7xp-8AB}Uj^)yMZrMO%nG_@c@&oU9s
zq9whN%;CiMWOk``CDp2X)HI16&R#>69axm>;n^z)Aai+veKat?KB%NjmkHlxn+&Bo
z#xkwHi$?GU06{7ZSueuLmhncr_W>3T<w6jDEajLio!E)Z$OM9kWqPf(mN$|?HpyyT
zmQAu+n0e7FGb(&)TTp9Pkr1UjFAt9DDaoY}`-6L43VZg4S*x87zfPoD^Hn;ufmN;=
zUB)37e_I-nUH`2WMe=EXR{=s|g^aVyq-5HUR*G~vOjXVe)ajBV=^-sIkssD}v=E0j
zS}_KWVhk>ne2F$0FvS=Yv^c{aSX(jzl77)mg8i1ZIUjsYX5y=;T4Wb7#zdHQ%^3Ux
z^)<(Nhg9K)w~Tu_n29E9Z&U4dH~^#dEsAj0uOJFUp6Q8YJ7f_<vttfX%-PQrt+O_8
z<stevbI&&FnaGy-0Ou5}eR=!?a@H=L)zt@Dta1{np-gM{%*fLx>yj3RwEB=eBTtQ>
zYal<OIIBj`!P++%{a&*_t<{<mYy0UASN=vISyD5VP@rZkxe$#r&evsTIIs~W?G!b<
zSU)t{9wO9b446HcQ#gSBpym&hXmsVxSb9X!Zo6n$_6x6sA?DYIoQK$x@K(|Kvh>-N
z4`d~!Xy`CpuOa6M)oz!OGM22x=s=--&>b%`qd%p_%XG)f4F$V0y(dC*3+_N>#!GU@
zc)2-Ddq)0%A+(JyPc~AyoP88dpAk3Z4C;6MfTIe;^^)@#LxR8D6x2C=sKw=aQJsqN
z<7Rai7oqDq`_1o>;8YScqhjCIB#T%=@d{l<p5$44D)WwJ?K-mbIagCz^0>m#l}?S6
zF<P?PWAFTo;!{@e(0s}_-~p0r1OV*PJx9v@9ECTmQkAq{y1;7{&oW+>Rfx74zPNz9
zMN-?g&<`g{DXAz${P{mB;(K{ToFPS=K@;VMTgWbLIf^FUFGJV|zmZ}KG4^>KGb<bO
zBr(cGPVRhh`17^j#H1r4bH1r_IC*hq`!<wcljS+bujx~E*>Z)sQIDepj#=!7WXhq?
zPYGEL-n6Yg*u8-zjDwa}BMsq1peB$A*JZ91u`e1(%$$e4sbzvw8{+t9IT}B6k^c(D
z*&4;y_pm#NY)DNDTOX<OXSi`Q?s!_xn3i}#Z4|h3oBF0$2*e};4n9LxbEVw080J80
z4ecsQy`1*-e1}eS_E(wlo)NN%G;LWDl^29(nN?n4>r20Rv`jwNb22WoGv*2NY|u-I
z%=|5qRD|z$-TEJmKekA$0i=}lI_l?^Kd^i?np?#p0OW4OUaYaDap7_aN(wJT%0t|;
zBG7qsEr+hYo4zeARg60N5!drItfanx-&Rg$w51;==o*v)K8wafS+KiXCMb2J=o4_e
z3Hn^UP_FcH<vU<;>9y@m?Gir3-JjM9I&G{zjH|ob1Fdf^EM<$7x`EASy#F|3^(7v;
z<rn*C+k!?CTsuNt?0b`Ye}9eb9Wa*M$9Ng5rz4hKUxMaDXFpf}-W(a<KCx-^_R(A$
z`-^`uB(|t%L1pST(v0ZrA33_$Z*9oQW6>ICpuFaJ6O6VQG+K7SwWwiq6o-vT-9gOG
zH~ZuJJwdtt7w^DdUsH7zQvKX@c5$JxhrLMhaDmDA`r^+1a{uTJnTmhnw_B@G9K!Vd
zn6X8DWL*4a8bJ0h{!7u{&|I+oL36S#cupwY?W&+58b%oeDzKL^j?vYofiM|!0p~pe
zKJf$T$O*9A7nDUmm-a3DR&H8FZAn>IxR*dRyM?yXq>ci65(z56-7Q9dj#Z{3x<)D8
zoyJ_5aG2-HmsI+BUFp&Izse;5yE3*TD%@JLwj+kCPg%IFq}r;quMg^!+dIA>UxoEN
zl1q?R&#wuU-l=-jc(J*YyNsFheQY8qEH%B(JFA7@W5TC!)UGZpSX-;R$Ss$z^|}4G
zqK6rKTy<>w2h(CgBQVHlm}OB;rz<jr>C@>kZZX;hSAo5Tj0Gq$+F*j4!ew*FE?!=g
zj7lV=5j3o|1<8-MdhtUPlyZZ&T)q-m^rZmT#W`&pz>Hayqu@>a%NGvrmAL|BaK%sq
zhB-on%HS%y4N6}~&gZlCEE=V8l+4NRP~(ypKf0fxR^1u48Sex8QnH%1q2ucsUAeJQ
z&iwTN4`c^;6=Xnll>vr!{hH5gK||=3h6H620z!BNHl^hLx@e5o%RNl7{!n>9d^E(i
z58y9lWt4lOcUJCyCwdfjlkcod<NCoLe`{jrcJ36vHO4>sc~Qek7q=V}JNKO^Lc`T9
z+>hQ#=Gfj<(Xv*QpPvLLW0-9=TH7IXN)hXBd9h3IP&&=SecaRu`TVKXgXwShzvZ1F
z4?69XAgmv?mjzlk-ri56`sW*>bku<Bn&llqPfzMO0^f;#f$RP{urq9zj7EQq+$32S
z_Vfl?H%A_fHT-13&yxpe4{<u>x}awhWd$47Nm(SMB*^L=P@qgJQY-xN9fler%vP-5
zkLPPKlYPwyP9#Tid;zGAWbn<}Ey0E!<6c$#=mUY#{|eYoK=?TPjzO<ue~I}!-yO;Q
zao(Sc1+4x4&UecFv48OSEK%=aZT@+{3?B5JcN7&{$05xHWlinlk7{ba`6y3Qd*moQ
z;aqo=qV>`UGv2*l8IJE>(0I_bV$M!c(%32|s8`}dn*#?ajpfjr`gGTnN^oJM&U+h|
z0*UZ&3vAH2@GDG=2M<0{`cRFi42$7^l=%SO@~YUQM5a_h@vQGnBCL`nBAXD!vaQZ$
zmFk~TH3{{YC3}H-*K>o|&fuCADfe7M1sEJ~lP2FKk-GqheWNNNXH}SX$(kj^8IWL(
zICq2UV2dz4!&E3xU>j4>+kZEI-68UeY0*PCb#@yBZ+QSIUhvxTc0f42J(R$>6#js$
z&77mdNQn>z5ytG~(r2Lvolcb%!0j9KM+V>(uCEVvig_5^2iv8uJwOsMi)NEXvs70;
zu7ZT6nh0-9=t?O2gRH4=(t!>hAQvvVT~<pLYg621U0x<`$eiix$S#UQMk_oHQSeOI
z(7zc@)FqdYkY>KDzSMka9enX;eAJUD$4^x0RdCe7YfEAwPX{&7X0aP3PinMFkNrN&
ziE3_XVuutMP;FCiFihK2xb|+O+V)WAen?<$gtF7glvd@1<Jv1DFVXtZS$nU)iAkT7
zUKERHl;!!m_vUxZ=1V44)R(pWK|P<t@!=WsLG_8!-~T`v^)Gilf0uNci3jSXCU|g+
zjE)jna}eiY%9(E+-AZ>@Q_E5pns&QNmM9%h2}++;B`G6`Y0pA3X#C-r<B1Y~zenkU
zB9FMfw=XO=+CGv>tmC?;N)FzTIoT{OGTJ!KCWvBu4<_Xi?hSIVaC680G}H*IPOTdw
zN3h%(tzD7|!)Rhk^3;?si!`T#G;XjjV`1`zdoC)E?HggVsw4d@)1Ni?+3%X7l0|t~
zgP(F*1o!W*e%j;dtUn5aJ?0+ifL7A!Py34bObVfO_I^#8KXw|V69D@zkH=1;$<E@h
zNce^2&YG{1bT>2r2wUbzDS>>jD)fHfTOujMrGWo>**qWx0du;rBc%XgAbApX=J?-3
zz)zpJ){!0W+rP<e=W_NYhrpXMRGI5_&Isw%e~_Mg+oa9eo{#1;2ZKsn@d@n_t9HA7
zo8J(Z8W!@aEK8oSJ>x?bwD{o2kTI#3kTGHViVuVFz4F}`ZrEzH#TeXGSmAgfQXP!%
zD~Zm>)Py&5-Xw4ItKw(OOa#lEi@v0c5iRRT&16X|z3sw4eNWVEvO1WdamQv!K)OGh
z_Y{RL;_4IIdX!+O5~4?h5>u-}=S``?Y-QpyaPq>+)K4|F77WDQhv(c$9)pVBR(+xi
z9Pt1SKRldWdV+I*du;!wh5U#L0A*YZF`WiKxGtF9P7Y<ygZop7i@XeRaxGo~vSTAJ
z1^lJjQJXf&6+203lPKT!z*tdH8_lrbf)5-UXb%i_1@;0(rRNjnTBGpYA@BC00j<r(
z&M}DLobsn2r}%@+OE;T$yt6sFNZDb&h2pTWIy{I0oxRq&-7l1F!ZvH9q^u`}%fZ0F
z?nc}c9%-WKF3W`N+xuM>Pi2ZFbwn=obrmXPfL0<;KG=4c^fzd2eDq&Hc=8S0`0(u-
z!=U6!N`A3Cql^a$mE>9;p}~2UEUPn=f5tOHX!5%b8TY9?2KBN)WgIdZ$m-%7W{D(T
zIb>9x78|AQ$O5$QC!HEgvVSG`MDebtx+LTA{jU9KA|B6kxv1_6k?=8<UoBdyHj*uK
zJudcg;wlTF&>iT|R3==>8hX`i+NG9=A!JRmeXHTSKwqXnN^(wC^%-qb85kjXiVe4Y
z)3bHCt`|?1c-vP$qz|}W6yu+Iyb8w3-BAINWufz?RYpD?wEb0FiNK%<dn~!Vc<bT0
z`%|XnNy^z&7|Sq00M@@7pAp&+kTQz0nmFY67aaq)d&P17&NsXm@CkOlQ58r8j|z|8
z61I=vy4gHW*jk_ZTt*&j?Hac`-0)(fvAiqf`8#is7P$D&wZ3}$o3RfStNd!H;bqv{
z^+C_B)QjWNu@B#g)(}LFZfv{+#u5LDj{lJ0$SOV~zl}}!$%0>{CLAK2*c@ul)|>hz
zJquZaR)U2+E@aGJAMD&NsMgN`g#&NLS&489r85r8BGuTpnW>OH)(3pR0`xz2ip<xj
ztAujv`w@D7nYI5ugT=jHnP`rp%e-1CC1!*+tN6+hRyAF&yv=oWHbX;rcAGiQUG}(|
zW3;ZMW;1dAwNhl_nCp0?j%{8F6Tymx!D@tYZatiu?B?Vy(!vJpQ_-74h)+U^W)8X+
zRH-eb>@N{Ml;>yRzC~mb@XHWH84fu@y50#UN~$wE+5z#2z$l3gM>#T&{5P-O3M2jv
z1+&oswN^5+$_RSap&J07)eq0}=Qcx?<u1aaa)=eaMlYa0;5_pi#s4vepC-JYwu*IG
zS?X>ba5td(d`;nXp}aDCAIN$+-Y_D%0AtCf+R<^y#-Lr%7=n#0l)o#BcxoT=vzPW`
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

literal 0
HcmV?d00001

diff --git a/Lib/venv/scripts/nt/venvlaunchert.exe b/Lib/venv/scripts/nt/venvlaunchert.exe
new file mode 100644
index 0000000000000000000000000000000000000000..99f5f5e9fca3531bdf05b627409794529eacf0d8
GIT binary patch
literal 268800
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

literal 0
HcmV?d00001

diff --git a/Lib/venv/scripts/nt/venvwlauncher.exe b/Lib/venv/scripts/nt/venvwlauncher.exe
new file mode 100644
index 0000000000000000000000000000000000000000..6c43c2e9d9365ab5ff80adb25b143c6580d177fd
GIT binary patch
literal 268800
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%0AtCf+R<^y#-Lr%7=n#0l)o#BcxoT=vzPW`
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

literal 0
HcmV?d00001

diff --git a/Lib/venv/scripts/nt/venvwlaunchert.exe b/Lib/venv/scripts/nt/venvwlaunchert.exe
new file mode 100644
index 0000000000000000000000000000000000000000..74f40deb0467b055fe42c80480144f3ecd542da5
GIT binary patch
literal 268800
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

literal 0
HcmV?d00001

diff --git a/crates/venvlauncher/Cargo.toml b/crates/venvlauncher/Cargo.toml
new file mode 100644
index 00000000000..d59a3a0269f
--- /dev/null
+++ b/crates/venvlauncher/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "rustpython-venvlauncher"
+description = "Lightweight venv launcher for RustPython"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[[bin]]
+name = "venvlauncher"
+path = "src/main.rs"
+
+[[bin]]
+name = "venvwlauncher"
+path = "src/main.rs"
+
+# Free-threaded variants (RustPython uses Py_GIL_DISABLED=true)
+[[bin]]
+name = "venvlaunchert"
+path = "src/main.rs"
+
+[[bin]]
+name = "venvwlaunchert"
+path = "src/main.rs"
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { workspace = true, features = [
+    "Win32_Foundation",
+    "Win32_System_Threading",
+    "Win32_System_Environment",
+    "Win32_Storage_FileSystem",
+    "Win32_System_Console",
+    "Win32_Security",
+] }
+
+[lints]
+workspace = true
diff --git a/crates/venvlauncher/build.rs b/crates/venvlauncher/build.rs
new file mode 100644
index 00000000000..404f46a484f
--- /dev/null
+++ b/crates/venvlauncher/build.rs
@@ -0,0 +1,21 @@
+//! Build script for venvlauncher
+//!
+//! Sets the Windows subsystem to GUI for venvwlauncher variants.
+//! Only MSVC toolchain is supported on Windows (same as CPython).
+
+fn main() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let target_env = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
+
+    // Only apply on Windows with MSVC toolchain
+    if target_os == "windows" && target_env == "msvc" {
+        let exe_name = std::env::var("CARGO_BIN_NAME").unwrap_or_default();
+
+        // venvwlauncher and venvwlaunchert should be Windows GUI applications
+        // (no console window)
+        if exe_name.contains("venvw") {
+            println!("cargo:rustc-link-arg=/SUBSYSTEM:WINDOWS");
+            println!("cargo:rustc-link-arg=/ENTRY:mainCRTStartup");
+        }
+    }
+}
diff --git a/crates/venvlauncher/src/main.rs b/crates/venvlauncher/src/main.rs
new file mode 100644
index 00000000000..aaf584dfa87
--- /dev/null
+++ b/crates/venvlauncher/src/main.rs
@@ -0,0 +1,155 @@
+//! RustPython venv launcher
+//!
+//! A lightweight launcher that reads pyvenv.cfg and delegates execution
+//! to the actual Python interpreter. This mimics CPython's venvlauncher.c.
+//! Windows only.
+
+#[cfg(not(windows))]
+compile_error!("venvlauncher is only supported on Windows");
+
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    match run() {
+        Ok(code) => ExitCode::from(code as u8),
+        Err(e) => {
+            eprintln!("venvlauncher error: {}", e);
+            ExitCode::from(1)
+        }
+    }
+}
+
+fn run() -> Result<u32, Box<dyn std::error::Error>> {
+    // 1. Get own executable path
+    let exe_path = env::current_exe()?;
+    let exe_name = exe_path
+        .file_name()
+        .ok_or("Failed to get executable name")?
+        .to_string_lossy();
+
+    // 2. Determine target executable name based on launcher name
+    // pythonw.exe / venvwlauncher -> pythonw.exe (GUI, no console)
+    // python.exe / venvlauncher -> python.exe (console)
+    let exe_name_lower = exe_name.to_lowercase();
+    let target_exe = if exe_name_lower.contains("pythonw") || exe_name_lower.contains("venvw") {
+        "pythonw.exe"
+    } else {
+        "python.exe"
+    };
+
+    // 3. Find pyvenv.cfg
+    // The launcher is in Scripts/ directory, pyvenv.cfg is in parent (venv root)
+    let scripts_dir = exe_path.parent().ok_or("Failed to get Scripts directory")?;
+    let venv_dir = scripts_dir.parent().ok_or("Failed to get venv directory")?;
+    let cfg_path = venv_dir.join("pyvenv.cfg");
+
+    if !cfg_path.exists() {
+        return Err(format!("pyvenv.cfg not found: {}", cfg_path.display()).into());
+    }
+
+    // 4. Parse home= from pyvenv.cfg
+    let home = read_home(&cfg_path)?;
+
+    // 5. Locate python executable in home directory
+    let python_path = PathBuf::from(&home).join(target_exe);
+    if !python_path.exists() {
+        return Err(format!("Python not found: {}", python_path.display()).into());
+    }
+
+    // 6. Set __PYVENV_LAUNCHER__ environment variable
+    // This tells Python it was launched from a venv
+    // SAFETY: We are in a single-threaded context (program entry point)
+    unsafe {
+        env::set_var("__PYVENV_LAUNCHER__", &exe_path);
+    }
+
+    // 7. Launch Python with same arguments
+    let args: Vec<String> = env::args().skip(1).collect();
+    launch_process(&python_path, &args)
+}
+
+/// Parse the `home=` value from pyvenv.cfg
+fn read_home(cfg_path: &Path) -> Result<String, Box<dyn std::error::Error>> {
+    let content = fs::read_to_string(cfg_path)?;
+
+    for line in content.lines() {
+        let line = line.trim();
+        // Skip comments and empty lines
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        // Look for "home = <path>" or "home=<path>"
+        if let Some(rest) = line.strip_prefix("home") {
+            let rest = rest.trim_start();
+            if let Some(value) = rest.strip_prefix('=') {
+                return Ok(value.trim().to_string());
+            }
+        }
+    }
+
+    Err("'home' key not found in pyvenv.cfg".into())
+}
+
+/// Launch the Python process and wait for it to complete
+fn launch_process(exe: &Path, args: &[String]) -> Result<u32, Box<dyn std::error::Error>> {
+    use std::process::Command;
+
+    let status = Command::new(exe).args(args).status()?;
+
+    Ok(status.code().unwrap_or(1) as u32)
+}
+
+#[cfg(all(test, windows))]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    #[test]
+    fn test_read_home() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "home = C:\\Python313").unwrap();
+        writeln!(file, "include-system-site-packages = false").unwrap();
+        writeln!(file, "version = 3.13.0").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "C:\\Python313");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+
+    #[test]
+    fn test_read_home_no_spaces() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv2.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "home=C:\\Python313").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "C:\\Python313");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+
+    #[test]
+    fn test_read_home_with_comments() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv3.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "# This is a comment").unwrap();
+        writeln!(file, "home = D:\\RustPython").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "D:\\RustPython");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+}
diff --git a/crates/vm/src/getpath.rs b/crates/vm/src/getpath.rs
index 423b9b54136..011d5336873 100644
--- a/crates/vm/src/getpath.rs
+++ b/crates/vm/src/getpath.rs
@@ -110,19 +110,26 @@ pub fn init_path_config(settings: &Settings) -> Paths {
 
     // Step 0: Get executable path
     let executable = get_executable_path();
-    paths.executable = executable
+    let real_executable = executable
         .as_ref()
         .map(|p| p.to_string_lossy().into_owned())
         .unwrap_or_default();
 
-    let exe_dir = executable
-        .as_ref()
-        .and_then(|p| p.parent().map(PathBuf::from));
-
     // Step 1: Check for __PYVENV_LAUNCHER__ environment variable
-    if let Ok(launcher) = env::var("__PYVENV_LAUNCHER__") {
-        paths.base_executable = launcher;
-    }
+    // When launched from a venv launcher, __PYVENV_LAUNCHER__ contains the venv's python.exe path
+    // In this case:
+    //   - sys.executable should be the launcher path (where user invoked Python)
+    //   - sys._base_executable should be the real Python executable
+    let exe_dir = if let Ok(launcher) = env::var("__PYVENV_LAUNCHER__") {
+        paths.executable = launcher.clone();
+        paths.base_executable = real_executable;
+        PathBuf::from(&launcher).parent().map(PathBuf::from)
+    } else {
+        paths.executable = real_executable;
+        executable
+            .as_ref()
+            .and_then(|p| p.parent().map(PathBuf::from))
+    };
 
     // Step 2: Check for venv (pyvenv.cfg) and get 'home'
     let (venv_prefix, home_dir) = detect_venv(&exe_dir);

From 21f24cdcc72c87f33f65fd32229187b1404dcd7d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 01:37:21 +0900
Subject: [PATCH 071/418] impl more winapi (#6529)

---
 Lib/test/test_winapi.py        |  14 --
 crates/vm/src/stdlib/winapi.rs | 439 ++++++++++++++++++++++++++++++++-
 2 files changed, 438 insertions(+), 15 deletions(-)

diff --git a/Lib/test/test_winapi.py b/Lib/test/test_winapi.py
index 846398f89d4..99b5a0dfd16 100644
--- a/Lib/test/test_winapi.py
+++ b/Lib/test/test_winapi.py
@@ -77,34 +77,22 @@ def _events_waitany_test(self, n):
                 evts[i] = old_evt
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_few_events_waitall(self):
         self._events_waitall_test(16)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_events_waitall(self):
         self._events_waitall_test(256)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_events_waitall(self):
         self._events_waitall_test(MAXIMUM_BATCHED_WAIT_OBJECTS)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_few_events_waitany(self):
         self._events_waitany_test(16)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_events_waitany(self):
         self._events_waitany_test(256)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_events_waitany(self):
         self._events_waitany_test(MAXIMUM_BATCHED_WAIT_OBJECTS)
 
@@ -140,8 +128,6 @@ def test_getshortpathname(self):
         # Should contain "PROGRA~" but we can't predict the number
         self.assertIsNotNone(re.match(r".\:\\PROGRA~\d", actual.upper()), actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_namedpipe(self):
         pipe_name = rf"\\.\pipe\LOCAL\{os_helper.TESTFN}"
 
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs
index 44f56f0112f..5cfb62fad6f 100644
--- a/crates/vm/src/stdlib/winapi.rs
+++ b/crates/vm/src/stdlib/winapi.rs
@@ -572,7 +572,7 @@ mod _winapi {
             LCMapStringEx as WinLCMapStringEx,
         };
 
-        // Reject unsupported flags (same as CPython)
+        // Reject unsupported flags
         if flags & (LCMAP_SORTHANDLE | LCMAP_HASH | LCMAP_BYTEREV | LCMAP_SORTKEY) != 0 {
             return Err(vm.new_value_error("unsupported flags"));
         }
@@ -725,4 +725,441 @@ mod _winapi {
         use windows_sys::Win32::Storage::FileSystem::GetLongPathNameW;
         get_path_name_impl(&path, GetLongPathNameW, vm)
     }
+
+    /// WaitNamedPipe - Wait for an instance of a named pipe to become available.
+    #[pyfunction]
+    fn WaitNamedPipe(name: PyStrRef, timeout: u32, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Pipes::WaitNamedPipeW;
+
+        let name_wide = name.as_wtf8().to_wide_with_nul();
+
+        let success = unsafe { WaitNamedPipeW(name_wide.as_ptr(), timeout) };
+
+        if success == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
+    /// PeekNamedPipe - Peek at data in a named pipe without removing it.
+    #[pyfunction]
+    fn PeekNamedPipe(
+        handle: WinHandle,
+        size: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        use windows_sys::Win32::System::Pipes::PeekNamedPipe as WinPeekNamedPipe;
+
+        let size = size.unwrap_or(0);
+
+        if size < 0 {
+            return Err(vm.new_value_error("negative size".to_string()));
+        }
+
+        let mut navail: u32 = 0;
+        let mut nleft: u32 = 0;
+
+        if size > 0 {
+            let mut buf = vec![0u8; size as usize];
+            let mut nread: u32 = 0;
+
+            let ret = unsafe {
+                WinPeekNamedPipe(
+                    handle.0,
+                    buf.as_mut_ptr() as *mut _,
+                    size as u32,
+                    &mut nread,
+                    &mut navail,
+                    &mut nleft,
+                )
+            };
+
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+
+            buf.truncate(nread as usize);
+            let bytes: PyObjectRef = vm.ctx.new_bytes(buf).into();
+            Ok(vm
+                .ctx
+                .new_tuple(vec![
+                    bytes,
+                    vm.ctx.new_int(navail).into(),
+                    vm.ctx.new_int(nleft).into(),
+                ])
+                .into())
+        } else {
+            let ret = unsafe {
+                WinPeekNamedPipe(handle.0, null_mut(), 0, null_mut(), &mut navail, &mut nleft)
+            };
+
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+
+            Ok(vm
+                .ctx
+                .new_tuple(vec![
+                    vm.ctx.new_int(navail).into(),
+                    vm.ctx.new_int(nleft).into(),
+                ])
+                .into())
+        }
+    }
+
+    /// CreateEventW - Create or open a named or unnamed event object.
+    #[pyfunction]
+    fn CreateEventW(
+        security_attributes: isize, // Always NULL (0)
+        manual_reset: bool,
+        initial_state: bool,
+        name: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Threading::CreateEventW as WinCreateEventW;
+
+        let _ = security_attributes; // Ignored, always NULL
+
+        let name_wide = name.map(|n| n.as_wtf8().to_wide_with_nul());
+        let name_ptr = name_wide.as_ref().map_or(null(), |n| n.as_ptr());
+
+        let handle = unsafe {
+            WinCreateEventW(
+                null(),
+                i32::from(manual_reset),
+                i32::from(initial_state),
+                name_ptr,
+            )
+        };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(WinHandle(handle))
+    }
+
+    /// SetEvent - Set the specified event object to the signaled state.
+    #[pyfunction]
+    fn SetEvent(event: WinHandle, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Threading::SetEvent as WinSetEvent;
+
+        let ret = unsafe { WinSetEvent(event.0) };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
+    /// WriteFile - Write data to a file or I/O device.
+    #[pyfunction]
+    fn WriteFile(
+        handle: WinHandle,
+        buffer: crate::function::ArgBytesLike,
+        use_overlapped: OptionalArg<bool>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(u32, u32)> {
+        use windows_sys::Win32::Storage::FileSystem::WriteFile as WinWriteFile;
+
+        let use_overlapped = use_overlapped.unwrap_or(false);
+
+        if use_overlapped {
+            return Err(vm.new_not_implemented_error(
+                "overlapped WriteFile is not yet implemented in _winapi".to_string(),
+            ));
+        }
+
+        let buf = buffer.borrow_buf();
+        let len = std::cmp::min(buf.len(), u32::MAX as usize) as u32;
+        let mut written: u32 = 0;
+
+        let ret = unsafe {
+            WinWriteFile(
+                handle.0,
+                buf.as_ptr() as *const _,
+                len,
+                &mut written,
+                null_mut(),
+            )
+        };
+
+        let err = if ret == 0 {
+            unsafe { windows_sys::Win32::Foundation::GetLastError() }
+        } else {
+            0
+        };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok((written, err))
+    }
+
+    const MAXIMUM_WAIT_OBJECTS: usize = 64;
+
+    /// BatchedWaitForMultipleObjects - Wait for multiple handles, supporting more than 64.
+    #[pyfunction]
+    fn BatchedWaitForMultipleObjects(
+        handle_seq: PyObjectRef,
+        wait_all: bool,
+        milliseconds: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        use std::sync::Arc;
+        use std::sync::atomic::{AtomicU32, Ordering};
+        use windows_sys::Win32::Foundation::{CloseHandle, WAIT_FAILED, WAIT_OBJECT_0};
+        use windows_sys::Win32::System::SystemInformation::GetTickCount64;
+        use windows_sys::Win32::System::Threading::{
+            CreateEventW as WinCreateEventW, CreateThread, GetExitCodeThread,
+            INFINITE as WIN_INFINITE, ResumeThread, SetEvent as WinSetEvent, TerminateThread,
+            WaitForMultipleObjects,
+        };
+
+        let milliseconds = milliseconds.unwrap_or(WIN_INFINITE);
+
+        // Get handles from sequence
+        let seq = ArgSequence::<isize>::try_from_object(vm, handle_seq)?;
+        let handles: Vec<isize> = seq.into_vec();
+        let nhandles = handles.len();
+
+        if nhandles == 0 {
+            return if wait_all {
+                Ok(vm.ctx.none())
+            } else {
+                Ok(vm.ctx.new_list(vec![]).into())
+            };
+        }
+
+        let max_total_objects = (MAXIMUM_WAIT_OBJECTS - 1) * (MAXIMUM_WAIT_OBJECTS - 1);
+        if nhandles > max_total_objects {
+            return Err(vm.new_value_error(format!(
+                "need at most {} handles, got a sequence of length {}",
+                max_total_objects, nhandles
+            )));
+        }
+
+        // Create batches of handles
+        let batch_size = MAXIMUM_WAIT_OBJECTS - 1; // Leave room for cancel_event
+        let mut batches: Vec<Vec<isize>> = Vec::new();
+        let mut i = 0;
+        while i < nhandles {
+            let end = std::cmp::min(i + batch_size, nhandles);
+            batches.push(handles[i..end].to_vec());
+            i = end;
+        }
+
+        if wait_all {
+            // For wait_all, we wait sequentially for each batch
+            let deadline = if milliseconds != WIN_INFINITE {
+                Some(unsafe { GetTickCount64() } + milliseconds as u64)
+            } else {
+                None
+            };
+
+            for batch in &batches {
+                let timeout = if let Some(deadline) = deadline {
+                    let now = unsafe { GetTickCount64() };
+                    if now >= deadline {
+                        return Err(
+                            vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned())
+                        );
+                    }
+                    (deadline - now) as u32
+                } else {
+                    WIN_INFINITE
+                };
+
+                let batch_handles: Vec<_> = batch.iter().map(|&h| h as _).collect();
+                let result = unsafe {
+                    WaitForMultipleObjects(
+                        batch_handles.len() as u32,
+                        batch_handles.as_ptr(),
+                        1, // wait_all = TRUE
+                        timeout,
+                    )
+                };
+
+                if result == WAIT_FAILED {
+                    return Err(vm.new_last_os_error());
+                }
+                if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                    return Err(vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned()));
+                }
+            }
+
+            Ok(vm.ctx.none())
+        } else {
+            // For wait_any, we use threads to wait on each batch in parallel
+            let cancel_event = unsafe { WinCreateEventW(null(), 1, 0, null()) }; // Manual reset, not signaled
+            if cancel_event.is_null() {
+                return Err(vm.new_last_os_error());
+            }
+
+            struct BatchData {
+                handles: Vec<isize>,
+                cancel_event: isize,
+                handle_base: usize,
+                result: AtomicU32,
+                thread: std::cell::UnsafeCell<isize>,
+            }
+
+            unsafe impl Send for BatchData {}
+            unsafe impl Sync for BatchData {}
+
+            let batch_data: Vec<Arc<BatchData>> = batches
+                .iter()
+                .enumerate()
+                .map(|(idx, batch)| {
+                    let base = idx * batch_size;
+                    let mut handles_with_cancel = batch.clone();
+                    handles_with_cancel.push(cancel_event as isize);
+                    Arc::new(BatchData {
+                        handles: handles_with_cancel,
+                        cancel_event: cancel_event as isize,
+                        handle_base: base,
+                        result: AtomicU32::new(WAIT_FAILED),
+                        thread: std::cell::UnsafeCell::new(0),
+                    })
+                })
+                .collect();
+
+            // Thread function
+            extern "system" fn batch_wait_thread(param: *mut std::ffi::c_void) -> u32 {
+                let data = unsafe { &*(param as *const BatchData) };
+                let handles: Vec<_> = data.handles.iter().map(|&h| h as _).collect();
+                let result = unsafe {
+                    WaitForMultipleObjects(
+                        handles.len() as u32,
+                        handles.as_ptr(),
+                        0, // wait_any
+                        WIN_INFINITE,
+                    )
+                };
+                data.result.store(result, Ordering::SeqCst);
+
+                if result == WAIT_FAILED {
+                    let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+                    unsafe { WinSetEvent(data.cancel_event as _) };
+                    return err;
+                } else if result >= windows_sys::Win32::Foundation::WAIT_ABANDONED_0
+                    && result
+                        < windows_sys::Win32::Foundation::WAIT_ABANDONED_0
+                            + MAXIMUM_WAIT_OBJECTS as u32
+                {
+                    data.result.store(WAIT_FAILED, Ordering::SeqCst);
+                    unsafe { WinSetEvent(data.cancel_event as _) };
+                    return windows_sys::Win32::Foundation::ERROR_ABANDONED_WAIT_0;
+                }
+                0
+            }
+
+            // Create threads
+            let mut thread_handles: Vec<isize> = Vec::new();
+            for data in &batch_data {
+                let thread = unsafe {
+                    CreateThread(
+                        null(),
+                        1, // Smallest stack
+                        Some(batch_wait_thread),
+                        Arc::as_ptr(data) as *const _ as *mut _,
+                        4, // CREATE_SUSPENDED
+                        null_mut(),
+                    )
+                };
+                if thread.is_null() {
+                    // Cleanup on error
+                    for h in &thread_handles {
+                        unsafe { TerminateThread(*h as _, 0) };
+                        unsafe { CloseHandle(*h as _) };
+                    }
+                    unsafe { CloseHandle(cancel_event) };
+                    return Err(vm.new_last_os_error());
+                }
+                unsafe { *data.thread.get() = thread as isize };
+                thread_handles.push(thread as isize);
+            }
+
+            // Resume all threads
+            for &thread in &thread_handles {
+                unsafe { ResumeThread(thread as _) };
+            }
+
+            // Wait for any thread to complete
+            let thread_handles_raw: Vec<_> = thread_handles.iter().map(|&h| h as _).collect();
+            let result = unsafe {
+                WaitForMultipleObjects(
+                    thread_handles_raw.len() as u32,
+                    thread_handles_raw.as_ptr(),
+                    0, // wait_any
+                    milliseconds,
+                )
+            };
+
+            let err = if result == WAIT_FAILED {
+                Some(unsafe { windows_sys::Win32::Foundation::GetLastError() })
+            } else if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                Some(windows_sys::Win32::Foundation::WAIT_TIMEOUT)
+            } else {
+                None
+            };
+
+            // Signal cancel event to stop other threads
+            unsafe { WinSetEvent(cancel_event) };
+
+            // Wait for all threads to finish
+            unsafe {
+                WaitForMultipleObjects(
+                    thread_handles_raw.len() as u32,
+                    thread_handles_raw.as_ptr(),
+                    1, // wait_all
+                    WIN_INFINITE,
+                )
+            };
+
+            // Check for errors from threads
+            let mut thread_err = err;
+            for data in &batch_data {
+                if thread_err.is_none() && data.result.load(Ordering::SeqCst) == WAIT_FAILED {
+                    let mut exit_code: u32 = 0;
+                    let thread = unsafe { *data.thread.get() };
+                    if unsafe { GetExitCodeThread(thread as _, &mut exit_code) } == 0 {
+                        thread_err =
+                            Some(unsafe { windows_sys::Win32::Foundation::GetLastError() });
+                    } else if exit_code != 0 {
+                        thread_err = Some(exit_code);
+                    }
+                }
+                let thread = unsafe { *data.thread.get() };
+                unsafe { CloseHandle(thread as _) };
+            }
+
+            unsafe { CloseHandle(cancel_event) };
+
+            // Return result
+            if let Some(e) = thread_err {
+                if e == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                    return Err(vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned()));
+                }
+                return Err(vm.new_os_error(e as i32));
+            }
+
+            // Collect triggered indices
+            let mut triggered_indices: Vec<PyObjectRef> = Vec::new();
+            for data in &batch_data {
+                let result = data.result.load(Ordering::SeqCst);
+                let triggered = result as i32 - WAIT_OBJECT_0 as i32;
+                // Check if it's a valid handle index (not the cancel_event which is last)
+                if triggered >= 0 && (triggered as usize) < data.handles.len() - 1 {
+                    let index = data.handle_base + triggered as usize;
+                    triggered_indices.push(vm.ctx.new_int(index).into());
+                }
+            }
+
+            Ok(vm.ctx.new_list(triggered_indices).into())
+        }
+    }
 }

From ae39b132e410ed8ba1e54453f2573c60b2679f22 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 09:43:01 +0900
Subject: [PATCH 072/418] impl more ntpath (#6531)

---
 Lib/test/test_ntpath.py       |  4 --
 crates/vm/src/builtins/str.rs | 15 +++++-
 crates/vm/src/stdlib/nt.rs    | 91 +++++++++++++++++++++++++++++++++++
 3 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/Lib/test/test_ntpath.py b/Lib/test/test_ntpath.py
index ed9d8b5d281..e1982dfd0bd 100644
--- a/Lib/test/test_ntpath.py
+++ b/Lib/test/test_ntpath.py
@@ -1279,8 +1279,6 @@ def test_ismount(self):
             self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$"))
             self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$\\"))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; crash")
     def test_ismount_invalid_paths(self):
         ismount = ntpath.ismount
         self.assertFalse(ismount("c:\\\udfff"))
@@ -1464,8 +1462,6 @@ def test_fast_paths_in_use(self):
         self.assertTrue(os.path.lexists is nt._path_lexists)
         self.assertFalse(inspect.isfunction(os.path.lexists))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(os.name != 'nt', "Dev Drives only exist on Win32")
     def test_isdevdrive(self):
         # Result may be True or False, but shouldn't raise
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 95b41e6d55c..df65fd5a4ed 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -668,8 +668,19 @@ impl PyStr {
 
     // casefold is much more aggressive than lower
     #[pymethod]
-    fn casefold(&self) -> String {
-        caseless::default_case_fold_str(self.as_str())
+    fn casefold(&self) -> Self {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => caseless::default_case_fold_str(s.as_str()).into(),
+            PyKindStr::Utf8(s) => caseless::default_case_fold_str(s).into(),
+            PyKindStr::Wtf8(w) => w
+                .chunks()
+                .map(|c| match c {
+                    Wtf8Chunk::Utf8(s) => Wtf8Buf::from_string(caseless::default_case_fold_str(s)),
+                    Wtf8Chunk::Surrogate(c) => Wtf8Buf::from(c),
+                })
+                .collect::<Wtf8Buf>()
+                .into(),
+        }
     }
 
     #[pymethod]
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
index fc68139dc88..05929344cc4 100644
--- a/crates/vm/src/stdlib/nt.rs
+++ b/crates/vm/src/stdlib/nt.rs
@@ -567,6 +567,97 @@ pub(crate) mod module {
             .is_some_and(|p| _test_file_exists(&p, false))
     }
 
+    /// Check if a path is on a Windows Dev Drive.
+    #[pyfunction]
+    fn _path_isdevdrive(path: OsPath, vm: &VirtualMachine) -> PyResult<bool> {
+        use windows_sys::Win32::Foundation::CloseHandle;
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_READ_ATTRIBUTES, FILE_SHARE_READ,
+            FILE_SHARE_WRITE, GetDriveTypeW, GetVolumePathNameW, OPEN_EXISTING,
+        };
+        use windows_sys::Win32::System::IO::DeviceIoControl;
+        use windows_sys::Win32::System::Ioctl::FSCTL_QUERY_PERSISTENT_VOLUME_STATE;
+        use windows_sys::Win32::System::WindowsProgramming::DRIVE_FIXED;
+
+        // PERSISTENT_VOLUME_STATE_DEV_VOLUME flag - not yet in windows-sys
+        const PERSISTENT_VOLUME_STATE_DEV_VOLUME: u32 = 0x00002000;
+
+        // FILE_FS_PERSISTENT_VOLUME_INFORMATION structure
+        #[repr(C)]
+        struct FileFsPersistentVolumeInformation {
+            volume_flags: u32,
+            flag_mask: u32,
+            version: u32,
+            reserved: u32,
+        }
+
+        let wide_path = path.to_wide_cstring(vm)?;
+        let mut volume = [0u16; Foundation::MAX_PATH as usize];
+
+        // Get volume path
+        let ret = unsafe {
+            GetVolumePathNameW(wide_path.as_ptr(), volume.as_mut_ptr(), volume.len() as _)
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Check if it's a fixed drive
+        if unsafe { GetDriveTypeW(volume.as_ptr()) } != DRIVE_FIXED {
+            return Ok(false);
+        }
+
+        // Open the volume
+        let handle = unsafe {
+            CreateFileW(
+                volume.as_ptr(),
+                FILE_READ_ATTRIBUTES,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                std::ptr::null(),
+                OPEN_EXISTING,
+                FILE_FLAG_BACKUP_SEMANTICS,
+                std::ptr::null_mut(),
+            )
+        };
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Query persistent volume state
+        let mut volume_state = FileFsPersistentVolumeInformation {
+            volume_flags: 0,
+            flag_mask: PERSISTENT_VOLUME_STATE_DEV_VOLUME,
+            version: 1,
+            reserved: 0,
+        };
+
+        let ret = unsafe {
+            DeviceIoControl(
+                handle,
+                FSCTL_QUERY_PERSISTENT_VOLUME_STATE,
+                &volume_state as *const _ as *const std::ffi::c_void,
+                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                &mut volume_state as *mut _ as *mut std::ffi::c_void,
+                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+            )
+        };
+
+        unsafe { CloseHandle(handle) };
+
+        if ret == 0 {
+            let err = io::Error::last_os_error();
+            // ERROR_INVALID_PARAMETER means not supported on this platform
+            if err.raw_os_error() == Some(Foundation::ERROR_INVALID_PARAMETER as i32) {
+                return Ok(false);
+            }
+            return Err(err.to_pyexception(vm));
+        }
+
+        Ok((volume_state.volume_flags & PERSISTENT_VOLUME_STATE_DEV_VOLUME) != 0)
+    }
+
     // cwait is available on MSVC only
     #[cfg(target_env = "msvc")]
     unsafe extern "C" {

From c9bf8df19ca9b88e6848b9513308f62637792b9c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 09:46:33 +0900
Subject: [PATCH 073/418] copyslot for init (#6515)

---
 Lib/test/test_codecs.py           |  1 -
 Lib/test/test_memoryio.py         |  8 ----
 Lib/test/test_pickle.py           | 15 -------
 Lib/test/test_pickletools.py      |  5 ---
 Lib/test/test_urllib2.py          | 28 -------------
 Lib/test/test_zipfile.py          |  2 -
 crates/derive-impl/src/pyclass.rs | 23 ++++++++--
 crates/vm/src/builtins/object.rs  | 49 +++++++++++-----------
 crates/vm/src/builtins/type.rs    | 70 +++++++++++++++++++++++++++----
 crates/vm/src/exception_group.rs  | 14 ++-----
 crates/vm/src/stdlib/io.rs        | 57 +++++++++++++++++--------
 crates/vm/src/types/slot.rs       | 69 +++++++++++++++++++++++++++++-
 crates/vm/src/types/zoo.rs        |  4 +-
 13 files changed, 216 insertions(+), 129 deletions(-)

diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py
index 0d3d8c9e2d6..736022599ed 100644
--- a/Lib/test/test_codecs.py
+++ b/Lib/test/test_codecs.py
@@ -3189,7 +3189,6 @@ def test_readline(self):
                 sout = reader.readline()
                 self.assertEqual(sout, b"\x80")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_buffer_api_usage(self):
         # We check all the transform codecs accept memoryview input
         # for encoding and decoding
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index 61d9b180e26..07d9d38d6e4 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -724,8 +724,6 @@ class CBytesIOTest(PyBytesIOTest):
     ioclass = io.BytesIO
     UnsupportedOperation = io.UnsupportedOperation
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bytes_array(self):
         super().test_bytes_array()
 
@@ -739,8 +737,6 @@ def test_flags(self):
     def test_getbuffer(self):
         super().test_getbuffer()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         super().test_init()
 
@@ -770,8 +766,6 @@ def test_relative_seek(self):
     def test_seek(self):
         super().test_seek()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclassing(self):
         super().test_subclassing()
 
@@ -884,8 +878,6 @@ def test_detach(self):
     def test_flags(self):
         super().test_flags()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         super().test_init()
 
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index 070e277c2a7..ea51b9d0916 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -180,11 +180,6 @@ def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers_writable_to_readonly()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_optional_frames()
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
@@ -220,11 +215,6 @@ def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers_writable_to_readonly()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_optional_frames()
-
 
 class InMemoryPickleTests(AbstractPickleTests, AbstractUnpickleTests,
                           BigmemPickleTests, unittest.TestCase):
@@ -309,11 +299,6 @@ def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it pas
     def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_optional_frames()
-
 class PersistentPicklerUnpicklerMixin(object):
 
     def dumps(self, arg, proto=None):
diff --git a/Lib/test/test_pickletools.py b/Lib/test/test_pickletools.py
index 6c38bef3d31..492f57cce22 100644
--- a/Lib/test/test_pickletools.py
+++ b/Lib/test/test_pickletools.py
@@ -97,11 +97,6 @@ def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers_writable_to_readonly()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_optional_frames()
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_py_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 5a02b5db8e5..399c94213a6 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -641,8 +641,6 @@ def test_raise(self):
         self.assertRaises(urllib.error.URLError, o.open, req)
         self.assertEqual(o.calls, [(handlers[0], "http_open", (req,), {})])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_http_error(self):
         # XXX http_error_default
         # http errors are a special case
@@ -666,8 +664,6 @@ def test_http_error(self):
             self.assertEqual((handler, method_name), got[:2])
             self.assertEqual(args, got[2])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_processors(self):
         # *_request / *_response methods get called appropriately
         o = OpenerDirector()
@@ -874,8 +870,6 @@ def test_file(self):
                 self.assertEqual(req.type, "ftp")
             self.assertEqual(req.type == "ftp", ftp)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_http(self):
 
         h = urllib.request.AbstractHTTPHandler()
@@ -1136,8 +1130,6 @@ def test_fixpath_in_weirdurls(self):
         self.assertEqual(newreq.host, 'www.python.org')
         self.assertEqual(newreq.selector, '')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_errors(self):
         h = urllib.request.HTTPErrorProcessor()
         o = h.parent = MockOpener()
@@ -1163,8 +1155,6 @@ def test_errors(self):
         self.assertEqual(o.proto, "http")  # o.error called
         self.assertEqual(o.args, (req, r, 502, "Bad gateway", {}))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cookies(self):
         cj = MockCookieJar()
         h = urllib.request.HTTPCookieProcessor(cj)
@@ -1291,8 +1281,6 @@ def test_relative_redirect(self):
             MockHeaders({"location": valid_url}))
         self.assertEqual(o.req.get_full_url(), valid_url)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cookie_redirect(self):
         # cookies shouldn't leak into redirected requests
         from http.cookiejar import CookieJar
@@ -1308,8 +1296,6 @@ def test_cookie_redirect(self):
         o.open("http://www.example.com/")
         self.assertFalse(hh.req.has_header("Cookie"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_redirect_fragment(self):
         redirected_url = 'http://www.example.com/index.html#OK\r\n\r\n'
         hh = MockHTTPHandler(302, 'Location: ' + redirected_url)
@@ -1374,8 +1360,6 @@ def http_open(self, req):
                 request = handler.last_buf
                 self.assertTrue(request.startswith(expected), repr(request))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy(self):
         u = "proxy.example.com:3128"
         for d in dict(http=u), dict(HTTP=u):
@@ -1420,8 +1404,6 @@ def test_proxy_no_proxy_all(self):
         self.assertEqual(req.host, "www.python.org")
         del os.environ['no_proxy']
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy_https(self):
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(https="proxy.example.com:3128"))
@@ -1509,8 +1491,6 @@ def check_basic_auth(self, headers, realm):
                                   "http://acme.example.com/protected",
                                   "http://acme.example.com/protected")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_auth(self):
         realm = "realm2@example.com"
         realm2 = "realm2@example.com"
@@ -1556,8 +1536,6 @@ def test_basic_auth(self):
                        for challenge in challenges]
             self.check_basic_auth(headers, realm)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy_basic_auth(self):
         opener = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com:3128"))
@@ -1575,8 +1553,6 @@ def test_proxy_basic_auth(self):
                               "proxy.example.com:3128",
                               )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_and_digest_auth_handlers(self):
         # HTTPDigestAuthHandler raised an exception if it couldn't handle a 40*
         # response (http://python.org/sf/1479302), where it should instead
@@ -1684,8 +1660,6 @@ def _test_basic_auth(self, opener, auth_handler, auth_header,
         self.assertEqual(len(http_handler.requests), 1)
         self.assertFalse(http_handler.requests[0].has_header(auth_header))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_prior_auth_auto_send(self):
         # Assume already authenticated if is_authenticated=True
         # for APIs like Github that don't return 401
@@ -1713,8 +1687,6 @@ def test_basic_prior_auth_auto_send(self):
         # expect request to be sent with auth header
         self.assertTrue(http_handler.has_auth_header)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_prior_auth_send_after_first_success(self):
         # Auto send auth header after authentication is successful once
 
diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile.py
index 0a50f036046..e7705590cd2 100644
--- a/Lib/test/test_zipfile.py
+++ b/Lib/test/test_zipfile.py
@@ -1746,8 +1746,6 @@ def test_empty_file_raises_BadZipFile(self):
             fp.write("short file")
         self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_negative_central_directory_offset_raises_BadZipFile(self):
         # Zip file containing an empty EOCD record
         buffer = bytearray(b'PK\x05\x06' + b'\0'*18)
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index d1fe5398634..1a01721391e 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -223,8 +223,8 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                         const METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_defs;
 
                         fn extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
-                            #impl_ty::__extend_slots(slots);
                             #with_slots
+                            #impl_ty::__extend_slots(slots);
                         }
                     }
                 }
@@ -1672,9 +1672,24 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
                             #extend_class(ctx, class);
                         });
                         with_method_defs.push(method_defs);
-                        with_slots.push(quote_spanned! { item_span =>
-                            #extend_slots(slots);
-                        });
+                        // For Initializer and Constructor traits, directly set the slot
+                        // instead of calling __extend_slots. This ensures that the trait
+                        // impl's override (e.g., slot_init in impl Initializer) is used,
+                        // not the trait's default implementation.
+                        let slot_code = if path.is_ident("Initializer") {
+                            quote_spanned! { item_span =>
+                                slots.init.store(Some(<Self as ::rustpython_vm::types::Initializer>::slot_init as _));
+                            }
+                        } else if path.is_ident("Constructor") {
+                            quote_spanned! { item_span =>
+                                slots.new.store(Some(<Self as ::rustpython_vm::types::Constructor>::slot_new as _));
+                            }
+                        } else {
+                            quote_spanned! { item_span =>
+                                #extend_slots(slots);
+                            }
+                        };
+                        with_slots.push(slot_code);
                     }
                 } else if path.is_ident("flags") {
                     for meta in nested {
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index ca208790f4b..77a1eff6c7d 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -120,44 +120,36 @@ impl Initializer for PyBaseObject {
 
     // object_init: excess_args validation
     fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        if args.is_empty() {
+            return Ok(());
+        }
+
         let typ = zelf.class();
         let object_type = &vm.ctx.types.object_type;
 
         let typ_init = typ.slots.init.load().map(|f| f as usize);
         let object_init = object_type.slots.init.load().map(|f| f as usize);
-        let typ_new = typ.slots.new.load().map(|f| f as usize);
-        let object_new = object_type.slots.new.load().map(|f| f as usize);
 
-        // For heap types (Python classes), check if __new__ is defined anywhere in MRO
-        // (before object) because heap types always have slots.new = new_wrapper via MRO
-        let is_heap_type = typ
-            .slots
-            .flags
-            .contains(crate::types::PyTypeFlags::HEAPTYPE);
-        let new_overridden = if is_heap_type {
-            // Check if __new__ is defined in any base class (excluding object)
-            let new_id = identifier!(vm, __new__);
-            typ.mro_collect()
-                .into_iter()
-                .take_while(|t| !std::ptr::eq(t.as_ref(), *object_type))
-                .any(|t| t.attributes.read().contains_key(new_id))
-        } else {
-            // For built-in types, use slot comparison
-            typ_new != object_new
-        };
-
-        // If both __init__ and __new__ are overridden, allow excess args
-        if typ_init != object_init && new_overridden {
-            return Ok(());
+        // if (type->tp_init != object_init) → first error
+        if typ_init != object_init {
+            return Err(vm.new_type_error(
+                "object.__init__() takes exactly one argument (the instance to initialize)"
+                    .to_owned(),
+            ));
         }
 
-        // Otherwise, reject excess args
-        if !args.is_empty() {
+        let typ_new = typ.slots.new.load().map(|f| f as usize);
+        let object_new = object_type.slots.new.load().map(|f| f as usize);
+
+        // if (type->tp_new == object_new) → second error
+        if typ_new == object_new {
             return Err(vm.new_type_error(format!(
                 "{}.__init__() takes exactly one argument (the instance to initialize)",
                 typ.name()
             )));
         }
+
+        // Both conditions false → OK (e.g., tuple, dict with custom __new__)
         Ok(())
     }
 
@@ -591,6 +583,13 @@ pub fn object_set_dict(obj: PyObjectRef, dict: PyDictRef, vm: &VirtualMachine) -
 }
 
 pub fn init(ctx: &Context) {
+    // Manually set init slot - derive macro doesn't generate extend_slots
+    // for trait impl that overrides #[pyslot] method
+    ctx.types
+        .object_type
+        .slots
+        .init
+        .store(Some(<PyBaseObject as Initializer>::slot_init));
     PyBaseObject::extend_class(ctx, ctx.types.object_type);
 }
 
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index ffaad324687..4f150d92589 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -25,8 +25,8 @@ use crate::{
     object::{Traverse, TraverseFn},
     protocol::{PyIterReturn, PyNumberMethods},
     types::{
-        AsNumber, Callable, Constructor, GetAttr, PyTypeFlags, PyTypeSlots, Representable, SetAttr,
-        TypeDataRef, TypeDataRefMut, TypeDataSlot,
+        AsNumber, Callable, Constructor, GetAttr, Initializer, PyTypeFlags, PyTypeSlots,
+        Representable, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
     },
 };
 use indexmap::{IndexMap, map::Entry};
@@ -412,8 +412,10 @@ impl PyType {
     }
 
     pub(crate) fn init_slots(&self, ctx: &Context) {
-        // Inherit slots from direct bases (not MRO)
-        for base in self.bases.read().iter() {
+        // Inherit slots from MRO
+        // Note: self.mro does NOT include self, so we iterate all elements
+        let mro: Vec<_> = self.mro.read().iter().cloned().collect();
+        for base in mro.iter() {
             self.inherit_slots(base);
         }
 
@@ -460,7 +462,7 @@ impl PyType {
         }
     }
 
-    /// Inherit slots from base type. typeobject.c: inherit_slots
+    /// Inherit slots from base type. inherit_slots
     pub(crate) fn inherit_slots(&self, base: &Self) {
         macro_rules! copyslot {
             ($slot:ident) => {
@@ -472,6 +474,28 @@ impl PyType {
             };
         }
 
+        // Copy init slot only if base actually defines it (not just inherited)
+        // This is needed for multiple inheritance where a later base might
+        // have a more specific init slot
+        macro_rules! copyslot_defined {
+            ($slot:ident) => {
+                if self.slots.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.$slot.load() {
+                        // SLOTDEFINED: base->SLOT && (basebase == NULL || base->SLOT != basebase->SLOT)
+                        let basebase = base.base.as_ref();
+                        let slot_defined = match basebase {
+                            None => true,
+                            Some(bb) => bb.slots.$slot.load().map(|v| v as usize)
+                                != Some(base_val as usize),
+                        };
+                        if slot_defined {
+                            self.slots.$slot.store(Some(base_val));
+                        }
+                    }
+                }
+            };
+        }
+
         // Core slots
         copyslot!(hash);
         copyslot!(call);
@@ -484,9 +508,8 @@ impl PyType {
         copyslot!(iternext);
         copyslot!(descr_get);
         copyslot!(descr_set);
-        // Note: init is NOT inherited here because object_init has special
-        // handling in CPython (checks if type->tp_init != object_init).
-        // TODO: implement proper init inheritance with object_init check
+        // init uses SLOTDEFINED check for multiple inheritance support
+        copyslot_defined!(init);
         copyslot!(del);
         // new is handled by set_new()
         // as_buffer is inherited at type creation time (not AtomicCell)
@@ -832,7 +855,16 @@ impl Py<PyType> {
 }
 
 #[pyclass(
-    with(Py, Constructor, GetAttr, SetAttr, Callable, AsNumber, Representable),
+    with(
+        Py,
+        Constructor,
+        Initializer,
+        GetAttr,
+        SetAttr,
+        Callable,
+        AsNumber,
+        Representable
+    ),
     flags(BASETYPE)
 )]
 impl PyType {
@@ -1532,6 +1564,26 @@ fn get_doc_from_internal_doc<'a>(name: &str, internal_doc: &'a str) -> &'a str {
     internal_doc
 }
 
+impl Initializer for PyType {
+    type Args = FuncArgs;
+
+    // type_init
+    fn slot_init(_zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        // type.__init__() takes 1 or 3 arguments
+        if args.args.len() == 1 && !args.kwargs.is_empty() {
+            return Err(vm.new_type_error("type.__init__() takes no keyword arguments".to_owned()));
+        }
+        if args.args.len() != 1 && args.args.len() != 3 {
+            return Err(vm.new_type_error("type.__init__() takes 1 or 3 arguments".to_owned()));
+        }
+        Ok(())
+    }
+
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        unreachable!("slot_init is defined")
+    }
+}
+
 impl GetAttr for PyType {
     fn getattro(zelf: &Py<Self>, name_str: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
         #[cold]
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index 645a3e779ff..b2dee206200 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -353,21 +353,13 @@ pub(super) mod types {
     impl Initializer for PyBaseExceptionGroup {
         type Args = FuncArgs;
 
-        fn slot_init(
-            _zelf: PyObjectRef,
-            _args: ::rustpython_vm::function::FuncArgs,
-            _vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
-            // CPython's BaseExceptionGroup.__init__ just calls BaseException.__init__
-            // which stores args as-is. Since __new__ already set up the correct args
-            // (message, exceptions_tuple), we don't need to do anything here.
-            // This also allows subclasses to pass extra arguments to __new__ without
-            // __init__ complaining about argument count.
+        fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
+            // No-op: __new__ already set up the correct args (message, exceptions_tuple)
             Ok(())
         }
 
         fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
-            unreachable!("slot_init is defined")
+            unreachable!("slot_init is overridden")
         }
     }
 
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 9402660a86e..a02965797bc 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -3679,23 +3679,31 @@ mod _io {
     }
 
     impl Constructor for StringIO {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
+                _base: Default::default(),
+                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(Vec::new()))),
+                closed: AtomicCell::new(false),
+            })
+        }
+    }
+
+    impl Initializer for StringIO {
         type Args = StringIONewArgs;
 
         #[allow(unused_variables)]
-        fn py_new(
-            _cls: &Py<PyType>,
+        fn init(
+            zelf: PyRef<Self>,
             Self::Args { object, newline }: Self::Args,
             _vm: &VirtualMachine,
-        ) -> PyResult<Self> {
+        ) -> PyResult<()> {
             let raw_bytes = object
                 .flatten()
                 .map_or_else(Vec::new, |v| v.as_bytes().to_vec());
-
-            Ok(Self {
-                _base: Default::default(),
-                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))),
-                closed: AtomicCell::new(false),
-            })
+            *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
+            Ok(())
         }
     }
 
@@ -3709,7 +3717,7 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(Constructor))]
+    #[pyclass(flags(BASETYPE, HAS_DICT), with(Constructor, Initializer))]
     impl StringIO {
         #[pymethod]
         const fn readable(&self) -> bool {
@@ -3814,22 +3822,35 @@ mod _io {
     }
 
     impl Constructor for BytesIO {
-        type Args = OptionalArg<Option<PyBytesRef>>;
-
-        fn py_new(_cls: &Py<PyType>, object: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-            let raw_bytes = object
-                .flatten()
-                .map_or_else(Vec::new, |input| input.as_bytes().to_vec());
+        type Args = FuncArgs;
 
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
             Ok(Self {
                 _base: Default::default(),
-                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))),
+                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(Vec::new()))),
                 closed: AtomicCell::new(false),
                 exports: AtomicCell::new(0),
             })
         }
     }
 
+    impl Initializer for BytesIO {
+        type Args = OptionalArg<Option<ArgBytesLike>>;
+
+        fn init(zelf: PyRef<Self>, object: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+            if zelf.exports.load() > 0 {
+                return Err(vm.new_buffer_error(
+                    "Existing exports of data: object cannot be re-sized".to_owned(),
+                ));
+            }
+            let raw_bytes = object
+                .flatten()
+                .map_or_else(Vec::new, |input| input.borrow_buf().to_vec());
+            *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
+            Ok(())
+        }
+    }
+
     impl BytesIO {
         fn buffer(&self, vm: &VirtualMachine) -> PyResult<PyRwLockWriteGuard<'_, BufferedIO>> {
             if !self.closed.load() {
@@ -3840,7 +3861,7 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(PyRef, Constructor))]
+    #[pyclass(flags(BASETYPE, HAS_DICT), with(PyRef, Constructor, Initializer))]
     impl BytesIO {
         #[pymethod]
         const fn readable(&self) -> bool {
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index bfe6e047622..13a43ed9c95 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -632,13 +632,48 @@ impl PyType {
                 update_slot!(descr_set, descr_set_wrapper);
             }
             _ if name == identifier!(ctx, __init__) => {
-                toggle_slot!(init, init_wrapper);
+                // Special handling: check if this type or any base has a real __init__ method
+                // If only slot wrappers exist, use the inherited slot from copyslot!
+                if ADD {
+                    // First check if this type has __init__ in its own dict
+                    let has_own_init = self.attributes.read().contains_key(name);
+                    if has_own_init {
+                        // This type defines __init__ - use wrapper
+                        self.slots.init.store(Some(init_wrapper));
+                    } else if self.has_real_method_in_mro(name, ctx) {
+                        // A base class defines a real __init__ method - use wrapper
+                        self.slots.init.store(Some(init_wrapper));
+                    }
+                    // else: keep inherited slot from copyslot!
+                } else {
+                    let inherited = self
+                        .mro
+                        .read()
+                        .iter()
+                        .skip(1)
+                        .find_map(|cls| cls.slots.init.load());
+                    self.slots.init.store(inherited);
+                }
             }
             _ if name == identifier!(ctx, __new__) => {
                 toggle_slot!(new, new_wrapper);
             }
             _ if name == identifier!(ctx, __del__) => {
-                toggle_slot!(del, del_wrapper);
+                // Same special handling as __init__
+                if ADD {
+                    let has_own_del = self.attributes.read().contains_key(name);
+                    if has_own_del || self.has_real_method_in_mro(name, ctx) {
+                        self.slots.del.store(Some(del_wrapper));
+                    }
+                } else {
+                    let inherited = self
+                        .mro
+                        .read()
+                        .iter()
+                        .skip(1)
+                        .find_map(|cls| cls.slots.del.load());
+                    self.slots.del.store(inherited);
+                }
             }
             _ if name == identifier!(ctx, __bool__) => {
                 toggle_sub_slot!(as_number, boolean, bool_wrapper);
@@ -890,6 +925,36 @@ impl PyType {
             _ => {}
         }
     }
+
+    /// Check if there's a real method (not a slot wrapper) for `name` anywhere in the MRO.
+    /// If a real method exists, we should use a wrapper function. Otherwise, use the inherited slot.
+    fn has_real_method_in_mro(&self, name: &'static PyStrInterned, ctx: &Context) -> bool {
+        use crate::builtins::descriptor::PySlotWrapper;
+
+        // Check the entire MRO (including self) for the method
+        for cls in self.mro.read().iter() {
+            if let Some(attr) = cls.attributes.read().get(name).cloned() {
+                // Found the method - check if it's a slot wrapper
+                if attr.class().is(ctx.types.wrapper_descriptor_type) {
+                    if let Some(wrapper) = attr.downcast_ref::<PySlotWrapper>() {
+                        // It's a slot wrapper - check if it belongs to this class
+                        let wrapper_typ: *const _ = wrapper.typ;
+                        let cls_ptr: *const _ = cls.as_ref();
+                        if wrapper_typ == cls_ptr {
+                            // Slot wrapper defined on this exact class - use inherited slot
+                            return false;
+                        }
+                    }
+                    // Inherited slot wrapper - continue checking MRO
+                } else {
+                    // Real method found - use wrapper function
+                    return true;
+                }
+            }
+        }
+        // No real method found in MRO - use inherited slot
+        false
+    }
 }
 
 /// Trait for types that can be constructed via Python's `__new__` method.
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index 0cd04a0ac17..9d164241676 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -199,8 +199,10 @@ impl TypeZoo {
     /// Fill attributes of builtin types.
     #[cold]
     pub(crate) fn extend(context: &Context) {
-        type_::init(context);
+        // object must be initialized before type to set object.slots.init,
+        // which type will inherit via inherit_slots()
         object::init(context);
+        type_::init(context);
         list::init(context);
         set::init(context);
         tuple::init(context);

From 72a90da13be2258a6f8c888a07582c932ca7c7cd Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 20:39:48 +0900
Subject: [PATCH 074/418] increase timeout-minutes to 45 (#6541)

---
 .github/workflows/ci.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 6dc9b75b138..dc5ce974e38 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -115,7 +115,7 @@ jobs:
       RUST_BACKTRACE: full
     name: Run rust tests
     runs-on:  ${{ matrix.os }}
-    timeout-minutes: ${{ contains(matrix.os, 'windows') && 45 || 35 }}
+    timeout-minutes: 45
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]

From 18564151967271b765189943c17c3ca3bddeebdf Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 21:38:05 +0900
Subject: [PATCH 075/418] Fix f-string conversion flag ValueError when
 compiling AST (#6533) (#6534)

The ast_from_object for ConversionFlag was using bytecode::ConvertValueOparg::from_op_arg()
which only accepts internal oparg values (0, 1, 2, 3, 255), but Python's AST uses ASCII codes
('s'=115, 'r'=114, 'a'=97, -1=None).

This caused compile() on parsed AST with conversion flags to fail with "invalid conversion flag".
---
 crates/vm/src/stdlib/ast.rs       |  1 -
 crates/vm/src/stdlib/ast/other.rs | 22 ++++++++++------------
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
index 8e03cb225ea..b8df86fb091 100644
--- a/crates/vm/src/stdlib/ast.rs
+++ b/crates/vm/src/stdlib/ast.rs
@@ -15,7 +15,6 @@ use crate::{
     builtins::PyIntRef,
     builtins::{PyDict, PyModule, PyStrRef, PyType},
     class::{PyClassImpl, StaticType},
-    compiler::core::bytecode::OpArgType,
     compiler::{CompileError, ParseError},
     convert::ToPyObject,
 };
diff --git a/crates/vm/src/stdlib/ast/other.rs b/crates/vm/src/stdlib/ast/other.rs
index cf8a8319749..ce7d5fe4807 100644
--- a/crates/vm/src/stdlib/ast/other.rs
+++ b/crates/vm/src/stdlib/ast/other.rs
@@ -1,6 +1,5 @@
 use super::*;
-use num_traits::ToPrimitive;
-use rustpython_compiler_core::{SourceFile, bytecode};
+use rustpython_compiler_core::SourceFile;
 
 impl Node for ruff::ConversionFlag {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
@@ -12,16 +11,15 @@ impl Node for ruff::ConversionFlag {
         _source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        i32::try_from_object(vm, object)?
-            .to_u32()
-            .and_then(bytecode::ConvertValueOparg::from_op_arg)
-            .map(|flag| match flag {
-                bytecode::ConvertValueOparg::None => Self::None,
-                bytecode::ConvertValueOparg::Str => Self::Str,
-                bytecode::ConvertValueOparg::Repr => Self::Repr,
-                bytecode::ConvertValueOparg::Ascii => Self::Ascii,
-            })
-            .ok_or_else(|| vm.new_value_error("invalid conversion flag"))
+        // Python's AST uses ASCII codes: 's', 'r', 'a', -1=None
+        // Note: 255 is -1i8 as u8 (ruff's ConversionFlag::None)
+        match i32::try_from_object(vm, object)? {
+            -1 | 255 => Ok(Self::None),
+            x if x == b's' as i32 => Ok(Self::Str),
+            x if x == b'r' as i32 => Ok(Self::Repr),
+            x if x == b'a' as i32 => Ok(Self::Ascii),
+            _ => Err(vm.new_value_error("invalid conversion flag")),
+        }
     }
 }
 

From 57b4b4ae4520521971cadf705c2fa294e7189f72 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 21:43:00 +0900
Subject: [PATCH 076/418] fix sys path (#6537)

---
 Lib/test/test_cmd_line_script.py |  4 ----
 src/lib.rs                       | 29 +++++++++++++++++++----------
 src/settings.rs                  |  1 +
 3 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index d773674feef..122c4ac16d4 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -411,8 +411,6 @@ def test_issue8202(self):
                                    script_name, script_name, script_dir, 'test_pkg',
                                    importlib.machinery.SourceFileLoader)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_issue8202_dash_c_file_ignored(self):
         # Make sure a "-c" file in the current directory
         # does not alter the value of sys.path[0]
@@ -713,8 +711,6 @@ def test_syntaxerror_null_bytes_in_multiline_string(self):
                     ]
                 )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_consistent_sys_path_for_direct_execution(self):
         # This test case ensures that the following all give the same
         # sys.path configuration:
diff --git a/src/lib.rs b/src/lib.rs
index 8d278058933..8ee22d4eb5a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -169,16 +169,9 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
 
     let scope = setup_main_module(vm)?;
 
-    if !vm.state.config.settings.safe_path {
-        // TODO: The prepending path depends on running mode
-        // See https://docs.python.org/3/using/cmdline.html#cmdoption-P
-        vm.run_code_string(
-            vm.new_scope_with_builtins(),
-            "import sys; sys.path.insert(0, '')",
-            "<embedded>".to_owned(),
-        )?;
-    }
-
+    // Import site first, before setting sys.path[0]
+    // This matches CPython's behavior where site.removeduppaths() runs
+    // before sys.path[0] is set, preventing '' from being converted to cwd
     let site_result = vm.import("site", 0);
     if site_result.is_err() {
         warn!(
@@ -187,6 +180,22 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         );
     }
 
+    // _PyPathConfig_ComputeSysPath0 - set sys.path[0] after site import
+    if !vm.state.config.settings.safe_path {
+        let path0: Option<String> = match &run_mode {
+            RunMode::Command(_) => Some(String::new()),
+            RunMode::Module(_) => env::current_dir()
+                .ok()
+                .and_then(|p| p.to_str().map(|s| s.to_owned())),
+            RunMode::Script(_) | RunMode::InstallPip(_) => None, // handled by run_script
+            RunMode::Repl => Some(String::new()),
+        };
+
+        if let Some(path) = path0 {
+            vm.insert_sys_path(vm.new_pyobj(path))?;
+        }
+    }
+
     // Enable faulthandler if -X faulthandler, PYTHONFAULTHANDLER or -X dev is set
     // _PyFaulthandler_Init()
     if vm.state.config.settings.faulthandler {
diff --git a/src/settings.rs b/src/settings.rs
index f77db4d159d..a63f1a07ccc 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -339,6 +339,7 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
 /// Helper function to retrieve a sequence of paths from an environment variable.
 fn get_paths(env_variable_name: &str) -> impl Iterator<Item = String> + '_ {
     env::var_os(env_variable_name)
+        .filter(|v| !v.is_empty())
         .into_iter()
         .flat_map(move |paths| {
             split_paths(&paths)

From 4a6e8fb29edfe09827e529aca2d1ac4c1b1c51d7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 21:54:23 +0900
Subject: [PATCH 077/418] Add except* support (#6530)

---
 .cspell.dict/python-more.txt               |   1 +
 Lib/test/test_compile.py                   |   6 -
 crates/codegen/src/compile.rs              | 157 ++++++++++++++++++++-
 crates/compiler-core/src/bytecode.rs       |   7 +-
 crates/vm/src/exceptions.rs                | 124 ++++++++++++++++
 crates/vm/src/frame.rs                     |  15 ++
 extra_tests/snippets/builtin_exceptions.py |  12 ++
 7 files changed, 308 insertions(+), 14 deletions(-)

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index e8534e9744a..d381bfe1e03 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -199,6 +199,7 @@ readbuffer
 reconstructor
 refcnt
 releaselevel
+reraised
 reverseitemiterator
 reverseiterator
 reversekeyiterator
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index e4d335a193d..3ea09354c3c 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1536,8 +1536,6 @@ def test_try_except_as(self):
             """
         self.check_stack_size(snippet)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_try_except_star_qualified(self):
         snippet = """
             try:
@@ -1549,8 +1547,6 @@ def test_try_except_star_qualified(self):
             """
         self.check_stack_size(snippet)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_try_except_star_as(self):
         snippet = """
             try:
@@ -1562,8 +1558,6 @@ def test_try_except_star_as(self):
             """
         self.check_stack_size(snippet)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_try_except_star_finally(self):
         snippet = """
                 try:
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 0131b3008e3..53cd81a4f42 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1510,7 +1510,7 @@ impl Compiler {
                 ..
             }) => {
                 if *is_star {
-                    self.compile_try_star_statement(body, handlers, orelse, finalbody)?
+                    self.compile_try_star_except(body, handlers, orelse, finalbody)?
                 } else {
                     self.compile_try_statement(body, handlers, orelse, finalbody)?
                 }
@@ -2119,14 +2119,157 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_try_star_statement(
+    fn compile_try_star_except(
         &mut self,
-        _body: &[Stmt],
-        _handlers: &[ExceptHandler],
-        _orelse: &[Stmt],
-        _finalbody: &[Stmt],
+        body: &[Stmt],
+        handlers: &[ExceptHandler],
+        orelse: &[Stmt],
+        finalbody: &[Stmt],
     ) -> CompileResult<()> {
-        Err(self.error(CodegenErrorType::NotImplementedYet))
+        // Simplified except* implementation using CheckEgMatch
+        let handler_block = self.new_block();
+        let finally_block = self.new_block();
+
+        if !finalbody.is_empty() {
+            emit!(
+                self,
+                Instruction::SetupFinally {
+                    handler: finally_block,
+                }
+            );
+        }
+
+        let else_block = self.new_block();
+
+        emit!(
+            self,
+            Instruction::SetupExcept {
+                handler: handler_block,
+            }
+        );
+        self.compile_statements(body)?;
+        emit!(self, Instruction::PopBlock);
+        emit!(self, Instruction::Jump { target: else_block });
+
+        self.switch_to_block(handler_block);
+        // Stack: [exc]
+
+        for handler in handlers {
+            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
+                type_, name, body, ..
+            }) = handler;
+
+            let skip_block = self.new_block();
+            let next_block = self.new_block();
+
+            // Compile exception type
+            if let Some(exc_type) = type_ {
+                // Check for unparenthesized tuple (e.g., `except* A, B:` instead of `except* (A, B):`)
+                if let Expr::Tuple(ExprTuple { elts, range, .. }) = exc_type.as_ref()
+                    && let Some(first) = elts.first()
+                    && range.start().to_u32() == first.range().start().to_u32()
+                {
+                    return Err(self.error(CodegenErrorType::SyntaxError(
+                        "multiple exception types must be parenthesized".to_owned(),
+                    )));
+                }
+                self.compile_expression(exc_type)?;
+            } else {
+                return Err(self.error(CodegenErrorType::SyntaxError(
+                    "except* must specify an exception type".to_owned(),
+                )));
+            }
+            // Stack: [exc, type]
+
+            emit!(self, Instruction::CheckEgMatch);
+            // Stack: [rest, match]
+
+            // Check if match is None (truthy check)
+            emit!(self, Instruction::CopyItem { index: 1 });
+            emit!(self, Instruction::ToBool);
+            emit!(self, Instruction::PopJumpIfFalse { target: skip_block });
+
+            // Handler matched - store match to name if provided
+            // Stack: [rest, match]
+            if let Some(alias) = name {
+                self.store_name(alias.as_str())?;
+            } else {
+                emit!(self, Instruction::PopTop);
+            }
+            // Stack: [rest]
+
+            self.compile_statements(body)?;
+
+            if let Some(alias) = name {
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            emit!(self, Instruction::Jump { target: next_block });
+
+            // No match - pop match (None) and continue with rest
+            self.switch_to_block(skip_block);
+            emit!(self, Instruction::PopTop); // drop match (None)
+            // Stack: [rest]
+
+            self.switch_to_block(next_block);
+            // Stack: [rest] - continue with rest for next handler
+        }
+
+        let handled_block = self.new_block();
+
+        // Check if remainder is truthy (has unhandled exceptions)
+        // Stack: [rest]
+        emit!(self, Instruction::CopyItem { index: 1 });
+        emit!(self, Instruction::ToBool);
+        emit!(
+            self,
+            Instruction::PopJumpIfFalse {
+                target: handled_block
+            }
+        );
+        // Reraise unhandled exceptions
+        emit!(
+            self,
+            Instruction::Raise {
+                kind: bytecode::RaiseKind::Raise
+            }
+        );
+
+        // All exceptions handled
+        self.switch_to_block(handled_block);
+        emit!(self, Instruction::PopTop); // drop remainder (None)
+        emit!(self, Instruction::PopException);
+
+        if !finalbody.is_empty() {
+            emit!(self, Instruction::PopBlock);
+            emit!(self, Instruction::EnterFinally);
+        }
+
+        emit!(
+            self,
+            Instruction::Jump {
+                target: finally_block,
+            }
+        );
+
+        // try-else path
+        self.switch_to_block(else_block);
+        self.compile_statements(orelse)?;
+
+        if !finalbody.is_empty() {
+            emit!(self, Instruction::PopBlock);
+            emit!(self, Instruction::EnterFinally);
+        }
+
+        self.switch_to_block(finally_block);
+        if !finalbody.is_empty() {
+            self.compile_statements(finalbody)?;
+            emit!(self, Instruction::EndFinally);
+        }
+
+        Ok(())
     }
 
     fn is_forbidden_arg_name(name: &str) -> bool {
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index dd49e679f27..add2c1c2f63 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -574,7 +574,7 @@ op_arg_enum!(
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
     #[repr(u8)]
     pub enum IntrinsicFunction2 {
-        // PrepReraiseS tar = 1,
+        PrepReraiseStar = 1,
         TypeVarWithBound = 2,
         TypeVarWithConstraint = 3,
         SetFunctionTypeParams = 4,
@@ -652,6 +652,9 @@ pub enum Instruction {
     CallMethodPositional {
         nargs: Arg<u32>,
     },
+    /// Check if exception matches except* handler type.
+    /// Pops exc_value and match_type, pushes (rest, match).
+    CheckEgMatch,
     CompareOperation {
         op: Arg<ComparisonOperator>,
     },
@@ -1721,6 +1724,7 @@ impl Instruction {
             CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
             CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
             CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
+            CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
             ConvertValue { .. } => 0,
             FormatSimple => 0,
             FormatWithSpec => -1,
@@ -1887,6 +1891,7 @@ impl Instruction {
             CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
             CallMethodKeyword { nargs } => w!(CALL_METHOD_KEYWORD, nargs),
             CallMethodPositional { nargs } => w!(CALL_METHOD_POSITIONAL, nargs),
+            CheckEgMatch => w!(CHECK_EG_MATCH),
             CompareOperation { op } => w!(COMPARE_OPERATION, ?op),
             ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
             Continue { target } => w!(CONTINUE, target),
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 8d6ce6142b4..7b8af83489e 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -2432,3 +2432,127 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyEncodingWarning(PyWarning);
 }
+
+/// Match exception against except* handler type.
+/// Returns (rest, match) tuple.
+pub fn exception_group_match(
+    exc_value: &PyObjectRef,
+    match_type: &PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, PyObjectRef)> {
+    // Implements _PyEval_ExceptionGroupMatch
+
+    // If exc_value is None, return (None, None)
+    if vm.is_none(exc_value) {
+        return Ok((vm.ctx.none(), vm.ctx.none()));
+    }
+
+    // Check if exc_value matches match_type
+    if exc_value.is_instance(match_type, vm)? {
+        // Full match of exc itself
+        let is_eg = exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group);
+        let matched = if is_eg {
+            exc_value.clone()
+        } else {
+            // Naked exception - wrap it in ExceptionGroup
+            let excs = vm.ctx.new_tuple(vec![exc_value.clone()]);
+            let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+            let wrapped = eg_type.call((vm.ctx.new_str(""), excs), vm)?;
+            // Copy traceback from original exception
+            if let Ok(exc) = exc_value.clone().downcast::<types::PyBaseException>()
+                && let Some(tb) = exc.__traceback__()
+                && let Ok(wrapped_exc) = wrapped.clone().downcast::<types::PyBaseException>()
+            {
+                let _ = wrapped_exc.set___traceback__(tb.into(), vm);
+            }
+            wrapped
+        };
+        return Ok((vm.ctx.none(), matched));
+    }
+
+    // Check for partial match if it's an exception group
+    if exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        let pair = vm.call_method(exc_value, "split", (match_type.clone(),))?;
+        let pair_tuple: PyTupleRef = pair.try_into_value(vm)?;
+        if pair_tuple.len() < 2 {
+            return Err(vm.new_type_error(format!(
+                "{}.split must return a 2-tuple, got tuple of size {}",
+                exc_value.class().name(),
+                pair_tuple.len()
+            )));
+        }
+        let matched = pair_tuple[0].clone();
+        let rest = pair_tuple[1].clone();
+        return Ok((rest, matched));
+    }
+
+    // No match
+    Ok((exc_value.clone(), vm.ctx.none()))
+}
+
+/// Prepare exception for reraise in except* block.
+pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Implements _PyExc_PrepReraiseStar
+    use crate::builtins::PyList;
+
+    let excs_list = excs
+        .downcast::<PyList>()
+        .map_err(|_| vm.new_type_error("expected list for prep_reraise_star"))?;
+
+    let excs_vec: Vec<PyObjectRef> = excs_list.borrow_vec().to_vec();
+
+    // Filter out None values
+    let mut raised: Vec<PyObjectRef> = Vec::new();
+    let mut reraised: Vec<PyObjectRef> = Vec::new();
+
+    for exc in excs_vec {
+        if vm.is_none(&exc) {
+            continue;
+        }
+        // Check if this exception was in the original exception group
+        if !vm.is_none(&orig) && is_same_exception_metadata(&exc, &orig, vm) {
+            reraised.push(exc);
+        } else {
+            raised.push(exc);
+        }
+    }
+
+    // If no exceptions to reraise, return None
+    if raised.is_empty() && reraised.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Combine raised and reraised exceptions
+    let mut all_excs = raised;
+    all_excs.extend(reraised);
+
+    if all_excs.len() == 1 {
+        // If only one exception, just return it
+        return Ok(all_excs.into_iter().next().unwrap());
+    }
+
+    // Create new ExceptionGroup
+    let excs_tuple = vm.ctx.new_tuple(all_excs);
+    let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+    eg_type.call((vm.ctx.new_str(""), excs_tuple), vm)
+}
+
+/// Check if two exceptions have the same metadata (for reraise detection)
+fn is_same_exception_metadata(exc1: &PyObjectRef, exc2: &PyObjectRef, vm: &VirtualMachine) -> bool {
+    // Check if exc1 is part of exc2's exception group
+    if exc2.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        let exc_class: PyObjectRef = exc1.class().to_owned().into();
+        if let Ok(result) = vm.call_method(exc2, "subgroup", (exc_class,))
+            && !vm.is_none(&result)
+            && let Ok(subgroup_excs) = result.get_attr("exceptions", vm)
+            && let Ok(tuple) = subgroup_excs.downcast::<PyTuple>()
+        {
+            for e in tuple.iter() {
+                if e.is(exc1) {
+                    return true;
+                }
+            }
+        }
+    }
+    exc1.is(exc2)
+}
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index e9a938ba023..6cb41f41d93 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -691,6 +691,15 @@ impl ExecutingFrame<'_> {
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_method_call(args, vm)
             }
+            bytecode::Instruction::CheckEgMatch => {
+                let match_type = self.pop_value();
+                let exc_value = self.pop_value();
+                let (rest, matched) =
+                    crate::exceptions::exception_group_match(&exc_value, &match_type, vm)?;
+                self.push_value(rest);
+                self.push_value(matched);
+                Ok(None)
+            }
             bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
             bytecode::Instruction::ContainsOp(invert) => {
                 let b = self.pop_value();
@@ -2494,6 +2503,12 @@ impl ExecutingFrame<'_> {
                         .into();
                 Ok(type_var)
             }
+            bytecode::IntrinsicFunction2::PrepReraiseStar => {
+                // arg1 = orig (original exception)
+                // arg2 = excs (list of exceptions raised/reraised in except* blocks)
+                // Returns: exception to reraise, or None if nothing to reraise
+                crate::exceptions::prep_reraise_star(arg1, arg2, vm)
+            }
         }
     }
 
diff --git a/extra_tests/snippets/builtin_exceptions.py b/extra_tests/snippets/builtin_exceptions.py
index 0af5cf05eaf..246be3b8fda 100644
--- a/extra_tests/snippets/builtin_exceptions.py
+++ b/extra_tests/snippets/builtin_exceptions.py
@@ -366,3 +366,15 @@ class SubError(MyError):
     vars(builtins).values(),
 ):
     assert isinstance(exc.__doc__, str)
+
+
+# except* handling should normalize non-group exceptions
+try:
+    raise ValueError("x")
+except* ValueError as err:
+    assert isinstance(err, ExceptionGroup)
+    assert len(err.exceptions) == 1
+    assert isinstance(err.exceptions[0], ValueError)
+    assert err.exceptions[0].args == ("x",)
+else:
+    assert False, "except* handler did not run"

From 7f4d308efc0ac13396997e98e7b4bdd868bba237 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 26 Dec 2025 22:13:00 +0900
Subject: [PATCH 078/418] Implement maybe_pyc_file and .pyc file execution
 (#6539)

* Implement maybe_pyc_file and .pyc file execution

* unmark failing tests
---
 Lib/test/test_cmd_line_script.py              |   2 -
 Lib/test/test_compileall.py                   |  10 --
 .../test_importlib/source/test_file_loader.py | 120 ------------------
 Lib/test/test_importlib/test_util.py          |   9 --
 crates/vm/src/import.rs                       |  11 --
 crates/vm/src/stdlib/imp.rs                   |   5 +-
 crates/vm/src/version.rs                      |  11 ++
 crates/vm/src/vm/compile.rs                   |  60 ++++++++-
 8 files changed, 69 insertions(+), 159 deletions(-)

diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index 122c4ac16d4..9fc240de818 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -247,8 +247,6 @@ def test_script_abspath(self):
                                script_dir, None,
                                importlib.machinery.SourceFileLoader)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_script_compiled(self):
         with os_helper.temp_dir() as script_dir:
             script_name = _make_test_script(script_dir, 'script')
diff --git a/Lib/test/test_compileall.py b/Lib/test/test_compileall.py
index f84e67e9cf6..9fa3dbc47e5 100644
--- a/Lib/test/test_compileall.py
+++ b/Lib/test/test_compileall.py
@@ -325,8 +325,6 @@ def _test_ddir_only(self, *, ddir, parallel=True):
             self.assertEqual(mod_code_obj.co_filename, expected_in)
             self.assertIn(f'"{expected_in}"', os.fsdecode(err))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ddir_only_one_worker(self):
         """Recursive compile_dir ddir= contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="<a prefix>", parallel=False)
@@ -336,8 +334,6 @@ def test_ddir_multiple_workers(self):
         """Recursive compile_dir ddir= contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="<a prefix>", parallel=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ddir_empty_only_one_worker(self):
         """Recursive compile_dir ddir='' contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="", parallel=False)
@@ -347,8 +343,6 @@ def test_ddir_empty_multiple_workers(self):
         """Recursive compile_dir ddir='' contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="", parallel=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_only(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
@@ -408,8 +402,6 @@ def test_prepend_only(self):
             str(err, encoding=sys.getdefaultencoding())
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_and_prepend(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
@@ -887,8 +879,6 @@ def test_workers_available_cores(self, compile_dir):
             self.assertTrue(compile_dir.called)
             self.assertEqual(compile_dir.call_args[-1]['workers'], 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_and_prepend(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py
index d487fc9b82d..fa0efee8da6 100644
--- a/Lib/test/test_importlib/source/test_file_loader.py
+++ b/Lib/test/test_importlib/source/test_file_loader.py
@@ -359,24 +359,6 @@ def test_overridden_unchecked_hash_based_pyc(self):
  ) = util.test_both(SimpleTest, importlib=importlib, machinery=machinery,
                     abc=importlib_abc, util=importlib_util)
 
-# TODO: RUSTPYTHON, get rid of this entire class when all of the following tests are fixed
-class Source_SimpleTest(Source_SimpleTest):
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_checked_hash_based_pyc(self):
-        super().test_checked_hash_based_pyc()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_unchecked_hash_based_pyc(self):
-        super().test_unchecked_hash_based_pyc()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_overridden_unchecked_hash_based_pyc(self):
-        super().test_overridden_unchecked_hash_based_pyc()
-
-
 class SourceDateEpochTestMeta(SourceDateEpochTestMeta,
                               type(Source_SimpleTest)):
     pass
@@ -697,24 +679,6 @@ class SourceLoaderBadBytecodeTestPEP451(
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
-# TODO: RUSTPYTHON, get rid of this entire class when all of the following tests are fixed
-class Source_SourceBadBytecodePEP451(Source_SourceBadBytecodePEP451):
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_bad_marshal(self):
-        super().test_bad_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_no_marshal(self):
-        super().test_no_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_non_code_marshal(self):
-        super().test_non_code_marshal()
-
-
 class SourceLoaderBadBytecodeTestPEP302(
         SourceLoaderBadBytecodeTest, BadBytecodeTestPEP302):
     pass
@@ -726,24 +690,6 @@ class SourceLoaderBadBytecodeTestPEP302(
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
-# TODO: RUSTPYTHON, get rid of this entire class when all of the following tests are fixed
-class Source_SourceBadBytecodePEP302(Source_SourceBadBytecodePEP302):
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_bad_marshal(self):
-        super().test_bad_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_no_marshal(self):
-        super().test_no_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_non_code_marshal(self):
-        super().test_non_code_marshal()
-
-
 class SourcelessLoaderBadBytecodeTest:
 
     @classmethod
@@ -829,39 +775,6 @@ class SourcelessLoaderBadBytecodeTestPEP451(SourcelessLoaderBadBytecodeTest,
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
-# TODO: RUSTPYTHON, get rid of this entire class when all of the following tests are fixed
-class Source_SourcelessBadBytecodePEP451(Source_SourcelessBadBytecodePEP451):
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_magic_only(self):
-        super().test_magic_only()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_no_marshal(self):
-        super().test_no_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_flags(self):
-        super().test_partial_flags()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_hash(self):
-        super().test_partial_hash()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_size(self):
-        super().test_partial_size()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_timestamp(self):
-        super().test_partial_timestamp()
-
-
 class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
         BadBytecodeTestPEP302):
     pass
@@ -873,38 +786,5 @@ class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
                     machinery=machinery, abc=importlib_abc,
                     util=importlib_util)
 
-# TODO: RUSTPYTHON, get rid of this entire class when all of the following tests are fixed
-class Source_SourcelessBadBytecodePEP302(Source_SourcelessBadBytecodePEP302):
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_magic_only(self):
-        super().test_magic_only()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_no_marshal(self):
-        super().test_no_marshal()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_flags(self):
-        super().test_partial_flags()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_hash(self):
-        super().test_partial_hash()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_size(self):
-        super().test_partial_size()
-
-    # TODO: RUSTPYTHON, get rid of all three of the following lines when this test is fixed
-    @unittest.expectedFailure
-    def test_partial_timestamp(self):
-        super().test_partial_timestamp()
-
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 201f5069114..87b7de9889b 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -327,15 +327,6 @@ def test_incorporates_rn(self):
  ) = util.test_both(MagicNumberTests, util=importlib_util)
 
 
-# TODO: RUSTPYTHON
-@unittest.expectedFailure
-def test_incorporates_rn_MONKEYPATCH(self):
-    self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
-
-# TODO: RUSTPYTHON
-Frozen_MagicNumberTests.test_incorporates_rn = test_incorporates_rn_MONKEYPATCH
-
-
 class PEP3147Tests:
 
     """Tests of PEP 3147-related functions: cache_from_source and source_from_cache."""
diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index 39748655e0f..f970a335aa5 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -5,7 +5,6 @@ use crate::{
     builtins::{PyCode, list, traceback::PyTraceback},
     exceptions::types::PyBaseException,
     scope::Scope,
-    version::get_git_revision,
     vm::{VirtualMachine, thread},
 };
 
@@ -44,16 +43,6 @@ pub(crate) fn init_importlib_package(vm: &VirtualMachine, importlib: PyObjectRef
 
         let install_external = importlib.get_attr("_install_external_importers", vm)?;
         install_external.call((), vm)?;
-        // Set pyc magic number to commit hash. Should be changed when bytecode will be more stable.
-        let importlib_external = vm.import("_frozen_importlib_external", 0)?;
-        let mut magic = get_git_revision().into_bytes();
-        magic.truncate(4);
-        if magic.len() != 4 {
-            // os_random is expensive, but this is only ever called once
-            magic = rustpython_common::rand::os_random::<4>().to_vec();
-        }
-        let magic: PyObjectRef = vm.ctx.new_bytes(magic).into();
-        importlib_external.set_attr("MAGIC_NUMBER", magic, vm)?;
         let zipimport_res = (|| -> PyResult<()> {
             let zipimport = vm.import("zipimport", 0)?;
             let zipimporter = zipimport.get_attr("zipimporter", vm)?;
diff --git a/crates/vm/src/stdlib/imp.rs b/crates/vm/src/stdlib/imp.rs
index 76b3bfd124c..df32b0c0068 100644
--- a/crates/vm/src/stdlib/imp.rs
+++ b/crates/vm/src/stdlib/imp.rs
@@ -85,7 +85,7 @@ mod _imp {
         PyObjectRef, PyRef, PyResult, VirtualMachine,
         builtins::{PyBytesRef, PyCode, PyMemoryView, PyModule, PyStrRef},
         function::OptionalArg,
-        import,
+        import, version,
     };
 
     #[pyattr]
@@ -94,6 +94,9 @@ mod _imp {
             .new_str(vm.state.config.settings.check_hash_pycs_mode.to_string())
     }
 
+    #[pyattr(name = "pyc_magic_number_token")]
+    use version::PYC_MAGIC_NUMBER_TOKEN;
+
     #[pyfunction]
     const fn extension_suffixes() -> PyResult<Vec<PyObjectRef>> {
         Ok(Vec::new())
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index deb3dccd535..0a598842a56 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -126,3 +126,14 @@ pub fn get_git_datetime() -> String {
 
     format!("{date} {time}")
 }
+
+// Must be aligned to Lib/importlib/_bootstrap_external.py
+pub const PYC_MAGIC_NUMBER: u16 = 3531;
+
+// CPython format: magic_number | ('\r' << 16) | ('\n' << 24)
+// This protects against text-mode file reads
+pub const PYC_MAGIC_NUMBER_TOKEN: u32 =
+    (PYC_MAGIC_NUMBER as u32) | ((b'\r' as u32) << 16) | ((b'\n' as u32) << 24);
+
+/// Magic number as little-endian bytes for .pyc files
+pub const PYC_MAGIC_NUMBER_BYTES: [u8; 4] = PYC_MAGIC_NUMBER_TOKEN.to_le_bytes();
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index a7e31cf0377..b5f10e47aa1 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -75,13 +75,20 @@ impl VirtualMachine {
         // Consider to use enum to distinguish `path`
         // https://github.com/RustPython/RustPython/pull/6276#discussion_r2529849479
 
-        // TODO: check .pyc here
-        let pyc = false;
+        let pyc = maybe_pyc_file(path);
         if pyc {
-            todo!("running pyc is not implemented yet");
+            // pyc file execution
+            set_main_loader(&module_dict, path, "SourcelessFileLoader", self)?;
+            let loader = module_dict.get_item("__loader__", self)?;
+            let get_code = loader.get_attr("get_code", self)?;
+            let code_obj = get_code.call((identifier!(self, __main__).to_owned(),), self)?;
+            let code = code_obj
+                .downcast::<PyCode>()
+                .map_err(|_| self.new_runtime_error("Bad code object in .pyc file".to_owned()))?;
+            self.run_code_obj(code, scope)?;
         } else {
             if path != "<stdin>" {
-                set_main_loader(&module_dict, path, self)?;
+                set_main_loader(&module_dict, path, "SourceFileLoader", self)?;
             }
             // TODO: replace to something equivalent to py_run_file
             match std::fs::read_to_string(path) {
@@ -125,16 +132,57 @@ impl VirtualMachine {
     }
 }
 
-fn set_main_loader(module_dict: &PyDictRef, filename: &str, vm: &VirtualMachine) -> PyResult<()> {
+fn set_main_loader(
+    module_dict: &PyDictRef,
+    filename: &str,
+    loader_name: &str,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
     vm.import("importlib.machinery", 0)?;
     let sys_modules = vm.sys_module.get_attr(identifier!(vm, modules), vm)?;
     let machinery = sys_modules.get_item("importlib.machinery", vm)?;
-    let loader_class = machinery.get_attr("SourceFileLoader", vm)?;
+    let loader_name = vm.ctx.new_str(loader_name);
+    let loader_class = machinery.get_attr(&loader_name, vm)?;
     let loader = loader_class.call((identifier!(vm, __main__).to_owned(), filename), vm)?;
     module_dict.set_item("__loader__", loader, vm)?;
     Ok(())
 }
 
+/// Check whether a file is maybe a pyc file.
+///
+/// Detection is performed by:
+/// 1. Checking if the filename ends with ".pyc"
+/// 2. If not, reading the first 2 bytes and comparing with the magic number
+fn maybe_pyc_file(path: &str) -> bool {
+    // 1. Check if filename ends with ".pyc"
+    if path.ends_with(".pyc") {
+        return true;
+    }
+    maybe_pyc_file_with_magic(path, &crate::version::PYC_MAGIC_NUMBER_BYTES).unwrap_or(false)
+}
+
+fn maybe_pyc_file_with_magic(path: &str, magic_number: &[u8]) -> std::io::Result<bool> {
+    // part of maybe_pyc_file
+    // For non-.pyc extension, check magic number
+    let path_obj = std::path::Path::new(path);
+    if !path_obj.is_file() {
+        return Ok(false);
+    }
+
+    let mut file = std::fs::File::open(path)?;
+    let mut buf = [0u8; 2];
+
+    use std::io::Read;
+    if file.read(&mut buf)? != 2 || magic_number.len() < 2 {
+        return Ok(false);
+    }
+
+    // Read only two bytes of the magic. If the file was opened in
+    // text mode, the bytes 3 and 4 of the magic (\r\n) might not
+    // be read as they are on disk.
+    Ok(buf == magic_number[..2])
+}
+
 fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
     let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
     let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;

From b704f42158e8be9a5de781497585207b3f8f576e Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 26 Dec 2025 16:16:16 +0100
Subject: [PATCH 079/418] Reduce usage `JumpIfTrueOrPop` & `JumpIfFalseOrPop`
 opcdes. Refactor `compile_compare` (#6524)

* Remove `JumpIfTrueOrPop` & `JumpIfFalseOrPop` opcdes

* Use correct instruction name

* Extract `compile_cmpop` to its own method

* Better alignment with CPython code

* Restore `PopJumpIf` instructions

* Revert PopJumpIfFalse for comparisons
---
 crates/codegen/src/compile.rs | 149 ++++++++++++++++++----------------
 1 file changed, 80 insertions(+), 69 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 53cd81a4f42..4a0ef83a57e 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4173,7 +4173,9 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::JumpIfFalseOrPop { target: end });
+                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::PopJumpIfFalse { target: end });
+                emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
         }
@@ -4187,92 +4189,97 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_chained_comparison(
+    /// [CPython `compiler_addcompare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L2880-L2924)
+    fn compile_addcompare(&mut self, op: &CmpOp) {
+        use bytecode::ComparisonOperator::*;
+        match op {
+            CmpOp::Eq => emit!(self, Instruction::CompareOperation { op: Equal }),
+            CmpOp::NotEq => emit!(self, Instruction::CompareOperation { op: NotEqual }),
+            CmpOp::Lt => emit!(self, Instruction::CompareOperation { op: Less }),
+            CmpOp::LtE => emit!(self, Instruction::CompareOperation { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, Instruction::CompareOperation { op: Greater }),
+            CmpOp::GtE => {
+                emit!(self, Instruction::CompareOperation { op: GreaterOrEqual })
+            }
+            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
+            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
+            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
+            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+        }
+    }
+
+    /// Compile a chained comparison.
+    ///
+    /// ```py
+    /// a == b == c == d
+    /// ```
+    ///
+    /// Will compile into (pseudo code):
+    ///
+    /// ```py
+    /// result = a == b
+    /// if result:
+    ///   result = b == c
+    ///   if result:
+    ///     result = c == d
+    /// ```
+    ///
+    /// # See Also
+    /// - [CPython `compiler_compare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L4678-L4717)
+    fn compile_compare(
         &mut self,
         left: &Expr,
         ops: &[CmpOp],
-        exprs: &[Expr],
+        comparators: &[Expr],
     ) -> CompileResult<()> {
-        assert!(!ops.is_empty());
-        assert_eq!(exprs.len(), ops.len());
         let (last_op, mid_ops) = ops.split_last().unwrap();
-        let (last_val, mid_exprs) = exprs.split_last().unwrap();
-
-        use bytecode::ComparisonOperator::*;
-        let compile_cmpop = |c: &mut Self, op: &CmpOp| match op {
-            CmpOp::Eq => emit!(c, Instruction::CompareOperation { op: Equal }),
-            CmpOp::NotEq => emit!(c, Instruction::CompareOperation { op: NotEqual }),
-            CmpOp::Lt => emit!(c, Instruction::CompareOperation { op: Less }),
-            CmpOp::LtE => emit!(c, Instruction::CompareOperation { op: LessOrEqual }),
-            CmpOp::Gt => emit!(c, Instruction::CompareOperation { op: Greater }),
-            CmpOp::GtE => {
-                emit!(c, Instruction::CompareOperation { op: GreaterOrEqual })
-            }
-            CmpOp::In => emit!(c, Instruction::ContainsOp(Invert::No)),
-            CmpOp::NotIn => emit!(c, Instruction::ContainsOp(Invert::Yes)),
-            CmpOp::Is => emit!(c, Instruction::IsOp(Invert::No)),
-            CmpOp::IsNot => emit!(c, Instruction::IsOp(Invert::Yes)),
-        };
-
-        // a == b == c == d
-        // compile into (pseudo code):
-        // result = a == b
-        // if result:
-        //   result = b == c
-        //   if result:
-        //     result = c == d
+        let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
 
         // initialize lhs outside of loop
         self.compile_expression(left)?;
 
-        let end_blocks = if mid_exprs.is_empty() {
-            None
-        } else {
-            let break_block = self.new_block();
-            let after_block = self.new_block();
-            Some((break_block, after_block))
-        };
+        if mid_comparators.is_empty() {
+            self.compile_expression(last_comparator)?;
+            self.compile_addcompare(last_op);
+
+            return Ok(());
+        }
+
+        let cleanup = self.new_block();
 
         // for all comparisons except the last (as the last one doesn't need a conditional jump)
-        for (op, val) in mid_ops.iter().zip(mid_exprs) {
-            self.compile_expression(val)?;
+        for (op, comparator) in mid_ops.iter().zip(mid_comparators) {
+            self.compile_expression(comparator)?;
+
             // store rhs for the next comparison in chain
             emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::CopyItem { index: 2_u32 });
+            emit!(self, Instruction::CopyItem { index: 2 });
 
-            compile_cmpop(self, op);
+            self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
-            if let Some((break_block, _)) = end_blocks {
-                emit!(
-                    self,
-                    Instruction::JumpIfFalseOrPop {
-                        target: break_block,
-                    }
-                );
-            }
+            /*
+            emit!(self, Instruction::CopyItem { index: 1 });
+            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
+            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::PopTop);
+            */
+
+            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
         }
 
-        // handle the last comparison
-        self.compile_expression(last_val)?;
-        compile_cmpop(self, last_op);
+        self.compile_expression(last_comparator)?;
+        self.compile_addcompare(last_op);
 
-        if let Some((break_block, after_block)) = end_blocks {
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: after_block,
-                }
-            );
-
-            // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
-            self.switch_to_block(break_block);
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::PopTop);
+        let end = self.new_block();
+        emit!(self, Instruction::Jump { target: end });
 
-            self.switch_to_block(after_block);
-        }
+        // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
+        self.switch_to_block(cleanup);
+        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::PopTop);
 
+        self.switch_to_block(end);
         Ok(())
     }
 
@@ -4600,14 +4607,16 @@ impl Compiler {
         let after_block = self.new_block();
 
         let (last_value, values) = values.split_last().unwrap();
+
         for value in values {
             self.compile_expression(value)?;
 
+            emit!(self, Instruction::CopyItem { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
                         self,
-                        Instruction::JumpIfFalseOrPop {
+                        Instruction::PopJumpIfFalse {
                             target: after_block,
                         }
                     );
@@ -4615,12 +4624,14 @@ impl Compiler {
                 BoolOp::Or => {
                     emit!(
                         self,
-                        Instruction::JumpIfTrueOrPop {
+                        Instruction::PopJumpIfTrue {
                             target: after_block,
                         }
                     );
                 }
             }
+
+            emit!(self, Instruction::PopTop);
         }
 
         // If all values did not qualify, take the value of the last value:
@@ -4697,7 +4708,7 @@ impl Compiler {
                 comparators,
                 ..
             }) => {
-                self.compile_chained_comparison(left, ops, comparators)?;
+                self.compile_compare(left, ops, comparators)?;
             }
             // Expr::Constant(ExprConstant { value, .. }) => {
             //     self.emit_load_const(compile_constant(value));

From a7d7f81ca7cd3d8ea591fd5369a3fadcc6446084 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sat, 27 Dec 2025 01:13:20 +0900
Subject: [PATCH 080/418] Handle unions with GenericAlias subclasses without
 TypeError (#6540)

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 Lib/test/test_types.py                |  2 --
 crates/vm/src/builtins/type.rs        |  2 +-
 crates/vm/src/builtins/union.rs       | 11 +++++++----
 crates/vm/src/stdlib/typing.rs        | 18 +++++++++++++++---
 extra_tests/snippets/stdlib_typing.py |  4 ++++
 5 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 7e9b28236c7..4200cb8ee5e 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -838,8 +838,6 @@ def test_union_parameter_chaining(self):
         self.assertEqual((list[T] | list[S])[int, T], list[int] | list[T])
         self.assertEqual((list[T] | list[S])[int, int], list[int])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_union_parameter_substitution(self):
         def eq(actual, expected, typed=True):
             self.assertEqual(actual, expected)
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 4f150d92589..bc567cd0978 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1963,7 +1963,7 @@ pub(crate) fn call_slot_new(
     slot_new(subtype, args, vm)
 }
 
-pub(super) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
     if !union_::is_unionable(zelf.clone(), vm) || !union_::is_unionable(other.clone(), vm) {
         return vm.ctx.not_implemented();
     }
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index 8310201a129..83e1316d027 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -8,6 +8,7 @@ use crate::{
     convert::{ToPyObject, ToPyResult},
     function::PyComparisonValue,
     protocol::{PyMappingMethods, PyNumberMethods},
+    stdlib::typing::TypeAliasType,
     types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable},
 };
 use std::fmt;
@@ -152,10 +153,12 @@ impl PyUnion {
 }
 
 pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
-    obj.class().is(vm.ctx.types.none_type)
+    let cls = obj.class();
+    cls.is(vm.ctx.types.none_type)
         || obj.downcastable::<PyType>()
-        || obj.class().is(vm.ctx.types.generic_alias_type)
-        || obj.class().is(vm.ctx.types.union_type)
+        || cls.fast_issubclass(vm.ctx.types.generic_alias_type)
+        || cls.is(vm.ctx.types.union_type)
+        || obj.downcast_ref::<TypeAliasType>().is_some()
 }
 
 fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
@@ -195,7 +198,7 @@ fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef
         if !new_args.iter().any(|param| {
             param
                 .rich_compare_bool(arg, PyComparisonOp::Eq, vm)
-                .expect("types are always comparable")
+                .unwrap_or_default()
         }) {
             new_args.push(arg.clone());
         }
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs
index 469a75b010f..f11acce3490 100644
--- a/crates/vm/src/stdlib/typing.rs
+++ b/crates/vm/src/stdlib/typing.rs
@@ -36,9 +36,11 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 pub(crate) mod decl {
     use crate::{
         Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr},
+        builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr, type_},
+        convert::ToPyResult,
         function::{FuncArgs, IntoFuncArgs},
-        types::{Constructor, Representable},
+        protocol::PyNumberMethods,
+        types::{AsNumber, Constructor, Representable},
     };
 
     pub(crate) fn _call_typing_func_object<'a>(
@@ -109,7 +111,7 @@ pub(crate) mod decl {
         // compute_value: PyObjectRef,
         // module: PyObjectRef,
     }
-    #[pyclass(with(Constructor, Representable), flags(BASETYPE))]
+    #[pyclass(with(Constructor, Representable, AsNumber), flags(BASETYPE))]
     impl TypeAliasType {
         pub const fn new(name: PyStrRef, type_params: PyTupleRef, value: PyObjectRef) -> Self {
             Self {
@@ -183,6 +185,16 @@ pub(crate) mod decl {
         }
     }
 
+    impl AsNumber for TypeAliasType {
+        fn as_number() -> &'static PyNumberMethods {
+            static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+                or: Some(|a, b, vm| type_::or_(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
     // impl AsMapping for Generic {
     //     fn as_mapping() -> &'static PyMappingMethods {
     //         static AS_MAPPING: Lazy<PyMappingMethods> = Lazy::new(|| PyMappingMethods {
diff --git a/extra_tests/snippets/stdlib_typing.py b/extra_tests/snippets/stdlib_typing.py
index ddc30b68460..681790abd0b 100644
--- a/extra_tests/snippets/stdlib_typing.py
+++ b/extra_tests/snippets/stdlib_typing.py
@@ -8,3 +8,7 @@ def abort_signal_handler(
     fn: Callable[[], Awaitable[T]], on_abort: Callable[[], None] | None = None
 ) -> T:
     pass
+
+
+# Ensure PEP 604 unions work with typing.Callable aliases.
+TracebackFilter = bool | Callable[[int], int]

From 27ab62de48340cd8ab557568540c1faacbb0ee3e Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sat, 27 Dec 2025 01:16:09 +0900
Subject: [PATCH 081/418] Prevent __class__ reassignment across incompatible
 layouts (#6521)

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 crates/vm/src/builtins/object.rs     | 35 +++++++++++++++++--
 extra_tests/snippets/builtin_type.py | 50 ++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+), 3 deletions(-)

diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 77a1eff6c7d..a61fb1e2971 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -497,16 +497,45 @@ impl PyBaseObject {
     ) -> PyResult<()> {
         match value.downcast::<PyType>() {
             Ok(cls) => {
-                let both_module = instance.class().fast_issubclass(vm.ctx.types.module_type)
+                let current_cls = instance.class();
+                let both_module = current_cls.fast_issubclass(vm.ctx.types.module_type)
                     && cls.fast_issubclass(vm.ctx.types.module_type);
-                let both_mutable = !instance
-                    .class()
+                let both_mutable = !current_cls
                     .slots
                     .flags
                     .has_feature(PyTypeFlags::IMMUTABLETYPE)
                     && !cls.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE);
                 // FIXME(#1979) cls instances might have a payload
                 if both_mutable || both_module {
+                    let has_dict =
+                        |typ: &Py<PyType>| typ.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+                    // Compare slots tuples
+                    let slots_equal = match (
+                        current_cls
+                            .heaptype_ext
+                            .as_ref()
+                            .and_then(|e| e.slots.as_ref()),
+                        cls.heaptype_ext.as_ref().and_then(|e| e.slots.as_ref()),
+                    ) {
+                        (Some(a), Some(b)) => {
+                            a.len() == b.len()
+                                && a.iter()
+                                    .zip(b.iter())
+                                    .all(|(x, y)| x.as_str() == y.as_str())
+                        }
+                        (None, None) => true,
+                        _ => false,
+                    };
+                    if current_cls.slots.basicsize != cls.slots.basicsize
+                        || !slots_equal
+                        || has_dict(current_cls) != has_dict(&cls)
+                    {
+                        return Err(vm.new_type_error(format!(
+                            "__class__ assignment: '{}' object layout differs from '{}'",
+                            cls.name(),
+                            current_cls.name()
+                        )));
+                    }
                     instance.set_class(cls, vm);
                     Ok(())
                 } else {
diff --git a/extra_tests/snippets/builtin_type.py b/extra_tests/snippets/builtin_type.py
index 7a8e4840e13..67269e694c0 100644
--- a/extra_tests/snippets/builtin_type.py
+++ b/extra_tests/snippets/builtin_type.py
@@ -240,6 +240,56 @@ class C(B, BB):
 assert C.mro() == [C, B, A, BB, AA, object]
 
 
+class TypeA:
+    def __init__(self):
+        self.a = 1
+
+
+class TypeB:
+    __slots__ = "b"
+
+    def __init__(self):
+        self.b = 2
+
+
+obj = TypeA()
+with assert_raises(TypeError) as cm:
+    obj.__class__ = TypeB
+assert "__class__ assignment: 'TypeB' object layout differs from 'TypeA'" in str(
+    cm.exception
+)
+
+
+# Test: same slot count but different slot names should fail
+class SlotX:
+    __slots__ = ("x",)
+
+
+class SlotY:
+    __slots__ = ("y",)
+
+
+slot_obj = SlotX()
+with assert_raises(TypeError) as cm:
+    slot_obj.__class__ = SlotY
+assert "__class__ assignment: 'SlotY' object layout differs from 'SlotX'" in str(
+    cm.exception
+)
+
+
+# Test: same slots should succeed
+class SlotA:
+    __slots__ = ("a",)
+
+
+class SlotA2:
+    __slots__ = ("a",)
+
+
+slot_a = SlotA()
+slot_a.__class__ = SlotA2  # Should work
+
+
 assert type(Exception.args).__name__ == "getset_descriptor"
 assert type(None).__bool__(None) is False
 

From 75ecd72428626298bda278885727adb8912570fc Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 27 Dec 2025 21:38:12 +0900
Subject: [PATCH 082/418] test_builtin.test_import (#6546)

* fix warnings

* fix test_import
---
 Lib/test/test_builtin.py                        |  2 --
 Lib/test/test_import/__init__.py                |  2 --
 .../test_importlib/import_/test___package__.py  |  4 ----
 Lib/test/test_importlib/import_/test_helpers.py |  8 --------
 .../test_importlib/import_/test_meta_path.py    |  2 --
 Lib/test/test_importlib/import_/test_path.py    |  2 --
 crates/vm/src/warn.rs                           | 17 ++++++++++++++---
 7 files changed, 14 insertions(+), 23 deletions(-)

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 183caa898ef..a5306b71d89 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -153,8 +153,6 @@ def check_iter_pickle(self, it, seq, proto):
         it = pickle.loads(d)
         self.assertEqual(list(it), seq[1:])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_import(self):
         __import__('sys')
         __import__('time')
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 85913cd7c58..51fafd89ceb 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -1403,8 +1403,6 @@ def test_absolute_circular_submodule(self):
             str(cm.exception),
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_unwritable_module(self):
         self.addCleanup(unload, "test.test_import.data.unwritable")
         self.addCleanup(unload, "test.test_import.data.unwritable.x")
diff --git a/Lib/test/test_importlib/import_/test___package__.py b/Lib/test/test_importlib/import_/test___package__.py
index 431faea5b4e..7130c99a6fc 100644
--- a/Lib/test/test_importlib/import_/test___package__.py
+++ b/Lib/test/test_importlib/import_/test___package__.py
@@ -56,8 +56,6 @@ def test_using___name__(self):
                                          '__path__': []})
         self.assertEqual(module.__name__, 'pkg')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warn_when_using___name__(self):
         with self.assertWarns(ImportWarning):
             self.import_module({'__name__': 'pkg.fake', '__path__': []})
@@ -75,8 +73,6 @@ def test_spec_fallback(self):
         module = self.import_module({'__spec__': FakeSpec('pkg.fake')})
         self.assertEqual(module.__name__, 'pkg')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warn_when_package_and_spec_disagree(self):
         # Raise a DeprecationWarning if __package__ != __spec__.parent.
         with self.assertWarns(DeprecationWarning):
diff --git a/Lib/test/test_importlib/import_/test_helpers.py b/Lib/test/test_importlib/import_/test_helpers.py
index 28cdc0e526e..550f88d1d7a 100644
--- a/Lib/test/test_importlib/import_/test_helpers.py
+++ b/Lib/test/test_importlib/import_/test_helpers.py
@@ -126,8 +126,6 @@ def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
             ValueError,
             _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_no_spec(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -137,8 +135,6 @@ def test_gh86298_no_spec(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_spec_is_none(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -148,8 +144,6 @@ def test_gh86298_spec_is_none(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_no_spec_loader(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -159,8 +153,6 @@ def test_gh86298_no_spec_loader(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_loader_and_spec_loader_disagree(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
diff --git a/Lib/test/test_importlib/import_/test_meta_path.py b/Lib/test/test_importlib/import_/test_meta_path.py
index 26e7b070b95..8689017ba43 100644
--- a/Lib/test/test_importlib/import_/test_meta_path.py
+++ b/Lib/test/test_importlib/import_/test_meta_path.py
@@ -30,8 +30,6 @@ def test_continuing(self):
             with util.import_state(meta_path=[first, second]):
                 self.assertIs(self.__import__(mod_name), second.modules[mod_name])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_empty(self):
         # Raise an ImportWarning if sys.meta_path is empty.
         module_name = 'nothing'
diff --git a/Lib/test/test_importlib/import_/test_path.py b/Lib/test/test_importlib/import_/test_path.py
index 9cf3a77cb84..89b52fbd1e1 100644
--- a/Lib/test/test_importlib/import_/test_path.py
+++ b/Lib/test/test_importlib/import_/test_path.py
@@ -68,8 +68,6 @@ def test_path_hooks(self):
             self.assertIn(path, sys.path_importer_cache)
             self.assertIs(sys.path_importer_cache[path], importer)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_empty_path_hooks(self):
         # Test that if sys.path_hooks is empty a warning is raised,
         # sys.path_importer_cache gets None set, and PathFinder returns None.
diff --git a/crates/vm/src/warn.rs b/crates/vm/src/warn.rs
index b632495eb4a..3dbd43ab537 100644
--- a/crates/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -67,8 +67,15 @@ fn get_warnings_attr(
             Err(_) => return Ok(None),
         }
     } else {
-        // TODO: finalizing support
-        return Ok(None);
+        // Check sys.modules for already-imported warnings module
+        // This is what CPython does with PyImport_GetModule
+        match vm.sys_module.get_attr(identifier!(vm, modules), vm) {
+            Ok(modules) => match modules.get_item(vm.ctx.intern_str("warnings"), vm) {
+                Ok(module) => module,
+                Err(_) => return Ok(None),
+            },
+            Err(_) => return Ok(None),
+        }
     };
     Ok(Some(module.get_attr(attr_name, vm)?))
 }
@@ -320,9 +327,13 @@ fn call_show_warning(
         return Err(vm.new_type_error("unable to get warnings.WarningMessage"));
     };
 
+    // Create a Warning instance by calling category(message)
+    // This is what warnings module does
+    let warning_instance = category.as_object().call((message,), vm)?;
+
     let msg = warnmsg_cls.call(
         vec![
-            message.into(),
+            warning_instance,
             category.into(),
             filename.into(),
             vm.new_pyobj(lineno),

From 8d9002800ea4ca75c8455383f05813351ef15007 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 27 Dec 2025 14:53:37 +0100
Subject: [PATCH 083/418] Update `test_dis.py` from 3.13.11 (#6528)

---
 Lib/dis.py           |   29 +-
 Lib/test/test_dis.py | 2461 +++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 2434 insertions(+), 56 deletions(-)

diff --git a/Lib/dis.py b/Lib/dis.py
index 05de51ce49c..6583cab62b8 100644
--- a/Lib/dis.py
+++ b/Lib/dis.py
@@ -1052,21 +1052,30 @@ def dis(self):
             return output.getvalue()
 
 
-from _dis import *
+from _dis import * # TODO: RUSTPYTHON; Remove this import (and module)
 
 
-# Disassembling a file by following cpython Lib/dis.py
-def _test():
-    """Simple test program to disassemble a file."""
+def main(args=None):
     import argparse
 
     parser = argparse.ArgumentParser()
-    parser.add_argument('infile', type=argparse.FileType('rb'), nargs='?', default='-')
-    args = parser.parse_args()
-    with args.infile as infile:
-        source = infile.read()
-    code = compile(source, args.infile.name, "exec")
+    parser.add_argument('-C', '--show-caches', action='store_true',
+                        help='show inline caches')
+    parser.add_argument('-O', '--show-offsets', action='store_true',
+                        help='show instruction offsets')
+    parser.add_argument('infile', nargs='?', default='-')
+    args = parser.parse_args(args=args)
+    if args.infile == '-':
+        name = '<stdin>'
+        source = sys.stdin.buffer.read()
+    else:
+        name = args.infile
+        with open(args.infile, 'rb') as infile:
+            source = infile.read()
+    code = compile(source, name, "exec")
+    # TODO: RUSTPYTHON; Add support for `show_caches` & `show_offsets` arguments
+    # dis(code, show_caches=args.show_caches, show_offsets=args.show_offsets)
     dis(code)
 
 if __name__ == "__main__":
-    _test()
+    main()
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index 8bbba86a464..dab8d73e54c 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -1,59 +1,2428 @@
-import subprocess
+# Minimal tests for dis module
+
+import contextlib
+import dis
+import functools
+import io
+import itertools
+import opcode
+import re
 import sys
+import tempfile
+import textwrap
+import types
 import unittest
+from test.support import (captured_stdout, requires_debug_ranges,
+                          requires_specialization, cpython_only,
+                          os_helper)
+from test.support.bytecode_helper import BytecodeTestCase
+
+
+CACHE = dis.opmap["CACHE"]
+
+def get_tb():
+    def _error():
+        try:
+            1 / 0
+        except Exception as e:
+            tb = e.__traceback__
+        return tb
+
+    tb = _error()
+    while tb.tb_next:
+        tb = tb.tb_next
+    return tb
 
-# This only tests that it prints something in order
-# to avoid changing this test if the bytecode changes
+TRACEBACK_CODE = get_tb().tb_frame.f_code
 
-# These tests start a new process instead of redirecting stdout because
-# stdout is being written to by rust code, which currently can't be
-# redirected by reassigning sys.stdout
+class _C:
+    def __init__(self, x):
+        self.x = x == 1
 
+    @staticmethod
+    def sm(x):
+        x = x == 1
 
-class TestDis(unittest.TestCase):
     @classmethod
-    def setUpClass(cls):
-        cls.setup = """
-import dis
-def tested_func(): pass
+    def cm(cls, x):
+        cls.x = x == 1
+
+dis_c_instance_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                1 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              LOAD_FAST                0 (self)
+              STORE_ATTR               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.__init__.__code__.co_firstlineno, _C.__init__.__code__.co_firstlineno + 1,)
+
+dis_c_instance_method_bytes = """\
+          RESUME                   0
+          LOAD_FAST                1
+          LOAD_CONST               1
+          COMPARE_OP              72 (==)
+          LOAD_FAST                0
+          STORE_ATTR               0
+          RETURN_CONST             0
+"""
+
+dis_c_class_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                1 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              LOAD_FAST                0 (cls)
+              STORE_ATTR               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.cm.__code__.co_firstlineno, _C.cm.__code__.co_firstlineno + 2,)
+
+dis_c_static_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                0 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              STORE_FAST               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.sm.__code__.co_firstlineno, _C.sm.__code__.co_firstlineno + 2,)
+
+# Class disassembling info has an extra newline at end.
+dis_c = """\
+Disassembly of %s:
+%s
+Disassembly of %s:
+%s
+Disassembly of %s:
+%s
+""" % (_C.__init__.__name__, dis_c_instance_method,
+       _C.cm.__name__, dis_c_class_method,
+       _C.sm.__name__, dis_c_static_method)
+
+def _f(a):
+    print(a)
+    return 1
+
+dis_f = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (print + NULL)
+              LOAD_FAST                0 (a)
+              CALL                     1
+              POP_TOP
+
+%3d           RETURN_CONST             1 (1)
+""" % (_f.__code__.co_firstlineno,
+       _f.__code__.co_firstlineno + 1,
+       _f.__code__.co_firstlineno + 2)
+
+dis_f_with_offsets = """\
+%3d          0       RESUME                   0
+
+%3d          2       LOAD_GLOBAL              1 (print + NULL)
+            12       LOAD_FAST                0 (a)
+            14       CALL                     1
+            22       POP_TOP
+
+%3d         24       RETURN_CONST             1 (1)
+""" % (_f.__code__.co_firstlineno,
+       _f.__code__.co_firstlineno + 1,
+       _f.__code__.co_firstlineno + 2)
+
+
+dis_f_co_code = """\
+          RESUME                   0
+          LOAD_GLOBAL              1
+          LOAD_FAST                0
+          CALL                     1
+          POP_TOP
+          RETURN_CONST             1
+"""
+
+def bug708901():
+    for res in range(1,
+                     10):
+        pass
+
+dis_bug708901 = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (range + NULL)
+              LOAD_CONST               1 (1)
+
+%3d           LOAD_CONST               2 (10)
+
+%3d           CALL                     2
+              GET_ITER
+      L1:     FOR_ITER                 3 (to L2)
+              STORE_FAST               0 (res)
+
+%3d           JUMP_BACKWARD            5 (to L1)
+
+%3d   L2:     END_FOR
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (bug708901.__code__.co_firstlineno,
+       bug708901.__code__.co_firstlineno + 1,
+       bug708901.__code__.co_firstlineno + 2,
+       bug708901.__code__.co_firstlineno + 1,
+       bug708901.__code__.co_firstlineno + 3,
+       bug708901.__code__.co_firstlineno + 1)
+
+
+def bug1333982(x=[]):
+    assert 0, ((s for s in x) +
+              1)
+    pass
+
+dis_bug1333982 = """\
+%3d           RESUME                   0
+
+%3d           LOAD_ASSERTION_ERROR
+              LOAD_CONST               1 (<code object <genexpr> at 0x..., file "%s", line %d>)
+              MAKE_FUNCTION
+              LOAD_FAST                0 (x)
+              GET_ITER
+              CALL                     0
+
+%3d           LOAD_CONST               2 (1)
+
+%3d           BINARY_OP                0 (+)
+              CALL                     0
+              RAISE_VARARGS            1
+""" % (bug1333982.__code__.co_firstlineno,
+       bug1333982.__code__.co_firstlineno + 1,
+       __file__,
+       bug1333982.__code__.co_firstlineno + 1,
+       bug1333982.__code__.co_firstlineno + 2,
+       bug1333982.__code__.co_firstlineno + 1)
+
+
+def bug42562():
+    pass
+
+
+# Set line number for 'pass' to None
+bug42562.__code__ = bug42562.__code__.replace(co_linetable=b'\xf8')
+
+
+dis_bug42562 = """\
+          RESUME                   0
+          RETURN_CONST             0 (None)
+"""
+
+# Extended arg followed by NOP
+code_bug_45757 = bytes([
+        opcode.opmap['EXTENDED_ARG'], 0x01,  # EXTENDED_ARG 0x01
+        opcode.opmap['NOP'],          0xFF,  # NOP 0xFF
+        opcode.opmap['EXTENDED_ARG'], 0x01,  # EXTENDED_ARG 0x01
+        opcode.opmap['LOAD_CONST'],   0x29,  # LOAD_CONST 0x29
+        opcode.opmap['RETURN_VALUE'], 0x00,  # RETURN_VALUE 0x00
+    ])
+
+dis_bug_45757 = """\
+          EXTENDED_ARG             1
+          NOP
+          EXTENDED_ARG             1
+          LOAD_CONST             297
+          RETURN_VALUE
 """
-        cls.command = (sys.executable, "-c")
 
+# [255, 255, 255, 252] is -4 in a 4 byte signed integer
+bug46724 = bytes([
+    opcode.EXTENDED_ARG, 255,
+    opcode.EXTENDED_ARG, 255,
+    opcode.EXTENDED_ARG, 255,
+    opcode.opmap['JUMP_FORWARD'], 252,
+])
+
+
+dis_bug46724 = """\
+  L1:     EXTENDED_ARG           255
+          EXTENDED_ARG         65535
+          EXTENDED_ARG         16777215
+          JUMP_FORWARD            -4 (to L1)
+"""
+
+def func_w_kwargs(a, b, **c):
+    pass
+
+def wrap_func_w_kwargs():
+    func_w_kwargs(1, 2, c=5)
+
+dis_kw_names = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (func_w_kwargs + NULL)
+              LOAD_CONST               1 (1)
+              LOAD_CONST               2 (2)
+              LOAD_CONST               3 (5)
+              LOAD_CONST               4 (('c',))
+              CALL_KW                  3
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (wrap_func_w_kwargs.__code__.co_firstlineno,
+       wrap_func_w_kwargs.__code__.co_firstlineno + 1)
+
+dis_intrinsic_1_2 = """\
+  0           RESUME                   0
+
+  1           LOAD_CONST               0 (0)
+              LOAD_CONST               1 (('*',))
+              IMPORT_NAME              0 (math)
+              CALL_INTRINSIC_1         2 (INTRINSIC_IMPORT_STAR)
+              POP_TOP
+              RETURN_CONST             2 (None)
+"""
+
+dis_intrinsic_1_5 = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (a)
+              CALL_INTRINSIC_1         5 (INTRINSIC_UNARY_POSITIVE)
+              RETURN_VALUE
+"""
+
+dis_intrinsic_1_6 = """\
+  0           RESUME                   0
+
+  1           BUILD_LIST               0
+              LOAD_NAME                0 (a)
+              LIST_EXTEND              1
+              CALL_INTRINSIC_1         6 (INTRINSIC_LIST_TO_TUPLE)
+              RETURN_VALUE
+"""
+
+_BIG_LINENO_FORMAT = """\
+  1           RESUME                   0
+
+%3d           LOAD_GLOBAL              0 (spam)
+              POP_TOP
+              RETURN_CONST             0 (None)
+"""
+
+_BIG_LINENO_FORMAT2 = """\
+   1           RESUME                   0
+
+%4d           LOAD_GLOBAL              0 (spam)
+               POP_TOP
+               RETURN_CONST             0 (None)
+"""
+
+dis_module_expected_results = """\
+Disassembly of f:
+  4           RESUME                   0
+              RETURN_CONST             0 (None)
+
+Disassembly of g:
+  5           RESUME                   0
+              RETURN_CONST             0 (None)
+
+"""
+
+expr_str = "x + 1"
+
+dis_expr_str = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (x)
+              LOAD_CONST               0 (1)
+              BINARY_OP                0 (+)
+              RETURN_VALUE
+"""
+
+simple_stmt_str = "x = x + 1"
+
+dis_simple_stmt_str = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (x)
+              LOAD_CONST               0 (1)
+              BINARY_OP                0 (+)
+              STORE_NAME               0 (x)
+              RETURN_CONST             1 (None)
+"""
+
+annot_stmt_str = """\
+
+x: int = 1
+y: fun(1)
+lst[fun(0)]: int = 1
+"""
+# leading newline is for a reason (tests lineno)
+
+dis_annot_stmt_str = """\
+  0           RESUME                   0
+
+  2           SETUP_ANNOTATIONS
+              LOAD_CONST               0 (1)
+              STORE_NAME               0 (x)
+              LOAD_NAME                1 (int)
+              LOAD_NAME                2 (__annotations__)
+              LOAD_CONST               1 ('x')
+              STORE_SUBSCR
+
+  3           LOAD_NAME                3 (fun)
+              PUSH_NULL
+              LOAD_CONST               0 (1)
+              CALL                     1
+              LOAD_NAME                2 (__annotations__)
+              LOAD_CONST               2 ('y')
+              STORE_SUBSCR
+
+  4           LOAD_CONST               0 (1)
+              LOAD_NAME                4 (lst)
+              LOAD_NAME                3 (fun)
+              PUSH_NULL
+              LOAD_CONST               3 (0)
+              CALL                     1
+              STORE_SUBSCR
+              LOAD_NAME                1 (int)
+              POP_TOP
+              RETURN_CONST             4 (None)
+"""
+
+compound_stmt_str = """\
+x = 0
+while 1:
+    x += 1"""
+# Trailing newline has been deliberately omitted
+
+dis_compound_stmt_str = """\
+  0           RESUME                   0
+
+  1           LOAD_CONST               0 (0)
+              STORE_NAME               0 (x)
+
+  2           NOP
+
+  3   L1:     LOAD_NAME                0 (x)
+              LOAD_CONST               1 (1)
+              BINARY_OP               13 (+=)
+              STORE_NAME               0 (x)
+
+  2           JUMP_BACKWARD            7 (to L1)
+"""
+
+dis_traceback = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d   L1:     LOAD_CONST               1 (1)
+               LOAD_CONST               2 (0)
+           --> BINARY_OP               11 (/)
+               POP_TOP
+
+%4d   L2:     LOAD_FAST_CHECK          1 (tb)
+               RETURN_VALUE
+
+  --   L3:     PUSH_EXC_INFO
+
+%4d           LOAD_GLOBAL              0 (Exception)
+               CHECK_EXC_MATCH
+               POP_JUMP_IF_FALSE       23 (to L7)
+               STORE_FAST               0 (e)
+
+%4d   L4:     LOAD_FAST                0 (e)
+               LOAD_ATTR                2 (__traceback__)
+               STORE_FAST               1 (tb)
+       L5:     POP_EXCEPT
+               LOAD_CONST               0 (None)
+               STORE_FAST               0 (e)
+               DELETE_FAST              0 (e)
+
+%4d           LOAD_FAST                1 (tb)
+               RETURN_VALUE
+
+  --   L6:     LOAD_CONST               0 (None)
+               STORE_FAST               0 (e)
+               DELETE_FAST              0 (e)
+               RERAISE                  1
+
+%4d   L7:     RERAISE                  0
+
+  --   L8:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [0]
+  L3 to L4 -> L8 [1] lasti
+  L4 to L5 -> L6 [1] lasti
+  L6 to L8 -> L8 [1] lasti
+""" % (TRACEBACK_CODE.co_firstlineno,
+       TRACEBACK_CODE.co_firstlineno + 1,
+       TRACEBACK_CODE.co_firstlineno + 2,
+       TRACEBACK_CODE.co_firstlineno + 5,
+       TRACEBACK_CODE.co_firstlineno + 3,
+       TRACEBACK_CODE.co_firstlineno + 4,
+       TRACEBACK_CODE.co_firstlineno + 5,
+       TRACEBACK_CODE.co_firstlineno + 3)
+
+def _fstring(a, b, c, d):
+    return f'{a} {b:4} {c!r} {d!r:4}'
+
+dis_fstring = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                0 (a)
+              FORMAT_SIMPLE
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                1 (b)
+              LOAD_CONST               2 ('4')
+              FORMAT_WITH_SPEC
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                2 (c)
+              CONVERT_VALUE            2 (repr)
+              FORMAT_SIMPLE
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                3 (d)
+              CONVERT_VALUE            2 (repr)
+              LOAD_CONST               2 ('4')
+              FORMAT_WITH_SPEC
+              BUILD_STRING             7
+              RETURN_VALUE
+""" % (_fstring.__code__.co_firstlineno, _fstring.__code__.co_firstlineno + 1)
+
+def _with(c):
+    with c:
+        x = 1
+    y = 2
+
+dis_with = """\
+%4d           RESUME                   0
+
+%4d           LOAD_FAST                0 (c)
+               BEFORE_WITH
+       L1:     POP_TOP
+
+%4d           LOAD_CONST               1 (1)
+               STORE_FAST               1 (x)
+
+%4d   L2:     LOAD_CONST               0 (None)
+               LOAD_CONST               0 (None)
+               LOAD_CONST               0 (None)
+               CALL                     2
+               POP_TOP
+
+%4d           LOAD_CONST               2 (2)
+               STORE_FAST               2 (y)
+               RETURN_CONST             0 (None)
+
+%4d   L3:     PUSH_EXC_INFO
+               WITH_EXCEPT_START
+               TO_BOOL
+               POP_JUMP_IF_TRUE         1 (to L4)
+               RERAISE                  2
+       L4:     POP_TOP
+       L5:     POP_EXCEPT
+               POP_TOP
+               POP_TOP
+
+%4d           LOAD_CONST               2 (2)
+               STORE_FAST               2 (y)
+               RETURN_CONST             0 (None)
+
+  --   L6:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [1] lasti
+  L3 to L5 -> L6 [3] lasti
+""" % (_with.__code__.co_firstlineno,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 2,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 3,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 3,
+       )
+
+async def _asyncwith(c):
+    async with c:
+        x = 1
+    y = 2
+
+dis_asyncwith = """\
+%4d            RETURN_GENERATOR
+                POP_TOP
+        L1:     RESUME                   0
+
+%4d            LOAD_FAST                0 (c)
+                BEFORE_ASYNC_WITH
+                GET_AWAITABLE            1
+                LOAD_CONST               0 (None)
+        L2:     SEND                     3 (to L5)
+        L3:     YIELD_VALUE              1
+        L4:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L2)
+        L5:     END_SEND
+        L6:     POP_TOP
+
+%4d            LOAD_CONST               1 (1)
+                STORE_FAST               1 (x)
+
+%4d    L7:     LOAD_CONST               0 (None)
+                LOAD_CONST               0 (None)
+                LOAD_CONST               0 (None)
+                CALL                     2
+                GET_AWAITABLE            2
+                LOAD_CONST               0 (None)
+        L8:     SEND                     3 (to L11)
+        L9:     YIELD_VALUE              1
+       L10:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L8)
+       L11:     END_SEND
+                POP_TOP
+
+%4d            LOAD_CONST               2 (2)
+                STORE_FAST               2 (y)
+                RETURN_CONST             0 (None)
+
+%4d   L12:     CLEANUP_THROW
+       L13:     JUMP_BACKWARD_NO_INTERRUPT 25 (to L5)
+       L14:     CLEANUP_THROW
+       L15:     JUMP_BACKWARD_NO_INTERRUPT 9 (to L11)
+       L16:     PUSH_EXC_INFO
+                WITH_EXCEPT_START
+                GET_AWAITABLE            2
+                LOAD_CONST               0 (None)
+       L17:     SEND                     4 (to L21)
+       L18:     YIELD_VALUE              1
+       L19:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L17)
+       L20:     CLEANUP_THROW
+       L21:     END_SEND
+                TO_BOOL
+                POP_JUMP_IF_TRUE         1 (to L22)
+                RERAISE                  2
+       L22:     POP_TOP
+       L23:     POP_EXCEPT
+                POP_TOP
+                POP_TOP
+
+%4d            LOAD_CONST               2 (2)
+                STORE_FAST               2 (y)
+                RETURN_CONST             0 (None)
+
+  --   L24:     COPY                     3
+                POP_EXCEPT
+                RERAISE                  1
+       L25:     CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
+                RERAISE                  1
+ExceptionTable:
+  L1 to L3 -> L25 [0] lasti
+  L3 to L4 -> L12 [3]
+  L4 to L6 -> L25 [0] lasti
+  L6 to L7 -> L16 [1] lasti
+  L7 to L9 -> L25 [0] lasti
+  L9 to L10 -> L14 [2]
+  L10 to L13 -> L25 [0] lasti
+  L14 to L15 -> L25 [0] lasti
+  L16 to L18 -> L24 [3] lasti
+  L18 to L19 -> L20 [6]
+  L19 to L23 -> L24 [3] lasti
+  L23 to L25 -> L25 [0] lasti
+""" % (_asyncwith.__code__.co_firstlineno,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 2,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 3,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 3,
+       )
+
+
+def _tryfinally(a, b):
+    try:
+        return a
+    finally:
+        b()
+
+def _tryfinallyconst(b):
+    try:
+        return 1
+    finally:
+        b()
+
+dis_tryfinally = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d   L1:     LOAD_FAST                0 (a)
+
+%4d   L2:     LOAD_FAST                1 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RETURN_VALUE
+
+  --   L3:     PUSH_EXC_INFO
+
+%4d           LOAD_FAST                1 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RERAISE                  0
+
+  --   L4:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [0]
+  L3 to L4 -> L4 [1] lasti
+""" % (_tryfinally.__code__.co_firstlineno,
+       _tryfinally.__code__.co_firstlineno + 1,
+       _tryfinally.__code__.co_firstlineno + 2,
+       _tryfinally.__code__.co_firstlineno + 4,
+       _tryfinally.__code__.co_firstlineno + 4,
+       )
+
+dis_tryfinallyconst = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d           NOP
+
+%4d           LOAD_FAST                0 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RETURN_CONST             1 (1)
+
+  --   L1:     PUSH_EXC_INFO
+
+%4d           LOAD_FAST                0 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RERAISE                  0
+
+  --   L2:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L2 [1] lasti
+""" % (_tryfinallyconst.__code__.co_firstlineno,
+       _tryfinallyconst.__code__.co_firstlineno + 1,
+       _tryfinallyconst.__code__.co_firstlineno + 2,
+       _tryfinallyconst.__code__.co_firstlineno + 4,
+       _tryfinallyconst.__code__.co_firstlineno + 4,
+       )
+
+def _g(x):
+    yield x
+
+async def _ag(x):
+    yield x
+
+async def _co(x):
+    async for item in _ag(x):
+        pass
+
+def _h(y):
+    def foo(x):
+        '''funcdoc'''
+        return list(x + z for z in y)
+    return foo
+
+dis_nested_0 = """\
+  --           MAKE_CELL                0 (y)
+
+%4d           RESUME                   0
+
+%4d           LOAD_FAST                0 (y)
+               BUILD_TUPLE              1
+               LOAD_CONST               1 (<code object foo at 0x..., file "%s", line %d>)
+               MAKE_FUNCTION
+               SET_FUNCTION_ATTRIBUTE   8 (closure)
+               STORE_FAST               1 (foo)
+
+%4d           LOAD_FAST                1 (foo)
+               RETURN_VALUE
+""" % (_h.__code__.co_firstlineno,
+       _h.__code__.co_firstlineno + 1,
+       __file__,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 4,
+)
+
+dis_nested_1 = """%s
+Disassembly of <code object foo at 0x..., file "%s", line %d>:
+  --           COPY_FREE_VARS           1
+               MAKE_CELL                0 (x)
+
+%4d           RESUME                   0
+
+%4d           LOAD_GLOBAL              1 (list + NULL)
+               LOAD_FAST                0 (x)
+               BUILD_TUPLE              1
+               LOAD_CONST               1 (<code object <genexpr> at 0x..., file "%s", line %d>)
+               MAKE_FUNCTION
+               SET_FUNCTION_ATTRIBUTE   8 (closure)
+               LOAD_DEREF               1 (y)
+               GET_ITER
+               CALL                     0
+               CALL                     1
+               RETURN_VALUE
+""" % (dis_nested_0,
+       __file__,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 3,
+       __file__,
+       _h.__code__.co_firstlineno + 3,
+)
+
+dis_nested_2 = """%s
+Disassembly of <code object <genexpr> at 0x..., file "%s", line %d>:
+  --           COPY_FREE_VARS           1
+
+%4d           RETURN_GENERATOR
+               POP_TOP
+       L1:     RESUME                   0
+               LOAD_FAST                0 (.0)
+               GET_ITER
+       L2:     FOR_ITER                10 (to L3)
+               STORE_FAST               1 (z)
+               LOAD_DEREF               2 (x)
+               LOAD_FAST                1 (z)
+               BINARY_OP                0 (+)
+               YIELD_VALUE              0
+               RESUME                   5
+               POP_TOP
+               JUMP_BACKWARD           12 (to L2)
+       L3:     END_FOR
+               POP_TOP
+               RETURN_CONST             0 (None)
+
+  --   L4:     CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
+               RERAISE                  1
+ExceptionTable:
+  L1 to L4 -> L4 [0] lasti
+""" % (dis_nested_1,
+       __file__,
+       _h.__code__.co_firstlineno + 3,
+       _h.__code__.co_firstlineno + 3,
+)
+
+def load_test(x, y=0):
+    a, b = x, y
+    return a, b
+
+dis_load_test_quickened_code = """\
+%3d           RESUME_CHECK             0
+
+%3d           LOAD_FAST_LOAD_FAST      1 (x, y)
+              STORE_FAST_STORE_FAST   50 (b, a)
+
+%3d           LOAD_FAST_LOAD_FAST     35 (a, b)
+              BUILD_TUPLE              2
+              RETURN_VALUE
+""" % (load_test.__code__.co_firstlineno,
+       load_test.__code__.co_firstlineno + 1,
+       load_test.__code__.co_firstlineno + 2)
+
+def loop_test():
+    for i in [1, 2, 3] * 3:
+        load_test(i)
+
+dis_loop_test_quickened_code = """\
+%3d           RESUME_CHECK             0
+
+%3d           BUILD_LIST               0
+              LOAD_CONST               1 ((1, 2, 3))
+              LIST_EXTEND              1
+              LOAD_CONST               2 (3)
+              BINARY_OP                5 (*)
+              GET_ITER
+      L1:     FOR_ITER_LIST           14 (to L2)
+              STORE_FAST               0 (i)
+
+%3d           LOAD_GLOBAL_MODULE       1 (load_test + NULL)
+              LOAD_FAST                0 (i)
+              CALL_PY_GENERAL          1
+              POP_TOP
+              JUMP_BACKWARD           16 (to L1)
+
+%3d   L2:     END_FOR
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (loop_test.__code__.co_firstlineno,
+       loop_test.__code__.co_firstlineno + 1,
+       loop_test.__code__.co_firstlineno + 2,
+       loop_test.__code__.co_firstlineno + 1,)
+
+def extended_arg_quick():
+    *_, _ = ...
+
+dis_extended_arg_quick_code = """\
+%3d           RESUME                   0
+
+%3d           LOAD_CONST               1 (Ellipsis)
+              EXTENDED_ARG             1
+              UNPACK_EX              256
+              POP_TOP
+              STORE_FAST               0 (_)
+              RETURN_CONST             0 (None)
+"""% (extended_arg_quick.__code__.co_firstlineno,
+      extended_arg_quick.__code__.co_firstlineno + 1,)
+
+ADAPTIVE_WARMUP_DELAY = 2
+
+class DisTestBase(unittest.TestCase):
+    "Common utilities for DisTests and TestDisTraceback"
+
+    def strip_addresses(self, text):
+        return re.sub(r'\b0x[0-9A-Fa-f]+\b', '0x...', text)
+
+    def assert_exception_table_increasing(self, lines):
+        prev_start, prev_end = -1, -1
+        count = 0
+        for line in lines:
+            m = re.match(r'  L(\d+) to L(\d+) -> L\d+ \[\d+\]', line)
+            start, end = [int(g) for g in m.groups()]
+            self.assertGreaterEqual(end, start)
+            self.assertGreaterEqual(start, prev_end)
+            prev_start, prev_end = start, end
+            count += 1
+        return count
+
+    def do_disassembly_compare(self, got, expected):
+        if got != expected:
+            got = self.strip_addresses(got)
+        self.assertEqual(got, expected)
+
+
+class DisTests(DisTestBase):
+
+    maxDiff = None
+
+    def get_disassembly(self, func, lasti=-1, wrapper=True, **kwargs):
+        # We want to test the default printing behaviour, not the file arg
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            if wrapper:
+                dis.dis(func, **kwargs)
+            else:
+                dis.disassemble(func, lasti, **kwargs)
+        return output.getvalue()
+
+    def get_disassemble_as_string(self, func, lasti=-1):
+        return self.get_disassembly(func, lasti, False)
+
+    def do_disassembly_test(self, func, expected, **kwargs):
+        self.maxDiff = None
+        got = self.get_disassembly(func, depth=0, **kwargs)
+        self.do_disassembly_compare(got, expected)
+        # Add checks for dis.disco
+        if hasattr(func, '__code__'):
+            got_disco = io.StringIO()
+            with contextlib.redirect_stdout(got_disco):
+                dis.disco(func.__code__, **kwargs)
+            self.do_disassembly_compare(got_disco.getvalue(), expected)
+
+    def test_opmap(self):
+        self.assertEqual(dis.opmap["CACHE"], 0)
+        self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
+        self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
+
+    def test_opname(self):
+        self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
+
+    def test_boundaries(self):
+        self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
+
+    def test_widths(self):
+        long_opcodes = set(['JUMP_BACKWARD_NO_INTERRUPT',
+                            'INSTRUMENTED_CALL_FUNCTION_EX'])
+        for opcode, opname in enumerate(dis.opname):
+            if opname in long_opcodes or opname.startswith("INSTRUMENTED"):
+                continue
+            with self.subTest(opname=opname):
+                width = dis._OPNAME_WIDTH
+                if opcode in dis.hasarg:
+                    width += 1 + dis._OPARG_WIDTH
+                self.assertLessEqual(len(opname), width)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dis(self):
-        test_code = f"""
-{self.setup}
-dis.dis(tested_func)
-dis.dis("x = 2; print(x)")
-"""
-
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        self.assertNotEqual("", result.stdout.decode())
-        self.assertEqual("", result.stderr.decode())
-
-    def test_disassemble(self):
-        test_code = f"""
-{self.setup}
-dis.disassemble(tested_func)
-"""
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        # In CPython this would raise an AttributeError, not a
-        # TypeError because dis is implemented in python in CPython and
-        # as such the type mismatch wouldn't be caught immeadiately
-        self.assertIn("TypeError", result.stderr.decode())
-
-        test_code = f"""
-{self.setup}
-dis.disassemble(tested_func.__code__)
-"""
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        self.assertNotEqual("", result.stdout.decode())
-        self.assertEqual("", result.stderr.decode())
+        self.do_disassembly_test(_f, dis_f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_dis_with_offsets(self):
+        self.do_disassembly_test(_f, dis_f_with_offsets, show_offsets=True)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_708901(self):
+        self.do_disassembly_test(bug708901, dis_bug708901)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_1333982(self):
+        # This one is checking bytecodes generated for an `assert` statement,
+        # so fails if the tests are run with -O.  Skip this test then.
+        if not __debug__:
+            self.skipTest('need asserts, run without -O')
+
+        self.do_disassembly_test(bug1333982, dis_bug1333982)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_42562(self):
+        self.do_disassembly_test(bug42562, dis_bug42562)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_45757(self):
+        # Extended arg followed by NOP
+        self.do_disassembly_test(code_bug_45757, dis_bug_45757)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_46724(self):
+        # Test that negative operargs are handled properly
+        self.do_disassembly_test(bug46724, dis_bug46724)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_kw_names(self):
+        # Test that value is displayed for keyword argument names:
+        self.do_disassembly_test(wrap_func_w_kwargs, dis_kw_names)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_intrinsic_1(self):
+        # Test that argrepr is displayed for CALL_INTRINSIC_1
+        self.do_disassembly_test("from math import *", dis_intrinsic_1_2)
+        self.do_disassembly_test("+a", dis_intrinsic_1_5)
+        self.do_disassembly_test("(*a,)", dis_intrinsic_1_6)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_intrinsic_2(self):
+        self.assertIn("CALL_INTRINSIC_2         1 (INTRINSIC_PREP_RERAISE_STAR)",
+                      self.get_disassembly("try: pass\nexcept* Exception: x"))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_big_linenos(self):
+        def func(count):
+            namespace = {}
+            func = "def foo():\n " + "".join(["\n "] * count + ["spam\n"])
+            exec(func, namespace)
+            return namespace['foo']
+
+        # Test all small ranges
+        for i in range(1, 300):
+            expected = _BIG_LINENO_FORMAT % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        # Test some larger ranges too
+        for i in range(300, 1000, 10):
+            expected = _BIG_LINENO_FORMAT % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        for i in range(1000, 5000, 10):
+            expected = _BIG_LINENO_FORMAT2 % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        from test import dis_module
+        self.do_disassembly_test(dis_module, dis_module_expected_results)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_str(self):
+        self.do_disassembly_test(expr_str, dis_expr_str)
+        self.do_disassembly_test(simple_stmt_str, dis_simple_stmt_str)
+        self.do_disassembly_test(annot_stmt_str, dis_annot_stmt_str)
+        self.do_disassembly_test(compound_stmt_str, dis_compound_stmt_str)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_bytes(self):
+        self.do_disassembly_test(_f.__code__.co_code, dis_f_co_code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_class(self):
+        self.do_disassembly_test(_C, dis_c)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_instance_method(self):
+        self.do_disassembly_test(_C(1).__init__, dis_c_instance_method)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_instance_method_bytes(self):
+        method_bytecode = _C(1).__init__.__code__.co_code
+        self.do_disassembly_test(method_bytecode, dis_c_instance_method_bytes)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_static_method(self):
+        self.do_disassembly_test(_C.sm, dis_c_static_method)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_class_method(self):
+        self.do_disassembly_test(_C.cm, dis_c_class_method)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_generator(self):
+        gen_func_disas = self.get_disassembly(_g)  # Generator function
+        gen_disas = self.get_disassembly(_g(1))  # Generator iterator
+        self.assertEqual(gen_disas, gen_func_disas)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_async_generator(self):
+        agen_func_disas = self.get_disassembly(_ag)  # Async generator function
+        agen_disas = self.get_disassembly(_ag(1))  # Async generator iterator
+        self.assertEqual(agen_disas, agen_func_disas)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_coroutine(self):
+        coro_func_disas = self.get_disassembly(_co)  # Coroutine function
+        coro = _co(1)  # Coroutine object
+        coro.close()  # Avoid a RuntimeWarning (never awaited)
+        coro_disas = self.get_disassembly(coro)
+        self.assertEqual(coro_disas, coro_func_disas)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_fstring(self):
+        self.do_disassembly_test(_fstring, dis_fstring)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_with(self):
+        self.do_disassembly_test(_with, dis_with)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_asyncwith(self):
+        self.do_disassembly_test(_asyncwith, dis_asyncwith)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_try_finally(self):
+        self.do_disassembly_test(_tryfinally, dis_tryfinally)
+        self.do_disassembly_test(_tryfinallyconst, dis_tryfinallyconst)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_dis_none(self):
+        try:
+            del sys.last_exc
+        except AttributeError:
+            pass
+        try:
+            del sys.last_traceback
+        except AttributeError:
+            pass
+        self.assertRaises(RuntimeError, dis.dis, None)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_dis_traceback(self):
+        self.maxDiff = None
+        try:
+            del sys.last_traceback
+        except AttributeError:
+            pass
+
+        try:
+            1/0
+        except Exception as e:
+            tb = e.__traceback__
+            sys.last_exc = e
+
+        tb_dis = self.get_disassemble_as_string(tb.tb_frame.f_code, tb.tb_lasti)
+        self.do_disassembly_test(None, tb_dis)
+
+    def test_dis_object(self):
+        self.assertRaises(TypeError, dis.dis, object())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_recursive(self):
+        def check(expected, **kwargs):
+            dis = self.get_disassembly(_h, **kwargs)
+            dis = self.strip_addresses(dis)
+            self.assertEqual(dis, expected)
+
+        check(dis_nested_0, depth=0)
+        check(dis_nested_1, depth=1)
+        check(dis_nested_2, depth=2)
+        check(dis_nested_2, depth=3)
+        check(dis_nested_2, depth=None)
+        check(dis_nested_2)
+
+    def test__try_compile_no_context_exc_on_error(self):
+        # see gh-102114
+        try:
+            dis._try_compile(")", "")
+        except Exception as e:
+            self.assertIsNone(e.__context__)
+
+    @staticmethod
+    def code_quicken(f, times=ADAPTIVE_WARMUP_DELAY):
+        for _ in range(times):
+            f()
+
+    @cpython_only
+    @requires_specialization
+    def test_super_instructions(self):
+        self.code_quicken(lambda: load_test(0, 0))
+        got = self.get_disassembly(load_test, adaptive=True)
+        self.do_disassembly_compare(got, dis_load_test_quickened_code)
+
+    @cpython_only
+    @requires_specialization
+    def test_binary_specialize(self):
+        binary_op_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (a)
+              LOAD_NAME                1 (b)
+              %s
+              RETURN_VALUE
+"""
+        co_int = compile('a + b', "<int>", "eval")
+        self.code_quicken(lambda: exec(co_int, {}, {'a': 1, 'b': 2}))
+        got = self.get_disassembly(co_int, adaptive=True)
+        self.do_disassembly_compare(got, binary_op_quicken % "BINARY_OP_ADD_INT        0 (+)")
+
+        co_unicode = compile('a + b', "<unicode>", "eval")
+        self.code_quicken(lambda: exec(co_unicode, {}, {'a': 'a', 'b': 'b'}))
+        got = self.get_disassembly(co_unicode, adaptive=True)
+        self.do_disassembly_compare(got, binary_op_quicken % "BINARY_OP_ADD_UNICODE    0 (+)")
+
+        binary_subscr_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (a)
+              LOAD_CONST               0 (0)
+              %s
+              RETURN_VALUE
+"""
+        co_list = compile('a[0]', "<list>", "eval")
+        self.code_quicken(lambda: exec(co_list, {}, {'a': [0]}))
+        got = self.get_disassembly(co_list, adaptive=True)
+        self.do_disassembly_compare(got, binary_subscr_quicken % "BINARY_SUBSCR_LIST_INT")
+
+        co_dict = compile('a[0]', "<dict>", "eval")
+        self.code_quicken(lambda: exec(co_dict, {}, {'a': {0: '1'}}))
+        got = self.get_disassembly(co_dict, adaptive=True)
+        self.do_disassembly_compare(got, binary_subscr_quicken % "BINARY_SUBSCR_DICT")
+
+    @cpython_only
+    @requires_specialization
+    def test_load_attr_specialize(self):
+        load_attr_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_CONST               0 ('a')
+              LOAD_ATTR_SLOT           0 (__class__)
+              RETURN_VALUE
+"""
+        co = compile("'a'.__class__", "", "eval")
+        self.code_quicken(lambda: exec(co, {}, {}))
+        got = self.get_disassembly(co, adaptive=True)
+        self.do_disassembly_compare(got, load_attr_quicken)
+
+    @cpython_only
+    @requires_specialization
+    def test_call_specialize(self):
+        call_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (str)
+              PUSH_NULL
+              LOAD_CONST               0 (1)
+              CALL_STR_1               1
+              RETURN_VALUE
+"""
+        co = compile("str(1)", "", "eval")
+        self.code_quicken(lambda: exec(co, {}, {}))
+        got = self.get_disassembly(co, adaptive=True)
+        self.do_disassembly_compare(got, call_quicken)
+
+    @cpython_only
+    @requires_specialization
+    def test_loop_quicken(self):
+        # Loop can trigger a quicken where the loop is located
+        self.code_quicken(loop_test, 4)
+        got = self.get_disassembly(loop_test, adaptive=True)
+        expected = dis_loop_test_quickened_code
+        self.do_disassembly_compare(got, expected)
+
+    @cpython_only
+    def test_extended_arg_quick(self):
+        got = self.get_disassembly(extended_arg_quick)
+        self.do_disassembly_compare(got, dis_extended_arg_quick_code)
+
+    def get_cached_values(self, quickened, adaptive):
+        def f():
+            l = []
+            for i in range(42):
+                l.append(i)
+        if quickened:
+            self.code_quicken(f)
+        else:
+            # "copy" the code to un-quicken it:
+            f.__code__ = f.__code__.replace()
+        for instruction in _unroll_caches_as_Instructions(dis.get_instructions(
+            f, show_caches=True, adaptive=adaptive
+        ), show_caches=True):
+            if instruction.opname == "CACHE":
+                yield instruction.argrepr
+
+    @cpython_only
+    def test_show_caches(self):
+        for quickened in (False, True):
+            for adaptive in (False, True):
+                with self.subTest(f"{quickened=}, {adaptive=}"):
+                    if adaptive:
+                        pattern = r"^(\w+: \d+)?$"
+                    else:
+                        pattern = r"^(\w+: 0)?$"
+                    caches = list(self.get_cached_values(quickened, adaptive))
+                    for cache in caches:
+                        self.assertRegex(cache, pattern)
+                    total_caches = 21
+                    empty_caches = 7
+                    self.assertEqual(caches.count(""), empty_caches)
+                    self.assertEqual(len(caches), total_caches)
+
+    @cpython_only
+    def test_show_currinstr_with_cache(self):
+        """
+        Make sure that with lasti pointing to CACHE, it still shows the current
+        line correctly
+        """
+        def f():
+            print(a)
+        # The code above should generate a LOAD_GLOBAL which has CACHE instr after
+        # However, this might change in the future. So we explicitly try to find
+        # a CACHE entry in the instructions. If we can't do that, fail the test
+
+        for inst in _unroll_caches_as_Instructions(
+                dis.get_instructions(f, show_caches=True), show_caches=True):
+            if inst.opname == "CACHE":
+                op_offset = inst.offset - 2
+                cache_offset = inst.offset
+                break
+            else:
+                opname = inst.opname
+        else:
+            self.fail("Can't find a CACHE entry in the function provided to do the test")
+
+        assem_op = self.get_disassembly(f.__code__, lasti=op_offset, wrapper=False)
+        assem_cache = self.get_disassembly(f.__code__, lasti=cache_offset, wrapper=False)
+
+        # Make sure --> exists and points to the correct op
+        self.assertRegex(assem_op, fr"--> {opname}")
+        # Make sure when lasti points to cache, it shows the same disassembly
+        self.assertEqual(assem_op, assem_cache)
+
+
+class DisWithFileTests(DisTests):
+
+    # Run the tests again, using the file arg instead of print
+    def get_disassembly(self, func, lasti=-1, wrapper=True, **kwargs):
+        output = io.StringIO()
+        if wrapper:
+            dis.dis(func, file=output, **kwargs)
+        else:
+            dis.disassemble(func, lasti, file=output, **kwargs)
+        return output.getvalue()
+
+
+if dis.code_info.__doc__ is None:
+    code_info_consts = "0: None"
+else:
+    code_info_consts = "0: 'Formatted details of methods, functions, or code.'"
+
+code_info_code_info = f"""\
+Name:              code_info
+Filename:          (.*)
+Argument count:    1
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  1
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS
+Constants:
+   {code_info_consts}
+Names:
+   0: _format_code_info
+   1: _get_code_object
+Variable names:
+   0: x"""
+
+
+@staticmethod
+def tricky(a, b, /, x, y, z=True, *args, c, d, e=[], **kwds):
+    def f(c=c):
+        print(a, b, x, y, z, c, d, e, f)
+    yield a, b, x, y, z, c, d, e, f
+
+code_info_tricky = """\
+Name:              tricky
+Filename:          (.*)
+Argument count:    5
+Positional-only arguments: 2
+Kw-only arguments: 3
+Number of locals:  10
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, VARARGS, VARKEYWORDS, GENERATOR
+Constants:
+   0: None
+   1: <code object f at (.*), file "(.*)", line (.*)>
+Variable names:
+   0: a
+   1: b
+   2: x
+   3: y
+   4: z
+   5: c
+   6: d
+   7: e
+   8: args
+   9: kwds
+Cell variables:
+   0: [abedfxyz]
+   1: [abedfxyz]
+   2: [abedfxyz]
+   3: [abedfxyz]
+   4: [abedfxyz]
+   5: [abedfxyz]"""
+# NOTE: the order of the cell variables above depends on dictionary order!
+
+co_tricky_nested_f = tricky.__func__.__code__.co_consts[1]
+
+code_info_tricky_nested_f = """\
+Filename:          (.*)
+Argument count:    1
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  1
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, NESTED
+Constants:
+   0: None
+Names:
+   0: print
+Variable names:
+   0: c
+Free variables:
+   0: [abedfxyz]
+   1: [abedfxyz]
+   2: [abedfxyz]
+   3: [abedfxyz]
+   4: [abedfxyz]
+   5: [abedfxyz]"""
+
+code_info_expr_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 1
+Names:
+   0: x"""
+
+code_info_simple_stmt_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 1
+   1: None
+Names:
+   0: x"""
+
+code_info_compound_stmt_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 0
+   1: 1
+Names:
+   0: x"""
+
+
+async def async_def():
+    await 1
+    async for a in b: pass
+    async with c as d: pass
+
+code_info_async_def = """\
+Name:              async_def
+Filename:          (.*)
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  2
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, COROUTINE
+Constants:
+   0: None
+   1: 1
+Names:
+   0: b
+   1: c
+Variable names:
+   0: a
+   1: d"""
+
+class CodeInfoTests(unittest.TestCase):
+    test_pairs = [
+      (dis.code_info, code_info_code_info),
+      (tricky, code_info_tricky),
+      (co_tricky_nested_f, code_info_tricky_nested_f),
+      (expr_str, code_info_expr_str),
+      (simple_stmt_str, code_info_simple_stmt_str),
+      (compound_stmt_str, code_info_compound_stmt_str),
+      (async_def, code_info_async_def)
+    ]
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_code_info(self):
+        self.maxDiff = 1000
+        for x, expected in self.test_pairs:
+            self.assertRegex(dis.code_info(x), expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_code(self):
+        self.maxDiff = 1000
+        for x, expected in self.test_pairs:
+            with captured_stdout() as output:
+                dis.show_code(x)
+            self.assertRegex(output.getvalue(), expected+"\n")
+            output = io.StringIO()
+            dis.show_code(x, file=output)
+            self.assertRegex(output.getvalue(), expected)
+
+    def test_code_info_object(self):
+        self.assertRaises(TypeError, dis.code_info, object())
+
+    def test_pretty_flags_no_flags(self):
+        self.assertEqual(dis.pretty_flags(0), '0x0')
+
+
+# Fodder for instruction introspection tests
+#   Editing any of these may require recalculating the expected output
+def outer(a=1, b=2):
+    def f(c=3, d=4):
+        def inner(e=5, f=6):
+            print(a, b, c, d, e, f)
+        print(a, b, c, d)
+        return inner
+    print(a, b, '', 1, [], {}, "Hello world!")
+    return f
+
+def jumpy():
+    # This won't actually run (but that's OK, we only disassemble it)
+    for i in range(10):
+        print(i)
+        if i < 4:
+            continue
+        if i > 6:
+            break
+    else:
+        print("I can haz else clause?")
+    while i:
+        print(i)
+        i -= 1
+        if i > 6:
+            continue
+        if i < 4:
+            break
+    else:
+        print("Who let lolcatz into this test suite?")
+    try:
+        1 / 0
+    except ZeroDivisionError:
+        print("Here we go, here we go, here we go...")
+    else:
+        with i as dodgy:
+            print("Never reach this")
+    finally:
+        print("OK, now we're done")
+
+# End fodder for opinfo generation tests
+expected_outer_line = 1
+_line_offset = outer.__code__.co_firstlineno - 1
+code_object_f = outer.__code__.co_consts[1]
+# expected_f_line = code_object_f.co_firstlineno - _line_offset # TODO: RUSTPYTHON; AttributeError: 'int' object has no attribute 'co_firstlineno'
+# code_object_inner = code_object_f.co_consts[1] # TODO: RUSTPYTHON; AttributeError: 'int' object has no attribute 'co_consts'
+# expected_inner_line = code_object_inner.co_firstlineno - _line_offset # TODO: RUSTPYTHON; NameError: name 'code_object_inner' is not defined
+expected_jumpy_line = 1
+
+# The following lines are useful to regenerate the expected results after
+# either the fodder is modified or the bytecode generation changes
+# After regeneration, update the references to code_object_f and
+# code_object_inner before rerunning the tests
+
+def _stringify_instruction(instr):
+    # Since line numbers and other offsets change a lot for these
+    # test cases, ignore them.
+    return f"  {instr._replace(positions=None)!r},"
+
+def _prepare_test_cases():
+    ignore = io.StringIO()
+    with contextlib.redirect_stdout(ignore):
+        f = outer()
+        inner = f()
+    _instructions_outer = dis.get_instructions(outer, first_line=expected_outer_line)
+    _instructions_f = dis.get_instructions(f, first_line=expected_f_line)
+    _instructions_inner = dis.get_instructions(inner, first_line=expected_inner_line)
+    _instructions_jumpy = dis.get_instructions(jumpy, first_line=expected_jumpy_line)
+    result = "\n".join(
+        [
+            "expected_opinfo_outer = [",
+            *map(_stringify_instruction, _instructions_outer),
+            "]",
+            "",
+            "expected_opinfo_f = [",
+            *map(_stringify_instruction, _instructions_f),
+            "]",
+            "",
+            "expected_opinfo_inner = [",
+            *map(_stringify_instruction, _instructions_inner),
+            "]",
+            "",
+            "expected_opinfo_jumpy = [",
+            *map(_stringify_instruction, _instructions_jumpy),
+            "]",
+        ]
+    )
+    result = result.replace(repr(repr(code_object_f)), "repr(code_object_f)")
+    result = result.replace(repr(code_object_f), "code_object_f")
+    result = result.replace(repr(repr(code_object_inner)), "repr(code_object_inner)")
+    result = result.replace(repr(code_object_inner), "code_object_inner")
+    print(result)
+
+# from test.test_dis import _prepare_test_cases; _prepare_test_cases()
+
+Instruction = dis.Instruction
+
+expected_opinfo_outer = [
+  Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=4, start_offset=4, starts_line=True, line_number=1, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='BUILD_TUPLE', opcode=52, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='MAKE_FUNCTION', opcode=26, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='BUILD_LIST', opcode=47, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='BUILD_MAP', opcode=48, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None),
+  Instruction(opname='RETURN_VALUE', opcode=36, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None),
+]
+
+expected_opinfo_f = [
+  Instruction(opname='COPY_FREE_VARS', opcode=62, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='BUILD_TUPLE', opcode=52, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None),
+  #Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None), # TODO: RUSTPYTHON; NameError: name 'code_object_inner' is not defined
+  Instruction(opname='MAKE_FUNCTION', opcode=26, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None),
+  Instruction(opname='RETURN_VALUE', opcode=36, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None),
+]
+
+expected_opinfo_inner = [
+  Instruction(opname='COPY_FREE_VARS', opcode=62, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=88, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None),
+]
+
+expected_opinfo_jumpy = [
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='GET_ITER', opcode=19, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='FOR_ITER', opcode=72, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None),
+  Instruction(opname='JUMP_FORWARD', opcode=79, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None),
+  Instruction(opname='END_FOR', opcode=11, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST_CHECK', opcode=87, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=40, argval=208, argrepr='to L9', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=6, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='BINARY_OP', opcode=45, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=176, argrepr='to L7', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=7, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=1, argval=190, argrepr='to L8', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_FORWARD', opcode=79, arg=20, argval=230, argrepr='to L10', offset=188, start_offset=188, starts_line=True, line_number=17, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=190, start_offset=190, starts_line=True, line_number=11, label=8, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=192, start_offset=192, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=208, argrepr='to L9', offset=200, start_offset=200, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=40, argval=128, argrepr='to L6', offset=204, start_offset=204, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=208, start_offset=208, starts_line=True, line_number=19, label=9, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=218, start_offset=218, starts_line=False, line_number=19, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=220, start_offset=220, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=228, start_offset=228, starts_line=False, line_number=19, label=None, positions=None, cache_info=None),
+  Instruction(opname='NOP', opcode=30, arg=None, argval=None, argrepr='', offset=230, start_offset=230, starts_line=True, line_number=20, label=10, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=1, argrepr='1', offset=232, start_offset=232, starts_line=True, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=7, argval=0, argrepr='0', offset=234, start_offset=234, starts_line=False, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='BINARY_OP', opcode=45, arg=11, argval=11, argrepr='/', offset=236, start_offset=236, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=242, start_offset=242, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='BEFORE_WITH', opcode=2, arg=None, argval=None, argrepr='', offset=244, start_offset=244, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=1, argval='dodgy', argrepr='dodgy', offset=246, start_offset=246, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=248, start_offset=248, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=258, start_offset=258, starts_line=False, line_number=26, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=268, start_offset=268, starts_line=False, line_number=26, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=270, start_offset=270, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=2, argval=2, argrepr='', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=284, start_offset=284, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=286, start_offset=286, starts_line=True, line_number=28, label=11, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=296, start_offset=296, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=306, start_offset=306, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=310, start_offset=310, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='WITH_EXCEPT_START', opcode=44, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=1, argval=328, argrepr='to L12', offset=322, start_offset=322, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='RERAISE', opcode=102, arg=2, argval=2, argrepr='', offset=326, start_offset=326, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=12, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=78, arg=26, argval=286, argrepr='to L11', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=338, start_offset=338, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=340, start_offset=340, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=342, start_offset=342, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=346, start_offset=346, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='CHECK_EXC_MATCH', opcode=7, arg=None, argval=None, argrepr='', offset=356, start_offset=356, starts_line=False, line_number=22, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=14, argval=390, argrepr='to L13', offset=358, start_offset=358, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=364, start_offset=364, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=374, start_offset=374, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=376, start_offset=376, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=384, start_offset=384, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=386, start_offset=386, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=78, arg=52, argval=286, argrepr='to L11', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=390, start_offset=390, starts_line=True, line_number=22, label=13, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=392, start_offset=392, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=394, start_offset=394, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=396, start_offset=396, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=400, start_offset=400, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=410, start_offset=410, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=412, start_offset=412, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=420, start_offset=420, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=422, start_offset=422, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=424, start_offset=424, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=428, start_offset=428, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+]
+
+# One last piece of inspect fodder to check the default line number handling
+def simple(): pass
+expected_opinfo_simple = [
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=simple.__code__.co_firstlineno, label=None, positions=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None),
+]
+
+
+class InstructionTestCase(BytecodeTestCase):
+
+    def assertInstructionsEqual(self, instrs_1, instrs_2, /):
+        instrs_1 = [instr_1._replace(positions=None, cache_info=None) for instr_1 in instrs_1]
+        instrs_2 = [instr_2._replace(positions=None, cache_info=None) for instr_2 in instrs_2]
+        self.assertEqual(instrs_1, instrs_2)
+
+class InstructionTests(InstructionTestCase):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.maxDiff = None
+
+    def test_instruction_str(self):
+        # smoke test for __str__
+        instrs = dis.get_instructions(simple)
+        for instr in instrs:
+            str(instr)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_default_first_line(self):
+        actual = dis.get_instructions(simple)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_simple)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_first_line_set_to_None(self):
+        actual = dis.get_instructions(simple, first_line=None)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_simple)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_outer(self):
+        actual = dis.get_instructions(outer, first_line=expected_outer_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_outer)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_nested(self):
+        with captured_stdout():
+            f = outer()
+        actual = dis.get_instructions(f, first_line=expected_f_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_doubly_nested(self):
+        with captured_stdout():
+            inner = outer()()
+        actual = dis.get_instructions(inner, first_line=expected_inner_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_inner)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_jumpy(self):
+        actual = dis.get_instructions(jumpy, first_line=expected_jumpy_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_jumpy)
+
+    @requires_debug_ranges()
+    def test_co_positions(self):
+        code = compile('f(\n  x, y, z\n)', '<test>', 'exec')
+        positions = [
+            instr.positions
+            for instr in dis.get_instructions(code)
+        ]
+        expected = [
+            (0, 1, 0, 0),
+            (1, 1, 0, 1),
+            (1, 1, 0, 1),
+            (2, 2, 2, 3),
+            (2, 2, 5, 6),
+            (2, 2, 8, 9),
+            (1, 3, 0, 1),
+            (1, 3, 0, 1),
+            (1, 3, 0, 1)
+        ]
+        self.assertEqual(positions, expected)
+
+        named_positions = [
+            (pos.lineno, pos.end_lineno, pos.col_offset, pos.end_col_offset)
+            for pos in positions
+        ]
+        self.assertEqual(named_positions, expected)
+
+    @requires_debug_ranges()
+    def test_co_positions_missing_info(self):
+        code = compile('x, y, z', '<test>', 'exec')
+        code_without_location_table = code.replace(co_linetable=b'')
+        actual = dis.get_instructions(code_without_location_table)
+        for instruction in actual:
+            with self.subTest(instruction=instruction):
+                positions = instruction.positions
+                self.assertEqual(len(positions), 4)
+                if instruction.opname == "RESUME":
+                    continue
+                self.assertIsNone(positions.lineno)
+                self.assertIsNone(positions.end_lineno)
+                self.assertIsNone(positions.col_offset)
+                self.assertIsNone(positions.end_col_offset)
+
+    @requires_debug_ranges()
+    def test_co_positions_with_lots_of_caches(self):
+        def roots(a, b, c):
+            d = b**2 - 4 * a * c
+            yield (-b - cmath.sqrt(d)) / (2 * a)
+            if d:
+                yield (-b + cmath.sqrt(d)) / (2 * a)
+        code = roots.__code__
+        ops = code.co_code[::2]
+        cache_opcode = opcode.opmap["CACHE"]
+        caches = sum(op == cache_opcode for op in ops)
+        non_caches = len(ops) - caches
+        # Make sure we have "lots of caches". If not, roots should be changed:
+        assert 1 / 3 <= caches / non_caches, "this test needs more caches!"
+        for show_caches in (False, True):
+            for adaptive in (False, True):
+                with self.subTest(f"{adaptive=}, {show_caches=}"):
+                    co_positions = [
+                        positions
+                        for op, positions in zip(ops, code.co_positions(), strict=True)
+                        if show_caches or op != cache_opcode
+                    ]
+                    dis_positions = [
+                        None if instruction.positions is None else (
+                            instruction.positions.lineno,
+                            instruction.positions.end_lineno,
+                            instruction.positions.col_offset,
+                            instruction.positions.end_col_offset,
+                        )
+                        for instruction in _unroll_caches_as_Instructions(dis.get_instructions(
+                            code, adaptive=adaptive, show_caches=show_caches
+                        ), show_caches=show_caches)
+                    ]
+                    self.assertEqual(co_positions, dis_positions)
+
+    def test_oparg_alias(self):
+        instruction = Instruction(opname="NOP", opcode=dis.opmap["NOP"], arg=None, argval=None,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(instruction.arg, instruction.oparg)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_caches_with_label(self):
+        def f(x, y, z):
+            if x:
+                res = y
+            else:
+                res = z
+            return res
+
+        output = io.StringIO()
+        dis.dis(f.__code__, file=output, show_caches=True)
+        self.assertIn("L1:", output.getvalue())
+
+    def test_baseopname_and_baseopcode(self):
+        # Standard instructions
+        for name, code in dis.opmap.items():
+            instruction = Instruction(opname=name, opcode=code, arg=None, argval=None, argrepr='', offset=0,
+                                      start_offset=0, starts_line=True, line_number=1, label=None, positions=None)
+            baseopname = instruction.baseopname
+            baseopcode = instruction.baseopcode
+            self.assertIsNotNone(baseopname)
+            self.assertIsNotNone(baseopcode)
+            self.assertEqual(name, baseopname)
+            self.assertEqual(code, baseopcode)
+
+        # Specialized instructions
+        for name in opcode._specialized_opmap:
+            instruction = Instruction(opname=name, opcode=dis._all_opmap[name], arg=None, argval=None, argrepr='',
+                                      offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None)
+            baseopname = instruction.baseopname
+            baseopcode = instruction.baseopcode
+            self.assertIn(name, opcode._specializations[baseopname])
+            self.assertEqual(opcode.opmap[baseopname], baseopcode)
+
+    def test_jump_target(self):
+        # Non-jump instructions should return None
+        instruction = Instruction(opname="NOP", opcode=dis.opmap["NOP"], arg=None, argval=None,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertIsNone(instruction.jump_target)
+
+        delta = 100
+        instruction = Instruction(opname="JUMP_FORWARD", opcode=dis.opmap["JUMP_FORWARD"], arg=delta, argval=delta,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(10 + 2 + 100*2, instruction.jump_target)
+
+        # Test negative deltas
+        instruction = Instruction(opname="JUMP_BACKWARD", opcode=dis.opmap["JUMP_BACKWARD"], arg=delta, argval=delta,
+                                  argrepr='', offset=200, start_offset=200, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(200 + 2 - 100*2 + 2*1, instruction.jump_target)
+
+        # Make sure cache entries are handled
+        instruction = Instruction(opname="SEND", opcode=dis.opmap["SEND"], arg=delta, argval=delta,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(10 + 2 + 1*2 + 100*2, instruction.jump_target)
+
+    def test_argval_argrepr(self):
+        def f(opcode, oparg, offset, *init_args):
+            arg_resolver = dis.ArgResolver(*init_args)
+            return arg_resolver.get_argval_argrepr(opcode, oparg, offset)
+
+        offset = 42
+        co_consts = (0, 1, 2, 3)
+        names = {1: 'a', 2: 'b'}
+        varname_from_oparg = lambda i : names[i]
+        labels_map = {24: 1}
+        args = (offset, co_consts, names, varname_from_oparg, labels_map)
+        self.assertEqual(f(opcode.opmap["POP_TOP"], None, *args), (None, ''))
+        self.assertEqual(f(opcode.opmap["LOAD_CONST"], 1, *args), (1, '1'))
+        self.assertEqual(f(opcode.opmap["LOAD_GLOBAL"], 2, *args), ('a', 'a'))
+        self.assertEqual(f(opcode.opmap["JUMP_BACKWARD"], 11, *args), (24, 'to L1'))
+        self.assertEqual(f(opcode.opmap["COMPARE_OP"], 3, *args), ('<', '<'))
+        self.assertEqual(f(opcode.opmap["SET_FUNCTION_ATTRIBUTE"], 2, *args), (2, 'kwdefaults'))
+        self.assertEqual(f(opcode.opmap["BINARY_OP"], 3, *args), (3, '<<'))
+        self.assertEqual(f(opcode.opmap["CALL_INTRINSIC_1"], 2, *args), (2, 'INTRINSIC_IMPORT_STAR'))
+
+    def test_custom_arg_resolver(self):
+        class MyArgResolver(dis.ArgResolver):
+            def offset_from_jump_arg(self, op, arg, offset):
+                return arg + 1
+
+            def get_label_for_offset(self, offset):
+                return 2 * offset
+
+        def f(opcode, oparg, offset, *init_args):
+            arg_resolver = MyArgResolver(*init_args)
+            return arg_resolver.get_argval_argrepr(opcode, oparg, offset)
+        offset = 42
+        self.assertEqual(f(opcode.opmap["JUMP_BACKWARD"], 1, offset), (2, 'to L4'))
+        self.assertEqual(f(opcode.opmap["SETUP_FINALLY"], 2, offset), (3, 'to L6'))
+
+
+    def get_instructions(self, code):
+        return dis._get_instructions_bytes(code)
+
+    def test_start_offset(self):
+        # When no extended args are present,
+        # start_offset should be equal to offset
+
+        instructions = list(dis.Bytecode(_f))
+        for instruction in instructions:
+            self.assertEqual(instruction.offset, instruction.start_offset)
+
+        def last_item(iterable):
+            return functools.reduce(lambda a, b : b, iterable)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+        ])
+        labels_map = dis._make_labels_map(code)
+        jump = last_item(self.get_instructions(code))
+        self.assertEqual(4, jump.offset)
+        self.assertEqual(2, jump.start_offset)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+        ])
+        jump = last_item(self.get_instructions(code))
+        self.assertEqual(8, jump.offset)
+        self.assertEqual(2, jump.start_offset)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+        ])
+        instructions = list(self.get_instructions(code))
+        # 1st jump
+        self.assertEqual(4, instructions[2].offset)
+        self.assertEqual(2, instructions[2].start_offset)
+        # 2nd jump
+        self.assertEqual(14, instructions[6].offset)
+        self.assertEqual(8, instructions[6].start_offset)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_cache_offset_and_end_offset(self):
+        code = bytes([
+            opcode.opmap["LOAD_GLOBAL"], 0x01,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["CALL"], 0x01,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00
+        ])
+        instructions = list(self.get_instructions(code))
+        self.assertEqual(2, instructions[0].cache_offset)
+        self.assertEqual(10, instructions[0].end_offset)
+        self.assertEqual(12, instructions[1].cache_offset)
+        self.assertEqual(12, instructions[1].end_offset)
+        self.assertEqual(14, instructions[2].cache_offset)
+        self.assertEqual(20, instructions[2].end_offset)
+
+        # end_offset of the previous instruction should be equal to the
+        # start_offset of the following instruction
+        instructions = list(dis.Bytecode(self.test_cache_offset_and_end_offset))
+        for prev, curr in zip(instructions, instructions[1:]):
+            self.assertEqual(prev.end_offset, curr.start_offset)
+
+
+# get_instructions has its own tests above, so can rely on it to validate
+# the object oriented API
+class BytecodeTests(InstructionTestCase, DisTestBase):
+
+    def test_instantiation(self):
+        # Test with function, method, code string and code object
+        for obj in [_f, _C(1).__init__, "a=1", _f.__code__]:
+            with self.subTest(obj=obj):
+                b = dis.Bytecode(obj)
+                self.assertIsInstance(b.codeobj, types.CodeType)
+
+        self.assertRaises(TypeError, dis.Bytecode, object())
+
+    def test_iteration(self):
+        for obj in [_f, _C(1).__init__, "a=1", _f.__code__]:
+            with self.subTest(obj=obj):
+                via_object = list(dis.Bytecode(obj))
+                via_generator = list(dis.get_instructions(obj))
+                self.assertInstructionsEqual(via_object, via_generator)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_explicit_first_line(self):
+        actual = dis.Bytecode(outer, first_line=expected_outer_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_outer)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_source_line_in_disassembly(self):
+        # Use the line in the source code
+        actual = dis.Bytecode(simple).dis()
+        actual = actual.strip().partition(" ")[0]  # extract the line no
+        expected = str(simple.__code__.co_firstlineno)
+        self.assertEqual(actual, expected)
+        # Use an explicit first line number
+        actual = dis.Bytecode(simple, first_line=350).dis()
+        actual = actual.strip().partition(" ")[0]  # extract the line no
+        self.assertEqual(actual, "350")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_info(self):
+        self.maxDiff = 1000
+        for x, expected in CodeInfoTests.test_pairs:
+            b = dis.Bytecode(x)
+            self.assertRegex(b.info(), expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassembled(self):
+        actual = dis.Bytecode(_f).dis()
+        self.do_disassembly_compare(actual, dis_f)
+
+    def test_from_traceback(self):
+        tb = get_tb()
+        b = dis.Bytecode.from_traceback(tb)
+        while tb.tb_next: tb = tb.tb_next
+
+        self.assertEqual(b.current_offset, tb.tb_lasti)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_from_traceback_dis(self):
+        self.maxDiff = None
+        tb = get_tb()
+        b = dis.Bytecode.from_traceback(tb)
+        self.assertEqual(b.dis(), dis_traceback)
+
+    @requires_debug_ranges()
+    def test_bytecode_co_positions(self):
+        bytecode = dis.Bytecode("a=1")
+        for instr, positions in zip(bytecode, bytecode.codeobj.co_positions()):
+            assert instr.positions == positions
+
+class TestBytecodeTestCase(BytecodeTestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assert_not_in_with_op_not_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        self.assertInBytecode(code, "LOAD_CONST", 1)
+        self.assertNotInBytecode(code, "LOAD_NAME")
+        self.assertNotInBytecode(code, "LOAD_NAME", "a")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assert_not_in_with_arg_not_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        self.assertInBytecode(code, "LOAD_CONST")
+        self.assertInBytecode(code, "LOAD_CONST", 1)
+        self.assertNotInBytecode(code, "LOAD_CONST", 2)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assert_not_in_with_arg_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        with self.assertRaises(AssertionError):
+            self.assertNotInBytecode(code, "LOAD_CONST", 1)
+
+class TestFinderMethods(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test__find_imports(self):
+        cases = [
+            ("import a.b.c", ('a.b.c', 0, None)),
+            ("from a.b import c", ('a.b', 0, ('c',))),
+            ("from a.b import c as d", ('a.b', 0, ('c',))),
+            ("from a.b import *", ('a.b', 0, ('*',))),
+            ("from ...a.b import c as d", ('a.b', 3, ('c',))),
+            ("from ..a.b import c as d, e as f", ('a.b', 2, ('c', 'e'))),
+            ("from ..a.b import *", ('a.b', 2, ('*',))),
+        ]
+        for src, expected in cases:
+            with self.subTest(src=src):
+                code = compile(src, "<string>", "exec")
+                res = tuple(dis._find_imports(code))
+                self.assertEqual(len(res), 1)
+                self.assertEqual(res[0], expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test__find_store_names(self):
+        cases = [
+            ("x+y", ()),
+            ("x=y=1", ('x', 'y')),
+            ("x+=y", ('x',)),
+            ("global x\nx=y=1", ('x', 'y')),
+            ("global x\nz=x", ('z',)),
+        ]
+        for src, expected in cases:
+            with self.subTest(src=src):
+                code = compile(src, "<string>", "exec")
+                res = tuple(dis._find_store_names(code))
+                self.assertEqual(res, expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_findlabels(self):
+        labels = dis.findlabels(jumpy.__code__.co_code)
+        jumps = [
+            instr.offset
+            for instr in expected_opinfo_jumpy
+            if instr.is_jump_target
+        ]
+
+        self.assertEqual(sorted(labels), sorted(jumps))
+
+    def test_findlinestarts(self):
+        def func():
+            pass
+
+        code = func.__code__
+        offsets = [linestart[0] for linestart in dis.findlinestarts(code)]
+        self.assertEqual(offsets, [0, 2])
+
+
+class TestDisTraceback(DisTestBase):
+    def setUp(self) -> None:
+        try:  # We need to clean up existing tracebacks
+            del sys.last_exc
+        except AttributeError:
+            pass
+        try:  # We need to clean up existing tracebacks
+            del sys.last_traceback
+        except AttributeError:
+            pass
+        return super().setUp()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def get_disassembly(self, tb):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.distb(tb)
+        return output.getvalue()
+
+    def test_distb_empty(self):
+        with self.assertRaises(RuntimeError):
+            dis.distb()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_distb_last_traceback(self):
+        self.maxDiff = None
+        # We need to have an existing last traceback in `sys`:
+        tb = get_tb()
+        sys.last_traceback = tb
+
+        self.do_disassembly_compare(self.get_disassembly(None), dis_traceback)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_distb_explicit_arg(self):
+        self.maxDiff = None
+        tb = get_tb()
+
+        self.do_disassembly_compare(self.get_disassembly(tb), dis_traceback)
+
+
+class TestDisTracebackWithFile(TestDisTraceback):
+    # Run the `distb` tests again, using the file arg instead of print
+    def get_disassembly(self, tb):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.distb(tb, file=output)
+        return output.getvalue()
+
+def _unroll_caches_as_Instructions(instrs, show_caches=False):
+    # Cache entries are no longer reported by dis as fake instructions,
+    # but some tests assume that do. We should rewrite the tests to assume
+    # the new API, but it will be clearer to keep the tests working as
+    # before and do that in a separate PR.
+
+    for instr in instrs:
+        yield instr
+        if not show_caches:
+            continue
+
+        offset = instr.offset
+        for name, size, data in (instr.cache_info or ()):
+            for i in range(size):
+                offset += 2
+                # Only show the fancy argrepr for a CACHE instruction when it's
+                # the first entry for a particular cache value:
+                if i == 0:
+                    argrepr = f"{name}: {int.from_bytes(data, sys.byteorder)}"
+                else:
+                    argrepr = ""
+
+                yield Instruction("CACHE", CACHE, 0, None, argrepr, offset, offset,
+                                  False, None, None, instr.positions)
+
+
+class TestDisCLI(unittest.TestCase):
+
+    def setUp(self):
+        self.filename = tempfile.mktemp()
+        self.addCleanup(os_helper.unlink, self.filename)
+
+    @staticmethod
+    def text_normalize(string):
+        """Dedent *string* and strip it from its surrounding whitespaces.
+
+        This method is used by the other utility functions so that any
+        string to write or to match against can be freely indented.
+        """
+        return textwrap.dedent(string).strip()
+
+    def set_source(self, content):
+        with open(self.filename, 'w') as fp:
+            fp.write(self.text_normalize(content))
+
+    def invoke_dis(self, *flags):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.main(args=[*flags, self.filename])
+        return self.text_normalize(output.getvalue())
+
+    def check_output(self, source, expect, *flags):
+        with self.subTest(source=source, flags=flags):
+            self.set_source(source)
+            res = self.invoke_dis(*flags)
+            expect = self.text_normalize(expect)
+            self.assertListEqual(res.splitlines(), expect.splitlines())
+
+    def test_invocation(self):
+        # test various combinations of parameters
+        base_flags = [
+            ('-C', '--show-caches'),
+            ('-O', '--show-offsets'),
+        ]
+
+        self.set_source('''
+            def f():
+                print(x)
+                return None
+        ''')
+
+        for r in range(1, len(base_flags) + 1):
+            for choices in itertools.combinations(base_flags, r=r):
+                for args in itertools.product(*choices):
+                    with self.subTest(args=args[1:]):
+                        _ = self.invoke_dis(*args)
+
+        with self.assertRaises(SystemExit):
+            # suppress argparse error message
+            with contextlib.redirect_stderr(io.StringIO()):
+                _ = self.invoke_dis('--unknown')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_cache(self):
+        # test 'python -m dis -C/--show-caches'
+        source = 'print()'
+        expect = '''
+            0           RESUME                   0
+
+            1           LOAD_NAME                0 (print)
+                        PUSH_NULL
+                        CALL                     0
+                        CACHE                    0 (counter: 0)
+                        CACHE                    0 (func_version: 0)
+                        CACHE                    0
+                        POP_TOP
+                        RETURN_CONST             0 (None)
+        '''
+        for flag in ['-C', '--show-caches']:
+            self.check_output(source, expect, flag)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_offsets(self):
+        # test 'python -m dis -O/--show-offsets'
+        source = 'pass'
+        expect = '''
+            0          0       RESUME                   0
+
+            1          2       RETURN_CONST             0 (None)
+        '''
+        for flag in ['-O', '--show-offsets']:
+            self.check_output(source, expect, flag)
 
 
 if __name__ == "__main__":

From 5b20c458af41b8439f50976a0e30bef3281f88f1 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 27 Dec 2025 23:03:23 +0900
Subject: [PATCH 084/418] Implement more except* (#6545)

* clean build documentation

* SetExcInfo

* fix EG subclass

* test_except_star
---
 .github/copilot-instructions.md      |    8 +
 Lib/test/test_except_star.py         | 1220 ++++++++++++++++++++++++++
 crates/codegen/src/compile.rs        |  245 +++++-
 crates/codegen/src/error.rs          |    8 +
 crates/compiler-core/src/bytecode.rs |    7 +-
 crates/vm/src/exceptions.rs          |  210 ++++-
 crates/vm/src/frame.rs               |   17 +-
 7 files changed, 1634 insertions(+), 81 deletions(-)
 create mode 100644 Lib/test/test_except_star.py

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 1db02dd17a9..a2ab43a695c 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -73,6 +73,14 @@ The `Lib/` directory contains Python standard library files copied from the CPyt
   - `unittest.skip("TODO: RustPython <reason>")`
   - `unittest.expectedFailure` with `# TODO: RUSTPYTHON <reason>` comment
 
+### Clean Build
+
+When you modify bytecode instructions, a full clean is required:
+
+```bash
+rm -r target/debug/build/rustpython-* && find . | grep -E "\.pyc$" | xargs rm -r
+```
+
 ### Testing
 
 ```bash
diff --git a/Lib/test/test_except_star.py b/Lib/test/test_except_star.py
new file mode 100644
index 00000000000..3e0f8caa9b2
--- /dev/null
+++ b/Lib/test/test_except_star.py
@@ -0,0 +1,1220 @@
+import sys
+import unittest
+import textwrap
+from test.support.testcase import ExceptionIsLikeMixin
+
+class TestInvalidExceptStar(unittest.TestCase):
+    def test_mixed_except_and_except_star_is_syntax_error(self):
+        errors = [
+            "try: pass\nexcept ValueError: pass\nexcept* TypeError: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept TypeError: pass\n",
+            "try: pass\nexcept ValueError as e: pass\nexcept* TypeError: pass\n",
+            "try: pass\nexcept* ValueError as e: pass\nexcept TypeError: pass\n",
+            "try: pass\nexcept ValueError: pass\nexcept* TypeError as e: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept TypeError as e: pass\n",
+            "try: pass\nexcept ValueError: pass\nexcept*: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept: pass\n",
+        ]
+
+        for err in errors:
+            with self.assertRaises(SyntaxError):
+                compile(err, "<string>", "exec")
+
+    def test_except_star_ExceptionGroup_is_runtime_error_single(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise OSError("blah")
+            except* ExceptionGroup as e:
+                pass
+
+    def test_except_star_ExceptionGroup_is_runtime_error_tuple(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise ExceptionGroup("eg", [ValueError(42)])
+            except* (TypeError, ExceptionGroup):
+                pass
+
+    def test_except_star_invalid_exception_type(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise ValueError
+            except* 42:
+                pass
+
+        with self.assertRaises(TypeError):
+            try:
+                raise ValueError
+            except* (ValueError, 42):
+                pass
+
+
+class TestBreakContinueReturnInExceptStarBlock(unittest.TestCase):
+    MSG = (r"'break', 'continue' and 'return'"
+           r" cannot appear in an except\* block")
+
+    def check_invalid(self, src):
+        with self.assertRaisesRegex(SyntaxError, self.MSG):
+            compile(textwrap.dedent(src), "<string>", "exec")
+
+    def test_break_in_except_star(self):
+        self.check_invalid(
+            """
+            try:
+                raise ValueError
+            except* Exception as e:
+                break
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        break
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        break
+                finally:
+                    return 0
+            """)
+
+
+    def test_continue_in_except_star_block_invalid(self):
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    raise ValueError
+                except* Exception as e:
+                    continue
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        continue
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        continue
+                finally:
+                    return 0
+            """)
+
+    def test_return_in_except_star_block_invalid(self):
+        self.check_invalid(
+            """
+            def f():
+                try:
+                    raise ValueError
+                except* Exception as e:
+                    return 42
+            """)
+
+        self.check_invalid(
+            """
+            def f():
+                try:
+                    pass
+                except* Exception as e:
+                    return 42
+                finally:
+                    finished = True
+            """)
+
+    def test_break_continue_in_except_star_block_valid(self):
+        try:
+            raise ValueError(42)
+        except* Exception as e:
+            count = 0
+            for i in range(5):
+                if i == 0:
+                    continue
+                if i == 4:
+                    break
+                count += 1
+
+            self.assertEqual(count, 3)
+            self.assertEqual(i, 4)
+            exc = e
+        self.assertIsInstance(exc, ExceptionGroup)
+
+    def test_return_in_except_star_block_valid(self):
+        try:
+            raise ValueError(42)
+        except* Exception as e:
+            def f(x):
+                return 2*x
+            r = f(3)
+            exc = e
+        self.assertEqual(r, 6)
+        self.assertIsInstance(exc, ExceptionGroup)
+
+
+class ExceptStarTest(ExceptionIsLikeMixin, unittest.TestCase):
+    def assertMetadataEqual(self, e1, e2):
+        if e1 is None or e2 is None:
+            self.assertTrue(e1 is None and e2 is None)
+        else:
+            self.assertEqual(e1.__context__, e2.__context__)
+            self.assertEqual(e1.__cause__, e2.__cause__)
+            self.assertEqual(e1.__traceback__, e2.__traceback__)
+
+    def assertMetadataNotEqual(self, e1, e2):
+        if e1 is None or e2 is None:
+            self.assertNotEqual(e1, e2)
+        else:
+            return not (e1.__context__ == e2.__context__
+                        and e1.__cause__ == e2.__cause__
+                        and e1.__traceback__ == e2.__traceback__)
+
+
+class TestExceptStarSplitSemantics(ExceptStarTest):
+    def doSplitTestNamed(self, exc, T, match_template, rest_template):
+        initial_sys_exception = sys.exception()
+        sys_exception = match = rest = None
+        try:
+            try:
+                raise exc
+            except* T as e:
+                sys_exception = sys.exception()
+                match = e
+        except BaseException as e:
+            rest = e
+
+        self.assertEqual(sys_exception, match)
+        self.assertExceptionIsLike(match, match_template)
+        self.assertExceptionIsLike(rest, rest_template)
+        self.assertEqual(sys.exception(), initial_sys_exception)
+
+    def doSplitTestUnnamed(self, exc, T, match_template, rest_template):
+        initial_sys_exception = sys.exception()
+        sys_exception = match = rest = None
+        try:
+            try:
+                raise exc
+            except* T:
+                sys_exception = match = sys.exception()
+            else:
+                if rest_template:
+                    self.fail("Exception not raised")
+        except BaseException as e:
+            rest = e
+        self.assertExceptionIsLike(match, match_template)
+        self.assertExceptionIsLike(rest, rest_template)
+        self.assertEqual(sys.exception(), initial_sys_exception)
+
+    def doSplitTestInExceptHandler(self, exc, T, match_template, rest_template):
+        try:
+            raise ExceptionGroup('eg', [TypeError(1), ValueError(2)])
+        except Exception:
+            self.doSplitTestNamed(exc, T, match_template, rest_template)
+            self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+
+    def doSplitTestInExceptStarHandler(self, exc, T, match_template, rest_template):
+        try:
+            raise ExceptionGroup('eg', [TypeError(1), ValueError(2)])
+        except* Exception:
+            self.doSplitTestNamed(exc, T, match_template, rest_template)
+            self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+
+    def doSplitTest(self, exc, T, match_template, rest_template):
+        self.doSplitTestNamed(exc, T, match_template, rest_template)
+        self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+        self.doSplitTestInExceptHandler(exc, T, match_template, rest_template)
+        self.doSplitTestInExceptStarHandler(exc, T, match_template, rest_template)
+
+    def test_no_match_single_type(self):
+        self.doSplitTest(
+            ExceptionGroup("test1", [ValueError("V"), TypeError("T")]),
+            SyntaxError,
+            None,
+            ExceptionGroup("test1", [ValueError("V"), TypeError("T")]))
+
+    def test_match_single_type(self):
+        self.doSplitTest(
+            ExceptionGroup("test2", [ValueError("V1"), ValueError("V2")]),
+            ValueError,
+            ExceptionGroup("test2", [ValueError("V1"), ValueError("V2")]),
+            None)
+
+    def test_match_single_type_partial_match(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "test3",
+                [ValueError("V1"), OSError("OS"), ValueError("V2")]),
+            ValueError,
+            ExceptionGroup("test3", [ValueError("V1"), ValueError("V2")]),
+            ExceptionGroup("test3", [OSError("OS")]))
+
+    def test_match_single_type_nested(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "g1", [
+                ValueError("V1"),
+                OSError("OS1"),
+                ExceptionGroup(
+                    "g2", [
+                    OSError("OS2"),
+                    ValueError("V2"),
+                    TypeError("T")])]),
+            ValueError,
+            ExceptionGroup(
+                "g1", [
+                ValueError("V1"),
+                ExceptionGroup("g2", [ValueError("V2")])]),
+            ExceptionGroup("g1", [
+                OSError("OS1"),
+                ExceptionGroup("g2", [
+                    OSError("OS2"), TypeError("T")])]))
+
+    def test_match_type_tuple_nested(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "h1", [
+                ValueError("V1"),
+                OSError("OS1"),
+                ExceptionGroup(
+                    "h2", [OSError("OS2"), ValueError("V2"), TypeError("T")])]),
+            (ValueError, TypeError),
+            ExceptionGroup(
+                "h1", [
+                ValueError("V1"),
+                ExceptionGroup("h2", [ValueError("V2"), TypeError("T")])]),
+            ExceptionGroup(
+                "h1", [
+                OSError("OS1"),
+                ExceptionGroup("h2", [OSError("OS2")])]))
+
+    def test_empty_groups_removed(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "eg", [
+                ExceptionGroup("i1", [ValueError("V1")]),
+                ExceptionGroup("i2", [ValueError("V2"), TypeError("T1")]),
+                ExceptionGroup("i3", [TypeError("T2")])]),
+            TypeError,
+            ExceptionGroup("eg", [
+                ExceptionGroup("i2", [TypeError("T1")]),
+                ExceptionGroup("i3", [TypeError("T2")])]),
+            ExceptionGroup("eg", [
+                    ExceptionGroup("i1", [ValueError("V1")]),
+                    ExceptionGroup("i2", [ValueError("V2")])]))
+
+    def test_singleton_groups_are_kept(self):
+        self.doSplitTest(
+            ExceptionGroup("j1", [
+                ExceptionGroup("j2", [
+                    ExceptionGroup("j3", [ValueError("V1")]),
+                    ExceptionGroup("j4", [TypeError("T")])])]),
+            TypeError,
+            ExceptionGroup(
+                "j1",
+                [ExceptionGroup("j2", [ExceptionGroup("j4", [TypeError("T")])])]),
+            ExceptionGroup(
+                "j1",
+                [ExceptionGroup("j2", [ExceptionGroup("j3", [ValueError("V1")])])]))
+
+    def test_naked_exception_matched_wrapped1(self):
+        self.doSplitTest(
+            ValueError("V"),
+            ValueError,
+            ExceptionGroup("", [ValueError("V")]),
+            None)
+
+    def test_naked_exception_matched_wrapped2(self):
+        self.doSplitTest(
+            ValueError("V"),
+            Exception,
+            ExceptionGroup("", [ValueError("V")]),
+            None)
+
+    def test_exception_group_except_star_Exception_not_wrapped(self):
+        self.doSplitTest(
+            ExceptionGroup("eg", [ValueError("V")]),
+            Exception,
+            ExceptionGroup("eg", [ValueError("V")]),
+            None)
+
+    def test_plain_exception_not_matched(self):
+        self.doSplitTest(
+            ValueError("V"),
+            TypeError,
+            None,
+            ValueError("V"))
+
+    def test_match__supertype(self):
+        self.doSplitTest(
+            ExceptionGroup("st", [BlockingIOError("io"), TypeError("T")]),
+            OSError,
+            ExceptionGroup("st", [BlockingIOError("io")]),
+            ExceptionGroup("st", [TypeError("T")]))
+
+    def test_multiple_matches_named(self):
+        try:
+            raise ExceptionGroup("mmn", [OSError("os"), BlockingIOError("io")])
+        except* BlockingIOError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmn", [BlockingIOError("io")]))
+        except* OSError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmn", [OSError("os")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_multiple_matches_unnamed(self):
+        try:
+            raise ExceptionGroup("mmu", [OSError("os"), BlockingIOError("io")])
+        except* BlockingIOError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmu", [BlockingIOError("io")]))
+        except* OSError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmu", [OSError("os")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_first_match_wins_named(self):
+        try:
+            raise ExceptionGroup("fst", [BlockingIOError("io")])
+        except* OSError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("fst", [BlockingIOError("io")]))
+        except* BlockingIOError:
+            self.fail("Should have been matched as OSError")
+        else:
+            self.fail("Exception not raised")
+
+    def test_first_match_wins_unnamed(self):
+        try:
+            raise ExceptionGroup("fstu", [BlockingIOError("io")])
+        except* OSError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("fstu", [BlockingIOError("io")]))
+        except* BlockingIOError:
+            pass
+        else:
+            self.fail("Exception not raised")
+
+    def test_nested_except_stars(self):
+        try:
+            raise ExceptionGroup("n", [BlockingIOError("io")])
+        except* BlockingIOError:
+            try:
+                raise ExceptionGroup("n", [ValueError("io")])
+            except* ValueError:
+                pass
+            else:
+                self.fail("Exception not raised")
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                 ExceptionGroup("n", [BlockingIOError("io")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_nested_in_loop(self):
+        for _ in range(2):
+            try:
+                raise ExceptionGroup("nl", [BlockingIOError("io")])
+            except* BlockingIOError:
+                pass
+            else:
+                self.fail("Exception not raised")
+
+
+class TestExceptStarReraise(ExceptStarTest):
+    def test_reraise_all_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                raise
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2), OSError(3)]))
+
+    def test_reraise_all_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                raise
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2), OSError(3)]))
+
+    def test_reraise_some_handle_all_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                pass
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_partial_handle_all_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                pass
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1)]))
+
+    def test_reraise_partial_handle_some_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                pass
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_partial_handle_some_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                pass
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_plain_exception_named(self):
+        try:
+            try:
+                raise ValueError(42)
+            except* ValueError as e:
+                raise
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [ValueError(42)]))
+
+    def test_reraise_plain_exception_unnamed(self):
+        try:
+            try:
+                raise ValueError(42)
+            except* ValueError:
+                raise
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [ValueError(42)]))
+
+
+class TestExceptStarRaise(ExceptStarTest):
+    def test_raise_named(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError as e:
+                raise TypeError(3)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+
+    def test_raise_unnamed(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError:
+                raise TypeError(3)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+
+    def test_raise_handle_all_raise_one_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3)
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+
+    def test_raise_handle_all_raise_one_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3)
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+
+    def test_raise_handle_all_raise_two_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError as e:
+                raise SyntaxError(3)
+            except* ValueError as e:
+                raise SyntaxError(4)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+
+    def test_raise_handle_all_raise_two_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError:
+                raise SyntaxError(3)
+            except* ValueError:
+                raise SyntaxError(4)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+
+
+class TestExceptStarRaiseFrom(ExceptStarTest):
+    def test_raise_named(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError as e:
+                raise TypeError(3) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__cause__)
+
+    def test_raise_unnamed(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError:
+                e = sys.exception()
+                raise TypeError(3) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__cause__)
+
+    def test_raise_handle_all_raise_one_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3) from e
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.__cause__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+        self.assertMetadataEqual(orig, exc.__cause__)
+
+    def test_raise_handle_all_raise_one_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                e = sys.exception()
+                raise SyntaxError(3) from e
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.__cause__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+        self.assertMetadataEqual(orig, exc.__cause__)
+
+    def test_raise_handle_all_raise_two_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError as e:
+                raise SyntaxError(3) from e
+            except* ValueError as e:
+                raise SyntaxError(4) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__cause__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+
+    def test_raise_handle_all_raise_two_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError:
+                e = sys.exception()
+                raise SyntaxError(3) from e
+            except* ValueError:
+                e = sys.exception()
+                raise SyntaxError(4) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__cause__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__cause__)
+
+
+class TestExceptStarExceptionGroupSubclass(ExceptStarTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_except_star_EG_subclass(self):
+        class EG(ExceptionGroup):
+            def __new__(cls, message, excs, code):
+                obj = super().__new__(cls, message, excs)
+                obj.code = code
+                return obj
+
+            def derive(self, excs):
+                return EG(self.message, excs, self.code)
+
+        try:
+            try:
+                try:
+                    try:
+                        raise TypeError(2)
+                    except TypeError as te:
+                        raise EG("nested", [te], 101) from None
+                except EG as nested:
+                    try:
+                        raise ValueError(1)
+                    except ValueError as ve:
+                        raise EG("eg", [ve, nested], 42)
+            except* ValueError as eg:
+                veg = eg
+        except EG as eg:
+            teg = eg
+
+        self.assertIsInstance(veg, EG)
+        self.assertIsInstance(teg, EG)
+        self.assertIsInstance(teg.exceptions[0], EG)
+        self.assertMetadataEqual(veg, teg)
+        self.assertEqual(veg.code, 42)
+        self.assertEqual(teg.code, 42)
+        self.assertEqual(teg.exceptions[0].code, 101)
+
+    def test_falsy_exception_group_subclass(self):
+        class FalsyEG(ExceptionGroup):
+            def __bool__(self):
+                return False
+
+            def derive(self, excs):
+                return FalsyEG(self.message, excs)
+
+        try:
+            try:
+                raise FalsyEG("eg", [TypeError(1), ValueError(2)])
+            except *TypeError as e:
+                tes = e
+                raise
+            except *ValueError as e:
+                ves = e
+                pass
+        except Exception as e:
+            exc = e
+
+        for e in [tes, ves, exc]:
+            self.assertFalse(e)
+            self.assertIsInstance(e, FalsyEG)
+
+        self.assertExceptionIsLike(exc, FalsyEG("eg", [TypeError(1)]))
+        self.assertExceptionIsLike(tes, FalsyEG("eg", [TypeError(1)]))
+        self.assertExceptionIsLike(ves, FalsyEG("eg", [ValueError(2)]))
+
+    def test_exception_group_subclass_with_bad_split_func(self):
+        # see gh-128049.
+        class BadEG1(ExceptionGroup):
+            def split(self, *args):
+                return "NOT A 2-TUPLE!"
+
+        class BadEG2(ExceptionGroup):
+            def split(self, *args):
+                return ("NOT A 2-TUPLE!",)
+
+        eg_list = [
+            (BadEG1("eg", [OSError(123), ValueError(456)]),
+             r"split must return a tuple, not str"),
+            (BadEG2("eg", [OSError(123), ValueError(456)]),
+             r"split must return a 2-tuple, got tuple of size 1")
+        ]
+
+        for eg_class, msg in eg_list:
+            with self.assertRaisesRegex(TypeError, msg) as m:
+                try:
+                    raise eg_class
+                except* ValueError:
+                    pass
+                except* OSError:
+                    pass
+
+            self.assertExceptionIsLike(m.exception.__context__, eg_class)
+
+        # we allow tuples of length > 2 for backwards compatibility
+        class WeirdEG(ExceptionGroup):
+            def split(self, *args):
+                return super().split(*args) + ("anything", 123456, None)
+
+        try:
+            raise WeirdEG("eg", [OSError(123), ValueError(456)])
+        except* OSError as e:
+            oeg = e
+        except* ValueError as e:
+            veg = e
+
+        self.assertExceptionIsLike(oeg, WeirdEG("eg", [OSError(123)]))
+        self.assertExceptionIsLike(veg, WeirdEG("eg", [ValueError(456)]))
+
+
+class TestExceptStarCleanup(ExceptStarTest):
+    def test_sys_exception_restored(self):
+        try:
+            try:
+                raise ValueError(42)
+            except:
+                try:
+                    raise TypeError(int)
+                except* Exception:
+                    pass
+                1/0
+        except Exception as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, ZeroDivisionError('division by zero'))
+        self.assertExceptionIsLike(exc.__context__, ValueError(42))
+        self.assertEqual(sys.exception(), None)
+
+
+class TestExceptStar_WeirdLeafExceptions(ExceptStarTest):
+    # Test that except* works when leaf exceptions are
+    # unhashable or have a bad custom __eq__
+
+    class UnhashableExc(ValueError):
+        __hash__ = None
+
+    class AlwaysEqualExc(ValueError):
+        def __eq__(self, other):
+            return True
+
+    class NeverEqualExc(ValueError):
+        def __eq__(self, other):
+            return False
+
+    class BrokenEqualExc(ValueError):
+        def __eq__(self, other):
+            raise RuntimeError()
+
+    def setUp(self):
+        self.bad_types = [self.UnhashableExc,
+                          self.AlwaysEqualExc,
+                          self.NeverEqualExc,
+                          self.BrokenEqualExc]
+
+    def except_type(self, eg, type):
+        match, rest = None, None
+        try:
+            try:
+                raise eg
+            except* type  as e:
+                match = e
+        except Exception as e:
+            rest = e
+        return match, rest
+
+    def test_catch_unhashable_leaf_exception(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, Bad)
+                self.assertExceptionIsLike(
+                    match, ExceptionGroup("eg", [Bad(2)]))
+                self.assertExceptionIsLike(
+                    rest, ExceptionGroup("eg", [TypeError(1)]))
+
+    def test_propagate_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, TypeError)
+                self.assertExceptionIsLike(
+                    match, ExceptionGroup("eg", [TypeError(1)]))
+                self.assertExceptionIsLike(
+                    rest, ExceptionGroup("eg", [Bad(2)]))
+
+    def test_catch_nothing_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, OSError)
+                self.assertIsNone(match)
+                self.assertExceptionIsLike(rest, eg)
+
+    def test_catch_everything_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, Exception)
+                self.assertExceptionIsLike(match, eg)
+                self.assertIsNone(rest)
+
+    def test_reraise_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup(
+                    "eg", [TypeError(1), Bad(2), ValueError(3)])
+
+                try:
+                    try:
+                        raise eg
+                    except* TypeError:
+                        pass
+                    except* Bad:
+                        raise
+                except Exception as e:
+                    exc = e
+
+                self.assertExceptionIsLike(
+                    exc, ExceptionGroup("eg", [Bad(2), ValueError(3)]))
+
+
+class TestExceptStar_WeirdExceptionGroupSubclass(ExceptStarTest):
+    # Test that except* works with exception groups that are
+    # unhashable or have a bad custom __eq__
+
+    class UnhashableEG(ExceptionGroup):
+        __hash__ = None
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class AlwaysEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            return True
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class NeverEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            return False
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class BrokenEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            raise RuntimeError()
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    def setUp(self):
+        self.bad_types = [self.UnhashableEG,
+                          self.AlwaysEqualEG,
+                          self.NeverEqualEG,
+                          self.BrokenEqualEG]
+
+    def except_type(self, eg, type):
+        match, rest = None, None
+        try:
+            try:
+                raise eg
+            except* type  as e:
+                match = e
+        except Exception as e:
+            rest = e
+        return match, rest
+
+    def test_catch_some_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, TypeError)
+                self.assertExceptionIsLike(match, BadEG("eg", [TypeError(1)]))
+                self.assertExceptionIsLike(rest,
+                    BadEG("eg", [BadEG("nested", [ValueError(2)])]))
+
+    def test_catch_none_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, OSError)
+                self.assertIsNone(match)
+                self.assertExceptionIsLike(rest, eg)
+
+    def test_catch_all_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, Exception)
+                self.assertExceptionIsLike(match, eg)
+                self.assertIsNone(rest)
+
+    def test_reraise_unhashable_eg(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1), ValueError(2),
+                            BadEG("nested", [ValueError(3), OSError(4)])])
+
+                try:
+                    try:
+                        raise eg
+                    except* ValueError:
+                        pass
+                    except* OSError:
+                        raise
+                except Exception as e:
+                    exc = e
+
+                self.assertExceptionIsLike(
+                    exc, BadEG("eg", [TypeError(1),
+                               BadEG("nested", [OSError(4)])]))
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 4a0ef83a57e..7909e924251 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1580,13 +1580,18 @@ impl Compiler {
             }
             Stmt::Break(_) => {
                 // Find the innermost loop in fblock stack
+                // Error if we encounter ExceptionGroupHandler before finding a loop
                 let found_loop = {
                     let code = self.current_code_info();
-                    let mut result = None;
+                    let mut result = Ok(None);
                     for i in (0..code.fblock.len()).rev() {
                         match code.fblock[i].fb_type {
                             FBlockType::WhileLoop | FBlockType::ForLoop => {
-                                result = Some(code.fblock[i].fb_exit);
+                                result = Ok(Some(code.fblock[i].fb_exit));
+                                break;
+                            }
+                            FBlockType::ExceptionGroupHandler => {
+                                result = Err(());
                                 break;
                             }
                             _ => continue,
@@ -1596,25 +1601,36 @@ impl Compiler {
                 };
 
                 match found_loop {
-                    Some(exit_block) => {
+                    Ok(Some(exit_block)) => {
                         emit!(self, Instruction::Break { target: exit_block });
                     }
-                    None => {
+                    Ok(None) => {
                         return Err(
                             self.error_ranged(CodegenErrorType::InvalidBreak, statement.range())
                         );
                     }
+                    Err(()) => {
+                        return Err(self.error_ranged(
+                            CodegenErrorType::BreakContinueReturnInExceptStar,
+                            statement.range(),
+                        ));
+                    }
                 }
             }
             Stmt::Continue(_) => {
                 // Find the innermost loop in fblock stack
+                // Error if we encounter ExceptionGroupHandler before finding a loop
                 let found_loop = {
                     let code = self.current_code_info();
-                    let mut result = None;
+                    let mut result = Ok(None);
                     for i in (0..code.fblock.len()).rev() {
                         match code.fblock[i].fb_type {
                             FBlockType::WhileLoop | FBlockType::ForLoop => {
-                                result = Some(code.fblock[i].fb_block);
+                                result = Ok(Some(code.fblock[i].fb_block));
+                                break;
+                            }
+                            FBlockType::ExceptionGroupHandler => {
+                                result = Err(());
                                 break;
                             }
                             _ => continue,
@@ -1624,14 +1640,20 @@ impl Compiler {
                 };
 
                 match found_loop {
-                    Some(loop_block) => {
+                    Ok(Some(loop_block)) => {
                         emit!(self, Instruction::Continue { target: loop_block });
                     }
-                    None => {
+                    Ok(None) => {
                         return Err(
                             self.error_ranged(CodegenErrorType::InvalidContinue, statement.range())
                         );
                     }
+                    Err(()) => {
+                        return Err(self.error_ranged(
+                            CodegenErrorType::BreakContinueReturnInExceptStar,
+                            statement.range(),
+                        ));
+                    }
                 }
             }
             Stmt::Return(StmtReturn { value, .. }) => {
@@ -1640,6 +1662,18 @@ impl Compiler {
                         self.error_ranged(CodegenErrorType::InvalidReturn, statement.range())
                     );
                 }
+                // Check if we're inside an except* block in the current function
+                {
+                    let code = self.current_code_info();
+                    for block in code.fblock.iter().rev() {
+                        if matches!(block.fb_type, FBlockType::ExceptionGroupHandler) {
+                            return Err(self.error_ranged(
+                                CodegenErrorType::BreakContinueReturnInExceptStar,
+                                statement.range(),
+                            ));
+                        }
+                    }
+                }
                 match value {
                     Some(v) => {
                         if self.ctx.func == FunctionContext::AsyncFunction
@@ -2126,9 +2160,14 @@ impl Compiler {
         orelse: &[Stmt],
         finalbody: &[Stmt],
     ) -> CompileResult<()> {
-        // Simplified except* implementation using CheckEgMatch
+        // Simplified except* implementation using PrepReraiseStar intrinsic
+        // Stack layout during handler processing: [orig, list, rest]
         let handler_block = self.new_block();
         let finally_block = self.new_block();
+        let else_block = self.new_block();
+        let end_block = self.new_block();
+        let reraise_star_block = self.new_block();
+        let reraise_block = self.new_block();
 
         if !finalbody.is_empty() {
             emit!(
@@ -2139,8 +2178,6 @@ impl Compiler {
             );
         }
 
-        let else_block = self.new_block();
-
         emit!(
             self,
             Instruction::SetupExcept {
@@ -2151,20 +2188,32 @@ impl Compiler {
         emit!(self, Instruction::PopBlock);
         emit!(self, Instruction::Jump { target: else_block });
 
+        // Exception handler entry
         self.switch_to_block(handler_block);
         // Stack: [exc]
 
-        for handler in handlers {
+        // Create list for tracking exception results and copy orig
+        emit!(self, Instruction::BuildList { size: 0 });
+        // Stack: [exc, []]
+        // CopyItem is 1-indexed: CopyItem(1)=TOS, CopyItem(2)=second from top
+        // With stack [exc, []], CopyItem(2) copies exc
+        emit!(self, Instruction::CopyItem { index: 2 });
+        // Stack: [exc, [], exc_copy]
+
+        // Now stack is: [orig, list, rest]
+
+        let n = handlers.len();
+        for (i, handler) in handlers.iter().enumerate() {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
                 type_, name, body, ..
             }) = handler;
 
-            let skip_block = self.new_block();
+            let no_match_block = self.new_block();
             let next_block = self.new_block();
 
             // Compile exception type
             if let Some(exc_type) = type_ {
-                // Check for unparenthesized tuple (e.g., `except* A, B:` instead of `except* (A, B):`)
+                // Check for unparenthesized tuple
                 if let Expr::Tuple(ExprTuple { elts, range, .. }) = exc_type.as_ref()
                     && let Some(first) = elts.first()
                     && range.start().to_u32() == first.range().start().to_u32()
@@ -2179,67 +2228,161 @@ impl Compiler {
                     "except* must specify an exception type".to_owned(),
                 )));
             }
-            // Stack: [exc, type]
+            // Stack: [orig, list, rest, type]
 
             emit!(self, Instruction::CheckEgMatch);
-            // Stack: [rest, match]
+            // Stack: [orig, list, new_rest, match]
 
-            // Check if match is None (truthy check)
+            // Check if match is not None (use identity check, not truthiness)
+            // CopyItem is 1-indexed: CopyItem(1) = TOS, CopyItem(2) = second from top
             emit!(self, Instruction::CopyItem { index: 1 });
-            emit!(self, Instruction::ToBool);
-            emit!(self, Instruction::PopJumpIfFalse { target: skip_block });
+            self.emit_load_const(ConstantData::None);
+            emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
+            emit!(
+                self,
+                Instruction::PopJumpIfTrue {
+                    target: no_match_block
+                }
+            );
 
-            // Handler matched - store match to name if provided
-            // Stack: [rest, match]
+            // Handler matched
+            // Stack: [orig, list, new_rest, match]
+            let handler_except_block = self.new_block();
+            let handler_done_block = self.new_block();
+
+            // Set matched exception as current exception for bare 'raise'
+            emit!(self, Instruction::SetExcInfo);
+
+            // Store match to name if provided
             if let Some(alias) = name {
+                // CopyItem(1) copies TOS (match)
+                emit!(self, Instruction::CopyItem { index: 1 });
                 self.store_name(alias.as_str())?;
-            } else {
-                emit!(self, Instruction::PopTop);
             }
-            // Stack: [rest]
+            // Stack: [orig, list, new_rest, match]
+
+            // Setup exception handler to catch 'raise' in handler body
+            emit!(
+                self,
+                Instruction::SetupExcept {
+                    handler: handler_except_block,
+                }
+            );
+
+            // Push fblock to disallow break/continue/return in except* handler
+            self.push_fblock(
+                FBlockType::ExceptionGroupHandler,
+                handler_done_block,
+                end_block,
+            )?;
 
+            // Execute handler body
             self.compile_statements(body)?;
 
+            // Handler body completed normally (didn't raise)
+            self.pop_fblock(FBlockType::ExceptionGroupHandler);
+            emit!(self, Instruction::PopBlock);
+
+            // Cleanup name binding
+            if let Some(alias) = name {
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            // Stack: [orig, list, new_rest, match]
+            // Pop match (handler consumed it)
+            emit!(self, Instruction::PopTop);
+            // Stack: [orig, list, new_rest]
+
+            // Append None to list (exception was consumed, not reraised)
+            self.emit_load_const(ConstantData::None);
+            // Stack: [orig, list, new_rest, None]
+            emit!(self, Instruction::ListAppend { i: 1 });
+            // Stack: [orig, list, new_rest]
+
+            emit!(
+                self,
+                Instruction::Jump {
+                    target: handler_done_block
+                }
+            );
+
+            // Handler raised an exception (bare 'raise' or other)
+            self.switch_to_block(handler_except_block);
+            // Stack: [orig, list, new_rest, match, raised_exc]
+
+            // Cleanup name binding
             if let Some(alias) = name {
                 self.emit_load_const(ConstantData::None);
                 self.store_name(alias.as_str())?;
                 self.compile_name(alias.as_str(), NameUsage::Delete)?;
             }
 
+            // Append raised_exc to list (the actual exception that was raised)
+            // Stack: [orig, list, new_rest, match, raised_exc]
+            // ListAppend(2): pop raised_exc, then append to list at stack[4-2-1]=stack[1]
+            emit!(self, Instruction::ListAppend { i: 2 });
+            // Stack: [orig, list, new_rest, match]
+
+            // Pop match (no longer needed)
+            emit!(self, Instruction::PopTop);
+            // Stack: [orig, list, new_rest]
+
+            self.switch_to_block(handler_done_block);
+            // Stack: [orig, list, new_rest]
+
             emit!(self, Instruction::Jump { target: next_block });
 
-            // No match - pop match (None) and continue with rest
-            self.switch_to_block(skip_block);
-            emit!(self, Instruction::PopTop); // drop match (None)
-            // Stack: [rest]
+            // No match - pop match (None), keep rest unchanged
+            self.switch_to_block(no_match_block);
+            emit!(self, Instruction::PopTop); // pop match (None)
+            // Stack: [orig, list, new_rest]
 
             self.switch_to_block(next_block);
-            // Stack: [rest] - continue with rest for next handler
+            // Stack: [orig, list, rest] (rest may have been updated)
+
+            // After last handler, append remaining rest to list
+            if i == n - 1 {
+                // Stack: [orig, list, rest]
+                // ListAppend(i) pops TOS, then accesses stack[len - i - 1]
+                // After pop, stack is [orig, list], len=2
+                // We want list at index 1, so 2 - i - 1 = 1, i = 0
+                emit!(self, Instruction::ListAppend { i: 0 });
+                // Stack: [orig, list]
+                emit!(
+                    self,
+                    Instruction::Jump {
+                        target: reraise_star_block
+                    }
+                );
+            }
         }
 
-        let handled_block = self.new_block();
-
-        // Check if remainder is truthy (has unhandled exceptions)
-        // Stack: [rest]
-        emit!(self, Instruction::CopyItem { index: 1 });
-        emit!(self, Instruction::ToBool);
+        // Reraise star block
+        self.switch_to_block(reraise_star_block);
+        // Stack: [orig, list]
         emit!(
             self,
-            Instruction::PopJumpIfFalse {
-                target: handled_block
+            Instruction::CallIntrinsic2 {
+                func: bytecode::IntrinsicFunction2::PrepReraiseStar
             }
         );
-        // Reraise unhandled exceptions
+        // Stack: [result] (exception to reraise or None)
+
+        // Check if result is not None (use identity check, not truthiness)
+        emit!(self, Instruction::CopyItem { index: 1 });
+        self.emit_load_const(ConstantData::None);
+        emit!(self, Instruction::IsOp(bytecode::Invert::Yes)); // is not None?
         emit!(
             self,
-            Instruction::Raise {
-                kind: bytecode::RaiseKind::Raise
+            Instruction::PopJumpIfTrue {
+                target: reraise_block
             }
         );
 
-        // All exceptions handled
-        self.switch_to_block(handled_block);
-        emit!(self, Instruction::PopTop); // drop remainder (None)
+        // Nothing to reraise
+        emit!(self, Instruction::PopTop);
         emit!(self, Instruction::PopException);
 
         if !finalbody.is_empty() {
@@ -2247,10 +2390,17 @@ impl Compiler {
             emit!(self, Instruction::EnterFinally);
         }
 
+        emit!(self, Instruction::Jump { target: end_block });
+
+        // Reraise the result
+        self.switch_to_block(reraise_block);
+        // Don't call PopException before Raise - it truncates the stack and removes the result.
+        // When Raise is executed, the exception propagates through unwind_blocks which
+        // will properly handle the ExceptHandler block.
         emit!(
             self,
-            Instruction::Jump {
-                target: finally_block,
+            Instruction::Raise {
+                kind: bytecode::RaiseKind::Raise
             }
         );
 
@@ -2263,8 +2413,11 @@ impl Compiler {
             emit!(self, Instruction::EnterFinally);
         }
 
-        self.switch_to_block(finally_block);
+        emit!(self, Instruction::Jump { target: end_block });
+
+        self.switch_to_block(end_block);
         if !finalbody.is_empty() {
+            self.switch_to_block(finally_block);
             self.compile_statements(finalbody)?;
             emit!(self, Instruction::EndFinally);
         }
diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
index a0e36bf29ae..70e2f13f253 100644
--- a/crates/codegen/src/error.rs
+++ b/crates/codegen/src/error.rs
@@ -88,6 +88,8 @@ pub enum CodegenErrorType {
     UnreachablePattern(PatternUnreachableReason),
     RepeatedAttributePattern,
     ConflictingNameBindPattern,
+    /// break/continue/return inside except* block
+    BreakContinueReturnInExceptStar,
     NotImplementedYet, // RustPython marker for unimplemented features
 }
 
@@ -148,6 +150,12 @@ impl fmt::Display for CodegenErrorType {
             ConflictingNameBindPattern => {
                 write!(f, "alternative patterns bind different names")
             }
+            BreakContinueReturnInExceptStar => {
+                write!(
+                    f,
+                    "'break', 'continue' and 'return' cannot appear in an except* block"
+                )
+            }
             NotImplementedYet => {
                 write!(f, "RustPython does not implement this feature yet")
             }
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index add2c1c2f63..8df5d9caf6f 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -865,11 +865,14 @@ pub enum Instruction {
     WithCleanupStart,
     YieldFrom,
     YieldValue,
+    /// Set the current exception to TOS (for except* handlers).
+    /// Does not pop the value.
+    SetExcInfo,
     // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
 }
 
 // This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::YieldValue;
+const LAST_INSTRUCTION: Instruction = Instruction::SetExcInfo;
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
@@ -1743,6 +1746,7 @@ impl Instruction {
             Resume { .. } => 0,
             YieldValue => 0,
             YieldFrom => -1,
+            SetExcInfo => 0,
             SetupAnnotation | SetupLoop | SetupFinally { .. } | EnterFinally | EndFinally => 0,
             SetupExcept { .. } => jump as i32,
             SetupWith { .. } => (!jump) as i32,
@@ -1961,6 +1965,7 @@ impl Instruction {
             SetupWith { end } => w!(SETUP_WITH, end),
             StoreAttr { idx } => w!(STORE_ATTR, name = idx),
             StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
+            SetExcInfo => w!(SET_EXC_INFO),
             StoreFast(idx) => w!(STORE_FAST, varname = idx),
             StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
             StoreLocal(idx) => w!(STORE_LOCAL, name = idx),
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 7b8af83489e..0e2051e5498 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -2433,6 +2433,40 @@ pub(super) mod types {
     pub struct PyEncodingWarning(PyWarning);
 }
 
+/// Check if match_type is valid for except* (must be exception type, not ExceptionGroup).
+fn check_except_star_type_valid(match_type: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    let base_exc: PyObjectRef = vm.ctx.exceptions.base_exception_type.to_owned().into();
+    let base_eg: PyObjectRef = vm.ctx.exceptions.base_exception_group.to_owned().into();
+
+    // Helper to check a single type
+    let check_one = |exc_type: &PyObjectRef| -> PyResult<()> {
+        // Must be a subclass of BaseException
+        if !exc_type.is_subclass(&base_exc, vm)? {
+            return Err(vm.new_type_error(
+                "catching classes that do not inherit from BaseException is not allowed".to_owned(),
+            ));
+        }
+        // Must not be a subclass of BaseExceptionGroup
+        if exc_type.is_subclass(&base_eg, vm)? {
+            return Err(vm.new_type_error(
+                "catching ExceptionGroup with except* is not allowed. Use except instead."
+                    .to_owned(),
+            ));
+        }
+        Ok(())
+    };
+
+    // If it's a tuple, check each element
+    if let Ok(tuple) = match_type.clone().downcast::<PyTuple>() {
+        for item in tuple.iter() {
+            check_one(item)?;
+        }
+    } else {
+        check_one(match_type)?;
+    }
+    Ok(())
+}
+
 /// Match exception against except* handler type.
 /// Returns (rest, match) tuple.
 pub fn exception_group_match(
@@ -2447,6 +2481,9 @@ pub fn exception_group_match(
         return Ok((vm.ctx.none(), vm.ctx.none()));
     }
 
+    // Validate match_type and reject ExceptionGroup/BaseExceptionGroup
+    check_except_star_type_valid(match_type, vm)?;
+
     // Check if exc_value matches match_type
     if exc_value.is_instance(match_type, vm)? {
         // Full match of exc itself
@@ -2473,6 +2510,13 @@ pub fn exception_group_match(
     // Check for partial match if it's an exception group
     if exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
         let pair = vm.call_method(exc_value, "split", (match_type.clone(),))?;
+        if !pair.class().is(vm.ctx.types.tuple_type) {
+            return Err(vm.new_type_error(format!(
+                "{}.split must return a tuple, not {}",
+                exc_value.class().name(),
+                pair.class().name()
+            )));
+        }
         let pair_tuple: PyTupleRef = pair.try_into_value(vm)?;
         if pair_tuple.len() < 2 {
             return Err(vm.new_type_error(format!(
@@ -2491,8 +2535,8 @@ pub fn exception_group_match(
 }
 
 /// Prepare exception for reraise in except* block.
+/// Implements _PyExc_PrepReraiseStar
 pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    // Implements _PyExc_PrepReraiseStar
     use crate::builtins::PyList;
 
     let excs_list = excs
@@ -2501,7 +2545,20 @@ pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachi
 
     let excs_vec: Vec<PyObjectRef> = excs_list.borrow_vec().to_vec();
 
-    // Filter out None values
+    // If no exceptions to process, return None
+    if excs_vec.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Special case: naked exception (not an ExceptionGroup)
+    // Only one except* clause could have executed, so there's at most one exception to raise
+    if !orig.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        // Find first non-None exception
+        let first = excs_vec.into_iter().find(|e| !vm.is_none(e));
+        return Ok(first.unwrap_or_else(|| vm.ctx.none()));
+    }
+
+    // Split excs into raised (new) and reraised (from original) by comparing metadata
     let mut raised: Vec<PyObjectRef> = Vec::new();
     let mut reraised: Vec<PyObjectRef> = Vec::new();
 
@@ -2509,8 +2566,8 @@ pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachi
         if vm.is_none(&exc) {
             continue;
         }
-        // Check if this exception was in the original exception group
-        if !vm.is_none(&orig) && is_same_exception_metadata(&exc, &orig, vm) {
+        // Check if this exception came from the original group
+        if is_exception_from_orig(&exc, &orig, vm) {
             reraised.push(exc);
         } else {
             raised.push(exc);
@@ -2522,37 +2579,134 @@ pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachi
         return Ok(vm.ctx.none());
     }
 
-    // Combine raised and reraised exceptions
-    let mut all_excs = raised;
-    all_excs.extend(reraised);
+    // Project reraised exceptions onto original structure to preserve nesting
+    let reraised_eg = exception_group_projection(&orig, &reraised, vm)?;
+
+    // If no new raised exceptions, just return the reraised projection
+    if raised.is_empty() {
+        return Ok(reraised_eg);
+    }
+
+    // Combine raised with reraised_eg
+    if !vm.is_none(&reraised_eg) {
+        raised.push(reraised_eg);
+    }
 
-    if all_excs.len() == 1 {
-        // If only one exception, just return it
-        return Ok(all_excs.into_iter().next().unwrap());
+    // If only one exception, return it directly
+    if raised.len() == 1 {
+        return Ok(raised.into_iter().next().unwrap());
     }
 
-    // Create new ExceptionGroup
-    let excs_tuple = vm.ctx.new_tuple(all_excs);
+    // Create new ExceptionGroup for multiple exceptions
+    let excs_tuple = vm.ctx.new_tuple(raised);
     let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
     eg_type.call((vm.ctx.new_str(""), excs_tuple), vm)
 }
 
-/// Check if two exceptions have the same metadata (for reraise detection)
-fn is_same_exception_metadata(exc1: &PyObjectRef, exc2: &PyObjectRef, vm: &VirtualMachine) -> bool {
-    // Check if exc1 is part of exc2's exception group
-    if exc2.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
-        let exc_class: PyObjectRef = exc1.class().to_owned().into();
-        if let Ok(result) = vm.call_method(exc2, "subgroup", (exc_class,))
-            && !vm.is_none(&result)
-            && let Ok(subgroup_excs) = result.get_attr("exceptions", vm)
-            && let Ok(tuple) = subgroup_excs.downcast::<PyTuple>()
-        {
-            for e in tuple.iter() {
-                if e.is(exc1) {
-                    return true;
-                }
-            }
+/// Check if an exception came from the original group (for reraise detection).
+/// Instead of comparing metadata (which can be modified when caught), we compare
+/// leaf exception object IDs. split() preserves leaf exception identity.
+fn is_exception_from_orig(exc: &PyObjectRef, orig: &PyObjectRef, vm: &VirtualMachine) -> bool {
+    // Collect leaf exception IDs from exc
+    let mut exc_leaf_ids = HashSet::new();
+    collect_exception_group_leaf_ids(exc, &mut exc_leaf_ids, vm);
+
+    if exc_leaf_ids.is_empty() {
+        return false;
+    }
+
+    // Collect leaf exception IDs from orig
+    let mut orig_leaf_ids = HashSet::new();
+    collect_exception_group_leaf_ids(orig, &mut orig_leaf_ids, vm);
+
+    // If ALL of exc's leaves are in orig's leaves, it's a reraise
+    exc_leaf_ids.iter().all(|id| orig_leaf_ids.contains(id))
+}
+
+/// Collect all leaf exception IDs from an exception (group).
+fn collect_exception_group_leaf_ids(
+    exc: &PyObjectRef,
+    leaf_ids: &mut HashSet<usize>,
+    vm: &VirtualMachine,
+) {
+    if vm.is_none(exc) {
+        return;
+    }
+
+    // If not an exception group, it's a leaf - add its ID
+    if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        leaf_ids.insert(exc.get_id());
+        return;
+    }
+
+    // Recurse into exception group's exceptions
+    if let Ok(excs_attr) = exc.get_attr("exceptions", vm)
+        && let Ok(tuple) = excs_attr.downcast::<PyTuple>()
+    {
+        for e in tuple.iter() {
+            collect_exception_group_leaf_ids(e, leaf_ids, vm);
+        }
+    }
+}
+
+/// Project orig onto keep list, preserving nested structure.
+/// Returns an exception group containing only the exceptions from orig
+/// that are also in the keep list.
+fn exception_group_projection(
+    orig: &PyObjectRef,
+    keep: &[PyObjectRef],
+    vm: &VirtualMachine,
+) -> PyResult {
+    if keep.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Collect all leaf IDs from keep list
+    let mut leaf_ids = HashSet::new();
+    for e in keep {
+        collect_exception_group_leaf_ids(e, &mut leaf_ids, vm);
+    }
+
+    // Split orig by matching leaf IDs, preserving structure
+    split_by_leaf_ids(orig, &leaf_ids, vm)
+}
+
+/// Recursively split an exception (group) by leaf IDs.
+/// Returns the projection containing only matching leaves with preserved structure.
+fn split_by_leaf_ids(
+    exc: &PyObjectRef,
+    leaf_ids: &HashSet<usize>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    if vm.is_none(exc) {
+        return Ok(vm.ctx.none());
+    }
+
+    // If not an exception group, check if it's in our set
+    if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        if leaf_ids.contains(&exc.get_id()) {
+            return Ok(exc.clone());
         }
+        return Ok(vm.ctx.none());
     }
-    exc1.is(exc2)
+
+    // Exception group - recurse and reconstruct
+    let excs_attr = exc.get_attr("exceptions", vm)?;
+    let tuple: PyTupleRef = excs_attr.try_into_value(vm)?;
+
+    let mut matched = Vec::new();
+    for e in tuple.iter() {
+        let m = split_by_leaf_ids(e, leaf_ids, vm)?;
+        if !vm.is_none(&m) {
+            matched.push(m);
+        }
+    }
+
+    if matched.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Reconstruct using derive() to preserve the structure (not necessarily the subclass type)
+    let matched_tuple = vm.ctx.new_tuple(matched);
+    vm.call_method(exc, "derive", (matched_tuple,))
 }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 6cb41f41d93..3f470e5453f 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1,8 +1,8 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{
-        PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator, PyList, PySet,
-        PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyType,
+        PyBaseException, PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator,
+        PyList, PySet, PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyType,
         asyncgenerator::PyAsyncGenWrappedValue,
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
@@ -361,10 +361,6 @@ impl ExecutingFrame<'_> {
         let mut arg_state = bytecode::OpArgState::default();
         loop {
             let idx = self.lasti() as usize;
-            // eprintln!(
-            //     "location: {:?} {}",
-            //     self.code.locations[idx], self.code.source_path
-            // );
             self.update_lasti(|i| *i += 1);
             let bytecode::CodeUnit { op, arg } = instructions[idx];
             let arg = arg_state.extend(arg);
@@ -1406,6 +1402,15 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
+            bytecode::Instruction::SetExcInfo => {
+                // Set the current exception to TOS (for except* handlers)
+                // This updates sys.exc_info() so bare 'raise' will reraise the matched exception
+                let exc = self.top_value();
+                if let Some(exc) = exc.downcast_ref::<PyBaseException>() {
+                    vm.set_exception(Some(exc.to_owned()));
+                }
+                Ok(None)
+            }
             bytecode::Instruction::SetFunctionAttribute { attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }

From 9b2ad34a084a95d55105e32708e039bff11f7ccc Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 00:06:29 +0900
Subject: [PATCH 085/418] check surrogates (#6547)

---
 Lib/test/test_builtin.py       |  4 ----
 crates/vm/src/builtins/str.rs  |  4 ++--
 crates/vm/src/builtins/type.rs | 29 +++++++++++++++++++++++++++++
 3 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index a5306b71d89..b957f79b87c 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -2399,8 +2399,6 @@ def test_type_nokwargs(self):
         with self.assertRaises(TypeError):
             type('a', (), dict={})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_name(self):
         for name in 'A', '\xc4', '\U0001f40d', 'B.A', '42', '':
             with self.subTest(name=name):
@@ -2450,8 +2448,6 @@ def test_type_qualname(self):
             A.__qualname__ = b'B'
         self.assertEqual(A.__qualname__, 'D.E')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_doc(self):
         for doc in 'x', '\xc4', '\U0001f40d', 'x\x00y', b'x', 42, None:
             A = type('A', (), {'__doc__': doc})
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index df65fd5a4ed..fa35c1725d4 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -441,7 +441,7 @@ impl PyStr {
         self.data.as_str()
     }
 
-    fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
+    pub(crate) fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
         if self.is_utf8() {
             Ok(())
         } else {
@@ -1336,7 +1336,7 @@ impl PyStr {
     }
 
     #[pymethod]
-    fn isidentifier(&self) -> bool {
+    pub fn isidentifier(&self) -> bool {
         let Some(s) = self.to_str() else { return false };
         let mut chars = s.chars();
         let is_identifier_start = chars.next().is_some_and(|c| c == '_' || is_xid_start(c));
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index bc567cd0978..de34678ae45 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1163,6 +1163,7 @@ impl PyType {
         if name.as_bytes().contains(&0) {
             return Err(vm.new_value_error("type name must not contain null characters"));
         }
+        name.ensure_valid_utf8(vm)?;
 
         // Use std::mem::replace to swap the new value in and get the old value out,
         // then drop the old value after releasing the lock (similar to CPython's Py_SETREF)
@@ -1254,6 +1255,7 @@ impl Constructor for PyType {
         if name.as_bytes().contains(&0) {
             return Err(vm.new_value_error("type name must not contain null characters"));
         }
+        name.ensure_valid_utf8(vm)?;
 
         let (metatype, base, bases, base_is_type) = if bases.is_empty() {
             let base = vm.ctx.types.object_type.to_owned();
@@ -1306,6 +1308,13 @@ impl Constructor for PyType {
             });
         let mut attributes = dict.to_attributes(vm);
 
+        // Check __doc__ for surrogates - raises UnicodeEncodeError during type creation
+        if let Some(doc) = attributes.get(identifier!(vm, __doc__))
+            && let Some(doc_str) = doc.downcast_ref::<PyStr>()
+        {
+            doc_str.ensure_valid_utf8(vm)?;
+        }
+
         if let Some(f) = attributes.get_mut(identifier!(vm, __init_subclass__))
             && f.class().is(vm.ctx.types.function_type)
         {
@@ -1340,6 +1349,13 @@ impl Constructor for PyType {
 
         let (heaptype_slots, add_dict): (Option<PyRef<PyTuple<PyStrRef>>>, bool) =
             if let Some(x) = attributes.get(identifier!(vm, __slots__)) {
+                // Check if __slots__ is bytes - not allowed
+                if x.class().is(vm.ctx.types.bytes_type) {
+                    return Err(vm.new_type_error(
+                        "__slots__ items must be strings, not 'bytes'".to_owned(),
+                    ));
+                }
+
                 let slots = if x.class().is(vm.ctx.types.str_type) {
                     let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
                     PyTuple::new_ref_typed(vec![x.to_owned()], &vm.ctx)
@@ -1348,6 +1364,12 @@ impl Constructor for PyType {
                     let elements = {
                         let mut elements = Vec::new();
                         while let PyIterReturn::Return(element) = iter.next(vm)? {
+                            // Check if any slot item is bytes
+                            if element.class().is(vm.ctx.types.bytes_type) {
+                                return Err(vm.new_type_error(
+                                    "__slots__ items must be strings, not 'bytes'".to_owned(),
+                                ));
+                            }
                             elements.push(element);
                         }
                         elements
@@ -1356,6 +1378,13 @@ impl Constructor for PyType {
                     tuple.try_into_typed(vm)?
                 };
 
+                // Validate that all slots are valid identifiers
+                for slot in slots.iter() {
+                    if !slot.isidentifier() {
+                        return Err(vm.new_type_error("__slots__ must be identifiers".to_owned()));
+                    }
+                }
+
                 // Check if __dict__ is in slots
                 let dict_name = "__dict__";
                 let has_dict = slots.iter().any(|s| s.as_str() == dict_name);

From ce00640b22bdfbc1cb90af8ef1efa610b295c44c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 09:08:03 +0900
Subject: [PATCH 086/418] fix input to check pty child (#6553)

* fix input to check pty child

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/py_io.rs           |  9 ++++++---
 crates/vm/src/stdlib/builtins.rs | 28 ++++++++++++++++++++++++----
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/crates/vm/src/py_io.rs b/crates/vm/src/py_io.rs
index 6b82bbd4788..a8063673a70 100644
--- a/crates/vm/src/py_io.rs
+++ b/crates/vm/src/py_io.rs
@@ -70,11 +70,14 @@ pub fn file_readline(obj: &PyObject, size: Option<usize>, vm: &VirtualMachine) -
     };
     let ret = match_class!(match ret {
         s @ PyStr => {
-            let s_val = s.as_str();
-            if s_val.is_empty() {
+            // Use as_wtf8() to handle strings with surrogates (e.g., surrogateescape)
+            let s_wtf8 = s.as_wtf8();
+            if s_wtf8.is_empty() {
                 return Err(eof_err());
             }
-            if let Some(no_nl) = s_val.strip_suffix('\n') {
+            // '\n' is ASCII, so we can check bytes directly
+            if s_wtf8.as_bytes().last() == Some(&b'\n') {
+                let no_nl = &s_wtf8[..s_wtf8.len() - 1];
                 vm.ctx.new_str(no_nl).into()
             } else {
                 s.into()
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 19f85af55da..7cd91f8b4b7 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -7,8 +7,6 @@ pub use builtins::{ascii, print, reversed};
 
 #[pymodule]
 mod builtins {
-    use std::io::IsTerminal;
-
     use crate::{
         AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
         builtins::{
@@ -464,6 +462,8 @@ mod builtins {
 
     #[pyfunction]
     fn input(prompt: OptionalArg<PyStrRef>, vm: &VirtualMachine) -> PyResult {
+        use std::io::IsTerminal;
+
         let stdin = sys::get_stdin(vm)?;
         let stdout = sys::get_stdout(vm)?;
         let stderr = sys::get_stderr(vm)?;
@@ -476,8 +476,13 @@ mod builtins {
                 .is_ok_and(|fd| fd == expected)
         };
 
-        // everything is normal, we can just rely on rustyline to use stdin/stdout
-        if fd_matches(&stdin, 0) && fd_matches(&stdout, 1) && std::io::stdin().is_terminal() {
+        // Check if we should use rustyline (interactive terminal, not PTY child)
+        let use_rustyline = fd_matches(&stdin, 0)
+            && fd_matches(&stdout, 1)
+            && std::io::stdin().is_terminal()
+            && !is_pty_child();
+
+        if use_rustyline {
             let prompt = prompt.as_ref().map_or("", |s| s.as_str());
             let mut readline = Readline::new(());
             match readline.readline(prompt) {
@@ -502,6 +507,21 @@ mod builtins {
         }
     }
 
+    /// Check if we're running in a PTY child process (e.g., after pty.fork()).
+    /// pty.fork() calls setsid(), making the child a session leader.
+    /// In this case, rustyline may hang because it uses raw mode.
+    #[cfg(unix)]
+    fn is_pty_child() -> bool {
+        use nix::unistd::{getpid, getsid};
+        // If this process is a session leader, we're likely in a PTY child
+        getsid(None) == Ok(getpid())
+    }
+
+    #[cfg(not(unix))]
+    fn is_pty_child() -> bool {
+        false
+    }
+
     #[pyfunction]
     fn isinstance(obj: PyObjectRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         obj.is_instance(&typ, vm)

From fd6c54876624b738b2ed18985457c3e68fc2711e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 09:08:16 +0900
Subject: [PATCH 087/418] no redundant venvlauncher targets (#6554)

---
 crates/venvlauncher/Cargo.toml | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/crates/venvlauncher/Cargo.toml b/crates/venvlauncher/Cargo.toml
index d59a3a0269f..ac3ea106b7a 100644
--- a/crates/venvlauncher/Cargo.toml
+++ b/crates/venvlauncher/Cargo.toml
@@ -8,23 +8,11 @@ rust-version.workspace = true
 repository.workspace = true
 license.workspace = true
 
-[[bin]]
-name = "venvlauncher"
-path = "src/main.rs"
-
-[[bin]]
-name = "venvwlauncher"
-path = "src/main.rs"
-
 # Free-threaded variants (RustPython uses Py_GIL_DISABLED=true)
 [[bin]]
 name = "venvlaunchert"
 path = "src/main.rs"
 
-[[bin]]
-name = "venvwlaunchert"
-path = "src/main.rs"
-
 [target.'cfg(windows)'.dependencies]
 windows-sys = { workspace = true, features = [
     "Win32_Foundation",

From 012799f5600e29643133fc6e08a23fc2640d4d21 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 10:13:03 +0900
Subject: [PATCH 088/418] Fix enum and os.read related to signal (#6552)

* fix enum

* fix os.read to check signals
---
 Lib/test/test_descr.py         |  1 -
 Lib/test/test_file_eintr.py    | 46 ++++++++++++++++++++++++++++------
 Lib/test/test_signal.py        |  6 -----
 Lib/test/test_socket.py        |  8 ------
 Lib/test/test_ssl.py           |  6 -----
 crates/vm/src/builtins/type.rs |  8 +++++-
 crates/vm/src/stdlib/os.rs     | 19 ++++++++++----
 7 files changed, 60 insertions(+), 34 deletions(-)

diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 88d120a427f..4e04371f626 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -4961,7 +4961,6 @@ class OverrideBoth(OverrideNew, OverrideInit):
             self.assertRaises(TypeError, case, 1, 2, 3)
             self.assertRaises(TypeError, case, 1, 2, foo=3)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclassing_does_not_duplicate_dict_descriptors(self):
         class Base:
             pass
diff --git a/Lib/test/test_file_eintr.py b/Lib/test/test_file_eintr.py
index 55cc31dc59f..13260b8e498 100644
--- a/Lib/test/test_file_eintr.py
+++ b/Lib/test/test_file_eintr.py
@@ -152,7 +152,6 @@ def _test_reading(self, data_to_write, read_and_verify_code):
                     '"got data %r\\nexpected %r" % (got, expected))'
             )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readline(self):
         """readline() must handle signals and not lose data."""
         self._test_reading(
@@ -161,7 +160,6 @@ def test_readline(self):
                         read_method_name='readline',
                         expected=b'hello, world!\n'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readlines(self):
         """readlines() must handle signals and not lose data."""
         self._test_reading(
@@ -170,7 +168,6 @@ def test_readlines(self):
                         read_method_name='readlines',
                         expected=[b'hello\n', b'world!\n']))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readall(self):
         """readall() must handle signals and not lose data."""
         self._test_reading(
@@ -189,6 +186,19 @@ def test_readall(self):
 class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
+    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
+    @unittest.expectedFailure
+    def test_readline(self):
+        super().test_readline()
+
+    @unittest.expectedFailure
+    def test_readlines(self):
+        super().test_readlines()
+
+    @unittest.expectedFailure
+    def test_readall(self):
+        super().test_readall()
+
 class PyTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
     modname = '_pyio'
 
@@ -200,7 +210,6 @@ def _generate_infile_setup_code(self):
                 'assert isinstance(infile, io.BufferedReader)' %
                 self.modname)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readall(self):
         """BufferedReader.read() must handle signals and not lose data."""
         self._test_reading(
@@ -212,6 +221,19 @@ def test_readall(self):
 class CTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
+    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
+    @unittest.expectedFailure
+    def test_readline(self):
+        super().test_readline()
+
+    @unittest.expectedFailure
+    def test_readlines(self):
+        super().test_readlines()
+
+    @unittest.expectedFailure
+    def test_readall(self):
+        super().test_readall()
+
 class PyTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
     modname = '_pyio'
 
@@ -224,7 +246,6 @@ def _generate_infile_setup_code(self):
                 'assert isinstance(infile, io.TextIOWrapper)' %
                 self.modname)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readline(self):
         """readline() must handle signals and not lose data."""
         self._test_reading(
@@ -233,7 +254,6 @@ def test_readline(self):
                         read_method_name='readline',
                         expected='hello, world!\n'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readlines(self):
         """readlines() must handle signals and not lose data."""
         self._test_reading(
@@ -242,7 +262,6 @@ def test_readlines(self):
                         read_method_name='readlines',
                         expected=['hello\n', 'world!\n']))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readall(self):
         """read() must handle signals and not lose data."""
         self._test_reading(
@@ -254,6 +273,19 @@ def test_readall(self):
 class CTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
+    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
+    @unittest.expectedFailure
+    def test_readline(self):
+        super().test_readline()
+
+    @unittest.expectedFailure
+    def test_readlines(self):
+        super().test_readlines()
+
+    @unittest.expectedFailure
+    def test_readall(self):
+        super().test_readall()
+
 class PyTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
     modname = '_pyio'
 
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index 34ef13adf33..58b3e55d321 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -24,8 +24,6 @@
 
 class GenericTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_enums(self):
         for name in dir(signal):
             sig = getattr(signal, name)
@@ -763,8 +761,6 @@ def handler(signum, frame):
                                     % (exitcode, stdout))
                 return (exitcode == 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_without_siginterrupt(self):
         # If a signal handler is installed and siginterrupt is not called
         # at all, when that signal arrives, it interrupts a syscall that's in
@@ -772,8 +768,6 @@ def test_without_siginterrupt(self):
         interrupted = self.readpipe_interrupted(None)
         self.assertTrue(interrupted)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_siginterrupt_on(self):
         # If a signal handler is installed and siginterrupt is called with
         # a true value for the second argument, when that signal arrives, it
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 5ccbfa7ff83..d5a35a3253e 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -2052,8 +2052,6 @@ def test_socket_fileno_requires_socket_fd(self):
                     fileno=afile.fileno())
             self.assertEqual(cm.exception.errno, errno.ENOTSOCK)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_addressfamily_enum(self):
         import _socket, enum
         CheckedAddressFamily = enum._old_convert_(
@@ -2063,8 +2061,6 @@ def test_addressfamily_enum(self):
                 )
         enum._test_simple_enum(CheckedAddressFamily, socket.AddressFamily)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_socketkind_enum(self):
         import _socket, enum
         CheckedSocketKind = enum._old_convert_(
@@ -2074,8 +2070,6 @@ def test_socketkind_enum(self):
                 )
         enum._test_simple_enum(CheckedSocketKind, socket.SocketKind)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_msgflag_enum(self):
         import _socket, enum
         CheckedMsgFlag = enum._old_convert_(
@@ -2085,8 +2079,6 @@ def test_msgflag_enum(self):
                 )
         enum._test_simple_enum(CheckedMsgFlag, socket.MsgFlag)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_addressinfo_enum(self):
         import _socket, enum
         CheckedAddressInfo = enum._old_convert_(
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index f073def5bc1..09d35a77a1c 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -5477,7 +5477,6 @@ class Checked_TLSMessageType(enum.IntEnum):
             CHANGE_CIPHER_SPEC = 0x0101
         enum._test_simple_enum(Checked_TLSMessageType, _TLSMessageType)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sslmethod(self):
         Checked_SSLMethod = enum._old_convert_(
                 enum.IntEnum, '_SSLMethod', 'ssl',
@@ -5488,7 +5487,6 @@ def test_sslmethod(self):
         Checked_SSLMethod.PROTOCOL_SSLv23 = Checked_SSLMethod.PROTOCOL_TLS
         enum._test_simple_enum(Checked_SSLMethod, ssl._SSLMethod)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_options(self):
         CheckedOptions = enum._old_convert_(
                 enum.IntFlag, 'Options', 'ssl',
@@ -5497,7 +5495,6 @@ def test_options(self):
                 )
         enum._test_simple_enum(CheckedOptions, ssl.Options)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_alertdescription(self):
         CheckedAlertDescription = enum._old_convert_(
                 enum.IntEnum, 'AlertDescription', 'ssl',
@@ -5506,7 +5503,6 @@ def test_alertdescription(self):
                 )
         enum._test_simple_enum(CheckedAlertDescription, ssl.AlertDescription)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sslerrornumber(self):
         Checked_SSLErrorNumber = enum._old_convert_(
                 enum.IntEnum, 'SSLErrorNumber', 'ssl',
@@ -5515,7 +5511,6 @@ def test_sslerrornumber(self):
                 )
         enum._test_simple_enum(Checked_SSLErrorNumber, ssl.SSLErrorNumber)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_verifyflags(self):
         CheckedVerifyFlags = enum._old_convert_(
                 enum.IntFlag, 'VerifyFlags', 'ssl',
@@ -5524,7 +5519,6 @@ def test_verifyflags(self):
                 )
         enum._test_simple_enum(CheckedVerifyFlags, ssl.VerifyFlags)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_verifymode(self):
         CheckedVerifyMode = enum._old_convert_(
                 enum.IntEnum, 'VerifyMode', 'ssl',
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index de34678ae45..86d871fe30f 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1499,9 +1499,15 @@ impl Constructor for PyType {
         // Only add if:
         // 1. base is not type (type subclasses inherit __dict__ from type)
         // 2. the class has HAS_DICT flag (i.e., __slots__ was not defined or __dict__ is in __slots__)
+        // 3. no base class in MRO already provides __dict__ descriptor
         if !base_is_type && typ.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
             let __dict__ = identifier!(vm, __dict__);
-            if !typ.attributes.read().contains_key(&__dict__) {
+            let has_inherited_dict = typ
+                .mro
+                .read()
+                .iter()
+                .any(|base| base.attributes.read().contains_key(&__dict__));
+            if !typ.attributes.read().contains_key(&__dict__) && !has_inherited_dict {
                 unsafe {
                     let descriptor =
                         vm.ctx
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 87080ff8e0f..28d4aeb3755 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -274,12 +274,21 @@ pub(super) mod _os {
     }
 
     #[pyfunction]
-    fn read(fd: crt_fd::Borrowed<'_>, n: usize, vm: &VirtualMachine) -> io::Result<PyBytesRef> {
+    fn read(fd: crt_fd::Borrowed<'_>, n: usize, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
         let mut buffer = vec![0u8; n];
-        let n = crt_fd::read(fd, &mut buffer)?;
-        buffer.truncate(n);
-
-        Ok(vm.ctx.new_bytes(buffer))
+        loop {
+            match crt_fd::read(fd, &mut buffer) {
+                Ok(n) => {
+                    buffer.truncate(n);
+                    return Ok(vm.ctx.new_bytes(buffer));
+                }
+                Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                    vm.check_signals()?;
+                    continue;
+                }
+                Err(e) => return Err(e.into_pyexception(vm)),
+            }
+        }
     }
 
     #[pyfunction]

From 7edc3bba5d275e28184e77ad1bf0f2a4da7473a0 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 10:27:58 +0900
Subject: [PATCH 089/418] tp_itemsize (#6544)

---
 Lib/test/test_builtin.py          |   2 -
 crates/derive-impl/src/pyclass.rs |  20 +++-
 crates/vm/src/builtins/bytes.rs   |   1 +
 crates/vm/src/builtins/int.rs     |   1 +
 crates/vm/src/builtins/tuple.rs   |  11 +-
 crates/vm/src/builtins/type.rs    | 192 ++++++++++++++++++++++--------
 crates/vm/src/class.rs            |   2 +
 crates/vm/src/types/slot.rs       |   2 +-
 8 files changed, 164 insertions(+), 67 deletions(-)

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index b957f79b87c..7d8c7a5e016 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -2481,8 +2481,6 @@ def test_bad_args(self):
         with self.assertRaises(TypeError):
             type('A', (int, str), {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bad_slots(self):
         with self.assertRaises(TypeError):
             type('A', (), {'__slots__': b'x'})
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 1a01721391e..82057d40f9e 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -165,6 +165,7 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                 with_impl,
                 with_method_defs,
                 with_slots,
+                itemsize,
             } = extract_impl_attrs(attr, &impl_ty)?;
             let payload_ty = attr_payload.unwrap_or(payload_guess);
             let method_def = &context.method_items;
@@ -189,9 +190,17 @@ pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Resul
                         #(#class_extensions)*
                     }
                 },
-                parse_quote! {
-                    fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
-                        #slots_impl
+                {
+                    let itemsize_impl = itemsize.as_ref().map(|size| {
+                        quote! {
+                            slots.itemsize = #size;
+                        }
+                    });
+                    parse_quote! {
+                        fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
+                            #itemsize_impl
+                            #slots_impl
+                        }
                     }
                 },
             ];
@@ -1618,6 +1627,7 @@ struct ExtractedImplAttrs {
     with_impl: TokenStream,
     with_method_defs: Vec<TokenStream>,
     with_slots: TokenStream,
+    itemsize: Option<syn::Expr>,
 }
 
 fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<ExtractedImplAttrs> {
@@ -1636,6 +1646,7 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
         }
     }];
     let mut payload = None;
+    let mut itemsize = None;
 
     for attr in attr {
         match attr {
@@ -1721,6 +1732,8 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
                     } else {
                         bail_span!(value, "payload must be a string literal")
                     }
+                } else if path.is_ident("itemsize") {
+                    itemsize = Some(value);
                 } else {
                     bail_span!(path, "Unknown pyimpl attribute")
                 }
@@ -1741,6 +1754,7 @@ fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<Extrac
         with_slots: quote! {
             #(#with_slots)*
         },
+        itemsize,
     })
 }
 
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index f782c035f86..0c67cd7bf24 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -187,6 +187,7 @@ impl PyRef<PyBytes> {
 }
 
 #[pyclass(
+    itemsize = 1,
     flags(BASETYPE, _MATCH_SELF),
     with(
         Py,
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 8fe85267cd0..46a0ff4774d 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -320,6 +320,7 @@ impl PyInt {
 }
 
 #[pyclass(
+    itemsize = 4,
     flags(BASETYPE, _MATCH_SELF),
     with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
 )]
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index adc5b483de3..13335428b35 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -257,16 +257,9 @@ impl<T> PyTuple<PyRef<T>> {
 }
 
 #[pyclass(
+    itemsize = std::mem::size_of::<crate::PyObjectRef>(),
     flags(BASETYPE, SEQUENCE, _MATCH_SELF),
-    with(
-        AsMapping,
-        AsSequence,
-        Hashable,
-        Comparable,
-        Iterable,
-        Constructor,
-        Representable
-    )
+    with(AsMapping, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
 )]
 impl PyTuple {
     #[pymethod]
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 86d871fe30f..ee07c0db0b9 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -948,6 +948,11 @@ impl PyType {
         self.slots.basicsize
     }
 
+    #[pygetset]
+    fn __itemsize__(&self) -> usize {
+        self.slots.itemsize
+    }
+
     #[pygetset]
     pub fn __name__(&self, vm: &VirtualMachine) -> PyStrRef {
         self.name_inner(
@@ -1347,65 +1352,144 @@ impl Constructor for PyType {
             attributes.insert(identifier!(vm, __hash__), vm.ctx.none.clone().into());
         }
 
-        let (heaptype_slots, add_dict): (Option<PyRef<PyTuple<PyStrRef>>>, bool) =
-            if let Some(x) = attributes.get(identifier!(vm, __slots__)) {
-                // Check if __slots__ is bytes - not allowed
-                if x.class().is(vm.ctx.types.bytes_type) {
-                    return Err(vm.new_type_error(
-                        "__slots__ items must be strings, not 'bytes'".to_owned(),
-                    ));
-                }
+        let (heaptype_slots, add_dict): (Option<PyRef<PyTuple<PyStrRef>>>, bool) = if let Some(x) =
+            attributes.get(identifier!(vm, __slots__))
+        {
+            // Check if __slots__ is bytes - not allowed
+            if x.class().is(vm.ctx.types.bytes_type) {
+                return Err(
+                    vm.new_type_error("__slots__ items must be strings, not 'bytes'".to_owned())
+                );
+            }
 
-                let slots = if x.class().is(vm.ctx.types.str_type) {
-                    let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
-                    PyTuple::new_ref_typed(vec![x.to_owned()], &vm.ctx)
-                } else {
-                    let iter = x.get_iter(vm)?;
-                    let elements = {
-                        let mut elements = Vec::new();
-                        while let PyIterReturn::Return(element) = iter.next(vm)? {
-                            // Check if any slot item is bytes
-                            if element.class().is(vm.ctx.types.bytes_type) {
-                                return Err(vm.new_type_error(
-                                    "__slots__ items must be strings, not 'bytes'".to_owned(),
-                                ));
-                            }
-                            elements.push(element);
+            let slots = if x.class().is(vm.ctx.types.str_type) {
+                let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
+                PyTuple::new_ref_typed(vec![x.to_owned()], &vm.ctx)
+            } else {
+                let iter = x.get_iter(vm)?;
+                let elements = {
+                    let mut elements = Vec::new();
+                    while let PyIterReturn::Return(element) = iter.next(vm)? {
+                        // Check if any slot item is bytes
+                        if element.class().is(vm.ctx.types.bytes_type) {
+                            return Err(vm.new_type_error(
+                                "__slots__ items must be strings, not 'bytes'".to_owned(),
+                            ));
                         }
-                        elements
-                    };
-                    let tuple = elements.into_pytuple(vm);
-                    tuple.try_into_typed(vm)?
+                        elements.push(element);
+                    }
+                    elements
                 };
+                let tuple = elements.into_pytuple(vm);
+                tuple.try_into_typed(vm)?
+            };
+
+            // Check if base has itemsize > 0 - can't add arbitrary slots to variable-size types
+            // Types like int, bytes, tuple have itemsize > 0 and don't allow custom slots
+            // But types like weakref.ref have itemsize = 0 and DO allow slots
+            let has_custom_slots = slots
+                .iter()
+                .any(|s| s.as_str() != "__dict__" && s.as_str() != "__weakref__");
+            if has_custom_slots && base.slots.itemsize > 0 {
+                return Err(vm.new_type_error(format!(
+                    "nonempty __slots__ not supported for subtype of '{}'",
+                    base.name()
+                )));
+            }
 
-                // Validate that all slots are valid identifiers
-                for slot in slots.iter() {
-                    if !slot.isidentifier() {
-                        return Err(vm.new_type_error("__slots__ must be identifiers".to_owned()));
+            // Validate slot names and track duplicates
+            let mut seen_dict = false;
+            let mut seen_weakref = false;
+            for slot in slots.iter() {
+                // Use isidentifier for validation (handles Unicode properly)
+                if !slot.isidentifier() {
+                    return Err(vm.new_type_error("__slots__ must be identifiers".to_owned()));
+                }
+
+                let slot_name = slot.as_str();
+
+                // Check for duplicate __dict__
+                if slot_name == "__dict__" {
+                    if seen_dict {
+                        return Err(vm.new_type_error(
+                            "__dict__ slot disallowed: we already got one".to_owned(),
+                        ));
                     }
+                    seen_dict = true;
                 }
 
-                // Check if __dict__ is in slots
-                let dict_name = "__dict__";
-                let has_dict = slots.iter().any(|s| s.as_str() == dict_name);
-
-                // Filter out __dict__ from slots
-                let filtered_slots = if has_dict {
-                    let filtered: Vec<PyStrRef> = slots
-                        .iter()
-                        .filter(|s| s.as_str() != dict_name)
-                        .cloned()
-                        .collect();
-                    PyTuple::new_ref_typed(filtered, &vm.ctx)
+                // Check for duplicate __weakref__
+                if slot_name == "__weakref__" {
+                    if seen_weakref {
+                        return Err(vm.new_type_error(
+                            "__weakref__ slot disallowed: we already got one".to_owned(),
+                        ));
+                    }
+                    seen_weakref = true;
+                }
+
+                // Check if slot name conflicts with class attributes
+                if attributes.contains_key(vm.ctx.intern_str(slot_name)) {
+                    return Err(vm.new_value_error(format!(
+                        "'{}' in __slots__ conflicts with a class variable",
+                        slot_name
+                    )));
+                }
+            }
+
+            // Check if base class already has __dict__ - can't redefine it
+            if seen_dict && base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+                return Err(
+                    vm.new_type_error("__dict__ slot disallowed: we already got one".to_owned())
+                );
+            }
+
+            // Check if base class already has __weakref__ - can't redefine it
+            // A base has weakref support if:
+            // 1. It's a heap type without explicit __slots__ (automatic weakref), OR
+            // 2. It's a heap type with __weakref__ in its __slots__
+            if seen_weakref {
+                let base_has_weakref = if let Some(ref ext) = base.heaptype_ext {
+                    match &ext.slots {
+                        // Heap type without __slots__ - has automatic weakref
+                        None => true,
+                        // Heap type with __slots__ - check if __weakref__ is in slots
+                        Some(base_slots) => base_slots.iter().any(|s| s.as_str() == "__weakref__"),
+                    }
                 } else {
-                    slots
+                    // Builtin type - check if it has __weakref__ descriptor
+                    let weakref_name = vm.ctx.intern_str("__weakref__");
+                    base.attributes.read().contains_key(weakref_name)
                 };
 
-                (Some(filtered_slots), has_dict)
+                if base_has_weakref {
+                    return Err(vm.new_type_error(
+                        "__weakref__ slot disallowed: we already got one".to_owned(),
+                    ));
+                }
+            }
+
+            // Check if __dict__ is in slots
+            let dict_name = "__dict__";
+            let has_dict = slots.iter().any(|s| s.as_str() == dict_name);
+
+            // Filter out __dict__ from slots
+            let filtered_slots = if has_dict {
+                let filtered: Vec<PyStrRef> = slots
+                    .iter()
+                    .filter(|s| s.as_str() != dict_name)
+                    .cloned()
+                    .collect();
+                PyTuple::new_ref_typed(filtered, &vm.ctx)
             } else {
-                (None, false)
+                slots
             };
 
+            (Some(filtered_slots), has_dict)
+        } else {
+            (None, false)
+        };
+
         // FIXME: this is a temporary fix. multi bases with multiple slots will break object
         let base_member_count = bases
             .iter()
@@ -2094,12 +2178,16 @@ fn solid_base<'a>(typ: &'a Py<PyType>, vm: &VirtualMachine) -> &'a Py<PyType> {
         vm.ctx.types.object_type
     };
 
-    // TODO: requires itemsize comparison too
-    if typ.__basicsize__() != base.__basicsize__() {
-        typ
-    } else {
-        base
-    }
+    // Check for extra instance variables (CPython's extra_ivars)
+    let t_size = typ.__basicsize__();
+    let b_size = base.__basicsize__();
+    let t_itemsize = typ.slots.itemsize;
+    let b_itemsize = base.slots.itemsize;
+
+    // Has extra ivars if: sizes differ AND (has items OR t_size > b_size)
+    let has_extra_ivars = t_size != b_size && (t_itemsize > 0 || b_itemsize > 0 || t_size > b_size);
+
+    if has_extra_ivars { typ } else { base }
 }
 
 fn best_base<'a>(bases: &'a [PyTypeRef], vm: &VirtualMachine) -> PyResult<&'a Py<PyType>> {
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index da860a96289..577fd7d6844 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -70,6 +70,7 @@ pub trait PyClassDef {
     const TP_NAME: &'static str;
     const DOC: Option<&'static str> = None;
     const BASICSIZE: usize;
+    const ITEMSIZE: usize = 0;
     const UNHASHABLE: bool = false;
 
     // due to restriction of rust trait system, object.__base__ is None
@@ -210,6 +211,7 @@ pub trait PyClassImpl: PyClassDef {
             flags: Self::TP_FLAGS,
             name: Self::TP_NAME,
             basicsize: Self::BASICSIZE,
+            itemsize: Self::ITEMSIZE,
             doc: Self::DOC,
             methods: Self::METHOD_DEFS,
             ..Default::default()
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 13a43ed9c95..0d6b17ae99d 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -128,7 +128,7 @@ pub struct PyTypeSlots {
     pub(crate) name: &'static str, // tp_name with <module>.<class> for print, not class name
 
     pub basicsize: usize,
-    // tp_itemsize
+    pub itemsize: usize, // tp_itemsize
 
     // Methods to implement standard operations
 

From 527111bc983d7323e1d60ad5e60101ab746c9b08 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 11:44:36 +0900
Subject: [PATCH 090/418] PyWrapperDescrObject and rewrite toggle_slot (#6536)

* SlotFunc

* slotdef

* unify slots

* remove unsed slots
---
 .cspell.dict/cpython.txt                      |    2 +
 Lib/test/test_descr.py                        |    1 -
 Lib/test/test_inspect/test_inspect.py         |    4 -
 Lib/test/test_sqlite3/test_factory.py         |    2 -
 .../test_unittest/testmock/testhelpers.py     |    2 -
 crates/vm/src/builtins/bool.rs                |   14 +-
 crates/vm/src/builtins/complex.rs             |  135 +-
 crates/vm/src/builtins/descriptor.rs          |  220 ++-
 crates/vm/src/builtins/float.rs               |  189 +--
 crates/vm/src/builtins/int.rs                 |  153 +-
 crates/vm/src/builtins/type.rs                |  172 +-
 crates/vm/src/class.rs                        |   91 +-
 crates/vm/src/protocol/mod.rs                 |    2 +-
 crates/vm/src/protocol/number.rs              |  113 +-
 crates/vm/src/types/mod.rs                    |    2 +
 crates/vm/src/types/slot.rs                   | 1084 +++++++-----
 crates/vm/src/types/slot_defs.rs              | 1465 +++++++++++++++++
 crates/vm/src/types/zoo.rs                    |    2 +-
 18 files changed, 2531 insertions(+), 1122 deletions(-)
 create mode 100644 crates/vm/src/types/slot_defs.rs

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 441e8af5b8f..cb6f774ed18 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -1,6 +1,7 @@
 argtypes
 asdl
 asname
+attro
 augassign
 badcert
 badsyntax
@@ -50,6 +51,7 @@ prec
 preinitialized
 pythonw
 PYTHREAD_NAME
+releasebuffer
 SA_ONSTACK
 SOABI
 stackdepth
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 4e04371f626..b3d973237df 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -1399,7 +1399,6 @@ class Q2:
                 __qualname__ = object()
                 __slots__ = ["__qualname__"]
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_descriptor(self):
         # Issue2115: slot descriptors did not correctly check
         # the type of the given object
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index 353d7c2e7b2..8f87fa8571a 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -2126,8 +2126,6 @@ class DataDescriptorSub(DataDescriptorWithNoGet,
         self.assertFalse(inspect.ismethoddescriptor(MethodDescriptorSub))
         self.assertFalse(inspect.ismethoddescriptor(DataDescriptorSub))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_builtin_descriptors(self):
         builtin_slot_wrapper = int.__add__  # This one is mentioned in docs.
         class Owner:
@@ -2217,8 +2215,6 @@ class DataDescriptor2:
         self.assertTrue(inspect.isdatadescriptor(DataDescriptor2()),
                         'class with __set__ = None is a data descriptor')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slot(self):
         class Slotted:
             __slots__ = 'foo',
diff --git a/Lib/test/test_sqlite3/test_factory.py b/Lib/test/test_sqlite3/test_factory.py
index e52c10fe944..c13a7481520 100644
--- a/Lib/test/test_sqlite3/test_factory.py
+++ b/Lib/test/test_sqlite3/test_factory.py
@@ -241,8 +241,6 @@ def test_sqlite_row_hash_cmp(self):
 
         self.assertEqual(hash(row_1), hash(row_2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_sqlite_row_as_sequence(self):
         """ Checks if the row object can act like a sequence """
         self.con.row_factory = sqlite.Row
diff --git a/Lib/test/test_unittest/testmock/testhelpers.py b/Lib/test/test_unittest/testmock/testhelpers.py
index 5facac685fd..c83068beb15 100644
--- a/Lib/test/test_unittest/testmock/testhelpers.py
+++ b/Lib/test/test_unittest/testmock/testhelpers.py
@@ -884,8 +884,6 @@ def f(a, self): pass
         a.f.assert_called_with(self=10)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_autospec_data_descriptor(self):
         class Descriptor(object):
             def __init__(self, value):
diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
index 8fee4af3834..cfd1f136d14 100644
--- a/crates/vm/src/builtins/bool.rs
+++ b/crates/vm/src/builtins/bool.rs
@@ -126,10 +126,10 @@ impl PyBool {
             .and_then(|format_spec| format_spec.format_bool(new_bool))
             .map_err(|err| err.into_pyexception(vm))
     }
+}
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
-    fn __or__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+impl PyBool {
+    pub(crate) fn __or__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         if lhs.fast_isinstance(vm.ctx.types.bool_type)
             && rhs.fast_isinstance(vm.ctx.types.bool_type)
         {
@@ -143,9 +143,7 @@ impl PyBool {
         }
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
-    fn __and__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    pub(crate) fn __and__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         if lhs.fast_isinstance(vm.ctx.types.bool_type)
             && rhs.fast_isinstance(vm.ctx.types.bool_type)
         {
@@ -159,9 +157,7 @@ impl PyBool {
         }
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
-    fn __xor__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    pub(crate) fn __xor__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         if lhs.fast_isinstance(vm.ctx.types.bool_type)
             && rhs.fast_isinstance(vm.ctx.types.bool_type)
         {
diff --git a/crates/vm/src/builtins/complex.rs b/crates/vm/src/builtins/complex.rs
index 8bf46cfdd5c..ba74d5e0367 100644
--- a/crates/vm/src/builtins/complex.rs
+++ b/crates/vm/src/builtins/complex.rs
@@ -5,11 +5,7 @@ use crate::{
     class::PyClassImpl,
     common::format::FormatSpec,
     convert::{IntoPyException, ToPyObject, ToPyResult},
-    function::{
-        FuncArgs, OptionalArg, OptionalOption,
-        PyArithmeticValue::{self, *},
-        PyComparisonValue,
-    },
+    function::{FuncArgs, OptionalArg, PyComparisonValue},
     protocol::PyNumberMethods,
     stdlib::warnings,
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
@@ -268,133 +264,11 @@ impl PyComplex {
         self.value.im
     }
 
-    #[pymethod]
-    fn __abs__(&self, vm: &VirtualMachine) -> PyResult<f64> {
-        let Complex64 { im, re } = self.value;
-        let is_finite = im.is_finite() && re.is_finite();
-        let abs_result = re.hypot(im);
-        if is_finite && abs_result.is_infinite() {
-            Err(vm.new_overflow_error("absolute value too large"))
-        } else {
-            Ok(abs_result)
-        }
-    }
-
-    #[inline]
-    fn op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>>
-    where
-        F: Fn(Complex64, Complex64) -> PyResult<Complex64>,
-    {
-        to_op_complex(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a + b), vm)
-    }
-
-    #[pymethod]
-    fn __sub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a - b), vm)
-    }
-
-    #[pymethod]
-    fn __rsub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(b - a), vm)
-    }
-
     #[pymethod]
     fn conjugate(&self) -> Complex64 {
         self.value.conj()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a * b), vm)
-    }
-
-    #[pymethod]
-    fn __truediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_div(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_div(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    const fn __pos__(&self) -> Complex64 {
-        self.value
-    }
-
-    #[pymethod]
-    fn __neg__(&self) -> Complex64 {
-        -self.value
-    }
-
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        mod_val: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        if mod_val.flatten().is_some() {
-            Err(vm.new_value_error("complex modulo not allowed"))
-        } else {
-            self.op(other, |a, b| inner_pow(a, b, vm), vm)
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_pow(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !Complex64::is_zero(&self.value)
-    }
-
     #[pymethod]
     const fn __getnewargs__(&self) -> (f64, f64) {
         let Complex64 { re, im } = self.value;
@@ -489,7 +363,12 @@ impl AsNumber for PyComplex {
             }),
             absolute: Some(|number, vm| {
                 let value = PyComplex::number_downcast(number).value;
-                value.norm().to_pyresult(vm)
+                let result = value.norm();
+                // Check for overflow: hypot returns inf for finite inputs that overflow
+                if result.is_infinite() && value.re.is_finite() && value.im.is_finite() {
+                    return Err(vm.new_overflow_error("absolute value too large".to_owned()));
+                }
+                result.to_pyresult(vm)
             }),
             boolean: Some(|number, _vm| Ok(!PyComplex::number_downcast(number).value.is_zero())),
             true_divide: Some(|a, b, vm| PyComplex::number_op(a, b, inner_div, vm)),
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index 297199eee18..802b81f6d79 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -4,11 +4,15 @@ use crate::{
     builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
     class::PyClassImpl,
     common::hash::PyHash,
-    convert::ToPyResult,
+    convert::{ToPyObject, ToPyResult},
     function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
+    protocol::{PyNumberBinaryFunc, PyNumberTernaryFunc, PyNumberUnaryFunc},
     types::{
-        Callable, Comparable, GetDescriptor, HashFunc, Hashable, InitFunc, IterFunc, IterNextFunc,
-        PyComparisonOp, Representable, StringifyFunc,
+        Callable, Comparable, DelFunc, DescrGetFunc, DescrSetFunc, GenericMethod, GetDescriptor,
+        GetattroFunc, HashFunc, Hashable, InitFunc, IterFunc, IterNextFunc, MapAssSubscriptFunc,
+        MapLenFunc, MapSubscriptFunc, PyComparisonOp, Representable, RichCompareFunc,
+        SeqAssItemFunc, SeqConcatFunc, SeqContainsFunc, SeqItemFunc, SeqLenFunc, SeqRepeatFunc,
+        SetattroFunc, StringifyFunc,
     },
 };
 use rustpython_common::lock::PyRwLock;
@@ -387,22 +391,58 @@ impl GetDescriptor for PyMemberDescriptor {
 pub fn init(ctx: &Context) {
     PyMemberDescriptor::extend_class(ctx, ctx.types.member_descriptor_type);
     PyMethodDescriptor::extend_class(ctx, ctx.types.method_descriptor_type);
-    PySlotWrapper::extend_class(ctx, ctx.types.wrapper_descriptor_type);
+    PyWrapper::extend_class(ctx, ctx.types.wrapper_descriptor_type);
     PyMethodWrapper::extend_class(ctx, ctx.types.method_wrapper_type);
 }
 
-// PySlotWrapper - wrapper_descriptor
+// PyWrapper - wrapper_descriptor
 
-/// Type-erased slot function - mirrors CPython's void* d_wrapped
 /// Each variant knows how to call the wrapped function with proper types
 #[derive(Clone, Copy)]
 pub enum SlotFunc {
+    // Basic slots
     Init(InitFunc),
     Hash(HashFunc),
     Str(StringifyFunc),
     Repr(StringifyFunc),
     Iter(IterFunc),
     IterNext(IterNextFunc),
+    Call(GenericMethod),
+    Del(DelFunc),
+
+    // Attribute access slots
+    GetAttro(GetattroFunc),
+    SetAttro(SetattroFunc), // __setattr__
+    DelAttro(SetattroFunc), // __delattr__ (same func type, different PySetterValue)
+
+    // Rich comparison slots (with comparison op)
+    RichCompare(RichCompareFunc, PyComparisonOp),
+
+    // Descriptor slots
+    DescrGet(DescrGetFunc),
+    DescrSet(DescrSetFunc), // __set__
+    DescrDel(DescrSetFunc), // __delete__ (same func type, different PySetterValue)
+
+    // Sequence sub-slots (sq_*)
+    SeqLength(SeqLenFunc),
+    SeqConcat(SeqConcatFunc),
+    SeqRepeat(SeqRepeatFunc),
+    SeqItem(SeqItemFunc),
+    SeqAssItem(SeqAssItemFunc),
+    SeqContains(SeqContainsFunc),
+
+    // Mapping sub-slots (mp_*)
+    MapLength(MapLenFunc),
+    MapSubscript(MapSubscriptFunc),
+    MapAssSubscript(MapAssSubscriptFunc),
+
+    // Number sub-slots (nb_*) - grouped by signature
+    NumBoolean(PyNumberUnaryFunc<bool>),  // __bool__
+    NumUnary(PyNumberUnaryFunc),          // __int__, __float__, __index__
+    NumBinary(PyNumberBinaryFunc),        // __add__, __sub__, __mul__, etc.
+    NumBinaryRight(PyNumberBinaryFunc),   // __radd__, __rsub__, etc. (swapped args)
+    NumTernary(PyNumberTernaryFunc),      // __pow__
+    NumTernaryRight(PyNumberTernaryFunc), // __rpow__ (swapped first two args)
 }
 
 impl std::fmt::Debug for SlotFunc {
@@ -414,6 +454,33 @@ impl std::fmt::Debug for SlotFunc {
             SlotFunc::Repr(_) => write!(f, "SlotFunc::Repr(...)"),
             SlotFunc::Iter(_) => write!(f, "SlotFunc::Iter(...)"),
             SlotFunc::IterNext(_) => write!(f, "SlotFunc::IterNext(...)"),
+            SlotFunc::Call(_) => write!(f, "SlotFunc::Call(...)"),
+            SlotFunc::Del(_) => write!(f, "SlotFunc::Del(...)"),
+            SlotFunc::GetAttro(_) => write!(f, "SlotFunc::GetAttro(...)"),
+            SlotFunc::SetAttro(_) => write!(f, "SlotFunc::SetAttro(...)"),
+            SlotFunc::DelAttro(_) => write!(f, "SlotFunc::DelAttro(...)"),
+            SlotFunc::RichCompare(_, op) => write!(f, "SlotFunc::RichCompare(..., {:?})", op),
+            SlotFunc::DescrGet(_) => write!(f, "SlotFunc::DescrGet(...)"),
+            SlotFunc::DescrSet(_) => write!(f, "SlotFunc::DescrSet(...)"),
+            SlotFunc::DescrDel(_) => write!(f, "SlotFunc::DescrDel(...)"),
+            // Sequence sub-slots
+            SlotFunc::SeqLength(_) => write!(f, "SlotFunc::SeqLength(...)"),
+            SlotFunc::SeqConcat(_) => write!(f, "SlotFunc::SeqConcat(...)"),
+            SlotFunc::SeqRepeat(_) => write!(f, "SlotFunc::SeqRepeat(...)"),
+            SlotFunc::SeqItem(_) => write!(f, "SlotFunc::SeqItem(...)"),
+            SlotFunc::SeqAssItem(_) => write!(f, "SlotFunc::SeqAssItem(...)"),
+            SlotFunc::SeqContains(_) => write!(f, "SlotFunc::SeqContains(...)"),
+            // Mapping sub-slots
+            SlotFunc::MapLength(_) => write!(f, "SlotFunc::MapLength(...)"),
+            SlotFunc::MapSubscript(_) => write!(f, "SlotFunc::MapSubscript(...)"),
+            SlotFunc::MapAssSubscript(_) => write!(f, "SlotFunc::MapAssSubscript(...)"),
+            // Number sub-slots
+            SlotFunc::NumBoolean(_) => write!(f, "SlotFunc::NumBoolean(...)"),
+            SlotFunc::NumUnary(_) => write!(f, "SlotFunc::NumUnary(...)"),
+            SlotFunc::NumBinary(_) => write!(f, "SlotFunc::NumBinary(...)"),
+            SlotFunc::NumBinaryRight(_) => write!(f, "SlotFunc::NumBinaryRight(...)"),
+            SlotFunc::NumTernary(_) => write!(f, "SlotFunc::NumTernary(...)"),
+            SlotFunc::NumTernaryRight(_) => write!(f, "SlotFunc::NumTernaryRight(...)"),
         }
     }
 }
@@ -463,6 +530,133 @@ impl SlotFunc {
                 }
                 func(&obj, vm).to_pyresult(vm)
             }
+            SlotFunc::Call(func) => func(&obj, args, vm),
+            SlotFunc::Del(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__del__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(&obj, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::GetAttro(func) => {
+                let (name,): (PyRef<PyStr>,) = args.bind(vm)?;
+                func(&obj, &name, vm)
+            }
+            SlotFunc::SetAttro(func) => {
+                let (name, value): (PyRef<PyStr>, PyObjectRef) = args.bind(vm)?;
+                func(&obj, &name, PySetterValue::Assign(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::DelAttro(func) => {
+                let (name,): (PyRef<PyStr>,) = args.bind(vm)?;
+                func(&obj, &name, PySetterValue::Delete, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::RichCompare(func, op) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, &other, *op, vm).map(|r| match r {
+                    crate::function::Either::A(obj) => obj,
+                    crate::function::Either::B(cmp_val) => cmp_val.to_pyobject(vm),
+                })
+            }
+            SlotFunc::DescrGet(func) => {
+                let (instance, owner): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let owner = owner.into_option();
+                let instance_opt = if vm.is_none(&instance) {
+                    None
+                } else {
+                    Some(instance)
+                };
+                func(obj, instance_opt, owner, vm)
+            }
+            SlotFunc::DescrSet(func) => {
+                let (instance, value): (PyObjectRef, PyObjectRef) = args.bind(vm)?;
+                func(&obj, instance, PySetterValue::Assign(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::DescrDel(func) => {
+                let (instance,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, instance, PySetterValue::Delete, vm)?;
+                Ok(vm.ctx.none())
+            }
+            // Sequence sub-slots
+            SlotFunc::SeqLength(func) => {
+                args.bind::<()>(vm)?;
+                let len = func(obj.sequence_unchecked(), vm)?;
+                Ok(vm.ctx.new_int(len).into())
+            }
+            SlotFunc::SeqConcat(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), &other, vm)
+            }
+            SlotFunc::SeqRepeat(func) => {
+                let (n,): (isize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), n, vm)
+            }
+            SlotFunc::SeqItem(func) => {
+                let (index,): (isize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, vm)
+            }
+            SlotFunc::SeqAssItem(func) => {
+                let (index, value): (isize, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, value.into_option(), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::SeqContains(func) => {
+                let (item,): (PyObjectRef,) = args.bind(vm)?;
+                let result = func(obj.sequence_unchecked(), &item, vm)?;
+                Ok(vm.ctx.new_bool(result).into())
+            }
+            // Mapping sub-slots
+            SlotFunc::MapLength(func) => {
+                args.bind::<()>(vm)?;
+                let len = func(obj.mapping_unchecked(), vm)?;
+                Ok(vm.ctx.new_int(len).into())
+            }
+            SlotFunc::MapSubscript(func) => {
+                let (key,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, vm)
+            }
+            SlotFunc::MapAssSubscript(func) => {
+                let (key, value): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, value.into_option(), vm)?;
+                Ok(vm.ctx.none())
+            }
+            // Number sub-slots
+            SlotFunc::NumBoolean(func) => {
+                args.bind::<()>(vm)?;
+                let result = func(obj.number(), vm)?;
+                Ok(vm.ctx.new_bool(result).into())
+            }
+            SlotFunc::NumUnary(func) => {
+                args.bind::<()>(vm)?;
+                func(obj.number(), vm)
+            }
+            SlotFunc::NumBinary(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, &other, vm)
+            }
+            SlotFunc::NumBinaryRight(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&other, &obj, vm) // Swapped: other op obj
+            }
+            SlotFunc::NumTernary(func) => {
+                let (y, z): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let z = z.unwrap_or_else(|| vm.ctx.none());
+                func(&obj, &y, &z, vm)
+            }
+            SlotFunc::NumTernaryRight(func) => {
+                let (y, z): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let z = z.unwrap_or_else(|| vm.ctx.none());
+                func(&y, &obj, &z, vm) // Swapped: y ** obj % z
+            }
         }
     }
 }
@@ -471,20 +665,20 @@ impl SlotFunc {
 // = PyWrapperDescrObject
 #[pyclass(name = "wrapper_descriptor", module = false)]
 #[derive(Debug)]
-pub struct PySlotWrapper {
+pub struct PyWrapper {
     pub typ: &'static Py<PyType>,
     pub name: &'static PyStrInterned,
     pub wrapped: SlotFunc,
     pub doc: Option<&'static str>,
 }
 
-impl PyPayload for PySlotWrapper {
+impl PyPayload for PyWrapper {
     fn class(ctx: &Context) -> &'static Py<PyType> {
         ctx.types.wrapper_descriptor_type
     }
 }
 
-impl GetDescriptor for PySlotWrapper {
+impl GetDescriptor for PyWrapper {
     fn descr_get(
         zelf: PyObjectRef,
         obj: Option<PyObjectRef>,
@@ -501,7 +695,7 @@ impl GetDescriptor for PySlotWrapper {
     }
 }
 
-impl Callable for PySlotWrapper {
+impl Callable for PyWrapper {
     type Args = FuncArgs;
 
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
@@ -525,7 +719,7 @@ impl Callable for PySlotWrapper {
     with(GetDescriptor, Callable, Representable),
     flags(DISALLOW_INSTANTIATION)
 )]
-impl PySlotWrapper {
+impl PyWrapper {
     #[pygetset]
     fn __name__(&self) -> &'static PyStrInterned {
         self.name
@@ -547,7 +741,7 @@ impl PySlotWrapper {
     }
 }
 
-impl Representable for PySlotWrapper {
+impl Representable for PyWrapper {
     #[inline]
     fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
         Ok(format!(
@@ -565,7 +759,7 @@ impl Representable for PySlotWrapper {
 #[pyclass(name = "method-wrapper", module = false, traverse)]
 #[derive(Debug)]
 pub struct PyMethodWrapper {
-    pub wrapper: PyRef<PySlotWrapper>,
+    pub wrapper: PyRef<PyWrapper>,
     #[pytraverse(skip)]
     pub obj: PyObjectRef,
 }
diff --git a/crates/vm/src/builtins/float.rs b/crates/vm/src/builtins/float.rs
index 26182d748a9..f101a3aa8e3 100644
--- a/crates/vm/src/builtins/float.rs
+++ b/crates/vm/src/builtins/float.rs
@@ -8,8 +8,7 @@ use crate::{
     common::{float_ops, format::FormatSpec, hash},
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{
-        ArgBytesLike, FuncArgs, OptionalArg, OptionalOption,
-        PyArithmeticValue::{self, *},
+        ArgBytesLike, FuncArgs, OptionalArg, OptionalOption, PyArithmeticValue::*,
         PyComparisonValue,
     },
     protocol::PyNumberMethods,
@@ -239,182 +238,6 @@ impl PyFloat {
         .to_owned())
     }
 
-    #[pymethod]
-    const fn __abs__(&self) -> f64 {
-        self.value.abs()
-    }
-
-    #[inline]
-    fn simple_op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>>
-    where
-        F: Fn(f64, f64) -> PyResult<f64>,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[inline]
-    fn complex_op<F>(&self, other: PyObjectRef, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: Fn(f64, f64) -> PyResult,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(vm.ctx.not_implemented()),
-            |other| op(self.value, other),
-        )
-    }
-
-    #[inline]
-    fn tuple_op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>>
-    where
-        F: Fn(f64, f64) -> PyResult<(f64, f64)>,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a + b), vm)
-    }
-
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        self.value != 0.0
-    }
-
-    #[pymethod]
-    fn __divmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>> {
-        self.tuple_op(other, |a, b| inner_divmod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rdivmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>> {
-        self.tuple_op(other, |a, b| inner_divmod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __floordiv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_floordiv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rfloordiv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_floordiv(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_mod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_mod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    const fn __pos__(&self) -> f64 {
-        self.value
-    }
-
-    #[pymethod]
-    const fn __neg__(&self) -> f64 {
-        -self.value
-    }
-
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        mod_val: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        if mod_val.flatten().is_some() {
-            Err(vm.new_type_error("floating point pow() does not accept a 3rd argument"))
-        } else {
-            self.complex_op(other, |a, b| float_pow(a, b, vm), vm)
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.complex_op(other, |a, b| float_pow(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __sub__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a - b), vm)
-    }
-
-    #[pymethod]
-    fn __rsub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(b - a), vm)
-    }
-
-    #[pymethod]
-    fn __truediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_div(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_div(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a * b), vm)
-    }
-
     #[pymethod]
     fn __trunc__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
         try_to_bigint(self.value, vm)
@@ -460,16 +283,6 @@ impl PyFloat {
         Ok(value)
     }
 
-    #[pymethod]
-    fn __int__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
-        self.__trunc__(vm)
-    }
-
-    #[pymethod]
-    const fn __float__(zelf: PyRef<Self>) -> PyRef<Self> {
-        zelf
-    }
-
     #[pygetset]
     const fn real(zelf: PyRef<Self>) -> PyRef<Self> {
         zelf
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 46a0ff4774d..37b41e085ad 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -12,8 +12,7 @@ use crate::{
     },
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{
-        ArgByteOrder, ArgIntoBool, FuncArgs, OptionalArg, OptionalOption, PyArithmeticValue,
-        PyComparisonValue,
+        ArgByteOrder, ArgIntoBool, FuncArgs, OptionalArg, PyArithmeticValue, PyComparisonValue,
     },
     protocol::{PyNumberMethods, handle_bytes_to_int_err},
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
@@ -325,83 +324,15 @@ impl PyInt {
     with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
 )]
 impl PyInt {
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a + b)
-    }
-
-    #[pymethod]
-    fn __sub__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a - b)
-    }
-
-    #[pymethod]
-    fn __rsub__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| b - a)
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a * b)
-    }
-
-    #[pymethod]
-    fn __truediv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_truediv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_truediv(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __floordiv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_floordiv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rfloordiv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_floordiv(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __lshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_lshift(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rlshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_lshift(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_rshift(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rrshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_rshift(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
-    pub fn __xor__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+    pub(crate) fn __xor__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
         self.int_op(other, |a, b| a ^ b)
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
-    pub fn __or__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+    pub(crate) fn __or__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
         self.int_op(other, |a, b| a | b)
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
-    pub fn __and__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+    pub(crate) fn __and__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
         self.int_op(other, |a, b| a & b)
     }
 
@@ -447,54 +378,6 @@ impl PyInt {
         )
     }
 
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        r#mod: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        match r#mod.flatten() {
-            Some(modulus) => self.modpow(other, modulus, vm),
-            None => self.general_op(other, |a, b| inner_pow(a, b, vm), vm),
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_pow(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_mod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_mod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __divmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_divmod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rdivmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_divmod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __neg__(&self) -> BigInt {
-        -(&self.value)
-    }
-
-    #[pymethod]
-    fn __abs__(&self) -> BigInt {
-        self.value.abs()
-    }
-
     #[pymethod]
     fn __round__(
         zelf: PyRef<Self>,
@@ -537,16 +420,6 @@ impl PyInt {
         Ok(zelf)
     }
 
-    #[pymethod]
-    fn __pos__(&self) -> BigInt {
-        self.value.clone()
-    }
-
-    #[pymethod]
-    fn __float__(&self, vm: &VirtualMachine) -> PyResult<f64> {
-        try_to_float(&self.value, vm)
-    }
-
     #[pymethod]
     fn __trunc__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
         zelf.__int__(vm)
@@ -562,16 +435,6 @@ impl PyInt {
         zelf.__int__(vm)
     }
 
-    #[pymethod]
-    fn __index__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pymethod]
-    fn __invert__(&self) -> BigInt {
-        !(&self.value)
-    }
-
     #[pymethod]
     fn __format__(&self, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
         FormatSpec::parse(spec.as_str())
@@ -579,11 +442,6 @@ impl PyInt {
             .map_err(|err| err.into_pyexception(vm))
     }
 
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !self.value.is_zero()
-    }
-
     #[pymethod]
     fn __sizeof__(&self) -> usize {
         std::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
@@ -706,8 +564,7 @@ impl PyInt {
 
 #[pyclass]
 impl PyRef<PyInt> {
-    #[pymethod]
-    fn __int__(self, vm: &VirtualMachine) -> PyRefExact<PyInt> {
+    pub(crate) fn __int__(self, vm: &VirtualMachine) -> PyRefExact<PyInt> {
         self.into_exact_or(&vm.ctx, |zelf| unsafe {
             // TODO: this is actually safe. we need better interface
             PyRefExact::new_unchecked(vm.ctx.new_bigint(&zelf.value))
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index ee07c0db0b9..f74095a8c8a 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -26,7 +26,7 @@ use crate::{
     protocol::{PyIterReturn, PyNumberMethods},
     types::{
         AsNumber, Callable, Constructor, GetAttr, Initializer, PyTypeFlags, PyTypeSlots,
-        Representable, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
+        Representable, SLOT_DEFS, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
     },
 };
 use indexmap::{IndexMap, map::Entry};
@@ -464,173 +464,11 @@ impl PyType {
 
     /// Inherit slots from base type. inherit_slots
     pub(crate) fn inherit_slots(&self, base: &Self) {
-        macro_rules! copyslot {
-            ($slot:ident) => {
-                if self.slots.$slot.load().is_none() {
-                    if let Some(base_val) = base.slots.$slot.load() {
-                        self.slots.$slot.store(Some(base_val));
-                    }
-                }
-            };
-        }
-
-        // Copy init slot only if base actually defines it (not just inherited)
-        // This is needed for multiple inheritance where a later base might
-        // have a more specific init slot
-        macro_rules! copyslot_defined {
-            ($slot:ident) => {
-                if self.slots.$slot.load().is_none() {
-                    if let Some(base_val) = base.slots.$slot.load() {
-                        // SLOTDEFINED: base->SLOT && (basebase == NULL || base->SLOT != basebase->SLOT)
-                        let basebase = base.base.as_ref();
-                        let slot_defined = match basebase {
-                            None => true,
-                            Some(bb) => bb.slots.$slot.load().map(|v| v as usize)
-                                != Some(base_val as usize),
-                        };
-                        if slot_defined {
-                            self.slots.$slot.store(Some(base_val));
-                        }
-                    }
-                }
-            };
-        }
-
-        // Core slots
-        copyslot!(hash);
-        copyslot!(call);
-        copyslot!(str);
-        copyslot!(repr);
-        copyslot!(getattro);
-        copyslot!(setattro);
-        copyslot!(richcompare);
-        copyslot!(iter);
-        copyslot!(iternext);
-        copyslot!(descr_get);
-        copyslot!(descr_set);
-        // init uses SLOTDEFINED check for multiple inheritance support
-        copyslot_defined!(init);
-        copyslot!(del);
-        // new is handled by set_new()
-        // as_buffer is inherited at type creation time (not AtomicCell)
-
-        // Sub-slots (number, sequence, mapping)
-        self.inherit_number_slots(base);
-        self.inherit_sequence_slots(base);
-        self.inherit_mapping_slots(base);
-    }
-
-    /// Inherit number sub-slots from base type
-    fn inherit_number_slots(&self, base: &Self) {
-        macro_rules! copy_num_slot {
-            ($slot:ident) => {
-                if self.slots.as_number.$slot.load().is_none() {
-                    if let Some(base_val) = base.slots.as_number.$slot.load() {
-                        self.slots.as_number.$slot.store(Some(base_val));
-                    }
-                }
-            };
+        // Use SLOT_DEFS to iterate all slots
+        // Note: as_buffer is handled in inherit_readonly_slots (not AtomicCell)
+        for def in SLOT_DEFS {
+            def.accessor.copyslot_if_none(self, base);
         }
-
-        // Binary operations
-        copy_num_slot!(add);
-        copy_num_slot!(right_add);
-        copy_num_slot!(inplace_add);
-        copy_num_slot!(subtract);
-        copy_num_slot!(right_subtract);
-        copy_num_slot!(inplace_subtract);
-        copy_num_slot!(multiply);
-        copy_num_slot!(right_multiply);
-        copy_num_slot!(inplace_multiply);
-        copy_num_slot!(remainder);
-        copy_num_slot!(right_remainder);
-        copy_num_slot!(inplace_remainder);
-        copy_num_slot!(divmod);
-        copy_num_slot!(right_divmod);
-        copy_num_slot!(power);
-        copy_num_slot!(right_power);
-        copy_num_slot!(inplace_power);
-
-        // Bitwise operations
-        copy_num_slot!(lshift);
-        copy_num_slot!(right_lshift);
-        copy_num_slot!(inplace_lshift);
-        copy_num_slot!(rshift);
-        copy_num_slot!(right_rshift);
-        copy_num_slot!(inplace_rshift);
-        copy_num_slot!(and);
-        copy_num_slot!(right_and);
-        copy_num_slot!(inplace_and);
-        copy_num_slot!(xor);
-        copy_num_slot!(right_xor);
-        copy_num_slot!(inplace_xor);
-        copy_num_slot!(or);
-        copy_num_slot!(right_or);
-        copy_num_slot!(inplace_or);
-
-        // Division operations
-        copy_num_slot!(floor_divide);
-        copy_num_slot!(right_floor_divide);
-        copy_num_slot!(inplace_floor_divide);
-        copy_num_slot!(true_divide);
-        copy_num_slot!(right_true_divide);
-        copy_num_slot!(inplace_true_divide);
-
-        // Matrix multiplication
-        copy_num_slot!(matrix_multiply);
-        copy_num_slot!(right_matrix_multiply);
-        copy_num_slot!(inplace_matrix_multiply);
-
-        // Unary operations
-        copy_num_slot!(negative);
-        copy_num_slot!(positive);
-        copy_num_slot!(absolute);
-        copy_num_slot!(boolean);
-        copy_num_slot!(invert);
-
-        // Conversion
-        copy_num_slot!(int);
-        copy_num_slot!(float);
-        copy_num_slot!(index);
-    }
-
-    /// Inherit sequence sub-slots from base type
-    fn inherit_sequence_slots(&self, base: &Self) {
-        macro_rules! copy_seq_slot {
-            ($slot:ident) => {
-                if self.slots.as_sequence.$slot.load().is_none() {
-                    if let Some(base_val) = base.slots.as_sequence.$slot.load() {
-                        self.slots.as_sequence.$slot.store(Some(base_val));
-                    }
-                }
-            };
-        }
-
-        copy_seq_slot!(length);
-        copy_seq_slot!(concat);
-        copy_seq_slot!(repeat);
-        copy_seq_slot!(item);
-        copy_seq_slot!(ass_item);
-        copy_seq_slot!(contains);
-        copy_seq_slot!(inplace_concat);
-        copy_seq_slot!(inplace_repeat);
-    }
-
-    /// Inherit mapping sub-slots from base type
-    fn inherit_mapping_slots(&self, base: &Self) {
-        macro_rules! copy_map_slot {
-            ($slot:ident) => {
-                if self.slots.as_mapping.$slot.load().is_none() {
-                    if let Some(base_val) = base.slots.as_mapping.$slot.load() {
-                        self.slots.as_mapping.$slot.store(Some(base_val));
-                    }
-                }
-            };
-        }
-
-        copy_map_slot!(length);
-        copy_map_slot!(subscript);
-        copy_map_slot!(ass_subscript);
     }
 
     // This is used for class initialization where the vm is not yet available.
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 577fd7d6844..ce41abcc60b 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -2,17 +2,60 @@
 
 use crate::{
     PyPayload,
-    builtins::{
-        PyBaseObject, PyType, PyTypeRef,
-        descriptor::{PySlotWrapper, SlotFunc},
-    },
+    builtins::{PyBaseObject, PyType, PyTypeRef, descriptor::PyWrapper},
     function::PyMethodDef,
     object::Py,
-    types::{PyTypeFlags, PyTypeSlots, hash_not_implemented},
+    types::{PyTypeFlags, PyTypeSlots, SLOT_DEFS, hash_not_implemented},
     vm::Context,
 };
 use rustpython_common::static_cell;
 
+/// Add slot wrapper descriptors to a type's dict
+///
+/// Iterates SLOT_DEFS and creates a PyWrapper for each slot that:
+/// 1. Has a function set in the type's slots
+/// 2. Doesn't already have an attribute in the type's dict
+pub fn add_operators(class: &'static Py<PyType>, ctx: &Context) {
+    for def in SLOT_DEFS.iter() {
+        // Skip __new__ - it has special handling
+        if def.name == "__new__" {
+            continue;
+        }
+
+        // Special handling for __hash__ = None
+        if def.name == "__hash__"
+            && class
+                .slots
+                .hash
+                .load()
+                .is_some_and(|h| h as usize == hash_not_implemented as usize)
+        {
+            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
+            continue;
+        }
+
+        // Get the slot function wrapped in SlotFunc
+        let Some(slot_func) = def.accessor.get_slot_func_with_op(&class.slots, def.op) else {
+            continue;
+        };
+
+        // Check if attribute already exists in dict
+        let attr_name = ctx.intern_str(def.name);
+        if class.attributes.read().contains_key(attr_name) {
+            continue;
+        }
+
+        // Create and add the wrapper
+        let wrapper = PyWrapper {
+            typ: class,
+            name: attr_name,
+            wrapped: slot_func,
+            doc: Some(def.doc),
+        };
+        class.set_attr(attr_name, wrapper.into_ref(ctx).into());
+    }
+}
+
 pub trait StaticType {
     // Ideally, saving PyType is better than PyTypeRef
     fn static_cell() -> &'static static_cell::StaticCell<PyTypeRef>;
@@ -140,42 +183,8 @@ pub trait PyClassImpl: PyClassDef {
             }
         }
 
-        // Add slot wrappers for slots that exist and are not already in dict
-        // This mirrors CPython's add_operators() in typeobject.c
-        macro_rules! add_slot_wrapper {
-            ($slot:ident, $name:ident, $variant:ident, $doc:expr) => {
-                if let Some(func) = class.slots.$slot.load() {
-                    let attr_name = identifier!(ctx, $name);
-                    if !class.attributes.read().contains_key(attr_name) {
-                        let wrapper = PySlotWrapper {
-                            typ: class,
-                            name: ctx.intern_str(stringify!($name)),
-                            wrapped: SlotFunc::$variant(func),
-                            doc: Some($doc),
-                        };
-                        class.set_attr(attr_name, wrapper.into_ref(ctx).into());
-                    }
-                }
-            };
-        }
-
-        add_slot_wrapper!(
-            init,
-            __init__,
-            Init,
-            "Initialize self.  See help(type(self)) for accurate signature."
-        );
-        add_slot_wrapper!(repr, __repr__, Repr, "Return repr(self).");
-        add_slot_wrapper!(str, __str__, Str, "Return str(self).");
-        add_slot_wrapper!(iter, __iter__, Iter, "Implement iter(self).");
-        add_slot_wrapper!(iternext, __next__, IterNext, "Implement next(self).");
-
-        // __hash__ needs special handling: hash_not_implemented sets __hash__ = None
-        if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
-            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
-        } else {
-            add_slot_wrapper!(hash, __hash__, Hash, "Return hash(self).");
-        }
+        // Add slot wrappers using SLOT_DEFS array
+        add_operators(class, ctx);
 
         // Inherit slots from base types after slots are fully initialized
         for base in class.bases.read().iter() {
diff --git a/crates/vm/src/protocol/mod.rs b/crates/vm/src/protocol/mod.rs
index e7be286c265..6eb2909f167 100644
--- a/crates/vm/src/protocol/mod.rs
+++ b/crates/vm/src/protocol/mod.rs
@@ -12,6 +12,6 @@ pub use iter::{PyIter, PyIterIter, PyIterReturn};
 pub use mapping::{PyMapping, PyMappingMethods, PyMappingSlots};
 pub use number::{
     PyNumber, PyNumberBinaryFunc, PyNumberBinaryOp, PyNumberMethods, PyNumberSlots,
-    PyNumberTernaryOp, PyNumberUnaryFunc, handle_bytes_to_int_err,
+    PyNumberTernaryFunc, PyNumberTernaryOp, PyNumberUnaryFunc, handle_bytes_to_int_err,
 };
 pub use sequence::{PySequence, PySequenceMethods, PySequenceSlots};
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
index 4f21a1e64f9..c208bf26de8 100644
--- a/crates/vm/src/protocol/number.rs
+++ b/crates/vm/src/protocol/number.rs
@@ -256,6 +256,7 @@ pub struct PyNumberSlots {
     pub int: AtomicCell<Option<PyNumberUnaryFunc>>,
     pub float: AtomicCell<Option<PyNumberUnaryFunc>>,
 
+    // Right variants (internal - not exposed in SlotAccessor)
     pub right_add: AtomicCell<Option<PyNumberBinaryFunc>>,
     pub right_subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
     pub right_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
@@ -295,8 +296,7 @@ pub struct PyNumberSlots {
 
 impl From<&PyNumberMethods> for PyNumberSlots {
     fn from(value: &PyNumberMethods) -> Self {
-        // right_* functions will use the same left function as PyNumberMethods
-        // allows both f(self, other) and f(other, self)
+        // right_* slots use the same function as left ops for native types
         Self {
             add: AtomicCell::new(value.add),
             subtract: AtomicCell::new(value.subtract),
@@ -352,6 +352,115 @@ impl From<&PyNumberMethods> for PyNumberSlots {
 }
 
 impl PyNumberSlots {
+    /// Copy from static PyNumberMethods
+    pub fn copy_from(&self, methods: &PyNumberMethods) {
+        if let Some(f) = methods.add {
+            self.add.store(Some(f));
+        }
+        if let Some(f) = methods.subtract {
+            self.subtract.store(Some(f));
+        }
+        if let Some(f) = methods.multiply {
+            self.multiply.store(Some(f));
+        }
+        if let Some(f) = methods.remainder {
+            self.remainder.store(Some(f));
+        }
+        if let Some(f) = methods.divmod {
+            self.divmod.store(Some(f));
+        }
+        if let Some(f) = methods.power {
+            self.power.store(Some(f));
+        }
+        if let Some(f) = methods.negative {
+            self.negative.store(Some(f));
+        }
+        if let Some(f) = methods.positive {
+            self.positive.store(Some(f));
+        }
+        if let Some(f) = methods.absolute {
+            self.absolute.store(Some(f));
+        }
+        if let Some(f) = methods.boolean {
+            self.boolean.store(Some(f));
+        }
+        if let Some(f) = methods.invert {
+            self.invert.store(Some(f));
+        }
+        if let Some(f) = methods.lshift {
+            self.lshift.store(Some(f));
+        }
+        if let Some(f) = methods.rshift {
+            self.rshift.store(Some(f));
+        }
+        if let Some(f) = methods.and {
+            self.and.store(Some(f));
+        }
+        if let Some(f) = methods.xor {
+            self.xor.store(Some(f));
+        }
+        if let Some(f) = methods.or {
+            self.or.store(Some(f));
+        }
+        if let Some(f) = methods.int {
+            self.int.store(Some(f));
+        }
+        if let Some(f) = methods.float {
+            self.float.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_add {
+            self.inplace_add.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_subtract {
+            self.inplace_subtract.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_multiply {
+            self.inplace_multiply.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_remainder {
+            self.inplace_remainder.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_power {
+            self.inplace_power.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_lshift {
+            self.inplace_lshift.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_rshift {
+            self.inplace_rshift.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_and {
+            self.inplace_and.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_xor {
+            self.inplace_xor.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_or {
+            self.inplace_or.store(Some(f));
+        }
+        if let Some(f) = methods.floor_divide {
+            self.floor_divide.store(Some(f));
+        }
+        if let Some(f) = methods.true_divide {
+            self.true_divide.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_floor_divide {
+            self.inplace_floor_divide.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_true_divide {
+            self.inplace_true_divide.store(Some(f));
+        }
+        if let Some(f) = methods.index {
+            self.index.store(Some(f));
+        }
+        if let Some(f) = methods.matrix_multiply {
+            self.matrix_multiply.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_matrix_multiply {
+            self.inplace_matrix_multiply.store(Some(f));
+        }
+    }
+
     pub fn left_binary_op(&self, op_slot: PyNumberBinaryOp) -> Option<PyNumberBinaryFunc> {
         use PyNumberBinaryOp::*;
         match op_slot {
diff --git a/crates/vm/src/types/mod.rs b/crates/vm/src/types/mod.rs
index f19328cdd2d..b17a737545f 100644
--- a/crates/vm/src/types/mod.rs
+++ b/crates/vm/src/types/mod.rs
@@ -1,7 +1,9 @@
 mod slot;
+pub mod slot_defs;
 mod structseq;
 mod zoo;
 
 pub use slot::*;
+pub use slot_defs::{SLOT_DEFS, SlotAccessor, SlotDef};
 pub use structseq::{PyStructSequence, PyStructSequenceData, struct_sequence_new};
 pub(crate) use zoo::TypeZoo;
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 0d6b17ae99d..b7c20041d00 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -14,6 +14,7 @@ use crate::{
         PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyMappingSlots, PyNumber,
         PyNumberMethods, PyNumberSlots, PySequence, PySequenceMethods, PySequenceSlots,
     },
+    types::slot_defs::{SlotAccessor, find_slot_defs_by_name},
     vm::Context,
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -288,6 +289,21 @@ pub(crate) type NewFunc = fn(PyTypeRef, FuncArgs, &VirtualMachine) -> PyResult;
 pub(crate) type InitFunc = fn(PyObjectRef, FuncArgs, &VirtualMachine) -> PyResult<()>;
 pub(crate) type DelFunc = fn(&PyObject, &VirtualMachine) -> PyResult<()>;
 
+// Sequence sub-slot function types
+pub(crate) type SeqLenFunc = fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>;
+pub(crate) type SeqConcatFunc = fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult;
+pub(crate) type SeqRepeatFunc = fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult;
+pub(crate) type SeqItemFunc = fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult;
+pub(crate) type SeqAssItemFunc =
+    fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>;
+pub(crate) type SeqContainsFunc = fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>;
+
+// Mapping sub-slot function types
+pub(crate) type MapLenFunc = fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>;
+pub(crate) type MapSubscriptFunc = fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult;
+pub(crate) type MapAssSubscriptFunc =
+    fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>;
+
 // slot_sq_length
 pub(crate) fn len_wrapper(obj: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
     let ret = vm.call_special_method(obj, identifier!(vm, __len__), ())?;
@@ -331,6 +347,28 @@ macro_rules! number_binary_right_op_wrapper {
         |a, b, vm| vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(),))
     };
 }
+macro_rules! number_ternary_op_wrapper {
+    ($name:ident) => {
+        |a, b, c, vm: &VirtualMachine| {
+            if vm.is_none(c) {
+                vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(),))
+            } else {
+                vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(), c.to_owned()))
+            }
+        }
+    };
+}
+macro_rules! number_ternary_right_op_wrapper {
+    ($name:ident) => {
+        |a, b, c, vm: &VirtualMachine| {
+            if vm.is_none(c) {
+                vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(),))
+            } else {
+                vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(), c.to_owned()))
+            }
+        }
+    };
+}
 fn getitem_wrapper<K: ToPyObject>(obj: &PyObject, needle: K, vm: &VirtualMachine) -> PyResult {
     vm.call_special_method(obj, identifier!(vm, __getitem__), (needle,))
 }
@@ -507,453 +545,717 @@ fn del_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
 }
 
 impl PyType {
+    /// Update slots based on dunder method changes
+    ///
+    /// Iterates SLOT_DEFS to find all slots matching the given name and updates them.
     pub(crate) fn update_slot<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
         debug_assert!(name.as_str().starts_with("__"));
         debug_assert!(name.as_str().ends_with("__"));
 
-        macro_rules! toggle_slot {
-            ($name:ident, $func:expr) => {{
+        // Find all slot_defs matching this name and update each
+        for def in find_slot_defs_by_name(name.as_str()) {
+            self.update_one_slot::<ADD>(&def.accessor, name, ctx);
+        }
+    }
+
+    /// Update a single slot
+    fn update_one_slot<const ADD: bool>(
+        &self,
+        accessor: &SlotAccessor,
+        name: &'static PyStrInterned,
+        ctx: &Context,
+    ) {
+        use crate::builtins::descriptor::SlotFunc;
+
+        // Helper macro for main slots
+        macro_rules! update_main_slot {
+            ($slot:ident, $wrapper:expr, $variant:ident) => {{
                 if ADD {
-                    self.slots.$name.store(Some($func));
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::$variant(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.$slot.store(Some(func));
+                    } else {
+                        self.slots.$slot.store(Some($wrapper));
+                    }
                 } else {
-                    // When deleting, re-inherit from MRO (skip self)
-                    let inherited = self
-                        .mro
-                        .read()
-                        .iter()
-                        .skip(1)
-                        .find_map(|cls| cls.slots.$name.load());
-                    self.slots.$name.store(inherited);
+                    accessor.inherit_from_mro(self);
                 }
             }};
         }
 
-        macro_rules! toggle_sub_slot {
-            ($group:ident, $name:ident, $func:expr) => {{
+        // Helper macro for number/sequence/mapping sub-slots
+        macro_rules! update_sub_slot {
+            ($group:ident, $slot:ident, $wrapper:expr, $variant:ident) => {{
                 if ADD {
-                    self.slots.$group.$name.store(Some($func));
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::$variant(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.$group.$slot.store(Some(func));
+                    } else {
+                        self.slots.$group.$slot.store(Some($wrapper));
+                    }
                 } else {
-                    // When deleting, re-inherit from MRO (skip self)
-                    let inherited = self
-                        .mro
-                        .read()
-                        .iter()
-                        .skip(1)
-                        .find_map(|cls| cls.slots.$group.$name.load());
-                    self.slots.$group.$name.store(inherited);
+                    accessor.inherit_from_mro(self);
                 }
             }};
         }
 
-        macro_rules! update_slot {
-            ($name:ident, $func:expr) => {{
-                self.slots.$name.store(Some($func));
-            }};
-        }
-
-        match name {
-            _ if name == identifier!(ctx, __len__) => {
-                toggle_sub_slot!(as_sequence, length, |seq, vm| len_wrapper(seq.obj, vm));
-                toggle_sub_slot!(as_mapping, length, |mapping, vm| len_wrapper(
-                    mapping.obj,
-                    vm
-                ));
-            }
-            _ if name == identifier!(ctx, __getitem__) => {
-                toggle_sub_slot!(as_sequence, item, |seq, i, vm| getitem_wrapper(
-                    seq.obj, i, vm
-                ));
-                toggle_sub_slot!(as_mapping, subscript, |mapping, key, vm| {
-                    getitem_wrapper(mapping.obj, key, vm)
-                });
-            }
-            _ if name == identifier!(ctx, __setitem__) || name == identifier!(ctx, __delitem__) => {
-                toggle_sub_slot!(as_sequence, ass_item, |seq, i, value, vm| {
-                    setitem_wrapper(seq.obj, i, value, vm)
-                });
-                toggle_sub_slot!(as_mapping, ass_subscript, |mapping, key, value, vm| {
-                    setitem_wrapper(mapping.obj, key, value, vm)
-                });
-            }
-            _ if name == identifier!(ctx, __contains__) => {
-                toggle_sub_slot!(as_sequence, contains, |seq, needle, vm| {
-                    contains_wrapper(seq.obj, needle, vm)
-                });
-            }
-            _ if name == identifier!(ctx, __repr__) => {
-                update_slot!(repr, repr_wrapper);
-            }
-            _ if name == identifier!(ctx, __str__) => {
-                update_slot!(str, str_wrapper);
-            }
-            _ if name == identifier!(ctx, __hash__) => {
-                let is_unhashable = self
-                    .attributes
-                    .read()
-                    .get(identifier!(ctx, __hash__))
-                    .is_some_and(|a| a.is(&ctx.none));
-                let wrapper = if is_unhashable {
-                    hash_not_implemented
+        match accessor {
+            // === Main slots ===
+            SlotAccessor::TpRepr => update_main_slot!(repr, repr_wrapper, Repr),
+            SlotAccessor::TpStr => update_main_slot!(str, str_wrapper, Str),
+            SlotAccessor::TpHash => {
+                // Special handling for __hash__ = None
+                if ADD {
+                    let method = self.attributes.read().get(name).cloned().or_else(|| {
+                        self.mro
+                            .read()
+                            .iter()
+                            .find_map(|cls| cls.attributes.read().get(name).cloned())
+                    });
+
+                    if method.as_ref().is_some_and(|m| m.is(&ctx.none)) {
+                        self.slots.hash.store(Some(hash_not_implemented));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::Hash(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.hash.store(Some(func));
+                    } else {
+                        self.slots.hash.store(Some(hash_wrapper));
+                    }
                 } else {
-                    hash_wrapper
-                };
-                toggle_slot!(hash, wrapper);
-            }
-            _ if name == identifier!(ctx, __call__) => {
-                toggle_slot!(call, call_wrapper);
-            }
-            _ if name == identifier!(ctx, __getattr__)
-                || name == identifier!(ctx, __getattribute__) =>
-            {
-                update_slot!(getattro, getattro_wrapper);
-            }
-            _ if name == identifier!(ctx, __setattr__) || name == identifier!(ctx, __delattr__) => {
-                update_slot!(setattro, setattro_wrapper);
-            }
-            _ if name == identifier!(ctx, __eq__)
-                || name == identifier!(ctx, __ne__)
-                || name == identifier!(ctx, __le__)
-                || name == identifier!(ctx, __lt__)
-                || name == identifier!(ctx, __ge__)
-                || name == identifier!(ctx, __gt__) =>
-            {
-                update_slot!(richcompare, richcompare_wrapper);
-            }
-            _ if name == identifier!(ctx, __iter__) => {
-                toggle_slot!(iter, iter_wrapper);
-            }
-            _ if name == identifier!(ctx, __next__) => {
-                toggle_slot!(iternext, iternext_wrapper);
-            }
-            _ if name == identifier!(ctx, __get__) => {
-                toggle_slot!(descr_get, descr_get_wrapper);
+                    accessor.inherit_from_mro(self);
+                }
             }
-            _ if name == identifier!(ctx, __set__) || name == identifier!(ctx, __delete__) => {
-                update_slot!(descr_set, descr_set_wrapper);
+            SlotAccessor::TpCall => update_main_slot!(call, call_wrapper, Call),
+            SlotAccessor::TpIter => update_main_slot!(iter, iter_wrapper, Iter),
+            SlotAccessor::TpIternext => update_main_slot!(iternext, iternext_wrapper, IterNext),
+            SlotAccessor::TpInit => update_main_slot!(init, init_wrapper, Init),
+            SlotAccessor::TpNew => {
+                // __new__ is not wrapped via PyWrapper
+                if ADD {
+                    self.slots.new.store(Some(new_wrapper));
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
             }
-            _ if name == identifier!(ctx, __init__) => {
-                // Special handling: check if this type or any base has a real __init__ method
-                // If only slot wrappers exist, use the inherited slot from copyslot!
+            SlotAccessor::TpDel => update_main_slot!(del, del_wrapper, Del),
+            SlotAccessor::TpGetattro => update_main_slot!(getattro, getattro_wrapper, GetAttro),
+            SlotAccessor::TpSetattro => {
+                // __setattr__ and __delattr__ share the same slot
                 if ADD {
-                    // First check if this type has __init__ in its own dict
-                    let has_own_init = self.attributes.read().contains_key(name);
-                    if has_own_init {
-                        // This type defines __init__ - use wrapper
-                        self.slots.init.store(Some(init_wrapper));
-                    } else if self.has_real_method_in_mro(name, ctx) {
-                        // A base class defines a real __init__ method - use wrapper
-                        self.slots.init.store(Some(init_wrapper));
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::SetAttro(f) | SlotFunc::DelAttro(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.setattro.store(Some(func));
+                    } else {
+                        self.slots.setattro.store(Some(setattro_wrapper));
                     }
-                    // else: keep inherited slot from copyslot!
                 } else {
-                    let inherited = self
-                        .mro
-                        .read()
-                        .iter()
-                        .skip(1)
-                        .find_map(|cls| cls.slots.init.load());
-                    self.slots.init.store(inherited);
+                    accessor.inherit_from_mro(self);
                 }
             }
-            _ if name == identifier!(ctx, __new__) => {
-                toggle_slot!(new, new_wrapper);
-            }
-            _ if name == identifier!(ctx, __del__) => {
-                // Same special handling as __init__
+            SlotAccessor::TpDescrGet => update_main_slot!(descr_get, descr_get_wrapper, DescrGet),
+            SlotAccessor::TpDescrSet => {
+                // __set__ and __delete__ share the same slot
                 if ADD {
-                    let has_own_del = self.attributes.read().contains_key(name);
-                    if has_own_del || self.has_real_method_in_mro(name, ctx) {
-                        self.slots.del.store(Some(del_wrapper));
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::DescrSet(f) | SlotFunc::DescrDel(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.descr_set.store(Some(func));
+                    } else {
+                        self.slots.descr_set.store(Some(descr_set_wrapper));
                     }
                 } else {
-                    let inherited = self
-                        .mro
-                        .read()
-                        .iter()
-                        .skip(1)
-                        .find_map(|cls| cls.slots.del.load());
-                    self.slots.del.store(inherited);
+                    accessor.inherit_from_mro(self);
                 }
             }
-            _ if name == identifier!(ctx, __bool__) => {
-                toggle_sub_slot!(as_number, boolean, bool_wrapper);
-            }
-            _ if name == identifier!(ctx, __int__) => {
-                toggle_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__));
-            }
-            _ if name == identifier!(ctx, __index__) => {
-                toggle_sub_slot!(as_number, index, number_unary_op_wrapper!(__index__));
-            }
-            _ if name == identifier!(ctx, __float__) => {
-                toggle_sub_slot!(as_number, float, number_unary_op_wrapper!(__float__));
-            }
-            _ if name == identifier!(ctx, __add__) => {
-                toggle_sub_slot!(as_number, add, number_binary_op_wrapper!(__add__));
-            }
-            _ if name == identifier!(ctx, __radd__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_add,
-                    number_binary_right_op_wrapper!(__radd__)
-                );
-            }
-            _ if name == identifier!(ctx, __iadd__) => {
-                toggle_sub_slot!(as_number, inplace_add, number_binary_op_wrapper!(__iadd__));
+
+            // === Rich compare (__lt__, __le__, __eq__, __ne__, __gt__, __ge__) ===
+            SlotAccessor::TpRichcompare => {
+                if ADD {
+                    // Check if self or any class in MRO has a Python-defined comparison method
+                    // All comparison ops share the same slot, so if any is overridden anywhere
+                    // in the hierarchy with a Python function, we need to use the wrapper
+                    let cmp_names = [
+                        identifier!(ctx, __eq__),
+                        identifier!(ctx, __ne__),
+                        identifier!(ctx, __lt__),
+                        identifier!(ctx, __le__),
+                        identifier!(ctx, __gt__),
+                        identifier!(ctx, __ge__),
+                    ];
+
+                    let has_python_cmp = {
+                        // Check self first
+                        let attrs = self.attributes.read();
+                        let in_self = cmp_names.iter().any(|n| attrs.contains_key(*n));
+                        drop(attrs);
+
+                        in_self
+                            || self.mro.read().iter().any(|cls| {
+                                let attrs = cls.attributes.read();
+                                cmp_names.iter().any(|n| {
+                                    if let Some(attr) = attrs.get(*n) {
+                                        // Check if it's a Python function (not wrapper_descriptor)
+                                        !attr.class().is(ctx.types.wrapper_descriptor_type)
+                                    } else {
+                                        false
+                                    }
+                                })
+                            })
+                    };
+
+                    if has_python_cmp {
+                        // Use wrapper to call the Python method
+                        self.slots.richcompare.store(Some(richcompare_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::RichCompare(f, _) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.richcompare.store(Some(func));
+                    } else {
+                        self.slots.richcompare.store(Some(richcompare_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
             }
-            _ if name == identifier!(ctx, __sub__) => {
-                toggle_sub_slot!(as_number, subtract, number_binary_op_wrapper!(__sub__));
+
+            // === Number binary operations ===
+            SlotAccessor::NbAdd => {
+                if name.as_str() == "__radd__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_add,
+                        number_binary_right_op_wrapper!(__radd__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        add,
+                        number_binary_op_wrapper!(__add__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rsub__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceAdd => {
+                update_sub_slot!(
                     as_number,
-                    right_subtract,
-                    number_binary_right_op_wrapper!(__rsub__)
-                );
+                    inplace_add,
+                    number_binary_op_wrapper!(__iadd__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbSubtract => {
+                if name.as_str() == "__rsub__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_subtract,
+                        number_binary_right_op_wrapper!(__rsub__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        subtract,
+                        number_binary_op_wrapper!(__sub__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __isub__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceSubtract => {
+                update_sub_slot!(
                     as_number,
                     inplace_subtract,
-                    number_binary_op_wrapper!(__isub__)
-                );
-            }
-            _ if name == identifier!(ctx, __mul__) => {
-                toggle_sub_slot!(as_number, multiply, number_binary_op_wrapper!(__mul__));
-            }
-            _ if name == identifier!(ctx, __rmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_multiply,
-                    number_binary_right_op_wrapper!(__rmul__)
-                );
+                    number_binary_op_wrapper!(__isub__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbMultiply => {
+                if name.as_str() == "__rmul__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_multiply,
+                        number_binary_right_op_wrapper!(__rmul__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        multiply,
+                        number_binary_op_wrapper!(__mul__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __imul__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceMultiply => {
+                update_sub_slot!(
                     as_number,
                     inplace_multiply,
-                    number_binary_op_wrapper!(__imul__)
-                );
-            }
-            _ if name == identifier!(ctx, __mod__) => {
-                toggle_sub_slot!(as_number, remainder, number_binary_op_wrapper!(__mod__));
-            }
-            _ if name == identifier!(ctx, __rmod__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_remainder,
-                    number_binary_right_op_wrapper!(__rmod__)
-                );
+                    number_binary_op_wrapper!(__imul__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbRemainder => {
+                if name.as_str() == "__rmod__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_remainder,
+                        number_binary_right_op_wrapper!(__rmod__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        remainder,
+                        number_binary_op_wrapper!(__mod__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __imod__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceRemainder => {
+                update_sub_slot!(
                     as_number,
                     inplace_remainder,
-                    number_binary_op_wrapper!(__imod__)
-                );
+                    number_binary_op_wrapper!(__imod__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbDivmod => {
+                if name.as_str() == "__rdivmod__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_divmod,
+                        number_binary_right_op_wrapper!(__rdivmod__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        divmod,
+                        number_binary_op_wrapper!(__divmod__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __divmod__) => {
-                toggle_sub_slot!(as_number, divmod, number_binary_op_wrapper!(__divmod__));
+            SlotAccessor::NbPower => {
+                if name.as_str() == "__rpow__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_power,
+                        number_ternary_right_op_wrapper!(__rpow__),
+                        NumTernary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        power,
+                        number_ternary_op_wrapper!(__pow__),
+                        NumTernary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rdivmod__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplacePower => {
+                update_sub_slot!(
                     as_number,
-                    right_divmod,
-                    number_binary_right_op_wrapper!(__rdivmod__)
-                );
-            }
-            _ if name == identifier!(ctx, __pow__) => {
-                toggle_sub_slot!(as_number, power, |a, b, c, vm| {
-                    let args = if vm.is_none(c) {
-                        vec![b.to_owned()]
-                    } else {
-                        vec![b.to_owned(), c.to_owned()]
-                    };
-                    vm.call_special_method(a, identifier!(vm, __pow__), args)
-                });
-            }
-            _ if name == identifier!(ctx, __rpow__) => {
-                toggle_sub_slot!(as_number, right_power, |a, b, c, vm| {
-                    let args = if vm.is_none(c) {
-                        vec![a.to_owned()]
-                    } else {
-                        vec![a.to_owned(), c.to_owned()]
-                    };
-                    vm.call_special_method(b, identifier!(vm, __rpow__), args)
-                });
-            }
-            _ if name == identifier!(ctx, __ipow__) => {
-                toggle_sub_slot!(as_number, inplace_power, |a, b, _, vm| {
-                    vm.call_special_method(a, identifier!(vm, __ipow__), (b.to_owned(),))
-                });
-            }
-            _ if name == identifier!(ctx, __lshift__) => {
-                toggle_sub_slot!(as_number, lshift, number_binary_op_wrapper!(__lshift__));
+                    inplace_power,
+                    number_ternary_op_wrapper!(__ipow__),
+                    NumTernary
+                )
+            }
+            SlotAccessor::NbFloorDivide => {
+                if name.as_str() == "__rfloordiv__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_floor_divide,
+                        number_binary_right_op_wrapper!(__rfloordiv__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        floor_divide,
+                        number_binary_op_wrapper!(__floordiv__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rlshift__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceFloorDivide => {
+                update_sub_slot!(
                     as_number,
-                    right_lshift,
-                    number_binary_right_op_wrapper!(__rlshift__)
-                );
+                    inplace_floor_divide,
+                    number_binary_op_wrapper!(__ifloordiv__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbTrueDivide => {
+                if name.as_str() == "__rtruediv__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_true_divide,
+                        number_binary_right_op_wrapper!(__rtruediv__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        true_divide,
+                        number_binary_op_wrapper!(__truediv__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __ilshift__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceTrueDivide => {
+                update_sub_slot!(
                     as_number,
-                    inplace_lshift,
-                    number_binary_op_wrapper!(__ilshift__)
-                );
+                    inplace_true_divide,
+                    number_binary_op_wrapper!(__itruediv__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbMatrixMultiply => {
+                if name.as_str() == "__rmatmul__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_matrix_multiply,
+                        number_binary_right_op_wrapper!(__rmatmul__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        matrix_multiply,
+                        number_binary_op_wrapper!(__matmul__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rshift__) => {
-                toggle_sub_slot!(as_number, rshift, number_binary_op_wrapper!(__rshift__));
+            SlotAccessor::NbInplaceMatrixMultiply => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_matrix_multiply,
+                    number_binary_op_wrapper!(__imatmul__),
+                    NumBinary
+                )
+            }
+
+            // === Number bitwise operations ===
+            SlotAccessor::NbLshift => {
+                if name.as_str() == "__rlshift__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_lshift,
+                        number_binary_right_op_wrapper!(__rlshift__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        lshift,
+                        number_binary_op_wrapper!(__lshift__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rrshift__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceLshift => {
+                update_sub_slot!(
                     as_number,
-                    right_rshift,
-                    number_binary_right_op_wrapper!(__rrshift__)
-                );
+                    inplace_lshift,
+                    number_binary_op_wrapper!(__ilshift__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbRshift => {
+                if name.as_str() == "__rrshift__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_rshift,
+                        number_binary_right_op_wrapper!(__rrshift__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        rshift,
+                        number_binary_op_wrapper!(__rshift__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __irshift__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceRshift => {
+                update_sub_slot!(
                     as_number,
                     inplace_rshift,
-                    number_binary_op_wrapper!(__irshift__)
-                );
-            }
-            _ if name == identifier!(ctx, __and__) => {
-                toggle_sub_slot!(as_number, and, number_binary_op_wrapper!(__and__));
+                    number_binary_op_wrapper!(__irshift__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbAnd => {
+                if name.as_str() == "__rand__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_and,
+                        number_binary_right_op_wrapper!(__rand__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        and,
+                        number_binary_op_wrapper!(__and__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rand__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceAnd => {
+                update_sub_slot!(
                     as_number,
-                    right_and,
-                    number_binary_right_op_wrapper!(__rand__)
-                );
-            }
-            _ if name == identifier!(ctx, __iand__) => {
-                toggle_sub_slot!(as_number, inplace_and, number_binary_op_wrapper!(__iand__));
-            }
-            _ if name == identifier!(ctx, __xor__) => {
-                toggle_sub_slot!(as_number, xor, number_binary_op_wrapper!(__xor__));
+                    inplace_and,
+                    number_binary_op_wrapper!(__iand__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbXor => {
+                if name.as_str() == "__rxor__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_xor,
+                        number_binary_right_op_wrapper!(__rxor__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        xor,
+                        number_binary_op_wrapper!(__xor__),
+                        NumBinary
+                    )
+                }
             }
-            _ if name == identifier!(ctx, __rxor__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceXor => {
+                update_sub_slot!(
                     as_number,
-                    right_xor,
-                    number_binary_right_op_wrapper!(__rxor__)
-                );
-            }
-            _ if name == identifier!(ctx, __ixor__) => {
-                toggle_sub_slot!(as_number, inplace_xor, number_binary_op_wrapper!(__ixor__));
-            }
-            _ if name == identifier!(ctx, __or__) => {
-                toggle_sub_slot!(as_number, or, number_binary_op_wrapper!(__or__));
+                    inplace_xor,
+                    number_binary_op_wrapper!(__ixor__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbOr => {
+                if name.as_str() == "__ror__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_or,
+                        number_binary_right_op_wrapper!(__ror__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(as_number, or, number_binary_op_wrapper!(__or__), NumBinary)
+                }
             }
-            _ if name == identifier!(ctx, __ror__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInplaceOr => {
+                update_sub_slot!(
                     as_number,
-                    right_or,
-                    number_binary_right_op_wrapper!(__ror__)
-                );
-            }
-            _ if name == identifier!(ctx, __ior__) => {
-                toggle_sub_slot!(as_number, inplace_or, number_binary_op_wrapper!(__ior__));
+                    inplace_or,
+                    number_binary_op_wrapper!(__ior__),
+                    NumBinary
+                )
             }
-            _ if name == identifier!(ctx, __floordiv__) => {
-                toggle_sub_slot!(
+
+            // === Number unary operations ===
+            SlotAccessor::NbNegative => {
+                update_sub_slot!(
                     as_number,
-                    floor_divide,
-                    number_binary_op_wrapper!(__floordiv__)
-                );
+                    negative,
+                    number_unary_op_wrapper!(__neg__),
+                    NumUnary
+                )
             }
-            _ if name == identifier!(ctx, __rfloordiv__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbPositive => {
+                update_sub_slot!(
                     as_number,
-                    right_floor_divide,
-                    number_binary_right_op_wrapper!(__rfloordiv__)
-                );
+                    positive,
+                    number_unary_op_wrapper!(__pos__),
+                    NumUnary
+                )
             }
-            _ if name == identifier!(ctx, __ifloordiv__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbAbsolute => {
+                update_sub_slot!(
                     as_number,
-                    inplace_floor_divide,
-                    number_binary_op_wrapper!(__ifloordiv__)
-                );
+                    absolute,
+                    number_unary_op_wrapper!(__abs__),
+                    NumUnary
+                )
             }
-            _ if name == identifier!(ctx, __truediv__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbInvert => {
+                update_sub_slot!(
                     as_number,
-                    true_divide,
-                    number_binary_op_wrapper!(__truediv__)
-                );
+                    invert,
+                    number_unary_op_wrapper!(__invert__),
+                    NumUnary
+                )
             }
-            _ if name == identifier!(ctx, __rtruediv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_true_divide,
-                    number_binary_right_op_wrapper!(__rtruediv__)
-                );
+            SlotAccessor::NbBool => {
+                update_sub_slot!(as_number, boolean, bool_wrapper, NumBoolean)
             }
-            _ if name == identifier!(ctx, __itruediv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_true_divide,
-                    number_binary_op_wrapper!(__itruediv__)
-                );
+            SlotAccessor::NbInt => {
+                update_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__), NumUnary)
             }
-            _ if name == identifier!(ctx, __matmul__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbFloat => {
+                update_sub_slot!(
                     as_number,
-                    matrix_multiply,
-                    number_binary_op_wrapper!(__matmul__)
-                );
+                    float,
+                    number_unary_op_wrapper!(__float__),
+                    NumUnary
+                )
             }
-            _ if name == identifier!(ctx, __rmatmul__) => {
-                toggle_sub_slot!(
+            SlotAccessor::NbIndex => {
+                update_sub_slot!(
                     as_number,
-                    right_matrix_multiply,
-                    number_binary_right_op_wrapper!(__rmatmul__)
-                );
+                    index,
+                    number_unary_op_wrapper!(__index__),
+                    NumUnary
+                )
+            }
+
+            // === Sequence slots ===
+            SlotAccessor::SqLength => {
+                update_sub_slot!(
+                    as_sequence,
+                    length,
+                    |seq, vm| len_wrapper(seq.obj, vm),
+                    SeqLength
+                )
+            }
+            SlotAccessor::SqConcat | SlotAccessor::SqInplaceConcat => {
+                // Sequence concat uses sq_concat slot - no generic wrapper needed
+                // (handled by number protocol fallback)
+                if !ADD {
+                    accessor.inherit_from_mro(self);
+                }
             }
-            _ if name == identifier!(ctx, __imatmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_matrix_multiply,
-                    number_binary_op_wrapper!(__imatmul__)
-                );
+            SlotAccessor::SqRepeat | SlotAccessor::SqInplaceRepeat => {
+                // Sequence repeat uses sq_repeat slot - no generic wrapper needed
+                // (handled by number protocol fallback)
+                if !ADD {
+                    accessor.inherit_from_mro(self);
+                }
             }
+            SlotAccessor::SqItem => {
+                update_sub_slot!(
+                    as_sequence,
+                    item,
+                    |seq, i, vm| getitem_wrapper(seq.obj, i, vm),
+                    SeqItem
+                )
+            }
+            SlotAccessor::SqAssItem => {
+                update_sub_slot!(
+                    as_sequence,
+                    ass_item,
+                    |seq, i, value, vm| setitem_wrapper(seq.obj, i, value, vm),
+                    SeqAssItem
+                )
+            }
+            SlotAccessor::SqContains => {
+                update_sub_slot!(
+                    as_sequence,
+                    contains,
+                    |seq, needle, vm| contains_wrapper(seq.obj, needle, vm),
+                    SeqContains
+                )
+            }
+
+            // === Mapping slots ===
+            SlotAccessor::MpLength => {
+                update_sub_slot!(
+                    as_mapping,
+                    length,
+                    |mapping, vm| len_wrapper(mapping.obj, vm),
+                    MapLength
+                )
+            }
+            SlotAccessor::MpSubscript => {
+                update_sub_slot!(
+                    as_mapping,
+                    subscript,
+                    |mapping, key, vm| getitem_wrapper(mapping.obj, key, vm),
+                    MapSubscript
+                )
+            }
+            SlotAccessor::MpAssSubscript => {
+                update_sub_slot!(
+                    as_mapping,
+                    ass_subscript,
+                    |mapping, key, value, vm| setitem_wrapper(mapping.obj, key, value, vm),
+                    MapAssSubscript
+                )
+            }
+
+            // Reserved slots - no-op
             _ => {}
         }
     }
 
-    /// Check if there's a real method (not a slot wrapper) for `name` anywhere in the MRO.
-    /// If a real method exists, we should use a wrapper function. Otherwise, use the inherited slot.
-    fn has_real_method_in_mro(&self, name: &'static PyStrInterned, ctx: &Context) -> bool {
-        use crate::builtins::descriptor::PySlotWrapper;
+    /// Look up a method in MRO and extract the slot function if it's a slot wrapper.
+    /// Returns Some(slot_func) if a matching slot wrapper is found, None if a real method
+    /// is found or no method exists.
+    fn lookup_slot_in_mro<T: Copy>(
+        &self,
+        name: &'static PyStrInterned,
+        ctx: &Context,
+        extract: impl Fn(&crate::builtins::descriptor::SlotFunc) -> Option<T>,
+    ) -> Option<T> {
+        use crate::builtins::descriptor::PyWrapper;
+
+        // Helper to extract slot from an attribute if it's a wrapper descriptor
+        let try_extract = |attr: &PyObjectRef| -> Option<T> {
+            if attr.class().is(ctx.types.wrapper_descriptor_type) {
+                attr.downcast_ref::<PyWrapper>()
+                    .and_then(|wrapper| extract(&wrapper.wrapped))
+            } else {
+                None
+            }
+        };
 
-        // Check the entire MRO (including self) for the method
+        // Look up in self's dict first
+        if let Some(attr) = self.attributes.read().get(name).cloned() {
+            if let Some(func) = try_extract(&attr) {
+                return Some(func);
+            }
+            return None;
+        }
+
+        // Look up in MRO
         for cls in self.mro.read().iter() {
             if let Some(attr) = cls.attributes.read().get(name).cloned() {
-                // Found the method - check if it's a slot wrapper
-                if attr.class().is(ctx.types.wrapper_descriptor_type) {
-                    if let Some(wrapper) = attr.downcast_ref::<PySlotWrapper>() {
-                        // It's a slot wrapper - check if it belongs to this class
-                        let wrapper_typ: *const _ = wrapper.typ;
-                        let cls_ptr: *const _ = cls.as_ref();
-                        if wrapper_typ == cls_ptr {
-                            // Slot wrapper defined on this exact class - use inherited slot
-                            return false;
-                        }
-                    }
-                    // Inherited slot wrapper - continue checking MRO
-                } else {
-                    // Real method found - use wrapper function
-                    return true;
+                if let Some(func) = try_extract(&attr) {
+                    return Some(func);
                 }
+                return None;
             }
         }
-        // No real method found in MRO - use inherited slot
-        false
+        // No method found in MRO
+        None
     }
 }
 
@@ -1233,60 +1535,8 @@ pub trait Comparable: PyPayload {
         vm: &VirtualMachine,
     ) -> PyResult<PyComparisonValue>;
 
-    #[inline]
-    #[pymethod]
-    fn __eq__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Eq, vm)
-    }
-    #[inline]
-    #[pymethod]
-    fn __ne__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Ne, vm)
-    }
-    #[inline]
-    #[pymethod]
-    fn __lt__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Lt, vm)
-    }
-    #[inline]
-    #[pymethod]
-    fn __le__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Le, vm)
-    }
-    #[inline]
-    #[pymethod]
-    fn __ge__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Ge, vm)
-    }
-    #[inline]
-    #[pymethod]
-    fn __gt__(
-        zelf: &Py<Self>,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(zelf, &other, PyComparisonOp::Gt, vm)
-    }
+    // Comparison methods are exposed as wrapper_descriptor via slot_richcompare
+    // No #[pymethod] - add_operators creates wrapper from SLOT_DEFS
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -1495,6 +1745,10 @@ pub trait AsNumber: PyPayload {
     #[pyslot]
     fn as_number() -> &'static PyNumberMethods;
 
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_number.copy_from(Self::as_number());
+    }
+
     fn clone_exact(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
         // not all AsNumber requires this implementation.
         unimplemented!()
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
new file mode 100644
index 00000000000..0d8dbf4b0cc
--- /dev/null
+++ b/crates/vm/src/types/slot_defs.rs
@@ -0,0 +1,1465 @@
+//! Slot definitions array
+//!
+//! This module provides a centralized array of all slot definitions,
+
+use super::{PyComparisonOp, PyTypeSlots};
+use crate::builtins::descriptor::SlotFunc;
+
+/// Slot operation type
+///
+/// Used to distinguish between different operations that share the same slot:
+/// - RichCompare: Lt, Le, Eq, Ne, Gt, Ge
+/// - Binary ops: Left (__add__) vs Right (__radd__)
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SlotOp {
+    // RichCompare operations
+    Lt,
+    Le,
+    Eq,
+    Ne,
+    Gt,
+    Ge,
+    // Binary operation direction
+    Left,
+    Right,
+    // Setter vs Deleter
+    Delete,
+}
+
+impl SlotOp {
+    /// Convert to PyComparisonOp if this is a comparison operation
+    pub fn as_compare_op(&self) -> Option<PyComparisonOp> {
+        match self {
+            Self::Lt => Some(PyComparisonOp::Lt),
+            Self::Le => Some(PyComparisonOp::Le),
+            Self::Eq => Some(PyComparisonOp::Eq),
+            Self::Ne => Some(PyComparisonOp::Ne),
+            Self::Gt => Some(PyComparisonOp::Gt),
+            Self::Ge => Some(PyComparisonOp::Ge),
+            _ => None,
+        }
+    }
+
+    /// Check if this is a right operation (__radd__, __rsub__, etc.)
+    pub fn is_right(&self) -> bool {
+        matches!(self, Self::Right)
+    }
+}
+
+/// Slot definition entry
+#[derive(Clone, Copy)]
+pub struct SlotDef {
+    /// Method name ("__init__", "__add__", etc.)
+    pub name: &'static str,
+
+    /// Slot accessor (which slot field to access)
+    pub accessor: SlotAccessor,
+
+    /// Operation type (for shared slots like RichCompare, binary ops)
+    pub op: Option<SlotOp>,
+
+    /// Documentation string
+    pub doc: &'static str,
+}
+
+/// Slot accessor
+///
+/// Values match CPython's Py_* slot IDs from typeslots.h.
+/// Unused slots are included for value reservation.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum SlotAccessor {
+    // Buffer protocol (1-2) - Reserved, not used in RustPython
+    BfGetBuffer = 1,
+    BfReleaseBuffer = 2,
+
+    // Mapping protocol (3-5)
+    MpAssSubscript = 3,
+    MpLength = 4,
+    MpSubscript = 5,
+
+    // Number protocol (6-38)
+    NbAbsolute = 6,
+    NbAdd = 7,
+    NbAnd = 8,
+    NbBool = 9,
+    NbDivmod = 10,
+    NbFloat = 11,
+    NbFloorDivide = 12,
+    NbIndex = 13,
+    NbInplaceAdd = 14,
+    NbInplaceAnd = 15,
+    NbInplaceFloorDivide = 16,
+    NbInplaceLshift = 17,
+    NbInplaceMultiply = 18,
+    NbInplaceOr = 19,
+    NbInplacePower = 20,
+    NbInplaceRemainder = 21,
+    NbInplaceRshift = 22,
+    NbInplaceSubtract = 23,
+    NbInplaceTrueDivide = 24,
+    NbInplaceXor = 25,
+    NbInt = 26,
+    NbInvert = 27,
+    NbLshift = 28,
+    NbMultiply = 29,
+    NbNegative = 30,
+    NbOr = 31,
+    NbPositive = 32,
+    NbPower = 33,
+    NbRemainder = 34,
+    NbRshift = 35,
+    NbSubtract = 36,
+    NbTrueDivide = 37,
+    NbXor = 38,
+
+    // Sequence protocol (39-46)
+    SqAssItem = 39,
+    SqConcat = 40,
+    SqContains = 41,
+    SqInplaceConcat = 42,
+    SqInplaceRepeat = 43,
+    SqItem = 44,
+    SqLength = 45,
+    SqRepeat = 46,
+
+    // Type slots (47-74)
+    TpAlloc = 47, // Reserved
+    TpBase = 48,  // Reserved
+    TpBases = 49, // Reserved
+    TpCall = 50,
+    TpClear = 51,   // Reserved
+    TpDealloc = 52, // Reserved
+    TpDel = 53,
+    TpDescrGet = 54,
+    TpDescrSet = 55,
+    TpDoc = 56,     // Reserved
+    TpGetattr = 57, // Reserved (use TpGetattro)
+    TpGetattro = 58,
+    TpHash = 59,
+    TpInit = 60,
+    TpIsGc = 61, // Reserved
+    TpIter = 62,
+    TpIternext = 63,
+    TpMethods = 64, // Reserved
+    TpNew = 65,
+    TpRepr = 66,
+    TpRichcompare = 67,
+    TpSetattr = 68, // Reserved (use TpSetattro)
+    TpSetattro = 69,
+    TpStr = 70,
+    TpTraverse = 71, // Reserved
+    TpMembers = 72,  // Reserved
+    TpGetset = 73,   // Reserved
+    TpFree = 74,     // Reserved
+
+    // Number protocol additions (75-76)
+    NbMatrixMultiply = 75,
+    NbInplaceMatrixMultiply = 76,
+
+    // Async protocol (77-81) - Reserved for future
+    AmAwait = 77,
+    AmAiter = 78,
+    AmAnext = 79,
+    TpFinalize = 80,
+    AmSend = 81,
+}
+
+impl SlotAccessor {
+    /// Check if this accessor is for a reserved/unused slot
+    pub fn is_reserved(&self) -> bool {
+        matches!(
+            self,
+            Self::BfGetBuffer
+                | Self::BfReleaseBuffer
+                | Self::TpAlloc
+                | Self::TpBase
+                | Self::TpBases
+                | Self::TpClear
+                | Self::TpDealloc
+                | Self::TpDoc
+                | Self::TpGetattr
+                | Self::TpIsGc
+                | Self::TpMethods
+                | Self::TpSetattr
+                | Self::TpTraverse
+                | Self::TpMembers
+                | Self::TpGetset
+                | Self::TpFree
+                | Self::TpFinalize
+                | Self::AmAwait
+                | Self::AmAiter
+                | Self::AmAnext
+                | Self::AmSend
+        )
+    }
+
+    /// Check if this is a number binary operation slot
+    pub fn is_number_binary(&self) -> bool {
+        matches!(
+            self,
+            Self::NbAdd
+                | Self::NbSubtract
+                | Self::NbMultiply
+                | Self::NbRemainder
+                | Self::NbDivmod
+                | Self::NbPower
+                | Self::NbLshift
+                | Self::NbRshift
+                | Self::NbAnd
+                | Self::NbXor
+                | Self::NbOr
+                | Self::NbFloorDivide
+                | Self::NbTrueDivide
+                | Self::NbMatrixMultiply
+        )
+    }
+
+    /// Check if this accessor refers to a shared slot
+    ///
+    /// Shared slots are used by multiple dunder methods:
+    /// - TpSetattro: __setattr__ and __delattr__
+    /// - TpRichcompare: __lt__, __le__, __eq__, __ne__, __gt__, __ge__
+    /// - TpDescrSet: __set__ and __delete__
+    /// - SqAssItem/MpAssSubscript: __setitem__ and __delitem__
+    /// - Number binaries: __add__ and __radd__, etc.
+    pub fn is_shared_slot(&self) -> bool {
+        matches!(
+            self,
+            Self::TpSetattro
+                | Self::TpRichcompare
+                | Self::TpDescrSet
+                | Self::SqAssItem
+                | Self::MpAssSubscript
+        ) || self.is_number_binary()
+    }
+
+    /// Get underlying slot field name for debugging
+    pub fn slot_name(&self) -> &'static str {
+        match self {
+            Self::BfGetBuffer => "bf_getbuffer",
+            Self::BfReleaseBuffer => "bf_releasebuffer",
+            Self::MpAssSubscript => "mp_ass_subscript",
+            Self::MpLength => "mp_length",
+            Self::MpSubscript => "mp_subscript",
+            Self::NbAbsolute => "nb_absolute",
+            Self::NbAdd => "nb_add",
+            Self::NbAnd => "nb_and",
+            Self::NbBool => "nb_bool",
+            Self::NbDivmod => "nb_divmod",
+            Self::NbFloat => "nb_float",
+            Self::NbFloorDivide => "nb_floor_divide",
+            Self::NbIndex => "nb_index",
+            Self::NbInplaceAdd => "nb_inplace_add",
+            Self::NbInplaceAnd => "nb_inplace_and",
+            Self::NbInplaceFloorDivide => "nb_inplace_floor_divide",
+            Self::NbInplaceLshift => "nb_inplace_lshift",
+            Self::NbInplaceMultiply => "nb_inplace_multiply",
+            Self::NbInplaceOr => "nb_inplace_or",
+            Self::NbInplacePower => "nb_inplace_power",
+            Self::NbInplaceRemainder => "nb_inplace_remainder",
+            Self::NbInplaceRshift => "nb_inplace_rshift",
+            Self::NbInplaceSubtract => "nb_inplace_subtract",
+            Self::NbInplaceTrueDivide => "nb_inplace_true_divide",
+            Self::NbInplaceXor => "nb_inplace_xor",
+            Self::NbInt => "nb_int",
+            Self::NbInvert => "nb_invert",
+            Self::NbLshift => "nb_lshift",
+            Self::NbMultiply => "nb_multiply",
+            Self::NbNegative => "nb_negative",
+            Self::NbOr => "nb_or",
+            Self::NbPositive => "nb_positive",
+            Self::NbPower => "nb_power",
+            Self::NbRemainder => "nb_remainder",
+            Self::NbRshift => "nb_rshift",
+            Self::NbSubtract => "nb_subtract",
+            Self::NbTrueDivide => "nb_true_divide",
+            Self::NbXor => "nb_xor",
+            Self::SqAssItem => "sq_ass_item",
+            Self::SqConcat => "sq_concat",
+            Self::SqContains => "sq_contains",
+            Self::SqInplaceConcat => "sq_inplace_concat",
+            Self::SqInplaceRepeat => "sq_inplace_repeat",
+            Self::SqItem => "sq_item",
+            Self::SqLength => "sq_length",
+            Self::SqRepeat => "sq_repeat",
+            Self::TpAlloc => "tp_alloc",
+            Self::TpBase => "tp_base",
+            Self::TpBases => "tp_bases",
+            Self::TpCall => "tp_call",
+            Self::TpClear => "tp_clear",
+            Self::TpDealloc => "tp_dealloc",
+            Self::TpDel => "tp_del",
+            Self::TpDescrGet => "tp_descr_get",
+            Self::TpDescrSet => "tp_descr_set",
+            Self::TpDoc => "tp_doc",
+            Self::TpGetattr => "tp_getattr",
+            Self::TpGetattro => "tp_getattro",
+            Self::TpHash => "tp_hash",
+            Self::TpInit => "tp_init",
+            Self::TpIsGc => "tp_is_gc",
+            Self::TpIter => "tp_iter",
+            Self::TpIternext => "tp_iternext",
+            Self::TpMethods => "tp_methods",
+            Self::TpNew => "tp_new",
+            Self::TpRepr => "tp_repr",
+            Self::TpRichcompare => "tp_richcompare",
+            Self::TpSetattr => "tp_setattr",
+            Self::TpSetattro => "tp_setattro",
+            Self::TpStr => "tp_str",
+            Self::TpTraverse => "tp_traverse",
+            Self::TpMembers => "tp_members",
+            Self::TpGetset => "tp_getset",
+            Self::TpFree => "tp_free",
+            Self::NbMatrixMultiply => "nb_matrix_multiply",
+            Self::NbInplaceMatrixMultiply => "nb_inplace_matrix_multiply",
+            Self::AmAwait => "am_await",
+            Self::AmAiter => "am_aiter",
+            Self::AmAnext => "am_anext",
+            Self::TpFinalize => "tp_finalize",
+            Self::AmSend => "am_send",
+        }
+    }
+
+    /// Extract the raw function pointer from a SlotFunc if it matches this accessor's type
+    pub fn extract_from_slot_func(&self, slot_func: &SlotFunc) -> bool {
+        match self {
+            // Type slots
+            Self::TpHash => matches!(slot_func, SlotFunc::Hash(_)),
+            Self::TpRepr => matches!(slot_func, SlotFunc::Repr(_)),
+            Self::TpStr => matches!(slot_func, SlotFunc::Str(_)),
+            Self::TpCall => matches!(slot_func, SlotFunc::Call(_)),
+            Self::TpIter => matches!(slot_func, SlotFunc::Iter(_)),
+            Self::TpIternext => matches!(slot_func, SlotFunc::IterNext(_)),
+            Self::TpInit => matches!(slot_func, SlotFunc::Init(_)),
+            Self::TpDel => matches!(slot_func, SlotFunc::Del(_)),
+            Self::TpGetattro => matches!(slot_func, SlotFunc::GetAttro(_)),
+            Self::TpSetattro => {
+                matches!(slot_func, SlotFunc::SetAttro(_) | SlotFunc::DelAttro(_))
+            }
+            Self::TpDescrGet => matches!(slot_func, SlotFunc::DescrGet(_)),
+            Self::TpDescrSet => {
+                matches!(slot_func, SlotFunc::DescrSet(_) | SlotFunc::DescrDel(_))
+            }
+            Self::TpRichcompare => matches!(slot_func, SlotFunc::RichCompare(_, _)),
+
+            // Number - Power (ternary)
+            Self::NbPower | Self::NbInplacePower => {
+                matches!(slot_func, SlotFunc::NumTernary(_))
+            }
+            // Number - Boolean
+            Self::NbBool => matches!(slot_func, SlotFunc::NumBoolean(_)),
+            // Number - Unary
+            Self::NbNegative
+            | Self::NbPositive
+            | Self::NbAbsolute
+            | Self::NbInvert
+            | Self::NbInt
+            | Self::NbFloat
+            | Self::NbIndex => matches!(slot_func, SlotFunc::NumUnary(_)),
+            // Number - Binary
+            Self::NbAdd
+            | Self::NbSubtract
+            | Self::NbMultiply
+            | Self::NbRemainder
+            | Self::NbDivmod
+            | Self::NbLshift
+            | Self::NbRshift
+            | Self::NbAnd
+            | Self::NbXor
+            | Self::NbOr
+            | Self::NbFloorDivide
+            | Self::NbTrueDivide
+            | Self::NbMatrixMultiply
+            | Self::NbInplaceAdd
+            | Self::NbInplaceSubtract
+            | Self::NbInplaceMultiply
+            | Self::NbInplaceRemainder
+            | Self::NbInplaceLshift
+            | Self::NbInplaceRshift
+            | Self::NbInplaceAnd
+            | Self::NbInplaceXor
+            | Self::NbInplaceOr
+            | Self::NbInplaceFloorDivide
+            | Self::NbInplaceTrueDivide
+            | Self::NbInplaceMatrixMultiply => matches!(slot_func, SlotFunc::NumBinary(_)),
+
+            // Sequence
+            Self::SqLength => matches!(slot_func, SlotFunc::SeqLength(_)),
+            Self::SqConcat | Self::SqInplaceConcat => matches!(slot_func, SlotFunc::SeqConcat(_)),
+            Self::SqRepeat | Self::SqInplaceRepeat => matches!(slot_func, SlotFunc::SeqRepeat(_)),
+            Self::SqItem => matches!(slot_func, SlotFunc::SeqItem(_)),
+            Self::SqAssItem => matches!(slot_func, SlotFunc::SeqAssItem(_)),
+            Self::SqContains => matches!(slot_func, SlotFunc::SeqContains(_)),
+
+            // Mapping
+            Self::MpLength => matches!(slot_func, SlotFunc::MapLength(_)),
+            Self::MpSubscript => matches!(slot_func, SlotFunc::MapSubscript(_)),
+            Self::MpAssSubscript => matches!(slot_func, SlotFunc::MapAssSubscript(_)),
+
+            // New and reserved slots
+            Self::TpNew => false,
+            _ => false, // Reserved slots
+        }
+    }
+
+    /// Inherit slot value from MRO
+    pub fn inherit_from_mro(&self, typ: &crate::builtins::PyType) {
+        // Note: typ.mro does NOT include typ itself
+        let mro = typ.mro.read();
+
+        macro_rules! inherit_main {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.$slot.load());
+                typ.slots.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_number {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.as_number.$slot.load());
+                typ.slots.as_number.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_sequence {
+            ($slot:ident) => {{
+                let inherited = mro
+                    .iter()
+                    .find_map(|cls| cls.slots.as_sequence.$slot.load());
+                typ.slots.as_sequence.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_mapping {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.as_mapping.$slot.load());
+                typ.slots.as_mapping.$slot.store(inherited);
+            }};
+        }
+
+        match self {
+            // Type slots
+            Self::TpHash => inherit_main!(hash),
+            Self::TpRepr => inherit_main!(repr),
+            Self::TpStr => inherit_main!(str),
+            Self::TpCall => inherit_main!(call),
+            Self::TpIter => inherit_main!(iter),
+            Self::TpIternext => inherit_main!(iternext),
+            Self::TpInit => inherit_main!(init),
+            Self::TpNew => inherit_main!(new),
+            Self::TpDel => inherit_main!(del),
+            Self::TpGetattro => inherit_main!(getattro),
+            Self::TpSetattro => inherit_main!(setattro),
+            Self::TpDescrGet => inherit_main!(descr_get),
+            Self::TpDescrSet => inherit_main!(descr_set),
+            Self::TpRichcompare => inherit_main!(richcompare),
+
+            // Number slots
+            Self::NbAdd => inherit_number!(add),
+            Self::NbSubtract => inherit_number!(subtract),
+            Self::NbMultiply => inherit_number!(multiply),
+            Self::NbRemainder => inherit_number!(remainder),
+            Self::NbDivmod => inherit_number!(divmod),
+            Self::NbPower => inherit_number!(power),
+            Self::NbLshift => inherit_number!(lshift),
+            Self::NbRshift => inherit_number!(rshift),
+            Self::NbAnd => inherit_number!(and),
+            Self::NbXor => inherit_number!(xor),
+            Self::NbOr => inherit_number!(or),
+            Self::NbFloorDivide => inherit_number!(floor_divide),
+            Self::NbTrueDivide => inherit_number!(true_divide),
+            Self::NbMatrixMultiply => inherit_number!(matrix_multiply),
+            Self::NbInplaceAdd => inherit_number!(inplace_add),
+            Self::NbInplaceSubtract => inherit_number!(inplace_subtract),
+            Self::NbInplaceMultiply => inherit_number!(inplace_multiply),
+            Self::NbInplaceRemainder => inherit_number!(inplace_remainder),
+            Self::NbInplacePower => inherit_number!(inplace_power),
+            Self::NbInplaceLshift => inherit_number!(inplace_lshift),
+            Self::NbInplaceRshift => inherit_number!(inplace_rshift),
+            Self::NbInplaceAnd => inherit_number!(inplace_and),
+            Self::NbInplaceXor => inherit_number!(inplace_xor),
+            Self::NbInplaceOr => inherit_number!(inplace_or),
+            Self::NbInplaceFloorDivide => inherit_number!(inplace_floor_divide),
+            Self::NbInplaceTrueDivide => inherit_number!(inplace_true_divide),
+            Self::NbInplaceMatrixMultiply => inherit_number!(inplace_matrix_multiply),
+            // Number unary
+            Self::NbNegative => inherit_number!(negative),
+            Self::NbPositive => inherit_number!(positive),
+            Self::NbAbsolute => inherit_number!(absolute),
+            Self::NbInvert => inherit_number!(invert),
+            Self::NbBool => inherit_number!(boolean),
+            Self::NbInt => inherit_number!(int),
+            Self::NbFloat => inherit_number!(float),
+            Self::NbIndex => inherit_number!(index),
+
+            // Sequence slots
+            Self::SqLength => inherit_sequence!(length),
+            Self::SqConcat => inherit_sequence!(concat),
+            Self::SqRepeat => inherit_sequence!(repeat),
+            Self::SqItem => inherit_sequence!(item),
+            Self::SqAssItem => inherit_sequence!(ass_item),
+            Self::SqContains => inherit_sequence!(contains),
+            Self::SqInplaceConcat => inherit_sequence!(inplace_concat),
+            Self::SqInplaceRepeat => inherit_sequence!(inplace_repeat),
+
+            // Mapping slots
+            Self::MpLength => inherit_mapping!(length),
+            Self::MpSubscript => inherit_mapping!(subscript),
+            Self::MpAssSubscript => inherit_mapping!(ass_subscript),
+
+            // Reserved slots - no-op
+            _ => {}
+        }
+    }
+
+    /// Copy slot from base type if self's slot is None
+    pub fn copyslot_if_none(&self, typ: &crate::builtins::PyType, base: &crate::builtins::PyType) {
+        macro_rules! copy_main {
+            ($slot:ident) => {{
+                if typ.slots.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.$slot.load() {
+                        typ.slots.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_number {
+            ($slot:ident) => {{
+                if typ.slots.as_number.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_number.$slot.load() {
+                        typ.slots.as_number.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_sequence {
+            ($slot:ident) => {{
+                if typ.slots.as_sequence.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_sequence.$slot.load() {
+                        typ.slots.as_sequence.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_mapping {
+            ($slot:ident) => {{
+                if typ.slots.as_mapping.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_mapping.$slot.load() {
+                        typ.slots.as_mapping.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        match self {
+            // Type slots
+            Self::TpHash => copy_main!(hash),
+            Self::TpRepr => copy_main!(repr),
+            Self::TpStr => copy_main!(str),
+            Self::TpCall => copy_main!(call),
+            Self::TpIter => copy_main!(iter),
+            Self::TpIternext => copy_main!(iternext),
+            Self::TpInit => {
+                // SLOTDEFINED check for multiple inheritance support
+                if typ.slots.init.load().is_none()
+                    && let Some(base_val) = base.slots.init.load()
+                {
+                    let slot_defined = base.base.as_ref().is_none_or(|bb| {
+                        bb.slots.init.load().map(|v| v as usize) != Some(base_val as usize)
+                    });
+                    if slot_defined {
+                        typ.slots.init.store(Some(base_val));
+                    }
+                }
+            }
+            Self::TpNew => {} // handled by set_new()
+            Self::TpDel => copy_main!(del),
+            Self::TpGetattro => copy_main!(getattro),
+            Self::TpSetattro => copy_main!(setattro),
+            Self::TpDescrGet => copy_main!(descr_get),
+            Self::TpDescrSet => copy_main!(descr_set),
+            Self::TpRichcompare => copy_main!(richcompare),
+
+            // Number slots
+            Self::NbAdd => copy_number!(add),
+            Self::NbSubtract => copy_number!(subtract),
+            Self::NbMultiply => copy_number!(multiply),
+            Self::NbRemainder => copy_number!(remainder),
+            Self::NbDivmod => copy_number!(divmod),
+            Self::NbPower => copy_number!(power),
+            Self::NbLshift => copy_number!(lshift),
+            Self::NbRshift => copy_number!(rshift),
+            Self::NbAnd => copy_number!(and),
+            Self::NbXor => copy_number!(xor),
+            Self::NbOr => copy_number!(or),
+            Self::NbFloorDivide => copy_number!(floor_divide),
+            Self::NbTrueDivide => copy_number!(true_divide),
+            Self::NbMatrixMultiply => copy_number!(matrix_multiply),
+            Self::NbInplaceAdd => copy_number!(inplace_add),
+            Self::NbInplaceSubtract => copy_number!(inplace_subtract),
+            Self::NbInplaceMultiply => copy_number!(inplace_multiply),
+            Self::NbInplaceRemainder => copy_number!(inplace_remainder),
+            Self::NbInplacePower => copy_number!(inplace_power),
+            Self::NbInplaceLshift => copy_number!(inplace_lshift),
+            Self::NbInplaceRshift => copy_number!(inplace_rshift),
+            Self::NbInplaceAnd => copy_number!(inplace_and),
+            Self::NbInplaceXor => copy_number!(inplace_xor),
+            Self::NbInplaceOr => copy_number!(inplace_or),
+            Self::NbInplaceFloorDivide => copy_number!(inplace_floor_divide),
+            Self::NbInplaceTrueDivide => copy_number!(inplace_true_divide),
+            Self::NbInplaceMatrixMultiply => copy_number!(inplace_matrix_multiply),
+            // Number unary
+            Self::NbNegative => copy_number!(negative),
+            Self::NbPositive => copy_number!(positive),
+            Self::NbAbsolute => copy_number!(absolute),
+            Self::NbInvert => copy_number!(invert),
+            Self::NbBool => copy_number!(boolean),
+            Self::NbInt => copy_number!(int),
+            Self::NbFloat => copy_number!(float),
+            Self::NbIndex => copy_number!(index),
+
+            // Sequence slots
+            Self::SqLength => copy_sequence!(length),
+            Self::SqConcat => copy_sequence!(concat),
+            Self::SqRepeat => copy_sequence!(repeat),
+            Self::SqItem => copy_sequence!(item),
+            Self::SqAssItem => copy_sequence!(ass_item),
+            Self::SqContains => copy_sequence!(contains),
+            Self::SqInplaceConcat => copy_sequence!(inplace_concat),
+            Self::SqInplaceRepeat => copy_sequence!(inplace_repeat),
+
+            // Mapping slots
+            Self::MpLength => copy_mapping!(length),
+            Self::MpSubscript => copy_mapping!(subscript),
+            Self::MpAssSubscript => copy_mapping!(ass_subscript),
+
+            // Reserved slots - no-op
+            _ => {}
+        }
+    }
+
+    /// Get the SlotFunc from type slots for this accessor
+    pub fn get_slot_func(&self, slots: &PyTypeSlots) -> Option<SlotFunc> {
+        match self {
+            // Type slots
+            Self::TpHash => slots.hash.load().map(SlotFunc::Hash),
+            Self::TpRepr => slots.repr.load().map(SlotFunc::Repr),
+            Self::TpStr => slots.str.load().map(SlotFunc::Str),
+            Self::TpCall => slots.call.load().map(SlotFunc::Call),
+            Self::TpIter => slots.iter.load().map(SlotFunc::Iter),
+            Self::TpIternext => slots.iternext.load().map(SlotFunc::IterNext),
+            Self::TpInit => slots.init.load().map(SlotFunc::Init),
+            Self::TpNew => None, // __new__ handled separately
+            Self::TpDel => slots.del.load().map(SlotFunc::Del),
+            Self::TpGetattro => slots.getattro.load().map(SlotFunc::GetAttro),
+            Self::TpSetattro => slots.setattro.load().map(SlotFunc::SetAttro),
+            Self::TpDescrGet => slots.descr_get.load().map(SlotFunc::DescrGet),
+            Self::TpDescrSet => slots.descr_set.load().map(SlotFunc::DescrSet),
+            Self::TpRichcompare => slots
+                .richcompare
+                .load()
+                .map(|f| SlotFunc::RichCompare(f, PyComparisonOp::Eq)),
+
+            // Number binary slots
+            Self::NbAdd => slots.as_number.add.load().map(SlotFunc::NumBinary),
+            Self::NbSubtract => slots.as_number.subtract.load().map(SlotFunc::NumBinary),
+            Self::NbMultiply => slots.as_number.multiply.load().map(SlotFunc::NumBinary),
+            Self::NbRemainder => slots.as_number.remainder.load().map(SlotFunc::NumBinary),
+            Self::NbDivmod => slots.as_number.divmod.load().map(SlotFunc::NumBinary),
+            Self::NbPower => slots.as_number.power.load().map(SlotFunc::NumTernary),
+            Self::NbLshift => slots.as_number.lshift.load().map(SlotFunc::NumBinary),
+            Self::NbRshift => slots.as_number.rshift.load().map(SlotFunc::NumBinary),
+            Self::NbAnd => slots.as_number.and.load().map(SlotFunc::NumBinary),
+            Self::NbXor => slots.as_number.xor.load().map(SlotFunc::NumBinary),
+            Self::NbOr => slots.as_number.or.load().map(SlotFunc::NumBinary),
+            Self::NbFloorDivide => slots.as_number.floor_divide.load().map(SlotFunc::NumBinary),
+            Self::NbTrueDivide => slots.as_number.true_divide.load().map(SlotFunc::NumBinary),
+            Self::NbMatrixMultiply => slots
+                .as_number
+                .matrix_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+
+            // Number inplace slots
+            Self::NbInplaceAdd => slots.as_number.inplace_add.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceSubtract => slots
+                .as_number
+                .inplace_subtract
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceMultiply => slots
+                .as_number
+                .inplace_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceRemainder => slots
+                .as_number
+                .inplace_remainder
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplacePower => slots
+                .as_number
+                .inplace_power
+                .load()
+                .map(SlotFunc::NumTernary),
+            Self::NbInplaceLshift => slots
+                .as_number
+                .inplace_lshift
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceRshift => slots
+                .as_number
+                .inplace_rshift
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceAnd => slots.as_number.inplace_and.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceXor => slots.as_number.inplace_xor.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceOr => slots.as_number.inplace_or.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceFloorDivide => slots
+                .as_number
+                .inplace_floor_divide
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceTrueDivide => slots
+                .as_number
+                .inplace_true_divide
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceMatrixMultiply => slots
+                .as_number
+                .inplace_matrix_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+
+            // Number unary slots
+            Self::NbNegative => slots.as_number.negative.load().map(SlotFunc::NumUnary),
+            Self::NbPositive => slots.as_number.positive.load().map(SlotFunc::NumUnary),
+            Self::NbAbsolute => slots.as_number.absolute.load().map(SlotFunc::NumUnary),
+            Self::NbInvert => slots.as_number.invert.load().map(SlotFunc::NumUnary),
+            Self::NbBool => slots.as_number.boolean.load().map(SlotFunc::NumBoolean),
+            Self::NbInt => slots.as_number.int.load().map(SlotFunc::NumUnary),
+            Self::NbFloat => slots.as_number.float.load().map(SlotFunc::NumUnary),
+            Self::NbIndex => slots.as_number.index.load().map(SlotFunc::NumUnary),
+
+            // Sequence slots
+            Self::SqLength => slots.as_sequence.length.load().map(SlotFunc::SeqLength),
+            Self::SqConcat => slots.as_sequence.concat.load().map(SlotFunc::SeqConcat),
+            Self::SqRepeat => slots.as_sequence.repeat.load().map(SlotFunc::SeqRepeat),
+            Self::SqItem => slots.as_sequence.item.load().map(SlotFunc::SeqItem),
+            Self::SqAssItem => slots.as_sequence.ass_item.load().map(SlotFunc::SeqAssItem),
+            Self::SqContains => slots.as_sequence.contains.load().map(SlotFunc::SeqContains),
+            Self::SqInplaceConcat => slots
+                .as_sequence
+                .inplace_concat
+                .load()
+                .map(SlotFunc::SeqConcat),
+            Self::SqInplaceRepeat => slots
+                .as_sequence
+                .inplace_repeat
+                .load()
+                .map(SlotFunc::SeqRepeat),
+
+            // Mapping slots
+            Self::MpLength => slots.as_mapping.length.load().map(SlotFunc::MapLength),
+            Self::MpSubscript => slots
+                .as_mapping
+                .subscript
+                .load()
+                .map(SlotFunc::MapSubscript),
+            Self::MpAssSubscript => slots
+                .as_mapping
+                .ass_subscript
+                .load()
+                .map(SlotFunc::MapAssSubscript),
+
+            // Reserved slots
+            _ => None,
+        }
+    }
+
+    /// Get slot function considering SlotOp for right-hand and delete operations
+    pub fn get_slot_func_with_op(
+        &self,
+        slots: &PyTypeSlots,
+        op: Option<SlotOp>,
+    ) -> Option<SlotFunc> {
+        // For Delete operations, return the delete variant
+        if op == Some(SlotOp::Delete) {
+            match self {
+                Self::TpSetattro => return slots.setattro.load().map(SlotFunc::DelAttro),
+                Self::TpDescrSet => return slots.descr_set.load().map(SlotFunc::DescrDel),
+                _ => {}
+            }
+        }
+        // For Right operations on binary number slots, use right_* fields with swapped args
+        if op == Some(SlotOp::Right) {
+            match self {
+                Self::NbAdd => {
+                    return slots
+                        .as_number
+                        .right_add
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbSubtract => {
+                    return slots
+                        .as_number
+                        .right_subtract
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbMultiply => {
+                    return slots
+                        .as_number
+                        .right_multiply
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbRemainder => {
+                    return slots
+                        .as_number
+                        .right_remainder
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbDivmod => {
+                    return slots
+                        .as_number
+                        .right_divmod
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbPower => {
+                    return slots
+                        .as_number
+                        .right_power
+                        .load()
+                        .map(SlotFunc::NumTernaryRight);
+                }
+                Self::NbLshift => {
+                    return slots
+                        .as_number
+                        .right_lshift
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbRshift => {
+                    return slots
+                        .as_number
+                        .right_rshift
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbAnd => {
+                    return slots
+                        .as_number
+                        .right_and
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbXor => {
+                    return slots
+                        .as_number
+                        .right_xor
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbOr => {
+                    return slots
+                        .as_number
+                        .right_or
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbFloorDivide => {
+                    return slots
+                        .as_number
+                        .right_floor_divide
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbTrueDivide => {
+                    return slots
+                        .as_number
+                        .right_true_divide
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbMatrixMultiply => {
+                    return slots
+                        .as_number
+                        .right_matrix_multiply
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                _ => {}
+            }
+        }
+        // For comparison operations, use the appropriate PyComparisonOp
+        if let Self::TpRichcompare = self
+            && let Some(cmp_op) = op.and_then(|o| o.as_compare_op())
+        {
+            return slots
+                .richcompare
+                .load()
+                .map(|f| SlotFunc::RichCompare(f, cmp_op));
+        }
+        // Fall back to existing get_slot_func for left/other operations
+        self.get_slot_func(slots)
+    }
+}
+
+/// Find all slot definitions with a given name
+pub fn find_slot_defs_by_name(name: &str) -> impl Iterator<Item = &'static SlotDef> {
+    SLOT_DEFS.iter().filter(move |def| def.name == name)
+}
+
+/// Total number of slot definitions
+pub const SLOT_DEFS_COUNT: usize = SLOT_DEFS.len();
+
+/// All slot definitions
+pub static SLOT_DEFS: &[SlotDef] = &[
+    // Type slots (tp_*)
+    SlotDef {
+        name: "__init__",
+        accessor: SlotAccessor::TpInit,
+        op: None,
+        doc: "Initialize self. See help(type(self)) for accurate signature.",
+    },
+    SlotDef {
+        name: "__new__",
+        accessor: SlotAccessor::TpNew,
+        op: None,
+        doc: "Create and return a new object. See help(type) for accurate signature.",
+    },
+    SlotDef {
+        name: "__del__",
+        accessor: SlotAccessor::TpDel,
+        op: None,
+        doc: "Called when the instance is about to be destroyed.",
+    },
+    SlotDef {
+        name: "__repr__",
+        accessor: SlotAccessor::TpRepr,
+        op: None,
+        doc: "Return repr(self).",
+    },
+    SlotDef {
+        name: "__str__",
+        accessor: SlotAccessor::TpStr,
+        op: None,
+        doc: "Return str(self).",
+    },
+    SlotDef {
+        name: "__hash__",
+        accessor: SlotAccessor::TpHash,
+        op: None,
+        doc: "Return hash(self).",
+    },
+    SlotDef {
+        name: "__call__",
+        accessor: SlotAccessor::TpCall,
+        op: None,
+        doc: "Call self as a function.",
+    },
+    SlotDef {
+        name: "__iter__",
+        accessor: SlotAccessor::TpIter,
+        op: None,
+        doc: "Implement iter(self).",
+    },
+    SlotDef {
+        name: "__next__",
+        accessor: SlotAccessor::TpIternext,
+        op: None,
+        doc: "Implement next(self).",
+    },
+    // Attribute access
+    SlotDef {
+        name: "__getattribute__",
+        accessor: SlotAccessor::TpGetattro,
+        op: None,
+        doc: "Return getattr(self, name).",
+    },
+    SlotDef {
+        name: "__setattr__",
+        accessor: SlotAccessor::TpSetattro,
+        op: None,
+        doc: "Implement setattr(self, name, value).",
+    },
+    SlotDef {
+        name: "__delattr__",
+        accessor: SlotAccessor::TpSetattro,
+        op: Some(SlotOp::Delete),
+        doc: "Implement delattr(self, name).",
+    },
+    // Rich comparison - all map to TpRichcompare with different op
+    SlotDef {
+        name: "__eq__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Eq),
+        doc: "Return self==value.",
+    },
+    SlotDef {
+        name: "__ne__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Ne),
+        doc: "Return self!=value.",
+    },
+    SlotDef {
+        name: "__lt__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Lt),
+        doc: "Return self<value.",
+    },
+    SlotDef {
+        name: "__le__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Le),
+        doc: "Return self<=value.",
+    },
+    SlotDef {
+        name: "__gt__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Gt),
+        doc: "Return self>value.",
+    },
+    SlotDef {
+        name: "__ge__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Ge),
+        doc: "Return self>=value.",
+    },
+    // Descriptor protocol
+    SlotDef {
+        name: "__get__",
+        accessor: SlotAccessor::TpDescrGet,
+        op: None,
+        doc: "Return an attribute of instance, which is of type owner.",
+    },
+    SlotDef {
+        name: "__set__",
+        accessor: SlotAccessor::TpDescrSet,
+        op: None,
+        doc: "Set an attribute of instance to value.",
+    },
+    SlotDef {
+        name: "__delete__",
+        accessor: SlotAccessor::TpDescrSet,
+        op: Some(SlotOp::Delete),
+        doc: "Delete an attribute of instance.",
+    },
+    // Sequence protocol (sq_*)
+    SlotDef {
+        name: "__len__",
+        accessor: SlotAccessor::SqLength,
+        op: None,
+        doc: "Return len(self).",
+    },
+    SlotDef {
+        name: "__getitem__",
+        accessor: SlotAccessor::SqItem,
+        op: None,
+        doc: "Return self[key].",
+    },
+    SlotDef {
+        name: "__setitem__",
+        accessor: SlotAccessor::SqAssItem,
+        op: None,
+        doc: "Set self[key] to value.",
+    },
+    SlotDef {
+        name: "__delitem__",
+        accessor: SlotAccessor::SqAssItem,
+        op: None,
+        doc: "Delete self[key].",
+    },
+    SlotDef {
+        name: "__contains__",
+        accessor: SlotAccessor::SqContains,
+        op: None,
+        doc: "Return key in self.",
+    },
+    // Mapping protocol (mp_*)
+    SlotDef {
+        name: "__len__",
+        accessor: SlotAccessor::MpLength,
+        op: None,
+        doc: "Return len(self).",
+    },
+    SlotDef {
+        name: "__getitem__",
+        accessor: SlotAccessor::MpSubscript,
+        op: None,
+        doc: "Return self[key].",
+    },
+    SlotDef {
+        name: "__setitem__",
+        accessor: SlotAccessor::MpAssSubscript,
+        op: None,
+        doc: "Set self[key] to value.",
+    },
+    SlotDef {
+        name: "__delitem__",
+        accessor: SlotAccessor::MpAssSubscript,
+        op: None,
+        doc: "Delete self[key].",
+    },
+    // Number protocol - binary ops with left/right variants
+    SlotDef {
+        name: "__add__",
+        accessor: SlotAccessor::NbAdd,
+        op: Some(SlotOp::Left),
+        doc: "Return self+value.",
+    },
+    SlotDef {
+        name: "__radd__",
+        accessor: SlotAccessor::NbAdd,
+        op: Some(SlotOp::Right),
+        doc: "Return value+self.",
+    },
+    SlotDef {
+        name: "__iadd__",
+        accessor: SlotAccessor::NbInplaceAdd,
+        op: None,
+        doc: "Implement self+=value.",
+    },
+    SlotDef {
+        name: "__sub__",
+        accessor: SlotAccessor::NbSubtract,
+        op: Some(SlotOp::Left),
+        doc: "Return self-value.",
+    },
+    SlotDef {
+        name: "__rsub__",
+        accessor: SlotAccessor::NbSubtract,
+        op: Some(SlotOp::Right),
+        doc: "Return value-self.",
+    },
+    SlotDef {
+        name: "__isub__",
+        accessor: SlotAccessor::NbInplaceSubtract,
+        op: None,
+        doc: "Implement self-=value.",
+    },
+    SlotDef {
+        name: "__mul__",
+        accessor: SlotAccessor::NbMultiply,
+        op: Some(SlotOp::Left),
+        doc: "Return self*value.",
+    },
+    SlotDef {
+        name: "__rmul__",
+        accessor: SlotAccessor::NbMultiply,
+        op: Some(SlotOp::Right),
+        doc: "Return value*self.",
+    },
+    SlotDef {
+        name: "__imul__",
+        accessor: SlotAccessor::NbInplaceMultiply,
+        op: None,
+        doc: "Implement self*=value.",
+    },
+    SlotDef {
+        name: "__mod__",
+        accessor: SlotAccessor::NbRemainder,
+        op: Some(SlotOp::Left),
+        doc: "Return self%value.",
+    },
+    SlotDef {
+        name: "__rmod__",
+        accessor: SlotAccessor::NbRemainder,
+        op: Some(SlotOp::Right),
+        doc: "Return value%self.",
+    },
+    SlotDef {
+        name: "__imod__",
+        accessor: SlotAccessor::NbInplaceRemainder,
+        op: None,
+        doc: "Implement self%=value.",
+    },
+    SlotDef {
+        name: "__divmod__",
+        accessor: SlotAccessor::NbDivmod,
+        op: Some(SlotOp::Left),
+        doc: "Return divmod(self, value).",
+    },
+    SlotDef {
+        name: "__rdivmod__",
+        accessor: SlotAccessor::NbDivmod,
+        op: Some(SlotOp::Right),
+        doc: "Return divmod(value, self).",
+    },
+    SlotDef {
+        name: "__pow__",
+        accessor: SlotAccessor::NbPower,
+        op: Some(SlotOp::Left),
+        doc: "Return pow(self, value, mod).",
+    },
+    SlotDef {
+        name: "__rpow__",
+        accessor: SlotAccessor::NbPower,
+        op: Some(SlotOp::Right),
+        doc: "Return pow(value, self, mod).",
+    },
+    SlotDef {
+        name: "__ipow__",
+        accessor: SlotAccessor::NbInplacePower,
+        op: None,
+        doc: "Implement self**=value.",
+    },
+    SlotDef {
+        name: "__lshift__",
+        accessor: SlotAccessor::NbLshift,
+        op: Some(SlotOp::Left),
+        doc: "Return self<<value.",
+    },
+    SlotDef {
+        name: "__rlshift__",
+        accessor: SlotAccessor::NbLshift,
+        op: Some(SlotOp::Right),
+        doc: "Return value<<self.",
+    },
+    SlotDef {
+        name: "__ilshift__",
+        accessor: SlotAccessor::NbInplaceLshift,
+        op: None,
+        doc: "Implement self<<=value.",
+    },
+    SlotDef {
+        name: "__rshift__",
+        accessor: SlotAccessor::NbRshift,
+        op: Some(SlotOp::Left),
+        doc: "Return self>>value.",
+    },
+    SlotDef {
+        name: "__rrshift__",
+        accessor: SlotAccessor::NbRshift,
+        op: Some(SlotOp::Right),
+        doc: "Return value>>self.",
+    },
+    SlotDef {
+        name: "__irshift__",
+        accessor: SlotAccessor::NbInplaceRshift,
+        op: None,
+        doc: "Implement self>>=value.",
+    },
+    SlotDef {
+        name: "__and__",
+        accessor: SlotAccessor::NbAnd,
+        op: Some(SlotOp::Left),
+        doc: "Return self&value.",
+    },
+    SlotDef {
+        name: "__rand__",
+        accessor: SlotAccessor::NbAnd,
+        op: Some(SlotOp::Right),
+        doc: "Return value&self.",
+    },
+    SlotDef {
+        name: "__iand__",
+        accessor: SlotAccessor::NbInplaceAnd,
+        op: None,
+        doc: "Implement self&=value.",
+    },
+    SlotDef {
+        name: "__xor__",
+        accessor: SlotAccessor::NbXor,
+        op: Some(SlotOp::Left),
+        doc: "Return self^value.",
+    },
+    SlotDef {
+        name: "__rxor__",
+        accessor: SlotAccessor::NbXor,
+        op: Some(SlotOp::Right),
+        doc: "Return value^self.",
+    },
+    SlotDef {
+        name: "__ixor__",
+        accessor: SlotAccessor::NbInplaceXor,
+        op: None,
+        doc: "Implement self^=value.",
+    },
+    SlotDef {
+        name: "__or__",
+        accessor: SlotAccessor::NbOr,
+        op: Some(SlotOp::Left),
+        doc: "Return self|value.",
+    },
+    SlotDef {
+        name: "__ror__",
+        accessor: SlotAccessor::NbOr,
+        op: Some(SlotOp::Right),
+        doc: "Return value|self.",
+    },
+    SlotDef {
+        name: "__ior__",
+        accessor: SlotAccessor::NbInplaceOr,
+        op: None,
+        doc: "Implement self|=value.",
+    },
+    SlotDef {
+        name: "__floordiv__",
+        accessor: SlotAccessor::NbFloorDivide,
+        op: Some(SlotOp::Left),
+        doc: "Return self//value.",
+    },
+    SlotDef {
+        name: "__rfloordiv__",
+        accessor: SlotAccessor::NbFloorDivide,
+        op: Some(SlotOp::Right),
+        doc: "Return value//self.",
+    },
+    SlotDef {
+        name: "__ifloordiv__",
+        accessor: SlotAccessor::NbInplaceFloorDivide,
+        op: None,
+        doc: "Implement self//=value.",
+    },
+    SlotDef {
+        name: "__truediv__",
+        accessor: SlotAccessor::NbTrueDivide,
+        op: Some(SlotOp::Left),
+        doc: "Return self/value.",
+    },
+    SlotDef {
+        name: "__rtruediv__",
+        accessor: SlotAccessor::NbTrueDivide,
+        op: Some(SlotOp::Right),
+        doc: "Return value/self.",
+    },
+    SlotDef {
+        name: "__itruediv__",
+        accessor: SlotAccessor::NbInplaceTrueDivide,
+        op: None,
+        doc: "Implement self/=value.",
+    },
+    SlotDef {
+        name: "__matmul__",
+        accessor: SlotAccessor::NbMatrixMultiply,
+        op: Some(SlotOp::Left),
+        doc: "Return self@value.",
+    },
+    SlotDef {
+        name: "__rmatmul__",
+        accessor: SlotAccessor::NbMatrixMultiply,
+        op: Some(SlotOp::Right),
+        doc: "Return value@self.",
+    },
+    SlotDef {
+        name: "__imatmul__",
+        accessor: SlotAccessor::NbInplaceMatrixMultiply,
+        op: None,
+        doc: "Implement self@=value.",
+    },
+    // Number unary operations
+    SlotDef {
+        name: "__neg__",
+        accessor: SlotAccessor::NbNegative,
+        op: None,
+        doc: "Return -self.",
+    },
+    SlotDef {
+        name: "__pos__",
+        accessor: SlotAccessor::NbPositive,
+        op: None,
+        doc: "Return +self.",
+    },
+    SlotDef {
+        name: "__abs__",
+        accessor: SlotAccessor::NbAbsolute,
+        op: None,
+        doc: "Return abs(self).",
+    },
+    SlotDef {
+        name: "__invert__",
+        accessor: SlotAccessor::NbInvert,
+        op: None,
+        doc: "Return ~self.",
+    },
+    SlotDef {
+        name: "__bool__",
+        accessor: SlotAccessor::NbBool,
+        op: None,
+        doc: "Return self != 0.",
+    },
+    SlotDef {
+        name: "__int__",
+        accessor: SlotAccessor::NbInt,
+        op: None,
+        doc: "Return int(self).",
+    },
+    SlotDef {
+        name: "__float__",
+        accessor: SlotAccessor::NbFloat,
+        op: None,
+        doc: "Return float(self).",
+    },
+    SlotDef {
+        name: "__index__",
+        accessor: SlotAccessor::NbIndex,
+        op: None,
+        doc: "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    },
+    // Sequence inplace operations (also map to number slots for some types)
+    SlotDef {
+        name: "__add__",
+        accessor: SlotAccessor::SqConcat,
+        op: None,
+        doc: "Return self+value.",
+    },
+    SlotDef {
+        name: "__mul__",
+        accessor: SlotAccessor::SqRepeat,
+        op: None,
+        doc: "Return self*value.",
+    },
+    SlotDef {
+        name: "__iadd__",
+        accessor: SlotAccessor::SqInplaceConcat,
+        op: None,
+        doc: "Implement self+=value.",
+    },
+    SlotDef {
+        name: "__imul__",
+        accessor: SlotAccessor::SqInplaceRepeat,
+        op: None,
+        doc: "Implement self*=value.",
+    },
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_by_name() {
+        // __len__ appears in both sequence and mapping
+        let len_defs: Vec<_> = find_slot_defs_by_name("__len__").collect();
+        assert_eq!(len_defs.len(), 2);
+
+        // __init__ appears once
+        let init_defs: Vec<_> = find_slot_defs_by_name("__init__").collect();
+        assert_eq!(init_defs.len(), 1);
+
+        // __add__ appears in number (left/right) and sequence
+        let add_defs: Vec<_> = find_slot_defs_by_name("__add__").collect();
+        assert_eq!(add_defs.len(), 2); // NbAdd(Left) and SqConcat
+    }
+
+    #[test]
+    fn test_slot_op() {
+        // Test comparison ops
+        assert_eq!(SlotOp::Lt.as_compare_op(), Some(PyComparisonOp::Lt));
+        assert_eq!(SlotOp::Eq.as_compare_op(), Some(PyComparisonOp::Eq));
+        assert_eq!(SlotOp::Left.as_compare_op(), None);
+
+        // Test right check
+        assert!(SlotOp::Right.is_right());
+        assert!(!SlotOp::Left.is_right());
+    }
+}
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index 9d164241676..c4aa7258c07 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -189,7 +189,7 @@ impl TypeZoo {
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
             member_descriptor_type: descriptor::PyMemberDescriptor::init_builtin_type(),
-            wrapper_descriptor_type: descriptor::PySlotWrapper::init_builtin_type(),
+            wrapper_descriptor_type: descriptor::PyWrapper::init_builtin_type(),
             method_wrapper_type: descriptor::PyMethodWrapper::init_builtin_type(),
 
             method_def: crate::function::HeapMethodDef::init_builtin_type(),

From ee747134b5fd68c079ee788fdf06f2ffcebdae0d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 12:04:33 +0900
Subject: [PATCH 091/418] signal timer (#6535)

* fix waitpid

* signal timer
---
 Lib/test/test_signal.py        |  12 ----
 crates/vm/src/stdlib/posix.rs  |  14 +++-
 crates/vm/src/stdlib/signal.rs | 116 +++++++++++++++++++++++++++++++++
 3 files changed, 127 insertions(+), 15 deletions(-)

diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index 58b3e55d321..cb744b41e8b 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -127,8 +127,6 @@ def test_strsignal(self):
         self.assertIn("Terminated", signal.strsignal(signal.SIGTERM))
         self.assertIn("Hangup", signal.strsignal(signal.SIGHUP))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Issue 3864, unknown if this affects earlier versions of freebsd also
     def test_interprocess_signal(self):
         dirname = os.path.dirname(__file__)
@@ -820,8 +818,6 @@ def sig_prof(self, *args):
         self.hndl_called = True
         signal.setitimer(signal.ITIMER_PROF, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_exc(self):
         # XXX I'm assuming -1 is an invalid itimer, but maybe some platform
         # defines it ?
@@ -831,16 +827,12 @@ def test_itimer_exc(self):
             self.assertRaises(signal.ItimerError,
                               signal.setitimer, signal.ITIMER_REAL, -1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_real(self):
         self.itimer = signal.ITIMER_REAL
         signal.setitimer(self.itimer, 1.0)
         signal.pause()
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Issue 3864, unknown if this affects earlier versions of freebsd also
     @unittest.skipIf(sys.platform in ('netbsd5',),
         'itimer not reliable (does not mix well with threading) on some BSDs.')
@@ -861,8 +853,6 @@ def test_itimer_virtual(self):
         # and the handler should have been called
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_prof(self):
         self.itimer = signal.ITIMER_PROF
         signal.signal(signal.SIGPROF, self.sig_prof)
@@ -880,8 +870,6 @@ def test_itimer_prof(self):
         # and the handler should have been called
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_setitimer_tiny(self):
         # bpo-30807: C setitimer() takes a microsecond-resolution interval.
         # Check that float -> timeval conversion doesn't round
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 15c8745ded4..b903e41889d 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -1738,9 +1738,17 @@ pub mod module {
     #[pyfunction]
     fn waitpid(pid: libc::pid_t, opt: i32, vm: &VirtualMachine) -> PyResult<(libc::pid_t, i32)> {
         let mut status = 0;
-        let pid = unsafe { libc::waitpid(pid, &mut status, opt) };
-        let pid = nix::Error::result(pid).map_err(|err| err.into_pyexception(vm))?;
-        Ok((pid, status))
+        loop {
+            let res = unsafe { libc::waitpid(pid, &mut status, opt) };
+            if res == -1 {
+                if nix::Error::last_raw() == libc::EINTR {
+                    vm.check_signals()?;
+                    continue;
+                }
+                return Err(nix::Error::last().into_pyexception(vm));
+            }
+            return Ok((res, status));
+        }
     }
 
     #[pyfunction]
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
index d34a681c2da..810ffabefe6 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/signal.rs
@@ -19,6 +19,11 @@ pub(crate) mod _signal {
         convert::{IntoPyException, TryFromBorrowedObject},
     };
     use crate::{PyObjectRef, PyResult, VirtualMachine, signal};
+    #[cfg(unix)]
+    use crate::{
+        builtins::PyTypeRef,
+        function::{ArgIntoFloat, OptionalArg},
+    };
     use std::sync::atomic::{self, Ordering};
 
     #[cfg(any(unix, windows))]
@@ -89,6 +94,18 @@ pub(crate) mod _signal {
         fn siginterrupt(sig: i32, flag: i32) -> i32;
     }
 
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    mod ffi {
+        unsafe extern "C" {
+            pub fn getitimer(which: libc::c_int, curr_value: *mut libc::itimerval) -> libc::c_int;
+            pub fn setitimer(
+                which: libc::c_int,
+                new_value: *const libc::itimerval,
+                old_value: *mut libc::itimerval,
+            ) -> libc::c_int;
+        }
+    }
+
     #[pyattr]
     use crate::signal::NSIG;
 
@@ -114,6 +131,31 @@ pub(crate) mod _signal {
     #[pyattr]
     use libc::{SIGPWR, SIGSTKFLT};
 
+    // Interval timer constants
+    #[cfg(all(unix, not(target_os = "android")))]
+    #[pyattr]
+    use libc::{ITIMER_PROF, ITIMER_REAL, ITIMER_VIRTUAL};
+
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_REAL: libc::c_int = 0;
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_VIRTUAL: libc::c_int = 1;
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_PROF: libc::c_int = 2;
+
+    #[cfg(unix)]
+    #[pyattr(name = "ItimerError", once)]
+    fn itimer_error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "signal",
+            "ItimerError",
+            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
+        )
+    }
+
     #[cfg(any(unix, windows))]
     pub(super) fn init_signal_handlers(
         module: &Py<crate::builtins::PyModule>,
@@ -216,6 +258,80 @@ pub(crate) mod _signal {
         prev_time.unwrap_or(0)
     }
 
+    #[cfg(unix)]
+    #[pyfunction]
+    fn pause(vm: &VirtualMachine) -> PyResult<()> {
+        unsafe { libc::pause() };
+        signal::check_signals(vm)?;
+        Ok(())
+    }
+
+    #[cfg(unix)]
+    fn timeval_to_double(tv: &libc::timeval) -> f64 {
+        tv.tv_sec as f64 + (tv.tv_usec as f64 / 1_000_000.0)
+    }
+
+    #[cfg(unix)]
+    fn double_to_timeval(val: f64) -> libc::timeval {
+        libc::timeval {
+            tv_sec: val.trunc() as _,
+            tv_usec: ((val.fract()) * 1_000_000.0) as _,
+        }
+    }
+
+    #[cfg(unix)]
+    fn itimerval_to_tuple(it: &libc::itimerval) -> (f64, f64) {
+        (
+            timeval_to_double(&it.it_value),
+            timeval_to_double(&it.it_interval),
+        )
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn setitimer(
+        which: i32,
+        seconds: ArgIntoFloat,
+        interval: OptionalArg<ArgIntoFloat>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(f64, f64)> {
+        let seconds: f64 = seconds.into();
+        let interval: f64 = interval.map(|v| v.into()).unwrap_or(0.0);
+        let new = libc::itimerval {
+            it_value: double_to_timeval(seconds),
+            it_interval: double_to_timeval(interval),
+        };
+        let mut old = std::mem::MaybeUninit::<libc::itimerval>::uninit();
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        let ret = unsafe { ffi::setitimer(which, &new, old.as_mut_ptr()) };
+        #[cfg(not(any(target_os = "linux", target_os = "android")))]
+        let ret = unsafe { libc::setitimer(which, &new, old.as_mut_ptr()) };
+        if ret != 0 {
+            let err = std::io::Error::last_os_error();
+            let itimer_error = itimer_error(vm);
+            return Err(vm.new_exception_msg(itimer_error, err.to_string()));
+        }
+        let old = unsafe { old.assume_init() };
+        Ok(itimerval_to_tuple(&old))
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn getitimer(which: i32, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
+        let mut old = std::mem::MaybeUninit::<libc::itimerval>::uninit();
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        let ret = unsafe { ffi::getitimer(which, old.as_mut_ptr()) };
+        #[cfg(not(any(target_os = "linux", target_os = "android")))]
+        let ret = unsafe { libc::getitimer(which, old.as_mut_ptr()) };
+        if ret != 0 {
+            let err = std::io::Error::last_os_error();
+            let itimer_error = itimer_error(vm);
+            return Err(vm.new_exception_msg(itimer_error, err.to_string()));
+        }
+        let old = unsafe { old.assume_init() };
+        Ok(itimerval_to_tuple(&old))
+    }
+
     #[pyfunction]
     fn default_int_handler(
         _signum: PyObjectRef,

From f8199d70991ad08e145223dddc97d94489002e5b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 14:25:10 +0900
Subject: [PATCH 092/418] impl basicsize (#6557)

* shape_differs

* may_add_dict

* basicsize
---
 Lib/test/test_types.py            |  2 --
 crates/derive-impl/src/pyclass.rs |  1 +
 crates/vm/src/builtins/type.rs    | 31 +++++++++++++++++--------------
 crates/vm/src/object/core.rs      |  1 +
 crates/vm/src/object/mod.rs       |  1 +
 5 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 4200cb8ee5e..b57fdf35fb6 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -591,8 +591,6 @@ def test_format_spec_errors(self):
         for code in 'xXobns':
             self.assertRaises(ValueError, format, 0, ',' + code)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_internal_sizes(self):
         self.assertGreater(object.__basicsize__, 0)
         self.assertGreater(tuple.__itemsize__, 0)
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 82057d40f9e..55f9c769940 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -455,6 +455,7 @@ fn generate_class_def(
     });
     // If repr(transparent) with a base, the type has the same memory layout as base,
     // so basicsize should be 0 (no additional space beyond the base type)
+    // Otherwise, basicsize = sizeof(payload). The header size is added in __basicsize__ getter.
     let basicsize = if is_repr_transparent && base.is_some() {
         quote!(0)
     } else {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index f74095a8c8a..e807d3f4f8e 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -782,8 +782,8 @@ impl PyType {
     }
 
     #[pygetset]
-    const fn __basicsize__(&self) -> usize {
-        self.slots.basicsize
+    fn __basicsize__(&self) -> usize {
+        crate::object::SIZEOF_PYOBJECT_HEAD + self.slots.basicsize
     }
 
     #[pygetset]
@@ -1338,10 +1338,16 @@ impl Constructor for PyType {
         let member_count: usize = base_member_count + heaptype_member_count;
 
         let mut flags = PyTypeFlags::heap_type_flags();
+
+        // Check if we may add dict
+        // We can only add a dict if the primary base class doesn't already have one
+        // In CPython, this checks tp_dictoffset == 0
+        let may_add_dict = !base.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+
         // Add HAS_DICT and MANAGED_DICT if:
-        // 1. __slots__ is not defined, OR
+        // 1. __slots__ is not defined AND base doesn't have dict, OR
         // 2. __dict__ is in __slots__
-        if heaptype_slots.is_none() || add_dict {
+        if (heaptype_slots.is_none() && may_add_dict) || add_dict {
             flags |= PyTypeFlags::HAS_DICT | PyTypeFlags::MANAGED_DICT;
         }
 
@@ -1349,6 +1355,7 @@ impl Constructor for PyType {
             let slots = PyTypeSlots {
                 flags,
                 member_count,
+                itemsize: base.slots.itemsize,
                 ..PyTypeSlots::heap_default()
             };
             let heaptype_ext = HeapTypeExt {
@@ -2009,6 +2016,11 @@ fn calculate_meta_class(
     Ok(winner)
 }
 
+/// Returns true if the two types have different instance layouts.
+fn shape_differs(t1: &Py<PyType>, t2: &Py<PyType>) -> bool {
+    t1.__basicsize__() != t2.__basicsize__() || t1.slots.itemsize != t2.slots.itemsize
+}
+
 fn solid_base<'a>(typ: &'a Py<PyType>, vm: &VirtualMachine) -> &'a Py<PyType> {
     let base = if let Some(base) = &typ.base {
         solid_base(base, vm)
@@ -2016,16 +2028,7 @@ fn solid_base<'a>(typ: &'a Py<PyType>, vm: &VirtualMachine) -> &'a Py<PyType> {
         vm.ctx.types.object_type
     };
 
-    // Check for extra instance variables (CPython's extra_ivars)
-    let t_size = typ.__basicsize__();
-    let b_size = base.__basicsize__();
-    let t_itemsize = typ.slots.itemsize;
-    let b_itemsize = base.slots.itemsize;
-
-    // Has extra ivars if: sizes differ AND (has items OR t_size > b_size)
-    let has_extra_ivars = t_size != b_size && (t_itemsize > 0 || b_itemsize > 0 || t_size > b_size);
-
-    if has_extra_ivars { typ } else { base }
+    if shape_differs(typ, base) { typ } else { base }
 }
 
 fn best_base<'a>(bases: &'a [PyTypeRef], vm: &VirtualMachine) -> PyResult<&'a Py<PyType>> {
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index a092d7097be..d52a33884ce 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -114,6 +114,7 @@ pub(super) struct PyInner<T> {
 
     pub(super) payload: T,
 }
+pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = std::mem::size_of::<PyInner<()>>();
 
 impl<T: fmt::Debug> fmt::Debug for PyInner<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/vm/src/object/mod.rs b/crates/vm/src/object/mod.rs
index 034523afe5a..a279201a0b0 100644
--- a/crates/vm/src/object/mod.rs
+++ b/crates/vm/src/object/mod.rs
@@ -7,4 +7,5 @@ mod traverse_object;
 pub use self::core::*;
 pub use self::ext::*;
 pub use self::payload::*;
+pub(crate) use core::SIZEOF_PYOBJECT_HEAD;
 pub use traverse::{MaybeTraverse, Traverse, TraverseFn};

From 04a4d1e02facaad1675b2811e33541627f1cd7e1 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 14:48:27 +0900
Subject: [PATCH 093/418] Prevent array.tofile re-entrant deadlock and add
 regression snippet (#6559)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 crates/stdlib/src/array.rs           |  6 ++++--
 extra_tests/snippets/stdlib_array.py | 17 +++++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 49ca4a89037..b51bc02d3fb 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -938,8 +938,10 @@ mod array {
             /* XXX Make the block size settable */
             const BLOCKSIZE: usize = 64 * 1024;
 
-            let bytes = self.read();
-            let bytes = bytes.get_bytes();
+            let bytes = {
+                let bytes = self.read();
+                bytes.get_bytes().to_vec()
+            };
 
             for b in bytes.chunks(BLOCKSIZE) {
                 let b = PyBytes::from(b.to_vec()).into_ref(&vm.ctx);
diff --git a/extra_tests/snippets/stdlib_array.py b/extra_tests/snippets/stdlib_array.py
index 34eac949168..ed2a8f22369 100644
--- a/extra_tests/snippets/stdlib_array.py
+++ b/extra_tests/snippets/stdlib_array.py
@@ -126,3 +126,20 @@ def test_array_frombytes():
 a = array("B", [0])
 assert a.__contains__(0)
 assert not a.__contains__(1)
+
+
+class _ReenteringWriter:
+    def __init__(self, arr):
+        self.arr = arr
+        self.reentered = False
+
+    def write(self, chunk):
+        if not self.reentered:
+            self.reentered = True
+            self.arr.append(0)
+        return len(chunk)
+
+
+arr = array("b", range(128))
+arr.tofile(_ReenteringWriter(arr))
+assert len(arr) == 129

From a37f4ec38e9edb12f0a214d666798ea3a5eb4dfe Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 15:49:10 +0900
Subject: [PATCH 094/418] upgrade shutil (#6558)

* Update shutil from v3.13.11

* fix os.remove

* fix os.fchmod

* fix is_file
---
 Lib/shutil.py                        | 288 ++++-----
 Lib/test/test_shutil.py              | 935 +++++++++++++++++----------
 crates/vm/src/stdlib/nt.rs           | 128 +++-
 crates/vm/src/stdlib/os.rs           |  56 +-
 crates/vm/src/stdlib/posix.rs        |   7 +
 crates/vm/src/stdlib/posix_compat.rs |  10 +-
 6 files changed, 881 insertions(+), 543 deletions(-)

diff --git a/Lib/shutil.py b/Lib/shutil.py
index 6803ee3ce6e..7df972012c7 100644
--- a/Lib/shutil.py
+++ b/Lib/shutil.py
@@ -10,7 +10,6 @@
 import fnmatch
 import collections
 import errno
-import warnings
 
 try:
     import zlib
@@ -48,7 +47,8 @@
 COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
 # This should never be removed, see rationale in:
 # https://bugs.python.org/issue43743#msg393429
-_USE_CP_SENDFILE = hasattr(os, "sendfile") and sys.platform.startswith("linux")
+_USE_CP_SENDFILE = (hasattr(os, "sendfile")
+                    and sys.platform.startswith(("linux", "android")))
 _HAS_FCOPYFILE = posix and hasattr(posix, "_fcopyfile")  # macOS
 
 # CMD defaults in Windows 10
@@ -153,16 +153,14 @@ def _fastcopy_sendfile(fsrc, fdst):
             err.filename = fsrc.name
             err.filename2 = fdst.name
 
-            # XXX RUSTPYTHON TODO: consistent OSError.errno
-            if hasattr(err, "errno") and err.errno == errno.ENOTSOCK:
+            if err.errno == errno.ENOTSOCK:
                 # sendfile() on this platform (probably Linux < 2.6.33)
                 # does not support copies between regular files (only
                 # sockets).
                 _USE_CP_SENDFILE = False
                 raise _GiveupOnFastCopy(err)
 
-            # XXX RUSTPYTHON TODO: consistent OSError.errno
-            if hasattr(err, "errno") and err.errno == errno.ENOSPC:  # filesystem is full
+            if err.errno == errno.ENOSPC:  # filesystem is full
                 raise err from None
 
             # Give up on first call and if no data was copied.
@@ -304,16 +302,17 @@ def copymode(src, dst, *, follow_symlinks=True):
     sys.audit("shutil.copymode", src, dst)
 
     if not follow_symlinks and _islink(src) and os.path.islink(dst):
-        if os.name == 'nt':
-            stat_func, chmod_func = os.lstat, os.chmod
-        elif hasattr(os, 'lchmod'):
+        if hasattr(os, 'lchmod'):
             stat_func, chmod_func = os.lstat, os.lchmod
         else:
             return
     else:
+        stat_func = _stat
         if os.name == 'nt' and os.path.islink(dst):
-            dst = os.path.realpath(dst, strict=True)
-        stat_func, chmod_func = _stat, os.chmod
+            def chmod_func(*args):
+                os.chmod(*args, follow_symlinks=True)
+        else:
+            chmod_func = os.chmod
 
     st = stat_func(src)
     chmod_func(dst, stat.S_IMODE(st.st_mode))
@@ -388,16 +387,8 @@ def lookup(name):
     # We must copy extended attributes before the file is (potentially)
     # chmod()'ed read-only, otherwise setxattr() will error with -EACCES.
     _copyxattr(src, dst, follow_symlinks=follow)
-    _chmod = lookup("chmod")
-    if os.name == 'nt':
-        if follow:
-            if os.path.islink(dst):
-                dst = os.path.realpath(dst, strict=True)
-        else:
-            def _chmod(*args, **kwargs):
-                os.chmod(*args)
     try:
-        _chmod(dst, mode, follow_symlinks=follow)
+        lookup("chmod")(dst, mode, follow_symlinks=follow)
     except NotImplementedError:
         # if we got a NotImplementedError, it's because
         #   * follow_symlinks=False,
@@ -565,7 +556,7 @@ def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
     If the optional symlinks flag is true, symbolic links in the
     source tree result in symbolic links in the destination tree; if
     it is false, the contents of the files pointed to by symbolic
-    links are copied. If the file pointed by the symlink doesn't
+    links are copied. If the file pointed to by the symlink doesn't
     exist, an exception will be added in the list of errors raised in
     an Error exception at the end of the copy process.
 
@@ -605,118 +596,115 @@ def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
                      dirs_exist_ok=dirs_exist_ok)
 
 if hasattr(os.stat_result, 'st_file_attributes'):
-    def _rmtree_islink(path):
-        try:
-            st = os.lstat(path)
-            return (stat.S_ISLNK(st.st_mode) or
-                (st.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
-                 and st.st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT))
-        except OSError:
-            return False
+    def _rmtree_islink(st):
+        return (stat.S_ISLNK(st.st_mode) or
+            (st.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
+                and st.st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT))
 else:
-    def _rmtree_islink(path):
-        return os.path.islink(path)
+    def _rmtree_islink(st):
+        return stat.S_ISLNK(st.st_mode)
 
 # version vulnerable to race conditions
 def _rmtree_unsafe(path, onexc):
-    try:
-        with os.scandir(path) as scandir_it:
-            entries = list(scandir_it)
-    except OSError as err:
-        onexc(os.scandir, path, err)
-        entries = []
-    for entry in entries:
-        fullname = entry.path
-        try:
-            is_dir = entry.is_dir(follow_symlinks=False)
-        except OSError:
-            is_dir = False
-
-        if is_dir and not entry.is_junction():
+    def onerror(err):
+        if not isinstance(err, FileNotFoundError):
+            onexc(os.scandir, err.filename, err)
+    results = os.walk(path, topdown=False, onerror=onerror, followlinks=os._walk_symlinks_as_files)
+    for dirpath, dirnames, filenames in results:
+        for name in dirnames:
+            fullname = os.path.join(dirpath, name)
             try:
-                if entry.is_symlink():
-                    # This can only happen if someone replaces
-                    # a directory with a symlink after the call to
-                    # os.scandir or entry.is_dir above.
-                    raise OSError("Cannot call rmtree on a symbolic link")
-            except OSError as err:
-                onexc(os.path.islink, fullname, err)
+                os.rmdir(fullname)
+            except FileNotFoundError:
                 continue
-            _rmtree_unsafe(fullname, onexc)
-        else:
+            except OSError as err:
+                onexc(os.rmdir, fullname, err)
+        for name in filenames:
+            fullname = os.path.join(dirpath, name)
             try:
                 os.unlink(fullname)
+            except FileNotFoundError:
+                continue
             except OSError as err:
                 onexc(os.unlink, fullname, err)
     try:
         os.rmdir(path)
+    except FileNotFoundError:
+        pass
     except OSError as err:
         onexc(os.rmdir, path, err)
 
 # Version using fd-based APIs to protect against races
-def _rmtree_safe_fd(topfd, path, onexc):
+def _rmtree_safe_fd(stack, onexc):
+    # Each stack item has four elements:
+    # * func: The first operation to perform: os.lstat, os.close or os.rmdir.
+    #   Walking a directory starts with an os.lstat() to detect symlinks; in
+    #   this case, func is updated before subsequent operations and passed to
+    #   onexc() if an error occurs.
+    # * dirfd: Open file descriptor, or None if we're processing the top-level
+    #   directory given to rmtree() and the user didn't supply dir_fd.
+    # * path: Path of file to operate upon. This is passed to onexc() if an
+    #   error occurs.
+    # * orig_entry: os.DirEntry, or None if we're processing the top-level
+    #   directory given to rmtree(). We used the cached stat() of the entry to
+    #   save a call to os.lstat() when walking subdirectories.
+    func, dirfd, path, orig_entry = stack.pop()
+    name = path if orig_entry is None else orig_entry.name
     try:
+        if func is os.close:
+            os.close(dirfd)
+            return
+        if func is os.rmdir:
+            os.rmdir(name, dir_fd=dirfd)
+            return
+
+        # Note: To guard against symlink races, we use the standard
+        # lstat()/open()/fstat() trick.
+        assert func is os.lstat
+        if orig_entry is None:
+            orig_st = os.lstat(name, dir_fd=dirfd)
+        else:
+            orig_st = orig_entry.stat(follow_symlinks=False)
+
+        func = os.open  # For error reporting.
+        topfd = os.open(name, os.O_RDONLY | os.O_NONBLOCK, dir_fd=dirfd)
+
+        func = os.path.islink  # For error reporting.
+        try:
+            if not os.path.samestat(orig_st, os.fstat(topfd)):
+                # Symlinks to directories are forbidden, see GH-46010.
+                raise OSError("Cannot call rmtree on a symbolic link")
+            stack.append((os.rmdir, dirfd, path, orig_entry))
+        finally:
+            stack.append((os.close, topfd, path, orig_entry))
+
+        func = os.scandir  # For error reporting.
         with os.scandir(topfd) as scandir_it:
             entries = list(scandir_it)
-    except OSError as err:
-        err.filename = path
-        onexc(os.scandir, path, err)
-        return
-    for entry in entries:
-        fullname = os.path.join(path, entry.name)
-        try:
-            is_dir = entry.is_dir(follow_symlinks=False)
-        except OSError:
-            is_dir = False
-        else:
-            if is_dir:
-                try:
-                    orig_st = entry.stat(follow_symlinks=False)
-                    is_dir = stat.S_ISDIR(orig_st.st_mode)
-                except OSError as err:
-                    onexc(os.lstat, fullname, err)
-                    continue
-        if is_dir:
+        for entry in entries:
+            fullname = os.path.join(path, entry.name)
             try:
-                dirfd = os.open(entry.name, os.O_RDONLY | os.O_NONBLOCK, dir_fd=topfd)
-                dirfd_closed = False
-            except OSError as err:
-                onexc(os.open, fullname, err)
-            else:
-                try:
-                    if os.path.samestat(orig_st, os.fstat(dirfd)):
-                        _rmtree_safe_fd(dirfd, fullname, onexc)
-                        try:
-                            os.close(dirfd)
-                        except OSError as err:
-                            # close() should not be retried after an error.
-                            dirfd_closed = True
-                            onexc(os.close, fullname, err)
-                        dirfd_closed = True
-                        try:
-                            os.rmdir(entry.name, dir_fd=topfd)
-                        except OSError as err:
-                            onexc(os.rmdir, fullname, err)
-                    else:
-                        try:
-                            # This can only happen if someone replaces
-                            # a directory with a symlink after the call to
-                            # os.scandir or stat.S_ISDIR above.
-                            raise OSError("Cannot call rmtree on a symbolic "
-                                          "link")
-                        except OSError as err:
-                            onexc(os.path.islink, fullname, err)
-                finally:
-                    if not dirfd_closed:
-                        try:
-                            os.close(dirfd)
-                        except OSError as err:
-                            onexc(os.close, fullname, err)
-        else:
+                if entry.is_dir(follow_symlinks=False):
+                    # Traverse into sub-directory.
+                    stack.append((os.lstat, topfd, fullname, entry))
+                    continue
+            except FileNotFoundError:
+                continue
+            except OSError:
+                pass
             try:
                 os.unlink(entry.name, dir_fd=topfd)
+            except FileNotFoundError:
+                continue
             except OSError as err:
                 onexc(os.unlink, fullname, err)
+    except FileNotFoundError as err:
+        if orig_entry is None or func is os.close:
+            err.filename = path
+            onexc(func, path, err)
+    except OSError as err:
+        err.filename = path
+        onexc(func, path, err)
 
 _use_fd_functions = ({os.open, os.stat, os.unlink, os.rmdir} <=
                      os.supports_dir_fd and
@@ -769,41 +757,16 @@ def onexc(*args):
         # While the unsafe rmtree works fine on bytes, the fd based does not.
         if isinstance(path, bytes):
             path = os.fsdecode(path)
-        # Note: To guard against symlink races, we use the standard
-        # lstat()/open()/fstat() trick.
-        try:
-            orig_st = os.lstat(path, dir_fd=dir_fd)
-        except Exception as err:
-            onexc(os.lstat, path, err)
-            return
+        stack = [(os.lstat, dir_fd, path, None)]
         try:
-            fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK, dir_fd=dir_fd)
-            fd_closed = False
-        except Exception as err:
-            onexc(os.open, path, err)
-            return
-        try:
-            if os.path.samestat(orig_st, os.fstat(fd)):
-                _rmtree_safe_fd(fd, path, onexc)
-                try:
-                    os.close(fd)
-                except OSError as err:
-                    # close() should not be retried after an error.
-                    fd_closed = True
-                    onexc(os.close, path, err)
-                fd_closed = True
-                try:
-                    os.rmdir(path, dir_fd=dir_fd)
-                except OSError as err:
-                    onexc(os.rmdir, path, err)
-            else:
-                try:
-                    # symlinks to directories are forbidden, see bug #1669
-                    raise OSError("Cannot call rmtree on a symbolic link")
-                except OSError as err:
-                    onexc(os.path.islink, path, err)
+            while stack:
+                _rmtree_safe_fd(stack, onexc)
         finally:
-            if not fd_closed:
+            # Close any file descriptors still on the stack.
+            while stack:
+                func, fd, path, entry = stack.pop()
+                if func is not os.close:
+                    continue
                 try:
                     os.close(fd)
                 except OSError as err:
@@ -812,7 +775,12 @@ def onexc(*args):
         if dir_fd is not None:
             raise NotImplementedError("dir_fd unavailable on this platform")
         try:
-            if _rmtree_islink(path):
+            st = os.lstat(path)
+        except OSError as err:
+            onexc(os.lstat, path, err)
+            return
+        try:
+            if _rmtree_islink(st):
                 # symlinks to directories are forbidden, see bug #1669
                 raise OSError("Cannot call rmtree on a symbolic link")
         except OSError as err:
@@ -1428,11 +1396,18 @@ def disk_usage(path):
         return _ntuple_diskusage(total, used, free)
 
 
-def chown(path, user=None, group=None):
+def chown(path, user=None, group=None, *, dir_fd=None, follow_symlinks=True):
     """Change owner user and group of the given path.
 
     user and group can be the uid/gid or the user/group names, and in that case,
     they are converted to their respective uid/gid.
+
+    If dir_fd is set, it should be an open file descriptor to the directory to
+    be used as the root of *path* if it is relative.
+
+    If follow_symlinks is set to False and the last element of the path is a
+    symbolic link, chown will modify the link itself and not the file being
+    referenced by the link.
     """
     sys.audit('shutil.chown', path, user, group)
 
@@ -1458,7 +1433,8 @@ def chown(path, user=None, group=None):
         if _group is None:
             raise LookupError("no such group: {!r}".format(group))
 
-    os.chown(path, _user, _group)
+    os.chown(path, _user, _group, dir_fd=dir_fd,
+             follow_symlinks=follow_symlinks)
 
 def get_terminal_size(fallback=(80, 24)):
     """Get the size of the terminal window.
@@ -1575,21 +1551,21 @@ def which(cmd, mode=os.F_OK | os.X_OK, path=None):
     if sys.platform == "win32":
         # PATHEXT is necessary to check on Windows.
         pathext_source = os.getenv("PATHEXT") or _WIN_DEFAULT_PATHEXT
-        pathext = [ext for ext in pathext_source.split(os.pathsep) if ext]
+        pathext = pathext_source.split(os.pathsep)
+        pathext = [ext.rstrip('.') for ext in pathext if ext]
 
         if use_bytes:
             pathext = [os.fsencode(ext) for ext in pathext]
 
-        files = ([cmd] + [cmd + ext for ext in pathext])
+        files = [cmd + ext for ext in pathext]
 
-        # gh-109590. If we are looking for an executable, we need to look
-        # for a PATHEXT match. The first cmd is the direct match
-        # (e.g. python.exe instead of python)
-        # Check that direct match first if and only if the extension is in PATHEXT
-        # Otherwise check it last
-        suffix = os.path.splitext(files[0])[1].upper()
-        if mode & os.X_OK and not any(suffix == ext.upper() for ext in pathext):
-            files.append(files.pop(0))
+        # If X_OK in mode, simulate the cmd.exe behavior: look at direct
+        # match if and only if the extension is in PATHEXT.
+        # If X_OK not in mode, simulate the first result of where.exe:
+        # always look at direct match before a PATHEXT match.
+        normcmd = cmd.upper()
+        if not (mode & os.X_OK) or any(normcmd.endswith(ext.upper()) for ext in pathext):
+            files.insert(0, cmd)
     else:
         # On other platforms you don't have things like PATHEXT to tell you
         # what file suffixes are executable, so just pass on cmd as-is.
@@ -1598,7 +1574,7 @@ def which(cmd, mode=os.F_OK | os.X_OK, path=None):
     seen = set()
     for dir in path:
         normdir = os.path.normcase(dir)
-        if not normdir in seen:
+        if normdir not in seen:
             seen.add(normdir)
             for thefile in files:
                 name = os.path.join(dir, thefile)
diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py
index ad67583d438..73ad81e871b 100644
--- a/Lib/test/test_shutil.py
+++ b/Lib/test/test_shutil.py
@@ -23,7 +23,6 @@
                     unregister_unpack_format, get_unpack_formats,
                     SameFileError, _GiveupOnFastCopy)
 import tarfile
-import warnings
 import zipfile
 try:
     import posix
@@ -71,18 +70,17 @@ def wrap(*args, **kwargs):
             os.rename = builtin_rename
     return wrap
 
-def write_file(path, content, binary=False):
+def create_file(path, content=b''):
     """Write *content* to a file located at *path*.
 
     If *path* is a tuple instead of a string, os.path.join will be used to
-    make a path.  If *binary* is true, the file will be opened in binary
-    mode.
+    make a path.
     """
     if isinstance(path, tuple):
         path = os.path.join(*path)
-    mode = 'wb' if binary else 'w'
-    encoding = None if binary else "utf-8"
-    with open(path, mode, encoding=encoding) as fp:
+    if isinstance(content, str):
+        content = content.encode()
+    with open(path, 'xb') as fp:
         fp.write(content)
 
 def write_test_file(path, size):
@@ -191,7 +189,7 @@ def test_rmtree_works_on_bytes(self):
         tmp = self.mkdtemp()
         victim = os.path.join(tmp, 'killme')
         os.mkdir(victim)
-        write_file(os.path.join(victim, 'somefile'), 'foo')
+        create_file(os.path.join(victim, 'somefile'), 'foo')
         victim = os.fsencode(victim)
         self.assertIsInstance(victim, bytes)
         shutil.rmtree(victim)
@@ -244,7 +242,7 @@ def test_rmtree_works_on_symlinks(self):
         for d in dir1, dir2, dir3:
             os.mkdir(d)
         file1 = os.path.join(tmp, 'file1')
-        write_file(file1, 'foo')
+        create_file(file1, 'foo')
         link1 = os.path.join(dir1, 'link1')
         os.symlink(dir2, link1)
         link2 = os.path.join(dir1, 'link2')
@@ -306,7 +304,7 @@ def test_rmtree_works_on_junctions(self):
         for d in dir1, dir2, dir3:
             os.mkdir(d)
         file1 = os.path.join(tmp, 'file1')
-        write_file(file1, 'foo')
+        create_file(file1, 'foo')
         link1 = os.path.join(dir1, 'link1')
         _winapi.CreateJunction(dir2, link1)
         link2 = os.path.join(dir1, 'link2')
@@ -319,7 +317,7 @@ def test_rmtree_works_on_junctions(self):
         self.assertTrue(os.path.exists(dir3))
         self.assertTrue(os.path.exists(file1))
 
-    def test_rmtree_errors_onerror(self):
+    def test_rmtree_errors(self):
         # filename is guaranteed not to exist
         filename = tempfile.mktemp(dir=self.mkdtemp())
         self.assertRaises(FileNotFoundError, shutil.rmtree, filename)
@@ -328,8 +326,8 @@ def test_rmtree_errors_onerror(self):
 
         # existing file
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, "tstfile"), "")
         filename = os.path.join(tmpdir, "tstfile")
+        create_file(filename)
         with self.assertRaises(NotADirectoryError) as cm:
             shutil.rmtree(filename)
         self.assertEqual(cm.exception.filename, filename)
@@ -337,6 +335,19 @@ def test_rmtree_errors_onerror(self):
         # test that ignore_errors option is honored
         shutil.rmtree(filename, ignore_errors=True)
         self.assertTrue(os.path.exists(filename))
+
+        self.assertRaises(TypeError, shutil.rmtree, None)
+        self.assertRaises(TypeError, shutil.rmtree, None, ignore_errors=True)
+        exc = TypeError if shutil.rmtree.avoids_symlink_attacks else NotImplementedError
+        with self.assertRaises(exc):
+            shutil.rmtree(filename, dir_fd='invalid')
+        with self.assertRaises(exc):
+            shutil.rmtree(filename, dir_fd='invalid', ignore_errors=True)
+
+    def test_rmtree_errors_onerror(self):
+        tmpdir = self.mkdtemp()
+        filename = os.path.join(tmpdir, "tstfile")
+        create_file(filename)
         errors = []
         def onerror(*args):
             errors.append(args)
@@ -352,23 +363,9 @@ def onerror(*args):
         self.assertEqual(errors[1][2][1].filename, filename)
 
     def test_rmtree_errors_onexc(self):
-        # filename is guaranteed not to exist
-        filename = tempfile.mktemp(dir=self.mkdtemp())
-        self.assertRaises(FileNotFoundError, shutil.rmtree, filename)
-        # test that ignore_errors option is honored
-        shutil.rmtree(filename, ignore_errors=True)
-
-        # existing file
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, "tstfile"), "")
         filename = os.path.join(tmpdir, "tstfile")
-        with self.assertRaises(NotADirectoryError) as cm:
-            shutil.rmtree(filename)
-        self.assertEqual(cm.exception.filename, filename)
-        self.assertTrue(os.path.exists(filename))
-        # test that ignore_errors option is honored
-        shutil.rmtree(filename, ignore_errors=True)
-        self.assertTrue(os.path.exists(filename))
+        create_file(filename)
         errors = []
         def onexc(*args):
             errors.append(args)
@@ -550,7 +547,7 @@ def raiser(fn, *args, **kwargs):
             os.lstat = raiser
 
             os.mkdir(TESTFN)
-            write_file((TESTFN, 'foo'), 'foo')
+            create_file((TESTFN, 'foo'), 'foo')
             shutil.rmtree(TESTFN)
         finally:
             os.lstat = orig_lstat
@@ -623,7 +620,7 @@ def test_rmtree_with_dir_fd(self):
         self.addCleanup(os.close, dir_fd)
         os.mkdir(fullname)
         os.mkdir(os.path.join(fullname, 'subdir'))
-        write_file(os.path.join(fullname, 'subdir', 'somefile'), 'foo')
+        create_file(os.path.join(fullname, 'subdir', 'somefile'), 'foo')
         self.assertTrue(os.path.exists(fullname))
         shutil.rmtree(victim, dir_fd=dir_fd)
         self.assertFalse(os.path.exists(fullname))
@@ -663,7 +660,7 @@ def test_rmtree_on_junction(self):
             src = os.path.join(TESTFN, 'cheese')
             dst = os.path.join(TESTFN, 'shop')
             os.mkdir(src)
-            open(os.path.join(src, 'spam'), 'wb').close()
+            create_file(os.path.join(src, 'spam'))
             _winapi.CreateJunction(src, dst)
             self.assertRaises(OSError, shutil.rmtree, dst)
             shutil.rmtree(dst, ignore_errors=True)
@@ -687,6 +684,73 @@ def test_rmtree_on_named_pipe(self):
         shutil.rmtree(TESTFN)
         self.assertFalse(os.path.exists(TESTFN))
 
+    @unittest.skipIf(sys.platform[:6] == 'cygwin',
+                     "This test can't be run on Cygwin (issue #1071513).")
+    @os_helper.skip_if_dac_override
+    @os_helper.skip_unless_working_chmod
+    def test_rmtree_deleted_race_condition(self):
+        # bpo-37260
+        #
+        # Test that a file or a directory deleted after it is enumerated
+        # by scandir() but before unlink() or rmdr() is called doesn't
+        # generate any errors.
+        def _onexc(fn, path, exc):
+            assert fn in (os.rmdir, os.unlink)
+            if not isinstance(exc, PermissionError):
+                raise
+            # Make the parent and the children writeable.
+            for p, mode in zip(paths, old_modes):
+                os.chmod(p, mode)
+            # Remove other dirs except one.
+            keep = next(p for p in dirs if p != path)
+            for p in dirs:
+                if p != keep:
+                    os.rmdir(p)
+            # Remove other files except one.
+            keep = next(p for p in files if p != path)
+            for p in files:
+                if p != keep:
+                    os.unlink(p)
+
+        os.mkdir(TESTFN)
+        paths = [TESTFN] + [os.path.join(TESTFN, f'child{i}')
+                            for i in range(6)]
+        dirs = paths[1::2]
+        files = paths[2::2]
+        for path in dirs:
+            os.mkdir(path)
+        for path in files:
+            create_file(path)
+
+        old_modes = [os.stat(path).st_mode for path in paths]
+
+        # Make the parent and the children non-writeable.
+        new_mode = stat.S_IREAD|stat.S_IEXEC
+        for path in reversed(paths):
+            os.chmod(path, new_mode)
+
+        try:
+            shutil.rmtree(TESTFN, onexc=_onexc)
+        except:
+            # Test failed, so cleanup artifacts.
+            for path, mode in zip(paths, old_modes):
+                try:
+                    os.chmod(path, mode)
+                except OSError:
+                    pass
+            shutil.rmtree(TESTFN)
+            raise
+
+    def test_rmtree_above_recursion_limit(self):
+        recursion_limit = 40
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = os.path.join(TESTFN, *(['d'] * directory_depth))
+        os.makedirs(base)
+
+        with support.infinite_recursion(recursion_limit):
+            shutil.rmtree(TESTFN)
+
 
 class TestCopyTree(BaseTest, unittest.TestCase):
 
@@ -695,9 +759,9 @@ def test_copytree_simple(self):
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
         self.addCleanup(shutil.rmtree, src_dir)
         self.addCleanup(shutil.rmtree, os.path.dirname(dst_dir))
-        write_file((src_dir, 'test.txt'), '123')
+        create_file((src_dir, 'test.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'test_dir'))
-        write_file((src_dir, 'test_dir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'test.txt'), '456')
 
         shutil.copytree(src_dir, dst_dir)
         self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'test.txt')))
@@ -715,11 +779,11 @@ def test_copytree_dirs_exist_ok(self):
         self.addCleanup(shutil.rmtree, src_dir)
         self.addCleanup(shutil.rmtree, dst_dir)
 
-        write_file((src_dir, 'nonexisting.txt'), '123')
+        create_file((src_dir, 'nonexisting.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'existing_dir'))
         os.mkdir(os.path.join(dst_dir, 'existing_dir'))
-        write_file((dst_dir, 'existing_dir', 'existing.txt'), 'will be replaced')
-        write_file((src_dir, 'existing_dir', 'existing.txt'), 'has been replaced')
+        create_file((dst_dir, 'existing_dir', 'existing.txt'), 'will be replaced')
+        create_file((src_dir, 'existing_dir', 'existing.txt'), 'has been replaced')
 
         shutil.copytree(src_dir, dst_dir, dirs_exist_ok=True)
         self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'nonexisting.txt')))
@@ -742,7 +806,7 @@ def test_copytree_symlinks(self):
         sub_dir = os.path.join(src_dir, 'sub')
         os.mkdir(src_dir)
         os.mkdir(sub_dir)
-        write_file((src_dir, 'file.txt'), 'foo')
+        create_file((src_dir, 'file.txt'), 'foo')
         src_link = os.path.join(sub_dir, 'link')
         dst_link = os.path.join(dst_dir, 'sub/link')
         os.symlink(os.path.join(src_dir, 'file.txt'),
@@ -773,16 +837,16 @@ def test_copytree_with_exclude(self):
         src_dir = self.mkdtemp()
         try:
             dst_dir = join(self.mkdtemp(), 'destination')
-            write_file((src_dir, 'test.txt'), '123')
-            write_file((src_dir, 'test.tmp'), '123')
+            create_file((src_dir, 'test.txt'), '123')
+            create_file((src_dir, 'test.tmp'), '123')
             os.mkdir(join(src_dir, 'test_dir'))
-            write_file((src_dir, 'test_dir', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir', 'test.txt'), '456')
             os.mkdir(join(src_dir, 'test_dir2'))
-            write_file((src_dir, 'test_dir2', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir2', 'test.txt'), '456')
             os.mkdir(join(src_dir, 'test_dir2', 'subdir'))
             os.mkdir(join(src_dir, 'test_dir2', 'subdir2'))
-            write_file((src_dir, 'test_dir2', 'subdir', 'test.txt'), '456')
-            write_file((src_dir, 'test_dir2', 'subdir2', 'test.py'), '456')
+            create_file((src_dir, 'test_dir2', 'subdir', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir2', 'subdir2', 'test.py'), '456')
 
             # testing glob-like patterns
             try:
@@ -841,7 +905,7 @@ def test_copytree_arg_types_of_ignore(self):
         os.mkdir(join(src_dir))
         os.mkdir(join(src_dir, 'test_dir'))
         os.mkdir(os.path.join(src_dir, 'test_dir', 'subdir'))
-        write_file((src_dir, 'test_dir', 'subdir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'subdir', 'test.txt'), '456')
 
         invokations = []
 
@@ -860,7 +924,7 @@ def _ignore(src, names):
                                     'test.txt')))
 
         dst_dir = join(self.mkdtemp(), 'destination')
-        shutil.copytree(pathlib.Path(src_dir), dst_dir, ignore=_ignore)
+        shutil.copytree(FakePath(src_dir), dst_dir, ignore=_ignore)
         self.assertTrue(exists(join(dst_dir, 'test_dir', 'subdir',
                                     'test.txt')))
 
@@ -881,9 +945,9 @@ def test_copytree_retains_permissions(self):
         self.addCleanup(shutil.rmtree, tmp_dir)
 
         os.chmod(src_dir, 0o777)
-        write_file((src_dir, 'permissive.txt'), '123')
+        create_file((src_dir, 'permissive.txt'), '123')
         os.chmod(os.path.join(src_dir, 'permissive.txt'), 0o777)
-        write_file((src_dir, 'restrictive.txt'), '456')
+        create_file((src_dir, 'restrictive.txt'), '456')
         os.chmod(os.path.join(src_dir, 'restrictive.txt'), 0o600)
         restrictive_subdir = tempfile.mkdtemp(dir=src_dir)
         self.addCleanup(os_helper.rmtree, restrictive_subdir)
@@ -926,8 +990,7 @@ def custom_cpfun(a, b):
         flag = []
         src = self.mkdtemp()
         dst = tempfile.mktemp(dir=self.mkdtemp())
-        with open(os.path.join(src, 'foo'), 'w', encoding='utf-8') as f:
-            f.close()
+        create_file(os.path.join(src, 'foo'))
         shutil.copytree(src, dst, copy_function=custom_cpfun)
         self.assertEqual(len(flag), 1)
 
@@ -962,9 +1025,9 @@ def test_copytree_named_pipe(self):
     def test_copytree_special_func(self):
         src_dir = self.mkdtemp()
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
-        write_file((src_dir, 'test.txt'), '123')
+        create_file((src_dir, 'test.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'test_dir'))
-        write_file((src_dir, 'test_dir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'test.txt'), '456')
 
         copied = []
         def _copy(src, dst):
@@ -977,7 +1040,7 @@ def _copy(src, dst):
     def test_copytree_dangling_symlinks(self):
         src_dir = self.mkdtemp()
         valid_file = os.path.join(src_dir, 'test.txt')
-        write_file(valid_file, 'abc')
+        create_file(valid_file, 'abc')
         dir_a = os.path.join(src_dir, 'dir_a')
         os.mkdir(dir_a)
         for d in src_dir, dir_a:
@@ -1005,8 +1068,7 @@ def test_copytree_symlink_dir(self):
         src_dir = self.mkdtemp()
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
         os.mkdir(os.path.join(src_dir, 'real_dir'))
-        with open(os.path.join(src_dir, 'real_dir', 'test.txt'), 'wb'):
-            pass
+        create_file(os.path.join(src_dir, 'real_dir', 'test.txt'))
         os.symlink(os.path.join(src_dir, 'real_dir'),
                    os.path.join(src_dir, 'link_to_dir'),
                    target_is_directory=True)
@@ -1026,7 +1088,7 @@ def test_copytree_return_value(self):
         dst_dir = src_dir + "dest"
         self.addCleanup(shutil.rmtree, dst_dir, True)
         src = os.path.join(src_dir, 'foo')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         rv = shutil.copytree(src_dir, dst_dir)
         self.assertEqual(['foo'], os.listdir(rv))
 
@@ -1038,7 +1100,7 @@ def test_copytree_subdirectory(self):
         dst_dir = os.path.join(src_dir, "somevendor", "1.0")
         os.makedirs(src_dir)
         src = os.path.join(src_dir, 'pol')
-        write_file(src, 'pol')
+        create_file(src, 'pol')
         rv = shutil.copytree(src_dir, dst_dir)
         self.assertEqual(['pol'], os.listdir(rv))
 
@@ -1053,8 +1115,8 @@ def test_copymode_follow_symlinks(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         os.chmod(src, stat.S_IRWXU|stat.S_IRWXG)
@@ -1077,35 +1139,34 @@ def test_copymode_follow_symlinks(self):
         shutil.copymode(src_link, dst_link)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
 
-    @unittest.skipUnless(hasattr(os, 'lchmod') or os.name == 'nt', 'requires os.lchmod')
+    @unittest.skipUnless(hasattr(os, 'lchmod'), 'requires os.lchmod')
     @os_helper.skip_unless_symlink
     def test_copymode_symlink_to_symlink(self):
-        _lchmod = os.chmod if os.name == 'nt' else os.lchmod
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         os.chmod(src, stat.S_IRWXU|stat.S_IRWXG)
         os.chmod(dst, stat.S_IRWXU)
-        _lchmod(src_link, stat.S_IRWXO|stat.S_IRWXG)
+        os.lchmod(src_link, stat.S_IRWXO|stat.S_IRWXG)
         # link to link
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         old_mode = os.stat(dst).st_mode
         shutil.copymode(src_link, dst_link, follow_symlinks=False)
         self.assertEqual(os.lstat(src_link).st_mode,
                          os.lstat(dst_link).st_mode)
         self.assertEqual(os.stat(dst).st_mode, old_mode)
         # src link - use chmod
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         shutil.copymode(src_link, dst, follow_symlinks=False)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
         # dst link - use chmod
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         shutil.copymode(src, dst_link, follow_symlinks=False)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
 
@@ -1117,8 +1178,8 @@ def test_copymode_symlink_to_symlink_wo_lchmod(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         shutil.copymode(src_link, dst_link, follow_symlinks=False)  # silent fail
@@ -1132,23 +1193,21 @@ def test_copystat_symlinks(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'qux')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         src_stat = os.stat(src)
         os.utime(src, (src_stat.st_atime,
                        src_stat.st_mtime - 42.0))  # ensure different mtimes
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         self.assertNotEqual(os.stat(src).st_mtime, os.stat(dst).st_mtime)
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXO)
-        elif os.name == 'nt':
-            os.chmod(src_link, stat.S_IRWXO)
         if hasattr(os, 'lchflags') and hasattr(stat, 'UF_NODUMP'):
             os.lchflags(src_link, stat.UF_NODUMP)
         src_link_stat = os.lstat(src_link)
         # follow
-        if hasattr(os, 'lchmod') or os.name == 'nt':
+        if hasattr(os, 'lchmod'):
             shutil.copystat(src_link, dst_link, follow_symlinks=True)
             self.assertNotEqual(src_link_stat.st_mode, os.stat(dst).st_mode)
         # don't follow
@@ -1159,7 +1218,7 @@ def test_copystat_symlinks(self):
                 # The modification times may be truncated in the new file.
                 self.assertLessEqual(getattr(src_link_stat, attr),
                                      getattr(dst_link_stat, attr) + 1)
-        if hasattr(os, 'lchmod') or os.name == 'nt':
+        if hasattr(os, 'lchmod'):
             self.assertEqual(src_link_stat.st_mode, dst_link_stat.st_mode)
         if hasattr(os, 'lchflags') and hasattr(src_link_stat, 'st_flags'):
             self.assertEqual(src_link_stat.st_flags, dst_link_stat.st_flags)
@@ -1176,8 +1235,8 @@ def test_copystat_handles_harmless_chflags_errors(self):
         tmpdir = self.mkdtemp()
         file1 = os.path.join(tmpdir, 'file1')
         file2 = os.path.join(tmpdir, 'file2')
-        write_file(file1, 'xxx')
-        write_file(file2, 'xxx')
+        create_file(file1, 'xxx')
+        create_file(file2, 'xxx')
 
         def make_chflags_raiser(err):
             ex = OSError()
@@ -1203,9 +1262,9 @@ def _chflags_raiser(path, flags, *, follow_symlinks=True):
     def test_copyxattr(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
 
         # no xattr == no problem
         shutil._copyxattr(src, dst)
@@ -1219,7 +1278,7 @@ def test_copyxattr(self):
                 os.getxattr(dst, 'user.foo'))
         # check errors don't affect other attrs
         os.remove(dst)
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         os_error = OSError(errno.EPERM, 'EPERM')
 
         def _raise_on_user_foo(fname, attr, val, **kwargs):
@@ -1249,15 +1308,15 @@ def _raise_on_src(fname, *, follow_symlinks=True):
         # test that shutil.copystat copies xattrs
         src = os.path.join(tmp_dir, 'the_original')
         srcro = os.path.join(tmp_dir, 'the_original_ro')
-        write_file(src, src)
-        write_file(srcro, srcro)
+        create_file(src, src)
+        create_file(srcro, srcro)
         os.setxattr(src, 'user.the_value', b'fiddly')
         os.setxattr(srcro, 'user.the_value', b'fiddly')
         os.chmod(srcro, 0o444)
         dst = os.path.join(tmp_dir, 'the_copy')
         dstro = os.path.join(tmp_dir, 'the_copy_ro')
-        write_file(dst, dst)
-        write_file(dstro, dstro)
+        create_file(dst, dst)
+        create_file(dstro, dstro)
         shutil.copystat(src, dst)
         shutil.copystat(srcro, dstro)
         self.assertEqual(os.getxattr(dst, 'user.the_value'), b'fiddly')
@@ -1273,13 +1332,13 @@ def test_copyxattr_symlinks(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         os.setxattr(src, 'trusted.foo', b'42')
         os.setxattr(src_link, 'trusted.foo', b'43', follow_symlinks=False)
         dst = os.path.join(tmp_dir, 'bar')
         dst_link = os.path.join(tmp_dir, 'qux')
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         os.symlink(dst, dst_link)
         shutil._copyxattr(src_link, dst_link, follow_symlinks=False)
         self.assertEqual(os.getxattr(dst_link, 'trusted.foo', follow_symlinks=False), b'43')
@@ -1292,7 +1351,7 @@ def test_copyxattr_symlinks(self):
     def _copy_file(self, method):
         fname = 'test.txt'
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, fname), 'xxx')
+        create_file((tmpdir, fname), 'xxx')
         file1 = os.path.join(tmpdir, fname)
         tmpdir2 = self.mkdtemp()
         method(file1, tmpdir2)
@@ -1311,7 +1370,7 @@ def test_copy_symlinks(self):
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
@@ -1353,7 +1412,7 @@ def test_copy2_symlinks(self):
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
@@ -1387,7 +1446,7 @@ def test_copy2_xattr(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.setxattr(src, 'user.foo', b'42')
         shutil.copy2(src, dst)
         self.assertEqual(
@@ -1401,7 +1460,7 @@ def test_copy_return_value(self):
             src_dir = self.mkdtemp()
             dst_dir = self.mkdtemp()
             src = os.path.join(src_dir, 'foo')
-            write_file(src, 'foo')
+            create_file(src, 'foo')
             rv = fn(src, dst_dir)
             self.assertEqual(rv, os.path.join(dst_dir, 'foo'))
             rv = fn(src, os.path.join(dst_dir, 'bar'))
@@ -1418,7 +1477,7 @@ def _test_copy_dir(self, copy_func):
         src_file = os.path.join(src_dir, 'foo')
         dir2 = self.mkdtemp()
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         if sys.platform == "win32":
             err = PermissionError
         else:
@@ -1438,7 +1497,7 @@ def test_copyfile_symlinks(self):
         dst = os.path.join(tmp_dir, 'dst')
         dst_link = os.path.join(tmp_dir, 'dst_link')
         link = os.path.join(tmp_dir, 'link')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, link)
         # don't follow
         shutil.copyfile(link, dst_link, follow_symlinks=False)
@@ -1455,8 +1514,7 @@ def test_dont_copy_file_onto_link_to_itself(self):
         src = os.path.join(TESTFN, 'cheese')
         dst = os.path.join(TESTFN, 'shop')
         try:
-            with open(src, 'w', encoding='utf-8') as f:
-                f.write('cheddar')
+            create_file(src, 'cheddar')
             try:
                 os.link(src, dst)
             except PermissionError as e:
@@ -1475,8 +1533,7 @@ def test_dont_copy_file_onto_symlink_to_itself(self):
         src = os.path.join(TESTFN, 'cheese')
         dst = os.path.join(TESTFN, 'shop')
         try:
-            with open(src, 'w', encoding='utf-8') as f:
-                f.write('cheddar')
+            create_file(src, 'cheddar')
             # Using `src` here would mean we end up with a symlink pointing
             # to TESTFN/TESTFN/cheese, while it should point at
             # TESTFN/cheese.
@@ -1511,7 +1568,7 @@ def test_copyfile_return_value(self):
         dst_dir = self.mkdtemp()
         dst_file = os.path.join(dst_dir, 'bar')
         src_file = os.path.join(src_dir, 'foo')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         rv = shutil.copyfile(src_file, dst_file)
         self.assertTrue(os.path.exists(rv))
         self.assertEqual(read_file(src_file), read_file(dst_file))
@@ -1521,7 +1578,7 @@ def test_copyfile_same_file(self):
         # are the same.
         src_dir = self.mkdtemp()
         src_file = os.path.join(src_dir, 'foo')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         self.assertRaises(SameFileError, shutil.copyfile, src_file, src_file)
         # But Error should work too, to stay backward compatible.
         self.assertRaises(Error, shutil.copyfile, src_file, src_file)
@@ -1538,7 +1595,7 @@ def test_copyfile_nonexistent_dir(self):
         src_dir = self.mkdtemp()
         src_file = os.path.join(src_dir, 'foo')
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         self.assertRaises(FileNotFoundError, shutil.copyfile, src_file, dst)
 
     def test_copyfile_copy_dir(self):
@@ -1549,7 +1606,7 @@ def test_copyfile_copy_dir(self):
         src_file = os.path.join(src_dir, 'foo')
         dir2 = self.mkdtemp()
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         if sys.platform == "win32":
             err = PermissionError
         else:
@@ -1564,42 +1621,6 @@ class TestArchives(BaseTest, unittest.TestCase):
 
     ### shutil.make_archive
 
-    @support.requires_zlib()
-    def test_make_tarball(self):
-        # creating something to tar
-        root_dir, base_dir = self._create_files('')
-
-        tmpdir2 = self.mkdtemp()
-        # force shutil to create the directory
-        os.rmdir(tmpdir2)
-        # working with relative paths
-        work_dir = os.path.dirname(tmpdir2)
-        rel_base_name = os.path.join(os.path.basename(tmpdir2), 'archive')
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            tarball = make_archive(rel_base_name, 'gztar', root_dir, '.')
-
-        # check if the compressed tarball was created
-        self.assertEqual(tarball, base_name + '.tar.gz')
-        self.assertTrue(os.path.isfile(tarball))
-        self.assertTrue(tarfile.is_tarfile(tarball))
-        with tarfile.open(tarball, 'r:gz') as tf:
-            self.assertCountEqual(tf.getnames(),
-                                  ['.', './sub', './sub2',
-                                   './file1', './file2', './sub/file3'])
-
-        # trying an uncompressed one
-        with os_helper.change_cwd(work_dir), no_chdir:
-            tarball = make_archive(rel_base_name, 'tar', root_dir, '.')
-        self.assertEqual(tarball, base_name + '.tar')
-        self.assertTrue(os.path.isfile(tarball))
-        self.assertTrue(tarfile.is_tarfile(tarball))
-        with tarfile.open(tarball, 'r') as tf:
-            self.assertCountEqual(tf.getnames(),
-                                  ['.', './sub', './sub2',
-                                  './file1', './file2', './sub/file3'])
-
     def _tarinfo(self, path):
         with tarfile.open(path) as tar:
             names = tar.getnames()
@@ -1611,15 +1632,101 @@ def _create_files(self, base_dir='dist'):
         root_dir = self.mkdtemp()
         dist = os.path.join(root_dir, base_dir)
         os.makedirs(dist, exist_ok=True)
-        write_file((dist, 'file1'), 'xxx')
-        write_file((dist, 'file2'), 'xxx')
+        create_file((dist, 'file1'), 'xxx')
+        create_file((dist, 'file2'), 'xxx')
         os.mkdir(os.path.join(dist, 'sub'))
-        write_file((dist, 'sub', 'file3'), 'xxx')
+        create_file((dist, 'sub', 'file3'), 'xxx')
         os.mkdir(os.path.join(dist, 'sub2'))
         if base_dir:
-            write_file((root_dir, 'outer'), 'xxx')
+            create_file((root_dir, 'outer'), 'xxx')
         return root_dir, base_dir
 
+    @support.requires_zlib()
+    def test_make_tarfile(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir)
+            # check if the compressed tarball was created
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
+        # Test with base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst2', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir, base_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            # check if the uncompressed tarball was created
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist', 'dist/sub', 'dist/sub2',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+        # Test with multi-component base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst3', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir,
+                                   os.path.join(base_dir, 'sub'))
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist/sub', 'dist/sub/file3'])
+
+    @support.requires_zlib()
+    def test_make_tarfile_without_rootdir(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        base_name = os.path.join(self.mkdtemp(), 'dst', 'archive')
+        base_name = os.path.relpath(base_name, root_dir)
+        with os_helper.change_cwd(root_dir), no_chdir:
+            archive = make_archive(base_name, 'gztar')
+            self.assertEqual(archive, base_name + '.tar.gz')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r:gz') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
+        # Test with base_dir.
+        with os_helper.change_cwd(root_dir), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', base_dir=base_dir)
+            self.assertEqual(archive, base_name + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist', 'dist/sub', 'dist/sub2',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+    def test_make_tarfile_with_explicit_curdir(self):
+        # Test with base_dir=os.curdir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir, os.curdir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
     @support.requires_zlib()
     @unittest.skipUnless(shutil.which('tar'),
                          'Need the tar command to run')
@@ -1669,40 +1776,89 @@ def test_tarfile_vs_tar(self):
 
     @support.requires_zlib()
     def test_make_zipfile(self):
-        # creating something to zip
         root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
+
+        # Test with base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst2', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir, base_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+        # Test with multi-component base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst3', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir,
+                                   os.path.join(base_dir, 'sub'))
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/sub/', 'dist/sub/file3'])
 
-        tmpdir2 = self.mkdtemp()
-        # force shutil to create the directory
-        os.rmdir(tmpdir2)
-        # working with relative paths
-        work_dir = os.path.dirname(tmpdir2)
-        rel_base_name = os.path.join(os.path.basename(tmpdir2), 'archive')
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            res = make_archive(rel_base_name, 'zip', root_dir)
+    @support.requires_zlib()
+    def test_make_zipfile_without_rootdir(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        base_name = os.path.join(self.mkdtemp(), 'dst', 'archive')
+        base_name = os.path.relpath(base_name, root_dir)
+        with os_helper.change_cwd(root_dir), no_chdir:
+            archive = make_archive(base_name, 'zip')
+            self.assertEqual(archive, base_name + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
+
+        # Test with base_dir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.change_cwd(root_dir), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', base_dir=base_dir)
+            self.assertEqual(archive, base_name + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
 
-        self.assertEqual(res, base_name + '.zip')
-        self.assertTrue(os.path.isfile(res))
-        self.assertTrue(zipfile.is_zipfile(res))
-        with zipfile.ZipFile(res) as zf:
-            self.assertCountEqual(zf.namelist(),
-                    ['dist/', 'dist/sub/', 'dist/sub2/',
-                     'dist/file1', 'dist/file2', 'dist/sub/file3',
-                     'outer'])
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            res = make_archive(rel_base_name, 'zip', root_dir, base_dir)
-
-        self.assertEqual(res, base_name + '.zip')
-        self.assertTrue(os.path.isfile(res))
-        self.assertTrue(zipfile.is_zipfile(res))
-        with zipfile.ZipFile(res) as zf:
-            self.assertCountEqual(zf.namelist(),
-                    ['dist/', 'dist/sub/', 'dist/sub2/',
-                     'dist/file1', 'dist/file2', 'dist/sub/file3'])
+    @support.requires_zlib()
+    def test_make_zipfile_with_explicit_curdir(self):
+        # Test with base_dir=os.curdir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir, os.curdir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
 
     @support.requires_zlib()
     @unittest.skipUnless(shutil.which('zip'),
@@ -1751,7 +1907,10 @@ def test_unzip_zipfile(self):
                 subprocess.check_output(zip_cmd, stderr=subprocess.STDOUT)
             except subprocess.CalledProcessError as exc:
                 details = exc.output.decode(errors="replace")
-                if 'unrecognized option: t' in details:
+                if any(message in details for message in [
+                    'unrecognized option: t',  # BusyBox
+                    'invalid option -- t',  # Android
+                ]):
                     self.skipTest("unzip doesn't support -t")
                 msg = "{}\n\n**Unzip Output**\n{}"
                 self.fail(msg.format(exc, details))
@@ -1872,17 +2031,19 @@ def archiver(base_name, base_dir, **kw):
             unregister_archive_format('xxx')
 
     def test_make_tarfile_in_curdir(self):
-        # Issue #21280
+        # Issue #21280: Test with the archive in the current directory.
         root_dir = self.mkdtemp()
         with os_helper.change_cwd(root_dir), no_chdir:
+            # root_dir must be None, so the archive path is relative.
             self.assertEqual(make_archive('test', 'tar'), 'test.tar')
             self.assertTrue(os.path.isfile('test.tar'))
 
     @support.requires_zlib()
     def test_make_zipfile_in_curdir(self):
-        # Issue #21280
+        # Issue #21280: Test with the archive in the current directory.
         root_dir = self.mkdtemp()
         with os_helper.change_cwd(root_dir), no_chdir:
+            # root_dir must be None, so the archive path is relative.
             self.assertEqual(make_archive('test', 'zip'), 'test.zip')
             self.assertTrue(os.path.isfile('test.zip'))
 
@@ -1903,10 +2064,11 @@ def test_register_archive_format(self):
         self.assertNotIn('xxx', formats)
 
     def test_make_tarfile_rootdir_nodir(self):
-        # GH-99203
+        # GH-99203: Test with root_dir is not a real directory.
         self.addCleanup(os_helper.unlink, f'{TESTFN}.tar')
         for dry_run in (False, True):
             with self.subTest(dry_run=dry_run):
+                # root_dir does not exist.
                 tmp_dir = self.mkdtemp()
                 nonexisting_file = os.path.join(tmp_dir, 'nonexisting')
                 with self.assertRaises(FileNotFoundError) as cm:
@@ -1915,6 +2077,7 @@ def test_make_tarfile_rootdir_nodir(self):
                 self.assertEqual(cm.exception.filename, nonexisting_file)
                 self.assertFalse(os.path.exists(f'{TESTFN}.tar'))
 
+                # root_dir is a file.
                 tmp_fd, tmp_file = tempfile.mkstemp(dir=tmp_dir)
                 os.close(tmp_fd)
                 with self.assertRaises(NotADirectoryError) as cm:
@@ -1925,10 +2088,11 @@ def test_make_tarfile_rootdir_nodir(self):
 
     @support.requires_zlib()
     def test_make_zipfile_rootdir_nodir(self):
-        # GH-99203
+        # GH-99203: Test with root_dir is not a real directory.
         self.addCleanup(os_helper.unlink, f'{TESTFN}.zip')
         for dry_run in (False, True):
             with self.subTest(dry_run=dry_run):
+                # root_dir does not exist.
                 tmp_dir = self.mkdtemp()
                 nonexisting_file = os.path.join(tmp_dir, 'nonexisting')
                 with self.assertRaises(FileNotFoundError) as cm:
@@ -1937,6 +2101,7 @@ def test_make_zipfile_rootdir_nodir(self):
                 self.assertEqual(cm.exception.filename, nonexisting_file)
                 self.assertFalse(os.path.exists(f'{TESTFN}.zip'))
 
+                # root_dir is a file.
                 tmp_fd, tmp_file = tempfile.mkstemp(dir=tmp_dir)
                 os.close(tmp_fd)
                 with self.assertRaises(NotADirectoryError) as cm:
@@ -1951,7 +2116,7 @@ def check_unpack_archive(self, format, **kwargs):
         self.check_unpack_archive_with_converter(
             format, lambda path: path, **kwargs)
         self.check_unpack_archive_with_converter(
-            format, pathlib.Path, **kwargs)
+            format, FakePath, **kwargs)
         self.check_unpack_archive_with_converter(format, FakePath, **kwargs)
 
     def check_unpack_archive_with_converter(self, format, converter, **kwargs):
@@ -2056,7 +2221,9 @@ def test_disk_usage(self):
     def test_chown(self):
         dirname = self.mkdtemp()
         filename = tempfile.mktemp(dir=dirname)
-        write_file(filename, 'testing chown function')
+        linkname = os.path.join(dirname, "chown_link")
+        create_file(filename, 'testing chown function')
+        os.symlink(filename, linkname)
 
         with self.assertRaises(ValueError):
             shutil.chown(filename)
@@ -2077,7 +2244,7 @@ def test_chown(self):
         gid = os.getgid()
 
         def check_chown(path, uid=None, gid=None):
-            s = os.stat(filename)
+            s = os.stat(path)
             if uid is not None:
                 self.assertEqual(uid, s.st_uid)
             if gid is not None:
@@ -2113,41 +2280,76 @@ def check_chown(path, uid=None, gid=None):
             shutil.chown(dirname, user, group)
             check_chown(dirname, uid, gid)
 
+        dirfd = os.open(dirname, os.O_RDONLY)
+        self.addCleanup(os.close, dirfd)
+        basename = os.path.basename(filename)
+        baselinkname = os.path.basename(linkname)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd)
+        check_chown(filename, uid, gid)
+        shutil.chown(basename, uid, dir_fd=dirfd)
+        check_chown(filename, uid)
+        shutil.chown(basename, group=gid, dir_fd=dirfd)
+        check_chown(filename, gid=gid)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd, follow_symlinks=True)
+        check_chown(filename, uid, gid)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd, follow_symlinks=False)
+        check_chown(filename, uid, gid)
+        shutil.chown(linkname, uid, follow_symlinks=True)
+        check_chown(filename, uid)
+        shutil.chown(baselinkname, group=gid, dir_fd=dirfd, follow_symlinks=False)
+        check_chown(filename, gid=gid)
+        shutil.chown(baselinkname, uid, gid, dir_fd=dirfd, follow_symlinks=True)
+        check_chown(filename, uid, gid)
+
+        with self.assertRaises(TypeError):
+            shutil.chown(filename, uid, dir_fd=dirname)
+
+        with self.assertRaises(FileNotFoundError):
+            shutil.chown('missingfile', uid, gid, dir_fd=dirfd)
+
+        with self.assertRaises(ValueError):
+            shutil.chown(filename, dir_fd=dirfd)
+
 
+@support.requires_subprocess()
 class TestWhich(BaseTest, unittest.TestCase):
 
     def setUp(self):
-        self.temp_dir = self.mkdtemp(prefix="Tmp")
+        temp_dir = self.mkdtemp(prefix="Tmp")
+        base_dir = os.path.join(temp_dir, TESTFN + '-basedir')
+        os.mkdir(base_dir)
+        self.dir = os.path.join(base_dir, TESTFN + '-dir')
+        os.mkdir(self.dir)
+        self.other_dir = os.path.join(base_dir, TESTFN + '-dir2')
+        os.mkdir(self.other_dir)
         # Give the temp_file an ".exe" suffix for all.
         # It's needed on Windows and not harmful on other platforms.
-        self.temp_file = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                     prefix="Tmp",
-                                                     suffix=".Exe")
-        os.chmod(self.temp_file.name, stat.S_IXUSR)
-        self.addCleanup(self.temp_file.close)
-        self.dir, self.file = os.path.split(self.temp_file.name)
+        self.file = TESTFN + '.Exe'
+        self.filepath = os.path.join(self.dir, self.file)
+        self.create_file(self.filepath)
         self.env_path = self.dir
         self.curdir = os.curdir
         self.ext = ".EXE"
 
-    def to_text_type(self, s):
-        '''
-        In this class we're testing with str, so convert s to a str
-        '''
-        if isinstance(s, bytes):
-            return s.decode()
-        return s
+    to_text_type = staticmethod(os.fsdecode)
+
+    def create_file(self, path):
+        create_file(path)
+        os.chmod(path, 0o755)
+
+    def assertNormEqual(self, actual, expected):
+        self.assertEqual(os.path.normcase(actual), os.path.normcase(expected))
 
     def test_basic(self):
         # Given an EXE in a directory, it should be returned.
         rv = shutil.which(self.file, path=self.dir)
-        self.assertEqual(rv, self.temp_file.name)
+        self.assertEqual(rv, self.filepath)
 
     def test_absolute_cmd(self):
         # When given the fully qualified path to an executable that exists,
         # it should be returned.
-        rv = shutil.which(self.temp_file.name, path=self.temp_dir)
-        self.assertEqual(rv, self.temp_file.name)
+        rv = shutil.which(self.filepath, path=self.other_dir)
+        self.assertEqual(rv, self.filepath)
 
     def test_relative_cmd(self):
         # When given the relative path with a directory part to an executable
@@ -2155,7 +2357,7 @@ def test_relative_cmd(self):
         base_dir, tail_dir = os.path.split(self.dir)
         relpath = os.path.join(tail_dir, self.file)
         with os_helper.change_cwd(path=base_dir):
-            rv = shutil.which(relpath, path=self.temp_dir)
+            rv = shutil.which(relpath, path=self.other_dir)
             self.assertEqual(rv, relpath)
         # But it shouldn't be searched in PATH directories (issue #16957).
         with os_helper.change_cwd(path=self.dir):
@@ -2166,9 +2368,8 @@ def test_relative_cmd(self):
                          "test is for non win32")
     def test_cwd_non_win32(self):
         # Issue #16957
-        base_dir = os.path.dirname(self.dir)
         with os_helper.change_cwd(path=self.dir):
-            rv = shutil.which(self.file, path=base_dir)
+            rv = shutil.which(self.file, path=self.other_dir)
             # non-win32: shouldn't match in the current directory.
             self.assertIsNone(rv)
 
@@ -2178,57 +2379,32 @@ def test_cwd_win32(self):
         base_dir = os.path.dirname(self.dir)
         with os_helper.change_cwd(path=self.dir):
             with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
-                rv = shutil.which(self.file, path=base_dir)
+                rv = shutil.which(self.file, path=self.other_dir)
                 # Current directory implicitly on PATH
                 self.assertEqual(rv, os.path.join(self.curdir, self.file))
             with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=False):
-                rv = shutil.which(self.file, path=base_dir)
+                rv = shutil.which(self.file, path=self.other_dir)
                 # Current directory not on PATH
                 self.assertIsNone(rv)
 
     @unittest.skipUnless(sys.platform == "win32",
                          "test is for win32")
     def test_cwd_win32_added_before_all_other_path(self):
-        base_dir = pathlib.Path(os.fsdecode(self.dir))
-
-        elsewhere_in_path_dir = base_dir / 'dir1'
-        elsewhere_in_path_dir.mkdir()
-        match_elsewhere_in_path = elsewhere_in_path_dir / 'hello.exe'
-        match_elsewhere_in_path.touch()
-
-        exe_in_cwd = base_dir / 'hello.exe'
-        exe_in_cwd.touch()
-
-        with os_helper.change_cwd(path=base_dir):
-            with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
-                rv = shutil.which('hello.exe', path=elsewhere_in_path_dir)
-
-            self.assertEqual(os.path.abspath(rv), os.path.abspath(exe_in_cwd))
-
-    @unittest.skipUnless(sys.platform == "win32",
-                         "test is for win32")
-    def test_pathext_match_before_path_full_match(self):
-        base_dir = pathlib.Path(os.fsdecode(self.dir))
-        dir1 = base_dir / 'dir1'
-        dir2 = base_dir / 'dir2'
-        dir1.mkdir()
-        dir2.mkdir()
-
-        pathext_match = dir1 / 'hello.com.exe'
-        path_match = dir2 / 'hello.com'
-        pathext_match.touch()
-        path_match.touch()
-
-        test_path = os.pathsep.join([str(dir1), str(dir2)])
-        assert os.path.basename(shutil.which(
-            'hello.com', path=test_path, mode = os.F_OK
-        )).lower() == 'hello.com.exe'
+        other_file_path = os.path.join(self.other_dir, self.file)
+        self.create_file(other_file_path)
+        with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
+            with os_helper.change_cwd(path=self.dir):
+                rv = shutil.which(self.file, path=self.other_dir)
+                self.assertEqual(rv, os.path.join(self.curdir, self.file))
+            with os_helper.change_cwd(path=self.other_dir):
+                rv = shutil.which(self.file, path=self.dir)
+                self.assertEqual(rv, os.path.join(self.curdir, self.file))
 
     @os_helper.skip_if_dac_override
     def test_non_matching_mode(self):
         # Set the file read-only and ask for writeable files.
-        os.chmod(self.temp_file.name, stat.S_IREAD)
-        if os.access(self.temp_file.name, os.W_OK):
+        os.chmod(self.filepath, stat.S_IREAD)
+        if os.access(self.filepath, os.W_OK):
             self.skipTest("can't set the file read-only")
         rv = shutil.which(self.file, path=self.dir, mode=os.W_OK)
         self.assertIsNone(rv)
@@ -2250,13 +2426,13 @@ def test_pathext_checking(self):
         # Ask for the file without the ".exe" extension, then ensure that
         # it gets found properly with the extension.
         rv = shutil.which(self.file[:-4], path=self.dir)
-        self.assertEqual(rv, self.temp_file.name[:-4] + self.ext)
+        self.assertEqual(rv, self.filepath[:-4] + self.ext)
 
     def test_environ_path(self):
         with os_helper.EnvironmentVarGuard() as env:
             env['PATH'] = self.env_path
             rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
     def test_environ_path_empty(self):
         # PATH='': no match
@@ -2270,12 +2446,9 @@ def test_environ_path_empty(self):
                 self.assertIsNone(rv)
 
     def test_environ_path_cwd(self):
-        expected_cwd = os.path.basename(self.temp_file.name)
+        expected_cwd = self.file
         if sys.platform == "win32":
-            curdir = os.curdir
-            if isinstance(expected_cwd, bytes):
-                curdir = os.fsencode(curdir)
-            expected_cwd = os.path.join(curdir, expected_cwd)
+            expected_cwd = os.path.join(self.curdir, expected_cwd)
 
         # PATH=':': explicitly looks in the current directory
         with os_helper.EnvironmentVarGuard() as env:
@@ -2293,21 +2466,21 @@ def test_environ_path_cwd(self):
 
     def test_environ_path_missing(self):
         with os_helper.EnvironmentVarGuard() as env:
-            env.pop('PATH', None)
+            del env['PATH']
 
             # without confstr
             with unittest.mock.patch('os.confstr', side_effect=ValueError, \
                                      create=True), \
                  support.swap_attr(os, 'defpath', self.dir):
                 rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
             # with confstr
             with unittest.mock.patch('os.confstr', return_value=self.dir, \
                                      create=True), \
                  support.swap_attr(os, 'defpath', ''):
                 rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
     def test_empty_path(self):
         base_dir = os.path.dirname(self.dir)
@@ -2319,56 +2492,94 @@ def test_empty_path(self):
 
     def test_empty_path_no_PATH(self):
         with os_helper.EnvironmentVarGuard() as env:
-            env.pop('PATH', None)
+            del env['PATH']
             rv = shutil.which(self.file)
             self.assertIsNone(rv)
 
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext(self):
-        ext = self.to_text_type(".xyz")
-        temp_filexyz = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                   prefix=self.to_text_type("Tmp2"), suffix=ext)
-        os.chmod(temp_filexyz.name, stat.S_IXUSR)
-        self.addCleanup(temp_filexyz.close)
-
-        # strip path and extension
-        program = os.path.basename(temp_filexyz.name)
-        program = os.path.splitext(program)[0]
-
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env['PATHEXT'] = ext if isinstance(ext, str) else ext.decode()
-            rv = shutil.which(program, path=self.temp_dir)
-            self.assertEqual(rv, temp_filexyz.name)
+            env['PATHEXT'] = ext
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
 
     # Issue 40592: See https://bugs.python.org/issue40592
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext_with_empty_str(self):
-        ext = self.to_text_type(".xyz")
-        temp_filexyz = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                   prefix=self.to_text_type("Tmp2"), suffix=ext)
-        self.addCleanup(temp_filexyz.close)
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = ext + ';'  # note the ;
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
 
-        # strip path and extension
-        program = os.path.basename(temp_filexyz.name)
-        program = os.path.splitext(program)[0]
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_with_multidot_extension(self):
+        ext = '.foo.bar'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = ext
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
+
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_with_null_extension(self):
+        cmd = self.to_text_type(TESTFN2)
+        cmddot = cmd + self.to_text_type('.')
+        filepath = os.path.join(self.dir, cmd)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = '.xyz'
+            self.assertIsNone(shutil.which(cmd, path=self.dir))
+            self.assertIsNone(shutil.which(cmddot, path=self.dir))
+            env['PATHEXT'] = '.xyz;.'  # note the .
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmddot, path=self.dir),
+                             filepath + self.to_text_type('.'))
+            env['PATHEXT'] = '.xyz;..'  # multiple dots
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmddot, path=self.dir),
+                             filepath + self.to_text_type('.'))
 
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_extension_ends_with_dot(self):
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        dot = self.to_text_type('.')
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env['PATHEXT'] = f"{ext if isinstance(ext, str) else ext.decode()};"  # note the ;
-            rv = shutil.which(program, path=self.temp_dir)
-            self.assertEqual(rv, temp_filexyz.name)
+            env['PATHEXT'] = ext + '.'
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)  # cmd.exe hangs here
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
+            self.assertIsNone(shutil.which(cmd + dot, path=self.dir))
+            self.assertIsNone(shutil.which(cmdext + dot, path=self.dir))
 
     # See GH-75586
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext_applied_on_files_in_path(self):
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".test"
-
-            test_path = os.path.join(self.temp_dir, self.to_text_type("test_program.test"))
-            open(test_path, 'w').close()
-            os.chmod(test_path, 0o755)
-
-            self.assertEqual(shutil.which(self.to_text_type("test_program")), test_path)
+            env["PATH"] = os.fsdecode(self.dir)
+            env["PATHEXT"] = ext
+            self.assertEqual(shutil.which(cmd), filepath)
+            self.assertEqual(shutil.which(cmdext), filepath)
 
     # See GH-75586
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
@@ -2384,49 +2595,107 @@ def test_win_path_needs_curdir(self):
             self.assertFalse(shutil._win_path_needs_curdir('dontcare', os.X_OK))
             need_curdir_mock.assert_called_once_with('dontcare')
 
-    # See GH-109590
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
-    def test_pathext_preferred_for_execute(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".test"
-
-            exe = os.path.join(self.temp_dir, self.to_text_type("test.exe"))
-            open(exe, 'w').close()
-            os.chmod(exe, 0o755)
-
-            # default behavior allows a direct match if nothing in PATHEXT matches
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), exe)
-
-            dot_test = os.path.join(self.temp_dir, self.to_text_type("test.exe.test"))
-            open(dot_test, 'w').close()
-            os.chmod(dot_test, 0o755)
+    def test_same_dir_with_pathext_extension(self):
+        cmd = self.file  # with .exe extension
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+
+        cmd2 = cmd + self.to_text_type('.com')  # with .exe.com extension
+        other_file_path = os.path.join(self.dir, cmd2)
+        self.create_file(other_file_path)
+
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+        self.assertNormEqual(shutil.which(cmd2, path=self.dir), other_file_path)
+        self.assertNormEqual(shutil.which(cmd2, path=self.dir, mode=os.F_OK),
+                             other_file_path)
 
-            # now we have a PATHEXT match, so it take precedence
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), dot_test)
-
-            # but if we don't use os.X_OK we don't change the order based off PATHEXT
-            # and therefore get the direct match.
-            self.assertEqual(shutil.which(self.to_text_type("test.exe"), mode=os.F_OK), exe)
-
-    # See GH-109590
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
-    def test_pathext_given_extension_preferred(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".exe2;.exe"
-
-            exe = os.path.join(self.temp_dir, self.to_text_type("test.exe"))
-            open(exe, 'w').close()
-            os.chmod(exe, 0o755)
+    def test_same_dir_without_pathext_extension(self):
+        cmd = self.file[:-4]  # without .exe extension
+        # pathext match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+
+        # without extension
+        other_file_path = os.path.join(self.dir, cmd)
+        self.create_file(other_file_path)
+
+        # pathext match if mode contains X_OK
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             other_file_path)
+        self.assertNormEqual(shutil.which(self.file, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(self.file, path=self.dir, mode=os.F_OK),
+                             self.filepath)
 
-            exe2 = os.path.join(self.temp_dir, self.to_text_type("test.exe2"))
-            open(exe2, 'w').close()
-            os.chmod(exe2, 0o755)
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_dir_order_with_pathext_extension(self):
+        cmd = self.file  # with .exe extension
+        search_path = os.pathsep.join([os.fsdecode(self.other_dir),
+                                       os.fsdecode(self.dir)])
+        # full match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        cmd2 = cmd + self.to_text_type('.com')  # with .exe.com extension
+        other_file_path = os.path.join(self.other_dir, cmd2)
+        self.create_file(other_file_path)
+
+        # pathext match in the first directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), other_file_path)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             other_file_path)
+        # full match in the first directory
+        self.assertNormEqual(shutil.which(cmd2, path=search_path), other_file_path)
+        self.assertNormEqual(shutil.which(cmd2, path=search_path, mode=os.F_OK),
+                             other_file_path)
+
+        # full match in the first directory
+        search_path = os.pathsep.join([os.fsdecode(self.dir),
+                                       os.fsdecode(self.other_dir)])
+        self.assertEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                         self.filepath)
 
-            # even though .exe2 is preferred in PATHEXT, we matched directly to test.exe
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), exe)
-            self.assertEqual(shutil.which(self.to_text_type("test")), exe2)
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_dir_order_without_pathext_extension(self):
+        cmd = self.file[:-4]  # without .exe extension
+        search_path = os.pathsep.join([os.fsdecode(self.other_dir),
+                                       os.fsdecode(self.dir)])
+        # pathext match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        # without extension
+        other_file_path = os.path.join(self.other_dir, cmd)
+        self.create_file(other_file_path)
+
+        # pathext match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        # full match in the first directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             other_file_path)
+        # full match in the second directory
+        self.assertNormEqual(shutil.which(self.file, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(self.file, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        # pathext match in the first directory
+        search_path = os.pathsep.join([os.fsdecode(self.dir),
+                                       os.fsdecode(self.other_dir)])
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
 
 
 class TestWhichBytes(TestWhich):
@@ -2434,18 +2703,12 @@ def setUp(self):
         TestWhich.setUp(self)
         self.dir = os.fsencode(self.dir)
         self.file = os.fsencode(self.file)
-        self.temp_file.name = os.fsencode(self.temp_file.name)
-        self.temp_dir = os.fsencode(self.temp_dir)
+        self.filepath = os.fsencode(self.filepath)
+        self.other_dir = os.fsencode(self.other_dir)
         self.curdir = os.fsencode(self.curdir)
         self.ext = os.fsencode(self.ext)
 
-    def to_text_type(self, s):
-        '''
-        In this class we're testing with bytes, so convert s to a bytes
-        '''
-        if isinstance(s, str):
-            return s.encode()
-        return s
+    to_text_type = staticmethod(os.fsencode)
 
 
 class TestMove(BaseTest, unittest.TestCase):
@@ -2456,8 +2719,7 @@ def setUp(self):
         self.dst_dir = self.mkdtemp()
         self.src_file = os.path.join(self.src_dir, filename)
         self.dst_file = os.path.join(self.dst_dir, filename)
-        with open(self.src_file, "wb") as f:
-            f.write(b"spam")
+        create_file(self.src_file, b"spam")
 
     def _check_move_file(self, src, dst, real_dst):
         with open(src, "rb") as f:
@@ -2483,12 +2745,12 @@ def test_move_file_to_dir(self):
 
     def test_move_file_to_dir_pathlike_src(self):
         # Move a pathlike file to another location on the same filesystem.
-        src = pathlib.Path(self.src_file)
+        src = FakePath(self.src_file)
         self._check_move_file(src, self.dst_dir, self.dst_file)
 
     def test_move_file_to_dir_pathlike_dst(self):
         # Move a file to another pathlike location on the same filesystem.
-        dst = pathlib.Path(self.dst_dir)
+        dst = FakePath(self.dst_dir)
         self._check_move_file(self.src_file, dst, self.dst_file)
 
     @mock_rename
@@ -2535,8 +2797,7 @@ def test_move_dir_altsep_to_dir(self):
 
     def test_existing_file_inside_dest_dir(self):
         # A file with the same name inside the destination dir already exists.
-        with open(self.dst_file, "wb"):
-            pass
+        create_file(self.dst_file)
         self.assertRaises(shutil.Error, shutil.move, self.src_file, self.dst_dir)
 
     def test_dont_move_dir_in_itself(self):
@@ -2951,8 +3212,7 @@ def test_empty_file(self):
         dstname = TESTFN + 'dst'
         self.addCleanup(lambda: os_helper.unlink(srcname))
         self.addCleanup(lambda: os_helper.unlink(dstname))
-        with open(srcname, "wb"):
-            pass
+        create_file(srcname)
 
         with open(srcname, "rb") as src:
             with open(dstname, "wb") as dst:
@@ -3075,7 +3335,7 @@ def test_blocksize_arg(self):
             self.assertEqual(blocksize, os.path.getsize(TESTFN))
             # ...unless we're dealing with a small file.
             os_helper.unlink(TESTFN2)
-            write_file(TESTFN2, b"hello", binary=True)
+            create_file(TESTFN2, b"hello")
             self.addCleanup(os_helper.unlink, TESTFN2 + '3')
             self.assertRaises(ZeroDivisionError,
                               shutil.copyfile, TESTFN2, TESTFN2 + '3')
@@ -3147,6 +3407,7 @@ def test_bad_environ(self):
         self.assertGreaterEqual(size.lines, 0)
 
     @unittest.skipUnless(os.isatty(sys.__stdout__.fileno()), "not on tty")
+    @support.requires_subprocess()
     @unittest.skipUnless(hasattr(os, 'get_terminal_size'),
                          'need os.get_terminal_size()')
     def test_stty_match(self):
@@ -3164,8 +3425,7 @@ def test_stty_match(self):
         expected = (int(size[1]), int(size[0])) # reversed order
 
         with os_helper.EnvironmentVarGuard() as env:
-            del env['LINES']
-            del env['COLUMNS']
+            env.unset('LINES', 'COLUMNS')
             actual = shutil.get_terminal_size()
 
         self.assertEqual(expected, actual)
@@ -3173,8 +3433,7 @@ def test_stty_match(self):
     @unittest.skipIf(support.is_wasi, "WASI has no /dev/null")
     def test_fallback(self):
         with os_helper.EnvironmentVarGuard() as env:
-            del env['LINES']
-            del env['COLUMNS']
+            env.unset('LINES', 'COLUMNS')
 
             # sys.__stdout__ has no fileno()
             with support.swap_attr(sys, '__stdout__', None):
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
index 05929344cc4..e056142658d 100644
--- a/crates/vm/src/stdlib/nt.rs
+++ b/crates/vm/src/stdlib/nt.rs
@@ -77,6 +77,58 @@ pub(crate) mod module {
                 || attr & FileSystem::FILE_ATTRIBUTE_DIRECTORY != 0))
     }
 
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    pub(super) fn remove(
+        path: OsPath,
+        dir_fd: DirFd<'static, 0>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // On Windows, use DeleteFileW directly.
+        // Rust's std::fs::remove_file may have different behavior for read-only files.
+        // See Py_DeleteFileW.
+        use windows_sys::Win32::Storage::FileSystem::{
+            DeleteFileW, FindClose, FindFirstFileW, RemoveDirectoryW, WIN32_FIND_DATAW,
+        };
+        use windows_sys::Win32::System::SystemServices::{
+            IO_REPARSE_TAG_MOUNT_POINT, IO_REPARSE_TAG_SYMLINK,
+        };
+
+        let [] = dir_fd.0;
+        let wide_path = path.to_wide_cstring(vm)?;
+        let attrs = unsafe { FileSystem::GetFileAttributesW(wide_path.as_ptr()) };
+
+        let mut is_directory = false;
+        let mut is_link = false;
+
+        if attrs != FileSystem::INVALID_FILE_ATTRIBUTES {
+            is_directory = (attrs & FileSystem::FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+            // Check if it's a symlink or junction point
+            if is_directory && (attrs & FileSystem::FILE_ATTRIBUTE_REPARSE_POINT) != 0 {
+                let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+                let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
+                if handle != INVALID_HANDLE_VALUE {
+                    is_link = find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK
+                        || find_data.dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT;
+                    unsafe { FindClose(handle) };
+                }
+            }
+        }
+
+        let result = if is_directory && is_link {
+            unsafe { RemoveDirectoryW(wide_path.as_ptr()) }
+        } else {
+            unsafe { DeleteFileW(wide_path.as_ptr()) }
+        };
+
+        if result == 0 {
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
+        }
+        Ok(())
+    }
+
     #[pyfunction]
     pub(super) fn _supports_virtual_terminal() -> PyResult<bool> {
         // TODO: implement this
@@ -139,9 +191,9 @@ pub(crate) mod module {
     }
 
     #[derive(FromArgs)]
-    struct ChmodArgs {
+    struct ChmodArgs<'a> {
         #[pyarg(any)]
-        path: OsPath,
+        path: OsPathOrFd<'a>,
         #[pyarg(any)]
         mode: u32,
         #[pyarg(flatten)]
@@ -150,17 +202,85 @@ pub(crate) mod module {
         follow_symlinks: OptionalArg<bool>,
     }
 
+    const S_IWRITE: u32 = 128;
+
+    fn fchmod_impl(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::Storage::FileSystem::{
+            FILE_BASIC_INFO, FileBasicInfo, GetFileInformationByHandleEx,
+            SetFileInformationByHandle,
+        };
+
+        // Get Windows HANDLE from fd
+        let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
+        let handle = crt_fd::as_handle(borrowed).map_err(|e| e.to_pyexception(vm))?;
+        let hfile = handle.as_raw_handle() as Foundation::HANDLE;
+
+        // Get current file info
+        let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+        let ret = unsafe {
+            GetFileInformationByHandleEx(
+                hfile,
+                FileBasicInfo,
+                &mut info as *mut _ as *mut _,
+                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Modify readonly attribute based on S_IWRITE bit
+        if mode & S_IWRITE != 0 {
+            info.FileAttributes &= !FileSystem::FILE_ATTRIBUTE_READONLY;
+        } else {
+            info.FileAttributes |= FileSystem::FILE_ATTRIBUTE_READONLY;
+        }
+
+        // Set the new attributes
+        let ret = unsafe {
+            SetFileInformationByHandle(
+                hfile,
+                FileBasicInfo,
+                &info as *const _ as *const _,
+                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
     #[pyfunction]
-    fn chmod(args: ChmodArgs, vm: &VirtualMachine) -> PyResult<()> {
+    fn fchmod(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        fchmod_impl(fd, mode, vm)
+    }
+
+    #[pyfunction]
+    fn chmod(args: ChmodArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
         let ChmodArgs {
             path,
             mode,
             dir_fd,
             follow_symlinks,
         } = args;
-        const S_IWRITE: u32 = 128;
         let [] = dir_fd.0;
 
+        // If path is a file descriptor, use fchmod
+        if let OsPathOrFd::Fd(fd) = path {
+            if follow_symlinks.into_option().is_some() {
+                return Err(vm.new_value_error(
+                    "chmod: follow_symlinks is not supported with fd argument".to_owned(),
+                ));
+            }
+            return fchmod_impl(fd.as_raw(), mode, vm);
+        }
+
+        let OsPathOrFd::Path(path) = path else {
+            unreachable!()
+        };
+
         // On Windows, os.chmod behavior differs based on whether follow_symlinks is explicitly provided:
         // - Not provided (default): use SetFileAttributesW on the path directly (doesn't follow symlinks)
         // - Explicitly True: resolve symlink first, then apply permissions to target
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 28d4aeb3755..b7c0d6401bb 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -296,40 +296,6 @@ pub(super) mod _os {
         data.with_ref(|b| crt_fd::write(fd, b))
     }
 
-    #[pyfunction]
-    #[pyfunction(name = "unlink")]
-    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
-        let [] = dir_fd.0;
-        #[cfg(windows)]
-        let is_dir_link = {
-            // On Windows, we need to check if it's a directory symlink/junction
-            // using GetFileAttributesW, which doesn't follow symlinks.
-            // This is similar to CPython's Py_DeleteFileW.
-            use windows_sys::Win32::Storage::FileSystem::{
-                FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_REPARSE_POINT, GetFileAttributesW,
-                INVALID_FILE_ATTRIBUTES,
-            };
-            let wide_path: Vec<u16> = path.path.as_os_str().to_wide_with_nul();
-            let attrs = unsafe { GetFileAttributesW(wide_path.as_ptr()) };
-            if attrs != INVALID_FILE_ATTRIBUTES {
-                let is_dir = (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
-                let is_reparse = (attrs & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
-                is_dir && is_reparse
-            } else {
-                false
-            }
-        };
-        #[cfg(not(windows))]
-        let is_dir_link = false;
-
-        let res = if is_dir_link {
-            fs::remove_dir(&path)
-        } else {
-            fs::remove_file(&path)
-        };
-        res.map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
-    }
-
     #[cfg(not(windows))]
     #[pyfunction]
     fn mkdir(
@@ -596,15 +562,16 @@ pub(super) mod _os {
 
         #[pymethod]
         fn is_dir(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
+            // Use cached file_type first to avoid stat() calls that may fail
+            if let Ok(file_type) = &self.file_type {
+                if !follow_symlinks.0 || !file_type.is_symlink() {
+                    return Ok(file_type.is_dir());
+                }
+            }
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_dir()),
                 Err(e) => {
                     if e.kind() == io::ErrorKind::NotFound {
-                        // On Windows, use cached file_type when file is removed
-                        #[cfg(windows)]
-                        if let Ok(file_type) = &self.file_type {
-                            return Ok(file_type.is_dir());
-                        }
                         Ok(false)
                     } else {
                         Err(e.into_pyexception(vm))
@@ -615,15 +582,16 @@ pub(super) mod _os {
 
         #[pymethod]
         fn is_file(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
+            // Use cached file_type first to avoid stat() calls that may fail
+            if let Ok(file_type) = &self.file_type {
+                if !follow_symlinks.0 || !file_type.is_symlink() {
+                    return Ok(file_type.is_file());
+                }
+            }
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_file()),
                 Err(e) => {
                     if e.kind() == io::ErrorKind::NotFound {
-                        // On Windows, use cached file_type when file is removed
-                        #[cfg(windows)]
-                        if let Ok(file_type) = &self.file_type {
-                            return Ok(file_type.is_file());
-                        }
                         Ok(false)
                     } else {
                         Err(e.into_pyexception(vm))
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index b903e41889d..efbd0cf9049 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -475,6 +475,13 @@ pub mod module {
         }
     }
 
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+        let [] = dir_fd.0;
+        fs::remove_file(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
+    }
+
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn fchdir(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<()> {
diff --git a/crates/vm/src/stdlib/posix_compat.rs b/crates/vm/src/stdlib/posix_compat.rs
index b2149b43192..0fabd6a1f45 100644
--- a/crates/vm/src/stdlib/posix_compat.rs
+++ b/crates/vm/src/stdlib/posix_compat.rs
@@ -14,16 +14,24 @@ pub(crate) mod module {
     use crate::{
         PyObjectRef, PyResult, VirtualMachine,
         builtins::PyStrRef,
+        convert::IntoPyException,
         ospath::OsPath,
         stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
     };
-    use std::env;
+    use std::{env, fs};
 
     #[pyfunction]
     pub(super) fn access(_path: PyStrRef, _mode: u8, vm: &VirtualMachine) -> PyResult<bool> {
         os_unimpl("os.access", vm)
     }
 
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+        let [] = dir_fd.0;
+        fs::remove_file(&path).map_err(|err| err.into_pyexception(vm))
+    }
+
     #[derive(FromArgs)]
     #[allow(unused)]
     pub(super) struct SymlinkArgs<'a> {

From 75daf6f5ecb244e76782c1f73593013df2674910 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 16:03:11 +0900
Subject: [PATCH 095/418] fix is_file (#6563)

---
 crates/vm/src/stdlib/os.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index b7c0d6401bb..f20046a1a66 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -563,10 +563,10 @@ pub(super) mod _os {
         #[pymethod]
         fn is_dir(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
             // Use cached file_type first to avoid stat() calls that may fail
-            if let Ok(file_type) = &self.file_type {
-                if !follow_symlinks.0 || !file_type.is_symlink() {
-                    return Ok(file_type.is_dir());
-                }
+            if let Ok(file_type) = &self.file_type
+                && (!follow_symlinks.0 || !file_type.is_symlink())
+            {
+                return Ok(file_type.is_dir());
             }
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_dir()),
@@ -583,10 +583,10 @@ pub(super) mod _os {
         #[pymethod]
         fn is_file(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
             // Use cached file_type first to avoid stat() calls that may fail
-            if let Ok(file_type) = &self.file_type {
-                if !follow_symlinks.0 || !file_type.is_symlink() {
-                    return Ok(file_type.is_file());
-                }
+            if let Ok(file_type) = &self.file_type
+                && (!follow_symlinks.0 || !file_type.is_symlink())
+            {
+                return Ok(file_type.is_file());
             }
             match super::fs_metadata(&self.pathval, follow_symlinks.0) {
                 Ok(meta) => Ok(meta.is_file()),

From 7b36c9e8e0e3f145b3352b1538337cd554fb5662 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Sun, 28 Dec 2025 16:27:32 +0900
Subject: [PATCH 096/418] Handle oversized __hash__ results without panicking
 (#6561)

* Initial plan

* Fix hash wrapper overflow handling

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Auto-format: cargo fmt --all

* Adjust __hash__ wrapper conversion

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Auto-format: cargo fmt --all

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/types/slot.rs          | 8 ++++----
 extra_tests/snippets/builtin_hash.py | 8 ++++++++
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index b7c20041d00..9823f189a26 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -5,7 +5,7 @@ use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef},
     bytecode::ComparisonOperator,
-    common::hash::PyHash,
+    common::hash::{PyHash, fix_sentinel, hash_bigint},
     convert::ToPyObject,
     function::{
         Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
@@ -18,7 +18,6 @@ use crate::{
     vm::Context,
 };
 use crossbeam_utils::atomic::AtomicCell;
-use malachite_bigint::BigInt;
 use num_traits::{Signed, ToPrimitive};
 use std::{any::Any, any::TypeId, borrow::Borrow, cmp::Ordering, ops::Deref};
 
@@ -412,9 +411,10 @@ fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
         .downcast_ref::<PyInt>()
         .ok_or_else(|| vm.new_type_error("__hash__ method should return an integer"))?;
     let big_int = py_int.as_bigint();
-    let hash: PyHash = big_int
+    let hash = big_int
         .to_i64()
-        .unwrap_or_else(|| (big_int % BigInt::from(u64::MAX)).to_i64().unwrap());
+        .map(fix_sentinel)
+        .unwrap_or_else(|| hash_bigint(big_int));
     Ok(hash)
 }
 
diff --git a/extra_tests/snippets/builtin_hash.py b/extra_tests/snippets/builtin_hash.py
index 96ccc46ba80..9b2c8388790 100644
--- a/extra_tests/snippets/builtin_hash.py
+++ b/extra_tests/snippets/builtin_hash.py
@@ -12,6 +12,14 @@ class A:
 assert type(hash(1.1)) is int
 assert type(hash("")) is int
 
+
+class Evil:
+    def __hash__(self):
+        return 1 << 63
+
+
+assert hash(Evil()) == 4
+
 with assert_raises(TypeError):
     hash({})
 

From 44327a8ee4b82ec94db7d6180456dbea12f34bb3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 16:30:44 +0900
Subject: [PATCH 097/418] Upgrade test/support from CPython 3.13.11 (#6556)

* Upgrade test/support from CPython 3.13.11

* fix test_support
---
 Lib/test/support/interpreters.py     | 198 ------------------
 Lib/test/support/os_helper.py        |  90 ++++++---
 Lib/test/support/refleak_helper.py   |   8 +
 Lib/test/support/script_helper.py    |  32 ++-
 Lib/test/support/socket_helper.py    |   4 +
 Lib/test/support/threading_helper.py |  53 ++---
 Lib/test/test_support.py             | 292 ++++++++++++++-------------
 7 files changed, 275 insertions(+), 402 deletions(-)
 delete mode 100644 Lib/test/support/interpreters.py
 create mode 100644 Lib/test/support/refleak_helper.py

diff --git a/Lib/test/support/interpreters.py b/Lib/test/support/interpreters.py
deleted file mode 100644
index 5c484d1170d..00000000000
--- a/Lib/test/support/interpreters.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Subinterpreters High Level Module."""
-
-import time
-import _xxsubinterpreters as _interpreters
-import _xxinterpchannels as _channels
-
-# aliases:
-from _xxsubinterpreters import is_shareable, RunFailedError
-from _xxinterpchannels import (
-    ChannelError, ChannelNotFoundError, ChannelEmptyError,
-)
-
-
-__all__ = [
-    'Interpreter', 'get_current', 'get_main', 'create', 'list_all',
-    'SendChannel', 'RecvChannel',
-    'create_channel', 'list_all_channels', 'is_shareable',
-    'ChannelError', 'ChannelNotFoundError',
-    'ChannelEmptyError',
-    ]
-
-
-def create(*, isolated=True):
-    """Return a new (idle) Python interpreter."""
-    id = _interpreters.create(isolated=isolated)
-    return Interpreter(id, isolated=isolated)
-
-
-def list_all():
-    """Return all existing interpreters."""
-    return [Interpreter(id) for id in _interpreters.list_all()]
-
-
-def get_current():
-    """Return the currently running interpreter."""
-    id = _interpreters.get_current()
-    return Interpreter(id)
-
-
-def get_main():
-    """Return the main interpreter."""
-    id = _interpreters.get_main()
-    return Interpreter(id)
-
-
-class Interpreter:
-    """A single Python interpreter."""
-
-    def __init__(self, id, *, isolated=None):
-        if not isinstance(id, (int, _interpreters.InterpreterID)):
-            raise TypeError(f'id must be an int, got {id!r}')
-        self._id = id
-        self._isolated = isolated
-
-    def __repr__(self):
-        data = dict(id=int(self._id), isolated=self._isolated)
-        kwargs = (f'{k}={v!r}' for k, v in data.items())
-        return f'{type(self).__name__}({", ".join(kwargs)})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __eq__(self, other):
-        if not isinstance(other, Interpreter):
-            return NotImplemented
-        else:
-            return other._id == self._id
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def isolated(self):
-        if self._isolated is None:
-            # XXX The low-level function has not been added yet.
-            # See bpo-....
-            self._isolated = _interpreters.is_isolated(self._id)
-        return self._isolated
-
-    def is_running(self):
-        """Return whether or not the identified interpreter is running."""
-        return _interpreters.is_running(self._id)
-
-    def close(self):
-        """Finalize and destroy the interpreter.
-
-        Attempting to destroy the current interpreter results
-        in a RuntimeError.
-        """
-        return _interpreters.destroy(self._id)
-
-    def run(self, src_str, /, *, channels=None):
-        """Run the given source code in the interpreter.
-
-        This blocks the current Python thread until done.
-        """
-        _interpreters.run_string(self._id, src_str, channels)
-
-
-def create_channel():
-    """Return (recv, send) for a new cross-interpreter channel.
-
-    The channel may be used to pass data safely between interpreters.
-    """
-    cid = _channels.create()
-    recv, send = RecvChannel(cid), SendChannel(cid)
-    return recv, send
-
-
-def list_all_channels():
-    """Return a list of (recv, send) for all open channels."""
-    return [(RecvChannel(cid), SendChannel(cid))
-            for cid in _channels.list_all()]
-
-
-class _ChannelEnd:
-    """The base class for RecvChannel and SendChannel."""
-
-    def __init__(self, id):
-        if not isinstance(id, (int, _channels.ChannelID)):
-            raise TypeError(f'id must be an int, got {id!r}')
-        self._id = id
-
-    def __repr__(self):
-        return f'{type(self).__name__}(id={int(self._id)})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __eq__(self, other):
-        if isinstance(self, RecvChannel):
-            if not isinstance(other, RecvChannel):
-                return NotImplemented
-        elif not isinstance(other, SendChannel):
-            return NotImplemented
-        return other._id == self._id
-
-    @property
-    def id(self):
-        return self._id
-
-
-_NOT_SET = object()
-
-
-class RecvChannel(_ChannelEnd):
-    """The receiving end of a cross-interpreter channel."""
-
-    def recv(self, *, _sentinel=object(), _delay=10 / 1000):  # 10 milliseconds
-        """Return the next object from the channel.
-
-        This blocks until an object has been sent, if none have been
-        sent already.
-        """
-        obj = _channels.recv(self._id, _sentinel)
-        while obj is _sentinel:
-            time.sleep(_delay)
-            obj = _channels.recv(self._id, _sentinel)
-        return obj
-
-    def recv_nowait(self, default=_NOT_SET):
-        """Return the next object from the channel.
-
-        If none have been sent then return the default if one
-        is provided or fail with ChannelEmptyError.  Otherwise this
-        is the same as recv().
-        """
-        if default is _NOT_SET:
-            return _channels.recv(self._id)
-        else:
-            return _channels.recv(self._id, default)
-
-
-class SendChannel(_ChannelEnd):
-    """The sending end of a cross-interpreter channel."""
-
-    def send(self, obj):
-        """Send the object (i.e. its data) to the channel's receiving end.
-
-        This blocks until the object is received.
-        """
-        _channels.send(self._id, obj)
-        # XXX We are missing a low-level channel_send_wait().
-        # See bpo-32604 and gh-19829.
-        # Until that shows up we fake it:
-        time.sleep(2)
-
-    def send_nowait(self, obj):
-        """Send the object to the channel's receiving end.
-
-        If the object is immediately received then return True
-        (else False).  Otherwise this is the same as send().
-        """
-        # XXX Note that at the moment channel_send() only ever returns
-        # None.  This should be fixed when channel_send_wait() is added.
-        # See bpo-32604 and gh-19829.
-        return _channels.send(self._id, obj)
diff --git a/Lib/test/support/os_helper.py b/Lib/test/support/os_helper.py
index 70161e90132..26c467a7ad2 100644
--- a/Lib/test/support/os_helper.py
+++ b/Lib/test/support/os_helper.py
@@ -1,6 +1,7 @@
 import collections.abc
 import contextlib
 import errno
+import logging
 import os
 import re
 import stat
@@ -10,7 +11,6 @@
 import unittest
 import warnings
 
-# From CPython 3.13.5
 from test import support
 
 
@@ -23,8 +23,8 @@
 
 # TESTFN_UNICODE is a non-ascii filename
 TESTFN_UNICODE = TESTFN_ASCII + "-\xe0\xf2\u0258\u0141\u011f"
-if sys.platform == 'darwin':
-    # In Mac OS X's VFS API file names are, by definition, canonically
+if support.is_apple:
+    # On Apple's VFS API file names are, by definition, canonically
     # decomposed Unicode, encoded using UTF-8. See QA1173:
     # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
     import unicodedata
@@ -49,8 +49,8 @@
                   'encoding (%s). Unicode filename tests may not be effective'
                   % (TESTFN_UNENCODABLE, sys.getfilesystemencoding()))
             TESTFN_UNENCODABLE = None
-# macOS and Emscripten deny unencodable filenames (invalid utf-8)
-elif sys.platform not in {'darwin', 'emscripten', 'wasi'}:
+# Apple and Emscripten deny unencodable filenames (invalid utf-8)
+elif not support.is_apple and sys.platform not in {"emscripten", "wasi"}:
     try:
         # ascii and utf-8 cannot encode the byte 0xff
         b'\xff'.decode(sys.getfilesystemencoding())
@@ -199,10 +199,8 @@ def skip_unless_symlink(test):
     return test if ok else unittest.skip(msg)(test)
 
 
-# From CPython 3.13.5
 _can_hardlink = None
 
-# From CPython 3.13.5
 def can_hardlink():
     global _can_hardlink
     if _can_hardlink is None:
@@ -212,7 +210,6 @@ def can_hardlink():
     return _can_hardlink
 
 
-# From CPython 3.13.5
 def skip_unless_hardlink(test):
     ok = can_hardlink()
     msg = "requires hardlink support"
@@ -268,15 +265,15 @@ def can_chmod():
     global _can_chmod
     if _can_chmod is not None:
         return _can_chmod
-    if not hasattr(os, "chown"):
+    if not hasattr(os, "chmod"):
         _can_chmod = False
         return _can_chmod
     try:
         with open(TESTFN, "wb") as f:
             try:
-                os.chmod(TESTFN, 0o777)
+                os.chmod(TESTFN, 0o555)
                 mode1 = os.stat(TESTFN).st_mode
-                os.chmod(TESTFN, 0o666)
+                os.chmod(TESTFN, 0o777)
                 mode2 = os.stat(TESTFN).st_mode
             except OSError as e:
                 can = False
@@ -323,6 +320,10 @@ def can_dac_override():
             else:
                 _can_dac_override = True
     finally:
+        try:
+            os.chmod(TESTFN, 0o700)
+        except OSError:
+            pass
         unlink(TESTFN)
 
     return _can_dac_override
@@ -378,8 +379,12 @@ def _waitfor(func, pathname, waitall=False):
             # Increase the timeout and try again
             time.sleep(timeout)
             timeout *= 2
-        warnings.warn('tests may fail, delete still pending for ' + pathname,
-                      RuntimeWarning, stacklevel=4)
+        logging.getLogger(__name__).warning(
+            'tests may fail, delete still pending for %s',
+            pathname,
+            stack_info=True,
+            stacklevel=4,
+        )
 
     def _unlink(filename):
         _waitfor(os.unlink, filename)
@@ -494,9 +499,14 @@ def temp_dir(path=None, quiet=False):
         except OSError as exc:
             if not quiet:
                 raise
-            warnings.warn(f'tests may fail, unable to create '
-                          f'temporary directory {path!r}: {exc}',
-                          RuntimeWarning, stacklevel=3)
+            logging.getLogger(__name__).warning(
+                "tests may fail, unable to create temporary directory %r: %s",
+                path,
+                exc,
+                exc_info=exc,
+                stack_info=True,
+                stacklevel=3,
+            )
     if dir_created:
         pid = os.getpid()
     try:
@@ -527,9 +537,15 @@ def change_cwd(path, quiet=False):
     except OSError as exc:
         if not quiet:
             raise
-        warnings.warn(f'tests may fail, unable to change the current working '
-                      f'directory to {path!r}: {exc}',
-                      RuntimeWarning, stacklevel=3)
+        logging.getLogger(__name__).warning(
+            'tests may fail, unable to change the current working directory '
+            'to %r: %s',
+            path,
+            exc,
+            exc_info=exc,
+            stack_info=True,
+            stacklevel=3,
+        )
     try:
         yield os.getcwd()
     finally:
@@ -612,11 +628,18 @@ def __fspath__(self):
 def fd_count():
     """Count the number of open file descriptors.
     """
-    if sys.platform.startswith(('linux', 'freebsd', 'emscripten')):
+    if sys.platform.startswith(('linux', 'android', 'freebsd', 'emscripten')):
+        fd_path = "/proc/self/fd"
+    elif support.is_apple:
+        fd_path = "/dev/fd"
+    else:
+        fd_path = None
+
+    if fd_path is not None:
         try:
-            names = os.listdir("/proc/self/fd")
+            names = os.listdir(fd_path)
             # Subtract one because listdir() internally opens a file
-            # descriptor to list the content of the /proc/self/fd/ directory.
+            # descriptor to list the content of the directory.
             return len(names) - 1
         except FileNotFoundError:
             pass
@@ -686,9 +709,10 @@ def temp_umask(umask):
 
 
 class EnvironmentVarGuard(collections.abc.MutableMapping):
+    """Class to help protect the environment variable properly.
 
-    """Class to help protect the environment variable properly.  Can be used as
-    a context manager."""
+    Can be used as a context manager.
+    """
 
     def __init__(self):
         self._environ = os.environ
@@ -722,7 +746,6 @@ def __len__(self):
     def set(self, envvar, value):
         self[envvar] = value
 
-    # From CPython 3.13.5
     def unset(self, envvar, /, *envvars):
         """Unset one or more environment variables."""
         for ev in (envvar, *envvars):
@@ -746,13 +769,16 @@ def __exit__(self, *ignore_exc):
 
 
 try:
-    import ctypes
-    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
-
-    ERROR_FILE_NOT_FOUND = 2
-    DDD_REMOVE_DEFINITION = 2
-    DDD_EXACT_MATCH_ON_REMOVE = 4
-    DDD_NO_BROADCAST_SYSTEM = 8
+    if support.MS_WINDOWS:
+        import ctypes
+        kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+
+        ERROR_FILE_NOT_FOUND = 2
+        DDD_REMOVE_DEFINITION = 2
+        DDD_EXACT_MATCH_ON_REMOVE = 4
+        DDD_NO_BROADCAST_SYSTEM = 8
+    else:
+        raise AttributeError
 except (ImportError, AttributeError):
     def subst_drive(path):
         raise unittest.SkipTest('ctypes or kernel32 is not available')
diff --git a/Lib/test/support/refleak_helper.py b/Lib/test/support/refleak_helper.py
new file mode 100644
index 00000000000..2f86c93a1e2
--- /dev/null
+++ b/Lib/test/support/refleak_helper.py
@@ -0,0 +1,8 @@
+"""
+Utilities for changing test behaviour while hunting
+for refleaks
+"""
+
+_hunting_for_refleaks = False
+def hunting_for_refleaks():
+    return _hunting_for_refleaks
diff --git a/Lib/test/support/script_helper.py b/Lib/test/support/script_helper.py
index c2b43f4060e..04458077d51 100644
--- a/Lib/test/support/script_helper.py
+++ b/Lib/test/support/script_helper.py
@@ -8,7 +8,6 @@
 import os.path
 import subprocess
 import py_compile
-import zipfile
 
 from importlib.util import source_from_cache
 from test import support
@@ -64,8 +63,8 @@ class _PythonRunResult(collections.namedtuple("_PythonRunResult",
     """Helper for reporting Python subprocess run results"""
     def fail(self, cmd_line):
         """Provide helpful details about failed subcommand runs"""
-        # Limit to 80 lines to ASCII characters
-        maxlen = 80 * 100
+        # Limit to 300 lines of ASCII characters
+        maxlen = 300 * 100
         out, err = self.out, self.err
         if len(out) > maxlen:
             out = b'(... truncated stdout ...)' + out[-maxlen:]
@@ -93,13 +92,28 @@ def fail(self, cmd_line):
 # Executing the interpreter in a subprocess
 @support.requires_subprocess()
 def run_python_until_end(*args, **env_vars):
+    """Used to implement assert_python_*.
+
+    *args are the command line flags to pass to the python interpreter.
+    **env_vars keyword arguments are environment variables to set on the process.
+
+    If __run_using_command= is supplied, it must be a list of
+    command line arguments to prepend to the command line used.
+    Useful when you want to run another command that should launch the
+    python interpreter via its own arguments. ["/bin/echo", "--"] for
+    example could print the unquoted python command line instead of
+    run it.
+    """
     env_required = interpreter_requires_environment()
+    run_using_command = env_vars.pop('__run_using_command', None)
     cwd = env_vars.pop('__cwd', None)
     if '__isolated' in env_vars:
         isolated = env_vars.pop('__isolated')
     else:
         isolated = not env_vars and not env_required
     cmd_line = [sys.executable, '-X', 'faulthandler']
+    if run_using_command:
+        cmd_line = run_using_command + cmd_line
     if isolated:
         # isolated mode: ignore Python environment variables, ignore user
         # site-packages, and don't add the current directory to sys.path
@@ -218,14 +232,19 @@ def make_script(script_dir, script_basename, source, omit_suffix=False):
     if not omit_suffix:
         script_filename += os.extsep + 'py'
     script_name = os.path.join(script_dir, script_filename)
-    # The script should be encoded to UTF-8, the default string encoding
-    with open(script_name, 'w', encoding='utf-8') as script_file:
-        script_file.write(source)
+    if isinstance(source, str):
+        # The script should be encoded to UTF-8, the default string encoding
+        with open(script_name, 'w', encoding='utf-8') as script_file:
+            script_file.write(source)
+    else:
+        with open(script_name, 'wb') as script_file:
+            script_file.write(source)
     importlib.invalidate_caches()
     return script_name
 
 
 def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None):
+    import zipfile
     zip_filename = zip_basename+os.extsep+'zip'
     zip_name = os.path.join(zip_dir, zip_filename)
     with zipfile.ZipFile(zip_name, 'w') as zip_file:
@@ -252,6 +271,7 @@ def make_pkg(pkg_dir, init_source=''):
 
 def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
                  source, depth=1, compiled=False):
+    import zipfile
     unlink = []
     init_name = make_script(zip_dir, '__init__', '')
     unlink.append(init_name)
diff --git a/Lib/test/support/socket_helper.py b/Lib/test/support/socket_helper.py
index 87941ee1791..a41e487f3e4 100644
--- a/Lib/test/support/socket_helper.py
+++ b/Lib/test/support/socket_helper.py
@@ -259,6 +259,10 @@ def filter_error(err):
             #        raise OSError('socket error', msg) from msg
             elif len(a) >= 2 and isinstance(a[1], OSError):
                 err = a[1]
+            # The error can also be wrapped as __cause__:
+            #    raise URLError(f"ftp error: {exp}") from exp
+            elif isinstance(err, urllib.error.URLError) and err.__cause__:
+                err = err.__cause__
             else:
                 break
         filter_error(err)
diff --git a/Lib/test/support/threading_helper.py b/Lib/test/support/threading_helper.py
index 7f16050f32b..afa25a76f63 100644
--- a/Lib/test/support/threading_helper.py
+++ b/Lib/test/support/threading_helper.py
@@ -22,34 +22,37 @@
 
 
 def threading_setup():
-    return _thread._count(), threading._dangling.copy()
+    return _thread._count(), len(threading._dangling)
 
 
 def threading_cleanup(*original_values):
-    _MAX_COUNT = 100
-
-    for count in range(_MAX_COUNT):
-        values = _thread._count(), threading._dangling
-        if values == original_values:
-            break
-
-        if not count:
-            # Display a warning at the first iteration
-            support.environment_altered = True
-            dangling_threads = values[1]
-            support.print_warning(f"threading_cleanup() failed to cleanup "
-                                  f"{values[0] - original_values[0]} threads "
-                                  f"(count: {values[0]}, "
-                                  f"dangling: {len(dangling_threads)})")
-            for thread in dangling_threads:
-                support.print_warning(f"Dangling thread: {thread!r}")
-
-            # Don't hold references to threads
-            dangling_threads = None
-        values = None
-
-        time.sleep(0.01)
-        support.gc_collect()
+    orig_count, orig_ndangling = original_values
+
+    timeout = 1.0
+    for _ in support.sleeping_retry(timeout, error=False):
+        # Copy the thread list to get a consistent output. threading._dangling
+        # is a WeakSet, its value changes when it's read.
+        dangling_threads = list(threading._dangling)
+        count = _thread._count()
+
+        if count <= orig_count:
+            return
+
+    # Timeout!
+    support.environment_altered = True
+    support.print_warning(
+        f"threading_cleanup() failed to clean up threads "
+        f"in {timeout:.1f} seconds\n"
+        f"  before: thread count={orig_count}, dangling={orig_ndangling}\n"
+        f"  after: thread count={count}, dangling={len(dangling_threads)}")
+    for thread in dangling_threads:
+        support.print_warning(f"Dangling thread: {thread!r}")
+
+    # The warning happens when a test spawns threads and some of these threads
+    # are still running after the test completes. To fix this warning, join
+    # threads explicitly to wait until they complete.
+    #
+    # To make the warning more likely, reduce the timeout.
 
 
 def reap_threads(func):
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 7c8380498e3..d66afdc833c 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -1,12 +1,15 @@
+import contextlib
 import errno
 import importlib
 import io
+import logging
 import os
 import shutil
 import socket
 import stat
 import subprocess
 import sys
+import sysconfig
 import tempfile
 import textwrap
 import unittest
@@ -18,11 +21,37 @@
 from test.support import script_helper
 from test.support import socket_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
 TESTFN = os_helper.TESTFN
 
 
-class TestSupport(unittest.TestCase):
+class LogCaptureHandler(logging.StreamHandler):
+    # Inspired by pytest's caplog
+    def __init__(self):
+        super().__init__(io.StringIO())
+        self.records = []
+
+    def emit(self, record) -> None:
+        self.records.append(record)
+        super().emit(record)
+
+    def handleError(self, record):
+        raise
+
+
+@contextlib.contextmanager
+def _caplog():
+    handler = LogCaptureHandler()
+    root_logger = logging.getLogger()
+    root_logger.addHandler(handler)
+    try:
+        yield handler
+    finally:
+        root_logger.removeHandler(handler)
+
+
+class TestSupport(unittest.TestCase, ExtraAssertions):
     @classmethod
     def setUpClass(cls):
         orig_filter_len = len(warnings.filters)
@@ -185,7 +214,7 @@ def test_temp_dir__existing_dir__quiet_true(self):
         path = os.path.realpath(path)
 
         try:
-            with warnings_helper.check_warnings() as recorder:
+            with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
                 with os_helper.temp_dir(path, quiet=True) as temp_path:
                     self.assertEqual(path, temp_path)
                 warnings = [str(w.message) for w in recorder.warnings]
@@ -194,11 +223,14 @@ def test_temp_dir__existing_dir__quiet_true(self):
         finally:
             shutil.rmtree(path)
 
-        self.assertEqual(len(warnings), 1, warnings)
-        warn = warnings[0]
-        self.assertTrue(warn.startswith(f'tests may fail, unable to create '
-                                        f'temporary directory {path!r}: '),
-                        warn)
+        self.assertListEqual(warnings, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to create '
+            f'temporary directory {path!r}: '
+        )
 
     @support.requires_fork()
     def test_temp_dir__forked_child(self):
@@ -258,35 +290,41 @@ def test_change_cwd__non_existent_dir__quiet_true(self):
 
         with os_helper.temp_dir() as parent_dir:
             bad_dir = os.path.join(parent_dir, 'does_not_exist')
-            with warnings_helper.check_warnings() as recorder:
+            with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
                 with os_helper.change_cwd(bad_dir, quiet=True) as new_cwd:
                     self.assertEqual(new_cwd, original_cwd)
                     self.assertEqual(os.getcwd(), new_cwd)
                 warnings = [str(w.message) for w in recorder.warnings]
 
-        self.assertEqual(len(warnings), 1, warnings)
-        warn = warnings[0]
-        self.assertTrue(warn.startswith(f'tests may fail, unable to change '
-                                        f'the current working directory '
-                                        f'to {bad_dir!r}: '),
-                        warn)
+        self.assertListEqual(warnings, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to change '
+            f'the current working directory '
+            f'to {bad_dir!r}: '
+        )
 
     # Tests for change_cwd()
 
     def test_change_cwd__chdir_warning(self):
         """Check the warning message when os.chdir() fails."""
         path = TESTFN + '_does_not_exist'
-        with warnings_helper.check_warnings() as recorder:
+        with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
             with os_helper.change_cwd(path=path, quiet=True):
                 pass
             messages = [str(w.message) for w in recorder.warnings]
 
-        self.assertEqual(len(messages), 1, messages)
-        msg = messages[0]
-        self.assertTrue(msg.startswith(f'tests may fail, unable to change '
-                                       f'the current working directory '
-                                       f'to {path!r}: '),
-                        msg)
+        self.assertListEqual(messages, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to change '
+            f'the current working directory '
+            f'to {path!r}: ',
+        )
 
     # Tests for temp_cwd()
 
@@ -420,8 +458,6 @@ def test_detect_api_mismatch__ignore(self):
                 self.OtherClass, self.RefClass, ignore=ignore)
         self.assertEqual(set(), missing_items)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_check__all__(self):
         extra = {'tempdir'}
         not_exported = {'template'}
@@ -432,10 +468,8 @@ def test_check__all__(self):
 
         extra = {
             'TextTestResult',
-            'findTestCases',
-            'getTestCaseNames',
             'installHandler',
-            'makeSuite',
+            'IsolatedAsyncioTestCase',
         }
         not_exported = {'load_tests', "TestProgram", "BaseTestSuite"}
         support.check__all__(self,
@@ -551,119 +585,14 @@ def test_optim_args_from_interpreter_flags(self):
             with self.subTest(opts=opts):
                 self.check_options(opts, 'optim_args_from_interpreter_flags')
 
-    def test_match_test(self):
-        class Test:
-            def __init__(self, test_id):
-                self.test_id = test_id
-
-            def id(self):
-                return self.test_id
-
-        test_access = Test('test.test_os.FileTests.test_access')
-        test_chdir = Test('test.test_os.Win32ErrorTests.test_chdir')
-
-        # Test acceptance
-        with support.swap_attr(support, '_match_test_func', None):
-            # match all
-            support.set_match_tests([])
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match all using None
-            support.set_match_tests(None, None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the full test identifier
-            support.set_match_tests([test_access.id()], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # match the module name
-            support.set_match_tests(['test_os'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Test '*' pattern
-            support.set_match_tests(['test_*'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Test case sensitivity
-            support.set_match_tests(['filetests'], None)
-            self.assertFalse(support.match_test(test_access))
-            support.set_match_tests(['FileTests'], None)
-            self.assertTrue(support.match_test(test_access))
-
-            # Test pattern containing '.' and a '*' metacharacter
-            support.set_match_tests(['*test_os.*.test_*'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Multiple patterns
-            support.set_match_tests([test_access.id(), test_chdir.id()], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            support.set_match_tests(['test_access', 'DONTMATCH'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-        # Test rejection
-        with support.swap_attr(support, '_match_test_func', None):
-            # match all
-            support.set_match_tests(ignore_patterns=[])
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match all using None
-            support.set_match_tests(None, None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the full test identifier
-            support.set_match_tests(None, [test_access.id()])
-            self.assertFalse(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the module name
-            support.set_match_tests(None, ['test_os'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Test '*' pattern
-            support.set_match_tests(None, ['test_*'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Test case sensitivity
-            support.set_match_tests(None, ['filetests'])
-            self.assertTrue(support.match_test(test_access))
-            support.set_match_tests(None, ['FileTests'])
-            self.assertFalse(support.match_test(test_access))
-
-            # Test pattern containing '.' and a '*' metacharacter
-            support.set_match_tests(None, ['*test_os.*.test_*'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Multiple patterns
-            support.set_match_tests(None, [test_access.id(), test_chdir.id()])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            support.set_match_tests(None, ['test_access', 'DONTMATCH'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-    @unittest.skipIf(sys.platform.startswith("win"), "TODO: RUSTPYTHON; os.dup on windows")
+    @unittest.skipIf(support.is_apple_mobile, "Unstable on Apple Mobile")
     @unittest.skipIf(support.is_emscripten, "Unstable in Emscripten")
     @unittest.skipIf(support.is_wasi, "Unavailable on WASI")
     def test_fd_count(self):
-        # We cannot test the absolute value of fd_count(): on old Linux
-        # kernel or glibc versions, os.urandom() keeps a FD open on
-        # /dev/urandom device and Python has 4 FD opens instead of 3.
-        # Test is unstable on Emscripten. The platform starts and stops
+        # We cannot test the absolute value of fd_count(): on old Linux kernel
+        # or glibc versions, os.urandom() keeps a FD open on /dev/urandom
+        # device and Python has 4 FD opens instead of 3. Test is unstable on
+        # Emscripten and Apple Mobile platforms; these platforms start and stop
         # background threads that use pipes and epoll fds.
         start = os_helper.fd_count()
         fd = os.open(__file__, os.O_RDONLY)
@@ -685,13 +614,16 @@ def test_print_warning(self):
         self.check_print_warning("a\nb",
                                  'Warning -- a\nWarning -- b\n')
 
-    @unittest.expectedFailureIf(sys.platform != "win32", "TODO: RUSTPYTHON")
+    # TODO: RUSTPYTHON - strftime extension not fully supported on non-Windows
+    @unittest.skipUnless(sys.platform == "win32" or support.is_emscripten,
+                         "strftime extension not fully supported on non-Windows")
     def test_has_strftime_extensions(self):
         if support.is_emscripten or sys.platform == "win32":
             self.assertFalse(support.has_strftime_extensions)
         else:
             self.assertTrue(support.has_strftime_extensions)
 
+    # TODO: RUSTPYTHON - _testinternalcapi module not available
     @unittest.expectedFailure
     def test_get_recursion_depth(self):
         # test support.get_recursion_depth()
@@ -736,13 +668,15 @@ def test_recursive(depth, limit):
         """)
         script_helper.assert_python_ok("-c", code)
 
+    # TODO: RUSTPYTHON - stack overflow in debug mode with deep recursion
+    @unittest.skip("TODO: RUSTPYTHON - causes segfault in debug builds")
     def test_recursion(self):
         # Test infinite_recursion() and get_recursion_available() functions.
         def recursive_function(depth):
             if depth:
                 recursive_function(depth - 1)
 
-        for max_depth in (5, 25, 250):
+        for max_depth in (5, 25, 250, 2500):
             with support.infinite_recursion(max_depth):
                 available = support.get_recursion_available()
 
@@ -768,7 +702,85 @@ def recursive_function(depth):
             else:
                 self.fail("RecursionError was not raised")
 
-        #self.assertEqual(available, 2)
+    def test_parse_memlimit(self):
+        parse = support._parse_memlimit
+        KiB = 1024
+        MiB = KiB * 1024
+        GiB = MiB * 1024
+        TiB = GiB * 1024
+        self.assertEqual(parse('0k'), 0)
+        self.assertEqual(parse('3k'), 3 * KiB)
+        self.assertEqual(parse('2.4m'), int(2.4 * MiB))
+        self.assertEqual(parse('4g'), int(4 * GiB))
+        self.assertEqual(parse('1t'), TiB)
+
+        for limit in ('', '3', '3.5.10k', '10x'):
+            with self.subTest(limit=limit):
+                with self.assertRaises(ValueError):
+                    parse(limit)
+
+    def test_set_memlimit(self):
+        _4GiB = 4 * 1024 ** 3
+        TiB = 1024 ** 4
+        old_max_memuse = support.max_memuse
+        old_real_max_memuse = support.real_max_memuse
+        try:
+            if sys.maxsize > 2**32:
+                support.set_memlimit('4g')
+                self.assertEqual(support.max_memuse, _4GiB)
+                self.assertEqual(support.real_max_memuse, _4GiB)
+
+                big = 2**100 // TiB
+                support.set_memlimit(f'{big}t')
+                self.assertEqual(support.max_memuse, sys.maxsize)
+                self.assertEqual(support.real_max_memuse, big * TiB)
+            else:
+                support.set_memlimit('4g')
+                self.assertEqual(support.max_memuse, sys.maxsize)
+                self.assertEqual(support.real_max_memuse, _4GiB)
+        finally:
+            support.max_memuse = old_max_memuse
+            support.real_max_memuse = old_real_max_memuse
+
+    def test_copy_python_src_ignore(self):
+        # Get source directory
+        src_dir = sysconfig.get_config_var('abs_srcdir')
+        if not src_dir:
+            src_dir = sysconfig.get_config_var('srcdir')
+        src_dir = os.path.abspath(src_dir)
+
+        # Check that the source code is available
+        if not os.path.exists(src_dir):
+            self.skipTest(f"cannot access Python source code directory:"
+                          f" {src_dir!r}")
+        # Check that the landmark copy_python_src_ignore() expects is available
+        # (Previously we looked for 'Lib\os.py', which is always present on Windows.)
+        landmark = os.path.join(src_dir, 'Modules')
+        if not os.path.exists(landmark):
+            self.skipTest(f"cannot access Python source code directory:"
+                          f" {landmark!r} landmark is missing")
+
+        # Test support.copy_python_src_ignore()
+
+        # Source code directory
+        ignored = {'.git', '__pycache__'}
+        names = os.listdir(src_dir)
+        self.assertEqual(support.copy_python_src_ignore(src_dir, names),
+                         ignored | {'build'})
+
+        # Doc/ directory
+        path = os.path.join(src_dir, 'Doc')
+        self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)),
+                         ignored | {'build', 'venv'})
+
+        # Another directory
+        path = os.path.join(src_dir, 'Objects')
+        self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)),
+                         ignored)
+
+    def test_linked_to_musl(self):
+        linked = support.linked_to_musl()
+        self.assertIsInstance(linked, bool)
 
     # XXX -follows a list of untested API
     # make_legacy_pyc
@@ -781,12 +793,10 @@ def recursive_function(depth):
     # EnvironmentVarGuard
     # transient_internet
     # run_with_locale
-    # set_memlimit
     # bigmemtest
     # precisionbigmemtest
     # bigaddrspacetest
     # requires_resource
-    # run_doctest
     # threading_cleanup
     # reap_threads
     # can_symlink

From 3600b6652dcc50ce39f94a97d8107ccaffb67d82 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 18:06:47 +0900
Subject: [PATCH 098/418] update _pyio, test_fileio from 3.13.11 and impl more
 io features (#6560)

* Update _pyio, test_fileio from 3.13.11

* impl more io

* unmark sucessful tests

* fix windows fileio
---
 Lib/_pyio.py                          |  55 +++--
 Lib/test/test_file_eintr.py           |  36 +--
 Lib/test/test_fileio.py               |  26 --
 Lib/test/test_io.py                   |  66 +++--
 Lib/test/test_subprocess.py           |   2 -
 Lib/test/test_tarfile.py              |   4 -
 crates/common/src/crt_fd.rs           |  16 +-
 crates/derive-impl/src/pystructseq.rs | 121 +++++++--
 crates/vm/src/exceptions.rs           |  68 +++++-
 crates/vm/src/stdlib/io.rs            | 340 +++++++++++++++++++++-----
 crates/vm/src/stdlib/os.rs            |  20 ++
 11 files changed, 563 insertions(+), 191 deletions(-)

diff --git a/Lib/_pyio.py b/Lib/_pyio.py
index 2629ed9e009..48c8f770f81 100644
--- a/Lib/_pyio.py
+++ b/Lib/_pyio.py
@@ -33,11 +33,8 @@
 # Rebind for compatibility
 BlockingIOError = BlockingIOError
 
-# Does io.IOBase finalizer log the exception if the close() method fails?
-# The exception is ignored silently by default in release build.
-_IOBASE_EMITS_UNRAISABLE = (hasattr(sys, "gettotalrefcount") or sys.flags.dev_mode)
 # Does open() check its 'errors' argument?
-_CHECK_ERRORS = _IOBASE_EMITS_UNRAISABLE
+_CHECK_ERRORS = (hasattr(sys, "gettotalrefcount") or sys.flags.dev_mode)
 
 
 def text_encoding(encoding, stacklevel=2):
@@ -416,18 +413,12 @@ def __del__(self):
         if closed:
             return
 
-        if _IOBASE_EMITS_UNRAISABLE:
-            self.close()
-        else:
-            # The try/except block is in case this is called at program
-            # exit time, when it's possible that globals have already been
-            # deleted, and then the close() call might fail.  Since
-            # there's nothing we can do about such failures and they annoy
-            # the end users, we suppress the traceback.
-            try:
-                self.close()
-            except:
-                pass
+        if dealloc_warn := getattr(self, "_dealloc_warn", None):
+            dealloc_warn(self)
+
+        # If close() fails, the caller logs the exception with
+        # sys.unraisablehook. close() must be called at the end at __del__().
+        self.close()
 
     ### Inquiries ###
 
@@ -632,16 +623,15 @@ def read(self, size=-1):
         n = self.readinto(b)
         if n is None:
             return None
+        if n < 0 or n > len(b):
+            raise ValueError(f"readinto returned {n} outside buffer size {len(b)}")
         del b[n:]
         return bytes(b)
 
     def readall(self):
         """Read until EOF, using multiple read() call."""
         res = bytearray()
-        while True:
-            data = self.read(DEFAULT_BUFFER_SIZE)
-            if not data:
-                break
+        while data := self.read(DEFAULT_BUFFER_SIZE):
             res += data
         if res:
             return bytes(res)
@@ -666,8 +656,6 @@ def write(self, b):
         self._unsupported("write")
 
 io.RawIOBase.register(RawIOBase)
-from _io import FileIO
-RawIOBase.register(FileIO)
 
 
 class BufferedIOBase(IOBase):
@@ -874,6 +862,10 @@ def __repr__(self):
         else:
             return "<{}.{} name={!r}>".format(modname, clsname, name)
 
+    def _dealloc_warn(self, source):
+        if dealloc_warn := getattr(self.raw, "_dealloc_warn", None):
+            dealloc_warn(source)
+
     ### Lower-level APIs ###
 
     def fileno(self):
@@ -1511,6 +1503,11 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
         if isinstance(file, float):
             raise TypeError('integer argument expected, got float')
         if isinstance(file, int):
+            if isinstance(file, bool):
+                import warnings
+                warnings.warn("bool is used as a file descriptor",
+                              RuntimeWarning, stacklevel=2)
+                file = int(file)
             fd = file
             if fd < 0:
                 raise ValueError('negative file descriptor')
@@ -1569,7 +1566,8 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
                     if not isinstance(fd, int):
                         raise TypeError('expected integer from opener')
                     if fd < 0:
-                        raise OSError('Negative file descriptor')
+                        # bpo-27066: Raise a ValueError for bad value.
+                        raise ValueError(f'opener returned {fd}')
                 owned_fd = fd
                 if not noinherit_flag:
                     os.set_inheritable(fd, False)
@@ -1608,12 +1606,11 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
             raise
         self._fd = fd
 
-    def __del__(self):
+    def _dealloc_warn(self, source):
         if self._fd >= 0 and self._closefd and not self.closed:
             import warnings
-            warnings.warn('unclosed file %r' % (self,), ResourceWarning,
+            warnings.warn(f'unclosed file {source!r}', ResourceWarning,
                           stacklevel=2, source=self)
-            self.close()
 
     def __getstate__(self):
         raise TypeError(f"cannot pickle {self.__class__.__name__!r} object")
@@ -1757,7 +1754,7 @@ def close(self):
         """
         if not self.closed:
             try:
-                if self._closefd:
+                if self._closefd and self._fd >= 0:
                     os.close(self._fd)
             finally:
                 super().close()
@@ -2649,6 +2646,10 @@ def readline(self, size=None):
     def newlines(self):
         return self._decoder.newlines if self._decoder else None
 
+    def _dealloc_warn(self, source):
+        if dealloc_warn := getattr(self.buffer, "_dealloc_warn", None):
+            dealloc_warn(source)
+
 
 class StringIO(TextIOWrapper):
     """Text I/O implementation using an in-memory buffer.
diff --git a/Lib/test/test_file_eintr.py b/Lib/test/test_file_eintr.py
index 13260b8e498..fa9c6637fd4 100644
--- a/Lib/test/test_file_eintr.py
+++ b/Lib/test/test_file_eintr.py
@@ -186,15 +186,7 @@ def test_readall(self):
 class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
-    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
-    @unittest.expectedFailure
-    def test_readline(self):
-        super().test_readline()
-
-    @unittest.expectedFailure
-    def test_readlines(self):
-        super().test_readlines()
-
+    # TODO: RUSTPYTHON - _io.FileIO.readall uses read_to_end which differs from _pyio.FileIO.readall
     @unittest.expectedFailure
     def test_readall(self):
         super().test_readall()
@@ -221,19 +213,6 @@ def test_readall(self):
 class CTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
-    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
-    @unittest.expectedFailure
-    def test_readline(self):
-        super().test_readline()
-
-    @unittest.expectedFailure
-    def test_readlines(self):
-        super().test_readlines()
-
-    @unittest.expectedFailure
-    def test_readall(self):
-        super().test_readall()
-
 class PyTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
     modname = '_pyio'
 
@@ -273,19 +252,6 @@ def test_readall(self):
 class CTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
-    # TODO: RUSTPYTHON - _io module uses _pyio internally, signal handling differs
-    @unittest.expectedFailure
-    def test_readline(self):
-        super().test_readline()
-
-    @unittest.expectedFailure
-    def test_readlines(self):
-        super().test_readlines()
-
-    @unittest.expectedFailure
-    def test_readall(self):
-        super().test_readall()
-
 class PyTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
     modname = '_pyio'
 
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
index edc29b34d54..fdb36ed997d 100644
--- a/Lib/test/test_fileio.py
+++ b/Lib/test/test_fileio.py
@@ -363,27 +363,6 @@ class CAutoFileTests(AutoFileTests, unittest.TestCase):
     FileIO = _io.FileIO
     modulename = '_io'
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def testBlksize(self):
-        return super().testBlksize()
-
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
-    def testErrnoOnClosedTruncate(self):
-        return super().testErrnoOnClosedTruncate()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def testMethods(self):
-        return super().testMethods()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def testOpenDirFD(self):
-        return super().testOpenDirFD()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_subclass_repr(self):
-        return super().test_subclass_repr()
-
-@unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, test setUp errors on Windows")
 class PyAutoFileTests(AutoFileTests, unittest.TestCase):
     FileIO = _pyio.FileIO
     modulename = '_pyio'
@@ -506,7 +485,6 @@ def testInvalidFd(self):
             import msvcrt
             self.assertRaises(OSError, msvcrt.get_osfhandle, make_bad_fd())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testBooleanFd(self):
         for fd in False, True:
             with self.assertWarnsRegex(RuntimeWarning,
@@ -634,10 +612,6 @@ def test_open_code(self):
             actual = f.read()
         self.assertEqual(expected, actual)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def testUnclosedFDOnException(self):
-        return super().testUnclosedFDOnException()
-
 
 class PyOtherFileTests(OtherFileTests, unittest.TestCase):
     FileIO = _pyio.FileIO
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 0142208427b..2cf84d9aae9 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -871,6 +871,22 @@ def test_RawIOBase_read(self):
         self.assertEqual(rawio.read(2), None)
         self.assertEqual(rawio.read(2), b"")
 
+    def test_RawIOBase_read_bounds_checking(self):
+        # Make sure a `.readinto` call which returns a value outside
+        # (0, len(buffer)) raises.
+        class Misbehaved(self.RawIOBase):
+            def __init__(self, readinto_return) -> None:
+                self._readinto_return = readinto_return
+            def readinto(self, b):
+                return self._readinto_return
+
+        with self.assertRaises(ValueError) as cm:
+            Misbehaved(2).read(1)
+        self.assertEqual(str(cm.exception), "readinto returned 2 outside buffer size 1")
+        for bad_size in (2147483647, sys.maxsize, -1, -1000):
+            with self.assertRaises(ValueError):
+                Misbehaved(bad_size).read()
+
     def test_types_have_dict(self):
         test = (
             self.IOBase(),
@@ -1204,14 +1220,6 @@ def test_stringio_setstate(self):
 class PyIOTest(IOTest):
     pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; OSError: Negative file descriptor
-    def test_bad_opener_negative_1():
-        return super().test_bad_opener_negative_1()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; OSError: Negative file descriptor
-    def test_bad_opener_other_negative():
-        return super().test_bad_opener_other_negative()
-
 
 @support.cpython_only
 class APIMismatchTest(unittest.TestCase):
@@ -1288,7 +1296,6 @@ def _with():
         # a ValueError.
         self.assertRaises(ValueError, _with)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_error_through_destructor(self):
         # Test that the exception state is not modified by a destructor,
         # even if close() fails.
@@ -1811,6 +1818,10 @@ def test_garbage_collection(self):
             support.gc_collect()
         self.assertIsNone(wr(), wr)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
+
     def test_args_error(self):
         # Issue #17275
         with self.assertRaisesRegex(TypeError, "BufferedReader"):
@@ -1824,7 +1835,6 @@ def test_bad_readinto_value(self):
             bufio.readline()
         self.assertIsNone(cm.exception.__cause__)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: 'bytes' object cannot be interpreted as an integer")
     def test_bad_readinto_type(self):
         rawio = self.tp(self.BytesIO(b"12"))
         rawio.readinto = lambda buf: b''
@@ -1841,7 +1851,6 @@ def test_flush_error_on_close(self):
     def test_seek_character_device_file(self):
         return super().test_seek_character_device_file()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: UnsupportedOperation not raised by truncate
     def test_truncate_on_read_only(self):
         return super().test_truncate_on_read_only()
 
@@ -1961,7 +1970,6 @@ def _seekrel(bufio):
     def test_writes_and_truncates(self):
         self.check_writes(lambda bufio: bufio.truncate(bufio.tell()))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_non_blocking(self):
         raw = self.MockNonBlockWriterIO()
         bufio = self.tp(raw, 8)
@@ -2158,6 +2166,10 @@ def test_slow_close_from_thread(self):
 class CBufferedWriterTest(BufferedWriterTest, SizeofTest):
     tp = io.BufferedWriter
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
+
     def test_initialization(self):
         rawio = self.MockRawIO()
         bufio = self.tp(rawio)
@@ -2680,6 +2692,10 @@ def test_interleaved_readline_write(self):
 class CBufferedRandomTest(BufferedRandomTest, SizeofTest):
     tp = io.BufferedRandom
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
+
     @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
@@ -3205,7 +3221,6 @@ def flush(self):
         support.gc_collect()
         self.assertEqual(record, [1, 2, 3])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_error_through_destructor(self):
         # Test that the exception state is not modified by a destructor,
         # even if close() fails.
@@ -4115,6 +4130,10 @@ class CTextIOWrapperTest(TextIOWrapperTest):
     io = io
     shutdown_error = "LookupError: unknown encoding: ascii"
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
+
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_initialization(self):
         r = self.BytesIO(b"\xc3\xa9\n\n")
@@ -4276,7 +4295,6 @@ def test_reconfigure_write_through(self):
     def test_repr(self):
         return super().test_repr()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_uninitialized(self):
         return super().test_uninitialized()
 
@@ -4596,7 +4614,6 @@ def _check_warn_on_dealloc(self, *args, **kwargs):
             support.gc_collect()
         self.assertIn(r, str(cm.warning.args[0]))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_warn_on_dealloc(self):
         self._check_warn_on_dealloc(os_helper.TESTFN, "wb", buffering=0)
         self._check_warn_on_dealloc(os_helper.TESTFN, "wb")
@@ -4621,7 +4638,6 @@ def cleanup_fds():
         with warnings_helper.check_no_resource_warning(self):
             self.open(r, *args, closefd=False, **kwargs)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_warn_on_dealloc_fd(self):
         self._check_warn_on_dealloc_fd("rb", buffering=0)
@@ -4651,14 +4667,12 @@ def test_pickling(self):
                         with self.assertRaisesRegex(TypeError, msg):
                             pickle.dumps(f, protocol)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(
         support.is_emscripten, "fstat() of a pipe fd is not supported"
     )
     def test_nonblock_pipe_write_bigbuf(self):
         self._test_nonblock_pipe_write(16*1024)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(
         support.is_emscripten, "fstat() of a pipe fd is not supported"
     )
@@ -4822,6 +4836,22 @@ class CMiscIOTest(MiscIOTest):
     name_of_module = "io", "_io"
     extra_exported = "BlockingIOError",
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; BufferedWriter seeks on non-seekable pipe
+    def test_nonblock_pipe_write_bigbuf(self):
+        return super().test_nonblock_pipe_write_bigbuf()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; BufferedWriter seeks on non-seekable pipe
+    def test_nonblock_pipe_write_smallbuf(self):
+        return super().test_nonblock_pipe_write_smallbuf()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_warn_on_dealloc(self):
+        return super().test_warn_on_dealloc()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_warn_on_dealloc_fd(self):
+        return super().test_warn_on_dealloc_fd()
+
     def test_readinto_buffer_overflow(self):
         # Issue #18025
         class BadReader(self.io.BufferedIOBase):
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 3917c0a76d9..5c5d2a9600f 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -1554,8 +1554,6 @@ def test_communicate_epipe_only_stdin(self):
         p.wait()
         p.communicate(b"x" * 2**20)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(hasattr(signal, 'SIGUSR1'),
                          "Requires signal.SIGUSR1")
     @unittest.skipUnless(hasattr(os, 'kill'),
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index 635a1c1c85a..4cf233d5f8b 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -1050,19 +1050,15 @@ def _test_sparse_file(self, name):
             s = os.stat(filename)
             self.assertLess(s.st_blocks * 512, s.st_size)
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_old(self):
         self._test_sparse_file("gnu/sparse")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_00(self):
         self._test_sparse_file("gnu/sparse-0.0")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_01(self):
         self._test_sparse_file("gnu/sparse-0.1")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_10(self):
         self._test_sparse_file("gnu/sparse-1.0")
 
diff --git a/crates/common/src/crt_fd.rs b/crates/common/src/crt_fd.rs
index 7b8279adbe3..b873ef9c52c 100644
--- a/crates/common/src/crt_fd.rs
+++ b/crates/common/src/crt_fd.rs
@@ -334,7 +334,21 @@ pub fn close(fd: Owned) -> io::Result<()> {
 }
 
 pub fn ftruncate(fd: Borrowed<'_>, len: Offset) -> io::Result<()> {
-    cvt(unsafe { suppress_iph!(c::ftruncate(fd.as_raw(), len)) })?;
+    let ret = unsafe { suppress_iph!(c::ftruncate(fd.as_raw(), len)) };
+    // On Windows, _chsize_s returns 0 on success, or a positive error code (errno value) on failure.
+    // On other platforms, ftruncate returns 0 on success, or -1 on failure with errno set.
+    #[cfg(windows)]
+    {
+        if ret != 0 {
+            // _chsize_s returns errno directly, convert to Windows error code
+            let winerror = crate::os::errno_to_winerror(ret);
+            return Err(io::Error::from_raw_os_error(winerror));
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        cvt(ret)?;
+    }
     Ok(())
 }
 
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
index 6c34844696d..2ebb05075e4 100644
--- a/crates/derive-impl/src/pystructseq.rs
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -22,6 +22,8 @@ enum FieldKind {
 struct ParsedField {
     ident: Ident,
     kind: FieldKind,
+    /// Optional cfg attributes for conditional compilation
+    cfg_attrs: Vec<syn::Attribute>,
 }
 
 /// Parsed field info from struct
@@ -31,27 +33,24 @@ struct FieldInfo {
 }
 
 impl FieldInfo {
-    fn named_fields(&self) -> Vec<Ident> {
+    fn named_fields(&self) -> Vec<&ParsedField> {
         self.fields
             .iter()
             .filter(|f| f.kind == FieldKind::Named)
-            .map(|f| f.ident.clone())
             .collect()
     }
 
-    fn visible_fields(&self) -> Vec<Ident> {
+    fn visible_fields(&self) -> Vec<&ParsedField> {
         self.fields
             .iter()
             .filter(|f| f.kind != FieldKind::Skipped)
-            .map(|f| f.ident.clone())
             .collect()
     }
 
-    fn skipped_fields(&self) -> Vec<Ident> {
+    fn skipped_fields(&self) -> Vec<&ParsedField> {
         self.fields
             .iter()
             .filter(|f| f.kind == FieldKind::Skipped)
-            .map(|f| f.ident.clone())
             .collect()
     }
 
@@ -82,8 +81,15 @@ fn parse_fields(input: &mut DeriveInput) -> Result<FieldInfo> {
         let mut skip = false;
         let mut unnamed = false;
         let mut attrs_to_remove = Vec::new();
+        let mut cfg_attrs = Vec::new();
 
         for (i, attr) in field.attrs.iter().enumerate() {
+            // Collect cfg attributes for conditional compilation
+            if attr.path().is_ident("cfg") {
+                cfg_attrs.push(attr.clone());
+                continue;
+            }
+
             if !attr.path().is_ident("pystruct_sequence") {
                 continue;
             }
@@ -135,7 +141,11 @@ fn parse_fields(input: &mut DeriveInput) -> Result<FieldInfo> {
             FieldKind::Named
         };
 
-        parsed_fields.push(ParsedField { ident, kind });
+        parsed_fields.push(ParsedField {
+            ident,
+            kind,
+            cfg_attrs,
+        });
     }
 
     Ok(FieldInfo {
@@ -194,18 +204,91 @@ pub(crate) fn impl_pystruct_sequence_data(
     let skipped_fields = field_info.skipped_fields();
     let n_unnamed_fields = field_info.n_unnamed_fields();
 
-    // Generate field index constants for visible fields
+    // Generate field index constants for visible fields (with cfg guards)
     let field_indices: Vec<_> = visible_fields
         .iter()
         .enumerate()
         .map(|(i, field)| {
-            let const_name = format_ident!("{}_INDEX", field.to_string().to_uppercase());
+            let const_name = format_ident!("{}_INDEX", field.ident.to_string().to_uppercase());
+            let cfg_attrs = &field.cfg_attrs;
             quote! {
+                #(#cfg_attrs)*
                 pub const #const_name: usize = #i;
             }
         })
         .collect();
 
+    // Generate field name entries with cfg guards for named fields
+    let named_field_names: Vec<_> = named_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! { stringify!(#ident), }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { stringify!(#ident) },
+                }
+            }
+        })
+        .collect();
+
+    // Generate field name entries with cfg guards for skipped fields
+    let skipped_field_names: Vec<_> = skipped_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! { stringify!(#ident), }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { stringify!(#ident) },
+                }
+            }
+        })
+        .collect();
+
+    // Generate into_tuple items with cfg guards
+    let visible_tuple_items: Vec<_> = visible_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! {
+                    ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm),
+                }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm) },
+                }
+            }
+        })
+        .collect();
+
+    let skipped_tuple_items: Vec<_> = skipped_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! {
+                    ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm),
+                }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm) },
+                }
+            }
+        })
+        .collect();
+
     // Generate TryFromObject impl only when try_from_object=true
     let try_from_object_impl = if try_from_object {
         let n_required = visible_fields.len();
@@ -233,6 +316,8 @@ pub(crate) fn impl_pystruct_sequence_data(
 
     // Generate try_from_elements trait override only when try_from_object=true
     let try_from_elements_trait_override = if try_from_object {
+        let visible_field_idents: Vec<_> = visible_fields.iter().map(|f| &f.ident).collect();
+        let skipped_field_idents: Vec<_> = skipped_fields.iter().map(|f| &f.ident).collect();
         quote! {
             fn try_from_elements(
                 elements: Vec<::rustpython_vm::PyObjectRef>,
@@ -240,8 +325,8 @@ pub(crate) fn impl_pystruct_sequence_data(
             ) -> ::rustpython_vm::PyResult<Self> {
                 let mut iter = elements.into_iter();
                 Ok(Self {
-                    #(#visible_fields: iter.next().unwrap().clone().try_into_value(vm)?,)*
-                    #(#skipped_fields: match iter.next() {
+                    #(#visible_field_idents: iter.next().unwrap().clone().try_into_value(vm)?,)*
+                    #(#skipped_field_idents: match iter.next() {
                         Some(v) => v.clone().try_into_value(vm)?,
                         None => vm.ctx.none(),
                     },)*
@@ -259,20 +344,14 @@ pub(crate) fn impl_pystruct_sequence_data(
 
         // PyStructSequenceData trait impl
         impl ::rustpython_vm::types::PyStructSequenceData for #data_ident {
-            const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#named_fields),)*];
-            const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#skipped_fields),)*];
+            const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(#named_field_names)*];
+            const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(#skipped_field_names)*];
             const UNNAMED_FIELDS_LEN: usize = #n_unnamed_fields;
 
             fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
                 let items = vec![
-                    #(::rustpython_vm::convert::ToPyObject::to_pyobject(
-                        self.#visible_fields,
-                        vm,
-                    ),)*
-                    #(::rustpython_vm::convert::ToPyObject::to_pyobject(
-                        self.#skipped_fields,
-                        vm,
-                    ),)*
+                    #(#visible_tuple_items)*
+                    #(#skipped_tuple_items)*
                 ];
                 ::rustpython_vm::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
             }
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 0e2051e5498..4e8b572e457 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -1592,6 +1592,9 @@ pub(super) mod types {
         filename2: PyAtomicRef<Option<PyObject>>,
         #[cfg(windows)]
         winerror: PyAtomicRef<Option<PyObject>>,
+        // For BlockingIOError: characters written before blocking occurred
+        // -1 means not set (AttributeError when accessed)
+        written: AtomicCell<isize>,
     }
 
     impl crate::class::PySubclass for PyOSError {
@@ -1666,6 +1669,7 @@ pub(super) mod types {
                 filename2: filename2.into(),
                 #[cfg(windows)]
                 winerror: None.into(),
+                written: AtomicCell::new(-1),
             })
         }
 
@@ -1707,8 +1711,14 @@ pub(super) mod types {
             #[allow(deprecated)]
             let exc: &Py<PyOSError> = zelf.downcast_ref::<PyOSError>().unwrap();
 
+            // Check if this is BlockingIOError - need to handle characters_written
+            let is_blocking_io_error =
+                zelf.class()
+                    .is(vm.ctx.exceptions.blocking_io_error.as_ref());
+
             // SAFETY: slot_init is called during object initialization,
             // so fields are None and swap result can be safely ignored
+            let mut set_filename = true;
             if len <= 5 {
                 // Only set errno/strerror when args len is 2-5
                 if 2 <= len {
@@ -1716,7 +1726,22 @@ pub(super) mod types {
                     let _ = unsafe { exc.strerror.swap(Some(new_args.args[1].clone())) };
                 }
                 if 3 <= len {
-                    let _ = unsafe { exc.filename.swap(Some(new_args.args[2].clone())) };
+                    let third_arg = &new_args.args[2];
+                    // BlockingIOError's 3rd argument can be the number of characters written
+                    if is_blocking_io_error
+                        && !vm.is_none(third_arg)
+                        && crate::protocol::PyNumber::check(third_arg)
+                        && let Ok(written) = third_arg.try_index(vm)
+                        && let Ok(n) = written.try_to_primitive::<isize>(vm)
+                    {
+                        exc.written.store(n);
+                        set_filename = false;
+                        // Clear filename that was set in py_new
+                        let _ = unsafe { exc.filename.swap(None) };
+                    }
+                    if set_filename {
+                        let _ = unsafe { exc.filename.swap(Some(third_arg.clone())) };
+                    }
                 }
                 #[cfg(windows)]
                 if 4 <= len {
@@ -1938,6 +1963,47 @@ pub(super) mod types {
         fn set_winerror(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
             self.winerror.swap_to_temporary_refs(value, vm);
         }
+
+        #[pygetset]
+        fn characters_written(&self, vm: &VirtualMachine) -> PyResult<isize> {
+            let written = self.written.load();
+            if written == -1 {
+                Err(vm.new_attribute_error("characters_written".to_owned()))
+            } else {
+                Ok(written)
+            }
+        }
+
+        #[pygetset(setter)]
+        fn set_characters_written(
+            &self,
+            value: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            match value {
+                None => {
+                    // Deleting the attribute
+                    if self.written.load() == -1 {
+                        Err(vm.new_attribute_error("characters_written".to_owned()))
+                    } else {
+                        self.written.store(-1);
+                        Ok(())
+                    }
+                }
+                Some(v) => {
+                    let n = v
+                        .try_index(vm)?
+                        .try_to_primitive::<isize>(vm)
+                        .map_err(|_| {
+                            vm.new_value_error(
+                                "cannot convert characters_written value to isize".to_owned(),
+                            )
+                        })?;
+                    self.written.store(n);
+                    Ok(())
+                }
+            }
+        }
     }
 
     #[pyexception(name, base = PyOSError, ctx = "blocking_io_error", impl)]
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index a02965797bc..0167df2bed4 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -9,6 +9,15 @@ cfg_if::cfg_if! {
     }
 }
 
+// EAGAIN constant for BlockingIOError
+cfg_if::cfg_if! {
+    if #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] {
+        const EAGAIN: i32 = libc::EAGAIN;
+    } else {
+        const EAGAIN: i32 = 11; // Standard POSIX value
+    }
+}
+
 use crate::{
     PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{PyBaseExceptionRef, PyModule},
@@ -159,6 +168,7 @@ mod _io {
         },
         common::wtf8::{Wtf8, Wtf8Buf},
         convert::ToPyObject,
+        exceptions::cstring_error,
         function::{
             ArgBytesLike, ArgIterable, ArgMemoryBuffer, ArgSize, Either, FuncArgs, IntoFuncArgs,
             OptionalArg, OptionalOption, PySetterValue,
@@ -169,6 +179,7 @@ mod _io {
         recursion::ReprGuard,
         types::{
             Callable, Constructor, DefaultConstructor, Destructor, Initializer, IterNext, Iterable,
+            Representable,
         },
         vm::VirtualMachine,
     };
@@ -202,6 +213,35 @@ mod _io {
         }
     }
 
+    /// Check if an error is an OSError with errno == EINTR.
+    /// If so, call check_signals() and return Ok(None) to indicate retry.
+    /// Otherwise, return Ok(Some(val)) for success or Err for other errors.
+    /// This mirrors CPythons _PyIO_trap_eintr() pattern.
+    #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+    fn trap_eintr<T>(result: PyResult<T>, vm: &VirtualMachine) -> PyResult<Option<T>> {
+        match result {
+            Ok(val) => Ok(Some(val)),
+            Err(exc) => {
+                // Check if its an OSError with errno == EINTR
+                if exc.fast_isinstance(vm.ctx.exceptions.os_error)
+                    && let Ok(errno_attr) = exc.as_object().get_attr("errno", vm)
+                    && let Ok(errno_val) = i32::try_from_object(vm, errno_attr)
+                    && errno_val == libc::EINTR
+                {
+                    vm.check_signals()?;
+                    return Ok(None);
+                }
+                Err(exc)
+            }
+        }
+    }
+
+    /// WASM version: no EINTR handling needed
+    #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
+    fn trap_eintr<T>(result: PyResult<T>, _vm: &VirtualMachine) -> PyResult<Option<T>> {
+        result.map(Some)
+    }
+
     pub fn new_unsupported_operation(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
         vm.new_os_subtype_error(unsupported_operation().to_owned(), None, msg)
             .upcast()
@@ -650,17 +690,26 @@ mod _io {
             if let Some(size) = size.to_usize() {
                 // FIXME: unnecessary zero-init
                 let b = PyByteArray::from(vec![0; size]).into_ref(&vm.ctx);
-                let n = <Option<usize>>::try_from_object(
+                let n = <Option<isize>>::try_from_object(
                     vm,
                     vm.call_method(&instance, "readinto", (b.clone(),))?,
                 )?;
-                Ok(n.map(|n| {
-                    let mut bytes = b.borrow_buf_mut();
-                    bytes.truncate(n);
-                    // FIXME: try to use Arc::unwrap on the bytearray to get at the inner buffer
-                    bytes.clone()
+                Ok(match n {
+                    None => vm.ctx.none(),
+                    Some(n) => {
+                        // Validate the return value is within bounds
+                        if n < 0 || (n as usize) > size {
+                            return Err(vm.new_value_error(format!(
+                                "readinto returned {n} outside buffer size {size}"
+                            )));
+                        }
+                        let n = n as usize;
+                        let mut bytes = b.borrow_buf_mut();
+                        bytes.truncate(n);
+                        // FIXME: try to use Arc::unwrap on the bytearray to get at the inner buffer
+                        bytes.clone().to_pyobject(vm)
+                    }
                 })
-                .to_pyobject(vm))
             } else {
                 vm.call_method(&instance, "readall", ())
             }
@@ -671,7 +720,14 @@ mod _io {
             let mut chunks = Vec::new();
             let mut total_len = 0;
             loop {
-                let data = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,))?;
+                // Loop with EINTR handling (PEP 475)
+                let data = loop {
+                    let res = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,));
+                    match trap_eintr(res, vm)? {
+                        Some(val) => break val,
+                        None => continue,
+                    }
+                };
                 let data = <Option<PyBytesRef>>::try_from_object(vm, data)?;
                 match data {
                     None => {
@@ -885,12 +941,20 @@ mod _io {
             while self.write_pos < self.write_end {
                 let n =
                     self.raw_write(None, self.write_pos as usize..self.write_end as usize, vm)?;
-                let n = n.ok_or_else(|| {
-                    vm.new_exception_msg(
-                        vm.ctx.exceptions.blocking_io_error.to_owned(),
-                        "write could not complete without blocking".to_owned(),
-                    )
-                })?;
+                let n = match n {
+                    Some(n) => n,
+                    None => {
+                        // BlockingIOError(errno, msg, characters_written=0)
+                        return Err(vm.invoke_exception(
+                            vm.ctx.exceptions.blocking_io_error.to_owned(),
+                            vec![
+                                vm.new_pyobj(EAGAIN),
+                                vm.new_pyobj("write could not complete without blocking"),
+                                vm.new_pyobj(0),
+                            ],
+                        )?);
+                    }
+                };
                 self.write_pos += n as Offset;
                 self.raw_pos = self.write_pos;
                 vm.check_signals()?;
@@ -1082,15 +1146,16 @@ mod _io {
                             let buffer_size = self.buffer.len() as _;
                             self.adjust_position(buffer_size);
                             self.write_end = buffer_size;
-                            // TODO: BlockingIOError(errno, msg, written)
-                            // written += self.buffer.len();
-                            return Err(vm
-                                .new_os_subtype_error(
-                                    vm.ctx.exceptions.blocking_io_error.to_owned(),
-                                    None,
-                                    "write could not complete without blocking".to_owned(),
-                                )
-                                .upcast());
+                            // BlockingIOError(errno, msg, characters_written)
+                            let chars_written = written + buffer_len;
+                            return Err(vm.invoke_exception(
+                                vm.ctx.exceptions.blocking_io_error.to_owned(),
+                                vec![
+                                    vm.new_pyobj(EAGAIN),
+                                    vm.new_pyobj("write could not complete without blocking"),
+                                    vm.new_pyobj(chars_written),
+                                ],
+                            )?);
                         } else {
                             break;
                         }
@@ -1156,7 +1221,7 @@ mod _io {
                     }
                 };
             }
-            while remaining > 0 {
+            while remaining > 0 && !self.buffer.is_empty() {
                 // MINUS_LAST_BLOCK() in CPython
                 let r = self.buffer.len() * (remaining / self.buffer.len());
                 if r == 0 {
@@ -1227,30 +1292,60 @@ mod _io {
                     )?
                     .into_ref(&vm.ctx);
 
-                    // TODO: loop if readinto() raises an interrupt
-                    let res =
-                        vm.call_method(self.raw.as_ref().unwrap(), "readinto", (mem_obj.clone(),));
+                    // Loop if readinto() raises EINTR (PEP 475)
+                    let res = loop {
+                        let res = vm.call_method(
+                            self.raw.as_ref().unwrap(),
+                            "readinto",
+                            (mem_obj.clone(),),
+                        );
+                        match trap_eintr(res, vm) {
+                            Ok(Some(val)) => break Ok(val),
+                            Ok(None) => continue, // EINTR, retry
+                            Err(e) => break Err(e),
+                        }
+                    };
 
                     mem_obj.release();
+                    // Always restore the buffer, even if an error occurred
                     *v = read_buf.take();
 
                     res?
                 }
                 Either::B(buf) => {
-                    let mem_obj = PyMemoryView::from_buffer_range(buf, buf_range, vm)?;
-                    // TODO: loop if readinto() raises an interrupt
-                    vm.call_method(self.raw.as_ref().unwrap(), "readinto", (mem_obj,))?
+                    let mem_obj =
+                        PyMemoryView::from_buffer_range(buf, buf_range, vm)?.into_ref(&vm.ctx);
+                    // Loop if readinto() raises EINTR (PEP 475)
+                    loop {
+                        let res = vm.call_method(
+                            self.raw.as_ref().unwrap(),
+                            "readinto",
+                            (mem_obj.clone(),),
+                        );
+                        match trap_eintr(res, vm)? {
+                            Some(val) => break val,
+                            None => continue,
+                        }
+                    }
                 }
             };
 
             if vm.is_none(&res) {
                 return Ok(None);
             }
-            let n = isize::try_from_object(vm, res)?;
+            // Try to convert to int; if it fails, treat as -1 and chain the TypeError
+            let (n, type_error) = match isize::try_from_object(vm, res.clone()) {
+                Ok(n) => (n, None),
+                Err(e) => (-1, Some(e)),
+            };
             if n < 0 || n as usize > len {
-                return Err(vm.new_os_error(format!(
+                let os_error = vm.new_os_error(format!(
                     "raw readinto() returned invalid length {n} (should have been between 0 and {len})"
-                )));
+                ));
+                if let Some(cause) = type_error {
+                    os_error.set___cause__(Some(cause));
+                }
+                return Err(os_error);
             }
             if n > 0 && self.abs_pos != -1 {
                 self.abs_pos += n as Offset
@@ -1293,7 +1388,14 @@ mod _io {
 
             let mut read_size = 0;
             loop {
-                let read_data = vm.call_method(self.raw.as_ref().unwrap(), "read", ())?;
+                // Loop with EINTR handling (PEP 475)
+                let read_data = loop {
+                    let res = vm.call_method(self.raw.as_ref().unwrap(), "read", ());
+                    match trap_eintr(res, vm)? {
+                        Some(val) => break val,
+                        None => continue,
+                    }
+                };
                 let read_data = <Option<PyBytesRef>>::try_from_object(vm, read_data)?;
 
                 match read_data {
@@ -1564,9 +1666,10 @@ mod _io {
             let pos = pos.flatten().to_pyobject(vm);
             let mut data = zelf.lock(vm)?;
             data.check_init(vm)?;
-            if data.writable() {
-                data.flush_rewind(vm)?;
+            if !data.writable() {
+                return Err(new_unsupported_operation(vm, "truncate".to_owned()));
             }
+            data.flush_rewind(vm)?;
             let res = vm.call_method(data.raw.as_ref().unwrap(), "truncate", (pos,))?;
             let _ = data.raw_tell(vm);
             Ok(res)
@@ -2400,7 +2503,13 @@ mod _io {
                 None if vm.state.config.settings.utf8_mode > 0 => {
                     identifier_utf8!(vm, utf_8).to_owned()
                 }
-                Some(enc) if enc.as_str() != "locale" => enc,
+                Some(enc) if enc.as_str() != "locale" => {
+                    // Check for embedded null character
+                    if enc.as_str().contains('\0') {
+                        return Err(cstring_error(vm));
+                    }
+                    enc
+                }
                 _ => {
                     // None without utf8_mode or "locale" encoding
                     vm.import("locale", 0)?
@@ -2414,6 +2523,11 @@ mod _io {
                 .errors
                 .unwrap_or_else(|| identifier!(vm, strict).to_owned());
 
+            // Check for embedded null character in errors (use as_wtf8 to handle surrogates)
+            if errors.as_wtf8().as_bytes().contains(&0) {
+                return Err(cstring_error(vm));
+            }
+
             let has_read1 = vm.get_attribute_opt(buffer.clone(), "read1")?.is_some();
             let seekable = vm.call_method(&buffer, "seekable", ())?.try_to_bool(vm)?;
 
@@ -2519,7 +2633,14 @@ mod _io {
     }
 
     #[pyclass(
-        with(Constructor, Initializer, Destructor, Iterable, IterNext),
+        with(
+            Constructor,
+            Initializer,
+            Destructor,
+            Iterable,
+            IterNext,
+            Representable
+        ),
         flags(BASETYPE)
     )]
     impl TextIOWrapper {
@@ -3396,6 +3517,46 @@ mod _io {
         }
     }
 
+    impl Representable for TextIOWrapper {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let type_name = zelf.class().slot_name();
+            let Some(data) = zelf.data.lock() else {
+                // Reentrant call
+                return Ok(format!("<{type_name}>"));
+            };
+            let Some(data) = data.as_ref() else {
+                return Err(vm.new_value_error("I/O operation on uninitialized object".to_owned()));
+            };
+
+            let mut result = format!("<{type_name}");
+
+            // Add name if present
+            if let Ok(Some(name)) = vm.get_attribute_opt(data.buffer.clone(), "name")
+                && let Ok(name_repr) = name.repr(vm)
+            {
+                result.push_str(" name=");
+                result.push_str(name_repr.as_str());
+            }
+
+            // Add mode if present
+            if let Ok(Some(mode)) = vm.get_attribute_opt(data.buffer.clone(), "mode")
+                && let Ok(mode_repr) = mode.repr(vm)
+            {
+                result.push_str(" mode=");
+                result.push_str(mode_repr.as_str());
+            }
+
+            // Add encoding
+            result.push_str(" encoding='");
+            result.push_str(data.encoding.as_str());
+            result.push('\'');
+
+            result.push('>');
+            Ok(result)
+        }
+    }
+
     impl Iterable for TextIOWrapper {
         fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             check_closed(&zelf, vm)?;
@@ -4465,7 +4626,7 @@ mod fileio {
     }
 
     #[pyattr]
-    #[pyclass(module = "io", name, base = _RawIOBase)]
+    #[pyclass(module = "_io", name, base = _RawIOBase)]
     #[derive(Debug)]
     pub(super) struct FileIO {
         _base: _RawIOBase,
@@ -4473,6 +4634,7 @@ mod fileio {
         closefd: AtomicCell<bool>,
         mode: AtomicCell<Mode>,
         seekable: AtomicCell<Option<bool>>,
+        blksize: AtomicCell<i64>,
     }
 
     #[derive(FromArgs)]
@@ -4495,6 +4657,7 @@ mod fileio {
                 closefd: AtomicCell::new(true),
                 mode: AtomicCell::new(Mode::empty()),
                 seekable: AtomicCell::new(None),
+                blksize: AtomicCell::new(8 * 1024), // DEFAULT_BUFFER_SIZE
             }
         }
     }
@@ -4507,6 +4670,15 @@ mod fileio {
         fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             // TODO: let atomic_flag_works
             let name = args.name;
+            // 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 {
@@ -4557,6 +4729,7 @@ 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));
@@ -4576,12 +4749,25 @@ mod fileio {
                 match fd_fstat {
                     Ok(status) => {
                         if (status.st_mode & libc::S_IFMT) == libc::S_IFDIR {
+                            // If fd was passed by user, don't close it on error
+                            if !fd_is_own {
+                                zelf.fd.store(-1);
+                            }
                             let err = std::io::Error::from_raw_os_error(libc::EISDIR);
                             return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
+                        // Store st_blksize for _blksize property
+                        if status.st_blksize > 1 {
+                            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+                            zelf.blksize.store(i64::from(status.st_blksize));
+                        }
                     }
                     Err(err) => {
                         if err.raw_os_error() == Some(libc::EBADF) {
+                            // If fd was passed by user, don't close it on error
+                            if !fd_is_own {
+                                zelf.fd.store(-1);
+                            }
                             return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
                     }
@@ -4590,7 +4776,13 @@ mod fileio {
 
             #[cfg(windows)]
             crate::stdlib::msvcrt::setmode_binary(fd);
-            zelf.as_object().set_attr("name", name, vm)?;
+            if let Err(e) = zelf.as_object().set_attr("name", name, vm) {
+                // If fd was passed by user, don't close it on error
+                if !fd_is_own {
+                    zelf.fd.store(-1);
+                }
+                return Err(e);
+            }
 
             if mode.contains(Mode::APPENDING) {
                 let _ = os::lseek(fd, 0, libc::SEEK_END, vm);
@@ -4603,17 +4795,18 @@ mod fileio {
     impl Representable for FileIO {
         #[inline]
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let type_name = zelf.class().slot_name();
             let fd = zelf.fd.load();
             if fd < 0 {
-                return Ok("<_io.FileIO [closed]>".to_owned());
+                return Ok(format!("<{type_name} [closed]>"));
             }
             let name_repr = repr_file_obj_name(zelf.as_object(), vm)?;
             let mode = zelf.mode();
             let closefd = if zelf.closefd.load() { "True" } else { "False" };
             let repr = if let Some(name_repr) = name_repr {
-                format!("<_io.FileIO name={name_repr} mode='{mode}' closefd={closefd}>")
+                format!("<{type_name} name={name_repr} mode='{mode}' closefd={closefd}>")
             } else {
-                format!("<_io.FileIO fd={fd} mode='{mode}' closefd={closefd}>")
+                format!("<{type_name} fd={fd} mode='{mode}' closefd={closefd}>")
             };
             Ok(repr)
         }
@@ -4648,6 +4841,11 @@ mod fileio {
             self.closefd.load()
         }
 
+        #[pygetset(name = "_blksize")]
+        fn blksize(&self) -> i64 {
+            self.blksize.load()
+        }
+
         #[pymethod]
         fn fileno(&self, vm: &VirtualMachine) -> PyResult<i32> {
             let fd = self.fd.load();
@@ -4664,13 +4862,19 @@ mod fileio {
         }
 
         #[pymethod]
-        fn readable(&self) -> bool {
-            self.mode.load().contains(Mode::READABLE)
+        fn readable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.mode.load().contains(Mode::READABLE))
         }
 
         #[pymethod]
-        fn writable(&self) -> bool {
-            self.mode.load().contains(Mode::WRITABLE)
+        fn writable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.mode.load().contains(Mode::WRITABLE))
         }
 
         #[pygetset]
@@ -4714,16 +4918,32 @@ mod fileio {
             let mut handle = zelf.get_fd(vm)?;
             let bytes = if let Some(read_byte) = read_byte.to_usize() {
                 let mut bytes = vec![0; read_byte];
-                let n = handle
-                    .read(&mut bytes)
-                    .map_err(|err| Self::io_error(zelf, err, vm))?;
+                // Loop on EINTR (PEP 475)
+                let n = loop {
+                    match handle.read(&mut bytes) {
+                        Ok(n) => break n,
+                        Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        Err(e) => return Err(Self::io_error(zelf, e, vm)),
+                    }
+                };
                 bytes.truncate(n);
                 bytes
             } else {
                 let mut bytes = vec![];
-                handle
-                    .read_to_end(&mut bytes)
-                    .map_err(|err| Self::io_error(zelf, err, vm))?;
+                // Loop on EINTR (PEP 475)
+                loop {
+                    match handle.read_to_end(&mut bytes) {
+                        Ok(_) => break,
+                        Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        Err(e) => return Err(Self::io_error(zelf, e, vm)),
+                    }
+                }
                 bytes
             };
 
@@ -4743,9 +4963,17 @@ mod fileio {
 
             let mut buf = obj.borrow_buf_mut();
             let mut f = handle.take(buf.len() as _);
-            let ret = f
-                .read(&mut buf)
-                .map_err(|err| Self::io_error(zelf, err, vm))?;
+            // Loop on EINTR (PEP 475)
+            let ret = loop {
+                match f.read(&mut buf) {
+                    Ok(n) => break n,
+                    Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                        vm.check_signals()?;
+                        continue;
+                    }
+                    Err(e) => return Err(Self::io_error(zelf, e, vm)),
+                }
+            };
 
             Ok(ret)
         }
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index f20046a1a66..6849ea365df 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -893,6 +893,15 @@ pub(super) mod _os {
         #[pyarg(any, default)]
         #[pystruct_sequence(skip)]
         pub st_ctime_ns: i128,
+        // Unix-specific attributes
+        #[cfg(not(windows))]
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_blksize: i64,
+        #[cfg(not(windows))]
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_blocks: i64,
         #[pyarg(any, default)]
         #[pystruct_sequence(skip)]
         pub st_reparse_tag: u32,
@@ -945,6 +954,13 @@ pub(super) mod _os {
             #[cfg(not(windows))]
             let st_ino = stat.st_ino;
 
+            #[cfg(not(windows))]
+            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            let st_blksize = i64::from(stat.st_blksize);
+            #[cfg(not(windows))]
+            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            let st_blocks = i64::from(stat.st_blocks);
+
             Self {
                 st_mode: vm.ctx.new_pyref(stat.st_mode),
                 st_ino: vm.ctx.new_pyref(st_ino),
@@ -962,6 +978,10 @@ pub(super) mod _os {
                 st_atime_ns: to_ns(atime),
                 st_mtime_ns: to_ns(mtime),
                 st_ctime_ns: to_ns(ctime),
+                #[cfg(not(windows))]
+                st_blksize,
+                #[cfg(not(windows))]
+                st_blocks,
                 st_reparse_tag,
                 st_file_attributes,
             }

From 476b75de499c413a5b0668c96a1099acaf30484a Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 28 Dec 2025 20:36:15 +0900
Subject: [PATCH 099/418] Upgrade test_io from 3.13.11 and fix more io tests
 (#6565)

* fix various test_io

* Upgrade test_io from 3.13.11

* Fix more test_io
---
 Lib/test/test_io.py                   |  99 +++++++-------
 crates/derive-impl/src/pystructseq.rs |  47 ++++++-
 crates/vm/src/stdlib/io.rs            | 189 ++++++++++++++++++++++----
 3 files changed, 249 insertions(+), 86 deletions(-)

diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 2cf84d9aae9..1e594c49640 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -1818,10 +1818,6 @@ def test_garbage_collection(self):
             support.gc_collect()
         self.assertIsNone(wr(), wr)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
     def test_args_error(self):
         # Issue #17275
         with self.assertRaisesRegex(TypeError, "BufferedReader"):
@@ -1844,12 +1840,8 @@ def test_bad_readinto_type(self):
         self.assertIsInstance(cm.exception.__cause__, TypeError)
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_flush_error_on_close(self):
-        return super().test_flush_error_on_close()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_seek_character_device_file(self):
-        return super().test_seek_character_device_file()
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
 
     def test_truncate_on_read_only(self):
         return super().test_truncate_on_read_only()
@@ -2166,10 +2158,6 @@ def test_slow_close_from_thread(self):
 class CBufferedWriterTest(BufferedWriterTest, SizeofTest):
     tp = io.BufferedWriter
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
     def test_initialization(self):
         rawio = self.MockRawIO()
         bufio = self.tp(rawio)
@@ -2205,8 +2193,8 @@ def test_args_error(self):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_flush_error_on_close(self):
-        return super().test_flush_error_on_close()
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
 
     @unittest.skip('TODO: RUSTPYTHON; fallible allocation')
     def test_constructor(self):
@@ -2692,10 +2680,6 @@ def test_interleaved_readline_write(self):
 class CBufferedRandomTest(BufferedRandomTest, SizeofTest):
     tp = io.BufferedRandom
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
     @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
@@ -2708,16 +2692,8 @@ def test_args_error(self):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_flush_error_on_close(self):
-        return super().test_flush_error_on_close()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_seek_character_device_file(self):
-        return super().test_seek_character_device_file()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; f.read1(1) returns b'a'
-    def test_read1_after_write(self):
-        return super().test_read1_after_write()
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
 
     @unittest.skip('TODO: RUSTPYTHON; fallible allocation')
     def test_constructor(self):
@@ -3395,7 +3371,24 @@ def test_multibyte_seek_and_tell(self):
         self.assertEqual(f.tell(), p1)
         f.close()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_tell_after_readline_with_cr(self):
+        # Test for gh-141314: TextIOWrapper.tell() assertion failure
+        # when dealing with standalone carriage returns
+        data = b'line1\r'
+        with self.open(os_helper.TESTFN, "wb") as f:
+            f.write(data)
+
+        with self.open(os_helper.TESTFN, "r") as f:
+            # Read line that ends with \r
+            line = f.readline()
+            self.assertEqual(line, "line1\n")
+            # This should not cause an assertion failure
+            pos = f.tell()
+            # Verify we can seek back to this position
+            f.seek(pos)
+            remaining = f.read()
+            self.assertEqual(remaining, "")
+
     def test_seek_with_encoder_state(self):
         f = self.open(os_helper.TESTFN, "w", encoding="euc_jis_2004")
         f.write("\u00e6\u0300")
@@ -4130,10 +4123,6 @@ class CTextIOWrapperTest(TextIOWrapperTest):
     io = io
     shutdown_error = "LookupError: unknown encoding: ascii"
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_error_through_destructor(self):
-        return super().test_error_through_destructor()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_initialization(self):
         r = self.BytesIO(b"\xc3\xa9\n\n")
@@ -4291,6 +4280,10 @@ def test_reconfigure_write_fromascii(self):
     def test_reconfigure_write_through(self):
         return super().test_reconfigure_write_through()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
+
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_repr(self):
         return super().test_repr()
@@ -4306,6 +4299,11 @@ def test_recursive_repr(self):
     def test_pickling_subclass(self):
         return super().test_pickling_subclass()
 
+    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
+    @unittest.expectedFailure
+    def test_seek_with_encoder_state(self):
+        return super().test_seek_with_encoder_state()
+
 
 class PyTextIOWrapperTest(TextIOWrapperTest):
     io = pyio
@@ -4319,6 +4317,11 @@ def test_constructor(self):
     def test_newlines(self):
         return super().test_newlines()
 
+    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
+    @unittest.expectedFailure
+    def test_seek_with_encoder_state(self):
+        return super().test_seek_with_encoder_state()
+
 
 class IncrementalNewlineDecoderTest(unittest.TestCase):
 
@@ -4836,22 +4839,6 @@ class CMiscIOTest(MiscIOTest):
     name_of_module = "io", "_io"
     extra_exported = "BlockingIOError",
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; BufferedWriter seeks on non-seekable pipe
-    def test_nonblock_pipe_write_bigbuf(self):
-        return super().test_nonblock_pipe_write_bigbuf()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON; BufferedWriter seeks on non-seekable pipe
-    def test_nonblock_pipe_write_smallbuf(self):
-        return super().test_nonblock_pipe_write_smallbuf()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_warn_on_dealloc(self):
-        return super().test_warn_on_dealloc()
-
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_warn_on_dealloc_fd(self):
-        return super().test_warn_on_dealloc_fd()
-
     def test_readinto_buffer_overflow(self):
         # Issue #18025
         class BadReader(self.io.BufferedIOBase):
@@ -4916,6 +4903,16 @@ def test_daemon_threads_shutdown_stderr_deadlock(self):
     def test_check_encoding_errors(self):
         return super().test_check_encoding_errors()
 
+    # TODO: RUSTPYTHON; ResourceWarning not triggered by _io.FileIO
+    @unittest.expectedFailure
+    def test_warn_on_dealloc(self):
+        return super().test_warn_on_dealloc()
+
+    # TODO: RUSTPYTHON; ResourceWarning not triggered by _io.FileIO
+    @unittest.expectedFailure
+    def test_warn_on_dealloc_fd(self):
+        return super().test_warn_on_dealloc_fd()
+
 
 class PyMiscIOTest(MiscIOTest):
     io = pyio
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
index 2ebb05075e4..32b603fe478 100644
--- a/crates/derive-impl/src/pystructseq.rs
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -316,8 +316,44 @@ pub(crate) fn impl_pystruct_sequence_data(
 
     // Generate try_from_elements trait override only when try_from_object=true
     let try_from_elements_trait_override = if try_from_object {
-        let visible_field_idents: Vec<_> = visible_fields.iter().map(|f| &f.ident).collect();
-        let skipped_field_idents: Vec<_> = skipped_fields.iter().map(|f| &f.ident).collect();
+        let visible_field_inits: Vec<_> = visible_fields
+            .iter()
+            .map(|f| {
+                let ident = &f.ident;
+                let cfg_attrs = &f.cfg_attrs;
+                if cfg_attrs.is_empty() {
+                    quote! { #ident: iter.next().unwrap().clone().try_into_value(vm)?, }
+                } else {
+                    quote! {
+                        #(#cfg_attrs)*
+                        #ident: iter.next().unwrap().clone().try_into_value(vm)?,
+                    }
+                }
+            })
+            .collect();
+        let skipped_field_inits: Vec<_> = skipped_fields
+            .iter()
+            .map(|f| {
+                let ident = &f.ident;
+                let cfg_attrs = &f.cfg_attrs;
+                if cfg_attrs.is_empty() {
+                    quote! {
+                        #ident: match iter.next() {
+                            Some(v) => v.clone().try_into_value(vm)?,
+                            None => vm.ctx.none(),
+                        },
+                    }
+                } else {
+                    quote! {
+                        #(#cfg_attrs)*
+                        #ident: match iter.next() {
+                            Some(v) => v.clone().try_into_value(vm)?,
+                            None => vm.ctx.none(),
+                        },
+                    }
+                }
+            })
+            .collect();
         quote! {
             fn try_from_elements(
                 elements: Vec<::rustpython_vm::PyObjectRef>,
@@ -325,11 +361,8 @@ pub(crate) fn impl_pystruct_sequence_data(
             ) -> ::rustpython_vm::PyResult<Self> {
                 let mut iter = elements.into_iter();
                 Ok(Self {
-                    #(#visible_field_idents: iter.next().unwrap().clone().try_into_value(vm)?,)*
-                    #(#skipped_field_idents: match iter.next() {
-                        Some(v) => v.clone().try_into_value(vm)?,
-                        None => vm.ctx.none(),
-                    },)*
+                    #(#visible_field_inits)*
+                    #(#skipped_field_inits)*
                 })
             }
         }
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 0167df2bed4..89dc8bca925 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -191,6 +191,7 @@ mod _io {
         borrow::Cow,
         io::{self, Cursor, SeekFrom, prelude::*},
         ops::Range,
+        sync::atomic::{AtomicBool, Ordering},
     };
 
     #[allow(clippy::let_and_return)]
@@ -935,7 +936,7 @@ mod _io {
             let rewind = self.raw_offset() + (self.pos - self.write_pos);
             if rewind != 0 {
                 self.raw_seek(-rewind, 1, vm)?;
-                self.raw_pos = -rewind;
+                self.raw_pos -= rewind;
             }
 
             while self.write_pos < self.write_end {
@@ -999,7 +1000,10 @@ mod _io {
                     };
                     if offset >= -self.pos && offset <= available {
                         self.pos += offset;
-                        return Ok(current - available + offset);
+                        // GH-95782: character devices may report raw position 0
+                        // even after reading, which would make this negative
+                        let result = current - available + offset;
+                        return Ok(if result < 0 { 0 } else { result });
                     }
                 }
             }
@@ -1111,9 +1115,51 @@ mod _io {
                 }
             }
 
-            // TODO: something something check if error is BlockingIOError?
-            let _ = self.flush(vm);
+            // if BlockingIOError, shift buffer
+            // and try to buffer the new data; otherwise propagate the error
+            match self.flush(vm) {
+                Ok(()) => {}
+                Err(e) if e.fast_isinstance(vm.ctx.exceptions.blocking_io_error) => {
+                    if self.readable() {
+                        self.reset_read();
+                    }
+                    // Shift buffer and adjust positions
+                    let shift = self.write_pos;
+                    if shift > 0 {
+                        self.buffer
+                            .copy_within(shift as usize..self.write_end as usize, 0);
+                        self.write_end -= shift;
+                        self.raw_pos -= shift;
+                        self.pos -= shift;
+                        self.write_pos = 0;
+                    }
+                    let avail = self.buffer.len() - self.write_end as usize;
+                    if buf_len <= avail {
+                        // Everything can be buffered
+                        let buf = obj.borrow_buf();
+                        self.buffer[self.write_end as usize..][..buf_len].copy_from_slice(&buf);
+                        self.write_end += buf_len as Offset;
+                        self.pos += buf_len as Offset;
+                        return Ok(buf_len);
+                    }
+                    // Buffer as much as possible and return BlockingIOError
+                    let buf = obj.borrow_buf();
+                    self.buffer[self.write_end as usize..][..avail].copy_from_slice(&buf[..avail]);
+                    self.write_end += avail as Offset;
+                    self.pos += avail as Offset;
+                    return Err(vm.invoke_exception(
+                        vm.ctx.exceptions.blocking_io_error.to_owned(),
+                        vec![
+                            vm.new_pyobj(EAGAIN),
+                            vm.new_pyobj("write could not complete without blocking"),
+                            vm.new_pyobj(avail),
+                        ],
+                    )?);
+                }
+                Err(e) => return Err(e),
+            }
 
+            // Only reach here if flush succeeded
             let offset = self.raw_offset();
             if offset != 0 {
                 self.raw_seek(-offset, 1, vm)?;
@@ -1556,6 +1602,7 @@ mod _io {
         const SEEKABLE: bool = false;
 
         fn data(&self) -> &PyThreadMutex<BufferedData>;
+        fn closing(&self) -> &AtomicBool;
 
         fn lock(&self, vm: &VirtualMachine) -> PyResult<PyThreadMutexGuard<'_, BufferedData>> {
             self.data()
@@ -1694,19 +1741,25 @@ mod _io {
             Ok(self.lock(vm)?.raw.clone())
         }
 
+        /// Get raw stream without holding the lock (for calling Python code safely)
+        fn get_raw_unlocked(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            let data = self.lock(vm)?;
+            Ok(data.check_init(vm)?.to_owned())
+        }
+
         #[pygetset]
         fn closed(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("closed", vm)
+            self.get_raw_unlocked(vm)?.get_attr("closed", vm)
         }
 
         #[pygetset]
         fn name(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("name", vm)
+            self.get_raw_unlocked(vm)?.get_attr("name", vm)
         }
 
         #[pygetset]
         fn mode(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("mode", vm)
+            self.get_raw_unlocked(vm)?.get_attr("mode", vm)
         }
 
         #[pymethod]
@@ -1750,17 +1803,19 @@ mod _io {
 
         #[pymethod]
         fn close(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-            {
+            // Don't hold the lock while calling Python code to avoid reentrant lock issues
+            let raw = {
                 let data = zelf.lock(vm)?;
                 let raw = data.check_init(vm)?;
                 if file_closed(raw, vm)? {
                     return Ok(vm.ctx.none());
                 }
-            }
+                raw.to_owned()
+            };
+            // Set closing flag so that concurrent write() calls will fail
+            zelf.closing().store(true, Ordering::Release);
             let flush_res = vm.call_method(zelf.as_object(), "flush", ()).map(drop);
-            let data = zelf.lock(vm)?;
-            let raw = data.raw.as_ref().unwrap();
-            let close_res = vm.call_method(raw, "close", ());
+            let close_res = vm.call_method(&raw, "close", ());
             exception_chain(flush_res, close_res)
         }
 
@@ -1774,10 +1829,9 @@ mod _io {
             Self::WRITABLE
         }
 
-        // TODO: this should be the default for an equivalent of _PyObject_GetState
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
     }
 
@@ -1830,6 +1884,10 @@ mod _io {
                 let n = std::cmp::min(have as usize, n);
                 return Ok(data.read_fast(n).unwrap());
             }
+            // Flush write buffer before reading
+            if data.writable() {
+                data.flush_rewind(vm)?;
+            }
             let mut v = vec![0; n];
             data.reset_read();
             let r = data
@@ -1855,6 +1913,19 @@ mod _io {
             ensure_unclosed(raw, "readinto of closed file", vm)?;
             data.readinto_generic(buf.into(), true, vm)
         }
+
+        #[pymethod]
+        fn flush(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // For read-only buffers, flush just calls raw.flush()
+            // Don't hold the lock while calling Python code to avoid reentrant lock issues
+            let raw = {
+                let data = self.reader().lock(vm)?;
+                data.check_init(vm)?.to_owned()
+            };
+            ensure_unclosed(&raw, "flush of closed file", vm)?;
+            vm.call_method(&raw, "flush", ())?;
+            Ok(())
+        }
     }
 
     fn exception_chain<T>(e1: PyResult<()>, e2: PyResult<T>) -> PyResult<T> {
@@ -1874,6 +1945,7 @@ mod _io {
     struct BufferedReader {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedReader {
@@ -1884,6 +1956,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedReadable for BufferedReader {
@@ -1922,6 +1998,27 @@ mod _io {
 
         #[pymethod]
         fn write(&self, obj: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+            // Check if close() is in progress (Issue #31976)
+            // If closing, wait for close() to complete by spinning until raw is closed.
+            // Note: This spin-wait has no timeout because close() is expected to always
+            // complete (flush + fd close).
+            if self.writer().closing().load(Ordering::Acquire) {
+                loop {
+                    let raw = {
+                        let data = self.writer().lock(vm)?;
+                        match &data.raw {
+                            Some(raw) => raw.to_owned(),
+                            None => break, // detached
+                        }
+                    };
+                    if file_closed(&raw, vm)? {
+                        break;
+                    }
+                    // Yield to other threads
+                    std::thread::yield_now();
+                }
+                return Err(vm.new_value_error("write to closed file".to_owned()));
+            }
             let mut data = self.writer().lock(vm)?;
             let raw = data.check_init(vm)?;
             ensure_unclosed(raw, "write to closed file", vm)?;
@@ -1944,6 +2041,7 @@ mod _io {
     struct BufferedWriter {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedWriter {
@@ -1954,6 +2052,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedWritable for BufferedWriter {
@@ -1990,6 +2092,7 @@ mod _io {
     struct BufferedRandom {
         _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedRandom {
@@ -2001,6 +2104,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedReadable for BufferedRandom {
@@ -3347,8 +3454,8 @@ mod _io {
         }
 
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
     }
 
@@ -4908,7 +5015,7 @@ mod fileio {
             zelf: &Py<Self>,
             read_byte: OptionalSize,
             vm: &VirtualMachine,
-        ) -> PyResult<Vec<u8>> {
+        ) -> PyResult<Option<Vec<u8>>> {
             if !zelf.mode.load().contains(Mode::READABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4926,6 +5033,10 @@ mod fileio {
                             vm.check_signals()?;
                             continue;
                         }
+                        // Non-blocking mode: return None if EAGAIN
+                        Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => {
+                            return Ok(None);
+                        }
                         Err(e) => return Err(Self::io_error(zelf, e, vm)),
                     }
                 };
@@ -4941,17 +5052,28 @@ mod fileio {
                             vm.check_signals()?;
                             continue;
                         }
+                        // Non-blocking mode: return None if EAGAIN (only if no data read yet)
+                        Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => {
+                            if bytes.is_empty() {
+                                return Ok(None);
+                            }
+                            break;
+                        }
                         Err(e) => return Err(Self::io_error(zelf, e, vm)),
                     }
                 }
                 bytes
             };
 
-            Ok(bytes)
+            Ok(Some(bytes))
         }
 
         #[pymethod]
-        fn readinto(zelf: &Py<Self>, obj: ArgMemoryBuffer, vm: &VirtualMachine) -> PyResult<usize> {
+        fn readinto(
+            zelf: &Py<Self>,
+            obj: ArgMemoryBuffer,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<usize>> {
             if !zelf.mode.load().contains(Mode::READABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4971,15 +5093,23 @@ mod fileio {
                         vm.check_signals()?;
                         continue;
                     }
+                    // Non-blocking mode: return None if EAGAIN
+                    Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => {
+                        return Ok(None);
+                    }
                     Err(e) => return Err(Self::io_error(zelf, e, vm)),
                 }
             };
 
-            Ok(ret)
+            Ok(Some(ret))
         }
 
         #[pymethod]
-        fn write(zelf: &Py<Self>, obj: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+        fn write(
+            zelf: &Py<Self>,
+            obj: ArgBytesLike,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<usize>> {
             if !zelf.mode.load().contains(Mode::WRITABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4989,12 +5119,15 @@ mod fileio {
 
             let mut handle = zelf.get_fd(vm)?;
 
-            let len = obj
-                .with_ref(|b| handle.write(b))
-                .map_err(|err| Self::io_error(zelf, err, vm))?;
+            let len = match obj.with_ref(|b| handle.write(b)) {
+                Ok(n) => n,
+                // Non-blocking mode: return None if EAGAIN
+                Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => return Ok(None),
+                Err(e) => return Err(Self::io_error(zelf, e, vm)),
+            };
 
             //return number of bytes written
-            Ok(len)
+            Ok(Some(len))
         }
 
         #[pymethod]
@@ -5060,8 +5193,8 @@ mod fileio {
         }
 
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
     }
 

From d1ff2cde776ad737ffaa120a0eaf5340899a3ffb Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 29 Dec 2025 11:21:11 +0900
Subject: [PATCH 100/418] RichCompare contains pymethod. No AtomicCell for
 slots (#6562)

* slots: add comparison pymethods to Comparable trait

* No AtomicCell
---
 crates/stdlib/src/contextvars.rs   |   2 +-
 crates/stdlib/src/sqlite.rs        |  15 ++-
 crates/vm/src/protocol/mapping.rs  |  20 ++--
 crates/vm/src/protocol/sequence.rs |  52 +++++-----
 crates/vm/src/types/slot.rs        | 158 +++++++++++++++++++++--------
 5 files changed, 156 insertions(+), 91 deletions(-)

diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index 56c2657f585..f88ce398c1c 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -264,7 +264,7 @@ mod _contextvars {
                         Err(vm.new_key_error(needle.to_owned().into()))
                     }
                 }),
-                ass_subscript: AtomicCell::new(None),
+                ass_subscript: None,
             };
             &AS_MAPPING
         }
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index c760c2830d7..103a827e99a 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -20,7 +20,6 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 
 #[pymodule]
 mod _sqlite {
-    use crossbeam_utils::atomic::AtomicCell;
     use libsqlite3_sys::{
         SQLITE_BLOB, SQLITE_DETERMINISTIC, SQLITE_FLOAT, SQLITE_INTEGER, SQLITE_NULL,
         SQLITE_OPEN_CREATE, SQLITE_OPEN_READWRITE, SQLITE_OPEN_URI, SQLITE_TEXT, SQLITE_TRACE_STMT,
@@ -2549,19 +2548,19 @@ mod _sqlite {
     impl AsSequence for Blob {
         fn as_sequence() -> &'static PySequenceMethods {
             static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
-                length: AtomicCell::new(None),
-                concat: AtomicCell::new(None),
-                repeat: AtomicCell::new(None),
-                item: AtomicCell::new(None),
-                ass_item: AtomicCell::new(None),
+                length: None,
+                concat: None,
+                repeat: None,
+                item: None,
+                ass_item: None,
                 contains: atomic_func!(|seq, _needle, vm| {
                     Err(vm.new_type_error(format!(
                         "argument of type '{}' is not iterable",
                         seq.obj.class().name(),
                     )))
                 }),
-                inplace_concat: AtomicCell::new(None),
-                inplace_repeat: AtomicCell::new(None),
+                inplace_concat: None,
+                inplace_repeat: None,
             };
             &AS_SEQUENCE
         }
diff --git a/crates/vm/src/protocol/mapping.rs b/crates/vm/src/protocol/mapping.rs
index 36813bf1df8..43dafeb9238 100644
--- a/crates/vm/src/protocol/mapping.rs
+++ b/crates/vm/src/protocol/mapping.rs
@@ -35,13 +35,13 @@ impl PyMappingSlots {
 
     /// Copy from static PyMappingMethods
     pub fn copy_from(&self, methods: &PyMappingMethods) {
-        if let Some(f) = methods.length.load() {
+        if let Some(f) = methods.length {
             self.length.store(Some(f));
         }
-        if let Some(f) = methods.subscript.load() {
+        if let Some(f) = methods.subscript {
             self.subscript.store(Some(f));
         }
-        if let Some(f) = methods.ass_subscript.load() {
+        if let Some(f) = methods.ass_subscript {
             self.ass_subscript.store(Some(f));
         }
     }
@@ -50,11 +50,10 @@ impl PyMappingSlots {
 #[allow(clippy::type_complexity)]
 #[derive(Default)]
 pub struct PyMappingMethods {
-    pub length: AtomicCell<Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>>,
-    pub subscript: AtomicCell<Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub ass_subscript: AtomicCell<
+    pub length: Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>,
+    pub subscript: Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub ass_subscript:
         Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
-    >,
 }
 
 impl std::fmt::Debug for PyMappingMethods {
@@ -64,11 +63,10 @@ impl std::fmt::Debug for PyMappingMethods {
 }
 
 impl PyMappingMethods {
-    #[allow(clippy::declare_interior_mutable_const)]
     pub const NOT_IMPLEMENTED: Self = Self {
-        length: AtomicCell::new(None),
-        subscript: AtomicCell::new(None),
-        ass_subscript: AtomicCell::new(None),
+        length: None,
+        subscript: None,
+        ass_subscript: None,
     };
 }
 
diff --git a/crates/vm/src/protocol/sequence.rs b/crates/vm/src/protocol/sequence.rs
index a7576e63efb..888ef91565f 100644
--- a/crates/vm/src/protocol/sequence.rs
+++ b/crates/vm/src/protocol/sequence.rs
@@ -42,28 +42,28 @@ impl PySequenceSlots {
 
     /// Copy from static PySequenceMethods
     pub fn copy_from(&self, methods: &PySequenceMethods) {
-        if let Some(f) = methods.length.load() {
+        if let Some(f) = methods.length {
             self.length.store(Some(f));
         }
-        if let Some(f) = methods.concat.load() {
+        if let Some(f) = methods.concat {
             self.concat.store(Some(f));
         }
-        if let Some(f) = methods.repeat.load() {
+        if let Some(f) = methods.repeat {
             self.repeat.store(Some(f));
         }
-        if let Some(f) = methods.item.load() {
+        if let Some(f) = methods.item {
             self.item.store(Some(f));
         }
-        if let Some(f) = methods.ass_item.load() {
+        if let Some(f) = methods.ass_item {
             self.ass_item.store(Some(f));
         }
-        if let Some(f) = methods.contains.load() {
+        if let Some(f) = methods.contains {
             self.contains.store(Some(f));
         }
-        if let Some(f) = methods.inplace_concat.load() {
+        if let Some(f) = methods.inplace_concat {
             self.inplace_concat.store(Some(f));
         }
-        if let Some(f) = methods.inplace_repeat.load() {
+        if let Some(f) = methods.inplace_repeat {
             self.inplace_repeat.store(Some(f));
         }
     }
@@ -72,18 +72,15 @@ impl PySequenceSlots {
 #[allow(clippy::type_complexity)]
 #[derive(Default)]
 pub struct PySequenceMethods {
-    pub length: AtomicCell<Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>>,
-    pub concat: AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
-    pub item: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
-    pub ass_item: AtomicCell<
+    pub length: Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>,
+    pub concat: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub repeat: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
+    pub item: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
+    pub ass_item:
         Option<fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
-    >,
-    pub contains:
-        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>>,
-    pub inplace_concat:
-        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+    pub contains: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>,
+    pub inplace_concat: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub inplace_repeat: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
 }
 
 impl std::fmt::Debug for PySequenceMethods {
@@ -93,16 +90,15 @@ impl std::fmt::Debug for PySequenceMethods {
 }
 
 impl PySequenceMethods {
-    #[allow(clippy::declare_interior_mutable_const)]
     pub const NOT_IMPLEMENTED: Self = Self {
-        length: AtomicCell::new(None),
-        concat: AtomicCell::new(None),
-        repeat: AtomicCell::new(None),
-        item: AtomicCell::new(None),
-        ass_item: AtomicCell::new(None),
-        contains: AtomicCell::new(None),
-        inplace_concat: AtomicCell::new(None),
-        inplace_repeat: AtomicCell::new(None),
+        length: None,
+        concat: None,
+        repeat: None,
+        item: None,
+        ass_item: None,
+        contains: None,
+        inplace_concat: None,
+        inplace_repeat: None,
     };
 }
 
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 9823f189a26..658e21cba8a 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -113,7 +113,7 @@ impl<T: Any + 'static> std::ops::DerefMut for TypeDataRefMut<'_, T> {
 #[macro_export]
 macro_rules! atomic_func {
     ($x:expr) => {
-        crossbeam_utils::atomic::AtomicCell::new(Some($x))
+        Some($x)
     };
 }
 
@@ -385,6 +385,59 @@ fn setitem_wrapper<K: ToPyObject>(
     .map(drop)
 }
 
+#[inline(never)]
+fn mapping_setitem_wrapper(
+    mapping: PyMapping<'_>,
+    key: &PyObject,
+    value: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    setitem_wrapper(mapping.obj, key, value, vm)
+}
+
+#[inline(never)]
+fn mapping_getitem_wrapper(
+    mapping: PyMapping<'_>,
+    key: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult {
+    getitem_wrapper(mapping.obj, key, vm)
+}
+
+#[inline(never)]
+fn mapping_len_wrapper(mapping: PyMapping<'_>, vm: &VirtualMachine) -> PyResult<usize> {
+    len_wrapper(mapping.obj, vm)
+}
+
+#[inline(never)]
+fn sequence_len_wrapper(seq: PySequence<'_>, vm: &VirtualMachine) -> PyResult<usize> {
+    len_wrapper(seq.obj, vm)
+}
+
+#[inline(never)]
+fn sequence_getitem_wrapper(seq: PySequence<'_>, i: isize, vm: &VirtualMachine) -> PyResult {
+    getitem_wrapper(seq.obj, i, vm)
+}
+
+#[inline(never)]
+fn sequence_setitem_wrapper(
+    seq: PySequence<'_>,
+    i: isize,
+    value: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    setitem_wrapper(seq.obj, i, value, vm)
+}
+
+#[inline(never)]
+fn sequence_contains_wrapper(
+    seq: PySequence<'_>,
+    needle: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    contains_wrapper(seq.obj, needle, vm)
+}
+
 fn repr_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
     let ret = vm.call_special_method(zelf, identifier!(vm, __repr__), ())?;
     ret.downcast::<PyStr>().map_err(|obj| {
@@ -1139,12 +1192,7 @@ impl PyType {
 
             // === Sequence slots ===
             SlotAccessor::SqLength => {
-                update_sub_slot!(
-                    as_sequence,
-                    length,
-                    |seq, vm| len_wrapper(seq.obj, vm),
-                    SeqLength
-                )
+                update_sub_slot!(as_sequence, length, sequence_len_wrapper, SeqLength)
             }
             SlotAccessor::SqConcat | SlotAccessor::SqInplaceConcat => {
                 // Sequence concat uses sq_concat slot - no generic wrapper needed
@@ -1161,52 +1209,32 @@ impl PyType {
                 }
             }
             SlotAccessor::SqItem => {
-                update_sub_slot!(
-                    as_sequence,
-                    item,
-                    |seq, i, vm| getitem_wrapper(seq.obj, i, vm),
-                    SeqItem
-                )
+                update_sub_slot!(as_sequence, item, sequence_getitem_wrapper, SeqItem)
             }
             SlotAccessor::SqAssItem => {
-                update_sub_slot!(
-                    as_sequence,
-                    ass_item,
-                    |seq, i, value, vm| setitem_wrapper(seq.obj, i, value, vm),
-                    SeqAssItem
-                )
+                update_sub_slot!(as_sequence, ass_item, sequence_setitem_wrapper, SeqAssItem)
             }
             SlotAccessor::SqContains => {
                 update_sub_slot!(
                     as_sequence,
                     contains,
-                    |seq, needle, vm| contains_wrapper(seq.obj, needle, vm),
+                    sequence_contains_wrapper,
                     SeqContains
                 )
             }
 
             // === Mapping slots ===
             SlotAccessor::MpLength => {
-                update_sub_slot!(
-                    as_mapping,
-                    length,
-                    |mapping, vm| len_wrapper(mapping.obj, vm),
-                    MapLength
-                )
+                update_sub_slot!(as_mapping, length, mapping_len_wrapper, MapLength)
             }
             SlotAccessor::MpSubscript => {
-                update_sub_slot!(
-                    as_mapping,
-                    subscript,
-                    |mapping, key, vm| getitem_wrapper(mapping.obj, key, vm),
-                    MapSubscript
-                )
+                update_sub_slot!(as_mapping, subscript, mapping_getitem_wrapper, MapSubscript)
             }
             SlotAccessor::MpAssSubscript => {
                 update_sub_slot!(
                     as_mapping,
                     ass_subscript,
-                    |mapping, key, value, vm| setitem_wrapper(mapping.obj, key, value, vm),
+                    mapping_setitem_wrapper,
                     MapAssSubscript
                 )
             }
@@ -1484,8 +1512,6 @@ pub trait Hashable: PyPayload {
         Self::hash(zelf, vm)
     }
 
-    // __hash__ is now exposed via SlotFunc::Hash wrapper in extend_class()
-
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>;
 }
 
@@ -1535,8 +1561,60 @@ pub trait Comparable: PyPayload {
         vm: &VirtualMachine,
     ) -> PyResult<PyComparisonValue>;
 
-    // Comparison methods are exposed as wrapper_descriptor via slot_richcompare
-    // No #[pymethod] - add_operators creates wrapper from SLOT_DEFS
+    #[inline]
+    #[pymethod]
+    fn __eq__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Eq, vm)
+    }
+    #[inline]
+    #[pymethod]
+    fn __ne__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Ne, vm)
+    }
+    #[inline]
+    #[pymethod]
+    fn __lt__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Lt, vm)
+    }
+    #[inline]
+    #[pymethod]
+    fn __le__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Le, vm)
+    }
+    #[inline]
+    #[pymethod]
+    fn __ge__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Ge, vm)
+    }
+    #[inline]
+    #[pymethod]
+    fn __gt__(
+        zelf: &Py<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        Self::cmp(zelf, &other, PyComparisonOp::Gt, vm)
+    }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -1779,8 +1857,6 @@ pub trait Iterable: PyPayload {
         Self::iter(zelf, vm)
     }
 
-    // __iter__ is exposed via SlotFunc::Iter wrapper in extend_class()
-
     fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult;
 
     fn extend_slots(_slots: &mut PyTypeSlots) {}
@@ -1798,8 +1874,6 @@ pub trait IterNext: PyPayload + Iterable {
     }
 
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn>;
-
-    // __next__ is exposed via SlotFunc::IterNext wrapper in extend_class()
 }
 
 pub trait SelfIter: PyPayload {}
@@ -1814,8 +1888,6 @@ where
         unreachable!("slot must be overridden for {}", repr.as_str());
     }
 
-    // __iter__ is exposed via SlotFunc::Iter wrapper in extend_class()
-
     #[cold]
     fn iter(_zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {
         unreachable!("slot_iter is implemented");

From a7d417cf634459724180bfc299e49f79aca41db0 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sun, 28 Dec 2025 11:09:55 +0900
Subject: [PATCH 101/418] Fix socket.getattrinfo

---
 crates/stdlib/src/socket.rs | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 08b05b56aa8..8af0bdd8679 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -1951,13 +1951,31 @@ mod _socket {
             flags: opts.flags,
         };
 
-        let host = opts.host.as_ref().map(|s| s.as_str());
-        let port = opts.port.as_ref().map(|p| -> std::borrow::Cow<'_, str> {
-            match p {
-                Either::A(s) => s.as_str().into(),
-                Either::B(i) => i.to_string().into(),
+        // Encode host using IDNA encoding
+        let host_encoded: Option<String> = match opts.host.as_ref() {
+            Some(s) => {
+                let encoded =
+                    vm.state
+                        .codec_registry
+                        .encode_text(s.to_owned().into(), "idna", None, vm)?;
+                let host_str = std::str::from_utf8(encoded.as_bytes())
+                    .map_err(|_| vm.new_runtime_error("idna output is not utf8".to_owned()))?;
+                Some(host_str.to_owned())
             }
-        });
+            None => None,
+        };
+        let host = host_encoded.as_deref();
+
+        // Encode port using UTF-8
+        let port: Option<std::borrow::Cow<'_, str>> = match opts.port.as_ref() {
+            Some(Either::A(s)) => {
+                Some(std::borrow::Cow::Borrowed(s.to_str().ok_or_else(|| {
+                    vm.new_unicode_encode_error("surrogates not allowed".to_owned())
+                })?))
+            }
+            Some(Either::B(i)) => Some(std::borrow::Cow::Owned(i.to_string())),
+            None => None,
+        };
         let port = port.as_ref().map(|p| p.as_ref());
 
         let addrs = dns_lookup::getaddrinfo(host, port, Some(hints))

From 81c13347a4af4010a44790c37176a884b6a8146e Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 28 Dec 2025 19:15:45 +0900
Subject: [PATCH 102/418] CAN_ attrs

---
 crates/stdlib/src/socket.rs | 76 +++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 8af0bdd8679..f29b8cedbb7 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -138,6 +138,82 @@ mod _socket {
         SOL_CAN_RAW,
     };
 
+    // CAN BCM opcodes
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_SETUP: i32 = 1;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_DELETE: i32 = 2;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_READ: i32 = 3;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_SEND: i32 = 4;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_SETUP: i32 = 5;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_DELETE: i32 = 6;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_READ: i32 = 7;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_STATUS: i32 = 8;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_EXPIRED: i32 = 9;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_STATUS: i32 = 10;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_TIMEOUT: i32 = 11;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_CHANGED: i32 = 12;
+
+    // CAN BCM flags (linux/can/bcm.h)
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_SETTIMER: i32 = 0x0001;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_STARTTIMER: i32 = 0x0002;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_COUNTEVT: i32 = 0x0004;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_ANNOUNCE: i32 = 0x0008;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_CP_CAN_ID: i32 = 0x0010;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_FILTER_ID: i32 = 0x0020;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_CHECK_DLC: i32 = 0x0040;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_NO_AUTOTIMER: i32 = 0x0080;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_ANNOUNCE_RESUME: i32 = 0x0100;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_RESET_MULTI_IDX: i32 = 0x0200;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_RTR_FRAME: i32 = 0x0400;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_CAN_FD_FRAME: i32 = 0x0800;
+
     #[cfg(all(target_os = "linux", target_env = "gnu"))]
     #[pyattr]
     use c::SOL_RDS;

From 219b4e316b6aac26887cba455df1b56240b47e84 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 28 Dec 2025 19:15:50 +0900
Subject: [PATCH 103/418] DEFAULT_TIMEOUT

---
 crates/stdlib/src/socket.rs | 56 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index f29b8cedbb7..1350209a9c2 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -925,10 +925,64 @@ mod _socket {
             sock: Socket,
         ) -> io::Result<()> {
             self.family.store(family);
-            self.kind.store(socket_kind);
+            // Mask out SOCK_NONBLOCK and SOCK_CLOEXEC flags from stored type
+            // to ensure consistent cross-platform behavior
+            #[cfg(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            ))]
+            let masked_kind = socket_kind & !(c::SOCK_NONBLOCK | c::SOCK_CLOEXEC);
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            )))]
+            let masked_kind = socket_kind;
+            self.kind.store(masked_kind);
             self.proto.store(proto);
             let mut s = self.sock.write();
             let sock = s.insert(sock);
+            // If SOCK_NONBLOCK is set, use timeout 0 (non-blocking)
+            #[cfg(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            ))]
+            let timeout = if socket_kind & c::SOCK_NONBLOCK != 0 {
+                0.0
+            } else {
+                DEFAULT_TIMEOUT.load()
+            };
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            )))]
             let timeout = DEFAULT_TIMEOUT.load();
             self.timeout.store(timeout);
             if timeout >= 0.0 {

From 2271f7464240eb5380fe45776126de0526244d72 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 28 Dec 2025 18:25:44 +0900
Subject: [PATCH 104/418] del for socket

---
 Lib/test/test_socket.py     |  2 +
 crates/stdlib/src/socket.rs | 75 +++++++++++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+)

diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index d5a35a3253e..756603bd514 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -824,6 +824,8 @@ class GeneralModuleTests(unittest.TestCase):
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     @unittest.skipUnless(_socket is not None, 'need _socket module')
+    # TODO: RUSTPYTHON gc.is_tracked not implemented
+    @unittest.expectedFailure
     def test_socket_type(self):
         self.assertTrue(gc.is_tracked(_socket.socket))
         with self.assertRaisesRegex(TypeError, "immutable"):
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 1350209a9c2..aaa28a19c78 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -226,6 +226,48 @@ mod _socket {
     #[pyattr]
     use c::{AF_SYSTEM, PF_SYSTEM, SYSPROTO_CONTROL, TCP_KEEPALIVE};
 
+    // RFC3542 IPv6 socket options for macOS (netinet6/in6.h)
+    // Not available in libc, define manually
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVHOPLIMIT: i32 = 37;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVRTHDR: i32 = 38;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVHOPOPTS: i32 = 39;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVDSTOPTS: i32 = 40;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_USE_MIN_MTU: i32 = 42;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVPATHMTU: i32 = 43;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_PATHMTU: i32 = 44;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_NEXTHOP: i32 = 48;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_HOPOPTS: i32 = 49;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_DSTOPTS: i32 = 50;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDR: i32 = 51;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDRDSTOPTS: i32 = 57;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDR_TYPE_0: i32 = 0;
+
     #[cfg(windows)]
     #[pyattr]
     use c::{
@@ -491,6 +533,7 @@ mod _socket {
         target_os = "dragonfly",
         target_os = "freebsd",
         target_os = "linux",
+        target_vendor = "apple",
         windows
     ))]
     #[pyattr]
@@ -1597,6 +1640,38 @@ mod _socket {
             Ok(())
         }
 
+        #[pymethod]
+        fn __del__(&self, vm: &VirtualMachine) {
+            // Emit ResourceWarning if socket is still open
+            if self.sock.read().is_some() {
+                let laddr = if let Ok(sock) = self.sock()
+                    && let Ok(addr) = sock.local_addr()
+                    && let Ok(repr) = get_addr_tuple(&addr, vm).repr(vm)
+                {
+                    format!(", laddr={}", repr.as_str())
+                } else {
+                    String::new()
+                };
+
+                let msg = format!(
+                    "unclosed <socket.socket fd={}, family={}, type={}, proto={}{}>",
+                    self.fileno(),
+                    self.family.load(),
+                    self.kind.load(),
+                    self.proto.load(),
+                    laddr
+                );
+                let _ = crate::vm::warn::warn(
+                    vm.ctx.new_str(msg),
+                    Some(vm.ctx.exceptions.resource_warning.to_owned()),
+                    1,
+                    None,
+                    vm,
+                );
+            }
+            let _ = self.close();
+        }
+
         #[pymethod]
         #[inline]
         fn detach(&self) -> i64 {

From 5079ee8fe3b60de8112ac193157ab179b6d4b88d Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Mon, 29 Dec 2025 11:26:50 +0900
Subject: [PATCH 105/418] fix socket

---
 crates/stdlib/src/socket.rs | 648 +++++++++++++++++++++++++++++++++++-
 1 file changed, 645 insertions(+), 3 deletions(-)

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index aaa28a19c78..8ad699d60a8 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -63,6 +63,10 @@ mod _socket {
             SOL_SOCKET, SOMAXCONN, TCP_NODELAY, WSAEBADF, WSAECONNRESET, WSAENOTSOCK,
             WSAEWOULDBLOCK,
         };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            INVALID_SOCKET, SOCKET_ERROR, WSA_FLAG_OVERLAPPED, WSADuplicateSocketW,
+            WSAGetLastError, WSAIoctl, WSAPROTOCOL_INFOW, WSASocketW,
+        };
         pub use windows_sys::Win32::Networking::WinSock::{
             SO_REUSEADDR as SO_EXCLUSIVEADDRUSE, getprotobyname, getservbyname, getservbyport,
             getsockopt, setsockopt,
@@ -82,6 +86,7 @@ mod _socket {
         pub const AI_PASSIVE: i32 = windows_sys::Win32::Networking::WinSock::AI_PASSIVE as _;
         pub const AI_NUMERICHOST: i32 =
             windows_sys::Win32::Networking::WinSock::AI_NUMERICHOST as _;
+        pub const FROM_PROTOCOL_INFO: i32 = -1;
     }
     // constants
     #[pyattr(name = "has_ipv6")]
@@ -902,6 +907,21 @@ mod _socket {
             .map(|sock| sock as RawSocket)
     }
 
+    #[cfg(target_os = "linux")]
+    #[derive(FromArgs)]
+    struct SendmsgAfalgArgs {
+        #[pyarg(any, default)]
+        msg: Vec<ArgBytesLike>,
+        #[pyarg(named)]
+        op: u32,
+        #[pyarg(named, default)]
+        iv: Option<ArgBytesLike>,
+        #[pyarg(named, default)]
+        assoclen: OptionalArg<isize>,
+        #[pyarg(named, default)]
+        flags: i32,
+    }
+
     #[pyattr(name = "socket")]
     #[pyattr(name = "SocketType")]
     #[pyclass(name = "socket")]
@@ -1169,6 +1189,129 @@ mod _socket {
                     }
                     Ok(addr6.into())
                 }
+                #[cfg(target_os = "linux")]
+                c::AF_CAN => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_CAN address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    if tuple.is_empty() || tuple.len() > 2 {
+                        return Err(vm
+                            .new_type_error(
+                                "AF_CAN address must be a tuple (interface,) or (interface, addr)",
+                            )
+                            .into());
+                    }
+                    let interface: PyStrRef = tuple[0].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_CAN interface must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    let ifname = interface.as_str();
+
+                    // Get interface index
+                    let ifindex = if ifname.is_empty() {
+                        0 // Bind to all CAN interfaces
+                    } else {
+                        // Check interface name length (IFNAMSIZ is typically 16)
+                        if ifname.len() >= 16 {
+                            return Err(vm
+                                .new_os_error("interface name too long".to_owned())
+                                .into());
+                        }
+                        let cstr = std::ffi::CString::new(ifname)
+                            .map_err(|_| vm.new_os_error("invalid interface name".to_owned()))?;
+                        let idx = unsafe { libc::if_nametoindex(cstr.as_ptr()) };
+                        if idx == 0 {
+                            return Err(io::Error::last_os_error().into());
+                        }
+                        idx as i32
+                    };
+
+                    // Create sockaddr_can
+                    let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+                    let can_addr =
+                        &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_can;
+                    unsafe {
+                        (*can_addr).can_family = libc::AF_CAN as libc::sa_family_t;
+                        (*can_addr).can_ifindex = ifindex;
+                    }
+                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    Ok(unsafe {
+                        socket2::SockAddr::new(
+                            storage,
+                            std::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
+                        )
+                    })
+                }
+                #[cfg(target_os = "linux")]
+                c::AF_ALG => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    if tuple.len() != 2 {
+                        return Err(vm
+                            .new_type_error("AF_ALG address must be a tuple (type, name)")
+                            .into());
+                    }
+                    let alg_type: PyStrRef = tuple[0].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG type must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    let alg_name: PyStrRef = tuple[1].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG name must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+
+                    let type_str = alg_type.as_str();
+                    let name_str = alg_name.as_str();
+
+                    // salg_type is 14 bytes, salg_name is 64 bytes
+                    if type_str.len() >= 14 {
+                        return Err(vm.new_value_error("type too long".to_owned()).into());
+                    }
+                    if name_str.len() >= 64 {
+                        return Err(vm.new_value_error("name too long".to_owned()).into());
+                    }
+
+                    // Create sockaddr_alg
+                    let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+                    let alg_addr =
+                        &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_alg;
+                    unsafe {
+                        (*alg_addr).salg_family = libc::AF_ALG as libc::sa_family_t;
+                        // Copy type string
+                        for (i, b) in type_str.bytes().enumerate() {
+                            (*alg_addr).salg_type[i] = b;
+                        }
+                        // Copy name string
+                        for (i, b) in name_str.bytes().enumerate() {
+                            (*alg_addr).salg_name[i] = b;
+                        }
+                    }
+                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    Ok(unsafe {
+                        socket2::SockAddr::new(
+                            storage,
+                            std::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
+                        )
+                    })
+                }
                 _ => Err(vm.new_os_error(format!("{caller}(): bad family")).into()),
             }
         }
@@ -1256,11 +1399,90 @@ mod _socket {
             let mut family = family.unwrap_or(-1);
             let mut socket_kind = socket_kind.unwrap_or(-1);
             let mut proto = proto.unwrap_or(-1);
+
+            let sock;
+
+            // On Windows, fileno can be bytes from socket.share() for fromshare()
+            #[cfg(windows)]
+            if let Some(fileno_obj) = fileno.flatten() {
+                use crate::vm::builtins::PyBytes;
+                if let Ok(bytes) = fileno_obj.clone().downcast::<PyBytes>() {
+                    let bytes_data = bytes.as_bytes();
+                    let expected_size = std::mem::size_of::<c::WSAPROTOCOL_INFOW>();
+
+                    if bytes_data.len() != expected_size {
+                        return Err(vm
+                            .new_value_error(format!(
+                                "socket descriptor string has wrong size, should be {} bytes",
+                                expected_size
+                            ))
+                            .into());
+                    }
+
+                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { std::mem::zeroed() };
+                    unsafe {
+                        std::ptr::copy_nonoverlapping(
+                            bytes_data.as_ptr(),
+                            &mut info as *mut c::WSAPROTOCOL_INFOW as *mut u8,
+                            expected_size,
+                        );
+                    }
+
+                    let fd = unsafe {
+                        c::WSASocketW(
+                            c::FROM_PROTOCOL_INFO,
+                            c::FROM_PROTOCOL_INFO,
+                            c::FROM_PROTOCOL_INFO,
+                            &info,
+                            0,
+                            c::WSA_FLAG_OVERLAPPED,
+                        )
+                    };
+
+                    if fd == c::INVALID_SOCKET {
+                        return Err(Self::wsa_error().into());
+                    }
+
+                    crate::vm::stdlib::nt::raw_set_handle_inheritable(fd as _, false)?;
+
+                    family = info.iAddressFamily;
+                    socket_kind = info.iSocketType;
+                    proto = info.iProtocol;
+
+                    sock = unsafe { sock_from_raw_unchecked(fd as RawSocket) };
+                    return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+                }
+
+                // Not bytes, treat as regular fileno
+                let fileno = get_raw_sock(fileno_obj, vm)?;
+                sock = sock_from_raw(fileno, vm)?;
+                match sock.local_addr() {
+                    Ok(addr) if family == -1 => family = addr.family() as i32,
+                    Err(e)
+                        if family == -1
+                            || matches!(
+                                e.raw_os_error(),
+                                Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
+                            ) =>
+                    {
+                        std::mem::forget(sock);
+                        return Err(e.into());
+                    }
+                    _ => {}
+                }
+                if socket_kind == -1 {
+                    socket_kind = sock.r#type().map_err(|e| e.into_pyexception(vm))?.into();
+                }
+                proto = 0;
+                return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+            }
+
+            #[cfg(not(windows))]
             let fileno = fileno
                 .flatten()
                 .map(|obj| get_raw_sock(obj, vm))
                 .transpose()?;
-            let sock;
+            #[cfg(not(windows))]
             if let Some(fileno) = fileno {
                 sock = sock_from_raw(fileno, vm)?;
                 match sock.local_addr() {
@@ -1294,7 +1516,11 @@ mod _socket {
                         proto = 0;
                     }
                 }
-            } else {
+                return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+            }
+
+            // No fileno provided, create new socket
+            {
                 if family == -1 {
                     family = c::AF_INET as _
                 }
@@ -1576,6 +1802,248 @@ mod _socket {
             .map_err(|e| e.into_pyexception(vm))
         }
 
+        /// sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags]]]) -> int
+        ///
+        /// Set operation mode and target IV for an AF_ALG socket.
+        #[cfg(target_os = "linux")]
+        #[pymethod]
+        fn sendmsg_afalg(&self, args: SendmsgAfalgArgs, vm: &VirtualMachine) -> PyResult<usize> {
+            let msg = args.msg;
+            let op = args.op;
+            let iv = args.iv;
+            let flags = args.flags;
+
+            // Validate assoclen - must be non-negative if provided
+            let assoclen: Option<u32> = match args.assoclen {
+                OptionalArg::Present(val) if val < 0 => {
+                    return Err(vm.new_type_error("assoclen must be non-negative".to_owned()));
+                }
+                OptionalArg::Present(val) => Some(val as u32),
+                OptionalArg::Missing => None,
+            };
+
+            // Build control messages for AF_ALG
+            let mut control_buf = Vec::new();
+
+            // Add ALG_SET_OP control message
+            {
+                let op_bytes = op.to_ne_bytes();
+                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_OP;
+                    let data = libc::CMSG_DATA(cmsg);
+                    std::ptr::copy_nonoverlapping(op_bytes.as_ptr(), data, op_bytes.len());
+                }
+            }
+
+            // Add ALG_SET_IV control message if iv is provided
+            if let Some(iv_data) = iv {
+                let iv_bytes = iv_data.borrow_buf();
+                // struct af_alg_iv { __u32 ivlen; __u8 iv[]; }
+                let iv_struct_size = 4 + iv_bytes.len();
+                let space = unsafe { libc::CMSG_SPACE(iv_struct_size as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(iv_struct_size as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_IV;
+                    let data = libc::CMSG_DATA(cmsg);
+                    // Write ivlen
+                    let ivlen = (iv_bytes.len() as u32).to_ne_bytes();
+                    std::ptr::copy_nonoverlapping(ivlen.as_ptr(), data, 4);
+                    // Write iv
+                    std::ptr::copy_nonoverlapping(iv_bytes.as_ptr(), data.add(4), iv_bytes.len());
+                }
+            }
+
+            // Add ALG_SET_AEAD_ASSOCLEN control message if assoclen is provided
+            if let Some(assoclen_val) = assoclen {
+                let assoclen_bytes = assoclen_val.to_ne_bytes();
+                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_AEAD_ASSOCLEN;
+                    let data = libc::CMSG_DATA(cmsg);
+                    std::ptr::copy_nonoverlapping(
+                        assoclen_bytes.as_ptr(),
+                        data,
+                        assoclen_bytes.len(),
+                    );
+                }
+            }
+
+            // Build buffers
+            let buffers = msg.iter().map(|buf| buf.borrow_buf()).collect::<Vec<_>>();
+            let iovecs: Vec<libc::iovec> = buffers
+                .iter()
+                .map(|buf| libc::iovec {
+                    iov_base: buf.as_ptr() as *mut _,
+                    iov_len: buf.len(),
+                })
+                .collect();
+
+            // Set up msghdr
+            let mut msghdr: libc::msghdr = unsafe { std::mem::zeroed() };
+            msghdr.msg_iov = iovecs.as_ptr() as *mut _;
+            msghdr.msg_iovlen = iovecs.len() as _;
+            if !control_buf.is_empty() {
+                msghdr.msg_control = control_buf.as_mut_ptr() as *mut _;
+                msghdr.msg_controllen = control_buf.len() as _;
+            }
+
+            self.sock_op(vm, SelectKind::Write, || {
+                let sock = self.sock()?;
+                let fd = sock_fileno(&sock);
+                let ret = unsafe { libc::sendmsg(fd as libc::c_int, &msghdr, flags) };
+                if ret < 0 {
+                    Err(io::Error::last_os_error())
+                } else {
+                    Ok(ret as usize)
+                }
+            })
+            .map_err(|e| e.into_pyexception(vm))
+        }
+
+        /// recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)
+        ///
+        /// Receive normal data and ancillary data from the socket.
+        #[cfg(all(unix, not(target_os = "redox")))]
+        #[pymethod]
+        fn recvmsg(
+            &self,
+            bufsize: isize,
+            ancbufsize: OptionalArg<isize>,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyTupleRef> {
+            use std::mem::MaybeUninit;
+
+            if bufsize < 0 {
+                return Err(vm.new_value_error("negative buffer size in recvmsg".to_owned()));
+            }
+            let bufsize = bufsize as usize;
+
+            let ancbufsize = ancbufsize.unwrap_or(0);
+            if ancbufsize < 0 {
+                return Err(
+                    vm.new_value_error("negative ancillary buffer size in recvmsg".to_owned())
+                );
+            }
+            let ancbufsize = ancbufsize as usize;
+            let flags = flags.unwrap_or(0);
+
+            // Allocate buffers
+            let mut data_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); bufsize];
+            let mut anc_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); ancbufsize];
+            let mut addr_storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+
+            // Set up iovec
+            let mut iov = [libc::iovec {
+                iov_base: data_buf.as_mut_ptr().cast(),
+                iov_len: bufsize,
+            }];
+
+            // Set up msghdr
+            let mut msg: libc::msghdr = unsafe { std::mem::zeroed() };
+            msg.msg_name = (&mut addr_storage as *mut libc::sockaddr_storage).cast();
+            msg.msg_namelen = std::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
+            msg.msg_iov = iov.as_mut_ptr();
+            msg.msg_iovlen = 1;
+            if ancbufsize > 0 {
+                msg.msg_control = anc_buf.as_mut_ptr().cast();
+                msg.msg_controllen = ancbufsize as _;
+            }
+
+            let n = self
+                .sock_op(vm, SelectKind::Read, || {
+                    let sock = self.sock()?;
+                    let fd = sock_fileno(&sock);
+                    let ret = unsafe { libc::recvmsg(fd as libc::c_int, &mut msg, flags) };
+                    if ret < 0 {
+                        Err(io::Error::last_os_error())
+                    } else {
+                        Ok(ret as usize)
+                    }
+                })
+                .map_err(|e| e.into_pyexception(vm))?;
+
+            // Build data bytes
+            let data = unsafe {
+                data_buf.set_len(n);
+                std::mem::transmute::<Vec<MaybeUninit<u8>>, Vec<u8>>(data_buf)
+            };
+
+            // Build ancdata list
+            let ancdata = Self::parse_ancillary_data(&msg, vm)?;
+
+            // Build address tuple
+            let address = if msg.msg_namelen > 0 {
+                let storage: socket2::SockAddrStorage =
+                    unsafe { std::mem::transmute(addr_storage) };
+                let addr = unsafe { socket2::SockAddr::new(storage, msg.msg_namelen) };
+                get_addr_tuple(&addr, vm)
+            } else {
+                vm.ctx.none()
+            };
+
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_bytes(data).into(),
+                ancdata,
+                vm.ctx.new_int(msg.msg_flags).into(),
+                address,
+            ]))
+        }
+
+        /// Parse ancillary data from a received message header
+        #[cfg(all(unix, not(target_os = "redox")))]
+        fn parse_ancillary_data(msg: &libc::msghdr, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            let mut result = Vec::new();
+
+            // Calculate buffer end for truncation handling
+            let ctrl_buf = msg.msg_control as *const u8;
+            let ctrl_end = unsafe { ctrl_buf.add(msg.msg_controllen as _) };
+
+            let mut cmsg: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(msg) };
+            while !cmsg.is_null() {
+                let cmsg_ref = unsafe { &*cmsg };
+                let data_ptr = unsafe { libc::CMSG_DATA(cmsg) };
+
+                // Calculate data length, respecting buffer truncation
+                let data_len_from_cmsg =
+                    cmsg_ref.cmsg_len as usize - (data_ptr as usize - cmsg as usize);
+                let available = ctrl_end as usize - data_ptr as usize;
+                let data_len = data_len_from_cmsg.min(available);
+
+                let data = unsafe { std::slice::from_raw_parts(data_ptr, data_len) };
+
+                let tuple = vm.ctx.new_tuple(vec![
+                    vm.ctx.new_int(cmsg_ref.cmsg_level).into(),
+                    vm.ctx.new_int(cmsg_ref.cmsg_type).into(),
+                    vm.ctx.new_bytes(data.to_vec()).into(),
+                ]);
+
+                result.push(tuple.into());
+
+                cmsg = unsafe { libc::CMSG_NXTHDR(msg, cmsg) };
+            }
+
+            Ok(vm.ctx.new_list(result).into())
+        }
+
         // based on nix's implementation
         #[cfg(all(unix, not(target_os = "redox")))]
         fn pack_cmsgs_to_send(
@@ -1620,7 +2088,7 @@ mod _socket {
                 unsafe {
                     (*pmhdr).cmsg_level = *lvl;
                     (*pmhdr).cmsg_type = *typ;
-                    (*pmhdr).cmsg_len = data.len() as _;
+                    (*pmhdr).cmsg_len = libc::CMSG_LEN(data.len() as _) as _;
                     ptr::copy_nonoverlapping(data.as_ptr(), libc::CMSG_DATA(pmhdr), data.len());
                 }
 
@@ -1834,6 +2302,136 @@ mod _socket {
             Ok(self.sock()?.shutdown(how)?)
         }
 
+        #[cfg(windows)]
+        fn wsa_error() -> io::Error {
+            io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn ioctl(
+            &self,
+            cmd: PyObjectRef,
+            option: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> Result<u32, IoOrPyException> {
+            use crate::vm::builtins::PyInt;
+            use crate::vm::convert::TryFromObject;
+
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+            let mut recv: u32 = 0;
+
+            // Convert cmd to u32, returning ValueError for invalid/negative values
+            let cmd_int = cmd
+                .downcast::<PyInt>()
+                .map_err(|_| vm.new_type_error("an integer is required"))?;
+            let cmd_val = cmd_int.as_bigint();
+            let cmd: u32 = cmd_val
+                .to_u32()
+                .ok_or_else(|| vm.new_value_error(format!("invalid ioctl command {}", cmd_val)))?;
+
+            match cmd {
+                c::SIO_RCVALL | c::SIO_LOOPBACK_FAST_PATH => {
+                    // Option must be an integer, not None
+                    if vm.is_none(&option) {
+                        return Err(vm
+                            .new_type_error("an integer is required (got type NoneType)")
+                            .into());
+                    }
+                    let option_val: u32 = TryFromObject::try_from_object(vm, option)?;
+                    let ret = unsafe {
+                        c::WSAIoctl(
+                            fd as _,
+                            cmd,
+                            &option_val as *const u32 as *const _,
+                            std::mem::size_of::<u32>() as u32,
+                            std::ptr::null_mut(),
+                            0,
+                            &mut recv,
+                            std::ptr::null_mut(),
+                            None,
+                        )
+                    };
+                    if ret == c::SOCKET_ERROR {
+                        return Err(Self::wsa_error().into());
+                    }
+                    Ok(recv)
+                }
+                c::SIO_KEEPALIVE_VALS => {
+                    let tuple: PyTupleRef = option
+                        .downcast()
+                        .map_err(|_| vm.new_type_error("SIO_KEEPALIVE_VALS requires a tuple"))?;
+                    if tuple.len() != 3 {
+                        return Err(vm
+                            .new_type_error(
+                                "SIO_KEEPALIVE_VALS requires (onoff, keepalivetime, keepaliveinterval)",
+                            )
+                            .into());
+                    }
+
+                    #[repr(C)]
+                    struct TcpKeepalive {
+                        onoff: u32,
+                        keepalivetime: u32,
+                        keepaliveinterval: u32,
+                    }
+
+                    let ka = TcpKeepalive {
+                        onoff: TryFromObject::try_from_object(vm, tuple[0].clone())?,
+                        keepalivetime: TryFromObject::try_from_object(vm, tuple[1].clone())?,
+                        keepaliveinterval: TryFromObject::try_from_object(vm, tuple[2].clone())?,
+                    };
+
+                    let ret = unsafe {
+                        c::WSAIoctl(
+                            fd as _,
+                            cmd,
+                            &ka as *const TcpKeepalive as *const _,
+                            std::mem::size_of::<TcpKeepalive>() as u32,
+                            std::ptr::null_mut(),
+                            0,
+                            &mut recv,
+                            std::ptr::null_mut(),
+                            None,
+                        )
+                    };
+                    if ret == c::SOCKET_ERROR {
+                        return Err(Self::wsa_error().into());
+                    }
+                    Ok(recv)
+                }
+                _ => Err(vm
+                    .new_value_error(format!("invalid ioctl command {}", cmd))
+                    .into()),
+            }
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn share(&self, process_id: u32, _vm: &VirtualMachine) -> Result<Vec<u8>, IoOrPyException> {
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+
+            let mut info: MaybeUninit<c::WSAPROTOCOL_INFOW> = MaybeUninit::uninit();
+
+            let ret = unsafe { c::WSADuplicateSocketW(fd as _, process_id, info.as_mut_ptr()) };
+
+            if ret == c::SOCKET_ERROR {
+                return Err(Self::wsa_error().into());
+            }
+
+            let info = unsafe { info.assume_init() };
+            let bytes = unsafe {
+                std::slice::from_raw_parts(
+                    &info as *const c::WSAPROTOCOL_INFOW as *const u8,
+                    std::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
+                )
+            };
+
+            Ok(bytes.to_vec())
+        }
+
         #[pygetset(name = "type")]
         fn kind(&self) -> i32 {
             self.kind.load()
@@ -1934,6 +2532,50 @@ mod _socket {
             let path = ffi::OsStr::from_bytes(&path[..nul_pos]);
             return vm.fsdecode(path).into();
         }
+        #[cfg(target_os = "linux")]
+        {
+            let family = addr.family();
+            if family == libc::AF_CAN as libc::sa_family_t {
+                // AF_CAN address: (interface_name,) or (interface_name, can_id)
+                let can_addr = unsafe { &*(addr.as_ptr() as *const libc::sockaddr_can) };
+                let ifindex = can_addr.can_ifindex;
+                let ifname = if ifindex == 0 {
+                    String::new()
+                } else {
+                    let mut buf = [0u8; libc::IF_NAMESIZE];
+                    let ret = unsafe {
+                        libc::if_indextoname(
+                            ifindex as libc::c_uint,
+                            buf.as_mut_ptr() as *mut libc::c_char,
+                        )
+                    };
+                    if ret.is_null() {
+                        String::new()
+                    } else {
+                        let nul_pos = memchr::memchr(b'\0', &buf).unwrap_or(buf.len());
+                        String::from_utf8_lossy(&buf[..nul_pos]).into_owned()
+                    }
+                };
+                return vm.ctx.new_tuple(vec![vm.ctx.new_str(ifname).into()]).into();
+            }
+            if family == libc::AF_ALG as libc::sa_family_t {
+                // AF_ALG address: (type, name)
+                let alg_addr = unsafe { &*(addr.as_ptr() as *const libc::sockaddr_alg) };
+                let type_bytes = &alg_addr.salg_type;
+                let name_bytes = &alg_addr.salg_name;
+                let type_nul = memchr::memchr(b'\0', type_bytes).unwrap_or(type_bytes.len());
+                let name_nul = memchr::memchr(b'\0', name_bytes).unwrap_or(name_bytes.len());
+                let type_str = String::from_utf8_lossy(&type_bytes[..type_nul]).into_owned();
+                let name_str = String::from_utf8_lossy(&name_bytes[..name_nul]).into_owned();
+                return vm
+                    .ctx
+                    .new_tuple(vec![
+                        vm.ctx.new_str(type_str).into(),
+                        vm.ctx.new_str(name_str).into(),
+                    ])
+                    .into();
+            }
+        }
         // TODO: support more address families
         (String::new(), 0).to_pyobject(vm)
     }

From 183cebe8a1e5de4d5f97be577e84d09242cfffdb Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sun, 28 Dec 2025 10:47:30 +0900
Subject: [PATCH 106/418] Upgrade socket from 3.13.11

---
 Lib/socket.py               | 130 +++++----
 Lib/test/test_socket.py     | 562 +++++++++++++++++++++++++++++-------
 crates/stdlib/src/socket.rs |   2 +-
 3 files changed, 533 insertions(+), 161 deletions(-)

diff --git a/Lib/socket.py b/Lib/socket.py
index 42ee1307732..35d87eff34d 100644
--- a/Lib/socket.py
+++ b/Lib/socket.py
@@ -306,7 +306,8 @@ def makefile(self, mode="r", buffering=None, *,
         """makefile(...) -> an I/O stream connected to the socket
 
         The arguments are as for io.open() after the filename, except the only
-        supported mode values are 'r' (default), 'w' and 'b'.
+        supported mode values are 'r' (default), 'w', 'b', or a combination of
+        those.
         """
         # XXX refactor to share code?
         if not set(mode) <= {"r", "w", "b"}:
@@ -591,16 +592,65 @@ def fromshare(info):
         return socket(0, 0, 0, info)
     __all__.append("fromshare")
 
-if hasattr(_socket, "socketpair"):
+# Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
+# This is used if _socket doesn't natively provide socketpair. It's
+# always defined so that it can be patched in for testing purposes.
+def _fallback_socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
+    if family == AF_INET:
+        host = _LOCALHOST
+    elif family == AF_INET6:
+        host = _LOCALHOST_V6
+    else:
+        raise ValueError("Only AF_INET and AF_INET6 socket address families "
+                         "are supported")
+    if type != SOCK_STREAM:
+        raise ValueError("Only SOCK_STREAM socket type is supported")
+    if proto != 0:
+        raise ValueError("Only protocol zero is supported")
+
+    # We create a connected TCP socket. Note the trick with
+    # setblocking(False) that prevents us from having to create a thread.
+    lsock = socket(family, type, proto)
+    try:
+        lsock.bind((host, 0))
+        lsock.listen()
+        # On IPv6, ignore flow_info and scope_id
+        addr, port = lsock.getsockname()[:2]
+        csock = socket(family, type, proto)
+        try:
+            csock.setblocking(False)
+            try:
+                csock.connect((addr, port))
+            except (BlockingIOError, InterruptedError):
+                pass
+            csock.setblocking(True)
+            ssock, _ = lsock.accept()
+        except:
+            csock.close()
+            raise
+    finally:
+        lsock.close()
 
-    def socketpair(family=None, type=SOCK_STREAM, proto=0):
-        """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
+    # Authenticating avoids using a connection from something else
+    # able to connect to {host}:{port} instead of us.
+    # We expect only AF_INET and AF_INET6 families.
+    try:
+        if (
+            ssock.getsockname() != csock.getpeername()
+            or csock.getsockname() != ssock.getpeername()
+        ):
+            raise ConnectionError("Unexpected peer connection")
+    except:
+        # getsockname() and getpeername() can fail
+        # if either socket isn't connected.
+        ssock.close()
+        csock.close()
+        raise
 
-        Create a pair of socket objects from the sockets returned by the platform
-        socketpair() function.
-        The arguments are the same as for socket() except the default family is
-        AF_UNIX if defined on the platform; otherwise, the default is AF_INET.
-        """
+    return (ssock, csock)
+
+if hasattr(_socket, "socketpair"):
+    def socketpair(family=None, type=SOCK_STREAM, proto=0):
         if family is None:
             try:
                 family = AF_UNIX
@@ -612,44 +662,7 @@ def socketpair(family=None, type=SOCK_STREAM, proto=0):
         return a, b
 
 else:
-
-    # Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
-    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
-        if family == AF_INET:
-            host = _LOCALHOST
-        elif family == AF_INET6:
-            host = _LOCALHOST_V6
-        else:
-            raise ValueError("Only AF_INET and AF_INET6 socket address families "
-                             "are supported")
-        if type != SOCK_STREAM:
-            raise ValueError("Only SOCK_STREAM socket type is supported")
-        if proto != 0:
-            raise ValueError("Only protocol zero is supported")
-
-        # We create a connected TCP socket. Note the trick with
-        # setblocking(False) that prevents us from having to create a thread.
-        lsock = socket(family, type, proto)
-        try:
-            lsock.bind((host, 0))
-            lsock.listen()
-            # On IPv6, ignore flow_info and scope_id
-            addr, port = lsock.getsockname()[:2]
-            csock = socket(family, type, proto)
-            try:
-                csock.setblocking(False)
-                try:
-                    csock.connect((addr, port))
-                except (BlockingIOError, InterruptedError):
-                    pass
-                csock.setblocking(True)
-                ssock, _ = lsock.accept()
-            except:
-                csock.close()
-                raise
-        finally:
-            lsock.close()
-        return (ssock, csock)
+    socketpair = _fallback_socketpair
     __all__.append("socketpair")
 
 socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
@@ -702,16 +715,15 @@ def readinto(self, b):
         self._checkReadable()
         if self._timeout_occurred:
             raise OSError("cannot read from timed out object")
-        while True:
-            try:
-                return self._sock.recv_into(b)
-            except timeout:
-                self._timeout_occurred = True
-                raise
-            except error as e:
-                if e.errno in _blocking_errnos:
-                    return None
-                raise
+        try:
+            return self._sock.recv_into(b)
+        except timeout:
+            self._timeout_occurred = True
+            raise
+        except error as e:
+            if e.errno in _blocking_errnos:
+                return None
+            raise
 
     def write(self, b):
         """Write the given bytes or bytearray object *b* to the socket
@@ -919,7 +931,9 @@ def create_server(address, *, family=AF_INET, backlog=None, reuse_port=False,
                 # Fail later on bind(), for platforms which may not
                 # support this option.
                 pass
-        if reuse_port:
+        # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+        # on other address families than AF_INET/AF_INET6.
+        if reuse_port and family in (AF_INET, AF_INET6):
             sock.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
         if has_ipv6 and family == AF_INET6:
             if dualstack_ipv6:
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 756603bd514..08676cf3388 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -1,9 +1,9 @@
 import unittest
+from unittest import mock
 from test import support
-from test.support import os_helper
-from test.support import socket_helper
-from test.support import threading_helper
-
+from test.support import (
+    is_apple, os_helper, refleak_helper, socket_helper, threading_helper
+)
 import _thread as thread
 import array
 import contextlib
@@ -28,6 +28,7 @@
 import threading
 import time
 import traceback
+import warnings
 from weakref import proxy
 try:
     import multiprocessing
@@ -37,6 +38,10 @@
     import fcntl
 except ImportError:
     fcntl = None
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
 
 support.requires_working_socket(module=True)
 
@@ -44,6 +49,7 @@
 # test unicode string and carriage return
 MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8')
 
+VMADDR_CID_LOCAL = 1
 VSOCKPORT = 1234
 AIX = platform.system() == "AIX"
 WSL = "microsoft-standard-WSL" in platform.release()
@@ -53,6 +59,35 @@
 except ImportError:
     _socket = None
 
+def skipForRefleakHuntinIf(condition, issueref):
+    if not condition:
+        def decorator(f):
+            f.client_skip = lambda f: f
+            return f
+
+    else:
+        def decorator(f):
+            @contextlib.wraps(f)
+            def wrapper(*args, **kwds):
+                if refleak_helper.hunting_for_refleaks():
+                    raise unittest.SkipTest(f"ignore while hunting for refleaks, see {issueref}")
+
+                return f(*args, **kwds)
+
+            def client_skip(f):
+                @contextlib.wraps(f)
+                def wrapper(*args, **kwds):
+                    if refleak_helper.hunting_for_refleaks():
+                        return
+
+                    return f(*args, **kwds)
+
+                return wrapper
+            wrapper.client_skip = client_skip
+            return wrapper
+
+    return decorator
+
 def get_cid():
     if fcntl is None:
         return None
@@ -128,8 +163,8 @@ def _have_socket_qipcrtr():
 
 def _have_socket_vsock():
     """Check whether AF_VSOCK sockets are supported on this host."""
-    ret = get_cid() is not None
-    return ret
+    cid = get_cid()
+    return (cid is not None)
 
 
 def _have_socket_bluetooth():
@@ -145,6 +180,17 @@ def _have_socket_bluetooth():
     return True
 
 
+def _have_socket_bluetooth_l2cap():
+    """Check whether BTPROTO_L2CAP sockets are supported on this host."""
+    try:
+        s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP)
+    except (AttributeError, OSError):
+        return False
+    else:
+        s.close()
+    return True
+
+
 def _have_socket_hyperv():
     """Check whether AF_HYPERV sockets are supported on this host."""
     try:
@@ -166,6 +212,24 @@ def socket_setdefaulttimeout(timeout):
         socket.setdefaulttimeout(old_timeout)
 
 
+@contextlib.contextmanager
+def downgrade_malformed_data_warning():
+    # This warning happens on macos and win, but does not always happen on linux.
+    if sys.platform not in {"win32", "darwin"}:
+        yield
+        return
+
+    with warnings.catch_warnings():
+        # TODO: gh-110012, we should investigate why this warning is happening
+        # and fix it properly.
+        warnings.filterwarnings(
+            action="always",
+            message="received malformed or improperly-truncated ancillary data",
+            category=RuntimeWarning,
+        )
+        yield
+
+
 HAVE_SOCKET_CAN = _have_socket_can()
 
 HAVE_SOCKET_CAN_ISOTP = _have_socket_can_isotp()
@@ -180,10 +244,15 @@ def socket_setdefaulttimeout(timeout):
 
 HAVE_SOCKET_VSOCK = _have_socket_vsock()
 
-HAVE_SOCKET_UDPLITE = hasattr(socket, "IPPROTO_UDPLITE")
+# Older Android versions block UDPLITE with SELinux.
+HAVE_SOCKET_UDPLITE = (
+    hasattr(socket, "IPPROTO_UDPLITE")
+    and not (support.is_android and platform.android_ver().api_level < 29))
 
 HAVE_SOCKET_BLUETOOTH = _have_socket_bluetooth()
 
+HAVE_SOCKET_BLUETOOTH_L2CAP = _have_socket_bluetooth_l2cap()
+
 HAVE_SOCKET_HYPERV = _have_socket_hyperv()
 
 # Size in bytes of the int type
@@ -485,8 +554,8 @@ def clientTearDown(self):
 @unittest.skipIf(WSL, 'VSOCK does not work on Microsoft WSL')
 @unittest.skipUnless(HAVE_SOCKET_VSOCK,
           'VSOCK sockets required for this test.')
-@unittest.skipUnless(get_cid() != 2,
-          "This test can only be run on a virtual guest.")
+@unittest.skipUnless(get_cid() != 2,  # VMADDR_CID_HOST
+                     "This test can only be run on a virtual guest.")
 class ThreadedVSOCKSocketStreamTest(unittest.TestCase, ThreadableTest):
 
     def __init__(self, methodName='runTest'):
@@ -508,10 +577,16 @@ def clientSetUp(self):
         self.cli = socket.socket(socket.AF_VSOCK, socket.SOCK_STREAM)
         self.addCleanup(self.cli.close)
         cid = get_cid()
+        if cid in (socket.VMADDR_CID_HOST, socket.VMADDR_CID_ANY):
+            # gh-119461: Use the local communication address (loopback)
+            cid = VMADDR_CID_LOCAL
         self.cli.connect((cid, VSOCKPORT))
 
     def testStream(self):
-        msg = self.conn.recv(1024)
+        try:
+            msg = self.conn.recv(1024)
+        except PermissionError as exc:
+            self.skipTest(repr(exc))
         self.assertEqual(msg, MSG)
 
     def _testStream(self):
@@ -556,19 +631,27 @@ class SocketPairTest(unittest.TestCase, ThreadableTest):
     def __init__(self, methodName='runTest'):
         unittest.TestCase.__init__(self, methodName=methodName)
         ThreadableTest.__init__(self)
+        self.cli = None
+        self.serv = None
+
+    def socketpair(self):
+        # To be overridden by some child classes.
+        return socket.socketpair()
 
     def setUp(self):
-        self.serv, self.cli = socket.socketpair()
+        self.serv, self.cli = self.socketpair()
 
     def tearDown(self):
-        self.serv.close()
+        if self.serv:
+            self.serv.close()
         self.serv = None
 
     def clientSetUp(self):
         pass
 
     def clientTearDown(self):
-        self.cli.close()
+        if self.cli:
+            self.cli.close()
         self.cli = None
         ThreadableTest.clientTearDown(self)
 
@@ -821,10 +904,8 @@ def requireSocket(*args):
 
 class GeneralModuleTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(_socket is not None, 'need _socket module')
-    # TODO: RUSTPYTHON gc.is_tracked not implemented
+    # TODO: RUSTPYTHON; gc.is_tracked not implemented
     @unittest.expectedFailure
     def test_socket_type(self):
         self.assertTrue(gc.is_tracked(_socket.socket))
@@ -888,7 +969,7 @@ def testSocketError(self):
         with self.assertRaises(OSError, msg=msg % 'socket.gaierror'):
             raise socket.gaierror
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; error message format differs
     @unittest.expectedFailure
     def testSendtoErrors(self):
         # Testing that sendto doesn't mask failures. See #10169.
@@ -975,8 +1056,6 @@ def test_socket_methods(self):
             if not hasattr(socket.socket, name):
                 self.fail(f"socket method {name} is missing")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(sys.platform == 'darwin', 'macOS specific test')
     @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 required for this test')
     def test3542SocketOptions(self):
@@ -1092,7 +1171,10 @@ def testInterfaceNameIndex(self):
     @unittest.skipUnless(hasattr(socket, 'if_indextoname'),
                          'socket.if_indextoname() not available.')
     def testInvalidInterfaceIndexToName(self):
-        self.assertRaises(OSError, socket.if_indextoname, 0)
+        with self.assertRaises(OSError) as cm:
+            socket.if_indextoname(0)
+        self.assertIsNotNone(cm.exception.errno)
+
         self.assertRaises(OverflowError, socket.if_indextoname, -1)
         self.assertRaises(OverflowError, socket.if_indextoname, 2**1000)
         self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
@@ -1111,8 +1193,11 @@ def testInvalidInterfaceIndexToName(self):
     @unittest.skipUnless(hasattr(socket, 'if_nametoindex'),
                          'socket.if_nametoindex() not available.')
     def testInvalidInterfaceNameToIndex(self):
+        with self.assertRaises(OSError) as cm:
+            socket.if_nametoindex("_DEADBEEF")
+        self.assertIsNotNone(cm.exception.errno)
+
         self.assertRaises(TypeError, socket.if_nametoindex, 0)
-        self.assertRaises(OSError, socket.if_nametoindex, '_DEADBEEF')
 
     @unittest.skipUnless(hasattr(sys, 'getrefcount'),
                          'test needs sys.getrefcount()')
@@ -1149,6 +1234,7 @@ def testNtoH(self):
             self.assertRaises(OverflowError, func, 1<<34)
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def testNtoHErrors(self):
         import _testcapi
         s_good_values = [0, 1, 2, 0xffff]
@@ -1177,8 +1263,11 @@ def testGetServBy(self):
         # Find one service that exists, then check all the related interfaces.
         # I've ordered this by protocols that have both a tcp and udp
         # protocol, at least for modern Linuxes.
-        if (sys.platform.startswith(('freebsd', 'netbsd', 'gnukfreebsd'))
-            or sys.platform in ('linux', 'darwin')):
+        if (
+            sys.platform.startswith(
+                ('linux', 'android', 'freebsd', 'netbsd', 'gnukfreebsd'))
+            or is_apple
+        ):
             # avoid the 'echo' service on this platform, as there is an
             # assumption breaking non-standard port/protocol entry
             services = ('daytime', 'qotd', 'domain')
@@ -1193,9 +1282,8 @@ def testGetServBy(self):
         else:
             raise OSError
         # Try same call with optional protocol omitted
-        # Issue #26936: Android getservbyname() was broken before API 23.
-        if (not hasattr(sys, 'getandroidapilevel') or
-                sys.getandroidapilevel() >= 23):
+        # Issue gh-71123: this fails on Android before API level 23.
+        if not (support.is_android and platform.android_ver().api_level < 23):
             port2 = socket.getservbyname(service)
             eq(port, port2)
         # Try udp, but don't barf if it doesn't exist
@@ -1206,8 +1294,9 @@ def testGetServBy(self):
         else:
             eq(udpport, port)
         # Now make sure the lookup by port returns the same service name
-        # Issue #26936: Android getservbyport() is broken.
-        if not support.is_android:
+        # Issue #26936: when the protocol is omitted, this fails on Android
+        # before API level 28.
+        if not (support.is_android and platform.android_ver().api_level < 28):
             eq(socket.getservbyport(port2), service)
         eq(socket.getservbyport(port, 'tcp'), service)
         if udpport is not None:
@@ -1505,8 +1594,6 @@ def test_getsockaddrarg(self):
                 break
 
     @unittest.skipUnless(os.name == "nt", "Windows specific")
-    # TODO: RUSTPYTHON, windows ioctls
-    @unittest.expectedFailure
     def test_sock_ioctl(self):
         self.assertTrue(hasattr(socket.socket, 'ioctl'))
         self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
@@ -1521,8 +1608,6 @@ def test_sock_ioctl(self):
     @unittest.skipUnless(os.name == "nt", "Windows specific")
     @unittest.skipUnless(hasattr(socket, 'SIO_LOOPBACK_FAST_PATH'),
                          'Loopback fast path support required for this test')
-    # TODO: RUSTPYTHON, AttributeError: 'socket' object has no attribute 'ioctl'
-    @unittest.expectedFailure
     def test_sio_loopback_fast_path(self):
         s = socket.socket()
         self.addCleanup(s.close)
@@ -1556,9 +1641,8 @@ def testGetaddrinfo(self):
             socket.getaddrinfo('::1', 80)
         # port can be a string service name such as "http", a numeric
         # port number or None
-        # Issue #26936: Android getaddrinfo() was broken before API level 23.
-        if (not hasattr(sys, 'getandroidapilevel') or
-                sys.getandroidapilevel() >= 23):
+        # Issue #26936: this fails on Android before API level 23.
+        if not (support.is_android and platform.android_ver().api_level < 23):
             socket.getaddrinfo(HOST, "http")
         socket.getaddrinfo(HOST, 80)
         socket.getaddrinfo(HOST, None)
@@ -1604,8 +1688,7 @@ def testGetaddrinfo(self):
                                flags=socket.AI_PASSIVE)
         self.assertEqual(a, b)
         # Issue #6697.
-        # XXX RUSTPYTHON TODO: surrogates in str
-        # self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
+        self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
 
         # Issue 17269: test workaround for OS X platform bug segfault
         if hasattr(socket, 'AI_NUMERICSERV'):
@@ -1617,8 +1700,7 @@ def testGetaddrinfo(self):
             except socket.gaierror:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_getaddrinfo_int_port_overflow(self):
         # gh-74895: Test that getaddrinfo does not raise OverflowError on port.
         #
@@ -1636,7 +1718,7 @@ def test_getaddrinfo_int_port_overflow(self):
         try:
             socket.getaddrinfo(None, ULONG_MAX + 1, type=socket.SOCK_STREAM)
         except OverflowError:
-            # Platforms differ as to what values consitute a getaddrinfo() error
+            # Platforms differ as to what values constitute a getaddrinfo() error
             # return. Some fail for LONG_MAX+1, others ULONG_MAX+1, and Windows
             # silently accepts such huge "port" aka "service" numeric values.
             self.fail("Either no error or socket.gaierror expected.")
@@ -1671,7 +1753,6 @@ def test_getnameinfo(self):
         # only IP addresses are allowed
         self.assertRaises(OSError, socket.getnameinfo, ('mail.python.org',0), 0)
 
-    @unittest.skip("TODO: RUSTPYTHON: flaky on CI?")
     @unittest.skipUnless(support.is_resource_enabled('network'),
                          'network is not enabled')
     def test_idna(self):
@@ -1726,8 +1807,6 @@ def test_sendall_interrupted(self):
     def test_sendall_interrupted_with_timeout(self):
         self.check_sendall_interrupted(True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dealloc_warn(self):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         r = repr(sock)
@@ -1815,6 +1894,7 @@ def test_listen_backlog(self):
             srv.listen()
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_listen_backlog_overflow(self):
         # Issue 15989
         import _testcapi
@@ -1907,7 +1987,6 @@ def test_str_for_enums(self):
             self.assertEqual(str(s.family), str(s.family.value))
             self.assertEqual(str(s.type), str(s.type.value))
 
-    @unittest.expectedFailureIf(sys.platform.startswith("linux"), "TODO: RUSTPYTHON, AssertionError: 526337 != <SocketKind.SOCK_STREAM: 1>")
     def test_socket_consistent_sock_type(self):
         SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', 0)
         SOCK_CLOEXEC = getattr(socket, 'SOCK_CLOEXEC', 0)
@@ -2100,8 +2179,6 @@ def testCrucialConstants(self):
 
     @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
                          'socket.CAN_BCM required for this test.')
-    # TODO: RUSTPYTHON, AttributeError: module 'socket' has no attribute 'CAN_BCM_TX_SETUP'
-    @unittest.expectedFailure
     def testBCMConstants(self):
         socket.CAN_BCM
 
@@ -2142,16 +2219,12 @@ def testCreateBCMSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM) as s:
             pass
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testBindAny(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             address = ('', )
             s.bind(address)
             self.assertEqual(s.getsockname(), address)
 
-    # TODO: RUSTPYTHON, AssertionError: "interface name too long" does not match "bind(): bad family"
-    @unittest.expectedFailure
     def testTooLongInterfaceName(self):
         # most systems limit IFNAMSIZ to 16, take 1024 to be sure
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
@@ -2294,16 +2367,12 @@ def testCreateISOTPSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
             pass
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testTooLongInterfaceName(self):
         # most systems limit IFNAMSIZ to 16, take 1024 to be sure
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
             with self.assertRaisesRegex(OSError, 'interface name too long'):
                 s.bind(('x' * 1024, 1, 2))
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
@@ -2325,8 +2394,6 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.interface = "vcan0"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(hasattr(socket, "CAN_J1939"),
                          'socket.CAN_J1939 required for this test.')
     def testJ1939Constants(self):
@@ -2368,8 +2435,6 @@ def testCreateJ1939Socket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
@@ -2581,6 +2646,143 @@ def testCreateScoSocket(self):
         with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
             pass
 
+    @unittest.skipUnless(HAVE_SOCKET_BLUETOOTH_L2CAP, 'Bluetooth L2CAP sockets required for this test')
+    def testBindBrEdrL2capSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            # First user PSM in BR/EDR L2CAP
+            psm = 0x1001
+            f.bind((socket.BDADDR_ANY, psm))
+            addr = f.getsockname()
+            self.assertEqual(addr, (socket.BDADDR_ANY, psm))
+
+    @unittest.skipUnless(HAVE_SOCKET_BLUETOOTH_L2CAP, 'Bluetooth L2CAP sockets required for this test')
+    def testBadL2capAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY, 0, 0))
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                f.bind(socket.BDADDR_ANY)
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY.encode(), 0x1001))
+            with self.assertRaises(OSError):
+                f.bind(('\ud812', 0x1001))
+
+    def testBindRfcommSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            channel = 0
+            try:
+                s.bind((socket.BDADDR_ANY, channel))
+            except OSError as err:
+                if sys.platform == 'win32' and err.winerror == 10050:
+                    self.skipTest(str(err))
+                raise
+            addr = s.getsockname()
+            self.assertEqual(addr, (mock.ANY, channel))
+            self.assertRegex(addr[0], r'(?i)[0-9a-f]{2}(?::[0-9a-f]{2}){4}')
+            if sys.platform != 'win32':
+                self.assertEqual(addr, (socket.BDADDR_ANY, channel))
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            s.bind(addr)
+            addr2 = s.getsockname()
+            self.assertEqual(addr2, addr)
+
+    def testBadRfcommAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            channel = 0
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY.encode(), channel))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY, channel, 0))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY + '\0', channel))
+            with self.assertRaises(OSError):
+                s.bind('\ud812')
+            with self.assertRaises(OSError):
+                s.bind(('invalid', channel))
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_HCI'), 'Bluetooth HCI sockets required for this test')
+    def testBindHciSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
+            if sys.platform.startswith(('netbsd', 'dragonfly', 'freebsd')):
+                s.bind(socket.BDADDR_ANY)
+                addr = s.getsockname()
+                self.assertEqual(addr, socket.BDADDR_ANY)
+            else:
+                dev = 0
+                try:
+                    s.bind((dev,))
+                except OSError as err:
+                    if err.errno in (errno.EINVAL, errno.ENODEV):
+                        self.skipTest(str(err))
+                    raise
+                addr = s.getsockname()
+                self.assertEqual(addr, dev)
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_HCI'), 'Bluetooth HCI sockets required for this test')
+    def testBadHciAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
+            if sys.platform.startswith(('netbsd', 'dragonfly', 'freebsd')):
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY.encode())
+                with self.assertRaises(OSError):
+                    s.bind((socket.BDADDR_ANY,))
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY + '\0')
+                with self.assertRaises((ValueError, OSError)):
+                    s.bind(socket.BDADDR_ANY + ' '*100)
+                with self.assertRaises(OSError):
+                    s.bind('\ud812')
+                with self.assertRaises(OSError):
+                    s.bind('invalid')
+                with self.assertRaises(OSError):
+                    s.bind(b'invalid')
+            else:
+                dev = 0
+                with self.assertRaises(OSError):
+                    s.bind(())
+                with self.assertRaises(OSError):
+                    s.bind((dev, 0))
+                with self.assertRaises(OSError):
+                    s.bind(dev)
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY)
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY.encode())
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_SCO'), 'Bluetooth SCO sockets required for this test')
+    def testBindScoSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            s.bind(socket.BDADDR_ANY)
+            addr = s.getsockname()
+            self.assertEqual(addr, socket.BDADDR_ANY)
+
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            s.bind(socket.BDADDR_ANY.encode())
+            addr = s.getsockname()
+            self.assertEqual(addr, socket.BDADDR_ANY)
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_SCO'), 'Bluetooth SCO sockets required for this test')
+    def testBadScoAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY.encode(),))
+            with self.assertRaises(ValueError):
+                s.bind(socket.BDADDR_ANY + '\0')
+            with self.assertRaises(ValueError):
+                s.bind(socket.BDADDR_ANY.encode() + b'\0')
+            with self.assertRaises(UnicodeEncodeError):
+                s.bind('\ud812')
+            with self.assertRaises(OSError):
+                s.bind('invalid')
+            with self.assertRaises(OSError):
+                s.bind(b'invalid')
+
 
 @unittest.skipUnless(HAVE_SOCKET_HYPERV,
                      'Hyper-V sockets required for this test.')
@@ -2711,22 +2913,29 @@ def testDup(self):
     def _testDup(self):
         self.serv_conn.send(MSG)
 
-    def testShutdown(self):
-        # Testing shutdown()
+    def check_shutdown(self):
+        # Test shutdown() helper
         msg = self.cli_conn.recv(1024)
         self.assertEqual(msg, MSG)
-        # wait for _testShutdown to finish: on OS X, when the server
+        # wait for _testShutdown[_overflow] to finish: on OS X, when the server
         # closes the connection the client also becomes disconnected,
         # and the client's shutdown call will fail. (Issue #4397.)
         self.done.wait()
 
+    def testShutdown(self):
+        self.check_shutdown()
+
     def _testShutdown(self):
         self.serv_conn.send(MSG)
         self.serv_conn.shutdown(2)
 
-    testShutdown_overflow = support.cpython_only(testShutdown)
+    @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def testShutdown_overflow(self):
+        self.check_shutdown()
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def _testShutdown_overflow(self):
         import _testcapi
         self.serv_conn.send(MSG)
@@ -3197,7 +3406,7 @@ def _testSendmsgTimeout(self):
     # Linux supports MSG_DONTWAIT when sending, but in general, it
     # only works when receiving.  Could add other platforms if they
     # support it too.
-    @skipWithClientIf(sys.platform not in {"linux"},
+    @skipWithClientIf(sys.platform not in {"linux", "android"},
                       "MSG_DONTWAIT not known to work on this platform when "
                       "sending")
     def testSendmsgDontWait(self):
@@ -3714,7 +3923,7 @@ def testFDPassCMSG_LEN(self):
     def _testFDPassCMSG_LEN(self):
         self.createAndSendFDs(1)
 
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparate(self):
@@ -3725,7 +3934,7 @@ def testFDPassSeparate(self):
                              maxcmsgs=2)
 
     @testFDPassSeparate.client_skip
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparate(self):
         fd0, fd1 = self.newFDs(2)
@@ -3738,7 +3947,7 @@ def _testFDPassSeparate(self):
                                           array.array("i", [fd1]))]),
             len(MSG))
 
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparateMinSpace(self):
@@ -3752,7 +3961,7 @@ def testFDPassSeparateMinSpace(self):
                              maxcmsgs=2, ignoreflags=socket.MSG_CTRUNC)
 
     @testFDPassSeparateMinSpace.client_skip
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparateMinSpace(self):
         fd0, fd1 = self.newFDs(2)
@@ -3776,7 +3985,7 @@ def sendAncillaryIfPossible(self, msg, ancdata):
             nbytes = self.sendmsgToServer([msg])
         self.assertEqual(nbytes, len(msg))
 
-    @unittest.skipIf(sys.platform == "darwin", "see issue #24725")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     def testFDPassEmpty(self):
         # Try to pass an empty FD array.  Can receive either no array
         # or an empty array.
@@ -3850,6 +4059,7 @@ def checkTruncatedHeader(self, result, ignoreflags=0):
         self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC,
                         ignore=ignoreflags)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncNoBufSize(self):
         # Check that no ancillary data is received when no buffer size
         # is specified.
@@ -3859,26 +4069,32 @@ def testCmsgTruncNoBufSize(self):
                                   # received.
                                   ignoreflags=socket.MSG_CTRUNC)
 
+    @testCmsgTruncNoBufSize.client_skip
     def _testCmsgTruncNoBufSize(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc0(self):
         # Check that no ancillary data is received when buffer size is 0.
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 0),
                                   ignoreflags=socket.MSG_CTRUNC)
 
+    @testCmsgTrunc0.client_skip
     def _testCmsgTrunc0(self):
         self.createAndSendFDs(1)
 
     # Check that no ancillary data is returned for various non-zero
     # (but still too small) buffer sizes.
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc1(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 1))
 
+    @testCmsgTrunc1.client_skip
     def _testCmsgTrunc1(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc2Int(self):
         # The cmsghdr structure has at least three members, two of
         # which are ints, so we still shouldn't see any ancillary
@@ -3886,13 +4102,16 @@ def testCmsgTrunc2Int(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
                                                  SIZEOF_INT * 2))
 
+    @testCmsgTrunc2Int.client_skip
     def _testCmsgTrunc2Int(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0Minus1(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
                                                  socket.CMSG_LEN(0) - 1))
 
+    @testCmsgTruncLen0Minus1.client_skip
     def _testCmsgTruncLen0Minus1(self):
         self.createAndSendFDs(1)
 
@@ -3904,8 +4123,9 @@ def checkTruncatedArray(self, ancbuf, maxdata, mindata=0):
         # mindata and maxdata bytes when received with buffer size
         # ancbuf, and that any complete file descriptor numbers are
         # valid.
-        msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
-                                                   len(MSG), ancbuf)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
+                                                       len(MSG), ancbuf)
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
         self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC)
@@ -3923,29 +4143,38 @@ def checkTruncatedArray(self, ancbuf, maxdata, mindata=0):
                 len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
         self.checkFDs(fds)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0), maxdata=0)
 
+    @testCmsgTruncLen0.client_skip
     def _testCmsgTruncLen0(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0Plus1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0) + 1, maxdata=1)
 
+    @testCmsgTruncLen0Plus1.client_skip
     def _testCmsgTruncLen0Plus1(self):
         self.createAndSendFDs(2)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(SIZEOF_INT),
                                  maxdata=SIZEOF_INT)
 
+    @testCmsgTruncLen1.client_skip
     def _testCmsgTruncLen1(self):
         self.createAndSendFDs(2)
 
+
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen2Minus1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(2 * SIZEOF_INT) - 1,
                                  maxdata=(2 * SIZEOF_INT) - 1)
 
+    @testCmsgTruncLen2Minus1.client_skip
     def _testCmsgTruncLen2Minus1(self):
         self.createAndSendFDs(2)
 
@@ -4247,8 +4476,9 @@ def testSingleCmsgTruncInData(self):
         self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
                                   socket.IPV6_RECVHOPLIMIT, 1)
         self.misc_event.set()
-        msg, ancdata, flags, addr = self.doRecvmsg(
-            self.serv_sock, len(MSG), socket.CMSG_LEN(SIZEOF_INT) - 1)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(
+                self.serv_sock, len(MSG), socket.CMSG_LEN(SIZEOF_INT) - 1)
 
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
@@ -4351,9 +4581,10 @@ def testSecondCmsgTruncInData(self):
         self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
                                   socket.IPV6_RECVTCLASS, 1)
         self.misc_event.set()
-        msg, ancdata, flags, addr = self.doRecvmsg(
-            self.serv_sock, len(MSG),
-            socket.CMSG_SPACE(SIZEOF_INT) + socket.CMSG_LEN(SIZEOF_INT) - 1)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(
+                self.serv_sock, len(MSG),
+                socket.CMSG_SPACE(SIZEOF_INT) + socket.CMSG_LEN(SIZEOF_INT) - 1)
 
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
@@ -4595,9 +4826,9 @@ class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase,
                                     ConnectedStreamTestMixin, UnixStreamBase):
     pass
 
-@unittest.skipIf(sys.platform == "darwin", "flaky on macOS")
 @requireAttrs(socket.socket, "sendmsg")
 @requireAttrs(socket, "AF_UNIX")
+@unittest.skip("TODO: RUSTPYTHON; accept() on Unix sockets returns EINVAL")
 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
     pass
 
@@ -4818,6 +5049,112 @@ def _testSend(self):
         self.assertEqual(msg, MSG)
 
 
+class PurePythonSocketPairTest(SocketPairTest):
+    # Explicitly use socketpair AF_INET or AF_INET6 to ensure that is the
+    # code path we're using regardless platform is the pure python one where
+    # `_socket.socketpair` does not exist.  (AF_INET does not work with
+    # _socket.socketpair on many platforms).
+    def socketpair(self):
+        # called by super().setUp().
+        try:
+            return socket.socketpair(socket.AF_INET6)
+        except OSError:
+            return socket.socketpair(socket.AF_INET)
+
+    # Local imports in this class make for easy security fix backporting.
+
+    def setUp(self):
+        if hasattr(_socket, "socketpair"):
+            self._orig_sp = socket.socketpair
+            # This forces the version using the non-OS provided socketpair
+            # emulation via an AF_INET socket in Lib/socket.py.
+            socket.socketpair = socket._fallback_socketpair
+        else:
+            # This platform already uses the non-OS provided version.
+            self._orig_sp = None
+        super().setUp()
+
+    def tearDown(self):
+        super().tearDown()
+        if self._orig_sp is not None:
+            # Restore the default socket.socketpair definition.
+            socket.socketpair = self._orig_sp
+
+    def test_recv(self):
+        msg = self.serv.recv(1024)
+        self.assertEqual(msg, MSG)
+
+    def _test_recv(self):
+        self.cli.send(MSG)
+
+    def test_send(self):
+        self.serv.send(MSG)
+
+    def _test_send(self):
+        msg = self.cli.recv(1024)
+        self.assertEqual(msg, MSG)
+
+    def test_ipv4(self):
+        cli, srv = socket.socketpair(socket.AF_INET)
+        cli.close()
+        srv.close()
+
+    def _test_ipv4(self):
+        pass
+
+    @unittest.skipIf(not hasattr(_socket, 'IPPROTO_IPV6') or
+                     not hasattr(_socket, 'IPV6_V6ONLY'),
+                     "IPV6_V6ONLY option not supported")
+    @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 required for this test')
+    def test_ipv6(self):
+        cli, srv = socket.socketpair(socket.AF_INET6)
+        cli.close()
+        srv.close()
+
+    def _test_ipv6(self):
+        pass
+
+    def test_injected_authentication_failure(self):
+        orig_getsockname = socket.socket.getsockname
+        inject_sock = None
+
+        def inject_getsocketname(self):
+            nonlocal inject_sock
+            sockname = orig_getsockname(self)
+            # Connect to the listening socket ahead of the
+            # client socket.
+            if inject_sock is None:
+                inject_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                inject_sock.setblocking(False)
+                try:
+                    inject_sock.connect(sockname[:2])
+                except (BlockingIOError, InterruptedError):
+                    pass
+                inject_sock.setblocking(True)
+            return sockname
+
+        sock1 = sock2 = None
+        try:
+            socket.socket.getsockname = inject_getsocketname
+            with self.assertRaises(OSError):
+                sock1, sock2 = socket.socketpair()
+        finally:
+            socket.socket.getsockname = orig_getsockname
+            if inject_sock:
+                inject_sock.close()
+            if sock1:  # This cleanup isn't needed on a successful test.
+                sock1.close()
+            if sock2:
+                sock2.close()
+
+    def _test_injected_authentication_failure(self):
+        # No-op.  Exists for base class threading infrastructure to call.
+        # We could refactor this test into its own lesser class along with the
+        # setUp and tearDown code to construct an ideal; it is simpler to keep
+        # it here and live with extra overhead one this _one_ failure test.
+        pass
+
+
 class NonBlockingTCPTests(ThreadedTCPSocketTest):
 
     def __init__(self, methodName='runTest'):
@@ -4865,6 +5202,7 @@ def _testSetBlocking(self):
         pass
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def testSetBlocking_overflow(self):
         # Issue 15989
         import _testcapi
@@ -4882,8 +5220,6 @@ def testSetBlocking_overflow(self):
     @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
                          'test needs socket.SOCK_NONBLOCK')
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: None != 0
-    @unittest.expectedFailure
     def testInitNonBlocking(self):
         # create a socket with SOCK_NONBLOCK
         self.serv.close()
@@ -4979,6 +5315,39 @@ def _testRecv(self):
         # send data: recv() will no longer block
         self.cli.sendall(MSG)
 
+    def testLargeTimeout(self):
+        # gh-126876: Check that a timeout larger than INT_MAX is replaced with
+        # INT_MAX in the poll() code path. The following assertion must not
+        # fail: assert(INT_MIN <= ms && ms <= INT_MAX).
+        if _testcapi is not None:
+            large_timeout = _testcapi.INT_MAX + 1
+        else:
+            large_timeout = 2147483648
+
+        # test recv() with large timeout
+        conn, addr = self.serv.accept()
+        self.addCleanup(conn.close)
+        try:
+            conn.settimeout(large_timeout)
+        except OverflowError:
+            # On Windows, settimeout() fails with OverflowError, whereas
+            # we want to test recv(). Just give up silently.
+            return
+        msg = conn.recv(len(MSG))
+
+    def _testLargeTimeout(self):
+        # test sendall() with large timeout
+        if _testcapi is not None:
+            large_timeout = _testcapi.INT_MAX + 1
+        else:
+            large_timeout = 2147483648
+        self.cli.connect((HOST, self.port))
+        try:
+            self.cli.settimeout(large_timeout)
+        except OverflowError:
+            return
+        self.cli.sendall(MSG)
+
 
 class FileObjectClassTestCase(SocketConnectedTest):
     """Unit tests for the object returned by socket.makefile()
@@ -5181,6 +5550,8 @@ def _testMakefileClose(self):
         self.write_file.write(self.write_msg)
         self.write_file.flush()
 
+    @unittest.skipUnless(hasattr(sys, 'getrefcount'),
+                         'test needs sys.getrefcount()')
     def testMakefileCloseSocketDestroy(self):
         refcount_before = sys.getrefcount(self.cli_conn)
         self.read_file.close()
@@ -5619,7 +5990,7 @@ def test_setblocking_invalidfd(self):
             sock.setblocking(False)
 
 
-@unittest.skipUnless(sys.platform == 'linux', 'Linux specific test')
+@unittest.skipUnless(sys.platform in ('linux', 'android'), 'Linux specific test')
 class TestLinuxAbstractNamespace(unittest.TestCase):
 
     UNIX_PATH_MAX = 108
@@ -5744,7 +6115,8 @@ def testUnencodableAddr(self):
         self.addCleanup(os_helper.unlink, path)
         self.assertEqual(self.sock.getsockname(), path)
 
-    @unittest.skipIf(sys.platform == 'linux', 'Linux specific test')
+    @unittest.skipIf(sys.platform in ('linux', 'android'),
+                     'Linux behavior is tested by TestLinuxAbstractNamespace')
     def testEmptyAddress(self):
         # Test that binding empty address fails.
         self.assertRaises(OSError, self.sock.bind, "")
@@ -5970,8 +6342,6 @@ class InheritanceTest(unittest.TestCase):
     @unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
                          "SOCK_CLOEXEC not defined")
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: 524289 != <SocketKind.SOCK_STREAM: 1>
-    @unittest.expectedFailure
     def test_SOCK_CLOEXEC(self):
         with socket.socket(socket.AF_INET,
                            socket.SOCK_STREAM | socket.SOCK_CLOEXEC) as s:
@@ -6064,8 +6434,6 @@ def checkNonblock(self, s, nonblock=True, timeout=0.0):
             self.assertTrue(s.getblocking())
 
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: 2049 != <SocketKind.SOCK_STREAM: 1>
-    @unittest.expectedFailure
     def test_SOCK_NONBLOCK(self):
         # a lot of it seems silly and redundant, but I wanted to test that
         # changing back and forth worked ok
@@ -6101,7 +6469,6 @@ def test_SOCK_NONBLOCK(self):
 
 @unittest.skipUnless(os.name == "nt", "Windows specific")
 @unittest.skipUnless(multiprocessing, "need multiprocessing")
-@unittest.skip("TODO: RUSTPYTHON, socket sharing")
 class TestSocketSharing(SocketTCPTest):
     # This must be classmethod and not staticmethod or multiprocessing
     # won't be able to bootstrap it.
@@ -6342,7 +6709,6 @@ def _testCount(self):
             self.assertEqual(sent, count)
             self.assertEqual(file.tell(), count)
 
-    @unittest.skipIf(sys.platform == "darwin", "TODO: RUSTPYTHON, killed (for OOM?)")
     def testCount(self):
         count = 5000007
         conn = self.accept_conn()
@@ -6418,7 +6784,6 @@ def _testWithTimeout(self):
             sent = meth(file)
             self.assertEqual(sent, self.FILESIZE)
 
-    @unittest.skip("TODO: RUSTPYTHON")
     def testWithTimeout(self):
         conn = self.accept_conn()
         data = self.recv_data(conn)
@@ -6472,6 +6837,7 @@ def test_errors(self):
 
 @unittest.skipUnless(hasattr(os, "sendfile"),
                      'os.sendfile() required for this test.')
+@unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly")
 class SendfileUsingSendfileTest(SendfileUsingSendTest):
     """
     Test the sendfile() implementation of socket.sendfile().
@@ -6497,8 +6863,6 @@ def create_alg(self, typ, name):
     # bpo-31705: On kernel older than 4.5, sendto() failed with ENOKEY,
     # at least on ppc64le architecture
     @support.requires_linux_version(4, 5)
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_sha256(self):
         expected = bytes.fromhex("ba7816bf8f01cfea414140de5dae2223b00361a396"
                                  "177a9cb410ff61f20015ad")
@@ -6516,8 +6880,6 @@ def test_sha256(self):
                 op.send(b'')
                 self.assertEqual(op.recv(512), expected)
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_hmac_sha1(self):
         # gh-109396: In FIPS mode, Linux 6.5 requires a key
         # of at least 112 bits. Use a key of 152 bits.
@@ -6534,8 +6896,6 @@ def test_hmac_sha1(self):
     # Although it should work with 3.19 and newer the test blocks on
     # Ubuntu 15.10 with Kernel 4.2.0-19.
     @support.requires_linux_version(4, 3)
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_aes_cbc(self):
         key = bytes.fromhex('06a9214036b8a15b512e03d534120006')
         iv = bytes.fromhex('3dafba429d9eb430b422da802c9fac41')
@@ -6576,10 +6936,14 @@ def test_aes_cbc(self):
             self.assertEqual(len(dec), msglen * multiplier)
             self.assertEqual(dec, msg * multiplier)
 
-    @support.requires_linux_version(4, 9)  # see issue29324
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
+    @support.requires_linux_version(4, 9)  # see gh-73510
     def test_aead_aes_gcm(self):
+        kernel_version = support._get_kernel_version("Linux")
+        if kernel_version is not None:
+            if kernel_version >= (6, 16) and kernel_version < (6, 18):
+                # See https://github.com/python/cpython/issues/139310.
+                self.skipTest("upstream Linux kernel issue")
+
         key = bytes.fromhex('c939cc13397c1d37de6ae0e1cb7c423c')
         iv = bytes.fromhex('b3d8cc017cbb89b39e0f67e2')
         plain = bytes.fromhex('c3b3c41f113a31b73d9a5cd432103069')
@@ -6642,8 +7006,6 @@ def test_aead_aes_gcm(self):
                 self.assertEqual(plain, res[assoclen:])
 
     @support.requires_linux_version(4, 3)  # see test_aes_cbc
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_drbg_pr_sha256(self):
         # deterministic random bit generator, prediction resistance, sha256
         with self.create_alg('rng', 'drbg_pr_sha256') as algo:
@@ -6654,8 +7016,6 @@ def test_drbg_pr_sha256(self):
                 rn = op.recv(32)
                 self.assertEqual(len(rn), 32)
 
-    # TODO: RUSTPYTHON, AttributeError: 'socket' object has no attribute 'sendmsg_afalg'
-    @unittest.expectedFailure
     def test_sendmsg_afalg_args(self):
         sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
         with sock:
@@ -6674,8 +7034,6 @@ def test_sendmsg_afalg_args(self):
             with self.assertRaises(TypeError):
                 sock.sendmsg_afalg(op=socket.ALG_OP_ENCRYPT, assoclen=-1)
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_length_restriction(self):
         # bpo-35050, off-by-one error in length check
         sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 8ad699d60a8..d6250e472bb 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -2804,7 +2804,7 @@ mod _socket {
                 let encoded =
                     vm.state
                         .codec_registry
-                        .encode_text(s.to_owned().into(), "idna", None, vm)?;
+                        .encode_text(s.to_owned(), "idna", None, vm)?;
                 let host_str = std::str::from_utf8(encoded.as_bytes())
                     .map_err(|_| vm.new_runtime_error("idna output is not utf8".to_owned()))?;
                 Some(host_str.to_owned())

From ed62c8ef58cbac2ab037f206203bfbbc907ae8cf Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Mon, 29 Dec 2025 11:27:00 +0900
Subject: [PATCH 107/418] mark failures

---
 Lib/test/test_socket.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 08676cf3388..87479171b5c 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -2394,6 +2394,8 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.interface = "vcan0"
 
+    # TODO: RUSTPYTHON - J1939 constants not fully implemented
+    @unittest.expectedFailure
     @unittest.skipUnless(hasattr(socket, "CAN_J1939"),
                          'socket.CAN_J1939 required for this test.')
     def testJ1939Constants(self):
@@ -2435,6 +2437,8 @@ def testCreateJ1939Socket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
             pass
 
+    # TODO: RUSTPYTHON - AF_CAN J1939 address format not fully implemented
+    @unittest.expectedFailure
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
@@ -4834,6 +4838,7 @@ class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
 
 @requireAttrs(socket.socket, "recvmsg")
 @requireAttrs(socket, "AF_UNIX")
+@unittest.skip("TODO: RUSTPYTHON; intermittent accept() EINVAL on Unix sockets")
 class RecvmsgUnixStreamTest(RecvmsgTests, RecvmsgGenericStreamTests,
                             SendrecvmsgUnixStreamTestBase):
     pass
@@ -4846,6 +4851,7 @@ class RecvmsgIntoUnixStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
 
 @requireAttrs(socket.socket, "sendmsg", "recvmsg")
 @requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS")
+@unittest.skip("TODO: RUSTPYTHON; intermittent accept() EINVAL on Unix sockets")
 class RecvmsgSCMRightsStreamTest(SCMRightsTest, SendrecvmsgUnixStreamTestBase):
     pass
 
@@ -6486,6 +6492,8 @@ def remoteProcessServer(cls, q):
         s2.close()
         s.close()
 
+    # TODO: RUSTPYTHON; multiprocessing.SemLock not implemented
+    @unittest.expectedFailure
     def testShare(self):
         # Transfer the listening server socket to another process
         # and service it from there.
@@ -6862,6 +6870,8 @@ def create_alg(self, typ, name):
 
     # bpo-31705: On kernel older than 4.5, sendto() failed with ENOKEY,
     # at least on ppc64le architecture
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure
     @support.requires_linux_version(4, 5)
     def test_sha256(self):
         expected = bytes.fromhex("ba7816bf8f01cfea414140de5dae2223b00361a396"
@@ -6880,6 +6890,8 @@ def test_sha256(self):
                 op.send(b'')
                 self.assertEqual(op.recv(512), expected)
 
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure
     def test_hmac_sha1(self):
         # gh-109396: In FIPS mode, Linux 6.5 requires a key
         # of at least 112 bits. Use a key of 152 bits.
@@ -6895,6 +6907,8 @@ def test_hmac_sha1(self):
 
     # Although it should work with 3.19 and newer the test blocks on
     # Ubuntu 15.10 with Kernel 4.2.0-19.
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure
     @support.requires_linux_version(4, 3)
     def test_aes_cbc(self):
         key = bytes.fromhex('06a9214036b8a15b512e03d534120006')
@@ -6936,6 +6950,8 @@ def test_aes_cbc(self):
             self.assertEqual(len(dec), msglen * multiplier)
             self.assertEqual(dec, msg * multiplier)
 
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure
     @support.requires_linux_version(4, 9)  # see gh-73510
     def test_aead_aes_gcm(self):
         kernel_version = support._get_kernel_version("Linux")
@@ -7005,6 +7021,8 @@ def test_aead_aes_gcm(self):
                 res = op.recv(len(msg) - taglen)
                 self.assertEqual(plain, res[assoclen:])
 
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
+    @unittest.expectedFailure
     @support.requires_linux_version(4, 3)  # see test_aes_cbc
     def test_drbg_pr_sha256(self):
         # deterministic random bit generator, prediction resistance, sha256

From feb5066be2d4854ef0d49b8a725093743598d54d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 29 Dec 2025 21:43:40 +0900
Subject: [PATCH 108/418] stdlib_module_names (#6568)

---
 .cspell.dict/cpython.txt        |   4 +
 Lib/test/test_sys.py            |   2 -
 crates/vm/src/builtins/frame.rs |   5 +
 crates/vm/src/stdlib/sys.rs     | 307 +++++++++++++++++++++++++++++++-
 4 files changed, 315 insertions(+), 3 deletions(-)

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index cb6f774ed18..5011975f496 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -36,8 +36,10 @@ kwonlyarg
 kwonlyargs
 lasti
 linearise
+lsprof
 maxdepth
 mult
+multibytecodec
 nkwargs
 noraise
 numer
@@ -49,6 +51,8 @@ posonlyarg
 posonlyargs
 prec
 preinitialized
+pydecimal
+pyrepl
 pythonw
 PYTHREAD_NAME
 releasebuffer
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 1ce2e9fc0fe..6ae3eaee74b 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -1124,8 +1124,6 @@ def test_orig_argv(self):
         self.assertEqual(proc.stdout.rstrip().splitlines(), expected,
                          proc)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'stdlib_module_names'
-    @unittest.expectedFailure
     def test_module_names(self):
         self.assertIsInstance(sys.stdlib_module_names, frozenset)
         for name in sys.stdlib_module_names:
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 6ccc594d338..3712b04e875 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -41,6 +41,11 @@ impl Frame {
         self.globals.clone()
     }
 
+    #[pygetset]
+    fn f_builtins(&self) -> PyDictRef {
+        self.builtins.clone()
+    }
+
     #[pygetset]
     fn f_locals(&self, vm: &VirtualMachine) -> PyResult {
         self.locals(vm).map(Into::into)
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 0e46ec18a01..92b15878b46 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -9,7 +9,8 @@ mod sys {
     use crate::{
         AsObject, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult,
         builtins::{
-            PyBaseExceptionRef, PyDictRef, PyNamespace, PyStr, PyStrRef, PyTupleRef, PyTypeRef,
+            PyBaseExceptionRef, PyDictRef, PyFrozenSet, PyNamespace, PyStr, PyStrRef, PyTupleRef,
+            PyTypeRef,
         },
         common::{
             ascii,
@@ -148,6 +149,310 @@ mod sys {
         )
     }
 
+    // List from cpython/Python/stdlib_module_names.h
+    const STDLIB_MODULE_NAMES: &[&str] = &[
+        "__future__",
+        "_abc",
+        "_aix_support",
+        "_android_support",
+        "_apple_support",
+        "_ast",
+        "_asyncio",
+        "_bisect",
+        "_blake2",
+        "_bz2",
+        "_codecs",
+        "_codecs_cn",
+        "_codecs_hk",
+        "_codecs_iso2022",
+        "_codecs_jp",
+        "_codecs_kr",
+        "_codecs_tw",
+        "_collections",
+        "_collections_abc",
+        "_colorize",
+        "_compat_pickle",
+        "_compression",
+        "_contextvars",
+        "_csv",
+        "_ctypes",
+        "_curses",
+        "_curses_panel",
+        "_datetime",
+        "_dbm",
+        "_decimal",
+        "_elementtree",
+        "_frozen_importlib",
+        "_frozen_importlib_external",
+        "_functools",
+        "_gdbm",
+        "_hashlib",
+        "_heapq",
+        "_imp",
+        "_interpchannels",
+        "_interpqueues",
+        "_interpreters",
+        "_io",
+        "_ios_support",
+        "_json",
+        "_locale",
+        "_lsprof",
+        "_lzma",
+        "_markupbase",
+        "_md5",
+        "_multibytecodec",
+        "_multiprocessing",
+        "_opcode",
+        "_opcode_metadata",
+        "_operator",
+        "_osx_support",
+        "_overlapped",
+        "_pickle",
+        "_posixshmem",
+        "_posixsubprocess",
+        "_py_abc",
+        "_pydatetime",
+        "_pydecimal",
+        "_pyio",
+        "_pylong",
+        "_pyrepl",
+        "_queue",
+        "_random",
+        "_scproxy",
+        "_sha1",
+        "_sha2",
+        "_sha3",
+        "_signal",
+        "_sitebuiltins",
+        "_socket",
+        "_sqlite3",
+        "_sre",
+        "_ssl",
+        "_stat",
+        "_statistics",
+        "_string",
+        "_strptime",
+        "_struct",
+        "_suggestions",
+        "_symtable",
+        "_sysconfig",
+        "_thread",
+        "_threading_local",
+        "_tkinter",
+        "_tokenize",
+        "_tracemalloc",
+        "_typing",
+        "_uuid",
+        "_warnings",
+        "_weakref",
+        "_weakrefset",
+        "_winapi",
+        "_wmi",
+        "_zoneinfo",
+        "abc",
+        "antigravity",
+        "argparse",
+        "array",
+        "ast",
+        "asyncio",
+        "atexit",
+        "base64",
+        "bdb",
+        "binascii",
+        "bisect",
+        "builtins",
+        "bz2",
+        "cProfile",
+        "calendar",
+        "cmath",
+        "cmd",
+        "code",
+        "codecs",
+        "codeop",
+        "collections",
+        "colorsys",
+        "compileall",
+        "concurrent",
+        "configparser",
+        "contextlib",
+        "contextvars",
+        "copy",
+        "copyreg",
+        "csv",
+        "ctypes",
+        "curses",
+        "dataclasses",
+        "datetime",
+        "dbm",
+        "decimal",
+        "difflib",
+        "dis",
+        "doctest",
+        "email",
+        "encodings",
+        "ensurepip",
+        "enum",
+        "errno",
+        "faulthandler",
+        "fcntl",
+        "filecmp",
+        "fileinput",
+        "fnmatch",
+        "fractions",
+        "ftplib",
+        "functools",
+        "gc",
+        "genericpath",
+        "getopt",
+        "getpass",
+        "gettext",
+        "glob",
+        "graphlib",
+        "grp",
+        "gzip",
+        "hashlib",
+        "heapq",
+        "hmac",
+        "html",
+        "http",
+        "idlelib",
+        "imaplib",
+        "importlib",
+        "inspect",
+        "io",
+        "ipaddress",
+        "itertools",
+        "json",
+        "keyword",
+        "linecache",
+        "locale",
+        "logging",
+        "lzma",
+        "mailbox",
+        "marshal",
+        "math",
+        "mimetypes",
+        "mmap",
+        "modulefinder",
+        "msvcrt",
+        "multiprocessing",
+        "netrc",
+        "nt",
+        "ntpath",
+        "nturl2path",
+        "numbers",
+        "opcode",
+        "operator",
+        "optparse",
+        "os",
+        "pathlib",
+        "pdb",
+        "pickle",
+        "pickletools",
+        "pkgutil",
+        "platform",
+        "plistlib",
+        "poplib",
+        "posix",
+        "posixpath",
+        "pprint",
+        "profile",
+        "pstats",
+        "pty",
+        "pwd",
+        "py_compile",
+        "pyclbr",
+        "pydoc",
+        "pydoc_data",
+        "pyexpat",
+        "queue",
+        "quopri",
+        "random",
+        "re",
+        "readline",
+        "reprlib",
+        "resource",
+        "rlcompleter",
+        "runpy",
+        "sched",
+        "secrets",
+        "select",
+        "selectors",
+        "shelve",
+        "shlex",
+        "shutil",
+        "signal",
+        "site",
+        "smtplib",
+        "socket",
+        "socketserver",
+        "sqlite3",
+        "sre_compile",
+        "sre_constants",
+        "sre_parse",
+        "ssl",
+        "stat",
+        "statistics",
+        "string",
+        "stringprep",
+        "struct",
+        "subprocess",
+        "symtable",
+        "sys",
+        "sysconfig",
+        "syslog",
+        "tabnanny",
+        "tarfile",
+        "tempfile",
+        "termios",
+        "textwrap",
+        "this",
+        "threading",
+        "time",
+        "timeit",
+        "tkinter",
+        "token",
+        "tokenize",
+        "tomllib",
+        "trace",
+        "traceback",
+        "tracemalloc",
+        "tty",
+        "turtle",
+        "turtledemo",
+        "types",
+        "typing",
+        "unicodedata",
+        "unittest",
+        "urllib",
+        "uuid",
+        "venv",
+        "warnings",
+        "wave",
+        "weakref",
+        "webbrowser",
+        "winreg",
+        "winsound",
+        "wsgiref",
+        "xml",
+        "xmlrpc",
+        "zipapp",
+        "zipfile",
+        "zipimport",
+        "zlib",
+        "zoneinfo",
+    ];
+
+    #[pyattr(once)]
+    fn stdlib_module_names(vm: &VirtualMachine) -> PyObjectRef {
+        let names = STDLIB_MODULE_NAMES
+            .iter()
+            .map(|&n| vm.ctx.new_str(n).into());
+        PyFrozenSet::from_iter(vm, names)
+            .expect("Creating stdlib_module_names frozen set must succeed")
+            .to_pyobject(vm)
+    }
+
     #[pyattr]
     fn byteorder(vm: &VirtualMachine) -> PyStrRef {
         // https://doc.rust-lang.org/reference/conditional-compilation.html#target_endian

From 879813f7635f78ddf4b8ff00a59c0b1518726df1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 29 Dec 2025 22:52:52 +0900
Subject: [PATCH 109/418] Bump rustix from 1.1.2 to 1.1.3 (#6572)

Bumps [rustix](https://github.com/bytecodealliance/rustix) from 1.1.2 to 1.1.3.
- [Release notes](https://github.com/bytecodealliance/rustix/releases)
- [Changelog](https://github.com/bytecodealliance/rustix/blob/main/CHANGES.md)
- [Commits](https://github.com/bytecodealliance/rustix/compare/v1.1.2...v1.1.3)

---
updated-dependencies:
- dependency-name: rustix
  dependency-version: 1.1.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 18 +++++++++---------
 Cargo.toml |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ffcc1e37c17..ad1e52c9587 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -113,7 +113,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -124,7 +124,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1146,7 +1146,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2853,15 +2853,15 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
 dependencies = [
  "bitflags 2.10.0",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2926,7 +2926,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3739,7 +3739,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -4389,7 +4389,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 44f9d3190f7..06734b47e18 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -199,7 +199,7 @@ quote = "1.0.38"
 radium = "1.1.1"
 rand = "0.9"
 rand_core = { version = "0.9", features = ["os_rng"] }
-rustix = { version = "1.0", features = ["event"] }
+rustix = { version = "1.1", features = ["event"] }
 rustyline = "17.0.1"
 serde = { version = "1.0.225", default-features = false }
 schannel = "0.1.28"

From 80599603e5775159a695d051fe43fd006bc868ba Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 29 Dec 2025 22:53:04 +0900
Subject: [PATCH 110/418] Bump insta from 1.45.0 to 1.45.1 (#6575)

Bumps [insta](https://github.com/mitsuhiko/insta) from 1.45.0 to 1.45.1.
- [Release notes](https://github.com/mitsuhiko/insta/releases)
- [Changelog](https://github.com/mitsuhiko/insta/blob/master/CHANGELOG.md)
- [Commits](https://github.com/mitsuhiko/insta/compare/1.45.0...1.45.1)

---
updated-dependencies:
- dependency-name: insta
  dependency-version: 1.45.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ad1e52c9587..46c4dafe13b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1181,7 +1181,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
  "cfg-if",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1487,9 +1487,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.45.0"
+version = "1.45.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b76866be74d68b1595eb8060cb9191dca9c021db2316558e52ddc5d55d41b66c"
+checksum = "983e3b24350c84ab8a65151f537d67afbbf7153bb9f1110e03e9fa9b07f67a5c"
 dependencies = [
  "console",
  "once_cell",

From 39aa6f952489c290c2174b27eec3aad21e365648 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 29 Dec 2025 23:17:16 +0900
Subject: [PATCH 111/418] use accept_raw (#6578)

---
 Lib/test/test_socket.py     | 3 ---
 crates/stdlib/src/socket.rs | 4 +++-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 87479171b5c..08d3dcb5792 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -4832,13 +4832,11 @@ class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase,
 
 @requireAttrs(socket.socket, "sendmsg")
 @requireAttrs(socket, "AF_UNIX")
-@unittest.skip("TODO: RUSTPYTHON; accept() on Unix sockets returns EINVAL")
 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
     pass
 
 @requireAttrs(socket.socket, "recvmsg")
 @requireAttrs(socket, "AF_UNIX")
-@unittest.skip("TODO: RUSTPYTHON; intermittent accept() EINVAL on Unix sockets")
 class RecvmsgUnixStreamTest(RecvmsgTests, RecvmsgGenericStreamTests,
                             SendrecvmsgUnixStreamTestBase):
     pass
@@ -4851,7 +4849,6 @@ class RecvmsgIntoUnixStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
 
 @requireAttrs(socket.socket, "sendmsg", "recvmsg")
 @requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS")
-@unittest.skip("TODO: RUSTPYTHON; intermittent accept() EINVAL on Unix sockets")
 class RecvmsgSCMRightsStreamTest(SCMRightsTest, SendrecvmsgUnixStreamTestBase):
     pass
 
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index d6250e472bb..91c7b1201f1 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -1570,7 +1570,9 @@ mod _socket {
             &self,
             vm: &VirtualMachine,
         ) -> Result<(RawSocket, PyObjectRef), IoOrPyException> {
-            let (sock, addr) = self.sock_op(vm, SelectKind::Read, || self.sock()?.accept())?;
+            // Use accept_raw() instead of accept() to avoid socket2's set_common_flags()
+            // which tries to set SO_NOSIGPIPE and fails with EINVAL on Unix domain sockets on macOS
+            let (sock, addr) = self.sock_op(vm, SelectKind::Read, || self.sock()?.accept_raw())?;
             let fd = into_sock_fileno(sock);
             Ok((fd, get_addr_tuple(&addr, vm)))
         }

From 4ce68279166016888797f3a5f9eccdae781c13da Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 00:24:07 +0900
Subject: [PATCH 112/418] various fix to support subprocess/multiprocessing
 (#6567)

* hashlib.UnsupportedDigestmodError

* mmap readonly

* thread _refcount

* fix os.statvfs

* apply review
---
 Lib/test/test_hmac.py          |   8 ---
 crates/stdlib/src/hashlib.rs   |  29 ++++++---
 crates/stdlib/src/mmap.rs      |   3 +-
 crates/vm/src/stdlib/os.rs     | 106 +++++++++++++++++++++++++++++++++
 crates/vm/src/stdlib/thread.rs |  25 +++++++-
 5 files changed, 152 insertions(+), 19 deletions(-)

diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
index 8e1a4a204c5..74ebcb2fe70 100644
--- a/Lib/test/test_hmac.py
+++ b/Lib/test/test_hmac.py
@@ -432,8 +432,6 @@ def test_dot_new_with_str_key(self):
         with self.assertRaises(TypeError):
             h = hmac.new("key", digestmod='sha256')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_withtext(self):
         # Constructor call with text.
@@ -443,8 +441,6 @@ def test_withtext(self):
             self.fail("Constructor call with text argument raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_with_bytearray(self):
         try:
@@ -454,8 +450,6 @@ def test_with_bytearray(self):
             self.fail("Constructor call with bytearray arguments raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_with_memoryview_msg(self):
         try:
@@ -464,8 +458,6 @@ def test_with_memoryview_msg(self):
             self.fail("Constructor call with memoryview msg raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_withmodule(self):
         # Constructor call with text and digest module.
diff --git a/crates/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
index e7b03a2ff12..bfde58f43f7 100644
--- a/crates/stdlib/src/hashlib.rs
+++ b/crates/stdlib/src/hashlib.rs
@@ -7,11 +7,11 @@ pub mod _hashlib {
     use crate::common::lock::PyRwLock;
     use crate::vm::{
         Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBytes, PyStrRef, PyTypeRef},
+        builtins::{PyBytes, PyStrRef, PyTypeRef, PyValueError},
+        class::StaticType,
         convert::ToPyObject,
         function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
-        protocol::PyBuffer,
-        types::Representable,
+        types::{Constructor, Initializer, Representable},
     };
     use blake2::{Blake2b512, Blake2s256};
     use digest::{DynDigest, core_api::BlockSizeUser};
@@ -22,6 +22,12 @@ pub mod _hashlib {
     use sha2::{Sha224, Sha256, Sha384, Sha512};
     use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 
+    #[pyattr]
+    #[pyexception(name = "UnsupportedDigestmodError", base = PyValueError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct UnsupportedDigestmodError(PyValueError);
+
     #[derive(FromArgs, Debug)]
     #[allow(unused)]
     struct NewHashArgs {
@@ -338,16 +344,21 @@ pub mod _hashlib {
     #[allow(unused)]
     pub struct NewHMACHashArgs {
         #[pyarg(positional)]
-        name: PyBuffer,
+        key: ArgBytesLike,
         #[pyarg(any, optional)]
-        data: OptionalArg<ArgBytesLike>,
-        #[pyarg(named, default = true)]
-        digestmod: bool, // TODO: RUSTPYTHON support functions & name functions
+        msg: OptionalArg<ArgBytesLike>,
+        #[pyarg(named, optional)]
+        digestmod: OptionalArg<PyObjectRef>,
     }
 
     #[pyfunction]
-    fn hmac_new(_args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        Err(vm.new_type_error("cannot create 'hmac' instances")) // TODO: RUSTPYTHON support hmac
+    fn hmac_new(args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Raise UnsupportedDigestmodError so Python's hmac.py falls back to pure-Python implementation
+        let _ = args;
+        Err(vm.new_exception_msg(
+            UnsupportedDigestmodError::static_type().to_owned(),
+            "unsupported hash type".to_owned(),
+        ))
     }
 
     pub trait ThreadSafeDynDigest: DynClone + DynDigest + Sync + Send {}
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
index 5309917a999..f1e2c2a039d 100644
--- a/crates/stdlib/src/mmap.rs
+++ b/crates/stdlib/src/mmap.rs
@@ -651,9 +651,10 @@ mod mmap {
 
     impl AsBuffer for PyMmap {
         fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+            let readonly = matches!(zelf.access, AccessMode::Read);
             let buf = PyBuffer::new(
                 zelf.to_owned().into(),
-                BufferDescriptor::simple(zelf.__len__(), true),
+                BufferDescriptor::simple(zelf.__len__(), readonly),
                 &BUFFER_METHODS,
             );
 
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 6849ea365df..6e2bb274fec 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -202,6 +202,15 @@ pub(super) mod _os {
     #[pyattr]
     pub(crate) const X_OK: u8 = 1 << 0;
 
+    // ST_RDONLY and ST_NOSUID flags for statvfs
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    const ST_RDONLY: libc::c_ulong = libc::ST_RDONLY;
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    const ST_NOSUID: libc::c_ulong = libc::ST_NOSUID;
+
     #[pyfunction]
     fn close(fileno: crt_fd::Owned) -> io::Result<()> {
         crt_fd::close(fileno)
@@ -1701,6 +1710,103 @@ pub(super) mod _os {
     #[pyclass(with(PyStructSequence))]
     impl PyUnameResult {}
 
+    // statvfs_result: Result from statvfs or fstatvfs.
+    // = statvfs_result_fields
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[derive(Debug)]
+    #[pystruct_sequence_data]
+    pub(crate) struct StatvfsResultData {
+        pub f_bsize: libc::c_ulong,     // filesystem block size
+        pub f_frsize: libc::c_ulong,    // fragment size
+        pub f_blocks: libc::fsblkcnt_t, // size of fs in f_frsize units
+        pub f_bfree: libc::fsblkcnt_t,  // free blocks
+        pub f_bavail: libc::fsblkcnt_t, // free blocks for unprivileged users
+        pub f_files: libc::fsfilcnt_t,  // inodes
+        pub f_ffree: libc::fsfilcnt_t,  // free inodes
+        pub f_favail: libc::fsfilcnt_t, // free inodes for unprivileged users
+        pub f_flag: libc::c_ulong,      // mount flags
+        pub f_namemax: libc::c_ulong,   // maximum filename length
+        #[pystruct_sequence(skip)]
+        pub f_fsid: libc::c_ulong, // filesystem ID (not in tuple but accessible as attribute)
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    #[pystruct_sequence(name = "statvfs_result", module = "os", data = "StatvfsResultData")]
+    pub(crate) struct PyStatvfsResult;
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyclass(with(PyStructSequence))]
+    impl PyStatvfsResult {
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let seq: PyObjectRef = args.bind(vm)?;
+            crate::types::struct_sequence_new(cls, seq, vm)
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl StatvfsResultData {
+        fn from_statvfs(st: libc::statvfs) -> Self {
+            // f_fsid is a struct on some platforms (e.g., Linux fsid_t) and a scalar on others.
+            // We extract raw bytes and interpret as a native-endian integer.
+            // Note: The value may differ across architectures due to endianness.
+            let f_fsid = {
+                let ptr = std::ptr::addr_of!(st.f_fsid) as *const u8;
+                let size = std::mem::size_of_val(&st.f_fsid);
+                if size >= 8 {
+                    let bytes = unsafe { std::slice::from_raw_parts(ptr, 8) };
+                    u64::from_ne_bytes([
+                        bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6],
+                        bytes[7],
+                    ]) as libc::c_ulong
+                } else if size >= 4 {
+                    let bytes = unsafe { std::slice::from_raw_parts(ptr, 4) };
+                    u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as libc::c_ulong
+                } else {
+                    0
+                }
+            };
+
+            Self {
+                f_bsize: st.f_bsize,
+                f_frsize: st.f_frsize,
+                f_blocks: st.f_blocks,
+                f_bfree: st.f_bfree,
+                f_bavail: st.f_bavail,
+                f_files: st.f_files,
+                f_ffree: st.f_ffree,
+                f_favail: st.f_favail,
+                f_flag: st.f_flag,
+                f_namemax: st.f_namemax,
+                f_fsid,
+            }
+        }
+    }
+
+    /// Perform a statvfs system call on the given path.
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction]
+    #[pyfunction(name = "fstatvfs")]
+    fn statvfs(path: OsPathOrFd<'_>, vm: &VirtualMachine) -> PyResult {
+        let mut st: libc::statvfs = unsafe { std::mem::zeroed() };
+        let ret = match &path {
+            OsPathOrFd::Path(p) => {
+                let cpath = p.clone().into_cstring(vm)?;
+                unsafe { libc::statvfs(cpath.as_ptr(), &mut st) }
+            }
+            OsPathOrFd::Fd(fd) => unsafe { libc::fstatvfs(fd.as_raw(), &mut st) },
+        };
+        if ret != 0 {
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path,
+                vm,
+            ));
+        }
+        Ok(StatvfsResultData::from_statvfs(st).to_pyobject(vm))
+    }
+
     pub(super) fn support_funcs() -> Vec<SupportFunc> {
         let mut supports = super::platform::module::support_funcs();
         supports.extend(vec![
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index 36252279397..fd300ac2f74 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -190,6 +190,7 @@ pub(crate) mod _thread {
     #[derive(PyPayload)]
     struct RLock {
         mu: RawRMutex,
+        count: std::sync::atomic::AtomicUsize,
     }
 
     impl fmt::Debug for RLock {
@@ -204,6 +205,7 @@ pub(crate) mod _thread {
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Self {
                 mu: RawRMutex::INIT,
+                count: std::sync::atomic::AtomicUsize::new(0),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into)
@@ -213,7 +215,12 @@ pub(crate) mod _thread {
         #[pymethod(name = "acquire_lock")]
         #[pymethod(name = "__enter__")]
         fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
-            acquire_lock_impl!(&self.mu, args, vm)
+            let result = acquire_lock_impl!(&self.mu, args, vm)?;
+            if result {
+                self.count
+                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            }
+            Ok(result)
         }
         #[pymethod]
         #[pymethod(name = "release_lock")]
@@ -221,6 +228,12 @@ pub(crate) mod _thread {
             if !self.mu.is_locked() {
                 return Err(vm.new_runtime_error("release unlocked lock"));
             }
+            debug_assert!(
+                self.count.load(std::sync::atomic::Ordering::Relaxed) > 0,
+                "RLock count underflow"
+            );
+            self.count
+                .fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
             unsafe { self.mu.unlock() };
             Ok(())
         }
@@ -232,6 +245,7 @@ pub(crate) mod _thread {
                     self.mu.unlock();
                 };
             }
+            self.count.store(0, std::sync::atomic::Ordering::Relaxed);
             let new_mut = RawRMutex::INIT;
 
             let old_mutex: AtomicCell<&RawRMutex> = AtomicCell::new(&self.mu);
@@ -245,6 +259,15 @@ pub(crate) mod _thread {
             self.mu.is_owned_by_current_thread()
         }
 
+        #[pymethod]
+        fn _recursion_count(&self) -> usize {
+            if self.mu.is_owned_by_current_thread() {
+                self.count.load(std::sync::atomic::Ordering::Relaxed)
+            } else {
+                0
+            }
+        }
+
         #[pymethod]
         fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             self.release(vm)

From f91ffe34d45ec744cd0d6e00703ed3eb19db0c22 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 00:36:52 +0900
Subject: [PATCH 113/418] Fix pyexpat parse (#6582)

---
 Lib/test/test_pyexpat.py            |   7 --
 Lib/test/test_xml_dom_xmlbuilder.py |   4 -
 Lib/test/test_xmlrpc.py             |  38 ----------
 Lib/xmlrpc/client.py                |   3 +-
 crates/stdlib/src/pyexpat.rs        | 110 +++++++++++++++++++++-------
 5 files changed, 85 insertions(+), 77 deletions(-)

diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index 015e7497268..d360e8cd65d 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -227,7 +227,6 @@ def _verify_parse_output(self, operations):
         for operation, expected_operation in zip(operations, expected_operations):
             self.assertEqual(operation, expected_operation)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse_bytes(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -276,7 +275,6 @@ def test_parse_again(self):
                           expat.errors.XML_ERROR_FINISHED)
 
 class NamespaceSeparatorTest(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_legal(self):
         # Tests that make sure we get errors when the namespace_separator value
         # is illegal, and that we don't for good values:
@@ -409,14 +407,12 @@ def test2(self):
         self.assertEqual(self.stuff, ["1<2> \n 3"],
                          "buffered text not properly collapsed")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test3(self):
         self.setHandlers(["StartElementHandler"])
         self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
         self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
                          "buffered text not properly split")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test4(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.CharacterDataHandler = None
@@ -424,14 +420,12 @@ def test4(self):
         self.assertEqual(self.stuff,
                          ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test5(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.Parse(b"<a>1<b></b>2<c/>3</a>", True)
         self.assertEqual(self.stuff,
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test6(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -529,7 +523,6 @@ def check_pos(self, event):
                 'Expected position %s, got position %s' %(pos, expected))
         self.upto += 1
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test(self):
         self.parser = expat.ParserCreate()
         self.parser.StartElementHandler = self.StartElementHandler
diff --git a/Lib/test/test_xml_dom_xmlbuilder.py b/Lib/test/test_xml_dom_xmlbuilder.py
index 5282e806e40..5f5f2eb328d 100644
--- a/Lib/test/test_xml_dom_xmlbuilder.py
+++ b/Lib/test/test_xml_dom_xmlbuilder.py
@@ -50,8 +50,6 @@ def test_builder(self):
         builder = imp.createDOMBuilder(imp.MODE_SYNCHRONOUS, None)
         self.assertIsInstance(builder, xmlbuilder.DOMBuilder)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parse_uri(self):
         body = (
             b"HTTP/1.1 200 OK\r\nContent-Type: text/xml; charset=utf-8\r\n\r\n"
@@ -74,8 +72,6 @@ def test_parse_uri(self):
         self.assertIsInstance(document, minidom.Document)
         self.assertEqual(len(document.childNodes), 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parse_with_systemId(self):
         response = io.BytesIO(SMALL_SAMPLE)
 
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index 8684e042bee..cf3f535b190 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -47,13 +47,11 @@
 
 class XMLRPCTestCase(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_load(self):
         dump = xmlrpclib.dumps((alist,))
         load = xmlrpclib.loads(dump)
         self.assertEqual(alist, load[0][0])
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_bare_datetime(self):
         # This checks that an unwrapped datetime.date object can be handled
         # by the marshalling code.  This can't be done via test_dump_load()
@@ -88,7 +86,6 @@ def test_dump_bare_datetime(self):
         self.assertIsNone(m)
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_datetime_before_1900(self):
         # same as before but with a date before 1900
         dt = datetime.datetime(1,  2, 10, 11, 41, 23)
@@ -107,7 +104,6 @@ def test_datetime_before_1900(self):
         self.assertIs(type(newdt), xmlrpclib.DateTime)
         self.assertIsNone(m)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_1164912 (self):
         d = xmlrpclib.DateTime()
         ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
@@ -118,7 +114,6 @@ def test_bug_1164912 (self):
         s = xmlrpclib.dumps((new_d,), methodresponse=True)
         self.assertIsInstance(s, str)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newstyle_class(self):
         class T(object):
             pass
@@ -184,7 +179,6 @@ def dummy_write(s):
         m.dump_double(xmlrpclib.MAXINT + 42, dummy_write)
         m.dump_double(xmlrpclib.MININT - 42, dummy_write)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_none(self):
         value = alist + [None]
         arg1 = (alist + [None],)
@@ -215,7 +209,6 @@ def test_dump_encoding(self):
         self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
         self.assertEqual(xmlrpclib.loads(strg)[1], methodname)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_bytes(self):
         sample = b"my dog has fleas"
         self.assertEqual(sample, xmlrpclib.Binary(sample))
@@ -258,7 +251,6 @@ def check_loads(self, s, value, **kwargs):
         self.assertIs(type(newvalue), type(value))
         self.assertIsNone(m)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_load_standard_types(self):
         check = self.check_loads
         check('string', 'string')
@@ -300,7 +292,6 @@ def test_load_extension_types(self):
         check('<bigdecimal>9876543210.0123456789</bigdecimal>',
               decimal.Decimal('9876543210.0123456789'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; NameError: name 'expat' is not defined
     def test_limit_int(self):
         check = self.check_loads
         maxdigits = 5000
@@ -332,7 +323,6 @@ def test_ssl_presence(self):
         except OSError:
             self.assertTrue(has_ssl)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keepalive_disconnect(self):
         class RequestHandler(http.server.BaseHTTPRequestHandler):
             protocol_version = "HTTP/1.1"
@@ -472,7 +462,6 @@ def test_repr(self):
         self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
         self.assertEqual(repr(f), str(f))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_fault(self):
         f = xmlrpclib.Fault(42, 'Test Fault')
         s = xmlrpclib.dumps((f,))
@@ -820,7 +809,6 @@ def tearDown(self):
         xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
 
 class SimpleServerTestCase(BaseServerTestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple1(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -831,7 +819,6 @@ def test_simple1(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_nonascii(self):
         start_string = 'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t'
         end_string = 'h\N{LATIN SMALL LETTER O WITH HORN}n'
@@ -860,7 +847,6 @@ def test_client_encoding(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_nonascii_methodname(self):
         try:
             p = xmlrpclib.ServerProxy(URL, encoding='ascii')
@@ -881,7 +867,6 @@ def test_404(self):
         self.assertEqual(response.status, 404)
         self.assertEqual(response.reason, 'Not Found')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_introspection1(self):
         expected_methods = set(['pow', 'div', 'my_function', 'add', 'têšt',
                                 'system.listMethods', 'system.methodHelp',
@@ -898,7 +883,6 @@ def test_introspection1(self):
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_introspection2(self):
         try:
             # test _methodHelp()
@@ -911,7 +895,6 @@ def test_introspection2(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @make_request_and_skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
     def test_introspection3(self):
@@ -926,7 +909,6 @@ def test_introspection3(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_introspection4(self):
         # the SimpleXMLRPCServer doesn't support signatures, but
         # at least check that we can try making the call
@@ -940,7 +922,6 @@ def test_introspection4(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multicall(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -958,7 +939,6 @@ def test_multicall(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_existing_multicall(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -980,7 +960,6 @@ def test_non_existing_multicall(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dotted_attribute(self):
         # Raises an AttributeError because private methods are not allowed.
         self.assertRaises(AttributeError,
@@ -991,14 +970,12 @@ def test_dotted_attribute(self):
         # This avoids waiting for the socket timeout.
         self.test_simple1()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_allow_dotted_names_true(self):
         # XXX also need allow_dotted_names_false test.
         server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
         data = server.Fixture.getData()
         self.assertEqual(data, '42')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unicode_host(self):
         server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
         self.assertEqual(server.add("a", "\xe9"), "a\xe9")
@@ -1013,7 +990,6 @@ def test_partial_post(self):
                       'Accept-Encoding: identity\r\n'
                       'Content-Length: 0\r\n\r\n'.encode('ascii'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_context_manager(self):
         with xmlrpclib.ServerProxy(URL) as server:
             server.add(2, 3)
@@ -1022,7 +998,6 @@ def test_context_manager(self):
         self.assertEqual(server('transport')._connection,
                          (None, None))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_context_manager_method_error(self):
         try:
             with xmlrpclib.ServerProxy(URL) as server:
@@ -1057,13 +1032,11 @@ def test_server_encoding(self):
 class MultiPathServerTestCase(BaseServerTestCase):
     threadFunc = staticmethod(http_multi_server)
     request_count = 2
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_path1(self):
         p = xmlrpclib.ServerProxy(URL+"/foo")
         self.assertEqual(p.pow(6,8), 6**8)
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_path2(self):
         p = xmlrpclib.ServerProxy(URL+"/foo/bar")
         self.assertEqual(p.add(6,8), 6+8)
@@ -1151,7 +1124,6 @@ def setUp(self):
 #A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism
 #does indeed serve subsequent requests on the same connection
 class KeepaliveServerTestCase1(BaseKeepaliveServerTestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_two(self):
         p = xmlrpclib.ServerProxy(URL)
         #do three requests.
@@ -1235,7 +1207,6 @@ def send_content(self, connection, body):
     def setUp(self):
         BaseServerTestCase.setUp(self)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gzip_request(self):
         t = self.Transport()
         t.encode_threshold = None
@@ -1259,7 +1230,6 @@ def test_bad_gzip_request(self):
             p.pow(6, 8)
         p("close")()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gzip_response(self):
         t = self.Transport()
         p = xmlrpclib.ServerProxy(URL, transport=t)
@@ -1318,7 +1288,6 @@ def assertContainsAdditionalHeaders(self, headers, additional):
         for key, value in additional.items():
             self.assertEqual(headers.get(key), value)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_header(self):
         p = xmlrpclib.ServerProxy(URL, headers=[('X-Test', 'foo')])
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1326,7 +1295,6 @@ def test_header(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_header_many(self):
         p = xmlrpclib.ServerProxy(
             URL, headers=[('X-Test', 'foo'), ('X-Test-Second', 'bar')])
@@ -1336,7 +1304,6 @@ def test_header_many(self):
         self.assertContainsAdditionalHeaders(
             headers, {'X-Test': 'foo', 'X-Test-Second': 'bar'})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_header_empty(self):
         p = xmlrpclib.ServerProxy(URL, headers=[])
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1344,7 +1311,6 @@ def test_header_empty(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_header_tuple(self):
         p = xmlrpclib.ServerProxy(URL, headers=(('X-Test', 'foo'),))
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1352,7 +1318,6 @@ def test_header_tuple(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_header_items(self):
         p = xmlrpclib.ServerProxy(URL, headers={'X-Test': 'foo'}.items())
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1411,7 +1376,6 @@ def tearDown(self):
         default_class = http.client.HTTPMessage
         xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = default_class
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_basic(self):
         # check that flag is false by default
         flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header
@@ -1506,7 +1470,6 @@ def test_cgi_get(self):
             self.assertEqual(message, 'Bad Request')
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cgi_xmlrpc_response(self):
         data = """<?xml version='1.0'?>
         <methodCall>
@@ -1552,7 +1515,6 @@ def test_cgi_xmlrpc_response(self):
 
 class UseBuiltinTypesTestCase(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_use_builtin_types(self):
         # SimpleXMLRPCDispatcher.__init__ accepts use_builtin_types, which
         # makes all dispatch of binary data as bytes instances, and all
diff --git a/Lib/xmlrpc/client.py b/Lib/xmlrpc/client.py
index 121e44023c1..a614cef6ab2 100644
--- a/Lib/xmlrpc/client.py
+++ b/Lib/xmlrpc/client.py
@@ -135,8 +135,7 @@
 from decimal import Decimal
 import http.client
 import urllib.parse
-# XXX RUSTPYTHON TODO: pyexpat
-# from xml.parsers import expat
+from xml.parsers import expat
 import errno
 from io import BytesIO
 try:
diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
index e96d6287489..89cf690770d 100644
--- a/crates/stdlib/src/pyexpat.rs
+++ b/crates/stdlib/src/pyexpat.rs
@@ -1,4 +1,7 @@
-/// Pyexpat builtin module
+//! Pyexpat builtin module
+
+// spell-checker: ignore libexpat
+
 use crate::vm::{PyRef, VirtualMachine, builtins::PyModule, extend_module};
 
 pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
@@ -49,9 +52,9 @@ macro_rules! create_bool_property {
 mod _pyexpat {
     use crate::vm::{
         Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyStr, PyStrRef, PyType},
+        builtins::{PyBytesRef, PyStr, PyStrRef, PyType},
         function::ArgBytesLike,
-        function::{IntoFuncArgs, OptionalArg},
+        function::{Either, IntoFuncArgs, OptionalArg},
     };
     use rustpython_common::lock::PyRwLock;
     use std::io::Cursor;
@@ -66,6 +69,8 @@ mod _pyexpat {
     #[pyclass(name = "xmlparser", module = false, traverse)]
     #[derive(Debug, PyPayload)]
     pub struct PyExpatLikeXmlParser {
+        #[pytraverse(skip)]
+        namespace_separator: Option<String>,
         start_element: MutableObject,
         end_element: MutableObject,
         character_data: MutableObject,
@@ -109,8 +114,14 @@ mod _pyexpat {
 
     #[pyclass]
     impl PyExpatLikeXmlParser {
-        fn new(vm: &VirtualMachine) -> PyResult<PyExpatLikeXmlParserRef> {
+        fn new(
+            namespace_separator: Option<String>,
+            intern: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyExpatLikeXmlParserRef> {
+            let intern_dict = intern.unwrap_or_else(|| vm.ctx.new_dict().into());
             Ok(Self {
+                namespace_separator,
                 start_element: MutableObject::new(vm.ctx.none()),
                 end_element: MutableObject::new(vm.ctx.none()),
                 character_data: MutableObject::new(vm.ctx.none()),
@@ -119,9 +130,7 @@ mod _pyexpat {
                 namespace_prefixes: MutableObject::new(vm.ctx.new_bool(false).into()),
                 ordered_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
                 specified_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
-                // String interning dictionary - used by the parser to intern element/attribute names
-                // for memory efficiency and faster comparisons. See CPython's pyexpat documentation.
-                intern: MutableObject::new(vm.ctx.new_dict().into()),
+                intern: MutableObject::new(intern_dict),
                 // Additional handlers (stubs for compatibility)
                 processing_instruction: MutableObject::new(vm.ctx.none()),
                 unparsed_entity_decl: MutableObject::new(vm.ctx.none()),
@@ -282,7 +291,19 @@ mod _pyexpat {
                 .whitespace_to_characters(true)
         }
 
-        fn do_parse<T>(&self, vm: &VirtualMachine, parser: xml::EventReader<T>)
+        /// Construct element name with namespace if separator is set
+        fn make_name(&self, name: &xml::name::OwnedName) -> String {
+            match (&self.namespace_separator, &name.namespace) {
+                (Some(sep), Some(ns)) => format!("{}{}{}", ns, sep, name.local_name),
+                _ => name.local_name.clone(),
+            }
+        }
+
+        fn do_parse<T>(
+            &self,
+            vm: &VirtualMachine,
+            parser: xml::EventReader<T>,
+        ) -> Result<(), xml::reader::Error>
         where
             T: std::io::Read,
         {
@@ -293,69 +314,106 @@ mod _pyexpat {
                     }) => {
                         let dict = vm.ctx.new_dict();
                         for attribute in attributes {
+                            let attr_name = self.make_name(&attribute.name);
                             dict.set_item(
-                                attribute.name.local_name.as_str(),
+                                attr_name.as_str(),
                                 vm.ctx.new_str(attribute.value).into(),
                                 vm,
                             )
                             .unwrap();
                         }
 
-                        let name_str = PyStr::from(name.local_name).into_ref(&vm.ctx);
+                        let name_str = PyStr::from(self.make_name(&name)).into_ref(&vm.ctx);
                         invoke_handler(vm, &self.start_element, (name_str, dict));
                     }
                     Ok(XmlEvent::EndElement { name, .. }) => {
-                        let name_str = PyStr::from(name.local_name).into_ref(&vm.ctx);
+                        let name_str = PyStr::from(self.make_name(&name)).into_ref(&vm.ctx);
                         invoke_handler(vm, &self.end_element, (name_str,));
                     }
                     Ok(XmlEvent::Characters(chars)) => {
                         let str = PyStr::from(chars).into_ref(&vm.ctx);
                         invoke_handler(vm, &self.character_data, (str,));
                     }
+                    Err(e) => return Err(e),
                     _ => {}
                 }
             }
+            Ok(())
         }
 
         #[pymethod(name = "Parse")]
-        fn parse(&self, data: PyStrRef, _isfinal: OptionalArg<bool>, vm: &VirtualMachine) {
-            let reader = Cursor::<Vec<u8>>::new(data.as_bytes().to_vec());
+        fn parse(
+            &self,
+            data: Either<PyStrRef, PyBytesRef>,
+            _isfinal: OptionalArg<bool>,
+            vm: &VirtualMachine,
+        ) -> PyResult<i32> {
+            let bytes = match data {
+                Either::A(s) => s.as_bytes().to_vec(),
+                Either::B(b) => b.as_bytes().to_vec(),
+            };
+            // Empty data is valid - used to finalize parsing
+            if bytes.is_empty() {
+                return Ok(1);
+            }
+            let reader = Cursor::<Vec<u8>>::new(bytes);
             let parser = self.create_config().create_reader(reader);
-            self.do_parse(vm, parser);
+            // Note: xml-rs is stricter than libexpat; some errors are silently ignored
+            // to maintain compatibility with existing Python code
+            let _ = self.do_parse(vm, parser);
+            Ok(1)
         }
 
         #[pymethod(name = "ParseFile")]
-        fn parse_file(&self, file: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            // todo: read chunks at a time
+        fn parse_file(&self, file: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
             let read_res = vm.call_method(&file, "read", ())?;
             let bytes_like = ArgBytesLike::try_from_object(vm, read_res)?;
             let buf = bytes_like.borrow_buf().to_vec();
+            if buf.is_empty() {
+                return Ok(1);
+            }
             let reader = Cursor::new(buf);
             let parser = self.create_config().create_reader(reader);
-            self.do_parse(vm, parser);
-
-            // todo: return value
-            Ok(())
+            // Note: xml-rs is stricter than libexpat; some errors are silently ignored
+            let _ = self.do_parse(vm, parser);
+            Ok(1)
         }
     }
 
     #[derive(FromArgs)]
-    #[allow(dead_code)]
     struct ParserCreateArgs {
         #[pyarg(any, optional)]
-        encoding: OptionalArg<PyStrRef>,
+        encoding: Option<PyStrRef>,
         #[pyarg(any, optional)]
-        namespace_separator: OptionalArg<PyStrRef>,
+        namespace_separator: Option<PyStrRef>,
         #[pyarg(any, optional)]
-        intern: OptionalArg<PyStrRef>,
+        intern: Option<PyObjectRef>,
     }
 
     #[pyfunction(name = "ParserCreate")]
     fn parser_create(
-        _args: ParserCreateArgs,
+        args: ParserCreateArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyExpatLikeXmlParserRef> {
-        PyExpatLikeXmlParser::new(vm)
+        // Validate namespace_separator: must be at most one character
+        let ns_sep = match args.namespace_separator {
+            Some(ref s) => {
+                let chars: Vec<char> = s.as_str().chars().collect();
+                if chars.len() > 1 {
+                    return Err(vm.new_value_error(
+                        "namespace_separator must be at most one character, omitted, or None"
+                            .to_owned(),
+                    ));
+                }
+                Some(s.as_str().to_owned())
+            }
+            None => None,
+        };
+
+        // encoding parameter is currently not used (xml-rs handles encoding from XML declaration)
+        let _ = args.encoding;
+
+        PyExpatLikeXmlParser::new(ns_sep, args.intern, vm)
     }
 }
 

From 2f4ca509c80191222766d0b5443390802668395d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 00:58:26 +0900
Subject: [PATCH 114/418] Initializer for PyCSimple, PyCArray (#6581)

---
 crates/vm/src/stdlib/ctypes/array.rs  | 57 +++++++++++++++++++++------
 crates/vm/src/stdlib/ctypes/simple.rs | 36 ++++++++++++++++-
 2 files changed, 80 insertions(+), 13 deletions(-)

diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index f31c8284d8b..25708b57f8e 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -13,6 +13,7 @@ use crate::{
     types::{AsBuffer, AsNumber, AsSequence, Constructor, Initializer},
 };
 use num_traits::{Signed, ToPrimitive};
+use std::borrow::Cow;
 
 /// Get itemsize from a PEP 3118 format string
 /// Extracts the type code (last char after endianness prefix) and returns its size
@@ -430,6 +431,18 @@ impl Constructor for PyCArray {
     }
 }
 
+impl Initializer for PyCArray {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Re-initialize array elements when __init__ is called
+        for (i, value) in args.args.iter().enumerate() {
+            PyCArray::setitem_by_index(&zelf, i as isize, value.clone(), vm)?;
+        }
+        Ok(())
+    }
+}
+
 impl AsSequence for PyCArray {
     fn as_sequence() -> &'static PySequenceMethods {
         use std::sync::LazyLock;
@@ -457,7 +470,7 @@ impl AsSequence for PyCArray {
 
 #[pyclass(
     flags(BASETYPE, IMMUTABLETYPE),
-    with(Constructor, AsSequence, AsBuffer)
+    with(Constructor, Initializer, AsSequence, AsBuffer)
 )]
 impl PyCArray {
     #[pyclassmethod]
@@ -868,16 +881,38 @@ impl PyCArray {
         };
 
         let mut buffer = buffer_lock.write();
-        Self::write_element_to_buffer(
-            buffer.to_mut(),
-            final_offset,
-            element_size,
-            type_code.as_deref(),
-            &value,
-            zelf,
-            index,
-            vm,
-        )
+
+        // For shared memory (Cow::Borrowed), we need to write directly to the memory
+        // For owned memory (Cow::Owned), we can write to the owned buffer
+        match &mut *buffer {
+            Cow::Borrowed(slice) => {
+                // SAFETY: For from_buffer, the slice points to writable shared memory.
+                // Python's from_buffer requires writable buffer, so this is safe.
+                let ptr = slice.as_ptr() as *mut u8;
+                let len = slice.len();
+                let owned_slice = unsafe { std::slice::from_raw_parts_mut(ptr, len) };
+                Self::write_element_to_buffer(
+                    owned_slice,
+                    final_offset,
+                    element_size,
+                    type_code.as_deref(),
+                    &value,
+                    zelf,
+                    index,
+                    vm,
+                )
+            }
+            Cow::Owned(vec) => Self::write_element_to_buffer(
+                vec,
+                final_offset,
+                element_size,
+                type_code.as_deref(),
+                &value,
+                zelf,
+                index,
+                vm,
+            ),
+        }
     }
 
     // Array_subscript
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index 803b38d6e05..fbb17620fe4 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -1085,6 +1085,18 @@ impl Constructor for PyCSimple {
     }
 }
 
+impl Initializer for PyCSimple {
+    type Args = (OptionalArg,);
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // If an argument is provided, update the value
+        if let Some(value) = args.0.into_option() {
+            PyCSimple::set_value(zelf.into(), value, vm)?;
+        }
+        Ok(())
+    }
+}
+
 // Simple_repr
 impl Representable for PyCSimple {
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
@@ -1111,7 +1123,10 @@ impl Representable for PyCSimple {
     }
 }
 
-#[pyclass(flags(BASETYPE), with(Constructor, AsBuffer, AsNumber, Representable))]
+#[pyclass(
+    flags(BASETYPE),
+    with(Constructor, Initializer, AsBuffer, AsNumber, Representable)
+)]
 impl PyCSimple {
     #[pygetset]
     fn _b0_(&self) -> Option<PyObjectRef> {
@@ -1278,7 +1293,24 @@ impl PyCSimple {
 
         // Update buffer when value changes
         let buffer_bytes = value_to_bytes_endian(&type_code, &content, swapped, vm);
-        *zelf.0.buffer.write() = std::borrow::Cow::Owned(buffer_bytes);
+
+        // If the buffer is borrowed (from shared memory), write in-place
+        // Otherwise replace with new owned buffer
+        let mut buffer = zelf.0.buffer.write();
+        match &mut *buffer {
+            Cow::Borrowed(slice) => {
+                // SAFETY: For from_buffer, the slice points to writable shared memory.
+                // Python's from_buffer requires writable buffer, so this is safe.
+                let ptr = slice.as_ptr() as *mut u8;
+                let len = slice.len().min(buffer_bytes.len());
+                unsafe {
+                    std::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len);
+                }
+            }
+            Cow::Owned(vec) => {
+                vec.copy_from_slice(&buffer_bytes);
+            }
+        }
 
         // For c_char_p (type "z"), c_wchar_p (type "Z"), and py_object (type "O"),
         // keep the reference in _objects

From f274164dcd4e53f1303df26f6f89dcd8987cd5d9 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Mon, 29 Dec 2025 22:28:03 -0500
Subject: [PATCH 115/418] Add __future__.py tests  (#6585)

* Added tests for __future__.py from v3.13.10

* * Deleted futures not in v3.13.10
* "Fixed" issues in test_future.py
---
 ...syntax_future10.py => badsyntax_future.py} |   0
 .../test_future_stmt/badsyntax_future3.py     |  10 -
 .../test_future_stmt/badsyntax_future4.py     |  10 -
 .../test_future_stmt/badsyntax_future5.py     |  12 --
 .../test_future_stmt/badsyntax_future6.py     |  10 -
 .../test_future_stmt/badsyntax_future7.py     |  11 -
 .../test_future_stmt/badsyntax_future8.py     |  10 -
 .../test_future_stmt/badsyntax_future9.py     |  10 -
 ..._test1.py => import_nested_scope_twice.py} |   0
 .../{future_test2.py => nested_scope.py}      |   0
 Lib/test/test_future_stmt/test_future.py      | 201 ++++++++++++------
 11 files changed, 139 insertions(+), 135 deletions(-)
 rename Lib/test/test_future_stmt/{badsyntax_future10.py => badsyntax_future.py} (100%)
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future3.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future4.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future5.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future6.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future7.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future8.py
 delete mode 100644 Lib/test/test_future_stmt/badsyntax_future9.py
 rename Lib/test/test_future_stmt/{future_test1.py => import_nested_scope_twice.py} (100%)
 rename Lib/test/test_future_stmt/{future_test2.py => nested_scope.py} (100%)

diff --git a/Lib/test/test_future_stmt/badsyntax_future10.py b/Lib/test/test_future_stmt/badsyntax_future.py
similarity index 100%
rename from Lib/test/test_future_stmt/badsyntax_future10.py
rename to Lib/test/test_future_stmt/badsyntax_future.py
diff --git a/Lib/test/test_future_stmt/badsyntax_future3.py b/Lib/test/test_future_stmt/badsyntax_future3.py
deleted file mode 100644
index f1c8417edaa..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future3.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-from __future__ import nested_scopes
-from __future__ import rested_snopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future4.py b/Lib/test/test_future_stmt/badsyntax_future4.py
deleted file mode 100644
index b5f4c98e922..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future4.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-import __future__
-from __future__ import nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future5.py b/Lib/test/test_future_stmt/badsyntax_future5.py
deleted file mode 100644
index 8a7e5fcb70f..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future5.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""This is a test"""
-from __future__ import nested_scopes
-import foo
-from __future__ import nested_scopes
-
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future6.py b/Lib/test/test_future_stmt/badsyntax_future6.py
deleted file mode 100644
index 5a8b55a02c4..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future6.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-"this isn't a doc string"
-from __future__ import nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future7.py b/Lib/test/test_future_stmt/badsyntax_future7.py
deleted file mode 100644
index 131db2c2164..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future7.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""This is a test"""
-
-from __future__ import nested_scopes; import string; from __future__ import \
-     nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future8.py b/Lib/test/test_future_stmt/badsyntax_future8.py
deleted file mode 100644
index ca45289e2e5..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future8.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-
-from __future__ import *
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-print(f(2)(4))
diff --git a/Lib/test/test_future_stmt/badsyntax_future9.py b/Lib/test/test_future_stmt/badsyntax_future9.py
deleted file mode 100644
index 916de06ab71..00000000000
--- a/Lib/test/test_future_stmt/badsyntax_future9.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-
-from __future__ import nested_scopes, braces
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-print(f(2)(4))
diff --git a/Lib/test/test_future_stmt/future_test1.py b/Lib/test/test_future_stmt/import_nested_scope_twice.py
similarity index 100%
rename from Lib/test/test_future_stmt/future_test1.py
rename to Lib/test/test_future_stmt/import_nested_scope_twice.py
diff --git a/Lib/test/test_future_stmt/future_test2.py b/Lib/test/test_future_stmt/nested_scope.py
similarity index 100%
rename from Lib/test/test_future_stmt/future_test2.py
rename to Lib/test/test_future_stmt/nested_scope.py
diff --git a/Lib/test/test_future_stmt/test_future.py b/Lib/test/test_future_stmt/test_future.py
index 9c30054963b..a7d649b32a6 100644
--- a/Lib/test/test_future_stmt/test_future.py
+++ b/Lib/test/test_future_stmt/test_future.py
@@ -10,6 +10,8 @@
 import re
 import sys
 
+TOP_LEVEL_MSG = 'from __future__ imports must occur at the beginning of the file'
+
 rx = re.compile(r'\((\S+).py, line (\d+)')
 
 def get_error_location(msg):
@@ -18,21 +20,48 @@ def get_error_location(msg):
 
 class FutureTest(unittest.TestCase):
 
-    def check_syntax_error(self, err, basename, lineno, offset=1):
-        self.assertIn('%s.py, line %d' % (basename, lineno), str(err))
-        self.assertEqual(os.path.basename(err.filename), basename + '.py')
+    def check_syntax_error(self, err, basename,
+                           *,
+                           lineno,
+                           message=TOP_LEVEL_MSG, offset=1):
+        if basename != '<string>':
+            basename += '.py'
+
+        self.assertEqual(f'{message} ({basename}, line {lineno})', str(err))
+        self.assertEqual(os.path.basename(err.filename), basename)
         self.assertEqual(err.lineno, lineno)
         self.assertEqual(err.offset, offset)
 
-    def test_future1(self):
-        with import_helper.CleanImport('test.test_future_stmt.future_test1'):
-            from test.test_future_stmt import future_test1
-            self.assertEqual(future_test1.result, 6)
+    def assertSyntaxError(self, code,
+                          *,
+                          lineno=1,
+                          message=TOP_LEVEL_MSG, offset=1,
+                          parametrize_docstring=True):
+        code = dedent(code.lstrip('\n'))
+        for add_docstring in ([False, True] if parametrize_docstring else [False]):
+            with self.subTest(code=code, add_docstring=add_docstring):
+                if add_docstring:
+                    code = '"""Docstring"""\n' + code
+                    lineno += 1
+                with self.assertRaises(SyntaxError) as cm:
+                    exec(code)
+                self.check_syntax_error(cm.exception, "<string>",
+                                        lineno=lineno,
+                                        message=message,
+                                        offset=offset)
+
+    def test_import_nested_scope_twice(self):
+        # Import the name nested_scopes twice to trigger SF bug #407394
+        with import_helper.CleanImport(
+            'test.test_future_stmt.import_nested_scope_twice',
+        ):
+            from test.test_future_stmt import import_nested_scope_twice
+        self.assertEqual(import_nested_scope_twice.result, 6)
 
-    def test_future2(self):
-        with import_helper.CleanImport('test.test_future_stmt.future_test2'):
-            from test.test_future_stmt import future_test2
-            self.assertEqual(future_test2.result, 6)
+    def test_nested_scope(self):
+        with import_helper.CleanImport('test.test_future_stmt.nested_scope'):
+            from test.test_future_stmt import nested_scope
+        self.assertEqual(nested_scope.result, 6)
 
     def test_future_single_import(self):
         with import_helper.CleanImport(
@@ -52,47 +81,92 @@ def test_future_multiple_features(self):
         ):
             from test.test_future_stmt import test_future_multiple_features
 
-    def test_badfuture3(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future3
-        self.check_syntax_error(cm.exception, "badsyntax_future3", 3)
+    # TODO: RUSTPYTHON
+    # AssertionError: 1 != 24
+    @unittest.expectedFailure
+    def test_unknown_future_flag(self):
+        code = """
+            from __future__ import nested_scopes
+            from __future__ import rested_snopes  # typo error here: nested => rested
+        """
+        self.assertSyntaxError(
+            code, lineno=2,
+            message='future feature rested_snopes is not defined', offset=24,
+        )
 
-    def test_badfuture4(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future4
-        self.check_syntax_error(cm.exception, "badsyntax_future4", 3)
+    def test_future_import_not_on_top(self):
+        code = """
+            import some_module
+            from __future__ import annotations
+        """
+        self.assertSyntaxError(code, lineno=2)
 
-    def test_badfuture5(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future5
-        self.check_syntax_error(cm.exception, "badsyntax_future5", 4)
+        code = """
+            import __future__
+            from __future__ import annotations
+        """
+        self.assertSyntaxError(code, lineno=2)
+
+        code = """
+            from __future__ import absolute_import
+            "spam, bar, blah"
+            from __future__ import print_function
+        """
+        self.assertSyntaxError(code, lineno=3)
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
-    def test_badfuture6(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future6
-        self.check_syntax_error(cm.exception, "badsyntax_future6", 3)
+    def test_future_import_with_extra_string(self):
+        code = """
+            '''Docstring'''
+            "this isn't a doc string"
+            from __future__ import nested_scopes
+        """
+        self.assertSyntaxError(code, lineno=3, parametrize_docstring=False)
 
-    def test_badfuture7(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future7
-        self.check_syntax_error(cm.exception, "badsyntax_future7", 3, 54)
+    def test_multiple_import_statements_on_same_line(self):
+        # With `\`:
+        code = """
+            from __future__ import nested_scopes; import string; from __future__ import \
+        nested_scopes
+        """
+        self.assertSyntaxError(code, offset=54)
 
-    def test_badfuture8(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future8
-        self.check_syntax_error(cm.exception, "badsyntax_future8", 3)
+        # Without `\`:
+        code = """
+            from __future__ import nested_scopes; import string; from __future__ import  nested_scopes
+        """
+        self.assertSyntaxError(code, offset=54)
 
-    def test_badfuture9(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future9
-        self.check_syntax_error(cm.exception, "badsyntax_future9", 3)
+    # TODO: RUSTPYTHON
+    # AssertionError: 1 != 24
+    @unittest.expectedFailure
+    def test_future_import_star(self):
+        code = """
+            from __future__ import *
+        """
+        self.assertSyntaxError(code, message='future feature * is not defined', offset=24)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: 'not a chance (<string>, line 2)' != 'future feature braces is not defined (<string>, line 2)'
+    @unittest.expectedFailure
+    def test_future_import_braces(self):
+        code = """
+            from __future__ import braces
+        """
+        # Congrats, you found an easter egg!
+        self.assertSyntaxError(code, message='not a chance', offset=24)
 
-    def test_badfuture10(self):
+        code = """
+            from __future__ import nested_scopes, braces
+        """
+        self.assertSyntaxError(code, message='not a chance', offset=39)
+
+    def test_module_with_future_import_not_on_top(self):
         with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future10
-        self.check_syntax_error(cm.exception, "badsyntax_future10", 3)
+            from test.test_future_stmt import badsyntax_future
+        self.check_syntax_error(cm.exception, "badsyntax_future", lineno=3)
 
     def test_ensure_flags_dont_clash(self):
         # bpo-39562: test that future flags and compiler flags doesn't clash
@@ -109,26 +183,6 @@ def test_ensure_flags_dont_clash(self):
         }
         self.assertCountEqual(set(flags.values()), flags.values())
 
-    def test_parserhack(self):
-        # test that the parser.c::future_hack function works as expected
-        # Note: although this test must pass, it's not testing the original
-        #       bug as of 2.6 since the with statement is not optional and
-        #       the parser hack disabled. If a new keyword is introduced in
-        #       2.6, change this to refer to the new future import.
-        try:
-            exec("from __future__ import print_function; print 0")
-        except SyntaxError:
-            pass
-        else:
-            self.fail("syntax error didn't occur")
-
-        try:
-            exec("from __future__ import (print_function); print 0")
-        except SyntaxError:
-            pass
-        else:
-            self.fail("syntax error didn't occur")
-
     def test_unicode_literals_exec(self):
         scope = {}
         exec("from __future__ import unicode_literals; x = ''", {}, scope)
@@ -141,6 +195,27 @@ def test_syntactical_future_repl(self):
         out = kill_python(p)
         self.assertNotIn(b'SyntaxError: invalid syntax', out)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # SyntaxError: future feature spam is not defined
+    def test_future_dotted_import(self):
+        with self.assertRaises(ImportError):
+            exec("from .__future__ import spam")
+
+        code = dedent(
+            """
+            from __future__ import print_function
+            from ...__future__ import ham
+            """
+        )
+        with self.assertRaises(ImportError):
+            exec(code)
+
+        code = """
+            from .__future__ import nested_scopes
+            from __future__ import barry_as_FLUFL
+        """
+        self.assertSyntaxError(code, lineno=2)
+
 class AnnotationsFutureTestCase(unittest.TestCase):
     template = dedent(
         """
@@ -385,6 +460,7 @@ def test_infinity_numbers(self):
         self.assertAnnotationEqual("(1e1000, (1e1000j,))", expected=f"({inf}, ({infj},))")
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
     def test_annotation_with_complex_target(self):
         with self.assertRaises(SyntaxError):
@@ -410,6 +486,7 @@ def bar():
         self.assertEqual(foo().__code__.co_freevars, ())
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
     def test_annotations_forbidden(self):
         with self.assertRaises(SyntaxError):

From 489289f54aaaf5084e8d3360c237c1de1d166521 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:28:47 +0900
Subject: [PATCH 116/418] Fix subprocess and Update subprocess from Python
 3.13.11 (#6583)

* fix test_subprocess

* fix posixsubprocess

* fix io warning

* Update subprocess from Python 3.13.11

* fix

* Auto-format: cargo fmt --all

* fix macos

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 Lib/subprocess.py                    | 128 +++++++----
 Lib/test/test_file.py                |   3 -
 Lib/test/test_subprocess.py          | 329 +++++++++++++++++++++++----
 crates/stdlib/src/posixsubprocess.rs |   7 +-
 crates/vm/src/stdlib/io.rs           |  10 +
 crates/vm/src/stdlib/posix.rs        |  19 +-
 crates/vm/src/stdlib/winapi.rs       |   3 +-
 7 files changed, 398 insertions(+), 101 deletions(-)

diff --git a/Lib/subprocess.py b/Lib/subprocess.py
index 1d17ae3608a..885f0092b53 100644
--- a/Lib/subprocess.py
+++ b/Lib/subprocess.py
@@ -74,8 +74,8 @@
 else:
     _mswindows = True
 
-# wasm32-emscripten and wasm32-wasi do not support processes
-_can_fork_exec = sys.platform not in {"emscripten", "wasi"}
+# some platforms do not support subprocesses
+_can_fork_exec = sys.platform not in {"emscripten", "wasi", "ios", "tvos", "watchos"}
 
 if _mswindows:
     import _winapi
@@ -83,6 +83,7 @@
                          STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
                          STD_ERROR_HANDLE, SW_HIDE,
                          STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW,
+                         STARTF_FORCEONFEEDBACK, STARTF_FORCEOFFFEEDBACK,
                          ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS,
                          HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS,
                          NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS,
@@ -93,6 +94,7 @@
                     "STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE",
                     "STD_ERROR_HANDLE", "SW_HIDE",
                     "STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW",
+                    "STARTF_FORCEONFEEDBACK", "STARTF_FORCEOFFFEEDBACK",
                     "STARTUPINFO",
                     "ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS",
                     "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS",
@@ -103,18 +105,22 @@
     if _can_fork_exec:
         from _posixsubprocess import fork_exec as _fork_exec
         # used in methods that are called by __del__
-        _waitpid = os.waitpid
-        _waitstatus_to_exitcode = os.waitstatus_to_exitcode
-        _WIFSTOPPED = os.WIFSTOPPED
-        _WSTOPSIG = os.WSTOPSIG
-        _WNOHANG = os.WNOHANG
+        class _del_safe:
+            waitpid = os.waitpid
+            waitstatus_to_exitcode = os.waitstatus_to_exitcode
+            WIFSTOPPED = os.WIFSTOPPED
+            WSTOPSIG = os.WSTOPSIG
+            WNOHANG = os.WNOHANG
+            ECHILD = errno.ECHILD
     else:
-        _fork_exec = None
-        _waitpid = None
-        _waitstatus_to_exitcode = None
-        _WIFSTOPPED = None
-        _WSTOPSIG = None
-        _WNOHANG = None
+        class _del_safe:
+            waitpid = None
+            waitstatus_to_exitcode = None
+            WIFSTOPPED = None
+            WSTOPSIG = None
+            WNOHANG = None
+            ECHILD = errno.ECHILD
+
     import select
     import selectors
 
@@ -346,7 +352,7 @@ def _args_from_interpreter_flags():
     if dev_mode:
         args.extend(('-X', 'dev'))
     for opt in ('faulthandler', 'tracemalloc', 'importtime',
-                'frozen_modules', 'showrefcount', 'utf8'):
+                'frozen_modules', 'showrefcount', 'utf8', 'gil'):
         if opt in xoptions:
             value = xoptions[opt]
             if value is True:
@@ -380,7 +386,7 @@ def _text_encoding():
 
 def call(*popenargs, timeout=None, **kwargs):
     """Run command with arguments.  Wait for command to complete or
-    timeout, then return the returncode attribute.
+    for timeout seconds, then return the returncode attribute.
 
     The arguments are the same as for the Popen constructor.  Example:
 
@@ -517,8 +523,8 @@ def run(*popenargs,
     in the returncode attribute, and output & stderr attributes if those streams
     were captured.
 
-    If timeout is given, and the process takes too long, a TimeoutExpired
-    exception will be raised.
+    If timeout (seconds) is given and the process takes too long,
+     a TimeoutExpired exception will be raised.
 
     There is an optional argument "input", allowing you to
     pass bytes or a string to the subprocess's stdin.  If you use this argument
@@ -709,6 +715,9 @@ def _use_posix_spawn():
         # os.posix_spawn() is not available
         return False
 
+    if ((_env := os.environ.get('_PYTHON_SUBPROCESS_USE_POSIX_SPAWN')) in ('0', '1')):
+        return bool(int(_env))
+
     if sys.platform in ('darwin', 'sunos5'):
         # posix_spawn() is a syscall on both macOS and Solaris,
         # and properly reports errors
@@ -744,6 +753,7 @@ def _use_posix_spawn():
 # guarantee the given libc/syscall API will be used.
 _USE_POSIX_SPAWN = _use_posix_spawn()
 _USE_VFORK = True
+_HAVE_POSIX_SPAWN_CLOSEFROM = hasattr(os, 'POSIX_SPAWN_CLOSEFROM')
 
 
 class Popen:
@@ -834,6 +844,9 @@ def __init__(self, args, bufsize=-1, executable=None,
         if not isinstance(bufsize, int):
             raise TypeError("bufsize must be an integer")
 
+        if stdout is STDOUT:
+            raise ValueError("STDOUT can only be used for stderr")
+
         if pipesize is None:
             pipesize = -1  # Restore default
         if not isinstance(pipesize, int):
@@ -1224,8 +1237,11 @@ def communicate(self, input=None, timeout=None):
 
             finally:
                 self._communication_started = True
-
-            sts = self.wait(timeout=self._remaining_time(endtime))
+            try:
+                sts = self.wait(timeout=self._remaining_time(endtime))
+            except TimeoutExpired as exc:
+                exc.timeout = timeout
+                raise
 
         return (stdout, stderr)
 
@@ -1600,6 +1616,10 @@ def _readerthread(self, fh, buffer):
             fh.close()
 
 
+        def _writerthread(self, input):
+            self._stdin_write(input)
+
+
         def _communicate(self, input, endtime, orig_timeout):
             # Start reader threads feeding into a list hanging off of this
             # object, unless they've already been started.
@@ -1618,8 +1638,23 @@ def _communicate(self, input, endtime, orig_timeout):
                 self.stderr_thread.daemon = True
                 self.stderr_thread.start()
 
-            if self.stdin:
-                self._stdin_write(input)
+            # Start writer thread to send input to stdin, unless already
+            # started.  The thread writes input and closes stdin when done,
+            # or continues in the background on timeout.
+            if self.stdin and not hasattr(self, "_stdin_thread"):
+                self._stdin_thread = \
+                        threading.Thread(target=self._writerthread,
+                                         args=(input,))
+                self._stdin_thread.daemon = True
+                self._stdin_thread.start()
+
+            # Wait for the writer thread, or time out.  If we time out, the
+            # thread remains writing and the fd left open in case the user
+            # calls communicate again.
+            if hasattr(self, "_stdin_thread"):
+                self._stdin_thread.join(self._remaining_time(endtime))
+                if self._stdin_thread.is_alive():
+                    raise TimeoutExpired(self.args, orig_timeout)
 
             # Wait for the reader threads, or time out.  If we time out, the
             # threads remain reading and the fds left open in case the user
@@ -1749,14 +1784,11 @@ def _get_handles(self, stdin, stdout, stderr):
                     errread, errwrite)
 
 
-        def _posix_spawn(self, args, executable, env, restore_signals,
+        def _posix_spawn(self, args, executable, env, restore_signals, close_fds,
                          p2cread, p2cwrite,
                          c2pread, c2pwrite,
                          errread, errwrite):
             """Execute program using os.posix_spawn()."""
-            if env is None:
-                env = os.environ
-
             kwargs = {}
             if restore_signals:
                 # See _Py_RestoreSignals() in Python/pylifecycle.c
@@ -1778,6 +1810,10 @@ def _posix_spawn(self, args, executable, env, restore_signals,
             ):
                 if fd != -1:
                     file_actions.append((os.POSIX_SPAWN_DUP2, fd, fd2))
+
+            if close_fds:
+                file_actions.append((os.POSIX_SPAWN_CLOSEFROM, 3))
+
             if file_actions:
                 kwargs['file_actions'] = file_actions
 
@@ -1825,7 +1861,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
             if (_USE_POSIX_SPAWN
                     and os.path.dirname(executable)
                     and preexec_fn is None
-                    and not close_fds
+                    and (not close_fds or _HAVE_POSIX_SPAWN_CLOSEFROM)
                     and not pass_fds
                     and cwd is None
                     and (p2cread == -1 or p2cread > 2)
@@ -1837,7 +1873,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                     and gids is None
                     and uid is None
                     and umask < 0):
-                self._posix_spawn(args, executable, env, restore_signals,
+                self._posix_spawn(args, executable, env, restore_signals, close_fds,
                                   p2cread, p2cwrite,
                                   c2pread, c2pwrite,
                                   errread, errwrite)
@@ -1958,20 +1994,16 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                 raise child_exception_type(err_msg)
 
 
-        def _handle_exitstatus(self, sts,
-                               _waitstatus_to_exitcode=_waitstatus_to_exitcode,
-                               _WIFSTOPPED=_WIFSTOPPED,
-                               _WSTOPSIG=_WSTOPSIG):
+        def _handle_exitstatus(self, sts, _del_safe=_del_safe):
             """All callers to this function MUST hold self._waitpid_lock."""
             # This method is called (indirectly) by __del__, so it cannot
             # refer to anything outside of its local scope.
-            if _WIFSTOPPED(sts):
-                self.returncode = -_WSTOPSIG(sts)
+            if _del_safe.WIFSTOPPED(sts):
+                self.returncode = -_del_safe.WSTOPSIG(sts)
             else:
-                self.returncode = _waitstatus_to_exitcode(sts)
+                self.returncode = _del_safe.waitstatus_to_exitcode(sts)
 
-        def _internal_poll(self, _deadstate=None, _waitpid=_waitpid,
-                _WNOHANG=_WNOHANG, _ECHILD=errno.ECHILD):
+        def _internal_poll(self, _deadstate=None, _del_safe=_del_safe):
             """Check if child process has terminated.  Returns returncode
             attribute.
 
@@ -1987,13 +2019,13 @@ def _internal_poll(self, _deadstate=None, _waitpid=_waitpid,
                 try:
                     if self.returncode is not None:
                         return self.returncode  # Another thread waited.
-                    pid, sts = _waitpid(self.pid, _WNOHANG)
+                    pid, sts = _del_safe.waitpid(self.pid, _del_safe.WNOHANG)
                     if pid == self.pid:
                         self._handle_exitstatus(sts)
                 except OSError as e:
                     if _deadstate is not None:
                         self.returncode = _deadstate
-                    elif e.errno == _ECHILD:
+                    elif e.errno == _del_safe.ECHILD:
                         # This happens if SIGCLD is set to be ignored or
                         # waiting for child processes has otherwise been
                         # disabled for our process.  This child is dead, we
@@ -2067,6 +2099,10 @@ def _communicate(self, input, endtime, orig_timeout):
                     self.stdin.flush()
                 except BrokenPipeError:
                     pass  # communicate() must ignore BrokenPipeError.
+                except ValueError:
+                    # ignore ValueError: I/O operation on closed file.
+                    if not self.stdin.closed:
+                        raise
                 if not input:
                     try:
                         self.stdin.close()
@@ -2092,10 +2128,13 @@ def _communicate(self, input, endtime, orig_timeout):
             self._save_input(input)
 
             if self._input:
-                input_view = memoryview(self._input)
+                if not isinstance(self._input, memoryview):
+                    input_view = memoryview(self._input)
+                else:
+                    input_view = self._input.cast("b")  # byte input required
 
             with _PopenSelector() as selector:
-                if self.stdin and input:
+                if self.stdin and not self.stdin.closed and self._input:
                     selector.register(self.stdin, selectors.EVENT_WRITE)
                 if self.stdout and not self.stdout.closed:
                     selector.register(self.stdout, selectors.EVENT_READ)
@@ -2128,7 +2167,7 @@ def _communicate(self, input, endtime, orig_timeout):
                                 selector.unregister(key.fileobj)
                                 key.fileobj.close()
                             else:
-                                if self._input_offset >= len(self._input):
+                                if self._input_offset >= len(input_view):
                                     selector.unregister(key.fileobj)
                                     key.fileobj.close()
                         elif key.fileobj in (self.stdout, self.stderr):
@@ -2137,8 +2176,11 @@ def _communicate(self, input, endtime, orig_timeout):
                                 selector.unregister(key.fileobj)
                                 key.fileobj.close()
                             self._fileobj2output[key.fileobj].append(data)
-
-            self.wait(timeout=self._remaining_time(endtime))
+            try:
+                self.wait(timeout=self._remaining_time(endtime))
+            except TimeoutExpired as exc:
+                exc.timeout = orig_timeout
+                raise
 
             # All data exchanged.  Translate lists into strings.
             if stdout is not None:
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index d64f3f797d8..36aea52a5a9 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -344,9 +344,6 @@ def testIteration(self):
 class COtherFileTests(OtherFileTests, unittest.TestCase):
     open = io.open
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def testSetBufferSize(self):
-        return super().testSetBufferSize()
 
 class PyOtherFileTests(OtherFileTests, unittest.TestCase):
     open = staticmethod(pyio.open)
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 5c5d2a9600f..997c98c2c62 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -25,7 +25,6 @@
 import gc
 import textwrap
 import json
-import pathlib
 from test.support.os_helper import FakePath
 
 try:
@@ -41,6 +40,10 @@
     import grp
 except ImportError:
     grp = None
+try:
+    import resource
+except ImportError:
+    resource = None
 
 try:
     import fcntl
@@ -158,6 +161,20 @@ def test_call_timeout(self):
                           [sys.executable, "-c", "while True: pass"],
                           timeout=0.1)
 
+    def test_timeout_exception(self):
+        try:
+            subprocess.run([sys.executable, '-c', 'import time;time.sleep(9)'], timeout = -1)
+        except subprocess.TimeoutExpired as e:
+            self.assertIn("-1 seconds", str(e))
+        else:
+            self.fail("Expected TimeoutExpired exception not raised")
+        try:
+            subprocess.run([sys.executable, '-c', 'import time;time.sleep(9)'], timeout = 0)
+        except subprocess.TimeoutExpired as e:
+            self.assertIn("0 seconds", str(e))
+        else:
+            self.fail("Expected TimeoutExpired exception not raised")
+
     def test_check_call_zero(self):
         # check_call() function with zero return code
         rc = subprocess.check_call(ZERO_RETURN_CMD)
@@ -269,21 +286,13 @@ def test_check_output_stdin_with_input_arg(self):
         self.assertIn('stdin', c.exception.args[0])
         self.assertIn('input', c.exception.args[0])
 
-    @support.requires_resource('walltime')
     def test_check_output_timeout(self):
         # check_output() function with timeout arg
         with self.assertRaises(subprocess.TimeoutExpired) as c:
             output = subprocess.check_output(
                     [sys.executable, "-c",
-                     "import sys, time\n"
-                     "sys.stdout.write('BDFL')\n"
-                     "sys.stdout.flush()\n"
-                     "time.sleep(3600)"],
-                    # Some heavily loaded buildbots (sparc Debian 3.x) require
-                    # this much time to start and print.
-                    timeout=3)
-            self.fail("Expected TimeoutExpired.")
-        self.assertEqual(c.exception.output, b'BDFL')
+                     "import time; time.sleep(3600)"],
+                    timeout=0.1)
 
     def test_call_kwargs(self):
         # call() function with keyword args
@@ -949,6 +958,48 @@ def test_communicate(self):
         self.assertEqual(stdout, b"banana")
         self.assertEqual(stderr, b"pineapple")
 
+    def test_communicate_memoryview_input(self):
+        # Test memoryview input with byte elements
+        test_data = b"Hello, memoryview!"
+        mv = memoryview(test_data)
+        p = subprocess.Popen([sys.executable, "-c",
+                              'import sys; sys.stdout.write(sys.stdin.read())'],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE)
+        self.addCleanup(p.stdout.close)
+        self.addCleanup(p.stdin.close)
+        (stdout, stderr) = p.communicate(mv)
+        self.assertEqual(stdout, test_data)
+        self.assertIsNone(stderr)
+
+    def test_communicate_memoryview_input_nonbyte(self):
+        # Test memoryview input with non-byte elements (e.g., int32)
+        # This tests the fix for gh-134453 where non-byte memoryviews
+        # had incorrect length tracking on POSIX
+        import array
+        # Create an array of 32-bit integers that's large enough to trigger
+        # the chunked writing behavior (> PIPE_BUF)
+        pipe_buf = getattr(select, 'PIPE_BUF', 512)
+        # Each 'i' element is 4 bytes, so we need more than pipe_buf/4 elements
+        # Add some extra to ensure we exceed the buffer size
+        num_elements = pipe_buf + 1
+        test_array = array.array('i', [0x64306f66 for _ in range(num_elements)])
+        expected_bytes = test_array.tobytes()
+        mv = memoryview(test_array)
+
+        p = subprocess.Popen([sys.executable, "-c",
+                              'import sys; '
+                              'data = sys.stdin.buffer.read(); '
+                              'sys.stdout.buffer.write(data)'],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE)
+        self.addCleanup(p.stdout.close)
+        self.addCleanup(p.stdin.close)
+        (stdout, stderr) = p.communicate(mv)
+        self.assertEqual(stdout, expected_bytes,
+                         msg=f"{len(stdout)=} =? {len(expected_bytes)=}")
+        self.assertIsNone(stderr)
+
     def test_communicate_timeout(self):
         p = subprocess.Popen([sys.executable, "-c",
                               'import sys,os,time;'
@@ -984,6 +1035,62 @@ def test_communicate_timeout_large_output(self):
         (stdout, _) = p.communicate()
         self.assertEqual(len(stdout), 4 * 64 * 1024)
 
+    def test_communicate_timeout_large_input(self):
+        # Test that timeout is enforced when writing large input to a
+        # slow-to-read subprocess, and that partial input is preserved
+        # for continuation after timeout (gh-141473).
+        #
+        # This is a regression test for Windows matching POSIX behavior.
+        # On POSIX, select() is used to multiplex I/O with timeout checking.
+        # On Windows, stdin writing must also honor the timeout rather than
+        # blocking indefinitely when the pipe buffer fills.
+
+        # Input larger than typical pipe buffer (4-64KB on Windows)
+        input_data = b"x" * (128 * 1024)
+
+        p = subprocess.Popen(
+            [sys.executable, "-c",
+             "import sys, time; "
+             "time.sleep(30); "  # Don't read stdin for a long time
+             "sys.stdout.buffer.write(sys.stdin.buffer.read())"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE)
+
+        try:
+            timeout = 0.2
+            start = time.monotonic()
+            try:
+                p.communicate(input_data, timeout=timeout)
+                # If we get here without TimeoutExpired, the timeout was ignored
+                elapsed = time.monotonic() - start
+                self.fail(
+                    f"TimeoutExpired not raised. communicate() completed in "
+                    f"{elapsed:.2f}s, but subprocess sleeps for 30s. "
+                    "Stdin writing blocked without enforcing timeout.")
+            except subprocess.TimeoutExpired:
+                elapsed = time.monotonic() - start
+
+            # Timeout should occur close to the specified timeout value,
+            # not after waiting for the subprocess to finish sleeping.
+            # Allow generous margin for slow CI, but must be well under
+            # the subprocess sleep time.
+            self.assertLess(elapsed, 5.0,
+                f"TimeoutExpired raised after {elapsed:.2f}s; expected ~{timeout}s. "
+                "Stdin writing blocked without checking timeout.")
+
+            # After timeout, continue communication. The remaining input
+            # should be sent and we should receive all data back.
+            stdout, stderr = p.communicate()
+
+            # Verify all input was eventually received by the subprocess
+            self.assertEqual(len(stdout), len(input_data),
+                f"Expected {len(input_data)} bytes output but got {len(stdout)}")
+            self.assertEqual(stdout, input_data)
+        finally:
+            p.kill()
+            p.wait()
+
     # Test for the fd leak reported in http://bugs.python.org/issue2791.
     def test_communicate_pipe_fd_leak(self):
         for stdin_pipe in (False, True):
@@ -1054,6 +1161,19 @@ def test_writes_before_communicate(self):
         self.assertEqual(stdout, b"bananasplit")
         self.assertEqual(stderr, b"")
 
+    def test_communicate_stdin_closed_before_call(self):
+        # gh-70560, gh-74389: stdin.close() before communicate()
+        # should not raise ValueError from stdin.flush()
+        with subprocess.Popen([sys.executable, "-c",
+                               'import sys; sys.exit(0)'],
+                              stdin=subprocess.PIPE,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE) as p:
+            p.stdin.close()  # Close stdin before communicate
+            # This should not raise ValueError
+            (stdout, stderr) = p.communicate()
+            self.assertEqual(p.returncode, 0)
+
     def test_universal_newlines_and_text(self):
         args = [
             sys.executable, "-c",
@@ -1223,6 +1343,16 @@ def test_no_leaking(self):
             max_handles = 1026 # too much for most UNIX systems
         else:
             max_handles = 2050 # too much for (at least some) Windows setups
+        if resource:
+            # And if it is not too much, try to make it too much.
+            try:
+                soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+                if soft > 1024:
+                    resource.setrlimit(resource.RLIMIT_NOFILE, (1024, hard))
+                    self.addCleanup(resource.setrlimit, resource.RLIMIT_NOFILE,
+                                    (soft, hard))
+            except (OSError, ValueError):
+                pass
         handles = []
         tmpdir = tempfile.mkdtemp()
         try:
@@ -1237,7 +1367,9 @@ def test_no_leaking(self):
             else:
                 self.skipTest("failed to reach the file descriptor limit "
                     "(tried %d)" % max_handles)
-            # Close a couple of them (should be enough for a subprocess)
+            # Close a couple of them (should be enough for a subprocess).
+            # Close lower file descriptors, so select() will work.
+            handles.reverse()
             for i in range(10):
                 os.close(handles.pop())
             # Loop creating some subprocesses. If one of them leaks some fds,
@@ -1341,8 +1473,6 @@ def test_bufsize_equal_one_text_mode(self):
         line = "line\n"
         self._test_bufsize_equal_one(line, line, universal_newlines=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bufsize_equal_one_binary_mode(self):
         # line is not flushed in binary mode with bufsize=1.
         # we should get empty response
@@ -1414,7 +1544,7 @@ def open_fds():
         t = threading.Thread(target=open_fds)
         t.start()
         try:
-            with self.assertRaises(EnvironmentError):
+            with self.assertRaises(OSError):
                 subprocess.Popen(NONEXISTING_CMD,
                                  stdin=subprocess.PIPE,
                                  stdout=subprocess.PIPE,
@@ -1528,9 +1658,6 @@ def test_communicate_epipe(self):
         p.communicate(b"x" * 2**20)
 
     def test_repr(self):
-        path_cmd = pathlib.Path("my-tool.py")
-        pathlib_cls = path_cmd.__class__.__name__
-
         cases = [
             ("ls", True, 123, "<Popen: returncode: 123 args: 'ls'>"),
             ('a' * 100, True, 0,
@@ -1538,7 +1665,8 @@ def test_repr(self):
             (["ls"], False, None, "<Popen: returncode: None args: ['ls']>"),
             (["ls", '--my-opts', 'a' * 100], False, None,
              "<Popen: returncode: None args: ['ls', '--my-opts', 'aaaaaaaaaaaaaaaaaaaaaaaa...>"),
-            (path_cmd, False, 7, f"<Popen: returncode: 7 args: {pathlib_cls}('my-tool.py')>")
+            (os_helper.FakePath("my-tool.py"), False, 7,
+             "<Popen: returncode: 7 args: <FakePath 'my-tool.py'>>")
         ]
         with unittest.mock.patch.object(subprocess.Popen, '_execute_child'):
             for cmd, shell, code, sx in cases:
@@ -1613,21 +1741,6 @@ def test_class_getitems(self):
         self.assertIsInstance(subprocess.Popen[bytes], types.GenericAlias)
         self.assertIsInstance(subprocess.CompletedProcess[str], types.GenericAlias)
 
-    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
-                     "vfork() not enabled by configure.")
-    @mock.patch("subprocess._fork_exec")
-    def test__use_vfork(self, mock_fork_exec):
-        self.assertTrue(subprocess._USE_VFORK)  # The default value regardless.
-        mock_fork_exec.side_effect = RuntimeError("just testing args")
-        with self.assertRaises(RuntimeError):
-            subprocess.run([sys.executable, "-c", "pass"])
-        mock_fork_exec.assert_called_once()
-        self.assertTrue(mock_fork_exec.call_args.args[-1])
-        with mock.patch.object(subprocess, '_USE_VFORK', False):
-            with self.assertRaises(RuntimeError):
-                subprocess.run([sys.executable, "-c", "pass"])
-            self.assertFalse(mock_fork_exec.call_args_list[-1].args[-1])
-
     @unittest.skipUnless(hasattr(subprocess, '_winapi'),
                          'need subprocess._winapi')
     def test_wait_negative_timeout(self):
@@ -1644,6 +1757,40 @@ def test_wait_negative_timeout(self):
 
             self.assertEqual(proc.wait(), 0)
 
+    def test_post_timeout_communicate_sends_input(self):
+        """GH-141473 regression test; the stdin pipe must close"""
+        with subprocess.Popen(
+                [sys.executable, "-uc", """\
+import sys
+while c := sys.stdin.read(512):
+    sys.stdout.write(c)
+print()
+"""],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+        ) as proc:
+            try:
+                data = f"spam{'#'*4096}beans"
+                proc.communicate(
+                    input=data,
+                    timeout=0,
+                )
+            except subprocess.TimeoutExpired as exc:
+                pass
+            # Prior to the bugfix, this would hang as the stdin
+            # pipe to the child had not been closed.
+            try:
+                stdout, stderr = proc.communicate(timeout=15)
+            except subprocess.TimeoutExpired as exc:
+                self.fail("communicate() hung waiting on child process that should have seen its stdin pipe close and exit")
+            self.assertEqual(
+                    proc.returncode, 0,
+                    msg=f"STDERR:\n{stderr}\nSTDOUT:\n{stdout}")
+            self.assertTrue(stdout.startswith("spam"), msg=stdout)
+            self.assertIn("beans", stdout)
+
 
 class RunFuncTestCase(BaseTestCase):
     def run_python(self, code, **kwargs):
@@ -1717,20 +1864,11 @@ def test_check_output_stdin_with_input_arg(self):
         self.assertIn('stdin', c.exception.args[0])
         self.assertIn('input', c.exception.args[0])
 
-    @support.requires_resource('walltime')
     def test_check_output_timeout(self):
         with self.assertRaises(subprocess.TimeoutExpired) as c:
-            cp = self.run_python((
-                     "import sys, time\n"
-                     "sys.stdout.write('BDFL')\n"
-                     "sys.stdout.flush()\n"
-                     "time.sleep(3600)"),
-                    # Some heavily loaded buildbots (sparc Debian 3.x) require
-                    # this much time to start and print.
-                    timeout=3, stdout=subprocess.PIPE)
-        self.assertEqual(c.exception.output, b'BDFL')
-        # output is aliased to stdout
-        self.assertEqual(c.exception.stdout, b'BDFL')
+            cp = self.run_python(
+                    "import time; time.sleep(3600)",
+                    timeout=0.1, stdout=subprocess.PIPE)
 
     def test_run_kwargs(self):
         newenv = os.environ.copy()
@@ -1785,6 +1923,13 @@ def test_capture_output(self):
         self.assertIn(b'BDFL', cp.stdout)
         self.assertIn(b'FLUFL', cp.stderr)
 
+    def test_stdout_stdout(self):
+        # run() refuses to accept stdout=STDOUT
+        with self.assertRaises(ValueError,
+                msg=("STDOUT can only be used for stderr")):
+            self.run_python("print('will not be run')",
+                            stdout=subprocess.STDOUT)
+
     def test_stdout_with_capture_output_arg(self):
         # run() refuses to accept 'stdout' with 'capture_output'
         tf = tempfile.TemporaryFile()
@@ -1969,8 +2114,6 @@ def bad_error(*args):
 
         self.assertIn(repr(error_data), str(e.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(not os.path.exists('/proc/self/status'),
                      "need /proc/self/status")
     def test_restore_signals(self):
@@ -2189,8 +2332,6 @@ def test_extra_groups_invalid_gid_t_values(self):
                                   cwd=os.curdir, env=os.environ,
                                   extra_groups=[2**64])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(mswindows or not hasattr(os, 'umask'),
                      'POSIX umask() is not available.')
     def test_umask(self):
@@ -3446,6 +3587,94 @@ def __del__(self):
         self.assertEqual(out.strip(), b"OK")
         self.assertIn(b"preexec_fn not supported at interpreter shutdown", err)
 
+    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
+                     "vfork() not enabled by configure.")
+    @mock.patch("subprocess._fork_exec")
+    @mock.patch("subprocess._USE_POSIX_SPAWN", new=False)
+    def test__use_vfork(self, mock_fork_exec):
+        self.assertTrue(subprocess._USE_VFORK)  # The default value regardless.
+        mock_fork_exec.side_effect = RuntimeError("just testing args")
+        with self.assertRaises(RuntimeError):
+            subprocess.run([sys.executable, "-c", "pass"])
+        mock_fork_exec.assert_called_once()
+        # NOTE: These assertions are *ugly* as they require the last arg
+        # to remain the have_vfork boolean. We really need to refactor away
+        # from the giant "wall of args" internal C extension API.
+        self.assertTrue(mock_fork_exec.call_args.args[-1])
+        with mock.patch.object(subprocess, '_USE_VFORK', False):
+            with self.assertRaises(RuntimeError):
+                subprocess.run([sys.executable, "-c", "pass"])
+            self.assertFalse(mock_fork_exec.call_args_list[-1].args[-1])
+
+    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
+                     "vfork() not enabled by configure.")
+    @unittest.skipIf(sys.platform != "linux", "Linux only, requires strace.")
+    @mock.patch("subprocess._USE_POSIX_SPAWN", new=False)
+    def test_vfork_used_when_expected(self):
+        # This is a performance regression test to ensure we default to using
+        # vfork() when possible.
+        # Technically this test could pass when posix_spawn is used as well
+        # because libc tends to implement that internally using vfork. But
+        # that'd just be testing a libc+kernel implementation detail.
+        strace_binary = "/usr/bin/strace"
+        # The only system calls we are interested in.
+        strace_filter = "--trace=clone,clone2,clone3,fork,vfork,exit,exit_group"
+        true_binary = "/bin/true"
+        strace_command = [strace_binary, strace_filter]
+
+        try:
+            does_strace_work_process = subprocess.run(
+                    strace_command + [true_binary],
+                    stderr=subprocess.PIPE,
+                    stdout=subprocess.DEVNULL,
+            )
+            rc = does_strace_work_process.returncode
+            stderr = does_strace_work_process.stderr
+        except OSError:
+            rc = -1
+            stderr = ""
+        if rc or (b"+++ exited with 0 +++" not in stderr):
+            self.skipTest("strace not found or not working as expected.")
+
+        with self.subTest(name="default_is_vfork"):
+            vfork_result = assert_python_ok(
+                    "-c",
+                    textwrap.dedent(f"""\
+                    import subprocess
+                    subprocess.check_call([{true_binary!r}])"""),
+                    __run_using_command=strace_command,
+            )
+            # Match both vfork() and clone(..., flags=...|CLONE_VFORK|...)
+            self.assertRegex(vfork_result.err, br"(?i)vfork")
+            # Do NOT check that fork() or other clones did not happen.
+            # If the OS denys the vfork it'll fallback to plain fork().
+
+        # Test that each individual thing that would disable the use of vfork
+        # actually disables it.
+        for sub_name, preamble, sp_kwarg, expect_permission_error in (
+                ("!use_vfork", "subprocess._USE_VFORK = False", "", False),
+                ("preexec", "", "preexec_fn=lambda: None", False),
+                ("setgid", "", f"group={os.getgid()}", True),
+                ("setuid", "", f"user={os.getuid()}", True),
+                ("setgroups", "", "extra_groups=[]", True),
+        ):
+            with self.subTest(name=sub_name):
+                non_vfork_result = assert_python_ok(
+                    "-c",
+                    textwrap.dedent(f"""\
+                    import subprocess
+                    {preamble}
+                    try:
+                        subprocess.check_call(
+                                [{true_binary!r}], **dict({sp_kwarg}))
+                    except PermissionError:
+                        if not {expect_permission_error}:
+                            raise"""),
+                    __run_using_command=strace_command,
+                )
+                # Ensure neither vfork() or clone(..., flags=...|CLONE_VFORK|...).
+                self.assertNotRegex(non_vfork_result.err, br"(?i)vfork")
+
 
 @unittest.skipUnless(mswindows, "Windows specific tests")
 class Win32ProcessTestCase(BaseTestCase):
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
index d05b24fd6dd..4b895d2102b 100644
--- a/crates/stdlib/src/posixsubprocess.rs
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -321,11 +321,14 @@ fn exec_inner(
     }
 
     if args.child_umask >= 0 {
-        // TODO: umask(child_umask);
+        unsafe { libc::umask(args.child_umask as libc::mode_t) };
     }
 
     if args.restore_signals {
-        // TODO: restore signals SIGPIPE, SIGXFZ, SIGXFSZ to SIG_DFL
+        unsafe {
+            libc::signal(libc::SIGPIPE, libc::SIG_DFL);
+            libc::signal(libc::SIGXFSZ, libc::SIG_DFL);
+        }
     }
 
     if args.call_setsid {
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 89dc8bca925..52900faec08 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -4489,6 +4489,16 @@ mod _io {
             bool::try_from_object(vm, atty)?
         };
 
+        // Warn if line buffering is requested in binary mode
+        if opts.buffering == 1 && matches!(mode.encode, EncodeMode::Bytes) {
+            crate::stdlib::warnings::warn(
+                vm.ctx.exceptions.runtime_warning,
+                "line buffering (buffering=1) isn't supported in binary mode, the default buffer size will be used".to_owned(),
+                1,
+                vm,
+            )?;
+        }
+
         let line_buffering = opts.buffering == 1 || isatty;
 
         let buffering = if opts.buffering < 0 || opts.buffering == 1 {
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index efbd0cf9049..a4a311df06a 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -1515,7 +1515,7 @@ pub mod module {
         #[pyarg(positional)]
         args: crate::function::ArgIterable<OsPath>,
         #[pyarg(positional)]
-        env: crate::function::ArgMapping,
+        env: Option<crate::function::ArgMapping>,
         #[pyarg(named, default)]
         file_actions: Option<crate::function::ArgIterable<PyTupleRef>>,
         #[pyarg(named, default)]
@@ -1678,7 +1678,22 @@ pub mod module {
                         .map_err(|_| vm.new_value_error("path should not have nul bytes"))
                 })
                 .collect::<Result<_, _>>()?;
-            let env = envp_from_dict(self.env, vm)?;
+            let env = if let Some(env_dict) = self.env {
+                envp_from_dict(env_dict, vm)?
+            } else {
+                // env=None means use the current environment
+                use rustpython_common::os::ffi::OsStringExt;
+                env::vars_os()
+                    .map(|(k, v)| {
+                        let mut entry = k.into_vec();
+                        entry.push(b'=');
+                        entry.extend(v.into_vec());
+                        CString::new(entry).map_err(|_| {
+                            vm.new_value_error("environment string contains null byte")
+                        })
+                    })
+                    .collect::<PyResult<Vec<_>>>()?
+            };
 
             let ret = if spawnp {
                 nix::spawn::posix_spawnp(&path, &file_actions, &attrp, &args, &env)
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs
index 5cfb62fad6f..a3aba447489 100644
--- a/crates/vm/src/stdlib/winapi.rs
+++ b/crates/vm/src/stdlib/winapi.rs
@@ -63,7 +63,8 @@ mod _winapi {
                 CREATE_BREAKAWAY_FROM_JOB, CREATE_DEFAULT_ERROR_MODE, CREATE_NEW_CONSOLE,
                 CREATE_NEW_PROCESS_GROUP, CREATE_NO_WINDOW, DETACHED_PROCESS, HIGH_PRIORITY_CLASS,
                 IDLE_PRIORITY_CLASS, INFINITE, NORMAL_PRIORITY_CLASS, PROCESS_DUP_HANDLE,
-                REALTIME_PRIORITY_CLASS, STARTF_USESHOWWINDOW, STARTF_USESTDHANDLES,
+                REALTIME_PRIORITY_CLASS, STARTF_FORCEOFFFEEDBACK, STARTF_FORCEONFEEDBACK,
+                STARTF_USESHOWWINDOW, STARTF_USESTDHANDLES,
             },
         },
         UI::WindowsAndMessaging::SW_HIDE,

From 1464d5ca43273ccf7a7add66a211f67a982ae9f3 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Mon, 29 Dec 2025 23:10:14 -0500
Subject: [PATCH 117/418] Adding + Fixing Clippy rules to better align with
 #[no_std] (#6570)

* * Added alloc_instead_of_core, std_instead_of_alloc, and std_instead_of_core clippy rules
* Manually changed part of the code to use core/alloc

* use clippy --fix to fix issues in stdlib

* * Used clippy --fix to fix issues in vm
* Imported Range in vm/src/anystr.rs

* * Used clippy --fix to fix issues in common
---
 Cargo.toml                                   |  3 +
 crates/codegen/src/compile.rs                | 13 +--
 crates/codegen/src/error.rs                  |  5 +-
 crates/codegen/src/ir.rs                     |  6 +-
 crates/codegen/src/lib.rs                    |  2 +
 crates/codegen/src/string_parser.rs          |  4 +-
 crates/codegen/src/symboltable.rs            | 12 +--
 crates/codegen/src/unparse.rs                |  9 +-
 crates/common/src/borrow.rs                  |  6 +-
 crates/common/src/boxvec.rs                  | 12 +--
 crates/common/src/cformat.rs                 | 15 ++--
 crates/common/src/crt_fd.rs                  |  4 +-
 crates/common/src/encodings.rs               |  4 +-
 crates/common/src/fileutils.rs               | 10 +--
 crates/common/src/format.rs                  |  6 +-
 crates/common/src/hash.rs                    |  8 +-
 crates/common/src/int.rs                     | 12 +--
 crates/common/src/lib.rs                     |  2 +
 crates/common/src/linked_list.rs             |  2 +-
 crates/common/src/lock/cell_lock.rs          |  2 +-
 crates/common/src/lock/immutable_mutex.rs    |  7 +-
 crates/common/src/lock/thread_mutex.rs       | 14 +--
 crates/common/src/os.rs                      |  3 +-
 crates/common/src/rc.rs                      |  4 +-
 crates/common/src/str.rs                     | 25 +++---
 crates/compiler-core/src/bytecode.rs         | 13 +--
 crates/compiler-core/src/lib.rs              |  2 +
 crates/compiler-core/src/marshal.rs          | 18 ++--
 crates/compiler-core/src/mode.rs             |  6 +-
 crates/compiler/src/lib.rs                   |  4 +-
 crates/derive-impl/src/compile_bytecode.rs   |  4 +-
 crates/derive-impl/src/from_args.rs          |  8 +-
 crates/derive-impl/src/pyclass.rs            | 10 +--
 crates/derive-impl/src/pymodule.rs           |  9 +-
 crates/derive-impl/src/pytraverse.rs         |  2 +-
 crates/derive-impl/src/util.rs               | 10 +--
 crates/derive/src/lib.rs                     |  2 +-
 crates/jit/src/lib.rs                        |  5 +-
 crates/literal/src/escape.rs                 | 30 +++----
 crates/literal/src/float.rs                  |  2 +-
 crates/sre_engine/src/engine.rs              |  8 +-
 crates/sre_engine/src/string.rs              |  2 +-
 crates/stdlib/src/array.rs                   | 41 ++++-----
 crates/stdlib/src/binascii.rs                |  2 +-
 crates/stdlib/src/bz2.rs                     |  3 +-
 crates/stdlib/src/cmath.rs                   |  4 +-
 crates/stdlib/src/compression.rs             |  4 +-
 crates/stdlib/src/contextvars.rs             | 26 +++---
 crates/stdlib/src/csv.rs                     |  7 +-
 crates/stdlib/src/faulthandler.rs            | 25 +++---
 crates/stdlib/src/fcntl.rs                   |  2 +-
 crates/stdlib/src/grp.rs                     |  4 +-
 crates/stdlib/src/hashlib.rs                 |  8 +-
 crates/stdlib/src/json.rs                    |  4 +-
 crates/stdlib/src/lib.rs                     |  3 +-
 crates/stdlib/src/locale.rs                  |  6 +-
 crates/stdlib/src/lzma.rs                    |  2 +-
 crates/stdlib/src/math.rs                    | 16 ++--
 crates/stdlib/src/mmap.rs                    |  4 +-
 crates/stdlib/src/opcode.rs                  |  2 +-
 crates/stdlib/src/openssl.rs                 |  8 +-
 crates/stdlib/src/overlapped.rs              | 24 ++---
 crates/stdlib/src/posixshmem.rs              |  2 +-
 crates/stdlib/src/posixsubprocess.rs         | 10 +--
 crates/stdlib/src/resource.rs                |  3 +-
 crates/stdlib/src/scproxy.rs                 |  2 +-
 crates/stdlib/src/select.rs                  | 15 ++--
 crates/stdlib/src/socket.rs                  | 32 ++++---
 crates/stdlib/src/sqlite.rs                  |  4 +-
 crates/stdlib/src/ssl.rs                     | 22 +++--
 crates/stdlib/src/ssl/cert.rs                | 31 +++----
 crates/stdlib/src/ssl/compat.rs              |  3 +-
 crates/stdlib/src/syslog.rs                  |  5 +-
 crates/stdlib/src/tkinter.rs                 |  8 +-
 crates/stdlib/src/zlib.rs                    |  4 +-
 crates/venvlauncher/src/main.rs              |  6 +-
 crates/vm/src/anystr.rs                      | 30 +++----
 crates/vm/src/buffer.rs                      | 12 +--
 crates/vm/src/builtins/bool.rs               |  4 +-
 crates/vm/src/builtins/builtin_func.rs       |  4 +-
 crates/vm/src/builtins/bytearray.rs          |  4 +-
 crates/vm/src/builtins/bytes.rs              |  2 +-
 crates/vm/src/builtins/code.rs               |  5 +-
 crates/vm/src/builtins/complex.rs            |  2 +-
 crates/vm/src/builtins/descriptor.rs         | 12 +--
 crates/vm/src/builtins/dict.rs               |  6 +-
 crates/vm/src/builtins/function.rs           |  4 +-
 crates/vm/src/builtins/genericalias.rs       |  2 +-
 crates/vm/src/builtins/getset.rs             |  6 +-
 crates/vm/src/builtins/int.rs                |  8 +-
 crates/vm/src/builtins/list.rs               | 17 ++--
 crates/vm/src/builtins/map.rs                |  2 +-
 crates/vm/src/builtins/memory.rs             |  2 +-
 crates/vm/src/builtins/module.rs             |  4 +-
 crates/vm/src/builtins/object.rs             |  2 +-
 crates/vm/src/builtins/property.rs           |  4 +-
 crates/vm/src/builtins/range.rs              |  2 +-
 crates/vm/src/builtins/set.rs                | 31 +++----
 crates/vm/src/builtins/str.rs                | 43 ++++-----
 crates/vm/src/builtins/traceback.rs          |  2 +-
 crates/vm/src/builtins/tuple.rs              | 27 +++---
 crates/vm/src/builtins/type.rs               | 27 +++---
 crates/vm/src/builtins/union.rs              |  2 +-
 crates/vm/src/bytes_inner.rs                 | 14 +--
 crates/vm/src/cformat.rs                     |  4 +-
 crates/vm/src/class.rs                       |  4 +-
 crates/vm/src/codecs.rs                      |  8 +-
 crates/vm/src/convert/try_from.rs            |  2 +-
 crates/vm/src/dict_inner.rs                  |  9 +-
 crates/vm/src/exceptions.rs                  | 10 +--
 crates/vm/src/frame.rs                       | 25 +++---
 crates/vm/src/function/argument.rs           |  8 +-
 crates/vm/src/function/builtin.rs            |  8 +-
 crates/vm/src/function/either.rs             |  2 +-
 crates/vm/src/function/fspath.rs             |  7 +-
 crates/vm/src/function/method.rs             |  6 +-
 crates/vm/src/function/number.rs             |  4 +-
 crates/vm/src/function/protocol.rs           | 12 +--
 crates/vm/src/intern.rs                      | 30 +++----
 crates/vm/src/lib.rs                         |  1 +
 crates/vm/src/macros.rs                      |  4 +-
 crates/vm/src/object/core.rs                 | 52 +++++------
 crates/vm/src/object/ext.rs                  |  9 +-
 crates/vm/src/object/payload.rs              | 18 ++--
 crates/vm/src/object/traverse.rs             |  2 +-
 crates/vm/src/object/traverse_object.rs      |  2 +-
 crates/vm/src/ospath.rs                      |  6 +-
 crates/vm/src/protocol/buffer.rs             | 11 +--
 crates/vm/src/protocol/callable.rs           |  4 +-
 crates/vm/src/protocol/iter.rs               |  8 +-
 crates/vm/src/protocol/mapping.rs            |  8 +-
 crates/vm/src/protocol/number.rs             |  2 +-
 crates/vm/src/protocol/sequence.rs           |  8 +-
 crates/vm/src/py_io.rs                       |  4 +-
 crates/vm/src/py_serde.rs                    |  2 +-
 crates/vm/src/readline.rs                    |  2 +-
 crates/vm/src/scope.rs                       |  2 +-
 crates/vm/src/sequence.rs                    |  4 +-
 crates/vm/src/signal.rs                      | 10 +--
 crates/vm/src/sliceable.rs                   |  2 +-
 crates/vm/src/stdlib/ast/elif_else_clause.rs |  2 +-
 crates/vm/src/stdlib/ast/parameter.rs        |  2 +-
 crates/vm/src/stdlib/ast/string.rs           |  4 +-
 crates/vm/src/stdlib/atexit.rs               |  2 +-
 crates/vm/src/stdlib/builtins.rs             | 10 +--
 crates/vm/src/stdlib/codecs.rs               |  8 +-
 crates/vm/src/stdlib/collections.rs          | 10 +--
 crates/vm/src/stdlib/ctypes.rs               | 42 +++++----
 crates/vm/src/stdlib/ctypes/array.rs         | 14 +--
 crates/vm/src/stdlib/ctypes/base.rs          | 64 ++++++-------
 crates/vm/src/stdlib/ctypes/function.rs      | 50 +++++------
 crates/vm/src/stdlib/ctypes/library.rs       |  4 +-
 crates/vm/src/stdlib/ctypes/pointer.rs       | 56 ++++++------
 crates/vm/src/stdlib/ctypes/simple.rs        | 94 ++++++++++----------
 crates/vm/src/stdlib/ctypes/structure.rs     | 12 +--
 crates/vm/src/stdlib/ctypes/union.rs         | 12 +--
 crates/vm/src/stdlib/io.rs                   | 52 +++++------
 crates/vm/src/stdlib/itertools.rs            |  4 +-
 crates/vm/src/stdlib/mod.rs                  |  3 +-
 crates/vm/src/stdlib/nt.rs                   | 34 +++----
 crates/vm/src/stdlib/os.rs                   | 29 +++---
 crates/vm/src/stdlib/posix.rs                | 14 +--
 crates/vm/src/stdlib/pwd.rs                  |  4 +-
 crates/vm/src/stdlib/signal.rs               | 14 +--
 crates/vm/src/stdlib/string.rs               |  2 +-
 crates/vm/src/stdlib/symtable.rs             |  4 +-
 crates/vm/src/stdlib/sys.rs                  | 12 +--
 crates/vm/src/stdlib/thread.rs               |  8 +-
 crates/vm/src/stdlib/time.rs                 | 28 +++---
 crates/vm/src/stdlib/winapi.rs               | 12 +--
 crates/vm/src/stdlib/winreg.rs               | 18 ++--
 crates/vm/src/suggestion.rs                  |  2 +-
 crates/vm/src/types/slot.rs                  | 18 ++--
 crates/vm/src/utils.rs                       |  8 +-
 crates/vm/src/version.rs                     |  3 +-
 crates/vm/src/vm/context.rs                  |  6 +-
 crates/vm/src/vm/interpreter.rs              |  2 +-
 crates/vm/src/vm/mod.rs                      | 16 ++--
 crates/vm/src/vm/thread.rs                   |  6 +-
 crates/vm/src/vm/vm_new.rs                   |  4 +-
 crates/vm/src/vm/vm_ops.rs                   |  4 +-
 crates/vm/src/warn.rs                        |  2 +-
 crates/vm/src/windows.rs                     |  6 +-
 examples/dis.rs                              |  2 +-
 src/lib.rs                                   |  2 +-
 185 files changed, 1000 insertions(+), 952 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 06734b47e18..12607cfa2cc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -232,6 +232,9 @@ unsafe_op_in_unsafe_fn = "deny"
 elided_lifetimes_in_paths = "warn"
 
 [workspace.lints.clippy]
+# alloc_instead_of_core = "warn"
+# std_instead_of_alloc = "warn"
+# std_instead_of_core = "warn"
 perf = "warn"
 style = "warn"
 complexity = "warn"
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 7909e924251..c44b2b00684 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -16,6 +16,7 @@ use crate::{
     symboltable::{self, CompilerScope, SymbolFlags, SymbolScope, SymbolTable},
     unparse::UnparseExpr,
 };
+use alloc::borrow::Cow;
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex;
@@ -42,7 +43,7 @@ use rustpython_compiler_core::{
     },
 };
 use rustpython_wtf8::Wtf8Buf;
-use std::{borrow::Cow, collections::HashSet};
+use std::collections::HashSet;
 
 const MAXBLOCKS: usize = 20;
 
@@ -293,7 +294,7 @@ fn compiler_unwrap_option<T>(zelf: &Compiler, o: Option<T>) -> T {
     o.unwrap()
 }
 
-// fn compiler_result_unwrap<T, E: std::fmt::Debug>(zelf: &Compiler, result: Result<T, E>) -> T {
+// fn compiler_result_unwrap<T, E: core::fmt::Debug>(zelf: &Compiler, result: Result<T, E>) -> T {
 //     if result.is_err() {
 //         eprintln!("=== CODEGEN PANIC INFO ===");
 //         eprintln!("This IS an internal error, an result was unwrapped during codegen");
@@ -1831,7 +1832,7 @@ impl Compiler {
             name.to_owned(),
         );
 
-        let args_iter = std::iter::empty()
+        let args_iter = core::iter::empty()
             .chain(&parameters.posonlyargs)
             .chain(&parameters.args)
             .map(|arg| &arg.parameter)
@@ -2438,7 +2439,7 @@ impl Compiler {
         let mut funcflags = bytecode::MakeFunctionFlags::empty();
 
         // Handle positional defaults
-        let defaults: Vec<_> = std::iter::empty()
+        let defaults: Vec<_> = core::iter::empty()
             .chain(&parameters.posonlyargs)
             .chain(&parameters.args)
             .filter_map(|x| x.default.as_deref())
@@ -2566,7 +2567,7 @@ impl Compiler {
         let mut num_annotations = 0;
 
         // Handle parameter annotations
-        let parameters_iter = std::iter::empty()
+        let parameters_iter = core::iter::empty()
             .chain(&parameters.posonlyargs)
             .chain(&parameters.args)
             .chain(&parameters.kwonlyargs)
@@ -4965,7 +4966,7 @@ impl Compiler {
                 let name = "<lambda>".to_owned();
 
                 // Prepare defaults before entering function
-                let defaults: Vec<_> = std::iter::empty()
+                let defaults: Vec<_> = core::iter::empty()
                     .chain(&params.posonlyargs)
                     .chain(&params.args)
                     .filter_map(|x| x.default.as_deref())
diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
index 70e2f13f253..459ba8e33b5 100644
--- a/crates/codegen/src/error.rs
+++ b/crates/codegen/src/error.rs
@@ -1,5 +1,6 @@
+use alloc::fmt;
+use core::fmt::Display;
 use rustpython_compiler_core::SourceLocation;
-use std::fmt::{self, Display};
 use thiserror::Error;
 
 #[derive(Debug)]
@@ -93,7 +94,7 @@ pub enum CodegenErrorType {
     NotImplementedYet, // RustPython marker for unimplemented features
 }
 
-impl std::error::Error for CodegenErrorType {}
+impl core::error::Error for CodegenErrorType {}
 
 impl fmt::Display for CodegenErrorType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index de0126f1122..670635fbd37 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -1,4 +1,4 @@
-use std::ops;
+use core::ops;
 
 use crate::{IndexMap, IndexSet, error::InternalError};
 use rustpython_compiler_core::{
@@ -198,7 +198,7 @@ impl CodeInfo {
                         *arg = new_arg;
                     }
                     let (extras, lo_arg) = arg.split();
-                    locations.extend(std::iter::repeat_n(info.location, arg.instr_size()));
+                    locations.extend(core::iter::repeat_n(info.location, arg.instr_size()));
                     instructions.extend(
                         extras
                             .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
@@ -401,7 +401,7 @@ fn stackdepth_push(
 
 fn iter_blocks(blocks: &[Block]) -> impl Iterator<Item = (BlockIdx, &Block)> + '_ {
     let mut next = BlockIdx(0);
-    std::iter::from_fn(move || {
+    core::iter::from_fn(move || {
         if next == BlockIdx::NULL {
             return None;
         }
diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs
index 291b57d7f67..34d3870ae91 100644
--- a/crates/codegen/src/lib.rs
+++ b/crates/codegen/src/lib.rs
@@ -5,6 +5,8 @@
 #[macro_use]
 extern crate log;
 
+extern crate alloc;
+
 type IndexMap<K, V> = indexmap::IndexMap<K, V, ahash::RandomState>;
 type IndexSet<T> = indexmap::IndexSet<T, ahash::RandomState>;
 
diff --git a/crates/codegen/src/string_parser.rs b/crates/codegen/src/string_parser.rs
index ede2f118c37..175e75c1a26 100644
--- a/crates/codegen/src/string_parser.rs
+++ b/crates/codegen/src/string_parser.rs
@@ -5,7 +5,7 @@
 //! after ruff has already successfully parsed the string literal, meaning
 //! we don't need to do any validation or error handling.
 
-use std::convert::Infallible;
+use core::convert::Infallible;
 
 use ruff_python_ast::{AnyStringFlags, StringFlags};
 use rustpython_wtf8::{CodePoint, Wtf8, Wtf8Buf};
@@ -96,7 +96,7 @@ impl StringParser {
         }
 
         // OK because radix_bytes is always going to be in the ASCII range.
-        let radix_str = std::str::from_utf8(&radix_bytes[..len]).expect("ASCII bytes");
+        let radix_str = core::str::from_utf8(&radix_bytes[..len]).expect("ASCII bytes");
         let value = u32::from_str_radix(radix_str, 8).unwrap();
         char::from_u32(value).unwrap()
     }
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 3c8454b9e22..1629e5fff38 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -11,6 +11,7 @@ use crate::{
     IndexMap,
     error::{CodegenError, CodegenErrorType},
 };
+use alloc::{borrow::Cow, fmt};
 use bitflags::bitflags;
 use ruff_python_ast::{
     self as ast, Comprehension, Decorator, Expr, Identifier, ModExpression, ModModule, Parameter,
@@ -20,7 +21,6 @@ use ruff_python_ast::{
 };
 use ruff_text_size::{Ranged, TextRange};
 use rustpython_compiler_core::{PositionEncoding, SourceFile, SourceLocation};
-use std::{borrow::Cow, fmt};
 
 /// Captures all symbols in the current scope, and has a list of sub-scopes in this scope.
 #[derive(Clone)]
@@ -215,8 +215,8 @@ impl SymbolTableError {
 
 type SymbolTableResult<T = ()> = Result<T, SymbolTableError>;
 
-impl std::fmt::Debug for SymbolTable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SymbolTable {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "SymbolTable({:?} symbols, {:?} sub scopes)",
@@ -261,8 +261,8 @@ fn drop_class_free(symbol_table: &mut SymbolTable) {
 type SymbolMap = IndexMap<String, Symbol>;
 
 mod stack {
+    use core::ptr::NonNull;
     use std::panic;
-    use std::ptr::NonNull;
     pub struct StackStack<T> {
         v: Vec<NonNull<T>>,
     }
@@ -325,7 +325,7 @@ struct SymbolTableAnalyzer {
 
 impl SymbolTableAnalyzer {
     fn analyze_symbol_table(&mut self, symbol_table: &mut SymbolTable) -> SymbolTableResult {
-        let symbols = std::mem::take(&mut symbol_table.symbols);
+        let symbols = core::mem::take(&mut symbol_table.symbols);
         let sub_tables = &mut *symbol_table.sub_tables;
 
         let mut info = (symbols, symbol_table.typ);
@@ -689,7 +689,7 @@ impl SymbolTableBuilder {
     fn leave_scope(&mut self) {
         let mut table = self.tables.pop().unwrap();
         // Save the collected varnames to the symbol table
-        table.varnames = std::mem::take(&mut self.current_varnames);
+        table.varnames = core::mem::take(&mut self.current_varnames);
         self.tables.last_mut().unwrap().sub_tables.push(table);
     }
 
diff --git a/crates/codegen/src/unparse.rs b/crates/codegen/src/unparse.rs
index 74e35fd5e2a..7b26d229187 100644
--- a/crates/codegen/src/unparse.rs
+++ b/crates/codegen/src/unparse.rs
@@ -1,3 +1,5 @@
+use alloc::fmt;
+use core::fmt::Display as _;
 use ruff_python_ast::{
     self as ruff, Arguments, BoolOp, Comprehension, ConversionFlag, Expr, Identifier, Operator,
     Parameter, ParameterWithDefault, Parameters,
@@ -5,7 +7,6 @@ use ruff_python_ast::{
 use ruff_text_size::Ranged;
 use rustpython_compiler_core::SourceFile;
 use rustpython_literal::escape::{AsciiEscape, UnicodeEscape};
-use std::fmt::{self, Display as _};
 
 mod precedence {
     macro_rules! precedence {
@@ -51,7 +52,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
     }
 
     fn p_delim(&mut self, first: &mut bool, s: &str) -> fmt::Result {
-        self.p_if(!std::mem::take(first), s)
+        self.p_if(!core::mem::take(first), s)
     }
 
     fn write_fmt(&mut self, f: fmt::Arguments<'_>) -> fmt::Result {
@@ -575,7 +576,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         if conversion != ConversionFlag::None {
             self.p("!")?;
             let buf = &[conversion as u8];
-            let c = std::str::from_utf8(buf).unwrap();
+            let c = core::str::from_utf8(buf).unwrap();
             self.p(c)?;
         }
 
@@ -650,7 +651,7 @@ impl fmt::Display for UnparseExpr<'_> {
 }
 
 fn to_string_fmt(f: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result) -> String {
-    use std::cell::Cell;
+    use core::cell::Cell;
     struct Fmt<F>(Cell<Option<F>>);
     impl<F: FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for Fmt<F> {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/common/src/borrow.rs b/crates/common/src/borrow.rs
index 610084006e1..d8389479b33 100644
--- a/crates/common/src/borrow.rs
+++ b/crates/common/src/borrow.rs
@@ -2,10 +2,8 @@ use crate::lock::{
     MapImmutable, PyImmutableMappedMutexGuard, PyMappedMutexGuard, PyMappedRwLockReadGuard,
     PyMappedRwLockWriteGuard, PyMutexGuard, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
-use std::{
-    fmt,
-    ops::{Deref, DerefMut},
-};
+use alloc::fmt;
+use core::ops::{Deref, DerefMut};
 
 macro_rules! impl_from {
     ($lt:lifetime, $gen:ident, $t:ty, $($var:ident($from:ty),)*) => {
diff --git a/crates/common/src/boxvec.rs b/crates/common/src/boxvec.rs
index 8687ba7f7f5..3260e76ca87 100644
--- a/crates/common/src/boxvec.rs
+++ b/crates/common/src/boxvec.rs
@@ -2,13 +2,13 @@
 //! An unresizable vector backed by a `Box<[T]>`
 
 #![allow(clippy::needless_lifetimes)]
-
-use std::{
+use alloc::{fmt, slice};
+use core::{
     borrow::{Borrow, BorrowMut},
-    cmp, fmt,
+    cmp,
     mem::{self, MaybeUninit},
     ops::{Bound, Deref, DerefMut, RangeBounds},
-    ptr, slice,
+    ptr,
 };
 
 pub struct BoxVec<T> {
@@ -555,7 +555,7 @@ impl<T> Extend<T> for BoxVec<T> {
             };
             let mut iter = iter.into_iter();
             loop {
-                if std::ptr::eq(ptr, end_ptr) {
+                if core::ptr::eq(ptr, end_ptr) {
                     break;
                 }
                 if let Some(elt) = iter.next() {
@@ -693,7 +693,7 @@ impl<T> CapacityError<T> {
 
 const CAPERROR: &str = "insufficient capacity";
 
-impl<T> std::error::Error for CapacityError<T> {}
+impl<T> core::error::Error for CapacityError<T> {}
 
 impl<T> fmt::Display for CapacityError<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/common/src/cformat.rs b/crates/common/src/cformat.rs
index b553f0b6b10..24332396fdb 100644
--- a/crates/common/src/cformat.rs
+++ b/crates/common/src/cformat.rs
@@ -1,15 +1,16 @@
 //! Implementation of Printf-Style string formatting
 //! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
+use alloc::fmt;
 use bitflags::bitflags;
+use core::{
+    cmp,
+    iter::{Enumerate, Peekable},
+    str::FromStr,
+};
 use itertools::Itertools;
 use malachite_bigint::{BigInt, Sign};
 use num_traits::Signed;
 use rustpython_literal::{float, format::Case};
-use std::{
-    cmp, fmt,
-    iter::{Enumerate, Peekable},
-    str::FromStr,
-};
 
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
@@ -785,7 +786,7 @@ impl<S> CFormatStrOrBytes<S> {
                         if !literal.is_empty() {
                             parts.push((
                                 part_index,
-                                CFormatPart::Literal(std::mem::take(&mut literal)),
+                                CFormatPart::Literal(core::mem::take(&mut literal)),
                             ));
                         }
                         let spec = CFormatSpecKeyed::parse(iter).map_err(|err| CFormatError {
@@ -816,7 +817,7 @@ impl<S> CFormatStrOrBytes<S> {
 
 impl<S> IntoIterator for CFormatStrOrBytes<S> {
     type Item = (usize, CFormatPart<S>);
-    type IntoIter = std::vec::IntoIter<Self::Item>;
+    type IntoIter = alloc::vec::IntoIter<Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.parts.into_iter()
diff --git a/crates/common/src/crt_fd.rs b/crates/common/src/crt_fd.rs
index b873ef9c52c..1902a362e32 100644
--- a/crates/common/src/crt_fd.rs
+++ b/crates/common/src/crt_fd.rs
@@ -1,7 +1,9 @@
 //! A module implementing an io type backed by the C runtime's file descriptors, i.e. what's
 //! returned from libc::open, even on windows.
 
-use std::{cmp, ffi, fmt, io};
+use alloc::fmt;
+use core::cmp;
+use std::{ffi, io};
 
 #[cfg(not(windows))]
 use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
diff --git a/crates/common/src/encodings.rs b/crates/common/src/encodings.rs
index 39ca2661262..d54581eb9ea 100644
--- a/crates/common/src/encodings.rs
+++ b/crates/common/src/encodings.rs
@@ -1,4 +1,4 @@
-use std::ops::{self, Range};
+use core::ops::{self, Range};
 
 use num_traits::ToPrimitive;
 
@@ -260,7 +260,7 @@ pub mod errors {
     use crate::str::UnicodeEscapeCodepoint;
 
     use super::*;
-    use std::fmt::Write;
+    use core::fmt::Write;
 
     pub struct Strict;
 
diff --git a/crates/common/src/fileutils.rs b/crates/common/src/fileutils.rs
index a12c1cd82e5..9ed5e77afbb 100644
--- a/crates/common/src/fileutils.rs
+++ b/crates/common/src/fileutils.rs
@@ -9,7 +9,7 @@ pub use windows::{StatStruct, fstat};
 
 #[cfg(not(windows))]
 pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
-    let mut stat = std::mem::MaybeUninit::uninit();
+    let mut stat = core::mem::MaybeUninit::uninit();
     unsafe {
         let ret = libc::fstat(fd.as_raw(), stat.as_mut_ptr());
         if ret == -1 {
@@ -165,7 +165,7 @@ pub mod windows {
     }
 
     fn file_time_to_time_t_nsec(in_ptr: &FILETIME) -> (libc::time_t, libc::c_int) {
-        let in_val: i64 = unsafe { std::mem::transmute_copy(in_ptr) };
+        let in_val: i64 = unsafe { core::mem::transmute_copy(in_ptr) };
         let nsec_out = (in_val % 10_000_000) * 100; // FILETIME is in units of 100 nsec.
         let time_out = (in_val / 10_000_000) - SECS_BETWEEN_EPOCHS;
         (time_out, nsec_out as _)
@@ -204,7 +204,7 @@ pub mod windows {
         let st_nlink = info.nNumberOfLinks as i32;
 
         let st_ino = if let Some(id_info) = id_info {
-            let file_id: [u64; 2] = unsafe { std::mem::transmute_copy(&id_info.FileId) };
+            let file_id: [u64; 2] = unsafe { core::mem::transmute_copy(&id_info.FileId) };
             file_id
         } else {
             let ino = ((info.nFileIndexHigh as u64) << 32) + info.nFileIndexLow as u64;
@@ -313,7 +313,7 @@ pub mod windows {
                     unsafe { GetProcAddress(module, name.as_bytes_with_nul().as_ptr()) }
                 {
                     Some(unsafe {
-                        std::mem::transmute::<
+                        core::mem::transmute::<
                             unsafe extern "system" fn() -> isize,
                             unsafe extern "system" fn(
                                 *const u16,
@@ -441,7 +441,7 @@ pub mod windows {
 // Open a file using std::fs::File and convert to FILE*
 // Automatically handles path encoding and EINTR retries
 pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::FILE> {
-    use std::ffi::CString;
+    use alloc::ffi::CString;
     use std::fs::File;
 
     // Currently only supports read mode
diff --git a/crates/common/src/format.rs b/crates/common/src/format.rs
index 447ae575f48..1afee519aef 100644
--- a/crates/common/src/format.rs
+++ b/crates/common/src/format.rs
@@ -1,4 +1,6 @@
 // spell-checker:ignore ddfe
+use core::ops::Deref;
+use core::{cmp, str::FromStr};
 use itertools::{Itertools, PeekingNext};
 use malachite_base::num::basic::floats::PrimitiveFloat;
 use malachite_bigint::{BigInt, Sign};
@@ -7,8 +9,6 @@ use num_traits::FromPrimitive;
 use num_traits::{Signed, cast::ToPrimitive};
 use rustpython_literal::float;
 use rustpython_literal::format::Case;
-use std::ops::Deref;
-use std::{cmp, str::FromStr};
 
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
@@ -598,7 +598,7 @@ impl FormatSpec {
                 (Some(_), _) => Err(FormatSpecError::NotAllowed("Sign")),
                 (_, true) => Err(FormatSpecError::NotAllowed("Alternate form (#)")),
                 (_, _) => match num.to_u32() {
-                    Some(n) if n <= 0x10ffff => Ok(std::char::from_u32(n).unwrap().to_string()),
+                    Some(n) if n <= 0x10ffff => Ok(core::char::from_u32(n).unwrap().to_string()),
                     Some(_) | None => Err(FormatSpecError::CodeNotInRange),
                 },
             },
diff --git a/crates/common/src/hash.rs b/crates/common/src/hash.rs
index dcf424f7ba9..40c428d89e3 100644
--- a/crates/common/src/hash.rs
+++ b/crates/common/src/hash.rs
@@ -1,7 +1,7 @@
+use core::hash::{BuildHasher, Hash, Hasher};
 use malachite_bigint::BigInt;
 use num_traits::ToPrimitive;
 use siphasher::sip::SipHasher24;
-use std::hash::{BuildHasher, Hash, Hasher};
 
 pub type PyHash = i64;
 pub type PyUHash = u64;
@@ -19,9 +19,9 @@ pub const INF: PyHash = 314_159;
 pub const NAN: PyHash = 0;
 pub const IMAG: PyHash = MULTIPLIER;
 pub const ALGO: &str = "siphash24";
-pub const HASH_BITS: usize = std::mem::size_of::<PyHash>() * 8;
+pub const HASH_BITS: usize = core::mem::size_of::<PyHash>() * 8;
 // SipHasher24 takes 2 u64s as a seed
-pub const SEED_BITS: usize = std::mem::size_of::<u64>() * 2 * 8;
+pub const SEED_BITS: usize = core::mem::size_of::<u64>() * 2 * 8;
 
 // pub const CUTOFF: usize = 7;
 
@@ -134,7 +134,7 @@ pub fn hash_bigint(value: &BigInt) -> PyHash {
         Some(i) => mod_int(i),
         None => (value % MODULUS).to_i64().unwrap_or_else(|| unsafe {
             // SAFETY: MODULUS < i64::MAX, so value % MODULUS is guaranteed to be in the range of i64
-            std::hint::unreachable_unchecked()
+            core::hint::unreachable_unchecked()
         }),
     };
     fix_sentinel(ret)
diff --git a/crates/common/src/int.rs b/crates/common/src/int.rs
index ed09cc01a0a..57696e21fe7 100644
--- a/crates/common/src/int.rs
+++ b/crates/common/src/int.rs
@@ -7,18 +7,18 @@ pub fn true_div(numerator: &BigInt, denominator: &BigInt) -> f64 {
     let rational = Rational::from_integers_ref(numerator.into(), denominator.into());
     match rational.rounding_into(RoundingMode::Nearest) {
         // returned value is $t::MAX but still less than the original
-        (val, std::cmp::Ordering::Less) if val == f64::MAX => f64::INFINITY,
+        (val, core::cmp::Ordering::Less) if val == f64::MAX => f64::INFINITY,
         // returned value is $t::MIN but still greater than the original
-        (val, std::cmp::Ordering::Greater) if val == f64::MIN => f64::NEG_INFINITY,
+        (val, core::cmp::Ordering::Greater) if val == f64::MIN => f64::NEG_INFINITY,
         (val, _) => val,
     }
 }
 
 pub fn float_to_ratio(value: f64) -> Option<(BigInt, BigInt)> {
-    let sign = match std::cmp::PartialOrd::partial_cmp(&value, &0.0)? {
-        std::cmp::Ordering::Less => Sign::Minus,
-        std::cmp::Ordering::Equal => return Some((BigInt::zero(), BigInt::one())),
-        std::cmp::Ordering::Greater => Sign::Plus,
+    let sign = match core::cmp::PartialOrd::partial_cmp(&value, &0.0)? {
+        core::cmp::Ordering::Less => Sign::Minus,
+        core::cmp::Ordering::Equal => return Some((BigInt::zero(), BigInt::one())),
+        core::cmp::Ordering::Greater => Sign::Plus,
     };
     Rational::try_from(value).ok().map(|x| {
         let (numer, denom) = x.into_numerator_and_denominator();
diff --git a/crates/common/src/lib.rs b/crates/common/src/lib.rs
index c99ba0286a4..0181562d043 100644
--- a/crates/common/src/lib.rs
+++ b/crates/common/src/lib.rs
@@ -2,6 +2,8 @@
 
 #![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
 
+extern crate alloc;
+
 #[macro_use]
 mod macros;
 pub use macros::*;
diff --git a/crates/common/src/linked_list.rs b/crates/common/src/linked_list.rs
index 8afc1478e6b..fb2b1260346 100644
--- a/crates/common/src/linked_list.rs
+++ b/crates/common/src/linked_list.rs
@@ -253,7 +253,7 @@ impl<L: Link> LinkedList<L, L::Target> {
     // === rustpython additions ===
 
     pub fn iter(&self) -> impl Iterator<Item = &L::Target> {
-        std::iter::successors(self.head, |node| unsafe {
+        core::iter::successors(self.head, |node| unsafe {
             L::pointers(*node).as_ref().get_next()
         })
         .map(|ptr| unsafe { ptr.as_ref() })
diff --git a/crates/common/src/lock/cell_lock.rs b/crates/common/src/lock/cell_lock.rs
index 25a5cfedba1..73d722a8fdb 100644
--- a/crates/common/src/lock/cell_lock.rs
+++ b/crates/common/src/lock/cell_lock.rs
@@ -1,9 +1,9 @@
 // spell-checker:ignore upgradably sharedly
+use core::{cell::Cell, num::NonZero};
 use lock_api::{
     GetThreadId, RawMutex, RawRwLock, RawRwLockDowngrade, RawRwLockRecursive, RawRwLockUpgrade,
     RawRwLockUpgradeDowngrade,
 };
-use std::{cell::Cell, num::NonZero};
 
 pub struct RawCellMutex {
     locked: Cell<bool>,
diff --git a/crates/common/src/lock/immutable_mutex.rs b/crates/common/src/lock/immutable_mutex.rs
index 81c5c93be71..2013cf1c60d 100644
--- a/crates/common/src/lock/immutable_mutex.rs
+++ b/crates/common/src/lock/immutable_mutex.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::needless_lifetimes)]
 
+use alloc::fmt;
+use core::{marker::PhantomData, ops::Deref};
 use lock_api::{MutexGuard, RawMutex};
-use std::{fmt, marker::PhantomData, ops::Deref};
 
 /// A mutex guard that has an exclusive lock, but only an immutable reference; useful if you
 /// need to map a mutex guard with a function that returns an `&T`. Construct using the
@@ -22,7 +23,7 @@ impl<'a, R: RawMutex, T: ?Sized> MapImmutable<'a, R, T> for MutexGuard<'a, R, T>
     {
         let raw = unsafe { MutexGuard::mutex(&s).raw() };
         let data = f(&s) as *const U;
-        std::mem::forget(s);
+        core::mem::forget(s);
         ImmutableMappedMutexGuard {
             raw,
             data,
@@ -38,7 +39,7 @@ impl<'a, R: RawMutex, T: ?Sized> ImmutableMappedMutexGuard<'a, R, T> {
     {
         let raw = s.raw;
         let data = f(&s) as *const U;
-        std::mem::forget(s);
+        core::mem::forget(s);
         ImmutableMappedMutexGuard {
             raw,
             data,
diff --git a/crates/common/src/lock/thread_mutex.rs b/crates/common/src/lock/thread_mutex.rs
index 2949a3c6c14..67ffc89245d 100644
--- a/crates/common/src/lock/thread_mutex.rs
+++ b/crates/common/src/lock/thread_mutex.rs
@@ -1,14 +1,14 @@
 #![allow(clippy::needless_lifetimes)]
 
-use lock_api::{GetThreadId, GuardNoSend, RawMutex};
-use std::{
+use alloc::fmt;
+use core::{
     cell::UnsafeCell,
-    fmt,
     marker::PhantomData,
     ops::{Deref, DerefMut},
     ptr::NonNull,
     sync::atomic::{AtomicUsize, Ordering},
 };
+use lock_api::{GetThreadId, GuardNoSend, RawMutex};
 
 // based off ReentrantMutex from lock_api
 
@@ -174,7 +174,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutexGuard<'a, R, G, T> {
     ) -> MappedThreadMutexGuard<'a, R, G, U> {
         let data = f(&mut s).into();
         let mu = &s.mu.raw;
-        std::mem::forget(s);
+        core::mem::forget(s);
         MappedThreadMutexGuard {
             mu,
             data,
@@ -188,7 +188,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutexGuard<'a, R, G, T> {
         if let Some(data) = f(&mut s) {
             let data = data.into();
             let mu = &s.mu.raw;
-            std::mem::forget(s);
+            core::mem::forget(s);
             Ok(MappedThreadMutexGuard {
                 mu,
                 data,
@@ -241,7 +241,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> MappedThreadMutexGuard<'a, R, G
     ) -> MappedThreadMutexGuard<'a, R, G, U> {
         let data = f(&mut s).into();
         let mu = s.mu;
-        std::mem::forget(s);
+        core::mem::forget(s);
         MappedThreadMutexGuard {
             mu,
             data,
@@ -255,7 +255,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> MappedThreadMutexGuard<'a, R, G
         if let Some(data) = f(&mut s) {
             let data = data.into();
             let mu = s.mu;
-            std::mem::forget(s);
+            core::mem::forget(s);
             Ok(MappedThreadMutexGuard {
                 mu,
                 data,
diff --git a/crates/common/src/os.rs b/crates/common/src/os.rs
index e77a81fd94f..3e09a29210a 100644
--- a/crates/common/src/os.rs
+++ b/crates/common/src/os.rs
@@ -1,7 +1,8 @@
 // spell-checker:disable
 // TODO: we can move more os-specific bindings/interfaces from stdlib::{os, posix, nt} to here
 
-use std::{io, process::ExitCode, str::Utf8Error};
+use core::str::Utf8Error;
+use std::{io, process::ExitCode};
 
 /// Convert exit code to std::process::ExitCode
 ///
diff --git a/crates/common/src/rc.rs b/crates/common/src/rc.rs
index 40c7cf97a8d..9e4cca228fd 100644
--- a/crates/common/src/rc.rs
+++ b/crates/common/src/rc.rs
@@ -1,7 +1,7 @@
 #[cfg(not(feature = "threading"))]
-use std::rc::Rc;
+use alloc::rc::Rc;
 #[cfg(feature = "threading")]
-use std::sync::Arc;
+use alloc::sync::Arc;
 
 // type aliases instead of new-types because you can't do `fn method(self: PyRc<Self>)` with a
 // newtype; requires the arbitrary_self_types unstable feature
diff --git a/crates/common/src/str.rs b/crates/common/src/str.rs
index 2d867130edd..155012ed21f 100644
--- a/crates/common/src/str.rs
+++ b/crates/common/src/str.rs
@@ -4,8 +4,8 @@ use crate::format::CharLen;
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 use ascii::{AsciiChar, AsciiStr, AsciiString};
 use core::fmt;
+use core::ops::{Bound, RangeBounds};
 use core::sync::atomic::Ordering::Relaxed;
-use std::ops::{Bound, RangeBounds};
 
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(non_camel_case_types)]
@@ -22,7 +22,7 @@ pub enum StrKind {
     Wtf8,
 }
 
-impl std::ops::BitOr for StrKind {
+impl core::ops::BitOr for StrKind {
     type Output = Self;
 
     fn bitor(self, other: Self) -> Self {
@@ -128,7 +128,7 @@ impl From<usize> for StrLen {
 }
 
 impl fmt::Debug for StrLen {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let len = self.0.load(Relaxed);
         if len == usize::MAX {
             f.write_str("<uncomputed>")
@@ -262,7 +262,7 @@ impl StrData {
     pub fn as_str(&self) -> Option<&str> {
         self.kind
             .is_utf8()
-            .then(|| unsafe { std::str::from_utf8_unchecked(self.data.as_bytes()) })
+            .then(|| unsafe { core::str::from_utf8_unchecked(self.data.as_bytes()) })
     }
 
     pub fn as_ascii(&self) -> Option<&AsciiStr> {
@@ -282,7 +282,7 @@ impl StrData {
                 PyKindStr::Ascii(unsafe { AsciiStr::from_ascii_unchecked(self.data.as_bytes()) })
             }
             StrKind::Utf8 => {
-                PyKindStr::Utf8(unsafe { std::str::from_utf8_unchecked(self.data.as_bytes()) })
+                PyKindStr::Utf8(unsafe { core::str::from_utf8_unchecked(self.data.as_bytes()) })
             }
             StrKind::Wtf8 => PyKindStr::Wtf8(&self.data),
         }
@@ -327,8 +327,8 @@ impl StrData {
     }
 }
 
-impl std::fmt::Display for StrData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for StrData {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.data.fmt(f)
     }
 }
@@ -421,7 +421,7 @@ pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
         };
         let mut filled = Vec::new();
         filled.extend_from_slice(sign);
-        filled.extend(std::iter::repeat_n(b'0', width - bytes.len()));
+        filled.extend(core::iter::repeat_n(b'0', width - bytes.len()));
         filled.extend_from_slice(s);
         filled
     }
@@ -465,7 +465,8 @@ impl fmt::Display for UnicodeEscapeCodepoint {
 }
 
 pub mod levenshtein {
-    use std::{cell::RefCell, thread_local};
+    use core::cell::RefCell;
+    use std::thread_local;
 
     pub const MOVE_COST: usize = 2;
     const CASE_COST: usize = 1;
@@ -524,9 +525,9 @@ pub mod levenshtein {
         }
 
         if b_end < a_end {
-            std::mem::swap(&mut a_bytes, &mut b_bytes);
-            std::mem::swap(&mut a_begin, &mut b_begin);
-            std::mem::swap(&mut a_end, &mut b_end);
+            core::mem::swap(&mut a_bytes, &mut b_bytes);
+            core::mem::swap(&mut a_begin, &mut b_begin);
+            core::mem::swap(&mut a_end, &mut b_end);
         }
 
         if (b_end - a_end) * MOVE_COST > max_cost {
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 8df5d9caf6f..5569fa2012b 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -5,12 +5,13 @@ use crate::{
     marshal::MarshalError,
     {OneIndexed, SourceLocation},
 };
+use alloc::{collections::BTreeSet, fmt};
 use bitflags::bitflags;
+use core::{hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
-use std::{collections::BTreeSet, fmt, hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
 
 /// Oparg values for [`Instruction::ConvertValue`].
 ///
@@ -506,7 +507,7 @@ impl<T: OpArgType> Eq for Arg<T> {}
 
 impl<T: OpArgType> fmt::Debug for Arg<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Arg<{}>", std::any::type_name::<T>())
+        write!(f, "Arg<{}>", core::any::type_name::<T>())
     }
 }
 
@@ -880,7 +881,7 @@ impl From<Instruction> for u8 {
     #[inline]
     fn from(ins: Instruction) -> Self {
         // SAFETY: there's no padding bits
-        unsafe { std::mem::transmute::<Instruction, Self>(ins) }
+        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
     }
 }
 
@@ -890,7 +891,7 @@ impl TryFrom<u8> for Instruction {
     #[inline]
     fn try_from(value: u8) -> Result<Self, MarshalError> {
         if value <= u8::from(LAST_INSTRUCTION) {
-            Ok(unsafe { std::mem::transmute::<u8, Self>(value) })
+            Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
         } else {
             Err(MarshalError::InvalidBytecode)
         }
@@ -1027,7 +1028,7 @@ impl PartialEq for ConstantData {
             (Boolean { value: a }, Boolean { value: b }) => a == b,
             (Str { value: a }, Str { value: b }) => a == b,
             (Bytes { value: a }, Bytes { value: b }) => a == b,
-            (Code { code: a }, Code { code: b }) => std::ptr::eq(a.as_ref(), b.as_ref()),
+            (Code { code: a }, Code { code: b }) => core::ptr::eq(a.as_ref(), b.as_ref()),
             (Tuple { elements: a }, Tuple { elements: b }) => a == b,
             (None, None) => true,
             (Ellipsis, Ellipsis) => true,
@@ -1053,7 +1054,7 @@ impl hash::Hash for ConstantData {
             Boolean { value } => value.hash(state),
             Str { value } => value.hash(state),
             Bytes { value } => value.hash(state),
-            Code { code } => std::ptr::hash(code.as_ref(), state),
+            Code { code } => core::ptr::hash(code.as_ref(), state),
             Tuple { elements } => elements.hash(state),
             None => {}
             Ellipsis => {}
diff --git a/crates/compiler-core/src/lib.rs b/crates/compiler-core/src/lib.rs
index 08cdc0ec21f..11246f6f44c 100644
--- a/crates/compiler-core/src/lib.rs
+++ b/crates/compiler-core/src/lib.rs
@@ -1,6 +1,8 @@
 #![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
 #![doc(html_root_url = "https://docs.rs/rustpython-compiler-core/")]
 
+extern crate alloc;
+
 pub mod bytecode;
 pub mod frozen;
 pub mod marshal;
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
index 39e48071678..b30894ea065 100644
--- a/crates/compiler-core/src/marshal.rs
+++ b/crates/compiler-core/src/marshal.rs
@@ -1,8 +1,8 @@
 use crate::{OneIndexed, SourceLocation, bytecode::*};
+use core::convert::Infallible;
 use malachite_bigint::{BigInt, Sign};
 use num_complex::Complex64;
 use rustpython_wtf8::Wtf8;
-use std::convert::Infallible;
 
 pub const FORMAT_VERSION: u32 = 4;
 
@@ -20,8 +20,8 @@ pub enum MarshalError {
     BadType,
 }
 
-impl std::fmt::Display for MarshalError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for MarshalError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::Eof => f.write_str("unexpected end of data"),
             Self::InvalidBytecode => f.write_str("invalid bytecode"),
@@ -32,15 +32,15 @@ impl std::fmt::Display for MarshalError {
     }
 }
 
-impl From<std::str::Utf8Error> for MarshalError {
-    fn from(_: std::str::Utf8Error) -> Self {
+impl From<core::str::Utf8Error> for MarshalError {
+    fn from(_: core::str::Utf8Error) -> Self {
         Self::InvalidUtf8
     }
 }
 
-impl std::error::Error for MarshalError {}
+impl core::error::Error for MarshalError {}
 
-type Result<T, E = MarshalError> = std::result::Result<T, E>;
+type Result<T, E = MarshalError> = core::result::Result<T, E>;
 
 #[repr(u8)]
 enum Type {
@@ -119,7 +119,7 @@ pub trait Read {
     }
 
     fn read_str(&mut self, len: u32) -> Result<&str> {
-        Ok(std::str::from_utf8(self.read_slice(len)?)?)
+        Ok(core::str::from_utf8(self.read_slice(len)?)?)
     }
 
     fn read_wtf8(&mut self, len: u32) -> Result<&Wtf8> {
@@ -147,7 +147,7 @@ pub(crate) trait ReadBorrowed<'a>: Read {
     fn read_slice_borrow(&mut self, n: u32) -> Result<&'a [u8]>;
 
     fn read_str_borrow(&mut self, len: u32) -> Result<&'a str> {
-        Ok(std::str::from_utf8(self.read_slice_borrow(len)?)?)
+        Ok(core::str::from_utf8(self.read_slice_borrow(len)?)?)
     }
 }
 
diff --git a/crates/compiler-core/src/mode.rs b/crates/compiler-core/src/mode.rs
index 35e9e77f590..f2b19d677be 100644
--- a/crates/compiler-core/src/mode.rs
+++ b/crates/compiler-core/src/mode.rs
@@ -7,7 +7,7 @@ pub enum Mode {
     BlockExpr,
 }
 
-impl std::str::FromStr for Mode {
+impl core::str::FromStr for Mode {
     type Err = ModeParseError;
 
     // To support `builtins.compile()` `mode` argument
@@ -25,8 +25,8 @@ impl std::str::FromStr for Mode {
 #[derive(Debug)]
 pub struct ModeParseError;
 
-impl std::fmt::Display for ModeParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for ModeParseError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, r#"mode must be "exec", "eval", or "single""#)
     }
 }
diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs
index 84e64f3c27f..7fa695c0c71 100644
--- a/crates/compiler/src/lib.rs
+++ b/crates/compiler/src/lib.rs
@@ -28,8 +28,8 @@ pub struct ParseError {
     pub source_path: String,
 }
 
-impl std::fmt::Display for ParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl ::core::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
         self.error.fmt(f)
     }
 }
diff --git a/crates/derive-impl/src/compile_bytecode.rs b/crates/derive-impl/src/compile_bytecode.rs
index cdcc89b9984..23c90690dad 100644
--- a/crates/derive-impl/src/compile_bytecode.rs
+++ b/crates/derive-impl/src/compile_bytecode.rs
@@ -58,11 +58,11 @@ pub trait Compiler {
         source: &str,
         mode: Mode,
         module_name: String,
-    ) -> Result<CodeObject, Box<dyn std::error::Error>>;
+    ) -> Result<CodeObject, Box<dyn core::error::Error>>;
 }
 
 impl CompilationSource {
-    fn compile_string<D: std::fmt::Display, F: FnOnce() -> D>(
+    fn compile_string<D: core::fmt::Display, F: FnOnce() -> D>(
         &self,
         source: &str,
         mode: Mode,
diff --git a/crates/derive-impl/src/from_args.rs b/crates/derive-impl/src/from_args.rs
index 4633c9b3aac..667f887e81c 100644
--- a/crates/derive-impl/src/from_args.rs
+++ b/crates/derive-impl/src/from_args.rs
@@ -18,7 +18,7 @@ enum ParameterKind {
 impl TryFrom<&Ident> for ParameterKind {
     type Error = ();
 
-    fn try_from(ident: &Ident) -> std::result::Result<Self, Self::Error> {
+    fn try_from(ident: &Ident) -> core::result::Result<Self, Self::Error> {
         Ok(match ident.to_string().as_str() {
             "positional" => Self::PositionalOnly,
             "any" => Self::PositionalOrKeyword,
@@ -105,12 +105,12 @@ impl ArgAttribute {
 impl TryFrom<&Field> for ArgAttribute {
     type Error = syn::Error;
 
-    fn try_from(field: &Field) -> std::result::Result<Self, Self::Error> {
+    fn try_from(field: &Field) -> core::result::Result<Self, Self::Error> {
         let mut pyarg_attrs = field
             .attrs
             .iter()
             .filter_map(Self::from_attribute)
-            .collect::<std::result::Result<Vec<_>, _>>()?;
+            .collect::<core::result::Result<Vec<_>, _>>()?;
 
         if pyarg_attrs.len() >= 2 {
             bail_span!(field, "Multiple pyarg attributes on field")
@@ -234,7 +234,7 @@ pub fn impl_from_args(input: DeriveInput) -> Result<TokenStream> {
             fn from_args(
                 vm: &::rustpython_vm::VirtualMachine,
                 args: &mut ::rustpython_vm::function::FuncArgs
-            ) -> ::std::result::Result<Self, ::rustpython_vm::function::ArgumentError> {
+            ) -> ::core::result::Result<Self, ::rustpython_vm::function::ArgumentError> {
                 Ok(Self { #fields })
             }
         }
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 55f9c769940..06bbc06cfb2 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -4,11 +4,11 @@ use crate::util::{
     ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, pyclass_ident_and_attrs,
     pyexception_ident_and_attrs, text_signature,
 };
+use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
 use quote::{ToTokens, quote, quote_spanned};
 use rustpython_doc::DB;
 use std::collections::{HashMap, HashSet};
-use std::str::FromStr;
 use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
 use syn_ext::ext::*;
 use syn_ext::types::*;
@@ -25,8 +25,8 @@ enum AttrName {
     Member,
 }
 
-impl std::fmt::Display for AttrName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for AttrName {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let s = match self {
             Self::Method => "pymethod",
             Self::ClassMethod => "pyclassmethod",
@@ -44,7 +44,7 @@ impl std::fmt::Display for AttrName {
 impl FromStr for AttrName {
     type Err = String;
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
         Ok(match s {
             "pymethod" => Self::Method,
             "pyclassmethod" => Self::ClassMethod,
@@ -1488,7 +1488,7 @@ impl ItemMeta for SlotItemMeta {
 
     fn from_nested<I>(item_ident: Ident, meta_ident: Ident, mut nested: I) -> Result<Self>
     where
-        I: std::iter::Iterator<Item = NestedMeta>,
+        I: core::iter::Iterator<Item = NestedMeta>,
     {
         let meta_map = if let Some(nested_meta) = nested.next() {
             match nested_meta {
diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
index 2d5ff7cb0c2..3689ac97fd8 100644
--- a/crates/derive-impl/src/pymodule.rs
+++ b/crates/derive-impl/src/pymodule.rs
@@ -5,10 +5,11 @@ use crate::util::{
     ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc, iter_use_idents,
     pyclass_ident_and_attrs, text_signature,
 };
+use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
 use quote::{ToTokens, quote, quote_spanned};
 use rustpython_doc::DB;
-use std::{collections::HashSet, str::FromStr};
+use std::collections::HashSet;
 use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
 use syn_ext::ext::*;
 use syn_ext::types::PunctuatedNestedMeta;
@@ -22,8 +23,8 @@ enum AttrName {
     StructSequence,
 }
 
-impl std::fmt::Display for AttrName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for AttrName {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let s = match self {
             Self::Function => "pyfunction",
             Self::Attr => "pyattr",
@@ -38,7 +39,7 @@ impl std::fmt::Display for AttrName {
 impl FromStr for AttrName {
     type Err = String;
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
         Ok(match s {
             "pyfunction" => Self::Function,
             "pyattr" => Self::Attr,
diff --git a/crates/derive-impl/src/pytraverse.rs b/crates/derive-impl/src/pytraverse.rs
index c5c4bbd2704..c4ec3823298 100644
--- a/crates/derive-impl/src/pytraverse.rs
+++ b/crates/derive-impl/src/pytraverse.rs
@@ -37,7 +37,7 @@ fn field_to_traverse_code(field: &Field) -> Result<TokenStream> {
         .attrs
         .iter()
         .filter_map(pytraverse_arg)
-        .collect::<std::result::Result<Vec<_>, _>>()?;
+        .collect::<core::result::Result<Vec<_>, _>>()?;
     let do_trace = if pytraverse_attrs.len() > 1 {
         bail_span!(
             field,
diff --git a/crates/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
index 379adc65b57..6be1fcdf7ad 100644
--- a/crates/derive-impl/src/util.rs
+++ b/crates/derive-impl/src/util.rs
@@ -97,7 +97,7 @@ pub(crate) struct ContentItemInner<T> {
 }
 
 pub(crate) trait ContentItem {
-    type AttrName: std::str::FromStr + std::fmt::Display;
+    type AttrName: core::str::FromStr + core::fmt::Display;
 
     fn inner(&self) -> &ContentItemInner<Self::AttrName>;
     fn index(&self) -> usize {
@@ -125,7 +125,7 @@ impl ItemMetaInner {
         allowed_names: &[&'static str],
     ) -> Result<Self>
     where
-        I: std::iter::Iterator<Item = NestedMeta>,
+        I: core::iter::Iterator<Item = NestedMeta>,
     {
         let (meta_map, lits) = nested.into_unique_map_and_lits(|path| {
             if let Some(ident) = path.get_ident() {
@@ -243,7 +243,7 @@ impl ItemMetaInner {
     pub fn _optional_list(
         &self,
         key: &str,
-    ) -> Result<Option<impl std::iter::Iterator<Item = &'_ NestedMeta>>> {
+    ) -> Result<Option<impl core::iter::Iterator<Item = &'_ NestedMeta>>> {
         let value = if let Some((_, meta)) = self.meta_map.get(key) {
             let Meta::List(MetaList {
                 path: _, nested, ..
@@ -269,7 +269,7 @@ pub(crate) trait ItemMeta: Sized {
 
     fn from_nested<I>(item_ident: Ident, meta_ident: Ident, nested: I) -> Result<Self>
     where
-        I: std::iter::Iterator<Item = NestedMeta>,
+        I: core::iter::Iterator<Item = NestedMeta>,
     {
         Ok(Self::from_inner(ItemMetaInner::from_nested(
             item_ident,
@@ -529,7 +529,7 @@ impl ExceptionItemMeta {
     }
 }
 
-impl std::ops::Deref for ExceptionItemMeta {
+impl core::ops::Deref for ExceptionItemMeta {
     type Target = ClassItemMeta;
     fn deref(&self) -> &Self::Target {
         &self.0
diff --git a/crates/derive/src/lib.rs b/crates/derive/src/lib.rs
index 655ad3b4c9e..5a3ff84c63a 100644
--- a/crates/derive/src/lib.rs
+++ b/crates/derive/src/lib.rs
@@ -274,7 +274,7 @@ impl derive_impl::Compiler for Compiler {
         source: &str,
         mode: rustpython_compiler::Mode,
         module_name: String,
-    ) -> Result<rustpython_compiler::CodeObject, Box<dyn std::error::Error>> {
+    ) -> Result<rustpython_compiler::CodeObject, Box<dyn core::error::Error>> {
         use rustpython_compiler::{CompileOpts, compile};
         Ok(compile(source, mode, &module_name, CompileOpts::default())?)
     }
diff --git a/crates/jit/src/lib.rs b/crates/jit/src/lib.rs
index 65ef87a62f6..1e278617661 100644
--- a/crates/jit/src/lib.rs
+++ b/crates/jit/src/lib.rs
@@ -1,11 +1,14 @@
 mod instructions;
 
+extern crate alloc;
+
+use alloc::fmt;
+use core::mem::ManuallyDrop;
 use cranelift::prelude::*;
 use cranelift_jit::{JITBuilder, JITModule};
 use cranelift_module::{FuncId, Linkage, Module, ModuleError};
 use instructions::FunctionCompiler;
 use rustpython_compiler_core::bytecode;
-use std::{fmt, mem::ManuallyDrop};
 
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
diff --git a/crates/literal/src/escape.rs b/crates/literal/src/escape.rs
index 6bdd94e9860..72ceaf60d5b 100644
--- a/crates/literal/src/escape.rs
+++ b/crates/literal/src/escape.rs
@@ -55,9 +55,9 @@ pub unsafe trait Escape {
     /// # Safety
     ///
     /// This string must only contain printable characters.
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result;
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result;
-    fn write_body(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result;
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result;
+    fn write_body(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         if self.changed() {
             self.write_body_slow(formatter)
         } else {
@@ -117,7 +117,7 @@ impl<'a> UnicodeEscape<'a> {
 pub struct StrRepr<'r, 'a>(&'r UnicodeEscape<'a>);
 
 impl StrRepr<'_, '_> {
-    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char(quote)?;
         self.0.write_body(formatter)?;
@@ -131,8 +131,8 @@ impl StrRepr<'_, '_> {
     }
 }
 
-impl std::fmt::Display for StrRepr<'_, '_> {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for StrRepr<'_, '_> {
+    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.write(formatter)
     }
 }
@@ -217,7 +217,7 @@ impl UnicodeEscape<'_> {
         ch: CodePoint,
         quote: Quote,
         formatter: &mut impl std::fmt::Write,
-    ) -> std::fmt::Result {
+    ) -> core::fmt::Result {
         let Some(ch) = ch.to_char() else {
             return write!(formatter, "\\u{:04x}", ch.to_u32());
         };
@@ -260,7 +260,7 @@ unsafe impl Escape for UnicodeEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         formatter.write_str(unsafe {
             // SAFETY: this function must be called only when source is printable characters (i.e. no surrogates)
             std::str::from_utf8_unchecked(self.source.as_bytes())
@@ -268,7 +268,7 @@ unsafe impl Escape for UnicodeEscape<'_> {
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         for ch in self.source.code_points() {
             Self::write_char(ch, self.layout().quote, formatter)?;
         }
@@ -378,7 +378,7 @@ impl AsciiEscape<'_> {
         }
     }
 
-    fn write_char(ch: u8, quote: Quote, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    fn write_char(ch: u8, quote: Quote, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         match ch {
             b'\t' => formatter.write_str("\\t"),
             b'\n' => formatter.write_str("\\n"),
@@ -404,7 +404,7 @@ unsafe impl Escape for AsciiEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         formatter.write_str(unsafe {
             // SAFETY: this function must be called only when source is printable ascii characters
             std::str::from_utf8_unchecked(self.source)
@@ -412,7 +412,7 @@ unsafe impl Escape for AsciiEscape<'_> {
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         for ch in self.source {
             Self::write_char(*ch, self.layout().quote, formatter)?;
         }
@@ -423,7 +423,7 @@ unsafe impl Escape for AsciiEscape<'_> {
 pub struct BytesRepr<'r, 'a>(&'r AsciiEscape<'a>);
 
 impl BytesRepr<'_, '_> {
-    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char('b')?;
         formatter.write_char(quote)?;
@@ -438,8 +438,8 @@ impl BytesRepr<'_, '_> {
     }
 }
 
-impl std::fmt::Display for BytesRepr<'_, '_> {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for BytesRepr<'_, '_> {
+    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.write(formatter)
     }
 }
diff --git a/crates/literal/src/float.rs b/crates/literal/src/float.rs
index e2bc54a8f1b..4d0d65cbb34 100644
--- a/crates/literal/src/float.rs
+++ b/crates/literal/src/float.rs
@@ -55,7 +55,7 @@ pub fn format_fixed(precision: usize, magnitude: f64, case: Case, alternate_form
     match magnitude {
         magnitude if magnitude.is_finite() => {
             let point = decimal_point_or_empty(precision, alternate_form);
-            let precision = std::cmp::min(precision, u16::MAX as usize);
+            let precision = core::cmp::min(precision, u16::MAX as usize);
             format!("{magnitude:.precision$}{point}")
         }
         magnitude if magnitude.is_nan() => format_nan(case),
diff --git a/crates/sre_engine/src/engine.rs b/crates/sre_engine/src/engine.rs
index 9cc2e4788a5..f1f25a2d920 100644
--- a/crates/sre_engine/src/engine.rs
+++ b/crates/sre_engine/src/engine.rs
@@ -6,8 +6,8 @@ use crate::string::{
 };
 
 use super::{MAXREPEAT, SreAtCode, SreCatCode, SreInfo, SreOpcode, StrDrive, StringCursor};
+use core::{convert::TryFrom, ptr::null};
 use optional::Optioned;
-use std::{convert::TryFrom, ptr::null};
 
 #[derive(Debug, Clone, Copy)]
 pub struct Request<'a, S> {
@@ -27,8 +27,8 @@ impl<'a, S: StrDrive> Request<'a, S> {
         pattern_codes: &'a [u32],
         match_all: bool,
     ) -> Self {
-        let end = std::cmp::min(end, string.count());
-        let start = std::cmp::min(start, end);
+        let end = core::cmp::min(end, string.count());
+        let start = core::cmp::min(start, end);
 
         Self {
             string,
@@ -1332,7 +1332,7 @@ fn _count<S: StrDrive>(
     ctx: &mut MatchContext,
     max_count: usize,
 ) -> usize {
-    let max_count = std::cmp::min(max_count, ctx.remaining_chars(req));
+    let max_count = core::cmp::min(max_count, ctx.remaining_chars(req));
     let end = ctx.cursor.position + max_count;
     let opcode = SreOpcode::try_from(ctx.peek_code(req, 0)).unwrap();
 
diff --git a/crates/sre_engine/src/string.rs b/crates/sre_engine/src/string.rs
index 0d3325b6a1d..489819bfb3e 100644
--- a/crates/sre_engine/src/string.rs
+++ b/crates/sre_engine/src/string.rs
@@ -9,7 +9,7 @@ pub struct StringCursor {
 impl Default for StringCursor {
     fn default() -> Self {
         Self {
-            ptr: std::ptr::null(),
+            ptr: core::ptr::null(),
             position: 0,
         }
     }
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index b51bc02d3fb..b7a6fbd8b4f 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -68,11 +68,12 @@ mod array {
             },
         },
     };
+    use alloc::fmt;
+    use core::cmp::Ordering;
     use itertools::Itertools;
     use num_traits::ToPrimitive;
     use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-    use std::{cmp::Ordering, fmt, os::raw};
-
+    use std::os::raw;
     macro_rules! def_array_enum {
         ($(($n:ident, $t:ty, $c:literal, $scode:literal)),*$(,)?) => {
             #[derive(Debug, Clone)]
@@ -104,14 +105,14 @@ mod array {
 
                 const fn itemsize_of_typecode(c: char) -> Option<usize> {
                     match c {
-                        $($c => Some(std::mem::size_of::<$t>()),)*
+                        $($c => Some(core::mem::size_of::<$t>()),)*
                         _ => None,
                     }
                 }
 
                 const fn itemsize(&self) -> usize {
                     match self {
-                        $(ArrayContentType::$n(_) => std::mem::size_of::<$t>(),)*
+                        $(ArrayContentType::$n(_) => core::mem::size_of::<$t>(),)*
                     }
                 }
 
@@ -201,10 +202,10 @@ mod array {
                             if v.is_empty() {
                                 // safe because every configuration of bytes for the types we
                                 // support are valid
-                                let b = std::mem::ManuallyDrop::new(b);
+                                let b = core::mem::ManuallyDrop::new(b);
                                 let ptr = b.as_ptr() as *mut $t;
-                                let len = b.len() / std::mem::size_of::<$t>();
-                                let capacity = b.capacity() / std::mem::size_of::<$t>();
+                                let len = b.len() / core::mem::size_of::<$t>();
+                                let capacity = b.capacity() / core::mem::size_of::<$t>();
                                 *v = unsafe { Vec::from_raw_parts(ptr, len, capacity) };
                             } else {
                                 self.frombytes(&b);
@@ -220,8 +221,8 @@ mod array {
                             // support are valid
                             if b.len() > 0 {
                                 let ptr = b.as_ptr() as *const $t;
-                                let ptr_len = b.len() / std::mem::size_of::<$t>();
-                                let slice = unsafe { std::slice::from_raw_parts(ptr, ptr_len) };
+                                let ptr_len = b.len() / core::mem::size_of::<$t>();
+                                let slice = unsafe { core::slice::from_raw_parts(ptr, ptr_len) };
                                 v.extend_from_slice(slice);
                             }
                         })*
@@ -249,8 +250,8 @@ mod array {
                         $(ArrayContentType::$n(v) => {
                             // safe because we're just reading memory as bytes
                             let ptr = v.as_ptr() as *const u8;
-                            let ptr_len = v.len() * std::mem::size_of::<$t>();
-                            unsafe { std::slice::from_raw_parts(ptr, ptr_len) }
+                            let ptr_len = v.len() * core::mem::size_of::<$t>();
+                            unsafe { core::slice::from_raw_parts(ptr, ptr_len) }
                         })*
                     }
                 }
@@ -260,8 +261,8 @@ mod array {
                         $(ArrayContentType::$n(v) => {
                             // safe because we're just reading memory as bytes
                             let ptr = v.as_ptr() as *mut u8;
-                            let ptr_len = v.len() * std::mem::size_of::<$t>();
-                            unsafe { std::slice::from_raw_parts_mut(ptr, ptr_len) }
+                            let ptr_len = v.len() * core::mem::size_of::<$t>();
+                            unsafe { core::slice::from_raw_parts_mut(ptr, ptr_len) }
                         })*
                     }
                 }
@@ -785,18 +786,18 @@ mod array {
             if item_size == 2 {
                 // safe because every configuration of bytes for the types we support are valid
                 let utf16 = unsafe {
-                    std::slice::from_raw_parts(
+                    core::slice::from_raw_parts(
                         bytes.as_ptr() as *const u16,
-                        bytes.len() / std::mem::size_of::<u16>(),
+                        bytes.len() / core::mem::size_of::<u16>(),
                     )
                 };
                 Ok(Wtf8Buf::from_wide(utf16))
             } else {
                 // safe because every configuration of bytes for the types we support are valid
                 let chars = unsafe {
-                    std::slice::from_raw_parts(
+                    core::slice::from_raw_parts(
                         bytes.as_ptr() as *const u32,
-                        bytes.len() / std::mem::size_of::<u32>(),
+                        bytes.len() / core::mem::size_of::<u32>(),
                     )
                 };
                 chars
@@ -1516,7 +1517,7 @@ mod array {
 
     impl MachineFormatCode {
         fn from_typecode(code: char) -> Option<Self> {
-            use std::mem::size_of;
+            use core::mem::size_of;
             let signed = code.is_ascii_uppercase();
             let big_endian = cfg!(target_endian = "big");
             let int_size = match code {
@@ -1590,7 +1591,7 @@ mod array {
 
     macro_rules! chunk_to_obj {
         ($BYTE:ident, $TY:ty, $BIG_ENDIAN:ident) => {{
-            let b = <[u8; ::std::mem::size_of::<$TY>()]>::try_from($BYTE).unwrap();
+            let b = <[u8; ::core::mem::size_of::<$TY>()]>::try_from($BYTE).unwrap();
             if $BIG_ENDIAN {
                 <$TY>::from_be_bytes(b)
             } else {
@@ -1601,7 +1602,7 @@ mod array {
             chunk_to_obj!($BYTE, $TY, $BIG_ENDIAN).to_pyobject($VM)
         };
         ($VM:ident, $BYTE:ident, $SIGNED_TY:ty, $UNSIGNED_TY:ty, $SIGNED:ident, $BIG_ENDIAN:ident) => {{
-            let b = <[u8; ::std::mem::size_of::<$SIGNED_TY>()]>::try_from($BYTE).unwrap();
+            let b = <[u8; ::core::mem::size_of::<$SIGNED_TY>()]>::try_from($BYTE).unwrap();
             match ($SIGNED, $BIG_ENDIAN) {
                 (false, false) => <$UNSIGNED_TY>::from_le_bytes(b).to_pyobject($VM),
                 (false, true) => <$UNSIGNED_TY>::from_be_bytes(b).to_pyobject($VM),
diff --git a/crates/stdlib/src/binascii.rs b/crates/stdlib/src/binascii.rs
index a2316d3c204..671d1d9e253 100644
--- a/crates/stdlib/src/binascii.rs
+++ b/crates/stdlib/src/binascii.rs
@@ -359,7 +359,7 @@ mod decl {
                     }
                     _ => unsafe {
                         // quad_pos is only assigned in this match statement to constants
-                        std::hint::unreachable_unchecked()
+                        core::hint::unreachable_unchecked()
                     },
                 }
             }
diff --git a/crates/stdlib/src/bz2.rs b/crates/stdlib/src/bz2.rs
index a2a40953cff..93142e92a68 100644
--- a/crates/stdlib/src/bz2.rs
+++ b/crates/stdlib/src/bz2.rs
@@ -15,9 +15,10 @@ mod _bz2 {
         object::PyResult,
         types::Constructor,
     };
+    use alloc::fmt;
     use bzip2::{Decompress, Status, write::BzEncoder};
     use rustpython_vm::convert::ToPyException;
-    use std::{fmt, io::Write};
+    use std::io::Write;
 
     const BUFSIZ: usize = 8192;
 
diff --git a/crates/stdlib/src/cmath.rs b/crates/stdlib/src/cmath.rs
index e5d1d55a578..7f975e41719 100644
--- a/crates/stdlib/src/cmath.rs
+++ b/crates/stdlib/src/cmath.rs
@@ -11,7 +11,7 @@ mod cmath {
 
     // Constants
     #[pyattr]
-    use std::f64::consts::{E as e, PI as pi, TAU as tau};
+    use core::f64::consts::{E as e, PI as pi, TAU as tau};
     #[pyattr(name = "inf")]
     const INF: f64 = f64::INFINITY;
     #[pyattr(name = "nan")]
@@ -93,7 +93,7 @@ mod cmath {
         z.log(
             base.into_option()
                 .map(|base| base.re)
-                .unwrap_or(std::f64::consts::E),
+                .unwrap_or(core::f64::consts::E),
         )
     }
 
diff --git a/crates/stdlib/src/compression.rs b/crates/stdlib/src/compression.rs
index 7f4e3432eab..a857b4e53de 100644
--- a/crates/stdlib/src/compression.rs
+++ b/crates/stdlib/src/compression.rs
@@ -107,7 +107,7 @@ impl<'a> Chunker<'a> {
     pub fn advance(&mut self, consumed: usize) {
         self.data1 = &self.data1[consumed..];
         if self.data1.is_empty() {
-            self.data1 = std::mem::take(&mut self.data2);
+            self.data1 = core::mem::take(&mut self.data2);
         }
     }
 }
@@ -140,7 +140,7 @@ pub fn _decompress_chunks<D: Decompressor>(
         let chunk = data.chunk();
         let flush = calc_flush(chunk.len() == data.len());
         loop {
-            let additional = std::cmp::min(bufsize, max_length - buf.capacity());
+            let additional = core::cmp::min(bufsize, max_length - buf.capacity());
             if additional == 0 {
                 return Ok((buf, false));
             }
diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index f88ce398c1c..731f5d11e0b 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -1,6 +1,6 @@
 use crate::vm::{PyRef, VirtualMachine, builtins::PyModule, class::StaticType};
 use _contextvars::PyContext;
-use std::cell::RefCell;
+use core::cell::RefCell;
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _contextvars::make_module(vm);
@@ -31,13 +31,13 @@ mod _contextvars {
         protocol::{PyMappingMethods, PySequenceMethods},
         types::{AsMapping, AsSequence, Constructor, Hashable, Representable},
     };
-    use crossbeam_utils::atomic::AtomicCell;
-    use indexmap::IndexMap;
-    use std::sync::LazyLock;
-    use std::{
+    use core::{
         cell::{Cell, RefCell, UnsafeCell},
         sync::atomic::Ordering,
     };
+    use crossbeam_utils::atomic::AtomicCell;
+    use indexmap::IndexMap;
+    use std::sync::LazyLock;
 
     // TODO: Real hamt implementation
     type Hamt = IndexMap<PyRef<ContextVar>, PyObjectRef, ahash::RandomState>;
@@ -90,11 +90,11 @@ mod _contextvars {
             }
         }
 
-        fn borrow_vars(&self) -> impl std::ops::Deref<Target = Hamt> + '_ {
+        fn borrow_vars(&self) -> impl core::ops::Deref<Target = Hamt> + '_ {
             self.inner.vars.hamt.borrow()
         }
 
-        fn borrow_vars_mut(&self) -> impl std::ops::DerefMut<Target = Hamt> + '_ {
+        fn borrow_vars_mut(&self) -> impl core::ops::DerefMut<Target = Hamt> + '_ {
             self.inner.vars.hamt.borrow_mut()
         }
 
@@ -293,13 +293,13 @@ mod _contextvars {
         #[pytraverse(skip)]
         cached: AtomicCell<Option<ContextVarCache>>,
         #[pytraverse(skip)]
-        cached_id: std::sync::atomic::AtomicUsize, // cached_tsid in CPython
+        cached_id: core::sync::atomic::AtomicUsize, // cached_tsid in CPython
         #[pytraverse(skip)]
         hash: UnsafeCell<PyHash>,
     }
 
-    impl std::fmt::Debug for ContextVar {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for ContextVar {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("ContextVar").finish()
         }
     }
@@ -308,7 +308,7 @@ mod _contextvars {
 
     impl PartialEq for ContextVar {
         fn eq(&self, other: &Self) -> bool {
-            std::ptr::eq(self, other)
+            core::ptr::eq(self, other)
         }
     }
     impl Eq for ContextVar {}
@@ -512,9 +512,9 @@ mod _contextvars {
         }
     }
 
-    impl std::hash::Hash for ContextVar {
+    impl core::hash::Hash for ContextVar {
         #[inline]
-        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
             unsafe { *self.hash.get() }.hash(state)
         }
     }
diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
index a62594a9f1b..4f6cbd76828 100644
--- a/crates/stdlib/src/csv.rs
+++ b/crates/stdlib/src/csv.rs
@@ -12,12 +12,13 @@ mod _csv {
         raise_if_stop,
         types::{Constructor, IterNext, Iterable, SelfIter},
     };
+    use alloc::fmt;
     use csv_core::Terminator;
     use itertools::{self, Itertools};
     use parking_lot::Mutex;
     use rustpython_vm::match_class;
+    use std::collections::HashMap;
     use std::sync::LazyLock;
-    use std::{collections::HashMap, fmt};
 
     #[pyattr]
     const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32;
@@ -1006,7 +1007,7 @@ mod _csv {
                         return Err(new_csv_error(vm, "filed too long to read".to_string()));
                     }
                     prev_end = end;
-                    let s = std::str::from_utf8(&buffer[range.clone()])
+                    let s = core::str::from_utf8(&buffer[range.clone()])
                         // not sure if this is possible - the input was all strings
                         .map_err(|_e| vm.new_unicode_decode_error("csv not utf8"))?;
                     // Rustpython TODO!
@@ -1116,7 +1117,7 @@ mod _csv {
             loop {
                 handle_res!(writer.terminator(&mut buffer[buffer_offset..]));
             }
-            let s = std::str::from_utf8(&buffer[..buffer_offset])
+            let s = core::str::from_utf8(&buffer[..buffer_offset])
                 .map_err(|_| vm.new_unicode_decode_error("csv not utf8"))?;
 
             self.write.call((s,), vm)
diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
index f45c9909c6f..eba5643b866 100644
--- a/crates/stdlib/src/faulthandler.rs
+++ b/crates/stdlib/src/faulthandler.rs
@@ -7,13 +7,13 @@ mod decl {
         PyObjectRef, PyResult, VirtualMachine, builtins::PyFloat, frame::Frame,
         function::OptionalArg, py_io::Write,
     };
+    use alloc::sync::Arc;
+    use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
+    use core::time::Duration;
     use parking_lot::{Condvar, Mutex};
     #[cfg(any(unix, windows))]
     use rustpython_common::os::{get_errno, set_errno};
-    use std::sync::Arc;
-    use std::sync::atomic::{AtomicBool, AtomicI32, Ordering};
     use std::thread;
-    use std::time::Duration;
 
     /// fault_handler_t
     #[cfg(unix)]
@@ -40,7 +40,7 @@ mod decl {
                 enabled: false,
                 name,
                 // SAFETY: sigaction is a C struct that can be zero-initialized
-                previous: unsafe { std::mem::zeroed() },
+                previous: unsafe { core::mem::zeroed() },
             }
         }
     }
@@ -144,7 +144,8 @@ mod decl {
     static mut FRAME_SNAPSHOTS: [FrameSnapshot; MAX_SNAPSHOT_FRAMES] =
         [FrameSnapshot::EMPTY; MAX_SNAPSHOT_FRAMES];
     #[cfg(any(unix, windows))]
-    static SNAPSHOT_COUNT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+    static SNAPSHOT_COUNT: core::sync::atomic::AtomicUsize =
+        core::sync::atomic::AtomicUsize::new(0);
 
     // Signal-safe output functions
 
@@ -240,7 +241,7 @@ mod decl {
         }
         let thread_id = current_thread_id();
         // Use appropriate width based on platform pointer size
-        dump_hexadecimal(fd, thread_id, std::mem::size_of::<usize>() * 2);
+        dump_hexadecimal(fd, thread_id, core::mem::size_of::<usize>() * 2);
         puts(fd, " (most recent call first):\n");
     }
 
@@ -429,7 +430,7 @@ mod decl {
         }
         handler.enabled = false;
         unsafe {
-            libc::sigaction(handler.signum, &handler.previous, std::ptr::null_mut());
+            libc::sigaction(handler.signum, &handler.previous, core::ptr::null_mut());
         }
     }
 
@@ -549,7 +550,7 @@ mod decl {
                     continue;
                 }
 
-                let mut action: libc::sigaction = std::mem::zeroed();
+                let mut action: libc::sigaction = core::mem::zeroed();
                 action.sa_sigaction = faulthandler_fatal_error as libc::sighandler_t;
                 // SA_NODEFER flag
                 action.sa_flags = libc::SA_NODEFER;
@@ -1051,8 +1052,8 @@ mod decl {
         #[cfg(not(target_arch = "wasm32"))]
         unsafe {
             suppress_crash_report();
-            let ptr: *const i32 = std::ptr::null();
-            std::ptr::read_volatile(ptr);
+            let ptr: *const i32 = core::ptr::null();
+            core::ptr::read_volatile(ptr);
         }
     }
 
@@ -1132,7 +1133,7 @@ mod decl {
                 panic!("Fatal Python error: in new thread");
             });
             // Wait a bit for the thread to panic
-            std::thread::sleep(std::time::Duration::from_secs(1));
+            std::thread::sleep(core::time::Duration::from_secs(1));
         }
     }
 
@@ -1203,7 +1204,7 @@ mod decl {
 
         suppress_crash_report();
         unsafe {
-            RaiseException(args.code, args.flags, 0, std::ptr::null());
+            RaiseException(args.code, args.flags, 0, core::ptr::null());
         }
     }
 }
diff --git a/crates/stdlib/src/fcntl.rs b/crates/stdlib/src/fcntl.rs
index dc6a0b8171e..822faeeedaa 100644
--- a/crates/stdlib/src/fcntl.rs
+++ b/crates/stdlib/src/fcntl.rs
@@ -173,7 +173,7 @@ mod fcntl {
             };
         }
 
-        let mut l: libc::flock = unsafe { std::mem::zeroed() };
+        let mut l: libc::flock = unsafe { core::mem::zeroed() };
         l.l_type = if cmd == libc::LOCK_UN {
             try_into_l_type!(libc::F_UNLCK)
         } else if (cmd & libc::LOCK_SH) != 0 {
diff --git a/crates/stdlib/src/grp.rs b/crates/stdlib/src/grp.rs
index 4664d5fc575..9f7e4195509 100644
--- a/crates/stdlib/src/grp.rs
+++ b/crates/stdlib/src/grp.rs
@@ -10,8 +10,8 @@ mod grp {
         exceptions,
         types::PyStructSequence,
     };
+    use core::ptr::NonNull;
     use nix::unistd;
-    use std::ptr::NonNull;
 
     #[pystruct_sequence_data]
     struct GroupData {
@@ -30,7 +30,7 @@ mod grp {
 
     impl GroupData {
         fn from_unistd_group(group: unistd::Group, vm: &VirtualMachine) -> Self {
-            let cstr_lossy = |s: std::ffi::CString| {
+            let cstr_lossy = |s: alloc::ffi::CString| {
                 s.into_string()
                     .unwrap_or_else(|e| e.into_cstring().to_string_lossy().into_owned())
             };
diff --git a/crates/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
index bfde58f43f7..2da47ceb740 100644
--- a/crates/stdlib/src/hashlib.rs
+++ b/crates/stdlib/src/hashlib.rs
@@ -97,8 +97,8 @@ pub mod _hashlib {
         pub ctx: PyRwLock<HashWrapper>,
     }
 
-    impl std::fmt::Debug for PyHasher {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for PyHasher {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "HASH {}", self.name)
         }
     }
@@ -170,8 +170,8 @@ pub mod _hashlib {
         ctx: PyRwLock<HashXofWrapper>,
     }
 
-    impl std::fmt::Debug for PyHasherXof {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for PyHasherXof {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "HASHXOF {}", self.name)
         }
     }
diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
index eb6ed3a5f64..a3fd7972126 100644
--- a/crates/stdlib/src/json.rs
+++ b/crates/stdlib/src/json.rs
@@ -12,9 +12,9 @@ mod _json {
         protocol::PyIterReturn,
         types::{Callable, Constructor},
     };
+    use core::str::FromStr;
     use malachite_bigint::BigInt;
     use rustpython_common::wtf8::Wtf8Buf;
-    use std::str::FromStr;
 
     #[pyattr(name = "make_scanner")]
     #[pyclass(name = "Scanner", traverse)]
@@ -216,7 +216,7 @@ mod _json {
         let mut buf = Vec::<u8>::with_capacity(s.len() + 2);
         machinery::write_json_string(s, ascii_only, &mut buf)
             // SAFETY: writing to a vec can't fail
-            .unwrap_or_else(|_| unsafe { std::hint::unreachable_unchecked() });
+            .unwrap_or_else(|_| unsafe { core::hint::unreachable_unchecked() });
         // SAFETY: we only output valid utf8 from write_json_string
         unsafe { String::from_utf8_unchecked(buf) }
     }
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
index 4b463e09c73..6b7796c8bad 100644
--- a/crates/stdlib/src/lib.rs
+++ b/crates/stdlib/src/lib.rs
@@ -6,6 +6,7 @@
 
 #[macro_use]
 extern crate rustpython_derive;
+extern crate alloc;
 
 pub mod array;
 mod binascii;
@@ -103,7 +104,7 @@ use rustpython_common as common;
 use rustpython_vm as vm;
 
 use crate::vm::{builtins, stdlib::StdlibInitFunc};
-use std::borrow::Cow;
+use alloc::borrow::Cow;
 
 pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInitFunc)> {
     macro_rules! modules {
diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
index 6cca8b9123b..c65f861d208 100644
--- a/crates/stdlib/src/locale.rs
+++ b/crates/stdlib/src/locale.rs
@@ -41,16 +41,14 @@ use libc::localeconv;
 
 #[pymodule]
 mod _locale {
+    use alloc::ffi::CString;
+    use core::{ffi::CStr, ptr};
     use rustpython_vm::{
         PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyDictRef, PyIntRef, PyListRef, PyStrRef, PyTypeRef},
         convert::ToPyException,
         function::OptionalArg,
     };
-    use std::{
-        ffi::{CStr, CString},
-        ptr,
-    };
 
     #[cfg(all(
         unix,
diff --git a/crates/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
index 855a5eae562..b18ac3ee69a 100644
--- a/crates/stdlib/src/lzma.rs
+++ b/crates/stdlib/src/lzma.rs
@@ -8,6 +8,7 @@ mod _lzma {
         CompressFlushKind, CompressState, CompressStatusKind, Compressor, DecompressArgs,
         DecompressError, DecompressState, DecompressStatus, Decompressor,
     };
+    use alloc::fmt;
     #[pyattr]
     use lzma_sys::{
         LZMA_CHECK_CRC32 as CHECK_CRC32, LZMA_CHECK_CRC64 as CHECK_CRC64,
@@ -38,7 +39,6 @@ mod _lzma {
     use rustpython_vm::function::ArgBytesLike;
     use rustpython_vm::types::Constructor;
     use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-    use std::fmt;
     use xz2::stream::{Action, Check, Error, Filters, LzmaOptions, Status, Stream};
 
     #[cfg(windows)]
diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
index 62b0ef73ad3..6e139530804 100644
--- a/crates/stdlib/src/math.rs
+++ b/crates/stdlib/src/math.rs
@@ -10,15 +10,15 @@ mod math {
         function::{ArgIndex, ArgIntoFloat, ArgIterable, Either, OptionalArg, PosArgs},
         identifier,
     };
+    use core::cmp::Ordering;
     use itertools::Itertools;
     use malachite_bigint::BigInt;
     use num_traits::{One, Signed, ToPrimitive, Zero};
     use rustpython_common::{float_ops, int::true_div};
-    use std::cmp::Ordering;
 
     // Constants
     #[pyattr]
-    use std::f64::consts::{E as e, PI as pi, TAU as tau};
+    use core::f64::consts::{E as e, PI as pi, TAU as tau};
 
     use super::pymath_error_to_exception;
     #[pyattr(name = "inf")]
@@ -136,7 +136,7 @@ mod math {
 
     #[pyfunction]
     fn log(x: PyObjectRef, base: OptionalArg<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let base = base.map(|b| *b).unwrap_or(std::f64::consts::E);
+        let base = base.map(|b| *b).unwrap_or(core::f64::consts::E);
         if base.is_sign_negative() {
             return Err(vm.new_value_error("math domain error"));
         }
@@ -359,9 +359,9 @@ mod math {
                 .iter()
                 .copied()
                 .map(|x| (x / scale).powi(2))
-                .chain(std::iter::once(-norm * norm))
+                .chain(core::iter::once(-norm * norm))
                 // Pairwise summation of floats gives less rounding error than a naive sum.
-                .tree_reduce(std::ops::Add::add)
+                .tree_reduce(core::ops::Add::add)
                 .expect("expected at least 1 element");
             norm = norm + correction / (2.0 * norm);
         }
@@ -424,12 +424,12 @@ mod math {
 
     #[pyfunction]
     fn degrees(x: ArgIntoFloat) -> f64 {
-        *x * (180.0 / std::f64::consts::PI)
+        *x * (180.0 / core::f64::consts::PI)
     }
 
     #[pyfunction]
     fn radians(x: ArgIntoFloat) -> f64 {
-        *x * (std::f64::consts::PI / 180.0)
+        *x * (core::f64::consts::PI / 180.0)
     }
 
     // Hyperbolic functions:
@@ -684,7 +684,7 @@ mod math {
             for j in 0..partials.len() {
                 let mut y: f64 = partials[j];
                 if x.abs() < y.abs() {
-                    std::mem::swap(&mut x, &mut y);
+                    core::mem::swap(&mut x, &mut y);
                 }
                 // Rounded `x+y` is stored in `hi` with round-off stored in
                 // `lo`. Together `hi+lo` are exactly equal to `x+y`.
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
index f1e2c2a039d..b520eb2a1a7 100644
--- a/crates/stdlib/src/mmap.rs
+++ b/crates/stdlib/src/mmap.rs
@@ -21,11 +21,11 @@ mod mmap {
         sliceable::{SaturatedSlice, SequenceIndex, SequenceIndexOp},
         types::{AsBuffer, AsMapping, AsSequence, Constructor, Representable},
     };
+    use core::ops::{Deref, DerefMut};
     use crossbeam_utils::atomic::AtomicCell;
     use memmap2::{Mmap, MmapMut, MmapOptions};
     use num_traits::Signed;
     use std::io::{self, Write};
-    use std::ops::{Deref, DerefMut};
 
     #[cfg(unix)]
     use nix::{sys::stat::fstat, unistd};
@@ -1057,7 +1057,7 @@ mod mmap {
                 // 3. Replace the old mmap
 
                 let old_size = self.size.load();
-                let copy_size = std::cmp::min(old_size, newsize);
+                let copy_size = core::cmp::min(old_size, newsize);
 
                 // Create new anonymous mmap
                 let mut new_mmap_opts = MmapOptions::new();
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index c355b59df91..bd4b9aa750a 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -8,7 +8,7 @@ mod opcode {
         bytecode::Instruction,
         match_class,
     };
-    use std::ops::Deref;
+    use core::ops::Deref;
 
     struct Opcode(Instruction);
 
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index d352d15a614..38103a9ab05 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -522,10 +522,10 @@ mod _ssl {
     // Thread-local storage for VirtualMachine pointer during handshake
     // SNI callback is only called during handshake which is synchronous
     thread_local! {
-        static HANDSHAKE_VM: std::cell::Cell<Option<*const VirtualMachine>> = const { std::cell::Cell::new(None) };
+        static HANDSHAKE_VM: core::cell::Cell<Option<*const VirtualMachine>> = const { core::cell::Cell::new(None) };
         // SSL pointer during handshake - needed because connection lock is held during handshake
         // and callbacks may need to access SSL without acquiring the lock
-        static HANDSHAKE_SSL_PTR: std::cell::Cell<Option<*mut sys::SSL>> = const { std::cell::Cell::new(None) };
+        static HANDSHAKE_SSL_PTR: core::cell::Cell<Option<*mut sys::SSL>> = const { core::cell::Cell::new(None) };
     }
 
     // RAII guard to set/clear thread-local handshake context
@@ -1896,7 +1896,7 @@ mod _ssl {
                                                 )));
                                             return Err(openssl::error::ErrorStack::get());
                                         }
-                                        let len = std::cmp::min(pw.len(), buf.len());
+                                        let len = core::cmp::min(pw.len(), buf.len());
                                         buf[..len].copy_from_slice(&pw[..len]);
                                         Ok(len)
                                     }
@@ -2714,7 +2714,7 @@ mod _ssl {
                 // Use thread-local SSL pointer during handshake to avoid deadlock
                 let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
                 unsafe {
-                    let mut out: *const libc::c_uchar = std::ptr::null();
+                    let mut out: *const libc::c_uchar = core::ptr::null();
                     let mut outlen: libc::c_uint = 0;
 
                     sys::SSL_get0_alpn_selected(ssl_ptr, &mut out, &mut outlen);
diff --git a/crates/stdlib/src/overlapped.rs b/crates/stdlib/src/overlapped.rs
index d8f14baf35e..1c74ee271b9 100644
--- a/crates/stdlib/src/overlapped.rs
+++ b/crates/stdlib/src/overlapped.rs
@@ -35,7 +35,7 @@ mod _overlapped {
 
     #[pyattr]
     const INVALID_HANDLE_VALUE: isize =
-        unsafe { std::mem::transmute(windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE) };
+        unsafe { core::mem::transmute(windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE) };
 
     #[pyattr]
     const NULL: isize = 0;
@@ -57,8 +57,8 @@ mod _overlapped {
     unsafe impl Sync for OverlappedInner {}
     unsafe impl Send for OverlappedInner {}
 
-    impl std::fmt::Debug for Overlapped {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for Overlapped {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             let zelf = self.inner.lock();
             f.debug_struct("Overlapped")
                 // .field("overlapped", &(self.overlapped as *const _ as usize))
@@ -98,8 +98,8 @@ mod _overlapped {
         address_length: libc::c_int,
     }
 
-    impl std::fmt::Debug for OverlappedReadFrom {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for OverlappedReadFrom {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("OverlappedReadFrom")
                 .field("result", &self.result)
                 .field("allocated_buffer", &self.allocated_buffer)
@@ -119,8 +119,8 @@ mod _overlapped {
         address_length: libc::c_int,
     }
 
-    impl std::fmt::Debug for OverlappedReadFromInto {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for OverlappedReadFromInto {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("OverlappedReadFromInto")
                 .field("result", &self.result)
                 .field("user_buffer", &self.user_buffer)
@@ -226,7 +226,7 @@ mod _overlapped {
             }
 
             #[cfg(target_pointer_width = "32")]
-            let size = std::cmp::min(size, std::isize::MAX as _);
+            let size = core::cmp::min(size, std::isize::MAX as _);
 
             let buf = vec![0u8; std::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
@@ -272,10 +272,10 @@ mod _overlapped {
             if event == INVALID_HANDLE_VALUE {
                 event = unsafe {
                     windows_sys::Win32::System::Threading::CreateEventA(
-                        std::ptr::null(),
+                        core::ptr::null(),
                         Foundation::TRUE,
                         Foundation::FALSE,
-                        std::ptr::null(),
+                        core::ptr::null(),
                     ) as isize
                 };
                 if event == NULL {
@@ -378,11 +378,11 @@ mod _overlapped {
                 let name = widestring::WideCString::from_str(&name).unwrap();
                 name.as_ptr()
             }
-            None => std::ptr::null(),
+            None => core::ptr::null(),
         };
         let event = unsafe {
             windows_sys::Win32::System::Threading::CreateEventW(
-                std::ptr::null(),
+                core::ptr::null(),
                 manual_reset as _,
                 initial_state as _,
                 name,
diff --git a/crates/stdlib/src/posixshmem.rs b/crates/stdlib/src/posixshmem.rs
index 2957f16792c..53bf372532d 100644
--- a/crates/stdlib/src/posixshmem.rs
+++ b/crates/stdlib/src/posixshmem.rs
@@ -4,7 +4,7 @@ pub(crate) use _posixshmem::make_module;
 #[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
 #[pymodule]
 mod _posixshmem {
-    use std::ffi::CString;
+    use alloc::ffi::CString;
 
     use crate::{
         common::os::errno_io_error,
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
index 4b895d2102b..1ebf6619c24 100644
--- a/crates/stdlib/src/posixsubprocess.rs
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -13,15 +13,15 @@ use nix::{
     unistd::{self, Pid},
 };
 use std::{
-    convert::Infallible as Never,
-    ffi::{CStr, CString},
     io::prelude::*,
-    marker::PhantomData,
-    ops::Deref,
     os::fd::{AsFd, AsRawFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd},
 };
 use unistd::{Gid, Uid};
 
+use alloc::ffi::CString;
+
+use core::{convert::Infallible as Never, ffi::CStr, marker::PhantomData, ops::Deref};
+
 pub(crate) use _posixsubprocess::make_module;
 
 #[pymodule]
@@ -87,7 +87,7 @@ impl<'a, T: AsRef<CStr>> FromIterator<&'a T> for CharPtrVec<'a> {
         let vec = iter
             .into_iter()
             .map(|x| x.as_ref().as_ptr())
-            .chain(std::iter::once(std::ptr::null()))
+            .chain(core::iter::once(core::ptr::null()))
             .collect();
         Self {
             vec,
diff --git a/crates/stdlib/src/resource.rs b/crates/stdlib/src/resource.rs
index 052f45e0cad..e6df75e4b01 100644
--- a/crates/stdlib/src/resource.rs
+++ b/crates/stdlib/src/resource.rs
@@ -9,7 +9,8 @@ mod resource {
         convert::{ToPyException, ToPyObject},
         types::PyStructSequence,
     };
-    use std::{io, mem};
+    use core::mem;
+    use std::io;
 
     cfg_if::cfg_if! {
         if #[cfg(target_os = "android")] {
diff --git a/crates/stdlib/src/scproxy.rs b/crates/stdlib/src/scproxy.rs
index 1974e7814ae..40267579029 100644
--- a/crates/stdlib/src/scproxy.rs
+++ b/crates/stdlib/src/scproxy.rs
@@ -22,7 +22,7 @@ mod _scproxy {
 
     fn proxy_dict() -> Option<CFDictionary<CFString, CFType>> {
         // Py_BEGIN_ALLOW_THREADS
-        let proxy_dict = unsafe { SCDynamicStoreCopyProxies(std::ptr::null()) };
+        let proxy_dict = unsafe { SCDynamicStoreCopyProxies(core::ptr::null()) };
         // Py_END_ALLOW_THREADS
         if proxy_dict.is_null() {
             None
diff --git a/crates/stdlib/src/select.rs b/crates/stdlib/src/select.rs
index 5639a66d2cc..3c2f5e63c7c 100644
--- a/crates/stdlib/src/select.rs
+++ b/crates/stdlib/src/select.rs
@@ -4,7 +4,8 @@ use crate::vm::{
     PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine, builtins::PyListRef,
     builtins::PyModule,
 };
-use std::{io, mem};
+use core::mem;
+use std::io;
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(windows)]
@@ -158,7 +159,7 @@ impl FdSet {
     pub fn new() -> Self {
         // it's just ints, and all the code that's actually
         // interacting with it is in C, so it's safe to zero
-        let mut fdset = std::mem::MaybeUninit::zeroed();
+        let mut fdset = core::mem::MaybeUninit::zeroed();
         unsafe { platform::FD_ZERO(fdset.as_mut_ptr()) };
         Self(fdset)
     }
@@ -191,7 +192,7 @@ pub fn select(
 ) -> io::Result<i32> {
     let timeout = match timeout {
         Some(tv) => tv as *mut timeval,
-        None => std::ptr::null_mut(),
+        None => core::ptr::null_mut(),
     };
     let ret = unsafe {
         platform::select(
@@ -336,12 +337,10 @@ mod decl {
             function::OptionalArg,
             stdlib::io::Fildes,
         };
+        use core::{convert::TryFrom, time::Duration};
         use libc::pollfd;
         use num_traits::{Signed, ToPrimitive};
-        use std::{
-            convert::TryFrom,
-            time::{Duration, Instant},
-        };
+        use std::time::Instant;
 
         #[derive(Default)]
         pub(super) struct TimeoutArg<const MILLIS: bool>(pub Option<Duration>);
@@ -554,8 +553,8 @@ mod decl {
             stdlib::io::Fildes,
             types::Constructor,
         };
+        use core::ops::Deref;
         use rustix::event::epoll::{self, EventData, EventFlags};
-        use std::ops::Deref;
         use std::os::fd::{AsRawFd, IntoRawFd, OwnedFd};
         use std::time::Instant;
 
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 91c7b1201f1..71bc8e9f170 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -22,15 +22,19 @@ mod _socket {
         types::{Constructor, DefaultConstructor, Initializer, Representable},
         utils::ToCString,
     };
+    use core::{
+        mem::MaybeUninit,
+        net::{Ipv4Addr, Ipv6Addr, SocketAddr},
+        time::Duration,
+    };
     use crossbeam_utils::atomic::AtomicCell;
     use num_traits::ToPrimitive;
     use socket2::Socket;
     use std::{
         ffi,
         io::{self, Read, Write},
-        mem::MaybeUninit,
-        net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs},
-        time::{Duration, Instant},
+        net::{self, Shutdown, ToSocketAddrs},
+        time::Instant,
     };
 
     #[cfg(unix)]
@@ -934,7 +938,7 @@ mod _socket {
         sock: PyRwLock<Option<Socket>>,
     }
 
-    const _: () = assert!(std::mem::size_of::<Option<Socket>>() == std::mem::size_of::<Socket>());
+    const _: () = assert!(core::mem::size_of::<Option<Socket>>() == core::mem::size_of::<Socket>());
 
     impl Default for PySocket {
         fn default() -> Self {
@@ -1494,7 +1498,7 @@ mod _socket {
                                 Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
                             ) =>
                     {
-                        std::mem::forget(sock);
+                        core::mem::forget(sock);
                         return Err(e.into());
                     }
                     _ => {}
@@ -2052,7 +2056,7 @@ mod _socket {
             cmsgs: &[(i32, i32, ArgBytesLike)],
             vm: &VirtualMachine,
         ) -> PyResult<Vec<u8>> {
-            use std::{mem, ptr};
+            use core::{mem, ptr};
 
             if cmsgs.is_empty() {
                 return Ok(vec![]);
@@ -2210,7 +2214,7 @@ mod _socket {
             let buflen = buflen.unwrap_or(0);
             if buflen == 0 {
                 let mut flag: libc::c_int = 0;
-                let mut flagsize = std::mem::size_of::<libc::c_int>() as _;
+                let mut flagsize = core::mem::size_of::<libc::c_int>() as _;
                 let ret = unsafe {
                     c::getsockopt(
                         fd as _,
@@ -2270,11 +2274,11 @@ mod _socket {
                         level,
                         name,
                         val as *const i32 as *const _,
-                        std::mem::size_of::<i32>() as _,
+                        core::mem::size_of::<i32>() as _,
                     )
                 },
                 (None, OptionalArg::Present(optlen)) => unsafe {
-                    c::setsockopt(fd as _, level, name, std::ptr::null(), optlen as _)
+                    c::setsockopt(fd as _, level, name, core::ptr::null(), optlen as _)
                 },
                 _ => {
                     return Err(vm
@@ -2456,7 +2460,7 @@ mod _socket {
     }
 
     impl ToSocketAddrs for Address {
-        type Iter = std::vec::IntoIter<SocketAddr>;
+        type Iter = alloc::vec::IntoIter<SocketAddr>;
         fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
             (self.host.as_str(), self.port).to_socket_addrs()
         }
@@ -2616,7 +2620,7 @@ mod _socket {
     }
 
     fn cstr_opt_as_ptr(x: &OptionalArg<ffi::CString>) -> *const libc::c_char {
-        x.as_ref().map_or_else(std::ptr::null, |s| s.as_ptr())
+        x.as_ref().map_or_else(core::ptr::null, |s| s.as_ptr())
     }
 
     #[pyfunction]
@@ -2807,7 +2811,7 @@ mod _socket {
                     vm.state
                         .codec_registry
                         .encode_text(s.to_owned(), "idna", None, vm)?;
-                let host_str = std::str::from_utf8(encoded.as_bytes())
+                let host_str = core::str::from_utf8(encoded.as_bytes())
                     .map_err(|_| vm.new_runtime_error("idna output is not utf8".to_owned()))?;
                 Some(host_str.to_owned())
             }
@@ -3183,7 +3187,7 @@ mod _socket {
             .state
             .codec_registry
             .encode_text(pyname, "idna", None, vm)?;
-        let name = std::str::from_utf8(name.as_bytes())
+        let name = core::str::from_utf8(name.as_bytes())
             .map_err(|_| vm.new_runtime_error("idna output is not utf8"))?;
         let mut res = dns_lookup::getaddrinfo(Some(name), None, Some(hints))
             .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?;
@@ -3339,7 +3343,7 @@ mod _socket {
     #[pyfunction]
     fn dup(x: PyObjectRef, vm: &VirtualMachine) -> Result<RawSocket, IoOrPyException> {
         let sock = get_raw_sock(x, vm)?;
-        let sock = std::mem::ManuallyDrop::new(sock_from_raw(sock, vm)?);
+        let sock = core::mem::ManuallyDrop::new(sock_from_raw(sock, vm)?);
         let newsock = sock.try_clone()?;
         let fd = into_sock_fileno(newsock);
         #[cfg(windows)]
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index 103a827e99a..3a82787cd8f 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -844,7 +844,7 @@ mod _sqlite {
     }
 
     impl Debug for Connection {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
             write!(f, "Sqlite3 Connection")
         }
     }
@@ -2583,7 +2583,7 @@ mod _sqlite {
     }
 
     impl Debug for Statement {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
             write!(
                 f,
                 "{} Statement",
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 16449e2d019..b90176a62fa 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -52,14 +52,12 @@ mod _ssl {
     use super::error::{
         PySSLEOFError, PySSLError, create_ssl_want_read_error, create_ssl_want_write_error,
     };
-    use std::{
-        collections::HashMap,
-        sync::{
-            Arc,
-            atomic::{AtomicUsize, Ordering},
-        },
-        time::{Duration, SystemTime},
+    use alloc::sync::Arc;
+    use core::{
+        sync::atomic::{AtomicUsize, Ordering},
+        time::Duration,
     };
+    use std::{collections::HashMap, time::SystemTime};
 
     // Rustls imports
     use parking_lot::{Mutex as ParkingMutex, RwLock as ParkingRwLock};
@@ -3124,7 +3122,7 @@ mod _ssl {
                         // When server_hostname=None, use an IP address to suppress SNI
                         // no hostname = no SNI extension
                         ServerName::IpAddress(
-                            std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1)).into(),
+                            core::net::IpAddr::V4(core::net::Ipv4Addr::new(127, 0, 0, 1)).into(),
                         )
                     };
 
@@ -3385,7 +3383,7 @@ mod _ssl {
                 let mut written = 0;
 
                 while written < data.len() {
-                    let chunk_end = std::cmp::min(written + CHUNK_SIZE, data.len());
+                    let chunk_end = core::cmp::min(written + CHUNK_SIZE, data.len());
                     let chunk = &data[written..chunk_end];
 
                     // Write chunk to TLS layer
@@ -4176,8 +4174,8 @@ mod _ssl {
         #[pygetset]
         fn id(&self, vm: &VirtualMachine) -> PyBytesRef {
             // Return session ID (hash of session data for uniqueness)
+            use core::hash::{Hash, Hasher};
             use std::collections::hash_map::DefaultHasher;
-            use std::hash::{Hash, Hasher};
 
             let mut hasher = DefaultHasher::new();
             self.session_data.hash(&mut hasher);
@@ -4487,7 +4485,7 @@ mod _ssl {
 
         let mut result = Vec::new();
 
-        let mut crl_context: *const CRL_CONTEXT = std::ptr::null();
+        let mut crl_context: *const CRL_CONTEXT = core::ptr::null();
         loop {
             crl_context = unsafe { CertEnumCRLsInStore(store, crl_context) };
             if crl_context.is_null() {
@@ -4587,8 +4585,8 @@ mod _ssl {
     // Implement Hashable trait for PySSLCertificate
     impl Hashable for PySSLCertificate {
         fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash> {
+            use core::hash::{Hash, Hasher};
             use std::collections::hash_map::DefaultHasher;
-            use std::hash::{Hash, Hasher};
 
             let mut hasher = DefaultHasher::new();
             zelf.der_bytes.hash(&mut hasher);
diff --git a/crates/stdlib/src/ssl/cert.rs b/crates/stdlib/src/ssl/cert.rs
index b3cb7d6c14e..cd39972cf41 100644
--- a/crates/stdlib/src/ssl/cert.rs
+++ b/crates/stdlib/src/ssl/cert.rs
@@ -9,6 +9,7 @@
 //! - Building and verifying certificate chains
 //! - Loading certificates from files, directories, and bytes
 
+use alloc::sync::Arc;
 use chrono::{DateTime, Utc};
 use parking_lot::RwLock as ParkingRwLock;
 use rustls::{
@@ -19,7 +20,6 @@ use rustls::{
 };
 use rustpython_vm::{PyObjectRef, PyResult, VirtualMachine};
 use std::collections::HashSet;
-use std::sync::Arc;
 use x509_parser::prelude::*;
 
 use super::compat::{VERIFY_X509_PARTIAL_CHAIN, VERIFY_X509_STRICT};
@@ -51,8 +51,9 @@ const ALL_SIGNATURE_SCHEMES: &[SignatureScheme] = &[
 /// operations, reducing code duplication and ensuring uniform error messages
 /// across the codebase.
 mod cert_error {
+    use alloc::sync::Arc;
+    use core::fmt::{Debug, Display};
     use std::io;
-    use std::sync::Arc;
 
     /// Create InvalidData error with formatted message
     pub fn invalid_data(msg: impl Into<String>) -> io::Error {
@@ -67,11 +68,11 @@ mod cert_error {
             invalid_data(format!("no start line: {context}"))
         }
 
-        pub fn parse_failed(e: impl std::fmt::Display) -> io::Error {
+        pub fn parse_failed(e: impl Display) -> io::Error {
             invalid_data(format!("Failed to parse PEM certificate: {e}"))
         }
 
-        pub fn parse_failed_debug(e: impl std::fmt::Debug) -> io::Error {
+        pub fn parse_failed_debug(e: impl Debug) -> io::Error {
             invalid_data(format!("Failed to parse PEM certificate: {e:?}"))
         }
 
@@ -88,7 +89,7 @@ mod cert_error {
             invalid_data(format!("not enough data: {context}"))
         }
 
-        pub fn parse_failed(e: impl std::fmt::Display) -> io::Error {
+        pub fn parse_failed(e: impl Display) -> io::Error {
             invalid_data(format!("Failed to parse DER certificate: {e}"))
         }
     }
@@ -101,15 +102,15 @@ mod cert_error {
             invalid_data(format!("No private key found in {context}"))
         }
 
-        pub fn parse_failed(e: impl std::fmt::Display) -> io::Error {
+        pub fn parse_failed(e: impl Display) -> io::Error {
             invalid_data(format!("Failed to parse private key: {e}"))
         }
 
-        pub fn parse_encrypted_failed(e: impl std::fmt::Display) -> io::Error {
+        pub fn parse_encrypted_failed(e: impl Display) -> io::Error {
             invalid_data(format!("Failed to parse encrypted private key: {e}"))
         }
 
-        pub fn decrypt_failed(e: impl std::fmt::Display) -> io::Error {
+        pub fn decrypt_failed(e: impl Display) -> io::Error {
             io::Error::other(format!(
                 "Failed to decrypt private key (wrong password?): {e}",
             ))
@@ -383,7 +384,7 @@ pub fn cert_der_to_dict_helper(vm: &VirtualMachine, cert_der: &[u8]) -> PyResult
                     s.to_string()
                 } else {
                     let value_bytes = attr.attr_value().data;
-                    match std::str::from_utf8(value_bytes) {
+                    match core::str::from_utf8(value_bytes) {
                         Ok(s) => s.to_string(),
                         Err(_) => String::from_utf8_lossy(value_bytes).into_owned(),
                     }
@@ -1126,7 +1127,7 @@ pub(super) fn load_cert_chain_from_file(
     cert_path: &str,
     key_path: &str,
     password: Option<&str>,
-) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>), Box<dyn std::error::Error>> {
+) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>), Box<dyn core::error::Error>> {
     // Load certificate file - preserve io::Error for errno
     let cert_contents = std::fs::read(cert_path)?;
 
@@ -1727,13 +1728,13 @@ fn verify_ip_address(
     cert: &X509Certificate<'_>,
     expected_ip: &rustls::pki_types::IpAddr,
 ) -> Result<(), rustls::Error> {
-    use std::net::IpAddr;
+    use core::net::IpAddr;
     use x509_parser::extensions::GeneralName;
 
     // Convert rustls IpAddr to std::net::IpAddr for comparison
     let expected_std_ip: IpAddr = match expected_ip {
-        rustls::pki_types::IpAddr::V4(octets) => IpAddr::V4(std::net::Ipv4Addr::from(*octets)),
-        rustls::pki_types::IpAddr::V6(octets) => IpAddr::V6(std::net::Ipv6Addr::from(*octets)),
+        rustls::pki_types::IpAddr::V4(octets) => IpAddr::V4(core::net::Ipv4Addr::from(*octets)),
+        rustls::pki_types::IpAddr::V6(octets) => IpAddr::V6(core::net::Ipv6Addr::from(*octets)),
     };
 
     // Check Subject Alternative Names for IP addresses
@@ -1745,7 +1746,7 @@ fn verify_ip_address(
                     4 => {
                         // IPv4
                         if let Ok(octets) = <[u8; 4]>::try_from(*cert_ip_bytes) {
-                            IpAddr::V4(std::net::Ipv4Addr::from(octets))
+                            IpAddr::V4(core::net::Ipv4Addr::from(octets))
                         } else {
                             continue;
                         }
@@ -1753,7 +1754,7 @@ fn verify_ip_address(
                     16 => {
                         // IPv6
                         if let Ok(octets) = <[u8; 16]>::try_from(*cert_ip_bytes) {
-                            IpAddr::V6(std::net::Ipv6Addr::from(octets))
+                            IpAddr::V6(core::net::Ipv6Addr::from(octets))
                         } else {
                             continue;
                         }
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index fa12855e242..2168fcfc91f 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -13,6 +13,7 @@ mod ssl_data;
 
 use crate::socket::{SelectKind, timeout_error_msg};
 use crate::vm::VirtualMachine;
+use alloc::sync::Arc;
 use parking_lot::RwLock as ParkingRwLock;
 use rustls::RootCertStore;
 use rustls::client::ClientConfig;
@@ -28,7 +29,7 @@ use rustpython_vm::convert::IntoPyException;
 use rustpython_vm::function::ArgBytesLike;
 use rustpython_vm::{AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject};
 use std::io::Read;
-use std::sync::{Arc, Once};
+use std::sync::Once;
 
 // Import PySSLSocket from parent module
 use super::_ssl::PySSLSocket;
diff --git a/crates/stdlib/src/syslog.rs b/crates/stdlib/src/syslog.rs
index d0ed3f60949..b52d1415692 100644
--- a/crates/stdlib/src/syslog.rs
+++ b/crates/stdlib/src/syslog.rs
@@ -11,7 +11,8 @@ mod syslog {
         function::{OptionalArg, OptionalOption},
         utils::ToCString,
     };
-    use std::{ffi::CStr, os::raw::c_char};
+    use core::ffi::CStr;
+    use std::os::raw::c_char;
 
     #[pyattr]
     use libc::{
@@ -50,7 +51,7 @@ mod syslog {
         fn as_ptr(&self) -> *const c_char {
             match self {
                 Self::Explicit(cstr) => cstr.as_ptr(),
-                Self::Implicit => std::ptr::null(),
+                Self::Implicit => core::ptr::null(),
             }
         }
     }
diff --git a/crates/stdlib/src/tkinter.rs b/crates/stdlib/src/tkinter.rs
index 687458b193b..49dcdc5f84f 100644
--- a/crates/stdlib/src/tkinter.rs
+++ b/crates/stdlib/src/tkinter.rs
@@ -59,8 +59,8 @@ mod _tkinter {
         value: *mut tk_sys::Tcl_Obj,
     }
 
-    impl std::fmt::Debug for TclObject {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for TclObject {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "TclObject")
         }
     }
@@ -107,8 +107,8 @@ mod _tkinter {
     unsafe impl Send for TkApp {}
     unsafe impl Sync for TkApp {}
 
-    impl std::fmt::Debug for TkApp {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for TkApp {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "TkApp")
         }
     }
diff --git a/crates/stdlib/src/zlib.rs b/crates/stdlib/src/zlib.rs
index 9ca94939f78..632543c5c64 100644
--- a/crates/stdlib/src/zlib.rs
+++ b/crates/stdlib/src/zlib.rs
@@ -39,7 +39,7 @@ mod zlib {
     #[pyattr(name = "ZLIB_RUNTIME_VERSION")]
     #[pyattr]
     const ZLIB_VERSION: &str = unsafe {
-        match std::ffi::CStr::from_ptr(libz_sys::zlibVersion()).to_str() {
+        match core::ffi::CStr::from_ptr(libz_sys::zlibVersion()).to_str() {
             Ok(s) => s,
             Err(_) => unreachable!(),
         }
@@ -322,7 +322,7 @@ mod zlib {
             };
 
             let inner = &mut *self.inner.lock();
-            let data = std::mem::replace(&mut inner.unconsumed_tail, vm.ctx.empty_bytes.clone());
+            let data = core::mem::replace(&mut inner.unconsumed_tail, vm.ctx.empty_bytes.clone());
 
             let (ret, _) = Self::decompress_inner(inner, &data, length, None, true, vm)?;
 
diff --git a/crates/venvlauncher/src/main.rs b/crates/venvlauncher/src/main.rs
index aaf584dfa87..fe147ce7ff3 100644
--- a/crates/venvlauncher/src/main.rs
+++ b/crates/venvlauncher/src/main.rs
@@ -22,7 +22,7 @@ fn main() -> ExitCode {
     }
 }
 
-fn run() -> Result<u32, Box<dyn std::error::Error>> {
+fn run() -> Result<u32, Box<dyn core::error::Error>> {
     // 1. Get own executable path
     let exe_path = env::current_exe()?;
     let exe_name = exe_path
@@ -72,7 +72,7 @@ fn run() -> Result<u32, Box<dyn std::error::Error>> {
 }
 
 /// Parse the `home=` value from pyvenv.cfg
-fn read_home(cfg_path: &Path) -> Result<String, Box<dyn std::error::Error>> {
+fn read_home(cfg_path: &Path) -> Result<String, Box<dyn core::error::Error>> {
     let content = fs::read_to_string(cfg_path)?;
 
     for line in content.lines() {
@@ -95,7 +95,7 @@ fn read_home(cfg_path: &Path) -> Result<String, Box<dyn std::error::Error>> {
 }
 
 /// Launch the Python process and wait for it to complete
-fn launch_process(exe: &Path, args: &[String]) -> Result<u32, Box<dyn std::error::Error>> {
+fn launch_process(exe: &Path, args: &[String]) -> Result<u32, Box<dyn core::error::Error>> {
     use std::process::Command;
 
     let status = Command::new(exe).args(args).status()?;
diff --git a/crates/vm/src/anystr.rs b/crates/vm/src/anystr.rs
index ef6d24c100e..79b62a58abf 100644
--- a/crates/vm/src/anystr.rs
+++ b/crates/vm/src/anystr.rs
@@ -6,6 +6,8 @@ use crate::{
 };
 use num_traits::{cast::ToPrimitive, sign::Signed};
 
+use core::ops::Range;
+
 #[derive(FromArgs)]
 pub struct SplitArgs<T: TryFromObject> {
     #[pyarg(any, default)]
@@ -43,7 +45,7 @@ pub struct StartsEndsWithArgs {
 }
 
 impl StartsEndsWithArgs {
-    pub fn get_value(self, len: usize) -> (PyObjectRef, Option<std::ops::Range<usize>>) {
+    pub fn get_value(self, len: usize) -> (PyObjectRef, Option<Range<usize>>) {
         let range = if self.start.is_some() || self.end.is_some() {
             Some(adjust_indices(self.start, self.end, len))
         } else {
@@ -56,7 +58,7 @@ impl StartsEndsWithArgs {
     pub fn prepare<S, F>(self, s: &S, len: usize, substr: F) -> Option<(PyObjectRef, &S)>
     where
         S: ?Sized + AnyStr,
-        F: Fn(&S, std::ops::Range<usize>) -> &S,
+        F: Fn(&S, Range<usize>) -> &S,
     {
         let (affix, range) = self.get_value(len);
         let substr = if let Some(range) = range {
@@ -83,11 +85,7 @@ fn saturate_to_isize(py_int: PyIntRef) -> isize {
 }
 
 // help get optional string indices
-pub fn adjust_indices(
-    start: Option<PyIntRef>,
-    end: Option<PyIntRef>,
-    len: usize,
-) -> std::ops::Range<usize> {
+pub fn adjust_indices(start: Option<PyIntRef>, end: Option<PyIntRef>, len: usize) -> Range<usize> {
     let mut start = start.map_or(0, saturate_to_isize);
     let mut end = end.map_or(len as isize, saturate_to_isize);
     if end > len as isize {
@@ -111,7 +109,7 @@ pub trait StringRange {
     fn is_normal(&self) -> bool;
 }
 
-impl StringRange for std::ops::Range<usize> {
+impl StringRange for Range<usize> {
     fn is_normal(&self) -> bool {
         self.start <= self.end
     }
@@ -144,9 +142,9 @@ pub trait AnyStr {
     fn to_container(&self) -> Self::Container;
     fn as_bytes(&self) -> &[u8];
     fn elements(&self) -> impl Iterator<Item = Self::Char>;
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self;
+    fn get_bytes(&self, range: Range<usize>) -> &Self;
     // FIXME: get_chars is expensive for str
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self;
+    fn get_chars(&self, range: Range<usize>) -> &Self;
     fn bytes_len(&self) -> usize;
     // NOTE: str::chars().count() consumes the O(n) time. But pystr::char_len does cache.
     //       So using chars_len directly is too expensive and the below method shouldn't be implemented.
@@ -254,7 +252,7 @@ pub trait AnyStr {
     }
 
     #[inline]
-    fn py_find<F>(&self, needle: &Self, range: std::ops::Range<usize>, find: F) -> Option<usize>
+    fn py_find<F>(&self, needle: &Self, range: Range<usize>, find: F) -> Option<usize>
     where
         F: Fn(&Self, &Self) -> Option<usize>,
     {
@@ -268,7 +266,7 @@ pub trait AnyStr {
     }
 
     #[inline]
-    fn py_count<F>(&self, needle: &Self, range: std::ops::Range<usize>, count: F) -> usize
+    fn py_count<F>(&self, needle: &Self, range: Range<usize>, count: F) -> usize
     where
         F: Fn(&Self, &Self) -> usize,
     {
@@ -283,9 +281,9 @@ pub trait AnyStr {
         let mut u = Self::Container::with_capacity(
             (left + right) * fillchar.bytes_len() + self.bytes_len(),
         );
-        u.extend(std::iter::repeat_n(fillchar, left));
+        u.extend(core::iter::repeat_n(fillchar, left));
         u.push_str(self);
-        u.extend(std::iter::repeat_n(fillchar, right));
+        u.extend(core::iter::repeat_n(fillchar, right));
         u
     }
 
@@ -305,7 +303,7 @@ pub trait AnyStr {
 
     fn py_join(
         &self,
-        mut iter: impl std::iter::Iterator<Item = PyResult<impl AnyStrWrapper<Self> + TryFromObject>>,
+        mut iter: impl core::iter::Iterator<Item = PyResult<impl AnyStrWrapper<Self> + TryFromObject>>,
     ) -> PyResult<Self::Container> {
         let mut joined = if let Some(elem) = iter.next() {
             elem?.as_ref().unwrap().to_container()
@@ -328,7 +326,7 @@ pub trait AnyStr {
     ) -> PyResult<(Self::Container, bool, Self::Container)>
     where
         F: Fn() -> S,
-        S: std::iter::Iterator<Item = &'a Self>,
+        S: core::iter::Iterator<Item = &'a Self>,
     {
         if sub.is_empty() {
             return Err(vm.new_value_error("empty separator"));
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index 5c67f87521d..3d5e48015ea 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -5,11 +5,13 @@ use crate::{
     convert::ToPyObject,
     function::{ArgBytesLike, ArgIntoBool, ArgIntoFloat},
 };
+use alloc::fmt;
+use core::{iter::Peekable, mem};
 use half::f16;
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_traits::{PrimInt, ToPrimitive};
-use std::{fmt, iter::Peekable, mem, os::raw};
+use std::os::raw;
 
 type PackFunc = fn(&VirtualMachine, PyObjectRef, &mut [u8]) -> PyResult<()>;
 type UnpackFunc = fn(&VirtualMachine, &[u8]) -> PyObjectRef;
@@ -545,7 +547,7 @@ macro_rules! make_pack_prim_int {
             }
             #[inline]
             fn unpack_int<E: ByteOrder>(data: &[u8]) -> Self {
-                let mut x = [0; std::mem::size_of::<$T>()];
+                let mut x = [0; core::mem::size_of::<$T>()];
                 x.copy_from_slice(data);
                 E::convert(<$T>::from_ne_bytes(x))
             }
@@ -681,7 +683,7 @@ fn pack_pascal(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResul
     }
     let b = ArgBytesLike::try_from_object(vm, arg)?;
     b.with_ref(|data| {
-        let string_length = std::cmp::min(std::cmp::min(data.len(), 255), buf.len() - 1);
+        let string_length = core::cmp::min(core::cmp::min(data.len(), 255), buf.len() - 1);
         buf[0] = string_length as u8;
         write_string(&mut buf[1..], data);
     });
@@ -689,7 +691,7 @@ fn pack_pascal(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResul
 }
 
 fn write_string(buf: &mut [u8], data: &[u8]) {
-    let len_from_data = std::cmp::min(data.len(), buf.len());
+    let len_from_data = core::cmp::min(data.len(), buf.len());
     buf[..len_from_data].copy_from_slice(&data[..len_from_data]);
     for byte in &mut buf[len_from_data..] {
         *byte = 0
@@ -708,7 +710,7 @@ fn unpack_pascal(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef {
             return vm.ctx.new_bytes(vec![]).into();
         }
     };
-    let len = std::cmp::min(len as usize, data.len());
+    let len = core::cmp::min(len as usize, data.len());
     vm.ctx.new_bytes(data[..len].to_vec()).into()
 }
 
diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
index cfd1f136d14..3dabdbae717 100644
--- a/crates/vm/src/builtins/bool.rs
+++ b/crates/vm/src/builtins/bool.rs
@@ -8,9 +8,9 @@ use crate::{
     protocol::PyNumberMethods,
     types::{AsNumber, Constructor, Representable},
 };
+use core::fmt::{Debug, Formatter};
 use malachite_bigint::Sign;
 use num_traits::Zero;
-use std::fmt::{Debug, Formatter};
 
 impl ToPyObject for bool {
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
@@ -90,7 +90,7 @@ impl PyObjectRef {
 pub struct PyBool(pub PyInt);
 
 impl Debug for PyBool {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         let value = !self.0.as_bigint().is_zero();
         write!(f, "PyBool({})", value)
     }
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
index 2b569375b28..422f922df94 100644
--- a/crates/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -7,7 +7,7 @@ use crate::{
     function::{FuncArgs, PyComparisonValue, PyMethodDef, PyMethodFlags, PyNativeFn},
     types::{Callable, Comparable, PyComparisonOp, Representable},
 };
-use std::fmt;
+use alloc::fmt;
 
 // PyCFunctionObject in CPython
 #[pyclass(name = "builtin_function_or_method", module = false)]
@@ -212,7 +212,7 @@ impl Comparable for PyNativeMethod {
                     (None, None) => true,
                     _ => false,
                 };
-                let eq = eq && std::ptr::eq(zelf.func.value, other.func.value);
+                let eq = eq && core::ptr::eq(zelf.func.value, other.func.value);
                 Ok(eq.into())
             } else {
                 Ok(PyComparisonValue::NotImplemented)
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index c5861befb73..212e4604ec9 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -37,7 +37,7 @@ use crate::{
     },
 };
 use bstr::ByteSlice;
-use std::mem::size_of;
+use core::mem::size_of;
 
 #[pyclass(module = false, name = "bytearray", unhashable = true)]
 #[derive(Debug, Default)]
@@ -687,7 +687,7 @@ impl Initializer for PyByteArray {
     fn init(zelf: PyRef<Self>, options: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
         // First unpack bytearray and *then* get a lock to set it.
         let mut inner = options.get_bytearray_inner(vm)?;
-        std::mem::swap(&mut *zelf.inner_mut(), &mut inner);
+        core::mem::swap(&mut *zelf.inner_mut(), &mut inner);
         Ok(())
     }
 }
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 0c67cd7bf24..b3feac8ac97 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -29,8 +29,8 @@ use crate::{
     },
 };
 use bstr::ByteSlice;
+use core::{mem::size_of, ops::Deref};
 use std::sync::LazyLock;
-use std::{mem::size_of, ops::Deref};
 
 #[pyclass(module = false, name = "bytes")]
 #[derive(Clone, Debug)]
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index e46cc711bb3..b897ef9d311 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -11,10 +11,11 @@ use crate::{
     function::OptionalArg,
     types::{Constructor, Representable},
 };
+use alloc::fmt;
+use core::{borrow::Borrow, ops::Deref};
 use malachite_bigint::BigInt;
 use num_traits::Zero;
 use rustpython_compiler_core::{OneIndexed, bytecode::CodeUnits, bytecode::PyCodeLocationInfoKind};
-use std::{borrow::Borrow, fmt, ops::Deref};
 
 /// State for iterating through code address ranges
 struct PyCodeAddressRange<'a> {
@@ -601,7 +602,7 @@ impl PyCode {
     pub fn co_code(&self, vm: &VirtualMachine) -> crate::builtins::PyBytesRef {
         // SAFETY: CodeUnit is #[repr(C)] with size 2, so we can safely transmute to bytes
         let bytes = unsafe {
-            std::slice::from_raw_parts(
+            core::slice::from_raw_parts(
                 self.code.instructions.as_ptr() as *const u8,
                 self.code.instructions.len() * 2,
             )
diff --git a/crates/vm/src/builtins/complex.rs b/crates/vm/src/builtins/complex.rs
index ba74d5e0367..78729b2f5c0 100644
--- a/crates/vm/src/builtins/complex.rs
+++ b/crates/vm/src/builtins/complex.rs
@@ -10,10 +10,10 @@ use crate::{
     stdlib::warnings,
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
+use core::num::Wrapping;
 use num_complex::Complex64;
 use num_traits::Zero;
 use rustpython_common::hash;
-use std::num::Wrapping;
 
 /// Create a complex number from a real part and an optional imaginary part.
 ///
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index 802b81f6d79..aa9da6e2d44 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -59,8 +59,8 @@ impl PyPayload for PyMethodDescriptor {
     }
 }
 
-impl std::fmt::Debug for PyMethodDescriptor {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyMethodDescriptor {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "method descriptor for '{}'", self.common.name)
     }
 }
@@ -218,8 +218,8 @@ impl PyMemberDef {
     }
 }
 
-impl std::fmt::Debug for PyMemberDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyMemberDef {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyMemberDef")
             .field("name", &self.name)
             .field("kind", &self.kind)
@@ -445,8 +445,8 @@ pub enum SlotFunc {
     NumTernaryRight(PyNumberTernaryFunc), // __rpow__ (swapped first two args)
 }
 
-impl std::fmt::Debug for SlotFunc {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SlotFunc {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
             SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 567e18d6419..358685fcdc4 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -23,8 +23,8 @@ use crate::{
     },
     vm::VirtualMachine,
 };
+use alloc::fmt;
 use rustpython_common::lock::PyMutex;
-use std::fmt;
 use std::sync::LazyLock;
 
 pub type DictContentType = dict_inner::Dict;
@@ -219,7 +219,7 @@ impl PyDict {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.entries.sizeof()
+        core::mem::size_of::<Self>() + self.entries.sizeof()
     }
 
     #[pymethod]
@@ -759,7 +759,7 @@ impl ExactSizeIterator for DictIter<'_> {
 
 #[pyclass]
 trait DictView: PyPayload + PyClassDef + Iterable + Representable {
-    type ReverseIter: PyPayload + std::fmt::Debug;
+    type ReverseIter: PyPayload + core::fmt::Debug;
 
     fn dict(&self) -> &Py<PyDict>;
     fn item(vm: &VirtualMachine, key: PyObjectRef, value: PyObjectRef) -> PyObjectRef;
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index c29e45ddcf6..95d70afcbc7 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -149,7 +149,7 @@ impl PyFunction {
             None
         };
 
-        let arg_pos = |range: std::ops::Range<_>, name: &str| {
+        let arg_pos = |range: core::ops::Range<_>, name: &str| {
             code.varnames
                 .iter()
                 .enumerate()
@@ -255,7 +255,7 @@ impl PyFunction {
             }
 
             if let Some(defaults) = defaults {
-                let n = std::cmp::min(nargs, n_expected_args);
+                let n = core::cmp::min(nargs, n_expected_args);
                 let i = n.saturating_sub(n_required);
 
                 // We have sufficient defaults, so iterate over the corresponding names and use
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index 8a7288980fa..5596aca9da2 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -16,7 +16,7 @@ use crate::{
         PyComparisonOp, Representable,
     },
 };
-use std::fmt;
+use alloc::fmt;
 
 // attr_exceptions
 static ATTR_EXCEPTIONS: [&str; 12] = [
diff --git a/crates/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
index 3fa4667a997..a3f0605a473 100644
--- a/crates/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -19,8 +19,8 @@ pub struct PyGetSet {
     // doc: Option<String>,
 }
 
-impl std::fmt::Debug for PyGetSet {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyGetSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "PyGetSet {{ name: {}, getter: {}, setter: {} }}",
@@ -158,7 +158,7 @@ impl Representable for PyGetSet {
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let class = unsafe { zelf.class.borrow_static() };
         // Special case for object type
-        if std::ptr::eq(class, vm.ctx.types.object_type) {
+        if core::ptr::eq(class, vm.ctx.types.object_type) {
             Ok(format!("<attribute '{}'>", zelf.name))
         } else {
             Ok(format!(
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 37b41e085ad..182333cea51 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -17,11 +17,11 @@ use crate::{
     protocol::{PyNumberMethods, handle_bytes_to_int_err},
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
 };
+use alloc::fmt;
+use core::ops::{Neg, Not};
 use malachite_bigint::{BigInt, Sign};
 use num_integer::Integer;
 use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
-use std::fmt;
-use std::ops::{Neg, Not};
 
 #[pyclass(module = false, name = "int")]
 #[derive(Debug)]
@@ -289,7 +289,7 @@ impl PyInt {
         I::try_from(self.as_bigint()).map_err(|_| {
             vm.new_overflow_error(format!(
                 "Python int too large to convert to Rust {}",
-                std::any::type_name::<I>()
+                core::any::type_name::<I>()
             ))
         })
     }
@@ -444,7 +444,7 @@ impl PyInt {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
+        core::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
     }
 
     #[pymethod]
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 12cab27a750..46145b339cf 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -20,7 +20,8 @@ use crate::{
     utils::collection_repr,
     vm::VirtualMachine,
 };
-use std::{fmt, ops::DerefMut};
+use alloc::fmt;
+use core::ops::DerefMut;
 
 #[pyclass(module = false, name = "list", unhashable = true, traverse)]
 #[derive(Default)]
@@ -172,7 +173,7 @@ impl PyList {
 
     #[pymethod]
     fn clear(&self) {
-        let _removed = std::mem::take(self.borrow_vec_mut().deref_mut());
+        let _removed = core::mem::take(self.borrow_vec_mut().deref_mut());
     }
 
     #[pymethod]
@@ -188,8 +189,8 @@ impl PyList {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>()
-            + self.elements.read().capacity() * std::mem::size_of::<PyObjectRef>()
+        core::mem::size_of::<Self>()
+            + self.elements.read().capacity() * core::mem::size_of::<PyObjectRef>()
     }
 
     #[pymethod]
@@ -324,9 +325,9 @@ impl PyList {
         // replace list contents with [] for duration of sort.
         // this prevents keyfunc from messing with the list and makes it easy to
         // check if it tries to append elements to it.
-        let mut elements = std::mem::take(self.borrow_vec_mut().deref_mut());
+        let mut elements = core::mem::take(self.borrow_vec_mut().deref_mut());
         let res = do_sort(vm, &mut elements, options.key, options.reverse);
-        std::mem::swap(self.borrow_vec_mut().deref_mut(), &mut elements);
+        core::mem::swap(self.borrow_vec_mut().deref_mut(), &mut elements);
         res?;
 
         if !elements.is_empty() {
@@ -375,7 +376,7 @@ impl MutObjectSequenceOp for PyList {
         inner.get(index).map(|r| r.as_ref())
     }
 
-    fn do_lock(&self) -> impl std::ops::Deref<Target = [PyObjectRef]> {
+    fn do_lock(&self) -> impl core::ops::Deref<Target = [PyObjectRef]> {
         self.borrow_vec()
     }
 }
@@ -397,7 +398,7 @@ impl Initializer for PyList {
         } else {
             vec![]
         };
-        std::mem::swap(zelf.borrow_vec_mut().deref_mut(), &mut elements);
+        core::mem::swap(zelf.borrow_vec_mut().deref_mut(), &mut elements);
         Ok(())
     }
 }
diff --git a/crates/vm/src/builtins/map.rs b/crates/vm/src/builtins/map.rs
index f5cee945ece..f83030824f1 100644
--- a/crates/vm/src/builtins/map.rs
+++ b/crates/vm/src/builtins/map.rs
@@ -42,7 +42,7 @@ impl PyMap {
     fn __length_hint__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         self.iterators.iter().try_fold(0, |prev, cur| {
             let cur = cur.as_ref().to_owned().length_hint(0, vm)?;
-            let max = std::cmp::max(prev, cur);
+            let max = core::cmp::max(prev, cur);
             Ok(max)
         })
     }
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
index 4e895f92b7e..ff5df031c42 100644
--- a/crates/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -26,11 +26,11 @@ use crate::{
         PyComparisonOp, Representable, SelfIter,
     },
 };
+use core::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range};
 use crossbeam_utils::atomic::AtomicCell;
 use itertools::Itertools;
 use rustpython_common::lock::PyMutex;
 use std::sync::LazyLock;
-use std::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range};
 
 #[derive(FromArgs)]
 pub struct PyMemoryViewNewArgs {
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
index f8e42b28e0b..faa6e4813fd 100644
--- a/crates/vm/src/builtins/module.rs
+++ b/crates/vm/src/builtins/module.rs
@@ -32,8 +32,8 @@ pub struct PyModuleSlots {
     pub exec: Option<ModuleExec>,
 }
 
-impl std::fmt::Debug for PyModuleSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyModuleSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyModuleSlots")
             .field("create", &self.create.is_some())
             .field("exec", &self.exec.is_some())
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index a61fb1e2971..e73f4b79ae0 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -218,7 +218,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
         //     basicsize += std::mem::size_of::<PyObjectRef>();
         // }
         if let Some(ref slot_names) = slot_names {
-            basicsize += std::mem::size_of::<PyObjectRef>() * slot_names.__len__();
+            basicsize += core::mem::size_of::<PyObjectRef>() * slot_names.__len__();
         }
         if obj.class().slots.basicsize > basicsize {
             return Err(
diff --git a/crates/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
index 7ea36d39768..3a86867176a 100644
--- a/crates/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -10,7 +10,7 @@ use crate::{
     function::{FuncArgs, PySetterValue},
     types::{Constructor, GetDescriptor, Initializer},
 };
-use std::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::{AtomicBool, Ordering};
 
 #[pyclass(module = false, name = "property", traverse)]
 #[derive(Debug)]
@@ -21,7 +21,7 @@ pub struct PyProperty {
     doc: PyRwLock<Option<PyObjectRef>>,
     name: PyRwLock<Option<PyObjectRef>>,
     #[pytraverse(skip)]
-    getter_doc: std::sync::atomic::AtomicBool,
+    getter_doc: core::sync::atomic::AtomicBool,
 }
 
 impl PyPayload for PyProperty {
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index 9f79f8efb2d..ab84c977ccd 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -14,11 +14,11 @@ use crate::{
         Representable, SelfIter,
     },
 };
+use core::cmp::max;
 use crossbeam_utils::atomic::AtomicCell;
 use malachite_bigint::{BigInt, Sign};
 use num_integer::Integer;
 use num_traits::{One, Signed, ToPrimitive, Zero};
-use std::cmp::max;
 use std::sync::LazyLock;
 
 // Search flag passed to iter_search
diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
index 5582ff3323c..b1236e44e93 100644
--- a/crates/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -23,12 +23,13 @@ use crate::{
     utils::collection_repr,
     vm::VirtualMachine,
 };
+use alloc::fmt;
+use core::ops::Deref;
 use rustpython_common::{
     atomic::{Ordering, PyAtomic, Radium},
     hash,
 };
 use std::sync::LazyLock;
-use std::{fmt, ops::Deref};
 
 pub type SetContentType = dict_inner::Dict<()>;
 
@@ -50,7 +51,7 @@ impl PySet {
 
     fn fold_op(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         op: fn(&PySetInner, ArgIterable, &VirtualMachine) -> PyResult<PySetInner>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -68,7 +69,7 @@ impl PySet {
         Ok(Self {
             inner: self
                 .inner
-                .fold_op(std::iter::once(other.into_iterable(vm)?), op, vm)?,
+                .fold_op(core::iter::once(other.into_iterable(vm)?), op, vm)?,
         })
     }
 }
@@ -111,7 +112,7 @@ impl PyFrozenSet {
 
     fn fold_op(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         op: fn(&PySetInner, ArgIterable, &VirtualMachine) -> PyResult<PySetInner>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -130,7 +131,7 @@ impl PyFrozenSet {
         Ok(Self {
             inner: self
                 .inner
-                .fold_op(std::iter::once(other.into_iterable(vm)?), op, vm)?,
+                .fold_op(core::iter::once(other.into_iterable(vm)?), op, vm)?,
             ..Default::default()
         })
     }
@@ -191,7 +192,7 @@ impl PySetInner {
 
     fn fold_op<O>(
         &self,
-        others: impl std::iter::Iterator<Item = O>,
+        others: impl core::iter::Iterator<Item = O>,
         op: fn(&Self, O, &VirtualMachine) -> PyResult<Self>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -352,7 +353,7 @@ impl PySetInner {
 
     fn update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -395,7 +396,7 @@ impl PySetInner {
 
     fn intersection_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let temp_inner = self.fold_op(others, Self::intersection, vm)?;
@@ -408,7 +409,7 @@ impl PySetInner {
 
     fn difference_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -422,7 +423,7 @@ impl PySetInner {
 
     fn symmetric_difference_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -539,7 +540,7 @@ impl PySet {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.inner.sizeof()
+        core::mem::size_of::<Self>() + self.inner.sizeof()
     }
 
     #[pymethod]
@@ -731,7 +732,7 @@ impl PySet {
     #[pymethod]
     fn __iand__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner
-            .intersection_update(std::iter::once(set.into_iterable(vm)?), vm)?;
+            .intersection_update(core::iter::once(set.into_iterable(vm)?), vm)?;
         Ok(zelf)
     }
 
@@ -978,7 +979,7 @@ impl PyFrozenSet {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.inner.sizeof()
+        core::mem::size_of::<Self>() + self.inner.sizeof()
     }
 
     #[pymethod]
@@ -1258,8 +1259,8 @@ impl AnySet {
     fn into_iterable_iter(
         self,
         vm: &VirtualMachine,
-    ) -> PyResult<impl std::iter::Iterator<Item = ArgIterable>> {
-        Ok(std::iter::once(self.into_iterable(vm)?))
+    ) -> PyResult<impl core::iter::Iterator<Item = ArgIterable>> {
+        Ok(core::iter::once(self.into_iterable(vm)?))
     }
 
     fn as_inner(&self) -> &PySetInner {
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index fa35c1725d4..0357e81b365 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -24,8 +24,10 @@ use crate::{
         PyComparisonOp, Representable, SelfIter,
     },
 };
+use alloc::{borrow::Cow, fmt};
 use ascii::{AsciiChar, AsciiStr, AsciiString};
 use bstr::ByteSlice;
+use core::{char, mem, ops::Range};
 use itertools::Itertools;
 use num_traits::ToPrimitive;
 use rustpython_common::{
@@ -37,8 +39,7 @@ use rustpython_common::{
     str::DeduceStrKind,
     wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk},
 };
-use std::{borrow::Cow, char, fmt, ops::Range};
-use std::{mem, sync::LazyLock};
+use std::sync::LazyLock;
 use unic_ucd_bidi::BidiClass;
 use unic_ucd_category::GeneralCategory;
 use unic_ucd_ident::{is_xid_continue, is_xid_start};
@@ -191,8 +192,8 @@ impl From<StrData> for PyStr {
     }
 }
 
-impl<'a> From<std::borrow::Cow<'a, str>> for PyStr {
-    fn from(s: std::borrow::Cow<'a, str>) -> Self {
+impl<'a> From<alloc::borrow::Cow<'a, str>> for PyStr {
+    fn from(s: alloc::borrow::Cow<'a, str>) -> Self {
         s.into_owned().into()
     }
 }
@@ -632,7 +633,7 @@ impl PyStr {
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.byte_len() * std::mem::size_of::<u8>()
+        core::mem::size_of::<Self>() + self.byte_len() * core::mem::size_of::<u8>()
     }
 
     #[pymethod(name = "__rmul__")]
@@ -1045,7 +1046,7 @@ impl PyStr {
 
     #[pymethod]
     fn replace(&self, args: ReplaceArgs) -> Wtf8Buf {
-        use std::cmp::Ordering;
+        use core::cmp::Ordering;
 
         let s = self.as_wtf8();
         let ReplaceArgs { old, new, count } = args;
@@ -1361,7 +1362,7 @@ impl PyStr {
                         let ch = bigint
                             .as_bigint()
                             .to_u32()
-                            .and_then(std::char::from_u32)
+                            .and_then(core::char::from_u32)
                             .ok_or_else(|| {
                                 vm.new_value_error("character mapping must be in range(0x110000)")
                             })?;
@@ -1494,7 +1495,7 @@ impl PyRef<PyStr> {
 }
 
 struct CharLenStr<'a>(&'a str, usize);
-impl std::ops::Deref for CharLenStr<'_> {
+impl core::ops::Deref for CharLenStr<'_> {
     type Target = str;
 
     fn deref(&self) -> &Self::Target {
@@ -1705,7 +1706,7 @@ pub struct FindArgs {
 }
 
 impl FindArgs {
-    fn get_value(self, len: usize) -> (PyStrRef, std::ops::Range<usize>) {
+    fn get_value(self, len: usize) -> (PyStrRef, core::ops::Range<usize>) {
         let range = adjust_indices(self.start, self.end, len);
         (self.sub, range)
     }
@@ -1945,8 +1946,8 @@ impl PyPayload for PyUtf8Str {
         ctx.types.str_type
     }
 
-    fn payload_type_id() -> std::any::TypeId {
-        std::any::TypeId::of::<PyStr>()
+    fn payload_type_id() -> core::any::TypeId {
+        core::any::TypeId::of::<PyStr>()
     }
 
     fn validate_downcastable_from(obj: &PyObject) -> bool {
@@ -2005,8 +2006,8 @@ impl From<char> for PyUtf8Str {
     }
 }
 
-impl<'a> From<std::borrow::Cow<'a, str>> for PyUtf8Str {
-    fn from(s: std::borrow::Cow<'a, str>) -> Self {
+impl<'a> From<alloc::borrow::Cow<'a, str>> for PyUtf8Str {
+    fn from(s: alloc::borrow::Cow<'a, str>) -> Self {
         s.into_owned().into()
     }
 }
@@ -2128,11 +2129,11 @@ impl AnyStr for str {
         Self::chars(self)
     }
 
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
         rustpython_common::str::get_chars(self, range)
     }
 
@@ -2239,11 +2240,11 @@ impl AnyStr for Wtf8 {
         self.code_points()
     }
 
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
         rustpython_common::str::get_codepoints(self, range)
     }
 
@@ -2361,11 +2362,11 @@ impl AnyStr for AsciiStr {
         self.chars()
     }
 
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
@@ -2436,8 +2437,8 @@ impl PyStrInterned {
     }
 }
 
-impl std::fmt::Display for PyStrInterned {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for PyStrInterned {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.data.fmt(f)
     }
 }
diff --git a/crates/vm/src/builtins/traceback.rs b/crates/vm/src/builtins/traceback.rs
index 6bf4070c9b5..84493e7125f 100644
--- a/crates/vm/src/builtins/traceback.rs
+++ b/crates/vm/src/builtins/traceback.rs
@@ -81,7 +81,7 @@ impl Constructor for PyTraceback {
 
 impl PyTracebackRef {
     pub fn iter(&self) -> impl Iterator<Item = Self> {
-        std::iter::successors(Some(self.clone()), |tb| tb.next.lock().clone())
+        core::iter::successors(Some(self.clone()), |tb| tb.next.lock().clone())
     }
 }
 
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index 13335428b35..70e4e20e405 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -21,7 +21,8 @@ use crate::{
     utils::collection_repr,
     vm::VirtualMachine,
 };
-use std::{fmt, sync::LazyLock};
+use alloc::fmt;
+use std::sync::LazyLock;
 
 #[pyclass(module = false, name = "tuple", traverse)]
 pub struct PyTuple<R = PyObjectRef> {
@@ -158,7 +159,7 @@ impl<R> AsRef<[R]> for PyTuple<R> {
     }
 }
 
-impl<R> std::ops::Deref for PyTuple<R> {
+impl<R> core::ops::Deref for PyTuple<R> {
     type Target = [R];
 
     fn deref(&self) -> &[R] {
@@ -166,18 +167,18 @@ impl<R> std::ops::Deref for PyTuple<R> {
     }
 }
 
-impl<'a, R> std::iter::IntoIterator for &'a PyTuple<R> {
+impl<'a, R> core::iter::IntoIterator for &'a PyTuple<R> {
     type Item = &'a R;
-    type IntoIter = std::slice::Iter<'a, R>;
+    type IntoIter = core::slice::Iter<'a, R>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 
-impl<'a, R> std::iter::IntoIterator for &'a Py<PyTuple<R>> {
+impl<'a, R> core::iter::IntoIterator for &'a Py<PyTuple<R>> {
     type Item = &'a R;
-    type IntoIter = std::slice::Iter<'a, R>;
+    type IntoIter = core::slice::Iter<'a, R>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -200,7 +201,7 @@ impl<R> PyTuple<R> {
     }
 
     #[inline]
-    pub fn iter(&self) -> std::slice::Iter<'_, R> {
+    pub fn iter(&self) -> core::slice::Iter<'_, R> {
         self.elements.iter()
     }
 }
@@ -249,15 +250,15 @@ impl<T> PyTuple<PyRef<T>> {
         // SAFETY: PyRef<T> has the same layout as PyObjectRef
         unsafe {
             let elements: Vec<PyObjectRef> =
-                std::mem::transmute::<Vec<PyRef<T>>, Vec<PyObjectRef>>(elements);
+                core::mem::transmute::<Vec<PyRef<T>>, Vec<PyObjectRef>>(elements);
             let tuple = PyTuple::<PyObjectRef>::new_ref(elements, ctx);
-            std::mem::transmute::<PyRef<PyTuple>, PyRef<Self>>(tuple)
+            core::mem::transmute::<PyRef<PyTuple>, PyRef<Self>>(tuple)
         }
     }
 }
 
 #[pyclass(
-    itemsize = std::mem::size_of::<crate::PyObjectRef>(),
+    itemsize = core::mem::size_of::<crate::PyObjectRef>(),
     flags(BASETYPE, SEQUENCE, _MATCH_SELF),
     with(AsMapping, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
 )]
@@ -489,21 +490,21 @@ impl PyRef<PyTuple<PyObjectRef>> {
             <PyRef<T> as TransmuteFromObject>::check(vm, elem)?;
         }
         // SAFETY: We just verified all elements are of type T
-        Ok(unsafe { std::mem::transmute::<Self, PyRef<PyTuple<PyRef<T>>>>(self) })
+        Ok(unsafe { core::mem::transmute::<Self, PyRef<PyTuple<PyRef<T>>>>(self) })
     }
 }
 
 impl<T: PyPayload> PyRef<PyTuple<PyRef<T>>> {
     pub fn into_untyped(self) -> PyRef<PyTuple> {
         // SAFETY: PyTuple<PyRef<T>> has the same layout as PyTuple
-        unsafe { std::mem::transmute::<Self, PyRef<PyTuple>>(self) }
+        unsafe { core::mem::transmute::<Self, PyRef<PyTuple>>(self) }
     }
 }
 
 impl<T: PyPayload> Py<PyTuple<PyRef<T>>> {
     pub fn as_untyped(&self) -> &Py<PyTuple> {
         // SAFETY: PyTuple<PyRef<T>> has the same layout as PyTuple
-        unsafe { std::mem::transmute::<&Self, &Py<PyTuple>>(self) }
+        unsafe { core::mem::transmute::<&Self, &Py<PyTuple>>(self) }
     }
 }
 
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index e807d3f4f8e..3eca5edc478 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -29,10 +29,11 @@ use crate::{
         Representable, SLOT_DEFS, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
     },
 };
+use core::{any::Any, borrow::Borrow, ops::Deref, pin::Pin, ptr::NonNull};
 use indexmap::{IndexMap, map::Entry};
 use itertools::Itertools;
 use num_traits::ToPrimitive;
-use std::{any::Any, borrow::Borrow, collections::HashSet, ops::Deref, pin::Pin, ptr::NonNull};
+use std::collections::HashSet;
 
 #[pyclass(module = false, name = "type", traverse = "manual")]
 pub struct PyType {
@@ -118,14 +119,14 @@ unsafe impl Traverse for PyAttributes {
     }
 }
 
-impl std::fmt::Display for PyType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.name(), f)
+impl core::fmt::Display for PyType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(&self.name(), f)
     }
 }
 
-impl std::fmt::Debug for PyType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "[PyType {}]", &self.name())
     }
 }
@@ -368,7 +369,7 @@ impl PyType {
 
         // Inherit SEQUENCE and MAPPING flags from base class
         // For static types, we only have a single base
-        Self::inherit_patma_flags(&mut slots, std::slice::from_ref(&base));
+        Self::inherit_patma_flags(&mut slots, core::slice::from_ref(&base));
 
         if slots.basicsize == 0 {
             slots.basicsize = base.slots.basicsize;
@@ -549,7 +550,7 @@ impl PyType {
         // Gather all members here:
         let mut attributes = PyAttributes::default();
 
-        for bc in std::iter::once(self)
+        for bc in core::iter::once(self)
             .chain(self.mro.read().iter().map(|cls| -> &Self { cls }))
             .rev()
         {
@@ -667,21 +668,21 @@ impl Py<PyType> {
     where
         F: Fn(&Self) -> R,
     {
-        std::iter::once(self)
+        core::iter::once(self)
             .chain(self.mro.read().iter().map(|x| x.deref()))
             .map(f)
             .collect()
     }
 
     pub fn mro_collect(&self) -> Vec<PyRef<PyType>> {
-        std::iter::once(self)
+        core::iter::once(self)
             .chain(self.mro.read().iter().map(|x| x.deref()))
             .map(|x| x.to_owned())
             .collect()
     }
 
     pub fn iter_base_chain(&self) -> impl Iterator<Item = &Self> {
-        std::iter::successors(Some(self), |cls| cls.base.as_deref())
+        core::iter::successors(Some(self), |cls| cls.base.as_deref())
     }
 
     pub fn extend_methods(&'static self, method_defs: &'static [PyMethodDef], ctx: &Context) {
@@ -846,7 +847,7 @@ impl PyType {
         // then drop the old value after releasing the lock
         let _old_qualname = {
             let mut qualname_guard = heap_type.qualname.write();
-            std::mem::replace(&mut *qualname_guard, str_value)
+            core::mem::replace(&mut *qualname_guard, str_value)
         };
         // old_qualname is dropped here, outside the lock scope
 
@@ -1012,7 +1013,7 @@ impl PyType {
         // then drop the old value after releasing the lock (similar to CPython's Py_SETREF)
         let _old_name = {
             let mut name_guard = self.heaptype_ext.as_ref().unwrap().name.write();
-            std::mem::replace(&mut *name_guard, name)
+            core::mem::replace(&mut *name_guard, name)
         };
         // old_name is dropped here, outside the lock scope
 
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index 83e1316d027..0342442b83d 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -11,7 +11,7 @@ use crate::{
     stdlib::typing::TypeAliasType,
     types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable},
 };
-use std::fmt;
+use alloc::fmt;
 use std::sync::LazyLock;
 
 const CLS_ATTRS: &[&str] = &["__module__"];
diff --git a/crates/vm/src/bytes_inner.rs b/crates/vm/src/bytes_inner.rs
index 8593f16fcd9..bb5db442c35 100644
--- a/crates/vm/src/bytes_inner.rs
+++ b/crates/vm/src/bytes_inner.rs
@@ -151,7 +151,7 @@ impl ByteInnerFindOptions {
         self,
         len: usize,
         vm: &VirtualMachine,
-    ) -> PyResult<(Vec<u8>, std::ops::Range<usize>)> {
+    ) -> PyResult<(Vec<u8>, core::ops::Range<usize>)> {
         let sub = match self.sub {
             Either::A(v) => v.elements.to_vec(),
             Either::B(int) => vec![int.as_bigint().byte_or(vm)?],
@@ -719,7 +719,7 @@ impl PyBytesInner {
     // len(self)>=1, from="", len(to)>=1, max_count>=1
     fn replace_interleave(&self, to: Self, max_count: Option<usize>) -> Vec<u8> {
         let place_count = self.elements.len() + 1;
-        let count = max_count.map_or(place_count, |v| std::cmp::min(v, place_count)) - 1;
+        let count = max_count.map_or(place_count, |v| core::cmp::min(v, place_count)) - 1;
         let capacity = self.elements.len() + count * to.len();
         let mut result = Vec::with_capacity(capacity);
         let to_slice = to.elements.as_slice();
@@ -952,7 +952,7 @@ where
 fn count_substring(haystack: &[u8], needle: &[u8], max_count: Option<usize>) -> usize {
     let substrings = haystack.find_iter(needle);
     if let Some(max_count) = max_count {
-        std::cmp::min(substrings.take(max_count).count(), max_count)
+        core::cmp::min(substrings.take(max_count).count(), max_count)
     } else {
         substrings.count()
     }
@@ -1025,11 +1025,11 @@ impl AnyStr for [u8] {
         self.iter().copied()
     }
 
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
@@ -1120,7 +1120,7 @@ fn hex_impl(bytes: &[u8], sep: u8, bytes_per_sep: isize) -> String {
     let len = bytes.len();
 
     let buf = if bytes_per_sep < 0 {
-        let bytes_per_sep = std::cmp::min(len, (-bytes_per_sep) as usize);
+        let bytes_per_sep = core::cmp::min(len, (-bytes_per_sep) as usize);
         let chunks = (len - 1) / bytes_per_sep;
         let chunked = chunks * bytes_per_sep;
         let unchunked = len - chunked;
@@ -1139,7 +1139,7 @@ fn hex_impl(bytes: &[u8], sep: u8, bytes_per_sep: isize) -> String {
         hex::encode_to_slice(&bytes[chunked..], &mut buf[j..j + unchunked * 2]).unwrap();
         buf
     } else {
-        let bytes_per_sep = std::cmp::min(len, bytes_per_sep as usize);
+        let bytes_per_sep = core::cmp::min(len, bytes_per_sep as usize);
         let chunks = (len - 1) / bytes_per_sep;
         let chunked = chunks * bytes_per_sep;
         let unchunked = len - chunked;
diff --git a/crates/vm/src/cformat.rs b/crates/vm/src/cformat.rs
index efb3cb2acc9..939b1c7760f 100644
--- a/crates/vm/src/cformat.rs
+++ b/crates/vm/src/cformat.rs
@@ -342,7 +342,7 @@ pub(crate) fn cformat_bytes(
     let values = if let Some(tup) = values_obj.downcast_ref::<tuple::PyTuple>() {
         tup.as_slice()
     } else {
-        std::slice::from_ref(&values_obj)
+        core::slice::from_ref(&values_obj)
     };
     let mut value_iter = values.iter();
 
@@ -435,7 +435,7 @@ pub(crate) fn cformat_string(
     let values = if let Some(tup) = values_obj.downcast_ref::<tuple::PyTuple>() {
         tup.as_slice()
     } else {
-        std::slice::from_ref(&values_obj)
+        core::slice::from_ref(&values_obj)
     };
     let mut value_iter = values.iter();
 
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index ce41abcc60b..98dc6fd2ed2 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -169,7 +169,7 @@ pub trait PyClassImpl: PyClassDef {
         // Exception: object itself should have __new__ in its dict
         if let Some(slot_new) = class.slots.new.load() {
             let object_new = ctx.types.object_type.slots.new.load();
-            let is_object_itself = std::ptr::eq(class, ctx.types.object_type);
+            let is_object_itself = core::ptr::eq(class, ctx.types.object_type);
             let is_inherited_from_object = !is_object_itself
                 && object_new.is_some_and(|obj_new| slot_new as usize == obj_new as usize);
 
@@ -203,7 +203,7 @@ pub trait PyClassImpl: PyClassDef {
             Self::extend_class(ctx, unsafe {
                 // typ will be saved in static_cell
                 let r: &Py<PyType> = &typ;
-                let r: &'static Py<PyType> = std::mem::transmute(r);
+                let r: &'static Py<PyType> = core::mem::transmute(r);
                 r
             });
             typ
diff --git a/crates/vm/src/codecs.rs b/crates/vm/src/codecs.rs
index 2edb67b497b..3241dee4981 100644
--- a/crates/vm/src/codecs.rs
+++ b/crates/vm/src/codecs.rs
@@ -16,12 +16,10 @@ use crate::{
     convert::ToPyObject,
     function::{ArgBytesLike, PyMethodDef},
 };
+use alloc::borrow::Cow;
+use core::ops::{self, Range};
 use once_cell::unsync::OnceCell;
-use std::{
-    borrow::Cow,
-    collections::HashMap,
-    ops::{self, Range},
-};
+use std::collections::HashMap;
 
 pub struct CodecsRegistry {
     inner: PyRwLock<RegistryInner>,
diff --git a/crates/vm/src/convert/try_from.rs b/crates/vm/src/convert/try_from.rs
index 4f921e9c5de..ceb7d003e9b 100644
--- a/crates/vm/src/convert/try_from.rs
+++ b/crates/vm/src/convert/try_from.rs
@@ -122,7 +122,7 @@ impl<'a, T: PyPayload> TryFromBorrowedObject<'a> for &'a Py<T> {
     }
 }
 
-impl TryFromObject for std::time::Duration {
+impl TryFromObject for core::time::Duration {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         if let Some(float) = obj.downcast_ref::<PyFloat>() {
             let f = float.to_f64();
diff --git a/crates/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
index 02e237afb00..d57f8be0fe7 100644
--- a/crates/vm/src/dict_inner.rs
+++ b/crates/vm/src/dict_inner.rs
@@ -16,8 +16,9 @@ use crate::{
     },
     object::{Traverse, TraverseFn},
 };
+use alloc::fmt;
+use core::{mem::size_of, ops::ControlFlow};
 use num_traits::ToPrimitive;
-use std::{fmt, mem::size_of, ops::ControlFlow};
 
 // HashIndex is intended to be same size with hash::PyHash
 // but it doesn't mean the values are compatible with actual PyHash value
@@ -281,7 +282,7 @@ impl<T: Clone> Dict<T> {
                         continue;
                     };
                     if entry.index == index_index {
-                        let removed = std::mem::replace(&mut entry.value, value);
+                        let removed = core::mem::replace(&mut entry.value, value);
                         // defer dec RC
                         break Some(removed);
                     } else {
@@ -357,7 +358,7 @@ impl<T: Clone> Dict<T> {
             inner.used = 0;
             inner.filled = 0;
             // defer dec rc
-            std::mem::take(&mut inner.entries)
+            core::mem::take(&mut inner.entries)
         };
     }
 
@@ -633,7 +634,7 @@ impl<T: Clone> Dict<T> {
 
     // returns Err(()) if changed since lookup
     fn pop_inner(&self, lookup: LookupResult) -> PopInnerResult<T> {
-        self.pop_inner_if(lookup, |_| Ok::<_, std::convert::Infallible>(true))
+        self.pop_inner_if(lookup, |_| Ok::<_, core::convert::Infallible>(true))
             .unwrap_or_else(|x| match x {})
     }
 
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 4e8b572e457..b1a654d58c4 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -33,8 +33,8 @@ unsafe impl Traverse for PyBaseException {
     }
 }
 
-impl std::fmt::Debug for PyBaseException {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyBaseException {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         // TODO: implement more detailed, non-recursive Debug formatter
         f.write_str("PyBaseException")
     }
@@ -1173,7 +1173,7 @@ pub fn cstring_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
     vm.new_value_error("embedded null character")
 }
 
-impl ToPyException for std::ffi::NulError {
+impl ToPyException for alloc::ffi::NulError {
     fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
         cstring_error(vm)
     }
@@ -1604,8 +1604,8 @@ pub(super) mod types {
         }
     }
 
-    impl std::fmt::Debug for PyOSError {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for PyOSError {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("PyOSError").finish_non_exhaustive()
         }
     }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 3f470e5453f..6acf0e84795 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -18,13 +18,14 @@ use crate::{
     types::PyTypeFlags,
     vm::{Context, PyMethod},
 };
+use alloc::fmt;
+use core::iter::zip;
+#[cfg(feature = "threading")]
+use core::sync::atomic;
 use indexmap::IndexMap;
 use itertools::Itertools;
 use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
 use rustpython_compiler_core::SourceLocation;
-#[cfg(feature = "threading")]
-use std::sync::atomic;
-use std::{fmt, iter::zip};
 
 #[derive(Clone, Debug)]
 struct Block {
@@ -91,7 +92,7 @@ struct FrameState {
 #[cfg(feature = "threading")]
 type Lasti = atomic::AtomicU32;
 #[cfg(not(feature = "threading"))]
-type Lasti = std::cell::Cell<u32>;
+type Lasti = core::cell::Cell<u32>;
 
 #[pyclass(module = false, name = "frame")]
 pub struct Frame {
@@ -142,7 +143,7 @@ impl Frame {
         func_obj: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> Self {
-        let cells_frees = std::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
+        let cells_frees = core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
             .take(code.cellvars.len())
             .chain(closure.iter().cloned())
             .collect();
@@ -189,7 +190,7 @@ impl Frame {
         let locals = &self.locals;
         let code = &**self.code;
         let map = &code.varnames;
-        let j = std::cmp::min(map.len(), code.varnames.len());
+        let j = core::cmp::min(map.len(), code.varnames.len());
         if !code.varnames.is_empty() {
             let fastlocals = self.fastlocals.lock();
             for (&k, v) in zip(&map[..j], &**fastlocals) {
@@ -2243,14 +2244,14 @@ impl ExecutingFrame<'_> {
             }
         })?;
         let msg = match elements.len().cmp(&(size as usize)) {
-            std::cmp::Ordering::Equal => {
+            core::cmp::Ordering::Equal => {
                 self.state.stack.extend(elements.into_iter().rev());
                 return Ok(None);
             }
-            std::cmp::Ordering::Greater => {
+            core::cmp::Ordering::Greater => {
                 format!("too many values to unpack (expected {size})")
             }
-            std::cmp::Ordering::Less => format!(
+            core::cmp::Ordering::Less => format!(
                 "not enough values to unpack (expected {}, got {})",
                 size,
                 elements.len()
@@ -2525,7 +2526,7 @@ impl ExecutingFrame<'_> {
     #[inline]
     fn replace_top(&mut self, mut top: PyObjectRef) -> PyObjectRef {
         let last = self.state.stack.last_mut().unwrap();
-        std::mem::swap(&mut top, last);
+        core::mem::swap(&mut top, last);
         top
     }
 
@@ -2561,12 +2562,12 @@ impl fmt::Debug for Frame {
             if elem.downcastable::<Self>() {
                 s.push_str("\n  > {frame}");
             } else {
-                std::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
+                core::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
             }
             s
         });
         let block_str = state.blocks.iter().fold(String::new(), |mut s, elem| {
-            std::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
+            core::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
             s
         });
         // TODO: fix this up
diff --git a/crates/vm/src/function/argument.rs b/crates/vm/src/function/argument.rs
index d657ff6be8f..a4877cf4042 100644
--- a/crates/vm/src/function/argument.rs
+++ b/crates/vm/src/function/argument.rs
@@ -4,9 +4,9 @@ use crate::{
     convert::ToPyObject,
     object::{Traverse, TraverseFn},
 };
+use core::ops::RangeInclusive;
 use indexmap::IndexMap;
 use itertools::Itertools;
-use std::ops::RangeInclusive;
 
 pub trait IntoFuncArgs: Sized {
     fn into_args(self, vm: &VirtualMachine) -> FuncArgs;
@@ -100,7 +100,7 @@ impl From<KwArgs> for FuncArgs {
 
 impl FromArgs for FuncArgs {
     fn from_args(_vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        Ok(std::mem::take(args))
+        Ok(core::mem::take(args))
     }
 }
 
@@ -424,7 +424,7 @@ impl<T> PosArgs<T> {
         self.0
     }
 
-    pub fn iter(&self) -> std::slice::Iter<'_, T> {
+    pub fn iter(&self) -> core::slice::Iter<'_, T> {
         self.0.iter()
     }
 }
@@ -469,7 +469,7 @@ where
 
 impl<T> IntoIterator for PosArgs<T> {
     type Item = T;
-    type IntoIter = std::vec::IntoIter<T>;
+    type IntoIter = alloc::vec::IntoIter<T>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
diff --git a/crates/vm/src/function/builtin.rs b/crates/vm/src/function/builtin.rs
index 1a91e4344ba..06fd6a44f54 100644
--- a/crates/vm/src/function/builtin.rs
+++ b/crates/vm/src/function/builtin.rs
@@ -3,7 +3,7 @@ use crate::{
     Py, PyPayload, PyRef, PyResult, VirtualMachine, convert::ToPyResult,
     object::PyThreadingConstraint,
 };
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 /// A built-in Python function.
 // PyCFunction in CPython
@@ -54,14 +54,14 @@ const fn zst_ref_out_of_thin_air<T: 'static>(x: T) -> &'static T {
     // if T is zero-sized, there's no issue forgetting it - even if it does have a Drop impl, it
     // would never get called anyway if we consider this semantically a Box::leak(Box::new(x))-type
     // operation. if T isn't zero-sized, we don't have to worry about it because we'll fail to compile.
-    std::mem::forget(x);
+    core::mem::forget(x);
     const {
-        if std::mem::size_of::<T>() != 0 {
+        if core::mem::size_of::<T>() != 0 {
             panic!("can't use a non-zero-sized type here")
         }
         // SAFETY: we just confirmed that T is zero-sized, so we can
         //         pull a value of it out of thin air.
-        unsafe { std::ptr::NonNull::<T>::dangling().as_ref() }
+        unsafe { core::ptr::NonNull::<T>::dangling().as_ref() }
     }
 }
 
diff --git a/crates/vm/src/function/either.rs b/crates/vm/src/function/either.rs
index 8700c6150db..9ee7f028bd2 100644
--- a/crates/vm/src/function/either.rs
+++ b/crates/vm/src/function/either.rs
@@ -1,7 +1,7 @@
 use crate::{
     AsObject, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, convert::ToPyObject,
 };
-use std::borrow::Borrow;
+use core::borrow::Borrow;
 
 pub enum Either<A, B> {
     A(A),
diff --git a/crates/vm/src/function/fspath.rs b/crates/vm/src/function/fspath.rs
index 44d41ab7632..7d3a0dcbbd5 100644
--- a/crates/vm/src/function/fspath.rs
+++ b/crates/vm/src/function/fspath.rs
@@ -5,7 +5,8 @@ use crate::{
     function::PyStr,
     protocol::PyBuffer,
 };
-use std::{borrow::Cow, ffi::OsStr, path::PathBuf};
+use alloc::borrow::Cow;
+use std::{ffi::OsStr, path::PathBuf};
 
 /// Helper to implement os.fspath()
 #[derive(Clone)]
@@ -111,8 +112,8 @@ impl FsPath {
         Ok(path)
     }
 
-    pub fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.as_bytes()).map_err(|e| e.into_pyexception(vm))
+    pub fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.as_bytes()).map_err(|e| e.into_pyexception(vm))
     }
 
     #[cfg(windows)]
diff --git a/crates/vm/src/function/method.rs b/crates/vm/src/function/method.rs
index 5e109176c5e..6440fd801fc 100644
--- a/crates/vm/src/function/method.rs
+++ b/crates/vm/src/function/method.rs
@@ -251,14 +251,14 @@ impl PyMethodDef {
     }
 }
 
-impl std::fmt::Debug for PyMethodDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyMethodDef {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyMethodDef")
             .field("name", &self.name)
             .field(
                 "func",
                 &(unsafe {
-                    std::mem::transmute::<&dyn PyNativeFn, [usize; 2]>(self.func)[1] as *const u8
+                    core::mem::transmute::<&dyn PyNativeFn, [usize; 2]>(self.func)[1] as *const u8
                 }),
             )
             .field("flags", &self.flags)
diff --git a/crates/vm/src/function/number.rs b/crates/vm/src/function/number.rs
index 7bb37b8f549..fb872cc48fd 100644
--- a/crates/vm/src/function/number.rs
+++ b/crates/vm/src/function/number.rs
@@ -1,9 +1,9 @@
 use super::argument::OptionalArg;
 use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, builtins::PyIntRef};
+use core::ops::Deref;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use num_traits::PrimInt;
-use std::ops::Deref;
 
 /// A Python complex-like object.
 ///
@@ -62,7 +62,7 @@ pub struct ArgIntoFloat {
 impl ArgIntoFloat {
     pub fn vec_into_f64(v: Vec<Self>) -> Vec<f64> {
         // TODO: Vec::into_raw_parts once stabilized
-        let mut v = std::mem::ManuallyDrop::new(v);
+        let mut v = core::mem::ManuallyDrop::new(v);
         let (p, l, c) = (v.as_mut_ptr(), v.len(), v.capacity());
         // SAFETY: IntoPyFloat is repr(transparent) over f64
         unsafe { Vec::from_raw_parts(p.cast(), l, c) }
diff --git a/crates/vm/src/function/protocol.rs b/crates/vm/src/function/protocol.rs
index a87ef339edd..94bdd3027eb 100644
--- a/crates/vm/src/function/protocol.rs
+++ b/crates/vm/src/function/protocol.rs
@@ -7,7 +7,7 @@ use crate::{
     protocol::{PyIter, PyIterIter, PyMapping},
     types::GenericMethod,
 };
-use std::{borrow::Borrow, marker::PhantomData, ops::Deref};
+use core::{borrow::Borrow, marker::PhantomData, ops::Deref};
 
 #[derive(Clone, Traverse)]
 pub struct ArgCallable {
@@ -24,8 +24,8 @@ impl ArgCallable {
     }
 }
 
-impl std::fmt::Debug for ArgCallable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for ArgCallable {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("ArgCallable")
             .field("obj", &self.obj)
             .field("call", &format!("{:08x}", self.call as usize))
@@ -203,7 +203,7 @@ impl<T> ArgSequence<T> {
     }
 }
 
-impl<T> std::ops::Deref for ArgSequence<T> {
+impl<T> core::ops::Deref for ArgSequence<T> {
     type Target = [T];
     #[inline(always)]
     fn deref(&self) -> &[T] {
@@ -213,14 +213,14 @@ impl<T> std::ops::Deref for ArgSequence<T> {
 
 impl<'a, T> IntoIterator for &'a ArgSequence<T> {
     type Item = &'a T;
-    type IntoIter = std::slice::Iter<'a, T>;
+    type IntoIter = core::slice::Iter<'a, T>;
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 impl<T> IntoIterator for ArgSequence<T> {
     type Item = T;
-    type IntoIter = std::vec::IntoIter<T>;
+    type IntoIter = alloc::vec::IntoIter<T>;
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
     }
diff --git a/crates/vm/src/intern.rs b/crates/vm/src/intern.rs
index a5b2a798d53..a50b8871cb9 100644
--- a/crates/vm/src/intern.rs
+++ b/crates/vm/src/intern.rs
@@ -6,10 +6,8 @@ use crate::{
     common::lock::PyRwLock,
     convert::ToPyObject,
 };
-use std::{
-    borrow::{Borrow, ToOwned},
-    ops::Deref,
-};
+use alloc::borrow::ToOwned;
+use core::{borrow::Borrow, ops::Deref};
 
 #[derive(Debug)]
 pub struct StringPool {
@@ -86,8 +84,8 @@ pub struct CachedPyStrRef {
     inner: PyRefExact<PyStr>,
 }
 
-impl std::hash::Hash for CachedPyStrRef {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+impl core::hash::Hash for CachedPyStrRef {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.inner.as_wtf8().hash(state)
     }
 }
@@ -100,7 +98,7 @@ impl PartialEq for CachedPyStrRef {
 
 impl Eq for CachedPyStrRef {}
 
-impl std::borrow::Borrow<Wtf8> for CachedPyStrRef {
+impl core::borrow::Borrow<Wtf8> for CachedPyStrRef {
     #[inline]
     fn borrow(&self) -> &Wtf8 {
         self.as_wtf8()
@@ -119,7 +117,7 @@ impl CachedPyStrRef {
     /// the given cache must be alive while returned reference is alive
     #[inline]
     const unsafe fn as_interned_str(&self) -> &'static PyStrInterned {
-        unsafe { std::mem::transmute_copy(self) }
+        unsafe { core::mem::transmute_copy(self) }
     }
 
     #[inline]
@@ -135,7 +133,7 @@ pub struct PyInterned<T> {
 impl<T: PyPayload> PyInterned<T> {
     #[inline]
     pub fn leak(cache: PyRef<T>) -> &'static Self {
-        unsafe { std::mem::transmute(cache) }
+        unsafe { core::mem::transmute(cache) }
     }
 
     #[inline]
@@ -163,9 +161,9 @@ impl<T: PyPayload> Borrow<PyObject> for PyInterned<T> {
 
 // NOTE: std::hash::Hash of Self and Self::Borrowed *must* be the same
 // This is ok only because PyObject doesn't implement Hash
-impl<T: PyPayload> std::hash::Hash for PyInterned<T> {
+impl<T: PyPayload> core::hash::Hash for PyInterned<T> {
     #[inline(always)]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.get_id().hash(state)
     }
 }
@@ -188,15 +186,15 @@ impl<T> Deref for PyInterned<T> {
 impl<T: PyPayload> PartialEq for PyInterned<T> {
     #[inline(always)]
     fn eq(&self, other: &Self) -> bool {
-        std::ptr::eq(self, other)
+        core::ptr::eq(self, other)
     }
 }
 
 impl<T: PyPayload> Eq for PyInterned<T> {}
 
-impl<T: std::fmt::Debug + PyPayload> std::fmt::Debug for PyInterned<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&**self, f)?;
+impl<T: core::fmt::Debug + PyPayload> core::fmt::Debug for PyInterned<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&**self, f)?;
         write!(f, "@{:p}", self.as_ptr())
     }
 }
@@ -308,7 +306,7 @@ impl MaybeInternedString for Py<PyStr> {
     #[inline(always)]
     fn as_interned(&self) -> Option<&'static PyStrInterned> {
         if self.as_object().is_interned() {
-            Some(unsafe { std::mem::transmute::<&Self, &PyInterned<PyStr>>(self) })
+            Some(unsafe { core::mem::transmute::<&Self, &PyInterned<PyStr>>(self) })
         } else {
             None
         }
diff --git a/crates/vm/src/lib.rs b/crates/vm/src/lib.rs
index f461c612955..3f0eee278a2 100644
--- a/crates/vm/src/lib.rs
+++ b/crates/vm/src/lib.rs
@@ -24,6 +24,7 @@ extern crate bitflags;
 #[macro_use]
 extern crate log;
 // extern crate env_logger;
+extern crate alloc;
 
 #[macro_use]
 extern crate rustpython_derive;
diff --git a/crates/vm/src/macros.rs b/crates/vm/src/macros.rs
index 1284c202782..f5c912d89cf 100644
--- a/crates/vm/src/macros.rs
+++ b/crates/vm/src/macros.rs
@@ -146,8 +146,8 @@ macro_rules! match_class {
     };
     (match ($obj:expr) { ref $binding:ident @ $class:ty => $expr:expr, $($rest:tt)* }) => {
         match $obj.downcast_ref::<$class>() {
-            ::std::option::Option::Some($binding) => $expr,
-            ::std::option::Option::None => $crate::match_class!(match ($obj) { $($rest)* }),
+            core::option::Option::Some($binding) => $expr,
+            core::option::Option::None => $crate::match_class!(match ($obj) { $($rest)* }),
         }
     };
 
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index d52a33884ce..cee3fac266e 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -31,11 +31,13 @@ use crate::{
     object::traverse::{MaybeTraverse, Traverse, TraverseFn},
 };
 use itertools::Itertools;
-use std::{
+
+use alloc::fmt;
+
+use core::{
     any::TypeId,
     borrow::Borrow,
     cell::UnsafeCell,
-    fmt,
     marker::PhantomData,
     mem::ManuallyDrop,
     ops::Deref,
@@ -82,7 +84,7 @@ pub(super) struct Erased;
 pub(super) unsafe fn drop_dealloc_obj<T: PyPayload>(x: *mut PyObject) {
     drop(unsafe { Box::from_raw(x as *mut PyInner<T>) });
 }
-pub(super) unsafe fn debug_obj<T: PyPayload + std::fmt::Debug>(
+pub(super) unsafe fn debug_obj<T: PyPayload + core::fmt::Debug>(
     x: &PyObject,
     f: &mut fmt::Formatter<'_>,
 ) -> fmt::Result {
@@ -114,7 +116,7 @@ pub(super) struct PyInner<T> {
 
     pub(super) payload: T,
 }
-pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = std::mem::size_of::<PyInner<()>>();
+pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = core::mem::size_of::<PyInner<()>>();
 
 impl<T: fmt::Debug> fmt::Debug for PyInner<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -376,7 +378,7 @@ impl PyWeak {
             let node_ptr = unsafe { NonNull::new_unchecked(py_inner as *mut Py<Self>) };
             // the list doesn't have ownership over its PyRef<PyWeak>! we're being dropped
             // right now so that should be obvious!!
-            std::mem::forget(unsafe { guard.list.remove(node_ptr) });
+            core::mem::forget(unsafe { guard.list.remove(node_ptr) });
             guard.ref_count -= 1;
             if Some(node_ptr) == guard.generic_weakref {
                 guard.generic_weakref = None;
@@ -438,11 +440,11 @@ impl InstanceDict {
 
     #[inline]
     pub fn replace(&self, d: PyDictRef) -> PyDictRef {
-        std::mem::replace(&mut self.d.write(), d)
+        core::mem::replace(&mut self.d.write(), d)
     }
 }
 
-impl<T: PyPayload + std::fmt::Debug> PyInner<T> {
+impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
     fn new(payload: T, typ: PyTypeRef, dict: Option<PyDictRef>) -> Box<Self> {
         let member_count = typ.slots.member_count;
         Box::new(Self {
@@ -453,7 +455,7 @@ impl<T: PyPayload + std::fmt::Debug> PyInner<T> {
             dict: dict.map(InstanceDict::new),
             weak_list: WeakRefList::new(),
             payload,
-            slots: std::iter::repeat_with(|| PyRwLock::new(None))
+            slots: core::iter::repeat_with(|| PyRwLock::new(None))
                 .take(member_count)
                 .collect_vec()
                 .into_boxed_slice(),
@@ -513,7 +515,7 @@ impl PyObjectRef {
     #[inline(always)]
     pub const fn into_raw(self) -> NonNull<PyObject> {
         let ptr = self.ptr;
-        std::mem::forget(self);
+        core::mem::forget(self);
         ptr
     }
 
@@ -946,12 +948,12 @@ impl<T: PyPayload> Borrow<PyObject> for Py<T> {
     }
 }
 
-impl<T> std::hash::Hash for Py<T>
+impl<T> core::hash::Hash for Py<T>
 where
-    T: std::hash::Hash + PyPayload,
+    T: core::hash::Hash + PyPayload,
 {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.deref().hash(state)
     }
 }
@@ -978,7 +980,7 @@ where
     }
 }
 
-impl<T: PyPayload + std::fmt::Debug> fmt::Debug for Py<T> {
+impl<T: PyPayload + core::fmt::Debug> fmt::Debug for Py<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(f)
     }
@@ -1059,12 +1061,12 @@ impl<T: PyPayload> PyRef<T> {
 
     pub const fn leak(pyref: Self) -> &'static Py<T> {
         let ptr = pyref.ptr;
-        std::mem::forget(pyref);
+        core::mem::forget(pyref);
         unsafe { ptr.as_ref() }
     }
 }
 
-impl<T: PyPayload + std::fmt::Debug> PyRef<T> {
+impl<T: PyPayload + core::fmt::Debug> PyRef<T> {
     #[inline(always)]
     pub fn new_ref(payload: T, typ: crate::builtins::PyTypeRef, dict: Option<PyDictRef>) -> Self {
         let inner = Box::into_raw(PyInner::new(payload, typ, dict));
@@ -1074,9 +1076,9 @@ impl<T: PyPayload + std::fmt::Debug> PyRef<T> {
     }
 }
 
-impl<T: crate::class::PySubclass + std::fmt::Debug> PyRef<T>
+impl<T: crate::class::PySubclass + core::fmt::Debug> PyRef<T>
 where
-    T::Base: std::fmt::Debug,
+    T::Base: core::fmt::Debug,
 {
     /// Converts this reference to the base type (ownership transfer).
     /// # Safety
@@ -1086,7 +1088,7 @@ where
         let obj: PyObjectRef = self.into();
         match obj.downcast() {
             Ok(base_ref) => base_ref,
-            Err(_) => unsafe { std::hint::unreachable_unchecked() },
+            Err(_) => unsafe { core::hint::unreachable_unchecked() },
         }
     }
     #[inline]
@@ -1098,7 +1100,7 @@ where
         let obj: PyObjectRef = self.into();
         match obj.downcast::<U>() {
             Ok(upcast_ref) => upcast_ref,
-            Err(_) => unsafe { std::hint::unreachable_unchecked() },
+            Err(_) => unsafe { core::hint::unreachable_unchecked() },
         }
     }
 }
@@ -1176,12 +1178,12 @@ impl<T> Deref for PyRef<T> {
     }
 }
 
-impl<T> std::hash::Hash for PyRef<T>
+impl<T> core::hash::Hash for PyRef<T>
 where
-    T: std::hash::Hash + PyPayload,
+    T: core::hash::Hash + PyPayload,
 {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.deref().hash(state)
     }
 }
@@ -1230,10 +1232,10 @@ macro_rules! partially_init {
                 $($uninit_field: unreachable!(),)*
             }};
         }
-        let mut m = ::std::mem::MaybeUninit::<$ty>::uninit();
+        let mut m = ::core::mem::MaybeUninit::<$ty>::uninit();
         #[allow(unused_unsafe)]
         unsafe {
-            $(::std::ptr::write(&mut (*m.as_mut_ptr()).$init_field, $init_value);)*
+            $(::core::ptr::write(&mut (*m.as_mut_ptr()).$init_field, $init_value);)*
         }
         m
     }};
@@ -1241,7 +1243,7 @@ macro_rules! partially_init {
 
 pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
     use crate::{builtins::object, class::PyClassImpl};
-    use std::mem::MaybeUninit;
+    use core::mem::MaybeUninit;
 
     // `type` inherits from `object`
     // and both `type` and `object are instances of `type`.
diff --git a/crates/vm/src/object/ext.rs b/crates/vm/src/object/ext.rs
index 88f5fdc66d7..c1a5f63f85e 100644
--- a/crates/vm/src/object/ext.rs
+++ b/crates/vm/src/object/ext.rs
@@ -12,9 +12,10 @@ use crate::{
     convert::{IntoPyException, ToPyObject, ToPyResult, TryFromObject},
     vm::Context,
 };
-use std::{
+use alloc::fmt;
+
+use core::{
     borrow::Borrow,
-    fmt,
     marker::PhantomData,
     ops::Deref,
     ptr::{NonNull, null_mut},
@@ -108,7 +109,7 @@ impl<T: PyPayload> AsRef<Py<T>> for PyExact<T> {
     }
 }
 
-impl<T: PyPayload> std::borrow::ToOwned for PyExact<T> {
+impl<T: PyPayload> alloc::borrow::ToOwned for PyExact<T> {
     type Owned = PyRefExact<T>;
 
     fn to_owned(&self) -> Self::Owned {
@@ -581,7 +582,7 @@ impl ToPyObject for &PyObject {
 // explicitly implementing `ToPyObject`.
 impl<T> ToPyObject for T
 where
-    T: PyPayload + std::fmt::Debug + Sized,
+    T: PyPayload + core::fmt::Debug + Sized,
 {
     #[inline(always)]
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
diff --git a/crates/vm/src/object/payload.rs b/crates/vm/src/object/payload.rs
index 4b900b7caa1..3a2f42675f7 100644
--- a/crates/vm/src/object/payload.rs
+++ b/crates/vm/src/object/payload.rs
@@ -27,8 +27,8 @@ pub(crate) fn cold_downcast_type_error(
 
 pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
-    fn payload_type_id() -> std::any::TypeId {
-        std::any::TypeId::of::<Self>()
+    fn payload_type_id() -> core::any::TypeId {
+        core::any::TypeId::of::<Self>()
     }
 
     /// # Safety: this function should only be called if `payload_type_id` matches the type of `obj`.
@@ -56,7 +56,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
     fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef
     where
-        Self: std::fmt::Debug,
+        Self: core::fmt::Debug,
     {
         self.into_ref(&vm.ctx).into()
     }
@@ -64,7 +64,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
     fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>
     where
-        Self: std::fmt::Debug,
+        Self: core::fmt::Debug,
     {
         let dict = if cls.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
             Some(ctx.new_dict())
@@ -77,7 +77,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
     fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>
     where
-        Self: std::fmt::Debug,
+        Self: core::fmt::Debug,
     {
         unsafe {
             // Self::into_ref() always returns exact typed PyRef
@@ -88,7 +88,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
     fn into_ref(self, ctx: &Context) -> PyRef<Self>
     where
-        Self: std::fmt::Debug,
+        Self: core::fmt::Debug,
     {
         let cls = Self::class(ctx);
         self._into_ref(cls.to_owned(), ctx)
@@ -97,7 +97,7 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
     #[inline]
     fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyTypeRef) -> PyResult<PyRef<Self>>
     where
-        Self: std::fmt::Debug,
+        Self: core::fmt::Debug,
     {
         let exact_class = Self::class(&vm.ctx);
         if cls.fast_issubclass(exact_class) {
@@ -138,11 +138,11 @@ pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
 }
 
 pub trait PyObjectPayload:
-    PyPayload + std::any::Any + std::fmt::Debug + MaybeTraverse + PyThreadingConstraint + 'static
+    PyPayload + core::any::Any + core::fmt::Debug + MaybeTraverse + PyThreadingConstraint + 'static
 {
 }
 
-impl<T: PyPayload + std::fmt::Debug + 'static> PyObjectPayload for T {}
+impl<T: PyPayload + core::fmt::Debug + 'static> PyObjectPayload for T {}
 
 pub trait SlotOffset {
     fn offset() -> usize;
diff --git a/crates/vm/src/object/traverse.rs b/crates/vm/src/object/traverse.rs
index 31bee8becea..2ce0db41a5e 100644
--- a/crates/vm/src/object/traverse.rs
+++ b/crates/vm/src/object/traverse.rs
@@ -1,4 +1,4 @@
-use std::ptr::NonNull;
+use core::ptr::NonNull;
 
 use rustpython_common::lock::{PyMutex, PyRwLock};
 
diff --git a/crates/vm/src/object/traverse_object.rs b/crates/vm/src/object/traverse_object.rs
index 281b0e56eb5..075ce5b9513 100644
--- a/crates/vm/src/object/traverse_object.rs
+++ b/crates/vm/src/object/traverse_object.rs
@@ -1,4 +1,4 @@
-use std::fmt;
+use alloc::fmt;
 
 use crate::{
     PyObject,
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
index 77abbee2cd5..25fcafb74c5 100644
--- a/crates/vm/src/ospath.rs
+++ b/crates/vm/src/ospath.rs
@@ -230,12 +230,12 @@ impl OsPath {
         self.path.into_encoded_bytes()
     }
 
-    pub fn to_string_lossy(&self) -> std::borrow::Cow<'_, str> {
+    pub fn to_string_lossy(&self) -> alloc::borrow::Cow<'_, str> {
         self.path.to_string_lossy()
     }
 
-    pub fn into_cstring(self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.into_bytes()).map_err(|err| err.to_pyexception(vm))
+    pub fn into_cstring(self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.into_bytes()).map_err(|err| err.to_pyexception(vm))
     }
 
     #[cfg(windows)]
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
index 88524a9a9ee..0fe4d15458b 100644
--- a/crates/vm/src/protocol/buffer.rs
+++ b/crates/vm/src/protocol/buffer.rs
@@ -10,8 +10,9 @@ use crate::{
     object::PyObjectPayload,
     sliceable::SequenceIndexOp,
 };
+use alloc::borrow::Cow;
+use core::{fmt::Debug, ops::Range};
 use itertools::Itertools;
-use std::{borrow::Cow, fmt::Debug, ops::Range};
 
 pub struct BufferMethods {
     pub obj_bytes: fn(&PyBuffer) -> BorrowedValue<'_, [u8]>,
@@ -21,7 +22,7 @@ pub struct BufferMethods {
 }
 
 impl Debug for BufferMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("BufferMethods")
             .field("obj_bytes", &(self.obj_bytes as usize))
             .field("obj_bytes_mut", &(self.obj_bytes_mut as usize))
@@ -134,8 +135,8 @@ impl PyBuffer {
     pub(crate) unsafe fn drop_without_release(&mut self) {
         // SAFETY: requirements forwarded from caller
         unsafe {
-            std::ptr::drop_in_place(&mut self.obj);
-            std::ptr::drop_in_place(&mut self.desc);
+            core::ptr::drop_in_place(&mut self.obj);
+            core::ptr::drop_in_place(&mut self.desc);
         }
     }
 }
@@ -414,7 +415,7 @@ pub struct VecBuffer {
 #[pyclass(flags(BASETYPE, DISALLOW_INSTANTIATION))]
 impl VecBuffer {
     pub fn take(&self) -> Vec<u8> {
-        std::mem::take(&mut self.data.lock())
+        core::mem::take(&mut self.data.lock())
     }
 }
 
diff --git a/crates/vm/src/protocol/callable.rs b/crates/vm/src/protocol/callable.rs
index 5280e04e928..fa5e48d58ba 100644
--- a/crates/vm/src/protocol/callable.rs
+++ b/crates/vm/src/protocol/callable.rs
@@ -61,8 +61,8 @@ enum TraceEvent {
     Return,
 }
 
-impl std::fmt::Display for TraceEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for TraceEvent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         use TraceEvent::*;
         match self {
             Call => write!(f, "call"),
diff --git a/crates/vm/src/protocol/iter.rs b/crates/vm/src/protocol/iter.rs
index f6146543de9..aa6ab6769cd 100644
--- a/crates/vm/src/protocol/iter.rs
+++ b/crates/vm/src/protocol/iter.rs
@@ -4,8 +4,8 @@ use crate::{
     convert::{ToPyObject, ToPyResult},
     object::{Traverse, TraverseFn},
 };
-use std::borrow::Borrow;
-use std::ops::Deref;
+use core::borrow::Borrow;
+use core::ops::Deref;
 
 /// Iterator Protocol
 // https://docs.python.org/3/c-api/iter.html
@@ -223,7 +223,7 @@ where
     vm: &'a VirtualMachine,
     obj: O, // creating PyIter<O> is zero-cost
     length_hint: Option<usize>,
-    _phantom: std::marker::PhantomData<T>,
+    _phantom: core::marker::PhantomData<T>,
 }
 
 unsafe impl<T, O> Traverse for PyIterIter<'_, T, O>
@@ -244,7 +244,7 @@ where
             vm,
             obj,
             length_hint,
-            _phantom: std::marker::PhantomData,
+            _phantom: core::marker::PhantomData,
         }
     }
 }
diff --git a/crates/vm/src/protocol/mapping.rs b/crates/vm/src/protocol/mapping.rs
index 43dafeb9238..6c200043e35 100644
--- a/crates/vm/src/protocol/mapping.rs
+++ b/crates/vm/src/protocol/mapping.rs
@@ -22,8 +22,8 @@ pub struct PyMappingSlots {
     >,
 }
 
-impl std::fmt::Debug for PyMappingSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyMappingSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("PyMappingSlots")
     }
 }
@@ -56,8 +56,8 @@ pub struct PyMappingMethods {
         Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
 }
 
-impl std::fmt::Debug for PyMappingMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyMappingMethods {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("PyMappingMethods")
     }
 }
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
index c208bf26de8..58891d1d710 100644
--- a/crates/vm/src/protocol/number.rs
+++ b/crates/vm/src/protocol/number.rs
@@ -1,4 +1,4 @@
-use std::ops::Deref;
+use core::ops::Deref;
 
 use crossbeam_utils::atomic::AtomicCell;
 
diff --git a/crates/vm/src/protocol/sequence.rs b/crates/vm/src/protocol/sequence.rs
index 888ef91565f..cee46a29089 100644
--- a/crates/vm/src/protocol/sequence.rs
+++ b/crates/vm/src/protocol/sequence.rs
@@ -29,8 +29,8 @@ pub struct PySequenceSlots {
     pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
 }
 
-impl std::fmt::Debug for PySequenceSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PySequenceSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("PySequenceSlots")
     }
 }
@@ -83,8 +83,8 @@ pub struct PySequenceMethods {
     pub inplace_repeat: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
 }
 
-impl std::fmt::Debug for PySequenceMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PySequenceMethods {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("PySequenceMethods")
     }
 }
diff --git a/crates/vm/src/py_io.rs b/crates/vm/src/py_io.rs
index a8063673a70..5649463b30e 100644
--- a/crates/vm/src/py_io.rs
+++ b/crates/vm/src/py_io.rs
@@ -3,7 +3,9 @@ use crate::{
     builtins::{PyBaseExceptionRef, PyBytes, PyStr},
     common::ascii,
 };
-use std::{fmt, io, ops};
+use alloc::fmt;
+use core::ops;
+use std::io;
 
 pub trait Write {
     type Error;
diff --git a/crates/vm/src/py_serde.rs b/crates/vm/src/py_serde.rs
index f9a5f4bc060..945068113f1 100644
--- a/crates/vm/src/py_serde.rs
+++ b/crates/vm/src/py_serde.rs
@@ -130,7 +130,7 @@ impl<'de> DeserializeSeed<'de> for PyObjectDeserializer<'de> {
 impl<'de> Visitor<'de> for PyObjectDeserializer<'de> {
     type Value = PyObjectRef;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         formatter.write_str("a type that can deserialize in Python")
     }
 
diff --git a/crates/vm/src/readline.rs b/crates/vm/src/readline.rs
index 77402dc6839..d62d520ecbd 100644
--- a/crates/vm/src/readline.rs
+++ b/crates/vm/src/readline.rs
@@ -5,7 +5,7 @@
 
 use std::{io, path::Path};
 
-type OtherError = Box<dyn std::error::Error>;
+type OtherError = Box<dyn core::error::Error>;
 type OtherResult<T> = Result<T, OtherError>;
 
 pub enum ReadlineResult {
diff --git a/crates/vm/src/scope.rs b/crates/vm/src/scope.rs
index 4f80e9999ec..74392dc9b73 100644
--- a/crates/vm/src/scope.rs
+++ b/crates/vm/src/scope.rs
@@ -1,5 +1,5 @@
 use crate::{VirtualMachine, builtins::PyDictRef, function::ArgMapping};
-use std::fmt;
+use alloc::fmt;
 
 #[derive(Clone)]
 pub struct Scope {
diff --git a/crates/vm/src/sequence.rs b/crates/vm/src/sequence.rs
index 6e03ad1697e..0bc12fd2631 100644
--- a/crates/vm/src/sequence.rs
+++ b/crates/vm/src/sequence.rs
@@ -6,8 +6,8 @@ use crate::{
     types::PyComparisonOp,
     vm::{MAX_MEMORY_SIZE, VirtualMachine},
 };
+use core::ops::{Deref, Range};
 use optional::Optioned;
-use std::ops::{Deref, Range};
 
 pub trait MutObjectSequenceOp {
     type Inner: ?Sized;
@@ -100,7 +100,7 @@ where
     fn mul(&self, vm: &VirtualMachine, n: isize) -> PyResult<Vec<T>> {
         let n = vm.check_repeat_or_overflow_error(self.as_ref().len(), n)?;
 
-        if n > 1 && std::mem::size_of_val(self.as_ref()) >= MAX_MEMORY_SIZE / n {
+        if n > 1 && core::mem::size_of_val(self.as_ref()) >= MAX_MEMORY_SIZE / n {
             return Err(vm.new_memory_error(""));
         }
 
diff --git a/crates/vm/src/signal.rs b/crates/vm/src/signal.rs
index 1074c8e8f11..4a1b84a1521 100644
--- a/crates/vm/src/signal.rs
+++ b/crates/vm/src/signal.rs
@@ -1,12 +1,8 @@
 #![cfg_attr(target_os = "wasi", allow(dead_code))]
 use crate::{PyResult, VirtualMachine};
-use std::{
-    fmt,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc,
-    },
-};
+use alloc::fmt;
+use core::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc;
 
 pub(crate) const NSIG: usize = 64;
 static ANY_TRIGGERED: AtomicBool = AtomicBool::new(false);
diff --git a/crates/vm/src/sliceable.rs b/crates/vm/src/sliceable.rs
index 786b66fb36a..e416f5a1b49 100644
--- a/crates/vm/src/sliceable.rs
+++ b/crates/vm/src/sliceable.rs
@@ -3,9 +3,9 @@ use crate::{
     PyObject, PyResult, VirtualMachine,
     builtins::{int::PyInt, slice::PySlice},
 };
+use core::ops::Range;
 use malachite_bigint::BigInt;
 use num_traits::{Signed, ToPrimitive};
-use std::ops::Range;
 
 pub trait SliceableSequenceMutOp
 where
diff --git a/crates/vm/src/stdlib/ast/elif_else_clause.rs b/crates/vm/src/stdlib/ast/elif_else_clause.rs
index 581fc499b8a..e2a8789dd08 100644
--- a/crates/vm/src/stdlib/ast/elif_else_clause.rs
+++ b/crates/vm/src/stdlib/ast/elif_else_clause.rs
@@ -3,7 +3,7 @@ use rustpython_compiler_core::SourceFile;
 
 pub(super) fn ast_to_object(
     clause: ruff::ElifElseClause,
-    mut rest: std::vec::IntoIter<ruff::ElifElseClause>,
+    mut rest: alloc::vec::IntoIter<ruff::ElifElseClause>,
     vm: &VirtualMachine,
     source_file: &SourceFile,
 ) -> PyObjectRef {
diff --git a/crates/vm/src/stdlib/ast/parameter.rs b/crates/vm/src/stdlib/ast/parameter.rs
index 87fa736687b..44fcbb2b464 100644
--- a/crates/vm/src/stdlib/ast/parameter.rs
+++ b/crates/vm/src/stdlib/ast/parameter.rs
@@ -403,7 +403,7 @@ fn merge_keyword_parameter_defaults(
     kw_only_args: KeywordParameters,
     defaults: ParameterDefaults,
 ) -> Vec<ruff::ParameterWithDefault> {
-    std::iter::zip(kw_only_args.keywords, defaults.defaults)
+    core::iter::zip(kw_only_args.keywords, defaults.defaults)
         .map(|(parameter, default)| ruff::ParameterWithDefault {
             node_index: Default::default(),
             parameter,
diff --git a/crates/vm/src/stdlib/ast/string.rs b/crates/vm/src/stdlib/ast/string.rs
index f3df8d99262..ffa5a3a958a 100644
--- a/crates/vm/src/stdlib/ast/string.rs
+++ b/crates/vm/src/stdlib/ast/string.rs
@@ -12,7 +12,7 @@ fn ruff_fstring_value_into_iter(
     });
     (0..fstring_value.as_slice().len()).map(move |i| {
         let tmp = fstring_value.iter_mut().nth(i).unwrap();
-        std::mem::replace(tmp, default.clone())
+        core::mem::replace(tmp, default.clone())
     })
 }
 
@@ -28,7 +28,7 @@ fn ruff_fstring_element_into_iter(
     (0..fstring_element.into_iter().len()).map(move |i| {
         let fstring_element = &mut fstring_element;
         let tmp = fstring_element.into_iter().nth(i).unwrap();
-        std::mem::replace(tmp, default.clone())
+        core::mem::replace(tmp, default.clone())
     })
 }
 
diff --git a/crates/vm/src/stdlib/atexit.rs b/crates/vm/src/stdlib/atexit.rs
index b1832b5481d..2286c36f1db 100644
--- a/crates/vm/src/stdlib/atexit.rs
+++ b/crates/vm/src/stdlib/atexit.rs
@@ -34,7 +34,7 @@ mod atexit {
 
     #[pyfunction]
     pub fn _run_exitfuncs(vm: &VirtualMachine) {
-        let funcs: Vec<_> = std::mem::take(&mut *vm.state.atexit_funcs.lock());
+        let funcs: Vec<_> = core::mem::take(&mut *vm.state.atexit_funcs.lock());
         for (func, args) in funcs.into_iter().rev() {
             if let Err(e) = func.call(args, vm) {
                 let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index 7cd91f8b4b7..c82161fc553 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -175,7 +175,7 @@ mod builtins {
                 let source = source.borrow_bytes();
 
                 // TODO: compiler::compile should probably get bytes
-                let source = std::str::from_utf8(&source)
+                let source = core::str::from_utf8(&source)
                     .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
 
                 let flags = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
@@ -333,7 +333,7 @@ mod builtins {
                     ));
                 }
 
-                let source = std::str::from_utf8(source).map_err(|err| {
+                let source = core::str::from_utf8(source).map_err(|err| {
                     let msg = format!(
                         "(unicode error) 'utf-8' codec can't decode byte 0x{:x?} in position {}: invalid start byte",
                         source[err.valid_up_to()],
@@ -605,7 +605,7 @@ mod builtins {
         }
 
         let candidates = match args.args.len().cmp(&1) {
-            std::cmp::Ordering::Greater => {
+            core::cmp::Ordering::Greater => {
                 if default.is_some() {
                     return Err(vm.new_type_error(format!(
                         "Cannot specify a default for {func_name}() with multiple positional arguments"
@@ -613,8 +613,8 @@ mod builtins {
                 }
                 args.args
             }
-            std::cmp::Ordering::Equal => args.args[0].try_to_value(vm)?,
-            std::cmp::Ordering::Less => {
+            core::cmp::Ordering::Equal => args.args[0].try_to_value(vm)?,
+            core::cmp::Ordering::Less => {
                 // zero arguments means type error:
                 return Err(
                     vm.new_type_error(format!("{func_name} expected at least 1 argument, got 0"))
diff --git a/crates/vm/src/stdlib/codecs.rs b/crates/vm/src/stdlib/codecs.rs
index 821b313090c..1661eef1750 100644
--- a/crates/vm/src/stdlib/codecs.rs
+++ b/crates/vm/src/stdlib/codecs.rs
@@ -270,7 +270,7 @@ mod _codecs {
                 wide.len() as i32,
                 std::ptr::null_mut(),
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
                 std::ptr::null_mut(),
             )
         };
@@ -291,7 +291,7 @@ mod _codecs {
                 wide.len() as i32,
                 buffer.as_mut_ptr().cast(),
                 size,
-                std::ptr::null(),
+                core::ptr::null(),
                 if errors == "strict" {
                     &mut used_default_char
                 } else {
@@ -472,7 +472,7 @@ mod _codecs {
                 wide.len() as i32,
                 std::ptr::null_mut(),
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
                 std::ptr::null_mut(),
             )
         };
@@ -493,7 +493,7 @@ mod _codecs {
                 wide.len() as i32,
                 buffer.as_mut_ptr().cast(),
                 size,
-                std::ptr::null(),
+                core::ptr::null(),
                 if errors == "strict" {
                     &mut used_default_char
                 } else {
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index eae56968cba..1249fa9315d 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -22,9 +22,9 @@ mod _collections {
         },
         utils::collection_repr,
     };
+    use alloc::collections::VecDeque;
+    use core::cmp::max;
     use crossbeam_utils::atomic::AtomicCell;
-    use std::cmp::max;
-    use std::collections::VecDeque;
 
     #[pyattr]
     #[pyclass(module = "collections", name = "deque", unhashable = true)]
@@ -157,7 +157,7 @@ mod _collections {
             let mut created = VecDeque::from(elements);
             let mut borrowed = self.borrow_deque_mut();
             created.append(&mut borrowed);
-            std::mem::swap(&mut created, &mut borrowed);
+            core::mem::swap(&mut created, &mut borrowed);
             Ok(())
         }
 
@@ -426,7 +426,7 @@ mod _collections {
             inner.get(index).map(|r| r.as_ref())
         }
 
-        fn do_lock(&self) -> impl std::ops::Deref<Target = Self::Inner> {
+        fn do_lock(&self) -> impl core::ops::Deref<Target = Self::Inner> {
             self.borrow_deque()
         }
     }
@@ -484,7 +484,7 @@ mod _collections {
                     // `maxlen` is better to be defined as UnsafeCell in common practice,
                     // but then more type works without any safety benefits
                     let unsafe_maxlen =
-                        &zelf.maxlen as *const _ as *const std::cell::UnsafeCell<Option<usize>>;
+                        &zelf.maxlen as *const _ as *const core::cell::UnsafeCell<Option<usize>>;
                     *(*unsafe_maxlen).get() = maxlen;
                 }
                 if let Some(elements) = elements {
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index a9c0636bd12..f3b6dd25aca 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -15,11 +15,11 @@ use crate::{
     class::PyClassImpl,
     types::TypeDataRef,
 };
-use std::ffi::{
+use core::ffi::{
     c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
     c_ulonglong, c_ushort,
 };
-use std::mem;
+use core::mem;
 use widestring::WideChar;
 
 pub use array::PyCArray;
@@ -387,7 +387,7 @@ pub(crate) mod _ctypes {
     const RTLD_GLOBAL: i32 = 0;
 
     #[pyattr]
-    const SIZEOF_TIME_T: usize = std::mem::size_of::<libc::time_t>();
+    const SIZEOF_TIME_T: usize = core::mem::size_of::<libc::time_t>();
 
     #[pyattr]
     const CTYPES_MAX_ARGCOUNT: usize = 1024;
@@ -535,11 +535,11 @@ pub(crate) mod _ctypes {
                 {
                     return Ok(super::get_size(type_str.as_ref()));
                 }
-                return Ok(std::mem::size_of::<usize>());
+                return Ok(core::mem::size_of::<usize>());
             }
             // Pointer types
             if type_obj.fast_issubclass(PyCPointer::static_type()) {
-                return Ok(std::mem::size_of::<usize>());
+                return Ok(core::mem::size_of::<usize>());
             }
             return Err(vm.new_type_error("this type has no size"));
         }
@@ -550,7 +550,7 @@ pub(crate) mod _ctypes {
             return Ok(cdata.size());
         }
         if obj.fast_isinstance(PyCPointer::static_type()) {
-            return Ok(std::mem::size_of::<usize>());
+            return Ok(core::mem::size_of::<usize>());
         }
 
         Err(vm.new_type_error("this type has no size"))
@@ -596,13 +596,17 @@ pub(crate) mod _ctypes {
             }
             None => {
                 // dlopen(NULL, mode) to get the current process handle (for pythonapi)
-                let handle = unsafe { libc::dlopen(std::ptr::null(), mode) };
+                let handle = unsafe { libc::dlopen(core::ptr::null(), mode) };
                 if handle.is_null() {
                     let err = unsafe { libc::dlerror() };
                     let msg = if err.is_null() {
                         "dlopen() error".to_string()
                     } else {
-                        unsafe { std::ffi::CStr::from_ptr(err).to_string_lossy().into_owned() }
+                        unsafe {
+                            core::ffi::CStr::from_ptr(err)
+                                .to_string_lossy()
+                                .into_owned()
+                        }
                     };
                     return Err(vm.new_os_error(msg));
                 }
@@ -641,7 +645,7 @@ pub(crate) mod _ctypes {
         name: crate::builtins::PyStrRef,
         vm: &VirtualMachine,
     ) -> PyResult<usize> {
-        let symbol_name = std::ffi::CString::new(name.as_str())
+        let symbol_name = alloc::ffi::CString::new(name.as_str())
             .map_err(|_| vm.new_value_error("symbol name contains null byte"))?;
 
         // Clear previous error
@@ -652,7 +656,11 @@ pub(crate) mod _ctypes {
         // Check for error via dlerror first
         let err = unsafe { libc::dlerror() };
         if !err.is_null() {
-            let msg = unsafe { std::ffi::CStr::from_ptr(err).to_string_lossy().into_owned() };
+            let msg = unsafe {
+                core::ffi::CStr::from_ptr(err)
+                    .to_string_lossy()
+                    .into_owned()
+            };
             return Err(vm.new_os_error(msg));
         }
 
@@ -851,7 +859,7 @@ pub(crate) mod _ctypes {
         }
         if obj.fast_isinstance(PyCPointer::static_type()) {
             // Pointer alignment is always pointer size
-            return Ok(std::mem::align_of::<usize>());
+            return Ok(core::mem::align_of::<usize>());
         }
         if obj.fast_isinstance(PyCUnion::static_type()) {
             // Calculate alignment from _fields_
@@ -914,7 +922,7 @@ pub(crate) mod _ctypes {
 
     #[pyfunction]
     fn resize(obj: PyObjectRef, size: isize, vm: &VirtualMachine) -> PyResult<()> {
-        use std::borrow::Cow;
+        use alloc::borrow::Cow;
 
         // 1. Get StgInfo from object's class (validates ctypes instance)
         let stg_info = obj
@@ -1148,8 +1156,8 @@ pub(crate) mod _ctypes {
         }
         let raw_ptr = ptr as *mut crate::object::PyObject;
         unsafe {
-            let obj = crate::PyObjectRef::from_raw(std::ptr::NonNull::new_unchecked(raw_ptr));
-            let obj = std::mem::ManuallyDrop::new(obj);
+            let obj = crate::PyObjectRef::from_raw(core::ptr::NonNull::new_unchecked(raw_ptr));
+            let obj = core::mem::ManuallyDrop::new(obj);
             Ok((*obj).clone())
         }
     }
@@ -1208,12 +1216,12 @@ pub(crate) mod _ctypes {
                 FORMAT_MESSAGE_ALLOCATE_BUFFER
                     | FORMAT_MESSAGE_FROM_SYSTEM
                     | FORMAT_MESSAGE_IGNORE_INSERTS,
-                std::ptr::null(),
+                core::ptr::null(),
                 error_code,
                 0,
                 &mut buffer as *mut *mut u16 as *mut u16,
                 0,
-                std::ptr::null(),
+                core::ptr::null(),
             )
         };
 
@@ -1280,7 +1288,7 @@ pub(crate) mod _ctypes {
                 let vtable = *iunknown;
                 debug_assert!(!vtable.is_null(), "IUnknown vtable is null");
                 let addref_fn: extern "system" fn(*mut std::ffi::c_void) -> u32 =
-                    std::mem::transmute(*vtable.add(1)); // AddRef is index 1
+                    core::mem::transmute(*vtable.add(1)); // AddRef is index 1
                 addref_fn(src_ptr as *mut std::ffi::c_void);
             }
         }
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 25708b57f8e..168da2bcc01 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -631,7 +631,7 @@ impl PyCArray {
                 let ptr_val = usize::from_ne_bytes(
                     ptr_bytes
                         .try_into()
-                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
                 );
                 if ptr_val == 0 {
                     return Ok(vm.ctx.none());
@@ -643,7 +643,7 @@ impl PyCArray {
                     while *ptr.add(len) != 0 {
                         len += 1;
                     }
-                    let bytes = std::slice::from_raw_parts(ptr, len);
+                    let bytes = core::slice::from_raw_parts(ptr, len);
                     Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
                 }
             }
@@ -656,7 +656,7 @@ impl PyCArray {
                 let ptr_val = usize::from_ne_bytes(
                     ptr_bytes
                         .try_into()
-                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
                 );
                 if ptr_val == 0 {
                     return Ok(vm.ctx.none());
@@ -668,10 +668,10 @@ impl PyCArray {
                     let mut pos = 0usize;
                     loop {
                         let code = if WCHAR_SIZE == 2 {
-                            let bytes = std::slice::from_raw_parts(ptr.add(pos), 2);
+                            let bytes = core::slice::from_raw_parts(ptr.add(pos), 2);
                             u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
                         } else {
-                            let bytes = std::slice::from_raw_parts(ptr.add(pos), 4);
+                            let bytes = core::slice::from_raw_parts(ptr.add(pos), 4);
                             u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
                         };
                         if code == 0 {
@@ -1136,7 +1136,7 @@ impl AsBuffer for PyCArray {
                 len: buffer_len,
                 readonly: false,
                 itemsize,
-                format: std::borrow::Cow::Owned(fmt),
+                format: alloc::borrow::Cow::Owned(fmt),
                 dim_desc,
             }
         } else {
@@ -1291,7 +1291,7 @@ fn add_wchar_array_getsets(array_type: &Py<PyType>, vm: &VirtualMachine) {
 // Linux/macOS: sizeof(wchar_t) == 4 (UTF-32)
 
 /// Size of wchar_t on this platform
-pub(super) const WCHAR_SIZE: usize = std::mem::size_of::<libc::wchar_t>();
+pub(super) const WCHAR_SIZE: usize = core::mem::size_of::<libc::wchar_t>();
 
 /// Read a single wchar_t from bytes (platform-endian)
 #[inline]
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index 0f859b3d10b..1f9eaeef56a 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -7,15 +7,15 @@ use crate::types::{GetDescriptor, Representable};
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
 };
+use alloc::borrow::Cow;
+use core::ffi::{
+    c_double, c_float, c_int, c_long, c_longlong, c_short, c_uint, c_ulong, c_ulonglong, c_ushort,
+};
+use core::fmt::Debug;
+use core::mem;
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::{Signed, ToPrimitive};
 use rustpython_common::lock::PyRwLock;
-use std::borrow::Cow;
-use std::ffi::{
-    c_double, c_float, c_int, c_long, c_longlong, c_short, c_uint, c_ulong, c_ulonglong, c_ushort,
-};
-use std::fmt::Debug;
-use std::mem;
 use widestring::WideChar;
 
 // StgInfo - Storage information for ctypes types
@@ -105,8 +105,8 @@ pub struct StgInfo {
 unsafe impl Send for StgInfo {}
 unsafe impl Sync for StgInfo {}
 
-impl std::fmt::Debug for StgInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for StgInfo {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("StgInfo")
             .field("initialized", &self.initialized)
             .field("size", &self.size)
@@ -227,7 +227,7 @@ impl StgInfo {
                     libffi::middle::Type::structure(self.ffi_field_types.iter().cloned())
                 } else if self.size <= MAX_FFI_STRUCT_SIZE {
                     // Small struct without field types: use bytes array
-                    libffi::middle::Type::structure(std::iter::repeat_n(
+                    libffi::middle::Type::structure(core::iter::repeat_n(
                         libffi::middle::Type::u8(),
                         self.size,
                     ))
@@ -242,9 +242,9 @@ impl StgInfo {
                     libffi::middle::Type::pointer()
                 } else if let Some(ref fmt) = self.format {
                     let elem_type = Self::format_to_ffi_type(fmt);
-                    libffi::middle::Type::structure(std::iter::repeat_n(elem_type, self.length))
+                    libffi::middle::Type::structure(core::iter::repeat_n(elem_type, self.length))
                 } else {
-                    libffi::middle::Type::structure(std::iter::repeat_n(
+                    libffi::middle::Type::structure(core::iter::repeat_n(
                         libffi::middle::Type::u8(),
                         self.size,
                     ))
@@ -373,10 +373,10 @@ pub(super) static CDATA_BUFFER_METHODS: BufferMethods = BufferMethods {
 
 /// Convert Vec<T> to Vec<u8> by reinterpreting the memory (same allocation).
 fn vec_to_bytes<T>(vec: Vec<T>) -> Vec<u8> {
-    let len = vec.len() * std::mem::size_of::<T>();
-    let cap = vec.capacity() * std::mem::size_of::<T>();
+    let len = vec.len() * core::mem::size_of::<T>();
+    let cap = vec.capacity() * core::mem::size_of::<T>();
     let ptr = vec.as_ptr() as *mut u8;
-    std::mem::forget(vec);
+    core::mem::forget(vec);
     unsafe { Vec::from_raw_parts(ptr, len, cap) }
 }
 
@@ -406,7 +406,7 @@ pub(super) fn str_to_wchar_bytes(s: &str, vm: &VirtualMachine) -> (PyObjectRef,
     let wchars: Vec<libc::wchar_t> = s
         .chars()
         .map(|c| c as libc::wchar_t)
-        .chain(std::iter::once(0))
+        .chain(core::iter::once(0))
         .collect();
     let ptr = wchars.as_ptr() as usize;
     let bytes = vec_to_bytes(wchars);
@@ -486,7 +486,7 @@ impl PyCData {
     pub unsafe fn at_address(ptr: *const u8, size: usize) -> Self {
         // = PyCData_AtAddress
         // SAFETY: Caller must ensure ptr is valid for the lifetime of returned PyCData
-        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
         PyCData {
             buffer: PyRwLock::new(Cow::Borrowed(slice)),
             base: PyRwLock::new(None),
@@ -534,7 +534,7 @@ impl PyCData {
     ) -> Self {
         // = PyCData_FromBaseObj
         // SAFETY: ptr points into base_obj's buffer, kept alive via base reference
-        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
         PyCData {
             buffer: PyRwLock::new(Cow::Borrowed(slice)),
             base: PyRwLock::new(Some(base_obj)),
@@ -561,7 +561,7 @@ impl PyCData {
         vm: &VirtualMachine,
     ) -> Self {
         // SAFETY: Caller must ensure ptr is valid for the lifetime of source
-        let slice: &'static [u8] = unsafe { std::slice::from_raw_parts(ptr, size) };
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
 
         // Python stores the reference in a dict with key "-1" (unique_key pattern)
         let objects_dict = vm.ctx.new_dict();
@@ -707,7 +707,7 @@ impl PyCData {
                 // (e.g., from from_address pointing to a ctypes buffer)
                 unsafe {
                     let ptr = slice.as_ptr() as *mut u8;
-                    std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(offset), bytes.len());
+                    core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(offset), bytes.len());
                 }
             }
             Cow::Owned(_) => {
@@ -893,7 +893,7 @@ impl PyCData {
             if let Some(bytes_val) = value.downcast_ref::<PyBytes>() {
                 let src = bytes_val.as_bytes();
                 let to_copy = PyCField::bytes_for_char_array(src);
-                let copy_len = std::cmp::min(to_copy.len(), size);
+                let copy_len = core::cmp::min(to_copy.len(), size);
                 self.write_bytes_at_offset(offset, &to_copy[..copy_len]);
                 self.keep_ref(index, value, vm)?;
                 return Ok(());
@@ -936,7 +936,7 @@ impl PyCData {
                 array_buffer.as_ptr() as usize
             };
             let addr_bytes = buffer_addr.to_ne_bytes();
-            let len = std::cmp::min(addr_bytes.len(), size);
+            let len = core::cmp::min(addr_bytes.len(), size);
             self.write_bytes_at_offset(offset, &addr_bytes[..len]);
             self.keep_ref(index, value, vm)?;
             return Ok(());
@@ -1364,7 +1364,7 @@ impl PyCField {
         if let Some(bytes) = value.downcast_ref::<PyBytes>() {
             let src = bytes.as_bytes();
             let mut result = vec![0u8; size];
-            let len = std::cmp::min(src.len(), size);
+            let len = core::cmp::min(src.len(), size);
             result[..len].copy_from_slice(&src[..len]);
             Ok(result)
         }
@@ -1372,7 +1372,7 @@ impl PyCField {
         else if let Some(cdata) = value.downcast_ref::<super::PyCData>() {
             let buffer = cdata.buffer.read();
             let mut result = vec![0u8; size];
-            let len = std::cmp::min(buffer.len(), size);
+            let len = core::cmp::min(buffer.len(), size);
             result[..len].copy_from_slice(&buffer[..len]);
             Ok(result)
         }
@@ -1473,7 +1473,7 @@ impl PyCField {
                     let (converted, ptr) = ensure_z_null_terminated(bytes, vm);
                     let mut result = vec![0u8; size];
                     let addr_bytes = ptr.to_ne_bytes();
-                    let len = std::cmp::min(addr_bytes.len(), size);
+                    let len = core::cmp::min(addr_bytes.len(), size);
                     result[..len].copy_from_slice(&addr_bytes[..len]);
                     return Ok((result, Some(converted)));
                 }
@@ -1482,7 +1482,7 @@ impl PyCField {
                     let v = int_val.as_bigint().to_usize().unwrap_or(0);
                     let mut result = vec![0u8; size];
                     let bytes = v.to_ne_bytes();
-                    let len = std::cmp::min(bytes.len(), size);
+                    let len = core::cmp::min(bytes.len(), size);
                     result[..len].copy_from_slice(&bytes[..len]);
                     return Ok((result, None));
                 }
@@ -1498,7 +1498,7 @@ impl PyCField {
                     let (holder, ptr) = str_to_wchar_bytes(s.as_str(), vm);
                     let mut result = vec![0u8; size];
                     let addr_bytes = ptr.to_ne_bytes();
-                    let len = std::cmp::min(addr_bytes.len(), size);
+                    let len = core::cmp::min(addr_bytes.len(), size);
                     result[..len].copy_from_slice(&addr_bytes[..len]);
                     return Ok((result, Some(holder)));
                 }
@@ -1507,7 +1507,7 @@ impl PyCField {
                     let v = int_val.as_bigint().to_usize().unwrap_or(0);
                     let mut result = vec![0u8; size];
                     let bytes = v.to_ne_bytes();
-                    let len = std::cmp::min(bytes.len(), size);
+                    let len = core::cmp::min(bytes.len(), size);
                     result[..len].copy_from_slice(&bytes[..len]);
                     return Ok((result, None));
                 }
@@ -1523,7 +1523,7 @@ impl PyCField {
                     let v = int_val.as_bigint().to_usize().unwrap_or(0);
                     let mut result = vec![0u8; size];
                     let bytes = v.to_ne_bytes();
-                    let len = std::cmp::min(bytes.len(), size);
+                    let len = core::cmp::min(bytes.len(), size);
                     result[..len].copy_from_slice(&bytes[..len]);
                     return Ok((result, None));
                 }
@@ -2078,7 +2078,7 @@ pub(super) fn bytes_to_pyobject(
                 if ptr == 0 {
                     return Ok(vm.ctx.none());
                 }
-                let c_str = unsafe { std::ffi::CStr::from_ptr(ptr as _) };
+                let c_str = unsafe { core::ffi::CStr::from_ptr(ptr as _) };
                 Ok(vm.ctx.new_bytes(c_str.to_bytes().to_vec()).into())
             }
             "Z" => {
@@ -2089,7 +2089,7 @@ pub(super) fn bytes_to_pyobject(
                 }
                 let len = unsafe { libc::wcslen(ptr as *const libc::wchar_t) };
                 let wchars =
-                    unsafe { std::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
+                    unsafe { core::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
                 let s: String = wchars
                     .iter()
                     .filter_map(|&c| char::from_u32(c as u32))
@@ -2149,7 +2149,7 @@ pub(super) fn get_usize_attr(
 /// Read a pointer value from buffer
 #[inline]
 pub(super) fn read_ptr_from_buffer(buffer: &[u8]) -> usize {
-    const PTR_SIZE: usize = std::mem::size_of::<usize>();
+    const PTR_SIZE: usize = core::mem::size_of::<usize>();
     if buffer.len() >= PTR_SIZE {
         usize::from_ne_bytes(buffer[..PTR_SIZE].try_into().unwrap())
     } else {
@@ -2242,7 +2242,7 @@ pub(super) fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyRe
         return Ok(s);
     }
 
-    Ok(std::mem::size_of::<usize>())
+    Ok(core::mem::size_of::<usize>())
 }
 
 /// Get the alignment of a ctypes field type
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
index 55a42f0ba15..5906bc91cd4 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -16,6 +16,9 @@ use crate::{
     types::{AsBuffer, Callable, Constructor, Initializer, Representable},
     vm::thread::with_current_vm,
 };
+use alloc::borrow::Cow;
+use core::ffi::c_void;
+use core::fmt::Debug;
 use libffi::{
     low,
     middle::{Arg, Cif, Closure, CodePtr, Type},
@@ -23,9 +26,6 @@ use libffi::{
 use libloading::Symbol;
 use num_traits::{Signed, ToPrimitive};
 use rustpython_common::lock::PyRwLock;
-use std::borrow::Cow;
-use std::ffi::c_void;
-use std::fmt::Debug;
 
 // Internal function addresses for special ctypes functions
 pub(super) const INTERNAL_CAST_ADDR: usize = 1;
@@ -37,7 +37,7 @@ std::thread_local! {
     /// Thread-local storage for ctypes errno
     /// This is separate from the system errno - ctypes swaps them during FFI calls
     /// when use_errno=True is specified.
-    static CTYPES_LOCAL_ERRNO: std::cell::Cell<i32> = const { std::cell::Cell::new(0) };
+    static CTYPES_LOCAL_ERRNO: core::cell::Cell<i32> = const { core::cell::Cell::new(0) };
 }
 
 /// Get ctypes thread-local errno value
@@ -79,7 +79,7 @@ where
 #[cfg(windows)]
 std::thread_local! {
     /// Thread-local storage for ctypes last_error (Windows only)
-    static CTYPES_LOCAL_LAST_ERROR: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
+    static CTYPES_LOCAL_LAST_ERROR: core::cell::Cell<u32> = const { core::cell::Cell::new(0) };
 }
 
 #[cfg(windows)]
@@ -135,14 +135,14 @@ fn ffi_type_from_tag(tag: u8) -> Type {
         b'i' => Type::i32(),
         b'I' => Type::u32(),
         b'l' => {
-            if std::mem::size_of::<libc::c_long>() == 8 {
+            if core::mem::size_of::<libc::c_long>() == 8 {
                 Type::i64()
             } else {
                 Type::i32()
             }
         }
         b'L' => {
-            if std::mem::size_of::<libc::c_ulong>() == 8 {
+            if core::mem::size_of::<libc::c_ulong>() == 8 {
                 Type::u64()
             } else {
                 Type::u32()
@@ -154,7 +154,7 @@ fn ffi_type_from_tag(tag: u8) -> Type {
         b'd' | b'g' => Type::f64(),
         b'?' => Type::u8(),
         b'u' => {
-            if std::mem::size_of::<super::WideChar>() == 2 {
+            if core::mem::size_of::<super::WideChar>() == 2 {
                 Type::u16()
             } else {
                 Type::u32()
@@ -207,7 +207,7 @@ fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgV
     // 5. PyCSimple (c_void_p, c_char_p, etc.) -> value from buffer
     if let Some(simple) = value.downcast_ref::<PyCSimple>() {
         let buffer = simple.0.buffer.read();
-        if buffer.len() >= std::mem::size_of::<usize>() {
+        if buffer.len() >= core::mem::size_of::<usize>() {
             let addr = super::base::read_ptr_from_buffer(&buffer);
             return Ok(FfiArgValue::Pointer(addr));
         }
@@ -283,7 +283,7 @@ fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<Argument> {
         let wide: Vec<u16> = s
             .as_str()
             .encode_utf16()
-            .chain(std::iter::once(0))
+            .chain(core::iter::once(0))
             .collect();
         let wide_bytes: Vec<u8> = wide.iter().flat_map(|&x| x.to_ne_bytes()).collect();
         let keep = vm.ctx.new_bytes(wide_bytes);
@@ -499,7 +499,7 @@ impl Initializer for PyCFuncPtrType {
 
         new_type.check_not_initialized(vm)?;
 
-        let ptr_size = std::mem::size_of::<usize>();
+        let ptr_size = core::mem::size_of::<usize>();
         let mut stg_info = StgInfo::new(ptr_size, ptr_size);
         stg_info.format = Some("X{}".to_string());
         stg_info.length = 1;
@@ -552,7 +552,7 @@ pub(super) struct PyCFuncPtr {
 }
 
 impl Debug for PyCFuncPtr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyCFuncPtr")
             .field("func_ptr", &self.get_func_ptr())
             .finish()
@@ -567,9 +567,9 @@ fn extract_ptr_from_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<usize>
     }
     if let Some(simple) = arg.downcast_ref::<PyCSimple>() {
         let buffer = simple.0.buffer.read();
-        if buffer.len() >= std::mem::size_of::<usize>() {
+        if buffer.len() >= core::mem::size_of::<usize>() {
             return Ok(usize::from_ne_bytes(
-                buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
             ));
         }
     }
@@ -612,7 +612,7 @@ fn string_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
         }
         size_usize
     };
-    let bytes = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let bytes = unsafe { core::slice::from_raw_parts(ptr, len) };
     Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
 }
 
@@ -627,12 +627,12 @@ fn wstring_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
     } else {
         // Overflow check for huge size values
         let size_usize = size as usize;
-        if size_usize > isize::MAX as usize / std::mem::size_of::<libc::wchar_t>() {
+        if size_usize > isize::MAX as usize / core::mem::size_of::<libc::wchar_t>() {
             return Err(vm.new_overflow_error("string too long"));
         }
         size_usize
     };
-    let wchars = unsafe { std::slice::from_raw_parts(w_ptr, len) };
+    let wchars = unsafe { core::slice::from_raw_parts(w_ptr, len) };
 
     // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
     // macOS/Linux: wchar_t = i32 (UTF-32) -> convert via char::from_u32
@@ -815,7 +815,7 @@ impl Constructor for PyCFuncPtr {
         // 3. Tuple argument: (name, dll) form
         // 4. Callable: callback creation
 
-        let ptr_size = std::mem::size_of::<usize>();
+        let ptr_size = core::mem::size_of::<usize>();
 
         if args.args.is_empty() {
             return PyCFuncPtr {
@@ -1513,11 +1513,11 @@ fn convert_raw_result(
         RawResult::Void => return None,
         RawResult::Pointer(ptr) => {
             let bytes = ptr.to_ne_bytes();
-            (bytes.to_vec(), std::mem::size_of::<usize>())
+            (bytes.to_vec(), core::mem::size_of::<usize>())
         }
         RawResult::Value(val) => {
             let bytes = val.to_ne_bytes();
-            (bytes.to_vec(), std::mem::size_of::<i64>())
+            (bytes.to_vec(), core::mem::size_of::<i64>())
         }
     };
 
@@ -1702,7 +1702,7 @@ impl Callable for PyCFuncPtr {
             None => {
                 debug_assert!(false, "NULL function pointer");
                 // In release mode, this will crash
-                CodePtr(std::ptr::null_mut())
+                CodePtr(core::ptr::null_mut())
             }
         };
 
@@ -1758,7 +1758,7 @@ impl AsBuffer for PyCFuncPtr {
                 stg_info.size,
             )
         } else {
-            (Cow::Borrowed("X{}"), std::mem::size_of::<usize>())
+            (Cow::Borrowed("X{}"), core::mem::size_of::<usize>())
         };
         let desc = BufferDescriptor {
             len: itemsize,
@@ -1902,7 +1902,7 @@ fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> Py
                 if cstr_ptr.is_null() {
                     vm.ctx.none()
                 } else {
-                    let cstr = std::ffi::CStr::from_ptr(cstr_ptr);
+                    let cstr = core::ffi::CStr::from_ptr(cstr_ptr);
                     vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into()
                 }
             }
@@ -1916,7 +1916,7 @@ fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> Py
                     while *wstr_ptr.add(len) != 0 {
                         len += 1;
                     }
-                    let slice = std::slice::from_raw_parts(wstr_ptr, len);
+                    let slice = core::slice::from_raw_parts(wstr_ptr, len);
                     // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
                     // Unix: wchar_t = i32 (UTF-32) -> convert via char::from_u32
                     #[cfg(windows)]
@@ -2113,7 +2113,7 @@ pub(super) struct PyCThunk {
 }
 
 impl Debug for PyCThunk {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyCThunk")
             .field("callable", &self.callable)
             .finish()
diff --git a/crates/vm/src/stdlib/ctypes/library.rs b/crates/vm/src/stdlib/ctypes/library.rs
index 7512ce29d8a..35ccb433845 100644
--- a/crates/vm/src/stdlib/ctypes/library.rs
+++ b/crates/vm/src/stdlib/ctypes/library.rs
@@ -1,9 +1,9 @@
 use crate::VirtualMachine;
+use alloc::fmt;
 use libloading::Library;
 use rustpython_common::lock::{PyMutex, PyRwLock};
 use std::collections::HashMap;
 use std::ffi::OsStr;
-use std::fmt;
 
 #[cfg(unix)]
 use libloading::os::unix::Library as UnixLibrary;
@@ -54,7 +54,7 @@ impl SharedLibrary {
             // On Windows: HMODULE (*mut c_void)
             // On Unix: *mut c_void from dlopen
             // We use transmute_copy to read the handle without consuming the Library
-            unsafe { std::mem::transmute_copy::<Library, usize>(l) }
+            unsafe { core::mem::transmute_copy::<Library, usize>(l) }
         } else {
             0
         }
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index ae97b741b3c..f564fd1965c 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -8,8 +8,8 @@ use crate::{
     class::StaticType,
     function::{FuncArgs, OptionalArg},
 };
+use alloc::borrow::Cow;
 use num_traits::ToPrimitive;
-use std::borrow::Cow;
 
 #[pyclass(name = "PyCPointerType", base = PyType, module = "_ctypes")]
 #[derive(Debug)]
@@ -37,7 +37,7 @@ impl Initializer for PyCPointerType {
             .and_then(|obj| obj.downcast::<PyType>().ok());
 
         // Initialize StgInfo for pointer type
-        let pointer_size = std::mem::size_of::<usize>();
+        let pointer_size = core::mem::size_of::<usize>();
         let mut stg_info = StgInfo::new(pointer_size, pointer_size);
         stg_info.proto = proto;
         stg_info.paramfunc = super::base::ParamFunc::Pointer;
@@ -232,7 +232,7 @@ impl Constructor for PyCPointer {
 
         // Create a new PyCPointer instance with NULL pointer (all zeros)
         // Initial contents is set via __init__ if provided
-        let cdata = PyCData::from_bytes(vec![0u8; std::mem::size_of::<usize>()], None);
+        let cdata = PyCData::from_bytes(vec![0u8; core::mem::size_of::<usize>()], None);
         // pointer instance has b_length set to 2 (for index 0 and 1)
         cdata.length.store(2);
         PyCPointer(cdata)
@@ -299,7 +299,7 @@ impl PyCPointer {
         let proto_type = stg_info.proto();
         let element_size = proto_type
             .stg_info_opt()
-            .map_or(std::mem::size_of::<usize>(), |info| info.size);
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
 
         // Create instance that references the memory directly
         // PyCData.into_ref_with_type works for all ctypes (simple, structure, union, array, pointer)
@@ -383,7 +383,7 @@ impl PyCPointer {
         let proto_type = stg_info.proto();
         let element_size = proto_type
             .stg_info_opt()
-            .map_or(std::mem::size_of::<usize>(), |info| info.size);
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
 
         // offset = index * iteminfo->size
         let offset = index * element_size as isize;
@@ -468,7 +468,7 @@ impl PyCPointer {
         let element_size = if let Some(ref proto_type) = stg_info.proto {
             proto_type.stg_info_opt().expect("proto has StgInfo").size
         } else {
-            std::mem::size_of::<usize>()
+            core::mem::size_of::<usize>()
         };
         let type_code = stg_info
             .proto
@@ -489,7 +489,7 @@ impl PyCPointer {
                 // Optimized contiguous copy
                 let start_addr = (ptr_value as isize + start * element_size as isize) as *const u8;
                 unsafe {
-                    result.extend_from_slice(std::slice::from_raw_parts(start_addr, len));
+                    result.extend_from_slice(core::slice::from_raw_parts(start_addr, len));
                 }
             } else {
                 let mut cur = start;
@@ -510,7 +510,7 @@ impl PyCPointer {
                 return Ok(vm.ctx.new_str("").into());
             }
             let mut result = String::with_capacity(len);
-            let wchar_size = std::mem::size_of::<libc::wchar_t>();
+            let wchar_size = core::mem::size_of::<libc::wchar_t>();
             let mut cur = start;
             for _ in 0..len {
                 let addr = (ptr_value as isize + cur * wchar_size as isize) as *const libc::wchar_t;
@@ -578,7 +578,7 @@ impl PyCPointer {
 
         let element_size = proto_type
             .stg_info_opt()
-            .map_or(std::mem::size_of::<usize>(), |info| info.size);
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
 
         // Calculate address
         let offset = index * element_size as isize;
@@ -595,7 +595,7 @@ impl PyCPointer {
             let copy_len = src_buffer.len().min(element_size);
             unsafe {
                 let dest_ptr = addr as *mut u8;
-                std::ptr::copy_nonoverlapping(src_buffer.as_ptr(), dest_ptr, copy_len);
+                core::ptr::copy_nonoverlapping(src_buffer.as_ptr(), dest_ptr, copy_len);
             }
         } else {
             // Handle z/Z specially to store converted value
@@ -641,43 +641,43 @@ impl PyCPointer {
                 // Multi-byte types need read_unaligned for safety on strict-alignment architectures
                 Some("h") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const i16) as i32)
+                    .new_int(core::ptr::read_unaligned(ptr as *const i16) as i32)
                     .into()),
                 Some("H") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const u16) as i32)
+                    .new_int(core::ptr::read_unaligned(ptr as *const u16) as i32)
                     .into()),
                 Some("i") | Some("l") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const i32))
+                    .new_int(core::ptr::read_unaligned(ptr as *const i32))
                     .into()),
                 Some("I") | Some("L") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const u32))
+                    .new_int(core::ptr::read_unaligned(ptr as *const u32))
                     .into()),
                 Some("q") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const i64))
+                    .new_int(core::ptr::read_unaligned(ptr as *const i64))
                     .into()),
                 Some("Q") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const u64))
+                    .new_int(core::ptr::read_unaligned(ptr as *const u64))
                     .into()),
                 Some("f") => Ok(vm
                     .ctx
-                    .new_float(std::ptr::read_unaligned(ptr as *const f32) as f64)
+                    .new_float(core::ptr::read_unaligned(ptr as *const f32) as f64)
                     .into()),
                 Some("d") | Some("g") => Ok(vm
                     .ctx
-                    .new_float(std::ptr::read_unaligned(ptr as *const f64))
+                    .new_float(core::ptr::read_unaligned(ptr as *const f64))
                     .into()),
                 Some("P") | Some("z") | Some("Z") => Ok(vm
                     .ctx
-                    .new_int(std::ptr::read_unaligned(ptr as *const usize))
+                    .new_int(core::ptr::read_unaligned(ptr as *const usize))
                     .into()),
                 _ => {
                     // Default: read as bytes
-                    let bytes = std::slice::from_raw_parts(ptr, size).to_vec();
+                    let bytes = core::slice::from_raw_parts(ptr, size).to_vec();
                     Ok(vm.ctx.new_bytes(bytes).into())
                 }
             }
@@ -708,7 +708,7 @@ impl PyCPointer {
                             "bytes/string or integer address expected".to_owned(),
                         ));
                     };
-                    std::ptr::write_unaligned(ptr as *mut usize, ptr_val);
+                    core::ptr::write_unaligned(ptr as *mut usize, ptr_val);
                     return Ok(());
                 }
                 _ => {}
@@ -723,19 +723,19 @@ impl PyCPointer {
                         *ptr = i.to_u8().expect("int too large");
                     }
                     2 => {
-                        std::ptr::write_unaligned(
+                        core::ptr::write_unaligned(
                             ptr as *mut i16,
                             i.to_i16().expect("int too large"),
                         );
                     }
                     4 => {
-                        std::ptr::write_unaligned(
+                        core::ptr::write_unaligned(
                             ptr as *mut i32,
                             i.to_i32().expect("int too large"),
                         );
                     }
                     8 => {
-                        std::ptr::write_unaligned(
+                        core::ptr::write_unaligned(
                             ptr as *mut i64,
                             i.to_i64().expect("int too large"),
                         );
@@ -743,7 +743,7 @@ impl PyCPointer {
                     _ => {
                         let bytes = i.to_signed_bytes_le();
                         let copy_len = bytes.len().min(size);
-                        std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                        core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
                     }
                 }
                 return Ok(());
@@ -754,10 +754,10 @@ impl PyCPointer {
                 let f = float_val.to_f64();
                 match size {
                     4 => {
-                        std::ptr::write_unaligned(ptr as *mut f32, f as f32);
+                        core::ptr::write_unaligned(ptr as *mut f32, f as f32);
                     }
                     8 => {
-                        std::ptr::write_unaligned(ptr as *mut f64, f);
+                        core::ptr::write_unaligned(ptr as *mut f64, f);
                     }
                     _ => {}
                 }
@@ -767,7 +767,7 @@ impl PyCPointer {
             // Try bytes
             if let Ok(bytes) = value.try_bytes_like(vm, |b| b.to_vec()) {
                 let copy_len = bytes.len().min(size);
-                std::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
                 return Ok(());
             }
 
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index fbb17620fe4..9835953812f 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -13,9 +13,9 @@ use crate::function::{Either, FuncArgs, OptionalArg};
 use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
 use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, Representable};
 use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+use alloc::borrow::Cow;
+use core::fmt::Debug;
 use num_traits::ToPrimitive;
-use std::borrow::Cow;
-use std::fmt::Debug;
 
 /// Valid type codes for ctypes simple types
 // spell-checker: disable-next-line
@@ -27,22 +27,22 @@ pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPXOv?g";
 fn ctypes_code_to_pep3118(code: char) -> char {
     match code {
         // c_int: map based on sizeof(int)
-        'i' if std::mem::size_of::<std::ffi::c_int>() == 2 => 'h',
-        'i' if std::mem::size_of::<std::ffi::c_int>() == 4 => 'i',
-        'i' if std::mem::size_of::<std::ffi::c_int>() == 8 => 'q',
-        'I' if std::mem::size_of::<std::ffi::c_int>() == 2 => 'H',
-        'I' if std::mem::size_of::<std::ffi::c_int>() == 4 => 'I',
-        'I' if std::mem::size_of::<std::ffi::c_int>() == 8 => 'Q',
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 2 => 'h',
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 4 => 'i',
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 8 => 'q',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 2 => 'H',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 4 => 'I',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 8 => 'Q',
         // c_long: map based on sizeof(long)
-        'l' if std::mem::size_of::<std::ffi::c_long>() == 4 => 'l',
-        'l' if std::mem::size_of::<std::ffi::c_long>() == 8 => 'q',
-        'L' if std::mem::size_of::<std::ffi::c_long>() == 4 => 'L',
-        'L' if std::mem::size_of::<std::ffi::c_long>() == 8 => 'Q',
+        'l' if core::mem::size_of::<core::ffi::c_long>() == 4 => 'l',
+        'l' if core::mem::size_of::<core::ffi::c_long>() == 8 => 'q',
+        'L' if core::mem::size_of::<core::ffi::c_long>() == 4 => 'L',
+        'L' if core::mem::size_of::<core::ffi::c_long>() == 8 => 'Q',
         // c_bool: map based on sizeof(bool) - typically 1 byte on all platforms
-        '?' if std::mem::size_of::<bool>() == 1 => '?',
-        '?' if std::mem::size_of::<bool>() == 2 => 'H',
-        '?' if std::mem::size_of::<bool>() == 4 => 'L',
-        '?' if std::mem::size_of::<bool>() == 8 => 'Q',
+        '?' if core::mem::size_of::<bool>() == 1 => '?',
+        '?' if core::mem::size_of::<bool>() == 2 => 'H',
+        '?' if core::mem::size_of::<bool>() == 4 => 'L',
+        '?' if core::mem::size_of::<bool>() == 8 => 'Q',
         // Default: use the same code
         _ => code,
     }
@@ -268,7 +268,7 @@ impl PyCSimpleType {
         let create_simple_with_value = |type_str: &str, val: &PyObject| -> PyResult {
             let simple = new_simple_type(Either::B(&cls), vm)?;
             let buffer_bytes = value_to_bytes_endian(type_str, val, false, vm);
-            *simple.0.buffer.write() = std::borrow::Cow::Owned(buffer_bytes.clone());
+            *simple.0.buffer.write() = alloc::borrow::Cow::Owned(buffer_bytes.clone());
             let simple_obj: PyObjectRef = simple.into_ref_with_type(vm, cls.clone())?.into();
             // from_param returns CArgObject, not the simple type itself
             let tag = type_str.as_bytes().first().copied().unwrap_or(b'?');
@@ -418,9 +418,9 @@ impl PyCSimpleType {
                 if let Some(funcptr) = value.downcast_ref::<PyCFuncPtr>() {
                     let ptr_val = {
                         let buffer = funcptr._base.buffer.read();
-                        if buffer.len() >= std::mem::size_of::<usize>() {
+                        if buffer.len() >= core::mem::size_of::<usize>() {
                             usize::from_ne_bytes(
-                                buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+                                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
                             )
                         } else {
                             0
@@ -441,9 +441,9 @@ impl PyCSimpleType {
                     if matches!(value_type_code.as_deref(), Some("z") | Some("Z")) {
                         let ptr_val = {
                             let buffer = simple.0.buffer.read();
-                            if buffer.len() >= std::mem::size_of::<usize>() {
+                            if buffer.len() >= core::mem::size_of::<usize>() {
                                 usize::from_ne_bytes(
-                                    buffer[..std::mem::size_of::<usize>()].try_into().unwrap(),
+                                    buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
                                 )
                             } else {
                                 0
@@ -712,7 +712,7 @@ fn create_swapped_types(
 pub struct PyCSimple(pub PyCData);
 
 impl Debug for PyCSimple {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyCSimple")
             .field("size", &self.0.buffer.read().len())
             .finish()
@@ -833,7 +833,7 @@ fn value_to_bytes_endian(
                 let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_long;
                 return to_bytes!(v);
             }
-            const SIZE: usize = std::mem::size_of::<libc::c_long>();
+            const SIZE: usize = core::mem::size_of::<libc::c_long>();
             vec![0; SIZE]
         }
         "L" => {
@@ -842,7 +842,7 @@ fn value_to_bytes_endian(
                 let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_ulong;
                 return to_bytes!(v);
             }
-            const SIZE: usize = std::mem::size_of::<libc::c_ulong>();
+            const SIZE: usize = core::mem::size_of::<libc::c_ulong>();
             vec![0; SIZE]
         }
         "q" => {
@@ -938,7 +938,7 @@ fn value_to_bytes_endian(
                     .expect("int too large for pointer");
                 return to_bytes!(v);
             }
-            vec![0; std::mem::size_of::<usize>()]
+            vec![0; core::mem::size_of::<usize>()]
         }
         "z" => {
             // c_char_p - pointer to char (stores pointer value from int)
@@ -950,7 +950,7 @@ fn value_to_bytes_endian(
                     .expect("int too large for pointer");
                 return to_bytes!(v);
             }
-            vec![0; std::mem::size_of::<usize>()]
+            vec![0; core::mem::size_of::<usize>()]
         }
         "Z" => {
             // c_wchar_p - pointer to wchar_t (stores pointer value from int)
@@ -962,7 +962,7 @@ fn value_to_bytes_endian(
                     .expect("int too large for pointer");
                 return to_bytes!(v);
             }
-            vec![0; std::mem::size_of::<usize>()]
+            vec![0; core::mem::size_of::<usize>()]
         }
         "O" => {
             // py_object - store object id as non-zero marker
@@ -1166,7 +1166,7 @@ impl PyCSimple {
             }
             // Read null-terminated string at the address
             unsafe {
-                let cstr = std::ffi::CStr::from_ptr(ptr as _);
+                let cstr = core::ffi::CStr::from_ptr(ptr as _);
                 return Ok(vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into());
             }
         }
@@ -1183,7 +1183,7 @@ impl PyCSimple {
             unsafe {
                 let w_ptr = ptr as *const libc::wchar_t;
                 let len = libc::wcslen(w_ptr);
-                let wchars = std::slice::from_raw_parts(w_ptr, len);
+                let wchars = core::slice::from_raw_parts(w_ptr, len);
                 #[cfg(windows)]
                 {
                     use rustpython_common::wtf8::Wtf8Buf;
@@ -1221,13 +1221,13 @@ impl PyCSimple {
 
         // Read value from buffer, swap bytes if needed
         let buffer = zelf.0.buffer.read();
-        let buffer_data: std::borrow::Cow<'_, [u8]> = if swapped {
+        let buffer_data: alloc::borrow::Cow<'_, [u8]> = if swapped {
             // Reverse bytes for swapped endian types
             let mut swapped_bytes = buffer.to_vec();
             swapped_bytes.reverse();
-            std::borrow::Cow::Owned(swapped_bytes)
+            alloc::borrow::Cow::Owned(swapped_bytes)
         } else {
-            std::borrow::Cow::Borrowed(&*buffer)
+            alloc::borrow::Cow::Borrowed(&*buffer)
         };
 
         let cls_ref = cls.to_owned();
@@ -1269,7 +1269,7 @@ impl PyCSimple {
         if type_code == "z" {
             if let Some(bytes) = value.downcast_ref::<PyBytes>() {
                 let (converted, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
-                *zelf.0.buffer.write() = std::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+                *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
                 *zelf.0.objects.write() = Some(converted);
                 return Ok(());
             }
@@ -1277,7 +1277,7 @@ impl PyCSimple {
             && let Some(s) = value.downcast_ref::<PyStr>()
         {
             let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
-            *zelf.0.buffer.write() = std::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+            *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
             *zelf.0.objects.write() = Some(holder);
             return Ok(());
         }
@@ -1368,65 +1368,65 @@ impl PyCSimple {
         let buffer = self.0.buffer.read();
         let bytes: &[u8] = &buffer;
 
-        if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
+        if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
             if !bytes.is_empty() {
                 return Some(FfiArgValue::U8(bytes[0]));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
             if !bytes.is_empty() {
                 return Some(FfiArgValue::I8(bytes[0] as i8));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
             if bytes.len() >= 2 {
                 return Some(FfiArgValue::U16(u16::from_ne_bytes([bytes[0], bytes[1]])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
             if bytes.len() >= 2 {
                 return Some(FfiArgValue::I16(i16::from_ne_bytes([bytes[0], bytes[1]])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
             if bytes.len() >= 4 {
                 return Some(FfiArgValue::U32(u32::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3],
                 ])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
             if bytes.len() >= 4 {
                 return Some(FfiArgValue::I32(i32::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3],
                 ])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
             if bytes.len() >= 8 {
                 return Some(FfiArgValue::U64(u64::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
                 ])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
             if bytes.len() >= 8 {
                 return Some(FfiArgValue::I64(i64::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
                 ])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f32().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f32().as_raw_ptr()) {
             if bytes.len() >= 4 {
                 return Some(FfiArgValue::F32(f32::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3],
                 ])));
             }
-        } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f64().as_raw_ptr()) {
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f64().as_raw_ptr()) {
             if bytes.len() >= 8 {
                 return Some(FfiArgValue::F64(f64::from_ne_bytes([
                     bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
                 ])));
             }
-        } else if std::ptr::eq(
+        } else if core::ptr::eq(
             ty.as_raw_ptr(),
             libffi::middle::Type::pointer().as_raw_ptr(),
-        ) && bytes.len() >= std::mem::size_of::<usize>()
+        ) && bytes.len() >= core::mem::size_of::<usize>()
         {
             let val =
-                usize::from_ne_bytes(bytes[..std::mem::size_of::<usize>()].try_into().unwrap());
+                usize::from_ne_bytes(bytes[..core::mem::size_of::<usize>()].try_into().unwrap());
             return Some(FfiArgValue::Pointer(val));
         }
         None
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index d5aca392c52..295ce0d87cf 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -6,9 +6,9 @@ use crate::function::PySetterValue;
 use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
 use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, SetAttr};
 use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use alloc::borrow::Cow;
+use core::fmt::Debug;
 use num_traits::ToPrimitive;
-use std::borrow::Cow;
-use std::fmt::Debug;
 
 /// Calculate Structure type size from _fields_ (sum of field sizes)
 pub(super) fn calculate_struct_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
@@ -206,7 +206,7 @@ impl PyCStructType {
             {
                 (
                     baseinfo.size,
-                    std::cmp::max(baseinfo.align, forced_alignment),
+                    core::cmp::max(baseinfo.align, forced_alignment),
                     baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
                     baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASUNION),
                     baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
@@ -252,7 +252,7 @@ impl PyCStructType {
 
             // Calculate effective alignment (PyCField_FromDesc)
             let effective_align = if pack > 0 {
-                std::cmp::min(pack, field_align)
+                core::cmp::min(pack, field_align)
             } else {
                 field_align
             };
@@ -347,7 +347,7 @@ impl PyCStructType {
         }
 
         // Calculate total_align = max(max_align, forced_alignment)
-        let total_align = std::cmp::max(max_align, forced_alignment);
+        let total_align = core::cmp::max(max_align, forced_alignment);
 
         // Calculate aligned_size (PyCStructUnionType_update_stginfo)
         let aligned_size = if total_align > 0 {
@@ -501,7 +501,7 @@ impl SetAttr for PyCStructType {
 pub struct PyCStructure(pub PyCData);
 
 impl Debug for PyCStructure {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyCStructure")
             .field("size", &self.0.size())
             .finish()
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
index 41bc7492a25..0da1ffee3fd 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -7,7 +7,7 @@ use crate::function::PySetterValue;
 use crate::protocol::{BufferDescriptor, PyBuffer};
 use crate::types::{AsBuffer, Constructor, Initializer, SetAttr};
 use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-use std::borrow::Cow;
+use alloc::borrow::Cow;
 
 /// Calculate Union type size from _fields_ (max field size)
 pub(super) fn calculate_union_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
@@ -175,7 +175,7 @@ impl PyCUnionType {
             {
                 (
                     baseinfo.size,
-                    std::cmp::max(baseinfo.align, forced_alignment),
+                    core::cmp::max(baseinfo.align, forced_alignment),
                     baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
                     baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
                     baseinfo.ffi_field_types.clone(),
@@ -215,7 +215,7 @@ impl PyCUnionType {
 
             // Calculate effective alignment
             let effective_align = if pack > 0 {
-                std::cmp::min(pack, field_align)
+                core::cmp::min(pack, field_align)
             } else {
                 field_align
             };
@@ -264,7 +264,7 @@ impl PyCUnionType {
         }
 
         // Calculate total_align and aligned_size
-        let total_align = std::cmp::max(max_align, forced_alignment);
+        let total_align = core::cmp::max(max_align, forced_alignment);
         let aligned_size = if total_align > 0 {
             max_size.div_ceil(total_align) * total_align
         } else {
@@ -418,8 +418,8 @@ impl SetAttr for PyCUnionType {
 #[repr(transparent)]
 pub struct PyCUnion(pub PyCData);
 
-impl std::fmt::Debug for PyCUnion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyCUnion {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("PyCUnion")
             .field("size", &self.0.size())
             .finish()
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 52900faec08..54a38ef20e6 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -53,7 +53,7 @@ impl ToOSErrorBuilder for std::io::Error {
         let msg = {
             let ptr = unsafe { libc::strerror(errno) };
             if !ptr.is_null() {
-                unsafe { std::ffi::CStr::from_ptr(ptr) }
+                unsafe { core::ffi::CStr::from_ptr(ptr) }
                     .to_string_lossy()
                     .into_owned()
             } else {
@@ -183,16 +183,16 @@ mod _io {
         },
         vm::VirtualMachine,
     };
+    use alloc::borrow::Cow;
     use bstr::ByteSlice;
-    use crossbeam_utils::atomic::AtomicCell;
-    use malachite_bigint::BigInt;
-    use num_traits::ToPrimitive;
-    use std::{
-        borrow::Cow,
-        io::{self, Cursor, SeekFrom, prelude::*},
+    use core::{
         ops::Range,
         sync::atomic::{AtomicBool, Ordering},
     };
+    use crossbeam_utils::atomic::AtomicCell;
+    use malachite_bigint::BigInt;
+    use num_traits::ToPrimitive;
+    use std::io::{self, Cursor, SeekFrom, prelude::*};
 
     #[allow(clippy::let_and_return)]
     fn validate_whence(whence: i32) -> bool {
@@ -354,7 +354,7 @@ mod _io {
             // if we don't specify the number of bytes, or it's too big, give the whole rest of the slice
             let n = bytes.map_or_else(
                 || avail_slice.len(),
-                |n| std::cmp::min(n, avail_slice.len()),
+                |n| core::cmp::min(n, avail_slice.len()),
             );
             let b = avail_slice[..n].to_vec();
             self.cursor.set_position((pos + n) as u64);
@@ -1059,7 +1059,7 @@ mod _io {
                 // TODO: loop if write() raises an interrupt
                 vm.call_method(self.raw.as_ref().unwrap(), "write", (mem_obj,))?
             } else {
-                let v = std::mem::take(&mut self.buffer);
+                let v = core::mem::take(&mut self.buffer);
                 let write_buf = VecBuffer::from(v).into_ref(&vm.ctx);
                 let mem_obj = PyMemoryView::from_buffer_range(
                     write_buf.clone().into_pybuffer(true),
@@ -1330,7 +1330,7 @@ mod _io {
             let res = match v {
                 Either::A(v) => {
                     let v = v.unwrap_or(&mut self.buffer);
-                    let read_buf = VecBuffer::from(std::mem::take(v)).into_ref(&vm.ctx);
+                    let read_buf = VecBuffer::from(core::mem::take(v)).into_ref(&vm.ctx);
                     let mem_obj = PyMemoryView::from_buffer_range(
                         read_buf.clone().into_pybuffer(false),
                         buf_range,
@@ -1527,7 +1527,7 @@ mod _io {
                 } else if !(readinto1 && written != 0) {
                     let n = self.fill_buffer(vm)?;
                     if let Some(n) = n.filter(|&n| n > 0) {
-                        let n = std::cmp::min(n, remaining);
+                        let n = core::cmp::min(n, remaining);
                         buf.as_contiguous_mut().unwrap()[written..][..n]
                             .copy_from_slice(&self.buffer[self.pos as usize..][..n]);
                         self.pos += n as Offset;
@@ -1881,7 +1881,7 @@ mod _io {
             }
             let have = data.readahead();
             if have > 0 {
-                let n = std::cmp::min(have as usize, n);
+                let n = core::cmp::min(have as usize, n);
                 return Ok(data.read_fast(n).unwrap());
             }
             // Flush write buffer before reading
@@ -2373,7 +2373,7 @@ mod _io {
         }
     }
 
-    impl std::ops::Add for Utf8size {
+    impl core::ops::Add for Utf8size {
         type Output = Self;
 
         #[inline]
@@ -2383,7 +2383,7 @@ mod _io {
         }
     }
 
-    impl std::ops::AddAssign for Utf8size {
+    impl core::ops::AddAssign for Utf8size {
         #[inline]
         fn add_assign(&mut self, rhs: Self) {
             self.bytes += rhs.bytes;
@@ -2391,7 +2391,7 @@ mod _io {
         }
     }
 
-    impl std::ops::Sub for Utf8size {
+    impl core::ops::Sub for Utf8size {
         type Output = Self;
 
         #[inline]
@@ -2401,7 +2401,7 @@ mod _io {
         }
     }
 
-    impl std::ops::SubAssign for Utf8size {
+    impl core::ops::SubAssign for Utf8size {
         #[inline]
         fn sub_assign(&mut self, rhs: Self) {
             self.bytes -= rhs.bytes;
@@ -2470,7 +2470,7 @@ mod _io {
     impl PendingWrites {
         fn push(&mut self, write: PendingWrite) {
             self.num_bytes += write.as_bytes().len();
-            self.data = match std::mem::take(&mut self.data) {
+            self.data = match core::mem::take(&mut self.data) {
                 PendingWritesData::None => PendingWritesData::One(write),
                 PendingWritesData::One(write1) => PendingWritesData::Many(vec![write1, write]),
                 PendingWritesData::Many(mut v) => {
@@ -2480,13 +2480,13 @@ mod _io {
             }
         }
         fn take(&mut self, vm: &VirtualMachine) -> PyBytesRef {
-            let Self { num_bytes, data } = std::mem::take(self);
+            let Self { num_bytes, data } = core::mem::take(self);
             if let PendingWritesData::One(PendingWrite::Bytes(b)) = data {
                 return b;
             }
             let writes_iter = match data {
                 PendingWritesData::None => itertools::Either::Left(vec![].into_iter()),
-                PendingWritesData::One(write) => itertools::Either::Right(std::iter::once(write)),
+                PendingWritesData::One(write) => itertools::Either::Right(core::iter::once(write)),
                 PendingWritesData::Many(writes) => itertools::Either::Left(writes.into_iter()),
             };
             let mut buf = Vec::with_capacity(num_bytes);
@@ -2508,7 +2508,7 @@ mod _io {
 
     impl TextIOCookie {
         const START_POS_OFF: usize = 0;
-        const DEC_FLAGS_OFF: usize = Self::START_POS_OFF + std::mem::size_of::<Offset>();
+        const DEC_FLAGS_OFF: usize = Self::START_POS_OFF + core::mem::size_of::<Offset>();
         const BYTES_TO_FEED_OFF: usize = Self::DEC_FLAGS_OFF + 4;
         const CHARS_TO_SKIP_OFF: usize = Self::BYTES_TO_FEED_OFF + 4;
         const NEED_EOF_OFF: usize = Self::CHARS_TO_SKIP_OFF + 4;
@@ -2525,7 +2525,7 @@ mod _io {
             macro_rules! get_field {
                 ($t:ty, $off:ident) => {{
                     <$t>::from_ne_bytes(
-                        buf[Self::$off..][..std::mem::size_of::<$t>()]
+                        buf[Self::$off..][..core::mem::size_of::<$t>()]
                             .try_into()
                             .unwrap(),
                     )
@@ -2546,7 +2546,7 @@ mod _io {
             macro_rules! set_field {
                 ($field:expr, $off:ident) => {{
                     let field = $field;
-                    buf[Self::$off..][..std::mem::size_of_val(&field)]
+                    buf[Self::$off..][..core::mem::size_of_val(&field)]
                         .copy_from_slice(&field.to_ne_bytes())
                 }};
             }
@@ -3509,7 +3509,7 @@ mod _io {
             } else {
                 size_hint
             };
-            let chunk_size = std::cmp::max(self.chunk_size, size_hint);
+            let chunk_size = core::cmp::max(self.chunk_size, size_hint);
             let input_chunk = vm.call_method(&self.buffer, method, (chunk_size,))?;
 
             let buf = ArgBytesLike::try_from_borrowed_object(vm, &input_chunk).map_err(|_| {
@@ -3591,8 +3591,8 @@ mod _io {
             vm: &VirtualMachine,
         ) -> PyStrRef {
             let empty_str = || vm.ctx.empty_str.to_owned();
-            let chars_pos = std::mem::take(&mut self.decoded_chars_used).bytes;
-            let decoded_chars = match std::mem::take(&mut self.decoded_chars) {
+            let chars_pos = core::mem::take(&mut self.decoded_chars_used).bytes;
+            let decoded_chars = match core::mem::take(&mut self.decoded_chars) {
                 None => return append.unwrap_or_else(empty_str),
                 Some(s) if s.is_empty() => return append.unwrap_or_else(empty_str),
                 Some(s) => s,
@@ -4294,7 +4294,7 @@ mod _io {
         plus: bool,
     }
 
-    impl std::str::FromStr for Mode {
+    impl core::str::FromStr for Mode {
         type Err = ParseModeError;
 
         fn from_str(s: &str) -> Result<Self, Self::Err> {
diff --git a/crates/vm/src/stdlib/itertools.rs b/crates/vm/src/stdlib/itertools.rs
index 3fedd17f12b..3aad2f91931 100644
--- a/crates/vm/src/stdlib/itertools.rs
+++ b/crates/vm/src/stdlib/itertools.rs
@@ -25,8 +25,8 @@ mod decl {
     use malachite_bigint::BigInt;
     use num_traits::One;
 
+    use alloc::fmt;
     use num_traits::{Signed, ToPrimitive};
-    use std::fmt;
 
     fn pickle_deprecation(vm: &VirtualMachine) -> PyResult<()> {
         warnings::warn(
@@ -1320,7 +1320,7 @@ mod decl {
             for arg in iterables.iter() {
                 pools.push(arg.try_to_value(vm)?);
             }
-            let pools = std::iter::repeat_n(pools, repeat)
+            let pools = core::iter::repeat_n(pools, repeat)
                 .flatten()
                 .collect::<Vec<Vec<PyObjectRef>>>();
 
diff --git a/crates/vm/src/stdlib/mod.rs b/crates/vm/src/stdlib/mod.rs
index 9fae516fe04..e46f333a28b 100644
--- a/crates/vm/src/stdlib/mod.rs
+++ b/crates/vm/src/stdlib/mod.rs
@@ -62,7 +62,8 @@ mod winapi;
 mod winreg;
 
 use crate::{PyRef, VirtualMachine, builtins::PyModule};
-use std::{borrow::Cow, collections::HashMap};
+use alloc::borrow::Cow;
+use std::collections::HashMap;
 
 pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyRef<PyModule>)>;
 pub type StdlibMap = HashMap<Cow<'static, str>, StdlibInitFunc, ahash::RandomState>;
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
index e056142658d..a32959808c0 100644
--- a/crates/vm/src/stdlib/nt.rs
+++ b/crates/vm/src/stdlib/nt.rs
@@ -497,7 +497,7 @@ pub(crate) mod module {
                 wide_path.as_ptr(),
                 FILE_READ_ATTRIBUTES,
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
                 std::ptr::null_mut(),
@@ -517,7 +517,7 @@ pub(crate) mod module {
                     wide_path.as_ptr(),
                     FILE_READ_ATTRIBUTES,
                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     OPEN_EXISTING,
                     FILE_FLAG_OPEN_REPARSE_POINT,
                     std::ptr::null_mut(),
@@ -568,7 +568,7 @@ pub(crate) mod module {
                 wide_path.as_ptr(),
                 FILE_READ_ATTRIBUTES,
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 flags,
                 std::ptr::null_mut(),
@@ -586,7 +586,7 @@ pub(crate) mod module {
                 wide_path.as_ptr(),
                 GENERIC_READ,
                 FILE_SHARE_READ | FILE_SHARE_WRITE,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 0,
                 std::ptr::null_mut(),
@@ -733,7 +733,7 @@ pub(crate) mod module {
                 volume.as_ptr(),
                 FILE_READ_ATTRIBUTES,
                 FILE_SHARE_READ | FILE_SHARE_WRITE,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS,
                 std::ptr::null_mut(),
@@ -862,7 +862,7 @@ pub(crate) mod module {
                     conout.as_ptr(),
                     Foundation::GENERIC_READ | Foundation::GENERIC_WRITE,
                     FileSystem::FILE_SHARE_READ | FileSystem::FILE_SHARE_WRITE,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     FileSystem::OPEN_EXISTING,
                     0,
                     std::ptr::null_mut(),
@@ -933,7 +933,7 @@ pub(crate) mod module {
         let argv_spawn: Vec<*const u16> = argv
             .iter()
             .map(|v| v.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         let result = unsafe { suppress_iph!(_wspawnv(mode, path.as_ptr(), argv_spawn.as_ptr())) };
@@ -976,7 +976,7 @@ pub(crate) mod module {
         let argv_spawn: Vec<*const u16> = argv
             .iter()
             .map(|v| v.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         // Build environment strings as "KEY=VALUE\0" wide strings
@@ -1004,7 +1004,7 @@ pub(crate) mod module {
         let envp: Vec<*const u16> = env_strings
             .iter()
             .map(|s| s.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         let result = unsafe {
@@ -1052,7 +1052,7 @@ pub(crate) mod module {
         let argv_execv: Vec<*const u16> = argv
             .iter()
             .map(|v| v.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         if (unsafe { suppress_iph!(_wexecv(path.as_ptr(), argv_execv.as_ptr())) } == -1) {
@@ -1093,7 +1093,7 @@ pub(crate) mod module {
         let argv_execve: Vec<*const u16> = argv
             .iter()
             .map(|v| v.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         // Build environment strings as "KEY=VALUE\0" wide strings
@@ -1121,7 +1121,7 @@ pub(crate) mod module {
         let envp: Vec<*const u16> = env_strings
             .iter()
             .map(|s| s.as_ptr())
-            .chain(once(std::ptr::null()))
+            .chain(once(core::ptr::null()))
             .collect();
 
         if (unsafe { suppress_iph!(_wexecve(path.as_ptr(), argv_execve.as_ptr(), envp.as_ptr())) }
@@ -1356,7 +1356,7 @@ pub(crate) mod module {
             .chain(std::iter::once(0)) // null-terminated
             .collect();
 
-        let mut end: *const u16 = std::ptr::null();
+        let mut end: *const u16 = core::ptr::null();
         let hr = unsafe {
             windows_sys::Win32::UI::Shell::PathCchSkipRoot(backslashed.as_ptr(), &mut end)
         };
@@ -1667,7 +1667,7 @@ pub(crate) mod module {
             let res = CreatePipe(
                 read.as_mut_ptr() as *mut _,
                 write.as_mut_ptr() as *mut _,
-                std::ptr::null(),
+                core::ptr::null(),
                 0,
             );
             if res == 0 {
@@ -1723,7 +1723,7 @@ pub(crate) mod module {
         let Some(func) = func else {
             return 0;
         };
-        let nt_query: NtQueryInformationProcessFn = unsafe { std::mem::transmute(func) };
+        let nt_query: NtQueryInformationProcessFn = unsafe { core::mem::transmute(func) };
 
         let mut info: PROCESS_BASIC_INFORMATION = unsafe { std::mem::zeroed() };
 
@@ -1808,7 +1808,7 @@ pub(crate) mod module {
                 wide_path.as_ptr(),
                 0, // No access needed, just reading reparse data
                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                std::ptr::null(),
+                core::ptr::null(),
                 OPEN_EXISTING,
                 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
                 std::ptr::null_mut(),
@@ -1832,7 +1832,7 @@ pub(crate) mod module {
             DeviceIoControl(
                 handle,
                 FSCTL_GET_REPARSE_POINT,
-                std::ptr::null(),
+                core::ptr::null(),
                 0,
                 buffer.as_mut_ptr() as *mut _,
                 BUFFER_SIZE as u32,
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 6e2bb274fec..add8763f5e1 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -171,15 +171,10 @@ pub(super) mod _os {
         utils::ToCString,
         vm::VirtualMachine,
     };
+    use core::time::Duration;
     use crossbeam_utils::atomic::AtomicCell;
     use itertools::Itertools;
-    use std::{
-        env, fs,
-        fs::OpenOptions,
-        io,
-        path::PathBuf,
-        time::{Duration, SystemTime},
-    };
+    use std::{env, fs, fs::OpenOptions, io, path::PathBuf, time::SystemTime};
 
     const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
     pub(crate) const MKDIR_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
@@ -518,7 +513,7 @@ pub(super) mod _os {
                 22,
                 format!(
                     "Invalid argument: {}",
-                    std::str::from_utf8(key).unwrap_or("<bytes encoding failure>")
+                    core::str::from_utf8(key).unwrap_or("<bytes encoding failure>")
                 ),
             );
 
@@ -1051,12 +1046,12 @@ pub(super) mod _os {
         dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
         follow_symlinks: FollowSymlinks,
     ) -> io::Result<Option<StatStruct>> {
-        let mut stat = std::mem::MaybeUninit::uninit();
+        let mut stat = core::mem::MaybeUninit::uninit();
         let ret = match file {
             OsPathOrFd::Path(path) => {
                 use rustpython_common::os::ffi::OsStrExt;
                 let path = path.as_ref().as_os_str().as_bytes();
-                let path = match std::ffi::CString::new(path) {
+                let path = match alloc::ffi::CString::new(path) {
                     Ok(x) => x,
                     Err(_) => return Ok(None),
                 };
@@ -1218,7 +1213,7 @@ pub(super) mod _os {
             use std::os::windows::io::AsRawHandle;
             use windows_sys::Win32::Storage::FileSystem;
             let handle = crt_fd::as_handle(fd).map_err(|e| e.into_pyexception(vm))?;
-            let mut distance_to_move: [i32; 2] = std::mem::transmute(position);
+            let mut distance_to_move: [i32; 2] = core::mem::transmute(position);
             let ret = FileSystem::SetFilePointer(
                 handle.as_raw_handle(),
                 distance_to_move[0],
@@ -1229,7 +1224,7 @@ pub(super) mod _os {
                 -1
             } else {
                 distance_to_move[0] = ret as _;
-                std::mem::transmute::<[i32; 2], i64>(distance_to_move)
+                core::mem::transmute::<[i32; 2], i64>(distance_to_move)
             }
         };
         if res < 0 {
@@ -1411,7 +1406,7 @@ pub(super) mod _os {
                 .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
 
             let ret = unsafe {
-                FileSystem::SetFileTime(f.as_raw_handle() as _, std::ptr::null(), &acc, &modif)
+                FileSystem::SetFileTime(f.as_raw_handle() as _, core::ptr::null(), &acc, &modif)
             };
 
             if ret == 0 {
@@ -1532,9 +1527,9 @@ pub(super) mod _os {
     #[pyfunction]
     fn copy_file_range(args: CopyFileRangeArgs<'_>, vm: &VirtualMachine) -> PyResult<usize> {
         #[allow(clippy::unnecessary_option_map_or_else)]
-        let p_offset_src = args.offset_src.as_ref().map_or_else(std::ptr::null, |x| x);
+        let p_offset_src = args.offset_src.as_ref().map_or_else(core::ptr::null, |x| x);
         #[allow(clippy::unnecessary_option_map_or_else)]
-        let p_offset_dst = args.offset_dst.as_ref().map_or_else(std::ptr::null, |x| x);
+        let p_offset_dst = args.offset_dst.as_ref().map_or_else(core::ptr::null, |x| x);
         let count: usize = args
             .count
             .try_into()
@@ -1566,7 +1561,7 @@ pub(super) mod _os {
 
     #[pyfunction]
     fn strerror(e: i32) -> String {
-        unsafe { std::ffi::CStr::from_ptr(libc::strerror(e)) }
+        unsafe { core::ffi::CStr::from_ptr(libc::strerror(e)) }
             .to_string_lossy()
             .into_owned()
     }
@@ -1670,7 +1665,7 @@ pub(super) mod _os {
                     if encoding.is_null() || encoding.read() == '\0' as libc::c_char {
                         "UTF-8".to_owned()
                     } else {
-                        std::ffi::CStr::from_ptr(encoding).to_string_lossy().into_owned()
+                        core::ffi::CStr::from_ptr(encoding).to_string_lossy().into_owned()
                     }
                 };
 
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index a4a311df06a..4ec71eecbf2 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -33,15 +33,15 @@ pub mod module {
         types::{Constructor, Representable},
         utils::ToCString,
     };
+    use alloc::ffi::CString;
     use bitflags::bitflags;
+    use core::ffi::CStr;
     use nix::{
         fcntl,
         unistd::{self, Gid, Pid, Uid},
     };
     use std::{
-        env,
-        ffi::{CStr, CString},
-        fs, io,
+        env, fs, io,
         os::fd::{AsFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},
     };
     use strum_macros::{EnumIter, EnumString};
@@ -917,7 +917,7 @@ pub mod module {
     #[pyfunction]
     fn sched_getparam(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<SchedParam> {
         let param = unsafe {
-            let mut param = std::mem::MaybeUninit::uninit();
+            let mut param = core::mem::MaybeUninit::uninit();
             if -1 == libc::sched_getparam(pid, param.as_mut_ptr()) {
                 return Err(vm.new_last_errno_error());
             }
@@ -1280,7 +1280,7 @@ pub mod module {
     }
 
     fn try_from_id(vm: &VirtualMachine, obj: PyObjectRef, typ_name: &str) -> PyResult<u32> {
-        use std::cmp::Ordering;
+        use core::cmp::Ordering;
         let i = obj
             .try_to_ref::<PyInt>(vm)
             .map_err(|_| {
@@ -1853,9 +1853,9 @@ pub mod module {
 
     #[pyfunction]
     fn dup2(args: Dup2Args<'_>, vm: &VirtualMachine) -> PyResult<OwnedFd> {
-        let mut fd2 = std::mem::ManuallyDrop::new(args.fd2);
+        let mut fd2 = core::mem::ManuallyDrop::new(args.fd2);
         nix::unistd::dup2(args.fd, &mut fd2).map_err(|e| e.into_pyexception(vm))?;
-        let fd2 = std::mem::ManuallyDrop::into_inner(fd2);
+        let fd2 = core::mem::ManuallyDrop::into_inner(fd2);
         if !args.inheritable {
             super::set_inheritable(fd2.as_fd(), false).map_err(|e| e.into_pyexception(vm))?
         }
diff --git a/crates/vm/src/stdlib/pwd.rs b/crates/vm/src/stdlib/pwd.rs
index e4d7075dbc8..6405ed7be91 100644
--- a/crates/vm/src/stdlib/pwd.rs
+++ b/crates/vm/src/stdlib/pwd.rs
@@ -37,7 +37,7 @@ mod pwd {
     impl From<User> for PasswdData {
         fn from(user: User) -> Self {
             // this is just a pain...
-            let cstr_lossy = |s: std::ffi::CString| {
+            let cstr_lossy = |s: alloc::ffi::CString| {
                 s.into_string()
                     .unwrap_or_else(|e| e.into_cstring().to_string_lossy().into_owned())
             };
@@ -105,7 +105,7 @@ mod pwd {
         let mut list = Vec::new();
 
         unsafe { libc::setpwent() };
-        while let Some(ptr) = std::ptr::NonNull::new(unsafe { libc::getpwent() }) {
+        while let Some(ptr) = core::ptr::NonNull::new(unsafe { libc::getpwent() }) {
             let user = User::from(unsafe { ptr.as_ref() });
             let passwd = PasswdData::from(user).to_pyobject(vm);
             list.push(passwd);
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
index 810ffabefe6..dd0d9a7a96f 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/signal.rs
@@ -24,7 +24,7 @@ pub(crate) mod _signal {
         builtins::PyTypeRef,
         function::{ArgIntoFloat, OptionalArg},
     };
-    use std::sync::atomic::{self, Ordering};
+    use core::sync::atomic::{self, Ordering};
 
     #[cfg(any(unix, windows))]
     use libc::sighandler_t;
@@ -301,7 +301,7 @@ pub(crate) mod _signal {
             it_value: double_to_timeval(seconds),
             it_interval: double_to_timeval(interval),
         };
-        let mut old = std::mem::MaybeUninit::<libc::itimerval>::uninit();
+        let mut old = core::mem::MaybeUninit::<libc::itimerval>::uninit();
         #[cfg(any(target_os = "linux", target_os = "android"))]
         let ret = unsafe { ffi::setitimer(which, &new, old.as_mut_ptr()) };
         #[cfg(not(any(target_os = "linux", target_os = "android")))]
@@ -318,7 +318,7 @@ pub(crate) mod _signal {
     #[cfg(unix)]
     #[pyfunction]
     fn getitimer(which: i32, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
-        let mut old = std::mem::MaybeUninit::<libc::itimerval>::uninit();
+        let mut old = core::mem::MaybeUninit::<libc::itimerval>::uninit();
         #[cfg(any(target_os = "linux", target_os = "android"))]
         let ret = unsafe { ffi::getitimer(which, old.as_mut_ptr()) };
         #[cfg(not(any(target_os = "linux", target_os = "android")))]
@@ -489,7 +489,7 @@ pub(crate) mod _signal {
         if s.is_null() {
             Ok(None)
         } else {
-            let cstr = unsafe { std::ffi::CStr::from_ptr(s) };
+            let cstr = unsafe { core::ffi::CStr::from_ptr(s) };
             Ok(Some(cstr.to_string_lossy().into_owned()))
         }
     }
@@ -522,7 +522,7 @@ pub(crate) mod _signal {
         #[cfg(unix)]
         {
             // Use sigfillset to get all valid signals
-            let mut mask: libc::sigset_t = unsafe { std::mem::zeroed() };
+            let mut mask: libc::sigset_t = unsafe { core::mem::zeroed() };
             // SAFETY: mask is a valid pointer
             if unsafe { libc::sigfillset(&mut mask) } != 0 {
                 return Err(vm.new_os_error("sigfillset failed".to_owned()));
@@ -580,7 +580,7 @@ pub(crate) mod _signal {
         use crate::convert::IntoPyException;
 
         // Initialize sigset
-        let mut sigset: libc::sigset_t = unsafe { std::mem::zeroed() };
+        let mut sigset: libc::sigset_t = unsafe { core::mem::zeroed() };
         // SAFETY: sigset is a valid pointer
         if unsafe { libc::sigemptyset(&mut sigset) } != 0 {
             return Err(std::io::Error::last_os_error().into_pyexception(vm));
@@ -611,7 +611,7 @@ pub(crate) mod _signal {
         }
 
         // Call pthread_sigmask
-        let mut old_mask: libc::sigset_t = unsafe { std::mem::zeroed() };
+        let mut old_mask: libc::sigset_t = unsafe { core::mem::zeroed() };
         // SAFETY: all pointers are valid
         let err = unsafe { libc::pthread_sigmask(how, &sigset, &mut old_mask) };
         if err != 0 {
diff --git a/crates/vm/src/stdlib/string.rs b/crates/vm/src/stdlib/string.rs
index 576cae62775..a9911f3d45f 100644
--- a/crates/vm/src/stdlib/string.rs
+++ b/crates/vm/src/stdlib/string.rs
@@ -16,7 +16,7 @@ mod _string {
         convert::ToPyException,
         convert::ToPyObject,
     };
-    use std::mem;
+    use core::mem;
 
     fn create_format_part(
         literal: Wtf8Buf,
diff --git a/crates/vm/src/stdlib/symtable.rs b/crates/vm/src/stdlib/symtable.rs
index 8a142857787..51c5c8e47ea 100644
--- a/crates/vm/src/stdlib/symtable.rs
+++ b/crates/vm/src/stdlib/symtable.rs
@@ -7,10 +7,10 @@ mod symtable {
         builtins::{PyDictRef, PyStrRef},
         compiler,
     };
+    use alloc::fmt;
     use rustpython_codegen::symboltable::{
         CompilerScope, Symbol, SymbolFlags, SymbolScope, SymbolTable,
     };
-    use std::fmt;
 
     // Consts as defined at
     // https://github.com/python/cpython/blob/6cb20a219a860eaf687b2d968b41c480c7461909/Include/internal/pycore_symtable.h#L156
@@ -180,7 +180,7 @@ mod symtable {
 
         #[pygetset]
         fn id(&self) -> usize {
-            self as *const Self as *const std::ffi::c_void as usize
+            self as *const Self as *const core::ffi::c_void as usize
         }
 
         #[pygetset]
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 92b15878b46..30f126b3742 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -24,11 +24,11 @@ mod sys {
         version,
         vm::{Settings, VirtualMachine},
     };
+    use core::sync::atomic::Ordering;
     use num_traits::ToPrimitive;
     use std::{
         env::{self, VarError},
         io::Read,
-        sync::atomic::Ordering,
     };
 
     #[cfg(windows)]
@@ -67,7 +67,7 @@ mod sys {
     #[pyattr(name = "maxsize")]
     pub(crate) const MAXSIZE: isize = isize::MAX;
     #[pyattr(name = "maxunicode")]
-    const MAXUNICODE: u32 = std::char::MAX as u32;
+    const MAXUNICODE: u32 = core::char::MAX as u32;
     #[pyattr(name = "platform")]
     pub(crate) const PLATFORM: &str = {
         cfg_if::cfg_if! {
@@ -751,7 +751,7 @@ mod sys {
         let sizeof = || -> PyResult<usize> {
             let res = vm.call_special_method(&args.obj, identifier!(vm, __sizeof__), ())?;
             let res = res.try_index(vm)?.try_to_primitive::<usize>(vm)?;
-            Ok(res + std::mem::size_of::<PyObject>())
+            Ok(res + core::mem::size_of::<PyObject>())
         };
         sizeof()
             .map(|x| vm.ctx.new_int(x).into())
@@ -1377,7 +1377,7 @@ mod sys {
         const INFO: Self = {
             use rustpython_common::hash::*;
             Self {
-                width: std::mem::size_of::<PyHash>() * 8,
+                width: core::mem::size_of::<PyHash>() * 8,
                 modulus: MODULUS,
                 inf: INF,
                 nan: NAN,
@@ -1407,7 +1407,7 @@ mod sys {
     impl IntInfoData {
         const INFO: Self = Self {
             bits_per_digit: 30, //?
-            sizeof_digit: std::mem::size_of::<u32>(),
+            sizeof_digit: core::mem::size_of::<u32>(),
             default_max_str_digits: 4300,
             str_digits_check_threshold: 640,
         };
@@ -1525,7 +1525,7 @@ pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins:
 pub struct PyStderr<'vm>(pub &'vm VirtualMachine);
 
 impl PyStderr<'_> {
-    pub fn write_fmt(&self, args: std::fmt::Arguments<'_>) {
+    pub fn write_fmt(&self, args: core::fmt::Arguments<'_>) {
         use crate::py_io::Write;
 
         let vm = self.0;
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index fd300ac2f74..6ab754be094 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -11,12 +11,14 @@ pub(crate) mod _thread {
         function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
         types::{Constructor, GetAttr, Representable, SetAttr},
     };
+    use alloc::fmt;
+    use core::{cell::RefCell, time::Duration};
     use crossbeam_utils::atomic::AtomicCell;
     use parking_lot::{
         RawMutex, RawThreadId,
         lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
     };
-    use std::{cell::RefCell, fmt, thread, time::Duration};
+    use std::thread;
     use thread_local::ThreadLocal;
 
     // PYTHREAD_NAME: show current thread name
@@ -151,7 +153,7 @@ pub(crate) mod _thread {
 
             let new_mut = RawMutex::INIT;
             unsafe {
-                let old_mutex: &AtomicCell<RawMutex> = std::mem::transmute(&self.mu);
+                let old_mutex: &AtomicCell<RawMutex> = core::mem::transmute(&self.mu);
                 old_mutex.swap(new_mut);
             }
 
@@ -287,7 +289,7 @@ pub(crate) mod _thread {
     }
 
     fn thread_to_id(t: &thread::Thread) -> u64 {
-        use std::hash::{Hash, Hasher};
+        use core::hash::{Hash, Hasher};
         struct U64Hash {
             v: Option<u64>,
         }
diff --git a/crates/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs
index b9b53cdc5c5..97d60ae98a1 100644
--- a/crates/vm/src/stdlib/time.rs
+++ b/crates/vm/src/stdlib/time.rs
@@ -21,12 +21,12 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 unsafe extern "C" {
     #[cfg(not(target_os = "freebsd"))]
     #[link_name = "daylight"]
-    static c_daylight: std::ffi::c_int;
+    static c_daylight: core::ffi::c_int;
     // pub static dstbias: std::ffi::c_int;
     #[link_name = "timezone"]
-    static c_timezone: std::ffi::c_long;
+    static c_timezone: core::ffi::c_long;
     #[link_name = "tzname"]
-    static c_tzname: [*const std::ffi::c_char; 2];
+    static c_tzname: [*const core::ffi::c_char; 2];
     #[link_name = "tzset"]
     fn c_tzset();
 }
@@ -43,7 +43,7 @@ mod decl {
         DateTime, Datelike, TimeZone, Timelike,
         naive::{NaiveDate, NaiveDateTime, NaiveTime},
     };
-    use std::time::Duration;
+    use core::time::Duration;
     #[cfg(target_env = "msvc")]
     #[cfg(not(target_arch = "wasm32"))]
     use windows_sys::Win32::System::Time::{GetTimeZoneInformation, TIME_ZONE_INFORMATION};
@@ -104,7 +104,7 @@ mod decl {
         {
             // this is basically std::thread::sleep, but that catches interrupts and we don't want to;
             let ts = nix::sys::time::TimeSpec::from(dur);
-            let res = unsafe { libc::nanosleep(ts.as_ref(), std::ptr::null_mut()) };
+            let res = unsafe { libc::nanosleep(ts.as_ref(), core::ptr::null_mut()) };
             let interrupted = res == -1 && nix::Error::last_raw() == libc::EINTR;
 
             if interrupted {
@@ -200,7 +200,7 @@ mod decl {
     #[cfg(not(target_env = "msvc"))]
     #[cfg(not(target_arch = "wasm32"))]
     #[pyattr]
-    fn timezone(_vm: &VirtualMachine) -> std::ffi::c_long {
+    fn timezone(_vm: &VirtualMachine) -> core::ffi::c_long {
         unsafe { super::c_timezone }
     }
 
@@ -217,7 +217,7 @@ mod decl {
     #[cfg(not(target_env = "msvc"))]
     #[cfg(not(target_arch = "wasm32"))]
     #[pyattr]
-    fn daylight(_vm: &VirtualMachine) -> std::ffi::c_int {
+    fn daylight(_vm: &VirtualMachine) -> core::ffi::c_int {
         unsafe { super::c_daylight }
     }
 
@@ -236,8 +236,8 @@ mod decl {
     fn tzname(vm: &VirtualMachine) -> crate::builtins::PyTupleRef {
         use crate::builtins::tuple::IntoPyTuple;
 
-        unsafe fn to_str(s: *const std::ffi::c_char) -> String {
-            unsafe { std::ffi::CStr::from_ptr(s) }
+        unsafe fn to_str(s: *const core::ffi::c_char) -> String {
+            unsafe { core::ffi::CStr::from_ptr(s) }
                 .to_string_lossy()
                 .into_owned()
         }
@@ -357,7 +357,7 @@ mod decl {
         t: OptionalArg<StructTimeData>,
         vm: &VirtualMachine,
     ) -> PyResult {
-        use std::fmt::Write;
+        use core::fmt::Write;
 
         let instant = t.naive_or_local(vm)?;
 
@@ -500,8 +500,8 @@ mod decl {
         pub tm_zone: PyObjectRef,
     }
 
-    impl std::fmt::Debug for StructTimeData {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for StructTimeData {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "struct_time()")
         }
     }
@@ -590,8 +590,8 @@ mod platform {
         builtins::{PyNamespace, PyStrRef},
         convert::IntoPyException,
     };
+    use core::time::Duration;
     use nix::{sys::time::TimeSpec, time::ClockId};
-    use std::time::Duration;
 
     #[cfg(target_os = "solaris")]
     #[pyattr]
@@ -818,7 +818,7 @@ mod platform {
 
     fn u64_from_filetime(time: FILETIME) -> u64 {
         let large: [u32; 2] = [time.dwLowDateTime, time.dwHighDateTime];
-        unsafe { std::mem::transmute(large) }
+        unsafe { core::mem::transmute(large) }
     }
 
     fn win_perf_counter_frequency(vm: &VirtualMachine) -> PyResult<i64> {
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs
index a3aba447489..7279f9776e2 100644
--- a/crates/vm/src/stdlib/winapi.rs
+++ b/crates/vm/src/stdlib/winapi.rs
@@ -108,7 +108,7 @@ mod _winapi {
             WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
                 read.as_mut_ptr(),
                 write.as_mut_ptr(),
-                std::ptr::null(),
+                core::ptr::null(),
                 size,
             ))
             .to_pyresult(vm)?;
@@ -279,8 +279,8 @@ mod _winapi {
             WindowsSysResult(windows_sys::Win32::System::Threading::CreateProcessW(
                 app_name,
                 command_line,
-                std::ptr::null(),
-                std::ptr::null(),
+                core::ptr::null(),
+                core::ptr::null(),
                 args.inherit_handles,
                 args.creation_flags
                     | windows_sys::Win32::System::Threading::EXTENDED_STARTUPINFO_PRESENT
@@ -455,7 +455,7 @@ mod _winapi {
                             handlelist.as_mut_ptr() as _,
                             (handlelist.len() * std::mem::size_of::<usize>()) as _,
                             std::ptr::null_mut(),
-                            std::ptr::null(),
+                            core::ptr::null(),
                         )
                     })
                     .into_pyresult(vm)?;
@@ -874,7 +874,7 @@ mod _winapi {
         }
 
         let buf = buffer.borrow_buf();
-        let len = std::cmp::min(buf.len(), u32::MAX as usize) as u32;
+        let len = core::cmp::min(buf.len(), u32::MAX as usize) as u32;
         let mut written: u32 = 0;
 
         let ret = unsafe {
@@ -948,7 +948,7 @@ mod _winapi {
         let mut batches: Vec<Vec<isize>> = Vec::new();
         let mut i = 0;
         while i < nhandles {
-            let end = std::cmp::min(i + batch_size, nhandles);
+            let end = core::cmp::min(i + batch_size, nhandles);
             batches.push(handles[i..end].to_vec());
             i = end;
         }
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
index b5e568fce6d..f3d8ca10768 100644
--- a/crates/vm/src/stdlib/winreg.rs
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -367,10 +367,10 @@ mod winreg {
                 key,
                 wide_sub_key.as_ptr(),
                 args.reserved,
-                std::ptr::null(),
+                core::ptr::null(),
                 Registry::REG_OPTION_NON_VOLATILE,
                 args.access,
-                std::ptr::null(),
+                core::ptr::null(),
                 &mut res,
                 std::ptr::null_mut(),
             )
@@ -404,7 +404,9 @@ mod winreg {
     #[pyfunction]
     fn DeleteValue(key: PyRef<PyHkey>, value: Option<String>, vm: &VirtualMachine) -> PyResult<()> {
         let wide_value = value.map(|v| v.to_wide_with_nul());
-        let value_ptr = wide_value.as_ref().map_or(std::ptr::null(), |v| v.as_ptr());
+        let value_ptr = wide_value
+            .as_ref()
+            .map_or(core::ptr::null(), |v| v.as_ptr());
         let res = unsafe { Registry::RegDeleteValueW(key.hkey.load(), value_ptr) };
         if res == 0 {
             Ok(())
@@ -713,7 +715,7 @@ mod winreg {
             let res = unsafe {
                 Registry::RegQueryValueExW(
                     target_key,
-                    std::ptr::null(), // NULL value name for default value
+                    core::ptr::null(), // NULL value name for default value
                     std::ptr::null_mut(),
                     &mut reg_type,
                     buffer.as_mut_ptr(),
@@ -871,10 +873,10 @@ mod winreg {
                     hkey,
                     wide_sub_key.as_ptr(),
                     0,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     0,
                     Registry::KEY_SET_VALUE,
-                    std::ptr::null(),
+                    core::ptr::null(),
                     &mut out_key,
                     std::ptr::null_mut(),
                 )
@@ -893,7 +895,7 @@ mod winreg {
         let res = unsafe {
             Registry::RegSetValueExW(
                 target_key,
-                std::ptr::null(), // value name is NULL
+                core::ptr::null(), // value name is NULL
                 0,
                 typ,
                 wide_value.as_ptr() as *const u8,
@@ -1104,7 +1106,7 @@ mod winreg {
             }
             Ok(None) => {
                 let len = 0;
-                let ptr = std::ptr::null();
+                let ptr = core::ptr::null();
                 let wide_value_name = value_name.to_wide_with_nul();
                 let res = unsafe {
                     Registry::RegSetValueExW(
diff --git a/crates/vm/src/suggestion.rs b/crates/vm/src/suggestion.rs
index 866deb668eb..55326d1d3f0 100644
--- a/crates/vm/src/suggestion.rs
+++ b/crates/vm/src/suggestion.rs
@@ -7,8 +7,8 @@ use crate::{
     exceptions::types::PyBaseException,
     sliceable::SliceableSequenceOp,
 };
+use core::iter::ExactSizeIterator;
 use rustpython_common::str::levenshtein::{MOVE_COST, levenshtein_distance};
-use std::iter::ExactSizeIterator;
 
 const MAX_CANDIDATE_ITEMS: usize = 750;
 
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 658e21cba8a..9d7d09f2d18 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -17,9 +17,9 @@ use crate::{
     types::slot_defs::{SlotAccessor, find_slot_defs_by_name},
     vm::Context,
 };
+use core::{any::Any, any::TypeId, borrow::Borrow, cmp::Ordering, ops::Deref};
 use crossbeam_utils::atomic::AtomicCell;
 use num_traits::{Signed, ToPrimitive};
-use std::{any::Any, any::TypeId, borrow::Borrow, cmp::Ordering, ops::Deref};
 
 /// Type-erased storage for extension module data attached to heap types.
 pub struct TypeDataSlot {
@@ -71,7 +71,7 @@ impl<'a, T: Any + 'static> TypeDataRef<'a, T> {
     }
 }
 
-impl<T: Any + 'static> std::ops::Deref for TypeDataRef<'_, T> {
+impl<T: Any + 'static> core::ops::Deref for TypeDataRef<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -96,7 +96,7 @@ impl<'a, T: Any + 'static> TypeDataRefMut<'a, T> {
     }
 }
 
-impl<T: Any + 'static> std::ops::Deref for TypeDataRefMut<'_, T> {
+impl<T: Any + 'static> core::ops::Deref for TypeDataRefMut<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -104,7 +104,7 @@ impl<T: Any + 'static> std::ops::Deref for TypeDataRefMut<'_, T> {
     }
 }
 
-impl<T: Any + 'static> std::ops::DerefMut for TypeDataRefMut<'_, T> {
+impl<T: Any + 'static> core::ops::DerefMut for TypeDataRefMut<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.guard
     }
@@ -203,8 +203,8 @@ impl PyTypeSlots {
     }
 }
 
-impl std::fmt::Debug for PyTypeSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyTypeSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("PyTypeSlots")
     }
 }
@@ -1310,7 +1310,7 @@ impl PyType {
 /// - Special class type handling (e.g., `PyType` and its metaclasses)
 /// - Post-creation mutations that require `PyRef`
 #[pyclass]
-pub trait Constructor: PyPayload + std::fmt::Debug {
+pub trait Constructor: PyPayload + core::fmt::Debug {
     type Args: FromArgs;
 
     /// The type slot for `__new__`. Override this only when you need special
@@ -1328,7 +1328,7 @@ pub trait Constructor: PyPayload + std::fmt::Debug {
     fn py_new(cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self>;
 }
 
-pub trait DefaultConstructor: PyPayload + Default + std::fmt::Debug {
+pub trait DefaultConstructor: PyPayload + Default + core::fmt::Debug {
     fn construct_and_init(args: Self::Args, vm: &VirtualMachine) -> PyResult<PyRef<Self>>
     where
         Self: Initializer,
@@ -1862,7 +1862,7 @@ pub trait Iterable: PyPayload {
     fn extend_slots(_slots: &mut PyTypeSlots) {}
 }
 
-// `Iterator` fits better, but to avoid confusion with rust std::iter::Iterator
+// `Iterator` fits better, but to avoid confusion with rust core::iter::Iterator
 #[pyclass(with(Iterable))]
 pub trait IterNext: PyPayload + Iterable {
     #[pyslot]
diff --git a/crates/vm/src/utils.rs b/crates/vm/src/utils.rs
index af34405c7be..db232e81949 100644
--- a/crates/vm/src/utils.rs
+++ b/crates/vm/src/utils.rs
@@ -14,15 +14,15 @@ pub fn hash_iter<'a, I: IntoIterator<Item = &'a PyObjectRef>>(
     vm.state.hash_secret.hash_iter(iter, |obj| obj.hash(vm))
 }
 
-impl ToPyObject for std::convert::Infallible {
+impl ToPyObject for core::convert::Infallible {
     fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         match self {}
     }
 }
 
 pub trait ToCString: AsRef<Wtf8> {
-    fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.as_ref().as_bytes()).map_err(|err| err.to_pyexception(vm))
+    fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.as_ref().as_bytes()).map_err(|err| err.to_pyexception(vm))
     }
     fn ensure_no_nul(&self, vm: &VirtualMachine) -> PyResult<()> {
         if self.as_ref().as_bytes().contains(&b'\0') {
@@ -45,7 +45,7 @@ pub(crate) fn collection_repr<'a, I>(
     vm: &VirtualMachine,
 ) -> PyResult<String>
 where
-    I: std::iter::Iterator<Item = &'a PyObjectRef>,
+    I: core::iter::Iterator<Item = &'a PyObjectRef>,
 {
     let mut repr = String::new();
     if let Some(name) = class_name {
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index 0a598842a56..cc118ee5b0e 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -1,7 +1,8 @@
 //! Several function to retrieve version information.
 
 use chrono::{Local, prelude::DateTime};
-use std::time::{Duration, UNIX_EPOCH};
+use core::time::Duration;
+use std::time::UNIX_EPOCH;
 
 // = 3.13.0alpha
 pub const MAJOR: usize = 3;
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index 486c1861fb1..b12352f6eee 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -264,7 +264,7 @@ declare_const_name! {
 
 // Basic objects:
 impl Context {
-    pub const INT_CACHE_POOL_RANGE: std::ops::RangeInclusive<i32> = (-5)..=256;
+    pub const INT_CACHE_POOL_RANGE: core::ops::RangeInclusive<i32> = (-5)..=256;
     const INT_CACHE_POOL_MIN: i32 = *Self::INT_CACHE_POOL_RANGE.start();
 
     pub fn genesis() -> &'static PyRc<Self> {
@@ -374,14 +374,14 @@ impl Context {
     #[inline]
     pub fn empty_tuple_typed<T>(&self) -> &Py<PyTuple<T>> {
         let py: &Py<PyTuple> = &self.empty_tuple;
-        unsafe { std::mem::transmute(py) }
+        unsafe { core::mem::transmute(py) }
     }
 
     // universal pyref constructor
     pub fn new_pyref<T, P>(&self, value: T) -> PyRef<P>
     where
         T: Into<P>,
-        P: PyPayload + std::fmt::Debug,
+        P: PyPayload + core::fmt::Debug,
     {
         value.into().into_ref(self)
     }
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index 503feb3dc7f..8d37ad6c840 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -1,6 +1,6 @@
 use super::{Context, PyConfig, VirtualMachine, setting::Settings, thread};
 use crate::{PyResult, getpath, stdlib::atexit, vm::PyBaseExceptionRef};
-use std::sync::atomic::Ordering;
+use core::sync::atomic::Ordering;
 
 /// The general interface for the VM
 ///
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 34092454059..7c527b3e0da 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -33,6 +33,11 @@ use crate::{
     signal, stdlib,
     warn::WarningsState,
 };
+use alloc::borrow::Cow;
+use core::{
+    cell::{Cell, Ref, RefCell},
+    sync::atomic::AtomicBool,
+};
 use crossbeam_utils::atomic::AtomicCell;
 #[cfg(unix)]
 use nix::{
@@ -40,11 +45,8 @@ use nix::{
     unistd::getpid,
 };
 use std::{
-    borrow::Cow,
-    cell::{Cell, Ref, RefCell},
     collections::{HashMap, HashSet},
     ffi::{OsStr, OsString},
-    sync::atomic::AtomicBool,
 };
 
 pub use context::Context;
@@ -789,14 +791,14 @@ impl VirtualMachine {
 
     pub(crate) fn push_exception(&self, exc: Option<PyBaseExceptionRef>) {
         let mut excs = self.exceptions.borrow_mut();
-        let prev = std::mem::take(&mut *excs);
+        let prev = core::mem::take(&mut *excs);
         excs.prev = Some(Box::new(prev));
         excs.exc = exc
     }
 
     pub(crate) fn pop_exception(&self) -> Option<PyBaseExceptionRef> {
         let mut excs = self.exceptions.borrow_mut();
-        let cur = std::mem::take(&mut *excs);
+        let cur = core::mem::take(&mut *excs);
         *excs = *cur.prev.expect("pop_exception() without nested exc stack");
         cur.exc
     }
@@ -811,7 +813,7 @@ impl VirtualMachine {
 
     pub(crate) fn set_exception(&self, exc: Option<PyBaseExceptionRef>) {
         // don't be holding the RefCell guard while __del__ is called
-        let prev = std::mem::replace(&mut self.exceptions.borrow_mut().exc, exc);
+        let prev = core::mem::replace(&mut self.exceptions.borrow_mut().exc, exc);
         drop(prev);
     }
 
@@ -984,7 +986,7 @@ impl AsRef<Context> for VirtualMachine {
 }
 
 fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
-    let iter = std::iter::empty();
+    let iter = core::iter::empty();
     macro_rules! ext_modules {
         ($iter:ident, $($t:tt)*) => {
             let $iter = $iter.chain(py_freeze!($($t)*));
diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs
index 2e687d99820..7e8f0f87e56 100644
--- a/crates/vm/src/vm/thread.rs
+++ b/crates/vm/src/vm/thread.rs
@@ -1,10 +1,10 @@
 use crate::{AsObject, PyObject, PyObjectRef, VirtualMachine};
-use itertools::Itertools;
-use std::{
+use core::{
     cell::{Cell, RefCell},
     ptr::NonNull,
-    thread_local,
 };
+use itertools::Itertools;
+use std::thread_local;
 
 thread_local! {
     pub(super) static VM_STACK: RefCell<Vec<NonNull<VirtualMachine>>> = Vec::with_capacity(1).into();
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 6d0e983c844..ba09c8ecf69 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -95,7 +95,7 @@ impl VirtualMachine {
     pub fn new_exception(&self, exc_type: PyTypeRef, args: Vec<PyObjectRef>) -> PyBaseExceptionRef {
         debug_assert_eq!(
             exc_type.slots.basicsize,
-            std::mem::size_of::<PyBaseException>(),
+            core::mem::size_of::<PyBaseException>(),
             "vm.new_exception() is only for exception types without additional payload. The given type '{}' is not allowed.",
             exc_type.class().name()
         );
@@ -118,7 +118,7 @@ impl VirtualMachine {
         errno: Option<i32>,
         msg: impl ToPyObject,
     ) -> PyRef<PyOSError> {
-        debug_assert_eq!(exc_type.slots.basicsize, std::mem::size_of::<PyOSError>());
+        debug_assert_eq!(exc_type.slots.basicsize, core::mem::size_of::<PyOSError>());
 
         OSErrorBuilder::with_subtype(exc_type, errno, msg, self).build(self)
     }
diff --git a/crates/vm/src/vm/vm_ops.rs b/crates/vm/src/vm/vm_ops.rs
index 635fa10e630..1d466984377 100644
--- a/crates/vm/src/vm/vm_ops.rs
+++ b/crates/vm/src/vm/vm_ops.rs
@@ -302,8 +302,8 @@ impl VirtualMachine {
         }
 
         if let Some(slot_c) = class_c.slots.as_number.left_ternary_op(op_slot)
-            && slot_a.is_some_and(|slot_a| !std::ptr::fn_addr_eq(slot_a, slot_c))
-            && slot_b.is_some_and(|slot_b| !std::ptr::fn_addr_eq(slot_b, slot_c))
+            && slot_a.is_some_and(|slot_a| !core::ptr::fn_addr_eq(slot_a, slot_c))
+            && slot_b.is_some_and(|slot_b| !core::ptr::fn_addr_eq(slot_b, slot_c))
         {
             let ret = slot_c(a, b, c, self)?;
             if !ret.is(&self.ctx.not_implemented) {
diff --git a/crates/vm/src/warn.rs b/crates/vm/src/warn.rs
index 3dbd43ab537..09d48078e56 100644
--- a/crates/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -60,7 +60,7 @@ fn get_warnings_attr(
         && !vm
             .state
             .finalizing
-            .load(std::sync::atomic::Ordering::SeqCst)
+            .load(core::sync::atomic::Ordering::SeqCst)
     {
         match vm.import("warnings", 0) {
             Ok(module) => module,
diff --git a/crates/vm/src/windows.rs b/crates/vm/src/windows.rs
index ccf940811b8..ff2b612c06d 100644
--- a/crates/vm/src/windows.rs
+++ b/crates/vm/src/windows.rs
@@ -301,7 +301,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
             wide.as_ptr(),
             access,
             0,
-            std::ptr::null(),
+            core::ptr::null(),
             OPEN_EXISTING,
             flags,
             std::ptr::null_mut(),
@@ -337,7 +337,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         wide.as_ptr(),
                         access | GENERIC_READ,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
-                        std::ptr::null(),
+                        core::ptr::null(),
                         OPEN_EXISTING,
                         flags,
                         std::ptr::null_mut(),
@@ -355,7 +355,7 @@ fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatSt
                         wide.as_ptr(),
                         access,
                         0,
-                        std::ptr::null(),
+                        core::ptr::null(),
                         OPEN_EXISTING,
                         flags | FILE_FLAG_OPEN_REPARSE_POINT,
                         std::ptr::null_mut(),
diff --git a/examples/dis.rs b/examples/dis.rs
index 504b734ca59..942643cd54b 100644
--- a/examples/dis.rs
+++ b/examples/dis.rs
@@ -9,9 +9,9 @@
 #[macro_use]
 extern crate log;
 
+use core::error::Error;
 use lexopt::ValueExt;
 use rustpython_compiler as compiler;
-use std::error::Error;
 use std::fs;
 use std::path::{Path, PathBuf};
 
diff --git a/src/lib.rs b/src/lib.rs
index 8ee22d4eb5a..9dff074e20d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -258,7 +258,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
 }
 
 #[cfg(feature = "flame-it")]
-fn write_profile(settings: &Settings) -> Result<(), Box<dyn std::error::Error>> {
+fn write_profile(settings: &Settings) -> Result<(), Box<dyn core::error::Error>> {
     use std::{fs, io};
 
     enum ProfileFormat {

From 5e1fc93f5043c1f054122e7220416b4979521dee Mon Sep 17 00:00:00 2001
From: Jack O'Connor <github@jackoconnor.dev>
Date: Tue, 30 Dec 2025 04:42:47 +0000
Subject: [PATCH 118/418] Update zipfile to 3.13.5 (#6069)

* Add Lib/test/archiver_tests.py @ 3.13.5

Needed for updated zipfile tests.

* Update zipfile to 3.13.5

Notes:

- I have to skip some brand new tests due to shift_jis encoding not
being supported

- `test_write_filtered_python_package` marked as `expectedFailure` with
"AttributeError: module 'os' has no attribute 'supports_effective_ids'"
  - I didn't want to do a partial or full update to os module in this PR

---------

Co-authored-by: Jack O'Connor <jack@jackoconnor.dev>
---
 Lib/test/archiver_tests.py                    |  177 +++
 Lib/test/test_zipfile/__init__.py             |    5 +
 Lib/test/test_zipfile/__main__.py             |    7 +
 Lib/test/test_zipfile/_path/__init__.py       |    0
 Lib/test/test_zipfile/_path/_functools.py     |    9 +
 Lib/test/test_zipfile/_path/_itertools.py     |   79 +
 Lib/test/test_zipfile/_path/_support.py       |    9 +
 Lib/test/test_zipfile/_path/_test_params.py   |   39 +
 .../test_zipfile/_path/test_complexity.py     |  105 ++
 Lib/test/test_zipfile/_path/test_path.py      |  687 +++++++++
 Lib/test/test_zipfile/_path/write-alpharep.py |    3 +
 .../test_core.py}                             | 1291 ++++++++++++-----
 Lib/{zipfile.py => zipfile/__init__.py}       |  737 ++++------
 Lib/zipfile/__main__.py                       |    4 +
 Lib/zipfile/_path/__init__.py                 |  452 ++++++
 Lib/zipfile/_path/glob.py                     |  113 ++
 16 files changed, 2890 insertions(+), 827 deletions(-)
 create mode 100644 Lib/test/archiver_tests.py
 create mode 100644 Lib/test/test_zipfile/__init__.py
 create mode 100644 Lib/test/test_zipfile/__main__.py
 create mode 100644 Lib/test/test_zipfile/_path/__init__.py
 create mode 100644 Lib/test/test_zipfile/_path/_functools.py
 create mode 100644 Lib/test/test_zipfile/_path/_itertools.py
 create mode 100644 Lib/test/test_zipfile/_path/_support.py
 create mode 100644 Lib/test/test_zipfile/_path/_test_params.py
 create mode 100644 Lib/test/test_zipfile/_path/test_complexity.py
 create mode 100644 Lib/test/test_zipfile/_path/test_path.py
 create mode 100644 Lib/test/test_zipfile/_path/write-alpharep.py
 rename Lib/test/{test_zipfile.py => test_zipfile/test_core.py} (72%)
 rename Lib/{zipfile.py => zipfile/__init__.py} (85%)
 create mode 100644 Lib/zipfile/__main__.py
 create mode 100644 Lib/zipfile/_path/__init__.py
 create mode 100644 Lib/zipfile/_path/glob.py

diff --git a/Lib/test/archiver_tests.py b/Lib/test/archiver_tests.py
new file mode 100644
index 00000000000..24745941b08
--- /dev/null
+++ b/Lib/test/archiver_tests.py
@@ -0,0 +1,177 @@
+"""Tests common to tarfile and zipfile."""
+
+import os
+import sys
+
+from test.support import swap_attr
+from test.support import os_helper
+
+class OverwriteTests:
+
+    def setUp(self):
+        os.makedirs(self.testdir)
+        self.addCleanup(os_helper.rmtree, self.testdir)
+
+    def create_file(self, path, content=b''):
+        with open(path, 'wb') as f:
+            f.write(content)
+
+    def open(self, path):
+        raise NotImplementedError
+
+    def extractall(self, ar):
+        raise NotImplementedError
+
+
+    def test_overwrite_file_as_file(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    def test_overwrite_dir_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_overwrite_dir_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+        self.assertTrue(os.path.isfile(os.path.join(target, 'file')))
+        with open(os.path.join(target, 'file'), 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    def test_overwrite_dir_as_file(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_file) as ar:
+            with self.assertRaises(PermissionError if sys.platform == 'win32'
+                                   else IsADirectoryError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_overwrite_file_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'content')
+
+    def test_overwrite_file_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_implicit_dir) as ar:
+            with self.assertRaises(FileNotFoundError if sys.platform == 'win32'
+                                   else NotADirectoryError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'content')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_file_symlink_as_file(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        self.create_file(target2, b'content')
+        os.symlink('test2', target)
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isfile(target2))
+        with open(target2, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_file_symlink_as_file(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target)
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isfile(target2))
+        with open(target2, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_dir_symlink_as_dir(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.mkdir(target2)
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isdir(target2))
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_dir_symlink_as_implicit_dir(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.mkdir(target2)
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isdir(target2))
+        self.assertTrue(os.path.isfile(os.path.join(target2, 'file')))
+        with open(os.path.join(target2, 'file'), 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_dir_symlink_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertFalse(os.path.exists(target2))
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_dir_symlink_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertFalse(os.path.exists(target2))
+
+    def test_concurrent_extract_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        def concurrent_mkdir(*args, **kwargs):
+            orig_mkdir(*args, **kwargs)
+            orig_mkdir(*args, **kwargs)
+        with swap_attr(os, 'mkdir', concurrent_mkdir) as orig_mkdir:
+            with self.open(self.ar_with_dir) as ar:
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_concurrent_extract_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        def concurrent_mkdir(*args, **kwargs):
+            orig_mkdir(*args, **kwargs)
+            orig_mkdir(*args, **kwargs)
+        with swap_attr(os, 'mkdir', concurrent_mkdir) as orig_mkdir:
+            with self.open(self.ar_with_implicit_dir) as ar:
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+        self.assertTrue(os.path.isfile(os.path.join(target, 'file')))
diff --git a/Lib/test/test_zipfile/__init__.py b/Lib/test/test_zipfile/__init__.py
new file mode 100644
index 00000000000..4b16ecc3115
--- /dev/null
+++ b/Lib/test/test_zipfile/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_zipfile/__main__.py b/Lib/test/test_zipfile/__main__.py
new file mode 100644
index 00000000000..e25ac946edf
--- /dev/null
+++ b/Lib/test/test_zipfile/__main__.py
@@ -0,0 +1,7 @@
+import unittest
+
+from . import load_tests  # noqa: F401
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_zipfile/_path/__init__.py b/Lib/test/test_zipfile/_path/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/Lib/test/test_zipfile/_path/_functools.py b/Lib/test/test_zipfile/_path/_functools.py
new file mode 100644
index 00000000000..75f2b20e06d
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_functools.py
@@ -0,0 +1,9 @@
+import functools
+
+
+# from jaraco.functools 3.5.2
+def compose(*funcs):
+    def compose_two(f1, f2):
+        return lambda *args, **kwargs: f1(f2(*args, **kwargs))
+
+    return functools.reduce(compose_two, funcs)
diff --git a/Lib/test/test_zipfile/_path/_itertools.py b/Lib/test/test_zipfile/_path/_itertools.py
new file mode 100644
index 00000000000..f735dd21733
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_itertools.py
@@ -0,0 +1,79 @@
+import itertools
+from collections import deque
+from itertools import islice
+
+
+# from jaraco.itertools 6.3.0
+class Counter:
+    """
+    Wrap an iterable in an object that stores the count of items
+    that pass through it.
+
+    >>> items = Counter(range(20))
+    >>> items.count
+    0
+    >>> values = list(items)
+    >>> items.count
+    20
+    """
+
+    def __init__(self, i):
+        self.count = 0
+        self.iter = zip(itertools.count(1), i)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        self.count, result = next(self.iter)
+        return result
+
+
+# from more_itertools v8.13.0
+def always_iterable(obj, base_type=(str, bytes)):
+    if obj is None:
+        return iter(())
+
+    if (base_type is not None) and isinstance(obj, base_type):
+        return iter((obj,))
+
+    try:
+        return iter(obj)
+    except TypeError:
+        return iter((obj,))
+
+
+# from more_itertools v9.0.0
+def consume(iterator, n=None):
+    """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
+    entirely.
+    Efficiently exhausts an iterator without returning values. Defaults to
+    consuming the whole iterator, but an optional second argument may be
+    provided to limit consumption.
+        >>> i = (x for x in range(10))
+        >>> next(i)
+        0
+        >>> consume(i, 3)
+        >>> next(i)
+        4
+        >>> consume(i)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+    If the iterator has fewer items remaining than the provided limit, the
+    whole iterator will be consumed.
+        >>> i = (x for x in range(3))
+        >>> consume(i, 5)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+    """
+    # Use functions that consume iterators at C speed.
+    if n is None:
+        # feed the entire iterator into a zero-length deque
+        deque(iterator, maxlen=0)
+    else:
+        # advance to the empty slice starting at position n
+        next(islice(iterator, n, n), None)
diff --git a/Lib/test/test_zipfile/_path/_support.py b/Lib/test/test_zipfile/_path/_support.py
new file mode 100644
index 00000000000..1afdf3b3a77
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_support.py
@@ -0,0 +1,9 @@
+import importlib
+import unittest
+
+
+def import_or_skip(name):
+    try:
+        return importlib.import_module(name)
+    except ImportError:  # pragma: no cover
+        raise unittest.SkipTest(f'Unable to import {name}')
diff --git a/Lib/test/test_zipfile/_path/_test_params.py b/Lib/test/test_zipfile/_path/_test_params.py
new file mode 100644
index 00000000000..00a9eaf2f99
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_test_params.py
@@ -0,0 +1,39 @@
+import functools
+import types
+
+from ._itertools import always_iterable
+
+
+def parameterize(names, value_groups):
+    """
+    Decorate a test method to run it as a set of subtests.
+
+    Modeled after pytest.parametrize.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped(self):
+            for values in value_groups:
+                resolved = map(Invoked.eval, always_iterable(values))
+                params = dict(zip(always_iterable(names), resolved))
+                with self.subTest(**params):
+                    func(self, **params)
+
+        return wrapped
+
+    return decorator
+
+
+class Invoked(types.SimpleNamespace):
+    """
+    Wrap a function to be invoked for each usage.
+    """
+
+    @classmethod
+    def wrap(cls, func):
+        return cls(func=func)
+
+    @classmethod
+    def eval(cls, cand):
+        return cand.func() if isinstance(cand, cls) else cand
diff --git a/Lib/test/test_zipfile/_path/test_complexity.py b/Lib/test/test_zipfile/_path/test_complexity.py
new file mode 100644
index 00000000000..7c108fc6ab8
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/test_complexity.py
@@ -0,0 +1,105 @@
+import io
+import itertools
+import math
+import re
+import string
+import unittest
+import zipfile
+
+from ._functools import compose
+from ._itertools import consume
+from ._support import import_or_skip
+
+big_o = import_or_skip('big_o')
+pytest = import_or_skip('pytest')
+
+
+class TestComplexity(unittest.TestCase):
+    @pytest.mark.flaky
+    def test_implied_dirs_performance(self):
+        best, others = big_o.big_o(
+            compose(consume, zipfile._path.CompleteDirs._implied_dirs),
+            lambda size: [
+                '/'.join(string.ascii_lowercase + str(n)) for n in range(size)
+            ],
+            max_n=1000,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    def make_zip_path(self, depth=1, width=1) -> zipfile.Path:
+        """
+        Construct a Path with width files at every level of depth.
+        """
+        zf = zipfile.ZipFile(io.BytesIO(), mode='w')
+        pairs = itertools.product(self.make_deep_paths(depth), self.make_names(width))
+        for path, name in pairs:
+            zf.writestr(f"{path}{name}.txt", b'')
+        zf.filename = "big un.zip"
+        return zipfile.Path(zf)
+
+    @classmethod
+    def make_names(cls, width, letters=string.ascii_lowercase):
+        """
+        >>> list(TestComplexity.make_names(1))
+        ['a']
+        >>> list(TestComplexity.make_names(2))
+        ['a', 'b']
+        >>> list(TestComplexity.make_names(30))
+        ['aa', 'ab', ..., 'bd']
+        >>> list(TestComplexity.make_names(17124))
+        ['aaa', 'aab', ..., 'zip']
+        """
+        # determine how many products are needed to produce width
+        n_products = max(1, math.ceil(math.log(width, len(letters))))
+        inputs = (letters,) * n_products
+        combinations = itertools.product(*inputs)
+        names = map(''.join, combinations)
+        return itertools.islice(names, width)
+
+    @classmethod
+    def make_deep_paths(cls, depth):
+        return map(cls.make_deep_path, range(depth))
+
+    @classmethod
+    def make_deep_path(cls, depth):
+        return ''.join(('d/',) * depth)
+
+    def test_baseline_regex_complexity(self):
+        best, others = big_o.big_o(
+            lambda path: re.fullmatch(r'[^/]*\\.txt', path),
+            self.make_deep_path,
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Constant
+
+    @pytest.mark.flaky
+    def test_glob_depth(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            self.make_zip_path,
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    @pytest.mark.flaky
+    def test_glob_width(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            lambda size: self.make_zip_path(width=size),
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    @pytest.mark.flaky
+    def test_glob_width_and_depth(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            lambda size: self.make_zip_path(depth=size, width=size),
+            max_n=10,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
diff --git a/Lib/test/test_zipfile/_path/test_path.py b/Lib/test/test_zipfile/_path/test_path.py
new file mode 100644
index 00000000000..2d1c06cd968
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/test_path.py
@@ -0,0 +1,687 @@
+import contextlib
+import io
+import itertools
+import pathlib
+import pickle
+import stat
+import sys
+import time
+import unittest
+import zipfile
+import zipfile._path
+
+from test.support.os_helper import FakePath, temp_dir
+
+from ._functools import compose
+from ._itertools import Counter
+from ._test_params import Invoked, parameterize
+
+
+class jaraco:
+    class itertools:
+        Counter = Counter
+
+
+def _make_link(info: zipfile.ZipInfo):  # type: ignore[name-defined]
+    info.external_attr |= stat.S_IFLNK << 16
+
+
+def build_alpharep_fixture():
+    """
+    Create a zip file with this structure:
+
+    .
+    ├── a.txt
+    ├── n.txt (-> a.txt)
+    ├── b
+    │   ├── c.txt
+    │   ├── d
+    │   │   └── e.txt
+    │   └── f.txt
+    ├── g
+    │   └── h
+    │       └── i.txt
+    └── j
+        ├── k.bin
+        ├── l.baz
+        └── m.bar
+
+    This fixture has the following key characteristics:
+
+    - a file at the root (a)
+    - a file two levels deep (b/d/e)
+    - multiple files in a directory (b/c, b/f)
+    - a directory containing only a directory (g/h)
+    - a directory with files of different extensions (j/klm)
+    - a symlink (n) pointing to (a)
+
+    "alpha" because it uses alphabet
+    "rep" because it's a representative example
+    """
+    data = io.BytesIO()
+    zf = zipfile.ZipFile(data, "w")
+    zf.writestr("a.txt", b"content of a")
+    zf.writestr("b/c.txt", b"content of c")
+    zf.writestr("b/d/e.txt", b"content of e")
+    zf.writestr("b/f.txt", b"content of f")
+    zf.writestr("g/h/i.txt", b"content of i")
+    zf.writestr("j/k.bin", b"content of k")
+    zf.writestr("j/l.baz", b"content of l")
+    zf.writestr("j/m.bar", b"content of m")
+    zf.writestr("n.txt", b"a.txt")
+    _make_link(zf.infolist()[-1])
+
+    zf.filename = "alpharep.zip"
+    return zf
+
+
+alpharep_generators = [
+    Invoked.wrap(build_alpharep_fixture),
+    Invoked.wrap(compose(zipfile._path.CompleteDirs.inject, build_alpharep_fixture)),
+]
+
+pass_alpharep = parameterize(['alpharep'], alpharep_generators)
+
+
+class TestPath(unittest.TestCase):
+    def setUp(self):
+        self.fixtures = contextlib.ExitStack()
+        self.addCleanup(self.fixtures.close)
+
+    def zipfile_ondisk(self, alpharep):
+        tmpdir = pathlib.Path(self.fixtures.enter_context(temp_dir()))
+        buffer = alpharep.fp
+        alpharep.close()
+        path = tmpdir / alpharep.filename
+        with path.open("wb") as strm:
+            strm.write(buffer.getvalue())
+        return path
+
+    @pass_alpharep
+    def test_iterdir_and_types(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.is_dir()
+        a, n, b, g, j = root.iterdir()
+        assert a.is_file()
+        assert b.is_dir()
+        assert g.is_dir()
+        c, f, d = b.iterdir()
+        assert c.is_file() and f.is_file()
+        (e,) = d.iterdir()
+        assert e.is_file()
+        (h,) = g.iterdir()
+        (i,) = h.iterdir()
+        assert i.is_file()
+
+    @pass_alpharep
+    def test_is_file_missing(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.joinpath('missing.txt').is_file()
+
+    @pass_alpharep
+    def test_iterdir_on_file(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        with self.assertRaises(ValueError):
+            a.iterdir()
+
+    @pass_alpharep
+    def test_subdir_is_dir(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'b').is_dir()
+        assert (root / 'b/').is_dir()
+        assert (root / 'g').is_dir()
+        assert (root / 'g/').is_dir()
+
+    @pass_alpharep
+    def test_open(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        with a.open(encoding="utf-8") as strm:
+            data = strm.read()
+        self.assertEqual(data, "content of a")
+        with a.open('r', "utf-8") as strm:  # not a kw, no gh-101144 TypeError
+            data = strm.read()
+        self.assertEqual(data, "content of a")
+
+    def test_open_encoding_utf16(self):
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.writestr("path/16.txt", "This was utf-16".encode("utf-16"))
+        zf.filename = "test_open_utf16.zip"
+        root = zipfile.Path(zf)
+        (path,) = root.iterdir()
+        u16 = path.joinpath("16.txt")
+        with u16.open('r', "utf-16") as strm:
+            data = strm.read()
+        assert data == "This was utf-16"
+        with u16.open(encoding="utf-16") as strm:
+            data = strm.read()
+        assert data == "This was utf-16"
+
+    def test_open_encoding_errors(self):
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.writestr("path/bad-utf8.bin", b"invalid utf-8: \xff\xff.")
+        zf.filename = "test_read_text_encoding_errors.zip"
+        root = zipfile.Path(zf)
+        (path,) = root.iterdir()
+        u16 = path.joinpath("bad-utf8.bin")
+
+        # encoding= as a positional argument for gh-101144.
+        data = u16.read_text("utf-8", errors="ignore")
+        assert data == "invalid utf-8: ."
+        with u16.open("r", "utf-8", errors="surrogateescape") as f:
+            assert f.read() == "invalid utf-8: \udcff\udcff."
+
+        # encoding= both positional and keyword is an error; gh-101144.
+        with self.assertRaisesRegex(TypeError, "encoding"):
+            data = u16.read_text("utf-8", encoding="utf-8")
+
+        # both keyword arguments work.
+        with u16.open("r", encoding="utf-8", errors="strict") as f:
+            # error during decoding with wrong codec.
+            with self.assertRaises(UnicodeDecodeError):
+                f.read()
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    @pass_alpharep
+    def test_encoding_warnings(self, alpharep):
+        """EncodingWarning must blame the read_text and open calls."""
+        assert sys.flags.warn_default_encoding
+        root = zipfile.Path(alpharep)
+        with self.assertWarns(EncodingWarning) as wc:  # noqa: F821 (astral-sh/ruff#13296)
+            root.joinpath("a.txt").read_text()
+        assert __file__ == wc.filename
+        with self.assertWarns(EncodingWarning) as wc:  # noqa: F821 (astral-sh/ruff#13296)
+            root.joinpath("a.txt").open("r").close()
+        assert __file__ == wc.filename
+
+    def test_open_write(self):
+        """
+        If the zipfile is open for write, it should be possible to
+        write bytes or text to it.
+        """
+        zf = zipfile.Path(zipfile.ZipFile(io.BytesIO(), mode='w'))
+        with zf.joinpath('file.bin').open('wb') as strm:
+            strm.write(b'binary contents')
+        with zf.joinpath('file.txt').open('w', encoding="utf-8") as strm:
+            strm.write('text file')
+
+    @pass_alpharep
+    def test_open_extant_directory(self, alpharep):
+        """
+        Attempting to open a directory raises IsADirectoryError.
+        """
+        zf = zipfile.Path(alpharep)
+        with self.assertRaises(IsADirectoryError):
+            zf.joinpath('b').open()
+
+    @pass_alpharep
+    def test_open_binary_invalid_args(self, alpharep):
+        root = zipfile.Path(alpharep)
+        with self.assertRaises(ValueError):
+            root.joinpath('a.txt').open('rb', encoding='utf-8')
+        with self.assertRaises(ValueError):
+            root.joinpath('a.txt').open('rb', 'utf-8')
+
+    @pass_alpharep
+    def test_open_missing_directory(self, alpharep):
+        """
+        Attempting to open a missing directory raises FileNotFoundError.
+        """
+        zf = zipfile.Path(alpharep)
+        with self.assertRaises(FileNotFoundError):
+            zf.joinpath('z').open()
+
+    @pass_alpharep
+    def test_read(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        assert a.read_text(encoding="utf-8") == "content of a"
+        # Also check positional encoding arg (gh-101144).
+        assert a.read_text("utf-8") == "content of a"
+        assert a.read_bytes() == b"content of a"
+
+    @pass_alpharep
+    def test_joinpath(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a = root.joinpath("a.txt")
+        assert a.is_file()
+        e = root.joinpath("b").joinpath("d").joinpath("e.txt")
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_joinpath_multiple(self, alpharep):
+        root = zipfile.Path(alpharep)
+        e = root.joinpath("b", "d", "e.txt")
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_traverse_truediv(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a = root / "a.txt"
+        assert a.is_file()
+        e = root / "b" / "d" / "e.txt"
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_pathlike_construction(self, alpharep):
+        """
+        zipfile.Path should be constructable from a path-like object
+        """
+        zipfile_ondisk = self.zipfile_ondisk(alpharep)
+        pathlike = FakePath(str(zipfile_ondisk))
+        zipfile.Path(pathlike)
+
+    @pass_alpharep
+    def test_traverse_pathlike(self, alpharep):
+        root = zipfile.Path(alpharep)
+        root / FakePath("a")
+
+    @pass_alpharep
+    def test_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'a').parent.at == ''
+        assert (root / 'a' / 'b').parent.at == 'a/'
+
+    @pass_alpharep
+    def test_dir_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'b').parent.at == ''
+        assert (root / 'b/').parent.at == ''
+
+    @pass_alpharep
+    def test_missing_dir_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'missing dir/').parent.at == ''
+
+    @pass_alpharep
+    def test_mutability(self, alpharep):
+        """
+        If the underlying zipfile is changed, the Path object should
+        reflect that change.
+        """
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        alpharep.writestr('foo.txt', 'foo')
+        alpharep.writestr('bar/baz.txt', 'baz')
+        assert any(child.name == 'foo.txt' for child in root.iterdir())
+        assert (root / 'foo.txt').read_text(encoding="utf-8") == 'foo'
+        (baz,) = (root / 'bar').iterdir()
+        assert baz.read_text(encoding="utf-8") == 'baz'
+
+    HUGE_ZIPFILE_NUM_ENTRIES = 2**13
+
+    def huge_zipfile(self):
+        """Create a read-only zipfile with a huge number of entries entries."""
+        strm = io.BytesIO()
+        zf = zipfile.ZipFile(strm, "w")
+        for entry in map(str, range(self.HUGE_ZIPFILE_NUM_ENTRIES)):
+            zf.writestr(entry, entry)
+        zf.mode = 'r'
+        return zf
+
+    def test_joinpath_constant_time(self):
+        """
+        Ensure joinpath on items in zipfile is linear time.
+        """
+        root = zipfile.Path(self.huge_zipfile())
+        entries = jaraco.itertools.Counter(root.iterdir())
+        for entry in entries:
+            entry.joinpath('suffix')
+        # Check the file iterated all items
+        assert entries.count == self.HUGE_ZIPFILE_NUM_ENTRIES
+
+    @pass_alpharep
+    def test_read_does_not_close(self, alpharep):
+        alpharep = self.zipfile_ondisk(alpharep)
+        with zipfile.ZipFile(alpharep) as file:
+            for rep in range(2):
+                zipfile.Path(file, 'a.txt').read_text(encoding="utf-8")
+
+    @pass_alpharep
+    def test_subclass(self, alpharep):
+        class Subclass(zipfile.Path):
+            pass
+
+        root = Subclass(alpharep)
+        assert isinstance(root / 'b', Subclass)
+
+    @pass_alpharep
+    def test_filename(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.filename == pathlib.Path('alpharep.zip')
+
+    @pass_alpharep
+    def test_root_name(self, alpharep):
+        """
+        The name of the root should be the name of the zipfile
+        """
+        root = zipfile.Path(alpharep)
+        assert root.name == 'alpharep.zip' == root.filename.name
+
+    @pass_alpharep
+    def test_root_on_disk(self, alpharep):
+        """
+        The name/stem of the root should match the zipfile on disk.
+
+        This condition must hold across platforms.
+        """
+        root = zipfile.Path(self.zipfile_ondisk(alpharep))
+        assert root.name == 'alpharep.zip' == root.filename.name
+        assert root.stem == 'alpharep' == root.filename.stem
+
+    @pass_alpharep
+    def test_suffix(self, alpharep):
+        """
+        The suffix of the root should be the suffix of the zipfile.
+        The suffix of each nested file is the final component's last suffix, if any.
+        Includes the leading period, just like pathlib.Path.
+        """
+        root = zipfile.Path(alpharep)
+        assert root.suffix == '.zip' == root.filename.suffix
+
+        b = root / "b.txt"
+        assert b.suffix == ".txt"
+
+        c = root / "c" / "filename.tar.gz"
+        assert c.suffix == ".gz"
+
+        d = root / "d"
+        assert d.suffix == ""
+
+    @pass_alpharep
+    def test_suffixes(self, alpharep):
+        """
+        The suffix of the root should be the suffix of the zipfile.
+        The suffix of each nested file is the final component's last suffix, if any.
+        Includes the leading period, just like pathlib.Path.
+        """
+        root = zipfile.Path(alpharep)
+        assert root.suffixes == ['.zip'] == root.filename.suffixes
+
+        b = root / 'b.txt'
+        assert b.suffixes == ['.txt']
+
+        c = root / 'c' / 'filename.tar.gz'
+        assert c.suffixes == ['.tar', '.gz']
+
+        d = root / 'd'
+        assert d.suffixes == []
+
+        e = root / '.hgrc'
+        assert e.suffixes == []
+
+    @pass_alpharep
+    def test_suffix_no_filename(self, alpharep):
+        alpharep.filename = None
+        root = zipfile.Path(alpharep)
+        assert root.joinpath('example').suffix == ""
+        assert root.joinpath('example').suffixes == []
+
+    @pass_alpharep
+    def test_stem(self, alpharep):
+        """
+        The final path component, without its suffix
+        """
+        root = zipfile.Path(alpharep)
+        assert root.stem == 'alpharep' == root.filename.stem
+
+        b = root / "b.txt"
+        assert b.stem == "b"
+
+        c = root / "c" / "filename.tar.gz"
+        assert c.stem == "filename.tar"
+
+        d = root / "d"
+        assert d.stem == "d"
+
+        assert (root / ".gitignore").stem == ".gitignore"
+
+    @pass_alpharep
+    def test_root_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.parent == pathlib.Path('.')
+        root.root.filename = 'foo/bar.zip'
+        assert root.parent == pathlib.Path('foo')
+
+    @pass_alpharep
+    def test_root_unnamed(self, alpharep):
+        """
+        It is an error to attempt to get the name
+        or parent of an unnamed zipfile.
+        """
+        alpharep.filename = None
+        root = zipfile.Path(alpharep)
+        with self.assertRaises(TypeError):
+            root.name
+        with self.assertRaises(TypeError):
+            root.parent
+
+        # .name and .parent should still work on subs
+        sub = root / "b"
+        assert sub.name == "b"
+        assert sub.parent
+
+    @pass_alpharep
+    def test_match_and_glob(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.match("*.txt")
+
+        assert list(root.glob("b/c.*")) == [zipfile.Path(alpharep, "b/c.txt")]
+        assert list(root.glob("b/*.txt")) == [
+            zipfile.Path(alpharep, "b/c.txt"),
+            zipfile.Path(alpharep, "b/f.txt"),
+        ]
+
+    @pass_alpharep
+    def test_glob_recursive(self, alpharep):
+        root = zipfile.Path(alpharep)
+        files = root.glob("**/*.txt")
+        assert all(each.match("*.txt") for each in files)
+
+        assert list(root.glob("**/*.txt")) == list(root.rglob("*.txt"))
+
+    @pass_alpharep
+    def test_glob_dirs(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert list(root.glob('b')) == [zipfile.Path(alpharep, "b/")]
+        assert list(root.glob('b*')) == [zipfile.Path(alpharep, "b/")]
+
+    @pass_alpharep
+    def test_glob_subdir(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert list(root.glob('g/h')) == [zipfile.Path(alpharep, "g/h/")]
+        assert list(root.glob('g*/h*')) == [zipfile.Path(alpharep, "g/h/")]
+
+    @pass_alpharep
+    def test_glob_subdirs(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("*/i.txt")) == []
+        assert list(root.rglob("*/i.txt")) == [zipfile.Path(alpharep, "g/h/i.txt")]
+
+    @pass_alpharep
+    def test_glob_does_not_overmatch_dot(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("*.xt")) == []
+
+    @pass_alpharep
+    def test_glob_single_char(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("a?txt")) == [zipfile.Path(alpharep, "a.txt")]
+        assert list(root.glob("a[.]txt")) == [zipfile.Path(alpharep, "a.txt")]
+        assert list(root.glob("a[?]txt")) == []
+
+    @pass_alpharep
+    def test_glob_chars(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("j/?.b[ai][nz]")) == [
+            zipfile.Path(alpharep, "j/k.bin"),
+            zipfile.Path(alpharep, "j/l.baz"),
+        ]
+
+    def test_glob_empty(self):
+        root = zipfile.Path(zipfile.ZipFile(io.BytesIO(), 'w'))
+        with self.assertRaises(ValueError):
+            root.glob('')
+
+    @pass_alpharep
+    def test_eq_hash(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root == zipfile.Path(alpharep)
+
+        assert root != (root / "a.txt")
+        assert (root / "a.txt") == (root / "a.txt")
+
+        root = zipfile.Path(alpharep)
+        assert root in {root}
+
+    @pass_alpharep
+    def test_is_symlink(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.joinpath('a.txt').is_symlink()
+        assert root.joinpath('n.txt').is_symlink()
+
+    @pass_alpharep
+    def test_relative_to(self, alpharep):
+        root = zipfile.Path(alpharep)
+        relative = root.joinpath("b", "c.txt").relative_to(root / "b")
+        assert str(relative) == "c.txt"
+
+        relative = root.joinpath("b", "d", "e.txt").relative_to(root / "b")
+        assert str(relative) == "d/e.txt"
+
+    @pass_alpharep
+    def test_inheritance(self, alpharep):
+        cls = type('PathChild', (zipfile.Path,), {})
+        file = cls(alpharep).joinpath('some dir').parent
+        assert isinstance(file, cls)
+
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON, fails on Windows")
+    @parameterize(
+        ['alpharep', 'path_type', 'subpath'],
+        itertools.product(
+            alpharep_generators,
+            [str, FakePath],
+            ['', 'b/'],
+        ),
+    )
+    def test_pickle(self, alpharep, path_type, subpath):
+        zipfile_ondisk = path_type(str(self.zipfile_ondisk(alpharep)))
+
+        saved_1 = pickle.dumps(zipfile.Path(zipfile_ondisk, at=subpath))
+        restored_1 = pickle.loads(saved_1)
+        first, *rest = restored_1.iterdir()
+        assert first.read_text(encoding='utf-8').startswith('content of ')
+
+    @pass_alpharep
+    def test_extract_orig_with_implied_dirs(self, alpharep):
+        """
+        A zip file wrapped in a Path should extract even with implied dirs.
+        """
+        source_path = self.zipfile_ondisk(alpharep)
+        zf = zipfile.ZipFile(source_path)
+        # wrap the zipfile for its side effect
+        zipfile.Path(zf)
+        zf.extractall(source_path.parent)
+
+    @pass_alpharep
+    def test_getinfo_missing(self, alpharep):
+        """
+        Validate behavior of getinfo on original zipfile after wrapping.
+        """
+        zipfile.Path(alpharep)
+        with self.assertRaises(KeyError):
+            alpharep.getinfo('does-not-exist')
+
+    def test_malformed_paths(self):
+        """
+        Path should handle malformed paths gracefully.
+
+        Paths with leading slashes are not visible.
+
+        Paths with dots are treated like regular files.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr("/one-slash.txt", b"content")
+        zf.writestr("//two-slash.txt", b"content")
+        zf.writestr("../parent.txt", b"content")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        assert list(map(str, root.iterdir())) == ['../']
+        assert root.joinpath('..').joinpath('parent.txt').read_bytes() == b'content'
+
+    def test_unsupported_names(self):
+        """
+        Path segments with special characters are readable.
+
+        On some platforms or file systems, characters like
+        ``:`` and ``?`` are not allowed, but they are valid
+        in the zip file.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr("path?", b"content")
+        zf.writestr("V: NMS.flac", b"fLaC...")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        contents = root.iterdir()
+        assert next(contents).name == 'path?'
+        assert next(contents).name == 'V: NMS.flac'
+        assert root.joinpath('V: NMS.flac').read_bytes() == b"fLaC..."
+
+    def test_backslash_not_separator(self):
+        """
+        In a zip file, backslashes are not separators.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr(DirtyZipInfo.for_name("foo\\bar", zf), b"content")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        (first,) = root.iterdir()
+        assert not first.is_dir()
+        assert first.name == 'foo\\bar'
+
+    @pass_alpharep
+    def test_interface(self, alpharep):
+        from importlib.resources.abc import Traversable
+
+        zf = zipfile.Path(alpharep)
+        assert isinstance(zf, Traversable)
+
+
+class DirtyZipInfo(zipfile.ZipInfo):
+    """
+    Bypass name sanitization.
+    """
+
+    def __init__(self, filename, *args, **kwargs):
+        super().__init__(filename, *args, **kwargs)
+        self.filename = filename
+
+    @classmethod
+    def for_name(cls, name, archive):
+        """
+        Construct the same way that ZipFile.writestr does.
+
+        TODO: extract this functionality and re-use
+        """
+        self = cls(filename=name, date_time=time.localtime(time.time())[:6])
+        self.compress_type = archive.compression
+        self.compress_level = archive.compresslevel
+        if self.filename.endswith('/'):  # pragma: no cover
+            self.external_attr = 0o40775 << 16  # drwxrwxr-x
+            self.external_attr |= 0x10  # MS-DOS directory flag
+        else:
+            self.external_attr = 0o600 << 16  # ?rw-------
+        return self
diff --git a/Lib/test/test_zipfile/_path/write-alpharep.py b/Lib/test/test_zipfile/_path/write-alpharep.py
new file mode 100644
index 00000000000..7418391abad
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/write-alpharep.py
@@ -0,0 +1,3 @@
+from . import test_path
+
+__name__ == '__main__' and test_path.build_alpharep_fixture().extractall('alpharep')
diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile/test_core.py
similarity index 72%
rename from Lib/test/test_zipfile.py
rename to Lib/test/test_zipfile/test_core.py
index e7705590cd2..fa1feef00cd 100644
--- a/Lib/test/test_zipfile.py
+++ b/Lib/test/test_zipfile/test_core.py
@@ -1,12 +1,11 @@
+import _pyio
 import array
 import contextlib
 import importlib.util
 import io
 import itertools
 import os
-import pathlib
 import posixpath
-import string
 import struct
 import subprocess
 import sys
@@ -14,16 +13,20 @@
 import unittest
 import unittest.mock as mock
 import zipfile
-import functools
 
 
 from tempfile import TemporaryFile
 from random import randint, random, randbytes
 
+from test import archiver_tests
 from test.support import script_helper
-from test.support import (findfile, requires_zlib, requires_bz2,
-                          requires_lzma, captured_stdout)
-from test.support.os_helper import TESTFN, unlink, rmtree, temp_dir, temp_cwd
+from test.support import (
+    findfile, requires_zlib, requires_bz2, requires_lzma,
+    captured_stdout, captured_stderr, requires_subprocess
+)
+from test.support.os_helper import (
+    TESTFN, unlink, rmtree, temp_dir, temp_cwd, fd_count, FakePath
+)
 
 
 TESTFN2 = TESTFN + "2"
@@ -120,8 +123,9 @@ def zip_test(self, f, compression, compresslevel=None):
                 self.assertEqual(info.filename, nm)
                 self.assertEqual(info.file_size, len(self.data))
 
-            # Check that testzip doesn't raise an exception
-            zipfp.testzip()
+            # Check that testzip thinks the archive is ok
+            # (it returns None if all contents could be read properly)
+            self.assertIsNone(zipfp.testzip())
 
     def test_basic(self):
         for f in get_files(self):
@@ -156,7 +160,7 @@ def test_open(self):
             self.zip_open_test(f, self.compression)
 
     def test_open_with_pathlike(self):
-        path = pathlib.Path(TESTFN2)
+        path = FakePath(TESTFN2)
         self.zip_open_test(path, self.compression)
         with zipfile.ZipFile(path, "r", self.compression) as zipfp:
             self.assertIsInstance(zipfp.filename, str)
@@ -312,7 +316,7 @@ def test_writestr_compresslevel(self):
         # Compression level follows the constructor.
         a_info = zipfp.getinfo('a.txt')
         self.assertEqual(a_info.compress_type, self.compression)
-        self.assertEqual(a_info._compresslevel, 1)
+        self.assertEqual(a_info.compress_level, 1)
 
         # Compression level is overridden.
         b_info = zipfp.getinfo('b.txt')
@@ -386,7 +390,6 @@ def test_repr(self):
                 with zipfp.open(fname) as zipopen:
                     r = repr(zipopen)
                     self.assertIn('name=%r' % fname, r)
-                    self.assertIn("mode='r'", r)
                     if self.compression != zipfile.ZIP_STORED:
                         self.assertIn('compress_type=', r)
                 self.assertIn('[closed]', repr(zipopen))
@@ -405,7 +408,7 @@ def test_per_file_compresslevel(self):
             one_info = zipfp.getinfo('compress_1')
             nine_info = zipfp.getinfo('compress_9')
             self.assertEqual(one_info._compresslevel, 1)
-            self.assertEqual(nine_info._compresslevel, 9)
+            self.assertEqual(nine_info.compress_level, 9)
 
     def test_writing_errors(self):
         class BrokenFile(io.BytesIO):
@@ -443,6 +446,27 @@ def write(self, data):
             self.assertEqual(zipfp.read('file1'), b'data1')
             self.assertEqual(zipfp.read('file2'), b'data2')
 
+    def test_zipextfile_attrs(self):
+        fname = "somefile.txt"
+        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
+            zipfp.writestr(fname, "bogus")
+
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
+            with zipfp.open(fname) as fid:
+                self.assertEqual(fid.name, fname)
+                self.assertRaises(io.UnsupportedOperation, fid.fileno)
+                self.assertEqual(fid.mode, 'rb')
+                self.assertIs(fid.readable(), True)
+                self.assertIs(fid.writable(), False)
+                self.assertIs(fid.seekable(), True)
+                self.assertIs(fid.closed, False)
+            self.assertIs(fid.closed, True)
+            self.assertEqual(fid.name, fname)
+            self.assertEqual(fid.mode, 'rb')
+            self.assertRaises(io.UnsupportedOperation, fid.fileno)
+            self.assertRaises(ValueError, fid.readable)
+            self.assertIs(fid.writable(), False)
+            self.assertRaises(ValueError, fid.seekable)
 
     def tearDown(self):
         unlink(TESTFN)
@@ -574,17 +598,16 @@ def test_write_default_name(self):
 
     def test_io_on_closed_zipextfile(self):
         fname = "somefile.txt"
-        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
+        with zipfile.ZipFile(TESTFN2, mode="w", compression=self.compression) as zipfp:
             zipfp.writestr(fname, "bogus")
 
         with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
             with zipfp.open(fname) as fid:
                 fid.close()
+                self.assertIs(fid.closed, True)
                 self.assertRaises(ValueError, fid.read)
                 self.assertRaises(ValueError, fid.seek, 0)
                 self.assertRaises(ValueError, fid.tell)
-                self.assertRaises(ValueError, fid.readable)
-                self.assertRaises(ValueError, fid.seekable)
 
     def test_write_to_readonly(self):
         """Check that trying to call write() on a readonly ZipFile object
@@ -744,8 +767,8 @@ def zip_test(self, f, compression):
                 self.assertEqual(info.filename, nm)
                 self.assertEqual(info.file_size, len(self.data))
 
-            # Check that testzip doesn't raise an exception
-            zipfp.testzip()
+            # Check that testzip thinks the archive is valid
+            self.assertIsNone(zipfp.testzip())
 
     def test_basic(self):
         for f in get_files(self):
@@ -1077,6 +1100,159 @@ def test_generated_valid_zip64_extra(self):
                     self.assertEqual(zinfo.header_offset, expected_header_offset)
                     self.assertEqual(zf.read(zinfo), expected_content)
 
+    def test_force_zip64(self):
+        """Test that forcing zip64 extensions correctly notes this in the zip file"""
+
+        # GH-103861 describes an issue where forcing a small file to use zip64
+        # extensions would add a zip64 extra record, but not change the data
+        # sizes to 0xFFFFFFFF to indicate to the extractor that the zip64
+        # record should be read. Additionally, it would not set the required
+        # version to indicate that zip64 extensions are required to extract it.
+        # This test replicates the situation and reads the raw data to specifically ensure:
+        #  - The required extract version is always >= ZIP64_VERSION
+        #  - The compressed and uncompressed size in the file headers are both
+        #     0xFFFFFFFF (ie. point to zip64 record)
+        #  - The zip64 record is provided and has the correct sizes in it
+        # Other aspects of the zip are checked as well, but verifying the above is the main goal.
+        # Because this is hard to verify by parsing the data as a zip, the raw
+        # bytes are checked to ensure that they line up with the zip spec.
+        # The spec for this can be found at: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+        # The relevant sections for this test are:
+        #  - 4.3.7 for local file header
+        #  - 4.5.3 for zip64 extra field
+
+        data = io.BytesIO()
+        with zipfile.ZipFile(data, mode="w", allowZip64=True) as zf:
+            with zf.open("text.txt", mode="w", force_zip64=True) as zi:
+                zi.write(b"_")
+
+        zipdata = data.getvalue()
+
+        # pull out and check zip information
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize, cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQx4s", zipdata[:63])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual(flags, 0)  # no flags
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, 1)  # uncompressed size
+        self.assertEqual(ex_csize, 1)  # compressed size
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
+        z = zipfile.ZipFile(io.BytesIO(zipdata))
+        zinfos = z.infolist()
+        self.assertEqual(len(zinfos), 1)
+        self.assertGreaterEqual(zinfos[0].extract_version, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+
+    def test_unseekable_zip_unknown_filesize(self):
+        """Test that creating a zip with/without seeking will raise a RuntimeError if zip64 was required but not used"""
+
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=True) as zf:
+                with zf.open("text.txt", mode="w", force_zip64=False) as zi:
+                    zi.write(b"_" * (zipfile.ZIP64_LIMIT + 1))
+
+        self.assertRaises(RuntimeError, make_zip, io.BytesIO())
+        self.assertRaises(RuntimeError, make_zip, Unseekable(io.BytesIO()))
+
+    def test_zip64_required_not_allowed_fail(self):
+        """Test that trying to add a large file to a zip that doesn't allow zip64 extensions fails on add"""
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=False) as zf:
+                # pretend zipfile.ZipInfo.from_file was used to get the name and filesize
+                info = zipfile.ZipInfo("text.txt")
+                info.file_size = zipfile.ZIP64_LIMIT + 1
+                zf.open(info, mode="w")
+
+        self.assertRaises(zipfile.LargeZipFile, make_zip, io.BytesIO())
+        self.assertRaises(zipfile.LargeZipFile, make_zip, Unseekable(io.BytesIO()))
+
+    def test_unseekable_zip_known_filesize(self):
+        """Test that creating a zip without seeking will use zip64 extensions if the file size is provided up-front"""
+
+        # This test ensures that the zip will use a zip64 data descriptor (same
+        # as a regular data descriptor except the sizes are 8 bytes instead of
+        # 4) record to communicate the size of a file if the zip is being
+        # written to an unseekable stream.
+        # Because this sort of thing is hard to verify by parsing the data back
+        # in as a zip, this test looks at the raw bytes created to ensure that
+        # the correct data has been generated.
+        # The spec for this can be found at: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+        # The relevant sections for this test are:
+        #  - 4.3.7 for local file header
+        #  - 4.3.9 for the data descriptor
+        #  - 4.5.3 for zip64 extra field
+
+        file_size = zipfile.ZIP64_LIMIT + 1
+
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=True) as zf:
+                # pretend zipfile.ZipInfo.from_file was used to get the name and filesize
+                info = zipfile.ZipInfo("text.txt")
+                info.file_size = file_size
+                with zf.open(info, mode="w", force_zip64=False) as zi:
+                    zi.write(b"_" * file_size)
+            return fp
+
+        # check seekable file information
+        seekable_data = make_zip(io.BytesIO()).getvalue()
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize,
+            cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQ{}x4s".format(file_size), seekable_data[:62 + file_size])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual(flags, 0)  # no flags set
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, file_size)  # uncompressed size
+        self.assertEqual(ex_csize, file_size)  # compressed size
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
+        # check unseekable file information
+        unseekable_data = make_zip(Unseekable(io.BytesIO())).fp.getvalue()
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize,
+            dd_header, dd_usize, dd_csize, cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQ{}x4s4xQQ4s".format(file_size), unseekable_data[:86 + file_size])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual("{:b}".format(flags), "1000")  # streaming flag set
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, 0)  # uncompressed size - 0 to defer to data descriptor
+        self.assertEqual(ex_csize, 0)  # compressed size - 0 to defer to data descriptor
+        self.assertEqual(dd_header, b"PK\07\x08")  # data descriptor
+        self.assertEqual(dd_usize, file_size)  # file size (8 bytes because zip64)
+        self.assertEqual(dd_csize, file_size)  # compressed size (8 bytes because zip64)
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
 
 @requires_zlib()
 class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
@@ -1128,6 +1304,25 @@ def test_issue44439(self):
                 self.assertEqual(data.write(q), LENGTH)
             self.assertEqual(zip.getinfo('data').file_size, LENGTH)
 
+    def test_zipwritefile_attrs(self):
+        fname = "somefile.txt"
+        with zipfile.ZipFile(TESTFN2, mode="w", compression=self.compression) as zipfp:
+            with zipfp.open(fname, 'w') as fid:
+                self.assertEqual(fid.name, fname)
+                self.assertRaises(io.UnsupportedOperation, fid.fileno)
+                self.assertEqual(fid.mode, 'wb')
+                self.assertIs(fid.readable(), False)
+                self.assertIs(fid.writable(), True)
+                self.assertIs(fid.seekable(), False)
+                self.assertIs(fid.closed, False)
+            self.assertIs(fid.closed, True)
+            self.assertEqual(fid.name, fname)
+            self.assertEqual(fid.mode, 'wb')
+            self.assertRaises(io.UnsupportedOperation, fid.fileno)
+            self.assertIs(fid.readable(), False)
+            self.assertIs(fid.writable(), True)
+            self.assertIs(fid.seekable(), False)
+
 class StoredWriterTests(AbstractWriterTests, unittest.TestCase):
     compression = zipfile.ZIP_STORED
 
@@ -1210,7 +1405,7 @@ def test_write_python_package(self):
             self.assertCompiledIn('email/__init__.py', names)
             self.assertCompiledIn('email/mime/text.py', names)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - AttributeError: module 'os' has no attribute 'supports_effective_ids'
     @unittest.expectedFailure
     def test_write_filtered_python_package(self):
         import test
@@ -1338,7 +1533,7 @@ def test_write_pathlike(self):
                 fp.write("print(42)\n")
 
             with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-                zipfp.writepy(pathlib.Path(TESTFN2) / "mod1.py")
+                zipfp.writepy(FakePath(os.path.join(TESTFN2, "mod1.py")))
                 names = zipfp.namelist()
                 self.assertCompiledIn('mod1.py', names)
         finally:
@@ -1396,7 +1591,7 @@ def test_extract_with_target(self):
 
     def test_extract_with_target_pathlike(self):
         with temp_dir() as extdir:
-            self._test_extract_with_target(pathlib.Path(extdir))
+            self._test_extract_with_target(FakePath(extdir))
 
     def test_extract_all(self):
         with temp_cwd():
@@ -1431,7 +1626,7 @@ def test_extract_all_with_target(self):
 
     def test_extract_all_with_target_pathlike(self):
         with temp_dir() as extdir:
-            self._test_extract_all_with_target(pathlib.Path(extdir))
+            self._test_extract_all_with_target(FakePath(extdir))
 
     def check_file(self, filename, content):
         self.assertTrue(os.path.isfile(filename))
@@ -1444,6 +1639,8 @@ def test_sanitize_windows_name(self):
         self.assertEqual(san(r',,?,C:,foo,bar/z', ','), r'_,C_,foo,bar/z')
         self.assertEqual(san(r'a\b,c<d>e|f"g?h*i', ','), r'a\b,c_d_e_f_g_h_i')
         self.assertEqual(san('../../foo../../ba..r', '/'), r'foo/ba..r')
+        self.assertEqual(san('  /  /foo  /  /ba  r', '/'), r'foo/ba  r')
+        self.assertEqual(san(' . /. /foo ./ . /. ./ba .r', '/'), r'foo/ba .r')
 
     def test_extract_hackers_arcnames_common_cases(self):
         common_hacknames = [
@@ -1458,8 +1655,6 @@ def test_extract_hackers_arcnames_common_cases(self):
         ]
         self._test_extract_hackers_arcnames(common_hacknames)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(os.path.sep != '\\', 'Requires \\ as path separator.')
     def test_extract_hackers_arcnames_windows_only(self):
         """Test combination of path fixing and windows name sanitization."""
@@ -1474,10 +1669,10 @@ def test_extract_hackers_arcnames_windows_only(self):
             (r'C:\foo\bar', 'foo/bar'),
             (r'//conky/mountpoint/foo/bar', 'foo/bar'),
             (r'\\conky\mountpoint\foo\bar', 'foo/bar'),
-            (r'///conky/mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\\conky\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
-            (r'//conky//mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\conky\\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
+            (r'///conky/mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\\conky\mountpoint\foo\bar', 'mountpoint/foo/bar'),
+            (r'//conky//mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\conky\\mountpoint\foo\bar', 'mountpoint/foo/bar'),
             (r'//?/C:/foo/bar', 'foo/bar'),
             (r'\\?\C:\foo\bar', 'foo/bar'),
             (r'C:/../C:/foo/bar', 'C_/foo/bar'),
@@ -1539,6 +1734,33 @@ def _test_extract_hackers_arcnames(self, hacknames):
             unlink(TESTFN2)
 
 
+class OverwriteTests(archiver_tests.OverwriteTests, unittest.TestCase):
+    testdir = TESTFN
+
+    @classmethod
+    def setUpClass(cls):
+        p = cls.ar_with_file = TESTFN + '-with-file.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.writestr('test', b'newcontent')
+
+        p = cls.ar_with_dir = TESTFN + '-with-dir.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.mkdir('test')
+
+        p = cls.ar_with_implicit_dir = TESTFN + '-with-implicit-dir.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.writestr('test/file', b'newcontent')
+
+    def open(self, path):
+        return zipfile.ZipFile(path, 'r')
+
+    def extractall(self, ar):
+        ar.extractall(self.testdir)
+
+
 class OtherTests(unittest.TestCase):
     def test_open_via_zip_info(self):
         # Create the ZIP archive
@@ -1564,7 +1786,7 @@ def test_writestr_extended_local_header_issue1202(self):
         with zipfile.ZipFile(TESTFN2, 'w') as orig_zip:
             for data in 'abcdefghijklmnop':
                 zinfo = zipfile.ZipInfo(data)
-                zinfo.flag_bits |= 0x08  # Include an extended local header.
+                zinfo.flag_bits |= zipfile._MASK_USE_DATA_DESCRIPTOR  # Include an extended local header.
                 orig_zip.writestr(zinfo, data)
 
     def test_close(self):
@@ -1606,7 +1828,7 @@ def test_unsupported_version(self):
     @requires_zlib()
     def test_read_unicode_filenames(self):
         # bug #10801
-        fname = findfile('zip_cp437_header.zip')
+        fname = findfile('zip_cp437_header.zip', subdir='archivetestdata')
         with zipfile.ZipFile(fname) as zipfp:
             for name in zipfp.namelist():
                 zipfp.open(name).close()
@@ -1621,6 +1843,44 @@ def test_write_unicode_filenames(self):
             self.assertEqual(zf.filelist[0].filename, "foo.txt")
             self.assertEqual(zf.filelist[1].filename, "\xf6.txt")
 
+    def create_zipfile_with_extra_data(self, filename, extra_data_name):
+        with zipfile.ZipFile(TESTFN, mode='w') as zf:
+            filename_encoded = filename.encode("utf-8")
+            # create a ZipInfo object with Unicode path extra field
+            zip_info = zipfile.ZipInfo(filename)
+
+            tag_for_unicode_path = b'\x75\x70'
+            version_of_unicode_path = b'\x01'
+
+            import zlib
+            filename_crc = struct.pack('<L', zlib.crc32(filename_encoded))
+
+            extra_data = version_of_unicode_path + filename_crc + extra_data_name
+            tsize = len(extra_data).to_bytes(2, 'little')
+
+            zip_info.extra = tag_for_unicode_path + tsize + extra_data
+
+            # add the file to the ZIP archive
+            zf.writestr(zip_info, b'Hello World!')
+
+    @requires_zlib()
+    def test_read_zipfile_containing_unicode_path_extra_field(self):
+        self.create_zipfile_with_extra_data("�름.txt", "�름.txt".encode("utf-8"))
+        with zipfile.ZipFile(TESTFN, "r") as zf:
+            self.assertEqual(zf.filelist[0].filename, "�름.txt")
+
+    @requires_zlib()
+    def test_read_zipfile_warning(self):
+        self.create_zipfile_with_extra_data("�름.txt", b"")
+        with self.assertWarns(UserWarning):
+            zipfile.ZipFile(TESTFN, "r").close()
+
+    @requires_zlib()
+    def test_read_zipfile_error(self):
+        self.create_zipfile_with_extra_data("�름.txt", b"\xff")
+        with self.assertRaises(zipfile.BadZipfile):
+            zipfile.ZipFile(TESTFN, "r").close()
+
     def test_read_after_write_unicode_filenames(self):
         with zipfile.ZipFile(TESTFN2, 'w') as zipfp:
             zipfp.writestr('приклад', b'sample')
@@ -1679,7 +1939,7 @@ def test_is_zip_erroneous_file(self):
             fp.write("this is not a legal zip file\n")
         self.assertFalse(zipfile.is_zipfile(TESTFN))
         # - passing a path-like object
-        self.assertFalse(zipfile.is_zipfile(pathlib.Path(TESTFN)))
+        self.assertFalse(zipfile.is_zipfile(FakePath(TESTFN)))
         # - passing a file object
         with open(TESTFN, "rb") as fp:
             self.assertFalse(zipfile.is_zipfile(fp))
@@ -2036,6 +2296,7 @@ def test_seek_tell(self):
                 fp.seek(bloc, os.SEEK_CUR)
                 self.assertEqual(fp.tell(), bloc)
                 self.assertEqual(fp.read(5), txt[bloc:bloc+5])
+                self.assertEqual(fp.tell(), bloc + 5)
                 fp.seek(0, os.SEEK_END)
                 self.assertEqual(fp.tell(), len(txt))
                 fp.seek(0, os.SEEK_SET)
@@ -2053,11 +2314,40 @@ def test_seek_tell(self):
                 fp.seek(bloc, os.SEEK_CUR)
                 self.assertEqual(fp.tell(), bloc)
                 self.assertEqual(fp.read(5), txt[bloc:bloc+5])
+                self.assertEqual(fp.tell(), bloc + 5)
                 fp.seek(0, os.SEEK_END)
                 self.assertEqual(fp.tell(), len(txt))
                 fp.seek(0, os.SEEK_SET)
                 self.assertEqual(fp.tell(), 0)
 
+    def test_read_after_seek(self):
+        # Issue 102956: Make sure seek(x, os.SEEK_CUR) doesn't break read()
+        txt = b"Charge men!"
+        bloc = txt.find(b"men")
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("foo.txt", txt)
+        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.seek(bloc, os.SEEK_CUR)
+                self.assertEqual(fp.read(-1), b'men!')
+        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.read(6)
+                fp.seek(1, os.SEEK_CUR)
+                self.assertEqual(fp.read(-1), b'men!')
+
+    def test_uncompressed_interleaved_seek_read(self):
+        # gh-127847: Make sure the position in the archive is correct
+        # in the special case of seeking in a ZIP_STORED entry.
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("a.txt", "123")
+            zipf.writestr("b.txt", "456")
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            with zipf.open("a.txt", "r") as a, zipf.open("b.txt", "r") as b:
+                self.assertEqual(a.read(1), b"1")
+                self.assertEqual(b.seek(1), 1)
+                self.assertEqual(b.read(1), b"5")
+
     @requires_bz2()
     def test_decompress_without_3rd_party_library(self):
         data = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
@@ -2068,6 +2358,170 @@ def test_decompress_without_3rd_party_library(self):
             with zipfile.ZipFile(zip_file) as zf:
                 self.assertRaises(RuntimeError, zf.extract, 'a.txt')
 
+    @requires_zlib()
+    def test_full_overlap_different_names(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00b\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00bPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            self.assertEqual(len(zipf.read('b')), 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'File name.*differ'):
+                zipf.read('a')
+
+    @requires_zlib()
+    def test_full_overlap_different_names2(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00a\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00bPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'File name.*differ'):
+                zipf.read('b')
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                self.assertEqual(len(zipf.read('a')), 1033)
+            self.assertEqual(cm.filename, __file__)
+
+    @requires_zlib()
+    def test_full_overlap_same_name(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00a\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'a'])
+            self.assertEqual(len(zipf.infolist()), 2)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            self.assertEqual(len(zipf.read('a')), 1033)
+            self.assertEqual(len(zipf.read(zi)), 1033)
+            self.assertEqual(len(zipf.read(zipf.infolist()[1])), 1033)
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                self.assertEqual(len(zipf.read(zipf.infolist()[0])), 1033)
+            self.assertEqual(cm.filename, __file__)
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                zipf.open(zipf.infolist()[0]).close()
+            self.assertEqual(cm.filename, __file__)
+
+    @requires_zlib()
+    def test_quoted_overlap(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05Y\xfc'
+            b'8\x044\x00\x00\x00(\x04\x00\x00\x01\x00\x00\x00a\x00'
+            b'\x1f\x00\xe0\xffPK\x03\x04\x14\x00\x00\x00\x08\x00\xa0l'
+            b'H\x05\xe2\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00'
+            b'\x00\x00b\xed\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\'
+            b'd\x0b`PK\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0'
+            b'lH\x05Y\xfc8\x044\x00\x00\x00(\x04\x00\x00\x01'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+            b'\x00aPK\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0l'
+            b'H\x05\xe2\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00'
+            b'bPK\x05\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00'
+            b'\x00S\x00\x00\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 52)
+            self.assertEqual(zi.file_size, 1064)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 36)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Overlapped entries'):
+                zipf.read('a')
+            self.assertEqual(len(zipf.read('b')), 1033)
+
+    @requires_zlib()
+    def test_overlap_with_central_dir(self):
+        data = (
+            b'PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00G_|Z'
+            b'\xe2\x1e8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x81\x00\x00\x00\x00aP'
+            b'K\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a'])
+            self.assertEqual(len(zipf.infolist()), 1)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 11)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Bad magic number'):
+                zipf.read('a')
+
+    @requires_zlib()
+    def test_overlap_with_archive_comment(self):
+        data = (
+            b'PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00G_|Z'
+            b'\xe2\x1e8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x81E\x00\x00\x00aP'
+            b'K\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x00'
+            b'\x00\x00\x00*\x00'
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00G_|Z\xe2\x1e'
+            b'8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00aK'
+            b'L\x1c\x05\xa3`\x14\x8cx\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a'])
+            self.assertEqual(len(zipf.infolist()), 1)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 69)
+            self.assertEqual(zi.compress_size, 11)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Overlapped entries'):
+                zipf.read('a')
+
     def tearDown(self):
         unlink(TESTFN)
         unlink(TESTFN2)
@@ -2220,10 +2674,23 @@ def test_good_password(self):
         self.assertEqual(self.zip2.read("zero"), self.plain2)
 
     def test_unicode_password(self):
-        self.assertRaises(TypeError, self.zip.setpassword, "unicode")
-        self.assertRaises(TypeError, self.zip.read, "test.txt", "python")
-        self.assertRaises(TypeError, self.zip.open, "test.txt", pwd="python")
-        self.assertRaises(TypeError, self.zip.extract, "test.txt", pwd="python")
+        expected_msg = "pwd: expected bytes, got str"
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.setpassword("unicode")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.read("test.txt", "python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.open("test.txt", pwd="python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.extract("test.txt", pwd="python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.pwd = "python"
+            self.zip.open("test.txt")
 
     def test_seek_tell(self):
         self.zip.setpassword(b"python")
@@ -2561,14 +3028,14 @@ def test_write_after_read(self):
     def test_many_opens(self):
         # Verify that read() and open() promptly close the file descriptor,
         # and don't rely on the garbage collector to free resources.
+        startcount = fd_count()
         self.make_test_archive(TESTFN2)
         with zipfile.ZipFile(TESTFN2, mode="r") as zipf:
-            for x in range(200):
+            for x in range(100):
                 zipf.read('ones')
                 with zipf.open('ones') as zopen1:
                     pass
-        with open(os.devnull, "rb") as f:
-            self.assertLess(f.fileno(), 200)
+        self.assertEqual(startcount, fd_count())
 
     def test_write_while_reading(self):
         with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_DEFLATED) as zipf:
@@ -2592,7 +3059,7 @@ def setUp(self):
         os.mkdir(TESTFN2)
 
     def test_extract_dir(self):
-        with zipfile.ZipFile(findfile("zipdir.zip")) as zipf:
+        with zipfile.ZipFile(findfile("zipdir.zip", subdir="archivetestdata")) as zipf:
             zipf.extractall(TESTFN2)
         self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
         self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
@@ -2603,6 +3070,22 @@ def test_bug_6050(self):
         os.mkdir(os.path.join(TESTFN2, "a"))
         self.test_extract_dir()
 
+    def test_extract_dir_backslash(self):
+        zfname = findfile("zipdir_backslash.zip", subdir="archivetestdata")
+        with zipfile.ZipFile(zfname) as zipf:
+            zipf.extractall(TESTFN2)
+        if os.name == 'nt':
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "a", "b", "c")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "d")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "d", "e")))
+        else:
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "a\\b\\c")))
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "d\\e\\")))
+            self.assertFalse(os.path.exists(os.path.join(TESTFN2, "a")))
+            self.assertFalse(os.path.exists(os.path.join(TESTFN2, "d")))
+
     def test_write_dir(self):
         dirpath = os.path.join(TESTFN2, "x")
         os.mkdir(dirpath)
@@ -2646,6 +3129,70 @@ def test_writestr_dir(self):
             self.assertTrue(os.path.isdir(os.path.join(target, "x")))
             self.assertEqual(os.listdir(target), ["x"])
 
+    def test_mkdir(self):
+        with zipfile.ZipFile(TESTFN, "w") as zf:
+            zf.mkdir("directory")
+            zinfo = zf.filelist[0]
+            self.assertEqual(zinfo.filename, "directory/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            zf.mkdir("directory2/")
+            zinfo = zf.filelist[1]
+            self.assertEqual(zinfo.filename, "directory2/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            zf.mkdir("directory3", mode=0o777)
+            zinfo = zf.filelist[2]
+            self.assertEqual(zinfo.filename, "directory3/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            old_zinfo = zipfile.ZipInfo("directory4/")
+            old_zinfo.external_attr = (0o40777 << 16) | 0x10
+            old_zinfo.CRC = 0
+            old_zinfo.file_size = 0
+            old_zinfo.compress_size = 0
+            zf.mkdir(old_zinfo)
+            new_zinfo = zf.filelist[3]
+            self.assertEqual(old_zinfo.filename, "directory4/")
+            self.assertEqual(old_zinfo.external_attr, new_zinfo.external_attr)
+
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zf.extractall(target)
+            self.assertEqual(set(os.listdir(target)), {"directory", "directory2", "directory3", "directory4"})
+
+    def test_create_directory_with_write(self):
+        with zipfile.ZipFile(TESTFN, "w") as zf:
+            zf.writestr(zipfile.ZipInfo('directory/'), '')
+
+            zinfo = zf.filelist[0]
+            self.assertEqual(zinfo.filename, "directory/")
+
+            directory = os.path.join(TESTFN2, "directory2")
+            os.mkdir(directory)
+            mode = os.stat(directory).st_mode & 0xFFFF
+            zf.write(directory, arcname="directory2/")
+            zinfo = zf.filelist[1]
+            self.assertEqual(zinfo.filename, "directory2/")
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zf.extractall(target)
+
+            self.assertEqual(set(os.listdir(target)), {"directory", "directory2"})
+
+    def test_root_folder_in_zipfile(self):
+        """
+        gh-112795: Some tools or self constructed codes will add '/' folder to
+        the zip file, this is a strange behavior, but we should support it.
+        """
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.mkdir('/')
+        zf.writestr('./a.txt', 'aaa')
+        zf.extractall(TESTFN2)
+
     def tearDown(self):
         rmtree(TESTFN2)
         if os.path.exists(TESTFN):
@@ -2655,13 +3202,13 @@ def tearDown(self):
 class ZipInfoTests(unittest.TestCase):
     def test_from_file(self):
         zi = zipfile.ZipInfo.from_file(__file__)
-        self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
+        self.assertEqual(posixpath.basename(zi.filename), 'test_core.py')
         self.assertFalse(zi.is_dir())
         self.assertEqual(zi.file_size, os.path.getsize(__file__))
 
     def test_from_file_pathlike(self):
-        zi = zipfile.ZipInfo.from_file(pathlib.Path(__file__))
-        self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
+        zi = zipfile.ZipInfo.from_file(FakePath(__file__))
+        self.assertEqual(posixpath.basename(zi.filename), 'test_core.py')
         self.assertFalse(zi.is_dir())
         self.assertEqual(zi.file_size, os.path.getsize(__file__))
 
@@ -2686,6 +3233,17 @@ def test_from_dir(self):
         self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
         self.assertEqual(zi.file_size, 0)
 
+    def test_compresslevel_property(self):
+        zinfo = zipfile.ZipInfo("xxx")
+        self.assertFalse(zinfo._compresslevel)
+        self.assertFalse(zinfo.compress_level)
+        zinfo._compresslevel = 99  # test the legacy @property.setter
+        self.assertEqual(zinfo.compress_level, 99)
+        self.assertEqual(zinfo._compresslevel, 99)
+        zinfo.compress_level = 8
+        self.assertEqual(zinfo.compress_level, 8)
+        self.assertEqual(zinfo._compresslevel, 8)
+
 
 class CommandLineTest(unittest.TestCase):
 
@@ -2708,7 +3266,7 @@ def test_bad_use(self):
         self.assertNotEqual(err.strip(), b'')
 
     def test_test_command(self):
-        zip_name = findfile('zipdir.zip')
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
         for opt in '-t', '--test':
             out = self.zipfilecmd(opt, zip_name)
             self.assertEqual(out.rstrip(), b'Done testing')
@@ -2717,7 +3275,7 @@ def test_test_command(self):
         self.assertEqual(out, b'')
 
     def test_list_command(self):
-        zip_name = findfile('zipdir.zip')
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
         t = io.StringIO()
         with zipfile.ZipFile(zip_name, 'r') as tf:
             tf.printdir(t)
@@ -2750,7 +3308,7 @@ def test_create_command(self):
                 unlink(TESTFN2)
 
     def test_extract_command(self):
-        zip_name = findfile('zipdir.zip')
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
         for opt in '-e', '--extract':
             with temp_dir() as extdir:
                 out = self.zipfilecmd(opt, zip_name, extdir)
@@ -2771,8 +3329,8 @@ class TestExecutablePrependedZip(unittest.TestCase):
     """Test our ability to open zip files with an executable prepended."""
 
     def setUp(self):
-        self.exe_zip = findfile('exe_with_zip', subdir='ziptestdata')
-        self.exe_zip64 = findfile('exe_with_z64', subdir='ziptestdata')
+        self.exe_zip = findfile('exe_with_zip', subdir='archivetestdata')
+        self.exe_zip64 = findfile('exe_with_z64', subdir='archivetestdata')
 
     def _test_zip_works(self, name):
         # bpo28494 sanity check: ensure is_zipfile works on these.
@@ -2795,6 +3353,7 @@ def test_read_zip64_with_exe_prepended(self):
     @unittest.skipUnless(sys.executable, 'sys.executable required.')
     @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
                          'Test relies on #!/bin/bash working.')
+    @requires_subprocess()
     def test_execute_zip2(self):
         output = subprocess.check_output([self.exe_zip, sys.executable])
         self.assertIn(b'number in executable: 5', output)
@@ -2804,365 +3363,301 @@ def test_execute_zip2(self):
     @unittest.skipUnless(sys.executable, 'sys.executable required.')
     @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
                          'Test relies on #!/bin/bash working.')
+    @requires_subprocess()
     def test_execute_zip64(self):
         output = subprocess.check_output([self.exe_zip64, sys.executable])
         self.assertIn(b'number in executable: 5', output)
 
 
-# Poor man's technique to consume a (smallish) iterable.
-consume = tuple
-
-
-# from jaraco.itertools 5.0
-class jaraco:
-    class itertools:
-        class Counter:
-            def __init__(self, i):
-                self.count = 0
-                self._orig_iter = iter(i)
-
-            def __iter__(self):
-                return self
-
-            def __next__(self):
-                result = next(self._orig_iter)
-                self.count += 1
-                return result
-
-
-def add_dirs(zf):
-    """
-    Given a writable zip file zf, inject directory entries for
-    any directories implied by the presence of children.
-    """
-    for name in zipfile.CompleteDirs._implied_dirs(zf.namelist()):
-        zf.writestr(name, b"")
-    return zf
-
-
-def build_alpharep_fixture():
-    """
-    Create a zip file with this structure:
-
-    .
-    ├── a.txt
-    ├── b
-    │   ├── c.txt
-    │   ├── d
-    │   │   └── e.txt
-    │   └── f.txt
-    └── g
-        └── h
-            └── i.txt
-
-    This fixture has the following key characteristics:
-
-    - a file at the root (a)
-    - a file two levels deep (b/d/e)
-    - multiple files in a directory (b/c, b/f)
-    - a directory containing only a directory (g/h)
-
-    "alpha" because it uses alphabet
-    "rep" because it's a representative example
-    """
-    data = io.BytesIO()
-    zf = zipfile.ZipFile(data, "w")
-    zf.writestr("a.txt", b"content of a")
-    zf.writestr("b/c.txt", b"content of c")
-    zf.writestr("b/d/e.txt", b"content of e")
-    zf.writestr("b/f.txt", b"content of f")
-    zf.writestr("g/h/i.txt", b"content of i")
-    zf.filename = "alpharep.zip"
-    return zf
-
-
-def pass_alpharep(meth):
-    """
-    Given a method, wrap it in a for loop that invokes method
-    with each subtest.
-    """
-
-    @functools.wraps(meth)
-    def wrapper(self):
-        for alpharep in self.zipfile_alpharep():
-            meth(self, alpharep=alpharep)
-
-    return wrapper
-
-
-class TestPath(unittest.TestCase):
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-
-    def zipfile_alpharep(self):
-        with self.subTest():
-            yield build_alpharep_fixture()
-        with self.subTest():
-            yield add_dirs(build_alpharep_fixture())
-
-    def zipfile_ondisk(self, alpharep):
-        tmpdir = pathlib.Path(self.fixtures.enter_context(temp_dir()))
-        buffer = alpharep.fp
-        alpharep.close()
-        path = tmpdir / alpharep.filename
-        with path.open("wb") as strm:
-            strm.write(buffer.getvalue())
-        return path
-
-    @pass_alpharep
-    def test_iterdir_and_types(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.is_dir()
-        a, b, g = root.iterdir()
-        assert a.is_file()
-        assert b.is_dir()
-        assert g.is_dir()
-        c, f, d = b.iterdir()
-        assert c.is_file() and f.is_file()
-        (e,) = d.iterdir()
-        assert e.is_file()
-        (h,) = g.iterdir()
-        (i,) = h.iterdir()
-        assert i.is_file()
-
-    @pass_alpharep
-    def test_is_file_missing(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert not root.joinpath('missing.txt').is_file()
-
-    @pass_alpharep
-    def test_iterdir_on_file(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        with self.assertRaises(ValueError):
-            a.iterdir()
-
-    @pass_alpharep
-    def test_subdir_is_dir(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'b').is_dir()
-        assert (root / 'b/').is_dir()
-        assert (root / 'g').is_dir()
-        assert (root / 'g/').is_dir()
-
-    @pass_alpharep
-    def test_open(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        with a.open(encoding="utf-8") as strm:
-            data = strm.read()
-        assert data == "content of a"
+# TODO: RUSTPYTHON
+@unittest.skip("TODO: RUSTPYTHON shift_jis encoding unsupported")
+class EncodedMetadataTests(unittest.TestCase):
+    file_names = ['\u4e00', '\u4e8c', '\u4e09']  # Han 'one', 'two', 'three'
+    file_content = [
+        "This is pure ASCII.\n".encode('ascii'),
+        # This is modern Japanese. (UTF-8)
+        "\u3053\u308c\u306f\u73fe\u4ee3\u7684\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('utf-8'),
+        # This is obsolete Japanese. (Shift JIS)
+        # "\u3053\u308c\u306f\u53e4\u3044\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('shift_jis'),  # TODO: RUSTPYTHON
+    ]
 
-    def test_open_write(self):
-        """
-        If the zipfile is open for write, it should be possible to
-        write bytes or text to it.
-        """
-        zf = zipfile.Path(zipfile.ZipFile(io.BytesIO(), mode='w'))
-        with zf.joinpath('file.bin').open('wb') as strm:
-            strm.write(b'binary contents')
-        with zf.joinpath('file.txt').open('w', encoding="utf-8") as strm:
-            strm.write('text file')
-
-    def test_open_extant_directory(self):
-        """
-        Attempting to open a directory raises IsADirectoryError.
-        """
-        zf = zipfile.Path(add_dirs(build_alpharep_fixture()))
-        with self.assertRaises(IsADirectoryError):
-            zf.joinpath('b').open()
-
-    @pass_alpharep
-    def test_open_binary_invalid_args(self, alpharep):
-        root = zipfile.Path(alpharep)
-        with self.assertRaises(ValueError):
-            root.joinpath('a.txt').open('rb', encoding='utf-8')
-        with self.assertRaises(ValueError):
-            root.joinpath('a.txt').open('rb', 'utf-8')
-
-    def test_open_missing_directory(self):
-        """
-        Attempting to open a missing directory raises FileNotFoundError.
-        """
-        zf = zipfile.Path(add_dirs(build_alpharep_fixture()))
-        with self.assertRaises(FileNotFoundError):
-            zf.joinpath('z').open()
-
-    @pass_alpharep
-    def test_read(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        assert a.read_text(encoding="utf-8") == "content of a"
-        assert a.read_bytes() == b"content of a"
-
-    @pass_alpharep
-    def test_joinpath(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a = root.joinpath("a.txt")
-        assert a.is_file()
-        e = root.joinpath("b").joinpath("d").joinpath("e.txt")
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_joinpath_multiple(self, alpharep):
-        root = zipfile.Path(alpharep)
-        e = root.joinpath("b", "d", "e.txt")
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_traverse_truediv(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a = root / "a.txt"
-        assert a.is_file()
-        e = root / "b" / "d" / "e.txt"
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_traverse_simplediv(self, alpharep):
-        """
-        Disable the __future__.division when testing traversal.
-        """
-        code = compile(
-            source="zipfile.Path(alpharep) / 'a'",
-            filename="(test)",
-            mode="eval",
-            dont_inherit=True,
-        )
-        eval(code)
-
-    @pass_alpharep
-    def test_pathlike_construction(self, alpharep):
-        """
-        zipfile.Path should be constructable from a path-like object
-        """
-        zipfile_ondisk = self.zipfile_ondisk(alpharep)
-        pathlike = pathlib.Path(str(zipfile_ondisk))
-        zipfile.Path(pathlike)
-
-    @pass_alpharep
-    def test_traverse_pathlike(self, alpharep):
-        root = zipfile.Path(alpharep)
-        root / pathlib.Path("a")
-
-    @pass_alpharep
-    def test_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'a').parent.at == ''
-        assert (root / 'a' / 'b').parent.at == 'a/'
-
-    @pass_alpharep
-    def test_dir_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'b').parent.at == ''
-        assert (root / 'b/').parent.at == ''
-
-    @pass_alpharep
-    def test_missing_dir_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'missing dir/').parent.at == ''
-
-    @pass_alpharep
-    def test_mutability(self, alpharep):
-        """
-        If the underlying zipfile is changed, the Path object should
-        reflect that change.
-        """
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        alpharep.writestr('foo.txt', 'foo')
-        alpharep.writestr('bar/baz.txt', 'baz')
-        assert any(child.name == 'foo.txt' for child in root.iterdir())
-        assert (root / 'foo.txt').read_text(encoding="utf-8") == 'foo'
-        (baz,) = (root / 'bar').iterdir()
-        assert baz.read_text(encoding="utf-8") == 'baz'
-
-    HUGE_ZIPFILE_NUM_ENTRIES = 2 ** 13
-
-    def huge_zipfile(self):
-        """Create a read-only zipfile with a huge number of entries entries."""
-        strm = io.BytesIO()
-        zf = zipfile.ZipFile(strm, "w")
-        for entry in map(str, range(self.HUGE_ZIPFILE_NUM_ENTRIES)):
-            zf.writestr(entry, entry)
-        zf.mode = 'r'
-        return zf
-
-    def test_joinpath_constant_time(self):
-        """
-        Ensure joinpath on items in zipfile is linear time.
-        """
-        root = zipfile.Path(self.huge_zipfile())
-        entries = jaraco.itertools.Counter(root.iterdir())
-        for entry in entries:
-            entry.joinpath('suffix')
-        # Check the file iterated all items
-        assert entries.count == self.HUGE_ZIPFILE_NUM_ENTRIES
-
-    # @func_timeout.func_set_timeout(3)
-    def test_implied_dirs_performance(self):
-        data = ['/'.join(string.ascii_lowercase + str(n)) for n in range(10000)]
-        zipfile.CompleteDirs._implied_dirs(data)
-
-    @pass_alpharep
-    def test_read_does_not_close(self, alpharep):
-        alpharep = self.zipfile_ondisk(alpharep)
-        with zipfile.ZipFile(alpharep) as file:
-            for rep in range(2):
-                zipfile.Path(file, 'a.txt').read_text(encoding="utf-8")
-
-    @pass_alpharep
-    def test_subclass(self, alpharep):
-        class Subclass(zipfile.Path):
-            pass
-
-        root = Subclass(alpharep)
-        assert isinstance(root / 'b', Subclass)
-
-    @pass_alpharep
-    def test_filename(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.filename == pathlib.Path('alpharep.zip')
+    def setUp(self):
+        self.addCleanup(unlink, TESTFN)
+        # Create .zip of 3 members with Han names encoded in Shift JIS.
+        # Each name is 1 Han character encoding to 2 bytes in Shift JIS.
+        # The ASCII names are arbitrary as long as they are length 2 and
+        # not otherwise contained in the zip file.
+        # Data elements are encoded bytes (ascii, utf-8, shift_jis).
+        placeholders = ["n1", "n2"] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, mode="w") as tf:
+            for temp, content in zip(placeholders, self.file_content):
+                tf.writestr(temp, content, zipfile.ZIP_STORED)
+        # Hack in the Shift JIS names with flag bit 11 (UTF-8) unset.
+        with open(TESTFN, "rb") as tf:
+            data = tf.read()
+        for name, temp in zip(self.file_names, placeholders[:2]):
+            data = data.replace(temp.encode('ascii'),
+                                name.encode('shift_jis'))
+        with open(TESTFN, "wb") as tf:
+            tf.write(data)
+
+    def _test_read(self, zipfp, expected_names, expected_content):
+        # Check the namelist
+        names = zipfp.namelist()
+        self.assertEqual(sorted(names), sorted(expected_names))
+
+        # Check infolist
+        infos = zipfp.infolist()
+        names = [zi.filename for zi in infos]
+        self.assertEqual(sorted(names), sorted(expected_names))
+
+        # check getinfo
+        for name, content in zip(expected_names, expected_content):
+            info = zipfp.getinfo(name)
+            self.assertEqual(info.filename, name)
+            self.assertEqual(info.file_size, len(content))
+            self.assertEqual(zipfp.read(name), content)
+
+    def test_read_with_metadata_encoding(self):
+        # Read the ZIP archive with correct metadata_encoding
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='shift_jis') as zipfp:
+            self._test_read(zipfp, self.file_names, self.file_content)
+
+    def test_read_without_metadata_encoding(self):
+        # Read the ZIP archive without metadata_encoding
+        expected_names = [name.encode('shift_jis').decode('cp437')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, "r") as zipfp:
+            self._test_read(zipfp, expected_names, self.file_content)
+
+    def test_read_with_incorrect_metadata_encoding(self):
+        # Read the ZIP archive with incorrect metadata_encoding
+        expected_names = [name.encode('shift_jis').decode('koi8-u')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='koi8-u') as zipfp:
+            self._test_read(zipfp, expected_names, self.file_content)
+
+    def test_read_with_unsuitable_metadata_encoding(self):
+        # Read the ZIP archive with metadata_encoding unsuitable for
+        # decoding metadata
+        with self.assertRaises(UnicodeDecodeError):
+            zipfile.ZipFile(TESTFN, "r", metadata_encoding='ascii')
+        with self.assertRaises(UnicodeDecodeError):
+            zipfile.ZipFile(TESTFN, "r", metadata_encoding='utf-8')
+
+    def test_read_after_append(self):
+        newname = '\u56db'  # Han 'four'
+        expected_names = [name.encode('shift_jis').decode('cp437')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        expected_names.append(newname)
+        expected_content = (*self.file_content, b"newcontent")
+
+        with zipfile.ZipFile(TESTFN, "a") as zipfp:
+            zipfp.writestr(newname, "newcontent")
+            self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
+
+        with zipfile.ZipFile(TESTFN, "r") as zipfp:
+            self._test_read(zipfp, expected_names, expected_content)
+
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='shift_jis') as zipfp:
+            self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
+            for i, (name, content) in enumerate(zip(expected_names, expected_content)):
+                info = zipfp.getinfo(name)
+                self.assertEqual(info.filename, name)
+                self.assertEqual(info.file_size, len(content))
+                if i < 2:
+                    with self.assertRaises(zipfile.BadZipFile):
+                        zipfp.read(name)
+                else:
+                    self.assertEqual(zipfp.read(name), content)
+
+    def test_write_with_metadata_encoding(self):
+        ZF = zipfile.ZipFile
+        for mode in ("w", "x", "a"):
+            with self.assertRaisesRegex(ValueError,
+                                        "^metadata_encoding is only"):
+                ZF("nonesuch.zip", mode, metadata_encoding="shift_jis")
+
+    def test_cli_with_metadata_encoding(self):
+        errmsg = "Non-conforming encodings not supported with -c."
+        args = ["--metadata-encoding=shift_jis", "-c", "nonesuch", "nonesuch"]
+        with captured_stdout() as stdout:
+            with captured_stderr() as stderr:
+                self.assertRaises(SystemExit, zipfile.main, args)
+        self.assertEqual(stdout.getvalue(), "")
+        self.assertIn(errmsg, stderr.getvalue())
+
+        with captured_stdout() as stdout:
+            zipfile.main(["--metadata-encoding=shift_jis", "-t", TESTFN])
+        listing = stdout.getvalue()
+
+        with captured_stdout() as stdout:
+            zipfile.main(["--metadata-encoding=shift_jis", "-l", TESTFN])
+        listing = stdout.getvalue()
+        for name in self.file_names:
+            self.assertIn(name, listing)
+
+    def test_cli_with_metadata_encoding_extract(self):
+        os.mkdir(TESTFN2)
+        self.addCleanup(rmtree, TESTFN2)
+        # Depending on locale, extracted file names can be not encodable
+        # with the filesystem encoding.
+        for fn in self.file_names:
+            try:
+                os.stat(os.path.join(TESTFN2, fn))
+            except OSError:
+                pass
+            except UnicodeEncodeError:
+                self.skipTest(f'cannot encode file name {fn!a}')
+
+        zipfile.main(["--metadata-encoding=shift_jis", "-e", TESTFN, TESTFN2])
+        listing = os.listdir(TESTFN2)
+        for name in self.file_names:
+            self.assertIn(name, listing)
+
+
+class StripExtraTests(unittest.TestCase):
+    # Note: all of the "z" characters are technically invalid, but up
+    # to 3 bytes at the end of the extra will be passed through as they
+    # are too short to encode a valid extra.
+
+    ZIP64_EXTRA = 1
+
+    def test_no_data(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 0)
+        b = s.pack(2, 0)
+        c = s.pack(3, 0)
+
+        self.assertEqual(b'', zipfile._Extra.strip(a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b+c, zipfile._Extra.strip(a+b+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+a+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+c+a, (self.ZIP64_EXTRA,)))
+
+    def test_with_data(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
+        b = s.pack(2, 2) + b"bb"
+        c = s.pack(3, 3) + b"ccc"
+
+        self.assertEqual(b"", zipfile._Extra.strip(a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b+c, zipfile._Extra.strip(a+b+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+a+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+c+a, (self.ZIP64_EXTRA,)))
+
+    def test_multiples(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
+        b = s.pack(2, 2) + b"bb"
+
+        self.assertEqual(b"", zipfile._Extra.strip(a+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b"", zipfile._Extra.strip(a+a+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"z", zipfile._Extra.strip(a+a+b"z", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(a+a+b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b, zipfile._Extra.strip(a+a+b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(a+b+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b+a+a, (self.ZIP64_EXTRA,)))
+
+    def test_too_short(self):
+        self.assertEqual(b"", zipfile._Extra.strip(b"", (self.ZIP64_EXTRA,)))
+        self.assertEqual(b"z", zipfile._Extra.strip(b"z", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"zz", zipfile._Extra.strip(b"zz", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"zzz", zipfile._Extra.strip(b"zzz", (self.ZIP64_EXTRA,)))
+
+
+class StatIO(_pyio.BytesIO):
+    """Buffer which remembers the number of bytes that were read."""
+
+    def __init__(self):
+        super().__init__()
+        self.bytes_read = 0
+
+    def read(self, size=-1):
+        bs = super().read(size)
+        self.bytes_read += len(bs)
+        return bs
+
+
+class StoredZipExtFileRandomReadTest(unittest.TestCase):
+    """Tests whether an uncompressed, unencrypted zip entry can be randomly
+    seek and read without reading redundant bytes."""
+    def test_stored_seek_and_read(self):
+
+        sio = StatIO()
+        # 20000 bytes
+        txt = b'0123456789' * 2000
+
+        # The seek length must be greater than ZipExtFile.MIN_READ_SIZE
+        # as `ZipExtFile._read2()` reads in blocks of this size and we
+        # need to seek out of the buffered data
+        read_buffer_size = zipfile.ZipExtFile.MIN_READ_SIZE
+        self.assertGreaterEqual(10002, read_buffer_size)  # for forward seek test
+        self.assertGreaterEqual(5003, read_buffer_size)  # for backward seek test
+        # The read length must be less than MIN_READ_SIZE, since we assume that
+        # only 1 block is read in the test.
+        read_length = 100
+        self.assertGreaterEqual(read_buffer_size, read_length)  # for read() calls
+
+        with zipfile.ZipFile(sio, "w", compression=zipfile.ZIP_STORED) as zipf:
+            zipf.writestr("foo.txt", txt)
 
-    @pass_alpharep
-    def test_root_name(self, alpharep):
-        """
-        The name of the root should be the name of the zipfile
-        """
-        root = zipfile.Path(alpharep)
-        assert root.name == 'alpharep.zip' == root.filename.name
-
-    @pass_alpharep
-    def test_root_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.parent == pathlib.Path('.')
-        root.root.filename = 'foo/bar.zip'
-        assert root.parent == pathlib.Path('foo')
-
-    @pass_alpharep
-    def test_root_unnamed(self, alpharep):
-        """
-        It is an error to attempt to get the name
-        or parent of an unnamed zipfile.
-        """
-        alpharep.filename = None
-        root = zipfile.Path(alpharep)
-        with self.assertRaises(TypeError):
-            root.name
-        with self.assertRaises(TypeError):
-            root.parent
-
-        # .name and .parent should still work on subs
-        sub = root / "b"
-        assert sub.name == "b"
-        assert sub.parent
-
-    @pass_alpharep
-    def test_inheritance(self, alpharep):
-        cls = type('PathChild', (zipfile.Path,), {})
-        for alpharep in self.zipfile_alpharep():
-            file = cls(alpharep).joinpath('some dir').parent
-            assert isinstance(file, cls)
+        # check random seek and read on a file
+        with zipfile.ZipFile(sio, "r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                # Test this optimized read hasn't rewound and read from the
+                # start of the file (as in the case of the unoptimized path)
+
+                # forward seek
+                old_count = sio.bytes_read
+                forward_seek_len = 10002
+                current_pos = 0
+                fp.seek(forward_seek_len, os.SEEK_CUR)
+                current_pos += forward_seek_len
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(fp._left, fp._compress_left)
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
+                self.assertEqual(fp._left, fp._compress_left)
+                read_count = sio.bytes_read - old_count
+                self.assertLessEqual(read_count, read_buffer_size)
+
+                # backward seek
+                old_count = sio.bytes_read
+                backward_seek_len = 5003
+                fp.seek(-backward_seek_len, os.SEEK_CUR)
+                current_pos -= backward_seek_len
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(fp._left, fp._compress_left)
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
+                self.assertEqual(fp._left, fp._compress_left)
+                read_count = sio.bytes_read - old_count
+                self.assertLessEqual(read_count, read_buffer_size)
+
+                # eof flags test
+                fp.seek(0, os.SEEK_END)
+                fp.seek(12345, os.SEEK_SET)
+                current_pos = 12345
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
 
 
 if __name__ == "__main__":
diff --git a/Lib/zipfile.py b/Lib/zipfile/__init__.py
similarity index 85%
rename from Lib/zipfile.py
rename to Lib/zipfile/__init__.py
index ef1eb47f9f1..05f387a950b 100644
--- a/Lib/zipfile.py
+++ b/Lib/zipfile/__init__.py
@@ -6,26 +6,13 @@
 import binascii
 import importlib.util
 import io
-import itertools
-try:
-    import os
-except ImportError:
-    import _dummy_os as os
-import posixpath
-try:
-    import shutil
-except ImportError:
-    pass
+import os
+import shutil
 import stat
 import struct
 import sys
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
+import threading
 import time
-import contextlib
-import pathlib
 
 try:
     import zlib # We may need its compression method
@@ -132,6 +119,32 @@ class LargeZipFile(Exception):
 _CD_EXTERNAL_FILE_ATTRIBUTES = 17
 _CD_LOCAL_HEADER_OFFSET = 18
 
+# General purpose bit flags
+# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes)
+_MASK_ENCRYPTED = 1 << 0
+# Bits 1 and 2 have different meanings depending on the compression used.
+_MASK_COMPRESS_OPTION_1 = 1 << 1
+# _MASK_COMPRESS_OPTION_2 = 1 << 2
+# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed
+# size are zero in the local header and the real values are written in the data
+# descriptor immediately following the compressed data.
+_MASK_USE_DATA_DESCRIPTOR = 1 << 3
+# Bit 4: Reserved for use with compression method 8, for enhanced deflating.
+# _MASK_RESERVED_BIT_4 = 1 << 4
+_MASK_COMPRESSED_PATCH = 1 << 5
+_MASK_STRONG_ENCRYPTION = 1 << 6
+# _MASK_UNUSED_BIT_7 = 1 << 7
+# _MASK_UNUSED_BIT_8 = 1 << 8
+# _MASK_UNUSED_BIT_9 = 1 << 9
+# _MASK_UNUSED_BIT_10 = 1 << 10
+_MASK_UTF_FILENAME = 1 << 11
+# Bit 12: Reserved by PKWARE for enhanced compression.
+# _MASK_RESERVED_BIT_12 = 1 << 12
+# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13
+# Bit 14, 15: Reserved by PKWARE
+# _MASK_RESERVED_BIT_14 = 1 << 14
+# _MASK_RESERVED_BIT_15 = 1 << 15
+
 # The "local file header" structure, magic number, size, and indices
 # (section V.A in the format document)
 structFileHeader = "<4s2B4HL2L2H"
@@ -175,26 +188,42 @@ class LargeZipFile(Exception):
 
 _DD_SIGNATURE = 0x08074b50
 
-_EXTRA_FIELD_STRUCT = struct.Struct('<HH')
-
-def _strip_extra(extra, xids):
-    # Remove Extra Fields with specified IDs.
-    unpack = _EXTRA_FIELD_STRUCT.unpack
-    modified = False
-    buffer = []
-    start = i = 0
-    while i + 4 <= len(extra):
-        xid, xlen = unpack(extra[i : i + 4])
-        j = i + 4 + xlen
-        if xid in xids:
-            if i != start:
-                buffer.append(extra[start : i])
-            start = j
-            modified = True
-        i = j
-    if not modified:
-        return extra
-    return b''.join(buffer)
+
+class _Extra(bytes):
+    FIELD_STRUCT = struct.Struct('<HH')
+
+    def __new__(cls, val, id=None):
+        return super().__new__(cls, val)
+
+    def __init__(self, val, id=None):
+        self.id = id
+
+    @classmethod
+    def read_one(cls, raw):
+        try:
+            xid, xlen = cls.FIELD_STRUCT.unpack(raw[:4])
+        except struct.error:
+            xid = None
+            xlen = 0
+        return cls(raw[:4+xlen], xid), raw[4+xlen:]
+
+    @classmethod
+    def split(cls, data):
+        # use memoryview for zero-copy slices
+        rest = memoryview(data)
+        while rest:
+            extra, rest = _Extra.read_one(rest)
+            yield extra
+
+    @classmethod
+    def strip(cls, data, xids):
+        """Remove Extra fields with specified IDs."""
+        return b''.join(
+            ex
+            for ex in cls.split(data)
+            if ex.id not in xids
+        )
+
 
 def _check_zipfile(fp):
     try:
@@ -280,7 +309,7 @@ def _EndRecData(fpin):
         fpin.seek(-sizeEndCentDir, 2)
     except OSError:
         return None
-    data = fpin.read()
+    data = fpin.read(sizeEndCentDir)
     if (len(data) == sizeEndCentDir and
         data[0:4] == stringEndArchive and
         data[-2:] == b"\000\000"):
@@ -300,9 +329,9 @@ def _EndRecData(fpin):
     # record signature. The comment is the last item in the ZIP file and may be
     # up to 64K long.  It is assumed that the "end of central directory" magic
     # number does not appear in the comment.
-    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
+    maxCommentStart = max(filesize - ZIP_MAX_COMMENT - sizeEndCentDir, 0)
     fpin.seek(maxCommentStart, 0)
-    data = fpin.read()
+    data = fpin.read(ZIP_MAX_COMMENT + sizeEndCentDir)
     start = data.rfind(stringEndArchive)
     if start >= 0:
         # found the magic number; attempt to unpack and interpret
@@ -323,8 +352,26 @@ def _EndRecData(fpin):
     # Unable to find a valid end of central directory structure
     return None
 
-
-class ZipInfo (object):
+def _sanitize_filename(filename):
+    """Terminate the file name at the first null byte and
+    ensure paths always use forward slashes as the directory separator."""
+
+    # Terminate the file name at the first null byte.  Null bytes in file
+    # names are used as tricks by viruses in archives.
+    null_byte = filename.find(chr(0))
+    if null_byte >= 0:
+        filename = filename[0:null_byte]
+    # This is used to ensure paths in generated ZIP files always use
+    # forward slashes as the directory separator, as required by the
+    # ZIP format specification.
+    if os.sep != "/" and os.sep in filename:
+        filename = filename.replace(os.sep, "/")
+    if os.altsep and os.altsep != "/" and os.altsep in filename:
+        filename = filename.replace(os.altsep, "/")
+    return filename
+
+
+class ZipInfo:
     """Class with attributes describing each file in the ZIP archive."""
 
     __slots__ = (
@@ -332,7 +379,7 @@ class ZipInfo (object):
         'filename',
         'date_time',
         'compress_type',
-        '_compresslevel',
+        'compress_level',
         'comment',
         'extra',
         'create_system',
@@ -348,21 +395,15 @@ class ZipInfo (object):
         'compress_size',
         'file_size',
         '_raw_time',
+        '_end_offset',
     )
 
     def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
         self.orig_filename = filename   # Original file name in archive
 
-        # Terminate the file name at the first null byte.  Null bytes in file
-        # names are used as tricks by viruses in archives.
-        null_byte = filename.find(chr(0))
-        if null_byte >= 0:
-            filename = filename[0:null_byte]
-        # This is used to ensure paths in generated ZIP files always use
-        # forward slashes as the directory separator, as required by the
-        # ZIP format specification.
-        if os.sep != "/" and os.sep in filename:
-            filename = filename.replace(os.sep, "/")
+        # Terminate the file name at the first null byte and
+        # ensure paths always use forward slashes as the directory separator.
+        filename = _sanitize_filename(filename)
 
         self.filename = filename        # Normalized file name
         self.date_time = date_time      # year, month, day, hour, min, sec
@@ -372,7 +413,7 @@ def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
 
         # Standard values:
         self.compress_type = ZIP_STORED # Type of compression for the file
-        self._compresslevel = None      # Level for the compressor
+        self.compress_level = None      # Level for the compressor
         self.comment = b""              # Comment for each file
         self.extra = b""                # ZIP extra data
         if sys.platform == 'win32':
@@ -389,10 +430,20 @@ def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
         self.external_attr = 0          # External file attributes
         self.compress_size = 0          # Size of the compressed file
         self.file_size = 0              # Size of the uncompressed file
+        self._end_offset = None         # Start of the next local header or central directory
         # Other attributes are set by class ZipFile:
         # header_offset         Byte offset to the file header
         # CRC                   CRC-32 of the uncompressed file
 
+    # Maintain backward compatibility with the old protected attribute name.
+    @property
+    def _compresslevel(self):
+        return self.compress_level
+
+    @_compresslevel.setter
+    def _compresslevel(self, value):
+        self.compress_level = value
+
     def __repr__(self):
         result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)]
         if self.compress_type != ZIP_STORED:
@@ -416,11 +467,16 @@ def __repr__(self):
         return ''.join(result)
 
     def FileHeader(self, zip64=None):
-        """Return the per-file header as a bytes object."""
+        """Return the per-file header as a bytes object.
+
+        When the optional zip64 arg is None rather than a bool, we will
+        decide based upon the file_size and compress_size, if known,
+        False otherwise.
+        """
         dt = self.date_time
         dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
         dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
-        if self.flag_bits & 0x08:
+        if self.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
             # Set these to zero because we write them after the file data
             CRC = compress_size = file_size = 0
         else:
@@ -432,16 +488,13 @@ def FileHeader(self, zip64=None):
 
         min_version = 0
         if zip64 is None:
+            # We always explicitly pass zip64 within this module.... This
+            # remains for anyone using ZipInfo.FileHeader as a public API.
             zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT
         if zip64:
             fmt = '<HHQQ'
             extra = extra + struct.pack(fmt,
                                         1, struct.calcsize(fmt)-4, file_size, compress_size)
-        if file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT:
-            if not zip64:
-                raise LargeZipFile("Filesize would require ZIP64 extensions")
-            # File is larger than what fits into a 4 byte integer,
-            # fall back to the ZIP64 extension
             file_size = 0xffffffff
             compress_size = 0xffffffff
             min_version = ZIP64_VERSION
@@ -465,9 +518,9 @@ def _encodeFilenameFlags(self):
         try:
             return self.filename.encode('ascii'), self.flag_bits
         except UnicodeEncodeError:
-            return self.filename.encode('utf-8'), self.flag_bits | 0x800
+            return self.filename.encode('utf-8'), self.flag_bits | _MASK_UTF_FILENAME
 
-    def _decodeExtra(self):
+    def _decodeExtra(self, filename_crc):
         # Try to decode the extra field.
         extra = self.extra
         unpack = struct.unpack
@@ -493,6 +546,22 @@ def _decodeExtra(self):
                 except struct.error:
                     raise BadZipFile(f"Corrupt zip64 extra field. "
                                      f"{field} not found.") from None
+            elif tp == 0x7075:
+                data = extra[4:ln+4]
+                # Unicode Path Extra Field
+                try:
+                    up_version, up_name_crc = unpack('<BL', data[:5])
+                    if up_version == 1 and up_name_crc == filename_crc:
+                        up_unicode_name = data[5:].decode('utf-8')
+                        if up_unicode_name:
+                            self.filename = _sanitize_filename(up_unicode_name)
+                        else:
+                            import warnings
+                            warnings.warn("Empty unicode path extra field (0x7075)", stacklevel=2)
+                except struct.error as e:
+                    raise BadZipFile("Corrupt unicode path extra field (0x7075)") from e
+                except UnicodeDecodeError as e:
+                    raise BadZipFile('Corrupt unicode path extra field (0x7075): invalid utf-8 bytes') from e
 
             extra = extra[ln+4:]
 
@@ -536,7 +605,15 @@ def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
 
     def is_dir(self):
         """Return True if this archive member is a directory."""
-        return self.filename[-1] == '/'
+        if self.filename.endswith('/'):
+            return True
+        # The ZIP format specification requires to use forward slashes
+        # as the directory separator, but in practice some ZIP files
+        # created on Windows can use backward slashes.  For compatibility
+        # with the extraction code which already handles this:
+        if os.path.altsep:
+            return self.filename.endswith((os.path.sep, os.path.altsep))
+        return False
 
 
 # ZIP encryption uses the CRC32 one-byte primitive for scrambling some
@@ -740,7 +817,10 @@ def seek(self, offset, whence=0):
                 raise ValueError("Can't reposition in the ZIP file while "
                         "there is an open writing handle on it. "
                         "Close the writing handle before trying to read.")
-            self._file.seek(offset, whence)
+            if whence == os.SEEK_CUR:
+                self._file.seek(self._pos + offset)
+            else:
+                self._file.seek(offset, whence)
             self._pos = self._file.tell()
             return self._pos
 
@@ -830,13 +910,14 @@ def __init__(self, fileobj, mode, zipinfo, pwd=None,
                 self._orig_compress_size = zipinfo.compress_size
                 self._orig_file_size = zipinfo.file_size
                 self._orig_start_crc = self._running_crc
+                self._orig_crc = self._expected_crc
                 self._seekable = True
         except AttributeError:
             pass
 
         self._decrypter = None
         if pwd:
-            if zipinfo.flag_bits & 0x8:
+            if zipinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
                 # compare against the file type from extended local headers
                 check_byte = (zipinfo._raw_time >> 8) & 0xff
             else:
@@ -862,7 +943,7 @@ def __repr__(self):
         result = ['<%s.%s' % (self.__class__.__module__,
                               self.__class__.__qualname__)]
         if not self.closed:
-            result.append(' name=%r mode=%r' % (self.name, self.mode))
+            result.append(' name=%r' % (self.name,))
             if self._compress_type != ZIP_STORED:
                 result.append(' compress_type=%s' %
                               compressor_names.get(self._compress_type,
@@ -1052,17 +1133,17 @@ def seekable(self):
             raise ValueError("I/O operation on closed file.")
         return self._seekable
 
-    def seek(self, offset, whence=0):
+    def seek(self, offset, whence=os.SEEK_SET):
         if self.closed:
             raise ValueError("seek on closed file.")
         if not self._seekable:
             raise io.UnsupportedOperation("underlying stream is not seekable")
         curr_pos = self.tell()
-        if whence == 0: # Seek from start of file
+        if whence == os.SEEK_SET:
             new_pos = offset
-        elif whence == 1: # Seek from current position
+        elif whence == os.SEEK_CUR:
             new_pos = curr_pos + offset
-        elif whence == 2: # Seek from EOF
+        elif whence == os.SEEK_END:
             new_pos = self._orig_file_size + offset
         else:
             raise ValueError("whence must be os.SEEK_SET (0), "
@@ -1081,10 +1162,25 @@ def seek(self, offset, whence=0):
             # Just move the _offset index if the new position is in the _readbuffer
             self._offset = buff_offset
             read_offset = 0
+        # Fast seek uncompressed unencrypted file
+        elif self._compress_type == ZIP_STORED and self._decrypter is None and read_offset != 0:
+            # disable CRC checking after first seeking - it would be invalid
+            self._expected_crc = None
+            # seek actual file taking already buffered data into account
+            read_offset -= len(self._readbuffer) - self._offset
+            self._fileobj.seek(read_offset, os.SEEK_CUR)
+            self._left -= read_offset
+            self._compress_left -= read_offset
+            self._eof = self._left <= 0
+            read_offset = 0
+            # flush read buffer
+            self._readbuffer = b''
+            self._offset = 0
         elif read_offset < 0:
             # Position is before the current position. Reset the ZipExtFile
             self._fileobj.seek(self._orig_compress_start)
             self._running_crc = self._orig_start_crc
+            self._expected_crc = self._orig_crc
             self._compress_left = self._orig_compress_size
             self._left = self._orig_file_size
             self._readbuffer = b''
@@ -1117,7 +1213,7 @@ def __init__(self, zf, zinfo, zip64):
         self._zip64 = zip64
         self._zipfile = zf
         self._compressor = _get_compressor(zinfo.compress_type,
-                                           zinfo._compresslevel)
+                                           zinfo.compress_level)
         self._file_size = 0
         self._compress_size = 0
         self._crc = 0
@@ -1126,6 +1222,14 @@ def __init__(self, zf, zinfo, zip64):
     def _fileobj(self):
         return self._zipfile.fp
 
+    @property
+    def name(self):
+        return self._zinfo.filename
+
+    @property
+    def mode(self):
+        return 'wb'
+
     def writable(self):
         return True
 
@@ -1164,21 +1268,20 @@ def close(self):
             self._zinfo.CRC = self._crc
             self._zinfo.file_size = self._file_size
 
+            if not self._zip64:
+                if self._file_size > ZIP64_LIMIT:
+                    raise RuntimeError("File size too large, try using force_zip64")
+                if self._compress_size > ZIP64_LIMIT:
+                    raise RuntimeError("Compressed size too large, try using force_zip64")
+
             # Write updated header info
-            if self._zinfo.flag_bits & 0x08:
+            if self._zinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
                 # Write CRC and file sizes after the file data
                 fmt = '<LLQQ' if self._zip64 else '<LLLL'
                 self._fileobj.write(struct.pack(fmt, _DD_SIGNATURE, self._zinfo.CRC,
                     self._zinfo.compress_size, self._zinfo.file_size))
                 self._zipfile.start_dir = self._fileobj.tell()
             else:
-                if not self._zip64:
-                    if self._file_size > ZIP64_LIMIT:
-                        raise RuntimeError(
-                            'File size unexpectedly exceeded ZIP64 limit')
-                    if self._compress_size > ZIP64_LIMIT:
-                        raise RuntimeError(
-                            'Compressed size unexpectedly exceeded ZIP64 limit')
                 # Seek backwards and write file header (which will now include
                 # correct CRC and file sizes)
 
@@ -1223,7 +1326,7 @@ class ZipFile:
     _windows_illegal_name_trans_table = None
 
     def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
-                 compresslevel=None, *, strict_timestamps=True):
+                 compresslevel=None, *, strict_timestamps=True, metadata_encoding=None):
         """Open the ZIP file with mode read 'r', write 'w', exclusive create 'x',
         or append 'a'."""
         if mode not in ('r', 'w', 'x', 'a'):
@@ -1242,6 +1345,12 @@ def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
         self.pwd = None
         self._comment = b''
         self._strict_timestamps = strict_timestamps
+        self.metadata_encoding = metadata_encoding
+
+        # Check that we don't try to write with nonconforming codecs
+        if self.metadata_encoding and mode != 'r':
+            raise ValueError(
+                "metadata_encoding is only supported for reading files")
 
         # Check if we were passed a file-like object
         if isinstance(file, os.PathLike):
@@ -1374,13 +1483,14 @@ def _RealGetContents(self):
             if self.debug > 2:
                 print(centdir)
             filename = fp.read(centdir[_CD_FILENAME_LENGTH])
-            flags = centdir[5]
-            if flags & 0x800:
+            orig_filename_crc = crc32(filename)
+            flags = centdir[_CD_FLAG_BITS]
+            if flags & _MASK_UTF_FILENAME:
                 # UTF-8 file names extension
                 filename = filename.decode('utf-8')
             else:
                 # Historical ZIP filename encoding
-                filename = filename.decode('cp437')
+                filename = filename.decode(self.metadata_encoding or 'cp437')
             # Create ZipInfo instance to store file information
             x = ZipInfo(filename)
             x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
@@ -1397,8 +1507,7 @@ def _RealGetContents(self):
             x._raw_time = t
             x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
                             t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
-
-            x._decodeExtra()
+            x._decodeExtra(orig_filename_crc)
             x.header_offset = x.header_offset + concat
             self.filelist.append(x)
             self.NameToInfo[x.filename] = x
@@ -1411,6 +1520,11 @@ def _RealGetContents(self):
             if self.debug > 2:
                 print("total", total)
 
+        end_offset = self.start_dir
+        for zinfo in reversed(sorted(self.filelist,
+                                     key=lambda zinfo: zinfo.header_offset)):
+            zinfo._end_offset = end_offset
+            end_offset = zinfo.header_offset
 
     def namelist(self):
         """Return a list of file names in the archive."""
@@ -1431,7 +1545,10 @@ def printdir(self, file=None):
                   file=file)
 
     def testzip(self):
-        """Read all the files and check the CRC."""
+        """Read all the files and check the CRC.
+
+        Return None if all files could be read successfully, or the name
+        of the offending file otherwise."""
         chunk_size = 2 ** 20
         for zinfo in self.filelist:
             try:
@@ -1480,7 +1597,8 @@ def comment(self, comment):
         self._didModify = True
 
     def read(self, name, pwd=None):
-        """Return file bytes for name."""
+        """Return file bytes for name. 'pwd' is the password to decrypt
+        encrypted files."""
         with self.open(name, "r", pwd) as fp:
             return fp.read()
 
@@ -1502,8 +1620,6 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
         """
         if mode not in {"r", "w"}:
             raise ValueError('open() requires mode "r" or "w"')
-        if pwd and not isinstance(pwd, bytes):
-            raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
         if pwd and (mode == "w"):
             raise ValueError("pwd is only supported for reading files")
         if not self.fp:
@@ -1517,7 +1633,7 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
         elif mode == 'w':
             zinfo = ZipInfo(name)
             zinfo.compress_type = self.compression
-            zinfo._compresslevel = self.compresslevel
+            zinfo.compress_level = self.compresslevel
         else:
             # Get info object for name
             zinfo = self.getinfo(name)
@@ -1545,39 +1661,54 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
 
             fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
             if fheader[_FH_EXTRA_FIELD_LENGTH]:
-                zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])
+                zef_file.seek(fheader[_FH_EXTRA_FIELD_LENGTH], whence=1)
 
-            if zinfo.flag_bits & 0x20:
+            if zinfo.flag_bits & _MASK_COMPRESSED_PATCH:
                 # Zip 2.7: compressed patched data
                 raise NotImplementedError("compressed patched data (flag bit 5)")
 
-            if zinfo.flag_bits & 0x40:
+            if zinfo.flag_bits & _MASK_STRONG_ENCRYPTION:
                 # strong encryption
                 raise NotImplementedError("strong encryption (flag bit 6)")
 
-            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & 0x800:
+            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME:
                 # UTF-8 filename
                 fname_str = fname.decode("utf-8")
             else:
-                fname_str = fname.decode("cp437")
+                fname_str = fname.decode(self.metadata_encoding or "cp437")
 
             if fname_str != zinfo.orig_filename:
                 raise BadZipFile(
                     'File name in directory %r and header %r differ.'
                     % (zinfo.orig_filename, fname))
 
+            if (zinfo._end_offset is not None and
+                zef_file.tell() + zinfo.compress_size > zinfo._end_offset):
+                if zinfo._end_offset == zinfo.header_offset:
+                    import warnings
+                    warnings.warn(
+                        f"Overlapped entries: {zinfo.orig_filename!r} "
+                        f"(possible zip bomb)",
+                        skip_file_prefixes=(os.path.dirname(__file__),))
+                else:
+                    raise BadZipFile(
+                        f"Overlapped entries: {zinfo.orig_filename!r} "
+                        f"(possible zip bomb)")
+
             # check for encrypted flag & handle password
-            is_encrypted = zinfo.flag_bits & 0x1
+            is_encrypted = zinfo.flag_bits & _MASK_ENCRYPTED
             if is_encrypted:
                 if not pwd:
                     pwd = self.pwd
+                if pwd and not isinstance(pwd, bytes):
+                    raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
                 if not pwd:
                     raise RuntimeError("File %r is encrypted, password "
                                        "required for extraction" % name)
             else:
                 pwd = None
 
-            return ZipExtFile(zef_file, mode, zinfo, pwd, True)
+            return ZipExtFile(zef_file, mode + 'b', zinfo, pwd, True)
         except:
             zef_file.close()
             raise
@@ -1600,16 +1731,17 @@ def _open_to_write(self, zinfo, force_zip64=False):
         zinfo.flag_bits = 0x00
         if zinfo.compress_type == ZIP_LZMA:
             # Compressed data includes an end-of-stream (EOS) marker
-            zinfo.flag_bits |= 0x02
+            zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1
         if not self._seekable:
-            zinfo.flag_bits |= 0x08
+            zinfo.flag_bits |= _MASK_USE_DATA_DESCRIPTOR
 
         if not zinfo.external_attr:
             zinfo.external_attr = 0o600 << 16  # permissions: ?rw-------
 
         # Compressed size can be larger than uncompressed size
-        zip64 = self._allowZip64 and \
-                (force_zip64 or zinfo.file_size * 1.05 > ZIP64_LIMIT)
+        zip64 = force_zip64 or (zinfo.file_size * 1.05 > ZIP64_LIMIT)
+        if not self._allowZip64 and zip64:
+            raise LargeZipFile("Filesize would require ZIP64 extensions")
 
         if self._seekable:
             self.fp.seek(self.start_dir)
@@ -1627,7 +1759,8 @@ def extract(self, member, path=None, pwd=None):
         """Extract a member from the archive to the current working directory,
            using its full name. Its file information is extracted as accurately
            as possible. `member' may be a filename or a ZipInfo object. You can
-           specify a different directory using `path'.
+           specify a different directory using `path'. You can specify the
+           password to decrypt the file using 'pwd'.
         """
         if path is None:
             path = os.getcwd()
@@ -1640,7 +1773,8 @@ def extractall(self, path=None, members=None, pwd=None):
         """Extract all members from the archive to the current working
            directory. `path' specifies a different directory to extract to.
            `members' is optional and must be a subset of the list returned
-           by namelist().
+           by namelist(). You can specify the password to decrypt all files
+           using 'pwd'.
         """
         if members is None:
             members = self.namelist()
@@ -1662,8 +1796,8 @@ def _sanitize_windows_name(cls, arcname, pathsep):
             table = str.maketrans(illegal, '_' * len(illegal))
             cls._windows_illegal_name_trans_table = table
         arcname = arcname.translate(table)
-        # remove trailing dots
-        arcname = (x.rstrip('.') for x in arcname.split(pathsep))
+        # remove trailing dots and spaces
+        arcname = (x.rstrip(' .') for x in arcname.split(pathsep))
         # rejoin, removing empty parts.
         arcname = pathsep.join(x for x in arcname if x)
         return arcname
@@ -1691,17 +1825,24 @@ def _extract_member(self, member, targetpath, pwd):
             # filter illegal characters on Windows
             arcname = self._sanitize_windows_name(arcname, os.path.sep)
 
+        if not arcname and not member.is_dir():
+            raise ValueError("Empty filename.")
+
         targetpath = os.path.join(targetpath, arcname)
         targetpath = os.path.normpath(targetpath)
 
         # Create all upper directories if necessary.
         upperdirs = os.path.dirname(targetpath)
         if upperdirs and not os.path.exists(upperdirs):
-            os.makedirs(upperdirs)
+            os.makedirs(upperdirs, exist_ok=True)
 
         if member.is_dir():
             if not os.path.isdir(targetpath):
-                os.mkdir(targetpath)
+                try:
+                    os.mkdir(targetpath)
+                except FileExistsError:
+                    if not os.path.isdir(targetpath):
+                        raise
             return targetpath
 
         with self.open(member, pwd=pwd) as source, \
@@ -1751,6 +1892,7 @@ def write(self, filename, arcname=None,
         if zinfo.is_dir():
             zinfo.compress_size = 0
             zinfo.CRC = 0
+            self.mkdir(zinfo)
         else:
             if compress_type is not None:
                 zinfo.compress_type = compress_type
@@ -1758,27 +1900,10 @@ def write(self, filename, arcname=None,
                 zinfo.compress_type = self.compression
 
             if compresslevel is not None:
-                zinfo._compresslevel = compresslevel
+                zinfo.compress_level = compresslevel
             else:
-                zinfo._compresslevel = self.compresslevel
+                zinfo.compress_level = self.compresslevel
 
-        if zinfo.is_dir():
-            with self._lock:
-                if self._seekable:
-                    self.fp.seek(self.start_dir)
-                zinfo.header_offset = self.fp.tell()  # Start of header bytes
-                if zinfo.compress_type == ZIP_LZMA:
-                # Compressed data includes an end-of-stream (EOS) marker
-                    zinfo.flag_bits |= 0x02
-
-                self._writecheck(zinfo)
-                self._didModify = True
-
-                self.filelist.append(zinfo)
-                self.NameToInfo[zinfo.filename] = zinfo
-                self.fp.write(zinfo.FileHeader(False))
-                self.start_dir = self.fp.tell()
-        else:
             with open(filename, "rb") as src, self.open(zinfo, 'w') as dest:
                 shutil.copyfileobj(src, dest, 1024*8)
 
@@ -1795,8 +1920,8 @@ def writestr(self, zinfo_or_arcname, data,
             zinfo = ZipInfo(filename=zinfo_or_arcname,
                             date_time=time.localtime(time.time())[:6])
             zinfo.compress_type = self.compression
-            zinfo._compresslevel = self.compresslevel
-            if zinfo.filename[-1] == '/':
+            zinfo.compress_level = self.compresslevel
+            if zinfo.filename.endswith('/'):
                 zinfo.external_attr = 0o40775 << 16   # drwxrwxr-x
                 zinfo.external_attr |= 0x10           # MS-DOS directory flag
             else:
@@ -1816,13 +1941,48 @@ def writestr(self, zinfo_or_arcname, data,
             zinfo.compress_type = compress_type
 
         if compresslevel is not None:
-            zinfo._compresslevel = compresslevel
+            zinfo.compress_level = compresslevel
 
         zinfo.file_size = len(data)            # Uncompressed size
         with self._lock:
             with self.open(zinfo, mode='w') as dest:
                 dest.write(data)
 
+    def mkdir(self, zinfo_or_directory_name, mode=511):
+        """Creates a directory inside the zip archive."""
+        if isinstance(zinfo_or_directory_name, ZipInfo):
+            zinfo = zinfo_or_directory_name
+            if not zinfo.is_dir():
+                raise ValueError("The given ZipInfo does not describe a directory")
+        elif isinstance(zinfo_or_directory_name, str):
+            directory_name = zinfo_or_directory_name
+            if not directory_name.endswith("/"):
+                directory_name += "/"
+            zinfo = ZipInfo(directory_name)
+            zinfo.compress_size = 0
+            zinfo.CRC = 0
+            zinfo.external_attr = ((0o40000 | mode) & 0xFFFF) << 16
+            zinfo.file_size = 0
+            zinfo.external_attr |= 0x10
+        else:
+            raise TypeError("Expected type str or ZipInfo")
+
+        with self._lock:
+            if self._seekable:
+                self.fp.seek(self.start_dir)
+            zinfo.header_offset = self.fp.tell()  # Start of header bytes
+            if zinfo.compress_type == ZIP_LZMA:
+            # Compressed data includes an end-of-stream (EOS) marker
+                zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1
+
+            self._writecheck(zinfo)
+            self._didModify = True
+
+            self.filelist.append(zinfo)
+            self.NameToInfo[zinfo.filename] = zinfo
+            self.fp.write(zinfo.FileHeader(False))
+            self.start_dir = self.fp.tell()
+
     def __del__(self):
         """Call the "close()" method in case the user forgot."""
         self.close()
@@ -1875,7 +2035,7 @@ def _write_end_record(self):
             min_version = 0
             if extra:
                 # Append a ZIP64 field to the extra's
-                extra_data = _strip_extra(extra_data, (1,))
+                extra_data = _Extra.strip(extra_data, (1,))
                 extra_data = struct.pack(
                     '<HH' + 'Q'*len(extra),
                     1, 8*len(extra), *extra) + extra_data
@@ -2124,300 +2284,6 @@ def _compile(file, optimize=-1):
         return (fname, archivename)
 
 
-def _parents(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all parents of that path.
-
-    >>> list(_parents('b/d'))
-    ['b']
-    >>> list(_parents('/b/d/'))
-    ['/b']
-    >>> list(_parents('b/d/f/'))
-    ['b/d', 'b']
-    >>> list(_parents('b'))
-    []
-    >>> list(_parents(''))
-    []
-    """
-    return itertools.islice(_ancestry(path), 1, None)
-
-
-def _ancestry(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all elements of that path
-
-    >>> list(_ancestry('b/d'))
-    ['b/d', 'b']
-    >>> list(_ancestry('/b/d/'))
-    ['/b/d', '/b']
-    >>> list(_ancestry('b/d/f/'))
-    ['b/d/f', 'b/d', 'b']
-    >>> list(_ancestry('b'))
-    ['b']
-    >>> list(_ancestry(''))
-    []
-    """
-    path = path.rstrip(posixpath.sep)
-    while path and path != posixpath.sep:
-        yield path
-        path, tail = posixpath.split(path)
-
-
-_dedupe = dict.fromkeys
-"""Deduplicate an iterable in original order"""
-
-
-def _difference(minuend, subtrahend):
-    """
-    Return items in minuend not in subtrahend, retaining order
-    with O(1) lookup.
-    """
-    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
-
-
-class CompleteDirs(ZipFile):
-    """
-    A ZipFile subclass that ensures that implied directories
-    are always included in the namelist.
-    """
-
-    @staticmethod
-    def _implied_dirs(names):
-        parents = itertools.chain.from_iterable(map(_parents, names))
-        as_dirs = (p + posixpath.sep for p in parents)
-        return _dedupe(_difference(as_dirs, names))
-
-    def namelist(self):
-        names = super(CompleteDirs, self).namelist()
-        return names + list(self._implied_dirs(names))
-
-    def _name_set(self):
-        return set(self.namelist())
-
-    def resolve_dir(self, name):
-        """
-        If the name represents a directory, return that name
-        as a directory (with the trailing slash).
-        """
-        names = self._name_set()
-        dirname = name + '/'
-        dir_match = name not in names and dirname in names
-        return dirname if dir_match else name
-
-    @classmethod
-    def make(cls, source):
-        """
-        Given a source (filename or zipfile), return an
-        appropriate CompleteDirs subclass.
-        """
-        if isinstance(source, CompleteDirs):
-            return source
-
-        if not isinstance(source, ZipFile):
-            return cls(source)
-
-        # Only allow for FastLookup when supplied zipfile is read-only
-        if 'r' not in source.mode:
-            cls = CompleteDirs
-
-        source.__class__ = cls
-        return source
-
-
-class FastLookup(CompleteDirs):
-    """
-    ZipFile subclass to ensure implicit
-    dirs exist and are resolved rapidly.
-    """
-
-    def namelist(self):
-        with contextlib.suppress(AttributeError):
-            return self.__names
-        self.__names = super(FastLookup, self).namelist()
-        return self.__names
-
-    def _name_set(self):
-        with contextlib.suppress(AttributeError):
-            return self.__lookup
-        self.__lookup = super(FastLookup, self)._name_set()
-        return self.__lookup
-
-
-class Path:
-    """
-    A pathlib-compatible interface for zip files.
-
-    Consider a zip file with this structure::
-
-        .
-        ├── a.txt
-        └── b
-            ├── c.txt
-            └── d
-                └── e.txt
-
-    >>> data = io.BytesIO()
-    >>> zf = ZipFile(data, 'w')
-    >>> zf.writestr('a.txt', 'content of a')
-    >>> zf.writestr('b/c.txt', 'content of c')
-    >>> zf.writestr('b/d/e.txt', 'content of e')
-    >>> zf.filename = 'mem/abcde.zip'
-
-    Path accepts the zipfile object itself or a filename
-
-    >>> root = Path(zf)
-
-    From there, several path operations are available.
-
-    Directory iteration (including the zip file itself):
-
-    >>> a, b = root.iterdir()
-    >>> a
-    Path('mem/abcde.zip', 'a.txt')
-    >>> b
-    Path('mem/abcde.zip', 'b/')
-
-    name property:
-
-    >>> b.name
-    'b'
-
-    join with divide operator:
-
-    >>> c = b / 'c.txt'
-    >>> c
-    Path('mem/abcde.zip', 'b/c.txt')
-    >>> c.name
-    'c.txt'
-
-    Read text:
-
-    >>> c.read_text()
-    'content of c'
-
-    existence:
-
-    >>> c.exists()
-    True
-    >>> (b / 'missing.txt').exists()
-    False
-
-    Coercion to string:
-
-    >>> import os
-    >>> str(c).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip/b/c.txt'
-
-    At the root, ``name``, ``filename``, and ``parent``
-    resolve to the zipfile. Note these attributes are not
-    valid and will raise a ``ValueError`` if the zipfile
-    has no filename.
-
-    >>> root.name
-    'abcde.zip'
-    >>> str(root.filename).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip'
-    >>> str(root.parent)
-    'mem'
-    """
-
-    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
-
-    def __init__(self, root, at=""):
-        """
-        Construct a Path from a ZipFile or filename.
-
-        Note: When the source is an existing ZipFile object,
-        its type (__class__) will be mutated to a
-        specialized type. If the caller wishes to retain the
-        original type, the caller should either create a
-        separate ZipFile object or pass a filename.
-        """
-        self.root = FastLookup.make(root)
-        self.at = at
-
-    def open(self, mode='r', *args, pwd=None, **kwargs):
-        """
-        Open this entry as text or binary following the semantics
-        of ``pathlib.Path.open()`` by passing arguments through
-        to io.TextIOWrapper().
-        """
-        if self.is_dir():
-            raise IsADirectoryError(self)
-        zip_mode = mode[0]
-        if not self.exists() and zip_mode == 'r':
-            raise FileNotFoundError(self)
-        stream = self.root.open(self.at, zip_mode, pwd=pwd)
-        if 'b' in mode:
-            if args or kwargs:
-                raise ValueError("encoding args invalid for binary operation")
-            return stream
-        else:
-            kwargs["encoding"] = io.text_encoding(kwargs.get("encoding"))
-        return io.TextIOWrapper(stream, *args, **kwargs)
-
-    @property
-    def name(self):
-        return pathlib.Path(self.at).name or self.filename.name
-
-    @property
-    def filename(self):
-        return pathlib.Path(self.root.filename).joinpath(self.at)
-
-    def read_text(self, *args, **kwargs):
-        kwargs["encoding"] = io.text_encoding(kwargs.get("encoding"))
-        with self.open('r', *args, **kwargs) as strm:
-            return strm.read()
-
-    def read_bytes(self):
-        with self.open('rb') as strm:
-            return strm.read()
-
-    def _is_child(self, path):
-        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
-
-    def _next(self, at):
-        return self.__class__(self.root, at)
-
-    def is_dir(self):
-        return not self.at or self.at.endswith("/")
-
-    def is_file(self):
-        return self.exists() and not self.is_dir()
-
-    def exists(self):
-        return self.at in self.root._name_set()
-
-    def iterdir(self):
-        if not self.is_dir():
-            raise ValueError("Can't listdir a file")
-        subs = map(self._next, self.root.namelist())
-        return filter(self._is_child, subs)
-
-    def __str__(self):
-        return posixpath.join(self.root.filename, self.at)
-
-    def __repr__(self):
-        return self.__repr.format(self=self)
-
-    def joinpath(self, *other):
-        next = posixpath.join(self.at, *other)
-        return self._next(self.root.resolve_dir(next))
-
-    __truediv__ = joinpath
-
-    @property
-    def parent(self):
-        if not self.at:
-            return self.filename.parent
-        parent_at = posixpath.dirname(self.at.rstrip('/'))
-        if parent_at:
-            parent_at += '/'
-        return self._next(parent_at)
-
-
 def main(args=None):
     import argparse
 
@@ -2434,11 +2300,15 @@ def main(args=None):
                        help='Create zipfile from sources')
     group.add_argument('-t', '--test', metavar='<zipfile>',
                        help='Test if a zipfile is valid')
+    parser.add_argument('--metadata-encoding', metavar='<encoding>',
+                        help='Specify encoding of member names for -l, -e and -t')
     args = parser.parse_args(args)
 
+    encoding = args.metadata_encoding
+
     if args.test is not None:
         src = args.test
-        with ZipFile(src, 'r') as zf:
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
             badfile = zf.testzip()
         if badfile:
             print("The following enclosed file is corrupted: {!r}".format(badfile))
@@ -2446,15 +2316,20 @@ def main(args=None):
 
     elif args.list is not None:
         src = args.list
-        with ZipFile(src, 'r') as zf:
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
             zf.printdir()
 
     elif args.extract is not None:
         src, curdir = args.extract
-        with ZipFile(src, 'r') as zf:
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
             zf.extractall(curdir)
 
     elif args.create is not None:
+        if encoding:
+            print("Non-conforming encodings not supported with -c.",
+                  file=sys.stderr)
+            sys.exit(1)
+
         zip_name = args.create.pop(0)
         files = args.create
 
@@ -2479,5 +2354,9 @@ def addToZip(zf, path, zippath):
                 addToZip(zf, path, zippath)
 
 
-if __name__ == "__main__":
-    main()
+from ._path import (  # noqa: E402
+    Path,
+
+    # used privately for tests
+    CompleteDirs,  # noqa: F401
+)
diff --git a/Lib/zipfile/__main__.py b/Lib/zipfile/__main__.py
new file mode 100644
index 00000000000..868d99efc3c
--- /dev/null
+++ b/Lib/zipfile/__main__.py
@@ -0,0 +1,4 @@
+from . import main
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/zipfile/_path/__init__.py b/Lib/zipfile/_path/__init__.py
new file mode 100644
index 00000000000..02f81171b4f
--- /dev/null
+++ b/Lib/zipfile/_path/__init__.py
@@ -0,0 +1,452 @@
+"""
+A Path-like interface for zipfiles.
+
+This codebase is shared between zipfile.Path in the stdlib
+and zipp in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
+
+import contextlib
+import io
+import itertools
+import pathlib
+import posixpath
+import re
+import stat
+import sys
+import zipfile
+
+from .glob import Translator
+
+__all__ = ['Path']
+
+
+def _parents(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all parents of that path.
+
+    >>> list(_parents('b/d'))
+    ['b']
+    >>> list(_parents('/b/d/'))
+    ['/b']
+    >>> list(_parents('b/d/f/'))
+    ['b/d', 'b']
+    >>> list(_parents('b'))
+    []
+    >>> list(_parents(''))
+    []
+    """
+    return itertools.islice(_ancestry(path), 1, None)
+
+
+def _ancestry(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all elements of that path.
+
+    >>> list(_ancestry('b/d'))
+    ['b/d', 'b']
+    >>> list(_ancestry('/b/d/'))
+    ['/b/d', '/b']
+    >>> list(_ancestry('b/d/f/'))
+    ['b/d/f', 'b/d', 'b']
+    >>> list(_ancestry('b'))
+    ['b']
+    >>> list(_ancestry(''))
+    []
+
+    Multiple separators are treated like a single.
+
+    >>> list(_ancestry('//b//d///f//'))
+    ['//b//d///f', '//b//d', '//b']
+    """
+    path = path.rstrip(posixpath.sep)
+    while path.rstrip(posixpath.sep):
+        yield path
+        path, tail = posixpath.split(path)
+
+
+_dedupe = dict.fromkeys
+"""Deduplicate an iterable in original order"""
+
+
+def _difference(minuend, subtrahend):
+    """
+    Return items in minuend not in subtrahend, retaining order
+    with O(1) lookup.
+    """
+    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
+
+
+class InitializedState:
+    """
+    Mix-in to save the initialization state for pickling.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__args = args
+        self.__kwargs = kwargs
+        super().__init__(*args, **kwargs)
+
+    def __getstate__(self):
+        return self.__args, self.__kwargs
+
+    def __setstate__(self, state):
+        args, kwargs = state
+        super().__init__(*args, **kwargs)
+
+
+class CompleteDirs(InitializedState, zipfile.ZipFile):
+    """
+    A ZipFile subclass that ensures that implied directories
+    are always included in the namelist.
+
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt']))
+    ['foo/', 'foo/bar/']
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt', 'foo/bar/']))
+    ['foo/']
+    """
+
+    @staticmethod
+    def _implied_dirs(names):
+        parents = itertools.chain.from_iterable(map(_parents, names))
+        as_dirs = (p + posixpath.sep for p in parents)
+        return _dedupe(_difference(as_dirs, names))
+
+    def namelist(self):
+        names = super().namelist()
+        return names + list(self._implied_dirs(names))
+
+    def _name_set(self):
+        return set(self.namelist())
+
+    def resolve_dir(self, name):
+        """
+        If the name represents a directory, return that name
+        as a directory (with the trailing slash).
+        """
+        names = self._name_set()
+        dirname = name + '/'
+        dir_match = name not in names and dirname in names
+        return dirname if dir_match else name
+
+    def getinfo(self, name):
+        """
+        Supplement getinfo for implied dirs.
+        """
+        try:
+            return super().getinfo(name)
+        except KeyError:
+            if not name.endswith('/') or name not in self._name_set():
+                raise
+            return zipfile.ZipInfo(filename=name)
+
+    @classmethod
+    def make(cls, source):
+        """
+        Given a source (filename or zipfile), return an
+        appropriate CompleteDirs subclass.
+        """
+        if isinstance(source, CompleteDirs):
+            return source
+
+        if not isinstance(source, zipfile.ZipFile):
+            return cls(source)
+
+        # Only allow for FastLookup when supplied zipfile is read-only
+        if 'r' not in source.mode:
+            cls = CompleteDirs
+
+        source.__class__ = cls
+        return source
+
+    @classmethod
+    def inject(cls, zf: zipfile.ZipFile) -> zipfile.ZipFile:
+        """
+        Given a writable zip file zf, inject directory entries for
+        any directories implied by the presence of children.
+        """
+        for name in cls._implied_dirs(zf.namelist()):
+            zf.writestr(name, b"")
+        return zf
+
+
+class FastLookup(CompleteDirs):
+    """
+    ZipFile subclass to ensure implicit
+    dirs exist and are resolved rapidly.
+    """
+
+    def namelist(self):
+        with contextlib.suppress(AttributeError):
+            return self.__names
+        self.__names = super().namelist()
+        return self.__names
+
+    def _name_set(self):
+        with contextlib.suppress(AttributeError):
+            return self.__lookup
+        self.__lookup = super()._name_set()
+        return self.__lookup
+
+def _extract_text_encoding(encoding=None, *args, **kwargs):
+    # compute stack level so that the caller of the caller sees any warning.
+    is_pypy = sys.implementation.name == 'pypy'
+    # PyPy no longer special cased after 7.3.19 (or maybe 7.3.18)
+    # See jaraco/zipp#143
+    is_old_pypi = is_pypy and sys.pypy_version_info < (7, 3, 19)
+    stack_level = 3 + is_old_pypi
+    return io.text_encoding(encoding, stack_level), args, kwargs
+
+
+class Path:
+    """
+    A :class:`importlib.resources.abc.Traversable` interface for zip files.
+
+    Implements many of the features users enjoy from
+    :class:`pathlib.Path`.
+
+    Consider a zip file with this structure::
+
+        .
+        ├── a.txt
+        └── b
+            ├── c.txt
+            └── d
+                └── e.txt
+
+    >>> data = io.BytesIO()
+    >>> zf = ZipFile(data, 'w')
+    >>> zf.writestr('a.txt', 'content of a')
+    >>> zf.writestr('b/c.txt', 'content of c')
+    >>> zf.writestr('b/d/e.txt', 'content of e')
+    >>> zf.filename = 'mem/abcde.zip'
+
+    Path accepts the zipfile object itself or a filename
+
+    >>> path = Path(zf)
+
+    From there, several path operations are available.
+
+    Directory iteration (including the zip file itself):
+
+    >>> a, b = path.iterdir()
+    >>> a
+    Path('mem/abcde.zip', 'a.txt')
+    >>> b
+    Path('mem/abcde.zip', 'b/')
+
+    name property:
+
+    >>> b.name
+    'b'
+
+    join with divide operator:
+
+    >>> c = b / 'c.txt'
+    >>> c
+    Path('mem/abcde.zip', 'b/c.txt')
+    >>> c.name
+    'c.txt'
+
+    Read text:
+
+    >>> c.read_text(encoding='utf-8')
+    'content of c'
+
+    existence:
+
+    >>> c.exists()
+    True
+    >>> (b / 'missing.txt').exists()
+    False
+
+    Coercion to string:
+
+    >>> import os
+    >>> str(c).replace(os.sep, posixpath.sep)
+    'mem/abcde.zip/b/c.txt'
+
+    At the root, ``name``, ``filename``, and ``parent``
+    resolve to the zipfile.
+
+    >>> str(path)
+    'mem/abcde.zip/'
+    >>> path.name
+    'abcde.zip'
+    >>> path.filename == pathlib.Path('mem/abcde.zip')
+    True
+    >>> str(path.parent)
+    'mem'
+
+    If the zipfile has no filename, such attributes are not
+    valid and accessing them will raise an Exception.
+
+    >>> zf.filename = None
+    >>> path.name
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.filename
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.parent
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    # workaround python/cpython#106763
+    >>> pass
+    """
+
+    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
+
+    def __init__(self, root, at=""):
+        """
+        Construct a Path from a ZipFile or filename.
+
+        Note: When the source is an existing ZipFile object,
+        its type (__class__) will be mutated to a
+        specialized type. If the caller wishes to retain the
+        original type, the caller should either create a
+        separate ZipFile object or pass a filename.
+        """
+        self.root = FastLookup.make(root)
+        self.at = at
+
+    def __eq__(self, other):
+        """
+        >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo'
+        False
+        """
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return (self.root, self.at) == (other.root, other.at)
+
+    def __hash__(self):
+        return hash((self.root, self.at))
+
+    def open(self, mode='r', *args, pwd=None, **kwargs):
+        """
+        Open this entry as text or binary following the semantics
+        of ``pathlib.Path.open()`` by passing arguments through
+        to io.TextIOWrapper().
+        """
+        if self.is_dir():
+            raise IsADirectoryError(self)
+        zip_mode = mode[0]
+        if zip_mode == 'r' and not self.exists():
+            raise FileNotFoundError(self)
+        stream = self.root.open(self.at, zip_mode, pwd=pwd)
+        if 'b' in mode:
+            if args or kwargs:
+                raise ValueError("encoding args invalid for binary operation")
+            return stream
+        # Text mode:
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        return io.TextIOWrapper(stream, encoding, *args, **kwargs)
+
+    def _base(self):
+        return pathlib.PurePosixPath(self.at) if self.at else self.filename
+
+    @property
+    def name(self):
+        return self._base().name
+
+    @property
+    def suffix(self):
+        return self._base().suffix
+
+    @property
+    def suffixes(self):
+        return self._base().suffixes
+
+    @property
+    def stem(self):
+        return self._base().stem
+
+    @property
+    def filename(self):
+        return pathlib.Path(self.root.filename).joinpath(self.at)
+
+    def read_text(self, *args, **kwargs):
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        with self.open('r', encoding, *args, **kwargs) as strm:
+            return strm.read()
+
+    def read_bytes(self):
+        with self.open('rb') as strm:
+            return strm.read()
+
+    def _is_child(self, path):
+        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
+
+    def _next(self, at):
+        return self.__class__(self.root, at)
+
+    def is_dir(self):
+        return not self.at or self.at.endswith("/")
+
+    def is_file(self):
+        return self.exists() and not self.is_dir()
+
+    def exists(self):
+        return self.at in self.root._name_set()
+
+    def iterdir(self):
+        if not self.is_dir():
+            raise ValueError("Can't listdir a file")
+        subs = map(self._next, self.root.namelist())
+        return filter(self._is_child, subs)
+
+    def match(self, path_pattern):
+        return pathlib.PurePosixPath(self.at).match(path_pattern)
+
+    def is_symlink(self):
+        """
+        Return whether this path is a symlink.
+        """
+        info = self.root.getinfo(self.at)
+        mode = info.external_attr >> 16
+        return stat.S_ISLNK(mode)
+
+    def glob(self, pattern):
+        if not pattern:
+            raise ValueError(f"Unacceptable pattern: {pattern!r}")
+
+        prefix = re.escape(self.at)
+        tr = Translator(seps='/')
+        matches = re.compile(prefix + tr.translate(pattern)).fullmatch
+        return map(self._next, filter(matches, self.root.namelist()))
+
+    def rglob(self, pattern):
+        return self.glob(f'**/{pattern}')
+
+    def relative_to(self, other, *extra):
+        return posixpath.relpath(str(self), str(other.joinpath(*extra)))
+
+    def __str__(self):
+        return posixpath.join(self.root.filename, self.at)
+
+    def __repr__(self):
+        return self.__repr.format(self=self)
+
+    def joinpath(self, *other):
+        next = posixpath.join(self.at, *other)
+        return self._next(self.root.resolve_dir(next))
+
+    __truediv__ = joinpath
+
+    @property
+    def parent(self):
+        if not self.at:
+            return self.filename.parent
+        parent_at = posixpath.dirname(self.at.rstrip('/'))
+        if parent_at:
+            parent_at += '/'
+        return self._next(parent_at)
diff --git a/Lib/zipfile/_path/glob.py b/Lib/zipfile/_path/glob.py
new file mode 100644
index 00000000000..4ed74cc48d9
--- /dev/null
+++ b/Lib/zipfile/_path/glob.py
@@ -0,0 +1,113 @@
+import os
+import re
+
+_default_seps = os.sep + str(os.altsep) * bool(os.altsep)
+
+
+class Translator:
+    """
+    >>> Translator('xyz')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+
+    >>> Translator('')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+    """
+
+    seps: str
+
+    def __init__(self, seps: str = _default_seps):
+        assert seps and set(seps) <= set(_default_seps), "Invalid separators"
+        self.seps = seps
+
+    def translate(self, pattern):
+        """
+        Given a glob pattern, produce a regex that matches it.
+        """
+        return self.extend(self.match_dirs(self.translate_core(pattern)))
+
+    def extend(self, pattern):
+        r"""
+        Extend regex for pattern-wide concerns.
+
+        Apply '(?s:)' to create a non-matching group that
+        matches newlines (valid on Unix).
+
+        Append '\Z' to imply fullmatch even when match is used.
+        """
+        return rf'(?s:{pattern})\Z'
+
+    def match_dirs(self, pattern):
+        """
+        Ensure that zipfile.Path directory names are matched.
+
+        zipfile.Path directory names always end in a slash.
+        """
+        return rf'{pattern}[/]?'
+
+    def translate_core(self, pattern):
+        r"""
+        Given a glob pattern, produce a regex that matches it.
+
+        >>> t = Translator()
+        >>> t.translate_core('*.txt').replace('\\\\', '')
+        '[^/]*\\.txt'
+        >>> t.translate_core('a?txt')
+        'a[^/]txt'
+        >>> t.translate_core('**/*').replace('\\\\', '')
+        '.*/[^/][^/]*'
+        """
+        self.restrict_rglob(pattern)
+        return ''.join(map(self.replace, separate(self.star_not_empty(pattern))))
+
+    def replace(self, match):
+        """
+        Perform the replacements for a match from :func:`separate`.
+        """
+        return match.group('set') or (
+            re.escape(match.group(0))
+            .replace('\\*\\*', r'.*')
+            .replace('\\*', rf'[^{re.escape(self.seps)}]*')
+            .replace('\\?', r'[^/]')
+        )
+
+    def restrict_rglob(self, pattern):
+        """
+        Raise ValueError if ** appears in anything but a full path segment.
+
+        >>> Translator().translate('**foo')
+        Traceback (most recent call last):
+        ...
+        ValueError: ** must appear alone in a path segment
+        """
+        seps_pattern = rf'[{re.escape(self.seps)}]+'
+        segments = re.split(seps_pattern, pattern)
+        if any('**' in segment and segment != '**' for segment in segments):
+            raise ValueError("** must appear alone in a path segment")
+
+    def star_not_empty(self, pattern):
+        """
+        Ensure that * will not match an empty segment.
+        """
+
+        def handle_segment(match):
+            segment = match.group(0)
+            return '?*' if segment == '*' else segment
+
+        not_seps_pattern = rf'[^{re.escape(self.seps)}]+'
+        return re.sub(not_seps_pattern, handle_segment, pattern)
+
+
+def separate(pattern):
+    """
+    Separate out character sets to avoid translating their contents.
+
+    >>> [m.group(0) for m in separate('*.txt')]
+    ['*.txt']
+    >>> [m.group(0) for m in separate('a[?]txt')]
+    ['a', '[?]', 'txt']
+    """
+    return re.finditer(r'([^\[]+)|(?P<set>[\[].*?[\]])|([\[][^\]]*$)', pattern)

From dac236dac077d737298d7570d10b5833a8c64f62 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 15:15:02 +0900
Subject: [PATCH 119/418] more no_std clippy (#6587)

---
 crates/common/src/os.rs               |  2 +-
 crates/jit/tests/common.rs            |  2 +-
 crates/sre_engine/benches/benches.rs  |  2 +-
 crates/stdlib/src/scproxy.rs          |  2 +-
 crates/stdlib/src/socket.rs           | 32 +++++++++++++--------------
 crates/stdlib/src/sqlite.rs           |  6 +++--
 crates/vm/src/function/builtin.rs     |  2 +-
 crates/vm/src/stdlib/ctypes.rs        |  2 +-
 crates/vm/src/stdlib/ctypes/array.rs  |  4 ++--
 crates/vm/src/stdlib/ctypes/simple.rs |  2 +-
 crates/vm/src/stdlib/os.rs            | 10 ++++-----
 crates/vm/src/stdlib/posix.rs         |  4 ++--
 crates/vm/src/stdlib/thread.rs        | 14 ++++++------
 crates/wasm/src/browser_module.rs     |  3 ++-
 crates/wasm/src/js_module.rs          |  2 +-
 crates/wasm/src/lib.rs                |  2 ++
 crates/wasm/src/vm_class.rs           |  8 +++----
 17 files changed, 50 insertions(+), 49 deletions(-)

diff --git a/crates/common/src/os.rs b/crates/common/src/os.rs
index 3e09a29210a..1ce25988d28 100644
--- a/crates/common/src/os.rs
+++ b/crates/common/src/os.rs
@@ -89,7 +89,7 @@ pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
 
 #[cfg(not(unix))]
 pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
-    Ok(std::str::from_utf8(b)?.as_ref())
+    Ok(core::str::from_utf8(b)?.as_ref())
 }
 
 #[cfg(unix)]
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 5dafeaeb807..17c280ec3c9 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,9 +1,9 @@
+use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
     CodeObject, ConstantData, Instruction, OpArg, OpArgState,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use std::collections::HashMap;
-use std::ops::ControlFlow;
 
 #[derive(Debug, Clone)]
 pub struct Function {
diff --git a/crates/sre_engine/benches/benches.rs b/crates/sre_engine/benches/benches.rs
index 127f72e2747..9905a8db70f 100644
--- a/crates/sre_engine/benches/benches.rs
+++ b/crates/sre_engine/benches/benches.rs
@@ -15,7 +15,7 @@ impl Pattern {
     fn state_range<'a, S: StrDrive>(
         &self,
         string: S,
-        range: std::ops::Range<usize>,
+        range: core::ops::Range<usize>,
     ) -> (Request<'a, S>, State) {
         let req = Request::new(string, range.start, range.end, self.code, false);
         let state = State::default();
diff --git a/crates/stdlib/src/scproxy.rs b/crates/stdlib/src/scproxy.rs
index 40267579029..b105dc4f2fb 100644
--- a/crates/stdlib/src/scproxy.rs
+++ b/crates/stdlib/src/scproxy.rs
@@ -91,7 +91,7 @@ mod _scproxy {
                     .find(host_key)
                     .and_then(|v| v.downcast::<CFString>())
             {
-                let h = std::borrow::Cow::<str>::from(&host);
+                let h = alloc::borrow::Cow::<str>::from(&host);
                 let v = if let Some(port) = proxy_dict
                     .find(port_key)
                     .and_then(|v| v.downcast::<CFNumber>())
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index 71bc8e9f170..a37a4fd241d 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -1228,7 +1228,7 @@ mod _socket {
                                 .new_os_error("interface name too long".to_owned())
                                 .into());
                         }
-                        let cstr = std::ffi::CString::new(ifname)
+                        let cstr = alloc::ffi::CString::new(ifname)
                             .map_err(|_| vm.new_os_error("invalid interface name".to_owned()))?;
                         let idx = unsafe { libc::if_nametoindex(cstr.as_ptr()) };
                         if idx == 0 {
@@ -1238,7 +1238,7 @@ mod _socket {
                     };
 
                     // Create sockaddr_can
-                    let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+                    let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
                     let can_addr =
                         &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_can;
                     unsafe {
@@ -1294,7 +1294,7 @@ mod _socket {
                     }
 
                     // Create sockaddr_alg
-                    let mut storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+                    let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
                     let alg_addr =
                         &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_alg;
                     unsafe {
@@ -1936,7 +1936,7 @@ mod _socket {
             flags: OptionalArg<i32>,
             vm: &VirtualMachine,
         ) -> PyResult<PyTupleRef> {
-            use std::mem::MaybeUninit;
+            use core::mem::MaybeUninit;
 
             if bufsize < 0 {
                 return Err(vm.new_value_error("negative buffer size in recvmsg".to_owned()));
@@ -1955,7 +1955,7 @@ mod _socket {
             // Allocate buffers
             let mut data_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); bufsize];
             let mut anc_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); ancbufsize];
-            let mut addr_storage: libc::sockaddr_storage = unsafe { std::mem::zeroed() };
+            let mut addr_storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
 
             // Set up iovec
             let mut iov = [libc::iovec {
@@ -1964,9 +1964,9 @@ mod _socket {
             }];
 
             // Set up msghdr
-            let mut msg: libc::msghdr = unsafe { std::mem::zeroed() };
+            let mut msg: libc::msghdr = unsafe { core::mem::zeroed() };
             msg.msg_name = (&mut addr_storage as *mut libc::sockaddr_storage).cast();
-            msg.msg_namelen = std::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
+            msg.msg_namelen = core::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
             msg.msg_iov = iov.as_mut_ptr();
             msg.msg_iovlen = 1;
             if ancbufsize > 0 {
@@ -1990,7 +1990,7 @@ mod _socket {
             // Build data bytes
             let data = unsafe {
                 data_buf.set_len(n);
-                std::mem::transmute::<Vec<MaybeUninit<u8>>, Vec<u8>>(data_buf)
+                core::mem::transmute::<Vec<MaybeUninit<u8>>, Vec<u8>>(data_buf)
             };
 
             // Build ancdata list
@@ -1999,7 +1999,7 @@ mod _socket {
             // Build address tuple
             let address = if msg.msg_namelen > 0 {
                 let storage: socket2::SockAddrStorage =
-                    unsafe { std::mem::transmute(addr_storage) };
+                    unsafe { core::mem::transmute(addr_storage) };
                 let addr = unsafe { socket2::SockAddr::new(storage, msg.msg_namelen) };
                 get_addr_tuple(&addr, vm)
             } else {
@@ -2034,7 +2034,7 @@ mod _socket {
                 let available = ctrl_end as usize - data_ptr as usize;
                 let data_len = data_len_from_cmsg.min(available);
 
-                let data = unsafe { std::slice::from_raw_parts(data_ptr, data_len) };
+                let data = unsafe { core::slice::from_raw_parts(data_ptr, data_len) };
 
                 let tuple = vm.ctx.new_tuple(vec![
                     vm.ctx.new_int(cmsg_ref.cmsg_level).into(),
@@ -2820,13 +2820,11 @@ mod _socket {
         let host = host_encoded.as_deref();
 
         // Encode port using UTF-8
-        let port: Option<std::borrow::Cow<'_, str>> = match opts.port.as_ref() {
-            Some(Either::A(s)) => {
-                Some(std::borrow::Cow::Borrowed(s.to_str().ok_or_else(|| {
-                    vm.new_unicode_encode_error("surrogates not allowed".to_owned())
-                })?))
-            }
-            Some(Either::B(i)) => Some(std::borrow::Cow::Owned(i.to_string())),
+        let port: Option<alloc::borrow::Cow<'_, str>> = match opts.port.as_ref() {
+            Some(Either::A(s)) => Some(alloc::borrow::Cow::Borrowed(s.to_str().ok_or_else(
+                || vm.new_unicode_encode_error("surrogates not allowed".to_owned()),
+            )?)),
+            Some(Either::B(i)) => Some(alloc::borrow::Cow::Owned(i.to_string())),
             None => None,
         };
         let port = port.as_ref().map(|p| p.as_ref());
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index 3a82787cd8f..54c889ecb6b 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -3191,7 +3191,9 @@ mod _sqlite {
         }
 
         fn aggregate_context<T>(self) -> *mut T {
-            unsafe { sqlite3_aggregate_context(self.ctx, std::mem::size_of::<T>() as c_int).cast() }
+            unsafe {
+                sqlite3_aggregate_context(self.ctx, core::mem::size_of::<T>() as c_int).cast()
+            }
         }
 
         fn result_exception(self, vm: &VirtualMachine, exc: PyBaseExceptionRef, msg: &str) {
@@ -3297,7 +3299,7 @@ mod _sqlite {
         } else if nbytes < 0 {
             Err(vm.new_system_error("negative size with ptr"))
         } else {
-            Ok(unsafe { std::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec())
+            Ok(unsafe { core::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec())
         }
     }
 
diff --git a/crates/vm/src/function/builtin.rs b/crates/vm/src/function/builtin.rs
index 06fd6a44f54..444df64a8ef 100644
--- a/crates/vm/src/function/builtin.rs
+++ b/crates/vm/src/function/builtin.rs
@@ -218,7 +218,7 @@ into_py_native_fn_tuple!(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::mem::size_of_val;
+    use core::mem::size_of_val;
 
     #[test]
     fn test_into_native_fn_noalloc() {
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
index f3b6dd25aca..cbe3f5405b6 100644
--- a/crates/vm/src/stdlib/ctypes.rs
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -1180,7 +1180,7 @@ pub(crate) mod _ctypes {
         path: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<bool> {
-        use std::ffi::CString;
+        use alloc::ffi::CString;
 
         let path = match path {
             Some(p) if !vm.is_none(&p) => p,
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 168da2bcc01..5c298d26a56 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -12,8 +12,8 @@ use crate::{
     protocol::{BufferDescriptor, PyBuffer, PyNumberMethods, PySequenceMethods},
     types::{AsBuffer, AsNumber, AsSequence, Constructor, Initializer},
 };
+use alloc::borrow::Cow;
 use num_traits::{Signed, ToPrimitive};
-use std::borrow::Cow;
 
 /// Get itemsize from a PEP 3118 format string
 /// Extracts the type code (last char after endianness prefix) and returns its size
@@ -890,7 +890,7 @@ impl PyCArray {
                 // Python's from_buffer requires writable buffer, so this is safe.
                 let ptr = slice.as_ptr() as *mut u8;
                 let len = slice.len();
-                let owned_slice = unsafe { std::slice::from_raw_parts_mut(ptr, len) };
+                let owned_slice = unsafe { core::slice::from_raw_parts_mut(ptr, len) };
                 Self::write_element_to_buffer(
                     owned_slice,
                     final_offset,
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index 9835953812f..7bcfa203b02 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -1304,7 +1304,7 @@ impl PyCSimple {
                 let ptr = slice.as_ptr() as *mut u8;
                 let len = slice.len().min(buffer_bytes.len());
                 unsafe {
-                    std::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len);
+                    core::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len);
                 }
             }
             Cow::Owned(vec) => {
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index add8763f5e1..fa1495fcdbf 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -1747,16 +1747,16 @@ pub(super) mod _os {
             // We extract raw bytes and interpret as a native-endian integer.
             // Note: The value may differ across architectures due to endianness.
             let f_fsid = {
-                let ptr = std::ptr::addr_of!(st.f_fsid) as *const u8;
-                let size = std::mem::size_of_val(&st.f_fsid);
+                let ptr = core::ptr::addr_of!(st.f_fsid) as *const u8;
+                let size = core::mem::size_of_val(&st.f_fsid);
                 if size >= 8 {
-                    let bytes = unsafe { std::slice::from_raw_parts(ptr, 8) };
+                    let bytes = unsafe { core::slice::from_raw_parts(ptr, 8) };
                     u64::from_ne_bytes([
                         bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6],
                         bytes[7],
                     ]) as libc::c_ulong
                 } else if size >= 4 {
-                    let bytes = unsafe { std::slice::from_raw_parts(ptr, 4) };
+                    let bytes = unsafe { core::slice::from_raw_parts(ptr, 4) };
                     u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as libc::c_ulong
                 } else {
                     0
@@ -1784,7 +1784,7 @@ pub(super) mod _os {
     #[pyfunction]
     #[pyfunction(name = "fstatvfs")]
     fn statvfs(path: OsPathOrFd<'_>, vm: &VirtualMachine) -> PyResult {
-        let mut st: libc::statvfs = unsafe { std::mem::zeroed() };
+        let mut st: libc::statvfs = unsafe { core::mem::zeroed() };
         let ret = match &path {
             OsPathOrFd::Path(p) => {
                 let cpath = p.clone().into_cstring(vm)?;
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 4ec71eecbf2..65a659790b2 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -360,9 +360,9 @@ pub mod module {
 
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     fn getgroups_impl() -> nix::Result<Vec<Gid>> {
+        use core::ptr;
         use libc::{c_int, gid_t};
         use nix::errno::Errno;
-        use std::ptr;
         let ret = unsafe { libc::getgroups(0, ptr::null_mut()) };
         let mut groups = Vec::<Gid>::with_capacity(Errno::result(ret)? as usize);
         let ret = unsafe {
@@ -1825,7 +1825,7 @@ pub mod module {
     #[cfg(target_os = "macos")]
     #[pyfunction]
     fn _fcopyfile(in_fd: i32, out_fd: i32, flags: i32, vm: &VirtualMachine) -> PyResult<()> {
-        let ret = unsafe { fcopyfile(in_fd, out_fd, std::ptr::null_mut(), flags as u32) };
+        let ret = unsafe { fcopyfile(in_fd, out_fd, core::ptr::null_mut(), flags as u32) };
         if ret < 0 {
             Err(vm.new_last_errno_error())
         } else {
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index 6ab754be094..eb881911659 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -192,7 +192,7 @@ pub(crate) mod _thread {
     #[derive(PyPayload)]
     struct RLock {
         mu: RawRMutex,
-        count: std::sync::atomic::AtomicUsize,
+        count: core::sync::atomic::AtomicUsize,
     }
 
     impl fmt::Debug for RLock {
@@ -207,7 +207,7 @@ pub(crate) mod _thread {
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Self {
                 mu: RawRMutex::INIT,
-                count: std::sync::atomic::AtomicUsize::new(0),
+                count: core::sync::atomic::AtomicUsize::new(0),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into)
@@ -220,7 +220,7 @@ pub(crate) mod _thread {
             let result = acquire_lock_impl!(&self.mu, args, vm)?;
             if result {
                 self.count
-                    .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    .fetch_add(1, core::sync::atomic::Ordering::Relaxed);
             }
             Ok(result)
         }
@@ -231,11 +231,11 @@ pub(crate) mod _thread {
                 return Err(vm.new_runtime_error("release unlocked lock"));
             }
             debug_assert!(
-                self.count.load(std::sync::atomic::Ordering::Relaxed) > 0,
+                self.count.load(core::sync::atomic::Ordering::Relaxed) > 0,
                 "RLock count underflow"
             );
             self.count
-                .fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
+                .fetch_sub(1, core::sync::atomic::Ordering::Relaxed);
             unsafe { self.mu.unlock() };
             Ok(())
         }
@@ -247,7 +247,7 @@ pub(crate) mod _thread {
                     self.mu.unlock();
                 };
             }
-            self.count.store(0, std::sync::atomic::Ordering::Relaxed);
+            self.count.store(0, core::sync::atomic::Ordering::Relaxed);
             let new_mut = RawRMutex::INIT;
 
             let old_mutex: AtomicCell<&RawRMutex> = AtomicCell::new(&self.mu);
@@ -264,7 +264,7 @@ pub(crate) mod _thread {
         #[pymethod]
         fn _recursion_count(&self) -> usize {
             if self.mu.is_owned_by_current_thread() {
-                self.count.load(std::sync::atomic::Ordering::Relaxed)
+                self.count.load(core::sync::atomic::Ordering::Relaxed)
             } else {
                 0
             }
diff --git a/crates/wasm/src/browser_module.rs b/crates/wasm/src/browser_module.rs
index 0b978a4b563..9b6219cab6f 100644
--- a/crates/wasm/src/browser_module.rs
+++ b/crates/wasm/src/browser_module.rs
@@ -117,7 +117,8 @@ mod _browser {
 
     #[pyfunction]
     fn request_animation_frame(func: ArgCallable, vm: &VirtualMachine) -> PyResult {
-        use std::{cell::RefCell, rc::Rc};
+        use alloc::rc::Rc;
+        use core::cell::RefCell;
 
         // this basic setup for request_animation_frame taken from:
         // https://rustwasm.github.io/wasm-bindgen/examples/request-animation-frame.html
diff --git a/crates/wasm/src/js_module.rs b/crates/wasm/src/js_module.rs
index d4f623da9f4..11d23bdf6d8 100644
--- a/crates/wasm/src/js_module.rs
+++ b/crates/wasm/src/js_module.rs
@@ -8,6 +8,7 @@ mod _js {
         vm_class::{WASMVirtualMachine, stored_vm_from_wasm},
         weak_vm,
     };
+    use core::{cell, fmt, future};
     use js_sys::{Array, Object, Promise, Reflect};
     use rustpython_vm::{
         Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
@@ -17,7 +18,6 @@ mod _js {
         protocol::PyIterReturn,
         types::{IterNext, Representable, SelfIter},
     };
-    use std::{cell, fmt, future};
     use wasm_bindgen::{JsCast, closure::Closure, prelude::*};
     use wasm_bindgen_futures::{JsFuture, future_to_promise};
 
diff --git a/crates/wasm/src/lib.rs b/crates/wasm/src/lib.rs
index 8d1d19ddae1..64595fd63ab 100644
--- a/crates/wasm/src/lib.rs
+++ b/crates/wasm/src/lib.rs
@@ -1,3 +1,5 @@
+extern crate alloc;
+
 pub mod browser_module;
 pub mod convert;
 pub mod js_module;
diff --git a/crates/wasm/src/vm_class.rs b/crates/wasm/src/vm_class.rs
index ad5df8dab96..0339a47821e 100644
--- a/crates/wasm/src/vm_class.rs
+++ b/crates/wasm/src/vm_class.rs
@@ -3,6 +3,8 @@ use crate::{
     convert::{self, PyResultExt},
     js_module, wasm_builtins,
 };
+use alloc::rc::{Rc, Weak};
+use core::cell::RefCell;
 use js_sys::{Object, TypeError};
 use rustpython_vm::{
     Interpreter, PyObjectRef, PyPayload, PyRef, PyResult, Settings, VirtualMachine,
@@ -10,11 +12,7 @@ use rustpython_vm::{
     compiler::Mode,
     scope::Scope,
 };
-use std::{
-    cell::RefCell,
-    collections::HashMap,
-    rc::{Rc, Weak},
-};
+use std::collections::HashMap;
 use wasm_bindgen::prelude::*;
 
 pub(crate) struct StoredVirtualMachine {

From 6ed0b4f0acfc3ca2c7a46cdf54ada7281d1821e1 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 15:15:16 +0900
Subject: [PATCH 120/418] Add PythonFinallizationError and upgrade
 multiprocessing (#6592)

* PythonFinallizationError

* fix posixprocess

* upgrade multiprocessing from 3.13.11
---
 Lib/multiprocessing/connection.py       |   2 +-
 Lib/multiprocessing/resource_tracker.py | 253 ++++++++++++++++--------
 Lib/multiprocessing/util.py             |  81 +++++++-
 crates/stdlib/src/posixsubprocess.rs    |  12 ++
 crates/vm/src/exceptions.rs             |  13 ++
 crates/vm/src/vm/vm_new.rs              |   1 +
 6 files changed, 283 insertions(+), 79 deletions(-)

diff --git a/Lib/multiprocessing/connection.py b/Lib/multiprocessing/connection.py
index 8caddd204d7..abd88adf76e 100644
--- a/Lib/multiprocessing/connection.py
+++ b/Lib/multiprocessing/connection.py
@@ -74,7 +74,7 @@ def arbitrary_address(family):
     if family == 'AF_INET':
         return ('localhost', 0)
     elif family == 'AF_UNIX':
-        return tempfile.mktemp(prefix='listener-', dir=util.get_temp_dir())
+        return tempfile.mktemp(prefix='sock-', dir=util.get_temp_dir())
     elif family == 'AF_PIPE':
         return tempfile.mktemp(prefix=r'\\.\pipe\pyc-%d-%d-' %
                                (os.getpid(), next(_mmap_counter)), dir="")
diff --git a/Lib/multiprocessing/resource_tracker.py b/Lib/multiprocessing/resource_tracker.py
index 05633ac21a2..22e3bbcf21b 100644
--- a/Lib/multiprocessing/resource_tracker.py
+++ b/Lib/multiprocessing/resource_tracker.py
@@ -15,11 +15,15 @@
 # this resource tracker process, "killall python" would probably leave unlinked
 # resources.
 
+import base64
 import os
 import signal
 import sys
 import threading
 import warnings
+from collections import deque
+
+import json
 
 from . import spawn
 from . import util
@@ -66,6 +70,14 @@ def __init__(self):
         self._fd = None
         self._pid = None
         self._exitcode = None
+        self._reentrant_messages = deque()
+
+        # True to use colon-separated lines, rather than JSON lines,
+        # for internal communication. (Mainly for testing).
+        # Filenames not supported by the simple format will always be sent
+        # using JSON.
+        # The reader should understand all formats.
+        self._use_simple_format = True
 
     def _reentrant_call_error(self):
         # gh-109629: this happens if an explicit call to the ResourceTracker
@@ -102,7 +114,7 @@ def _stop_locked(
         # This shouldn't happen (it might when called by a finalizer)
         # so we check for it anyway.
         if self._lock._recursion_count() > 1:
-            return self._reentrant_call_error()
+            raise self._reentrant_call_error()
         if self._fd is None:
             # not running
             return
@@ -113,7 +125,12 @@ def _stop_locked(
         close(self._fd)
         self._fd = None
 
-        _, status = waitpid(self._pid, 0)
+        try:
+            _, status = waitpid(self._pid, 0)
+        except ChildProcessError:
+            self._pid = None
+            self._exitcode = None
+            return
 
         self._pid = None
 
@@ -132,76 +149,119 @@ def ensure_running(self):
 
         This can be run from any process.  Usually a child process will use
         the resource created by its parent.'''
+        return self._ensure_running_and_write()
+
+    def _teardown_dead_process(self):
+        os.close(self._fd)
+
+        # Clean-up to avoid dangling processes.
+        try:
+            # _pid can be None if this process is a child from another
+            # python process, which has started the resource_tracker.
+            if self._pid is not None:
+                os.waitpid(self._pid, 0)
+        except ChildProcessError:
+            # The resource_tracker has already been terminated.
+            pass
+        self._fd = None
+        self._pid = None
+        self._exitcode = None
+
+        warnings.warn('resource_tracker: process died unexpectedly, '
+                      'relaunching.  Some resources might leak.')
+
+    def _launch(self):
+        fds_to_pass = []
+        try:
+            fds_to_pass.append(sys.stderr.fileno())
+        except Exception:
+            pass
+        r, w = os.pipe()
+        try:
+            fds_to_pass.append(r)
+            # process will out live us, so no need to wait on pid
+            exe = spawn.get_executable()
+            args = [
+                exe,
+                *util._args_from_interpreter_flags(),
+                '-c',
+                f'from multiprocessing.resource_tracker import main;main({r})',
+            ]
+            # bpo-33613: Register a signal mask that will block the signals.
+            # This signal mask will be inherited by the child that is going
+            # to be spawned and will protect the child from a race condition
+            # that can make the child die before it registers signal handlers
+            # for SIGINT and SIGTERM. The mask is unregistered after spawning
+            # the child.
+            prev_sigmask = None
+            try:
+                if _HAVE_SIGMASK:
+                    prev_sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, _IGNORED_SIGNALS)
+                pid = util.spawnv_passfds(exe, args, fds_to_pass)
+            finally:
+                if prev_sigmask is not None:
+                    signal.pthread_sigmask(signal.SIG_SETMASK, prev_sigmask)
+        except:
+            os.close(w)
+            raise
+        else:
+            self._fd = w
+            self._pid = pid
+        finally:
+            os.close(r)
+
+    def _make_probe_message(self):
+        """Return a probe message."""
+        if self._use_simple_format:
+            return b'PROBE:0:noop\n'
+        return (
+            json.dumps(
+                {"cmd": "PROBE", "rtype": "noop"},
+                ensure_ascii=True,
+                separators=(",", ":"),
+            )
+            + "\n"
+        ).encode("ascii")
+
+    def _ensure_running_and_write(self, msg=None):
         with self._lock:
             if self._lock._recursion_count() > 1:
                 # The code below is certainly not reentrant-safe, so bail out
-                return self._reentrant_call_error()
+                if msg is None:
+                    raise self._reentrant_call_error()
+                return self._reentrant_messages.append(msg)
+
             if self._fd is not None:
                 # resource tracker was launched before, is it still running?
-                if self._check_alive():
-                    # => still alive
-                    return
-                # => dead, launch it again
-                os.close(self._fd)
-
-                # Clean-up to avoid dangling processes.
+                if msg is None:
+                    to_send = self._make_probe_message()
+                else:
+                    to_send = msg
                 try:
-                    # _pid can be None if this process is a child from another
-                    # python process, which has started the resource_tracker.
-                    if self._pid is not None:
-                        os.waitpid(self._pid, 0)
-                except ChildProcessError:
-                    # The resource_tracker has already been terminated.
-                    pass
-                self._fd = None
-                self._pid = None
-                self._exitcode = None
+                    self._write(to_send)
+                except OSError:
+                    self._teardown_dead_process()
+                    self._launch()
 
-                warnings.warn('resource_tracker: process died unexpectedly, '
-                              'relaunching.  Some resources might leak.')
+                msg = None  # message was sent in probe
+            else:
+                self._launch()
 
-            fds_to_pass = []
-            try:
-                fds_to_pass.append(sys.stderr.fileno())
-            except Exception:
-                pass
-            cmd = 'from multiprocessing.resource_tracker import main;main(%d)'
-            r, w = os.pipe()
+        while True:
             try:
-                fds_to_pass.append(r)
-                # process will out live us, so no need to wait on pid
-                exe = spawn.get_executable()
-                args = [exe] + util._args_from_interpreter_flags()
-                args += ['-c', cmd % r]
-                # bpo-33613: Register a signal mask that will block the signals.
-                # This signal mask will be inherited by the child that is going
-                # to be spawned and will protect the child from a race condition
-                # that can make the child die before it registers signal handlers
-                # for SIGINT and SIGTERM. The mask is unregistered after spawning
-                # the child.
-                prev_sigmask = None
-                try:
-                    if _HAVE_SIGMASK:
-                        prev_sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, _IGNORED_SIGNALS)
-                    pid = util.spawnv_passfds(exe, args, fds_to_pass)
-                finally:
-                    if prev_sigmask is not None:
-                        signal.pthread_sigmask(signal.SIG_SETMASK, prev_sigmask)
-            except:
-                os.close(w)
-                raise
-            else:
-                self._fd = w
-                self._pid = pid
-            finally:
-                os.close(r)
+                reentrant_msg = self._reentrant_messages.popleft()
+            except IndexError:
+                break
+            self._write(reentrant_msg)
+        if msg is not None:
+            self._write(msg)
 
     def _check_alive(self):
         '''Check that the pipe has not been closed by sending a probe.'''
         try:
             # We cannot use send here as it calls ensure_running, creating
             # a cycle.
-            os.write(self._fd, b'PROBE:0:noop\n')
+            os.write(self._fd, self._make_probe_message())
         except OSError:
             return False
         else:
@@ -215,27 +275,42 @@ def unregister(self, name, rtype):
         '''Unregister name of resource with resource tracker.'''
         self._send('UNREGISTER', name, rtype)
 
-    def _send(self, cmd, name, rtype):
-        try:
-            self.ensure_running()
-        except ReentrantCallError:
-            # The code below might or might not work, depending on whether
-            # the resource tracker was already running and still alive.
-            # Better warn the user.
-            # (XXX is warnings.warn itself reentrant-safe? :-)
-            warnings.warn(
-                f"ResourceTracker called reentrantly for resource cleanup, "
-                f"which is unsupported. "
-                f"The {rtype} object {name!r} might leak.")
-        msg = '{0}:{1}:{2}\n'.format(cmd, name, rtype).encode('ascii')
-        if len(msg) > 512:
-            # posix guarantees that writes to a pipe of less than PIPE_BUF
-            # bytes are atomic, and that PIPE_BUF >= 512
-            raise ValueError('msg too long')
+    def _write(self, msg):
         nbytes = os.write(self._fd, msg)
-        assert nbytes == len(msg), "nbytes {0:n} but len(msg) {1:n}".format(
-            nbytes, len(msg))
+        assert nbytes == len(msg), f"{nbytes=} != {len(msg)=}"
 
+    def _send(self, cmd, name, rtype):
+        if self._use_simple_format and '\n' not in name:
+            msg = f"{cmd}:{name}:{rtype}\n".encode("ascii")
+            if len(msg) > 512:
+                # posix guarantees that writes to a pipe of less than PIPE_BUF
+                # bytes are atomic, and that PIPE_BUF >= 512
+                raise ValueError('msg too long')
+            self._ensure_running_and_write(msg)
+            return
+
+        # POSIX guarantees that writes to a pipe of less than PIPE_BUF (512 on Linux)
+        # bytes are atomic. Therefore, we want the message to be shorter than 512 bytes.
+        # POSIX shm_open() and sem_open() require the name, including its leading slash,
+        # to be at most NAME_MAX bytes (255 on Linux)
+        # With json.dump(..., ensure_ascii=True) every non-ASCII byte becomes a 6-char
+        # escape like \uDC80.
+        # As we want the overall message to be kept atomic and therefore smaller than 512,
+        # we encode encode the raw name bytes with URL-safe Base64 - so a 255 long name
+        # will not exceed 340 bytes.
+        b = name.encode('utf-8', 'surrogateescape')
+        if len(b) > 255:
+            raise ValueError('shared memory name too long (max 255 bytes)')
+        b64 = base64.urlsafe_b64encode(b).decode('ascii')
+
+        payload = {"cmd": cmd, "rtype": rtype, "base64_name": b64}
+        msg = (json.dumps(payload, ensure_ascii=True, separators=(",", ":")) + "\n").encode("ascii")
+
+        # The entire JSON message is guaranteed < PIPE_BUF (512 bytes) by construction.
+        assert len(msg) <= 512, f"internal error: message too long ({len(msg)} bytes)"
+        assert msg.startswith(b'{')
+
+        self._ensure_running_and_write(msg)
 
 _resource_tracker = ResourceTracker()
 ensure_running = _resource_tracker.ensure_running
@@ -244,6 +319,30 @@ def _send(self, cmd, name, rtype):
 getfd = _resource_tracker.getfd
 
 
+def _decode_message(line):
+    if line.startswith(b'{'):
+        try:
+            obj = json.loads(line.decode('ascii'))
+        except Exception as e:
+            raise ValueError("malformed resource_tracker message: %r" % (line,)) from e
+
+        cmd = obj["cmd"]
+        rtype = obj["rtype"]
+        b64  = obj.get("base64_name", "")
+
+        if not isinstance(cmd, str) or not isinstance(rtype, str) or not isinstance(b64, str):
+            raise ValueError("malformed resource_tracker fields: %r" % (obj,))
+
+        try:
+            name = base64.urlsafe_b64decode(b64).decode('utf-8', 'surrogateescape')
+        except ValueError as e:
+            raise ValueError("malformed resource_tracker base64_name: %r" % (b64,)) from e
+    else:
+        cmd, rest = line.strip().decode('ascii').split(':', maxsplit=1)
+        name, rtype = rest.rsplit(':', maxsplit=1)
+    return cmd, rtype, name
+
+
 def main(fd):
     '''Run resource tracker.'''
     # protect the process from ^C and "killall python" etc
@@ -266,7 +365,7 @@ def main(fd):
         with open(fd, 'rb') as f:
             for line in f:
                 try:
-                    cmd, name, rtype = line.strip().decode('ascii').split(':')
+                    cmd, rtype, name = _decode_message(line)
                     cleanup_func = _CLEANUP_FUNCS.get(rtype, None)
                     if cleanup_func is None:
                         raise ValueError(
diff --git a/Lib/multiprocessing/util.py b/Lib/multiprocessing/util.py
index 75dde02d88c..b8bfea045df 100644
--- a/Lib/multiprocessing/util.py
+++ b/Lib/multiprocessing/util.py
@@ -34,6 +34,7 @@
 DEBUG = 10
 INFO = 20
 SUBWARNING = 25
+WARNING = 30
 
 LOGGER_NAME = 'multiprocessing'
 DEFAULT_LOGGING_FORMAT = '[%(levelname)s/%(processName)s] %(message)s'
@@ -53,6 +54,10 @@ def info(msg, *args):
     if _logger:
         _logger.log(INFO, msg, *args, stacklevel=2)
 
+def _warn(msg, *args):
+    if _logger:
+        _logger.log(WARNING, msg, *args, stacklevel=2)
+
 def sub_warning(msg, *args):
     if _logger:
         _logger.log(SUBWARNING, msg, *args, stacklevel=2)
@@ -121,6 +126,23 @@ def is_abstract_socket_namespace(address):
 # Function returning a temp directory which will be removed on exit
 #
 
+# Maximum length of a NULL-terminated [1] socket file path is usually
+# between 92 and 108 [2], but Linux is known to use a size of 108 [3].
+# BSD-based systems usually use a size of 104 or 108 and Windows does
+# not create AF_UNIX sockets.
+#
+# [1]: https://github.com/python/cpython/issues/140734
+# [2]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/sys_un.h.html
+# [3]: https://man7.org/linux/man-pages/man7/unix.7.html
+
+if sys.platform == 'linux':
+    _SUN_PATH_MAX = 108
+elif sys.platform.startswith(('openbsd', 'freebsd')):
+    _SUN_PATH_MAX = 104
+else:
+    # On Windows platforms, we do not create AF_UNIX sockets.
+    _SUN_PATH_MAX = None if os.name == 'nt' else 92
+
 def _remove_temp_dir(rmtree, tempdir):
     rmtree(tempdir)
 
@@ -130,12 +152,69 @@ def _remove_temp_dir(rmtree, tempdir):
     if current_process is not None:
         current_process._config['tempdir'] = None
 
+def _get_base_temp_dir(tempfile):
+    """Get a temporary directory where socket files will be created.
+
+    To prevent additional imports, pass a pre-imported 'tempfile' module.
+    """
+    if os.name == 'nt':
+        return None
+    # Most of the time, the default temporary directory is /tmp. Thus,
+    # listener sockets files "$TMPDIR/pymp-XXXXXXXX/sock-XXXXXXXX" do
+    # not have a path length exceeding SUN_PATH_MAX.
+    #
+    # If users specify their own temporary directory, we may be unable
+    # to create those files. Therefore, we fall back to the system-wide
+    # temporary directory /tmp, assumed to exist on POSIX systems.
+    #
+    # See https://github.com/python/cpython/issues/132124.
+    base_tempdir = tempfile.gettempdir()
+    # Files created in a temporary directory are suffixed by a string
+    # generated by tempfile._RandomNameSequence, which, by design,
+    # is 8 characters long.
+    #
+    # Thus, the socket file path length (without NULL terminator) will be:
+    #
+    #   len(base_tempdir + '/pymp-XXXXXXXX' + '/sock-XXXXXXXX')
+    sun_path_len = len(base_tempdir) + 14 + 14
+    # Strict inequality to account for the NULL terminator.
+    # See https://github.com/python/cpython/issues/140734.
+    if sun_path_len < _SUN_PATH_MAX:
+        return base_tempdir
+    # Fallback to the default system-wide temporary directory.
+    # This ignores user-defined environment variables.
+    #
+    # On POSIX systems, /tmp MUST be writable by any application [1].
+    # We however emit a warning if this is not the case to prevent
+    # obscure errors later in the execution.
+    #
+    # On some legacy systems, /var/tmp and /usr/tmp can be present
+    # and will be used instead.
+    #
+    # [1]: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03s18.html
+    dirlist = ['/tmp', '/var/tmp', '/usr/tmp']
+    try:
+        base_system_tempdir = tempfile._get_default_tempdir(dirlist)
+    except FileNotFoundError:
+        _warn("Process-wide temporary directory %s will not be usable for "
+              "creating socket files and no usable system-wide temporary "
+              "directory was found in %s", base_tempdir, dirlist)
+        # At this point, the system-wide temporary directory is not usable
+        # but we may assume that the user-defined one is, even if we will
+        # not be able to write socket files out there.
+        return base_tempdir
+    _warn("Ignoring user-defined temporary directory: %s", base_tempdir)
+    # at most max(map(len, dirlist)) + 14 + 14 = 36 characters
+    assert len(base_system_tempdir) + 14 + 14 < _SUN_PATH_MAX
+    return base_system_tempdir
+
 def get_temp_dir():
     # get name of a temp directory which will be automatically cleaned up
     tempdir = process.current_process()._config.get('tempdir')
     if tempdir is None:
         import shutil, tempfile
-        tempdir = tempfile.mkdtemp(prefix='pymp-')
+        base_tempdir = _get_base_temp_dir(tempfile)
+        tempdir = tempfile.mkdtemp(prefix='pymp-', dir=base_tempdir)
         info('created temp directory %s', tempdir)
         # keep a strong reference to shutil.rmtree(), since the finalizer
         # can be called late during Python shutdown
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
index 1ebf6619c24..a6badc081d2 100644
--- a/crates/stdlib/src/posixsubprocess.rs
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -33,6 +33,18 @@ mod _posixsubprocess {
 
     #[pyfunction]
     fn fork_exec(args: ForkExecArgs<'_>, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
+        // Check for interpreter shutdown when preexec_fn is used
+        if args.preexec_fn.is_some()
+            && vm
+                .state
+                .finalizing
+                .load(std::sync::atomic::Ordering::Acquire)
+        {
+            return Err(vm.new_python_finalization_error(
+                "preexec_fn not supported at interpreter shutdown".to_owned(),
+            ));
+        }
+
         let extra_groups = args
             .groups_list
             .as_ref()
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index b1a654d58c4..5d0c1c6f3ed 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -493,6 +493,7 @@ pub struct ExceptionZoo {
     pub runtime_error: &'static Py<PyType>,
     pub not_implemented_error: &'static Py<PyType>,
     pub recursion_error: &'static Py<PyType>,
+    pub python_finalization_error: &'static Py<PyType>,
     pub syntax_error: &'static Py<PyType>,
     pub incomplete_input_error: &'static Py<PyType>,
     pub indentation_error: &'static Py<PyType>,
@@ -804,6 +805,7 @@ impl ExceptionZoo {
         let runtime_error = PyRuntimeError::init_builtin_type();
         let not_implemented_error = PyNotImplementedError::init_builtin_type();
         let recursion_error = PyRecursionError::init_builtin_type();
+        let python_finalization_error = PyPythonFinalizationError::init_builtin_type();
 
         let syntax_error = PySyntaxError::init_builtin_type();
         let incomplete_input_error = PyIncompleteInputError::init_builtin_type();
@@ -879,6 +881,7 @@ impl ExceptionZoo {
             runtime_error,
             not_implemented_error,
             recursion_error,
+            python_finalization_error,
             syntax_error,
             incomplete_input_error,
             indentation_error,
@@ -992,6 +995,11 @@ impl ExceptionZoo {
         extend_exception!(PyRuntimeError, ctx, excs.runtime_error);
         extend_exception!(PyNotImplementedError, ctx, excs.not_implemented_error);
         extend_exception!(PyRecursionError, ctx, excs.recursion_error);
+        extend_exception!(
+            PyPythonFinalizationError,
+            ctx,
+            excs.python_finalization_error
+        );
 
         extend_exception!(PySyntaxError, ctx, excs.syntax_error, {
             "msg" => ctx.new_static_getset(
@@ -2111,6 +2119,11 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyRecursionError(PyRuntimeError);
 
+    #[pyexception(name, base = PyRuntimeError, ctx = "python_finalization_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyPythonFinalizationError(PyRuntimeError);
+
     #[pyexception(name, base = PyException, ctx = "syntax_error")]
     #[derive(Debug)]
     #[repr(transparent)]
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index ba09c8ecf69..4f25d6e2036 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -600,5 +600,6 @@ impl VirtualMachine {
     define_exception_fn!(fn new_zero_division_error, zero_division_error, ZeroDivisionError);
     define_exception_fn!(fn new_overflow_error, overflow_error, OverflowError);
     define_exception_fn!(fn new_runtime_error, runtime_error, RuntimeError);
+    define_exception_fn!(fn new_python_finalization_error, python_finalization_error, PythonFinalizationError);
     define_exception_fn!(fn new_memory_error, memory_error, MemoryError);
 }

From 6bd1d90b6a8f010ddac7a047b3023cd93e151a9b Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Tue, 30 Dec 2025 02:35:58 -0500
Subject: [PATCH 121/418] Updated bdb.py + test_bdb.py (#6593)

* Updated bdb.py + test_bdb.py

* Double checked test_bdb.py with the script
---
 Lib/bdb.py           | 148 +++++++++++++++++++++++++++++++++----------
 Lib/test/test_bdb.py |  95 +++++++++++++++++----------
 2 files changed, 177 insertions(+), 66 deletions(-)

diff --git a/Lib/bdb.py b/Lib/bdb.py
index 0f3eec653ba..f256b56daaa 100644
--- a/Lib/bdb.py
+++ b/Lib/bdb.py
@@ -3,6 +3,7 @@
 import fnmatch
 import sys
 import os
+from contextlib import contextmanager
 from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
 
 __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
@@ -32,7 +33,12 @@ def __init__(self, skip=None):
         self.skip = set(skip) if skip else None
         self.breaks = {}
         self.fncache = {}
+        self.frame_trace_lines_opcodes = {}
         self.frame_returning = None
+        self.trace_opcodes = False
+        self.enterframe = None
+        self.cmdframe = None
+        self.cmdlineno = None
 
         self._load_breaks()
 
@@ -60,6 +66,12 @@ def reset(self):
         self.botframe = None
         self._set_stopinfo(None, None)
 
+    @contextmanager
+    def set_enterframe(self, frame):
+        self.enterframe = frame
+        yield
+        self.enterframe = None
+
     def trace_dispatch(self, frame, event, arg):
         """Dispatch a trace function for debugged frames based on the event.
 
@@ -84,24 +96,28 @@ def trace_dispatch(self, frame, event, arg):
 
         The arg parameter depends on the previous event.
         """
-        if self.quitting:
-            return # None
-        if event == 'line':
-            return self.dispatch_line(frame)
-        if event == 'call':
-            return self.dispatch_call(frame, arg)
-        if event == 'return':
-            return self.dispatch_return(frame, arg)
-        if event == 'exception':
-            return self.dispatch_exception(frame, arg)
-        if event == 'c_call':
-            return self.trace_dispatch
-        if event == 'c_exception':
-            return self.trace_dispatch
-        if event == 'c_return':
+
+        with self.set_enterframe(frame):
+            if self.quitting:
+                return # None
+            if event == 'line':
+                return self.dispatch_line(frame)
+            if event == 'call':
+                return self.dispatch_call(frame, arg)
+            if event == 'return':
+                return self.dispatch_return(frame, arg)
+            if event == 'exception':
+                return self.dispatch_exception(frame, arg)
+            if event == 'c_call':
+                return self.trace_dispatch
+            if event == 'c_exception':
+                return self.trace_dispatch
+            if event == 'c_return':
+                return self.trace_dispatch
+            if event == 'opcode':
+                return self.dispatch_opcode(frame, arg)
+            print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))
             return self.trace_dispatch
-        print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))
-        return self.trace_dispatch
 
     def dispatch_line(self, frame):
         """Invoke user function and return trace function for line event.
@@ -110,7 +126,12 @@ def dispatch_line(self, frame):
         self.user_line(). Raise BdbQuit if self.quitting is set.
         Return self.trace_dispatch to continue tracing in this scope.
         """
-        if self.stop_here(frame) or self.break_here(frame):
+        # GH-136057
+        # For line events, we don't want to stop at the same line where
+        # the latest next/step command was issued.
+        if (self.stop_here(frame) or self.break_here(frame)) and not (
+            self.cmdframe == frame and self.cmdlineno == frame.f_lineno
+        ):
             self.user_line(frame)
             if self.quitting: raise BdbQuit
         return self.trace_dispatch
@@ -157,6 +178,11 @@ def dispatch_return(self, frame, arg):
             # The user issued a 'next' or 'until' command.
             if self.stopframe is frame and self.stoplineno != -1:
                 self._set_stopinfo(None, None)
+            # The previous frame might not have f_trace set, unless we are
+            # issuing a command that does not expect to stop, we should set
+            # f_trace
+            if self.stoplineno != -1:
+                self._set_caller_tracefunc(frame)
         return self.trace_dispatch
 
     def dispatch_exception(self, frame, arg):
@@ -186,6 +212,17 @@ def dispatch_exception(self, frame, arg):
 
         return self.trace_dispatch
 
+    def dispatch_opcode(self, frame, arg):
+        """Invoke user function and return trace function for opcode event.
+        If the debugger stops on the current opcode, invoke
+        self.user_opcode(). Raise BdbQuit if self.quitting is set.
+        Return self.trace_dispatch to continue tracing in this scope.
+        """
+        if self.stop_here(frame) or self.break_here(frame):
+            self.user_opcode(frame)
+            if self.quitting: raise BdbQuit
+        return self.trace_dispatch
+
     # Normally derived classes don't override the following
     # methods, but they may if they want to redefine the
     # definition of stopping and breakpoints.
@@ -272,7 +309,22 @@ def user_exception(self, frame, exc_info):
         """Called when we stop on an exception."""
         pass
 
-    def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
+    def user_opcode(self, frame):
+        """Called when we are about to execute an opcode."""
+        pass
+
+    def _set_trace_opcodes(self, trace_opcodes):
+        if trace_opcodes != self.trace_opcodes:
+            self.trace_opcodes = trace_opcodes
+            frame = self.enterframe
+            while frame is not None:
+                frame.f_trace_opcodes = trace_opcodes
+                if frame is self.botframe:
+                    break
+                frame = frame.f_back
+
+    def _set_stopinfo(self, stopframe, returnframe, stoplineno=0, opcode=False,
+                      cmdframe=None, cmdlineno=None):
         """Set the attributes for stopping.
 
         If stoplineno is greater than or equal to 0, then stop at line
@@ -285,6 +337,21 @@ def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
         # stoplineno >= 0 means: stop at line >= the stoplineno
         # stoplineno -1 means: don't stop at all
         self.stoplineno = stoplineno
+        # cmdframe/cmdlineno is the frame/line number when the user issued
+        # step/next commands.
+        self.cmdframe = cmdframe
+        self.cmdlineno = cmdlineno
+        self._set_trace_opcodes(opcode)
+
+    def _set_caller_tracefunc(self, current_frame):
+        # Issue #13183: pdb skips frames after hitting a breakpoint and running
+        # step commands.
+        # Restore the trace function in the caller (that may not have been set
+        # for performance reasons) when returning from the current frame, unless
+        # the caller is the botframe.
+        caller_frame = current_frame.f_back
+        if caller_frame and not caller_frame.f_trace and caller_frame is not self.botframe:
+            caller_frame.f_trace = self.trace_dispatch
 
     # Derived classes and clients can call the following methods
     # to affect the stepping state.
@@ -299,19 +366,17 @@ def set_until(self, frame, lineno=None):
 
     def set_step(self):
         """Stop after one line of code."""
-        # Issue #13183: pdb skips frames after hitting a breakpoint and running
-        # step commands.
-        # Restore the trace function in the caller (that may not have been set
-        # for performance reasons) when returning from the current frame.
-        if self.frame_returning:
-            caller_frame = self.frame_returning.f_back
-            if caller_frame and not caller_frame.f_trace:
-                caller_frame.f_trace = self.trace_dispatch
-        self._set_stopinfo(None, None)
+        # set_step() could be called from signal handler so enterframe might be None
+        self._set_stopinfo(None, None, cmdframe=self.enterframe,
+                           cmdlineno=getattr(self.enterframe, 'f_lineno', None))
+
+    def set_stepinstr(self):
+        """Stop before the next instruction."""
+        self._set_stopinfo(None, None, opcode=True)
 
     def set_next(self, frame):
         """Stop on the next line in or below the given frame."""
-        self._set_stopinfo(frame, None)
+        self._set_stopinfo(frame, None, cmdframe=frame, cmdlineno=frame.f_lineno)
 
     def set_return(self, frame):
         """Stop when returning from the given frame."""
@@ -328,11 +393,15 @@ def set_trace(self, frame=None):
         if frame is None:
             frame = sys._getframe().f_back
         self.reset()
-        while frame:
-            frame.f_trace = self.trace_dispatch
-            self.botframe = frame
-            frame = frame.f_back
-        self.set_step()
+        with self.set_enterframe(frame):
+            while frame:
+                frame.f_trace = self.trace_dispatch
+                self.botframe = frame
+                self.frame_trace_lines_opcodes[frame] = (frame.f_trace_lines, frame.f_trace_opcodes)
+                # We need f_trace_lines == True for the debugger to work
+                frame.f_trace_lines = True
+                frame = frame.f_back
+            self.set_stepinstr()
         sys.settrace(self.trace_dispatch)
 
     def set_continue(self):
@@ -349,6 +418,9 @@ def set_continue(self):
             while frame and frame is not self.botframe:
                 del frame.f_trace
                 frame = frame.f_back
+            for frame, (trace_lines, trace_opcodes) in self.frame_trace_lines_opcodes.items():
+                frame.f_trace_lines, frame.f_trace_opcodes = trace_lines, trace_opcodes
+            self.frame_trace_lines_opcodes = {}
 
     def set_quit(self):
         """Set quitting attribute to True.
@@ -387,6 +459,14 @@ def set_break(self, filename, lineno, temporary=False, cond=None,
             return 'Line %s:%d does not exist' % (filename, lineno)
         self._add_to_breaks(filename, lineno)
         bp = Breakpoint(filename, lineno, temporary, cond, funcname)
+        # After we set a new breakpoint, we need to search through all frames
+        # and set f_trace to trace_dispatch if there could be a breakpoint in
+        # that frame.
+        frame = self.enterframe
+        while frame:
+            if self.break_anywhere(frame):
+                frame.f_trace = self.trace_dispatch
+            frame = frame.f_back
         return None
 
     def _load_breaks(self):
diff --git a/Lib/test/test_bdb.py b/Lib/test/test_bdb.py
index a3abbbb8db2..d1c1c786861 100644
--- a/Lib/test/test_bdb.py
+++ b/Lib/test/test_bdb.py
@@ -228,6 +228,10 @@ def user_exception(self, frame, exc_info):
         self.process_event('exception', frame)
         self.next_set_method()
 
+    def user_opcode(self, frame):
+        self.process_event('opcode', frame)
+        self.next_set_method()
+
     def do_clear(self, arg):
         # The temporary breakpoints are deleted in user_line().
         bp_list = [self.currentbp]
@@ -366,7 +370,7 @@ def next_set_method(self):
         set_method = getattr(self, 'set_' + set_type)
 
         # The following set methods give back control to the tracer.
-        if set_type in ('step', 'continue', 'quit'):
+        if set_type in ('step', 'stepinstr', 'continue', 'quit'):
             set_method()
             return
         elif set_type in ('next', 'return'):
@@ -586,7 +590,7 @@ def fail(self, msg=None):
 class StateTestCase(BaseTestCase):
     """Test the step, next, return, until and quit 'set_' methods."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_step(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -597,7 +601,7 @@ def test_step(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_step_next_on_last_statement(self):
         for set_type in ('step', 'next'):
             with self.subTest(set_type=set_type):
@@ -612,7 +616,18 @@ def test_step_next_on_last_statement(self):
                 with TracerRun(self) as tracer:
                     tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON')
+    # AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',), ('quit',)]
+    def test_stepinstr(self):
+        self.expect_set = [
+            ('line',   2, 'tfunc_main'),  ('stepinstr', ),
+            ('opcode', 2, 'tfunc_main'),  ('next', ),
+            ('line',   3, 'tfunc_main'),  ('quit', ),
+        ]
+        with TracerRun(self) as tracer:
+            tracer.runcall(tfunc_main)
+
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -624,7 +639,7 @@ def test_next(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_over_import(self):
         code = """
             def main():
@@ -639,7 +654,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_on_plain_statement(self):
         # Check that set_next() is equivalent to set_step() on a plain
         # statement.
@@ -652,7 +667,7 @@ def test_next_on_plain_statement(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_in_caller_frame(self):
         # Check that set_next() in the caller frame causes the tracer
         # to stop next in the caller frame.
@@ -666,7 +681,7 @@ def test_next_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_return(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),    ('step', ),
@@ -679,7 +694,7 @@ def test_return(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_return_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -691,7 +706,7 @@ def test_return_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_until(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -703,7 +718,7 @@ def test_until(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_until_with_too_large_count(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),               break_in_func('tfunc_first'),
@@ -714,7 +729,7 @@ def test_until_with_too_large_count(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_until_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -726,7 +741,8 @@ def test_until_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @patch_list(sys.meta_path)
     def test_skip(self):
         # Check that tracing is skipped over the import statement in
         # 'tfunc_import()'.
@@ -759,7 +775,7 @@ def test_skip_with_no_name_module(self):
         bdb = Bdb(skip=['anything*'])
         self.assertIs(bdb.is_skipped_module(None), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_down(self):
         # Check that set_down() raises BdbError at the newest frame.
         self.expect_set = [
@@ -768,7 +784,7 @@ def test_down(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_up(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -782,7 +798,7 @@ def test_up(self):
 class BreakpointTestCase(BaseTestCase):
     """Test the breakpoint set method."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_bp_on_non_existent_module(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('break', ('/non/existent/module.py', 1))
@@ -790,7 +806,7 @@ def test_bp_on_non_existent_module(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_bp_after_last_statement(self):
         code = """
             def main():
@@ -804,7 +820,7 @@ def main():
             with TracerRun(self) as tracer:
                 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_temporary_bp(self):
         code = """
             def func():
@@ -828,7 +844,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_disabled_temporary_bp(self):
         code = """
             def func():
@@ -857,7 +873,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_bp_condition(self):
         code = """
             def func(a):
@@ -878,7 +894,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_bp_exception_on_condition_evaluation(self):
         code = """
             def func(a):
@@ -898,7 +914,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_bp_ignore_count(self):
         code = """
             def func():
@@ -920,7 +936,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_ignore_count_on_disabled_bp(self):
         code = """
             def func():
@@ -948,7 +964,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_clear_two_bp_on_same_line(self):
         code = """
             def func():
@@ -974,7 +990,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_clear_at_no_bp(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('clear', (__file__, 1))
@@ -1028,7 +1044,7 @@ def test_load_bps_from_previous_Bdb_instance(self):
 class RunTestCase(BaseTestCase):
     """Test run, runeval and set_trace."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_run_step(self):
         # Check that the bdb 'run' method stops at the first line event.
         code = """
@@ -1041,7 +1057,7 @@ def test_run_step(self):
         with TracerRun(self) as tracer:
             tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_runeval_step(self):
         # Test bdb 'runeval'.
         code = """
@@ -1064,7 +1080,7 @@ def main():
 class IssuesTestCase(BaseTestCase):
     """Test fixed bdb issues."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_step_at_return_with_no_trace_in_caller(self):
         # Issue #13183.
         # Check that the tracer does step into the caller frame when the
@@ -1095,7 +1111,7 @@ def func():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_until_return_in_generator(self):
         # Issue #16596.
         # Check that set_next(), set_until() and set_return() do not treat the
@@ -1137,7 +1153,7 @@ def main():
                     with TracerRun(self) as tracer:
                         tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_command_in_generator_for_loop(self):
         # Issue #16596.
         code = """
@@ -1169,7 +1185,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_next_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1201,7 +1217,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
     def test_return_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1233,6 +1249,21 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',)]
+    def test_next_to_botframe(self):
+        # gh-125422
+        # Check that next command won't go to the bottom frame.
+        code = """
+            lno = 2
+        """
+        self.expect_set = [
+            ('line', 2, '<module>'),   ('step', ),
+            ('return', 2, '<module>'), ('next', ),
+        ]
+        with TracerRun(self) as tracer:
+            tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
+
 
 class TestRegressions(unittest.TestCase):
     def test_format_stack_entry_no_lineno(self):

From e79a1a1a6665565530bc143a305496b5cefed92e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 16:58:53 +0900
Subject: [PATCH 122/418] Fix traceback (#6569)

* Fix traceback

* Update traceback from CPython 3.13.11

* unmark test_traceback

* fix code

* fix debug range

* fix tests
---
 .cspell.dict/python-more.txt         |    1 +
 Lib/test/test_code.py                |    4 -
 Lib/test/test_traceback.py           |  110 ---
 Lib/test/test_zipimport.py           |    2 +
 Lib/traceback.py                     | 1198 +++++++++++++++++++++++---
 crates/codegen/src/compile.rs        |   30 +-
 crates/codegen/src/ir.rs             |   87 +-
 crates/compiler-core/src/bytecode.rs |    6 +-
 crates/compiler-core/src/marshal.rs  |   19 +-
 crates/vm/src/builtins/code.rs       |   21 +-
 crates/vm/src/builtins/frame.rs      |   11 +-
 crates/vm/src/frame.rs               |    6 +-
 crates/vm/src/vm/mod.rs              |    1 +
 crates/vm/src/vm/setting.rs          |    4 +-
 examples/dis.rs                      |    5 +-
 src/settings.rs                      |    4 +
 16 files changed, 1202 insertions(+), 307 deletions(-)

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index d381bfe1e03..1f3fc4864cd 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -178,6 +178,7 @@ PYTHONHASHSEED
 PYTHONHOME
 PYTHONINSPECT
 PYTHONINTMAXSTRDIGITS
+PYTHONNODEBUGRANGES
 PYTHONNOUSERSITE
 PYTHONOPTIMIZE
 PYTHONPATH
diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
index 804cce1dba4..f2ef233a59a 100644
--- a/Lib/test/test_code.py
+++ b/Lib/test/test_code.py
@@ -425,8 +425,6 @@ def test_co_positions_artificial_instructions(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_endline_and_columntable_none_when_no_debug_ranges(self):
         # Make sure that if `-X no_debug_ranges` is used, there is
         # minimal debug info
@@ -442,8 +440,6 @@ def f():
             """)
         assert_python_ok('-X', 'no_debug_ranges', '-c', code)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_endline_and_columntable_none_when_no_debug_ranges_env(self):
         # Same as above but using the environment variable opt out.
         code = textwrap.dedent("""
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index 9d95903d526..f2ec8344b2f 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -218,8 +218,6 @@ def test_base_exception(self):
         lst = traceback.format_exception_only(e.__class__, e)
         self.assertEqual(lst, ['KeyboardInterrupt\n'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_only_bad__str__(self):
         class X(Exception):
             def __str__(self):
@@ -238,8 +236,6 @@ def test_format_exception_group_without_show_group(self):
         err = traceback.format_exception_only(eg)
         self.assertEqual(err, ['ExceptionGroup: A (1 sub-exception)\n'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group(self):
         eg = ExceptionGroup('A', [ValueError('B')])
         err = traceback.format_exception_only(eg, show_group=True)
@@ -248,8 +244,6 @@ def test_format_exception_group(self):
             '   ValueError: B\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_base_exception_group(self):
         eg = BaseExceptionGroup('A', [BaseException('B')])
         err = traceback.format_exception_only(eg, show_group=True)
@@ -258,8 +252,6 @@ def test_format_base_exception_group(self):
             '   BaseException: B\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_with_note(self):
         exc = ValueError('B')
         exc.add_note('Note')
@@ -271,8 +263,6 @@ def test_format_exception_group_with_note(self):
             '   Note\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_explicit_class(self):
         eg = ExceptionGroup('A', [ValueError('B')])
         err = traceback.format_exception_only(ExceptionGroup, eg, show_group=True)
@@ -281,8 +271,6 @@ def test_format_exception_group_explicit_class(self):
             '   ValueError: B\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_multiple_exceptions(self):
         eg = ExceptionGroup('A', [ValueError('B'), TypeError('C')])
         err = traceback.format_exception_only(eg, show_group=True)
@@ -292,8 +280,6 @@ def test_format_exception_group_multiple_exceptions(self):
             '   TypeError: C\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_multiline_messages(self):
         eg = ExceptionGroup('A\n1', [ValueError('B\n2')])
         err = traceback.format_exception_only(eg, show_group=True)
@@ -303,8 +289,6 @@ def test_format_exception_group_multiline_messages(self):
             '   2\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_multiline2_messages(self):
         exc = ValueError('B\n\n2\n')
         exc.add_note('\nC\n\n3')
@@ -323,8 +307,6 @@ def test_format_exception_group_multiline2_messages(self):
             '   IndexError: D\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_syntax_error(self):
         exc = SyntaxError("error", ("x.py", 23, None, "bad syntax"))
         eg = ExceptionGroup('A\n1', [exc])
@@ -336,8 +318,6 @@ def test_format_exception_group_syntax_error(self):
             '   SyntaxError: error\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_nested_with_notes(self):
         exc = IndexError('D')
         exc.add_note('Note\nmultiline')
@@ -358,8 +338,6 @@ def test_format_exception_group_nested_with_notes(self):
             '   TypeError: F\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_with_tracebacks(self):
         def f():
             try:
@@ -385,8 +363,6 @@ def g():
             '      TypeError: g\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_with_cause(self):
         def f():
             try:
@@ -404,8 +380,6 @@ def f():
             '   ValueError: 0\n',
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_group_syntax_error_with_custom_values(self):
         # See https://github.com/python/cpython/issues/128894
         for exc in [
@@ -550,16 +524,12 @@ def test_print_exception_exc(self):
         traceback.print_exception(Exception("projector"), file=output)
         self.assertEqual(output.getvalue(), "Exception: projector\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_print_last(self):
         with support.swap_attr(sys, 'last_exc', ValueError(42)):
             output = StringIO()
             traceback.print_last(file=output)
             self.assertEqual(output.getvalue(), "ValueError: 42\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_exception_exc(self):
         e = Exception("projector")
         output = traceback.format_exception(e)
@@ -598,8 +568,6 @@ def test_exception_is_None(self):
         self.assertEqual(
             traceback.format_exception_only(None, None), [NONE_EXC_STRING])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_signatures(self):
         self.assertEqual(
             str(inspect.signature(traceback.print_exception)),
@@ -2286,8 +2254,6 @@ def test_print_exception_bad_type_capi(self):
              'Exception expected for value, int found\n')
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_print_exception_bad_type_python(self):
         msg = "Exception expected for value, int found"
         with self.assertRaisesRegex(TypeError, msg):
@@ -2366,8 +2332,6 @@ def test_simple(self):
         self.assertTrue(lines[1].startswith('  File'))
         self.assertIn('1/0 # Marker', lines[2])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cause(self):
         def inner_raise():
             try:
@@ -2501,8 +2465,6 @@ def test_message_none(self):
         err = self.get_report(Exception(''))
         self.assertIn('Exception\n', err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_syntax_error_various_offsets(self):
         for offset in range(-5, 10):
             for add in [0, 2]:
@@ -2525,8 +2487,6 @@ def test_syntax_error_various_offsets(self):
                 exp = "\n".join(expected)
                 self.assertEqual(exp, err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_with_note(self):
         e = ValueError(123)
         vanilla = self.get_report(e)
@@ -2545,8 +2505,6 @@ def test_exception_with_note(self):
         del e.__notes__
         self.assertEqual(self.get_report(e), vanilla)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_with_invalid_notes(self):
         e = ValueError(123)
         vanilla = self.get_report(e)
@@ -2604,8 +2562,6 @@ def __getattr__(self, name):
             self.get_report(e),
             vanilla + "Ignored error getting __notes__: ValueError('no __notes__')\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_with_multiple_notes(self):
         for e in [ValueError(42), SyntaxError('bad syntax')]:
             with self.subTest(e=e):
@@ -2685,8 +2641,6 @@ def __str__(self):
         exp = f'<unknown>.{X.__qualname__}: I am X\n'
         self.assertEqual(exp, err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_bad__str__(self):
         class X(Exception):
             def __str__(self):
@@ -2861,8 +2815,6 @@ def exc():
         report = self.get_report(exc)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_width_limit(self):
         excs = []
         for i in range(1000):
@@ -2907,8 +2859,6 @@ def test_exception_group_width_limit(self):
         report = self.get_report(eg)
         self.assertEqual(report, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_depth_limit(self):
         exc = TypeError('bad type')
         for i in range(1000):
@@ -3371,8 +3321,6 @@ def test_basics(self):
         self.assertNotEqual(f, object())
         self.assertEqual(f, ALWAYS_EQ)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_lazy_lines(self):
         linecache.clearcache()
         f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
@@ -3509,8 +3457,6 @@ def some_inner():
             s.format(),
             [f'{__file__}:{some_inner.__code__.co_firstlineno + 1}'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dropping_frames(self):
         def f():
             1/0
@@ -3611,13 +3557,9 @@ def do_test_smoke(self, exc, expected_type_str):
         self.assertEqual(expected_type_str, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_smoke_builtin(self):
         self.do_test_smoke(ValueError(42), 'ValueError')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_smoke_user_exception(self):
         class MyException(Exception):
             pass
@@ -3630,8 +3572,6 @@ class MyException(Exception):
                         'test_smoke_user_exception.<locals>.MyException')
         self.do_test_smoke(MyException('bad things happened'), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_from_exception(self):
         # Check all the parameters are accepted.
         def foo():
@@ -3657,8 +3597,6 @@ def foo():
         self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cause(self):
         try:
             try:
@@ -3683,8 +3621,6 @@ def test_cause(self):
         self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_context(self):
         try:
             try:
@@ -3734,8 +3670,6 @@ def f():
         self.assertIn(
             "RecursionError: maximum recursion depth exceeded", res[-1])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compact_with_cause(self):
         try:
             try:
@@ -3758,8 +3692,6 @@ def test_compact_with_cause(self):
         self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compact_no_cause(self):
         try:
             try:
@@ -3782,8 +3714,6 @@ def test_compact_no_cause(self):
         self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
         self.assertEqual(str(exc_obj), str(exc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_no_save_exc_type(self):
         try:
             1/0
@@ -3912,8 +3842,6 @@ def test_lookup_lines(self):
         linecache.updatecache('/foo.py', globals())
         self.assertEqual(exc.stack[0].line, "import sys")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_locals(self):
         linecache.updatecache('/foo.py', globals())
         e = Exception("uh oh")
@@ -3962,8 +3890,6 @@ def f():
              'ZeroDivisionError: division by zero',
              ''])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dont_swallow_cause_or_context_of_falsey_exception(self):
         # see gh-132308: Ensure that __cause__ or __context__ attributes of exceptions
         # that evaluate as falsey are included in the output. For falsey term,
@@ -4034,8 +3960,6 @@ def test_exception_group_format_exception_only(self):
 
         self.assertEqual(formatted, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_format_exception_onlyi_recursive(self):
         teg = traceback.TracebackException.from_exception(self.eg)
         formatted = ''.join(teg.format_exception_only(show_group=True)).split('\n')
@@ -4100,8 +4024,6 @@ def test_exception_group_format(self):
 
         self.assertEqual(formatted, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_group_width(self):
         excs1 = []
         excs2 = []
@@ -4140,8 +4062,6 @@ def test_max_group_width(self):
 
         self.assertEqual(formatted, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_group_depth(self):
         exc = TypeError('bad type')
         for i in range(3):
@@ -4191,8 +4111,6 @@ def test_comparison(self):
         self.assertNotEqual(exc, object())
         self.assertEqual(exc, ALWAYS_EQ)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dont_swallow_subexceptions_of_falsey_exceptiongroup(self):
         # see gh-132308: Ensure that subexceptions of exception groups
         # that evaluate as falsey are displayed in the output. For falsey term,
@@ -4230,8 +4148,6 @@ def callable():
         )
         return result_lines[0]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getattr_suggestions(self):
         class Substitution:
             noise = more_noise = a = bc = None
@@ -4275,8 +4191,6 @@ class CaseChangeOverSubstitution:
             actual = self.get_suggestion(cls(), 'bluch')
             self.assertIn(suggestion, actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getattr_suggestions_underscored(self):
         class A:
             bluch = None
@@ -4330,8 +4244,6 @@ class A:
         actual = self.get_suggestion(A(), 'bluch')
         self.assertNotIn("blech", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getattr_suggestions_no_args(self):
         class A:
             blech = None
@@ -4349,8 +4261,6 @@ def __getattr__(self, attr):
         actual = self.get_suggestion(A(), 'bluch')
         self.assertIn("blech", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getattr_suggestions_invalid_args(self):
         class NonStringifyClass:
             __str__ = None
@@ -4392,8 +4302,6 @@ def __dir__(self):
         self.assertNotIn("blech", actual)
         self.assertNotIn("oh no!", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attribute_error_with_non_string_candidates(self):
         class T:
             bluch = 1
@@ -4567,8 +4475,6 @@ def raise_attribute_error_with_bad_name():
         )
         self.assertNotIn("?", result_lines[-1])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_suggestions(self):
         def Substitution():
             noise = more_noise = a = bc = None
@@ -4609,24 +4515,18 @@ def EliminationOverAddition():
             actual = self.get_suggestion(func)
             self.assertIn(suggestion, actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_suggestions_from_globals(self):
         def func():
             print(global_for_suggestio)
         actual = self.get_suggestion(func)
         self.assertIn("'global_for_suggestions'?", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_suggestions_from_builtins(self):
         def func():
             print(ZeroDivisionErrrrr)
         actual = self.get_suggestion(func)
         self.assertIn("'ZeroDivisionError'?", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_suggestions_from_builtins_when_builtins_is_module(self):
         def func():
             custom_globals = globals().copy()
@@ -4635,8 +4535,6 @@ def func():
         actual = self.get_suggestion(func)
         self.assertIn("'ZeroDivisionError'?", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_suggestions_with_non_string_candidates(self):
         def func():
             abc = 1
@@ -4785,8 +4683,6 @@ def func():
         actual = self.get_suggestion(func)
         self.assertNotIn("blech", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_with_instance(self):
         class A:
             def __init__(self):
@@ -4843,8 +4739,6 @@ def func():
         actual = self.get_suggestion(func)
         self.assertNotIn("something", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_for_stdlib_modules(self):
         def func():
             stream = io.StringIO()
@@ -4852,8 +4746,6 @@ def func():
         actual = self.get_suggestion(func)
         self.assertIn("forget to import 'io'", actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_error_for_private_stdlib_modules(self):
         def func():
             stream = _io.StringIO()
@@ -4898,8 +4790,6 @@ def test_all(self):
                 expected.add(name)
         self.assertCountEqual(traceback.__all__, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_levenshtein_distance(self):
         # copied from _testinternalcapi.test_edit_cost
         # to also exercise the Python implementation
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index b291d530169..b9c1fd6134e 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -724,6 +724,8 @@ def doTraceback(self, module):
         else:
             raise AssertionError("This ought to be impossible")
 
+    # TODO: RUSTPYTHON; empty caret lines from equal col/end_col
+    @unittest.expectedFailure
     def testTraceback(self):
         files = {TESTMOD + ".py": (NOW, raise_src)}
         self.doTest(None, files, TESTMOD, call=self.doTraceback)
diff --git a/Lib/traceback.py b/Lib/traceback.py
index d6a010f4157..572a3177cb0 100644
--- a/Lib/traceback.py
+++ b/Lib/traceback.py
@@ -1,9 +1,14 @@
 """Extract, format and print information about Python stack traces."""
 
-import collections
+import collections.abc
 import itertools
 import linecache
 import sys
+import textwrap
+import warnings
+from contextlib import suppress
+import _colorize
+from _colorize import ANSIColors
 
 __all__ = ['extract_stack', 'extract_tb', 'format_exception',
            'format_exception_only', 'format_list', 'format_stack',
@@ -16,6 +21,7 @@
 # Formatting and printing lists of traceback lines.
 #
 
+
 def print_list(extracted_list, file=None):
     """Print the list of tuples as returned by extract_tb() or
     extract_stack() as a formatted stack trace to the given file."""
@@ -69,7 +75,8 @@ def extract_tb(tb, limit=None):
     trace.  The line is a string with leading and trailing
     whitespace stripped; if the source is not available it is None.
     """
-    return StackSummary.extract(walk_tb(tb), limit=limit)
+    return StackSummary._extract_from_extended_frame_gen(
+        _walk_tb_with_full_positions(tb), limit=limit)
 
 #
 # Exception formatting and output.
@@ -95,14 +102,18 @@ def _parse_value_tb(exc, value, tb):
         raise ValueError("Both or neither of value and tb must be given")
     if value is tb is _sentinel:
         if exc is not None:
-            return exc, exc.__traceback__
+            if isinstance(exc, BaseException):
+                return exc, exc.__traceback__
+
+            raise TypeError(f'Exception expected for value, '
+                            f'{type(exc).__name__} found')
         else:
             return None, None
     return value, tb
 
 
 def print_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
-                    file=None, chain=True):
+                    file=None, chain=True, **kwargs):
     """Print exception up to 'limit' stack trace entries from 'tb' to 'file'.
 
     This differs from print_tb() in the following ways: (1) if
@@ -113,16 +124,23 @@ def print_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
     occurred with a caret on the next line indicating the approximate
     position of the error.
     """
+    colorize = kwargs.get("colorize", False)
     value, tb = _parse_value_tb(exc, value, tb)
-    if file is None:
-        file = sys.stderr
     te = TracebackException(type(value), value, tb, limit=limit, compact=True)
-    for line in te.format(chain=chain):
-        print(line, file=file, end="")
+    te.print(file=file, chain=chain, colorize=colorize)
+
+
+BUILTIN_EXCEPTION_LIMIT = object()
+
+
+def _print_exception_bltin(exc, /):
+    file = sys.stderr if sys.stderr is not None else sys.__stderr__
+    colorize = _colorize.can_colorize(file=file)
+    return print_exception(exc, limit=BUILTIN_EXCEPTION_LIMIT, file=file, colorize=colorize)
 
 
 def format_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
-                     chain=True):
+                     chain=True, **kwargs):
     """Format a stack trace and the exception information.
 
     The arguments have the same meaning as the corresponding arguments
@@ -131,64 +149,79 @@ def format_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
     these lines are concatenated and printed, exactly the same text is
     printed as does print_exception().
     """
+    colorize = kwargs.get("colorize", False)
     value, tb = _parse_value_tb(exc, value, tb)
     te = TracebackException(type(value), value, tb, limit=limit, compact=True)
-    return list(te.format(chain=chain))
+    return list(te.format(chain=chain, colorize=colorize))
 
 
-def format_exception_only(exc, /, value=_sentinel):
+def format_exception_only(exc, /, value=_sentinel, *, show_group=False, **kwargs):
     """Format the exception part of a traceback.
 
     The return value is a list of strings, each ending in a newline.
 
-    Normally, the list contains a single string; however, for
-    SyntaxError exceptions, it contains several lines that (when
-    printed) display detailed information about where the syntax
-    error occurred.
-
-    The message indicating which exception occurred is always the last
-    string in the list.
+    The list contains the exception's message, which is
+    normally a single string; however, for :exc:`SyntaxError` exceptions, it
+    contains several lines that (when printed) display detailed information
+    about where the syntax error occurred. Following the message, the list
+    contains the exception's ``__notes__``.
 
+    When *show_group* is ``True``, and the exception is an instance of
+    :exc:`BaseExceptionGroup`, the nested exceptions are included as
+    well, recursively, with indentation relative to their nesting depth.
     """
+    colorize = kwargs.get("colorize", False)
     if value is _sentinel:
         value = exc
     te = TracebackException(type(value), value, None, compact=True)
-    return list(te.format_exception_only())
+    return list(te.format_exception_only(show_group=show_group, colorize=colorize))
 
 
 # -- not official API but folk probably use these two functions.
 
-def _format_final_exc_line(etype, value):
-    valuestr = _some_str(value)
-    if value is None or not valuestr:
-        line = "%s\n" % etype
+def _format_final_exc_line(etype, value, *, insert_final_newline=True, colorize=False):
+    valuestr = _safe_string(value, 'exception')
+    end_char = "\n" if insert_final_newline else ""
+    if colorize:
+        if value is None or not valuestr:
+            line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}{end_char}"
+        else:
+            line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}: {ANSIColors.MAGENTA}{valuestr}{ANSIColors.RESET}{end_char}"
     else:
-        line = "%s: %s\n" % (etype, valuestr)
+        if value is None or not valuestr:
+            line = f"{etype}{end_char}"
+        else:
+            line = f"{etype}: {valuestr}{end_char}"
     return line
 
-def _some_str(value):
+
+def _safe_string(value, what, func=str):
     try:
-        return str(value)
+        return func(value)
     except:
-        return '<unprintable %s object>' % type(value).__name__
+        return f'<{what} {func.__name__}() failed>'
 
 # --
 
 def print_exc(limit=None, file=None, chain=True):
-    """Shorthand for 'print_exception(*sys.exc_info(), limit, file)'."""
-    print_exception(*sys.exc_info(), limit=limit, file=file, chain=chain)
+    """Shorthand for 'print_exception(sys.exception(), limit=limit, file=file, chain=chain)'."""
+    print_exception(sys.exception(), limit=limit, file=file, chain=chain)
 
 def format_exc(limit=None, chain=True):
     """Like print_exc() but return a string."""
-    return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain))
+    return "".join(format_exception(sys.exception(), limit=limit, chain=chain))
 
 def print_last(limit=None, file=None, chain=True):
-    """This is a shorthand for 'print_exception(sys.last_type,
-    sys.last_value, sys.last_traceback, limit, file)'."""
-    if not hasattr(sys, "last_type"):
+    """This is a shorthand for 'print_exception(sys.last_exc, limit=limit, file=file, chain=chain)'."""
+    if not hasattr(sys, "last_exc") and not hasattr(sys, "last_type"):
         raise ValueError("no last exception")
-    print_exception(sys.last_type, sys.last_value, sys.last_traceback,
-                    limit, file, chain)
+
+    if hasattr(sys, "last_exc"):
+        print_exception(sys.last_exc, limit=limit, file=file, chain=chain)
+    else:
+        print_exception(sys.last_type, sys.last_value, sys.last_traceback,
+                        limit=limit, file=file, chain=chain)
+
 
 #
 # Printing and Extracting Stacks.
@@ -241,7 +274,7 @@ def clear_frames(tb):
 
 
 class FrameSummary:
-    """A single frame from a traceback.
+    """Information about a single frame from a traceback.
 
     - :attr:`filename` The filename for the frame.
     - :attr:`lineno` The line within filename for the frame that was
@@ -254,10 +287,12 @@ class FrameSummary:
       mapping the name to the repr() of the variable.
     """
 
-    __slots__ = ('filename', 'lineno', 'name', '_line', 'locals')
+    __slots__ = ('filename', 'lineno', 'end_lineno', 'colno', 'end_colno',
+                 'name', '_lines', '_lines_dedented', 'locals', '_code')
 
     def __init__(self, filename, lineno, name, *, lookup_line=True,
-            locals=None, line=None):
+            locals=None, line=None,
+            end_lineno=None, colno=None, end_colno=None, **kwargs):
         """Construct a FrameSummary.
 
         :param lookup_line: If True, `linecache` is consulted for the source
@@ -269,11 +304,17 @@ def __init__(self, filename, lineno, name, *, lookup_line=True,
         """
         self.filename = filename
         self.lineno = lineno
+        self.end_lineno = lineno if end_lineno is None else end_lineno
+        self.colno = colno
+        self.end_colno = end_colno
         self.name = name
-        self._line = line
+        self._code = kwargs.get("_code")
+        self._lines = line
+        self._lines_dedented = None
         if lookup_line:
             self.line
-        self.locals = {k: repr(v) for k, v in locals.items()} if locals else None
+        self.locals = {k: _safe_string(v, 'local', func=repr)
+            for k, v in locals.items()} if locals else None
 
     def __eq__(self, other):
         if isinstance(other, FrameSummary):
@@ -298,13 +339,43 @@ def __repr__(self):
     def __len__(self):
         return 4
 
+    def _set_lines(self):
+        if (
+            self._lines is None
+            and self.lineno is not None
+            and self.end_lineno is not None
+        ):
+            lines = []
+            for lineno in range(self.lineno, self.end_lineno + 1):
+                # treat errors (empty string) and empty lines (newline) as the same
+                line = linecache.getline(self.filename, lineno).rstrip()
+                if not line and self._code is not None and self.filename.startswith("<"):
+                    line = linecache._getline_from_code(self._code, lineno).rstrip()
+                lines.append(line)
+            self._lines = "\n".join(lines) + "\n"
+
+    @property
+    def _original_lines(self):
+        # Returns the line as-is from the source, without modifying whitespace.
+        self._set_lines()
+        return self._lines
+
+    @property
+    def _dedented_lines(self):
+        # Returns _original_lines, but dedented
+        self._set_lines()
+        if self._lines_dedented is None and self._lines is not None:
+            self._lines_dedented = textwrap.dedent(self._lines)
+        return self._lines_dedented
+
     @property
     def line(self):
-        if self._line is None:
-            if self.lineno is None:
-                return None
-            self._line = linecache.getline(self.filename, self.lineno)
-        return self._line.strip()
+        self._set_lines()
+        if self._lines is None:
+            return None
+        # return only the first line, stripped
+        return self._lines.partition("\n")[0].strip()
+
 
 def walk_stack(f):
     """Walk a stack yielding the frame and line number for each frame.
@@ -313,7 +384,7 @@ def walk_stack(f):
     current stack is used. Usually used with StackSummary.extract.
     """
     if f is None:
-        f = sys._getframe().f_back.f_back
+        f = sys._getframe().f_back.f_back.f_back.f_back
     while f is not None:
         yield f, f.f_lineno
         f = f.f_back
@@ -330,18 +401,40 @@ def walk_tb(tb):
         tb = tb.tb_next
 
 
+def _walk_tb_with_full_positions(tb):
+    # Internal version of walk_tb that yields full code positions including
+    # end line and column information.
+    while tb is not None:
+        positions = _get_code_position(tb.tb_frame.f_code, tb.tb_lasti)
+        # Yield tb_lineno when co_positions does not have a line number to
+        # maintain behavior with walk_tb.
+        if positions[0] is None:
+            yield tb.tb_frame, (tb.tb_lineno, ) + positions[1:]
+        else:
+            yield tb.tb_frame, positions
+        tb = tb.tb_next
+
+
+def _get_code_position(code, instruction_index):
+    if instruction_index < 0:
+        return (None, None, None, None)
+    positions_gen = code.co_positions()
+    return next(itertools.islice(positions_gen, instruction_index // 2, None))
+
+
 _RECURSIVE_CUTOFF = 3 # Also hardcoded in traceback.c.
 
+
 class StackSummary(list):
-    """A stack of frames."""
+    """A list of FrameSummary objects, representing a stack of frames."""
 
     @classmethod
     def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
             capture_locals=False):
         """Create a StackSummary from a traceback or stack object.
 
-        :param frame_gen: A generator that yields (frame, lineno) tuples to
-            include in the stack.
+        :param frame_gen: A generator that yields (frame, lineno) tuples
+            whose summaries are to be included in the stack.
         :param limit: None to include all frames or the number of frames to
             include.
         :param lookup_lines: If True, lookup lines for each frame immediately,
@@ -349,23 +442,41 @@ def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
         :param capture_locals: If True, the local variables from each frame will
             be captured as object representations into the FrameSummary.
         """
-        if limit is None:
+        def extended_frame_gen():
+            for f, lineno in frame_gen:
+                yield f, (lineno, None, None, None)
+
+        return klass._extract_from_extended_frame_gen(
+            extended_frame_gen(), limit=limit, lookup_lines=lookup_lines,
+            capture_locals=capture_locals)
+
+    @classmethod
+    def _extract_from_extended_frame_gen(klass, frame_gen, *, limit=None,
+            lookup_lines=True, capture_locals=False):
+        # Same as extract but operates on a frame generator that yields
+        # (frame, (lineno, end_lineno, colno, end_colno)) in the stack.
+        # Only lineno is required, the remaining fields can be None if the
+        # information is not available.
+        builtin_limit = limit is BUILTIN_EXCEPTION_LIMIT
+        if limit is None or builtin_limit:
             limit = getattr(sys, 'tracebacklimit', None)
             if limit is not None and limit < 0:
                 limit = 0
         if limit is not None:
-            if limit >= 0:
+            if builtin_limit:
+                frame_gen = tuple(frame_gen)
+                frame_gen = frame_gen[len(frame_gen) - limit:]
+            elif limit >= 0:
                 frame_gen = itertools.islice(frame_gen, limit)
             else:
                 frame_gen = collections.deque(frame_gen, maxlen=-limit)
 
         result = klass()
         fnames = set()
-        for f, lineno in frame_gen:
+        for f, (lineno, end_lineno, colno, end_colno) in frame_gen:
             co = f.f_code
             filename = co.co_filename
             name = co.co_name
-
             fnames.add(filename)
             linecache.lazycache(filename, f.f_globals)
             # Must defer line lookups until we have called checkcache.
@@ -373,10 +484,16 @@ def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
                 f_locals = f.f_locals
             else:
                 f_locals = None
-            result.append(FrameSummary(
-                filename, lineno, name, lookup_line=False, locals=f_locals))
+            result.append(
+                FrameSummary(filename, lineno, name,
+                    lookup_line=False, locals=f_locals,
+                    end_lineno=end_lineno, colno=colno, end_colno=end_colno,
+                    _code=f.f_code,
+                )
+            )
         for filename in fnames:
             linecache.checkcache(filename)
+
         # If immediate lookup was desired, trigger lookups now.
         if lookup_lines:
             for f in result:
@@ -402,7 +519,223 @@ def from_list(klass, a_list):
                 result.append(FrameSummary(filename, lineno, name, line=line))
         return result
 
-    def format(self):
+    def format_frame_summary(self, frame_summary, **kwargs):
+        """Format the lines for a single FrameSummary.
+
+        Returns a string representing one frame involved in the stack. This
+        gets called for every frame to be printed in the stack summary.
+        """
+        colorize = kwargs.get("colorize", False)
+        row = []
+        filename = frame_summary.filename
+        if frame_summary.filename.startswith("<stdin-") and frame_summary.filename.endswith('>'):
+            filename = "<stdin>"
+        if colorize:
+            row.append('  File {}"{}"{}, line {}{}{}, in {}{}{}\n'.format(
+                    ANSIColors.MAGENTA,
+                    filename,
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    frame_summary.lineno,
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    frame_summary.name,
+                    ANSIColors.RESET,
+                    )
+            )
+        else:
+            row.append('  File "{}", line {}, in {}\n'.format(
+                filename, frame_summary.lineno, frame_summary.name))
+        if frame_summary._dedented_lines and frame_summary._dedented_lines.strip():
+            if (
+                frame_summary.colno is None or
+                frame_summary.end_colno is None
+            ):
+                # only output first line if column information is missing
+                row.append(textwrap.indent(frame_summary.line, '    ') + "\n")
+            else:
+                # get first and last line
+                all_lines_original = frame_summary._original_lines.splitlines()
+                first_line = all_lines_original[0]
+                # assume all_lines_original has enough lines (since we constructed it)
+                last_line = all_lines_original[frame_summary.end_lineno - frame_summary.lineno]
+
+                # character index of the start/end of the instruction
+                start_offset = _byte_offset_to_character_offset(first_line, frame_summary.colno)
+                end_offset = _byte_offset_to_character_offset(last_line, frame_summary.end_colno)
+
+                all_lines = frame_summary._dedented_lines.splitlines()[
+                    :frame_summary.end_lineno - frame_summary.lineno + 1
+                ]
+
+                # adjust start/end offset based on dedent
+                dedent_characters = len(first_line) - len(all_lines[0])
+                start_offset = max(0, start_offset - dedent_characters)
+                end_offset = max(0, end_offset - dedent_characters)
+
+                # When showing this on a terminal, some of the non-ASCII characters
+                # might be rendered as double-width characters, so we need to take
+                # that into account when calculating the length of the line.
+                dp_start_offset = _display_width(all_lines[0], offset=start_offset)
+                dp_end_offset = _display_width(all_lines[-1], offset=end_offset)
+
+                # get exact code segment corresponding to the instruction
+                segment = "\n".join(all_lines)
+                segment = segment[start_offset:len(segment) - (len(all_lines[-1]) - end_offset)]
+
+                # attempt to parse for anchors
+                anchors = None
+                show_carets = False
+                with suppress(Exception):
+                    anchors = _extract_caret_anchors_from_line_segment(segment)
+                show_carets = self._should_show_carets(start_offset, end_offset, all_lines, anchors)
+
+                result = []
+
+                # only display first line, last line, and lines around anchor start/end
+                significant_lines = {0, len(all_lines) - 1}
+
+                anchors_left_end_offset = 0
+                anchors_right_start_offset = 0
+                primary_char = "^"
+                secondary_char = "^"
+                if anchors:
+                    anchors_left_end_offset = anchors.left_end_offset
+                    anchors_right_start_offset = anchors.right_start_offset
+                    # computed anchor positions do not take start_offset into account,
+                    # so account for it here
+                    if anchors.left_end_lineno == 0:
+                        anchors_left_end_offset += start_offset
+                    if anchors.right_start_lineno == 0:
+                        anchors_right_start_offset += start_offset
+
+                    # account for display width
+                    anchors_left_end_offset = _display_width(
+                        all_lines[anchors.left_end_lineno], offset=anchors_left_end_offset
+                    )
+                    anchors_right_start_offset = _display_width(
+                        all_lines[anchors.right_start_lineno], offset=anchors_right_start_offset
+                    )
+
+                    primary_char = anchors.primary_char
+                    secondary_char = anchors.secondary_char
+                    significant_lines.update(
+                        range(anchors.left_end_lineno - 1, anchors.left_end_lineno + 2)
+                    )
+                    significant_lines.update(
+                        range(anchors.right_start_lineno - 1, anchors.right_start_lineno + 2)
+                    )
+
+                # remove bad line numbers
+                significant_lines.discard(-1)
+                significant_lines.discard(len(all_lines))
+
+                def output_line(lineno):
+                    """output all_lines[lineno] along with carets"""
+                    result.append(all_lines[lineno] + "\n")
+                    if not show_carets:
+                        return
+                    num_spaces = len(all_lines[lineno]) - len(all_lines[lineno].lstrip())
+                    carets = []
+                    num_carets = dp_end_offset if lineno == len(all_lines) - 1 else _display_width(all_lines[lineno])
+                    # compute caret character for each position
+                    for col in range(num_carets):
+                        if col < num_spaces or (lineno == 0 and col < dp_start_offset):
+                            # before first non-ws char of the line, or before start of instruction
+                            carets.append(' ')
+                        elif anchors and (
+                            lineno > anchors.left_end_lineno or
+                            (lineno == anchors.left_end_lineno and col >= anchors_left_end_offset)
+                        ) and (
+                            lineno < anchors.right_start_lineno or
+                            (lineno == anchors.right_start_lineno and col < anchors_right_start_offset)
+                        ):
+                            # within anchors
+                            carets.append(secondary_char)
+                        else:
+                            carets.append(primary_char)
+                    if colorize:
+                        # Replace the previous line with a red version of it only in the parts covered
+                        # by the carets.
+                        line = result[-1]
+                        colorized_line_parts = []
+                        colorized_carets_parts = []
+
+                        for color, group in itertools.groupby(itertools.zip_longest(line, carets, fillvalue=""), key=lambda x: x[1]):
+                            caret_group = list(group)
+                            if color == "^":
+                                colorized_line_parts.append(ANSIColors.BOLD_RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+                                colorized_carets_parts.append(ANSIColors.BOLD_RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
+                            elif color == "~":
+                                colorized_line_parts.append(ANSIColors.RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+                                colorized_carets_parts.append(ANSIColors.RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
+                            else:
+                                colorized_line_parts.append("".join(char for char, _ in caret_group))
+                                colorized_carets_parts.append("".join(caret for _, caret in caret_group))
+
+                        colorized_line = "".join(colorized_line_parts)
+                        colorized_carets = "".join(colorized_carets_parts)
+                        result[-1] = colorized_line
+                        result.append(colorized_carets + "\n")
+                    else:
+                        result.append("".join(carets) + "\n")
+
+                # display significant lines
+                sig_lines_list = sorted(significant_lines)
+                for i, lineno in enumerate(sig_lines_list):
+                    if i:
+                        linediff = lineno - sig_lines_list[i - 1]
+                        if linediff == 2:
+                            # 1 line in between - just output it
+                            output_line(lineno - 1)
+                        elif linediff > 2:
+                            # > 1 line in between - abbreviate
+                            result.append(f"...<{linediff - 1} lines>...\n")
+                    output_line(lineno)
+
+                row.append(
+                    textwrap.indent(textwrap.dedent("".join(result)), '    ', lambda line: True)
+                )
+        if frame_summary.locals:
+            for name, value in sorted(frame_summary.locals.items()):
+                row.append('    {name} = {value}\n'.format(name=name, value=value))
+
+        return ''.join(row)
+
+    def _should_show_carets(self, start_offset, end_offset, all_lines, anchors):
+        with suppress(SyntaxError, ImportError):
+            import ast
+            tree = ast.parse('\n'.join(all_lines))
+            if not tree.body:
+                return False
+            statement = tree.body[0]
+            value = None
+            def _spawns_full_line(value):
+                return (
+                    value.lineno == 1
+                    and value.end_lineno == len(all_lines)
+                    and value.col_offset == start_offset
+                    and value.end_col_offset == end_offset
+                )
+            match statement:
+                case ast.Return(value=ast.Call()):
+                    if isinstance(statement.value.func, ast.Name):
+                        value = statement.value
+                case ast.Assign(value=ast.Call()):
+                    if (
+                        len(statement.targets) == 1 and
+                        isinstance(statement.targets[0], ast.Name)
+                    ):
+                        value = statement.value
+            if value is not None and _spawns_full_line(value):
+                return False
+        if anchors:
+            return True
+        if all_lines[0][:start_offset].lstrip() or all_lines[-1][end_offset:].rstrip():
+            return True
+        return False
+
+    def format(self, **kwargs):
         """Format the stack ready for printing.
 
         Returns a list of strings ready for printing.  Each string in the
@@ -414,37 +747,34 @@ def format(self):
         repetitions are shown, followed by a summary line stating the exact
         number of further repetitions.
         """
+        colorize = kwargs.get("colorize", False)
         result = []
         last_file = None
         last_line = None
         last_name = None
         count = 0
-        for frame in self:
-            if (last_file is None or last_file != frame.filename or
-                last_line is None or last_line != frame.lineno or
-                last_name is None or last_name != frame.name):
+        for frame_summary in self:
+            formatted_frame = self.format_frame_summary(frame_summary, colorize=colorize)
+            if formatted_frame is None:
+                continue
+            if (last_file is None or last_file != frame_summary.filename or
+                last_line is None or last_line != frame_summary.lineno or
+                last_name is None or last_name != frame_summary.name):
                 if count > _RECURSIVE_CUTOFF:
                     count -= _RECURSIVE_CUTOFF
                     result.append(
                         f'  [Previous line repeated {count} more '
                         f'time{"s" if count > 1 else ""}]\n'
                     )
-                last_file = frame.filename
-                last_line = frame.lineno
-                last_name = frame.name
+                last_file = frame_summary.filename
+                last_line = frame_summary.lineno
+                last_name = frame_summary.name
                 count = 0
             count += 1
             if count > _RECURSIVE_CUTOFF:
                 continue
-            row = []
-            row.append('  File "{}", line {}, in {}\n'.format(
-                frame.filename, frame.lineno, frame.name))
-            if frame.line:
-                row.append('    {}\n'.format(frame.line.strip()))
-            if frame.locals:
-                for name, value in sorted(frame.locals.items()):
-                    row.append('    {name} = {value}\n'.format(name=name, value=value))
-            result.append(''.join(row))
+            result.append(formatted_frame)
+
         if count > _RECURSIVE_CUTOFF:
             count -= _RECURSIVE_CUTOFF
             result.append(
@@ -454,6 +784,216 @@ def format(self):
         return result
 
 
+def _byte_offset_to_character_offset(str, offset):
+    as_utf8 = str.encode('utf-8')
+    return len(as_utf8[:offset].decode("utf-8", errors="replace"))
+
+
+_Anchors = collections.namedtuple(
+    "_Anchors",
+    [
+        "left_end_lineno",
+        "left_end_offset",
+        "right_start_lineno",
+        "right_start_offset",
+        "primary_char",
+        "secondary_char",
+    ],
+    defaults=["~", "^"]
+)
+
+def _extract_caret_anchors_from_line_segment(segment):
+    """
+    Given source code `segment` corresponding to a FrameSummary, determine:
+        - for binary ops, the location of the binary op
+        - for indexing and function calls, the location of the brackets.
+    `segment` is expected to be a valid Python expression.
+    """
+    import ast
+
+    try:
+        # Without parentheses, `segment` is parsed as a statement.
+        # Binary ops, subscripts, and calls are expressions, so
+        # we can wrap them with parentheses to parse them as
+        # (possibly multi-line) expressions.
+        # e.g. if we try to highlight the addition in
+        # x = (
+        #     a +
+        #     b
+        # )
+        # then we would ast.parse
+        #     a +
+        #     b
+        # which is not a valid statement because of the newline.
+        # Adding brackets makes it a valid expression.
+        # (
+        #     a +
+        #     b
+        # )
+        # Line locations will be different than the original,
+        # which is taken into account later on.
+        tree = ast.parse(f"(\n{segment}\n)")
+    except SyntaxError:
+        return None
+
+    if len(tree.body) != 1:
+        return None
+
+    lines = segment.splitlines()
+
+    def normalize(lineno, offset):
+        """Get character index given byte offset"""
+        return _byte_offset_to_character_offset(lines[lineno], offset)
+
+    def next_valid_char(lineno, col):
+        """Gets the next valid character index in `lines`, if
+        the current location is not valid. Handles empty lines.
+        """
+        while lineno < len(lines) and col >= len(lines[lineno]):
+            col = 0
+            lineno += 1
+        assert lineno < len(lines) and col < len(lines[lineno])
+        return lineno, col
+
+    def increment(lineno, col):
+        """Get the next valid character index in `lines`."""
+        col += 1
+        lineno, col = next_valid_char(lineno, col)
+        return lineno, col
+
+    def nextline(lineno, col):
+        """Get the next valid character at least on the next line"""
+        col = 0
+        lineno += 1
+        lineno, col = next_valid_char(lineno, col)
+        return lineno, col
+
+    def increment_until(lineno, col, stop):
+        """Get the next valid non-"\\#" character that satisfies the `stop` predicate"""
+        while True:
+            ch = lines[lineno][col]
+            if ch in "\\#":
+                lineno, col = nextline(lineno, col)
+            elif not stop(ch):
+                lineno, col = increment(lineno, col)
+            else:
+                break
+        return lineno, col
+
+    def setup_positions(expr, force_valid=True):
+        """Get the lineno/col position of the end of `expr`. If `force_valid` is True,
+        forces the position to be a valid character (e.g. if the position is beyond the
+        end of the line, move to the next line)
+        """
+        # -2 since end_lineno is 1-indexed and because we added an extra
+        # bracket + newline to `segment` when calling ast.parse
+        lineno = expr.end_lineno - 2
+        col = normalize(lineno, expr.end_col_offset)
+        return next_valid_char(lineno, col) if force_valid else (lineno, col)
+
+    statement = tree.body[0]
+    match statement:
+        case ast.Expr(expr):
+            match expr:
+                case ast.BinOp():
+                    # ast gives these locations for BinOp subexpressions
+                    # ( left_expr ) + ( right_expr )
+                    #   left^^^^^       right^^^^^
+                    lineno, col = setup_positions(expr.left)
+
+                    # First operator character is the first non-space/')' character
+                    lineno, col = increment_until(lineno, col, lambda x: not x.isspace() and x != ')')
+
+                    # binary op is 1 or 2 characters long, on the same line,
+                    # before the right subexpression
+                    right_col = col + 1
+                    if (
+                        right_col < len(lines[lineno])
+                        and (
+                            # operator char should not be in the right subexpression
+                            expr.right.lineno - 2 > lineno or
+                            right_col < normalize(expr.right.lineno - 2, expr.right.col_offset)
+                        )
+                        and not (ch := lines[lineno][right_col]).isspace()
+                        and ch not in "\\#"
+                    ):
+                        right_col += 1
+
+                    # right_col can be invalid since it is exclusive
+                    return _Anchors(lineno, col, lineno, right_col)
+                case ast.Subscript():
+                    # ast gives these locations for value and slice subexpressions
+                    # ( value_expr ) [ slice_expr ]
+                    #   value^^^^^     slice^^^^^
+                    # subscript^^^^^^^^^^^^^^^^^^^^
+
+                    # find left bracket
+                    left_lineno, left_col = setup_positions(expr.value)
+                    left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '[')
+                    # find right bracket (final character of expression)
+                    right_lineno, right_col = setup_positions(expr, force_valid=False)
+                    return _Anchors(left_lineno, left_col, right_lineno, right_col)
+                case ast.Call():
+                    # ast gives these locations for function call expressions
+                    # ( func_expr ) (args, kwargs)
+                    #   func^^^^^
+                    # call^^^^^^^^^^^^^^^^^^^^^^^^
+
+                    # find left bracket
+                    left_lineno, left_col = setup_positions(expr.func)
+                    left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '(')
+                    # find right bracket (final character of expression)
+                    right_lineno, right_col = setup_positions(expr, force_valid=False)
+                    return _Anchors(left_lineno, left_col, right_lineno, right_col)
+
+    return None
+
+_WIDE_CHAR_SPECIFIERS = "WF"
+
+def _display_width(line, offset=None):
+    """Calculate the extra amount of width space the given source
+    code segment might take if it were to be displayed on a fixed
+    width output device. Supports wide unicode characters and emojis."""
+
+    if offset is None:
+        offset = len(line)
+
+    # Fast track for ASCII-only strings
+    if line.isascii():
+        return offset
+
+    import unicodedata
+
+    return sum(
+        2 if unicodedata.east_asian_width(char) in _WIDE_CHAR_SPECIFIERS else 1
+        for char in line[:offset]
+    )
+
+
+
+class _ExceptionPrintContext:
+    def __init__(self):
+        self.seen = set()
+        self.exception_group_depth = 0
+        self.need_close = False
+
+    def indent(self):
+        return ' ' * (2 * self.exception_group_depth)
+
+    def emit(self, text_gen, margin_char=None):
+        if margin_char is None:
+            margin_char = '|'
+        indent_str = self.indent()
+        if self.exception_group_depth:
+            indent_str += margin_char + ' '
+
+        if isinstance(text_gen, str):
+            yield textwrap.indent(text_gen, indent_str, lambda line: True)
+        else:
+            for text in text_gen:
+                yield textwrap.indent(text, indent_str, lambda line: True)
+
+
 class TracebackException:
     """An exception ready for rendering.
 
@@ -461,16 +1001,24 @@ class TracebackException:
     to this intermediary form to ensure that no references are held, while
     still being able to fully print or format it.
 
+    max_group_width and max_group_depth control the formatting of exception
+    groups. The depth refers to the nesting level of the group, and the width
+    refers to the size of a single exception group's exceptions array. The
+    formatted output is truncated when either limit is exceeded.
+
     Use `from_exception` to create TracebackException instances from exception
     objects, or the constructor to create TracebackException instances from
     individual components.
 
     - :attr:`__cause__` A TracebackException of the original *__cause__*.
     - :attr:`__context__` A TracebackException of the original *__context__*.
+    - :attr:`exceptions` For exception groups - a list of TracebackException
+      instances for the nested *exceptions*.  ``None`` for other exceptions.
     - :attr:`__suppress_context__` The *__suppress_context__* value from the
       original exception.
     - :attr:`stack` A `StackSummary` representing the traceback.
-    - :attr:`exc_type` The class of the original traceback.
+    - :attr:`exc_type` (deprecated) The class of the original traceback.
+    - :attr:`exc_type_str` String display of exc_type
     - :attr:`filename` For syntax errors - the filename where the error
       occurred.
     - :attr:`lineno` For syntax errors - the linenumber where the error
@@ -481,14 +1029,14 @@ class TracebackException:
       occurred.
     - :attr:`offset` For syntax errors - the offset into the text where the
       error occurred.
-    - :attr:`end_offset` For syntax errors - the offset into the text where the
-      error occurred. Can be `None` if not present.
+    - :attr:`end_offset` For syntax errors - the end offset into the text where
+      the error occurred. Can be `None` if not present.
     - :attr:`msg` For syntax errors - the compiler error message.
     """
 
     def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             lookup_lines=True, capture_locals=False, compact=False,
-            _seen=None):
+            max_group_width=15, max_group_depth=10, save_exc_type=True, _seen=None):
         # NB: we need to accept exc_traceback, exc_value, exc_traceback to
         # permit backwards compat with the existing API, otherwise we
         # need stub thunk objects just to glue it together.
@@ -498,14 +1046,34 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             _seen = set()
         _seen.add(id(exc_value))
 
-        # TODO: locals.
-        self.stack = StackSummary.extract(
-            walk_tb(exc_traceback), limit=limit, lookup_lines=lookup_lines,
+        self.max_group_width = max_group_width
+        self.max_group_depth = max_group_depth
+
+        self.stack = StackSummary._extract_from_extended_frame_gen(
+            _walk_tb_with_full_positions(exc_traceback),
+            limit=limit, lookup_lines=lookup_lines,
             capture_locals=capture_locals)
-        self.exc_type = exc_type
+
+        self._exc_type = exc_type if save_exc_type else None
+
         # Capture now to permit freeing resources: only complication is in the
         # unofficial API _format_final_exc_line
-        self._str = _some_str(exc_value)
+        self._str = _safe_string(exc_value, 'exception')
+        try:
+            self.__notes__ = getattr(exc_value, '__notes__', None)
+        except Exception as e:
+            self.__notes__ = [
+                f'Ignored error getting __notes__: {_safe_string(e, '__notes__', repr)}']
+
+        self._is_syntax_error = False
+        self._have_exc_type = exc_type is not None
+        if exc_type is not None:
+            self.exc_type_qualname = exc_type.__qualname__
+            self.exc_type_module = exc_type.__module__
+        else:
+            self.exc_type_qualname = None
+            self.exc_type_module = None
+
         if exc_type and issubclass(exc_type, SyntaxError):
             # Handle SyntaxError's specially
             self.filename = exc_value.filename
@@ -517,6 +1085,26 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             self.offset = exc_value.offset
             self.end_offset = exc_value.end_offset
             self.msg = exc_value.msg
+            self._is_syntax_error = True
+        elif exc_type and issubclass(exc_type, ImportError) and \
+                getattr(exc_value, "name_from", None) is not None:
+            wrong_name = getattr(exc_value, "name_from", None)
+            suggestion = _compute_suggestion_error(exc_value, exc_traceback, wrong_name)
+            if suggestion:
+                self._str += f". Did you mean: '{suggestion}'?"
+        elif exc_type and issubclass(exc_type, (NameError, AttributeError)) and \
+                getattr(exc_value, "name", None) is not None:
+            wrong_name = getattr(exc_value, "name", None)
+            suggestion = _compute_suggestion_error(exc_value, exc_traceback, wrong_name)
+            if suggestion:
+                self._str += f". Did you mean: '{suggestion}'?"
+            if issubclass(exc_type, NameError):
+                wrong_name = getattr(exc_value, "name", None)
+                if wrong_name is not None and wrong_name in sys.stdlib_module_names:
+                    if suggestion:
+                        self._str += f" Or did you forget to import '{wrong_name}'?"
+                    else:
+                        self._str += f". Did you forget to import '{wrong_name}'?"
         if lookup_lines:
             self._load_lines()
         self.__suppress_context__ = \
@@ -528,7 +1116,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             queue = [(self, exc_value)]
             while queue:
                 te, e = queue.pop()
-                if (e and e.__cause__ is not None
+                if (e is not None and e.__cause__ is not None
                     and id(e.__cause__) not in _seen):
                     cause = TracebackException(
                         type(e.__cause__),
@@ -537,6 +1125,8 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                         limit=limit,
                         lookup_lines=lookup_lines,
                         capture_locals=capture_locals,
+                        max_group_width=max_group_width,
+                        max_group_depth=max_group_depth,
                         _seen=_seen)
                 else:
                     cause = None
@@ -547,7 +1137,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                                     not e.__suppress_context__)
                 else:
                     need_context = True
-                if (e and e.__context__ is not None
+                if (e is not None and e.__context__ is not None
                     and need_context and id(e.__context__) not in _seen):
                     context = TracebackException(
                         type(e.__context__),
@@ -556,21 +1146,62 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                         limit=limit,
                         lookup_lines=lookup_lines,
                         capture_locals=capture_locals,
+                        max_group_width=max_group_width,
+                        max_group_depth=max_group_depth,
                         _seen=_seen)
                 else:
                     context = None
+
+                if e is not None and isinstance(e, BaseExceptionGroup):
+                    exceptions = []
+                    for exc in e.exceptions:
+                        texc = TracebackException(
+                            type(exc),
+                            exc,
+                            exc.__traceback__,
+                            limit=limit,
+                            lookup_lines=lookup_lines,
+                            capture_locals=capture_locals,
+                            max_group_width=max_group_width,
+                            max_group_depth=max_group_depth,
+                            _seen=_seen)
+                        exceptions.append(texc)
+                else:
+                    exceptions = None
+
                 te.__cause__ = cause
                 te.__context__ = context
+                te.exceptions = exceptions
                 if cause:
                     queue.append((te.__cause__, e.__cause__))
                 if context:
                     queue.append((te.__context__, e.__context__))
+                if exceptions:
+                    queue.extend(zip(te.exceptions, e.exceptions))
 
     @classmethod
     def from_exception(cls, exc, *args, **kwargs):
         """Create a TracebackException from an exception."""
         return cls(type(exc), exc, exc.__traceback__, *args, **kwargs)
 
+    @property
+    def exc_type(self):
+        warnings.warn('Deprecated in 3.13. Use exc_type_str instead.',
+                      DeprecationWarning, stacklevel=2)
+        return self._exc_type
+
+    @property
+    def exc_type_str(self):
+        if not self._have_exc_type:
+            return None
+        stype = self.exc_type_qualname
+        smod = self.exc_type_module
+        if smod not in ("__main__", "builtins"):
+            if not isinstance(smod, str):
+                smod = "<unknown>"
+            stype = smod + '.' + stype
+        return stype
+
     def _load_lines(self):
         """Private API. force all lines in the stack to be loaded."""
         for frame in self.stack:
@@ -584,72 +1215,152 @@ def __eq__(self, other):
     def __str__(self):
         return self._str
 
-    def format_exception_only(self):
+    def format_exception_only(self, *, show_group=False, _depth=0, **kwargs):
         """Format the exception part of the traceback.
 
         The return value is a generator of strings, each ending in a newline.
 
-        Normally, the generator emits a single string; however, for
-        SyntaxError exceptions, it emits several lines that (when
-        printed) display detailed information about where the syntax
-        error occurred.
-
-        The message indicating which exception occurred is always the last
-        string in the output.
+        Generator yields the exception message.
+        For :exc:`SyntaxError` exceptions, it
+        also yields (before the exception message)
+        several lines that (when printed)
+        display detailed information about where the syntax error occurred.
+        Following the message, generator also yields
+        all the exception's ``__notes__``.
+
+        When *show_group* is ``True``, and the exception is an instance of
+        :exc:`BaseExceptionGroup`, the nested exceptions are included as
+        well, recursively, with indentation relative to their nesting depth.
         """
-        if self.exc_type is None:
-            yield _format_final_exc_line(None, self._str)
-            return
+        colorize = kwargs.get("colorize", False)
 
-        stype = self.exc_type.__qualname__
-        smod = self.exc_type.__module__
-        if smod not in ("__main__", "builtins"):
-            if not isinstance(smod, str):
-                smod = "<unknown>"
-            stype = smod + '.' + stype
+        indent = 3 * _depth * ' '
+        if not self._have_exc_type:
+            yield indent + _format_final_exc_line(None, self._str, colorize=colorize)
+            return
 
-        if not issubclass(self.exc_type, SyntaxError):
-            yield _format_final_exc_line(stype, self._str)
+        stype = self.exc_type_str
+        if not self._is_syntax_error:
+            if _depth > 0:
+                # Nested exceptions needs correct handling of multiline messages.
+                formatted = _format_final_exc_line(
+                    stype, self._str, insert_final_newline=False, colorize=colorize
+                ).split('\n')
+                yield from [
+                    indent + l + '\n'
+                    for l in formatted
+                ]
+            else:
+                yield _format_final_exc_line(stype, self._str, colorize=colorize)
         else:
-            yield from self._format_syntax_error(stype)
-
-    def _format_syntax_error(self, stype):
+            yield from [indent + l for l in self._format_syntax_error(stype, colorize=colorize)]
+
+        if (
+            isinstance(self.__notes__, collections.abc.Sequence)
+            and not isinstance(self.__notes__, (str, bytes))
+        ):
+            for note in self.__notes__:
+                note = _safe_string(note, 'note')
+                yield from [indent + l + '\n' for l in note.split('\n')]
+        elif self.__notes__ is not None:
+            yield indent + "{}\n".format(_safe_string(self.__notes__, '__notes__', func=repr))
+
+        if self.exceptions and show_group:
+            for ex in self.exceptions:
+                yield from ex.format_exception_only(show_group=show_group, _depth=_depth+1, colorize=colorize)
+
+    def _format_syntax_error(self, stype, **kwargs):
         """Format SyntaxError exceptions (internal helper)."""
         # Show exactly where the problem was found.
+        colorize = kwargs.get("colorize", False)
         filename_suffix = ''
         if self.lineno is not None:
-            yield '  File "{}", line {}\n'.format(
-                self.filename or "<string>", self.lineno)
+            if colorize:
+                yield '  File {}"{}"{}, line {}{}{}\n'.format(
+                    ANSIColors.MAGENTA,
+                    self.filename or "<string>",
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    self.lineno,
+                    ANSIColors.RESET,
+                    )
+            else:
+                yield '  File "{}", line {}\n'.format(
+                    self.filename or "<string>", self.lineno)
         elif self.filename is not None:
             filename_suffix = ' ({})'.format(self.filename)
 
         text = self.text
-        if text is not None:
+        if isinstance(text, str):
             # text  = "   foo\n"
             # rtext = "   foo"
             # ltext =    "foo"
             rtext = text.rstrip('\n')
             ltext = rtext.lstrip(' \n\f')
             spaces = len(rtext) - len(ltext)
-            yield '    {}\n'.format(ltext)
-
-            if self.offset is not None:
+            if self.offset is None:
+                yield '    {}\n'.format(ltext)
+            elif isinstance(self.offset, int):
                 offset = self.offset
-                end_offset = self.end_offset if self.end_offset not in {None, 0} else offset
-                if offset == end_offset or end_offset == -1:
+                if self.lineno == self.end_lineno:
+                    end_offset = (
+                        self.end_offset
+                        if (
+                            isinstance(self.end_offset, int)
+                            and self.end_offset != 0
+                        )
+                        else offset
+                    )
+                else:
+                    end_offset = len(rtext) + 1
+
+                if self.text and offset > len(self.text):
+                    offset = len(rtext) + 1
+                if self.text and end_offset > len(self.text):
+                    end_offset = len(rtext) + 1
+                if offset >= end_offset or end_offset < 0:
                     end_offset = offset + 1
 
                 # Convert 1-based column offset to 0-based index into stripped text
                 colno = offset - 1 - spaces
                 end_colno = end_offset - 1 - spaces
+                caretspace = ' '
                 if colno >= 0:
                     # non-space whitespace (likes tabs) must be kept for alignment
                     caretspace = ((c if c.isspace() else ' ') for c in ltext[:colno])
-                    yield '    {}{}'.format("".join(caretspace), ('^' * (end_colno - colno) + "\n"))
+                    start_color = end_color = ""
+                    if colorize:
+                        # colorize from colno to end_colno
+                        ltext = (
+                            ltext[:colno] +
+                            ANSIColors.BOLD_RED + ltext[colno:end_colno] + ANSIColors.RESET +
+                            ltext[end_colno:]
+                        )
+                        start_color = ANSIColors.BOLD_RED
+                        end_color = ANSIColors.RESET
+                    yield '    {}\n'.format(ltext)
+                    yield '    {}{}{}{}\n'.format(
+                        "".join(caretspace),
+                        start_color,
+                        ('^' * (end_colno - colno)),
+                        end_color,
+                    )
+                else:
+                    yield '    {}\n'.format(ltext)
         msg = self.msg or "<no detail available>"
-        yield "{}: {}{}\n".format(stype, msg, filename_suffix)
+        if colorize:
+            yield "{}{}{}: {}{}{}{}\n".format(
+                ANSIColors.BOLD_MAGENTA,
+                stype,
+                ANSIColors.RESET,
+                ANSIColors.MAGENTA,
+                msg,
+                ANSIColors.RESET,
+                filename_suffix)
+        else:
+            yield "{}: {}{}\n".format(stype, msg, filename_suffix)
 
-    def format(self, *, chain=True):
+    def format(self, *, chain=True, _ctx=None, **kwargs):
         """Format the exception.
 
         If chain is not *True*, *__cause__* and *__context__* will not be formatted.
@@ -661,11 +1372,14 @@ def format(self, *, chain=True):
         The message indicating which exception occurred is always the last
         string in the output.
         """
+        colorize = kwargs.get("colorize", False)
+        if _ctx is None:
+            _ctx = _ExceptionPrintContext()
 
         output = []
         exc = self
-        while exc:
-            if chain:
+        if chain:
+            while exc:
                 if exc.__cause__ is not None:
                     chained_msg = _cause_message
                     chained_exc = exc.__cause__
@@ -679,14 +1393,246 @@ def format(self, *, chain=True):
 
                 output.append((chained_msg, exc))
                 exc = chained_exc
-            else:
-                output.append((None, exc))
-                exc = None
+        else:
+            output.append((None, exc))
 
         for msg, exc in reversed(output):
             if msg is not None:
-                yield msg
-            if exc.stack:
-                yield 'Traceback (most recent call last):\n'
-                yield from exc.stack.format()
-            yield from exc.format_exception_only()
+                yield from _ctx.emit(msg)
+            if exc.exceptions is None:
+                if exc.stack:
+                    yield from _ctx.emit('Traceback (most recent call last):\n')
+                    yield from _ctx.emit(exc.stack.format(colorize=colorize))
+                yield from _ctx.emit(exc.format_exception_only(colorize=colorize))
+            elif _ctx.exception_group_depth > self.max_group_depth:
+                # exception group, but depth exceeds limit
+                yield from _ctx.emit(
+                    f"... (max_group_depth is {self.max_group_depth})\n")
+            else:
+                # format exception group
+                is_toplevel = (_ctx.exception_group_depth == 0)
+                if is_toplevel:
+                    _ctx.exception_group_depth += 1
+
+                if exc.stack:
+                    yield from _ctx.emit(
+                        'Exception Group Traceback (most recent call last):\n',
+                        margin_char = '+' if is_toplevel else None)
+                    yield from _ctx.emit(exc.stack.format(colorize=colorize))
+
+                yield from _ctx.emit(exc.format_exception_only(colorize=colorize))
+                num_excs = len(exc.exceptions)
+                if num_excs <= self.max_group_width:
+                    n = num_excs
+                else:
+                    n = self.max_group_width + 1
+                _ctx.need_close = False
+                for i in range(n):
+                    last_exc = (i == n-1)
+                    if last_exc:
+                        # The closing frame may be added by a recursive call
+                        _ctx.need_close = True
+
+                    if self.max_group_width is not None:
+                        truncated = (i >= self.max_group_width)
+                    else:
+                        truncated = False
+                    title = f'{i+1}' if not truncated else '...'
+                    yield (_ctx.indent() +
+                           ('+-' if i==0 else '  ') +
+                           f'+---------------- {title} ----------------\n')
+                    _ctx.exception_group_depth += 1
+                    if not truncated:
+                        yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx, colorize=colorize)
+                    else:
+                        remaining = num_excs - self.max_group_width
+                        plural = 's' if remaining > 1 else ''
+                        yield from _ctx.emit(
+                            f"and {remaining} more exception{plural}\n")
+
+                    if last_exc and _ctx.need_close:
+                        yield (_ctx.indent() +
+                               "+------------------------------------\n")
+                        _ctx.need_close = False
+                    _ctx.exception_group_depth -= 1
+
+                if is_toplevel:
+                    assert _ctx.exception_group_depth == 1
+                    _ctx.exception_group_depth = 0
+
+
+    def print(self, *, file=None, chain=True, **kwargs):
+        """Print the result of self.format(chain=chain) to 'file'."""
+        colorize = kwargs.get("colorize", False)
+        if file is None:
+            file = sys.stderr
+        for line in self.format(chain=chain, colorize=colorize):
+            print(line, file=file, end="")
+
+
+_MAX_CANDIDATE_ITEMS = 750
+_MAX_STRING_SIZE = 40
+_MOVE_COST = 2
+_CASE_COST = 1
+
+
+def _substitution_cost(ch_a, ch_b):
+    if ch_a == ch_b:
+        return 0
+    if ch_a.lower() == ch_b.lower():
+        return _CASE_COST
+    return _MOVE_COST
+
+
+def _compute_suggestion_error(exc_value, tb, wrong_name):
+    if wrong_name is None or not isinstance(wrong_name, str):
+        return None
+    if isinstance(exc_value, AttributeError):
+        obj = exc_value.obj
+        try:
+            try:
+                d = dir(obj)
+            except TypeError:  # Attributes are unsortable, e.g. int and str
+                d = list(obj.__class__.__dict__.keys()) + list(obj.__dict__.keys())
+            d = sorted([x for x in d if isinstance(x, str)])
+            hide_underscored = (wrong_name[:1] != '_')
+            if hide_underscored and tb is not None:
+                while tb.tb_next is not None:
+                    tb = tb.tb_next
+                frame = tb.tb_frame
+                if 'self' in frame.f_locals and frame.f_locals['self'] is obj:
+                    hide_underscored = False
+            if hide_underscored:
+                d = [x for x in d if x[:1] != '_']
+        except Exception:
+            return None
+    elif isinstance(exc_value, ImportError):
+        try:
+            mod = __import__(exc_value.name)
+            try:
+                d = dir(mod)
+            except TypeError:  # Attributes are unsortable, e.g. int and str
+                d = list(mod.__dict__.keys())
+            d = sorted([x for x in d if isinstance(x, str)])
+            if wrong_name[:1] != '_':
+                d = [x for x in d if x[:1] != '_']
+        except Exception:
+            return None
+    else:
+        assert isinstance(exc_value, NameError)
+        # find most recent frame
+        if tb is None:
+            return None
+        while tb.tb_next is not None:
+            tb = tb.tb_next
+        frame = tb.tb_frame
+        d = (
+            list(frame.f_locals)
+            + list(frame.f_globals)
+            + list(frame.f_builtins)
+        )
+        d = [x for x in d if isinstance(x, str)]
+
+        # Check first if we are in a method and the instance
+        # has the wrong name as attribute
+        if 'self' in frame.f_locals:
+            self = frame.f_locals['self']
+            try:
+                has_wrong_name = hasattr(self, wrong_name)
+            except Exception:
+                has_wrong_name = False
+            if has_wrong_name:
+                return f"self.{wrong_name}"
+
+    try:
+        import _suggestions
+    except ImportError:
+        pass
+    else:
+        return _suggestions._generate_suggestions(d, wrong_name)
+
+    # Compute closest match
+
+    if len(d) > _MAX_CANDIDATE_ITEMS:
+        return None
+    wrong_name_len = len(wrong_name)
+    if wrong_name_len > _MAX_STRING_SIZE:
+        return None
+    best_distance = wrong_name_len
+    suggestion = None
+    for possible_name in d:
+        if possible_name == wrong_name:
+            # A missing attribute is "found". Don't suggest it (see GH-88821).
+            continue
+        # No more than 1/3 of the involved characters should need changed.
+        max_distance = (len(possible_name) + wrong_name_len + 3) * _MOVE_COST // 6
+        # Don't take matches we've already beaten.
+        max_distance = min(max_distance, best_distance - 1)
+        current_distance = _levenshtein_distance(wrong_name, possible_name, max_distance)
+        if current_distance > max_distance:
+            continue
+        if not suggestion or current_distance < best_distance:
+            suggestion = possible_name
+            best_distance = current_distance
+    return suggestion
+
+
+def _levenshtein_distance(a, b, max_cost):
+    # A Python implementation of Python/suggestions.c:levenshtein_distance.
+
+    # Both strings are the same
+    if a == b:
+        return 0
+
+    # Trim away common affixes
+    pre = 0
+    while a[pre:] and b[pre:] and a[pre] == b[pre]:
+        pre += 1
+    a = a[pre:]
+    b = b[pre:]
+    post = 0
+    while a[:post or None] and b[:post or None] and a[post-1] == b[post-1]:
+        post -= 1
+    a = a[:post or None]
+    b = b[:post or None]
+    if not a or not b:
+        return _MOVE_COST * (len(a) + len(b))
+    if len(a) > _MAX_STRING_SIZE or len(b) > _MAX_STRING_SIZE:
+        return max_cost + 1
+
+    # Prefer shorter buffer
+    if len(b) < len(a):
+        a, b = b, a
+
+    # Quick fail when a match is impossible
+    if (len(b) - len(a)) * _MOVE_COST > max_cost:
+        return max_cost + 1
+
+    # Instead of producing the whole traditional len(a)-by-len(b)
+    # matrix, we can update just one row in place.
+    # Initialize the buffer row
+    row = list(range(_MOVE_COST, _MOVE_COST * (len(a) + 1), _MOVE_COST))
+
+    result = 0
+    for bindex in range(len(b)):
+        bchar = b[bindex]
+        distance = result = bindex * _MOVE_COST
+        minimum = sys.maxsize
+        for index in range(len(a)):
+            # 1) Previous distance in this row is cost(b[:b_index], a[:index])
+            substitute = distance + _substitution_cost(bchar, a[index])
+            # 2) cost(b[:b_index], a[:index+1]) from previous row
+            distance = row[index]
+            # 3) existing result is cost(b[:b_index+1], a[index])
+
+            insert_delete = min(result, distance) + _MOVE_COST
+            result = min(insert_delete, substitute)
+
+            # cost(b[:b_index+1], a[:index+1])
+            row[index] = result
+            if result < minimum:
+                minimum = result
+        if minimum > max_cost:
+            # Everything in this row is too big, so bail early.
+            return max_cost + 1
+    return result
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index c44b2b00684..5cc7d0d2212 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -115,11 +115,22 @@ enum DoneWithFuture {
     Yes,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct CompileOpts {
     /// How optimized the bytecode output should be; any optimize > 0 does
     /// not emit assert statements
     pub optimize: u8,
+    /// Include column info in bytecode (-X no_debug_ranges disables)
+    pub debug_ranges: bool,
+}
+
+impl Default for CompileOpts {
+    fn default() -> Self {
+        Self {
+            optimize: 0,
+            debug_ranges: true,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -859,7 +870,7 @@ impl Compiler {
         let pop = self.code_stack.pop();
         let stack_top = compiler_unwrap_option(self, pop);
         // No parent scope stack to maintain
-        unwrap_internal(self, stack_top.finalize_code(self.opts.optimize))
+        unwrap_internal(self, stack_top.finalize_code(&self.opts))
     }
 
     /// Push a new fblock
@@ -1486,7 +1497,9 @@ impl Compiler {
                 ..
             }) => self.compile_for(target, iter, body, orelse, *is_async)?,
             Stmt::Match(StmtMatch { subject, cases, .. }) => self.compile_match(subject, cases)?,
-            Stmt::Raise(StmtRaise { exc, cause, .. }) => {
+            Stmt::Raise(StmtRaise {
+                exc, cause, range, ..
+            }) => {
                 let kind = match exc {
                     Some(value) => {
                         self.compile_expression(value)?;
@@ -1500,6 +1513,7 @@ impl Compiler {
                     }
                     None => bytecode::RaiseKind::Reraise,
                 };
+                self.set_source_range(*range);
                 emit!(self, Instruction::Raise { kind });
             }
             Stmt::Try(StmtTry {
@@ -5639,17 +5653,15 @@ impl Compiler {
     // Low level helper functions:
     fn _emit(&mut self, instr: Instruction, arg: OpArg, target: BlockIdx) {
         let range = self.current_source_range;
-        let location = self
-            .source_file
-            .to_source_code()
-            .source_location(range.start(), PositionEncoding::Utf8);
-        // TODO: insert source filename
+        let source = self.source_file.to_source_code();
+        let location = source.source_location(range.start(), PositionEncoding::Utf8);
+        let end_location = source.source_location(range.end(), PositionEncoding::Utf8);
         self.current_block().instructions.push(ir::InstructionInfo {
             instr,
             arg,
             target,
             location,
-            // range,
+            end_location,
         });
     }
 
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 670635fbd37..31ee8d8b230 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -86,9 +86,8 @@ pub struct InstructionInfo {
     pub instr: Instruction,
     pub arg: OpArg,
     pub target: BlockIdx,
-    // pub range: TextRange,
     pub location: SourceLocation,
-    // TODO: end_location for debug ranges
+    pub end_location: SourceLocation,
 }
 
 // spell-checker:ignore petgraph
@@ -133,8 +132,11 @@ pub struct CodeInfo {
 }
 
 impl CodeInfo {
-    pub fn finalize_code(mut self, optimize: u8) -> crate::InternalResult<CodeObject> {
-        if optimize > 0 {
+    pub fn finalize_code(
+        mut self,
+        opts: &crate::compile::CompileOpts,
+    ) -> crate::InternalResult<CodeObject> {
+        if opts.optimize > 0 {
             self.dce();
         }
 
@@ -198,7 +200,10 @@ impl CodeInfo {
                         *arg = new_arg;
                     }
                     let (extras, lo_arg) = arg.split();
-                    locations.extend(core::iter::repeat_n(info.location, arg.instr_size()));
+                    locations.extend(core::iter::repeat_n(
+                        (info.location, info.end_location),
+                        arg.instr_size(),
+                    ));
                     instructions.extend(
                         extras
                             .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
@@ -217,7 +222,11 @@ impl CodeInfo {
         }
 
         // Generate linetable from locations
-        let linetable = generate_linetable(&locations, first_line_number.get() as i32);
+        let linetable = generate_linetable(
+            &locations,
+            first_line_number.get() as i32,
+            opts.debug_ranges,
+        );
 
         Ok(CodeObject {
             flags,
@@ -412,7 +421,11 @@ fn iter_blocks(blocks: &[Block]) -> impl Iterator<Item = (BlockIdx, &Block)> + '
 }
 
 /// Generate CPython 3.11+ format linetable from source locations
-fn generate_linetable(locations: &[SourceLocation], first_line: i32) -> Box<[u8]> {
+fn generate_linetable(
+    locations: &[(SourceLocation, SourceLocation)],
+    first_line: i32,
+    debug_ranges: bool,
+) -> Box<[u8]> {
     if locations.is_empty() {
         return Box::new([]);
     }
@@ -424,7 +437,7 @@ fn generate_linetable(locations: &[SourceLocation], first_line: i32) -> Box<[u8]
     let mut i = 0;
 
     while i < locations.len() {
-        let loc = &locations[i];
+        let (loc, end_loc) = &locations[i];
 
         // Count consecutive instructions with the same location
         let mut length = 1;
@@ -436,18 +449,33 @@ fn generate_linetable(locations: &[SourceLocation], first_line: i32) -> Box<[u8]
         while length > 0 {
             let entry_length = length.min(8);
 
-            // Get line and column information
-            // SourceLocation always has row and column (both are OneIndexed)
+            // Get line information
             let line = loc.line.get() as i32;
-            let col = loc.character_offset.to_zero_indexed() as i32;
-
+            let end_line = end_loc.line.get() as i32;
             let line_delta = line - prev_line;
+            let end_line_delta = end_line - line;
 
-            // Choose the appropriate encoding based on line delta and column info
-            // Note: SourceLocation always has valid column, so we never get NO_COLUMNS case
-            if line_delta == 0 {
-                let end_col = col; // Use same column for end (no range info available)
+            // When debug_ranges is disabled, only emit line info (NoColumns format)
+            if !debug_ranges {
+                // NoColumns format (code 13): line info only, no column data
+                linetable.push(
+                    0x80 | ((PyCodeLocationInfoKind::NoColumns as u8) << 3)
+                        | ((entry_length - 1) as u8),
+                );
+                write_signed_varint(&mut linetable, line_delta);
 
+                prev_line = line;
+                length -= entry_length;
+                i += entry_length;
+                continue;
+            }
+
+            // Get column information (only when debug_ranges is enabled)
+            let col = loc.character_offset.to_zero_indexed() as i32;
+            let end_col = end_loc.character_offset.to_zero_indexed() as i32;
+
+            // Choose the appropriate encoding based on line delta and column info
+            if line_delta == 0 && end_line_delta == 0 {
                 if col < 80 && end_col - col < 16 && end_col >= col {
                     // Short form (codes 0-9) for common cases
                     let code = (col / 8).min(9) as u8; // Short0 to Short9
@@ -470,42 +498,37 @@ fn generate_linetable(locations: &[SourceLocation], first_line: i32) -> Box<[u8]
                     );
                     write_signed_varint(&mut linetable, 0); // line_delta = 0
                     write_varint(&mut linetable, 0); // end_line delta = 0
-                    write_varint(&mut linetable, (col as u32) + 1); // column + 1 for encoding
-                    write_varint(&mut linetable, (end_col as u32) + 1); // end_col + 1
+                    write_varint(&mut linetable, (col as u32) + 1);
+                    write_varint(&mut linetable, (end_col as u32) + 1);
                 }
-            } else if line_delta > 0 && line_delta < 3
-            /* && column.is_some() */
-            {
+            } else if line_delta > 0 && line_delta < 3 && end_line_delta == 0 {
                 // One-line form (codes 11-12) for line deltas 1-2
-                let end_col = col; // Use same column for end
-
                 if col < 128 && end_col < 128 {
-                    let code = (PyCodeLocationInfoKind::OneLine0 as u8) + (line_delta as u8); // 11 for delta=1, 12 for delta=2
+                    let code = (PyCodeLocationInfoKind::OneLine0 as u8) + (line_delta as u8);
                     linetable.push(0x80 | (code << 3) | ((entry_length - 1) as u8));
                     linetable.push(col as u8);
                     linetable.push(end_col as u8);
                 } else {
-                    // Long form for columns >= 128 or negative line delta
+                    // Long form for columns >= 128
                     linetable.push(
                         0x80 | ((PyCodeLocationInfoKind::Long as u8) << 3)
                             | ((entry_length - 1) as u8),
                     );
                     write_signed_varint(&mut linetable, line_delta);
                     write_varint(&mut linetable, 0); // end_line delta = 0
-                    write_varint(&mut linetable, (col as u32) + 1); // column + 1 for encoding
-                    write_varint(&mut linetable, (end_col as u32) + 1); // end_col + 1
+                    write_varint(&mut linetable, (col as u32) + 1);
+                    write_varint(&mut linetable, (end_col as u32) + 1);
                 }
             } else {
                 // Long form (code 14) for all other cases
-                // This handles: line_delta < 0, line_delta >= 3, or columns >= 128
-                let end_col = col; // Use same column for end
+                // Handles: line_delta < 0, line_delta >= 3, multi-line spans, or columns >= 128
                 linetable.push(
                     0x80 | ((PyCodeLocationInfoKind::Long as u8) << 3) | ((entry_length - 1) as u8),
                 );
                 write_signed_varint(&mut linetable, line_delta);
-                write_varint(&mut linetable, 0); // end_line delta = 0
-                write_varint(&mut linetable, (col as u32) + 1); // column + 1 for encoding
-                write_varint(&mut linetable, (end_col as u32) + 1); // end_col + 1
+                write_varint(&mut linetable, end_line_delta as u32);
+                write_varint(&mut linetable, (col as u32) + 1);
+                write_varint(&mut linetable, (end_col as u32) + 1);
             }
 
             prev_line = line;
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 5569fa2012b..7675ef34863 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -258,7 +258,7 @@ impl ConstantBag for BasicBag {
 #[derive(Clone)]
 pub struct CodeObject<C: Constant = ConstantData> {
     pub instructions: CodeUnits,
-    pub locations: Box<[SourceLocation]>,
+    pub locations: Box<[(SourceLocation, SourceLocation)]>,
     pub flags: CodeFlags,
     /// Number of positional-only arguments
     pub posonlyarg_count: u32,
@@ -1483,14 +1483,14 @@ impl<C: Constant> CodeObject<C> {
         level: usize,
     ) -> fmt::Result {
         let label_targets = self.label_targets();
-        let line_digits = (3).max(self.locations.last().unwrap().line.digits().get());
+        let line_digits = (3).max(self.locations.last().unwrap().0.line.digits().get());
         let offset_digits = (4).max(1 + self.instructions.len().ilog10() as usize);
         let mut last_line = OneIndexed::MAX;
         let mut arg_state = OpArgState::default();
         for (offset, &instruction) in self.instructions.iter().enumerate() {
             let (instruction, arg) = arg_state.get(instruction);
             // optional line number
-            let line = self.locations[offset].line;
+            let line = self.locations[offset].0.line;
             if line != last_line {
                 if last_line != OneIndexed::MAX {
                     writeln!(f)?;
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
index b30894ea065..5b528fe7e50 100644
--- a/crates/compiler-core/src/marshal.rs
+++ b/crates/compiler-core/src/marshal.rs
@@ -190,12 +190,17 @@ pub fn deserialize_code<R: Read, Bag: ConstantBag>(
     let len = rdr.read_u32()?;
     let locations = (0..len)
         .map(|_| {
-            Ok(SourceLocation {
+            let start = SourceLocation {
                 line: OneIndexed::new(rdr.read_u32()? as _).ok_or(MarshalError::InvalidLocation)?,
                 character_offset: OneIndexed::from_zero_indexed(rdr.read_u32()? as _),
-            })
+            };
+            let end = SourceLocation {
+                line: OneIndexed::new(rdr.read_u32()? as _).ok_or(MarshalError::InvalidLocation)?,
+                character_offset: OneIndexed::from_zero_indexed(rdr.read_u32()? as _),
+            };
+            Ok((start, end))
         })
-        .collect::<Result<Box<[SourceLocation]>>>()?;
+        .collect::<Result<Box<[(SourceLocation, SourceLocation)]>>>()?;
 
     let flags = CodeFlags::from_bits_truncate(rdr.read_u16()?);
 
@@ -648,9 +653,11 @@ pub fn serialize_code<W: Write, C: Constant>(buf: &mut W, code: &CodeObject<C>)
     buf.write_slice(instructions_bytes);
 
     write_len(buf, code.locations.len());
-    for loc in &*code.locations {
-        buf.write_u32(loc.line.get() as _);
-        buf.write_u32(loc.character_offset.to_zero_indexed() as _);
+    for (start, end) in &*code.locations {
+        buf.write_u32(start.line.get() as _);
+        buf.write_u32(start.character_offset.to_zero_indexed() as _);
+        buf.write_u32(end.line.get() as _);
+        buf.write_u32(end.character_offset.to_zero_indexed() as _);
     }
 
     buf.write_u16(code.flags.bits());
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index b897ef9d311..32e53a5d376 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -467,20 +467,22 @@ impl Constructor for PyCode {
             .collect::<Vec<_>>()
             .into_boxed_slice();
 
-        // Create locations
+        // Create locations (start and end pairs)
         let row = if args.firstlineno > 0 {
             OneIndexed::new(args.firstlineno as usize).unwrap_or(OneIndexed::MIN)
         } else {
             OneIndexed::MIN
         };
-        let locations: Box<[rustpython_compiler_core::SourceLocation]> = vec![
-                rustpython_compiler_core::SourceLocation {
-                    line: row,
-                    character_offset: OneIndexed::from_zero_indexed(0),
-                };
-                instructions.len()
-            ]
-        .into_boxed_slice();
+        let loc = rustpython_compiler_core::SourceLocation {
+            line: row,
+            character_offset: OneIndexed::from_zero_indexed(0),
+        };
+        let locations: Box<
+            [(
+                rustpython_compiler_core::SourceLocation,
+                rustpython_compiler_core::SourceLocation,
+            )],
+        > = vec![(loc, loc); instructions.len()].into_boxed_slice();
 
         // Build the CodeObject
         let code = CodeObject {
@@ -809,7 +811,6 @@ impl PyCode {
                         Some(line + end_line_delta)
                     };
 
-                    // Convert Option to PyObject (None or int)
                     let line_obj = final_line.to_pyobject(vm);
                     let end_line_obj = final_endline.to_pyobject(vm);
                     let column_obj = column.to_pyobject(vm);
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 3712b04e875..28c4e751476 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -58,12 +58,19 @@ impl Frame {
 
     #[pygetset]
     fn f_lasti(&self) -> u32 {
-        self.lasti()
+        // Return byte offset (each instruction is 2 bytes) for compatibility
+        self.lasti() * 2
     }
 
     #[pygetset]
     pub fn f_lineno(&self) -> usize {
-        self.current_location().line.get()
+        // If lasti is 0, execution hasn't started yet - use first line number
+        // Similar to PyCode_Addr2Line which returns co_firstlineno for addr_q < 0
+        if self.lasti() == 0 {
+            self.code.first_line_number.map(|n| n.get()).unwrap_or(1)
+        } else {
+            self.current_location().line.get()
+        }
     }
 
     #[pygetset]
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 6acf0e84795..6500f578dca 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -172,7 +172,7 @@ impl Frame {
     }
 
     pub fn current_location(&self) -> SourceLocation {
-        self.code.locations[self.lasti() as usize - 1]
+        self.code.locations[self.lasti() as usize - 1].0
     }
 
     pub fn lasti(&self) -> u32 {
@@ -385,12 +385,12 @@ impl ExecutingFrame<'_> {
                         // 2. Add new entry with current execution position (filename, lineno, code_object) to traceback.
                         // 3. Unwind block stack till appropriate handler is found.
 
-                        let loc = frame.code.locations[idx];
+                        let (loc, _end_loc) = frame.code.locations[idx];
                         let next = exception.__traceback__();
                         let new_traceback = PyTraceback::new(
                             next,
                             frame.object.to_owned(),
-                            frame.lasti(),
+                            frame.lasti() * 2,
                             loc.line,
                         );
                         vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.line);
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 7c527b3e0da..ddbf7660f7d 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -508,6 +508,7 @@ impl VirtualMachine {
     pub fn compile_opts(&self) -> crate::compiler::CompileOpts {
         crate::compiler::CompileOpts {
             optimize: self.state.config.settings.optimize,
+            debug_ranges: self.state.config.settings.code_debug_ranges,
         }
     }
 
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index 53e2cef1160..8a307d1852b 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -57,7 +57,8 @@ pub struct Settings {
     // int tracemalloc;
     // int perf_profiling;
     // int import_time;
-    // int code_debug_ranges;
+    /// -X no_debug_ranges: disable column info in bytecode
+    pub code_debug_ranges: bool,
     // int show_ref_count;
     // int dump_refs;
     // wchar_t *dump_refs_file;
@@ -192,6 +193,7 @@ impl Default for Settings {
             argv: vec![],
             hash_seed: None,
             faulthandler: false,
+            code_debug_ranges: true,
             buffered_stdio: true,
             check_hash_pycs_mode: CheckHashPycsMode::Default,
             allow_external_library: cfg!(feature = "importlib"),
diff --git a/examples/dis.rs b/examples/dis.rs
index 942643cd54b..1ca350603f9 100644
--- a/examples/dis.rs
+++ b/examples/dis.rs
@@ -53,7 +53,10 @@ fn main() -> Result<(), lexopt::Error> {
         return Err("expected at least one argument".into());
     }
 
-    let opts = compiler::CompileOpts { optimize };
+    let opts = compiler::CompileOpts {
+        optimize,
+        debug_ranges: true,
+    };
 
     for script in &scripts {
         if script.exists() && script.is_file() {
diff --git a/src/settings.rs b/src/settings.rs
index a63f1a07ccc..54e66086932 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -270,6 +270,7 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
             "faulthandler" => settings.faulthandler = true,
             "warn_default_encoding" => settings.warn_default_encoding = true,
             "no_sig_int" => settings.install_signal_handlers = false,
+            "no_debug_ranges" => settings.code_debug_ranges = false,
             "int_max_str_digits" => {
                 settings.int_max_str_digits = match value.unwrap().parse() {
                     Ok(digits) if digits == 0 || digits >= 640 => digits,
@@ -293,6 +294,9 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
     settings.warn_default_encoding =
         settings.warn_default_encoding || env_bool("PYTHONWARNDEFAULTENCODING");
     settings.faulthandler = settings.faulthandler || env_bool("PYTHONFAULTHANDLER");
+    if env_bool("PYTHONNODEBUGRANGES") {
+        settings.code_debug_ranges = false;
+    }
 
     if settings.dev_mode {
         settings.warnoptions.push("default".to_owned());

From 7b9f0d9657e86db7627c76e2414c105588838671 Mon Sep 17 00:00:00 2001
From: Ashwin Naren <arihant2math@gmail.com>
Date: Tue, 30 Dec 2025 00:07:03 -0800
Subject: [PATCH 123/418] More tkinter (#5784)

* fix build

* fix usage of Tcl_GetVar2Ex

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* no panic on mainloop

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* add static var

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* fix getvar

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* add globalgetvar support

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* formatting

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>

* address review

* fix build

* Auto-format: cargo fmt --all

---------

Signed-off-by: Ashwin Naren <arihant2math@gmail.com>
Co-authored-by: Jeong YunWon <jeong@youknowone.org>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yaml    |   8 ++
 crates/stdlib/Cargo.toml     |   3 +-
 crates/stdlib/src/tkinter.rs | 144 ++++++++++++++++++++++++++---------
 3 files changed, 118 insertions(+), 37 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index dc5ce974e38..a873aa2d29d 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -157,6 +157,14 @@ jobs:
           cargo build --no-default-features --features ssl-openssl
         if: runner.os == 'Linux'
 
+      # - name: Install tk-dev for tkinter build
+      #   run: sudo apt-get update && sudo apt-get install -y tk-dev
+      #   if: runner.os == 'Linux'
+
+      # - name: Test tkinter build
+      #   run: cargo build --features tkinter
+      #   if: runner.os == 'Linux'
+
       - name: Test example projects
         run:
           cargo run --manifest-path example_projects/barebone/Cargo.toml
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index 4885319ea17..e943470a3af 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -21,7 +21,7 @@ ssl-rustls = ["ssl", "rustls", "rustls-native-certs", "rustls-pemfile", "rustls-
 ssl-rustls-fips = ["ssl-rustls", "aws-lc-rs/fips"]
 ssl-openssl = ["ssl", "openssl", "openssl-sys", "foreign-types-shared", "openssl-probe"]
 ssl-vendor = ["ssl-openssl", "openssl/vendored"]
-tkinter = ["dep:tk-sys", "dep:tcl-sys"]
+tkinter = ["dep:tk-sys", "dep:tcl-sys", "dep:widestring"]
 
 [dependencies]
 # rustpython crates
@@ -90,6 +90,7 @@ bzip2 = "0.6"
 # tkinter
 tk-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
 tcl-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
+widestring = { workspace = true, optional = true }
 chrono.workspace = true
 
 # uuid
diff --git a/crates/stdlib/src/tkinter.rs b/crates/stdlib/src/tkinter.rs
index 49dcdc5f84f..6b7c4387d6c 100644
--- a/crates/stdlib/src/tkinter.rs
+++ b/crates/stdlib/src/tkinter.rs
@@ -4,8 +4,9 @@ pub(crate) use self::_tkinter::make_module;
 
 #[pymodule]
 mod _tkinter {
+    use rustpython_vm::convert::IntoPyException;
     use rustpython_vm::types::Constructor;
-    use rustpython_vm::{PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+    use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 
     use rustpython_vm::builtins::{PyInt, PyStr, PyType};
     use std::{ffi, ptr};
@@ -72,6 +73,7 @@ mod _tkinter {
     impl TclObject {}
 
     static QUIT_MAIN_LOOP: AtomicBool = AtomicBool::new(false);
+    static ERROR_IN_CMD: AtomicBool = AtomicBool::new(false);
 
     #[pyattr]
     #[pyclass(name = "tkapp")]
@@ -125,7 +127,7 @@ mod _tkinter {
         interactive: i32,
         #[pyarg(any)]
         wantobjects: i32,
-        #[pyarg(any, default = "true")]
+        #[pyarg(any, default = true)]
         want_tk: bool,
         #[pyarg(any)]
         sync: i32,
@@ -136,11 +138,7 @@ mod _tkinter {
     impl Constructor for TkApp {
         type Args = TkAppConstructorArgs;
 
-        fn py_new(
-            _zelf: PyRef<PyType>,
-            args: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyObjectRef> {
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             create(args, vm)
         }
     }
@@ -168,10 +166,18 @@ mod _tkinter {
         )))
     }
 
+    #[derive(Debug, FromArgs)]
+    struct TkAppGetVarArgs {
+        #[pyarg(any)]
+        name: PyObjectRef,
+        #[pyarg(any, default)]
+        name2: Option<String>,
+    }
+
     // TODO: DISALLOW_INSTANTIATION
     #[pyclass(with(Constructor))]
     impl TkApp {
-        fn from_bool(&self, obj: *mut tk_sys::Tcl_Obj) -> bool {
+        fn tcl_obj_to_bool(&self, obj: *mut tk_sys::Tcl_Obj) -> bool {
             let mut res = -1;
             unsafe {
                 if tk_sys::Tcl_GetBooleanFromObj(self.interpreter, obj, &mut res)
@@ -184,16 +190,16 @@ mod _tkinter {
             res != 0
         }
 
-        fn from_object(
+        fn tcl_obj_to_pyobject(
             &self,
             obj: *mut tk_sys::Tcl_Obj,
             vm: &VirtualMachine,
         ) -> PyResult<PyObjectRef> {
             let type_ptr = unsafe { (*obj).typePtr };
-            if type_ptr == ptr::null() {
+            if type_ptr.is_null() {
                 return self.unicode_from_object(obj, vm);
             } else if type_ptr == self.old_boolean_type || type_ptr == self.boolean_type {
-                return Ok(vm.ctx.new_bool(self.from_bool(obj)).into());
+                return Ok(vm.ctx.new_bool(self.tcl_obj_to_bool(obj)).into());
             } else if type_ptr == self.string_type
                 || type_ptr == self.utf32_string_type
                 || type_ptr == self.pixel_type
@@ -202,7 +208,7 @@ mod _tkinter {
             }
             // TODO: handle other types
 
-            return Ok(TclObject { value: obj }.into_pyobject(vm));
+            Ok(TclObject { value: obj }.into_pyobject(vm))
         }
 
         fn unicode_from_string(
@@ -226,8 +232,8 @@ mod _tkinter {
             vm: &VirtualMachine,
         ) -> PyResult<PyObjectRef> {
             let type_ptr = unsafe { (*obj).typePtr };
-            if type_ptr != ptr::null()
-                && self.interpreter != ptr::null_mut()
+            if !type_ptr.is_null()
+                && !self.interpreter.is_null()
                 && (type_ptr == self.string_type || type_ptr == self.utf32_string_type)
             {
                 let len = ptr::null_mut();
@@ -247,30 +253,75 @@ mod _tkinter {
             Self::unicode_from_string(s, len as _, vm)
         }
 
-        #[pymethod]
-        fn getvar(&self, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        fn var_invoke(&self) {
+            if self.threaded && self.thread_id != Some(unsafe { tk_sys::Tcl_GetCurrentThread() }) {
+                // TODO: do stuff
+            }
+        }
+
+        fn inner_getvar(
+            &self,
+            args: TkAppGetVarArgs,
+            flags: u32,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let TkAppGetVarArgs { name, name2 } = args;
             // TODO: technically not thread safe
-            let name = varname_converter(arg, vm)?;
+            let name = varname_converter(name, vm)?;
 
+            let name = ffi::CString::new(name).map_err(|e| e.into_pyexception(vm))?;
+            let name2 =
+                ffi::CString::new(name2.unwrap_or_default()).map_err(|e| e.into_pyexception(vm))?;
+            let name2_ptr = if name2.is_empty() {
+                ptr::null()
+            } else {
+                name2.as_ptr()
+            };
             let res = unsafe {
                 tk_sys::Tcl_GetVar2Ex(
                     self.interpreter,
-                    ptr::null(),
                     name.as_ptr() as _,
-                    tk_sys::TCL_LEAVE_ERR_MSG as _,
+                    name2_ptr as _,
+                    flags as _,
                 )
             };
-            if res == ptr::null_mut() {
-                todo!();
+            if res.is_null() {
+                // TODO: Should be tk error
+                unsafe {
+                    let err_obj = tk_sys::Tcl_GetObjResult(self.interpreter);
+                    let err_str_obj = tk_sys::Tcl_GetString(err_obj);
+                    let err_cstr = ffi::CStr::from_ptr(err_str_obj as _);
+                    return Err(vm.new_type_error(format!("{err_cstr:?}")));
+                }
             }
             let res = if self.want_objects {
-                self.from_object(res, vm)
+                self.tcl_obj_to_pyobject(res, vm)
             } else {
                 self.unicode_from_object(res, vm)
             }?;
             Ok(res)
         }
 
+        #[pymethod]
+        fn getvar(&self, args: TkAppGetVarArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            self.var_invoke();
+            self.inner_getvar(args, tk_sys::TCL_LEAVE_ERR_MSG, vm)
+        }
+
+        #[pymethod]
+        fn globalgetvar(
+            &self,
+            args: TkAppGetVarArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            self.var_invoke();
+            self.inner_getvar(
+                args,
+                tk_sys::TCL_LEAVE_ERR_MSG | tk_sys::TCL_GLOBAL_ONLY,
+                vm,
+            )
+        }
+
         #[pymethod]
         fn getint(&self, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
             if let Some(int) = arg.downcast_ref::<PyInt>() {
@@ -289,7 +340,21 @@ mod _tkinter {
         #[pymethod]
         fn mainloop(&self, threshold: Option<i32>) -> PyResult<()> {
             let threshold = threshold.unwrap_or(0);
-            todo!();
+            // self.dispatching = true;
+            QUIT_MAIN_LOOP.store(false, Ordering::Relaxed);
+            while unsafe { tk_sys::Tk_GetNumMainWindows() } > threshold
+                && !QUIT_MAIN_LOOP.load(Ordering::Relaxed)
+                && !ERROR_IN_CMD.load(Ordering::Relaxed)
+            {
+                if self.threaded {
+                    unsafe { tk_sys::Tcl_DoOneEvent(0 as _) };
+                } else {
+                    unsafe { tk_sys::Tcl_DoOneEvent(tk_sys::TCL_DONT_WAIT as _) };
+                    // TODO: sleep for the proper time
+                    std::thread::sleep(std::time::Duration::from_millis(1));
+                }
+            }
+            Ok(())
         }
 
         #[pymethod]
@@ -299,13 +364,15 @@ mod _tkinter {
     }
 
     #[pyfunction]
-    fn create(args: TkAppConstructorArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    fn create(args: TkAppConstructorArgs, vm: &VirtualMachine) -> PyResult<TkApp> {
         unsafe {
             let interp = tk_sys::Tcl_CreateInterp();
             let want_objects = args.wantobjects != 0;
-            let threaded = {
+            let threaded = !{
                 let part1 = String::from("tcl_platform");
                 let part2 = String::from("threaded");
+                let part1 = ffi::CString::new(part1).map_err(|e| e.into_pyexception(vm))?;
+                let part2 = ffi::CString::new(part2).map_err(|e| e.into_pyexception(vm))?;
                 let part1_ptr = part1.as_ptr();
                 let part2_ptr = part2.as_ptr();
                 tk_sys::Tcl_GetVar2Ex(
@@ -314,7 +381,8 @@ mod _tkinter {
                     part2_ptr as _,
                     tk_sys::TCL_GLOBAL_ONLY as ffi::c_int,
                 )
-            } != ptr::null_mut();
+            }
+            .is_null();
             let thread_id = tk_sys::Tcl_GetCurrentThread();
             let dispatching = false;
             let trace = None;
@@ -339,8 +407,8 @@ mod _tkinter {
             let double_type = tk_sys::Tcl_GetObjType(double_str.as_ptr() as _);
             let int_str = String::from("int");
             let int_type = tk_sys::Tcl_GetObjType(int_str.as_ptr() as _);
-            let int_type = if int_type == ptr::null() {
-                let mut value = *tk_sys::Tcl_NewIntObj(0);
+            let int_type = if int_type.is_null() {
+                let mut value = *tk_sys::Tcl_NewWideIntObj(0);
                 let res = value.typePtr;
                 tk_sys::Tcl_DecrRefCount(&mut value);
                 res
@@ -374,33 +442,37 @@ mod _tkinter {
             }
 
             if args.interactive != 0 {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "tcl_interactive".as_ptr() as _,
+                    ptr::null(),
                     "1".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
             } else {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "tcl_interactive".as_ptr() as _,
+                    ptr::null(),
                     "0".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
             }
 
             let argv0 = args.class_name.clone().to_lowercase();
-            tk_sys::Tcl_SetVar(
+            tk_sys::Tcl_SetVar2(
                 interp,
                 "argv0".as_ptr() as _,
+                ptr::null(),
                 argv0.as_ptr() as _,
                 tk_sys::TCL_GLOBAL_ONLY as i32,
             );
 
             if !args.want_tk {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "_tkinter_skip_tk_init".as_ptr() as _,
+                    ptr::null(),
                     "1".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
@@ -418,11 +490,12 @@ mod _tkinter {
                     argv.push_str("-use ");
                     argv.push_str(&args.use_.unwrap());
                 }
-                argv.push_str("\0");
+                argv.push('\0');
                 let argv_ptr = argv.as_ptr() as *mut *mut i8;
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "argv".as_ptr() as _,
+                    ptr::null(),
                     argv_ptr as *const i8,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
@@ -460,8 +533,7 @@ mod _tkinter {
                 string_type,
                 utf32_string_type,
                 pixel_type,
-            }
-            .into_pyobject(vm))
+            })
         }
     }
 

From 9fcc471c94844cbfeaa4b6c1853217ea18330f53 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 30 Dec 2025 17:36:15 +0900
Subject: [PATCH 124/418] Prevent tb_next loop (#6596)

---
 Lib/test/test_raise.py              |  1 -
 crates/vm/src/builtins/traceback.rs | 26 ++++++++++++++++++++++----
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/Lib/test/test_raise.py b/Lib/test/test_raise.py
index 53fce0a501d..605169f4b40 100644
--- a/Lib/test/test_raise.py
+++ b/Lib/test/test_raise.py
@@ -244,7 +244,6 @@ class TestTracebackType(unittest.TestCase):
     def raiser(self):
         raise ValueError
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_attrs(self):
         try:
             self.raiser()
diff --git a/crates/vm/src/builtins/traceback.rs b/crates/vm/src/builtins/traceback.rs
index 84493e7125f..675025cd6b6 100644
--- a/crates/vm/src/builtins/traceback.rs
+++ b/crates/vm/src/builtins/traceback.rs
@@ -1,7 +1,7 @@
 use super::PyType;
 use crate::{
-    Context, Py, PyPayload, PyRef, PyResult, VirtualMachine, class::PyClassImpl, frame::FrameRef,
-    types::Constructor,
+    AsObject, Context, Py, PyPayload, PyRef, PyResult, VirtualMachine, class::PyClassImpl,
+    frame::FrameRef, types::Constructor,
 };
 use rustpython_common::lock::PyMutex;
 use rustpython_compiler_core::OneIndexed;
@@ -63,8 +63,26 @@ impl PyTraceback {
     }
 
     #[pygetset(setter)]
-    fn set_tb_next(&self, value: Option<PyRef<Self>>) {
-        *self.next.lock() = value;
+    fn set_tb_next(
+        zelf: &Py<Self>,
+        value: Option<PyRef<Self>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if let Some(ref new_next) = value {
+            let mut cursor = new_next.clone();
+            loop {
+                if cursor.is(zelf) {
+                    return Err(vm.new_value_error("traceback loop detected".to_owned()));
+                }
+                let next = cursor.next.lock().clone();
+                match next {
+                    Some(n) => cursor = n,
+                    None => break,
+                }
+            }
+        }
+        *zelf.next.lock() = value;
+        Ok(())
     }
 }
 

From b98f06214d0f6e8b2dc642e354e53c7ea566d4d4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 01:42:11 +0900
Subject: [PATCH 125/418] Update issubclass and make mro representation fit to
 CPython (#5866)

---
 crates/vm/src/builtins/type.rs   | 56 ++++++++++++++------------------
 crates/vm/src/object/core.rs     |  8 ++++-
 crates/vm/src/types/slot.rs      |  7 ++--
 crates/vm/src/types/slot_defs.rs |  5 +--
 4 files changed, 39 insertions(+), 37 deletions(-)

diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 3eca5edc478..178131c96d6 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -50,7 +50,8 @@ unsafe impl crate::object::Traverse for PyType {
     fn traverse(&self, tracer_fn: &mut crate::object::TraverseFn<'_>) {
         self.base.traverse(tracer_fn);
         self.bases.traverse(tracer_fn);
-        self.mro.traverse(tracer_fn);
+        // mro contains self as mro[0], so skip traversing to avoid circular reference
+        // self.mro.traverse(tracer_fn);
         self.subclasses.traverse(tracer_fn);
         self.attributes
             .read_recursive()
@@ -341,6 +342,7 @@ impl PyType {
             metaclass,
             None,
         );
+        new_type.mro.write().insert(0, new_type.clone());
 
         new_type.init_slots(ctx);
 
@@ -393,6 +395,7 @@ impl PyType {
             metaclass,
             None,
         );
+        new_type.mro.write().insert(0, new_type.clone());
 
         // Note: inherit_slots is called in PyClassImpl::init_class after
         // slots are fully initialized by make_slots()
@@ -413,9 +416,8 @@ impl PyType {
     }
 
     pub(crate) fn init_slots(&self, ctx: &Context) {
-        // Inherit slots from MRO
-        // Note: self.mro does NOT include self, so we iterate all elements
-        let mro: Vec<_> = self.mro.read().iter().cloned().collect();
+        // Inherit slots from MRO (mro[0] is self, so skip it)
+        let mro: Vec<_> = self.mro.read()[1..].to_vec();
         for base in mro.iter() {
             self.inherit_slots(base);
         }
@@ -424,7 +426,8 @@ impl PyType {
         #[allow(clippy::mutable_key_type)]
         let mut slot_name_set = std::collections::HashSet::new();
 
-        for cls in self.mro.read().iter() {
+        // mro[0] is self, so skip it; self.attributes is checked separately below
+        for cls in self.mro.read()[1..].iter() {
             for &name in cls.attributes.read().keys() {
                 if name.as_bytes().starts_with(b"__") && name.as_bytes().ends_with(b"__") {
                     slot_name_set.insert(name);
@@ -503,18 +506,12 @@ impl PyType {
     /// Equivalent to CPython's find_name_in_mro
     /// Look in tp_dict of types in MRO - bypasses descriptors and other attribute access machinery
     fn find_name_in_mro(&self, name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        // First check in our own dict
-        if let Some(value) = self.attributes.read().get(name) {
-            return Some(value.clone());
-        }
-
-        // Then check in MRO
-        for base in self.mro.read().iter() {
-            if let Some(value) = base.attributes.read().get(name) {
+        // mro[0] is self, so we just iterate through the entire MRO
+        for cls in self.mro.read().iter() {
+            if let Some(value) = cls.attributes.read().get(name) {
                 return Some(value.clone());
             }
         }
-
         None
     }
 
@@ -530,8 +527,7 @@ impl PyType {
     }
 
     pub fn get_super_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        self.mro
-            .read()
+        self.mro.read()[1..]
             .iter()
             .find_map(|class| class.attributes.read().get(attr_name).cloned())
     }
@@ -539,9 +535,7 @@ impl PyType {
     // This is the internal has_attr implementation for fast lookup on a class.
     pub fn has_attr(&self, attr_name: &'static PyStrInterned) -> bool {
         self.attributes.read().contains_key(attr_name)
-            || self
-                .mro
-                .read()
+            || self.mro.read()[1..]
                 .iter()
                 .any(|c| c.attributes.read().contains_key(attr_name))
     }
@@ -550,10 +544,8 @@ impl PyType {
         // Gather all members here:
         let mut attributes = PyAttributes::default();
 
-        for bc in core::iter::once(self)
-            .chain(self.mro.read().iter().map(|cls| -> &Self { cls }))
-            .rev()
-        {
+        // mro[0] is self, so we iterate through the entire MRO in reverse
+        for bc in self.mro.read().iter().map(|cls| -> &Self { cls }).rev() {
             for (name, value) in bc.attributes.read().iter() {
                 attributes.insert(name.to_owned(), value.clone());
             }
@@ -661,22 +653,21 @@ impl Py<PyType> {
     /// so only use this if `cls` is known to have not overridden the base __subclasscheck__ magic
     /// method.
     pub fn fast_issubclass(&self, cls: &impl Borrow<PyObject>) -> bool {
-        self.as_object().is(cls.borrow()) || self.mro.read().iter().any(|c| c.is(cls.borrow()))
+        self.as_object().is(cls.borrow()) || self.mro.read()[1..].iter().any(|c| c.is(cls.borrow()))
     }
 
     pub fn mro_map_collect<F, R>(&self, f: F) -> Vec<R>
     where
         F: Fn(&Self) -> R,
     {
-        core::iter::once(self)
-            .chain(self.mro.read().iter().map(|x| x.deref()))
-            .map(f)
-            .collect()
+        self.mro.read().iter().map(|x| x.deref()).map(f).collect()
     }
 
     pub fn mro_collect(&self) -> Vec<PyRef<PyType>> {
-        core::iter::once(self)
-            .chain(self.mro.read().iter().map(|x| x.deref()))
+        self.mro
+            .read()
+            .iter()
+            .map(|x| x.deref())
             .map(|x| x.to_owned())
             .collect()
     }
@@ -745,8 +736,11 @@ impl PyType {
         *zelf.bases.write() = bases;
         // Recursively update the mros of this class and all subclasses
         fn update_mro_recursively(cls: &PyType, vm: &VirtualMachine) -> PyResult<()> {
-            *cls.mro.write() =
+            let mut mro =
                 PyType::resolve_mro(&cls.bases.read()).map_err(|msg| vm.new_type_error(msg))?;
+            // Preserve self (mro[0]) when updating MRO
+            mro.insert(0, cls.mro.read()[0].to_owned());
+            *cls.mro.write() = mro;
             for subclass in cls.subclasses.write().iter() {
                 let subclass = subclass.upgrade().unwrap();
                 let subclass: &Py<PyType> = subclass.downcast_ref().unwrap();
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index cee3fac266e..e904117b06a 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -1310,12 +1310,16 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             ptr::write(&mut (*type_type_ptr).typ, PyAtomicRef::from(type_type));
 
             let object_type = PyTypeRef::from_raw(object_type_ptr.cast());
+            // object's mro is [object]
+            (*object_type_ptr).payload.mro = PyRwLock::new(vec![object_type.clone()]);
 
-            (*type_type_ptr).payload.mro = PyRwLock::new(vec![object_type.clone()]);
             (*type_type_ptr).payload.bases = PyRwLock::new(vec![object_type.clone()]);
             (*type_type_ptr).payload.base = Some(object_type.clone());
 
             let type_type = PyTypeRef::from_raw(type_type_ptr.cast());
+            // type's mro is [type, object]
+            (*type_type_ptr).payload.mro =
+                PyRwLock::new(vec![type_type.clone(), object_type.clone()]);
 
             (type_type, object_type)
         }
@@ -1331,6 +1335,8 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         heaptype_ext: None,
     };
     let weakref_type = PyRef::new_ref(weakref_type, type_type.clone(), None);
+    // weakref's mro is [weakref, object]
+    weakref_type.mro.write().insert(0, weakref_type.clone());
 
     object_type.subclasses.write().push(
         type_type
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 9d7d09f2d18..085cfea5cee 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -760,8 +760,9 @@ impl PyType {
                         let in_self = cmp_names.iter().any(|n| attrs.contains_key(*n));
                         drop(attrs);
 
+                        // mro[0] is self, so skip it since we already checked self above
                         in_self
-                            || self.mro.read().iter().any(|cls| {
+                            || self.mro.read()[1..].iter().any(|cls| {
                                 let attrs = cls.attributes.read();
                                 cmp_names.iter().any(|n| {
                                     if let Some(attr) = attrs.get(*n) {
@@ -1273,8 +1274,8 @@ impl PyType {
             return None;
         }
 
-        // Look up in MRO
-        for cls in self.mro.read().iter() {
+        // Look up in MRO (mro[0] is self, so skip it)
+        for cls in self.mro.read()[1..].iter() {
             if let Some(attr) = cls.attributes.read().get(name).cloned() {
                 if let Some(func) = try_extract(&attr) {
                     return Some(func);
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
index 0d8dbf4b0cc..958adb2f27e 100644
--- a/crates/vm/src/types/slot_defs.rs
+++ b/crates/vm/src/types/slot_defs.rs
@@ -405,8 +405,9 @@ impl SlotAccessor {
 
     /// Inherit slot value from MRO
     pub fn inherit_from_mro(&self, typ: &crate::builtins::PyType) {
-        // Note: typ.mro does NOT include typ itself
-        let mro = typ.mro.read();
+        // mro[0] is self, so skip it
+        let mro_guard = typ.mro.read();
+        let mro = &mro_guard[1..];
 
         macro_rules! inherit_main {
             ($slot:ident) => {{

From ca1c4c1f715c32ab6a60f6d395c9cbc6df3c56e4 Mon Sep 17 00:00:00 2001
From: Vinh Nguyen <89290241+ntvinh2005@users.noreply.github.com>
Date: Tue, 30 Dec 2025 11:54:50 -0500
Subject: [PATCH 126/418] feat: Sync code.py + test_code_module.py from CPython
 v3.13.1 (#6181)

* feat: Sync code module from cpython 3.13

* also udpate test_code_module

---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 Lib/code.py                  | 203 +++++++++++++++++++++++-----------
 Lib/test/test_code_module.py | 208 ++++++++++++++++++++++++++++++++---
 2 files changed, 326 insertions(+), 85 deletions(-)

diff --git a/Lib/code.py b/Lib/code.py
index 2bd5fa3e795..2777c311187 100644
--- a/Lib/code.py
+++ b/Lib/code.py
@@ -5,6 +5,7 @@
 # Inspired by similar code by Jeff Epler and Fredrik Lundh.
 
 
+import builtins
 import sys
 import traceback
 from codeop import CommandCompiler, compile_command
@@ -12,6 +13,7 @@
 __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
            "compile_command"]
 
+
 class InteractiveInterpreter:
     """Base class for InteractiveConsole.
 
@@ -24,10 +26,10 @@ class InteractiveInterpreter:
     def __init__(self, locals=None):
         """Constructor.
 
-        The optional 'locals' argument specifies the dictionary in
-        which code will be executed; it defaults to a newly created
-        dictionary with key "__name__" set to "__console__" and key
-        "__doc__" set to None.
+        The optional 'locals' argument specifies a mapping to use as the
+        namespace in which code will be executed; it defaults to a newly
+        created dictionary with key "__name__" set to "__console__" and
+        key "__doc__" set to None.
 
         """
         if locals is None:
@@ -63,7 +65,7 @@ def runsource(self, source, filename="<input>", symbol="single"):
             code = self.compile(source, filename, symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
-            self.showsyntaxerror(filename)
+            self.showsyntaxerror(filename, source=source)
             return False
 
         if code is None:
@@ -93,7 +95,7 @@ def runcode(self, code):
         except:
             self.showtraceback()
 
-    def showsyntaxerror(self, filename=None):
+    def showsyntaxerror(self, filename=None, **kwargs):
         """Display the syntax error that just occurred.
 
         This doesn't display a stack trace because there isn't one.
@@ -105,29 +107,14 @@ def showsyntaxerror(self, filename=None):
         The output is written by self.write(), below.
 
         """
-        type, value, tb = sys.exc_info()
-        sys.last_exc = value
-        sys.last_type = type
-        sys.last_value = value
-        sys.last_traceback = tb
-        if filename and type is SyntaxError:
-            # Work hard to stuff the correct filename in the exception
-            try:
-                msg, (dummy_filename, lineno, offset, line) = value.args
-            except ValueError:
-                # Not the format we expect; leave it alone
-                pass
-            else:
-                # Stuff in the right filename
-                value = SyntaxError(msg, (filename, lineno, offset, line))
-                sys.last_exc = sys.last_value = value
-        if sys.excepthook is sys.__excepthook__:
-            lines = traceback.format_exception_only(type, value)
-            self.write(''.join(lines))
-        else:
-            # If someone has set sys.excepthook, we let that take precedence
-            # over self.write
-            sys.excepthook(type, value, tb)
+        try:
+            typ, value, tb = sys.exc_info()
+            if filename and issubclass(typ, SyntaxError):
+                value.filename = filename
+            source = kwargs.pop('source', "")
+            self._showtraceback(typ, value, None, source)
+        finally:
+            typ = value = tb = None
 
     def showtraceback(self):
         """Display the exception that just occurred.
@@ -137,19 +124,46 @@ def showtraceback(self):
         The output is written by self.write(), below.
 
         """
-        sys.last_type, sys.last_value, last_tb = ei = sys.exc_info()
-        sys.last_traceback = last_tb
-        sys.last_exc = ei[1]
         try:
-            lines = traceback.format_exception(ei[0], ei[1], last_tb.tb_next)
-            if sys.excepthook is sys.__excepthook__:
-                self.write(''.join(lines))
-            else:
-                # If someone has set sys.excepthook, we let that take precedence
-                # over self.write
-                sys.excepthook(ei[0], ei[1], last_tb)
+            typ, value, tb = sys.exc_info()
+            self._showtraceback(typ, value, tb.tb_next, '')
         finally:
-            last_tb = ei = None
+            typ = value = tb = None
+
+    def _showtraceback(self, typ, value, tb, source):
+        sys.last_type = typ
+        sys.last_traceback = tb
+        value = value.with_traceback(tb)
+        # Set the line of text that the exception refers to
+        lines = source.splitlines()
+        if (source and typ is SyntaxError
+                and not value.text and value.lineno is not None
+                and len(lines) >= value.lineno):
+            value.text = lines[value.lineno - 1]
+        sys.last_exc = sys.last_value = value = value.with_traceback(tb)
+        if sys.excepthook is sys.__excepthook__:
+            self._excepthook(typ, value, tb)
+        else:
+            # If someone has set sys.excepthook, we let that take precedence
+            # over self.write
+            try:
+                sys.excepthook(typ, value, tb)
+            except SystemExit:
+                raise
+            except BaseException as e:
+                e.__context__ = None
+                e = e.with_traceback(e.__traceback__.tb_next)
+                print('Error in sys.excepthook:', file=sys.stderr)
+                sys.__excepthook__(type(e), e, e.__traceback__)
+                print(file=sys.stderr)
+                print('Original exception was:', file=sys.stderr)
+                sys.__excepthook__(typ, value, tb)
+
+    def _excepthook(self, typ, value, tb):
+        # This method is being overwritten in
+        # _pyrepl.console.InteractiveColoredConsole
+        lines = traceback.format_exception(typ, value, tb)
+        self.write(''.join(lines))
 
     def write(self, data):
         """Write a string.
@@ -169,7 +183,7 @@ class InteractiveConsole(InteractiveInterpreter):
 
     """
 
-    def __init__(self, locals=None, filename="<console>"):
+    def __init__(self, locals=None, filename="<console>", *, local_exit=False):
         """Constructor.
 
         The optional locals argument will be passed to the
@@ -181,6 +195,7 @@ def __init__(self, locals=None, filename="<console>"):
         """
         InteractiveInterpreter.__init__(self, locals)
         self.filename = filename
+        self.local_exit = local_exit
         self.resetbuffer()
 
     def resetbuffer(self):
@@ -219,29 +234,66 @@ def interact(self, banner=None, exitmsg=None):
         elif banner:
             self.write("%s\n" % str(banner))
         more = 0
-        while 1:
-            try:
-                if more:
-                    prompt = sys.ps2
-                else:
-                    prompt = sys.ps1
+
+        # When the user uses exit() or quit() in their interactive shell
+        # they probably just want to exit the created shell, not the whole
+        # process. exit and quit in builtins closes sys.stdin which makes
+        # it super difficult to restore
+        #
+        # When self.local_exit is True, we overwrite the builtins so
+        # exit() and quit() only raises SystemExit and we can catch that
+        # to only exit the interactive shell
+
+        _exit = None
+        _quit = None
+
+        if self.local_exit:
+            if hasattr(builtins, "exit"):
+                _exit = builtins.exit
+                builtins.exit = Quitter("exit")
+
+            if hasattr(builtins, "quit"):
+                _quit = builtins.quit
+                builtins.quit = Quitter("quit")
+
+        try:
+            while True:
                 try:
-                    line = self.raw_input(prompt)
-                except EOFError:
-                    self.write("\n")
-                    break
-                else:
-                    more = self.push(line)
-            except KeyboardInterrupt:
-                self.write("\nKeyboardInterrupt\n")
-                self.resetbuffer()
-                more = 0
-        if exitmsg is None:
-            self.write('now exiting %s...\n' % self.__class__.__name__)
-        elif exitmsg != '':
-            self.write('%s\n' % exitmsg)
-
-    def push(self, line):
+                    if more:
+                        prompt = sys.ps2
+                    else:
+                        prompt = sys.ps1
+                    try:
+                        line = self.raw_input(prompt)
+                    except EOFError:
+                        self.write("\n")
+                        break
+                    else:
+                        more = self.push(line)
+                except KeyboardInterrupt:
+                    self.write("\nKeyboardInterrupt\n")
+                    self.resetbuffer()
+                    more = 0
+                except SystemExit as e:
+                    if self.local_exit:
+                        self.write("\n")
+                        break
+                    else:
+                        raise e
+        finally:
+            # restore exit and quit in builtins if they were modified
+            if _exit is not None:
+                builtins.exit = _exit
+
+            if _quit is not None:
+                builtins.quit = _quit
+
+            if exitmsg is None:
+                self.write('now exiting %s...\n' % self.__class__.__name__)
+            elif exitmsg != '':
+                self.write('%s\n' % exitmsg)
+
+    def push(self, line, filename=None, _symbol="single"):
         """Push a line to the interpreter.
 
         The line should not have a trailing newline; it may have
@@ -257,7 +309,9 @@ def push(self, line):
         """
         self.buffer.append(line)
         source = "\n".join(self.buffer)
-        more = self.runsource(source, self.filename)
+        if filename is None:
+            filename = self.filename
+        more = self.runsource(source, filename, symbol=_symbol)
         if not more:
             self.resetbuffer()
         return more
@@ -276,8 +330,22 @@ def raw_input(self, prompt=""):
         return input(prompt)
 
 
+class Quitter:
+    def __init__(self, name):
+        self.name = name
+        if sys.platform == "win32":
+            self.eof = 'Ctrl-Z plus Return'
+        else:
+            self.eof = 'Ctrl-D (i.e. EOF)'
+
+    def __repr__(self):
+        return f'Use {self.name} or {self.eof} to exit'
+
+    def __call__(self, code=None):
+        raise SystemExit(code)
+
 
-def interact(banner=None, readfunc=None, local=None, exitmsg=None):
+def interact(banner=None, readfunc=None, local=None, exitmsg=None, local_exit=False):
     """Closely emulate the interactive Python interpreter.
 
     This is a backwards compatible interface to the InteractiveConsole
@@ -290,9 +358,10 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None):
     readfunc -- if not None, replaces InteractiveConsole.raw_input()
     local -- passed to InteractiveInterpreter.__init__()
     exitmsg -- passed to InteractiveConsole.interact()
+    local_exit -- passed to InteractiveConsole.__init__()
 
     """
-    console = InteractiveConsole(local)
+    console = InteractiveConsole(local, local_exit=local_exit)
     if readfunc is not None:
         console.raw_input = readfunc
     else:
@@ -308,7 +377,7 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None):
 
     parser = argparse.ArgumentParser()
     parser.add_argument('-q', action='store_true',
-                       help="don't print version and copyright messages")
+                        help="don't print version and copyright messages")
     args = parser.parse_args()
     if args.q or sys.flags.quiet:
         banner = ''
diff --git a/Lib/test/test_code_module.py b/Lib/test/test_code_module.py
index 5ac17ef16ea..346cf6746a7 100644
--- a/Lib/test/test_code_module.py
+++ b/Lib/test/test_code_module.py
@@ -1,20 +1,17 @@
 "Test InteractiveConsole and InteractiveInterpreter from code module"
 import sys
+import traceback
 import unittest
 from textwrap import dedent
 from contextlib import ExitStack
 from unittest import mock
+from test.support import force_not_colorized_test_class
 from test.support import import_helper
 
-
 code = import_helper.import_module('code')
 
 
-class TestInteractiveConsole(unittest.TestCase):
-
-    def setUp(self):
-        self.console = code.InteractiveConsole()
-        self.mock_sys()
+class MockSys:
 
     def mock_sys(self):
         "Mock system environment for InteractiveConsole"
@@ -32,6 +29,15 @@ def mock_sys(self):
         del self.sysmod.ps1
         del self.sysmod.ps2
 
+
+@force_not_colorized_test_class
+class TestInteractiveConsole(unittest.TestCase, MockSys):
+    maxDiff = None
+
+    def setUp(self):
+        self.console = code.InteractiveConsole()
+        self.mock_sys()
+
     def test_ps1(self):
         self.infunc.side_effect = EOFError('Finished')
         self.console.interact()
@@ -44,9 +50,9 @@ def test_ps2(self):
         self.infunc.side_effect = EOFError('Finished')
         self.console.interact()
         self.assertEqual(self.sysmod.ps2, '... ')
-        self.sysmod.ps1 = 'custom2> '
+        self.sysmod.ps2 = 'custom2> '
         self.console.interact()
-        self.assertEqual(self.sysmod.ps1, 'custom2> ')
+        self.assertEqual(self.sysmod.ps2, 'custom2> ')
 
     def test_console_stderr(self):
         self.infunc.side_effect = ["'antioch'", "", EOFError('Finished')]
@@ -57,22 +63,162 @@ def test_console_stderr(self):
         else:
             raise AssertionError("no console stdout")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_syntax_error(self):
-        self.infunc.side_effect = ["undefined", EOFError('Finished')]
+        self.infunc.side_effect = ["def f():",
+                                   "    x = ?",
+                                   "",
+                                    EOFError('Finished')]
         self.console.interact()
-        for call in self.stderr.method_calls:
-            if 'NameError' in ''.join(call[1]):
-                break
-        else:
-            raise AssertionError("No syntax error from console")
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[:output.index('\nnow exiting')]
+        self.assertEqual(output.splitlines()[1:], [
+            '  File "<console>", line 2',
+            '    x = ?',
+            '        ^',
+            'SyntaxError: invalid syntax'])
+        self.assertIs(self.sysmod.last_type, SyntaxError)
+        self.assertIs(type(self.sysmod.last_value), SyntaxError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_indentation_error(self):
+        self.infunc.side_effect = ["  1", EOFError('Finished')]
+        self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[:output.index('\nnow exiting')]
+        self.assertEqual(output.splitlines()[1:], [
+            '  File "<console>", line 1',
+            '    1',
+            'IndentationError: unexpected indent'])
+        self.assertIs(self.sysmod.last_type, IndentationError)
+        self.assertIs(type(self.sysmod.last_value), IndentationError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_unicode_error(self):
+        self.infunc.side_effect = ["'\ud800'", EOFError('Finished')]
+        self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[output.index('\n') + 1:]
+        self.assertTrue(output.startswith('UnicodeEncodeError: '), output)
+        self.assertIs(self.sysmod.last_type, UnicodeEncodeError)
+        self.assertIs(type(self.sysmod.last_value), UnicodeEncodeError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
     def test_sysexcepthook(self):
-        self.infunc.side_effect = ["raise ValueError('')",
+        self.infunc.side_effect = ["def f():",
+                                   "    raise ValueError('BOOM!')",
+                                   "",
+                                   "f()",
+                                    EOFError('Finished')]
+        hook = mock.Mock()
+        self.sysmod.excepthook = hook
+        self.console.interact()
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, ValueError)
+        self.assertIs(type(self.sysmod.last_value), ValueError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            'Traceback (most recent call last):\n',
+            '  File "<console>", line 1, in <module>\n',
+            '  File "<console>", line 2, in f\n',
+            'ValueError: BOOM!\n'])
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_sysexcepthook_syntax_error(self):
+        self.infunc.side_effect = ["def f():",
+                                   "    x = ?",
+                                   "",
                                     EOFError('Finished')]
         hook = mock.Mock()
         self.sysmod.excepthook = hook
         self.console.interact()
-        self.assertTrue(hook.called)
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, SyntaxError)
+        self.assertIs(type(self.sysmod.last_value), SyntaxError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            '  File "<console>", line 2\n',
+            '    x = ?\n',
+            '        ^\n',
+            'SyntaxError: invalid syntax\n'])
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_sysexcepthook_indentation_error(self):
+        self.infunc.side_effect = ["  1", EOFError('Finished')]
+        hook = mock.Mock()
+        self.sysmod.excepthook = hook
+        self.console.interact()
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, IndentationError)
+        self.assertIs(type(self.sysmod.last_value), IndentationError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            '  File "<console>", line 1\n',
+            '    1\n',
+            'IndentationError: unexpected indent\n'])
+
+    def test_sysexcepthook_crashing_doesnt_close_repl(self):
+        self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
+        self.sysmod.excepthook = 1
+        self.console.interact()
+        self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
+        error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
+        self.assertIn("Error in sys.excepthook:", error)
+        self.assertEqual(error.count("'int' object is not callable"), 1)
+        self.assertIn("Original exception was:", error)
+        self.assertIn("division by zero", error)
+
+    def test_sysexcepthook_raising_BaseException(self):
+        self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
+        s = "not so fast"
+        def raise_base(*args, **kwargs):
+            raise BaseException(s)
+        self.sysmod.excepthook = raise_base
+        self.console.interact()
+        self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
+        error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
+        self.assertIn("Error in sys.excepthook:", error)
+        self.assertEqual(error.count("not so fast"), 1)
+        self.assertIn("Original exception was:", error)
+        self.assertIn("division by zero", error)
+
+    def test_sysexcepthook_raising_SystemExit_gets_through(self):
+        self.infunc.side_effect = ["1/0"]
+        def raise_base(*args, **kwargs):
+            raise SystemExit
+        self.sysmod.excepthook = raise_base
+        with self.assertRaises(SystemExit):
+            self.console.interact()
 
     def test_banner(self):
         # with banner
@@ -115,6 +261,7 @@ def test_exit_msg(self):
         expected = message + '\n'
         self.assertEqual(err_msg, ['write', (expected,), {}])
 
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_cause_tb(self):
@@ -132,9 +279,12 @@ def test_cause_tb(self):
         ValueError
         """)
         self.assertIn(expected, output)
+        self.assertIs(self.sysmod.last_type, ValueError)
+        self.assertIs(type(self.sysmod.last_value), ValueError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIsNotNone(self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_context_tb(self):
         self.infunc.side_effect = ["try: ham\nexcept: eggs\n",
                                     EOFError('Finished')]
@@ -152,6 +302,28 @@ def test_context_tb(self):
         NameError: name 'eggs' is not defined
         """)
         self.assertIn(expected, output)
+        self.assertIs(self.sysmod.last_type, NameError)
+        self.assertIs(type(self.sysmod.last_value), NameError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIsNotNone(self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+
+class TestInteractiveConsoleLocalExit(unittest.TestCase, MockSys):
+
+    def setUp(self):
+        self.console = code.InteractiveConsole(local_exit=True)
+        self.mock_sys()
+
+    @unittest.skipIf(sys.flags.no_site, "exit() isn't defined unless there's a site module")
+    def test_exit(self):
+        # default exit message
+        self.infunc.side_effect = ["exit()"]
+        self.console.interact(banner='')
+        self.assertEqual(len(self.stderr.method_calls), 2)
+        err_msg = self.stderr.method_calls[1]
+        expected = 'now exiting InteractiveConsole...\n'
+        self.assertEqual(err_msg, ['write', (expected,), {}])
 
 
 if __name__ == "__main__":

From 6bf1ab65c08b614d4d15c716ba84e8dcf2774111 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 01:58:34 +0900
Subject: [PATCH 127/418] Initiailzer for PyCStructure (#6586)

---
 crates/vm/src/stdlib/ctypes/structure.rs | 140 ++++++++++++++---------
 crates/vm/src/stdlib/ctypes/union.rs     |   8 +-
 2 files changed, 94 insertions(+), 54 deletions(-)

diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index 295ce0d87cf..732f3c66801 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -368,6 +368,7 @@ impl PyCStructType {
 
         // Store StgInfo with aligned size and total alignment
         let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.length = fields.len();
         stg_info.format = Some(format);
         stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL; // Mark as finalized
         if has_pointer {
@@ -511,7 +512,7 @@ impl Debug for PyCStructure {
 impl Constructor for PyCStructure {
     type Args = FuncArgs;
 
-    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         // Check for abstract class and extract values in a block to drop the borrow
         let (total_size, total_align, length) = {
             let stg_info = cls.stg_info(vm)?;
@@ -523,79 +524,116 @@ impl Constructor for PyCStructure {
             stg_info_mut.flags |= StgInfoFlags::DICTFLAG_FINAL;
         }
 
-        // Get _fields_ from the class using get_attr to properly search MRO
-        let fields_attr = cls.as_object().get_attr("_fields_", vm).ok();
+        // Initialize buffer with zeros using computed size
+        let mut new_stg_info = StgInfo::new(total_size, total_align);
+        new_stg_info.length = length;
+        PyCStructure(PyCData::from_stg_info(&new_stg_info))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl PyCStructure {
+    /// Recursively initialize positional arguments through inheritance chain
+    /// Returns the number of arguments consumed
+    fn init_pos_args(
+        self_obj: &Py<Self>,
+        type_obj: &Py<PyType>,
+        args: &[PyObjectRef],
+        kwargs: &indexmap::IndexMap<String, PyObjectRef>,
+        index: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        let mut current_index = index;
 
-        // Collect field names for initialization
-        let mut field_names: Vec<String> = Vec::new();
-        if let Some(fields_attr) = fields_attr {
-            let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>()
+        // 1. First process base class fields recursively
+        let base_clone = {
+            let bases = type_obj.bases.read();
+            if let Some(base) = bases.first()
+                && base.stg_info_opt().is_some()
             {
-                list.borrow_vec().to_vec()
-            } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
-                tuple.to_vec()
+                Some(base.clone())
             } else {
-                vec![]
-            };
+                None
+            }
+        };
+
+        if let Some(ref base) = base_clone {
+            current_index = Self::init_pos_args(self_obj, base, args, kwargs, current_index, vm)?;
+        }
+
+        // 2. Process this class's _fields_
+        if let Some(fields_attr) = type_obj.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
 
             for field in fields.iter() {
-                let Some(field_tuple) = field.downcast_ref::<PyTuple>() else {
-                    continue;
-                };
-                if field_tuple.len() < 2 {
-                    continue;
+                if current_index >= args.len() {
+                    break;
                 }
-                if let Some(name) = field_tuple.first().unwrap().downcast_ref::<PyStr>() {
-                    field_names.push(name.to_string());
+                if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                    && let Some(name) = tuple.first()
+                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                {
+                    let field_name = name_str.as_str().to_owned();
+                    // Check for duplicate in kwargs
+                    if kwargs.contains_key(&field_name) {
+                        return Err(vm.new_type_error(format!(
+                            "duplicate values for field {:?}",
+                            field_name
+                        )));
+                    }
+                    self_obj.as_object().set_attr(
+                        vm.ctx.intern_str(field_name),
+                        args[current_index].clone(),
+                        vm,
+                    )?;
+                    current_index += 1;
                 }
             }
         }
 
-        // Initialize buffer with zeros using computed size
-        let mut stg_info = StgInfo::new(total_size, total_align);
-        stg_info.length = if length > 0 {
-            length
-        } else {
-            field_names.len()
-        };
-        stg_info.paramfunc = super::base::ParamFunc::Structure;
-        let instance = PyCStructure(PyCData::from_stg_info(&stg_info));
+        Ok(current_index)
+    }
+}
 
-        // Handle keyword arguments for field initialization
-        let py_instance = instance.into_ref_with_type(vm, cls.clone())?;
-        let py_obj: PyObjectRef = py_instance.clone().into();
+impl Initializer for PyCStructure {
+    type Args = FuncArgs;
 
-        // Set field values from kwargs using standard attribute setting
-        for (key, value) in args.kwargs.iter() {
-            if field_names.iter().any(|n| n == key.as_str()) {
-                py_obj.set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
+    fn init(zelf: crate::PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Struct_init: handle positional and keyword arguments
+        let cls = zelf.class().to_owned();
+
+        // 1. Process positional arguments recursively through inheritance chain
+        if !args.args.is_empty() {
+            let consumed =
+                PyCStructure::init_pos_args(&zelf, &cls, &args.args, &args.kwargs, 0, vm)?;
+
+            if consumed < args.args.len() {
+                return Err(vm.new_type_error("too many initializers"));
             }
         }
 
-        // Set field values from positional args
-        if args.args.len() > field_names.len() {
-            return Err(vm.new_type_error("too many initializers".to_string()));
-        }
-        for (i, value) in args.args.iter().enumerate() {
-            py_obj.set_attr(
-                vm.ctx.intern_str(field_names[i].as_str()),
-                value.clone(),
-                vm,
-            )?;
+        // 2. Process keyword arguments
+        for (key, value) in args.kwargs.iter() {
+            zelf.as_object()
+                .set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
         }
 
-        Ok(py_instance.into())
-    }
-
-    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
-        unimplemented!("use slot_new")
+        Ok(())
     }
 }
 
 // Note: GetAttr and SetAttr are not implemented here.
 // Field access is handled by CField descriptors registered on the class.
 
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor, AsBuffer))]
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsBuffer)
+)]
 impl PyCStructure {
     #[pygetset]
     fn _b0_(&self) -> Option<PyObjectRef> {
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
index 0da1ffee3fd..aecef18ec7c 100644
--- a/crates/vm/src/stdlib/ctypes/union.rs
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -273,6 +273,7 @@ impl PyCUnionType {
 
         // Store StgInfo with aligned size
         let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.length = fields.len();
         stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL | StgInfoFlags::TYPEFLAG_HASUNION;
         // PEP 3118 doesn't support union. Use 'B' for bytes.
         stg_info.format = Some("B".to_string());
@@ -431,9 +432,9 @@ impl Constructor for PyCUnion {
 
     fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         // Check for abstract class and extract values in a block to drop the borrow
-        let (total_size, total_align) = {
+        let (total_size, total_align, length) = {
             let stg_info = cls.stg_info(vm)?;
-            (stg_info.size, stg_info.align)
+            (stg_info.size, stg_info.align, stg_info.length)
         };
 
         // Mark the class as finalized (instance creation finalizes the type)
@@ -442,7 +443,8 @@ impl Constructor for PyCUnion {
         }
 
         // Initialize buffer with zeros using computed size
-        let new_stg_info = StgInfo::new(total_size, total_align);
+        let mut new_stg_info = StgInfo::new(total_size, total_align);
+        new_stg_info.length = length;
         PyCUnion(PyCData::from_stg_info(&new_stg_info))
             .into_ref_with_type(vm, cls)
             .map(Into::into)

From e22091ef606c4eade1850fb5d57fdf0fc3693965 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Tue, 30 Dec 2025 12:31:08 -0500
Subject: [PATCH 128/418] Update straightforward packages Pt 1 (#6595)

* Deleted _pycodecs.py

* Updated code.py library

* Updated the _pydatetime.py lib

* Removed distutils package

* Updated doctest package

* * Updated datetimetester.py
* Added back in _pycodecs.py

* Used tool to verify datetimetester + test_code_module
---
 Lib/_pydatetime.py                        |   62 +-
 Lib/distutils/README                      |   13 -
 Lib/distutils/__init__.py                 |   13 -
 Lib/distutils/_msvccompiler.py            |  574 ----------
 Lib/distutils/archive_util.py             |  256 -----
 Lib/distutils/bcppcompiler.py             |  393 -------
 Lib/distutils/ccompiler.py                | 1115 -------------------
 Lib/distutils/cmd.py                      |  434 --------
 Lib/distutils/command/__init__.py         |   31 -
 Lib/distutils/command/bdist.py            |  143 ---
 Lib/distutils/command/bdist_dumb.py       |  123 --
 Lib/distutils/command/bdist_msi.py        |  741 ------------
 Lib/distutils/command/bdist_rpm.py        |  582 ----------
 Lib/distutils/command/bdist_wininst.py    |  367 ------
 Lib/distutils/command/build.py            |  157 ---
 Lib/distutils/command/build_clib.py       |  209 ----
 Lib/distutils/command/build_ext.py        |  755 -------------
 Lib/distutils/command/build_py.py         |  416 -------
 Lib/distutils/command/build_scripts.py    |  160 ---
 Lib/distutils/command/check.py            |  145 ---
 Lib/distutils/command/clean.py            |   76 --
 Lib/distutils/command/command_template    |   33 -
 Lib/distutils/command/config.py           |  347 ------
 Lib/distutils/command/install.py          |  705 ------------
 Lib/distutils/command/install_data.py     |   79 --
 Lib/distutils/command/install_egg_info.py |   97 --
 Lib/distutils/command/install_headers.py  |   47 -
 Lib/distutils/command/install_lib.py      |  221 ----
 Lib/distutils/command/install_scripts.py  |   60 -
 Lib/distutils/command/register.py         |  304 -----
 Lib/distutils/command/sdist.py            |  456 --------
 Lib/distutils/command/upload.py           |  200 ----
 Lib/distutils/config.py                   |  131 ---
 Lib/distutils/core.py                     |  234 ----
 Lib/distutils/cygwinccompiler.py          |  405 -------
 Lib/distutils/debug.py                    |    5 -
 Lib/distutils/dep_util.py                 |   92 --
 Lib/distutils/dir_util.py                 |  223 ----
 Lib/distutils/dist.py                     | 1236 ---------------------
 Lib/distutils/errors.py                   |   97 --
 Lib/distutils/extension.py                |  240 ----
 Lib/distutils/fancy_getopt.py             |  457 --------
 Lib/distutils/file_util.py                |  238 ----
 Lib/distutils/filelist.py                 |  327 ------
 Lib/distutils/log.py                      |   77 --
 Lib/distutils/msvc9compiler.py            |  791 -------------
 Lib/distutils/msvccompiler.py             |  643 -----------
 Lib/distutils/spawn.py                    |  192 ----
 Lib/distutils/sysconfig.py                |  556 ---------
 Lib/distutils/text_file.py                |  286 -----
 Lib/distutils/unixccompiler.py            |  333 ------
 Lib/distutils/util.py                     |  557 ----------
 Lib/distutils/version.py                  |  343 ------
 Lib/distutils/versionpredicate.py         |  166 ---
 Lib/doctest.py                            |  292 +++--
 Lib/test/datetimetester.py                |  511 +++++++--
 Lib/test/test_code_module.py              |    8 +-
 57 files changed, 638 insertions(+), 17116 deletions(-)
 delete mode 100644 Lib/distutils/README
 delete mode 100644 Lib/distutils/__init__.py
 delete mode 100644 Lib/distutils/_msvccompiler.py
 delete mode 100644 Lib/distutils/archive_util.py
 delete mode 100644 Lib/distutils/bcppcompiler.py
 delete mode 100644 Lib/distutils/ccompiler.py
 delete mode 100644 Lib/distutils/cmd.py
 delete mode 100644 Lib/distutils/command/__init__.py
 delete mode 100644 Lib/distutils/command/bdist.py
 delete mode 100644 Lib/distutils/command/bdist_dumb.py
 delete mode 100644 Lib/distutils/command/bdist_msi.py
 delete mode 100644 Lib/distutils/command/bdist_rpm.py
 delete mode 100644 Lib/distutils/command/bdist_wininst.py
 delete mode 100644 Lib/distutils/command/build.py
 delete mode 100644 Lib/distutils/command/build_clib.py
 delete mode 100644 Lib/distutils/command/build_ext.py
 delete mode 100644 Lib/distutils/command/build_py.py
 delete mode 100644 Lib/distutils/command/build_scripts.py
 delete mode 100644 Lib/distutils/command/check.py
 delete mode 100644 Lib/distutils/command/clean.py
 delete mode 100644 Lib/distutils/command/command_template
 delete mode 100644 Lib/distutils/command/config.py
 delete mode 100644 Lib/distutils/command/install.py
 delete mode 100644 Lib/distutils/command/install_data.py
 delete mode 100644 Lib/distutils/command/install_egg_info.py
 delete mode 100644 Lib/distutils/command/install_headers.py
 delete mode 100644 Lib/distutils/command/install_lib.py
 delete mode 100644 Lib/distutils/command/install_scripts.py
 delete mode 100644 Lib/distutils/command/register.py
 delete mode 100644 Lib/distutils/command/sdist.py
 delete mode 100644 Lib/distutils/command/upload.py
 delete mode 100644 Lib/distutils/config.py
 delete mode 100644 Lib/distutils/core.py
 delete mode 100644 Lib/distutils/cygwinccompiler.py
 delete mode 100644 Lib/distutils/debug.py
 delete mode 100644 Lib/distutils/dep_util.py
 delete mode 100644 Lib/distutils/dir_util.py
 delete mode 100644 Lib/distutils/dist.py
 delete mode 100644 Lib/distutils/errors.py
 delete mode 100644 Lib/distutils/extension.py
 delete mode 100644 Lib/distutils/fancy_getopt.py
 delete mode 100644 Lib/distutils/file_util.py
 delete mode 100644 Lib/distutils/filelist.py
 delete mode 100644 Lib/distutils/log.py
 delete mode 100644 Lib/distutils/msvc9compiler.py
 delete mode 100644 Lib/distutils/msvccompiler.py
 delete mode 100644 Lib/distutils/spawn.py
 delete mode 100644 Lib/distutils/sysconfig.py
 delete mode 100644 Lib/distutils/text_file.py
 delete mode 100644 Lib/distutils/unixccompiler.py
 delete mode 100644 Lib/distutils/util.py
 delete mode 100644 Lib/distutils/version.py
 delete mode 100644 Lib/distutils/versionpredicate.py

diff --git a/Lib/_pydatetime.py b/Lib/_pydatetime.py
index cd0ea900bfb..38e1f764f00 100644
--- a/Lib/_pydatetime.py
+++ b/Lib/_pydatetime.py
@@ -402,6 +402,8 @@ def _parse_hh_mm_ss_ff(tstr):
             raise ValueError("Invalid microsecond component")
         else:
             pos += 1
+            if not all(map(_is_ascii_digit, tstr[pos:])):
+                raise ValueError("Non-digit values in fraction")
 
             len_remainder = len_str - pos
 
@@ -413,9 +415,6 @@ def _parse_hh_mm_ss_ff(tstr):
             time_comps[3] = int(tstr[pos:(pos+to_parse)])
             if to_parse < 6:
                 time_comps[3] *= _FRACTION_CORRECTION[to_parse-1]
-            if (len_remainder > to_parse
-                    and not all(map(_is_ascii_digit, tstr[(pos+to_parse):]))):
-                raise ValueError("Non-digit values in unparsed fraction")
 
     return time_comps
 
@@ -556,10 +555,6 @@ def _check_tzinfo_arg(tz):
     if tz is not None and not isinstance(tz, tzinfo):
         raise TypeError("tzinfo argument must be None or of a tzinfo subclass")
 
-def _cmperror(x, y):
-    raise TypeError("can't compare '%s' to '%s'" % (
-                    type(x).__name__, type(y).__name__))
-
 def _divide_and_round(a, b):
     """divide a by b and round result to the nearest integer
 
@@ -970,6 +965,8 @@ def __new__(cls, year, month=None, day=None):
     @classmethod
     def fromtimestamp(cls, t):
         "Construct a date from a POSIX timestamp (like time.time())."
+        if t is None:
+            raise TypeError("'NoneType' object cannot be interpreted as an integer")
         y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)
         return cls(y, m, d)
 
@@ -1059,8 +1056,8 @@ def isoformat(self):
         This is 'YYYY-MM-DD'.
 
         References:
-        - http://www.w3.org/TR/NOTE-datetime
-        - http://www.cl.cam.ac.uk/~mgk25/iso-time.html
+        - https://www.w3.org/TR/NOTE-datetime
+        - https://www.cl.cam.ac.uk/~mgk25/iso-time.html
         """
         return "%04d-%02d-%02d" % (self._year, self._month, self._day)
 
@@ -1108,35 +1105,38 @@ def replace(self, year=None, month=None, day=None):
             day = self._day
         return type(self)(year, month, day)
 
+    __replace__ = replace
+
     # Comparisons of date objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) == 0
         return NotImplemented
 
     def __le__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) <= 0
         return NotImplemented
 
     def __lt__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) < 0
         return NotImplemented
 
     def __ge__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) >= 0
         return NotImplemented
 
     def __gt__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) > 0
         return NotImplemented
 
     def _cmp(self, other):
         assert isinstance(other, date)
+        assert not isinstance(other, datetime)
         y, m, d = self._year, self._month, self._day
         y2, m2, d2 = other._year, other._month, other._day
         return _cmp((y, m, d), (y2, m2, d2))
@@ -1191,7 +1191,7 @@ def isocalendar(self):
         The first week is 1; Monday is 1 ... Sunday is 7.
 
         ISO calendar algorithm taken from
-        http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
+        https://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
         (used with permission)
         """
         year = self._year
@@ -1633,6 +1633,8 @@ def replace(self, hour=None, minute=None, second=None, microsecond=None,
             fold = self._fold
         return type(self)(hour, minute, second, microsecond, tzinfo, fold=fold)
 
+    __replace__ = replace
+
     # Pickle support.
 
     def _getstate(self, protocol=3):
@@ -1680,7 +1682,7 @@ class datetime(date):
     The year, month and day arguments are required. tzinfo may be None, or an
     instance of a tzinfo subclass. The remaining arguments may be ints.
     """
-    __slots__ = date.__slots__ + time.__slots__
+    __slots__ = time.__slots__
 
     def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
                 microsecond=0, tzinfo=None, *, fold=0):
@@ -1979,6 +1981,8 @@ def replace(self, year=None, month=None, day=None, hour=None,
         return type(self)(year, month, day, hour, minute, second,
                           microsecond, tzinfo, fold=fold)
 
+    __replace__ = replace
+
     def _local_timezone(self):
         if self.tzinfo is None:
             ts = self._mktime()
@@ -2040,7 +2044,7 @@ def isoformat(self, sep='T', timespec='auto'):
         By default, the fractional part is omitted if self.microsecond == 0.
 
         If self.tzinfo is not None, the UTC offset is also attached, giving
-        giving a full format of 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM'.
+        a full format of 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM'.
 
         Optional argument sep specifies the separator between date and
         time, default 'T'.
@@ -2131,42 +2135,32 @@ def dst(self):
     def __eq__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other, allow_mixed=True) == 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            return False
+            return NotImplemented
 
     def __le__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) <= 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __lt__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) < 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __ge__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) >= 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __gt__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) > 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def _cmp(self, other, allow_mixed=False):
         assert isinstance(other, datetime)
@@ -2311,7 +2305,6 @@ def __reduce__(self):
 
 def _isoweek1monday(year):
     # Helper to calculate the day number of the Monday starting week 1
-    # XXX This could be done more efficiently
     THURSDAY = 3
     firstday = _ymd2ord(year, 1, 1)
     firstweekday = (firstday + 6) % 7  # See weekday() above
@@ -2341,6 +2334,9 @@ def __new__(cls, offset, name=_Omitted):
                              "timedelta(hours=24).")
         return cls._create(offset, name)
 
+    def __init_subclass__(cls):
+        raise TypeError("type 'datetime.timezone' is not an acceptable base type")
+
     @classmethod
     def _create(cls, offset, name=None):
         self = tzinfo.__new__(cls)
diff --git a/Lib/distutils/README b/Lib/distutils/README
deleted file mode 100644
index 408a203b85d..00000000000
--- a/Lib/distutils/README
+++ /dev/null
@@ -1,13 +0,0 @@
-This directory contains the Distutils package.
-
-There's a full documentation available at:
-
-    http://docs.python.org/distutils/
-
-The Distutils-SIG web page is also a good starting point:
-
-    http://www.python.org/sigs/distutils-sig/
-
-WARNING : Distutils must remain compatible with 2.3
-
-$Id$
diff --git a/Lib/distutils/__init__.py b/Lib/distutils/__init__.py
deleted file mode 100644
index d823d040a1c..00000000000
--- a/Lib/distutils/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""distutils
-
-The main package for the Python Module Distribution Utilities.  Normally
-used from a setup script as
-
-   from distutils.core import setup
-
-   setup (...)
-"""
-
-import sys
-
-__version__ = sys.version[:sys.version.index(' ')]
diff --git a/Lib/distutils/_msvccompiler.py b/Lib/distutils/_msvccompiler.py
deleted file mode 100644
index 30b3b473985..00000000000
--- a/Lib/distutils/_msvccompiler.py
+++ /dev/null
@@ -1,574 +0,0 @@
-"""distutils._msvccompiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for Microsoft Visual Studio 2015.
-
-The module is compatible with VS 2015 and later. You can find legacy support
-for older versions in distutils.msvc9compiler and distutils.msvccompiler.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-# ported to VS 2005 and VS 2008 by Christian Heimes
-# ported to VS 2015 by Steve Dower
-
-import os
-import shutil
-import stat
-import subprocess
-import winreg
-
-from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
-                             CompileError, LibError, LinkError
-from distutils.ccompiler import CCompiler, gen_lib_options
-from distutils import log
-from distutils.util import get_platform
-
-from itertools import count
-
-def _find_vc2015():
-    try:
-        key = winreg.OpenKeyEx(
-            winreg.HKEY_LOCAL_MACHINE,
-            r"Software\Microsoft\VisualStudio\SxS\VC7",
-            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY
-        )
-    except OSError:
-        log.debug("Visual C++ is not registered")
-        return None, None
-
-    best_version = 0
-    best_dir = None
-    with key:
-        for i in count():
-            try:
-                v, vc_dir, vt = winreg.EnumValue(key, i)
-            except OSError:
-                break
-            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
-                try:
-                    version = int(float(v))
-                except (ValueError, TypeError):
-                    continue
-                if version >= 14 and version > best_version:
-                    best_version, best_dir = version, vc_dir
-    return best_version, best_dir
-
-def _find_vc2017():
-    import _distutils_findvs
-    import threading
-
-    best_version = 0,   # tuple for full version comparisons
-    best_dir = None
-
-    # We need to call findall() on its own thread because it will
-    # initialize COM.
-    all_packages = []
-    def _getall():
-        all_packages.extend(_distutils_findvs.findall())
-    t = threading.Thread(target=_getall)
-    t.start()
-    t.join()
-
-    for name, version_str, path, packages in all_packages:
-        if 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64' in packages:
-            vc_dir = os.path.join(path, 'VC', 'Auxiliary', 'Build')
-            if not os.path.isdir(vc_dir):
-                continue
-            try:
-                version = tuple(int(i) for i in version_str.split('.'))
-            except (ValueError, TypeError):
-                continue
-            if version > best_version:
-                best_version, best_dir = version, vc_dir
-    try:
-        best_version = best_version[0]
-    except IndexError:
-        best_version = None
-    return best_version, best_dir
-
-def _find_vcvarsall(plat_spec):
-    best_version, best_dir = _find_vc2017()
-    vcruntime = None
-    vcruntime_plat = 'x64' if 'amd64' in plat_spec else 'x86'
-    if best_version:
-        vcredist = os.path.join(best_dir, "..", "..", "redist", "MSVC", "**",
-            "Microsoft.VC141.CRT", "vcruntime140.dll")
-        try:
-            import glob
-            vcruntime = glob.glob(vcredist, recursive=True)[-1]
-        except (ImportError, OSError, LookupError):
-            vcruntime = None
-
-    if not best_version:
-        best_version, best_dir = _find_vc2015()
-        if best_version:
-            vcruntime = os.path.join(best_dir, 'redist', vcruntime_plat,
-                "Microsoft.VC140.CRT", "vcruntime140.dll")
-
-    if not best_version:
-        log.debug("No suitable Visual C++ version found")
-        return None, None
-
-    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
-    if not os.path.isfile(vcvarsall):
-        log.debug("%s cannot be found", vcvarsall)
-        return None, None
-
-    if not vcruntime or not os.path.isfile(vcruntime):
-        log.debug("%s cannot be found", vcruntime)
-        vcruntime = None
-
-    return vcvarsall, vcruntime
-
-def _get_vc_env(plat_spec):
-    if os.getenv("DISTUTILS_USE_SDK"):
-        return {
-            key.lower(): value
-            for key, value in os.environ.items()
-        }
-
-    vcvarsall, vcruntime = _find_vcvarsall(plat_spec)
-    if not vcvarsall:
-        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
-
-    try:
-        out = subprocess.check_output(
-            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
-            stderr=subprocess.STDOUT,
-        ).decode('utf-16le', errors='replace')
-    except subprocess.CalledProcessError as exc:
-        log.error(exc.output)
-        raise DistutilsPlatformError("Error executing {}"
-                .format(exc.cmd))
-
-    env = {
-        key.lower(): value
-        for key, _, value in
-        (line.partition('=') for line in out.splitlines())
-        if key and value
-    }
-
-    if vcruntime:
-        env['py_vcruntime_redist'] = vcruntime
-    return env
-
-def _find_exe(exe, paths=None):
-    """Return path to an MSVC executable program.
-
-    Tries to find the program in several places: first, one of the
-    MSVC program search paths from the registry; next, the directories
-    in the PATH environment variable.  If any of those work, return an
-    absolute path that is known to exist.  If none of them work, just
-    return the original program name, 'exe'.
-    """
-    if not paths:
-        paths = os.getenv('path').split(os.pathsep)
-    for p in paths:
-        fn = os.path.join(os.path.abspath(p), exe)
-        if os.path.isfile(fn):
-            return fn
-    return exe
-
-# A map keyed by get_platform() return values to values accepted by
-# 'vcvarsall.bat'. Always cross-compile from x86 to work with the
-# lighter-weight MSVC installs that do not include native 64-bit tools.
-PLAT_TO_VCVARS = {
-    'win32' : 'x86',
-    'win-amd64' : 'x86_amd64',
-}
-
-# A set containing the DLLs that are guaranteed to be available for
-# all micro versions of this Python version. Known extension
-# dependencies that are not in this set will be copied to the output
-# path.
-_BUNDLED_DLLS = frozenset(['vcruntime140.dll'])
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        # target platform (.plat_name is consistent with 'bdist')
-        self.plat_name = None
-        self.initialized = False
-
-    def initialize(self, plat_name=None):
-        # multi-init means we would need to check platform same each time...
-        assert not self.initialized, "don't init multiple times"
-        if plat_name is None:
-            plat_name = get_platform()
-        # sanity check for platforms to prevent obscure errors later.
-        if plat_name not in PLAT_TO_VCVARS:
-            raise DistutilsPlatformError("--plat-name must be one of {}"
-                                         .format(tuple(PLAT_TO_VCVARS)))
-
-        # Get the vcvarsall.bat spec for the requested platform.
-        plat_spec = PLAT_TO_VCVARS[plat_name]
-
-        vc_env = _get_vc_env(plat_spec)
-        if not vc_env:
-            raise DistutilsPlatformError("Unable to find a compatible "
-                "Visual Studio installation.")
-
-        self._paths = vc_env.get('path', '')
-        paths = self._paths.split(os.pathsep)
-        self.cc = _find_exe("cl.exe", paths)
-        self.linker = _find_exe("link.exe", paths)
-        self.lib = _find_exe("lib.exe", paths)
-        self.rc = _find_exe("rc.exe", paths)   # resource compiler
-        self.mc = _find_exe("mc.exe", paths)   # message compiler
-        self.mt = _find_exe("mt.exe", paths)   # message compiler
-        self._vcruntime_redist = vc_env.get('py_vcruntime_redist', '')
-
-        for dir in vc_env.get('include', '').split(os.pathsep):
-            if dir:
-                self.add_include_dir(dir.rstrip(os.sep))
-
-        for dir in vc_env.get('lib', '').split(os.pathsep):
-            if dir:
-                self.add_library_dir(dir.rstrip(os.sep))
-
-        self.preprocess_options = None
-        # If vcruntime_redist is available, link against it dynamically. Otherwise,
-        # use /MT[d] to build statically, then switch from libucrt[d].lib to ucrt[d].lib
-        # later to dynamically link to ucrtbase but not vcruntime.
-        self.compile_options = [
-            '/nologo', '/Ox', '/W3', '/GL', '/DNDEBUG'
-        ]
-        self.compile_options.append('/MD' if self._vcruntime_redist else '/MT')
-
-        self.compile_options_debug = [
-            '/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
-        ]
-
-        ldflags = [
-            '/nologo', '/INCREMENTAL:NO', '/LTCG'
-        ]
-        if not self._vcruntime_redist:
-            ldflags.extend(('/nodefaultlib:libucrt.lib', 'ucrt.lib'))
-
-        ldflags_debug = [
-            '/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'
-        ]
-
-        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
-        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
-        self.ldflags_shared = [*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
-        self.ldflags_shared_debug = [*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
-        self.ldflags_static = [*ldflags]
-        self.ldflags_static_debug = [*ldflags_debug]
-
-        self._ldflags = {
-            (CCompiler.EXECUTABLE, None): self.ldflags_exe,
-            (CCompiler.EXECUTABLE, False): self.ldflags_exe,
-            (CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
-            (CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
-            (CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
-            (CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
-            (CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
-            (CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
-            (CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
-        }
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        ext_map = {
-            **{ext: self.obj_extension for ext in self.src_extensions},
-            **{ext: self.res_extension for ext in self._rc_extensions + self._mc_extensions},
-        }
-
-        output_dir = output_dir or ''
-
-        def make_out_path(p):
-            base, ext = os.path.splitext(p)
-            if strip_dir:
-                base = os.path.basename(base)
-            else:
-                _, base = os.path.splitdrive(base)
-                if base.startswith((os.path.sep, os.path.altsep)):
-                    base = base[1:]
-            try:
-                # XXX: This may produce absurdly long paths. We should check
-                # the length of the result and trim base until we fit within
-                # 260 characters.
-                return os.path.join(output_dir, base + ext_map[ext])
-            except LookupError:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError("Don't know how to compile {}".format(p))
-
-        return list(map(make_out_path, source_filenames))
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-
-        add_cpp_opts = False
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-                add_cpp_opts = True
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
-                    base, _ = os.path.splitext(os.path.basename (src))
-                    rc_file = os.path.join(rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc, "/fo" + obj, rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile {} to {}"
-                                   .format(src, obj))
-
-            args = [self.cc] + compile_opts + pp_opts
-            if add_cpp_opts:
-                args.append('/EHsc')
-            args.append(input_opt)
-            args.append("/Fo" + obj)
-            args.extend(extra_postargs)
-
-            try:
-                self.spawn(args)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        if runtime_library_dirs:
-            self.warn("I don't know what to do with 'runtime_library_dirs': "
-                       + str(runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ldflags = self._ldflags[target_desc, debug]
-
-            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            build_temp = os.path.dirname(objects[0])
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    build_temp,
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            output_dir = os.path.dirname(os.path.abspath(output_filename))
-            self.mkpath(output_dir)
-            try:
-                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
-                self.spawn([self.linker] + ld_args)
-                self._copy_vcruntime(output_dir)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def _copy_vcruntime(self, output_dir):
-        vcruntime = self._vcruntime_redist
-        if not vcruntime or not os.path.isfile(vcruntime):
-            return
-
-        if os.path.basename(vcruntime).lower() in _BUNDLED_DLLS:
-            return
-
-        log.debug('Copying "%s"', vcruntime)
-        vcruntime = shutil.copy(vcruntime, output_dir)
-        os.chmod(vcruntime, stat.S_IWRITE)
-
-    def spawn(self, cmd):
-        old_path = os.getenv('path')
-        try:
-            os.environ['path'] = self._paths
-            return super().spawn(cmd)
-        finally:
-            os.environ['path'] = old_path
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename(name))
-                if os.path.isfile(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
diff --git a/Lib/distutils/archive_util.py b/Lib/distutils/archive_util.py
deleted file mode 100644
index b002dc3b845..00000000000
--- a/Lib/distutils/archive_util.py
+++ /dev/null
@@ -1,256 +0,0 @@
-"""distutils.archive_util
-
-Utility functions for creating archive files (tarballs, zip files,
-that sort of thing)."""
-
-import os
-from warnings import warn
-import sys
-
-try:
-    import zipfile
-except ImportError:
-    zipfile = None
-
-
-from distutils.errors import DistutilsExecError
-from distutils.spawn import spawn
-from distutils.dir_util import mkpath
-from distutils import log
-
-try:
-    from pwd import getpwnam
-except ImportError:
-    getpwnam = None
-
-try:
-    from grp import getgrnam
-except ImportError:
-    getgrnam = None
-
-def _get_gid(name):
-    """Returns a gid, given a group name."""
-    if getgrnam is None or name is None:
-        return None
-    try:
-        result = getgrnam(name)
-    except KeyError:
-        result = None
-    if result is not None:
-        return result[2]
-    return None
-
-def _get_uid(name):
-    """Returns an uid, given a user name."""
-    if getpwnam is None or name is None:
-        return None
-    try:
-        result = getpwnam(name)
-    except KeyError:
-        result = None
-    if result is not None:
-        return result[2]
-    return None
-
-def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
-                 owner=None, group=None):
-    """Create a (possibly compressed) tar file from all the files under
-    'base_dir'.
-
-    'compress' must be "gzip" (the default), "bzip2", "xz", "compress", or
-    None.  ("compress" will be deprecated in Python 3.2)
-
-    'owner' and 'group' can be used to define an owner and a group for the
-    archive that is being built. If not provided, the current owner and group
-    will be used.
-
-    The output tar file will be named 'base_dir' +  ".tar", possibly plus
-    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").
-
-    Returns the output filename.
-    """
-    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', 'xz': 'xz', None: '',
-                       'compress': ''}
-    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz',
-                    'compress': '.Z'}
-
-    # flags for compression program, each element of list will be an argument
-    if compress is not None and compress not in compress_ext.keys():
-        raise ValueError(
-              "bad value for 'compress': must be None, 'gzip', 'bzip2', "
-              "'xz' or 'compress'")
-
-    archive_name = base_name + '.tar'
-    if compress != 'compress':
-        archive_name += compress_ext.get(compress, '')
-
-    mkpath(os.path.dirname(archive_name), dry_run=dry_run)
-
-    # creating the tarball
-    import tarfile  # late import so Python build itself doesn't break
-
-    log.info('Creating tar archive')
-
-    uid = _get_uid(owner)
-    gid = _get_gid(group)
-
-    def _set_uid_gid(tarinfo):
-        if gid is not None:
-            tarinfo.gid = gid
-            tarinfo.gname = group
-        if uid is not None:
-            tarinfo.uid = uid
-            tarinfo.uname = owner
-        return tarinfo
-
-    if not dry_run:
-        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
-        try:
-            tar.add(base_dir, filter=_set_uid_gid)
-        finally:
-            tar.close()
-
-    # compression using `compress`
-    if compress == 'compress':
-        warn("'compress' will be deprecated.", PendingDeprecationWarning)
-        # the option varies depending on the platform
-        compressed_name = archive_name + compress_ext[compress]
-        if sys.platform == 'win32':
-            cmd = [compress, archive_name, compressed_name]
-        else:
-            cmd = [compress, '-f', archive_name]
-        spawn(cmd, dry_run=dry_run)
-        return compressed_name
-
-    return archive_name
-
-def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
-    """Create a zip file from all the files under 'base_dir'.
-
-    The output zip file will be named 'base_name' + ".zip".  Uses either the
-    "zipfile" Python module (if available) or the InfoZIP "zip" utility
-    (if installed and found on the default search path).  If neither tool is
-    available, raises DistutilsExecError.  Returns the name of the output zip
-    file.
-    """
-    zip_filename = base_name + ".zip"
-    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
-
-    # If zipfile module is not available, try spawning an external
-    # 'zip' command.
-    if zipfile is None:
-        if verbose:
-            zipoptions = "-r"
-        else:
-            zipoptions = "-rq"
-
-        try:
-            spawn(["zip", zipoptions, zip_filename, base_dir],
-                  dry_run=dry_run)
-        except DistutilsExecError:
-            # XXX really should distinguish between "couldn't find
-            # external 'zip' command" and "zip failed".
-            raise DistutilsExecError(("unable to create zip file '%s': "
-                   "could neither import the 'zipfile' module nor "
-                   "find a standalone zip utility") % zip_filename)
-
-    else:
-        log.info("creating '%s' and adding '%s' to it",
-                 zip_filename, base_dir)
-
-        if not dry_run:
-            try:
-                zip = zipfile.ZipFile(zip_filename, "w",
-                                      compression=zipfile.ZIP_DEFLATED)
-            except RuntimeError:
-                zip = zipfile.ZipFile(zip_filename, "w",
-                                      compression=zipfile.ZIP_STORED)
-
-            if base_dir != os.curdir:
-                path = os.path.normpath(os.path.join(base_dir, ''))
-                zip.write(path, path)
-                log.info("adding '%s'", path)
-            for dirpath, dirnames, filenames in os.walk(base_dir):
-                for name in dirnames:
-                    path = os.path.normpath(os.path.join(dirpath, name, ''))
-                    zip.write(path, path)
-                    log.info("adding '%s'", path)
-                for name in filenames:
-                    path = os.path.normpath(os.path.join(dirpath, name))
-                    if os.path.isfile(path):
-                        zip.write(path, path)
-                        log.info("adding '%s'", path)
-            zip.close()
-
-    return zip_filename
-
-ARCHIVE_FORMATS = {
-    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
-    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
-    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
-    'ztar':  (make_tarball, [('compress', 'compress')], "compressed tar file"),
-    'tar':   (make_tarball, [('compress', None)], "uncompressed tar file"),
-    'zip':   (make_zipfile, [],"ZIP file")
-    }
-
-def check_archive_formats(formats):
-    """Returns the first format from the 'format' list that is unknown.
-
-    If all formats are known, returns None
-    """
-    for format in formats:
-        if format not in ARCHIVE_FORMATS:
-            return format
-    return None
-
-def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
-                 dry_run=0, owner=None, group=None):
-    """Create an archive file (eg. zip or tar).
-
-    'base_name' is the name of the file to create, minus any format-specific
-    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
-    "bztar", "xztar", or "ztar".
-
-    'root_dir' is a directory that will be the root directory of the
-    archive; ie. we typically chdir into 'root_dir' before creating the
-    archive.  'base_dir' is the directory where we start archiving from;
-    ie. 'base_dir' will be the common prefix of all files and
-    directories in the archive.  'root_dir' and 'base_dir' both default
-    to the current directory.  Returns the name of the archive file.
-
-    'owner' and 'group' are used when creating a tar archive. By default,
-    uses the current owner and group.
-    """
-    save_cwd = os.getcwd()
-    if root_dir is not None:
-        log.debug("changing into '%s'", root_dir)
-        base_name = os.path.abspath(base_name)
-        if not dry_run:
-            os.chdir(root_dir)
-
-    if base_dir is None:
-        base_dir = os.curdir
-
-    kwargs = {'dry_run': dry_run}
-
-    try:
-        format_info = ARCHIVE_FORMATS[format]
-    except KeyError:
-        raise ValueError("unknown archive format '%s'" % format)
-
-    func = format_info[0]
-    for arg, val in format_info[1]:
-        kwargs[arg] = val
-
-    if format != 'zip':
-        kwargs['owner'] = owner
-        kwargs['group'] = group
-
-    try:
-        filename = func(base_name, base_dir, **kwargs)
-    finally:
-        if root_dir is not None:
-            log.debug("changing back to '%s'", save_cwd)
-            os.chdir(save_cwd)
-
-    return filename
diff --git a/Lib/distutils/bcppcompiler.py b/Lib/distutils/bcppcompiler.py
deleted file mode 100644
index 9f4c432d90e..00000000000
--- a/Lib/distutils/bcppcompiler.py
+++ /dev/null
@@ -1,393 +0,0 @@
-"""distutils.bcppcompiler
-
-Contains BorlandCCompiler, an implementation of the abstract CCompiler class
-for the Borland C++ compiler.
-"""
-
-# This implementation by Lyle Johnson, based on the original msvccompiler.py
-# module and using the directions originally published by Gordon Williams.
-
-# XXX looks like there's a LOT of overlap between these two classes:
-# someone should sit down and factor out the common code as
-# WindowsCCompiler!  --GPW
-
-
-import os
-from distutils.errors import \
-     DistutilsExecError, DistutilsPlatformError, \
-     CompileError, LibError, LinkError, UnknownFileError
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.file_util import write_file
-from distutils.dep_util import newer
-from distutils import log
-
-class BCPPCompiler(CCompiler) :
-    """Concrete class that implements an interface to the Borland C/C++
-    compiler, as defined by the CCompiler abstract class.
-    """
-
-    compiler_type = 'bcpp'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = _c_extensions + _cpp_extensions
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-
-    def __init__ (self,
-                  verbose=0,
-                  dry_run=0,
-                  force=0):
-
-        CCompiler.__init__ (self, verbose, dry_run, force)
-
-        # These executables are assumed to all be in the path.
-        # Borland doesn't seem to use any special registry settings to
-        # indicate their installation locations.
-
-        self.cc = "bcc32.exe"
-        self.linker = "ilink32.exe"
-        self.lib = "tlib.exe"
-
-        self.preprocess_options = None
-        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
-        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']
-
-        self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
-        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
-        self.ldflags_static = []
-        self.ldflags_exe = ['/Gn', '/q', '/x']
-        self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']
-
-
-    # -- Worker methods ------------------------------------------------
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        macros, objects, extra_postargs, pp_opts, build = \
-                self._setup_compile(output_dir, macros, include_dirs, sources,
-                                    depends, extra_postargs)
-        compile_opts = extra_preargs or []
-        compile_opts.append ('-c')
-        if debug:
-            compile_opts.extend (self.compile_options_debug)
-        else:
-            compile_opts.extend (self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            # XXX why do the normpath here?
-            src = os.path.normpath(src)
-            obj = os.path.normpath(obj)
-            # XXX _setup_compile() did a mkpath() too but before the normpath.
-            # Is it possible to skip the normpath?
-            self.mkpath(os.path.dirname(obj))
-
-            if ext == '.res':
-                # This is already a binary file -- skip it.
-                continue # the 'for' loop
-            if ext == '.rc':
-                # This needs to be compiled to a .res file -- do it now.
-                try:
-                    self.spawn (["brcc32", "-fo", obj, src])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue # the 'for' loop
-
-            # The next two are both for the real compiler.
-            if ext in self._c_extensions:
-                input_opt = ""
-            elif ext in self._cpp_extensions:
-                input_opt = "-P"
-            else:
-                # Unknown file type -- no extra options.  The compiler
-                # will probably fail, but let it just in case this is a
-                # file the compiler recognizes even if we don't.
-                input_opt = ""
-
-            output_opt = "-o" + obj
-
-            # Compiler command line syntax is: "bcc32 [options] file(s)".
-            # Note that the source file names must appear at the end of
-            # the command line.
-            try:
-                self.spawn ([self.cc] + compile_opts + pp_opts +
-                            [input_opt, output_opt] +
-                            extra_postargs + [src])
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-    # compile ()
-
-
-    def create_static_lib (self,
-                           objects,
-                           output_libname,
-                           output_dir=None,
-                           debug=0,
-                           target_lang=None):
-
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        output_filename = \
-            self.library_filename (output_libname, output_dir=output_dir)
-
-        if self._need_link (objects, output_filename):
-            lib_args = [output_filename, '/u'] + objects
-            if debug:
-                pass                    # XXX what goes here?
-            try:
-                self.spawn ([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # create_static_lib ()
-
-
-    def link (self,
-              target_desc,
-              objects,
-              output_filename,
-              output_dir=None,
-              libraries=None,
-              library_dirs=None,
-              runtime_library_dirs=None,
-              export_symbols=None,
-              debug=0,
-              extra_preargs=None,
-              extra_postargs=None,
-              build_temp=None,
-              target_lang=None):
-
-        # XXX this ignores 'build_temp'!  should follow the lead of
-        # msvccompiler.py
-
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        (libraries, library_dirs, runtime_library_dirs) = \
-            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)
-
-        if runtime_library_dirs:
-            log.warn("I don't know what to do with 'runtime_library_dirs': %s",
-                     str(runtime_library_dirs))
-
-        if output_dir is not None:
-            output_filename = os.path.join (output_dir, output_filename)
-
-        if self._need_link (objects, output_filename):
-
-            # Figure out linker args based on type of target.
-            if target_desc == CCompiler.EXECUTABLE:
-                startup_obj = 'c0w32'
-                if debug:
-                    ld_args = self.ldflags_exe_debug[:]
-                else:
-                    ld_args = self.ldflags_exe[:]
-            else:
-                startup_obj = 'c0d32'
-                if debug:
-                    ld_args = self.ldflags_shared_debug[:]
-                else:
-                    ld_args = self.ldflags_shared[:]
-
-
-            # Create a temporary exports file for use by the linker
-            if export_symbols is None:
-                def_file = ''
-            else:
-                head, tail = os.path.split (output_filename)
-                modname, ext = os.path.splitext (tail)
-                temp_dir = os.path.dirname(objects[0]) # preserve tree structure
-                def_file = os.path.join (temp_dir, '%s.def' % modname)
-                contents = ['EXPORTS']
-                for sym in (export_symbols or []):
-                    contents.append('  %s=_%s' % (sym, sym))
-                self.execute(write_file, (def_file, contents),
-                             "writing %s" % def_file)
-
-            # Borland C++ has problems with '/' in paths
-            objects2 = map(os.path.normpath, objects)
-            # split objects in .obj and .res files
-            # Borland C++ needs them at different positions in the command line
-            objects = [startup_obj]
-            resources = []
-            for file in objects2:
-                (base, ext) = os.path.splitext(os.path.normcase(file))
-                if ext == '.res':
-                    resources.append(file)
-                else:
-                    objects.append(file)
-
-
-            for l in library_dirs:
-                ld_args.append("/L%s" % os.path.normpath(l))
-            ld_args.append("/L.") # we sometimes use relative paths
-
-            # list of object files
-            ld_args.extend(objects)
-
-            # XXX the command-line syntax for Borland C++ is a bit wonky;
-            # certain filenames are jammed together in one big string, but
-            # comma-delimited.  This doesn't mesh too well with the
-            # Unix-centric attitude (with a DOS/Windows quoting hack) of
-            # 'spawn()', so constructing the argument list is a bit
-            # awkward.  Note that doing the obvious thing and jamming all
-            # the filenames and commas into one argument would be wrong,
-            # because 'spawn()' would quote any filenames with spaces in
-            # them.  Arghghh!.  Apparently it works fine as coded...
-
-            # name of dll/exe file
-            ld_args.extend([',',output_filename])
-            # no map file and start libraries
-            ld_args.append(',,')
-
-            for lib in libraries:
-                # see if we find it and if there is a bcpp specific lib
-                # (xxx_bcpp.lib)
-                libfile = self.find_library_file(library_dirs, lib, debug)
-                if libfile is None:
-                    ld_args.append(lib)
-                    # probably a BCPP internal library -- don't warn
-                else:
-                    # full name which prefers bcpp_xxx.lib over xxx.lib
-                    ld_args.append(libfile)
-
-            # some default libraries
-            ld_args.append ('import32')
-            ld_args.append ('cw32mt')
-
-            # def file for export symbols
-            ld_args.extend([',',def_file])
-            # add resource files
-            ld_args.append(',')
-            ld_args.extend(resources)
-
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath (os.path.dirname (output_filename))
-            try:
-                self.spawn ([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # link ()
-
-    # -- Miscellaneous methods -----------------------------------------
-
-
-    def find_library_file (self, dirs, lib, debug=0):
-        # List of effective library names to try, in order of preference:
-        # xxx_bcpp.lib is better than xxx.lib
-        # and xxx_d.lib is better than xxx.lib if debug is set
-        #
-        # The "_bcpp" suffix is to handle a Python installation for people
-        # with multiple compilers (primarily Distutils hackers, I suspect
-        # ;-).  The idea is they'd have one static library for each
-        # compiler they care about, since (almost?) every Windows compiler
-        # seems to have a different format for static libraries.
-        if debug:
-            dlib = (lib + "_d")
-            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
-        else:
-            try_names = (lib + "_bcpp", lib)
-
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename(name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # overwrite the one from CCompiler to support rc and res-files
-    def object_filenames (self,
-                          source_filenames,
-                          strip_dir=0,
-                          output_dir=''):
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
-            (base, ext) = os.path.splitext (os.path.normcase(src_name))
-            if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
-                      (ext, src_name))
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext == '.res':
-                # these can go unchanged
-                obj_names.append (os.path.join (output_dir, base + ext))
-            elif ext == '.rc':
-                # these need to be compiled to .res-files
-                obj_names.append (os.path.join (output_dir, base + '.res'))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                            base + self.obj_extension))
-        return obj_names
-
-    # object_filenames ()
-
-    def preprocess (self,
-                    source,
-                    output_file=None,
-                    macros=None,
-                    include_dirs=None,
-                    extra_preargs=None,
-                    extra_postargs=None):
-
-        (_, macros, include_dirs) = \
-            self._fix_compile_args(None, macros, include_dirs)
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = ['cpp32.exe'] + pp_opts
-        if output_file is not None:
-            pp_args.append('-o' + output_file)
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # We need to preprocess: either we're being forced to, or the
-        # source file is newer than the target (or the target doesn't
-        # exist).
-        if self.force or output_file is None or newer(source, output_file):
-            if output_file:
-                self.mkpath(os.path.dirname(output_file))
-            try:
-                self.spawn(pp_args)
-            except DistutilsExecError as msg:
-                print(msg)
-                raise CompileError(msg)
-
-    # preprocess()
diff --git a/Lib/distutils/ccompiler.py b/Lib/distutils/ccompiler.py
deleted file mode 100644
index b71d1d39bcd..00000000000
--- a/Lib/distutils/ccompiler.py
+++ /dev/null
@@ -1,1115 +0,0 @@
-"""distutils.ccompiler
-
-Contains CCompiler, an abstract base class that defines the interface
-for the Distutils compiler abstraction model."""
-
-import sys, os, re
-from distutils.errors import *
-from distutils.spawn import spawn
-from distutils.file_util import move_file
-from distutils.dir_util import mkpath
-from distutils.dep_util import newer_pairwise, newer_group
-from distutils.util import split_quoted, execute
-from distutils import log
-
-class CCompiler:
-    """Abstract base class to define the interface that must be implemented
-    by real compiler classes.  Also has some utility methods used by
-    several compiler classes.
-
-    The basic idea behind a compiler abstraction class is that each
-    instance can be used for all the compile/link steps in building a
-    single project.  Thus, attributes common to all of those compile and
-    link steps -- include directories, macros to define, libraries to link
-    against, etc. -- are attributes of the compiler instance.  To allow for
-    variability in how individual files are treated, most of those
-    attributes may be varied on a per-compilation or per-link basis.
-    """
-
-    # 'compiler_type' is a class attribute that identifies this class.  It
-    # keeps code that wants to know what kind of compiler it's dealing with
-    # from having to import all possible compiler classes just to do an
-    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
-    # should really, really be one of the keys of the 'compiler_class'
-    # dictionary (see below -- used by the 'new_compiler()' factory
-    # function) -- authors of new compiler interface classes are
-    # responsible for updating 'compiler_class'!
-    compiler_type = None
-
-    # XXX things not handled by this compiler abstraction model:
-    #   * client can't provide additional options for a compiler,
-    #     e.g. warning, optimization, debugging flags.  Perhaps this
-    #     should be the domain of concrete compiler abstraction classes
-    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
-    #     class should have methods for the common ones.
-    #   * can't completely override the include or library searchg
-    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
-    #     I'm not sure how widely supported this is even by Unix
-    #     compilers, much less on other platforms.  And I'm even less
-    #     sure how useful it is; maybe for cross-compiling, but
-    #     support for that is a ways off.  (And anyways, cross
-    #     compilers probably have a dedicated binary with the
-    #     right paths compiled in.  I hope.)
-    #   * can't do really freaky things with the library list/library
-    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
-    #     different versions of libfoo.a in different locations.  I
-    #     think this is useless without the ability to null out the
-    #     library search path anyways.
-
-
-    # Subclasses that rely on the standard filename generation methods
-    # implemented below should override these; see the comment near
-    # those methods ('object_filenames()' et. al.) for details:
-    src_extensions = None               # list of strings
-    obj_extension = None                # string
-    static_lib_extension = None
-    shared_lib_extension = None         # string
-    static_lib_format = None            # format string
-    shared_lib_format = None            # prob. same as static_lib_format
-    exe_extension = None                # string
-
-    # Default language settings. language_map is used to detect a source
-    # file or Extension target language, checking source filenames.
-    # language_order is used to detect the language precedence, when deciding
-    # what language to use when mixing source types. For example, if some
-    # extension has two files with ".c" extension, and one with ".cpp", it
-    # is still linked as c++.
-    language_map = {".c"   : "c",
-                    ".cc"  : "c++",
-                    ".cpp" : "c++",
-                    ".cxx" : "c++",
-                    ".m"   : "objc",
-                   }
-    language_order = ["c++", "objc", "c"]
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        self.dry_run = dry_run
-        self.force = force
-        self.verbose = verbose
-
-        # 'output_dir': a common output directory for object, library,
-        # shared object, and shared library files
-        self.output_dir = None
-
-        # 'macros': a list of macro definitions (or undefinitions).  A
-        # macro definition is a 2-tuple (name, value), where the value is
-        # either a string or None (no explicit value).  A macro
-        # undefinition is a 1-tuple (name,).
-        self.macros = []
-
-        # 'include_dirs': a list of directories to search for include files
-        self.include_dirs = []
-
-        # 'libraries': a list of libraries to include in any link
-        # (library names, not filenames: eg. "foo" not "libfoo.a")
-        self.libraries = []
-
-        # 'library_dirs': a list of directories to search for libraries
-        self.library_dirs = []
-
-        # 'runtime_library_dirs': a list of directories to search for
-        # shared libraries/objects at runtime
-        self.runtime_library_dirs = []
-
-        # 'objects': a list of object files (or similar, such as explicitly
-        # named library files) to include on any link
-        self.objects = []
-
-        for key in self.executables.keys():
-            self.set_executable(key, self.executables[key])
-
-    def set_executables(self, **kwargs):
-        """Define the executables (and options for them) that will be run
-        to perform the various stages of compilation.  The exact set of
-        executables that may be specified here depends on the compiler
-        class (via the 'executables' class attribute), but most will have:
-          compiler      the C/C++ compiler
-          linker_so     linker used to create shared objects and libraries
-          linker_exe    linker used to create binary executables
-          archiver      static library creator
-
-        On platforms with a command-line (Unix, DOS/Windows), each of these
-        is a string that will be split into executable name and (optional)
-        list of arguments.  (Splitting the string is done similarly to how
-        Unix shells operate: words are delimited by spaces, but quotes and
-        backslashes can override this.  See
-        'distutils.util.split_quoted()'.)
-        """
-
-        # Note that some CCompiler implementation classes will define class
-        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
-        # this is appropriate when a compiler class is for exactly one
-        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
-        # classes (UnixCCompiler, in particular) are driven by information
-        # discovered at run-time, since there are many different ways to do
-        # basically the same things with Unix C compilers.
-
-        for key in kwargs:
-            if key not in self.executables:
-                raise ValueError("unknown executable '%s' for class %s" %
-                      (key, self.__class__.__name__))
-            self.set_executable(key, kwargs[key])
-
-    def set_executable(self, key, value):
-        if isinstance(value, str):
-            setattr(self, key, split_quoted(value))
-        else:
-            setattr(self, key, value)
-
-    def _find_macro(self, name):
-        i = 0
-        for defn in self.macros:
-            if defn[0] == name:
-                return i
-            i += 1
-        return None
-
-    def _check_macro_definitions(self, definitions):
-        """Ensures that every element of 'definitions' is a valid macro
-        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
-        nothing if all definitions are OK, raise TypeError otherwise.
-        """
-        for defn in definitions:
-            if not (isinstance(defn, tuple) and
-                    (len(defn) in (1, 2) and
-                      (isinstance (defn[1], str) or defn[1] is None)) and
-                    isinstance (defn[0], str)):
-                raise TypeError(("invalid macro definition '%s': " % defn) + \
-                      "must be tuple (string,), (string, string), or " + \
-                      "(string, None)")
-
-
-    # -- Bookkeeping methods -------------------------------------------
-
-    def define_macro(self, name, value=None):
-        """Define a preprocessor macro for all compilations driven by this
-        compiler object.  The optional parameter 'value' should be a
-        string; if it is not supplied, then the macro will be defined
-        without an explicit value and the exact outcome depends on the
-        compiler used (XXX true? does ANSI say anything about this?)
-        """
-        # Delete from the list of macro definitions/undefinitions if
-        # already there (so that this one will take precedence).
-        i = self._find_macro (name)
-        if i is not None:
-            del self.macros[i]
-
-        self.macros.append((name, value))
-
-    def undefine_macro(self, name):
-        """Undefine a preprocessor macro for all compilations driven by
-        this compiler object.  If the same macro is defined by
-        'define_macro()' and undefined by 'undefine_macro()' the last call
-        takes precedence (including multiple redefinitions or
-        undefinitions).  If the macro is redefined/undefined on a
-        per-compilation basis (ie. in the call to 'compile()'), then that
-        takes precedence.
-        """
-        # Delete from the list of macro definitions/undefinitions if
-        # already there (so that this one will take precedence).
-        i = self._find_macro (name)
-        if i is not None:
-            del self.macros[i]
-
-        undefn = (name,)
-        self.macros.append(undefn)
-
-    def add_include_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        header files.  The compiler is instructed to search directories in
-        the order in which they are supplied by successive calls to
-        'add_include_dir()'.
-        """
-        self.include_dirs.append(dir)
-
-    def set_include_dirs(self, dirs):
-        """Set the list of directories that will be searched to 'dirs' (a
-        list of strings).  Overrides any preceding calls to
-        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
-        to the list passed to 'set_include_dirs()'.  This does not affect
-        any list of standard include directories that the compiler may
-        search by default.
-        """
-        self.include_dirs = dirs[:]
-
-    def add_library(self, libname):
-        """Add 'libname' to the list of libraries that will be included in
-        all links driven by this compiler object.  Note that 'libname'
-        should *not* be the name of a file containing a library, but the
-        name of the library itself: the actual filename will be inferred by
-        the linker, the compiler, or the compiler class (depending on the
-        platform).
-
-        The linker will be instructed to link against libraries in the
-        order they were supplied to 'add_library()' and/or
-        'set_libraries()'.  It is perfectly valid to duplicate library
-        names; the linker will be instructed to link against libraries as
-        many times as they are mentioned.
-        """
-        self.libraries.append(libname)
-
-    def set_libraries(self, libnames):
-        """Set the list of libraries to be included in all links driven by
-        this compiler object to 'libnames' (a list of strings).  This does
-        not affect any standard system libraries that the linker may
-        include by default.
-        """
-        self.libraries = libnames[:]
-
-    def add_library_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        libraries specified to 'add_library()' and 'set_libraries()'.  The
-        linker will be instructed to search for libraries in the order they
-        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
-        """
-        self.library_dirs.append(dir)
-
-    def set_library_dirs(self, dirs):
-        """Set the list of library search directories to 'dirs' (a list of
-        strings).  This does not affect any standard library search path
-        that the linker may search by default.
-        """
-        self.library_dirs = dirs[:]
-
-    def add_runtime_library_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        shared libraries at runtime.
-        """
-        self.runtime_library_dirs.append(dir)
-
-    def set_runtime_library_dirs(self, dirs):
-        """Set the list of directories to search for shared libraries at
-        runtime to 'dirs' (a list of strings).  This does not affect any
-        standard search path that the runtime linker may search by
-        default.
-        """
-        self.runtime_library_dirs = dirs[:]
-
-    def add_link_object(self, object):
-        """Add 'object' to the list of object files (or analogues, such as
-        explicitly named library files or the output of "resource
-        compilers") to be included in every link driven by this compiler
-        object.
-        """
-        self.objects.append(object)
-
-    def set_link_objects(self, objects):
-        """Set the list of object files (or analogues) to be included in
-        every link to 'objects'.  This does not affect any standard object
-        files that the linker may include by default (such as system
-        libraries).
-        """
-        self.objects = objects[:]
-
-
-    # -- Private utility methods --------------------------------------
-    # (here for the convenience of subclasses)
-
-    # Helper method to prep compiler in subclass compile() methods
-
-    def _setup_compile(self, outdir, macros, incdirs, sources, depends,
-                       extra):
-        """Process arguments and decide which source files to compile."""
-        if outdir is None:
-            outdir = self.output_dir
-        elif not isinstance(outdir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        if macros is None:
-            macros = self.macros
-        elif isinstance(macros, list):
-            macros = macros + (self.macros or [])
-        else:
-            raise TypeError("'macros' (if supplied) must be a list of tuples")
-
-        if incdirs is None:
-            incdirs = self.include_dirs
-        elif isinstance(incdirs, (list, tuple)):
-            incdirs = list(incdirs) + (self.include_dirs or [])
-        else:
-            raise TypeError(
-                  "'include_dirs' (if supplied) must be a list of strings")
-
-        if extra is None:
-            extra = []
-
-        # Get the list of expected output (object) files
-        objects = self.object_filenames(sources, strip_dir=0,
-                                        output_dir=outdir)
-        assert len(objects) == len(sources)
-
-        pp_opts = gen_preprocess_options(macros, incdirs)
-
-        build = {}
-        for i in range(len(sources)):
-            src = sources[i]
-            obj = objects[i]
-            ext = os.path.splitext(src)[1]
-            self.mkpath(os.path.dirname(obj))
-            build[obj] = (src, ext)
-
-        return macros, objects, extra, pp_opts, build
-
-    def _get_cc_args(self, pp_opts, debug, before):
-        # works for unixccompiler, cygwinccompiler
-        cc_args = pp_opts + ['-c']
-        if debug:
-            cc_args[:0] = ['-g']
-        if before:
-            cc_args[:0] = before
-        return cc_args
-
-    def _fix_compile_args(self, output_dir, macros, include_dirs):
-        """Typecheck and fix-up some of the arguments to the 'compile()'
-        method, and return fixed-up values.  Specifically: if 'output_dir'
-        is None, replaces it with 'self.output_dir'; ensures that 'macros'
-        is a list, and augments it with 'self.macros'; ensures that
-        'include_dirs' is a list, and augments it with 'self.include_dirs'.
-        Guarantees that the returned values are of the correct type,
-        i.e. for 'output_dir' either string or None, and for 'macros' and
-        'include_dirs' either list or None.
-        """
-        if output_dir is None:
-            output_dir = self.output_dir
-        elif not isinstance(output_dir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        if macros is None:
-            macros = self.macros
-        elif isinstance(macros, list):
-            macros = macros + (self.macros or [])
-        else:
-            raise TypeError("'macros' (if supplied) must be a list of tuples")
-
-        if include_dirs is None:
-            include_dirs = self.include_dirs
-        elif isinstance(include_dirs, (list, tuple)):
-            include_dirs = list(include_dirs) + (self.include_dirs or [])
-        else:
-            raise TypeError(
-                  "'include_dirs' (if supplied) must be a list of strings")
-
-        return output_dir, macros, include_dirs
-
-    def _prep_compile(self, sources, output_dir, depends=None):
-        """Decide which souce files must be recompiled.
-
-        Determine the list of object files corresponding to 'sources',
-        and figure out which ones really need to be recompiled.
-        Return a list of all object files and a dictionary telling
-        which source files can be skipped.
-        """
-        # Get the list of expected output (object) files
-        objects = self.object_filenames(sources, output_dir=output_dir)
-        assert len(objects) == len(sources)
-
-        # Return an empty dict for the "which source files can be skipped"
-        # return value to preserve API compatibility.
-        return objects, {}
-
-    def _fix_object_args(self, objects, output_dir):
-        """Typecheck and fix up some arguments supplied to various methods.
-        Specifically: ensure that 'objects' is a list; if output_dir is
-        None, replace with self.output_dir.  Return fixed versions of
-        'objects' and 'output_dir'.
-        """
-        if not isinstance(objects, (list, tuple)):
-            raise TypeError("'objects' must be a list or tuple of strings")
-        objects = list(objects)
-
-        if output_dir is None:
-            output_dir = self.output_dir
-        elif not isinstance(output_dir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        return (objects, output_dir)
-
-    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
-        """Typecheck and fix up some of the arguments supplied to the
-        'link_*' methods.  Specifically: ensure that all arguments are
-        lists, and augment them with their permanent versions
-        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
-        fixed versions of all arguments.
-        """
-        if libraries is None:
-            libraries = self.libraries
-        elif isinstance(libraries, (list, tuple)):
-            libraries = list (libraries) + (self.libraries or [])
-        else:
-            raise TypeError(
-                  "'libraries' (if supplied) must be a list of strings")
-
-        if library_dirs is None:
-            library_dirs = self.library_dirs
-        elif isinstance(library_dirs, (list, tuple)):
-            library_dirs = list (library_dirs) + (self.library_dirs or [])
-        else:
-            raise TypeError(
-                  "'library_dirs' (if supplied) must be a list of strings")
-
-        if runtime_library_dirs is None:
-            runtime_library_dirs = self.runtime_library_dirs
-        elif isinstance(runtime_library_dirs, (list, tuple)):
-            runtime_library_dirs = (list(runtime_library_dirs) +
-                                    (self.runtime_library_dirs or []))
-        else:
-            raise TypeError("'runtime_library_dirs' (if supplied) "
-                            "must be a list of strings")
-
-        return (libraries, library_dirs, runtime_library_dirs)
-
-    def _need_link(self, objects, output_file):
-        """Return true if we need to relink the files listed in 'objects'
-        to recreate 'output_file'.
-        """
-        if self.force:
-            return True
-        else:
-            if self.dry_run:
-                newer = newer_group (objects, output_file, missing='newer')
-            else:
-                newer = newer_group (objects, output_file)
-            return newer
-
-    def detect_language(self, sources):
-        """Detect the language of a given file, or list of files. Uses
-        language_map, and language_order to do the job.
-        """
-        if not isinstance(sources, list):
-            sources = [sources]
-        lang = None
-        index = len(self.language_order)
-        for source in sources:
-            base, ext = os.path.splitext(source)
-            extlang = self.language_map.get(ext)
-            try:
-                extindex = self.language_order.index(extlang)
-                if extindex < index:
-                    lang = extlang
-                    index = extindex
-            except ValueError:
-                pass
-        return lang
-
-
-    # -- Worker methods ------------------------------------------------
-    # (must be implemented by subclasses)
-
-    def preprocess(self, source, output_file=None, macros=None,
-                   include_dirs=None, extra_preargs=None, extra_postargs=None):
-        """Preprocess a single C/C++ source file, named in 'source'.
-        Output will be written to file named 'output_file', or stdout if
-        'output_file' not supplied.  'macros' is a list of macro
-        definitions as for 'compile()', which will augment the macros set
-        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
-        list of directory names that will be added to the default list.
-
-        Raises PreprocessError on failure.
-        """
-        pass
-
-    def compile(self, sources, output_dir=None, macros=None,
-                include_dirs=None, debug=0, extra_preargs=None,
-                extra_postargs=None, depends=None):
-        """Compile one or more source files.
-
-        'sources' must be a list of filenames, most likely C/C++
-        files, but in reality anything that can be handled by a
-        particular compiler and compiler class (eg. MSVCCompiler can
-        handle resource files in 'sources').  Return a list of object
-        filenames, one per source filename in 'sources'.  Depending on
-        the implementation, not all source files will necessarily be
-        compiled, but all corresponding object filenames will be
-        returned.
-
-        If 'output_dir' is given, object files will be put under it, while
-        retaining their original path component.  That is, "foo/bar.c"
-        normally compiles to "foo/bar.o" (for a Unix implementation); if
-        'output_dir' is "build", then it would compile to
-        "build/foo/bar.o".
-
-        'macros', if given, must be a list of macro definitions.  A macro
-        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
-        The former defines a macro; if the value is None, the macro is
-        defined without an explicit value.  The 1-tuple case undefines a
-        macro.  Later definitions/redefinitions/ undefinitions take
-        precedence.
-
-        'include_dirs', if given, must be a list of strings, the
-        directories to add to the default include file search path for this
-        compilation only.
-
-        'debug' is a boolean; if true, the compiler will be instructed to
-        output debug symbols in (or alongside) the object file(s).
-
-        'extra_preargs' and 'extra_postargs' are implementation- dependent.
-        On platforms that have the notion of a command-line (e.g. Unix,
-        DOS/Windows), they are most likely lists of strings: extra
-        command-line arguments to prepand/append to the compiler command
-        line.  On other platforms, consult the implementation class
-        documentation.  In any event, they are intended as an escape hatch
-        for those occasions when the abstract compiler framework doesn't
-        cut the mustard.
-
-        'depends', if given, is a list of filenames that all targets
-        depend on.  If a source file is older than any file in
-        depends, then the source file will be recompiled.  This
-        supports dependency tracking, but only at a coarse
-        granularity.
-
-        Raises CompileError on failure.
-        """
-        # A concrete compiler class can either override this method
-        # entirely or implement _compile().
-        macros, objects, extra_postargs, pp_opts, build = \
-                self._setup_compile(output_dir, macros, include_dirs, sources,
-                                    depends, extra_postargs)
-        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
-
-        # Return *all* object filenames, not just the ones we just built.
-        return objects
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        """Compile 'src' to product 'obj'."""
-        # A concrete compiler class that does not override compile()
-        # should implement _compile().
-        pass
-
-    def create_static_lib(self, objects, output_libname, output_dir=None,
-                          debug=0, target_lang=None):
-        """Link a bunch of stuff together to create a static library file.
-        The "bunch of stuff" consists of the list of object files supplied
-        as 'objects', the extra object files supplied to
-        'add_link_object()' and/or 'set_link_objects()', the libraries
-        supplied to 'add_library()' and/or 'set_libraries()', and the
-        libraries supplied as 'libraries' (if any).
-
-        'output_libname' should be a library name, not a filename; the
-        filename will be inferred from the library name.  'output_dir' is
-        the directory where the library file will be put.
-
-        'debug' is a boolean; if true, debugging information will be
-        included in the library (note that on most platforms, it is the
-        compile step where this matters: the 'debug' flag is included here
-        just for consistency).
-
-        'target_lang' is the target language for which the given objects
-        are being compiled. This allows specific linkage time treatment of
-        certain languages.
-
-        Raises LibError on failure.
-        """
-        pass
-
-
-    # values for target_desc parameter in link()
-    SHARED_OBJECT = "shared_object"
-    SHARED_LIBRARY = "shared_library"
-    EXECUTABLE = "executable"
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-        """Link a bunch of stuff together to create an executable or
-        shared library file.
-
-        The "bunch of stuff" consists of the list of object files supplied
-        as 'objects'.  'output_filename' should be a filename.  If
-        'output_dir' is supplied, 'output_filename' is relative to it
-        (i.e. 'output_filename' can provide directory components if
-        needed).
-
-        'libraries' is a list of libraries to link against.  These are
-        library names, not filenames, since they're translated into
-        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
-        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
-        directory component, which means the linker will look in that
-        specific directory rather than searching all the normal locations.
-
-        'library_dirs', if supplied, should be a list of directories to
-        search for libraries that were specified as bare library names
-        (ie. no directory component).  These are on top of the system
-        default and those supplied to 'add_library_dir()' and/or
-        'set_library_dirs()'.  'runtime_library_dirs' is a list of
-        directories that will be embedded into the shared library and used
-        to search for other shared libraries that *it* depends on at
-        run-time.  (This may only be relevant on Unix.)
-
-        'export_symbols' is a list of symbols that the shared library will
-        export.  (This appears to be relevant only on Windows.)
-
-        'debug' is as for 'compile()' and 'create_static_lib()', with the
-        slight distinction that it actually matters on most platforms (as
-        opposed to 'create_static_lib()', which includes a 'debug' flag
-        mostly for form's sake).
-
-        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
-        of course that they supply command-line arguments for the
-        particular linker being used).
-
-        'target_lang' is the target language for which the given objects
-        are being compiled. This allows specific linkage time treatment of
-        certain languages.
-
-        Raises LinkError on failure.
-        """
-        raise NotImplementedError
-
-
-    # Old 'link_*()' methods, rewritten to use the new 'link()' method.
-
-    def link_shared_lib(self,
-                        objects,
-                        output_libname,
-                        output_dir=None,
-                        libraries=None,
-                        library_dirs=None,
-                        runtime_library_dirs=None,
-                        export_symbols=None,
-                        debug=0,
-                        extra_preargs=None,
-                        extra_postargs=None,
-                        build_temp=None,
-                        target_lang=None):
-        self.link(CCompiler.SHARED_LIBRARY, objects,
-                  self.library_filename(output_libname, lib_type='shared'),
-                  output_dir,
-                  libraries, library_dirs, runtime_library_dirs,
-                  export_symbols, debug,
-                  extra_preargs, extra_postargs, build_temp, target_lang)
-
-
-    def link_shared_object(self,
-                           objects,
-                           output_filename,
-                           output_dir=None,
-                           libraries=None,
-                           library_dirs=None,
-                           runtime_library_dirs=None,
-                           export_symbols=None,
-                           debug=0,
-                           extra_preargs=None,
-                           extra_postargs=None,
-                           build_temp=None,
-                           target_lang=None):
-        self.link(CCompiler.SHARED_OBJECT, objects,
-                  output_filename, output_dir,
-                  libraries, library_dirs, runtime_library_dirs,
-                  export_symbols, debug,
-                  extra_preargs, extra_postargs, build_temp, target_lang)
-
-
-    def link_executable(self,
-                        objects,
-                        output_progname,
-                        output_dir=None,
-                        libraries=None,
-                        library_dirs=None,
-                        runtime_library_dirs=None,
-                        debug=0,
-                        extra_preargs=None,
-                        extra_postargs=None,
-                        target_lang=None):
-        self.link(CCompiler.EXECUTABLE, objects,
-                  self.executable_filename(output_progname), output_dir,
-                  libraries, library_dirs, runtime_library_dirs, None,
-                  debug, extra_preargs, extra_postargs, None, target_lang)
-
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function; there is
-    # no appropriate default implementation so subclasses should
-    # implement all of these.
-
-    def library_dir_option(self, dir):
-        """Return the compiler option to add 'dir' to the list of
-        directories searched for libraries.
-        """
-        raise NotImplementedError
-
-    def runtime_library_dir_option(self, dir):
-        """Return the compiler option to add 'dir' to the list of
-        directories searched for runtime libraries.
-        """
-        raise NotImplementedError
-
-    def library_option(self, lib):
-        """Return the compiler option to add 'lib' to the list of libraries
-        linked into the shared library or executable.
-        """
-        raise NotImplementedError
-
-    def has_function(self, funcname, includes=None, include_dirs=None,
-                     libraries=None, library_dirs=None):
-        """Return a boolean indicating whether funcname is supported on
-        the current platform.  The optional arguments can be used to
-        augment the compilation environment.
-        """
-        # this can't be included at module scope because it tries to
-        # import math which might not be available at that point - maybe
-        # the necessary logic should just be inlined?
-        import tempfile
-        if includes is None:
-            includes = []
-        if include_dirs is None:
-            include_dirs = []
-        if libraries is None:
-            libraries = []
-        if library_dirs is None:
-            library_dirs = []
-        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
-        f = os.fdopen(fd, "w")
-        try:
-            for incl in includes:
-                f.write("""#include "%s"\n""" % incl)
-            f.write("""\
-main (int argc, char **argv) {
-    %s();
-}
-""" % funcname)
-        finally:
-            f.close()
-        try:
-            objects = self.compile([fname], include_dirs=include_dirs)
-        except CompileError:
-            return False
-
-        try:
-            self.link_executable(objects, "a.out",
-                                 libraries=libraries,
-                                 library_dirs=library_dirs)
-        except (LinkError, TypeError):
-            return False
-        return True
-
-    def find_library_file (self, dirs, lib, debug=0):
-        """Search the specified list of directories for a static or shared
-        library file 'lib' and return the full path to that file.  If
-        'debug' true, look for a debugging version (if that makes sense on
-        the current platform).  Return None if 'lib' wasn't found in any of
-        the specified directories.
-        """
-        raise NotImplementedError
-
-    # -- Filename generation methods -----------------------------------
-
-    # The default implementation of the filename generating methods are
-    # prejudiced towards the Unix/DOS/Windows view of the world:
-    #   * object files are named by replacing the source file extension
-    #     (eg. .c/.cpp -> .o/.obj)
-    #   * library files (shared or static) are named by plugging the
-    #     library name and extension into a format string, eg.
-    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
-    #   * executables are named by appending an extension (possibly
-    #     empty) to the program name: eg. progname + ".exe" for
-    #     Windows
-    #
-    # To reduce redundant code, these methods expect to find
-    # several attributes in the current object (presumably defined
-    # as class attributes):
-    #   * src_extensions -
-    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
-    #   * obj_extension -
-    #     object file extension, eg. '.o' or '.obj'
-    #   * static_lib_extension -
-    #     extension for static library files, eg. '.a' or '.lib'
-    #   * shared_lib_extension -
-    #     extension for shared library/object files, eg. '.so', '.dll'
-    #   * static_lib_format -
-    #     format string for generating static library filenames,
-    #     eg. 'lib%s.%s' or '%s.%s'
-    #   * shared_lib_format
-    #     format string for generating shared library filenames
-    #     (probably same as static_lib_format, since the extension
-    #     is one of the intended parameters to the format string)
-    #   * exe_extension -
-    #     extension for executable files, eg. '' or '.exe'
-
-    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
-        if output_dir is None:
-            output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            base, ext = os.path.splitext(src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                raise UnknownFileError(
-                      "unknown file type '%s' (from '%s')" % (ext, src_name))
-            if strip_dir:
-                base = os.path.basename(base)
-            obj_names.append(os.path.join(output_dir,
-                                          base + self.obj_extension))
-        return obj_names
-
-    def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if strip_dir:
-            basename = os.path.basename(basename)
-        return os.path.join(output_dir, basename + self.shared_lib_extension)
-
-    def executable_filename(self, basename, strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if strip_dir:
-            basename = os.path.basename(basename)
-        return os.path.join(output_dir, basename + (self.exe_extension or ''))
-
-    def library_filename(self, libname, lib_type='static',     # or 'shared'
-                         strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if lib_type not in ("static", "shared", "dylib", "xcode_stub"):
-            raise ValueError(
-                  "'lib_type' must be \"static\", \"shared\", \"dylib\", or \"xcode_stub\"")
-        fmt = getattr(self, lib_type + "_lib_format")
-        ext = getattr(self, lib_type + "_lib_extension")
-
-        dir, base = os.path.split(libname)
-        filename = fmt % (base, ext)
-        if strip_dir:
-            dir = ''
-
-        return os.path.join(output_dir, dir, filename)
-
-
-    # -- Utility methods -----------------------------------------------
-
-    def announce(self, msg, level=1):
-        log.debug(msg)
-
-    def debug_print(self, msg):
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-
-    def warn(self, msg):
-        sys.stderr.write("warning: %s\n" % msg)
-
-    def execute(self, func, args, msg=None, level=1):
-        execute(func, args, msg, self.dry_run)
-
-    def spawn(self, cmd):
-        spawn(cmd, dry_run=self.dry_run)
-
-    def move_file(self, src, dst):
-        return move_file(src, dst, dry_run=self.dry_run)
-
-    def mkpath (self, name, mode=0o777):
-        mkpath(name, mode, dry_run=self.dry_run)
-
-
-# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
-# type for that platform. Keys are interpreted as re match
-# patterns. Order is important; platform mappings are preferred over
-# OS names.
-_default_compilers = (
-
-    # Platform string mappings
-
-    # on a cygwin built python we can use gcc like an ordinary UNIXish
-    # compiler
-    ('cygwin.*', 'unix'),
-
-    # OS name mappings
-    ('posix', 'unix'),
-    ('nt', 'msvc'),
-
-    )
-
-def get_default_compiler(osname=None, platform=None):
-    """Determine the default compiler to use for the given platform.
-
-       osname should be one of the standard Python OS names (i.e. the
-       ones returned by os.name) and platform the common value
-       returned by sys.platform for the platform in question.
-
-       The default values are os.name and sys.platform in case the
-       parameters are not given.
-    """
-    if osname is None:
-        osname = os.name
-    if platform is None:
-        platform = sys.platform
-    for pattern, compiler in _default_compilers:
-        if re.match(pattern, platform) is not None or \
-           re.match(pattern, osname) is not None:
-            return compiler
-    # Default to Unix compiler
-    return 'unix'
-
-# Map compiler types to (module_name, class_name) pairs -- ie. where to
-# find the code that implements an interface to this compiler.  (The module
-# is assumed to be in the 'distutils' package.)
-compiler_class = { 'unix':    ('unixccompiler', 'UnixCCompiler',
-                               "standard UNIX-style compiler"),
-                   'msvc':    ('_msvccompiler', 'MSVCCompiler',
-                               "Microsoft Visual C++"),
-                   'cygwin':  ('cygwinccompiler', 'CygwinCCompiler',
-                               "Cygwin port of GNU C Compiler for Win32"),
-                   'mingw32': ('cygwinccompiler', 'Mingw32CCompiler',
-                               "Mingw32 port of GNU C Compiler for Win32"),
-                   'bcpp':    ('bcppcompiler', 'BCPPCompiler',
-                               "Borland C++ Compiler"),
-                 }
-
-def show_compilers():
-    """Print list of available compilers (used by the "--help-compiler"
-    options to "build", "build_ext", "build_clib").
-    """
-    # XXX this "knows" that the compiler option it's describing is
-    # "--compiler", which just happens to be the case for the three
-    # commands that use it.
-    from distutils.fancy_getopt import FancyGetopt
-    compilers = []
-    for compiler in compiler_class.keys():
-        compilers.append(("compiler="+compiler, None,
-                          compiler_class[compiler][2]))
-    compilers.sort()
-    pretty_printer = FancyGetopt(compilers)
-    pretty_printer.print_help("List of available compilers:")
-
-
-def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
-    """Generate an instance of some CCompiler subclass for the supplied
-    platform/compiler combination.  'plat' defaults to 'os.name'
-    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
-    for that platform.  Currently only 'posix' and 'nt' are supported, and
-    the default compilers are "traditional Unix interface" (UnixCCompiler
-    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
-    possible to ask for a Unix compiler object under Windows, and a
-    Microsoft compiler object under Unix -- if you supply a value for
-    'compiler', 'plat' is ignored.
-    """
-    if plat is None:
-        plat = os.name
-
-    try:
-        if compiler is None:
-            compiler = get_default_compiler(plat)
-
-        (module_name, class_name, long_description) = compiler_class[compiler]
-    except KeyError:
-        msg = "don't know how to compile C/C++ code on platform '%s'" % plat
-        if compiler is not None:
-            msg = msg + " with '%s' compiler" % compiler
-        raise DistutilsPlatformError(msg)
-
-    try:
-        module_name = "distutils." + module_name
-        __import__ (module_name)
-        module = sys.modules[module_name]
-        klass = vars(module)[class_name]
-    except ImportError:
-        raise DistutilsModuleError(
-              "can't compile C/C++ code: unable to load module '%s'" % \
-              module_name)
-    except KeyError:
-        raise DistutilsModuleError(
-               "can't compile C/C++ code: unable to find class '%s' "
-               "in module '%s'" % (class_name, module_name))
-
-    # XXX The None is necessary to preserve backwards compatibility
-    # with classes that expect verbose to be the first positional
-    # argument.
-    return klass(None, dry_run, force)
-
-
-def gen_preprocess_options(macros, include_dirs):
-    """Generate C pre-processor options (-D, -U, -I) as used by at least
-    two types of compilers: the typical Unix compiler and Visual C++.
-    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
-    means undefine (-U) macro 'name', and (name,value) means define (-D)
-    macro 'name' to 'value'.  'include_dirs' is just a list of directory
-    names to be added to the header file search path (-I).  Returns a list
-    of command-line options suitable for either Unix compilers or Visual
-    C++.
-    """
-    # XXX it would be nice (mainly aesthetic, and so we don't generate
-    # stupid-looking command lines) to go over 'macros' and eliminate
-    # redundant definitions/undefinitions (ie. ensure that only the
-    # latest mention of a particular macro winds up on the command
-    # line).  I don't think it's essential, though, since most (all?)
-    # Unix C compilers only pay attention to the latest -D or -U
-    # mention of a macro on their command line.  Similar situation for
-    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
-    # redundancies like this should probably be the province of
-    # CCompiler, since the data structures used are inherited from it
-    # and therefore common to all CCompiler classes.
-    pp_opts = []
-    for macro in macros:
-        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
-            raise TypeError(
-                  "bad macro definition '%s': "
-                  "each element of 'macros' list must be a 1- or 2-tuple"
-                  % macro)
-
-        if len(macro) == 1:        # undefine this macro
-            pp_opts.append("-U%s" % macro[0])
-        elif len(macro) == 2:
-            if macro[1] is None:    # define with no explicit value
-                pp_opts.append("-D%s" % macro[0])
-            else:
-                # XXX *don't* need to be clever about quoting the
-                # macro value here, because we're going to avoid the
-                # shell at all costs when we spawn the command!
-                pp_opts.append("-D%s=%s" % macro)
-
-    for dir in include_dirs:
-        pp_opts.append("-I%s" % dir)
-    return pp_opts
-
-
-def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
-    """Generate linker options for searching library directories and
-    linking with specific libraries.  'libraries' and 'library_dirs' are,
-    respectively, lists of library names (not filenames!) and search
-    directories.  Returns a list of command-line options suitable for use
-    with some compiler (depending on the two format strings passed in).
-    """
-    lib_opts = []
-
-    for dir in library_dirs:
-        lib_opts.append(compiler.library_dir_option(dir))
-
-    for dir in runtime_library_dirs:
-        opt = compiler.runtime_library_dir_option(dir)
-        if isinstance(opt, list):
-            lib_opts = lib_opts + opt
-        else:
-            lib_opts.append(opt)
-
-    # XXX it's important that we *not* remove redundant library mentions!
-    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
-    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
-    # -lbar" to get things to work -- that's certainly a possibility, but a
-    # pretty nasty way to arrange your C code.
-
-    for lib in libraries:
-        (lib_dir, lib_name) = os.path.split(lib)
-        if lib_dir:
-            lib_file = compiler.find_library_file([lib_dir], lib_name)
-            if lib_file:
-                lib_opts.append(lib_file)
-            else:
-                compiler.warn("no library file corresponding to "
-                              "'%s' found (skipping)" % lib)
-        else:
-            lib_opts.append(compiler.library_option (lib))
-    return lib_opts
diff --git a/Lib/distutils/cmd.py b/Lib/distutils/cmd.py
deleted file mode 100644
index 939f7959457..00000000000
--- a/Lib/distutils/cmd.py
+++ /dev/null
@@ -1,434 +0,0 @@
-"""distutils.cmd
-
-Provides the Command class, the base class for the command classes
-in the distutils.command package.
-"""
-
-import sys, os, re
-from distutils.errors import DistutilsOptionError
-from distutils import util, dir_util, file_util, archive_util, dep_util
-from distutils import log
-
-class Command:
-    """Abstract base class for defining command classes, the "worker bees"
-    of the Distutils.  A useful analogy for command classes is to think of
-    them as subroutines with local variables called "options".  The options
-    are "declared" in 'initialize_options()' and "defined" (given their
-    final values, aka "finalized") in 'finalize_options()', both of which
-    must be defined by every command class.  The distinction between the
-    two is necessary because option values might come from the outside
-    world (command line, config file, ...), and any options dependent on
-    other options must be computed *after* these outside influences have
-    been processed -- hence 'finalize_options()'.  The "body" of the
-    subroutine, where it does all its work based on the values of its
-    options, is the 'run()' method, which must also be implemented by every
-    command class.
-    """
-
-    # 'sub_commands' formalizes the notion of a "family" of commands,
-    # eg. "install" as the parent with sub-commands "install_lib",
-    # "install_headers", etc.  The parent of a family of commands
-    # defines 'sub_commands' as a class attribute; it's a list of
-    #    (command_name : string, predicate : unbound_method | string | None)
-    # tuples, where 'predicate' is a method of the parent command that
-    # determines whether the corresponding command is applicable in the
-    # current situation.  (Eg. we "install_headers" is only applicable if
-    # we have any C header files to install.)  If 'predicate' is None,
-    # that command is always applicable.
-    #
-    # 'sub_commands' is usually defined at the *end* of a class, because
-    # predicates can be unbound methods, so they must already have been
-    # defined.  The canonical example is the "install" command.
-    sub_commands = []
-
-
-    # -- Creation/initialization methods -------------------------------
-
-    def __init__(self, dist):
-        """Create and initialize a new Command object.  Most importantly,
-        invokes the 'initialize_options()' method, which is the real
-        initializer and depends on the actual command being
-        instantiated.
-        """
-        # late import because of mutual dependence between these classes
-        from distutils.dist import Distribution
-
-        if not isinstance(dist, Distribution):
-            raise TypeError("dist must be a Distribution instance")
-        if self.__class__ is Command:
-            raise RuntimeError("Command is an abstract class")
-
-        self.distribution = dist
-        self.initialize_options()
-
-        # Per-command versions of the global flags, so that the user can
-        # customize Distutils' behaviour command-by-command and let some
-        # commands fall back on the Distribution's behaviour.  None means
-        # "not defined, check self.distribution's copy", while 0 or 1 mean
-        # false and true (duh).  Note that this means figuring out the real
-        # value of each flag is a touch complicated -- hence "self._dry_run"
-        # will be handled by __getattr__, below.
-        # XXX This needs to be fixed.
-        self._dry_run = None
-
-        # verbose is largely ignored, but needs to be set for
-        # backwards compatibility (I think)?
-        self.verbose = dist.verbose
-
-        # Some commands define a 'self.force' option to ignore file
-        # timestamps, but methods defined *here* assume that
-        # 'self.force' exists for all commands.  So define it here
-        # just to be safe.
-        self.force = None
-
-        # The 'help' flag is just used for command-line parsing, so
-        # none of that complicated bureaucracy is needed.
-        self.help = 0
-
-        # 'finalized' records whether or not 'finalize_options()' has been
-        # called.  'finalize_options()' itself should not pay attention to
-        # this flag: it is the business of 'ensure_finalized()', which
-        # always calls 'finalize_options()', to respect/update it.
-        self.finalized = 0
-
-    # XXX A more explicit way to customize dry_run would be better.
-    def __getattr__(self, attr):
-        if attr == 'dry_run':
-            myval = getattr(self, "_" + attr)
-            if myval is None:
-                return getattr(self.distribution, attr)
-            else:
-                return myval
-        else:
-            raise AttributeError(attr)
-
-    def ensure_finalized(self):
-        if not self.finalized:
-            self.finalize_options()
-        self.finalized = 1
-
-    # Subclasses must define:
-    #   initialize_options()
-    #     provide default values for all options; may be customized by
-    #     setup script, by options from config file(s), or by command-line
-    #     options
-    #   finalize_options()
-    #     decide on the final values for all options; this is called
-    #     after all possible intervention from the outside world
-    #     (command-line, option file, etc.) has been processed
-    #   run()
-    #     run the command: do whatever it is we're here to do,
-    #     controlled by the command's various option values
-
-    def initialize_options(self):
-        """Set default values for all the options that this command
-        supports.  Note that these defaults may be overridden by other
-        commands, by the setup script, by config files, or by the
-        command-line.  Thus, this is not the place to code dependencies
-        between options; generally, 'initialize_options()' implementations
-        are just a bunch of "self.foo = None" assignments.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-    def finalize_options(self):
-        """Set final values for all the options that this command supports.
-        This is always called as late as possible, ie.  after any option
-        assignments from the command-line or from other commands have been
-        done.  Thus, this is the place to code option dependencies: if
-        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
-        long as 'foo' still has the same value it was assigned in
-        'initialize_options()'.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-
-    def dump_options(self, header=None, indent=""):
-        from distutils.fancy_getopt import longopt_xlate
-        if header is None:
-            header = "command options for '%s':" % self.get_command_name()
-        self.announce(indent + header, level=log.INFO)
-        indent = indent + "  "
-        for (option, _, _) in self.user_options:
-            option = option.translate(longopt_xlate)
-            if option[-1] == "=":
-                option = option[:-1]
-            value = getattr(self, option)
-            self.announce(indent + "%s = %s" % (option, value),
-                          level=log.INFO)
-
-    def run(self):
-        """A command's raison d'etre: carry out the action it exists to
-        perform, controlled by the options initialized in
-        'initialize_options()', customized by other commands, the setup
-        script, the command-line, and config files, and finalized in
-        'finalize_options()'.  All terminal output and filesystem
-        interaction should be done by 'run()'.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-    def announce(self, msg, level=1):
-        """If the current verbosity level is of greater than or equal to
-        'level' print 'msg' to stdout.
-        """
-        log.log(level, msg)
-
-    def debug_print(self, msg):
-        """Print 'msg' to stdout if the global DEBUG (taken from the
-        DISTUTILS_DEBUG environment variable) flag is true.
-        """
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-            sys.stdout.flush()
-
-
-    # -- Option validation methods -------------------------------------
-    # (these are very handy in writing the 'finalize_options()' method)
-    #
-    # NB. the general philosophy here is to ensure that a particular option
-    # value meets certain type and value constraints.  If not, we try to
-    # force it into conformance (eg. if we expect a list but have a string,
-    # split the string on comma and/or whitespace).  If we can't force the
-    # option into conformance, raise DistutilsOptionError.  Thus, command
-    # classes need do nothing more than (eg.)
-    #   self.ensure_string_list('foo')
-    # and they can be guaranteed that thereafter, self.foo will be
-    # a list of strings.
-
-    def _ensure_stringlike(self, option, what, default=None):
-        val = getattr(self, option)
-        if val is None:
-            setattr(self, option, default)
-            return default
-        elif not isinstance(val, str):
-            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
-                                       % (option, what, val))
-        return val
-
-    def ensure_string(self, option, default=None):
-        """Ensure that 'option' is a string; if not defined, set it to
-        'default'.
-        """
-        self._ensure_stringlike(option, "string", default)
-
-    def ensure_string_list(self, option):
-        r"""Ensure that 'option' is a list of strings.  If 'option' is
-        currently a string, we split it either on /,\s*/ or /\s+/, so
-        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
-        ["foo", "bar", "baz"].
-        """
-        val = getattr(self, option)
-        if val is None:
-            return
-        elif isinstance(val, str):
-            setattr(self, option, re.split(r',\s*|\s+', val))
-        else:
-            if isinstance(val, list):
-                ok = all(isinstance(v, str) for v in val)
-            else:
-                ok = False
-            if not ok:
-                raise DistutilsOptionError(
-                      "'%s' must be a list of strings (got %r)"
-                      % (option, val))
-
-    def _ensure_tested_string(self, option, tester, what, error_fmt,
-                              default=None):
-        val = self._ensure_stringlike(option, what, default)
-        if val is not None and not tester(val):
-            raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
-                                       % (option, val))
-
-    def ensure_filename(self, option):
-        """Ensure that 'option' is the name of an existing file."""
-        self._ensure_tested_string(option, os.path.isfile,
-                                   "filename",
-                                   "'%s' does not exist or is not a file")
-
-    def ensure_dirname(self, option):
-        self._ensure_tested_string(option, os.path.isdir,
-                                   "directory name",
-                                   "'%s' does not exist or is not a directory")
-
-
-    # -- Convenience methods for commands ------------------------------
-
-    def get_command_name(self):
-        if hasattr(self, 'command_name'):
-            return self.command_name
-        else:
-            return self.__class__.__name__
-
-    def set_undefined_options(self, src_cmd, *option_pairs):
-        """Set the values of any "undefined" options from corresponding
-        option values in some other command object.  "Undefined" here means
-        "is None", which is the convention used to indicate that an option
-        has not been changed between 'initialize_options()' and
-        'finalize_options()'.  Usually called from 'finalize_options()' for
-        options that depend on some other command rather than another
-        option of the same command.  'src_cmd' is the other command from
-        which option values will be taken (a command object will be created
-        for it if necessary); the remaining arguments are
-        '(src_option,dst_option)' tuples which mean "take the value of
-        'src_option' in the 'src_cmd' command object, and copy it to
-        'dst_option' in the current command object".
-        """
-        # Option_pairs: list of (src_option, dst_option) tuples
-        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
-        src_cmd_obj.ensure_finalized()
-        for (src_option, dst_option) in option_pairs:
-            if getattr(self, dst_option) is None:
-                setattr(self, dst_option, getattr(src_cmd_obj, src_option))
-
-    def get_finalized_command(self, command, create=1):
-        """Wrapper around Distribution's 'get_command_obj()' method: find
-        (create if necessary and 'create' is true) the command object for
-        'command', call its 'ensure_finalized()' method, and return the
-        finalized command object.
-        """
-        cmd_obj = self.distribution.get_command_obj(command, create)
-        cmd_obj.ensure_finalized()
-        return cmd_obj
-
-    # XXX rename to 'get_reinitialized_command()'? (should do the
-    # same in dist.py, if so)
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        return self.distribution.reinitialize_command(command,
-                                                      reinit_subcommands)
-
-    def run_command(self, command):
-        """Run some other command: uses the 'run_command()' method of
-        Distribution, which creates and finalizes the command object if
-        necessary and then invokes its 'run()' method.
-        """
-        self.distribution.run_command(command)
-
-    def get_sub_commands(self):
-        """Determine the sub-commands that are relevant in the current
-        distribution (ie., that need to be run).  This is based on the
-        'sub_commands' class attribute: each tuple in that list may include
-        a method that we call to determine if the subcommand needs to be
-        run for the current distribution.  Return a list of command names.
-        """
-        commands = []
-        for (cmd_name, method) in self.sub_commands:
-            if method is None or method(self):
-                commands.append(cmd_name)
-        return commands
-
-
-    # -- External world manipulation -----------------------------------
-
-    def warn(self, msg):
-        log.warn("warning: %s: %s\n", self.get_command_name(), msg)
-
-    def execute(self, func, args, msg=None, level=1):
-        util.execute(func, args, msg, dry_run=self.dry_run)
-
-    def mkpath(self, name, mode=0o777):
-        dir_util.mkpath(name, mode, dry_run=self.dry_run)
-
-    def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
-                  link=None, level=1):
-        """Copy a file respecting verbose, dry-run and force flags.  (The
-        former two default to whatever is in the Distribution object, and
-        the latter defaults to false for commands that don't define it.)"""
-        return file_util.copy_file(infile, outfile, preserve_mode,
-                                   preserve_times, not self.force, link,
-                                   dry_run=self.dry_run)
-
-    def copy_tree(self, infile, outfile, preserve_mode=1, preserve_times=1,
-                   preserve_symlinks=0, level=1):
-        """Copy an entire directory tree respecting verbose, dry-run,
-        and force flags.
-        """
-        return dir_util.copy_tree(infile, outfile, preserve_mode,
-                                  preserve_times, preserve_symlinks,
-                                  not self.force, dry_run=self.dry_run)
-
-    def move_file (self, src, dst, level=1):
-        """Move a file respecting dry-run flag."""
-        return file_util.move_file(src, dst, dry_run=self.dry_run)
-
-    def spawn(self, cmd, search_path=1, level=1):
-        """Spawn an external command respecting dry-run flag."""
-        from distutils.spawn import spawn
-        spawn(cmd, search_path, dry_run=self.dry_run)
-
-    def make_archive(self, base_name, format, root_dir=None, base_dir=None,
-                     owner=None, group=None):
-        return archive_util.make_archive(base_name, format, root_dir, base_dir,
-                                         dry_run=self.dry_run,
-                                         owner=owner, group=group)
-
-    def make_file(self, infiles, outfile, func, args,
-                  exec_msg=None, skip_msg=None, level=1):
-        """Special case of 'execute()' for operations that process one or
-        more input files and generate one output file.  Works just like
-        'execute()', except the operation is skipped and a different
-        message printed if 'outfile' already exists and is newer than all
-        files listed in 'infiles'.  If the command defined 'self.force',
-        and it is true, then the command is unconditionally run -- does no
-        timestamp checks.
-        """
-        if skip_msg is None:
-            skip_msg = "skipping %s (inputs unchanged)" % outfile
-
-        # Allow 'infiles' to be a single string
-        if isinstance(infiles, str):
-            infiles = (infiles,)
-        elif not isinstance(infiles, (list, tuple)):
-            raise TypeError(
-                  "'infiles' must be a string, or a list or tuple of strings")
-
-        if exec_msg is None:
-            exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
-
-        # If 'outfile' must be regenerated (either because it doesn't
-        # exist, is out-of-date, or the 'force' flag is true) then
-        # perform the action that presumably regenerates it
-        if self.force or dep_util.newer_group(infiles, outfile):
-            self.execute(func, args, exec_msg, level)
-        # Otherwise, print the "skip" message
-        else:
-            log.debug(skip_msg)
-
-# XXX 'install_misc' class not currently used -- it was the base class for
-# both 'install_scripts' and 'install_data', but they outgrew it.  It might
-# still be useful for 'install_headers', though, so I'm keeping it around
-# for the time being.
-
-class install_misc(Command):
-    """Common base class for installing some files in a subdirectory.
-    Currently used by install_data and install_scripts.
-    """
-
-    user_options = [('install-dir=', 'd', "directory to install the files to")]
-
-    def initialize_options (self):
-        self.install_dir = None
-        self.outfiles = []
-
-    def _install_dir_from(self, dirname):
-        self.set_undefined_options('install', (dirname, 'install_dir'))
-
-    def _copy_files(self, filelist):
-        self.outfiles = []
-        if not filelist:
-            return
-        self.mkpath(self.install_dir)
-        for f in filelist:
-            self.copy_file(f, self.install_dir)
-            self.outfiles.append(os.path.join(self.install_dir, f))
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/__init__.py b/Lib/distutils/command/__init__.py
deleted file mode 100644
index 481eea9fd4b..00000000000
--- a/Lib/distutils/command/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-"""distutils.command
-
-Package containing implementation of all the standard Distutils
-commands."""
-
-__all__ = ['build',
-           'build_py',
-           'build_ext',
-           'build_clib',
-           'build_scripts',
-           'clean',
-           'install',
-           'install_lib',
-           'install_headers',
-           'install_scripts',
-           'install_data',
-           'sdist',
-           'register',
-           'bdist',
-           'bdist_dumb',
-           'bdist_rpm',
-           'bdist_wininst',
-           'check',
-           'upload',
-           # These two are reserved for future use:
-           #'bdist_sdux',
-           #'bdist_pkgtool',
-           # Note:
-           # bdist_packager is not included because it only provides
-           # an abstract base class
-          ]
diff --git a/Lib/distutils/command/bdist.py b/Lib/distutils/command/bdist.py
deleted file mode 100644
index 014871d280e..00000000000
--- a/Lib/distutils/command/bdist.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""distutils.command.bdist
-
-Implements the Distutils 'bdist' command (create a built [binary]
-distribution)."""
-
-import os
-from distutils.core import Command
-from distutils.errors import *
-from distutils.util import get_platform
-
-
-def show_formats():
-    """Print list of available formats (arguments to "--format" option).
-    """
-    from distutils.fancy_getopt import FancyGetopt
-    formats = []
-    for format in bdist.format_commands:
-        formats.append(("formats=" + format, None,
-                        bdist.format_command[format][1]))
-    pretty_printer = FancyGetopt(formats)
-    pretty_printer.print_help("List of available distribution formats:")
-
-
-class bdist(Command):
-
-    description = "create a built (binary) distribution"
-
-    user_options = [('bdist-base=', 'b',
-                     "temporary directory for creating built distributions"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('formats=', None,
-                     "formats for distribution (comma-separated list)"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in "
-                     "[default: dist]"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('owner=', 'u',
-                     "Owner name used when creating a tar file"
-                     " [default: current user]"),
-                    ('group=', 'g',
-                     "Group name used when creating a tar file"
-                     " [default: current group]"),
-                   ]
-
-    boolean_options = ['skip-build']
-
-    help_options = [
-        ('help-formats', None,
-         "lists available distribution formats", show_formats),
-        ]
-
-    # The following commands do not take a format option from bdist
-    no_format_option = ('bdist_rpm',)
-
-    # This won't do in reality: will need to distinguish RPM-ish Linux,
-    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
-    default_format = {'posix': 'gztar',
-                      'nt': 'zip'}
-
-    # Establish the preferred order (for the --help-formats option).
-    format_commands = ['rpm', 'gztar', 'bztar', 'xztar', 'ztar', 'tar',
-                       'wininst', 'zip', 'msi']
-
-    # And the real information.
-    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
-                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
-                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
-                      'xztar': ('bdist_dumb', "xz'ed tar file"),
-                      'ztar':  ('bdist_dumb', "compressed tar file"),
-                      'tar':   ('bdist_dumb', "tar file"),
-                      'wininst': ('bdist_wininst',
-                                  "Windows executable installer"),
-                      'zip':   ('bdist_dumb', "ZIP file"),
-                      'msi':   ('bdist_msi',  "Microsoft Installer")
-                      }
-
-
-    def initialize_options(self):
-        self.bdist_base = None
-        self.plat_name = None
-        self.formats = None
-        self.dist_dir = None
-        self.skip_build = 0
-        self.group = None
-        self.owner = None
-
-    def finalize_options(self):
-        # have to finalize 'plat_name' before 'bdist_base'
-        if self.plat_name is None:
-            if self.skip_build:
-                self.plat_name = get_platform()
-            else:
-                self.plat_name = self.get_finalized_command('build').plat_name
-
-        # 'bdist_base' -- parent of per-built-distribution-format
-        # temporary directories (eg. we'll probably have
-        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
-        if self.bdist_base is None:
-            build_base = self.get_finalized_command('build').build_base
-            self.bdist_base = os.path.join(build_base,
-                                           'bdist.' + self.plat_name)
-
-        self.ensure_string_list('formats')
-        if self.formats is None:
-            try:
-                self.formats = [self.default_format[os.name]]
-            except KeyError:
-                raise DistutilsPlatformError(
-                      "don't know how to create built distributions "
-                      "on platform %s" % os.name)
-
-        if self.dist_dir is None:
-            self.dist_dir = "dist"
-
-    def run(self):
-        # Figure out which sub-commands we need to run.
-        commands = []
-        for format in self.formats:
-            try:
-                commands.append(self.format_command[format][0])
-            except KeyError:
-                raise DistutilsOptionError("invalid format '%s'" % format)
-
-        # Reinitialize and run each command.
-        for i in range(len(self.formats)):
-            cmd_name = commands[i]
-            sub_cmd = self.reinitialize_command(cmd_name)
-            if cmd_name not in self.no_format_option:
-                sub_cmd.format = self.formats[i]
-
-            # passing the owner and group names for tar archiving
-            if cmd_name == 'bdist_dumb':
-                sub_cmd.owner = self.owner
-                sub_cmd.group = self.group
-
-            # If we're going to need to run this command again, tell it to
-            # keep its temporary files around so subsequent runs go faster.
-            if cmd_name in commands[i+1:]:
-                sub_cmd.keep_temp = 1
-            self.run_command(cmd_name)
diff --git a/Lib/distutils/command/bdist_dumb.py b/Lib/distutils/command/bdist_dumb.py
deleted file mode 100644
index f0d6b5b8cd8..00000000000
--- a/Lib/distutils/command/bdist_dumb.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""distutils.command.bdist_dumb
-
-Implements the Distutils 'bdist_dumb' command (create a "dumb" built
-distribution -- i.e., just an archive to be unpacked under $prefix or
-$exec_prefix)."""
-
-import os
-from distutils.core import Command
-from distutils.util import get_platform
-from distutils.dir_util import remove_tree, ensure_relative
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_dumb(Command):
-
-    description = "create a \"dumb\" built distribution"
-
-    user_options = [('bdist-dir=', 'd',
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('format=', 'f',
-                     "archive format to create (tar, gztar, bztar, xztar, "
-                     "ztar, zip)"),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('relative', None,
-                     "build the archive using relative paths "
-                     "(default: false)"),
-                    ('owner=', 'u',
-                     "Owner name used when creating a tar file"
-                     " [default: current user]"),
-                    ('group=', 'g',
-                     "Group name used when creating a tar file"
-                     " [default: current group]"),
-                   ]
-
-    boolean_options = ['keep-temp', 'skip-build', 'relative']
-
-    default_format = { 'posix': 'gztar',
-                       'nt': 'zip' }
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.format = None
-        self.keep_temp = 0
-        self.dist_dir = None
-        self.skip_build = None
-        self.relative = 0
-        self.owner = None
-        self.group = None
-
-    def finalize_options(self):
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'dumb')
-
-        if self.format is None:
-            try:
-                self.format = self.default_format[os.name]
-            except KeyError:
-                raise DistutilsPlatformError(
-                       "don't know how to create dumb built distributions "
-                       "on platform %s" % os.name)
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                   ('skip_build', 'skip_build'))
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.root = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-
-        log.info("installing to %s", self.bdist_dir)
-        self.run_command('install')
-
-        # And make an archive relative to the root of the
-        # pseudo-installation tree.
-        archive_basename = "%s.%s" % (self.distribution.get_fullname(),
-                                      self.plat_name)
-
-        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
-        if not self.relative:
-            archive_root = self.bdist_dir
-        else:
-            if (self.distribution.has_ext_modules() and
-                (install.install_base != install.install_platbase)):
-                raise DistutilsPlatformError(
-                       "can't make a dumb built distribution where "
-                       "base and platbase are different (%s, %s)"
-                       % (repr(install.install_base),
-                          repr(install.install_platbase)))
-            else:
-                archive_root = os.path.join(self.bdist_dir,
-                                   ensure_relative(install.install_base))
-
-        # Make the archive
-        filename = self.make_archive(pseudoinstall_root,
-                                     self.format, root_dir=archive_root,
-                                     owner=self.owner, group=self.group)
-        if self.distribution.has_ext_modules():
-            pyversion = get_python_version()
-        else:
-            pyversion = 'any'
-        self.distribution.dist_files.append(('bdist_dumb', pyversion,
-                                             filename))
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
diff --git a/Lib/distutils/command/bdist_msi.py b/Lib/distutils/command/bdist_msi.py
deleted file mode 100644
index 80104c372d9..00000000000
--- a/Lib/distutils/command/bdist_msi.py
+++ /dev/null
@@ -1,741 +0,0 @@
-# Copyright (C) 2005, 2006 Martin von Löwis
-# Licensed to PSF under a Contributor Agreement.
-# The bdist_wininst command proper
-# based on bdist_wininst
-"""
-Implements the bdist_msi command.
-"""
-
-import sys, os
-from distutils.core import Command
-from distutils.dir_util import remove_tree
-from distutils.sysconfig import get_python_version
-from distutils.version import StrictVersion
-from distutils.errors import DistutilsOptionError
-from distutils.util import get_platform
-from distutils import log
-import msilib
-from msilib import schema, sequence, text
-from msilib import Directory, Feature, Dialog, add_data
-
-class PyDialog(Dialog):
-    """Dialog class with a fixed layout: controls at the top, then a ruler,
-    then a list of buttons: back, next, cancel. Optionally a bitmap at the
-    left."""
-    def __init__(self, *args, **kw):
-        """Dialog(database, name, x, y, w, h, attributes, title, first,
-        default, cancel, bitmap=true)"""
-        Dialog.__init__(self, *args)
-        ruler = self.h - 36
-        bmwidth = 152*ruler/328
-        #if kw.get("bitmap", True):
-        #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
-        self.line("BottomLine", 0, ruler, self.w, 0)
-
-    def title(self, title):
-        "Set the title text of the dialog at the top."
-        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
-        # text, in VerdanaBold10
-        self.text("Title", 15, 10, 320, 60, 0x30003,
-                  r"{\VerdanaBold10}%s" % title)
-
-    def back(self, title, next, name = "Back", active = 1):
-        """Add a back button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)
-
-    def cancel(self, title, next, name = "Cancel", active = 1):
-        """Add a cancel button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)
-
-    def next(self, title, next, name = "Next", active = 1):
-        """Add a Next button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)
-
-    def xbutton(self, name, title, next, xpos):
-        """Add a button with a given title, the tab-next button,
-        its name in the Control table, giving its x position; the
-        y-position is aligned with the other buttons.
-
-        Return the button, so that events can be associated"""
-        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)
-
-class bdist_msi(Command):
-
-    description = "create a Microsoft Installer (.msi) binary distribution"
-
-    user_options = [('bdist-dir=', None,
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('target-version=', None,
-                     "require a specific python version" +
-                     " on the target system"),
-                    ('no-target-compile', 'c',
-                     "do not compile .py to .pyc on the target system"),
-                    ('no-target-optimize', 'o',
-                     "do not compile .py to .pyo (optimized) "
-                     "on the target system"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('install-script=', None,
-                     "basename of installation script to be run after "
-                     "installation or before deinstallation"),
-                    ('pre-install-script=', None,
-                     "Fully qualified filename of a script to be run before "
-                     "any files are installed.  This script need not be in the "
-                     "distribution"),
-                   ]
-
-    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
-                       'skip-build']
-
-    all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
-                    '2.5', '2.6', '2.7', '2.8', '2.9',
-                    '3.0', '3.1', '3.2', '3.3', '3.4',
-                    '3.5', '3.6', '3.7', '3.8', '3.9']
-    other_version = 'X'
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.no_target_compile = 0
-        self.no_target_optimize = 0
-        self.target_version = None
-        self.dist_dir = None
-        self.skip_build = None
-        self.install_script = None
-        self.pre_install_script = None
-        self.versions = None
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
-
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'msi')
-
-        short_version = get_python_version()
-        if (not self.target_version) and self.distribution.has_ext_modules():
-            self.target_version = short_version
-
-        if self.target_version:
-            self.versions = [self.target_version]
-            if not self.skip_build and self.distribution.has_ext_modules()\
-               and self.target_version != short_version:
-                raise DistutilsOptionError(
-                      "target version can only be %s, or the '--skip-build'"
-                      " option must be specified" % (short_version,))
-        else:
-            self.versions = list(self.all_versions)
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                   )
-
-        if self.pre_install_script:
-            raise DistutilsOptionError(
-                  "the pre-install-script feature is not yet implemented")
-
-        if self.install_script:
-            for script in self.distribution.scripts:
-                if self.install_script == os.path.basename(script):
-                    break
-            else:
-                raise DistutilsOptionError(
-                      "install_script '%s' not found in scripts"
-                      % self.install_script)
-        self.install_script_key = None
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.prefix = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-
-        install_lib = self.reinitialize_command('install_lib')
-        # we do not want to include pyc or pyo files
-        install_lib.compile = 0
-        install_lib.optimize = 0
-
-        if self.distribution.has_ext_modules():
-            # If we are building an installer for a Python version other
-            # than the one we are currently running, then we need to ensure
-            # our build_lib reflects the other Python version rather than ours.
-            # Note that for target_version!=sys.version, we must have skipped the
-            # build step, so there is no issue with enforcing the build of this
-            # version.
-            target_version = self.target_version
-            if not target_version:
-                assert self.skip_build, "Should have already checked this"
-                target_version = '%d.%d' % sys.version_info[:2]
-            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
-            build = self.get_finalized_command('build')
-            build.build_lib = os.path.join(build.build_base,
-                                           'lib' + plat_specifier)
-
-        log.info("installing to %s", self.bdist_dir)
-        install.ensure_finalized()
-
-        # avoid warning of 'install_lib' about installing
-        # into a directory not in sys.path
-        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
-
-        install.run()
-
-        del sys.path[0]
-
-        self.mkpath(self.dist_dir)
-        fullname = self.distribution.get_fullname()
-        installer_name = self.get_installer_filename(fullname)
-        installer_name = os.path.abspath(installer_name)
-        if os.path.exists(installer_name): os.unlink(installer_name)
-
-        metadata = self.distribution.metadata
-        author = metadata.author
-        if not author:
-            author = metadata.maintainer
-        if not author:
-            author = "UNKNOWN"
-        version = metadata.get_version()
-        # ProductVersion must be strictly numeric
-        # XXX need to deal with prerelease versions
-        sversion = "%d.%d.%d" % StrictVersion(version).version
-        # Prefix ProductName with Python x.y, so that
-        # it sorts together with the other Python packages
-        # in Add-Remove-Programs (APR)
-        fullname = self.distribution.get_fullname()
-        if self.target_version:
-            product_name = "Python %s %s" % (self.target_version, fullname)
-        else:
-            product_name = "Python %s" % (fullname)
-        self.db = msilib.init_database(installer_name, schema,
-                product_name, msilib.gen_uuid(),
-                sversion, author)
-        msilib.add_tables(self.db, sequence)
-        props = [('DistVersion', version)]
-        email = metadata.author_email or metadata.maintainer_email
-        if email:
-            props.append(("ARPCONTACT", email))
-        if metadata.url:
-            props.append(("ARPURLINFOABOUT", metadata.url))
-        if props:
-            add_data(self.db, 'Property', props)
-
-        self.add_find_python()
-        self.add_files()
-        self.add_scripts()
-        self.add_ui()
-        self.db.Commit()
-
-        if hasattr(self.distribution, 'dist_files'):
-            tup = 'bdist_msi', self.target_version or 'any', fullname
-            self.distribution.dist_files.append(tup)
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-    def add_files(self):
-        db = self.db
-        cab = msilib.CAB("distfiles")
-        rootdir = os.path.abspath(self.bdist_dir)
-
-        root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
-        f = Feature(db, "Python", "Python", "Everything",
-                    0, 1, directory="TARGETDIR")
-
-        items = [(f, root, '')]
-        for version in self.versions + [self.other_version]:
-            target = "TARGETDIR" + version
-            name = default = "Python" + version
-            desc = "Everything"
-            if version is self.other_version:
-                title = "Python from another location"
-                level = 2
-            else:
-                title = "Python %s from registry" % version
-                level = 1
-            f = Feature(db, name, title, desc, 1, level, directory=target)
-            dir = Directory(db, cab, root, rootdir, target, default)
-            items.append((f, dir, version))
-        db.Commit()
-
-        seen = {}
-        for feature, dir, version in items:
-            todo = [dir]
-            while todo:
-                dir = todo.pop()
-                for file in os.listdir(dir.absolute):
-                    afile = os.path.join(dir.absolute, file)
-                    if os.path.isdir(afile):
-                        short = "%s|%s" % (dir.make_short(file), file)
-                        default = file + version
-                        newdir = Directory(db, cab, dir, file, default, short)
-                        todo.append(newdir)
-                    else:
-                        if not dir.component:
-                            dir.start_component(dir.logical, feature, 0)
-                        if afile not in seen:
-                            key = seen[afile] = dir.add_file(file)
-                            if file==self.install_script:
-                                if self.install_script_key:
-                                    raise DistutilsOptionError(
-                                          "Multiple files with name %s" % file)
-                                self.install_script_key = '[#%s]' % key
-                        else:
-                            key = seen[afile]
-                            add_data(self.db, "DuplicateFile",
-                                [(key + version, dir.component, key, None, dir.logical)])
-            db.Commit()
-        cab.commit(db)
-
-    def add_find_python(self):
-        """Adds code to the installer to compute the location of Python.
-
-        Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
-        registry for each version of Python.
-
-        Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
-        else from PYTHON.MACHINE.X.Y.
-
-        Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""
-
-        start = 402
-        for ver in self.versions:
-            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
-            machine_reg = "python.machine." + ver
-            user_reg = "python.user." + ver
-            machine_prop = "PYTHON.MACHINE." + ver
-            user_prop = "PYTHON.USER." + ver
-            machine_action = "PythonFromMachine" + ver
-            user_action = "PythonFromUser" + ver
-            exe_action = "PythonExe" + ver
-            target_dir_prop = "TARGETDIR" + ver
-            exe_prop = "PYTHON" + ver
-            if msilib.Win64:
-                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
-                Type = 2+16
-            else:
-                Type = 2
-            add_data(self.db, "RegLocator",
-                    [(machine_reg, 2, install_path, None, Type),
-                     (user_reg, 1, install_path, None, Type)])
-            add_data(self.db, "AppSearch",
-                    [(machine_prop, machine_reg),
-                     (user_prop, user_reg)])
-            add_data(self.db, "CustomAction",
-                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
-                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
-                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
-                    ])
-            add_data(self.db, "InstallExecuteSequence",
-                    [(machine_action, machine_prop, start),
-                     (user_action, user_prop, start + 1),
-                     (exe_action, None, start + 2),
-                    ])
-            add_data(self.db, "InstallUISequence",
-                    [(machine_action, machine_prop, start),
-                     (user_action, user_prop, start + 1),
-                     (exe_action, None, start + 2),
-                    ])
-            add_data(self.db, "Condition",
-                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
-            start += 4
-            assert start < 500
-
-    def add_scripts(self):
-        if self.install_script:
-            start = 6800
-            for ver in self.versions + [self.other_version]:
-                install_action = "install_script." + ver
-                exe_prop = "PYTHON" + ver
-                add_data(self.db, "CustomAction",
-                        [(install_action, 50, exe_prop, self.install_script_key)])
-                add_data(self.db, "InstallExecuteSequence",
-                        [(install_action, "&Python%s=3" % ver, start)])
-                start += 1
-        # XXX pre-install scripts are currently refused in finalize_options()
-        #     but if this feature is completed, it will also need to add
-        #     entries for each version as the above code does
-        if self.pre_install_script:
-            scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
-            f = open(scriptfn, "w")
-            # The batch file will be executed with [PYTHON], so that %1
-            # is the path to the Python interpreter; %0 will be the path
-            # of the batch file.
-            # rem ="""
-            # %1 %0
-            # exit
-            # """
-            # <actual script>
-            f.write('rem ="""\n%1 %0\nexit\n"""\n')
-            f.write(open(self.pre_install_script).read())
-            f.close()
-            add_data(self.db, "Binary",
-                [("PreInstall", msilib.Binary(scriptfn))
-                ])
-            add_data(self.db, "CustomAction",
-                [("PreInstall", 2, "PreInstall", None)
-                ])
-            add_data(self.db, "InstallExecuteSequence",
-                    [("PreInstall", "NOT Installed", 450)])
-
-
-    def add_ui(self):
-        db = self.db
-        x = y = 50
-        w = 370
-        h = 300
-        title = "[ProductName] Setup"
-
-        # see "Dialog Style Bits"
-        modal = 3      # visible | modal
-        modeless = 1   # visible
-        track_disk_space = 32
-
-        # UI customization properties
-        add_data(db, "Property",
-                 # See "DefaultUIFont Property"
-                 [("DefaultUIFont", "DlgFont8"),
-                  # See "ErrorDialog Style Bit"
-                  ("ErrorDialog", "ErrorDlg"),
-                  ("Progress1", "Install"),   # modified in maintenance type dlg
-                  ("Progress2", "installs"),
-                  ("MaintenanceForm_Action", "Repair"),
-                  # possible values: ALL, JUSTME
-                  ("WhichUsers", "ALL")
-                 ])
-
-        # Fonts, see "TextStyle Table"
-        add_data(db, "TextStyle",
-                 [("DlgFont8", "Tahoma", 9, None, 0),
-                  ("DlgFontBold8", "Tahoma", 8, None, 1), #bold
-                  ("VerdanaBold10", "Verdana", 10, None, 1),
-                  ("VerdanaRed9", "Verdana", 9, 255, 0),
-                 ])
-
-        # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
-        # Numbers indicate sequence; see sequence.py for how these action integrate
-        add_data(db, "InstallUISequence",
-                 [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
-                  ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
-                  # In the user interface, assume all-users installation if privileged.
-                  ("SelectFeaturesDlg", "Not Installed", 1230),
-                  # XXX no support for resume installations yet
-                  #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
-                  ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
-                  ("ProgressDlg", None, 1280)])
-
-        add_data(db, 'ActionText', text.ActionText)
-        add_data(db, 'UIText', text.UIText)
-        #####################################################################
-        # Standard dialogs: FatalError, UserExit, ExitDialog
-        fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
-                     "Finish", "Finish", "Finish")
-        fatal.title("[ProductName] Installer ended prematurely")
-        fatal.back("< Back", "Finish", active = 0)
-        fatal.cancel("Cancel", "Back", active = 0)
-        fatal.text("Description1", 15, 70, 320, 80, 0x30003,
-                   "[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.")
-        fatal.text("Description2", 15, 155, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c=fatal.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Exit")
-
-        user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
-                     "Finish", "Finish", "Finish")
-        user_exit.title("[ProductName] Installer was interrupted")
-        user_exit.back("< Back", "Finish", active = 0)
-        user_exit.cancel("Cancel", "Back", active = 0)
-        user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
-                   "[ProductName] setup was interrupted.  Your system has not been modified.  "
-                   "To install this program at a later time, please run the installation again.")
-        user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c = user_exit.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Exit")
-
-        exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
-                             "Finish", "Finish", "Finish")
-        exit_dialog.title("Completing the [ProductName] Installer")
-        exit_dialog.back("< Back", "Finish", active = 0)
-        exit_dialog.cancel("Cancel", "Back", active = 0)
-        exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c = exit_dialog.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Return")
-
-        #####################################################################
-        # Required dialog: FilesInUse, ErrorDlg
-        inuse = PyDialog(db, "FilesInUse",
-                         x, y, w, h,
-                         19,                # KeepModeless|Modal|Visible
-                         title,
-                         "Retry", "Retry", "Retry", bitmap=False)
-        inuse.text("Title", 15, 6, 200, 15, 0x30003,
-                   r"{\DlgFontBold8}Files in Use")
-        inuse.text("Description", 20, 23, 280, 20, 0x30003,
-               "Some files that need to be updated are currently in use.")
-        inuse.text("Text", 20, 55, 330, 50, 3,
-                   "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
-        inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
-                      None, None, None)
-        c=inuse.back("Exit", "Ignore", name="Exit")
-        c.event("EndDialog", "Exit")
-        c=inuse.next("Ignore", "Retry", name="Ignore")
-        c.event("EndDialog", "Ignore")
-        c=inuse.cancel("Retry", "Exit", name="Retry")
-        c.event("EndDialog","Retry")
-
-        # See "Error Dialog". See "ICE20" for the required names of the controls.
-        error = Dialog(db, "ErrorDlg",
-                       50, 10, 330, 101,
-                       65543,       # Error|Minimize|Modal|Visible
-                       title,
-                       "ErrorText", None, None)
-        error.text("ErrorText", 50,9,280,48,3, "")
-        #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
-        error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
-        error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
-        error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
-        error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
-        error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
-        error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
-        error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")
-
-        #####################################################################
-        # Global "Query Cancel" dialog
-        cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
-                        "No", "No", "No")
-        cancel.text("Text", 48, 15, 194, 30, 3,
-                    "Are you sure you want to cancel [ProductName] installation?")
-        #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
-        #               "py.ico", None, None)
-        c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
-        c.event("EndDialog", "Exit")
-
-        c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
-        c.event("EndDialog", "Return")
-
-        #####################################################################
-        # Global "Wait for costing" dialog
-        costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
-                         "Return", "Return", "Return")
-        costing.text("Text", 48, 15, 194, 30, 3,
-                     "Please wait while the installer finishes determining your disk space requirements.")
-        c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
-        c.event("EndDialog", "Exit")
-
-        #####################################################################
-        # Preparation dialog: no user input except cancellation
-        prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
-                        "Cancel", "Cancel", "Cancel")
-        prep.text("Description", 15, 70, 320, 40, 0x30003,
-                  "Please wait while the Installer prepares to guide you through the installation.")
-        prep.title("Welcome to the [ProductName] Installer")
-        c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
-        c.mapping("ActionText", "Text")
-        c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
-        c.mapping("ActionData", "Text")
-        prep.back("Back", None, active=0)
-        prep.next("Next", None, active=0)
-        c=prep.cancel("Cancel", None)
-        c.event("SpawnDialog", "CancelDlg")
-
-        #####################################################################
-        # Feature (Python directory) selection
-        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
-                        "Next", "Next", "Cancel")
-        seldlg.title("Select Python Installations")
-
-        seldlg.text("Hint", 15, 30, 300, 20, 3,
-                    "Select the Python locations where %s should be installed."
-                    % self.distribution.get_fullname())
-
-        seldlg.back("< Back", None, active=0)
-        c = seldlg.next("Next >", "Cancel")
-        order = 1
-        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
-        for version in self.versions + [self.other_version]:
-            order += 1
-            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
-                    "FEATURE_SELECTED AND &Python%s=3" % version,
-                    ordering=order)
-        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
-        c.event("EndDialog", "Return", ordering=order + 2)
-        c = seldlg.cancel("Cancel", "Features")
-        c.event("SpawnDialog", "CancelDlg")
-
-        c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
-                           "FEATURE", None, "PathEdit", None)
-        c.event("[FEATURE_SELECTED]", "1")
-        ver = self.other_version
-        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
-        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver
-
-        c = seldlg.text("Other", 15, 200, 300, 15, 3,
-                        "Provide an alternate Python location")
-        c.condition("Enable", install_other_cond)
-        c.condition("Show", install_other_cond)
-        c.condition("Disable", dont_install_other_cond)
-        c.condition("Hide", dont_install_other_cond)
-
-        c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
-                           "TARGETDIR" + ver, None, "Next", None)
-        c.condition("Enable", install_other_cond)
-        c.condition("Show", install_other_cond)
-        c.condition("Disable", dont_install_other_cond)
-        c.condition("Hide", dont_install_other_cond)
-
-        #####################################################################
-        # Disk cost
-        cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
-                        "OK", "OK", "OK", bitmap=False)
-        cost.text("Title", 15, 6, 200, 15, 0x30003,
-                 r"{\DlgFontBold8}Disk Space Requirements")
-        cost.text("Description", 20, 20, 280, 20, 0x30003,
-                  "The disk space required for the installation of the selected features.")
-        cost.text("Text", 20, 53, 330, 60, 3,
-                  "The highlighted volumes (if any) do not have enough disk space "
-              "available for the currently selected features.  You can either "
-              "remove some files from the highlighted volumes, or choose to "
-              "install less features onto local drive(s), or select different "
-              "destination drive(s).")
-        cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
-                     None, "{120}{70}{70}{70}{70}", None, None)
-        cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")
-
-        #####################################################################
-        # WhichUsers Dialog. Only available on NT, and for privileged users.
-        # This must be run before FindRelatedProducts, because that will
-        # take into account whether the previous installation was per-user
-        # or per-machine. We currently don't support going back to this
-        # dialog after "Next" was selected; to support this, we would need to
-        # find how to reset the ALLUSERS property, and how to re-run
-        # FindRelatedProducts.
-        # On Windows9x, the ALLUSERS property is ignored on the command line
-        # and in the Property table, but installer fails according to the documentation
-        # if a dialog attempts to set ALLUSERS.
-        whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
-                            "AdminInstall", "Next", "Cancel")
-        whichusers.title("Select whether to install [ProductName] for all users of this computer.")
-        # A radio group with two options: allusers, justme
-        g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
-                                  "WhichUsers", "", "Next")
-        g.add("ALL", 0, 5, 150, 20, "Install for all users")
-        g.add("JUSTME", 0, 25, 150, 20, "Install just for me")
-
-        whichusers.back("Back", None, active=0)
-
-        c = whichusers.next("Next >", "Cancel")
-        c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
-        c.event("EndDialog", "Return", ordering = 2)
-
-        c = whichusers.cancel("Cancel", "AdminInstall")
-        c.event("SpawnDialog", "CancelDlg")
-
-        #####################################################################
-        # Installation Progress dialog (modeless)
-        progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
-                            "Cancel", "Cancel", "Cancel", bitmap=False)
-        progress.text("Title", 20, 15, 200, 15, 0x30003,
-                     r"{\DlgFontBold8}[Progress1] [ProductName]")
-        progress.text("Text", 35, 65, 300, 30, 3,
-                      "Please wait while the Installer [Progress2] [ProductName]. "
-                      "This may take several minutes.")
-        progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")
-
-        c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
-        c.mapping("ActionText", "Text")
-
-        #c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
-        #c.mapping("ActionData", "Text")
-
-        c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
-                           None, "Progress done", None, None)
-        c.mapping("SetProgress", "Progress")
-
-        progress.back("< Back", "Next", active=False)
-        progress.next("Next >", "Cancel", active=False)
-        progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")
-
-        ###################################################################
-        # Maintenance type: repair/uninstall
-        maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
-                         "Next", "Next", "Cancel")
-        maint.title("Welcome to the [ProductName] Setup Wizard")
-        maint.text("BodyText", 15, 63, 330, 42, 3,
-                   "Select whether you want to repair or remove [ProductName].")
-        g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
-                            "MaintenanceForm_Action", "", "Next")
-        #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
-        g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
-        g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")
-
-        maint.back("< Back", None, active=False)
-        c=maint.next("Finish", "Cancel")
-        # Change installation: Change progress dialog to "Change", then ask
-        # for feature selection
-        #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
-        #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)
-
-        # Reinstall: Change progress dialog to "Repair", then invoke reinstall
-        # Also set list of reinstalled features to "ALL"
-        c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
-        c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
-        c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
-        c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)
-
-        # Uninstall: Change progress to "Remove", then invoke uninstall
-        # Also set list of removed features to "ALL"
-        c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
-        c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
-        c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
-        c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)
-
-        # Close dialog when maintenance action scheduled
-        c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
-        #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)
-
-        maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")
-
-    def get_installer_filename(self, fullname):
-        # Factored out to allow overriding in subclasses
-        if self.target_version:
-            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
-                                            self.target_version)
-        else:
-            base_name = "%s.%s.msi" % (fullname, self.plat_name)
-        installer_name = os.path.join(self.dist_dir, base_name)
-        return installer_name
diff --git a/Lib/distutils/command/bdist_rpm.py b/Lib/distutils/command/bdist_rpm.py
deleted file mode 100644
index 02f10dd89d9..00000000000
--- a/Lib/distutils/command/bdist_rpm.py
+++ /dev/null
@@ -1,582 +0,0 @@
-"""distutils.command.bdist_rpm
-
-Implements the Distutils 'bdist_rpm' command (create RPM source and binary
-distributions)."""
-
-import subprocess, sys, os
-from distutils.core import Command
-from distutils.debug import DEBUG
-from distutils.util import get_platform
-from distutils.file_util import write_file
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_rpm(Command):
-
-    description = "create an RPM distribution"
-
-    user_options = [
-        ('bdist-base=', None,
-         "base directory for creating built distributions"),
-        ('rpm-base=', None,
-         "base directory for creating RPMs (defaults to \"rpm\" under "
-         "--bdist-base; must be specified for RPM 2)"),
-        ('dist-dir=', 'd',
-         "directory to put final RPM files in "
-         "(and .spec files if --spec-only)"),
-        ('python=', None,
-         "path to Python interpreter to hard-code in the .spec file "
-         "(default: \"python\")"),
-        ('fix-python', None,
-         "hard-code the exact path to the current Python interpreter in "
-         "the .spec file"),
-        ('spec-only', None,
-         "only regenerate spec file"),
-        ('source-only', None,
-         "only generate source RPM"),
-        ('binary-only', None,
-         "only generate binary RPM"),
-        ('use-bzip2', None,
-         "use bzip2 instead of gzip to create source distribution"),
-
-        # More meta-data: too RPM-specific to put in the setup script,
-        # but needs to go in the .spec file -- so we make these options
-        # to "bdist_rpm".  The idea is that packagers would put this
-        # info in setup.cfg, although they are of course free to
-        # supply it on the command line.
-        ('distribution-name=', None,
-         "name of the (Linux) distribution to which this "
-         "RPM applies (*not* the name of the module distribution!)"),
-        ('group=', None,
-         "package classification [default: \"Development/Libraries\"]"),
-        ('release=', None,
-         "RPM release number"),
-        ('serial=', None,
-         "RPM serial number"),
-        ('vendor=', None,
-         "RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
-         "[default: maintainer or author from setup script]"),
-        ('packager=', None,
-         "RPM packager (eg. \"Jane Doe <jane@example.net>\") "
-         "[default: vendor]"),
-        ('doc-files=', None,
-         "list of documentation files (space or comma-separated)"),
-        ('changelog=', None,
-         "RPM changelog"),
-        ('icon=', None,
-         "name of icon file"),
-        ('provides=', None,
-         "capabilities provided by this package"),
-        ('requires=', None,
-         "capabilities required by this package"),
-        ('conflicts=', None,
-         "capabilities which conflict with this package"),
-        ('build-requires=', None,
-         "capabilities required to build this package"),
-        ('obsoletes=', None,
-         "capabilities made obsolete by this package"),
-        ('no-autoreq', None,
-         "do not automatically calculate dependencies"),
-
-        # Actions to take when building RPM
-        ('keep-temp', 'k',
-         "don't clean up RPM build directory"),
-        ('no-keep-temp', None,
-         "clean up RPM build directory [default]"),
-        ('use-rpm-opt-flags', None,
-         "compile with RPM_OPT_FLAGS when building from source RPM"),
-        ('no-rpm-opt-flags', None,
-         "do not pass any RPM CFLAGS to compiler"),
-        ('rpm3-mode', None,
-         "RPM 3 compatibility mode (default)"),
-        ('rpm2-mode', None,
-         "RPM 2 compatibility mode"),
-
-        # Add the hooks necessary for specifying custom scripts
-        ('prep-script=', None,
-         "Specify a script for the PREP phase of RPM building"),
-        ('build-script=', None,
-         "Specify a script for the BUILD phase of RPM building"),
-
-        ('pre-install=', None,
-         "Specify a script for the pre-INSTALL phase of RPM building"),
-        ('install-script=', None,
-         "Specify a script for the INSTALL phase of RPM building"),
-        ('post-install=', None,
-         "Specify a script for the post-INSTALL phase of RPM building"),
-
-        ('pre-uninstall=', None,
-         "Specify a script for the pre-UNINSTALL phase of RPM building"),
-        ('post-uninstall=', None,
-         "Specify a script for the post-UNINSTALL phase of RPM building"),
-
-        ('clean-script=', None,
-         "Specify a script for the CLEAN phase of RPM building"),
-
-        ('verify-script=', None,
-         "Specify a script for the VERIFY phase of the RPM build"),
-
-        # Allow a packager to explicitly force an architecture
-        ('force-arch=', None,
-         "Force an architecture onto the RPM build process"),
-
-        ('quiet', 'q',
-         "Run the INSTALL phase of RPM building in quiet mode"),
-        ]
-
-    boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
-                       'no-autoreq', 'quiet']
-
-    negative_opt = {'no-keep-temp': 'keep-temp',
-                    'no-rpm-opt-flags': 'use-rpm-opt-flags',
-                    'rpm2-mode': 'rpm3-mode'}
-
-
-    def initialize_options(self):
-        self.bdist_base = None
-        self.rpm_base = None
-        self.dist_dir = None
-        self.python = None
-        self.fix_python = None
-        self.spec_only = None
-        self.binary_only = None
-        self.source_only = None
-        self.use_bzip2 = None
-
-        self.distribution_name = None
-        self.group = None
-        self.release = None
-        self.serial = None
-        self.vendor = None
-        self.packager = None
-        self.doc_files = None
-        self.changelog = None
-        self.icon = None
-
-        self.prep_script = None
-        self.build_script = None
-        self.install_script = None
-        self.clean_script = None
-        self.verify_script = None
-        self.pre_install = None
-        self.post_install = None
-        self.pre_uninstall = None
-        self.post_uninstall = None
-        self.prep = None
-        self.provides = None
-        self.requires = None
-        self.conflicts = None
-        self.build_requires = None
-        self.obsoletes = None
-
-        self.keep_temp = 0
-        self.use_rpm_opt_flags = 1
-        self.rpm3_mode = 1
-        self.no_autoreq = 0
-
-        self.force_arch = None
-        self.quiet = 0
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
-        if self.rpm_base is None:
-            if not self.rpm3_mode:
-                raise DistutilsOptionError(
-                      "you must specify --rpm-base in RPM 2 mode")
-            self.rpm_base = os.path.join(self.bdist_base, "rpm")
-
-        if self.python is None:
-            if self.fix_python:
-                self.python = sys.executable
-            else:
-                self.python = "python3"
-        elif self.fix_python:
-            raise DistutilsOptionError(
-                  "--python and --fix-python are mutually exclusive options")
-
-        if os.name != 'posix':
-            raise DistutilsPlatformError("don't know how to create RPM "
-                   "distributions on platform %s" % os.name)
-        if self.binary_only and self.source_only:
-            raise DistutilsOptionError(
-                  "cannot supply both '--source-only' and '--binary-only'")
-
-        # don't pass CFLAGS to pure python distributions
-        if not self.distribution.has_ext_modules():
-            self.use_rpm_opt_flags = 0
-
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-        self.finalize_package_data()
-
-    def finalize_package_data(self):
-        self.ensure_string('group', "Development/Libraries")
-        self.ensure_string('vendor',
-                           "%s <%s>" % (self.distribution.get_contact(),
-                                        self.distribution.get_contact_email()))
-        self.ensure_string('packager')
-        self.ensure_string_list('doc_files')
-        if isinstance(self.doc_files, list):
-            for readme in ('README', 'README.txt'):
-                if os.path.exists(readme) and readme not in self.doc_files:
-                    self.doc_files.append(readme)
-
-        self.ensure_string('release', "1")
-        self.ensure_string('serial')   # should it be an int?
-
-        self.ensure_string('distribution_name')
-
-        self.ensure_string('changelog')
-          # Format changelog correctly
-        self.changelog = self._format_changelog(self.changelog)
-
-        self.ensure_filename('icon')
-
-        self.ensure_filename('prep_script')
-        self.ensure_filename('build_script')
-        self.ensure_filename('install_script')
-        self.ensure_filename('clean_script')
-        self.ensure_filename('verify_script')
-        self.ensure_filename('pre_install')
-        self.ensure_filename('post_install')
-        self.ensure_filename('pre_uninstall')
-        self.ensure_filename('post_uninstall')
-
-        # XXX don't forget we punted on summaries and descriptions -- they
-        # should be handled here eventually!
-
-        # Now *this* is some meta-data that belongs in the setup script...
-        self.ensure_string_list('provides')
-        self.ensure_string_list('requires')
-        self.ensure_string_list('conflicts')
-        self.ensure_string_list('build_requires')
-        self.ensure_string_list('obsoletes')
-
-        self.ensure_string('force_arch')
-
-    def run(self):
-        if DEBUG:
-            print("before _get_package_data():")
-            print("vendor =", self.vendor)
-            print("packager =", self.packager)
-            print("doc_files =", self.doc_files)
-            print("changelog =", self.changelog)
-
-        # make directories
-        if self.spec_only:
-            spec_dir = self.dist_dir
-            self.mkpath(spec_dir)
-        else:
-            rpm_dir = {}
-            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
-                rpm_dir[d] = os.path.join(self.rpm_base, d)
-                self.mkpath(rpm_dir[d])
-            spec_dir = rpm_dir['SPECS']
-
-        # Spec file goes into 'dist_dir' if '--spec-only specified',
-        # build/rpm.<plat> otherwise.
-        spec_path = os.path.join(spec_dir,
-                                 "%s.spec" % self.distribution.get_name())
-        self.execute(write_file,
-                     (spec_path,
-                      self._make_spec_file()),
-                     "writing '%s'" % spec_path)
-
-        if self.spec_only: # stop if requested
-            return
-
-        # Make a source distribution and copy to SOURCES directory with
-        # optional icon.
-        saved_dist_files = self.distribution.dist_files[:]
-        sdist = self.reinitialize_command('sdist')
-        if self.use_bzip2:
-            sdist.formats = ['bztar']
-        else:
-            sdist.formats = ['gztar']
-        self.run_command('sdist')
-        self.distribution.dist_files = saved_dist_files
-
-        source = sdist.get_archive_files()[0]
-        source_dir = rpm_dir['SOURCES']
-        self.copy_file(source, source_dir)
-
-        if self.icon:
-            if os.path.exists(self.icon):
-                self.copy_file(self.icon, source_dir)
-            else:
-                raise DistutilsFileError(
-                      "icon file '%s' does not exist" % self.icon)
-
-        # build package
-        log.info("building RPMs")
-        rpm_cmd = ['rpm']
-        if os.path.exists('/usr/bin/rpmbuild') or \
-           os.path.exists('/bin/rpmbuild'):
-            rpm_cmd = ['rpmbuild']
-
-        if self.source_only: # what kind of RPMs?
-            rpm_cmd.append('-bs')
-        elif self.binary_only:
-            rpm_cmd.append('-bb')
-        else:
-            rpm_cmd.append('-ba')
-        rpm_cmd.extend(['--define', '__python %s' % self.python])
-        if self.rpm3_mode:
-            rpm_cmd.extend(['--define',
-                             '_topdir %s' % os.path.abspath(self.rpm_base)])
-        if not self.keep_temp:
-            rpm_cmd.append('--clean')
-
-        if self.quiet:
-            rpm_cmd.append('--quiet')
-
-        rpm_cmd.append(spec_path)
-        # Determine the binary rpm names that should be built out of this spec
-        # file
-        # Note that some of these may not be really built (if the file
-        # list is empty)
-        nvr_string = "%{name}-%{version}-%{release}"
-        src_rpm = nvr_string + ".src.rpm"
-        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
-        q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
-            src_rpm, non_src_rpm, spec_path)
-
-        out = os.popen(q_cmd)
-        try:
-            binary_rpms = []
-            source_rpm = None
-            while True:
-                line = out.readline()
-                if not line:
-                    break
-                l = line.strip().split()
-                assert(len(l) == 2)
-                binary_rpms.append(l[1])
-                # The source rpm is named after the first entry in the spec file
-                if source_rpm is None:
-                    source_rpm = l[0]
-
-            status = out.close()
-            if status:
-                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
-
-        finally:
-            out.close()
-
-        self.spawn(rpm_cmd)
-
-        if not self.dry_run:
-            if self.distribution.has_ext_modules():
-                pyversion = get_python_version()
-            else:
-                pyversion = 'any'
-
-            if not self.binary_only:
-                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
-                assert(os.path.exists(srpm))
-                self.move_file(srpm, self.dist_dir)
-                filename = os.path.join(self.dist_dir, source_rpm)
-                self.distribution.dist_files.append(
-                    ('bdist_rpm', pyversion, filename))
-
-            if not self.source_only:
-                for rpm in binary_rpms:
-                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
-                    if os.path.exists(rpm):
-                        self.move_file(rpm, self.dist_dir)
-                        filename = os.path.join(self.dist_dir,
-                                                os.path.basename(rpm))
-                        self.distribution.dist_files.append(
-                            ('bdist_rpm', pyversion, filename))
-
-    def _dist_path(self, path):
-        return os.path.join(self.dist_dir, os.path.basename(path))
-
-    def _make_spec_file(self):
-        """Generate the text of an RPM spec file and return it as a
-        list of strings (one per line).
-        """
-        # definitions and headers
-        spec_file = [
-            '%define name ' + self.distribution.get_name(),
-            '%define version ' + self.distribution.get_version().replace('-','_'),
-            '%define unmangled_version ' + self.distribution.get_version(),
-            '%define release ' + self.release.replace('-','_'),
-            '',
-            'Summary: ' + self.distribution.get_description(),
-            ]
-
-        # Workaround for #14443 which affects some RPM based systems such as
-        # RHEL6 (and probably derivatives)
-        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
-        # Generate a potential replacement value for __os_install_post (whilst
-        # normalizing the whitespace to simplify the test for whether the
-        # invocation of brp-python-bytecompile passes in __python):
-        vendor_hook = '\n'.join(['  %s \\' % line.strip()
-                                 for line in vendor_hook.splitlines()])
-        problem = "brp-python-bytecompile \\\n"
-        fixed = "brp-python-bytecompile %{__python} \\\n"
-        fixed_hook = vendor_hook.replace(problem, fixed)
-        if fixed_hook != vendor_hook:
-            spec_file.append('# Workaround for http://bugs.python.org/issue14443')
-            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')
-
-        # put locale summaries into spec file
-        # XXX not supported for now (hard to put a dictionary
-        # in a config file -- arg!)
-        #for locale in self.summaries.keys():
-        #    spec_file.append('Summary(%s): %s' % (locale,
-        #                                          self.summaries[locale]))
-
-        spec_file.extend([
-            'Name: %{name}',
-            'Version: %{version}',
-            'Release: %{release}',])
-
-        # XXX yuck! this filename is available from the "sdist" command,
-        # but only after it has run: and we create the spec file before
-        # running "sdist", in case of --spec-only.
-        if self.use_bzip2:
-            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
-        else:
-            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')
-
-        spec_file.extend([
-            'License: ' + self.distribution.get_license(),
-            'Group: ' + self.group,
-            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
-            'Prefix: %{_prefix}', ])
-
-        if not self.force_arch:
-            # noarch if no extension modules
-            if not self.distribution.has_ext_modules():
-                spec_file.append('BuildArch: noarch')
-        else:
-            spec_file.append( 'BuildArch: %s' % self.force_arch )
-
-        for field in ('Vendor',
-                      'Packager',
-                      'Provides',
-                      'Requires',
-                      'Conflicts',
-                      'Obsoletes',
-                      ):
-            val = getattr(self, field.lower())
-            if isinstance(val, list):
-                spec_file.append('%s: %s' % (field, ' '.join(val)))
-            elif val is not None:
-                spec_file.append('%s: %s' % (field, val))
-
-
-        if self.distribution.get_url() != 'UNKNOWN':
-            spec_file.append('Url: ' + self.distribution.get_url())
-
-        if self.distribution_name:
-            spec_file.append('Distribution: ' + self.distribution_name)
-
-        if self.build_requires:
-            spec_file.append('BuildRequires: ' +
-                             ' '.join(self.build_requires))
-
-        if self.icon:
-            spec_file.append('Icon: ' + os.path.basename(self.icon))
-
-        if self.no_autoreq:
-            spec_file.append('AutoReq: 0')
-
-        spec_file.extend([
-            '',
-            '%description',
-            self.distribution.get_long_description()
-            ])
-
-        # put locale descriptions into spec file
-        # XXX again, suppressed because config file syntax doesn't
-        # easily support this ;-(
-        #for locale in self.descriptions.keys():
-        #    spec_file.extend([
-        #        '',
-        #        '%description -l ' + locale,
-        #        self.descriptions[locale],
-        #        ])
-
-        # rpm scripts
-        # figure out default build script
-        def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
-        def_build = "%s build" % def_setup_call
-        if self.use_rpm_opt_flags:
-            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
-
-        # insert contents of files
-
-        # XXX this is kind of misleading: user-supplied options are files
-        # that we open and interpolate into the spec file, but the defaults
-        # are just text that we drop in as-is.  Hmmm.
-
-        install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
-                       '--record=INSTALLED_FILES') % def_setup_call
-
-        script_options = [
-            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
-            ('build', 'build_script', def_build),
-            ('install', 'install_script', install_cmd),
-            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
-            ('verifyscript', 'verify_script', None),
-            ('pre', 'pre_install', None),
-            ('post', 'post_install', None),
-            ('preun', 'pre_uninstall', None),
-            ('postun', 'post_uninstall', None),
-        ]
-
-        for (rpm_opt, attr, default) in script_options:
-            # Insert contents of file referred to, if no file is referred to
-            # use 'default' as contents of script
-            val = getattr(self, attr)
-            if val or default:
-                spec_file.extend([
-                    '',
-                    '%' + rpm_opt,])
-                if val:
-                    spec_file.extend(open(val, 'r').read().split('\n'))
-                else:
-                    spec_file.append(default)
-
-
-        # files section
-        spec_file.extend([
-            '',
-            '%files -f INSTALLED_FILES',
-            '%defattr(-,root,root)',
-            ])
-
-        if self.doc_files:
-            spec_file.append('%doc ' + ' '.join(self.doc_files))
-
-        if self.changelog:
-            spec_file.extend([
-                '',
-                '%changelog',])
-            spec_file.extend(self.changelog)
-
-        return spec_file
-
-    def _format_changelog(self, changelog):
-        """Format the changelog correctly and convert it to a list of strings
-        """
-        if not changelog:
-            return changelog
-        new_changelog = []
-        for line in changelog.strip().split('\n'):
-            line = line.strip()
-            if line[0] == '*':
-                new_changelog.extend(['', line])
-            elif line[0] == '-':
-                new_changelog.append(line)
-            else:
-                new_changelog.append('  ' + line)
-
-        # strip trailing newline inserted by first changelog entry
-        if not new_changelog[0]:
-            del new_changelog[0]
-
-        return new_changelog
diff --git a/Lib/distutils/command/bdist_wininst.py b/Lib/distutils/command/bdist_wininst.py
deleted file mode 100644
index 1db47f9b983..00000000000
--- a/Lib/distutils/command/bdist_wininst.py
+++ /dev/null
@@ -1,367 +0,0 @@
-"""distutils.command.bdist_wininst
-
-Implements the Distutils 'bdist_wininst' command: create a windows installer
-exe-program."""
-
-import sys, os
-from distutils.core import Command
-from distutils.util import get_platform
-from distutils.dir_util import create_tree, remove_tree
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_wininst(Command):
-
-    description = "create an executable installer for MS Windows"
-
-    user_options = [('bdist-dir=', None,
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('target-version=', None,
-                     "require a specific python version" +
-                     " on the target system"),
-                    ('no-target-compile', 'c',
-                     "do not compile .py to .pyc on the target system"),
-                    ('no-target-optimize', 'o',
-                     "do not compile .py to .pyo (optimized) "
-                     "on the target system"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('bitmap=', 'b',
-                     "bitmap to use for the installer instead of python-powered logo"),
-                    ('title=', 't',
-                     "title to display on the installer background instead of default"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('install-script=', None,
-                     "basename of installation script to be run after "
-                     "installation or before deinstallation"),
-                    ('pre-install-script=', None,
-                     "Fully qualified filename of a script to be run before "
-                     "any files are installed.  This script need not be in the "
-                     "distribution"),
-                    ('user-access-control=', None,
-                     "specify Vista's UAC handling - 'none'/default=no "
-                     "handling, 'auto'=use UAC if target Python installed for "
-                     "all users, 'force'=always use UAC"),
-                   ]
-
-    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
-                       'skip-build']
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.no_target_compile = 0
-        self.no_target_optimize = 0
-        self.target_version = None
-        self.dist_dir = None
-        self.bitmap = None
-        self.title = None
-        self.skip_build = None
-        self.install_script = None
-        self.pre_install_script = None
-        self.user_access_control = None
-
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
-
-        if self.bdist_dir is None:
-            if self.skip_build and self.plat_name:
-                # If build is skipped and plat_name is overridden, bdist will
-                # not see the correct 'plat_name' - so set that up manually.
-                bdist = self.distribution.get_command_obj('bdist')
-                bdist.plat_name = self.plat_name
-                # next the command will be initialized using that name
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'wininst')
-
-        if not self.target_version:
-            self.target_version = ""
-
-        if not self.skip_build and self.distribution.has_ext_modules():
-            short_version = get_python_version()
-            if self.target_version and self.target_version != short_version:
-                raise DistutilsOptionError(
-                      "target version can only be %s, or the '--skip-build'" \
-                      " option must be specified" % (short_version,))
-            self.target_version = short_version
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                  )
-
-        if self.install_script:
-            for script in self.distribution.scripts:
-                if self.install_script == os.path.basename(script):
-                    break
-            else:
-                raise DistutilsOptionError(
-                      "install_script '%s' not found in scripts"
-                      % self.install_script)
-
-    def run(self):
-        if (sys.platform != "win32" and
-            (self.distribution.has_ext_modules() or
-             self.distribution.has_c_libraries())):
-            raise DistutilsPlatformError \
-                  ("distribution contains extensions and/or C libraries; "
-                   "must be compiled on a Windows 32 platform")
-
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.root = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-        install.plat_name = self.plat_name
-
-        install_lib = self.reinitialize_command('install_lib')
-        # we do not want to include pyc or pyo files
-        install_lib.compile = 0
-        install_lib.optimize = 0
-
-        if self.distribution.has_ext_modules():
-            # If we are building an installer for a Python version other
-            # than the one we are currently running, then we need to ensure
-            # our build_lib reflects the other Python version rather than ours.
-            # Note that for target_version!=sys.version, we must have skipped the
-            # build step, so there is no issue with enforcing the build of this
-            # version.
-            target_version = self.target_version
-            if not target_version:
-                assert self.skip_build, "Should have already checked this"
-                target_version = '%d.%d' % sys.version_info[:2]
-            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
-            build = self.get_finalized_command('build')
-            build.build_lib = os.path.join(build.build_base,
-                                           'lib' + plat_specifier)
-
-        # Use a custom scheme for the zip-file, because we have to decide
-        # at installation time which scheme to use.
-        for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
-            value = key.upper()
-            if key == 'headers':
-                value = value + '/Include/$dist_name'
-            setattr(install,
-                    'install_' + key,
-                    value)
-
-        log.info("installing to %s", self.bdist_dir)
-        install.ensure_finalized()
-
-        # avoid warning of 'install_lib' about installing
-        # into a directory not in sys.path
-        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
-
-        install.run()
-
-        del sys.path[0]
-
-        # And make an archive relative to the root of the
-        # pseudo-installation tree.
-        from tempfile import mktemp
-        archive_basename = mktemp()
-        fullname = self.distribution.get_fullname()
-        arcname = self.make_archive(archive_basename, "zip",
-                                    root_dir=self.bdist_dir)
-        # create an exe containing the zip-file
-        self.create_exe(arcname, fullname, self.bitmap)
-        if self.distribution.has_ext_modules():
-            pyversion = get_python_version()
-        else:
-            pyversion = 'any'
-        self.distribution.dist_files.append(('bdist_wininst', pyversion,
-                                             self.get_installer_filename(fullname)))
-        # remove the zip-file again
-        log.debug("removing temporary file '%s'", arcname)
-        os.remove(arcname)
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-    def get_inidata(self):
-        # Return data describing the installation.
-        lines = []
-        metadata = self.distribution.metadata
-
-        # Write the [metadata] section.
-        lines.append("[metadata]")
-
-        # 'info' will be displayed in the installer's dialog box,
-        # describing the items to be installed.
-        info = (metadata.long_description or '') + '\n'
-
-        # Escape newline characters
-        def escape(s):
-            return s.replace("\n", "\\n")
-
-        for name in ["author", "author_email", "description", "maintainer",
-                     "maintainer_email", "name", "url", "version"]:
-            data = getattr(metadata, name, "")
-            if data:
-                info = info + ("\n    %s: %s" % \
-                               (name.capitalize(), escape(data)))
-                lines.append("%s=%s" % (name, escape(data)))
-
-        # The [setup] section contains entries controlling
-        # the installer runtime.
-        lines.append("\n[Setup]")
-        if self.install_script:
-            lines.append("install_script=%s" % self.install_script)
-        lines.append("info=%s" % escape(info))
-        lines.append("target_compile=%d" % (not self.no_target_compile))
-        lines.append("target_optimize=%d" % (not self.no_target_optimize))
-        if self.target_version:
-            lines.append("target_version=%s" % self.target_version)
-        if self.user_access_control:
-            lines.append("user_access_control=%s" % self.user_access_control)
-
-        title = self.title or self.distribution.get_fullname()
-        lines.append("title=%s" % escape(title))
-        import time
-        import distutils
-        build_info = "Built %s with distutils-%s" % \
-                     (time.ctime(time.time()), distutils.__version__)
-        lines.append("build_info=%s" % build_info)
-        return "\n".join(lines)
-
-    def create_exe(self, arcname, fullname, bitmap=None):
-        import struct
-
-        self.mkpath(self.dist_dir)
-
-        cfgdata = self.get_inidata()
-
-        installer_name = self.get_installer_filename(fullname)
-        self.announce("creating %s" % installer_name)
-
-        if bitmap:
-            bitmapdata = open(bitmap, "rb").read()
-            bitmaplen = len(bitmapdata)
-        else:
-            bitmaplen = 0
-
-        file = open(installer_name, "wb")
-        file.write(self.get_exe_bytes())
-        if bitmap:
-            file.write(bitmapdata)
-
-        # Convert cfgdata from unicode to ascii, mbcs encoded
-        if isinstance(cfgdata, str):
-            cfgdata = cfgdata.encode("mbcs")
-
-        # Append the pre-install script
-        cfgdata = cfgdata + b"\0"
-        if self.pre_install_script:
-            # We need to normalize newlines, so we open in text mode and
-            # convert back to bytes. "latin-1" simply avoids any possible
-            # failures.
-            with open(self.pre_install_script, "r",
-                encoding="latin-1") as script:
-                script_data = script.read().encode("latin-1")
-            cfgdata = cfgdata + script_data + b"\n\0"
-        else:
-            # empty pre-install script
-            cfgdata = cfgdata + b"\0"
-        file.write(cfgdata)
-
-        # The 'magic number' 0x1234567B is used to make sure that the
-        # binary layout of 'cfgdata' is what the wininst.exe binary
-        # expects.  If the layout changes, increment that number, make
-        # the corresponding changes to the wininst.exe sources, and
-        # recompile them.
-        header = struct.pack("<iii",
-                             0x1234567B,       # tag
-                             len(cfgdata),     # length
-                             bitmaplen,        # number of bytes in bitmap
-                             )
-        file.write(header)
-        file.write(open(arcname, "rb").read())
-
-    def get_installer_filename(self, fullname):
-        # Factored out to allow overriding in subclasses
-        if self.target_version:
-            # if we create an installer for a specific python version,
-            # it's better to include this in the name
-            installer_name = os.path.join(self.dist_dir,
-                                          "%s.%s-py%s.exe" %
-                                           (fullname, self.plat_name, self.target_version))
-        else:
-            installer_name = os.path.join(self.dist_dir,
-                                          "%s.%s.exe" % (fullname, self.plat_name))
-        return installer_name
-
-    def get_exe_bytes(self):
-        # If a target-version other than the current version has been
-        # specified, then using the MSVC version from *this* build is no good.
-        # Without actually finding and executing the target version and parsing
-        # its sys.version, we just hard-code our knowledge of old versions.
-        # NOTE: Possible alternative is to allow "--target-version" to
-        # specify a Python executable rather than a simple version string.
-        # We can then execute this program to obtain any info we need, such
-        # as the real sys.version string for the build.
-        cur_version = get_python_version()
-
-        # If the target version is *later* than us, then we assume they
-        # use what we use
-        # string compares seem wrong, but are what sysconfig.py itself uses
-        if self.target_version and self.target_version < cur_version:
-            if self.target_version < "2.4":
-                bv = '6.0'
-            elif self.target_version == "2.4":
-                bv = '7.1'
-            elif self.target_version == "2.5":
-                bv = '8.0'
-            elif self.target_version <= "3.2":
-                bv = '9.0'
-            elif self.target_version <= "3.4":
-                bv = '10.0'
-            else:
-                bv = '14.0'
-        else:
-            # for current version - use authoritative check.
-            try:
-                from msvcrt import CRT_ASSEMBLY_VERSION
-            except ImportError:
-                # cross-building, so assume the latest version
-                bv = '14.0'
-            else:
-                # as far as we know, CRT is binary compatible based on
-                # the first field, so assume 'x.0' until proven otherwise
-                major = CRT_ASSEMBLY_VERSION.partition('.')[0]
-                bv = major + '.0'
-
-
-        # wininst-x.y.exe is in the same directory as this file
-        directory = os.path.dirname(__file__)
-        # we must use a wininst-x.y.exe built with the same C compiler
-        # used for python.  XXX What about mingw, borland, and so on?
-
-        # if plat_name starts with "win" but is not "win32"
-        # we want to strip "win" and leave the rest (e.g. -amd64)
-        # for all other cases, we don't want any suffix
-        if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
-            sfix = self.plat_name[3:]
-        else:
-            sfix = ''
-
-        filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
-        try:
-            f = open(filename, "rb")
-        except IOError as e:
-            raise DistutilsFileError(str(e) + ', %s not included in the Debian packages.' % filename)
-        try:
-            return f.read()
-        finally:
-            f.close()
diff --git a/Lib/distutils/command/build.py b/Lib/distutils/command/build.py
deleted file mode 100644
index c6f52e61e1b..00000000000
--- a/Lib/distutils/command/build.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""distutils.command.build
-
-Implements the Distutils 'build' command."""
-
-import sys, os
-from distutils.core import Command
-from distutils.errors import DistutilsOptionError
-from distutils.util import get_platform
-
-
-def show_compilers():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build(Command):
-
-    description = "build everything needed to install"
-
-    user_options = [
-        ('build-base=', 'b',
-         "base directory for build library"),
-        ('build-purelib=', None,
-         "build directory for platform-neutral distributions"),
-        ('build-platlib=', None,
-         "build directory for platform-specific distributions"),
-        ('build-lib=', None,
-         "build directory for all distribution (defaults to either " +
-         "build-purelib or build-platlib"),
-        ('build-scripts=', None,
-         "build directory for scripts"),
-        ('build-temp=', 't',
-         "temporary build directory"),
-        ('plat-name=', 'p',
-         "platform name to build for, if supported "
-         "(default: %s)" % get_platform()),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ('parallel=', 'j',
-         "number of parallel build jobs"),
-        ('debug', 'g',
-         "compile extensions and libraries with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('executable=', 'e',
-         "specify final destination interpreter path (build.py)"),
-        ]
-
-    boolean_options = ['debug', 'force']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.build_base = 'build'
-        # these are decided only after 'build_base' has its final value
-        # (unless overridden by the user or client)
-        self.build_purelib = None
-        self.build_platlib = None
-        self.build_lib = None
-        self.build_temp = None
-        self.build_scripts = None
-        self.compiler = None
-        self.plat_name = None
-        self.debug = None
-        self.force = 0
-        self.executable = None
-        self.parallel = None
-
-    def finalize_options(self):
-        if self.plat_name is None:
-            self.plat_name = get_platform()
-        else:
-            # plat-name only supported for windows (other platforms are
-            # supported via ./configure flags, if at all).  Avoid misleading
-            # other platforms.
-            if os.name != 'nt':
-                raise DistutilsOptionError(
-                            "--plat-name only supported on Windows (try "
-                            "using './configure --help' on your platform)")
-
-        plat_specifier = ".%s-%d.%d" % (self.plat_name, *sys.version_info[:2])
-
-        # Make it so Python 2.x and Python 2.x with --with-pydebug don't
-        # share the same build directories. Doing so confuses the build
-        # process for C modules
-        if hasattr(sys, 'gettotalrefcount'):
-            plat_specifier += '-pydebug'
-
-        # 'build_purelib' and 'build_platlib' just default to 'lib' and
-        # 'lib.<plat>' under the base build directory.  We only use one of
-        # them for a given distribution, though --
-        if self.build_purelib is None:
-            self.build_purelib = os.path.join(self.build_base, 'lib')
-        if self.build_platlib is None:
-            self.build_platlib = os.path.join(self.build_base,
-                                              'lib' + plat_specifier)
-
-        # 'build_lib' is the actual directory that we will use for this
-        # particular module distribution -- if user didn't supply it, pick
-        # one of 'build_purelib' or 'build_platlib'.
-        if self.build_lib is None:
-            if self.distribution.ext_modules:
-                self.build_lib = self.build_platlib
-            else:
-                self.build_lib = self.build_purelib
-
-        # 'build_temp' -- temporary directory for compiler turds,
-        # "build/temp.<plat>"
-        if self.build_temp is None:
-            self.build_temp = os.path.join(self.build_base,
-                                           'temp' + plat_specifier)
-        if self.build_scripts is None:
-            self.build_scripts = os.path.join(self.build_base,
-                                              'scripts-%d.%d' % sys.version_info[:2])
-
-        if self.executable is None:
-            self.executable = os.path.normpath(sys.executable)
-
-        if isinstance(self.parallel, str):
-            try:
-                self.parallel = int(self.parallel)
-            except ValueError:
-                raise DistutilsOptionError("parallel should be an integer")
-
-    def run(self):
-        # Run all relevant sub-commands.  This will be some subset of:
-        #  - build_py      - pure Python modules
-        #  - build_clib    - standalone C libraries
-        #  - build_ext     - Python extensions
-        #  - build_scripts - (Python) scripts
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-
-    # -- Predicates for the sub-command list ---------------------------
-
-    def has_pure_modules(self):
-        return self.distribution.has_pure_modules()
-
-    def has_c_libraries(self):
-        return self.distribution.has_c_libraries()
-
-    def has_ext_modules(self):
-        return self.distribution.has_ext_modules()
-
-    def has_scripts(self):
-        return self.distribution.has_scripts()
-
-
-    sub_commands = [('build_py',      has_pure_modules),
-                    ('build_clib',    has_c_libraries),
-                    ('build_ext',     has_ext_modules),
-                    ('build_scripts', has_scripts),
-                   ]
diff --git a/Lib/distutils/command/build_clib.py b/Lib/distutils/command/build_clib.py
deleted file mode 100644
index 3e20ef23cd8..00000000000
--- a/Lib/distutils/command/build_clib.py
+++ /dev/null
@@ -1,209 +0,0 @@
-"""distutils.command.build_clib
-
-Implements the Distutils 'build_clib' command, to build a C/C++ library
-that is included in the module distribution and needed by an extension
-module."""
-
-
-# XXX this module has *lots* of code ripped-off quite transparently from
-# build_ext.py -- not surprisingly really, as the work required to build
-# a static library from a collection of C source files is not really all
-# that different from what's required to build a shared object file from
-# a collection of C source files.  Nevertheless, I haven't done the
-# necessary refactoring to account for the overlap in code between the
-# two modules, mainly because a number of subtle details changed in the
-# cut 'n paste.  Sigh.
-
-import os
-from distutils.core import Command
-from distutils.errors import *
-from distutils.sysconfig import customize_compiler
-from distutils import log
-
-def show_compilers():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build_clib(Command):
-
-    description = "build C/C++ libraries used by Python extensions"
-
-    user_options = [
-        ('build-clib=', 'b',
-         "directory to build C/C++ libraries to"),
-        ('build-temp=', 't',
-         "directory to put temporary build by-products"),
-        ('debug', 'g',
-         "compile with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ]
-
-    boolean_options = ['debug', 'force']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.build_clib = None
-        self.build_temp = None
-
-        # List of libraries to build
-        self.libraries = None
-
-        # Compilation options for all libraries
-        self.include_dirs = None
-        self.define = None
-        self.undef = None
-        self.debug = None
-        self.force = 0
-        self.compiler = None
-
-
-    def finalize_options(self):
-        # This might be confusing: both build-clib and build-temp default
-        # to build-temp as defined by the "build" command.  This is because
-        # I think that C libraries are really just temporary build
-        # by-products, at least from the point of view of building Python
-        # extensions -- but I want to keep my options open.
-        self.set_undefined_options('build',
-                                   ('build_temp', 'build_clib'),
-                                   ('build_temp', 'build_temp'),
-                                   ('compiler', 'compiler'),
-                                   ('debug', 'debug'),
-                                   ('force', 'force'))
-
-        self.libraries = self.distribution.libraries
-        if self.libraries:
-            self.check_library_list(self.libraries)
-
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        if isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        # XXX same as for build_ext -- what about 'self.define' and
-        # 'self.undef' ?
-
-
-    def run(self):
-        if not self.libraries:
-            return
-
-        # Yech -- this is cut 'n pasted from build_ext.py!
-        from distutils.ccompiler import new_compiler
-        self.compiler = new_compiler(compiler=self.compiler,
-                                     dry_run=self.dry_run,
-                                     force=self.force)
-        customize_compiler(self.compiler)
-
-        if self.include_dirs is not None:
-            self.compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name,value) in self.define:
-                self.compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                self.compiler.undefine_macro(macro)
-
-        self.build_libraries(self.libraries)
-
-
-    def check_library_list(self, libraries):
-        """Ensure that the list of libraries is valid.
-
-        `library` is presumably provided as a command option 'libraries'.
-        This method checks that it is a list of 2-tuples, where the tuples
-        are (library_name, build_info_dict).
-
-        Raise DistutilsSetupError if the structure is invalid anywhere;
-        just returns otherwise.
-        """
-        if not isinstance(libraries, list):
-            raise DistutilsSetupError(
-                  "'libraries' option must be a list of tuples")
-
-        for lib in libraries:
-            if not isinstance(lib, tuple) and len(lib) != 2:
-                raise DistutilsSetupError(
-                      "each element of 'libraries' must a 2-tuple")
-
-            name, build_info = lib
-
-            if not isinstance(name, str):
-                raise DistutilsSetupError(
-                      "first element of each tuple in 'libraries' "
-                      "must be a string (the library name)")
-
-            if '/' in name or (os.sep != '/' and os.sep in name):
-                raise DistutilsSetupError("bad library name '%s': "
-                       "may not contain directory separators" % lib[0])
-
-            if not isinstance(build_info, dict):
-                raise DistutilsSetupError(
-                      "second element of each tuple in 'libraries' "
-                      "must be a dictionary (build info)")
-
-
-    def get_library_names(self):
-        # Assume the library list is valid -- 'check_library_list()' is
-        # called from 'finalize_options()', so it should be!
-        if not self.libraries:
-            return None
-
-        lib_names = []
-        for (lib_name, build_info) in self.libraries:
-            lib_names.append(lib_name)
-        return lib_names
-
-
-    def get_source_files(self):
-        self.check_library_list(self.libraries)
-        filenames = []
-        for (lib_name, build_info) in self.libraries:
-            sources = build_info.get('sources')
-            if sources is None or not isinstance(sources, (list, tuple)):
-                raise DistutilsSetupError(
-                       "in 'libraries' option (library '%s'), "
-                       "'sources' must be present and must be "
-                       "a list of source filenames" % lib_name)
-
-            filenames.extend(sources)
-        return filenames
-
-
-    def build_libraries(self, libraries):
-        for (lib_name, build_info) in libraries:
-            sources = build_info.get('sources')
-            if sources is None or not isinstance(sources, (list, tuple)):
-                raise DistutilsSetupError(
-                       "in 'libraries' option (library '%s'), "
-                       "'sources' must be present and must be "
-                       "a list of source filenames" % lib_name)
-            sources = list(sources)
-
-            log.info("building '%s' library", lib_name)
-
-            # First, compile the source code to object files in the library
-            # directory.  (This should probably change to putting object
-            # files in a temporary build directory.)
-            macros = build_info.get('macros')
-            include_dirs = build_info.get('include_dirs')
-            objects = self.compiler.compile(sources,
-                                            output_dir=self.build_temp,
-                                            macros=macros,
-                                            include_dirs=include_dirs,
-                                            debug=self.debug)
-
-            # Now "link" the object files together into a static library.
-            # (On Unix at least, this isn't really linking -- it just
-            # builds an archive.  Whatever.)
-            self.compiler.create_static_lib(objects, lib_name,
-                                            output_dir=self.build_clib,
-                                            debug=self.debug)
diff --git a/Lib/distutils/command/build_ext.py b/Lib/distutils/command/build_ext.py
deleted file mode 100644
index acf2fc5484a..00000000000
--- a/Lib/distutils/command/build_ext.py
+++ /dev/null
@@ -1,755 +0,0 @@
-"""distutils.command.build_ext
-
-Implements the Distutils 'build_ext' command, for building extension
-modules (currently limited to C extensions, should accommodate C++
-extensions ASAP)."""
-
-import contextlib
-import os
-import re
-import sys
-from distutils.core import Command
-from distutils.errors import *
-from distutils.sysconfig import customize_compiler, get_python_version
-from distutils.sysconfig import get_config_h_filename
-from distutils.dep_util import newer_group
-from distutils.extension import Extension
-from distutils.util import get_platform
-from distutils import log
-
-from site import USER_BASE
-
-# An extension name is just a dot-separated list of Python NAMEs (ie.
-# the same as a fully-qualified module name).
-extension_name_re = re.compile \
-    (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')
-
-
-def show_compilers ():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build_ext(Command):
-
-    description = "build C/C++ extensions (compile/link to build directory)"
-
-    # XXX thoughts on how to deal with complex command-line options like
-    # these, i.e. how to make it so fancy_getopt can suck them off the
-    # command line and make it look like setup.py defined the appropriate
-    # lists of tuples of what-have-you.
-    #   - each command needs a callback to process its command-line options
-    #   - Command.__init__() needs access to its share of the whole
-    #     command line (must ultimately come from
-    #     Distribution.parse_command_line())
-    #   - it then calls the current command class' option-parsing
-    #     callback to deal with weird options like -D, which have to
-    #     parse the option text and churn out some custom data
-    #     structure
-    #   - that data structure (in this case, a list of 2-tuples)
-    #     will then be present in the command object by the time
-    #     we get to finalize_options() (i.e. the constructor
-    #     takes care of both command-line and client options
-    #     in between initialize_options() and finalize_options())
-
-    sep_by = " (separated by '%s')" % os.pathsep
-    user_options = [
-        ('build-lib=', 'b',
-         "directory for compiled extension modules"),
-        ('build-temp=', 't',
-         "directory for temporary files (build by-products)"),
-        ('plat-name=', 'p',
-         "platform name to cross-compile for, if supported "
-         "(default: %s)" % get_platform()),
-        ('inplace', 'i',
-         "ignore build-lib and put compiled extensions into the source " +
-         "directory alongside your pure Python modules"),
-        ('include-dirs=', 'I',
-         "list of directories to search for header files" + sep_by),
-        ('define=', 'D',
-         "C preprocessor macros to define"),
-        ('undef=', 'U',
-         "C preprocessor macros to undefine"),
-        ('libraries=', 'l',
-         "external C libraries to link with"),
-        ('library-dirs=', 'L',
-         "directories to search for external C libraries" + sep_by),
-        ('rpath=', 'R',
-         "directories to search for shared C libraries at runtime"),
-        ('link-objects=', 'O',
-         "extra explicit link objects to include in the link"),
-        ('debug', 'g',
-         "compile/link with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ('parallel=', 'j',
-         "number of parallel build jobs"),
-        ('swig-cpp', None,
-         "make SWIG create C++ files (default is C)"),
-        ('swig-opts=', None,
-         "list of SWIG command line options"),
-        ('swig=', None,
-         "path to the SWIG executable"),
-        ('user', None,
-         "add user include, library and rpath")
-        ]
-
-    boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.extensions = None
-        self.build_lib = None
-        self.plat_name = None
-        self.build_temp = None
-        self.inplace = 0
-        self.package = None
-
-        self.include_dirs = None
-        self.define = None
-        self.undef = None
-        self.libraries = None
-        self.library_dirs = None
-        self.rpath = None
-        self.link_objects = None
-        self.debug = None
-        self.force = None
-        self.compiler = None
-        self.swig = None
-        self.swig_cpp = None
-        self.swig_opts = None
-        self.user = None
-        self.parallel = None
-
-    def finalize_options(self):
-        from distutils import sysconfig
-
-        self.set_undefined_options('build',
-                                   ('build_lib', 'build_lib'),
-                                   ('build_temp', 'build_temp'),
-                                   ('compiler', 'compiler'),
-                                   ('debug', 'debug'),
-                                   ('force', 'force'),
-                                   ('parallel', 'parallel'),
-                                   ('plat_name', 'plat_name'),
-                                   )
-
-        if self.package is None:
-            self.package = self.distribution.ext_package
-
-        self.extensions = self.distribution.ext_modules
-
-        # Make sure Python's include directories (for Python.h, pyconfig.h,
-        # etc.) are in the include search path.
-        py_include = sysconfig.get_python_inc()
-        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        if isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        # If in a virtualenv, add its include directory
-        # Issue 16116
-        if sys.exec_prefix != sys.base_exec_prefix:
-            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
-
-        # Put the Python "system" include dir at the end, so that
-        # any local include dirs take precedence.
-        self.include_dirs.append(py_include)
-        if plat_py_include != py_include:
-            self.include_dirs.append(plat_py_include)
-
-        self.ensure_string_list('libraries')
-        self.ensure_string_list('link_objects')
-
-        # Life is easier if we're not forever checking for None, so
-        # simplify these options to empty lists if unset
-        if self.libraries is None:
-            self.libraries = []
-        if self.library_dirs is None:
-            self.library_dirs = []
-        elif isinstance(self.library_dirs, str):
-            self.library_dirs = self.library_dirs.split(os.pathsep)
-
-        if self.rpath is None:
-            self.rpath = []
-        elif isinstance(self.rpath, str):
-            self.rpath = self.rpath.split(os.pathsep)
-
-        # for extensions under windows use different directories
-        # for Release and Debug builds.
-        # also Python's library directory must be appended to library_dirs
-        if os.name == 'nt':
-            # the 'libs' directory is for binary installs - we assume that
-            # must be the *native* platform.  But we don't really support
-            # cross-compiling via a binary install anyway, so we let it go.
-            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
-            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
-                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
-            if self.debug:
-                self.build_temp = os.path.join(self.build_temp, "Debug")
-            else:
-                self.build_temp = os.path.join(self.build_temp, "Release")
-
-            # Append the source distribution include and library directories,
-            # this allows distutils on windows to work in the source tree
-            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
-            _sys_home = getattr(sys, '_home', None)
-            if _sys_home:
-                self.library_dirs.append(_sys_home)
-
-            # Use the .lib files for the correct architecture
-            if self.plat_name == 'win32':
-                suffix = 'win32'
-            else:
-                # win-amd64 or win-ia64
-                suffix = self.plat_name[4:]
-            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
-            if suffix:
-                new_lib = os.path.join(new_lib, suffix)
-            self.library_dirs.append(new_lib)
-
-        # for extensions under Cygwin and AtheOS Python's library directory must be
-        # appended to library_dirs
-        if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
-            if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
-                # building third party extensions
-                self.library_dirs.append(os.path.join(sys.prefix, "lib",
-                                                      "python" + get_python_version(),
-                                                      "config"))
-            else:
-                # building python standard extensions
-                self.library_dirs.append('.')
-
-        # For building extensions with a shared Python library,
-        # Python's library directory must be appended to library_dirs
-        # See Issues: #1600860, #4366
-        if False and (sysconfig.get_config_var('Py_ENABLE_SHARED')):
-            if not sysconfig.python_build:
-                # building third party extensions
-                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
-            else:
-                # building python standard extensions
-                self.library_dirs.append('.')
-
-        # The argument parsing will result in self.define being a string, but
-        # it has to be a list of 2-tuples.  All the preprocessor symbols
-        # specified by the 'define' option will be set to '1'.  Multiple
-        # symbols can be separated with commas.
-
-        if self.define:
-            defines = self.define.split(',')
-            self.define = [(symbol, '1') for symbol in defines]
-
-        # The option for macros to undefine is also a string from the
-        # option parsing, but has to be a list.  Multiple symbols can also
-        # be separated with commas here.
-        if self.undef:
-            self.undef = self.undef.split(',')
-
-        if self.swig_opts is None:
-            self.swig_opts = []
-        else:
-            self.swig_opts = self.swig_opts.split(' ')
-
-        # Finally add the user include and library directories if requested
-        if self.user:
-            user_include = os.path.join(USER_BASE, "include")
-            user_lib = os.path.join(USER_BASE, "lib")
-            if os.path.isdir(user_include):
-                self.include_dirs.append(user_include)
-            if os.path.isdir(user_lib):
-                self.library_dirs.append(user_lib)
-                self.rpath.append(user_lib)
-
-        if isinstance(self.parallel, str):
-            try:
-                self.parallel = int(self.parallel)
-            except ValueError:
-                raise DistutilsOptionError("parallel should be an integer")
-
-    def run(self):
-        from distutils.ccompiler import new_compiler
-
-        # 'self.extensions', as supplied by setup.py, is a list of
-        # Extension instances.  See the documentation for Extension (in
-        # distutils.extension) for details.
-        #
-        # For backwards compatibility with Distutils 0.8.2 and earlier, we
-        # also allow the 'extensions' list to be a list of tuples:
-        #    (ext_name, build_info)
-        # where build_info is a dictionary containing everything that
-        # Extension instances do except the name, with a few things being
-        # differently named.  We convert these 2-tuples to Extension
-        # instances as needed.
-
-        if not self.extensions:
-            return
-
-        # If we were asked to build any C/C++ libraries, make sure that the
-        # directory where we put them is in the library search path for
-        # linking extensions.
-        if self.distribution.has_c_libraries():
-            build_clib = self.get_finalized_command('build_clib')
-            self.libraries.extend(build_clib.get_library_names() or [])
-            self.library_dirs.append(build_clib.build_clib)
-
-        # Setup the CCompiler object that we'll use to do all the
-        # compiling and linking
-        self.compiler = new_compiler(compiler=self.compiler,
-                                     verbose=self.verbose,
-                                     dry_run=self.dry_run,
-                                     force=self.force)
-        customize_compiler(self.compiler)
-        # If we are cross-compiling, init the compiler now (if we are not
-        # cross-compiling, init would not hurt, but people may rely on
-        # late initialization of compiler even if they shouldn't...)
-        if os.name == 'nt' and self.plat_name != get_platform():
-            self.compiler.initialize(self.plat_name)
-
-        # And make sure that any compile/link-related options (which might
-        # come from the command-line or from the setup script) are set in
-        # that CCompiler object -- that way, they automatically apply to
-        # all compiling and linking done here.
-        if self.include_dirs is not None:
-            self.compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name, value) in self.define:
-                self.compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                self.compiler.undefine_macro(macro)
-        if self.libraries is not None:
-            self.compiler.set_libraries(self.libraries)
-        if self.library_dirs is not None:
-            self.compiler.set_library_dirs(self.library_dirs)
-        if self.rpath is not None:
-            self.compiler.set_runtime_library_dirs(self.rpath)
-        if self.link_objects is not None:
-            self.compiler.set_link_objects(self.link_objects)
-
-        # Now actually compile and link everything.
-        self.build_extensions()
-
-    def check_extensions_list(self, extensions):
-        """Ensure that the list of extensions (presumably provided as a
-        command option 'extensions') is valid, i.e. it is a list of
-        Extension objects.  We also support the old-style list of 2-tuples,
-        where the tuples are (ext_name, build_info), which are converted to
-        Extension instances here.
-
-        Raise DistutilsSetupError if the structure is invalid anywhere;
-        just returns otherwise.
-        """
-        if not isinstance(extensions, list):
-            raise DistutilsSetupError(
-                  "'ext_modules' option must be a list of Extension instances")
-
-        for i, ext in enumerate(extensions):
-            if isinstance(ext, Extension):
-                continue                # OK! (assume type-checking done
-                                        # by Extension constructor)
-
-            if not isinstance(ext, tuple) or len(ext) != 2:
-                raise DistutilsSetupError(
-                       "each element of 'ext_modules' option must be an "
-                       "Extension instance or 2-tuple")
-
-            ext_name, build_info = ext
-
-            log.warn("old-style (ext_name, build_info) tuple found in "
-                     "ext_modules for extension '%s' "
-                     "-- please convert to Extension instance", ext_name)
-
-            if not (isinstance(ext_name, str) and
-                    extension_name_re.match(ext_name)):
-                raise DistutilsSetupError(
-                       "first element of each tuple in 'ext_modules' "
-                       "must be the extension name (a string)")
-
-            if not isinstance(build_info, dict):
-                raise DistutilsSetupError(
-                       "second element of each tuple in 'ext_modules' "
-                       "must be a dictionary (build info)")
-
-            # OK, the (ext_name, build_info) dict is type-safe: convert it
-            # to an Extension instance.
-            ext = Extension(ext_name, build_info['sources'])
-
-            # Easy stuff: one-to-one mapping from dict elements to
-            # instance attributes.
-            for key in ('include_dirs', 'library_dirs', 'libraries',
-                        'extra_objects', 'extra_compile_args',
-                        'extra_link_args'):
-                val = build_info.get(key)
-                if val is not None:
-                    setattr(ext, key, val)
-
-            # Medium-easy stuff: same syntax/semantics, different names.
-            ext.runtime_library_dirs = build_info.get('rpath')
-            if 'def_file' in build_info:
-                log.warn("'def_file' element of build info dict "
-                         "no longer supported")
-
-            # Non-trivial stuff: 'macros' split into 'define_macros'
-            # and 'undef_macros'.
-            macros = build_info.get('macros')
-            if macros:
-                ext.define_macros = []
-                ext.undef_macros = []
-                for macro in macros:
-                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
-                        raise DistutilsSetupError(
-                              "'macros' element of build info dict "
-                              "must be 1- or 2-tuple")
-                    if len(macro) == 1:
-                        ext.undef_macros.append(macro[0])
-                    elif len(macro) == 2:
-                        ext.define_macros.append(macro)
-
-            extensions[i] = ext
-
-    def get_source_files(self):
-        self.check_extensions_list(self.extensions)
-        filenames = []
-
-        # Wouldn't it be neat if we knew the names of header files too...
-        for ext in self.extensions:
-            filenames.extend(ext.sources)
-        return filenames
-
-    def get_outputs(self):
-        # Sanity check the 'extensions' list -- can't assume this is being
-        # done in the same run as a 'build_extensions()' call (in fact, we
-        # can probably assume that it *isn't*!).
-        self.check_extensions_list(self.extensions)
-
-        # And build the list of output (built) filenames.  Note that this
-        # ignores the 'inplace' flag, and assumes everything goes in the
-        # "build" tree.
-        outputs = []
-        for ext in self.extensions:
-            outputs.append(self.get_ext_fullpath(ext.name))
-        return outputs
-
-    def build_extensions(self):
-        # First, sanity-check the 'extensions' list
-        self.check_extensions_list(self.extensions)
-        if self.parallel:
-            self._build_extensions_parallel()
-        else:
-            self._build_extensions_serial()
-
-    def _build_extensions_parallel(self):
-        workers = self.parallel
-        if self.parallel is True:
-            workers = os.cpu_count()  # may return None
-        try:
-            from concurrent.futures import ThreadPoolExecutor
-        except ImportError:
-            workers = None
-
-        if workers is None:
-            self._build_extensions_serial()
-            return
-
-        with ThreadPoolExecutor(max_workers=workers) as executor:
-            futures = [executor.submit(self.build_extension, ext)
-                       for ext in self.extensions]
-            for ext, fut in zip(self.extensions, futures):
-                with self._filter_build_errors(ext):
-                    fut.result()
-
-    def _build_extensions_serial(self):
-        for ext in self.extensions:
-            with self._filter_build_errors(ext):
-                self.build_extension(ext)
-
-    @contextlib.contextmanager
-    def _filter_build_errors(self, ext):
-        try:
-            yield
-        except (CCompilerError, DistutilsError, CompileError) as e:
-            if not ext.optional:
-                raise
-            self.warn('building extension "%s" failed: %s' %
-                      (ext.name, e))
-
-    def build_extension(self, ext):
-        sources = ext.sources
-        if sources is None or not isinstance(sources, (list, tuple)):
-            raise DistutilsSetupError(
-                  "in 'ext_modules' option (extension '%s'), "
-                  "'sources' must be present and must be "
-                  "a list of source filenames" % ext.name)
-        sources = list(sources)
-
-        ext_path = self.get_ext_fullpath(ext.name)
-        depends = sources + ext.depends
-        if not (self.force or newer_group(depends, ext_path, 'newer')):
-            log.debug("skipping '%s' extension (up-to-date)", ext.name)
-            return
-        else:
-            log.info("building '%s' extension", ext.name)
-
-        # First, scan the sources for SWIG definition files (.i), run
-        # SWIG on 'em to create .c files, and modify the sources list
-        # accordingly.
-        sources = self.swig_sources(sources, ext)
-
-        # Next, compile the source code to object files.
-
-        # XXX not honouring 'define_macros' or 'undef_macros' -- the
-        # CCompiler API needs to change to accommodate this, and I
-        # want to do one thing at a time!
-
-        # Two possible sources for extra compiler arguments:
-        #   - 'extra_compile_args' in Extension object
-        #   - CFLAGS environment variable (not particularly
-        #     elegant, but people seem to expect it and I
-        #     guess it's useful)
-        # The environment variable should take precedence, and
-        # any sensible compiler will give precedence to later
-        # command line args.  Hence we combine them in order:
-        extra_args = ext.extra_compile_args or []
-
-        macros = ext.define_macros[:]
-        for undef in ext.undef_macros:
-            macros.append((undef,))
-
-        objects = self.compiler.compile(sources,
-                                         output_dir=self.build_temp,
-                                         macros=macros,
-                                         include_dirs=ext.include_dirs,
-                                         debug=self.debug,
-                                         extra_postargs=extra_args,
-                                         depends=ext.depends)
-
-        # XXX outdated variable, kept here in case third-part code
-        # needs it.
-        self._built_objects = objects[:]
-
-        # Now link the object files together into a "shared object" --
-        # of course, first we have to figure out all the other things
-        # that go into the mix.
-        if ext.extra_objects:
-            objects.extend(ext.extra_objects)
-        extra_args = ext.extra_link_args or []
-
-        # Detect target language, if not provided
-        language = ext.language or self.compiler.detect_language(sources)
-
-        self.compiler.link_shared_object(
-            objects, ext_path,
-            libraries=self.get_libraries(ext),
-            library_dirs=ext.library_dirs,
-            runtime_library_dirs=ext.runtime_library_dirs,
-            extra_postargs=extra_args,
-            export_symbols=self.get_export_symbols(ext),
-            debug=self.debug,
-            build_temp=self.build_temp,
-            target_lang=language)
-
-    def swig_sources(self, sources, extension):
-        """Walk the list of source files in 'sources', looking for SWIG
-        interface (.i) files.  Run SWIG on all that are found, and
-        return a modified 'sources' list with SWIG source files replaced
-        by the generated C (or C++) files.
-        """
-        new_sources = []
-        swig_sources = []
-        swig_targets = {}
-
-        # XXX this drops generated C/C++ files into the source tree, which
-        # is fine for developers who want to distribute the generated
-        # source -- but there should be an option to put SWIG output in
-        # the temp dir.
-
-        if self.swig_cpp:
-            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")
-
-        if self.swig_cpp or ('-c++' in self.swig_opts) or \
-           ('-c++' in extension.swig_opts):
-            target_ext = '.cpp'
-        else:
-            target_ext = '.c'
-
-        for source in sources:
-            (base, ext) = os.path.splitext(source)
-            if ext == ".i":             # SWIG interface file
-                new_sources.append(base + '_wrap' + target_ext)
-                swig_sources.append(source)
-                swig_targets[source] = new_sources[-1]
-            else:
-                new_sources.append(source)
-
-        if not swig_sources:
-            return new_sources
-
-        swig = self.swig or self.find_swig()
-        swig_cmd = [swig, "-python"]
-        swig_cmd.extend(self.swig_opts)
-        if self.swig_cpp:
-            swig_cmd.append("-c++")
-
-        # Do not override commandline arguments
-        if not self.swig_opts:
-            for o in extension.swig_opts:
-                swig_cmd.append(o)
-
-        for source in swig_sources:
-            target = swig_targets[source]
-            log.info("swigging %s to %s", source, target)
-            self.spawn(swig_cmd + ["-o", target, source])
-
-        return new_sources
-
-    def find_swig(self):
-        """Return the name of the SWIG executable.  On Unix, this is
-        just "swig" -- it should be in the PATH.  Tries a bit harder on
-        Windows.
-        """
-        if os.name == "posix":
-            return "swig"
-        elif os.name == "nt":
-            # Look for SWIG in its standard installation directory on
-            # Windows (or so I presume!).  If we find it there, great;
-            # if not, act like Unix and assume it's in the PATH.
-            for vers in ("1.3", "1.2", "1.1"):
-                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
-                if os.path.isfile(fn):
-                    return fn
-            else:
-                return "swig.exe"
-        else:
-            raise DistutilsPlatformError(
-                  "I don't know how to find (much less run) SWIG "
-                  "on platform '%s'" % os.name)
-
-    # -- Name generators -----------------------------------------------
-    # (extension names, filenames, whatever)
-    def get_ext_fullpath(self, ext_name):
-        """Returns the path of the filename for a given extension.
-
-        The file is located in `build_lib` or directly in the package
-        (inplace option).
-        """
-        fullname = self.get_ext_fullname(ext_name)
-        modpath = fullname.split('.')
-        filename = self.get_ext_filename(modpath[-1])
-
-        if not self.inplace:
-            # no further work needed
-            # returning :
-            #   build_dir/package/path/filename
-            filename = os.path.join(*modpath[:-1]+[filename])
-            return os.path.join(self.build_lib, filename)
-
-        # the inplace option requires to find the package directory
-        # using the build_py command for that
-        package = '.'.join(modpath[0:-1])
-        build_py = self.get_finalized_command('build_py')
-        package_dir = os.path.abspath(build_py.get_package_dir(package))
-
-        # returning
-        #   package_dir/filename
-        return os.path.join(package_dir, filename)
-
-    def get_ext_fullname(self, ext_name):
-        """Returns the fullname of a given extension name.
-
-        Adds the `package.` prefix"""
-        if self.package is None:
-            return ext_name
-        else:
-            return self.package + '.' + ext_name
-
-    def get_ext_filename(self, ext_name):
-        r"""Convert the name of an extension (eg. "foo.bar") into the name
-        of the file from which it will be loaded (eg. "foo/bar.so", or
-        "foo\bar.pyd").
-        """
-        from distutils.sysconfig import get_config_var
-        ext_path = ext_name.split('.')
-        ext_suffix = get_config_var('EXT_SUFFIX')
-        return os.path.join(*ext_path) + ext_suffix
-
-    def get_export_symbols(self, ext):
-        """Return the list of symbols that a shared extension has to
-        export.  This either uses 'ext.export_symbols' or, if it's not
-        provided, "PyInit_" + module_name.  Only relevant on Windows, where
-        the .pyd file (DLL) must export the module "PyInit_" function.
-        """
-        initfunc_name = "PyInit_" + ext.name.split('.')[-1]
-        if initfunc_name not in ext.export_symbols:
-            ext.export_symbols.append(initfunc_name)
-        return ext.export_symbols
-
-    def get_libraries(self, ext):
-        """Return the list of libraries to link against when building a
-        shared extension.  On most platforms, this is just 'ext.libraries';
-        on Windows, we add the Python library (eg. python20.dll).
-        """
-        # The python library is always needed on Windows.  For MSVC, this
-        # is redundant, since the library is mentioned in a pragma in
-        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
-        # to need it mentioned explicitly, though, so that's what we do.
-        # Append '_d' to the python import library on debug builds.
-        if sys.platform == "win32":
-            from distutils._msvccompiler import MSVCCompiler
-            if not isinstance(self.compiler, MSVCCompiler):
-                template = "python%d%d"
-                if self.debug:
-                    template = template + '_d'
-                pythonlib = (template %
-                       (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-                # don't extend ext.libraries, it may be shared with other
-                # extensions, it is a reference to the original list
-                return ext.libraries + [pythonlib]
-            else:
-                return ext.libraries
-        elif sys.platform[:6] == "cygwin":
-            template = "python%d.%d"
-            pythonlib = (template %
-                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-            # don't extend ext.libraries, it may be shared with other
-            # extensions, it is a reference to the original list
-            return ext.libraries + [pythonlib]
-        elif sys.platform[:6] == "atheos":
-            from distutils import sysconfig
-
-            template = "python%d.%d"
-            pythonlib = (template %
-                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-            # Get SHLIBS from Makefile
-            extra = []
-            for lib in sysconfig.get_config_var('SHLIBS').split():
-                if lib.startswith('-l'):
-                    extra.append(lib[2:])
-                else:
-                    extra.append(lib)
-            # don't extend ext.libraries, it may be shared with other
-            # extensions, it is a reference to the original list
-            return ext.libraries + [pythonlib, "m"] + extra
-        elif sys.platform == 'darwin':
-            # Don't use the default code below
-            return ext.libraries
-        elif sys.platform[:3] == 'aix':
-            # Don't use the default code below
-            return ext.libraries
-        else:
-            from distutils import sysconfig
-            if False and sysconfig.get_config_var('Py_ENABLE_SHARED'):
-                pythonlib = 'python{}.{}{}'.format(
-                    sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff,
-                    sysconfig.get_config_var('ABIFLAGS'))
-                return ext.libraries + [pythonlib]
-            else:
-                return ext.libraries
diff --git a/Lib/distutils/command/build_py.py b/Lib/distutils/command/build_py.py
deleted file mode 100644
index cf0ca57c320..00000000000
--- a/Lib/distutils/command/build_py.py
+++ /dev/null
@@ -1,416 +0,0 @@
-"""distutils.command.build_py
-
-Implements the Distutils 'build_py' command."""
-
-import os
-import importlib.util
-import sys
-from glob import glob
-
-from distutils.core import Command
-from distutils.errors import *
-from distutils.util import convert_path, Mixin2to3
-from distutils import log
-
-class build_py (Command):
-
-    description = "\"build\" pure Python modules (copy to build directory)"
-
-    user_options = [
-        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
-        ('compile', 'c', "compile .py to .pyc"),
-        ('no-compile', None, "don't compile .py files [default]"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
-        ]
-
-    boolean_options = ['compile', 'force']
-    negative_opt = {'no-compile' : 'compile'}
-
-    def initialize_options(self):
-        self.build_lib = None
-        self.py_modules = None
-        self.package = None
-        self.package_data = None
-        self.package_dir = None
-        self.compile = 0
-        self.optimize = 0
-        self.force = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_lib', 'build_lib'),
-                                   ('force', 'force'))
-
-        # Get the distribution options that are aliases for build_py
-        # options -- list of packages and list of modules.
-        self.packages = self.distribution.packages
-        self.py_modules = self.distribution.py_modules
-        self.package_data = self.distribution.package_data
-        self.package_dir = {}
-        if self.distribution.package_dir:
-            for name, path in self.distribution.package_dir.items():
-                self.package_dir[name] = convert_path(path)
-        self.data_files = self.get_data_files()
-
-        # Ick, copied straight from install_lib.py (fancy_getopt needs a
-        # type system!  Hell, *everything* needs a type system!!!)
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                assert 0 <= self.optimize <= 2
-            except (ValueError, AssertionError):
-                raise DistutilsOptionError("optimize must be 0, 1, or 2")
-
-    def run(self):
-        # XXX copy_file by default preserves atime and mtime.  IMHO this is
-        # the right thing to do, but perhaps it should be an option -- in
-        # particular, a site administrator might want installed files to
-        # reflect the time of installation rather than the last
-        # modification time before the installed release.
-
-        # XXX copy_file by default preserves mode, which appears to be the
-        # wrong thing to do: if a file is read-only in the working
-        # directory, we want it to be installed read/write so that the next
-        # installation of the same module distribution can overwrite it
-        # without problems.  (This might be a Unix-specific issue.)  Thus
-        # we turn off 'preserve_mode' when copying to the build directory,
-        # since the build directory is supposed to be exactly what the
-        # installation will look like (ie. we preserve mode when
-        # installing).
-
-        # Two options control which modules will be installed: 'packages'
-        # and 'py_modules'.  The former lets us work with whole packages, not
-        # specifying individual modules at all; the latter is for
-        # specifying modules one-at-a-time.
-
-        if self.py_modules:
-            self.build_modules()
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        self.byte_compile(self.get_outputs(include_bytecode=0))
-
-    def get_data_files(self):
-        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
-        data = []
-        if not self.packages:
-            return data
-        for package in self.packages:
-            # Locate package source directory
-            src_dir = self.get_package_dir(package)
-
-            # Compute package build directory
-            build_dir = os.path.join(*([self.build_lib] + package.split('.')))
-
-            # Length of path to strip from found files
-            plen = 0
-            if src_dir:
-                plen = len(src_dir)+1
-
-            # Strip directory from globbed filenames
-            filenames = [
-                file[plen:] for file in self.find_data_files(package, src_dir)
-                ]
-            data.append((package, src_dir, build_dir, filenames))
-        return data
-
-    def find_data_files(self, package, src_dir):
-        """Return filenames for package's data files in 'src_dir'"""
-        globs = (self.package_data.get('', [])
-                 + self.package_data.get(package, []))
-        files = []
-        for pattern in globs:
-            # Each pattern has to be converted to a platform-specific path
-            filelist = glob(os.path.join(src_dir, convert_path(pattern)))
-            # Files that match more than one pattern are only added once
-            files.extend([fn for fn in filelist if fn not in files
-                and os.path.isfile(fn)])
-        return files
-
-    def build_package_data(self):
-        """Copy data files into build directory"""
-        lastdir = None
-        for package, src_dir, build_dir, filenames in self.data_files:
-            for filename in filenames:
-                target = os.path.join(build_dir, filename)
-                self.mkpath(os.path.dirname(target))
-                self.copy_file(os.path.join(src_dir, filename), target,
-                               preserve_mode=False)
-
-    def get_package_dir(self, package):
-        """Return the directory, relative to the top of the source
-           distribution, where package 'package' should be found
-           (at least according to the 'package_dir' option, if any)."""
-        path = package.split('.')
-
-        if not self.package_dir:
-            if path:
-                return os.path.join(*path)
-            else:
-                return ''
-        else:
-            tail = []
-            while path:
-                try:
-                    pdir = self.package_dir['.'.join(path)]
-                except KeyError:
-                    tail.insert(0, path[-1])
-                    del path[-1]
-                else:
-                    tail.insert(0, pdir)
-                    return os.path.join(*tail)
-            else:
-                # Oops, got all the way through 'path' without finding a
-                # match in package_dir.  If package_dir defines a directory
-                # for the root (nameless) package, then fallback on it;
-                # otherwise, we might as well have not consulted
-                # package_dir at all, as we just use the directory implied
-                # by 'tail' (which should be the same as the original value
-                # of 'path' at this point).
-                pdir = self.package_dir.get('')
-                if pdir is not None:
-                    tail.insert(0, pdir)
-
-                if tail:
-                    return os.path.join(*tail)
-                else:
-                    return ''
-
-    def check_package(self, package, package_dir):
-        # Empty dir name means current directory, which we can probably
-        # assume exists.  Also, os.path.exists and isdir don't know about
-        # my "empty string means current dir" convention, so we have to
-        # circumvent them.
-        if package_dir != "":
-            if not os.path.exists(package_dir):
-                raise DistutilsFileError(
-                      "package directory '%s' does not exist" % package_dir)
-            if not os.path.isdir(package_dir):
-                raise DistutilsFileError(
-                       "supposed package directory '%s' exists, "
-                       "but is not a directory" % package_dir)
-
-        # Require __init__.py for all but the "root package"
-        if package:
-            init_py = os.path.join(package_dir, "__init__.py")
-            if os.path.isfile(init_py):
-                return init_py
-            else:
-                log.warn(("package init file '%s' not found " +
-                          "(or not a regular file)"), init_py)
-
-        # Either not in a package at all (__init__.py not expected), or
-        # __init__.py doesn't exist -- so don't return the filename.
-        return None
-
-    def check_module(self, module, module_file):
-        if not os.path.isfile(module_file):
-            log.warn("file %s (for module %s) not found", module_file, module)
-            return False
-        else:
-            return True
-
-    def find_package_modules(self, package, package_dir):
-        self.check_package(package, package_dir)
-        module_files = glob(os.path.join(package_dir, "*.py"))
-        modules = []
-        setup_script = os.path.abspath(self.distribution.script_name)
-
-        for f in module_files:
-            abs_f = os.path.abspath(f)
-            if abs_f != setup_script:
-                module = os.path.splitext(os.path.basename(f))[0]
-                modules.append((package, module, f))
-            else:
-                self.debug_print("excluding %s" % setup_script)
-        return modules
-
-    def find_modules(self):
-        """Finds individually-specified Python modules, ie. those listed by
-        module name in 'self.py_modules'.  Returns a list of tuples (package,
-        module_base, filename): 'package' is a tuple of the path through
-        package-space to the module; 'module_base' is the bare (no
-        packages, no dots) module name, and 'filename' is the path to the
-        ".py" file (relative to the distribution root) that implements the
-        module.
-        """
-        # Map package names to tuples of useful info about the package:
-        #    (package_dir, checked)
-        # package_dir - the directory where we'll find source files for
-        #   this package
-        # checked - true if we have checked that the package directory
-        #   is valid (exists, contains __init__.py, ... ?)
-        packages = {}
-
-        # List of (package, module, filename) tuples to return
-        modules = []
-
-        # We treat modules-in-packages almost the same as toplevel modules,
-        # just the "package" for a toplevel is empty (either an empty
-        # string or empty list, depending on context).  Differences:
-        #   - don't check for __init__.py in directory for empty package
-        for module in self.py_modules:
-            path = module.split('.')
-            package = '.'.join(path[0:-1])
-            module_base = path[-1]
-
-            try:
-                (package_dir, checked) = packages[package]
-            except KeyError:
-                package_dir = self.get_package_dir(package)
-                checked = 0
-
-            if not checked:
-                init_py = self.check_package(package, package_dir)
-                packages[package] = (package_dir, 1)
-                if init_py:
-                    modules.append((package, "__init__", init_py))
-
-            # XXX perhaps we should also check for just .pyc files
-            # (so greedy closed-source bastards can distribute Python
-            # modules too)
-            module_file = os.path.join(package_dir, module_base + ".py")
-            if not self.check_module(module, module_file):
-                continue
-
-            modules.append((package, module_base, module_file))
-
-        return modules
-
-    def find_all_modules(self):
-        """Compute the list of all modules that will be built, whether
-        they are specified one-module-at-a-time ('self.py_modules') or
-        by whole packages ('self.packages').  Return a list of tuples
-        (package, module, module_file), just like 'find_modules()' and
-        'find_package_modules()' do."""
-        modules = []
-        if self.py_modules:
-            modules.extend(self.find_modules())
-        if self.packages:
-            for package in self.packages:
-                package_dir = self.get_package_dir(package)
-                m = self.find_package_modules(package, package_dir)
-                modules.extend(m)
-        return modules
-
-    def get_source_files(self):
-        return [module[-1] for module in self.find_all_modules()]
-
-    def get_module_outfile(self, build_dir, package, module):
-        outfile_path = [build_dir] + list(package) + [module + ".py"]
-        return os.path.join(*outfile_path)
-
-    def get_outputs(self, include_bytecode=1):
-        modules = self.find_all_modules()
-        outputs = []
-        for (package, module, module_file) in modules:
-            package = package.split('.')
-            filename = self.get_module_outfile(self.build_lib, package, module)
-            outputs.append(filename)
-            if include_bytecode:
-                if self.compile:
-                    outputs.append(importlib.util.cache_from_source(
-                        filename, optimization=''))
-                if self.optimize > 0:
-                    outputs.append(importlib.util.cache_from_source(
-                        filename, optimization=self.optimize))
-
-        outputs += [
-            os.path.join(build_dir, filename)
-            for package, src_dir, build_dir, filenames in self.data_files
-            for filename in filenames
-            ]
-
-        return outputs
-
-    def build_module(self, module, module_file, package):
-        if isinstance(package, str):
-            package = package.split('.')
-        elif not isinstance(package, (list, tuple)):
-            raise TypeError(
-                  "'package' must be a string (dot-separated), list, or tuple")
-
-        # Now put the module source file into the "build" area -- this is
-        # easy, we just copy it somewhere under self.build_lib (the build
-        # directory for Python source).
-        outfile = self.get_module_outfile(self.build_lib, package, module)
-        dir = os.path.dirname(outfile)
-        self.mkpath(dir)
-        return self.copy_file(module_file, outfile, preserve_mode=0)
-
-    def build_modules(self):
-        modules = self.find_modules()
-        for (package, module, module_file) in modules:
-            # Now "build" the module -- ie. copy the source file to
-            # self.build_lib (the build directory for Python source).
-            # (Actually, it gets copied to the directory for this package
-            # under self.build_lib.)
-            self.build_module(module, module_file, package)
-
-    def build_packages(self):
-        for package in self.packages:
-            # Get list of (package, module, module_file) tuples based on
-            # scanning the package directory.  'package' is only included
-            # in the tuple so that 'find_modules()' and
-            # 'find_package_tuples()' have a consistent interface; it's
-            # ignored here (apart from a sanity check).  Also, 'module' is
-            # the *unqualified* module name (ie. no dots, no package -- we
-            # already know its package!), and 'module_file' is the path to
-            # the .py file, relative to the current directory
-            # (ie. including 'package_dir').
-            package_dir = self.get_package_dir(package)
-            modules = self.find_package_modules(package, package_dir)
-
-            # Now loop over the modules we found, "building" each one (just
-            # copy it to self.build_lib).
-            for (package_, module, module_file) in modules:
-                assert package == package_
-                self.build_module(module, module_file, package)
-
-    def byte_compile(self, files):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-        prefix = self.build_lib
-        if prefix[-1] != os.sep:
-            prefix = prefix + os.sep
-
-        # XXX this code is essentially the same as the 'byte_compile()
-        # method of the "install_lib" command, except for the determination
-        # of the 'prefix' string.  Hmmm.
-        if self.compile:
-            byte_compile(files, optimize=0,
-                         force=self.force, prefix=prefix, dry_run=self.dry_run)
-        if self.optimize > 0:
-            byte_compile(files, optimize=self.optimize,
-                         force=self.force, prefix=prefix, dry_run=self.dry_run)
-
-class build_py_2to3(build_py, Mixin2to3):
-    def run(self):
-        self.updated_files = []
-
-        # Base class code
-        if self.py_modules:
-            self.build_modules()
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        # 2to3
-        self.run_2to3(self.updated_files)
-
-        # Remaining base class code
-        self.byte_compile(self.get_outputs(include_bytecode=0))
-
-    def build_module(self, module, module_file, package):
-        res = build_py.build_module(self, module, module_file, package)
-        if res[1]:
-            # file was copied
-            self.updated_files.append(res[0])
-        return res
diff --git a/Lib/distutils/command/build_scripts.py b/Lib/distutils/command/build_scripts.py
deleted file mode 100644
index ccc70e64650..00000000000
--- a/Lib/distutils/command/build_scripts.py
+++ /dev/null
@@ -1,160 +0,0 @@
-"""distutils.command.build_scripts
-
-Implements the Distutils 'build_scripts' command."""
-
-import os, re
-from stat import ST_MODE
-from distutils import sysconfig
-from distutils.core import Command
-from distutils.dep_util import newer
-from distutils.util import convert_path, Mixin2to3
-from distutils import log
-import tokenize
-
-# check if Python is called on the first line with this expression
-first_line_re = re.compile(b'^#!.*python[0-9.]*([ \t].*)?$')
-
-class build_scripts(Command):
-
-    description = "\"build\" scripts (copy and fixup #! line)"
-
-    user_options = [
-        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
-        ('force', 'f', "forcibly build everything (ignore file timestamps"),
-        ('executable=', 'e', "specify final destination interpreter path"),
-        ]
-
-    boolean_options = ['force']
-
-
-    def initialize_options(self):
-        self.build_dir = None
-        self.scripts = None
-        self.force = None
-        self.executable = None
-        self.outfiles = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_scripts', 'build_dir'),
-                                   ('force', 'force'),
-                                   ('executable', 'executable'))
-        self.scripts = self.distribution.scripts
-
-    def get_source_files(self):
-        return self.scripts
-
-    def run(self):
-        if not self.scripts:
-            return
-        self.copy_scripts()
-
-
-    def copy_scripts(self):
-        r"""Copy each script listed in 'self.scripts'; if it's marked as a
-        Python script in the Unix way (first line matches 'first_line_re',
-        ie. starts with "\#!" and contains "python"), then adjust the first
-        line to refer to the current Python interpreter as we copy.
-        """
-        self.mkpath(self.build_dir)
-        outfiles = []
-        updated_files = []
-        for script in self.scripts:
-            adjust = False
-            script = convert_path(script)
-            outfile = os.path.join(self.build_dir, os.path.basename(script))
-            outfiles.append(outfile)
-
-            if not self.force and not newer(script, outfile):
-                log.debug("not copying %s (up-to-date)", script)
-                continue
-
-            # Always open the file, but ignore failures in dry-run mode --
-            # that way, we'll get accurate feedback if we can read the
-            # script.
-            try:
-                f = open(script, "rb")
-            except OSError:
-                if not self.dry_run:
-                    raise
-                f = None
-            else:
-                encoding, lines = tokenize.detect_encoding(f.readline)
-                f.seek(0)
-                first_line = f.readline()
-                if not first_line:
-                    self.warn("%s is an empty file (skipping)" % script)
-                    continue
-
-                match = first_line_re.match(first_line)
-                if match:
-                    adjust = True
-                    post_interp = match.group(1) or b''
-
-            if adjust:
-                log.info("copying and adjusting %s -> %s", script,
-                         self.build_dir)
-                updated_files.append(outfile)
-                if not self.dry_run:
-                    if not sysconfig.python_build:
-                        executable = self.executable
-                    else:
-                        executable = os.path.join(
-                            sysconfig.get_config_var("BINDIR"),
-                           "python%s%s" % (sysconfig.get_config_var("VERSION"),
-                                           sysconfig.get_config_var("EXE")))
-                    executable = os.fsencode(executable)
-                    shebang = b"#!" + executable + post_interp + b"\n"
-                    # Python parser starts to read a script using UTF-8 until
-                    # it gets a #coding:xxx cookie. The shebang has to be the
-                    # first line of a file, the #coding:xxx cookie cannot be
-                    # written before. So the shebang has to be decodable from
-                    # UTF-8.
-                    try:
-                        shebang.decode('utf-8')
-                    except UnicodeDecodeError:
-                        raise ValueError(
-                            "The shebang ({!r}) is not decodable "
-                            "from utf-8".format(shebang))
-                    # If the script is encoded to a custom encoding (use a
-                    # #coding:xxx cookie), the shebang has to be decodable from
-                    # the script encoding too.
-                    try:
-                        shebang.decode(encoding)
-                    except UnicodeDecodeError:
-                        raise ValueError(
-                            "The shebang ({!r}) is not decodable "
-                            "from the script encoding ({})"
-                            .format(shebang, encoding))
-                    with open(outfile, "wb") as outf:
-                        outf.write(shebang)
-                        outf.writelines(f.readlines())
-                if f:
-                    f.close()
-            else:
-                if f:
-                    f.close()
-                updated_files.append(outfile)
-                self.copy_file(script, outfile)
-
-        if os.name == 'posix':
-            for file in outfiles:
-                if self.dry_run:
-                    log.info("changing mode of %s", file)
-                else:
-                    oldmode = os.stat(file)[ST_MODE] & 0o7777
-                    newmode = (oldmode | 0o555) & 0o7777
-                    if newmode != oldmode:
-                        log.info("changing mode of %s from %o to %o",
-                                 file, oldmode, newmode)
-                        os.chmod(file, newmode)
-        # XXX should we modify self.outfiles?
-        return outfiles, updated_files
-
-class build_scripts_2to3(build_scripts, Mixin2to3):
-
-    def copy_scripts(self):
-        outfiles, updated_files = build_scripts.copy_scripts(self)
-        if not self.dry_run:
-            self.run_2to3(updated_files)
-        return outfiles, updated_files
diff --git a/Lib/distutils/command/check.py b/Lib/distutils/command/check.py
deleted file mode 100644
index 7ebe707cff4..00000000000
--- a/Lib/distutils/command/check.py
+++ /dev/null
@@ -1,145 +0,0 @@
-"""distutils.command.check
-
-Implements the Distutils 'check' command.
-"""
-from distutils.core import Command
-from distutils.errors import DistutilsSetupError
-
-try:
-    # docutils is installed
-    from docutils.utils import Reporter
-    from docutils.parsers.rst import Parser
-    from docutils import frontend
-    from docutils import nodes
-    from io import StringIO
-
-    class SilentReporter(Reporter):
-
-        def __init__(self, source, report_level, halt_level, stream=None,
-                     debug=0, encoding='ascii', error_handler='replace'):
-            self.messages = []
-            Reporter.__init__(self, source, report_level, halt_level, stream,
-                              debug, encoding, error_handler)
-
-        def system_message(self, level, message, *children, **kwargs):
-            self.messages.append((level, message, children, kwargs))
-            return nodes.system_message(message, level=level,
-                                        type=self.levels[level],
-                                        *children, **kwargs)
-
-    HAS_DOCUTILS = True
-except Exception:
-    # Catch all exceptions because exceptions besides ImportError probably
-    # indicate that docutils is not ported to Py3k.
-    HAS_DOCUTILS = False
-
-class check(Command):
-    """This command checks the meta-data of the package.
-    """
-    description = ("perform some checks on the package")
-    user_options = [('metadata', 'm', 'Verify meta-data'),
-                    ('restructuredtext', 'r',
-                     ('Checks if long string meta-data syntax '
-                      'are reStructuredText-compliant')),
-                    ('strict', 's',
-                     'Will exit with an error if a check fails')]
-
-    boolean_options = ['metadata', 'restructuredtext', 'strict']
-
-    def initialize_options(self):
-        """Sets default values for options."""
-        self.restructuredtext = 0
-        self.metadata = 1
-        self.strict = 0
-        self._warnings = 0
-
-    def finalize_options(self):
-        pass
-
-    def warn(self, msg):
-        """Counts the number of warnings that occurs."""
-        self._warnings += 1
-        return Command.warn(self, msg)
-
-    def run(self):
-        """Runs the command."""
-        # perform the various tests
-        if self.metadata:
-            self.check_metadata()
-        if self.restructuredtext:
-            if HAS_DOCUTILS:
-                self.check_restructuredtext()
-            elif self.strict:
-                raise DistutilsSetupError('The docutils package is needed.')
-
-        # let's raise an error in strict mode, if we have at least
-        # one warning
-        if self.strict and self._warnings > 0:
-            raise DistutilsSetupError('Please correct your package.')
-
-    def check_metadata(self):
-        """Ensures that all required elements of meta-data are supplied.
-
-        name, version, URL, (author and author_email) or
-        (maintainer and maintainer_email)).
-
-        Warns if any are missing.
-        """
-        metadata = self.distribution.metadata
-
-        missing = []
-        for attr in ('name', 'version', 'url'):
-            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
-                missing.append(attr)
-
-        if missing:
-            self.warn("missing required meta-data: %s"  % ', '.join(missing))
-        if metadata.author:
-            if not metadata.author_email:
-                self.warn("missing meta-data: if 'author' supplied, " +
-                          "'author_email' must be supplied too")
-        elif metadata.maintainer:
-            if not metadata.maintainer_email:
-                self.warn("missing meta-data: if 'maintainer' supplied, " +
-                          "'maintainer_email' must be supplied too")
-        else:
-            self.warn("missing meta-data: either (author and author_email) " +
-                      "or (maintainer and maintainer_email) " +
-                      "must be supplied")
-
-    def check_restructuredtext(self):
-        """Checks if the long string fields are reST-compliant."""
-        data = self.distribution.get_long_description()
-        for warning in self._check_rst_data(data):
-            line = warning[-1].get('line')
-            if line is None:
-                warning = warning[1]
-            else:
-                warning = '%s (line %s)' % (warning[1], line)
-            self.warn(warning)
-
-    def _check_rst_data(self, data):
-        """Returns warnings when the provided data doesn't compile."""
-        source_path = StringIO()
-        parser = Parser()
-        settings = frontend.OptionParser(components=(Parser,)).get_default_values()
-        settings.tab_width = 4
-        settings.pep_references = None
-        settings.rfc_references = None
-        reporter = SilentReporter(source_path,
-                          settings.report_level,
-                          settings.halt_level,
-                          stream=settings.warning_stream,
-                          debug=settings.debug,
-                          encoding=settings.error_encoding,
-                          error_handler=settings.error_encoding_error_handler)
-
-        document = nodes.document(settings, reporter, source=source_path)
-        document.note_source(source_path, -1)
-        try:
-            parser.parse(data, document)
-        except AttributeError as e:
-            reporter.messages.append(
-                (-1, 'Could not finish the parsing: %s.' % e, '', {}))
-
-        return reporter.messages
diff --git a/Lib/distutils/command/clean.py b/Lib/distutils/command/clean.py
deleted file mode 100644
index 0cb27016621..00000000000
--- a/Lib/distutils/command/clean.py
+++ /dev/null
@@ -1,76 +0,0 @@
-"""distutils.command.clean
-
-Implements the Distutils 'clean' command."""
-
-# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
-
-import os
-from distutils.core import Command
-from distutils.dir_util import remove_tree
-from distutils import log
-
-class clean(Command):
-
-    description = "clean up temporary files from 'build' command"
-    user_options = [
-        ('build-base=', 'b',
-         "base build directory (default: 'build.build-base')"),
-        ('build-lib=', None,
-         "build directory for all modules (default: 'build.build-lib')"),
-        ('build-temp=', 't',
-         "temporary build directory (default: 'build.build-temp')"),
-        ('build-scripts=', None,
-         "build directory for scripts (default: 'build.build-scripts')"),
-        ('bdist-base=', None,
-         "temporary directory for built distributions"),
-        ('all', 'a',
-         "remove all build output, not just temporary by-products")
-    ]
-
-    boolean_options = ['all']
-
-    def initialize_options(self):
-        self.build_base = None
-        self.build_lib = None
-        self.build_temp = None
-        self.build_scripts = None
-        self.bdist_base = None
-        self.all = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_base', 'build_base'),
-                                   ('build_lib', 'build_lib'),
-                                   ('build_scripts', 'build_scripts'),
-                                   ('build_temp', 'build_temp'))
-        self.set_undefined_options('bdist',
-                                   ('bdist_base', 'bdist_base'))
-
-    def run(self):
-        # remove the build/temp.<plat> directory (unless it's already
-        # gone)
-        if os.path.exists(self.build_temp):
-            remove_tree(self.build_temp, dry_run=self.dry_run)
-        else:
-            log.debug("'%s' does not exist -- can't clean it",
-                      self.build_temp)
-
-        if self.all:
-            # remove build directories
-            for directory in (self.build_lib,
-                              self.bdist_base,
-                              self.build_scripts):
-                if os.path.exists(directory):
-                    remove_tree(directory, dry_run=self.dry_run)
-                else:
-                    log.warn("'%s' does not exist -- can't clean it",
-                             directory)
-
-        # just for the heck of it, try to remove the base build directory:
-        # we might have emptied it right now, but if not we don't care
-        if not self.dry_run:
-            try:
-                os.rmdir(self.build_base)
-                log.info("removing '%s'", self.build_base)
-            except OSError:
-                pass
diff --git a/Lib/distutils/command/command_template b/Lib/distutils/command/command_template
deleted file mode 100644
index 6106819db84..00000000000
--- a/Lib/distutils/command/command_template
+++ /dev/null
@@ -1,33 +0,0 @@
-"""distutils.command.x
-
-Implements the Distutils 'x' command.
-"""
-
-# created 2000/mm/dd, John Doe
-
-__revision__ = "$Id$"
-
-from distutils.core import Command
-
-
-class x(Command):
-
-    # Brief (40-50 characters) description of the command
-    description = ""
-
-    # List of option tuples: long name, short name (None if no short
-    # name), and help string.
-    user_options = [('', '',
-                     ""),
-                   ]
-
-    def initialize_options(self):
-        self. = None
-        self. = None
-        self. = None
-
-    def finalize_options(self):
-        if self.x is None:
-            self.x = 
-
-    def run(self):
diff --git a/Lib/distutils/command/config.py b/Lib/distutils/command/config.py
deleted file mode 100644
index 4ae153d1943..00000000000
--- a/Lib/distutils/command/config.py
+++ /dev/null
@@ -1,347 +0,0 @@
-"""distutils.command.config
-
-Implements the Distutils 'config' command, a (mostly) empty command class
-that exists mainly to be sub-classed by specific module distributions and
-applications.  The idea is that while every "config" command is different,
-at least they're all named the same, and users always see "config" in the
-list of standard commands.  Also, this is a good place to put common
-configure-like tasks: "try to compile this C code", or "figure out where
-this header file lives".
-"""
-
-import os, re
-
-from distutils.core import Command
-from distutils.errors import DistutilsExecError
-from distutils.sysconfig import customize_compiler
-from distutils import log
-
-LANG_EXT = {"c": ".c", "c++": ".cxx"}
-
-class config(Command):
-
-    description = "prepare to build"
-
-    user_options = [
-        ('compiler=', None,
-         "specify the compiler type"),
-        ('cc=', None,
-         "specify the compiler executable"),
-        ('include-dirs=', 'I',
-         "list of directories to search for header files"),
-        ('define=', 'D',
-         "C preprocessor macros to define"),
-        ('undef=', 'U',
-         "C preprocessor macros to undefine"),
-        ('libraries=', 'l',
-         "external C libraries to link with"),
-        ('library-dirs=', 'L',
-         "directories to search for external C libraries"),
-
-        ('noisy', None,
-         "show every action (compile, link, run, ...) taken"),
-        ('dump-source', None,
-         "dump generated source files before attempting to compile them"),
-        ]
-
-
-    # The three standard command methods: since the "config" command
-    # does nothing by default, these are empty.
-
-    def initialize_options(self):
-        self.compiler = None
-        self.cc = None
-        self.include_dirs = None
-        self.libraries = None
-        self.library_dirs = None
-
-        # maximal output for now
-        self.noisy = 1
-        self.dump_source = 1
-
-        # list of temporary files generated along-the-way that we have
-        # to clean at some point
-        self.temp_files = []
-
-    def finalize_options(self):
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        elif isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        if self.libraries is None:
-            self.libraries = []
-        elif isinstance(self.libraries, str):
-            self.libraries = [self.libraries]
-
-        if self.library_dirs is None:
-            self.library_dirs = []
-        elif isinstance(self.library_dirs, str):
-            self.library_dirs = self.library_dirs.split(os.pathsep)
-
-    def run(self):
-        pass
-
-    # Utility methods for actual "config" commands.  The interfaces are
-    # loosely based on Autoconf macros of similar names.  Sub-classes
-    # may use these freely.
-
-    def _check_compiler(self):
-        """Check that 'self.compiler' really is a CCompiler object;
-        if not, make it one.
-        """
-        # We do this late, and only on-demand, because this is an expensive
-        # import.
-        from distutils.ccompiler import CCompiler, new_compiler
-        if not isinstance(self.compiler, CCompiler):
-            self.compiler = new_compiler(compiler=self.compiler,
-                                         dry_run=self.dry_run, force=1)
-            customize_compiler(self.compiler)
-            if self.include_dirs:
-                self.compiler.set_include_dirs(self.include_dirs)
-            if self.libraries:
-                self.compiler.set_libraries(self.libraries)
-            if self.library_dirs:
-                self.compiler.set_library_dirs(self.library_dirs)
-
-    def _gen_temp_sourcefile(self, body, headers, lang):
-        filename = "_configtest" + LANG_EXT[lang]
-        file = open(filename, "w")
-        if headers:
-            for header in headers:
-                file.write("#include <%s>\n" % header)
-            file.write("\n")
-        file.write(body)
-        if body[-1] != "\n":
-            file.write("\n")
-        file.close()
-        return filename
-
-    def _preprocess(self, body, headers, include_dirs, lang):
-        src = self._gen_temp_sourcefile(body, headers, lang)
-        out = "_configtest.i"
-        self.temp_files.extend([src, out])
-        self.compiler.preprocess(src, out, include_dirs=include_dirs)
-        return (src, out)
-
-    def _compile(self, body, headers, include_dirs, lang):
-        src = self._gen_temp_sourcefile(body, headers, lang)
-        if self.dump_source:
-            dump_file(src, "compiling '%s':" % src)
-        (obj,) = self.compiler.object_filenames([src])
-        self.temp_files.extend([src, obj])
-        self.compiler.compile([src], include_dirs=include_dirs)
-        return (src, obj)
-
-    def _link(self, body, headers, include_dirs, libraries, library_dirs,
-              lang):
-        (src, obj) = self._compile(body, headers, include_dirs, lang)
-        prog = os.path.splitext(os.path.basename(src))[0]
-        self.compiler.link_executable([obj], prog,
-                                      libraries=libraries,
-                                      library_dirs=library_dirs,
-                                      target_lang=lang)
-
-        if self.compiler.exe_extension is not None:
-            prog = prog + self.compiler.exe_extension
-        self.temp_files.append(prog)
-
-        return (src, obj, prog)
-
-    def _clean(self, *filenames):
-        if not filenames:
-            filenames = self.temp_files
-            self.temp_files = []
-        log.info("removing: %s", ' '.join(filenames))
-        for filename in filenames:
-            try:
-                os.remove(filename)
-            except OSError:
-                pass
-
-
-    # XXX these ignore the dry-run flag: what to do, what to do? even if
-    # you want a dry-run build, you still need some sort of configuration
-    # info.  My inclination is to make it up to the real config command to
-    # consult 'dry_run', and assume a default (minimal) configuration if
-    # true.  The problem with trying to do it here is that you'd have to
-    # return either true or false from all the 'try' methods, neither of
-    # which is correct.
-
-    # XXX need access to the header search path and maybe default macros.
-
-    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
-        """Construct a source file from 'body' (a string containing lines
-        of C/C++ code) and 'headers' (a list of header files to include)
-        and run it through the preprocessor.  Return true if the
-        preprocessor succeeded, false if there were any errors.
-        ('body' probably isn't of much use, but what the heck.)
-        """
-        from distutils.ccompiler import CompileError
-        self._check_compiler()
-        ok = True
-        try:
-            self._preprocess(body, headers, include_dirs, lang)
-        except CompileError:
-            ok = False
-
-        self._clean()
-        return ok
-
-    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
-                   lang="c"):
-        """Construct a source file (just like 'try_cpp()'), run it through
-        the preprocessor, and return true if any line of the output matches
-        'pattern'.  'pattern' should either be a compiled regex object or a
-        string containing a regex.  If both 'body' and 'headers' are None,
-        preprocesses an empty file -- which can be useful to determine the
-        symbols the preprocessor and compiler set by default.
-        """
-        self._check_compiler()
-        src, out = self._preprocess(body, headers, include_dirs, lang)
-
-        if isinstance(pattern, str):
-            pattern = re.compile(pattern)
-
-        file = open(out)
-        match = False
-        while True:
-            line = file.readline()
-            if line == '':
-                break
-            if pattern.search(line):
-                match = True
-                break
-
-        file.close()
-        self._clean()
-        return match
-
-    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
-        """Try to compile a source file built from 'body' and 'headers'.
-        Return true on success, false otherwise.
-        """
-        from distutils.ccompiler import CompileError
-        self._check_compiler()
-        try:
-            self._compile(body, headers, include_dirs, lang)
-            ok = True
-        except CompileError:
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-    def try_link(self, body, headers=None, include_dirs=None, libraries=None,
-                 library_dirs=None, lang="c"):
-        """Try to compile and link a source file, built from 'body' and
-        'headers', to executable form.  Return true on success, false
-        otherwise.
-        """
-        from distutils.ccompiler import CompileError, LinkError
-        self._check_compiler()
-        try:
-            self._link(body, headers, include_dirs,
-                       libraries, library_dirs, lang)
-            ok = True
-        except (CompileError, LinkError):
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-    def try_run(self, body, headers=None, include_dirs=None, libraries=None,
-                library_dirs=None, lang="c"):
-        """Try to compile, link to an executable, and run a program
-        built from 'body' and 'headers'.  Return true on success, false
-        otherwise.
-        """
-        from distutils.ccompiler import CompileError, LinkError
-        self._check_compiler()
-        try:
-            src, obj, exe = self._link(body, headers, include_dirs,
-                                       libraries, library_dirs, lang)
-            self.spawn([exe])
-            ok = True
-        except (CompileError, LinkError, DistutilsExecError):
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-
-    # -- High-level methods --------------------------------------------
-    # (these are the ones that are actually likely to be useful
-    # when implementing a real-world config command!)
-
-    def check_func(self, func, headers=None, include_dirs=None,
-                   libraries=None, library_dirs=None, decl=0, call=0):
-        """Determine if function 'func' is available by constructing a
-        source file that refers to 'func', and compiles and links it.
-        If everything succeeds, returns true; otherwise returns false.
-
-        The constructed source file starts out by including the header
-        files listed in 'headers'.  If 'decl' is true, it then declares
-        'func' (as "int func()"); you probably shouldn't supply 'headers'
-        and set 'decl' true in the same call, or you might get errors about
-        a conflicting declarations for 'func'.  Finally, the constructed
-        'main()' function either references 'func' or (if 'call' is true)
-        calls it.  'libraries' and 'library_dirs' are used when
-        linking.
-        """
-        self._check_compiler()
-        body = []
-        if decl:
-            body.append("int %s ();" % func)
-        body.append("int main () {")
-        if call:
-            body.append("  %s();" % func)
-        else:
-            body.append("  %s;" % func)
-        body.append("}")
-        body = "\n".join(body) + "\n"
-
-        return self.try_link(body, headers, include_dirs,
-                             libraries, library_dirs)
-
-    def check_lib(self, library, library_dirs=None, headers=None,
-                  include_dirs=None, other_libraries=[]):
-        """Determine if 'library' is available to be linked against,
-        without actually checking that any particular symbols are provided
-        by it.  'headers' will be used in constructing the source file to
-        be compiled, but the only effect of this is to check if all the
-        header files listed are available.  Any libraries listed in
-        'other_libraries' will be included in the link, in case 'library'
-        has symbols that depend on other libraries.
-        """
-        self._check_compiler()
-        return self.try_link("int main (void) { }", headers, include_dirs,
-                             [library] + other_libraries, library_dirs)
-
-    def check_header(self, header, include_dirs=None, library_dirs=None,
-                     lang="c"):
-        """Determine if the system header file named by 'header_file'
-        exists and can be found by the preprocessor; return true if so,
-        false otherwise.
-        """
-        return self.try_cpp(body="/* No body */", headers=[header],
-                            include_dirs=include_dirs)
-
-
-def dump_file(filename, head=None):
-    """Dumps a file content into log.info.
-
-    If head is not None, will be dumped before the file content.
-    """
-    if head is None:
-        log.info('%s', filename)
-    else:
-        log.info(head)
-    file = open(filename)
-    try:
-        log.info(file.read())
-    finally:
-        file.close()
diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py
deleted file mode 100644
index fd3357ea78e..00000000000
--- a/Lib/distutils/command/install.py
+++ /dev/null
@@ -1,705 +0,0 @@
-"""distutils.command.install
-
-Implements the Distutils 'install' command."""
-
-import sys
-import os
-
-from distutils import log
-from distutils.core import Command
-from distutils.debug import DEBUG
-from distutils.sysconfig import get_config_vars
-from distutils.errors import DistutilsPlatformError
-from distutils.file_util import write_file
-from distutils.util import convert_path, subst_vars, change_root
-from distutils.util import get_platform
-from distutils.errors import DistutilsOptionError
-
-from site import USER_BASE
-from site import USER_SITE
-HAS_USER_SITE = True
-
-WINDOWS_SCHEME = {
-    'purelib': '$base/Lib/site-packages',
-    'platlib': '$base/Lib/site-packages',
-    'headers': '$base/Include/$dist_name',
-    'scripts': '$base/Scripts',
-    'data'   : '$base',
-}
-
-INSTALL_SCHEMES = {
-    'unix_prefix': {
-        'purelib': '$base/lib/python$py_version_short/site-packages',
-        'platlib': '$platbase/lib/python$py_version_short/site-packages',
-        'headers': '$base/include/python$py_version_short$abiflags/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'unix_local': {
-        'purelib': '$base/local/lib/python$py_version_short/dist-packages',
-        'platlib': '$platbase/local/lib/python$py_version_short/dist-packages',
-        'headers': '$base/local/include/python$py_version_short/$dist_name',
-        'scripts': '$base/local/bin',
-        'data'   : '$base/local',
-        },
-    'deb_system': {
-        'purelib': '$base/lib/python3/dist-packages',
-        'platlib': '$platbase/lib/python3/dist-packages',
-        'headers': '$base/include/python$py_version_short/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'unix_home': {
-        'purelib': '$base/lib/python',
-        'platlib': '$base/lib/python',
-        'headers': '$base/include/python/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'nt': WINDOWS_SCHEME,
-    }
-
-# user site schemes
-if HAS_USER_SITE:
-    INSTALL_SCHEMES['nt_user'] = {
-        'purelib': '$usersite',
-        'platlib': '$usersite',
-        'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
-        'scripts': '$userbase/Python$py_version_nodot/Scripts',
-        'data'   : '$userbase',
-        }
-
-    INSTALL_SCHEMES['unix_user'] = {
-        'purelib': '$usersite',
-        'platlib': '$usersite',
-        'headers':
-            '$userbase/include/python$py_version_short$abiflags/$dist_name',
-        'scripts': '$userbase/bin',
-        'data'   : '$userbase',
-        }
-
-# XXX RUSTPYTHON: replace python with rustpython in all these paths
-for group in INSTALL_SCHEMES.values():
-    for key in group.keys():
-        group[key] = group[key].replace("Python", "RustPython").replace("python", "rustpython")
-
-# The keys to an installation scheme; if any new types of files are to be
-# installed, be sure to add an entry to every installation scheme above,
-# and to SCHEME_KEYS here.
-SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
-
-
-class install(Command):
-
-    description = "install everything from build directory"
-
-    user_options = [
-        # Select installation scheme and set base director(y|ies)
-        ('prefix=', None,
-         "installation prefix"),
-        ('exec-prefix=', None,
-         "(Unix only) prefix for platform-specific files"),
-        ('home=', None,
-         "(Unix only) home directory to install under"),
-
-        # Or, just set the base director(y|ies)
-        ('install-base=', None,
-         "base installation directory (instead of --prefix or --home)"),
-        ('install-platbase=', None,
-         "base installation directory for platform-specific files " +
-         "(instead of --exec-prefix or --home)"),
-        ('root=', None,
-         "install everything relative to this alternate root directory"),
-
-        # Or, explicitly set the installation scheme
-        ('install-purelib=', None,
-         "installation directory for pure Python module distributions"),
-        ('install-platlib=', None,
-         "installation directory for non-pure module distributions"),
-        ('install-lib=', None,
-         "installation directory for all module distributions " +
-         "(overrides --install-purelib and --install-platlib)"),
-
-        ('install-headers=', None,
-         "installation directory for C/C++ headers"),
-        ('install-scripts=', None,
-         "installation directory for Python scripts"),
-        ('install-data=', None,
-         "installation directory for data files"),
-
-        # Byte-compilation options -- see install_lib.py for details, as
-        # these are duplicated from there (but only install_lib does
-        # anything with them).
-        ('compile', 'c', "compile .py to .pyc [default]"),
-        ('no-compile', None, "don't compile .py files"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-
-        # Miscellaneous control options
-        ('force', 'f',
-         "force installation (overwrite any existing files)"),
-        ('skip-build', None,
-         "skip rebuilding everything (for testing/debugging)"),
-
-        # Where to install documentation (eventually!)
-        #('doc-format=', None, "format of documentation to generate"),
-        #('install-man=', None, "directory for Unix man pages"),
-        #('install-html=', None, "directory for HTML documentation"),
-        #('install-info=', None, "directory for GNU info files"),
-
-        ('record=', None,
-         "filename in which to record list of installed files"),
-
-        ('install-layout=', None,
-         "installation layout to choose (known values: deb, unix)"),
-        ]
-
-    boolean_options = ['compile', 'force', 'skip-build']
-
-    if HAS_USER_SITE:
-        user_options.append(('user', None,
-                             "install in user site-package '%s'" % USER_SITE))
-        boolean_options.append('user')
-
-    negative_opt = {'no-compile' : 'compile'}
-
-
-    def initialize_options(self):
-        """Initializes options."""
-        # High-level options: these select both an installation base
-        # and scheme.
-        self.prefix = None
-        self.exec_prefix = None
-        self.home = None
-        self.user = 0
-        self.prefix_option = None
-
-        # These select only the installation base; it's up to the user to
-        # specify the installation scheme (currently, that means supplying
-        # the --install-{platlib,purelib,scripts,data} options).
-        self.install_base = None
-        self.install_platbase = None
-        self.root = None
-
-        # These options are the actual installation directories; if not
-        # supplied by the user, they are filled in using the installation
-        # scheme implied by prefix/exec-prefix/home and the contents of
-        # that installation scheme.
-        self.install_purelib = None     # for pure module distributions
-        self.install_platlib = None     # non-pure (dists w/ extensions)
-        self.install_headers = None     # for C/C++ headers
-        self.install_lib = None         # set to either purelib or platlib
-        self.install_scripts = None
-        self.install_data = None
-        self.install_userbase = USER_BASE
-        self.install_usersite = USER_SITE
-
-        # enable custom installation, known values: deb
-        self.install_layout = None
-        self.multiarch = None
-        
-        self.compile = None
-        self.optimize = None
-
-        # Deprecated
-        # These two are for putting non-packagized distributions into their
-        # own directory and creating a .pth file if it makes sense.
-        # 'extra_path' comes from the setup file; 'install_path_file' can
-        # be turned off if it makes no sense to install a .pth file.  (But
-        # better to install it uselessly than to guess wrong and not
-        # install it when it's necessary and would be used!)  Currently,
-        # 'install_path_file' is always true unless some outsider meddles
-        # with it.
-        self.extra_path = None
-        self.install_path_file = 1
-
-        # 'force' forces installation, even if target files are not
-        # out-of-date.  'skip_build' skips running the "build" command,
-        # handy if you know it's not necessary.  'warn_dir' (which is *not*
-        # a user option, it's just there so the bdist_* commands can turn
-        # it off) determines whether we warn about installing to a
-        # directory not in sys.path.
-        self.force = 0
-        self.skip_build = 0
-        self.warn_dir = 1
-
-        # These are only here as a conduit from the 'build' command to the
-        # 'install_*' commands that do the real work.  ('build_base' isn't
-        # actually used anywhere, but it might be useful in future.)  They
-        # are not user options, because if the user told the install
-        # command where the build directory is, that wouldn't affect the
-        # build command.
-        self.build_base = None
-        self.build_lib = None
-
-        # Not defined yet because we don't know anything about
-        # documentation yet.
-        #self.install_man = None
-        #self.install_html = None
-        #self.install_info = None
-
-        self.record = None
-
-
-    # -- Option finalizing methods -------------------------------------
-    # (This is rather more involved than for most commands,
-    # because this is where the policy for installing third-
-    # party Python modules on various platforms given a wide
-    # array of user input is decided.  Yes, it's quite complex!)
-
-    def finalize_options(self):
-        """Finalizes options."""
-        # This method (and its pliant slaves, like 'finalize_unix()',
-        # 'finalize_other()', and 'select_scheme()') is where the default
-        # installation directories for modules, extension modules, and
-        # anything else we care to install from a Python module
-        # distribution.  Thus, this code makes a pretty important policy
-        # statement about how third-party stuff is added to a Python
-        # installation!  Note that the actual work of installation is done
-        # by the relatively simple 'install_*' commands; they just take
-        # their orders from the installation directory options determined
-        # here.
-
-        # Check for errors/inconsistencies in the options; first, stuff
-        # that's wrong on any platform.
-
-        if ((self.prefix or self.exec_prefix or self.home) and
-            (self.install_base or self.install_platbase)):
-            raise DistutilsOptionError(
-                   "must supply either prefix/exec-prefix/home or " +
-                   "install-base/install-platbase -- not both")
-
-        if self.home and (self.prefix or self.exec_prefix):
-            raise DistutilsOptionError(
-                  "must supply either home or prefix/exec-prefix -- not both")
-
-        if self.user and (self.prefix or self.exec_prefix or self.home or
-                self.install_base or self.install_platbase):
-            raise DistutilsOptionError("can't combine user with prefix, "
-                                       "exec_prefix/home, or install_(plat)base")
-
-        # Next, stuff that's wrong (or dubious) only on certain platforms.
-        if os.name != "posix":
-            if self.exec_prefix:
-                self.warn("exec-prefix option ignored on this platform")
-                self.exec_prefix = None
-
-        # Now the interesting logic -- so interesting that we farm it out
-        # to other methods.  The goal of these methods is to set the final
-        # values for the install_{lib,scripts,data,...}  options, using as
-        # input a heady brew of prefix, exec_prefix, home, install_base,
-        # install_platbase, user-supplied versions of
-        # install_{purelib,platlib,lib,scripts,data,...}, and the
-        # INSTALL_SCHEME dictionary above.  Phew!
-
-        self.dump_dirs("pre-finalize_{unix,other}")
-
-        if os.name == 'posix':
-            self.finalize_unix()
-        else:
-            self.finalize_other()
-
-        self.dump_dirs("post-finalize_{unix,other}()")
-
-        # Expand configuration variables, tilde, etc. in self.install_base
-        # and self.install_platbase -- that way, we can use $base or
-        # $platbase in the other installation directories and not worry
-        # about needing recursive variable expansion (shudder).
-
-        py_version = sys.version.split()[0]
-        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
-        try:
-            abiflags = sys.abiflags
-        except AttributeError:
-            # sys.abiflags may not be defined on all platforms.
-            abiflags = ''
-        self.config_vars = {'dist_name': self.distribution.get_name(),
-                            'dist_version': self.distribution.get_version(),
-                            'dist_fullname': self.distribution.get_fullname(),
-                            'py_version': py_version,
-                            'py_version_short': '%d.%d' % sys.version_info[:2],
-                            'py_version_nodot': '%d%d' % sys.version_info[:2],
-                            'sys_prefix': prefix,
-                            'prefix': prefix,
-                            'sys_exec_prefix': exec_prefix,
-                            'exec_prefix': exec_prefix,
-                            'abiflags': abiflags,
-                           }
-
-        if HAS_USER_SITE:
-            self.config_vars['userbase'] = self.install_userbase
-            self.config_vars['usersite'] = self.install_usersite
-
-        self.expand_basedirs()
-
-        self.dump_dirs("post-expand_basedirs()")
-
-        # Now define config vars for the base directories so we can expand
-        # everything else.
-        self.config_vars['base'] = self.install_base
-        self.config_vars['platbase'] = self.install_platbase
-
-        if DEBUG:
-            from pprint import pprint
-            print("config vars:")
-            pprint(self.config_vars)
-
-        # Expand "~" and configuration variables in the installation
-        # directories.
-        self.expand_dirs()
-
-        self.dump_dirs("post-expand_dirs()")
-
-        # Create directories in the home dir:
-        if self.user:
-            self.create_home_path()
-
-        # Pick the actual directory to install all modules to: either
-        # install_purelib or install_platlib, depending on whether this
-        # module distribution is pure or not.  Of course, if the user
-        # already specified install_lib, use their selection.
-        if self.install_lib is None:
-            if self.distribution.ext_modules: # has extensions: non-pure
-                self.install_lib = self.install_platlib
-            else:
-                self.install_lib = self.install_purelib
-
-
-        # Convert directories from Unix /-separated syntax to the local
-        # convention.
-        self.convert_paths('lib', 'purelib', 'platlib',
-                           'scripts', 'data', 'headers',
-                           'userbase', 'usersite')
-
-        # Deprecated
-        # Well, we're not actually fully completely finalized yet: we still
-        # have to deal with 'extra_path', which is the hack for allowing
-        # non-packagized module distributions (hello, Numerical Python!) to
-        # get their own directories.
-        self.handle_extra_path()
-        self.install_libbase = self.install_lib # needed for .pth file
-        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
-
-        # If a new root directory was supplied, make all the installation
-        # dirs relative to it.
-        if self.root is not None:
-            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
-                              'scripts', 'data', 'headers')
-
-        self.dump_dirs("after prepending root")
-
-        # Find out the build directories, ie. where to install from.
-        self.set_undefined_options('build',
-                                   ('build_base', 'build_base'),
-                                   ('build_lib', 'build_lib'))
-
-        # Punt on doc directories for now -- after all, we're punting on
-        # documentation completely!
-
-    def dump_dirs(self, msg):
-        """Dumps the list of user options."""
-        if not DEBUG:
-            return
-        from distutils.fancy_getopt import longopt_xlate
-        log.debug(msg + ":")
-        for opt in self.user_options:
-            opt_name = opt[0]
-            if opt_name[-1] == "=":
-                opt_name = opt_name[0:-1]
-            if opt_name in self.negative_opt:
-                opt_name = self.negative_opt[opt_name]
-                opt_name = opt_name.translate(longopt_xlate)
-                val = not getattr(self, opt_name)
-            else:
-                opt_name = opt_name.translate(longopt_xlate)
-                val = getattr(self, opt_name)
-            log.debug("  %s: %s", opt_name, val)
-
-    def finalize_unix(self):
-        """Finalizes options for posix platforms."""
-        if self.install_base is not None or self.install_platbase is not None:
-            if ((self.install_lib is None and
-                 self.install_purelib is None and
-                 self.install_platlib is None) or
-                self.install_headers is None or
-                self.install_scripts is None or
-                self.install_data is None):
-                raise DistutilsOptionError(
-                      "install-base or install-platbase supplied, but "
-                      "installation scheme is incomplete")
-            return
-
-        if self.user:
-            if self.install_userbase is None:
-                raise DistutilsPlatformError(
-                    "User base directory is not specified")
-            self.install_base = self.install_platbase = self.install_userbase
-            self.select_scheme("unix_user")
-        elif self.home is not None:
-            self.install_base = self.install_platbase = self.home
-            self.select_scheme("unix_home")
-        else:
-            self.prefix_option = self.prefix
-            if self.prefix is None:
-                if self.exec_prefix is not None:
-                    raise DistutilsOptionError(
-                          "must not supply exec-prefix without prefix")
-
-                self.prefix = os.path.normpath(sys.prefix)
-                self.exec_prefix = os.path.normpath(sys.exec_prefix)
-
-            else:
-                if self.exec_prefix is None:
-                    self.exec_prefix = self.prefix
-
-            self.install_base = self.prefix
-            self.install_platbase = self.exec_prefix
-            if self.install_layout:
-                if self.install_layout.lower() in ['deb']:
-                    import sysconfig
-                    self.multiarch = sysconfig.get_config_var('MULTIARCH')
-                    self.select_scheme("deb_system")
-                elif self.install_layout.lower() in ['unix']:
-                    self.select_scheme("unix_prefix")
-                else:
-                    raise DistutilsOptionError(
-                        "unknown value for --install-layout")
-            elif ((self.prefix_option and
-                   os.path.normpath(self.prefix) != '/usr/local')
-                  or sys.base_prefix != sys.prefix
-                  or 'PYTHONUSERBASE' in os.environ
-                  or 'VIRTUAL_ENV' in os.environ
-                  or 'real_prefix' in sys.__dict__):
-                self.select_scheme("unix_prefix")
-            else:
-                if os.path.normpath(self.prefix) == '/usr/local':
-                    self.prefix = self.exec_prefix = '/usr'
-                    self.install_base = self.install_platbase = '/usr'
-                self.select_scheme("unix_local")
-
-    def finalize_other(self):
-        """Finalizes options for non-posix platforms"""
-        if self.user:
-            if self.install_userbase is None:
-                raise DistutilsPlatformError(
-                    "User base directory is not specified")
-            self.install_base = self.install_platbase = self.install_userbase
-            self.select_scheme(os.name + "_user")
-        elif self.home is not None:
-            self.install_base = self.install_platbase = self.home
-            self.select_scheme("unix_home")
-        else:
-            if self.prefix is None:
-                self.prefix = os.path.normpath(sys.prefix)
-
-            self.install_base = self.install_platbase = self.prefix
-            try:
-                self.select_scheme(os.name)
-            except KeyError:
-                raise DistutilsPlatformError(
-                      "I don't know how to install stuff on '%s'" % os.name)
-
-    def select_scheme(self, name):
-        """Sets the install directories by applying the install schemes."""
-        # it's the caller's problem if they supply a bad name!
-        scheme = INSTALL_SCHEMES[name]
-        for key in SCHEME_KEYS:
-            attrname = 'install_' + key
-            if getattr(self, attrname) is None:
-                setattr(self, attrname, scheme[key])
-
-    def _expand_attrs(self, attrs):
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                if os.name == 'posix' or os.name == 'nt':
-                    val = os.path.expanduser(val)
-                val = subst_vars(val, self.config_vars)
-                setattr(self, attr, val)
-
-    def expand_basedirs(self):
-        """Calls `os.path.expanduser` on install_base, install_platbase and
-        root."""
-        self._expand_attrs(['install_base', 'install_platbase', 'root'])
-
-    def expand_dirs(self):
-        """Calls `os.path.expanduser` on install dirs."""
-        self._expand_attrs(['install_purelib', 'install_platlib',
-                            'install_lib', 'install_headers',
-                            'install_scripts', 'install_data',])
-
-    def convert_paths(self, *names):
-        """Call `convert_path` over `names`."""
-        for name in names:
-            attr = "install_" + name
-            setattr(self, attr, convert_path(getattr(self, attr)))
-
-    def handle_extra_path(self):
-        """Set `path_file` and `extra_dirs` using `extra_path`."""
-        if self.extra_path is None:
-            self.extra_path = self.distribution.extra_path
-
-        if self.extra_path is not None:
-            log.warn(
-                "Distribution option extra_path is deprecated. "
-                "See issue27919 for details."
-            )
-            if isinstance(self.extra_path, str):
-                self.extra_path = self.extra_path.split(',')
-
-            if len(self.extra_path) == 1:
-                path_file = extra_dirs = self.extra_path[0]
-            elif len(self.extra_path) == 2:
-                path_file, extra_dirs = self.extra_path
-            else:
-                raise DistutilsOptionError(
-                      "'extra_path' option must be a list, tuple, or "
-                      "comma-separated string with 1 or 2 elements")
-
-            # convert to local form in case Unix notation used (as it
-            # should be in setup scripts)
-            extra_dirs = convert_path(extra_dirs)
-        else:
-            path_file = None
-            extra_dirs = ''
-
-        # XXX should we warn if path_file and not extra_dirs? (in which
-        # case the path file would be harmless but pointless)
-        self.path_file = path_file
-        self.extra_dirs = extra_dirs
-
-    def change_roots(self, *names):
-        """Change the install directories pointed by name using root."""
-        for name in names:
-            attr = "install_" + name
-            setattr(self, attr, change_root(self.root, getattr(self, attr)))
-
-    def create_home_path(self):
-        """Create directories under ~."""
-        if not self.user:
-            return
-        home = convert_path(os.path.expanduser("~"))
-        for name, path in self.config_vars.items():
-            if path.startswith(home) and not os.path.isdir(path):
-                self.debug_print("os.makedirs('%s', 0o700)" % path)
-                os.makedirs(path, 0o700)
-
-    # -- Command execution methods -------------------------------------
-
-    def run(self):
-        """Runs the command."""
-        # Obviously have to build before we can install
-        if not self.skip_build:
-            self.run_command('build')
-            # If we built for any other platform, we can't install.
-            build_plat = self.distribution.get_command_obj('build').plat_name
-            # check warn_dir - it is a clue that the 'install' is happening
-            # internally, and not to sys.path, so we don't check the platform
-            # matches what we are running.
-            if self.warn_dir and build_plat != get_platform():
-                raise DistutilsPlatformError("Can't install when "
-                                             "cross-compiling")
-
-        # Run all sub-commands (at least those that need to be run)
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        if self.path_file:
-            self.create_path_file()
-
-        # write list of installed files, if requested.
-        if self.record:
-            outputs = self.get_outputs()
-            if self.root:               # strip any package prefix
-                root_len = len(self.root)
-                for counter in range(len(outputs)):
-                    outputs[counter] = outputs[counter][root_len:]
-            self.execute(write_file,
-                         (self.record, outputs),
-                         "writing list of installed files to '%s'" %
-                         self.record)
-
-        sys_path = map(os.path.normpath, sys.path)
-        sys_path = map(os.path.normcase, sys_path)
-        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
-        if (self.warn_dir and
-            not (self.path_file and self.install_path_file) and
-            install_lib not in sys_path):
-            log.debug(("modules installed to '%s', which is not in "
-                       "Python's module search path (sys.path) -- "
-                       "you'll have to change the search path yourself"),
-                       self.install_lib)
-
-    def create_path_file(self):
-        """Creates the .pth file"""
-        filename = os.path.join(self.install_libbase,
-                                self.path_file + ".pth")
-        if self.install_path_file:
-            self.execute(write_file,
-                         (filename, [self.extra_dirs]),
-                         "creating %s" % filename)
-        else:
-            self.warn("path file '%s' not created" % filename)
-
-
-    # -- Reporting methods ---------------------------------------------
-
-    def get_outputs(self):
-        """Assembles the outputs of all the sub-commands."""
-        outputs = []
-        for cmd_name in self.get_sub_commands():
-            cmd = self.get_finalized_command(cmd_name)
-            # Add the contents of cmd.get_outputs(), ensuring
-            # that outputs doesn't contain duplicate entries
-            for filename in cmd.get_outputs():
-                if filename not in outputs:
-                    outputs.append(filename)
-
-        if self.path_file and self.install_path_file:
-            outputs.append(os.path.join(self.install_libbase,
-                                        self.path_file + ".pth"))
-
-        return outputs
-
-    def get_inputs(self):
-        """Returns the inputs of all the sub-commands"""
-        # XXX gee, this looks familiar ;-(
-        inputs = []
-        for cmd_name in self.get_sub_commands():
-            cmd = self.get_finalized_command(cmd_name)
-            inputs.extend(cmd.get_inputs())
-
-        return inputs
-
-    # -- Predicates for sub-command list -------------------------------
-
-    def has_lib(self):
-        """Returns true if the current distribution has any Python
-        modules to install."""
-        return (self.distribution.has_pure_modules() or
-                self.distribution.has_ext_modules())
-
-    def has_headers(self):
-        """Returns true if the current distribution has any headers to
-        install."""
-        return self.distribution.has_headers()
-
-    def has_scripts(self):
-        """Returns true if the current distribution has any scripts to.
-        install."""
-        return self.distribution.has_scripts()
-
-    def has_data(self):
-        """Returns true if the current distribution has any data to.
-        install."""
-        return self.distribution.has_data_files()
-
-    # 'sub_commands': a list of commands this command might have to run to
-    # get its work done.  See cmd.py for more info.
-    sub_commands = [('install_lib',     has_lib),
-                    ('install_headers', has_headers),
-                    ('install_scripts', has_scripts),
-                    ('install_data',    has_data),
-                    ('install_egg_info', lambda self:True),
-                   ]
diff --git a/Lib/distutils/command/install_data.py b/Lib/distutils/command/install_data.py
deleted file mode 100644
index 947cd76a99e..00000000000
--- a/Lib/distutils/command/install_data.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""distutils.command.install_data
-
-Implements the Distutils 'install_data' command, for installing
-platform-independent data files."""
-
-# contributed by Bastian Kleineidam
-
-import os
-from distutils.core import Command
-from distutils.util import change_root, convert_path
-
-class install_data(Command):
-
-    description = "install data files"
-
-    user_options = [
-        ('install-dir=', 'd',
-         "base directory for installing data files "
-         "(default: installation base dir)"),
-        ('root=', None,
-         "install everything relative to this alternate root directory"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ]
-
-    boolean_options = ['force']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.outfiles = []
-        self.root = None
-        self.force = 0
-        self.data_files = self.distribution.data_files
-        self.warn_dir = 1
-
-    def finalize_options(self):
-        self.set_undefined_options('install',
-                                   ('install_data', 'install_dir'),
-                                   ('root', 'root'),
-                                   ('force', 'force'),
-                                  )
-
-    def run(self):
-        self.mkpath(self.install_dir)
-        for f in self.data_files:
-            if isinstance(f, str):
-                # it's a simple file, so copy it
-                f = convert_path(f)
-                if self.warn_dir:
-                    self.warn("setup script did not provide a directory for "
-                              "'%s' -- installing right in '%s'" %
-                              (f, self.install_dir))
-                (out, _) = self.copy_file(f, self.install_dir)
-                self.outfiles.append(out)
-            else:
-                # it's a tuple with path to install to and a list of files
-                dir = convert_path(f[0])
-                if not os.path.isabs(dir):
-                    dir = os.path.join(self.install_dir, dir)
-                elif self.root:
-                    dir = change_root(self.root, dir)
-                self.mkpath(dir)
-
-                if f[1] == []:
-                    # If there are no files listed, the user must be
-                    # trying to create an empty directory, so add the
-                    # directory to the list of output files.
-                    self.outfiles.append(dir)
-                else:
-                    # Copy files, adding them to the list of output files.
-                    for data in f[1]:
-                        data = convert_path(data)
-                        (out, _) = self.copy_file(data, dir)
-                        self.outfiles.append(out)
-
-    def get_inputs(self):
-        return self.data_files or []
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/install_egg_info.py b/Lib/distutils/command/install_egg_info.py
deleted file mode 100644
index 0a71b610005..00000000000
--- a/Lib/distutils/command/install_egg_info.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""distutils.command.install_egg_info
-
-Implements the Distutils 'install_egg_info' command, for installing
-a package's PKG-INFO metadata."""
-
-
-from distutils.cmd import Command
-from distutils import log, dir_util
-import os, sys, re
-
-class install_egg_info(Command):
-    """Install an .egg-info file for the package"""
-
-    description = "Install package's PKG-INFO metadata as an .egg-info file"
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-        ('install-layout', None, "custom installation layout"),
-    ]
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.install_layout = None
-        self.prefix_option = None
-
-    def finalize_options(self):
-        self.set_undefined_options('install_lib',('install_dir','install_dir'))
-        self.set_undefined_options('install',('install_layout','install_layout'))
-        self.set_undefined_options('install',('prefix_option','prefix_option'))
-        if self.install_layout:
-            if not self.install_layout.lower() in ['deb', 'unix']:
-                raise DistutilsOptionError(
-                    "unknown value for --install-layout")
-            no_pyver = (self.install_layout.lower() == 'deb')
-        elif self.prefix_option:
-            no_pyver = False
-        else:
-            no_pyver = True
-        if no_pyver:
-            basename = "%s-%s.egg-info" % (
-                to_filename(safe_name(self.distribution.get_name())),
-                to_filename(safe_version(self.distribution.get_version()))
-                )
-        else:
-            basename = "%s-%s-py%d.%d.egg-info" % (
-                to_filename(safe_name(self.distribution.get_name())),
-                to_filename(safe_version(self.distribution.get_version())),
-                *sys.version_info[:2]
-            )
-        self.target = os.path.join(self.install_dir, basename)
-        self.outputs = [self.target]
-
-    def run(self):
-        target = self.target
-        if os.path.isdir(target) and not os.path.islink(target):
-            dir_util.remove_tree(target, dry_run=self.dry_run)
-        elif os.path.exists(target):
-            self.execute(os.unlink,(self.target,),"Removing "+target)
-        elif not os.path.isdir(self.install_dir):
-            self.execute(os.makedirs, (self.install_dir,),
-                         "Creating "+self.install_dir)
-        log.info("Writing %s", target)
-        if not self.dry_run:
-            with open(target, 'w', encoding='UTF-8') as f:
-                self.distribution.metadata.write_pkg_file(f)
-
-    def get_outputs(self):
-        return self.outputs
-
-
-# The following routines are taken from setuptools' pkg_resources module and
-# can be replaced by importing them from pkg_resources once it is included
-# in the stdlib.
-
-def safe_name(name):
-    """Convert an arbitrary string to a standard distribution name
-
-    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
-    """
-    return re.sub('[^A-Za-z0-9.]+', '-', name)
-
-
-def safe_version(version):
-    """Convert an arbitrary string to a standard version string
-
-    Spaces become dots, and all other non-alphanumeric characters become
-    dashes, with runs of multiple dashes condensed to a single dash.
-    """
-    version = version.replace(' ','.')
-    return re.sub('[^A-Za-z0-9.]+', '-', version)
-
-
-def to_filename(name):
-    """Convert a project or version name to its filename-escaped form
-
-    Any '-' characters are currently replaced with '_'.
-    """
-    return name.replace('-','_')
diff --git a/Lib/distutils/command/install_headers.py b/Lib/distutils/command/install_headers.py
deleted file mode 100644
index 9bb0b18dc0d..00000000000
--- a/Lib/distutils/command/install_headers.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""distutils.command.install_headers
-
-Implements the Distutils 'install_headers' command, to install C/C++ header
-files to the Python include directory."""
-
-from distutils.core import Command
-
-
-# XXX force is never used
-class install_headers(Command):
-
-    description = "install C/C++ header files"
-
-    user_options = [('install-dir=', 'd',
-                     "directory to install header files to"),
-                    ('force', 'f',
-                     "force installation (overwrite existing files)"),
-                   ]
-
-    boolean_options = ['force']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.force = 0
-        self.outfiles = []
-
-    def finalize_options(self):
-        self.set_undefined_options('install',
-                                   ('install_headers', 'install_dir'),
-                                   ('force', 'force'))
-
-
-    def run(self):
-        headers = self.distribution.headers
-        if not headers:
-            return
-
-        self.mkpath(self.install_dir)
-        for header in headers:
-            (out, _) = self.copy_file(header, self.install_dir)
-            self.outfiles.append(out)
-
-    def get_inputs(self):
-        return self.distribution.headers or []
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/install_lib.py b/Lib/distutils/command/install_lib.py
deleted file mode 100644
index eef63626ff7..00000000000
--- a/Lib/distutils/command/install_lib.py
+++ /dev/null
@@ -1,221 +0,0 @@
-"""distutils.command.install_lib
-
-Implements the Distutils 'install_lib' command
-(install all Python modules)."""
-
-import os
-import importlib.util
-import sys
-
-from distutils.core import Command
-from distutils.errors import DistutilsOptionError
-
-
-# Extension for Python source files.
-PYTHON_SOURCE_EXTENSION = ".py"
-
-class install_lib(Command):
-
-    description = "install all Python modules (extensions and pure Python)"
-
-    # The byte-compilation options are a tad confusing.  Here are the
-    # possible scenarios:
-    #   1) no compilation at all (--no-compile --no-optimize)
-    #   2) compile .pyc only (--compile --no-optimize; default)
-    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
-    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
-    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
-    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
-    #
-    # The UI for this is two options, 'compile' and 'optimize'.
-    # 'compile' is strictly boolean, and only decides whether to
-    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
-    # decides both whether to generate .pyc files and what level of
-    # optimization to use.
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-        ('build-dir=','b', "build directory (where to install from)"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ('compile', 'c', "compile .py to .pyc [default]"),
-        ('no-compile', None, "don't compile .py files"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('skip-build', None, "skip the build steps"),
-        ]
-
-    boolean_options = ['force', 'compile', 'skip-build']
-    negative_opt = {'no-compile' : 'compile'}
-
-    def initialize_options(self):
-        # let the 'install' command dictate our installation directory
-        self.install_dir = None
-        self.build_dir = None
-        self.force = 0
-        self.compile = None
-        self.optimize = None
-        self.skip_build = None
-        self.multiarch = None # if we should rename the extensions
-
-    def finalize_options(self):
-        # Get all the information we need to install pure Python modules
-        # from the umbrella 'install' command -- build (source) directory,
-        # install (target) directory, and whether to compile .py files.
-        self.set_undefined_options('install',
-                                   ('build_lib', 'build_dir'),
-                                   ('install_lib', 'install_dir'),
-                                   ('force', 'force'),
-                                   ('compile', 'compile'),
-                                   ('optimize', 'optimize'),
-                                   ('skip_build', 'skip_build'),
-                                   ('multiarch', 'multiarch'),
-                                  )
-
-        if self.compile is None:
-            self.compile = True
-        if self.optimize is None:
-            self.optimize = False
-
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                if self.optimize not in (0, 1, 2):
-                    raise AssertionError
-            except (ValueError, AssertionError):
-                raise DistutilsOptionError("optimize must be 0, 1, or 2")
-
-    def run(self):
-        # Make sure we have built everything we need first
-        self.build()
-
-        # Install everything: simply dump the entire contents of the build
-        # directory to the installation directory (that's the beauty of
-        # having a build directory!)
-        outfiles = self.install()
-
-        # (Optionally) compile .py to .pyc
-        if outfiles is not None and self.distribution.has_pure_modules():
-            self.byte_compile(outfiles)
-
-    # -- Top-level worker functions ------------------------------------
-    # (called from 'run()')
-
-    def build(self):
-        if not self.skip_build:
-            if self.distribution.has_pure_modules():
-                self.run_command('build_py')
-            if self.distribution.has_ext_modules():
-                self.run_command('build_ext')
-
-    def install(self):
-        if os.path.isdir(self.build_dir):
-            import distutils.dir_util
-            distutils.dir_util._multiarch = self.multiarch
-            outfiles = self.copy_tree(self.build_dir, self.install_dir)
-        else:
-            self.warn("'%s' does not exist -- no Python modules to install" %
-                      self.build_dir)
-            return
-        return outfiles
-
-    def byte_compile(self, files):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-
-        # Get the "--root" directory supplied to the "install" command,
-        # and use it as a prefix to strip off the purported filename
-        # encoded in bytecode files.  This is far from complete, but it
-        # should at least generate usable bytecode in RPM distributions.
-        install_root = self.get_finalized_command('install').root
-
-        if self.compile:
-            byte_compile(files, optimize=0,
-                         force=self.force, prefix=install_root,
-                         dry_run=self.dry_run)
-        if self.optimize > 0:
-            byte_compile(files, optimize=self.optimize,
-                         force=self.force, prefix=install_root,
-                         verbose=self.verbose, dry_run=self.dry_run)
-
-
-    # -- Utility methods -----------------------------------------------
-
-    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
-        if not has_any:
-            return []
-
-        build_cmd = self.get_finalized_command(build_cmd)
-        build_files = build_cmd.get_outputs()
-        build_dir = getattr(build_cmd, cmd_option)
-
-        prefix_len = len(build_dir) + len(os.sep)
-        outputs = []
-        for file in build_files:
-            outputs.append(os.path.join(output_dir, file[prefix_len:]))
-
-        return outputs
-
-    def _bytecode_filenames(self, py_filenames):
-        bytecode_files = []
-        for py_file in py_filenames:
-            # Since build_py handles package data installation, the
-            # list of outputs can contain more than just .py files.
-            # Make sure we only report bytecode for the .py files.
-            ext = os.path.splitext(os.path.normcase(py_file))[1]
-            if ext != PYTHON_SOURCE_EXTENSION:
-                continue
-            if self.compile:
-                bytecode_files.append(importlib.util.cache_from_source(
-                    py_file, optimization=''))
-            if self.optimize > 0:
-                bytecode_files.append(importlib.util.cache_from_source(
-                    py_file, optimization=self.optimize))
-
-        return bytecode_files
-
-
-    # -- External interface --------------------------------------------
-    # (called by outsiders)
-
-    def get_outputs(self):
-        """Return the list of files that would be installed if this command
-        were actually run.  Not affected by the "dry-run" flag or whether
-        modules have actually been built yet.
-        """
-        pure_outputs = \
-            self._mutate_outputs(self.distribution.has_pure_modules(),
-                                 'build_py', 'build_lib',
-                                 self.install_dir)
-        if self.compile:
-            bytecode_outputs = self._bytecode_filenames(pure_outputs)
-        else:
-            bytecode_outputs = []
-
-        ext_outputs = \
-            self._mutate_outputs(self.distribution.has_ext_modules(),
-                                 'build_ext', 'build_lib',
-                                 self.install_dir)
-
-        return pure_outputs + bytecode_outputs + ext_outputs
-
-    def get_inputs(self):
-        """Get the list of files that are input to this command, ie. the
-        files that get installed as they are named in the build tree.
-        The files in this list correspond one-to-one to the output
-        filenames returned by 'get_outputs()'.
-        """
-        inputs = []
-
-        if self.distribution.has_pure_modules():
-            build_py = self.get_finalized_command('build_py')
-            inputs.extend(build_py.get_outputs())
-
-        if self.distribution.has_ext_modules():
-            build_ext = self.get_finalized_command('build_ext')
-            inputs.extend(build_ext.get_outputs())
-
-        return inputs
diff --git a/Lib/distutils/command/install_scripts.py b/Lib/distutils/command/install_scripts.py
deleted file mode 100644
index 31a1130ee54..00000000000
--- a/Lib/distutils/command/install_scripts.py
+++ /dev/null
@@ -1,60 +0,0 @@
-"""distutils.command.install_scripts
-
-Implements the Distutils 'install_scripts' command, for installing
-Python scripts."""
-
-# contributed by Bastian Kleineidam
-
-import os
-from distutils.core import Command
-from distutils import log
-from stat import ST_MODE
-
-
-class install_scripts(Command):
-
-    description = "install scripts (Python or otherwise)"
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install scripts to"),
-        ('build-dir=','b', "build directory (where to install from)"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ('skip-build', None, "skip the build steps"),
-    ]
-
-    boolean_options = ['force', 'skip-build']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.force = 0
-        self.build_dir = None
-        self.skip_build = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
-        self.set_undefined_options('install',
-                                   ('install_scripts', 'install_dir'),
-                                   ('force', 'force'),
-                                   ('skip_build', 'skip_build'),
-                                  )
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build_scripts')
-        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
-        if os.name == 'posix':
-            # Set the executable bits (owner, group, and world) on
-            # all the scripts we just installed.
-            for file in self.get_outputs():
-                if self.dry_run:
-                    log.info("changing mode of %s", file)
-                else:
-                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
-                    log.info("changing mode of %s to %o", file, mode)
-                    os.chmod(file, mode)
-
-    def get_inputs(self):
-        return self.distribution.scripts or []
-
-    def get_outputs(self):
-        return self.outfiles or []
diff --git a/Lib/distutils/command/register.py b/Lib/distutils/command/register.py
deleted file mode 100644
index 0fac94e9e54..00000000000
--- a/Lib/distutils/command/register.py
+++ /dev/null
@@ -1,304 +0,0 @@
-"""distutils.command.register
-
-Implements the Distutils 'register' command (register with the repository).
-"""
-
-# created 2002/10/21, Richard Jones
-
-import getpass
-import io
-import urllib.parse, urllib.request
-from warnings import warn
-
-from distutils.core import PyPIRCCommand
-from distutils.errors import *
-from distutils import log
-
-class register(PyPIRCCommand):
-
-    description = ("register the distribution with the Python package index")
-    user_options = PyPIRCCommand.user_options + [
-        ('list-classifiers', None,
-         'list the valid Trove classifiers'),
-        ('strict', None ,
-         'Will stop the registering if the meta-data are not fully compliant')
-        ]
-    boolean_options = PyPIRCCommand.boolean_options + [
-        'verify', 'list-classifiers', 'strict']
-
-    sub_commands = [('check', lambda self: True)]
-
-    def initialize_options(self):
-        PyPIRCCommand.initialize_options(self)
-        self.list_classifiers = 0
-        self.strict = 0
-
-    def finalize_options(self):
-        PyPIRCCommand.finalize_options(self)
-        # setting options for the `check` subcommand
-        check_options = {'strict': ('register', self.strict),
-                         'restructuredtext': ('register', 1)}
-        self.distribution.command_options['check'] = check_options
-
-    def run(self):
-        self.finalize_options()
-        self._set_config()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        if self.dry_run:
-            self.verify_metadata()
-        elif self.list_classifiers:
-            self.classifiers()
-        else:
-            self.send_metadata()
-
-    def check_metadata(self):
-        """Deprecated API."""
-        warn("distutils.command.register.check_metadata is deprecated, \
-              use the check command instead", PendingDeprecationWarning)
-        check = self.distribution.get_command_obj('check')
-        check.ensure_finalized()
-        check.strict = self.strict
-        check.restructuredtext = 1
-        check.run()
-
-    def _set_config(self):
-        ''' Reads the configuration file and set attributes.
-        '''
-        config = self._read_pypirc()
-        if config != {}:
-            self.username = config['username']
-            self.password = config['password']
-            self.repository = config['repository']
-            self.realm = config['realm']
-            self.has_config = True
-        else:
-            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
-                raise ValueError('%s not found in .pypirc' % self.repository)
-            if self.repository == 'pypi':
-                self.repository = self.DEFAULT_REPOSITORY
-            self.has_config = False
-
-    def classifiers(self):
-        ''' Fetch the list of classifiers from the server.
-        '''
-        url = self.repository+'?:action=list_classifiers'
-        response = urllib.request.urlopen(url)
-        log.info(self._read_pypi_response(response))
-
-    def verify_metadata(self):
-        ''' Send the metadata to the package index server to be checked.
-        '''
-        # send the info to the server and report the result
-        (code, result) = self.post_to_server(self.build_post_data('verify'))
-        log.info('Server response (%s): %s', code, result)
-
-    def send_metadata(self):
-        ''' Send the metadata to the package index server.
-
-            Well, do the following:
-            1. figure who the user is, and then
-            2. send the data as a Basic auth'ed POST.
-
-            First we try to read the username/password from $HOME/.pypirc,
-            which is a ConfigParser-formatted file with a section
-            [distutils] containing username and password entries (both
-            in clear text). Eg:
-
-                [distutils]
-                index-servers =
-                    pypi
-
-                [pypi]
-                username: fred
-                password: sekrit
-
-            Otherwise, to figure who the user is, we offer the user three
-            choices:
-
-             1. use existing login,
-             2. register as a new user, or
-             3. set the password to a random string and email the user.
-
-        '''
-        # see if we can short-cut and get the username/password from the
-        # config
-        if self.has_config:
-            choice = '1'
-            username = self.username
-            password = self.password
-        else:
-            choice = 'x'
-            username = password = ''
-
-        # get the user's login info
-        choices = '1 2 3 4'.split()
-        while choice not in choices:
-            self.announce('''\
-We need to know who you are, so please choose either:
- 1. use your existing login,
- 2. register as a new user,
- 3. have the server generate a new password for you (and email it to you), or
- 4. quit
-Your selection [default 1]: ''', log.INFO)
-            choice = input()
-            if not choice:
-                choice = '1'
-            elif choice not in choices:
-                print('Please choose one of the four options!')
-
-        if choice == '1':
-            # get the username and password
-            while not username:
-                username = input('Username: ')
-            while not password:
-                password = getpass.getpass('Password: ')
-
-            # set up the authentication
-            auth = urllib.request.HTTPPasswordMgr()
-            host = urllib.parse.urlparse(self.repository)[1]
-            auth.add_password(self.realm, host, username, password)
-            # send the info to the server and report the result
-            code, result = self.post_to_server(self.build_post_data('submit'),
-                auth)
-            self.announce('Server response (%s): %s' % (code, result),
-                          log.INFO)
-
-            # possibly save the login
-            if code == 200:
-                if self.has_config:
-                    # sharing the password in the distribution instance
-                    # so the upload command can reuse it
-                    self.distribution.password = password
-                else:
-                    self.announce(('I can store your PyPI login so future '
-                                   'submissions will be faster.'), log.INFO)
-                    self.announce('(the login will be stored in %s)' % \
-                                  self._get_rc_file(), log.INFO)
-                    choice = 'X'
-                    while choice.lower() not in 'yn':
-                        choice = input('Save your login (y/N)?')
-                        if not choice:
-                            choice = 'n'
-                    if choice.lower() == 'y':
-                        self._store_pypirc(username, password)
-
-        elif choice == '2':
-            data = {':action': 'user'}
-            data['name'] = data['password'] = data['email'] = ''
-            data['confirm'] = None
-            while not data['name']:
-                data['name'] = input('Username: ')
-            while data['password'] != data['confirm']:
-                while not data['password']:
-                    data['password'] = getpass.getpass('Password: ')
-                while not data['confirm']:
-                    data['confirm'] = getpass.getpass(' Confirm: ')
-                if data['password'] != data['confirm']:
-                    data['password'] = ''
-                    data['confirm'] = None
-                    print("Password and confirm don't match!")
-            while not data['email']:
-                data['email'] = input('   EMail: ')
-            code, result = self.post_to_server(data)
-            if code != 200:
-                log.info('Server response (%s): %s', code, result)
-            else:
-                log.info('You will receive an email shortly.')
-                log.info(('Follow the instructions in it to '
-                          'complete registration.'))
-        elif choice == '3':
-            data = {':action': 'password_reset'}
-            data['email'] = ''
-            while not data['email']:
-                data['email'] = input('Your email address: ')
-            code, result = self.post_to_server(data)
-            log.info('Server response (%s): %s', code, result)
-
-    def build_post_data(self, action):
-        # figure the data to send - the metadata plus some additional
-        # information used by the package server
-        meta = self.distribution.metadata
-        data = {
-            ':action': action,
-            'metadata_version' : '1.0',
-            'name': meta.get_name(),
-            'version': meta.get_version(),
-            'summary': meta.get_description(),
-            'home_page': meta.get_url(),
-            'author': meta.get_contact(),
-            'author_email': meta.get_contact_email(),
-            'license': meta.get_licence(),
-            'description': meta.get_long_description(),
-            'keywords': meta.get_keywords(),
-            'platform': meta.get_platforms(),
-            'classifiers': meta.get_classifiers(),
-            'download_url': meta.get_download_url(),
-            # PEP 314
-            'provides': meta.get_provides(),
-            'requires': meta.get_requires(),
-            'obsoletes': meta.get_obsoletes(),
-        }
-        if data['provides'] or data['requires'] or data['obsoletes']:
-            data['metadata_version'] = '1.1'
-        return data
-
-    def post_to_server(self, data, auth=None):
-        ''' Post a query to the server, and return a string response.
-        '''
-        if 'name' in data:
-            self.announce('Registering %s to %s' % (data['name'],
-                                                    self.repository),
-                                                    log.INFO)
-        # Build up the MIME payload for the urllib2 POST data
-        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = '\n--' + boundary
-        end_boundary = sep_boundary + '--'
-        body = io.StringIO()
-        for key, value in data.items():
-            # handle multiple entries for the same name
-            if type(value) not in (type([]), type( () )):
-                value = [value]
-            for value in value:
-                value = str(value)
-                body.write(sep_boundary)
-                body.write('\nContent-Disposition: form-data; name="%s"'%key)
-                body.write("\n\n")
-                body.write(value)
-                if value and value[-1] == '\r':
-                    body.write('\n')  # write an extra newline (lurve Macs)
-        body.write(end_boundary)
-        body.write("\n")
-        body = body.getvalue().encode("utf-8")
-
-        # build the Request
-        headers = {
-            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
-            'Content-length': str(len(body))
-        }
-        req = urllib.request.Request(self.repository, body, headers)
-
-        # handle HTTP and include the Basic Auth handler
-        opener = urllib.request.build_opener(
-            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
-        )
-        data = ''
-        try:
-            result = opener.open(req)
-        except urllib.error.HTTPError as e:
-            if self.show_response:
-                data = e.fp.read()
-            result = e.code, e.msg
-        except urllib.error.URLError as e:
-            result = 500, str(e)
-        else:
-            if self.show_response:
-                data = self._read_pypi_response(result)
-            result = 200, 'OK'
-        if self.show_response:
-            msg = '\n'.join(('-' * 75, data, '-' * 75))
-            self.announce(msg, log.INFO)
-        return result
diff --git a/Lib/distutils/command/sdist.py b/Lib/distutils/command/sdist.py
deleted file mode 100644
index 4fd1d4715de..00000000000
--- a/Lib/distutils/command/sdist.py
+++ /dev/null
@@ -1,456 +0,0 @@
-"""distutils.command.sdist
-
-Implements the Distutils 'sdist' command (create a source distribution)."""
-
-import os
-import sys
-from types import *
-from glob import glob
-from warnings import warn
-
-from distutils.core import Command
-from distutils import dir_util, dep_util, file_util, archive_util
-from distutils.text_file import TextFile
-from distutils.errors import *
-from distutils.filelist import FileList
-from distutils import log
-from distutils.util import convert_path
-
-def show_formats():
-    """Print all possible values for the 'formats' option (used by
-    the "--help-formats" command-line option).
-    """
-    from distutils.fancy_getopt import FancyGetopt
-    from distutils.archive_util import ARCHIVE_FORMATS
-    formats = []
-    for format in ARCHIVE_FORMATS.keys():
-        formats.append(("formats=" + format, None,
-                        ARCHIVE_FORMATS[format][2]))
-    formats.sort()
-    FancyGetopt(formats).print_help(
-        "List of available source distribution formats:")
-
-class sdist(Command):
-
-    description = "create a source distribution (tarball, zip file, etc.)"
-
-    def checking_metadata(self):
-        """Callable used for the check sub-command.
-
-        Placed here so user_options can view it"""
-        return self.metadata_check
-
-    user_options = [
-        ('template=', 't',
-         "name of manifest template file [default: MANIFEST.in]"),
-        ('manifest=', 'm',
-         "name of manifest file [default: MANIFEST]"),
-        ('use-defaults', None,
-         "include the default file set in the manifest "
-         "[default; disable with --no-defaults]"),
-        ('no-defaults', None,
-         "don't include the default file set"),
-        ('prune', None,
-         "specifically exclude files/directories that should not be "
-         "distributed (build tree, RCS/CVS dirs, etc.) "
-         "[default; disable with --no-prune]"),
-        ('no-prune', None,
-         "don't automatically exclude anything"),
-        ('manifest-only', 'o',
-         "just regenerate the manifest and then stop "
-         "(implies --force-manifest)"),
-        ('force-manifest', 'f',
-         "forcibly regenerate the manifest and carry on as usual. "
-         "Deprecated: now the manifest is always regenerated."),
-        ('formats=', None,
-         "formats for source distribution (comma-separated list)"),
-        ('keep-temp', 'k',
-         "keep the distribution tree around after creating " +
-         "archive file(s)"),
-        ('dist-dir=', 'd',
-         "directory to put the source distribution archive(s) in "
-         "[default: dist]"),
-        ('metadata-check', None,
-         "Ensure that all required elements of meta-data "
-         "are supplied. Warn if any missing. [default]"),
-        ('owner=', 'u',
-         "Owner name used when creating a tar file [default: current user]"),
-        ('group=', 'g',
-         "Group name used when creating a tar file [default: current group]"),
-        ]
-
-    boolean_options = ['use-defaults', 'prune',
-                       'manifest-only', 'force-manifest',
-                       'keep-temp', 'metadata-check']
-
-    help_options = [
-        ('help-formats', None,
-         "list available distribution formats", show_formats),
-        ]
-
-    negative_opt = {'no-defaults': 'use-defaults',
-                    'no-prune': 'prune' }
-
-    sub_commands = [('check', checking_metadata)]
-
-    def initialize_options(self):
-        # 'template' and 'manifest' are, respectively, the names of
-        # the manifest template and manifest file.
-        self.template = None
-        self.manifest = None
-
-        # 'use_defaults': if true, we will include the default file set
-        # in the manifest
-        self.use_defaults = 1
-        self.prune = 1
-
-        self.manifest_only = 0
-        self.force_manifest = 0
-
-        self.formats = ['gztar']
-        self.keep_temp = 0
-        self.dist_dir = None
-
-        self.archive_files = None
-        self.metadata_check = 1
-        self.owner = None
-        self.group = None
-
-    def finalize_options(self):
-        if self.manifest is None:
-            self.manifest = "MANIFEST"
-        if self.template is None:
-            self.template = "MANIFEST.in"
-
-        self.ensure_string_list('formats')
-
-        bad_format = archive_util.check_archive_formats(self.formats)
-        if bad_format:
-            raise DistutilsOptionError(
-                  "unknown archive format '%s'" % bad_format)
-
-        if self.dist_dir is None:
-            self.dist_dir = "dist"
-
-    def run(self):
-        # 'filelist' contains the list of files that will make up the
-        # manifest
-        self.filelist = FileList()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        # Do whatever it takes to get the list of files to process
-        # (process the manifest template, read an existing manifest,
-        # whatever).  File list is accumulated in 'self.filelist'.
-        self.get_file_list()
-
-        # If user just wanted us to regenerate the manifest, stop now.
-        if self.manifest_only:
-            return
-
-        # Otherwise, go ahead and create the source distribution tarball,
-        # or zipfile, or whatever.
-        self.make_distribution()
-
-    def check_metadata(self):
-        """Deprecated API."""
-        warn("distutils.command.sdist.check_metadata is deprecated, \
-              use the check command instead", PendingDeprecationWarning)
-        check = self.distribution.get_command_obj('check')
-        check.ensure_finalized()
-        check.run()
-
-    def get_file_list(self):
-        """Figure out the list of files to include in the source
-        distribution, and put it in 'self.filelist'.  This might involve
-        reading the manifest template (and writing the manifest), or just
-        reading the manifest, or just using the default file set -- it all
-        depends on the user's options.
-        """
-        # new behavior when using a template:
-        # the file list is recalculated every time because
-        # even if MANIFEST.in or setup.py are not changed
-        # the user might have added some files in the tree that
-        # need to be included.
-        #
-        #  This makes --force the default and only behavior with templates.
-        template_exists = os.path.isfile(self.template)
-        if not template_exists and self._manifest_is_not_generated():
-            self.read_manifest()
-            self.filelist.sort()
-            self.filelist.remove_duplicates()
-            return
-
-        if not template_exists:
-            self.warn(("manifest template '%s' does not exist " +
-                        "(using default file list)") %
-                        self.template)
-        self.filelist.findall()
-
-        if self.use_defaults:
-            self.add_defaults()
-
-        if template_exists:
-            self.read_template()
-
-        if self.prune:
-            self.prune_file_list()
-
-        self.filelist.sort()
-        self.filelist.remove_duplicates()
-        self.write_manifest()
-
-    def add_defaults(self):
-        """Add all the default files to self.filelist:
-          - README or README.txt
-          - setup.py
-          - test/test*.py
-          - all pure Python modules mentioned in setup script
-          - all files pointed by package_data (build_py)
-          - all files defined in data_files.
-          - all files defined as scripts.
-          - all C sources listed as part of extensions or C libraries
-            in the setup script (doesn't catch C headers!)
-        Warns if (README or README.txt) or setup.py are missing; everything
-        else is optional.
-        """
-        standards = [('README', 'README.txt'), self.distribution.script_name]
-        for fn in standards:
-            if isinstance(fn, tuple):
-                alts = fn
-                got_it = False
-                for fn in alts:
-                    if os.path.exists(fn):
-                        got_it = True
-                        self.filelist.append(fn)
-                        break
-
-                if not got_it:
-                    self.warn("standard file not found: should have one of " +
-                              ', '.join(alts))
-            else:
-                if os.path.exists(fn):
-                    self.filelist.append(fn)
-                else:
-                    self.warn("standard file '%s' not found" % fn)
-
-        optional = ['test/test*.py', 'setup.cfg']
-        for pattern in optional:
-            files = filter(os.path.isfile, glob(pattern))
-            self.filelist.extend(files)
-
-        # build_py is used to get:
-        #  - python modules
-        #  - files defined in package_data
-        build_py = self.get_finalized_command('build_py')
-
-        # getting python files
-        if self.distribution.has_pure_modules():
-            self.filelist.extend(build_py.get_source_files())
-
-        # getting package_data files
-        # (computed in build_py.data_files by build_py.finalize_options)
-        for pkg, src_dir, build_dir, filenames in build_py.data_files:
-            for filename in filenames:
-                self.filelist.append(os.path.join(src_dir, filename))
-
-        # getting distribution.data_files
-        if self.distribution.has_data_files():
-            for item in self.distribution.data_files:
-                if isinstance(item, str): # plain file
-                    item = convert_path(item)
-                    if os.path.isfile(item):
-                        self.filelist.append(item)
-                else:    # a (dirname, filenames) tuple
-                    dirname, filenames = item
-                    for f in filenames:
-                        f = convert_path(f)
-                        if os.path.isfile(f):
-                            self.filelist.append(f)
-
-        if self.distribution.has_ext_modules():
-            build_ext = self.get_finalized_command('build_ext')
-            self.filelist.extend(build_ext.get_source_files())
-
-        if self.distribution.has_c_libraries():
-            build_clib = self.get_finalized_command('build_clib')
-            self.filelist.extend(build_clib.get_source_files())
-
-        if self.distribution.has_scripts():
-            build_scripts = self.get_finalized_command('build_scripts')
-            self.filelist.extend(build_scripts.get_source_files())
-
-    def read_template(self):
-        """Read and parse manifest template file named by self.template.
-
-        (usually "MANIFEST.in") The parsing and processing is done by
-        'self.filelist', which updates itself accordingly.
-        """
-        log.info("reading manifest template '%s'", self.template)
-        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
-                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
-                            collapse_join=1)
-
-        try:
-            while True:
-                line = template.readline()
-                if line is None:            # end of file
-                    break
-
-                try:
-                    self.filelist.process_template_line(line)
-                # the call above can raise a DistutilsTemplateError for
-                # malformed lines, or a ValueError from the lower-level
-                # convert_path function
-                except (DistutilsTemplateError, ValueError) as msg:
-                    self.warn("%s, line %d: %s" % (template.filename,
-                                                   template.current_line,
-                                                   msg))
-        finally:
-            template.close()
-
-    def prune_file_list(self):
-        """Prune off branches that might slip into the file list as created
-        by 'read_template()', but really don't belong there:
-          * the build tree (typically "build")
-          * the release tree itself (only an issue if we ran "sdist"
-            previously with --keep-temp, or it aborted)
-          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
-        """
-        build = self.get_finalized_command('build')
-        base_dir = self.distribution.get_fullname()
-
-        self.filelist.exclude_pattern(None, prefix=build.build_base)
-        self.filelist.exclude_pattern(None, prefix=base_dir)
-
-        if sys.platform == 'win32':
-            seps = r'/|\\'
-        else:
-            seps = '/'
-
-        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
-                    '_darcs']
-        vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
-        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)
-
-    def write_manifest(self):
-        """Write the file list in 'self.filelist' (presumably as filled in
-        by 'add_defaults()' and 'read_template()') to the manifest file
-        named by 'self.manifest'.
-        """
-        if self._manifest_is_not_generated():
-            log.info("not writing to manually maintained "
-                     "manifest file '%s'" % self.manifest)
-            return
-
-        content = self.filelist.files[:]
-        content.insert(0, '# file GENERATED by distutils, do NOT edit')
-        self.execute(file_util.write_file, (self.manifest, content),
-                     "writing manifest file '%s'" % self.manifest)
-
-    def _manifest_is_not_generated(self):
-        # check for special comment used in 3.1.3 and higher
-        if not os.path.isfile(self.manifest):
-            return False
-
-        fp = open(self.manifest)
-        try:
-            first_line = fp.readline()
-        finally:
-            fp.close()
-        return first_line != '# file GENERATED by distutils, do NOT edit\n'
-
-    def read_manifest(self):
-        """Read the manifest file (named by 'self.manifest') and use it to
-        fill in 'self.filelist', the list of files to include in the source
-        distribution.
-        """
-        log.info("reading manifest file '%s'", self.manifest)
-        manifest = open(self.manifest)
-        for line in manifest:
-            # ignore comments and blank lines
-            line = line.strip()
-            if line.startswith('#') or not line:
-                continue
-            self.filelist.append(line)
-        manifest.close()
-
-    def make_release_tree(self, base_dir, files):
-        """Create the directory tree that will become the source
-        distribution archive.  All directories implied by the filenames in
-        'files' are created under 'base_dir', and then we hard link or copy
-        (if hard linking is unavailable) those files into place.
-        Essentially, this duplicates the developer's source tree, but in a
-        directory named after the distribution, containing only the files
-        to be distributed.
-        """
-        # Create all the directories under 'base_dir' necessary to
-        # put 'files' there; the 'mkpath()' is just so we don't die
-        # if the manifest happens to be empty.
-        self.mkpath(base_dir)
-        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)
-
-        # And walk over the list of files, either making a hard link (if
-        # os.link exists) to each one that doesn't already exist in its
-        # corresponding location under 'base_dir', or copying each file
-        # that's out-of-date in 'base_dir'.  (Usually, all files will be
-        # out-of-date, because by default we blow away 'base_dir' when
-        # we're done making the distribution archives.)
-
-        if hasattr(os, 'link'):        # can make hard links on this system
-            link = 'hard'
-            msg = "making hard links in %s..." % base_dir
-        else:                           # nope, have to copy
-            link = None
-            msg = "copying files to %s..." % base_dir
-
-        if not files:
-            log.warn("no files to distribute -- empty manifest?")
-        else:
-            log.info(msg)
-        for file in files:
-            if not os.path.isfile(file):
-                log.warn("'%s' not a regular file -- skipping", file)
-            else:
-                dest = os.path.join(base_dir, file)
-                self.copy_file(file, dest, link=link)
-
-        self.distribution.metadata.write_pkg_info(base_dir)
-
-    def make_distribution(self):
-        """Create the source distribution(s).  First, we create the release
-        tree with 'make_release_tree()'; then, we create all required
-        archive files (according to 'self.formats') from the release tree.
-        Finally, we clean up by blowing away the release tree (unless
-        'self.keep_temp' is true).  The list of archive files created is
-        stored so it can be retrieved later by 'get_archive_files()'.
-        """
-        # Don't warn about missing meta-data here -- should be (and is!)
-        # done elsewhere.
-        base_dir = self.distribution.get_fullname()
-        base_name = os.path.join(self.dist_dir, base_dir)
-
-        self.make_release_tree(base_dir, self.filelist.files)
-        archive_files = []              # remember names of files we create
-        # tar archive must be created last to avoid overwrite and remove
-        if 'tar' in self.formats:
-            self.formats.append(self.formats.pop(self.formats.index('tar')))
-
-        for fmt in self.formats:
-            file = self.make_archive(base_name, fmt, base_dir=base_dir,
-                                     owner=self.owner, group=self.group)
-            archive_files.append(file)
-            self.distribution.dist_files.append(('sdist', '', file))
-
-        self.archive_files = archive_files
-
-        if not self.keep_temp:
-            dir_util.remove_tree(base_dir, dry_run=self.dry_run)
-
-    def get_archive_files(self):
-        """Return the list of archive files created when the command
-        was run, or None if the command hasn't run yet.
-        """
-        return self.archive_files
diff --git a/Lib/distutils/command/upload.py b/Lib/distutils/command/upload.py
deleted file mode 100644
index 32dda359bad..00000000000
--- a/Lib/distutils/command/upload.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""
-distutils.command.upload
-
-Implements the Distutils 'upload' subcommand (upload package to a package
-index).
-"""
-
-import os
-import io
-import platform
-import hashlib
-from base64 import standard_b64encode
-from urllib.request import urlopen, Request, HTTPError
-from urllib.parse import urlparse
-from distutils.errors import DistutilsError, DistutilsOptionError
-from distutils.core import PyPIRCCommand
-from distutils.spawn import spawn
-from distutils import log
-
-class upload(PyPIRCCommand):
-
-    description = "upload binary package to PyPI"
-
-    user_options = PyPIRCCommand.user_options + [
-        ('sign', 's',
-         'sign files to upload using gpg'),
-        ('identity=', 'i', 'GPG identity used to sign files'),
-        ]
-
-    boolean_options = PyPIRCCommand.boolean_options + ['sign']
-
-    def initialize_options(self):
-        PyPIRCCommand.initialize_options(self)
-        self.username = ''
-        self.password = ''
-        self.show_response = 0
-        self.sign = False
-        self.identity = None
-
-    def finalize_options(self):
-        PyPIRCCommand.finalize_options(self)
-        if self.identity and not self.sign:
-            raise DistutilsOptionError(
-                "Must use --sign for --identity to have meaning"
-            )
-        config = self._read_pypirc()
-        if config != {}:
-            self.username = config['username']
-            self.password = config['password']
-            self.repository = config['repository']
-            self.realm = config['realm']
-
-        # getting the password from the distribution
-        # if previously set by the register command
-        if not self.password and self.distribution.password:
-            self.password = self.distribution.password
-
-    def run(self):
-        if not self.distribution.dist_files:
-            msg = ("Must create and upload files in one command "
-                   "(e.g. setup.py sdist upload)")
-            raise DistutilsOptionError(msg)
-        for command, pyversion, filename in self.distribution.dist_files:
-            self.upload_file(command, pyversion, filename)
-
-    def upload_file(self, command, pyversion, filename):
-        # Makes sure the repository URL is compliant
-        schema, netloc, url, params, query, fragments = \
-            urlparse(self.repository)
-        if params or query or fragments:
-            raise AssertionError("Incompatible url %s" % self.repository)
-
-        if schema not in ('http', 'https'):
-            raise AssertionError("unsupported schema " + schema)
-
-        # Sign if requested
-        if self.sign:
-            gpg_args = ["gpg", "--detach-sign", "-a", filename]
-            if self.identity:
-                gpg_args[2:2] = ["--local-user", self.identity]
-            spawn(gpg_args,
-                  dry_run=self.dry_run)
-
-        # Fill in the data - send all the meta-data in case we need to
-        # register a new release
-        f = open(filename,'rb')
-        try:
-            content = f.read()
-        finally:
-            f.close()
-        meta = self.distribution.metadata
-        data = {
-            # action
-            ':action': 'file_upload',
-            'protocol_version': '1',
-
-            # identify release
-            'name': meta.get_name(),
-            'version': meta.get_version(),
-
-            # file content
-            'content': (os.path.basename(filename),content),
-            'filetype': command,
-            'pyversion': pyversion,
-            'md5_digest': hashlib.md5(content).hexdigest(),
-
-            # additional meta-data
-            'metadata_version': '1.0',
-            'summary': meta.get_description(),
-            'home_page': meta.get_url(),
-            'author': meta.get_contact(),
-            'author_email': meta.get_contact_email(),
-            'license': meta.get_licence(),
-            'description': meta.get_long_description(),
-            'keywords': meta.get_keywords(),
-            'platform': meta.get_platforms(),
-            'classifiers': meta.get_classifiers(),
-            'download_url': meta.get_download_url(),
-            # PEP 314
-            'provides': meta.get_provides(),
-            'requires': meta.get_requires(),
-            'obsoletes': meta.get_obsoletes(),
-            }
-        comment = ''
-        if command == 'bdist_rpm':
-            dist, version, id = platform.dist()
-            if dist:
-                comment = 'built for %s %s' % (dist, version)
-        elif command == 'bdist_dumb':
-            comment = 'built for %s' % platform.platform(terse=1)
-        data['comment'] = comment
-
-        if self.sign:
-            data['gpg_signature'] = (os.path.basename(filename) + ".asc",
-                                     open(filename+".asc", "rb").read())
-
-        # set up the authentication
-        user_pass = (self.username + ":" + self.password).encode('ascii')
-        # The exact encoding of the authentication string is debated.
-        # Anyway PyPI only accepts ascii for both username or password.
-        auth = "Basic " + standard_b64encode(user_pass).decode('ascii')
-
-        # Build up the MIME payload for the POST data
-        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = b'\r\n--' + boundary.encode('ascii')
-        end_boundary = sep_boundary + b'--\r\n'
-        body = io.BytesIO()
-        for key, value in data.items():
-            title = '\r\nContent-Disposition: form-data; name="%s"' % key
-            # handle multiple entries for the same name
-            if not isinstance(value, list):
-                value = [value]
-            for value in value:
-                if type(value) is tuple:
-                    title += '; filename="%s"' % value[0]
-                    value = value[1]
-                else:
-                    value = str(value).encode('utf-8')
-                body.write(sep_boundary)
-                body.write(title.encode('utf-8'))
-                body.write(b"\r\n\r\n")
-                body.write(value)
-        body.write(end_boundary)
-        body = body.getvalue()
-
-        msg = "Submitting %s to %s" % (filename, self.repository)
-        self.announce(msg, log.INFO)
-
-        # build the Request
-        headers = {
-            'Content-type': 'multipart/form-data; boundary=%s' % boundary,
-            'Content-length': str(len(body)),
-            'Authorization': auth,
-        }
-
-        request = Request(self.repository, data=body,
-                          headers=headers)
-        # send the data
-        try:
-            result = urlopen(request)
-            status = result.getcode()
-            reason = result.msg
-        except HTTPError as e:
-            status = e.code
-            reason = e.msg
-        except OSError as e:
-            self.announce(str(e), log.ERROR)
-            raise
-
-        if status == 200:
-            self.announce('Server response (%s): %s' % (status, reason),
-                          log.INFO)
-            if self.show_response:
-                text = self._read_pypi_response(result)
-                msg = '\n'.join(('-' * 75, text, '-' * 75))
-                self.announce(msg, log.INFO)
-        else:
-            msg = 'Upload failed (%s): %s' % (status, reason)
-            self.announce(msg, log.ERROR)
-            raise DistutilsError(msg)
diff --git a/Lib/distutils/config.py b/Lib/distutils/config.py
deleted file mode 100644
index bf8d8dd2f5a..00000000000
--- a/Lib/distutils/config.py
+++ /dev/null
@@ -1,131 +0,0 @@
-"""distutils.pypirc
-
-Provides the PyPIRCCommand class, the base class for the command classes
-that uses .pypirc in the distutils.command package.
-"""
-import os
-from configparser import RawConfigParser
-
-from distutils.cmd import Command
-
-DEFAULT_PYPIRC = """\
-[distutils]
-index-servers =
-    pypi
-
-[pypi]
-username:%s
-password:%s
-"""
-
-class PyPIRCCommand(Command):
-    """Base command that knows how to handle the .pypirc file
-    """
-    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
-    DEFAULT_REALM = 'pypi'
-    repository = None
-    realm = None
-
-    user_options = [
-        ('repository=', 'r',
-         "url of repository [default: %s]" % \
-            DEFAULT_REPOSITORY),
-        ('show-response', None,
-         'display full response text from server')]
-
-    boolean_options = ['show-response']
-
-    def _get_rc_file(self):
-        """Returns rc file path."""
-        return os.path.join(os.path.expanduser('~'), '.pypirc')
-
-    def _store_pypirc(self, username, password):
-        """Creates a default .pypirc file."""
-        rc = self._get_rc_file()
-        with os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0o600), 'w') as f:
-            f.write(DEFAULT_PYPIRC % (username, password))
-
-    def _read_pypirc(self):
-        """Reads the .pypirc file."""
-        rc = self._get_rc_file()
-        if os.path.exists(rc):
-            self.announce('Using PyPI login from %s' % rc)
-            repository = self.repository or self.DEFAULT_REPOSITORY
-            realm = self.realm or self.DEFAULT_REALM
-
-            config = RawConfigParser()
-            config.read(rc)
-            sections = config.sections()
-            if 'distutils' in sections:
-                # let's get the list of servers
-                index_servers = config.get('distutils', 'index-servers')
-                _servers = [server.strip() for server in
-                            index_servers.split('\n')
-                            if server.strip() != '']
-                if _servers == []:
-                    # nothing set, let's try to get the default pypi
-                    if 'pypi' in sections:
-                        _servers = ['pypi']
-                    else:
-                        # the file is not properly defined, returning
-                        # an empty dict
-                        return {}
-                for server in _servers:
-                    current = {'server': server}
-                    current['username'] = config.get(server, 'username')
-
-                    # optional params
-                    for key, default in (('repository',
-                                          self.DEFAULT_REPOSITORY),
-                                         ('realm', self.DEFAULT_REALM),
-                                         ('password', None)):
-                        if config.has_option(server, key):
-                            current[key] = config.get(server, key)
-                        else:
-                            current[key] = default
-
-                    # work around people having "repository" for the "pypi"
-                    # section of their config set to the HTTP (rather than
-                    # HTTPS) URL
-                    if (server == 'pypi' and
-                        repository in (self.DEFAULT_REPOSITORY, 'pypi')):
-                        current['repository'] = self.DEFAULT_REPOSITORY
-                        return current
-
-                    if (current['server'] == repository or
-                        current['repository'] == repository):
-                        return current
-            elif 'server-login' in sections:
-                # old format
-                server = 'server-login'
-                if config.has_option(server, 'repository'):
-                    repository = config.get(server, 'repository')
-                else:
-                    repository = self.DEFAULT_REPOSITORY
-                return {'username': config.get(server, 'username'),
-                        'password': config.get(server, 'password'),
-                        'repository': repository,
-                        'server': server,
-                        'realm': self.DEFAULT_REALM}
-
-        return {}
-
-    def _read_pypi_response(self, response):
-        """Read and decode a PyPI HTTP response."""
-        import cgi
-        content_type = response.getheader('content-type', 'text/plain')
-        encoding = cgi.parse_header(content_type)[1].get('charset', 'ascii')
-        return response.read().decode(encoding)
-
-    def initialize_options(self):
-        """Initialize options."""
-        self.repository = None
-        self.realm = None
-        self.show_response = 0
-
-    def finalize_options(self):
-        """Finalizes options."""
-        if self.repository is None:
-            self.repository = self.DEFAULT_REPOSITORY
-        if self.realm is None:
-            self.realm = self.DEFAULT_REALM
diff --git a/Lib/distutils/core.py b/Lib/distutils/core.py
deleted file mode 100644
index d603d4a45a7..00000000000
--- a/Lib/distutils/core.py
+++ /dev/null
@@ -1,234 +0,0 @@
-"""distutils.core
-
-The only module that needs to be imported to use the Distutils; provides
-the 'setup' function (which is to be called from the setup script).  Also
-indirectly provides the Distribution and Command classes, although they are
-really defined in distutils.dist and distutils.cmd.
-"""
-
-import os
-import sys
-
-from distutils.debug import DEBUG
-from distutils.errors import *
-
-# Mainly import these so setup scripts can "from distutils.core import" them.
-from distutils.dist import Distribution
-from distutils.cmd import Command
-from distutils.config import PyPIRCCommand
-from distutils.extension import Extension
-
-# This is a barebones help message generated displayed when the user
-# runs the setup script with no arguments at all.  More useful help
-# is generated with various --help options: global help, list commands,
-# and per-command help.
-USAGE = """\
-usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
-   or: %(script)s --help [cmd1 cmd2 ...]
-   or: %(script)s --help-commands
-   or: %(script)s cmd --help
-"""
-
-def gen_usage (script_name):
-    script = os.path.basename(script_name)
-    return USAGE % vars()
-
-
-# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
-_setup_stop_after = None
-_setup_distribution = None
-
-# Legal keyword arguments for the setup() function
-setup_keywords = ('distclass', 'script_name', 'script_args', 'options',
-                  'name', 'version', 'author', 'author_email',
-                  'maintainer', 'maintainer_email', 'url', 'license',
-                  'description', 'long_description', 'keywords',
-                  'platforms', 'classifiers', 'download_url',
-                  'requires', 'provides', 'obsoletes',
-                  )
-
-# Legal keyword arguments for the Extension constructor
-extension_keywords = ('name', 'sources', 'include_dirs',
-                      'define_macros', 'undef_macros',
-                      'library_dirs', 'libraries', 'runtime_library_dirs',
-                      'extra_objects', 'extra_compile_args', 'extra_link_args',
-                      'swig_opts', 'export_symbols', 'depends', 'language')
-
-def setup (**attrs):
-    """The gateway to the Distutils: do everything your setup script needs
-    to do, in a highly flexible and user-driven way.  Briefly: create a
-    Distribution instance; find and parse config files; parse the command
-    line; run each Distutils command found there, customized by the options
-    supplied to 'setup()' (as keyword arguments), in config files, and on
-    the command line.
-
-    The Distribution instance might be an instance of a class supplied via
-    the 'distclass' keyword argument to 'setup'; if no such class is
-    supplied, then the Distribution class (in dist.py) is instantiated.
-    All other arguments to 'setup' (except for 'cmdclass') are used to set
-    attributes of the Distribution instance.
-
-    The 'cmdclass' argument, if supplied, is a dictionary mapping command
-    names to command classes.  Each command encountered on the command line
-    will be turned into a command class, which is in turn instantiated; any
-    class found in 'cmdclass' is used in place of the default, which is
-    (for command 'foo_bar') class 'foo_bar' in module
-    'distutils.command.foo_bar'.  The command class must provide a
-    'user_options' attribute which is a list of option specifiers for
-    'distutils.fancy_getopt'.  Any command-line options between the current
-    and the next command are used to set attributes of the current command
-    object.
-
-    When the entire command-line has been successfully parsed, calls the
-    'run()' method on each command object in turn.  This method will be
-    driven entirely by the Distribution object (which each command object
-    has a reference to, thanks to its constructor), and the
-    command-specific options that became attributes of each command
-    object.
-    """
-
-    global _setup_stop_after, _setup_distribution
-
-    # Determine the distribution class -- either caller-supplied or
-    # our Distribution (see below).
-    klass = attrs.get('distclass')
-    if klass:
-        del attrs['distclass']
-    else:
-        klass = Distribution
-
-    if 'script_name' not in attrs:
-        attrs['script_name'] = os.path.basename(sys.argv[0])
-    if 'script_args'  not in attrs:
-        attrs['script_args'] = sys.argv[1:]
-
-    # Create the Distribution instance, using the remaining arguments
-    # (ie. everything except distclass) to initialize it
-    try:
-        _setup_distribution = dist = klass(attrs)
-    except DistutilsSetupError as msg:
-        if 'name' not in attrs:
-            raise SystemExit("error in setup command: %s" % msg)
-        else:
-            raise SystemExit("error in %s setup command: %s" % \
-                  (attrs['name'], msg))
-
-    if _setup_stop_after == "init":
-        return dist
-
-    # Find and parse the config file(s): they will override options from
-    # the setup script, but be overridden by the command line.
-    dist.parse_config_files()
-
-    if DEBUG:
-        print("options (after parsing config files):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "config":
-        return dist
-
-    # Parse the command line and override config files; any
-    # command-line errors are the end user's fault, so turn them into
-    # SystemExit to suppress tracebacks.
-    try:
-        ok = dist.parse_command_line()
-    except DistutilsArgError as msg:
-        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)
-
-    if DEBUG:
-        print("options (after parsing command line):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "commandline":
-        return dist
-
-    # And finally, run all the commands found on the command line.
-    if ok:
-        try:
-            dist.run_commands()
-        except KeyboardInterrupt:
-            raise SystemExit("interrupted")
-        except OSError as exc:
-            if DEBUG:
-                sys.stderr.write("error: %s\n" % (exc,))
-                raise
-            else:
-                raise SystemExit("error: %s" % (exc,))
-
-        except (DistutilsError,
-                CCompilerError) as msg:
-            if DEBUG:
-                raise
-            else:
-                raise SystemExit("error: " + str(msg))
-
-    return dist
-
-# setup ()
-
-
-def run_setup (script_name, script_args=None, stop_after="run"):
-    """Run a setup script in a somewhat controlled environment, and
-    return the Distribution instance that drives things.  This is useful
-    if you need to find out the distribution meta-data (passed as
-    keyword args from 'script' to 'setup()', or the contents of the
-    config files or command-line.
-
-    'script_name' is a file that will be read and run with 'exec()';
-    'sys.argv[0]' will be replaced with 'script' for the duration of the
-    call.  'script_args' is a list of strings; if supplied,
-    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
-    the call.
-
-    'stop_after' tells 'setup()' when to stop processing; possible
-    values:
-      init
-        stop after the Distribution instance has been created and
-        populated with the keyword arguments to 'setup()'
-      config
-        stop after config files have been parsed (and their data
-        stored in the Distribution instance)
-      commandline
-        stop after the command-line ('sys.argv[1:]' or 'script_args')
-        have been parsed (and the data stored in the Distribution)
-      run [default]
-        stop after all commands have been run (the same as if 'setup()'
-        had been called in the usual way
-
-    Returns the Distribution instance, which provides all information
-    used to drive the Distutils.
-    """
-    if stop_after not in ('init', 'config', 'commandline', 'run'):
-        raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))
-
-    global _setup_stop_after, _setup_distribution
-    _setup_stop_after = stop_after
-
-    save_argv = sys.argv.copy()
-    g = {'__file__': script_name}
-    try:
-        try:
-            sys.argv[0] = script_name
-            if script_args is not None:
-                sys.argv[1:] = script_args
-            with open(script_name, 'rb') as f:
-                exec(f.read(), g)
-        finally:
-            sys.argv = save_argv
-            _setup_stop_after = None
-    except SystemExit:
-        # Hmm, should we do something if exiting with a non-zero code
-        # (ie. error)?
-        pass
-
-    if _setup_distribution is None:
-        raise RuntimeError(("'distutils.core.setup()' was never called -- "
-               "perhaps '%s' is not a Distutils setup script?") % \
-              script_name)
-
-    # I wonder if the setup script's namespace -- g and l -- would be of
-    # any interest to callers?
-    #print "_setup_distribution:", _setup_distribution
-    return _setup_distribution
-
-# run_setup ()
diff --git a/Lib/distutils/cygwinccompiler.py b/Lib/distutils/cygwinccompiler.py
deleted file mode 100644
index 1c369903477..00000000000
--- a/Lib/distutils/cygwinccompiler.py
+++ /dev/null
@@ -1,405 +0,0 @@
-"""distutils.cygwinccompiler
-
-Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
-handles the Cygwin port of the GNU C compiler to Windows.  It also contains
-the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
-cygwin in no-cygwin mode).
-"""
-
-# problems:
-#
-# * if you use a msvc compiled python version (1.5.2)
-#   1. you have to insert a __GNUC__ section in its config.h
-#   2. you have to generate an import library for its dll
-#      - create a def-file for python??.dll
-#      - create an import library using
-#             dlltool --dllname python15.dll --def python15.def \
-#                       --output-lib libpython15.a
-#
-#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
-#
-# * We put export_symbols in a def-file, and don't use
-#   --export-all-symbols because it doesn't worked reliable in some
-#   tested configurations. And because other windows compilers also
-#   need their symbols specified this no serious problem.
-#
-# tested configurations:
-#
-# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
-#   (after patching python's config.h and for C++ some other include files)
-#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
-# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
-#   (ld doesn't support -shared, so we use dllwrap)
-# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
-#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
-#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
-#   - using gcc -mdll instead dllwrap doesn't work without -static because
-#     it tries to link against dlls instead their import libraries. (If
-#     it finds the dll first.)
-#     By specifying -static we force ld to link against the import libraries,
-#     this is windows standard and there are normally not the necessary symbols
-#     in the dlls.
-#   *** only the version of June 2000 shows these problems
-# * cygwin gcc 3.2/ld 2.13.90 works
-#   (ld supports -shared)
-# * mingw gcc 3.2/ld 2.13 works
-#   (ld supports -shared)
-
-import os
-import sys
-import copy
-from subprocess import Popen, PIPE, check_output
-import re
-
-from distutils.ccompiler import gen_preprocess_options, gen_lib_options
-from distutils.unixccompiler import UnixCCompiler
-from distutils.file_util import write_file
-from distutils.errors import (DistutilsExecError, CCompilerError,
-        CompileError, UnknownFileError)
-from distutils import log
-from distutils.version import LooseVersion
-from distutils.spawn import find_executable
-
-def get_msvcr():
-    """Include the appropriate MSVC runtime library if Python was built
-    with MSVC 7.0 or later.
-    """
-    msc_pos = sys.version.find('MSC v.')
-    if msc_pos != -1:
-        msc_ver = sys.version[msc_pos+6:msc_pos+10]
-        if msc_ver == '1300':
-            # MSVC 7.0
-            return ['msvcr70']
-        elif msc_ver == '1310':
-            # MSVC 7.1
-            return ['msvcr71']
-        elif msc_ver == '1400':
-            # VS2005 / MSVC 8.0
-            return ['msvcr80']
-        elif msc_ver == '1500':
-            # VS2008 / MSVC 9.0
-            return ['msvcr90']
-        elif msc_ver == '1600':
-            # VS2010 / MSVC 10.0
-            return ['msvcr100']
-        else:
-            raise ValueError("Unknown MS Compiler version %s " % msc_ver)
-
-
-class CygwinCCompiler(UnixCCompiler):
-    """ Handles the Cygwin port of the GNU C compiler to Windows.
-    """
-    compiler_type = 'cygwin'
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".dll"
-    static_lib_format = "lib%s%s"
-    shared_lib_format = "%s%s"
-    exe_extension = ".exe"
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        UnixCCompiler.__init__(self, verbose, dry_run, force)
-
-        status, details = check_config_h()
-        self.debug_print("Python's GCC status: %s (details: %s)" %
-                         (status, details))
-        if status is not CONFIG_H_OK:
-            self.warn(
-                "Python's pyconfig.h doesn't seem to support your compiler. "
-                "Reason: %s. "
-                "Compiling may fail because of undefined preprocessor macros."
-                % details)
-
-        self.gcc_version, self.ld_version, self.dllwrap_version = \
-            get_versions()
-        self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
-                         (self.gcc_version,
-                          self.ld_version,
-                          self.dllwrap_version) )
-
-        # ld_version >= "2.10.90" and < "2.13" should also be able to use
-        # gcc -mdll instead of dllwrap
-        # Older dllwraps had own version numbers, newer ones use the
-        # same as the rest of binutils ( also ld )
-        # dllwrap 2.10.90 is buggy
-        if self.ld_version >= "2.10.90":
-            self.linker_dll = "gcc"
-        else:
-            self.linker_dll = "dllwrap"
-
-        # ld_version >= "2.13" support -shared so use it instead of
-        # -mdll -static
-        if self.ld_version >= "2.13":
-            shared_option = "-shared"
-        else:
-            shared_option = "-mdll -static"
-
-        # Hard-code GCC because that's what this is all about.
-        # XXX optimization, warnings etc. should be customizable.
-        self.set_executables(compiler='gcc -mcygwin -O -Wall',
-                             compiler_so='gcc -mcygwin -mdll -O -Wall',
-                             compiler_cxx='g++ -mcygwin -O -Wall',
-                             linker_exe='gcc -mcygwin',
-                             linker_so=('%s -mcygwin %s' %
-                                        (self.linker_dll, shared_option)))
-
-        # cygwin and mingw32 need different sets of libraries
-        if self.gcc_version == "2.91.57":
-            # cygwin shouldn't need msvcrt, but without the dlls will crash
-            # (gcc version 2.91.57) -- perhaps something about initialization
-            self.dll_libraries=["msvcrt"]
-            self.warn(
-                "Consider upgrading to a newer version of gcc")
-        else:
-            # Include the appropriate MSVC runtime library if Python was built
-            # with MSVC 7.0 or later.
-            self.dll_libraries = get_msvcr()
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        """Compiles the source by spawning GCC and windres if needed."""
-        if ext == '.rc' or ext == '.res':
-            # gcc needs '.res' and '.rc' compiled to object files !!!
-            try:
-                self.spawn(["windres", "-i", src, "-o", obj])
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-        else: # for other files use the C-compiler
-            try:
-                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-    def link(self, target_desc, objects, output_filename, output_dir=None,
-             libraries=None, library_dirs=None, runtime_library_dirs=None,
-             export_symbols=None, debug=0, extra_preargs=None,
-             extra_postargs=None, build_temp=None, target_lang=None):
-        """Link the objects."""
-        # use separate copies, so we can modify the lists
-        extra_preargs = copy.copy(extra_preargs or [])
-        libraries = copy.copy(libraries or [])
-        objects = copy.copy(objects or [])
-
-        # Additional libraries
-        libraries.extend(self.dll_libraries)
-
-        # handle export symbols by creating a def-file
-        # with executables this only works with gcc/ld as linker
-        if ((export_symbols is not None) and
-            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
-            # (The linker doesn't do anything if output is up-to-date.
-            # So it would probably better to check if we really need this,
-            # but for this we had to insert some unchanged parts of
-            # UnixCCompiler, and this is not what we want.)
-
-            # we want to put some files in the same directory as the
-            # object files are, build_temp doesn't help much
-            # where are the object files
-            temp_dir = os.path.dirname(objects[0])
-            # name of dll to give the helper files the same base name
-            (dll_name, dll_extension) = os.path.splitext(
-                os.path.basename(output_filename))
-
-            # generate the filenames for these files
-            def_file = os.path.join(temp_dir, dll_name + ".def")
-            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
-
-            # Generate .def file
-            contents = [
-                "LIBRARY %s" % os.path.basename(output_filename),
-                "EXPORTS"]
-            for sym in export_symbols:
-                contents.append(sym)
-            self.execute(write_file, (def_file, contents),
-                         "writing %s" % def_file)
-
-            # next add options for def-file and to creating import libraries
-
-            # dllwrap uses different options than gcc/ld
-            if self.linker_dll == "dllwrap":
-                extra_preargs.extend(["--output-lib", lib_file])
-                # for dllwrap we have to use a special option
-                extra_preargs.extend(["--def", def_file])
-            # we use gcc/ld here and can be sure ld is >= 2.9.10
-            else:
-                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
-                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
-                # for gcc/ld the def-file is specified as any object files
-                objects.append(def_file)
-
-        #end: if ((export_symbols is not None) and
-        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
-
-        # who wants symbols and a many times larger output file
-        # should explicitly switch the debug mode on
-        # otherwise we let dllwrap/ld strip the output file
-        # (On my machine: 10KB < stripped_file < ??100KB
-        #   unstripped_file = stripped_file + XXX KB
-        #  ( XXX=254 for a typical python extension))
-        if not debug:
-            extra_preargs.append("-s")
-
-        UnixCCompiler.link(self, target_desc, objects, output_filename,
-                           output_dir, libraries, library_dirs,
-                           runtime_library_dirs,
-                           None, # export_symbols, we do this in our def-file
-                           debug, extra_preargs, extra_postargs, build_temp,
-                           target_lang)
-
-    # -- Miscellaneous methods -----------------------------------------
-
-    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
-        """Adds supports for rc and res files."""
-        if output_dir is None:
-            output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
-            base, ext = os.path.splitext(os.path.normcase(src_name))
-            if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
-                      (ext, src_name))
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in ('.res', '.rc'):
-                # these need to be compiled to object files
-                obj_names.append (os.path.join(output_dir,
-                                              base + ext + self.obj_extension))
-            else:
-                obj_names.append (os.path.join(output_dir,
-                                               base + self.obj_extension))
-        return obj_names
-
-# the same as cygwin plus some additional parameters
-class Mingw32CCompiler(CygwinCCompiler):
-    """ Handles the Mingw32 port of the GNU C compiler to Windows.
-    """
-    compiler_type = 'mingw32'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        CygwinCCompiler.__init__ (self, verbose, dry_run, force)
-
-        # ld_version >= "2.13" support -shared so use it instead of
-        # -mdll -static
-        if self.ld_version >= "2.13":
-            shared_option = "-shared"
-        else:
-            shared_option = "-mdll -static"
-
-        # A real mingw32 doesn't need to specify a different entry point,
-        # but cygwin 2.91.57 in no-cygwin-mode needs it.
-        if self.gcc_version <= "2.91.57":
-            entry_point = '--entry _DllMain@12'
-        else:
-            entry_point = ''
-
-        if is_cygwingcc():
-            raise CCompilerError(
-                'Cygwin gcc cannot be used with --compiler=mingw32')
-
-        self.set_executables(compiler='gcc -O -Wall',
-                             compiler_so='gcc -mdll -O -Wall',
-                             compiler_cxx='g++ -O -Wall',
-                             linker_exe='gcc',
-                             linker_so='%s %s %s'
-                                        % (self.linker_dll, shared_option,
-                                           entry_point))
-        # Maybe we should also append -mthreads, but then the finished
-        # dlls need another dll (mingwm10.dll see Mingw32 docs)
-        # (-mthreads: Support thread-safe exception handling on `Mingw32')
-
-        # no additional libraries needed
-        self.dll_libraries=[]
-
-        # Include the appropriate MSVC runtime library if Python was built
-        # with MSVC 7.0 or later.
-        self.dll_libraries = get_msvcr()
-
-# Because these compilers aren't configured in Python's pyconfig.h file by
-# default, we should at least warn the user if he is using an unmodified
-# version.
-
-CONFIG_H_OK = "ok"
-CONFIG_H_NOTOK = "not ok"
-CONFIG_H_UNCERTAIN = "uncertain"
-
-def check_config_h():
-    """Check if the current Python installation appears amenable to building
-    extensions with GCC.
-
-    Returns a tuple (status, details), where 'status' is one of the following
-    constants:
-
-    - CONFIG_H_OK: all is well, go ahead and compile
-    - CONFIG_H_NOTOK: doesn't look good
-    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
-
-    'details' is a human-readable string explaining the situation.
-
-    Note there are two ways to conclude "OK": either 'sys.version' contains
-    the string "GCC" (implying that this Python was built with GCC), or the
-    installed "pyconfig.h" contains the string "__GNUC__".
-    """
-
-    # XXX since this function also checks sys.version, it's not strictly a
-    # "pyconfig.h" check -- should probably be renamed...
-
-    from distutils import sysconfig
-
-    # if sys.version contains GCC then python was compiled with GCC, and the
-    # pyconfig.h file should be OK
-    if "GCC" in sys.version:
-        return CONFIG_H_OK, "sys.version mentions 'GCC'"
-
-    # let's see if __GNUC__ is mentioned in python.h
-    fn = sysconfig.get_config_h_filename()
-    try:
-        config_h = open(fn)
-        try:
-            if "__GNUC__" in config_h.read():
-                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
-            else:
-                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
-        finally:
-            config_h.close()
-    except OSError as exc:
-        return (CONFIG_H_UNCERTAIN,
-                "couldn't read '%s': %s" % (fn, exc.strerror))
-
-RE_VERSION = re.compile(br'(\d+\.\d+(\.\d+)*)')
-
-def _find_exe_version(cmd):
-    """Find the version of an executable by running `cmd` in the shell.
-
-    If the command is not found, or the output does not match
-    `RE_VERSION`, returns None.
-    """
-    executable = cmd.split()[0]
-    if find_executable(executable) is None:
-        return None
-    out = Popen(cmd, shell=True, stdout=PIPE).stdout
-    try:
-        out_string = out.read()
-    finally:
-        out.close()
-    result = RE_VERSION.search(out_string)
-    if result is None:
-        return None
-    # LooseVersion works with strings
-    # so we need to decode our bytes
-    return LooseVersion(result.group(1).decode())
-
-def get_versions():
-    """ Try to find out the versions of gcc, ld and dllwrap.
-
-    If not possible it returns None for it.
-    """
-    commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version']
-    return tuple([_find_exe_version(cmd) for cmd in commands])
-
-def is_cygwingcc():
-    '''Try to determine if the gcc that would be used is from cygwin.'''
-    out_string = check_output(['gcc', '-dumpmachine'])
-    return out_string.strip().endswith(b'cygwin')
diff --git a/Lib/distutils/debug.py b/Lib/distutils/debug.py
deleted file mode 100644
index daf1660f0d8..00000000000
--- a/Lib/distutils/debug.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import os
-
-# If DISTUTILS_DEBUG is anything other than the empty string, we run in
-# debug mode.
-DEBUG = os.environ.get('DISTUTILS_DEBUG')
diff --git a/Lib/distutils/dep_util.py b/Lib/distutils/dep_util.py
deleted file mode 100644
index d74f5e4e92f..00000000000
--- a/Lib/distutils/dep_util.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""distutils.dep_util
-
-Utility functions for simple, timestamp-based dependency of files
-and groups of files; also, function based entirely on such
-timestamp dependency analysis."""
-
-import os
-from distutils.errors import DistutilsFileError
-
-
-def newer (source, target):
-    """Return true if 'source' exists and is more recently modified than
-    'target', or if 'source' exists and 'target' doesn't.  Return false if
-    both exist and 'target' is the same age or younger than 'source'.
-    Raise DistutilsFileError if 'source' does not exist.
-    """
-    if not os.path.exists(source):
-        raise DistutilsFileError("file '%s' does not exist" %
-                                 os.path.abspath(source))
-    if not os.path.exists(target):
-        return 1
-
-    from stat import ST_MTIME
-    mtime1 = os.stat(source)[ST_MTIME]
-    mtime2 = os.stat(target)[ST_MTIME]
-
-    return mtime1 > mtime2
-
-# newer ()
-
-
-def newer_pairwise (sources, targets):
-    """Walk two filename lists in parallel, testing if each source is newer
-    than its corresponding target.  Return a pair of lists (sources,
-    targets) where source is newer than target, according to the semantics
-    of 'newer()'.
-    """
-    if len(sources) != len(targets):
-        raise ValueError("'sources' and 'targets' must be same length")
-
-    # build a pair of lists (sources, targets) where  source is newer
-    n_sources = []
-    n_targets = []
-    for i in range(len(sources)):
-        if newer(sources[i], targets[i]):
-            n_sources.append(sources[i])
-            n_targets.append(targets[i])
-
-    return (n_sources, n_targets)
-
-# newer_pairwise ()
-
-
-def newer_group (sources, target, missing='error'):
-    """Return true if 'target' is out-of-date with respect to any file
-    listed in 'sources'.  In other words, if 'target' exists and is newer
-    than every file in 'sources', return false; otherwise return true.
-    'missing' controls what we do when a source file is missing; the
-    default ("error") is to blow up with an OSError from inside 'stat()';
-    if it is "ignore", we silently drop any missing source files; if it is
-    "newer", any missing source files make us assume that 'target' is
-    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
-    carry out commands that wouldn't work because inputs are missing, but
-    that doesn't matter because you're not actually going to run the
-    commands).
-    """
-    # If the target doesn't even exist, then it's definitely out-of-date.
-    if not os.path.exists(target):
-        return 1
-
-    # Otherwise we have to find out the hard way: if *any* source file
-    # is more recent than 'target', then 'target' is out-of-date and
-    # we can immediately return true.  If we fall through to the end
-    # of the loop, then 'target' is up-to-date and we return false.
-    from stat import ST_MTIME
-    target_mtime = os.stat(target)[ST_MTIME]
-    for source in sources:
-        if not os.path.exists(source):
-            if missing == 'error':      # blow up when we stat() the file
-                pass
-            elif missing == 'ignore':   # missing source dropped from
-                continue                #  target's dependency list
-            elif missing == 'newer':    # missing source means target is
-                return 1                #  out-of-date
-
-        source_mtime = os.stat(source)[ST_MTIME]
-        if source_mtime > target_mtime:
-            return 1
-    else:
-        return 0
-
-# newer_group ()
diff --git a/Lib/distutils/dir_util.py b/Lib/distutils/dir_util.py
deleted file mode 100644
index df4d751c942..00000000000
--- a/Lib/distutils/dir_util.py
+++ /dev/null
@@ -1,223 +0,0 @@
-"""distutils.dir_util
-
-Utility functions for manipulating directories and directory trees."""
-
-import os
-import errno
-from distutils.errors import DistutilsFileError, DistutilsInternalError
-from distutils import log
-
-# cache for by mkpath() -- in addition to cheapening redundant calls,
-# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
-_path_created = {}
-
-# I don't use os.makedirs because a) it's new to Python 1.5.2, and
-# b) it blows up if the directory already exists (I want to silently
-# succeed in that case).
-def mkpath(name, mode=0o777, verbose=1, dry_run=0):
-    """Create a directory and any missing ancestor directories.
-
-    If the directory already exists (or if 'name' is the empty string, which
-    means the current directory, which of course exists), then do nothing.
-    Raise DistutilsFileError if unable to create some directory along the way
-    (eg. some sub-path exists, but is a file rather than a directory).
-    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
-    Return the list of directories actually created.
-    """
-
-    global _path_created
-
-    # Detect a common bug -- name is None
-    if not isinstance(name, str):
-        raise DistutilsInternalError(
-              "mkpath: 'name' must be a string (got %r)" % (name,))
-
-    # XXX what's the better way to handle verbosity? print as we create
-    # each directory in the path (the current behaviour), or only announce
-    # the creation of the whole path? (quite easy to do the latter since
-    # we're not using a recursive algorithm)
-
-    name = os.path.normpath(name)
-    created_dirs = []
-    if os.path.isdir(name) or name == '':
-        return created_dirs
-    if _path_created.get(os.path.abspath(name)):
-        return created_dirs
-
-    (head, tail) = os.path.split(name)
-    tails = [tail]                      # stack of lone dirs to create
-
-    while head and tail and not os.path.isdir(head):
-        (head, tail) = os.path.split(head)
-        tails.insert(0, tail)          # push next higher dir onto stack
-
-    # now 'head' contains the deepest directory that already exists
-    # (that is, the child of 'head' in 'name' is the highest directory
-    # that does *not* exist)
-    for d in tails:
-        #print "head = %s, d = %s: " % (head, d),
-        head = os.path.join(head, d)
-        abs_head = os.path.abspath(head)
-
-        if _path_created.get(abs_head):
-            continue
-
-        if verbose >= 1:
-            log.info("creating %s", head)
-
-        if not dry_run:
-            try:
-                os.mkdir(head, mode)
-            except OSError as exc:
-                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
-                    raise DistutilsFileError(
-                          "could not create '%s': %s" % (head, exc.args[-1]))
-            created_dirs.append(head)
-
-        _path_created[abs_head] = 1
-    return created_dirs
-
-def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
-    """Create all the empty directories under 'base_dir' needed to put 'files'
-    there.
-
-    'base_dir' is just the name of a directory which doesn't necessarily
-    exist yet; 'files' is a list of filenames to be interpreted relative to
-    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
-    will be created if it doesn't already exist.  'mode', 'verbose' and
-    'dry_run' flags are as for 'mkpath()'.
-    """
-    # First get the list of directories to create
-    need_dir = set()
-    for file in files:
-        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))
-
-    # Now create them
-    for dir in sorted(need_dir):
-        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
-
-import sysconfig
-_multiarch = None
-
-def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
-              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
-    """Copy an entire directory tree 'src' to a new location 'dst'.
-
-    Both 'src' and 'dst' must be directory names.  If 'src' is not a
-    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
-    created with 'mkpath()'.  The end result of the copy is that every
-    file in 'src' is copied to 'dst', and directories under 'src' are
-    recursively copied to 'dst'.  Return the list of files that were
-    copied or might have been copied, using their output name.  The
-    return value is unaffected by 'update' or 'dry_run': it is simply
-    the list of all files under 'src', with the names changed to be
-    under 'dst'.
-
-    'preserve_mode' and 'preserve_times' are the same as for
-    'copy_file'; note that they only apply to regular files, not to
-    directories.  If 'preserve_symlinks' is true, symlinks will be
-    copied as symlinks (on platforms that support them!); otherwise
-    (the default), the destination of the symlink will be copied.
-    'update' and 'verbose' are the same as for 'copy_file'.
-    """
-    from distutils.file_util import copy_file
-
-    if not dry_run and not os.path.isdir(src):
-        raise DistutilsFileError(
-              "cannot copy tree '%s': not a directory" % src)
-    try:
-        names = os.listdir(src)
-    except OSError as e:
-        if dry_run:
-            names = []
-        else:
-            raise DistutilsFileError(
-                  "error listing files in '%s': %s" % (src, e.strerror))
-
-    ext_suffix = sysconfig.get_config_var ('EXT_SUFFIX')
-    _multiarch = sysconfig.get_config_var ('MULTIARCH')
-    if ext_suffix.endswith(_multiarch + ext_suffix[-3:]):
-        new_suffix = None
-    else:
-        new_suffix = "%s-%s%s" % (ext_suffix[:-3], _multiarch, ext_suffix[-3:])
-
-    if not dry_run:
-        mkpath(dst, verbose=verbose)
-
-    outputs = []
-
-    for n in names:
-        src_name = os.path.join(src, n)
-        dst_name = os.path.join(dst, n)
-        if new_suffix and _multiarch and n.endswith(ext_suffix) and not n.endswith(new_suffix):
-            dst_name = os.path.join(dst, n.replace(ext_suffix, new_suffix))
-            log.info("renaming extension %s -> %s", n, n.replace(ext_suffix, new_suffix))
-
-        if n.startswith('.nfs'):
-            # skip NFS rename files
-            continue
-
-        if preserve_symlinks and os.path.islink(src_name):
-            link_dest = os.readlink(src_name)
-            if verbose >= 1:
-                log.info("linking %s -> %s", dst_name, link_dest)
-            if not dry_run:
-                os.symlink(link_dest, dst_name)
-            outputs.append(dst_name)
-
-        elif os.path.isdir(src_name):
-            outputs.extend(
-                copy_tree(src_name, dst_name, preserve_mode,
-                          preserve_times, preserve_symlinks, update,
-                          verbose=verbose, dry_run=dry_run))
-        else:
-            copy_file(src_name, dst_name, preserve_mode,
-                      preserve_times, update, verbose=verbose,
-                      dry_run=dry_run)
-            outputs.append(dst_name)
-
-    return outputs
-
-def _build_cmdtuple(path, cmdtuples):
-    """Helper for remove_tree()."""
-    for f in os.listdir(path):
-        real_f = os.path.join(path,f)
-        if os.path.isdir(real_f) and not os.path.islink(real_f):
-            _build_cmdtuple(real_f, cmdtuples)
-        else:
-            cmdtuples.append((os.remove, real_f))
-    cmdtuples.append((os.rmdir, path))
-
-def remove_tree(directory, verbose=1, dry_run=0):
-    """Recursively remove an entire directory tree.
-
-    Any errors are ignored (apart from being reported to stdout if 'verbose'
-    is true).
-    """
-    global _path_created
-
-    if verbose >= 1:
-        log.info("removing '%s' (and everything under it)", directory)
-    if dry_run:
-        return
-    cmdtuples = []
-    _build_cmdtuple(directory, cmdtuples)
-    for cmd in cmdtuples:
-        try:
-            cmd[0](cmd[1])
-            # remove dir from cache if it's already there
-            abspath = os.path.abspath(cmd[1])
-            if abspath in _path_created:
-                del _path_created[abspath]
-        except OSError as exc:
-            log.warn("error removing %s: %s", directory, exc)
-
-def ensure_relative(path):
-    """Take the full path 'path', and make it a relative path.
-
-    This is useful to make 'path' the second argument to os.path.join().
-    """
-    drive, path = os.path.splitdrive(path)
-    if path[0:1] == os.sep:
-        path = drive + path[1:]
-    return path
diff --git a/Lib/distutils/dist.py b/Lib/distutils/dist.py
deleted file mode 100644
index 62a24516cfa..00000000000
--- a/Lib/distutils/dist.py
+++ /dev/null
@@ -1,1236 +0,0 @@
-"""distutils.dist
-
-Provides the Distribution class, which represents the module distribution
-being built/installed/distributed.
-"""
-
-import sys
-import os
-import re
-from email import message_from_file
-
-try:
-    import warnings
-except ImportError:
-    warnings = None
-
-from distutils.errors import *
-from distutils.fancy_getopt import FancyGetopt, translate_longopt
-from distutils.util import check_environ, strtobool, rfc822_escape
-from distutils import log
-from distutils.debug import DEBUG
-
-# Regex to define acceptable Distutils command names.  This is not *quite*
-# the same as a Python NAME -- I don't allow leading underscores.  The fact
-# that they're very similar is no coincidence; the default naming scheme is
-# to look for a Python module named after the command.
-command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
-
-
-class Distribution:
-    """The core of the Distutils.  Most of the work hiding behind 'setup'
-    is really done within a Distribution instance, which farms the work out
-    to the Distutils commands specified on the command line.
-
-    Setup scripts will almost never instantiate Distribution directly,
-    unless the 'setup()' function is totally inadequate to their needs.
-    However, it is conceivable that a setup script might wish to subclass
-    Distribution for some specialized purpose, and then pass the subclass
-    to 'setup()' as the 'distclass' keyword argument.  If so, it is
-    necessary to respect the expectations that 'setup' has of Distribution.
-    See the code for 'setup()', in core.py, for details.
-    """
-
-    # 'global_options' describes the command-line options that may be
-    # supplied to the setup script prior to any actual commands.
-    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
-    # these global options.  This list should be kept to a bare minimum,
-    # since every global option is also valid as a command option -- and we
-    # don't want to pollute the commands with too many options that they
-    # have minimal control over.
-    # The fourth entry for verbose means that it can be repeated.
-    global_options = [
-        ('verbose', 'v', "run verbosely (default)", 1),
-        ('quiet', 'q', "run quietly (turns verbosity off)"),
-        ('dry-run', 'n', "don't actually do anything"),
-        ('help', 'h', "show detailed help message"),
-        ('no-user-cfg', None,
-            'ignore pydistutils.cfg in your home directory'),
-    ]
-
-    # 'common_usage' is a short (2-3 line) string describing the common
-    # usage of the setup script.
-    common_usage = """\
-Common commands: (see '--help-commands' for more)
-
-  setup.py build      will build the package underneath 'build/'
-  setup.py install    will install the package
-"""
-
-    # options that are not propagated to the commands
-    display_options = [
-        ('help-commands', None,
-         "list all available commands"),
-        ('name', None,
-         "print package name"),
-        ('version', 'V',
-         "print package version"),
-        ('fullname', None,
-         "print <package name>-<version>"),
-        ('author', None,
-         "print the author's name"),
-        ('author-email', None,
-         "print the author's email address"),
-        ('maintainer', None,
-         "print the maintainer's name"),
-        ('maintainer-email', None,
-         "print the maintainer's email address"),
-        ('contact', None,
-         "print the maintainer's name if known, else the author's"),
-        ('contact-email', None,
-         "print the maintainer's email address if known, else the author's"),
-        ('url', None,
-         "print the URL for this package"),
-        ('license', None,
-         "print the license of the package"),
-        ('licence', None,
-         "alias for --license"),
-        ('description', None,
-         "print the package description"),
-        ('long-description', None,
-         "print the long package description"),
-        ('platforms', None,
-         "print the list of platforms"),
-        ('classifiers', None,
-         "print the list of classifiers"),
-        ('keywords', None,
-         "print the list of keywords"),
-        ('provides', None,
-         "print the list of packages/modules provided"),
-        ('requires', None,
-         "print the list of packages/modules required"),
-        ('obsoletes', None,
-         "print the list of packages/modules made obsolete")
-        ]
-    display_option_names = [translate_longopt(x[0]) for x in display_options]
-
-    # negative options are options that exclude other options
-    negative_opt = {'quiet': 'verbose'}
-
-    # -- Creation/initialization methods -------------------------------
-
-    def __init__(self, attrs=None):
-        """Construct a new Distribution instance: initialize all the
-        attributes of a Distribution, and then use 'attrs' (a dictionary
-        mapping attribute names to values) to assign some of those
-        attributes their "real" values.  (Any attributes not mentioned in
-        'attrs' will be assigned to some null value: 0, None, an empty list
-        or dictionary, etc.)  Most importantly, initialize the
-        'command_obj' attribute to the empty dictionary; this will be
-        filled in with real command objects by 'parse_command_line()'.
-        """
-
-        # Default values for our command-line options
-        self.verbose = 1
-        self.dry_run = 0
-        self.help = 0
-        for attr in self.display_option_names:
-            setattr(self, attr, 0)
-
-        # Store the distribution meta-data (name, version, author, and so
-        # forth) in a separate object -- we're getting to have enough
-        # information here (and enough command-line options) that it's
-        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
-        # object in a sneaky and underhanded (but efficient!) way.
-        self.metadata = DistributionMetadata()
-        for basename in self.metadata._METHOD_BASENAMES:
-            method_name = "get_" + basename
-            setattr(self, method_name, getattr(self.metadata, method_name))
-
-        # 'cmdclass' maps command names to class objects, so we
-        # can 1) quickly figure out which class to instantiate when
-        # we need to create a new command object, and 2) have a way
-        # for the setup script to override command classes
-        self.cmdclass = {}
-
-        # 'command_packages' is a list of packages in which commands
-        # are searched for.  The factory for command 'foo' is expected
-        # to be named 'foo' in the module 'foo' in one of the packages
-        # named here.  This list is searched from the left; an error
-        # is raised if no named package provides the command being
-        # searched for.  (Always access using get_command_packages().)
-        self.command_packages = None
-
-        # 'script_name' and 'script_args' are usually set to sys.argv[0]
-        # and sys.argv[1:], but they can be overridden when the caller is
-        # not necessarily a setup script run from the command-line.
-        self.script_name = None
-        self.script_args = None
-
-        # 'command_options' is where we store command options between
-        # parsing them (from config files, the command-line, etc.) and when
-        # they are actually needed -- ie. when the command in question is
-        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
-        #   command_options = { command_name : { option : (source, value) } }
-        self.command_options = {}
-
-        # 'dist_files' is the list of (command, pyversion, file) that
-        # have been created by any dist commands run so far. This is
-        # filled regardless of whether the run is dry or not. pyversion
-        # gives sysconfig.get_python_version() if the dist file is
-        # specific to a Python version, 'any' if it is good for all
-        # Python versions on the target platform, and '' for a source
-        # file. pyversion should not be used to specify minimum or
-        # maximum required Python versions; use the metainfo for that
-        # instead.
-        self.dist_files = []
-
-        # These options are really the business of various commands, rather
-        # than of the Distribution itself.  We provide aliases for them in
-        # Distribution as a convenience to the developer.
-        self.packages = None
-        self.package_data = {}
-        self.package_dir = None
-        self.py_modules = None
-        self.libraries = None
-        self.headers = None
-        self.ext_modules = None
-        self.ext_package = None
-        self.include_dirs = None
-        self.extra_path = None
-        self.scripts = None
-        self.data_files = None
-        self.password = ''
-
-        # And now initialize bookkeeping stuff that can't be supplied by
-        # the caller at all.  'command_obj' maps command names to
-        # Command instances -- that's how we enforce that every command
-        # class is a singleton.
-        self.command_obj = {}
-
-        # 'have_run' maps command names to boolean values; it keeps track
-        # of whether we have actually run a particular command, to make it
-        # cheap to "run" a command whenever we think we might need to -- if
-        # it's already been done, no need for expensive filesystem
-        # operations, we just check the 'have_run' dictionary and carry on.
-        # It's only safe to query 'have_run' for a command class that has
-        # been instantiated -- a false value will be inserted when the
-        # command object is created, and replaced with a true value when
-        # the command is successfully run.  Thus it's probably best to use
-        # '.get()' rather than a straight lookup.
-        self.have_run = {}
-
-        # Now we'll use the attrs dictionary (ultimately, keyword args from
-        # the setup script) to possibly override any or all of these
-        # distribution options.
-
-        if attrs:
-            # Pull out the set of command options and work on them
-            # specifically.  Note that this order guarantees that aliased
-            # command options will override any supplied redundantly
-            # through the general options dictionary.
-            options = attrs.get('options')
-            if options is not None:
-                del attrs['options']
-                for (command, cmd_options) in options.items():
-                    opt_dict = self.get_option_dict(command)
-                    for (opt, val) in cmd_options.items():
-                        opt_dict[opt] = ("setup script", val)
-
-            if 'licence' in attrs:
-                attrs['license'] = attrs['licence']
-                del attrs['licence']
-                msg = "'licence' distribution option is deprecated; use 'license'"
-                if warnings is not None:
-                    warnings.warn(msg)
-                else:
-                    sys.stderr.write(msg + "\n")
-
-            # Now work on the rest of the attributes.  Any attribute that's
-            # not already defined is invalid!
-            for (key, val) in attrs.items():
-                if hasattr(self.metadata, "set_" + key):
-                    getattr(self.metadata, "set_" + key)(val)
-                elif hasattr(self.metadata, key):
-                    setattr(self.metadata, key, val)
-                elif hasattr(self, key):
-                    setattr(self, key, val)
-                else:
-                    msg = "Unknown distribution option: %s" % repr(key)
-                    if warnings is not None:
-                        warnings.warn(msg)
-                    else:
-                        sys.stderr.write(msg + "\n")
-
-        # no-user-cfg is handled before other command line args
-        # because other args override the config files, and this
-        # one is needed before we can load the config files.
-        # If attrs['script_args'] wasn't passed, assume false.
-        #
-        # This also make sure we just look at the global options
-        self.want_user_cfg = True
-
-        if self.script_args is not None:
-            for arg in self.script_args:
-                if not arg.startswith('-'):
-                    break
-                if arg == '--no-user-cfg':
-                    self.want_user_cfg = False
-                    break
-
-        self.finalize_options()
-
-    def get_option_dict(self, command):
-        """Get the option dictionary for a given command.  If that
-        command's option dictionary hasn't been created yet, then create it
-        and return the new dictionary; otherwise, return the existing
-        option dictionary.
-        """
-        dict = self.command_options.get(command)
-        if dict is None:
-            dict = self.command_options[command] = {}
-        return dict
-
-    def dump_option_dicts(self, header=None, commands=None, indent=""):
-        from pprint import pformat
-
-        if commands is None:             # dump all command option dicts
-            commands = sorted(self.command_options.keys())
-
-        if header is not None:
-            self.announce(indent + header)
-            indent = indent + "  "
-
-        if not commands:
-            self.announce(indent + "no commands known yet")
-            return
-
-        for cmd_name in commands:
-            opt_dict = self.command_options.get(cmd_name)
-            if opt_dict is None:
-                self.announce(indent +
-                              "no option dict for '%s' command" % cmd_name)
-            else:
-                self.announce(indent +
-                              "option dict for '%s' command:" % cmd_name)
-                out = pformat(opt_dict)
-                for line in out.split('\n'):
-                    self.announce(indent + "  " + line)
-
-    # -- Config file finding/parsing methods ---------------------------
-
-    def find_config_files(self):
-        """Find as many configuration files as should be processed for this
-        platform, and return a list of filenames in the order in which they
-        should be parsed.  The filenames returned are guaranteed to exist
-        (modulo nasty race conditions).
-
-        There are three possible config files: distutils.cfg in the
-        Distutils installation directory (ie. where the top-level
-        Distutils __inst__.py file lives), a file in the user's home
-        directory named .pydistutils.cfg on Unix and pydistutils.cfg
-        on Windows/Mac; and setup.cfg in the current directory.
-
-        The file in the user's home directory can be disabled with the
-        --no-user-cfg option.
-        """
-        files = []
-        check_environ()
-
-        # Where to look for the system-wide Distutils config file
-        sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
-
-        # Look for the system config file
-        sys_file = os.path.join(sys_dir, "distutils.cfg")
-        if os.path.isfile(sys_file):
-            files.append(sys_file)
-
-        # What to call the per-user config file
-        if os.name == 'posix':
-            user_filename = ".pydistutils.cfg"
-        else:
-            user_filename = "pydistutils.cfg"
-
-        # And look for the user config file
-        if self.want_user_cfg:
-            user_file = os.path.join(os.path.expanduser('~'), user_filename)
-            if os.path.isfile(user_file):
-                files.append(user_file)
-
-        # All platforms support local setup.cfg
-        local_file = "setup.cfg"
-        if os.path.isfile(local_file):
-            files.append(local_file)
-
-        if DEBUG:
-            self.announce("using config files: %s" % ', '.join(files))
-
-        return files
-
-    def parse_config_files(self, filenames=None):
-        from configparser import ConfigParser
-
-        # Ignore install directory options if we have a venv
-        if sys.prefix != sys.base_prefix:
-            ignore_options = [
-                'install-base', 'install-platbase', 'install-lib',
-                'install-platlib', 'install-purelib', 'install-headers',
-                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
-                'home', 'user', 'root']
-        else:
-            ignore_options = []
-
-        ignore_options = frozenset(ignore_options)
-
-        if filenames is None:
-            filenames = self.find_config_files()
-
-        if DEBUG:
-            self.announce("Distribution.parse_config_files():")
-
-        parser = ConfigParser()
-        for filename in filenames:
-            if DEBUG:
-                self.announce("  reading %s" % filename)
-            parser.read(filename)
-            for section in parser.sections():
-                options = parser.options(section)
-                opt_dict = self.get_option_dict(section)
-
-                for opt in options:
-                    if opt != '__name__' and opt not in ignore_options:
-                        val = parser.get(section,opt)
-                        opt = opt.replace('-', '_')
-                        opt_dict[opt] = (filename, val)
-
-            # Make the ConfigParser forget everything (so we retain
-            # the original filenames that options come from)
-            parser.__init__()
-
-        # If there was a "global" section in the config file, use it
-        # to set Distribution options.
-
-        if 'global' in self.command_options:
-            for (opt, (src, val)) in self.command_options['global'].items():
-                alias = self.negative_opt.get(opt)
-                try:
-                    if alias:
-                        setattr(self, alias, not strtobool(val))
-                    elif opt in ('verbose', 'dry_run'): # ugh!
-                        setattr(self, opt, strtobool(val))
-                    else:
-                        setattr(self, opt, val)
-                except ValueError as msg:
-                    raise DistutilsOptionError(msg)
-
-    # -- Command-line parsing methods ----------------------------------
-
-    def parse_command_line(self):
-        """Parse the setup script's command line, taken from the
-        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
-        -- see 'setup()' in core.py).  This list is first processed for
-        "global options" -- options that set attributes of the Distribution
-        instance.  Then, it is alternately scanned for Distutils commands
-        and options for that command.  Each new command terminates the
-        options for the previous command.  The allowed options for a
-        command are determined by the 'user_options' attribute of the
-        command class -- thus, we have to be able to load command classes
-        in order to parse the command line.  Any error in that 'options'
-        attribute raises DistutilsGetoptError; any error on the
-        command-line raises DistutilsArgError.  If no Distutils commands
-        were found on the command line, raises DistutilsArgError.  Return
-        true if command-line was successfully parsed and we should carry
-        on with executing commands; false if no errors but we shouldn't
-        execute commands (currently, this only happens if user asks for
-        help).
-        """
-        #
-        # We now have enough information to show the Macintosh dialog
-        # that allows the user to interactively specify the "command line".
-        #
-        toplevel_options = self._get_toplevel_options()
-
-        # We have to parse the command line a bit at a time -- global
-        # options, then the first command, then its options, and so on --
-        # because each command will be handled by a different class, and
-        # the options that are valid for a particular class aren't known
-        # until we have loaded the command class, which doesn't happen
-        # until we know what the command is.
-
-        self.commands = []
-        parser = FancyGetopt(toplevel_options + self.display_options)
-        parser.set_negative_aliases(self.negative_opt)
-        parser.set_aliases({'licence': 'license'})
-        args = parser.getopt(args=self.script_args, object=self)
-        option_order = parser.get_option_order()
-        log.set_verbosity(self.verbose)
-
-        # for display options we return immediately
-        if self.handle_display_options(option_order):
-            return
-        while args:
-            args = self._parse_command_opts(parser, args)
-            if args is None:            # user asked for help (and got it)
-                return
-
-        # Handle the cases of --help as a "global" option, ie.
-        # "setup.py --help" and "setup.py --help command ...".  For the
-        # former, we show global options (--verbose, --dry-run, etc.)
-        # and display-only options (--name, --version, etc.); for the
-        # latter, we omit the display-only options and show help for
-        # each command listed on the command line.
-        if self.help:
-            self._show_help(parser,
-                            display_options=len(self.commands) == 0,
-                            commands=self.commands)
-            return
-
-        # Oops, no commands found -- an end-user error
-        if not self.commands:
-            raise DistutilsArgError("no commands supplied")
-
-        # All is well: return true
-        return True
-
-    def _get_toplevel_options(self):
-        """Return the non-display options recognized at the top level.
-
-        This includes options that are recognized *only* at the top
-        level as well as options recognized for commands.
-        """
-        return self.global_options + [
-            ("command-packages=", None,
-             "list of packages that provide distutils commands"),
-            ]
-
-    def _parse_command_opts(self, parser, args):
-        """Parse the command-line options for a single command.
-        'parser' must be a FancyGetopt instance; 'args' must be the list
-        of arguments, starting with the current command (whose options
-        we are about to parse).  Returns a new version of 'args' with
-        the next command at the front of the list; will be the empty
-        list if there are no more commands on the command line.  Returns
-        None if the user asked for help on this command.
-        """
-        # late import because of mutual dependence between these modules
-        from distutils.cmd import Command
-
-        # Pull the current command from the head of the command line
-        command = args[0]
-        if not command_re.match(command):
-            raise SystemExit("invalid command name '%s'" % command)
-        self.commands.append(command)
-
-        # Dig up the command class that implements this command, so we
-        # 1) know that it's a valid command, and 2) know which options
-        # it takes.
-        try:
-            cmd_class = self.get_command_class(command)
-        except DistutilsModuleError as msg:
-            raise DistutilsArgError(msg)
-
-        # Require that the command class be derived from Command -- want
-        # to be sure that the basic "command" interface is implemented.
-        if not issubclass(cmd_class, Command):
-            raise DistutilsClassError(
-                "command class %s must subclass Command" % cmd_class)
-
-        # Also make sure that the command object provides a list of its
-        # known options.
-        if not (hasattr(cmd_class, 'user_options') and
-                isinstance(cmd_class.user_options, list)):
-            msg = ("command class %s must provide "
-                "'user_options' attribute (a list of tuples)")
-            raise DistutilsClassError(msg % cmd_class)
-
-        # If the command class has a list of negative alias options,
-        # merge it in with the global negative aliases.
-        negative_opt = self.negative_opt
-        if hasattr(cmd_class, 'negative_opt'):
-            negative_opt = negative_opt.copy()
-            negative_opt.update(cmd_class.negative_opt)
-
-        # Check for help_options in command class.  They have a different
-        # format (tuple of four) so we need to preprocess them here.
-        if (hasattr(cmd_class, 'help_options') and
-                isinstance(cmd_class.help_options, list)):
-            help_options = fix_help_options(cmd_class.help_options)
-        else:
-            help_options = []
-
-        # All commands support the global options too, just by adding
-        # in 'global_options'.
-        parser.set_option_table(self.global_options +
-                                cmd_class.user_options +
-                                help_options)
-        parser.set_negative_aliases(negative_opt)
-        (args, opts) = parser.getopt(args[1:])
-        if hasattr(opts, 'help') and opts.help:
-            self._show_help(parser, display_options=0, commands=[cmd_class])
-            return
-
-        if (hasattr(cmd_class, 'help_options') and
-                isinstance(cmd_class.help_options, list)):
-            help_option_found=0
-            for (help_option, short, desc, func) in cmd_class.help_options:
-                if hasattr(opts, parser.get_attr_name(help_option)):
-                    help_option_found=1
-                    if callable(func):
-                        func()
-                    else:
-                        raise DistutilsClassError(
-                            "invalid help function %r for help option '%s': "
-                            "must be a callable object (function, etc.)"
-                            % (func, help_option))
-
-            if help_option_found:
-                return
-
-        # Put the options from the command-line into their official
-        # holding pen, the 'command_options' dictionary.
-        opt_dict = self.get_option_dict(command)
-        for (name, value) in vars(opts).items():
-            opt_dict[name] = ("command line", value)
-
-        return args
-
-    def finalize_options(self):
-        """Set final values for all the options on the Distribution
-        instance, analogous to the .finalize_options() method of Command
-        objects.
-        """
-        for attr in ('keywords', 'platforms'):
-            value = getattr(self.metadata, attr)
-            if value is None:
-                continue
-            if isinstance(value, str):
-                value = [elm.strip() for elm in value.split(',')]
-                setattr(self.metadata, attr, value)
-
-    def _show_help(self, parser, global_options=1, display_options=1,
-                   commands=[]):
-        """Show help for the setup script command-line in the form of
-        several lists of command-line options.  'parser' should be a
-        FancyGetopt instance; do not expect it to be returned in the
-        same state, as its option table will be reset to make it
-        generate the correct help text.
-
-        If 'global_options' is true, lists the global options:
-        --verbose, --dry-run, etc.  If 'display_options' is true, lists
-        the "display-only" options: --name, --version, etc.  Finally,
-        lists per-command help for every command name or command class
-        in 'commands'.
-        """
-        # late import because of mutual dependence between these modules
-        from distutils.core import gen_usage
-        from distutils.cmd import Command
-
-        if global_options:
-            if display_options:
-                options = self._get_toplevel_options()
-            else:
-                options = self.global_options
-            parser.set_option_table(options)
-            parser.print_help(self.common_usage + "\nGlobal options:")
-            print('')
-
-        if display_options:
-            parser.set_option_table(self.display_options)
-            parser.print_help(
-                "Information display options (just display " +
-                "information, ignore any commands)")
-            print('')
-
-        for command in self.commands:
-            if isinstance(command, type) and issubclass(command, Command):
-                klass = command
-            else:
-                klass = self.get_command_class(command)
-            if (hasattr(klass, 'help_options') and
-                    isinstance(klass.help_options, list)):
-                parser.set_option_table(klass.user_options +
-                                        fix_help_options(klass.help_options))
-            else:
-                parser.set_option_table(klass.user_options)
-            parser.print_help("Options for '%s' command:" % klass.__name__)
-            print('')
-
-        print(gen_usage(self.script_name))
-
-    def handle_display_options(self, option_order):
-        """If there were any non-global "display-only" options
-        (--help-commands or the metadata display options) on the command
-        line, display the requested info and return true; else return
-        false.
-        """
-        from distutils.core import gen_usage
-
-        # User just wants a list of commands -- we'll print it out and stop
-        # processing now (ie. if they ran "setup --help-commands foo bar",
-        # we ignore "foo bar").
-        if self.help_commands:
-            self.print_commands()
-            print('')
-            print(gen_usage(self.script_name))
-            return 1
-
-        # If user supplied any of the "display metadata" options, then
-        # display that metadata in the order in which the user supplied the
-        # metadata options.
-        any_display_options = 0
-        is_display_option = {}
-        for option in self.display_options:
-            is_display_option[option[0]] = 1
-
-        for (opt, val) in option_order:
-            if val and is_display_option.get(opt):
-                opt = translate_longopt(opt)
-                value = getattr(self.metadata, "get_"+opt)()
-                if opt in ['keywords', 'platforms']:
-                    print(','.join(value))
-                elif opt in ('classifiers', 'provides', 'requires',
-                             'obsoletes'):
-                    print('\n'.join(value))
-                else:
-                    print(value)
-                any_display_options = 1
-
-        return any_display_options
-
-    def print_command_list(self, commands, header, max_length):
-        """Print a subset of the list of all commands -- used by
-        'print_commands()'.
-        """
-        print(header + ":")
-
-        for cmd in commands:
-            klass = self.cmdclass.get(cmd)
-            if not klass:
-                klass = self.get_command_class(cmd)
-            try:
-                description = klass.description
-            except AttributeError:
-                description = "(no description available)"
-
-            print("  %-*s  %s" % (max_length, cmd, description))
-
-    def print_commands(self):
-        """Print out a help message listing all available commands with a
-        description of each.  The list is divided into "standard commands"
-        (listed in distutils.command.__all__) and "extra commands"
-        (mentioned in self.cmdclass, but not a standard command).  The
-        descriptions come from the command class attribute
-        'description'.
-        """
-        import distutils.command
-        std_commands = distutils.command.__all__
-        is_std = {}
-        for cmd in std_commands:
-            is_std[cmd] = 1
-
-        extra_commands = []
-        for cmd in self.cmdclass.keys():
-            if not is_std.get(cmd):
-                extra_commands.append(cmd)
-
-        max_length = 0
-        for cmd in (std_commands + extra_commands):
-            if len(cmd) > max_length:
-                max_length = len(cmd)
-
-        self.print_command_list(std_commands,
-                                "Standard commands",
-                                max_length)
-        if extra_commands:
-            print()
-            self.print_command_list(extra_commands,
-                                    "Extra commands",
-                                    max_length)
-
-    def get_command_list(self):
-        """Get a list of (command, description) tuples.
-        The list is divided into "standard commands" (listed in
-        distutils.command.__all__) and "extra commands" (mentioned in
-        self.cmdclass, but not a standard command).  The descriptions come
-        from the command class attribute 'description'.
-        """
-        # Currently this is only used on Mac OS, for the Mac-only GUI
-        # Distutils interface (by Jack Jansen)
-        import distutils.command
-        std_commands = distutils.command.__all__
-        is_std = {}
-        for cmd in std_commands:
-            is_std[cmd] = 1
-
-        extra_commands = []
-        for cmd in self.cmdclass.keys():
-            if not is_std.get(cmd):
-                extra_commands.append(cmd)
-
-        rv = []
-        for cmd in (std_commands + extra_commands):
-            klass = self.cmdclass.get(cmd)
-            if not klass:
-                klass = self.get_command_class(cmd)
-            try:
-                description = klass.description
-            except AttributeError:
-                description = "(no description available)"
-            rv.append((cmd, description))
-        return rv
-
-    # -- Command class/object methods ----------------------------------
-
-    def get_command_packages(self):
-        """Return a list of packages from which commands are loaded."""
-        pkgs = self.command_packages
-        if not isinstance(pkgs, list):
-            if pkgs is None:
-                pkgs = ''
-            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
-            if "distutils.command" not in pkgs:
-                pkgs.insert(0, "distutils.command")
-            self.command_packages = pkgs
-        return pkgs
-
-    def get_command_class(self, command):
-        """Return the class that implements the Distutils command named by
-        'command'.  First we check the 'cmdclass' dictionary; if the
-        command is mentioned there, we fetch the class object from the
-        dictionary and return it.  Otherwise we load the command module
-        ("distutils.command." + command) and fetch the command class from
-        the module.  The loaded class is also stored in 'cmdclass'
-        to speed future calls to 'get_command_class()'.
-
-        Raises DistutilsModuleError if the expected module could not be
-        found, or if that module does not define the expected class.
-        """
-        klass = self.cmdclass.get(command)
-        if klass:
-            return klass
-
-        for pkgname in self.get_command_packages():
-            module_name = "%s.%s" % (pkgname, command)
-            klass_name = command
-
-            try:
-                __import__(module_name)
-                module = sys.modules[module_name]
-            except ImportError:
-                continue
-
-            try:
-                klass = getattr(module, klass_name)
-            except AttributeError:
-                raise DistutilsModuleError(
-                    "invalid command '%s' (no class '%s' in module '%s')"
-                    % (command, klass_name, module_name))
-
-            self.cmdclass[command] = klass
-            return klass
-
-        raise DistutilsModuleError("invalid command '%s'" % command)
-
-    def get_command_obj(self, command, create=1):
-        """Return the command object for 'command'.  Normally this object
-        is cached on a previous call to 'get_command_obj()'; if no command
-        object for 'command' is in the cache, then we either create and
-        return it (if 'create' is true) or return None.
-        """
-        cmd_obj = self.command_obj.get(command)
-        if not cmd_obj and create:
-            if DEBUG:
-                self.announce("Distribution.get_command_obj(): "
-                              "creating '%s' command object" % command)
-
-            klass = self.get_command_class(command)
-            cmd_obj = self.command_obj[command] = klass(self)
-            self.have_run[command] = 0
-
-            # Set any options that were supplied in config files
-            # or on the command line.  (NB. support for error
-            # reporting is lame here: any errors aren't reported
-            # until 'finalize_options()' is called, which means
-            # we won't report the source of the error.)
-            options = self.command_options.get(command)
-            if options:
-                self._set_command_options(cmd_obj, options)
-
-        return cmd_obj
-
-    def _set_command_options(self, command_obj, option_dict=None):
-        """Set the options for 'command_obj' from 'option_dict'.  Basically
-        this means copying elements of a dictionary ('option_dict') to
-        attributes of an instance ('command').
-
-        'command_obj' must be a Command instance.  If 'option_dict' is not
-        supplied, uses the standard option dictionary for this command
-        (from 'self.command_options').
-        """
-        command_name = command_obj.get_command_name()
-        if option_dict is None:
-            option_dict = self.get_option_dict(command_name)
-
-        if DEBUG:
-            self.announce("  setting options for '%s' command:" % command_name)
-        for (option, (source, value)) in option_dict.items():
-            if DEBUG:
-                self.announce("    %s = %s (from %s)" % (option, value,
-                                                         source))
-            try:
-                bool_opts = [translate_longopt(o)
-                             for o in command_obj.boolean_options]
-            except AttributeError:
-                bool_opts = []
-            try:
-                neg_opt = command_obj.negative_opt
-            except AttributeError:
-                neg_opt = {}
-
-            try:
-                is_string = isinstance(value, str)
-                if option in neg_opt and is_string:
-                    setattr(command_obj, neg_opt[option], not strtobool(value))
-                elif option in bool_opts and is_string:
-                    setattr(command_obj, option, strtobool(value))
-                elif hasattr(command_obj, option):
-                    setattr(command_obj, option, value)
-                else:
-                    raise DistutilsOptionError(
-                        "error in %s: command '%s' has no such option '%s'"
-                        % (source, command_name, option))
-            except ValueError as msg:
-                raise DistutilsOptionError(msg)
-
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        """Reinitializes a command to the state it was in when first
-        returned by 'get_command_obj()': ie., initialized but not yet
-        finalized.  This provides the opportunity to sneak option
-        values in programmatically, overriding or supplementing
-        user-supplied values from the config files and command line.
-        You'll have to re-finalize the command object (by calling
-        'finalize_options()' or 'ensure_finalized()') before using it for
-        real.
-
-        'command' should be a command name (string) or command object.  If
-        'reinit_subcommands' is true, also reinitializes the command's
-        sub-commands, as declared by the 'sub_commands' class attribute (if
-        it has one).  See the "install" command for an example.  Only
-        reinitializes the sub-commands that actually matter, ie. those
-        whose test predicates return true.
-
-        Returns the reinitialized command object.
-        """
-        from distutils.cmd import Command
-        if not isinstance(command, Command):
-            command_name = command
-            command = self.get_command_obj(command_name)
-        else:
-            command_name = command.get_command_name()
-
-        if not command.finalized:
-            return command
-        command.initialize_options()
-        command.finalized = 0
-        self.have_run[command_name] = 0
-        self._set_command_options(command)
-
-        if reinit_subcommands:
-            for sub in command.get_sub_commands():
-                self.reinitialize_command(sub, reinit_subcommands)
-
-        return command
-
-    # -- Methods that operate on the Distribution ----------------------
-
-    def announce(self, msg, level=log.INFO):
-        log.log(level, msg)
-
-    def run_commands(self):
-        """Run each command that was seen on the setup script command line.
-        Uses the list of commands found and cache of command objects
-        created by 'get_command_obj()'.
-        """
-        for cmd in self.commands:
-            self.run_command(cmd)
-
-    # -- Methods that operate on its Commands --------------------------
-
-    def run_command(self, command):
-        """Do whatever it takes to run a command (including nothing at all,
-        if the command has already been run).  Specifically: if we have
-        already created and run the command named by 'command', return
-        silently without doing anything.  If the command named by 'command'
-        doesn't even have a command object yet, create one.  Then invoke
-        'run()' on that command object (or an existing one).
-        """
-        # Already been here, done that? then return silently.
-        if self.have_run.get(command):
-            return
-
-        log.info("running %s", command)
-        cmd_obj = self.get_command_obj(command)
-        cmd_obj.ensure_finalized()
-        cmd_obj.run()
-        self.have_run[command] = 1
-
-    # -- Distribution query methods ------------------------------------
-
-    def has_pure_modules(self):
-        return len(self.packages or self.py_modules or []) > 0
-
-    def has_ext_modules(self):
-        return self.ext_modules and len(self.ext_modules) > 0
-
-    def has_c_libraries(self):
-        return self.libraries and len(self.libraries) > 0
-
-    def has_modules(self):
-        return self.has_pure_modules() or self.has_ext_modules()
-
-    def has_headers(self):
-        return self.headers and len(self.headers) > 0
-
-    def has_scripts(self):
-        return self.scripts and len(self.scripts) > 0
-
-    def has_data_files(self):
-        return self.data_files and len(self.data_files) > 0
-
-    def is_pure(self):
-        return (self.has_pure_modules() and
-                not self.has_ext_modules() and
-                not self.has_c_libraries())
-
-    # -- Metadata query methods ----------------------------------------
-
-    # If you're looking for 'get_name()', 'get_version()', and so forth,
-    # they are defined in a sneaky way: the constructor binds self.get_XXX
-    # to self.metadata.get_XXX.  The actual code is in the
-    # DistributionMetadata class, below.
-
-class DistributionMetadata:
-    """Dummy class to hold the distribution meta-data: name, version,
-    author, and so forth.
-    """
-
-    _METHOD_BASENAMES = ("name", "version", "author", "author_email",
-                         "maintainer", "maintainer_email", "url",
-                         "license", "description", "long_description",
-                         "keywords", "platforms", "fullname", "contact",
-                         "contact_email", "classifiers", "download_url",
-                         # PEP 314
-                         "provides", "requires", "obsoletes",
-                         )
-
-    def __init__(self, path=None):
-        if path is not None:
-            self.read_pkg_file(open(path))
-        else:
-            self.name = None
-            self.version = None
-            self.author = None
-            self.author_email = None
-            self.maintainer = None
-            self.maintainer_email = None
-            self.url = None
-            self.license = None
-            self.description = None
-            self.long_description = None
-            self.keywords = None
-            self.platforms = None
-            self.classifiers = None
-            self.download_url = None
-            # PEP 314
-            self.provides = None
-            self.requires = None
-            self.obsoletes = None
-
-    def read_pkg_file(self, file):
-        """Reads the metadata values from a file object."""
-        msg = message_from_file(file)
-
-        def _read_field(name):
-            value = msg[name]
-            if value == 'UNKNOWN':
-                return None
-            return value
-
-        def _read_list(name):
-            values = msg.get_all(name, None)
-            if values == []:
-                return None
-            return values
-
-        metadata_version = msg['metadata-version']
-        self.name = _read_field('name')
-        self.version = _read_field('version')
-        self.description = _read_field('summary')
-        # we are filling author only.
-        self.author = _read_field('author')
-        self.maintainer = None
-        self.author_email = _read_field('author-email')
-        self.maintainer_email = None
-        self.url = _read_field('home-page')
-        self.license = _read_field('license')
-
-        if 'download-url' in msg:
-            self.download_url = _read_field('download-url')
-        else:
-            self.download_url = None
-
-        self.long_description = _read_field('description')
-        self.description = _read_field('summary')
-
-        if 'keywords' in msg:
-            self.keywords = _read_field('keywords').split(',')
-
-        self.platforms = _read_list('platform')
-        self.classifiers = _read_list('classifier')
-
-        # PEP 314 - these fields only exist in 1.1
-        if metadata_version == '1.1':
-            self.requires = _read_list('requires')
-            self.provides = _read_list('provides')
-            self.obsoletes = _read_list('obsoletes')
-        else:
-            self.requires = None
-            self.provides = None
-            self.obsoletes = None
-
-    def write_pkg_info(self, base_dir):
-        """Write the PKG-INFO file into the release tree.
-        """
-        with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
-                  encoding='UTF-8') as pkg_info:
-            self.write_pkg_file(pkg_info)
-
-    def write_pkg_file(self, file):
-        """Write the PKG-INFO format data to a file object.
-        """
-        version = '1.0'
-        if (self.provides or self.requires or self.obsoletes or
-                self.classifiers or self.download_url):
-            version = '1.1'
-
-        file.write('Metadata-Version: %s\n' % version)
-        file.write('Name: %s\n' % self.get_name())
-        file.write('Version: %s\n' % self.get_version())
-        file.write('Summary: %s\n' % self.get_description())
-        file.write('Home-page: %s\n' % self.get_url())
-        file.write('Author: %s\n' % self.get_contact())
-        file.write('Author-email: %s\n' % self.get_contact_email())
-        file.write('License: %s\n' % self.get_license())
-        if self.download_url:
-            file.write('Download-URL: %s\n' % self.download_url)
-
-        long_desc = rfc822_escape(self.get_long_description())
-        file.write('Description: %s\n' % long_desc)
-
-        keywords = ','.join(self.get_keywords())
-        if keywords:
-            file.write('Keywords: %s\n' % keywords)
-
-        self._write_list(file, 'Platform', self.get_platforms())
-        self._write_list(file, 'Classifier', self.get_classifiers())
-
-        # PEP 314
-        self._write_list(file, 'Requires', self.get_requires())
-        self._write_list(file, 'Provides', self.get_provides())
-        self._write_list(file, 'Obsoletes', self.get_obsoletes())
-
-    def _write_list(self, file, name, values):
-        for value in values:
-            file.write('%s: %s\n' % (name, value))
-
-    # -- Metadata query methods ----------------------------------------
-
-    def get_name(self):
-        return self.name or "UNKNOWN"
-
-    def get_version(self):
-        return self.version or "0.0.0"
-
-    def get_fullname(self):
-        return "%s-%s" % (self.get_name(), self.get_version())
-
-    def get_author(self):
-        return self.author or "UNKNOWN"
-
-    def get_author_email(self):
-        return self.author_email or "UNKNOWN"
-
-    def get_maintainer(self):
-        return self.maintainer or "UNKNOWN"
-
-    def get_maintainer_email(self):
-        return self.maintainer_email or "UNKNOWN"
-
-    def get_contact(self):
-        return self.maintainer or self.author or "UNKNOWN"
-
-    def get_contact_email(self):
-        return self.maintainer_email or self.author_email or "UNKNOWN"
-
-    def get_url(self):
-        return self.url or "UNKNOWN"
-
-    def get_license(self):
-        return self.license or "UNKNOWN"
-    get_licence = get_license
-
-    def get_description(self):
-        return self.description or "UNKNOWN"
-
-    def get_long_description(self):
-        return self.long_description or "UNKNOWN"
-
-    def get_keywords(self):
-        return self.keywords or []
-
-    def get_platforms(self):
-        return self.platforms or ["UNKNOWN"]
-
-    def get_classifiers(self):
-        return self.classifiers or []
-
-    def get_download_url(self):
-        return self.download_url or "UNKNOWN"
-
-    # PEP 314
-    def get_requires(self):
-        return self.requires or []
-
-    def set_requires(self, value):
-        import distutils.versionpredicate
-        for v in value:
-            distutils.versionpredicate.VersionPredicate(v)
-        self.requires = value
-
-    def get_provides(self):
-        return self.provides or []
-
-    def set_provides(self, value):
-        value = [v.strip() for v in value]
-        for v in value:
-            import distutils.versionpredicate
-            distutils.versionpredicate.split_provision(v)
-        self.provides = value
-
-    def get_obsoletes(self):
-        return self.obsoletes or []
-
-    def set_obsoletes(self, value):
-        import distutils.versionpredicate
-        for v in value:
-            distutils.versionpredicate.VersionPredicate(v)
-        self.obsoletes = value
-
-def fix_help_options(options):
-    """Convert a 4-tuple 'help_options' list as found in various command
-    classes to the 3-tuple form required by FancyGetopt.
-    """
-    new_options = []
-    for help_tuple in options:
-        new_options.append(help_tuple[0:3])
-    return new_options
diff --git a/Lib/distutils/errors.py b/Lib/distutils/errors.py
deleted file mode 100644
index 8b93059e19f..00000000000
--- a/Lib/distutils/errors.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""distutils.errors
-
-Provides exceptions used by the Distutils modules.  Note that Distutils
-modules may raise standard exceptions; in particular, SystemExit is
-usually raised for errors that are obviously the end-user's fault
-(eg. bad command-line arguments).
-
-This module is safe to use in "from ... import *" mode; it only exports
-symbols whose names start with "Distutils" and end with "Error"."""
-
-class DistutilsError (Exception):
-    """The root of all Distutils evil."""
-    pass
-
-class DistutilsModuleError (DistutilsError):
-    """Unable to load an expected module, or to find an expected class
-    within some module (in particular, command modules and classes)."""
-    pass
-
-class DistutilsClassError (DistutilsError):
-    """Some command class (or possibly distribution class, if anyone
-    feels a need to subclass Distribution) is found not to be holding
-    up its end of the bargain, ie. implementing some part of the
-    "command "interface."""
-    pass
-
-class DistutilsGetoptError (DistutilsError):
-    """The option table provided to 'fancy_getopt()' is bogus."""
-    pass
-
-class DistutilsArgError (DistutilsError):
-    """Raised by fancy_getopt in response to getopt.error -- ie. an
-    error in the command line usage."""
-    pass
-
-class DistutilsFileError (DistutilsError):
-    """Any problems in the filesystem: expected file not found, etc.
-    Typically this is for problems that we detect before OSError
-    could be raised."""
-    pass
-
-class DistutilsOptionError (DistutilsError):
-    """Syntactic/semantic errors in command options, such as use of
-    mutually conflicting options, or inconsistent options,
-    badly-spelled values, etc.  No distinction is made between option
-    values originating in the setup script, the command line, config
-    files, or what-have-you -- but if we *know* something originated in
-    the setup script, we'll raise DistutilsSetupError instead."""
-    pass
-
-class DistutilsSetupError (DistutilsError):
-    """For errors that can be definitely blamed on the setup script,
-    such as invalid keyword arguments to 'setup()'."""
-    pass
-
-class DistutilsPlatformError (DistutilsError):
-    """We don't know how to do something on the current platform (but
-    we do know how to do it on some platform) -- eg. trying to compile
-    C files on a platform not supported by a CCompiler subclass."""
-    pass
-
-class DistutilsExecError (DistutilsError):
-    """Any problems executing an external program (such as the C
-    compiler, when compiling C files)."""
-    pass
-
-class DistutilsInternalError (DistutilsError):
-    """Internal inconsistencies or impossibilities (obviously, this
-    should never be seen if the code is working!)."""
-    pass
-
-class DistutilsTemplateError (DistutilsError):
-    """Syntax error in a file list template."""
-
-class DistutilsByteCompileError(DistutilsError):
-    """Byte compile error."""
-
-# Exception classes used by the CCompiler implementation classes
-class CCompilerError (Exception):
-    """Some compile/link operation failed."""
-
-class PreprocessError (CCompilerError):
-    """Failure to preprocess one or more C/C++ files."""
-
-class CompileError (CCompilerError):
-    """Failure to compile one or more C/C++ source files."""
-
-class LibError (CCompilerError):
-    """Failure to create a static library from one or more C/C++ object
-    files."""
-
-class LinkError (CCompilerError):
-    """Failure to link one or more C/C++ object files into an executable
-    or shared library file."""
-
-class UnknownFileError (CCompilerError):
-    """Attempt to process an unknown file type."""
diff --git a/Lib/distutils/extension.py b/Lib/distutils/extension.py
deleted file mode 100644
index c507da360aa..00000000000
--- a/Lib/distutils/extension.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""distutils.extension
-
-Provides the Extension class, used to describe C/C++ extension
-modules in setup scripts."""
-
-import os
-import warnings
-
-# This class is really only used by the "build_ext" command, so it might
-# make sense to put it in distutils.command.build_ext.  However, that
-# module is already big enough, and I want to make this class a bit more
-# complex to simplify some common cases ("foo" module in "foo.c") and do
-# better error-checking ("foo.c" actually exists).
-#
-# Also, putting this in build_ext.py means every setup script would have to
-# import that large-ish module (indirectly, through distutils.core) in
-# order to do anything.
-
-class Extension:
-    """Just a collection of attributes that describes an extension
-    module and everything needed to build it (hopefully in a portable
-    way, but there are hooks that let you be as unportable as you need).
-
-    Instance attributes:
-      name : string
-        the full name of the extension, including any packages -- ie.
-        *not* a filename or pathname, but Python dotted name
-      sources : [string]
-        list of source filenames, relative to the distribution root
-        (where the setup script lives), in Unix form (slash-separated)
-        for portability.  Source files may be C, C++, SWIG (.i),
-        platform-specific resource files, or whatever else is recognized
-        by the "build_ext" command as source for a Python extension.
-      include_dirs : [string]
-        list of directories to search for C/C++ header files (in Unix
-        form for portability)
-      define_macros : [(name : string, value : string|None)]
-        list of macros to define; each macro is defined using a 2-tuple,
-        where 'value' is either the string to define it to or None to
-        define it without a particular value (equivalent of "#define
-        FOO" in source or -DFOO on Unix C compiler command line)
-      undef_macros : [string]
-        list of macros to undefine explicitly
-      library_dirs : [string]
-        list of directories to search for C/C++ libraries at link time
-      libraries : [string]
-        list of library names (not filenames or paths) to link against
-      runtime_library_dirs : [string]
-        list of directories to search for C/C++ libraries at run time
-        (for shared extensions, this is when the extension is loaded)
-      extra_objects : [string]
-        list of extra files to link with (eg. object files not implied
-        by 'sources', static library that must be explicitly specified,
-        binary resource files, etc.)
-      extra_compile_args : [string]
-        any extra platform- and compiler-specific information to use
-        when compiling the source files in 'sources'.  For platforms and
-        compilers where "command line" makes sense, this is typically a
-        list of command-line arguments, but for other platforms it could
-        be anything.
-      extra_link_args : [string]
-        any extra platform- and compiler-specific information to use
-        when linking object files together to create the extension (or
-        to create a new static Python interpreter).  Similar
-        interpretation as for 'extra_compile_args'.
-      export_symbols : [string]
-        list of symbols to be exported from a shared extension.  Not
-        used on all platforms, and not generally necessary for Python
-        extensions, which typically export exactly one symbol: "init" +
-        extension_name.
-      swig_opts : [string]
-        any extra options to pass to SWIG if a source file has the .i
-        extension.
-      depends : [string]
-        list of files that the extension depends on
-      language : string
-        extension language (i.e. "c", "c++", "objc"). Will be detected
-        from the source extensions if not provided.
-      optional : boolean
-        specifies that a build failure in the extension should not abort the
-        build process, but simply not install the failing extension.
-    """
-
-    # When adding arguments to this constructor, be sure to update
-    # setup_keywords in core.py.
-    def __init__(self, name, sources,
-                  include_dirs=None,
-                  define_macros=None,
-                  undef_macros=None,
-                  library_dirs=None,
-                  libraries=None,
-                  runtime_library_dirs=None,
-                  extra_objects=None,
-                  extra_compile_args=None,
-                  extra_link_args=None,
-                  export_symbols=None,
-                  swig_opts = None,
-                  depends=None,
-                  language=None,
-                  optional=None,
-                  **kw                      # To catch unknown keywords
-                 ):
-        if not isinstance(name, str):
-            raise AssertionError("'name' must be a string")
-        if not (isinstance(sources, list) and
-                all(isinstance(v, str) for v in sources)):
-            raise AssertionError("'sources' must be a list of strings")
-
-        self.name = name
-        self.sources = sources
-        self.include_dirs = include_dirs or []
-        self.define_macros = define_macros or []
-        self.undef_macros = undef_macros or []
-        self.library_dirs = library_dirs or []
-        self.libraries = libraries or []
-        self.runtime_library_dirs = runtime_library_dirs or []
-        self.extra_objects = extra_objects or []
-        self.extra_compile_args = extra_compile_args or []
-        self.extra_link_args = extra_link_args or []
-        self.export_symbols = export_symbols or []
-        self.swig_opts = swig_opts or []
-        self.depends = depends or []
-        self.language = language
-        self.optional = optional
-
-        # If there are unknown keyword options, warn about them
-        if len(kw) > 0:
-            options = [repr(option) for option in kw]
-            options = ', '.join(sorted(options))
-            msg = "Unknown Extension options: %s" % options
-            warnings.warn(msg)
-
-    def __repr__(self):
-        return '<%s.%s(%r) at %#x>' % (
-            self.__class__.__module__,
-            self.__class__.__qualname__,
-            self.name,
-            id(self))
-
-
-def read_setup_file(filename):
-    """Reads a Setup file and returns Extension instances."""
-    from distutils.sysconfig import (parse_makefile, expand_makefile_vars,
-                                     _variable_rx)
-
-    from distutils.text_file import TextFile
-    from distutils.util import split_quoted
-
-    # First pass over the file to gather "VAR = VALUE" assignments.
-    vars = parse_makefile(filename)
-
-    # Second pass to gobble up the real content: lines of the form
-    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
-    file = TextFile(filename,
-                    strip_comments=1, skip_blanks=1, join_lines=1,
-                    lstrip_ws=1, rstrip_ws=1)
-    try:
-        extensions = []
-
-        while True:
-            line = file.readline()
-            if line is None:                # eof
-                break
-            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
-                continue
-
-            if line[0] == line[-1] == "*":
-                file.warn("'%s' lines not handled yet" % line)
-                continue
-
-            line = expand_makefile_vars(line, vars)
-            words = split_quoted(line)
-
-            # NB. this parses a slightly different syntax than the old
-            # makesetup script: here, there must be exactly one extension per
-            # line, and it must be the first word of the line.  I have no idea
-            # why the old syntax supported multiple extensions per line, as
-            # they all wind up being the same.
-
-            module = words[0]
-            ext = Extension(module, [])
-            append_next_word = None
-
-            for word in words[1:]:
-                if append_next_word is not None:
-                    append_next_word.append(word)
-                    append_next_word = None
-                    continue
-
-                suffix = os.path.splitext(word)[1]
-                switch = word[0:2] ; value = word[2:]
-
-                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
-                    # hmm, should we do something about C vs. C++ sources?
-                    # or leave it up to the CCompiler implementation to
-                    # worry about?
-                    ext.sources.append(word)
-                elif switch == "-I":
-                    ext.include_dirs.append(value)
-                elif switch == "-D":
-                    equals = value.find("=")
-                    if equals == -1:        # bare "-DFOO" -- no value
-                        ext.define_macros.append((value, None))
-                    else:                   # "-DFOO=blah"
-                        ext.define_macros.append((value[0:equals],
-                                                  value[equals+2:]))
-                elif switch == "-U":
-                    ext.undef_macros.append(value)
-                elif switch == "-C":        # only here 'cause makesetup has it!
-                    ext.extra_compile_args.append(word)
-                elif switch == "-l":
-                    ext.libraries.append(value)
-                elif switch == "-L":
-                    ext.library_dirs.append(value)
-                elif switch == "-R":
-                    ext.runtime_library_dirs.append(value)
-                elif word == "-rpath":
-                    append_next_word = ext.runtime_library_dirs
-                elif word == "-Xlinker":
-                    append_next_word = ext.extra_link_args
-                elif word == "-Xcompiler":
-                    append_next_word = ext.extra_compile_args
-                elif switch == "-u":
-                    ext.extra_link_args.append(word)
-                    if not value:
-                        append_next_word = ext.extra_link_args
-                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
-                    # NB. a really faithful emulation of makesetup would
-                    # append a .o file to extra_objects only if it
-                    # had a slash in it; otherwise, it would s/.o/.c/
-                    # and append it to sources.  Hmmmm.
-                    ext.extra_objects.append(word)
-                else:
-                    file.warn("unrecognized argument '%s'" % word)
-
-            extensions.append(ext)
-    finally:
-        file.close()
-
-    return extensions
diff --git a/Lib/distutils/fancy_getopt.py b/Lib/distutils/fancy_getopt.py
deleted file mode 100644
index 7d170dd2773..00000000000
--- a/Lib/distutils/fancy_getopt.py
+++ /dev/null
@@ -1,457 +0,0 @@
-"""distutils.fancy_getopt
-
-Wrapper around the standard getopt module that provides the following
-additional features:
-  * short and long options are tied together
-  * options have help strings, so fancy_getopt could potentially
-    create a complete usage summary
-  * options set attributes of a passed-in object
-"""
-
-import sys, string, re
-import getopt
-from distutils.errors import *
-
-# Much like command_re in distutils.core, this is close to but not quite
-# the same as a Python NAME -- except, in the spirit of most GNU
-# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
-# The similarities to NAME are again not a coincidence...
-longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
-longopt_re = re.compile(r'^%s$' % longopt_pat)
-
-# For recognizing "negative alias" options, eg. "quiet=!verbose"
-neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))
-
-# This is used to translate long options to legitimate Python identifiers
-# (for use as attributes of some object).
-longopt_xlate = str.maketrans('-', '_')
-
-class FancyGetopt:
-    """Wrapper around the standard 'getopt()' module that provides some
-    handy extra functionality:
-      * short and long options are tied together
-      * options have help strings, and help text can be assembled
-        from them
-      * options set attributes of a passed-in object
-      * boolean options can have "negative aliases" -- eg. if
-        --quiet is the "negative alias" of --verbose, then "--quiet"
-        on the command line sets 'verbose' to false
-    """
-
-    def __init__(self, option_table=None):
-        # The option table is (currently) a list of tuples.  The
-        # tuples may have 3 or four values:
-        #   (long_option, short_option, help_string [, repeatable])
-        # if an option takes an argument, its long_option should have '='
-        # appended; short_option should just be a single character, no ':'
-        # in any case.  If a long_option doesn't have a corresponding
-        # short_option, short_option should be None.  All option tuples
-        # must have long options.
-        self.option_table = option_table
-
-        # 'option_index' maps long option names to entries in the option
-        # table (ie. those 3-tuples).
-        self.option_index = {}
-        if self.option_table:
-            self._build_index()
-
-        # 'alias' records (duh) alias options; {'foo': 'bar'} means
-        # --foo is an alias for --bar
-        self.alias = {}
-
-        # 'negative_alias' keeps track of options that are the boolean
-        # opposite of some other option
-        self.negative_alias = {}
-
-        # These keep track of the information in the option table.  We
-        # don't actually populate these structures until we're ready to
-        # parse the command-line, since the 'option_table' passed in here
-        # isn't necessarily the final word.
-        self.short_opts = []
-        self.long_opts = []
-        self.short2long = {}
-        self.attr_name = {}
-        self.takes_arg = {}
-
-        # And 'option_order' is filled up in 'getopt()'; it records the
-        # original order of options (and their values) on the command-line,
-        # but expands short options, converts aliases, etc.
-        self.option_order = []
-
-    def _build_index(self):
-        self.option_index.clear()
-        for option in self.option_table:
-            self.option_index[option[0]] = option
-
-    def set_option_table(self, option_table):
-        self.option_table = option_table
-        self._build_index()
-
-    def add_option(self, long_option, short_option=None, help_string=None):
-        if long_option in self.option_index:
-            raise DistutilsGetoptError(
-                  "option conflict: already an option '%s'" % long_option)
-        else:
-            option = (long_option, short_option, help_string)
-            self.option_table.append(option)
-            self.option_index[long_option] = option
-
-    def has_option(self, long_option):
-        """Return true if the option table for this parser has an
-        option with long name 'long_option'."""
-        return long_option in self.option_index
-
-    def get_attr_name(self, long_option):
-        """Translate long option name 'long_option' to the form it
-        has as an attribute of some object: ie., translate hyphens
-        to underscores."""
-        return long_option.translate(longopt_xlate)
-
-    def _check_alias_dict(self, aliases, what):
-        assert isinstance(aliases, dict)
-        for (alias, opt) in aliases.items():
-            if alias not in self.option_index:
-                raise DistutilsGetoptError(("invalid %s '%s': "
-                       "option '%s' not defined") % (what, alias, alias))
-            if opt not in self.option_index:
-                raise DistutilsGetoptError(("invalid %s '%s': "
-                       "aliased option '%s' not defined") % (what, alias, opt))
-
-    def set_aliases(self, alias):
-        """Set the aliases for this option parser."""
-        self._check_alias_dict(alias, "alias")
-        self.alias = alias
-
-    def set_negative_aliases(self, negative_alias):
-        """Set the negative aliases for this option parser.
-        'negative_alias' should be a dictionary mapping option names to
-        option names, both the key and value must already be defined
-        in the option table."""
-        self._check_alias_dict(negative_alias, "negative alias")
-        self.negative_alias = negative_alias
-
-    def _grok_option_table(self):
-        """Populate the various data structures that keep tabs on the
-        option table.  Called by 'getopt()' before it can do anything
-        worthwhile.
-        """
-        self.long_opts = []
-        self.short_opts = []
-        self.short2long.clear()
-        self.repeat = {}
-
-        for option in self.option_table:
-            if len(option) == 3:
-                long, short, help = option
-                repeat = 0
-            elif len(option) == 4:
-                long, short, help, repeat = option
-            else:
-                # the option table is part of the code, so simply
-                # assert that it is correct
-                raise ValueError("invalid option tuple: %r" % (option,))
-
-            # Type- and value-check the option names
-            if not isinstance(long, str) or len(long) < 2:
-                raise DistutilsGetoptError(("invalid long option '%s': "
-                       "must be a string of length >= 2") % long)
-
-            if (not ((short is None) or
-                     (isinstance(short, str) and len(short) == 1))):
-                raise DistutilsGetoptError("invalid short option '%s': "
-                       "must a single character or None" % short)
-
-            self.repeat[long] = repeat
-            self.long_opts.append(long)
-
-            if long[-1] == '=':             # option takes an argument?
-                if short: short = short + ':'
-                long = long[0:-1]
-                self.takes_arg[long] = 1
-            else:
-                # Is option is a "negative alias" for some other option (eg.
-                # "quiet" == "!verbose")?
-                alias_to = self.negative_alias.get(long)
-                if alias_to is not None:
-                    if self.takes_arg[alias_to]:
-                        raise DistutilsGetoptError(
-                              "invalid negative alias '%s': "
-                              "aliased option '%s' takes a value"
-                              % (long, alias_to))
-
-                    self.long_opts[-1] = long # XXX redundant?!
-                self.takes_arg[long] = 0
-
-            # If this is an alias option, make sure its "takes arg" flag is
-            # the same as the option it's aliased to.
-            alias_to = self.alias.get(long)
-            if alias_to is not None:
-                if self.takes_arg[long] != self.takes_arg[alias_to]:
-                    raise DistutilsGetoptError(
-                          "invalid alias '%s': inconsistent with "
-                          "aliased option '%s' (one of them takes a value, "
-                          "the other doesn't"
-                          % (long, alias_to))
-
-            # Now enforce some bondage on the long option name, so we can
-            # later translate it to an attribute name on some object.  Have
-            # to do this a bit late to make sure we've removed any trailing
-            # '='.
-            if not longopt_re.match(long):
-                raise DistutilsGetoptError(
-                       "invalid long option name '%s' "
-                       "(must be letters, numbers, hyphens only" % long)
-
-            self.attr_name[long] = self.get_attr_name(long)
-            if short:
-                self.short_opts.append(short)
-                self.short2long[short[0]] = long
-
-    def getopt(self, args=None, object=None):
-        """Parse command-line options in args. Store as attributes on object.
-
-        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
-        'object' is None or not supplied, creates a new OptionDummy
-        object, stores option values there, and returns a tuple (args,
-        object).  If 'object' is supplied, it is modified in place and
-        'getopt()' just returns 'args'; in both cases, the returned
-        'args' is a modified copy of the passed-in 'args' list, which
-        is left untouched.
-        """
-        if args is None:
-            args = sys.argv[1:]
-        if object is None:
-            object = OptionDummy()
-            created_object = True
-        else:
-            created_object = False
-
-        self._grok_option_table()
-
-        short_opts = ' '.join(self.short_opts)
-        try:
-            opts, args = getopt.getopt(args, short_opts, self.long_opts)
-        except getopt.error as msg:
-            raise DistutilsArgError(msg)
-
-        for opt, val in opts:
-            if len(opt) == 2 and opt[0] == '-': # it's a short option
-                opt = self.short2long[opt[1]]
-            else:
-                assert len(opt) > 2 and opt[:2] == '--'
-                opt = opt[2:]
-
-            alias = self.alias.get(opt)
-            if alias:
-                opt = alias
-
-            if not self.takes_arg[opt]:     # boolean option?
-                assert val == '', "boolean option can't have value"
-                alias = self.negative_alias.get(opt)
-                if alias:
-                    opt = alias
-                    val = 0
-                else:
-                    val = 1
-
-            attr = self.attr_name[opt]
-            # The only repeating option at the moment is 'verbose'.
-            # It has a negative option -q quiet, which should set verbose = 0.
-            if val and self.repeat.get(attr) is not None:
-                val = getattr(object, attr, 0) + 1
-            setattr(object, attr, val)
-            self.option_order.append((opt, val))
-
-        # for opts
-        if created_object:
-            return args, object
-        else:
-            return args
-
-    def get_option_order(self):
-        """Returns the list of (option, value) tuples processed by the
-        previous run of 'getopt()'.  Raises RuntimeError if
-        'getopt()' hasn't been called yet.
-        """
-        if self.option_order is None:
-            raise RuntimeError("'getopt()' hasn't been called yet")
-        else:
-            return self.option_order
-
-    def generate_help(self, header=None):
-        """Generate help text (a list of strings, one per suggested line of
-        output) from the option table for this FancyGetopt object.
-        """
-        # Blithely assume the option table is good: probably wouldn't call
-        # 'generate_help()' unless you've already called 'getopt()'.
-
-        # First pass: determine maximum length of long option names
-        max_opt = 0
-        for option in self.option_table:
-            long = option[0]
-            short = option[1]
-            l = len(long)
-            if long[-1] == '=':
-                l = l - 1
-            if short is not None:
-                l = l + 5                   # " (-x)" where short == 'x'
-            if l > max_opt:
-                max_opt = l
-
-        opt_width = max_opt + 2 + 2 + 2     # room for indent + dashes + gutter
-
-        # Typical help block looks like this:
-        #   --foo       controls foonabulation
-        # Help block for longest option looks like this:
-        #   --flimflam  set the flim-flam level
-        # and with wrapped text:
-        #   --flimflam  set the flim-flam level (must be between
-        #               0 and 100, except on Tuesdays)
-        # Options with short names will have the short name shown (but
-        # it doesn't contribute to max_opt):
-        #   --foo (-f)  controls foonabulation
-        # If adding the short option would make the left column too wide,
-        # we push the explanation off to the next line
-        #   --flimflam (-l)
-        #               set the flim-flam level
-        # Important parameters:
-        #   - 2 spaces before option block start lines
-        #   - 2 dashes for each long option name
-        #   - min. 2 spaces between option and explanation (gutter)
-        #   - 5 characters (incl. space) for short option name
-
-        # Now generate lines of help text.  (If 80 columns were good enough
-        # for Jesus, then 78 columns are good enough for me!)
-        line_width = 78
-        text_width = line_width - opt_width
-        big_indent = ' ' * opt_width
-        if header:
-            lines = [header]
-        else:
-            lines = ['Option summary:']
-
-        for option in self.option_table:
-            long, short, help = option[:3]
-            text = wrap_text(help, text_width)
-            if long[-1] == '=':
-                long = long[0:-1]
-
-            # Case 1: no short option at all (makes life easy)
-            if short is None:
-                if text:
-                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
-                else:
-                    lines.append("  --%-*s  " % (max_opt, long))
-
-            # Case 2: we have a short option, so we have to include it
-            # just after the long option
-            else:
-                opt_names = "%s (-%s)" % (long, short)
-                if text:
-                    lines.append("  --%-*s  %s" %
-                                 (max_opt, opt_names, text[0]))
-                else:
-                    lines.append("  --%-*s" % opt_names)
-
-            for l in text[1:]:
-                lines.append(big_indent + l)
-        return lines
-
-    def print_help(self, header=None, file=None):
-        if file is None:
-            file = sys.stdout
-        for line in self.generate_help(header):
-            file.write(line + "\n")
-
-
-def fancy_getopt(options, negative_opt, object, args):
-    parser = FancyGetopt(options)
-    parser.set_negative_aliases(negative_opt)
-    return parser.getopt(args, object)
-
-
-WS_TRANS = {ord(_wschar) : ' ' for _wschar in string.whitespace}
-
-def wrap_text(text, width):
-    """wrap_text(text : string, width : int) -> [string]
-
-    Split 'text' into multiple lines of no more than 'width' characters
-    each, and return the list of strings that results.
-    """
-    if text is None:
-        return []
-    if len(text) <= width:
-        return [text]
-
-    text = text.expandtabs()
-    text = text.translate(WS_TRANS)
-    chunks = re.split(r'( +|-+)', text)
-    chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings
-    lines = []
-
-    while chunks:
-        cur_line = []                   # list of chunks (to-be-joined)
-        cur_len = 0                     # length of current line
-
-        while chunks:
-            l = len(chunks[0])
-            if cur_len + l <= width:    # can squeeze (at least) this chunk in
-                cur_line.append(chunks[0])
-                del chunks[0]
-                cur_len = cur_len + l
-            else:                       # this line is full
-                # drop last chunk if all space
-                if cur_line and cur_line[-1][0] == ' ':
-                    del cur_line[-1]
-                break
-
-        if chunks:                      # any chunks left to process?
-            # if the current line is still empty, then we had a single
-            # chunk that's too big too fit on a line -- so we break
-            # down and break it up at the line width
-            if cur_len == 0:
-                cur_line.append(chunks[0][0:width])
-                chunks[0] = chunks[0][width:]
-
-            # all-whitespace chunks at the end of a line can be discarded
-            # (and we know from the re.split above that if a chunk has
-            # *any* whitespace, it is *all* whitespace)
-            if chunks[0][0] == ' ':
-                del chunks[0]
-
-        # and store this line in the list-of-all-lines -- as a single
-        # string, of course!
-        lines.append(''.join(cur_line))
-
-    return lines
-
-
-def translate_longopt(opt):
-    """Convert a long option name to a valid Python identifier by
-    changing "-" to "_".
-    """
-    return opt.translate(longopt_xlate)
-
-
-class OptionDummy:
-    """Dummy class just used as a place to hold command-line option
-    values as instance attributes."""
-
-    def __init__(self, options=[]):
-        """Create a new OptionDummy instance.  The attributes listed in
-        'options' will be initialized to None."""
-        for opt in options:
-            setattr(self, opt, None)
-
-
-if __name__ == "__main__":
-    text = """\
-Tra-la-la, supercalifragilisticexpialidocious.
-How *do* you spell that odd word, anyways?
-(Someone ask Mary -- she'll know [or she'll
-say, "How should I know?"].)"""
-
-    for w in (10, 20, 30, 40):
-        print("width: %d" % w)
-        print("\n".join(wrap_text(text, w)))
-        print()
diff --git a/Lib/distutils/file_util.py b/Lib/distutils/file_util.py
deleted file mode 100644
index b3fee35a6cc..00000000000
--- a/Lib/distutils/file_util.py
+++ /dev/null
@@ -1,238 +0,0 @@
-"""distutils.file_util
-
-Utility functions for operating on single files.
-"""
-
-import os
-from distutils.errors import DistutilsFileError
-from distutils import log
-
-# for generating verbose output in 'copy_file()'
-_copy_action = { None:   'copying',
-                 'hard': 'hard linking',
-                 'sym':  'symbolically linking' }
-
-
-def _copy_file_contents(src, dst, buffer_size=16*1024):
-    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
-    opening either file, reading from 'src', or writing to 'dst', raises
-    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
-    bytes (default 16k).  No attempt is made to handle anything apart from
-    regular files.
-    """
-    # Stolen from shutil module in the standard library, but with
-    # custom error-handling added.
-    fsrc = None
-    fdst = None
-    try:
-        try:
-            fsrc = open(src, 'rb')
-        except OSError as e:
-            raise DistutilsFileError("could not open '%s': %s" % (src, e.strerror))
-
-        if os.path.exists(dst):
-            try:
-                os.unlink(dst)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not delete '%s': %s" % (dst, e.strerror))
-
-        try:
-            fdst = open(dst, 'wb')
-        except OSError as e:
-            raise DistutilsFileError(
-                  "could not create '%s': %s" % (dst, e.strerror))
-
-        while True:
-            try:
-                buf = fsrc.read(buffer_size)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not read from '%s': %s" % (src, e.strerror))
-
-            if not buf:
-                break
-
-            try:
-                fdst.write(buf)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not write to '%s': %s" % (dst, e.strerror))
-    finally:
-        if fdst:
-            fdst.close()
-        if fsrc:
-            fsrc.close()
-
-def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
-              link=None, verbose=1, dry_run=0):
-    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
-    copied there with the same name; otherwise, it must be a filename.  (If
-    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
-    is true (the default), the file's mode (type and permission bits, or
-    whatever is analogous on the current platform) is copied.  If
-    'preserve_times' is true (the default), the last-modified and
-    last-access times are copied as well.  If 'update' is true, 'src' will
-    only be copied if 'dst' does not exist, or if 'dst' does exist but is
-    older than 'src'.
-
-    'link' allows you to make hard links (os.link) or symbolic links
-    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
-    None (the default), files are copied.  Don't set 'link' on systems that
-    don't support it: 'copy_file()' doesn't check if hard or symbolic
-    linking is available. If hardlink fails, falls back to
-    _copy_file_contents().
-
-    Under Mac OS, uses the native file copy function in macostools; on
-    other systems, uses '_copy_file_contents()' to copy file contents.
-
-    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
-    the output file, and 'copied' is true if the file was copied (or would
-    have been copied, if 'dry_run' true).
-    """
-    # XXX if the destination file already exists, we clobber it if
-    # copying, but blow up if linking.  Hmmm.  And I don't know what
-    # macostools.copyfile() does.  Should definitely be consistent, and
-    # should probably blow up if destination exists and we would be
-    # changing it (ie. it's not already a hard/soft link to src OR
-    # (not update) and (src newer than dst).
-
-    from distutils.dep_util import newer
-    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE
-
-    if not os.path.isfile(src):
-        raise DistutilsFileError(
-              "can't copy '%s': doesn't exist or not a regular file" % src)
-
-    if os.path.isdir(dst):
-        dir = dst
-        dst = os.path.join(dst, os.path.basename(src))
-    else:
-        dir = os.path.dirname(dst)
-
-    if update and not newer(src, dst):
-        if verbose >= 1:
-            log.debug("not copying %s (output up-to-date)", src)
-        return (dst, 0)
-
-    try:
-        action = _copy_action[link]
-    except KeyError:
-        raise ValueError("invalid value '%s' for 'link' argument" % link)
-
-    if verbose >= 1:
-        if os.path.basename(dst) == os.path.basename(src):
-            log.info("%s %s -> %s", action, src, dir)
-        else:
-            log.info("%s %s -> %s", action, src, dst)
-
-    if dry_run:
-        return (dst, 1)
-
-    # If linking (hard or symbolic), use the appropriate system call
-    # (Unix only, of course, but that's the caller's responsibility)
-    elif link == 'hard':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            try:
-                os.link(src, dst)
-                return (dst, 1)
-            except OSError:
-                # If hard linking fails, fall back on copying file
-                # (some special filesystems don't support hard linking
-                #  even under Unix, see issue #8876).
-                pass
-    elif link == 'sym':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            os.symlink(src, dst)
-            return (dst, 1)
-
-    # Otherwise (non-Mac, not linking), copy the file contents and
-    # (optionally) copy the times and mode.
-    _copy_file_contents(src, dst)
-    if preserve_mode or preserve_times:
-        st = os.stat(src)
-
-        # According to David Ascher <da@ski.org>, utime() should be done
-        # before chmod() (at least under NT).
-        if preserve_times:
-            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
-        if preserve_mode:
-            os.chmod(dst, S_IMODE(st[ST_MODE]))
-
-    return (dst, 1)
-
-
-# XXX I suspect this is Unix-specific -- need porting help!
-def move_file (src, dst,
-               verbose=1,
-               dry_run=0):
-
-    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
-    be moved into it with the same name; otherwise, 'src' is just renamed
-    to 'dst'.  Return the new full name of the file.
-
-    Handles cross-device moves on Unix using 'copy_file()'.  What about
-    other systems???
-    """
-    from os.path import exists, isfile, isdir, basename, dirname
-    import errno
-
-    if verbose >= 1:
-        log.info("moving %s -> %s", src, dst)
-
-    if dry_run:
-        return dst
-
-    if not isfile(src):
-        raise DistutilsFileError("can't move '%s': not a regular file" % src)
-
-    if isdir(dst):
-        dst = os.path.join(dst, basename(src))
-    elif exists(dst):
-        raise DistutilsFileError(
-              "can't move '%s': destination '%s' already exists" %
-              (src, dst))
-
-    if not isdir(dirname(dst)):
-        raise DistutilsFileError(
-              "can't move '%s': destination '%s' not a valid path" %
-              (src, dst))
-
-    copy_it = False
-    try:
-        os.rename(src, dst)
-    except OSError as e:
-        (num, msg) = e.args
-        if num == errno.EXDEV:
-            copy_it = True
-        else:
-            raise DistutilsFileError(
-                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))
-
-    if copy_it:
-        copy_file(src, dst, verbose=verbose)
-        try:
-            os.unlink(src)
-        except OSError as e:
-            (num, msg) = e.args
-            try:
-                os.unlink(dst)
-            except OSError:
-                pass
-            raise DistutilsFileError(
-                  "couldn't move '%s' to '%s' by copy/delete: "
-                  "delete '%s' failed: %s"
-                  % (src, dst, src, msg))
-    return dst
-
-
-def write_file (filename, contents):
-    """Create a file with the specified name and write 'contents' (a
-    sequence of strings without line terminators) to it.
-    """
-    f = open(filename, "w")
-    try:
-        for line in contents:
-            f.write(line + "\n")
-    finally:
-        f.close()
diff --git a/Lib/distutils/filelist.py b/Lib/distutils/filelist.py
deleted file mode 100644
index c92d5fdba39..00000000000
--- a/Lib/distutils/filelist.py
+++ /dev/null
@@ -1,327 +0,0 @@
-"""distutils.filelist
-
-Provides the FileList class, used for poking about the filesystem
-and building lists of files.
-"""
-
-import os, re
-import fnmatch
-import functools
-from distutils.util import convert_path
-from distutils.errors import DistutilsTemplateError, DistutilsInternalError
-from distutils import log
-
-class FileList:
-    """A list of files built by on exploring the filesystem and filtered by
-    applying various patterns to what we find there.
-
-    Instance attributes:
-      dir
-        directory from which files will be taken -- only used if
-        'allfiles' not supplied to constructor
-      files
-        list of filenames currently being built/filtered/manipulated
-      allfiles
-        complete list of files under consideration (ie. without any
-        filtering applied)
-    """
-
-    def __init__(self, warn=None, debug_print=None):
-        # ignore argument to FileList, but keep them for backwards
-        # compatibility
-        self.allfiles = None
-        self.files = []
-
-    def set_allfiles(self, allfiles):
-        self.allfiles = allfiles
-
-    def findall(self, dir=os.curdir):
-        self.allfiles = findall(dir)
-
-    def debug_print(self, msg):
-        """Print 'msg' to stdout if the global DEBUG (taken from the
-        DISTUTILS_DEBUG environment variable) flag is true.
-        """
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-
-    # -- List-like methods ---------------------------------------------
-
-    def append(self, item):
-        self.files.append(item)
-
-    def extend(self, items):
-        self.files.extend(items)
-
-    def sort(self):
-        # Not a strict lexical sort!
-        sortable_files = sorted(map(os.path.split, self.files))
-        self.files = []
-        for sort_tuple in sortable_files:
-            self.files.append(os.path.join(*sort_tuple))
-
-
-    # -- Other miscellaneous utility methods ---------------------------
-
-    def remove_duplicates(self):
-        # Assumes list has been sorted!
-        for i in range(len(self.files) - 1, 0, -1):
-            if self.files[i] == self.files[i - 1]:
-                del self.files[i]
-
-
-    # -- "File template" methods ---------------------------------------
-
-    def _parse_template_line(self, line):
-        words = line.split()
-        action = words[0]
-
-        patterns = dir = dir_pattern = None
-
-        if action in ('include', 'exclude',
-                      'global-include', 'global-exclude'):
-            if len(words) < 2:
-                raise DistutilsTemplateError(
-                      "'%s' expects <pattern1> <pattern2> ..." % action)
-            patterns = [convert_path(w) for w in words[1:]]
-        elif action in ('recursive-include', 'recursive-exclude'):
-            if len(words) < 3:
-                raise DistutilsTemplateError(
-                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action)
-            dir = convert_path(words[1])
-            patterns = [convert_path(w) for w in words[2:]]
-        elif action in ('graft', 'prune'):
-            if len(words) != 2:
-                raise DistutilsTemplateError(
-                      "'%s' expects a single <dir_pattern>" % action)
-            dir_pattern = convert_path(words[1])
-        else:
-            raise DistutilsTemplateError("unknown action '%s'" % action)
-
-        return (action, patterns, dir, dir_pattern)
-
-    def process_template_line(self, line):
-        # Parse the line: split it up, make sure the right number of words
-        # is there, and return the relevant words.  'action' is always
-        # defined: it's the first word of the line.  Which of the other
-        # three are defined depends on the action; it'll be either
-        # patterns, (dir and patterns), or (dir_pattern).
-        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
-
-        # OK, now we know that the action is valid and we have the
-        # right number of words on the line for that action -- so we
-        # can proceed with minimal error-checking.
-        if action == 'include':
-            self.debug_print("include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=1):
-                    log.warn("warning: no files found matching '%s'",
-                             pattern)
-
-        elif action == 'exclude':
-            self.debug_print("exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=1):
-                    log.warn(("warning: no previously-included files "
-                              "found matching '%s'"), pattern)
-
-        elif action == 'global-include':
-            self.debug_print("global-include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=0):
-                    log.warn(("warning: no files found matching '%s' "
-                              "anywhere in distribution"), pattern)
-
-        elif action == 'global-exclude':
-            self.debug_print("global-exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=0):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found anywhere in distribution"),
-                             pattern)
-
-        elif action == 'recursive-include':
-            self.debug_print("recursive-include %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, prefix=dir):
-                    log.warn(("warning: no files found matching '%s' "
-                                "under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'recursive-exclude':
-            self.debug_print("recursive-exclude %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, prefix=dir):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'graft':
-            self.debug_print("graft " + dir_pattern)
-            if not self.include_pattern(None, prefix=dir_pattern):
-                log.warn("warning: no directories found matching '%s'",
-                         dir_pattern)
-
-        elif action == 'prune':
-            self.debug_print("prune " + dir_pattern)
-            if not self.exclude_pattern(None, prefix=dir_pattern):
-                log.warn(("no previously-included directories found "
-                          "matching '%s'"), dir_pattern)
-        else:
-            raise DistutilsInternalError(
-                  "this cannot happen: invalid action '%s'" % action)
-
-
-    # -- Filtering/selection methods -----------------------------------
-
-    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
-        """Select strings (presumably filenames) from 'self.files' that
-        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
-        are not quite the same as implemented by the 'fnmatch' module: '*'
-        and '?'  match non-special characters, where "special" is platform-
-        dependent: slash on Unix; colon, slash, and backslash on
-        DOS/Windows; and colon on Mac OS.
-
-        If 'anchor' is true (the default), then the pattern match is more
-        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
-        'anchor' is false, both of these will match.
-
-        If 'prefix' is supplied, then only filenames starting with 'prefix'
-        (itself a pattern) and ending with 'pattern', with anything in between
-        them, will match.  'anchor' is ignored in this case.
-
-        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
-        'pattern' is assumed to be either a string containing a regex or a
-        regex object -- no translation is done, the regex is just compiled
-        and used as-is.
-
-        Selected strings will be added to self.files.
-
-        Return True if files are found, False otherwise.
-        """
-        # XXX docstring lying about what the special chars are?
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("include_pattern: applying regex r'%s'" %
-                         pattern_re.pattern)
-
-        # delayed loading of allfiles list
-        if self.allfiles is None:
-            self.findall()
-
-        for name in self.allfiles:
-            if pattern_re.search(name):
-                self.debug_print(" adding " + name)
-                self.files.append(name)
-                files_found = True
-        return files_found
-
-
-    def exclude_pattern (self, pattern,
-                         anchor=1, prefix=None, is_regex=0):
-        """Remove strings (presumably filenames) from 'files' that match
-        'pattern'.  Other parameters are the same as for
-        'include_pattern()', above.
-        The list 'self.files' is modified in place.
-        Return True if files are found, False otherwise.
-        """
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("exclude_pattern: applying regex r'%s'" %
-                         pattern_re.pattern)
-        for i in range(len(self.files)-1, -1, -1):
-            if pattern_re.search(self.files[i]):
-                self.debug_print(" removing " + self.files[i])
-                del self.files[i]
-                files_found = True
-        return files_found
-
-
-# ----------------------------------------------------------------------
-# Utility functions
-
-def _find_all_simple(path):
-    """
-    Find all files under 'path'
-    """
-    results = (
-        os.path.join(base, file)
-        for base, dirs, files in os.walk(path, followlinks=True)
-        for file in files
-    )
-    return filter(os.path.isfile, results)
-
-
-def findall(dir=os.curdir):
-    """
-    Find all files under 'dir' and return the list of full filenames.
-    Unless dir is '.', return full filenames with dir prepended.
-    """
-    files = _find_all_simple(dir)
-    if dir == os.curdir:
-        make_rel = functools.partial(os.path.relpath, start=dir)
-        files = map(make_rel, files)
-    return list(files)
-
-
-def glob_to_re(pattern):
-    """Translate a shell-like glob pattern to a regular expression; return
-    a string containing the regex.  Differs from 'fnmatch.translate()' in
-    that '*' does not match "special characters" (which are
-    platform-specific).
-    """
-    pattern_re = fnmatch.translate(pattern)
-
-    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
-    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
-    # and by extension they shouldn't match such "special characters" under
-    # any OS.  So change all non-escaped dots in the RE to match any
-    # character except the special characters (currently: just os.sep).
-    sep = os.sep
-    if os.sep == '\\':
-        # we're using a regex to manipulate a regex, so we need
-        # to escape the backslash twice
-        sep = r'\\\\'
-    escaped = r'\1[^%s]' % sep
-    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
-    return pattern_re
-
-
-def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
-    """Translate a shell-like wildcard pattern to a compiled regular
-    expression.  Return the compiled regex.  If 'is_regex' true,
-    then 'pattern' is directly compiled to a regex (if it's a string)
-    or just returned as-is (assumes it's a regex object).
-    """
-    if is_regex:
-        if isinstance(pattern, str):
-            return re.compile(pattern)
-        else:
-            return pattern
-
-    # ditch start and end characters
-    start, _, end = glob_to_re('_').partition('_')
-
-    if pattern:
-        pattern_re = glob_to_re(pattern)
-        assert pattern_re.startswith(start) and pattern_re.endswith(end)
-    else:
-        pattern_re = ''
-
-    if prefix is not None:
-        prefix_re = glob_to_re(prefix)
-        assert prefix_re.startswith(start) and prefix_re.endswith(end)
-        prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
-        sep = os.sep
-        if os.sep == '\\':
-            sep = r'\\'
-        pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
-        pattern_re = r'%s\A%s%s.*%s%s' % (start, prefix_re, sep, pattern_re, end)
-    else:                               # no prefix -- respect anchor flag
-        if anchor:
-            pattern_re = r'%s\A%s' % (start, pattern_re[len(start):])
-
-    return re.compile(pattern_re)
diff --git a/Lib/distutils/log.py b/Lib/distutils/log.py
deleted file mode 100644
index 8ef6b28ea2e..00000000000
--- a/Lib/distutils/log.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""A simple log mechanism styled after PEP 282."""
-
-# The class here is styled after PEP 282 so that it could later be
-# replaced with a standard Python logging implementation.
-
-DEBUG = 1
-INFO = 2
-WARN = 3
-ERROR = 4
-FATAL = 5
-
-import sys
-
-class Log:
-
-    def __init__(self, threshold=WARN):
-        self.threshold = threshold
-
-    def _log(self, level, msg, args):
-        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
-            raise ValueError('%s wrong log level' % str(level))
-
-        if level >= self.threshold:
-            if args:
-                msg = msg % args
-            if level in (WARN, ERROR, FATAL):
-                stream = sys.stderr
-            else:
-                stream = sys.stdout
-            try:
-                stream.write('%s\n' % msg)
-            except UnicodeEncodeError:
-                # emulate backslashreplace error handler
-                encoding = stream.encoding
-                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
-                stream.write('%s\n' % msg)
-            stream.flush()
-
-    def log(self, level, msg, *args):
-        self._log(level, msg, args)
-
-    def debug(self, msg, *args):
-        self._log(DEBUG, msg, args)
-
-    def info(self, msg, *args):
-        self._log(INFO, msg, args)
-
-    def warn(self, msg, *args):
-        self._log(WARN, msg, args)
-
-    def error(self, msg, *args):
-        self._log(ERROR, msg, args)
-
-    def fatal(self, msg, *args):
-        self._log(FATAL, msg, args)
-
-_global_log = Log()
-log = _global_log.log
-debug = _global_log.debug
-info = _global_log.info
-warn = _global_log.warn
-error = _global_log.error
-fatal = _global_log.fatal
-
-def set_threshold(level):
-    # return the old threshold for use from tests
-    old = _global_log.threshold
-    _global_log.threshold = level
-    return old
-
-def set_verbosity(v):
-    if v <= 0:
-        set_threshold(WARN)
-    elif v == 1:
-        set_threshold(INFO)
-    elif v >= 2:
-        set_threshold(DEBUG)
diff --git a/Lib/distutils/msvc9compiler.py b/Lib/distutils/msvc9compiler.py
deleted file mode 100644
index 21191276227..00000000000
--- a/Lib/distutils/msvc9compiler.py
+++ /dev/null
@@ -1,791 +0,0 @@
-"""distutils.msvc9compiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for the Microsoft Visual Studio 2008.
-
-The module is compatible with VS 2005 and VS 2008. You can find legacy support
-for older versions of VS in distutils.msvccompiler.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-# ported to VS2005 and VS 2008 by Christian Heimes
-
-import os
-import subprocess
-import sys
-import re
-
-from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
-                             CompileError, LibError, LinkError
-from distutils.ccompiler import CCompiler, gen_preprocess_options, \
-                                gen_lib_options
-from distutils import log
-from distutils.util import get_platform
-
-import winreg
-
-RegOpenKeyEx = winreg.OpenKeyEx
-RegEnumKey = winreg.EnumKey
-RegEnumValue = winreg.EnumValue
-RegError = winreg.error
-
-HKEYS = (winreg.HKEY_USERS,
-         winreg.HKEY_CURRENT_USER,
-         winreg.HKEY_LOCAL_MACHINE,
-         winreg.HKEY_CLASSES_ROOT)
-
-NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
-if NATIVE_WIN64:
-    # Visual C++ is a 32-bit application, so we need to look in
-    # the corresponding registry branch, if we're running a
-    # 64-bit Python on Win64
-    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
-else:
-    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Microsoft\.NETFramework"
-
-# A map keyed by get_platform() return values to values accepted by
-# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
-# the param to cross-compile on x86 targeting amd64.)
-PLAT_TO_VCVARS = {
-    'win32' : 'x86',
-    'win-amd64' : 'amd64',
-    'win-ia64' : 'ia64',
-}
-
-class Reg:
-    """Helper class to read values from the registry
-    """
-
-    def get_value(cls, path, key):
-        for base in HKEYS:
-            d = cls.read_values(base, path)
-            if d and key in d:
-                return d[key]
-        raise KeyError(key)
-    get_value = classmethod(get_value)
-
-    def read_keys(cls, base, key):
-        """Return list of registry keys."""
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        L = []
-        i = 0
-        while True:
-            try:
-                k = RegEnumKey(handle, i)
-            except RegError:
-                break
-            L.append(k)
-            i += 1
-        return L
-    read_keys = classmethod(read_keys)
-
-    def read_values(cls, base, key):
-        """Return dict of registry keys and values.
-
-        All names are converted to lowercase.
-        """
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        d = {}
-        i = 0
-        while True:
-            try:
-                name, value, type = RegEnumValue(handle, i)
-            except RegError:
-                break
-            name = name.lower()
-            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
-            i += 1
-        return d
-    read_values = classmethod(read_values)
-
-    def convert_mbcs(s):
-        dec = getattr(s, "decode", None)
-        if dec is not None:
-            try:
-                s = dec("mbcs")
-            except UnicodeError:
-                pass
-        return s
-    convert_mbcs = staticmethod(convert_mbcs)
-
-class MacroExpander:
-
-    def __init__(self, version):
-        self.macros = {}
-        self.vsbase = VS_BASE % version
-        self.load_macros(version)
-
-    def set_macro(self, macro, path, key):
-        self.macros["$(%s)" % macro] = Reg.get_value(path, key)
-
-    def load_macros(self, version):
-        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
-        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
-        self.set_macro("FrameworkDir", NET_BASE, "installroot")
-        try:
-            if version >= 8.0:
-                self.set_macro("FrameworkSDKDir", NET_BASE,
-                               "sdkinstallrootv2.0")
-            else:
-                raise KeyError("sdkinstallrootv2.0")
-        except KeyError:
-            raise DistutilsPlatformError(
-            """Python was built with Visual Studio 2008;
-extensions must be built with a compiler than can generate compatible binaries.
-Visual Studio 2008 was not found on this system. If you have Cygwin installed,
-you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
-
-        if version >= 9.0:
-            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
-            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
-        else:
-            p = r"Software\Microsoft\NET Framework Setup\Product"
-            for base in HKEYS:
-                try:
-                    h = RegOpenKeyEx(base, p)
-                except RegError:
-                    continue
-                key = RegEnumKey(h, 0)
-                d = Reg.get_value(base, r"%s\%s" % (p, key))
-                self.macros["$(FrameworkVersion)"] = d["version"]
-
-    def sub(self, s):
-        for k, v in self.macros.items():
-            s = s.replace(k, v)
-        return s
-
-def get_build_version():
-    """Return the version of MSVC that was used to build Python.
-
-    For Python 2.3 and up, the version number is included in
-    sys.version.  For earlier versions, assume the compiler is MSVC 6.
-    """
-    prefix = "MSC v."
-    i = sys.version.find(prefix)
-    if i == -1:
-        return 6
-    i = i + len(prefix)
-    s, rest = sys.version[i:].split(" ", 1)
-    majorVersion = int(s[:-2]) - 6
-    if majorVersion >= 13:
-        # v13 was skipped and should be v14
-        majorVersion += 1
-    minorVersion = int(s[2:3]) / 10.0
-    # I don't think paths are affected by minor version in version 6
-    if majorVersion == 6:
-        minorVersion = 0
-    if majorVersion >= 6:
-        return majorVersion + minorVersion
-    # else we don't know what version of the compiler this is
-    return None
-
-def normalize_and_reduce_paths(paths):
-    """Return a list of normalized paths with duplicates removed.
-
-    The current order of paths is maintained.
-    """
-    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
-    reduced_paths = []
-    for p in paths:
-        np = os.path.normpath(p)
-        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
-        if np not in reduced_paths:
-            reduced_paths.append(np)
-    return reduced_paths
-
-def removeDuplicates(variable):
-    """Remove duplicate values of an environment variable.
-    """
-    oldList = variable.split(os.pathsep)
-    newList = []
-    for i in oldList:
-        if i not in newList:
-            newList.append(i)
-    newVariable = os.pathsep.join(newList)
-    return newVariable
-
-def find_vcvarsall(version):
-    """Find the vcvarsall.bat file
-
-    At first it tries to find the productdir of VS 2008 in the registry. If
-    that fails it falls back to the VS90COMNTOOLS env var.
-    """
-    vsbase = VS_BASE % version
-    try:
-        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
-                                   "productdir")
-    except KeyError:
-        log.debug("Unable to find productdir in registry")
-        productdir = None
-
-    if not productdir or not os.path.isdir(productdir):
-        toolskey = "VS%0.f0COMNTOOLS" % version
-        toolsdir = os.environ.get(toolskey, None)
-
-        if toolsdir and os.path.isdir(toolsdir):
-            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
-            productdir = os.path.abspath(productdir)
-            if not os.path.isdir(productdir):
-                log.debug("%s is not a valid directory" % productdir)
-                return None
-        else:
-            log.debug("Env var %s is not set or invalid" % toolskey)
-    if not productdir:
-        log.debug("No productdir found")
-        return None
-    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
-    if os.path.isfile(vcvarsall):
-        return vcvarsall
-    log.debug("Unable to find vcvarsall.bat")
-    return None
-
-def query_vcvarsall(version, arch="x86"):
-    """Launch vcvarsall.bat and read the settings from its environment
-    """
-    vcvarsall = find_vcvarsall(version)
-    interesting = set(("include", "lib", "libpath", "path"))
-    result = {}
-
-    if vcvarsall is None:
-        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
-    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
-    popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-    try:
-        stdout, stderr = popen.communicate()
-        if popen.wait() != 0:
-            raise DistutilsPlatformError(stderr.decode("mbcs"))
-
-        stdout = stdout.decode("mbcs")
-        for line in stdout.split("\n"):
-            line = Reg.convert_mbcs(line)
-            if '=' not in line:
-                continue
-            line = line.strip()
-            key, value = line.split('=', 1)
-            key = key.lower()
-            if key in interesting:
-                if value.endswith(os.pathsep):
-                    value = value[:-1]
-                result[key] = removeDuplicates(value)
-
-    finally:
-        popen.stdout.close()
-        popen.stderr.close()
-
-    if len(result) != len(interesting):
-        raise ValueError(str(list(result.keys())))
-
-    return result
-
-# More globals
-VERSION = get_build_version()
-if VERSION < 8.0:
-    raise DistutilsPlatformError("VC %0.1f is not supported by this module" % VERSION)
-# MACROS = MacroExpander(VERSION)
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        self.__version = VERSION
-        self.__root = r"Software\Microsoft\VisualStudio"
-        # self.__macros = MACROS
-        self.__paths = []
-        # target platform (.plat_name is consistent with 'bdist')
-        self.plat_name = None
-        self.__arch = None # deprecated name
-        self.initialized = False
-
-    def initialize(self, plat_name=None):
-        # multi-init means we would need to check platform same each time...
-        assert not self.initialized, "don't init multiple times"
-        if plat_name is None:
-            plat_name = get_platform()
-        # sanity check for platforms to prevent obscure errors later.
-        ok_plats = 'win32', 'win-amd64', 'win-ia64'
-        if plat_name not in ok_plats:
-            raise DistutilsPlatformError("--plat-name must be one of %s" %
-                                         (ok_plats,))
-
-        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
-            # Assume that the SDK set up everything alright; don't try to be
-            # smarter
-            self.cc = "cl.exe"
-            self.linker = "link.exe"
-            self.lib = "lib.exe"
-            self.rc = "rc.exe"
-            self.mc = "mc.exe"
-        else:
-            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
-            # to cross compile, you use 'x86_amd64'.
-            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
-            # compile use 'x86' (ie, it runs the x86 compiler directly)
-            # No idea how itanium handles this, if at all.
-            if plat_name == get_platform() or plat_name == 'win32':
-                # native build or cross-compile to win32
-                plat_spec = PLAT_TO_VCVARS[plat_name]
-            else:
-                # cross compile from win32 -> some 64bit
-                plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
-                            PLAT_TO_VCVARS[plat_name]
-
-            vc_env = query_vcvarsall(VERSION, plat_spec)
-
-            self.__paths = vc_env['path'].split(os.pathsep)
-            os.environ['lib'] = vc_env['lib']
-            os.environ['include'] = vc_env['include']
-
-            if len(self.__paths) == 0:
-                raise DistutilsPlatformError("Python was built with %s, "
-                       "and extensions need to be built with the same "
-                       "version of the compiler, but it isn't installed."
-                       % self.__product)
-
-            self.cc = self.find_exe("cl.exe")
-            self.linker = self.find_exe("link.exe")
-            self.lib = self.find_exe("lib.exe")
-            self.rc = self.find_exe("rc.exe")   # resource compiler
-            self.mc = self.find_exe("mc.exe")   # message compiler
-            #self.set_path_env_var('lib')
-            #self.set_path_env_var('include')
-
-        # extend the MSVC path with the current path
-        try:
-            for p in os.environ['path'].split(';'):
-                self.__paths.append(p)
-        except KeyError:
-            pass
-        self.__paths = normalize_and_reduce_paths(self.__paths)
-        os.environ['path'] = ";".join(self.__paths)
-
-        self.preprocess_options = None
-        if self.__arch == "x86":
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3',
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
-                                          '/Z7', '/D_DEBUG']
-        else:
-            # Win64
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
-                                          '/Z7', '/D_DEBUG']
-
-        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
-        if self.__version >= 7:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
-                ]
-        self.ldflags_static = [ '/nologo']
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        # Copied from ccompiler.py, extended to return .res as 'object'-file
-        # for .rc input file
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            (base, ext) = os.path.splitext (src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError ("Don't know how to compile %s" % src_name)
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in self._rc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            elif ext in self._mc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.obj_extension))
-        return obj_names
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append ('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts +
-                               [output_opt] + [input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc] +
-                               ['-h', h_dir, '-r', rc_dir] + [src])
-                    base, _ = os.path.splitext (os.path.basename (src))
-                    rc_file = os.path.join (rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc] +
-                               ["/fo" + obj] + [rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile %s to %s"
-                                   % (src, obj))
-
-            output_opt = "/Fo" + obj
-            try:
-                self.spawn([self.cc] + compile_opts + pp_opts +
-                           [input_opt, output_opt] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        (libraries, library_dirs, runtime_library_dirs) = fixed_args
-
-        if runtime_library_dirs:
-            self.warn ("I don't know what to do with 'runtime_library_dirs': "
-                       + str (runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            if target_desc == CCompiler.EXECUTABLE:
-                if debug:
-                    ldflags = self.ldflags_shared_debug[1:]
-                else:
-                    ldflags = self.ldflags_shared[1:]
-            else:
-                if debug:
-                    ldflags = self.ldflags_shared_debug
-                else:
-                    ldflags = self.ldflags_shared
-
-            export_opts = []
-            for sym in (export_symbols or []):
-                export_opts.append("/EXPORT:" + sym)
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            build_temp = os.path.dirname(objects[0])
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    build_temp,
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                self.spawn([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-            # embed the manifest
-            # XXX - this is somewhat fragile - if mt.exe fails, distutils
-            # will still consider the DLL up-to-date, but it will not have a
-            # manifest.  Maybe we should link to a temp file?  OTOH, that
-            # implies a build environment error that shouldn't go undetected.
-            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
-            if mfinfo is not None:
-                mffilename, mfid = mfinfo
-                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
-                try:
-                    self.spawn(['mt.exe', '-nologo', '-manifest',
-                                mffilename, out_arg])
-                except DistutilsExecError as msg:
-                    raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
-        # If we need a manifest at all, an embedded manifest is recommended.
-        # See MSDN article titled
-        # "How to: Embed a Manifest Inside a C/C++ Application"
-        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
-        # Ask the linker to generate the manifest in the temp dir, so
-        # we can check it, and possibly embed it, later.
-        temp_manifest = os.path.join(
-                build_temp,
-                os.path.basename(output_filename) + ".manifest")
-        ld_args.append('/MANIFESTFILE:' + temp_manifest)
-
-    def manifest_get_embed_info(self, target_desc, ld_args):
-        # If a manifest should be embedded, return a tuple of
-        # (manifest_filename, resource_id).  Returns None if no manifest
-        # should be embedded.  See http://bugs.python.org/issue7833 for why
-        # we want to avoid any manifest for extension modules if we can)
-        for arg in ld_args:
-            if arg.startswith("/MANIFESTFILE:"):
-                temp_manifest = arg.split(":", 1)[1]
-                break
-        else:
-            # no /MANIFESTFILE so nothing to do.
-            return None
-        if target_desc == CCompiler.EXECUTABLE:
-            # by default, executables always get the manifest with the
-            # CRT referenced.
-            mfid = 1
-        else:
-            # Extension modules try and avoid any manifest if possible.
-            mfid = 2
-            temp_manifest = self._remove_visual_c_ref(temp_manifest)
-        if temp_manifest is None:
-            return None
-        return temp_manifest, mfid
-
-    def _remove_visual_c_ref(self, manifest_file):
-        try:
-            # Remove references to the Visual C runtime, so they will
-            # fall through to the Visual C dependency of Python.exe.
-            # This way, when installed for a restricted user (e.g.
-            # runtimes are not in WinSxS folder, but in Python's own
-            # folder), the runtimes do not need to be in every folder
-            # with .pyd's.
-            # Returns either the filename of the modified manifest or
-            # None if no manifest should be embedded.
-            manifest_f = open(manifest_file)
-            try:
-                manifest_buf = manifest_f.read()
-            finally:
-                manifest_f.close()
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
-                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
-                re.DOTALL)
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            pattern = r"<dependentAssembly>\s*</dependentAssembly>"
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            # Now see if any other assemblies are referenced - if not, we
-            # don't want a manifest embedded.
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
-                r""".*?(?:/>|</assemblyIdentity>)""", re.DOTALL)
-            if re.search(pattern, manifest_buf) is None:
-                return None
-
-            manifest_f = open(manifest_file, 'w')
-            try:
-                manifest_f.write(manifest_buf)
-                return manifest_file
-            finally:
-                manifest_f.close()
-        except OSError:
-            pass
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC++")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename (name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # Helper methods for using the MSVC registry settings
-
-    def find_exe(self, exe):
-        """Return path to an MSVC executable program.
-
-        Tries to find the program in several places: first, one of the
-        MSVC program search paths from the registry; next, the directories
-        in the PATH environment variable.  If any of those work, return an
-        absolute path that is known to exist.  If none of them work, just
-        return the original program name, 'exe'.
-        """
-        for p in self.__paths:
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-
-        # didn't find it; try existing path
-        for p in os.environ['Path'].split(';'):
-            fn = os.path.join(os.path.abspath(p),exe)
-            if os.path.isfile(fn):
-                return fn
-
-        return exe
diff --git a/Lib/distutils/msvccompiler.py b/Lib/distutils/msvccompiler.py
deleted file mode 100644
index 1048cd41593..00000000000
--- a/Lib/distutils/msvccompiler.py
+++ /dev/null
@@ -1,643 +0,0 @@
-"""distutils.msvccompiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for the Microsoft Visual Studio.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-
-import sys, os
-from distutils.errors import \
-     DistutilsExecError, DistutilsPlatformError, \
-     CompileError, LibError, LinkError
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils import log
-
-_can_read_reg = False
-try:
-    import winreg
-
-    _can_read_reg = True
-    hkey_mod = winreg
-
-    RegOpenKeyEx = winreg.OpenKeyEx
-    RegEnumKey = winreg.EnumKey
-    RegEnumValue = winreg.EnumValue
-    RegError = winreg.error
-
-except ImportError:
-    try:
-        import win32api
-        import win32con
-        _can_read_reg = True
-        hkey_mod = win32con
-
-        RegOpenKeyEx = win32api.RegOpenKeyEx
-        RegEnumKey = win32api.RegEnumKey
-        RegEnumValue = win32api.RegEnumValue
-        RegError = win32api.error
-    except ImportError:
-        log.info("Warning: Can't read registry to find the "
-                 "necessary compiler setting\n"
-                 "Make sure that Python modules winreg, "
-                 "win32api or win32con are installed.")
-        pass
-
-if _can_read_reg:
-    HKEYS = (hkey_mod.HKEY_USERS,
-             hkey_mod.HKEY_CURRENT_USER,
-             hkey_mod.HKEY_LOCAL_MACHINE,
-             hkey_mod.HKEY_CLASSES_ROOT)
-
-def read_keys(base, key):
-    """Return list of registry keys."""
-    try:
-        handle = RegOpenKeyEx(base, key)
-    except RegError:
-        return None
-    L = []
-    i = 0
-    while True:
-        try:
-            k = RegEnumKey(handle, i)
-        except RegError:
-            break
-        L.append(k)
-        i += 1
-    return L
-
-def read_values(base, key):
-    """Return dict of registry keys and values.
-
-    All names are converted to lowercase.
-    """
-    try:
-        handle = RegOpenKeyEx(base, key)
-    except RegError:
-        return None
-    d = {}
-    i = 0
-    while True:
-        try:
-            name, value, type = RegEnumValue(handle, i)
-        except RegError:
-            break
-        name = name.lower()
-        d[convert_mbcs(name)] = convert_mbcs(value)
-        i += 1
-    return d
-
-def convert_mbcs(s):
-    dec = getattr(s, "decode", None)
-    if dec is not None:
-        try:
-            s = dec("mbcs")
-        except UnicodeError:
-            pass
-    return s
-
-class MacroExpander:
-    def __init__(self, version):
-        self.macros = {}
-        self.load_macros(version)
-
-    def set_macro(self, macro, path, key):
-        for base in HKEYS:
-            d = read_values(base, path)
-            if d:
-                self.macros["$(%s)" % macro] = d[key]
-                break
-
-    def load_macros(self, version):
-        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
-        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
-        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
-        net = r"Software\Microsoft\.NETFramework"
-        self.set_macro("FrameworkDir", net, "installroot")
-        try:
-            if version > 7.0:
-                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
-            else:
-                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
-        except KeyError as exc: #
-            raise DistutilsPlatformError(
-            """Python was built with Visual Studio 2003;
-extensions must be built with a compiler than can generate compatible binaries.
-Visual Studio 2003 was not found on this system. If you have Cygwin installed,
-you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
-
-        p = r"Software\Microsoft\NET Framework Setup\Product"
-        for base in HKEYS:
-            try:
-                h = RegOpenKeyEx(base, p)
-            except RegError:
-                continue
-            key = RegEnumKey(h, 0)
-            d = read_values(base, r"%s\%s" % (p, key))
-            self.macros["$(FrameworkVersion)"] = d["version"]
-
-    def sub(self, s):
-        for k, v in self.macros.items():
-            s = s.replace(k, v)
-        return s
-
-def get_build_version():
-    """Return the version of MSVC that was used to build Python.
-
-    For Python 2.3 and up, the version number is included in
-    sys.version.  For earlier versions, assume the compiler is MSVC 6.
-    """
-    prefix = "MSC v."
-    i = sys.version.find(prefix)
-    if i == -1:
-        return 6
-    i = i + len(prefix)
-    s, rest = sys.version[i:].split(" ", 1)
-    majorVersion = int(s[:-2]) - 6
-    if majorVersion >= 13:
-        # v13 was skipped and should be v14
-        majorVersion += 1
-    minorVersion = int(s[2:3]) / 10.0
-    # I don't think paths are affected by minor version in version 6
-    if majorVersion == 6:
-        minorVersion = 0
-    if majorVersion >= 6:
-        return majorVersion + minorVersion
-    # else we don't know what version of the compiler this is
-    return None
-
-def get_build_architecture():
-    """Return the processor architecture.
-
-    Possible results are "Intel", "Itanium", or "AMD64".
-    """
-
-    prefix = " bit ("
-    i = sys.version.find(prefix)
-    if i == -1:
-        return "Intel"
-    j = sys.version.find(")", i)
-    return sys.version[i+len(prefix):j]
-
-def normalize_and_reduce_paths(paths):
-    """Return a list of normalized paths with duplicates removed.
-
-    The current order of paths is maintained.
-    """
-    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
-    reduced_paths = []
-    for p in paths:
-        np = os.path.normpath(p)
-        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
-        if np not in reduced_paths:
-            reduced_paths.append(np)
-    return reduced_paths
-
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        self.__version = get_build_version()
-        self.__arch = get_build_architecture()
-        if self.__arch == "Intel":
-            # x86
-            if self.__version >= 7:
-                self.__root = r"Software\Microsoft\VisualStudio"
-                self.__macros = MacroExpander(self.__version)
-            else:
-                self.__root = r"Software\Microsoft\Devstudio"
-            self.__product = "Visual Studio version %s" % self.__version
-        else:
-            # Win64. Assume this was built with the platform SDK
-            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)
-
-        self.initialized = False
-
-    def initialize(self):
-        self.__paths = []
-        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
-            # Assume that the SDK set up everything alright; don't try to be
-            # smarter
-            self.cc = "cl.exe"
-            self.linker = "link.exe"
-            self.lib = "lib.exe"
-            self.rc = "rc.exe"
-            self.mc = "mc.exe"
-        else:
-            self.__paths = self.get_msvc_paths("path")
-
-            if len(self.__paths) == 0:
-                raise DistutilsPlatformError("Python was built with %s, "
-                       "and extensions need to be built with the same "
-                       "version of the compiler, but it isn't installed."
-                       % self.__product)
-
-            self.cc = self.find_exe("cl.exe")
-            self.linker = self.find_exe("link.exe")
-            self.lib = self.find_exe("lib.exe")
-            self.rc = self.find_exe("rc.exe")   # resource compiler
-            self.mc = self.find_exe("mc.exe")   # message compiler
-            self.set_path_env_var('lib')
-            self.set_path_env_var('include')
-
-        # extend the MSVC path with the current path
-        try:
-            for p in os.environ['path'].split(';'):
-                self.__paths.append(p)
-        except KeyError:
-            pass
-        self.__paths = normalize_and_reduce_paths(self.__paths)
-        os.environ['path'] = ";".join(self.__paths)
-
-        self.preprocess_options = None
-        if self.__arch == "Intel":
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GX' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX',
-                                          '/Z7', '/D_DEBUG']
-        else:
-            # Win64
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
-                                          '/Z7', '/D_DEBUG']
-
-        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
-        if self.__version >= 7:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
-                ]
-        else:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
-                ]
-        self.ldflags_static = [ '/nologo']
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        # Copied from ccompiler.py, extended to return .res as 'object'-file
-        # for .rc input file
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            (base, ext) = os.path.splitext (src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError ("Don't know how to compile %s" % src_name)
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in self._rc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            elif ext in self._mc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.obj_extension))
-        return obj_names
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append ('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts +
-                               [output_opt] + [input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc] +
-                               ['-h', h_dir, '-r', rc_dir] + [src])
-                    base, _ = os.path.splitext (os.path.basename (src))
-                    rc_file = os.path.join (rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc] +
-                               ["/fo" + obj] + [rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile %s to %s"
-                                   % (src, obj))
-
-            output_opt = "/Fo" + obj
-            try:
-                self.spawn([self.cc] + compile_opts + pp_opts +
-                           [input_opt, output_opt] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        (libraries, library_dirs, runtime_library_dirs) = fixed_args
-
-        if runtime_library_dirs:
-            self.warn ("I don't know what to do with 'runtime_library_dirs': "
-                       + str (runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            if target_desc == CCompiler.EXECUTABLE:
-                if debug:
-                    ldflags = self.ldflags_shared_debug[1:]
-                else:
-                    ldflags = self.ldflags_shared[1:]
-            else:
-                if debug:
-                    ldflags = self.ldflags_shared_debug
-                else:
-                    ldflags = self.ldflags_shared
-
-            export_opts = []
-            for sym in (export_symbols or []):
-                export_opts.append("/EXPORT:" + sym)
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    os.path.dirname(objects[0]),
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                self.spawn([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC++")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename (name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # Helper methods for using the MSVC registry settings
-
-    def find_exe(self, exe):
-        """Return path to an MSVC executable program.
-
-        Tries to find the program in several places: first, one of the
-        MSVC program search paths from the registry; next, the directories
-        in the PATH environment variable.  If any of those work, return an
-        absolute path that is known to exist.  If none of them work, just
-        return the original program name, 'exe'.
-        """
-        for p in self.__paths:
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-
-        # didn't find it; try existing path
-        for p in os.environ['Path'].split(';'):
-            fn = os.path.join(os.path.abspath(p),exe)
-            if os.path.isfile(fn):
-                return fn
-
-        return exe
-
-    def get_msvc_paths(self, path, platform='x86'):
-        """Get a list of devstudio directories (include, lib or path).
-
-        Return a list of strings.  The list will be empty if unable to
-        access the registry or appropriate registry keys not found.
-        """
-        if not _can_read_reg:
-            return []
-
-        path = path + " dirs"
-        if self.__version >= 7:
-            key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories"
-                   % (self.__root, self.__version))
-        else:
-            key = (r"%s\6.0\Build System\Components\Platforms"
-                   r"\Win32 (%s)\Directories" % (self.__root, platform))
-
-        for base in HKEYS:
-            d = read_values(base, key)
-            if d:
-                if self.__version >= 7:
-                    return self.__macros.sub(d[path]).split(";")
-                else:
-                    return d[path].split(";")
-        # MSVC 6 seems to create the registry entries we need only when
-        # the GUI is run.
-        if self.__version == 6:
-            for base in HKEYS:
-                if read_values(base, r"%s\6.0" % self.__root) is not None:
-                    self.warn("It seems you have Visual Studio 6 installed, "
-                        "but the expected registry settings are not present.\n"
-                        "You must at least run the Visual Studio GUI once "
-                        "so that these entries are created.")
-                    break
-        return []
-
-    def set_path_env_var(self, name):
-        """Set environment variable 'name' to an MSVC path type value.
-
-        This is equivalent to a SET command prior to execution of spawned
-        commands.
-        """
-
-        if name == "lib":
-            p = self.get_msvc_paths("library")
-        else:
-            p = self.get_msvc_paths(name)
-        if p:
-            os.environ[name] = ';'.join(p)
-
-
-if get_build_version() >= 8.0:
-    log.debug("Importing new compiler from distutils.msvc9compiler")
-    OldMSVCCompiler = MSVCCompiler
-    from distutils.msvc9compiler import MSVCCompiler
-    # get_build_architecture not really relevant now we support cross-compile
-    from distutils.msvc9compiler import MacroExpander
diff --git a/Lib/distutils/spawn.py b/Lib/distutils/spawn.py
deleted file mode 100644
index 53876880932..00000000000
--- a/Lib/distutils/spawn.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""distutils.spawn
-
-Provides the 'spawn()' function, a front-end to various platform-
-specific functions for launching another program in a sub-process.
-Also provides the 'find_executable()' to search the path for a given
-executable name.
-"""
-
-import sys
-import os
-
-from distutils.errors import DistutilsPlatformError, DistutilsExecError
-from distutils.debug import DEBUG
-from distutils import log
-
-def spawn(cmd, search_path=1, verbose=0, dry_run=0):
-    """Run another program, specified as a command list 'cmd', in a new process.
-
-    'cmd' is just the argument list for the new process, ie.
-    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
-    There is no way to run a program with a name different from that of its
-    executable.
-
-    If 'search_path' is true (the default), the system's executable
-    search path will be used to find the program; otherwise, cmd[0]
-    must be the exact path to the executable.  If 'dry_run' is true,
-    the command will not actually be run.
-
-    Raise DistutilsExecError if running the program fails in any way; just
-    return on success.
-    """
-    # cmd is documented as a list, but just in case some code passes a tuple
-    # in, protect our %-formatting code against horrible death
-    cmd = list(cmd)
-    if os.name == 'posix':
-        _spawn_posix(cmd, search_path, dry_run=dry_run)
-    elif os.name == 'nt':
-        _spawn_nt(cmd, search_path, dry_run=dry_run)
-    else:
-        raise DistutilsPlatformError(
-              "don't know how to spawn programs on platform '%s'" % os.name)
-
-def _nt_quote_args(args):
-    """Quote command-line arguments for DOS/Windows conventions.
-
-    Just wraps every argument which contains blanks in double quotes, and
-    returns a new argument list.
-    """
-    # XXX this doesn't seem very robust to me -- but if the Windows guys
-    # say it'll work, I guess I'll have to accept it.  (What if an arg
-    # contains quotes?  What other magic characters, other than spaces,
-    # have to be escaped?  Is there an escaping mechanism other than
-    # quoting?)
-    for i, arg in enumerate(args):
-        if ' ' in arg:
-            args[i] = '"%s"' % arg
-    return args
-
-def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
-    executable = cmd[0]
-    cmd = _nt_quote_args(cmd)
-    if search_path:
-        # either we find one or it stays the same
-        executable = find_executable(executable) or executable
-    log.info(' '.join([executable] + cmd[1:]))
-    if not dry_run:
-        # spawn for NT requires a full path to the .exe
-        try:
-            rc = os.spawnv(os.P_WAIT, executable, cmd)
-        except OSError as exc:
-            # this seems to happen when the command isn't found
-            if not DEBUG:
-                cmd = executable
-            raise DistutilsExecError(
-                  "command %r failed: %s" % (cmd, exc.args[-1]))
-        if rc != 0:
-            # and this reflects the command running but failing
-            if not DEBUG:
-                cmd = executable
-            raise DistutilsExecError(
-                  "command %r failed with exit status %d" % (cmd, rc))
-
-if sys.platform == 'darwin':
-    from distutils import sysconfig
-    _cfg_target = None
-    _cfg_target_split = None
-
-def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
-    log.info(' '.join(cmd))
-    if dry_run:
-        return
-    executable = cmd[0]
-    exec_fn = search_path and os.execvp or os.execv
-    env = None
-    if sys.platform == 'darwin':
-        global _cfg_target, _cfg_target_split
-        if _cfg_target is None:
-            _cfg_target = sysconfig.get_config_var(
-                                  'MACOSX_DEPLOYMENT_TARGET') or ''
-            if _cfg_target:
-                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
-        if _cfg_target:
-            # ensure that the deployment target of build process is not less
-            # than that used when the interpreter was built. This ensures
-            # extension modules are built with correct compatibility values
-            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
-            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
-                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
-                          'now "%s" but "%s" during configure'
-                                % (cur_target, _cfg_target))
-                raise DistutilsPlatformError(my_msg)
-            env = dict(os.environ,
-                       MACOSX_DEPLOYMENT_TARGET=cur_target)
-            exec_fn = search_path and os.execvpe or os.execve
-    pid = os.fork()
-    if pid == 0: # in the child
-        try:
-            if env is None:
-                exec_fn(executable, cmd)
-            else:
-                exec_fn(executable, cmd, env)
-        except OSError as e:
-            if not DEBUG:
-                cmd = executable
-            sys.stderr.write("unable to execute %r: %s\n"
-                             % (cmd, e.strerror))
-            os._exit(1)
-
-        if not DEBUG:
-            cmd = executable
-        sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
-        os._exit(1)
-    else: # in the parent
-        # Loop until the child either exits or is terminated by a signal
-        # (ie. keep waiting if it's merely stopped)
-        while True:
-            try:
-                pid, status = os.waitpid(pid, 0)
-            except OSError as exc:
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "command %r failed: %s" % (cmd, exc.args[-1]))
-            if os.WIFSIGNALED(status):
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "command %r terminated by signal %d"
-                      % (cmd, os.WTERMSIG(status)))
-            elif os.WIFEXITED(status):
-                exit_status = os.WEXITSTATUS(status)
-                if exit_status == 0:
-                    return   # hey, it succeeded!
-                else:
-                    if not DEBUG:
-                        cmd = executable
-                    raise DistutilsExecError(
-                          "command %r failed with exit status %d"
-                          % (cmd, exit_status))
-            elif os.WIFSTOPPED(status):
-                continue
-            else:
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "unknown error executing %r: termination status %d"
-                      % (cmd, status))
-
-def find_executable(executable, path=None):
-    """Tries to find 'executable' in the directories listed in 'path'.
-
-    A string listing directories separated by 'os.pathsep'; defaults to
-    os.environ['PATH'].  Returns the complete filename or None if not found.
-    """
-    if path is None:
-        path = os.environ.get('PATH', os.defpath)
-
-    paths = path.split(os.pathsep)
-    base, ext = os.path.splitext(executable)
-
-    if (sys.platform == 'win32') and (ext != '.exe'):
-        executable = executable + '.exe'
-
-    if not os.path.isfile(executable):
-        for p in paths:
-            f = os.path.join(p, executable)
-            if os.path.isfile(f):
-                # the file exists, we have a shot at spawn working
-                return f
-        return None
-    else:
-        return executable
diff --git a/Lib/distutils/sysconfig.py b/Lib/distutils/sysconfig.py
deleted file mode 100644
index 3a5984f5c01..00000000000
--- a/Lib/distutils/sysconfig.py
+++ /dev/null
@@ -1,556 +0,0 @@
-"""Provide access to Python's configuration information.  The specific
-configuration variables available depend heavily on the platform and
-configuration.  The values may be retrieved using
-get_config_var(name), and the list of variables is available via
-get_config_vars().keys().  Additional convenience functions are also
-available.
-
-Written by:   Fred L. Drake, Jr.
-Email:        <fdrake@acm.org>
-"""
-
-import _imp
-import os
-import re
-import sys
-
-from .errors import DistutilsPlatformError
-
-# These are needed in a couple of spots, so just compute them once.
-PREFIX = os.path.normpath(sys.prefix)
-EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
-BASE_PREFIX = os.path.normpath(sys.base_prefix)
-BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
-
-# Path to the base directory of the project. On Windows the binary may
-# live in project/PCbuild/win32 or project/PCbuild/amd64.
-# set for cross builds
-if "_PYTHON_PROJECT_BASE" in os.environ:
-    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
-else:
-    if sys.executable:
-        project_base = os.path.dirname(os.path.abspath(sys.executable))
-    else:
-        # sys.executable can be empty if argv[0] has been changed and Python is
-        # unable to retrieve the real program name
-        project_base = os.getcwd()
-
-
-# python_build: (Boolean) if true, we're either building Python or
-# building an extension with an un-installed Python, so we use
-# different (hard-wired) directories.
-def _is_python_source_dir(d):
-    for fn in ("Setup", "Setup.local"):
-        if os.path.isfile(os.path.join(d, "Modules", fn)):
-            return True
-    return False
-
-_sys_home = getattr(sys, '_home', None)
-
-if os.name == 'nt':
-    def _fix_pcbuild(d):
-        if d and os.path.normcase(d).startswith(
-                os.path.normcase(os.path.join(PREFIX, "PCbuild"))):
-            return PREFIX
-        return d
-    project_base = _fix_pcbuild(project_base)
-    _sys_home = _fix_pcbuild(_sys_home)
-
-def _python_build():
-    if _sys_home:
-        return _is_python_source_dir(_sys_home)
-    return _is_python_source_dir(project_base)
-
-python_build = _python_build()
-
-
-# Calculate the build qualifier flags if they are defined.  Adding the flags
-# to the include and lib directories only makes sense for an installation, not
-# an in-source build.
-build_flags = ''
-try:
-    if not python_build:
-        build_flags = sys.abiflags
-except AttributeError:
-    # It's not a configure-based build, so the sys module doesn't have
-    # this attribute, which is fine.
-    pass
-
-def get_python_version():
-    """Return a string containing the major and minor Python version,
-    leaving off the patchlevel.  Sample return values could be '1.5'
-    or '2.2'.
-    """
-    return '%d.%d' % sys.version_info[:2]
-
-
-def get_python_inc(plat_specific=0, prefix=None):
-    """Return the directory containing installed Python header files.
-
-    If 'plat_specific' is false (the default), this is the path to the
-    non-platform-specific header files, i.e. Python.h and so on;
-    otherwise, this is the path to platform-specific header files
-    (namely pyconfig.h).
-
-    If 'prefix' is supplied, use it instead of sys.base_prefix or
-    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
-    """
-    if prefix is None:
-        prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
-    if os.name == "posix":
-        if python_build:
-            # Assume the executable is in the build directory.  The
-            # pyconfig.h file should be in the same directory.  Since
-            # the build directory may not be the source directory, we
-            # must use "srcdir" from the makefile to find the "Include"
-            # directory.
-            if plat_specific:
-                return _sys_home or project_base
-            else:
-                incdir = os.path.join(get_config_var('srcdir'), 'Include')
-                return os.path.normpath(incdir)
-        python_dir = 'python' + get_python_version() + build_flags
-        return os.path.join(prefix, "include", python_dir)
-    elif os.name == "nt":
-        if python_build:
-            # Include both the include and PC dir to ensure we can find
-            # pyconfig.h
-            return (os.path.join(prefix, "include") + os.path.pathsep +
-                    os.path.join(prefix, "PC"))
-        return os.path.join(prefix, "include")
-    else:
-        raise DistutilsPlatformError(
-            "I don't know where Python installs its C header files "
-            "on platform '%s'" % os.name)
-
-
-def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
-    """Return the directory containing the Python library (standard or
-    site additions).
-
-    If 'plat_specific' is true, return the directory containing
-    platform-specific modules, i.e. any module from a non-pure-Python
-    module distribution; otherwise, return the platform-shared library
-    directory.  If 'standard_lib' is true, return the directory
-    containing standard Python library modules; otherwise, return the
-    directory for site-specific modules.
-
-    If 'prefix' is supplied, use it instead of sys.base_prefix or
-    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
-    """
-    if prefix is None:
-        if standard_lib:
-            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
-        else:
-            prefix = plat_specific and EXEC_PREFIX or PREFIX
-
-    if os.name == "posix":
-        if plat_specific or standard_lib:
-            # Platform-specific modules (any module from a non-pure-Python
-            # module distribution) or standard Python library modules.
-            libdir = sys.platlibdir
-        else:
-            # Pure Python
-            libdir = "lib"
-        libpython = os.path.join(prefix, libdir,
-                                 # XXX RUSTPYTHON: changed from python->rustpython
-                                 "rustpython" + get_python_version())
-        if standard_lib:
-            return libpython
-        else:
-            return os.path.join(libpython, "site-packages")
-    elif os.name == "nt":
-        if standard_lib:
-            return os.path.join(prefix, "Lib")
-        else:
-            return os.path.join(prefix, "Lib", "site-packages")
-    else:
-        raise DistutilsPlatformError(
-            "I don't know where Python installs its library "
-            "on platform '%s'" % os.name)
-
-
-
-def customize_compiler(compiler):
-    """Do any platform-specific customization of a CCompiler instance.
-
-    Mainly needed on Unix, so we can plug in the information that
-    varies across Unices and is stored in Python's Makefile.
-    """
-    if compiler.compiler_type == "unix":
-        if sys.platform == "darwin":
-            # Perform first-time customization of compiler-related
-            # config vars on OS X now that we know we need a compiler.
-            # This is primarily to support Pythons from binary
-            # installers.  The kind and paths to build tools on
-            # the user system may vary significantly from the system
-            # that Python itself was built on.  Also the user OS
-            # version and build tools may not support the same set
-            # of CPU architectures for universal builds.
-            global _config_vars
-            # Use get_config_var() to ensure _config_vars is initialized.
-            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
-                import _osx_support
-                _osx_support.customize_compiler(_config_vars)
-                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
-
-        (cc, cxx, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \
-            get_config_vars('CC', 'CXX', 'CFLAGS',
-                            'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')
-
-        if 'CC' in os.environ:
-            newcc = os.environ['CC']
-            if (sys.platform == 'darwin'
-                    and 'LDSHARED' not in os.environ
-                    and ldshared.startswith(cc)):
-                # On OS X, if CC is overridden, use that as the default
-                #       command for LDSHARED as well
-                ldshared = newcc + ldshared[len(cc):]
-            cc = newcc
-        if 'CXX' in os.environ:
-            cxx = os.environ['CXX']
-        if 'LDSHARED' in os.environ:
-            ldshared = os.environ['LDSHARED']
-        if 'CPP' in os.environ:
-            cpp = os.environ['CPP']
-        else:
-            cpp = cc + " -E"           # not always
-        if 'LDFLAGS' in os.environ:
-            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
-        if 'CFLAGS' in os.environ:
-            cflags = cflags + ' ' + os.environ['CFLAGS']
-            ldshared = ldshared + ' ' + os.environ['CFLAGS']
-        if 'CPPFLAGS' in os.environ:
-            cpp = cpp + ' ' + os.environ['CPPFLAGS']
-            cflags = cflags + ' ' + os.environ['CPPFLAGS']
-            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
-        if 'AR' in os.environ:
-            ar = os.environ['AR']
-        if 'ARFLAGS' in os.environ:
-            archiver = ar + ' ' + os.environ['ARFLAGS']
-        else:
-            archiver = ar + ' ' + ar_flags
-
-        cc_cmd = cc + ' ' + cflags
-        compiler.set_executables(
-            preprocessor=cpp,
-            compiler=cc_cmd,
-            compiler_so=cc_cmd + ' ' + ccshared,
-            compiler_cxx=cxx,
-            linker_so=ldshared,
-            linker_exe=cc,
-            archiver=archiver)
-
-        compiler.shared_lib_extension = shlib_suffix
-
-
-def get_config_h_filename():
-    """Return full pathname of installed pyconfig.h file."""
-    if python_build:
-        if os.name == "nt":
-            inc_dir = os.path.join(_sys_home or project_base, "PC")
-        else:
-            inc_dir = _sys_home or project_base
-    else:
-        inc_dir = get_python_inc(plat_specific=1)
-
-    return os.path.join(inc_dir, 'pyconfig.h')
-
-
-def get_makefile_filename():
-    """Return full pathname of installed Makefile from the Python build."""
-    if python_build:
-        return os.path.join(_sys_home or project_base, "Makefile")
-    lib_dir = get_python_lib(plat_specific=0, standard_lib=1)
-    config_file = 'config-{}{}'.format(get_python_version(), build_flags)
-    if hasattr(sys.implementation, '_multiarch'):
-        config_file += '-%s' % sys.implementation._multiarch
-    return os.path.join(lib_dir, config_file, 'Makefile')
-
-
-def parse_config_h(fp, g=None):
-    """Parse a config.h-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    if g is None:
-        g = {}
-    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
-    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
-    #
-    while True:
-        line = fp.readline()
-        if not line:
-            break
-        m = define_rx.match(line)
-        if m:
-            n, v = m.group(1, 2)
-            try: v = int(v)
-            except ValueError: pass
-            g[n] = v
-        else:
-            m = undef_rx.match(line)
-            if m:
-                g[m.group(1)] = 0
-    return g
-
-
-# Regexes needed for parsing Makefile (and similar syntaxes,
-# like old-style Setup files).
-_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
-_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
-_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
-
-def parse_makefile(fn, g=None):
-    """Parse a Makefile-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    from distutils.text_file import TextFile
-    fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape")
-
-    if g is None:
-        g = {}
-    done = {}
-    notdone = {}
-
-    while True:
-        line = fp.readline()
-        if line is None: # eof
-            break
-        m = _variable_rx.match(line)
-        if m:
-            n, v = m.group(1, 2)
-            v = v.strip()
-            # `$$' is a literal `$' in make
-            tmpv = v.replace('$$', '')
-
-            if "$" in tmpv:
-                notdone[n] = v
-            else:
-                try:
-                    v = int(v)
-                except ValueError:
-                    # insert literal `$'
-                    done[n] = v.replace('$$', '$')
-                else:
-                    done[n] = v
-
-    # Variables with a 'PY_' prefix in the makefile. These need to
-    # be made available without that prefix through sysconfig.
-    # Special care is needed to ensure that variable expansion works, even
-    # if the expansion uses the name without a prefix.
-    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
-
-    # do variable interpolation here
-    while notdone:
-        for name in list(notdone):
-            value = notdone[name]
-            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
-            if m:
-                n = m.group(1)
-                found = True
-                if n in done:
-                    item = str(done[n])
-                elif n in notdone:
-                    # get it on a subsequent round
-                    found = False
-                elif n in os.environ:
-                    # do it like make: fall back to environment
-                    item = os.environ[n]
-
-                elif n in renamed_variables:
-                    if name.startswith('PY_') and name[3:] in renamed_variables:
-                        item = ""
-
-                    elif 'PY_' + n in notdone:
-                        found = False
-
-                    else:
-                        item = str(done['PY_' + n])
-                else:
-                    done[n] = item = ""
-                if found:
-                    after = value[m.end():]
-                    value = value[:m.start()] + item + after
-                    if "$" in after:
-                        notdone[name] = value
-                    else:
-                        try: value = int(value)
-                        except ValueError:
-                            done[name] = value.strip()
-                        else:
-                            done[name] = value
-                        del notdone[name]
-
-                        if name.startswith('PY_') \
-                            and name[3:] in renamed_variables:
-
-                            name = name[3:]
-                            if name not in done:
-                                done[name] = value
-            else:
-                # bogus variable reference; just drop it since we can't deal
-                del notdone[name]
-
-    fp.close()
-
-    # strip spurious spaces
-    for k, v in done.items():
-        if isinstance(v, str):
-            done[k] = v.strip()
-
-    # save the results in the global dictionary
-    g.update(done)
-    return g
-
-
-def expand_makefile_vars(s, vars):
-    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
-    'string' according to 'vars' (a dictionary mapping variable names to
-    values).  Variables not present in 'vars' are silently expanded to the
-    empty string.  The variable values in 'vars' should not contain further
-    variable expansions; if 'vars' is the output of 'parse_makefile()',
-    you're fine.  Returns a variable-expanded version of 's'.
-    """
-
-    # This algorithm does multiple expansion, so if vars['foo'] contains
-    # "${bar}", it will expand ${foo} to ${bar}, and then expand
-    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
-    # 'parse_makefile()', which takes care of such expansions eagerly,
-    # according to make's variable expansion semantics.
-
-    while True:
-        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
-        if m:
-            (beg, end) = m.span()
-            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
-        else:
-            break
-    return s
-
-
-_config_vars = None
-
-def _init_posix():
-    """Initialize the module as appropriate for POSIX systems."""
-    # _sysconfigdata is generated at build time, see the sysconfig module
-    name = os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',
-        '_sysconfigdata_{abi}_{platform}_{multiarch}'.format(
-        abi=sys.abiflags,
-        platform=sys.platform,
-        multiarch=getattr(sys.implementation, '_multiarch', ''),
-    ))
-    _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
-    build_time_vars = _temp.build_time_vars
-    global _config_vars
-    _config_vars = {}
-    _config_vars.update(build_time_vars)
-
-
-def _init_nt():
-    """Initialize the module as appropriate for NT"""
-    g = {}
-    # set basic install directories
-    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
-    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
-
-    # XXX hmmm.. a normal install puts include files here
-    g['INCLUDEPY'] = get_python_inc(plat_specific=0)
-
-    g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
-    g['EXE'] = ".exe"
-    g['VERSION'] = get_python_version().replace(".", "")
-    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))
-
-    global _config_vars
-    _config_vars = g
-
-
-def get_config_vars(*args):
-    """With no arguments, return a dictionary of all configuration
-    variables relevant for the current platform.  Generally this includes
-    everything needed to build extensions and install both pure modules and
-    extensions.  On Unix, this means every variable defined in Python's
-    installed Makefile; on Windows it's a much smaller set.
-
-    With arguments, return a list of values that result from looking up
-    each argument in the configuration variable dictionary.
-    """
-    global _config_vars
-    if _config_vars is None:
-        func = globals().get("_init_" + os.name)
-        if func:
-            func()
-        else:
-            _config_vars = {}
-
-        # Normalized versions of prefix and exec_prefix are handy to have;
-        # in fact, these are the standard versions used most places in the
-        # Distutils.
-        _config_vars['prefix'] = PREFIX
-        _config_vars['exec_prefix'] = EXEC_PREFIX
-
-        # For backward compatibility, see issue19555
-        SO = _config_vars.get('EXT_SUFFIX')
-        if SO is not None:
-            _config_vars['SO'] = SO
-
-        # Always convert srcdir to an absolute path
-        srcdir = _config_vars.get('srcdir', project_base)
-        if os.name == 'posix':
-            if python_build:
-                # If srcdir is a relative path (typically '.' or '..')
-                # then it should be interpreted relative to the directory
-                # containing Makefile.
-                base = os.path.dirname(get_makefile_filename())
-                srcdir = os.path.join(base, srcdir)
-            else:
-                # srcdir is not meaningful since the installation is
-                # spread about the filesystem.  We choose the
-                # directory containing the Makefile since we know it
-                # exists.
-                srcdir = os.path.dirname(get_makefile_filename())
-        _config_vars['srcdir'] = os.path.abspath(os.path.normpath(srcdir))
-
-        # Convert srcdir into an absolute path if it appears necessary.
-        # Normally it is relative to the build directory.  However, during
-        # testing, for example, we might be running a non-installed python
-        # from a different directory.
-        if python_build and os.name == "posix":
-            base = project_base
-            if (not os.path.isabs(_config_vars['srcdir']) and
-                base != os.getcwd()):
-                # srcdir is relative and we are not in the same directory
-                # as the executable. Assume executable is in the build
-                # directory and make srcdir absolute.
-                srcdir = os.path.join(base, _config_vars['srcdir'])
-                _config_vars['srcdir'] = os.path.normpath(srcdir)
-
-        # OS X platforms require special customization to handle
-        # multi-architecture, multi-os-version installers
-        if sys.platform == 'darwin':
-            import _osx_support
-            _osx_support.customize_config_vars(_config_vars)
-
-    if args:
-        vals = []
-        for name in args:
-            vals.append(_config_vars.get(name))
-        return vals
-    else:
-        return _config_vars
-
-def get_config_var(name):
-    """Return the value of a single variable using the dictionary
-    returned by 'get_config_vars()'.  Equivalent to
-    get_config_vars().get(name)
-    """
-    if name == 'SO':
-        import warnings
-        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
-    return get_config_vars().get(name)
diff --git a/Lib/distutils/text_file.py b/Lib/distutils/text_file.py
deleted file mode 100644
index 93abad38f43..00000000000
--- a/Lib/distutils/text_file.py
+++ /dev/null
@@ -1,286 +0,0 @@
-"""text_file
-
-provides the TextFile class, which gives an interface to text files
-that (optionally) takes care of stripping comments, ignoring blank
-lines, and joining lines with backslashes."""
-
-import sys, io
-
-
-class TextFile:
-    """Provides a file-like object that takes care of all the things you
-       commonly want to do when processing a text file that has some
-       line-by-line syntax: strip comments (as long as "#" is your
-       comment character), skip blank lines, join adjacent lines by
-       escaping the newline (ie. backslash at end of line), strip
-       leading and/or trailing whitespace.  All of these are optional
-       and independently controllable.
-
-       Provides a 'warn()' method so you can generate warning messages that
-       report physical line number, even if the logical line in question
-       spans multiple physical lines.  Also provides 'unreadline()' for
-       implementing line-at-a-time lookahead.
-
-       Constructor is called as:
-
-           TextFile (filename=None, file=None, **options)
-
-       It bombs (RuntimeError) if both 'filename' and 'file' are None;
-       'filename' should be a string, and 'file' a file object (or
-       something that provides 'readline()' and 'close()' methods).  It is
-       recommended that you supply at least 'filename', so that TextFile
-       can include it in warning messages.  If 'file' is not supplied,
-       TextFile creates its own using 'io.open()'.
-
-       The options are all boolean, and affect the value returned by
-       'readline()':
-         strip_comments [default: true]
-           strip from "#" to end-of-line, as well as any whitespace
-           leading up to the "#" -- unless it is escaped by a backslash
-         lstrip_ws [default: false]
-           strip leading whitespace from each line before returning it
-         rstrip_ws [default: true]
-           strip trailing whitespace (including line terminator!) from
-           each line before returning it
-         skip_blanks [default: true}
-           skip lines that are empty *after* stripping comments and
-           whitespace.  (If both lstrip_ws and rstrip_ws are false,
-           then some lines may consist of solely whitespace: these will
-           *not* be skipped, even if 'skip_blanks' is true.)
-         join_lines [default: false]
-           if a backslash is the last non-newline character on a line
-           after stripping comments and whitespace, join the following line
-           to it to form one "logical line"; if N consecutive lines end
-           with a backslash, then N+1 physical lines will be joined to
-           form one logical line.
-         collapse_join [default: false]
-           strip leading whitespace from lines that are joined to their
-           predecessor; only matters if (join_lines and not lstrip_ws)
-         errors [default: 'strict']
-           error handler used to decode the file content
-
-       Note that since 'rstrip_ws' can strip the trailing newline, the
-       semantics of 'readline()' must differ from those of the builtin file
-       object's 'readline()' method!  In particular, 'readline()' returns
-       None for end-of-file: an empty string might just be a blank line (or
-       an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
-       not."""
-
-    default_options = { 'strip_comments': 1,
-                        'skip_blanks':    1,
-                        'lstrip_ws':      0,
-                        'rstrip_ws':      1,
-                        'join_lines':     0,
-                        'collapse_join':  0,
-                        'errors':         'strict',
-                      }
-
-    def __init__(self, filename=None, file=None, **options):
-        """Construct a new TextFile object.  At least one of 'filename'
-           (a string) and 'file' (a file-like object) must be supplied.
-           They keyword argument options are described above and affect
-           the values returned by 'readline()'."""
-        if filename is None and file is None:
-            raise RuntimeError("you must supply either or both of 'filename' and 'file'")
-
-        # set values for all options -- either from client option hash
-        # or fallback to default_options
-        for opt in self.default_options.keys():
-            if opt in options:
-                setattr(self, opt, options[opt])
-            else:
-                setattr(self, opt, self.default_options[opt])
-
-        # sanity check client option hash
-        for opt in options.keys():
-            if opt not in self.default_options:
-                raise KeyError("invalid TextFile option '%s'" % opt)
-
-        if file is None:
-            self.open(filename)
-        else:
-            self.filename = filename
-            self.file = file
-            self.current_line = 0       # assuming that file is at BOF!
-
-        # 'linebuf' is a stack of lines that will be emptied before we
-        # actually read from the file; it's only populated by an
-        # 'unreadline()' operation
-        self.linebuf = []
-
-    def open(self, filename):
-        """Open a new file named 'filename'.  This overrides both the
-           'filename' and 'file' arguments to the constructor."""
-        self.filename = filename
-        self.file = io.open(self.filename, 'r', errors=self.errors)
-        self.current_line = 0
-
-    def close(self):
-        """Close the current file and forget everything we know about it
-           (filename, current line number)."""
-        file = self.file
-        self.file = None
-        self.filename = None
-        self.current_line = None
-        file.close()
-
-    def gen_error(self, msg, line=None):
-        outmsg = []
-        if line is None:
-            line = self.current_line
-        outmsg.append(self.filename + ", ")
-        if isinstance(line, (list, tuple)):
-            outmsg.append("lines %d-%d: " % tuple(line))
-        else:
-            outmsg.append("line %d: " % line)
-        outmsg.append(str(msg))
-        return "".join(outmsg)
-
-    def error(self, msg, line=None):
-        raise ValueError("error: " + self.gen_error(msg, line))
-
-    def warn(self, msg, line=None):
-        """Print (to stderr) a warning message tied to the current logical
-           line in the current file.  If the current logical line in the
-           file spans multiple physical lines, the warning refers to the
-           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
-           the current line number; it may be a list or tuple to indicate a
-           range of physical lines, or an integer for a single physical
-           line."""
-        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
-
-    def readline(self):
-        """Read and return a single logical line from the current file (or
-           from an internal buffer if lines have previously been "unread"
-           with 'unreadline()').  If the 'join_lines' option is true, this
-           may involve reading multiple physical lines concatenated into a
-           single string.  Updates the current line number, so calling
-           'warn()' after 'readline()' emits a warning about the physical
-           line(s) just read.  Returns None on end-of-file, since the empty
-           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
-           not."""
-        # If any "unread" lines waiting in 'linebuf', return the top
-        # one.  (We don't actually buffer read-ahead data -- lines only
-        # get put in 'linebuf' if the client explicitly does an
-        # 'unreadline()'.
-        if self.linebuf:
-            line = self.linebuf[-1]
-            del self.linebuf[-1]
-            return line
-
-        buildup_line = ''
-
-        while True:
-            # read the line, make it None if EOF
-            line = self.file.readline()
-            if line == '':
-                line = None
-
-            if self.strip_comments and line:
-
-                # Look for the first "#" in the line.  If none, never
-                # mind.  If we find one and it's the first character, or
-                # is not preceded by "\", then it starts a comment --
-                # strip the comment, strip whitespace before it, and
-                # carry on.  Otherwise, it's just an escaped "#", so
-                # unescape it (and any other escaped "#"'s that might be
-                # lurking in there) and otherwise leave the line alone.
-
-                pos = line.find("#")
-                if pos == -1: # no "#" -- no comments
-                    pass
-
-                # It's definitely a comment -- either "#" is the first
-                # character, or it's elsewhere and unescaped.
-                elif pos == 0 or line[pos-1] != "\\":
-                    # Have to preserve the trailing newline, because it's
-                    # the job of a later step (rstrip_ws) to remove it --
-                    # and if rstrip_ws is false, we'd better preserve it!
-                    # (NB. this means that if the final line is all comment
-                    # and has no trailing newline, we will think that it's
-                    # EOF; I think that's OK.)
-                    eol = (line[-1] == '\n') and '\n' or ''
-                    line = line[0:pos] + eol
-
-                    # If all that's left is whitespace, then skip line
-                    # *now*, before we try to join it to 'buildup_line' --
-                    # that way constructs like
-                    #   hello \\
-                    #   # comment that should be ignored
-                    #   there
-                    # result in "hello there".
-                    if line.strip() == "":
-                        continue
-                else: # it's an escaped "#"
-                    line = line.replace("\\#", "#")
-
-            # did previous line end with a backslash? then accumulate
-            if self.join_lines and buildup_line:
-                # oops: end of file
-                if line is None:
-                    self.warn("continuation line immediately precedes "
-                              "end-of-file")
-                    return buildup_line
-
-                if self.collapse_join:
-                    line = line.lstrip()
-                line = buildup_line + line
-
-                # careful: pay attention to line number when incrementing it
-                if isinstance(self.current_line, list):
-                    self.current_line[1] = self.current_line[1] + 1
-                else:
-                    self.current_line = [self.current_line,
-                                         self.current_line + 1]
-            # just an ordinary line, read it as usual
-            else:
-                if line is None: # eof
-                    return None
-
-                # still have to be careful about incrementing the line number!
-                if isinstance(self.current_line, list):
-                    self.current_line = self.current_line[1] + 1
-                else:
-                    self.current_line = self.current_line + 1
-
-            # strip whitespace however the client wants (leading and
-            # trailing, or one or the other, or neither)
-            if self.lstrip_ws and self.rstrip_ws:
-                line = line.strip()
-            elif self.lstrip_ws:
-                line = line.lstrip()
-            elif self.rstrip_ws:
-                line = line.rstrip()
-
-            # blank line (whether we rstrip'ed or not)? skip to next line
-            # if appropriate
-            if (line == '' or line == '\n') and self.skip_blanks:
-                continue
-
-            if self.join_lines:
-                if line[-1] == '\\':
-                    buildup_line = line[:-1]
-                    continue
-
-                if line[-2:] == '\\\n':
-                    buildup_line = line[0:-2] + '\n'
-                    continue
-
-            # well, I guess there's some actual content there: return it
-            return line
-
-    def readlines(self):
-        """Read and return the list of all logical lines remaining in the
-           current file."""
-        lines = []
-        while True:
-            line = self.readline()
-            if line is None:
-                return lines
-            lines.append(line)
-
-    def unreadline(self, line):
-        """Push 'line' (a string) onto an internal buffer that will be
-           checked by future 'readline()' calls.  Handy for implementing
-           a parser with line-at-a-time lookahead."""
-        self.linebuf.append(line)
diff --git a/Lib/distutils/unixccompiler.py b/Lib/distutils/unixccompiler.py
deleted file mode 100644
index 4524417e668..00000000000
--- a/Lib/distutils/unixccompiler.py
+++ /dev/null
@@ -1,333 +0,0 @@
-"""distutils.unixccompiler
-
-Contains the UnixCCompiler class, a subclass of CCompiler that handles
-the "typical" Unix-style command-line C compiler:
-  * macros defined with -Dname[=value]
-  * macros undefined with -Uname
-  * include search directories specified with -Idir
-  * libraries specified with -lllib
-  * library search directories specified with -Ldir
-  * compile handled by 'cc' (or similar) executable with -c option:
-    compiles .c to .o
-  * link static library handled by 'ar' command (possibly with 'ranlib')
-  * link shared library handled by 'cc -shared'
-"""
-
-import os, sys, re
-
-from distutils import sysconfig
-from distutils.dep_util import newer
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.errors import \
-     DistutilsExecError, CompileError, LibError, LinkError
-from distutils import log
-
-if sys.platform == 'darwin':
-    import _osx_support
-
-# XXX Things not currently handled:
-#   * optimization/debug/warning flags; we just use whatever's in Python's
-#     Makefile and live with it.  Is this adequate?  If not, we might
-#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
-#     SunCCompiler, and I suspect down that road lies madness.
-#   * even if we don't know a warning flag from an optimization flag,
-#     we need some way for outsiders to feed preprocessor/compiler/linker
-#     flags in to us -- eg. a sysadmin might want to mandate certain flags
-#     via a site config file, or a user might want to set something for
-#     compiling this module distribution only via the setup.py command
-#     line, whatever.  As long as these options come from something on the
-#     current system, they can be as system-dependent as they like, and we
-#     should just happily stuff them into the preprocessor/compiler/linker
-#     options and carry on.
-
-
-class UnixCCompiler(CCompiler):
-
-    compiler_type = 'unix'
-
-    # These are used by CCompiler in two places: the constructor sets
-    # instance attributes 'preprocessor', 'compiler', etc. from them, and
-    # 'set_executable()' allows any of these to be set.  The defaults here
-    # are pretty generic; they will probably have to be set by an outsider
-    # (eg. using information discovered by the sysconfig about building
-    # Python extensions).
-    executables = {'preprocessor' : None,
-                   'compiler'     : ["cc"],
-                   'compiler_so'  : ["cc"],
-                   'compiler_cxx' : ["cc"],
-                   'linker_so'    : ["cc", "-shared"],
-                   'linker_exe'   : ["cc"],
-                   'archiver'     : ["ar", "-cr"],
-                   'ranlib'       : None,
-                  }
-
-    if sys.platform[:6] == "darwin":
-        executables['ranlib'] = ["ranlib"]
-
-    # Needed for the filename generation methods provided by the base
-    # class, CCompiler.  NB. whoever instantiates/uses a particular
-    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
-    # reasonable common default here, but it's not necessarily used on all
-    # Unices!
-
-    src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".so"
-    dylib_lib_extension = ".dylib"
-    xcode_stub_lib_extension = ".tbd"
-    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
-    xcode_stub_lib_format = dylib_lib_format
-    if sys.platform == "cygwin":
-        exe_extension = ".exe"
-
-    def preprocess(self, source, output_file=None, macros=None,
-                   include_dirs=None, extra_preargs=None, extra_postargs=None):
-        fixed_args = self._fix_compile_args(None, macros, include_dirs)
-        ignore, macros, include_dirs = fixed_args
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = self.preprocessor + pp_opts
-        if output_file:
-            pp_args.extend(['-o', output_file])
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # We need to preprocess: either we're being forced to, or we're
-        # generating output to stdout, or there's a target output file and
-        # the source file is newer than the target (or the target doesn't
-        # exist).
-        if self.force or output_file is None or newer(source, output_file):
-            if output_file:
-                self.mkpath(os.path.dirname(output_file))
-            try:
-                self.spawn(pp_args)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        compiler_so = self.compiler_so
-        if sys.platform == 'darwin':
-            compiler_so = _osx_support.compiler_fixup(compiler_so,
-                                                    cc_args + extra_postargs)
-        try:
-            self.spawn(compiler_so + cc_args + [src, '-o', obj] +
-                       extra_postargs)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def create_static_lib(self, objects, output_libname,
-                          output_dir=None, debug=0, target_lang=None):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-
-        output_filename = \
-            self.library_filename(output_libname, output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            self.mkpath(os.path.dirname(output_filename))
-            self.spawn(self.archiver +
-                       [output_filename] +
-                       objects + self.objects)
-
-            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
-            # think the only major Unix that does.  Maybe we need some
-            # platform intelligence here to skip ranlib if it's not
-            # needed -- or maybe Python's configure script took care of
-            # it for us, hence the check for leading colon.
-            if self.ranlib:
-                try:
-                    self.spawn(self.ranlib + [output_filename])
-                except DistutilsExecError as msg:
-                    raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def link(self, target_desc, objects,
-             output_filename, output_dir=None, libraries=None,
-             library_dirs=None, runtime_library_dirs=None,
-             export_symbols=None, debug=0, extra_preargs=None,
-             extra_postargs=None, build_temp=None, target_lang=None):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        # filter out standard library paths, which are not explicitely needed
-        # for linking
-        system_libdirs = ['/lib', '/lib64', '/usr/lib', '/usr/lib64']
-        multiarch = sysconfig.get_config_var("MULTIARCH")
-        if multiarch:
-            system_libdirs.extend(['/lib/%s' % multiarch, '/usr/lib/%s' % multiarch])
-        library_dirs = [dir for dir in library_dirs
-                        if not dir in system_libdirs]
-        runtime_library_dirs = [dir for dir in runtime_library_dirs
-                                if not dir in system_libdirs]
-
-        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
-                                   libraries)
-        if not isinstance(output_dir, (str, type(None))):
-            raise TypeError("'output_dir' must be a string or None")
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ld_args = (objects + self.objects +
-                       lib_opts + ['-o', output_filename])
-            if debug:
-                ld_args[:0] = ['-g']
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                if target_desc == CCompiler.EXECUTABLE:
-                    linker = self.linker_exe[:]
-                else:
-                    linker = self.linker_so[:]
-                if target_lang == "c++" and self.compiler_cxx:
-                    # skip over environment variable settings if /usr/bin/env
-                    # is used to set up the linker's environment.
-                    # This is needed on OSX. Note: this assumes that the
-                    # normal and C++ compiler have the same environment
-                    # settings.
-                    i = 0
-                    if os.path.basename(linker[0]) == "env":
-                        i = 1
-                        while '=' in linker[i]:
-                            i += 1
-                    linker[i] = self.compiler_cxx[i]
-
-                if sys.platform == 'darwin':
-                    linker = _osx_support.compiler_fixup(linker, ld_args)
-
-                self.spawn(linker + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "-L" + dir
-
-    def _is_gcc(self, compiler_name):
-        return "gcc" in compiler_name or "g++" in compiler_name
-
-    def runtime_library_dir_option(self, dir):
-        # XXX Hackish, at the very least.  See Python bug #445902:
-        # http://sourceforge.net/tracker/index.php
-        #   ?func=detail&aid=445902&group_id=5470&atid=105470
-        # Linkers on different platforms need different options to
-        # specify that directories need to be added to the list of
-        # directories searched for dependencies when a dynamic library
-        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
-        # be told to pass the -R option through to the linker, whereas
-        # other compilers and gcc on other systems just know this.
-        # Other compilers may need something slightly different.  At
-        # this time, there's no way to determine this information from
-        # the configuration data stored in the Python installation, so
-        # we use this hack.
-        compiler = os.path.basename(sysconfig.get_config_var("CC"))
-        if sys.platform[:6] == "darwin":
-            # MacOSX's linker doesn't understand the -R flag at all
-            return "-L" + dir
-        elif sys.platform[:7] == "freebsd":
-            return "-Wl,-rpath=" + dir
-        elif sys.platform[:5] == "hp-ux":
-            if self._is_gcc(compiler):
-                return ["-Wl,+s", "-L" + dir]
-            return ["+s", "-L" + dir]
-        elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5":
-            return ["-rpath", dir]
-        else:
-            if self._is_gcc(compiler):
-                # gcc on non-GNU systems does not need -Wl, but can
-                # use it anyway.  Since distutils has always passed in
-                # -Wl whenever gcc was used in the past it is probably
-                # safest to keep doing so.
-                if sysconfig.get_config_var("GNULD") == "yes":
-                    # GNU ld needs an extra option to get a RUNPATH
-                    # instead of just an RPATH.
-                    return "-Wl,--enable-new-dtags,-R" + dir
-                else:
-                    return "-Wl,-R" + dir
-            else:
-                # No idea how --enable-new-dtags would be passed on to
-                # ld if this system was using GNU ld.  Don't know if a
-                # system like this even exists.
-                return "-R" + dir
-
-    def library_option(self, lib):
-        return "-l" + lib
-
-    def find_library_file(self, dirs, lib, debug=0):
-        shared_f = self.library_filename(lib, lib_type='shared')
-        dylib_f = self.library_filename(lib, lib_type='dylib')
-        xcode_stub_f = self.library_filename(lib, lib_type='xcode_stub')
-        static_f = self.library_filename(lib, lib_type='static')
-
-        if sys.platform == 'darwin':
-            # On OSX users can specify an alternate SDK using
-            # '-isysroot', calculate the SDK root if it is specified
-            # (and use it further on)
-            #
-            # Note that, as of Xcode 7, Apple SDKs may contain textual stub
-            # libraries with .tbd extensions rather than the normal .dylib
-            # shared libraries installed in /.  The Apple compiler tool
-            # chain handles this transparently but it can cause problems
-            # for programs that are being built with an SDK and searching
-            # for specific libraries.  Callers of find_library_file need to
-            # keep in mind that the base filename of the returned SDK library
-            # file might have a different extension from that of the library
-            # file installed on the running system, for example:
-            #   /Applications/Xcode.app/Contents/Developer/Platforms/
-            #       MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
-            #       usr/lib/libedit.tbd
-            # vs
-            #   /usr/lib/libedit.dylib
-            cflags = sysconfig.get_config_var('CFLAGS')
-            m = re.search(r'-isysroot\s+(\S+)', cflags)
-            if m is None:
-                sysroot = '/'
-            else:
-                sysroot = m.group(1)
-
-
-
-        for dir in dirs:
-            shared = os.path.join(dir, shared_f)
-            dylib = os.path.join(dir, dylib_f)
-            static = os.path.join(dir, static_f)
-            xcode_stub = os.path.join(dir, xcode_stub_f)
-
-            if sys.platform == 'darwin' and (
-                dir.startswith('/System/') or (
-                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):
-
-                shared = os.path.join(sysroot, dir[1:], shared_f)
-                dylib = os.path.join(sysroot, dir[1:], dylib_f)
-                static = os.path.join(sysroot, dir[1:], static_f)
-                xcode_stub = os.path.join(sysroot, dir[1:], xcode_stub_f)
-
-            # We're second-guessing the linker here, with not much hard
-            # data to go on: GCC seems to prefer the shared library, so I'm
-            # assuming that *all* Unix C compilers do.  And of course I'm
-            # ignoring even GCC's "-static" option.  So sue me.
-            if os.path.exists(dylib):
-                return dylib
-            elif os.path.exists(xcode_stub):
-                return xcode_stub
-            elif os.path.exists(shared):
-                return shared
-            elif os.path.exists(static):
-                return static
-
-        # Oops, didn't find it in *any* of 'dirs'
-        return None
diff --git a/Lib/distutils/util.py b/Lib/distutils/util.py
deleted file mode 100644
index fdcf6fabae2..00000000000
--- a/Lib/distutils/util.py
+++ /dev/null
@@ -1,557 +0,0 @@
-"""distutils.util
-
-Miscellaneous utility functions -- anything that doesn't fit into
-one of the other *util.py modules.
-"""
-
-import os
-import re
-import importlib.util
-import string
-import sys
-from distutils.errors import DistutilsPlatformError
-from distutils.dep_util import newer
-from distutils.spawn import spawn
-from distutils import log
-from distutils.errors import DistutilsByteCompileError
-
-def get_platform ():
-    """Return a string that identifies the current platform.  This is used
-    mainly to distinguish platform-specific build directories and
-    platform-specific built distributions.  Typically includes the OS name
-    and version and the architecture (as supplied by 'os.uname()'),
-    although the exact information included depends on the OS; eg. for IRIX
-    the architecture isn't particularly important (IRIX only runs on SGI
-    hardware), but for Linux the kernel version isn't particularly
-    important.
-
-    Examples of returned values:
-       linux-i586
-       linux-alpha (?)
-       solaris-2.6-sun4u
-       irix-5.3
-       irix64-6.2
-
-    Windows will return one of:
-       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
-       win-ia64 (64bit Windows on Itanium)
-       win32 (all others - specifically, sys.platform is returned)
-
-    For other non-POSIX platforms, currently just returns 'sys.platform'.
-    """
-    if os.name == 'nt':
-        # sniff sys.version for architecture.
-        prefix = " bit ("
-        i = sys.version.find(prefix)
-        if i == -1:
-            return sys.platform
-        j = sys.version.find(")", i)
-        look = sys.version[i+len(prefix):j].lower()
-        if look == 'amd64':
-            return 'win-amd64'
-        if look == 'itanium':
-            return 'win-ia64'
-        return sys.platform
-
-    # Set for cross builds explicitly
-    if "_PYTHON_HOST_PLATFORM" in os.environ:
-        return os.environ["_PYTHON_HOST_PLATFORM"]
-
-    if os.name != "posix" or not hasattr(os, 'uname'):
-        # XXX what about the architecture? NT is Intel or Alpha,
-        # Mac OS is M68k or PPC, etc.
-        return sys.platform
-
-    # Try to distinguish various flavours of Unix
-
-    (osname, host, release, version, machine) = os.uname()
-
-    # Convert the OS name to lowercase, remove '/' characters
-    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
-    osname = osname.lower().replace('/', '')
-    machine = machine.replace(' ', '_')
-    machine = machine.replace('/', '-')
-
-    if osname[:5] == "linux":
-        # At least on Linux/Intel, 'machine' is the processor --
-        # i386, etc.
-        # XXX what about Alpha, SPARC, etc?
-        return  "%s-%s" % (osname, machine)
-    elif osname[:5] == "sunos":
-        if release[0] >= "5":           # SunOS 5 == Solaris 2
-            osname = "solaris"
-            release = "%d.%s" % (int(release[0]) - 3, release[2:])
-            # We can't use "platform.architecture()[0]" because a
-            # bootstrap problem. We use a dict to get an error
-            # if some suspicious happens.
-            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
-            machine += ".%s" % bitness[sys.maxsize]
-        # fall through to standard osname-release-machine representation
-    elif osname[:4] == "irix":              # could be "irix64"!
-        return "%s-%s" % (osname, release)
-    elif osname[:3] == "aix":
-        return "%s-%s.%s" % (osname, version, release)
-    elif osname[:6] == "cygwin":
-        osname = "cygwin"
-        rel_re = re.compile (r'[\d.]+', re.ASCII)
-        m = rel_re.match(release)
-        if m:
-            release = m.group()
-    elif osname[:6] == "darwin":
-        import _osx_support, distutils.sysconfig
-        osname, release, machine = _osx_support.get_platform_osx(
-                                        distutils.sysconfig.get_config_vars(),
-                                        osname, release, machine)
-
-    return "%s-%s-%s" % (osname, release, machine)
-
-# get_platform ()
-
-
-def convert_path (pathname):
-    """Return 'pathname' as a name that will work on the native filesystem,
-    i.e. split it on '/' and put it back together again using the current
-    directory separator.  Needed because filenames in the setup script are
-    always supplied in Unix style, and have to be converted to the local
-    convention before we can actually use them in the filesystem.  Raises
-    ValueError on non-Unix-ish systems if 'pathname' either starts or
-    ends with a slash.
-    """
-    if os.sep == '/':
-        return pathname
-    if not pathname:
-        return pathname
-    if pathname[0] == '/':
-        raise ValueError("path '%s' cannot be absolute" % pathname)
-    if pathname[-1] == '/':
-        raise ValueError("path '%s' cannot end with '/'" % pathname)
-
-    paths = pathname.split('/')
-    while '.' in paths:
-        paths.remove('.')
-    if not paths:
-        return os.curdir
-    return os.path.join(*paths)
-
-# convert_path ()
-
-
-def change_root (new_root, pathname):
-    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
-    relative, this is equivalent to "os.path.join(new_root,pathname)".
-    Otherwise, it requires making 'pathname' relative and then joining the
-    two, which is tricky on DOS/Windows and Mac OS.
-    """
-    if os.name == 'posix':
-        if not os.path.isabs(pathname):
-            return os.path.join(new_root, pathname)
-        else:
-            return os.path.join(new_root, pathname[1:])
-
-    elif os.name == 'nt':
-        (drive, path) = os.path.splitdrive(pathname)
-        if path[0] == '\\':
-            path = path[1:]
-        return os.path.join(new_root, path)
-
-    else:
-        raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)
-
-
-_environ_checked = 0
-def check_environ ():
-    """Ensure that 'os.environ' has all the environment variables we
-    guarantee that users can use in config files, command-line options,
-    etc.  Currently this includes:
-      HOME - user's home directory (Unix only)
-      PLAT - description of the current platform, including hardware
-             and OS (see 'get_platform()')
-    """
-    global _environ_checked
-    if _environ_checked:
-        return
-
-    if os.name == 'posix' and 'HOME' not in os.environ:
-        import pwd
-        os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
-
-    if 'PLAT' not in os.environ:
-        os.environ['PLAT'] = get_platform()
-
-    _environ_checked = 1
-
-
-def subst_vars (s, local_vars):
-    """Perform shell/Perl-style variable substitution on 'string'.  Every
-    occurrence of '$' followed by a name is considered a variable, and
-    variable is substituted by the value found in the 'local_vars'
-    dictionary, or in 'os.environ' if it's not in 'local_vars'.
-    'os.environ' is first checked/augmented to guarantee that it contains
-    certain values: see 'check_environ()'.  Raise ValueError for any
-    variables not found in either 'local_vars' or 'os.environ'.
-    """
-    check_environ()
-    def _subst (match, local_vars=local_vars):
-        var_name = match.group(1)
-        if var_name in local_vars:
-            return str(local_vars[var_name])
-        else:
-            return os.environ[var_name]
-
-    try:
-        return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
-    except KeyError as var:
-        raise ValueError("invalid variable '$%s'" % var)
-
-# subst_vars ()
-
-
-def grok_environment_error (exc, prefix="error: "):
-    # Function kept for backward compatibility.
-    # Used to try clever things with EnvironmentErrors,
-    # but nowadays str(exception) produces good messages.
-    return prefix + str(exc)
-
-
-# Needed by 'split_quoted()'
-_wordchars_re = _squote_re = _dquote_re = None
-def _init_regex():
-    global _wordchars_re, _squote_re, _dquote_re
-    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
-    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
-    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
-
-def split_quoted (s):
-    """Split a string up according to Unix shell-like rules for quotes and
-    backslashes.  In short: words are delimited by spaces, as long as those
-    spaces are not escaped by a backslash, or inside a quoted string.
-    Single and double quotes are equivalent, and the quote characters can
-    be backslash-escaped.  The backslash is stripped from any two-character
-    escape sequence, leaving only the escaped character.  The quote
-    characters are stripped from any quoted string.  Returns a list of
-    words.
-    """
-
-    # This is a nice algorithm for splitting up a single string, since it
-    # doesn't require character-by-character examination.  It was a little
-    # bit of a brain-bender to get it working right, though...
-    if _wordchars_re is None: _init_regex()
-
-    s = s.strip()
-    words = []
-    pos = 0
-
-    while s:
-        m = _wordchars_re.match(s, pos)
-        end = m.end()
-        if end == len(s):
-            words.append(s[:end])
-            break
-
-        if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
-            words.append(s[:end])       # we definitely have a word delimiter
-            s = s[end:].lstrip()
-            pos = 0
-
-        elif s[end] == '\\':            # preserve whatever is being escaped;
-                                        # will become part of the current word
-            s = s[:end] + s[end+1:]
-            pos = end+1
-
-        else:
-            if s[end] == "'":           # slurp singly-quoted string
-                m = _squote_re.match(s, end)
-            elif s[end] == '"':         # slurp doubly-quoted string
-                m = _dquote_re.match(s, end)
-            else:
-                raise RuntimeError("this can't happen (bad char '%c')" % s[end])
-
-            if m is None:
-                raise ValueError("bad string (mismatched %s quotes?)" % s[end])
-
-            (beg, end) = m.span()
-            s = s[:beg] + s[beg+1:end-1] + s[end:]
-            pos = m.end() - 2
-
-        if pos >= len(s):
-            words.append(s)
-            break
-
-    return words
-
-# split_quoted ()
-
-
-def execute (func, args, msg=None, verbose=0, dry_run=0):
-    """Perform some action that affects the outside world (eg.  by
-    writing to the filesystem).  Such actions are special because they
-    are disabled by the 'dry_run' flag.  This method takes care of all
-    that bureaucracy for you; all you have to do is supply the
-    function to call and an argument tuple for it (to embody the
-    "external action" being performed), and an optional message to
-    print.
-    """
-    if msg is None:
-        msg = "%s%r" % (func.__name__, args)
-        if msg[-2:] == ',)':        # correct for singleton tuple
-            msg = msg[0:-2] + ')'
-
-    log.info(msg)
-    if not dry_run:
-        func(*args)
-
-
-def strtobool (val):
-    """Convert a string representation of truth to true (1) or false (0).
-
-    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
-    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
-    'val' is anything else.
-    """
-    val = val.lower()
-    if val in ('y', 'yes', 't', 'true', 'on', '1'):
-        return 1
-    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
-        return 0
-    else:
-        raise ValueError("invalid truth value %r" % (val,))
-
-
-def byte_compile (py_files,
-                  optimize=0, force=0,
-                  prefix=None, base_dir=None,
-                  verbose=1, dry_run=0,
-                  direct=None):
-    """Byte-compile a collection of Python source files to .pyc
-    files in a __pycache__ subdirectory.  'py_files' is a list
-    of files to compile; any files that don't end in ".py" are silently
-    skipped.  'optimize' must be one of the following:
-      0 - don't optimize
-      1 - normal optimization (like "python -O")
-      2 - extra optimization (like "python -OO")
-    If 'force' is true, all files are recompiled regardless of
-    timestamps.
-
-    The source filename encoded in each bytecode file defaults to the
-    filenames listed in 'py_files'; you can modify these with 'prefix' and
-    'basedir'.  'prefix' is a string that will be stripped off of each
-    source filename, and 'base_dir' is a directory name that will be
-    prepended (after 'prefix' is stripped).  You can supply either or both
-    (or neither) of 'prefix' and 'base_dir', as you wish.
-
-    If 'dry_run' is true, doesn't actually do anything that would
-    affect the filesystem.
-
-    Byte-compilation is either done directly in this interpreter process
-    with the standard py_compile module, or indirectly by writing a
-    temporary script and executing it.  Normally, you should let
-    'byte_compile()' figure out to use direct compilation or not (see
-    the source for details).  The 'direct' flag is used by the script
-    generated in indirect mode; unless you know what you're doing, leave
-    it set to None.
-    """
-
-    # Late import to fix a bootstrap issue: _posixsubprocess is built by
-    # setup.py, but setup.py uses distutils.
-    import subprocess
-
-    # nothing is done if sys.dont_write_bytecode is True
-    if sys.dont_write_bytecode:
-        raise DistutilsByteCompileError('byte-compiling is disabled.')
-
-    # First, if the caller didn't force us into direct or indirect mode,
-    # figure out which mode we should be in.  We take a conservative
-    # approach: choose direct mode *only* if the current interpreter is
-    # in debug mode and optimize is 0.  If we're not in debug mode (-O
-    # or -OO), we don't know which level of optimization this
-    # interpreter is running with, so we can't do direct
-    # byte-compilation and be certain that it's the right thing.  Thus,
-    # always compile indirectly if the current interpreter is in either
-    # optimize mode, or if either optimization level was requested by
-    # the caller.
-    if direct is None:
-        direct = (__debug__ and optimize == 0)
-
-    # "Indirect" byte-compilation: write a temporary script and then
-    # run it with the appropriate flags.
-    if not direct:
-        try:
-            from tempfile import mkstemp
-            (script_fd, script_name) = mkstemp(".py")
-        except ImportError:
-            from tempfile import mktemp
-            (script_fd, script_name) = None, mktemp(".py")
-        log.info("writing byte-compilation script '%s'", script_name)
-        if not dry_run:
-            if script_fd is not None:
-                script = os.fdopen(script_fd, "w")
-            else:
-                script = open(script_name, "w")
-
-            script.write("""\
-from distutils.util import byte_compile
-files = [
-""")
-
-            # XXX would be nice to write absolute filenames, just for
-            # safety's sake (script should be more robust in the face of
-            # chdir'ing before running it).  But this requires abspath'ing
-            # 'prefix' as well, and that breaks the hack in build_lib's
-            # 'byte_compile()' method that carefully tacks on a trailing
-            # slash (os.sep really) to make sure the prefix here is "just
-            # right".  This whole prefix business is rather delicate -- the
-            # problem is that it's really a directory, but I'm treating it
-            # as a dumb string, so trailing slashes and so forth matter.
-
-            #py_files = map(os.path.abspath, py_files)
-            #if prefix:
-            #    prefix = os.path.abspath(prefix)
-
-            script.write(",\n".join(map(repr, py_files)) + "]\n")
-            script.write("""
-byte_compile(files, optimize=%r, force=%r,
-             prefix=%r, base_dir=%r,
-             verbose=%r, dry_run=0,
-             direct=1)
-""" % (optimize, force, prefix, base_dir, verbose))
-
-            script.close()
-
-        cmd = [sys.executable]
-        cmd.extend(subprocess._optim_args_from_interpreter_flags())
-        cmd.append(script_name)
-        spawn(cmd, dry_run=dry_run)
-        execute(os.remove, (script_name,), "removing %s" % script_name,
-                dry_run=dry_run)
-
-    # "Direct" byte-compilation: use the py_compile module to compile
-    # right here, right now.  Note that the script generated in indirect
-    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
-    # cross-process recursion.  Hey, it works!
-    else:
-        from py_compile import compile
-
-        for file in py_files:
-            if file[-3:] != ".py":
-                # This lets us be lazy and not filter filenames in
-                # the "install_lib" command.
-                continue
-
-            # Terminology from the py_compile module:
-            #   cfile - byte-compiled file
-            #   dfile - purported source filename (same as 'file' by default)
-            if optimize >= 0:
-                opt = '' if optimize == 0 else optimize
-                cfile = importlib.util.cache_from_source(
-                    file, optimization=opt)
-            else:
-                cfile = importlib.util.cache_from_source(file)
-            dfile = file
-            if prefix:
-                if file[:len(prefix)] != prefix:
-                    raise ValueError("invalid prefix: filename %r doesn't start with %r"
-                           % (file, prefix))
-                dfile = dfile[len(prefix):]
-            if base_dir:
-                dfile = os.path.join(base_dir, dfile)
-
-            cfile_base = os.path.basename(cfile)
-            if direct:
-                if force or newer(file, cfile):
-                    log.info("byte-compiling %s to %s", file, cfile_base)
-                    if not dry_run:
-                        compile(file, cfile, dfile)
-                else:
-                    log.debug("skipping byte-compilation of %s to %s",
-                              file, cfile_base)
-
-# byte_compile ()
-
-def rfc822_escape (header):
-    """Return a version of the string escaped for inclusion in an
-    RFC-822 header, by ensuring there are 8 spaces space after each newline.
-    """
-    lines = header.split('\n')
-    sep = '\n' + 8 * ' '
-    return sep.join(lines)
-
-# 2to3 support
-
-def run_2to3(files, fixer_names=None, options=None, explicit=None):
-    """Invoke 2to3 on a list of Python files.
-    The files should all come from the build area, as the
-    modification is done in-place. To reduce the build time,
-    only files modified since the last invocation of this
-    function should be passed in the files argument."""
-
-    if not files:
-        return
-
-    # Make this class local, to delay import of 2to3
-    from lib2to3.refactor import RefactoringTool, get_fixers_from_package
-    class DistutilsRefactoringTool(RefactoringTool):
-        def log_error(self, msg, *args, **kw):
-            log.error(msg, *args)
-
-        def log_message(self, msg, *args):
-            log.info(msg, *args)
-
-        def log_debug(self, msg, *args):
-            log.debug(msg, *args)
-
-    if fixer_names is None:
-        fixer_names = get_fixers_from_package('lib2to3.fixes')
-    r = DistutilsRefactoringTool(fixer_names, options=options)
-    r.refactor(files, write=True)
-
-def copydir_run_2to3(src, dest, template=None, fixer_names=None,
-                     options=None, explicit=None):
-    """Recursively copy a directory, only copying new and changed files,
-    running run_2to3 over all newly copied Python modules afterward.
-
-    If you give a template string, it's parsed like a MANIFEST.in.
-    """
-    from distutils.dir_util import mkpath
-    from distutils.file_util import copy_file
-    from distutils.filelist import FileList
-    filelist = FileList()
-    curdir = os.getcwd()
-    os.chdir(src)
-    try:
-        filelist.findall()
-    finally:
-        os.chdir(curdir)
-    filelist.files[:] = filelist.allfiles
-    if template:
-        for line in template.splitlines():
-            line = line.strip()
-            if not line: continue
-            filelist.process_template_line(line)
-    copied = []
-    for filename in filelist.files:
-        outname = os.path.join(dest, filename)
-        mkpath(os.path.dirname(outname))
-        res = copy_file(os.path.join(src, filename), outname, update=1)
-        if res[1]: copied.append(outname)
-    run_2to3([fn for fn in copied if fn.lower().endswith('.py')],
-             fixer_names=fixer_names, options=options, explicit=explicit)
-    return copied
-
-class Mixin2to3:
-    '''Mixin class for commands that run 2to3.
-    To configure 2to3, setup scripts may either change
-    the class variables, or inherit from individual commands
-    to override how 2to3 is invoked.'''
-
-    # provide list of fixers to run;
-    # defaults to all from lib2to3.fixers
-    fixer_names = None
-
-    # options dictionary
-    options = None
-
-    # list of fixers to invoke even though they are marked as explicit
-    explicit = None
-
-    def run_2to3(self, files):
-        return run_2to3(files, self.fixer_names, self.options, self.explicit)
diff --git a/Lib/distutils/version.py b/Lib/distutils/version.py
deleted file mode 100644
index af14cc13481..00000000000
--- a/Lib/distutils/version.py
+++ /dev/null
@@ -1,343 +0,0 @@
-#
-# distutils/version.py
-#
-# Implements multiple version numbering conventions for the
-# Python Module Distribution Utilities.
-#
-# $Id$
-#
-
-"""Provides classes to represent module version numbers (one class for
-each style of version numbering).  There are currently two such classes
-implemented: StrictVersion and LooseVersion.
-
-Every version number class implements the following interface:
-  * the 'parse' method takes a string and parses it to some internal
-    representation; if the string is an invalid version number,
-    'parse' raises a ValueError exception
-  * the class constructor takes an optional string argument which,
-    if supplied, is passed to 'parse'
-  * __str__ reconstructs the string that was passed to 'parse' (or
-    an equivalent string -- ie. one that will generate an equivalent
-    version number instance)
-  * __repr__ generates Python code to recreate the version number instance
-  * _cmp compares the current instance with either another instance
-    of the same class or a string (which will be parsed to an instance
-    of the same class, thus must follow the same rules)
-"""
-
-import re
-
-class Version:
-    """Abstract base class for version numbering classes.  Just provides
-    constructor (__init__) and reproducer (__repr__), because those
-    seem to be the same for all version numbering classes; and route
-    rich comparisons to _cmp.
-    """
-
-    def __init__ (self, vstring=None):
-        if vstring:
-            self.parse(vstring)
-
-    def __repr__ (self):
-        return "%s ('%s')" % (self.__class__.__name__, str(self))
-
-    def __eq__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c == 0
-
-    def __lt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c < 0
-
-    def __le__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c <= 0
-
-    def __gt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c > 0
-
-    def __ge__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c >= 0
-
-
-# Interface for version-number classes -- must be implemented
-# by the following classes (the concrete ones -- Version should
-# be treated as an abstract class).
-#    __init__ (string) - create and take same action as 'parse'
-#                        (string parameter is optional)
-#    parse (string)    - convert a string representation to whatever
-#                        internal representation is appropriate for
-#                        this style of version numbering
-#    __str__ (self)    - convert back to a string; should be very similar
-#                        (if not identical to) the string supplied to parse
-#    __repr__ (self)   - generate Python code to recreate
-#                        the instance
-#    _cmp (self, other) - compare two version numbers ('other' may
-#                        be an unparsed version string, or another
-#                        instance of your version class)
-
-
-class StrictVersion (Version):
-
-    """Version numbering for anal retentives and software idealists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of two or three
-    dot-separated numeric components, with an optional "pre-release" tag
-    on the end.  The pre-release tag consists of the letter 'a' or 'b'
-    followed by a number.  If the numeric components of two version
-    numbers are equal, then one with a pre-release tag will always
-    be deemed earlier (lesser) than one without.
-
-    The following are valid version numbers (shown in the order that
-    would be obtained by sorting according to the supplied cmp function):
-
-        0.4       0.4.0  (these two are equivalent)
-        0.4.1
-        0.5a1
-        0.5b3
-        0.5
-        0.9.6
-        1.0
-        1.0.4a3
-        1.0.4b1
-        1.0.4
-
-    The following are examples of invalid version numbers:
-
-        1
-        2.7.2.2
-        1.3.a4
-        1.3pl1
-        1.3c4
-
-    The rationale for this version numbering system will be explained
-    in the distutils documentation.
-    """
-
-    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
-                            re.VERBOSE | re.ASCII)
-
-
-    def parse (self, vstring):
-        match = self.version_re.match(vstring)
-        if not match:
-            raise ValueError("invalid version number '%s'" % vstring)
-
-        (major, minor, patch, prerelease, prerelease_num) = \
-            match.group(1, 2, 4, 5, 6)
-
-        if patch:
-            self.version = tuple(map(int, [major, minor, patch]))
-        else:
-            self.version = tuple(map(int, [major, minor])) + (0,)
-
-        if prerelease:
-            self.prerelease = (prerelease[0], int(prerelease_num))
-        else:
-            self.prerelease = None
-
-
-    def __str__ (self):
-
-        if self.version[2] == 0:
-            vstring = '.'.join(map(str, self.version[0:2]))
-        else:
-            vstring = '.'.join(map(str, self.version))
-
-        if self.prerelease:
-            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
-
-        return vstring
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            other = StrictVersion(other)
-
-        if self.version != other.version:
-            # numeric versions don't match
-            # prerelease stuff doesn't matter
-            if self.version < other.version:
-                return -1
-            else:
-                return 1
-
-        # have to compare prerelease
-        # case 1: neither has prerelease; they're equal
-        # case 2: self has prerelease, other doesn't; other is greater
-        # case 3: self doesn't have prerelease, other does: self is greater
-        # case 4: both have prerelease: must compare them!
-
-        if (not self.prerelease and not other.prerelease):
-            return 0
-        elif (self.prerelease and not other.prerelease):
-            return -1
-        elif (not self.prerelease and other.prerelease):
-            return 1
-        elif (self.prerelease and other.prerelease):
-            if self.prerelease == other.prerelease:
-                return 0
-            elif self.prerelease < other.prerelease:
-                return -1
-            else:
-                return 1
-        else:
-            assert False, "never get here"
-
-# end class StrictVersion
-
-
-# The rules according to Greg Stein:
-# 1) a version number has 1 or more numbers separated by a period or by
-#    sequences of letters. If only periods, then these are compared
-#    left-to-right to determine an ordering.
-# 2) sequences of letters are part of the tuple for comparison and are
-#    compared lexicographically
-# 3) recognize the numeric components may have leading zeroes
-#
-# The LooseVersion class below implements these rules: a version number
-# string is split up into a tuple of integer and string components, and
-# comparison is a simple tuple comparison.  This means that version
-# numbers behave in a predictable and obvious way, but a way that might
-# not necessarily be how people *want* version numbers to behave.  There
-# wouldn't be a problem if people could stick to purely numeric version
-# numbers: just split on period and compare the numbers as tuples.
-# However, people insist on putting letters into their version numbers;
-# the most common purpose seems to be:
-#   - indicating a "pre-release" version
-#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
-#   - indicating a post-release patch ('p', 'pl', 'patch')
-# but of course this can't cover all version number schemes, and there's
-# no way to know what a programmer means without asking him.
-#
-# The problem is what to do with letters (and other non-numeric
-# characters) in a version number.  The current implementation does the
-# obvious and predictable thing: keep them as strings and compare
-# lexically within a tuple comparison.  This has the desired effect if
-# an appended letter sequence implies something "post-release":
-# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
-#
-# However, if letters in a version number imply a pre-release version,
-# the "obvious" thing isn't correct.  Eg. you would expect that
-# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
-# implemented here, this just isn't so.
-#
-# Two possible solutions come to mind.  The first is to tie the
-# comparison algorithm to a particular set of semantic rules, as has
-# been done in the StrictVersion class above.  This works great as long
-# as everyone can go along with bondage and discipline.  Hopefully a
-# (large) subset of Python module programmers will agree that the
-# particular flavour of bondage and discipline provided by StrictVersion
-# provides enough benefit to be worth using, and will submit their
-# version numbering scheme to its domination.  The free-thinking
-# anarchists in the lot will never give in, though, and something needs
-# to be done to accommodate them.
-#
-# Perhaps a "moderately strict" version class could be implemented that
-# lets almost anything slide (syntactically), and makes some heuristic
-# assumptions about non-digits in version number strings.  This could
-# sink into special-case-hell, though; if I was as talented and
-# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
-# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
-# just as happy dealing with things like "2g6" and "1.13++".  I don't
-# think I'm smart enough to do it right though.
-#
-# In any case, I've coded the test suite for this module (see
-# ../test/test_version.py) specifically to fail on things like comparing
-# "1.2a2" and "1.2".  That's not because the *code* is doing anything
-# wrong, it's because the simple, obvious design doesn't match my
-# complicated, hairy expectations for real-world version numbers.  It
-# would be a snap to fix the test suite to say, "Yep, LooseVersion does
-# the Right Thing" (ie. the code matches the conception).  But I'd rather
-# have a conception that matches common notions about version numbers.
-
-class LooseVersion (Version):
-
-    """Version numbering for anarchists and software realists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of a series of numbers,
-    separated by either periods or strings of letters.  When comparing
-    version numbers, the numeric components will be compared
-    numerically, and the alphabetic components lexically.  The following
-    are all valid version numbers, in no particular order:
-
-        1.5.1
-        1.5.2b2
-        161
-        3.10a
-        8.02
-        3.4j
-        1996.07.12
-        3.2.pl0
-        3.1.1.6
-        2g6
-        11g
-        0.960923
-        2.2beta29
-        1.13++
-        5.5.kw
-        2.0b1pl0
-
-    In fact, there is no such thing as an invalid version number under
-    this scheme; the rules for comparison are simple and predictable,
-    but may not always give the results you want (for some definition
-    of "want").
-    """
-
-    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
-
-    def __init__ (self, vstring=None):
-        if vstring:
-            self.parse(vstring)
-
-
-    def parse (self, vstring):
-        # I've given up on thinking I can reconstruct the version string
-        # from the parsed tuple -- so I just store the string here for
-        # use by __str__
-        self.vstring = vstring
-        components = [x for x in self.component_re.split(vstring)
-                              if x and x != '.']
-        for i, obj in enumerate(components):
-            try:
-                components[i] = int(obj)
-            except ValueError:
-                pass
-
-        self.version = components
-
-
-    def __str__ (self):
-        return self.vstring
-
-
-    def __repr__ (self):
-        return "LooseVersion ('%s')" % str(self)
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            other = LooseVersion(other)
-
-        if self.version == other.version:
-            return 0
-        if self.version < other.version:
-            return -1
-        if self.version > other.version:
-            return 1
-
-
-# end class LooseVersion
diff --git a/Lib/distutils/versionpredicate.py b/Lib/distutils/versionpredicate.py
deleted file mode 100644
index 062c98f2489..00000000000
--- a/Lib/distutils/versionpredicate.py
+++ /dev/null
@@ -1,166 +0,0 @@
-"""Module for parsing and testing package version predicate strings.
-"""
-import re
-import distutils.version
-import operator
-
-
-re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
-    re.ASCII)
-# (package) (rest)
-
-re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
-re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
-# (comp) (version)
-
-
-def splitUp(pred):
-    """Parse a single version comparison.
-
-    Return (comparison string, StrictVersion)
-    """
-    res = re_splitComparison.match(pred)
-    if not res:
-        raise ValueError("bad package restriction syntax: %r" % pred)
-    comp, verStr = res.groups()
-    return (comp, distutils.version.StrictVersion(verStr))
-
-compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
-           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
-
-class VersionPredicate:
-    """Parse and test package version predicates.
-
-    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
-
-    The `name` attribute provides the full dotted name that is given::
-
-    >>> v.name
-    'pyepat.abc'
-
-    The str() of a `VersionPredicate` provides a normalized
-    human-readable version of the expression::
-
-    >>> print(v)
-    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
-
-    The `satisfied_by()` method can be used to determine with a given
-    version number is included in the set described by the version
-    restrictions::
-
-    >>> v.satisfied_by('1.1')
-    True
-    >>> v.satisfied_by('1.4')
-    True
-    >>> v.satisfied_by('1.0')
-    False
-    >>> v.satisfied_by('4444.4')
-    False
-    >>> v.satisfied_by('1555.1b3')
-    False
-
-    `VersionPredicate` is flexible in accepting extra whitespace::
-
-    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
-    >>> v.name
-    'pat'
-    >>> v.satisfied_by('0.1')
-    True
-    >>> v.satisfied_by('0.2')
-    False
-
-    If any version numbers passed in do not conform to the
-    restrictions of `StrictVersion`, a `ValueError` is raised::
-
-    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
-    Traceback (most recent call last):
-      ...
-    ValueError: invalid version number '1.2zb3'
-
-    It the module or package name given does not conform to what's
-    allowed as a legal module or package name, `ValueError` is
-    raised::
-
-    >>> v = VersionPredicate('foo-bar')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: '-bar'
-
-    >>> v = VersionPredicate('foo bar (12.21)')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: 'bar (12.21)'
-
-    """
-
-    def __init__(self, versionPredicateStr):
-        """Parse a version predicate string.
-        """
-        # Fields:
-        #    name:  package name
-        #    pred:  list of (comparison string, StrictVersion)
-
-        versionPredicateStr = versionPredicateStr.strip()
-        if not versionPredicateStr:
-            raise ValueError("empty package restriction")
-        match = re_validPackage.match(versionPredicateStr)
-        if not match:
-            raise ValueError("bad package name in %r" % versionPredicateStr)
-        self.name, paren = match.groups()
-        paren = paren.strip()
-        if paren:
-            match = re_paren.match(paren)
-            if not match:
-                raise ValueError("expected parenthesized list: %r" % paren)
-            str = match.groups()[0]
-            self.pred = [splitUp(aPred) for aPred in str.split(",")]
-            if not self.pred:
-                raise ValueError("empty parenthesized list in %r"
-                                 % versionPredicateStr)
-        else:
-            self.pred = []
-
-    def __str__(self):
-        if self.pred:
-            seq = [cond + " " + str(ver) for cond, ver in self.pred]
-            return self.name + " (" + ", ".join(seq) + ")"
-        else:
-            return self.name
-
-    def satisfied_by(self, version):
-        """True if version is compatible with all the predicates in self.
-        The parameter version must be acceptable to the StrictVersion
-        constructor.  It may be either a string or StrictVersion.
-        """
-        for cond, ver in self.pred:
-            if not compmap[cond](version, ver):
-                return False
-        return True
-
-
-_provision_rx = None
-
-def split_provision(value):
-    """Return the name and optional version number of a provision.
-
-    The version number, if given, will be returned as a `StrictVersion`
-    instance, otherwise it will be `None`.
-
-    >>> split_provision('mypkg')
-    ('mypkg', None)
-    >>> split_provision(' mypkg( 1.2 ) ')
-    ('mypkg', StrictVersion ('1.2'))
-    """
-    global _provision_rx
-    if _provision_rx is None:
-        _provision_rx = re.compile(
-            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
-            re.ASCII)
-    value = value.strip()
-    m = _provision_rx.match(value)
-    if not m:
-        raise ValueError("illegal provides specification: %r" % value)
-    ver = m.group(2) or None
-    if ver:
-        ver = distutils.version.StrictVersion(ver)
-    return m.group(1), ver
diff --git a/Lib/doctest.py b/Lib/doctest.py
index 387f71b184a..ecac54ad5a5 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -94,6 +94,7 @@ def _test():
 
 import __future__
 import difflib
+import functools
 import inspect
 import linecache
 import os
@@ -104,8 +105,26 @@ def _test():
 import unittest
 from io import StringIO, IncrementalNewlineDecoder
 from collections import namedtuple
+import _colorize  # Used in doctests
+from _colorize import ANSIColors, can_colorize
+
+
+class TestResults(namedtuple('TestResults', 'failed attempted')):
+    def __new__(cls, failed, attempted, *, skipped=0):
+        results = super().__new__(cls, failed, attempted)
+        results.skipped = skipped
+        return results
+
+    def __repr__(self):
+        if self.skipped:
+            return (f'TestResults(failed={self.failed}, '
+                    f'attempted={self.attempted}, '
+                    f'skipped={self.skipped})')
+        else:
+            # Leave the repr() unchanged for backward compatibility
+            # if skipped is zero
+            return super().__repr__()
 
-TestResults = namedtuple('TestResults', 'failed attempted')
 
 # There are 4 basic classes:
 #  - Example: a <source, want> pair, plus an intra-docstring line number.
@@ -207,7 +226,13 @@ def _normalize_module(module, depth=2):
     elif isinstance(module, str):
         return __import__(module, globals(), locals(), ["*"])
     elif module is None:
-        return sys.modules[sys._getframe(depth).f_globals['__name__']]
+        try:
+            try:
+                return sys.modules[sys._getframemodulename(depth)]
+            except AttributeError:
+                return sys.modules[sys._getframe(depth).f_globals['__name__']]
+        except KeyError:
+            pass
     else:
         raise TypeError("Expected a module, string, or None")
 
@@ -229,7 +254,6 @@ def _load_testfile(filename, package, module_relative, encoding):
             file_contents = file_contents.decode(encoding)
             # get_data() opens files as 'rb', so one must do the equivalent
             # conversion as universal newlines would do.
-
             return _newline_convert(file_contents), filename
     with open(filename, encoding=encoding) as f:
         return f.read(), filename
@@ -570,9 +594,11 @@ def __hash__(self):
     def __lt__(self, other):
         if not isinstance(other, DocTest):
             return NotImplemented
-        return ((self.name, self.filename, self.lineno, id(self))
+        self_lno = self.lineno if self.lineno is not None else -1
+        other_lno = other.lineno if other.lineno is not None else -1
+        return ((self.name, self.filename, self_lno, id(self))
                 <
-                (other.name, other.filename, other.lineno, id(other)))
+                (other.name, other.filename, other_lno, id(other)))
 
 ######################################################################
 ## 3. DocTestParser
@@ -957,7 +983,8 @@ def _from_module(self, module, object):
             return module is inspect.getmodule(object)
         elif inspect.isfunction(object):
             return module.__dict__ is object.__globals__
-        elif inspect.ismethoddescriptor(object):
+        elif (inspect.ismethoddescriptor(object) or
+              inspect.ismethodwrapper(object)):
             if hasattr(object, '__objclass__'):
                 obj_mod = object.__objclass__.__module__
             elif hasattr(object, '__module__'):
@@ -1104,7 +1131,7 @@ def _find_lineno(self, obj, source_lines):
             if source_lines is None:
                 return None
             pat = re.compile(r'^\s*class\s*%s\b' %
-                             getattr(obj, '__name__', '-'))
+                             re.escape(getattr(obj, '__name__', '-')))
             for i, line in enumerate(source_lines):
                 if pat.match(line):
                     lineno = i
@@ -1112,13 +1139,24 @@ def _find_lineno(self, obj, source_lines):
 
         # Find the line number for functions & methods.
         if inspect.ismethod(obj): obj = obj.__func__
-        if inspect.isfunction(obj) and getattr(obj, '__doc__', None):
+        if isinstance(obj, property):
+            obj = obj.fget
+        if isinstance(obj, functools.cached_property):
+            obj = obj.func
+        if inspect.isroutine(obj) and getattr(obj, '__doc__', None):
             # We don't use `docstring` var here, because `obj` can be changed.
-            obj = obj.__code__
+            obj = inspect.unwrap(obj)
+            try:
+                obj = obj.__code__
+            except AttributeError:
+                # Functions implemented in C don't necessarily
+                # have a __code__ attribute.
+                # If there's no code, there's no lineno
+                return None
         if inspect.istraceback(obj): obj = obj.tb_frame
         if inspect.isframe(obj): obj = obj.f_code
         if inspect.iscode(obj):
-            lineno = getattr(obj, 'co_firstlineno', None)-1
+            lineno = obj.co_firstlineno - 1
 
         # Find the line number where the docstring starts.  Assume
         # that it's the first line that begins with a quote mark.
@@ -1144,8 +1182,10 @@ class DocTestRunner:
     """
     A class used to run DocTest test cases, and accumulate statistics.
     The `run` method is used to process a single DocTest case.  It
-    returns a tuple `(f, t)`, where `t` is the number of test cases
-    tried, and `f` is the number of test cases that failed.
+    returns a TestResults instance.
+
+        >>> save_colorize = _colorize.COLORIZE
+        >>> _colorize.COLORIZE = False
 
         >>> tests = DocTestFinder().find(_TestClass)
         >>> runner = DocTestRunner(verbose=False)
@@ -1158,27 +1198,29 @@ class DocTestRunner:
         _TestClass.square -> TestResults(failed=0, attempted=1)
 
     The `summarize` method prints a summary of all the test cases that
-    have been run by the runner, and returns an aggregated `(f, t)`
-    tuple:
+    have been run by the runner, and returns an aggregated TestResults
+    instance:
 
         >>> runner.summarize(verbose=1)
         4 items passed all tests:
            2 tests in _TestClass
            2 tests in _TestClass.__init__
            2 tests in _TestClass.get
-           1 tests in _TestClass.square
+           1 test in _TestClass.square
         7 tests in 4 items.
-        7 passed and 0 failed.
+        7 passed.
         Test passed.
         TestResults(failed=0, attempted=7)
 
-    The aggregated number of tried examples and failed examples is
-    also available via the `tries` and `failures` attributes:
+    The aggregated number of tried examples and failed examples is also
+    available via the `tries`, `failures` and `skips` attributes:
 
         >>> runner.tries
         7
         >>> runner.failures
         0
+        >>> runner.skips
+        0
 
     The comparison between expected outputs and actual outputs is done
     by an `OutputChecker`.  This comparison may be customized with a
@@ -1195,6 +1237,8 @@ class DocTestRunner:
     can be also customized by subclassing DocTestRunner, and
     overriding the methods `report_start`, `report_success`,
     `report_unexpected_exception`, and `report_failure`.
+
+        >>> _colorize.COLORIZE = save_colorize
     """
     # This divider string is used to separate failure messages, and to
     # separate sections of the summary.
@@ -1227,7 +1271,8 @@ def __init__(self, checker=None, verbose=None, optionflags=0):
         # Keep track of the examples we've run.
         self.tries = 0
         self.failures = 0
-        self._name2ft = {}
+        self.skips = 0
+        self._stats = {}
 
         # Create a fake output target for capturing doctest output.
         self._fakeout = _SpoofOut()
@@ -1272,7 +1317,10 @@ def report_unexpected_exception(self, out, test, example, exc_info):
             'Exception raised:\n' + _indent(_exception_traceback(exc_info)))
 
     def _failure_header(self, test, example):
-        out = [self.DIVIDER]
+        red, reset = (
+            (ANSIColors.RED, ANSIColors.RESET) if can_colorize() else ("", "")
+        )
+        out = [f"{red}{self.DIVIDER}{reset}"]
         if test.filename:
             if test.lineno is not None and example.lineno is not None:
                 lineno = test.lineno + example.lineno + 1
@@ -1296,13 +1344,11 @@ def __run(self, test, compileflags, out):
         Run the examples in `test`.  Write the outcome of each example
         with one of the `DocTestRunner.report_*` methods, using the
         writer function `out`.  `compileflags` is the set of compiler
-        flags that should be used to execute examples.  Return a tuple
-        `(f, t)`, where `t` is the number of examples tried, and `f`
-        is the number of examples that failed.  The examples are run
-        in the namespace `test.globs`.
+        flags that should be used to execute examples.  Return a TestResults
+        instance.  The examples are run in the namespace `test.globs`.
         """
-        # Keep track of the number of failures and tries.
-        failures = tries = 0
+        # Keep track of the number of failed, attempted, skipped examples.
+        failures = attempted = skips = 0
 
         # Save the option flags (since option directives can be used
         # to modify them).
@@ -1314,6 +1360,7 @@ def __run(self, test, compileflags, out):
 
         # Process each example.
         for examplenum, example in enumerate(test.examples):
+            attempted += 1
 
             # If REPORT_ONLY_FIRST_FAILURE is set, then suppress
             # reporting after the first failure.
@@ -1331,10 +1378,10 @@ def __run(self, test, compileflags, out):
 
             # If 'SKIP' is set, then skip this example.
             if self.optionflags & SKIP:
+                skips += 1
                 continue
 
             # Record that we started this example.
-            tries += 1
             if not quiet:
                 self.report_start(out, test, example)
 
@@ -1370,7 +1417,24 @@ def __run(self, test, compileflags, out):
 
             # The example raised an exception:  check if it was expected.
             else:
-                exc_msg = traceback.format_exception_only(*exception[:2])[-1]
+                formatted_ex = traceback.format_exception_only(*exception[:2])
+                if issubclass(exception[0], SyntaxError):
+                    # SyntaxError / IndentationError is special:
+                    # we don't care about the carets / suggestions / etc
+                    # We only care about the error message and notes.
+                    # They start with `SyntaxError:` (or any other class name)
+                    exception_line_prefixes = (
+                        f"{exception[0].__qualname__}:",
+                        f"{exception[0].__module__}.{exception[0].__qualname__}:",
+                    )
+                    exc_msg_index = next(
+                        index
+                        for index, line in enumerate(formatted_ex)
+                        if line.startswith(exception_line_prefixes)
+                    )
+                    formatted_ex = formatted_ex[exc_msg_index:]
+
+                exc_msg = "".join(formatted_ex)
                 if not quiet:
                     got += _exception_traceback(exception)
 
@@ -1412,19 +1476,22 @@ def __run(self, test, compileflags, out):
         # Restore the option flags (in case they were modified)
         self.optionflags = original_optionflags
 
-        # Record and return the number of failures and tries.
-        self.__record_outcome(test, failures, tries)
-        return TestResults(failures, tries)
+        # Record and return the number of failures and attempted.
+        self.__record_outcome(test, failures, attempted, skips)
+        return TestResults(failures, attempted, skipped=skips)
 
-    def __record_outcome(self, test, f, t):
+    def __record_outcome(self, test, failures, tries, skips):
         """
-        Record the fact that the given DocTest (`test`) generated `f`
-        failures out of `t` tried examples.
+        Record the fact that the given DocTest (`test`) generated `failures`
+        failures out of `tries` tried examples.
         """
-        f2, t2 = self._name2ft.get(test.name, (0,0))
-        self._name2ft[test.name] = (f+f2, t+t2)
-        self.failures += f
-        self.tries += t
+        failures2, tries2, skips2 = self._stats.get(test.name, (0, 0, 0))
+        self._stats[test.name] = (failures + failures2,
+                                  tries + tries2,
+                                  skips + skips2)
+        self.failures += failures
+        self.tries += tries
+        self.skips += skips
 
     __LINECACHE_FILENAME_RE = re.compile(r'<doctest '
                                          r'(?P<name>.+)'
@@ -1493,7 +1560,11 @@ def out(s):
         # Make sure sys.displayhook just prints the value to stdout
         save_displayhook = sys.displayhook
         sys.displayhook = sys.__displayhook__
-
+        saved_can_colorize = _colorize.can_colorize
+        _colorize.can_colorize = lambda *args, **kwargs: False
+        color_variables = {"PYTHON_COLORS": None, "FORCE_COLOR": None}
+        for key in color_variables:
+            color_variables[key] = os.environ.pop(key, None)
         try:
             return self.__run(test, compileflags, out)
         finally:
@@ -1502,6 +1573,10 @@ def out(s):
             sys.settrace(save_trace)
             linecache.getlines = self.save_linecache_getlines
             sys.displayhook = save_displayhook
+            _colorize.can_colorize = saved_can_colorize
+            for key, value in color_variables.items():
+                if value is not None:
+                    os.environ[key] = value
             if clear_globs:
                 test.globs.clear()
                 import builtins
@@ -1513,9 +1588,7 @@ def out(s):
     def summarize(self, verbose=None):
         """
         Print a summary of all the test cases that have been run by
-        this DocTestRunner, and return a tuple `(f, t)`, where `f` is
-        the total number of failed examples, and `t` is the total
-        number of tried examples.
+        this DocTestRunner, and return a TestResults instance.
 
         The optional `verbose` argument controls how detailed the
         summary is.  If the verbosity is not specified, then the
@@ -1523,66 +1596,98 @@ def summarize(self, verbose=None):
         """
         if verbose is None:
             verbose = self._verbose
-        notests = []
-        passed = []
-        failed = []
-        totalt = totalf = 0
-        for x in self._name2ft.items():
-            name, (f, t) = x
-            assert f <= t
-            totalt += t
-            totalf += f
-            if t == 0:
+
+        notests, passed, failed = [], [], []
+        total_tries = total_failures = total_skips = 0
+
+        for name, (failures, tries, skips) in self._stats.items():
+            assert failures <= tries
+            total_tries += tries
+            total_failures += failures
+            total_skips += skips
+
+            if tries == 0:
                 notests.append(name)
-            elif f == 0:
-                passed.append( (name, t) )
+            elif failures == 0:
+                passed.append((name, tries))
             else:
-                failed.append(x)
+                failed.append((name, (failures, tries, skips)))
+
+        ansi = _colorize.get_colors()
+        bold_green = ansi.BOLD_GREEN
+        bold_red = ansi.BOLD_RED
+        green = ansi.GREEN
+        red = ansi.RED
+        reset = ansi.RESET
+        yellow = ansi.YELLOW
+
         if verbose:
             if notests:
-                print(len(notests), "items had no tests:")
+                print(f"{_n_items(notests)} had no tests:")
                 notests.sort()
-                for thing in notests:
-                    print("   ", thing)
+                for name in notests:
+                    print(f"    {name}")
+
             if passed:
-                print(len(passed), "items passed all tests:")
-                passed.sort()
-                for thing, count in passed:
-                    print(" %3d tests in %s" % (count, thing))
+                print(f"{green}{_n_items(passed)} passed all tests:{reset}")
+                for name, count in sorted(passed):
+                    s = "" if count == 1 else "s"
+                    print(f" {green}{count:3d} test{s} in {name}{reset}")
+
         if failed:
-            print(self.DIVIDER)
-            print(len(failed), "items had failures:")
-            failed.sort()
-            for thing, (f, t) in failed:
-                print(" %3d of %3d in %s" % (f, t, thing))
+            print(f"{red}{self.DIVIDER}{reset}")
+            print(f"{_n_items(failed)} had failures:")
+            for name, (failures, tries, skips) in sorted(failed):
+                print(f" {failures:3d} of {tries:3d} in {name}")
+
         if verbose:
-            print(totalt, "tests in", len(self._name2ft), "items.")
-            print(totalt - totalf, "passed and", totalf, "failed.")
-        if totalf:
-            print("***Test Failed***", totalf, "failures.")
+            s = "" if total_tries == 1 else "s"
+            print(f"{total_tries} test{s} in {_n_items(self._stats)}.")
+
+            and_f = (
+                f" and {red}{total_failures} failed{reset}"
+                if total_failures else ""
+            )
+            print(f"{green}{total_tries - total_failures} passed{reset}{and_f}.")
+
+        if total_failures:
+            s = "" if total_failures == 1 else "s"
+            msg = f"{bold_red}***Test Failed*** {total_failures} failure{s}{reset}"
+            if total_skips:
+                s = "" if total_skips == 1 else "s"
+                msg = f"{msg} and {yellow}{total_skips} skipped test{s}{reset}"
+            print(f"{msg}.")
         elif verbose:
-            print("Test passed.")
-        return TestResults(totalf, totalt)
+            print(f"{bold_green}Test passed.{reset}")
+
+        return TestResults(total_failures, total_tries, skipped=total_skips)
 
     #/////////////////////////////////////////////////////////////////
     # Backward compatibility cruft to maintain doctest.master.
     #/////////////////////////////////////////////////////////////////
     def merge(self, other):
-        d = self._name2ft
-        for name, (f, t) in other._name2ft.items():
+        d = self._stats
+        for name, (failures, tries, skips) in other._stats.items():
             if name in d:
-                # Don't print here by default, since doing
-                #     so breaks some of the buildbots
-                #print("*** DocTestRunner.merge: '" + name + "' in both" \
-                #    " testers; summing outcomes.")
-                f2, t2 = d[name]
-                f = f + f2
-                t = t + t2
-            d[name] = f, t
+                failures2, tries2, skips2 = d[name]
+                failures = failures + failures2
+                tries = tries + tries2
+                skips = skips + skips2
+            d[name] = (failures, tries, skips)
+
+
+def _n_items(items: list | dict) -> str:
+    """
+    Helper to pluralise the number of items in a list.
+    """
+    n = len(items)
+    s = "" if n == 1 else "s"
+    return f"{n} item{s}"
+
 
 class OutputChecker:
     """
-    A class used to check the whether the actual output from a doctest
+    A class used to check whether the actual output from a doctest
     example matches the expected output.  `OutputChecker` defines two
     methods: `check_output`, which compares a given pair of outputs,
     and returns true if they match; and `output_difference`, which
@@ -1887,8 +1992,8 @@ def testmod(m=None, name=None, globs=None, verbose=None,
     from module m (or the current module if m is not supplied), starting
     with m.__doc__.
 
-    Also test examples reachable from dict m.__test__ if it exists and is
-    not None.  m.__test__ maps names to functions, classes and strings;
+    Also test examples reachable from dict m.__test__ if it exists.
+    m.__test__ maps names to functions, classes and strings;
     function and class docstrings are tested even if the name is private;
     strings are tested directly, as if they were docstrings.
 
@@ -1978,7 +2083,8 @@ class doctest.Tester, then merges the results into (or creates)
     else:
         master.merge(runner)
 
-    return TestResults(runner.failures, runner.tries)
+    return TestResults(runner.failures, runner.tries, skipped=runner.skips)
+
 
 def testfile(filename, module_relative=True, name=None, package=None,
              globs=None, verbose=None, report=True, optionflags=0,
@@ -2101,7 +2207,8 @@ class doctest.Tester, then merges the results into (or creates)
     else:
         master.merge(runner)
 
-    return TestResults(runner.failures, runner.tries)
+    return TestResults(runner.failures, runner.tries, skipped=runner.skips)
+
 
 def run_docstring_examples(f, globs, verbose=False, name="NoName",
                            compileflags=None, optionflags=0):
@@ -2176,13 +2283,13 @@ def __init__(self, test, optionflags=0, setUp=None, tearDown=None,
         unittest.TestCase.__init__(self)
         self._dt_optionflags = optionflags
         self._dt_checker = checker
-        self._dt_globs = test.globs.copy()
         self._dt_test = test
         self._dt_setUp = setUp
         self._dt_tearDown = tearDown
 
     def setUp(self):
         test = self._dt_test
+        self._dt_globs = test.globs.copy()
 
         if self._dt_setUp is not None:
             self._dt_setUp(test)
@@ -2213,12 +2320,13 @@ def runTest(self):
 
         try:
             runner.DIVIDER = "-"*70
-            failures, tries = runner.run(
-                test, out=new.write, clear_globs=False)
+            results = runner.run(test, out=new.write, clear_globs=False)
+            if results.skipped == results.attempted:
+                raise unittest.SkipTest("all examples were skipped")
         finally:
             sys.stdout = old
 
-        if failures:
+        if results.failed:
             raise self.failureException(self.format_failure(new.getvalue()))
 
     def format_failure(self, err):
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
index 2636c1fbb98..1bb74c6d969 100644
--- a/Lib/test/datetimetester.py
+++ b/Lib/test/datetimetester.py
@@ -1,3 +1,6 @@
+# TODO: RustPython
+# Skipping some tests because time module has no attribute tzset
+# implementation detail specific to cpython
 """Test date/time type.
 
 See https://www.zope.dev/Members/fdrake/DateTimeWiki/TestCases
@@ -13,6 +16,7 @@
 import re
 import struct
 import sys
+import textwrap
 import unittest
 import warnings
 
@@ -22,6 +26,7 @@
 
 from test import support
 from test.support import is_resource_enabled, ALWAYS_EQ, LARGEST, SMALLEST
+from test.support import script_helper, warnings_helper
 
 import datetime as datetime_module
 from datetime import MINYEAR, MAXYEAR
@@ -37,6 +42,10 @@
     import _testcapi
 except ImportError:
     _testcapi = None
+try:
+    import _interpreters
+except ModuleNotFoundError:
+    _interpreters = None
 
 # Needed by test_datetime
 import _strptime
@@ -301,6 +310,10 @@ def test_inheritance(self):
         self.assertIsInstance(timezone.utc, tzinfo)
         self.assertIsInstance(self.EST, tzinfo)
 
+    def test_cannot_subclass(self):
+        with self.assertRaises(TypeError):
+            class MyTimezone(timezone): pass
+
     def test_utcoffset(self):
         dummy = self.DT
         for h in [0, 1.5, 12]:
@@ -752,6 +765,9 @@ def test_str(self):
                    microseconds=999999)),
            "999999999 days, 23:59:59.999999")
 
+        # test the Doc/library/datetime.rst recipe
+        eq(f'-({-td(hours=-1)!s})', "-(1:00:00)")
+
     def test_repr(self):
         name = 'datetime.' + self.theclass.__name__
         self.assertEqual(repr(self.theclass(1)),
@@ -1331,6 +1347,11 @@ def test_insane_fromtimestamp(self):
             self.assertRaises(OverflowError, self.theclass.fromtimestamp,
                               insane)
 
+    def test_fromtimestamp_with_none_arg(self):
+        # See gh-120268 for more details
+        with self.assertRaises(TypeError):
+            self.theclass.fromtimestamp(None)
+
     def test_today(self):
         import time
 
@@ -1498,8 +1519,7 @@ def test_strftime(self):
         # bpo-41260: The parameter was named "fmt" in the pure python impl.
         t.strftime(format="%f")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_strftime_trailing_percent(self):
         # bpo-35066: Make sure trailing '%' doesn't cause datetime's strftime to
         # complain. Different libcs have different handling of trailing
@@ -1600,8 +1620,7 @@ def test_pickling(self):
             self.assertEqual(orig, derived)
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ndate\n(S'\\x07\\xdf\\x0b\\x1b'\ntR.",
@@ -1703,29 +1722,44 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
 
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4)):
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     def test_subclass_replace(self):
         class DateSubclass(self.theclass):
-            pass
+            def __new__(cls, *args, **kwargs):
+                result = self.theclass.__new__(cls, *args, **kwargs)
+                result.extra = 7
+                return result
 
         dt = DateSubclass(2012, 1, 1)
-        self.assertIs(type(dt.replace(year=2013)), DateSubclass)
+
+        test_cases = [
+            ('self.replace', dt.replace(year=2013)),
+            ('copy.replace', copy.replace(dt, year=2013)),
+        ]
+
+        for name, res in test_cases:
+            with self.subTest(name):
+                self.assertIs(type(res), DateSubclass)
+                self.assertEqual(res.year, 2013)
+                self.assertEqual(res.month, 1)
+                self.assertEqual(res.extra, 7)
 
     def test_subclass_date(self):
 
@@ -1912,6 +1946,10 @@ def test_fromisoformat_fails(self):
             '2009-02-29',       # Invalid leap day
             '2019-W53-1',       # No week 53 in 2019
             '2020-W54-1',       # No week 54
+            '0000-W25-1',       # Invalid year
+            '10000-W25-1',      # Invalid year
+            '2020-W25-0',       # Invalid day-of-week
+            '2020-W25-8',       # Invalid day-of-week
             '2009\ud80002\ud80028',     # Separators are surrogate codepoints
         ]
 
@@ -2369,8 +2407,7 @@ def test_pickling_subclass_datetime(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassDatetime))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n('
@@ -2780,6 +2817,20 @@ def test_strptime_single_digit(self):
                 newdate = strptime(string, format)
                 self.assertEqual(newdate, target, msg=reason)
 
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)
+    def test_strptime_leap_year(self):
+        # GH-70647: warns if parsing a format with a day and no year.
+        with self.assertRaises(ValueError):
+            # The existing behavior that GH-70647 seeks to change.
+            self.theclass.strptime('02-29', '%m-%d')
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r'.*day of month without a year.*'):
+            self.theclass.strptime('03-14.159265', '%m-%d.%f')
+        with self._assertNotWarns(DeprecationWarning):
+            self.theclass.strptime('20-03-14.159265', '%y-%m-%d.%f')
+        with self._assertNotWarns(DeprecationWarning):
+            self.theclass.strptime('02-29,2024', '%m-%d,%Y')
+
     def test_more_timetuple(self):
         # This tests fields beyond those tested by the TestDate.test_timetuple.
         t = self.theclass(2004, 12, 31, 6, 22, 33)
@@ -2813,11 +2864,34 @@ def test_more_strftime(self):
             self.assertEqual(t.strftime("%z"), "-0200" + z)
             self.assertEqual(t.strftime("%:z"), "-02:00:" + z)
 
-        # bpo-34482: Check that surrogates don't cause a crash.
-        try:
-            t.strftime('%y\ud800%m %H\ud800%M')
-        except UnicodeEncodeError:
-            pass
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
+    def test_strftime_special(self):
+        t = self.theclass(2004, 12, 31, 6, 22, 33, 47)
+        s1 = t.strftime('%c')
+        s2 = t.strftime('%B')
+        # gh-52551, gh-78662: Unicode strings should pass through strftime,
+        # independently from locale.
+        self.assertEqual(t.strftime('\U0001f40d'), '\U0001f40d')
+        self.assertEqual(t.strftime('\U0001f4bb%c\U0001f40d%B'), f'\U0001f4bb{s1}\U0001f40d{s2}')
+        self.assertEqual(t.strftime('%c\U0001f4bb%B\U0001f40d'), f'{s1}\U0001f4bb{s2}\U0001f40d')
+        # Lone surrogates should pass through.
+        self.assertEqual(t.strftime('\ud83d'), '\ud83d')
+        self.assertEqual(t.strftime('\udc0d'), '\udc0d')
+        self.assertEqual(t.strftime('\ud83d%c\udc0d%B'), f'\ud83d{s1}\udc0d{s2}')
+        self.assertEqual(t.strftime('%c\ud83d%B\udc0d'), f'{s1}\ud83d{s2}\udc0d')
+        self.assertEqual(t.strftime('%c\udc0d%B\ud83d'), f'{s1}\udc0d{s2}\ud83d')
+        # Surrogate pairs should not recombine.
+        self.assertEqual(t.strftime('\ud83d\udc0d'), '\ud83d\udc0d')
+        self.assertEqual(t.strftime('%c\ud83d\udc0d%B'), f'{s1}\ud83d\udc0d{s2}')
+        # Surrogate-escaped bytes should not recombine.
+        self.assertEqual(t.strftime('\udcf0\udc9f\udc90\udc8d'), '\udcf0\udc9f\udc90\udc8d')
+        self.assertEqual(t.strftime('%c\udcf0\udc9f\udc90\udc8d%B'), f'{s1}\udcf0\udc9f\udc90\udc8d{s2}')
+        # gh-124531: The null character should not terminate the format string.
+        self.assertEqual(t.strftime('\0'), '\0')
+        self.assertEqual(t.strftime('\0'*1000), '\0'*1000)
+        self.assertEqual(t.strftime('\0%c\0%B'), f'\0{s1}\0{s2}')
+        self.assertEqual(t.strftime('%c\0%B\0'), f'{s1}\0{s2}\0')
 
     def test_extract(self):
         dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
@@ -2862,26 +2936,27 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3, 4, 5, 6, 7]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4),
-                             ("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4),
+                   ("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     @support.run_with_tz('EDT4')
     def test_astimezone(self):
@@ -3024,6 +3099,26 @@ def __new__(cls, *args, **kwargs):
                 self.assertIsInstance(dt, DateTimeSubclass)
                 self.assertEqual(dt.extra, 7)
 
+    def test_subclass_replace_fold(self):
+        class DateTimeSubclass(self.theclass):
+            pass
+
+        dt = DateTimeSubclass(2012, 1, 1)
+        dt2 = DateTimeSubclass(2012, 1, 1, fold=1)
+
+        test_cases = [
+            ('self.replace', dt.replace(year=2013), 0),
+            ('self.replace', dt2.replace(year=2013), 1),
+            ('copy.replace', copy.replace(dt, year=2013), 0),
+            ('copy.replace', copy.replace(dt2, year=2013), 1),
+        ]
+
+        for name, res, fold in test_cases:
+            with self.subTest(name, fold=fold):
+                self.assertIs(type(res), DateTimeSubclass)
+                self.assertEqual(res.year, 2013)
+                self.assertEqual(res.fold, fold)
+
     def test_fromisoformat_datetime(self):
         # Test that isoformat() is reversible
         base_dates = [
@@ -3301,6 +3396,9 @@ def test_fromisoformat_fails_datetime(self):
             '2009-04-19T12:30:45.123456-05:00a',    # Extra text
             '2009-04-19T12:30:45.123-05:00a',       # Extra text
             '2009-04-19T12:30:45-05:00a',           # Extra text
+            '2009-04-19T12:30:45.400 +02:30',  # Space between ms and timezone (gh-130959)
+            '2009-04-19T12:30:45.400 ',        # Trailing space (gh-130959)
+            '2009-04-19T12:30:45. 400',        # Space before fraction (gh-130959)
         ]
 
         for bad_str in bad_strs:
@@ -3570,6 +3668,35 @@ def test_strftime(self):
         # gh-85432: The parameter was named "fmt" in the pure-Python impl.
         t.strftime(format="%f")
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
+    def test_strftime_special(self):
+        t = self.theclass(1, 2, 3, 4)
+        s1 = t.strftime('%I%p%Z')
+        s2 = t.strftime('%X')
+        # gh-52551, gh-78662: Unicode strings should pass through strftime,
+        # independently from locale.
+        self.assertEqual(t.strftime('\U0001f40d'), '\U0001f40d')
+        self.assertEqual(t.strftime('\U0001f4bb%I%p%Z\U0001f40d%X'), f'\U0001f4bb{s1}\U0001f40d{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\U0001f4bb%X\U0001f40d'), f'{s1}\U0001f4bb{s2}\U0001f40d')
+        # Lone surrogates should pass through.
+        self.assertEqual(t.strftime('\ud83d'), '\ud83d')
+        self.assertEqual(t.strftime('\udc0d'), '\udc0d')
+        self.assertEqual(t.strftime('\ud83d%I%p%Z\udc0d%X'), f'\ud83d{s1}\udc0d{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\ud83d%X\udc0d'), f'{s1}\ud83d{s2}\udc0d')
+        self.assertEqual(t.strftime('%I%p%Z\udc0d%X\ud83d'), f'{s1}\udc0d{s2}\ud83d')
+        # Surrogate pairs should not recombine.
+        self.assertEqual(t.strftime('\ud83d\udc0d'), '\ud83d\udc0d')
+        self.assertEqual(t.strftime('%I%p%Z\ud83d\udc0d%X'), f'{s1}\ud83d\udc0d{s2}')
+        # Surrogate-escaped bytes should not recombine.
+        self.assertEqual(t.strftime('\udcf0\udc9f\udc90\udc8d'), '\udcf0\udc9f\udc90\udc8d')
+        self.assertEqual(t.strftime('%I%p%Z\udcf0\udc9f\udc90\udc8d%X'), f'{s1}\udcf0\udc9f\udc90\udc8d{s2}')
+        # gh-124531: The null character should not terminate the format string.
+        self.assertEqual(t.strftime('\0'), '\0')
+        self.assertEqual(t.strftime('\0'*1000), '\0'*1000)
+        self.assertEqual(t.strftime('\0%I%p%Z\0%X'), f'\0{s1}\0{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\0%X\0'), f'{s1}\0{s2}\0')
+
     def test_format(self):
         t = self.theclass(1, 2, 3, 4)
         self.assertEqual(t.__format__(''), str(t))
@@ -3641,8 +3768,7 @@ def test_pickling_subclass_time(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassTime))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             (b"cdatetime\ntime\n(S'\\x14;\\x10\\x00\\x10\\x00'\ntR.",
@@ -3679,19 +3805,19 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3, 4]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(1)
@@ -3699,13 +3825,35 @@ def test_replace(self):
         self.assertRaises(ValueError, base.replace, minute=-1)
         self.assertRaises(ValueError, base.replace, second=100)
         self.assertRaises(ValueError, base.replace, microsecond=1000000)
+        self.assertRaises(ValueError, copy.replace, base, hour=24)
+        self.assertRaises(ValueError, copy.replace, base, minute=-1)
+        self.assertRaises(ValueError, copy.replace, base, second=100)
+        self.assertRaises(ValueError, copy.replace, base, microsecond=1000000)
 
     def test_subclass_replace(self):
         class TimeSubclass(self.theclass):
-            pass
+            def __new__(cls, *args, **kwargs):
+                result = self.theclass.__new__(cls, *args, **kwargs)
+                result.extra = 7
+                return result
 
         ctime = TimeSubclass(12, 30)
-        self.assertIs(type(ctime.replace(hour=10)), TimeSubclass)
+        ctime2 = TimeSubclass(12, 30, fold=1)
+
+        test_cases = [
+            ('self.replace', ctime.replace(hour=10), 0),
+            ('self.replace', ctime2.replace(hour=10), 1),
+            ('copy.replace', copy.replace(ctime, hour=10), 0),
+            ('copy.replace', copy.replace(ctime2, hour=10), 1),
+        ]
+
+        for name, res, fold in test_cases:
+            with self.subTest(name, fold=fold):
+                self.assertIs(type(res), TimeSubclass)
+                self.assertEqual(res.hour, 10)
+                self.assertEqual(res.minute, 30)
+                self.assertEqual(res.extra, 7)
+                self.assertEqual(res.fold, fold)
 
     def test_subclass_time(self):
 
@@ -3918,6 +4066,8 @@ def test_empty(self):
         self.assertEqual(t.microsecond, 0)
         self.assertIsNone(t.tzinfo)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud800' in position 0: surrogates not allowed
     def test_zones(self):
         est = FixedOffset(-300, "EST", 1)
         utc = FixedOffset(0, "UTC", -2)
@@ -4001,9 +4151,8 @@ def tzname(self, dt): return self.tz
         self.assertRaises(TypeError, t.strftime, "%Z")
 
         # Issue #6697:
-        if '_Fast' in self.__class__.__name__:
-            Badtzname.tz = '\ud800'
-            self.assertRaises(ValueError, t.strftime, "%Z")
+        Badtzname.tz = '\ud800'
+        self.assertEqual(t.strftime("%Z"), '\ud800')
 
     def test_hash_edge_cases(self):
         # Offsets that overflow a basic time.
@@ -4037,8 +4186,7 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ntime\n(S'\\x05\\x06\\x07\\x01\\xe2@'\n"
@@ -4095,31 +4243,37 @@ def test_replace(self):
         zm200 = FixedOffset(timedelta(minutes=-200), "-200")
         args = [1, 2, 3, 4, z100]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8),
-                             ("tzinfo", zm200)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8),
+                   ("tzinfo", zm200))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Ensure we can get rid of a tzinfo.
         self.assertEqual(base.tzname(), "+100")
         base2 = base.replace(tzinfo=None)
         self.assertIsNone(base2.tzinfo)
         self.assertIsNone(base2.tzname())
+        base22 = copy.replace(base, tzinfo=None)
+        self.assertIsNone(base22.tzinfo)
+        self.assertIsNone(base22.tzname())
 
         # Ensure we can add one.
         base3 = base2.replace(tzinfo=z100)
         self.assertEqual(base, base3)
         self.assertIs(base.tzinfo, base3.tzinfo)
+        base32 = copy.replace(base22, tzinfo=z100)
+        self.assertEqual(base, base32)
+        self.assertIs(base.tzinfo, base32.tzinfo)
 
         # Out of bounds.
         base = cls(1)
@@ -4127,6 +4281,10 @@ def test_replace(self):
         self.assertRaises(ValueError, base.replace, minute=-1)
         self.assertRaises(ValueError, base.replace, second=100)
         self.assertRaises(ValueError, base.replace, microsecond=1000000)
+        self.assertRaises(ValueError, copy.replace, base, hour=24)
+        self.assertRaises(ValueError, copy.replace, base, minute=-1)
+        self.assertRaises(ValueError, copy.replace, base, second=100)
+        self.assertRaises(ValueError, copy.replace, base, microsecond=1000000)
 
     def test_mixed_compare(self):
         t1 = self.theclass(1, 2, 3)
@@ -4331,6 +4489,9 @@ def test_fromisoformat_fails(self):
             '12:30:45.123456-',         # Extra at end of microsecond time
             '12:30:45.123456+',         # Extra at end of microsecond time
             '12:30:45.123456+12:00:30a',    # Extra at end of full time
+            '12:30:45.400 +02:30',      # Space between ms and timezone (gh-130959)
+            '12:30:45.400 ',            # Trailing space (gh-130959)
+            '12:30:45. 400',            # Space before fraction (gh-130959)
         ]
 
         for bad_str in bad_strs:
@@ -4491,8 +4652,7 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n'
@@ -4897,38 +5057,45 @@ def test_replace(self):
         zm200 = FixedOffset(timedelta(minutes=-200), "-200")
         args = [1, 2, 3, 4, 5, 6, 7, z100]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4),
-                             ("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8),
-                             ("tzinfo", zm200)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4),
+                   ("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8),
+                   ("tzinfo", zm200))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Ensure we can get rid of a tzinfo.
         self.assertEqual(base.tzname(), "+100")
         base2 = base.replace(tzinfo=None)
         self.assertIsNone(base2.tzinfo)
         self.assertIsNone(base2.tzname())
+        base22 = copy.replace(base, tzinfo=None)
+        self.assertIsNone(base22.tzinfo)
+        self.assertIsNone(base22.tzname())
 
         # Ensure we can add one.
         base3 = base2.replace(tzinfo=z100)
         self.assertEqual(base, base3)
         self.assertIs(base.tzinfo, base3.tzinfo)
+        base32 = copy.replace(base22, tzinfo=z100)
+        self.assertEqual(base, base32)
+        self.assertIs(base.tzinfo, base32.tzinfo)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     def test_more_astimezone(self):
         # The inherited test_astimezone covered some trivial and error cases.
@@ -5418,42 +5585,50 @@ def fromutc(self, dt):
 
 class Oddballs(unittest.TestCase):
 
-    def test_bug_1028306(self):
+    def test_date_datetime_comparison(self):
+        # bpo-1028306, bpo-5516 (gh-49766)
         # Trying to compare a date to a datetime should act like a mixed-
         # type comparison, despite that datetime is a subclass of date.
         as_date = date.today()
         as_datetime = datetime.combine(as_date, time())
-        self.assertTrue(as_date != as_datetime)
-        self.assertTrue(as_datetime != as_date)
-        self.assertFalse(as_date == as_datetime)
-        self.assertFalse(as_datetime == as_date)
-        self.assertRaises(TypeError, lambda: as_date < as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime < as_date)
-        self.assertRaises(TypeError, lambda: as_date <= as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime <= as_date)
-        self.assertRaises(TypeError, lambda: as_date > as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime > as_date)
-        self.assertRaises(TypeError, lambda: as_date >= as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime >= as_date)
-
-        # Nevertheless, comparison should work with the base-class (date)
-        # projection if use of a date method is forced.
-        self.assertEqual(as_date.__eq__(as_datetime), True)
-        different_day = (as_date.day + 1) % 20 + 1
-        as_different = as_datetime.replace(day= different_day)
-        self.assertEqual(as_date.__eq__(as_different), False)
+        date_sc = SubclassDate(as_date.year, as_date.month, as_date.day)
+        datetime_sc = SubclassDatetime(as_date.year, as_date.month,
+                                       as_date.day, 0, 0, 0)
+        for d in (as_date, date_sc):
+            for dt in (as_datetime, datetime_sc):
+                for x, y in (d, dt), (dt, d):
+                    self.assertTrue(x != y)
+                    self.assertFalse(x == y)
+                    self.assertRaises(TypeError, lambda: x < y)
+                    self.assertRaises(TypeError, lambda: x <= y)
+                    self.assertRaises(TypeError, lambda: x > y)
+                    self.assertRaises(TypeError, lambda: x >= y)
 
         # And date should compare with other subclasses of date.  If a
         # subclass wants to stop this, it's up to the subclass to do so.
-        date_sc = SubclassDate(as_date.year, as_date.month, as_date.day)
-        self.assertEqual(as_date, date_sc)
-        self.assertEqual(date_sc, as_date)
-
         # Ditto for datetimes.
-        datetime_sc = SubclassDatetime(as_datetime.year, as_datetime.month,
-                                       as_date.day, 0, 0, 0)
-        self.assertEqual(as_datetime, datetime_sc)
-        self.assertEqual(datetime_sc, as_datetime)
+        for x, y in ((as_date, date_sc),
+                     (date_sc, as_date),
+                     (as_datetime, datetime_sc),
+                     (datetime_sc, as_datetime)):
+            self.assertTrue(x == y)
+            self.assertFalse(x != y)
+            self.assertFalse(x < y)
+            self.assertFalse(x > y)
+            self.assertTrue(x <= y)
+            self.assertTrue(x >= y)
+
+        # Nevertheless, comparison should work if other object is an instance
+        # of date or datetime class with overridden comparison operators.
+        # So special methods should return NotImplemented, as if
+        # date and datetime were independent classes.
+        for x, y in (as_date, as_datetime), (as_datetime, as_date):
+            self.assertEqual(x.__eq__(y), NotImplemented)
+            self.assertEqual(x.__ne__(y), NotImplemented)
+            self.assertEqual(x.__lt__(y), NotImplemented)
+            self.assertEqual(x.__gt__(y), NotImplemented)
+            self.assertEqual(x.__gt__(y), NotImplemented)
+            self.assertEqual(x.__ge__(y), NotImplemented)
 
     def test_extra_attributes(self):
         with self.assertWarns(DeprecationWarning):
@@ -6679,6 +6854,126 @@ def test_datetime_from_timestamp(self):
 
                     self.assertEqual(dt_orig, dt_rt)
 
+    def test_type_check_in_subinterp(self):
+        # iOS requires the use of the custom framework loader,
+        # not the ExtensionFileLoader.
+        if sys.platform == "ios":
+            extension_loader = "AppleFrameworkLoader"
+        else:
+            extension_loader = "ExtensionFileLoader"
+
+        script = textwrap.dedent(f"""
+            if {_interpreters is None}:
+                import _testcapi as module
+                module.test_datetime_capi()
+            else:
+                import importlib.machinery
+                import importlib.util
+                fullname = '_testcapi_datetime'
+                origin = importlib.util.find_spec('_testcapi').origin
+                loader = importlib.machinery.{extension_loader}(fullname, origin)
+                spec = importlib.util.spec_from_loader(fullname, loader)
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+
+            def run(type_checker, obj):
+                if not type_checker(obj, True):
+                    raise TypeError(f'{{type(obj)}} is not C API type')
+
+            import _datetime
+            run(module.datetime_check_date,     _datetime.date.today())
+            run(module.datetime_check_datetime, _datetime.datetime.now())
+            run(module.datetime_check_time,     _datetime.time(12, 30))
+            run(module.datetime_check_delta,    _datetime.timedelta(1))
+            run(module.datetime_check_tzinfo,   _datetime.tzinfo())
+        """)
+        if _interpreters is None:
+            ret = support.run_in_subinterp(script)
+            self.assertEqual(ret, 0)
+        else:
+            for name in ('isolated', 'legacy'):
+                with self.subTest(name):
+                    config = _interpreters.new_config(name).__dict__
+                    ret = support.run_in_subinterp_with_config(script, **config)
+                    self.assertEqual(ret, 0)
+
+
+class ExtensionModuleTests(unittest.TestCase):
+
+    def setUp(self):
+        if self.__class__.__name__.endswith('Pure'):
+            self.skipTest('Not relevant in pure Python')
+
+    @support.cpython_only
+    def test_gh_120161(self):
+        with self.subTest('simple'):
+            script = textwrap.dedent("""
+                import datetime
+                from _ast import Tuple
+                f = lambda: None
+                Tuple.dims = property(f, f)
+
+                class tzutc(datetime.tzinfo):
+                    pass
+                """)
+            script_helper.assert_python_ok('-c', script)
+
+        with self.subTest('complex'):
+            script = textwrap.dedent("""
+                import asyncio
+                import datetime
+                from typing import Type
+
+                class tzutc(datetime.tzinfo):
+                    pass
+                _EPOCHTZ = datetime.datetime(1970, 1, 1, tzinfo=tzutc())
+
+                class FakeDateMeta(type):
+                    def __instancecheck__(self, obj):
+                        return True
+                class FakeDate(datetime.date, metaclass=FakeDateMeta):
+                    pass
+                def pickle_fake_date(datetime_) -> Type[FakeDate]:
+                    # A pickle function for FakeDate
+                    return FakeDate
+                """)
+            script_helper.assert_python_ok('-c', script)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: Process return code is 1
+    @unittest.expectedFailure
+    def test_update_type_cache(self):
+        # gh-120782
+        script = textwrap.dedent("""
+            import sys
+            for i in range(5):
+                import _datetime
+                assert _datetime.date.max > _datetime.date.min
+                assert _datetime.time.max > _datetime.time.min
+                assert _datetime.datetime.max > _datetime.datetime.min
+                assert _datetime.timedelta.max > _datetime.timedelta.min
+                assert _datetime.date.__dict__["min"] is _datetime.date.min
+                assert _datetime.date.__dict__["max"] is _datetime.date.max
+                assert _datetime.date.__dict__["resolution"] is _datetime.date.resolution
+                assert _datetime.time.__dict__["min"] is _datetime.time.min
+                assert _datetime.time.__dict__["max"] is _datetime.time.max
+                assert _datetime.time.__dict__["resolution"] is _datetime.time.resolution
+                assert _datetime.datetime.__dict__["min"] is _datetime.datetime.min
+                assert _datetime.datetime.__dict__["max"] is _datetime.datetime.max
+                assert _datetime.datetime.__dict__["resolution"] is _datetime.datetime.resolution
+                assert _datetime.timedelta.__dict__["min"] is _datetime.timedelta.min
+                assert _datetime.timedelta.__dict__["max"] is _datetime.timedelta.max
+                assert _datetime.timedelta.__dict__["resolution"] is _datetime.timedelta.resolution
+                assert _datetime.timezone.__dict__["min"] is _datetime.timezone.min
+                assert _datetime.timezone.__dict__["max"] is _datetime.timezone.max
+                assert _datetime.timezone.__dict__["utc"] is _datetime.timezone.utc
+                assert isinstance(_datetime.timezone.min, _datetime.tzinfo)
+                assert isinstance(_datetime.timezone.max, _datetime.tzinfo)
+                assert isinstance(_datetime.timezone.utc, _datetime.tzinfo)
+                del sys.modules['_datetime']
+            """)
+        script_helper.assert_python_ok('-c', script)
+
 
 def load_tests(loader, standard_tests, pattern):
     standard_tests.addTest(ZoneInfoCompleteTest())
diff --git a/Lib/test/test_code_module.py b/Lib/test/test_code_module.py
index 346cf6746a7..4d5463e6db3 100644
--- a/Lib/test/test_code_module.py
+++ b/Lib/test/test_code_module.py
@@ -64,6 +64,7 @@ def test_console_stderr(self):
             raise AssertionError("no console stdout")
 
     # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[27 chars]    x = ?', '        ^', 'SyntaxError: got unexpected token ?'] != ['  F[27 chars]    x = ?', '        ^', 'SyntaxError: invalid syntax']
     @unittest.expectedFailure
     def test_syntax_error(self):
         self.infunc.side_effect = ["def f():",
@@ -86,6 +87,7 @@ def test_syntax_error(self):
         self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
     # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[15 chars], line 1', '    1', 'IndentationError: unexpected indentation'] != ['  F[15 chars], line 1', '    1', 'IndentationError: unexpected indent']
     @unittest.expectedFailure
     def test_indentation_error(self):
         self.infunc.side_effect = ["  1", EOFError('Finished')]
@@ -104,6 +106,7 @@ def test_indentation_error(self):
         self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
     # TODO: RUSTPYTHON
+    # AssertionError: False is not true : UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 1
     @unittest.expectedFailure
     def test_unicode_error(self):
         self.infunc.side_effect = ["'\ud800'", EOFError('Finished')]
@@ -142,6 +145,7 @@ def test_sysexcepthook(self):
             'ValueError: BOOM!\n'])
 
     # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[35 chars]= ?\n', '        ^\n', 'SyntaxError: got unexpected token ?\n'] != ['  F[35 chars]= ?\n', '        ^\n', 'SyntaxError: invalid syntax\n']
     @unittest.expectedFailure
     def test_sysexcepthook_syntax_error(self):
         self.infunc.side_effect = ["def f():",
@@ -167,6 +171,7 @@ def test_sysexcepthook_syntax_error(self):
             'SyntaxError: invalid syntax\n'])
 
     # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[21 chars] 1\n', '    1\n', 'IndentationError: unexpected indentation\n'] != ['  F[21 chars] 1\n', '    1\n', 'IndentationError: unexpected indent\n']
     @unittest.expectedFailure
     def test_sysexcepthook_indentation_error(self):
         self.infunc.side_effect = ["  1", EOFError('Finished')]
@@ -262,8 +267,7 @@ def test_exit_msg(self):
         self.assertEqual(err_msg, ['write', (expected,), {}])
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cause_tb(self):
         self.infunc.side_effect = ["raise ValueError('') from AttributeError",
                                     EOFError('Finished')]

From cd012f9b2e5bea893d7ba483fe34c5189ef2fd17 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Tue, 30 Dec 2025 19:43:10 -0500
Subject: [PATCH 129/418] Added doctest tests (#6598)

---
 Lib/test/test_doctest/__init__.py             |    5 +
 Lib/test/test_doctest/decorator_mod.py        |   10 +
 Lib/test/test_doctest/doctest_aliases.py      |   13 +
 Lib/test/test_doctest/doctest_lineno.py       |  107 +
 Lib/test/test_doctest/sample_doctest.py       |   76 +
 .../test_doctest/sample_doctest_errors.py     |   46 +
 .../sample_doctest_no_docstrings.py           |   12 +
 .../sample_doctest_no_doctests.py             |   15 +
 Lib/test/test_doctest/sample_doctest_skip.py  |   49 +
 Lib/test/test_doctest/test_doctest.py         | 4021 +++++++++++++++++
 Lib/test/test_doctest/test_doctest.txt        |   17 +
 Lib/test/test_doctest/test_doctest2.py        |  126 +
 Lib/test/test_doctest/test_doctest2.txt       |   14 +
 Lib/test/test_doctest/test_doctest3.txt       |    5 +
 Lib/test/test_doctest/test_doctest4.txt       |   11 +
 Lib/test/test_doctest/test_doctest_errors.txt |   14 +
 Lib/test/test_doctest/test_doctest_skip.txt   |    6 +
 Lib/test/test_doctest/test_doctest_skip2.txt  |    6 +
 crates/vm/src/builtins/int.rs                 |    2 +-
 19 files changed, 4554 insertions(+), 1 deletion(-)
 create mode 100644 Lib/test/test_doctest/__init__.py
 create mode 100644 Lib/test/test_doctest/decorator_mod.py
 create mode 100644 Lib/test/test_doctest/doctest_aliases.py
 create mode 100644 Lib/test/test_doctest/doctest_lineno.py
 create mode 100644 Lib/test/test_doctest/sample_doctest.py
 create mode 100644 Lib/test/test_doctest/sample_doctest_errors.py
 create mode 100644 Lib/test/test_doctest/sample_doctest_no_docstrings.py
 create mode 100644 Lib/test/test_doctest/sample_doctest_no_doctests.py
 create mode 100644 Lib/test/test_doctest/sample_doctest_skip.py
 create mode 100644 Lib/test/test_doctest/test_doctest.py
 create mode 100644 Lib/test/test_doctest/test_doctest.txt
 create mode 100644 Lib/test/test_doctest/test_doctest2.py
 create mode 100644 Lib/test/test_doctest/test_doctest2.txt
 create mode 100644 Lib/test/test_doctest/test_doctest3.txt
 create mode 100644 Lib/test/test_doctest/test_doctest4.txt
 create mode 100644 Lib/test/test_doctest/test_doctest_errors.txt
 create mode 100644 Lib/test/test_doctest/test_doctest_skip.txt
 create mode 100644 Lib/test/test_doctest/test_doctest_skip2.txt

diff --git a/Lib/test/test_doctest/__init__.py b/Lib/test/test_doctest/__init__.py
new file mode 100644
index 00000000000..4b16ecc3115
--- /dev/null
+++ b/Lib/test/test_doctest/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_doctest/decorator_mod.py b/Lib/test/test_doctest/decorator_mod.py
new file mode 100644
index 00000000000..9f106888411
--- /dev/null
+++ b/Lib/test/test_doctest/decorator_mod.py
@@ -0,0 +1,10 @@
+# This module is used in `doctest_lineno.py`.
+import functools
+
+
+def decorator(f):
+    @functools.wraps(f)
+    def inner():
+        return f()
+
+    return inner
diff --git a/Lib/test/test_doctest/doctest_aliases.py b/Lib/test/test_doctest/doctest_aliases.py
new file mode 100644
index 00000000000..30cefafa83e
--- /dev/null
+++ b/Lib/test/test_doctest/doctest_aliases.py
@@ -0,0 +1,13 @@
+# Used by test_doctest.py.
+
+class TwoNames:
+    '''f() and g() are two names for the same method'''
+
+    def f(self):
+        '''
+        >>> print(TwoNames().f())
+        f
+        '''
+        return 'f'
+
+    g = f # define an alias for f
diff --git a/Lib/test/test_doctest/doctest_lineno.py b/Lib/test/test_doctest/doctest_lineno.py
new file mode 100644
index 00000000000..0bd402e9828
--- /dev/null
+++ b/Lib/test/test_doctest/doctest_lineno.py
@@ -0,0 +1,107 @@
+# This module is used in `test_doctest`.
+# It must not have a docstring.
+
+def func_with_docstring():
+    """Some unrelated info."""
+
+
+def func_without_docstring():
+    pass
+
+
+def func_with_doctest():
+    """
+    This function really contains a test case.
+
+    >>> func_with_doctest.__name__
+    'func_with_doctest'
+    """
+    return 3
+
+
+class ClassWithDocstring:
+    """Some unrelated class information."""
+
+
+class ClassWithoutDocstring:
+    pass
+
+
+class ClassWithDoctest:
+    """This class really has a test case in it.
+
+    >>> ClassWithDoctest.__name__
+    'ClassWithDoctest'
+    """
+
+
+class MethodWrapper:
+    def method_with_docstring(self):
+        """Method with a docstring."""
+
+    def method_without_docstring(self):
+        pass
+
+    def method_with_doctest(self):
+        """
+        This has a doctest!
+        >>> MethodWrapper.method_with_doctest.__name__
+        'method_with_doctest'
+        """
+
+    @classmethod
+    def classmethod_with_doctest(cls):
+        """
+        This has a doctest!
+        >>> MethodWrapper.classmethod_with_doctest.__name__
+        'classmethod_with_doctest'
+        """
+
+    @property
+    def property_with_doctest(self):
+        """
+        This has a doctest!
+        >>> MethodWrapper.property_with_doctest.__name__
+        'property_with_doctest'
+        """
+
+# https://github.com/python/cpython/issues/99433
+str_wrapper = object().__str__
+
+
+# https://github.com/python/cpython/issues/115392
+from test.test_doctest.decorator_mod import decorator
+
+@decorator
+@decorator
+def func_with_docstring_wrapped():
+    """Some unrelated info."""
+
+
+# https://github.com/python/cpython/issues/136914
+import functools
+
+
+@functools.cache
+def cached_func_with_doctest(value):
+    """
+    >>> cached_func_with_doctest(1)
+    -1
+    """
+    return -value
+
+
+@functools.cache
+def cached_func_without_docstring(value):
+    return value + 1
+
+
+class ClassWithACachedProperty:
+
+    @functools.cached_property
+    def cached(self):
+        """
+        >>> X().cached
+        -1
+        """
+        return 0
diff --git a/Lib/test/test_doctest/sample_doctest.py b/Lib/test/test_doctest/sample_doctest.py
new file mode 100644
index 00000000000..049f737a0a4
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest.py
@@ -0,0 +1,76 @@
+"""This is a sample module that doesn't really test anything all that
+   interesting.
+
+It simply has a few tests, some of which succeed and some of which fail.
+
+It's important that the numbers remain constant as another test is
+testing the running of these tests.
+
+
+>>> 2+2
+4
+"""
+
+
+def foo():
+    """
+
+    >>> 2+2
+    5
+
+    >>> 2+2
+    4
+    """
+
+def bar():
+    """
+
+    >>> 2+2
+    4
+    """
+
+def test_silly_setup():
+    """
+
+    >>> import test.test_doctest.test_doctest
+    >>> test.test_doctest.test_doctest.sillySetup
+    True
+    """
+
+def w_blank():
+    """
+    >>> if 1:
+    ...    print('a')
+    ...    print()
+    ...    print('b')
+    a
+    <BLANKLINE>
+    b
+    """
+
+x = 1
+def x_is_one():
+    """
+    >>> x
+    1
+    """
+
+def y_is_one():
+    """
+    >>> y
+    1
+    """
+
+__test__ = {'good': """
+                    >>> 42
+                    42
+                    """,
+            'bad':  """
+                    >>> 42
+                    666
+                    """,
+           }
+
+def test_suite():
+    import doctest
+    return doctest.DocTestSuite()
diff --git a/Lib/test/test_doctest/sample_doctest_errors.py b/Lib/test/test_doctest/sample_doctest_errors.py
new file mode 100644
index 00000000000..4a6f07af2d4
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_errors.py
@@ -0,0 +1,46 @@
+"""This is a sample module used for testing doctest.
+
+This module includes various scenarios involving errors.
+
+>>> 2 + 2
+5
+>>> 1/0
+1
+"""
+
+def g():
+    [][0] # line 12
+
+def errors():
+    """
+    >>> 2 + 2
+    5
+    >>> 1/0
+    1
+    >>> def f():
+    ...     2 + '2'
+    ...
+    >>> f()
+    1
+    >>> g()
+    1
+    """
+
+def syntax_error():
+    """
+    >>> 2+*3
+    5
+    """
+
+__test__ = {
+    'bad':  """
+        >>> 2 + 2
+        5
+        >>> 1/0
+        1
+        """,
+}
+
+def test_suite():
+    import doctest
+    return doctest.DocTestSuite()
diff --git a/Lib/test/test_doctest/sample_doctest_no_docstrings.py b/Lib/test/test_doctest/sample_doctest_no_docstrings.py
new file mode 100644
index 00000000000..e4201edbce9
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_no_docstrings.py
@@ -0,0 +1,12 @@
+# This is a sample module used for testing doctest.
+#
+# This module is for testing how doctest handles a module with no
+# docstrings.
+
+
+class Foo(object):
+
+    # A class with no docstring.
+
+    def __init__(self):
+        pass
diff --git a/Lib/test/test_doctest/sample_doctest_no_doctests.py b/Lib/test/test_doctest/sample_doctest_no_doctests.py
new file mode 100644
index 00000000000..7daa57231c8
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_no_doctests.py
@@ -0,0 +1,15 @@
+"""This is a sample module used for testing doctest.
+
+This module is for testing how doctest handles a module with docstrings
+but no doctest examples.
+
+"""
+
+
+class Foo(object):
+    """A docstring with no doctest examples.
+
+    """
+
+    def __init__(self):
+        pass
diff --git a/Lib/test/test_doctest/sample_doctest_skip.py b/Lib/test/test_doctest/sample_doctest_skip.py
new file mode 100644
index 00000000000..1b83dec1f8c
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_skip.py
@@ -0,0 +1,49 @@
+"""This is a sample module used for testing doctest.
+
+This module includes various scenarios involving skips.
+"""
+
+def no_skip_pass():
+    """
+    >>> 2 + 2
+    4
+    """
+
+def no_skip_fail():
+    """
+    >>> 2 + 2
+    5
+    """
+
+def single_skip():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    """
+
+def double_skip():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 3 + 3  # doctest: +SKIP
+    6
+    """
+
+def partial_skip_pass():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 3 + 3
+    6
+    """
+
+def partial_skip_fail():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 2 + 2
+    5
+    """
+
+def no_examples():
+    """A docstring with no examples should not be counted as run or skipped."""
diff --git a/Lib/test/test_doctest/test_doctest.py b/Lib/test/test_doctest/test_doctest.py
new file mode 100644
index 00000000000..48d5ff6f73f
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest.py
@@ -0,0 +1,4021 @@
+"""
+Test script for doctest.
+"""
+
+from test import support
+from test.support import import_helper
+from test.support.pty_helper import FakeInput  # used in doctests
+import doctest
+import functools
+import os
+import sys
+import importlib
+import importlib.abc
+import importlib.util
+import unittest
+import tempfile
+import types
+import contextlib
+import _colorize
+
+
+def doctest_skip_if(condition):
+    def decorator(func):
+        if condition and support.HAVE_DOCSTRINGS:
+            func.__doc__ = ">>> pass  # doctest: +SKIP"
+        return func
+    return decorator
+
+
+# NOTE: There are some additional tests relating to interaction with
+#       zipimport in the test_zipimport_support test module.
+# There are also related tests in `test_doctest2` module.
+
+######################################################################
+## Sample Objects (used by test cases)
+######################################################################
+
+def sample_func(v):
+    """
+    Blah blah
+
+    >>> print(sample_func(22))
+    44
+
+    Yee ha!
+    """
+    return v+v
+
+class SampleClass:
+    """
+    >>> print(1)
+    1
+
+    >>> # comments get ignored.  so are empty PS1 and PS2 prompts:
+    >>>
+    ...
+
+    Multiline example:
+    >>> sc = SampleClass(3)
+    >>> for i in range(10):
+    ...     sc = sc.double()
+    ...     print(' ', sc.get(), sep='', end='')
+     6 12 24 48 96 192 384 768 1536 3072
+    """
+    def __init__(self, val):
+        """
+        >>> print(SampleClass(12).get())
+        12
+        """
+        self.val = val
+
+    def double(self):
+        """
+        >>> print(SampleClass(12).double().get())
+        24
+        """
+        return SampleClass(self.val + self.val)
+
+    def get(self):
+        """
+        >>> print(SampleClass(-5).get())
+        -5
+        """
+        return self.val
+
+    def setter(self, val):
+        """
+        >>> s = SampleClass(-5)
+        >>> s.setter(1)
+        >>> print(s.val)
+        1
+        """
+        self.val = val
+
+    def a_staticmethod(v):
+        """
+        >>> print(SampleClass.a_staticmethod(10))
+        11
+        """
+        return v+1
+    a_staticmethod = staticmethod(a_staticmethod)
+
+    def a_classmethod(cls, v):
+        """
+        >>> print(SampleClass.a_classmethod(10))
+        12
+        >>> print(SampleClass(0).a_classmethod(10))
+        12
+        """
+        return v+2
+    a_classmethod = classmethod(a_classmethod)
+
+    a_property = property(get, setter, doc="""
+        >>> print(SampleClass(22).a_property)
+        22
+        """)
+
+    a_class_attribute = 42
+
+    @functools.cached_property
+    def a_cached_property(self):
+        """
+        >>> print(SampleClass(29).get())
+        29
+        """
+        return "hello"
+
+    class NestedClass:
+        """
+        >>> x = SampleClass.NestedClass(5)
+        >>> y = x.square()
+        >>> print(y.get())
+        25
+        """
+        def __init__(self, val=0):
+            """
+            >>> print(SampleClass.NestedClass().get())
+            0
+            """
+            self.val = val
+        def square(self):
+            return SampleClass.NestedClass(self.val*self.val)
+        def get(self):
+            return self.val
+
+class SampleNewStyleClass(object):
+    r"""
+    >>> print('1\n2\n3')
+    1
+    2
+    3
+    """
+    def __init__(self, val):
+        """
+        >>> print(SampleNewStyleClass(12).get())
+        12
+        """
+        self.val = val
+
+    def double(self):
+        """
+        >>> print(SampleNewStyleClass(12).double().get())
+        24
+        """
+        return SampleNewStyleClass(self.val + self.val)
+
+    def get(self):
+        """
+        >>> print(SampleNewStyleClass(-5).get())
+        -5
+        """
+        return self.val
+
+######################################################################
+## Test Cases
+######################################################################
+
+def test_Example(): r"""
+Unit tests for the `Example` class.
+
+Example is a simple container class that holds:
+  - `source`: A source string.
+  - `want`: An expected output string.
+  - `exc_msg`: An expected exception message string (or None if no
+    exception is expected).
+  - `lineno`: A line number (within the docstring).
+  - `indent`: The example's indentation in the input string.
+  - `options`: An option dictionary, mapping option flags to True or
+    False.
+
+These attributes are set by the constructor.  `source` and `want` are
+required; the other attributes all have default values:
+
+    >>> example = doctest.Example('print(1)', '1\n')
+    >>> (example.source, example.want, example.exc_msg,
+    ...  example.lineno, example.indent, example.options)
+    ('print(1)\n', '1\n', None, 0, 0, {})
+
+The first three attributes (`source`, `want`, and `exc_msg`) may be
+specified positionally; the remaining arguments should be specified as
+keyword arguments:
+
+    >>> exc_msg = 'IndexError: pop from an empty list'
+    >>> example = doctest.Example('[].pop()', '', exc_msg,
+    ...                           lineno=5, indent=4,
+    ...                           options={doctest.ELLIPSIS: True})
+    >>> (example.source, example.want, example.exc_msg,
+    ...  example.lineno, example.indent, example.options)
+    ('[].pop()\n', '', 'IndexError: pop from an empty list\n', 5, 4, {8: True})
+
+The constructor normalizes the `source` string to end in a newline:
+
+    Source spans a single line: no terminating newline.
+    >>> e = doctest.Example('print(1)', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print(1)\n', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    Source spans multiple lines: require terminating newline.
+    >>> e = doctest.Example('print(1);\nprint(2)\n', '1\n2\n')
+    >>> e.source, e.want
+    ('print(1);\nprint(2)\n', '1\n2\n')
+
+    >>> e = doctest.Example('print(1);\nprint(2)', '1\n2\n')
+    >>> e.source, e.want
+    ('print(1);\nprint(2)\n', '1\n2\n')
+
+    Empty source string (which should never appear in real examples)
+    >>> e = doctest.Example('', '')
+    >>> e.source, e.want
+    ('\n', '')
+
+The constructor normalizes the `want` string to end in a newline,
+unless it's the empty string:
+
+    >>> e = doctest.Example('print(1)', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print(1)', '1')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print', '')
+    >>> e.source, e.want
+    ('print\n', '')
+
+The constructor normalizes the `exc_msg` string to end in a newline,
+unless it's `None`:
+
+    Message spans one line
+    >>> exc_msg = 'IndexError: pop from an empty list'
+    >>> e = doctest.Example('[].pop()', '', exc_msg)
+    >>> e.exc_msg
+    'IndexError: pop from an empty list\n'
+
+    >>> exc_msg = 'IndexError: pop from an empty list\n'
+    >>> e = doctest.Example('[].pop()', '', exc_msg)
+    >>> e.exc_msg
+    'IndexError: pop from an empty list\n'
+
+    Message spans multiple lines
+    >>> exc_msg = 'ValueError: 1\n  2'
+    >>> e = doctest.Example('raise ValueError("1\n  2")', '', exc_msg)
+    >>> e.exc_msg
+    'ValueError: 1\n  2\n'
+
+    >>> exc_msg = 'ValueError: 1\n  2\n'
+    >>> e = doctest.Example('raise ValueError("1\n  2")', '', exc_msg)
+    >>> e.exc_msg
+    'ValueError: 1\n  2\n'
+
+    Empty (but non-None) exception message (which should never appear
+    in real examples)
+    >>> exc_msg = ''
+    >>> e = doctest.Example('raise X()', '', exc_msg)
+    >>> e.exc_msg
+    '\n'
+
+Compare `Example`:
+    >>> example = doctest.Example('print 1', '1\n')
+    >>> same_example = doctest.Example('print 1', '1\n')
+    >>> other_example = doctest.Example('print 42', '42\n')
+    >>> example == same_example
+    True
+    >>> example != same_example
+    False
+    >>> hash(example) == hash(same_example)
+    True
+    >>> example == other_example
+    False
+    >>> example != other_example
+    True
+"""
+
+def test_DocTest(): r"""
+Unit tests for the `DocTest` class.
+
+DocTest is a collection of examples, extracted from a docstring, along
+with information about where the docstring comes from (a name,
+filename, and line number).  The docstring is parsed by the `DocTest`
+constructor:
+
+    >>> docstring = '''
+    ...     >>> print(12)
+    ...     12
+    ...
+    ... Non-example text.
+    ...
+    ...     >>> print('another\\example')
+    ...     another
+    ...     example
+    ... '''
+    >>> globs = {} # globals to run the test in.
+    >>> parser = doctest.DocTestParser()
+    >>> test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                           'some_file', 20)
+    >>> print(test)
+    <DocTest some_test from some_file:20 (2 examples)>
+    >>> len(test.examples)
+    2
+    >>> e1, e2 = test.examples
+    >>> (e1.source, e1.want, e1.lineno)
+    ('print(12)\n', '12\n', 1)
+    >>> (e2.source, e2.want, e2.lineno)
+    ("print('another\\example')\n", 'another\nexample\n', 6)
+
+Source information (name, filename, and line number) is available as
+attributes on the doctest object:
+
+    >>> (test.name, test.filename, test.lineno)
+    ('some_test', 'some_file', 20)
+
+The line number of an example within its containing file is found by
+adding the line number of the example and the line number of its
+containing test:
+
+    >>> test.lineno + e1.lineno
+    21
+    >>> test.lineno + e2.lineno
+    26
+
+If the docstring contains inconsistent leading whitespace in the
+expected output of an example, then `DocTest` will raise a ValueError:
+
+    >>> docstring = r'''
+    ...       >>> print('bad\nindentation')
+    ...       bad
+    ...     indentation
+    ...     '''
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 4 of the docstring for some_test has inconsistent leading whitespace: 'indentation'
+
+If the docstring contains inconsistent leading whitespace on
+continuation lines, then `DocTest` will raise a ValueError:
+
+    >>> docstring = r'''
+    ...       >>> print(('bad indentation',
+    ...     ...          2))
+    ...       ('bad', 'indentation')
+    ...     '''
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 2 of the docstring for some_test has inconsistent leading whitespace: '...          2))'
+
+If there's no blank space after a PS1 prompt ('>>>'), then `DocTest`
+will raise a ValueError:
+
+    >>> docstring = '>>>print(1)\n1'
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the docstring for some_test lacks blank after >>>: '>>>print(1)'
+
+If there's no blank space after a PS2 prompt ('...'), then `DocTest`
+will raise a ValueError:
+
+    >>> docstring = '>>> if 1:\n...print(1)\n1'
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 2 of the docstring for some_test lacks blank after ...: '...print(1)'
+
+Compare `DocTest`:
+
+    >>> docstring = '''
+    ...     >>> print 12
+    ...     12
+    ... '''
+    >>> test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                           'some_test', 20)
+    >>> same_test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                                'some_test', 20)
+    >>> test == same_test
+    True
+    >>> test != same_test
+    False
+    >>> hash(test) == hash(same_test)
+    True
+    >>> docstring = '''
+    ...     >>> print 42
+    ...     42
+    ... '''
+    >>> other_test = parser.get_doctest(docstring, globs, 'other_test',
+    ...                                 'other_file', 10)
+    >>> test == other_test
+    False
+    >>> test != other_test
+    True
+    >>> test < other_test
+    False
+    >>> other_test < test
+    True
+
+Test comparison with lineno None on one side
+
+    >>> no_lineno = parser.get_doctest(docstring, globs, 'some_test',
+    ...                               'some_test', None)
+    >>> test.lineno is None
+    False
+    >>> no_lineno.lineno is None
+    True
+    >>> test < no_lineno
+    False
+    >>> no_lineno < test
+    True
+
+Compare `DocTestCase`:
+
+    >>> DocTestCase = doctest.DocTestCase
+    >>> test_case = DocTestCase(test)
+    >>> same_test_case = DocTestCase(same_test)
+    >>> other_test_case = DocTestCase(other_test)
+    >>> test_case == same_test_case
+    True
+    >>> test_case != same_test_case
+    False
+    >>> hash(test_case) == hash(same_test_case)
+    True
+    >>> test == other_test_case
+    False
+    >>> test != other_test_case
+    True
+
+"""
+
+class test_DocTestFinder:
+    def basics(): r"""
+Unit tests for the `DocTestFinder` class.
+
+DocTestFinder is used to extract DocTests from an object's docstring
+and the docstrings of its contained objects.  It can be used with
+modules, functions, classes, methods, staticmethods, classmethods, and
+properties.
+
+Finding Tests in Functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+For a function whose docstring contains examples, DocTestFinder.find()
+will return a single test (for that function's docstring):
+
+    >>> finder = doctest.DocTestFinder()
+
+We'll simulate a __file__ attr that ends in pyc:
+
+    >>> from test.test_doctest import test_doctest
+    >>> old = test_doctest.__file__
+    >>> test_doctest.__file__ = 'test_doctest.pyc'
+
+    >>> tests = finder.find(sample_func)
+
+    >>> print(tests)  # doctest: +ELLIPSIS
+    [<DocTest sample_func from test_doctest.py:38 (1 example)>]
+
+The exact name depends on how test_doctest was invoked, so allow for
+leading path components.
+
+    >>> tests[0].filename # doctest: +ELLIPSIS
+    '...test_doctest.py'
+
+    >>> test_doctest.__file__ = old
+
+
+    >>> e = tests[0].examples[0]
+    >>> (e.source, e.want, e.lineno)
+    ('print(sample_func(22))\n', '44\n', 3)
+
+By default, tests are created for objects with no docstring:
+
+    >>> def no_docstring(v):
+    ...     pass
+    >>> finder.find(no_docstring)
+    []
+
+However, the optional argument `exclude_empty` to the DocTestFinder
+constructor can be used to exclude tests for objects with empty
+docstrings:
+
+    >>> def no_docstring(v):
+    ...     pass
+    >>> excl_empty_finder = doctest.DocTestFinder(exclude_empty=True)
+    >>> excl_empty_finder.find(no_docstring)
+    []
+
+If the function has a docstring with no examples, then a test with no
+examples is returned.  (This lets `DocTestRunner` collect statistics
+about which functions have no tests -- but is that useful?  And should
+an empty test also be created when there's no docstring?)
+
+    >>> def no_examples(v):
+    ...     ''' no doctest examples '''
+    >>> finder.find(no_examples) # doctest: +ELLIPSIS
+    [<DocTest no_examples from ...:1 (no examples)>]
+
+Finding Tests in Classes
+~~~~~~~~~~~~~~~~~~~~~~~~
+For a class, DocTestFinder will create a test for the class's
+docstring, and will recursively explore its contents, including
+methods, classmethods, staticmethods, properties, and nested classes.
+
+    >>> finder = doctest.DocTestFinder()
+    >>> tests = finder.find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+New-style classes are also supported:
+
+    >>> tests = finder.find(SampleNewStyleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     1  SampleNewStyleClass
+     1  SampleNewStyleClass.__init__
+     1  SampleNewStyleClass.double
+     1  SampleNewStyleClass.get
+
+Finding Tests in Modules
+~~~~~~~~~~~~~~~~~~~~~~~~
+For a module, DocTestFinder will create a test for the class's
+docstring, and will recursively explore its contents, including
+functions, classes, and the `__test__` dictionary, if it exists:
+
+    >>> # A module
+    >>> import types
+    >>> m = types.ModuleType('some_module')
+    >>> def triple(val):
+    ...     '''
+    ...     >>> print(triple(11))
+    ...     33
+    ...     '''
+    ...     return val*3
+    >>> m.__dict__.update({
+    ...     'sample_func': sample_func,
+    ...     'SampleClass': SampleClass,
+    ...     '__doc__': '''
+    ...         Module docstring.
+    ...             >>> print('module')
+    ...             module
+    ...         ''',
+    ...     '__test__': {
+    ...         'd': '>>> print(6)\n6\n>>> print(7)\n7\n',
+    ...         'c': triple}})
+
+    >>> finder = doctest.DocTestFinder()
+    >>> # Use module=test_doctest, to prevent doctest from
+    >>> # ignoring the objects since they weren't defined in m.
+    >>> from test.test_doctest import test_doctest
+    >>> tests = finder.find(m, module=test_doctest)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     1  some_module
+     3  some_module.SampleClass
+     3  some_module.SampleClass.NestedClass
+     1  some_module.SampleClass.NestedClass.__init__
+     1  some_module.SampleClass.__init__
+     1  some_module.SampleClass.a_cached_property
+     2  some_module.SampleClass.a_classmethod
+     1  some_module.SampleClass.a_property
+     1  some_module.SampleClass.a_staticmethod
+     1  some_module.SampleClass.double
+     1  some_module.SampleClass.get
+     3  some_module.SampleClass.setter
+     1  some_module.__test__.c
+     2  some_module.__test__.d
+     1  some_module.sample_func
+
+However, doctest will ignore imported objects from other modules
+(without proper `module=`):
+
+    >>> import types
+    >>> m = types.ModuleType('poluted_namespace')
+    >>> m.__dict__.update({
+    ...     'sample_func': sample_func,
+    ...     'SampleClass': SampleClass,
+    ... })
+
+    >>> finder = doctest.DocTestFinder()
+    >>> finder.find(m)
+    []
+
+Duplicate Removal
+~~~~~~~~~~~~~~~~~
+If a single object is listed twice (under different names), then tests
+will only be generated for it once:
+
+    >>> from test.test_doctest import doctest_aliases
+    >>> assert doctest_aliases.TwoNames.f
+    >>> assert doctest_aliases.TwoNames.g
+    >>> tests = excl_empty_finder.find(doctest_aliases)
+    >>> print(len(tests))
+    2
+    >>> print(tests[0].name)
+    test.test_doctest.doctest_aliases.TwoNames
+
+    TwoNames.f and TwoNames.g are bound to the same object.
+    We can't guess which will be found in doctest's traversal of
+    TwoNames.__dict__ first, so we have to allow for either.
+
+    >>> tests[1].name.split('.')[-1] in ['f', 'g']
+    True
+
+Empty Tests
+~~~~~~~~~~~
+By default, an object with no doctests doesn't create any tests:
+
+    >>> tests = doctest.DocTestFinder().find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+By default, that excluded objects with no doctests.  exclude_empty=False
+tells it to include (empty) tests for objects with no doctests.  This feature
+is really to support backward compatibility in what doctest.master.summarize()
+displays.
+
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     0  SampleClass.NestedClass.get
+     0  SampleClass.NestedClass.square
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+When used with `exclude_empty=False` we are also interested in line numbers
+of doctests that are empty.
+It used to be broken for quite some time until `bpo-28249`.
+
+    >>> from test.test_doctest import doctest_lineno
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(doctest_lineno)
+    >>> for t in tests:
+    ...     print('%5s  %s' % (t.lineno, t.name))
+     None  test.test_doctest.doctest_lineno
+     None  test.test_doctest.doctest_lineno.ClassWithACachedProperty
+      102  test.test_doctest.doctest_lineno.ClassWithACachedProperty.cached
+       22  test.test_doctest.doctest_lineno.ClassWithDocstring
+       30  test.test_doctest.doctest_lineno.ClassWithDoctest
+     None  test.test_doctest.doctest_lineno.ClassWithoutDocstring
+     None  test.test_doctest.doctest_lineno.MethodWrapper
+       53  test.test_doctest.doctest_lineno.MethodWrapper.classmethod_with_doctest
+       39  test.test_doctest.doctest_lineno.MethodWrapper.method_with_docstring
+       45  test.test_doctest.doctest_lineno.MethodWrapper.method_with_doctest
+     None  test.test_doctest.doctest_lineno.MethodWrapper.method_without_docstring
+       61  test.test_doctest.doctest_lineno.MethodWrapper.property_with_doctest
+       86  test.test_doctest.doctest_lineno.cached_func_with_doctest
+     None  test.test_doctest.doctest_lineno.cached_func_without_docstring
+        4  test.test_doctest.doctest_lineno.func_with_docstring
+       77  test.test_doctest.doctest_lineno.func_with_docstring_wrapped
+       12  test.test_doctest.doctest_lineno.func_with_doctest
+     None  test.test_doctest.doctest_lineno.func_without_docstring
+
+Turning off Recursion
+~~~~~~~~~~~~~~~~~~~~~
+DocTestFinder can be told not to look for tests in contained objects
+using the `recurse` flag:
+
+    >>> tests = doctest.DocTestFinder(recurse=False).find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+
+Line numbers
+~~~~~~~~~~~~
+DocTestFinder finds the line number of each example:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...
+    ...     some text
+    ...
+    ...     >>> # examples are not created for comments & bare prompts.
+    ...     >>>
+    ...     ...
+    ...
+    ...     >>> for x in range(10):
+    ...     ...     print(x, end=' ')
+    ...     0 1 2 3 4 5 6 7 8 9
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> [e.lineno for e in test.examples]
+    [1, 9, 12]
+"""
+
+# TODO: RUSTPYTHON
+# Currently, only 5 builtins types exist in RustPython
+# So this test will fail
+#     if int.__doc__: # simple check for --without-doc-strings, skip if lacking
+#         def non_Python_modules(): r"""
+
+# Finding Doctests in Modules Not Written in Python
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# DocTestFinder can also find doctests in most modules not written in Python.
+# We'll use builtins as an example, since it almost certainly isn't written in
+# plain ol' Python and is guaranteed to be available.
+
+#     >>> import builtins
+#     >>> tests = doctest.DocTestFinder().find(builtins)
+#     >>> 830 < len(tests) < 860 # approximate number of objects with docstrings
+#     True
+#     >>> real_tests = [t for t in tests if len(t.examples) > 0]
+#     >>> len(real_tests) # objects that actually have doctests
+#     14
+#     >>> for t in real_tests:
+#     ...     print('{}  {}'.format(len(t.examples), t.name))
+#     ...
+#     1  builtins.bin
+#     5  builtins.bytearray.hex
+#     5  builtins.bytes.hex
+#     3  builtins.float.as_integer_ratio
+#     2  builtins.float.fromhex
+#     2  builtins.float.hex
+#     1  builtins.hex
+#     1  builtins.int
+#     3  builtins.int.as_integer_ratio
+#     2  builtins.int.bit_count
+#     2  builtins.int.bit_length
+#     5  builtins.memoryview.hex
+#     1  builtins.oct
+#     1  builtins.zip
+
+# Note here that 'bin', 'oct', and 'hex' are functions; 'float.as_integer_ratio',
+# 'float.hex', and 'int.bit_length' are methods; 'float.fromhex' is a classmethod,
+# and 'int' is a type.
+# """
+
+
+class TestDocTest(unittest.TestCase):
+
+    def test_run(self):
+        test = '''
+            >>> 1 + 1
+            11
+            >>> 2 + 3      # doctest: +SKIP
+            "23"
+            >>> 5 + 7
+            57
+        '''
+
+        def myfunc():
+            pass
+        myfunc.__doc__ = test
+
+        # test DocTestFinder.run()
+        test = doctest.DocTestFinder().find(myfunc)[0]
+        with support.captured_stdout():
+            with support.captured_stderr():
+                results = doctest.DocTestRunner(verbose=False).run(test)
+
+        # test TestResults
+        self.assertIsInstance(results, doctest.TestResults)
+        self.assertEqual(results.failed, 2)
+        self.assertEqual(results.attempted, 3)
+        self.assertEqual(results.skipped, 1)
+        self.assertEqual(tuple(results), (2, 3))
+        x, y = results
+        self.assertEqual((x, y), (2, 3))
+
+
+class TestDocTestFinder(unittest.TestCase):
+
+    def test_issue35753(self):
+        # This import of `call` should trigger issue35753 when
+        # DocTestFinder.find() is called due to inspect.unwrap() failing,
+        # however with a patched doctest this should succeed.
+        from unittest.mock import call
+        dummy_module = types.ModuleType("dummy")
+        dummy_module.__dict__['inject_call'] = call
+        finder = doctest.DocTestFinder()
+        self.assertEqual(finder.find(dummy_module), [])
+
+    def test_empty_namespace_package(self):
+        pkg_name = 'doctest_empty_pkg'
+        with tempfile.TemporaryDirectory() as parent_dir:
+            pkg_dir = os.path.join(parent_dir, pkg_name)
+            os.mkdir(pkg_dir)
+            sys.path.append(parent_dir)
+            try:
+                mod = importlib.import_module(pkg_name)
+            finally:
+                import_helper.forget(pkg_name)
+                sys.path.pop()
+
+            include_empty_finder = doctest.DocTestFinder(exclude_empty=False)
+            exclude_empty_finder = doctest.DocTestFinder(exclude_empty=True)
+
+            self.assertEqual(len(include_empty_finder.find(mod)), 1)
+            self.assertEqual(len(exclude_empty_finder.find(mod)), 0)
+
+def test_DocTestParser(): r"""
+Unit tests for the `DocTestParser` class.
+
+DocTestParser is used to parse docstrings containing doctest examples.
+
+The `parse` method divides a docstring into examples and intervening
+text:
+
+    >>> s = '''
+    ...     >>> x, y = 2, 3  # no output expected
+    ...     >>> if 1:
+    ...     ...     print(x)
+    ...     ...     print(y)
+    ...     2
+    ...     3
+    ...
+    ...     Some text.
+    ...     >>> x+y
+    ...     5
+    ...     '''
+    >>> parser = doctest.DocTestParser()
+    >>> for piece in parser.parse(s):
+    ...     if isinstance(piece, doctest.Example):
+    ...         print('Example:', (piece.source, piece.want, piece.lineno))
+    ...     else:
+    ...         print('   Text:', repr(piece))
+       Text: '\n'
+    Example: ('x, y = 2, 3  # no output expected\n', '', 1)
+       Text: ''
+    Example: ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+       Text: '\nSome text.\n'
+    Example: ('x+y\n', '5\n', 9)
+       Text: ''
+
+The `get_examples` method returns just the examples:
+
+    >>> for piece in parser.get_examples(s):
+    ...     print((piece.source, piece.want, piece.lineno))
+    ('x, y = 2, 3  # no output expected\n', '', 1)
+    ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+    ('x+y\n', '5\n', 9)
+
+The `get_doctest` method creates a Test from the examples, along with the
+given arguments:
+
+    >>> test = parser.get_doctest(s, {}, 'name', 'filename', lineno=5)
+    >>> (test.name, test.filename, test.lineno)
+    ('name', 'filename', 5)
+    >>> for piece in test.examples:
+    ...     print((piece.source, piece.want, piece.lineno))
+    ('x, y = 2, 3  # no output expected\n', '', 1)
+    ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+    ('x+y\n', '5\n', 9)
+"""
+
+class test_DocTestRunner:
+    def basics(): r"""
+Unit tests for the `DocTestRunner` class.
+
+DocTestRunner is used to run DocTest test cases, and to accumulate
+statistics.  Here's a simple DocTest case we can use:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     12
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+
+The main DocTestRunner interface is the `run` method, which runs a
+given DocTest case in a given namespace (globs).  It returns a tuple
+`(f,t)`, where `f` is the number of failed tests and `t` is the number
+of tried tests.
+
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=3)
+
+If any example produces incorrect output, then the test runner reports
+the failure and proceeds to the next example:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     14
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=True).run(test)
+    ... # doctest: +ELLIPSIS
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        14
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        print(x)
+    Expected:
+        14
+    Got:
+        12
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=1, attempted=3)
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+    def verbose_flag(): r"""
+The `verbose` flag makes the test runner generate more detailed
+output:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     12
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+
+    >>> doctest.DocTestRunner(verbose=True).run(test)
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        12
+    ok
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=0, attempted=3)
+
+If the `verbose` flag is unspecified, then the output will be verbose
+iff `-v` appears in sys.argv:
+
+    >>> # Save the real sys.argv list.
+    >>> old_argv = sys.argv
+
+    >>> # If -v does not appear in sys.argv, then output isn't verbose.
+    >>> sys.argv = ['test']
+    >>> doctest.DocTestRunner().run(test)
+    TestResults(failed=0, attempted=3)
+
+    >>> # If -v does appear in sys.argv, then output is verbose.
+    >>> sys.argv = ['test', '-v']
+    >>> doctest.DocTestRunner().run(test)
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        12
+    ok
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=0, attempted=3)
+
+    >>> # Restore sys.argv
+    >>> sys.argv = old_argv
+
+In the remaining examples, the test runner's verbosity will be
+explicitly set, to ensure that the test behavior is consistent.
+    """
+    def exceptions(): r"""
+Tests of `DocTestRunner`'s exception handling.
+
+An expected exception is specified with a traceback message.  The
+lines between the first line and the type/value may be omitted or
+replaced with any other string:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x//0)
+    ...     Traceback (most recent call last):
+    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+An example may not generate output before it raises an exception; if
+it does, then the traceback message will not be recognized as
+signaling an expected exception, so the example will be reported as an
+unexpected exception:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print('pre-exception output', x//0)
+    ...     pre-exception output
+    ...     Traceback (most recent call last):
+    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        print('pre-exception output', x//0)
+    Exception raised:
+        ...
+        ZeroDivisionError: integer division or modulo by zero
+    TestResults(failed=1, attempted=2)
+
+Exception messages may contain newlines:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('multi\nline\nmessage')
+    ...     Traceback (most recent call last):
+    ...     ValueError: multi
+    ...     line
+    ...     message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+If an exception is expected, but an exception with the wrong type or
+message is raised, then it is reported as a failure:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message')
+    ...     Traceback (most recent call last):
+    ...     ValueError: wrong message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        raise ValueError('message')
+    Expected:
+        Traceback (most recent call last):
+        ValueError: wrong message
+    Got:
+        Traceback (most recent call last):
+        ...
+        ValueError: message
+    TestResults(failed=1, attempted=1)
+
+However, IGNORE_EXCEPTION_DETAIL can be used to allow a mismatch in the
+detail:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     ValueError: wrong message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+IGNORE_EXCEPTION_DETAIL also ignores difference in exception formatting
+between Python versions. For example, in Python 2.x, the module path of
+the exception is not in the output, but this will fail under Python 3:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message')
+    ...     Traceback (most recent call last):
+    ...     HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        raise HTTPException('message')
+    Expected:
+        Traceback (most recent call last):
+        HTTPException: message
+    Got:
+        Traceback (most recent call last):
+        ...
+        http.client.HTTPException: message
+    TestResults(failed=1, attempted=2)
+
+But in Python 3 the module path is included, and therefore a test must look
+like the following test to succeed in Python 3. But that test will fail under
+Python 2.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message')
+    ...     Traceback (most recent call last):
+    ...     http.client.HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+However, with IGNORE_EXCEPTION_DETAIL, the module name of the exception
+(or its unexpected absence) will be ignored:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+The module path will be completely ignored, so two different module paths will
+still pass if IGNORE_EXCEPTION_DETAIL is given. This is intentional, so it can
+be used when exceptions have changed module.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+But IGNORE_EXCEPTION_DETAIL does not allow a mismatch in the exception type:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     TypeError: wrong type
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    Expected:
+        Traceback (most recent call last):
+        TypeError: wrong type
+    Got:
+        Traceback (most recent call last):
+        ...
+        ValueError: message
+    TestResults(failed=1, attempted=1)
+
+If the exception does not have a message, you can still use
+IGNORE_EXCEPTION_DETAIL to normalize the modules between Python 2 and 3:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException() #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+Note that a trailing colon doesn't matter either:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException() #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException:
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+If an exception is raised but not expected, then it is reported as an
+unexpected exception:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> 1//0
+    ...     0
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        1//0
+    Exception raised:
+        Traceback (most recent call last):
+        ...
+        ZeroDivisionError: integer division or modulo by zero
+    TestResults(failed=1, attempted=1)
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+    def displayhook(): r"""
+Test that changing sys.displayhook doesn't matter for doctest.
+
+    >>> import sys
+    >>> orig_displayhook = sys.displayhook
+    >>> def my_displayhook(x):
+    ...     print('hi!')
+    >>> sys.displayhook = my_displayhook
+    >>> def f():
+    ...     '''
+    ...     >>> 3
+    ...     3
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> r = doctest.DocTestRunner(verbose=False).run(test)
+    >>> post_displayhook = sys.displayhook
+
+    We need to restore sys.displayhook now, so that we'll be able to test
+    results.
+
+    >>> sys.displayhook = orig_displayhook
+
+    Ok, now we can check that everything is ok.
+
+    >>> r
+    TestResults(failed=0, attempted=1)
+    >>> post_displayhook is my_displayhook
+    True
+"""
+    def optionflags(): r"""
+Tests of `DocTestRunner`'s option flag handling.
+
+Several option flags can be used to customize the behavior of the test
+runner.  These are defined as module constants in doctest, and passed
+to the DocTestRunner constructor (multiple constants should be ORed
+together).
+
+The DONT_ACCEPT_TRUE_FOR_1 flag disables matches between True/False
+and 1/0:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '>>> True\n1\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.DONT_ACCEPT_TRUE_FOR_1
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        True
+    Expected:
+        1
+    Got:
+        True
+    TestResults(failed=1, attempted=1)
+
+The DONT_ACCEPT_BLANKLINE flag disables the match between blank lines
+and the '<BLANKLINE>' marker:
+
+    >>> def f(x):
+    ...     '>>> print("a\\n\\nb")\na\n<BLANKLINE>\nb\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.DONT_ACCEPT_BLANKLINE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print("a\n\nb")
+    Expected:
+        a
+        <BLANKLINE>
+        b
+    Got:
+        a
+    <BLANKLINE>
+        b
+    TestResults(failed=1, attempted=1)
+
+The NORMALIZE_WHITESPACE flag causes all sequences of whitespace to be
+treated as equal:
+
+    >>> def f(x):
+    ...     '\n>>> print(1, 2, 3)\n  1   2\n 3'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print(1, 2, 3)
+    Expected:
+          1   2
+         3
+    Got:
+        1 2 3
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.NORMALIZE_WHITESPACE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    TestResults(failed=0, attempted=1)
+
+    An example from the docs:
+    >>> print(list(range(20))) #doctest: +NORMALIZE_WHITESPACE
+    [0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
+    10,  11, 12, 13, 14, 15, 16, 17, 18, 19]
+
+The ELLIPSIS flag causes ellipsis marker ("...") in the expected
+output to match any substring in the actual output:
+
+    >>> def f(x):
+    ...     '>>> print(list(range(15)))\n[0, 1, 2, ..., 14]\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(15)))
+    Expected:
+        [0, 1, 2, ..., 14]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.ELLIPSIS
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    TestResults(failed=0, attempted=1)
+
+    ... also matches nothing:
+
+    >>> if 1:
+    ...     for i in range(100):
+    ...         print(i**2, end=' ') #doctest: +ELLIPSIS
+    ...     print('!')
+    0 1...4...9 16 ... 36 49 64 ... 9801 !
+
+    ... can be surprising; e.g., this test passes:
+
+    >>> if 1:  #doctest: +ELLIPSIS
+    ...     for i in range(20):
+    ...         print(i, end=' ')
+    ...     print(20)
+    0 1 2 ...1...2...0
+
+    Examples from the docs:
+
+    >>> print(list(range(20))) # doctest:+ELLIPSIS
+    [0, 1, ..., 18, 19]
+
+    >>> print(list(range(20))) # doctest: +ELLIPSIS
+    ...                 # doctest: +NORMALIZE_WHITESPACE
+    [0,    1, ...,   18,    19]
+
+The SKIP flag causes an example to be skipped entirely.  I.e., the
+example is not run.  It can be useful in contexts where doctest
+examples serve as both documentation and test cases, and an example
+should be included for documentation purposes, but should not be
+checked (e.g., because its output is random, or depends on resources
+which would be unavailable.)  The SKIP flag can also be used for
+'commenting out' broken examples.
+
+    >>> import unavailable_resource           # doctest: +SKIP
+    >>> unavailable_resource.do_something()   # doctest: +SKIP
+    >>> unavailable_resource.blow_up()        # doctest: +SKIP
+    Traceback (most recent call last):
+        ...
+    UncheckedBlowUpError:  Nobody checks me.
+
+    >>> import random
+    >>> print(random.random()) # doctest: +SKIP
+    0.721216923889
+
+The REPORT_UDIFF flag causes failures that involve multi-line expected
+and actual outputs to be displayed using a unified diff:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print('\n'.join('abcdefg'))
+    ...     a
+    ...     B
+    ...     c
+    ...     d
+    ...     f
+    ...     g
+    ...     h
+    ...     '''
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Expected:
+        a
+        B
+        c
+        d
+        f
+        g
+        h
+    Got:
+        a
+        b
+        c
+        d
+        e
+        f
+        g
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_UDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Differences (unified diff with -expected +actual):
+        @@ -1,7 +1,7 @@
+         a
+        -B
+        +b
+         c
+         d
+        +e
+         f
+         g
+        -h
+    TestResults(failed=1, attempted=1)
+
+The REPORT_CDIFF flag causes failures that involve multi-line expected
+and actual outputs to be displayed using a context diff:
+
+    >>> # Reuse f() from the REPORT_UDIFF example, above.
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_CDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Differences (context diff with expected followed by actual):
+        ***************
+        *** 1,7 ****
+          a
+        ! B
+          c
+          d
+          f
+          g
+        - h
+        --- 1,7 ----
+          a
+        ! b
+          c
+          d
+        + e
+          f
+          g
+    TestResults(failed=1, attempted=1)
+
+
+The REPORT_NDIFF flag causes failures to use the difflib.Differ algorithm
+used by the popular ndiff.py utility.  This does intraline difference
+marking, as well as interline differences.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print("a b  c d e f g h i   j k l m")
+    ...     a b c d e f g h i j k 1 m
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_NDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print("a b  c d e f g h i   j k l m")
+    Differences (ndiff with -expected +actual):
+        - a b c d e f g h i j k 1 m
+        ?                       ^
+        + a b  c d e f g h i   j k l m
+        ?     +              ++    ^
+    TestResults(failed=1, attempted=1)
+
+The REPORT_ONLY_FIRST_FAILURE suppresses result output after the first
+failing example:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print(1) # first success
+    ...     1
+    ...     >>> print(2) # first failure
+    ...     200
+    ...     >>> print(3) # second failure
+    ...     300
+    ...     >>> print(4) # second success
+    ...     4
+    ...     >>> print(5) # third failure
+    ...     500
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=3, attempted=5)
+
+However, output from `report_start` is not suppressed:
+
+    >>> doctest.DocTestRunner(verbose=True, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    Trying:
+        print(1) # first success
+    Expecting:
+        1
+    ok
+    Trying:
+        print(2) # first failure
+    Expecting:
+        200
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=3, attempted=5)
+
+The FAIL_FAST flag causes the runner to exit after the first failing example,
+so subsequent examples are not even attempted:
+
+    >>> flags = doctest.FAIL_FAST
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=1, attempted=2)
+
+Specifying both FAIL_FAST and REPORT_ONLY_FIRST_FAILURE is equivalent to
+FAIL_FAST only:
+
+    >>> flags = doctest.FAIL_FAST | doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=1, attempted=2)
+
+For the purposes of both REPORT_ONLY_FIRST_FAILURE and FAIL_FAST, unexpected
+exceptions count as failures:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print(1) # first success
+    ...     1
+    ...     >>> raise ValueError(2) # first failure
+    ...     200
+    ...     >>> print(3) # second failure
+    ...     300
+    ...     >>> print(4) # second success
+    ...     4
+    ...     >>> print(5) # third failure
+    ...     500
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        raise ValueError(2) # first failure
+    Exception raised:
+        ...
+        ValueError: 2
+    TestResults(failed=3, attempted=5)
+    >>> flags = doctest.FAIL_FAST
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        raise ValueError(2) # first failure
+    Exception raised:
+        ...
+        ValueError: 2
+    TestResults(failed=1, attempted=2)
+
+New option flags can also be registered, via register_optionflag().  Here
+we reach into doctest's internals a bit.
+
+    >>> unlikely = "UNLIKELY_OPTION_NAME"
+    >>> unlikely in doctest.OPTIONFLAGS_BY_NAME
+    False
+    >>> new_flag_value = doctest.register_optionflag(unlikely)
+    >>> unlikely in doctest.OPTIONFLAGS_BY_NAME
+    True
+
+Before 2.4.4/2.5, registering a name more than once erroneously created
+more than one flag value.  Here we verify that's fixed:
+
+    >>> redundant_flag_value = doctest.register_optionflag(unlikely)
+    >>> redundant_flag_value == new_flag_value
+    True
+
+Clean up.
+    >>> del doctest.OPTIONFLAGS_BY_NAME[unlikely]
+    >>> _colorize.COLORIZE = save_colorize
+
+    """
+
+    def option_directives(): r"""
+Tests of `DocTestRunner`'s option directive mechanism.
+
+Option directives can be used to turn option flags on or off for a
+single example.  To turn an option on for an example, follow that
+example with a comment of the form ``# doctest: +OPTION``:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+To turn an option off for an example, follow that example with a
+comment of the form ``# doctest: -OPTION``:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> # should fail: no ellipsis
+    ...     >>> print(list(range(10)))      # doctest: -ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False,
+    ...                       optionflags=doctest.ELLIPSIS).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 6, in f
+    Failed example:
+        print(list(range(10)))      # doctest: -ELLIPSIS
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+Option directives affect only the example that they appear with; they
+do not change the options for surrounding examples:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    **********************************************************************
+    File ..., line 8, in f
+    Failed example:
+        print(list(range(10)))      # Should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=2, attempted=3)
+
+Multiple options may be modified by a single option directive.  They
+may be separated by whitespace, commas, or both:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS,+NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+The option directive may be put on the line following the source, as
+long as a continuation prompt is used:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))
+    ...     ... # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+For examples with multi-line source, the option directive may appear
+at the end of any line:
+
+    >>> def f(x): r'''
+    ...     >>> for x in range(10): # doctest: +ELLIPSIS
+    ...     ...     print(' ', x, end='', sep='')
+    ...      0 1 2 ... 9
+    ...
+    ...     >>> for x in range(10):
+    ...     ...     print(' ', x, end='', sep='') # doctest: +ELLIPSIS
+    ...      0 1 2 ... 9
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+If more than one line of an example with multi-line source has an
+option directive, then they are combined:
+
+    >>> def f(x): r'''
+    ...     Should fail (option directive not on the last line):
+    ...         >>> for x in range(10): # doctest: +ELLIPSIS
+    ...         ...     print(x, end=' ') # doctest: +NORMALIZE_WHITESPACE
+    ...         0  1    2...9
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+It is an error to have a comment of the form ``# doctest:`` that is
+*not* followed by words of the form ``+OPTION`` or ``-OPTION``, where
+``OPTION`` is an option that has been registered with
+`register_option`:
+
+    >>> # Error: Option not registered
+    >>> s = '>>> print(12)  #doctest: +BADOPTION'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the doctest for s has an invalid option: '+BADOPTION'
+
+    >>> # Error: No + or - prefix
+    >>> s = '>>> print(12)  #doctest: ELLIPSIS'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the doctest for s has an invalid option: 'ELLIPSIS'
+
+It is an error to use an option directive on a line that contains no
+source:
+
+    >>> s = '>>> # doctest: +ELLIPSIS'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 0 of the doctest for s has an option directive on a line with no example: '# doctest: +ELLIPSIS'
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+
+def test_testsource(): r"""
+Unit tests for `testsource()`.
+
+The testsource() function takes a module and a name, finds the (first)
+test with that name in that module, and converts it to a script. The
+example code is converted to regular Python code.  The surrounding
+words and expected output are converted to comments:
+
+    >>> from test.test_doctest import test_doctest
+    >>> name = 'test.test_doctest.test_doctest.sample_func'
+    >>> print(doctest.testsource(test_doctest, name))
+    # Blah blah
+    #
+    print(sample_func(22))
+    # Expected:
+    ## 44
+    #
+    # Yee ha!
+    <BLANKLINE>
+
+    >>> name = 'test.test_doctest.test_doctest.SampleNewStyleClass'
+    >>> print(doctest.testsource(test_doctest, name))
+    print('1\n2\n3')
+    # Expected:
+    ## 1
+    ## 2
+    ## 3
+    <BLANKLINE>
+
+    >>> name = 'test.test_doctest.test_doctest.SampleClass.a_classmethod'
+    >>> print(doctest.testsource(test_doctest, name))
+    print(SampleClass.a_classmethod(10))
+    # Expected:
+    ## 12
+    print(SampleClass(0).a_classmethod(10))
+    # Expected:
+    ## 12
+    <BLANKLINE>
+"""
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# def test_debug(): r"""
+
+# Create a docstring that we want to debug:
+
+#     >>> s = '''
+#     ...     >>> x = 12
+#     ...     >>> print(x)
+#     ...     12
+#     ...     '''
+
+# Create some fake stdin input, to feed to the debugger:
+
+#     >>> real_stdin = sys.stdin
+#     >>> sys.stdin = FakeInput(['next', 'print(x)', 'continue'])
+
+# Run the debugger on the docstring, and then restore sys.stdin.
+
+#     >>> try: doctest.debug_src(s)
+#     ... finally: sys.stdin = real_stdin
+#     > <string>(1)<module>()
+#     (Pdb) next
+#     12
+#     --Return--
+#     > <string>(1)<module>()->None
+#     (Pdb) print(x)
+#     12
+#     (Pdb) continue
+
+# """
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+# if not hasattr(sys, 'gettrace') or not sys.gettrace():
+#     def test_pdb_set_trace():
+#         """Using pdb.set_trace from a doctest.
+
+#         You can use pdb.set_trace from a doctest.  To do so, you must
+#         retrieve the set_trace function from the pdb module at the time
+#         you use it.  The doctest module changes sys.stdout so that it can
+#         capture program output.  It also temporarily replaces pdb.set_trace
+#         with a version that restores stdout.  This is necessary for you to
+#         see debugger output.
+
+#           >>> save_colorize = _colorize.COLORIZE
+#           >>> _colorize.COLORIZE = False
+
+#           >>> doc = '''
+#           ... >>> x = 42
+#           ... >>> raise Exception('clé')
+#           ... Traceback (most recent call last):
+#           ... Exception: clé
+#           ... >>> import pdb; pdb.set_trace()
+#           ... '''
+#           >>> parser = doctest.DocTestParser()
+#           >>> test = parser.get_doctest(doc, {}, "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> runner = doctest.DocTestRunner(verbose=False)
+
+#         To demonstrate this, we'll create a fake standard input that
+#         captures our debugger input:
+
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'print(x)',  # print data defined by the example
+#           ...    'continue', # stop debugging
+#           ...    ''])
+
+#           >>> try: runner.run(test)
+#           ... finally: sys.stdin = real_stdin
+#           > <doctest foo-bar@baz[2]>(1)<module>()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) print(x)
+#           42
+#           (Pdb) continue
+#           TestResults(failed=0, attempted=3)
+
+#           You can also put pdb.set_trace in a function called from a test:
+
+#           >>> def calls_set_trace():
+#           ...    y=2
+#           ...    import pdb; pdb.set_trace()
+
+#           >>> doc = '''
+#           ... >>> x=1
+#           ... >>> calls_set_trace()
+#           ... '''
+#           >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'print(y)',  # print data defined in the function
+#           ...    'up',       # out of function
+#           ...    'print(x)',  # print data defined by the example
+#           ...    'continue', # stop debugging
+#           ...    ''])
+
+#           >>> try:
+#           ...     runner.run(test)
+#           ... finally:
+#           ...     sys.stdin = real_stdin
+#           > <doctest test.test_doctest.test_doctest.test_pdb_set_trace[9]>(3)calls_set_trace()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) print(y)
+#           2
+#           (Pdb) up
+#           > <doctest foo-bar@baz[1]>(1)<module>()
+#           -> calls_set_trace()
+#           (Pdb) print(x)
+#           1
+#           (Pdb) continue
+#           TestResults(failed=0, attempted=2)
+
+#         During interactive debugging, source code is shown, even for
+#         doctest examples:
+
+#           >>> doc = '''
+#           ... >>> def f(x):
+#           ... ...     g(x*2)
+#           ... >>> def g(x):
+#           ... ...     print(x+3)
+#           ... ...     import pdb; pdb.set_trace()
+#           ... >>> f(3)
+#           ... '''
+#           >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'step',     # return event of g
+#           ...    'list',     # list source from example 2
+#           ...    'next',     # return from g()
+#           ...    'list',     # list source from example 1
+#           ...    'next',     # return from f()
+#           ...    'list',     # list source from example 3
+#           ...    'continue', # stop debugging
+#           ...    ''])
+#           >>> try: runner.run(test)
+#           ... finally: sys.stdin = real_stdin
+#           ... # doctest: +NORMALIZE_WHITESPACE
+#           > <doctest foo-bar@baz[1]>(3)g()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) step
+#           --Return--
+#           > <doctest foo-bar@baz[1]>(3)g()->None
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) list
+#             1     def g(x):
+#             2         print(x+3)
+#             3  ->     import pdb; pdb.set_trace()
+#           [EOF]
+#           (Pdb) next
+#           --Return--
+#           > <doctest foo-bar@baz[0]>(2)f()->None
+#           -> g(x*2)
+#           (Pdb) list
+#             1     def f(x):
+#             2  ->     g(x*2)
+#           [EOF]
+#           (Pdb) next
+#           --Return--
+#           > <doctest foo-bar@baz[2]>(1)<module>()->None
+#           -> f(3)
+#           (Pdb) list
+#             1  -> f(3)
+#           [EOF]
+#           (Pdb) continue
+#           **********************************************************************
+#           File "foo-bar@baz.py", line 7, in foo-bar@baz
+#           Failed example:
+#               f(3)
+#           Expected nothing
+#           Got:
+#               9
+#           TestResults(failed=1, attempted=3)
+
+#           >>> _colorize.COLORIZE = save_colorize
+#           """
+
+    # TODO: RUSTPYTHON
+    # Issue with pdb
+    # AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+    # def test_pdb_set_trace_nested():
+    #     """This illustrates more-demanding use of set_trace with nested functions.
+
+    #     >>> class C(object):
+    #     ...     def calls_set_trace(self):
+    #     ...         y = 1
+    #     ...         import pdb; pdb.set_trace()
+    #     ...         self.f1()
+    #     ...         y = 2
+    #     ...     def f1(self):
+    #     ...         x = 1
+    #     ...         self.f2()
+    #     ...         x = 2
+    #     ...     def f2(self):
+    #     ...         z = 1
+    #     ...         z = 2
+
+    #     >>> calls_set_trace = C().calls_set_trace
+
+    #     >>> doc = '''
+    #     ... >>> a = 1
+    #     ... >>> calls_set_trace()
+    #     ... '''
+    #     >>> parser = doctest.DocTestParser()
+    #     >>> runner = doctest.DocTestRunner(verbose=False)
+    #     >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+    #     >>> real_stdin = sys.stdin
+    #     >>> sys.stdin = FakeInput([
+    #     ...    'step',
+    #     ...    'print(y)',  # print data defined in the function
+    #     ...    'step', 'step', 'step', 'step', 'step', 'step', 'print(z)',
+    #     ...    'up', 'print(x)',
+    #     ...    'up', 'print(y)',
+    #     ...    'up', 'print(foo)',
+    #     ...    'continue', # stop debugging
+    #     ...    ''])
+
+    #     >>> try:
+    #     ...     runner.run(test)
+    #     ... finally:
+    #     ...     sys.stdin = real_stdin
+    #     ... # doctest: +REPORT_NDIFF
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(4)calls_set_trace()
+    #     -> import pdb; pdb.set_trace()
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(5)calls_set_trace()
+    #     -> self.f1()
+    #     (Pdb) print(y)
+    #     1
+    #     (Pdb) step
+    #     --Call--
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(7)f1()
+    #     -> def f1(self):
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(8)f1()
+    #     -> x = 1
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(9)f1()
+    #     -> self.f2()
+    #     (Pdb) step
+    #     --Call--
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(11)f2()
+    #     -> def f2(self):
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(12)f2()
+    #     -> z = 1
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(13)f2()
+    #     -> z = 2
+    #     (Pdb) print(z)
+    #     1
+    #     (Pdb) up
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(9)f1()
+    #     -> self.f2()
+    #     (Pdb) print(x)
+    #     1
+    #     (Pdb) up
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(5)calls_set_trace()
+    #     -> self.f1()
+    #     (Pdb) print(y)
+    #     1
+    #     (Pdb) up
+    #     > <doctest foo-bar@baz[1]>(1)<module>()
+    #     -> calls_set_trace()
+    #     (Pdb) print(foo)
+    #     *** NameError: name 'foo' is not defined
+    #     (Pdb) continue
+    #     TestResults(failed=0, attempted=2)
+    # """
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+# def test_DocTestSuite():
+#     """DocTestSuite creates a unittest test suite from a doctest.
+
+#        We create a Suite by providing a module.  A module can be provided
+#        by passing a module object:
+
+#          >>> import unittest
+#          >>> import test.test_doctest.sample_doctest
+#          >>> suite = doctest.DocTestSuite(test.test_doctest.sample_doctest)
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+#          >>> for tst, _ in result.failures:
+#          ...     print(tst)
+#          bad (test.test_doctest.sample_doctest.__test__)
+#          foo (test.test_doctest.sample_doctest)
+#          test_silly_setup (test.test_doctest.sample_doctest)
+#          y_is_one (test.test_doctest.sample_doctest)
+
+#        We can also supply the module by name:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        The module need not contain any doctest examples:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_doctests')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        The module need not contain any docstrings either:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_docstrings')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        If all examples in a docstring are skipped, unittest will report it as a
+#        skipped test:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_skip')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=6 errors=0 failures=2>
+#         >>> len(result.skipped)
+#         2
+#         >>> for tst, _ in result.skipped:
+#         ...     print(tst)
+#         double_skip (test.test_doctest.sample_doctest_skip)
+#         single_skip (test.test_doctest.sample_doctest_skip)
+#         >>> for tst, _ in result.failures:
+#         ...     print(tst)
+#         no_skip_fail (test.test_doctest.sample_doctest_skip)
+#         partial_skip_fail (test.test_doctest.sample_doctest_skip)
+
+#        We can use the current module:
+
+#          >>> suite = test.test_doctest.sample_doctest.test_suite()
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        We can also provide a DocTestFinder:
+
+#          >>> finder = doctest.DocTestFinder()
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                          test_finder=finder)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        The DocTestFinder need not return any tests:
+
+#          >>> finder = doctest.DocTestFinder()
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_docstrings',
+#          ...                          test_finder=finder)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        We can supply global variables.  If we pass globs, they will be
+#        used instead of the module globals.  Here we'll pass an empty
+#        globals, triggering an extra error:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest', globs={})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=5>
+
+#        Alternatively, we can provide extra globals.  Here we'll make an
+#        error go away by providing an extra global variable:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                              extraglobs={'y': 1})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        You can pass option flags.  Here we'll cause an extra error
+#        by disabling the blank-line feature:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                      optionflags=doctest.DONT_ACCEPT_BLANKLINE)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=5>
+
+#        You can supply setUp and tearDown functions:
+
+#          >>> def setUp(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     test_doctest.sillySetup = True
+
+#          >>> def tearDown(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     del test_doctest.sillySetup
+
+#        Here, we installed a silly variable that the test expects:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...      setUp=setUp, tearDown=tearDown)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        But the tearDown restores sanity:
+
+#          >>> from test.test_doctest import test_doctest
+#          >>> test_doctest.sillySetup
+#          Traceback (most recent call last):
+#          ...
+#          AttributeError: module 'test.test_doctest.test_doctest' has no attribute 'sillySetup'
+
+#        The setUp and tearDown functions are passed test objects. Here
+#        we'll use the setUp function to supply the missing variable y:
+
+#          >>> def setUp(test):
+#          ...     test.globs['y'] = 1
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest', setUp=setUp)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        Here, we didn't need to use a tearDown function because we
+#        modified the test globals, which are a copy of the
+#        sample_doctest module dictionary.  The test globals are
+#        automatically cleared for us after a test.
+#     """
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_DocTestSuite_errors():
+#     """Tests for error reporting in DocTestSuite.
+
+#          >>> import unittest
+#          >>> import test.test_doctest.sample_doctest_errors as mod
+#          >>> suite = doctest.DocTestSuite(mod)
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=4 errors=0 failures=4>
+#          >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors
+#            File "...sample_doctest_errors.py", line 0, in sample_doctest_errors
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 5, in test.test_doctest.sample_doctest_errors
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 7, in test.test_doctest.sample_doctest_errors
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[1][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.__test__.bad
+#            File "...sample_doctest_errors.py", line unknown line number, in bad
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.__test__.bad[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[2][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.errors
+#            File "...sample_doctest_errors.py", line 14, in errors
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 16, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 18, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 23, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              f()
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[3]>", line 1, in <module>
+#                  f()
+#                  ~^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[2]>", line 2, in f
+#                  2 + '2'
+#                  ~~^~~~~
+#              TypeError: ...
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 25, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              g()
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[4]>", line 1, in <module>
+#                  g()
+#                  ~^^
+#                File "...sample_doctest_errors.py", line 12, in g
+#                  [][0] # line 12
+#                  ~~^^^
+#              IndexError: list index out of range
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[3][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.syntax_error
+#            File "...sample_doctest_errors.py", line 29, in syntax_error
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 31, in test.test_doctest.sample_doctest_errors.syntax_error
+#          Failed example:
+#              2+*3
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                       ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.syntax_error[0]>", line 1
+#                  2+*3
+#                    ^
+#              SyntaxError: invalid syntax
+#          <BLANKLINE>
+#          <BLANKLINE>
+#     """
+
+# TODO: RUSTPYTHON
+# try finally does not work in the interactive shell
+# def test_DocFileSuite():
+#     """We can test tests found in text files using a DocFileSuite.
+
+#        We create a suite by providing the names of one or more text
+#        files that include examples:
+
+#          >>> import unittest
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        The test files are looked for in the directory containing the
+#        calling module.  A package keyword argument can be provided to
+#        specify a different relative location.
+
+#          >>> import unittest
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              package='test.test_doctest')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        Support for using a package's __loader__.get_data() is also
+#        provided.
+
+#          >>> import unittest, pkgutil, test
+#          >>> added_loader = False
+#          >>> if not hasattr(test, '__loader__'):
+#          ...     test.__loader__ = pkgutil.get_loader(test)
+#          ...     added_loader = True
+#          >>> try:
+#          ...     suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                                  'test_doctest2.txt',
+#          ...                                  'test_doctest4.txt',
+#          ...                                  package='test.test_doctest')
+#          ...     suite.run(unittest.TestResult())
+#          ... finally:
+#          ...     if added_loader:
+#          ...         del test.__loader__
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        '/' should be used as a path separator.  It will be converted
+#        to a native separator at run time:
+
+#          >>> suite = doctest.DocFileSuite('../test_doctest/test_doctest.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=1>
+
+#        If DocFileSuite is used from an interactive session, then files
+#        are resolved relative to the directory of sys.argv[0]:
+
+#          >>> import types, os.path
+#          >>> from test.test_doctest import test_doctest
+#          >>> save_argv = sys.argv
+#          >>> sys.argv = [test_doctest.__file__]
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              package=types.ModuleType('__main__'))
+#          >>> sys.argv = save_argv
+
+#        By setting `module_relative=False`, os-specific paths may be
+#        used (including absolute paths and paths relative to the
+#        working directory):
+
+#          >>> # Get the absolute path of the test package.
+#          >>> test_doctest_path = os.path.abspath(test_doctest.__file__)
+#          >>> test_pkg_path = os.path.split(test_doctest_path)[0]
+
+#          >>> # Use it to find the absolute path of test_doctest.txt.
+#          >>> test_file = os.path.join(test_pkg_path, 'test_doctest.txt')
+
+#          >>> suite = doctest.DocFileSuite(test_file, module_relative=False)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=1>
+
+#        It is an error to specify `package` when `module_relative=False`:
+
+#          >>> suite = doctest.DocFileSuite(test_file, module_relative=False,
+#          ...                              package='test')
+#          Traceback (most recent call last):
+#          ValueError: Package may only be specified for module-relative paths.
+
+#        If all examples in a file are skipped, unittest will report it as a
+#        skipped test:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              'test_doctest_skip.txt',
+#          ...                              'test_doctest_skip2.txt')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=4 errors=0 failures=1>
+#          >>> len(result.skipped)
+#          1
+#          >>> for tst, _ in result.skipped: # doctest: +ELLIPSIS
+#          ...     print('=', tst)
+#          = ...test_doctest_skip.txt
+
+#        You can specify initial global variables:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              globs={'favorite_color': 'blue'})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=1>
+
+#        In this case, we supplied a missing favorite color. You can
+#        provide doctest options:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                         optionflags=doctest.DONT_ACCEPT_BLANKLINE,
+#          ...                              globs={'favorite_color': 'blue'})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        And, you can provide setUp and tearDown functions:
+
+#          >>> def setUp(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     test_doctest.sillySetup = True
+
+#          >>> def tearDown(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     del test_doctest.sillySetup
+
+#        Here, we installed a silly variable that the test expects:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              setUp=setUp, tearDown=tearDown)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=1>
+
+#        But the tearDown restores sanity:
+
+#          >>> from test.test_doctest import test_doctest
+#          >>> test_doctest.sillySetup
+#          Traceback (most recent call last):
+#          ...
+#          AttributeError: module 'test.test_doctest.test_doctest' has no attribute 'sillySetup'
+
+#        The setUp and tearDown functions are passed test objects.
+#        Here, we'll use a setUp function to set the favorite color in
+#        test_doctest.txt:
+
+#          >>> def setUp(test):
+#          ...     test.globs['favorite_color'] = 'blue'
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt', setUp=setUp)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=0>
+
+#        Here, we didn't need to use a tearDown function because we
+#        modified the test globals.  The test globals are
+#        automatically cleared for us after a test.
+
+#        Tests in a file run using `DocFileSuite` can also access the
+#        `__file__` global, which is set to the name of the file
+#        containing the tests:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest3.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=0>
+
+#        If the tests contain non-ASCII characters, we have to specify which
+#        encoding the file is encoded with. We do so by using the `encoding`
+#        parameter:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              encoding='utf-8')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+#     """
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_DocFileSuite_errors():
+#     """Tests for error reporting in DocTestSuite.
+
+#         >>> import unittest
+#         >>> suite = doctest.DocFileSuite('test_doctest_errors.txt')
+#         >>> result = suite.run(unittest.TestResult())
+#         >>> result
+#         <unittest.result.TestResult run=1 errors=0 failures=1>
+#         >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+#         Traceback (most recent call last):
+#           File ...
+#             raise self.failureException(self.format_failure(new.getvalue()))
+#         AssertionError: Failed doctest test for test_doctest_errors.txt
+#           File "...test_doctest_errors.txt", line 0
+#         <BLANKLINE>
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 4, in test_doctest_errors.txt
+#         Failed example:
+#             2 + 2
+#         Expected:
+#             5
+#         Got:
+#             4
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 6, in test_doctest_errors.txt
+#         Failed example:
+#             1/0
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                 ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[1]>", line 1, in <module>
+#                 1/0
+#                 ~^~
+#             ZeroDivisionError: division by zero
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 11, in test_doctest_errors.txt
+#         Failed example:
+#             f()
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                 ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[3]>", line 1, in <module>
+#                 f()
+#                 ~^^
+#               File "<doctest test_doctest_errors.txt[2]>", line 2, in f
+#                 2 + '2'
+#                 ~~^~~~~
+#             TypeError: ...
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 13, in test_doctest_errors.txt
+#         Failed example:
+#             2+*3
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                      ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[4]>", line 1
+#                 2+*3
+#                   ^
+#             SyntaxError: invalid syntax
+#         <BLANKLINE>
+#         <BLANKLINE>
+#     """
+
+def test_trailing_space_in_test():
+    """
+    Trailing spaces in expected output are significant:
+
+      >>> x, y = 'foo', ''
+      >>> print(x, y)
+      foo \n
+    """
+
+class Wrapper:
+    def __init__(self, func):
+        self.func = func
+        functools.update_wrapper(self, func)
+
+    def __call__(self, *args, **kwargs):
+        self.func(*args, **kwargs)
+
+@Wrapper
+def wrapped():
+    """
+    Docstrings in wrapped functions must be detected as well.
+
+    >>> 'one other test'
+    'one other test'
+    """
+
+def test_look_in_unwrapped():
+    """
+    Ensure that wrapped doctests work correctly.
+
+    >>> import doctest
+    >>> doctest.run_docstring_examples(
+    ...     wrapped, {}, name=wrapped.__name__, verbose=True)
+    Finding tests in wrapped
+    Trying:
+        'one other test'
+    Expecting:
+        'one other test'
+    ok
+    """
+
+@doctest_skip_if(support.check_impl_detail(cpython=False))
+def test_wrapped_c_func():
+    """
+    # https://github.com/python/cpython/issues/117692
+    >>> import binascii
+    >>> from test.test_doctest.decorator_mod import decorator
+
+    >>> c_func_wrapped = decorator(binascii.b2a_hex)
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(c_func_wrapped)
+    >>> for test in tests:
+    ...    print(test.lineno, test.name)
+    None b2a_hex
+    """
+
+def test_unittest_reportflags():
+    """Default unittest reporting flags can be set to control reporting
+
+    Here, we'll set the REPORT_ONLY_FIRST_FAILURE option so we see
+    only the first failure of each test.  First, we'll look at the
+    output without the flag.  The file test_doctest.txt file has two
+    tests. They both fail if blank lines are disabled:
+
+      >>> suite = doctest.DocFileSuite('test_doctest.txt',
+      ...                          optionflags=doctest.DONT_ACCEPT_BLANKLINE)
+      >>> import unittest
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      ...
+      Failed example:
+          if 1:
+      ...
+
+    Note that we see both failures displayed.
+
+      >>> old = doctest.set_unittest_reportflags(
+      ...    doctest.REPORT_ONLY_FIRST_FAILURE)
+
+    Now, when we run the test:
+
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      Exception raised:
+          ...
+          NameError: name 'favorite_color' is not defined
+      <BLANKLINE>
+      <BLANKLINE>
+
+    We get only the first failure.
+
+    If we give any reporting options when we set up the tests,
+    however:
+
+      >>> suite = doctest.DocFileSuite('test_doctest.txt',
+      ...     optionflags=doctest.DONT_ACCEPT_BLANKLINE | doctest.REPORT_NDIFF)
+
+    Then the default eporting options are ignored:
+
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+
+    *NOTE*: These doctest are intentionally not placed in raw string to depict
+    the trailing whitespace using `\x20` in the diff below.
+
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      ...
+      Failed example:
+          if 1:
+             print('a')
+             print()
+             print('b')
+      Differences (ndiff with -expected +actual):
+            a
+          - <BLANKLINE>
+          +\x20
+            b
+      <BLANKLINE>
+      <BLANKLINE>
+
+
+    Test runners can restore the formatting flags after they run:
+
+      >>> ignored = doctest.set_unittest_reportflags(old)
+
+    """
+
+def test_testfile(): r"""
+Tests for the `testfile()` function.  This function runs all the
+doctest examples in a given file.  In its simple invocation, it is
+called with the name of a file, which is taken to be relative to the
+calling module.  The return value is (#failures, #tests).
+
+We don't want color or `-v` in sys.argv for these tests.
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> save_argv = sys.argv
+    >>> if '-v' in sys.argv:
+    ...     sys.argv = [arg for arg in save_argv if arg != '-v']
+
+
+    >>> doctest.testfile('test_doctest.txt') # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Exception raised:
+        ...
+        NameError: name 'favorite_color' is not defined
+    **********************************************************************
+    1 item had failures:
+       1 of   2 in test_doctest.txt
+    ***Test Failed*** 1 failure.
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+(Note: we'll be clearing doctest.master after each call to
+`doctest.testfile`, to suppress warnings about multiple tests with the
+same name.)
+
+Globals may be specified with the `globs` and `extraglobs` parameters:
+
+    >>> globs = {'favorite_color': 'blue'}
+    >>> doctest.testfile('test_doctest.txt', globs=globs)
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+    >>> extraglobs = {'favorite_color': 'red'}
+    >>> doctest.testfile('test_doctest.txt', globs=globs,
+    ...                  extraglobs=extraglobs) # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Expected:
+        'blue'
+    Got:
+        'red'
+    **********************************************************************
+    1 item had failures:
+       1 of   2 in test_doctest.txt
+    ***Test Failed*** 1 failure.
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The file may be made relative to a given module or package, using the
+optional `module_relative` parameter:
+
+    >>> doctest.testfile('test_doctest.txt', globs=globs,
+    ...                  module_relative='test')
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+Verbosity can be increased with the optional `verbose` parameter:
+
+    >>> doctest.testfile('test_doctest.txt', globs=globs, verbose=True)
+    Trying:
+        favorite_color
+    Expecting:
+        'blue'
+    ok
+    Trying:
+        if 1:
+           print('a')
+           print()
+           print('b')
+    Expecting:
+        a
+        <BLANKLINE>
+        b
+    ok
+    1 item passed all tests:
+       2 tests in test_doctest.txt
+    2 tests in 1 item.
+    2 passed.
+    Test passed.
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The name of the test may be specified with the optional `name`
+parameter:
+
+    >>> doctest.testfile('test_doctest.txt', name='newname')
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in newname
+    ...
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The summary report may be suppressed with the optional `report`
+parameter:
+
+    >>> doctest.testfile('test_doctest.txt', report=False)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Exception raised:
+        ...
+        NameError: name 'favorite_color' is not defined
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The optional keyword argument `raise_on_error` can be used to raise an
+exception on the first error (which may be useful for postmortem
+debugging):
+
+    >>> doctest.testfile('test_doctest.txt', raise_on_error=True)
+    ... # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    doctest.UnexpectedException: ...
+    >>> doctest.master = None  # Reset master.
+
+If the tests contain non-ASCII characters, the tests might fail, since
+it's unknown which encoding is used. The encoding can be specified
+using the optional keyword argument `encoding`:
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='latin-1') # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 7, in test_doctest4.txt
+    Failed example:
+        '...'
+    Expected:
+        'f\xf6\xf6'
+    Got:
+        'f\xc3\xb6\xc3\xb6'
+    **********************************************************************
+    ...
+    **********************************************************************
+    1 item had failures:
+       2 of   2 in test_doctest4.txt
+    ***Test Failed*** 2 failures.
+    TestResults(failed=2, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='utf-8')
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+Test the verbose output:
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='utf-8', verbose=True)
+    Trying:
+        'föö'
+    Expecting:
+        'f\xf6\xf6'
+    ok
+    Trying:
+        'bÄ…r'
+    Expecting:
+        'b\u0105r'
+    ok
+    1 item passed all tests:
+       2 tests in test_doctest4.txt
+    2 tests in 1 item.
+    2 passed.
+    Test passed.
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+    >>> sys.argv = save_argv
+    >>> _colorize.COLORIZE = save_colorize
+"""
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_testfile_errors(): r"""
+# Tests for error reporting in the testfile() function.
+
+#     >>> doctest.testfile('test_doctest_errors.txt', verbose=False) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 4, in test_doctest_errors.txt
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 6, in test_doctest_errors.txt
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 11, in test_doctest_errors.txt
+#     Failed example:
+#         f()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[3]>", line 1, in <module>
+#             f()
+#             ~^^
+#           File "<doctest test_doctest_errors.txt[2]>", line 2, in f
+#             2 + '2'
+#             ~~^~~~~
+#         TypeError: ...
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 13, in test_doctest_errors.txt
+#     Failed example:
+#         2+*3
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#                  ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[4]>", line 1
+#             2+*3
+#               ^
+#         SyntaxError: invalid syntax
+#     **********************************************************************
+#     1 item had failures:
+#        4 of   5 in test_doctest_errors.txt
+#     ***Test Failed*** 4 failures.
+#     TestResults(failed=4, attempted=5)
+# """
+
+class TestImporter(importlib.abc.MetaPathFinder):
+
+    def find_spec(self, fullname, path, target=None):
+        return importlib.util.spec_from_file_location(fullname, path, loader=self)
+
+    def get_data(self, path):
+        with open(path, mode='rb') as f:
+            return f.read()
+
+    def exec_module(self, module):
+        raise ImportError
+
+    def create_module(self, spec):
+        return None
+
+class TestHook:
+
+    def __init__(self, pathdir):
+        self.sys_path = sys.path[:]
+        self.meta_path = sys.meta_path[:]
+        self.path_hooks = sys.path_hooks[:]
+        sys.path.append(pathdir)
+        sys.path_importer_cache.clear()
+        self.modules_before = sys.modules.copy()
+        self.importer = TestImporter()
+        sys.meta_path.append(self.importer)
+
+    def remove(self):
+        sys.path[:] = self.sys_path
+        sys.meta_path[:] = self.meta_path
+        sys.path_hooks[:] = self.path_hooks
+        sys.path_importer_cache.clear()
+        sys.modules.clear()
+        sys.modules.update(self.modules_before)
+
+
+@contextlib.contextmanager
+def test_hook(pathdir):
+    hook = TestHook(pathdir)
+    try:
+        yield hook
+    finally:
+        hook.remove()
+
+# TODO: RUSTPYTHON
+# f.write(b'Test:\r\n\r\n  >>> x = 1 + 1\r\n\r\nDone.\r\n')
+# does not return in with...
+# def test_lineendings(): r"""
+# *nix systems use \n line endings, while Windows systems use \r\n, and
+# old Mac systems used \r, which Python still recognizes as a line ending.  Python
+# handles this using universal newline mode for reading files.  Let's make
+# sure doctest does so (issue 8473) by creating temporary test files using each
+# of the three line disciplines.  At least one will not match either the universal
+# newline \n or os.linesep for the platform the test is run on.
+
+# Windows line endings first:
+
+#     >>> import tempfile, os
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...    f.write(b'Test:\r\n\r\n  >>> x = 1 + 1\r\n\r\nDone.\r\n')
+#     35
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# And now *nix line endings:
+
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(b'Test:\n\n  >>> x = 1 + 1\n\nDone.\n')
+#     30
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# And finally old Mac line endings:
+
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(b'Test:\r\r  >>> x = 1 + 1\r\rDone.\r')
+#     30
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# Now we test with a package loader that has a get_data method, since that
+# bypasses the standard universal newline handling so doctest has to do the
+# newline conversion itself; let's make sure it does so correctly (issue 1812).
+# We'll write a file inside the package that has all three kinds of line endings
+# in it, and use a package hook to install a custom loader; on any platform,
+# at least one of the line endings will raise a ValueError for inconsistent
+# whitespace if doctest does not correctly do the newline conversion.
+
+#     >>> from test.support import os_helper
+#     >>> import shutil
+#     >>> dn = tempfile.mkdtemp()
+#     >>> pkg = os.path.join(dn, "doctest_testpkg")
+#     >>> os.mkdir(pkg)
+#     >>> os_helper.create_empty_file(os.path.join(pkg, "__init__.py"))
+#     >>> fn = os.path.join(pkg, "doctest_testfile.txt")
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(
+#     ...         b'Test:\r\n\r\n'
+#     ...         b'  >>> x = 1 + 1\r\n\r\n'
+#     ...         b'Done.\r\n'
+#     ...         b'Test:\n\n'
+#     ...         b'  >>> x = 1 + 1\n\n'
+#     ...         b'Done.\n'
+#     ...         b'Test:\r\r'
+#     ...         b'  >>> x = 1 + 1\r\r'
+#     ...         b'Done.\r'
+#     ...     )
+#     95
+#     >>> with test_hook(dn):
+#     ...     doctest.testfile("doctest_testfile.txt", package="doctest_testpkg", verbose=False)
+#     TestResults(failed=0, attempted=3)
+#     >>> shutil.rmtree(dn)
+
+# """
+
+def test_testmod(): r"""
+Tests for the testmod function.  More might be useful, but for now we're just
+testing the case raised by Issue 6195, where trying to doctest a C module would
+fail with a UnicodeDecodeError because doctest tried to read the "source" lines
+out of the binary module.
+
+    >>> import unicodedata
+    >>> doctest.testmod(unicodedata, verbose=False)
+    TestResults(failed=0, attempted=0)
+"""
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_testmod_errors(): r"""
+# Tests for error reporting in the testmod() function.
+
+#     >>> import test.test_doctest.sample_doctest_errors as mod
+#     >>> doctest.testmod(mod, verbose=False) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 5, in test.test_doctest.sample_doctest_errors
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 7, in test.test_doctest.sample_doctest_errors
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.__test__.bad[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 16, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 18, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 23, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         f()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[3]>", line 1, in <module>
+#             f()
+#             ~^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[2]>", line 2, in f
+#             2 + '2'
+#             ~~^~~~~
+#         TypeError: ...
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 25, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         g()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[4]>", line 1, in <module>
+#             g()
+#             ~^^
+#           File "...sample_doctest_errors.py", line 12, in g
+#             [][0] # line 12
+#             ~~^^^
+#         IndexError: list index out of range
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 31, in test.test_doctest.sample_doctest_errors.syntax_error
+#     Failed example:
+#         2+*3
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#                  ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.syntax_error[0]>", line 1
+#             2+*3
+#               ^
+#         SyntaxError: invalid syntax
+#     **********************************************************************
+#     4 items had failures:
+#        2 of   2 in test.test_doctest.sample_doctest_errors
+#        2 of   2 in test.test_doctest.sample_doctest_errors.__test__.bad
+#        4 of   5 in test.test_doctest.sample_doctest_errors.errors
+#        1 of   1 in test.test_doctest.sample_doctest_errors.syntax_error
+#     ***Test Failed*** 9 failures.
+#     TestResults(failed=9, attempted=10)
+# """
+
+try:
+    os.fsencode("foo-bär@baz.py")
+    supports_unicode = True
+except UnicodeEncodeError:
+    # Skip the test: the filesystem encoding is unable to encode the filename
+    supports_unicode = False
+
+# TODO: RUSTPYTHON
+# traceback message is different than in CPython
+# if supports_unicode:
+#     def test_unicode(): """
+# Check doctest with a non-ascii filename:
+
+#     >>> save_colorize = _colorize.COLORIZE
+#     >>> _colorize.COLORIZE = False
+
+#     >>> doc = '''
+#     ... >>> raise Exception('clé')
+#     ... '''
+#     ...
+#     >>> parser = doctest.DocTestParser()
+#     >>> test = parser.get_doctest(doc, {}, "foo-bär@baz", "foo-bär@baz.py", 0)
+#     >>> test
+#     <DocTest foo-bär@baz from foo-bär@baz.py:0 (1 example)>
+#     >>> runner = doctest.DocTestRunner(verbose=False)
+#     >>> runner.run(test) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "foo-bär@baz.py", line 2, in foo-bär@baz
+#     Failed example:
+#         raise Exception('clé')
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest foo-bär@baz[0]>", line 1, in <module>
+#             raise Exception('clé')
+#         Exception: clé
+#     TestResults(failed=1, attempted=1)
+
+#     >>> _colorize.COLORIZE = save_colorize
+#     """
+
+
+# TODO: RUSTPYTHON
+# Difference in Error:
+# FileNotFoundError: [Errno ...] ...nosuchfile... vs FileNotFoundError: (2, 'No such file or directory')
+# @doctest_skip_if(not support.has_subprocess_support)
+# def test_CLI(): r"""
+# The doctest module can be used to run doctests against an arbitrary file.
+# These tests test this CLI functionality.
+
+# We'll use the support module's script_helpers for this, and write a test files
+# to a temp dir to run the command against.  Due to a current limitation in
+# script_helpers, though, we need a little utility function to turn the returned
+# output into something we can doctest against:
+
+#     >>> def normalize(s):
+#     ...     return '\n'.join(s.decode().splitlines())
+
+# With those preliminaries out of the way, we'll start with a file with two
+# simple tests and no errors.  We'll run both the unadorned doctest command, and
+# the verbose version, and then check the output:
+
+#     >>> from test.support import script_helper
+#     >>> from test.support.os_helper import temp_dir
+#     >>> with temp_dir() as tmpdir:
+#     ...     fn = os.path.join(tmpdir, 'myfile.doc')
+#     ...     with open(fn, 'w', encoding='utf-8') as f:
+#     ...         _ = f.write('This is a very simple test file.\n')
+#     ...         _ = f.write('   >>> 1 + 1\n')
+#     ...         _ = f.write('   2\n')
+#     ...         _ = f.write('   >>> "a"\n')
+#     ...         _ = f.write("   'a'\n")
+#     ...         _ = f.write('\n')
+#     ...         _ = f.write('And that is it.\n')
+#     ...     rc1, out1, err1 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', fn)
+#     ...     rc2, out2, err2 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-v', fn)
+
+# With no arguments and passing tests, we should get no output:
+
+#     >>> rc1, out1, err1
+#     (0, b'', b'')
+
+# With the verbose flag, we should see the test output, but no error output:
+
+#     >>> rc2, err2
+#     (0, b'')
+#     >>> print(normalize(out2))
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "a"
+#     Expecting:
+#         'a'
+#     ok
+#     1 item passed all tests:
+#        2 tests in myfile.doc
+#     2 tests in 1 item.
+#     2 passed.
+#     Test passed.
+
+# Now we'll write a couple files, one with three tests, the other a python module
+# with two tests, both of the files having "errors" in the tests that can be made
+# non-errors by applying the appropriate doctest options to the run (ELLIPSIS in
+# the first file, NORMALIZE_WHITESPACE in the second).  This combination will
+# allow thoroughly testing the -f and -o flags, as well as the doctest command's
+# ability to process more than one file on the command line and, since the second
+# file ends in '.py', its handling of python module files (as opposed to straight
+# text files).
+
+#     >>> from test.support import script_helper
+#     >>> from test.support.os_helper import temp_dir
+#     >>> with temp_dir() as tmpdir:
+#     ...     fn = os.path.join(tmpdir, 'myfile.doc')
+#     ...     with open(fn, 'w', encoding="utf-8") as f:
+#     ...         _ = f.write('This is another simple test file.\n')
+#     ...         _ = f.write('   >>> 1 + 1\n')
+#     ...         _ = f.write('   2\n')
+#     ...         _ = f.write('   >>> "abcdef"\n')
+#     ...         _ = f.write("   'a...f'\n")
+#     ...         _ = f.write('   >>> "ajkml"\n')
+#     ...         _ = f.write("   'a...l'\n")
+#     ...         _ = f.write('\n')
+#     ...         _ = f.write('And that is it.\n')
+#     ...     fn2 = os.path.join(tmpdir, 'myfile2.py')
+#     ...     with open(fn2, 'w', encoding='utf-8') as f:
+#     ...         _ = f.write('def test_func():\n')
+#     ...         _ = f.write('   \"\"\"\n')
+#     ...         _ = f.write('   This is simple python test function.\n')
+#     ...         _ = f.write('       >>> 1 + 1\n')
+#     ...         _ = f.write('       2\n')
+#     ...         _ = f.write('       >>> "abc   def"\n')
+#     ...         _ = f.write("       'abc def'\n")
+#     ...         _ = f.write("\n")
+#     ...         _ = f.write('   \"\"\"\n')
+#     ...     rc1, out1, err1 = script_helper.assert_python_failure(
+#     ...             '-m', 'doctest', fn, fn2)
+#     ...     rc2, out2, err2 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-o', 'ELLIPSIS', fn)
+#     ...     rc3, out3, err3 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-o', 'ELLIPSIS',
+#     ...             '-o', 'NORMALIZE_WHITESPACE', fn, fn2)
+#     ...     rc4, out4, err4 = script_helper.assert_python_failure(
+#     ...             '-m', 'doctest', '-f', fn, fn2)
+#     ...     rc5, out5, err5 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-v', '-o', 'ELLIPSIS',
+#     ...             '-o', 'NORMALIZE_WHITESPACE', fn, fn2)
+
+# Our first test run will show the errors from the first file (doctest stops if a
+# file has errors).  Note that doctest test-run error output appears on stdout,
+# not stderr:
+
+#     >>> rc1, err1
+#     (1, b'')
+#     >>> print(normalize(out1))                # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...myfile.doc", line 4, in myfile.doc
+#     Failed example:
+#         "abcdef"
+#     Expected:
+#         'a...f'
+#     Got:
+#         'abcdef'
+#     **********************************************************************
+#     File "...myfile.doc", line 6, in myfile.doc
+#     Failed example:
+#         "ajkml"
+#     Expected:
+#         'a...l'
+#     Got:
+#         'ajkml'
+#     **********************************************************************
+#     1 item had failures:
+#        2 of   3 in myfile.doc
+#     ***Test Failed*** 2 failures.
+
+# With -o ELLIPSIS specified, the second run, against just the first file, should
+# produce no errors, and with -o NORMALIZE_WHITESPACE also specified, neither
+# should the third, which ran against both files:
+
+#     >>> rc2, out2, err2
+#     (0, b'', b'')
+#     >>> rc3, out3, err3
+#     (0, b'', b'')
+
+# The fourth run uses FAIL_FAST, so we should see only one error:
+
+#     >>> rc4, err4
+#     (1, b'')
+#     >>> print(normalize(out4))                # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...myfile.doc", line 4, in myfile.doc
+#     Failed example:
+#         "abcdef"
+#     Expected:
+#         'a...f'
+#     Got:
+#         'abcdef'
+#     **********************************************************************
+#     1 item had failures:
+#        1 of   2 in myfile.doc
+#     ***Test Failed*** 1 failure.
+
+# The fifth test uses verbose with the two options, so we should get verbose
+# success output for the tests in both files:
+
+#     >>> rc5, err5
+#     (0, b'')
+#     >>> print(normalize(out5))
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "abcdef"
+#     Expecting:
+#         'a...f'
+#     ok
+#     Trying:
+#         "ajkml"
+#     Expecting:
+#         'a...l'
+#     ok
+#     1 item passed all tests:
+#        3 tests in myfile.doc
+#     3 tests in 1 item.
+#     3 passed.
+#     Test passed.
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "abc   def"
+#     Expecting:
+#         'abc def'
+#     ok
+#     1 item had no tests:
+#         myfile2
+#     1 item passed all tests:
+#        2 tests in myfile2.test_func
+#     2 tests in 2 items.
+#     2 passed.
+#     Test passed.
+
+# We should also check some typical error cases.
+
+# Invalid file name:
+
+#     >>> rc, out, err = script_helper.assert_python_failure(
+#     ...         '-m', 'doctest', 'nosuchfile')
+#     >>> rc, out
+#     (1, b'')
+#     >>> # The exact error message changes depending on the platform.
+#     >>> print(normalize(err))                    # doctest: +ELLIPSIS
+#     Traceback (most recent call last):
+#       ...
+#     FileNotFoundError: [Errno ...] ...nosuchfile...
+
+# Invalid doctest option:
+
+#     >>> rc, out, err = script_helper.assert_python_failure(
+#     ...         '-m', 'doctest', '-o', 'nosuchoption')
+#     >>> rc, out
+#     (2, b'')
+#     >>> print(normalize(err))                    # doctest: +ELLIPSIS
+#     usage...invalid...nosuchoption...
+
+# """
+
+def test_no_trailing_whitespace_stripping():
+    r"""
+    The fancy reports had a bug for a long time where any trailing whitespace on
+    the reported diff lines was stripped, making it impossible to see the
+    differences in line reported as different that differed only in the amount of
+    trailing whitespace.  The whitespace still isn't particularly visible unless
+    you use NDIFF, but at least it is now there to be found.
+
+    *NOTE*: This snippet was intentionally put inside a raw string to get rid of
+    leading whitespace error in executing the example below
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print('\n'.join(['a    ', 'b']))
+    ...     a
+    ...     b
+    ...     '''
+    """
+    """
+    *NOTE*: These doctest are not placed in raw string to depict the trailing whitespace
+    using `\x20`
+
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_NDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join(['a    ', 'b']))
+    Differences (ndiff with -expected +actual):
+        - a
+        + a
+          b
+    TestResults(failed=1, attempted=1)
+
+    *NOTE*: `\x20` is for checking the trailing whitespace on the +a line above.
+    We cannot use actual spaces there, as a commit hook prevents from committing
+    patches that contain trailing whitespace. More info on Issue 24746.
+    """
+
+
+def test_run_doctestsuite_multiple_times():
+    """
+    It was not possible to run the same DocTestSuite multiple times
+    http://bugs.python.org/issue2604
+    http://bugs.python.org/issue9736
+
+    >>> import unittest
+    >>> import test.test_doctest.sample_doctest
+    >>> suite = doctest.DocTestSuite(test.test_doctest.sample_doctest)
+    >>> suite.run(unittest.TestResult())
+    <unittest.result.TestResult run=9 errors=0 failures=4>
+    >>> suite.run(unittest.TestResult())
+    <unittest.result.TestResult run=9 errors=0 failures=4>
+    """
+
+
+def test_exception_with_note(note):
+    """
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> test_exception_with_note('Note')
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    Note
+
+    >>> test_exception_with_note('Note')  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    Note
+
+    >>> test_exception_with_note('''Note
+    ... multiline
+    ... example''')
+    Traceback (most recent call last):
+    ValueError: Text
+    Note
+    multiline
+    example
+
+    Different note will fail the test:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> exc = ValueError('message')
+    ...     >>> exc.add_note('note')
+    ...     >>> raise exc
+    ...     Traceback (most recent call last):
+    ...     ValueError: message
+    ...     wrong note
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 5, in f
+    Failed example:
+        raise exc
+    Expected:
+        Traceback (most recent call last):
+        ValueError: message
+        wrong note
+    Got:
+        Traceback (most recent call last):
+          ...
+        ValueError: message
+        note
+    TestResults(failed=1, attempted=...)
+
+    >>> _colorize.COLORIZE = save_colorize
+    """
+    exc = ValueError('Text')
+    exc.add_note(note)
+    raise exc
+
+
+def test_exception_with_multiple_notes():
+    """
+    >>> test_exception_with_multiple_notes()
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    One
+    Two
+    """
+    exc = ValueError('Text')
+    exc.add_note('One')
+    exc.add_note('Two')
+    raise exc
+
+
+def test_syntax_error_with_note(cls, multiline=False):
+    """
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+      ...
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+      ...
+      File "x.py", line 23
+        bad syntax
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(IndentationError)
+    Traceback (most recent call last):
+      ...
+    IndentationError: error
+    Note
+
+    >>> test_syntax_error_with_note(TabError, multiline=True)
+    Traceback (most recent call last):
+      ...
+    TabError: error
+    Note
+    Line
+    """
+    exc = cls("error", ("x.py", 23, None, "bad syntax"))
+    exc.add_note('Note\nLine' if multiline else 'Note')
+    raise exc
+
+
+def test_syntax_error_subclass_from_stdlib():
+    """
+    `ParseError` is a subclass of `SyntaxError`, but it is not a builtin:
+
+    >>> test_syntax_error_subclass_from_stdlib()
+    Traceback (most recent call last):
+      ...
+    xml.etree.ElementTree.ParseError: error
+    error
+    Note
+    Line
+    """
+    from xml.etree.ElementTree import ParseError
+    exc = ParseError("error\nerror")
+    exc.add_note('Note\nLine')
+    raise exc
+
+
+def test_syntax_error_with_incorrect_expected_note():
+    """
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> exc = SyntaxError("error", ("x.py", 23, None, "bad syntax"))
+    ...     >>> exc.add_note('note1')
+    ...     >>> exc.add_note('note2')
+    ...     >>> raise exc
+    ...     Traceback (most recent call last):
+    ...     SyntaxError: error
+    ...     wrong note
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in f
+    Failed example:
+        raise exc
+    Expected:
+        Traceback (most recent call last):
+        SyntaxError: error
+        wrong note
+    Got:
+        Traceback (most recent call last):
+          ...
+        SyntaxError: error
+        note1
+        note2
+    TestResults(failed=1, attempted=...)
+
+    >>> _colorize.COLORIZE = save_colorize
+    """
+
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(doctest))
+    tests.addTest(doctest.DocTestSuite())
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main(module='test.test_doctest.test_doctest')
diff --git a/Lib/test/test_doctest/test_doctest.txt b/Lib/test/test_doctest/test_doctest.txt
new file mode 100644
index 00000000000..23446d1d224
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest.txt
@@ -0,0 +1,17 @@
+This is a sample doctest in a text file.
+
+In this example, we'll rely on a global variable being set for us
+already:
+
+  >>> favorite_color
+  'blue'
+
+We can make this fail by disabling the blank-line feature.
+
+  >>> if 1:
+  ...    print('a')
+  ...    print()
+  ...    print('b')
+  a
+  <BLANKLINE>
+  b
diff --git a/Lib/test/test_doctest/test_doctest2.py b/Lib/test/test_doctest/test_doctest2.py
new file mode 100644
index 00000000000..ab8a0696736
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest2.py
@@ -0,0 +1,126 @@
+"""A module to test whether doctest recognizes some 2.2 features,
+like static and class methods.
+
+>>> print('yup')  # 1
+yup
+
+We include some (random) encoded (utf-8) text in the text surrounding
+the example.  It should be ignored:
+
+ЉЊЈ�Ђ
+
+"""
+
+import sys
+import unittest
+if sys.flags.optimize >= 2:
+    raise unittest.SkipTest("Cannot test docstrings with -O2")
+
+class C(object):
+    """Class C.
+
+    >>> print(C())  # 2
+    42
+
+
+    We include some (random) encoded (utf-8) text in the text surrounding
+    the example.  It should be ignored:
+
+        ЉЊЈ�Ђ
+
+    """
+
+    def __init__(self):
+        """C.__init__.
+
+        >>> print(C()) # 3
+        42
+        """
+
+    def __str__(self):
+        """
+        >>> print(C()) # 4
+        42
+        """
+        return "42"
+
+    class D(object):
+        """A nested D class.
+
+        >>> print("In D!")   # 5
+        In D!
+        """
+
+        def nested(self):
+            """
+            >>> print(3) # 6
+            3
+            """
+
+    def getx(self):
+        """
+        >>> c = C()    # 7
+        >>> c.x = 12   # 8
+        >>> print(c.x)  # 9
+        -12
+        """
+        return -self._x
+
+    def setx(self, value):
+        """
+        >>> c = C()     # 10
+        >>> c.x = 12    # 11
+        >>> print(c.x)   # 12
+        -12
+        """
+        self._x = value
+
+    x = property(getx, setx, doc="""\
+        >>> c = C()    # 13
+        >>> c.x = 12   # 14
+        >>> print(c.x)  # 15
+        -12
+        """)
+
+    @staticmethod
+    def statm():
+        """
+        A static method.
+
+        >>> print(C.statm())    # 16
+        666
+        >>> print(C().statm())  # 17
+        666
+        """
+        return 666
+
+    @classmethod
+    def clsm(cls, val):
+        """
+        A class method.
+
+        >>> print(C.clsm(22))    # 18
+        22
+        >>> print(C().clsm(23))  # 19
+        23
+        """
+        return val
+
+
+class Test(unittest.TestCase):
+    def test_testmod(self):
+        import doctest, sys
+        EXPECTED = 19
+        f, t = doctest.testmod(sys.modules[__name__])
+        if f:
+            self.fail("%d of %d doctests failed" % (f, t))
+        if t != EXPECTED:
+            self.fail("expected %d tests to run, not %d" % (EXPECTED, t))
+
+
+# Pollute the namespace with a bunch of imported functions and classes,
+# to make sure they don't get tested.
+from doctest import *
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_doctest/test_doctest2.txt b/Lib/test/test_doctest/test_doctest2.txt
new file mode 100644
index 00000000000..76dab94a9c0
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest2.txt
@@ -0,0 +1,14 @@
+This is a sample doctest in a text file.
+
+In this example, we'll rely on some silly setup:
+
+  >>> import test.test_doctest.test_doctest
+  >>> test.test_doctest.test_doctest.sillySetup
+  True
+
+This test also has some (random) encoded (utf-8) unicode text:
+
+  �‰�Š�ˆ���‚
+
+This doesn't cause a problem in the tect surrounding the examples, but
+we include it here (in this test text file) to make sure. :)
diff --git a/Lib/test/test_doctest/test_doctest3.txt b/Lib/test/test_doctest/test_doctest3.txt
new file mode 100644
index 00000000000..dd8557e57a5
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest3.txt
@@ -0,0 +1,5 @@
+
+Here we check that `__file__` is provided:
+
+  >>> type(__file__)
+  <class 'str'>
diff --git a/Lib/test/test_doctest/test_doctest4.txt b/Lib/test/test_doctest/test_doctest4.txt
new file mode 100644
index 00000000000..0428e6f9632
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest4.txt
@@ -0,0 +1,11 @@
+This is a sample doctest in a text file that contains non-ASCII characters.
+This file is encoded using UTF-8.
+
+In order to get this test to pass, we have to manually specify the
+encoding.
+
+  >>> 'föö'
+  'f\xf6\xf6'
+
+  >>> 'bÄ…r'
+  'b\u0105r'
diff --git a/Lib/test/test_doctest/test_doctest_errors.txt b/Lib/test/test_doctest/test_doctest_errors.txt
new file mode 100644
index 00000000000..93c3c106e60
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_errors.txt
@@ -0,0 +1,14 @@
+This is a sample doctest in a text file, in which all examples fail
+or raise an exception.
+
+  >>> 2 + 2
+  5
+  >>> 1/0
+  1
+  >>> def f():
+  ...     2 + '2'
+  ...
+  >>> f()
+  1
+  >>> 2+*3
+  5
diff --git a/Lib/test/test_doctest/test_doctest_skip.txt b/Lib/test/test_doctest/test_doctest_skip.txt
new file mode 100644
index 00000000000..06c23d06e60
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_skip.txt
@@ -0,0 +1,6 @@
+This is a sample doctest in a text file, in which all examples are skipped.
+
+  >>> 2 + 2  # doctest: +SKIP
+  5
+  >>> 2 + 2  # doctest: +SKIP
+  4
diff --git a/Lib/test/test_doctest/test_doctest_skip2.txt b/Lib/test/test_doctest/test_doctest_skip2.txt
new file mode 100644
index 00000000000..85e4938c346
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_skip2.txt
@@ -0,0 +1,6 @@
+This is a sample doctest in a text file, in which some examples are skipped.
+
+  >>> 2 + 2  # doctest: +SKIP
+  5
+  >>> 2 + 2
+  4
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 182333cea51..9b74b66e3a7 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -129,7 +129,7 @@ fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
 
 fn inner_floordiv(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
     if int2.is_zero() {
-        Err(vm.new_zero_division_error("integer division by zero"))
+        Err(vm.new_zero_division_error("integer division or modulo by zero"))
     } else {
         Ok(vm.ctx.new_int(int1.div_floor(int2)).into())
     }

From 580f6e3f34659a89e4b26d076ba3a90199be0e2b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 31 Dec 2025 09:47:59 +0900
Subject: [PATCH 130/418] Bump cranelift-* from 0.126.1 to 0.127.0 (#6571)

Bumps [cranelift](https://github.com/bytecodealliance/wasmtime) from 0.126.1 to 0.127.0.
- [Release notes](https://github.com/bytecodealliance/wasmtime/releases)
- [Changelog](https://github.com/bytecodealliance/wasmtime/blob/main/RELEASES.md)
- [Commits](https://github.com/bytecodealliance/wasmtime/commits)

--------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Cargo.lock            | 76 +++++++++++++++++++++----------------------
 crates/jit/Cargo.toml |  6 ++--
 2 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 46c4dafe13b..89cace13b26 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -691,9 +691,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68971376deb1edf5e9c0ac77ef00479d740ce7a60e6181adb0648afe1dc7b8f4"
+checksum = "513887fe45ce3979a4766ddc9992c3cdbf509add2a31906350649423a1d0d287"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -702,42 +702,42 @@ dependencies = [
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30054f4aef4d614d37f27d5b77e36e165f0b27a71563be348e7c9fcfac41eed8"
+checksum = "8bd963a645179fa33834ba61fa63353998543b07f877e208da9eb47d4a70d1e7"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0beab56413879d4f515e08bcf118b1cb85f294129bb117057f573d37bfbb925a"
+checksum = "3f6d5739c9dc6b5553ca758d78d87d127dd19f397f776efecf817b8ba8d0bb01"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d054747549a69b264d5299c8ca1b0dd45dc6bd0ee43f1edfcc42a8b12952c7a"
+checksum = "ff402c11bb1c9652b67a3e885e84b1b8d00c13472c8fd85211e06a41a63c3e03"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98b92d481b77a7dc9d07c96e24a16f29e0c9c27d042828fdf7e49e54ee9819bf"
+checksum = "769a0d88c2f5539e9c5536a93a7bf164b0dc68d91e3d00723e5b4ffc1440afdc"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6eeccfc043d599b0ef1806942707fc51cdd1c3965c343956dc975a55d82a920f"
+checksum = "d4351f721fb3b26add1c180f0a75c7474bab2f903c8b777c6ca65238ded59a78"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -761,9 +761,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1174cdb9d9d43b2bdaa612a07ed82af13db9b95526bc2c286c2aec4689bcc038"
+checksum = "61f86c0ba5b96713643f4dd0de0df12844de9c7bb137d6829b174b706939aa74"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -773,33 +773,33 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d572be73fae802eb115f45e7e67a9ed16acb4ee683b67c4086768786545419a"
+checksum = "f08605eee8d51fd976a970bd5b16c9529b51b624f8af68f80649ffb172eb85a4"
 
 [[package]]
 name = "cranelift-control"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1587465cc84c5cc793b44add928771945f3132bbf6b3621ee9473c631a87156"
+checksum = "623aab0a09e40f0cf0b5d35eb7832bae4c4f13e3768228e051a6c1a60e88ef5f"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "063b83448b1343e79282c3c7cbda7ed5f0816f0b763a4c15f7cecb0a17d87ea6"
+checksum = "ea0f066e07e3bcbe38884cc5c94c32c7a90267d69df80f187d9dfe421adaa7c4"
 dependencies = [
  "cranelift-bitset",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa4461c2d2ca48bc72883f5f5c3129d9aefac832df1db824af9db8db3efee109"
+checksum = "40865b02a0e52ca8e580ad64feef530cb1d05f6bb4972b4eef05e3eaeae81701"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -809,15 +809,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acd811b25e18f14810d09c504e06098acc1d9dbfa24879bf0d6b6fb44415fc66"
+checksum = "104b3c117ae513e9af1d90679842101193a5ccb96ac9f997966d85ea25be2852"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01527663ba63c10509d7c87fd1f8495d21170ba35bf714f57271495689d8fde5"
+checksum = "3aa5f855cfb8e4253ed2d0dfc1a0b6ebe4912e67aa8b7ee14026ff55ca17f1fe"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -830,14 +830,14 @@ dependencies = [
  "region",
  "target-lexicon",
  "wasmtime-internal-jit-icache-coherence",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "cranelift-module"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72328edb49aeafb1655818c91c476623970cb7b8a89ffbdadd82ce7d13dedc1d"
+checksum = "b1d01806b191b59f4fc4680293dd5f554caf2de5b62f95eff5beef7acb46c29c"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -846,9 +846,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2417046989d8d6367a55bbab2e406a9195d176f4779be4aa484d645887217d37"
+checksum = "e5c54e0a358bc05b48f2032e1c320e7f468da068604f2869b77052eab68eb0fe"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -857,9 +857,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.126.1"
+version = "0.127.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d039de901c8d928222b8128e1b9a9ab27b82a7445cb749a871c75d9cb25c57d"
+checksum = "cc6f4b039f453b66c75e9f7886e5a2af96276e151f44dc19b24b58f9a0c98009"
 
 [[package]]
 name = "crc32fast"
@@ -4293,21 +4293,21 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "39.0.1"
+version = "40.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97ccd36e25390258ce6720add639ffe5a7d81a5c904350aa08f5bbc60433d22"
+checksum = "0858b470463f3e7c73acd6049046049e64be17b98901c2db5047450cf83df1fe"
 dependencies = [
  "anyhow",
  "cfg-if",
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "wasmtime-internal-math"
-version = "39.0.1"
+version = "40.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd1b856e1bbf0230ab560ba4204e944b141971adc4e6cdf3feb6979c1a7b7953"
+checksum = "222e1a590ece4e898f20af1e541b61d2cb803f2557e7eaff23e6c1db5434454a"
 dependencies = [
  "libm",
 ]
diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
index a79e48bac2d..fde10b7c006 100644
--- a/crates/jit/Cargo.toml
+++ b/crates/jit/Cargo.toml
@@ -17,9 +17,9 @@ num-traits = { workspace = true }
 thiserror = { workspace = true }
 libffi = { workspace = true }
 
-cranelift = "0.126"
-cranelift-jit = "0.126"
-cranelift-module = "0.126"
+cranelift = "0.127"
+cranelift-jit = "0.127"
+cranelift-module = "0.127"
 
 [dev-dependencies]
 rustpython-derive = { workspace = true }

From 00ae4a175136541851f88b1c0108e565917bfbae Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 11:28:04 +0900
Subject: [PATCH 131/418] enhance error codec and exit code (#6602)

---
 crates/vm/src/vm/mod.rs | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index ddbf7660f7d..b156e30b738 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -327,11 +327,17 @@ impl VirtualMachine {
                     let line_buffering = buffered_stdio && (isatty || fd == 2);
 
                     let newline = if cfg!(windows) { None } else { Some("\n") };
+                    // stderr uses backslashreplace error handler
+                    let errors: Option<&str> = if fd == 2 {
+                        Some("backslashreplace")
+                    } else {
+                        None
+                    };
 
                     let stdio = self.call_method(
                         &io,
                         "TextIOWrapper",
-                        (buf, (), (), newline, line_buffering, write_through),
+                        (buf, (), errors, newline, line_buffering, write_through),
                     )?;
                     let mode = if write { "w" } else { "r" };
                     stdio.set_attr("mode", self.ctx.new_str(mode), self)?;
@@ -853,7 +859,13 @@ impl VirtualMachine {
                 [arg] => match_class!(match arg {
                     ref i @ PyInt => {
                         use num_traits::cast::ToPrimitive;
-                        return i.as_bigint().to_u32().unwrap_or(0);
+                        // Try u32 first, then i32 (for negative values), else -1 for overflow
+                        let code = i
+                            .as_bigint()
+                            .to_u32()
+                            .or_else(|| i.as_bigint().to_i32().map(|v| v as u32))
+                            .unwrap_or(-1i32 as u32);
+                        return code;
                     }
                     arg => {
                         if self.is_none(arg) {
@@ -866,8 +878,11 @@ impl VirtualMachine {
                 _ => args.as_object().repr(self).ok(),
             };
             if let Some(msg) = msg {
-                let stderr = stdlib::sys::PyStderr(self);
-                writeln!(stderr, "{msg}");
+                // Write using Python's write() to use stderr's error handler (backslashreplace)
+                if let Ok(stderr) = stdlib::sys::get_stderr(self) {
+                    let _ = self.call_method(&stderr, "write", (msg,));
+                    let _ = self.call_method(&stderr, "write", ("\n",));
+                }
             }
             1
         } else if exc.fast_isinstance(self.ctx.exceptions.keyboard_interrupt) {

From 4cf5697e063361b0cb055199b10749576de92896 Mon Sep 17 00:00:00 2001
From: Ashwin Naren <arihant2math@gmail.com>
Date: Tue, 30 Dec 2025 18:57:42 -0800
Subject: [PATCH 132/418] Symboltable updates (#5861)

* symboltable updates

* Fix symboltable

---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 crates/codegen/src/symboltable.rs | 92 +++++++++++++++++++++++++------
 1 file changed, 74 insertions(+), 18 deletions(-)

diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 1629e5fff38..07766373d5a 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -137,12 +137,12 @@ pub enum SymbolScope {
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub struct SymbolFlags: u16 {
-        const REFERENCED = 0x001;
-        const ASSIGNED = 0x002;
-        const PARAMETER = 0x004;
-        const ANNOTATED = 0x008;
-        const IMPORTED = 0x010;
-        const NONLOCAL = 0x020;
+        const REFERENCED = 0x001;  // USE
+        const ASSIGNED = 0x002;    // DEF_LOCAL
+        const PARAMETER = 0x004;   // DEF_PARAM
+        const ANNOTATED = 0x008;   // DEF_ANNOT
+        const IMPORTED = 0x010;    // DEF_IMPORT
+        const NONLOCAL = 0x020;    // DEF_NONLOCAL
         // indicates if the symbol gets a value assigned by a named expression in a comprehension
         // this is required to correct the scope in the analysis.
         const ASSIGNED_IN_COMPREHENSION = 0x040;
@@ -157,8 +157,12 @@ bitflags! {
         ///         def method(self):
         ///             return x // is_free_class
         /// ```
-        const FREE_CLASS = 0x100;
-        const BOUND = Self::ASSIGNED.bits() | Self::PARAMETER.bits() | Self::IMPORTED.bits() | Self::ITER.bits();
+        const FREE_CLASS = 0x100;  // DEF_FREE_CLASS
+        const GLOBAL = 0x200;      // DEF_GLOBAL
+        const COMP_ITER = 0x400;   // DEF_COMP_ITER
+        const COMP_CELL = 0x800;   // DEF_COMP_CELL
+        const TYPE_PARAM = 0x1000; // DEF_TYPE_PARAM
+        const BOUND = Self::ASSIGNED.bits() | Self::PARAMETER.bits() | Self::IMPORTED.bits() | Self::ITER.bits() | Self::TYPE_PARAM.bits();
     }
 }
 
@@ -611,6 +615,8 @@ struct SymbolTableBuilder {
     source_file: SourceFile,
     // Current scope's varnames being collected (temporary storage)
     current_varnames: Vec<String>,
+    // Track if we're inside an iterable definition expression (for nested comprehensions)
+    in_iter_def_exp: bool,
 }
 
 /// Enum to indicate in what mode an expression
@@ -634,6 +640,7 @@ impl SymbolTableBuilder {
             future_annotations: false,
             source_file,
             current_varnames: Vec::new(),
+            in_iter_def_exp: false,
         };
         this.enter_scope("top", CompilerScope::Module, 0);
         this
@@ -720,6 +727,23 @@ impl SymbolTableBuilder {
         } else {
             SymbolUsage::Parameter
         };
+
+        // Check for duplicate parameter names
+        let table = self.tables.last().unwrap();
+        if table.symbols.contains_key(parameter.name.as_str()) {
+            return Err(SymbolTableError {
+                error: format!(
+                    "duplicate parameter '{}' in function definition",
+                    parameter.name
+                ),
+                location: Some(
+                    self.source_file
+                        .to_source_code()
+                        .source_location(parameter.name.range.start(), PositionEncoding::Utf8),
+                ),
+            });
+        }
+
         self.register_ident(&parameter.name, usage)
     }
 
@@ -871,6 +895,18 @@ impl SymbolTableBuilder {
                     if let Some(alias) = &name.asname {
                         // `import my_module as my_alias`
                         self.register_ident(alias, SymbolUsage::Imported)?;
+                    } else if name.name.as_str() == "*" {
+                        // Star imports are only allowed at module level
+                        if self.tables.last().unwrap().typ != CompilerScope::Module {
+                            return Err(SymbolTableError {
+                                error: "'import *' only allowed at module level".to_string(),
+                                location: Some(self.source_file.to_source_code().source_location(
+                                    name.name.range.start(),
+                                    PositionEncoding::Utf8,
+                                )),
+                            });
+                        }
+                        // Don't register star imports as symbols
                     } else {
                         // `import module`
                         self.register_name(
@@ -1162,7 +1198,12 @@ impl SymbolTableBuilder {
                 range,
                 ..
             }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
                 self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::ListComp(ExprListComp {
                 elt,
@@ -1170,7 +1211,12 @@ impl SymbolTableBuilder {
                 range,
                 node_index: _,
             }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
                 self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::SetComp(ExprSetComp {
                 elt,
@@ -1178,7 +1224,12 @@ impl SymbolTableBuilder {
                 range,
                 node_index: _,
             }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
                 self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::DictComp(ExprDictComp {
                 key,
@@ -1187,7 +1238,12 @@ impl SymbolTableBuilder {
                 range,
                 node_index: _,
             }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
                 self.scan_comprehension("genexpr", key, Some(value), generators, *range)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::Call(ExprCall {
                 func,
@@ -1312,8 +1368,8 @@ impl SymbolTableBuilder {
                 node_index: _,
             }) => {
                 // named expressions are not allowed in the definition of
-                // comprehension iterator definitions
-                if let ExpressionContext::IterDefinitionExp = context {
+                // comprehension iterator definitions (including nested comprehensions)
+                if context == ExpressionContext::IterDefinitionExp || self.in_iter_def_exp {
                     return Err(SymbolTableError {
                           error: "assignment expression cannot be used in a comprehension iterable expression".to_string(),
                           location: Some(self.source_file.to_source_code().source_location(target.range().start(), PositionEncoding::Utf8)),
@@ -1745,6 +1801,7 @@ impl SymbolTableBuilder {
             }
             SymbolUsage::Global => {
                 symbol.scope = SymbolScope::GlobalExplicit;
+                flags.insert(SymbolFlags::GLOBAL);
             }
             SymbolUsage::Used => {
                 flags.insert(SymbolFlags::REFERENCED);
@@ -1753,21 +1810,20 @@ impl SymbolTableBuilder {
                 flags.insert(SymbolFlags::ITER);
             }
             SymbolUsage::TypeParam => {
-                // Type parameters are always cell variables in their scope
-                symbol.scope = SymbolScope::Cell;
-                flags.insert(SymbolFlags::ASSIGNED);
+                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::TYPE_PARAM);
             }
         }
 
         // and even more checking
         // it is not allowed to assign to iterator variables (by named expressions)
-        if flags.contains(SymbolFlags::ITER | SymbolFlags::ASSIGNED)
-        /*&& symbol.is_assign_named_expr_in_comprehension*/
+        if flags.contains(SymbolFlags::ITER)
+            && flags.contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
         {
             return Err(SymbolTableError {
-                error:
-                    "assignment expression cannot be used in a comprehension iterable expression"
-                        .to_string(),
+                error: format!(
+                    "assignment expression cannot rebind comprehension iteration variable '{}'",
+                    symbol.name
+                ),
                 location,
             });
         }

From 37c47fca6ba9a411192059e5ef671a470b286fbf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 31 Dec 2025 12:02:47 +0900
Subject: [PATCH 133/418] Bump qs and express in /wasm/demo (#6603)

Bumps [qs](https://github.com/ljharb/qs) and [express](https://github.com/expressjs/express). These dependencies needed to be updated together.

Updates `qs` from 6.13.0 to 6.14.1
- [Changelog](https://github.com/ljharb/qs/blob/main/CHANGELOG.md)
- [Commits](https://github.com/ljharb/qs/compare/v6.13.0...v6.14.1)

Updates `express` from 4.21.2 to 4.22.1
- [Release notes](https://github.com/expressjs/express/releases)
- [Changelog](https://github.com/expressjs/express/blob/v4.22.1/History.md)
- [Commits](https://github.com/expressjs/express/compare/4.21.2...v4.22.1)

---
updated-dependencies:
- dependency-name: qs
  dependency-version: 6.14.1
  dependency-type: indirect
- dependency-name: express
  dependency-version: 4.22.1
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 wasm/demo/package-lock.json | 48 ++++++++++++++++++++++++-------------
 1 file changed, 32 insertions(+), 16 deletions(-)

diff --git a/wasm/demo/package-lock.json b/wasm/demo/package-lock.json
index 3acc105e3c3..eb6957b3c54 100644
--- a/wasm/demo/package-lock.json
+++ b/wasm/demo/package-lock.json
@@ -2205,40 +2205,40 @@
             }
         },
         "node_modules/express": {
-            "version": "4.21.2",
-            "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
-            "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+            "version": "4.22.1",
+            "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
+            "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "accepts": "~1.3.8",
                 "array-flatten": "1.1.1",
-                "body-parser": "1.20.3",
-                "content-disposition": "0.5.4",
+                "body-parser": "~1.20.3",
+                "content-disposition": "~0.5.4",
                 "content-type": "~1.0.4",
-                "cookie": "0.7.1",
-                "cookie-signature": "1.0.6",
+                "cookie": "~0.7.1",
+                "cookie-signature": "~1.0.6",
                 "debug": "2.6.9",
                 "depd": "2.0.0",
                 "encodeurl": "~2.0.0",
                 "escape-html": "~1.0.3",
                 "etag": "~1.8.1",
-                "finalhandler": "1.3.1",
-                "fresh": "0.5.2",
-                "http-errors": "2.0.0",
+                "finalhandler": "~1.3.1",
+                "fresh": "~0.5.2",
+                "http-errors": "~2.0.0",
                 "merge-descriptors": "1.0.3",
                 "methods": "~1.1.2",
-                "on-finished": "2.4.1",
+                "on-finished": "~2.4.1",
                 "parseurl": "~1.3.3",
-                "path-to-regexp": "0.1.12",
+                "path-to-regexp": "~0.1.12",
                 "proxy-addr": "~2.0.7",
-                "qs": "6.13.0",
+                "qs": "~6.14.0",
                 "range-parser": "~1.2.1",
                 "safe-buffer": "5.2.1",
-                "send": "0.19.0",
-                "serve-static": "1.16.2",
+                "send": "~0.19.0",
+                "serve-static": "~1.16.2",
                 "setprototypeof": "1.2.0",
-                "statuses": "2.0.1",
+                "statuses": "~2.0.1",
                 "type-is": "~1.6.18",
                 "utils-merge": "1.0.1",
                 "vary": "~1.1.2"
@@ -2271,6 +2271,22 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/express/node_modules/qs": {
+            "version": "6.14.1",
+            "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
+            "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "dependencies": {
+                "side-channel": "^1.1.0"
+            },
+            "engines": {
+                "node": ">=0.6"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
         "node_modules/express/node_modules/range-parser": {
             "version": "1.2.1",
             "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",

From bd0aaf6f4f6aaf92283b3f83058ce20208759e67 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Wed, 31 Dec 2025 00:58:34 -0500
Subject: [PATCH 134/418] Updated the hmac +  mailbox libraries + associated
 tests (#6608)

* Updated hmac + test library

* Updated mailbox library

* Added mailbox library test (v3.13.10)
---
 Lib/hmac.py              |    2 +-
 Lib/mailbox.py           |   96 +-
 Lib/test/test_hmac.py    |    8 +
 Lib/test/test_mailbox.py | 2495 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 2588 insertions(+), 13 deletions(-)
 create mode 100644 Lib/test/test_mailbox.py

diff --git a/Lib/hmac.py b/Lib/hmac.py
index 8b4f920db95..8b4eb2fe741 100644
--- a/Lib/hmac.py
+++ b/Lib/hmac.py
@@ -53,7 +53,7 @@ def __init__(self, key, msg=None, digestmod=''):
             raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__)
 
         if not digestmod:
-            raise TypeError("Missing required parameter 'digestmod'.")
+            raise TypeError("Missing required argument 'digestmod'.")
 
         if _hashopenssl and isinstance(digestmod, (str, _functype)):
             try:
diff --git a/Lib/mailbox.py b/Lib/mailbox.py
index 70da07ed2e9..b00d9e8634c 100644
--- a/Lib/mailbox.py
+++ b/Lib/mailbox.py
@@ -395,6 +395,56 @@ def get_file(self, key):
         f = open(os.path.join(self._path, self._lookup(key)), 'rb')
         return _ProxyFile(f)
 
+    def get_info(self, key):
+        """Get the keyed message's "info" as a string."""
+        subpath = self._lookup(key)
+        if self.colon in subpath:
+            return subpath.split(self.colon)[-1]
+        return ''
+
+    def set_info(self, key, info: str):
+        """Set the keyed message's "info" string."""
+        if not isinstance(info, str):
+            raise TypeError(f'info must be a string: {type(info)}')
+        old_subpath = self._lookup(key)
+        new_subpath = old_subpath.split(self.colon)[0]
+        if info:
+            new_subpath += self.colon + info
+        if new_subpath == old_subpath:
+            return
+        old_path = os.path.join(self._path, old_subpath)
+        new_path = os.path.join(self._path, new_subpath)
+        os.rename(old_path, new_path)
+        self._toc[key] = new_subpath
+
+    def get_flags(self, key):
+        """Return as a string the standard flags that are set on the keyed message."""
+        info = self.get_info(key)
+        if info.startswith('2,'):
+            return info[2:]
+        return ''
+
+    def set_flags(self, key, flags: str):
+        """Set the given flags and unset all others on the keyed message."""
+        if not isinstance(flags, str):
+            raise TypeError(f'flags must be a string: {type(flags)}')
+        # TODO: check if flags are valid standard flag characters?
+        self.set_info(key, '2,' + ''.join(sorted(set(flags))))
+
+    def add_flag(self, key, flag: str):
+        """Set the given flag(s) without changing others on the keyed message."""
+        if not isinstance(flag, str):
+            raise TypeError(f'flag must be a string: {type(flag)}')
+        # TODO: check that flag is a valid standard flag character?
+        self.set_flags(key, ''.join(set(self.get_flags(key)) | set(flag)))
+
+    def remove_flag(self, key, flag: str):
+        """Unset the given string flag(s) without changing others on the keyed message."""
+        if not isinstance(flag, str):
+            raise TypeError(f'flag must be a string: {type(flag)}')
+        if self.get_flags(key):
+            self.set_flags(key, ''.join(set(self.get_flags(key)) - set(flag)))
+
     def iterkeys(self):
         """Return an iterator over keys."""
         self._refresh()
@@ -540,6 +590,8 @@ def _refresh(self):
         for subdir in self._toc_mtimes:
             path = self._paths[subdir]
             for entry in os.listdir(path):
+                if entry.startswith('.'):
+                    continue
                 p = os.path.join(path, entry)
                 if os.path.isdir(p):
                     continue
@@ -698,9 +750,13 @@ def flush(self):
         _sync_close(new_file)
         # self._file is about to get replaced, so no need to sync.
         self._file.close()
-        # Make sure the new file's mode is the same as the old file's
-        mode = os.stat(self._path).st_mode
-        os.chmod(new_file.name, mode)
+        # Make sure the new file's mode and owner are the same as the old file's
+        info = os.stat(self._path)
+        os.chmod(new_file.name, info.st_mode)
+        try:
+            os.chown(new_file.name, info.st_uid, info.st_gid)
+        except (AttributeError, OSError):
+            pass
         try:
             os.rename(new_file.name, self._path)
         except FileExistsError:
@@ -778,10 +834,11 @@ def get_message(self, key):
         """Return a Message representation or raise a KeyError."""
         start, stop = self._lookup(key)
         self._file.seek(start)
-        from_line = self._file.readline().replace(linesep, b'')
+        from_line = self._file.readline().replace(linesep, b'').decode('ascii')
         string = self._file.read(stop - self._file.tell())
         msg = self._message_factory(string.replace(linesep, b'\n'))
-        msg.set_from(from_line[5:].decode('ascii'))
+        msg.set_unixfrom(from_line)
+        msg.set_from(from_line[5:])
         return msg
 
     def get_string(self, key, from_=False):
@@ -1089,10 +1146,24 @@ def __len__(self):
         """Return a count of messages in the mailbox."""
         return len(list(self.iterkeys()))
 
+    def _open_mh_sequences_file(self, text):
+        mode = '' if text else 'b'
+        kwargs = {'encoding': 'ASCII'} if text else {}
+        path = os.path.join(self._path, '.mh_sequences')
+        while True:
+            try:
+                return open(path, 'r+' + mode, **kwargs)
+            except FileNotFoundError:
+                pass
+            try:
+                return open(path, 'x+' + mode, **kwargs)
+            except FileExistsError:
+                pass
+
     def lock(self):
         """Lock the mailbox."""
         if not self._locked:
-            self._file = open(os.path.join(self._path, '.mh_sequences'), 'rb+')
+            self._file = self._open_mh_sequences_file(text=False)
             _lock_file(self._file)
             self._locked = True
 
@@ -1146,7 +1217,11 @@ def remove_folder(self, folder):
     def get_sequences(self):
         """Return a name-to-key-list dictionary to define each sequence."""
         results = {}
-        with open(os.path.join(self._path, '.mh_sequences'), 'r', encoding='ASCII') as f:
+        try:
+            f = open(os.path.join(self._path, '.mh_sequences'), 'r', encoding='ASCII')
+        except FileNotFoundError:
+            return results
+        with f:
             all_keys = set(self.keys())
             for line in f:
                 try:
@@ -1169,7 +1244,7 @@ def get_sequences(self):
 
     def set_sequences(self, sequences):
         """Set sequences using the given name-to-key-list dictionary."""
-        f = open(os.path.join(self._path, '.mh_sequences'), 'r+', encoding='ASCII')
+        f = self._open_mh_sequences_file(text=True)
         try:
             os.close(os.open(f.name, os.O_WRONLY | os.O_TRUNC))
             for name, keys in sequences.items():
@@ -1956,10 +2031,7 @@ def readlines(self, sizehint=None):
 
     def __iter__(self):
         """Iterate over lines."""
-        while True:
-            line = self.readline()
-            if not line:
-                return
+        while line := self.readline():
             yield line
 
     def tell(self):
diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
index 74ebcb2fe70..1726975e864 100644
--- a/Lib/test/test_hmac.py
+++ b/Lib/test/test_hmac.py
@@ -505,6 +505,14 @@ def test_exercise_all_methods(self):
             self.fail("Exception raised during normal usage of HMAC class.")
 
 
+class UpdateTestCase(unittest.TestCase):
+    @hashlib_helper.requires_hashdigest('sha256')
+    def test_with_str_update(self):
+        with self.assertRaises(TypeError):
+            h = hmac.new(b"key", digestmod='sha256')
+            h.update("invalid update")
+
+
 class CopyTestCase(unittest.TestCase):
 
     @hashlib_helper.requires_hashdigest('sha256')
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
new file mode 100644
index 00000000000..940baf39415
--- /dev/null
+++ b/Lib/test/test_mailbox.py
@@ -0,0 +1,2495 @@
+import os
+import sys
+import time
+import stat
+import socket
+import email
+import email.message
+import re
+import io
+import tempfile
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+from test.support import refleak_helper
+from test.support import socket_helper
+from test.support.testcase import ExtraAssertions
+import unittest
+import textwrap
+import mailbox
+import glob
+
+
+if not socket_helper.has_gethostname:
+    raise unittest.SkipTest("test requires gethostname()")
+
+
+class TestBase:
+
+    all_mailbox_types = (mailbox.Message, mailbox.MaildirMessage,
+                         mailbox.mboxMessage, mailbox.MHMessage,
+                         mailbox.BabylMessage, mailbox.MMDFMessage)
+
+    def _check_sample(self, msg):
+        # Inspect a mailbox.Message representation of the sample message
+        self.assertIsInstance(msg, email.message.Message)
+        self.assertIsInstance(msg, mailbox.Message)
+        for key, value in _sample_headers:
+            self.assertIn(value, msg.get_all(key))
+        self.assertTrue(msg.is_multipart())
+        self.assertEqual(len(msg.get_payload()), len(_sample_payloads))
+        for i, payload in enumerate(_sample_payloads):
+            part = msg.get_payload(i)
+            self.assertIsInstance(part, email.message.Message)
+            self.assertNotIsInstance(part, mailbox.Message)
+            self.assertEqual(part.get_payload(), payload)
+
+    def _delete_recursively(self, target):
+        # Delete a file or delete a directory recursively
+        if os.path.isdir(target):
+            os_helper.rmtree(target)
+        elif os.path.exists(target):
+            os_helper.unlink(target)
+
+
+class TestMailbox(TestBase):
+
+    maxDiff = None
+
+    _factory = None     # Overridden by subclasses to reuse tests
+    _template = 'From: foo\n\n%s\n'
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._delete_recursively(self._path)
+        self._box = self._factory(self._path)
+
+    def tearDown(self):
+        self._box.close()
+        self._delete_recursively(self._path)
+
+    def test_add(self):
+        # Add copies of a sample message
+        keys = []
+        keys.append(self._box.add(self._template % 0))
+        self.assertEqual(len(self._box), 1)
+        keys.append(self._box.add(mailbox.Message(_sample_message)))
+        self.assertEqual(len(self._box), 2)
+        keys.append(self._box.add(email.message_from_string(_sample_message)))
+        self.assertEqual(len(self._box), 3)
+        keys.append(self._box.add(io.BytesIO(_bytes_sample_message)))
+        self.assertEqual(len(self._box), 4)
+        keys.append(self._box.add(_sample_message))
+        self.assertEqual(len(self._box), 5)
+        keys.append(self._box.add(_bytes_sample_message))
+        self.assertEqual(len(self._box), 6)
+        with self.assertWarns(DeprecationWarning):
+            keys.append(self._box.add(
+                io.TextIOWrapper(io.BytesIO(_bytes_sample_message), encoding="utf-8")))
+        self.assertEqual(len(self._box), 7)
+        self.assertEqual(self._box.get_string(keys[0]), self._template % 0)
+        for i in (1, 2, 3, 4, 5, 6):
+            self._check_sample(self._box[keys[i]])
+
+    _nonascii_msg = textwrap.dedent("""\
+            From: foo
+            Subject: Falinaptár házhozszállítással. Már rendeltél?
+
+            0
+            """)
+
+    def test_add_invalid_8bit_bytes_header(self):
+        key = self._box.add(self._nonascii_msg.encode('latin-1'))
+        self.assertEqual(len(self._box), 1)
+        self.assertEqual(self._box.get_bytes(key),
+            self._nonascii_msg.encode('latin-1'))
+
+    def test_invalid_nonascii_header_as_string(self):
+        subj = self._nonascii_msg.splitlines()[1]
+        key = self._box.add(subj.encode('latin-1'))
+        self.assertEqual(self._box.get_string(key),
+            'Subject: =?unknown-8bit?b?RmFsaW5hcHThciBo4Xpob3pzeuFsbO104XNz'
+            'YWwuIE3hciByZW5kZWx06Ww/?=\n\n')
+
+    def test_add_nonascii_string_header_raises(self):
+        with self.assertRaisesRegex(ValueError, "ASCII-only"):
+            self._box.add(self._nonascii_msg)
+        self._box.flush()
+        self.assertEqual(len(self._box), 0)
+        self.assertMailboxEmpty()
+
+    def test_add_that_raises_leaves_mailbox_empty(self):
+        class CustomError(Exception): ...
+        exc_msg = "a fake error"
+
+        def raiser(*args, **kw):
+            raise CustomError(exc_msg)
+        support.patch(self, email.generator.BytesGenerator, 'flatten', raiser)
+        with self.assertRaisesRegex(CustomError, exc_msg):
+            self._box.add(email.message_from_string("From: Alphöso"))
+        self.assertEqual(len(self._box), 0)
+        self._box.close()
+        self.assertMailboxEmpty()
+
+    _non_latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: báz
+        Subject: Maintenant je vous présente mon collègue, le pouf célèbre
+        \tJean de Baddie
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: 8bit
+
+        Да, они лет�т.
+        """).encode('utf-8')
+
+    def test_add_8bit_body(self):
+        key = self._box.add(self._non_latin_bin_msg)
+        self.assertEqual(self._box.get_bytes(key),
+                         self._non_latin_bin_msg)
+        with self._box.get_file(key) as f:
+            self.assertEqual(f.read(),
+                             self._non_latin_bin_msg.replace(b'\n',
+                                os.linesep.encode()))
+        self.assertEqual(self._box[key].get_payload(),
+                        "Да, они лет�т.\n")
+
+    def test_add_binary_file(self):
+        with tempfile.TemporaryFile('wb+') as f:
+            f.write(_bytes_sample_message)
+            f.seek(0)
+            key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            _bytes_sample_message.split(b'\n'))
+
+    def test_add_binary_nonascii_file(self):
+        with tempfile.TemporaryFile('wb+') as f:
+            f.write(self._non_latin_bin_msg)
+            f.seek(0)
+            key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            self._non_latin_bin_msg.split(b'\n'))
+
+    def test_add_text_file_warns(self):
+        with tempfile.TemporaryFile('w+', encoding='utf-8') as f:
+            f.write(_sample_message)
+            f.seek(0)
+            with self.assertWarns(DeprecationWarning):
+                key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            _bytes_sample_message.split(b'\n'))
+
+    def test_add_StringIO_warns(self):
+        with self.assertWarns(DeprecationWarning):
+            key = self._box.add(io.StringIO(self._template % "0"))
+        self.assertEqual(self._box.get_string(key), self._template % "0")
+
+    def test_add_nonascii_StringIO_raises(self):
+        with self.assertWarns(DeprecationWarning):
+            with self.assertRaisesRegex(ValueError, "ASCII-only"):
+                self._box.add(io.StringIO(self._nonascii_msg))
+        self.assertEqual(len(self._box), 0)
+        self._box.close()
+        self.assertMailboxEmpty()
+
+    def test_remove(self):
+        # Remove messages using remove()
+        self._test_remove_or_delitem(self._box.remove)
+
+    def test_delitem(self):
+        # Remove messages using __delitem__()
+        self._test_remove_or_delitem(self._box.__delitem__)
+
+    def _test_remove_or_delitem(self, method):
+        # (Used by test_remove() and test_delitem().)
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(len(self._box), 2)
+        method(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+        self.assertRaises(KeyError, lambda: method(key0))
+        self.assertEqual(self._box.get_string(key1), self._template % 1)
+        key2 = self._box.add(self._template % 2)
+        self.assertEqual(len(self._box), 2)
+        method(key2)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key2])
+        self.assertRaises(KeyError, lambda: method(key2))
+        self.assertEqual(self._box.get_string(key1), self._template % 1)
+        method(key1)
+        self.assertEqual(len(self._box), 0)
+        self.assertRaises(KeyError, lambda: self._box[key1])
+        self.assertRaises(KeyError, lambda: method(key1))
+
+    def test_discard(self, repetitions=10):
+        # Discard messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(len(self._box), 2)
+        self._box.discard(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+        self._box.discard(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+
+    def test_get(self):
+        # Retrieve messages using get()
+        key0 = self._box.add(self._template % 0)
+        msg = self._box.get(key0)
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '0\n')
+        self.assertIsNone(self._box.get('foo'))
+        self.assertIs(self._box.get('foo', False), False)
+        self._box.close()
+        self._box = self._factory(self._path)
+        key1 = self._box.add(self._template % 1)
+        msg = self._box.get(key1)
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '1\n')
+
+    def test_getitem(self):
+        # Retrieve message using __getitem__()
+        key0 = self._box.add(self._template % 0)
+        msg = self._box[key0]
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '0\n')
+        self.assertRaises(KeyError, lambda: self._box['foo'])
+        self._box.discard(key0)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+
+    def test_get_message(self):
+        # Get Message representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        msg0 = self._box.get_message(key0)
+        self.assertIsInstance(msg0, mailbox.Message)
+        self.assertEqual(msg0['from'], 'foo')
+        self.assertEqual(msg0.get_payload(), '0\n')
+        self._check_sample(self._box.get_message(key1))
+
+    def test_get_bytes(self):
+        # Get bytes representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        self.assertEqual(self._box.get_bytes(key0),
+            (self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1), _bytes_sample_message)
+
+    def test_get_string(self):
+        # Get string representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        self.assertEqual(self._box.get_string(key0), self._template % 0)
+        self.assertEqual(self._box.get_string(key1).split('\n'),
+                         _sample_message.split('\n'))
+
+    def test_get_file(self):
+        # Get file representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        with self._box.get_file(key0) as file:
+            data0 = file.read()
+        with self._box.get_file(key1) as file:
+            data1 = file.read()
+        self.assertEqual(data0.decode('ascii').replace(os.linesep, '\n'),
+                         self._template % 0)
+        self.assertEqual(data1.decode('ascii').replace(os.linesep, '\n'),
+                         _sample_message)
+
+    def test_get_file_can_be_closed_twice(self):
+        # Issue 11700
+        key = self._box.add(_sample_message)
+        f = self._box.get_file(key)
+        f.close()
+        f.close()
+
+    def test_iterkeys(self):
+        # Get keys using iterkeys()
+        self._check_iteration(self._box.iterkeys, do_keys=True, do_values=False)
+
+    def test_keys(self):
+        # Get keys using keys()
+        self._check_iteration(self._box.keys, do_keys=True, do_values=False)
+
+    def test_itervalues(self):
+        # Get values using itervalues()
+        self._check_iteration(self._box.itervalues, do_keys=False,
+                              do_values=True)
+
+    def test_iter(self):
+        # Get values using __iter__()
+        self._check_iteration(self._box.__iter__, do_keys=False,
+                              do_values=True)
+
+    def test_values(self):
+        # Get values using values()
+        self._check_iteration(self._box.values, do_keys=False, do_values=True)
+
+    def test_iteritems(self):
+        # Get keys and values using iteritems()
+        self._check_iteration(self._box.iteritems, do_keys=True,
+                              do_values=True)
+
+    def test_items(self):
+        # Get keys and values using items()
+        self._check_iteration(self._box.items, do_keys=True, do_values=True)
+
+    def _check_iteration(self, method, do_keys, do_values, repetitions=10):
+        for value in method():
+            self.fail("Not empty")
+        keys, values = [], []
+        for i in range(repetitions):
+            keys.append(self._box.add(self._template % i))
+            values.append(self._template % i)
+        if do_keys and not do_values:
+            returned_keys = list(method())
+        elif do_values and not do_keys:
+            returned_values = list(method())
+        else:
+            returned_keys, returned_values = [], []
+            for key, value in method():
+                returned_keys.append(key)
+                returned_values.append(value)
+        if do_keys:
+            self.assertEqual(len(keys), len(returned_keys))
+            self.assertEqual(set(keys), set(returned_keys))
+        if do_values:
+            count = 0
+            for value in returned_values:
+                self.assertEqual(value['from'], 'foo')
+                self.assertLess(int(value.get_payload()), repetitions)
+                count += 1
+            self.assertEqual(len(values), count)
+
+    def test_contains(self):
+        # Check existence of keys using __contains__()
+        self.assertNotIn('foo', self._box)
+        key0 = self._box.add(self._template % 0)
+        self.assertIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+        key1 = self._box.add(self._template % 1)
+        self.assertIn(key1, self._box)
+        self.assertIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+        self._box.remove(key0)
+        self.assertNotIn(key0, self._box)
+        self.assertIn(key1, self._box)
+        self.assertNotIn('foo', self._box)
+        self._box.remove(key1)
+        self.assertNotIn(key1, self._box)
+        self.assertNotIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+
+    def test_len(self, repetitions=10):
+        # Get message count
+        keys = []
+        for i in range(repetitions):
+            self.assertEqual(len(self._box), i)
+            keys.append(self._box.add(self._template % i))
+            self.assertEqual(len(self._box), i + 1)
+        for i in range(repetitions):
+            self.assertEqual(len(self._box), repetitions - i)
+            self._box.remove(keys[i])
+            self.assertEqual(len(self._box), repetitions - i - 1)
+
+    def test_set_item(self):
+        # Modify messages using __setitem__()
+        key0 = self._box.add(self._template % 'original 0')
+        self.assertEqual(self._box.get_string(key0),
+                         self._template % 'original 0')
+        key1 = self._box.add(self._template % 'original 1')
+        self.assertEqual(self._box.get_string(key1),
+                         self._template % 'original 1')
+        self._box[key0] = self._template % 'changed 0'
+        self.assertEqual(self._box.get_string(key0),
+                         self._template % 'changed 0')
+        self._box[key1] = self._template % 'changed 1'
+        self.assertEqual(self._box.get_string(key1),
+                         self._template % 'changed 1')
+        self._box[key0] = _sample_message
+        self._check_sample(self._box[key0])
+        self._box[key1] = self._box[key0]
+        self._check_sample(self._box[key1])
+        self._box[key0] = self._template % 'original 0'
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'original 0')
+        self._check_sample(self._box[key1])
+        self.assertRaises(KeyError,
+                          lambda: self._box.__setitem__('foo', 'bar'))
+        self.assertRaises(KeyError, lambda: self._box['foo'])
+        self.assertEqual(len(self._box), 2)
+
+    def test_clear(self, iterations=10):
+        # Remove all messages using clear()
+        keys = []
+        for i in range(iterations):
+            self._box.add(self._template % i)
+        for i, key in enumerate(keys):
+            self.assertEqual(self._box.get_string(key), self._template % i)
+        self._box.clear()
+        self.assertEqual(len(self._box), 0)
+        for i, key in enumerate(keys):
+            self.assertRaises(KeyError, lambda: self._box.get_string(key))
+
+    def test_pop(self):
+        # Get and remove a message using pop()
+        key0 = self._box.add(self._template % 0)
+        self.assertIn(key0, self._box)
+        key1 = self._box.add(self._template % 1)
+        self.assertIn(key1, self._box)
+        self.assertEqual(self._box.pop(key0).get_payload(), '0\n')
+        self.assertNotIn(key0, self._box)
+        self.assertIn(key1, self._box)
+        key2 = self._box.add(self._template % 2)
+        self.assertIn(key2, self._box)
+        self.assertEqual(self._box.pop(key2).get_payload(), '2\n')
+        self.assertNotIn(key2, self._box)
+        self.assertIn(key1, self._box)
+        self.assertEqual(self._box.pop(key1).get_payload(), '1\n')
+        self.assertNotIn(key1, self._box)
+        self.assertEqual(len(self._box), 0)
+
+    def test_popitem(self, iterations=10):
+        # Get and remove an arbitrary (key, message) using popitem()
+        keys = []
+        for i in range(10):
+            keys.append(self._box.add(self._template % i))
+        seen = []
+        for i in range(10):
+            key, msg = self._box.popitem()
+            self.assertIn(key, keys)
+            self.assertNotIn(key, seen)
+            seen.append(key)
+            self.assertEqual(int(msg.get_payload()), keys.index(key))
+        self.assertEqual(len(self._box), 0)
+        for key in keys:
+            self.assertRaises(KeyError, lambda: self._box[key])
+
+    def test_update(self):
+        # Modify multiple messages using update()
+        key0 = self._box.add(self._template % 'original 0')
+        key1 = self._box.add(self._template % 'original 1')
+        key2 = self._box.add(self._template % 'original 2')
+        self._box.update({key0: self._template % 'changed 0',
+                          key2: _sample_message})
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'changed 0')
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % 'original 1')
+        self._check_sample(self._box[key2])
+        self._box.update([(key2, self._template % 'changed 2'),
+                    (key1, self._template % 'changed 1'),
+                    (key0, self._template % 'original 0')])
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'original 0')
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % 'changed 1')
+        self.assertEqual(self._box.get_string(key2),
+                     self._template % 'changed 2')
+        self.assertRaises(KeyError,
+                          lambda: self._box.update({'foo': 'bar',
+                                          key0: self._template % "changed 0"}))
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % "changed 0")
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % "changed 1")
+        self.assertEqual(self._box.get_string(key2),
+                     self._template % "changed 2")
+
+    def test_flush(self):
+        # Write changes to disk
+        self._test_flush_or_close(self._box.flush, True)
+
+    def test_popitem_and_flush_twice(self):
+        # See #15036.
+        self._box.add(self._template % 0)
+        self._box.add(self._template % 1)
+        self._box.flush()
+
+        self._box.popitem()
+        self._box.flush()
+        self._box.popitem()
+        self._box.flush()
+
+    def test_lock_unlock(self):
+        # Lock and unlock the mailbox
+        self.assertFalse(os.path.exists(self._get_lock_path()))
+        self._box.lock()
+        self.assertTrue(os.path.exists(self._get_lock_path()))
+        self._box.unlock()
+        self.assertFalse(os.path.exists(self._get_lock_path()))
+
+    def test_close(self):
+        # Close mailbox and flush changes to disk
+        self._test_flush_or_close(self._box.close, False)
+
+    def _test_flush_or_close(self, method, should_call_close):
+        contents = [self._template % i for i in range(3)]
+        self._box.add(contents[0])
+        self._box.add(contents[1])
+        self._box.add(contents[2])
+        oldbox = self._box
+        method()
+        if should_call_close:
+            self._box.close()
+        self._box = self._factory(self._path)
+        keys = self._box.keys()
+        self.assertEqual(len(keys), 3)
+        for key in keys:
+            self.assertIn(self._box.get_string(key), contents)
+        oldbox.close()
+
+    def test_dump_message(self):
+        # Write message representations to disk
+        for input in (email.message_from_string(_sample_message),
+                      _sample_message, io.BytesIO(_bytes_sample_message)):
+            output = io.BytesIO()
+            self._box._dump_message(input, output)
+            self.assertEqual(output.getvalue(),
+                _bytes_sample_message.replace(b'\n', os.linesep.encode()))
+        output = io.BytesIO()
+        self.assertRaises(TypeError,
+                          lambda: self._box._dump_message(None, output))
+
+    def _get_lock_path(self):
+        # Return the path of the dot lock file. May be overridden.
+        return self._path + '.lock'
+
+
+class TestMailboxSuperclass(TestBase, unittest.TestCase):
+
+    def test_notimplemented(self):
+        # Test that all Mailbox methods raise NotImplementedException.
+        box = mailbox.Mailbox('path')
+        self.assertRaises(NotImplementedError, lambda: box.add(''))
+        self.assertRaises(NotImplementedError, lambda: box.remove(''))
+        self.assertRaises(NotImplementedError, lambda: box.__delitem__(''))
+        self.assertRaises(NotImplementedError, lambda: box.discard(''))
+        self.assertRaises(NotImplementedError, lambda: box.__setitem__('', ''))
+        self.assertRaises(NotImplementedError, lambda: box.iterkeys())
+        self.assertRaises(NotImplementedError, lambda: box.keys())
+        self.assertRaises(NotImplementedError, lambda: box.itervalues().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.__iter__().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.values())
+        self.assertRaises(NotImplementedError, lambda: box.iteritems().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.items())
+        self.assertRaises(NotImplementedError, lambda: box.get(''))
+        self.assertRaises(NotImplementedError, lambda: box.__getitem__(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_message(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_string(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_bytes(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_file(''))
+        self.assertRaises(NotImplementedError, lambda: '' in box)
+        self.assertRaises(NotImplementedError, lambda: box.__contains__(''))
+        self.assertRaises(NotImplementedError, lambda: box.__len__())
+        self.assertRaises(NotImplementedError, lambda: box.clear())
+        self.assertRaises(NotImplementedError, lambda: box.pop(''))
+        self.assertRaises(NotImplementedError, lambda: box.popitem())
+        self.assertRaises(NotImplementedError, lambda: box.update((('', ''),)))
+        self.assertRaises(NotImplementedError, lambda: box.flush())
+        self.assertRaises(NotImplementedError, lambda: box.lock())
+        self.assertRaises(NotImplementedError, lambda: box.unlock())
+        self.assertRaises(NotImplementedError, lambda: box.close())
+
+
+class TestMaildir(TestMailbox, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.Maildir(path, factory)
+
+    def setUp(self):
+        TestMailbox.setUp(self)
+        if (os.name == 'nt') or (sys.platform == 'cygwin'):
+            self._box.colon = '!'
+
+    def assertMailboxEmpty(self):
+        self.assertEqual(os.listdir(os.path.join(self._path, 'tmp')), [])
+
+    def test_add_MM(self):
+        # Add a MaildirMessage instance
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_info('foo')
+        key = self._box.add(msg)
+        self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' %
+                                                 (key, self._box.colon))))
+
+    def test_get_MM(self):
+        # Get a MaildirMessage instance
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_flags('RF')
+        key = self._box.add(msg)
+        msg_returned = self._box.get_message(key)
+        self.assertIsInstance(msg_returned, mailbox.MaildirMessage)
+        self.assertEqual(msg_returned.get_subdir(), 'cur')
+        self.assertEqual(msg_returned.get_flags(), 'FR')
+
+    def test_set_MM(self):
+        # Set with a MaildirMessage instance
+        msg0 = mailbox.MaildirMessage(self._template % 0)
+        msg0.set_flags('TP')
+        key = self._box.add(msg0)
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), 'PT')
+        msg1 = mailbox.MaildirMessage(self._template % 1)
+        self._box[key] = msg1
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), '')
+        self.assertEqual(msg_returned.get_payload(), '1\n')
+        msg2 = mailbox.MaildirMessage(self._template % 2)
+        msg2.set_info('2,S')
+        self._box[key] = msg2
+        self._box[key] = self._template % 3
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), 'S')
+        self.assertEqual(msg_returned.get_payload(), '3\n')
+
+    def test_consistent_factory(self):
+        # Add a message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_flags('RF')
+        key = self._box.add(msg)
+
+        # Create new mailbox with
+        class FakeMessage(mailbox.MaildirMessage):
+            pass
+        box = mailbox.Maildir(self._path, factory=FakeMessage)
+        box.colon = self._box.colon
+        msg2 = box.get_message(key)
+        self.assertIsInstance(msg2, FakeMessage)
+
+    def test_initialize_new(self):
+        # Initialize a non-existent mailbox
+        self.tearDown()
+        self._box = mailbox.Maildir(self._path)
+        self._check_basics()
+        self._delete_recursively(self._path)
+        self._box = self._factory(self._path, factory=None)
+        self._check_basics()
+
+    def test_initialize_existing(self):
+        # Initialize an existing mailbox
+        self.tearDown()
+        for subdir in '', 'tmp', 'new', 'cur':
+            os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
+        self._box = mailbox.Maildir(self._path)
+        self._check_basics()
+
+    def test_filename_leading_dot(self):
+        self.tearDown()
+        for subdir in '', 'tmp', 'new', 'cur':
+            os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
+        for subdir in 'tmp', 'new', 'cur':
+            fname = os.path.join(self._path, subdir, '.foo' + subdir)
+            with open(fname, 'wb') as f:
+                f.write(b"@")
+        self._box = mailbox.Maildir(self._path)
+        self.assertNotIn('.footmp', self._box)
+        self.assertNotIn('.foonew', self._box)
+        self.assertNotIn('.foocur', self._box)
+        self.assertEqual(list(self._box.iterkeys()), [])
+
+    def _check_basics(self, factory=None):
+        # (Used by test_open_new() and test_open_existing().)
+        self.assertEqual(self._box._path, os.path.abspath(self._path))
+        self.assertEqual(self._box._factory, factory)
+        for subdir in '', 'tmp', 'new', 'cur':
+            path = os.path.join(self._path, subdir)
+            self.assertTrue(os.path.isdir(path), f"Not a directory: {path!r}")
+
+    def test_list_folders(self):
+        # List folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 3)
+        self.assertEqual(set(self._box.list_folders()),
+                     set(('one', 'two', 'three')))
+
+    def test_get_folder(self):
+        # Open folders
+        self._box.add_folder('foo.bar')
+        folder0 = self._box.get_folder('foo.bar')
+        folder0.add(self._template % 'bar')
+        self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar')))
+        folder1 = self._box.get_folder('foo.bar')
+        self.assertEqual(folder1.get_string(folder1.keys()[0]),
+                         self._template % 'bar')
+
+    def test_add_and_remove_folders(self):
+        # Delete folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
+        self._box.remove_folder('one')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
+        self._box.remove_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.remove_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 0)
+        self.assertEqual(self._box.list_folders(), [])
+
+    def test_clean(self):
+        # Remove old files from 'tmp'
+        foo_path = os.path.join(self._path, 'tmp', 'foo')
+        bar_path = os.path.join(self._path, 'tmp', 'bar')
+        with open(foo_path, 'w', encoding='utf-8') as f:
+            f.write("@")
+        with open(bar_path, 'w', encoding='utf-8') as f:
+            f.write("@")
+        self._box.clean()
+        self.assertTrue(os.path.exists(foo_path))
+        self.assertTrue(os.path.exists(bar_path))
+        foo_stat = os.stat(foo_path)
+        os.utime(foo_path, (time.time() - 129600 - 2,
+                            foo_stat.st_mtime))
+        self._box.clean()
+        self.assertFalse(os.path.exists(foo_path))
+        self.assertTrue(os.path.exists(bar_path))
+
+    def test_create_tmp(self, repetitions=10):
+        # Create files in tmp directory
+        hostname = socket.gethostname()
+        if '/' in hostname:
+            hostname = hostname.replace('/', r'\057')
+        if ':' in hostname:
+            hostname = hostname.replace(':', r'\072')
+        pid = os.getpid()
+        pattern = re.compile(r"(?P<time>\d+)\.M(?P<M>\d{1,6})P(?P<P>\d+)"
+                             r"Q(?P<Q>\d+)\.(?P<host>[^:/]*)")
+        previous_groups = None
+        for x in range(repetitions):
+            tmp_file = self._box._create_tmp()
+            head, tail = os.path.split(tmp_file.name)
+            self.assertEqual(head, os.path.abspath(os.path.join(self._path,
+                                                                "tmp")),
+                             "File in wrong location: '%s'" % head)
+            match = pattern.match(tail)
+            self.assertIsNotNone(match, "Invalid file name: '%s'" % tail)
+            groups = match.groups()
+            if previous_groups is not None:
+                self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]),
+                             "Non-monotonic seconds: '%s' before '%s'" %
+                             (previous_groups[0], groups[0]))
+                if int(groups[0]) == int(previous_groups[0]):
+                    self.assertGreaterEqual(int(groups[1]), int(previous_groups[1]),
+                                "Non-monotonic milliseconds: '%s' before '%s'" %
+                                (previous_groups[1], groups[1]))
+                self.assertEqual(int(groups[2]), pid,
+                             "Process ID mismatch: '%s' should be '%s'" %
+                             (groups[2], pid))
+                self.assertEqual(int(groups[3]), int(previous_groups[3]) + 1,
+                             "Non-sequential counter: '%s' before '%s'" %
+                             (previous_groups[3], groups[3]))
+                self.assertEqual(groups[4], hostname,
+                             "Host name mismatch: '%s' should be '%s'" %
+                             (groups[4], hostname))
+            previous_groups = groups
+            tmp_file.write(_bytes_sample_message)
+            tmp_file.seek(0)
+            self.assertEqual(tmp_file.read(), _bytes_sample_message)
+            tmp_file.close()
+        file_count = len(os.listdir(os.path.join(self._path, "tmp")))
+        self.assertEqual(file_count, repetitions,
+                     "Wrong file count: '%s' should be '%s'" %
+                     (file_count, repetitions))
+
+    def test_refresh(self):
+        # Update the table of contents
+        self.assertEqual(self._box._toc, {})
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(self._box._toc, {})
+        self._box._refresh()
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1)})
+        key2 = self._box.add(self._template % 2)
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1)})
+        self._box._refresh()
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1),
+                                          key2: os.path.join('new', key2)})
+
+    def test_refresh_after_safety_period(self):
+        # Issue #13254: Call _refresh after the "file system safety
+        # period" of 2 seconds has passed; _toc should still be
+        # updated because this is the first call to _refresh.
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+
+        self._box = self._factory(self._path)
+        self.assertEqual(self._box._toc, {})
+
+        # Emulate sleeping. Instead of sleeping for 2 seconds, use the
+        # skew factor to make _refresh think that the filesystem
+        # safety period has passed and re-reading the _toc is only
+        # required if mtimes differ.
+        self._box._skewfactor = -3
+
+        self._box._refresh()
+        self.assertEqual(sorted(self._box._toc.keys()), sorted([key0, key1]))
+
+    def test_lookup(self):
+        # Look up message subpaths in the TOC
+        self.assertRaises(KeyError, lambda: self._box._lookup('foo'))
+        key0 = self._box.add(self._template % 0)
+        self.assertEqual(self._box._lookup(key0), os.path.join('new', key0))
+        os.remove(os.path.join(self._path, 'new', key0))
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0)})
+        # Be sure that the TOC is read back from disk (see issue #6896
+        # about bad mtime behaviour on some systems).
+        self._box.flush()
+        self.assertRaises(KeyError, lambda: self._box._lookup(key0))
+        self.assertEqual(self._box._toc, {})
+
+    def test_lock_unlock(self):
+        # Lock and unlock the mailbox. For Maildir, this does nothing.
+        self._box.lock()
+        self._box.unlock()
+
+    def test_get_info(self):
+        # Test getting message info from Maildir, not the message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_info(key), '')
+        msg.set_info('OurTestInfo')
+        self._box[key] = msg
+        self.assertEqual(self._box.get_info(key), 'OurTestInfo')
+
+    def test_set_info(self):
+        # Test setting message info from Maildir, not the message.
+        # This should immediately rename the message file.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        def check_info(oldinfo, newinfo):
+            oldfilename = os.path.join(self._box._path, self._box._lookup(key))
+            newsubpath = self._box._lookup(key).split(self._box.colon)[0]
+            if newinfo:
+                newsubpath += self._box.colon + newinfo
+            newfilename = os.path.join(self._box._path, newsubpath)
+            # assert initial conditions
+            self.assertEqual(self._box.get_info(key), oldinfo)
+            if not oldinfo:
+                self.assertNotIn(self._box._lookup(key), self._box.colon)
+            self.assertTrue(os.path.exists(oldfilename))
+            if oldinfo != newinfo:
+                self.assertFalse(os.path.exists(newfilename))
+            # do the rename
+            self._box.set_info(key, newinfo)
+            # assert post conditions
+            if not newinfo:
+                self.assertNotIn(self._box._lookup(key), self._box.colon)
+            if oldinfo != newinfo:
+                self.assertFalse(os.path.exists(oldfilename))
+            self.assertTrue(os.path.exists(newfilename))
+            self.assertEqual(self._box.get_info(key), newinfo)
+        # none -> has info
+        check_info('', 'info1')
+        # has info -> same info
+        check_info('info1', 'info1')
+        # has info -> different info
+        check_info('info1', 'info2')
+        # has info -> none
+        check_info('info2', '')
+        # none -> none
+        check_info('', '')
+
+    def test_get_flags(self):
+        # Test getting message flags from Maildir, not the message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        msg.set_flags('T')
+        self._box[key] = msg
+        self.assertEqual(self._box.get_flags(key), 'T')
+
+    def test_set_flags(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        self._box.set_flags(key, 'S')
+        self.assertEqual(self._box.get_flags(key), 'S')
+
+    def test_add_flag(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        self._box.add_flag(key, 'B')
+        self.assertEqual(self._box.get_flags(key), 'B')
+        self._box.add_flag(key, 'B')
+        self.assertEqual(self._box.get_flags(key), 'B')
+        self._box.add_flag(key, 'AC')
+        self.assertEqual(self._box.get_flags(key), 'ABC')
+
+    def test_remove_flag(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self._box.set_flags(key, 'abc')
+        self.assertEqual(self._box.get_flags(key), 'abc')
+        self._box.remove_flag(key, 'b')
+        self.assertEqual(self._box.get_flags(key), 'ac')
+        self._box.remove_flag(key, 'b')
+        self.assertEqual(self._box.get_flags(key), 'ac')
+        self._box.remove_flag(key, 'ac')
+        self.assertEqual(self._box.get_flags(key), '')
+
+    def test_folder (self):
+        # Test for bug #1569790: verify that folders returned by .get_folder()
+        # use the same factory function.
+        def dummy_factory (s):
+            return None
+        box = self._factory(self._path, factory=dummy_factory)
+        folder = box.add_folder('folder1')
+        self.assertIs(folder._factory, dummy_factory)
+
+        folder1_alias = box.get_folder('folder1')
+        self.assertIs(folder1_alias._factory, dummy_factory)
+
+    def test_directory_in_folder (self):
+        # Test that mailboxes still work if there's a stray extra directory
+        # in a folder.
+        for i in range(10):
+            self._box.add(mailbox.Message(_sample_message))
+
+        # Create a stray directory
+        os.mkdir(os.path.join(self._path, 'cur', 'stray-dir'))
+
+        # Check that looping still works with the directory present.
+        for msg in self._box:
+            pass
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_file_permissions(self):
+        # Verify that message files are created without execute permissions
+        msg = mailbox.MaildirMessage(self._template % 0)
+        orig_umask = os.umask(0)
+        try:
+            key = self._box.add(msg)
+        finally:
+            os.umask(orig_umask)
+        path = os.path.join(self._path, self._box._lookup(key))
+        mode = os.stat(path).st_mode
+        self.assertFalse(mode & 0o111)
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_folder_file_perms(self):
+        # From bug #3228, we want to verify that the file created inside a Maildir
+        # subfolder isn't marked as executable.
+        orig_umask = os.umask(0)
+        try:
+            subfolder = self._box.add_folder('subfolder')
+        finally:
+            os.umask(orig_umask)
+
+        path = os.path.join(subfolder._path, 'maildirfolder')
+        st = os.stat(path)
+        perms = st.st_mode
+        self.assertFalse((perms & 0o111)) # Execute bits should all be off.
+
+    def test_reread(self):
+        # Do an initial unconditional refresh
+        self._box._refresh()
+
+        # Put the last modified times more than two seconds into the past
+        # (because mtime may have a two second granularity)
+        for subdir in ('cur', 'new'):
+            os.utime(os.path.join(self._box._path, subdir),
+                     (time.time()-5,)*2)
+
+        # Because mtime has a two second granularity in worst case (FAT), a
+        # refresh is done unconditionally if called for within
+        # two-second-plus-a-bit of the last one, just in case the mbox has
+        # changed; so now we have to wait for that interval to expire.
+        #
+        # Because this is a test, emulate sleeping. Instead of
+        # sleeping for 2 seconds, use the skew factor to make _refresh
+        # think that 2 seconds have passed and re-reading the _toc is
+        # only required if mtimes differ.
+        self._box._skewfactor = -3
+
+        # Re-reading causes the ._toc attribute to be assigned a new dictionary
+        # object, so we'll check that the ._toc attribute isn't a different
+        # object.
+        orig_toc = self._box._toc
+        def refreshed():
+            return self._box._toc is not orig_toc
+
+        self._box._refresh()
+        self.assertFalse(refreshed())
+
+        # Now, write something into cur and remove it.  This changes
+        # the mtime and should cause a re-read. Note that "sleep
+        # emulation" is still in effect, as skewfactor is -3.
+        filename = os.path.join(self._path, 'cur', 'stray-file')
+        os_helper.create_empty_file(filename)
+        os.unlink(filename)
+        self._box._refresh()
+        self.assertTrue(refreshed())
+
+
+class _TestSingleFile(TestMailbox):
+    '''Common tests for single-file mailboxes'''
+
+    def test_add_doesnt_rewrite(self):
+        # When only adding messages, flush() should not rewrite the
+        # mailbox file. See issue #9559.
+
+        # Inode number changes if the contents are written to another
+        # file which is then renamed over the original file. So we
+        # must check that the inode number doesn't change.
+        inode_before = os.stat(self._path).st_ino
+
+        self._box.add(self._template % 0)
+        self._box.flush()
+
+        inode_after = os.stat(self._path).st_ino
+        self.assertEqual(inode_before, inode_after)
+
+        # Make sure the message was really added
+        self._box.close()
+        self._box = self._factory(self._path)
+        self.assertEqual(len(self._box), 1)
+
+    def test_permissions_after_flush(self):
+        # See issue #5346
+
+        # Make the mailbox world writable. It's unlikely that the new
+        # mailbox file would have these permissions after flush(),
+        # because umask usually prevents it.
+        mode = os.stat(self._path).st_mode | 0o666
+        os.chmod(self._path, mode)
+
+        self._box.add(self._template % 0)
+        i = self._box.add(self._template % 1)
+        # Need to remove one message to make flush() create a new file
+        self._box.remove(i)
+        self._box.flush()
+
+        self.assertEqual(os.stat(self._path).st_mode, mode)
+
+    @unittest.skipUnless(hasattr(os, 'chown'), 'requires os.chown')
+    def test_ownership_after_flush(self):
+        # See issue gh-117467
+
+        pwd = import_helper.import_module('pwd')
+        grp = import_helper.import_module('grp')
+        st = os.stat(self._path)
+
+        for e in pwd.getpwall():
+            if e.pw_uid != st.st_uid:
+                other_uid = e.pw_uid
+                break
+        else:
+            self.skipTest("test needs more than one user")
+
+        for e in grp.getgrall():
+            if e.gr_gid != st.st_gid:
+                other_gid = e.gr_gid
+                break
+        else:
+            self.skipTest("test needs more than one group")
+
+        try:
+            os.chown(self._path, other_uid, other_gid)
+        except OSError:
+            self.skipTest('test needs root privilege')
+        # Change permissions as in test_permissions_after_flush.
+        mode = st.st_mode | 0o666
+        os.chmod(self._path, mode)
+
+        self._box.add(self._template % 0)
+        i = self._box.add(self._template % 1)
+        # Need to remove one message to make flush() create a new file
+        self._box.remove(i)
+        self._box.flush()
+
+        st = os.stat(self._path)
+        self.assertEqual(st.st_uid, other_uid)
+        self.assertEqual(st.st_gid, other_gid)
+        self.assertEqual(st.st_mode, mode)
+
+
+class _TestMboxMMDF(_TestSingleFile):
+
+    def tearDown(self):
+        super().tearDown()
+        self._box.close()
+        self._delete_recursively(self._path)
+        for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
+            os_helper.unlink(lock_remnant)
+
+    def assertMailboxEmpty(self):
+        with open(self._path, 'rb') as f:
+            self.assertEqual(f.readlines(), [])
+
+    def test_get_bytes_from(self):
+        # Get bytes representations of messages with _unixfrom.
+        unixfrom = 'From foo@bar blah\n'
+        key0 = self._box.add(unixfrom + self._template % 0)
+        key1 = self._box.add(unixfrom + _sample_message)
+        self.assertEqual(self._box.get_bytes(key0, from_=False),
+            (self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1, from_=False),
+            _bytes_sample_message)
+        self.assertEqual(self._box.get_bytes(key0, from_=True),
+            (unixfrom + self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1, from_=True),
+            unixfrom.encode('ascii') + _bytes_sample_message)
+
+    def test_get_string_from(self):
+        # Get string representations of messages with _unixfrom.
+        unixfrom = 'From foo@bar blah\n'
+        key0 = self._box.add(unixfrom + self._template % 0)
+        key1 = self._box.add(unixfrom + _sample_message)
+        self.assertEqual(self._box.get_string(key0, from_=False),
+                         self._template % 0)
+        self.assertEqual(self._box.get_string(key1, from_=False).split('\n'),
+                         _sample_message.split('\n'))
+        self.assertEqual(self._box.get_string(key0, from_=True),
+                         unixfrom + self._template % 0)
+        self.assertEqual(self._box.get_string(key1, from_=True).split('\n'),
+                         (unixfrom + _sample_message).split('\n'))
+
+    def test_add_from_string(self):
+        # Add a string starting with 'From ' to the mailbox
+        key = self._box.add('From foo@bar blah\nFrom: foo\n\n0\n')
+        self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
+        self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
+        self.assertEqual(self._box[key].get_payload(), '0\n')
+
+    def test_add_from_bytes(self):
+        # Add a byte string starting with 'From ' to the mailbox
+        key = self._box.add(b'From foo@bar blah\nFrom: foo\n\n0\n')
+        self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
+        self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
+        self.assertEqual(self._box[key].get_payload(), '0\n')
+
+    def test_add_mbox_or_mmdf_message(self):
+        # Add an mboxMessage or MMDFMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg = class_('From foo@bar blah\nFrom: foo\n\n0\n')
+            key = self._box.add(msg)
+
+    def test_open_close_open(self):
+        # Open and inspect previously-created mailbox
+        values = [self._template % i for i in range(3)]
+        for value in values:
+            self._box.add(value)
+        self._box.close()
+        mtime = os.path.getmtime(self._path)
+        self._box = self._factory(self._path)
+        self.assertEqual(len(self._box), 3)
+        for key in self._box.iterkeys():
+            self.assertIn(self._box.get_string(key), values)
+        self._box.close()
+        self.assertEqual(mtime, os.path.getmtime(self._path))
+
+    def test_add_and_close(self):
+        # Verifying that closing a mailbox doesn't change added items
+        self._box.add(_sample_message)
+        for i in range(3):
+            self._box.add(self._template % i)
+        self._box.add(_sample_message)
+        self._box._file.flush()
+        self._box._file.seek(0)
+        contents = self._box._file.read()
+        self._box.close()
+        with open(self._path, 'rb') as f:
+            self.assertEqual(contents, f.read())
+        self._box = self._factory(self._path)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(socket, 'socketpair'), "Test needs socketpair().")
+    def test_lock_conflict(self):
+        # Fork off a child process that will lock the mailbox temporarily,
+        # unlock it and exit.
+        c, p = socket.socketpair()
+        self.addCleanup(c.close)
+        self.addCleanup(p.close)
+
+        pid = os.fork()
+        if pid == 0:
+            # child
+            try:
+                # lock the mailbox, and signal the parent it can proceed
+                self._box.lock()
+                c.send(b'c')
+
+                # wait until the parent is done, and unlock the mailbox
+                c.recv(1)
+                self._box.unlock()
+            finally:
+                os._exit(0)
+
+        # In the parent, wait until the child signals it locked the mailbox.
+        p.recv(1)
+        try:
+            self.assertRaises(mailbox.ExternalClashError,
+                              self._box.lock)
+        finally:
+            # Signal the child it can now release the lock and exit.
+            p.send(b'p')
+            # Wait for child to exit.  Locking should now succeed.
+            support.wait_process(pid, exitcode=0)
+
+        self._box.lock()
+        self._box.unlock()
+
+    def test_relock(self):
+        # Test case for bug #1575506: the mailbox class was locking the
+        # wrong file object in its flush() method.
+        msg = "Subject: sub\n\nbody\n"
+        key1 = self._box.add(msg)
+        self._box.flush()
+        self._box.close()
+
+        self._box = self._factory(self._path)
+        self._box.lock()
+        key2 = self._box.add(msg)
+        self._box.flush()
+        self.assertTrue(self._box._locked)
+        self._box.close()
+
+
+class TestMbox(_TestMboxMMDF, unittest.TestCase, ExtraAssertions):
+
+    _factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_file_perms(self):
+        # From bug #3228, we want to verify that the mailbox file isn't executable,
+        # even if the umask is set to something that would leave executable bits set.
+        # We only run this test on platforms that support umask.
+        try:
+            old_umask = os.umask(0o077)
+            self._box.close()
+            os.unlink(self._path)
+            self._box = mailbox.mbox(self._path, create=True)
+            self._box.add('')
+            self._box.close()
+        finally:
+            os.umask(old_umask)
+
+        st = os.stat(self._path)
+        perms = st.st_mode
+        self.assertFalse((perms & 0o111)) # Execute bits should all be off.
+
+    def test_terminating_newline(self):
+        message = email.message.Message()
+        message['From'] = 'john@example.com'
+        message.set_payload('No newline at the end')
+        i = self._box.add(message)
+
+        # A newline should have been appended to the payload
+        message = self._box.get(i)
+        self.assertEqual(message.get_payload(), 'No newline at the end\n')
+
+    def test_message_separator(self):
+        # Check there's always a single blank line after each message
+        self._box.add('From: foo\n\n0')  # No newline at the end
+        with open(self._path, encoding='utf-8') as f:
+            data = f.read()
+            self.assertEndsWith(data, '0\n\n')
+
+        self._box.add('From: foo\n\n0\n')  # Newline at the end
+        with open(self._path, encoding='utf-8') as f:
+            data = f.read()
+            self.assertEndsWith(data, '0\n\n')
+
+
+class TestMMDF(_TestMboxMMDF, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.MMDF(path, factory)
+
+
+class TestMH(TestMailbox, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.MH(path, factory)
+
+    def assertMailboxEmpty(self):
+        self.assertEqual(os.listdir(self._path), ['.mh_sequences'])
+
+    def test_list_folders(self):
+        # List folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 3)
+        self.assertEqual(set(self._box.list_folders()),
+                     set(('one', 'two', 'three')))
+
+    def test_get_folder(self):
+        # Open folders
+        def dummy_factory (s):
+            return None
+        self._box = self._factory(self._path, dummy_factory)
+
+        new_folder = self._box.add_folder('foo.bar')
+        folder0 = self._box.get_folder('foo.bar')
+        folder0.add(self._template % 'bar')
+        self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar')))
+        folder1 = self._box.get_folder('foo.bar')
+        self.assertEqual(folder1.get_string(folder1.keys()[0]),
+                         self._template % 'bar')
+
+        # Test for bug #1569790: verify that folders returned by .get_folder()
+        # use the same factory function.
+        self.assertIs(new_folder._factory, self._box._factory)
+        self.assertIs(folder0._factory, self._box._factory)
+
+    def test_add_and_remove_folders(self):
+        # Delete folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
+        self._box.remove_folder('one')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
+        self._box.remove_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.remove_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 0)
+        self.assertEqual(self._box.list_folders(), [])
+
+    def test_sequences(self):
+        # Get and set sequences
+        self.assertEqual(self._box.get_sequences(), {})
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg0.add_sequence('foo')
+        key0 = self._box.add(msg0)
+        self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
+        msg1 = mailbox.MHMessage(self._template % 1)
+        msg1.set_sequences(['bar', 'replied', 'foo'])
+        key1 = self._box.add(msg1)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]})
+        msg0.set_sequences(['flagged'])
+        self._box[key0] = msg0
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key1], 'bar':[key1], 'replied':[key1],
+                      'flagged':[key0]})
+        self._box.remove(key1)
+        self.assertEqual(self._box.get_sequences(), {'flagged':[key0]})
+
+        self._box.set_sequences({'foo':[key0]})
+        self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
+
+    def test_no_dot_mh_sequences_file(self):
+        path = os.path.join(self._path, 'foo.bar')
+        os.mkdir(path)
+        box = self._factory(path)
+        self.assertEqual(os.listdir(path), [])
+        self.assertEqual(box.get_sequences(), {})
+        self.assertEqual(os.listdir(path), [])
+        box.set_sequences({})
+        self.assertEqual(os.listdir(path), ['.mh_sequences'])
+
+    def test_lock_unlock_no_dot_mh_sequences_file(self):
+        path = os.path.join(self._path, 'foo.bar')
+        os.mkdir(path)
+        box = self._factory(path)
+        self.assertEqual(os.listdir(path), [])
+        box.lock()
+        box.unlock()
+        self.assertEqual(os.listdir(path), ['.mh_sequences'])
+
+    def test_issue2625(self):
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg0.add_sequence('foo')
+        key0 = self._box.add(msg0)
+        refmsg0 = self._box.get_message(key0)
+
+    def test_issue7627(self):
+        msg0 = mailbox.MHMessage(self._template % 0)
+        key0 = self._box.add(msg0)
+        self._box.lock()
+        self._box.remove(key0)
+        self._box.unlock()
+
+    def test_pack(self):
+        # Pack the contents of the mailbox
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg1 = mailbox.MHMessage(self._template % 1)
+        msg2 = mailbox.MHMessage(self._template % 2)
+        msg3 = mailbox.MHMessage(self._template % 3)
+        msg0.set_sequences(['foo', 'unseen'])
+        msg1.set_sequences(['foo'])
+        msg2.set_sequences(['foo', 'flagged'])
+        msg3.set_sequences(['foo', 'bar', 'replied'])
+        key0 = self._box.add(msg0)
+        key1 = self._box.add(msg1)
+        key2 = self._box.add(msg2)
+        key3 = self._box.add(msg3)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0,key1,key2,key3], 'unseen':[key0],
+                      'flagged':[key2], 'bar':[key3], 'replied':[key3]})
+        self._box.remove(key2)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
+                      'replied':[key3]})
+        self._box.pack()
+        self.assertEqual(self._box.keys(), [1, 2, 3])
+        key0 = key0
+        key1 = key0 + 1
+        key2 = key1 + 1
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]})
+
+        # Test case for packing while holding the mailbox locked.
+        key0 = self._box.add(msg1)
+        key1 = self._box.add(msg1)
+        key2 = self._box.add(msg1)
+        key3 = self._box.add(msg1)
+
+        self._box.remove(key0)
+        self._box.remove(key2)
+        self._box.lock()
+        self._box.pack()
+        self._box.unlock()
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[1, 2, 3, 4, 5],
+                      'unseen':[1], 'bar':[3], 'replied':[3]})
+
+    def _get_lock_path(self):
+        return os.path.join(self._path, '.mh_sequences.lock')
+
+
+class TestBabyl(_TestSingleFile, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.Babyl(path, factory)
+
+    def assertMailboxEmpty(self):
+        with open(self._path, 'rb') as f:
+            self.assertEqual(f.readlines(), [])
+
+    def tearDown(self):
+        super().tearDown()
+        self._box.close()
+        self._delete_recursively(self._path)
+        for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
+            os_helper.unlink(lock_remnant)
+
+    def test_labels(self):
+        # Get labels from the mailbox
+        self.assertEqual(self._box.get_labels(), [])
+        msg0 = mailbox.BabylMessage(self._template % 0)
+        msg0.add_label('foo')
+        key0 = self._box.add(msg0)
+        self.assertEqual(self._box.get_labels(), ['foo'])
+        msg1 = mailbox.BabylMessage(self._template % 1)
+        msg1.set_labels(['bar', 'answered', 'foo'])
+        key1 = self._box.add(msg1)
+        self.assertEqual(set(self._box.get_labels()), set(['foo', 'bar']))
+        msg0.set_labels(['blah', 'filed'])
+        self._box[key0] = msg0
+        self.assertEqual(set(self._box.get_labels()),
+                     set(['foo', 'bar', 'blah']))
+        self._box.remove(key1)
+        self.assertEqual(set(self._box.get_labels()), set(['blah']))
+
+
+class FakeFileLikeObject:
+
+    def __init__(self):
+        self.closed = False
+
+    def close(self):
+        self.closed = True
+
+
+class FakeMailBox(mailbox.Mailbox):
+
+    def __init__(self):
+        mailbox.Mailbox.__init__(self, '', lambda file: None)
+        self.files = [FakeFileLikeObject() for i in range(10)]
+
+    def get_file(self, key):
+        return self.files[key]
+
+
+class TestFakeMailBox(unittest.TestCase):
+
+    def test_closing_fd(self):
+        box = FakeMailBox()
+        for i in range(10):
+            self.assertFalse(box.files[i].closed)
+        for i in range(10):
+            box[i]
+        for i in range(10):
+            self.assertTrue(box.files[i].closed)
+
+
+class TestMessage(TestBase, unittest.TestCase):
+
+    _factory = mailbox.Message      # Overridden by subclasses to reuse tests
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+
+    def tearDown(self):
+        self._delete_recursively(self._path)
+
+    def test_initialize_with_eMM(self):
+        # Initialize based on email.message.Message instance
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory(eMM)
+        self._post_initialize_hook(msg)
+        self._check_sample(msg)
+
+    def test_initialize_with_string(self):
+        # Initialize based on string
+        msg = self._factory(_sample_message)
+        self._post_initialize_hook(msg)
+        self._check_sample(msg)
+
+    def test_initialize_with_file(self):
+        # Initialize based on contents of file
+        with open(self._path, 'w+', encoding='utf-8') as f:
+            f.write(_sample_message)
+            f.seek(0)
+            msg = self._factory(f)
+            self._post_initialize_hook(msg)
+            self._check_sample(msg)
+
+    def test_initialize_with_binary_file(self):
+        # Initialize based on contents of binary file
+        with open(self._path, 'wb+') as f:
+            f.write(_bytes_sample_message)
+            f.seek(0)
+            msg = self._factory(f)
+            self._post_initialize_hook(msg)
+            self._check_sample(msg)
+
+    def test_initialize_with_nothing(self):
+        # Initialize without arguments
+        msg = self._factory()
+        self._post_initialize_hook(msg)
+        self.assertIsInstance(msg, email.message.Message)
+        self.assertIsInstance(msg, mailbox.Message)
+        self.assertIsInstance(msg, self._factory)
+        self.assertEqual(msg.keys(), [])
+        self.assertFalse(msg.is_multipart())
+        self.assertIsNone(msg.get_payload())
+
+    def test_initialize_incorrectly(self):
+        # Initialize with invalid argument
+        self.assertRaises(TypeError, lambda: self._factory(object()))
+
+    def test_all_eMM_attributes_exist(self):
+        # Issue 12537
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory(_sample_message)
+        for attr in eMM.__dict__:
+            self.assertIn(attr, msg.__dict__,
+                '{} attribute does not exist'.format(attr))
+
+    def test_become_message(self):
+        # Take on the state of another message
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory()
+        msg._become_message(eMM)
+        self._check_sample(msg)
+
+    def test_explain_to(self):
+        # Copy self's format-specific data to other message formats.
+        # This test is superficial; better ones are in TestMessageConversion.
+        msg = self._factory()
+        for class_ in self.all_mailbox_types:
+            other_msg = class_()
+            msg._explain_to(other_msg)
+        other_msg = email.message.Message()
+        self.assertRaises(TypeError, lambda: msg._explain_to(other_msg))
+
+    def _post_initialize_hook(self, msg):
+        # Overridden by subclasses to check extra things after initialization
+        pass
+
+
+class TestMaildirMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.MaildirMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._subdir, 'new')
+        self.assertEqual(msg._info, '')
+
+    def test_subdir(self):
+        # Use get_subdir() and set_subdir()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_subdir('cur')
+        self.assertEqual(msg.get_subdir(), 'cur')
+        msg.set_subdir('new')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self.assertRaises(ValueError, lambda: msg.set_subdir('tmp'))
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_subdir('new')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self._check_sample(msg)
+
+    def test_flags(self):
+        # Use get_flags(), set_flags(), add_flag(), remove_flag()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_flags('F')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self.assertEqual(msg.get_flags(), 'F')
+        msg.set_flags('SDTP')
+        self.assertEqual(msg.get_flags(), 'DPST')
+        msg.add_flag('FT')
+        self.assertEqual(msg.get_flags(), 'DFPST')
+        msg.remove_flag('TDRP')
+        self.assertEqual(msg.get_flags(), 'FS')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self._check_sample(msg)
+
+    def test_date(self):
+        # Use get_date() and set_date()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertLess(abs(msg.get_date() - time.time()), 60)
+        msg.set_date(0.0)
+        self.assertEqual(msg.get_date(), 0.0)
+
+    def test_info(self):
+        # Use get_info() and set_info()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_info(), '')
+        msg.set_info('1,foo=bar')
+        self.assertEqual(msg.get_info(), '1,foo=bar')
+        self.assertRaises(TypeError, lambda: msg.set_info(None))
+        self._check_sample(msg)
+
+    def test_info_and_flags(self):
+        # Test interaction of info and flag methods
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_info(), '')
+        msg.set_flags('SF')
+        self.assertEqual(msg.get_flags(), 'FS')
+        self.assertEqual(msg.get_info(), '2,FS')
+        msg.set_info('1,')
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_info(), '1,')
+        msg.remove_flag('RPT')
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_info(), '1,')
+        msg.add_flag('D')
+        self.assertEqual(msg.get_flags(), 'D')
+        self.assertEqual(msg.get_info(), '2,D')
+        self._check_sample(msg)
+
+
+class _TestMboxMMDFMessage:
+
+    _factory = mailbox._mboxMMDFMessage
+
+    def _post_initialize_hook(self, msg):
+        self._check_from(msg)
+
+    def test_initialize_with_unixfrom(self):
+        # Initialize with a message that already has a _unixfrom attribute
+        msg = mailbox.Message(_sample_message)
+        msg.set_unixfrom('From foo@bar blah')
+        msg = mailbox.mboxMessage(msg)
+        self.assertEqual(msg.get_from(), 'foo@bar blah')
+        self.assertEqual(msg.get_unixfrom(), 'From foo@bar blah')
+
+    def test_from(self):
+        # Get and set "From " line
+        msg = mailbox.mboxMessage(_sample_message)
+        self._check_from(msg)
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('foo bar')
+        self.assertEqual(msg.get_from(), 'foo bar')
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('foo@bar', True)
+        self._check_from(msg, 'foo@bar')
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('blah@temp', time.localtime())
+        self._check_from(msg, 'blah@temp')
+        self.assertIsNone(msg.get_unixfrom())
+
+    def test_flags(self):
+        # Use get_flags(), set_flags(), add_flag(), remove_flag()
+        msg = mailbox.mboxMessage(_sample_message)
+        self.assertEqual(msg.get_flags(), '')
+        msg.set_flags('F')
+        self.assertEqual(msg.get_flags(), 'F')
+        msg.set_flags('XODR')
+        self.assertEqual(msg.get_flags(), 'RODX')
+        msg.add_flag('FA')
+        self.assertEqual(msg.get_flags(), 'RODFAX')
+        msg.remove_flag('FDXA')
+        self.assertEqual(msg.get_flags(), 'RO')
+        self._check_sample(msg)
+
+    def _check_from(self, msg, sender=None):
+        # Check contents of "From " line
+        if sender is None:
+            sender = "MAILER-DAEMON"
+        self.assertIsNotNone(re.match(
+                sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:\d{2} \d{4}",
+                msg.get_from()))
+
+
+class TestMboxMessage(_TestMboxMMDFMessage, TestMessage):
+
+    _factory = mailbox.mboxMessage
+
+
+class TestMHMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.MHMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._sequences, [])
+
+    def test_sequences(self):
+        # Get, set, join, and leave sequences
+        msg = mailbox.MHMessage(_sample_message)
+        self.assertEqual(msg.get_sequences(), [])
+        msg.set_sequences(['foobar'])
+        self.assertEqual(msg.get_sequences(), ['foobar'])
+        msg.set_sequences([])
+        self.assertEqual(msg.get_sequences(), [])
+        msg.add_sequence('unseen')
+        self.assertEqual(msg.get_sequences(), ['unseen'])
+        msg.add_sequence('flagged')
+        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
+        msg.add_sequence('flagged')
+        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
+        msg.remove_sequence('unseen')
+        self.assertEqual(msg.get_sequences(), ['flagged'])
+        msg.add_sequence('foobar')
+        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
+        msg.remove_sequence('replied')
+        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
+        msg.set_sequences(['foobar', 'replied'])
+        self.assertEqual(msg.get_sequences(), ['foobar', 'replied'])
+
+
+class TestBabylMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.BabylMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._labels, [])
+
+    def test_labels(self):
+        # Get, set, join, and leave labels
+        msg = mailbox.BabylMessage(_sample_message)
+        self.assertEqual(msg.get_labels(), [])
+        msg.set_labels(['foobar'])
+        self.assertEqual(msg.get_labels(), ['foobar'])
+        msg.set_labels([])
+        self.assertEqual(msg.get_labels(), [])
+        msg.add_label('filed')
+        self.assertEqual(msg.get_labels(), ['filed'])
+        msg.add_label('resent')
+        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
+        msg.add_label('resent')
+        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
+        msg.remove_label('filed')
+        self.assertEqual(msg.get_labels(), ['resent'])
+        msg.add_label('foobar')
+        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
+        msg.remove_label('unseen')
+        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
+        msg.set_labels(['foobar', 'answered'])
+        self.assertEqual(msg.get_labels(), ['foobar', 'answered'])
+
+    def test_visible(self):
+        # Get, set, and update visible headers
+        msg = mailbox.BabylMessage(_sample_message)
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), [])
+        self.assertIsNone(visible.get_payload())
+        visible['User-Agent'] = 'FooBar 1.0'
+        visible['X-Whatever'] = 'Blah'
+        self.assertEqual(msg.get_visible().keys(), [])
+        msg.set_visible(visible)
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
+        self.assertEqual(visible['User-Agent'], 'FooBar 1.0')
+        self.assertEqual(visible['X-Whatever'], 'Blah')
+        self.assertIsNone(visible.get_payload())
+        msg.update_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
+        self.assertIsNone(visible.get_payload())
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To',
+                                          'Subject'])
+        for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'):
+            self.assertEqual(visible[header], msg[header])
+
+
+class TestMMDFMessage(_TestMboxMMDFMessage, TestMessage):
+
+    _factory = mailbox.MMDFMessage
+
+
+class TestMessageConversion(TestBase, unittest.TestCase):
+
+    def test_plain_to_x(self):
+        # Convert Message to all formats
+        for class_ in self.all_mailbox_types:
+            msg_plain = mailbox.Message(_sample_message)
+            msg = class_(msg_plain)
+            self._check_sample(msg)
+
+    def test_x_to_plain(self):
+        # Convert all formats to Message
+        for class_ in self.all_mailbox_types:
+            msg = class_(_sample_message)
+            msg_plain = mailbox.Message(msg)
+            self._check_sample(msg_plain)
+
+    def test_x_from_bytes(self):
+        # Convert all formats to Message
+        for class_ in self.all_mailbox_types:
+            msg = class_(_bytes_sample_message)
+            self._check_sample(msg)
+
+    def test_x_to_invalid(self):
+        # Convert all formats to an invalid format
+        for class_ in self.all_mailbox_types:
+            self.assertRaises(TypeError, lambda: class_(False))
+
+    def test_type_specific_attributes_removed_on_conversion(self):
+        reference = {class_: class_(_sample_message).__dict__
+                        for class_ in self.all_mailbox_types}
+        for class1 in self.all_mailbox_types:
+            for class2 in self.all_mailbox_types:
+                if class1 is class2:
+                    continue
+                source = class1(_sample_message)
+                target = class2(source)
+                type_specific = [a for a in reference[class1]
+                                   if a not in reference[class2]]
+                for attr in type_specific:
+                    self.assertNotIn(attr, target.__dict__,
+                        "while converting {} to {}".format(class1, class2))
+
+    def test_maildir_to_maildir(self):
+        # Convert MaildirMessage to MaildirMessage
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        msg_maildir.set_flags('DFPRST')
+        msg_maildir.set_subdir('cur')
+        date = msg_maildir.get_date()
+        msg = mailbox.MaildirMessage(msg_maildir)
+        self._check_sample(msg)
+        self.assertEqual(msg.get_flags(), 'DFPRST')
+        self.assertEqual(msg.get_subdir(), 'cur')
+        self.assertEqual(msg.get_date(), date)
+
+    def test_maildir_to_mboxmmdf(self):
+        # Convert MaildirMessage to mboxmessage and MMDFMessage
+        pairs = (('D', ''), ('F', 'F'), ('P', ''), ('R', 'A'), ('S', 'R'),
+                 ('T', 'D'), ('DFPRST', 'RDFA'))
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_maildir = mailbox.MaildirMessage(_sample_message)
+            msg_maildir.set_date(0.0)
+            for setting, result in pairs:
+                msg_maildir.set_flags(setting)
+                msg = class_(msg_maildir)
+                self.assertEqual(msg.get_flags(), result)
+                self.assertEqual(msg.get_from(), 'MAILER-DAEMON %s' %
+                             time.asctime(time.gmtime(0.0)))
+                self.assertIsNone(msg.get_unixfrom())
+            msg_maildir.set_subdir('cur')
+            self.assertEqual(class_(msg_maildir).get_flags(), 'RODFA')
+
+    def test_maildir_to_mh(self):
+        # Convert MaildirMessage to MHMessage
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        pairs = (('D', ['unseen']), ('F', ['unseen', 'flagged']),
+                 ('P', ['unseen']), ('R', ['unseen', 'replied']), ('S', []),
+                 ('T', ['unseen']), ('DFPRST', ['replied', 'flagged']))
+        for setting, result in pairs:
+            msg_maildir.set_flags(setting)
+            self.assertEqual(mailbox.MHMessage(msg_maildir).get_sequences(),
+                             result)
+
+    def test_maildir_to_babyl(self):
+        # Convert MaildirMessage to Babyl
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        pairs = (('D', ['unseen']), ('F', ['unseen']),
+                 ('P', ['unseen', 'forwarded']), ('R', ['unseen', 'answered']),
+                 ('S', []), ('T', ['unseen', 'deleted']),
+                 ('DFPRST', ['deleted', 'answered', 'forwarded']))
+        for setting, result in pairs:
+            msg_maildir.set_flags(setting)
+            self.assertEqual(mailbox.BabylMessage(msg_maildir).get_labels(),
+                             result)
+
+    def test_mboxmmdf_to_maildir(self):
+        # Convert mboxMessage and MMDFMessage to MaildirMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            msg_mboxMMDF.set_from('foo@bar', time.gmtime(0.0))
+            pairs = (('R', 'S'), ('O', ''), ('D', 'T'), ('F', 'F'), ('A', 'R'),
+                     ('RODFA', 'FRST'))
+            for setting, result in pairs:
+                msg_mboxMMDF.set_flags(setting)
+                msg = mailbox.MaildirMessage(msg_mboxMMDF)
+                self.assertEqual(msg.get_flags(), result)
+                self.assertEqual(msg.get_date(), 0.0)
+            msg_mboxMMDF.set_flags('O')
+            self.assertEqual(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir(),
+                             'cur')
+
+    def test_mboxmmdf_to_mboxmmdf(self):
+        # Convert mboxMessage and MMDFMessage to mboxMessage and MMDFMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            msg_mboxMMDF.set_flags('RODFA')
+            msg_mboxMMDF.set_from('foo@bar')
+            self.assertIsNone(msg_mboxMMDF.get_unixfrom())
+            for class2_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                msg2 = class2_(msg_mboxMMDF)
+                self.assertEqual(msg2.get_flags(), 'RODFA')
+                self.assertEqual(msg2.get_from(), 'foo@bar')
+                self.assertIsNone(msg2.get_unixfrom())
+
+    def test_mboxmmdf_to_mh(self):
+        # Convert mboxMessage and MMDFMessage to MHMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            pairs = (('R', []), ('O', ['unseen']), ('D', ['unseen']),
+                     ('F', ['unseen', 'flagged']),
+                     ('A', ['unseen', 'replied']),
+                     ('RODFA', ['replied', 'flagged']))
+            for setting, result in pairs:
+                msg_mboxMMDF.set_flags(setting)
+                self.assertEqual(mailbox.MHMessage(msg_mboxMMDF).get_sequences(),
+                                 result)
+
+    def test_mboxmmdf_to_babyl(self):
+        # Convert mboxMessage and MMDFMessage to BabylMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg = class_(_sample_message)
+            pairs = (('R', []), ('O', ['unseen']),
+                     ('D', ['unseen', 'deleted']), ('F', ['unseen']),
+                     ('A', ['unseen', 'answered']),
+                     ('RODFA', ['deleted', 'answered']))
+            for setting, result in pairs:
+                msg.set_flags(setting)
+                self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
+
+    def test_mh_to_maildir(self):
+        # Convert MHMessage to MaildirMessage
+        pairs = (('unseen', ''), ('replied', 'RS'), ('flagged', 'FS'))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'FR')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+
+    def test_mh_to_mboxmmdf(self):
+        # Convert MHMessage to mboxMessage and MMDFMessage
+        pairs = (('unseen', 'O'), ('replied', 'ROA'), ('flagged', 'ROF'))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                self.assertEqual(class_(msg).get_flags(), result)
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            self.assertEqual(class_(msg).get_flags(), 'OFA')
+
+    def test_mh_to_mh(self):
+        # Convert MHMessage to MHMessage
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+                         ['unseen', 'replied', 'flagged'])
+
+    def test_mh_to_babyl(self):
+        # Convert MHMessage to BabylMessage
+        pairs = (('unseen', ['unseen']), ('replied', ['answered']),
+                 ('flagged', []))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.BabylMessage(msg).get_labels(),
+                         ['unseen', 'answered'])
+
+    def test_babyl_to_maildir(self):
+        # Convert BabylMessage to MaildirMessage
+        pairs = (('unseen', ''), ('deleted', 'ST'), ('filed', 'S'),
+                 ('answered', 'RS'), ('forwarded', 'PS'), ('edited', 'S'),
+                 ('resent', 'PS'))
+        for setting, result in pairs:
+            msg = mailbox.BabylMessage(_sample_message)
+            msg.add_label(setting)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'PRT')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+
+    def test_babyl_to_mboxmmdf(self):
+        # Convert BabylMessage to mboxMessage and MMDFMessage
+        pairs = (('unseen', 'O'), ('deleted', 'ROD'), ('filed', 'RO'),
+                 ('answered', 'ROA'), ('forwarded', 'RO'), ('edited', 'RO'),
+                 ('resent', 'RO'))
+        for setting, result in pairs:
+            for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                msg = mailbox.BabylMessage(_sample_message)
+                msg.add_label(setting)
+                self.assertEqual(class_(msg).get_flags(), result)
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            self.assertEqual(class_(msg).get_flags(), 'ODA')
+
+    def test_babyl_to_mh(self):
+        # Convert BabylMessage to MHMessage
+        pairs = (('unseen', ['unseen']), ('deleted', []), ('filed', []),
+                 ('answered', ['replied']), ('forwarded', []), ('edited', []),
+                 ('resent', []))
+        for setting, result in pairs:
+            msg = mailbox.BabylMessage(_sample_message)
+            msg.add_label(setting)
+            self.assertEqual(mailbox.MHMessage(msg).get_sequences(), result)
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+                         ['unseen', 'replied'])
+
+    def test_babyl_to_babyl(self):
+        # Convert BabylMessage to BabylMessage
+        msg = mailbox.BabylMessage(_sample_message)
+        msg.update_visible()
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        msg2 = mailbox.BabylMessage(msg)
+        self.assertEqual(msg2.get_labels(), ['unseen', 'deleted', 'filed',
+                                             'answered', 'forwarded', 'edited',
+                                             'resent'])
+        self.assertEqual(msg.get_visible().keys(), msg2.get_visible().keys())
+        for key in msg.get_visible().keys():
+            self.assertEqual(msg.get_visible()[key], msg2.get_visible()[key])
+
+
+class TestProxyFileBase(TestBase):
+
+    def _test_read(self, proxy):
+        # Read by byte
+        proxy.seek(0)
+        self.assertEqual(proxy.read(), b'bar')
+        proxy.seek(1)
+        self.assertEqual(proxy.read(), b'ar')
+        proxy.seek(0)
+        self.assertEqual(proxy.read(2), b'ba')
+        proxy.seek(1)
+        self.assertEqual(proxy.read(-1), b'ar')
+        proxy.seek(2)
+        self.assertEqual(proxy.read(1000), b'r')
+
+    def _test_readline(self, proxy):
+        # Read by line
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        self.assertEqual(proxy.readline(), b'foo' + linesep)
+        self.assertEqual(proxy.readline(), b'bar' + linesep)
+        self.assertEqual(proxy.readline(), b'fred' + linesep)
+        self.assertEqual(proxy.readline(), b'bob')
+        proxy.seek(2)
+        self.assertEqual(proxy.readline(), b'o' + linesep)
+        proxy.seek(6 + 2 * len(os.linesep))
+        self.assertEqual(proxy.readline(), b'fred' + linesep)
+        proxy.seek(6 + 2 * len(os.linesep))
+        self.assertEqual(proxy.readline(2), b'fr')
+        self.assertEqual(proxy.readline(-10), b'ed' + linesep)
+
+    def _test_readlines(self, proxy):
+        # Read multiple lines
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        self.assertEqual(proxy.readlines(), [b'foo' + linesep,
+                                           b'bar' + linesep,
+                                           b'fred' + linesep, b'bob'])
+        proxy.seek(0)
+        self.assertEqual(proxy.readlines(2), [b'foo' + linesep])
+        proxy.seek(3 + len(linesep))
+        self.assertEqual(proxy.readlines(4 + len(linesep)),
+                     [b'bar' + linesep, b'fred' + linesep])
+        proxy.seek(3)
+        self.assertEqual(proxy.readlines(1000), [linesep, b'bar' + linesep,
+                                               b'fred' + linesep, b'bob'])
+
+    def _test_iteration(self, proxy):
+        # Iterate by line
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        iterator = iter(proxy)
+        self.assertEqual(next(iterator), b'foo' + linesep)
+        self.assertEqual(next(iterator), b'bar' + linesep)
+        self.assertEqual(next(iterator), b'fred' + linesep)
+        self.assertEqual(next(iterator), b'bob')
+        self.assertRaises(StopIteration, next, iterator)
+
+    def _test_seek_and_tell(self, proxy):
+        # Seek and use tell to check position
+        linesep = os.linesep.encode()
+        proxy.seek(3)
+        self.assertEqual(proxy.tell(), 3)
+        self.assertEqual(proxy.read(len(linesep)), linesep)
+        proxy.seek(2, 1)
+        self.assertEqual(proxy.read(1 + len(linesep)), b'r' + linesep)
+        proxy.seek(-3 - len(linesep), 2)
+        self.assertEqual(proxy.read(3), b'bar')
+        proxy.seek(2, 0)
+        self.assertEqual(proxy.read(), b'o' + linesep + b'bar' + linesep)
+        proxy.seek(100)
+        self.assertFalse(proxy.read())
+
+    def _test_close(self, proxy):
+        # Close a file
+        self.assertFalse(proxy.closed)
+        proxy.close()
+        self.assertTrue(proxy.closed)
+        # Issue 11700 subsequent closes should be a no-op.
+        proxy.close()
+        self.assertTrue(proxy.closed)
+
+
+class TestProxyFile(TestProxyFileBase, unittest.TestCase):
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._file = open(self._path, 'wb+')
+
+    def tearDown(self):
+        self._file.close()
+        self._delete_recursively(self._path)
+
+    def test_initialize(self):
+        # Initialize and check position
+        self._file.write(b'foo')
+        pos = self._file.tell()
+        proxy0 = mailbox._ProxyFile(self._file)
+        self.assertEqual(proxy0.tell(), pos)
+        self.assertEqual(self._file.tell(), pos)
+        proxy1 = mailbox._ProxyFile(self._file, 0)
+        self.assertEqual(proxy1.tell(), 0)
+        self.assertEqual(self._file.tell(), pos)
+
+    def test_read(self):
+        self._file.write(b'bar')
+        self._test_read(mailbox._ProxyFile(self._file))
+
+    def test_readline(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_readline(mailbox._ProxyFile(self._file))
+
+    def test_readlines(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_readlines(mailbox._ProxyFile(self._file))
+
+    def test_iteration(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_iteration(mailbox._ProxyFile(self._file))
+
+    def test_seek_and_tell(self):
+        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._test_seek_and_tell(mailbox._ProxyFile(self._file))
+
+    def test_close(self):
+        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._test_close(mailbox._ProxyFile(self._file))
+
+
+class TestPartialFile(TestProxyFileBase, unittest.TestCase):
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._file = open(self._path, 'wb+')
+
+    def tearDown(self):
+        self._file.close()
+        self._delete_recursively(self._path)
+
+    def test_initialize(self):
+        # Initialize and check position
+        self._file.write(bytes('foo' + os.linesep + 'bar', 'ascii'))
+        pos = self._file.tell()
+        proxy = mailbox._PartialFile(self._file, 2, 5)
+        self.assertEqual(proxy.tell(), 0)
+        self.assertEqual(self._file.tell(), pos)
+
+    def test_read(self):
+        self._file.write(bytes('***bar***', 'ascii'))
+        self._test_read(mailbox._PartialFile(self._file, 3, 6))
+
+    def test_readline(self):
+        self._file.write(bytes('!!!!!foo%sbar%sfred%sbob!!!!!' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_readline(mailbox._PartialFile(self._file, 5,
+                                                 18 + 3 * len(os.linesep)))
+
+    def test_readlines(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob?????' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_readlines(mailbox._PartialFile(self._file, 0,
+                                                  13 + 3 * len(os.linesep)))
+
+    def test_iteration(self):
+        self._file.write(bytes('____foo%sbar%sfred%sbob####' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_iteration(mailbox._PartialFile(self._file, 4,
+                                                  17 + 3 * len(os.linesep)))
+
+    def test_seek_and_tell(self):
+        self._file.write(bytes('(((foo%sbar%s$$$' % (os.linesep, os.linesep), 'ascii'))
+        self._test_seek_and_tell(mailbox._PartialFile(self._file, 3,
+                                                      9 + 2 * len(os.linesep)))
+
+    def test_close(self):
+        self._file.write(bytes('&foo%sbar%s^' % (os.linesep, os.linesep), 'ascii'))
+        self._test_close(mailbox._PartialFile(self._file, 1,
+                                              6 + 3 * len(os.linesep)))
+
+
+## Start: tests from the original module (for backward compatibility).
+
+FROM_ = "From some.body@dummy.domain  Sat Jul 24 13:43:35 2004\n"
+DUMMY_MESSAGE = """\
+From: some.body@dummy.domain
+To: me@my.domain
+Subject: Simple Test
+
+This is a dummy message.
+"""
+
+class MaildirTestCase(unittest.TestCase):
+
+    def setUp(self):
+        # create a new maildir mailbox to work with:
+        self._dir = os_helper.TESTFN
+        if os.path.isdir(self._dir):
+            os_helper.rmtree(self._dir)
+        elif os.path.isfile(self._dir):
+            os_helper.unlink(self._dir)
+        os.mkdir(self._dir)
+        os.mkdir(os.path.join(self._dir, "cur"))
+        os.mkdir(os.path.join(self._dir, "tmp"))
+        os.mkdir(os.path.join(self._dir, "new"))
+        self._counter = 1
+        self._msgfiles = []
+
+    def tearDown(self):
+        list(map(os.unlink, self._msgfiles))
+        os_helper.rmdir(os.path.join(self._dir, "cur"))
+        os_helper.rmdir(os.path.join(self._dir, "tmp"))
+        os_helper.rmdir(os.path.join(self._dir, "new"))
+        os_helper.rmdir(self._dir)
+
+    def createMessage(self, dir, mbox=False):
+        t = int(time.time() % 1000000)
+        pid = self._counter
+        self._counter += 1
+        filename = ".".join((str(t), str(pid), "myhostname", "mydomain"))
+        tmpname = os.path.join(self._dir, "tmp", filename)
+        newname = os.path.join(self._dir, dir, filename)
+        with open(tmpname, "w", encoding="utf-8") as fp:
+            self._msgfiles.append(tmpname)
+            if mbox:
+                fp.write(FROM_)
+            fp.write(DUMMY_MESSAGE)
+        try:
+            os.link(tmpname, newname)
+        except (AttributeError, PermissionError):
+            with open(newname, "w") as fp:
+                fp.write(DUMMY_MESSAGE)
+        self._msgfiles.append(newname)
+        return tmpname
+
+    def test_empty_maildir(self):
+        """Test an empty maildir mailbox"""
+        # Test for regression on bug #117490:
+        # Make sure the boxes attribute actually gets set.
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertHasAttr(self.mbox, "boxes")
+        #self.assertEqual(len(self.mbox.boxes), 0)
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_cur(self):
+        self.createMessage("cur")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 1)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_new(self):
+        self.createMessage("new")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 1)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_both(self):
+        self.createMessage("cur")
+        self.createMessage("new")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 2)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+## End: tests from the original module (for backward compatibility).
+
+
+_sample_message = """\
+Return-Path: <gkj@gregorykjohnson.com>
+X-Original-To: gkj+person@localhost
+Delivered-To: gkj+person@localhost
+Received: from localhost (localhost [127.0.0.1])
+        by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
+        for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
+Delivered-To: gkj@sundance.gregorykjohnson.com
+Received: from localhost [127.0.0.1]
+        by localhost with POP3 (fetchmail-6.2.5)
+        for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
+Received: from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
+        by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
+        for <gkj@gregorykjohnson.com>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
+Received: by andy.gregorykjohnson.com (Postfix, from userid 1000)
+        id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
+Date: Wed, 13 Jul 2005 17:23:11 -0400
+From: "Gregory K. Johnson" <gkj@gregorykjohnson.com>
+To: gkj@gregorykjohnson.com
+Subject: Sample message
+Message-ID: <20050713212311.GC4701@andy.gregorykjohnson.com>
+Mime-Version: 1.0
+Content-Type: multipart/mixed; boundary="NMuMz9nt05w80d4+"
+Content-Disposition: inline
+User-Agent: Mutt/1.5.9i
+
+
+--NMuMz9nt05w80d4+
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+
+This is a sample message.
+
+--
+Gregory K. Johnson
+
+--NMuMz9nt05w80d4+
+Content-Type: application/octet-stream
+Content-Disposition: attachment; filename="text.gz"
+Content-Transfer-Encoding: base64
+
+H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
+3FYlAAAA
+
+--NMuMz9nt05w80d4+--
+"""
+
+_bytes_sample_message = _sample_message.encode('ascii')
+
+_sample_headers = [
+    ("Return-Path", "<gkj@gregorykjohnson.com>"),
+    ("X-Original-To", "gkj+person@localhost"),
+    ("Delivered-To", "gkj+person@localhost"),
+    ("Received", """from localhost (localhost [127.0.0.1])
+        by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
+        for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
+    ("Delivered-To", "gkj@sundance.gregorykjohnson.com"),
+    ("Received", """from localhost [127.0.0.1]
+        by localhost with POP3 (fetchmail-6.2.5)
+        for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
+    ("Received", """from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
+        by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
+        for <gkj@gregorykjohnson.com>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
+    ("Received", """by andy.gregorykjohnson.com (Postfix, from userid 1000)
+        id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
+    ("Date", "Wed, 13 Jul 2005 17:23:11 -0400"),
+    ("From", """"Gregory K. Johnson" <gkj@gregorykjohnson.com>"""),
+    ("To", "gkj@gregorykjohnson.com"),
+    ("Subject", "Sample message"),
+    ("Mime-Version", "1.0"),
+    ("Content-Type", """multipart/mixed; boundary="NMuMz9nt05w80d4+\""""),
+    ("Content-Disposition", "inline"),
+    ("User-Agent", "Mutt/1.5.9i"),
+]
+
+_sample_payloads = ("""This is a sample message.
+
+--
+Gregory K. Johnson
+""",
+"""H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
+3FYlAAAA
+""")
+
+
+class MiscTestCase(unittest.TestCase):
+    def test__all__(self):
+        support.check__all__(self, mailbox,
+                             not_exported={"linesep", "fcntl"})
+
+
+def tearDownModule():
+    support.reap_children()
+    # reap_children may have re-populated caches:
+    if refleak_helper.hunting_for_refleaks():
+        sys._clear_internal_caches()
+
+
+if __name__ == '__main__':
+    unittest.main()

From 01a5f94e7b581da938a2c4dd7f631f9880dd1873 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 15:01:55 +0900
Subject: [PATCH 135/418] Fix error / warning messages (#6594)

* fix functools.partial repr

* warn_deprecated_throw_signature

* fix function error messages
---
 Lib/test/test_dataclasses/__init__.py    |  2 --
 Lib/test/test_functools.py               |  2 --
 Lib/test/test_generators.py              |  1 -
 Lib/test/test_keywordonlyarg.py          |  1 -
 Lib/test/test_positional_only_arg.py     |  4 ---
 Lib/test/test_typing.py                  |  1 -
 crates/vm/src/builtins/asyncgenerator.rs |  5 +++-
 crates/vm/src/builtins/coroutine.rs      |  4 ++-
 crates/vm/src/builtins/function.rs       | 20 ++++++++++++---
 crates/vm/src/builtins/generator.rs      |  3 ++-
 crates/vm/src/coroutine.rs               | 22 ++++++++++++++++
 crates/vm/src/stdlib/functools.rs        | 32 ++++++++++--------------
 12 files changed, 61 insertions(+), 36 deletions(-)

diff --git a/Lib/test/test_dataclasses/__init__.py b/Lib/test/test_dataclasses/__init__.py
index 1b16da42648..3f1e2331bc2 100644
--- a/Lib/test/test_dataclasses/__init__.py
+++ b/Lib/test/test_dataclasses/__init__.py
@@ -4728,8 +4728,6 @@ class C:
             b: int = field(kw_only=True)
         self.assertEqual(C(42, b=10).__match_args__, ('a',))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_KW_ONLY(self):
         @dataclass
         class A:
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 6de5d14bf73..047916caf07 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -465,11 +465,9 @@ def __str__(self):
         self.assertIn('astr', r)
         self.assertIn("['sth']", r)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_repr(self):
         return super().test_repr()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_recursive_repr(self):
         return super().test_recursive_repr()
 
diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index c6f66085c74..8833a102b36 100644
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -479,7 +479,6 @@ def generator():
         with self.assertRaises(StopIteration):
             gen.throw(E)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: DeprecationWarning not triggered
     def test_gen_3_arg_deprecation_warning(self):
         def g():
             yield 42
diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py
index e41e7c051f6..8fd2e89122f 100644
--- a/Lib/test/test_keywordonlyarg.py
+++ b/Lib/test/test_keywordonlyarg.py
@@ -58,7 +58,6 @@ def testSyntaxForManyArguments(self):
         fundef = "def f(*, %s):\n  pass\n" % ', '.join('i%d' % i for i in range(300))
         compile(fundef, "<test>", "single")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testTooManyPositionalErrorMessage(self):
         def f(a, b=None, *, c=None):
             pass
diff --git a/Lib/test/test_positional_only_arg.py b/Lib/test/test_positional_only_arg.py
index e0d784325ba..4b27f4f4d3f 100644
--- a/Lib/test/test_positional_only_arg.py
+++ b/Lib/test/test_positional_only_arg.py
@@ -152,8 +152,6 @@ def f(a, b, /, c):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes 3 positional arguments but 4 were given"):
             f(1, 2, 3, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positional_only_and_optional_arg_invalid_calls(self):
         def f(a, b, /, c=3):
             pass
@@ -198,8 +196,6 @@ def f(a, b, /):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes 2 positional arguments but 3 were given"):
             f(1, 2, 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positional_only_with_optional_invalid_calls(self):
         def f(a, b=2, /):
             pass
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index 74ab94eb5c3..3e6c530cecc 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -8144,7 +8144,6 @@ class CNT(NamedTuple):
                 self.assertEqual(struct.__annotations__, {})
                 self.assertIsInstance(struct(), struct)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_namedtuple_errors(self):
         with self.assertRaises(TypeError):
             NamedTuple.__new__()
diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 483ba6a7f96..9218ccc8a43 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -4,7 +4,7 @@ use crate::{
     builtins::PyBaseExceptionRef,
     class::PyClassImpl,
     common::lock::PyMutex,
-    coroutine::Coro,
+    coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
@@ -312,6 +312,7 @@ impl PyAsyncGenASend {
             return Err(vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()"));
         }
 
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         let res = self.ag.inner.throw(
             self.ag.as_object(),
             exc_type,
@@ -431,6 +432,7 @@ impl PyAsyncGenAThrow {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         let ret = self.ag.inner.throw(
             self.ag.as_object(),
             exc_type,
@@ -601,6 +603,7 @@ impl PyAnextAwaitable {
         vm: &VirtualMachine,
     ) -> PyResult {
         self.check_closed(vm)?;
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         self.state.store(AwaitableState::Iter);
         let awaitable = self.get_awaitable_iter(vm)?;
         let result = vm.call_method(
diff --git a/crates/vm/src/builtins/coroutine.rs b/crates/vm/src/builtins/coroutine.rs
index 21405448693..9e8d5d534f1 100644
--- a/crates/vm/src/builtins/coroutine.rs
+++ b/crates/vm/src/builtins/coroutine.rs
@@ -2,7 +2,7 @@ use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
 use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
-    coroutine::Coro,
+    coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
@@ -108,6 +108,7 @@ impl Py<PyCoroutine> {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         self.inner.throw(
             self.as_object(),
             exc_type,
@@ -181,6 +182,7 @@ impl PyCoroutineWrapper {
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
         self.check_closed(vm)?;
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         let result = self.coro.throw(exc_type, exc_val, exc_tb, vm);
         // Mark as closed if exhausted
         if let Ok(PyIterReturn::StopIteration(_)) = &result {
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 95d70afcbc7..3e5048e133f 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -131,11 +131,25 @@ impl PyFunction {
         } else {
             // Check the number of positional arguments
             if nargs > n_expected_args {
+                let n_defaults = self
+                    .defaults_and_kwdefaults
+                    .lock()
+                    .0
+                    .as_ref()
+                    .map_or(0, |d| d.len());
+                let n_required = n_expected_args - n_defaults;
+                let takes_msg = if n_defaults > 0 {
+                    format!("from {} to {}", n_required, n_expected_args)
+                } else {
+                    n_expected_args.to_string()
+                };
                 return Err(vm.new_type_error(format!(
-                    "{}() takes {} positional arguments but {} were given",
+                    "{}() takes {} positional argument{} but {} {} given",
                     self.__qualname__(),
-                    n_expected_args,
-                    nargs
+                    takes_msg,
+                    if n_expected_args == 1 { "" } else { "s" },
+                    nargs,
+                    if nargs == 1 { "was" } else { "were" }
                 )));
             }
         }
diff --git a/crates/vm/src/builtins/generator.rs b/crates/vm/src/builtins/generator.rs
index 04cd7dd3456..9a1e737500b 100644
--- a/crates/vm/src/builtins/generator.rs
+++ b/crates/vm/src/builtins/generator.rs
@@ -6,7 +6,7 @@ use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
 use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
-    coroutine::Coro,
+    coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
@@ -99,6 +99,7 @@ impl Py<PyGenerator> {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         self.inner.throw(
             self.as_object(),
             exc_type,
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
index ebe3107cb36..13dde152391 100644
--- a/crates/vm/src/coroutine.rs
+++ b/crates/vm/src/coroutine.rs
@@ -4,6 +4,7 @@ use crate::{
     common::lock::PyMutex,
     exceptions::types::PyBaseException,
     frame::{ExecutionResult, FrameRef},
+    function::OptionalArg,
     protocol::PyIterReturn,
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -211,3 +212,24 @@ impl Coro {
 pub fn is_gen_exit(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
     exc.fast_isinstance(vm.ctx.exceptions.generator_exit)
 }
+
+/// Emit DeprecationWarning for the deprecated 3-argument throw() signature.
+pub fn warn_deprecated_throw_signature(
+    exc_val: &OptionalArg,
+    exc_tb: &OptionalArg,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if exc_val.is_present() || exc_tb.is_present() {
+        crate::warn::warn(
+            vm.ctx.new_str(
+                "the (type, val, tb) signature of throw() is deprecated, \
+                 use throw(val) instead",
+            ),
+            Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
+            1,
+            None,
+            vm,
+        )?;
+    }
+    Ok(())
+}
diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index 77f352c78fc..a59fd48f6b2 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -43,7 +43,7 @@ mod _functools {
     }
 
     #[pyattr]
-    #[pyclass(name = "partial", module = "_functools")]
+    #[pyclass(name = "partial", module = "functools")]
     #[derive(Debug, PyPayload)]
     pub struct PyPartial {
         inner: PyRwLock<PyPartialInner>,
@@ -319,28 +319,22 @@ mod _functools {
                     ));
                 }
 
-                let class_name = zelf.class().name();
+                let qualname = zelf.class().__qualname__(vm);
+                let qualname_str = qualname
+                    .downcast::<crate::builtins::PyStr>()
+                    .map(|s| s.as_str().to_owned())
+                    .unwrap_or_else(|_| zelf.class().name().to_owned());
                 let module = zelf.class().__module__(vm);
 
-                let qualified_name = if zelf.class().is(Self::class(&vm.ctx)) {
-                    // For the base partial class, always use functools.partial
-                    "functools.partial".to_owned()
-                } else {
-                    // For subclasses, check if they're defined in __main__ or test modules
-                    match module.downcast::<crate::builtins::PyStr>() {
-                        Ok(module_str) => {
-                            let module_name = module_str.as_str();
-                            match module_name {
-                                "builtins" | "" | "__main__" => class_name.to_owned(),
-                                name if name.starts_with("test.") || name == "test" => {
-                                    // For test modules, just use the class name without module prefix
-                                    class_name.to_owned()
-                                }
-                                _ => format!("{module_name}.{class_name}"),
-                            }
+                let qualified_name = match module.downcast::<crate::builtins::PyStr>() {
+                    Ok(module_str) => {
+                        let module_name = module_str.as_str();
+                        match module_name {
+                            "builtins" | "" => qualname_str,
+                            _ => format!("{module_name}.{qualname_str}"),
                         }
-                        Err(_) => class_name.to_owned(),
                     }
+                    Err(_) => qualname_str,
                 };
 
                 Ok(format!(

From b3b97cac7c2df62a6b1b1005e8a41f0397c6ebcd Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 15:02:08 +0900
Subject: [PATCH 136/418] fix symtable for named_expressions (#6604)

* check duplicated type parameter

* typealias

* fix self.in_comp_inner_loop_target
---
 Lib/test/test_named_expressions.py |   4 -
 crates/codegen/src/symboltable.rs  | 165 ++++++++++++++++++++++++-----
 2 files changed, 136 insertions(+), 33 deletions(-)

diff --git a/Lib/test/test_named_expressions.py b/Lib/test/test_named_expressions.py
index 03f5384b632..68e4a7704f4 100644
--- a/Lib/test/test_named_expressions.py
+++ b/Lib/test/test_named_expressions.py
@@ -165,8 +165,6 @@ def test_named_expression_invalid_rebinding_list_comprehension_iteration_variabl
                 with self.assertRaisesRegex(SyntaxError, msg):
                     exec(code, {}, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure # wrong error message
     def test_named_expression_invalid_rebinding_list_comprehension_inner_loop(self):
         cases = [
             ("Inner reuse", 'j', "[i for i in range(5) if (j := 0) for j in range(5)]"),
@@ -223,8 +221,6 @@ def test_named_expression_invalid_rebinding_set_comprehension_iteration_variable
                 with self.assertRaisesRegex(SyntaxError, msg):
                     exec(code, {}, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_named_expression_invalid_rebinding_set_comprehension_inner_loop(self):
         cases = [
             ("Inner reuse", 'j', "{i for i in range(5) if (j := 0) for j in range(5)}"),
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 07766373d5a..95f9c0cd400 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -585,7 +585,11 @@ impl SymbolTableAnalyzer {
                 self.analyze_symbol_comprehension(symbol, parent_offset + 1)?;
             }
             CompilerScope::TypeParams => {
-                todo!("analyze symbol comprehension for type params");
+                // Named expression in comprehension cannot be used in type params
+                return Err(SymbolTableError {
+                    error: "assignment expression within a comprehension cannot be used within the definition of a generic".to_string(),
+                    location: None,
+                });
             }
         }
         Ok(())
@@ -617,6 +621,14 @@ struct SymbolTableBuilder {
     current_varnames: Vec<String>,
     // Track if we're inside an iterable definition expression (for nested comprehensions)
     in_iter_def_exp: bool,
+    // Track if we're inside an annotation (yield/await/named expr not allowed)
+    in_annotation: bool,
+    // Track if we're inside a type alias (yield/await/named expr not allowed)
+    in_type_alias: bool,
+    // Track if we're scanning an inner loop iteration target (not the first generator)
+    in_comp_inner_loop_target: bool,
+    // Scope info for error messages (e.g., "a TypeVar bound")
+    scope_info: Option<&'static str>,
 }
 
 /// Enum to indicate in what mode an expression
@@ -641,6 +653,10 @@ impl SymbolTableBuilder {
             source_file,
             current_varnames: Vec::new(),
             in_iter_def_exp: false,
+            in_annotation: false,
+            in_type_alias: false,
+            in_comp_inner_loop_target: false,
+            scope_info: None,
         };
         this.enter_scope("top", CompilerScope::Module, 0);
         this
@@ -751,7 +767,11 @@ impl SymbolTableBuilder {
         if self.future_annotations {
             Ok(())
         } else {
-            self.scan_expression(annotation, ExpressionContext::Load)
+            let was_in_annotation = self.in_annotation;
+            self.in_annotation = true;
+            let result = self.scan_expression(annotation, ExpressionContext::Load);
+            self.in_annotation = was_in_annotation;
+            result
         }
     }
 
@@ -1020,6 +1040,8 @@ impl SymbolTableBuilder {
                 type_params,
                 ..
             }) => {
+                let was_in_type_alias = self.in_type_alias;
+                self.in_type_alias = true;
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         "TypeAlias",
@@ -1031,6 +1053,7 @@ impl SymbolTableBuilder {
                 } else {
                     self.scan_expression(value, ExpressionContext::Load)?;
                 }
+                self.in_type_alias = was_in_type_alias;
                 self.scan_expression(name, ExpressionContext::Store)?;
             }
             Stmt::IpyEscapeCommand(_) => todo!(),
@@ -1067,24 +1090,40 @@ impl SymbolTableBuilder {
     ) -> SymbolTableResult {
         use ruff_python_ast::*;
 
-        // Check for expressions not allowed in type parameters scope
-        if let Some(table) = self.tables.last()
-            && table.typ == CompilerScope::TypeParams
-            && let Some(keyword) = match expression {
-                Expr::Yield(_) | Expr::YieldFrom(_) => Some("yield"),
-                Expr::Await(_) => Some("await"),
-                Expr::Named(_) => Some("named"),
-                _ => None,
+        // Check for expressions not allowed in certain contexts
+        // (type parameters, annotations, type aliases, TypeVar bounds/defaults)
+        if let Some(keyword) = match expression {
+            Expr::Yield(_) | Expr::YieldFrom(_) => Some("yield"),
+            Expr::Await(_) => Some("await"),
+            Expr::Named(_) => Some("named"),
+            _ => None,
+        } {
+            // Determine the context name for the error message
+            // scope_info takes precedence (e.g., "a TypeVar bound")
+            let context_name = if let Some(scope_info) = self.scope_info {
+                Some(scope_info)
+            } else if let Some(table) = self.tables.last()
+                && table.typ == CompilerScope::TypeParams
+            {
+                Some("a type parameter")
+            } else if self.in_annotation {
+                Some("an annotation")
+            } else if self.in_type_alias {
+                Some("a type alias")
+            } else {
+                None
+            };
+
+            if let Some(context_name) = context_name {
+                return Err(SymbolTableError {
+                    error: format!("{keyword} expression cannot be used within {context_name}"),
+                    location: Some(
+                        self.source_file
+                            .to_source_code()
+                            .source_location(expression.range().start(), PositionEncoding::Utf8),
+                    ),
+                });
             }
-        {
-            return Err(SymbolTableError {
-                error: format!("{keyword} expression cannot be used within a type parameter"),
-                location: Some(
-                    self.source_file
-                        .to_source_code()
-                        .source_location(expression.range().start(), PositionEncoding::Utf8),
-                ),
-            });
         }
 
         match expression {
@@ -1430,7 +1469,13 @@ impl SymbolTableBuilder {
 
         let mut is_first_generator = true;
         for generator in generators {
+            // Set flag for INNER_LOOP_CONFLICT check (only for inner loops, not the first)
+            if !is_first_generator {
+                self.in_comp_inner_loop_target = true;
+            }
             self.scan_expression(&generator.target, ExpressionContext::Iter)?;
+            self.in_comp_inner_loop_target = false;
+
             if is_first_generator {
                 is_first_generator = false;
             } else {
@@ -1453,25 +1498,55 @@ impl SymbolTableBuilder {
 
     /// Scan type parameter bound or default in a separate scope
     // = symtable_visit_type_param_bound_or_default
-    fn scan_type_param_bound_or_default(&mut self, expr: &Expr, name: &str) -> SymbolTableResult {
+    fn scan_type_param_bound_or_default(
+        &mut self,
+        expr: &Expr,
+        scope_name: &str,
+        scope_info: &'static str,
+    ) -> SymbolTableResult {
         // Enter a new TypeParams scope for the bound/default expression
         // This allows the expression to access outer scope symbols
         let line_number = self.line_index_start(expr.range());
-        self.enter_scope(name, CompilerScope::TypeParams, line_number);
+        self.enter_scope(scope_name, CompilerScope::TypeParams, line_number);
 
         // Note: In CPython, can_see_class_scope is preserved in the new scope
         // In RustPython, this is handled through the scope hierarchy
 
+        // Set scope_info for better error messages
+        let old_scope_info = self.scope_info;
+        self.scope_info = Some(scope_info);
+
         // Scan the expression in this new scope
         let result = self.scan_expression(expr, ExpressionContext::Load);
 
-        // Exit the scope
+        // Restore scope_info and exit the scope
+        self.scope_info = old_scope_info;
         self.leave_scope();
 
         result
     }
 
     fn scan_type_params(&mut self, type_params: &TypeParams) -> SymbolTableResult {
+        // Check for duplicate type parameter names
+        let mut seen_names: std::collections::HashSet<&str> = std::collections::HashSet::new();
+        for type_param in &type_params.type_params {
+            let (name, range) = match type_param {
+                TypeParam::TypeVar(tv) => (tv.name.as_str(), tv.range),
+                TypeParam::ParamSpec(ps) => (ps.name.as_str(), ps.range),
+                TypeParam::TypeVarTuple(tvt) => (tvt.name.as_str(), tvt.range),
+            };
+            if !seen_names.insert(name) {
+                return Err(SymbolTableError {
+                    error: format!("duplicate type parameter '{}'", name),
+                    location: Some(
+                        self.source_file
+                            .to_source_code()
+                            .source_location(range.start(), PositionEncoding::Utf8),
+                    ),
+                });
+            }
+        }
+
         // Register .type_params as a type parameter (automatically becomes cell variable)
         self.register_name(".type_params", SymbolUsage::TypeParam, type_params.range)?;
 
@@ -1489,18 +1564,25 @@ impl SymbolTableBuilder {
 
                     // Process bound in a separate scope
                     if let Some(binding) = bound {
-                        let scope_name = if binding.is_tuple_expr() {
-                            format!("<TypeVar constraint of {name}>")
+                        let (scope_name, scope_info) = if binding.is_tuple_expr() {
+                            (
+                                format!("<TypeVar constraint of {name}>"),
+                                "a TypeVar constraint",
+                            )
                         } else {
-                            format!("<TypeVar bound of {name}>")
+                            (format!("<TypeVar bound of {name}>"), "a TypeVar bound")
                         };
-                        self.scan_type_param_bound_or_default(binding, &scope_name)?;
+                        self.scan_type_param_bound_or_default(binding, &scope_name, scope_info)?;
                     }
 
                     // Process default in a separate scope
                     if let Some(default_value) = default {
                         let scope_name = format!("<TypeVar default of {name}>");
-                        self.scan_type_param_bound_or_default(default_value, &scope_name)?;
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a TypeVar default",
+                        )?;
                     }
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec {
@@ -1514,7 +1596,11 @@ impl SymbolTableBuilder {
                     // Process default in a separate scope
                     if let Some(default_value) = default {
                         let scope_name = format!("<ParamSpec default of {name}>");
-                        self.scan_type_param_bound_or_default(default_value, &scope_name)?;
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a ParamSpec default",
+                        )?;
                     }
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple {
@@ -1528,7 +1614,11 @@ impl SymbolTableBuilder {
                     // Process default in a separate scope
                     if let Some(default_value) = default {
                         let scope_name = format!("<TypeVarTuple default of {name}>");
-                        self.scan_type_param_bound_or_default(default_value, &scope_name)?;
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a TypeVarTuple default",
+                        )?;
                     }
                 }
             }
@@ -1667,6 +1757,23 @@ impl SymbolTableBuilder {
         // Some checks for the symbol that present on this scope level:
         let symbol = if let Some(symbol) = table.symbols.get_mut(name.as_ref()) {
             let flags = &symbol.flags;
+
+            // INNER_LOOP_CONFLICT: comprehension inner loop cannot rebind
+            // a variable that was used as a named expression target
+            // Example: [i for i in range(5) if (j := 0) for j in range(5)]
+            // Here 'j' is used in named expr first, then as inner loop iter target
+            if self.in_comp_inner_loop_target
+                && flags.contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
+            {
+                return Err(SymbolTableError {
+                    error: format!(
+                        "comprehension inner loop cannot rebind assignment expression target '{}'",
+                        name
+                    ),
+                    location,
+                });
+            }
+
             // Role already set..
             match role {
                 SymbolUsage::Global if !symbol.is_global() => {

From d3afd465f3d08e56a2b00617921ab7159bde7d97 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 17:52:24 +0900
Subject: [PATCH 137/418] fix concurrent socket close (#6612)

---
 crates/stdlib/src/socket.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
index a37a4fd241d..ea5f39cb40d 100644
--- a/crates/stdlib/src/socket.rs
+++ b/crates/stdlib/src/socket.rs
@@ -2107,9 +2107,9 @@ mod _socket {
 
         #[pymethod]
         fn close(&self) -> io::Result<()> {
-            let sock = self.detach();
-            if sock != INVALID_SOCKET as i64 {
-                close_inner(sock as RawSocket)?;
+            let sock = self.sock.write().take();
+            if let Some(sock) = sock {
+                close_inner(into_sock_fileno(sock))?;
             }
             Ok(())
         }

From a8cfa36c8a6b595e0f1299882daabc51a852a469 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 20:26:38 +0900
Subject: [PATCH 138/418] Remove duplicated richcompare pymethods and add
 missing rops' wrapper, __getattr__, proper __bool__ impl (#6579)

* slots: remove duplicate pymethods from object

* Add missing __rmul__

* migrate __bool__

* subclass_update, __getattr__
---
 crates/vm/src/builtins/object.rs        | 72 -------------------------
 crates/vm/src/builtins/range.rs         | 23 +++++---
 crates/vm/src/builtins/singletons.rs    | 30 +++++------
 crates/vm/src/builtins/tuple.rs         | 24 ++++++---
 crates/vm/src/builtins/weakproxy.rs     | 25 ++++++---
 crates/vm/src/class.rs                  |  7 +++
 crates/vm/src/stdlib/collections.rs     | 25 ++++++---
 crates/vm/src/stdlib/ctypes/function.rs | 24 ++++++---
 crates/vm/src/stdlib/ctypes/pointer.rs  | 21 +++++---
 crates/vm/src/stdlib/ctypes/simple.rs   |  8 ---
 crates/vm/src/stdlib/winreg.rs          | 15 ++----
 crates/vm/src/types/slot.rs             | 70 +++++++++++++++++++++++-
 crates/vm/src/types/slot_defs.rs        | 12 +++++
 13 files changed, 203 insertions(+), 153 deletions(-)

diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index e73f4b79ae0..6f072542547 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -326,66 +326,6 @@ impl PyBaseObject {
         Ok(res)
     }
 
-    /// Return self==value.
-    #[pymethod]
-    fn __eq__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Eq, vm)
-    }
-
-    /// Return self!=value.
-    #[pymethod]
-    fn __ne__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Ne, vm)
-    }
-
-    /// Return self<value.
-    #[pymethod]
-    fn __lt__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Lt, vm)
-    }
-
-    /// Return self<=value.
-    #[pymethod]
-    fn __le__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Le, vm)
-    }
-
-    /// Return self>=value.
-    #[pymethod]
-    fn __ge__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Ge, vm)
-    }
-
-    /// Return self>value.
-    #[pymethod]
-    fn __gt__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Gt, vm)
-    }
-
     /// Implement setattr(self, name, value).
     #[pymethod]
     fn __setattr__(
@@ -450,12 +390,6 @@ impl PyBaseObject {
         }
     }
 
-    /// Return repr(self).
-    #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
-    }
-
     #[pyclassmethod]
     fn __subclasshook__(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
         vm.ctx.not_implemented()
@@ -590,12 +524,6 @@ impl PyBaseObject {
         Ok(zelf.get_id() as _)
     }
 
-    /// Return hash(self).
-    #[pymethod]
-    fn __hash__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyHash> {
-        Self::slot_hash(&zelf, vm)
-    }
-
     #[pymethod]
     fn __sizeof__(zelf: PyObjectRef) -> usize {
         zelf.class().slots.basicsize
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index ab84c977ccd..fac5206b82d 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -8,9 +8,9 @@ use crate::{
     class::PyClassImpl,
     common::hash::PyHash,
     function::{ArgIndex, FuncArgs, OptionalArg, PyComparisonValue},
-    protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     types::{
-        AsMapping, AsSequence, Comparable, Hashable, IterNext, Iterable, PyComparisonOp,
+        AsMapping, AsNumber, AsSequence, Comparable, Hashable, IterNext, Iterable, PyComparisonOp,
         Representable, SelfIter,
     },
 };
@@ -176,6 +176,7 @@ pub fn init(context: &Context) {
     with(
         Py,
         AsMapping,
+        AsNumber,
         AsSequence,
         Hashable,
         Comparable,
@@ -269,11 +270,6 @@ impl PyRange {
         self.compute_length()
     }
 
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !self.is_empty()
-    }
-
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> (PyTypeRef, PyTupleRef) {
         let range_parameters: Vec<PyObjectRef> = [&self.start, &self.stop, &self.step]
@@ -426,6 +422,19 @@ impl AsSequence for PyRange {
     }
 }
 
+impl AsNumber for PyRange {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyRange>().unwrap();
+                Ok(!zelf.is_empty())
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl Hashable for PyRange {
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
         let length = zelf.compute_length();
diff --git a/crates/vm/src/builtins/singletons.rs b/crates/vm/src/builtins/singletons.rs
index bdc032cc865..61ab1968a45 100644
--- a/crates/vm/src/builtins/singletons.rs
+++ b/crates/vm/src/builtins/singletons.rs
@@ -50,12 +50,7 @@ impl Constructor for PyNone {
 }
 
 #[pyclass(with(Constructor, AsNumber, Representable))]
-impl PyNone {
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        false
-    }
-}
+impl PyNone {}
 
 impl Representable for PyNone {
     #[inline]
@@ -103,22 +98,27 @@ impl Constructor for PyNotImplemented {
     }
 }
 
-#[pyclass(with(Constructor))]
+#[pyclass(with(Constructor, AsNumber, Representable))]
 impl PyNotImplemented {
-    // TODO: As per https://bugs.python.org/issue35712, using NotImplemented
-    // in boolean contexts will need to raise a DeprecationWarning in 3.9
-    // and, eventually, a TypeError.
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        true
-    }
-
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyStrRef {
         vm.ctx.names.NotImplemented.to_owned()
     }
 }
 
+impl AsNumber for PyNotImplemented {
+    fn as_number() -> &'static PyNumberMethods {
+        // TODO: As per https://bugs.python.org/issue35712, using NotImplemented
+        // in boolean contexts will need to raise a DeprecationWarning in 3.9
+        // and, eventually, a TypeError.
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|_number, _vm| Ok(true)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl Representable for PyNotImplemented {
     #[inline]
     fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index 70e4e20e405..e0b8009e892 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -10,12 +10,12 @@ use crate::{
     convert::{ToPyObject, TransmuteFromObject},
     function::{ArgSize, FuncArgs, OptionalArg, PyArithmeticValue, PyComparisonValue},
     iter::PyExactSizeIterator,
-    protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     recursion::ReprGuard,
     sequence::{OptionalRangeArgs, SequenceExt},
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
-        AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
         PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
@@ -260,7 +260,7 @@ impl<T> PyTuple<PyRef<T>> {
 #[pyclass(
     itemsize = core::mem::size_of::<crate::PyObjectRef>(),
     flags(BASETYPE, SEQUENCE, _MATCH_SELF),
-    with(AsMapping, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
+    with(AsMapping, AsNumber, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
 )]
 impl PyTuple {
     #[pymethod]
@@ -286,11 +286,6 @@ impl PyTuple {
         PyArithmeticValue::from_option(added.ok())
     }
 
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        !self.elements.is_empty()
-    }
-
     #[pymethod]
     fn count(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
         let mut count: usize = 0;
@@ -423,6 +418,19 @@ impl AsSequence for PyTuple {
     }
 }
 
+impl AsNumber for PyTuple {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyTuple>().unwrap();
+                Ok(!zelf.elements.is_empty())
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl Hashable for PyTuple {
     #[inline]
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
index 94c54b5459e..51120c02c01 100644
--- a/crates/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -4,11 +4,11 @@ use crate::{
     class::PyClassImpl,
     common::hash::PyHash,
     function::{OptionalArg, PyComparisonValue, PySetterValue},
-    protocol::{PyIter, PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIter, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     stdlib::builtins::reversed,
     types::{
-        AsMapping, AsSequence, Comparable, Constructor, GetAttr, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SetAttr,
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, GetAttr, Hashable, IterNext,
+        Iterable, PyComparisonOp, Representable, SetAttr,
     },
 };
 use std::sync::LazyLock;
@@ -68,6 +68,7 @@ crate::common::static_cell! {
     SetAttr,
     Constructor,
     Comparable,
+    AsNumber,
     AsSequence,
     AsMapping,
     Representable,
@@ -87,11 +88,6 @@ impl PyWeakProxy {
         self.try_upgrade(vm)?.length(vm)
     }
 
-    #[pymethod]
-    fn __bool__(&self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.try_upgrade(vm)?.is_true(vm)
-    }
-
     #[pymethod]
     fn __bytes__(&self, vm: &VirtualMachine) -> PyResult {
         self.try_upgrade(vm)?.bytes(vm)
@@ -171,6 +167,19 @@ impl SetAttr for PyWeakProxy {
     }
 }
 
+impl AsNumber for PyWeakProxy {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: LazyLock<PyNumberMethods> = LazyLock::new(|| PyNumberMethods {
+            boolean: Some(|number, vm| {
+                let zelf = number.obj.downcast_ref::<PyWeakProxy>().unwrap();
+                zelf.try_upgrade(vm)?.is_true(vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        });
+        &AS_NUMBER
+    }
+}
+
 impl Comparable for PyWeakProxy {
     fn cmp(
         zelf: &Py<Self>,
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
index 98dc6fd2ed2..4590b62d503 100644
--- a/crates/vm/src/class.rs
+++ b/crates/vm/src/class.rs
@@ -34,6 +34,13 @@ pub fn add_operators(class: &'static Py<PyType>, ctx: &Context) {
             continue;
         }
 
+        // __getattr__ should only have a wrapper if the type explicitly defines it.
+        // Unlike __getattribute__, __getattr__ is not present on object by default.
+        // Both map to TpGetattro, but only __getattribute__ gets a wrapper from the slot.
+        if def.name == "__getattr__" {
+            continue;
+        }
+
         // Get the slot function wrapped in SlotFunc
         let Some(slot_func) = def.accessor.get_slot_func_with_op(&class.slots, def.op) else {
             continue;
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 1249fa9315d..67e8e1f2734 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -12,13 +12,13 @@ mod _collections {
         common::lock::{PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard},
         function::{KwArgs, OptionalArg, PyComparisonValue},
         iter::PyExactSizeIterator,
-        protocol::{PyIterReturn, PySequenceMethods},
+        protocol::{PyIterReturn, PyNumberMethods, PySequenceMethods},
         recursion::ReprGuard,
         sequence::{MutObjectSequenceOp, OptionalRangeArgs},
         sliceable::SequenceIndexOp,
         types::{
-            AsSequence, Comparable, Constructor, DefaultConstructor, Initializer, IterNext,
-            Iterable, PyComparisonOp, Representable, SelfIter,
+            AsNumber, AsSequence, Comparable, Constructor, DefaultConstructor, Initializer,
+            IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
         },
         utils::collection_repr,
     };
@@ -60,6 +60,7 @@ mod _collections {
         with(
             Constructor,
             Initializer,
+            AsNumber,
             AsSequence,
             Comparable,
             Iterable,
@@ -354,11 +355,6 @@ mod _collections {
             self.borrow_deque().len()
         }
 
-        #[pymethod]
-        fn __bool__(&self) -> bool {
-            !self.borrow_deque().is_empty()
-        }
-
         #[pymethod]
         fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
             self.concat(&other, vm)
@@ -496,6 +492,19 @@ mod _collections {
         }
     }
 
+    impl AsNumber for PyDeque {
+        fn as_number() -> &'static PyNumberMethods {
+            static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+                boolean: Some(|number, _vm| {
+                    let zelf = number.obj.downcast_ref::<PyDeque>().unwrap();
+                    Ok(!zelf.borrow_deque().is_empty())
+                }),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
     impl AsSequence for PyDeque {
         fn as_sequence() -> &'static PySequenceMethods {
             static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
index 5906bc91cd4..295e6fd137d 100644
--- a/crates/vm/src/stdlib/ctypes/function.rs
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -12,8 +12,8 @@ use crate::{
     builtins::{PyBytes, PyDict, PyNone, PyStr, PyTuple, PyType, PyTypeRef},
     class::StaticType,
     function::FuncArgs,
-    protocol::{BufferDescriptor, PyBuffer},
-    types::{AsBuffer, Callable, Constructor, Initializer, Representable},
+    protocol::{BufferDescriptor, PyBuffer, PyNumberMethods},
+    types::{AsBuffer, AsNumber, Callable, Constructor, Initializer, Representable},
     vm::thread::with_current_vm,
 };
 use alloc::borrow::Cow;
@@ -1772,7 +1772,10 @@ impl AsBuffer for PyCFuncPtr {
     }
 }
 
-#[pyclass(flags(BASETYPE), with(Callable, Constructor, Representable, AsBuffer))]
+#[pyclass(
+    flags(BASETYPE),
+    with(Callable, Constructor, AsNumber, Representable, AsBuffer)
+)]
 impl PyCFuncPtr {
     // restype getter/setter
     #[pygetset]
@@ -1848,11 +1851,18 @@ impl PyCFuncPtr {
             .map(|stg| stg.flags.bits())
             .unwrap_or(StgInfoFlags::empty().bits())
     }
+}
 
-    // bool conversion - check if function pointer is set
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        self.get_func_ptr() != 0
+impl AsNumber for PyCFuncPtr {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyCFuncPtr>().unwrap();
+                Ok(zelf.get_func_ptr() != 0)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
     }
 }
 
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index f564fd1965c..aad21f8fe45 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -261,7 +261,7 @@ impl Initializer for PyCPointer {
 
 #[pyclass(
     flags(BASETYPE, IMMUTABLETYPE),
-    with(Constructor, Initializer, AsBuffer)
+    with(Constructor, Initializer, AsNumber, AsBuffer)
 )]
 impl PyCPointer {
     /// Get the pointer value stored in buffer as usize
@@ -279,12 +279,6 @@ impl PyCPointer {
         }
     }
 
-    /// Pointer_bool: returns True if pointer is not NULL
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        self.get_ptr_value() != 0
-    }
-
     /// contents getter - reads address from b_ptr and creates an instance of the pointed-to type
     #[pygetset]
     fn contents(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
@@ -779,6 +773,19 @@ impl PyCPointer {
     }
 }
 
+impl AsNumber for PyCPointer {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyCPointer>().unwrap();
+                Ok(zelf.get_ptr_value() != 0)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl AsBuffer for PyCPointer {
     fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
         let stg_info = zelf
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index 7bcfa203b02..17d3aa17ad1 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -1133,14 +1133,6 @@ impl PyCSimple {
         self.0.base.read().clone()
     }
 
-    /// return True if any byte in buffer is non-zero
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        let buffer = self.0.buffer.read();
-        // Simple_bool: memcmp(self->b_ptr, zeros, self->b_size)
-        buffer.iter().any(|&b| b != 0)
-    }
-
     #[pygetset]
     pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         let zelf: &Py<Self> = instance
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
index f3d8ca10768..400cab44210 100644
--- a/crates/vm/src/stdlib/winreg.rs
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -212,11 +212,6 @@ mod winreg {
             Ok(old_hkey as usize)
         }
 
-        #[pymethod]
-        fn __bool__(&self) -> bool {
-            !self.hkey.load().is_null()
-        }
-
         #[pymethod]
         fn __enter__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             Ok(zelf)
@@ -268,13 +263,9 @@ mod winreg {
                 negative: Some(|_a, vm| PyHkey::unary_fail(vm)),
                 positive: Some(|_a, vm| PyHkey::unary_fail(vm)),
                 absolute: Some(|_a, vm| PyHkey::unary_fail(vm)),
-                boolean: Some(|a, vm| {
-                    if let Some(a) = a.downcast_ref::<PyHkey>() {
-                        Ok(a.__bool__())
-                    } else {
-                        PyHkey::unary_fail(vm)?;
-                        unreachable!()
-                    }
+                boolean: Some(|a, _vm| {
+                    let zelf = a.obj.downcast_ref::<PyHkey>().unwrap();
+                    Ok(!zelf.hkey.load().is_null())
                 }),
                 invert: Some(|_a, vm| PyHkey::unary_fail(vm)),
                 lshift: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 085cfea5cee..d7ead562063 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -601,6 +601,7 @@ impl PyType {
     /// Update slots based on dunder method changes
     ///
     /// Iterates SLOT_DEFS to find all slots matching the given name and updates them.
+    /// Also recursively updates subclasses that don't have their own definition.
     pub(crate) fn update_slot<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
         debug_assert!(name.as_str().starts_with("__"));
         debug_assert!(name.as_str().ends_with("__"));
@@ -609,6 +610,36 @@ impl PyType {
         for def in find_slot_defs_by_name(name.as_str()) {
             self.update_one_slot::<ADD>(&def.accessor, name, ctx);
         }
+
+        // Recursively update subclasses that don't have their own definition
+        self.update_subclasses::<ADD>(name, ctx);
+    }
+
+    /// Recursively update subclasses' slots
+    /// recurse_down_subclasses
+    fn update_subclasses<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
+        let subclasses = self.subclasses.read();
+        for weak_ref in subclasses.iter() {
+            let Some(subclass) = weak_ref.upgrade() else {
+                continue;
+            };
+            let Some(subclass) = subclass.downcast_ref::<PyType>() else {
+                continue;
+            };
+
+            // Skip if subclass has its own definition for this attribute
+            if subclass.attributes.read().contains_key(name) {
+                continue;
+            }
+
+            // Update subclass's slots
+            for def in find_slot_defs_by_name(name.as_str()) {
+                subclass.update_one_slot::<ADD>(&def.accessor, name, ctx);
+            }
+
+            // Recurse into subclass's subclasses
+            subclass.update_subclasses::<ADD>(name, ctx);
+        }
     }
 
     /// Update a single slot
@@ -706,7 +737,44 @@ impl PyType {
                 }
             }
             SlotAccessor::TpDel => update_main_slot!(del, del_wrapper, Del),
-            SlotAccessor::TpGetattro => update_main_slot!(getattro, getattro_wrapper, GetAttro),
+            SlotAccessor::TpGetattro => {
+                // __getattribute__ and __getattr__ both map to TpGetattro.
+                // If __getattr__ is defined anywhere in MRO, we must use the wrapper
+                // because the native slot won't call __getattr__.
+                let __getattr__ = identifier!(ctx, __getattr__);
+                let has_getattr = {
+                    let attrs = self.attributes.read();
+                    let in_self = attrs.contains_key(__getattr__);
+                    drop(attrs);
+                    // mro[0] is self, so skip it
+                    in_self
+                        || self
+                            .mro
+                            .read()
+                            .iter()
+                            .skip(1)
+                            .any(|cls| cls.attributes.read().contains_key(__getattr__))
+                };
+
+                if has_getattr {
+                    // Must use wrapper to handle __getattr__
+                    self.slots.getattro.store(Some(getattro_wrapper));
+                } else if ADD {
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::GetAttro(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.getattro.store(Some(func));
+                    } else {
+                        self.slots.getattro.store(Some(getattro_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
             SlotAccessor::TpSetattro => {
                 // __setattr__ and __delattr__ share the same slot
                 if ADD {
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
index 958adb2f27e..1fd493f685e 100644
--- a/crates/vm/src/types/slot_defs.rs
+++ b/crates/vm/src/types/slot_defs.rs
@@ -986,6 +986,12 @@ pub static SLOT_DEFS: &[SlotDef] = &[
         op: None,
         doc: "Return getattr(self, name).",
     },
+    SlotDef {
+        name: "__getattr__",
+        accessor: SlotAccessor::TpGetattro,
+        op: None,
+        doc: "Implement getattr(self, name).",
+    },
     SlotDef {
         name: "__setattr__",
         accessor: SlotAccessor::TpSetattro,
@@ -1419,6 +1425,12 @@ pub static SLOT_DEFS: &[SlotDef] = &[
         op: None,
         doc: "Return self*value.",
     },
+    SlotDef {
+        name: "__rmul__",
+        accessor: SlotAccessor::SqRepeat,
+        op: None,
+        doc: "Return value*self.",
+    },
     SlotDef {
         name: "__iadd__",
         accessor: SlotAccessor::SqInplaceConcat,

From 7c8df94f4ef81ae256390425c3f1a1d4f071b625 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 21:12:21 +0900
Subject: [PATCH 139/418] Fix __origname__ of frozen modules (#6613)

---
 crates/vm/src/import.rs     | 15 ++++++++++-----
 crates/vm/src/stdlib/imp.rs |  4 +++-
 crates/vm/src/vm/mod.rs     | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index f970a335aa5..d67bf59b35f 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -5,7 +5,7 @@ use crate::{
     builtins::{PyCode, list, traceback::PyTraceback},
     exceptions::types::PyBaseException,
     scope::Scope,
-    vm::{VirtualMachine, thread},
+    vm::{VirtualMachine, resolve_frozen_alias, thread},
 };
 
 pub(crate) fn init_importlib_base(vm: &mut VirtualMachine) -> PyResult<PyObjectRef> {
@@ -69,11 +69,16 @@ pub fn make_frozen(vm: &VirtualMachine, name: &str) -> PyResult<PyRef<PyCode>> {
 }
 
 pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
-    let frozen = make_frozen(vm, module_name)?;
-    let module = import_code_obj(vm, module_name, frozen, false)?;
+    let frozen = vm.state.frozen.get(module_name).ok_or_else(|| {
+        vm.new_import_error(
+            format!("No such frozen object named {module_name}"),
+            vm.ctx.new_str(module_name),
+        )
+    })?;
+    let module = import_code_obj(vm, module_name, vm.ctx.new_code(frozen.code), false)?;
     debug_assert!(module.get_attr(identifier!(vm, __name__), vm).is_ok());
-    // TODO: give a correct origname here
-    module.set_attr("__origname__", vm.ctx.new_str(module_name.to_owned()), vm)?;
+    let origname = resolve_frozen_alias(module_name);
+    module.set_attr("__origname__", vm.ctx.new_str(origname), vm)?;
     Ok(module)
 }
 
diff --git a/crates/vm/src/stdlib/imp.rs b/crates/vm/src/stdlib/imp.rs
index df32b0c0068..ad2cede975c 100644
--- a/crates/vm/src/stdlib/imp.rs
+++ b/crates/vm/src/stdlib/imp.rs
@@ -2,6 +2,8 @@ use crate::frozen::FrozenModule;
 use crate::{VirtualMachine, builtins::PyBaseExceptionRef};
 pub(crate) use _imp::make_module;
 
+pub use crate::vm::resolve_frozen_alias;
+
 #[cfg(feature = "threading")]
 #[pymodule(sub)]
 mod lock {
@@ -191,7 +193,7 @@ mod _imp {
             Err(e) => return Err(e.to_pyexception(name.as_str(), vm)),
         };
 
-        let origname = name; // FIXME: origname != name
+        let origname = vm.ctx.new_str(super::resolve_frozen_alias(name.as_str()));
         Ok(Some((None, info.package, origname)))
     }
 
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index b156e30b738..2eef479d1b4 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -1001,6 +1001,16 @@ impl AsRef<Context> for VirtualMachine {
     }
 }
 
+/// Resolve frozen module alias to its original name.
+/// Returns the original module name if an alias exists, otherwise returns the input name.
+pub fn resolve_frozen_alias(name: &str) -> &str {
+    match name {
+        "_frozen_importlib" => "importlib._bootstrap",
+        "_frozen_importlib_external" => "importlib._bootstrap_external",
+        _ => name,
+    }
+}
+
 fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
     let iter = core::iter::empty();
     macro_rules! ext_modules {
@@ -1064,3 +1074,26 @@ fn test_nested_frozen() {
         }
     })
 }
+
+#[test]
+fn frozen_origname_matches() {
+    use rustpython_vm as vm;
+
+    vm::Interpreter::with_init(Default::default(), |_vm| {}).enter(|vm| {
+        let check = |name, expected| {
+            let module = import::import_frozen(vm, name).unwrap();
+            let origname: PyStrRef = module
+                .get_attr("__origname__", vm)
+                .unwrap()
+                .try_into_value(vm)
+                .unwrap();
+            assert_eq!(origname.as_str(), expected);
+        };
+
+        check("_frozen_importlib", "importlib._bootstrap");
+        check(
+            "_frozen_importlib_external",
+            "importlib._bootstrap_external",
+        );
+    });
+}

From 6ccf3b5104ea9ded9797b99ec6eeb4132efe4f48 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 31 Dec 2025 14:13:29 +0200
Subject: [PATCH 140/418] Update ruff to `0.14.10` (#6271)

* Update `ruff` to `0.14.10`

* Mark failing test
---
 Cargo.lock              | 168 +++++++++++++++++++++-------------------
 Cargo.toml              |  10 +--
 Lib/test/test_syntax.py |   1 +
 3 files changed, 96 insertions(+), 83 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 89cace13b26..0b7436570a8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -113,7 +113,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -124,7 +124,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -284,9 +284,9 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "base64ct"
-version = "1.8.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55248b47b0caf0546f7988906588779981c43bb1bc9d0c44087278f80cdb44ba"
+checksum = "0e050f626429857a27ddccb31e0aca21356bfa709c04041aefddac081a8f068a"
 
 [[package]]
 name = "bindgen"
@@ -380,9 +380,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 dependencies = [
  "allocator-api2",
 ]
@@ -443,9 +443,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.47"
+version = "1.2.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
 dependencies = [
  "find-msvc-tools",
  "jobserver",
@@ -577,9 +577,9 @@ dependencies = [
 
 [[package]]
 name = "cmake"
-version = "0.1.54"
+version = "0.1.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
+checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
 dependencies = [
  "cc",
 ]
@@ -1146,7 +1146,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1181,14 +1181,14 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
  "cfg-if",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "find-msvc-tools"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
 
 [[package]]
 name = "flagset"
@@ -1282,9 +1282,9 @@ dependencies = [
 
 [[package]]
 name = "get-size-derive2"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff47daa61505c85af126e9dd64af6a342a33dc0cccfe1be74ceadc7d352e6efd"
+checksum = "ab21d7bd2c625f2064f04ce54bcb88bc57c45724cde45cba326d784e22d3f71a"
 dependencies = [
  "attribute-derive",
  "quote",
@@ -1293,9 +1293,9 @@ dependencies = [
 
 [[package]]
 name = "get-size2"
-version = "0.7.2"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac7bb8710e1f09672102be7ddf39f764d8440ae74a9f4e30aaa4820dcdffa4af"
+checksum = "879272b0de109e2b67b39fcfe3d25fdbba96ac07e44a254f5a0b4d7ff55340cb"
 dependencies = [
  "compact_str",
  "get-size-derive2",
@@ -1541,15 +1541,15 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.15"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jiff"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
+checksum = "a87d9b8105c23642f50cbbae03d1f75d8422c5cb98ce7ee9271f7ff7505be6b8"
 dependencies = [
  "jiff-static",
  "log",
@@ -1560,9 +1560,9 @@ dependencies = [
 
 [[package]]
 name = "jiff-static"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+checksum = "b787bebb543f8969132630c51fd0afab173a86c6abae56ff3b9e5e3e3f9f6e58"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1732,9 +1732,9 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.10"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
  "bitflags 2.10.0",
  "libc",
@@ -1753,9 +1753,9 @@ dependencies = [
 
 [[package]]
 name = "libz-rs-sys"
-version = "0.5.2"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "840db8cf39d9ec4dd794376f38acc40d0fc65eec2a8f484f7fd375b84602becd"
+checksum = "c10501e7805cee23da17c7790e59df2870c0d4043ec6d03f67d31e2b53e77415"
 dependencies = [
  "zlib-rs",
 ]
@@ -2140,6 +2140,12 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
+[[package]]
+name = "openssl-probe"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391"
+
 [[package]]
 name = "openssl-src"
 version = "300.5.4+3.5.4"
@@ -2390,9 +2396,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
 
 [[package]]
 name = "portable-atomic-util"
@@ -2441,9 +2447,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.103"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
 dependencies = [
  "unicode-ident",
 ]
@@ -2772,7 +2778,7 @@ dependencies = [
 [[package]]
 name = "ruff_python_ast"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=2bffef59665ce7d2630dfd72ee99846663660db8#2bffef59665ce7d2630dfd72ee99846663660db8"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "aho-corasick",
  "bitflags 2.10.0",
@@ -2791,7 +2797,7 @@ dependencies = [
 [[package]]
 name = "ruff_python_parser"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=2bffef59665ce7d2630dfd72ee99846663660db8#2bffef59665ce7d2630dfd72ee99846663660db8"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "bitflags 2.10.0",
  "bstr",
@@ -2811,7 +2817,7 @@ dependencies = [
 [[package]]
 name = "ruff_python_trivia"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=2bffef59665ce7d2630dfd72ee99846663660db8#2bffef59665ce7d2630dfd72ee99846663660db8"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "itertools 0.14.0",
  "ruff_source_file",
@@ -2822,7 +2828,7 @@ dependencies = [
 [[package]]
 name = "ruff_source_file"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=2bffef59665ce7d2630dfd72ee99846663660db8#2bffef59665ce7d2630dfd72ee99846663660db8"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "memchr",
  "ruff_text_size",
@@ -2831,7 +2837,7 @@ dependencies = [
 [[package]]
 name = "ruff_text_size"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?rev=2bffef59665ce7d2630dfd72ee99846663660db8#2bffef59665ce7d2630dfd72ee99846663660db8"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "get-size2",
 ]
@@ -2861,7 +2867,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2880,11 +2886,11 @@ dependencies = [
 
 [[package]]
 name = "rustls-native-certs"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "openssl-probe",
+ "openssl-probe 0.2.0",
  "rustls-pki-types",
  "schannel",
  "security-framework",
@@ -2901,9 +2907,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.13.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a"
+checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
 dependencies = [
  "zeroize",
 ]
@@ -2926,7 +2932,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3178,7 +3184,7 @@ dependencies = [
  "num_enum",
  "oid-registry",
  "openssl",
- "openssl-probe",
+ "openssl-probe 0.1.6",
  "openssl-sys",
  "page_size",
  "parking_lot",
@@ -3365,9 +3371,9 @@ dependencies = [
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 
 [[package]]
 name = "safe_arch"
@@ -3494,22 +3500,22 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.145"
+version = "1.0.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+checksum = "3084b546a1dd6289475996f182a22aba973866ea8e8b02c51d9f46b1336a22da"
 dependencies = [
  "itoa",
  "memchr",
- "ryu",
  "serde",
  "serde_core",
+ "zmij",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
 dependencies = [
  "serde_core",
 ]
@@ -3582,9 +3588,9 @@ dependencies = [
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "similar"
@@ -3662,9 +3668,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.111"
+version = "2.0.112"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3716,9 +3722,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.3"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
+checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
 
 [[package]]
 name = "tcl-sys"
@@ -3731,15 +3737,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.23.0"
+version = "3.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
 dependencies = [
  "fastrand",
  "getrandom 0.3.4",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3911,9 +3917,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.9.8"
+version = "0.9.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
+checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48"
 dependencies = [
  "indexmap",
  "serde_core",
@@ -3926,27 +3932,27 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.3"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_parser"
-version = "1.0.4"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
 dependencies = [
  "winnow",
 ]
 
 [[package]]
 name = "toml_writer"
-version = "1.0.4"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
 
 [[package]]
 name = "twox-hash"
@@ -4389,7 +4395,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4764,18 +4770,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.30"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.30"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4793,9 +4799,9 @@ dependencies = [
 
 [[package]]
 name = "zeroize_derive"
-version = "1.4.2"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4804,6 +4810,12 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.5.3"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3"
+
+[[package]]
+name = "zmij"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36134c44663532e6519d7a6dfdbbe06f6f8192bde8ae9ed076e9b213f0e31df7"
+checksum = "e3280a1b827474fcd5dbef4b35a674deb52ba5c312363aef9135317df179d81b"
diff --git a/Cargo.toml b/Cargo.toml
index 12607cfa2cc..988e99efacc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -151,12 +151,12 @@ rustpython-sre_engine = { path = "crates/sre_engine", version = "0.4.0" }
 rustpython-wtf8 = { path = "crates/wtf8", version = "0.4.0" }
 rustpython-doc = { path = "crates/doc", version = "0.4.0" }
 
-# Ruff tag 0.14.1 is based on commit 2bffef59665ce7d2630dfd72ee99846663660db8
+# Ruff tag 0.14.10 is based on commit 45bbb4cbffe73cf925d4579c2e3eb413e0539390
 # at the time of this capture. We use the commit hash to ensure reproducible builds.
-ruff_python_parser = { git = "https://github.com/astral-sh/ruff.git", rev = "2bffef59665ce7d2630dfd72ee99846663660db8" }
-ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", rev = "2bffef59665ce7d2630dfd72ee99846663660db8" }
-ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", rev = "2bffef59665ce7d2630dfd72ee99846663660db8" }
-ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", rev = "2bffef59665ce7d2630dfd72ee99846663660db8" }
+ruff_python_parser = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
 
 phf = { version = "0.13.1", default-features = false, features = ["macros"]}
 ahash = "0.8.12"
diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py
index 29dd04995ec..5085798b81e 100644
--- a/Lib/test/test_syntax.py
+++ b/Lib/test/test_syntax.py
@@ -2577,6 +2577,7 @@ async def bug():
             with self.subTest(f"out of range: {n=}"):
                 self._check_error(get_code(n), "too many statically nested blocks")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Wrong error message
     def test_barry_as_flufl_with_syntax_errors(self):
         # The "barry_as_flufl" rule can produce some "bugs-at-a-distance" if
         # is reading the wrong token in the presence of syntax errors later

From 1e706d911e41e37856ed1e6a8adff2f1aa13ad6c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 31 Dec 2025 22:14:28 +0900
Subject: [PATCH 141/418] Interpreter (#6614)

* Refine documentation in interpreter.rs

Improve InterpreterConfig with convenience methods (with_debug, add_path, add_paths), better documentation with working examples, refactored stdlib setup into focused functions, and comprehensive unit tests while maintaining 100% backward compatibility.

* Improve error message for non-Unicode paths

* Use consistent make_module naming in all doc examples

* cut useful changes

---------

Co-authored-by: Mohamed Gharbi <galaxysea777@gmail.com>
---
 src/interpreter.rs | 120 +++++++++++++++++++++++++++++----------------
 1 file changed, 77 insertions(+), 43 deletions(-)

diff --git a/src/interpreter.rs b/src/interpreter.rs
index b4fd319cdae..51667e724f1 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -26,15 +26,18 @@ pub type InitHook = Box<dyn FnOnce(&mut VirtualMachine)>;
 /// ```
 ///
 /// To add native modules:
-/// ```compile_fail
+/// ```
+/// use rustpython_vm::pymodule;
+///
+/// #[pymodule]
+/// mod your_module {}
+///
 /// let interpreter = rustpython::InterpreterConfig::new()
 ///     .init_stdlib()
-///     .init_hook(Box::new(|vm| {
-///         vm.add_native_module(
-///             "your_module_name".to_owned(),
-///             Box::new(your_module::make_module),
-///         );
-///     }))
+///     .add_native_module(
+///         "your_module_name".to_owned(),
+///         your_module::make_module,
+///     )
 ///     .interpreter();
 /// ```
 #[derive(Default)]
@@ -44,9 +47,12 @@ pub struct InterpreterConfig {
 }
 
 impl InterpreterConfig {
+    /// Creates a new interpreter configuration with default settings.
     pub fn new() -> Self {
         Self::default()
     }
+
+    /// Builds the interpreter with the current configuration.
     pub fn interpreter(self) -> Interpreter {
         let settings = self.settings.unwrap_or_default();
         Interpreter::with_init(settings, |vm| {
@@ -56,14 +62,23 @@ impl InterpreterConfig {
         })
     }
 
+    /// Sets custom settings for the interpreter.
+    ///
+    /// If called multiple times, only the last settings will be used.
     pub fn settings(mut self, settings: Settings) -> Self {
         self.settings = Some(settings);
         self
     }
+
+    /// Adds a custom initialization hook.
+    ///
+    /// Hooks are executed in the order they are added during interpreter creation.
     pub fn init_hook(mut self, hook: InitHook) -> Self {
         self.init_hooks.push(hook);
         self
     }
+
+    /// Adds a native module to the interpreter.
     pub fn add_native_module(
         self,
         name: String,
@@ -73,56 +88,75 @@ impl InterpreterConfig {
             vm.add_native_module(name, Box::new(make_module))
         }))
     }
+
+    /// Initializes the Python standard library.
+    ///
+    /// Requires the `stdlib` feature to be enabled.
     #[cfg(feature = "stdlib")]
     pub fn init_stdlib(self) -> Self {
         self.init_hook(Box::new(init_stdlib))
     }
 }
 
+/// Initializes all standard library modules for the given VM.
 #[cfg(feature = "stdlib")]
 pub fn init_stdlib(vm: &mut VirtualMachine) {
     vm.add_native_modules(rustpython_stdlib::get_module_inits());
 
-    // if we're on freeze-stdlib, the core stdlib modules will be included anyway
     #[cfg(feature = "freeze-stdlib")]
-    {
-        vm.add_frozen(rustpython_pylib::FROZEN_STDLIB);
-
-        // FIXME: Remove this hack once sys._stdlib_dir is properly implemented or _frozen_importlib doesn't depend on it anymore.
-        assert!(vm.sys_module.get_attr("_stdlib_dir", vm).is_err());
-        vm.sys_module
-            .set_attr(
-                "_stdlib_dir",
-                vm.new_pyobj(rustpython_pylib::LIB_PATH.to_owned()),
-                vm,
-            )
-            .unwrap();
-    }
+    setup_frozen_stdlib(vm);
 
     #[cfg(not(feature = "freeze-stdlib"))]
-    {
-        use rustpython_vm::common::rc::PyRc;
-
-        let state = PyRc::get_mut(&mut vm.state).unwrap();
-
-        // Collect additional paths to add
-        let mut additional_paths = Vec::new();
-
-        // BUILDTIME_RUSTPYTHONPATH should be set when distributing
-        if let Some(paths) = option_env!("BUILDTIME_RUSTPYTHONPATH") {
-            additional_paths.extend(
-                crate::settings::split_paths(paths)
-                    .map(|path| path.into_os_string().into_string().unwrap()),
-            )
-        } else {
-            #[cfg(feature = "rustpython-pylib")]
-            additional_paths.push(rustpython_pylib::LIB_PATH.to_owned())
-        }
+    setup_dynamic_stdlib(vm);
+}
 
-        // Add to both path_list (for compatibility) and module_search_paths (for sys.path)
-        // Insert at the beginning so stdlib comes before user paths
-        for path in additional_paths.into_iter().rev() {
-            state.config.paths.module_search_paths.insert(0, path);
+/// Setup frozen standard library (compiled into the binary)
+#[cfg(all(feature = "stdlib", feature = "freeze-stdlib"))]
+fn setup_frozen_stdlib(vm: &mut VirtualMachine) {
+    vm.add_frozen(rustpython_pylib::FROZEN_STDLIB);
+
+    // FIXME: Remove this hack once sys._stdlib_dir is properly implemented
+    // or _frozen_importlib doesn't depend on it anymore.
+    assert!(vm.sys_module.get_attr("_stdlib_dir", vm).is_err());
+    vm.sys_module
+        .set_attr(
+            "_stdlib_dir",
+            vm.new_pyobj(rustpython_pylib::LIB_PATH.to_owned()),
+            vm,
+        )
+        .unwrap();
+}
+
+/// Setup dynamic standard library loading from filesystem
+#[cfg(all(feature = "stdlib", not(feature = "freeze-stdlib")))]
+fn setup_dynamic_stdlib(vm: &mut VirtualMachine) {
+    use rustpython_vm::common::rc::PyRc;
+
+    let state = PyRc::get_mut(&mut vm.state).unwrap();
+    let paths = collect_stdlib_paths();
+
+    // Insert at the beginning so stdlib comes before user paths
+    for path in paths.into_iter().rev() {
+        state.config.paths.module_search_paths.insert(0, path);
+    }
+}
+
+/// Collect standard library paths from build-time configuration
+#[cfg(all(feature = "stdlib", not(feature = "freeze-stdlib")))]
+fn collect_stdlib_paths() -> Vec<String> {
+    // BUILDTIME_RUSTPYTHONPATH should be set when distributing
+    if let Some(paths) = option_env!("BUILDTIME_RUSTPYTHONPATH") {
+        crate::settings::split_paths(paths)
+            .map(|path| path.into_os_string().into_string().unwrap())
+            .collect()
+    } else {
+        #[cfg(feature = "rustpython-pylib")]
+        {
+            vec![rustpython_pylib::LIB_PATH.to_owned()]
+        }
+        #[cfg(not(feature = "rustpython-pylib"))]
+        {
+            vec![]
         }
     }
 }

From a4df238b3db52527b49cfe1e6ff995d17ced8673 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Wed, 31 Dec 2025 18:58:59 -0500
Subject: [PATCH 142/418] Updated the importlib + nturl2path + pathlib
 libraries + associated tests - v3.13.10 (#6609)

* Updated the nturl2path library

* Updated pathlib library + test

* Updated urllib test

* Added expectedFailure to failing tests

* Updated importlib library
---
 Lib/importlib/__init__.py                 |    4 +-
 Lib/importlib/_bootstrap.py               |   16 +-
 Lib/importlib/_bootstrap_external.py      |  103 +-
 Lib/importlib/abc.py                      |    6 +-
 Lib/importlib/machinery.py                |    1 +
 Lib/importlib/metadata/__init__.py        |  330 +-
 Lib/importlib/metadata/_adapters.py       |    2 +-
 Lib/importlib/metadata/_meta.py           |   52 +-
 Lib/importlib/metadata/diagnose.py        |   21 +
 Lib/importlib/resources/__init__.py       |   23 +-
 Lib/importlib/resources/_common.py        |   16 +-
 Lib/importlib/resources/_functional.py    |   81 +
 Lib/importlib/resources/readers.py        |   67 +-
 Lib/importlib/resources/simple.py         |    4 +-
 Lib/importlib/util.py                     |   90 +-
 Lib/nturl2path.py                         |   54 +-
 Lib/pathlib.py                            | 1435 ---------
 Lib/pathlib/__init__.py                   |   12 +
 Lib/pathlib/_abc.py                       |  930 ++++++
 Lib/pathlib/_local.py                     |  861 ++++++
 Lib/test/test_pathlib.py                  | 3328 ---------------------
 Lib/test/test_pathlib/__init__.py         |    5 +
 Lib/test/test_pathlib/test_pathlib.py     | 1660 ++++++++++
 Lib/test/test_pathlib/test_pathlib_abc.py | 2499 ++++++++++++++++
 Lib/test/test_urllib.py                   |  267 +-
 25 files changed, 6751 insertions(+), 5116 deletions(-)
 create mode 100644 Lib/importlib/metadata/diagnose.py
 create mode 100644 Lib/importlib/resources/_functional.py
 delete mode 100644 Lib/pathlib.py
 create mode 100644 Lib/pathlib/__init__.py
 create mode 100644 Lib/pathlib/_abc.py
 create mode 100644 Lib/pathlib/_local.py
 delete mode 100644 Lib/test/test_pathlib.py
 create mode 100644 Lib/test/test_pathlib/__init__.py
 create mode 100644 Lib/test/test_pathlib/test_pathlib.py
 create mode 100644 Lib/test/test_pathlib/test_pathlib_abc.py

diff --git a/Lib/importlib/__init__.py b/Lib/importlib/__init__.py
index 707c081cb2c..a7d57561ead 100644
--- a/Lib/importlib/__init__.py
+++ b/Lib/importlib/__init__.py
@@ -54,8 +54,6 @@
 # Fully bootstrapped at this point, import whatever you like, circular
 # dependencies and startup overhead minimisation permitting :)
 
-import warnings
-
 
 # Public API #########################################################
 
@@ -105,7 +103,7 @@ def reload(module):
         try:
             name = module.__name__
         except AttributeError:
-            raise TypeError("reload() argument must be a module")
+            raise TypeError("reload() argument must be a module") from None
 
     if sys.modules.get(name) is not module:
         raise ImportError(f"module {name} not in sys.modules", name=name)
diff --git a/Lib/importlib/_bootstrap.py b/Lib/importlib/_bootstrap.py
index 093a0b82456..68d993cacae 100644
--- a/Lib/importlib/_bootstrap.py
+++ b/Lib/importlib/_bootstrap.py
@@ -53,7 +53,7 @@ def _new_module(name):
 
 # For a list that can have a weakref to it.
 class _List(list):
-    pass
+    __slots__ = ("__weakref__",)
 
 
 # Copied from weakref.py with some simplifications and modifications unique to
@@ -527,7 +527,7 @@ def _load_module_shim(self, fullname):
 
     """
     msg = ("the load_module() method is deprecated and slated for removal in "
-          "Python 3.12; use exec_module() instead")
+           "Python 3.15; use exec_module() instead")
     _warnings.warn(msg, DeprecationWarning)
     spec = spec_from_loader(fullname, self)
     if fullname in sys.modules:
@@ -825,10 +825,16 @@ def _module_repr_from_spec(spec):
     """Return the repr to use for the module."""
     name = '?' if spec.name is None else spec.name
     if spec.origin is None:
-        if spec.loader is None:
+        loader = spec.loader
+        if loader is None:
             return f'<module {name!r}>'
+        elif (
+            _bootstrap_external is not None
+            and isinstance(loader, _bootstrap_external.NamespaceLoader)
+        ):
+            return f'<module {name!r} (namespace) from {list(loader._path)}>'
         else:
-            return f'<module {name!r} (namespace) from {list(spec.loader._path)}>'
+            return f'<module {name!r} ({loader!r})>'
     else:
         if spec.has_location:
             return f'<module {name!r} from {spec.origin!r}>'
@@ -1129,7 +1135,7 @@ def find_spec(cls, fullname, path=None, target=None):
         # part of the importer), instead of here (the finder part).
         # The loader is the usual place to get the data that will
         # be loaded into the module.  (For example, see _LoaderBasics
-        # in _bootstra_external.py.)  Most importantly, this importer
+        # in _bootstrap_external.py.)  Most importantly, this importer
         # is simpler if we wait to get the data.
         # However, getting as much data in the finder as possible
         # to later load the module is okay, and sometimes important.
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index 73ac4405cb5..41f538acb03 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -52,7 +52,7 @@
 
 # Bootstrap-related code ######################################################
 _CASE_INSENSITIVE_PLATFORMS_STR_KEY = 'win',
-_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY = 'cygwin', 'darwin'
+_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY = 'cygwin', 'darwin', 'ios', 'tvos', 'watchos'
 _CASE_INSENSITIVE_PLATFORMS =  (_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY
                                 + _CASE_INSENSITIVE_PLATFORMS_STR_KEY)
 
@@ -81,6 +81,11 @@ def _pack_uint32(x):
     return (int(x) & 0xFFFFFFFF).to_bytes(4, 'little')
 
 
+def _unpack_uint64(data):
+    """Convert 8 bytes in little-endian to an integer."""
+    assert len(data) == 8
+    return int.from_bytes(data, 'little')
+
 def _unpack_uint32(data):
     """Convert 4 bytes in little-endian to an integer."""
     assert len(data) == 4
@@ -203,7 +208,7 @@ def _write_atomic(path, data, mode=0o666):
     try:
         # We first write data to a temporary file, and then use os.replace() to
         # perform an atomic rename.
-        with _io.FileIO(fd, 'wb') as file:
+        with _io.open(fd, 'wb') as file:
             file.write(data)
         _os.replace(path_tmp, path)
     except OSError:
@@ -413,6 +418,7 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.11a7 3492 (make POP_JUMP_IF_NONE/NOT_NONE/TRUE/FALSE relative)
 #     Python 3.11a7 3493 (Make JUMP_IF_TRUE_OR_POP/JUMP_IF_FALSE_OR_POP relative)
 #     Python 3.11a7 3494 (New location info table)
+#     Python 3.11b4 3495 (Set line number of module's RESUME instr to 0 per PEP 626)
 #     Python 3.12a1 3500 (Remove PRECALL opcode)
 #     Python 3.12a1 3501 (YIELD_VALUE oparg == stack_depth)
 #     Python 3.12a1 3502 (LOAD_FAST_CHECK, no NULL-check in LOAD_FAST)
@@ -445,8 +451,30 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.12b1 3529 (Inline list/dict/set comprehensions)
 #     Python 3.12b1 3530 (Shrink the LOAD_SUPER_ATTR caches)
 #     Python 3.12b1 3531 (Add PEP 695 changes)
-
-#     Python 3.13 will start with 3550
+#     Python 3.13a1 3550 (Plugin optimizer support)
+#     Python 3.13a1 3551 (Compact superinstructions)
+#     Python 3.13a1 3552 (Remove LOAD_FAST__LOAD_CONST and LOAD_CONST__LOAD_FAST)
+#     Python 3.13a1 3553 (Add SET_FUNCTION_ATTRIBUTE)
+#     Python 3.13a1 3554 (more efficient bytecodes for f-strings)
+#     Python 3.13a1 3555 (generate specialized opcodes metadata from bytecodes.c)
+#     Python 3.13a1 3556 (Convert LOAD_CLOSURE to a pseudo-op)
+#     Python 3.13a1 3557 (Make the conversion to boolean in jumps explicit)
+#     Python 3.13a1 3558 (Reorder the stack items for CALL)
+#     Python 3.13a1 3559 (Generate opcode IDs from bytecodes.c)
+#     Python 3.13a1 3560 (Add RESUME_CHECK instruction)
+#     Python 3.13a1 3561 (Add cache entry to branch instructions)
+#     Python 3.13a1 3562 (Assign opcode IDs for internal ops in separate range)
+#     Python 3.13a1 3563 (Add CALL_KW and remove KW_NAMES)
+#     Python 3.13a1 3564 (Removed oparg from YIELD_VALUE, changed oparg values of RESUME)
+#     Python 3.13a1 3565 (Oparg of YIELD_VALUE indicates whether it is in a yield-from)
+#     Python 3.13a1 3566 (Emit JUMP_NO_INTERRUPT instead of JUMP for non-loop no-lineno cases)
+#     Python 3.13a1 3567 (Reimplement line number propagation by the compiler)
+#     Python 3.13a1 3568 (Change semantics of END_FOR)
+#     Python 3.13a5 3569 (Specialize CONTAINS_OP)
+#     Python 3.13a6 3570 (Add __firstlineno__ class attribute)
+#     Python 3.13b1 3571 (Fix miscompilation of private names in generic classes)
+
+#     Python 3.14 will start with 3600
 
 #     Please don't copy-paste the same pre-release tag for new entries above!!!
 #     You should always use the *upcoming* tag. For example, if 3.12a6 came out
@@ -461,7 +489,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3531).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (3571).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
@@ -535,7 +563,8 @@ def cache_from_source(path, debug_override=None, *, optimization=None):
         # Strip initial drive from a Windows path. We know we have an absolute
         # path here, so the second part of the check rules out a POSIX path that
         # happens to contain a colon at the second character.
-        if head[1] == ':' and head[0] not in path_separators:
+        # Slicing avoids issues with an empty (or short) `head`.
+        if head[1:2] == ':' and head[0:1] not in path_separators:
             head = head[2:]
 
         # Strip initial path separator from `head` to complete the conversion
@@ -1437,7 +1466,7 @@ class PathFinder:
     @staticmethod
     def invalidate_caches():
         """Call the invalidate_caches() method on all path entry finders
-        stored in sys.path_importer_caches (where implemented)."""
+        stored in sys.path_importer_cache (where implemented)."""
         for name, finder in list(sys.path_importer_cache.items()):
             # Drop entry if finder name is a relative path. The current
             # working directory may have changed.
@@ -1449,6 +1478,9 @@ def invalidate_caches():
         # https://bugs.python.org/issue45703
         _NamespacePath._epoch += 1
 
+        from importlib.metadata import MetadataPathFinder
+        MetadataPathFinder.invalidate_caches()
+
     @staticmethod
     def _path_hooks(path):
         """Search sys.path_hooks for a finder for 'path'."""
@@ -1690,6 +1722,52 @@ def __repr__(self):
         return f'FileFinder({self.path!r})'
 
 
+class AppleFrameworkLoader(ExtensionFileLoader):
+    """A loader for modules that have been packaged as frameworks for
+    compatibility with Apple's iOS App Store policies.
+    """
+    def create_module(self, spec):
+        # If the ModuleSpec has been created by the FileFinder, it will have
+        # been created with an origin pointing to the .fwork file. We need to
+        # redirect this to the location in the Frameworks folder, using the
+        # content of the .fwork file.
+        if spec.origin.endswith(".fwork"):
+            with _io.FileIO(spec.origin, 'r') as file:
+                framework_binary = file.read().decode().strip()
+            bundle_path = _path_split(sys.executable)[0]
+            spec.origin = _path_join(bundle_path, framework_binary)
+
+        # If the loader is created based on the spec for a loaded module, the
+        # path will be pointing at the Framework location. If this occurs,
+        # get the original .fwork location to use as the module's __file__.
+        if self.path.endswith(".fwork"):
+            path = self.path
+        else:
+            with _io.FileIO(self.path + ".origin", 'r') as file:
+                origin = file.read().decode().strip()
+                bundle_path = _path_split(sys.executable)[0]
+                path = _path_join(bundle_path, origin)
+
+        module = _bootstrap._call_with_frames_removed(_imp.create_dynamic, spec)
+
+        _bootstrap._verbose_message(
+            "Apple framework extension module {!r} loaded from {!r} (path {!r})",
+            spec.name,
+            spec.origin,
+            path,
+        )
+
+        # Ensure that the __file__ points at the .fwork location
+        try:
+            module.__file__ = path
+        except AttributeError:
+            # Not important enough to report.
+            # (The error is also ignored in _bootstrap._init_module_attrs or
+            # import_run_extension in import.c)
+            pass
+
+        return module
+
 # Import setup ###############################################################
 
 def _fix_up_module(ns, name, pathname, cpathname=None):
@@ -1722,10 +1800,17 @@ def _get_supported_file_loaders():
 
     Each item is a tuple (loader, suffixes).
     """
-    extensions = ExtensionFileLoader, _imp.extension_suffixes()
+    extension_loaders = []
+    if hasattr(_imp, 'create_dynamic'):
+        if sys.platform in {"ios", "tvos", "watchos"}:
+            extension_loaders = [(AppleFrameworkLoader, [
+                suffix.replace(".so", ".fwork")
+                for suffix in _imp.extension_suffixes()
+            ])]
+        extension_loaders.append((ExtensionFileLoader, _imp.extension_suffixes()))
     source = SourceFileLoader, SOURCE_SUFFIXES
     bytecode = SourcelessFileLoader, BYTECODE_SUFFIXES
-    return [extensions, source, bytecode]
+    return extension_loaders + [source, bytecode]
 
 
 def _set_bootstrap_module(_bootstrap_module):
diff --git a/Lib/importlib/abc.py b/Lib/importlib/abc.py
index b56fa94eb9c..37fef357fe2 100644
--- a/Lib/importlib/abc.py
+++ b/Lib/importlib/abc.py
@@ -180,7 +180,11 @@ def get_code(self, fullname):
         else:
             return self.source_to_code(source, path)
 
-_register(ExecutionLoader, machinery.ExtensionFileLoader)
+_register(
+    ExecutionLoader,
+    machinery.ExtensionFileLoader,
+    machinery.AppleFrameworkLoader,
+)
 
 
 class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader):
diff --git a/Lib/importlib/machinery.py b/Lib/importlib/machinery.py
index d9a19a13f7b..fbd30b159fb 100644
--- a/Lib/importlib/machinery.py
+++ b/Lib/importlib/machinery.py
@@ -12,6 +12,7 @@
 from ._bootstrap_external import SourceFileLoader
 from ._bootstrap_external import SourcelessFileLoader
 from ._bootstrap_external import ExtensionFileLoader
+from ._bootstrap_external import AppleFrameworkLoader
 from ._bootstrap_external import NamespaceLoader
 
 
diff --git a/Lib/importlib/metadata/__init__.py b/Lib/importlib/metadata/__init__.py
index 82e0ce1b281..8ce62dd864f 100644
--- a/Lib/importlib/metadata/__init__.py
+++ b/Lib/importlib/metadata/__init__.py
@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 import os
 import re
 import abc
-import csv
 import sys
+import json
 import email
+import types
+import inspect
 import pathlib
 import zipfile
 import operator
@@ -12,11 +16,9 @@
 import functools
 import itertools
 import posixpath
-import contextlib
 import collections
-import inspect
 
-from . import _adapters, _meta
+from . import _meta
 from ._collections import FreezableDefaultDict, Pair
 from ._functools import method_cache, pass_none
 from ._itertools import always_iterable, unique_everseen
@@ -26,8 +28,7 @@
 from importlib import import_module
 from importlib.abc import MetaPathFinder
 from itertools import starmap
-from typing import List, Mapping, Optional, cast
-
+from typing import Any, Iterable, List, Mapping, Match, Optional, Set, cast
 
 __all__ = [
     'Distribution',
@@ -48,11 +49,11 @@
 class PackageNotFoundError(ModuleNotFoundError):
     """The package was not found."""
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"No package metadata was found for {self.name}"
 
     @property
-    def name(self):
+    def name(self) -> str:  # type: ignore[override]
         (name,) = self.args
         return name
 
@@ -118,38 +119,11 @@ def read(text, filter_=None):
             yield Pair(name, value)
 
     @staticmethod
-    def valid(line):
+    def valid(line: str):
         return line and not line.startswith('#')
 
 
-class DeprecatedTuple:
-    """
-    Provide subscript item access for backward compatibility.
-
-    >>> recwarn = getfixture('recwarn')
-    >>> ep = EntryPoint(name='name', value='value', group='group')
-    >>> ep[:]
-    ('name', 'value', 'group')
-    >>> ep[0]
-    'name'
-    >>> len(recwarn)
-    1
-    """
-
-    # Do not remove prior to 2023-05-01 or Python 3.13
-    _warn = functools.partial(
-        warnings.warn,
-        "EntryPoint tuple interface is deprecated. Access members by name.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    def __getitem__(self, item):
-        self._warn()
-        return self._key()[item]
-
-
-class EntryPoint(DeprecatedTuple):
+class EntryPoint:
     """An entry point as defined by Python packaging conventions.
 
     See `the packaging docs on entry points
@@ -191,34 +165,37 @@ class EntryPoint(DeprecatedTuple):
     value: str
     group: str
 
-    dist: Optional['Distribution'] = None
+    dist: Optional[Distribution] = None
 
-    def __init__(self, name, value, group):
+    def __init__(self, name: str, value: str, group: str) -> None:
         vars(self).update(name=name, value=value, group=group)
 
-    def load(self):
+    def load(self) -> Any:
         """Load the entry point from its definition. If only a module
         is indicated by the value, return that module. Otherwise,
         return the named object.
         """
-        match = self.pattern.match(self.value)
+        match = cast(Match, self.pattern.match(self.value))
         module = import_module(match.group('module'))
         attrs = filter(None, (match.group('attr') or '').split('.'))
         return functools.reduce(getattr, attrs, module)
 
     @property
-    def module(self):
+    def module(self) -> str:
         match = self.pattern.match(self.value)
+        assert match is not None
         return match.group('module')
 
     @property
-    def attr(self):
+    def attr(self) -> str:
         match = self.pattern.match(self.value)
+        assert match is not None
         return match.group('attr')
 
     @property
-    def extras(self):
+    def extras(self) -> List[str]:
         match = self.pattern.match(self.value)
+        assert match is not None
         return re.findall(r'\w+', match.group('extras') or '')
 
     def _for(self, dist):
@@ -266,7 +243,7 @@ def __repr__(self):
             f'group={self.group!r})'
         )
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self._key())
 
 
@@ -277,7 +254,7 @@ class EntryPoints(tuple):
 
     __slots__ = ()
 
-    def __getitem__(self, name):  # -> EntryPoint:
+    def __getitem__(self, name: str) -> EntryPoint:  # type: ignore[override]
         """
         Get the EntryPoint in self matching name.
         """
@@ -286,7 +263,14 @@ def __getitem__(self, name):  # -> EntryPoint:
         except StopIteration:
             raise KeyError(name)
 
-    def select(self, **params):
+    def __repr__(self):
+        """
+        Repr with classname and tuple constructor to
+        signal that we deviate from regular tuple behavior.
+        """
+        return '%s(%r)' % (self.__class__.__name__, tuple(self))
+
+    def select(self, **params) -> EntryPoints:
         """
         Select entry points from self that match the
         given parameters (typically group and/or name).
@@ -294,14 +278,14 @@ def select(self, **params):
         return EntryPoints(ep for ep in self if ep.matches(**params))
 
     @property
-    def names(self):
+    def names(self) -> Set[str]:
         """
         Return the set of all names of all entry points.
         """
         return {ep.name for ep in self}
 
     @property
-    def groups(self):
+    def groups(self) -> Set[str]:
         """
         Return the set of all groups of all entry points.
         """
@@ -322,28 +306,31 @@ def _from_text(text):
 class PackagePath(pathlib.PurePosixPath):
     """A reference to a path in a package"""
 
-    def read_text(self, encoding='utf-8'):
-        with self.locate().open(encoding=encoding) as stream:
-            return stream.read()
+    hash: Optional[FileHash]
+    size: int
+    dist: Distribution
 
-    def read_binary(self):
-        with self.locate().open('rb') as stream:
-            return stream.read()
+    def read_text(self, encoding: str = 'utf-8') -> str:  # type: ignore[override]
+        return self.locate().read_text(encoding=encoding)
 
-    def locate(self):
+    def read_binary(self) -> bytes:
+        return self.locate().read_bytes()
+
+    def locate(self) -> SimplePath:
         """Return a path-like object for this path"""
         return self.dist.locate_file(self)
 
 
 class FileHash:
-    def __init__(self, spec):
+    def __init__(self, spec: str) -> None:
         self.mode, _, self.value = spec.partition('=')
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<FileHash mode: {self.mode} value: {self.value}>'
 
 
 class DeprecatedNonAbstract:
+    # Required until Python 3.14
     def __new__(cls, *args, **kwargs):
         all_names = {
             name for subclass in inspect.getmro(cls) for name in vars(subclass)
@@ -363,25 +350,48 @@ def __new__(cls, *args, **kwargs):
 
 
 class Distribution(DeprecatedNonAbstract):
-    """A Python distribution package."""
+    """
+    An abstract Python distribution package.
+
+    Custom providers may derive from this class and define
+    the abstract methods to provide a concrete implementation
+    for their environment. Some providers may opt to override
+    the default implementation of some properties to bypass
+    the file-reading mechanism.
+    """
 
     @abc.abstractmethod
     def read_text(self, filename) -> Optional[str]:
         """Attempt to load metadata file given by the name.
 
+        Python distribution metadata is organized by blobs of text
+        typically represented as "files" in the metadata directory
+        (e.g. package-1.0.dist-info). These files include things
+        like:
+
+        - METADATA: The distribution metadata including fields
+          like Name and Version and Description.
+        - entry_points.txt: A series of entry points as defined in
+          `the entry points spec <https://packaging.python.org/en/latest/specifications/entry-points/#file-format>`_.
+        - RECORD: A record of files according to
+          `this recording spec <https://packaging.python.org/en/latest/specifications/recording-installed-packages/#the-record-file>`_.
+
+        A package may provide any set of files, including those
+        not listed here or none at all.
+
         :param filename: The name of the file in the distribution info.
         :return: The text if found, otherwise None.
         """
 
     @abc.abstractmethod
-    def locate_file(self, path):
+    def locate_file(self, path: str | os.PathLike[str]) -> SimplePath:
         """
-        Given a path to a file in this distribution, return a path
+        Given a path to a file in this distribution, return a SimplePath
         to it.
         """
 
     @classmethod
-    def from_name(cls, name: str):
+    def from_name(cls, name: str) -> Distribution:
         """Return the Distribution for the given package name.
 
         :param name: The name of the distribution package to search for.
@@ -394,21 +404,23 @@ def from_name(cls, name: str):
         if not name:
             raise ValueError("A distribution name is required.")
         try:
-            return next(cls.discover(name=name))
+            return next(iter(cls.discover(name=name)))
         except StopIteration:
             raise PackageNotFoundError(name)
 
     @classmethod
-    def discover(cls, **kwargs):
+    def discover(
+        cls, *, context: Optional[DistributionFinder.Context] = None, **kwargs
+    ) -> Iterable[Distribution]:
         """Return an iterable of Distribution objects for all packages.
 
         Pass a ``context`` or pass keyword arguments for constructing
         a context.
 
         :context: A ``DistributionFinder.Context`` object.
-        :return: Iterable of Distribution objects for all packages.
+        :return: Iterable of Distribution objects for packages matching
+          the context.
         """
-        context = kwargs.pop('context', None)
         if context and kwargs:
             raise ValueError("cannot accept context and kwargs")
         context = context or DistributionFinder.Context(**kwargs)
@@ -417,8 +429,8 @@ def discover(cls, **kwargs):
         )
 
     @staticmethod
-    def at(path):
-        """Return a Distribution for the indicated metadata path
+    def at(path: str | os.PathLike[str]) -> Distribution:
+        """Return a Distribution for the indicated metadata path.
 
         :param path: a string or path-like object
         :return: a concrete Distribution instance for the path
@@ -427,7 +439,7 @@ def at(path):
 
     @staticmethod
     def _discover_resolvers():
-        """Search the meta_path for resolvers."""
+        """Search the meta_path for resolvers (MetadataPathFinders)."""
         declared = (
             getattr(finder, 'find_distributions', None) for finder in sys.meta_path
         )
@@ -438,8 +450,15 @@ def metadata(self) -> _meta.PackageMetadata:
         """Return the parsed metadata for this Distribution.
 
         The returned object will have keys that name the various bits of
-        metadata.  See PEP 566 for details.
+        metadata per the
+        `Core metadata specifications <https://packaging.python.org/en/latest/specifications/core-metadata/#core-metadata>`_.
+
+        Custom providers may provide the METADATA file or override this
+        property.
         """
+        # deferred for performance (python/cpython#109829)
+        from . import _adapters
+
         opt_text = (
             self.read_text('METADATA')
             or self.read_text('PKG-INFO')
@@ -452,7 +471,7 @@ def metadata(self) -> _meta.PackageMetadata:
         return _adapters.Message(email.message_from_string(text))
 
     @property
-    def name(self):
+    def name(self) -> str:
         """Return the 'Name' metadata for the distribution package."""
         return self.metadata['Name']
 
@@ -462,16 +481,22 @@ def _normalized_name(self):
         return Prepared.normalize(self.name)
 
     @property
-    def version(self):
+    def version(self) -> str:
         """Return the 'Version' metadata for the distribution package."""
         return self.metadata['Version']
 
     @property
-    def entry_points(self):
+    def entry_points(self) -> EntryPoints:
+        """
+        Return EntryPoints for this distribution.
+
+        Custom providers may provide the ``entry_points.txt`` file
+        or override this property.
+        """
         return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self)
 
     @property
-    def files(self):
+    def files(self) -> Optional[List[PackagePath]]:
         """Files in this distribution.
 
         :return: List of PackagePath for this distribution or None
@@ -480,6 +505,10 @@ def files(self):
         (i.e. RECORD for dist-info, or installed-files.txt or
         SOURCES.txt for egg-info) is missing.
         Result may be empty if the metadata exists but is empty.
+
+        Custom providers are recommended to provide a "RECORD" file (in
+        ``read_text``) or override this property to allow for callers to be
+        able to resolve filenames provided by the package.
         """
 
         def make_file(name, hash=None, size_str=None):
@@ -491,6 +520,10 @@ def make_file(name, hash=None, size_str=None):
 
         @pass_none
         def make_files(lines):
+            # Delay csv import, since Distribution.files is not as widely used
+            # as other parts of importlib.metadata
+            import csv
+
             return starmap(make_file, csv.reader(lines))
 
         @pass_none
@@ -507,7 +540,7 @@ def skip_missing_files(package_paths):
 
     def _read_files_distinfo(self):
         """
-        Read the lines of RECORD
+        Read the lines of RECORD.
         """
         text = self.read_text('RECORD')
         return text and text.splitlines()
@@ -534,7 +567,7 @@ def _read_files_egginfo_installed(self):
         paths = (
             (subdir / name)
             .resolve()
-            .relative_to(self.locate_file('').resolve())
+            .relative_to(self.locate_file('').resolve(), walk_up=True)
             .as_posix()
             for name in text.splitlines()
         )
@@ -556,7 +589,7 @@ def _read_files_egginfo_sources(self):
         return text and map('"{}"'.format, text.splitlines())
 
     @property
-    def requires(self):
+    def requires(self) -> Optional[List[str]]:
         """Generated requirements specified for this Distribution"""
         reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
         return reqs and list(reqs)
@@ -607,10 +640,23 @@ def url_req_space(req):
             space = url_req_space(section.value)
             yield section.value + space + quoted_marker(section.name)
 
+    @property
+    def origin(self):
+        return self._load_json('direct_url.json')
+
+    def _load_json(self, filename):
+        return pass_none(json.loads)(
+            self.read_text(filename),
+            object_hook=lambda data: types.SimpleNamespace(**data),
+        )
+
 
 class DistributionFinder(MetaPathFinder):
     """
     A MetaPathFinder capable of discovering installed distributions.
+
+    Custom providers should implement this interface in order to
+    supply metadata.
     """
 
     class Context:
@@ -623,6 +669,17 @@ class Context:
         Each DistributionFinder may expect any parameters
         and should attempt to honor the canonical
         parameters defined below when appropriate.
+
+        This mechanism gives a custom provider a means to
+        solicit additional details from the caller beyond
+        "name" and "path" when searching distributions.
+        For example, imagine a provider that exposes suites
+        of packages in either a "public" or "private" ``realm``.
+        A caller may wish to query only for distributions in
+        a particular realm and could call
+        ``distributions(realm="private")`` to signal to the
+        custom provider to only include distributions from that
+        realm.
         """
 
         name = None
@@ -635,7 +692,7 @@ def __init__(self, **kwargs):
             vars(self).update(kwargs)
 
         @property
-        def path(self):
+        def path(self) -> List[str]:
             """
             The sequence of directory path that a distribution finder
             should search.
@@ -646,7 +703,7 @@ def path(self):
             return vars(self).get('path', sys.path)
 
     @abc.abstractmethod
-    def find_distributions(self, context=Context()):
+    def find_distributions(self, context=Context()) -> Iterable[Distribution]:
         """
         Find distributions.
 
@@ -658,11 +715,18 @@ def find_distributions(self, context=Context()):
 
 class FastPath:
     """
-    Micro-optimized class for searching a path for
-    children.
+    Micro-optimized class for searching a root for children.
+
+    Root is a path on the file system that may contain metadata
+    directories either as natural directories or within a zip file.
 
     >>> FastPath('').children()
     ['...']
+
+    FastPath objects are cached and recycled for any given root.
+
+    >>> FastPath('foobar') is FastPath('foobar')
+    True
     """
 
     @functools.lru_cache()  # type: ignore
@@ -704,7 +768,19 @@ def lookup(self, mtime):
 
 
 class Lookup:
+    """
+    A micro-optimized class for searching a (fast) path for metadata.
+    """
+
     def __init__(self, path: FastPath):
+        """
+        Calculate all of the children representing metadata.
+
+        From the children in the path, calculate early all of the
+        children that appear to represent metadata (infos) or legacy
+        metadata (eggs).
+        """
+
         base = os.path.basename(path.root).lower()
         base_is_egg = base.endswith(".egg")
         self.infos = FreezableDefaultDict(list)
@@ -725,7 +801,10 @@ def __init__(self, path: FastPath):
         self.infos.freeze()
         self.eggs.freeze()
 
-    def search(self, prepared):
+    def search(self, prepared: Prepared):
+        """
+        Yield all infos and eggs matching the Prepared query.
+        """
         infos = (
             self.infos[prepared.normalized]
             if prepared
@@ -741,13 +820,28 @@ def search(self, prepared):
 
 class Prepared:
     """
-    A prepared search for metadata on a possibly-named package.
+    A prepared search query for metadata on a possibly-named package.
+
+    Pre-calculates the normalization to prevent repeated operations.
+
+    >>> none = Prepared(None)
+    >>> none.normalized
+    >>> none.legacy_normalized
+    >>> bool(none)
+    False
+    >>> sample = Prepared('Sample__Pkg-name.foo')
+    >>> sample.normalized
+    'sample_pkg_name_foo'
+    >>> sample.legacy_normalized
+    'sample__pkg_name.foo'
+    >>> bool(sample)
+    True
     """
 
     normalized = None
     legacy_normalized = None
 
-    def __init__(self, name):
+    def __init__(self, name: Optional[str]):
         self.name = name
         if name is None:
             return
@@ -775,7 +869,9 @@ def __bool__(self):
 
 class MetadataPathFinder(DistributionFinder):
     @classmethod
-    def find_distributions(cls, context=DistributionFinder.Context()):
+    def find_distributions(
+        cls, context=DistributionFinder.Context()
+    ) -> Iterable[PathDistribution]:
         """
         Find distributions.
 
@@ -795,19 +891,20 @@ def _search_paths(cls, name, paths):
             path.search(prepared) for path in map(FastPath, paths)
         )
 
-    def invalidate_caches(cls):
+    @classmethod
+    def invalidate_caches(cls) -> None:
         FastPath.__new__.cache_clear()
 
 
 class PathDistribution(Distribution):
-    def __init__(self, path: SimplePath):
+    def __init__(self, path: SimplePath) -> None:
         """Construct a distribution.
 
         :param path: SimplePath indicating the metadata directory.
         """
         self._path = path
 
-    def read_text(self, filename):
+    def read_text(self, filename: str | os.PathLike[str]) -> Optional[str]:
         with suppress(
             FileNotFoundError,
             IsADirectoryError,
@@ -817,9 +914,11 @@ def read_text(self, filename):
         ):
             return self._path.joinpath(filename).read_text(encoding='utf-8')
 
+        return None
+
     read_text.__doc__ = Distribution.read_text.__doc__
 
-    def locate_file(self, path):
+    def locate_file(self, path: str | os.PathLike[str]) -> SimplePath:
         return self._path.parent / path
 
     @property
@@ -852,7 +951,7 @@ def _name_from_stem(stem):
         return name
 
 
-def distribution(distribution_name):
+def distribution(distribution_name: str) -> Distribution:
     """Get the ``Distribution`` instance for the named package.
 
     :param distribution_name: The name of the distribution package as a string.
@@ -861,7 +960,7 @@ def distribution(distribution_name):
     return Distribution.from_name(distribution_name)
 
 
-def distributions(**kwargs):
+def distributions(**kwargs) -> Iterable[Distribution]:
     """Get all ``Distribution`` instances in the current environment.
 
     :return: An iterable of ``Distribution`` instances.
@@ -869,7 +968,7 @@ def distributions(**kwargs):
     return Distribution.discover(**kwargs)
 
 
-def metadata(distribution_name) -> _meta.PackageMetadata:
+def metadata(distribution_name: str) -> _meta.PackageMetadata:
     """Get the metadata for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -878,7 +977,7 @@ def metadata(distribution_name) -> _meta.PackageMetadata:
     return Distribution.from_name(distribution_name).metadata
 
 
-def version(distribution_name):
+def version(distribution_name: str) -> str:
     """Get the version string for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -912,7 +1011,7 @@ def entry_points(**params) -> EntryPoints:
     return EntryPoints(eps).select(**params)
 
 
-def files(distribution_name):
+def files(distribution_name: str) -> Optional[List[PackagePath]]:
     """Return a list of files for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -921,11 +1020,11 @@ def files(distribution_name):
     return distribution(distribution_name).files
 
 
-def requires(distribution_name):
+def requires(distribution_name: str) -> Optional[List[str]]:
     """
     Return a list of requirements for the named package.
 
-    :return: An iterator of requirements, suitable for
+    :return: An iterable of requirements, suitable for
         packaging.requirement.Requirement.
     """
     return distribution(distribution_name).requires
@@ -952,13 +1051,42 @@ def _top_level_declared(dist):
     return (dist.read_text('top_level.txt') or '').split()
 
 
+def _topmost(name: PackagePath) -> Optional[str]:
+    """
+    Return the top-most parent as long as there is a parent.
+    """
+    top, *rest = name.parts
+    return top if rest else None
+
+
+def _get_toplevel_name(name: PackagePath) -> str:
+    """
+    Infer a possibly importable module name from a name presumed on
+    sys.path.
+
+    >>> _get_toplevel_name(PackagePath('foo.py'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo.pyc'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo/__init__.py'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo.pth'))
+    'foo.pth'
+    >>> _get_toplevel_name(PackagePath('foo.dist-info'))
+    'foo.dist-info'
+    """
+    return _topmost(name) or (
+        # python/typeshed#10328
+        inspect.getmodulename(name)  # type: ignore
+        or str(name)
+    )
+
+
 def _top_level_inferred(dist):
-    opt_names = {
-        f.parts[0] if len(f.parts) > 1 else inspect.getmodulename(f)
-        for f in always_iterable(dist.files)
-    }
+    opt_names = set(map(_get_toplevel_name, always_iterable(dist.files)))
 
-    @pass_none
     def importable_name(name):
         return '.' not in name
 
diff --git a/Lib/importlib/metadata/_adapters.py b/Lib/importlib/metadata/_adapters.py
index 6aed69a3085..59116880895 100644
--- a/Lib/importlib/metadata/_adapters.py
+++ b/Lib/importlib/metadata/_adapters.py
@@ -53,7 +53,7 @@ def __iter__(self):
     def __getitem__(self, item):
         """
         Warn users that a ``KeyError`` can be expected when a
-        mising key is supplied. Ref python/importlib_metadata#371.
+        missing key is supplied. Ref python/importlib_metadata#371.
         """
         res = super().__getitem__(item)
         if res is None:
diff --git a/Lib/importlib/metadata/_meta.py b/Lib/importlib/metadata/_meta.py
index c9a7ef906a8..1927d0f624d 100644
--- a/Lib/importlib/metadata/_meta.py
+++ b/Lib/importlib/metadata/_meta.py
@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import os
 from typing import Protocol
 from typing import Any, Dict, Iterator, List, Optional, TypeVar, Union, overload
 
@@ -6,30 +9,27 @@
 
 
 class PackageMetadata(Protocol):
-    def __len__(self) -> int:
-        ...  # pragma: no cover
+    def __len__(self) -> int: ...  # pragma: no cover
 
-    def __contains__(self, item: str) -> bool:
-        ...  # pragma: no cover
+    def __contains__(self, item: str) -> bool: ...  # pragma: no cover
 
-    def __getitem__(self, key: str) -> str:
-        ...  # pragma: no cover
+    def __getitem__(self, key: str) -> str: ...  # pragma: no cover
 
-    def __iter__(self) -> Iterator[str]:
-        ...  # pragma: no cover
+    def __iter__(self) -> Iterator[str]: ...  # pragma: no cover
 
     @overload
-    def get(self, name: str, failobj: None = None) -> Optional[str]:
-        ...  # pragma: no cover
+    def get(
+        self, name: str, failobj: None = None
+    ) -> Optional[str]: ...  # pragma: no cover
 
     @overload
-    def get(self, name: str, failobj: _T) -> Union[str, _T]:
-        ...  # pragma: no cover
+    def get(self, name: str, failobj: _T) -> Union[str, _T]: ...  # pragma: no cover
 
     # overload per python/importlib_metadata#435
     @overload
-    def get_all(self, name: str, failobj: None = None) -> Optional[List[Any]]:
-        ...  # pragma: no cover
+    def get_all(
+        self, name: str, failobj: None = None
+    ) -> Optional[List[Any]]: ...  # pragma: no cover
 
     @overload
     def get_all(self, name: str, failobj: _T) -> Union[List[Any], _T]:
@@ -44,20 +44,24 @@ def json(self) -> Dict[str, Union[str, List[str]]]:
         """
 
 
-class SimplePath(Protocol[_T]):
+class SimplePath(Protocol):
     """
-    A minimal subset of pathlib.Path required by PathDistribution.
+    A minimal subset of pathlib.Path required by Distribution.
     """
 
-    def joinpath(self) -> _T:
-        ...  # pragma: no cover
+    def joinpath(
+        self, other: Union[str, os.PathLike[str]]
+    ) -> SimplePath: ...  # pragma: no cover
 
-    def __truediv__(self, other: Union[str, _T]) -> _T:
-        ...  # pragma: no cover
+    def __truediv__(
+        self, other: Union[str, os.PathLike[str]]
+    ) -> SimplePath: ...  # pragma: no cover
 
     @property
-    def parent(self) -> _T:
-        ...  # pragma: no cover
+    def parent(self) -> SimplePath: ...  # pragma: no cover
+
+    def read_text(self, encoding=None) -> str: ...  # pragma: no cover
+
+    def read_bytes(self) -> bytes: ...  # pragma: no cover
 
-    def read_text(self) -> str:
-        ...  # pragma: no cover
+    def exists(self) -> bool: ...  # pragma: no cover
diff --git a/Lib/importlib/metadata/diagnose.py b/Lib/importlib/metadata/diagnose.py
new file mode 100644
index 00000000000..e405471ac4d
--- /dev/null
+++ b/Lib/importlib/metadata/diagnose.py
@@ -0,0 +1,21 @@
+import sys
+
+from . import Distribution
+
+
+def inspect(path):
+    print("Inspecting", path)
+    dists = list(Distribution.discover(path=[path]))
+    if not dists:
+        return
+    print("Found", len(dists), "packages:", end=' ')
+    print(', '.join(dist.name for dist in dists))
+
+
+def run():
+    for path in sys.path:
+        inspect(path)
+
+
+if __name__ == '__main__':
+    run()
diff --git a/Lib/importlib/resources/__init__.py b/Lib/importlib/resources/__init__.py
index 34e3a9950cc..723c9f9eb33 100644
--- a/Lib/importlib/resources/__init__.py
+++ b/Lib/importlib/resources/__init__.py
@@ -1,20 +1,27 @@
-"""Read resources contained within a package."""
+"""
+Read resources contained within a package.
+
+This codebase is shared between importlib.resources in the stdlib
+and importlib_resources in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
 
 from ._common import (
     as_file,
     files,
     Package,
+    Anchor,
 )
 
-from ._legacy import (
+from ._functional import (
     contents,
+    is_resource,
     open_binary,
-    read_binary,
     open_text,
-    read_text,
-    is_resource,
     path,
-    Resource,
+    read_binary,
+    read_text,
 )
 
 from .abc import ResourceReader
@@ -22,11 +29,11 @@
 
 __all__ = [
     'Package',
-    'Resource',
+    'Anchor',
     'ResourceReader',
     'as_file',
-    'contents',
     'files',
+    'contents',
     'is_resource',
     'open_binary',
     'open_text',
diff --git a/Lib/importlib/resources/_common.py b/Lib/importlib/resources/_common.py
index b402e05116e..d9128266a2e 100644
--- a/Lib/importlib/resources/_common.py
+++ b/Lib/importlib/resources/_common.py
@@ -12,8 +12,6 @@
 from typing import Union, Optional, cast
 from .abc import ResourceReader, Traversable
 
-from ._adapters import wrap_spec
-
 Package = Union[types.ModuleType, str]
 Anchor = Package
 
@@ -27,6 +25,8 @@ def package_to_anchor(func):
     >>> files('a', 'b')
     Traceback (most recent call last):
     TypeError: files() takes from 0 to 1 positional arguments but 2 were given
+
+    Remove this compatibility in Python 3.14.
     """
     undefined = object()
 
@@ -66,10 +66,10 @@ def get_resource_reader(package: types.ModuleType) -> Optional[ResourceReader]:
     # zipimport.zipimporter does not support weak references, resulting in a
     # TypeError.  That seems terrible.
     spec = package.__spec__
-    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore
+    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore[union-attr]
     if reader is None:
         return None
-    return reader(spec.name)  # type: ignore
+    return reader(spec.name)  # type: ignore[union-attr]
 
 
 @functools.singledispatch
@@ -93,12 +93,13 @@ def _infer_caller():
     """
 
     def is_this_file(frame_info):
-        return frame_info.filename == __file__
+        return frame_info.filename == stack[0].filename
 
     def is_wrapper(frame_info):
         return frame_info.function == 'wrapper'
 
-    not_this_file = itertools.filterfalse(is_this_file, inspect.stack())
+    stack = inspect.stack()
+    not_this_file = itertools.filterfalse(is_this_file, stack)
     # also exclude 'wrapper' due to singledispatch in the call stack
     callers = itertools.filterfalse(is_wrapper, not_this_file)
     return next(callers).frame
@@ -109,6 +110,9 @@ def from_package(package: types.ModuleType):
     Return a Traversable object for the given package.
 
     """
+    # deferred for performance (python/cpython#109829)
+    from ._adapters import wrap_spec
+
     spec = wrap_spec(package)
     reader = spec.loader.get_resource_reader(spec.name)
     return reader.files()
diff --git a/Lib/importlib/resources/_functional.py b/Lib/importlib/resources/_functional.py
new file mode 100644
index 00000000000..f59416f2dd6
--- /dev/null
+++ b/Lib/importlib/resources/_functional.py
@@ -0,0 +1,81 @@
+"""Simplified function-based API for importlib.resources"""
+
+import warnings
+
+from ._common import files, as_file
+
+
+_MISSING = object()
+
+
+def open_binary(anchor, *path_names):
+    """Open for binary reading the *resource* within *package*."""
+    return _get_resource(anchor, path_names).open('rb')
+
+
+def open_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Open for text reading the *resource* within *package*."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.open('r', encoding=encoding, errors=errors)
+
+
+def read_binary(anchor, *path_names):
+    """Read and return contents of *resource* within *package* as bytes."""
+    return _get_resource(anchor, path_names).read_bytes()
+
+
+def read_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Read and return contents of *resource* within *package* as str."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.read_text(encoding=encoding, errors=errors)
+
+
+def path(anchor, *path_names):
+    """Return the path to the *resource* as an actual file system path."""
+    return as_file(_get_resource(anchor, path_names))
+
+
+def is_resource(anchor, *path_names):
+    """Return ``True`` if there is a resource named *name* in the package,
+
+    Otherwise returns ``False``.
+    """
+    return _get_resource(anchor, path_names).is_file()
+
+
+def contents(anchor, *path_names):
+    """Return an iterable over the named resources within the package.
+
+    The iterable returns :class:`str` resources (e.g. files).
+    The iterable does not recurse into subdirectories.
+    """
+    warnings.warn(
+        "importlib.resources.contents is deprecated. "
+        "Use files(anchor).iterdir() instead.",
+        DeprecationWarning,
+        stacklevel=1,
+    )
+    return (resource.name for resource in _get_resource(anchor, path_names).iterdir())
+
+
+def _get_encoding_arg(path_names, encoding):
+    # For compatibility with versions where *encoding* was a positional
+    # argument, it needs to be given explicitly when there are multiple
+    # *path_names*.
+    # This limitation can be removed in Python 3.15.
+    if encoding is _MISSING:
+        if len(path_names) > 1:
+            raise TypeError(
+                "'encoding' argument required with multiple path names",
+            )
+        else:
+            return 'utf-8'
+    return encoding
+
+
+def _get_resource(anchor, path_names):
+    if anchor is None:
+        raise TypeError("anchor must be module or string, got None")
+    return files(anchor).joinpath(*path_names)
diff --git a/Lib/importlib/resources/readers.py b/Lib/importlib/resources/readers.py
index c3cdf769cbe..70fc7e2b9c0 100644
--- a/Lib/importlib/resources/readers.py
+++ b/Lib/importlib/resources/readers.py
@@ -1,8 +1,14 @@
+from __future__ import annotations
+
 import collections
+import contextlib
 import itertools
 import pathlib
 import operator
+import re
+import warnings
 import zipfile
+from collections.abc import Iterator
 
 from . import abc
 
@@ -31,8 +37,10 @@ def files(self):
 
 class ZipReader(abc.TraversableResources):
     def __init__(self, loader, module):
-        _, _, name = module.rpartition('.')
-        self.prefix = loader.prefix.replace('\\', '/') + name + '/'
+        self.prefix = loader.prefix.replace('\\', '/')
+        if loader.is_package(module):
+            _, _, name = module.rpartition('.')
+            self.prefix += name + '/'
         self.archive = loader.archive
 
     def open_resource(self, resource):
@@ -62,7 +70,7 @@ class MultiplexedPath(abc.Traversable):
     """
 
     def __init__(self, *paths):
-        self._paths = list(map(pathlib.Path, remove_duplicates(paths)))
+        self._paths = list(map(_ensure_traversable, remove_duplicates(paths)))
         if not self._paths:
             message = 'MultiplexedPath must contain at least one path'
             raise FileNotFoundError(message)
@@ -130,7 +138,40 @@ class NamespaceReader(abc.TraversableResources):
     def __init__(self, namespace_path):
         if 'NamespacePath' not in str(namespace_path):
             raise ValueError('Invalid path')
-        self.path = MultiplexedPath(*list(namespace_path))
+        self.path = MultiplexedPath(*filter(bool, map(self._resolve, namespace_path)))
+
+    @classmethod
+    def _resolve(cls, path_str) -> abc.Traversable | None:
+        r"""
+        Given an item from a namespace path, resolve it to a Traversable.
+
+        path_str might be a directory on the filesystem or a path to a
+        zipfile plus the path within the zipfile, e.g. ``/foo/bar`` or
+        ``/foo/baz.zip/inner_dir`` or ``foo\baz.zip\inner_dir\sub``.
+
+        path_str might also be a sentinel used by editable packages to
+        trigger other behaviors (see python/importlib_resources#311).
+        In that case, return None.
+        """
+        dirs = (cand for cand in cls._candidate_paths(path_str) if cand.is_dir())
+        return next(dirs, None)
+
+    @classmethod
+    def _candidate_paths(cls, path_str: str) -> Iterator[abc.Traversable]:
+        yield pathlib.Path(path_str)
+        yield from cls._resolve_zip_path(path_str)
+
+    @staticmethod
+    def _resolve_zip_path(path_str: str):
+        for match in reversed(list(re.finditer(r'[\\/]', path_str))):
+            with contextlib.suppress(
+                FileNotFoundError,
+                IsADirectoryError,
+                NotADirectoryError,
+                PermissionError,
+            ):
+                inner = path_str[match.end() :].replace('\\', '/') + '/'
+                yield zipfile.Path(path_str[: match.start()], inner.lstrip('/'))
 
     def resource_path(self, resource):
         """
@@ -142,3 +183,21 @@ def resource_path(self, resource):
 
     def files(self):
         return self.path
+
+
+def _ensure_traversable(path):
+    """
+    Convert deprecated string arguments to traversables (pathlib.Path).
+
+    Remove with Python 3.15.
+    """
+    if not isinstance(path, str):
+        return path
+
+    warnings.warn(
+        "String arguments are deprecated. Pass a Traversable instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+    return pathlib.Path(path)
diff --git a/Lib/importlib/resources/simple.py b/Lib/importlib/resources/simple.py
index 7770c922c84..2e75299b13a 100644
--- a/Lib/importlib/resources/simple.py
+++ b/Lib/importlib/resources/simple.py
@@ -77,7 +77,7 @@ class ResourceHandle(Traversable):
 
     def __init__(self, parent: ResourceContainer, name: str):
         self.parent = parent
-        self.name = name  # type: ignore
+        self.name = name  # type: ignore[misc]
 
     def is_file(self):
         return True
@@ -88,7 +88,7 @@ def is_dir(self):
     def open(self, mode='r', *args, **kwargs):
         stream = self.parent.reader.open_binary(self.name)
         if 'b' not in mode:
-            stream = io.TextIOWrapper(*args, **kwargs)
+            stream = io.TextIOWrapper(stream, *args, **kwargs)
         return stream
 
     def joinpath(self, name):
diff --git a/Lib/importlib/util.py b/Lib/importlib/util.py
index f4d6e823315..284206b62f9 100644
--- a/Lib/importlib/util.py
+++ b/Lib/importlib/util.py
@@ -135,7 +135,7 @@ class _incompatible_extension_module_restrictions:
     may not be imported in a subinterpreter.  That implies modules
     that do not implement multi-phase init or that explicitly of out.
 
-    Likewise for modules import in a subinterpeter with its own GIL
+    Likewise for modules import in a subinterpreter with its own GIL
     when the extension does not support a per-interpreter GIL.  This
     implies the module does not have a Py_mod_multiple_interpreters slot
     set to Py_MOD_PER_INTERPRETER_GIL_SUPPORTED.
@@ -145,7 +145,7 @@ class _incompatible_extension_module_restrictions:
 
     You can get the same effect as this function by implementing the
     basic interface of multi-phase init (PEP 489) and lying about
-    support for mulitple interpreters (or per-interpreter GIL).
+    support for multiple interpreters (or per-interpreter GIL).
     """
 
     def __init__(self, *, disable_check):
@@ -171,36 +171,57 @@ class _LazyModule(types.ModuleType):
 
     def __getattribute__(self, attr):
         """Trigger the load of the module and return the attribute."""
-        # All module metadata must be garnered from __spec__ in order to avoid
-        # using mutated values.
-        # Stop triggering this method.
-        self.__class__ = types.ModuleType
-        # Get the original name to make sure no object substitution occurred
-        # in sys.modules.
-        original_name = self.__spec__.name
-        # Figure out exactly what attributes were mutated between the creation
-        # of the module and now.
-        attrs_then = self.__spec__.loader_state['__dict__']
-        attrs_now = self.__dict__
-        attrs_updated = {}
-        for key, value in attrs_now.items():
-            # Code that set the attribute may have kept a reference to the
-            # assigned object, making identity more important than equality.
-            if key not in attrs_then:
-                attrs_updated[key] = value
-            elif id(attrs_now[key]) != id(attrs_then[key]):
-                attrs_updated[key] = value
-        self.__spec__.loader.exec_module(self)
-        # If exec_module() was used directly there is no guarantee the module
-        # object was put into sys.modules.
-        if original_name in sys.modules:
-            if id(self) != id(sys.modules[original_name]):
-                raise ValueError(f"module object for {original_name!r} "
-                                  "substituted in sys.modules during a lazy "
-                                  "load")
-        # Update after loading since that's what would happen in an eager
-        # loading situation.
-        self.__dict__.update(attrs_updated)
+        __spec__ = object.__getattribute__(self, '__spec__')
+        loader_state = __spec__.loader_state
+        with loader_state['lock']:
+            # Only the first thread to get the lock should trigger the load
+            # and reset the module's class. The rest can now getattr().
+            if object.__getattribute__(self, '__class__') is _LazyModule:
+                __class__ = loader_state['__class__']
+
+                # Reentrant calls from the same thread must be allowed to proceed without
+                # triggering the load again.
+                # exec_module() and self-referential imports are the primary ways this can
+                # happen, but in any case we must return something to avoid deadlock.
+                if loader_state['is_loading']:
+                    return __class__.__getattribute__(self, attr)
+                loader_state['is_loading'] = True
+
+                __dict__ = __class__.__getattribute__(self, '__dict__')
+
+                # All module metadata must be gathered from __spec__ in order to avoid
+                # using mutated values.
+                # Get the original name to make sure no object substitution occurred
+                # in sys.modules.
+                original_name = __spec__.name
+                # Figure out exactly what attributes were mutated between the creation
+                # of the module and now.
+                attrs_then = loader_state['__dict__']
+                attrs_now = __dict__
+                attrs_updated = {}
+                for key, value in attrs_now.items():
+                    # Code that set an attribute may have kept a reference to the
+                    # assigned object, making identity more important than equality.
+                    if key not in attrs_then:
+                        attrs_updated[key] = value
+                    elif id(attrs_now[key]) != id(attrs_then[key]):
+                        attrs_updated[key] = value
+                __spec__.loader.exec_module(self)
+                # If exec_module() was used directly there is no guarantee the module
+                # object was put into sys.modules.
+                if original_name in sys.modules:
+                    if id(self) != id(sys.modules[original_name]):
+                        raise ValueError(f"module object for {original_name!r} "
+                                          "substituted in sys.modules during a lazy "
+                                          "load")
+                # Update after loading since that's what would happen in an eager
+                # loading situation.
+                __dict__.update(attrs_updated)
+                # Finally, stop triggering this method, if the module did not
+                # already update its own __class__.
+                if isinstance(self, _LazyModule):
+                    object.__setattr__(self, '__class__', __class__)
+
         return getattr(self, attr)
 
     def __delattr__(self, attr):
@@ -235,6 +256,9 @@ def create_module(self, spec):
 
     def exec_module(self, module):
         """Make the module load lazily."""
+        # Threading is only needed for lazy loading, and importlib.util can
+        # be pulled in at interpreter startup, so defer until needed.
+        import threading
         module.__spec__.loader = self.loader
         module.__loader__ = self.loader
         # Don't need to worry about deep-copying as trying to set an attribute
@@ -244,5 +268,7 @@ def exec_module(self, module):
         loader_state = {}
         loader_state['__dict__'] = module.__dict__.copy()
         loader_state['__class__'] = module.__class__
+        loader_state['lock'] = threading.RLock()
+        loader_state['is_loading'] = False
         module.__spec__.loader_state = loader_state
         module.__class__ = _LazyModule
diff --git a/Lib/nturl2path.py b/Lib/nturl2path.py
index 61852aff589..757fd01bec8 100644
--- a/Lib/nturl2path.py
+++ b/Lib/nturl2path.py
@@ -15,32 +15,29 @@ def url2pathname(url):
     # become
     #   C:\foo\bar\spam.foo
     import string, urllib.parse
+    if url[:3] == '///':
+        # URL has an empty authority section, so the path begins on the third
+        # character.
+        url = url[2:]
+    elif url[:12] == '//localhost/':
+        # Skip past 'localhost' authority.
+        url = url[11:]
+    if url[:3] == '///':
+        # Skip past extra slash before UNC drive in URL path.
+        url = url[1:]
     # Windows itself uses ":" even in URLs.
     url = url.replace(':', '|')
     if not '|' in url:
         # No drive specifier, just convert slashes
-        if url[:4] == '////':
-            # path is something like ////host/path/on/remote/host
-            # convert this to \\host\path\on\remote\host
-            # (notice halving of slashes at the start of the path)
-            url = url[2:]
-        components = url.split('/')
         # make sure not to convert quoted slashes :-)
-        return urllib.parse.unquote('\\'.join(components))
+        return urllib.parse.unquote(url.replace('/', '\\'))
     comp = url.split('|')
     if len(comp) != 2 or comp[0][-1] not in string.ascii_letters:
         error = 'Bad URL: ' + url
         raise OSError(error)
     drive = comp[0][-1].upper()
-    components = comp[1].split('/')
-    path = drive + ':'
-    for comp in components:
-        if comp:
-            path = path + '\\' + urllib.parse.unquote(comp)
-    # Issue #11474 - handing url such as |c/|
-    if path.endswith(':') and url.endswith('/'):
-        path += '\\'
-    return path
+    tail = urllib.parse.unquote(comp[1].replace('/', '\\'))
+    return drive + ':' + tail
 
 def pathname2url(p):
     """OS-specific conversion from a file system path to a relative URL
@@ -52,30 +49,21 @@ def pathname2url(p):
     import urllib.parse
     # First, clean up some special forms. We are going to sacrifice
     # the additional information anyway
-    if p[:4] == '\\\\?\\':
+    p = p.replace('\\', '/')
+    if p[:4] == '//?/':
         p = p[4:]
-        if p[:4].upper() == 'UNC\\':
-            p = '\\' + p[4:]
+        if p[:4].upper() == 'UNC/':
+            p = '//' + p[4:]
         elif p[1:2] != ':':
             raise OSError('Bad path: ' + p)
     if not ':' in p:
-        # No drive specifier, just convert slashes and quote the name
-        if p[:2] == '\\\\':
-        # path is something like \\host\path\on\remote\host
-        # convert this to ////host/path/on/remote/host
-        # (notice doubling of slashes at the start of the path)
-            p = '\\\\' + p
-        components = p.split('\\')
-        return urllib.parse.quote('/'.join(components))
+        # No DOS drive specified, just quote the pathname
+        return urllib.parse.quote(p)
     comp = p.split(':', maxsplit=2)
     if len(comp) != 2 or len(comp[0]) > 1:
         error = 'Bad path: ' + p
         raise OSError(error)
 
     drive = urllib.parse.quote(comp[0].upper())
-    components = comp[1].split('\\')
-    path = '///' + drive + ':'
-    for comp in components:
-        if comp:
-            path = path + '/' + urllib.parse.quote(comp)
-    return path
+    tail = urllib.parse.quote(comp[1])
+    return '///' + drive + ':' + tail
diff --git a/Lib/pathlib.py b/Lib/pathlib.py
deleted file mode 100644
index bd5a096f9e3..00000000000
--- a/Lib/pathlib.py
+++ /dev/null
@@ -1,1435 +0,0 @@
-"""Object-oriented filesystem paths.
-
-This module provides classes to represent abstract paths and concrete
-paths with operations that have semantics appropriate for different
-operating systems.
-"""
-
-import fnmatch
-import functools
-import io
-import ntpath
-import os
-import posixpath
-import re
-import sys
-import warnings
-from _collections_abc import Sequence
-from errno import ENOENT, ENOTDIR, EBADF, ELOOP
-from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
-from urllib.parse import quote_from_bytes as urlquote_from_bytes
-
-
-__all__ = [
-    "PurePath", "PurePosixPath", "PureWindowsPath",
-    "Path", "PosixPath", "WindowsPath",
-    ]
-
-#
-# Internals
-#
-
-# Reference for Windows paths can be found at
-# https://learn.microsoft.com/en-gb/windows/win32/fileio/naming-a-file .
-_WIN_RESERVED_NAMES = frozenset(
-    {'CON', 'PRN', 'AUX', 'NUL', 'CONIN$', 'CONOUT$'} |
-    {f'COM{c}' for c in '123456789\xb9\xb2\xb3'} |
-    {f'LPT{c}' for c in '123456789\xb9\xb2\xb3'}
-)
-
-_WINERROR_NOT_READY = 21  # drive exists but is not accessible
-_WINERROR_INVALID_NAME = 123  # fix for bpo-35306
-_WINERROR_CANT_RESOLVE_FILENAME = 1921  # broken symlink pointing to itself
-
-# EBADF - guard against macOS `stat` throwing EBADF
-_IGNORED_ERRNOS = (ENOENT, ENOTDIR, EBADF, ELOOP)
-
-_IGNORED_WINERRORS = (
-    _WINERROR_NOT_READY,
-    _WINERROR_INVALID_NAME,
-    _WINERROR_CANT_RESOLVE_FILENAME)
-
-def _ignore_error(exception):
-    return (getattr(exception, 'errno', None) in _IGNORED_ERRNOS or
-            getattr(exception, 'winerror', None) in _IGNORED_WINERRORS)
-
-
-@functools.cache
-def _is_case_sensitive(flavour):
-    return flavour.normcase('Aa') == 'Aa'
-
-#
-# Globbing helpers
-#
-
-
-# fnmatch.translate() returns a regular expression that includes a prefix and
-# a suffix, which enable matching newlines and ensure the end of the string is
-# matched, respectively. These features are undesirable for our implementation
-# of PurePatch.match(), which represents path separators as newlines and joins
-# pattern segments together. As a workaround, we define a slice object that
-# can remove the prefix and suffix from any translate() result. See the
-# _compile_pattern_lines() function for more details.
-_FNMATCH_PREFIX, _FNMATCH_SUFFIX = fnmatch.translate('_').split('_')
-_FNMATCH_SLICE = slice(len(_FNMATCH_PREFIX), -len(_FNMATCH_SUFFIX))
-_SWAP_SEP_AND_NEWLINE = {
-    '/': str.maketrans({'/': '\n', '\n': '/'}),
-    '\\': str.maketrans({'\\': '\n', '\n': '\\'}),
-}
-
-
-@functools.lru_cache()
-def _make_selector(pattern_parts, flavour, case_sensitive):
-    pat = pattern_parts[0]
-    if not pat:
-        return _TerminatingSelector()
-    if pat == '**':
-        child_parts_idx = 1
-        while child_parts_idx < len(pattern_parts) and pattern_parts[child_parts_idx] == '**':
-            child_parts_idx += 1
-        child_parts = pattern_parts[child_parts_idx:]
-        if '**' in child_parts:
-            cls = _DoubleRecursiveWildcardSelector
-        else:
-            cls = _RecursiveWildcardSelector
-    else:
-        child_parts = pattern_parts[1:]
-        if pat == '..':
-            cls = _ParentSelector
-        elif '**' in pat:
-            raise ValueError("Invalid pattern: '**' can only be an entire path component")
-        else:
-            cls = _WildcardSelector
-    return cls(pat, child_parts, flavour, case_sensitive)
-
-
-@functools.lru_cache(maxsize=256)
-def _compile_pattern(pat, case_sensitive):
-    flags = re.NOFLAG if case_sensitive else re.IGNORECASE
-    return re.compile(fnmatch.translate(pat), flags).match
-
-
-@functools.lru_cache()
-def _compile_pattern_lines(pattern_lines, case_sensitive):
-    """Compile the given pattern lines to an `re.Pattern` object.
-
-    The *pattern_lines* argument is a glob-style pattern (e.g. '*/*.py') with
-    its path separators and newlines swapped (e.g. '*\n*.py`). By using
-    newlines to separate path components, and not setting `re.DOTALL`, we
-    ensure that the `*` wildcard cannot match path separators.
-
-    The returned `re.Pattern` object may have its `match()` method called to
-    match a complete pattern, or `search()` to match from the right. The
-    argument supplied to these methods must also have its path separators and
-    newlines swapped.
-    """
-
-    # Match the start of the path, or just after a path separator
-    parts = ['^']
-    for part in pattern_lines.splitlines(keepends=True):
-        if part == '*\n':
-            part = r'.+\n'
-        elif part == '*':
-            part = r'.+'
-        else:
-            # Any other component: pass to fnmatch.translate(). We slice off
-            # the common prefix and suffix added by translate() to ensure that
-            # re.DOTALL is not set, and the end of the string not matched,
-            # respectively. With DOTALL not set, '*' wildcards will not match
-            # path separators, because the '.' characters in the pattern will
-            # not match newlines.
-            part = fnmatch.translate(part)[_FNMATCH_SLICE]
-        parts.append(part)
-    # Match the end of the path, always.
-    parts.append(r'\Z')
-    flags = re.MULTILINE
-    if not case_sensitive:
-        flags |= re.IGNORECASE
-    return re.compile(''.join(parts), flags=flags)
-
-
-class _Selector:
-    """A selector matches a specific glob pattern part against the children
-    of a given path."""
-
-    def __init__(self, child_parts, flavour, case_sensitive):
-        self.child_parts = child_parts
-        if child_parts:
-            self.successor = _make_selector(child_parts, flavour, case_sensitive)
-            self.dironly = True
-        else:
-            self.successor = _TerminatingSelector()
-            self.dironly = False
-
-    def select_from(self, parent_path):
-        """Iterate over all child paths of `parent_path` matched by this
-        selector.  This can contain parent_path itself."""
-        path_cls = type(parent_path)
-        scandir = path_cls._scandir
-        if not parent_path.is_dir():
-            return iter([])
-        return self._select_from(parent_path, scandir)
-
-
-class _TerminatingSelector:
-
-    def _select_from(self, parent_path, scandir):
-        yield parent_path
-
-
-class _ParentSelector(_Selector):
-
-    def __init__(self, name, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-
-    def _select_from(self,  parent_path, scandir):
-        path = parent_path._make_child_relpath('..')
-        for p in self.successor._select_from(path, scandir):
-            yield p
-
-
-class _WildcardSelector(_Selector):
-
-    def __init__(self, pat, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-        if case_sensitive is None:
-            # TODO: evaluate case-sensitivity of each directory in _select_from()
-            case_sensitive = _is_case_sensitive(flavour)
-        self.match = _compile_pattern(pat, case_sensitive)
-
-    def _select_from(self, parent_path, scandir):
-        try:
-            # We must close the scandir() object before proceeding to
-            # avoid exhausting file descriptors when globbing deep trees.
-            with scandir(parent_path) as scandir_it:
-                entries = list(scandir_it)
-        except OSError:
-            pass
-        else:
-            for entry in entries:
-                if self.dironly:
-                    try:
-                        if not entry.is_dir():
-                            continue
-                    except OSError:
-                        continue
-                name = entry.name
-                if self.match(name):
-                    path = parent_path._make_child_relpath(name)
-                    for p in self.successor._select_from(path, scandir):
-                        yield p
-
-
-class _RecursiveWildcardSelector(_Selector):
-
-    def __init__(self, pat, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-
-    def _iterate_directories(self, parent_path):
-        yield parent_path
-        for dirpath, dirnames, _ in parent_path.walk():
-            for dirname in dirnames:
-                yield dirpath._make_child_relpath(dirname)
-
-    def _select_from(self, parent_path, scandir):
-        successor_select = self.successor._select_from
-        for starting_point in self._iterate_directories(parent_path):
-            for p in successor_select(starting_point, scandir):
-                yield p
-
-
-class _DoubleRecursiveWildcardSelector(_RecursiveWildcardSelector):
-    """
-    Like _RecursiveWildcardSelector, but also de-duplicates results from
-    successive selectors. This is necessary if the pattern contains
-    multiple non-adjacent '**' segments.
-    """
-
-    def _select_from(self, parent_path, scandir):
-        yielded = set()
-        try:
-            for p in super()._select_from(parent_path, scandir):
-                if p not in yielded:
-                    yield p
-                    yielded.add(p)
-        finally:
-            yielded.clear()
-
-
-#
-# Public API
-#
-
-class _PathParents(Sequence):
-    """This object provides sequence-like access to the logical ancestors
-    of a path.  Don't try to construct it yourself."""
-    __slots__ = ('_path', '_drv', '_root', '_tail')
-
-    def __init__(self, path):
-        self._path = path
-        self._drv = path.drive
-        self._root = path.root
-        self._tail = path._tail
-
-    def __len__(self):
-        return len(self._tail)
-
-    def __getitem__(self, idx):
-        if isinstance(idx, slice):
-            return tuple(self[i] for i in range(*idx.indices(len(self))))
-
-        if idx >= len(self) or idx < -len(self):
-            raise IndexError(idx)
-        if idx < 0:
-            idx += len(self)
-        return self._path._from_parsed_parts(self._drv, self._root,
-                                             self._tail[:-idx - 1])
-
-    def __repr__(self):
-        return "<{}.parents>".format(type(self._path).__name__)
-
-
-class PurePath(object):
-    """Base class for manipulating paths without I/O.
-
-    PurePath represents a filesystem path and offers operations which
-    don't imply any actual filesystem I/O.  Depending on your system,
-    instantiating a PurePath will return either a PurePosixPath or a
-    PureWindowsPath object.  You can also instantiate either of these classes
-    directly, regardless of your system.
-    """
-
-    __slots__ = (
-        # The `_raw_paths` slot stores unnormalized string paths. This is set
-        # in the `__init__()` method.
-        '_raw_paths',
-
-        # The `_drv`, `_root` and `_tail_cached` slots store parsed and
-        # normalized parts of the path. They are set when any of the `drive`,
-        # `root` or `_tail` properties are accessed for the first time. The
-        # three-part division corresponds to the result of
-        # `os.path.splitroot()`, except that the tail is further split on path
-        # separators (i.e. it is a list of strings), and that the root and
-        # tail are normalized.
-        '_drv', '_root', '_tail_cached',
-
-        # The `_str` slot stores the string representation of the path,
-        # computed from the drive, root and tail when `__str__()` is called
-        # for the first time. It's used to implement `_str_normcase`
-        '_str',
-
-        # The `_str_normcase_cached` slot stores the string path with
-        # normalized case. It is set when the `_str_normcase` property is
-        # accessed for the first time. It's used to implement `__eq__()`
-        # `__hash__()`, and `_parts_normcase`
-        '_str_normcase_cached',
-
-        # The `_parts_normcase_cached` slot stores the case-normalized
-        # string path after splitting on path separators. It's set when the
-        # `_parts_normcase` property is accessed for the first time. It's used
-        # to implement comparison methods like `__lt__()`.
-        '_parts_normcase_cached',
-
-        # The `_lines_cached` slot stores the string path with path separators
-        # and newlines swapped. This is used to implement `match()`.
-        '_lines_cached',
-
-        # The `_hash` slot stores the hash of the case-normalized string
-        # path. It's set when `__hash__()` is called for the first time.
-        '_hash',
-    )
-    _flavour = os.path
-
-    def __new__(cls, *args, **kwargs):
-        """Construct a PurePath from one or several strings and or existing
-        PurePath objects.  The strings and path objects are combined so as
-        to yield a canonicalized path, which is incorporated into the
-        new PurePath object.
-        """
-        if cls is PurePath:
-            cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
-        return object.__new__(cls)
-
-    def __reduce__(self):
-        # Using the parts tuple helps share interned path parts
-        # when pickling related paths.
-        return (self.__class__, self.parts)
-
-    def __init__(self, *args):
-        paths = []
-        for arg in args:
-            if isinstance(arg, PurePath):
-                if arg._flavour is ntpath and self._flavour is posixpath:
-                    # GH-103631: Convert separators for backwards compatibility.
-                    paths.extend(path.replace('\\', '/') for path in arg._raw_paths)
-                else:
-                    paths.extend(arg._raw_paths)
-            else:
-                try:
-                    path = os.fspath(arg)
-                except TypeError:
-                    path = arg
-                if not isinstance(path, str):
-                    raise TypeError(
-                        "argument should be a str or an os.PathLike "
-                        "object where __fspath__ returns a str, "
-                        f"not {type(path).__name__!r}")
-                paths.append(path)
-        self._raw_paths = paths
-
-    def with_segments(self, *pathsegments):
-        """Construct a new path object from any number of path-like objects.
-        Subclasses may override this method to customize how new path objects
-        are created from methods like `iterdir()`.
-        """
-        return type(self)(*pathsegments)
-
-    @classmethod
-    def _parse_path(cls, path):
-        if not path:
-            return '', '', []
-        sep = cls._flavour.sep
-        altsep = cls._flavour.altsep
-        if altsep:
-            path = path.replace(altsep, sep)
-        drv, root, rel = cls._flavour.splitroot(path)
-        if not root and drv.startswith(sep) and not drv.endswith(sep):
-            drv_parts = drv.split(sep)
-            if len(drv_parts) == 4 and drv_parts[2] not in '?.':
-                # e.g. //server/share
-                root = sep
-            elif len(drv_parts) == 6:
-                # e.g. //?/unc/server/share
-                root = sep
-        parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
-        return drv, root, parsed
-
-    def _load_parts(self):
-        paths = self._raw_paths
-        if len(paths) == 0:
-            path = ''
-        elif len(paths) == 1:
-            path = paths[0]
-        else:
-            path = self._flavour.join(*paths)
-        drv, root, tail = self._parse_path(path)
-        self._drv = drv
-        self._root = root
-        self._tail_cached = tail
-
-    def _from_parsed_parts(self, drv, root, tail):
-        path_str = self._format_parsed_parts(drv, root, tail)
-        path = self.with_segments(path_str)
-        path._str = path_str or '.'
-        path._drv = drv
-        path._root = root
-        path._tail_cached = tail
-        return path
-
-    @classmethod
-    def _format_parsed_parts(cls, drv, root, tail):
-        if drv or root:
-            return drv + root + cls._flavour.sep.join(tail)
-        elif tail and cls._flavour.splitdrive(tail[0])[0]:
-            tail = ['.'] + tail
-        return cls._flavour.sep.join(tail)
-
-    def __str__(self):
-        """Return the string representation of the path, suitable for
-        passing to system calls."""
-        try:
-            return self._str
-        except AttributeError:
-            self._str = self._format_parsed_parts(self.drive, self.root,
-                                                  self._tail) or '.'
-            return self._str
-
-    def __fspath__(self):
-        return str(self)
-
-    def as_posix(self):
-        """Return the string representation of the path with forward (/)
-        slashes."""
-        f = self._flavour
-        return str(self).replace(f.sep, '/')
-
-    def __bytes__(self):
-        """Return the bytes representation of the path.  This is only
-        recommended to use under Unix."""
-        return os.fsencode(self)
-
-    def __repr__(self):
-        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
-
-    def as_uri(self):
-        """Return the path as a 'file' URI."""
-        if not self.is_absolute():
-            raise ValueError("relative path can't be expressed as a file URI")
-
-        drive = self.drive
-        if len(drive) == 2 and drive[1] == ':':
-            # It's a path on a local drive => 'file:///c:/a/b'
-            prefix = 'file:///' + drive
-            path = self.as_posix()[2:]
-        elif drive:
-            # It's a path on a network drive => 'file://host/share/a/b'
-            prefix = 'file:'
-            path = self.as_posix()
-        else:
-            # It's a posix path => 'file:///etc/hosts'
-            prefix = 'file://'
-            path = str(self)
-        return prefix + urlquote_from_bytes(os.fsencode(path))
-
-    @property
-    def _str_normcase(self):
-        # String with normalized case, for hashing and equality checks
-        try:
-            return self._str_normcase_cached
-        except AttributeError:
-            if _is_case_sensitive(self._flavour):
-                self._str_normcase_cached = str(self)
-            else:
-                self._str_normcase_cached = str(self).lower()
-            return self._str_normcase_cached
-
-    @property
-    def _parts_normcase(self):
-        # Cached parts with normalized case, for comparisons.
-        try:
-            return self._parts_normcase_cached
-        except AttributeError:
-            self._parts_normcase_cached = self._str_normcase.split(self._flavour.sep)
-            return self._parts_normcase_cached
-
-    @property
-    def _lines(self):
-        # Path with separators and newlines swapped, for pattern matching.
-        try:
-            return self._lines_cached
-        except AttributeError:
-            path_str = str(self)
-            if path_str == '.':
-                self._lines_cached = ''
-            else:
-                trans = _SWAP_SEP_AND_NEWLINE[self._flavour.sep]
-                self._lines_cached = path_str.translate(trans)
-            return self._lines_cached
-
-    def __eq__(self, other):
-        if not isinstance(other, PurePath):
-            return NotImplemented
-        return self._str_normcase == other._str_normcase and self._flavour is other._flavour
-
-    def __hash__(self):
-        try:
-            return self._hash
-        except AttributeError:
-            self._hash = hash(self._str_normcase)
-            return self._hash
-
-    def __lt__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase < other._parts_normcase
-
-    def __le__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase <= other._parts_normcase
-
-    def __gt__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase > other._parts_normcase
-
-    def __ge__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase >= other._parts_normcase
-
-    @property
-    def drive(self):
-        """The drive prefix (letter or UNC path), if any."""
-        try:
-            return self._drv
-        except AttributeError:
-            self._load_parts()
-            return self._drv
-
-    @property
-    def root(self):
-        """The root of the path, if any."""
-        try:
-            return self._root
-        except AttributeError:
-            self._load_parts()
-            return self._root
-
-    @property
-    def _tail(self):
-        try:
-            return self._tail_cached
-        except AttributeError:
-            self._load_parts()
-            return self._tail_cached
-
-    @property
-    def anchor(self):
-        """The concatenation of the drive and root, or ''."""
-        anchor = self.drive + self.root
-        return anchor
-
-    @property
-    def name(self):
-        """The final path component, if any."""
-        tail = self._tail
-        if not tail:
-            return ''
-        return tail[-1]
-
-    @property
-    def suffix(self):
-        """
-        The final component's last suffix, if any.
-
-        This includes the leading period. For example: '.txt'
-        """
-        name = self.name
-        i = name.rfind('.')
-        if 0 < i < len(name) - 1:
-            return name[i:]
-        else:
-            return ''
-
-    @property
-    def suffixes(self):
-        """
-        A list of the final component's suffixes, if any.
-
-        These include the leading periods. For example: ['.tar', '.gz']
-        """
-        name = self.name
-        if name.endswith('.'):
-            return []
-        name = name.lstrip('.')
-        return ['.' + suffix for suffix in name.split('.')[1:]]
-
-    @property
-    def stem(self):
-        """The final path component, minus its last suffix."""
-        name = self.name
-        i = name.rfind('.')
-        if 0 < i < len(name) - 1:
-            return name[:i]
-        else:
-            return name
-
-    def with_name(self, name):
-        """Return a new path with the file name changed."""
-        if not self.name:
-            raise ValueError("%r has an empty name" % (self,))
-        f = self._flavour
-        if not name or f.sep in name or (f.altsep and f.altsep in name) or name == '.':
-            raise ValueError("Invalid name %r" % (name))
-        return self._from_parsed_parts(self.drive, self.root,
-                                       self._tail[:-1] + [name])
-
-    def with_stem(self, stem):
-        """Return a new path with the stem changed."""
-        return self.with_name(stem + self.suffix)
-
-    def with_suffix(self, suffix):
-        """Return a new path with the file suffix changed.  If the path
-        has no suffix, add given suffix.  If the given suffix is an empty
-        string, remove the suffix from the path.
-        """
-        f = self._flavour
-        if f.sep in suffix or f.altsep and f.altsep in suffix:
-            raise ValueError("Invalid suffix %r" % (suffix,))
-        if suffix and not suffix.startswith('.') or suffix == '.':
-            raise ValueError("Invalid suffix %r" % (suffix))
-        name = self.name
-        if not name:
-            raise ValueError("%r has an empty name" % (self,))
-        old_suffix = self.suffix
-        if not old_suffix:
-            name = name + suffix
-        else:
-            name = name[:-len(old_suffix)] + suffix
-        return self._from_parsed_parts(self.drive, self.root,
-                                       self._tail[:-1] + [name])
-
-    def relative_to(self, other, /, *_deprecated, walk_up=False):
-        """Return the relative path to another path identified by the passed
-        arguments.  If the operation is not possible (because this is not
-        related to the other path), raise ValueError.
-
-        The *walk_up* parameter controls whether `..` may be used to resolve
-        the path.
-        """
-        if _deprecated:
-            msg = ("support for supplying more than one positional argument "
-                   "to pathlib.PurePath.relative_to() is deprecated and "
-                   "scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath.relative_to(*args)", msg,
-                                 remove=(3, 14))
-        other = self.with_segments(other, *_deprecated)
-        for step, path in enumerate([other] + list(other.parents)):
-            if self.is_relative_to(path):
-                break
-            elif not walk_up:
-                raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
-            elif path.name == '..':
-                raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
-        else:
-            raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
-        parts = ['..'] * step + self._tail[len(path._tail):]
-        return self.with_segments(*parts)
-
-    def is_relative_to(self, other, /, *_deprecated):
-        """Return True if the path is relative to another path or False.
-        """
-        if _deprecated:
-            msg = ("support for supplying more than one argument to "
-                   "pathlib.PurePath.is_relative_to() is deprecated and "
-                   "scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath.is_relative_to(*args)",
-                                 msg, remove=(3, 14))
-        other = self.with_segments(other, *_deprecated)
-        return other == self or other in self.parents
-
-    @property
-    def parts(self):
-        """An object providing sequence-like access to the
-        components in the filesystem path."""
-        if self.drive or self.root:
-            return (self.drive + self.root,) + tuple(self._tail)
-        else:
-            return tuple(self._tail)
-
-    def joinpath(self, *pathsegments):
-        """Combine this path with one or several arguments, and return a
-        new path representing either a subpath (if all arguments are relative
-        paths) or a totally different path (if one of the arguments is
-        anchored).
-        """
-        return self.with_segments(self, *pathsegments)
-
-    def __truediv__(self, key):
-        try:
-            return self.joinpath(key)
-        except TypeError:
-            return NotImplemented
-
-    def __rtruediv__(self, key):
-        try:
-            return self.with_segments(key, self)
-        except TypeError:
-            return NotImplemented
-
-    @property
-    def parent(self):
-        """The logical parent of the path."""
-        drv = self.drive
-        root = self.root
-        tail = self._tail
-        if not tail:
-            return self
-        return self._from_parsed_parts(drv, root, tail[:-1])
-
-    @property
-    def parents(self):
-        """A sequence of this path's logical parents."""
-        # The value of this property should not be cached on the path object,
-        # as doing so would introduce a reference cycle.
-        return _PathParents(self)
-
-    def is_absolute(self):
-        """True if the path is absolute (has both a root and, if applicable,
-        a drive)."""
-        if self._flavour is ntpath:
-            # ntpath.isabs() is defective - see GH-44626.
-            return bool(self.drive and self.root)
-        elif self._flavour is posixpath:
-            # Optimization: work with raw paths on POSIX.
-            for path in self._raw_paths:
-                if path.startswith('/'):
-                    return True
-            return False
-        else:
-            return self._flavour.isabs(str(self))
-
-    def is_reserved(self):
-        """Return True if the path contains one of the special names reserved
-        by the system, if any."""
-        if self._flavour is posixpath or not self._tail:
-            return False
-
-        # NOTE: the rules for reserved names seem somewhat complicated
-        # (e.g. r"..\NUL" is reserved but not r"foo\NUL" if "foo" does not
-        # exist). We err on the side of caution and return True for paths
-        # which are not considered reserved by Windows.
-        if self.drive.startswith('\\\\'):
-            # UNC paths are never reserved.
-            return False
-        name = self._tail[-1].partition('.')[0].partition(':')[0].rstrip(' ')
-        return name.upper() in _WIN_RESERVED_NAMES
-
-    def match(self, path_pattern, *, case_sensitive=None):
-        """
-        Return True if this path matches the given pattern.
-        """
-        if not isinstance(path_pattern, PurePath):
-            path_pattern = self.with_segments(path_pattern)
-        if case_sensitive is None:
-            case_sensitive = _is_case_sensitive(self._flavour)
-        pattern = _compile_pattern_lines(path_pattern._lines, case_sensitive)
-        if path_pattern.drive or path_pattern.root:
-            return pattern.match(self._lines) is not None
-        elif path_pattern._tail:
-            return pattern.search(self._lines) is not None
-        else:
-            raise ValueError("empty pattern")
-
-
-# Can't subclass os.PathLike from PurePath and keep the constructor
-# optimizations in PurePath.__slots__.
-os.PathLike.register(PurePath)
-
-
-class PurePosixPath(PurePath):
-    """PurePath subclass for non-Windows systems.
-
-    On a POSIX system, instantiating a PurePath should return this object.
-    However, you can also instantiate it directly on any system.
-    """
-    _flavour = posixpath
-    __slots__ = ()
-
-
-class PureWindowsPath(PurePath):
-    """PurePath subclass for Windows systems.
-
-    On a Windows system, instantiating a PurePath should return this object.
-    However, you can also instantiate it directly on any system.
-    """
-    _flavour = ntpath
-    __slots__ = ()
-
-
-# Filesystem-accessing classes
-
-
-class Path(PurePath):
-    """PurePath subclass that can make system calls.
-
-    Path represents a filesystem path but unlike PurePath, also offers
-    methods to do system calls on path objects. Depending on your system,
-    instantiating a Path will return either a PosixPath or a WindowsPath
-    object. You can also instantiate a PosixPath or WindowsPath directly,
-    but cannot instantiate a WindowsPath on a POSIX system or vice versa.
-    """
-    __slots__ = ()
-
-    def stat(self, *, follow_symlinks=True):
-        """
-        Return the result of the stat() system call on this path, like
-        os.stat() does.
-        """
-        return os.stat(self, follow_symlinks=follow_symlinks)
-
-    def lstat(self):
-        """
-        Like stat(), except if the path points to a symlink, the symlink's
-        status information is returned, rather than its target's.
-        """
-        return self.stat(follow_symlinks=False)
-
-
-    # Convenience functions for querying the stat results
-
-    def exists(self, *, follow_symlinks=True):
-        """
-        Whether this path exists.
-
-        This method normally follows symlinks; to check whether a symlink exists,
-        add the argument follow_symlinks=False.
-        """
-        try:
-            self.stat(follow_symlinks=follow_symlinks)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-        return True
-
-    def is_dir(self):
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return S_ISDIR(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_file(self):
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return S_ISREG(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_mount(self):
-        """
-        Check if this path is a mount point
-        """
-        return self._flavour.ismount(self)
-
-    def is_symlink(self):
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return S_ISLNK(self.lstat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_junction(self):
-        """
-        Whether this path is a junction.
-        """
-        return self._flavour.isjunction(self)
-
-    def is_block_device(self):
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_char_device(self):
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_fifo(self):
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_socket(self):
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def samefile(self, other_path):
-        """Return whether other_path is the same or not as this file
-        (as returned by os.path.samefile()).
-        """
-        st = self.stat()
-        try:
-            other_st = other_path.stat()
-        except AttributeError:
-            other_st = self.with_segments(other_path).stat()
-        return self._flavour.samestat(st, other_st)
-
-    def open(self, mode='r', buffering=-1, encoding=None,
-             errors=None, newline=None):
-        """
-        Open the file pointed by this path and return a file object, as
-        the built-in open() function does.
-        """
-        if "b" not in mode:
-            encoding = io.text_encoding(encoding)
-        return io.open(self, mode, buffering, encoding, errors, newline)
-
-    def read_bytes(self):
-        """
-        Open the file in bytes mode, read it, and close the file.
-        """
-        with self.open(mode='rb') as f:
-            return f.read()
-
-    def read_text(self, encoding=None, errors=None):
-        """
-        Open the file in text mode, read it, and close the file.
-        """
-        encoding = io.text_encoding(encoding)
-        with self.open(mode='r', encoding=encoding, errors=errors) as f:
-            return f.read()
-
-    def write_bytes(self, data):
-        """
-        Open the file in bytes mode, write to it, and close the file.
-        """
-        # type-check for the buffer interface before truncating the file
-        view = memoryview(data)
-        with self.open(mode='wb') as f:
-            return f.write(view)
-
-    def write_text(self, data, encoding=None, errors=None, newline=None):
-        """
-        Open the file in text mode, write to it, and close the file.
-        """
-        if not isinstance(data, str):
-            raise TypeError('data must be str, not %s' %
-                            data.__class__.__name__)
-        encoding = io.text_encoding(encoding)
-        with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
-            return f.write(data)
-
-    def iterdir(self):
-        """Yield path objects of the directory contents.
-
-        The children are yielded in arbitrary order, and the
-        special entries '.' and '..' are not included.
-        """
-        for name in os.listdir(self):
-            yield self._make_child_relpath(name)
-
-    def _scandir(self):
-        # bpo-24132: a future version of pathlib will support subclassing of
-        # pathlib.Path to customize how the filesystem is accessed. This
-        # includes scandir(), which is used to implement glob().
-        return os.scandir(self)
-
-    def _make_child_relpath(self, name):
-        path_str = str(self)
-        tail = self._tail
-        if tail:
-            path_str = f'{path_str}{self._flavour.sep}{name}'
-        elif path_str != '.':
-            path_str = f'{path_str}{name}'
-        else:
-            path_str = name
-        path = self.with_segments(path_str)
-        path._str = path_str
-        path._drv = self.drive
-        path._root = self.root
-        path._tail_cached = tail + [name]
-        return path
-
-    def glob(self, pattern, *, case_sensitive=None):
-        """Iterate over this subtree and yield all existing files (of any
-        kind, including directories) matching the given relative pattern.
-        """
-        sys.audit("pathlib.Path.glob", self, pattern)
-        if not pattern:
-            raise ValueError("Unacceptable pattern: {!r}".format(pattern))
-        drv, root, pattern_parts = self._parse_path(pattern)
-        if drv or root:
-            raise NotImplementedError("Non-relative patterns are unsupported")
-        if pattern[-1] in (self._flavour.sep, self._flavour.altsep):
-            pattern_parts.append('')
-        selector = _make_selector(tuple(pattern_parts), self._flavour, case_sensitive)
-        for p in selector.select_from(self):
-            yield p
-
-    def rglob(self, pattern, *, case_sensitive=None):
-        """Recursively yield all existing files (of any kind, including
-        directories) matching the given relative pattern, anywhere in
-        this subtree.
-        """
-        sys.audit("pathlib.Path.rglob", self, pattern)
-        drv, root, pattern_parts = self._parse_path(pattern)
-        if drv or root:
-            raise NotImplementedError("Non-relative patterns are unsupported")
-        if pattern and pattern[-1] in (self._flavour.sep, self._flavour.altsep):
-            pattern_parts.append('')
-        selector = _make_selector(("**",) + tuple(pattern_parts), self._flavour, case_sensitive)
-        for p in selector.select_from(self):
-            yield p
-
-    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
-        """Walk the directory tree from this directory, similar to os.walk()."""
-        sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
-        paths = [self]
-
-        while paths:
-            path = paths.pop()
-            if isinstance(path, tuple):
-                yield path
-                continue
-
-            # We may not have read permission for self, in which case we can't
-            # get a list of the files the directory contains. os.walk()
-            # always suppressed the exception in that instance, rather than
-            # blow up for a minor reason when (say) a thousand readable
-            # directories are still left to visit. That logic is copied here.
-            try:
-                scandir_it = path._scandir()
-            except OSError as error:
-                if on_error is not None:
-                    on_error(error)
-                continue
-
-            with scandir_it:
-                dirnames = []
-                filenames = []
-                for entry in scandir_it:
-                    try:
-                        is_dir = entry.is_dir(follow_symlinks=follow_symlinks)
-                    except OSError:
-                        # Carried over from os.path.isdir().
-                        is_dir = False
-
-                    if is_dir:
-                        dirnames.append(entry.name)
-                    else:
-                        filenames.append(entry.name)
-
-            if top_down:
-                yield path, dirnames, filenames
-            else:
-                paths.append((path, dirnames, filenames))
-
-            paths += [path._make_child_relpath(d) for d in reversed(dirnames)]
-
-    def __init__(self, *args, **kwargs):
-        if kwargs:
-            msg = ("support for supplying keyword arguments to pathlib.PurePath "
-                   "is deprecated and scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
-        super().__init__(*args)
-
-    def __new__(cls, *args, **kwargs):
-        if cls is Path:
-            cls = WindowsPath if os.name == 'nt' else PosixPath
-        return object.__new__(cls)
-
-    def __enter__(self):
-        # In previous versions of pathlib, __exit__() marked this path as
-        # closed; subsequent attempts to perform I/O would raise an IOError.
-        # This functionality was never documented, and had the effect of
-        # making Path objects mutable, contrary to PEP 428.
-        # In Python 3.9 __exit__() was made a no-op.
-        # In Python 3.11 __enter__() began emitting DeprecationWarning.
-        # In Python 3.13 __enter__() and __exit__() should be removed.
-        warnings.warn("pathlib.Path.__enter__() is deprecated and scheduled "
-                      "for removal in Python 3.13; Path objects as a context "
-                      "manager is a no-op",
-                      DeprecationWarning, stacklevel=2)
-        return self
-
-    def __exit__(self, t, v, tb):
-        pass
-
-    # Public API
-
-    @classmethod
-    def cwd(cls):
-        """Return a new path pointing to the current working directory."""
-        # We call 'absolute()' rather than using 'os.getcwd()' directly to
-        # enable users to replace the implementation of 'absolute()' in a
-        # subclass and benefit from the new behaviour here. This works because
-        # os.path.abspath('.') == os.getcwd().
-        return cls().absolute()
-
-    @classmethod
-    def home(cls):
-        """Return a new path pointing to the user's home directory (as
-        returned by os.path.expanduser('~')).
-        """
-        return cls("~").expanduser()
-
-    def absolute(self):
-        """Return an absolute version of this path by prepending the current
-        working directory. No normalization or symlink resolution is performed.
-
-        Use resolve() to get the canonical path to a file.
-        """
-        if self.is_absolute():
-            return self
-        elif self.drive:
-            # There is a CWD on each drive-letter drive.
-            cwd = self._flavour.abspath(self.drive)
-        else:
-            cwd = os.getcwd()
-            # Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
-            # We pass only one argument to with_segments() to avoid the cost
-            # of joining, and we exploit the fact that getcwd() returns a
-            # fully-normalized string by storing it in _str. This is used to
-            # implement Path.cwd().
-            if not self.root and not self._tail:
-                result = self.with_segments(cwd)
-                result._str = cwd
-                return result
-        return self.with_segments(cwd, self)
-
-    def resolve(self, strict=False):
-        """
-        Make the path absolute, resolving all symlinks on the way and also
-        normalizing it.
-        """
-
-        def check_eloop(e):
-            winerror = getattr(e, 'winerror', 0)
-            if e.errno == ELOOP or winerror == _WINERROR_CANT_RESOLVE_FILENAME:
-                raise RuntimeError("Symlink loop from %r" % e.filename)
-
-        try:
-            s = self._flavour.realpath(self, strict=strict)
-        except OSError as e:
-            check_eloop(e)
-            raise
-        p = self.with_segments(s)
-
-        # In non-strict mode, realpath() doesn't raise on symlink loops.
-        # Ensure we get an exception by calling stat()
-        if not strict:
-            try:
-                p.stat()
-            except OSError as e:
-                check_eloop(e)
-        return p
-
-    def owner(self):
-        """
-        Return the login name of the file owner.
-        """
-        try:
-            import pwd
-            return pwd.getpwuid(self.stat().st_uid).pw_name
-        except ImportError:
-            raise NotImplementedError("Path.owner() is unsupported on this system")
-
-    def group(self):
-        """
-        Return the group name of the file gid.
-        """
-
-        try:
-            import grp
-            return grp.getgrgid(self.stat().st_gid).gr_name
-        except ImportError:
-            raise NotImplementedError("Path.group() is unsupported on this system")
-
-    def readlink(self):
-        """
-        Return the path to which the symbolic link points.
-        """
-        if not hasattr(os, "readlink"):
-            raise NotImplementedError("os.readlink() not available on this system")
-        return self.with_segments(os.readlink(self))
-
-    def touch(self, mode=0o666, exist_ok=True):
-        """
-        Create this file with the given access mode, if it doesn't exist.
-        """
-
-        if exist_ok:
-            # First try to bump modification time
-            # Implementation note: GNU touch uses the UTIME_NOW option of
-            # the utimensat() / futimens() functions.
-            try:
-                os.utime(self, None)
-            except OSError:
-                # Avoid exception chaining
-                pass
-            else:
-                return
-        flags = os.O_CREAT | os.O_WRONLY
-        if not exist_ok:
-            flags |= os.O_EXCL
-        fd = os.open(self, flags, mode)
-        os.close(fd)
-
-    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
-        """
-        Create a new directory at this given path.
-        """
-        try:
-            os.mkdir(self, mode)
-        except FileNotFoundError:
-            if not parents or self.parent == self:
-                raise
-            self.parent.mkdir(parents=True, exist_ok=True)
-            self.mkdir(mode, parents=False, exist_ok=exist_ok)
-        except OSError:
-            # Cannot rely on checking for EEXIST, since the operating system
-            # could give priority to other errors like EACCES or EROFS
-            if not exist_ok or not self.is_dir():
-                raise
-
-    def chmod(self, mode, *, follow_symlinks=True):
-        """
-        Change the permissions of the path, like os.chmod().
-        """
-        os.chmod(self, mode, follow_symlinks=follow_symlinks)
-
-    def lchmod(self, mode):
-        """
-        Like chmod(), except if the path points to a symlink, the symlink's
-        permissions are changed, rather than its target's.
-        """
-        self.chmod(mode, follow_symlinks=False)
-
-    def unlink(self, missing_ok=False):
-        """
-        Remove this file or link.
-        If the path is a directory, use rmdir() instead.
-        """
-        try:
-            os.unlink(self)
-        except FileNotFoundError:
-            if not missing_ok:
-                raise
-
-    def rmdir(self):
-        """
-        Remove this directory.  The directory must be empty.
-        """
-        os.rmdir(self)
-
-    def rename(self, target):
-        """
-        Rename this path to the target path.
-
-        The target path may be absolute or relative. Relative paths are
-        interpreted relative to the current working directory, *not* the
-        directory of the Path object.
-
-        Returns the new Path instance pointing to the target path.
-        """
-        os.rename(self, target)
-        return self.with_segments(target)
-
-    def replace(self, target):
-        """
-        Rename this path to the target path, overwriting if that path exists.
-
-        The target path may be absolute or relative. Relative paths are
-        interpreted relative to the current working directory, *not* the
-        directory of the Path object.
-
-        Returns the new Path instance pointing to the target path.
-        """
-        os.replace(self, target)
-        return self.with_segments(target)
-
-    def symlink_to(self, target, target_is_directory=False):
-        """
-        Make this path a symlink pointing to the target path.
-        Note the order of arguments (link, target) is the reverse of os.symlink.
-        """
-        if not hasattr(os, "symlink"):
-            raise NotImplementedError("os.symlink() not available on this system")
-        os.symlink(target, self, target_is_directory)
-
-    def hardlink_to(self, target):
-        """
-        Make this path a hard link pointing to the same file as *target*.
-
-        Note the order of arguments (self, target) is the reverse of os.link's.
-        """
-        if not hasattr(os, "link"):
-            raise NotImplementedError("os.link() not available on this system")
-        os.link(target, self)
-
-    def expanduser(self):
-        """ Return a new path with expanded ~ and ~user constructs
-        (as returned by os.path.expanduser)
-        """
-        if (not (self.drive or self.root) and
-            self._tail and self._tail[0][:1] == '~'):
-            homedir = self._flavour.expanduser(self._tail[0])
-            if homedir[:1] == "~":
-                raise RuntimeError("Could not determine home directory.")
-            drv, root, tail = self._parse_path(homedir)
-            return self._from_parsed_parts(drv, root, tail + self._tail[1:])
-
-        return self
-
-
-class PosixPath(Path, PurePosixPath):
-    """Path subclass for non-Windows systems.
-
-    On a POSIX system, instantiating a Path should return this object.
-    """
-    __slots__ = ()
-
-    if os.name == 'nt':
-        def __new__(cls, *args, **kwargs):
-            raise NotImplementedError(
-                f"cannot instantiate {cls.__name__!r} on your system")
-
-class WindowsPath(Path, PureWindowsPath):
-    """Path subclass for Windows systems.
-
-    On a Windows system, instantiating a Path should return this object.
-    """
-    __slots__ = ()
-
-    if os.name != 'nt':
-        def __new__(cls, *args, **kwargs):
-            raise NotImplementedError(
-                f"cannot instantiate {cls.__name__!r} on your system")
diff --git a/Lib/pathlib/__init__.py b/Lib/pathlib/__init__.py
new file mode 100644
index 00000000000..4b3edf535a6
--- /dev/null
+++ b/Lib/pathlib/__init__.py
@@ -0,0 +1,12 @@
+"""Object-oriented filesystem paths.
+
+This module provides classes to represent abstract paths and concrete
+paths with operations that have semantics appropriate for different
+operating systems.
+"""
+
+from ._abc import *
+from ._local import *
+
+__all__ = (_abc.__all__ +
+           _local.__all__)
diff --git a/Lib/pathlib/_abc.py b/Lib/pathlib/_abc.py
new file mode 100644
index 00000000000..4d24146aa53
--- /dev/null
+++ b/Lib/pathlib/_abc.py
@@ -0,0 +1,930 @@
+"""
+Abstract base classes for rich path objects.
+
+This module is published as a PyPI package called "pathlib-abc".
+
+This module is also a *PRIVATE* part of the Python standard library, where
+it's developed alongside pathlib. If it finds success and maturity as a PyPI
+package, it could become a public part of the standard library.
+
+Two base classes are defined here -- PurePathBase and PathBase -- that
+resemble pathlib's PurePath and Path respectively.
+"""
+
+import functools
+from glob import _Globber, _no_recurse_symlinks
+from errno import ENOENT, ENOTDIR, EBADF, ELOOP, EINVAL
+from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
+
+
+__all__ = ["UnsupportedOperation"]
+
+#
+# Internals
+#
+
+_WINERROR_NOT_READY = 21  # drive exists but is not accessible
+_WINERROR_INVALID_NAME = 123  # fix for bpo-35306
+_WINERROR_CANT_RESOLVE_FILENAME = 1921  # broken symlink pointing to itself
+
+# EBADF - guard against macOS `stat` throwing EBADF
+_IGNORED_ERRNOS = (ENOENT, ENOTDIR, EBADF, ELOOP)
+
+_IGNORED_WINERRORS = (
+    _WINERROR_NOT_READY,
+    _WINERROR_INVALID_NAME,
+    _WINERROR_CANT_RESOLVE_FILENAME)
+
+def _ignore_error(exception):
+    return (getattr(exception, 'errno', None) in _IGNORED_ERRNOS or
+            getattr(exception, 'winerror', None) in _IGNORED_WINERRORS)
+
+
+@functools.cache
+def _is_case_sensitive(parser):
+    return parser.normcase('Aa') == 'Aa'
+
+
+class UnsupportedOperation(NotImplementedError):
+    """An exception that is raised when an unsupported operation is called on
+    a path object.
+    """
+    pass
+
+
+class ParserBase:
+    """Base class for path parsers, which do low-level path manipulation.
+
+    Path parsers provide a subset of the os.path API, specifically those
+    functions needed to provide PurePathBase functionality. Each PurePathBase
+    subclass references its path parser via a 'parser' class attribute.
+
+    Every method in this base class raises an UnsupportedOperation exception.
+    """
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported"
+
+    @property
+    def sep(self):
+        """The character used to separate path components."""
+        raise UnsupportedOperation(self._unsupported_msg('sep'))
+
+    def join(self, path, *paths):
+        """Join path segments."""
+        raise UnsupportedOperation(self._unsupported_msg('join()'))
+
+    def split(self, path):
+        """Split the path into a pair (head, tail), where *head* is everything
+        before the final path separator, and *tail* is everything after.
+        Either part may be empty.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('split()'))
+
+    def splitdrive(self, path):
+        """Split the path into a 2-item tuple (drive, tail), where *drive* is
+        a device name or mount point, and *tail* is everything after the
+        drive. Either part may be empty."""
+        raise UnsupportedOperation(self._unsupported_msg('splitdrive()'))
+
+    def normcase(self, path):
+        """Normalize the case of the path."""
+        raise UnsupportedOperation(self._unsupported_msg('normcase()'))
+
+    def isabs(self, path):
+        """Returns whether the path is absolute, i.e. unaffected by the
+        current directory or drive."""
+        raise UnsupportedOperation(self._unsupported_msg('isabs()'))
+
+
+class PurePathBase:
+    """Base class for pure path objects.
+
+    This class *does not* provide several magic methods that are defined in
+    its subclass PurePath. They are: __fspath__, __bytes__, __reduce__,
+    __hash__, __eq__, __lt__, __le__, __gt__, __ge__. Its initializer and path
+    joining methods accept only strings, not os.PathLike objects more broadly.
+    """
+
+    __slots__ = (
+        # The `_raw_path` slot store a joined string path. This is set in the
+        # `__init__()` method.
+        '_raw_path',
+
+        # The '_resolving' slot stores a boolean indicating whether the path
+        # is being processed by `PathBase.resolve()`. This prevents duplicate
+        # work from occurring when `resolve()` calls `stat()` or `readlink()`.
+        '_resolving',
+    )
+    parser = ParserBase()
+    _globber = _Globber
+
+    def __init__(self, path, *paths):
+        self._raw_path = self.parser.join(path, *paths) if paths else path
+        if not isinstance(self._raw_path, str):
+            raise TypeError(
+                f"path should be a str, not {type(self._raw_path).__name__!r}")
+        self._resolving = False
+
+    def with_segments(self, *pathsegments):
+        """Construct a new path object from any number of path-like objects.
+        Subclasses may override this method to customize how new path objects
+        are created from methods like `iterdir()`.
+        """
+        return type(self)(*pathsegments)
+
+    def __str__(self):
+        """Return the string representation of the path, suitable for
+        passing to system calls."""
+        return self._raw_path
+
+    def as_posix(self):
+        """Return the string representation of the path with forward (/)
+        slashes."""
+        return str(self).replace(self.parser.sep, '/')
+
+    @property
+    def drive(self):
+        """The drive prefix (letter or UNC path), if any."""
+        return self.parser.splitdrive(self.anchor)[0]
+
+    @property
+    def root(self):
+        """The root of the path, if any."""
+        return self.parser.splitdrive(self.anchor)[1]
+
+    @property
+    def anchor(self):
+        """The concatenation of the drive and root, or ''."""
+        return self._stack[0]
+
+    @property
+    def name(self):
+        """The final path component, if any."""
+        return self.parser.split(self._raw_path)[1]
+
+    @property
+    def suffix(self):
+        """
+        The final component's last suffix, if any.
+
+        This includes the leading period. For example: '.txt'
+        """
+        name = self.name
+        i = name.rfind('.')
+        if 0 < i < len(name) - 1:
+            return name[i:]
+        else:
+            return ''
+
+    @property
+    def suffixes(self):
+        """
+        A list of the final component's suffixes, if any.
+
+        These include the leading periods. For example: ['.tar', '.gz']
+        """
+        name = self.name
+        if name.endswith('.'):
+            return []
+        name = name.lstrip('.')
+        return ['.' + suffix for suffix in name.split('.')[1:]]
+
+    @property
+    def stem(self):
+        """The final path component, minus its last suffix."""
+        name = self.name
+        i = name.rfind('.')
+        if 0 < i < len(name) - 1:
+            return name[:i]
+        else:
+            return name
+
+    def with_name(self, name):
+        """Return a new path with the file name changed."""
+        split = self.parser.split
+        if split(name)[0]:
+            raise ValueError(f"Invalid name {name!r}")
+        return self.with_segments(split(self._raw_path)[0], name)
+
+    def with_stem(self, stem):
+        """Return a new path with the stem changed."""
+        suffix = self.suffix
+        if not suffix:
+            return self.with_name(stem)
+        elif not stem:
+            # If the suffix is non-empty, we can't make the stem empty.
+            raise ValueError(f"{self!r} has a non-empty suffix")
+        else:
+            return self.with_name(stem + suffix)
+
+    def with_suffix(self, suffix):
+        """Return a new path with the file suffix changed.  If the path
+        has no suffix, add given suffix.  If the given suffix is an empty
+        string, remove the suffix from the path.
+        """
+        stem = self.stem
+        if not stem:
+            # If the stem is empty, we can't make the suffix non-empty.
+            raise ValueError(f"{self!r} has an empty name")
+        elif suffix and not (suffix.startswith('.') and len(suffix) > 1):
+            raise ValueError(f"Invalid suffix {suffix!r}")
+        else:
+            return self.with_name(stem + suffix)
+
+    def relative_to(self, other, *, walk_up=False):
+        """Return the relative path to another path identified by the passed
+        arguments.  If the operation is not possible (because this is not
+        related to the other path), raise ValueError.
+
+        The *walk_up* parameter controls whether `..` may be used to resolve
+        the path.
+        """
+        if not isinstance(other, PurePathBase):
+            other = self.with_segments(other)
+        anchor0, parts0 = self._stack
+        anchor1, parts1 = other._stack
+        if anchor0 != anchor1:
+            raise ValueError(f"{self._raw_path!r} and {other._raw_path!r} have different anchors")
+        while parts0 and parts1 and parts0[-1] == parts1[-1]:
+            parts0.pop()
+            parts1.pop()
+        for part in parts1:
+            if not part or part == '.':
+                pass
+            elif not walk_up:
+                raise ValueError(f"{self._raw_path!r} is not in the subpath of {other._raw_path!r}")
+            elif part == '..':
+                raise ValueError(f"'..' segment in {other._raw_path!r} cannot be walked")
+            else:
+                parts0.append('..')
+        return self.with_segments('', *reversed(parts0))
+
+    def is_relative_to(self, other):
+        """Return True if the path is relative to another path or False.
+        """
+        if not isinstance(other, PurePathBase):
+            other = self.with_segments(other)
+        anchor0, parts0 = self._stack
+        anchor1, parts1 = other._stack
+        if anchor0 != anchor1:
+            return False
+        while parts0 and parts1 and parts0[-1] == parts1[-1]:
+            parts0.pop()
+            parts1.pop()
+        for part in parts1:
+            if part and part != '.':
+                return False
+        return True
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        anchor, parts = self._stack
+        if anchor:
+            parts.append(anchor)
+        return tuple(reversed(parts))
+
+    def joinpath(self, *pathsegments):
+        """Combine this path with one or several arguments, and return a
+        new path representing either a subpath (if all arguments are relative
+        paths) or a totally different path (if one of the arguments is
+        anchored).
+        """
+        return self.with_segments(self._raw_path, *pathsegments)
+
+    def __truediv__(self, key):
+        try:
+            return self.with_segments(self._raw_path, key)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, key):
+        try:
+            return self.with_segments(key, self._raw_path)
+        except TypeError:
+            return NotImplemented
+
+    @property
+    def _stack(self):
+        """
+        Split the path into a 2-tuple (anchor, parts), where *anchor* is the
+        uppermost parent of the path (equivalent to path.parents[-1]), and
+        *parts* is a reversed list of parts following the anchor.
+        """
+        split = self.parser.split
+        path = self._raw_path
+        parent, name = split(path)
+        names = []
+        while path != parent:
+            names.append(name)
+            path = parent
+            parent, name = split(path)
+        return path, names
+
+    @property
+    def parent(self):
+        """The logical parent of the path."""
+        path = self._raw_path
+        parent = self.parser.split(path)[0]
+        if path != parent:
+            parent = self.with_segments(parent)
+            parent._resolving = self._resolving
+            return parent
+        return self
+
+    @property
+    def parents(self):
+        """A sequence of this path's logical parents."""
+        split = self.parser.split
+        path = self._raw_path
+        parent = split(path)[0]
+        parents = []
+        while path != parent:
+            parents.append(self.with_segments(parent))
+            path = parent
+            parent = split(path)[0]
+        return tuple(parents)
+
+    def is_absolute(self):
+        """True if the path is absolute (has both a root and, if applicable,
+        a drive)."""
+        return self.parser.isabs(self._raw_path)
+
+    @property
+    def _pattern_str(self):
+        """The path expressed as a string, for use in pattern-matching."""
+        return str(self)
+
+    def match(self, path_pattern, *, case_sensitive=None):
+        """
+        Return True if this path matches the given pattern. If the pattern is
+        relative, matching is done from the right; otherwise, the entire path
+        is matched. The recursive wildcard '**' is *not* supported by this
+        method.
+        """
+        if not isinstance(path_pattern, PurePathBase):
+            path_pattern = self.with_segments(path_pattern)
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+        sep = path_pattern.parser.sep
+        path_parts = self.parts[::-1]
+        pattern_parts = path_pattern.parts[::-1]
+        if not pattern_parts:
+            raise ValueError("empty pattern")
+        if len(path_parts) < len(pattern_parts):
+            return False
+        if len(path_parts) > len(pattern_parts) and path_pattern.anchor:
+            return False
+        globber = self._globber(sep, case_sensitive)
+        for path_part, pattern_part in zip(path_parts, pattern_parts):
+            match = globber.compile(pattern_part)
+            if match(path_part) is None:
+                return False
+        return True
+
+    def full_match(self, pattern, *, case_sensitive=None):
+        """
+        Return True if this path matches the given glob-style pattern. The
+        pattern is matched against the entire path.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+        globber = self._globber(pattern.parser.sep, case_sensitive, recursive=True)
+        match = globber.compile(pattern._pattern_str)
+        return match(self._pattern_str) is not None
+
+
+
+class PathBase(PurePathBase):
+    """Base class for concrete path objects.
+
+    This class provides dummy implementations for many methods that derived
+    classes can override selectively; the default implementations raise
+    UnsupportedOperation. The most basic methods, such as stat() and open(),
+    directly raise UnsupportedOperation; these basic methods are called by
+    other methods such as is_dir() and read_text().
+
+    The Path class derives this class to implement local filesystem paths.
+    Users may derive their own classes to implement virtual filesystem paths,
+    such as paths in archive files or on remote storage systems.
+    """
+    __slots__ = ()
+
+    # Maximum number of symlinks to follow in resolve()
+    _max_symlinks = 40
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported"
+
+    def stat(self, *, follow_symlinks=True):
+        """
+        Return the result of the stat() system call on this path, like
+        os.stat() does.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('stat()'))
+
+    def lstat(self):
+        """
+        Like stat(), except if the path points to a symlink, the symlink's
+        status information is returned, rather than its target's.
+        """
+        return self.stat(follow_symlinks=False)
+
+
+    # Convenience functions for querying the stat results
+
+    def exists(self, *, follow_symlinks=True):
+        """
+        Whether this path exists.
+
+        This method normally follows symlinks; to check whether a symlink exists,
+        add the argument follow_symlinks=False.
+        """
+        try:
+            self.stat(follow_symlinks=follow_symlinks)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+        return True
+
+    def is_dir(self, *, follow_symlinks=True):
+        """
+        Whether this path is a directory.
+        """
+        try:
+            return S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_file(self, *, follow_symlinks=True):
+        """
+        Whether this path is a regular file (also True for symlinks pointing
+        to regular files).
+        """
+        try:
+            return S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_mount(self):
+        """
+        Check if this path is a mount point
+        """
+        # Need to exist and be a dir
+        if not self.exists() or not self.is_dir():
+            return False
+
+        try:
+            parent_dev = self.parent.stat().st_dev
+        except OSError:
+            return False
+
+        dev = self.stat().st_dev
+        if dev != parent_dev:
+            return True
+        ino = self.stat().st_ino
+        parent_ino = self.parent.stat().st_ino
+        return ino == parent_ino
+
+    def is_symlink(self):
+        """
+        Whether this path is a symbolic link.
+        """
+        try:
+            return S_ISLNK(self.lstat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_junction(self):
+        """
+        Whether this path is a junction.
+        """
+        # Junctions are a Windows-only feature, not present in POSIX nor the
+        # majority of virtual filesystems. There is no cross-platform idiom
+        # to check for junctions (using stat().st_mode).
+        return False
+
+    def is_block_device(self):
+        """
+        Whether this path is a block device.
+        """
+        try:
+            return S_ISBLK(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_char_device(self):
+        """
+        Whether this path is a character device.
+        """
+        try:
+            return S_ISCHR(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_fifo(self):
+        """
+        Whether this path is a FIFO.
+        """
+        try:
+            return S_ISFIFO(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_socket(self):
+        """
+        Whether this path is a socket.
+        """
+        try:
+            return S_ISSOCK(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def samefile(self, other_path):
+        """Return whether other_path is the same or not as this file
+        (as returned by os.path.samefile()).
+        """
+        st = self.stat()
+        try:
+            other_st = other_path.stat()
+        except AttributeError:
+            other_st = self.with_segments(other_path).stat()
+        return (st.st_ino == other_st.st_ino and
+                st.st_dev == other_st.st_dev)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        """
+        Open the file pointed to by this path and return a file object, as
+        the built-in open() function does.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('open()'))
+
+    def read_bytes(self):
+        """
+        Open the file in bytes mode, read it, and close the file.
+        """
+        with self.open(mode='rb') as f:
+            return f.read()
+
+    def read_text(self, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, read it, and close the file.
+        """
+        with self.open(mode='r', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.read()
+
+    def write_bytes(self, data):
+        """
+        Open the file in bytes mode, write to it, and close the file.
+        """
+        # type-check for the buffer interface before truncating the file
+        view = memoryview(data)
+        with self.open(mode='wb') as f:
+            return f.write(view)
+
+    def write_text(self, data, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, write to it, and close the file.
+        """
+        if not isinstance(data, str):
+            raise TypeError('data must be str, not %s' %
+                            data.__class__.__name__)
+        with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.write(data)
+
+    def iterdir(self):
+        """Yield path objects of the directory contents.
+
+        The children are yielded in arbitrary order, and the
+        special entries '.' and '..' are not included.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('iterdir()'))
+
+    def _glob_selector(self, parts, case_sensitive, recurse_symlinks):
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+            case_pedantic = False
+        else:
+            # The user has expressed a case sensitivity choice, but we don't
+            # know the case sensitivity of the underlying filesystem, so we
+            # must use scandir() for everything, including non-wildcard parts.
+            case_pedantic = True
+        recursive = True if recurse_symlinks else _no_recurse_symlinks
+        globber = self._globber(self.parser.sep, case_sensitive, case_pedantic, recursive)
+        return globber.selector(parts)
+
+    def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
+        """Iterate over this subtree and yield all existing files (of any
+        kind, including directories) matching the given relative pattern.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        anchor, parts = pattern._stack
+        if anchor:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        select = self._glob_selector(parts, case_sensitive, recurse_symlinks)
+        return select(self)
+
+    def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
+        """Recursively yield all existing files (of any kind, including
+        directories) matching the given relative pattern, anywhere in
+        this subtree.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        pattern = '**' / pattern
+        return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
+
+    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+        """Walk the directory tree from this directory, similar to os.walk()."""
+        paths = [self]
+        while paths:
+            path = paths.pop()
+            if isinstance(path, tuple):
+                yield path
+                continue
+            dirnames = []
+            filenames = []
+            if not top_down:
+                paths.append((path, dirnames, filenames))
+            try:
+                for child in path.iterdir():
+                    try:
+                        if child.is_dir(follow_symlinks=follow_symlinks):
+                            if not top_down:
+                                paths.append(child)
+                            dirnames.append(child.name)
+                        else:
+                            filenames.append(child.name)
+                    except OSError:
+                        filenames.append(child.name)
+            except OSError as error:
+                if on_error is not None:
+                    on_error(error)
+                if not top_down:
+                    while not isinstance(paths.pop(), tuple):
+                        pass
+                continue
+            if top_down:
+                yield path, dirnames, filenames
+                paths += [path.joinpath(d) for d in reversed(dirnames)]
+
+    def absolute(self):
+        """Return an absolute version of this path
+        No normalization or symlink resolution is performed.
+
+        Use resolve() to resolve symlinks and remove '..' segments.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('absolute()'))
+
+    @classmethod
+    def cwd(cls):
+        """Return a new path pointing to the current working directory."""
+        # We call 'absolute()' rather than using 'os.getcwd()' directly to
+        # enable users to replace the implementation of 'absolute()' in a
+        # subclass and benefit from the new behaviour here. This works because
+        # os.path.abspath('.') == os.getcwd().
+        return cls('').absolute()
+
+    def expanduser(self):
+        """ Return a new path with expanded ~ and ~user constructs
+        (as returned by os.path.expanduser)
+        """
+        raise UnsupportedOperation(self._unsupported_msg('expanduser()'))
+
+    @classmethod
+    def home(cls):
+        """Return a new path pointing to expanduser('~').
+        """
+        return cls("~").expanduser()
+
+    def readlink(self):
+        """
+        Return the path to which the symbolic link points.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('readlink()'))
+    readlink._supported = False
+
+    def resolve(self, strict=False):
+        """
+        Make the path absolute, resolving all symlinks on the way and also
+        normalizing it.
+        """
+        if self._resolving:
+            return self
+        path_root, parts = self._stack
+        path = self.with_segments(path_root)
+        try:
+            path = path.absolute()
+        except UnsupportedOperation:
+            path_tail = []
+        else:
+            path_root, path_tail = path._stack
+            path_tail.reverse()
+
+        # If the user has *not* overridden the `readlink()` method, then symlinks are unsupported
+        # and (in non-strict mode) we can improve performance by not calling `stat()`.
+        querying = strict or getattr(self.readlink, '_supported', True)
+        link_count = 0
+        while parts:
+            part = parts.pop()
+            if not part or part == '.':
+                continue
+            if part == '..':
+                if not path_tail:
+                    if path_root:
+                        # Delete '..' segment immediately following root
+                        continue
+                elif path_tail[-1] != '..':
+                    # Delete '..' segment and its predecessor
+                    path_tail.pop()
+                    continue
+            path_tail.append(part)
+            if querying and part != '..':
+                path = self.with_segments(path_root + self.parser.sep.join(path_tail))
+                path._resolving = True
+                try:
+                    st = path.stat(follow_symlinks=False)
+                    if S_ISLNK(st.st_mode):
+                        # Like Linux and macOS, raise OSError(errno.ELOOP) if too many symlinks are
+                        # encountered during resolution.
+                        link_count += 1
+                        if link_count >= self._max_symlinks:
+                            raise OSError(ELOOP, "Too many symbolic links in path", self._raw_path)
+                        target_root, target_parts = path.readlink()._stack
+                        # If the symlink target is absolute (like '/etc/hosts'), set the current
+                        # path to its uppermost parent (like '/').
+                        if target_root:
+                            path_root = target_root
+                            path_tail.clear()
+                        else:
+                            path_tail.pop()
+                        # Add the symlink target's reversed tail parts (like ['hosts', 'etc']) to
+                        # the stack of unresolved path parts.
+                        parts.extend(target_parts)
+                        continue
+                    elif parts and not S_ISDIR(st.st_mode):
+                        raise NotADirectoryError(ENOTDIR, "Not a directory", self._raw_path)
+                except OSError:
+                    if strict:
+                        raise
+                    else:
+                        querying = False
+        return self.with_segments(path_root + self.parser.sep.join(path_tail))
+
+    def symlink_to(self, target, target_is_directory=False):
+        """
+        Make this path a symlink pointing to the target path.
+        Note the order of arguments (link, target) is the reverse of os.symlink.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('symlink_to()'))
+
+    def hardlink_to(self, target):
+        """
+        Make this path a hard link pointing to the same file as *target*.
+
+        Note the order of arguments (self, target) is the reverse of os.link's.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('hardlink_to()'))
+
+    def touch(self, mode=0o666, exist_ok=True):
+        """
+        Create this file with the given access mode, if it doesn't exist.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('touch()'))
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        """
+        Create a new directory at this given path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('mkdir()'))
+
+    def rename(self, target):
+        """
+        Rename this path to the target path.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('rename()'))
+
+    def replace(self, target):
+        """
+        Rename this path to the target path, overwriting if that path exists.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('replace()'))
+
+    def chmod(self, mode, *, follow_symlinks=True):
+        """
+        Change the permissions of the path, like os.chmod().
+        """
+        raise UnsupportedOperation(self._unsupported_msg('chmod()'))
+
+    def lchmod(self, mode):
+        """
+        Like chmod(), except if the path points to a symlink, the symlink's
+        permissions are changed, rather than its target's.
+        """
+        self.chmod(mode, follow_symlinks=False)
+
+    def unlink(self, missing_ok=False):
+        """
+        Remove this file or link.
+        If the path is a directory, use rmdir() instead.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('unlink()'))
+
+    def rmdir(self):
+        """
+        Remove this directory.  The directory must be empty.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('rmdir()'))
+
+    def owner(self, *, follow_symlinks=True):
+        """
+        Return the login name of the file owner.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('owner()'))
+
+    def group(self, *, follow_symlinks=True):
+        """
+        Return the group name of the file gid.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('group()'))
+
+    @classmethod
+    def from_uri(cls, uri):
+        """Return a new path from the given 'file' URI."""
+        raise UnsupportedOperation(cls._unsupported_msg('from_uri()'))
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        raise UnsupportedOperation(self._unsupported_msg('as_uri()'))
diff --git a/Lib/pathlib/_local.py b/Lib/pathlib/_local.py
new file mode 100644
index 00000000000..0188e7c7722
--- /dev/null
+++ b/Lib/pathlib/_local.py
@@ -0,0 +1,861 @@
+import io
+import ntpath
+import operator
+import os
+import posixpath
+import sys
+import warnings
+from glob import _StringGlobber
+from itertools import chain
+from _collections_abc import Sequence
+
+try:
+    import pwd
+except ImportError:
+    pwd = None
+try:
+    import grp
+except ImportError:
+    grp = None
+
+from ._abc import UnsupportedOperation, PurePathBase, PathBase
+
+
+__all__ = [
+    "PurePath", "PurePosixPath", "PureWindowsPath",
+    "Path", "PosixPath", "WindowsPath",
+    ]
+
+
+class _PathParents(Sequence):
+    """This object provides sequence-like access to the logical ancestors
+    of a path.  Don't try to construct it yourself."""
+    __slots__ = ('_path', '_drv', '_root', '_tail')
+
+    def __init__(self, path):
+        self._path = path
+        self._drv = path.drive
+        self._root = path.root
+        self._tail = path._tail
+
+    def __len__(self):
+        return len(self._tail)
+
+    def __getitem__(self, idx):
+        if isinstance(idx, slice):
+            return tuple(self[i] for i in range(*idx.indices(len(self))))
+
+        if idx >= len(self) or idx < -len(self):
+            raise IndexError(idx)
+        if idx < 0:
+            idx += len(self)
+        return self._path._from_parsed_parts(self._drv, self._root,
+                                             self._tail[:-idx - 1])
+
+    def __repr__(self):
+        return "<{}.parents>".format(type(self._path).__name__)
+
+
+class PurePath(PurePathBase):
+    """Base class for manipulating paths without I/O.
+
+    PurePath represents a filesystem path and offers operations which
+    don't imply any actual filesystem I/O.  Depending on your system,
+    instantiating a PurePath will return either a PurePosixPath or a
+    PureWindowsPath object.  You can also instantiate either of these classes
+    directly, regardless of your system.
+    """
+
+    __slots__ = (
+        # The `_raw_paths` slot stores unnormalized string paths. This is set
+        # in the `__init__()` method.
+        '_raw_paths',
+
+        # The `_drv`, `_root` and `_tail_cached` slots store parsed and
+        # normalized parts of the path. They are set when any of the `drive`,
+        # `root` or `_tail` properties are accessed for the first time. The
+        # three-part division corresponds to the result of
+        # `os.path.splitroot()`, except that the tail is further split on path
+        # separators (i.e. it is a list of strings), and that the root and
+        # tail are normalized.
+        '_drv', '_root', '_tail_cached',
+
+        # The `_str` slot stores the string representation of the path,
+        # computed from the drive, root and tail when `__str__()` is called
+        # for the first time. It's used to implement `_str_normcase`
+        '_str',
+
+        # The `_str_normcase_cached` slot stores the string path with
+        # normalized case. It is set when the `_str_normcase` property is
+        # accessed for the first time. It's used to implement `__eq__()`
+        # `__hash__()`, and `_parts_normcase`
+        '_str_normcase_cached',
+
+        # The `_parts_normcase_cached` slot stores the case-normalized
+        # string path after splitting on path separators. It's set when the
+        # `_parts_normcase` property is accessed for the first time. It's used
+        # to implement comparison methods like `__lt__()`.
+        '_parts_normcase_cached',
+
+        # The `_hash` slot stores the hash of the case-normalized string
+        # path. It's set when `__hash__()` is called for the first time.
+        '_hash',
+    )
+    parser = os.path
+    _globber = _StringGlobber
+
+    def __new__(cls, *args, **kwargs):
+        """Construct a PurePath from one or several strings and or existing
+        PurePath objects.  The strings and path objects are combined so as
+        to yield a canonicalized path, which is incorporated into the
+        new PurePath object.
+        """
+        if cls is PurePath:
+            cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
+        return object.__new__(cls)
+
+    def __init__(self, *args):
+        paths = []
+        for arg in args:
+            if isinstance(arg, PurePath):
+                if arg.parser is not self.parser:
+                    # GH-103631: Convert separators for backwards compatibility.
+                    paths.append(arg.as_posix())
+                else:
+                    paths.extend(arg._raw_paths)
+            else:
+                try:
+                    path = os.fspath(arg)
+                except TypeError:
+                    path = arg
+                if not isinstance(path, str):
+                    raise TypeError(
+                        "argument should be a str or an os.PathLike "
+                        "object where __fspath__ returns a str, "
+                        f"not {type(path).__name__!r}")
+                paths.append(path)
+        # Avoid calling super().__init__, as an optimisation
+        self._raw_paths = paths
+
+    def joinpath(self, *pathsegments):
+        """Combine this path with one or several arguments, and return a
+        new path representing either a subpath (if all arguments are relative
+        paths) or a totally different path (if one of the arguments is
+        anchored).
+        """
+        return self.with_segments(self, *pathsegments)
+
+    def __truediv__(self, key):
+        try:
+            return self.with_segments(self, key)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, key):
+        try:
+            return self.with_segments(key, self)
+        except TypeError:
+            return NotImplemented
+
+    def __reduce__(self):
+        return self.__class__, tuple(self._raw_paths)
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+    def __fspath__(self):
+        return str(self)
+
+    def __bytes__(self):
+        """Return the bytes representation of the path.  This is only
+        recommended to use under Unix."""
+        return os.fsencode(self)
+
+    @property
+    def _str_normcase(self):
+        # String with normalized case, for hashing and equality checks
+        try:
+            return self._str_normcase_cached
+        except AttributeError:
+            if self.parser is posixpath:
+                self._str_normcase_cached = str(self)
+            else:
+                self._str_normcase_cached = str(self).lower()
+            return self._str_normcase_cached
+
+    def __hash__(self):
+        try:
+            return self._hash
+        except AttributeError:
+            self._hash = hash(self._str_normcase)
+            return self._hash
+
+    def __eq__(self, other):
+        if not isinstance(other, PurePath):
+            return NotImplemented
+        return self._str_normcase == other._str_normcase and self.parser is other.parser
+
+    @property
+    def _parts_normcase(self):
+        # Cached parts with normalized case, for comparisons.
+        try:
+            return self._parts_normcase_cached
+        except AttributeError:
+            self._parts_normcase_cached = self._str_normcase.split(self.parser.sep)
+            return self._parts_normcase_cached
+
+    def __lt__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase < other._parts_normcase
+
+    def __le__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase <= other._parts_normcase
+
+    def __gt__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase > other._parts_normcase
+
+    def __ge__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase >= other._parts_normcase
+
+    def __str__(self):
+        """Return the string representation of the path, suitable for
+        passing to system calls."""
+        try:
+            return self._str
+        except AttributeError:
+            self._str = self._format_parsed_parts(self.drive, self.root,
+                                                  self._tail) or '.'
+            return self._str
+
+    @classmethod
+    def _format_parsed_parts(cls, drv, root, tail):
+        if drv or root:
+            return drv + root + cls.parser.sep.join(tail)
+        elif tail and cls.parser.splitdrive(tail[0])[0]:
+            tail = ['.'] + tail
+        return cls.parser.sep.join(tail)
+
+    def _from_parsed_parts(self, drv, root, tail):
+        path = self._from_parsed_string(self._format_parsed_parts(drv, root, tail))
+        path._drv = drv
+        path._root = root
+        path._tail_cached = tail
+        return path
+
+    def _from_parsed_string(self, path_str):
+        path = self.with_segments(path_str)
+        path._str = path_str or '.'
+        return path
+
+    @classmethod
+    def _parse_path(cls, path):
+        if not path:
+            return '', '', []
+        sep = cls.parser.sep
+        altsep = cls.parser.altsep
+        if altsep:
+            path = path.replace(altsep, sep)
+        drv, root, rel = cls.parser.splitroot(path)
+        if not root and drv.startswith(sep) and not drv.endswith(sep):
+            drv_parts = drv.split(sep)
+            if len(drv_parts) == 4 and drv_parts[2] not in '?.':
+                # e.g. //server/share
+                root = sep
+            elif len(drv_parts) == 6:
+                # e.g. //?/unc/server/share
+                root = sep
+        parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
+        return drv, root, parsed
+
+    @property
+    def _raw_path(self):
+        """The joined but unnormalized path."""
+        paths = self._raw_paths
+        if len(paths) == 0:
+            path = ''
+        elif len(paths) == 1:
+            path = paths[0]
+        else:
+            path = self.parser.join(*paths)
+        return path
+
+    @property
+    def drive(self):
+        """The drive prefix (letter or UNC path), if any."""
+        try:
+            return self._drv
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._drv
+
+    @property
+    def root(self):
+        """The root of the path, if any."""
+        try:
+            return self._root
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._root
+
+    @property
+    def _tail(self):
+        try:
+            return self._tail_cached
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._tail_cached
+
+    @property
+    def anchor(self):
+        """The concatenation of the drive and root, or ''."""
+        return self.drive + self.root
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        if self.drive or self.root:
+            return (self.drive + self.root,) + tuple(self._tail)
+        else:
+            return tuple(self._tail)
+
+    @property
+    def parent(self):
+        """The logical parent of the path."""
+        drv = self.drive
+        root = self.root
+        tail = self._tail
+        if not tail:
+            return self
+        return self._from_parsed_parts(drv, root, tail[:-1])
+
+    @property
+    def parents(self):
+        """A sequence of this path's logical parents."""
+        # The value of this property should not be cached on the path object,
+        # as doing so would introduce a reference cycle.
+        return _PathParents(self)
+
+    @property
+    def name(self):
+        """The final path component, if any."""
+        tail = self._tail
+        if not tail:
+            return ''
+        return tail[-1]
+
+    def with_name(self, name):
+        """Return a new path with the file name changed."""
+        p = self.parser
+        if not name or p.sep in name or (p.altsep and p.altsep in name) or name == '.':
+            raise ValueError(f"Invalid name {name!r}")
+        tail = self._tail.copy()
+        if not tail:
+            raise ValueError(f"{self!r} has an empty name")
+        tail[-1] = name
+        return self._from_parsed_parts(self.drive, self.root, tail)
+
+    def relative_to(self, other, /, *_deprecated, walk_up=False):
+        """Return the relative path to another path identified by the passed
+        arguments.  If the operation is not possible (because this is not
+        related to the other path), raise ValueError.
+
+        The *walk_up* parameter controls whether `..` may be used to resolve
+        the path.
+        """
+        if _deprecated:
+            msg = ("support for supplying more than one positional argument "
+                   "to pathlib.PurePath.relative_to() is deprecated and "
+                   "scheduled for removal in Python 3.14")
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            other = self.with_segments(other, *_deprecated)
+        elif not isinstance(other, PurePath):
+            other = self.with_segments(other)
+        for step, path in enumerate(chain([other], other.parents)):
+            if path == self or path in self.parents:
+                break
+            elif not walk_up:
+                raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
+            elif path.name == '..':
+                raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
+        else:
+            raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
+        parts = ['..'] * step + self._tail[len(path._tail):]
+        return self._from_parsed_parts('', '', parts)
+
+    def is_relative_to(self, other, /, *_deprecated):
+        """Return True if the path is relative to another path or False.
+        """
+        if _deprecated:
+            msg = ("support for supplying more than one argument to "
+                   "pathlib.PurePath.is_relative_to() is deprecated and "
+                   "scheduled for removal in Python 3.14")
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            other = self.with_segments(other, *_deprecated)
+        elif not isinstance(other, PurePath):
+            other = self.with_segments(other)
+        return other == self or other in self.parents
+
+    def is_absolute(self):
+        """True if the path is absolute (has both a root and, if applicable,
+        a drive)."""
+        if self.parser is posixpath:
+            # Optimization: work with raw paths on POSIX.
+            for path in self._raw_paths:
+                if path.startswith('/'):
+                    return True
+            return False
+        return self.parser.isabs(self)
+
+    def is_reserved(self):
+        """Return True if the path contains one of the special names reserved
+        by the system, if any."""
+        msg = ("pathlib.PurePath.is_reserved() is deprecated and scheduled "
+               "for removal in Python 3.15. Use os.path.isreserved() to "
+               "detect reserved paths on Windows.")
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        if self.parser is ntpath:
+            return self.parser.isreserved(self)
+        return False
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        if not self.is_absolute():
+            raise ValueError("relative path can't be expressed as a file URI")
+
+        drive = self.drive
+        if len(drive) == 2 and drive[1] == ':':
+            # It's a path on a local drive => 'file:///c:/a/b'
+            prefix = 'file:///' + drive
+            path = self.as_posix()[2:]
+        elif drive:
+            # It's a path on a network drive => 'file://host/share/a/b'
+            prefix = 'file:'
+            path = self.as_posix()
+        else:
+            # It's a posix path => 'file:///etc/hosts'
+            prefix = 'file://'
+            path = str(self)
+        from urllib.parse import quote_from_bytes
+        return prefix + quote_from_bytes(os.fsencode(path))
+
+    @property
+    def _pattern_str(self):
+        """The path expressed as a string, for use in pattern-matching."""
+        # The string representation of an empty path is a single dot ('.'). Empty
+        # paths shouldn't match wildcards, so we change it to the empty string.
+        path_str = str(self)
+        return '' if path_str == '.' else path_str
+
+# Subclassing os.PathLike makes isinstance() checks slower,
+# which in turn makes Path construction slower. Register instead!
+os.PathLike.register(PurePath)
+
+
+class PurePosixPath(PurePath):
+    """PurePath subclass for non-Windows systems.
+
+    On a POSIX system, instantiating a PurePath should return this object.
+    However, you can also instantiate it directly on any system.
+    """
+    parser = posixpath
+    __slots__ = ()
+
+
+class PureWindowsPath(PurePath):
+    """PurePath subclass for Windows systems.
+
+    On a Windows system, instantiating a PurePath should return this object.
+    However, you can also instantiate it directly on any system.
+    """
+    parser = ntpath
+    __slots__ = ()
+
+
+class Path(PathBase, PurePath):
+    """PurePath subclass that can make system calls.
+
+    Path represents a filesystem path but unlike PurePath, also offers
+    methods to do system calls on path objects. Depending on your system,
+    instantiating a Path will return either a PosixPath or a WindowsPath
+    object. You can also instantiate a PosixPath or WindowsPath directly,
+    but cannot instantiate a WindowsPath on a POSIX system or vice versa.
+    """
+    __slots__ = ()
+    as_uri = PurePath.as_uri
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported on this system"
+
+    def __init__(self, *args, **kwargs):
+        if kwargs:
+            msg = ("support for supplying keyword arguments to pathlib.PurePath "
+                   "is deprecated and scheduled for removal in Python {remove}")
+            warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
+        super().__init__(*args)
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Path:
+            cls = WindowsPath if os.name == 'nt' else PosixPath
+        return object.__new__(cls)
+
+    def stat(self, *, follow_symlinks=True):
+        """
+        Return the result of the stat() system call on this path, like
+        os.stat() does.
+        """
+        return os.stat(self, follow_symlinks=follow_symlinks)
+
+    def is_mount(self):
+        """
+        Check if this path is a mount point
+        """
+        return os.path.ismount(self)
+
+    def is_junction(self):
+        """
+        Whether this path is a junction.
+        """
+        return os.path.isjunction(self)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        """
+        Open the file pointed to by this path and return a file object, as
+        the built-in open() function does.
+        """
+        if "b" not in mode:
+            encoding = io.text_encoding(encoding)
+        return io.open(self, mode, buffering, encoding, errors, newline)
+
+    def read_text(self, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, read it, and close the file.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        return PathBase.read_text(self, encoding, errors, newline)
+
+    def write_text(self, data, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, write to it, and close the file.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        return PathBase.write_text(self, data, encoding, errors, newline)
+
+    _remove_leading_dot = operator.itemgetter(slice(2, None))
+    _remove_trailing_slash = operator.itemgetter(slice(-1))
+
+    def _filter_trailing_slash(self, paths):
+        sep = self.parser.sep
+        anchor_len = len(self.anchor)
+        for path_str in paths:
+            if len(path_str) > anchor_len and path_str[-1] == sep:
+                path_str = path_str[:-1]
+            yield path_str
+
+    def iterdir(self):
+        """Yield path objects of the directory contents.
+
+        The children are yielded in arbitrary order, and the
+        special entries '.' and '..' are not included.
+        """
+        root_dir = str(self)
+        with os.scandir(root_dir) as scandir_it:
+            paths = [entry.path for entry in scandir_it]
+        if root_dir == '.':
+            paths = map(self._remove_leading_dot, paths)
+        return map(self._from_parsed_string, paths)
+
+    def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
+        """Iterate over this subtree and yield all existing files (of any
+        kind, including directories) matching the given relative pattern.
+        """
+        sys.audit("pathlib.Path.glob", self, pattern)
+        if not isinstance(pattern, PurePath):
+            pattern = self.with_segments(pattern)
+        if pattern.anchor:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        parts = pattern._tail.copy()
+        if not parts:
+            raise ValueError("Unacceptable pattern: {!r}".format(pattern))
+        raw = pattern._raw_path
+        if raw[-1] in (self.parser.sep, self.parser.altsep):
+            # GH-65238: pathlib doesn't preserve trailing slash. Add it back.
+            parts.append('')
+        select = self._glob_selector(parts[::-1], case_sensitive, recurse_symlinks)
+        root = str(self)
+        paths = select(root)
+
+        # Normalize results
+        if root == '.':
+            paths = map(self._remove_leading_dot, paths)
+        if parts[-1] == '':
+            paths = map(self._remove_trailing_slash, paths)
+        elif parts[-1] == '**':
+            paths = self._filter_trailing_slash(paths)
+        paths = map(self._from_parsed_string, paths)
+        return paths
+
+    def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
+        """Recursively yield all existing files (of any kind, including
+        directories) matching the given relative pattern, anywhere in
+        this subtree.
+        """
+        sys.audit("pathlib.Path.rglob", self, pattern)
+        if not isinstance(pattern, PurePath):
+            pattern = self.with_segments(pattern)
+        pattern = '**' / pattern
+        return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
+
+    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+        """Walk the directory tree from this directory, similar to os.walk()."""
+        sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
+        root_dir = str(self)
+        if not follow_symlinks:
+            follow_symlinks = os._walk_symlinks_as_files
+        results = os.walk(root_dir, top_down, on_error, follow_symlinks)
+        for path_str, dirnames, filenames in results:
+            if root_dir == '.':
+                path_str = path_str[2:]
+            yield self._from_parsed_string(path_str), dirnames, filenames
+
+    def absolute(self):
+        """Return an absolute version of this path
+        No normalization or symlink resolution is performed.
+
+        Use resolve() to resolve symlinks and remove '..' segments.
+        """
+        if self.is_absolute():
+            return self
+        if self.root:
+            drive = os.path.splitroot(os.getcwd())[0]
+            return self._from_parsed_parts(drive, self.root, self._tail)
+        if self.drive:
+            # There is a CWD on each drive-letter drive.
+            cwd = os.path.abspath(self.drive)
+        else:
+            cwd = os.getcwd()
+        if not self._tail:
+            # Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
+            # We pass only one argument to with_segments() to avoid the cost
+            # of joining, and we exploit the fact that getcwd() returns a
+            # fully-normalized string by storing it in _str. This is used to
+            # implement Path.cwd().
+            return self._from_parsed_string(cwd)
+        drive, root, rel = os.path.splitroot(cwd)
+        if not rel:
+            return self._from_parsed_parts(drive, root, self._tail)
+        tail = rel.split(self.parser.sep)
+        tail.extend(self._tail)
+        return self._from_parsed_parts(drive, root, tail)
+
+    def resolve(self, strict=False):
+        """
+        Make the path absolute, resolving all symlinks on the way and also
+        normalizing it.
+        """
+
+        return self.with_segments(os.path.realpath(self, strict=strict))
+
+    if pwd:
+        def owner(self, *, follow_symlinks=True):
+            """
+            Return the login name of the file owner.
+            """
+            uid = self.stat(follow_symlinks=follow_symlinks).st_uid
+            return pwd.getpwuid(uid).pw_name
+
+    if grp:
+        def group(self, *, follow_symlinks=True):
+            """
+            Return the group name of the file gid.
+            """
+            gid = self.stat(follow_symlinks=follow_symlinks).st_gid
+            return grp.getgrgid(gid).gr_name
+
+    if hasattr(os, "readlink"):
+        def readlink(self):
+            """
+            Return the path to which the symbolic link points.
+            """
+            return self.with_segments(os.readlink(self))
+
+    def touch(self, mode=0o666, exist_ok=True):
+        """
+        Create this file with the given access mode, if it doesn't exist.
+        """
+
+        if exist_ok:
+            # First try to bump modification time
+            # Implementation note: GNU touch uses the UTIME_NOW option of
+            # the utimensat() / futimens() functions.
+            try:
+                os.utime(self, None)
+            except OSError:
+                # Avoid exception chaining
+                pass
+            else:
+                return
+        flags = os.O_CREAT | os.O_WRONLY
+        if not exist_ok:
+            flags |= os.O_EXCL
+        fd = os.open(self, flags, mode)
+        os.close(fd)
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        """
+        Create a new directory at this given path.
+        """
+        try:
+            os.mkdir(self, mode)
+        except FileNotFoundError:
+            if not parents or self.parent == self:
+                raise
+            self.parent.mkdir(parents=True, exist_ok=True)
+            self.mkdir(mode, parents=False, exist_ok=exist_ok)
+        except OSError:
+            # Cannot rely on checking for EEXIST, since the operating system
+            # could give priority to other errors like EACCES or EROFS
+            if not exist_ok or not self.is_dir():
+                raise
+
+    def chmod(self, mode, *, follow_symlinks=True):
+        """
+        Change the permissions of the path, like os.chmod().
+        """
+        os.chmod(self, mode, follow_symlinks=follow_symlinks)
+
+    def unlink(self, missing_ok=False):
+        """
+        Remove this file or link.
+        If the path is a directory, use rmdir() instead.
+        """
+        try:
+            os.unlink(self)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    def rmdir(self):
+        """
+        Remove this directory.  The directory must be empty.
+        """
+        os.rmdir(self)
+
+    def rename(self, target):
+        """
+        Rename this path to the target path.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        os.rename(self, target)
+        return self.with_segments(target)
+
+    def replace(self, target):
+        """
+        Rename this path to the target path, overwriting if that path exists.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        os.replace(self, target)
+        return self.with_segments(target)
+
+    if hasattr(os, "symlink"):
+        def symlink_to(self, target, target_is_directory=False):
+            """
+            Make this path a symlink pointing to the target path.
+            Note the order of arguments (link, target) is the reverse of os.symlink.
+            """
+            os.symlink(target, self, target_is_directory)
+
+    if hasattr(os, "link"):
+        def hardlink_to(self, target):
+            """
+            Make this path a hard link pointing to the same file as *target*.
+
+            Note the order of arguments (self, target) is the reverse of os.link's.
+            """
+            os.link(target, self)
+
+    def expanduser(self):
+        """ Return a new path with expanded ~ and ~user constructs
+        (as returned by os.path.expanduser)
+        """
+        if (not (self.drive or self.root) and
+            self._tail and self._tail[0][:1] == '~'):
+            homedir = os.path.expanduser(self._tail[0])
+            if homedir[:1] == "~":
+                raise RuntimeError("Could not determine home directory.")
+            drv, root, tail = self._parse_path(homedir)
+            return self._from_parsed_parts(drv, root, tail + self._tail[1:])
+
+        return self
+
+    @classmethod
+    def from_uri(cls, uri):
+        """Return a new path from the given 'file' URI."""
+        if not uri.startswith('file:'):
+            raise ValueError(f"URI does not start with 'file:': {uri!r}")
+        path = uri[5:]
+        if path[:3] == '///':
+            # Remove empty authority
+            path = path[2:]
+        elif path[:12] == '//localhost/':
+            # Remove 'localhost' authority
+            path = path[11:]
+        if path[:3] == '///' or (path[:1] == '/' and path[2:3] in ':|'):
+            # Remove slash before DOS device/UNC path
+            path = path[1:]
+        if path[1:2] == '|':
+            # Replace bar with colon in DOS drive
+            path = path[:1] + ':' + path[2:]
+        from urllib.parse import unquote_to_bytes
+        path = cls(os.fsdecode(unquote_to_bytes(path)))
+        if not path.is_absolute():
+            raise ValueError(f"URI is not absolute: {uri!r}")
+        return path
+
+
+class PosixPath(Path, PurePosixPath):
+    """Path subclass for non-Windows systems.
+
+    On a POSIX system, instantiating a Path should return this object.
+    """
+    __slots__ = ()
+
+    if os.name == 'nt':
+        def __new__(cls, *args, **kwargs):
+            raise UnsupportedOperation(
+                f"cannot instantiate {cls.__name__!r} on your system")
+
+class WindowsPath(Path, PureWindowsPath):
+    """Path subclass for Windows systems.
+
+    On a Windows system, instantiating a Path should return this object.
+    """
+    __slots__ = ()
+
+    if os.name != 'nt':
+        def __new__(cls, *args, **kwargs):
+            raise UnsupportedOperation(
+                f"cannot instantiate {cls.__name__!r} on your system")
diff --git a/Lib/test/test_pathlib.py b/Lib/test/test_pathlib.py
deleted file mode 100644
index c1696bb3737..00000000000
--- a/Lib/test/test_pathlib.py
+++ /dev/null
@@ -1,3328 +0,0 @@
-import contextlib
-import collections.abc
-import io
-import os
-import sys
-import errno
-import pathlib
-import pickle
-import socket
-import stat
-import tempfile
-import unittest
-from unittest import mock
-
-from test.support import import_helper
-from test.support import set_recursion_limit
-from test.support import is_emscripten, is_wasi
-from test.support import os_helper
-from test.support.os_helper import TESTFN, FakePath
-
-try:
-    import grp, pwd
-except ImportError:
-    grp = pwd = None
-
-
-#
-# Tests for the pure classes.
-#
-
-class _BasePurePathSubclass(object):
-    def __init__(self, *pathsegments, session_id):
-        super().__init__(*pathsegments)
-        self.session_id = session_id
-
-    def with_segments(self, *pathsegments):
-        return type(self)(*pathsegments, session_id=self.session_id)
-
-
-class _BasePurePathTest(object):
-
-    # Keys are canonical paths, values are list of tuples of arguments
-    # supposed to produce equal paths.
-    equivalences = {
-        'a/b': [
-            ('a', 'b'), ('a/', 'b'), ('a', 'b/'), ('a/', 'b/'),
-            ('a/b/',), ('a//b',), ('a//b//',),
-            # Empty components get removed.
-            ('', 'a', 'b'), ('a', '', 'b'), ('a', 'b', ''),
-            ],
-        '/b/c/d': [
-            ('a', '/b/c', 'd'), ('/a', '/b/c', 'd'),
-            # Empty components get removed.
-            ('/', 'b', '', 'c/d'), ('/', '', 'b/c/d'), ('', '/b/c/d'),
-            ],
-    }
-
-    def setUp(self):
-        p = self.cls('a')
-        self.flavour = p._flavour
-        self.sep = self.flavour.sep
-        self.altsep = self.flavour.altsep
-
-    def test_constructor_common(self):
-        P = self.cls
-        p = P('a')
-        self.assertIsInstance(p, P)
-        P('a', 'b', 'c')
-        P('/a', 'b', 'c')
-        P('a/b/c')
-        P('/a/b/c')
-        P(FakePath("a/b/c"))
-        self.assertEqual(P(P('a')), P('a'))
-        self.assertEqual(P(P('a'), 'b'), P('a/b'))
-        self.assertEqual(P(P('a'), P('b')), P('a/b'))
-        self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
-        self.assertEqual(P(P('./a:b')), P('./a:b'))
-
-    def test_bytes(self):
-        P = self.cls
-        message = (r"argument should be a str or an os\.PathLike object "
-                   r"where __fspath__ returns a str, not 'bytes'")
-        with self.assertRaisesRegex(TypeError, message):
-            P(b'a')
-        with self.assertRaisesRegex(TypeError, message):
-            P(b'a', 'b')
-        with self.assertRaisesRegex(TypeError, message):
-            P('a', b'b')
-        with self.assertRaises(TypeError):
-            P('a').joinpath(b'b')
-        with self.assertRaises(TypeError):
-            P('a') / b'b'
-        with self.assertRaises(TypeError):
-            b'a' / P('b')
-        with self.assertRaises(TypeError):
-            P('a').match(b'b')
-        with self.assertRaises(TypeError):
-            P('a').relative_to(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_name(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_stem(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_suffix(b'b')
-
-    def _check_str_subclass(self, *args):
-        # Issue #21127: it should be possible to construct a PurePath object
-        # from a str subclass instance, and it then gets converted to
-        # a pure str object.
-        class StrSubclass(str):
-            pass
-        P = self.cls
-        p = P(*(StrSubclass(x) for x in args))
-        self.assertEqual(p, P(*args))
-        for part in p.parts:
-            self.assertIs(type(part), str)
-
-    def test_str_subclass_common(self):
-        self._check_str_subclass('')
-        self._check_str_subclass('.')
-        self._check_str_subclass('a')
-        self._check_str_subclass('a/b.txt')
-        self._check_str_subclass('/a/b.txt')
-
-    @unittest.skip("TODO: RUSTPYTHON; PyObject::set_slot index out of bounds")
-    def test_with_segments_common(self):
-        class P(_BasePurePathSubclass, self.cls):
-            pass
-        p = P('foo', 'bar', session_id=42)
-        self.assertEqual(42, (p / 'foo').session_id)
-        self.assertEqual(42, ('foo' / p).session_id)
-        self.assertEqual(42, p.joinpath('foo').session_id)
-        self.assertEqual(42, p.with_name('foo').session_id)
-        self.assertEqual(42, p.with_stem('foo').session_id)
-        self.assertEqual(42, p.with_suffix('.foo').session_id)
-        self.assertEqual(42, p.with_segments('foo').session_id)
-        self.assertEqual(42, p.relative_to('foo').session_id)
-        self.assertEqual(42, p.parent.session_id)
-        for parent in p.parents:
-            self.assertEqual(42, parent.session_id)
-
-    def _get_drive_root_parts(self, parts):
-        path = self.cls(*parts)
-        return path.drive, path.root, path.parts
-
-    def _check_drive_root_parts(self, arg, *expected):
-        sep = self.flavour.sep
-        actual = self._get_drive_root_parts([x.replace('/', sep) for x in arg])
-        self.assertEqual(actual, expected)
-        if altsep := self.flavour.altsep:
-            actual = self._get_drive_root_parts([x.replace('/', altsep) for x in arg])
-            self.assertEqual(actual, expected)
-
-    def test_drive_root_parts_common(self):
-        check = self._check_drive_root_parts
-        sep = self.flavour.sep
-        # Unanchored parts.
-        check((),                   '', '', ())
-        check(('a',),               '', '', ('a',))
-        check(('a/',),              '', '', ('a',))
-        check(('a', 'b'),           '', '', ('a', 'b'))
-        # Expansion.
-        check(('a/b',),             '', '', ('a', 'b'))
-        check(('a/b/',),            '', '', ('a', 'b'))
-        check(('a', 'b/c', 'd'),    '', '', ('a', 'b', 'c', 'd'))
-        # Collapsing and stripping excess slashes.
-        check(('a', 'b//c', 'd'),   '', '', ('a', 'b', 'c', 'd'))
-        check(('a', 'b/c/', 'd'),   '', '', ('a', 'b', 'c', 'd'))
-        # Eliminating standalone dots.
-        check(('.',),               '', '', ())
-        check(('.', '.', 'b'),      '', '', ('b',))
-        check(('a', '.', 'b'),      '', '', ('a', 'b'))
-        check(('a', '.', '.'),      '', '', ('a',))
-        # The first part is anchored.
-        check(('/a/b',),            '', sep, (sep, 'a', 'b'))
-        check(('/a', 'b'),          '', sep, (sep, 'a', 'b'))
-        check(('/a/', 'b'),         '', sep, (sep, 'a', 'b'))
-        # Ignoring parts before an anchored part.
-        check(('a', '/b', 'c'),     '', sep, (sep, 'b', 'c'))
-        check(('a', '/b', '/c'),    '', sep, (sep, 'c'))
-
-    def test_join_common(self):
-        P = self.cls
-        p = P('a/b')
-        pp = p.joinpath('c')
-        self.assertEqual(pp, P('a/b/c'))
-        self.assertIs(type(pp), type(p))
-        pp = p.joinpath('c', 'd')
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = p.joinpath(P('c'))
-        self.assertEqual(pp, P('a/b/c'))
-        pp = p.joinpath('/c')
-        self.assertEqual(pp, P('/c'))
-
-    def test_div_common(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('a/b')
-        pp = p / 'c'
-        self.assertEqual(pp, P('a/b/c'))
-        self.assertIs(type(pp), type(p))
-        pp = p / 'c/d'
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = p / 'c' / 'd'
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = 'c' / p / 'd'
-        self.assertEqual(pp, P('c/a/b/d'))
-        pp = p / P('c')
-        self.assertEqual(pp, P('a/b/c'))
-        pp = p/ '/c'
-        self.assertEqual(pp, P('/c'))
-
-    def _check_str(self, expected, args):
-        p = self.cls(*args)
-        self.assertEqual(str(p), expected.replace('/', self.sep))
-
-    def test_str_common(self):
-        # Canonicalized paths roundtrip.
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            self._check_str(pathstr, (pathstr,))
-        # Special case for the empty path.
-        self._check_str('.', ('',))
-        # Other tests for str() are in test_equivalences().
-
-    def test_as_posix_common(self):
-        P = self.cls
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            self.assertEqual(P(pathstr).as_posix(), pathstr)
-        # Other tests for as_posix() are in test_equivalences().
-
-    def test_as_bytes_common(self):
-        sep = os.fsencode(self.sep)
-        P = self.cls
-        self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
-
-    def test_as_uri_common(self):
-        P = self.cls
-        with self.assertRaises(ValueError):
-            P('a').as_uri()
-        with self.assertRaises(ValueError):
-            P().as_uri()
-
-    def test_repr_common(self):
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            with self.subTest(pathstr=pathstr):
-                p = self.cls(pathstr)
-                clsname = p.__class__.__name__
-                r = repr(p)
-                # The repr() is in the form ClassName("forward-slashes path").
-                self.assertTrue(r.startswith(clsname + '('), r)
-                self.assertTrue(r.endswith(')'), r)
-                inner = r[len(clsname) + 1 : -1]
-                self.assertEqual(eval(inner), p.as_posix())
-
-    def test_repr_roundtrips(self):
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            with self.subTest(pathstr=pathstr):
-                p = self.cls(pathstr)
-                r = repr(p)
-                # The repr() roundtrips.
-                q = eval(r, pathlib.__dict__)
-                self.assertIs(q.__class__, p.__class__)
-                self.assertEqual(q, p)
-                self.assertEqual(repr(q), r)
-
-    def test_eq_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b'), P('a/b'))
-        self.assertEqual(P('a/b'), P('a', 'b'))
-        self.assertNotEqual(P('a/b'), P('a'))
-        self.assertNotEqual(P('a/b'), P('/a/b'))
-        self.assertNotEqual(P('a/b'), P())
-        self.assertNotEqual(P('/a/b'), P('/'))
-        self.assertNotEqual(P(), P('/'))
-        self.assertNotEqual(P(), "")
-        self.assertNotEqual(P(), {})
-        self.assertNotEqual(P(), int)
-
-    def test_match_common(self):
-        P = self.cls
-        self.assertRaises(ValueError, P('a').match, '')
-        self.assertRaises(ValueError, P('a').match, '.')
-        # Simple relative pattern.
-        self.assertTrue(P('b.py').match('b.py'))
-        self.assertTrue(P('a/b.py').match('b.py'))
-        self.assertTrue(P('/a/b.py').match('b.py'))
-        self.assertFalse(P('a.py').match('b.py'))
-        self.assertFalse(P('b/py').match('b.py'))
-        self.assertFalse(P('/a.py').match('b.py'))
-        self.assertFalse(P('b.py/c').match('b.py'))
-        # Wildcard relative pattern.
-        self.assertTrue(P('b.py').match('*.py'))
-        self.assertTrue(P('a/b.py').match('*.py'))
-        self.assertTrue(P('/a/b.py').match('*.py'))
-        self.assertFalse(P('b.pyc').match('*.py'))
-        self.assertFalse(P('b./py').match('*.py'))
-        self.assertFalse(P('b.py/c').match('*.py'))
-        # Multi-part relative pattern.
-        self.assertTrue(P('ab/c.py').match('a*/*.py'))
-        self.assertTrue(P('/d/ab/c.py').match('a*/*.py'))
-        self.assertFalse(P('a.py').match('a*/*.py'))
-        self.assertFalse(P('/dab/c.py').match('a*/*.py'))
-        self.assertFalse(P('ab/c.py/d').match('a*/*.py'))
-        # Absolute pattern.
-        self.assertTrue(P('/b.py').match('/*.py'))
-        self.assertFalse(P('b.py').match('/*.py'))
-        self.assertFalse(P('a/b.py').match('/*.py'))
-        self.assertFalse(P('/a/b.py').match('/*.py'))
-        # Multi-part absolute pattern.
-        self.assertTrue(P('/a/b.py').match('/a/*.py'))
-        self.assertFalse(P('/ab.py').match('/a/*.py'))
-        self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
-        # Multi-part glob-style pattern.
-        self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
-        self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
-        # Case-sensitive flag
-        self.assertFalse(P('A.py').match('a.PY', case_sensitive=True))
-        self.assertTrue(P('A.py').match('a.PY', case_sensitive=False))
-        self.assertFalse(P('c:/a/B.Py').match('C:/A/*.pY', case_sensitive=True))
-        self.assertTrue(P('/a/b/c.py').match('/A/*/*.Py', case_sensitive=False))
-        # Matching against empty path
-        self.assertFalse(P().match('*'))
-        self.assertTrue(P().match('**'))
-        self.assertFalse(P().match('**/*'))
-
-    def test_ordering_common(self):
-        # Ordering is tuple-alike.
-        def assertLess(a, b):
-            self.assertLess(a, b)
-            self.assertGreater(b, a)
-        P = self.cls
-        a = P('a')
-        b = P('a/b')
-        c = P('abc')
-        d = P('b')
-        assertLess(a, b)
-        assertLess(a, c)
-        assertLess(a, d)
-        assertLess(b, c)
-        assertLess(c, d)
-        P = self.cls
-        a = P('/a')
-        b = P('/a/b')
-        c = P('/abc')
-        d = P('/b')
-        assertLess(a, b)
-        assertLess(a, c)
-        assertLess(a, d)
-        assertLess(b, c)
-        assertLess(c, d)
-        with self.assertRaises(TypeError):
-            P() < {}
-
-    def test_parts_common(self):
-        # `parts` returns a tuple.
-        sep = self.sep
-        P = self.cls
-        p = P('a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('a', 'b'))
-        # When the path is absolute, the anchor is a separate part.
-        p = P('/a/b')
-        parts = p.parts
-        self.assertEqual(parts, (sep, 'a', 'b'))
-
-    def test_fspath_common(self):
-        P = self.cls
-        p = P('a/b')
-        self._check_str(p.__fspath__(), ('a/b',))
-        self._check_str(os.fspath(p), ('a/b',))
-
-    def test_equivalences(self):
-        for k, tuples in self.equivalences.items():
-            canon = k.replace('/', self.sep)
-            posix = k.replace(self.sep, '/')
-            if canon != posix:
-                tuples = tuples + [
-                    tuple(part.replace('/', self.sep) for part in t)
-                    for t in tuples
-                    ]
-                tuples.append((posix, ))
-            pcanon = self.cls(canon)
-            for t in tuples:
-                p = self.cls(*t)
-                self.assertEqual(p, pcanon, "failed with args {}".format(t))
-                self.assertEqual(hash(p), hash(pcanon))
-                self.assertEqual(str(p), canon)
-                self.assertEqual(p.as_posix(), posix)
-
-    def test_parent_common(self):
-        # Relative
-        P = self.cls
-        p = P('a/b/c')
-        self.assertEqual(p.parent, P('a/b'))
-        self.assertEqual(p.parent.parent, P('a'))
-        self.assertEqual(p.parent.parent.parent, P())
-        self.assertEqual(p.parent.parent.parent.parent, P())
-        # Anchored
-        p = P('/a/b/c')
-        self.assertEqual(p.parent, P('/a/b'))
-        self.assertEqual(p.parent.parent, P('/a'))
-        self.assertEqual(p.parent.parent.parent, P('/'))
-        self.assertEqual(p.parent.parent.parent.parent, P('/'))
-
-    def test_parents_common(self):
-        # Relative
-        P = self.cls
-        p = P('a/b/c')
-        par = p.parents
-        self.assertEqual(len(par), 3)
-        self.assertEqual(par[0], P('a/b'))
-        self.assertEqual(par[1], P('a'))
-        self.assertEqual(par[2], P('.'))
-        self.assertEqual(par[-1], P('.'))
-        self.assertEqual(par[-2], P('a'))
-        self.assertEqual(par[-3], P('a/b'))
-        self.assertEqual(par[0:1], (P('a/b'),))
-        self.assertEqual(par[:2], (P('a/b'), P('a')))
-        self.assertEqual(par[:-1], (P('a/b'), P('a')))
-        self.assertEqual(par[1:], (P('a'), P('.')))
-        self.assertEqual(par[::2], (P('a/b'), P('.')))
-        self.assertEqual(par[::-1], (P('.'), P('a'), P('a/b')))
-        self.assertEqual(list(par), [P('a/b'), P('a'), P('.')])
-        with self.assertRaises(IndexError):
-            par[-4]
-        with self.assertRaises(IndexError):
-            par[3]
-        with self.assertRaises(TypeError):
-            par[0] = p
-        # Anchored
-        p = P('/a/b/c')
-        par = p.parents
-        self.assertEqual(len(par), 3)
-        self.assertEqual(par[0], P('/a/b'))
-        self.assertEqual(par[1], P('/a'))
-        self.assertEqual(par[2], P('/'))
-        self.assertEqual(par[-1], P('/'))
-        self.assertEqual(par[-2], P('/a'))
-        self.assertEqual(par[-3], P('/a/b'))
-        self.assertEqual(par[0:1], (P('/a/b'),))
-        self.assertEqual(par[:2], (P('/a/b'), P('/a')))
-        self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
-        self.assertEqual(par[1:], (P('/a'), P('/')))
-        self.assertEqual(par[::2], (P('/a/b'), P('/')))
-        self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
-        self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
-        with self.assertRaises(IndexError):
-            par[-4]
-        with self.assertRaises(IndexError):
-            par[3]
-
-    def test_drive_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').drive, '')
-        self.assertEqual(P('/a/b').drive, '')
-        self.assertEqual(P('').drive, '')
-
-    def test_root_common(self):
-        P = self.cls
-        sep = self.sep
-        self.assertEqual(P('').root, '')
-        self.assertEqual(P('a/b').root, '')
-        self.assertEqual(P('/').root, sep)
-        self.assertEqual(P('/a/b').root, sep)
-
-    def test_anchor_common(self):
-        P = self.cls
-        sep = self.sep
-        self.assertEqual(P('').anchor, '')
-        self.assertEqual(P('a/b').anchor, '')
-        self.assertEqual(P('/').anchor, sep)
-        self.assertEqual(P('/a/b').anchor, sep)
-
-    def test_name_common(self):
-        P = self.cls
-        self.assertEqual(P('').name, '')
-        self.assertEqual(P('.').name, '')
-        self.assertEqual(P('/').name, '')
-        self.assertEqual(P('a/b').name, 'b')
-        self.assertEqual(P('/a/b').name, 'b')
-        self.assertEqual(P('/a/b/.').name, 'b')
-        self.assertEqual(P('a/b.py').name, 'b.py')
-        self.assertEqual(P('/a/b.py').name, 'b.py')
-
-    def test_suffix_common(self):
-        P = self.cls
-        self.assertEqual(P('').suffix, '')
-        self.assertEqual(P('.').suffix, '')
-        self.assertEqual(P('..').suffix, '')
-        self.assertEqual(P('/').suffix, '')
-        self.assertEqual(P('a/b').suffix, '')
-        self.assertEqual(P('/a/b').suffix, '')
-        self.assertEqual(P('/a/b/.').suffix, '')
-        self.assertEqual(P('a/b.py').suffix, '.py')
-        self.assertEqual(P('/a/b.py').suffix, '.py')
-        self.assertEqual(P('a/.hgrc').suffix, '')
-        self.assertEqual(P('/a/.hgrc').suffix, '')
-        self.assertEqual(P('a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('/a/Some name. Ending with a dot.').suffix, '')
-
-    def test_suffixes_common(self):
-        P = self.cls
-        self.assertEqual(P('').suffixes, [])
-        self.assertEqual(P('.').suffixes, [])
-        self.assertEqual(P('/').suffixes, [])
-        self.assertEqual(P('a/b').suffixes, [])
-        self.assertEqual(P('/a/b').suffixes, [])
-        self.assertEqual(P('/a/b/.').suffixes, [])
-        self.assertEqual(P('a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('/a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('a/.hgrc').suffixes, [])
-        self.assertEqual(P('/a/.hgrc').suffixes, [])
-        self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('a/Some name. Ending with a dot.').suffixes, [])
-        self.assertEqual(P('/a/Some name. Ending with a dot.').suffixes, [])
-
-    def test_stem_common(self):
-        P = self.cls
-        self.assertEqual(P('').stem, '')
-        self.assertEqual(P('.').stem, '')
-        self.assertEqual(P('..').stem, '..')
-        self.assertEqual(P('/').stem, '')
-        self.assertEqual(P('a/b').stem, 'b')
-        self.assertEqual(P('a/b.py').stem, 'b')
-        self.assertEqual(P('a/.hgrc').stem, '.hgrc')
-        self.assertEqual(P('a/.hg.rc').stem, '.hg')
-        self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
-        self.assertEqual(P('a/Some name. Ending with a dot.').stem,
-                         'Some name. Ending with a dot.')
-
-    def test_with_name_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
-        self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
-        self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
-        self.assertRaises(ValueError, P('').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('.').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('/').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('a/b').with_name, '')
-        self.assertRaises(ValueError, P('a/b').with_name, '.')
-        self.assertRaises(ValueError, P('a/b').with_name, '/c')
-        self.assertRaises(ValueError, P('a/b').with_name, 'c/')
-        self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
-
-    def test_with_stem_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
-        self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
-        self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
-        self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
-        self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
-        self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d'))
-        self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d'))
-        self.assertRaises(ValueError, P('').with_stem, 'd')
-        self.assertRaises(ValueError, P('.').with_stem, 'd')
-        self.assertRaises(ValueError, P('/').with_stem, 'd')
-        self.assertRaises(ValueError, P('a/b').with_stem, '')
-        self.assertRaises(ValueError, P('a/b').with_stem, '.')
-        self.assertRaises(ValueError, P('a/b').with_stem, '/c')
-        self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
-        self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
-
-    def test_with_suffix_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
-        self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
-        self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
-        self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
-        # Stripping suffix.
-        self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
-        self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
-        # Path doesn't have a "filename" component.
-        self.assertRaises(ValueError, P('').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
-        # Invalid suffix.
-        self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '/')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
-        self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
-        self.assertRaises(ValueError, P('a/b').with_suffix,
-                          (self.flavour.sep, 'd'))
-
-    def test_relative_to_common(self):
-        P = self.cls
-        p = P('a/b')
-        self.assertRaises(TypeError, p.relative_to)
-        self.assertRaises(TypeError, p.relative_to, b'a')
-        self.assertEqual(p.relative_to(P()), P('a/b'))
-        self.assertEqual(p.relative_to(''), P('a/b'))
-        self.assertEqual(p.relative_to(P('a')), P('b'))
-        self.assertEqual(p.relative_to('a'), P('b'))
-        self.assertEqual(p.relative_to('a/'), P('b'))
-        self.assertEqual(p.relative_to(P('a/b')), P())
-        self.assertEqual(p.relative_to('a/b'), P())
-        self.assertEqual(p.relative_to(P(), walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P())
-        self.assertEqual(p.relative_to('a/b', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
-        self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
-        # With several args.
-        with self.assertWarns(DeprecationWarning):
-            p.relative_to('a', 'b')
-            p.relative_to('a', 'b', walk_up=True)
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('c'))
-        self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
-        self.assertRaises(ValueError, p.relative_to, P('a/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a'))
-        self.assertRaises(ValueError, p.relative_to, P("../a"))
-        self.assertRaises(ValueError, p.relative_to, P("a/.."))
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
-        p = P('/a/b')
-        self.assertEqual(p.relative_to(P('/')), P('a/b'))
-        self.assertEqual(p.relative_to('/'), P('a/b'))
-        self.assertEqual(p.relative_to(P('/a')), P('b'))
-        self.assertEqual(p.relative_to('/a'), P('b'))
-        self.assertEqual(p.relative_to('/a/'), P('b'))
-        self.assertEqual(p.relative_to(P('/a/b')), P())
-        self.assertEqual(p.relative_to('/a/b'), P())
-        self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P())
-        self.assertEqual(p.relative_to('/a/b', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
-        self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a/c'))
-        self.assertRaises(ValueError, p.relative_to, P())
-        self.assertRaises(ValueError, p.relative_to, '')
-        self.assertRaises(ValueError, p.relative_to, P('a'))
-        self.assertRaises(ValueError, p.relative_to, P("../a"))
-        self.assertRaises(ValueError, p.relative_to, P("a/.."))
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
-        self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
-
-    def test_is_relative_to_common(self):
-        P = self.cls
-        p = P('a/b')
-        self.assertRaises(TypeError, p.is_relative_to)
-        self.assertRaises(TypeError, p.is_relative_to, b'a')
-        self.assertTrue(p.is_relative_to(P()))
-        self.assertTrue(p.is_relative_to(''))
-        self.assertTrue(p.is_relative_to(P('a')))
-        self.assertTrue(p.is_relative_to('a/'))
-        self.assertTrue(p.is_relative_to(P('a/b')))
-        self.assertTrue(p.is_relative_to('a/b'))
-        # With several args.
-        with self.assertWarns(DeprecationWarning):
-            p.is_relative_to('a', 'b')
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('c')))
-        self.assertFalse(p.is_relative_to(P('a/b/c')))
-        self.assertFalse(p.is_relative_to(P('a/c')))
-        self.assertFalse(p.is_relative_to(P('/a')))
-        p = P('/a/b')
-        self.assertTrue(p.is_relative_to(P('/')))
-        self.assertTrue(p.is_relative_to('/'))
-        self.assertTrue(p.is_relative_to(P('/a')))
-        self.assertTrue(p.is_relative_to('/a'))
-        self.assertTrue(p.is_relative_to('/a/'))
-        self.assertTrue(p.is_relative_to(P('/a/b')))
-        self.assertTrue(p.is_relative_to('/a/b'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('/c')))
-        self.assertFalse(p.is_relative_to(P('/a/b/c')))
-        self.assertFalse(p.is_relative_to(P('/a/c')))
-        self.assertFalse(p.is_relative_to(P()))
-        self.assertFalse(p.is_relative_to(''))
-        self.assertFalse(p.is_relative_to(P('a')))
-
-    def test_pickling_common(self):
-        P = self.cls
-        p = P('/a/b')
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            dumped = pickle.dumps(p, proto)
-            pp = pickle.loads(dumped)
-            self.assertIs(pp.__class__, p.__class__)
-            self.assertEqual(pp, p)
-            self.assertEqual(hash(pp), hash(p))
-            self.assertEqual(str(pp), str(p))
-
-
-class PurePosixPathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PurePosixPath
-
-    def test_drive_root_parts(self):
-        check = self._check_drive_root_parts
-        # Collapsing of excess leading slashes, except for the double-slash
-        # special case.
-        check(('//a', 'b'),             '', '//', ('//', 'a', 'b'))
-        check(('///a', 'b'),            '', '/', ('/', 'a', 'b'))
-        check(('////a', 'b'),           '', '/', ('/', 'a', 'b'))
-        # Paths which look like NT paths aren't treated specially.
-        check(('c:a',),                 '', '', ('c:a',))
-        check(('c:\\a',),               '', '', ('c:\\a',))
-        check(('\\a',),                 '', '', ('\\a',))
-
-    def test_root(self):
-        P = self.cls
-        self.assertEqual(P('/a/b').root, '/')
-        self.assertEqual(P('///a/b').root, '/')
-        # POSIX special case for two leading slashes.
-        self.assertEqual(P('//a/b').root, '//')
-
-    def test_eq(self):
-        P = self.cls
-        self.assertNotEqual(P('a/b'), P('A/b'))
-        self.assertEqual(P('/a'), P('///a'))
-        self.assertNotEqual(P('/a'), P('//a'))
-
-    def test_as_uri(self):
-        P = self.cls
-        self.assertEqual(P('/').as_uri(), 'file:///')
-        self.assertEqual(P('/a/b.c').as_uri(), 'file:///a/b.c')
-        self.assertEqual(P('/a/b%#c').as_uri(), 'file:///a/b%25%23c')
-
-    def test_as_uri_non_ascii(self):
-        from urllib.parse import quote_from_bytes
-        P = self.cls
-        try:
-            os.fsencode('\xe9')
-        except UnicodeEncodeError:
-            self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
-        self.assertEqual(P('/a/b\xe9').as_uri(),
-                         'file:///a/b' + quote_from_bytes(os.fsencode('\xe9')))
-
-    def test_match(self):
-        P = self.cls
-        self.assertFalse(P('A.py').match('a.PY'))
-
-    def test_is_absolute(self):
-        P = self.cls
-        self.assertFalse(P().is_absolute())
-        self.assertFalse(P('a').is_absolute())
-        self.assertFalse(P('a/b/').is_absolute())
-        self.assertTrue(P('/').is_absolute())
-        self.assertTrue(P('/a').is_absolute())
-        self.assertTrue(P('/a/b/').is_absolute())
-        self.assertTrue(P('//a').is_absolute())
-        self.assertTrue(P('//a/b').is_absolute())
-
-    def test_is_reserved(self):
-        P = self.cls
-        self.assertIs(False, P('').is_reserved())
-        self.assertIs(False, P('/').is_reserved())
-        self.assertIs(False, P('/foo/bar').is_reserved())
-        self.assertIs(False, P('/dev/con/PRN/NUL').is_reserved())
-
-    def test_join(self):
-        P = self.cls
-        p = P('//a')
-        pp = p.joinpath('b')
-        self.assertEqual(pp, P('//a/b'))
-        pp = P('/a').joinpath('//c')
-        self.assertEqual(pp, P('//c'))
-        pp = P('//a').joinpath('/c')
-        self.assertEqual(pp, P('/c'))
-
-    def test_div(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('//a')
-        pp = p / 'b'
-        self.assertEqual(pp, P('//a/b'))
-        pp = P('/a') / '//c'
-        self.assertEqual(pp, P('//c'))
-        pp = P('//a') / '/c'
-        self.assertEqual(pp, P('/c'))
-
-    def test_parse_windows_path(self):
-        P = self.cls
-        p = P('c:', 'a', 'b')
-        pp = P(pathlib.PureWindowsPath('c:\\a\\b'))
-        self.assertEqual(p, pp)
-
-
-class PureWindowsPathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PureWindowsPath
-
-    equivalences = _BasePurePathTest.equivalences.copy()
-    equivalences.update({
-        './a:b': [ ('./a:b',) ],
-        'c:a': [ ('c:', 'a'), ('c:', 'a/'), ('.', 'c:', 'a') ],
-        'c:/a': [
-            ('c:/', 'a'), ('c:', '/', 'a'), ('c:', '/a'),
-            ('/z', 'c:/', 'a'), ('//x/y', 'c:/', 'a'),
-            ],
-        '//a/b/': [ ('//a/b',) ],
-        '//a/b/c': [
-            ('//a/b', 'c'), ('//a/b/', 'c'),
-            ],
-    })
-
-    def test_drive_root_parts(self):
-        check = self._check_drive_root_parts
-        # First part is anchored.
-        check(('c:',),                  'c:', '', ('c:',))
-        check(('c:/',),                 'c:', '\\', ('c:\\',))
-        check(('/',),                   '', '\\', ('\\',))
-        check(('c:a',),                 'c:', '', ('c:', 'a'))
-        check(('c:/a',),                'c:', '\\', ('c:\\', 'a'))
-        check(('/a',),                  '', '\\', ('\\', 'a'))
-        # UNC paths.
-        check(('//',),                  '\\\\', '', ('\\\\',))
-        check(('//a',),                 '\\\\a', '', ('\\\\a',))
-        check(('//a/',),                '\\\\a\\', '', ('\\\\a\\',))
-        check(('//a/b',),               '\\\\a\\b', '\\', ('\\\\a\\b\\',))
-        check(('//a/b/',),              '\\\\a\\b', '\\', ('\\\\a\\b\\',))
-        check(('//a/b/c',),             '\\\\a\\b', '\\', ('\\\\a\\b\\', 'c'))
-        # Second part is anchored, so that the first part is ignored.
-        check(('a', 'Z:b', 'c'),        'Z:', '', ('Z:', 'b', 'c'))
-        check(('a', 'Z:/b', 'c'),       'Z:', '\\', ('Z:\\', 'b', 'c'))
-        # UNC paths.
-        check(('a', '//b/c', 'd'),      '\\\\b\\c', '\\', ('\\\\b\\c\\', 'd'))
-        # Collapsing and stripping excess slashes.
-        check(('a', 'Z://b//c/', 'd/'), 'Z:', '\\', ('Z:\\', 'b', 'c', 'd'))
-        # UNC paths.
-        check(('a', '//b/c//', 'd'),    '\\\\b\\c', '\\', ('\\\\b\\c\\', 'd'))
-        # Extended paths.
-        check(('//./c:',),              '\\\\.\\c:', '', ('\\\\.\\c:',))
-        check(('//?/c:/',),             '\\\\?\\c:', '\\', ('\\\\?\\c:\\',))
-        check(('//?/c:/a',),            '\\\\?\\c:', '\\', ('\\\\?\\c:\\', 'a'))
-        check(('//?/c:/a', '/b'),       '\\\\?\\c:', '\\', ('\\\\?\\c:\\', 'b'))
-        # Extended UNC paths (format is "\\?\UNC\server\share").
-        check(('//?',),                 '\\\\?', '', ('\\\\?',))
-        check(('//?/',),                '\\\\?\\', '', ('\\\\?\\',))
-        check(('//?/UNC',),             '\\\\?\\UNC', '', ('\\\\?\\UNC',))
-        check(('//?/UNC/',),            '\\\\?\\UNC\\', '', ('\\\\?\\UNC\\',))
-        check(('//?/UNC/b',),           '\\\\?\\UNC\\b', '', ('\\\\?\\UNC\\b',))
-        check(('//?/UNC/b/',),          '\\\\?\\UNC\\b\\', '', ('\\\\?\\UNC\\b\\',))
-        check(('//?/UNC/b/c',),         '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\',))
-        check(('//?/UNC/b/c/',),        '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\',))
-        check(('//?/UNC/b/c/d',),       '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\', 'd'))
-        # UNC device paths
-        check(('//./BootPartition/',),   '\\\\.\\BootPartition', '\\', ('\\\\.\\BootPartition\\',))
-        check(('//?/BootPartition/',),   '\\\\?\\BootPartition', '\\', ('\\\\?\\BootPartition\\',))
-        check(('//./PhysicalDrive0',),   '\\\\.\\PhysicalDrive0', '', ('\\\\.\\PhysicalDrive0',))
-        check(('//?/Volume{}/',),        '\\\\?\\Volume{}', '\\', ('\\\\?\\Volume{}\\',))
-        check(('//./nul',),              '\\\\.\\nul', '', ('\\\\.\\nul',))
-        # Second part has a root but not drive.
-        check(('a', '/b', 'c'),         '', '\\', ('\\', 'b', 'c'))
-        check(('Z:/a', '/b', 'c'),      'Z:', '\\', ('Z:\\', 'b', 'c'))
-        check(('//?/Z:/a', '/b', 'c'),  '\\\\?\\Z:', '\\', ('\\\\?\\Z:\\', 'b', 'c'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        check(('c:/a/b', 'c:x/y'),      'c:', '\\', ('c:\\', 'a', 'b', 'x', 'y'))
-        check(('c:/a/b', 'c:/x/y'),     'c:', '\\', ('c:\\', 'x', 'y'))
-        # Paths to files with NTFS alternate data streams
-        check(('./c:s',),               '', '', ('c:s',))
-        check(('cc:s',),                '', '', ('cc:s',))
-        check(('C:c:s',),               'C:', '', ('C:', 'c:s'))
-        check(('C:/c:s',),              'C:', '\\', ('C:\\', 'c:s'))
-        check(('D:a', './c:b'),         'D:', '', ('D:', 'a', 'c:b'))
-        check(('D:/a', './c:b'),        'D:', '\\', ('D:\\', 'a', 'c:b'))
-
-    def test_str(self):
-        p = self.cls('a/b/c')
-        self.assertEqual(str(p), 'a\\b\\c')
-        p = self.cls('c:/a/b/c')
-        self.assertEqual(str(p), 'c:\\a\\b\\c')
-        p = self.cls('//a/b')
-        self.assertEqual(str(p), '\\\\a\\b\\')
-        p = self.cls('//a/b/c')
-        self.assertEqual(str(p), '\\\\a\\b\\c')
-        p = self.cls('//a/b/c/d')
-        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
-
-    def test_str_subclass(self):
-        self._check_str_subclass('.\\a:b')
-        self._check_str_subclass('c:')
-        self._check_str_subclass('c:a')
-        self._check_str_subclass('c:a\\b.txt')
-        self._check_str_subclass('c:\\')
-        self._check_str_subclass('c:\\a')
-        self._check_str_subclass('c:\\a\\b.txt')
-        self._check_str_subclass('\\\\some\\share')
-        self._check_str_subclass('\\\\some\\share\\a')
-        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
-
-    def test_eq(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b'), P('c:a/b'))
-        self.assertEqual(P('c:a/b'), P('c:', 'a', 'b'))
-        self.assertNotEqual(P('c:a/b'), P('d:a/b'))
-        self.assertNotEqual(P('c:a/b'), P('c:/a/b'))
-        self.assertNotEqual(P('/a/b'), P('c:/a/b'))
-        # Case-insensitivity.
-        self.assertEqual(P('a/B'), P('A/b'))
-        self.assertEqual(P('C:a/B'), P('c:A/b'))
-        self.assertEqual(P('//Some/SHARE/a/B'), P('//somE/share/A/b'))
-        self.assertEqual(P('\u0130'), P('i\u0307'))
-
-    def test_as_uri(self):
-        P = self.cls
-        with self.assertRaises(ValueError):
-            P('/a/b').as_uri()
-        with self.assertRaises(ValueError):
-            P('c:a/b').as_uri()
-        self.assertEqual(P('c:/').as_uri(), 'file:///c:/')
-        self.assertEqual(P('c:/a/b.c').as_uri(), 'file:///c:/a/b.c')
-        self.assertEqual(P('c:/a/b%#c').as_uri(), 'file:///c:/a/b%25%23c')
-        self.assertEqual(P('c:/a/b\xe9').as_uri(), 'file:///c:/a/b%C3%A9')
-        self.assertEqual(P('//some/share/').as_uri(), 'file://some/share/')
-        self.assertEqual(P('//some/share/a/b.c').as_uri(),
-                         'file://some/share/a/b.c')
-        self.assertEqual(P('//some/share/a/b%#c\xe9').as_uri(),
-                         'file://some/share/a/b%25%23c%C3%A9')
-
-    def test_match(self):
-        P = self.cls
-        # Absolute patterns.
-        self.assertTrue(P('c:/b.py').match('*:/*.py'))
-        self.assertTrue(P('c:/b.py').match('c:/*.py'))
-        self.assertFalse(P('d:/b.py').match('c:/*.py'))  # wrong drive
-        self.assertFalse(P('b.py').match('/*.py'))
-        self.assertFalse(P('b.py').match('c:*.py'))
-        self.assertFalse(P('b.py').match('c:/*.py'))
-        self.assertFalse(P('c:b.py').match('/*.py'))
-        self.assertFalse(P('c:b.py').match('c:/*.py'))
-        self.assertFalse(P('/b.py').match('c:*.py'))
-        self.assertFalse(P('/b.py').match('c:/*.py'))
-        # UNC patterns.
-        self.assertTrue(P('//some/share/a.py').match('//*/*/*.py'))
-        self.assertTrue(P('//some/share/a.py').match('//some/share/*.py'))
-        self.assertFalse(P('//other/share/a.py').match('//some/share/*.py'))
-        self.assertFalse(P('//some/share/a/b.py').match('//some/share/*.py'))
-        # Case-insensitivity.
-        self.assertTrue(P('B.py').match('b.PY'))
-        self.assertTrue(P('c:/a/B.Py').match('C:/A/*.pY'))
-        self.assertTrue(P('//Some/Share/B.Py').match('//somE/sharE/*.pY'))
-        # Path anchor doesn't match pattern anchor
-        self.assertFalse(P('c:/b.py').match('/*.py'))  # 'c:/' vs '/'
-        self.assertFalse(P('c:/b.py').match('c:*.py'))  # 'c:/' vs 'c:'
-        self.assertFalse(P('//some/share/a.py').match('/*.py'))  # '//some/share/' vs '/'
-
-    def test_ordering_common(self):
-        # Case-insensitivity.
-        def assertOrderedEqual(a, b):
-            self.assertLessEqual(a, b)
-            self.assertGreaterEqual(b, a)
-        P = self.cls
-        p = P('c:A/b')
-        q = P('C:a/B')
-        assertOrderedEqual(p, q)
-        self.assertFalse(p < q)
-        self.assertFalse(p > q)
-        p = P('//some/Share/A/b')
-        q = P('//Some/SHARE/a/B')
-        assertOrderedEqual(p, q)
-        self.assertFalse(p < q)
-        self.assertFalse(p > q)
-
-    def test_parts(self):
-        P = self.cls
-        p = P('c:a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('c:', 'a', 'b'))
-        p = P('c:/a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('c:\\', 'a', 'b'))
-        p = P('//a/b/c/d')
-        parts = p.parts
-        self.assertEqual(parts, ('\\\\a\\b\\', 'c', 'd'))
-
-    def test_parent(self):
-        # Anchored
-        P = self.cls
-        p = P('z:a/b/c')
-        self.assertEqual(p.parent, P('z:a/b'))
-        self.assertEqual(p.parent.parent, P('z:a'))
-        self.assertEqual(p.parent.parent.parent, P('z:'))
-        self.assertEqual(p.parent.parent.parent.parent, P('z:'))
-        p = P('z:/a/b/c')
-        self.assertEqual(p.parent, P('z:/a/b'))
-        self.assertEqual(p.parent.parent, P('z:/a'))
-        self.assertEqual(p.parent.parent.parent, P('z:/'))
-        self.assertEqual(p.parent.parent.parent.parent, P('z:/'))
-        p = P('//a/b/c/d')
-        self.assertEqual(p.parent, P('//a/b/c'))
-        self.assertEqual(p.parent.parent, P('//a/b'))
-        self.assertEqual(p.parent.parent.parent, P('//a/b'))
-
-    def test_parents(self):
-        # Anchored
-        P = self.cls
-        p = P('z:a/b/')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('z:a'))
-        self.assertEqual(par[1], P('z:'))
-        self.assertEqual(par[0:1], (P('z:a'),))
-        self.assertEqual(par[:-1], (P('z:a'),))
-        self.assertEqual(par[:2], (P('z:a'), P('z:')))
-        self.assertEqual(par[1:], (P('z:'),))
-        self.assertEqual(par[::2], (P('z:a'),))
-        self.assertEqual(par[::-1], (P('z:'), P('z:a')))
-        self.assertEqual(list(par), [P('z:a'), P('z:')])
-        with self.assertRaises(IndexError):
-            par[2]
-        p = P('z:/a/b/')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('z:/a'))
-        self.assertEqual(par[1], P('z:/'))
-        self.assertEqual(par[0:1], (P('z:/a'),))
-        self.assertEqual(par[0:-1], (P('z:/a'),))
-        self.assertEqual(par[:2], (P('z:/a'), P('z:/')))
-        self.assertEqual(par[1:], (P('z:/'),))
-        self.assertEqual(par[::2], (P('z:/a'),))
-        self.assertEqual(par[::-1], (P('z:/'), P('z:/a'),))
-        self.assertEqual(list(par), [P('z:/a'), P('z:/')])
-        with self.assertRaises(IndexError):
-            par[2]
-        p = P('//a/b/c/d')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('//a/b/c'))
-        self.assertEqual(par[1], P('//a/b'))
-        self.assertEqual(par[0:1], (P('//a/b/c'),))
-        self.assertEqual(par[0:-1], (P('//a/b/c'),))
-        self.assertEqual(par[:2], (P('//a/b/c'), P('//a/b')))
-        self.assertEqual(par[1:], (P('//a/b'),))
-        self.assertEqual(par[::2], (P('//a/b/c'),))
-        self.assertEqual(par[::-1], (P('//a/b'), P('//a/b/c')))
-        self.assertEqual(list(par), [P('//a/b/c'), P('//a/b')])
-        with self.assertRaises(IndexError):
-            par[2]
-
-    def test_drive(self):
-        P = self.cls
-        self.assertEqual(P('c:').drive, 'c:')
-        self.assertEqual(P('c:a/b').drive, 'c:')
-        self.assertEqual(P('c:/').drive, 'c:')
-        self.assertEqual(P('c:/a/b/').drive, 'c:')
-        self.assertEqual(P('//a/b').drive, '\\\\a\\b')
-        self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
-        self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
-        self.assertEqual(P('./c:a').drive, '')
-
-    def test_root(self):
-        P = self.cls
-        self.assertEqual(P('c:').root, '')
-        self.assertEqual(P('c:a/b').root, '')
-        self.assertEqual(P('c:/').root, '\\')
-        self.assertEqual(P('c:/a/b/').root, '\\')
-        self.assertEqual(P('//a/b').root, '\\')
-        self.assertEqual(P('//a/b/').root, '\\')
-        self.assertEqual(P('//a/b/c/d').root, '\\')
-
-    def test_anchor(self):
-        P = self.cls
-        self.assertEqual(P('c:').anchor, 'c:')
-        self.assertEqual(P('c:a/b').anchor, 'c:')
-        self.assertEqual(P('c:/').anchor, 'c:\\')
-        self.assertEqual(P('c:/a/b/').anchor, 'c:\\')
-        self.assertEqual(P('//a/b').anchor, '\\\\a\\b\\')
-        self.assertEqual(P('//a/b/').anchor, '\\\\a\\b\\')
-        self.assertEqual(P('//a/b/c/d').anchor, '\\\\a\\b\\')
-
-    def test_name(self):
-        P = self.cls
-        self.assertEqual(P('c:').name, '')
-        self.assertEqual(P('c:/').name, '')
-        self.assertEqual(P('c:a/b').name, 'b')
-        self.assertEqual(P('c:/a/b').name, 'b')
-        self.assertEqual(P('c:a/b.py').name, 'b.py')
-        self.assertEqual(P('c:/a/b.py').name, 'b.py')
-        self.assertEqual(P('//My.py/Share.php').name, '')
-        self.assertEqual(P('//My.py/Share.php/a/b').name, 'b')
-
-    def test_suffix(self):
-        P = self.cls
-        self.assertEqual(P('c:').suffix, '')
-        self.assertEqual(P('c:/').suffix, '')
-        self.assertEqual(P('c:a/b').suffix, '')
-        self.assertEqual(P('c:/a/b').suffix, '')
-        self.assertEqual(P('c:a/b.py').suffix, '.py')
-        self.assertEqual(P('c:/a/b.py').suffix, '.py')
-        self.assertEqual(P('c:a/.hgrc').suffix, '')
-        self.assertEqual(P('c:/a/.hgrc').suffix, '')
-        self.assertEqual(P('c:a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('c:/a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('c:a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('c:/a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('//My.py/Share.php').suffix, '')
-        self.assertEqual(P('//My.py/Share.php/a/b').suffix, '')
-
-    def test_suffixes(self):
-        P = self.cls
-        self.assertEqual(P('c:').suffixes, [])
-        self.assertEqual(P('c:/').suffixes, [])
-        self.assertEqual(P('c:a/b').suffixes, [])
-        self.assertEqual(P('c:/a/b').suffixes, [])
-        self.assertEqual(P('c:a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('c:/a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('c:a/.hgrc').suffixes, [])
-        self.assertEqual(P('c:/a/.hgrc').suffixes, [])
-        self.assertEqual(P('c:a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('c:/a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('c:a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('c:/a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('//My.py/Share.php').suffixes, [])
-        self.assertEqual(P('//My.py/Share.php/a/b').suffixes, [])
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffixes, [])
-        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffixes, [])
-
-    def test_stem(self):
-        P = self.cls
-        self.assertEqual(P('c:').stem, '')
-        self.assertEqual(P('c:.').stem, '')
-        self.assertEqual(P('c:..').stem, '..')
-        self.assertEqual(P('c:/').stem, '')
-        self.assertEqual(P('c:a/b').stem, 'b')
-        self.assertEqual(P('c:a/b.py').stem, 'b')
-        self.assertEqual(P('c:a/.hgrc').stem, '.hgrc')
-        self.assertEqual(P('c:a/.hg.rc').stem, '.hg')
-        self.assertEqual(P('c:a/b.tar.gz').stem, 'b.tar')
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').stem,
-                         'Some name. Ending with a dot.')
-
-    def test_with_name(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_name('d.xml'), P('c:a/d.xml'))
-        self.assertEqual(P('c:/a/b').with_name('d.xml'), P('c:/a/d.xml'))
-        self.assertEqual(P('c:a/Dot ending.').with_name('d.xml'), P('c:a/d.xml'))
-        self.assertEqual(P('c:/a/Dot ending.').with_name('d.xml'), P('c:/a/d.xml'))
-        self.assertRaises(ValueError, P('c:').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('c:/').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('//My/Share').with_name, 'd.xml')
-        self.assertEqual(str(P('a').with_name('d:')), '.\\d:')
-        self.assertEqual(str(P('a').with_name('d:e')), '.\\d:e')
-        self.assertEqual(P('c:a/b').with_name('d:'), P('c:a/d:'))
-        self.assertEqual(P('c:a/b').with_name('d:e'), P('c:a/d:e'))
-        self.assertRaises(ValueError, P('c:a/b').with_name, 'd:/e')
-        self.assertRaises(ValueError, P('c:a/b').with_name, '//My/Share')
-
-    def test_with_stem(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_stem('d'), P('c:a/d'))
-        self.assertEqual(P('c:/a/b').with_stem('d'), P('c:/a/d'))
-        self.assertEqual(P('c:a/Dot ending.').with_stem('d'), P('c:a/d'))
-        self.assertEqual(P('c:/a/Dot ending.').with_stem('d'), P('c:/a/d'))
-        self.assertRaises(ValueError, P('c:').with_stem, 'd')
-        self.assertRaises(ValueError, P('c:/').with_stem, 'd')
-        self.assertRaises(ValueError, P('//My/Share').with_stem, 'd')
-        self.assertEqual(str(P('a').with_stem('d:')), '.\\d:')
-        self.assertEqual(str(P('a').with_stem('d:e')), '.\\d:e')
-        self.assertEqual(P('c:a/b').with_stem('d:'), P('c:a/d:'))
-        self.assertEqual(P('c:a/b').with_stem('d:e'), P('c:a/d:e'))
-        self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:/e')
-        self.assertRaises(ValueError, P('c:a/b').with_stem, '//My/Share')
-
-    def test_with_suffix(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_suffix('.gz'), P('c:a/b.gz'))
-        self.assertEqual(P('c:/a/b').with_suffix('.gz'), P('c:/a/b.gz'))
-        self.assertEqual(P('c:a/b.py').with_suffix('.gz'), P('c:a/b.gz'))
-        self.assertEqual(P('c:/a/b.py').with_suffix('.gz'), P('c:/a/b.gz'))
-        # Path doesn't have a "filename" component.
-        self.assertRaises(ValueError, P('').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('//My/Share').with_suffix, '.gz')
-        # Invalid suffix.
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c/d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c\\d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c/d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c\\d')
-
-    def test_relative_to(self):
-        P = self.cls
-        p = P('C:Foo/Bar')
-        self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO'), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:foO/baR')), P())
-        self.assertEqual(p.relative_to('c:foO/baR'), P())
-        self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
-        self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
-        self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P())
-        self.assertRaises(ValueError, p.relative_to, '')
-        self.assertRaises(ValueError, p.relative_to, P('d:'))
-        self.assertRaises(ValueError, p.relative_to, P('/'))
-        self.assertRaises(ValueError, p.relative_to, P('Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
-        p = P('C:/Foo/Bar')
-        self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
-        self.assertEqual(p.relative_to('c:/foO/baR'), P())
-        self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
-        self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
-        self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
-        self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, 'c:')
-        self.assertRaises(ValueError, p.relative_to, P('c:'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('d:'))
-        self.assertRaises(ValueError, p.relative_to, P('d:/'))
-        self.assertRaises(ValueError, p.relative_to, P('/'))
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
-        self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
-        # UNC paths.
-        p = P('//Server/Share/Foo/Bar')
-        self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
-        self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
-
-    def test_is_relative_to(self):
-        P = self.cls
-        p = P('C:Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('c:')))
-        self.assertTrue(p.is_relative_to('c:'))
-        self.assertTrue(p.is_relative_to(P('c:foO')))
-        self.assertTrue(p.is_relative_to('c:foO'))
-        self.assertTrue(p.is_relative_to('c:foO/'))
-        self.assertTrue(p.is_relative_to(P('c:foO/baR')))
-        self.assertTrue(p.is_relative_to('c:foO/baR'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P()))
-        self.assertFalse(p.is_relative_to(''))
-        self.assertFalse(p.is_relative_to(P('d:')))
-        self.assertFalse(p.is_relative_to(P('/')))
-        self.assertFalse(p.is_relative_to(P('Foo')))
-        self.assertFalse(p.is_relative_to(P('/Foo')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo')))
-        self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
-        p = P('C:/Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('c:/')))
-        self.assertTrue(p.is_relative_to(P('c:/foO')))
-        self.assertTrue(p.is_relative_to('c:/foO/'))
-        self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
-        self.assertTrue(p.is_relative_to('c:/foO/baR'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to('c:'))
-        self.assertFalse(p.is_relative_to(P('C:/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:Foo')))
-        self.assertFalse(p.is_relative_to(P('d:')))
-        self.assertFalse(p.is_relative_to(P('d:/')))
-        self.assertFalse(p.is_relative_to(P('/')))
-        self.assertFalse(p.is_relative_to(P('/Foo')))
-        self.assertFalse(p.is_relative_to(P('//C/Foo')))
-        # UNC paths.
-        p = P('//Server/Share/Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare'))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/'))
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
-
-    def test_is_absolute(self):
-        P = self.cls
-        # Under NT, only paths with both a drive and a root are absolute.
-        self.assertFalse(P().is_absolute())
-        self.assertFalse(P('a').is_absolute())
-        self.assertFalse(P('a/b/').is_absolute())
-        self.assertFalse(P('/').is_absolute())
-        self.assertFalse(P('/a').is_absolute())
-        self.assertFalse(P('/a/b/').is_absolute())
-        self.assertFalse(P('c:').is_absolute())
-        self.assertFalse(P('c:a').is_absolute())
-        self.assertFalse(P('c:a/b/').is_absolute())
-        self.assertTrue(P('c:/').is_absolute())
-        self.assertTrue(P('c:/a').is_absolute())
-        self.assertTrue(P('c:/a/b/').is_absolute())
-        # UNC paths are absolute by definition.
-        self.assertTrue(P('//a/b').is_absolute())
-        self.assertTrue(P('//a/b/').is_absolute())
-        self.assertTrue(P('//a/b/c').is_absolute())
-        self.assertTrue(P('//a/b/c/d').is_absolute())
-
-    def test_join(self):
-        P = self.cls
-        p = P('C:/a/b')
-        pp = p.joinpath('x/y')
-        self.assertEqual(pp, P('C:/a/b/x/y'))
-        pp = p.joinpath('/x/y')
-        self.assertEqual(pp, P('C:/x/y'))
-        # Joining with a different drive => the first path is ignored, even
-        # if the second path is relative.
-        pp = p.joinpath('D:x/y')
-        self.assertEqual(pp, P('D:x/y'))
-        pp = p.joinpath('D:/x/y')
-        self.assertEqual(pp, P('D:/x/y'))
-        pp = p.joinpath('//host/share/x/y')
-        self.assertEqual(pp, P('//host/share/x/y'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        pp = p.joinpath('c:x/y')
-        self.assertEqual(pp, P('C:/a/b/x/y'))
-        pp = p.joinpath('c:/x/y')
-        self.assertEqual(pp, P('C:/x/y'))
-        # Joining with files with NTFS data streams => the filename should
-        # not be parsed as a drive letter
-        pp = p.joinpath(P('./d:s'))
-        self.assertEqual(pp, P('C:/a/b/d:s'))
-        pp = p.joinpath(P('./dd:s'))
-        self.assertEqual(pp, P('C:/a/b/dd:s'))
-        pp = p.joinpath(P('E:d:s'))
-        self.assertEqual(pp, P('E:d:s'))
-        # Joining onto a UNC path with no root
-        pp = P('//').joinpath('server')
-        self.assertEqual(pp, P('//server'))
-        pp = P('//server').joinpath('share')
-        self.assertEqual(pp, P('//server/share'))
-        pp = P('//./BootPartition').joinpath('Windows')
-        self.assertEqual(pp, P('//./BootPartition/Windows'))
-
-    def test_div(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('C:/a/b')
-        self.assertEqual(p / 'x/y', P('C:/a/b/x/y'))
-        self.assertEqual(p / 'x' / 'y', P('C:/a/b/x/y'))
-        self.assertEqual(p / '/x/y', P('C:/x/y'))
-        self.assertEqual(p / '/x' / 'y', P('C:/x/y'))
-        # Joining with a different drive => the first path is ignored, even
-        # if the second path is relative.
-        self.assertEqual(p / 'D:x/y', P('D:x/y'))
-        self.assertEqual(p / 'D:' / 'x/y', P('D:x/y'))
-        self.assertEqual(p / 'D:/x/y', P('D:/x/y'))
-        self.assertEqual(p / 'D:' / '/x/y', P('D:/x/y'))
-        self.assertEqual(p / '//host/share/x/y', P('//host/share/x/y'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        self.assertEqual(p / 'c:x/y', P('C:/a/b/x/y'))
-        self.assertEqual(p / 'c:/x/y', P('C:/x/y'))
-        # Joining with files with NTFS data streams => the filename should
-        # not be parsed as a drive letter
-        self.assertEqual(p / P('./d:s'), P('C:/a/b/d:s'))
-        self.assertEqual(p / P('./dd:s'), P('C:/a/b/dd:s'))
-        self.assertEqual(p / P('E:d:s'), P('E:d:s'))
-
-    def test_is_reserved(self):
-        P = self.cls
-        self.assertIs(False, P('').is_reserved())
-        self.assertIs(False, P('/').is_reserved())
-        self.assertIs(False, P('/foo/bar').is_reserved())
-        # UNC paths are never reserved.
-        self.assertIs(False, P('//my/share/nul/con/aux').is_reserved())
-        # Case-insensitive DOS-device names are reserved.
-        self.assertIs(True, P('nul').is_reserved())
-        self.assertIs(True, P('aux').is_reserved())
-        self.assertIs(True, P('prn').is_reserved())
-        self.assertIs(True, P('con').is_reserved())
-        self.assertIs(True, P('conin$').is_reserved())
-        self.assertIs(True, P('conout$').is_reserved())
-        # COM/LPT + 1-9 or + superscript 1-3 are reserved.
-        self.assertIs(True, P('COM1').is_reserved())
-        self.assertIs(True, P('LPT9').is_reserved())
-        self.assertIs(True, P('com\xb9').is_reserved())
-        self.assertIs(True, P('com\xb2').is_reserved())
-        self.assertIs(True, P('lpt\xb3').is_reserved())
-        # DOS-device name mataching ignores characters after a dot or
-        # a colon and also ignores trailing spaces.
-        self.assertIs(True, P('NUL.txt').is_reserved())
-        self.assertIs(True, P('PRN  ').is_reserved())
-        self.assertIs(True, P('AUX  .txt').is_reserved())
-        self.assertIs(True, P('COM1:bar').is_reserved())
-        self.assertIs(True, P('LPT9   :bar').is_reserved())
-        # DOS-device names are only matched at the beginning
-        # of a path component.
-        self.assertIs(False, P('bar.com9').is_reserved())
-        self.assertIs(False, P('bar.lpt9').is_reserved())
-        # Only the last path component matters.
-        self.assertIs(True, P('c:/baz/con/NUL').is_reserved())
-        self.assertIs(False, P('c:/NUL/con/baz').is_reserved())
-
-class PurePathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PurePath
-
-    def test_concrete_class(self):
-        p = self.cls('a')
-        self.assertIs(type(p),
-            pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath)
-
-    def test_different_flavours_unequal(self):
-        p = pathlib.PurePosixPath('a')
-        q = pathlib.PureWindowsPath('a')
-        self.assertNotEqual(p, q)
-
-    def test_different_flavours_unordered(self):
-        p = pathlib.PurePosixPath('a')
-        q = pathlib.PureWindowsPath('a')
-        with self.assertRaises(TypeError):
-            p < q
-        with self.assertRaises(TypeError):
-            p <= q
-        with self.assertRaises(TypeError):
-            p > q
-        with self.assertRaises(TypeError):
-            p >= q
-
-
-#
-# Tests for the concrete classes.
-#
-
-# Make sure any symbolic links in the base test path are resolved.
-BASE = os.path.realpath(TESTFN)
-join = lambda *x: os.path.join(BASE, *x)
-rel_join = lambda *x: os.path.join(TESTFN, *x)
-
-only_nt = unittest.skipIf(os.name != 'nt',
-                          'test requires a Windows-compatible system')
-only_posix = unittest.skipIf(os.name == 'nt',
-                             'test requires a POSIX-compatible system')
-
-@only_posix
-class PosixPathAsPureTest(PurePosixPathTest):
-    cls = pathlib.PosixPath
-
-@only_nt
-class WindowsPathAsPureTest(PureWindowsPathTest):
-    cls = pathlib.WindowsPath
-
-    def test_owner(self):
-        P = self.cls
-        with self.assertRaises(NotImplementedError):
-            P('c:/').owner()
-
-    def test_group(self):
-        P = self.cls
-        with self.assertRaises(NotImplementedError):
-            P('c:/').group()
-
-
-class _BasePathTest(object):
-    """Tests for the FS-accessing functionalities of the Path classes."""
-
-    # (BASE)
-    #  |
-    #  |-- brokenLink -> non-existing
-    #  |-- dirA
-    #  |   `-- linkC -> ../dirB
-    #  |-- dirB
-    #  |   |-- fileB
-    #  |   `-- linkD -> ../dirB
-    #  |-- dirC
-    #  |   |-- dirD
-    #  |   |   `-- fileD
-    #  |   `-- fileC
-    #  |   `-- novel.txt
-    #  |-- dirE  # No permissions
-    #  |-- fileA
-    #  |-- linkA -> fileA
-    #  |-- linkB -> dirB
-    #  `-- brokenLinkLoop -> brokenLinkLoop
-    #
-
-    def setUp(self):
-        def cleanup():
-            os.chmod(join('dirE'), 0o777)
-            os_helper.rmtree(BASE)
-        self.addCleanup(cleanup)
-        os.mkdir(BASE)
-        os.mkdir(join('dirA'))
-        os.mkdir(join('dirB'))
-        os.mkdir(join('dirC'))
-        os.mkdir(join('dirC', 'dirD'))
-        os.mkdir(join('dirE'))
-        with open(join('fileA'), 'wb') as f:
-            f.write(b"this is file A\n")
-        with open(join('dirB', 'fileB'), 'wb') as f:
-            f.write(b"this is file B\n")
-        with open(join('dirC', 'fileC'), 'wb') as f:
-            f.write(b"this is file C\n")
-        with open(join('dirC', 'novel.txt'), 'wb') as f:
-            f.write(b"this is a novel\n")
-        with open(join('dirC', 'dirD', 'fileD'), 'wb') as f:
-            f.write(b"this is file D\n")
-        os.chmod(join('dirE'), 0)
-        if os_helper.can_symlink():
-            # Relative symlinks.
-            os.symlink('fileA', join('linkA'))
-            os.symlink('non-existing', join('brokenLink'))
-            self.dirlink('dirB', join('linkB'))
-            self.dirlink(os.path.join('..', 'dirB'), join('dirA', 'linkC'))
-            # This one goes upwards, creating a loop.
-            self.dirlink(os.path.join('..', 'dirB'), join('dirB', 'linkD'))
-            # Broken symlink (pointing to itself).
-            os.symlink('brokenLinkLoop',  join('brokenLinkLoop'))
-
-    if os.name == 'nt':
-        # Workaround for http://bugs.python.org/issue13772.
-        def dirlink(self, src, dest):
-            os.symlink(src, dest, target_is_directory=True)
-    else:
-        def dirlink(self, src, dest):
-            os.symlink(src, dest)
-
-    def assertSame(self, path_a, path_b):
-        self.assertTrue(os.path.samefile(str(path_a), str(path_b)),
-                        "%r and %r don't point to the same file" %
-                        (path_a, path_b))
-
-    def assertFileNotFound(self, func, *args, **kwargs):
-        with self.assertRaises(FileNotFoundError) as cm:
-            func(*args, **kwargs)
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-
-    def assertEqualNormCase(self, path_a, path_b):
-        self.assertEqual(os.path.normcase(path_a), os.path.normcase(path_b))
-
-    def _test_cwd(self, p):
-        q = self.cls(os.getcwd())
-        self.assertEqual(p, q)
-        self.assertEqualNormCase(str(p), str(q))
-        self.assertIs(type(p), type(q))
-        self.assertTrue(p.is_absolute())
-
-    def test_cwd(self):
-        p = self.cls.cwd()
-        self._test_cwd(p)
-
-    def test_absolute_common(self):
-        P = self.cls
-
-        with mock.patch("os.getcwd") as getcwd:
-            getcwd.return_value = BASE
-
-            # Simple relative paths.
-            self.assertEqual(str(P().absolute()), BASE)
-            self.assertEqual(str(P('.').absolute()), BASE)
-            self.assertEqual(str(P('a').absolute()), os.path.join(BASE, 'a'))
-            self.assertEqual(str(P('a', 'b', 'c').absolute()), os.path.join(BASE, 'a', 'b', 'c'))
-
-            # Symlinks should not be resolved.
-            self.assertEqual(str(P('linkB', 'fileB').absolute()), os.path.join(BASE, 'linkB', 'fileB'))
-            self.assertEqual(str(P('brokenLink').absolute()), os.path.join(BASE, 'brokenLink'))
-            self.assertEqual(str(P('brokenLinkLoop').absolute()), os.path.join(BASE, 'brokenLinkLoop'))
-
-            # '..' entries should be preserved and not normalised.
-            self.assertEqual(str(P('..').absolute()), os.path.join(BASE, '..'))
-            self.assertEqual(str(P('a', '..').absolute()), os.path.join(BASE, 'a', '..'))
-            self.assertEqual(str(P('..', 'b').absolute()), os.path.join(BASE, '..', 'b'))
-
-    def _test_home(self, p):
-        q = self.cls(os.path.expanduser('~'))
-        self.assertEqual(p, q)
-        self.assertEqualNormCase(str(p), str(q))
-        self.assertIs(type(p), type(q))
-        self.assertTrue(p.is_absolute())
-
-    @unittest.skipIf(
-        pwd is None, reason="Test requires pwd module to get homedir."
-    )
-    def test_home(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            self._test_home(self.cls.home())
-
-            env.clear()
-            env['USERPROFILE'] = os.path.join(BASE, 'userprofile')
-            self._test_home(self.cls.home())
-
-            # bpo-38883: ignore `HOME` when set on windows
-            env['HOME'] = os.path.join(BASE, 'home')
-            self._test_home(self.cls.home())
-
-    @unittest.skip("TODO: RUSTPYTHON; PyObject::set_slot index out of bounds")
-    def test_with_segments(self):
-        class P(_BasePurePathSubclass, self.cls):
-            pass
-        p = P(BASE, session_id=42)
-        self.assertEqual(42, p.absolute().session_id)
-        self.assertEqual(42, p.resolve().session_id)
-        if not is_wasi:  # WASI has no user accounts.
-            self.assertEqual(42, p.with_segments('~').expanduser().session_id)
-        self.assertEqual(42, (p / 'fileA').rename(p / 'fileB').session_id)
-        self.assertEqual(42, (p / 'fileB').replace(p / 'fileA').session_id)
-        if os_helper.can_symlink():
-            self.assertEqual(42, (p / 'linkA').readlink().session_id)
-        for path in p.iterdir():
-            self.assertEqual(42, path.session_id)
-        for path in p.glob('*'):
-            self.assertEqual(42, path.session_id)
-        for path in p.rglob('*'):
-            self.assertEqual(42, path.session_id)
-        for dirpath, dirnames, filenames in p.walk():
-            self.assertEqual(42, dirpath.session_id)
-
-    def test_samefile(self):
-        fileA_path = os.path.join(BASE, 'fileA')
-        fileB_path = os.path.join(BASE, 'dirB', 'fileB')
-        p = self.cls(fileA_path)
-        pp = self.cls(fileA_path)
-        q = self.cls(fileB_path)
-        self.assertTrue(p.samefile(fileA_path))
-        self.assertTrue(p.samefile(pp))
-        self.assertFalse(p.samefile(fileB_path))
-        self.assertFalse(p.samefile(q))
-        # Test the non-existent file case
-        non_existent = os.path.join(BASE, 'foo')
-        r = self.cls(non_existent)
-        self.assertRaises(FileNotFoundError, p.samefile, r)
-        self.assertRaises(FileNotFoundError, p.samefile, non_existent)
-        self.assertRaises(FileNotFoundError, r.samefile, p)
-        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
-        self.assertRaises(FileNotFoundError, r.samefile, r)
-        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
-
-    def test_empty_path(self):
-        # The empty path points to '.'
-        p = self.cls('')
-        self.assertEqual(p.stat(), os.stat('.'))
-
-    @unittest.skipIf(is_wasi, "WASI has no user accounts.")
-    def test_expanduser_common(self):
-        P = self.cls
-        p = P('~')
-        self.assertEqual(p.expanduser(), P(os.path.expanduser('~')))
-        p = P('foo')
-        self.assertEqual(p.expanduser(), p)
-        p = P('/~')
-        self.assertEqual(p.expanduser(), p)
-        p = P('../~')
-        self.assertEqual(p.expanduser(), p)
-        p = P(P('').absolute().anchor) / '~'
-        self.assertEqual(p.expanduser(), p)
-        p = P('~/a:b')
-        self.assertEqual(p.expanduser(), P(os.path.expanduser('~'), './a:b'))
-
-    def test_exists(self):
-        P = self.cls
-        p = P(BASE)
-        self.assertIs(True, p.exists())
-        self.assertIs(True, (p / 'dirA').exists())
-        self.assertIs(True, (p / 'fileA').exists())
-        self.assertIs(False, (p / 'fileA' / 'bah').exists())
-        if os_helper.can_symlink():
-            self.assertIs(True, (p / 'linkA').exists())
-            self.assertIs(True, (p / 'linkB').exists())
-            self.assertIs(True, (p / 'linkB' / 'fileB').exists())
-            self.assertIs(False, (p / 'linkA' / 'bah').exists())
-            self.assertIs(False, (p / 'brokenLink').exists())
-            self.assertIs(True, (p / 'brokenLink').exists(follow_symlinks=False))
-        self.assertIs(False, (p / 'foo').exists())
-        self.assertIs(False, P('/xyzzy').exists())
-        self.assertIs(False, P(BASE + '\udfff').exists())
-        self.assertIs(False, P(BASE + '\x00').exists())
-
-    def test_open_common(self):
-        p = self.cls(BASE)
-        with (p / 'fileA').open('r') as f:
-            self.assertIsInstance(f, io.TextIOBase)
-            self.assertEqual(f.read(), "this is file A\n")
-        with (p / 'fileA').open('rb') as f:
-            self.assertIsInstance(f, io.BufferedIOBase)
-            self.assertEqual(f.read().strip(), b"this is file A")
-        with (p / 'fileA').open('rb', buffering=0) as f:
-            self.assertIsInstance(f, io.RawIOBase)
-            self.assertEqual(f.read().strip(), b"this is file A")
-
-    def test_read_write_bytes(self):
-        p = self.cls(BASE)
-        (p / 'fileA').write_bytes(b'abcdefg')
-        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
-        # Check that trying to write str does not truncate the file.
-        self.assertRaises(TypeError, (p / 'fileA').write_bytes, 'somestr')
-        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
-
-    def test_read_write_text(self):
-        p = self.cls(BASE)
-        (p / 'fileA').write_text('äbcdefg', encoding='latin-1')
-        self.assertEqual((p / 'fileA').read_text(
-            encoding='utf-8', errors='ignore'), 'bcdefg')
-        # Check that trying to write bytes does not truncate the file.
-        self.assertRaises(TypeError, (p / 'fileA').write_text, b'somebytes')
-        self.assertEqual((p / 'fileA').read_text(encoding='latin-1'), 'äbcdefg')
-
-    def test_write_text_with_newlines(self):
-        p = self.cls(BASE)
-        # Check that `\n` character change nothing
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\n')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\nfghlk\n\rmnopq')
-        # Check that `\r` character replaces `\n`
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\rfghlk\r\rmnopq')
-        # Check that `\r\n` character replaces `\n`
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r\n')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\r\nfghlk\r\n\rmnopq')
-        # Check that no argument passed will change `\n` to `os.linesep`
-        os_linesep_byte = bytes(os.linesep, encoding='ascii')
-        (p / 'fileA').write_text('abcde\nfghlk\n\rmnopq')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                          b'abcde' + os_linesep_byte + b'fghlk' + os_linesep_byte + b'\rmnopq')
-
-    def test_iterdir(self):
-        P = self.cls
-        p = P(BASE)
-        it = p.iterdir()
-        paths = set(it)
-        expected = ['dirA', 'dirB', 'dirC', 'dirE', 'fileA']
-        if os_helper.can_symlink():
-            expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
-        self.assertEqual(paths, { P(BASE, q) for q in expected })
-
-    @os_helper.skip_unless_symlink
-    def test_iterdir_symlink(self):
-        # __iter__ on a symlink to a directory.
-        P = self.cls
-        p = P(BASE, 'linkB')
-        paths = set(p.iterdir())
-        expected = { P(BASE, 'linkB', q) for q in ['fileB', 'linkD'] }
-        self.assertEqual(paths, expected)
-
-    def test_iterdir_nodir(self):
-        # __iter__ on something that is not a directory.
-        p = self.cls(BASE, 'fileA')
-        with self.assertRaises(OSError) as cm:
-            next(p.iterdir())
-        # ENOENT or EINVAL under Windows, ENOTDIR otherwise
-        # (see issue #12802).
-        self.assertIn(cm.exception.errno, (errno.ENOTDIR,
-                                           errno.ENOENT, errno.EINVAL))
-
-    def test_glob_common(self):
-        def _check(glob, expected):
-            self.assertEqual(set(glob), { P(BASE, q) for q in expected })
-        P = self.cls
-        p = P(BASE)
-        it = p.glob("fileA")
-        self.assertIsInstance(it, collections.abc.Iterator)
-        _check(it, ["fileA"])
-        _check(p.glob("fileB"), [])
-        _check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
-        if not os_helper.can_symlink():
-            _check(p.glob("*A"), ['dirA', 'fileA'])
-        else:
-            _check(p.glob("*A"), ['dirA', 'fileA', 'linkA'])
-        if not os_helper.can_symlink():
-            _check(p.glob("*B/*"), ['dirB/fileB'])
-        else:
-            _check(p.glob("*B/*"), ['dirB/fileB', 'dirB/linkD',
-                                    'linkB/fileB', 'linkB/linkD'])
-        if not os_helper.can_symlink():
-            _check(p.glob("*/fileB"), ['dirB/fileB'])
-        else:
-            _check(p.glob("*/fileB"), ['dirB/fileB', 'linkB/fileB'])
-        if os_helper.can_symlink():
-            _check(p.glob("brokenLink"), ['brokenLink'])
-
-        if not os_helper.can_symlink():
-            _check(p.glob("*/"), ["dirA", "dirB", "dirC", "dirE"])
-        else:
-            _check(p.glob("*/"), ["dirA", "dirB", "dirC", "dirE", "linkB"])
-
-    def test_glob_case_sensitive(self):
-        P = self.cls
-        def _check(path, pattern, case_sensitive, expected):
-            actual = {str(q) for q in path.glob(pattern, case_sensitive=case_sensitive)}
-            expected = {str(P(BASE, q)) for q in expected}
-            self.assertEqual(actual, expected)
-        path = P(BASE)
-        _check(path, "DIRB/FILE*", True, [])
-        _check(path, "DIRB/FILE*", False, ["dirB/fileB"])
-        _check(path, "dirb/file*", True, [])
-        _check(path, "dirb/file*", False, ["dirB/fileB"])
-
-    def test_rglob_common(self):
-        def _check(glob, expected):
-            self.assertEqual(sorted(glob), sorted(P(BASE, q) for q in expected))
-        P = self.cls
-        p = P(BASE)
-        it = p.rglob("fileA")
-        self.assertIsInstance(it, collections.abc.Iterator)
-        _check(it, ["fileA"])
-        _check(p.rglob("fileB"), ["dirB/fileB"])
-        _check(p.rglob("**/fileB"), ["dirB/fileB"])
-        _check(p.rglob("*/fileA"), [])
-        if not os_helper.can_symlink():
-            _check(p.rglob("*/fileB"), ["dirB/fileB"])
-        else:
-            _check(p.rglob("*/fileB"), ["dirB/fileB", "dirB/linkD/fileB",
-                                        "linkB/fileB", "dirA/linkC/fileB"])
-        _check(p.rglob("file*"), ["fileA", "dirB/fileB",
-                                  "dirC/fileC", "dirC/dirD/fileD"])
-        if not os_helper.can_symlink():
-            _check(p.rglob("*/"), [
-                "dirA", "dirB", "dirC", "dirC/dirD", "dirE",
-            ])
-        else:
-            _check(p.rglob("*/"), [
-                "dirA", "dirA/linkC", "dirB", "dirB/linkD", "dirC",
-                "dirC/dirD", "dirE", "linkB",
-            ])
-        _check(p.rglob(""), ["", "dirA", "dirB", "dirC", "dirE", "dirC/dirD"])
-
-        p = P(BASE, "dirC")
-        _check(p.rglob("*"), ["dirC/fileC", "dirC/novel.txt",
-                              "dirC/dirD", "dirC/dirD/fileD"])
-        _check(p.rglob("file*"), ["dirC/fileC", "dirC/dirD/fileD"])
-        _check(p.rglob("**/file*"), ["dirC/fileC", "dirC/dirD/fileD"])
-        _check(p.rglob("dir*/**"), ["dirC/dirD"])
-        _check(p.rglob("*/*"), ["dirC/dirD/fileD"])
-        _check(p.rglob("*/"), ["dirC/dirD"])
-        _check(p.rglob(""), ["dirC", "dirC/dirD"])
-        _check(p.rglob("**"), ["dirC", "dirC/dirD"])
-        # gh-91616, a re module regression
-        _check(p.rglob("*.txt"), ["dirC/novel.txt"])
-        _check(p.rglob("*.*"), ["dirC/novel.txt"])
-
-    @os_helper.skip_unless_symlink
-    def test_rglob_symlink_loop(self):
-        # Don't get fooled by symlink loops (Issue #26012).
-        P = self.cls
-        p = P(BASE)
-        given = set(p.rglob('*'))
-        expect = {'brokenLink',
-                  'dirA', 'dirA/linkC',
-                  'dirB', 'dirB/fileB', 'dirB/linkD',
-                  'dirC', 'dirC/dirD', 'dirC/dirD/fileD',
-                  'dirC/fileC', 'dirC/novel.txt',
-                  'dirE',
-                  'fileA',
-                  'linkA',
-                  'linkB',
-                  'brokenLinkLoop',
-                  }
-        self.assertEqual(given, {p / x for x in expect})
-
-    def test_glob_many_open_files(self):
-        depth = 30
-        P = self.cls
-        base = P(BASE) / 'deep'
-        p = P(base, *(['d']*depth))
-        p.mkdir(parents=True)
-        pattern = '/'.join(['*'] * depth)
-        iters = [base.glob(pattern) for j in range(100)]
-        for it in iters:
-            self.assertEqual(next(it), p)
-        iters = [base.rglob('d') for j in range(100)]
-        p = base
-        for i in range(depth):
-            p = p / 'd'
-            for it in iters:
-                self.assertEqual(next(it), p)
-
-    def test_glob_dotdot(self):
-        # ".." is not special in globs.
-        P = self.cls
-        p = P(BASE)
-        self.assertEqual(set(p.glob("..")), { P(BASE, "..") })
-        self.assertEqual(set(p.glob("../..")), { P(BASE, "..", "..") })
-        self.assertEqual(set(p.glob("dirA/..")), { P(BASE, "dirA", "..") })
-        self.assertEqual(set(p.glob("dirA/../file*")), { P(BASE, "dirA/../fileA") })
-        self.assertEqual(set(p.glob("dirA/../file*/..")), set())
-        self.assertEqual(set(p.glob("../xyzzy")), set())
-        self.assertEqual(set(p.glob("xyzzy/..")), set())
-        self.assertEqual(set(p.glob("/".join([".."] * 50))), { P(BASE, *[".."] * 50)})
-
-    @os_helper.skip_unless_symlink
-    def test_glob_permissions(self):
-        # See bpo-38894
-        P = self.cls
-        base = P(BASE) / 'permissions'
-        base.mkdir()
-        self.addCleanup(os_helper.rmtree, base)
-
-        for i in range(100):
-            link = base / f"link{i}"
-            if i % 2:
-                link.symlink_to(P(BASE, "dirE", "nonexistent"))
-            else:
-                link.symlink_to(P(BASE, "dirC"))
-
-        self.assertEqual(len(set(base.glob("*"))), 100)
-        self.assertEqual(len(set(base.glob("*/"))), 50)
-        self.assertEqual(len(set(base.glob("*/fileC"))), 50)
-        self.assertEqual(len(set(base.glob("*/file*"))), 50)
-
-    @os_helper.skip_unless_symlink
-    def test_glob_long_symlink(self):
-        # See gh-87695
-        base = self.cls(BASE) / 'long_symlink'
-        base.mkdir()
-        bad_link = base / 'bad_link'
-        bad_link.symlink_to("bad" * 200)
-        self.assertEqual(sorted(base.glob('**/*')), [bad_link])
-
-    def test_glob_above_recursion_limit(self):
-        recursion_limit = 50
-        # directory_depth > recursion_limit
-        directory_depth = recursion_limit + 10
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d'] * directory_depth))
-        path.mkdir(parents=True)
-
-        with set_recursion_limit(recursion_limit):
-            list(base.glob('**'))
-
-    def _check_resolve(self, p, expected, strict=True):
-        q = p.resolve(strict)
-        self.assertEqual(q, expected)
-
-    # This can be used to check both relative and absolute resolutions.
-    _check_resolve_relative = _check_resolve_absolute = _check_resolve
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_common(self):
-        P = self.cls
-        p = P(BASE, 'foo')
-        with self.assertRaises(OSError) as cm:
-            p.resolve(strict=True)
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-        # Non-strict
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.join(BASE, 'foo'))
-        p = P(BASE, 'foo', 'in', 'spam')
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.join(BASE, 'foo', 'in', 'spam'))
-        p = P(BASE, '..', 'foo', 'in', 'spam')
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.abspath(os.path.join('foo', 'in', 'spam')))
-        # These are all relative symlinks.
-        p = P(BASE, 'dirB', 'fileB')
-        self._check_resolve_relative(p, p)
-        p = P(BASE, 'linkA')
-        self._check_resolve_relative(p, P(BASE, 'fileA'))
-        p = P(BASE, 'dirA', 'linkC', 'fileB')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
-        p = P(BASE, 'dirB', 'linkD', 'fileB')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
-        # Non-strict
-        p = P(BASE, 'dirA', 'linkC', 'fileB', 'foo', 'in', 'spam')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB', 'foo', 'in',
-                                          'spam'), False)
-        p = P(BASE, 'dirA', 'linkC', '..', 'foo', 'in', 'spam')
-        if os.name == 'nt':
-            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
-            # resolves to 'dirA' without resolving linkY first.
-            self._check_resolve_relative(p, P(BASE, 'dirA', 'foo', 'in',
-                                              'spam'), False)
-        else:
-            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
-            # resolves to 'dirB/..' first before resolving to parent of dirB.
-            self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
-        # Now create absolute symlinks.
-        d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
-                                                 dir=os.getcwd()))
-        self.addCleanup(os_helper.rmtree, d)
-        os.symlink(os.path.join(d), join('dirA', 'linkX'))
-        os.symlink(join('dirB'), os.path.join(d, 'linkY'))
-        p = P(BASE, 'dirA', 'linkX', 'linkY', 'fileB')
-        self._check_resolve_absolute(p, P(BASE, 'dirB', 'fileB'))
-        # Non-strict
-        p = P(BASE, 'dirA', 'linkX', 'linkY', 'foo', 'in', 'spam')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'foo', 'in', 'spam'),
-                                     False)
-        p = P(BASE, 'dirA', 'linkX', 'linkY', '..', 'foo', 'in', 'spam')
-        if os.name == 'nt':
-            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
-            # resolves to 'dirA' without resolving linkY first.
-            self._check_resolve_relative(p, P(d, 'foo', 'in', 'spam'), False)
-        else:
-            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
-            # resolves to 'dirB/..' first before resolving to parent of dirB.
-            self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_dot(self):
-        # See http://web.archive.org/web/20200623062557/https://bitbucket.org/pitrou/pathlib/issues/9/
-        p = self.cls(BASE)
-        self.dirlink('.', join('0'))
-        self.dirlink(os.path.join('0', '0'), join('1'))
-        self.dirlink(os.path.join('1', '1'), join('2'))
-        q = p / '2'
-        self.assertEqual(q.resolve(strict=True), p)
-        r = q / '3' / '4'
-        self.assertRaises(FileNotFoundError, r.resolve, strict=True)
-        # Non-strict
-        self.assertEqual(r.resolve(strict=False), p / '3' / '4')
-
-    def test_resolve_nonexist_relative_issue38671(self):
-        p = self.cls('non', 'exist')
-
-        old_cwd = os.getcwd()
-        os.chdir(BASE)
-        try:
-            self.assertEqual(p.resolve(), self.cls(BASE, p))
-        finally:
-            os.chdir(old_cwd)
-
-    def test_with(self):
-        p = self.cls(BASE)
-        it = p.iterdir()
-        it2 = p.iterdir()
-        next(it2)
-        # bpo-46556: path context managers are deprecated in Python 3.11.
-        with self.assertWarns(DeprecationWarning):
-            with p:
-                pass
-        # Using a path as a context manager is a no-op, thus the following
-        # operations should still succeed after the context manage exits.
-        next(it)
-        next(it2)
-        p.exists()
-        p.resolve()
-        p.absolute()
-        with self.assertWarns(DeprecationWarning):
-            with p:
-                pass
-
-    @os_helper.skip_unless_working_chmod
-    def test_chmod(self):
-        p = self.cls(BASE) / 'fileA'
-        mode = p.stat().st_mode
-        # Clear writable bit.
-        new_mode = mode & ~0o222
-        p.chmod(new_mode)
-        self.assertEqual(p.stat().st_mode, new_mode)
-        # Set writable bit.
-        new_mode = mode | 0o222
-        p.chmod(new_mode)
-        self.assertEqual(p.stat().st_mode, new_mode)
-
-    # On Windows, os.chmod does not follow symlinks (issue #15411)
-    @only_posix
-    @os_helper.skip_unless_working_chmod
-    def test_chmod_follow_symlinks_true(self):
-        p = self.cls(BASE) / 'linkA'
-        q = p.resolve()
-        mode = q.stat().st_mode
-        # Clear writable bit.
-        new_mode = mode & ~0o222
-        p.chmod(new_mode, follow_symlinks=True)
-        self.assertEqual(q.stat().st_mode, new_mode)
-        # Set writable bit
-        new_mode = mode | 0o222
-        p.chmod(new_mode, follow_symlinks=True)
-        self.assertEqual(q.stat().st_mode, new_mode)
-
-    # XXX also need a test for lchmod.
-
-    @os_helper.skip_unless_working_chmod
-    def test_stat(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(p.stat(), st)
-        # Change file mode by flipping write bit.
-        p.chmod(st.st_mode ^ 0o222)
-        self.addCleanup(p.chmod, st.st_mode)
-        self.assertNotEqual(p.stat(), st)
-
-    @os_helper.skip_unless_symlink
-    def test_stat_no_follow_symlinks(self):
-        p = self.cls(BASE) / 'linkA'
-        st = p.stat()
-        self.assertNotEqual(st, p.stat(follow_symlinks=False))
-
-    def test_stat_no_follow_symlinks_nosymlink(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(st, p.stat(follow_symlinks=False))
-
-    @os_helper.skip_unless_symlink
-    def test_lstat(self):
-        p = self.cls(BASE)/ 'linkA'
-        st = p.stat()
-        self.assertNotEqual(st, p.lstat())
-
-    def test_lstat_nosymlink(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(st, p.lstat())
-
-    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
-    def test_owner(self):
-        p = self.cls(BASE) / 'fileA'
-        uid = p.stat().st_uid
-        try:
-            name = pwd.getpwuid(uid).pw_name
-        except KeyError:
-            self.skipTest(
-                "user %d doesn't have an entry in the system database" % uid)
-        self.assertEqual(name, p.owner())
-
-    @unittest.skipUnless(grp, "the grp module is needed for this test")
-    def test_group(self):
-        p = self.cls(BASE) / 'fileA'
-        gid = p.stat().st_gid
-        try:
-            name = grp.getgrgid(gid).gr_name
-        except KeyError:
-            self.skipTest(
-                "group %d doesn't have an entry in the system database" % gid)
-        self.assertEqual(name, p.group())
-
-    def test_unlink(self):
-        p = self.cls(BASE) / 'fileA'
-        p.unlink()
-        self.assertFileNotFound(p.stat)
-        self.assertFileNotFound(p.unlink)
-
-    def test_unlink_missing_ok(self):
-        p = self.cls(BASE) / 'fileAAA'
-        self.assertFileNotFound(p.unlink)
-        p.unlink(missing_ok=True)
-
-    def test_rmdir(self):
-        p = self.cls(BASE) / 'dirA'
-        for q in p.iterdir():
-            q.unlink()
-        p.rmdir()
-        self.assertFileNotFound(p.stat)
-        self.assertFileNotFound(p.unlink)
-
-    @unittest.skipUnless(hasattr(os, "link"), "os.link() is not present")
-    def test_hardlink_to(self):
-        P = self.cls(BASE)
-        target = P / 'fileA'
-        size = target.stat().st_size
-        # linking to another path.
-        link = P / 'dirA' / 'fileAA'
-        link.hardlink_to(target)
-        self.assertEqual(link.stat().st_size, size)
-        self.assertTrue(os.path.samefile(target, link))
-        self.assertTrue(target.exists())
-        # Linking to a str of a relative path.
-        link2 = P / 'dirA' / 'fileAAA'
-        target2 = rel_join('fileA')
-        link2.hardlink_to(target2)
-        self.assertEqual(os.stat(target2).st_size, size)
-        self.assertTrue(link2.exists())
-
-    @unittest.skipIf(hasattr(os, "link"), "os.link() is present")
-    def test_link_to_not_implemented(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        # linking to another path.
-        q = P / 'dirA' / 'fileAA'
-        with self.assertRaises(NotImplementedError):
-            q.hardlink_to(p)
-
-    def test_rename(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        size = p.stat().st_size
-        # Renaming to another path.
-        q = P / 'dirA' / 'fileAA'
-        renamed_p = p.rename(q)
-        self.assertEqual(renamed_p, q)
-        self.assertEqual(q.stat().st_size, size)
-        self.assertFileNotFound(p.stat)
-        # Renaming to a str of a relative path.
-        r = rel_join('fileAAA')
-        renamed_q = q.rename(r)
-        self.assertEqual(renamed_q, self.cls(r))
-        self.assertEqual(os.stat(r).st_size, size)
-        self.assertFileNotFound(q.stat)
-
-    def test_replace(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        size = p.stat().st_size
-        # Replacing a non-existing path.
-        q = P / 'dirA' / 'fileAA'
-        replaced_p = p.replace(q)
-        self.assertEqual(replaced_p, q)
-        self.assertEqual(q.stat().st_size, size)
-        self.assertFileNotFound(p.stat)
-        # Replacing another (existing) path.
-        r = rel_join('dirB', 'fileB')
-        replaced_q = q.replace(r)
-        self.assertEqual(replaced_q, self.cls(r))
-        self.assertEqual(os.stat(r).st_size, size)
-        self.assertFileNotFound(q.stat)
-
-    @os_helper.skip_unless_symlink
-    def test_readlink(self):
-        P = self.cls(BASE)
-        self.assertEqual((P / 'linkA').readlink(), self.cls('fileA'))
-        self.assertEqual((P / 'brokenLink').readlink(),
-                         self.cls('non-existing'))
-        self.assertEqual((P / 'linkB').readlink(), self.cls('dirB'))
-        with self.assertRaises(OSError):
-            (P / 'fileA').readlink()
-
-    def test_touch_common(self):
-        P = self.cls(BASE)
-        p = P / 'newfileA'
-        self.assertFalse(p.exists())
-        p.touch()
-        self.assertTrue(p.exists())
-        st = p.stat()
-        old_mtime = st.st_mtime
-        old_mtime_ns = st.st_mtime_ns
-        # Rewind the mtime sufficiently far in the past to work around
-        # filesystem-specific timestamp granularity.
-        os.utime(str(p), (old_mtime - 10, old_mtime - 10))
-        # The file mtime should be refreshed by calling touch() again.
-        p.touch()
-        st = p.stat()
-        self.assertGreaterEqual(st.st_mtime_ns, old_mtime_ns)
-        self.assertGreaterEqual(st.st_mtime, old_mtime)
-        # Now with exist_ok=False.
-        p = P / 'newfileB'
-        self.assertFalse(p.exists())
-        p.touch(mode=0o700, exist_ok=False)
-        self.assertTrue(p.exists())
-        self.assertRaises(OSError, p.touch, exist_ok=False)
-
-    def test_touch_nochange(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        p.touch()
-        with p.open('rb') as f:
-            self.assertEqual(f.read().strip(), b"this is file A")
-
-    def test_mkdir(self):
-        P = self.cls(BASE)
-        p = P / 'newdirA'
-        self.assertFalse(p.exists())
-        p.mkdir()
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_parents(self):
-        # Creating a chain of directories.
-        p = self.cls(BASE, 'newdirB', 'newdirC')
-        self.assertFalse(p.exists())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-        p.mkdir(parents=True)
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        # Test `mode` arg.
-        mode = stat.S_IMODE(p.stat().st_mode)  # Default mode.
-        p = self.cls(BASE, 'newdirD', 'newdirE')
-        p.mkdir(0o555, parents=True)
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        if os.name != 'nt':
-            # The directory's permissions follow the mode argument.
-            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o7555 & mode)
-        # The parent's permissions follow the default process settings.
-        self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), mode)
-
-    def test_mkdir_exist_ok(self):
-        p = self.cls(BASE, 'dirB')
-        st_ctime_first = p.stat().st_ctime
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p.mkdir(exist_ok=True)
-        self.assertTrue(p.exists())
-        self.assertEqual(p.stat().st_ctime, st_ctime_first)
-
-    def test_mkdir_exist_ok_with_parent(self):
-        p = self.cls(BASE, 'dirC')
-        self.assertTrue(p.exists())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p = p / 'newdirC'
-        p.mkdir(parents=True)
-        st_ctime_first = p.stat().st_ctime
-        self.assertTrue(p.exists())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p.mkdir(parents=True, exist_ok=True)
-        self.assertTrue(p.exists())
-        self.assertEqual(p.stat().st_ctime, st_ctime_first)
-
-    @unittest.skipIf(is_emscripten, "FS root cannot be modified on Emscripten.")
-    def test_mkdir_exist_ok_root(self):
-        # Issue #25803: A drive root could raise PermissionError on Windows.
-        self.cls('/').resolve().mkdir(exist_ok=True)
-        self.cls('/').resolve().mkdir(parents=True, exist_ok=True)
-
-    @only_nt  # XXX: not sure how to test this on POSIX.
-    def test_mkdir_with_unknown_drive(self):
-        for d in 'ZYXWVUTSRQPONMLKJIHGFEDCBA':
-            p = self.cls(d + ':\\')
-            if not p.is_dir():
-                break
-        else:
-            self.skipTest("cannot find a drive that doesn't exist")
-        with self.assertRaises(OSError):
-            (p / 'child' / 'path').mkdir(parents=True)
-
-    def test_mkdir_with_child_file(self):
-        p = self.cls(BASE, 'dirB', 'fileB')
-        self.assertTrue(p.exists())
-        # An exception is raised when the last path component is an existing
-        # regular file, regardless of whether exist_ok is true or not.
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True, exist_ok=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_no_parents_file(self):
-        p = self.cls(BASE, 'fileA')
-        self.assertTrue(p.exists())
-        # An exception is raised when the last path component is an existing
-        # regular file, regardless of whether exist_ok is true or not.
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(exist_ok=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_concurrent_parent_creation(self):
-        for pattern_num in range(32):
-            p = self.cls(BASE, 'dirCPC%d' % pattern_num)
-            self.assertFalse(p.exists())
-
-            real_mkdir = os.mkdir
-            def my_mkdir(path, mode=0o777):
-                path = str(path)
-                # Emulate another process that would create the directory
-                # just before we try to create it ourselves.  We do it
-                # in all possible pattern combinations, assuming that this
-                # function is called at most 5 times (dirCPC/dir1/dir2,
-                # dirCPC/dir1, dirCPC, dirCPC/dir1, dirCPC/dir1/dir2).
-                if pattern.pop():
-                    real_mkdir(path, mode)  # From another process.
-                    concurrently_created.add(path)
-                real_mkdir(path, mode)  # Our real call.
-
-            pattern = [bool(pattern_num & (1 << n)) for n in range(5)]
-            concurrently_created = set()
-            p12 = p / 'dir1' / 'dir2'
-            try:
-                with mock.patch("os.mkdir", my_mkdir):
-                    p12.mkdir(parents=True, exist_ok=False)
-            except FileExistsError:
-                self.assertIn(str(p12), concurrently_created)
-            else:
-                self.assertNotIn(str(p12), concurrently_created)
-            self.assertTrue(p.exists())
-
-    @os_helper.skip_unless_symlink
-    def test_symlink_to(self):
-        P = self.cls(BASE)
-        target = P / 'fileA'
-        # Symlinking a path target.
-        link = P / 'dirA' / 'linkAA'
-        link.symlink_to(target)
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        # Symlinking a str target.
-        link = P / 'dirA' / 'linkAAA'
-        link.symlink_to(str(target))
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        self.assertFalse(link.is_dir())
-        # Symlinking to a directory.
-        target = P / 'dirB'
-        link = P / 'dirA' / 'linkAAAA'
-        link.symlink_to(target, target_is_directory=True)
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        self.assertTrue(link.is_dir())
-        self.assertTrue(list(link.iterdir()))
-
-    def test_is_dir(self):
-        P = self.cls(BASE)
-        self.assertTrue((P / 'dirA').is_dir())
-        self.assertFalse((P / 'fileA').is_dir())
-        self.assertFalse((P / 'non-existing').is_dir())
-        self.assertFalse((P / 'fileA' / 'bah').is_dir())
-        if os_helper.can_symlink():
-            self.assertFalse((P / 'linkA').is_dir())
-            self.assertTrue((P / 'linkB').is_dir())
-            self.assertFalse((P/ 'brokenLink').is_dir(), False)
-        self.assertIs((P / 'dirA\udfff').is_dir(), False)
-        self.assertIs((P / 'dirA\x00').is_dir(), False)
-
-    def test_is_file(self):
-        P = self.cls(BASE)
-        self.assertTrue((P / 'fileA').is_file())
-        self.assertFalse((P / 'dirA').is_file())
-        self.assertFalse((P / 'non-existing').is_file())
-        self.assertFalse((P / 'fileA' / 'bah').is_file())
-        if os_helper.can_symlink():
-            self.assertTrue((P / 'linkA').is_file())
-            self.assertFalse((P / 'linkB').is_file())
-            self.assertFalse((P/ 'brokenLink').is_file())
-        self.assertIs((P / 'fileA\udfff').is_file(), False)
-        self.assertIs((P / 'fileA\x00').is_file(), False)
-
-    def test_is_mount(self):
-        P = self.cls(BASE)
-        if os.name == 'nt':
-            R = self.cls('c:\\')
-        else:
-            R = self.cls('/')
-        self.assertFalse((P / 'fileA').is_mount())
-        self.assertFalse((P / 'dirA').is_mount())
-        self.assertFalse((P / 'non-existing').is_mount())
-        self.assertFalse((P / 'fileA' / 'bah').is_mount())
-        self.assertTrue(R.is_mount())
-        if os_helper.can_symlink():
-            self.assertFalse((P / 'linkA').is_mount())
-        self.assertIs((R / '\udfff').is_mount(), False)
-
-    def test_is_symlink(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_symlink())
-        self.assertFalse((P / 'dirA').is_symlink())
-        self.assertFalse((P / 'non-existing').is_symlink())
-        self.assertFalse((P / 'fileA' / 'bah').is_symlink())
-        if os_helper.can_symlink():
-            self.assertTrue((P / 'linkA').is_symlink())
-            self.assertTrue((P / 'linkB').is_symlink())
-            self.assertTrue((P/ 'brokenLink').is_symlink())
-        self.assertIs((P / 'fileA\udfff').is_file(), False)
-        self.assertIs((P / 'fileA\x00').is_file(), False)
-        if os_helper.can_symlink():
-            self.assertIs((P / 'linkA\udfff').is_file(), False)
-            self.assertIs((P / 'linkA\x00').is_file(), False)
-
-    def test_is_junction(self):
-        P = self.cls(BASE)
-
-        with mock.patch.object(P._flavour, 'isjunction'):
-            self.assertEqual(P.is_junction(), P._flavour.isjunction.return_value)
-            P._flavour.isjunction.assert_called_once_with(P)
-
-    def test_is_fifo_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_fifo())
-        self.assertFalse((P / 'dirA').is_fifo())
-        self.assertFalse((P / 'non-existing').is_fifo())
-        self.assertFalse((P / 'fileA' / 'bah').is_fifo())
-        self.assertIs((P / 'fileA\udfff').is_fifo(), False)
-        self.assertIs((P / 'fileA\x00').is_fifo(), False)
-
-    @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
-    @unittest.skipIf(sys.platform == "vxworks",
-                    "fifo requires special path on VxWorks")
-    def test_is_fifo_true(self):
-        P = self.cls(BASE, 'myfifo')
-        try:
-            os.mkfifo(str(P))
-        except PermissionError as e:
-            self.skipTest('os.mkfifo(): %s' % e)
-        self.assertTrue(P.is_fifo())
-        self.assertFalse(P.is_socket())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(BASE, 'myfifo\udfff').is_fifo(), False)
-        self.assertIs(self.cls(BASE, 'myfifo\x00').is_fifo(), False)
-
-    def test_is_socket_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_socket())
-        self.assertFalse((P / 'dirA').is_socket())
-        self.assertFalse((P / 'non-existing').is_socket())
-        self.assertFalse((P / 'fileA' / 'bah').is_socket())
-        self.assertIs((P / 'fileA\udfff').is_socket(), False)
-        self.assertIs((P / 'fileA\x00').is_socket(), False)
-
-    @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
-    @unittest.skipIf(
-        is_emscripten, "Unix sockets are not implemented on Emscripten."
-    )
-    @unittest.skipIf(
-        is_wasi, "Cannot create socket on WASI."
-    )
-    def test_is_socket_true(self):
-        P = self.cls(BASE, 'mysock')
-        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.addCleanup(sock.close)
-        try:
-            sock.bind(str(P))
-        except OSError as e:
-            if (isinstance(e, PermissionError) or
-                    "AF_UNIX path too long" in str(e)):
-                self.skipTest("cannot bind Unix socket: " + str(e))
-        self.assertTrue(P.is_socket())
-        self.assertFalse(P.is_fifo())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(BASE, 'mysock\udfff').is_socket(), False)
-        self.assertIs(self.cls(BASE, 'mysock\x00').is_socket(), False)
-
-    def test_is_block_device_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_block_device())
-        self.assertFalse((P / 'dirA').is_block_device())
-        self.assertFalse((P / 'non-existing').is_block_device())
-        self.assertFalse((P / 'fileA' / 'bah').is_block_device())
-        self.assertIs((P / 'fileA\udfff').is_block_device(), False)
-        self.assertIs((P / 'fileA\x00').is_block_device(), False)
-
-    def test_is_char_device_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_char_device())
-        self.assertFalse((P / 'dirA').is_char_device())
-        self.assertFalse((P / 'non-existing').is_char_device())
-        self.assertFalse((P / 'fileA' / 'bah').is_char_device())
-        self.assertIs((P / 'fileA\udfff').is_char_device(), False)
-        self.assertIs((P / 'fileA\x00').is_char_device(), False)
-
-    def test_is_char_device_true(self):
-        # os.devnull should generally be a char device.
-        P = self.cls(os.devnull)
-        if not P.exists():
-            self.skipTest("null device required")
-        self.assertTrue(P.is_char_device())
-        self.assertFalse(P.is_block_device())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(f'{os.devnull}\udfff').is_char_device(), False)
-        self.assertIs(self.cls(f'{os.devnull}\x00').is_char_device(), False)
-
-    def test_pickling_common(self):
-        p = self.cls(BASE, 'fileA')
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            dumped = pickle.dumps(p, proto)
-            pp = pickle.loads(dumped)
-            self.assertEqual(pp.stat(), p.stat())
-
-    def test_parts_interning(self):
-        P = self.cls
-        p = P('/usr/bin/foo')
-        q = P('/usr/local/bin')
-        # 'usr'
-        self.assertIs(p.parts[1], q.parts[1])
-        # 'bin'
-        self.assertIs(p.parts[2], q.parts[3])
-
-    def _check_complex_symlinks(self, link0_target):
-        # Test solving a non-looping chain of symlinks (issue #19887).
-        P = self.cls(BASE)
-        self.dirlink(os.path.join('link0', 'link0'), join('link1'))
-        self.dirlink(os.path.join('link1', 'link1'), join('link2'))
-        self.dirlink(os.path.join('link2', 'link2'), join('link3'))
-        self.dirlink(link0_target, join('link0'))
-
-        # Resolve absolute paths.
-        p = (P / 'link0').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link1').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link2').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link3').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-
-        # Resolve relative paths.
-        old_path = os.getcwd()
-        os.chdir(BASE)
-        try:
-            p = self.cls('link0').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link1').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link2').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link3').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-        finally:
-            os.chdir(old_path)
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_absolute(self):
-        self._check_complex_symlinks(BASE)
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_relative(self):
-        self._check_complex_symlinks('.')
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_relative_dot_dot(self):
-        self._check_complex_symlinks(os.path.join('dirA', '..'))
-
-    def test_passing_kwargs_deprecated(self):
-        with self.assertWarns(DeprecationWarning):
-            self.cls(foo="bar")
-
-
-class WalkTests(unittest.TestCase):
-
-    def setUp(self):
-        self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
-
-        # Build:
-        #     TESTFN/
-        #       TEST1/              a file kid and two directory kids
-        #         tmp1
-        #         SUB1/             a file kid and a directory kid
-        #           tmp2
-        #           SUB11/          no kids
-        #         SUB2/             a file kid and a dirsymlink kid
-        #           tmp3
-        #           SUB21/          not readable
-        #             tmp5
-        #           link/           a symlink to TEST2
-        #           broken_link
-        #           broken_link2
-        #           broken_link3
-        #       TEST2/
-        #         tmp4              a lone file
-        self.walk_path = pathlib.Path(os_helper.TESTFN, "TEST1")
-        self.sub1_path = self.walk_path / "SUB1"
-        self.sub11_path = self.sub1_path / "SUB11"
-        self.sub2_path = self.walk_path / "SUB2"
-        sub21_path= self.sub2_path / "SUB21"
-        tmp1_path = self.walk_path / "tmp1"
-        tmp2_path = self.sub1_path / "tmp2"
-        tmp3_path = self.sub2_path / "tmp3"
-        tmp5_path = sub21_path / "tmp3"
-        self.link_path = self.sub2_path / "link"
-        t2_path = pathlib.Path(os_helper.TESTFN, "TEST2")
-        tmp4_path = pathlib.Path(os_helper.TESTFN, "TEST2", "tmp4")
-        broken_link_path = self.sub2_path / "broken_link"
-        broken_link2_path = self.sub2_path / "broken_link2"
-        broken_link3_path = self.sub2_path / "broken_link3"
-
-        os.makedirs(self.sub11_path)
-        os.makedirs(self.sub2_path)
-        os.makedirs(sub21_path)
-        os.makedirs(t2_path)
-
-        for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path, tmp5_path:
-            with open(path, "x", encoding='utf-8') as f:
-                f.write(f"I'm {path} and proud of it.  Blame test_pathlib.\n")
-
-        if os_helper.can_symlink():
-            os.symlink(os.path.abspath(t2_path), self.link_path)
-            os.symlink('broken', broken_link_path, True)
-            os.symlink(pathlib.Path('tmp3', 'broken'), broken_link2_path, True)
-            os.symlink(pathlib.Path('SUB21', 'tmp5'), broken_link3_path, True)
-            self.sub2_tree = (self.sub2_path, ["SUB21"],
-                              ["broken_link", "broken_link2", "broken_link3",
-                               "link", "tmp3"])
-        else:
-            self.sub2_tree = (self.sub2_path, ["SUB21"], ["tmp3"])
-
-        if not is_emscripten:
-            # Emscripten fails with inaccessible directories.
-            os.chmod(sub21_path, 0)
-        try:
-            os.listdir(sub21_path)
-        except PermissionError:
-            self.addCleanup(os.chmod, sub21_path, stat.S_IRWXU)
-        else:
-            os.chmod(sub21_path, stat.S_IRWXU)
-            os.unlink(tmp5_path)
-            os.rmdir(sub21_path)
-            del self.sub2_tree[1][:1]
-
-    def test_walk_topdown(self):
-        walker = self.walk_path.walk()
-        entry = next(walker)
-        entry[1].sort()  # Ensure we visit SUB1 before SUB2
-        self.assertEqual(entry, (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
-        entry = next(walker)
-        self.assertEqual(entry, (self.sub1_path, ["SUB11"], ["tmp2"]))
-        entry = next(walker)
-        self.assertEqual(entry, (self.sub11_path, [], []))
-        entry = next(walker)
-        entry[1].sort()
-        entry[2].sort()
-        self.assertEqual(entry, self.sub2_tree)
-        with self.assertRaises(StopIteration):
-            next(walker)
-
-    def test_walk_prune(self, walk_path=None):
-        if walk_path is None:
-            walk_path = self.walk_path
-        # Prune the search.
-        all = []
-        for root, dirs, files in walk_path.walk():
-            all.append((root, dirs, files))
-            if 'SUB1' in dirs:
-                # Note that this also mutates the dirs we appended to all!
-                dirs.remove('SUB1')
-
-        self.assertEqual(len(all), 2)
-        self.assertEqual(all[0], (self.walk_path, ["SUB2"], ["tmp1"]))
-
-        all[1][-1].sort()
-        all[1][1].sort()
-        self.assertEqual(all[1], self.sub2_tree)
-
-    def test_file_like_path(self):
-        self.test_walk_prune(FakePath(self.walk_path).__fspath__())
-
-    def test_walk_bottom_up(self):
-        seen_testfn = seen_sub1 = seen_sub11 = seen_sub2 = False
-        for path, dirnames, filenames in self.walk_path.walk(top_down=False):
-            if path == self.walk_path:
-                self.assertFalse(seen_testfn)
-                self.assertTrue(seen_sub1)
-                self.assertTrue(seen_sub2)
-                self.assertEqual(sorted(dirnames), ["SUB1", "SUB2"])
-                self.assertEqual(filenames, ["tmp1"])
-                seen_testfn = True
-            elif path == self.sub1_path:
-                self.assertFalse(seen_testfn)
-                self.assertFalse(seen_sub1)
-                self.assertTrue(seen_sub11)
-                self.assertEqual(dirnames, ["SUB11"])
-                self.assertEqual(filenames, ["tmp2"])
-                seen_sub1 = True
-            elif path == self.sub11_path:
-                self.assertFalse(seen_sub1)
-                self.assertFalse(seen_sub11)
-                self.assertEqual(dirnames, [])
-                self.assertEqual(filenames, [])
-                seen_sub11 = True
-            elif path == self.sub2_path:
-                self.assertFalse(seen_testfn)
-                self.assertFalse(seen_sub2)
-                self.assertEqual(sorted(dirnames), sorted(self.sub2_tree[1]))
-                self.assertEqual(sorted(filenames), sorted(self.sub2_tree[2]))
-                seen_sub2 = True
-            else:
-                raise AssertionError(f"Unexpected path: {path}")
-        self.assertTrue(seen_testfn)
-
-    @os_helper.skip_unless_symlink
-    def test_walk_follow_symlinks(self):
-        walk_it = self.walk_path.walk(follow_symlinks=True)
-        for root, dirs, files in walk_it:
-            if root == self.link_path:
-                self.assertEqual(dirs, [])
-                self.assertEqual(files, ["tmp4"])
-                break
-        else:
-            self.fail("Didn't follow symlink with follow_symlinks=True")
-
-    @os_helper.skip_unless_symlink
-    def test_walk_symlink_location(self):
-        # Tests whether symlinks end up in filenames or dirnames depending
-        # on the `follow_symlinks` argument.
-        walk_it = self.walk_path.walk(follow_symlinks=False)
-        for root, dirs, files in walk_it:
-            if root == self.sub2_path:
-                self.assertIn("link", files)
-                break
-        else:
-            self.fail("symlink not found")
-
-        walk_it = self.walk_path.walk(follow_symlinks=True)
-        for root, dirs, files in walk_it:
-            if root == self.sub2_path:
-                self.assertIn("link", dirs)
-                break
-
-    def test_walk_bad_dir(self):
-        errors = []
-        walk_it = self.walk_path.walk(on_error=errors.append)
-        root, dirs, files = next(walk_it)
-        self.assertEqual(errors, [])
-        dir1 = 'SUB1'
-        path1 = root / dir1
-        path1new = (root / dir1).with_suffix(".new")
-        path1.rename(path1new)
-        try:
-            roots = [r for r, _, _ in walk_it]
-            self.assertTrue(errors)
-            self.assertNotIn(path1, roots)
-            self.assertNotIn(path1new, roots)
-            for dir2 in dirs:
-                if dir2 != dir1:
-                    self.assertIn(root / dir2, roots)
-        finally:
-            path1new.rename(path1)
-
-    def test_walk_many_open_files(self):
-        depth = 30
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d']*depth))
-        path.mkdir(parents=True)
-
-        iters = [base.walk(top_down=False) for _ in range(100)]
-        for i in range(depth + 1):
-            expected = (path, ['d'] if i else [], [])
-            for it in iters:
-                self.assertEqual(next(it), expected)
-            path = path.parent
-
-        iters = [base.walk(top_down=True) for _ in range(100)]
-        path = base
-        for i in range(depth + 1):
-            expected = (path, ['d'] if i < depth else [], [])
-            for it in iters:
-                self.assertEqual(next(it), expected)
-            path = path / 'd'
-
-    def test_walk_above_recursion_limit(self):
-        recursion_limit = 40
-        # directory_depth > recursion_limit
-        directory_depth = recursion_limit + 10
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d'] * directory_depth))
-        path.mkdir(parents=True)
-
-        with set_recursion_limit(recursion_limit):
-            list(base.walk())
-            list(base.walk(top_down=False))
-
-
-class PathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.Path
-
-    def test_concrete_class(self):
-        p = self.cls('a')
-        self.assertIs(type(p),
-            pathlib.WindowsPath if os.name == 'nt' else pathlib.PosixPath)
-
-    def test_unsupported_flavour(self):
-        if os.name == 'nt':
-            self.assertRaises(NotImplementedError, pathlib.PosixPath)
-        else:
-            self.assertRaises(NotImplementedError, pathlib.WindowsPath)
-
-    def test_glob_empty_pattern(self):
-        p = self.cls()
-        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
-            list(p.glob(''))
-
-
-@only_posix
-class PosixPathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.PosixPath
-
-    def test_absolute(self):
-        P = self.cls
-        self.assertEqual(str(P('/').absolute()), '/')
-        self.assertEqual(str(P('/a').absolute()), '/a')
-        self.assertEqual(str(P('/a/b').absolute()), '/a/b')
-
-        # '//'-prefixed absolute path (supported by POSIX).
-        self.assertEqual(str(P('//').absolute()), '//')
-        self.assertEqual(str(P('//a').absolute()), '//a')
-        self.assertEqual(str(P('//a/b').absolute()), '//a/b')
-
-    def _check_symlink_loop(self, *args, strict=True):
-        path = self.cls(*args)
-        with self.assertRaises(RuntimeError):
-            print(path.resolve(strict))
-
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "umask is not implemented on Emscripten/WASI."
-    )
-    def test_open_mode(self):
-        old_mask = os.umask(0)
-        self.addCleanup(os.umask, old_mask)
-        p = self.cls(BASE)
-        with (p / 'new_file').open('wb'):
-            pass
-        st = os.stat(join('new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
-        os.umask(0o022)
-        with (p / 'other_new_file').open('wb'):
-            pass
-        st = os.stat(join('other_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
-
-    def test_resolve_root(self):
-        current_directory = os.getcwd()
-        try:
-            os.chdir('/')
-            p = self.cls('spam')
-            self.assertEqual(str(p.resolve()), '/spam')
-        finally:
-            os.chdir(current_directory)
-
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "umask is not implemented on Emscripten/WASI."
-    )
-    def test_touch_mode(self):
-        old_mask = os.umask(0)
-        self.addCleanup(os.umask, old_mask)
-        p = self.cls(BASE)
-        (p / 'new_file').touch()
-        st = os.stat(join('new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
-        os.umask(0o022)
-        (p / 'other_new_file').touch()
-        st = os.stat(join('other_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
-        (p / 'masked_new_file').touch(mode=0o750)
-        st = os.stat(join('masked_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_loop(self):
-        # Loops with relative symlinks.
-        os.symlink('linkX/inside', join('linkX'))
-        self._check_symlink_loop(BASE, 'linkX')
-        os.symlink('linkY', join('linkY'))
-        self._check_symlink_loop(BASE, 'linkY')
-        os.symlink('linkZ/../linkZ', join('linkZ'))
-        self._check_symlink_loop(BASE, 'linkZ')
-        # Non-strict
-        self._check_symlink_loop(BASE, 'linkZ', 'foo', strict=False)
-        # Loops with absolute symlinks.
-        os.symlink(join('linkU/inside'), join('linkU'))
-        self._check_symlink_loop(BASE, 'linkU')
-        os.symlink(join('linkV'), join('linkV'))
-        self._check_symlink_loop(BASE, 'linkV')
-        os.symlink(join('linkW/../linkW'), join('linkW'))
-        self._check_symlink_loop(BASE, 'linkW')
-        # Non-strict
-        self._check_symlink_loop(BASE, 'linkW', 'foo', strict=False)
-
-    def test_glob(self):
-        P = self.cls
-        p = P(BASE)
-        given = set(p.glob("FILEa"))
-        expect = set() if not os_helper.fs_is_case_insensitive(BASE) else given
-        self.assertEqual(given, expect)
-        self.assertEqual(set(p.glob("FILEa*")), set())
-
-    def test_rglob(self):
-        P = self.cls
-        p = P(BASE, "dirC")
-        given = set(p.rglob("FILEd"))
-        expect = set() if not os_helper.fs_is_case_insensitive(BASE) else given
-        self.assertEqual(given, expect)
-        self.assertEqual(set(p.rglob("FILEd*")), set())
-
-    @unittest.skipUnless(hasattr(pwd, 'getpwall'),
-                         'pwd module does not expose getpwall()')
-    @unittest.skipIf(sys.platform == "vxworks",
-                     "no home directory on VxWorks")
-    def test_expanduser(self):
-        P = self.cls
-        import_helper.import_module('pwd')
-        import pwd
-        pwdent = pwd.getpwuid(os.getuid())
-        username = pwdent.pw_name
-        userhome = pwdent.pw_dir.rstrip('/') or '/'
-        # Find arbitrary different user (if exists).
-        for pwdent in pwd.getpwall():
-            othername = pwdent.pw_name
-            otherhome = pwdent.pw_dir.rstrip('/')
-            if othername != username and otherhome:
-                break
-        else:
-            othername = username
-            otherhome = userhome
-
-        fakename = 'fakeuser'
-        # This user can theoretically exist on a test runner. Create unique name:
-        try:
-            while pwd.getpwnam(fakename):
-                fakename += '1'
-        except KeyError:
-            pass  # Non-existent name found
-
-        p1 = P('~/Documents')
-        p2 = P(f'~{username}/Documents')
-        p3 = P(f'~{othername}/Documents')
-        p4 = P(f'../~{username}/Documents')
-        p5 = P(f'/~{username}/Documents')
-        p6 = P('')
-        p7 = P(f'~{fakename}/Documents')
-
-        with os_helper.EnvironmentVarGuard() as env:
-            env.pop('HOME', None)
-
-            self.assertEqual(p1.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-            self.assertRaises(RuntimeError, p7.expanduser)
-
-            env['HOME'] = '/tmp'
-            self.assertEqual(p1.expanduser(), P('/tmp/Documents'))
-            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-            self.assertRaises(RuntimeError, p7.expanduser)
-
-    @unittest.skipIf(sys.platform != "darwin",
-                     "Bad file descriptor in /dev/fd affects only macOS")
-    def test_handling_bad_descriptor(self):
-        try:
-            file_descriptors = list(pathlib.Path('/dev/fd').rglob("*"))[3:]
-            if not file_descriptors:
-                self.skipTest("no file descriptors - issue was not reproduced")
-            # Checking all file descriptors because there is no guarantee
-            # which one will fail.
-            for f in file_descriptors:
-                f.exists()
-                f.is_dir()
-                f.is_file()
-                f.is_symlink()
-                f.is_block_device()
-                f.is_char_device()
-                f.is_fifo()
-                f.is_socket()
-        except OSError as e:
-            if e.errno == errno.EBADF:
-                self.fail("Bad file descriptor not handled.")
-            raise
-
-
-@only_nt
-class WindowsPathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.WindowsPath
-
-    def test_absolute(self):
-        P = self.cls
-
-        # Simple absolute paths.
-        self.assertEqual(str(P('c:\\').absolute()), 'c:\\')
-        self.assertEqual(str(P('c:\\a').absolute()), 'c:\\a')
-        self.assertEqual(str(P('c:\\a\\b').absolute()), 'c:\\a\\b')
-
-        # UNC absolute paths.
-        share = '\\\\server\\share\\'
-        self.assertEqual(str(P(share).absolute()), share)
-        self.assertEqual(str(P(share + 'a').absolute()), share + 'a')
-        self.assertEqual(str(P(share + 'a\\b').absolute()), share + 'a\\b')
-
-        # UNC relative paths.
-        with mock.patch("os.getcwd") as getcwd:
-            getcwd.return_value = share
-
-            self.assertEqual(str(P().absolute()), share)
-            self.assertEqual(str(P('.').absolute()), share)
-            self.assertEqual(str(P('a').absolute()), os.path.join(share, 'a'))
-            self.assertEqual(str(P('a', 'b', 'c').absolute()),
-                             os.path.join(share, 'a', 'b', 'c'))
-
-        drive = os.path.splitdrive(BASE)[0]
-        with os_helper.change_cwd(BASE):
-            # Relative path with root
-            self.assertEqual(str(P('\\').absolute()), drive + '\\')
-            self.assertEqual(str(P('\\foo').absolute()), drive + '\\foo')
-
-            # Relative path on current drive
-            self.assertEqual(str(P(drive).absolute()), BASE)
-            self.assertEqual(str(P(drive + 'foo').absolute()), os.path.join(BASE, 'foo'))
-
-        with os_helper.subst_drive(BASE) as other_drive:
-            # Set the working directory on the substitute drive
-            saved_cwd = os.getcwd()
-            other_cwd = f'{other_drive}\\dirA'
-            os.chdir(other_cwd)
-            os.chdir(saved_cwd)
-
-            # Relative path on another drive
-            self.assertEqual(str(P(other_drive).absolute()), other_cwd)
-            self.assertEqual(str(P(other_drive + 'foo').absolute()), other_cwd + '\\foo')
-
-    def test_glob(self):
-        P = self.cls
-        p = P(BASE)
-        self.assertEqual(set(p.glob("FILEa")), { P(BASE, "fileA") })
-        self.assertEqual(set(p.glob("*a\\")), { P(BASE, "dirA") })
-        self.assertEqual(set(p.glob("F*a")), { P(BASE, "fileA") })
-        self.assertEqual(set(map(str, p.glob("FILEa"))), {f"{p}\\fileA"})
-        self.assertEqual(set(map(str, p.glob("F*a"))), {f"{p}\\fileA"})
-
-    def test_rglob(self):
-        P = self.cls
-        p = P(BASE, "dirC")
-        self.assertEqual(set(p.rglob("FILEd")), { P(BASE, "dirC/dirD/fileD") })
-        self.assertEqual(set(p.rglob("*\\")), { P(BASE, "dirC/dirD") })
-        self.assertEqual(set(map(str, p.rglob("FILEd"))), {f"{p}\\dirD\\fileD"})
-
-    def test_expanduser(self):
-        P = self.cls
-        with os_helper.EnvironmentVarGuard() as env:
-            env.pop('HOME', None)
-            env.pop('USERPROFILE', None)
-            env.pop('HOMEPATH', None)
-            env.pop('HOMEDRIVE', None)
-            env['USERNAME'] = 'alice'
-
-            # test that the path returns unchanged
-            p1 = P('~/My Documents')
-            p2 = P('~alice/My Documents')
-            p3 = P('~bob/My Documents')
-            p4 = P('/~/My Documents')
-            p5 = P('d:~/My Documents')
-            p6 = P('')
-            self.assertRaises(RuntimeError, p1.expanduser)
-            self.assertRaises(RuntimeError, p2.expanduser)
-            self.assertRaises(RuntimeError, p3.expanduser)
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-
-            def check():
-                env.pop('USERNAME', None)
-                self.assertEqual(p1.expanduser(),
-                                 P('C:/Users/alice/My Documents'))
-                self.assertRaises(RuntimeError, p2.expanduser)
-                env['USERNAME'] = 'alice'
-                self.assertEqual(p2.expanduser(),
-                                 P('C:/Users/alice/My Documents'))
-                self.assertEqual(p3.expanduser(),
-                                 P('C:/Users/bob/My Documents'))
-                self.assertEqual(p4.expanduser(), p4)
-                self.assertEqual(p5.expanduser(), p5)
-                self.assertEqual(p6.expanduser(), p6)
-
-            env['HOMEPATH'] = 'C:\\Users\\alice'
-            check()
-
-            env['HOMEDRIVE'] = 'C:\\'
-            env['HOMEPATH'] = 'Users\\alice'
-            check()
-
-            env.pop('HOMEDRIVE', None)
-            env.pop('HOMEPATH', None)
-            env['USERPROFILE'] = 'C:\\Users\\alice'
-            check()
-
-            # bpo-38883: ignore `HOME` when set on windows
-            env['HOME'] = 'C:\\Users\\eve'
-            check()
-
-
-class PurePathSubclassTest(_BasePurePathTest, unittest.TestCase):
-    class cls(pathlib.PurePath):
-        pass
-
-    # repr() roundtripping is not supported in custom subclass.
-    test_repr_roundtrips = None
-
-
-class PathSubclassTest(_BasePathTest, unittest.TestCase):
-    class cls(pathlib.Path):
-        pass
-
-    # repr() roundtripping is not supported in custom subclass.
-    test_repr_roundtrips = None
-
-
-class CompatiblePathTest(unittest.TestCase):
-    """
-    Test that a type can be made compatible with PurePath
-    derivatives by implementing division operator overloads.
-    """
-
-    class CompatPath:
-        """
-        Minimum viable class to test PurePath compatibility.
-        Simply uses the division operator to join a given
-        string and the string value of another object with
-        a forward slash.
-        """
-        def __init__(self, string):
-            self.string = string
-
-        def __truediv__(self, other):
-            return type(self)(f"{self.string}/{other}")
-
-        def __rtruediv__(self, other):
-            return type(self)(f"{other}/{self.string}")
-
-    def test_truediv(self):
-        result = pathlib.PurePath("test") / self.CompatPath("right")
-        self.assertIsInstance(result, self.CompatPath)
-        self.assertEqual(result.string, "test/right")
-
-        with self.assertRaises(TypeError):
-            # Verify improper operations still raise a TypeError
-            pathlib.PurePath("test") / 10
-
-    def test_rtruediv(self):
-        result = self.CompatPath("left") / pathlib.PurePath("test")
-        self.assertIsInstance(result, self.CompatPath)
-        self.assertEqual(result.string, "left/test")
-
-        with self.assertRaises(TypeError):
-            # Verify improper operations still raise a TypeError
-            10 / pathlib.PurePath("test")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_pathlib/__init__.py b/Lib/test/test_pathlib/__init__.py
new file mode 100644
index 00000000000..4b16ecc3115
--- /dev/null
+++ b/Lib/test/test_pathlib/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_pathlib/test_pathlib.py b/Lib/test/test_pathlib/test_pathlib.py
new file mode 100644
index 00000000000..6cbc15d7675
--- /dev/null
+++ b/Lib/test/test_pathlib/test_pathlib.py
@@ -0,0 +1,1660 @@
+# TODO: RUSTPYTHON
+# Has not been tested with Windows style paths
+import io
+import os
+import sys
+import errno
+import ntpath
+import pathlib
+import pickle
+import posixpath
+import socket
+import stat
+import tempfile
+import unittest
+from unittest import mock
+from urllib.request import pathname2url
+
+from test.support import import_helper
+from test.support import is_emscripten, is_wasi
+from test.support import infinite_recursion
+from test.support import os_helper
+from test.support.os_helper import TESTFN, FS_NONASCII, FakePath
+from test.test_pathlib import test_pathlib_abc
+from test.test_pathlib.test_pathlib_abc import needs_posix, needs_windows, needs_symlinks
+
+try:
+    import grp, pwd
+except ImportError:
+    grp = pwd = None
+
+
+root_in_posix = False
+if hasattr(os, 'geteuid'):
+    root_in_posix = (os.geteuid() == 0)
+
+#
+# Tests for the pure classes.
+#
+
+class PurePathTest(test_pathlib_abc.DummyPurePathTest):
+    cls = pathlib.PurePath
+
+    # Make sure any symbolic links in the base test path are resolved.
+    base = os.path.realpath(TESTFN)
+
+    # Keys are canonical paths, values are list of tuples of arguments
+    # supposed to produce equal paths.
+    equivalences = {
+        'a/b': [
+            ('a', 'b'), ('a/', 'b'), ('a', 'b/'), ('a/', 'b/'),
+            ('a/b/',), ('a//b',), ('a//b//',),
+            # Empty components get removed.
+            ('', 'a', 'b'), ('a', '', 'b'), ('a', 'b', ''),
+            ],
+        '/b/c/d': [
+            ('a', '/b/c', 'd'), ('/a', '/b/c', 'd'),
+            # Empty components get removed.
+            ('/', 'b', '', 'c/d'), ('/', '', 'b/c/d'), ('', '/b/c/d'),
+            ],
+    }
+
+    def test_concrete_class(self):
+        if self.cls is pathlib.PurePath:
+            expected = pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath
+        else:
+            expected = self.cls
+        p = self.cls('a')
+        self.assertIs(type(p), expected)
+
+    def test_concrete_parser(self):
+        if self.cls is pathlib.PurePosixPath:
+            expected = posixpath
+        elif self.cls is pathlib.PureWindowsPath:
+            expected = ntpath
+        else:
+            expected = os.path
+        p = self.cls('a')
+        self.assertIs(p.parser, expected)
+
+    def test_different_parsers_unequal(self):
+        p = self.cls('a')
+        if p.parser is posixpath:
+            q = pathlib.PureWindowsPath('a')
+        else:
+            q = pathlib.PurePosixPath('a')
+        self.assertNotEqual(p, q)
+
+    def test_different_parsers_unordered(self):
+        p = self.cls('a')
+        if p.parser is posixpath:
+            q = pathlib.PureWindowsPath('a')
+        else:
+            q = pathlib.PurePosixPath('a')
+        with self.assertRaises(TypeError):
+            p < q
+        with self.assertRaises(TypeError):
+            p <= q
+        with self.assertRaises(TypeError):
+            p > q
+        with self.assertRaises(TypeError):
+            p >= q
+
+    def test_constructor_nested(self):
+        P = self.cls
+        P(FakePath("a/b/c"))
+        self.assertEqual(P(P('a')), P('a'))
+        self.assertEqual(P(P('a'), 'b'), P('a/b'))
+        self.assertEqual(P(P('a'), P('b')), P('a/b'))
+        self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
+        self.assertEqual(P(P('./a:b')), P('./a:b'))
+
+    @needs_windows
+    def test_constructor_nested_foreign_flavour(self):
+        # See GH-125069.
+        p1 = pathlib.PurePosixPath('b/c:\\d')
+        p2 = pathlib.PurePosixPath('b/', 'c:\\d')
+        self.assertEqual(p1, p2)
+        self.assertEqual(self.cls(p1), self.cls('b/c:/d'))
+        self.assertEqual(self.cls(p2), self.cls('b/c:/d'))
+
+    def _check_parse_path(self, raw_path, *expected):
+        sep = self.parser.sep
+        actual = self.cls._parse_path(raw_path.replace('/', sep))
+        self.assertEqual(actual, expected)
+        if altsep := self.parser.altsep:
+            actual = self.cls._parse_path(raw_path.replace('/', altsep))
+            self.assertEqual(actual, expected)
+
+    def test_parse_path_common(self):
+        check = self._check_parse_path
+        sep = self.parser.sep
+        check('',         '', '', [])
+        check('a',        '', '', ['a'])
+        check('a/',       '', '', ['a'])
+        check('a/b',      '', '', ['a', 'b'])
+        check('a/b/',     '', '', ['a', 'b'])
+        check('a/b/c/d',  '', '', ['a', 'b', 'c', 'd'])
+        check('a/b//c/d', '', '', ['a', 'b', 'c', 'd'])
+        check('a/b/c/d',  '', '', ['a', 'b', 'c', 'd'])
+        check('.',        '', '', [])
+        check('././b',    '', '', ['b'])
+        check('a/./b',    '', '', ['a', 'b'])
+        check('a/./.',    '', '', ['a'])
+        check('/a/b',     '', sep, ['a', 'b'])
+
+    def test_empty_path(self):
+        # The empty path points to '.'
+        p = self.cls('')
+        self.assertEqual(str(p), '.')
+        # Special case for the empty path.
+        self._check_str('.', ('',))
+
+    def test_parts_interning(self):
+        P = self.cls
+        p = P('/usr/bin/foo')
+        q = P('/usr/local/bin')
+        # 'usr'
+        self.assertIs(p.parts[1], q.parts[1])
+        # 'bin'
+        self.assertIs(p.parts[2], q.parts[3])
+
+    def test_join_nested(self):
+        P = self.cls
+        p = P('a/b').joinpath(P('c'))
+        self.assertEqual(p, P('a/b/c'))
+
+    def test_div_nested(self):
+        P = self.cls
+        p = P('a/b') / P('c')
+        self.assertEqual(p, P('a/b/c'))
+
+    def test_pickling_common(self):
+        P = self.cls
+        for pathstr in ('a', 'a/', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c', 'a/b/c/'):
+            with self.subTest(pathstr=pathstr):
+                p = P(pathstr)
+                for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+                    dumped = pickle.dumps(p, proto)
+                    pp = pickle.loads(dumped)
+                    self.assertIs(pp.__class__, p.__class__)
+                    self.assertEqual(pp, p)
+                    self.assertEqual(hash(pp), hash(p))
+                    self.assertEqual(str(pp), str(p))
+
+    def test_repr_common(self):
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            with self.subTest(pathstr=pathstr):
+                p = self.cls(pathstr)
+                clsname = p.__class__.__name__
+                r = repr(p)
+                # The repr() is in the form ClassName("forward-slashes path").
+                self.assertTrue(r.startswith(clsname + '('), r)
+                self.assertTrue(r.endswith(')'), r)
+                inner = r[len(clsname) + 1 : -1]
+                self.assertEqual(eval(inner), p.as_posix())
+
+    def test_fspath_common(self):
+        P = self.cls
+        p = P('a/b')
+        self._check_str(p.__fspath__(), ('a/b',))
+        self._check_str(os.fspath(p), ('a/b',))
+
+    def test_bytes_exc_message(self):
+        P = self.cls
+        message = (r"argument should be a str or an os\.PathLike object "
+                   r"where __fspath__ returns a str, not 'bytes'")
+        with self.assertRaisesRegex(TypeError, message):
+            P(b'a')
+        with self.assertRaisesRegex(TypeError, message):
+            P(b'a', 'b')
+        with self.assertRaisesRegex(TypeError, message):
+            P('a', b'b')
+
+    def test_as_bytes_common(self):
+        sep = os.fsencode(self.sep)
+        P = self.cls
+        self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
+
+    def test_eq_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b'), P('a/b'))
+        self.assertEqual(P('a/b'), P('a', 'b'))
+        self.assertNotEqual(P('a/b'), P('a'))
+        self.assertNotEqual(P('a/b'), P('/a/b'))
+        self.assertNotEqual(P('a/b'), P())
+        self.assertNotEqual(P('/a/b'), P('/'))
+        self.assertNotEqual(P(), P('/'))
+        self.assertNotEqual(P(), "")
+        self.assertNotEqual(P(), {})
+        self.assertNotEqual(P(), int)
+
+    def test_equivalences(self, equivalences=None):
+        if equivalences is None:
+            equivalences = self.equivalences
+        for k, tuples in equivalences.items():
+            canon = k.replace('/', self.sep)
+            posix = k.replace(self.sep, '/')
+            if canon != posix:
+                tuples = tuples + [
+                    tuple(part.replace('/', self.sep) for part in t)
+                    for t in tuples
+                    ]
+                tuples.append((posix, ))
+            pcanon = self.cls(canon)
+            for t in tuples:
+                p = self.cls(*t)
+                self.assertEqual(p, pcanon, "failed with args {}".format(t))
+                self.assertEqual(hash(p), hash(pcanon))
+                self.assertEqual(str(p), canon)
+                self.assertEqual(p.as_posix(), posix)
+
+    def test_ordering_common(self):
+        # Ordering is tuple-alike.
+        def assertLess(a, b):
+            self.assertLess(a, b)
+            self.assertGreater(b, a)
+        P = self.cls
+        a = P('a')
+        b = P('a/b')
+        c = P('abc')
+        d = P('b')
+        assertLess(a, b)
+        assertLess(a, c)
+        assertLess(a, d)
+        assertLess(b, c)
+        assertLess(c, d)
+        P = self.cls
+        a = P('/a')
+        b = P('/a/b')
+        c = P('/abc')
+        d = P('/b')
+        assertLess(a, b)
+        assertLess(a, c)
+        assertLess(a, d)
+        assertLess(b, c)
+        assertLess(c, d)
+        with self.assertRaises(TypeError):
+            P() < {}
+
+    def test_as_uri_common(self):
+        P = self.cls
+        with self.assertRaises(ValueError):
+            P('a').as_uri()
+        with self.assertRaises(ValueError):
+            P().as_uri()
+
+    def test_repr_roundtrips(self):
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            with self.subTest(pathstr=pathstr):
+                p = self.cls(pathstr)
+                r = repr(p)
+                # The repr() roundtrips.
+                q = eval(r, pathlib.__dict__)
+                self.assertIs(q.__class__, p.__class__)
+                self.assertEqual(q, p)
+                self.assertEqual(repr(q), r)
+
+    def test_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').name, '')
+        self.assertEqual(P('.').name, '')
+        self.assertEqual(P('/a/b/.').name, 'b')
+
+    def test_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').stem, '')
+        self.assertEqual(P('.').stem, '')
+
+    def test_with_name_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('.').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('/').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('a/b').with_name, '')
+        self.assertRaises(ValueError, P('a/b').with_name, '.')
+
+    def test_with_stem_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('').with_stem, 'd')
+        self.assertRaises(ValueError, P('.').with_stem, 'd')
+        self.assertRaises(ValueError, P('/').with_stem, 'd')
+        self.assertRaises(ValueError, P('a/b').with_stem, '')
+        self.assertRaises(ValueError, P('a/b').with_stem, '.')
+
+    def test_relative_to_several_args(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.relative_to('a', 'b')
+            p.relative_to('a', 'b', walk_up=True)
+
+    def test_is_relative_to_several_args(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.is_relative_to('a', 'b')
+
+    def test_is_reserved_deprecated(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.is_reserved()
+
+    def test_match_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a').match, '')
+        self.assertRaises(ValueError, P('a').match, '.')
+
+    @needs_posix
+    def test_parse_path_posix(self):
+        check = self._check_parse_path
+        # Collapsing of excess leading slashes, except for the double-slash
+        # special case.
+        check('//a/b',   '', '//', ['a', 'b'])
+        check('///a/b',  '', '/', ['a', 'b'])
+        check('////a/b', '', '/', ['a', 'b'])
+        # Paths which look like NT paths aren't treated specially.
+        check('c:a',     '', '', ['c:a',])
+        check('c:\\a',   '', '', ['c:\\a',])
+        check('\\a',     '', '', ['\\a',])
+
+    @needs_posix
+    def test_eq_posix(self):
+        P = self.cls
+        self.assertNotEqual(P('a/b'), P('A/b'))
+        self.assertEqual(P('/a'), P('///a'))
+        self.assertNotEqual(P('/a'), P('//a'))
+
+    @needs_posix
+    def test_as_uri_posix(self):
+        P = self.cls
+        self.assertEqual(P('/').as_uri(), 'file:///')
+        self.assertEqual(P('/a/b.c').as_uri(), 'file:///a/b.c')
+        self.assertEqual(P('/a/b%#c').as_uri(), 'file:///a/b%25%23c')
+
+    @needs_posix
+    def test_as_uri_non_ascii(self):
+        from urllib.parse import quote_from_bytes
+        P = self.cls
+        try:
+            os.fsencode('\xe9')
+        except UnicodeEncodeError:
+            self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
+        self.assertEqual(P('/a/b\xe9').as_uri(),
+                         'file:///a/b' + quote_from_bytes(os.fsencode('\xe9')))
+
+    @needs_posix
+    def test_parse_windows_path(self):
+        P = self.cls
+        p = P('c:', 'a', 'b')
+        pp = P(pathlib.PureWindowsPath('c:\\a\\b'))
+        self.assertEqual(p, pp)
+
+    windows_equivalences = {
+        './a:b': [ ('./a:b',) ],
+        'c:a': [ ('c:', 'a'), ('c:', 'a/'), ('.', 'c:', 'a') ],
+        'c:/a': [
+            ('c:/', 'a'), ('c:', '/', 'a'), ('c:', '/a'),
+            ('/z', 'c:/', 'a'), ('//x/y', 'c:/', 'a'),
+            ],
+        '//a/b/': [ ('//a/b',) ],
+        '//a/b/c': [
+            ('//a/b', 'c'), ('//a/b/', 'c'),
+            ],
+    }
+
+    @needs_windows
+    def test_equivalences_windows(self):
+        self.test_equivalences(self.windows_equivalences)
+
+    @needs_windows
+    def test_parse_path_windows(self):
+        check = self._check_parse_path
+        # First part is anchored.
+        check('c:',                  'c:', '', [])
+        check('c:/',                 'c:', '\\', [])
+        check('/',                   '', '\\', [])
+        check('c:a',                 'c:', '', ['a'])
+        check('c:/a',                'c:', '\\', ['a'])
+        check('/a',                  '', '\\', ['a'])
+        # UNC paths.
+        check('//',                  '\\\\', '', [])
+        check('//a',                 '\\\\a', '', [])
+        check('//a/',                '\\\\a\\', '', [])
+        check('//a/b',               '\\\\a\\b', '\\', [])
+        check('//a/b/',              '\\\\a\\b', '\\', [])
+        check('//a/b/c',             '\\\\a\\b', '\\', ['c'])
+        # Collapsing and stripping excess slashes.
+        check('Z://b//c/d/',         'Z:', '\\', ['b', 'c', 'd'])
+        # UNC paths.
+        check('//b/c//d',            '\\\\b\\c', '\\', ['d'])
+        # Extended paths.
+        check('//./c:',              '\\\\.\\c:', '', [])
+        check('//?/c:/',             '\\\\?\\c:', '\\', [])
+        check('//?/c:/a',            '\\\\?\\c:', '\\', ['a'])
+        # Extended UNC paths (format is "\\?\UNC\server\share").
+        check('//?',                 '\\\\?', '', [])
+        check('//?/',                '\\\\?\\', '', [])
+        check('//?/UNC',             '\\\\?\\UNC', '', [])
+        check('//?/UNC/',            '\\\\?\\UNC\\', '', [])
+        check('//?/UNC/b',           '\\\\?\\UNC\\b', '', [])
+        check('//?/UNC/b/',          '\\\\?\\UNC\\b\\', '', [])
+        check('//?/UNC/b/c',         '\\\\?\\UNC\\b\\c', '\\', [])
+        check('//?/UNC/b/c/',        '\\\\?\\UNC\\b\\c', '\\', [])
+        check('//?/UNC/b/c/d',       '\\\\?\\UNC\\b\\c', '\\', ['d'])
+        # UNC device paths
+        check('//./BootPartition/',  '\\\\.\\BootPartition', '\\', [])
+        check('//?/BootPartition/',  '\\\\?\\BootPartition', '\\', [])
+        check('//./PhysicalDrive0',  '\\\\.\\PhysicalDrive0', '', [])
+        check('//?/Volume{}/',       '\\\\?\\Volume{}', '\\', [])
+        check('//./nul',             '\\\\.\\nul', '', [])
+        # Paths to files with NTFS alternate data streams
+        check('./c:s',               '', '', ['c:s'])
+        check('cc:s',                '', '', ['cc:s'])
+        check('C:c:s',               'C:', '', ['c:s'])
+        check('C:/c:s',              'C:', '\\', ['c:s'])
+        check('D:a/c:b',             'D:', '', ['a', 'c:b'])
+        check('D:/a/c:b',            'D:', '\\', ['a', 'c:b'])
+
+    @needs_windows
+    def test_eq_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b'), P('c:a/b'))
+        self.assertEqual(P('c:a/b'), P('c:', 'a', 'b'))
+        self.assertNotEqual(P('c:a/b'), P('d:a/b'))
+        self.assertNotEqual(P('c:a/b'), P('c:/a/b'))
+        self.assertNotEqual(P('/a/b'), P('c:/a/b'))
+        # Case-insensitivity.
+        self.assertEqual(P('a/B'), P('A/b'))
+        self.assertEqual(P('C:a/B'), P('c:A/b'))
+        self.assertEqual(P('//Some/SHARE/a/B'), P('//somE/share/A/b'))
+        self.assertEqual(P('\u0130'), P('i\u0307'))
+
+    @needs_windows
+    def test_as_uri_windows(self):
+        P = self.cls
+        with self.assertRaises(ValueError):
+            P('/a/b').as_uri()
+        with self.assertRaises(ValueError):
+            P('c:a/b').as_uri()
+        self.assertEqual(P('c:/').as_uri(), 'file:///c:/')
+        self.assertEqual(P('c:/a/b.c').as_uri(), 'file:///c:/a/b.c')
+        self.assertEqual(P('c:/a/b%#c').as_uri(), 'file:///c:/a/b%25%23c')
+        self.assertEqual(P('//some/share/').as_uri(), 'file://some/share/')
+        self.assertEqual(P('//some/share/a/b.c').as_uri(),
+                         'file://some/share/a/b.c')
+
+        from urllib.parse import quote_from_bytes
+        QUOTED_FS_NONASCII = quote_from_bytes(os.fsencode(FS_NONASCII))
+        self.assertEqual(P('c:/a/b' + FS_NONASCII).as_uri(),
+                         'file:///c:/a/b' + QUOTED_FS_NONASCII)
+        self.assertEqual(P('//some/share/a/b%#c' + FS_NONASCII).as_uri(),
+                         'file://some/share/a/b%25%23c' + QUOTED_FS_NONASCII)
+
+    @needs_windows
+    def test_ordering_windows(self):
+        # Case-insensitivity.
+        def assertOrderedEqual(a, b):
+            self.assertLessEqual(a, b)
+            self.assertGreaterEqual(b, a)
+        P = self.cls
+        p = P('c:A/b')
+        q = P('C:a/B')
+        assertOrderedEqual(p, q)
+        self.assertFalse(p < q)
+        self.assertFalse(p > q)
+        p = P('//some/Share/A/b')
+        q = P('//Some/SHARE/a/B')
+        assertOrderedEqual(p, q)
+        self.assertFalse(p < q)
+        self.assertFalse(p > q)
+
+
+class PurePosixPathTest(PurePathTest):
+    cls = pathlib.PurePosixPath
+
+
+class PureWindowsPathTest(PurePathTest):
+    cls = pathlib.PureWindowsPath
+
+
+class PurePathSubclassTest(PurePathTest):
+    class cls(pathlib.PurePath):
+        pass
+
+    # repr() roundtripping is not supported in custom subclass.
+    test_repr_roundtrips = None
+
+
+#
+# Tests for the concrete classes.
+#
+
+class PathTest(test_pathlib_abc.DummyPathTest, PurePathTest):
+    """Tests for the FS-accessing functionalities of the Path classes."""
+    cls = pathlib.Path
+    can_symlink = os_helper.can_symlink()
+
+    def setUp(self):
+        super().setUp()
+        os.chmod(self.parser.join(self.base, 'dirE'), 0)
+
+    def tearDown(self):
+        os.chmod(self.parser.join(self.base, 'dirE'), 0o777)
+        os_helper.rmtree(self.base)
+
+    def tempdir(self):
+        d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
+                                                 dir=os.getcwd()))
+        self.addCleanup(os_helper.rmtree, d)
+        return d
+
+    def test_matches_pathbase_api(self):
+        our_names = {name for name in dir(self.cls) if name[0] != '_'}
+        our_names.remove('is_reserved')  # only present in PurePath
+        path_names = {name for name in dir(pathlib._abc.PathBase) if name[0] != '_'}
+        self.assertEqual(our_names, path_names)
+        for attr_name in our_names:
+            if attr_name == 'parser':
+                # On Windows, Path.parser is ntpath, but PathBase.parser is
+                # posixpath, and so their docstrings differ.
+                continue
+            our_attr = getattr(self.cls, attr_name)
+            path_attr = getattr(pathlib._abc.PathBase, attr_name)
+            self.assertEqual(our_attr.__doc__, path_attr.__doc__)
+
+    def test_concrete_class(self):
+        if self.cls is pathlib.Path:
+            expected = pathlib.WindowsPath if os.name == 'nt' else pathlib.PosixPath
+        else:
+            expected = self.cls
+        p = self.cls('a')
+        self.assertIs(type(p), expected)
+
+    def test_unsupported_parser(self):
+        if self.cls.parser is os.path:
+            self.skipTest("path parser is supported")
+        else:
+            self.assertRaises(pathlib.UnsupportedOperation, self.cls)
+
+    def _test_cwd(self, p):
+        q = self.cls(os.getcwd())
+        self.assertEqual(p, q)
+        self.assertEqualNormCase(str(p), str(q))
+        self.assertIs(type(p), type(q))
+        self.assertTrue(p.is_absolute())
+
+    def test_cwd(self):
+        p = self.cls.cwd()
+        self._test_cwd(p)
+
+    def test_absolute_common(self):
+        P = self.cls
+
+        with mock.patch("os.getcwd") as getcwd:
+            getcwd.return_value = self.base
+
+            # Simple relative paths.
+            self.assertEqual(str(P().absolute()), self.base)
+            self.assertEqual(str(P('.').absolute()), self.base)
+            self.assertEqual(str(P('a').absolute()), os.path.join(self.base, 'a'))
+            self.assertEqual(str(P('a', 'b', 'c').absolute()), os.path.join(self.base, 'a', 'b', 'c'))
+
+            # Symlinks should not be resolved.
+            self.assertEqual(str(P('linkB', 'fileB').absolute()), os.path.join(self.base, 'linkB', 'fileB'))
+            self.assertEqual(str(P('brokenLink').absolute()), os.path.join(self.base, 'brokenLink'))
+            self.assertEqual(str(P('brokenLinkLoop').absolute()), os.path.join(self.base, 'brokenLinkLoop'))
+
+            # '..' entries should be preserved and not normalised.
+            self.assertEqual(str(P('..').absolute()), os.path.join(self.base, '..'))
+            self.assertEqual(str(P('a', '..').absolute()), os.path.join(self.base, 'a', '..'))
+            self.assertEqual(str(P('..', 'b').absolute()), os.path.join(self.base, '..', 'b'))
+
+    def _test_home(self, p):
+        q = self.cls(os.path.expanduser('~'))
+        self.assertEqual(p, q)
+        self.assertEqualNormCase(str(p), str(q))
+        self.assertIs(type(p), type(q))
+        self.assertTrue(p.is_absolute())
+
+    @unittest.skipIf(
+        pwd is None, reason="Test requires pwd module to get homedir."
+    )
+    def test_home(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            self._test_home(self.cls.home())
+
+            env.clear()
+            env['USERPROFILE'] = os.path.join(self.base, 'userprofile')
+            self._test_home(self.cls.home())
+
+            # bpo-38883: ignore `HOME` when set on windows
+            env['HOME'] = os.path.join(self.base, 'home')
+            self._test_home(self.cls.home())
+
+    @unittest.skipIf(is_wasi, "WASI has no user accounts.")
+    def test_expanduser_common(self):
+        P = self.cls
+        p = P('~')
+        self.assertEqual(p.expanduser(), P(os.path.expanduser('~')))
+        p = P('foo')
+        self.assertEqual(p.expanduser(), p)
+        p = P('/~')
+        self.assertEqual(p.expanduser(), p)
+        p = P('../~')
+        self.assertEqual(p.expanduser(), p)
+        p = P(P('').absolute().anchor) / '~'
+        self.assertEqual(p.expanduser(), p)
+        p = P('~/a:b')
+        self.assertEqual(p.expanduser(), P(os.path.expanduser('~'), './a:b'))
+
+    def test_with_segments(self):
+        class P(self.cls):
+            def __init__(self, *pathsegments, session_id):
+                super().__init__(*pathsegments)
+                self.session_id = session_id
+
+            def with_segments(self, *pathsegments):
+                return type(self)(*pathsegments, session_id=self.session_id)
+        p = P(self.base, session_id=42)
+        self.assertEqual(42, p.absolute().session_id)
+        self.assertEqual(42, p.resolve().session_id)
+        if not is_wasi:  # WASI has no user accounts.
+            self.assertEqual(42, p.with_segments('~').expanduser().session_id)
+        self.assertEqual(42, (p / 'fileA').rename(p / 'fileB').session_id)
+        self.assertEqual(42, (p / 'fileB').replace(p / 'fileA').session_id)
+        if self.can_symlink:
+            self.assertEqual(42, (p / 'linkA').readlink().session_id)
+        for path in p.iterdir():
+            self.assertEqual(42, path.session_id)
+        for path in p.glob('*'):
+            self.assertEqual(42, path.session_id)
+        for path in p.rglob('*'):
+            self.assertEqual(42, path.session_id)
+        for dirpath, dirnames, filenames in p.walk():
+            self.assertEqual(42, dirpath.session_id)
+
+    def test_open_unbuffered(self):
+        p = self.cls(self.base)
+        with (p / 'fileA').open('rb', buffering=0) as f:
+            self.assertIsInstance(f, io.RawIOBase)
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_resolve_nonexist_relative_issue38671(self):
+        p = self.cls('non', 'exist')
+
+        old_cwd = os.getcwd()
+        os.chdir(self.base)
+        try:
+            self.assertEqual(p.resolve(), self.cls(self.base, p))
+        finally:
+            os.chdir(old_cwd)
+
+    @os_helper.skip_unless_working_chmod
+    def test_chmod(self):
+        p = self.cls(self.base) / 'fileA'
+        mode = p.stat().st_mode
+        # Clear writable bit.
+        new_mode = mode & ~0o222
+        p.chmod(new_mode)
+        self.assertEqual(p.stat().st_mode, new_mode)
+        # Set writable bit.
+        new_mode = mode | 0o222
+        p.chmod(new_mode)
+        self.assertEqual(p.stat().st_mode, new_mode)
+
+    # On Windows, os.chmod does not follow symlinks (issue #15411)
+    @needs_posix
+    @os_helper.skip_unless_working_chmod
+    def test_chmod_follow_symlinks_true(self):
+        p = self.cls(self.base) / 'linkA'
+        q = p.resolve()
+        mode = q.stat().st_mode
+        # Clear writable bit.
+        new_mode = mode & ~0o222
+        p.chmod(new_mode, follow_symlinks=True)
+        self.assertEqual(q.stat().st_mode, new_mode)
+        # Set writable bit
+        new_mode = mode | 0o222
+        p.chmod(new_mode, follow_symlinks=True)
+        self.assertEqual(q.stat().st_mode, new_mode)
+
+    # XXX also need a test for lchmod.
+
+    def _get_pw_name_or_skip_test(self, uid):
+        try:
+            return pwd.getpwuid(uid).pw_name
+        except KeyError:
+            self.skipTest(
+                "user %d doesn't have an entry in the system database" % uid)
+
+    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
+    def test_owner(self):
+        p = self.cls(self.base) / 'fileA'
+        expected_uid = p.stat().st_uid
+        expected_name = self._get_pw_name_or_skip_test(expected_uid)
+
+        self.assertEqual(expected_name, p.owner())
+
+    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
+    @unittest.skipUnless(root_in_posix, "test needs root privilege")
+    def test_owner_no_follow_symlinks(self):
+        all_users = [u.pw_uid for u in pwd.getpwall()]
+        if len(all_users) < 2:
+            self.skipTest("test needs more than one user")
+
+        target = self.cls(self.base) / 'fileA'
+        link = self.cls(self.base) / 'linkA'
+
+        uid_1, uid_2 = all_users[:2]
+        os.chown(target, uid_1, -1)
+        os.chown(link, uid_2, -1, follow_symlinks=False)
+
+        expected_uid = link.stat(follow_symlinks=False).st_uid
+        expected_name = self._get_pw_name_or_skip_test(expected_uid)
+
+        self.assertEqual(expected_uid, uid_2)
+        self.assertEqual(expected_name, link.owner(follow_symlinks=False))
+
+    def _get_gr_name_or_skip_test(self, gid):
+        try:
+            return grp.getgrgid(gid).gr_name
+        except KeyError:
+            self.skipTest(
+                "group %d doesn't have an entry in the system database" % gid)
+
+    @unittest.skipUnless(grp, "the grp module is needed for this test")
+    def test_group(self):
+        p = self.cls(self.base) / 'fileA'
+        expected_gid = p.stat().st_gid
+        expected_name = self._get_gr_name_or_skip_test(expected_gid)
+
+        self.assertEqual(expected_name, p.group())
+
+    @unittest.skipUnless(grp, "the grp module is needed for this test")
+    @unittest.skipUnless(root_in_posix, "test needs root privilege")
+    def test_group_no_follow_symlinks(self):
+        all_groups = [g.gr_gid for g in grp.getgrall()]
+        if len(all_groups) < 2:
+            self.skipTest("test needs more than one group")
+
+        target = self.cls(self.base) / 'fileA'
+        link = self.cls(self.base) / 'linkA'
+
+        gid_1, gid_2 = all_groups[:2]
+        os.chown(target, -1, gid_1)
+        os.chown(link, -1, gid_2, follow_symlinks=False)
+
+        expected_gid = link.stat(follow_symlinks=False).st_gid
+        expected_name = self._get_gr_name_or_skip_test(expected_gid)
+
+        self.assertEqual(expected_gid, gid_2)
+        self.assertEqual(expected_name, link.group(follow_symlinks=False))
+
+    def test_unlink(self):
+        p = self.cls(self.base) / 'fileA'
+        p.unlink()
+        self.assertFileNotFound(p.stat)
+        self.assertFileNotFound(p.unlink)
+
+    def test_unlink_missing_ok(self):
+        p = self.cls(self.base) / 'fileAAA'
+        self.assertFileNotFound(p.unlink)
+        p.unlink(missing_ok=True)
+
+    def test_rmdir(self):
+        p = self.cls(self.base) / 'dirA'
+        for q in p.iterdir():
+            q.unlink()
+        p.rmdir()
+        self.assertFileNotFound(p.stat)
+        self.assertFileNotFound(p.unlink)
+
+    @os_helper.skip_unless_hardlink
+    def test_hardlink_to(self):
+        P = self.cls(self.base)
+        target = P / 'fileA'
+        size = target.stat().st_size
+        # linking to another path.
+        link = P / 'dirA' / 'fileAA'
+        link.hardlink_to(target)
+        self.assertEqual(link.stat().st_size, size)
+        self.assertTrue(os.path.samefile(target, link))
+        self.assertTrue(target.exists())
+        # Linking to a str of a relative path.
+        link2 = P / 'dirA' / 'fileAAA'
+        target2 = self.parser.join(TESTFN, 'fileA')
+        link2.hardlink_to(target2)
+        self.assertEqual(os.stat(target2).st_size, size)
+        self.assertTrue(link2.exists())
+
+    @unittest.skipIf(hasattr(os, "link"), "os.link() is present")
+    def test_hardlink_to_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        # linking to another path.
+        q = P / 'dirA' / 'fileAA'
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            q.hardlink_to(p)
+
+    def test_rename(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        size = p.stat().st_size
+        # Renaming to another path.
+        q = P / 'dirA' / 'fileAA'
+        renamed_p = p.rename(q)
+        self.assertEqual(renamed_p, q)
+        self.assertEqual(q.stat().st_size, size)
+        self.assertFileNotFound(p.stat)
+        # Renaming to a str of a relative path.
+        r = self.parser.join(TESTFN, 'fileAAA')
+        renamed_q = q.rename(r)
+        self.assertEqual(renamed_q, self.cls(r))
+        self.assertEqual(os.stat(r).st_size, size)
+        self.assertFileNotFound(q.stat)
+
+    def test_replace(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        size = p.stat().st_size
+        # Replacing a non-existing path.
+        q = P / 'dirA' / 'fileAA'
+        replaced_p = p.replace(q)
+        self.assertEqual(replaced_p, q)
+        self.assertEqual(q.stat().st_size, size)
+        self.assertFileNotFound(p.stat)
+        # Replacing another (existing) path.
+        r = self.parser.join(TESTFN, 'dirB', 'fileB')
+        replaced_q = q.replace(r)
+        self.assertEqual(replaced_q, self.cls(r))
+        self.assertEqual(os.stat(r).st_size, size)
+        self.assertFileNotFound(q.stat)
+
+    def test_touch_common(self):
+        P = self.cls(self.base)
+        p = P / 'newfileA'
+        self.assertFalse(p.exists())
+        p.touch()
+        self.assertTrue(p.exists())
+        st = p.stat()
+        old_mtime = st.st_mtime
+        old_mtime_ns = st.st_mtime_ns
+        # Rewind the mtime sufficiently far in the past to work around
+        # filesystem-specific timestamp granularity.
+        os.utime(str(p), (old_mtime - 10, old_mtime - 10))
+        # The file mtime should be refreshed by calling touch() again.
+        p.touch()
+        st = p.stat()
+        self.assertGreaterEqual(st.st_mtime_ns, old_mtime_ns)
+        self.assertGreaterEqual(st.st_mtime, old_mtime)
+        # Now with exist_ok=False.
+        p = P / 'newfileB'
+        self.assertFalse(p.exists())
+        p.touch(mode=0o700, exist_ok=False)
+        self.assertTrue(p.exists())
+        self.assertRaises(OSError, p.touch, exist_ok=False)
+
+    def test_touch_nochange(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        p.touch()
+        with p.open('rb') as f:
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_mkdir(self):
+        P = self.cls(self.base)
+        p = P / 'newdirA'
+        self.assertFalse(p.exists())
+        p.mkdir()
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_parents(self):
+        # Creating a chain of directories.
+        p = self.cls(self.base, 'newdirB', 'newdirC')
+        self.assertFalse(p.exists())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        p.mkdir(parents=True)
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        # Test `mode` arg.
+        mode = stat.S_IMODE(p.stat().st_mode)  # Default mode.
+        p = self.cls(self.base, 'newdirD', 'newdirE')
+        p.mkdir(0o555, parents=True)
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        if os.name != 'nt':
+            # The directory's permissions follow the mode argument.
+            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o7555 & mode)
+        # The parent's permissions follow the default process settings.
+        self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), mode)
+
+    def test_mkdir_exist_ok(self):
+        p = self.cls(self.base, 'dirB')
+        st_ctime_first = p.stat().st_ctime
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p.mkdir(exist_ok=True)
+        self.assertTrue(p.exists())
+        self.assertEqual(p.stat().st_ctime, st_ctime_first)
+
+    def test_mkdir_exist_ok_with_parent(self):
+        p = self.cls(self.base, 'dirC')
+        self.assertTrue(p.exists())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p = p / 'newdirC'
+        p.mkdir(parents=True)
+        st_ctime_first = p.stat().st_ctime
+        self.assertTrue(p.exists())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p.mkdir(parents=True, exist_ok=True)
+        self.assertTrue(p.exists())
+        self.assertEqual(p.stat().st_ctime, st_ctime_first)
+
+    @unittest.skipIf(is_emscripten, "FS root cannot be modified on Emscripten.")
+    def test_mkdir_exist_ok_root(self):
+        # Issue #25803: A drive root could raise PermissionError on Windows.
+        self.cls('/').resolve().mkdir(exist_ok=True)
+        self.cls('/').resolve().mkdir(parents=True, exist_ok=True)
+
+    @needs_windows  # XXX: not sure how to test this on POSIX.
+    def test_mkdir_with_unknown_drive(self):
+        for d in 'ZYXWVUTSRQPONMLKJIHGFEDCBA':
+            p = self.cls(d + ':\\')
+            if not p.is_dir():
+                break
+        else:
+            self.skipTest("cannot find a drive that doesn't exist")
+        with self.assertRaises(OSError):
+            (p / 'child' / 'path').mkdir(parents=True)
+
+    def test_mkdir_with_child_file(self):
+        p = self.cls(self.base, 'dirB', 'fileB')
+        self.assertTrue(p.exists())
+        # An exception is raised when the last path component is an existing
+        # regular file, regardless of whether exist_ok is true or not.
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True, exist_ok=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_no_parents_file(self):
+        p = self.cls(self.base, 'fileA')
+        self.assertTrue(p.exists())
+        # An exception is raised when the last path component is an existing
+        # regular file, regardless of whether exist_ok is true or not.
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(exist_ok=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_concurrent_parent_creation(self):
+        for pattern_num in range(32):
+            p = self.cls(self.base, 'dirCPC%d' % pattern_num)
+            self.assertFalse(p.exists())
+
+            real_mkdir = os.mkdir
+            def my_mkdir(path, mode=0o777):
+                path = str(path)
+                # Emulate another process that would create the directory
+                # just before we try to create it ourselves.  We do it
+                # in all possible pattern combinations, assuming that this
+                # function is called at most 5 times (dirCPC/dir1/dir2,
+                # dirCPC/dir1, dirCPC, dirCPC/dir1, dirCPC/dir1/dir2).
+                if pattern.pop():
+                    real_mkdir(path, mode)  # From another process.
+                    concurrently_created.add(path)
+                real_mkdir(path, mode)  # Our real call.
+
+            pattern = [bool(pattern_num & (1 << n)) for n in range(5)]
+            concurrently_created = set()
+            p12 = p / 'dir1' / 'dir2'
+            try:
+                with mock.patch("os.mkdir", my_mkdir):
+                    p12.mkdir(parents=True, exist_ok=False)
+            except FileExistsError:
+                self.assertIn(str(p12), concurrently_created)
+            else:
+                self.assertNotIn(str(p12), concurrently_created)
+            self.assertTrue(p.exists())
+
+    @needs_symlinks
+    def test_symlink_to(self):
+        P = self.cls(self.base)
+        target = P / 'fileA'
+        # Symlinking a path target.
+        link = P / 'dirA' / 'linkAA'
+        link.symlink_to(target)
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        # Symlinking a str target.
+        link = P / 'dirA' / 'linkAAA'
+        link.symlink_to(str(target))
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        self.assertFalse(link.is_dir())
+        # Symlinking to a directory.
+        target = P / 'dirB'
+        link = P / 'dirA' / 'linkAAAA'
+        link.symlink_to(target, target_is_directory=True)
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        self.assertTrue(link.is_dir())
+        self.assertTrue(list(link.iterdir()))
+
+    @unittest.skipIf(hasattr(os, "symlink"), "os.symlink() is present")
+    def test_symlink_to_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        # linking to another path.
+        q = P / 'dirA' / 'fileAA'
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            q.symlink_to(p)
+
+    def test_is_junction(self):
+        P = self.cls(self.base)
+
+        with mock.patch.object(P.parser, 'isjunction'):
+            self.assertEqual(P.is_junction(), P.parser.isjunction.return_value)
+            P.parser.isjunction.assert_called_once_with(P)
+
+    @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
+    @unittest.skipIf(sys.platform == "vxworks",
+                    "fifo requires special path on VxWorks")
+    def test_is_fifo_true(self):
+        P = self.cls(self.base, 'myfifo')
+        try:
+            os.mkfifo(str(P))
+        except PermissionError as e:
+            self.skipTest('os.mkfifo(): %s' % e)
+        self.assertTrue(P.is_fifo())
+        self.assertFalse(P.is_socket())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(self.base, 'myfifo\udfff').is_fifo(), False)
+        self.assertIs(self.cls(self.base, 'myfifo\x00').is_fifo(), False)
+
+    @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
+    @unittest.skipIf(
+        is_emscripten, "Unix sockets are not implemented on Emscripten."
+    )
+    @unittest.skipIf(
+        is_wasi, "Cannot create socket on WASI."
+    )
+    def test_is_socket_true(self):
+        P = self.cls(self.base, 'mysock')
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.addCleanup(sock.close)
+        try:
+            sock.bind(str(P))
+        except OSError as e:
+            if (isinstance(e, PermissionError) or
+                    "AF_UNIX path too long" in str(e)):
+                self.skipTest("cannot bind Unix socket: " + str(e))
+        self.assertTrue(P.is_socket())
+        self.assertFalse(P.is_fifo())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(self.base, 'mysock\udfff').is_socket(), False)
+        self.assertIs(self.cls(self.base, 'mysock\x00').is_socket(), False)
+
+    def test_is_char_device_true(self):
+        # os.devnull should generally be a char device.
+        P = self.cls(os.devnull)
+        if not P.exists():
+            self.skipTest("null device required")
+        self.assertTrue(P.is_char_device())
+        self.assertFalse(P.is_block_device())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(f'{os.devnull}\udfff').is_char_device(), False)
+        self.assertIs(self.cls(f'{os.devnull}\x00').is_char_device(), False)
+
+    def test_is_mount_root(self):
+        if os.name == 'nt':
+            R = self.cls('c:\\')
+        else:
+            R = self.cls('/')
+        self.assertTrue(R.is_mount())
+        self.assertFalse((R / '\udfff').is_mount())
+
+    def test_passing_kwargs_deprecated(self):
+        with self.assertWarns(DeprecationWarning):
+            self.cls(foo="bar")
+
+    def setUpWalk(self):
+        super().setUpWalk()
+        sub21_path= self.sub2_path / "SUB21"
+        tmp5_path = sub21_path / "tmp3"
+        broken_link3_path = self.sub2_path / "broken_link3"
+
+        os.makedirs(sub21_path)
+        tmp5_path.write_text("I am tmp5, blame test_pathlib.")
+        if self.can_symlink:
+            os.symlink(tmp5_path, broken_link3_path)
+            self.sub2_tree[2].append('broken_link3')
+            self.sub2_tree[2].sort()
+        if not is_emscripten:
+            # Emscripten fails with inaccessible directories.
+            os.chmod(sub21_path, 0)
+        try:
+            os.listdir(sub21_path)
+        except PermissionError:
+            self.sub2_tree[1].append('SUB21')
+        else:
+            os.chmod(sub21_path, stat.S_IRWXU)
+            os.unlink(tmp5_path)
+            os.rmdir(sub21_path)
+
+    def test_walk_bad_dir(self):
+        self.setUpWalk()
+        errors = []
+        walk_it = self.walk_path.walk(on_error=errors.append)
+        root, dirs, files = next(walk_it)
+        self.assertEqual(errors, [])
+        dir1 = 'SUB1'
+        path1 = root / dir1
+        path1new = (root / dir1).with_suffix(".new")
+        path1.rename(path1new)
+        try:
+            roots = [r for r, _, _ in walk_it]
+            self.assertTrue(errors)
+            self.assertNotIn(path1, roots)
+            self.assertNotIn(path1new, roots)
+            for dir2 in dirs:
+                if dir2 != dir1:
+                    self.assertIn(root / dir2, roots)
+        finally:
+            path1new.rename(path1)
+
+    def test_walk_many_open_files(self):
+        depth = 30
+        base = self.cls(self.base, 'deep')
+        path = self.cls(base, *(['d']*depth))
+        path.mkdir(parents=True)
+
+        iters = [base.walk(top_down=False) for _ in range(100)]
+        for i in range(depth + 1):
+            expected = (path, ['d'] if i else [], [])
+            for it in iters:
+                self.assertEqual(next(it), expected)
+            path = path.parent
+
+        iters = [base.walk(top_down=True) for _ in range(100)]
+        path = base
+        for i in range(depth + 1):
+            expected = (path, ['d'] if i < depth else [], [])
+            for it in iters:
+                self.assertEqual(next(it), expected)
+            path = path / 'd'
+
+    def test_walk_above_recursion_limit(self):
+        recursion_limit = 40
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = self.cls(self.base, 'deep')
+        path = base.joinpath(*(['d'] * directory_depth))
+        path.mkdir(parents=True)
+
+        with infinite_recursion(recursion_limit):
+            list(base.walk())
+            list(base.walk(top_down=False))
+
+    def test_glob_empty_pattern(self):
+        p = self.cls('')
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob(''))
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob('.'))
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob('./'))
+
+    def test_glob_many_open_files(self):
+        depth = 30
+        P = self.cls
+        p = base = P(self.base) / 'deep'
+        p.mkdir()
+        for _ in range(depth):
+            p /= 'd'
+            p.mkdir()
+        pattern = '/'.join(['*'] * depth)
+        iters = [base.glob(pattern) for j in range(100)]
+        for it in iters:
+            self.assertEqual(next(it), p)
+        iters = [base.rglob('d') for j in range(100)]
+        p = base
+        for i in range(depth):
+            p = p / 'd'
+            for it in iters:
+                self.assertEqual(next(it), p)
+
+    def test_glob_above_recursion_limit(self):
+        recursion_limit = 50
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = self.cls(self.base, 'deep')
+        path = base.joinpath(*(['d'] * directory_depth))
+        path.mkdir(parents=True)
+
+        with infinite_recursion(recursion_limit):
+            list(base.glob('**/'))
+
+    def test_glob_pathlike(self):
+        P = self.cls
+        p = P(self.base)
+        pattern = "dir*/file*"
+        expect = {p / "dirB/fileB", p / "dirC/fileC"}
+        self.assertEqual(expect, set(p.glob(P(pattern))))
+        self.assertEqual(expect, set(p.glob(FakePath(pattern))))
+
+    @needs_symlinks
+    def test_glob_dot(self):
+        P = self.cls
+        with os_helper.change_cwd(P(self.base, "dirC")):
+            self.assertEqual(
+                set(P('.').glob('*')), {P("fileC"), P("novel.txt"), P("dirD")})
+            self.assertEqual(
+                set(P('.').glob('**')), {P("fileC"), P("novel.txt"), P("dirD"), P("dirD/fileD"), P(".")})
+            self.assertEqual(
+                set(P('.').glob('**/*')), {P("fileC"), P("novel.txt"), P("dirD"), P("dirD/fileD")})
+            self.assertEqual(
+                set(P('.').glob('**/*/*')), {P("dirD/fileD")})
+
+    def test_glob_inaccessible(self):
+        P = self.cls
+        p = P(self.base, "mydir1", "mydir2")
+        p.mkdir(parents=True)
+        p.parent.chmod(0)
+        self.assertEqual(set(p.glob('*')), set())
+
+    def test_rglob_pathlike(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        pattern = "**/file*"
+        expect = {p / "fileC", p / "dirD/fileD"}
+        self.assertEqual(expect, set(p.rglob(P(pattern))))
+        self.assertEqual(expect, set(p.rglob(FakePath(pattern))))
+
+    @needs_posix
+    def test_absolute_posix(self):
+        P = self.cls
+        self.assertEqual(str(P('/').absolute()), '/')
+        self.assertEqual(str(P('/a').absolute()), '/a')
+        self.assertEqual(str(P('/a/b').absolute()), '/a/b')
+
+        # '//'-prefixed absolute path (supported by POSIX).
+        self.assertEqual(str(P('//').absolute()), '//')
+        self.assertEqual(str(P('//a').absolute()), '//a')
+        self.assertEqual(str(P('//a/b').absolute()), '//a/b')
+
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    @needs_posix
+    def test_open_mode(self):
+        # Unmask all permissions except world-write, which may
+        # not be supported on some filesystems (see GH-85633.)
+        old_mask = os.umask(0o002)
+        self.addCleanup(os.umask, old_mask)
+        p = self.cls(self.base)
+        with (p / 'new_file').open('wb'):
+            pass
+        st = os.stat(self.parser.join(self.base, 'new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o664)
+        os.umask(0o026)
+        with (p / 'other_new_file').open('wb'):
+            pass
+        st = os.stat(self.parser.join(self.base, 'other_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o640)
+
+    @needs_posix
+    def test_resolve_root(self):
+        current_directory = os.getcwd()
+        try:
+            os.chdir('/')
+            p = self.cls('spam')
+            self.assertEqual(str(p.resolve()), '/spam')
+        finally:
+            os.chdir(current_directory)
+
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    @needs_posix
+    def test_touch_mode(self):
+        # Unmask all permissions except world-write, which may
+        # not be supported on some filesystems (see GH-85633.)
+        old_mask = os.umask(0o002)
+        self.addCleanup(os.umask, old_mask)
+        p = self.cls(self.base)
+        (p / 'new_file').touch()
+        st = os.stat(self.parser.join(self.base, 'new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o664)
+        os.umask(0o026)
+        (p / 'other_new_file').touch()
+        st = os.stat(self.parser.join(self.base, 'other_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o640)
+        (p / 'masked_new_file').touch(mode=0o750)
+        st = os.stat(self.parser.join(self.base, 'masked_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
+
+    @unittest.skipUnless(hasattr(pwd, 'getpwall'),
+                         'pwd module does not expose getpwall()')
+    @unittest.skipIf(sys.platform == "vxworks",
+                     "no home directory on VxWorks")
+    @needs_posix
+    def test_expanduser_posix(self):
+        P = self.cls
+        import_helper.import_module('pwd')
+        import pwd
+        pwdent = pwd.getpwuid(os.getuid())
+        username = pwdent.pw_name
+        userhome = pwdent.pw_dir.rstrip('/') or '/'
+        # Find arbitrary different user (if exists).
+        for pwdent in pwd.getpwall():
+            othername = pwdent.pw_name
+            otherhome = pwdent.pw_dir.rstrip('/')
+            if othername != username and otherhome:
+                break
+        else:
+            othername = username
+            otherhome = userhome
+
+        fakename = 'fakeuser'
+        # This user can theoretically exist on a test runner. Create unique name:
+        try:
+            while pwd.getpwnam(fakename):
+                fakename += '1'
+        except KeyError:
+            pass  # Non-existent name found
+
+        p1 = P('~/Documents')
+        p2 = P(f'~{username}/Documents')
+        p3 = P(f'~{othername}/Documents')
+        p4 = P(f'../~{username}/Documents')
+        p5 = P(f'/~{username}/Documents')
+        p6 = P('')
+        p7 = P(f'~{fakename}/Documents')
+
+        with os_helper.EnvironmentVarGuard() as env:
+            env.unset('HOME')
+
+            self.assertEqual(p1.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+            self.assertRaises(RuntimeError, p7.expanduser)
+
+            env['HOME'] = '/tmp'
+            self.assertEqual(p1.expanduser(), P('/tmp/Documents'))
+            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+            self.assertRaises(RuntimeError, p7.expanduser)
+
+    @unittest.skipIf(sys.platform != "darwin",
+                     "Bad file descriptor in /dev/fd affects only macOS")
+    @needs_posix
+    def test_handling_bad_descriptor(self):
+        try:
+            file_descriptors = list(pathlib.Path('/dev/fd').rglob("*"))[3:]
+            if not file_descriptors:
+                self.skipTest("no file descriptors - issue was not reproduced")
+            # Checking all file descriptors because there is no guarantee
+            # which one will fail.
+            for f in file_descriptors:
+                f.exists()
+                f.is_dir()
+                f.is_file()
+                f.is_symlink()
+                f.is_block_device()
+                f.is_char_device()
+                f.is_fifo()
+                f.is_socket()
+        except OSError as e:
+            if e.errno == errno.EBADF:
+                self.fail("Bad file descriptor not handled.")
+            raise
+
+    @needs_posix
+    def test_from_uri_posix(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:/foo/bar'), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file://foo/bar'), P('//foo/bar'))
+        self.assertEqual(P.from_uri('file:///foo/bar'), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file:////foo/bar'), P('//foo/bar'))
+        self.assertEqual(P.from_uri('file://localhost/foo/bar'), P('/foo/bar'))
+        self.assertRaises(ValueError, P.from_uri, 'foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '/foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '//foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'file:foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'http://foo/bar')
+
+    @needs_posix
+    def test_from_uri_pathname2url_posix(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:' + pathname2url('/foo/bar')), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file:' + pathname2url('//foo/bar')), P('//foo/bar'))
+
+    @needs_windows
+    def test_absolute_windows(self):
+        P = self.cls
+
+        # Simple absolute paths.
+        self.assertEqual(str(P('c:\\').absolute()), 'c:\\')
+        self.assertEqual(str(P('c:\\a').absolute()), 'c:\\a')
+        self.assertEqual(str(P('c:\\a\\b').absolute()), 'c:\\a\\b')
+
+        # UNC absolute paths.
+        share = '\\\\server\\share\\'
+        self.assertEqual(str(P(share).absolute()), share)
+        self.assertEqual(str(P(share + 'a').absolute()), share + 'a')
+        self.assertEqual(str(P(share + 'a\\b').absolute()), share + 'a\\b')
+
+        # UNC relative paths.
+        with mock.patch("os.getcwd") as getcwd:
+            getcwd.return_value = share
+
+            self.assertEqual(str(P().absolute()), share)
+            self.assertEqual(str(P('.').absolute()), share)
+            self.assertEqual(str(P('a').absolute()), os.path.join(share, 'a'))
+            self.assertEqual(str(P('a', 'b', 'c').absolute()),
+                             os.path.join(share, 'a', 'b', 'c'))
+
+        drive = os.path.splitdrive(self.base)[0]
+        with os_helper.change_cwd(self.base):
+            # Relative path with root
+            self.assertEqual(str(P('\\').absolute()), drive + '\\')
+            self.assertEqual(str(P('\\foo').absolute()), drive + '\\foo')
+
+            # Relative path on current drive
+            self.assertEqual(str(P(drive).absolute()), self.base)
+            self.assertEqual(str(P(drive + 'foo').absolute()), os.path.join(self.base, 'foo'))
+
+        with os_helper.subst_drive(self.base) as other_drive:
+            # Set the working directory on the substitute drive
+            saved_cwd = os.getcwd()
+            other_cwd = f'{other_drive}\\dirA'
+            os.chdir(other_cwd)
+            os.chdir(saved_cwd)
+
+            # Relative path on another drive
+            self.assertEqual(str(P(other_drive).absolute()), other_cwd)
+            self.assertEqual(str(P(other_drive + 'foo').absolute()), other_cwd + '\\foo')
+
+    @needs_windows
+    def test_expanduser_windows(self):
+        P = self.cls
+        with os_helper.EnvironmentVarGuard() as env:
+            env.unset('HOME', 'USERPROFILE', 'HOMEPATH', 'HOMEDRIVE')
+            env['USERNAME'] = 'alice'
+
+            # test that the path returns unchanged
+            p1 = P('~/My Documents')
+            p2 = P('~alice/My Documents')
+            p3 = P('~bob/My Documents')
+            p4 = P('/~/My Documents')
+            p5 = P('d:~/My Documents')
+            p6 = P('')
+            self.assertRaises(RuntimeError, p1.expanduser)
+            self.assertRaises(RuntimeError, p2.expanduser)
+            self.assertRaises(RuntimeError, p3.expanduser)
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+
+            def check():
+                env.pop('USERNAME', None)
+                self.assertEqual(p1.expanduser(),
+                                 P('C:/Users/alice/My Documents'))
+                self.assertRaises(RuntimeError, p2.expanduser)
+                env['USERNAME'] = 'alice'
+                self.assertEqual(p2.expanduser(),
+                                 P('C:/Users/alice/My Documents'))
+                self.assertEqual(p3.expanduser(),
+                                 P('C:/Users/bob/My Documents'))
+                self.assertEqual(p4.expanduser(), p4)
+                self.assertEqual(p5.expanduser(), p5)
+                self.assertEqual(p6.expanduser(), p6)
+
+            env['HOMEPATH'] = 'C:\\Users\\alice'
+            check()
+
+            env['HOMEDRIVE'] = 'C:\\'
+            env['HOMEPATH'] = 'Users\\alice'
+            check()
+
+            env.unset('HOMEDRIVE', 'HOMEPATH')
+            env['USERPROFILE'] = 'C:\\Users\\alice'
+            check()
+
+            # bpo-38883: ignore `HOME` when set on windows
+            env['HOME'] = 'C:\\Users\\eve'
+            check()
+
+    @needs_windows
+    def test_from_uri_windows(self):
+        P = self.cls
+        # DOS drive paths
+        self.assertEqual(P.from_uri('file:c:/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:c|/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:/c|/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:///c|/path/to/file'), P('c:/path/to/file'))
+        # UNC paths
+        self.assertEqual(P.from_uri('file://server/path/to/file'), P('//server/path/to/file'))
+        self.assertEqual(P.from_uri('file:////server/path/to/file'), P('//server/path/to/file'))
+        self.assertEqual(P.from_uri('file://///server/path/to/file'), P('//server/path/to/file'))
+        # Localhost paths
+        self.assertEqual(P.from_uri('file://localhost/c:/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file://localhost/c|/path/to/file'), P('c:/path/to/file'))
+        # Invalid paths
+        self.assertRaises(ValueError, P.from_uri, 'foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'c:/foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '//foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'file:foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'http://foo/bar')
+
+    @needs_windows
+    def test_from_uri_pathname2url_windows(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:' + pathname2url(r'c:\path\to\file')), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:' + pathname2url(r'\\server\path\to\file')), P('//server/path/to/file'))
+
+    @needs_windows
+    def test_owner_windows(self):
+        P = self.cls
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            P('c:/').owner()
+
+    @needs_windows
+    def test_group_windows(self):
+        P = self.cls
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            P('c:/').group()
+
+
+@unittest.skipIf(os.name == 'nt', 'test requires a POSIX-compatible system')
+class PosixPathTest(PathTest, PurePosixPathTest):
+    cls = pathlib.PosixPath
+
+
+@unittest.skipIf(os.name != 'nt', 'test requires a Windows-compatible system')
+class WindowsPathTest(PathTest, PureWindowsPathTest):
+    cls = pathlib.WindowsPath
+
+
+class PathSubclassTest(PathTest):
+    class cls(pathlib.Path):
+        pass
+
+    # repr() roundtripping is not supported in custom subclass.
+    test_repr_roundtrips = None
+
+
+class CompatiblePathTest(unittest.TestCase):
+    """
+    Test that a type can be made compatible with PurePath
+    derivatives by implementing division operator overloads.
+    """
+
+    class CompatPath:
+        """
+        Minimum viable class to test PurePath compatibility.
+        Simply uses the division operator to join a given
+        string and the string value of another object with
+        a forward slash.
+        """
+        def __init__(self, string):
+            self.string = string
+
+        def __truediv__(self, other):
+            return type(self)(f"{self.string}/{other}")
+
+        def __rtruediv__(self, other):
+            return type(self)(f"{other}/{self.string}")
+
+    def test_truediv(self):
+        result = pathlib.PurePath("test") / self.CompatPath("right")
+        self.assertIsInstance(result, self.CompatPath)
+        self.assertEqual(result.string, "test/right")
+
+        with self.assertRaises(TypeError):
+            # Verify improper operations still raise a TypeError
+            pathlib.PurePath("test") / 10
+
+    def test_rtruediv(self):
+        result = self.CompatPath("left") / pathlib.PurePath("test")
+        self.assertIsInstance(result, self.CompatPath)
+        self.assertEqual(result.string, "left/test")
+
+        with self.assertRaises(TypeError):
+            # Verify improper operations still raise a TypeError
+            10 / pathlib.PurePath("test")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_pathlib_abc.py b/Lib/test/test_pathlib/test_pathlib_abc.py
new file mode 100644
index 00000000000..2e050362158
--- /dev/null
+++ b/Lib/test/test_pathlib/test_pathlib_abc.py
@@ -0,0 +1,2499 @@
+# TODO: RUSTPYTHON
+# Has not been tested with Windows style paths
+import collections
+import io
+import os
+import errno
+import stat
+import unittest
+
+from pathlib._abc import UnsupportedOperation, ParserBase, PurePathBase, PathBase
+import posixpath
+
+from test.support import is_wasi
+from test.support.os_helper import TESTFN
+
+
+_tests_needing_posix = set()
+_tests_needing_windows = set()
+_tests_needing_symlinks = set()
+
+
+def needs_posix(fn):
+    """Decorator that marks a test as requiring a POSIX-flavoured path class."""
+    _tests_needing_posix.add(fn.__name__)
+    return fn
+
+def needs_windows(fn):
+    """Decorator that marks a test as requiring a Windows-flavoured path class."""
+    _tests_needing_windows.add(fn.__name__)
+    return fn
+
+def needs_symlinks(fn):
+    """Decorator that marks a test as requiring a path class that supports symlinks."""
+    _tests_needing_symlinks.add(fn.__name__)
+    return fn
+
+
+class UnsupportedOperationTest(unittest.TestCase):
+    def test_is_notimplemented(self):
+        self.assertTrue(issubclass(UnsupportedOperation, NotImplementedError))
+        self.assertTrue(isinstance(UnsupportedOperation(), NotImplementedError))
+
+
+class ParserBaseTest(unittest.TestCase):
+    cls = ParserBase
+
+    def test_unsupported_operation(self):
+        m = self.cls()
+        e = UnsupportedOperation
+        with self.assertRaises(e):
+            m.sep
+        self.assertRaises(e, m.join, 'foo')
+        self.assertRaises(e, m.split, 'foo')
+        self.assertRaises(e, m.splitdrive, 'foo')
+        self.assertRaises(e, m.normcase, 'foo')
+        self.assertRaises(e, m.isabs, 'foo')
+
+#
+# Tests for the pure classes.
+#
+
+
+class PurePathBaseTest(unittest.TestCase):
+    cls = PurePathBase
+
+    def test_unsupported_operation_pure(self):
+        p = self.cls('foo')
+        e = UnsupportedOperation
+        with self.assertRaises(e):
+            p.drive
+        with self.assertRaises(e):
+            p.root
+        with self.assertRaises(e):
+            p.anchor
+        with self.assertRaises(e):
+            p.parts
+        with self.assertRaises(e):
+            p.parent
+        with self.assertRaises(e):
+            p.parents
+        with self.assertRaises(e):
+            p.name
+        with self.assertRaises(e):
+            p.stem
+        with self.assertRaises(e):
+            p.suffix
+        with self.assertRaises(e):
+            p.suffixes
+        with self.assertRaises(e):
+            p / 'bar'
+        with self.assertRaises(e):
+            'bar' / p
+        self.assertRaises(e, p.joinpath, 'bar')
+        self.assertRaises(e, p.with_name, 'bar')
+        self.assertRaises(e, p.with_stem, 'bar')
+        self.assertRaises(e, p.with_suffix, '.txt')
+        self.assertRaises(e, p.relative_to, '')
+        self.assertRaises(e, p.is_relative_to, '')
+        self.assertRaises(e, p.is_absolute)
+        self.assertRaises(e, p.match, '*')
+
+    def test_magic_methods(self):
+        P = self.cls
+        self.assertFalse(hasattr(P, '__fspath__'))
+        self.assertFalse(hasattr(P, '__bytes__'))
+        self.assertIs(P.__reduce__, object.__reduce__)
+        self.assertIs(P.__repr__, object.__repr__)
+        self.assertIs(P.__hash__, object.__hash__)
+        self.assertIs(P.__eq__, object.__eq__)
+        self.assertIs(P.__lt__, object.__lt__)
+        self.assertIs(P.__le__, object.__le__)
+        self.assertIs(P.__gt__, object.__gt__)
+        self.assertIs(P.__ge__, object.__ge__)
+
+    def test_parser(self):
+        self.assertIsInstance(self.cls.parser, ParserBase)
+
+
+class DummyPurePath(PurePathBase):
+    __slots__ = ()
+    parser = posixpath
+
+    def __eq__(self, other):
+        if not isinstance(other, DummyPurePath):
+            return NotImplemented
+        return str(self) == str(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+
+class DummyPurePathTest(unittest.TestCase):
+    cls = DummyPurePath
+
+    # Use a base path that's unrelated to any real filesystem path.
+    base = f'/this/path/kills/fascists/{TESTFN}'
+
+    def setUp(self):
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_posix and self.cls.parser is not posixpath:
+            self.skipTest('requires POSIX-flavoured path class')
+        if name in _tests_needing_windows and self.cls.parser is posixpath:
+            self.skipTest('requires Windows-flavoured path class')
+        p = self.cls('a')
+        self.parser = p.parser
+        self.sep = self.parser.sep
+        self.altsep = self.parser.altsep
+
+    def test_constructor_common(self):
+        P = self.cls
+        p = P('a')
+        self.assertIsInstance(p, P)
+        P('a', 'b', 'c')
+        P('/a', 'b', 'c')
+        P('a/b/c')
+        P('/a/b/c')
+
+    def test_bytes(self):
+        P = self.cls
+        with self.assertRaises(TypeError):
+            P(b'a')
+        with self.assertRaises(TypeError):
+            P(b'a', 'b')
+        with self.assertRaises(TypeError):
+            P('a', b'b')
+        with self.assertRaises(TypeError):
+            P('a').joinpath(b'b')
+        with self.assertRaises(TypeError):
+            P('a') / b'b'
+        with self.assertRaises(TypeError):
+            b'a' / P('b')
+        with self.assertRaises(TypeError):
+            P('a').match(b'b')
+        with self.assertRaises(TypeError):
+            P('a').relative_to(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_name(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_stem(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_suffix(b'b')
+
+    def _check_str_subclass(self, *args):
+        # Issue #21127: it should be possible to construct a PurePath object
+        # from a str subclass instance, and it then gets converted to
+        # a pure str object.
+        class StrSubclass(str):
+            pass
+        P = self.cls
+        p = P(*(StrSubclass(x) for x in args))
+        self.assertEqual(p, P(*args))
+        for part in p.parts:
+            self.assertIs(type(part), str)
+
+    def test_str_subclass_common(self):
+        self._check_str_subclass('')
+        self._check_str_subclass('.')
+        self._check_str_subclass('a')
+        self._check_str_subclass('a/b.txt')
+        self._check_str_subclass('/a/b.txt')
+
+    @needs_windows
+    def test_str_subclass_windows(self):
+        self._check_str_subclass('.\\a:b')
+        self._check_str_subclass('c:')
+        self._check_str_subclass('c:a')
+        self._check_str_subclass('c:a\\b.txt')
+        self._check_str_subclass('c:\\')
+        self._check_str_subclass('c:\\a')
+        self._check_str_subclass('c:\\a\\b.txt')
+        self._check_str_subclass('\\\\some\\share')
+        self._check_str_subclass('\\\\some\\share\\a')
+        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
+
+    def test_with_segments_common(self):
+        class P(self.cls):
+            def __init__(self, *pathsegments, session_id):
+                super().__init__(*pathsegments)
+                self.session_id = session_id
+
+            def with_segments(self, *pathsegments):
+                return type(self)(*pathsegments, session_id=self.session_id)
+        p = P('foo', 'bar', session_id=42)
+        self.assertEqual(42, (p / 'foo').session_id)
+        self.assertEqual(42, ('foo' / p).session_id)
+        self.assertEqual(42, p.joinpath('foo').session_id)
+        self.assertEqual(42, p.with_name('foo').session_id)
+        self.assertEqual(42, p.with_stem('foo').session_id)
+        self.assertEqual(42, p.with_suffix('.foo').session_id)
+        self.assertEqual(42, p.with_segments('foo').session_id)
+        self.assertEqual(42, p.relative_to('foo').session_id)
+        self.assertEqual(42, p.parent.session_id)
+        for parent in p.parents:
+            self.assertEqual(42, parent.session_id)
+
+    def test_join_common(self):
+        P = self.cls
+        p = P('a/b')
+        pp = p.joinpath('c')
+        self.assertEqual(pp, P('a/b/c'))
+        self.assertIs(type(pp), type(p))
+        pp = p.joinpath('c', 'd')
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = p.joinpath('/c')
+        self.assertEqual(pp, P('/c'))
+
+    @needs_posix
+    def test_join_posix(self):
+        P = self.cls
+        p = P('//a')
+        pp = p.joinpath('b')
+        self.assertEqual(pp, P('//a/b'))
+        pp = P('/a').joinpath('//c')
+        self.assertEqual(pp, P('//c'))
+        pp = P('//a').joinpath('/c')
+        self.assertEqual(pp, P('/c'))
+
+    @needs_windows
+    def test_join_windows(self):
+        P = self.cls
+        p = P('C:/a/b')
+        pp = p.joinpath('x/y')
+        self.assertEqual(pp, P('C:/a/b/x/y'))
+        pp = p.joinpath('/x/y')
+        self.assertEqual(pp, P('C:/x/y'))
+        # Joining with a different drive => the first path is ignored, even
+        # if the second path is relative.
+        pp = p.joinpath('D:x/y')
+        self.assertEqual(pp, P('D:x/y'))
+        pp = p.joinpath('D:/x/y')
+        self.assertEqual(pp, P('D:/x/y'))
+        pp = p.joinpath('//host/share/x/y')
+        self.assertEqual(pp, P('//host/share/x/y'))
+        # Joining with the same drive => the first path is appended to if
+        # the second path is relative.
+        pp = p.joinpath('c:x/y')
+        self.assertEqual(pp, P('C:/a/b/x/y'))
+        pp = p.joinpath('c:/x/y')
+        self.assertEqual(pp, P('C:/x/y'))
+        # Joining with files with NTFS data streams => the filename should
+        # not be parsed as a drive letter
+        pp = p.joinpath(P('./d:s'))
+        self.assertEqual(pp, P('C:/a/b/d:s'))
+        pp = p.joinpath(P('./dd:s'))
+        self.assertEqual(pp, P('C:/a/b/dd:s'))
+        pp = p.joinpath(P('E:d:s'))
+        self.assertEqual(pp, P('E:d:s'))
+        # Joining onto a UNC path with no root
+        pp = P('//').joinpath('server')
+        self.assertEqual(pp, P('//server'))
+        pp = P('//server').joinpath('share')
+        self.assertEqual(pp, P('//server/share'))
+        pp = P('//./BootPartition').joinpath('Windows')
+        self.assertEqual(pp, P('//./BootPartition/Windows'))
+
+    def test_div_common(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('a/b')
+        pp = p / 'c'
+        self.assertEqual(pp, P('a/b/c'))
+        self.assertIs(type(pp), type(p))
+        pp = p / 'c/d'
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = p / 'c' / 'd'
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = 'c' / p / 'd'
+        self.assertEqual(pp, P('c/a/b/d'))
+        pp = p/ '/c'
+        self.assertEqual(pp, P('/c'))
+
+    @needs_posix
+    def test_div_posix(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('//a')
+        pp = p / 'b'
+        self.assertEqual(pp, P('//a/b'))
+        pp = P('/a') / '//c'
+        self.assertEqual(pp, P('//c'))
+        pp = P('//a') / '/c'
+        self.assertEqual(pp, P('/c'))
+
+    @needs_windows
+    def test_div_windows(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('C:/a/b')
+        self.assertEqual(p / 'x/y', P('C:/a/b/x/y'))
+        self.assertEqual(p / 'x' / 'y', P('C:/a/b/x/y'))
+        self.assertEqual(p / '/x/y', P('C:/x/y'))
+        self.assertEqual(p / '/x' / 'y', P('C:/x/y'))
+        # Joining with a different drive => the first path is ignored, even
+        # if the second path is relative.
+        self.assertEqual(p / 'D:x/y', P('D:x/y'))
+        self.assertEqual(p / 'D:' / 'x/y', P('D:x/y'))
+        self.assertEqual(p / 'D:/x/y', P('D:/x/y'))
+        self.assertEqual(p / 'D:' / '/x/y', P('D:/x/y'))
+        self.assertEqual(p / '//host/share/x/y', P('//host/share/x/y'))
+        # Joining with the same drive => the first path is appended to if
+        # the second path is relative.
+        self.assertEqual(p / 'c:x/y', P('C:/a/b/x/y'))
+        self.assertEqual(p / 'c:/x/y', P('C:/x/y'))
+        # Joining with files with NTFS data streams => the filename should
+        # not be parsed as a drive letter
+        self.assertEqual(p / P('./d:s'), P('C:/a/b/d:s'))
+        self.assertEqual(p / P('./dd:s'), P('C:/a/b/dd:s'))
+        self.assertEqual(p / P('E:d:s'), P('E:d:s'))
+
+    def _check_str(self, expected, args):
+        p = self.cls(*args)
+        self.assertEqual(str(p), expected.replace('/', self.sep))
+
+    def test_str_common(self):
+        # Canonicalized paths roundtrip.
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            self._check_str(pathstr, (pathstr,))
+        # Other tests for str() are in test_equivalences().
+
+    @needs_windows
+    def test_str_windows(self):
+        p = self.cls('a/b/c')
+        self.assertEqual(str(p), 'a\\b\\c')
+        p = self.cls('c:/a/b/c')
+        self.assertEqual(str(p), 'c:\\a\\b\\c')
+        p = self.cls('//a/b')
+        self.assertEqual(str(p), '\\\\a\\b\\')
+        p = self.cls('//a/b/c')
+        self.assertEqual(str(p), '\\\\a\\b\\c')
+        p = self.cls('//a/b/c/d')
+        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
+
+    def test_as_posix_common(self):
+        P = self.cls
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            self.assertEqual(P(pathstr).as_posix(), pathstr)
+        # Other tests for as_posix() are in test_equivalences().
+
+    def test_match_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a').match, '')
+
+    def test_match_common(self):
+        P = self.cls
+        # Simple relative pattern.
+        self.assertTrue(P('b.py').match('b.py'))
+        self.assertTrue(P('a/b.py').match('b.py'))
+        self.assertTrue(P('/a/b.py').match('b.py'))
+        self.assertFalse(P('a.py').match('b.py'))
+        self.assertFalse(P('b/py').match('b.py'))
+        self.assertFalse(P('/a.py').match('b.py'))
+        self.assertFalse(P('b.py/c').match('b.py'))
+        # Wildcard relative pattern.
+        self.assertTrue(P('b.py').match('*.py'))
+        self.assertTrue(P('a/b.py').match('*.py'))
+        self.assertTrue(P('/a/b.py').match('*.py'))
+        self.assertFalse(P('b.pyc').match('*.py'))
+        self.assertFalse(P('b./py').match('*.py'))
+        self.assertFalse(P('b.py/c').match('*.py'))
+        # Multi-part relative pattern.
+        self.assertTrue(P('ab/c.py').match('a*/*.py'))
+        self.assertTrue(P('/d/ab/c.py').match('a*/*.py'))
+        self.assertFalse(P('a.py').match('a*/*.py'))
+        self.assertFalse(P('/dab/c.py').match('a*/*.py'))
+        self.assertFalse(P('ab/c.py/d').match('a*/*.py'))
+        # Absolute pattern.
+        self.assertTrue(P('/b.py').match('/*.py'))
+        self.assertFalse(P('b.py').match('/*.py'))
+        self.assertFalse(P('a/b.py').match('/*.py'))
+        self.assertFalse(P('/a/b.py').match('/*.py'))
+        # Multi-part absolute pattern.
+        self.assertTrue(P('/a/b.py').match('/a/*.py'))
+        self.assertFalse(P('/ab.py').match('/a/*.py'))
+        self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
+        # Multi-part glob-style pattern.
+        self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
+        # Case-sensitive flag
+        self.assertFalse(P('A.py').match('a.PY', case_sensitive=True))
+        self.assertTrue(P('A.py').match('a.PY', case_sensitive=False))
+        self.assertFalse(P('c:/a/B.Py').match('C:/A/*.pY', case_sensitive=True))
+        self.assertTrue(P('/a/b/c.py').match('/A/*/*.Py', case_sensitive=False))
+        # Matching against empty path
+        self.assertFalse(P('').match('*'))
+        self.assertFalse(P('').match('**'))
+        self.assertFalse(P('').match('**/*'))
+
+    @needs_posix
+    def test_match_posix(self):
+        P = self.cls
+        self.assertFalse(P('A.py').match('a.PY'))
+
+    @needs_windows
+    def test_match_windows(self):
+        P = self.cls
+        # Absolute patterns.
+        self.assertTrue(P('c:/b.py').match('*:/*.py'))
+        self.assertTrue(P('c:/b.py').match('c:/*.py'))
+        self.assertFalse(P('d:/b.py').match('c:/*.py'))  # wrong drive
+        self.assertFalse(P('b.py').match('/*.py'))
+        self.assertFalse(P('b.py').match('c:*.py'))
+        self.assertFalse(P('b.py').match('c:/*.py'))
+        self.assertFalse(P('c:b.py').match('/*.py'))
+        self.assertFalse(P('c:b.py').match('c:/*.py'))
+        self.assertFalse(P('/b.py').match('c:*.py'))
+        self.assertFalse(P('/b.py').match('c:/*.py'))
+        # UNC patterns.
+        self.assertTrue(P('//some/share/a.py').match('//*/*/*.py'))
+        self.assertTrue(P('//some/share/a.py').match('//some/share/*.py'))
+        self.assertFalse(P('//other/share/a.py').match('//some/share/*.py'))
+        self.assertFalse(P('//some/share/a/b.py').match('//some/share/*.py'))
+        # Case-insensitivity.
+        self.assertTrue(P('B.py').match('b.PY'))
+        self.assertTrue(P('c:/a/B.Py').match('C:/A/*.pY'))
+        self.assertTrue(P('//Some/Share/B.Py').match('//somE/sharE/*.pY'))
+        # Path anchor doesn't match pattern anchor
+        self.assertFalse(P('c:/b.py').match('/*.py'))  # 'c:/' vs '/'
+        self.assertFalse(P('c:/b.py').match('c:*.py'))  # 'c:/' vs 'c:'
+        self.assertFalse(P('//some/share/a.py').match('/*.py'))  # '//some/share/' vs '/'
+
+    def test_full_match_common(self):
+        P = self.cls
+        # Simple relative pattern.
+        self.assertTrue(P('b.py').full_match('b.py'))
+        self.assertFalse(P('a/b.py').full_match('b.py'))
+        self.assertFalse(P('/a/b.py').full_match('b.py'))
+        self.assertFalse(P('a.py').full_match('b.py'))
+        self.assertFalse(P('b/py').full_match('b.py'))
+        self.assertFalse(P('/a.py').full_match('b.py'))
+        self.assertFalse(P('b.py/c').full_match('b.py'))
+        # Wildcard relative pattern.
+        self.assertTrue(P('b.py').full_match('*.py'))
+        self.assertFalse(P('a/b.py').full_match('*.py'))
+        self.assertFalse(P('/a/b.py').full_match('*.py'))
+        self.assertFalse(P('b.pyc').full_match('*.py'))
+        self.assertFalse(P('b./py').full_match('*.py'))
+        self.assertFalse(P('b.py/c').full_match('*.py'))
+        # Multi-part relative pattern.
+        self.assertTrue(P('ab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('/d/ab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('a.py').full_match('a*/*.py'))
+        self.assertFalse(P('/dab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('ab/c.py/d').full_match('a*/*.py'))
+        # Absolute pattern.
+        self.assertTrue(P('/b.py').full_match('/*.py'))
+        self.assertFalse(P('b.py').full_match('/*.py'))
+        self.assertFalse(P('a/b.py').full_match('/*.py'))
+        self.assertFalse(P('/a/b.py').full_match('/*.py'))
+        # Multi-part absolute pattern.
+        self.assertTrue(P('/a/b.py').full_match('/a/*.py'))
+        self.assertFalse(P('/ab.py').full_match('/a/*.py'))
+        self.assertFalse(P('/a/b/c.py').full_match('/a/*.py'))
+        # Multi-part glob-style pattern.
+        self.assertTrue(P('a').full_match('**'))
+        self.assertTrue(P('c.py').full_match('**'))
+        self.assertTrue(P('a/b/c.py').full_match('**'))
+        self.assertTrue(P('/a/b/c.py').full_match('**'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/**'))
+        self.assertTrue(P('/a/b/c.py').full_match('**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/b/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**/**/**/**/*.py'))
+        self.assertFalse(P('c.py').full_match('**/a.py'))
+        self.assertFalse(P('c.py').full_match('c/**'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c.'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
+        self.assertFalse(P('a/b/c.py').full_match('/a/b/c.py/**'))
+        self.assertFalse(P('a/b/c.py').full_match('/**/a/b/c.py'))
+        # Case-sensitive flag
+        self.assertFalse(P('A.py').full_match('a.PY', case_sensitive=True))
+        self.assertTrue(P('A.py').full_match('a.PY', case_sensitive=False))
+        self.assertFalse(P('c:/a/B.Py').full_match('C:/A/*.pY', case_sensitive=True))
+        self.assertTrue(P('/a/b/c.py').full_match('/A/*/*.Py', case_sensitive=False))
+        # Matching against empty path
+        self.assertFalse(P('').full_match('*'))
+        self.assertTrue(P('').full_match('**'))
+        self.assertFalse(P('').full_match('**/*'))
+        # Matching with empty pattern
+        self.assertTrue(P('').full_match(''))
+        self.assertTrue(P('.').full_match('.'))
+        self.assertFalse(P('/').full_match(''))
+        self.assertFalse(P('/').full_match('.'))
+        self.assertFalse(P('foo').full_match(''))
+        self.assertFalse(P('foo').full_match('.'))
+
+    def test_parts_common(self):
+        # `parts` returns a tuple.
+        sep = self.sep
+        P = self.cls
+        p = P('a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('a', 'b'))
+        # When the path is absolute, the anchor is a separate part.
+        p = P('/a/b')
+        parts = p.parts
+        self.assertEqual(parts, (sep, 'a', 'b'))
+
+    @needs_windows
+    def test_parts_windows(self):
+        P = self.cls
+        p = P('c:a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:', 'a', 'b'))
+        p = P('c:/a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:\\', 'a', 'b'))
+        p = P('//a/b/c/d')
+        parts = p.parts
+        self.assertEqual(parts, ('\\\\a\\b\\', 'c', 'd'))
+
+    def test_parent_common(self):
+        # Relative
+        P = self.cls
+        p = P('a/b/c')
+        self.assertEqual(p.parent, P('a/b'))
+        self.assertEqual(p.parent.parent, P('a'))
+        self.assertEqual(p.parent.parent.parent, P(''))
+        self.assertEqual(p.parent.parent.parent.parent, P(''))
+        # Anchored
+        p = P('/a/b/c')
+        self.assertEqual(p.parent, P('/a/b'))
+        self.assertEqual(p.parent.parent, P('/a'))
+        self.assertEqual(p.parent.parent.parent, P('/'))
+        self.assertEqual(p.parent.parent.parent.parent, P('/'))
+
+    @needs_windows
+    def test_parent_windows(self):
+        # Anchored
+        P = self.cls
+        p = P('z:a/b/c')
+        self.assertEqual(p.parent, P('z:a/b'))
+        self.assertEqual(p.parent.parent, P('z:a'))
+        self.assertEqual(p.parent.parent.parent, P('z:'))
+        self.assertEqual(p.parent.parent.parent.parent, P('z:'))
+        p = P('z:/a/b/c')
+        self.assertEqual(p.parent, P('z:/a/b'))
+        self.assertEqual(p.parent.parent, P('z:/a'))
+        self.assertEqual(p.parent.parent.parent, P('z:/'))
+        self.assertEqual(p.parent.parent.parent.parent, P('z:/'))
+        p = P('//a/b/c/d')
+        self.assertEqual(p.parent, P('//a/b/c'))
+        self.assertEqual(p.parent.parent, P('//a/b'))
+        self.assertEqual(p.parent.parent.parent, P('//a/b'))
+
+    def test_parents_common(self):
+        # Relative
+        P = self.cls
+        p = P('a/b/c')
+        par = p.parents
+        self.assertEqual(len(par), 3)
+        self.assertEqual(par[0], P('a/b'))
+        self.assertEqual(par[1], P('a'))
+        self.assertEqual(par[2], P(''))
+        self.assertEqual(par[-1], P(''))
+        self.assertEqual(par[-2], P('a'))
+        self.assertEqual(par[-3], P('a/b'))
+        self.assertEqual(par[0:1], (P('a/b'),))
+        self.assertEqual(par[:2], (P('a/b'), P('a')))
+        self.assertEqual(par[:-1], (P('a/b'), P('a')))
+        self.assertEqual(par[1:], (P('a'), P('')))
+        self.assertEqual(par[::2], (P('a/b'), P('')))
+        self.assertEqual(par[::-1], (P(''), P('a'), P('a/b')))
+        self.assertEqual(list(par), [P('a/b'), P('a'), P('')])
+        with self.assertRaises(IndexError):
+            par[-4]
+        with self.assertRaises(IndexError):
+            par[3]
+        with self.assertRaises(TypeError):
+            par[0] = p
+        # Anchored
+        p = P('/a/b/c')
+        par = p.parents
+        self.assertEqual(len(par), 3)
+        self.assertEqual(par[0], P('/a/b'))
+        self.assertEqual(par[1], P('/a'))
+        self.assertEqual(par[2], P('/'))
+        self.assertEqual(par[-1], P('/'))
+        self.assertEqual(par[-2], P('/a'))
+        self.assertEqual(par[-3], P('/a/b'))
+        self.assertEqual(par[0:1], (P('/a/b'),))
+        self.assertEqual(par[:2], (P('/a/b'), P('/a')))
+        self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
+        self.assertEqual(par[1:], (P('/a'), P('/')))
+        self.assertEqual(par[::2], (P('/a/b'), P('/')))
+        self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
+        self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
+        with self.assertRaises(IndexError):
+            par[-4]
+        with self.assertRaises(IndexError):
+            par[3]
+
+    @needs_windows
+    def test_parents_windows(self):
+        # Anchored
+        P = self.cls
+        p = P('z:a/b/')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('z:a'))
+        self.assertEqual(par[1], P('z:'))
+        self.assertEqual(par[0:1], (P('z:a'),))
+        self.assertEqual(par[:-1], (P('z:a'),))
+        self.assertEqual(par[:2], (P('z:a'), P('z:')))
+        self.assertEqual(par[1:], (P('z:'),))
+        self.assertEqual(par[::2], (P('z:a'),))
+        self.assertEqual(par[::-1], (P('z:'), P('z:a')))
+        self.assertEqual(list(par), [P('z:a'), P('z:')])
+        with self.assertRaises(IndexError):
+            par[2]
+        p = P('z:/a/b/')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('z:/a'))
+        self.assertEqual(par[1], P('z:/'))
+        self.assertEqual(par[0:1], (P('z:/a'),))
+        self.assertEqual(par[0:-1], (P('z:/a'),))
+        self.assertEqual(par[:2], (P('z:/a'), P('z:/')))
+        self.assertEqual(par[1:], (P('z:/'),))
+        self.assertEqual(par[::2], (P('z:/a'),))
+        self.assertEqual(par[::-1], (P('z:/'), P('z:/a'),))
+        self.assertEqual(list(par), [P('z:/a'), P('z:/')])
+        with self.assertRaises(IndexError):
+            par[2]
+        p = P('//a/b/c/d')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('//a/b/c'))
+        self.assertEqual(par[1], P('//a/b'))
+        self.assertEqual(par[0:1], (P('//a/b/c'),))
+        self.assertEqual(par[0:-1], (P('//a/b/c'),))
+        self.assertEqual(par[:2], (P('//a/b/c'), P('//a/b')))
+        self.assertEqual(par[1:], (P('//a/b'),))
+        self.assertEqual(par[::2], (P('//a/b/c'),))
+        self.assertEqual(par[::-1], (P('//a/b'), P('//a/b/c')))
+        self.assertEqual(list(par), [P('//a/b/c'), P('//a/b')])
+        with self.assertRaises(IndexError):
+            par[2]
+
+    def test_drive_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').drive, '')
+        self.assertEqual(P('/a/b').drive, '')
+        self.assertEqual(P('').drive, '')
+
+    @needs_windows
+    def test_drive_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').drive, 'c:')
+        self.assertEqual(P('c:a/b').drive, 'c:')
+        self.assertEqual(P('c:/').drive, 'c:')
+        self.assertEqual(P('c:/a/b/').drive, 'c:')
+        self.assertEqual(P('//a/b').drive, '\\\\a\\b')
+        self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
+        self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
+        self.assertEqual(P('./c:a').drive, '')
+
+    def test_root_common(self):
+        P = self.cls
+        sep = self.sep
+        self.assertEqual(P('').root, '')
+        self.assertEqual(P('a/b').root, '')
+        self.assertEqual(P('/').root, sep)
+        self.assertEqual(P('/a/b').root, sep)
+
+    @needs_posix
+    def test_root_posix(self):
+        P = self.cls
+        self.assertEqual(P('/a/b').root, '/')
+        # POSIX special case for two leading slashes.
+        self.assertEqual(P('//a/b').root, '//')
+
+    @needs_windows
+    def test_root_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').root, '')
+        self.assertEqual(P('c:a/b').root, '')
+        self.assertEqual(P('c:/').root, '\\')
+        self.assertEqual(P('c:/a/b/').root, '\\')
+        self.assertEqual(P('//a/b').root, '\\')
+        self.assertEqual(P('//a/b/').root, '\\')
+        self.assertEqual(P('//a/b/c/d').root, '\\')
+
+    def test_anchor_common(self):
+        P = self.cls
+        sep = self.sep
+        self.assertEqual(P('').anchor, '')
+        self.assertEqual(P('a/b').anchor, '')
+        self.assertEqual(P('/').anchor, sep)
+        self.assertEqual(P('/a/b').anchor, sep)
+
+    @needs_windows
+    def test_anchor_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').anchor, 'c:')
+        self.assertEqual(P('c:a/b').anchor, 'c:')
+        self.assertEqual(P('c:/').anchor, 'c:\\')
+        self.assertEqual(P('c:/a/b/').anchor, 'c:\\')
+        self.assertEqual(P('//a/b').anchor, '\\\\a\\b\\')
+        self.assertEqual(P('//a/b/').anchor, '\\\\a\\b\\')
+        self.assertEqual(P('//a/b/c/d').anchor, '\\\\a\\b\\')
+
+    def test_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').name, '')
+        self.assertEqual(P('.').name, '.')
+        self.assertEqual(P('/a/b/.').name, '.')
+
+    def test_name_common(self):
+        P = self.cls
+        self.assertEqual(P('/').name, '')
+        self.assertEqual(P('a/b').name, 'b')
+        self.assertEqual(P('/a/b').name, 'b')
+        self.assertEqual(P('a/b.py').name, 'b.py')
+        self.assertEqual(P('/a/b.py').name, 'b.py')
+
+    @needs_windows
+    def test_name_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').name, '')
+        self.assertEqual(P('c:/').name, '')
+        self.assertEqual(P('c:a/b').name, 'b')
+        self.assertEqual(P('c:/a/b').name, 'b')
+        self.assertEqual(P('c:a/b.py').name, 'b.py')
+        self.assertEqual(P('c:/a/b.py').name, 'b.py')
+        self.assertEqual(P('//My.py/Share.php').name, '')
+        self.assertEqual(P('//My.py/Share.php/a/b').name, 'b')
+
+    def test_suffix_common(self):
+        P = self.cls
+        self.assertEqual(P('').suffix, '')
+        self.assertEqual(P('.').suffix, '')
+        self.assertEqual(P('..').suffix, '')
+        self.assertEqual(P('/').suffix, '')
+        self.assertEqual(P('a/b').suffix, '')
+        self.assertEqual(P('/a/b').suffix, '')
+        self.assertEqual(P('/a/b/.').suffix, '')
+        self.assertEqual(P('a/b.py').suffix, '.py')
+        self.assertEqual(P('/a/b.py').suffix, '.py')
+        self.assertEqual(P('a/.hgrc').suffix, '')
+        self.assertEqual(P('/a/.hgrc').suffix, '')
+        self.assertEqual(P('a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('/a/Some name. Ending with a dot.').suffix, '')
+
+    @needs_windows
+    def test_suffix_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').suffix, '')
+        self.assertEqual(P('c:/').suffix, '')
+        self.assertEqual(P('c:a/b').suffix, '')
+        self.assertEqual(P('c:/a/b').suffix, '')
+        self.assertEqual(P('c:a/b.py').suffix, '.py')
+        self.assertEqual(P('c:/a/b.py').suffix, '.py')
+        self.assertEqual(P('c:a/.hgrc').suffix, '')
+        self.assertEqual(P('c:/a/.hgrc').suffix, '')
+        self.assertEqual(P('c:a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('c:/a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('c:a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('c:/a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('//My.py/Share.php').suffix, '')
+        self.assertEqual(P('//My.py/Share.php/a/b').suffix, '')
+
+    def test_suffixes_common(self):
+        P = self.cls
+        self.assertEqual(P('').suffixes, [])
+        self.assertEqual(P('.').suffixes, [])
+        self.assertEqual(P('/').suffixes, [])
+        self.assertEqual(P('a/b').suffixes, [])
+        self.assertEqual(P('/a/b').suffixes, [])
+        self.assertEqual(P('/a/b/.').suffixes, [])
+        self.assertEqual(P('a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('/a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('a/.hgrc').suffixes, [])
+        self.assertEqual(P('/a/.hgrc').suffixes, [])
+        self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('a/Some name. Ending with a dot.').suffixes, [])
+        self.assertEqual(P('/a/Some name. Ending with a dot.').suffixes, [])
+
+    @needs_windows
+    def test_suffixes_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').suffixes, [])
+        self.assertEqual(P('c:/').suffixes, [])
+        self.assertEqual(P('c:a/b').suffixes, [])
+        self.assertEqual(P('c:/a/b').suffixes, [])
+        self.assertEqual(P('c:a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('c:/a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('c:a/.hgrc').suffixes, [])
+        self.assertEqual(P('c:/a/.hgrc').suffixes, [])
+        self.assertEqual(P('c:a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('c:/a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('c:a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('c:/a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('//My.py/Share.php').suffixes, [])
+        self.assertEqual(P('//My.py/Share.php/a/b').suffixes, [])
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffixes, [])
+        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffixes, [])
+
+    def test_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').stem, '')
+        self.assertEqual(P('.').stem, '.')
+
+    def test_stem_common(self):
+        P = self.cls
+        self.assertEqual(P('..').stem, '..')
+        self.assertEqual(P('/').stem, '')
+        self.assertEqual(P('a/b').stem, 'b')
+        self.assertEqual(P('a/b.py').stem, 'b')
+        self.assertEqual(P('a/.hgrc').stem, '.hgrc')
+        self.assertEqual(P('a/.hg.rc').stem, '.hg')
+        self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
+        self.assertEqual(P('a/Some name. Ending with a dot.').stem,
+                         'Some name. Ending with a dot.')
+
+    @needs_windows
+    def test_stem_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').stem, '')
+        self.assertEqual(P('c:.').stem, '')
+        self.assertEqual(P('c:..').stem, '..')
+        self.assertEqual(P('c:/').stem, '')
+        self.assertEqual(P('c:a/b').stem, 'b')
+        self.assertEqual(P('c:a/b.py').stem, 'b')
+        self.assertEqual(P('c:a/.hgrc').stem, '.hgrc')
+        self.assertEqual(P('c:a/.hg.rc').stem, '.hg')
+        self.assertEqual(P('c:a/b.tar.gz').stem, 'b.tar')
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').stem,
+                         'Some name. Ending with a dot.')
+    def test_with_name_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
+        self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
+        self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
+
+    @needs_windows
+    def test_with_name_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_name('d.xml'), P('c:a/d.xml'))
+        self.assertEqual(P('c:/a/b').with_name('d.xml'), P('c:/a/d.xml'))
+        self.assertEqual(P('c:a/Dot ending.').with_name('d.xml'), P('c:a/d.xml'))
+        self.assertEqual(P('c:/a/Dot ending.').with_name('d.xml'), P('c:/a/d.xml'))
+        self.assertRaises(ValueError, P('c:').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('c:/').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('//My/Share').with_name, 'd.xml')
+        self.assertEqual(str(P('a').with_name('d:')), '.\\d:')
+        self.assertEqual(str(P('a').with_name('d:e')), '.\\d:e')
+        self.assertEqual(P('c:a/b').with_name('d:'), P('c:a/d:'))
+        self.assertEqual(P('c:a/b').with_name('d:e'), P('c:a/d:e'))
+        self.assertRaises(ValueError, P('c:a/b').with_name, 'd:/e')
+        self.assertRaises(ValueError, P('c:a/b').with_name, '//My/Share')
+
+    def test_with_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').with_name('d.xml'), P('d.xml'))
+        self.assertEqual(P('.').with_name('d.xml'), P('d.xml'))
+        self.assertEqual(P('/').with_name('d.xml'), P('/d.xml'))
+        self.assertEqual(P('a/b').with_name(''), P('a/'))
+        self.assertEqual(P('a/b').with_name('.'), P('a/.'))
+
+    def test_with_name_seps(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a/b').with_name, '/c')
+        self.assertRaises(ValueError, P('a/b').with_name, 'c/')
+        self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
+
+    def test_with_stem_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
+        self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
+        self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
+        self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
+        self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
+        self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d'))
+        self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d'))
+
+    @needs_windows
+    def test_with_stem_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_stem('d'), P('c:a/d'))
+        self.assertEqual(P('c:/a/b').with_stem('d'), P('c:/a/d'))
+        self.assertEqual(P('c:a/Dot ending.').with_stem('d'), P('c:a/d'))
+        self.assertEqual(P('c:/a/Dot ending.').with_stem('d'), P('c:/a/d'))
+        self.assertRaises(ValueError, P('c:').with_stem, 'd')
+        self.assertRaises(ValueError, P('c:/').with_stem, 'd')
+        self.assertRaises(ValueError, P('//My/Share').with_stem, 'd')
+        self.assertEqual(str(P('a').with_stem('d:')), '.\\d:')
+        self.assertEqual(str(P('a').with_stem('d:e')), '.\\d:e')
+        self.assertEqual(P('c:a/b').with_stem('d:'), P('c:a/d:'))
+        self.assertEqual(P('c:a/b').with_stem('d:e'), P('c:a/d:e'))
+        self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:/e')
+        self.assertRaises(ValueError, P('c:a/b').with_stem, '//My/Share')
+
+    def test_with_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').with_stem('d'), P('d'))
+        self.assertEqual(P('.').with_stem('d'), P('d'))
+        self.assertEqual(P('/').with_stem('d'), P('/d'))
+        self.assertEqual(P('a/b').with_stem(''), P('a/'))
+        self.assertEqual(P('a/b').with_stem('.'), P('a/.'))
+        self.assertRaises(ValueError, P('foo.gz').with_stem, '')
+        self.assertRaises(ValueError, P('/a/b/foo.gz').with_stem, '')
+
+    def test_with_stem_seps(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a/b').with_stem, '/c')
+        self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
+        self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
+
+    def test_with_suffix_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
+        self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
+        self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
+        self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
+        # Stripping suffix.
+        self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
+        self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
+
+    @needs_windows
+    def test_with_suffix_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_suffix('.gz'), P('c:a/b.gz'))
+        self.assertEqual(P('c:/a/b').with_suffix('.gz'), P('c:/a/b.gz'))
+        self.assertEqual(P('c:a/b.py').with_suffix('.gz'), P('c:a/b.gz'))
+        self.assertEqual(P('c:/a/b.py').with_suffix('.gz'), P('c:/a/b.gz'))
+        # Path doesn't have a "filename" component.
+        self.assertRaises(ValueError, P('').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('//My/Share').with_suffix, '.gz')
+        # Invalid suffix.
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c/d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c\\d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c/d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c\\d')
+        self.assertRaises(TypeError, P('c:a/b').with_suffix, None)
+
+    def test_with_suffix_empty(self):
+        P = self.cls
+        # Path doesn't have a "filename" component.
+        self.assertRaises(ValueError, P('').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
+
+    def test_with_suffix_invalid(self):
+        P = self.cls
+        # Invalid suffix.
+        self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '/')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
+        self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
+        self.assertRaises(TypeError, P('a/b').with_suffix, None)
+
+    def test_relative_to_common(self):
+        P = self.cls
+        p = P('a/b')
+        self.assertRaises(TypeError, p.relative_to)
+        self.assertRaises(TypeError, p.relative_to, b'a')
+        self.assertEqual(p.relative_to(P('')), P('a/b'))
+        self.assertEqual(p.relative_to(''), P('a/b'))
+        self.assertEqual(p.relative_to(P('a')), P('b'))
+        self.assertEqual(p.relative_to('a'), P('b'))
+        self.assertEqual(p.relative_to('a/'), P('b'))
+        self.assertEqual(p.relative_to(P('a/b')), P(''))
+        self.assertEqual(p.relative_to('a/b'), P(''))
+        self.assertEqual(p.relative_to(P(''), walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P(''))
+        self.assertEqual(p.relative_to('a/b', walk_up=True), P(''))
+        self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
+        self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('c'))
+        self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
+        self.assertRaises(ValueError, p.relative_to, P('a/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a'))
+        self.assertRaises(ValueError, p.relative_to, P("../a"))
+        self.assertRaises(ValueError, p.relative_to, P("a/.."))
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
+        p = P('/a/b')
+        self.assertEqual(p.relative_to(P('/')), P('a/b'))
+        self.assertEqual(p.relative_to('/'), P('a/b'))
+        self.assertEqual(p.relative_to(P('/a')), P('b'))
+        self.assertEqual(p.relative_to('/a'), P('b'))
+        self.assertEqual(p.relative_to('/a/'), P('b'))
+        self.assertEqual(p.relative_to(P('/a/b')), P(''))
+        self.assertEqual(p.relative_to('/a/b'), P(''))
+        self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P(''))
+        self.assertEqual(p.relative_to('/a/b', walk_up=True), P(''))
+        self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
+        self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a/c'))
+        self.assertRaises(ValueError, p.relative_to, P(''))
+        self.assertRaises(ValueError, p.relative_to, '')
+        self.assertRaises(ValueError, p.relative_to, P('a'))
+        self.assertRaises(ValueError, p.relative_to, P("../a"))
+        self.assertRaises(ValueError, p.relative_to, P("a/.."))
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
+        self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
+
+    @needs_windows
+    def test_relative_to_windows(self):
+        P = self.cls
+        p = P('C:Foo/Bar')
+        self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO'), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:foO/baR')), P())
+        self.assertEqual(p.relative_to('c:foO/baR'), P())
+        self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
+        self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
+        self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
+        self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P())
+        self.assertRaises(ValueError, p.relative_to, '')
+        self.assertRaises(ValueError, p.relative_to, P('d:'))
+        self.assertRaises(ValueError, p.relative_to, P('/'))
+        self.assertRaises(ValueError, p.relative_to, P('Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
+        p = P('C:/Foo/Bar')
+        self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
+        self.assertEqual(p.relative_to('c:/foO/baR'), P())
+        self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
+        self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
+        self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
+        self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, 'c:')
+        self.assertRaises(ValueError, p.relative_to, P('c:'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('d:'))
+        self.assertRaises(ValueError, p.relative_to, P('d:/'))
+        self.assertRaises(ValueError, p.relative_to, P('/'))
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
+        self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
+        # UNC paths.
+        p = P('//Server/Share/Foo/Bar')
+        self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
+        self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
+        self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
+
+    def test_is_relative_to_common(self):
+        P = self.cls
+        p = P('a/b')
+        self.assertRaises(TypeError, p.is_relative_to)
+        self.assertRaises(TypeError, p.is_relative_to, b'a')
+        self.assertTrue(p.is_relative_to(P('')))
+        self.assertTrue(p.is_relative_to(''))
+        self.assertTrue(p.is_relative_to(P('a')))
+        self.assertTrue(p.is_relative_to('a/'))
+        self.assertTrue(p.is_relative_to(P('a/b')))
+        self.assertTrue(p.is_relative_to('a/b'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('c')))
+        self.assertFalse(p.is_relative_to(P('a/b/c')))
+        self.assertFalse(p.is_relative_to(P('a/c')))
+        self.assertFalse(p.is_relative_to(P('/a')))
+        p = P('/a/b')
+        self.assertTrue(p.is_relative_to(P('/')))
+        self.assertTrue(p.is_relative_to('/'))
+        self.assertTrue(p.is_relative_to(P('/a')))
+        self.assertTrue(p.is_relative_to('/a'))
+        self.assertTrue(p.is_relative_to('/a/'))
+        self.assertTrue(p.is_relative_to(P('/a/b')))
+        self.assertTrue(p.is_relative_to('/a/b'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('/c')))
+        self.assertFalse(p.is_relative_to(P('/a/b/c')))
+        self.assertFalse(p.is_relative_to(P('/a/c')))
+        self.assertFalse(p.is_relative_to(P('')))
+        self.assertFalse(p.is_relative_to(''))
+        self.assertFalse(p.is_relative_to(P('a')))
+
+    @needs_windows
+    def test_is_relative_to_windows(self):
+        P = self.cls
+        p = P('C:Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('c:')))
+        self.assertTrue(p.is_relative_to('c:'))
+        self.assertTrue(p.is_relative_to(P('c:foO')))
+        self.assertTrue(p.is_relative_to('c:foO'))
+        self.assertTrue(p.is_relative_to('c:foO/'))
+        self.assertTrue(p.is_relative_to(P('c:foO/baR')))
+        self.assertTrue(p.is_relative_to('c:foO/baR'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P()))
+        self.assertFalse(p.is_relative_to(''))
+        self.assertFalse(p.is_relative_to(P('d:')))
+        self.assertFalse(p.is_relative_to(P('/')))
+        self.assertFalse(p.is_relative_to(P('Foo')))
+        self.assertFalse(p.is_relative_to(P('/Foo')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo')))
+        self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
+        p = P('C:/Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('c:/')))
+        self.assertTrue(p.is_relative_to(P('c:/foO')))
+        self.assertTrue(p.is_relative_to('c:/foO/'))
+        self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
+        self.assertTrue(p.is_relative_to('c:/foO/baR'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to('c:'))
+        self.assertFalse(p.is_relative_to(P('C:/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:Foo')))
+        self.assertFalse(p.is_relative_to(P('d:')))
+        self.assertFalse(p.is_relative_to(P('d:/')))
+        self.assertFalse(p.is_relative_to(P('/')))
+        self.assertFalse(p.is_relative_to(P('/Foo')))
+        self.assertFalse(p.is_relative_to(P('//C/Foo')))
+        # UNC paths.
+        p = P('//Server/Share/Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare'))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/'))
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
+
+    @needs_posix
+    def test_is_absolute_posix(self):
+        P = self.cls
+        self.assertFalse(P('').is_absolute())
+        self.assertFalse(P('a').is_absolute())
+        self.assertFalse(P('a/b/').is_absolute())
+        self.assertTrue(P('/').is_absolute())
+        self.assertTrue(P('/a').is_absolute())
+        self.assertTrue(P('/a/b/').is_absolute())
+        self.assertTrue(P('//a').is_absolute())
+        self.assertTrue(P('//a/b').is_absolute())
+
+    @needs_windows
+    def test_is_absolute_windows(self):
+        P = self.cls
+        # Under NT, only paths with both a drive and a root are absolute.
+        self.assertFalse(P().is_absolute())
+        self.assertFalse(P('a').is_absolute())
+        self.assertFalse(P('a/b/').is_absolute())
+        self.assertFalse(P('/').is_absolute())
+        self.assertFalse(P('/a').is_absolute())
+        self.assertFalse(P('/a/b/').is_absolute())
+        self.assertFalse(P('c:').is_absolute())
+        self.assertFalse(P('c:a').is_absolute())
+        self.assertFalse(P('c:a/b/').is_absolute())
+        self.assertTrue(P('c:/').is_absolute())
+        self.assertTrue(P('c:/a').is_absolute())
+        self.assertTrue(P('c:/a/b/').is_absolute())
+        # UNC paths are absolute by definition.
+        self.assertTrue(P('//').is_absolute())
+        self.assertTrue(P('//a').is_absolute())
+        self.assertTrue(P('//a/b').is_absolute())
+        self.assertTrue(P('//a/b/').is_absolute())
+        self.assertTrue(P('//a/b/c').is_absolute())
+        self.assertTrue(P('//a/b/c/d').is_absolute())
+        self.assertTrue(P('//?/UNC/').is_absolute())
+        self.assertTrue(P('//?/UNC/spam').is_absolute())
+
+
+#
+# Tests for the virtual classes.
+#
+
+class PathBaseTest(PurePathBaseTest):
+    cls = PathBase
+
+    def test_unsupported_operation(self):
+        P = self.cls
+        p = self.cls('')
+        e = UnsupportedOperation
+        self.assertRaises(e, p.stat)
+        self.assertRaises(e, p.lstat)
+        self.assertRaises(e, p.exists)
+        self.assertRaises(e, p.samefile, 'foo')
+        self.assertRaises(e, p.is_dir)
+        self.assertRaises(e, p.is_file)
+        self.assertRaises(e, p.is_mount)
+        self.assertRaises(e, p.is_symlink)
+        self.assertRaises(e, p.is_block_device)
+        self.assertRaises(e, p.is_char_device)
+        self.assertRaises(e, p.is_fifo)
+        self.assertRaises(e, p.is_socket)
+        self.assertRaises(e, p.open)
+        self.assertRaises(e, p.read_bytes)
+        self.assertRaises(e, p.read_text)
+        self.assertRaises(e, p.write_bytes, b'foo')
+        self.assertRaises(e, p.write_text, 'foo')
+        self.assertRaises(e, p.iterdir)
+        self.assertRaises(e, p.glob, '*')
+        self.assertRaises(e, p.rglob, '*')
+        self.assertRaises(e, lambda: list(p.walk()))
+        self.assertRaises(e, p.absolute)
+        self.assertRaises(e, P.cwd)
+        self.assertRaises(e, p.expanduser)
+        self.assertRaises(e, p.home)
+        self.assertRaises(e, p.readlink)
+        self.assertRaises(e, p.symlink_to, 'foo')
+        self.assertRaises(e, p.hardlink_to, 'foo')
+        self.assertRaises(e, p.mkdir)
+        self.assertRaises(e, p.touch)
+        self.assertRaises(e, p.rename, 'foo')
+        self.assertRaises(e, p.replace, 'foo')
+        self.assertRaises(e, p.chmod, 0o755)
+        self.assertRaises(e, p.lchmod, 0o755)
+        self.assertRaises(e, p.unlink)
+        self.assertRaises(e, p.rmdir)
+        self.assertRaises(e, p.owner)
+        self.assertRaises(e, p.group)
+        self.assertRaises(e, p.as_uri)
+
+    def test_as_uri_common(self):
+        e = UnsupportedOperation
+        self.assertRaises(e, self.cls('').as_uri)
+
+    def test_fspath_common(self):
+        self.assertRaises(TypeError, os.fspath, self.cls(''))
+
+    def test_as_bytes_common(self):
+        self.assertRaises(TypeError, bytes, self.cls(''))
+
+
+class DummyPathIO(io.BytesIO):
+    """
+    Used by DummyPath to implement `open('w')`
+    """
+
+    def __init__(self, files, path):
+        super().__init__()
+        self.files = files
+        self.path = path
+
+    def close(self):
+        self.files[self.path] = self.getvalue()
+        super().close()
+
+
+DummyPathStatResult = collections.namedtuple(
+    'DummyPathStatResult',
+    'st_mode st_ino st_dev st_nlink st_uid st_gid st_size st_atime st_mtime st_ctime')
+
+
+class DummyPath(PathBase):
+    """
+    Simple implementation of PathBase that keeps files and directories in
+    memory.
+    """
+    __slots__ = ()
+    parser = posixpath
+
+    _files = {}
+    _directories = {}
+    _symlinks = {}
+
+    def __eq__(self, other):
+        if not isinstance(other, DummyPath):
+            return NotImplemented
+        return str(self) == str(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+    def stat(self, *, follow_symlinks=True):
+        if follow_symlinks or self.name in ('', '.', '..'):
+            path = str(self.resolve(strict=True))
+        else:
+            path = str(self.parent.resolve(strict=True) / self.name)
+        if path in self._files:
+            st_mode = stat.S_IFREG
+        elif path in self._directories:
+            st_mode = stat.S_IFDIR
+        elif path in self._symlinks:
+            st_mode = stat.S_IFLNK
+        else:
+            raise FileNotFoundError(errno.ENOENT, "Not found", str(self))
+        return DummyPathStatResult(st_mode, hash(str(self)), 0, 0, 0, 0, 0, 0, 0, 0)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        if buffering != -1:
+            raise NotImplementedError
+        path_obj = self.resolve()
+        path = str(path_obj)
+        name = path_obj.name
+        parent = str(path_obj.parent)
+        if path in self._directories:
+            raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
+
+        text = 'b' not in mode
+        mode = ''.join(c for c in mode if c not in 'btU')
+        if mode == 'r':
+            if path not in self._files:
+                raise FileNotFoundError(errno.ENOENT, "File not found", path)
+            stream = io.BytesIO(self._files[path])
+        elif mode == 'w':
+            if parent not in self._directories:
+                raise FileNotFoundError(errno.ENOENT, "File not found", parent)
+            stream = DummyPathIO(self._files, path)
+            self._files[path] = b''
+            self._directories[parent].add(name)
+        else:
+            raise NotImplementedError
+        if text:
+            stream = io.TextIOWrapper(stream, encoding=encoding, errors=errors, newline=newline)
+        return stream
+
+    def iterdir(self):
+        path = str(self.resolve())
+        if path in self._files:
+            raise NotADirectoryError(errno.ENOTDIR, "Not a directory", path)
+        elif path in self._directories:
+            return (self / name for name in self._directories[path])
+        else:
+            raise FileNotFoundError(errno.ENOENT, "File not found", path)
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        path = str(self.resolve())
+        if path in self._directories:
+            if exist_ok:
+                return
+            else:
+                raise FileExistsError(errno.EEXIST, "File exists", path)
+        try:
+            if self.name:
+                self._directories[str(self.parent)].add(self.name)
+            self._directories[path] = set()
+        except KeyError:
+            if not parents:
+                raise FileNotFoundError(errno.ENOENT, "File not found", str(self.parent)) from None
+            self.parent.mkdir(parents=True, exist_ok=True)
+            self.mkdir(mode, parents=False, exist_ok=exist_ok)
+
+
+class DummyPathTest(DummyPurePathTest):
+    """Tests for PathBase methods that use stat(), open() and iterdir()."""
+
+    cls = DummyPath
+    can_symlink = False
+
+    # (self.base)
+    #  |
+    #  |-- brokenLink -> non-existing
+    #  |-- dirA
+    #  |   `-- linkC -> ../dirB
+    #  |-- dirB
+    #  |   |-- fileB
+    #  |   `-- linkD -> ../dirB
+    #  |-- dirC
+    #  |   |-- dirD
+    #  |   |   `-- fileD
+    #  |   `-- fileC
+    #  |   `-- novel.txt
+    #  |-- dirE  # No permissions
+    #  |-- fileA
+    #  |-- linkA -> fileA
+    #  |-- linkB -> dirB
+    #  `-- brokenLinkLoop -> brokenLinkLoop
+    #
+
+    def setUp(self):
+        super().setUp()
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_symlinks and not self.can_symlink:
+            self.skipTest('requires symlinks')
+        parser = self.cls.parser
+        p = self.cls(self.base)
+        p.mkdir(parents=True)
+        p.joinpath('dirA').mkdir()
+        p.joinpath('dirB').mkdir()
+        p.joinpath('dirC').mkdir()
+        p.joinpath('dirC', 'dirD').mkdir()
+        p.joinpath('dirE').mkdir()
+        with p.joinpath('fileA').open('wb') as f:
+            f.write(b"this is file A\n")
+        with p.joinpath('dirB', 'fileB').open('wb') as f:
+            f.write(b"this is file B\n")
+        with p.joinpath('dirC', 'fileC').open('wb') as f:
+            f.write(b"this is file C\n")
+        with p.joinpath('dirC', 'novel.txt').open('wb') as f:
+            f.write(b"this is a novel\n")
+        with p.joinpath('dirC', 'dirD', 'fileD').open('wb') as f:
+            f.write(b"this is file D\n")
+        if self.can_symlink:
+            p.joinpath('linkA').symlink_to('fileA')
+            p.joinpath('brokenLink').symlink_to('non-existing')
+            p.joinpath('linkB').symlink_to('dirB')
+            p.joinpath('dirA', 'linkC').symlink_to(parser.join('..', 'dirB'))
+            p.joinpath('dirB', 'linkD').symlink_to(parser.join('..', 'dirB'))
+            p.joinpath('brokenLinkLoop').symlink_to('brokenLinkLoop')
+
+    def tearDown(self):
+        cls = self.cls
+        cls._files.clear()
+        cls._directories.clear()
+        cls._symlinks.clear()
+
+    def tempdir(self):
+        path = self.cls(self.base).with_name('tmp-dirD')
+        path.mkdir()
+        return path
+
+    def assertFileNotFound(self, func, *args, **kwargs):
+        with self.assertRaises(FileNotFoundError) as cm:
+            func(*args, **kwargs)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+
+    def assertEqualNormCase(self, path_a, path_b):
+        normcase = self.parser.normcase
+        self.assertEqual(normcase(path_a), normcase(path_b))
+
+    def test_samefile(self):
+        parser = self.parser
+        fileA_path = parser.join(self.base, 'fileA')
+        fileB_path = parser.join(self.base, 'dirB', 'fileB')
+        p = self.cls(fileA_path)
+        pp = self.cls(fileA_path)
+        q = self.cls(fileB_path)
+        self.assertTrue(p.samefile(fileA_path))
+        self.assertTrue(p.samefile(pp))
+        self.assertFalse(p.samefile(fileB_path))
+        self.assertFalse(p.samefile(q))
+        # Test the non-existent file case
+        non_existent = parser.join(self.base, 'foo')
+        r = self.cls(non_existent)
+        self.assertRaises(FileNotFoundError, p.samefile, r)
+        self.assertRaises(FileNotFoundError, p.samefile, non_existent)
+        self.assertRaises(FileNotFoundError, r.samefile, p)
+        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
+        self.assertRaises(FileNotFoundError, r.samefile, r)
+        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
+
+    def test_exists(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertIs(True, p.exists())
+        self.assertIs(True, (p / 'dirA').exists())
+        self.assertIs(True, (p / 'fileA').exists())
+        self.assertIs(False, (p / 'fileA' / 'bah').exists())
+        if self.can_symlink:
+            self.assertIs(True, (p / 'linkA').exists())
+            self.assertIs(True, (p / 'linkB').exists())
+            self.assertIs(True, (p / 'linkB' / 'fileB').exists())
+            self.assertIs(False, (p / 'linkA' / 'bah').exists())
+            self.assertIs(False, (p / 'brokenLink').exists())
+            self.assertIs(True, (p / 'brokenLink').exists(follow_symlinks=False))
+        self.assertIs(False, (p / 'foo').exists())
+        self.assertIs(False, P('/xyzzy').exists())
+        self.assertIs(False, P(self.base + '\udfff').exists())
+        self.assertIs(False, P(self.base + '\x00').exists())
+
+    def test_open_common(self):
+        p = self.cls(self.base)
+        with (p / 'fileA').open('r') as f:
+            self.assertIsInstance(f, io.TextIOBase)
+            self.assertEqual(f.read(), "this is file A\n")
+        with (p / 'fileA').open('rb') as f:
+            self.assertIsInstance(f, io.BufferedIOBase)
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_read_write_bytes(self):
+        p = self.cls(self.base)
+        (p / 'fileA').write_bytes(b'abcdefg')
+        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
+        # Check that trying to write str does not truncate the file.
+        self.assertRaises(TypeError, (p / 'fileA').write_bytes, 'somestr')
+        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
+
+    def test_read_write_text(self):
+        p = self.cls(self.base)
+        (p / 'fileA').write_text('äbcdefg', encoding='latin-1')
+        self.assertEqual((p / 'fileA').read_text(
+            encoding='utf-8', errors='ignore'), 'bcdefg')
+        # Check that trying to write bytes does not truncate the file.
+        self.assertRaises(TypeError, (p / 'fileA').write_text, b'somebytes')
+        self.assertEqual((p / 'fileA').read_text(encoding='latin-1'), 'äbcdefg')
+
+    def test_read_text_with_newlines(self):
+        p = self.cls(self.base)
+        # Check that `\n` character change nothing
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\n'),
+                         'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r` character replaces `\n`
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\r'),
+                         'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r\n` character replaces `\n`
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\r\n'),
+                             'abcde\r\nfghlk\n\rmnopq')
+
+    def test_write_text_with_newlines(self):
+        p = self.cls(self.base)
+        # Check that `\n` character change nothing
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\n')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r` character replaces `\n`
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\rfghlk\r\rmnopq')
+        # Check that `\r\n` character replaces `\n`
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r\n')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\r\nfghlk\r\n\rmnopq')
+        # Check that no argument passed will change `\n` to `os.linesep`
+        os_linesep_byte = bytes(os.linesep, encoding='ascii')
+        (p / 'fileA').write_text('abcde\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                          b'abcde' + os_linesep_byte + b'fghlk' + os_linesep_byte + b'\rmnopq')
+
+    def test_iterdir(self):
+        P = self.cls
+        p = P(self.base)
+        it = p.iterdir()
+        paths = set(it)
+        expected = ['dirA', 'dirB', 'dirC', 'dirE', 'fileA']
+        if self.can_symlink:
+            expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
+        self.assertEqual(paths, { P(self.base, q) for q in expected })
+
+    @needs_symlinks
+    def test_iterdir_symlink(self):
+        # __iter__ on a symlink to a directory.
+        P = self.cls
+        p = P(self.base, 'linkB')
+        paths = set(p.iterdir())
+        expected = { P(self.base, 'linkB', q) for q in ['fileB', 'linkD'] }
+        self.assertEqual(paths, expected)
+
+    def test_iterdir_nodir(self):
+        # __iter__ on something that is not a directory.
+        p = self.cls(self.base, 'fileA')
+        with self.assertRaises(OSError) as cm:
+            p.iterdir()
+        # ENOENT or EINVAL under Windows, ENOTDIR otherwise
+        # (see issue #12802).
+        self.assertIn(cm.exception.errno, (errno.ENOTDIR,
+                                           errno.ENOENT, errno.EINVAL))
+
+    def test_glob_common(self):
+        def _check(glob, expected):
+            self.assertEqual(set(glob), { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        it = p.glob("fileA")
+        self.assertIsInstance(it, collections.abc.Iterator)
+        _check(it, ["fileA"])
+        _check(p.glob("fileB"), [])
+        _check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
+        if not self.can_symlink:
+            _check(p.glob("*A"), ['dirA', 'fileA'])
+        else:
+            _check(p.glob("*A"), ['dirA', 'fileA', 'linkA'])
+        if not self.can_symlink:
+            _check(p.glob("*B/*"), ['dirB/fileB'])
+        else:
+            _check(p.glob("*B/*"), ['dirB/fileB', 'dirB/linkD',
+                                    'linkB/fileB', 'linkB/linkD'])
+        if not self.can_symlink:
+            _check(p.glob("*/fileB"), ['dirB/fileB'])
+        else:
+            _check(p.glob("*/fileB"), ['dirB/fileB', 'linkB/fileB'])
+        if self.can_symlink:
+            _check(p.glob("brokenLink"), ['brokenLink'])
+
+        if not self.can_symlink:
+            _check(p.glob("*/"), ["dirA/", "dirB/", "dirC/", "dirE/"])
+        else:
+            _check(p.glob("*/"), ["dirA/", "dirB/", "dirC/", "dirE/", "linkB/"])
+
+    @needs_posix
+    def test_glob_posix(self):
+        P = self.cls
+        p = P(self.base)
+        q = p / "FILEa"
+        given = set(p.glob("FILEa"))
+        expect = {q} if q.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.glob("FILEa*")), set())
+
+    @needs_windows
+    def test_glob_windows(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
+        self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
+        self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
+
+    def test_glob_empty_pattern(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(list(p.glob("")), [p])
+        self.assertEqual(list(p.glob(".")), [p / "."])
+        self.assertEqual(list(p.glob("./")), [p / "./"])
+
+    def test_glob_case_sensitive(self):
+        P = self.cls
+        def _check(path, pattern, case_sensitive, expected):
+            actual = {str(q) for q in path.glob(pattern, case_sensitive=case_sensitive)}
+            expected = {str(P(self.base, q)) for q in expected}
+            self.assertEqual(actual, expected)
+        path = P(self.base)
+        _check(path, "DIRB/FILE*", True, [])
+        _check(path, "DIRB/FILE*", False, ["dirB/fileB"])
+        _check(path, "dirb/file*", True, [])
+        _check(path, "dirb/file*", False, ["dirB/fileB"])
+
+    @needs_symlinks
+    def test_glob_recurse_symlinks_common(self):
+        def _check(path, glob, expected):
+            actual = {path for path in path.glob(glob, recurse_symlinks=True)
+                      if path.parts.count("linkD") <= 1}  # exclude symlink loop.
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        _check(p, "fileB", [])
+        _check(p, "dir*/file*", ["dirB/fileB", "dirC/fileC"])
+        _check(p, "*A", ["dirA", "fileA", "linkA"])
+        _check(p, "*B/*", ["dirB/fileB", "dirB/linkD", "linkB/fileB", "linkB/linkD"])
+        _check(p, "*/fileB", ["dirB/fileB", "linkB/fileB"])
+        _check(p, "*/", ["dirA/", "dirB/", "dirC/", "dirE/", "linkB/"])
+        _check(p, "dir*/*/..", ["dirC/dirD/..", "dirA/linkC/..", "dirB/linkD/.."])
+        _check(p, "dir*/**", [
+            "dirA/", "dirA/linkC", "dirA/linkC/fileB", "dirA/linkC/linkD", "dirA/linkC/linkD/fileB",
+            "dirB/", "dirB/fileB", "dirB/linkD", "dirB/linkD/fileB",
+            "dirC/", "dirC/fileC", "dirC/dirD",  "dirC/dirD/fileD", "dirC/novel.txt",
+            "dirE/"])
+        _check(p, "dir*/**/", ["dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                               "dirC/", "dirC/dirD/", "dirE/"])
+        _check(p, "dir*/**/..", ["dirA/..", "dirA/linkC/..", "dirB/..",
+                                 "dirB/linkD/..", "dirA/linkC/linkD/..",
+                                 "dirC/..", "dirC/dirD/..", "dirE/.."])
+        _check(p, "dir*/*/**", [
+            "dirA/linkC/", "dirA/linkC/linkD", "dirA/linkC/fileB", "dirA/linkC/linkD/fileB",
+            "dirB/linkD/", "dirB/linkD/fileB",
+            "dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "dir*/*/**/", ["dirA/linkC/", "dirA/linkC/linkD/", "dirB/linkD/", "dirC/dirD/"])
+        _check(p, "dir*/*/**/..", ["dirA/linkC/..", "dirA/linkC/linkD/..",
+                                   "dirB/linkD/..", "dirC/dirD/.."])
+        _check(p, "dir*/**/fileC", ["dirC/fileC"])
+        _check(p, "dir*/*/../dirD/**/", ["dirC/dirD/../dirD/"])
+        _check(p, "*/dirD/**", ["dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "*/dirD/**/", ["dirC/dirD/"])
+
+    def test_rglob_recurse_symlinks_false(self):
+        def _check(path, glob, expected):
+            actual = set(path.rglob(glob, recurse_symlinks=False))
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        it = p.rglob("fileA")
+        self.assertIsInstance(it, collections.abc.Iterator)
+        _check(p, "fileA", ["fileA"])
+        _check(p, "fileB", ["dirB/fileB"])
+        _check(p, "**/fileB", ["dirB/fileB"])
+        _check(p, "*/fileA", [])
+
+        if self.can_symlink:
+            _check(p, "*/fileB", ["dirB/fileB", "dirB/linkD/fileB",
+                                  "linkB/fileB", "dirA/linkC/fileB"])
+            _check(p, "*/", [
+                "dirA/", "dirA/linkC/", "dirB/", "dirB/linkD/", "dirC/",
+                "dirC/dirD/", "dirE/", "linkB/"])
+        else:
+            _check(p, "*/fileB", ["dirB/fileB"])
+            _check(p, "*/", ["dirA/", "dirB/", "dirC/", "dirC/dirD/", "dirE/"])
+
+        _check(p, "file*", ["fileA", "dirB/fileB", "dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "", ["", "dirA/", "dirB/", "dirC/", "dirE/", "dirC/dirD/"])
+        p = P(self.base, "dirC")
+        _check(p, "*", ["dirC/fileC", "dirC/novel.txt",
+                              "dirC/dirD", "dirC/dirD/fileD"])
+        _check(p, "file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "**/file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "dir*/**", ["dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "dir*/**/", ["dirC/dirD/"])
+        _check(p, "*/*", ["dirC/dirD/fileD"])
+        _check(p, "*/", ["dirC/dirD/"])
+        _check(p, "", ["dirC/", "dirC/dirD/"])
+        _check(p, "**", ["dirC/", "dirC/fileC", "dirC/dirD", "dirC/dirD/fileD", "dirC/novel.txt"])
+        _check(p, "**/", ["dirC/", "dirC/dirD/"])
+        # gh-91616, a re module regression
+        _check(p, "*.txt", ["dirC/novel.txt"])
+        _check(p, "*.*", ["dirC/novel.txt"])
+
+    @needs_posix
+    def test_rglob_posix(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        q = p / "dirD" / "FILEd"
+        given = set(p.rglob("FILEd"))
+        expect = {q} if q.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.rglob("FILEd*")), set())
+
+    @needs_windows
+    def test_rglob_windows(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        self.assertEqual(set(p.rglob("FILEd")), { P(self.base, "dirC/dirD/fileD") })
+        self.assertEqual(set(p.rglob("*\\")), { P(self.base, "dirC/dirD/") })
+
+    @needs_symlinks
+    def test_rglob_recurse_symlinks_common(self):
+        def _check(path, glob, expected):
+            actual = {path for path in path.rglob(glob, recurse_symlinks=True)
+                      if path.parts.count("linkD") <= 1}  # exclude symlink loop.
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        _check(p, "fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB",
+                            "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB"])
+        _check(p, "*/fileA", [])
+        _check(p, "*/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB",
+                              "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB"])
+        _check(p, "file*", ["fileA", "dirA/linkC/fileB", "dirB/fileB",
+                            "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB",
+                            "dirC/fileC", "dirC/dirD/fileD", "linkB/fileB"])
+        _check(p, "*/", ["dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                         "dirC/", "dirC/dirD/", "dirE/", "linkB/", "linkB/linkD/"])
+        _check(p, "", ["", "dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                       "dirC/", "dirE/", "dirC/dirD/", "linkB/", "linkB/linkD/"])
+
+        p = P(self.base, "dirC")
+        _check(p, "*", ["dirC/fileC", "dirC/novel.txt",
+                        "dirC/dirD", "dirC/dirD/fileD"])
+        _check(p, "file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "*/*", ["dirC/dirD/fileD"])
+        _check(p, "*/", ["dirC/dirD/"])
+        _check(p, "", ["dirC/", "dirC/dirD/"])
+        # gh-91616, a re module regression
+        _check(p, "*.txt", ["dirC/novel.txt"])
+        _check(p, "*.*", ["dirC/novel.txt"])
+
+    @needs_symlinks
+    def test_rglob_symlink_loop(self):
+        # Don't get fooled by symlink loops (Issue #26012).
+        P = self.cls
+        p = P(self.base)
+        given = set(p.rglob('*', recurse_symlinks=False))
+        expect = {'brokenLink',
+                  'dirA', 'dirA/linkC',
+                  'dirB', 'dirB/fileB', 'dirB/linkD',
+                  'dirC', 'dirC/dirD', 'dirC/dirD/fileD',
+                  'dirC/fileC', 'dirC/novel.txt',
+                  'dirE',
+                  'fileA',
+                  'linkA',
+                  'linkB',
+                  'brokenLinkLoop',
+                  }
+        self.assertEqual(given, {p / x for x in expect})
+
+    # See https://github.com/WebAssembly/wasi-filesystem/issues/26
+    @unittest.skipIf(is_wasi, "WASI resolution of '..' parts doesn't match POSIX")
+    def test_glob_dotdot(self):
+        # ".." is not special in globs.
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(set(p.glob("..")), { P(self.base, "..") })
+        self.assertEqual(set(p.glob("../..")), { P(self.base, "..", "..") })
+        self.assertEqual(set(p.glob("dirA/..")), { P(self.base, "dirA", "..") })
+        self.assertEqual(set(p.glob("dirA/../file*")), { P(self.base, "dirA/../fileA") })
+        self.assertEqual(set(p.glob("dirA/../file*/..")), set())
+        self.assertEqual(set(p.glob("../xyzzy")), set())
+        if self.cls.parser is posixpath:
+            self.assertEqual(set(p.glob("xyzzy/..")), set())
+        else:
+            # ".." segments are normalized first on Windows, so this path is stat()able.
+            self.assertEqual(set(p.glob("xyzzy/..")), { P(self.base, "xyzzy", "..") })
+        self.assertEqual(set(p.glob("/".join([".."] * 50))), { P(self.base, *[".."] * 50)})
+
+    @needs_symlinks
+    def test_glob_permissions(self):
+        # See bpo-38894
+        P = self.cls
+        base = P(self.base) / 'permissions'
+        base.mkdir()
+
+        for i in range(100):
+            link = base / f"link{i}"
+            if i % 2:
+                link.symlink_to(P(self.base, "dirE", "nonexistent"))
+            else:
+                link.symlink_to(P(self.base, "dirC"))
+
+        self.assertEqual(len(set(base.glob("*"))), 100)
+        self.assertEqual(len(set(base.glob("*/"))), 50)
+        self.assertEqual(len(set(base.glob("*/fileC"))), 50)
+        self.assertEqual(len(set(base.glob("*/file*"))), 50)
+
+    @needs_symlinks
+    def test_glob_long_symlink(self):
+        # See gh-87695
+        base = self.cls(self.base) / 'long_symlink'
+        base.mkdir()
+        bad_link = base / 'bad_link'
+        bad_link.symlink_to("bad" * 200)
+        self.assertEqual(sorted(base.glob('**/*')), [bad_link])
+
+    @needs_symlinks
+    def test_readlink(self):
+        P = self.cls(self.base)
+        self.assertEqual((P / 'linkA').readlink(), self.cls('fileA'))
+        self.assertEqual((P / 'brokenLink').readlink(),
+                         self.cls('non-existing'))
+        self.assertEqual((P / 'linkB').readlink(), self.cls('dirB'))
+        self.assertEqual((P / 'linkB' / 'linkD').readlink(), self.cls('../dirB'))
+        with self.assertRaises(OSError):
+            (P / 'fileA').readlink()
+
+    @unittest.skipIf(hasattr(os, "readlink"), "os.readlink() is present")
+    def test_readlink_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        with self.assertRaises(UnsupportedOperation):
+            q.readlink(p)
+
+    def _check_resolve(self, p, expected, strict=True):
+        q = p.resolve(strict)
+        self.assertEqual(q, expected)
+
+    # This can be used to check both relative and absolute resolutions.
+    _check_resolve_relative = _check_resolve_absolute = _check_resolve
+
+    @needs_symlinks
+    def test_resolve_common(self):
+        P = self.cls
+        p = P(self.base, 'foo')
+        with self.assertRaises(OSError) as cm:
+            p.resolve(strict=True)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        # Non-strict
+        parser = self.parser
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(self.base, 'foo'))
+        p = P(self.base, 'foo', 'in', 'spam')
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(self.base, 'foo', 'in', 'spam'))
+        p = P(self.base, '..', 'foo', 'in', 'spam')
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(parser.dirname(self.base), 'foo', 'in', 'spam'))
+        # These are all relative symlinks.
+        p = P(self.base, 'dirB', 'fileB')
+        self._check_resolve_relative(p, p)
+        p = P(self.base, 'linkA')
+        self._check_resolve_relative(p, P(self.base, 'fileA'))
+        p = P(self.base, 'dirA', 'linkC', 'fileB')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB'))
+        p = P(self.base, 'dirB', 'linkD', 'fileB')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB'))
+        # Non-strict
+        p = P(self.base, 'dirA', 'linkC', 'fileB', 'foo', 'in', 'spam')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB', 'foo', 'in',
+                                          'spam'), False)
+        p = P(self.base, 'dirA', 'linkC', '..', 'foo', 'in', 'spam')
+        if self.cls.parser is not posixpath:
+            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
+            # resolves to 'dirA' without resolving linkY first.
+            self._check_resolve_relative(p, P(self.base, 'dirA', 'foo', 'in',
+                                              'spam'), False)
+        else:
+            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
+            # resolves to 'dirB/..' first before resolving to parent of dirB.
+            self._check_resolve_relative(p, P(self.base, 'foo', 'in', 'spam'), False)
+        # Now create absolute symlinks.
+        d = self.tempdir()
+        P(self.base, 'dirA', 'linkX').symlink_to(d)
+        P(self.base, str(d), 'linkY').symlink_to(self.parser.join(self.base, 'dirB'))
+        p = P(self.base, 'dirA', 'linkX', 'linkY', 'fileB')
+        self._check_resolve_absolute(p, P(self.base, 'dirB', 'fileB'))
+        # Non-strict
+        p = P(self.base, 'dirA', 'linkX', 'linkY', 'foo', 'in', 'spam')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'foo', 'in', 'spam'),
+                                     False)
+        p = P(self.base, 'dirA', 'linkX', 'linkY', '..', 'foo', 'in', 'spam')
+        if self.cls.parser is not posixpath:
+            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
+            # resolves to 'dirA' without resolving linkY first.
+            self._check_resolve_relative(p, P(d, 'foo', 'in', 'spam'), False)
+        else:
+            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
+            # resolves to 'dirB/..' first before resolving to parent of dirB.
+            self._check_resolve_relative(p, P(self.base, 'foo', 'in', 'spam'), False)
+
+    @needs_symlinks
+    def test_resolve_dot(self):
+        # See http://web.archive.org/web/20200623062557/https://bitbucket.org/pitrou/pathlib/issues/9/
+        parser = self.parser
+        p = self.cls(self.base)
+        p.joinpath('0').symlink_to('.', target_is_directory=True)
+        p.joinpath('1').symlink_to(parser.join('0', '0'), target_is_directory=True)
+        p.joinpath('2').symlink_to(parser.join('1', '1'), target_is_directory=True)
+        q = p / '2'
+        self.assertEqual(q.resolve(strict=True), p)
+        r = q / '3' / '4'
+        self.assertRaises(FileNotFoundError, r.resolve, strict=True)
+        # Non-strict
+        self.assertEqual(r.resolve(strict=False), p / '3' / '4')
+
+    def _check_symlink_loop(self, *args):
+        path = self.cls(*args)
+        with self.assertRaises(OSError) as cm:
+            path.resolve(strict=True)
+        self.assertEqual(cm.exception.errno, errno.ELOOP)
+
+    @needs_posix
+    @needs_symlinks
+    def test_resolve_loop(self):
+        # Loops with relative symlinks.
+        self.cls(self.base, 'linkX').symlink_to('linkX/inside')
+        self._check_symlink_loop(self.base, 'linkX')
+        self.cls(self.base, 'linkY').symlink_to('linkY')
+        self._check_symlink_loop(self.base, 'linkY')
+        self.cls(self.base, 'linkZ').symlink_to('linkZ/../linkZ')
+        self._check_symlink_loop(self.base, 'linkZ')
+        # Non-strict
+        p = self.cls(self.base, 'linkZ', 'foo')
+        self.assertEqual(p.resolve(strict=False), p)
+        # Loops with absolute symlinks.
+        self.cls(self.base, 'linkU').symlink_to(self.parser.join(self.base, 'linkU/inside'))
+        self._check_symlink_loop(self.base, 'linkU')
+        self.cls(self.base, 'linkV').symlink_to(self.parser.join(self.base, 'linkV'))
+        self._check_symlink_loop(self.base, 'linkV')
+        self.cls(self.base, 'linkW').symlink_to(self.parser.join(self.base, 'linkW/../linkW'))
+        self._check_symlink_loop(self.base, 'linkW')
+        # Non-strict
+        q = self.cls(self.base, 'linkW', 'foo')
+        self.assertEqual(q.resolve(strict=False), q)
+
+    def test_stat(self):
+        statA = self.cls(self.base).joinpath('fileA').stat()
+        statB = self.cls(self.base).joinpath('dirB', 'fileB').stat()
+        statC = self.cls(self.base).joinpath('dirC').stat()
+        # st_mode: files are the same, directory differs.
+        self.assertIsInstance(statA.st_mode, int)
+        self.assertEqual(statA.st_mode, statB.st_mode)
+        self.assertNotEqual(statA.st_mode, statC.st_mode)
+        self.assertNotEqual(statB.st_mode, statC.st_mode)
+        # st_ino: all different,
+        self.assertIsInstance(statA.st_ino, int)
+        self.assertNotEqual(statA.st_ino, statB.st_ino)
+        self.assertNotEqual(statA.st_ino, statC.st_ino)
+        self.assertNotEqual(statB.st_ino, statC.st_ino)
+        # st_dev: all the same.
+        self.assertIsInstance(statA.st_dev, int)
+        self.assertEqual(statA.st_dev, statB.st_dev)
+        self.assertEqual(statA.st_dev, statC.st_dev)
+        # other attributes not used by pathlib.
+
+    @needs_symlinks
+    def test_stat_no_follow_symlinks(self):
+        p = self.cls(self.base) / 'linkA'
+        st = p.stat()
+        self.assertNotEqual(st, p.stat(follow_symlinks=False))
+
+    def test_stat_no_follow_symlinks_nosymlink(self):
+        p = self.cls(self.base) / 'fileA'
+        st = p.stat()
+        self.assertEqual(st, p.stat(follow_symlinks=False))
+
+    @needs_symlinks
+    def test_lstat(self):
+        p = self.cls(self.base)/ 'linkA'
+        st = p.stat()
+        self.assertNotEqual(st, p.lstat())
+
+    def test_lstat_nosymlink(self):
+        p = self.cls(self.base) / 'fileA'
+        st = p.stat()
+        self.assertEqual(st, p.lstat())
+
+    def test_is_dir(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'dirA').is_dir())
+        self.assertFalse((P / 'fileA').is_dir())
+        self.assertFalse((P / 'non-existing').is_dir())
+        self.assertFalse((P / 'fileA' / 'bah').is_dir())
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_dir())
+            self.assertTrue((P / 'linkB').is_dir())
+            self.assertFalse((P/ 'brokenLink').is_dir())
+        self.assertFalse((P / 'dirA\udfff').is_dir())
+        self.assertFalse((P / 'dirA\x00').is_dir())
+
+    def test_is_dir_no_follow_symlinks(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'dirA').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'fileA').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'non-existing').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'fileA' / 'bah').is_dir(follow_symlinks=False))
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_dir(follow_symlinks=False))
+            self.assertFalse((P / 'linkB').is_dir(follow_symlinks=False))
+            self.assertFalse((P/ 'brokenLink').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'dirA\udfff').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'dirA\x00').is_dir(follow_symlinks=False))
+
+    def test_is_file(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'fileA').is_file())
+        self.assertFalse((P / 'dirA').is_file())
+        self.assertFalse((P / 'non-existing').is_file())
+        self.assertFalse((P / 'fileA' / 'bah').is_file())
+        if self.can_symlink:
+            self.assertTrue((P / 'linkA').is_file())
+            self.assertFalse((P / 'linkB').is_file())
+            self.assertFalse((P/ 'brokenLink').is_file())
+        self.assertFalse((P / 'fileA\udfff').is_file())
+        self.assertFalse((P / 'fileA\x00').is_file())
+
+    def test_is_file_no_follow_symlinks(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'fileA').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'dirA').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'non-existing').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA' / 'bah').is_file(follow_symlinks=False))
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_file(follow_symlinks=False))
+            self.assertFalse((P / 'linkB').is_file(follow_symlinks=False))
+            self.assertFalse((P/ 'brokenLink').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA\udfff').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA\x00').is_file(follow_symlinks=False))
+
+    def test_is_mount(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_mount())
+        self.assertFalse((P / 'dirA').is_mount())
+        self.assertFalse((P / 'non-existing').is_mount())
+        self.assertFalse((P / 'fileA' / 'bah').is_mount())
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_mount())
+
+    def test_is_symlink(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_symlink())
+        self.assertFalse((P / 'dirA').is_symlink())
+        self.assertFalse((P / 'non-existing').is_symlink())
+        self.assertFalse((P / 'fileA' / 'bah').is_symlink())
+        if self.can_symlink:
+            self.assertTrue((P / 'linkA').is_symlink())
+            self.assertTrue((P / 'linkB').is_symlink())
+            self.assertTrue((P/ 'brokenLink').is_symlink())
+        self.assertIs((P / 'fileA\udfff').is_file(), False)
+        self.assertIs((P / 'fileA\x00').is_file(), False)
+        if self.can_symlink:
+            self.assertIs((P / 'linkA\udfff').is_file(), False)
+            self.assertIs((P / 'linkA\x00').is_file(), False)
+
+    def test_is_junction_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_junction())
+        self.assertFalse((P / 'dirA').is_junction())
+        self.assertFalse((P / 'non-existing').is_junction())
+        self.assertFalse((P / 'fileA' / 'bah').is_junction())
+        self.assertFalse((P / 'fileA\udfff').is_junction())
+        self.assertFalse((P / 'fileA\x00').is_junction())
+
+    def test_is_fifo_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_fifo())
+        self.assertFalse((P / 'dirA').is_fifo())
+        self.assertFalse((P / 'non-existing').is_fifo())
+        self.assertFalse((P / 'fileA' / 'bah').is_fifo())
+        self.assertIs((P / 'fileA\udfff').is_fifo(), False)
+        self.assertIs((P / 'fileA\x00').is_fifo(), False)
+
+    def test_is_socket_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_socket())
+        self.assertFalse((P / 'dirA').is_socket())
+        self.assertFalse((P / 'non-existing').is_socket())
+        self.assertFalse((P / 'fileA' / 'bah').is_socket())
+        self.assertIs((P / 'fileA\udfff').is_socket(), False)
+        self.assertIs((P / 'fileA\x00').is_socket(), False)
+
+    def test_is_block_device_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_block_device())
+        self.assertFalse((P / 'dirA').is_block_device())
+        self.assertFalse((P / 'non-existing').is_block_device())
+        self.assertFalse((P / 'fileA' / 'bah').is_block_device())
+        self.assertIs((P / 'fileA\udfff').is_block_device(), False)
+        self.assertIs((P / 'fileA\x00').is_block_device(), False)
+
+    def test_is_char_device_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_char_device())
+        self.assertFalse((P / 'dirA').is_char_device())
+        self.assertFalse((P / 'non-existing').is_char_device())
+        self.assertFalse((P / 'fileA' / 'bah').is_char_device())
+        self.assertIs((P / 'fileA\udfff').is_char_device(), False)
+        self.assertIs((P / 'fileA\x00').is_char_device(), False)
+
+    def _check_complex_symlinks(self, link0_target):
+        # Test solving a non-looping chain of symlinks (issue #19887).
+        parser = self.parser
+        P = self.cls(self.base)
+        P.joinpath('link1').symlink_to(parser.join('link0', 'link0'), target_is_directory=True)
+        P.joinpath('link2').symlink_to(parser.join('link1', 'link1'), target_is_directory=True)
+        P.joinpath('link3').symlink_to(parser.join('link2', 'link2'), target_is_directory=True)
+        P.joinpath('link0').symlink_to(link0_target, target_is_directory=True)
+
+        # Resolve absolute paths.
+        p = (P / 'link0').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link1').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link2').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link3').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+
+        # Resolve relative paths.
+        try:
+            self.cls('').absolute()
+        except UnsupportedOperation:
+            return
+        old_path = os.getcwd()
+        os.chdir(self.base)
+        try:
+            p = self.cls('link0').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link1').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link2').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link3').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+        finally:
+            os.chdir(old_path)
+
+    @needs_symlinks
+    def test_complex_symlinks_absolute(self):
+        self._check_complex_symlinks(self.base)
+
+    @needs_symlinks
+    def test_complex_symlinks_relative(self):
+        self._check_complex_symlinks('.')
+
+    @needs_symlinks
+    def test_complex_symlinks_relative_dot_dot(self):
+        self._check_complex_symlinks(self.parser.join('dirA', '..'))
+
+    def setUpWalk(self):
+        # Build:
+        #     TESTFN/
+        #       TEST1/              a file kid and two directory kids
+        #         tmp1
+        #         SUB1/             a file kid and a directory kid
+        #           tmp2
+        #           SUB11/          no kids
+        #         SUB2/             a file kid and a dirsymlink kid
+        #           tmp3
+        #           link/           a symlink to TEST2
+        #           broken_link
+        #           broken_link2
+        #       TEST2/
+        #         tmp4              a lone file
+        self.walk_path = self.cls(self.base, "TEST1")
+        self.sub1_path = self.walk_path / "SUB1"
+        self.sub11_path = self.sub1_path / "SUB11"
+        self.sub2_path = self.walk_path / "SUB2"
+        tmp1_path = self.walk_path / "tmp1"
+        tmp2_path = self.sub1_path / "tmp2"
+        tmp3_path = self.sub2_path / "tmp3"
+        self.link_path = self.sub2_path / "link"
+        t2_path = self.cls(self.base, "TEST2")
+        tmp4_path = self.cls(self.base, "TEST2", "tmp4")
+        broken_link_path = self.sub2_path / "broken_link"
+        broken_link2_path = self.sub2_path / "broken_link2"
+
+        self.sub11_path.mkdir(parents=True)
+        self.sub2_path.mkdir(parents=True)
+        t2_path.mkdir(parents=True)
+
+        for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path:
+            with path.open("w", encoding='utf-8') as f:
+                f.write(f"I'm {path} and proud of it.  Blame test_pathlib.\n")
+
+        if self.can_symlink:
+            self.link_path.symlink_to(t2_path)
+            broken_link_path.symlink_to('broken')
+            broken_link2_path.symlink_to(self.cls('tmp3', 'broken'))
+            self.sub2_tree = (self.sub2_path, [], ["broken_link", "broken_link2", "link", "tmp3"])
+        else:
+            self.sub2_tree = (self.sub2_path, [], ["tmp3"])
+
+    def test_walk_topdown(self):
+        self.setUpWalk()
+        walker = self.walk_path.walk()
+        entry = next(walker)
+        entry[1].sort()  # Ensure we visit SUB1 before SUB2
+        self.assertEqual(entry, (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
+        entry = next(walker)
+        self.assertEqual(entry, (self.sub1_path, ["SUB11"], ["tmp2"]))
+        entry = next(walker)
+        self.assertEqual(entry, (self.sub11_path, [], []))
+        entry = next(walker)
+        entry[1].sort()
+        entry[2].sort()
+        self.assertEqual(entry, self.sub2_tree)
+        with self.assertRaises(StopIteration):
+            next(walker)
+
+    def test_walk_prune(self):
+        self.setUpWalk()
+        # Prune the search.
+        all = []
+        for root, dirs, files in self.walk_path.walk():
+            all.append((root, dirs, files))
+            if 'SUB1' in dirs:
+                # Note that this also mutates the dirs we appended to all!
+                dirs.remove('SUB1')
+
+        self.assertEqual(len(all), 2)
+        self.assertEqual(all[0], (self.walk_path, ["SUB2"], ["tmp1"]))
+
+        all[1][-1].sort()
+        all[1][1].sort()
+        self.assertEqual(all[1], self.sub2_tree)
+
+    def test_walk_bottom_up(self):
+        self.setUpWalk()
+        seen_testfn = seen_sub1 = seen_sub11 = seen_sub2 = False
+        for path, dirnames, filenames in self.walk_path.walk(top_down=False):
+            if path == self.walk_path:
+                self.assertFalse(seen_testfn)
+                self.assertTrue(seen_sub1)
+                self.assertTrue(seen_sub2)
+                self.assertEqual(sorted(dirnames), ["SUB1", "SUB2"])
+                self.assertEqual(filenames, ["tmp1"])
+                seen_testfn = True
+            elif path == self.sub1_path:
+                self.assertFalse(seen_testfn)
+                self.assertFalse(seen_sub1)
+                self.assertTrue(seen_sub11)
+                self.assertEqual(dirnames, ["SUB11"])
+                self.assertEqual(filenames, ["tmp2"])
+                seen_sub1 = True
+            elif path == self.sub11_path:
+                self.assertFalse(seen_sub1)
+                self.assertFalse(seen_sub11)
+                self.assertEqual(dirnames, [])
+                self.assertEqual(filenames, [])
+                seen_sub11 = True
+            elif path == self.sub2_path:
+                self.assertFalse(seen_testfn)
+                self.assertFalse(seen_sub2)
+                self.assertEqual(sorted(dirnames), sorted(self.sub2_tree[1]))
+                self.assertEqual(sorted(filenames), sorted(self.sub2_tree[2]))
+                seen_sub2 = True
+            else:
+                raise AssertionError(f"Unexpected path: {path}")
+        self.assertTrue(seen_testfn)
+
+    @needs_symlinks
+    def test_walk_follow_symlinks(self):
+        self.setUpWalk()
+        walk_it = self.walk_path.walk(follow_symlinks=True)
+        for root, dirs, files in walk_it:
+            if root == self.link_path:
+                self.assertEqual(dirs, [])
+                self.assertEqual(files, ["tmp4"])
+                break
+        else:
+            self.fail("Didn't follow symlink with follow_symlinks=True")
+
+    @needs_symlinks
+    def test_walk_symlink_location(self):
+        self.setUpWalk()
+        # Tests whether symlinks end up in filenames or dirnames depending
+        # on the `follow_symlinks` argument.
+        walk_it = self.walk_path.walk(follow_symlinks=False)
+        for root, dirs, files in walk_it:
+            if root == self.sub2_path:
+                self.assertIn("link", files)
+                break
+        else:
+            self.fail("symlink not found")
+
+        walk_it = self.walk_path.walk(follow_symlinks=True)
+        for root, dirs, files in walk_it:
+            if root == self.sub2_path:
+                self.assertIn("link", dirs)
+                break
+        else:
+            self.fail("symlink not found")
+
+
+class DummyPathWithSymlinks(DummyPath):
+    __slots__ = ()
+
+    # Reduce symlink traversal limit to make tests run faster.
+    _max_symlinks = 20
+
+    def readlink(self):
+        path = str(self.parent.resolve() / self.name)
+        if path in self._symlinks:
+            return self.with_segments(self._symlinks[path])
+        elif path in self._files or path in self._directories:
+            raise OSError(errno.EINVAL, "Not a symlink", path)
+        else:
+            raise FileNotFoundError(errno.ENOENT, "File not found", path)
+
+    def symlink_to(self, target, target_is_directory=False):
+        self._directories[str(self.parent)].add(self.name)
+        self._symlinks[str(self)] = str(target)
+
+
+class DummyPathWithSymlinksTest(DummyPathTest):
+    cls = DummyPathWithSymlinks
+    can_symlink = True
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index 82f1d9dc2e7..aee9fb78017 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -10,7 +10,9 @@
 from unittest.mock import patch
 from test import support
 from test.support import os_helper
+from test.support import socket_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 import os
 try:
     import ssl
@@ -18,12 +20,15 @@
     ssl = None
 import sys
 import tempfile
-from nturl2path import url2pathname, pathname2url
 
 from base64 import b64encode
 import collections
 
 
+if not socket_helper.has_gethostname:
+    raise unittest.SkipTest("test requires gethostname()")
+
+
 def hexescape(char):
     """Escape char as RFC 2396 specifies"""
     hex_repr = hex(ord(char))[2:].upper()
@@ -135,7 +140,7 @@ def unfakeftp(self):
         urllib.request.ftpwrapper = self._ftpwrapper_class
 
 
-class urlopen_FileTests(unittest.TestCase):
+class urlopen_FileTests(unittest.TestCase, ExtraAssertions):
     """Test urlopen() opening a temporary file.
 
     Try to test as much functionality as possible so as to cut down on reliance
@@ -153,7 +158,7 @@ def setUp(self):
         finally:
             f.close()
         self.pathname = os_helper.TESTFN
-        self.quoted_pathname = urllib.parse.quote(self.pathname)
+        self.quoted_pathname = urllib.parse.quote(os.fsencode(self.pathname))
         self.returned_obj = urlopen("file:%s" % self.quoted_pathname)
 
     def tearDown(self):
@@ -165,9 +170,7 @@ def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines", "fileno",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertTrue(hasattr(self.returned_obj, attr),
-                         "object returned by urlopen() lacks %s attribute" %
-                         attr)
+            self.assertHasAttr(self.returned_obj, attr)
 
     def test_read(self):
         self.assertEqual(self.text, self.returned_obj.read())
@@ -232,17 +235,12 @@ class ProxyTests(unittest.TestCase):
 
     def setUp(self):
         # Records changes to env vars
-        self.env = os_helper.EnvironmentVarGuard()
+        self.env = self.enterContext(os_helper.EnvironmentVarGuard())
         # Delete all proxy related env vars
         for k in list(os.environ):
             if 'proxy' in k.lower():
                 self.env.unset(k)
 
-    def tearDown(self):
-        # Restore all proxy related env vars
-        self.env.__exit__()
-        del self.env
-
     def test_getproxies_environment_keep_no_proxies(self):
         self.env.set('NO_PROXY', 'localhost')
         proxies = urllib.request.getproxies_environment()
@@ -477,7 +475,9 @@ def test_read_bogus(self):
 Content-Type: text/html; charset=iso-8859-1
 ''', mock_close=True)
         try:
-            self.assertRaises(OSError, urlopen, "http://python.org/")
+            with self.assertRaises(urllib.error.HTTPError) as cm:
+                urllib.request.urlopen("http://python.org/")
+            cm.exception.close()
         finally:
             self.unfakehttp()
 
@@ -492,8 +492,9 @@ def test_invalid_redirect(self):
 ''', mock_close=True)
         try:
             msg = "Redirection to url 'file:"
-            with self.assertRaisesRegex(urllib.error.HTTPError, msg):
-                urlopen("http://python.org/")
+            with self.assertRaisesRegex(urllib.error.HTTPError, msg) as cm:
+                urllib.request.urlopen("http://python.org/")
+            cm.exception.close()
         finally:
             self.unfakehttp()
 
@@ -506,8 +507,9 @@ def test_redirect_limit_independent(self):
 Connection: close
 ''', mock_close=True)
             try:
-                self.assertRaises(urllib.error.HTTPError, urlopen,
-                    "http://something")
+                with self.assertRaises(urllib.error.HTTPError) as cm:
+                    urllib.request.urlopen("http://something")
+                cm.exception.close()
             finally:
                 self.unfakehttp()
 
@@ -597,17 +599,8 @@ def test_URLopener_deprecation(self):
         with warnings_helper.check_warnings(('',DeprecationWarning)):
             urllib.request.URLopener()
 
-    @unittest.skipUnless(ssl, "ssl module required")
-    def test_cafile_and_context(self):
-        context = ssl.create_default_context()
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            with self.assertRaises(ValueError):
-                urllib.request.urlopen(
-                    "https://localhost", cafile="/nonexistent/path", context=context
-                )
-
 
-class urlopen_DataTests(unittest.TestCase):
+class urlopen_DataTests(unittest.TestCase, ExtraAssertions):
     """Test urlopen() opening a data URL."""
 
     def setUp(self):
@@ -636,18 +629,17 @@ def setUp(self):
             "QOjdAAAAAXNSR0IArs4c6QAAAA9JREFUCNdj%0AYGBg%2BP//PwAGAQL%2BCm8 "
             "vHgAAAABJRU5ErkJggg%3D%3D%0A%20")
 
-        self.text_url_resp = urllib.request.urlopen(self.text_url)
-        self.text_url_base64_resp = urllib.request.urlopen(
-            self.text_url_base64)
-        self.image_url_resp = urllib.request.urlopen(self.image_url)
+        self.text_url_resp = self.enterContext(
+            urllib.request.urlopen(self.text_url))
+        self.text_url_base64_resp = self.enterContext(
+            urllib.request.urlopen(self.text_url_base64))
+        self.image_url_resp = self.enterContext(urllib.request.urlopen(self.image_url))
 
     def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertTrue(hasattr(self.text_url_resp, attr),
-                         "object returned by urlopen() lacks %s attribute" %
-                         attr)
+            self.assertHasAttr(self.text_url_resp, attr)
 
     def test_info(self):
         self.assertIsInstance(self.text_url_resp.info(), email.message.Message)
@@ -655,8 +647,10 @@ def test_info(self):
             [('text/plain', ''), ('charset', 'ISO-8859-1')])
         self.assertEqual(self.image_url_resp.info()['content-length'],
             str(len(self.image)))
-        self.assertEqual(urllib.request.urlopen("data:,").info().get_params(),
+        r = urllib.request.urlopen("data:,")
+        self.assertEqual(r.info().get_params(),
             [('text/plain', ''), ('charset', 'US-ASCII')])
+        r.close()
 
     def test_geturl(self):
         self.assertEqual(self.text_url_resp.geturl(), self.text_url)
@@ -719,10 +713,6 @@ def tearDown(self):
 
     def constructLocalFileUrl(self, filePath):
         filePath = os.path.abspath(filePath)
-        try:
-            filePath.encode("utf-8")
-        except UnicodeEncodeError:
-            raise unittest.SkipTest("filePath is not encodable to utf8")
         return "file://%s" % urllib.request.pathname2url(filePath)
 
     def createNewTempFile(self, data=b""):
@@ -1104,6 +1094,8 @@ def test_unquoting(self):
         self.assertEqual(result.count('%'), 1,
                          "using unquote(): not all characters escaped: "
                          "%s" % result)
+
+    def test_unquote_rejects_none_and_tuple(self):
         self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, None)
         self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, ())
 
@@ -1527,39 +1519,121 @@ def test_quoting(self):
                          (expect, result))
 
     @unittest.skipUnless(sys.platform == 'win32',
-                         'test specific to the nturl2path functions.')
-    def test_prefixes(self):
+                         'test specific to Windows pathnames.')
+    def test_pathname2url_win(self):
         # Test special prefixes are correctly handled in pathname2url()
-        given = '\\\\?\\C:\\dir'
-        expect = '///C:/dir'
-        result = urllib.request.pathname2url(given)
-        self.assertEqual(expect, result,
-                         "pathname2url() failed; %s != %s" %
-                         (expect, result))
-        given = '\\\\?\\unc\\server\\share\\dir'
-        expect = '/server/share/dir'
-        result = urllib.request.pathname2url(given)
-        self.assertEqual(expect, result,
-                         "pathname2url() failed; %s != %s" %
-                         (expect, result))
-
+        fn = urllib.request.pathname2url
+        self.assertEqual(fn('\\\\?\\C:\\dir'), '///C:/dir')
+        self.assertEqual(fn('\\\\?\\unc\\server\\share\\dir'), '//server/share/dir')
+        self.assertEqual(fn("C:"), '///C:')
+        self.assertEqual(fn("C:\\"), '///C:/')
+        self.assertEqual(fn('C:\\a\\b.c'), '///C:/a/b.c')
+        self.assertEqual(fn('C:\\a\\b.c\\'), '///C:/a/b.c/')
+        self.assertEqual(fn('C:\\a\\\\b.c'), '///C:/a//b.c')
+        self.assertEqual(fn('C:\\a\\b%#c'), '///C:/a/b%25%23c')
+        self.assertEqual(fn('C:\\a\\b\xe9'), '///C:/a/b%C3%A9')
+        self.assertEqual(fn('C:\\foo\\bar\\spam.foo'), "///C:/foo/bar/spam.foo")
+        # Long drive letter
+        self.assertRaises(IOError, fn, "XX:\\")
+        # No drive letter
+        self.assertEqual(fn("\\folder\\test\\"), '/folder/test/')
+        self.assertEqual(fn("\\\\folder\\test\\"), '//folder/test/')
+        self.assertEqual(fn("\\\\\\folder\\test\\"), '///folder/test/')
+        self.assertEqual(fn('\\\\some\\share\\'), '//some/share/')
+        self.assertEqual(fn('\\\\some\\share\\a\\b.c'), '//some/share/a/b.c')
+        self.assertEqual(fn('\\\\some\\share\\a\\b%#c\xe9'), '//some/share/a/b%25%23c%C3%A9')
+        # Alternate path separator
+        self.assertEqual(fn('C:/a/b.c'), '///C:/a/b.c')
+        self.assertEqual(fn('//some/share/a/b.c'), '//some/share/a/b.c')
+        self.assertEqual(fn('//?/C:/dir'), '///C:/dir')
+        self.assertEqual(fn('//?/unc/server/share/dir'), '//server/share/dir')
+        # Round-tripping
+        urls = ['///C:',
+                '/folder/test/',
+                '///C:/foo/bar/spam.foo']
+        for url in urls:
+            self.assertEqual(fn(urllib.request.url2pathname(url)), url)
+
+    @unittest.skipIf(sys.platform == 'win32',
+                     'test specific to POSIX pathnames')
+    @unittest.expectedFailure # AssertionError: '//a/b.c' != '////a/b.c'
+    def test_pathname2url_posix(self):
+        fn = urllib.request.pathname2url
+        self.assertEqual(fn('/'), '/')
+        self.assertEqual(fn('/a/b.c'), '/a/b.c')
+        self.assertEqual(fn('//a/b.c'), '////a/b.c')
+        self.assertEqual(fn('///a/b.c'), '/////a/b.c')
+        self.assertEqual(fn('////a/b.c'), '//////a/b.c')
+        self.assertEqual(fn('/a/b%#c'), '/a/b%25%23c')
+
+    @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
+    def test_pathname2url_nonascii(self):
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        url = urllib.parse.quote(os_helper.FS_NONASCII, encoding=encoding, errors=errors)
+        self.assertEqual(urllib.request.pathname2url(os_helper.FS_NONASCII), url)
 
     @unittest.skipUnless(sys.platform == 'win32',
-                         'test specific to the urllib.url2path function.')
-    def test_ntpath(self):
-        given = ('/C:/', '///C:/', '/C|//')
-        expect = 'C:\\'
-        for url in given:
-            result = urllib.request.url2pathname(url)
-            self.assertEqual(expect, result,
-                             'urllib.request..url2pathname() failed; %s != %s' %
-                             (expect, result))
-        given = '///C|/path'
-        expect = 'C:\\path'
-        result = urllib.request.url2pathname(given)
-        self.assertEqual(expect, result,
-                         'urllib.request.url2pathname() failed; %s != %s' %
-                         (expect, result))
+                         'test specific to Windows pathnames.')
+    def test_url2pathname_win(self):
+        fn = urllib.request.url2pathname
+        self.assertEqual(fn('/C:/'), 'C:\\')
+        self.assertEqual(fn("///C|"), 'C:')
+        self.assertEqual(fn("///C:"), 'C:')
+        self.assertEqual(fn('///C:/'), 'C:\\')
+        self.assertEqual(fn('/C|//'), 'C:\\\\')
+        self.assertEqual(fn('///C|/path'), 'C:\\path')
+        # No DOS drive
+        self.assertEqual(fn("///C/test/"), '\\C\\test\\')
+        self.assertEqual(fn("////C/test/"), '\\\\C\\test\\')
+        # DOS drive paths
+        self.assertEqual(fn('C:/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('C:/path/to/file/'), 'C:\\path\\to\\file\\')
+        self.assertEqual(fn('C:/path/to//file'), 'C:\\path\\to\\\\file')
+        self.assertEqual(fn('C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('/C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('///C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn("///C|/foo/bar/spam.foo"), 'C:\\foo\\bar\\spam.foo')
+        # Non-ASCII drive letter
+        self.assertRaises(IOError, fn, "///\u00e8|/")
+        # UNC paths
+        self.assertEqual(fn('//server/path/to/file'), '\\\\server\\path\\to\\file')
+        self.assertEqual(fn('////server/path/to/file'), '\\\\server\\path\\to\\file')
+        self.assertEqual(fn('/////server/path/to/file'), '\\\\server\\path\\to\\file')
+        # Localhost paths
+        self.assertEqual(fn('//localhost/C:/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('//localhost/C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('//localhost/path/to/file'), '\\path\\to\\file')
+        self.assertEqual(fn('//localhost//server/path/to/file'), '\\\\server\\path\\to\\file')
+        # Percent-encoded forward slashes are preserved for backwards compatibility
+        self.assertEqual(fn('C:/foo%2fbar'), 'C:\\foo/bar')
+        self.assertEqual(fn('//server/share/foo%2fbar'), '\\\\server\\share\\foo/bar')
+        # Round-tripping
+        paths = ['C:',
+                 r'\C\test\\',
+                 r'C:\foo\bar\spam.foo']
+        for path in paths:
+            self.assertEqual(fn(urllib.request.pathname2url(path)), path)
+
+    @unittest.skipIf(sys.platform == 'win32',
+                     'test specific to POSIX pathnames')
+    @unittest.expectedFailure # AssertionError: '///foo/bar' != '/foo/bar'
+    def test_url2pathname_posix(self):
+        fn = urllib.request.url2pathname
+        self.assertEqual(fn('/foo/bar'), '/foo/bar')
+        self.assertEqual(fn('//foo/bar'), '//foo/bar')
+        self.assertEqual(fn('///foo/bar'), '/foo/bar')
+        self.assertEqual(fn('////foo/bar'), '//foo/bar')
+        self.assertEqual(fn('//localhost/foo/bar'), '/foo/bar')
+
+    @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
+    def test_url2pathname_nonascii(self):
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        url = os_helper.FS_NONASCII
+        self.assertEqual(urllib.request.url2pathname(url), os_helper.FS_NONASCII)
+        url = urllib.parse.quote(url, encoding=encoding, errors=errors)
+        self.assertEqual(urllib.request.url2pathname(url), os_helper.FS_NONASCII)
 
 class Utility_Tests(unittest.TestCase):
     """Testcase to test the various utility functions in the urllib."""
@@ -1643,60 +1717,5 @@ def test_with_method_arg(self):
         self.assertEqual(request.get_method(), 'HEAD')
 
 
-class URL2PathNameTests(unittest.TestCase):
-
-    def test_converting_drive_letter(self):
-        self.assertEqual(url2pathname("///C|"), 'C:')
-        self.assertEqual(url2pathname("///C:"), 'C:')
-        self.assertEqual(url2pathname("///C|/"), 'C:\\')
-
-    def test_converting_when_no_drive_letter(self):
-        # cannot end a raw string in \
-        self.assertEqual(url2pathname("///C/test/"), r'\\\C\test' '\\')
-        self.assertEqual(url2pathname("////C/test/"), r'\\C\test' '\\')
-
-    def test_simple_compare(self):
-        self.assertEqual(url2pathname("///C|/foo/bar/spam.foo"),
-                         r'C:\foo\bar\spam.foo')
-
-    def test_non_ascii_drive_letter(self):
-        self.assertRaises(IOError, url2pathname, "///\u00e8|/")
-
-    def test_roundtrip_url2pathname(self):
-        list_of_paths = ['C:',
-                         r'\\\C\test\\',
-                         r'C:\foo\bar\spam.foo'
-                         ]
-        for path in list_of_paths:
-            self.assertEqual(url2pathname(pathname2url(path)), path)
-
-class PathName2URLTests(unittest.TestCase):
-
-    def test_converting_drive_letter(self):
-        self.assertEqual(pathname2url("C:"), '///C:')
-        self.assertEqual(pathname2url("C:\\"), '///C:')
-
-    def test_converting_when_no_drive_letter(self):
-        self.assertEqual(pathname2url(r"\\\folder\test" "\\"),
-                         '/////folder/test/')
-        self.assertEqual(pathname2url(r"\\folder\test" "\\"),
-                         '////folder/test/')
-        self.assertEqual(pathname2url(r"\folder\test" "\\"),
-                         '/folder/test/')
-
-    def test_simple_compare(self):
-        self.assertEqual(pathname2url(r'C:\foo\bar\spam.foo'),
-                         "///C:/foo/bar/spam.foo" )
-
-    def test_long_drive_letter(self):
-        self.assertRaises(IOError, pathname2url, "XX:\\")
-
-    def test_roundtrip_pathname2url(self):
-        list_of_paths = ['///C:',
-                         '/////folder/test/',
-                         '///C:/foo/bar/spam.foo']
-        for path in list_of_paths:
-            self.assertEqual(pathname2url(url2pathname(path)), path)
-
 if __name__ == '__main__':
     unittest.main()

From e58cf84c711977e04489699413e5e4d45fe333af Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 14:44:53 +0900
Subject: [PATCH 143/418] Update dbm from 3.13.11, implement sqlite3 autocommit
 (#6616)

---
 Lib/dbm/__init__.py          |  21 +-
 Lib/dbm/dumb.py              |  11 +-
 Lib/dbm/gnu.py               |   3 +
 Lib/dbm/ndbm.py              |   3 +
 Lib/dbm/sqlite3.py           | 144 ++++++++++++++
 Lib/test/test_dbm.py         | 180 ++++++++++-------
 Lib/test/test_dbm_dumb.py    |  86 ++++++++-
 Lib/test/test_dbm_sqlite3.py | 362 +++++++++++++++++++++++++++++++++++
 crates/stdlib/src/sqlite.rs  | 136 +++++++++++--
 9 files changed, 851 insertions(+), 95 deletions(-)
 create mode 100644 Lib/dbm/gnu.py
 create mode 100644 Lib/dbm/ndbm.py
 create mode 100644 Lib/dbm/sqlite3.py
 create mode 100644 Lib/test/test_dbm_sqlite3.py

diff --git a/Lib/dbm/__init__.py b/Lib/dbm/__init__.py
index f65da521af4..4fdbc54e74c 100644
--- a/Lib/dbm/__init__.py
+++ b/Lib/dbm/__init__.py
@@ -5,7 +5,7 @@
         import dbm
         d = dbm.open(file, 'w', 0o666)
 
-The returned object is a dbm.gnu, dbm.ndbm or dbm.dumb object, dependent on the
+The returned object is a dbm.sqlite3, dbm.gnu, dbm.ndbm or dbm.dumb database object, dependent on the
 type of database being opened (determined by the whichdb function) in the case
 of an existing dbm. If the dbm does not exist and the create or new flag ('c'
 or 'n') was specified, the dbm type will be determined by the availability of
@@ -38,7 +38,7 @@
 class error(Exception):
     pass
 
-_names = ['dbm.gnu', 'dbm.ndbm', 'dbm.dumb']
+_names = ['dbm.sqlite3', 'dbm.gnu', 'dbm.ndbm', 'dbm.dumb']
 _defaultmod = None
 _modules = {}
 
@@ -109,17 +109,18 @@ def whichdb(filename):
     """
 
     # Check for ndbm first -- this has a .pag and a .dir file
+    filename = os.fsencode(filename)
     try:
-        f = io.open(filename + ".pag", "rb")
+        f = io.open(filename + b".pag", "rb")
         f.close()
-        f = io.open(filename + ".dir", "rb")
+        f = io.open(filename + b".dir", "rb")
         f.close()
         return "dbm.ndbm"
     except OSError:
         # some dbm emulations based on Berkeley DB generate a .db file
         # some do not, but they should be caught by the bsd checks
         try:
-            f = io.open(filename + ".db", "rb")
+            f = io.open(filename + b".db", "rb")
             f.close()
             # guarantee we can actually open the file using dbm
             # kind of overkill, but since we are dealing with emulations
@@ -134,12 +135,12 @@ def whichdb(filename):
     # Check for dumbdbm next -- this has a .dir and a .dat file
     try:
         # First check for presence of files
-        os.stat(filename + ".dat")
-        size = os.stat(filename + ".dir").st_size
+        os.stat(filename + b".dat")
+        size = os.stat(filename + b".dir").st_size
         # dumbdbm files with no keys are empty
         if size == 0:
             return "dbm.dumb"
-        f = io.open(filename + ".dir", "rb")
+        f = io.open(filename + b".dir", "rb")
         try:
             if f.read(1) in (b"'", b'"'):
                 return "dbm.dumb"
@@ -163,6 +164,10 @@ def whichdb(filename):
     if len(s) != 4:
         return ""
 
+    # Check for SQLite3 header string.
+    if s16 == b"SQLite format 3\0":
+        return "dbm.sqlite3"
+
     # Convert to 4-byte int in native byte order -- return "" if impossible
     try:
         (magic,) = struct.unpack("=l", s)
diff --git a/Lib/dbm/dumb.py b/Lib/dbm/dumb.py
index 864ad371ec9..def120ffc37 100644
--- a/Lib/dbm/dumb.py
+++ b/Lib/dbm/dumb.py
@@ -46,6 +46,7 @@ class _Database(collections.abc.MutableMapping):
     _io = _io       # for _commit()
 
     def __init__(self, filebasename, mode, flag='c'):
+        filebasename = self._os.fsencode(filebasename)
         self._mode = mode
         self._readonly = (flag == 'r')
 
@@ -54,14 +55,14 @@ def __init__(self, filebasename, mode, flag='c'):
         # where key is the string key, pos is the offset into the dat
         # file of the associated value's first byte, and siz is the number
         # of bytes in the associated value.
-        self._dirfile = filebasename + '.dir'
+        self._dirfile = filebasename + b'.dir'
 
         # The data file is a binary file pointed into by the directory
         # file, and holds the values associated with keys.  Each value
         # begins at a _BLOCKSIZE-aligned byte offset, and is a raw
         # binary 8-bit string value.
-        self._datfile = filebasename + '.dat'
-        self._bakfile = filebasename + '.bak'
+        self._datfile = filebasename + b'.dat'
+        self._bakfile = filebasename + b'.bak'
 
         # The index is an in-memory dict, mirroring the directory file.
         self._index = None  # maps keys to (pos, siz) pairs
@@ -97,7 +98,8 @@ def _update(self, flag):
         except OSError:
             if flag not in ('c', 'n'):
                 raise
-            self._modified = True
+            with self._io.open(self._dirfile, 'w', encoding="Latin-1") as f:
+                self._chmod(self._dirfile)
         else:
             with f:
                 for line in f:
@@ -133,6 +135,7 @@ def _commit(self):
                 # position; UTF-8, though, does care sometimes.
                 entry = "%r, %r\n" % (key.decode('Latin-1'), pos_and_siz_pair)
                 f.write(entry)
+        self._modified = False
 
     sync = _commit
 
diff --git a/Lib/dbm/gnu.py b/Lib/dbm/gnu.py
new file mode 100644
index 00000000000..b07a1defffd
--- /dev/null
+++ b/Lib/dbm/gnu.py
@@ -0,0 +1,3 @@
+"""Provide the _gdbm module as a dbm submodule."""
+
+from _gdbm import *
diff --git a/Lib/dbm/ndbm.py b/Lib/dbm/ndbm.py
new file mode 100644
index 00000000000..23056a29ef2
--- /dev/null
+++ b/Lib/dbm/ndbm.py
@@ -0,0 +1,3 @@
+"""Provide the _dbm module as a dbm submodule."""
+
+from _dbm import *
diff --git a/Lib/dbm/sqlite3.py b/Lib/dbm/sqlite3.py
new file mode 100644
index 00000000000..d0eed54e0f8
--- /dev/null
+++ b/Lib/dbm/sqlite3.py
@@ -0,0 +1,144 @@
+import os
+import sqlite3
+from pathlib import Path
+from contextlib import suppress, closing
+from collections.abc import MutableMapping
+
+BUILD_TABLE = """
+  CREATE TABLE IF NOT EXISTS Dict (
+    key BLOB UNIQUE NOT NULL,
+    value BLOB NOT NULL
+  )
+"""
+GET_SIZE = "SELECT COUNT (key) FROM Dict"
+LOOKUP_KEY = "SELECT value FROM Dict WHERE key = CAST(? AS BLOB)"
+STORE_KV = "REPLACE INTO Dict (key, value) VALUES (CAST(? AS BLOB), CAST(? AS BLOB))"
+DELETE_KEY = "DELETE FROM Dict WHERE key = CAST(? AS BLOB)"
+ITER_KEYS = "SELECT key FROM Dict"
+
+
+class error(OSError):
+    pass
+
+
+_ERR_CLOSED = "DBM object has already been closed"
+_ERR_REINIT = "DBM object does not support reinitialization"
+
+
+def _normalize_uri(path):
+    path = Path(path)
+    uri = path.absolute().as_uri()
+    while "//" in uri:
+        uri = uri.replace("//", "/")
+    return uri
+
+
+class _Database(MutableMapping):
+
+    def __init__(self, path, /, *, flag, mode):
+        if hasattr(self, "_cx"):
+            raise error(_ERR_REINIT)
+
+        path = os.fsdecode(path)
+        match flag:
+            case "r":
+                flag = "ro"
+            case "w":
+                flag = "rw"
+            case "c":
+                flag = "rwc"
+                Path(path).touch(mode=mode, exist_ok=True)
+            case "n":
+                flag = "rwc"
+                Path(path).unlink(missing_ok=True)
+                Path(path).touch(mode=mode)
+            case _:
+                raise ValueError("Flag must be one of 'r', 'w', 'c', or 'n', "
+                                 f"not {flag!r}")
+
+        # We use the URI format when opening the database.
+        uri = _normalize_uri(path)
+        uri = f"{uri}?mode={flag}"
+        if flag == "ro":
+            # Add immutable=1 to allow read-only SQLite access even if wal/shm missing
+            uri += "&immutable=1"
+
+        try:
+            self._cx = sqlite3.connect(uri, autocommit=True, uri=True)
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+        if flag != "ro":
+            # This is an optimization only; it's ok if it fails.
+            with suppress(sqlite3.OperationalError):
+                self._cx.execute("PRAGMA journal_mode = wal")
+
+            if flag == "rwc":
+                self._execute(BUILD_TABLE)
+
+    def _execute(self, *args, **kwargs):
+        if not self._cx:
+            raise error(_ERR_CLOSED)
+        try:
+            return closing(self._cx.execute(*args, **kwargs))
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+    def __len__(self):
+        with self._execute(GET_SIZE) as cu:
+            row = cu.fetchone()
+        return row[0]
+
+    def __getitem__(self, key):
+        with self._execute(LOOKUP_KEY, (key,)) as cu:
+            row = cu.fetchone()
+        if not row:
+            raise KeyError(key)
+        return row[0]
+
+    def __setitem__(self, key, value):
+        self._execute(STORE_KV, (key, value))
+
+    def __delitem__(self, key):
+        with self._execute(DELETE_KEY, (key,)) as cu:
+            if not cu.rowcount:
+                raise KeyError(key)
+
+    def __iter__(self):
+        try:
+            with self._execute(ITER_KEYS) as cu:
+                for row in cu:
+                    yield row[0]
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+    def close(self):
+        if self._cx:
+            self._cx.close()
+            self._cx = None
+
+    def keys(self):
+        return list(super().keys())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+def open(filename, /, flag="r", mode=0o666):
+    """Open a dbm.sqlite3 database and return the dbm object.
+
+    The 'filename' parameter is the name of the database file.
+
+    The optional 'flag' parameter can be one of ...:
+        'r' (default): open an existing database for read only access
+        'w': open an existing database for read/write access
+        'c': create a database if it does not exist; open for read/write access
+        'n': always create a new, empty database; open for read/write access
+
+    The optional 'mode' parameter is the Unix file access mode of the database;
+    only used when creating a new database. Default: 0o666.
+    """
+    return _Database(filename, flag=flag, mode=mode)
diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py
index e615d284cd3..6785aa273ac 100644
--- a/Lib/test/test_dbm.py
+++ b/Lib/test/test_dbm.py
@@ -1,23 +1,28 @@
 """Test script for the dbm.open function based on testdumbdbm.py"""
 
 import unittest
-import glob
-import test.support
-from test.support import os_helper, import_helper
+import dbm
+import os
+from test.support import import_helper
+from test.support import os_helper
+
+
+try:
+    from dbm import sqlite3 as dbm_sqlite3
+except ImportError:
+    dbm_sqlite3 = None
 
-# Skip tests if dbm module doesn't exist.
-dbm = import_helper.import_module('dbm')
 
 try:
     from dbm import ndbm
 except ImportError:
     ndbm = None
 
-_fname = os_helper.TESTFN
+dirname = os_helper.TESTFN
+_fname = os.path.join(dirname, os_helper.TESTFN)
 
 #
-# Iterates over every database module supported by dbm currently available,
-# setting dbm to use each in turn, and yielding that module
+# Iterates over every database module supported by dbm currently available.
 #
 def dbm_iterator():
     for name in dbm._names:
@@ -31,11 +36,12 @@ def dbm_iterator():
 #
 # Clean up all scratch databases we might have created during testing
 #
-def delete_files():
-    # we don't know the precise name the underlying database uses
-    # so we use glob to locate all names
-    for f in glob.glob(glob.escape(_fname) + "*"):
-        os_helper.unlink(f)
+def cleaunup_test_dir():
+    os_helper.rmtree(dirname)
+
+def setup_test_dir():
+    cleaunup_test_dir()
+    os.mkdir(dirname)
 
 
 class AnyDBMTestCase:
@@ -129,85 +135,127 @@ def test_anydbm_access(self):
         assert(f[key] == b"Python:")
         f.close()
 
+    def test_open_with_bytes(self):
+        dbm.open(os.fsencode(_fname), "c").close()
+
+    def test_open_with_pathlib_path(self):
+        dbm.open(os_helper.FakePath(_fname), "c").close()
+
+    def test_open_with_pathlib_path_bytes(self):
+        dbm.open(os_helper.FakePath(os.fsencode(_fname)), "c").close()
+
     def read_helper(self, f):
         keys = self.keys_helper(f)
         for key in self._dict:
             self.assertEqual(self._dict[key], f[key.encode("ascii")])
 
-    def tearDown(self):
-        delete_files()
+    def test_keys(self):
+        with dbm.open(_fname, 'c') as d:
+            self.assertEqual(d.keys(), [])
+            a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
+            for k, v in a:
+                d[k] = v
+            self.assertEqual(sorted(d.keys()), sorted(k for (k, v) in a))
+            for k, v in a:
+                self.assertIn(k, d)
+                self.assertEqual(d[k], v)
+            self.assertNotIn(b'xxx', d)
+            self.assertRaises(KeyError, lambda: d[b'xxx'])
+
+    def test_clear(self):
+        with dbm.open(_fname, 'c') as d:
+            self.assertEqual(d.keys(), [])
+            a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
+            for k, v in a:
+                d[k] = v
+            for k, _ in a:
+                self.assertIn(k, d)
+            self.assertEqual(len(d), len(a))
+
+            d.clear()
+            self.assertEqual(len(d), 0)
+            for k, _ in a:
+                self.assertNotIn(k, d)
 
     def setUp(self):
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
         dbm._defaultmod = self.module
-        delete_files()
+        self.addCleanup(cleaunup_test_dir)
+        setup_test_dir()
 
 
 class WhichDBTestCase(unittest.TestCase):
     def test_whichdb(self):
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
+        _bytes_fname = os.fsencode(_fname)
+        fnames = [_fname, os_helper.FakePath(_fname),
+                  _bytes_fname, os_helper.FakePath(_bytes_fname)]
         for module in dbm_iterator():
             # Check whether whichdb correctly guesses module name
             # for databases opened with "module" module.
-            # Try with empty files first
             name = module.__name__
-            if name == 'dbm.dumb':
-                continue   # whichdb can't support dbm.dumb
-            delete_files()
-            f = module.open(_fname, 'c')
-            f.close()
-            self.assertEqual(name, self.dbm.whichdb(_fname))
+            setup_test_dir()
+            dbm._defaultmod = module
+            # Try with empty files first
+            with module.open(_fname, 'c'): pass
+            for path in fnames:
+                self.assertEqual(name, self.dbm.whichdb(path))
             # Now add a key
-            f = module.open(_fname, 'w')
-            f[b"1"] = b"1"
-            # and test that we can find it
-            self.assertIn(b"1", f)
-            # and read it
-            self.assertEqual(f[b"1"], b"1")
-            f.close()
-            self.assertEqual(name, self.dbm.whichdb(_fname))
+            with module.open(_fname, 'w') as f:
+                f[b"1"] = b"1"
+                # and test that we can find it
+                self.assertIn(b"1", f)
+                # and read it
+                self.assertEqual(f[b"1"], b"1")
+            for path in fnames:
+                self.assertEqual(name, self.dbm.whichdb(path))
 
     @unittest.skipUnless(ndbm, reason='Test requires ndbm')
     def test_whichdb_ndbm(self):
         # Issue 17198: check that ndbm which is referenced in whichdb is defined
-        db_file = '{}_ndbm.db'.format(_fname)
-        with open(db_file, 'w'):
-            self.addCleanup(os_helper.unlink, db_file)
-        self.assertIsNone(self.dbm.whichdb(db_file[:-3]))
+        with open(_fname + '.db', 'wb') as f:
+            f.write(b'spam')
+        _bytes_fname = os.fsencode(_fname)
+        fnames = [_fname, os_helper.FakePath(_fname),
+                  _bytes_fname, os_helper.FakePath(_bytes_fname)]
+        for path in fnames:
+            self.assertIsNone(self.dbm.whichdb(path))
+
+    @unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3')
+    def test_whichdb_sqlite3(self):
+        # Databases created by dbm.sqlite3 are detected correctly.
+        with dbm_sqlite3.open(_fname, "c") as db:
+            db["key"] = "value"
+        self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3")
+
+    @unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3')
+    def test_whichdb_sqlite3_existing_db(self):
+        # Existing sqlite3 databases are detected correctly.
+        sqlite3 = import_helper.import_module("sqlite3")
+        try:
+            # Create an empty database.
+            with sqlite3.connect(_fname) as cx:
+                cx.execute("CREATE TABLE dummy(database)")
+                cx.commit()
+        finally:
+            cx.close()
+        self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3")
 
-    def tearDown(self):
-        delete_files()
 
     def setUp(self):
-        delete_files()
-        self.filename = os_helper.TESTFN
-        self.d = dbm.open(self.filename, 'c')
-        self.d.close()
+        self.addCleanup(cleaunup_test_dir)
+        setup_test_dir()
         self.dbm = import_helper.import_fresh_module('dbm')
 
-    def test_keys(self):
-        self.d = dbm.open(self.filename, 'c')
-        self.assertEqual(self.d.keys(), [])
-        a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
-        for k, v in a:
-            self.d[k] = v
-        self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a))
-        for k, v in a:
-            self.assertIn(k, self.d)
-            self.assertEqual(self.d[k], v)
-        self.assertNotIn(b'xxx', self.d)
-        self.assertRaises(KeyError, lambda: self.d[b'xxx'])
-        self.d.close()
-
-
-def load_tests(loader, tests, pattern):
-    classes = []
-    for mod in dbm_iterator():
-        classes.append(type("TestCase-" + mod.__name__,
-                            (AnyDBMTestCase, unittest.TestCase),
-                            {'module': mod}))
-    suites = [unittest.makeSuite(c) for c in classes]
-
-    tests.addTests(suites)
-    return tests
+
+for mod in dbm_iterator():
+    assert mod.__name__.startswith('dbm.')
+    suffix = mod.__name__[4:]
+    testname = f'TestCase_{suffix}'
+    globals()[testname] = type(testname,
+                               (AnyDBMTestCase, unittest.TestCase),
+                               {'module': mod})
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_dbm_dumb.py b/Lib/test/test_dbm_dumb.py
index 0dc489362b2..672f9092207 100644
--- a/Lib/test/test_dbm_dumb.py
+++ b/Lib/test/test_dbm_dumb.py
@@ -15,6 +15,7 @@
 
 _fname = os_helper.TESTFN
 
+
 def _delete_files():
     for ext in [".dir", ".dat", ".bak"]:
         try:
@@ -41,6 +42,7 @@ def test_dumbdbm_creation(self):
             self.read_helper(f)
 
     @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    @os_helper.skip_unless_working_chmod
     def test_dumbdbm_creation_mode(self):
         try:
             old_umask = os.umask(0o002)
@@ -231,7 +233,7 @@ def test_create_new(self):
             self.assertEqual(f.keys(), [])
 
     def test_eval(self):
-        with open(_fname + '.dir', 'w') as stream:
+        with open(_fname + '.dir', 'w', encoding="utf-8") as stream:
             stream.write("str(print('Hacked!')), 0\n")
         with support.captured_stdout() as stdout:
             with self.assertRaises(ValueError):
@@ -244,9 +246,27 @@ def test_missing_data(self):
             _delete_files()
             with self.assertRaises(FileNotFoundError):
                 dumbdbm.open(_fname, value)
+            self.assertFalse(os.path.exists(_fname + '.dat'))
             self.assertFalse(os.path.exists(_fname + '.dir'))
             self.assertFalse(os.path.exists(_fname + '.bak'))
 
+        for value in ('c', 'n'):
+            _delete_files()
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dat'))
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
+        for value in ('c', 'n'):
+            _delete_files()
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dat'))
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertTrue(os.path.exists(_fname + '.bak'))
+
     def test_missing_index(self):
         with dumbdbm.open(_fname, 'n') as f:
             pass
@@ -257,6 +277,60 @@ def test_missing_index(self):
             self.assertFalse(os.path.exists(_fname + '.dir'))
             self.assertFalse(os.path.exists(_fname + '.bak'))
 
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+            os.unlink(_fname + '.dir')
+
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertTrue(os.path.exists(_fname + '.bak'))
+            os.unlink(_fname + '.dir')
+            os.unlink(_fname + '.bak')
+
+    def test_sync_empty_unmodified(self):
+        with dumbdbm.open(_fname, 'n') as f:
+            pass
+        os.unlink(_fname + '.dir')
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                f.sync()
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                os.unlink(_fname + '.dir')
+                f.sync()
+                self.assertFalse(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.dir'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
+    def test_sync_nonempty_unmodified(self):
+        with dumbdbm.open(_fname, 'n') as f:
+            pass
+        os.unlink(_fname + '.dir')
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                f.sync()
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertTrue(os.path.exists(_fname + '.bak'))
+                os.unlink(_fname + '.dir')
+                os.unlink(_fname + '.bak')
+                f.sync()
+                self.assertFalse(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.dir'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
     def test_invalid_flag(self):
         for flag in ('x', 'rf', None):
             with self.assertRaisesRegex(ValueError,
@@ -264,6 +338,7 @@ def test_invalid_flag(self):
                                         "'r', 'w', 'c', or 'n'"):
                 dumbdbm.open(_fname, flag)
 
+    @os_helper.skip_unless_working_chmod
     def test_readonly_files(self):
         with os_helper.temp_dir() as dir:
             fname = os.path.join(dir, 'db')
@@ -293,6 +368,15 @@ def test_nonascii_filename(self):
             self.assertTrue(b'key' in db)
             self.assertEqual(db[b'key'], b'value')
 
+    def test_open_with_pathlib_path(self):
+        dumbdbm.open(os_helper.FakePath(_fname), "c").close()
+
+    def test_open_with_bytes_path(self):
+        dumbdbm.open(os.fsencode(_fname), "c").close()
+
+    def test_open_with_pathlib_bytes_path(self):
+        dumbdbm.open(os_helper.FakePath(os.fsencode(_fname)), "c").close()
+
     def tearDown(self):
         _delete_files()
 
diff --git a/Lib/test/test_dbm_sqlite3.py b/Lib/test/test_dbm_sqlite3.py
new file mode 100644
index 00000000000..39eac7a35ec
--- /dev/null
+++ b/Lib/test/test_dbm_sqlite3.py
@@ -0,0 +1,362 @@
+import os
+import stat
+import sys
+import test.support
+import unittest
+from contextlib import closing
+from functools import partial
+from pathlib import Path
+from test.support import cpython_only, import_helper, os_helper
+
+dbm_sqlite3 = import_helper.import_module("dbm.sqlite3")
+# N.B. The test will fail on some platforms without sqlite3
+# if the sqlite3 import is above the import of dbm.sqlite3.
+# This is deliberate: if the import helper managed to import dbm.sqlite3,
+# we must inevitably be able to import sqlite3. Else, we have a problem.
+import sqlite3
+from dbm.sqlite3 import _normalize_uri
+
+
+root_in_posix = False
+if hasattr(os, 'geteuid'):
+    root_in_posix = (os.geteuid() == 0)
+
+
+class _SQLiteDbmTests(unittest.TestCase):
+
+    def setUp(self):
+        self.filename = os_helper.TESTFN
+        db = dbm_sqlite3.open(self.filename, "c")
+        db.close()
+
+    def tearDown(self):
+        for suffix in "", "-wal", "-shm":
+            os_helper.unlink(self.filename + suffix)
+
+
+class URI(unittest.TestCase):
+
+    def test_uri_substitutions(self):
+        dataset = (
+            ("/absolute/////b/c", "/absolute/b/c"),
+            ("PRE#MID##END", "PRE%23MID%23%23END"),
+            ("%#?%%#", "%25%23%3F%25%25%23"),
+        )
+        for path, normalized in dataset:
+            with self.subTest(path=path, normalized=normalized):
+                self.assertTrue(_normalize_uri(path).endswith(normalized))
+
+    @unittest.skipUnless(sys.platform == "win32", "requires Windows")
+    def test_uri_windows(self):
+        dataset = (
+            # Relative subdir.
+            (r"2018\January.xlsx",
+             "2018/January.xlsx"),
+            # Absolute with drive letter.
+            (r"C:\Projects\apilibrary\apilibrary.sln",
+             "/C:/Projects/apilibrary/apilibrary.sln"),
+            # Relative with drive letter.
+            (r"C:Projects\apilibrary\apilibrary.sln",
+             "/C:Projects/apilibrary/apilibrary.sln"),
+        )
+        for path, normalized in dataset:
+            with self.subTest(path=path, normalized=normalized):
+                if not Path(path).is_absolute():
+                    self.skipTest(f"skipping relative path: {path!r}")
+                self.assertTrue(_normalize_uri(path).endswith(normalized))
+
+
+class ReadOnly(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        with dbm_sqlite3.open(self.filename, "w") as db:
+            db[b"key1"] = "value1"
+            db[b"key2"] = "value2"
+        self.db = dbm_sqlite3.open(self.filename, "r")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_readonly_read(self):
+        self.assertEqual(self.db[b"key1"], b"value1")
+        self.assertEqual(self.db[b"key2"], b"value2")
+
+    def test_readonly_write(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"new"] = "value"
+
+    def test_readonly_delete(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            del self.db[b"key1"]
+
+    def test_readonly_keys(self):
+        self.assertEqual(self.db.keys(), [b"key1", b"key2"])
+
+    def test_readonly_iter(self):
+        self.assertEqual([k for k in self.db], [b"key1", b"key2"])
+
+
+@unittest.skipIf(root_in_posix, "test is meanless with root privilege")
+class ReadOnlyFilesystem(unittest.TestCase):
+
+    def setUp(self):
+        self.test_dir = os_helper.TESTFN
+        self.addCleanup(os_helper.rmtree, self.test_dir)
+        os.mkdir(self.test_dir)
+        self.db_path = os.path.join(self.test_dir, "test.db")
+
+        db = dbm_sqlite3.open(self.db_path, "c")
+        db[b"key"] = b"value"
+        db.close()
+
+    def test_readonly_file_read(self):
+        os.chmod(self.db_path, stat.S_IREAD)
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_readonly_file_write(self):
+        os.chmod(self.db_path, stat.S_IREAD)
+        with dbm_sqlite3.open(self.db_path, "w") as db:
+            with self.assertRaises(dbm_sqlite3.error):
+                db[b"newkey"] = b"newvalue"
+
+    def test_readonly_dir_read(self):
+        os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_readonly_dir_write(self):
+        os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
+        with dbm_sqlite3.open(self.db_path, "w") as db:
+            try:
+                db[b"newkey"] = b"newvalue"
+                modified = True  # on Windows and macOS
+            except dbm_sqlite3.error:
+                modified = False
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            if modified:
+                self.assertEqual(db[b"newkey"], b"newvalue")
+            else:
+                self.assertNotIn(b"newkey", db)
+
+
+class ReadWrite(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def db_content(self):
+        with closing(sqlite3.connect(self.filename)) as cx:
+            keys = [r[0] for r in cx.execute("SELECT key FROM Dict")]
+            vals = [r[0] for r in cx.execute("SELECT value FROM Dict")]
+        return keys, vals
+
+    def test_readwrite_unique_key(self):
+        self.db["key"] = "value"
+        self.db["key"] = "other"
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [b"key"])
+        self.assertEqual(vals, [b"other"])
+
+    def test_readwrite_delete(self):
+        self.db["key"] = "value"
+        self.db["new"] = "other"
+
+        del self.db[b"new"]
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [b"key"])
+        self.assertEqual(vals, [b"value"])
+
+        del self.db[b"key"]
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [])
+        self.assertEqual(vals, [])
+
+    def test_readwrite_null_key(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[None] = "value"
+
+    def test_readwrite_null_value(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"key"] = None
+
+
+class Misuse(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_misuse_double_create(self):
+        self.db["key"] = "value"
+        with dbm_sqlite3.open(self.filename, "c") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_misuse_double_close(self):
+        self.db.close()
+
+    def test_misuse_invalid_flag(self):
+        regex = "must be.*'r'.*'w'.*'c'.*'n', not 'invalid'"
+        with self.assertRaisesRegex(ValueError, regex):
+            dbm_sqlite3.open(self.filename, flag="invalid")
+
+    def test_misuse_double_delete(self):
+        self.db["key"] = "value"
+        del self.db[b"key"]
+        with self.assertRaises(KeyError):
+            del self.db[b"key"]
+
+    def test_misuse_invalid_key(self):
+        with self.assertRaises(KeyError):
+            self.db[b"key"]
+
+    def test_misuse_iter_close1(self):
+        self.db["1"] = 1
+        it = iter(self.db)
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            next(it)
+
+    def test_misuse_iter_close2(self):
+        self.db["1"] = 1
+        self.db["2"] = 2
+        it = iter(self.db)
+        next(it)
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            next(it)
+
+    def test_misuse_use_after_close(self):
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"read"]
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"write"] = "value"
+        with self.assertRaises(dbm_sqlite3.error):
+            del self.db[b"del"]
+        with self.assertRaises(dbm_sqlite3.error):
+            len(self.db)
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db.keys()
+
+    def test_misuse_reinit(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db.__init__("new.db", flag="n", mode=0o666)
+
+    def test_misuse_empty_filename(self):
+        for flag in "r", "w", "c", "n":
+            with self.assertRaises(dbm_sqlite3.error):
+                db = dbm_sqlite3.open("", flag="c")
+
+
+class DataTypes(_SQLiteDbmTests):
+
+    dataset = (
+        # (raw, coerced)
+        (42, b"42"),
+        (3.14, b"3.14"),
+        ("string", b"string"),
+        (b"bytes", b"bytes"),
+    )
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_datatypes_values(self):
+        for raw, coerced in self.dataset:
+            with self.subTest(raw=raw, coerced=coerced):
+                self.db["key"] = raw
+                self.assertEqual(self.db[b"key"], coerced)
+
+    def test_datatypes_keys(self):
+        for raw, coerced in self.dataset:
+            with self.subTest(raw=raw, coerced=coerced):
+                self.db[raw] = "value"
+                self.assertEqual(self.db[coerced], b"value")
+                # Raw keys are silently coerced to bytes.
+                self.assertEqual(self.db[raw], b"value")
+                del self.db[raw]
+
+    def test_datatypes_replace_coerced(self):
+        self.db["10"] = "value"
+        self.db[b"10"] = "value"
+        self.db[10] = "value"
+        self.assertEqual(self.db.keys(), [b"10"])
+
+
+class CorruptDatabase(_SQLiteDbmTests):
+    """Verify that database exceptions are raised as dbm.sqlite3.error."""
+
+    def setUp(self):
+        super().setUp()
+        with closing(sqlite3.connect(self.filename)) as cx:
+            with cx:
+                cx.execute("DROP TABLE IF EXISTS Dict")
+                cx.execute("CREATE TABLE Dict (invalid_schema)")
+
+    def check(self, flag, fn, should_succeed=False):
+        with closing(dbm_sqlite3.open(self.filename, flag)) as db:
+            with self.assertRaises(dbm_sqlite3.error):
+                fn(db)
+
+    @staticmethod
+    def read(db):
+        return db["key"]
+
+    @staticmethod
+    def write(db):
+        db["key"] = "value"
+
+    @staticmethod
+    def iter(db):
+        next(iter(db))
+
+    @staticmethod
+    def keys(db):
+        db.keys()
+
+    @staticmethod
+    def del_(db):
+        del db["key"]
+
+    @staticmethod
+    def len_(db):
+        len(db)
+
+    def test_corrupt_readwrite(self):
+        for flag in "r", "w", "c":
+            with self.subTest(flag=flag):
+                check = partial(self.check, flag=flag)
+                check(fn=self.read)
+                check(fn=self.write)
+                check(fn=self.iter)
+                check(fn=self.keys)
+                check(fn=self.del_)
+                check(fn=self.len_)
+
+    def test_corrupt_force_new(self):
+        with closing(dbm_sqlite3.open(self.filename, "n")) as db:
+            db["foo"] = "write"
+            _ = db[b"foo"]
+            next(iter(db))
+            del db[b"foo"]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index 54c889ecb6b..7e0392b1f30 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -29,21 +29,21 @@ mod _sqlite {
         sqlite3_bind_null, sqlite3_bind_parameter_count, sqlite3_bind_parameter_name,
         sqlite3_bind_text, sqlite3_blob, sqlite3_blob_bytes, sqlite3_blob_close, sqlite3_blob_open,
         sqlite3_blob_read, sqlite3_blob_write, sqlite3_busy_timeout, sqlite3_changes,
-        sqlite3_close, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count,
-        sqlite3_column_decltype, sqlite3_column_double, sqlite3_column_int64, sqlite3_column_name,
-        sqlite3_column_text, sqlite3_column_type, sqlite3_complete, sqlite3_context,
-        sqlite3_context_db_handle, sqlite3_create_collation_v2, sqlite3_create_function_v2,
-        sqlite3_create_window_function, sqlite3_data_count, sqlite3_db_handle, sqlite3_errcode,
-        sqlite3_errmsg, sqlite3_exec, sqlite3_expanded_sql, sqlite3_extended_errcode,
-        sqlite3_finalize, sqlite3_get_autocommit, sqlite3_interrupt, sqlite3_last_insert_rowid,
-        sqlite3_libversion, sqlite3_limit, sqlite3_open_v2, sqlite3_prepare_v2,
-        sqlite3_progress_handler, sqlite3_reset, sqlite3_result_blob, sqlite3_result_double,
-        sqlite3_result_error, sqlite3_result_error_nomem, sqlite3_result_error_toobig,
-        sqlite3_result_int64, sqlite3_result_null, sqlite3_result_text, sqlite3_set_authorizer,
-        sqlite3_sleep, sqlite3_step, sqlite3_stmt, sqlite3_stmt_busy, sqlite3_stmt_readonly,
-        sqlite3_threadsafe, sqlite3_total_changes, sqlite3_trace_v2, sqlite3_user_data,
-        sqlite3_value, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double,
-        sqlite3_value_int64, sqlite3_value_text, sqlite3_value_type,
+        sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count, sqlite3_column_decltype,
+        sqlite3_column_double, sqlite3_column_int64, sqlite3_column_name, sqlite3_column_text,
+        sqlite3_column_type, sqlite3_complete, sqlite3_context, sqlite3_context_db_handle,
+        sqlite3_create_collation_v2, sqlite3_create_function_v2, sqlite3_create_window_function,
+        sqlite3_data_count, sqlite3_db_handle, sqlite3_errcode, sqlite3_errmsg, sqlite3_exec,
+        sqlite3_expanded_sql, sqlite3_extended_errcode, sqlite3_finalize, sqlite3_get_autocommit,
+        sqlite3_interrupt, sqlite3_last_insert_rowid, sqlite3_libversion, sqlite3_limit,
+        sqlite3_open_v2, sqlite3_prepare_v2, sqlite3_progress_handler, sqlite3_reset,
+        sqlite3_result_blob, sqlite3_result_double, sqlite3_result_error,
+        sqlite3_result_error_nomem, sqlite3_result_error_toobig, sqlite3_result_int64,
+        sqlite3_result_null, sqlite3_result_text, sqlite3_set_authorizer, sqlite3_sleep,
+        sqlite3_step, sqlite3_stmt, sqlite3_stmt_busy, sqlite3_stmt_readonly, sqlite3_threadsafe,
+        sqlite3_total_changes, sqlite3_trace_v2, sqlite3_user_data, sqlite3_value,
+        sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int64,
+        sqlite3_value_text, sqlite3_value_type,
     };
     use malachite_bigint::Sign;
     use rustpython_common::{
@@ -160,6 +160,8 @@ mod _sqlite {
     const PARSE_DECLTYPES: c_int = 1;
     #[pyattr]
     const PARSE_COLNAMES: c_int = 2;
+    #[pyattr]
+    const LEGACY_TRANSACTION_CONTROL: c_int = -1;
 
     #[pyattr]
     use libsqlite3_sys::{
@@ -300,6 +302,41 @@ mod _sqlite {
         SQLITE_IOERR_CORRUPTFS
     );
 
+    /// Autocommit mode setting for sqlite3 connections.
+    /// - Legacy (default): use isolation_level to control transactions
+    /// - Enabled: autocommit mode (no automatic transactions)
+    /// - Disabled: manual commit mode
+    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+    enum AutocommitMode {
+        #[default]
+        Legacy,
+        Enabled,
+        Disabled,
+    }
+
+    impl TryFromBorrowedObject<'_> for AutocommitMode {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Self> {
+            if obj.is(&vm.ctx.true_value) {
+                Ok(Self::Enabled)
+            } else if obj.is(&vm.ctx.false_value) {
+                Ok(Self::Disabled)
+            } else if let Ok(val) = obj.try_to_value::<c_int>(vm) {
+                if val == LEGACY_TRANSACTION_CONTROL {
+                    Ok(Self::Legacy)
+                } else {
+                    Err(vm.new_value_error(format!(
+                        "autocommit must be True, False, or sqlite3.LEGACY_TRANSACTION_CONTROL, not {val}"
+                    )))
+                }
+            } else {
+                Err(vm.new_type_error(format!(
+                    "autocommit must be True, False, or sqlite3.LEGACY_TRANSACTION_CONTROL, not {}",
+                    obj.class().name()
+                )))
+            }
+        }
+    }
+
     #[derive(FromArgs)]
     struct ConnectArgs {
         #[pyarg(any)]
@@ -320,6 +357,8 @@ mod _sqlite {
         cached_statements: c_int,
         #[pyarg(any, default = false)]
         uri: bool,
+        #[pyarg(any, default)]
+        autocommit: AutocommitMode,
     }
 
     unsafe impl Traverse for ConnectArgs {
@@ -841,6 +880,7 @@ mod _sqlite {
         thread_ident: PyMutex<ThreadId>, // TODO: Use atomic
         row_factory: PyAtomicRef<Option<PyObject>>,
         text_factory: PyAtomicRef<PyObject>,
+        autocommit: PyMutex<AutocommitMode>,
     }
 
     impl Debug for Connection {
@@ -878,6 +918,7 @@ mod _sqlite {
                 thread_ident: PyMutex::new(std::thread::current().id()),
                 row_factory: PyAtomicRef::from(None),
                 text_factory: PyAtomicRef::from(text_factory),
+                autocommit: PyMutex::new(args.autocommit),
             })
         }
     }
@@ -919,12 +960,14 @@ mod _sqlite {
                 detect_types,
                 isolation_level,
                 check_same_thread,
+                autocommit,
                 ..
             } = args;
 
             zelf.detect_types.store(detect_types, Ordering::Relaxed);
             zelf.check_same_thread
                 .store(check_same_thread, Ordering::Relaxed);
+            *zelf.autocommit.lock() = autocommit;
             *zelf.thread_ident.lock() = std::thread::current().id();
             let _ = unsafe { zelf.isolation_level.swap(isolation_level) };
 
@@ -1465,6 +1508,43 @@ mod _sqlite {
             }
         }
 
+        #[pygetset]
+        fn autocommit(&self, vm: &VirtualMachine) -> PyObjectRef {
+            match *self.autocommit.lock() {
+                AutocommitMode::Enabled => vm.ctx.true_value.clone().into(),
+                AutocommitMode::Disabled => vm.ctx.false_value.clone().into(),
+                AutocommitMode::Legacy => vm.ctx.new_int(LEGACY_TRANSACTION_CONTROL).into(),
+            }
+        }
+        #[pygetset(setter)]
+        fn set_autocommit(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mode = AutocommitMode::try_from_borrowed_object(vm, &val)?;
+            let db = self.db_lock(vm)?;
+
+            // Handle transaction state based on mode change
+            match mode {
+                AutocommitMode::Enabled => {
+                    // If there's a pending transaction, commit it
+                    if !db.is_autocommit() {
+                        db._exec(b"COMMIT", vm)?;
+                    }
+                }
+                AutocommitMode::Disabled => {
+                    // If not in a transaction, begin one
+                    if db.is_autocommit() {
+                        db._exec(b"BEGIN", vm)?;
+                    }
+                }
+                AutocommitMode::Legacy => {
+                    // Legacy mode doesn't change transaction state
+                }
+            }
+
+            drop(db);
+            *self.autocommit.lock() = mode;
+            Ok(())
+        }
+
         #[pygetset]
         fn text_factory(&self) -> PyObjectRef {
             self.text_factory.to_owned()
@@ -1622,9 +1702,11 @@ mod _sqlite {
 
             let db = zelf.connection.db_lock(vm)?;
 
+            // Start implicit transaction for DML statements unless in autocommit mode
             if stmt.is_dml
                 && db.is_autocommit()
                 && zelf.connection.isolation_level.deref().is_some()
+                && *zelf.connection.autocommit.lock() != AutocommitMode::Enabled
             {
                 db.begin_transaction(
                     zelf.connection
@@ -1715,9 +1797,11 @@ mod _sqlite {
 
             let db = zelf.connection.db_lock(vm)?;
 
+            // Start implicit transaction for DML statements unless in autocommit mode
             if stmt.is_dml
                 && db.is_autocommit()
                 && zelf.connection.isolation_level.deref().is_some()
+                && *zelf.connection.autocommit.lock() != AutocommitMode::Enabled
             {
                 db.begin_transaction(
                     zelf.connection
@@ -1954,6 +2038,18 @@ mod _sqlite {
     impl SelfIter for Cursor {}
     impl IterNext for Cursor {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            // Check if connection is closed first, and if so, clear statement to release file lock
+            if zelf.connection.is_closed() {
+                let mut guard = zelf.inner.lock();
+                if let Some(stmt) = guard.as_mut().and_then(|inner| inner.statement.take()) {
+                    stmt.lock().reset();
+                }
+                return Err(new_programming_error(
+                    vm,
+                    "Cannot operate on a closed database.".to_owned(),
+                ));
+            }
+
             let mut inner = zelf.inner(vm)?;
             let Some(stmt) = &inner.statement else {
                 return Ok(PyIterReturn::StopIteration(None));
@@ -2658,9 +2754,17 @@ mod _sqlite {
         }
     }
 
+    // sqlite3_close_v2 is not exported by libsqlite3-sys, so we declare it manually.
+    // It handles "zombie close" - if there are still unfinalized statements,
+    // the database will be closed when the last statement is finalized.
+    unsafe extern "C" {
+        fn sqlite3_close_v2(db: *mut sqlite3) -> c_int;
+    }
+
     impl Drop for Sqlite {
         fn drop(&mut self) {
-            unsafe { sqlite3_close(self.raw.db) };
+            // Use sqlite3_close_v2 for safe closing even with active statements
+            unsafe { sqlite3_close_v2(self.raw.db) };
         }
     }
 

From e10dc949928e66f108a4a4a232cd1304dccb8565 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 14:48:27 +0900
Subject: [PATCH 144/418] Fix stdio_encoding, stdio_errors (#6617)

* stdio_errors, stdio_encodings

* add ascii

* unmark tests
---
 .cspell.dict/python-more.txt                  |  1 +
 Lib/test/test_tarfile.py                      |  4 --
 crates/vm/Lib/core_modules/encodings_ascii.py |  1 +
 crates/vm/src/vm/mod.rs                       | 51 +++++++++++++------
 crates/vm/src/vm/setting.rs                   |  8 ++-
 src/settings.rs                               | 17 +++++++
 6 files changed, 61 insertions(+), 21 deletions(-)
 create mode 120000 crates/vm/Lib/core_modules/encodings_ascii.py

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index 1f3fc4864cd..a13f345eece 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -178,6 +178,7 @@ PYTHONHASHSEED
 PYTHONHOME
 PYTHONINSPECT
 PYTHONINTMAXSTRDIGITS
+PYTHONIOENCODING
 PYTHONNODEBUGRANGES
 PYTHONNOUSERSITE
 PYTHONOPTIMIZE
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index 4cf233d5f8b..d29c6918234 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -2494,8 +2494,6 @@ def test_test_command_invalid_file(self):
                 finally:
                     os_helper.unlink(tmpname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_command(self):
         for tar_name in testtarnames:
             with support.captured_stdout() as t:
@@ -2507,8 +2505,6 @@ def test_list_command(self):
                                       PYTHONIOENCODING='ascii')
                 self.assertEqual(out, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_command_verbose(self):
         for tar_name in testtarnames:
             with support.captured_stdout() as t:
diff --git a/crates/vm/Lib/core_modules/encodings_ascii.py b/crates/vm/Lib/core_modules/encodings_ascii.py
new file mode 120000
index 00000000000..c0507e75b03
--- /dev/null
+++ b/crates/vm/Lib/core_modules/encodings_ascii.py
@@ -0,0 +1 @@
+../../../../Lib/encodings/ascii.py
\ No newline at end of file
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 2eef479d1b4..7f7c5ea7674 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -261,17 +261,28 @@ impl VirtualMachine {
         Ok(())
     }
 
-    fn import_utf8_encodings(&mut self) -> PyResult<()> {
+    fn import_ascii_utf8_encodings(&mut self) -> PyResult<()> {
         import::import_frozen(self, "codecs")?;
-        // FIXME: See corresponding part of `core_frozen_inits`
-        // let encoding_module_name = if cfg!(feature = "freeze-stdlib") {
-        //     "encodings.utf_8"
-        // } else {
-        //     "encodings_utf_8"
-        // };
-        let encoding_module_name = "encodings_utf_8";
-        let encoding_module = import::import_frozen(self, encoding_module_name)?;
-        let getregentry = encoding_module.get_attr("getregentry", self)?;
+
+        // Use dotted names when freeze-stdlib is enabled (modules come from Lib/encodings/),
+        // otherwise use underscored names (modules come from core_modules/).
+        let (ascii_module_name, utf8_module_name) = if cfg!(feature = "freeze-stdlib") {
+            ("encodings.ascii", "encodings.utf_8")
+        } else {
+            ("encodings_ascii", "encodings_utf_8")
+        };
+
+        // Register ascii encoding
+        let ascii_module = import::import_frozen(self, ascii_module_name)?;
+        let getregentry = ascii_module.get_attr("getregentry", self)?;
+        let codec_info = getregentry.call((), self)?;
+        self.state
+            .codec_registry
+            .register_manual("ascii", codec_info.try_into_value(self)?)?;
+
+        // Register utf-8 encoding
+        let utf8_module = import::import_frozen(self, utf8_module_name)?;
+        let getregentry = utf8_module.get_attr("getregentry", self)?;
         let codec_info = getregentry.call((), self)?;
         self.state
             .codec_registry
@@ -298,7 +309,7 @@ impl VirtualMachine {
             #[cfg(not(feature = "threading"))]
             import::import_frozen(self, "_thread")?;
             let importlib = import::init_importlib_base(self)?;
-            self.import_utf8_encodings()?;
+            self.import_ascii_utf8_encodings()?;
 
             #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
             {
@@ -327,17 +338,25 @@ impl VirtualMachine {
                     let line_buffering = buffered_stdio && (isatty || fd == 2);
 
                     let newline = if cfg!(windows) { None } else { Some("\n") };
-                    // stderr uses backslashreplace error handler
-                    let errors: Option<&str> = if fd == 2 {
+                    let encoding = self.state.config.settings.stdio_encoding.as_deref();
+                    // stderr always uses backslashreplace (ignores stdio_errors)
+                    let errors = if fd == 2 {
                         Some("backslashreplace")
                     } else {
-                        None
+                        self.state.config.settings.stdio_errors.as_deref()
                     };
 
                     let stdio = self.call_method(
                         &io,
                         "TextIOWrapper",
-                        (buf, (), errors, newline, line_buffering, write_through),
+                        (
+                            buf,
+                            encoding,
+                            errors,
+                            newline,
+                            line_buffering,
+                            write_through,
+                        ),
                     )?;
                     let mode = if write { "w" } else { "r" };
                     stdio.set_attr("mode", self.ctx.new_str(mode), self)?;
@@ -1007,6 +1026,8 @@ pub fn resolve_frozen_alias(name: &str) -> &str {
     match name {
         "_frozen_importlib" => "importlib._bootstrap",
         "_frozen_importlib_external" => "importlib._bootstrap_external",
+        "encodings_ascii" => "encodings.ascii",
+        "encodings_utf_8" => "encodings.utf_8",
         _ => name,
     }
 }
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index 8a307d1852b..9be21b4484e 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -112,9 +112,11 @@ pub struct Settings {
     /// -u, PYTHONUNBUFFERED=x
     pub buffered_stdio: bool,
 
-    // wchar_t *stdio_encoding;
+    /// PYTHONIOENCODING - stdio encoding
+    pub stdio_encoding: Option<String>,
+    /// PYTHONIOENCODING - stdio error handler
+    pub stdio_errors: Option<String>,
     pub utf8_mode: u8,
-    // wchar_t *stdio_errors;
     /// --check-hash-based-pycs
     pub check_hash_pycs_mode: CheckHashPycsMode,
 
@@ -197,6 +199,8 @@ impl Default for Settings {
             buffered_stdio: true,
             check_hash_pycs_mode: CheckHashPycsMode::Default,
             allow_external_library: cfg!(feature = "importlib"),
+            stdio_encoding: None,
+            stdio_errors: None,
             utf8_mode: 1,
             int_max_str_digits: 4300,
             #[cfg(feature = "flame-it")]
diff --git a/src/settings.rs b/src/settings.rs
index 54e66086932..7dd3c1a7714 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -298,6 +298,23 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
         settings.code_debug_ranges = false;
     }
 
+    // Parse PYTHONIOENCODING=encoding[:errors]
+    if let Some(val) = get_env("PYTHONIOENCODING")
+        && let Some(val_str) = val.to_str()
+        && !val_str.is_empty()
+    {
+        if let Some((enc, err)) = val_str.split_once(':') {
+            if !enc.is_empty() {
+                settings.stdio_encoding = Some(enc.to_owned());
+            }
+            if !err.is_empty() {
+                settings.stdio_errors = Some(err.to_owned());
+            }
+        } else {
+            settings.stdio_encoding = Some(val_str.to_owned());
+        }
+    }
+
     if settings.dev_mode {
         settings.warnoptions.push("default".to_owned());
         settings.faulthandler = true;

From 020ff3058c46d60e2fc158658173e1789fdb265f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 15:00:30 +0900
Subject: [PATCH 145/418] update_sub_slot, __delitem__, no __bool__, missing
 rops (#6618)

* fix update_sub_slot

* Fix __setitem__ __delitem__ handling

* contains

* no __bool__ anymore

* Add rops to wrapper

* Remove pymethod from set

* remove len
---
 crates/vm/src/builtins/bool.rs         |  63 +++++-------
 crates/vm/src/builtins/bytearray.rs    |   1 -
 crates/vm/src/builtins/bytes.rs        |   1 -
 crates/vm/src/builtins/dict.rs         |   2 -
 crates/vm/src/builtins/list.rs         |   1 -
 crates/vm/src/builtins/mappingproxy.rs |   2 +-
 crates/vm/src/builtins/memory.rs       |   1 -
 crates/vm/src/builtins/set.rs          | 129 +++++++++++++++++--------
 crates/vm/src/builtins/tuple.rs        |   1 -
 crates/vm/src/protocol/number.rs       |  14 +++
 crates/vm/src/stdlib/collections.rs    |   6 --
 crates/vm/src/stdlib/ctypes/array.rs   |   1 -
 crates/vm/src/stdlib/winreg.rs         |   1 -
 crates/vm/src/types/slot.rs            |  28 +++++-
 14 files changed, 154 insertions(+), 97 deletions(-)

diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
index 3dabdbae717..24ded08ab10 100644
--- a/crates/vm/src/builtins/bool.rs
+++ b/crates/vm/src/builtins/bool.rs
@@ -9,7 +9,6 @@ use crate::{
     types::{AsNumber, Constructor, Representable},
 };
 use core::fmt::{Debug, Formatter};
-use malachite_bigint::Sign;
 use num_traits::Zero;
 
 impl ToPyObject for bool {
@@ -42,46 +41,28 @@ impl PyObjectRef {
         if self.is(&vm.ctx.false_value) {
             return Ok(false);
         }
-        let rs_bool = if let Some(nb_bool) = self.class().slots.as_number.boolean.load() {
-            nb_bool(self.as_object().number(), vm)?
-        } else {
-            // TODO: Fully implement AsNumber and remove this block
-            match vm.get_method(self.clone(), identifier!(vm, __bool__)) {
-                Some(method_or_err) => {
-                    // If descriptor returns Error, propagate it further
-                    let method = method_or_err?;
-                    let bool_obj = method.call((), vm)?;
-                    if !bool_obj.fast_isinstance(vm.ctx.types.bool_type) {
-                        return Err(vm.new_type_error(format!(
-                            "__bool__ should return bool, returned type {}",
-                            bool_obj.class().name()
-                        )));
-                    }
-
-                    get_value(&bool_obj)
-                }
-                None => match vm.get_method(self, identifier!(vm, __len__)) {
-                    Some(method_or_err) => {
-                        let method = method_or_err?;
-                        let bool_obj = method.call((), vm)?;
-                        let int_obj = bool_obj.downcast_ref::<PyInt>().ok_or_else(|| {
-                            vm.new_type_error(format!(
-                                "'{}' object cannot be interpreted as an integer",
-                                bool_obj.class().name()
-                            ))
-                        })?;
-
-                        let len_val = int_obj.as_bigint();
-                        if len_val.sign() == Sign::Minus {
-                            return Err(vm.new_value_error("__len__() should return >= 0"));
-                        }
-                        !len_val.is_zero()
-                    }
-                    None => true,
-                },
-            }
-        };
-        Ok(rs_bool)
+
+        let slots = &self.class().slots;
+
+        // 1. Try nb_bool slot first
+        if let Some(nb_bool) = slots.as_number.boolean.load() {
+            return nb_bool(self.as_object().number(), vm);
+        }
+
+        // 2. Try mp_length slot (mapping protocol)
+        if let Some(mp_length) = slots.as_mapping.length.load() {
+            let len = mp_length(self.as_object().mapping_unchecked(), vm)?;
+            return Ok(len != 0);
+        }
+
+        // 3. Try sq_length slot (sequence protocol)
+        if let Some(sq_length) = slots.as_sequence.length.load() {
+            let len = sq_length(self.as_object().sequence_unchecked(), vm)?;
+            return Ok(len != 0);
+        }
+
+        // 4. Default: objects without __bool__ or __len__ are truthy
+        Ok(true)
     }
 }
 
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index 212e4604ec9..dc5ee100acf 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -206,7 +206,6 @@ impl PyByteArray {
         self.inner().capacity()
     }
 
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.borrow_buf().len()
     }
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index b3feac8ac97..7e5b98b1ece 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -205,7 +205,6 @@ impl PyRef<PyBytes> {
 )]
 impl PyBytes {
     #[inline]
-    #[pymethod]
     pub const fn __len__(&self) -> usize {
         self.inner.len()
     }
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 358685fcdc4..693505b1f82 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -212,7 +212,6 @@ impl PyDict {
         }
     }
 
-    #[pymethod]
     pub fn __len__(&self) -> usize {
         self.entries.len()
     }
@@ -764,7 +763,6 @@ trait DictView: PyPayload + PyClassDef + Iterable + Representable {
     fn dict(&self) -> &Py<PyDict>;
     fn item(vm: &VirtualMachine, key: PyObjectRef, value: PyObjectRef) -> PyObjectRef;
 
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.dict().__len__()
     }
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 46145b339cf..52df0756498 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -182,7 +182,6 @@ impl PyList {
     }
 
     #[allow(clippy::len_without_is_empty)]
-    #[pymethod]
     pub fn __len__(&self) -> usize {
         self.borrow_vec().len()
     }
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index 475f36cb5a9..34a598b03e0 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -173,7 +173,6 @@ impl PyMappingProxy {
         PyGenericAlias::from_args(cls, args, vm)
     }
 
-    #[pymethod]
     fn __len__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         let obj = self.to_object(vm)?;
         obj.length(vm)
@@ -235,6 +234,7 @@ impl AsMapping for PyMappingProxy {
 impl AsSequence for PyMappingProxy {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            length: atomic_func!(|seq, vm| PyMappingProxy::sequence_downcast(seq).__len__(vm)),
             contains: atomic_func!(
                 |seq, target, vm| PyMappingProxy::sequence_downcast(seq)._contains(target, vm)
             ),
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
index ff5df031c42..5ca4257cded 100644
--- a/crates/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -690,7 +690,6 @@ impl PyMemoryView {
         Err(vm.new_type_error("cannot delete memory"))
     }
 
-    #[pymethod]
     fn __len__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         self.try_not_released(vm)?;
         if self.desc.ndim() == 0 {
diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
index b1236e44e93..1c0268e2ed7 100644
--- a/crates/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -533,11 +533,14 @@ fn reduce_set(
     flags(BASETYPE, _MATCH_SELF)
 )]
 impl PySet {
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.inner.len()
     }
 
+    fn __contains__(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        self.inner.contains(needle, vm)
+    }
+
     #[pymethod]
     fn __sizeof__(&self) -> usize {
         core::mem::size_of::<Self>() + self.inner.sizeof()
@@ -550,11 +553,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
-    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.inner.contains(&needle, vm)
-    }
-
     #[pymethod]
     fn union(&self, others: PosArgs<ArgIterable>, vm: &VirtualMachine) -> PyResult<Self> {
         self.fold_op(others.into_iter(), PySetInner::union, vm)
@@ -594,8 +592,6 @@ impl PySet {
         self.inner.isdisjoint(other, vm)
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<Self>> {
         if let Ok(other) = AnySet::try_from_object(vm, other) {
             Ok(PyArithmeticValue::Implemented(self.op(
@@ -608,8 +604,6 @@ impl PySet {
         }
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(
         &self,
         other: PyObjectRef,
@@ -626,7 +620,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
     fn __sub__(
         &self,
         other: PyObjectRef,
@@ -643,7 +636,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
     fn __rsub__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -660,8 +652,6 @@ impl PySet {
         }
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(
         &self,
         other: PyObjectRef,
@@ -705,7 +695,6 @@ impl PySet {
         self.inner.pop(vm)
     }
 
-    #[pymethod]
     fn __ior__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner.update(set.into_iterable_iter(vm)?, vm)?;
         Ok(zelf)
@@ -729,7 +718,6 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __iand__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner
             .intersection_update(core::iter::once(set.into_iterable(vm)?), vm)?;
@@ -742,7 +730,6 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __isub__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner
             .difference_update(set.into_iterable_iter(vm)?, vm)?;
@@ -760,7 +747,6 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __ixor__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner
             .symmetric_difference_update(set.into_iterable_iter(vm)?, vm)?;
@@ -799,9 +785,9 @@ impl AsSequence for PySet {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
             length: atomic_func!(|seq, _vm| Ok(PySet::sequence_downcast(seq).__len__())),
-            contains: atomic_func!(|seq, needle, vm| PySet::sequence_downcast(seq)
-                .inner
-                .contains(needle, vm)),
+            contains: atomic_func!(
+                |seq, needle, vm| PySet::sequence_downcast(seq).__contains__(needle, vm)
+            ),
             ..PySequenceMethods::NOT_IMPLEMENTED
         });
         &AS_SEQUENCE
@@ -830,30 +816,77 @@ impl Iterable for PySet {
 impl AsNumber for PySet {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            // Binary ops check both operands are sets (like CPython's set_sub, etc.)
+            // This is needed because __rsub__ swaps operands: a.__rsub__(b) calls subtract(b, a)
             subtract: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__sub__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    // When called via __rsub__, a might be PyFrozenSet
+                    a.__sub__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             and: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__and__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__and__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             xor: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__xor__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__xor__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             or: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__or__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__or__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -972,11 +1005,14 @@ impl Constructor for PyFrozenSet {
     )
 )]
 impl PyFrozenSet {
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.inner.len()
     }
 
+    fn __contains__(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        self.inner.contains(needle, vm)
+    }
+
     #[pymethod]
     fn __sizeof__(&self) -> usize {
         core::mem::size_of::<Self>() + self.inner.sizeof()
@@ -995,11 +1031,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
-    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.inner.contains(&needle, vm)
-    }
-
     #[pymethod]
     fn union(&self, others: PosArgs<ArgIterable>, vm: &VirtualMachine) -> PyResult<Self> {
         self.fold_op(others.into_iter(), PySetInner::union, vm)
@@ -1039,8 +1070,6 @@ impl PyFrozenSet {
         self.inner.isdisjoint(other, vm)
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<Self>> {
         if let Ok(set) = AnySet::try_from_object(vm, other) {
             Ok(PyArithmeticValue::Implemented(self.op(
@@ -1053,8 +1082,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(
         &self,
         other: PyObjectRef,
@@ -1071,7 +1098,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
     fn __sub__(
         &self,
         other: PyObjectRef,
@@ -1088,7 +1114,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
     fn __rsub__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -1106,8 +1131,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(
         &self,
         other: PyObjectRef,
@@ -1142,9 +1165,9 @@ impl AsSequence for PyFrozenSet {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
             length: atomic_func!(|seq, _vm| Ok(PyFrozenSet::sequence_downcast(seq).__len__())),
-            contains: atomic_func!(|seq, needle, vm| PyFrozenSet::sequence_downcast(seq)
-                .inner
-                .contains(needle, vm)),
+            contains: atomic_func!(
+                |seq, needle, vm| PyFrozenSet::sequence_downcast(seq).__contains__(needle, vm)
+            ),
             ..PySequenceMethods::NOT_IMPLEMENTED
         });
         &AS_SEQUENCE
@@ -1196,30 +1219,53 @@ impl Iterable for PyFrozenSet {
 impl AsNumber for PyFrozenSet {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            // Binary ops check both operands are sets (like CPython's set_sub, etc.)
+            // __rsub__ swaps operands. Result type follows first operand's type.
             subtract: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__sub__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    // When called via __rsub__, a might be PySet - return set (not frozenset)
+                    a.__sub__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             and: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__and__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__and__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             xor: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__xor__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__xor__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             or: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__or__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__or__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -1252,6 +1298,13 @@ struct AnySet {
 }
 
 impl AnySet {
+    /// Check if object is a set or frozenset (including subclasses)
+    /// Equivalent to CPython's PyAnySet_Check
+    fn check(obj: &PyObject, vm: &VirtualMachine) -> bool {
+        let ctx = &vm.ctx;
+        obj.fast_isinstance(ctx.types.set_type) || obj.fast_isinstance(ctx.types.frozenset_type)
+    }
+
     fn into_iterable(self, vm: &VirtualMachine) -> PyResult<ArgIterable> {
         self.object.try_into_value(vm)
     }
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index e0b8009e892..910b0c8a204 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -298,7 +298,6 @@ impl PyTuple {
     }
 
     #[inline]
-    #[pymethod]
     pub const fn __len__(&self) -> usize {
         self.elements.len()
     }
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
index 58891d1d710..542afce2c6c 100644
--- a/crates/vm/src/protocol/number.rs
+++ b/crates/vm/src/protocol/number.rs
@@ -356,21 +356,27 @@ impl PyNumberSlots {
     pub fn copy_from(&self, methods: &PyNumberMethods) {
         if let Some(f) = methods.add {
             self.add.store(Some(f));
+            self.right_add.store(Some(f));
         }
         if let Some(f) = methods.subtract {
             self.subtract.store(Some(f));
+            self.right_subtract.store(Some(f));
         }
         if let Some(f) = methods.multiply {
             self.multiply.store(Some(f));
+            self.right_multiply.store(Some(f));
         }
         if let Some(f) = methods.remainder {
             self.remainder.store(Some(f));
+            self.right_remainder.store(Some(f));
         }
         if let Some(f) = methods.divmod {
             self.divmod.store(Some(f));
+            self.right_divmod.store(Some(f));
         }
         if let Some(f) = methods.power {
             self.power.store(Some(f));
+            self.right_power.store(Some(f));
         }
         if let Some(f) = methods.negative {
             self.negative.store(Some(f));
@@ -389,18 +395,23 @@ impl PyNumberSlots {
         }
         if let Some(f) = methods.lshift {
             self.lshift.store(Some(f));
+            self.right_lshift.store(Some(f));
         }
         if let Some(f) = methods.rshift {
             self.rshift.store(Some(f));
+            self.right_rshift.store(Some(f));
         }
         if let Some(f) = methods.and {
             self.and.store(Some(f));
+            self.right_and.store(Some(f));
         }
         if let Some(f) = methods.xor {
             self.xor.store(Some(f));
+            self.right_xor.store(Some(f));
         }
         if let Some(f) = methods.or {
             self.or.store(Some(f));
+            self.right_or.store(Some(f));
         }
         if let Some(f) = methods.int {
             self.int.store(Some(f));
@@ -440,9 +451,11 @@ impl PyNumberSlots {
         }
         if let Some(f) = methods.floor_divide {
             self.floor_divide.store(Some(f));
+            self.right_floor_divide.store(Some(f));
         }
         if let Some(f) = methods.true_divide {
             self.true_divide.store(Some(f));
+            self.right_true_divide.store(Some(f));
         }
         if let Some(f) = methods.inplace_floor_divide {
             self.inplace_floor_divide.store(Some(f));
@@ -455,6 +468,7 @@ impl PyNumberSlots {
         }
         if let Some(f) = methods.matrix_multiply {
             self.matrix_multiply.store(Some(f));
+            self.right_matrix_multiply.store(Some(f));
         }
         if let Some(f) = methods.inplace_matrix_multiply {
             self.inplace_matrix_multiply.store(Some(f));
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 67e8e1f2734..9b7a78f7237 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -350,16 +350,10 @@ mod _collections {
             Ok(zelf)
         }
 
-        #[pymethod]
         fn __len__(&self) -> usize {
             self.borrow_deque().len()
         }
 
-        #[pymethod]
-        fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
-            self.concat(&other, vm)
-        }
-
         fn concat(&self, other: &PyObject, vm: &VirtualMachine) -> PyResult<Self> {
             if let Some(o) = other.downcast_ref::<Self>() {
                 let mut deque = self.borrow_deque().clone();
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 5c298d26a56..63594879878 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -1087,7 +1087,6 @@ impl PyCArray {
         Ok(())
     }
 
-    #[pymethod]
     fn __len__(zelf: &Py<Self>, _vm: &VirtualMachine) -> usize {
         zelf.class().stg_info_opt().map_or(0, |i| i.length)
     }
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
index 400cab44210..28fa2e9b74c 100644
--- a/crates/vm/src/stdlib/winreg.rs
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -222,7 +222,6 @@ mod winreg {
             zelf.Close(vm)
         }
 
-        #[pymethod]
         fn __int__(&self) -> usize {
             self.hkey.load() as usize
         }
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index d7ead562063..17b2b4e2f8a 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -607,7 +607,9 @@ impl PyType {
         debug_assert!(name.as_str().ends_with("__"));
 
         // Find all slot_defs matching this name and update each
-        for def in find_slot_defs_by_name(name.as_str()) {
+        // NOTE: Collect into Vec first to avoid issues during iteration
+        let defs: Vec<_> = find_slot_defs_by_name(name.as_str()).collect();
+        for def in defs {
             self.update_one_slot::<ADD>(&def.accessor, name, ctx);
         }
 
@@ -676,7 +678,29 @@ impl PyType {
         macro_rules! update_sub_slot {
             ($group:ident, $slot:ident, $wrapper:expr, $variant:ident) => {{
                 if ADD {
-                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                    // Check if this type defines any method that maps to this slot.
+                    // Some slots like SqAssItem/MpAssSubscript are shared by multiple
+                    // methods (__setitem__ and __delitem__). If any of those methods
+                    // is defined, we must use the wrapper to ensure Python method calls.
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        // Check the current method name
+                        let mut result = guard.contains_key(name);
+                        // For ass_item/ass_subscript slots, also check the paired method
+                        // (__setitem__ and __delitem__ share the same slot)
+                        if !result
+                            && (stringify!($slot) == "ass_item"
+                                || stringify!($slot) == "ass_subscript")
+                        {
+                            let setitem = ctx.intern_str("__setitem__");
+                            let delitem = ctx.intern_str("__delitem__");
+                            result = guard.contains_key(setitem) || guard.contains_key(delitem);
+                        }
+                        result
+                    };
+                    if has_own {
+                        self.slots.$group.$slot.store(Some($wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
                         if let SlotFunc::$variant(f) = sf {
                             Some(*f)
                         } else {

From a445a228683412f6be0cc808c44bf462e71611e3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 16:55:39 +0900
Subject: [PATCH 146/418] fix compiler (#6615)

---
 Lib/test/test_inspect/test_inspect.py |  2 --
 Lib/test/test_unittest/test_case.py   |  2 --
 crates/vm/src/frame.rs                | 37 ++++++++++++++++++++++++++-
 crates/vm/src/vm/compile.rs           | 13 ++++++----
 4 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index 8f87fa8571a..b9cfca6df21 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -957,8 +957,6 @@ def test_getsource_stdlib_decimal(self):
 
 class TestGetsourceInteractive(unittest.TestCase):
     @support.force_not_colorized
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getclasses_interactive(self):
         # bpo-44648: simulate a REPL session;
         # there is no `__file__` in the __main__ module
diff --git a/Lib/test/test_unittest/test_case.py b/Lib/test/test_unittest/test_case.py
index ae6a2b94dba..82a442a04e6 100644
--- a/Lib/test/test_unittest/test_case.py
+++ b/Lib/test/test_unittest/test_case.py
@@ -1970,8 +1970,6 @@ def testNoCycles(self):
             del case
             self.assertFalse(wr())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_no_exception_leak(self):
         # Issue #19880: TestCase.run() should not keep a reference
         # to the exception
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 6500f578dca..1f74d07f87c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1739,7 +1739,42 @@ impl ExecutingFrame<'_> {
         // We do not have any more blocks to unwind. Inspect the reason we are here:
         match reason {
             UnwindReason::Raising { exception } => Err(exception),
-            UnwindReason::Returning { value } => Ok(Some(ExecutionResult::Return(value))),
+            UnwindReason::Returning { value } => {
+                // Clear tracebacks of exceptions in fastlocals to break reference cycles.
+                // This is needed because when returning from inside an except block,
+                // the exception cleanup code (e = None; del e) is skipped, leaving the
+                // exception with a traceback that references this frame, which references
+                // the exception in fastlocals, creating a cycle that can't be collected
+                // since RustPython doesn't have a tracing GC.
+                //
+                // We only clear tracebacks of exceptions that:
+                // 1. Are not the return value itself (will be needed by caller)
+                // 2. Are not the current active exception (still being handled)
+                // 3. Have a traceback whose top frame is THIS frame (we created it)
+                let current_exc = vm.current_exception();
+                let fastlocals = self.fastlocals.lock();
+                for obj in fastlocals.iter().flatten() {
+                    // Skip if this object is the return value
+                    if obj.is(&value) {
+                        continue;
+                    }
+                    if let Ok(exc) = obj.clone().downcast::<PyBaseException>() {
+                        // Skip if this is the current active exception
+                        if current_exc.as_ref().is_some_and(|cur| exc.is(cur)) {
+                            continue;
+                        }
+                        // Only clear if traceback's top frame is this frame
+                        if exc
+                            .__traceback__()
+                            .is_some_and(|tb| core::ptr::eq::<Py<Frame>>(&*tb.frame, self.object))
+                        {
+                            exc.set_traceback_typed(None);
+                        }
+                    }
+                }
+                drop(fastlocals);
+                Ok(Some(ExecutionResult::Return(value)))
+            }
             UnwindReason::Break { .. } | UnwindReason::Continue { .. } => {
                 self.fatal("break or continue must occur within a loop block.")
             } // UnwindReason::NoWorries => Ok(None),
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index b5f10e47aa1..07ab4b833d2 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -115,11 +115,14 @@ impl VirtualMachine {
             .compile(source, compiler::Mode::Exec, source_path.clone())
             .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
         // trace!("Code object: {:?}", code_obj.borrow());
-        scope.globals.set_item(
-            identifier!(self, __file__),
-            self.new_pyobj(source_path),
-            self,
-        )?;
+        // Only set __file__ for real file paths, not pseudo-paths like <string>
+        if !(source_path.starts_with('<') && source_path.ends_with('>')) {
+            scope.globals.set_item(
+                identifier!(self, __file__),
+                self.new_pyobj(source_path),
+                self,
+            )?;
+        }
         self.run_code_obj(code_obj, scope)
     }
 

From b446dac359e9e708eee692c9b5d70c00ff76e470 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 1 Jan 2026 10:15:00 +0200
Subject: [PATCH 147/418] Update `shelve.py` from 3.13.11 (#6483)

* Update `test_shelve.py` from 3.13.11

* Update `shelve.py` from 3.13.11
---
 Lib/shelve.py           |  11 +++-
 Lib/test/test_shelve.py | 142 +++++++++++++++++++---------------------
 2 files changed, 76 insertions(+), 77 deletions(-)

diff --git a/Lib/shelve.py b/Lib/shelve.py
index 5d443a0fa8d..50584716e9e 100644
--- a/Lib/shelve.py
+++ b/Lib/shelve.py
@@ -56,7 +56,7 @@
 the persistent dictionary on disk, if feasible).
 """
 
-from pickle import Pickler, Unpickler
+from pickle import DEFAULT_PROTOCOL, Pickler, Unpickler
 from io import BytesIO
 
 import collections.abc
@@ -85,7 +85,7 @@ def __init__(self, dict, protocol=None, writeback=False,
                  keyencoding="utf-8"):
         self.dict = dict
         if protocol is None:
-            protocol = 3
+            protocol = DEFAULT_PROTOCOL
         self._protocol = protocol
         self.writeback = writeback
         self.cache = {}
@@ -226,6 +226,13 @@ def __init__(self, filename, flag='c', protocol=None, writeback=False):
         import dbm
         Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback)
 
+    def clear(self):
+        """Remove all items from the shelf."""
+        # Call through to the clear method on dbm-backed shelves.
+        # see https://github.com/python/cpython/issues/107089
+        self.cache.clear()
+        self.dict.clear()
+
 
 def open(filename, flag='c', protocol=None, writeback=False):
     """Open a persistent dictionary for reading and writing.
diff --git a/Lib/test/test_shelve.py b/Lib/test/test_shelve.py
index ac25eee2e52..08c6562f2a2 100644
--- a/Lib/test/test_shelve.py
+++ b/Lib/test/test_shelve.py
@@ -1,7 +1,9 @@
 import unittest
+import dbm
 import shelve
-import glob
-from test import support
+import pickle
+import os
+
 from test.support import os_helper
 from collections.abc import MutableMapping
 from test.test_dbm import dbm_iterator
@@ -41,12 +43,8 @@ def copy(self):
 
 
 class TestCase(unittest.TestCase):
-
-    fn = "shelftemp.db"
-
-    def tearDown(self):
-        for f in glob.glob(self.fn+"*"):
-            os_helper.unlink(f)
+    dirname = os_helper.TESTFN
+    fn = os.path.join(os_helper.TESTFN, "shelftemp.db")
 
     def test_close(self):
         d1 = {}
@@ -63,29 +61,34 @@ def test_close(self):
         else:
             self.fail('Closed shelf should not find a key')
 
-    def test_ascii_file_shelf(self):
-        s = shelve.open(self.fn, protocol=0)
+    def test_open_template(self, filename=None, protocol=None):
+        os.mkdir(self.dirname)
+        self.addCleanup(os_helper.rmtree, self.dirname)
+        s = shelve.open(filename=filename if filename is not None else self.fn,
+                        protocol=protocol)
         try:
             s['key1'] = (1,2,3,4)
             self.assertEqual(s['key1'], (1,2,3,4))
         finally:
             s.close()
 
+    def test_ascii_file_shelf(self):
+        self.test_open_template(protocol=0)
+
     def test_binary_file_shelf(self):
-        s = shelve.open(self.fn, protocol=1)
-        try:
-            s['key1'] = (1,2,3,4)
-            self.assertEqual(s['key1'], (1,2,3,4))
-        finally:
-            s.close()
+        self.test_open_template(protocol=1)
 
     def test_proto2_file_shelf(self):
-        s = shelve.open(self.fn, protocol=2)
-        try:
-            s['key1'] = (1,2,3,4)
-            self.assertEqual(s['key1'], (1,2,3,4))
-        finally:
-            s.close()
+        self.test_open_template(protocol=2)
+
+    def test_pathlib_path_file_shelf(self):
+        self.test_open_template(filename=os_helper.FakePath(self.fn))
+
+    def test_bytes_path_file_shelf(self):
+        self.test_open_template(filename=os.fsencode(self.fn))
+
+    def test_pathlib_bytes_path_file_shelf(self):
+        self.test_open_template(filename=os_helper.FakePath(os.fsencode(self.fn)))
 
     def test_in_memory_shelf(self):
         d1 = byteskeydict()
@@ -160,65 +163,54 @@ def test_with(self):
 
     def test_default_protocol(self):
         with shelve.Shelf({}) as s:
-            self.assertEqual(s._protocol, 3)
+            self.assertEqual(s._protocol, pickle.DEFAULT_PROTOCOL)
 
-from test import mapping_tests
 
-class TestShelveBase(mapping_tests.BasicTestMappingProtocol):
-    fn = "shelftemp.db"
-    counter = 0
-    def __init__(self, *args, **kw):
-        self._db = []
-        mapping_tests.BasicTestMappingProtocol.__init__(self, *args, **kw)
+class TestShelveBase:
     type2test = shelve.Shelf
+
     def _reference(self):
         return {"key1":"value1", "key2":2, "key3":(1,2,3)}
+
+
+class TestShelveInMemBase(TestShelveBase):
     def _empty_mapping(self):
-        if self._in_mem:
-            x= shelve.Shelf(byteskeydict(), **self._args)
-        else:
-            self.counter+=1
-            x= shelve.open(self.fn+str(self.counter), **self._args)
-        self._db.append(x)
+        return shelve.Shelf(byteskeydict(), **self._args)
+
+
+class TestShelveFileBase(TestShelveBase):
+    counter = 0
+
+    def _empty_mapping(self):
+        self.counter += 1
+        x = shelve.open(self.base_path + str(self.counter), **self._args)
+        self.addCleanup(x.close)
         return x
-    def tearDown(self):
-        for db in self._db:
-            db.close()
-        self._db = []
-        if not self._in_mem:
-            for f in glob.glob(self.fn+"*"):
-                os_helper.unlink(f)
-
-class TestAsciiFileShelve(TestShelveBase):
-    _args={'protocol':0}
-    _in_mem = False
-class TestBinaryFileShelve(TestShelveBase):
-    _args={'protocol':1}
-    _in_mem = False
-class TestProto2FileShelve(TestShelveBase):
-    _args={'protocol':2}
-    _in_mem = False
-class TestAsciiMemShelve(TestShelveBase):
-    _args={'protocol':0}
-    _in_mem = True
-class TestBinaryMemShelve(TestShelveBase):
-    _args={'protocol':1}
-    _in_mem = True
-class TestProto2MemShelve(TestShelveBase):
-    _args={'protocol':2}
-    _in_mem = True
-
-def test_main():
-    for module in dbm_iterator():
-        support.run_unittest(
-            TestAsciiFileShelve,
-            TestBinaryFileShelve,
-            TestProto2FileShelve,
-            TestAsciiMemShelve,
-            TestBinaryMemShelve,
-            TestProto2MemShelve,
-            TestCase
-        )
+
+    def setUp(self):
+        dirname = os_helper.TESTFN
+        os.mkdir(dirname)
+        self.addCleanup(os_helper.rmtree, dirname)
+        self.base_path = os.path.join(dirname, "shelftemp.db")
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
+        dbm._defaultmod = self.dbm_mod
+
+
+from test import mapping_tests
+
+for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+    bases = (TestShelveInMemBase, mapping_tests.BasicTestMappingProtocol)
+    name = f'TestProto{proto}MemShelve'
+    globals()[name] = type(name, bases,
+                           {'_args': {'protocol': proto}})
+    bases = (TestShelveFileBase, mapping_tests.BasicTestMappingProtocol)
+    for dbm_mod in dbm_iterator():
+        assert dbm_mod.__name__.startswith('dbm.')
+        suffix = dbm_mod.__name__[4:]
+        name = f'TestProto{proto}File_{suffix}Shelve'
+        globals()[name] = type(name, bases,
+                               {'dbm_mod': dbm_mod, '_args': {'protocol': proto}})
+
 
 if __name__ == "__main__":
-    test_main()
+    unittest.main()

From 3e2ada058651d9a1648bdb1453999758a32c4d13 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Thu, 1 Jan 2026 11:35:55 +0200
Subject: [PATCH 148/418] Update `test_sys.py` from 3.13.11 (#6428)

* mark RustPython as  free-threaded

* Py_GIL_DISABLED

* Update `test_sys.py` from 3.13.11

* mark tests

---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 Lib/test/test_sys.py                  | 716 ++++++++++++++++++--------
 crates/vm/src/stdlib/sys.rs           |   7 +-
 crates/vm/src/stdlib/sysconfigdata.rs |   2 +
 3 files changed, 498 insertions(+), 227 deletions(-)

diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 6ae3eaee74b..969c2866aac 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -1,9 +1,12 @@
 import builtins
 import codecs
+# import _datetime # TODO: RUSTPYTHON
 import gc
+import io
 import locale
 import operator
 import os
+import random
 import struct
 import subprocess
 import sys
@@ -14,14 +17,21 @@
 from test.support.script_helper import assert_python_ok, assert_python_failure
 from test.support import threading_helper
 from test.support import import_helper
+from test.support import force_not_colorized
+try:
+    from test.support import interpreters
+except ImportError:
+    interpreters = None
 import textwrap
 import unittest
 import warnings
 
 
-# count the number of test runs, used to create unique
-# strings to intern in test_intern()
-INTERN_NUMRUNS = 0
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(interpreters is None,
+                           'subinterpreters required')(meth)
+
 
 DICT_KEY_STRUCT_FORMAT = 'n2BI2n'
 
@@ -71,6 +81,18 @@ def baddisplayhook(obj):
             code = compile("42", "<string>", "single")
             self.assertRaises(ValueError, eval, code)
 
+    def test_gh130163(self):
+        class X:
+            def __repr__(self):
+                sys.stdout = io.StringIO()
+                support.gc_collect()
+                return 'foo'
+
+        with support.swap_attr(sys, 'stdout', None):
+            sys.stdout = io.StringIO()  # the only reference
+            sys.displayhook(X())  # should not crash
+
+
 class ActiveExceptionTests(unittest.TestCase):
     def test_exc_info_no_exception(self):
         self.assertEqual(sys.exc_info(), (None, None, None))
@@ -137,6 +159,7 @@ def f():
 
 class ExceptHookTest(unittest.TestCase):
 
+    @force_not_colorized
     def test_original_excepthook(self):
         try:
             raise ValueError(42)
@@ -148,8 +171,8 @@ def test_original_excepthook(self):
 
         self.assertRaises(TypeError, sys.__excepthook__)
 
-    # TODO: RUSTPYTHON, SyntaxError formatting in arbitrary tracebacks
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError formatting in arbitrary tracebacks
+    @force_not_colorized
     def test_excepthook_bytes_filename(self):
         # bpo-37467: sys.excepthook() must not crash if a filename
         # is a bytes string
@@ -169,7 +192,8 @@ def test_excepthook_bytes_filename(self):
 
     def test_excepthook(self):
         with test.support.captured_output("stderr") as stderr:
-            sys.excepthook(1, '1', 1)
+            with test.support.catch_unraisable_exception():
+                sys.excepthook(1, '1', 1)
         self.assertTrue("TypeError: print_exception(): Exception expected for " \
                          "value, str found" in stderr.getvalue())
 
@@ -182,6 +206,7 @@ class SysModuleTest(unittest.TestCase):
     def tearDown(self):
         test.support.reap_children()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_exit(self):
         # call with two arguments
         self.assertRaises(TypeError, sys.exit, 42, 42)
@@ -196,6 +221,20 @@ def test_exit(self):
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+        # gh-125842: Windows uses 32-bit unsigned integers for exit codes
+        # so a -1 exit code is sometimes interpreted as 0xffff_ffff.
+        rc, out, err = assert_python_failure('-c', 'import sys; sys.exit(0xffff_ffff)')
+        self.assertIn(rc, (-1, 0xff, 0xffff_ffff))
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
+
+        # Overflow results in a -1 exit code, which may be converted to 0xff
+        # or 0xffff_ffff.
+        rc, out, err = assert_python_failure('-c', 'import sys; sys.exit(2**128)')
+        self.assertIn(rc, (-1, 0xff, 0xffff_ffff))
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
+
         # call with integer argument
         with self.assertRaises(SystemExit) as cm:
             sys.exit(42)
@@ -238,17 +277,36 @@ def check_exit_message(code, expected, **env_vars):
 
         # test that the exit message is written with backslashreplace error
         # handler to stderr
-        # TODO: RUSTPYTHON; allow surrogates in strings
-        # check_exit_message(
-        #     r'import sys; sys.exit("surrogates:\uDCFF")',
-        #     b"surrogates:\\udcff")
+        check_exit_message(
+            r'import sys; sys.exit("surrogates:\uDCFF")',
+            b"surrogates:\\udcff")
 
         # test that the unicode message is encoded to the stderr encoding
         # instead of the default encoding (utf8)
-        # TODO: RUSTPYTHON; handle PYTHONIOENCODING
-        # check_exit_message(
-        #     r'import sys; sys.exit("h\xe9")',
-        #     b"h\xe9", PYTHONIOENCODING='latin-1')
+        check_exit_message(
+            r'import sys; sys.exit("h\xe9")',
+            b"h\xe9", PYTHONIOENCODING='latin-1')
+
+    @support.requires_subprocess()
+    def test_exit_codes_under_repl(self):
+        # GH-129900: SystemExit, or things that raised it, didn't
+        # get their return code propagated by the REPL
+        import tempfile
+
+        exit_ways = [
+            "exit",
+            "__import__('sys').exit",
+            "raise SystemExit"
+        ]
+
+        for exitfunc in exit_ways:
+            for return_code in (0, 123):
+                with self.subTest(exitfunc=exitfunc, return_code=return_code):
+                    with tempfile.TemporaryFile("w+") as stdin:
+                        stdin.write(f"{exitfunc}({return_code})\n")
+                        stdin.seek(0)
+                        proc = subprocess.run([sys.executable], stdin=stdin)
+                        self.assertEqual(proc.returncode, return_code)
 
     def test_getdefaultencoding(self):
         self.assertRaises(TypeError, sys.getdefaultencoding, 42)
@@ -273,21 +331,30 @@ def test_switchinterval(self):
         finally:
             sys.setswitchinterval(orig)
 
-    def test_recursionlimit(self):
+    def test_getrecursionlimit(self):
+        limit = sys.getrecursionlimit()
+        self.assertIsInstance(limit, int)
+        self.assertGreater(limit, 1)
+
         self.assertRaises(TypeError, sys.getrecursionlimit, 42)
-        oldlimit = sys.getrecursionlimit()
-        self.assertRaises(TypeError, sys.setrecursionlimit)
-        self.assertRaises(ValueError, sys.setrecursionlimit, -42)
-        sys.setrecursionlimit(10000)
-        self.assertEqual(sys.getrecursionlimit(), 10000)
-        sys.setrecursionlimit(oldlimit)
-
-    @unittest.skipIf(getattr(sys, "_rustpython_debugbuild", False), "TODO: RUSTPYTHON, stack overflow on debug build")
+
+    def test_setrecursionlimit(self):
+        old_limit = sys.getrecursionlimit()
+        try:
+            sys.setrecursionlimit(10_005)
+            self.assertEqual(sys.getrecursionlimit(), 10_005)
+
+            self.assertRaises(TypeError, sys.setrecursionlimit)
+            self.assertRaises(ValueError, sys.setrecursionlimit, -42)
+        finally:
+            sys.setrecursionlimit(old_limit)
+
+    @unittest.skipIf(getattr(sys, '_rustpython_debugbuild', False), 'TODO: RUSTPYTHON; stack overflow on debug build')
     def test_recursionlimit_recovery(self):
         if hasattr(sys, 'gettrace') and sys.gettrace():
             self.skipTest('fatal error if run with a trace function')
 
-        oldlimit = sys.getrecursionlimit()
+        old_limit = sys.getrecursionlimit()
         def f():
             f()
         try:
@@ -306,38 +373,63 @@ def f():
                 with self.assertRaises(RecursionError):
                     f()
         finally:
-            sys.setrecursionlimit(oldlimit)
+            sys.setrecursionlimit(old_limit)
 
     @test.support.cpython_only
-    def test_setrecursionlimit_recursion_depth(self):
+    def test_setrecursionlimit_to_depth(self):
         # Issue #25274: Setting a low recursion limit must be blocked if the
         # current recursion depth is already higher than limit.
 
-        from _testinternalcapi import get_recursion_depth
-
-        def set_recursion_limit_at_depth(depth, limit):
-            recursion_depth = get_recursion_depth()
-            if recursion_depth >= depth:
+        old_limit = sys.getrecursionlimit()
+        try:
+            depth = support.get_recursion_depth()
+            with self.subTest(limit=sys.getrecursionlimit(), depth=depth):
+                # depth + 1 is OK
+                sys.setrecursionlimit(depth + 1)
+
+                # reset the limit to be able to call self.assertRaises()
+                # context manager
+                sys.setrecursionlimit(old_limit)
                 with self.assertRaises(RecursionError) as cm:
-                    sys.setrecursionlimit(limit)
-                self.assertRegex(str(cm.exception),
-                                 "cannot set the recursion limit to [0-9]+ "
-                                 "at the recursion depth [0-9]+: "
-                                 "the limit is too low")
-            else:
-                set_recursion_limit_at_depth(depth, limit)
+                    sys.setrecursionlimit(depth)
+            self.assertRegex(str(cm.exception),
+                             "cannot set the recursion limit to [0-9]+ "
+                             "at the recursion depth [0-9]+: "
+                             "the limit is too low")
+        finally:
+            sys.setrecursionlimit(old_limit)
 
-        oldlimit = sys.getrecursionlimit()
-        try:
-            sys.setrecursionlimit(1000)
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful if the GIL is disabled")
+    @threading_helper.requires_working_threading()
+    def test_racing_recursion_limit(self):
+        from threading import Thread
+        def something_recursive():
+            def count(n):
+                if n > 0:
+                    return count(n - 1) + 1
+                return 0
 
-            for limit in (10, 25, 50, 75, 100, 150, 200):
-                set_recursion_limit_at_depth(limit, limit)
-        finally:
-            sys.setrecursionlimit(oldlimit)
+            count(50)
+
+        def set_recursion_limit():
+            for limit in range(100, 200):
+                sys.setrecursionlimit(limit)
+
+        threads = []
+        for _ in range(5):
+            threads.append(Thread(target=set_recursion_limit))
+
+        for _ in range(5):
+            threads.append(Thread(target=something_recursive))
+
+        with threading_helper.catch_threading_exception() as cm:
+            with threading_helper.start_threads(threads):
+                pass
+
+            if cm.exc_value:
+                raise cm.exc_value
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getwindowsversion(self):
         # Raise SkipTest if sys doesn't have getwindowsversion attribute
         test.support.get_attribute(sys, "getwindowsversion")
@@ -368,8 +460,7 @@ def test_getwindowsversion(self):
         #  still has 5 elements
         maj, min, buildno, plat, csd = sys.getwindowsversion()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'call_tracing'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute 'call_tracing'
     def test_call_tracing(self):
         self.assertRaises(TypeError, sys.call_tracing, type, 2)
 
@@ -386,15 +477,21 @@ def test_dlopenflags(self):
 
     @test.support.refcount_test
     def test_refcount(self):
-        # n here must be a global in order for this test to pass while
-        # tracing with a python function.  Tracing calls PyFrame_FastToLocals
-        # which will add a copy of any locals to the frame object, causing
-        # the reference count to increase by 2 instead of 1.
+        # n here originally had to be a global in order for this test to pass
+        # while tracing with a python function. Tracing used to call
+        # PyFrame_FastToLocals, which would add a copy of any locals to the
+        # frame object, causing the ref count to increase by 2 instead of 1.
+        # While that no longer happens (due to PEP 667), this test case retains
+        # its original global-based implementation
+        # PEP 683's immortal objects also made this point moot, since the
+        # refcount for None doesn't change anyway. Maybe this test should be
+        # using a different constant value? (e.g. an integer)
         global n
         self.assertRaises(TypeError, sys.getrefcount)
         c = sys.getrefcount(None)
         n = None
-        self.assertEqual(sys.getrefcount(None), c+1)
+        # Singleton refcnts don't change
+        self.assertEqual(sys.getrefcount(None), c)
         del n
         self.assertEqual(sys.getrefcount(None), c)
         if hasattr(sys, "gettotalrefcount"):
@@ -408,6 +505,26 @@ def test_getframe(self):
             is sys._getframe().f_code
         )
 
+    def test_getframemodulename(self):
+        # Default depth gets ourselves
+        self.assertEqual(__name__, sys._getframemodulename())
+        self.assertEqual("unittest.case", sys._getframemodulename(1))
+        i = 0
+        f = sys._getframe(i)
+        while f:
+            self.assertEqual(
+                f.f_globals['__name__'],
+                sys._getframemodulename(i) or '__main__'
+            )
+            i += 1
+            f2 = f.f_back
+            try:
+                f = sys._getframe(i)
+            except ValueError:
+                break
+            self.assertIs(f, f2)
+        self.assertIsNone(sys._getframemodulename(i))
+
     # sys._current_frames() is a CPython-only gimmick.
     # XXX RUSTPYTHON: above comment is from original cpython test; not sure why the cpython_only decorator wasn't added
     @test.support.cpython_only
@@ -436,49 +553,49 @@ def g456():
         t.start()
         entered_g.wait()
 
-        # At this point, t has finished its entered_g.set(), although it's
-        # impossible to guess whether it's still on that line or has moved on
-        # to its leave_g.wait().
-        self.assertEqual(len(thread_info), 1)
-        thread_id = thread_info[0]
-
-        d = sys._current_frames()
-        for tid in d:
-            self.assertIsInstance(tid, int)
-            self.assertGreater(tid, 0)
-
-        main_id = threading.get_ident()
-        self.assertIn(main_id, d)
-        self.assertIn(thread_id, d)
-
-        # Verify that the captured main-thread frame is _this_ frame.
-        frame = d.pop(main_id)
-        self.assertTrue(frame is sys._getframe())
-
-        # Verify that the captured thread frame is blocked in g456, called
-        # from f123.  This is a little tricky, since various bits of
-        # threading.py are also in the thread's call stack.
-        frame = d.pop(thread_id)
-        stack = traceback.extract_stack(frame)
-        for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
-            if funcname == "f123":
-                break
-        else:
-            self.fail("didn't find f123() on thread's call stack")
-
-        self.assertEqual(sourceline, "g456()")
+        try:
+            # At this point, t has finished its entered_g.set(), although it's
+            # impossible to guess whether it's still on that line or has moved on
+            # to its leave_g.wait().
+            self.assertEqual(len(thread_info), 1)
+            thread_id = thread_info[0]
+
+            d = sys._current_frames()
+            for tid in d:
+                self.assertIsInstance(tid, int)
+                self.assertGreater(tid, 0)
+
+            main_id = threading.get_ident()
+            self.assertIn(main_id, d)
+            self.assertIn(thread_id, d)
+
+            # Verify that the captured main-thread frame is _this_ frame.
+            frame = d.pop(main_id)
+            self.assertTrue(frame is sys._getframe())
+
+            # Verify that the captured thread frame is blocked in g456, called
+            # from f123.  This is a little tricky, since various bits of
+            # threading.py are also in the thread's call stack.
+            frame = d.pop(thread_id)
+            stack = traceback.extract_stack(frame)
+            for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
+                if funcname == "f123":
+                    break
+            else:
+                self.fail("didn't find f123() on thread's call stack")
 
-        # And the next record must be for g456().
-        filename, lineno, funcname, sourceline = stack[i+1]
-        self.assertEqual(funcname, "g456")
-        self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
+            self.assertEqual(sourceline, "g456()")
 
-        # Reap the spawned thread.
-        leave_g.set()
-        t.join()
+            # And the next record must be for g456().
+            filename, lineno, funcname, sourceline = stack[i+1]
+            self.assertEqual(funcname, "g456")
+            self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute '_current_exceptions'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_current_exceptions'
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_current_exceptions(self):
@@ -488,7 +605,7 @@ def test_current_exceptions(self):
         # Spawn a thread that blocks at a known place.  Then the main
         # thread does sys._current_frames(), and verifies that the frames
         # returned make sense.
-        entered_g = threading.Event()
+        g_raised = threading.Event()
         leave_g = threading.Event()
         thread_info = []  # the thread's id
 
@@ -497,55 +614,54 @@ def f123():
 
         def g456():
             thread_info.append(threading.get_ident())
-            entered_g.set()
             while True:
                 try:
                     raise ValueError("oops")
                 except ValueError:
+                    g_raised.set()
                     if leave_g.wait(timeout=support.LONG_TIMEOUT):
                         break
 
         t = threading.Thread(target=f123)
         t.start()
-        entered_g.wait()
+        g_raised.wait(timeout=support.LONG_TIMEOUT)
 
-        # At this point, t has finished its entered_g.set(), although it's
-        # impossible to guess whether it's still on that line or has moved on
-        # to its leave_g.wait().
-        self.assertEqual(len(thread_info), 1)
-        thread_id = thread_info[0]
-
-        d = sys._current_exceptions()
-        for tid in d:
-            self.assertIsInstance(tid, int)
-            self.assertGreater(tid, 0)
-
-        main_id = threading.get_ident()
-        self.assertIn(main_id, d)
-        self.assertIn(thread_id, d)
-        self.assertEqual((None, None, None), d.pop(main_id))
-
-        # Verify that the captured thread frame is blocked in g456, called
-        # from f123.  This is a little tricky, since various bits of
-        # threading.py are also in the thread's call stack.
-        exc_type, exc_value, exc_tb = d.pop(thread_id)
-        stack = traceback.extract_stack(exc_tb.tb_frame)
-        for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
-            if funcname == "f123":
-                break
-        else:
-            self.fail("didn't find f123() on thread's call stack")
-
-        self.assertEqual(sourceline, "g456()")
+        try:
+            self.assertEqual(len(thread_info), 1)
+            thread_id = thread_info[0]
+
+            d = sys._current_exceptions()
+            for tid in d:
+                self.assertIsInstance(tid, int)
+                self.assertGreater(tid, 0)
+
+            main_id = threading.get_ident()
+            self.assertIn(main_id, d)
+            self.assertIn(thread_id, d)
+            self.assertEqual(None, d.pop(main_id))
+
+            # Verify that the captured thread frame is blocked in g456, called
+            # from f123.  This is a little tricky, since various bits of
+            # threading.py are also in the thread's call stack.
+            exc_value = d.pop(thread_id)
+            stack = traceback.extract_stack(exc_value.__traceback__.tb_frame)
+            for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
+                if funcname == "f123":
+                    break
+            else:
+                self.fail("didn't find f123() on thread's call stack")
 
-        # And the next record must be for g456().
-        filename, lineno, funcname, sourceline = stack[i+1]
-        self.assertEqual(funcname, "g456")
-        self.assertTrue(sourceline.startswith("if leave_g.wait("))
+            self.assertEqual(sourceline, "g456()")
 
-        # Reap the spawned thread.
-        leave_g.set()
-        t.join()
+            # And the next record must be for g456().
+            filename, lineno, funcname, sourceline = stack[i+1]
+            self.assertEqual(funcname, "g456")
+            self.assertTrue((sourceline.startswith("if leave_g.wait(") or
+                             sourceline.startswith("g_raised.set()")))
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
 
     def test_attributes(self):
         self.assertIsInstance(sys.api_version, int)
@@ -647,7 +763,7 @@ def test_thread_info(self):
         self.assertEqual(len(info), 3)
         self.assertIn(info.name, ('nt', 'pthread', 'pthread-stubs', 'solaris', None))
         self.assertIn(info.lock, ('semaphore', 'mutex+cond', None))
-        if sys.platform.startswith(("linux", "freebsd")):
+        if sys.platform.startswith(("linux", "android", "freebsd")):
             self.assertEqual(info.name, "pthread")
         elif sys.platform == "win32":
             self.assertEqual(info.name, "nt")
@@ -670,13 +786,23 @@ def test_43581(self):
         self.assertEqual(sys.__stdout__.encoding, sys.__stderr__.encoding)
 
     def test_intern(self):
-        global INTERN_NUMRUNS
-        INTERN_NUMRUNS += 1
+        has_is_interned = (test.support.check_impl_detail(cpython=True)
+                           or hasattr(sys, '_is_interned'))
         self.assertRaises(TypeError, sys.intern)
-        s = "never interned before" + str(INTERN_NUMRUNS)
+        self.assertRaises(TypeError, sys.intern, b'abc')
+        if has_is_interned:
+            self.assertRaises(TypeError, sys._is_interned)
+            self.assertRaises(TypeError, sys._is_interned, b'abc')
+        s = "never interned before" + str(random.randrange(0, 10**9))
         self.assertTrue(sys.intern(s) is s)
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s), True)
         s2 = s.swapcase().swapcase()
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s2), False)
         self.assertTrue(sys.intern(s2) is s)
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s2), False)
 
         # Subclasses of string can't be interned, because they
         # provide too much opportunity for insane things to happen.
@@ -688,6 +814,73 @@ def __hash__(self):
                 return 123
 
         self.assertRaises(TypeError, sys.intern, S("abc"))
+        if has_is_interned:
+            self.assertIs(sys._is_interned(S("abc")), False)
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_dynamically_allocated(self):
+        # Implementation detail: Dynamically allocated strings
+        # are distinct between interpreters
+        s = "never interned before" + str(random.randrange(0, 10**9))
+        t = sys.intern(s)
+        self.assertIs(t, s)
+
+        interp = interpreters.create()
+        interp.exec(textwrap.dedent(f'''
+            import sys
+
+            # set `s`, avoid parser interning & constant folding
+            s = str({s.encode()!r}, 'utf-8')
+
+            t = sys.intern(s)
+
+            assert id(t) != {id(s)}, (id(t), {id(s)})
+            assert id(t) != {id(t)}, (id(t), {id(t)})
+            '''))
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_statically_allocated(self):
+        # Implementation detail: Statically allocated strings are shared
+        # between interpreters.
+        # See Tools/build/generate_global_objects.py for the list
+        # of strings that are always statically allocated.
+        for s in ('__init__', 'CANCELLED', '<module>', 'utf-8',
+                  '{{', '', '\n', '_', 'x', '\0', '\N{CEDILLA}', '\xff',
+                  ):
+            with self.subTest(s=s):
+                t = sys.intern(s)
+
+                interp = interpreters.create()
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+
+                    # set `s`, avoid parser interning & constant folding
+                    s = str({s.encode()!r}, 'utf-8')
+
+                    t = sys.intern(s)
+                    assert id(t) == {id(t)}, (id(t), {id(t)})
+                    '''))
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_singleton(self):
+        # Implementation detail: singletons are used for 0- and 1-character
+        # latin1 strings.
+        for s in '', '\n', '_', 'x', '\0', '\N{CEDILLA}', '\xff':
+            with self.subTest(s=s):
+                interp = interpreters.create()
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+
+                    # set `s`, avoid parser interning & constant folding
+                    s = str({s.encode()!r}, 'utf-8')
+
+                    assert id(s) == {id(s)}
+                    t = sys.intern(s)
+                    '''))
+                self.assertTrue(sys._is_interned(s))
 
     def test_sys_flags(self):
         self.assertTrue(sys.flags)
@@ -709,12 +902,7 @@ def test_sys_flags(self):
     def assert_raise_on_new_sys_type(self, sys_attr):
         # Users are intentionally prevented from creating new instances of
         # sys.flags, sys.version_info, and sys.getwindowsversion.
-        arg = sys_attr
-        attr_type = type(sys_attr)
-        with self.assertRaises(TypeError):
-            attr_type(arg)
-        with self.assertRaises(TypeError):
-            attr_type.__new__(attr_type, arg)
+        support.check_disallow_instantiation(self, type(sys_attr), sys_attr)
 
     def test_sys_flags_no_instantiation(self):
         self.assert_raise_on_new_sys_type(sys.flags)
@@ -722,8 +910,7 @@ def test_sys_flags_no_instantiation(self):
     def test_sys_version_info_no_instantiation(self):
         self.assert_raise_on_new_sys_type(sys.version_info)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sys_getwindowsversion_no_instantiation(self):
         # Skip if not being run on Windows.
         test.support.get_attribute(sys, "getwindowsversion")
@@ -733,8 +920,8 @@ def test_sys_getwindowsversion_no_instantiation(self):
     def test_clear_type_cache(self):
         sys._clear_type_cache()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
     @support.requires_subprocess()
     def test_ioencoding(self):
         env = dict(os.environ)
@@ -898,14 +1085,12 @@ def check_locale_surrogateescape(self, locale):
                          'stdout: surrogateescape\n'
                          'stderr: backslashreplace\n')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_c_locale_surrogateescape(self):
         self.check_locale_surrogateescape('C')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_posix_locale_surrogateescape(self):
         self.check_locale_surrogateescape('POSIX')
@@ -958,12 +1143,12 @@ def test_debugmallocstats(self):
                          "sys.getallocatedblocks unavailable on this build")
     def test_getallocatedblocks(self):
         try:
-            import _testcapi
+            import _testinternalcapi
         except ImportError:
             with_pymalloc = support.with_pymalloc()
         else:
             try:
-                alloc_name = _testcapi.pymem_getallocatorsname()
+                alloc_name = _testinternalcapi.pymem_getallocatorsname()
             except RuntimeError as exc:
                 # "cannot get allocators name" (ex: tracemalloc is used)
                 with_pymalloc = True
@@ -995,8 +1180,13 @@ def test_getallocatedblocks(self):
         c = sys.getallocatedblocks()
         self.assertIn(c, range(b - 50, b + 50))
 
-    # TODO: RUSTPYTHON, AtExit.__del__ is not invoked because module destruction is missing.
-    @unittest.expectedFailure
+    def test_is_gil_enabled(self):
+        if support.Py_GIL_DISABLED:
+            self.assertIs(type(sys._is_gil_enabled()), bool)
+        else:
+            self.assertTrue(sys._is_gil_enabled())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AtExit.__del__ is not invoked because module destruction is missing.
     def test_is_finalizing(self):
         self.assertIs(sys.is_finalizing(), False)
         # Don't use the atexit module because _Py_Finalizing is only set
@@ -1018,8 +1208,7 @@ def __del__(self):
         rc, stdout, stderr = assert_python_ok('-c', code)
         self.assertEqual(stdout.rstrip(), b'True')
 
-    # TODO: RUSTPYTHON, IndexError: list index out of range
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; IndexError: list index out of range
     def test_issue20602(self):
         # sys.flags and sys.float_info were wiped during shutdown.
         code = """if 1:
@@ -1052,15 +1241,15 @@ def __del__(self):
         self.assertEqual(stdout.rstrip(), b"")
         self.assertEqual(stderr.rstrip(), b"")
 
-    @unittest.skipUnless(hasattr(sys, 'getandroidapilevel'),
-                         'need sys.getandroidapilevel()')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute 'getandroidapilevel'
+    @unittest.skipUnless(sys.platform == "android", "Android only")
     def test_getandroidapilevel(self):
         level = sys.getandroidapilevel()
         self.assertIsInstance(level, int)
         self.assertGreater(level, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
     @support.requires_subprocess()
     def test_sys_tracebacklimit(self):
         code = """if 1:
@@ -1081,14 +1270,20 @@ def check(tracebacklimit, expected):
         traceback = [
             b'Traceback (most recent call last):',
             b'  File "<string>", line 8, in <module>',
+            b'    f2()',
+            b'    ~~^^',
             b'  File "<string>", line 6, in f2',
+            b'    f1()',
+            b'    ~~^^',
             b'  File "<string>", line 4, in f1',
+            b'    1 / 0',
+            b'    ~~^~~',
             b'ZeroDivisionError: division by zero'
         ]
         check(10, traceback)
         check(3, traceback)
-        check(2, traceback[:1] + traceback[2:])
-        check(1, traceback[:1] + traceback[3:])
+        check(2, traceback[:1] + traceback[4:])
+        check(1, traceback[:1] + traceback[7:])
         check(0, [traceback[-1]])
         check(-1, [traceback[-1]])
         check(1<<1000, traceback)
@@ -1129,8 +1324,7 @@ def test_module_names(self):
         for name in sys.stdlib_module_names:
             self.assertIsInstance(name, str)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute '_stdlib_dir'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_stdlib_dir'
     def test_stdlib_dir(self):
         os = import_helper.import_fresh_module('os')
         marker = getattr(os, '__file__', None)
@@ -1140,41 +1334,76 @@ def test_stdlib_dir(self):
         self.assertEqual(os.path.normpath(sys._stdlib_dir),
                          os.path.normpath(expected))
 
+    @unittest.skipUnless(hasattr(sys, 'getobjects'), 'need sys.getobjects()')
+    def test_getobjects(self):
+        # sys.getobjects(0)
+        all_objects = sys.getobjects(0)
+        self.assertIsInstance(all_objects, list)
+        self.assertGreater(len(all_objects), 0)
+
+        # sys.getobjects(0, MyType)
+        class MyType:
+            pass
+        size = 100
+        my_objects = [MyType() for _ in range(size)]
+        get_objects = sys.getobjects(0, MyType)
+        self.assertEqual(len(get_objects), size)
+        for obj in get_objects:
+            self.assertIsInstance(obj, MyType)
+
+        # sys.getobjects(3, MyType)
+        get_objects = sys.getobjects(3, MyType)
+        self.assertEqual(len(get_objects), 3)
+
+    @unittest.skipUnless(hasattr(sys, '_stats_on'), 'need Py_STATS build')
+    def test_pystats(self):
+        # Call the functions, just check that they don't crash
+        # Cannot save/restore state.
+        sys._stats_on()
+        sys._stats_off()
+        sys._stats_clear()
+        sys._stats_dump()
+
+    @test.support.cpython_only
+    @unittest.skipUnless(hasattr(sys, 'abiflags'), 'need sys.abiflags')
+    def test_disable_gil_abi(self):
+        self.assertEqual('t' in sys.abiflags, support.Py_GIL_DISABLED)
+
 
 @test.support.cpython_only
 class UnraisableHookTest(unittest.TestCase):
-    def write_unraisable_exc(self, exc, err_msg, obj):
-        import _testcapi
-        import types
-        err_msg2 = f"Exception ignored {err_msg}"
-        try:
-            _testcapi.write_unraisable_exc(exc, err_msg, obj)
-            return types.SimpleNamespace(exc_type=type(exc),
-                                         exc_value=exc,
-                                         exc_traceback=exc.__traceback__,
-                                         err_msg=err_msg2,
-                                         object=obj)
-        finally:
-            # Explicitly break any reference cycle
-            exc = None
-
     def test_original_unraisablehook(self):
-        for err_msg in (None, "original hook"):
-            with self.subTest(err_msg=err_msg):
-                obj = "an object"
-
-                with test.support.captured_output("stderr") as stderr:
-                    with test.support.swap_attr(sys, 'unraisablehook',
-                                                sys.__unraisablehook__):
-                        self.write_unraisable_exc(ValueError(42), err_msg, obj)
-
-                err = stderr.getvalue()
-                if err_msg is not None:
-                    self.assertIn(f'Exception ignored {err_msg}: {obj!r}\n', err)
-                else:
-                    self.assertIn(f'Exception ignored in: {obj!r}\n', err)
-                self.assertIn('Traceback (most recent call last):\n', err)
-                self.assertIn('ValueError: 42\n', err)
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable, err_formatunraisable
+        obj = hex
+
+        with support.swap_attr(sys, 'unraisablehook',
+                                    sys.__unraisablehook__):
+            with support.captured_stderr() as stderr:
+                err_writeunraisable(ValueError(42), obj)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], f'Exception ignored in: {obj!r}')
+            self.assertEqual(lines[1], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_writeunraisable(ValueError(42), None)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_formatunraisable(ValueError(42), 'Error in %R', obj)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], f'Error in {obj!r}:')
+            self.assertEqual(lines[1], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_formatunraisable(ValueError(42), None)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
 
     def test_original_unraisablehook_err(self):
         # bpo-22836: PyErr_WriteUnraisable() should give sensible reports
@@ -1221,6 +1450,8 @@ def test_original_unraisablehook_exception_qualname(self):
         # Check that the exception is printed with its qualified name
         # rather than just classname, and the module names appears
         # unless it is one of the hard-coded exclusions.
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable
         class A:
             class B:
                 class X(Exception):
@@ -1232,9 +1463,7 @@ class X(Exception):
                 with test.support.captured_stderr() as stderr, test.support.swap_attr(
                     sys, 'unraisablehook', sys.__unraisablehook__
                 ):
-                    expected = self.write_unraisable_exc(
-                        A.B.X(), "msg", "obj"
-                    )
+                    err_writeunraisable(A.B.X(), "obj")
                 report = stderr.getvalue()
                 self.assertIn(A.B.X.__qualname__, report)
                 if moduleName in ['builtins', '__main__']:
@@ -1250,34 +1479,45 @@ def test_original_unraisablehook_wrong_type(self):
                 sys.unraisablehook(exc)
 
     def test_custom_unraisablehook(self):
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable, err_formatunraisable
         hook_args = None
 
         def hook_func(args):
             nonlocal hook_args
             hook_args = args
 
-        obj = object()
+        obj = hex
         try:
             with test.support.swap_attr(sys, 'unraisablehook', hook_func):
-                expected = self.write_unraisable_exc(ValueError(42),
-                                                     "custom hook", obj)
-                for attr in "exc_type exc_value exc_traceback err_msg object".split():
-                    self.assertEqual(getattr(hook_args, attr),
-                                     getattr(expected, attr),
-                                     (hook_args, expected))
+                exc = ValueError(42)
+                err_writeunraisable(exc, obj)
+                self.assertIs(hook_args.exc_type, type(exc))
+                self.assertIs(hook_args.exc_value, exc)
+                self.assertIs(hook_args.exc_traceback, exc.__traceback__)
+                self.assertIsNone(hook_args.err_msg)
+                self.assertEqual(hook_args.object, obj)
+
+                err_formatunraisable(exc, "custom hook %R", obj)
+                self.assertIs(hook_args.exc_type, type(exc))
+                self.assertIs(hook_args.exc_value, exc)
+                self.assertIs(hook_args.exc_traceback, exc.__traceback__)
+                self.assertEqual(hook_args.err_msg, f'custom hook {obj!r}')
+                self.assertIsNone(hook_args.object)
         finally:
             # expected and hook_args contain an exception: break reference cycle
             expected = None
             hook_args = None
 
     def test_custom_unraisablehook_fail(self):
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable
         def hook_func(*args):
             raise Exception("hook_func failed")
 
         with test.support.captured_output("stderr") as stderr:
             with test.support.swap_attr(sys, 'unraisablehook', hook_func):
-                self.write_unraisable_exc(ValueError(42),
-                                          "custom hook fail", None)
+                err_writeunraisable(ValueError(42), "custom hook fail")
 
         err = stderr.getvalue()
         self.assertIn(f'Exception ignored in sys.unraisablehook: '
@@ -1293,8 +1533,9 @@ class SizeofTest(unittest.TestCase):
     def setUp(self):
         self.P = struct.calcsize('P')
         self.longdigit = sys.int_info.sizeof_digit
-        import _testinternalcapi
+        _testinternalcapi = import_helper.import_module("_testinternalcapi")
         self.gc_headsize = _testinternalcapi.SIZEOF_PYGC_HEAD
+        self.managed_pre_header_size = _testinternalcapi.SIZEOF_MANAGED_PRE_HEADER
 
     check_sizeof = test.support.check_sizeof
 
@@ -1330,7 +1571,7 @@ class OverflowSizeof(int):
             def __sizeof__(self):
                 return int(self)
         self.assertEqual(sys.getsizeof(OverflowSizeof(sys.maxsize)),
-                         sys.maxsize + self.gc_headsize)
+                         sys.maxsize + self.gc_headsize + self.managed_pre_header_size)
         with self.assertRaises(OverflowError):
             sys.getsizeof(OverflowSizeof(sys.maxsize + 1))
         with self.assertRaises(ValueError):
@@ -1452,10 +1693,10 @@ class C(object): pass
         def func():
             return sys._getframe()
         x = func()
-        check(x, size('3Pi3c7P2ic??2P'))
+        check(x, size('3Pi2c2P7P2ic??2P'))
         # function
         def func(): pass
-        check(func, size('14Pi'))
+        check(func, size('15Pi'))
         class c():
             @staticmethod
             def foo():
@@ -1469,7 +1710,7 @@ def bar(cls):
             check(bar, size('PP'))
         # generator
         def get_gen(): yield 1
-        check(get_gen(), size('P2P4P4c7P2ic??P'))
+        check(get_gen(), size('PP4P4c7P2ic??2P'))
         # iterator
         check(iter('abc'), size('lP'))
         # callable-iterator
@@ -1497,7 +1738,10 @@ def get_gen(): yield 1
         check(int(PyLong_BASE**2-1), vsize('') + 2*self.longdigit)
         check(int(PyLong_BASE**2), vsize('') + 3*self.longdigit)
         # module
-        check(unittest, size('PnPPP'))
+        if support.Py_GIL_DISABLED:
+            check(unittest, size('PPPPPP'))
+        else:
+            check(unittest, size('PPPPP'))
         # None
         check(None, size(''))
         # NotImplementedType
@@ -1512,9 +1756,10 @@ def delx(self): del self.__x
             x = property(getx, setx, delx, "")
             check(x, size('5Pi'))
         # PyCapsule
-        # XXX
+        check(_datetime.datetime_CAPI, size('6P'))
         # rangeiterator
-        check(iter(range(1)), size('4l'))
+        check(iter(range(1)), size('3l'))
+        check(iter(range(2**65)), size('3P'))
         # reverse
         check(reversed(''), size('nP'))
         # range
@@ -1551,8 +1796,8 @@ def delx(self): del self.__x
         check((1,2,3), vsize('') + 3*self.P)
         # type
         # static type: PyTypeObject
-        fmt = 'P2nPI13Pl4Pn9Pn12PIP'
-        s = vsize('2P' + fmt)
+        fmt = 'P2nPI13Pl4Pn9Pn12PIPc'
+        s = vsize(fmt)
         check(int, s)
         # class
         s = vsize(fmt +                 # PyTypeObject
@@ -1562,7 +1807,7 @@ def delx(self): del self.__x
                   '10P'                 # PySequenceMethods
                   '2P'                  # PyBufferProcs
                   '6P'
-                  '1P'                  # Specializer cache
+                  '1PIP'                 # Specializer cache
                   )
         class newstyleclass(object): pass
         # Separate block for PyDictKeysObject with 8 keys and 5 entries
@@ -1584,8 +1829,8 @@ class newstyleclass(object): pass
                    '\u0100'*40, '\uffff'*100,
                    '\U00010000'*30, '\U0010ffff'*100]
         # also update field definitions in test_unicode.test_raiseMemError
-        asciifields = "nnbP"
-        compactfields = asciifields + "nPn"
+        asciifields = "nnb"
+        compactfields = asciifields + "nP"
         unicodefields = compactfields + "P"
         for s in samples:
             maxchar = ord(max(s))
@@ -1609,11 +1854,15 @@ class newstyleclass(object): pass
         # TODO: add check that forces layout of unicodefields
         # weakref
         import weakref
-        check(weakref.ref(int), size('2Pn3P'))
+        if support.Py_GIL_DISABLED:
+            expected = size('2Pn4P')
+        else:
+            expected = size('2Pn3P')
+        check(weakref.ref(int), expected)
         # weakproxy
         # XXX
         # weakcallableproxy
-        check(weakref.proxy(int), size('2Pn3P'))
+        check(weakref.proxy(int), expected)
 
     def check_slots(self, obj, base, extra):
         expected = sys.getsizeof(base) + struct.calcsize(extra)
@@ -1655,15 +1904,16 @@ def test_pythontypes(self):
         check(_ast.AST(), size('P'))
         try:
             raise TypeError
-        except TypeError:
-            tb = sys.exc_info()[2]
+        except TypeError as e:
+            tb = e.__traceback__
             # traceback
             if tb is not None:
                 check(tb, size('2P2i'))
         # symtable entry
         # XXX
         # sys.flags
-        check(sys.flags, vsize('') + self.P * len(sys.flags))
+        # FIXME: The +1 will not be necessary once gh-122575 is fixed
+        check(sys.flags, vsize('') + self.P * (1 + len(sys.flags)))
 
     def test_asyncgen_hooks(self):
         old = sys.get_asyncgen_hooks()
@@ -1671,6 +1921,21 @@ def test_asyncgen_hooks(self):
         self.assertIsNone(old.finalizer)
 
         firstiter = lambda *a: None
+        finalizer = lambda *a: None
+
+        with self.assertRaises(TypeError):
+            sys.set_asyncgen_hooks(firstiter=firstiter, finalizer="invalid")
+        cur = sys.get_asyncgen_hooks()
+        self.assertIsNone(cur.firstiter)
+        self.assertIsNone(cur.finalizer)
+
+        # gh-118473
+        with self.assertRaises(TypeError):
+            sys.set_asyncgen_hooks(firstiter="invalid", finalizer=finalizer)
+        cur = sys.get_asyncgen_hooks()
+        self.assertIsNone(cur.firstiter)
+        self.assertIsNone(cur.finalizer)
+
         sys.set_asyncgen_hooks(firstiter=firstiter)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
@@ -1678,7 +1943,6 @@ def test_asyncgen_hooks(self):
         self.assertIs(hooks.finalizer, None)
         self.assertIs(hooks[1], None)
 
-        finalizer = lambda *a: None
         sys.set_asyncgen_hooks(finalizer=finalizer)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 30f126b3742..8295da9486d 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -53,7 +53,7 @@ mod sys {
     const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
 
     #[pyattr(name = "abiflags")]
-    pub(crate) const ABIFLAGS: &str = "";
+    pub(crate) const ABIFLAGS: &str = "t"; // 't' for free-threaded (no GIL)
     #[pyattr(name = "api_version")]
     const API_VERSION: u32 = 0x0; // what C api?
     #[pyattr(name = "copyright")]
@@ -599,6 +599,11 @@ mod sys {
         // TODO: sys.audit implementation
     }
 
+    #[pyfunction]
+    const fn _is_gil_enabled() -> bool {
+        false // RustPython has no GIL (like free-threaded Python)
+    }
+
     #[pyfunction]
     fn exit(code: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
         let code = code.unwrap_or_none(vm);
diff --git a/crates/vm/src/stdlib/sysconfigdata.rs b/crates/vm/src/stdlib/sysconfigdata.rs
index 5e954f7fe7a..99228024d2d 100644
--- a/crates/vm/src/stdlib/sysconfigdata.rs
+++ b/crates/vm/src/stdlib/sysconfigdata.rs
@@ -23,6 +23,8 @@ pub(crate) mod _sysconfigdata {
             "RUST_MULTIARCH" => RUST_MULTIARCH,
             // enough for tests to stop expecting urandom() to fail after restricting file resources
             "HAVE_GETRANDOM" => 1,
+            // RustPython has no GIL (like free-threaded Python)
+            "Py_GIL_DISABLED" => 1,
             // Compiler configuration for native extension builds
             "CC" => "cc",
             "CXX" => "c++",

From d3e2fa47ccca06cdf6372e343aceadcfbf79fcd2 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 18:50:34 +0900
Subject: [PATCH 149/418] Remove wrong Deref (#6620)

---
 crates/stdlib/src/array.rs             |   4 +-
 crates/stdlib/src/bisect.rs            |   2 +-
 crates/stdlib/src/cmath.rs             |  54 ++++++-------
 crates/stdlib/src/math.rs              | 106 +++++++++++++------------
 crates/stdlib/src/statistics.rs        |   2 +-
 crates/vm/src/buffer.rs                |   6 +-
 crates/vm/src/builtins/bytes.rs        |   2 +-
 crates/vm/src/builtins/mappingproxy.rs |   8 +-
 crates/vm/src/builtins/slice.rs        |   1 +
 crates/vm/src/function/number.rs       |  58 +++++++-------
 crates/vm/src/function/protocol.rs     |  15 ++--
 crates/vm/src/stdlib/builtins.rs       |   8 +-
 crates/vm/src/stdlib/itertools.rs      |   4 +-
 13 files changed, 141 insertions(+), 129 deletions(-)

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index b7a6fbd8b4f..4746882e462 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -565,11 +565,11 @@ mod array {
     }
 
     fn f32_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f32> {
-        ArgIntoFloat::try_from_object(vm, obj).map(|x| *x as f32)
+        ArgIntoFloat::try_from_object(vm, obj).map(|x| x.into_float() as f32)
     }
 
     fn f64_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f64> {
-        ArgIntoFloat::try_from_object(vm, obj).map(Into::into)
+        ArgIntoFloat::try_from_object(vm, obj).map(|x| x.into_float())
     }
 
     fn pyfloat_from_f32(value: f32) -> PyFloat {
diff --git a/crates/stdlib/src/bisect.rs b/crates/stdlib/src/bisect.rs
index 46e689ac068..e712d0275d2 100644
--- a/crates/stdlib/src/bisect.rs
+++ b/crates/stdlib/src/bisect.rs
@@ -24,7 +24,7 @@ mod _bisect {
     #[inline]
     fn handle_default(arg: OptionalArg<ArgIndex>, vm: &VirtualMachine) -> PyResult<Option<isize>> {
         arg.into_option()
-            .map(|v| v.try_to_primitive(vm))
+            .map(|v| v.into_int_ref().try_to_primitive(vm))
             .transpose()
     }
 
diff --git a/crates/stdlib/src/cmath.rs b/crates/stdlib/src/cmath.rs
index 7f975e41719..6ce471195cc 100644
--- a/crates/stdlib/src/cmath.rs
+++ b/crates/stdlib/src/cmath.rs
@@ -23,64 +23,64 @@ mod cmath {
 
     #[pyfunction]
     fn phase(z: ArgIntoComplex) -> f64 {
-        z.arg()
+        z.into_complex().arg()
     }
 
     #[pyfunction]
     fn polar(x: ArgIntoComplex) -> (f64, f64) {
-        x.to_polar()
+        x.into_complex().to_polar()
     }
 
     #[pyfunction]
     fn rect(r: ArgIntoFloat, phi: ArgIntoFloat) -> Complex64 {
-        Complex64::from_polar(*r, *phi)
+        Complex64::from_polar(r.into_float(), phi.into_float())
     }
 
     #[pyfunction]
     fn isinf(z: ArgIntoComplex) -> bool {
-        let Complex64 { re, im } = *z;
+        let Complex64 { re, im } = z.into_complex();
         re.is_infinite() || im.is_infinite()
     }
 
     #[pyfunction]
     fn isfinite(z: ArgIntoComplex) -> bool {
-        z.is_finite()
+        z.into_complex().is_finite()
     }
 
     #[pyfunction]
     fn isnan(z: ArgIntoComplex) -> bool {
-        z.is_nan()
+        z.into_complex().is_nan()
     }
 
     #[pyfunction]
     fn exp(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
-        let z = *z;
+        let z = z.into_complex();
         result_or_overflow(z, z.exp(), vm)
     }
 
     #[pyfunction]
     fn sqrt(z: ArgIntoComplex) -> Complex64 {
-        z.sqrt()
+        z.into_complex().sqrt()
     }
 
     #[pyfunction]
     fn sin(z: ArgIntoComplex) -> Complex64 {
-        z.sin()
+        z.into_complex().sin()
     }
 
     #[pyfunction]
     fn asin(z: ArgIntoComplex) -> Complex64 {
-        z.asin()
+        z.into_complex().asin()
     }
 
     #[pyfunction]
     fn cos(z: ArgIntoComplex) -> Complex64 {
-        z.cos()
+        z.into_complex().cos()
     }
 
     #[pyfunction]
     fn acos(z: ArgIntoComplex) -> Complex64 {
-        z.acos()
+        z.into_complex().acos()
     }
 
     #[pyfunction]
@@ -90,56 +90,56 @@ mod cmath {
         //       which returns NaN when base is negative.
         //       log10(z) / log10(base) yields correct results but division
         //       doesn't handle pos/neg zero nicely. (i.e log(1, 0.5))
-        z.log(
+        z.into_complex().log(
             base.into_option()
-                .map(|base| base.re)
+                .map(|base| base.into_complex().re)
                 .unwrap_or(core::f64::consts::E),
         )
     }
 
     #[pyfunction]
     fn log10(z: ArgIntoComplex) -> Complex64 {
-        z.log(10.0)
+        z.into_complex().log(10.0)
     }
 
     #[pyfunction]
     fn acosh(z: ArgIntoComplex) -> Complex64 {
-        z.acosh()
+        z.into_complex().acosh()
     }
 
     #[pyfunction]
     fn atan(z: ArgIntoComplex) -> Complex64 {
-        z.atan()
+        z.into_complex().atan()
     }
 
     #[pyfunction]
     fn atanh(z: ArgIntoComplex) -> Complex64 {
-        z.atanh()
+        z.into_complex().atanh()
     }
 
     #[pyfunction]
     fn tan(z: ArgIntoComplex) -> Complex64 {
-        z.tan()
+        z.into_complex().tan()
     }
 
     #[pyfunction]
     fn tanh(z: ArgIntoComplex) -> Complex64 {
-        z.tanh()
+        z.into_complex().tanh()
     }
 
     #[pyfunction]
     fn sinh(z: ArgIntoComplex) -> Complex64 {
-        z.sinh()
+        z.into_complex().sinh()
     }
 
     #[pyfunction]
     fn cosh(z: ArgIntoComplex) -> Complex64 {
-        z.cosh()
+        z.into_complex().cosh()
     }
 
     #[pyfunction]
     fn asinh(z: ArgIntoComplex) -> Complex64 {
-        z.asinh()
+        z.into_complex().asinh()
     }
 
     #[derive(FromArgs)]
@@ -156,10 +156,10 @@ mod cmath {
 
     #[pyfunction]
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
-        let a = *args.a;
-        let b = *args.b;
-        let rel_tol = args.rel_tol.map_or(1e-09, Into::into);
-        let abs_tol = args.abs_tol.map_or(0.0, Into::into);
+        let a = args.a.into_complex();
+        let b = args.b.into_complex();
+        let rel_tol = args.rel_tol.map_or(1e-09, |v| v.into_float());
+        let abs_tol = args.abs_tol.map_or(0.0, |v| v.into_float());
 
         if rel_tol < 0.0 || abs_tol < 0.0 {
             return Err(vm.new_value_error("tolerances must be non-negative"));
diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
index 6e139530804..fb8945c74f7 100644
--- a/crates/stdlib/src/math.rs
+++ b/crates/stdlib/src/math.rs
@@ -29,7 +29,7 @@ mod math {
     // Helper macro:
     macro_rules! call_math_func {
         ( $fun:ident, $name:ident, $vm:ident ) => {{
-            let value = *$name;
+            let value = $name.into_float();
             let result = value.$fun();
             result_or_overflow(value, result, $vm)
         }};
@@ -54,17 +54,17 @@ mod math {
 
     #[pyfunction]
     fn isfinite(x: ArgIntoFloat) -> bool {
-        x.is_finite()
+        x.into_float().is_finite()
     }
 
     #[pyfunction]
     fn isinf(x: ArgIntoFloat) -> bool {
-        x.is_infinite()
+        x.into_float().is_infinite()
     }
 
     #[pyfunction]
     fn isnan(x: ArgIntoFloat) -> bool {
-        x.is_nan()
+        x.into_float().is_nan()
     }
 
     #[derive(FromArgs)]
@@ -81,10 +81,10 @@ mod math {
 
     #[pyfunction]
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
-        let a = *args.a;
-        let b = *args.b;
-        let rel_tol = args.rel_tol.map_or(1e-09, |value| value.into());
-        let abs_tol = args.abs_tol.map_or(0.0, |value| value.into());
+        let a = args.a.into_float();
+        let b = args.b.into_float();
+        let rel_tol = args.rel_tol.map_or(1e-09, |v| v.into_float());
+        let abs_tol = args.abs_tol.map_or(0.0, |v| v.into_float());
 
         if rel_tol < 0.0 || abs_tol < 0.0 {
             return Err(vm.new_value_error("tolerances must be non-negative"));
@@ -115,7 +115,7 @@ mod math {
 
     #[pyfunction]
     fn copysign(x: ArgIntoFloat, y: ArgIntoFloat) -> f64 {
-        x.copysign(*y)
+        x.into_float().copysign(y.into_float())
     }
 
     // Power and logarithmic functions:
@@ -136,7 +136,7 @@ mod math {
 
     #[pyfunction]
     fn log(x: PyObjectRef, base: OptionalArg<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let base = base.map(|b| *b).unwrap_or(core::f64::consts::E);
+        let base: f64 = base.map(Into::into).unwrap_or(core::f64::consts::E);
         if base.is_sign_negative() {
             return Err(vm.new_value_error("math domain error"));
         }
@@ -145,7 +145,7 @@ mod math {
 
     #[pyfunction]
     fn log1p(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
+        let x = x.into_float();
         if x.is_nan() || x > -1.0_f64 {
             Ok(x.ln_1p())
         } else {
@@ -197,8 +197,8 @@ mod math {
 
     #[pyfunction]
     fn pow(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
+        let x = x.into_float();
+        let y = y.into_float();
 
         if x < 0.0 && x.is_finite() && y.fract() != 0.0 && y.is_finite()
             || x == 0.0 && y < 0.0 && y != f64::NEG_INFINITY
@@ -217,7 +217,7 @@ mod math {
 
     #[pyfunction]
     fn sqrt(value: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let value = *value;
+        let value = value.into_float();
         if value.is_nan() {
             return Ok(value);
         }
@@ -232,6 +232,7 @@ mod math {
 
     #[pyfunction]
     fn isqrt(x: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let x = x.into_int_ref();
         let value = x.as_bigint();
 
         if value.is_negative() {
@@ -243,7 +244,7 @@ mod math {
     // Trigonometric functions:
     #[pyfunction]
     fn acos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
+        let x = x.into_float();
         if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
             Ok(x.acos())
         } else {
@@ -253,7 +254,7 @@ mod math {
 
     #[pyfunction]
     fn asin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
+        let x = x.into_float();
         if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
             Ok(x.asin())
         } else {
@@ -268,15 +269,16 @@ mod math {
 
     #[pyfunction]
     fn atan2(y: ArgIntoFloat, x: ArgIntoFloat) -> f64 {
-        y.atan2(*x)
+        y.into_float().atan2(x.into())
     }
 
     #[pyfunction]
     fn cos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let x = x.into_float();
         if x.is_infinite() {
             return Err(vm.new_value_error("math domain error"));
         }
-        call_math_func!(cos, x, vm)
+        result_or_overflow(x, x.cos(), vm)
     }
 
     #[pyfunction]
@@ -408,35 +410,37 @@ mod math {
 
     #[pyfunction]
     fn sin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let x = x.into_float();
         if x.is_infinite() {
             return Err(vm.new_value_error("math domain error"));
         }
-        call_math_func!(sin, x, vm)
+        result_or_overflow(x, x.sin(), vm)
     }
 
     #[pyfunction]
     fn tan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let x = x.into_float();
         if x.is_infinite() {
             return Err(vm.new_value_error("math domain error"));
         }
-        call_math_func!(tan, x, vm)
+        result_or_overflow(x, x.tan(), vm)
     }
 
     #[pyfunction]
     fn degrees(x: ArgIntoFloat) -> f64 {
-        *x * (180.0 / core::f64::consts::PI)
+        x.into_float() * (180.0 / core::f64::consts::PI)
     }
 
     #[pyfunction]
     fn radians(x: ArgIntoFloat) -> f64 {
-        *x * (core::f64::consts::PI / 180.0)
+        x.into_float() * (core::f64::consts::PI / 180.0)
     }
 
     // Hyperbolic functions:
 
     #[pyfunction]
     fn acosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
+        let x = x.into_float();
         if x.is_sign_negative() || x.is_zero() {
             Err(vm.new_value_error("math domain error"))
         } else {
@@ -451,7 +455,7 @@ mod math {
 
     #[pyfunction]
     fn atanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
+        let x = x.into_float();
         if x >= 1.0_f64 || x <= -1.0_f64 {
             Err(vm.new_value_error("math domain error"))
         } else {
@@ -477,22 +481,22 @@ mod math {
     // Special functions:
     #[pyfunction]
     fn erf(x: ArgIntoFloat) -> f64 {
-        pymath::erf(*x)
+        pymath::erf(x.into())
     }
 
     #[pyfunction]
     fn erfc(x: ArgIntoFloat) -> f64 {
-        pymath::erfc(*x)
+        pymath::erfc(x.into())
     }
 
     #[pyfunction]
     fn gamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::gamma(*x).map_err(|err| pymath_error_to_exception(err, vm))
+        pymath::gamma(x.into()).map_err(|err| pymath_error_to_exception(err, vm))
     }
 
     #[pyfunction]
     fn lgamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::lgamma(*x).map_err(|err| pymath_error_to_exception(err, vm))
+        pymath::lgamma(x.into()).map_err(|err| pymath_error_to_exception(err, vm))
     }
 
     fn try_magic_method(
@@ -541,7 +545,7 @@ mod math {
 
     #[pyfunction]
     fn frexp(x: ArgIntoFloat) -> (f64, i32) {
-        let value = *x;
+        let value: f64 = x.into();
         if value.is_finite() {
             let (m, exp) = float_ops::decompose_float(value);
             (m * value.signum(), exp)
@@ -641,12 +645,12 @@ mod math {
         if arg_vec.is_empty() {
             return default;
         } else if arg_vec.len() == 1 {
-            return op(arg_vec[0].as_bigint(), &arg_vec[0]);
+            return op(arg_vec[0].as_ref().as_bigint(), arg_vec[0].as_ref());
         }
 
-        let mut res = arg_vec[0].as_bigint().clone();
+        let mut res = arg_vec[0].as_ref().as_bigint().clone();
         for num in &arg_vec[1..] {
-            res = op(&res, num)
+            res = op(&res, num.as_ref())
         }
         res
     }
@@ -665,7 +669,7 @@ mod math {
 
     #[pyfunction]
     fn cbrt(x: ArgIntoFloat) -> f64 {
-        x.cbrt()
+        x.into_float().cbrt()
     }
 
     #[pyfunction]
@@ -675,7 +679,7 @@ mod math {
         let mut inf_sum = 0.0;
 
         for obj in seq.iter(vm)? {
-            let mut x = *obj?;
+            let mut x = obj?.into_float();
 
             let xsave = x;
             let mut i = 0;
@@ -790,11 +794,12 @@ mod math {
         k: OptionalArg<Option<ArgIndex>>,
         vm: &VirtualMachine,
     ) -> PyResult<BigInt> {
+        let n = n.into_int_ref();
         let n = n.as_bigint();
         let k_ref;
         let v = match k.flatten() {
             Some(k) => {
-                k_ref = k;
+                k_ref = k.into_int_ref();
                 k_ref.as_bigint()
             }
             None => n,
@@ -818,7 +823,9 @@ mod math {
 
     #[pyfunction]
     fn comb(n: ArgIndex, k: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let k = k.into_int_ref();
         let mut k = k.as_bigint();
+        let n = n.into_int_ref();
         let n = n.as_bigint();
         let one = BigInt::one();
         let zero = BigInt::zero();
@@ -856,7 +863,7 @@ mod math {
 
     #[pyfunction]
     fn modf(x: ArgIntoFloat) -> (f64, f64) {
-        let x = *x;
+        let x = x.into_float();
         if !x.is_finite() {
             if x.is_infinite() {
                 return (0.0_f64.copysign(x), x);
@@ -882,27 +889,25 @@ mod math {
     fn nextafter(arg: NextAfterArgs, vm: &VirtualMachine) -> PyResult<f64> {
         let steps: Option<i64> = arg
             .steps
-            .map(|v| v.try_to_primitive(vm))
+            .map(|v| v.into_int_ref().try_to_primitive(vm))
             .transpose()?
             .into_option();
+        let x: f64 = arg.x.into();
+        let y: f64 = arg.y.into();
         match steps {
             Some(steps) => {
                 if steps < 0 {
                     return Err(vm.new_value_error("steps must be a non-negative integer"));
                 }
-                Ok(float_ops::nextafter_with_steps(
-                    *arg.x,
-                    *arg.y,
-                    steps as u64,
-                ))
+                Ok(float_ops::nextafter_with_steps(x, y, steps as u64))
             }
-            None => Ok(float_ops::nextafter(*arg.x, *arg.y)),
+            None => Ok(float_ops::nextafter(x, y)),
         }
     }
 
     #[pyfunction]
     fn ulp(x: ArgIntoFloat) -> f64 {
-        float_ops::ulp(*x)
+        float_ops::ulp(x.into())
     }
 
     fn fmod(x: f64, y: f64) -> f64 {
@@ -915,8 +920,8 @@ mod math {
 
     #[pyfunction(name = "fmod")]
     fn py_fmod(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
+        let x = x.into_float();
+        let y = y.into_float();
 
         let r = fmod(x, y);
 
@@ -929,8 +934,8 @@ mod math {
 
     #[pyfunction]
     fn remainder(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
+        let x = x.into_float();
+        let y = y.into_float();
 
         if x.is_finite() && y.is_finite() {
             if y == 0.0 {
@@ -1025,7 +1030,10 @@ mod math {
         z: ArgIntoFloat,
         vm: &VirtualMachine,
     ) -> PyResult<f64> {
-        let result = (*x).mul_add(*y, *z);
+        let x = x.into_float();
+        let y = y.into_float();
+        let z = z.into_float();
+        let result = x.mul_add(y, z);
 
         if result.is_finite() {
             return Ok(result);
diff --git a/crates/stdlib/src/statistics.rs b/crates/stdlib/src/statistics.rs
index 9f5b294c009..8be2447ffd6 100644
--- a/crates/stdlib/src/statistics.rs
+++ b/crates/stdlib/src/statistics.rs
@@ -126,7 +126,7 @@ mod _statistics {
         sigma: ArgIntoFloat,
         vm: &VirtualMachine,
     ) -> PyResult<f64> {
-        normal_dist_inv_cdf(*p, *mu, *sigma)
+        normal_dist_inv_cdf(p.into_float(), mu.into_float(), sigma.into_float())
             .ok_or_else(|| vm.new_value_error("inv_cdf undefined for these parameters"))
     }
 }
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
index 3d5e48015ea..6cbddb7333b 100644
--- a/crates/vm/src/buffer.rs
+++ b/crates/vm/src/buffer.rs
@@ -603,7 +603,7 @@ macro_rules! make_pack_float {
                 arg: PyObjectRef,
                 data: &mut [u8],
             ) -> PyResult<()> {
-                let f = *ArgIntoFloat::try_from_object(vm, arg)? as $T;
+                let f = ArgIntoFloat::try_from_object(vm, arg)?.into_float() as $T;
                 f.to_bits().pack_int::<E>(data);
                 Ok(())
             }
@@ -621,7 +621,7 @@ make_pack_float!(f64);
 
 impl Packable for f16 {
     fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        let f_64 = *ArgIntoFloat::try_from_object(vm, arg)?;
+        let f_64 = ArgIntoFloat::try_from_object(vm, arg)?.into_float();
         // "from_f64 should be preferred in any non-`const` context" except it gives the wrong result :/
         let f_16 = Self::from_f64_const(f_64);
         if f_16.is_infinite() != f_64.is_infinite() {
@@ -649,7 +649,7 @@ impl Packable for *mut raw::c_void {
 
 impl Packable for bool {
     fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        let v = *ArgIntoBool::try_from_object(vm, arg)? as u8;
+        let v = ArgIntoBool::try_from_object(vm, arg)?.into_bool() as u8;
         v.pack_int::<E>(data);
         Ok(())
     }
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 7e5b98b1ece..df1acedfd63 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -515,7 +515,7 @@ impl PyBytes {
     #[pymethod(name = "__rmul__")]
     #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgIndex, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.repeat(value.try_to_primitive(vm)?, vm)
+        zelf.repeat(value.into_int_ref().try_to_primitive(vm)?, vm)
     }
 
     #[pymethod(name = "__mod__")]
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index 34a598b03e0..ed4e6367b66 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -122,7 +122,9 @@ impl PyMappingProxy {
             MappingProxyInner::Class(class) => Ok(key
                 .as_interned_str(vm)
                 .is_some_and(|key| class.attributes.read().contains_key(key))),
-            MappingProxyInner::Mapping(mapping) => mapping.sequence_unchecked().contains(key, vm),
+            MappingProxyInner::Mapping(mapping) => {
+                mapping.obj().sequence_unchecked().contains(key, vm)
+            }
         }
     }
 
@@ -161,7 +163,9 @@ impl PyMappingProxy {
     #[pymethod]
     pub fn copy(&self, vm: &VirtualMachine) -> PyResult {
         match &self.mapping {
-            MappingProxyInner::Mapping(d) => vm.call_method(d, identifier!(vm, copy).as_str(), ()),
+            MappingProxyInner::Mapping(d) => {
+                vm.call_method(d.obj(), identifier!(vm, copy).as_str(), ())
+            }
             MappingProxyInner::Class(c) => {
                 Ok(PyDict::from_attributes(c.attributes.read().clone(), vm)?.to_pyobject(vm))
             }
diff --git a/crates/vm/src/builtins/slice.rs b/crates/vm/src/builtins/slice.rs
index 09a6c462ed5..3aa23b0746c 100644
--- a/crates/vm/src/builtins/slice.rs
+++ b/crates/vm/src/builtins/slice.rs
@@ -174,6 +174,7 @@ impl PySlice {
 
     #[pymethod]
     fn indices(&self, length: ArgIndex, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let length = length.into_int_ref();
         let length = length.as_bigint();
         if length.is_negative() {
             return Err(vm.new_value_error("length should not be negative."));
diff --git a/crates/vm/src/function/number.rs b/crates/vm/src/function/number.rs
index fb872cc48fd..b53208bcd93 100644
--- a/crates/vm/src/function/number.rs
+++ b/crates/vm/src/function/number.rs
@@ -20,17 +20,16 @@ pub struct ArgIntoComplex {
     value: Complex64,
 }
 
-impl From<ArgIntoComplex> for Complex64 {
-    fn from(arg: ArgIntoComplex) -> Self {
-        arg.value
+impl ArgIntoComplex {
+    #[inline]
+    pub fn into_complex(self) -> Complex64 {
+        self.value
     }
 }
 
-impl Deref for ArgIntoComplex {
-    type Target = Complex64;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
+impl From<ArgIntoComplex> for Complex64 {
+    fn from(arg: ArgIntoComplex) -> Self {
+        arg.value
     }
 }
 
@@ -60,6 +59,11 @@ pub struct ArgIntoFloat {
 }
 
 impl ArgIntoFloat {
+    #[inline]
+    pub fn into_float(self) -> f64 {
+        self.value
+    }
+
     pub fn vec_into_f64(v: Vec<Self>) -> Vec<f64> {
         // TODO: Vec::into_raw_parts once stabilized
         let mut v = core::mem::ManuallyDrop::new(v);
@@ -75,13 +79,6 @@ impl From<ArgIntoFloat> for f64 {
     }
 }
 
-impl Deref for ArgIntoFloat {
-    type Target = f64;
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
 impl TryFromObject for ArgIntoFloat {
     // Equivalent to PyFloat_AsDouble.
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
@@ -106,6 +103,11 @@ pub struct ArgIntoBool {
 impl ArgIntoBool {
     pub const TRUE: Self = Self { value: true };
     pub const FALSE: Self = Self { value: false };
+
+    #[inline]
+    pub fn into_bool(self) -> bool {
+        self.value
+    }
 }
 
 impl From<ArgIntoBool> for bool {
@@ -114,13 +116,6 @@ impl From<ArgIntoBool> for bool {
     }
 }
 
-impl Deref for ArgIntoBool {
-    type Target = bool;
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
 impl TryFromObject for ArgIntoBool {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         Ok(Self {
@@ -136,20 +131,25 @@ pub struct ArgIndex {
     value: PyIntRef,
 }
 
-impl From<ArgIndex> for PyIntRef {
-    fn from(arg: ArgIndex) -> Self {
-        arg.value
+impl ArgIndex {
+    #[inline]
+    pub fn into_int_ref(self) -> PyIntRef {
+        self.value
     }
 }
 
-impl Deref for ArgIndex {
-    type Target = PyIntRef;
-
-    fn deref(&self) -> &Self::Target {
+impl AsRef<PyIntRef> for ArgIndex {
+    fn as_ref(&self) -> &PyIntRef {
         &self.value
     }
 }
 
+impl From<ArgIndex> for PyIntRef {
+    fn from(arg: ArgIndex) -> Self {
+        arg.value
+    }
+}
+
 impl TryFromObject for ArgIndex {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         Ok(Self {
diff --git a/crates/vm/src/function/protocol.rs b/crates/vm/src/function/protocol.rs
index 94bdd3027eb..402f6d0365b 100644
--- a/crates/vm/src/function/protocol.rs
+++ b/crates/vm/src/function/protocol.rs
@@ -7,7 +7,7 @@ use crate::{
     protocol::{PyIter, PyIterIter, PyMapping},
     types::GenericMethod,
 };
-use core::{borrow::Borrow, marker::PhantomData, ops::Deref};
+use core::{borrow::Borrow, marker::PhantomData};
 
 #[derive(Clone, Traverse)]
 pub struct ArgCallable {
@@ -133,6 +133,11 @@ impl ArgMapping {
         Self { obj: dict.into() }
     }
 
+    #[inline(always)]
+    pub fn obj(&self) -> &PyObject {
+        &self.obj
+    }
+
     #[inline(always)]
     pub fn mapping(&self) -> PyMapping<'_> {
         self.obj.mapping_unchecked()
@@ -153,14 +158,6 @@ impl AsRef<PyObject> for ArgMapping {
     }
 }
 
-impl Deref for ArgMapping {
-    type Target = PyObject;
-    #[inline(always)]
-    fn deref(&self) -> &PyObject {
-        &self.obj
-    }
-}
-
 impl From<ArgMapping> for PyObjectRef {
     #[inline(always)]
     fn from(value: ArgMapping) -> Self {
diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
index c82161fc553..b4554bc30aa 100644
--- a/crates/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -45,7 +45,7 @@ mod builtins {
     #[pyfunction]
     fn all(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if !*item? {
+            if !item?.into_bool() {
                 return Ok(false);
             }
         }
@@ -55,7 +55,7 @@ mod builtins {
     #[pyfunction]
     fn any(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if *item? {
+            if item?.into_bool() {
                 return Ok(true);
             }
         }
@@ -451,6 +451,7 @@ mod builtins {
 
     #[pyfunction]
     fn hex(number: ArgIndex) -> String {
+        let number = number.into_int_ref();
         let n = number.as_bigint();
         format!("{n:#x}")
     }
@@ -687,6 +688,7 @@ mod builtins {
 
     #[pyfunction]
     fn oct(number: ArgIndex, vm: &VirtualMachine) -> PyResult {
+        let number = number.into_int_ref();
         let n = number.as_bigint();
         let s = if n.is_negative() {
             format!("-0o{:o}", n.abs())
@@ -786,7 +788,7 @@ mod builtins {
             .unwrap_or_else(|| PyStr::from("\n").into_ref(&vm.ctx));
         write(end)?;
 
-        if *options.flush {
+        if options.flush.into() {
             vm.call_method(&file, "flush", ())?;
         }
 
diff --git a/crates/vm/src/stdlib/itertools.rs b/crates/vm/src/stdlib/itertools.rs
index 3aad2f91931..1eedbde7a22 100644
--- a/crates/vm/src/stdlib/itertools.rs
+++ b/crates/vm/src/stdlib/itertools.rs
@@ -561,7 +561,7 @@ mod decl {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.stop_flag.store(*obj);
+                zelf.stop_flag.store(obj.into_bool());
             }
             Ok(())
         }
@@ -648,7 +648,7 @@ mod decl {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.start_flag.store(*obj);
+                zelf.start_flag.store(obj.into_bool());
             }
             Ok(())
         }

From b19312b403ab3a6fbf73e32d5d2e8e54b79cd89e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 1 Jan 2026 22:39:16 +0900
Subject: [PATCH 150/418] slot for numeric ops (#6619)

* fix sequence_repeat wrappers

* slot for numeric ops

* fix bpo-37619
---
 crates/stdlib/src/array.rs               |  5 ---
 crates/vm/src/builtins/bytearray.rs      | 15 +------
 crates/vm/src/builtins/bytes.rs          | 13 +-----
 crates/vm/src/builtins/descriptor.rs     | 15 +++++--
 crates/vm/src/builtins/dict.rs           | 11 -----
 crates/vm/src/builtins/genericalias.rs   |  2 -
 crates/vm/src/builtins/list.rs           |  5 ---
 crates/vm/src/builtins/mappingproxy.rs   |  3 --
 crates/vm/src/builtins/str.rs            | 13 +-----
 crates/vm/src/builtins/tuple.rs          |  3 --
 crates/vm/src/builtins/type.rs           |  2 -
 crates/vm/src/builtins/union.rs          |  2 -
 crates/vm/src/stdlib/collections.rs      |  4 --
 crates/vm/src/stdlib/ctypes/pointer.rs   |  1 -
 crates/vm/src/stdlib/ctypes/simple.rs    |  1 -
 crates/vm/src/stdlib/ctypes/structure.rs |  1 -
 crates/vm/src/types/slot.rs              | 54 ++++++++++++++++++------
 17 files changed, 60 insertions(+), 90 deletions(-)

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 4746882e462..878a6ce8fb7 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -1060,7 +1060,6 @@ mod array {
             self.delitem_inner(&needle, vm)
         }
 
-        #[pymethod]
         fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             if let Some(other) = other.downcast_ref::<Self>() {
                 self.read()
@@ -1074,7 +1073,6 @@ mod array {
             }
         }
 
-        #[pymethod]
         fn __iadd__(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -1093,15 +1091,12 @@ mod array {
             Ok(zelf)
         }
 
-        #[pymethod(name = "__rmul__")]
-        #[pymethod]
         fn __mul__(&self, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             self.read()
                 .mul(value, vm)
                 .map(|x| Self::from(x).into_ref(&vm.ctx))
         }
 
-        #[pymethod]
         fn __imul__(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             zelf.try_resizable(vm)?.imul(value, vm)?;
             Ok(zelf)
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index dc5ee100acf..d3f1b0bd4e8 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -215,7 +215,6 @@ impl PyByteArray {
         size_of::<Self>() + self.borrow_buf().len() * size_of::<u8>()
     }
 
-    #[pymethod]
     fn __add__(&self, other: ArgBytesLike) -> Self {
         self.inner().add(&other.borrow_buf()).into()
     }
@@ -229,7 +228,6 @@ impl PyByteArray {
         self.inner().contains(needle, vm)
     }
 
-    #[pymethod]
     fn __iadd__(
         zelf: PyRef<Self>,
         other: ArgBytesLike,
@@ -524,29 +522,20 @@ impl PyByteArray {
         self.inner().title().into()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(&self, value: ArgSize, vm: &VirtualMachine) -> PyResult<Self> {
         self.repeat(value.into(), vm)
     }
 
-    #[pymethod]
     fn __imul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::irepeat(&zelf, value.into(), vm)?;
         Ok(zelf)
     }
 
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         let formatted = self.inner().cformat(values, vm)?;
         Ok(formatted.into())
     }
 
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
     #[pymethod]
     fn reverse(&self) {
         self.borrow_buf_mut().reverse();
@@ -822,7 +811,7 @@ impl AsNumber for PyByteArray {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyByteArray>() {
-                    a.mod_(b.to_owned(), vm).to_pyresult(vm)
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index df1acedfd63..537a618be3b 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -224,7 +224,6 @@ impl PyBytes {
         size_of::<Self>() + self.len() * size_of::<u8>()
     }
 
-    #[pymethod]
     fn __add__(&self, other: ArgBytesLike) -> Vec<u8> {
         self.inner.add(&other.borrow_buf())
     }
@@ -512,23 +511,15 @@ impl PyBytes {
         self.inner.title().into()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgIndex, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.repeat(value.into_int_ref().try_to_primitive(vm)?, vm)
     }
 
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         let formatted = self.inner.cformat(values, vm)?;
         Ok(formatted.into())
     }
 
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
     #[pymethod]
     fn __getnewargs__(&self, vm: &VirtualMachine) -> PyTupleRef {
         let param: Vec<PyObjectRef> = self.elements().map(|x| x.to_pyobject(vm)).collect();
@@ -677,7 +668,7 @@ impl AsNumber for PyBytes {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyBytes>() {
-                    a.mod_(b.to_owned(), vm).to_pyresult(vm)
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index aa9da6e2d44..a9218c8d689 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -5,7 +5,7 @@ use crate::{
     class::PyClassImpl,
     common::hash::PyHash,
     convert::{ToPyObject, ToPyResult},
-    function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
+    function::{ArgSize, FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
     protocol::{PyNumberBinaryFunc, PyNumberTernaryFunc, PyNumberUnaryFunc},
     types::{
         Callable, Comparable, DelFunc, DescrGetFunc, DescrSetFunc, GenericMethod, GetDescriptor,
@@ -593,8 +593,8 @@ impl SlotFunc {
                 func(obj.sequence_unchecked(), &other, vm)
             }
             SlotFunc::SeqRepeat(func) => {
-                let (n,): (isize,) = args.bind(vm)?;
-                func(obj.sequence_unchecked(), n, vm)
+                let (n,): (ArgSize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), n.into(), vm)
             }
             SlotFunc::SeqItem(func) => {
                 let (index,): (isize,) = args.bind(vm)?;
@@ -774,6 +774,15 @@ impl Callable for PyMethodWrapper {
     type Args = FuncArgs;
 
     fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // bpo-37619: Check type compatibility before calling wrapped slot
+        if !zelf.obj.fast_isinstance(zelf.wrapper.typ) {
+            return Err(vm.new_type_error(format!(
+                "descriptor '{}' requires a '{}' object but received a '{}'",
+                zelf.wrapper.name.as_str(),
+                zelf.wrapper.typ.name(),
+                zelf.obj.class().name()
+            )));
+        }
         zelf.wrapper.wrapped.call(zelf.obj.clone(), args, vm)
     }
 }
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 693505b1f82..41f6779c212 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -293,7 +293,6 @@ impl PyDict {
         Ok(())
     }
 
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let other_dict: Result<PyDictRef, _> = other.downcast();
         if let Ok(other) = other_dict {
@@ -403,13 +402,11 @@ impl PyRef<PyDict> {
         PyDictReverseKeyIterator::new(self)
     }
 
-    #[pymethod]
     fn __ior__(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         self.merge_object(other, vm)?;
         Ok(self)
     }
 
-    #[pymethod]
     fn __ror__(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let other_dict: Result<Self, _> = other.downcast();
         if let Ok(other) = other_dict {
@@ -1046,38 +1043,30 @@ trait ViewSetOps: DictView {
         PySetInner::from_iter(iter, vm)
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.symmetric_difference(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.intersection(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.union(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod]
     fn __sub__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.difference(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod]
     fn __rsub__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let left = PySetInner::from_iter(other.iter(vm)?, vm)?;
         let right = ArgIterable::try_from_object(vm, Self::iter(zelf, vm)?)?;
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index 5596aca9da2..99c1eacc3ec 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -236,12 +236,10 @@ impl PyGenericAlias {
         Err(vm.new_type_error("issubclass() argument 2 cannot be a parameterized generic"))
     }
 
-    #[pymethod]
     fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         type_::or_(other, zelf, vm)
     }
 
-    #[pymethod]
     fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         type_::or_(zelf, other, vm)
     }
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 52df0756498..514b38b6c28 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -145,7 +145,6 @@ impl PyList {
         Ok(Self::from(elements).into_ref(&vm.ctx))
     }
 
-    #[pymethod]
     fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         self.concat(&other, vm)
     }
@@ -160,7 +159,6 @@ impl PyList {
         Ok(zelf.to_owned().into())
     }
 
-    #[pymethod]
     fn __iadd__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -240,13 +238,10 @@ impl PyList {
         self._setitem(&needle, value, vm)
     }
 
-    #[pymethod]
-    #[pymethod(name = "__rmul__")]
     fn __mul__(&self, n: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         self.repeat(n.into(), vm)
     }
 
-    #[pymethod]
     fn __imul__(zelf: PyRef<Self>, n: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::irepeat(zelf, n.into(), vm)
     }
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index ed4e6367b66..13b0fa32490 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -191,7 +191,6 @@ impl PyMappingProxy {
         )
     }
 
-    #[pymethod]
     fn __ior__(&self, _args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         Err(vm.new_type_error(format!(
             r#""'|=' is not supported by {}; use '|' instead""#,
@@ -199,8 +198,6 @@ impl PyMappingProxy {
         )))
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         vm._or(self.copy(vm)?.as_ref(), args.as_ref())
     }
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 0357e81b365..e101ef2a52b 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -541,7 +541,6 @@ impl Py<PyStr> {
     )
 )]
 impl PyStr {
-    #[pymethod]
     fn __add__(zelf: PyRef<Self>, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         if let Some(other) = other.downcast_ref::<Self>() {
             let bytes = zelf.as_wtf8().py_add(other.as_wtf8());
@@ -636,8 +635,6 @@ impl PyStr {
         core::mem::size_of::<Self>() + self.byte_len() * core::mem::size_of::<u8>()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::repeat(zelf, value.into(), vm)
     }
@@ -947,16 +944,10 @@ impl PyStr {
             && self.char_all(|c| GeneralCategory::of(c) == GeneralCategory::DecimalNumber)
     }
 
-    #[pymethod(name = "__mod__")]
-    fn modulo(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         cformat_string(vm, self.as_wtf8(), values)
     }
 
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
     #[pymethod]
     fn format(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
         let format_str =
@@ -1564,7 +1555,7 @@ impl AsNumber for PyStr {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyStr>() {
-                    a.modulo(b.to_owned(), vm).to_pyresult(vm)
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index 910b0c8a204..f3da8b26163 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -263,7 +263,6 @@ impl<T> PyTuple<PyRef<T>> {
     with(AsMapping, AsNumber, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
 )]
 impl PyTuple {
-    #[pymethod]
     fn __add__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -302,8 +301,6 @@ impl PyTuple {
         self.elements.len()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::repeat(zelf, value.into(), vm)
     }
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 178131c96d6..e2e69c7bffc 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -951,12 +951,10 @@ impl PyType {
         )
     }
 
-    #[pymethod]
     pub fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         or_(other, zelf, vm)
     }
 
-    #[pymethod]
     pub fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         or_(zelf, other, vm)
     }
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index 0342442b83d..b5e12dcb3c8 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -136,8 +136,6 @@ impl PyUnion {
         }
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         type_::or_(zelf, other, vm)
     }
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 9b7a78f7237..4688121c9b5 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -332,8 +332,6 @@ mod _collections {
             Ok(deque)
         }
 
-        #[pymethod]
-        #[pymethod(name = "__rmul__")]
         fn __mul__(&self, n: isize, vm: &VirtualMachine) -> PyResult<Self> {
             let deque = self._mul(n, vm)?;
             Ok(Self {
@@ -343,7 +341,6 @@ mod _collections {
             })
         }
 
-        #[pymethod]
         fn __imul__(zelf: PyRef<Self>, n: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             let mul_deque = zelf._mul(n, vm)?;
             *zelf.borrow_deque_mut() = mul_deque;
@@ -379,7 +376,6 @@ mod _collections {
             }
         }
 
-        #[pymethod]
         fn __iadd__(
             zelf: PyRef<Self>,
             other: PyObjectRef,
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index aad21f8fe45..4f935945e88 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -137,7 +137,6 @@ impl PyCPointerType {
         )))
     }
 
-    #[pymethod]
     fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
         use super::array::array_type_from_ctype;
 
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index 17d3aa17ad1..de13dab2202 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -488,7 +488,6 @@ impl PyCSimpleType {
         }
     }
 
-    #[pymethod]
     fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
         PyCSimple::repeat(cls, n, vm)
     }
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
index 732f3c66801..cd36ce85560 100644
--- a/crates/vm/src/stdlib/ctypes/structure.rs
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -393,7 +393,6 @@ impl PyCStructType {
         Ok(())
     }
 
-    #[pymethod]
     fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
         use super::array::array_type_from_ctype;
 
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 17b2b4e2f8a..2df440b5b9f 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -438,6 +438,16 @@ fn sequence_contains_wrapper(
     contains_wrapper(seq.obj, needle, vm)
 }
 
+#[inline(never)]
+fn sequence_repeat_wrapper(seq: PySequence<'_>, n: isize, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(seq.obj, identifier!(vm, __mul__), (n,))
+}
+
+#[inline(never)]
+fn sequence_inplace_repeat_wrapper(seq: PySequence<'_>, n: isize, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(seq.obj, identifier!(vm, __imul__), (n,))
+}
+
 fn repr_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
     let ret = vm.call_special_method(zelf, identifier!(vm, __repr__), ())?;
     ret.downcast::<PyStr>().map_err(|obj| {
@@ -1294,12 +1304,16 @@ impl PyType {
                     accessor.inherit_from_mro(self);
                 }
             }
-            SlotAccessor::SqRepeat | SlotAccessor::SqInplaceRepeat => {
-                // Sequence repeat uses sq_repeat slot - no generic wrapper needed
-                // (handled by number protocol fallback)
-                if !ADD {
-                    accessor.inherit_from_mro(self);
-                }
+            SlotAccessor::SqRepeat => {
+                update_sub_slot!(as_sequence, repeat, sequence_repeat_wrapper, SeqRepeat)
+            }
+            SlotAccessor::SqInplaceRepeat => {
+                update_sub_slot!(
+                    as_sequence,
+                    inplace_repeat,
+                    sequence_inplace_repeat_wrapper,
+                    SeqRepeat
+                )
             }
             SlotAccessor::SqItem => {
                 update_sub_slot!(as_sequence, item, sequence_getitem_wrapper, SeqItem)
@@ -1348,28 +1362,44 @@ impl PyType {
     ) -> Option<T> {
         use crate::builtins::descriptor::PyWrapper;
 
+        // Helper to check if a class is a subclass of another by checking MRO
+        let is_subclass_of = |subclass_mro: &[PyRef<PyType>], superclass: &Py<PyType>| -> bool {
+            subclass_mro.iter().any(|c| c.is(superclass))
+        };
+
         // Helper to extract slot from an attribute if it's a wrapper descriptor
-        let try_extract = |attr: &PyObjectRef| -> Option<T> {
+        // and the wrapper's type is compatible with the given class.
+        // bpo-37619: wrapper descriptor from wrong class should not be used directly.
+        let try_extract = |attr: &PyObjectRef, for_class_mro: &[PyRef<PyType>]| -> Option<T> {
             if attr.class().is(ctx.types.wrapper_descriptor_type) {
-                attr.downcast_ref::<PyWrapper>()
-                    .and_then(|wrapper| extract(&wrapper.wrapped))
+                attr.downcast_ref::<PyWrapper>().and_then(|wrapper| {
+                    // Only extract slot if for_class is a subclass of wrapper.typ
+                    if is_subclass_of(for_class_mro, wrapper.typ) {
+                        extract(&wrapper.wrapped)
+                    } else {
+                        None
+                    }
+                })
             } else {
                 None
             }
         };
 
+        let mro = self.mro.read();
+
         // Look up in self's dict first
         if let Some(attr) = self.attributes.read().get(name).cloned() {
-            if let Some(func) = try_extract(&attr) {
+            if let Some(func) = try_extract(&attr, &mro) {
                 return Some(func);
             }
             return None;
         }
 
         // Look up in MRO (mro[0] is self, so skip it)
-        for cls in self.mro.read()[1..].iter() {
+        for (i, cls) in mro[1..].iter().enumerate() {
             if let Some(attr) = cls.attributes.read().get(name).cloned() {
-                if let Some(func) = try_extract(&attr) {
+                // Use the slice starting from this class in MRO
+                if let Some(func) = try_extract(&attr, &mro[i + 1..]) {
                     return Some(func);
                 }
                 return None;

From 1f8ef0aa3646babad28525646c442a7ce96b82a0 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 2 Jan 2026 00:35:59 +0900
Subject: [PATCH 151/418] sequence, mapping slots and fix separate __delitem__
 slots (#6621)

* fix call

* Remove repr pymethod

* Remove __get__ and __set__ pymethod

* Remove __contains__ pymethod

* Remove __len__ pymethod

* mapping priors sequence

* fix ctypes
---
 crates/stdlib/src/array.rs             |  2 -
 crates/stdlib/src/contextvars.rs       |  1 -
 crates/stdlib/src/mmap.rs              |  1 -
 crates/vm/src/builtins/bytearray.rs    |  1 -
 crates/vm/src/builtins/bytes.rs        |  1 -
 crates/vm/src/builtins/descriptor.rs   | 36 ++++++++++-----
 crates/vm/src/builtins/dict.rs         |  3 --
 crates/vm/src/builtins/getset.rs       | 13 ------
 crates/vm/src/builtins/list.rs         |  1 -
 crates/vm/src/builtins/mappingproxy.rs |  1 -
 crates/vm/src/builtins/property.rs     | 13 ------
 crates/vm/src/builtins/range.rs        |  2 -
 crates/vm/src/builtins/str.rs          |  1 -
 crates/vm/src/builtins/tuple.rs        |  1 -
 crates/vm/src/builtins/weakproxy.rs    |  1 -
 crates/vm/src/exception_group.rs       |  5 --
 crates/vm/src/stdlib/collections.rs    |  1 -
 crates/vm/src/stdlib/ctypes/array.rs   | 30 ++++++++++--
 crates/vm/src/stdlib/ctypes/base.rs    | 15 ------
 crates/vm/src/stdlib/ctypes/pointer.rs | 28 ++++++++++--
 crates/vm/src/types/slot.rs            | 61 ++++++++++++++++++++++---
 crates/vm/src/types/slot_defs.rs       | 63 +++++++++++++++++---------
 22 files changed, 171 insertions(+), 110 deletions(-)

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 878a6ce8fb7..2e28714611c 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -1102,7 +1102,6 @@ mod array {
             Ok(zelf)
         }
 
-        #[pymethod]
         pub(crate) fn __len__(&self) -> usize {
             self.read().len()
         }
@@ -1177,7 +1176,6 @@ mod array {
             ))
         }
 
-        #[pymethod]
         fn __contains__(&self, value: PyObjectRef, vm: &VirtualMachine) -> bool {
             let array = self.array.read();
             for element in array
diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index 731f5d11e0b..658d0906b24 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -202,7 +202,6 @@ mod _contextvars {
             Ok(item.to_owned())
         }
 
-        #[pymethod]
         fn __len__(&self) -> usize {
             self.borrow_vars().len()
         }
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
index b520eb2a1a7..191a330d536 100644
--- a/crates/stdlib/src/mmap.rs
+++ b/crates/stdlib/src/mmap.rs
@@ -731,7 +731,6 @@ mod mmap {
             .into()
         }
 
-        #[pymethod]
         fn __len__(&self) -> usize {
             self.size.load()
         }
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index d3f1b0bd4e8..e1e437310eb 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -219,7 +219,6 @@ impl PyByteArray {
         self.inner().add(&other.borrow_buf()).into()
     }
 
-    #[pymethod]
     fn __contains__(
         &self,
         needle: Either<PyBytesInner, PyIntRef>,
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 537a618be3b..57aed481dd4 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -228,7 +228,6 @@ impl PyBytes {
         self.inner.add(&other.borrow_buf())
     }
 
-    #[pymethod]
     fn __contains__(
         &self,
         needle: Either<PyBytesInner, PyIntRef>,
diff --git a/crates/vm/src/builtins/descriptor.rs b/crates/vm/src/builtins/descriptor.rs
index a9218c8d689..89dafdd14b7 100644
--- a/crates/vm/src/builtins/descriptor.rs
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -428,13 +428,15 @@ pub enum SlotFunc {
     SeqConcat(SeqConcatFunc),
     SeqRepeat(SeqRepeatFunc),
     SeqItem(SeqItemFunc),
-    SeqAssItem(SeqAssItemFunc),
+    SeqSetItem(SeqAssItemFunc), // __setitem__ (same func type, value = Some)
+    SeqDelItem(SeqAssItemFunc), // __delitem__ (same func type, value = None)
     SeqContains(SeqContainsFunc),
 
     // Mapping sub-slots (mp_*)
     MapLength(MapLenFunc),
     MapSubscript(MapSubscriptFunc),
-    MapAssSubscript(MapAssSubscriptFunc),
+    MapSetSubscript(MapAssSubscriptFunc), // __setitem__ (same func type, value = Some)
+    MapDelSubscript(MapAssSubscriptFunc), // __delitem__ (same func type, value = None)
 
     // Number sub-slots (nb_*) - grouped by signature
     NumBoolean(PyNumberUnaryFunc<bool>),  // __bool__
@@ -468,12 +470,14 @@ impl core::fmt::Debug for SlotFunc {
             SlotFunc::SeqConcat(_) => write!(f, "SlotFunc::SeqConcat(...)"),
             SlotFunc::SeqRepeat(_) => write!(f, "SlotFunc::SeqRepeat(...)"),
             SlotFunc::SeqItem(_) => write!(f, "SlotFunc::SeqItem(...)"),
-            SlotFunc::SeqAssItem(_) => write!(f, "SlotFunc::SeqAssItem(...)"),
+            SlotFunc::SeqSetItem(_) => write!(f, "SlotFunc::SeqSetItem(...)"),
+            SlotFunc::SeqDelItem(_) => write!(f, "SlotFunc::SeqDelItem(...)"),
             SlotFunc::SeqContains(_) => write!(f, "SlotFunc::SeqContains(...)"),
             // Mapping sub-slots
             SlotFunc::MapLength(_) => write!(f, "SlotFunc::MapLength(...)"),
             SlotFunc::MapSubscript(_) => write!(f, "SlotFunc::MapSubscript(...)"),
-            SlotFunc::MapAssSubscript(_) => write!(f, "SlotFunc::MapAssSubscript(...)"),
+            SlotFunc::MapSetSubscript(_) => write!(f, "SlotFunc::MapSetSubscript(...)"),
+            SlotFunc::MapDelSubscript(_) => write!(f, "SlotFunc::MapDelSubscript(...)"),
             // Number sub-slots
             SlotFunc::NumBoolean(_) => write!(f, "SlotFunc::NumBoolean(...)"),
             SlotFunc::NumUnary(_) => write!(f, "SlotFunc::NumUnary(...)"),
@@ -600,10 +604,14 @@ impl SlotFunc {
                 let (index,): (isize,) = args.bind(vm)?;
                 func(obj.sequence_unchecked(), index, vm)
             }
-            SlotFunc::SeqAssItem(func) => {
-                let (index, value): (isize, crate::function::OptionalArg<PyObjectRef>) =
-                    args.bind(vm)?;
-                func(obj.sequence_unchecked(), index, value.into_option(), vm)?;
+            SlotFunc::SeqSetItem(func) => {
+                let (index, value): (isize, PyObjectRef) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, Some(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::SeqDelItem(func) => {
+                let (index,): (isize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, None, vm)?;
                 Ok(vm.ctx.none())
             }
             SlotFunc::SeqContains(func) => {
@@ -621,10 +629,14 @@ impl SlotFunc {
                 let (key,): (PyObjectRef,) = args.bind(vm)?;
                 func(obj.mapping_unchecked(), &key, vm)
             }
-            SlotFunc::MapAssSubscript(func) => {
-                let (key, value): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
-                    args.bind(vm)?;
-                func(obj.mapping_unchecked(), &key, value.into_option(), vm)?;
+            SlotFunc::MapSetSubscript(func) => {
+                let (key, value): (PyObjectRef, PyObjectRef) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, Some(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::MapDelSubscript(func) => {
+                let (key,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, None, vm)?;
                 Ok(vm.ctx.none())
             }
             // Number sub-slots
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 41f6779c212..19b14688994 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -221,7 +221,6 @@ impl PyDict {
         core::mem::size_of::<Self>() + self.entries.sizeof()
     }
 
-    #[pymethod]
     fn __contains__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self.entries.contains(vm, &*key)
     }
@@ -1130,7 +1129,6 @@ impl ViewSetOps for PyDictKeys {}
     )
 )]
 impl PyDictKeys {
-    #[pymethod]
     fn __contains__(zelf: PyObjectRef, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         zelf.sequence_unchecked().contains(&key, vm)
     }
@@ -1195,7 +1193,6 @@ impl ViewSetOps for PyDictItems {}
     )
 )]
 impl PyDictItems {
-    #[pymethod]
     fn __contains__(zelf: PyObjectRef, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         zelf.sequence_unchecked().contains(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
index a3f0605a473..86f0524b12c 100644
--- a/crates/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -118,19 +118,6 @@ impl PyGetSet {
             )))
         }
     }
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
 
     #[pygetset]
     fn __name__(&self) -> String {
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 514b38b6c28..eaff4a54688 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -251,7 +251,6 @@ impl PyList {
         self.mut_count(vm, &needle)
     }
 
-    #[pymethod]
     pub(crate) fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self.mut_contains(vm, &needle)
     }
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index 13b0fa32490..c8f77c5c5fc 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -128,7 +128,6 @@ impl PyMappingProxy {
         }
     }
 
-    #[pymethod]
     pub fn __contains__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self._contains(&key, vm)
     }
diff --git a/crates/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
index 3a86867176a..8cc9ba92e92 100644
--- a/crates/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -125,19 +125,6 @@ impl PyProperty {
             }
         }
     }
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
 
     // Access functions
 
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index fac5206b82d..957a66020c1 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -265,7 +265,6 @@ impl PyRange {
         )
     }
 
-    #[pymethod]
     fn __len__(&self) -> BigInt {
         self.compute_length()
     }
@@ -342,7 +341,6 @@ impl Py<PyRange> {
         }
     }
 
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> bool {
         self.contains_inner(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index e101ef2a52b..d14bcd92bbe 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -572,7 +572,6 @@ impl PyStr {
         }
     }
 
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self._contains(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index f3da8b26163..e7271f9b6fd 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -345,7 +345,6 @@ impl PyTuple {
         Ok(false)
     }
 
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self._contains(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
index 51120c02c01..0f68e9e9815 100644
--- a/crates/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -98,7 +98,6 @@ impl PyWeakProxy {
         let obj = self.try_upgrade(vm)?;
         reversed(obj, vm)
     }
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self.try_upgrade(vm)?
             .sequence_unchecked()
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index b2dee206200..a55273480f6 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -202,11 +202,6 @@ pub(super) mod types {
             )))
         }
 
-        #[pymethod]
-        fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            Self::slot_repr(&zelf, vm)
-        }
-
         #[pyslot]
         fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
             let zelf = zelf
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 4688121c9b5..86caef7a25f 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -303,7 +303,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
             self._contains(&needle, vm)
         }
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index 63594879878..d808f967a0f 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -9,8 +9,8 @@ use crate::{
     },
     class::StaticType,
     function::{ArgBytesLike, FuncArgs, PySetterValue},
-    protocol::{BufferDescriptor, PyBuffer, PyNumberMethods, PySequenceMethods},
-    types::{AsBuffer, AsNumber, AsSequence, Constructor, Initializer},
+    protocol::{BufferDescriptor, PyBuffer, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    types::{AsBuffer, AsMapping, AsNumber, AsSequence, Constructor, Initializer},
 };
 use alloc::borrow::Cow;
 use num_traits::{Signed, ToPrimitive};
@@ -468,9 +468,33 @@ impl AsSequence for PyCArray {
     }
 }
 
+impl AsMapping for PyCArray {
+    fn as_mapping() -> &'static PyMappingMethods {
+        use std::sync::LazyLock;
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            length: atomic_func!(|mapping, _vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                Ok(zelf.class().stg_info_opt().map_or(0, |i| i.length))
+            }),
+            subscript: atomic_func!(|mapping, needle, vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                PyCArray::__getitem__(zelf, needle.to_owned(), vm)
+            }),
+            ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                match value {
+                    Some(value) => PyCArray::__setitem__(zelf, needle.to_owned(), value, vm),
+                    None => PyCArray::__delitem__(zelf, needle.to_owned(), vm),
+                }
+            }),
+        });
+        &AS_MAPPING
+    }
+}
+
 #[pyclass(
     flags(BASETYPE, IMMUTABLETYPE),
-    with(Constructor, Initializer, AsSequence, AsBuffer)
+    with(Constructor, Initializer, AsSequence, AsMapping, AsBuffer)
 )]
 impl PyCArray {
     #[pyclassmethod]
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
index 1f9eaeef56a..58d9466adb2 100644
--- a/crates/vm/src/stdlib/ctypes/base.rs
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -1650,21 +1650,6 @@ impl PyCField {
         }
     }
 
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
-
     #[pygetset]
     fn offset(&self) -> isize {
         self.offset
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index 4f935945e88..8a0f7cb0f6a 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -1,7 +1,8 @@
 use super::base::CDATA_BUFFER_METHODS;
 use super::{PyCArray, PyCData, PyCSimple, PyCStructure, StgInfo, StgInfoFlags};
-use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
-use crate::types::{AsBuffer, AsNumber, Constructor, Initializer};
+use crate::atomic_func;
+use crate::protocol::{BufferDescriptor, PyBuffer, PyMappingMethods, PyNumberMethods};
+use crate::types::{AsBuffer, AsMapping, AsNumber, Constructor, Initializer};
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
@@ -260,7 +261,7 @@ impl Initializer for PyCPointer {
 
 #[pyclass(
     flags(BASETYPE, IMMUTABLETYPE),
-    with(Constructor, Initializer, AsNumber, AsBuffer)
+    with(Constructor, Initializer, AsNumber, AsBuffer, AsMapping)
 )]
 impl PyCPointer {
     /// Get the pointer value stored in buffer as usize
@@ -785,6 +786,27 @@ impl AsNumber for PyCPointer {
     }
 }
 
+impl AsMapping for PyCPointer {
+    fn as_mapping() -> &'static PyMappingMethods {
+        use std::sync::LazyLock;
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            subscript: atomic_func!(|mapping, needle, vm| {
+                let zelf = PyCPointer::mapping_downcast(mapping);
+                PyCPointer::__getitem__(zelf, needle.to_owned(), vm)
+            }),
+            ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                let zelf = PyCPointer::mapping_downcast(mapping);
+                match value {
+                    Some(value) => PyCPointer::__setitem__(zelf, needle.to_owned(), value, vm),
+                    None => Err(vm.new_type_error("Pointer does not support item deletion")),
+                }
+            }),
+            ..PyMappingMethods::NOT_IMPLEMENTED
+        });
+        &AS_MAPPING
+    }
+}
+
 impl AsBuffer for PyCPointer {
     fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
         let stg_info = zelf
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 2df440b5b9f..b637bfc40b6 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -1319,7 +1319,33 @@ impl PyType {
                 update_sub_slot!(as_sequence, item, sequence_getitem_wrapper, SeqItem)
             }
             SlotAccessor::SqAssItem => {
-                update_sub_slot!(as_sequence, ass_item, sequence_setitem_wrapper, SeqAssItem)
+                // SqAssItem is shared by __setitem__ (SeqSetItem) and __delitem__ (SeqDelItem)
+                if ADD {
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        let setitem = ctx.intern_str("__setitem__");
+                        let delitem = ctx.intern_str("__delitem__");
+                        guard.contains_key(setitem) || guard.contains_key(delitem)
+                    };
+                    if has_own {
+                        self.slots
+                            .as_sequence
+                            .ass_item
+                            .store(Some(sequence_setitem_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::SeqSetItem(f) | SlotFunc::SeqDelItem(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.as_sequence.ass_item.store(Some(func));
+                    } else {
+                        self.slots
+                            .as_sequence
+                            .ass_item
+                            .store(Some(sequence_setitem_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
             }
             SlotAccessor::SqContains => {
                 update_sub_slot!(
@@ -1338,12 +1364,33 @@ impl PyType {
                 update_sub_slot!(as_mapping, subscript, mapping_getitem_wrapper, MapSubscript)
             }
             SlotAccessor::MpAssSubscript => {
-                update_sub_slot!(
-                    as_mapping,
-                    ass_subscript,
-                    mapping_setitem_wrapper,
-                    MapAssSubscript
-                )
+                // MpAssSubscript is shared by __setitem__ (MapSetSubscript) and __delitem__ (MapDelSubscript)
+                if ADD {
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        let setitem = ctx.intern_str("__setitem__");
+                        let delitem = ctx.intern_str("__delitem__");
+                        guard.contains_key(setitem) || guard.contains_key(delitem)
+                    };
+                    if has_own {
+                        self.slots
+                            .as_mapping
+                            .ass_subscript
+                            .store(Some(mapping_setitem_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::MapSetSubscript(f) | SlotFunc::MapDelSubscript(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.as_mapping.ass_subscript.store(Some(func));
+                    } else {
+                        self.slots
+                            .as_mapping
+                            .ass_subscript
+                            .store(Some(mapping_setitem_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
             }
 
             // Reserved slots - no-op
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
index 1fd493f685e..024776f7893 100644
--- a/crates/vm/src/types/slot_defs.rs
+++ b/crates/vm/src/types/slot_defs.rs
@@ -389,13 +389,20 @@ impl SlotAccessor {
             Self::SqConcat | Self::SqInplaceConcat => matches!(slot_func, SlotFunc::SeqConcat(_)),
             Self::SqRepeat | Self::SqInplaceRepeat => matches!(slot_func, SlotFunc::SeqRepeat(_)),
             Self::SqItem => matches!(slot_func, SlotFunc::SeqItem(_)),
-            Self::SqAssItem => matches!(slot_func, SlotFunc::SeqAssItem(_)),
+            Self::SqAssItem => {
+                matches!(slot_func, SlotFunc::SeqSetItem(_) | SlotFunc::SeqDelItem(_))
+            }
             Self::SqContains => matches!(slot_func, SlotFunc::SeqContains(_)),
 
             // Mapping
             Self::MpLength => matches!(slot_func, SlotFunc::MapLength(_)),
             Self::MpSubscript => matches!(slot_func, SlotFunc::MapSubscript(_)),
-            Self::MpAssSubscript => matches!(slot_func, SlotFunc::MapAssSubscript(_)),
+            Self::MpAssSubscript => {
+                matches!(
+                    slot_func,
+                    SlotFunc::MapSetSubscript(_) | SlotFunc::MapDelSubscript(_)
+                )
+            }
 
             // New and reserved slots
             Self::TpNew => false,
@@ -751,7 +758,7 @@ impl SlotAccessor {
             Self::SqConcat => slots.as_sequence.concat.load().map(SlotFunc::SeqConcat),
             Self::SqRepeat => slots.as_sequence.repeat.load().map(SlotFunc::SeqRepeat),
             Self::SqItem => slots.as_sequence.item.load().map(SlotFunc::SeqItem),
-            Self::SqAssItem => slots.as_sequence.ass_item.load().map(SlotFunc::SeqAssItem),
+            Self::SqAssItem => slots.as_sequence.ass_item.load().map(SlotFunc::SeqSetItem),
             Self::SqContains => slots.as_sequence.contains.load().map(SlotFunc::SeqContains),
             Self::SqInplaceConcat => slots
                 .as_sequence
@@ -775,7 +782,7 @@ impl SlotAccessor {
                 .as_mapping
                 .ass_subscript
                 .load()
-                .map(SlotFunc::MapAssSubscript),
+                .map(SlotFunc::MapSetSubscript),
 
             // Reserved slots
             _ => None,
@@ -793,6 +800,16 @@ impl SlotAccessor {
             match self {
                 Self::TpSetattro => return slots.setattro.load().map(SlotFunc::DelAttro),
                 Self::TpDescrSet => return slots.descr_set.load().map(SlotFunc::DescrDel),
+                Self::SqAssItem => {
+                    return slots.as_sequence.ass_item.load().map(SlotFunc::SeqDelItem);
+                }
+                Self::MpAssSubscript => {
+                    return slots
+                        .as_mapping
+                        .ass_subscript
+                        .load()
+                        .map(SlotFunc::MapDelSubscript);
+                }
                 _ => {}
             }
         }
@@ -1060,62 +1077,64 @@ pub static SLOT_DEFS: &[SlotDef] = &[
         op: Some(SlotOp::Delete),
         doc: "Delete an attribute of instance.",
     },
-    // Sequence protocol (sq_*)
+    // Mapping protocol (mp_*) - must come before Sequence protocol
+    // so that mp_subscript wins over sq_item for __getitem__
+    // (see CPython typeobject.c:10995-11006)
     SlotDef {
         name: "__len__",
-        accessor: SlotAccessor::SqLength,
+        accessor: SlotAccessor::MpLength,
         op: None,
         doc: "Return len(self).",
     },
     SlotDef {
         name: "__getitem__",
-        accessor: SlotAccessor::SqItem,
+        accessor: SlotAccessor::MpSubscript,
         op: None,
         doc: "Return self[key].",
     },
     SlotDef {
         name: "__setitem__",
-        accessor: SlotAccessor::SqAssItem,
+        accessor: SlotAccessor::MpAssSubscript,
         op: None,
         doc: "Set self[key] to value.",
     },
     SlotDef {
         name: "__delitem__",
-        accessor: SlotAccessor::SqAssItem,
-        op: None,
+        accessor: SlotAccessor::MpAssSubscript,
+        op: Some(SlotOp::Delete),
         doc: "Delete self[key].",
     },
-    SlotDef {
-        name: "__contains__",
-        accessor: SlotAccessor::SqContains,
-        op: None,
-        doc: "Return key in self.",
-    },
-    // Mapping protocol (mp_*)
+    // Sequence protocol (sq_*)
     SlotDef {
         name: "__len__",
-        accessor: SlotAccessor::MpLength,
+        accessor: SlotAccessor::SqLength,
         op: None,
         doc: "Return len(self).",
     },
     SlotDef {
         name: "__getitem__",
-        accessor: SlotAccessor::MpSubscript,
+        accessor: SlotAccessor::SqItem,
         op: None,
         doc: "Return self[key].",
     },
     SlotDef {
         name: "__setitem__",
-        accessor: SlotAccessor::MpAssSubscript,
+        accessor: SlotAccessor::SqAssItem,
         op: None,
         doc: "Set self[key] to value.",
     },
     SlotDef {
         name: "__delitem__",
-        accessor: SlotAccessor::MpAssSubscript,
-        op: None,
+        accessor: SlotAccessor::SqAssItem,
+        op: Some(SlotOp::Delete),
         doc: "Delete self[key].",
     },
+    SlotDef {
+        name: "__contains__",
+        accessor: SlotAccessor::SqContains,
+        op: None,
+        doc: "Return key in self.",
+    },
     // Number protocol - binary ops with left/right variants
     SlotDef {
         name: "__add__",

From 2e2924801c967913e8c71100d9c9300115c7a380 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 2 Jan 2026 08:29:42 +0900
Subject: [PATCH 152/418] __{get,set,del}item__ without pymethods (#6622)

* __getitem__ without pymethod

* __setitem__ __delitem__ without pymethod

* sort slot names
---
 crates/stdlib/src/array.rs             | 3 ---
 crates/stdlib/src/contextvars.rs       | 1 -
 crates/stdlib/src/mmap.rs              | 2 --
 crates/vm/src/builtins/bytearray.rs    | 3 ---
 crates/vm/src/builtins/bytes.rs        | 1 -
 crates/vm/src/builtins/dict.rs         | 3 ---
 crates/vm/src/builtins/genericalias.rs | 1 -
 crates/vm/src/builtins/list.rs         | 3 ---
 crates/vm/src/builtins/mappingproxy.rs | 1 -
 crates/vm/src/builtins/memory.rs       | 3 ---
 crates/vm/src/builtins/range.rs        | 1 -
 crates/vm/src/builtins/str.rs          | 1 -
 crates/vm/src/builtins/tuple.rs        | 1 -
 crates/vm/src/builtins/type.rs         | 5 ++++-
 crates/vm/src/stdlib/collections.rs    | 3 ---
 crates/vm/src/stdlib/ctypes/array.rs   | 3 ---
 crates/vm/src/stdlib/ctypes/pointer.rs | 2 --
 crates/vm/src/stdlib/sre.rs            | 1 -
 18 files changed, 4 insertions(+), 34 deletions(-)

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
index 2e28714611c..463027d9baa 100644
--- a/crates/stdlib/src/array.rs
+++ b/crates/stdlib/src/array.rs
@@ -996,7 +996,6 @@ mod array {
             }
         }
 
-        #[pymethod]
         fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
             self.getitem_inner(&needle, vm)
         }
@@ -1038,7 +1037,6 @@ mod array {
             }
         }
 
-        #[pymethod]
         fn __setitem__(
             zelf: &Py<Self>,
             needle: PyObjectRef,
@@ -1055,7 +1053,6 @@ mod array {
             }
         }
 
-        #[pymethod]
         fn __delitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             self.delitem_inner(&needle, vm)
         }
diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index 658d0906b24..329342fe6dc 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -189,7 +189,6 @@ mod _contextvars {
             }
         }
 
-        #[pymethod]
         fn __getitem__(
             &self,
             var: PyRef<ContextVar>,
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
index 191a330d536..d3895521096 100644
--- a/crates/stdlib/src/mmap.rs
+++ b/crates/stdlib/src/mmap.rs
@@ -1240,12 +1240,10 @@ mod mmap {
             Ok(())
         }
 
-        #[pymethod]
         fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
             self.getitem_inner(&needle, vm)
         }
 
-        #[pymethod]
         fn __setitem__(
             zelf: &Py<Self>,
             needle: PyObjectRef,
diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index e1e437310eb..0f9dce7230b 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -238,12 +238,10 @@ impl PyByteArray {
         Ok(zelf)
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
 
-    #[pymethod]
     pub fn __delitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self._delitem(&needle, vm)
     }
@@ -549,7 +547,6 @@ impl PyByteArray {
 
 #[pyclass]
 impl Py<PyByteArray> {
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 57aed481dd4..01e67358aae 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -241,7 +241,6 @@ impl PyBytes {
         PyBytesInner::maketrans(from, to, vm)
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 19b14688994..43f7100e963 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -225,7 +225,6 @@ impl PyDict {
         self.entries.contains(vm, &*key)
     }
 
-    #[pymethod]
     fn __delitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self.inner_delitem(&*key, vm)
     }
@@ -235,7 +234,6 @@ impl PyDict {
         self.entries.clear()
     }
 
-    #[pymethod]
     fn __setitem__(
         &self,
         key: PyObjectRef,
@@ -372,7 +370,6 @@ impl Py<PyDict> {
         Ok(Implemented(true))
     }
 
-    #[pymethod]
     #[cfg_attr(feature = "flame-it", flame("PyDictRef"))]
     fn __getitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self.inner_getitem(&*key, vm)
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index 99c1eacc3ec..e9150e4c088 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -189,7 +189,6 @@ impl PyGenericAlias {
         }
     }
 
-    #[pymethod]
     fn __getitem__(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let new_args = subs_parameters(
             zelf.to_owned().into(),
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index eaff4a54688..02475ee12b6 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -213,7 +213,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
@@ -228,7 +227,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
@@ -308,7 +306,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __delitem__(&self, subscript: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self._delitem(&subscript, vm)
     }
diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index c8f77c5c5fc..f7fb64fa6ab 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -111,7 +111,6 @@ impl PyMappingProxy {
         )?))
     }
 
-    #[pymethod]
     pub fn __getitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self.get_inner(key.clone(), vm)?
             .ok_or_else(|| vm.new_key_error(key))
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
index 5ca4257cded..6db260c80e0 100644
--- a/crates/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -659,7 +659,6 @@ impl PyMemoryView {
         self.release();
     }
 
-    #[pymethod]
     fn __getitem__(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         zelf.try_not_released(vm)?;
         if zelf.desc.ndim() == 0 {
@@ -682,7 +681,6 @@ impl PyMemoryView {
         }
     }
 
-    #[pymethod]
     fn __delitem__(&self, _needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         if self.desc.readonly {
             return Err(vm.new_type_error("cannot modify read-only memory"));
@@ -847,7 +845,6 @@ impl PyMemoryView {
 
 #[pyclass]
 impl Py<PyMemoryView> {
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
diff --git a/crates/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
index 957a66020c1..49f50ffbaa2 100644
--- a/crates/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -279,7 +279,6 @@ impl PyRange {
         (vm.ctx.types.range_type.to_owned(), range_parameters_tuple)
     }
 
-    #[pymethod]
     fn __getitem__(&self, subscript: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         match RangeIndex::try_from_object(vm, subscript)? {
             RangeIndex::Slice(slice) => {
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index d14bcd92bbe..4931a748198 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -584,7 +584,6 @@ impl PyStr {
         Ok(item)
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index e7271f9b6fd..f6eff5b91e5 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -315,7 +315,6 @@ impl PyTuple {
         }
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index e2e69c7bffc..b6995d6f595 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -439,7 +439,10 @@ impl PyType {
                 slot_name_set.insert(name);
             }
         }
-        for attr_name in slot_name_set {
+        // Sort for deterministic iteration order (important for slot processing)
+        let mut slot_names: Vec<_> = slot_name_set.into_iter().collect();
+        slot_names.sort_by_key(|name| name.as_str());
+        for attr_name in slot_names {
             self.update_slot::<true>(attr_name, ctx);
         }
 
diff --git a/crates/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
index 86caef7a25f..fd48cea0598 100644
--- a/crates/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -278,7 +278,6 @@ mod _collections {
             self.maxlen
         }
 
-        #[pymethod]
         fn __getitem__(&self, idx: isize, vm: &VirtualMachine) -> PyResult {
             let deque = self.borrow_deque();
             idx.wrapped_at(deque.len())
@@ -286,7 +285,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __setitem__(&self, idx: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             let mut deque = self.borrow_deque_mut();
             idx.wrapped_at(deque.len())
@@ -295,7 +293,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __delitem__(&self, idx: isize, vm: &VirtualMachine) -> PyResult<()> {
             let mut deque = self.borrow_deque_mut();
             idx.wrapped_at(deque.len())
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
index d808f967a0f..eea1fd765d5 100644
--- a/crates/vm/src/stdlib/ctypes/array.rs
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -940,7 +940,6 @@ impl PyCArray {
     }
 
     // Array_subscript
-    #[pymethod]
     fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // PyIndex_Check
         if let Some(i) = item.downcast_ref::<PyInt>() {
@@ -1047,7 +1046,6 @@ impl PyCArray {
     }
 
     // Array_ass_subscript
-    #[pymethod]
     fn __setitem__(
         zelf: &Py<Self>,
         item: PyObjectRef,
@@ -1074,7 +1072,6 @@ impl PyCArray {
     }
 
     // Array does not support item deletion
-    #[pymethod]
     fn __delitem__(&self, _item: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         Err(vm.new_type_error("Array does not support item deletion"))
     }
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
index 8a0f7cb0f6a..875d78a0010 100644
--- a/crates/vm/src/stdlib/ctypes/pointer.rs
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -346,7 +346,6 @@ impl PyCPointer {
     }
 
     // Pointer_subscript
-    #[pymethod]
     fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         // PyIndex_Check
         if let Some(i) = item.downcast_ref::<PyInt>() {
@@ -529,7 +528,6 @@ impl PyCPointer {
     }
 
     // Pointer_ass_item
-    #[pymethod]
     fn __setitem__(
         zelf: &Py<Self>,
         item: PyObjectRef,
diff --git a/crates/vm/src/stdlib/sre.rs b/crates/vm/src/stdlib/sre.rs
index b950db9e1ff..33f884e1adc 100644
--- a/crates/vm/src/stdlib/sre.rs
+++ b/crates/vm/src/stdlib/sre.rs
@@ -737,7 +737,6 @@ mod _sre {
             })
         }
 
-        #[pymethod]
         fn __getitem__(
             &self,
             group: PyObjectRef,

From 32184103c348c26b5ceb4a9d27a9ccd89fe583d9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 2 Jan 2026 13:14:39 +0900
Subject: [PATCH 153/418] ruff_source_file (#6624)

---
 crates/compiler-source/src/lib.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/compiler-source/src/lib.rs b/crates/compiler-source/src/lib.rs
index 2d967e218d2..e3fb55ef603 100644
--- a/crates/compiler-source/src/lib.rs
+++ b/crates/compiler-source/src/lib.rs
@@ -1,4 +1,4 @@
-pub use ruff_source_file::{LineIndex, OneIndexed as LineNumber, SourceLocation};
+pub use ruff_source_file::{LineIndex, OneIndexed as LineNumber, PositionEncoding, SourceLocation};
 use ruff_text_size::TextRange;
 pub use ruff_text_size::TextSize;
 
@@ -20,7 +20,8 @@ impl<'src> SourceCode<'src> {
     }
 
     pub fn source_location(&self, offset: TextSize) -> SourceLocation {
-        self.index.source_location(offset, self.text)
+        self.index
+            .source_location(offset, self.text, PositionEncoding::Utf8)
     }
 
     pub fn get_range(&'src self, range: TextRange) -> &'src str {

From 346519bb6b0d39fa173f9cad5eae88232c8cae4b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 2 Jan 2026 17:49:55 +0900
Subject: [PATCH 154/418] Warn user not to override special magic methods
 (#6625)

---
 crates/derive-impl/src/pyclass.rs | 106 +++++++++++++++++++++++++++---
 1 file changed, 97 insertions(+), 9 deletions(-)

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 06bbc06cfb2..028d3d7c292 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -909,18 +909,106 @@ where
 
         let py_name = item_meta.method_name()?;
 
-        // Disallow __new__ and __init__ as pymethod in impl blocks (not in traits)
+        // Disallow slot methods - they should be defined via trait implementations
+        // These are exposed as wrapper_descriptor via add_operators from SLOT_DEFS
         if !args.context.is_trait {
-            if py_name == "__new__" {
-                return Err(syn::Error::new(
-                    ident.span(),
-                    "#[pymethod] cannot define '__new__'. Use #[pyclass(with(Constructor))] instead.",
-                ));
-            }
-            if py_name == "__init__" {
+            const FORBIDDEN_SLOT_METHODS: &[(&str, &str)] = &[
+                // Constructor/Initializer traits
+                ("__new__", "Constructor"),
+                ("__init__", "Initializer"),
+                // Representable trait
+                // ("__repr__", "Representable"),
+                // ("__str__", "???"), // allow __str__
+                // Hashable trait
+                ("__hash__", "Hashable"),
+                // Callable trait
+                ("__call__", "Callable"),
+                // GetAttr/SetAttr traits
+                // NOTE: __getattribute__, __setattr__, __delattr__ are intentionally NOT forbidden
+                // because they need pymethod for subclass override mechanism to work properly.
+                // GetDescriptor/SetDescriptor traits
+                // ("__get__", "GetDescriptor"),
+                // ("__set__", "SetDescriptor"),
+                // ("__delete__", "SetDescriptor"),
+                // AsNumber trait
+                ("__add__", "AsNumber"),
+                ("__radd__", "AsNumber"),
+                ("__iadd__", "AsNumber"),
+                ("__sub__", "AsNumber"),
+                ("__rsub__", "AsNumber"),
+                ("__isub__", "AsNumber"),
+                ("__mul__", "AsNumber"),
+                ("__rmul__", "AsNumber"),
+                ("__imul__", "AsNumber"),
+                ("__truediv__", "AsNumber"),
+                ("__rtruediv__", "AsNumber"),
+                ("__itruediv__", "AsNumber"),
+                ("__floordiv__", "AsNumber"),
+                ("__rfloordiv__", "AsNumber"),
+                ("__ifloordiv__", "AsNumber"),
+                ("__mod__", "AsNumber"),
+                ("__rmod__", "AsNumber"),
+                ("__imod__", "AsNumber"),
+                ("__pow__", "AsNumber"),
+                ("__rpow__", "AsNumber"),
+                ("__ipow__", "AsNumber"),
+                ("__divmod__", "AsNumber"),
+                ("__rdivmod__", "AsNumber"),
+                ("__matmul__", "AsNumber"),
+                ("__rmatmul__", "AsNumber"),
+                ("__imatmul__", "AsNumber"),
+                ("__lshift__", "AsNumber"),
+                ("__rlshift__", "AsNumber"),
+                ("__ilshift__", "AsNumber"),
+                ("__rshift__", "AsNumber"),
+                ("__rrshift__", "AsNumber"),
+                ("__irshift__", "AsNumber"),
+                ("__and__", "AsNumber"),
+                ("__rand__", "AsNumber"),
+                ("__iand__", "AsNumber"),
+                ("__or__", "AsNumber"),
+                ("__ror__", "AsNumber"),
+                ("__ior__", "AsNumber"),
+                ("__xor__", "AsNumber"),
+                ("__rxor__", "AsNumber"),
+                ("__ixor__", "AsNumber"),
+                ("__neg__", "AsNumber"),
+                ("__pos__", "AsNumber"),
+                ("__abs__", "AsNumber"),
+                ("__invert__", "AsNumber"),
+                ("__int__", "AsNumber"),
+                ("__float__", "AsNumber"),
+                ("__index__", "AsNumber"),
+                ("__bool__", "AsNumber"),
+                // AsSequence trait
+                // ("__len__", "AsSequence (or AsMapping)"),
+                // ("__contains__", "AsSequence"),
+                // AsMapping trait
+                // ("__getitem__", "AsMapping (or AsSequence)"),
+                // ("__setitem__", "AsMapping (or AsSequence)"),
+                // ("__delitem__", "AsMapping (or AsSequence)"),
+                // IterNext trait
+                // ("__iter__", "IterNext"),
+                // ("__next__", "IterNext"),
+                // Comparable trait
+                ("__eq__", "Comparable"),
+                ("__ne__", "Comparable"),
+                ("__lt__", "Comparable"),
+                ("__le__", "Comparable"),
+                ("__gt__", "Comparable"),
+                ("__ge__", "Comparable"),
+            ];
+
+            if let Some((_, trait_name)) = FORBIDDEN_SLOT_METHODS
+                .iter()
+                .find(|(method, _)| *method == py_name.as_str())
+            {
                 return Err(syn::Error::new(
                     ident.span(),
-                    "#[pymethod] cannot define '__init__'. Use #[pyclass(with(Initializer))] instead.",
+                    format!(
+                        "#[pymethod] cannot define '{py_name}'. Use `impl {trait_name} for ...` instead. \
+                         Slot methods are exposed as wrapper_descriptor automatically.",
+                    ),
                 ));
             }
         }

From 546d35b8c19a876241acc50762ca311e0bbc45f4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 3 Jan 2026 00:14:43 +0900
Subject: [PATCH 155/418] impl multiprocessing SemLock (#6542)

---
 .cspell.dict/cpython.txt                      |   2 +
 Lib/test/_test_multiprocessing.py             | 113 ++-
 Lib/test/mp_fork_bomb.py                      |  18 +
 Lib/test/mp_preload.py                        |  18 +
 Lib/test/mp_preload_flush.py                  |  11 +
 .../test_importlib/test_threaded_import.py    |   3 +-
 Lib/test/test_logging.py                      |   6 +-
 crates/stdlib/src/multiprocessing.rs          | 692 +++++++++++++++++-
 crates/stdlib/src/posixshmem.rs               |  26 +-
 crates/stdlib/src/pystruct.rs                 |   2 +-
 10 files changed, 849 insertions(+), 42 deletions(-)
 create mode 100644 Lib/test/mp_fork_bomb.py
 create mode 100644 Lib/test/mp_preload.py
 create mode 100644 Lib/test/mp_preload_flush.py

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 5011975f496..0e4e17e2872 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -30,6 +30,7 @@ fromlist
 heaptype
 HIGHRES
 IMMUTABLETYPE
+ismine
 Itertool
 keeped
 kwonlyarg
@@ -40,6 +41,7 @@ lsprof
 maxdepth
 mult
 multibytecodec
+newsemlockobject
 nkwargs
 noraise
 numer
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index c22ce769c48..351887819e6 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -38,7 +38,7 @@
 from test.support import socket_helper
 from test.support import threading_helper
 from test.support import warnings_helper
-
+from test.support import subTests
 
 # Skip tests if _multiprocessing wasn't built.
 _multiprocessing = import_helper.import_module('_multiprocessing')
@@ -1109,7 +1109,7 @@ def test_put(self):
     @classmethod
     def _test_get(cls, queue, child_can_start, parent_can_continue):
         child_can_start.wait()
-        #queue.put(1)
+        queue.put(1)
         queue.put(2)
         queue.put(3)
         queue.put(4)
@@ -1133,15 +1133,16 @@ def test_get(self):
         child_can_start.set()
         parent_can_continue.wait()
 
-        time.sleep(DELTA)
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if not queue_empty(queue):
+                break
         self.assertEqual(queue_empty(queue), False)
 
-        # Hangs unexpectedly, remove for now
-        #self.assertEqual(queue.get(), 1)
+        self.assertEqual(queue.get_nowait(), 1)
         self.assertEqual(queue.get(True, None), 2)
         self.assertEqual(queue.get(True), 3)
         self.assertEqual(queue.get(timeout=1), 4)
-        self.assertEqual(queue.get_nowait(), 5)
+        self.assertEqual(queue.get(), 5)
 
         self.assertEqual(queue_empty(queue), True)
 
@@ -2970,6 +2971,8 @@ def test_map_no_failfast(self):
         # check that we indeed waited for all jobs
         self.assertGreater(time.monotonic() - t_start, 0.9)
 
+    # TODO: RUSTPYTHON - reference counting differences
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_release_task_refs(self):
         # Issue #29861: task arguments and results should not be kept
         # alive after we are done with them.
@@ -3882,6 +3885,8 @@ def _remote(cls, conn):
 
         conn.close()
 
+    # TODO: RUSTPYTHON - hangs
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_pickling(self):
         families = self.connection.families
 
@@ -4051,6 +4056,8 @@ def test_heap(self):
         self.assertEqual(len(heap._allocated_blocks), 0, heap._allocated_blocks)
         self.assertEqual(len(heap._len_to_seq), 0)
 
+    # TODO: RUSTPYTHON - gc.enable() not implemented
+    @unittest.expectedFailure
     def test_free_from_gc(self):
         # Check that freeing of blocks by the garbage collector doesn't deadlock
         # (issue #12352).
@@ -4103,6 +4110,8 @@ def _double(cls, x, y, z, foo, arr, string):
         for i in range(len(arr)):
             arr[i] *= 2
 
+    # TODO: RUSTPYTHON - ctypes Structure shared memory not working
+    @unittest.expectedFailure
     def test_sharedctypes(self, lock=False):
         x = Value('i', 7, lock=lock)
         y = Value(c_double, 1.0/3.0, lock=lock)
@@ -4126,6 +4135,8 @@ def test_sharedctypes(self, lock=False):
             self.assertAlmostEqual(arr[i], i*2)
         self.assertEqual(string.value, latin('hellohello'))
 
+    # TODO: RUSTPYTHON - calls test_sharedctypes which fails
+    @unittest.expectedFailure
     def test_synchronize(self):
         self.test_sharedctypes(lock=True)
 
@@ -4140,6 +4151,19 @@ def test_copy(self):
         self.assertEqual(bar.z, 2 ** 33)
 
 
+def resource_tracker_format_subtests(func):
+    """Run given test using both resource tracker communication formats"""
+    def _inner(self, *args, **kwargs):
+        tracker = resource_tracker._resource_tracker
+        for use_simple_format in False, True:
+            with (
+                self.subTest(use_simple_format=use_simple_format),
+                unittest.mock.patch.object(
+                    tracker, '_use_simple_format', use_simple_format)
+            ):
+                func(self, *args, **kwargs)
+    return _inner
+
 @unittest.skipUnless(HAS_SHMEM, "requires multiprocessing.shared_memory")
 @hashlib_helper.requires_hashdigest('sha256')
 class _TestSharedMemory(BaseTestCase):
@@ -4417,6 +4441,7 @@ def test_shared_memory_SharedMemoryServer_ignores_sigint(self):
         smm.shutdown()
 
     @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
     def test_shared_memory_SharedMemoryManager_reuses_resource_tracker(self):
         # bpo-36867: test that a SharedMemoryManager uses the
         # same resource_tracker process as its parent.
@@ -4667,6 +4692,7 @@ def test_shared_memory_cleaned_after_process_termination(self):
                     "shared_memory objects to clean up at shutdown", err)
 
     @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
     def test_shared_memory_untracking(self):
         # gh-82300: When a separate Python process accesses shared memory
         # with track=False, it must not cause the memory to be deleted
@@ -4694,6 +4720,7 @@ def test_shared_memory_untracking(self):
             mem.close()
 
     @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
     def test_shared_memory_tracking(self):
         # gh-82300: When a separate Python process accesses shared memory
         # with track=True, it must cause the memory to be deleted when
@@ -4787,6 +4814,8 @@ def test_finalize(self):
         result = [obj for obj in iter(conn.recv, 'STOP')]
         self.assertEqual(result, ['a', 'b', 'd10', 'd03', 'd02', 'd01', 'e'])
 
+    # TODO: RUSTPYTHON - gc.get_threshold() and gc.set_threshold() not implemented
+    @unittest.expectedFailure
     @support.requires_resource('cpu')
     def test_thread_safety(self):
         # bpo-24484: _run_finalizers() should be thread-safe
@@ -5414,6 +5443,8 @@ def run_in_child(cls, start_method):
         flags = (tuple(sys.flags), grandchild_flags)
         print(json.dumps(flags))
 
+    # TODO: RUSTPYTHON - SyntaxError in subprocess after fork
+    @unittest.expectedFailure
     def test_flags(self):
         import json
         # start child process using unusual flags
@@ -6457,28 +6488,13 @@ def test_std_streams_flushed_after_preload(self):
         if multiprocessing.get_start_method() != "forkserver":
             self.skipTest("forkserver specific test")
 
-        # Create a test module in the temporary directory on the child's path
-        # TODO: This can all be simplified once gh-126631 is fixed and we can
-        #       use __main__ instead of a module.
-        dirname = os.path.join(self._temp_dir, 'preloaded_module')
-        init_name = os.path.join(dirname, '__init__.py')
-        os.mkdir(dirname)
-        with open(init_name, "w") as f:
-            cmd = '''if 1:
-                import sys
-                print('stderr', end='', file=sys.stderr)
-                print('stdout', end='', file=sys.stdout)
-            '''
-            f.write(cmd)
-
         name = os.path.join(os.path.dirname(__file__), 'mp_preload_flush.py')
-        env = {'PYTHONPATH': self._temp_dir}
-        _, out, err = test.support.script_helper.assert_python_ok(name, **env)
+        _, out, err = test.support.script_helper.assert_python_ok(name)
 
         # Check stderr first, as it is more likely to be useful to see in the
         # event of a failure.
-        self.assertEqual(err.decode().rstrip(), 'stderr')
-        self.assertEqual(out.decode().rstrip(), 'stdout')
+        self.assertEqual(err.decode().rstrip(), '__main____mp_main__')
+        self.assertEqual(out.decode().rstrip(), '__main____mp_main__')
 
 
 class MiscTestCase(unittest.TestCase):
@@ -6804,3 +6820,52 @@ class SemLock(_multiprocessing.SemLock):
         name = f'test_semlock_subclass-{os.getpid()}'
         s = SemLock(1, 0, 10, name, False)
         _multiprocessing.sem_unlink(name)
+
+
+@unittest.skipUnless(HAS_SHMEM, "requires multiprocessing.shared_memory")
+class TestSharedMemoryNames(unittest.TestCase):
+    @subTests('use_simple_format', (True, False))
+    def test_that_shared_memory_name_with_colons_has_no_resource_tracker_errors(
+            self, use_simple_format):
+        # Test script that creates and cleans up shared memory with colon in name
+        test_script = textwrap.dedent("""
+            import sys
+            from multiprocessing import shared_memory
+            from multiprocessing import resource_tracker
+            import time
+
+            resource_tracker._resource_tracker._use_simple_format = %s
+
+            # Test various patterns of colons in names
+            test_names = [
+                "a:b",
+                "a:b:c",
+                "test:name:with:many:colons",
+                ":starts:with:colon",
+                "ends:with:colon:",
+                "::double::colons::",
+                "name\\nwithnewline",
+                "name-with-trailing-newline\\n",
+                "\\nname-starts-with-newline",
+                "colons:and\\nnewlines:mix",
+                "multi\\nline\\nname",
+            ]
+
+            for name in test_names:
+                try:
+                    shm = shared_memory.SharedMemory(create=True, size=100, name=name)
+                    shm.buf[:5] = b'hello'  # Write something to the shared memory
+                    shm.close()
+                    shm.unlink()
+
+                except Exception as e:
+                    print(f"Error with name '{name}': {e}", file=sys.stderr)
+                    sys.exit(1)
+
+            print("SUCCESS")
+        """ % use_simple_format)
+
+        rc, out, err = script_helper.assert_python_ok("-c", test_script)
+        self.assertIn(b"SUCCESS", out)
+        self.assertNotIn(b"traceback", err.lower(), err)
+        self.assertNotIn(b"resource_tracker.py", err, err)
diff --git a/Lib/test/mp_fork_bomb.py b/Lib/test/mp_fork_bomb.py
new file mode 100644
index 00000000000..017e010ba0e
--- /dev/null
+++ b/Lib/test/mp_fork_bomb.py
@@ -0,0 +1,18 @@
+import multiprocessing, sys
+
+def foo():
+    print("123")
+
+# Because "if __name__ == '__main__'" is missing this will not work
+# correctly on Windows.  However, we should get a RuntimeError rather
+# than the Windows equivalent of a fork bomb.
+
+if len(sys.argv) > 1:
+    multiprocessing.set_start_method(sys.argv[1])
+else:
+    multiprocessing.set_start_method('spawn')
+
+p = multiprocessing.Process(target=foo)
+p.start()
+p.join()
+sys.exit(p.exitcode)
diff --git a/Lib/test/mp_preload.py b/Lib/test/mp_preload.py
new file mode 100644
index 00000000000..5314e8f0b21
--- /dev/null
+++ b/Lib/test/mp_preload.py
@@ -0,0 +1,18 @@
+import multiprocessing
+
+multiprocessing.Lock()
+
+
+def f():
+    print("ok")
+
+
+if __name__ == "__main__":
+    ctx = multiprocessing.get_context("forkserver")
+    modname = "test.mp_preload"
+    # Make sure it's importable
+    __import__(modname)
+    ctx.set_forkserver_preload([modname])
+    proc = ctx.Process(target=f)
+    proc.start()
+    proc.join()
diff --git a/Lib/test/mp_preload_flush.py b/Lib/test/mp_preload_flush.py
new file mode 100644
index 00000000000..c195a9ef6b2
--- /dev/null
+++ b/Lib/test/mp_preload_flush.py
@@ -0,0 +1,11 @@
+import multiprocessing
+import sys
+
+print(__name__, end='', file=sys.stderr)
+print(__name__, end='', file=sys.stdout)
+if __name__ == '__main__':
+    multiprocessing.set_start_method('forkserver')
+    for _ in range(2):
+        p = multiprocessing.Process()
+        p.start()
+        p.join()
diff --git a/Lib/test/test_importlib/test_threaded_import.py b/Lib/test/test_importlib/test_threaded_import.py
index 148b2e4370b..3ceb86cbea3 100644
--- a/Lib/test/test_importlib/test_threaded_import.py
+++ b/Lib/test/test_importlib/test_threaded_import.py
@@ -256,8 +256,7 @@ def test_concurrent_futures_circular_import(self):
                           'partial', 'cfimport.py')
         script_helper.assert_python_ok(fn)
 
-    @unittest.skipUnless(hasattr(_multiprocessing, "SemLock"), "TODO: RUSTPYTHON, pool_in_threads.py needs _multiprocessing.SemLock")                                                                                      
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
+    @unittest.skip("TODO: RUSTPYTHON - fails on Linux due to multiprocessing issues")
     def test_multiprocessing_pool_circular_import(self):
         # Regression test for bpo-41567
         fn = os.path.join(os.path.dirname(__file__),
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 9004e9ed744..529cb2dc2f1 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -4058,7 +4058,8 @@ def _mpinit_issue121723(qspec, message_to_log):
         # log a message (this creates a record put in the queue)
         logging.getLogger().info(message_to_log)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ImportError: cannot import name 'SemLock'
+    # TODO: RUSTPYTHON - SemLock not implemented on Windows
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @skip_if_tsan_fork
     @support.requires_subprocess()
     def test_multiprocessing_queues(self):
@@ -4118,7 +4119,8 @@ def test_90195(self):
         # Logger should be enabled, since explicitly mentioned
         self.assertFalse(logger.disabled)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; ImportError: cannot import name 'SemLock'
+    # TODO: RUSTPYTHON - SemLock not implemented on Windows
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_111615(self):
         # See gh-111615
         import_helper.import_module('_multiprocessing')  # see gh-113692
diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
index 9ff2d3dc318..21b7bfa85c7 100644
--- a/crates/stdlib/src/multiprocessing.rs
+++ b/crates/stdlib/src/multiprocessing.rs
@@ -41,6 +41,696 @@ mod _multiprocessing {
     }
 }
 
-#[cfg(not(windows))]
+// Unix platforms (Linux, macOS, etc.)
+// macOS has broken sem_timedwait/sem_getvalue - we use polled fallback
+#[cfg(unix)]
+#[pymodule]
+mod _multiprocessing {
+    use crate::vm::{
+        Context, FromArgs, Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyDict, PyType, PyTypeRef},
+        function::{FuncArgs, KwArgs},
+        types::Constructor,
+    };
+    use libc::sem_t;
+    use nix::errno::Errno;
+    use std::{
+        ffi::CString,
+        sync::atomic::{AtomicI32, AtomicU64, Ordering},
+    };
+
+    /// Error type for sem_timedwait operations
+    #[cfg(target_vendor = "apple")]
+    enum SemWaitError {
+        Timeout,
+        SignalException(PyBaseExceptionRef),
+        OsError(Errno),
+    }
+
+    /// macOS fallback for sem_timedwait using select + sem_trywait polling
+    /// Matches sem_timedwait_save in semaphore.c
+    #[cfg(target_vendor = "apple")]
+    fn sem_timedwait_polled(
+        sem: *mut sem_t,
+        deadline: &libc::timespec,
+        vm: &VirtualMachine,
+    ) -> Result<(), SemWaitError> {
+        let mut delay: u64 = 0;
+
+        loop {
+            // poll: try to acquire
+            if unsafe { libc::sem_trywait(sem) } == 0 {
+                return Ok(());
+            }
+            let err = Errno::last();
+            if err != Errno::EAGAIN {
+                return Err(SemWaitError::OsError(err));
+            }
+
+            // get current time
+            let mut now = libc::timeval {
+                tv_sec: 0,
+                tv_usec: 0,
+            };
+            if unsafe { libc::gettimeofday(&mut now, std::ptr::null_mut()) } < 0 {
+                return Err(SemWaitError::OsError(Errno::last()));
+            }
+
+            // check for timeout
+            let deadline_usec = deadline.tv_sec * 1_000_000 + deadline.tv_nsec / 1000;
+            #[allow(clippy::unnecessary_cast)]
+            let now_usec = now.tv_sec as i64 * 1_000_000 + now.tv_usec as i64;
+
+            if now_usec >= deadline_usec {
+                return Err(SemWaitError::Timeout);
+            }
+
+            // calculate how much time is left
+            let difference = (deadline_usec - now_usec) as u64;
+
+            // check delay not too long -- maximum is 20 msecs
+            delay += 1000;
+            if delay > 20000 {
+                delay = 20000;
+            }
+            if delay > difference {
+                delay = difference;
+            }
+
+            // sleep using select
+            let mut tv_delay = libc::timeval {
+                tv_sec: (delay / 1_000_000) as _,
+                tv_usec: (delay % 1_000_000) as _,
+            };
+            unsafe {
+                libc::select(
+                    0,
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    &mut tv_delay,
+                )
+            };
+
+            // check for signals - preserve the exception (e.g., KeyboardInterrupt)
+            if let Err(exc) = vm.check_signals() {
+                return Err(SemWaitError::SignalException(exc));
+            }
+        }
+    }
+
+    // These match the values in Lib/multiprocessing/synchronize.py
+    const RECURSIVE_MUTEX: i32 = 0;
+    const SEMAPHORE: i32 = 1;
+
+    // #define ISMINE(o) (o->count > 0 && PyThread_get_thread_ident() == o->last_tid)
+    macro_rules! ismine {
+        ($self:expr) => {
+            $self.count.load(Ordering::Acquire) > 0
+                && $self.last_tid.load(Ordering::Acquire) == current_thread_id()
+        };
+    }
+
+    #[derive(FromArgs)]
+    struct SemLockNewArgs {
+        #[pyarg(positional)]
+        kind: i32,
+        #[pyarg(positional)]
+        value: i32,
+        #[pyarg(positional)]
+        maxvalue: i32,
+        #[pyarg(positional)]
+        name: String,
+        #[pyarg(positional)]
+        unlink: bool,
+    }
+
+    #[pyattr]
+    #[pyclass(name = "SemLock", module = "_multiprocessing")]
+    #[derive(Debug, PyPayload)]
+    struct SemLock {
+        handle: SemHandle,
+        kind: i32,
+        maxvalue: i32,
+        name: Option<String>,
+        last_tid: AtomicU64, // unsigned long
+        count: AtomicI32,    // int
+    }
+
+    #[derive(Debug)]
+    struct SemHandle {
+        raw: *mut sem_t,
+    }
+
+    unsafe impl Send for SemHandle {}
+    unsafe impl Sync for SemHandle {}
+
+    impl SemHandle {
+        fn create(
+            name: &str,
+            value: u32,
+            unlink: bool,
+            vm: &VirtualMachine,
+        ) -> PyResult<(Self, Option<String>)> {
+            let cname = semaphore_name(vm, name)?;
+            // SEM_CREATE(name, val, max) sem_open(name, O_CREAT | O_EXCL, 0600, val)
+            let raw = unsafe {
+                libc::sem_open(cname.as_ptr(), libc::O_CREAT | libc::O_EXCL, 0o600, value)
+            };
+            if raw == libc::SEM_FAILED {
+                let err = Errno::last();
+                return Err(os_error(vm, err));
+            }
+            if unlink {
+                // SEM_UNLINK(name) sem_unlink(name)
+                unsafe {
+                    libc::sem_unlink(cname.as_ptr());
+                }
+                Ok((SemHandle { raw }, None))
+            } else {
+                Ok((SemHandle { raw }, Some(name.to_owned())))
+            }
+        }
+
+        fn open_existing(name: &str, vm: &VirtualMachine) -> PyResult<Self> {
+            let cname = semaphore_name(vm, name)?;
+            let raw = unsafe { libc::sem_open(cname.as_ptr(), 0) };
+            if raw == libc::SEM_FAILED {
+                let err = Errno::last();
+                return Err(os_error(vm, err));
+            }
+            Ok(SemHandle { raw })
+        }
+
+        #[inline]
+        fn as_ptr(&self) -> *mut sem_t {
+            self.raw
+        }
+    }
+
+    impl Drop for SemHandle {
+        fn drop(&mut self) {
+            // Guard against default/uninitialized state.
+            // Note: SEM_FAILED is (sem_t*)-1, not null, but valid handles are never null
+            // and SEM_FAILED is never stored (error is returned immediately on sem_open failure).
+            if !self.raw.is_null() {
+                // SEM_CLOSE(sem) sem_close(sem)
+                unsafe {
+                    libc::sem_close(self.raw);
+                }
+            }
+        }
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl SemLock {
+        #[pygetset]
+        fn handle(&self) -> isize {
+            self.handle.as_ptr() as isize
+        }
+
+        #[pygetset]
+        fn kind(&self) -> i32 {
+            self.kind
+        }
+
+        #[pygetset]
+        fn maxvalue(&self) -> i32 {
+            self.maxvalue
+        }
+
+        #[pygetset]
+        fn name(&self) -> Option<String> {
+            self.name.clone()
+        }
+
+        /// Acquire the semaphore/lock.
+        // _multiprocessing_SemLock_acquire_impl
+        #[pymethod]
+        fn acquire(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<bool> {
+            // block=True, timeout=None
+
+            let blocking: bool = args
+                .kwargs
+                .get("block")
+                .or_else(|| args.args.first())
+                .map(|o| o.clone().try_to_bool(vm))
+                .transpose()?
+                .unwrap_or(true);
+
+            let timeout_obj = args
+                .kwargs
+                .get("timeout")
+                .or_else(|| args.args.get(1))
+                .cloned();
+
+            if self.kind == RECURSIVE_MUTEX && ismine!(self) {
+                self.count.fetch_add(1, Ordering::Release);
+                return Ok(true);
+            }
+
+            // timeout_obj != Py_None
+            let use_deadline = timeout_obj.as_ref().is_some_and(|o| !vm.is_none(o));
+
+            let deadline = if use_deadline {
+                let timeout_obj = timeout_obj.unwrap();
+                // This accepts both int and float, converting to f64
+                let timeout: f64 = timeout_obj.try_float(vm)?.to_f64();
+                let timeout = if timeout < 0.0 { 0.0 } else { timeout };
+
+                let mut tv = libc::timeval {
+                    tv_sec: 0,
+                    tv_usec: 0,
+                };
+                let res = unsafe { libc::gettimeofday(&mut tv, std::ptr::null_mut()) };
+                if res < 0 {
+                    return Err(vm.new_os_error("gettimeofday failed".to_string()));
+                }
+
+                // deadline calculation:
+                // long sec = (long) timeout;
+                // long nsec = (long) (1e9 * (timeout - sec) + 0.5);
+                // deadline.tv_sec = now.tv_sec + sec;
+                // deadline.tv_nsec = now.tv_usec * 1000 + nsec;
+                // deadline.tv_sec += (deadline.tv_nsec / 1000000000);
+                // deadline.tv_nsec %= 1000000000;
+                let sec = timeout as libc::c_long;
+                let nsec = (1e9 * (timeout - sec as f64) + 0.5) as libc::c_long;
+                let mut deadline = libc::timespec {
+                    tv_sec: tv.tv_sec + sec as libc::time_t,
+                    tv_nsec: (tv.tv_usec as libc::c_long * 1000 + nsec) as _,
+                };
+                deadline.tv_sec += (deadline.tv_nsec / 1_000_000_000) as libc::time_t;
+                deadline.tv_nsec %= 1_000_000_000;
+                Some(deadline)
+            } else {
+                None
+            };
+
+            // Check whether we can acquire without releasing the GIL and blocking
+            let mut res;
+            loop {
+                res = unsafe { libc::sem_trywait(self.handle.as_ptr()) };
+                if res >= 0 {
+                    break;
+                }
+                let err = Errno::last();
+                if err == Errno::EINTR {
+                    vm.check_signals()?;
+                    continue;
+                }
+                break;
+            }
+
+            // if (res < 0 && errno == EAGAIN && blocking)
+            if res < 0 && Errno::last() == Errno::EAGAIN && blocking {
+                // Couldn't acquire immediately, need to block
+                #[cfg(not(target_vendor = "apple"))]
+                {
+                    loop {
+                        // Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS
+                        // RustPython doesn't have GIL, so we just do the wait
+                        if let Some(ref dl) = deadline {
+                            res = unsafe { libc::sem_timedwait(self.handle.as_ptr(), dl) };
+                        } else {
+                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
+                        }
+
+                        if res >= 0 {
+                            break;
+                        }
+                        let err = Errno::last();
+                        if err == Errno::EINTR {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                #[cfg(target_vendor = "apple")]
+                {
+                    // macOS: use polled fallback since sem_timedwait is not available
+                    if let Some(ref dl) = deadline {
+                        match sem_timedwait_polled(self.handle.as_ptr(), dl, vm) {
+                            Ok(()) => res = 0,
+                            Err(SemWaitError::Timeout) => {
+                                // Timeout occurred - return false directly
+                                return Ok(false);
+                            }
+                            Err(SemWaitError::SignalException(exc)) => {
+                                // Propagate the original exception (e.g., KeyboardInterrupt)
+                                return Err(exc);
+                            }
+                            Err(SemWaitError::OsError(e)) => {
+                                return Err(os_error(vm, e));
+                            }
+                        }
+                    } else {
+                        // No timeout: use sem_wait (available on macOS)
+                        loop {
+                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
+                            if res >= 0 {
+                                break;
+                            }
+                            let err = Errno::last();
+                            if err == Errno::EINTR {
+                                vm.check_signals()?;
+                                continue;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // result handling:
+            if res < 0 {
+                let err = Errno::last();
+                match err {
+                    Errno::EAGAIN | Errno::ETIMEDOUT => return Ok(false),
+                    Errno::EINTR => {
+                        // EINTR should be handled by the check_signals() loop above
+                        // If we reach here, check signals again and propagate any exception
+                        return vm.check_signals().map(|_| false);
+                    }
+                    _ => return Err(os_error(vm, err)),
+                }
+            }
+
+            self.count.fetch_add(1, Ordering::Release);
+            self.last_tid.store(current_thread_id(), Ordering::Release);
+
+            Ok(true)
+        }
+
+        /// Release the semaphore/lock.
+        // _multiprocessing_SemLock_release_impl
+        #[pymethod]
+        fn release(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.kind == RECURSIVE_MUTEX {
+                // if (!ISMINE(self))
+                if !ismine!(self) {
+                    return Err(vm.new_exception_msg(
+                        vm.ctx.exceptions.assertion_error.to_owned(),
+                        "attempt to release recursive lock not owned by thread".to_owned(),
+                    ));
+                }
+                // if (self->count > 1) { --self->count; Py_RETURN_NONE; }
+                if self.count.load(Ordering::Acquire) > 1 {
+                    self.count.fetch_sub(1, Ordering::Release);
+                    return Ok(());
+                }
+                // assert(self->count == 1);
+            } else {
+                // SEMAPHORE case: check value before releasing
+                #[cfg(not(target_vendor = "apple"))]
+                {
+                    // Linux: use sem_getvalue
+                    let mut sval: libc::c_int = 0;
+                    let res = unsafe { libc::sem_getvalue(self.handle.as_ptr(), &mut sval) };
+                    if res < 0 {
+                        return Err(os_error(vm, Errno::last()));
+                    }
+                    if sval >= self.maxvalue {
+                        return Err(vm.new_value_error(
+                            "semaphore or lock released too many times".to_owned(),
+                        ));
+                    }
+                }
+                #[cfg(target_vendor = "apple")]
+                {
+                    // macOS: HAVE_BROKEN_SEM_GETVALUE
+                    // We will only check properly the maxvalue == 1 case
+                    if self.maxvalue == 1 {
+                        // make sure that already locked
+                        if unsafe { libc::sem_trywait(self.handle.as_ptr()) } < 0 {
+                            if Errno::last() != Errno::EAGAIN {
+                                return Err(os_error(vm, Errno::last()));
+                            }
+                            // it is already locked as expected
+                        } else {
+                            // it was not locked so undo wait and raise
+                            if unsafe { libc::sem_post(self.handle.as_ptr()) } < 0 {
+                                return Err(os_error(vm, Errno::last()));
+                            }
+                            return Err(vm.new_value_error(
+                                "semaphore or lock released too many times".to_owned(),
+                            ));
+                        }
+                    }
+                }
+            }
+
+            let res = unsafe { libc::sem_post(self.handle.as_ptr()) };
+            if res < 0 {
+                return Err(os_error(vm, Errno::last()));
+            }
+
+            self.count.fetch_sub(1, Ordering::Release);
+            Ok(())
+        }
+
+        /// Enter the semaphore/lock (context manager).
+        // _multiprocessing_SemLock___enter___impl
+        #[pymethod(name = "__enter__")]
+        fn enter(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            // return _multiprocessing_SemLock_acquire_impl(self, 1, Py_None);
+            self.acquire(
+                FuncArgs::new::<Vec<_>, KwArgs>(
+                    vec![vm.ctx.new_bool(true).into()],
+                    KwArgs::default(),
+                ),
+                vm,
+            )
+        }
+
+        /// Exit the semaphore/lock (context manager).
+        // _multiprocessing_SemLock___exit___impl
+        #[pymethod]
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.release(vm)
+        }
+
+        /// Rebuild a SemLock from pickled state.
+        // _multiprocessing_SemLock__rebuild_impl
+        #[pyclassmethod(name = "_rebuild")]
+        fn rebuild(
+            cls: PyTypeRef,
+            _handle: isize,
+            kind: i32,
+            maxvalue: i32,
+            name: Option<String>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let Some(ref name_str) = name else {
+                return Err(vm.new_value_error("cannot rebuild SemLock without name".to_owned()));
+            };
+            let handle = SemHandle::open_existing(name_str, vm)?;
+            // return newsemlockobject(type, handle, kind, maxvalue, name_copy);
+            let zelf = SemLock {
+                handle,
+                kind,
+                maxvalue,
+                name,
+                last_tid: AtomicU64::new(0),
+                count: AtomicI32::new(0),
+            };
+            zelf.into_ref_with_type(vm, cls).map(Into::into)
+        }
+
+        /// Rezero the net acquisition count after fork().
+        // _multiprocessing_SemLock__after_fork_impl
+        #[pymethod]
+        fn _after_fork(&self) {
+            self.count.store(0, Ordering::Release);
+            // Also reset last_tid for safety
+            self.last_tid.store(0, Ordering::Release);
+        }
+
+        /// Num of `acquire()`s minus num of `release()`s for this process.
+        // _multiprocessing_SemLock__count_impl
+        #[pymethod]
+        fn _count(&self) -> i32 {
+            self.count.load(Ordering::Acquire)
+        }
+
+        /// Whether the lock is owned by this thread.
+        // _multiprocessing_SemLock__is_mine_impl
+        #[pymethod]
+        fn _is_mine(&self) -> bool {
+            ismine!(self)
+        }
+
+        /// Get the value of the semaphore.
+        // _multiprocessing_SemLock__get_value_impl
+        #[pymethod]
+        fn _get_value(&self, vm: &VirtualMachine) -> PyResult<i32> {
+            #[cfg(not(target_vendor = "apple"))]
+            {
+                // Linux: use sem_getvalue
+                let mut sval: libc::c_int = 0;
+                let res = unsafe { libc::sem_getvalue(self.handle.as_ptr(), &mut sval) };
+                if res < 0 {
+                    return Err(os_error(vm, Errno::last()));
+                }
+                // some posix implementations use negative numbers to indicate
+                // the number of waiting threads
+                Ok(if sval < 0 { 0 } else { sval })
+            }
+            #[cfg(target_vendor = "apple")]
+            {
+                // macOS: HAVE_BROKEN_SEM_GETVALUE - raise NotImplementedError
+                Err(vm.new_not_implemented_error(String::new()))
+            }
+        }
+
+        /// Return whether semaphore has value zero.
+        // _multiprocessing_SemLock__is_zero_impl
+        #[pymethod]
+        fn _is_zero(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            #[cfg(not(target_vendor = "apple"))]
+            {
+                Ok(self._get_value(vm)? == 0)
+            }
+            #[cfg(target_vendor = "apple")]
+            {
+                // macOS: HAVE_BROKEN_SEM_GETVALUE
+                // Try to acquire - if EAGAIN, value is 0
+                if unsafe { libc::sem_trywait(self.handle.as_ptr()) } < 0 {
+                    if Errno::last() == Errno::EAGAIN {
+                        return Ok(true);
+                    }
+                    return Err(os_error(vm, Errno::last()));
+                }
+                // Successfully acquired - undo and return false
+                if unsafe { libc::sem_post(self.handle.as_ptr()) } < 0 {
+                    return Err(os_error(vm, Errno::last()));
+                }
+                Ok(false)
+            }
+        }
+
+        #[extend_class]
+        fn extend_class(ctx: &Context, class: &Py<PyType>) {
+            class.set_attr(
+                ctx.intern_str("RECURSIVE_MUTEX"),
+                ctx.new_int(RECURSIVE_MUTEX).into(),
+            );
+            class.set_attr(ctx.intern_str("SEMAPHORE"), ctx.new_int(SEMAPHORE).into());
+            // SEM_VALUE_MAX from system, or INT_MAX if negative
+            // We use a reasonable default
+            let sem_value_max: i32 = unsafe {
+                let val = libc::sysconf(libc::_SC_SEM_VALUE_MAX);
+                if val < 0 || val > i32::MAX as libc::c_long {
+                    i32::MAX
+                } else {
+                    val as i32
+                }
+            };
+            class.set_attr(
+                ctx.intern_str("SEM_VALUE_MAX"),
+                ctx.new_int(sem_value_max).into(),
+            );
+        }
+    }
+
+    impl Constructor for SemLock {
+        type Args = SemLockNewArgs;
+
+        // Create a new SemLock.
+        // _multiprocessing_SemLock_impl
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            if args.kind != RECURSIVE_MUTEX && args.kind != SEMAPHORE {
+                return Err(vm.new_value_error("unrecognized kind".to_owned()));
+            }
+            // Value validation
+            if args.value < 0 || args.value > args.maxvalue {
+                return Err(vm.new_value_error("invalid value".to_owned()));
+            }
+
+            let value = args.value as u32;
+            let (handle, name) = SemHandle::create(&args.name, value, args.unlink, vm)?;
+
+            // return newsemlockobject(type, handle, kind, maxvalue, name_copy);
+            Ok(SemLock {
+                handle,
+                kind: args.kind,
+                maxvalue: args.maxvalue,
+                name,
+                last_tid: AtomicU64::new(0),
+                count: AtomicI32::new(0),
+            })
+        }
+    }
+
+    /// Function to unlink semaphore names.
+    // _PyMp_sem_unlink.
+    #[pyfunction]
+    fn sem_unlink(name: String, vm: &VirtualMachine) -> PyResult<()> {
+        let cname = semaphore_name(vm, &name)?;
+        let res = unsafe { libc::sem_unlink(cname.as_ptr()) };
+        if res < 0 {
+            return Err(os_error(vm, Errno::last()));
+        }
+        Ok(())
+    }
+
+    /// Module-level flags dict.
+    #[pyattr]
+    fn flags(vm: &VirtualMachine) -> PyRef<PyDict> {
+        let flags = vm.ctx.new_dict();
+        // HAVE_SEM_OPEN is always 1 on Unix (we wouldn't be here otherwise)
+        flags
+            .set_item("HAVE_SEM_OPEN", vm.ctx.new_int(1).into(), vm)
+            .unwrap();
+
+        #[cfg(not(target_vendor = "apple"))]
+        {
+            // Linux: HAVE_SEM_TIMEDWAIT is available
+            flags
+                .set_item("HAVE_SEM_TIMEDWAIT", vm.ctx.new_int(1).into(), vm)
+                .unwrap();
+        }
+
+        #[cfg(target_vendor = "apple")]
+        {
+            // macOS: sem_getvalue is broken
+            flags
+                .set_item("HAVE_BROKEN_SEM_GETVALUE", vm.ctx.new_int(1).into(), vm)
+                .unwrap();
+        }
+
+        flags
+    }
+
+    fn semaphore_name(vm: &VirtualMachine, name: &str) -> PyResult<CString> {
+        // POSIX semaphore names must start with /
+        let mut full = String::with_capacity(name.len() + 1);
+        if !name.starts_with('/') {
+            full.push('/');
+        }
+        full.push_str(name);
+        CString::new(full).map_err(|_| vm.new_value_error("embedded null character".to_owned()))
+    }
+
+    fn os_error(vm: &VirtualMachine, err: Errno) -> PyBaseExceptionRef {
+        // _PyMp_SetError maps to PyErr_SetFromErrno
+        let exc_type = match err {
+            Errno::EEXIST => vm.ctx.exceptions.file_exists_error.to_owned(),
+            Errno::ENOENT => vm.ctx.exceptions.file_not_found_error.to_owned(),
+            _ => vm.ctx.exceptions.os_error.to_owned(),
+        };
+        vm.new_os_subtype_error(exc_type, Some(err as i32), err.desc().to_owned())
+            .upcast()
+    }
+
+    /// Get current thread identifier.
+    /// PyThread_get_thread_ident on Unix (pthread_self).
+    fn current_thread_id() -> u64 {
+        unsafe { libc::pthread_self() as u64 }
+    }
+}
+
+#[cfg(all(not(unix), not(windows)))]
 #[pymodule]
 mod _multiprocessing {}
diff --git a/crates/stdlib/src/posixshmem.rs b/crates/stdlib/src/posixshmem.rs
index 53bf372532d..a52866b7985 100644
--- a/crates/stdlib/src/posixshmem.rs
+++ b/crates/stdlib/src/posixshmem.rs
@@ -8,25 +8,27 @@ mod _posixshmem {
 
     use crate::{
         common::os::errno_io_error,
-        vm::{
-            PyResult, VirtualMachine, builtins::PyStrRef, convert::IntoPyException,
-            function::OptionalArg,
-        },
+        vm::{FromArgs, PyResult, VirtualMachine, builtins::PyStrRef, convert::IntoPyException},
     };
 
-    #[pyfunction]
-    fn shm_open(
+    #[derive(FromArgs)]
+    struct ShmOpenArgs {
+        #[pyarg(any)]
         name: PyStrRef,
+        #[pyarg(any)]
         flags: libc::c_int,
-        mode: OptionalArg<libc::mode_t>,
-        vm: &VirtualMachine,
-    ) -> PyResult<libc::c_int> {
-        let name = CString::new(name.as_str()).map_err(|e| e.into_pyexception(vm))?;
-        let mode: libc::c_uint = mode.unwrap_or(0o600) as _;
+        #[pyarg(any, default = 0o600)]
+        mode: libc::mode_t,
+    }
+
+    #[pyfunction]
+    fn shm_open(args: ShmOpenArgs, vm: &VirtualMachine) -> PyResult<libc::c_int> {
+        let name = CString::new(args.name.as_str()).map_err(|e| e.into_pyexception(vm))?;
+        let mode: libc::c_uint = args.mode as _;
         #[cfg(target_os = "freebsd")]
         let mode = mode.try_into().unwrap();
         // SAFETY: `name` is a NUL-terminated string and `shm_open` does not write through it.
-        let fd = unsafe { libc::shm_open(name.as_ptr(), flags, mode) };
+        let fd = unsafe { libc::shm_open(name.as_ptr(), args.flags, mode) };
         if fd == -1 {
             Err(errno_io_error().into_pyexception(vm))
         } else {
diff --git a/crates/stdlib/src/pystruct.rs b/crates/stdlib/src/pystruct.rs
index 34a4905ed9f..8801f0d705e 100644
--- a/crates/stdlib/src/pystruct.rs
+++ b/crates/stdlib/src/pystruct.rs
@@ -71,7 +71,7 @@ pub(crate) mod _struct {
             } else {
                 ("unpack_from", "unpacking")
             };
-            if offset >= buffer_len {
+            if offset + needed > buffer_len {
                 let msg = format!(
                     "{op} requires a buffer of at least {required} bytes for {op_action} {needed} \
                     bytes at offset {offset} (actual buffer size is {buffer_len})",

From 0eddee500ace0102b090abd13df94b01158e2d75 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 3 Jan 2026 00:15:31 +0900
Subject: [PATCH 156/418] fix fcntl, sslsocket traverse, super , excepthook
 (#6623)

* fix fcntl

* fix traverse

* fix super

* excepthook

* fix warn
---
 Lib/test/test_super.py          |   2 -
 crates/stdlib/src/fcntl.rs      |   6 +-
 crates/stdlib/src/ssl.rs        |  12 ++-
 crates/vm/src/builtins/super.rs |   7 +-
 crates/vm/src/stdlib/thread.rs  | 132 ++++++++++++++++++++++++++++++++
 crates/vm/src/warn.rs           |  14 +++-
 6 files changed, 166 insertions(+), 7 deletions(-)

diff --git a/Lib/test/test_super.py b/Lib/test/test_super.py
index 76eda799da4..5548f4c71a2 100644
--- a/Lib/test/test_super.py
+++ b/Lib/test/test_super.py
@@ -344,7 +344,6 @@ def test_super_argcount(self):
         with self.assertRaisesRegex(TypeError, "expected at most"):
             super(int, int, int)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: "argument 1 must be a type" does not match "Expected type 'type' but 'int' found."
     def test_super_argtype(self):
         with self.assertRaisesRegex(TypeError, "argument 1 must be a type"):
             super(1, int)
@@ -409,7 +408,6 @@ def method(self):
         with self.assertRaisesRegex(AttributeError, "'super' object has no attribute 'msg'"):
             C().method()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: "argument 1 must be a type" does not match "Expected type 'type' but 'int' found."
     def test_bad_first_arg(self):
         class C:
             def method(self):
diff --git a/crates/stdlib/src/fcntl.rs b/crates/stdlib/src/fcntl.rs
index 822faeeedaa..477c1f54210 100644
--- a/crates/stdlib/src/fcntl.rs
+++ b/crates/stdlib/src/fcntl.rs
@@ -92,11 +92,15 @@ mod fcntl {
     #[pyfunction]
     fn ioctl(
         io::Fildes(fd): io::Fildes,
-        request: u32,
+        request: i64,
         arg: OptionalArg<Either<Either<ArgMemoryBuffer, ArgStrOrBytesLike>, i32>>,
         mutate_flag: OptionalArg<bool>,
         vm: &VirtualMachine,
     ) -> PyResult {
+        // Convert to unsigned - handles both positive u32 values and negative i32 values
+        // that represent the same bit pattern (e.g., TIOCSWINSZ on some platforms).
+        // First truncate to u32 (takes lower 32 bits), then zero-extend to c_ulong.
+        let request = (request as u32) as libc::c_ulong;
         let arg = arg.unwrap_or_else(|| Either::B(0));
         match arg {
             Either::A(buf_kind) => {
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index b90176a62fa..c22dd303c59 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -2293,7 +2293,7 @@ mod _ssl {
 
     // SSLSocket - represents a TLS-wrapped socket
     #[pyattr]
-    #[pyclass(name = "_SSLSocket", module = "ssl")]
+    #[pyclass(name = "_SSLSocket", module = "ssl", traverse)]
     #[derive(Debug, PyPayload)]
     pub(crate) struct PySSLSocket {
         // Underlying socket
@@ -2301,14 +2301,19 @@ mod _ssl {
         // SSL context
         context: PyRwLock<PyRef<PySSLContext>>,
         // Server-side or client-side
+        #[pytraverse(skip)]
         server_side: bool,
         // Server hostname for SNI
+        #[pytraverse(skip)]
         server_hostname: PyRwLock<Option<String>>,
         // TLS connection state
+        #[pytraverse(skip)]
         connection: PyMutex<Option<TlsConnection>>,
         // Handshake completed flag
+        #[pytraverse(skip)]
         handshake_done: PyMutex<bool>,
         // Session was reused (for session resumption tracking)
+        #[pytraverse(skip)]
         session_was_reused: PyMutex<bool>,
         // Owner (SSLSocket instance that owns this _SSLSocket)
         owner: PyRwLock<Option<PyObjectRef>>,
@@ -2316,22 +2321,27 @@ mod _ssl {
         session: PyRwLock<Option<PyObjectRef>>,
         // Verified certificate chain (built during verification)
         #[allow(dead_code)]
+        #[pytraverse(skip)]
         verified_chain: PyRwLock<Option<Vec<CertificateDer<'static>>>>,
         // MemoryBIO mode (optional)
         incoming_bio: Option<PyRef<PyMemoryBIO>>,
         outgoing_bio: Option<PyRef<PyMemoryBIO>>,
         // SNI certificate resolver state (for server-side only)
+        #[pytraverse(skip)]
         sni_state: PyRwLock<Option<Arc<ParkingMutex<SniCertName>>>>,
         // Pending context change (for SNI callback deferred handling)
         pending_context: PyRwLock<Option<PyRef<PySSLContext>>>,
         // Buffer to store ClientHello for connection recreation
+        #[pytraverse(skip)]
         client_hello_buffer: PyMutex<Option<Vec<u8>>>,
         // Shutdown state for tracking close-notify exchange
+        #[pytraverse(skip)]
         shutdown_state: PyMutex<ShutdownState>,
         // Deferred client certificate verification error (for TLS 1.3)
         // Stores error message if client cert verification failed during handshake
         // Error is raised on first I/O operation after handshake
         // Using Arc to share with the certificate verifier
+        #[pytraverse(skip)]
         deferred_cert_error: Arc<ParkingRwLock<Option<String>>>,
     }
 
diff --git a/crates/vm/src/builtins/super.rs b/crates/vm/src/builtins/super.rs
index f0d873abfbb..893509bc6d3 100644
--- a/crates/vm/src/builtins/super.rs
+++ b/crates/vm/src/builtins/super.rs
@@ -61,7 +61,7 @@ impl Constructor for PySuper {
 #[derive(FromArgs)]
 pub struct InitArgs {
     #[pyarg(positional, optional)]
-    py_type: OptionalArg<PyTypeRef>,
+    py_type: OptionalArg<PyObjectRef>,
     #[pyarg(positional, optional)]
     py_obj: OptionalArg<PyObjectRef>,
 }
@@ -75,7 +75,10 @@ impl Initializer for PySuper {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         // Get the type:
-        let (typ, obj) = if let OptionalArg::Present(ty) = py_type {
+        let (typ, obj) = if let OptionalArg::Present(ty_obj) = py_type {
+            let ty = ty_obj
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("super() argument 1 must be a type"))?;
             (ty, py_obj.unwrap_or_none(vm))
         } else {
             let frame = vm
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index eb881911659..b7f00537c26 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -400,6 +400,138 @@ pub(crate) mod _thread {
         vm.state.thread_count.load()
     }
 
+    /// ExceptHookArgs - simple class to hold exception hook arguments
+    /// This allows threading.py to import _excepthook and _ExceptHookArgs from _thread
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "_ExceptHookArgs")]
+    #[derive(Debug, PyPayload)]
+    struct ExceptHookArgs {
+        exc_type: crate::PyObjectRef,
+        exc_value: crate::PyObjectRef,
+        exc_traceback: crate::PyObjectRef,
+        thread: crate::PyObjectRef,
+    }
+
+    #[pyclass(with(Constructor))]
+    impl ExceptHookArgs {
+        #[pygetset]
+        fn exc_type(&self) -> crate::PyObjectRef {
+            self.exc_type.clone()
+        }
+
+        #[pygetset]
+        fn exc_value(&self) -> crate::PyObjectRef {
+            self.exc_value.clone()
+        }
+
+        #[pygetset]
+        fn exc_traceback(&self) -> crate::PyObjectRef {
+            self.exc_traceback.clone()
+        }
+
+        #[pygetset]
+        fn thread(&self) -> crate::PyObjectRef {
+            self.thread.clone()
+        }
+    }
+
+    impl Constructor for ExceptHookArgs {
+        // Takes a single iterable argument like namedtuple
+        type Args = (crate::PyObjectRef,);
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            // Convert the argument to a list/tuple and extract elements
+            let seq: Vec<crate::PyObjectRef> = args.0.try_to_value(vm)?;
+            if seq.len() != 4 {
+                return Err(vm.new_type_error(format!(
+                    "_ExceptHookArgs expected 4 arguments, got {}",
+                    seq.len()
+                )));
+            }
+            Ok(Self {
+                exc_type: seq[0].clone(),
+                exc_value: seq[1].clone(),
+                exc_traceback: seq[2].clone(),
+                thread: seq[3].clone(),
+            })
+        }
+    }
+
+    /// Handle uncaught exception in Thread.run()
+    #[pyfunction]
+    fn _excepthook(args: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Type check: args must be _ExceptHookArgs
+        let args = args.downcast::<ExceptHookArgs>().map_err(|_| {
+            vm.new_type_error(
+                "_thread._excepthook argument type must be _ExceptHookArgs".to_owned(),
+            )
+        })?;
+
+        let exc_type = args.exc_type.clone();
+        let exc_value = args.exc_value.clone();
+        let exc_traceback = args.exc_traceback.clone();
+        let thread = args.thread.clone();
+
+        // Silently ignore SystemExit (identity check)
+        if exc_type.is(vm.ctx.exceptions.system_exit.as_ref()) {
+            return Ok(());
+        }
+
+        // Get stderr - fall back to thread._stderr if sys.stderr is None
+        let file = match vm.sys_module.get_attr("stderr", vm) {
+            Ok(stderr) if !vm.is_none(&stderr) => stderr,
+            _ => {
+                if vm.is_none(&thread) {
+                    // do nothing if sys.stderr is None and thread is None
+                    return Ok(());
+                }
+                let thread_stderr = thread.get_attr("_stderr", vm)?;
+                if vm.is_none(&thread_stderr) {
+                    // do nothing if sys.stderr is None and sys.stderr was None
+                    // when the thread was created
+                    return Ok(());
+                }
+                thread_stderr
+            }
+        };
+
+        // Print "Exception in thread {thread.name}:"
+        let thread_name = if !vm.is_none(&thread) {
+            thread
+                .get_attr("name", vm)
+                .ok()
+                .and_then(|n| n.str(vm).ok())
+                .map(|s| s.as_str().to_owned())
+        } else {
+            None
+        };
+        let name = thread_name.unwrap_or_else(|| format!("{}", get_ident()));
+
+        let _ = vm.call_method(
+            &file,
+            "write",
+            (format!("Exception in thread {}:\n", name),),
+        );
+
+        // Display the traceback
+        if let Ok(traceback_mod) = vm.import("traceback", 0)
+            && let Ok(print_exc) = traceback_mod.get_attr("print_exception", vm)
+        {
+            use crate::function::KwArgs;
+            let kwargs: KwArgs = vec![("file".to_owned(), file.clone())]
+                .into_iter()
+                .collect();
+            let _ = print_exc.call_with_args(
+                crate::function::FuncArgs::new(vec![exc_type, exc_value, exc_traceback], kwargs),
+                vm,
+            );
+        }
+
+        // Flush file
+        let _ = vm.call_method(&file, "flush", ());
+        Ok(())
+    }
+
     #[pyattr]
     #[pyclass(module = "thread", name = "_local")]
     #[derive(Debug, PyPayload)]
diff --git a/crates/vm/src/warn.rs b/crates/vm/src/warn.rs
index 09d48078e56..b7249da19fe 100644
--- a/crates/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -404,8 +404,20 @@ fn setup_context(
 
     let (globals, filename, lineno) = if let Some(f) = f {
         (f.globals.clone(), f.code.source_path, f.f_lineno())
+    } else if let Some(frame) = vm.current_frame() {
+        // We have a frame but it wasn't found during stack walking
+        (frame.globals.clone(), vm.ctx.intern_str("<sys>"), 1)
     } else {
-        (vm.current_globals().clone(), vm.ctx.intern_str("sys"), 1)
+        // No frames on the stack - use sys.__dict__ (interp->sysdict)
+        let globals = vm
+            .sys_module
+            .as_object()
+            .get_attr(identifier!(vm, __dict__), vm)
+            .and_then(|d| {
+                d.downcast::<crate::builtins::PyDict>()
+                    .map_err(|_| vm.new_type_error("sys.__dict__ is not a dictionary"))
+            })?;
+        (globals, vm.ctx.intern_str("<sys>"), 0)
     };
 
     let registry = if let Ok(registry) = globals.get_item(__warningregistry__, vm) {

From 52dd8292c4ba23e3032731cddc808ae1f0b2c1b4 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Fri, 2 Jan 2026 18:27:18 -0500
Subject: [PATCH 157/418] Updated enum + file_cmp library + tests - v3.13.10
 (#6606)

* Updated enum library

* Updated filecmp + file_cmp test

* Removed unneeded @unittest.expectedFailures

* Updated unexpected success in enum test

* Fixed unexpected success in test_filecmp
---
 Lib/enum.py                   | 473 +++++++++++++++----------
 Lib/filecmp.py                |  23 +-
 Lib/test/test_ast/test_ast.py |   1 -
 Lib/test/test_enum.py         | 645 +++++++++++++++++++++++++++-------
 Lib/test/test_filecmp.py      | 171 +++++++--
 Lib/test/test_ssl.py          |   4 -
 Lib/test/test_uuid.py         |   1 -
 7 files changed, 974 insertions(+), 344 deletions(-)

diff --git a/Lib/enum.py b/Lib/enum.py
index 7cffb71863c..3adb208c7e6 100644
--- a/Lib/enum.py
+++ b/Lib/enum.py
@@ -1,12 +1,11 @@
 import sys
 import builtins as bltns
+from functools import partial
 from types import MappingProxyType, DynamicClassAttribute
-from operator import or_ as _or_
-from functools import reduce
 
 
 __all__ = [
-        'EnumType', 'EnumMeta',
+        'EnumType', 'EnumMeta', 'EnumDict',
         'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag', 'ReprEnum',
         'auto', 'unique', 'property', 'verify', 'member', 'nonmember',
         'FlagBoundary', 'STRICT', 'CONFORM', 'EJECT', 'KEEP',
@@ -39,7 +38,7 @@ def _is_descriptor(obj):
     """
     Returns True if obj is a descriptor, False otherwise.
     """
-    return (
+    return not isinstance(obj, partial) and (
             hasattr(obj, '__get__') or
             hasattr(obj, '__set__') or
             hasattr(obj, '__delete__')
@@ -63,8 +62,8 @@ def _is_sunder(name):
     return (
             len(name) > 2 and
             name[0] == name[-1] == '_' and
-            name[1:2] != '_' and
-            name[-2:-1] != '_'
+            name[1] != '_' and
+            name[-2] != '_'
             )
 
 def _is_internal_class(cls_name, obj):
@@ -83,7 +82,6 @@ def _is_private(cls_name, name):
     if (
             len(name) > pat_len
             and name.startswith(pattern)
-            and name[pat_len:pat_len+1] != ['_']
             and (name[-1] != '_' or name[-2] != '_')
         ):
         return True
@@ -158,7 +156,6 @@ def _dedent(text):
     Like textwrap.dedent.  Rewritten because we cannot import textwrap.
     """
     lines = text.split('\n')
-    blanks = 0
     for i, ch in enumerate(lines[0]):
         if ch != ' ':
             break
@@ -166,6 +163,11 @@ def _dedent(text):
         lines[j] = l[i:]
     return '\n'.join(lines)
 
+class _not_given:
+    def __repr__(self):
+        return('<not given>')
+_not_given = _not_given()
+
 class _auto_null:
     def __repr__(self):
         return '_auto_null'
@@ -283,9 +285,10 @@ def __set_name__(self, enum_class, member_name):
         enum_member._sort_order_ = len(enum_class._member_names_)
 
         if Flag is not None and issubclass(enum_class, Flag):
-            enum_class._flag_mask_ |= value
-            if _is_single_bit(value):
-                enum_class._singles_mask_ |= value
+            if isinstance(value, int):
+                enum_class._flag_mask_ |= value
+                if _is_single_bit(value):
+                    enum_class._singles_mask_ |= value
             enum_class._all_bits_ = 2 ** ((enum_class._flag_mask_).bit_length()) - 1
 
         # If another member with the same value was already defined, the
@@ -313,72 +316,40 @@ def __set_name__(self, enum_class, member_name):
             elif (
                     Flag is not None
                     and issubclass(enum_class, Flag)
+                    and isinstance(value, int)
                     and _is_single_bit(value)
                 ):
                 # no other instances found, record this member in _member_names_
                 enum_class._member_names_.append(member_name)
-        # if necessary, get redirect in place and then add it to _member_map_
-        found_descriptor = None
-        descriptor_type = None
-        class_type = None
-        for base in enum_class.__mro__[1:]:
-            attr = base.__dict__.get(member_name)
-            if attr is not None:
-                if isinstance(attr, (property, DynamicClassAttribute)):
-                    found_descriptor = attr
-                    class_type = base
-                    descriptor_type = 'enum'
-                    break
-                elif _is_descriptor(attr):
-                    found_descriptor = attr
-                    descriptor_type = descriptor_type or 'desc'
-                    class_type = class_type or base
-                    continue
-                else:
-                    descriptor_type = 'attr'
-                    class_type = base
-        if found_descriptor:
-            redirect = property()
-            redirect.member = enum_member
-            redirect.__set_name__(enum_class, member_name)
-            if descriptor_type in ('enum','desc'):
-                # earlier descriptor found; copy fget, fset, fdel to this one.
-                redirect.fget = getattr(found_descriptor, 'fget', None)
-                redirect._get = getattr(found_descriptor, '__get__', None)
-                redirect.fset = getattr(found_descriptor, 'fset', None)
-                redirect._set = getattr(found_descriptor, '__set__', None)
-                redirect.fdel = getattr(found_descriptor, 'fdel', None)
-                redirect._del = getattr(found_descriptor, '__delete__', None)
-            redirect._attr_type = descriptor_type
-            redirect._cls_type = class_type
-            setattr(enum_class, member_name, redirect)
-        else:
-            setattr(enum_class, member_name, enum_member)
-        # now add to _member_map_ (even aliases)
-        enum_class._member_map_[member_name] = enum_member
+
+        enum_class._add_member_(member_name, enum_member)
         try:
             # This may fail if value is not hashable. We can't add the value
             # to the map, and by-value lookups for this value will be
             # linear.
             enum_class._value2member_map_.setdefault(value, enum_member)
+            if value not in enum_class._hashable_values_:
+                enum_class._hashable_values_.append(value)
         except TypeError:
             # keep track of the value in a list so containment checks are quick
             enum_class._unhashable_values_.append(value)
+            enum_class._unhashable_values_map_.setdefault(member_name, []).append(value)
 
 
-class _EnumDict(dict):
+class EnumDict(dict):
     """
     Track enum member order and ensure member names are not reused.
 
     EnumType will use the names found in self._member_names as the
     enumeration member names.
     """
-    def __init__(self):
+    def __init__(self, cls_name=None):
         super().__init__()
-        self._member_names = {} # use a dict to keep insertion order
+        self._member_names = {} # use a dict -- faster look-up than a list, and keeps insertion order since 3.7
         self._last_values = []
         self._ignore = []
         self._auto_called = False
+        self._cls_name = cls_name
 
     def __setitem__(self, key, value):
         """
@@ -389,23 +360,19 @@ def __setitem__(self, key, value):
 
         Single underscore (sunder) names are reserved.
         """
-        if _is_internal_class(self._cls_name, value):
-            import warnings
-            warnings.warn(
-                    "In 3.13 classes created inside an enum will not become a member.  "
-                    "Use the `member` decorator to keep the current behavior.",
-                    DeprecationWarning,
-                    stacklevel=2,
-                    )
-        if _is_private(self._cls_name, key):
-            # also do nothing, name will be a normal attribute
+        if self._cls_name is not None and _is_private(self._cls_name, key):
+            # do nothing, name will be a normal attribute
             pass
         elif _is_sunder(key):
             if key not in (
                     '_order_',
                     '_generate_next_value_', '_numeric_repr_', '_missing_', '_ignore_',
                     '_iter_member_', '_iter_member_by_value_', '_iter_member_by_def_',
-                    ):
+                    '_add_alias_', '_add_value_alias_',
+                    # While not in use internally, those are common for pretty
+                    # printing and thus excluded from Enum's reservation of
+                    # _sunder_ names
+                    ) and not key.startswith('_repr_'):
                 raise ValueError(
                         '_sunder_ names, such as %r, are reserved for future Enum use'
                         % (key, )
@@ -439,12 +406,17 @@ def __setitem__(self, key, value):
         elif isinstance(value, nonmember):
             # unwrap value here; it won't be processed by the below `else`
             value = value.value
+        elif isinstance(value, partial):
+            import warnings
+            warnings.warn('functools.partial will be a method descriptor '
+                          'in future Python versions; wrap it in '
+                          'enum.member() if you want to preserve the '
+                          'old behavior', FutureWarning, stacklevel=2)
         elif _is_descriptor(value):
             pass
-        # TODO: uncomment next three lines in 3.13
-        # elif _is_internal_class(self._cls_name, value):
-        #     # do nothing, name will be a normal attribute
-        #     pass
+        elif self._cls_name is not None and _is_internal_class(self._cls_name, value):
+            # do nothing, name will be a normal attribute
+            pass
         else:
             if key in self:
                 # enum overwriting a descriptor?
@@ -457,10 +429,11 @@ def __setitem__(self, key, value):
             if isinstance(value, auto):
                 single = True
                 value = (value, )
-            if type(value) is tuple and any(isinstance(v, auto) for v in value):
+            if isinstance(value, tuple) and any(isinstance(v, auto) for v in value):
                 # insist on an actual tuple, no subclasses, in keeping with only supporting
                 # top-level auto() usage (not contained in any other data structure)
                 auto_valued = []
+                t = type(value)
                 for v in value:
                     if isinstance(v, auto):
                         non_auto_store = False
@@ -475,12 +448,21 @@ def __setitem__(self, key, value):
                 if single:
                     value = auto_valued[0]
                 else:
-                    value = tuple(auto_valued)
+                    try:
+                        # accepts iterable as multiple arguments?
+                        value = t(auto_valued)
+                    except TypeError:
+                        # then pass them in singly
+                        value = t(*auto_valued)
             self._member_names[key] = None
             if non_auto_store:
                 self._last_values.append(value)
         super().__setitem__(key, value)
 
+    @property
+    def member_names(self):
+        return list(self._member_names)
+
     def update(self, members, **more_members):
         try:
             for name in members.keys():
@@ -491,6 +473,8 @@ def update(self, members, **more_members):
         for name, value in more_members.items():
             self[name] = value
 
+_EnumDict = EnumDict        # keep private name for backwards compatibility
+
 
 class EnumType(type):
     """
@@ -502,8 +486,7 @@ def __prepare__(metacls, cls, bases, **kwds):
         # check that previous enum members do not exist
         metacls._check_for_existing_members_(cls, bases)
         # create the namespace dict
-        enum_dict = _EnumDict()
-        enum_dict._cls_name = cls
+        enum_dict = EnumDict(cls)
         # inherit previous flags and _generate_next_value_ function
         member_type, first_enum = metacls._get_mixins_(cls, bases)
         if first_enum is not None:
@@ -564,7 +547,9 @@ def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **k
         classdict['_member_names_'] = []
         classdict['_member_map_'] = {}
         classdict['_value2member_map_'] = {}
-        classdict['_unhashable_values_'] = []
+        classdict['_hashable_values_'] = []          # for comparing with non-hashable types
+        classdict['_unhashable_values_'] = []       # e.g. frozenset() with set()
+        classdict['_unhashable_values_map_'] = {}
         classdict['_member_type_'] = member_type
         # now set the __repr__ for the value
         classdict['_value_repr_'] = metacls._find_data_repr_(cls, bases)
@@ -579,15 +564,16 @@ def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **k
         classdict['_all_bits_'] = 0
         classdict['_inverted_'] = None
         try:
-            exc = None
+            classdict['_%s__in_progress' % cls] = True
             enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)
-        except RuntimeError as e:
-            # any exceptions raised by member.__new__ will get converted to a
-            # RuntimeError, so get that original exception back and raise it instead
-            exc = e.__cause__ or e
-        if exc is not None:
-            raise exc
-        #
+            classdict['_%s__in_progress' % cls] = False
+            delattr(enum_class, '_%s__in_progress' % cls)
+        except Exception as e:
+            # since 3.12 the note "Error calling __set_name__ on '_proto_member' instance ..."
+            # is tacked on to the error instead of raising a RuntimeError, so discard it
+            if hasattr(e, '__notes__'):
+                del e.__notes__
+            raise
         # update classdict with any changes made by __init_subclass__
         classdict.update(enum_class.__dict__)
         #
@@ -706,7 +692,7 @@ def __bool__(cls):
         """
         return True
 
-    def __call__(cls, value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None):
+    def __call__(cls, value, names=_not_given, *values, module=None, qualname=None, type=None, start=1, boundary=None):
         """
         Either returns an existing member, or creates a new enum class.
 
@@ -735,18 +721,18 @@ def __call__(cls, value, names=None, *values, module=None, qualname=None, type=N
         """
         if cls._member_map_:
             # simple value lookup if members exist
-            if names:
+            if names is not _not_given:
                 value = (value, names) + values
             return cls.__new__(cls, value)
         # otherwise, functional API: we're creating a new Enum type
-        if names is None and type is None:
+        if names is _not_given and type is None:
             # no body? no data-type? possibly wrong usage
             raise TypeError(
                     f"{cls} has no members; specify `names=()` if you meant to create a new, empty, enum"
                     )
         return cls._create_(
                 class_name=value,
-                names=names,
+                names=None if names is _not_given else names,
                 module=module,
                 qualname=qualname,
                 type=type,
@@ -760,10 +746,20 @@ def __contains__(cls, value):
         `value` is in `cls` if:
         1) `value` is a member of `cls`, or
         2) `value` is the value of one of the `cls`'s members.
+        3) `value` is a pseudo-member (flags)
         """
         if isinstance(value, cls):
             return True
-        return value in cls._value2member_map_ or value in cls._unhashable_values_
+        if issubclass(cls, Flag):
+            try:
+                result = cls._missing_(value)
+                return isinstance(result, cls)
+            except ValueError:
+                pass
+        return (
+                value in cls._unhashable_values_    # both structures are lists
+                or value in cls._hashable_values_
+                )
 
     def __delattr__(cls, attr):
         # nicer error message when someone tries to delete an attribute
@@ -1059,7 +1055,55 @@ def _find_new_(mcls, classdict, member_type, first_enum):
         else:
             use_args = True
         return __new__, save_new, use_args
-EnumMeta = EnumType
+
+    def _add_member_(cls, name, member):
+        # _value_ structures are not updated
+        if name in cls._member_map_:
+            if cls._member_map_[name] is not member:
+                raise NameError('%r is already bound: %r' % (name, cls._member_map_[name]))
+            return
+        #
+        # if necessary, get redirect in place and then add it to _member_map_
+        found_descriptor = None
+        descriptor_type = None
+        class_type = None
+        for base in cls.__mro__[1:]:
+            attr = base.__dict__.get(name)
+            if attr is not None:
+                if isinstance(attr, (property, DynamicClassAttribute)):
+                    found_descriptor = attr
+                    class_type = base
+                    descriptor_type = 'enum'
+                    break
+                elif _is_descriptor(attr):
+                    found_descriptor = attr
+                    descriptor_type = descriptor_type or 'desc'
+                    class_type = class_type or base
+                    continue
+                else:
+                    descriptor_type = 'attr'
+                    class_type = base
+        if found_descriptor:
+            redirect = property()
+            redirect.member = member
+            redirect.__set_name__(cls, name)
+            if descriptor_type in ('enum', 'desc'):
+                # earlier descriptor found; copy fget, fset, fdel to this one.
+                redirect.fget = getattr(found_descriptor, 'fget', None)
+                redirect._get = getattr(found_descriptor, '__get__', None)
+                redirect.fset = getattr(found_descriptor, 'fset', None)
+                redirect._set = getattr(found_descriptor, '__set__', None)
+                redirect.fdel = getattr(found_descriptor, 'fdel', None)
+                redirect._del = getattr(found_descriptor, '__delete__', None)
+            redirect._attr_type = descriptor_type
+            redirect._cls_type = class_type
+            setattr(cls, name, redirect)
+        else:
+            setattr(cls, name, member)
+        # now add to _member_map_ (even aliases)
+        cls._member_map_[name] = member
+
+EnumMeta = EnumType         # keep EnumMeta name for backwards compatibility
 
 
 class Enum(metaclass=EnumType):
@@ -1125,12 +1169,17 @@ def __new__(cls, value):
             pass
         except TypeError:
             # not there, now do long search -- O(n) behavior
-            for member in cls._member_map_.values():
-                if member._value_ == value:
-                    return member
+            for name, unhashable_values in cls._unhashable_values_map_.items():
+                if value in unhashable_values:
+                    return cls[name]
+            for name, member in cls._member_map_.items():
+                if value == member._value_:
+                    return cls[name]
         # still not found -- verify that members exist, in-case somebody got here mistakenly
         # (such as via super when trying to override __new__)
         if not cls._member_map_:
+            if getattr(cls, '_%s__in_progress' % cls.__name__, False):
+                raise TypeError('do not use `super().__new__; call the appropriate __new__ directly') from None
             raise TypeError("%r has no members defined" % cls)
         #
         # still not found -- try _missing_ hook
@@ -1168,6 +1217,34 @@ def __new__(cls, value):
     def __init__(self, *args, **kwds):
         pass
 
+    def _add_alias_(self, name):
+        self.__class__._add_member_(name, self)
+
+    def _add_value_alias_(self, value):
+        cls = self.__class__
+        try:
+            if value in cls._value2member_map_:
+                if cls._value2member_map_[value] is not self:
+                    raise ValueError('%r is already bound: %r' % (value, cls._value2member_map_[value]))
+                return
+        except TypeError:
+            # unhashable value, do long search
+            for m in cls._member_map_.values():
+                if m._value_ == value:
+                    if m is not self:
+                        raise ValueError('%r is already bound: %r' % (value, cls._value2member_map_[value]))
+                    return
+        try:
+            # This may fail if value is not hashable. We can't add the value
+            # to the map, and by-value lookups for this value will be
+            # linear.
+            cls._value2member_map_.setdefault(value, self)
+            cls._hashable_values_.append(value)
+        except TypeError:
+            # keep track of the value in a list so containment checks are quick
+            cls._unhashable_values_.append(value)
+            cls._unhashable_values_map_.setdefault(self.name, []).append(value)
+
     @staticmethod
     def _generate_next_value_(name, start, count, last_values):
         """
@@ -1181,28 +1258,13 @@ def _generate_next_value_(name, start, count, last_values):
         if not last_values:
             return start
         try:
-            last = last_values[-1]
-            last_values.sort()
-            if last == last_values[-1]:
-                # no difference between old and new methods
-                return last + 1
-            else:
-                # trigger old method (with warning)
-                raise TypeError
+            last_value = sorted(last_values).pop()
         except TypeError:
-            import warnings
-            warnings.warn(
-                    "In 3.13 the default `auto()`/`_generate_next_value_` will require all values to be sortable and support adding +1\n"
-                    "and the value returned will be the largest value in the enum incremented by 1",
-                    DeprecationWarning,
-                    stacklevel=3,
-                    )
-            for v in reversed(last_values):
-                try:
-                    return v + 1
-                except TypeError:
-                    pass
-            return start
+            raise TypeError('unable to sort non-numeric values') from None
+        try:
+            return last_value + 1
+        except TypeError:
+            raise TypeError('unable to increment %r' % (last_value, )) from None
 
     @classmethod
     def _missing_(cls, value):
@@ -1217,14 +1279,13 @@ def __str__(self):
 
     def __dir__(self):
         """
-        Returns all members and all public methods
+        Returns public methods and other interesting attributes.
         """
-        if self.__class__._member_type_ is object:
-            interesting = set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value'])
-        else:
+        interesting = set()
+        if self.__class__._member_type_ is not object:
             interesting = set(object.__dir__(self))
         for name in getattr(self, '__dict__', []):
-            if name[0] != '_':
+            if name[0] != '_' and name not in self._member_map_:
                 interesting.add(name)
         for cls in self.__class__.mro():
             for name, obj in cls.__dict__.items():
@@ -1237,7 +1298,7 @@ def __dir__(self):
                     else:
                         # in case it was added by `dir(self)`
                         interesting.discard(name)
-                else:
+                elif name not in self._member_map_:
                     interesting.add(name)
         names = sorted(
                 set(['__class__', '__doc__', '__eq__', '__hash__', '__module__'])
@@ -1525,37 +1586,50 @@ def __str__(self):
     def __bool__(self):
         return bool(self._value_)
 
+    def _get_value(self, flag):
+        if isinstance(flag, self.__class__):
+            return flag._value_
+        elif self._member_type_ is not object and isinstance(flag, self._member_type_):
+            return flag
+        return NotImplemented
+
     def __or__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with |")
         value = self._value_
-        return self.__class__(value | other)
+        return self.__class__(value | other_value)
 
     def __and__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with &")
         value = self._value_
-        return self.__class__(value & other)
+        return self.__class__(value & other_value)
 
     def __xor__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with ^")
         value = self._value_
-        return self.__class__(value ^ other)
+        return self.__class__(value ^ other_value)
 
     def __invert__(self):
+        if self._get_value(self) is None:
+            raise TypeError(f"'{self}' cannot be inverted")
+
         if self._inverted_ is None:
             if self._boundary_ in (EJECT, KEEP):
                 self._inverted_ = self.__class__(~self._value_)
@@ -1622,7 +1696,7 @@ def global_flag_repr(self):
     cls_name = self.__class__.__name__
     if self._name_ is None:
         return "%s.%s(%r)" % (module, cls_name, self._value_)
-    if _is_single_bit(self):
+    if _is_single_bit(self._value_):
         return '%s.%s' % (module, self._name_)
     if self._boundary_ is not FlagBoundary.KEEP:
         return '|'.join(['%s.%s' % (module, name) for name in self.name.split('|')])
@@ -1665,7 +1739,7 @@ def _simple_enum(etype=Enum, *, boundary=None, use_args=None):
     Class decorator that converts a normal class into an :class:`Enum`.  No
     safety checks are done, and some advanced behavior (such as
     :func:`__init_subclass__`) is not available.  Enum creation can be faster
-    using :func:`simple_enum`.
+    using :func:`_simple_enum`.
 
         >>> from enum import Enum, _simple_enum
         >>> @_simple_enum(Enum)
@@ -1696,7 +1770,9 @@ def convert_class(cls):
         body['_member_names_'] = member_names = []
         body['_member_map_'] = member_map = {}
         body['_value2member_map_'] = value2member_map = {}
-        body['_unhashable_values_'] = []
+        body['_hashable_values_'] = hashable_values = []
+        body['_unhashable_values_'] = unhashable_values = []
+        body['_unhashable_values_map_'] = {}
         body['_member_type_'] = member_type = etype._member_type_
         body['_value_repr_'] = etype._value_repr_
         if issubclass(etype, Flag):
@@ -1743,35 +1819,42 @@ def convert_class(cls):
             for name, value in attrs.items():
                 if isinstance(value, auto) and auto.value is _auto_null:
                     value = gnv(name, 1, len(member_names), gnv_last_values)
-                if value in value2member_map:
+                # create basic member (possibly isolate value for alias check)
+                if use_args:
+                    if not isinstance(value, tuple):
+                        value = (value, )
+                    member = new_member(enum_class, *value)
+                    value = value[0]
+                else:
+                    member = new_member(enum_class)
+                if __new__ is None:
+                    member._value_ = value
+                # now check if alias
+                try:
+                    contained = value2member_map.get(member._value_)
+                except TypeError:
+                    contained = None
+                    if member._value_ in unhashable_values or member.value in hashable_values:
+                        for m in enum_class:
+                            if m._value_ == member._value_:
+                                contained = m
+                                break
+                if contained is not None:
                     # an alias to an existing member
-                    member = value2member_map[value]
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
+                    contained._add_alias_(name)
                 else:
-                    # create the member
-                    if use_args:
-                        if not isinstance(value, tuple):
-                            value = (value, )
-                        member = new_member(enum_class, *value)
-                        value = value[0]
-                    else:
-                        member = new_member(enum_class)
-                    if __new__ is None:
-                        member._value_ = value
+                    # finish creating member
                     member._name_ = name
                     member.__objclass__ = enum_class
                     member.__init__(value)
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
                     member._sort_order_ = len(member_names)
+                    if name not in ('name', 'value'):
+                        setattr(enum_class, name, member)
+                        member_map[name] = member
+                    else:
+                        enum_class._add_member_(name, member)
                     value2member_map[value] = member
+                    hashable_values.append(value)
                     if _is_single_bit(value):
                         # not a multi-bit alias, record in _member_names_ and _flag_mask_
                         member_names.append(name)
@@ -1793,37 +1876,53 @@ def convert_class(cls):
                     if value.value is _auto_null:
                         value.value = gnv(name, 1, len(member_names), gnv_last_values)
                     value = value.value
-                if value in value2member_map:
+                # create basic member (possibly isolate value for alias check)
+                if use_args:
+                    if not isinstance(value, tuple):
+                        value = (value, )
+                    member = new_member(enum_class, *value)
+                    value = value[0]
+                else:
+                    member = new_member(enum_class)
+                if __new__ is None:
+                    member._value_ = value
+                # now check if alias
+                try:
+                    contained = value2member_map.get(member._value_)
+                except TypeError:
+                    contained = None
+                    if member._value_ in unhashable_values or member._value_ in hashable_values:
+                        for m in enum_class:
+                            if m._value_ == member._value_:
+                                contained = m
+                                break
+                if contained is not None:
                     # an alias to an existing member
-                    member = value2member_map[value]
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
+                    contained._add_alias_(name)
                 else:
-                    # create the member
-                    if use_args:
-                        if not isinstance(value, tuple):
-                            value = (value, )
-                        member = new_member(enum_class, *value)
-                        value = value[0]
-                    else:
-                        member = new_member(enum_class)
-                    if __new__ is None:
-                        member._value_ = value
+                    # finish creating member
                     member._name_ = name
                     member.__objclass__ = enum_class
                     member.__init__(value)
                     member._sort_order_ = len(member_names)
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
-                    value2member_map[value] = member
+                    if name not in ('name', 'value'):
+                        setattr(enum_class, name, member)
+                        member_map[name] = member
+                    else:
+                        enum_class._add_member_(name, member)
                     member_names.append(name)
                     gnv_last_values.append(value)
+                    try:
+                        # This may fail if value is not hashable. We can't add the value
+                        # to the map, and by-value lookups for this value will be
+                        # linear.
+                        enum_class._value2member_map_.setdefault(value, member)
+                        if value not in hashable_values:
+                            hashable_values.append(value)
+                    except TypeError:
+                        # keep track of the value in a list so containment checks are quick
+                        enum_class._unhashable_values_.append(value)
+                        enum_class._unhashable_values_map_.setdefault(name, []).append(value)
         if '__new__' in body:
             enum_class.__new_member__ = enum_class.__new__
         enum_class.__new__ = Enum.__new__
@@ -1880,7 +1979,7 @@ def __call__(self, enumeration):
                         if 2**i not in values:
                             missing.append(2**i)
                 elif enum_type == 'enum':
-                    # check for powers of one
+                    # check for missing consecutive integers
                     for i in range(low+1, high):
                         if i not in values:
                             missing.append(i)
@@ -1908,7 +2007,8 @@ def __call__(self, enumeration):
                     missed = [v for v in values if v not in member_values]
                     if missed:
                         missing_names.append(name)
-                        missing_value |= reduce(_or_, missed)
+                        for val in missed:
+                            missing_value |= val
                 if missing_names:
                     if len(missing_names) == 1:
                         alias = 'alias %s is missing' % missing_names[0]
@@ -1957,7 +2057,8 @@ def _test_simple_enum(checked_enum, simple_enum):
                 + list(simple_enum._member_map_.keys())
                 )
         for key in set(checked_keys + simple_keys):
-            if key in ('__module__', '_member_map_', '_value2member_map_', '__doc__'):
+            if key in ('__module__', '_member_map_', '_value2member_map_', '__doc__',
+                       '__static_attributes__', '__firstlineno__'):
                 # keys known to be different, or very long
                 continue
             elif key in member_names:
diff --git a/Lib/filecmp.py b/Lib/filecmp.py
index 30bd900fa80..c5b8d854d77 100644
--- a/Lib/filecmp.py
+++ b/Lib/filecmp.py
@@ -88,12 +88,15 @@ def _do_cmp(f1, f2):
 class dircmp:
     """A class that manages the comparison of 2 directories.
 
-    dircmp(a, b, ignore=None, hide=None)
+    dircmp(a, b, ignore=None, hide=None, *, shallow=True)
       A and B are directories.
       IGNORE is a list of names to ignore,
         defaults to DEFAULT_IGNORES.
       HIDE is a list of names to hide,
         defaults to [os.curdir, os.pardir].
+      SHALLOW specifies whether to just check the stat signature (do not read
+        the files).
+        defaults to True.
 
     High level usage:
       x = dircmp(dir1, dir2)
@@ -121,7 +124,7 @@ class dircmp:
        in common_dirs.
      """
 
-    def __init__(self, a, b, ignore=None, hide=None): # Initialize
+    def __init__(self, a, b, ignore=None, hide=None, *, shallow=True): # Initialize
         self.left = a
         self.right = b
         if hide is None:
@@ -132,6 +135,7 @@ def __init__(self, a, b, ignore=None, hide=None): # Initialize
             self.ignore = DEFAULT_IGNORES
         else:
             self.ignore = ignore
+        self.shallow = shallow
 
     def phase0(self): # Compare everything except common subdirectories
         self.left_list = _filter(os.listdir(self.left),
@@ -160,12 +164,14 @@ def phase2(self): # Distinguish files, directories, funnies
             ok = True
             try:
                 a_stat = os.stat(a_path)
-            except OSError:
+            except (OSError, ValueError):
+                # See https://github.com/python/cpython/issues/122400
+                # for the rationale for protecting against ValueError.
                 # print('Can\'t stat', a_path, ':', why.args[1])
                 ok = False
             try:
                 b_stat = os.stat(b_path)
-            except OSError:
+            except (OSError, ValueError):
                 # print('Can\'t stat', b_path, ':', why.args[1])
                 ok = False
 
@@ -184,7 +190,7 @@ def phase2(self): # Distinguish files, directories, funnies
                 self.common_funny.append(x)
 
     def phase3(self): # Find out differences between common files
-        xx = cmpfiles(self.left, self.right, self.common_files)
+        xx = cmpfiles(self.left, self.right, self.common_files, self.shallow)
         self.same_files, self.diff_files, self.funny_files = xx
 
     def phase4(self): # Find out differences between common subdirectories
@@ -196,7 +202,8 @@ def phase4(self): # Find out differences between common subdirectories
         for x in self.common_dirs:
             a_x = os.path.join(self.left, x)
             b_x = os.path.join(self.right, x)
-            self.subdirs[x]  = self.__class__(a_x, b_x, self.ignore, self.hide)
+            self.subdirs[x]  = self.__class__(a_x, b_x, self.ignore, self.hide,
+                                              shallow=self.shallow)
 
     def phase4_closure(self): # Recursively call phase4() on subdirectories
         self.phase4()
@@ -280,12 +287,12 @@ def cmpfiles(a, b, common, shallow=True):
 # Return:
 #       0 for equal
 #       1 for different
-#       2 for funny cases (can't stat, etc.)
+#       2 for funny cases (can't stat, NUL bytes, etc.)
 #
 def _cmp(a, b, sh, abs=abs, cmp=cmp):
     try:
         return not abs(cmp(a, b, sh))
-    except OSError:
+    except (OSError, ValueError):
         return 2
 
 
diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index 628c243f2ff..3ff1cea2bf8 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -995,7 +995,6 @@ def test_constant_as_unicode_name(self):
                 f"identifier field can't represent '{constant[0]}' constant"):
                 ast.parse(constant[1], mode="eval")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_precedence_enum(self):
         class _Precedence(enum.IntEnum):
             """Precedence table that originated from python grammar."""
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 32a3c1dee07..8f4b39b4dbb 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -11,14 +11,15 @@
 import builtins as bltns
 from collections import OrderedDict
 from datetime import date
+from functools import partial
 from enum import Enum, EnumMeta, IntEnum, StrEnum, EnumType, Flag, IntFlag, unique, auto
 from enum import STRICT, CONFORM, EJECT, KEEP, _simple_enum, _test_simple_enum
 from enum import verify, UNIQUE, CONTINUOUS, NAMED_FLAGS, ReprEnum
-from enum import member, nonmember, _iter_bits_lsb
+from enum import member, nonmember, _iter_bits_lsb, EnumDict
 from io import StringIO
 from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
 from test import support
-from test.support import ALWAYS_EQ
+from test.support import ALWAYS_EQ, REPO_ROOT
 from test.support import threading_helper
 from datetime import timedelta
 
@@ -26,18 +27,42 @@
 
 def load_tests(loader, tests, ignore):
     tests.addTests(doctest.DocTestSuite(enum))
-    if os.path.exists('Doc/library/enum.rst'):
+
+    lib_tests = os.path.join(REPO_ROOT, 'Doc/library/enum.rst')
+    if os.path.exists(lib_tests):
         tests.addTests(doctest.DocFileSuite(
-                '../../Doc/library/enum.rst',
+                lib_tests,
+                module_relative=False,
                 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
                 ))
-    if os.path.exists('Doc/howto/enum.rst'):
+    howto_tests = os.path.join(REPO_ROOT, 'Doc/howto/enum.rst')
+    if os.path.exists(howto_tests) and sys.float_repr_style == 'short':
         tests.addTests(doctest.DocFileSuite(
-                '../../Doc/howto/enum.rst',
+                howto_tests,
+                module_relative=False,
                 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
                 ))
     return tests
 
+def reraise_if_not_enum(*enum_types_or_exceptions):
+    from functools import wraps
+
+    def decorator(func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            excs = [
+                e
+                for e in enum_types_or_exceptions
+                if isinstance(e, Exception)
+            ]
+            if len(excs) == 1:
+                raise excs[0]
+            elif excs:
+                raise ExceptionGroup('Enum Exceptions', excs)
+            return func(*args, **kwargs)
+        return inner
+    return decorator
+
 MODULE = __name__
 SHORT_MODULE = MODULE.split('.')[-1]
 
@@ -75,30 +100,42 @@ class FlagStooges(Flag):
 except Exception as exc:
     FlagStooges = exc
 
-class FlagStoogesWithZero(Flag):
-    NOFLAG = 0
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
-
-class IntFlagStooges(IntFlag):
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
-
-class IntFlagStoogesWithZero(IntFlag):
-    NOFLAG = 0
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
+try:
+    class FlagStoogesWithZero(Flag):
+        NOFLAG = 0
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    FlagStoogesWithZero = exc
+
+try:
+    class IntFlagStooges(IntFlag):
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    IntFlagStooges = exc
+
+try:
+    class IntFlagStoogesWithZero(IntFlag):
+        NOFLAG = 0
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    IntFlagStoogesWithZero = exc
 
 # for pickle test and subclass tests
-class Name(StrEnum):
-    BDFL = 'Guido van Rossum'
-    FLUFL = 'Barry Warsaw'
+try:
+    class Name(StrEnum):
+        BDFL = 'Guido van Rossum'
+        FLUFL = 'Barry Warsaw'
+except Exception as exc:
+    Name = exc
 
 try:
     Question = Enum('Question', 'who what when where why', module=__name__)
@@ -140,7 +177,7 @@ class TestHelpers(unittest.TestCase):
 
     sunder_names = '_bad_', '_good_', '_what_ho_'
     dunder_names = '__mal__', '__bien__', '__que_que__'
-    private_names = '_MyEnum__private', '_MyEnum__still_private'
+    private_names = '_MyEnum__private', '_MyEnum__still_private', '_MyEnum___triple_private'
     private_and_sunder_names = '_MyEnum__private_', '_MyEnum__also_private_'
     random_names = 'okay', '_semi_private', '_weird__', '_MyEnum__'
 
@@ -204,26 +241,35 @@ def __get__(self, instance, ownerclass):
 
 # for global repr tests
 
-@enum.global_enum
-class HeadlightsK(IntFlag, boundary=enum.KEEP):
-    OFF_K = 0
-    LOW_BEAM_K = auto()
-    HIGH_BEAM_K = auto()
-    FOG_K = auto()
+try:
+    @enum.global_enum
+    class HeadlightsK(IntFlag, boundary=enum.KEEP):
+        OFF_K = 0
+        LOW_BEAM_K = auto()
+        HIGH_BEAM_K = auto()
+        FOG_K = auto()
+except Exception as exc:
+    HeadlightsK = exc
 
 
-@enum.global_enum
-class HeadlightsC(IntFlag, boundary=enum.CONFORM):
-    OFF_C = 0
-    LOW_BEAM_C = auto()
-    HIGH_BEAM_C = auto()
-    FOG_C = auto()
+try:
+    @enum.global_enum
+    class HeadlightsC(IntFlag, boundary=enum.CONFORM):
+        OFF_C = 0
+        LOW_BEAM_C = auto()
+        HIGH_BEAM_C = auto()
+        FOG_C = auto()
+except Exception as exc:
+    HeadlightsC = exc
 
 
-@enum.global_enum
-class NoName(Flag):
-    ONE = 1
-    TWO = 2
+try:
+    @enum.global_enum
+    class NoName(Flag):
+        ONE = 1
+        TWO = 2
+except Exception as exc:
+    NoName = exc
 
 
 # tests
@@ -399,10 +445,12 @@ def spam(cls):
         with self.assertRaises(AttributeError):
             del Season.SPRING.name
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance failed in 'BadSuper'
     def test_bad_new_super(self):
         with self.assertRaisesRegex(
                 TypeError,
-                'has no members defined',
+                'do not use .super...__new__;',
             ):
             class BadSuper(self.enum_type):
                 def __new__(cls, value):
@@ -417,6 +465,7 @@ def test_basics(self):
             self.assertEqual(str(TE), "<flag 'MainEnum'>")
             self.assertEqual(format(TE), "<flag 'MainEnum'>")
             self.assertTrue(TE(5) is self.dupe2)
+            self.assertTrue(7 in TE)
         else:
             self.assertEqual(repr(TE), "<enum 'MainEnum'>")
             self.assertEqual(str(TE), "<enum 'MainEnum'>")
@@ -469,6 +518,7 @@ def test_contains_tf(self):
             self.assertFalse('first' in MainEnum)
         val = MainEnum.dupe
         self.assertIn(val, MainEnum)
+        self.assertNotIn(float('nan'), MainEnum)
         #
         class OtherEnum(Enum):
             one = auto()
@@ -1005,6 +1055,22 @@ class TestPlainEnumFunction(_EnumTests, _PlainOutputTests, unittest.TestCase):
 class TestPlainFlagClass(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
     enum_type = Flag
 
+    def test_none_member(self):
+        class FlagWithNoneMember(Flag):
+            A = 1
+            E = None
+
+        self.assertEqual(FlagWithNoneMember.A.value, 1)
+        self.assertIs(FlagWithNoneMember.E.value, None)
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with |"):
+            FlagWithNoneMember.A | FlagWithNoneMember.E
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with &"):
+            FlagWithNoneMember.E & FlagWithNoneMember.A
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with \^"):
+            FlagWithNoneMember.A ^ FlagWithNoneMember.E
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be inverted"):
+            ~FlagWithNoneMember.E
+
 
 class TestPlainFlagFunction(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
     enum_type = Flag
@@ -1292,7 +1358,7 @@ class Color(Enum):
                 red = 1
                 green = 2
                 blue = 3
-                def red(self):
+                def red(self):  # noqa: F811
                     return 'red'
         #
         with self.assertRaises(TypeError):
@@ -1300,13 +1366,12 @@ class Color(Enum):
                 @enum.property
                 def red(self):
                     return 'redder'
-                red = 1
+                red = 1  # noqa: F811
                 green = 2
                 blue = 3
 
+    @reraise_if_not_enum(Theory)
     def test_enum_function_with_qualname(self):
-        if isinstance(Theory, Exception):
-            raise Theory
         self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
 
     def test_enum_of_types(self):
@@ -1369,12 +1434,10 @@ class Inner(Enum):
             [Outer.a, Outer.b, Outer.Inner],
             )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'inner classes are still members',
+            )
     def test_nested_classes_in_enum_are_not_members(self):
         """Support locally-defined nested classes."""
         class Outer(Enum):
@@ -1439,6 +1502,27 @@ class SpamEnum(Enum):
             spam = nonmember(SpamEnumIsInner)
         self.assertTrue(SpamEnum.spam is SpamEnumIsInner)
 
+    def test_using_members_as_nonmember(self):
+        class Example(Flag):
+            A = 1
+            B = 2
+            ALL = nonmember(A | B)
+
+        self.assertEqual(Example.A.value, 1)
+        self.assertEqual(Example.B.value, 2)
+        self.assertEqual(Example.ALL, 3)
+        self.assertIs(type(Example.ALL), int)
+
+        class Example(Flag):
+            A = auto()
+            B = auto()
+            ALL = nonmember(A | B)
+
+        self.assertEqual(Example.A.value, 1)
+        self.assertEqual(Example.B.value, 2)
+        self.assertEqual(Example.ALL, 3)
+        self.assertIs(type(Example.ALL), int)
+
     def test_nested_classes_in_enum_with_member(self):
         """Support locally-defined nested classes."""
         class Outer(Enum):
@@ -1460,6 +1544,22 @@ class Inner(Enum):
             [Outer.a, Outer.b, Outer.Inner],
             )
 
+    # TODO: RUSTPYTHON
+    # AssertionError: FutureWarning not triggered
+    @unittest.expectedFailure
+    def test_partial(self):
+        def func(a, b=5):
+            return a, b
+        with self.assertWarnsRegex(FutureWarning, r'partial.*enum\.member') as cm:
+            class E(Enum):
+                a = 1
+                b = partial(func)
+        self.assertEqual(cm.filename, __file__)
+        self.assertIsInstance(E.b, partial)
+        self.assertEqual(E.b(2), (2, 5))
+        with self.assertWarnsRegex(FutureWarning, 'partial'):
+            self.assertEqual(E.a.b(2), (2, 5))
+
     def test_enum_with_value_name(self):
         class Huh(Enum):
             name = 1
@@ -1491,6 +1591,17 @@ class IntFlag1(IntFlag):
         self.assertIn(IntEnum1.X, IntFlag1)
         self.assertIn(IntFlag1.X, IntEnum1)
 
+    def test_contains_does_not_call_missing(self):
+        class AnEnum(Enum):
+            UNKNOWN = None
+            LUCKY = 3
+            @classmethod
+            def _missing_(cls, *values):
+                return cls.UNKNOWN
+        self.assertTrue(None in AnEnum)
+        self.assertTrue(3 in AnEnum)
+        self.assertFalse(7 in AnEnum)
+
     def test_inherited_data_type(self):
         class HexInt(int):
             __qualname__ = 'HexInt'
@@ -1537,6 +1648,7 @@ class MyUnBrokenEnum(UnBrokenInt, Enum):
         test_pickle_dump_load(self.assertIs, MyUnBrokenEnum.I)
         test_pickle_dump_load(self.assertIs, MyUnBrokenEnum)
 
+    @reraise_if_not_enum(FloatStooges)
     def test_floatenum_fromhex(self):
         h = float.hex(FloatStooges.MOE.value)
         self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
@@ -1657,8 +1769,8 @@ class ThreePart(Enum):
         self.assertIs(ThreePart((3, 3.0, 'three')), ThreePart.THREE)
         self.assertIs(ThreePart(3, 3.0, 'three'), ThreePart.THREE)
 
-    # TODO: RUSTPYTHON, AssertionError: <test.test_enum.IntStooges object at 0x55c70c38a240> is not <IntStooges.MOE: 3>
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: <test.test_enum.IntStooges object at 0x55c70c38a240> is not <IntStooges.MOE: 3>
+    @reraise_if_not_enum(IntStooges)
     def test_intenum_from_bytes(self):
         self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
         with self.assertRaises(ValueError):
@@ -1687,33 +1799,28 @@ def repr(self):
             class Huh(MyStr, MyInt, Enum):
                 One = 1
 
+    @reraise_if_not_enum(Stooges)
     def test_pickle_enum(self):
-        if isinstance(Stooges, Exception):
-            raise Stooges
         test_pickle_dump_load(self.assertIs, Stooges.CURLY)
         test_pickle_dump_load(self.assertIs, Stooges)
 
+    @reraise_if_not_enum(IntStooges)
     def test_pickle_int(self):
-        if isinstance(IntStooges, Exception):
-            raise IntStooges
         test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
         test_pickle_dump_load(self.assertIs, IntStooges)
 
+    @reraise_if_not_enum(FloatStooges)
     def test_pickle_float(self):
-        if isinstance(FloatStooges, Exception):
-            raise FloatStooges
         test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
         test_pickle_dump_load(self.assertIs, FloatStooges)
 
+    @reraise_if_not_enum(Answer)
     def test_pickle_enum_function(self):
-        if isinstance(Answer, Exception):
-            raise Answer
         test_pickle_dump_load(self.assertIs, Answer.him)
         test_pickle_dump_load(self.assertIs, Answer)
 
+    @reraise_if_not_enum(Question)
     def test_pickle_enum_function_with_module(self):
-        if isinstance(Question, Exception):
-            raise Question
         test_pickle_dump_load(self.assertIs, Question.who)
         test_pickle_dump_load(self.assertIs, Question)
 
@@ -1776,9 +1883,8 @@ class Season(Enum):
                 [Season.SUMMER, Season.WINTER, Season.AUTUMN, Season.SPRING],
                 )
 
+    @reraise_if_not_enum(Name)
     def test_subclassing(self):
-        if isinstance(Name, Exception):
-            raise Name
         self.assertEqual(Name.BDFL, 'Guido van Rossum')
         self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
         self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
@@ -1817,6 +1923,27 @@ def test_wrong_inheritance_order(self):
             class Wrong(Enum, str):
                 NotHere = 'error before this point'
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance INVALID in 'RgbColor'
+    def test_raise_custom_error_on_creation(self):
+        class InvalidRgbColorError(ValueError):
+            def __init__(self, r, g, b):
+                self.r = r
+                self.g = g
+                self.b = b
+                super().__init__(f'({r}, {g}, {b}) is not a valid RGB color')
+
+        with self.assertRaises(InvalidRgbColorError):
+            class RgbColor(Enum):
+                RED = (255, 0, 0)
+                GREEN = (0, 255, 0)
+                BLUE = (0, 0, 255)
+                INVALID = (256, 0, 0)
+
+                def __init__(self, r, g, b):
+                    if not all(0 <= val <= 255 for val in (r, g, b)):
+                        raise InvalidRgbColorError(r, g, b)
+
     def test_intenum_transitivity(self):
         class number(IntEnum):
             one = 1
@@ -2003,8 +2130,7 @@ class NEI(NamedInt, Enum):
         test_pickle_dump_load(self.assertIs, NEI.y)
         test_pickle_dump_load(self.assertIs, NEI)
 
-    # TODO: RUSTPYTHON, fails on pickle
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; fails on pickle
     def test_subclasses_with_getnewargs_ex(self):
         class NamedInt(int):
             __qualname__ = 'NamedInt'       # needed for pickle protocol 4
@@ -2312,6 +2438,40 @@ class SomeTuple(tuple, Enum):
         globals()['SomeTuple'] = SomeTuple
         test_pickle_dump_load(self.assertIs, SomeTuple.first)
 
+    def test_tuple_subclass_with_auto_1(self):
+        from collections import namedtuple
+        T = namedtuple('T', 'index desc')
+        class SomeEnum(T, Enum):
+            __qualname__ = 'SomeEnum'      # needed for pickle protocol 4
+            first = auto(), 'for the money'
+            second = auto(), 'for the show'
+            third = auto(), 'for the music'
+        self.assertIs(type(SomeEnum.first), SomeEnum)
+        self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
+        self.assertIsInstance(SomeEnum.third.value, T)
+        self.assertEqual(SomeEnum.first.index, 1)
+        self.assertEqual(SomeEnum.second.desc, 'for the show')
+        globals()['SomeEnum'] = SomeEnum
+        globals()['T'] = T
+        test_pickle_dump_load(self.assertIs, SomeEnum.first)
+
+    def test_tuple_subclass_with_auto_2(self):
+        from collections import namedtuple
+        T = namedtuple('T', 'index desc')
+        class SomeEnum(Enum):
+            __qualname__ = 'SomeEnum'      # needed for pickle protocol 4
+            first = T(auto(), 'for the money')
+            second = T(auto(), 'for the show')
+            third = T(auto(), 'for the music')
+        self.assertIs(type(SomeEnum.first), SomeEnum)
+        self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
+        self.assertIsInstance(SomeEnum.third.value, T)
+        self.assertEqual(SomeEnum.first.value.index, 1)
+        self.assertEqual(SomeEnum.second.value.desc, 'for the show')
+        globals()['SomeEnum'] = SomeEnum
+        globals()['T'] = T
+        test_pickle_dump_load(self.assertIs, SomeEnum.first)
+
     def test_duplicate_values_give_unique_enum_items(self):
         class AutoNumber(Enum):
             first = ()
@@ -2453,6 +2613,8 @@ class Test(Base2):
         self.assertEqual(Test.flash.flash, 'flashy dynamic')
         self.assertEqual(Test.flash.value, 1)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance grene in 'Color'
     def test_no_duplicates(self):
         class UniqueEnum(Enum):
             def __init__(self, *args):
@@ -2838,6 +3000,8 @@ def test_empty_globals(self):
         local_ls = {}
         exec(code, global_ns, local_ls)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance one in 'FirstFailedStrEnum'
     def test_strenum(self):
         class GoodStrEnum(StrEnum):
             one = '1'
@@ -2900,8 +3064,7 @@ class ThirdFailedStrEnum(StrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    # TODO: RUSTPYTHON, fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
     def test_custom_strenum(self):
         class CustomStrEnum(str, Enum):
             pass
@@ -2952,15 +3115,19 @@ class SecondFailedStrEnum(CustomStrEnum):
         class ThirdFailedStrEnum(CustomStrEnum):
             one = '1'
             two = 2  # this will become '2'
-        with self.assertRaisesRegex(TypeError, '.encoding. must be str, not '):
+        with self.assertRaisesRegex(TypeError,
+                r"argument (2|'encoding') must be str, not "):
             class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', sys.getdefaultencoding
-        with self.assertRaisesRegex(TypeError, '.errors. must be str, not '):
+        with self.assertRaisesRegex(TypeError,
+                r"argument (3|'errors') must be str, not "):
             class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance key_type in 'Combined'
     def test_missing_value_error(self):
         with self.assertRaisesRegex(TypeError, "_value_ not set in __new__"):
             class Combined(str, Enum):
@@ -3170,6 +3337,37 @@ class NTEnum(Enum):
                 [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
                 )
 
+        self.assertRaises(AttributeError, getattr, NTEnum.NONE, 'id')
+        #
+        class NTCEnum(TTuple, Enum):
+            NONE = 0, 0, []
+            A = 1, 2, [4]
+            B = 2, 4, [0, 1, 2]
+        self.assertEqual(repr(NTCEnum.NONE), "<NTCEnum.NONE: TTuple(id=0, a=0, blist=[])>")
+        self.assertEqual(NTCEnum.NONE.value, TTuple(id=0, a=0, blist=[]))
+        self.assertEqual(NTCEnum.NONE.id, 0)
+        self.assertEqual(NTCEnum.A.a, 2)
+        self.assertEqual(NTCEnum.B.blist, [0, 1 ,2])
+        self.assertEqual(
+                [x.value for x in NTCEnum],
+                [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
+                )
+        #
+        class NTDEnum(Enum):
+            def __new__(cls, id, a, blist):
+                member = object.__new__(cls)
+                member.id = id
+                member.a = a
+                member.blist = blist
+                return member
+            NONE = TTuple(0, 0, [])
+            A = TTuple(1, 2, [4])
+            B = TTuple(2, 4, [0, 1, 2])
+        self.assertEqual(repr(NTDEnum.NONE), "<NTDEnum.NONE: TTuple(id=0, a=0, blist=[])>")
+        self.assertEqual(NTDEnum.NONE.id, 0)
+        self.assertEqual(NTDEnum.A.a, 2)
+        self.assertEqual(NTDEnum.B.blist, [0, 1 ,2])
+
     def test_flag_with_custom_new(self):
         class FlagFromChar(IntFlag):
             def __new__(cls, c):
@@ -3216,6 +3414,8 @@ def __new__(cls, c):
         self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
         self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # RuntimeError: Error calling __set_name__ on '_proto_member' instance A in 'MyEnum'
     def test_init_exception(self):
         class Base:
             def __new__(cls, *args):
@@ -3237,6 +3437,102 @@ def __new__(cls, value):
                     member._value_ = Base(value)
                     return member
 
+    def test_extra_member_creation(self):
+        class IDEnumMeta(EnumMeta):
+            def __new__(metacls, cls, bases, classdict, **kwds):
+                # add new entries to classdict
+                for name in classdict.member_names:
+                    classdict[f'{name}_DESC'] = f'-{classdict[name]}'
+                return super().__new__(metacls, cls, bases, classdict, **kwds)
+        class IDEnum(StrEnum, metaclass=IDEnumMeta):
+            pass
+        class MyEnum(IDEnum):
+            ID = 'id'
+            NAME = 'name'
+        self.assertEqual(list(MyEnum), [MyEnum.ID, MyEnum.NAME, MyEnum.ID_DESC, MyEnum.NAME_DESC])
+
+    def test_add_alias(self):
+        class mixin:
+            @property
+            def ORG(self):
+                return 'huh'
+        class Color(mixin, Enum):
+            RED = 1
+            GREEN = 2
+            BLUE = 3
+        Color.RED._add_alias_('ROJO')
+        self.assertIs(Color.RED, Color['ROJO'])
+        self.assertIs(Color.RED, Color.ROJO)
+        Color.BLUE._add_alias_('ORG')
+        self.assertIs(Color.BLUE, Color['ORG'])
+        self.assertIs(Color.BLUE, Color.ORG)
+        self.assertEqual(Color.RED.ORG, 'huh')
+        self.assertEqual(Color.GREEN.ORG, 'huh')
+        self.assertEqual(Color.BLUE.ORG, 'huh')
+        self.assertEqual(Color.ORG.ORG, 'huh')
+
+    def test_add_value_alias_after_creation(self):
+        class Color(Enum):
+            RED = 1
+            GREEN = 2
+            BLUE = 3
+        Color.RED._add_value_alias_(5)
+        self.assertIs(Color.RED, Color(5))
+
+    def test_add_value_alias_during_creation(self):
+        class Types(Enum):
+            Unknown = 0,
+            Source  = 1, 'src'
+            NetList = 2, 'nl'
+            def __new__(cls, int_value, *value_aliases):
+                member = object.__new__(cls)
+                member._value_ = int_value
+                for alias in value_aliases:
+                    member._add_value_alias_(alias)
+                return member
+        self.assertIs(Types(0), Types.Unknown)
+        self.assertIs(Types(1), Types.Source)
+        self.assertIs(Types('src'), Types.Source)
+        self.assertIs(Types(2), Types.NetList)
+        self.assertIs(Types('nl'), Types.NetList)
+
+    def test_second_tuple_item_is_falsey(self):
+        class Cardinal(Enum):
+            RIGHT = (1, 0)
+            UP = (0, 1)
+            LEFT = (-1, 0)
+            DOWN = (0, -1)
+        self.assertIs(Cardinal(1, 0), Cardinal.RIGHT)
+        self.assertIs(Cardinal(-1, 0), Cardinal.LEFT)
+
+    def test_no_members(self):
+        with self.assertRaisesRegex(
+                TypeError,
+                'has no members',
+            ):
+            Enum(7)
+        with self.assertRaisesRegex(
+                TypeError,
+                'has no members',
+            ):
+            Flag(7)
+
+    def test_empty_names(self):
+        for nothing in '', [], {}:
+            for e_type in None, int:
+                empty_enum = Enum('empty_enum', nothing, type=e_type)
+                self.assertEqual(len(empty_enum), 0)
+                self.assertRaisesRegex(TypeError, 'has no members', empty_enum, 0)
+        self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', names=0)
+        self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', 0, type=int)
+
+    def test_nonhashable_matches_hashable(self):    # issue 125710
+        class Directions(Enum):
+            DOWN_ONLY = frozenset({"sc"})
+            UP_ONLY = frozenset({"cs"})
+            UNRESTRICTED = frozenset({"sc", "cs"})
+        self.assertIs(Directions({"sc"}), Directions.DOWN_ONLY)
+
 
 class TestOrder(unittest.TestCase):
     "test usage of the `_order_` attribute"
@@ -3518,9 +3814,13 @@ def test_programatic_function_from_dict(self):
             self.assertIn(e, Perm)
             self.assertIs(type(e), Perm)
 
+    @reraise_if_not_enum(
+        FlagStooges,
+        FlagStoogesWithZero,
+        IntFlagStooges,
+        IntFlagStoogesWithZero,
+    )
     def test_pickle(self):
-        if isinstance(FlagStooges, Exception):
-            raise FlagStooges
         test_pickle_dump_load(self.assertIs, FlagStooges.CURLY)
         test_pickle_dump_load(self.assertEqual,
                         FlagStooges.CURLY|FlagStooges.MOE)
@@ -3704,7 +4004,7 @@ class Color(StrMixin, AllMixin, Flag):
         self.assertEqual(Color.ALL.value, 7)
         self.assertEqual(str(Color.BLUE), 'blue')
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_unique_composite(self):
@@ -3826,6 +4126,7 @@ def test_type(self):
         self.assertTrue(isinstance(Open.WO | Open.RW, Open))
         self.assertEqual(Open.WO | Open.RW, 3)
 
+    @reraise_if_not_enum(HeadlightsK)
     def test_global_repr_keep(self):
         self.assertEqual(
                 repr(HeadlightsK(0)),
@@ -3840,6 +4141,7 @@ def test_global_repr_keep(self):
                 '%(m)s.HeadlightsK(8)' % {'m': SHORT_MODULE},
                 )
 
+    @reraise_if_not_enum(HeadlightsC)
     def test_global_repr_conform1(self):
         self.assertEqual(
                 repr(HeadlightsC(0)),
@@ -3854,13 +4156,14 @@ def test_global_repr_conform1(self):
                 '%(m)s.OFF_C' % {'m': SHORT_MODULE},
                 )
 
+    @reraise_if_not_enum(NoName)
     def test_global_enum_str(self):
+        self.assertEqual(repr(NoName.ONE), 'test_enum.ONE')
+        self.assertEqual(repr(NoName(0)), 'test_enum.NoName(0)')
         self.assertEqual(str(NoName.ONE & NoName.TWO), 'NoName(0)')
         self.assertEqual(str(NoName(0)), 'NoName(0)')
 
-
-    # TODO: RUSTPYTHON, format(NewPerm.R) does not use __str__
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; format(NewPerm.R) does not use __str__
     def test_format(self):
         Perm = self.Perm
         self.assertEqual(format(Perm.R, ''), '4')
@@ -4223,7 +4526,7 @@ class Color(StrMixin, AllMixin, IntFlag):
         self.assertEqual(Color.ALL.value, 7)
         self.assertEqual(str(Color.BLUE), 'blue')
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_unique_composite(self):
@@ -4548,35 +4851,28 @@ class Color(Enum):
                 red = 'red'
                 blue = 2
                 green = auto()
-                yellow = auto()
 
-        self.assertEqual(list(Color),
-                         [Color.red, Color.blue, Color.green, Color.yellow])
+        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
         self.assertEqual(Color.red.value, 'red')
         self.assertEqual(Color.blue.value, 2)
         self.assertEqual(Color.green.value, 3)
-        self.assertEqual(Color.yellow.value, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'mixed types with auto() will raise in 3.13',
+            )
     def test_auto_garbage_fail(self):
-        with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
+        with self.assertRaisesRegex(TypeError, "unable to increment 'red'"):
             class Color(Enum):
                 red = 'red'
                 blue = auto()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'mixed types with auto() will raise in 3.13',
+            )
     def test_auto_garbage_corrected_fail(self):
-        with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
+        with self.assertRaisesRegex(TypeError, 'unable to sort non-numeric values'):
             class Color(Enum):
                 red = 'red'
                 blue = 2
@@ -4604,9 +4900,9 @@ def _generate_next_value_(name, start, count, last):
         self.assertEqual(Color.blue.value, 'blue')
 
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'auto() will return highest value + 1 in 3.13',
+            )
     def test_auto_with_aliases(self):
         class Color(Enum):
             red = auto()
@@ -4670,8 +4966,6 @@ def _generate_next_value_(name, start, count, last):
         self.assertEqual(Huh.TWO.value, (2, 2))
         self.assertEqual(Huh.THREE.value, (3, 3, 3))
 
-class TestEnumTypeSubclassing(unittest.TestCase):
-    pass
 
 expected_help_output_with_docs = """\
 Help on class Color in module %s:
@@ -4702,22 +4996,23 @@ class Color(enum.Enum)
  |      The value of the Enum member.
  |
  |  ----------------------------------------------------------------------
- |  Methods inherited from enum.EnumType:
+ |  Static methods inherited from enum.EnumType:
  |
- |  __contains__(value) from enum.EnumType
+ |  __contains__(value)
  |      Return True if `value` is in `cls`.
  |
  |      `value` is in `cls` if:
  |      1) `value` is a member of `cls`, or
  |      2) `value` is the value of one of the `cls`'s members.
+ |      3) `value` is a pseudo-member (flags)
  |
- |  __getitem__(name) from enum.EnumType
+ |  __getitem__(name)
  |      Return the member matching `name`.
  |
- |  __iter__() from enum.EnumType
+ |  __iter__()
  |      Return members in definition order.
  |
- |  __len__() from enum.EnumType
+ |  __len__()
  |      Return the number of members (no aliases)
  |
  |  ----------------------------------------------------------------------
@@ -4742,11 +5037,11 @@ class Color(enum.Enum)
  |
  |  Data and other attributes defined here:
  |
- |  YELLOW = <Color.YELLOW: 3>
+ |  CYAN = <Color.CYAN: 1>
  |
  |  MAGENTA = <Color.MAGENTA: 2>
  |
- |  CYAN = <Color.CYAN: 1>
+ |  YELLOW = <Color.YELLOW: 3>
  |
  |  ----------------------------------------------------------------------
  |  Data descriptors inherited from enum.Enum:
@@ -4756,7 +5051,18 @@ class Color(enum.Enum)
  |  value
  |
  |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.EnumType:
+ |  Static methods inherited from enum.EnumType:
+ |
+ |  __contains__(value)
+ |
+ |  __getitem__(name)
+ |
+ |  __iter__()
+ |
+ |  __len__()
+ |
+ |  ----------------------------------------------------------------------
+ |  Readonly properties inherited from enum.EnumType:
  |
  |  __members__"""
 
@@ -4769,8 +5075,7 @@ class Color(Enum):
         MAGENTA = 2
         YELLOW = 3
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pydoc(self):
         # indirectly test __objclass__
         if StrEnum.__doc__ is None:
@@ -4903,8 +5208,7 @@ def test_inspect_signatures(self):
                     ]),
                 )
 
-    # TODO: RUSTPYTHON, len is often/always > 256
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; len is often/always > 256
     def test_test_simple_enum(self):
         @_simple_enum(Enum)
         class SimpleColor:
@@ -4921,12 +5225,14 @@ class CheckedColor(Enum):
             @bltns.property
             def zeroth(self):
                 return 'zeroed %s' % self.name
-        self.assertTrue(_test_simple_enum(CheckedColor, SimpleColor) is None)
+        _test_simple_enum(CheckedColor, SimpleColor)
         SimpleColor.MAGENTA._value_ = 9
         self.assertRaisesRegex(
                 TypeError, "enum mismatch",
                 _test_simple_enum, CheckedColor, SimpleColor,
                 )
+        #
+        #
         class CheckedMissing(IntFlag, boundary=KEEP):
             SIXTY_FOUR = 64
             ONE_TWENTY_EIGHT = 128
@@ -4943,8 +5249,78 @@ class Missing:
             ALL = 2048 + 128 + 64 + 12
         M = Missing
         self.assertEqual(list(CheckedMissing), [M.SIXTY_FOUR, M.ONE_TWENTY_EIGHT, M.TWENTY_FORTY_EIGHT])
-        #
         _test_simple_enum(CheckedMissing, Missing)
+        #
+        #
+        class CheckedUnhashable(Enum):
+            ONE = dict()
+            TWO = set()
+            name = 'python'
+        self.assertIn(dict(), CheckedUnhashable)
+        self.assertIn('python', CheckedUnhashable)
+        self.assertEqual(CheckedUnhashable.name.value, 'python')
+        self.assertEqual(CheckedUnhashable.name.name, 'name')
+        #
+        @_simple_enum()
+        class Unhashable:
+            ONE = dict()
+            TWO = set()
+            name = 'python'
+        self.assertIn(dict(), Unhashable)
+        self.assertIn('python', Unhashable)
+        self.assertEqual(Unhashable.name.value, 'python')
+        self.assertEqual(Unhashable.name.name, 'name')
+        _test_simple_enum(CheckedUnhashable, Unhashable)
+        ##
+        class CheckedComplexStatus(IntEnum):
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            SOME_HINTS = 103, 'Some Early Hints'
+        #
+        @_simple_enum(IntEnum)
+        class ComplexStatus:
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            SOME_HINTS = 103, 'Some Early Hints'
+        _test_simple_enum(CheckedComplexStatus, ComplexStatus)
+        #
+        #
+        class CheckedComplexFlag(IntFlag):
+            def __new__(cls, value, label):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.label = label
+                return obj
+            SHIRT = 1, 'upper half'
+            VEST = 1, 'outer upper half'
+            PANTS = 2, 'lower half'
+        self.assertIs(CheckedComplexFlag.SHIRT, CheckedComplexFlag.VEST)
+        #
+        @_simple_enum(IntFlag)
+        class ComplexFlag:
+            def __new__(cls, value, label):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.label = label
+                return obj
+            SHIRT = 1, 'upper half'
+            VEST = 1, 'uppert half'
+            PANTS = 2, 'lower half'
+        _test_simple_enum(CheckedComplexFlag, ComplexFlag)
 
 
 class MiscTestCase(unittest.TestCase):
@@ -5031,7 +5407,7 @@ def test_convert_value_lookup_priority(self):
                 filter=lambda x: x.startswith('CONVERT_TEST_'))
         # We don't want the reverse lookup value to vary when there are
         # multiple possible names for a given value.  It should always
-        # report the first lexigraphical name in that case.
+        # report the first lexicographical name in that case.
         self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
 
     def test_convert_int(self):
@@ -5117,6 +5493,37 @@ def test_convert_repr_and_str(self):
         self.assertEqual(format(test_type.CONVERT_STRING_TEST_NAME_A), '5')
 
 
+class TestEnumDict(unittest.TestCase):
+    def test_enum_dict_in_metaclass(self):
+        """Test that EnumDict is usable as a class namespace"""
+        class Meta(type):
+            @classmethod
+            def __prepare__(metacls, cls, bases, **kwds):
+                return EnumDict(cls)
+
+        class MyClass(metaclass=Meta):
+            a = 1
+
+            with self.assertRaises(TypeError):
+                a = 2  # duplicate
+
+            with self.assertRaises(ValueError):
+                _a_sunder_ = 3
+
+    def test_enum_dict_standalone(self):
+        """Test that EnumDict is usable on its own"""
+        enumdict = EnumDict()
+        enumdict['a'] = 1
+
+        with self.assertRaises(TypeError):
+            enumdict['a'] = 'other value'
+
+        # Only MutableMapping interface is overridden for now.
+        # If this stops passing, update the documentation.
+        enumdict |= {'a': 'other value'}
+        self.assertEqual(enumdict['a'], 'other value')
+
+
 # helpers
 
 def enum_dir(cls):
@@ -5151,7 +5558,7 @@ def member_dir(member):
                     allowed.add(name)
                 else:
                     allowed.discard(name)
-            else:
+            elif name not in member._member_map_:
                 allowed.add(name)
     return sorted(allowed)
 
diff --git a/Lib/test/test_filecmp.py b/Lib/test/test_filecmp.py
index 9b5ac12bccc..2c83667b22f 100644
--- a/Lib/test/test_filecmp.py
+++ b/Lib/test/test_filecmp.py
@@ -1,5 +1,6 @@
 import filecmp
 import os
+import re
 import shutil
 import tempfile
 import unittest
@@ -8,11 +9,24 @@
 from test.support import os_helper
 
 
+def _create_file_shallow_equal(template_path, new_path):
+    """create a file with the same size and mtime but different content."""
+    shutil.copy2(template_path, new_path)
+    with open(new_path, 'r+b') as f:
+        next_char = bytearray(f.read(1))
+        next_char[0] = (next_char[0] + 1) % 256
+        f.seek(0)
+        f.write(next_char)
+    shutil.copystat(template_path, new_path)
+    assert os.stat(new_path).st_size == os.stat(template_path).st_size
+    assert os.stat(new_path).st_mtime == os.stat(template_path).st_mtime
+
 class FileCompareTestCase(unittest.TestCase):
     def setUp(self):
         self.name = os_helper.TESTFN
         self.name_same = os_helper.TESTFN + '-same'
         self.name_diff = os_helper.TESTFN + '-diff'
+        self.name_same_shallow = os_helper.TESTFN + '-same-shallow'
         data = 'Contents of file go here.\n'
         for name in [self.name, self.name_same, self.name_diff]:
             with open(name, 'w', encoding="utf-8") as output:
@@ -20,12 +34,19 @@ def setUp(self):
 
         with open(self.name_diff, 'a+', encoding="utf-8") as output:
             output.write('An extra line.\n')
+
+        for name in [self.name_same, self.name_diff]:
+            shutil.copystat(self.name, name)
+
+        _create_file_shallow_equal(self.name, self.name_same_shallow)
+
         self.dir = tempfile.gettempdir()
 
     def tearDown(self):
         os.unlink(self.name)
         os.unlink(self.name_same)
         os.unlink(self.name_diff)
+        os.unlink(self.name_same_shallow)
 
     def test_matching(self):
         self.assertTrue(filecmp.cmp(self.name, self.name),
@@ -36,12 +57,17 @@ def test_matching(self):
                         "Comparing file to identical file fails")
         self.assertTrue(filecmp.cmp(self.name, self.name_same, shallow=False),
                         "Comparing file to identical file fails")
+        self.assertTrue(filecmp.cmp(self.name, self.name_same_shallow),
+                        "Shallow identical files should be considered equal")
 
     def test_different(self):
         self.assertFalse(filecmp.cmp(self.name, self.name_diff),
                     "Mismatched files compare as equal")
         self.assertFalse(filecmp.cmp(self.name, self.dir),
                     "File and directory compare as equal")
+        self.assertFalse(filecmp.cmp(self.name, self.name_same_shallow,
+                                     shallow=False),
+                        "Mismatched file to shallow identical file compares as equal")
 
     def test_cache_clear(self):
         first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
@@ -56,6 +82,8 @@ def setUp(self):
         self.dir = os.path.join(tmpdir, 'dir')
         self.dir_same = os.path.join(tmpdir, 'dir-same')
         self.dir_diff = os.path.join(tmpdir, 'dir-diff')
+        self.dir_diff_file = os.path.join(tmpdir, 'dir-diff-file')
+        self.dir_same_shallow = os.path.join(tmpdir, 'dir-same-shallow')
 
         # Another dir is created under dir_same, but it has a name from the
         # ignored list so it should not affect testing results.
@@ -63,7 +91,17 @@ def setUp(self):
 
         self.caseinsensitive = os.path.normcase('A') == os.path.normcase('a')
         data = 'Contents of file go here.\n'
-        for dir in (self.dir, self.dir_same, self.dir_diff, self.dir_ignored):
+
+        shutil.rmtree(self.dir, True)
+        os.mkdir(self.dir)
+        subdir_path = os.path.join(self.dir, 'subdir')
+        os.mkdir(subdir_path)
+        dir_file_path = os.path.join(self.dir, "file")
+        with open(dir_file_path, 'w', encoding="utf-8") as output:
+            output.write(data)
+
+        for dir in (self.dir_same, self.dir_same_shallow,
+                    self.dir_diff, self.dir_diff_file):
             shutil.rmtree(dir, True)
             os.mkdir(dir)
             subdir_path = os.path.join(dir, 'subdir')
@@ -72,14 +110,25 @@ def setUp(self):
                 fn = 'FiLe'     # Verify case-insensitive comparison
             else:
                 fn = 'file'
-            with open(os.path.join(dir, fn), 'w', encoding="utf-8") as output:
-                output.write(data)
+
+            file_path = os.path.join(dir, fn)
+
+            if dir is self.dir_same_shallow:
+                _create_file_shallow_equal(dir_file_path, file_path)
+            else:
+                shutil.copy2(dir_file_path, file_path)
 
         with open(os.path.join(self.dir_diff, 'file2'), 'w', encoding="utf-8") as output:
             output.write('An extra file.\n')
 
+        # Add different file2 with respect to dir_diff
+        with open(os.path.join(self.dir_diff_file, 'file2'), 'w', encoding="utf-8") as output:
+            output.write('Different contents.\n')
+
+
     def tearDown(self):
-        for dir in (self.dir, self.dir_same, self.dir_diff):
+        for dir in (self.dir, self.dir_same, self.dir_diff,
+                    self.dir_same_shallow, self.dir_diff_file):
             shutil.rmtree(dir)
 
     def test_default_ignores(self):
@@ -102,25 +151,65 @@ def test_cmpfiles(self):
                                          shallow=False),
                         "Comparing directory to same fails")
 
-        # Add different file2
-        with open(os.path.join(self.dir, 'file2'), 'w', encoding="utf-8") as output:
-            output.write('Different contents.\n')
-
-        self.assertFalse(filecmp.cmpfiles(self.dir, self.dir_same,
+        self.assertFalse(filecmp.cmpfiles(self.dir, self.dir_diff_file,
                                      ['file', 'file2']) ==
                     (['file'], ['file2'], []),
                     "Comparing mismatched directories fails")
 
+    def test_cmpfiles_invalid_names(self):
+        # See https://github.com/python/cpython/issues/122400.
+        for file, desc in [
+            ('\x00', 'NUL bytes filename'),
+            (__file__ + '\x00', 'filename with embedded NUL bytes'),
+            ("\uD834\uDD1E.py", 'surrogate codes (MUSICAL SYMBOL G CLEF)'),
+            ('a' * 1_000_000, 'very long filename'),
+        ]:
+            for other_dir in [self.dir, self.dir_same, self.dir_diff]:
+                with self.subTest(f'cmpfiles: {desc}', other_dir=other_dir):
+                    res = filecmp.cmpfiles(self.dir, other_dir, [file])
+                    self.assertTupleEqual(res, ([], [], [file]))
+
+    def test_dircmp_invalid_names(self):
+        for bad_dir, desc in [
+            ('\x00', 'NUL bytes dirname'),
+            (f'Top{os.sep}Mid\x00', 'dirname with embedded NUL bytes'),
+            ("\uD834\uDD1E", 'surrogate codes (MUSICAL SYMBOL G CLEF)'),
+            ('a' * 1_000_000, 'very long dirname'),
+        ]:
+            d1 = filecmp.dircmp(self.dir, bad_dir)
+            d2 = filecmp.dircmp(bad_dir, self.dir)
+            for target in [
+                # attributes where os.listdir() raises OSError or ValueError
+                'left_list', 'right_list',
+                'left_only', 'right_only', 'common',
+            ]:
+                with self.subTest(f'dircmp(ok, bad): {desc}', target=target):
+                    with self.assertRaises((OSError, ValueError)):
+                        getattr(d1, target)
+                with self.subTest(f'dircmp(bad, ok): {desc}', target=target):
+                    with self.assertRaises((OSError, ValueError)):
+                        getattr(d2, target)
 
     def _assert_lists(self, actual, expected):
         """Assert that two lists are equal, up to ordering."""
         self.assertEqual(sorted(actual), sorted(expected))
 
+    def test_dircmp_identical_directories(self):
+        self._assert_dircmp_identical_directories()
+        self._assert_dircmp_identical_directories(shallow=False)
+
+    def test_dircmp_different_file(self):
+        self._assert_dircmp_different_file()
+        self._assert_dircmp_different_file(shallow=False)
 
-    def test_dircmp(self):
+    def test_dircmp_different_directories(self):
+        self._assert_dircmp_different_directories()
+        self._assert_dircmp_different_directories(shallow=False)
+
+    def _assert_dircmp_identical_directories(self, **options):
         # Check attributes for comparison of two identical directories
         left_dir, right_dir = self.dir, self.dir_same
-        d = filecmp.dircmp(left_dir, right_dir)
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         if self.caseinsensitive:
@@ -142,9 +231,10 @@ def test_dircmp(self):
         ]
         self._assert_report(d.report, expected_report)
 
+    def _assert_dircmp_different_directories(self, **options):
         # Check attributes for comparison of two different directories (right)
         left_dir, right_dir = self.dir, self.dir_diff
-        d = filecmp.dircmp(left_dir, right_dir)
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         self._assert_lists(d.left_list, ['file', 'subdir'])
@@ -164,12 +254,8 @@ def test_dircmp(self):
         self._assert_report(d.report, expected_report)
 
         # Check attributes for comparison of two different directories (left)
-        left_dir, right_dir = self.dir, self.dir_diff
-        shutil.move(
-            os.path.join(self.dir_diff, 'file2'),
-            os.path.join(self.dir, 'file2')
-        )
-        d = filecmp.dircmp(left_dir, right_dir)
+        left_dir, right_dir = self.dir_diff, self.dir
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         self._assert_lists(d.left_list, ['file', 'file2', 'subdir'])
@@ -180,27 +266,62 @@ def test_dircmp(self):
         self.assertEqual(d.same_files, ['file'])
         self.assertEqual(d.diff_files, [])
         expected_report = [
-            "diff {} {}".format(self.dir, self.dir_diff),
-            "Only in {} : ['file2']".format(self.dir),
+            "diff {} {}".format(self.dir_diff, self.dir),
+            "Only in {} : ['file2']".format(self.dir_diff),
             "Identical files : ['file']",
             "Common subdirectories : ['subdir']",
         ]
         self._assert_report(d.report, expected_report)
 
-        # Add different file2
-        with open(os.path.join(self.dir_diff, 'file2'), 'w', encoding="utf-8") as output:
-            output.write('Different contents.\n')
-        d = filecmp.dircmp(self.dir, self.dir_diff)
+
+    def _assert_dircmp_different_file(self, **options):
+        # A different file2
+        d = filecmp.dircmp(self.dir_diff, self.dir_diff_file, **options)
         self.assertEqual(d.same_files, ['file'])
         self.assertEqual(d.diff_files, ['file2'])
         expected_report = [
-            "diff {} {}".format(self.dir, self.dir_diff),
+            "diff {} {}".format(self.dir_diff, self.dir_diff_file),
             "Identical files : ['file']",
             "Differing files : ['file2']",
             "Common subdirectories : ['subdir']",
         ]
         self._assert_report(d.report, expected_report)
 
+    def test_dircmp_no_shallow_different_file(self):
+        # A non shallow different file2
+        d = filecmp.dircmp(self.dir, self.dir_same_shallow, shallow=False)
+        self.assertEqual(d.same_files, [])
+        self.assertEqual(d.diff_files, ['file'])
+        expected_report = [
+            "diff {} {}".format(self.dir, self.dir_same_shallow),
+            "Differing files : ['file']",
+            "Common subdirectories : ['subdir']",
+        ]
+        self._assert_report(d.report, expected_report)
+
+    def test_dircmp_shallow_same_file(self):
+        # A non shallow different file2
+        d = filecmp.dircmp(self.dir, self.dir_same_shallow)
+        self.assertEqual(d.same_files, ['file'])
+        self.assertEqual(d.diff_files, [])
+        expected_report = [
+            "diff {} {}".format(self.dir, self.dir_same_shallow),
+            "Identical files : ['file']",
+            "Common subdirectories : ['subdir']",
+        ]
+        self._assert_report(d.report, expected_report)
+
+    def test_dircmp_shallow_is_keyword_only(self):
+        with self.assertRaisesRegex(
+            TypeError,
+            re.escape("dircmp.__init__() takes from 3 to 5 positional arguments but 6 were given"),
+        ):
+            filecmp.dircmp(self.dir, self.dir_same, None, None, True)
+        self.assertIsInstance(
+            filecmp.dircmp(self.dir, self.dir_same, None, None, shallow=True),
+            filecmp.dircmp,
+        )
+
     def test_dircmp_subdirs_type(self):
         """Check that dircmp.subdirs respects subclassing."""
         class MyDirCmp(filecmp.dircmp):
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 09d35a77a1c..7450cd34143 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -5375,7 +5375,6 @@ def call_after_accept(conn_to_client):
 
 class TestEnumerations(unittest.TestCase):
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tlsversion(self):
         class CheckedTLSVersion(enum.IntEnum):
             MINIMUM_SUPPORTED = _ssl.PROTO_MINIMUM_SUPPORTED
@@ -5387,7 +5386,6 @@ class CheckedTLSVersion(enum.IntEnum):
             MAXIMUM_SUPPORTED = _ssl.PROTO_MAXIMUM_SUPPORTED
         enum._test_simple_enum(CheckedTLSVersion, TLSVersion)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tlscontenttype(self):
         class Checked_TLSContentType(enum.IntEnum):
             """Content types (record layer)
@@ -5403,7 +5401,6 @@ class Checked_TLSContentType(enum.IntEnum):
             INNER_CONTENT_TYPE = 0x101
         enum._test_simple_enum(Checked_TLSContentType, _TLSContentType)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tlsalerttype(self):
         class Checked_TLSAlertType(enum.IntEnum):
             """Alert types for TLSContentType.ALERT messages
@@ -5446,7 +5443,6 @@ class Checked_TLSAlertType(enum.IntEnum):
             NO_APPLICATION_PROTOCOL = 120
         enum._test_simple_enum(Checked_TLSAlertType, _TLSAlertType)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tlsmessagetype(self):
         class Checked_TLSMessageType(enum.IntEnum):
             """Message types (handshake protocol)
diff --git a/Lib/test/test_uuid.py b/Lib/test/test_uuid.py
index 4aa15f69932..ce396aa942b 100644
--- a/Lib/test/test_uuid.py
+++ b/Lib/test/test_uuid.py
@@ -33,7 +33,6 @@ def get_command_stdout(command, args):
 class BaseTestUUID:
     uuid = None
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_safe_uuid_enum(self):
         class CheckedSafeUUID(enum.Enum):
             safe = 0

From 5ae75a679bbf37da78ed56367a14c0bed7943773 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Fri, 2 Jan 2026 18:28:25 -0500
Subject: [PATCH 158/418] Update the fractions and ftplib libraries +
 associated tests - v.3.13.10 (#6607)

* Updated ftplib + test library

* Updated fractions + test library
---
 Lib/fractions.py           | 107 ++++++++++---
 Lib/ftplib.py              |  27 ++--
 Lib/test/test_fractions.py | 315 ++++++++++++++++++++++---------------
 Lib/test/test_ftplib.py    |  86 ++++++----
 4 files changed, 338 insertions(+), 197 deletions(-)

diff --git a/Lib/fractions.py b/Lib/fractions.py
index 88b418fe383..9d42e809875 100644
--- a/Lib/fractions.py
+++ b/Lib/fractions.py
@@ -139,6 +139,23 @@ def _round_to_figures(n, d, figures):
     return sign, significand, exponent
 
 
+# Pattern for matching non-float-style format specifications.
+_GENERAL_FORMAT_SPECIFICATION_MATCHER = re.compile(r"""
+    (?:
+        (?P<fill>.)?
+        (?P<align>[<>=^])
+    )?
+    (?P<sign>[-+ ]?)
+    # Alt flag forces a slash and denominator in the output, even for
+    # integer-valued Fraction objects.
+    (?P<alt>\#)?
+    # We don't implement the zeropad flag since there's no single obvious way
+    # to interpret it.
+    (?P<minimumwidth>0|[1-9][0-9]*)?
+    (?P<thousands_sep>[,_])?
+""", re.DOTALL | re.VERBOSE).fullmatch
+
+
 # Pattern for matching float-style format specifications;
 # supports 'e', 'E', 'f', 'F', 'g', 'G' and '%' presentation types.
 _FLOAT_FORMAT_SPECIFICATION_MATCHER = re.compile(r"""
@@ -414,27 +431,42 @@ def __str__(self):
         else:
             return '%s/%s' % (self._numerator, self._denominator)
 
-    def __format__(self, format_spec, /):
-        """Format this fraction according to the given format specification."""
-
-        # Backwards compatiblility with existing formatting.
-        if not format_spec:
-            return str(self)
+    def _format_general(self, match):
+        """Helper method for __format__.
 
+        Handles fill, alignment, signs, and thousands separators in the
+        case of no presentation type.
+        """
         # Validate and parse the format specifier.
-        match = _FLOAT_FORMAT_SPECIFICATION_MATCHER(format_spec)
-        if match is None:
-            raise ValueError(
-                f"Invalid format specifier {format_spec!r} "
-                f"for object of type {type(self).__name__!r}"
-            )
-        elif match["align"] is not None and match["zeropad"] is not None:
-            # Avoid the temptation to guess.
-            raise ValueError(
-                f"Invalid format specifier {format_spec!r} "
-                f"for object of type {type(self).__name__!r}; "
-                "can't use explicit alignment when zero-padding"
-            )
+        fill = match["fill"] or " "
+        align = match["align"] or ">"
+        pos_sign = "" if match["sign"] == "-" else match["sign"]
+        alternate_form = bool(match["alt"])
+        minimumwidth = int(match["minimumwidth"] or "0")
+        thousands_sep = match["thousands_sep"] or ''
+
+        # Determine the body and sign representation.
+        n, d = self._numerator, self._denominator
+        if d > 1 or alternate_form:
+            body = f"{abs(n):{thousands_sep}}/{d:{thousands_sep}}"
+        else:
+            body = f"{abs(n):{thousands_sep}}"
+        sign = '-' if n < 0 else pos_sign
+
+        # Pad with fill character if necessary and return.
+        padding = fill * (minimumwidth - len(sign) - len(body))
+        if align == ">":
+            return padding + sign + body
+        elif align == "<":
+            return sign + body + padding
+        elif align == "^":
+            half = len(padding) // 2
+            return padding[:half] + sign + body + padding[half:]
+        else:  # align == "="
+            return sign + padding + body
+
+    def _format_float_style(self, match):
+        """Helper method for __format__; handles float presentation types."""
         fill = match["fill"] or " "
         align = match["align"] or ">"
         pos_sign = "" if match["sign"] == "-" else match["sign"]
@@ -449,6 +481,9 @@ def __format__(self, format_spec, /):
         trim_point = not alternate_form
         exponent_indicator = "E" if presentation_type in "EFG" else "e"
 
+        if align == '=' and fill == '0':
+            zeropad = True
+
         # Round to get the digits we need, figure out where to place the point,
         # and decide whether to use scientific notation. 'point_pos' is the
         # relative to the _end_ of the digit string: that is, it's the number
@@ -530,7 +565,25 @@ def __format__(self, format_spec, /):
         else:  # align == "="
             return sign + padding + body
 
-    def _operator_fallbacks(monomorphic_operator, fallback_operator):
+    def __format__(self, format_spec, /):
+        """Format this fraction according to the given format specification."""
+
+        if match := _GENERAL_FORMAT_SPECIFICATION_MATCHER(format_spec):
+            return self._format_general(match)
+
+        if match := _FLOAT_FORMAT_SPECIFICATION_MATCHER(format_spec):
+            # Refuse the temptation to guess if both alignment _and_
+            # zero padding are specified.
+            if match["align"] is None or match["zeropad"] is None:
+                return self._format_float_style(match)
+
+        raise ValueError(
+            f"Invalid format specifier {format_spec!r} "
+            f"for object of type {type(self).__name__!r}"
+        )
+
+    def _operator_fallbacks(monomorphic_operator, fallback_operator,
+                            handle_complex=True):
         """Generates forward and reverse operators given a purely-rational
         operator and a function from the operator module.
 
@@ -617,7 +670,7 @@ def forward(a, b):
                 return monomorphic_operator(a, Fraction(b))
             elif isinstance(b, float):
                 return fallback_operator(float(a), b)
-            elif isinstance(b, complex):
+            elif handle_complex and isinstance(b, complex):
                 return fallback_operator(complex(a), b)
             else:
                 return NotImplemented
@@ -630,7 +683,7 @@ def reverse(b, a):
                 return monomorphic_operator(Fraction(a), b)
             elif isinstance(a, numbers.Real):
                 return fallback_operator(float(a), float(b))
-            elif isinstance(a, numbers.Complex):
+            elif handle_complex and isinstance(a, numbers.Complex):
                 return fallback_operator(complex(a), complex(b))
             else:
                 return NotImplemented
@@ -781,7 +834,7 @@ def _floordiv(a, b):
         """a // b"""
         return (a.numerator * b.denominator) // (a.denominator * b.numerator)
 
-    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv)
+    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv, False)
 
     def _divmod(a, b):
         """(a // b, a % b)"""
@@ -789,14 +842,14 @@ def _divmod(a, b):
         div, n_mod = divmod(a.numerator * db, da * b.numerator)
         return div, Fraction(n_mod, da * db)
 
-    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod)
+    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod, False)
 
     def _mod(a, b):
         """a % b"""
         da, db = a.denominator, b.denominator
         return Fraction((a.numerator * db) % (b.numerator * da), da * db)
 
-    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod)
+    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod, False)
 
     def __pow__(a, b):
         """a ** b
@@ -825,8 +878,10 @@ def __pow__(a, b):
                 # A fractional power will generally produce an
                 # irrational number.
                 return float(a) ** float(b)
-        else:
+        elif isinstance(b, (float, complex)):
             return float(a) ** b
+        else:
+            return NotImplemented
 
     def __rpow__(b, a):
         """a ** b"""
diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index a56e0c30857..10c5d1ea08a 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -900,11 +900,17 @@ def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
 
 def test():
     '''Test program.
-    Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
+    Usage: ftplib [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
 
-    -d dir
-    -l list
-    -p password
+    Options:
+      -d        increase debugging level
+      -r[file]  set alternate ~/.netrc file
+
+    Commands:
+      -l[dir]   list directory
+      -d[dir]   change the current directory
+      -p        toggle passive and active mode
+      file      retrieve the file and write it to stdout
     '''
 
     if len(sys.argv) < 2:
@@ -930,15 +936,14 @@ def test():
         netrcobj = netrc.netrc(rcfile)
     except OSError:
         if rcfile is not None:
-            sys.stderr.write("Could not open account file"
-                             " -- using anonymous login.")
+            print("Could not open account file -- using anonymous login.",
+                  file=sys.stderr)
     else:
         try:
             userid, acct, passwd = netrcobj.authenticators(host)
-        except KeyError:
+        except (KeyError, TypeError):
             # no account for host
-            sys.stderr.write(
-                    "No account -- using anonymous login.")
+            print("No account -- using anonymous login.", file=sys.stderr)
     ftp.login(userid, passwd, acct)
     for file in sys.argv[2:]:
         if file[:2] == '-l':
@@ -951,7 +956,9 @@ def test():
             ftp.set_pasv(not ftp.passiveserver)
         else:
             ftp.retrbinary('RETR ' + file, \
-                           sys.stdout.write, 1024)
+                           sys.stdout.buffer.write, 1024)
+            sys.stdout.buffer.flush()
+        sys.stdout.flush()
     ftp.quit()
 
 
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index 5c74e36a182..67c9b98d67f 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -2,7 +2,7 @@
 
 import cmath
 from decimal import Decimal
-# from test.support import requires_IEEE_754
+from test.support import requires_IEEE_754, adjust_int_max_str_digits
 import math
 import numbers
 import operator
@@ -19,7 +19,7 @@
 
 #locate file with float format test values
 test_dir = os.path.dirname(__file__) or os.curdir
-format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')
+format_testfile = os.path.join(test_dir, 'mathdata', 'formatfloat_testcases.txt')
 
 class DummyFloat(object):
     """Dummy float class for testing comparisons with Fractions"""
@@ -97,7 +97,7 @@ def typed_approx_eq(a, b):
 
 class Symbolic:
     """Simple non-numeric class for testing mixed arithmetic.
-    It is not Integral, Rational, Real or Complex, and cannot be conveted
+    It is not Integral, Rational, Real or Complex, and cannot be converted
     to int, float or complex. but it supports some arithmetic operations.
     """
     def __init__(self, value):
@@ -331,7 +331,7 @@ def testInit(self):
         self.assertRaises(TypeError, F, 3, 1j)
         self.assertRaises(TypeError, F, 1, 2, 3)
 
-    # @requires_IEEE_754
+    @requires_IEEE_754
     def testInitFromFloat(self):
         self.assertEqual((5, 2), _components(F(2.5)))
         self.assertEqual((0, 1), _components(F(-0.0)))
@@ -357,12 +357,14 @@ def testInitFromDecimal(self):
 
     def testFromString(self):
         self.assertEqual((5, 1), _components(F("5")))
+        self.assertEqual((5, 1), _components(F("005")))
         self.assertEqual((3, 2), _components(F("3/2")))
         self.assertEqual((3, 2), _components(F("3 / 2")))
         self.assertEqual((3, 2), _components(F(" \n  +3/2")))
         self.assertEqual((-3, 2), _components(F("-3/2  ")))
-        self.assertEqual((13, 2), _components(F("    013/02 \n  ")))
+        self.assertEqual((13, 2), _components(F("    0013/002 \n  ")))
         self.assertEqual((16, 5), _components(F(" 3.2 ")))
+        self.assertEqual((16, 5), _components(F("003.2")))
         self.assertEqual((-16, 5), _components(F(" -3.2 ")))
         self.assertEqual((-3, 1), _components(F(" -3. ")))
         self.assertEqual((3, 5), _components(F(" .6 ")))
@@ -381,116 +383,102 @@ def testFromString(self):
         self.assertRaisesMessage(
             ZeroDivisionError, "Fraction(3, 0)",
             F, "3/0")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '3/'",
-            F, "3/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '/2'",
-            F, "/2")
-        self.assertRaisesMessage(
-            # Denominators don't need a sign.
-            ValueError, "Invalid literal for Fraction: '3/+2'",
-            F, "3/+2")
-        self.assertRaisesMessage(
-            # Imitate float's parsing.
-            ValueError, "Invalid literal for Fraction: '+ 3/2'",
-            F, "+ 3/2")
-        self.assertRaisesMessage(
-            # Avoid treating '.' as a regex special character.
-            ValueError, "Invalid literal for Fraction: '3a2'",
-            F, "3a2")
-        self.assertRaisesMessage(
-            # Don't accept combinations of decimals and rationals.
-            ValueError, "Invalid literal for Fraction: '3/7.2'",
-            F, "3/7.2")
-        self.assertRaisesMessage(
-            # Don't accept combinations of decimals and rationals.
-            ValueError, "Invalid literal for Fraction: '3.2/7'",
-            F, "3.2/7")
-        self.assertRaisesMessage(
-            # Allow 3. and .3, but not .
-            ValueError, "Invalid literal for Fraction: '.'",
-            F, ".")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_'",
-            F, "_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_1'",
-            F, "_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1__2'",
-            F, "1__2")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '/_'",
-            F, "/_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1_/'",
-            F, "1_/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_1/'",
-            F, "_1/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1__2/'",
-            F, "1__2/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/_'",
-            F, "1/_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/_1'",
-            F, "1/_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/1__2'",
-            F, "1/1__2")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1._111'",
-            F, "1._111")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1__1'",
-            F, "1.1__1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1e+_1'",
-            F, "1.1e+_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1e+1__1'",
-            F, "1.1e+1__1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '123.dd'",
-            F, "123.dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '123.5_dd'",
-            F, "123.5_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: 'dd.5'",
-            F, "dd.5")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '7_dd'",
-            F, "7_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/dd'",
-            F, "1/dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/123_dd'",
-            F, "1/123_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '789edd'",
-            F, "789edd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '789e2_dd'",
-            F, "789e2_dd")
+
+        def check_invalid(s):
+            msg = "Invalid literal for Fraction: " + repr(s)
+            self.assertRaisesMessage(ValueError, msg, F, s)
+
+        check_invalid("3/")
+        check_invalid("/2")
+        # Denominators don't need a sign.
+        check_invalid("3/+2")
+        check_invalid("3/-2")
+        # Imitate float's parsing.
+        check_invalid("+ 3/2")
+        check_invalid("- 3/2")
+        # Avoid treating '.' as a regex special character.
+        check_invalid("3a2")
+        # Don't accept combinations of decimals and rationals.
+        check_invalid("3/7.2")
+        check_invalid("3.2/7")
+        # No space around dot.
+        check_invalid("3 .2")
+        check_invalid("3. 2")
+        # No space around e.
+        check_invalid("3.2 e1")
+        check_invalid("3.2e 1")
+        # Fractional part don't need a sign.
+        check_invalid("3.+2")
+        check_invalid("3.-2")
+        # Only accept base 10.
+        check_invalid("0x10")
+        check_invalid("0x10/1")
+        check_invalid("1/0x10")
+        check_invalid("0x10.")
+        check_invalid("0x10.1")
+        check_invalid("1.0x10")
+        check_invalid("1.0e0x10")
+        # Only accept decimal digits.
+        check_invalid("³")
+        check_invalid("³/2")
+        check_invalid("3/²")
+        check_invalid("³.2")
+        check_invalid("3.²")
+        check_invalid("3.2e²")
+        check_invalid("¼")
+        # Allow 3. and .3, but not .
+        check_invalid(".")
+        check_invalid("_")
+        check_invalid("_1")
+        check_invalid("1__2")
+        check_invalid("/_")
+        check_invalid("1_/")
+        check_invalid("_1/")
+        check_invalid("1__2/")
+        check_invalid("1/_")
+        check_invalid("1/_1")
+        check_invalid("1/1__2")
+        check_invalid("1._111")
+        check_invalid("1.1__1")
+        check_invalid("1.1e+_1")
+        check_invalid("1.1e+1__1")
+        check_invalid("123.dd")
+        check_invalid("123.5_dd")
+        check_invalid("dd.5")
+        check_invalid("7_dd")
+        check_invalid("1/dd")
+        check_invalid("1/123_dd")
+        check_invalid("789edd")
+        check_invalid("789e2_dd")
         # Test catastrophic backtracking.
         val = "9"*50 + "_"
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '" + val + "'",
-            F, val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/" + val + "'",
-            F, "1/" + val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1." + val + "'",
-            F, "1." + val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1+e" + val + "'",
-            F, "1.1+e" + val)
+        check_invalid(val)
+        check_invalid("1/" + val)
+        check_invalid("1." + val)
+        check_invalid("." + val)
+        check_invalid("1.1+e" + val)
+        check_invalid("1.1e" + val)
+
+    def test_limit_int(self):
+        maxdigits = 5000
+        with adjust_int_max_str_digits(maxdigits):
+            msg = 'Exceeds the limit'
+            val = '1' * maxdigits
+            num = (10**maxdigits - 1)//9
+            self.assertEqual((num, 1), _components(F(val)))
+            self.assertRaisesRegex(ValueError, msg, F, val + '1')
+            self.assertEqual((num, 2), _components(F(val + '/2')))
+            self.assertRaisesRegex(ValueError, msg, F, val + '1/2')
+            self.assertEqual((1, num), _components(F('1/' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '1/1' + val)
+            self.assertEqual(((10**(maxdigits+1) - 1)//9, 10**maxdigits),
+                             _components(F('1.' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '1.1' + val)
+            self.assertEqual((num, 10**maxdigits), _components(F('.' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '.1' + val)
+            self.assertRaisesRegex(ValueError, msg, F, '1.1e1' + val)
+            self.assertEqual((11, 10), _components(F('1.1e' + '0' * maxdigits)))
+            self.assertRaisesRegex(ValueError, msg, F, '1.1e' + '0' * (maxdigits+1))
 
     def testImmutable(self):
         r = F(7, 3)
@@ -922,21 +910,21 @@ def testMixedPower(self):
         self.assertTypedEquals(Root(4) ** F(2, 1), Root(4, F(1)))
         self.assertTypedEquals(Root(4) ** F(-2, 1), Root(4, -F(1)))
         self.assertTypedEquals(Root(4) ** F(-2, 3), Root(4, -3.0))
-        self.assertEqual(F(3, 2) ** SymbolicReal('X'), SymbolicReal('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** SymbolicReal('X'), SymbolicReal('3/2 ** X'))
         self.assertEqual(SymbolicReal('X') ** F(3, 2), SymbolicReal('X ** 1.5'))
 
-        self.assertTypedEquals(F(3, 2) ** Rect(2, 0), Polar(2.25, 0.0))
-        self.assertTypedEquals(F(1, 1) ** Rect(2, 3), Polar(1.0, 0.0))
+        self.assertTypedEquals(F(3, 2) ** Rect(2, 0), Polar(F(9,4), 0.0))
+        self.assertTypedEquals(F(1, 1) ** Rect(2, 3), Polar(F(1), 0.0))
         self.assertTypedEquals(F(3, 2) ** RectComplex(2, 0), Polar(2.25, 0.0))
         self.assertTypedEquals(F(1, 1) ** RectComplex(2, 3), Polar(1.0, 0.0))
         self.assertTypedEquals(Polar(4, 2) ** F(3, 2), Polar(8.0, 3.0))
         self.assertTypedEquals(Polar(4, 2) ** F(3, 1), Polar(64, 6))
         self.assertTypedEquals(Polar(4, 2) ** F(-3, 1), Polar(0.015625, -6))
         self.assertTypedEquals(Polar(4, 2) ** F(-3, 2), Polar(0.125, -3.0))
-        self.assertEqual(F(3, 2) ** SymbolicComplex('X'), SymbolicComplex('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** SymbolicComplex('X'), SymbolicComplex('3/2 ** X'))
         self.assertEqual(SymbolicComplex('X') ** F(3, 2), SymbolicComplex('X ** 1.5'))
 
-        self.assertEqual(F(3, 2) ** Symbolic('X'), Symbolic('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** Symbolic('X'), Symbolic('3/2 ** X'))
         self.assertEqual(Symbolic('X') ** F(3, 2), Symbolic('X ** 1.5'))
 
     def testMixingWithDecimal(self):
@@ -1165,12 +1153,50 @@ def denominator(self):
         self.assertEqual(type(f.denominator), myint)
 
     def test_format_no_presentation_type(self):
-        # Triples (fraction, specification, expected_result)
+        # Triples (fraction, specification, expected_result).
         testcases = [
-            (F(1, 3), '', '1/3'),
-            (F(-1, 3), '', '-1/3'),
-            (F(3), '', '3'),
-            (F(-3), '', '-3'),
+            # Explicit sign handling
+            (F(2, 3), '+', '+2/3'),
+            (F(-2, 3), '+', '-2/3'),
+            (F(3), '+', '+3'),
+            (F(-3), '+', '-3'),
+            (F(2, 3), ' ', ' 2/3'),
+            (F(-2, 3), ' ', '-2/3'),
+            (F(3), ' ', ' 3'),
+            (F(-3), ' ', '-3'),
+            (F(2, 3), '-', '2/3'),
+            (F(-2, 3), '-', '-2/3'),
+            (F(3), '-', '3'),
+            (F(-3), '-', '-3'),
+            # Padding
+            (F(0), '5', '    0'),
+            (F(2, 3), '5', '  2/3'),
+            (F(-2, 3), '5', ' -2/3'),
+            (F(2, 3), '0', '2/3'),
+            (F(2, 3), '1', '2/3'),
+            (F(2, 3), '2', '2/3'),
+            # Alignment
+            (F(2, 3), '<5', '2/3  '),
+            (F(2, 3), '>5', '  2/3'),
+            (F(2, 3), '^5', ' 2/3 '),
+            (F(2, 3), '=5', '  2/3'),
+            (F(-2, 3), '<5', '-2/3 '),
+            (F(-2, 3), '>5', ' -2/3'),
+            (F(-2, 3), '^5', '-2/3 '),
+            (F(-2, 3), '=5', '- 2/3'),
+            # Fill
+            (F(2, 3), 'X>5', 'XX2/3'),
+            (F(-2, 3), '.<5', '-2/3.'),
+            (F(-2, 3), '\n^6', '\n-2/3\n'),
+            # Thousands separators
+            (F(1234, 5679), ',', '1,234/5,679'),
+            (F(-1234, 5679), '_', '-1_234/5_679'),
+            (F(1234567), '_', '1_234_567'),
+            (F(-1234567), ',', '-1,234,567'),
+            # Alternate form forces a slash in the output
+            (F(123), '#', '123/1'),
+            (F(-123), '#', '-123/1'),
+            (F(0), '#', '0/1'),
         ]
         for fraction, spec, expected in testcases:
             with self.subTest(fraction=fraction, spec=spec):
@@ -1385,11 +1411,8 @@ def test_format_f_presentation_type(self):
             (F('-1234.5678'), '08,.0f', '-001,235'),
             (F('-1234.5678'), '09,.0f', '-0,001,235'),
             # Corner-case - zero-padding specified through fill and align
-            # instead of the zero-pad character - in this case, treat '0' as a
-            # regular fill character and don't attempt to insert commas into
-            # the filled portion. This differs from the int and float
-            # behaviour.
-            (F('1234.5678'), '0=12,.2f', '00001,234.57'),
+            # instead of the zero-pad character.
+            (F('1234.5678'), '0=12,.2f', '0,001,234.57'),
             # Corner case where it's not clear whether the '0' indicates zero
             # padding or gives the minimum width, but there's still an obvious
             # answer to give. We want this to work in case the minimum width
@@ -1534,13 +1557,17 @@ def test_invalid_formats(self):
             '.%',
             # Z instead of z for negative zero suppression
             'Z.2f'
+            # z flag not supported for general formatting
+            'z',
+            # zero padding not supported for general formatting
+            '05',
         ]
         for spec in invalid_specs:
             with self.subTest(spec=spec):
                 with self.assertRaises(ValueError):
                     format(fraction, spec)
 
-    # @requires_IEEE_754
+    @requires_IEEE_754
     def test_float_format_testfile(self):
         with open(format_testfile, encoding="utf-8") as testfile:
             for line in testfile:
@@ -1564,6 +1591,36 @@ def test_float_format_testfile(self):
                     self.assertEqual(float(format(f, fmt2)), float(rhs))
                     self.assertEqual(float(format(-f, fmt2)), float('-' + rhs))
 
+    # TODO: RUSTPYTHON
+    # TypeError: '%' not supported between instances of 'Fraction' and 'complex'
+    @unittest.expectedFailure
+    def test_complex_handling(self):
+        # See issue gh-102840 for more details.
+
+        a = F(1, 2)
+        b = 1j
+        message = "unsupported operand type(s) for %s: '%s' and '%s'"
+        # test forward
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "Fraction", "complex"),
+                                 operator.mod, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "Fraction", "complex"),
+                                 operator.floordiv, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "Fraction", "complex"),
+                                 divmod, a, b)
+        # test reverse
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "complex", "Fraction"),
+                                 operator.mod, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "complex", "Fraction"),
+                                 operator.floordiv, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "complex", "Fraction"),
+                                 divmod, b, a)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index b3e4e776a47..ae4ec5dbfb7 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -18,6 +18,7 @@
 
 from unittest import TestCase, skipUnless
 from test import support
+from test.support import requires_subprocess
 from test.support import threading_helper
 from test.support import socket_helper
 from test.support import warnings_helper
@@ -32,7 +33,7 @@
 DEFAULT_ENCODING = 'utf-8'
 # the dummy data returned by server over the data channel when
 # RETR, LIST, NLST, MLSD commands are issued
-RETR_DATA = 'abcde12345\r\n' * 1000 + 'non-ascii char \xAE\r\n'
+RETR_DATA = 'abcde\xB9\xB2\xB3\xA4\xA6\r\n' * 1000
 LIST_DATA = 'foo\r\nbar\r\n non-ascii char \xAE\r\n'
 NLST_DATA = 'foo\r\nbar\r\n non-ascii char \xAE\r\n'
 MLSD_DATA = ("type=cdir;perm=el;unique==keVO1+ZF4; test\r\n"
@@ -67,11 +68,11 @@ class DummyDTPHandler(asynchat.async_chat):
     def __init__(self, conn, baseclass):
         asynchat.async_chat.__init__(self, conn)
         self.baseclass = baseclass
-        self.baseclass.last_received_data = ''
+        self.baseclass.last_received_data = bytearray()
         self.encoding = baseclass.encoding
 
     def handle_read(self):
-        new_data = self.recv(1024).decode(self.encoding, 'replace')
+        new_data = self.recv(1024)
         self.baseclass.last_received_data += new_data
 
     def handle_close(self):
@@ -80,7 +81,7 @@ def handle_close(self):
         # (behaviour witnessed with test_data_connection)
         if not self.dtp_conn_closed:
             self.baseclass.push('226 transfer complete')
-            self.close()
+            self.shutdown()
             self.dtp_conn_closed = True
 
     def push(self, what):
@@ -94,6 +95,9 @@ def push(self, what):
     def handle_error(self):
         default_error_handler()
 
+    def shutdown(self):
+        self.close()
+
 
 class DummyFTPHandler(asynchat.async_chat):
 
@@ -107,7 +111,7 @@ def __init__(self, conn, encoding=DEFAULT_ENCODING):
         self.in_buffer = []
         self.dtp = None
         self.last_received_cmd = None
-        self.last_received_data = ''
+        self.last_received_data = bytearray()
         self.next_response = ''
         self.next_data = None
         self.rest = None
@@ -226,7 +230,7 @@ def cmd_type(self, arg):
 
     def cmd_quit(self, arg):
         self.push('221 quit ok')
-        self.close()
+        self.shutdown()
 
     def cmd_abor(self, arg):
         self.push('226 abor ok')
@@ -313,7 +317,7 @@ def handle_accepted(self, conn, addr):
         self.handler_instance = self.handler(conn, encoding=self.encoding)
 
     def handle_connect(self):
-        self.close()
+        self.shutdown()
     handle_read = handle_connect
 
     def writable(self):
@@ -325,8 +329,8 @@ def handle_error(self):
 
 if ssl is not None:
 
-    CERTFILE = os.path.join(os.path.dirname(__file__), "keycert3.pem")
-    CAFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
+    CERTFILE = os.path.join(os.path.dirname(__file__), "certdata", "keycert3.pem")
+    CAFILE = os.path.join(os.path.dirname(__file__), "certdata", "pycacert.pem")
 
     class SSLConnection(asyncore.dispatcher):
         """An asyncore.dispatcher subclass supporting TLS/SSL."""
@@ -425,12 +429,12 @@ def recv(self, buffer_size):
         def handle_error(self):
             default_error_handler()
 
-        def close(self):
+        def shutdown(self):
             if (isinstance(self.socket, ssl.SSLSocket) and
                     self.socket._sslobj is not None):
                 self._do_ssl_shutdown()
             else:
-                super(SSLConnection, self).close()
+                self.close()
 
 
     class DummyTLS_DTPHandler(SSLConnection, DummyDTPHandler):
@@ -542,8 +546,8 @@ def test_set_pasv(self):
         self.assertFalse(self.client.passiveserver)
 
     def test_voidcmd(self):
-        self.client.voidcmd('echo 200')
-        self.client.voidcmd('echo 299')
+        self.assertEqual(self.client.voidcmd('echo 200'), '200')
+        self.assertEqual(self.client.voidcmd('echo 299'), '299')
         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')
         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')
 
@@ -589,37 +593,44 @@ def test_quit(self):
     def test_abort(self):
         self.client.abort()
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_retrbinary(self):
-        def callback(data):
-            received.append(data.decode(self.client.encoding))
         received = []
-        self.client.retrbinary('retr', callback)
-        self.check_data(''.join(received), RETR_DATA)
+        self.client.retrbinary('retr', received.append)
+        self.check_data(b''.join(received),
+                        RETR_DATA.encode(self.client.encoding))
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_retrbinary_rest(self):
-        def callback(data):
-            received.append(data.decode(self.client.encoding))
         for rest in (0, 10, 20):
             received = []
-            self.client.retrbinary('retr', callback, rest=rest)
-            self.check_data(''.join(received), RETR_DATA[rest:])
+            self.client.retrbinary('retr', received.append, rest=rest)
+            self.check_data(b''.join(received),
+                            RETR_DATA[rest:].encode(self.client.encoding))
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_retrlines(self):
         received = []
         self.client.retrlines('retr', received.append)
         self.check_data(''.join(received), RETR_DATA.replace('\r\n', ''))
 
-    @unittest.skip("TODO: RUSTPYTHON; weird limiting to 8192, something w/ buffering?")
+    @unittest.skip('TODO: RUSTPYTHON; weird limiting to 8192, something w/ buffering?')
     def test_storbinary(self):
         f = io.BytesIO(RETR_DATA.encode(self.client.encoding))
         self.client.storbinary('stor', f)
-        self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
+        self.check_data(self.server.handler_instance.last_received_data,
+                        RETR_DATA.encode(self.server.encoding))
         # test new callback arg
         flag = []
         f.seek(0)
         self.client.storbinary('stor', f, callback=lambda x: flag.append(None))
         self.assertTrue(flag)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_storbinary_rest(self):
         data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
         f = io.BytesIO(data)
@@ -628,11 +639,14 @@ def test_storbinary_rest(self):
             self.client.storbinary('stor', f, rest=r)
             self.assertEqual(self.server.handler_instance.rest, str(r))
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_storlines(self):
         data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
         f = io.BytesIO(data)
         self.client.storlines('stor', f)
-        self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
+        self.check_data(self.server.handler_instance.last_received_data,
+                        RETR_DATA.encode(self.server.encoding))
         # test new callback arg
         flag = []
         f.seek(0)
@@ -644,15 +658,21 @@ def test_storlines(self):
         with warnings_helper.check_warnings(('', BytesWarning), quiet=True):
             self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_nlst(self):
         self.client.nlst()
         self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_dir(self):
         l = []
-        self.client.dir(lambda x: l.append(x))
+        self.client.dir(l.append)
         self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_mlsd(self):
         list(self.client.mlsd())
         list(self.client.mlsd(path='/'))
@@ -839,6 +859,8 @@ def test_storlines_too_long(self):
         f = io.BytesIO(b'x' * self.client.maxline * 2)
         self.assertRaises(ftplib.Error, self.client.storlines, 'stor', f)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # TimeoutError: The read operation timed out
     def test_encoding_param(self):
         encodings = ['latin-1', 'utf-8']
         for encoding in encodings:
@@ -890,12 +912,10 @@ def test_makepasv(self):
 
     def test_transfer(self):
         def retr():
-            def callback(data):
-                received.append(data.decode(self.client.encoding))
             received = []
-            self.client.retrbinary('retr', callback)
-            self.assertEqual(len(''.join(received)), len(RETR_DATA))
-            self.assertEqual(''.join(received), RETR_DATA)
+            self.client.retrbinary('retr', received.append)
+            self.assertEqual(b''.join(received),
+                             RETR_DATA.encode(self.client.encoding))
         self.client.set_pasv(True)
         retr()
         self.client.set_pasv(False)
@@ -903,7 +923,7 @@ def callback(data):
 
 
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; figure out why do_handshake() is throwing 'ssl session has been shut down'. SslSession object?")
+@requires_subprocess()
 class TestTLS_FTPClassMixin(TestFTPClass):
     """Repeat TestFTPClass tests starting the TLS layer for both control
     and data connections first.
@@ -920,7 +940,7 @@ def setUp(self, encoding=DEFAULT_ENCODING):
 
 
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; fix ssl")
+@requires_subprocess()
 class TestTLS_FTPClass(TestCase):
     """Specific TLS_FTP class tests."""
 
@@ -1004,6 +1024,8 @@ def test_context(self):
             self.assertIs(sock.context, ctx)
             self.assertIsInstance(sock, ssl.SSLSocket)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_ccc(self):
         self.assertRaises(ValueError, self.client.ccc)
         self.client.login(secure=True)

From cff37af5f67c1c9f64fd655dd48d638151ddb505 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 3 Jan 2026 11:43:29 +0900
Subject: [PATCH 159/418] Fix locale.getencoding, overlapped.getresult, chdir
 for windows  (#6629)

* locale getencoding

* overlapped.getresult

* Fix windows chdir

* mark flaky
---
 Lib/test/_test_multiprocessing.py |   1 +
 crates/stdlib/src/locale.rs       |  37 ++++++
 crates/stdlib/src/overlapped.rs   | 183 +++++++++++++++++++++++++++++-
 crates/vm/src/stdlib/os.rs        |  35 +++++-
 4 files changed, 253 insertions(+), 3 deletions(-)

diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 351887819e6..093139e45e5 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -1459,6 +1459,7 @@ def _acquire_release(lock, timeout, l=None, n=1):
         for _ in range(n):
             lock.release()
 
+    @unittest.skip("TODO: RUSTPYTHON; flaky test")
     def test_repr_rlock(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
index c65f861d208..51cf352590b 100644
--- a/crates/stdlib/src/locale.rs
+++ b/crates/stdlib/src/locale.rs
@@ -49,6 +49,8 @@ mod _locale {
         convert::ToPyException,
         function::OptionalArg,
     };
+    #[cfg(windows)]
+    use windows_sys::Win32::Globalization::GetACP;
 
     #[cfg(all(
         unix,
@@ -260,4 +262,39 @@ mod _locale {
             pystr_from_raw_cstr(vm, result)
         }
     }
+
+    /// Get the current locale encoding.
+    #[pyfunction]
+    fn getencoding() -> String {
+        #[cfg(windows)]
+        {
+            // On Windows, use GetACP() to get the ANSI code page
+            let acp = unsafe { GetACP() };
+            format!("cp{}", acp)
+        }
+        #[cfg(not(windows))]
+        {
+            // On Unix, use nl_langinfo(CODESET) or fallback to UTF-8
+            #[cfg(all(
+                unix,
+                not(any(target_os = "ios", target_os = "android", target_os = "redox"))
+            ))]
+            {
+                unsafe {
+                    let codeset = libc::nl_langinfo(libc::CODESET);
+                    if !codeset.is_null()
+                        && let Ok(s) = CStr::from_ptr(codeset).to_str()
+                        && !s.is_empty()
+                    {
+                        return s.to_string();
+                    }
+                }
+                "UTF-8".to_string()
+            }
+            #[cfg(any(target_os = "ios", target_os = "android", target_os = "redox"))]
+            {
+                "UTF-8".to_string()
+            }
+        }
+    }
 }
diff --git a/crates/stdlib/src/overlapped.rs b/crates/stdlib/src/overlapped.rs
index 1c74ee271b9..664aa3f392c 100644
--- a/crates/stdlib/src/overlapped.rs
+++ b/crates/stdlib/src/overlapped.rs
@@ -8,16 +8,17 @@ mod _overlapped {
     // straight-forward port of Modules/overlapped.c
 
     use crate::vm::{
-        Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
         builtins::{PyBaseExceptionRef, PyBytesRef, PyType},
         common::lock::PyMutex,
         convert::{ToPyException, ToPyObject},
+        function::OptionalArg,
         protocol::PyBuffer,
         types::Constructor,
     };
     use windows_sys::Win32::{
         Foundation::{self, GetLastError, HANDLE},
-        Networking::WinSock::SOCKADDR_IN6,
+        Networking::WinSock::{AF_INET, AF_INET6, SOCKADDR_IN, SOCKADDR_IN6},
         System::IO::OVERLAPPED,
     };
 
@@ -153,6 +154,51 @@ mod _overlapped {
         overlapped.Internal != (Foundation::STATUS_PENDING as usize)
     }
 
+    /// Parse a SOCKADDR_IN6 (which can also hold IPv4 addresses) to a Python address tuple
+    fn unparse_address(
+        addr: &SOCKADDR_IN6,
+        _addr_len: libc::c_int,
+        vm: &VirtualMachine,
+    ) -> PyObjectRef {
+        use crate::vm::convert::ToPyObject;
+
+        unsafe {
+            let family = addr.sin6_family;
+            if family == AF_INET {
+                // IPv4 address stored in SOCKADDR_IN6 structure
+                let addr_in = &*(addr as *const SOCKADDR_IN6 as *const SOCKADDR_IN);
+                let ip_bytes = addr_in.sin_addr.S_un.S_un_b;
+                let ip_str = format!(
+                    "{}.{}.{}.{}",
+                    ip_bytes.s_b1, ip_bytes.s_b2, ip_bytes.s_b3, ip_bytes.s_b4
+                );
+                let port = u16::from_be(addr_in.sin_port);
+                (ip_str, port).to_pyobject(vm)
+            } else if family == AF_INET6 {
+                // IPv6 address
+                let ip_bytes = addr.sin6_addr.u.Byte;
+                let ip_str = format!(
+                    "{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}",
+                    u16::from_be_bytes([ip_bytes[0], ip_bytes[1]]),
+                    u16::from_be_bytes([ip_bytes[2], ip_bytes[3]]),
+                    u16::from_be_bytes([ip_bytes[4], ip_bytes[5]]),
+                    u16::from_be_bytes([ip_bytes[6], ip_bytes[7]]),
+                    u16::from_be_bytes([ip_bytes[8], ip_bytes[9]]),
+                    u16::from_be_bytes([ip_bytes[10], ip_bytes[11]]),
+                    u16::from_be_bytes([ip_bytes[12], ip_bytes[13]]),
+                    u16::from_be_bytes([ip_bytes[14], ip_bytes[15]]),
+                );
+                let port = u16::from_be(addr.sin6_port);
+                let flowinfo = addr.sin6_flowinfo;
+                let scope_id = addr.Anonymous.sin6_scope_id;
+                (ip_str, port, flowinfo, scope_id).to_pyobject(vm)
+            } else {
+                // Unknown address family, return None
+                vm.ctx.none()
+            }
+        }
+    }
+
     #[pyclass(with(Constructor))]
     impl Overlapped {
         #[pygetset]
@@ -259,6 +305,139 @@ mod _overlapped {
             }
             Ok(())
         }
+
+        #[pymethod]
+        fn getresult(zelf: &Py<Self>, wait: OptionalArg<bool>, vm: &VirtualMachine) -> PyResult {
+            use windows_sys::Win32::Foundation::{
+                ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_SUCCESS,
+            };
+            use windows_sys::Win32::System::IO::GetOverlappedResult;
+
+            let mut inner = zelf.inner.lock();
+            let wait = wait.unwrap_or(false);
+
+            // Check operation state
+            if matches!(inner.data, OverlappedData::None) {
+                return Err(vm.new_value_error("operation not yet attempted".to_owned()));
+            }
+            if matches!(inner.data, OverlappedData::NotStarted) {
+                return Err(vm.new_value_error("operation failed to start".to_owned()));
+            }
+
+            // Get the result
+            let mut transferred: u32 = 0;
+            let ret = unsafe {
+                GetOverlappedResult(
+                    inner.handle,
+                    &inner.overlapped,
+                    &mut transferred,
+                    if wait { 1 } else { 0 },
+                )
+            };
+
+            let err = if ret != 0 {
+                ERROR_SUCCESS
+            } else {
+                unsafe { GetLastError() }
+            };
+            inner.error = err;
+
+            // Handle errors
+            match err {
+                ERROR_SUCCESS | ERROR_MORE_DATA => {}
+                ERROR_BROKEN_PIPE => {
+                    // For read operations, broken pipe is acceptable
+                    match &inner.data {
+                        OverlappedData::Read(_) | OverlappedData::ReadInto(_) => {}
+                        OverlappedData::ReadFrom(rf)
+                            if rf.result.is(&vm.ctx.none())
+                                || rf.allocated_buffer.is(&vm.ctx.none()) =>
+                        {
+                            return Err(from_windows_err(err, vm));
+                        }
+                        OverlappedData::ReadFrom(_) => {}
+                        OverlappedData::ReadFromInto(rfi) if rfi.result.is(&vm.ctx.none()) => {
+                            return Err(from_windows_err(err, vm));
+                        }
+                        OverlappedData::ReadFromInto(_) => {}
+                        _ => return Err(from_windows_err(err, vm)),
+                    }
+                }
+                ERROR_IO_PENDING => {
+                    return Err(from_windows_err(err, vm));
+                }
+                _ => return Err(from_windows_err(err, vm)),
+            }
+
+            // Return result based on operation type
+            match &inner.data {
+                OverlappedData::Read(buf) => {
+                    // Resize buffer to actual bytes read
+                    let bytes = buf.as_bytes();
+                    let result = if transferred as usize != bytes.len() {
+                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    } else {
+                        buf.clone()
+                    };
+                    Ok(result.into())
+                }
+                OverlappedData::ReadInto(_) => {
+                    // Return number of bytes read
+                    Ok(vm.ctx.new_int(transferred).into())
+                }
+                OverlappedData::Write(_) => {
+                    // Return number of bytes written
+                    Ok(vm.ctx.new_int(transferred).into())
+                }
+                OverlappedData::Accept(_) => {
+                    // Return None for accept
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::Connect => {
+                    // Return None for connect
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::Disconnect => {
+                    // Return None for disconnect
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::ConnectNamedPipe => {
+                    // Return None for connect named pipe
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::WaitNamedPipeAndConnect => {
+                    // Return None
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::ReadFrom(rf) => {
+                    // Return (resized_buffer, (host, port)) tuple
+                    let buf = rf
+                        .allocated_buffer
+                        .downcast_ref::<crate::vm::builtins::PyBytes>()
+                        .unwrap();
+                    let bytes = buf.as_bytes();
+                    let resized_buf = if transferred as usize != bytes.len() {
+                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    } else {
+                        buf.to_owned()
+                    };
+                    let addr_tuple = unparse_address(&rf.address, rf.address_length, vm);
+                    Ok(vm
+                        .ctx
+                        .new_tuple(vec![resized_buf.into(), addr_tuple])
+                        .into())
+                }
+                OverlappedData::ReadFromInto(rfi) => {
+                    // Return (transferred, (host, port)) tuple
+                    let addr_tuple = unparse_address(&rfi.address, rfi.address_length, vm);
+                    Ok(vm
+                        .ctx
+                        .new_tuple(vec![vm.ctx.new_int(transferred).into(), addr_tuple])
+                        .into())
+                }
+                _ => Ok(vm.ctx.none()),
+            }
+        }
     }
 
     impl Constructor for Overlapped {
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index fa1495fcdbf..416f26018cb 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -1124,7 +1124,40 @@ pub(super) mod _os {
     #[pyfunction]
     fn chdir(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
         env::set_current_dir(&path.path)
-            .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
+
+        #[cfg(windows)]
+        {
+            // win32_wchdir()
+
+            // On Windows, set the per-drive CWD environment variable (=X:)
+            // This is required for GetFullPathNameW to work correctly with drive-relative paths
+
+            use std::os::windows::ffi::OsStrExt;
+            use windows_sys::Win32::System::Environment::SetEnvironmentVariableW;
+
+            if let Ok(cwd) = env::current_dir() {
+                let cwd_str = cwd.as_os_str();
+                let mut cwd_wide: Vec<u16> = cwd_str.encode_wide().collect();
+
+                // Check for UNC-like paths (\\server\share or //server/share)
+                // wcsncmp(new_path, L"\\\\", 2) == 0 || wcsncmp(new_path, L"//", 2) == 0
+                let is_unc_like_path = cwd_wide.len() >= 2
+                    && ((cwd_wide[0] == b'\\' as u16 && cwd_wide[1] == b'\\' as u16)
+                        || (cwd_wide[0] == b'/' as u16 && cwd_wide[1] == b'/' as u16));
+
+                if !is_unc_like_path {
+                    // Create env var name "=X:" where X is the drive letter
+                    let env_name: [u16; 4] = [b'=' as u16, cwd_wide[0], b':' as u16, 0];
+                    cwd_wide.push(0); // null-terminate the path
+                    unsafe {
+                        SetEnvironmentVariableW(env_name.as_ptr(), cwd_wide.as_ptr());
+                    }
+                }
+            }
+        }
+
+        Ok(())
     }
 
     #[pyfunction]

From eea6cc49cb0bcb03b28b7b4a01aa6cc118cfdefb Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 3 Jan 2026 02:27:25 -0500
Subject: [PATCH 160/418] Update the signal + socket libraries + associated
 tests - v3.13.11 (#6631)

* Updated signal test library

* Update socketserve + test library

* Fixed test issues with mac

* Added sys import into ftplib

* Reverted ftplib test changes
---
 Lib/socketserver.py           | 30 ++++++++++++++++++------
 Lib/test/test_signal.py       | 43 +++++++++++++++++++----------------
 Lib/test/test_socketserver.py | 27 +++++-----------------
 3 files changed, 52 insertions(+), 48 deletions(-)

diff --git a/Lib/socketserver.py b/Lib/socketserver.py
index 2905e3eac36..35b2723de3b 100644
--- a/Lib/socketserver.py
+++ b/Lib/socketserver.py
@@ -127,10 +127,7 @@ class will essentially render the service "deaf" while one request is
 import selectors
 import os
 import sys
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
+import threading
 from io import BufferedIOBase
 from time import monotonic as time
 
@@ -144,6 +141,8 @@ class will essentially render the service "deaf" while one request is
     __all__.extend(["UnixStreamServer","UnixDatagramServer",
                     "ThreadingUnixStreamServer",
                     "ThreadingUnixDatagramServer"])
+    if hasattr(os, "fork"):
+        __all__.extend(["ForkingUnixStreamServer", "ForkingUnixDatagramServer"])
 
 # poll/select have the advantage of not requiring any extra file descriptor,
 # contrarily to epoll/kqueue (also, they require a single syscall).
@@ -190,6 +189,7 @@ class BaseServer:
     - address_family
     - socket_type
     - allow_reuse_address
+    - allow_reuse_port
 
     Instance variables:
 
@@ -294,8 +294,7 @@ def handle_request(self):
             selector.register(self, selectors.EVENT_READ)
 
             while True:
-                ready = selector.select(timeout)
-                if ready:
+                if selector.select(timeout):
                     return self._handle_request_noblock()
                 else:
                     if timeout is not None:
@@ -428,6 +427,7 @@ class TCPServer(BaseServer):
     - socket_type
     - request_queue_size (only for stream sockets)
     - allow_reuse_address
+    - allow_reuse_port
 
     Instance variables:
 
@@ -445,6 +445,8 @@ class TCPServer(BaseServer):
 
     allow_reuse_address = False
 
+    allow_reuse_port = False
+
     def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
         """Constructor.  May be extended, do not override."""
         BaseServer.__init__(self, server_address, RequestHandlerClass)
@@ -464,8 +466,15 @@ def server_bind(self):
         May be overridden.
 
         """
-        if self.allow_reuse_address:
+        if self.allow_reuse_address and hasattr(socket, "SO_REUSEADDR"):
             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+        # on other address families than AF_INET/AF_INET6.
+        if (
+            self.allow_reuse_port and hasattr(socket, "SO_REUSEPORT")
+            and self.address_family in (socket.AF_INET, socket.AF_INET6)
+        ):
+            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
         self.socket.bind(self.server_address)
         self.server_address = self.socket.getsockname()
 
@@ -522,6 +531,8 @@ class UDPServer(TCPServer):
 
     allow_reuse_address = False
 
+    allow_reuse_port = False
+
     socket_type = socket.SOCK_DGRAM
 
     max_packet_size = 8192
@@ -723,6 +734,11 @@ class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
 
     class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
 
+    if hasattr(os, "fork"):
+        class ForkingUnixStreamServer(ForkingMixIn, UnixStreamServer): pass
+
+        class ForkingUnixDatagramServer(ForkingMixIn, UnixDatagramServer): pass
+
 class BaseRequestHandler:
 
     """Base class for request handler classes.
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index cb744b41e8b..578bee3172a 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -13,9 +13,10 @@
 import time
 import unittest
 from test import support
-from test.support import os_helper
+from test.support import (
+    is_apple, is_apple_mobile, os_helper, threading_helper
+)
 from test.support.script_helper import assert_python_ok, spawn_python
-from test.support import threading_helper
 try:
     import _testcapi
 except ImportError:
@@ -122,6 +123,8 @@ def __repr__(self):
         self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
         self.assertEqual(0, argument.repr_count)
 
+    @unittest.skipIf(sys.platform.startswith("netbsd"),
+                     "gh-124083: strsignal is not supported on NetBSD")
     def test_strsignal(self):
         self.assertIn("Interrupt", signal.strsignal(signal.SIGINT))
         self.assertIn("Terminated", signal.strsignal(signal.SIGTERM))
@@ -189,8 +192,7 @@ def test_valid_signals(self):
         self.assertNotIn(signal.NSIG, s)
         self.assertLess(len(s), signal.NSIG)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue9324(self):
         # Updated for issue #10003, adding SIGBREAK
         handler = lambda x, y: None
@@ -699,7 +701,7 @@ def handler(signum, frame):
 @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
 class SiginterruptTest(unittest.TestCase):
 
-    def readpipe_interrupted(self, interrupt):
+    def readpipe_interrupted(self, interrupt, timeout=support.SHORT_TIMEOUT):
         """Perform a read during which a signal will arrive.  Return True if the
         read is interrupted by the signal and raises an exception.  Return False
         if it returns normally.
@@ -747,7 +749,7 @@ def handler(signum, frame):
                 # wait until the child process is loaded and has started
                 first_line = process.stdout.readline()
 
-                stdout, stderr = process.communicate(timeout=support.SHORT_TIMEOUT)
+                stdout, stderr = process.communicate(timeout=timeout)
             except subprocess.TimeoutExpired:
                 process.kill()
                 return False
@@ -778,7 +780,7 @@ def test_siginterrupt_off(self):
         # If a signal handler is installed and siginterrupt is called with
         # a false value for the second argument, when that signal arrives, it
         # does not interrupt a syscall that's in progress.
-        interrupted = self.readpipe_interrupted(False)
+        interrupted = self.readpipe_interrupted(False, timeout=2)
         self.assertFalse(interrupted)
 
 
@@ -834,16 +836,16 @@ def test_itimer_real(self):
         self.assertEqual(self.hndl_called, True)
 
     # Issue 3864, unknown if this affects earlier versions of freebsd also
-    @unittest.skipIf(sys.platform in ('netbsd5',),
+    @unittest.skipIf(sys.platform in ('netbsd5',) or is_apple_mobile,
         'itimer not reliable (does not mix well with threading) on some BSDs.')
     def test_itimer_virtual(self):
         self.itimer = signal.ITIMER_VIRTUAL
         signal.signal(signal.SIGVTALRM, self.sig_vtalrm)
-        signal.setitimer(self.itimer, 0.3, 0.2)
+        signal.setitimer(self.itimer, 0.001, 0.001)
 
         for _ in support.busy_retry(support.LONG_TIMEOUT):
             # use up some virtual time by doing real work
-            _ = pow(12345, 67890, 10000019)
+            _ = sum(i * i for i in range(10**5))
             if signal.getitimer(self.itimer) == (0.0, 0.0):
                 # sig_vtalrm handler stopped this itimer
                 break
@@ -860,7 +862,7 @@ def test_itimer_prof(self):
 
         for _ in support.busy_retry(support.LONG_TIMEOUT):
             # do some work
-            _ = pow(12345, 67890, 10000019)
+            _ = sum(i * i for i in range(10**5))
             if signal.getitimer(self.itimer) == (0.0, 0.0):
                 # sig_prof handler stopped this itimer
                 break
@@ -1326,15 +1328,18 @@ def test_stress_delivery_simultaneous(self):
         def handler(signum, frame):
             sigs.append(signum)
 
-        self.setsig(signal.SIGUSR1, handler)
+        # On Android, SIGUSR1 is unreliable when used in close proximity to
+        # another signal – see Android/testbed/app/src/main/python/main.py.
+        # So we use a different signal.
+        self.setsig(signal.SIGUSR2, handler)
         self.setsig(signal.SIGALRM, handler)  # for ITIMER_REAL
 
         expected_sigs = 0
         while expected_sigs < N:
             # Hopefully the SIGALRM will be received somewhere during
-            # initial processing of SIGUSR1.
+            # initial processing of SIGUSR2.
             signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
-            os.kill(os.getpid(), signal.SIGUSR1)
+            os.kill(os.getpid(), signal.SIGUSR2)
 
             expected_sigs += 2
             # Wait for handlers to run to avoid signal coalescing
@@ -1346,8 +1351,8 @@ def handler(signum, frame):
         # Python handler
         self.assertEqual(len(sigs), N, "Some signals were lost")
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
-    @unittest.skipIf(sys.platform == "darwin", "crashes due to system bug (FB13453490)")
+    @unittest.skip('TODO: RUSTPYTHON; hang')
+    @unittest.skipIf(is_apple, "crashes due to system bug (FB13453490)")
     @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
                          "test needs SIGUSR1")
     @threading_helper.requires_working_threading()
@@ -1414,8 +1419,7 @@ def test_sigint(self):
         with self.assertRaises(KeyboardInterrupt):
             signal.raise_signal(signal.SIGINT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.platform != "win32", "Windows specific test")
     def test_invalid_argument(self):
         try:
@@ -1439,8 +1443,7 @@ def handler(a, b):
         signal.raise_signal(signal.SIGINT)
         self.assertTrue(is_ok)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__thread_interrupt_main(self):
         # See https://github.com/python/cpython/issues/102397
         code = """if 1:
diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py
index cdbf341b9cb..6235c8e74cf 100644
--- a/Lib/test/test_socketserver.py
+++ b/Lib/test/test_socketserver.py
@@ -8,7 +8,6 @@
 import select
 import signal
 import socket
-import tempfile
 import threading
 import unittest
 import socketserver
@@ -21,6 +20,8 @@
 
 
 test.support.requires("network")
+test.support.requires_working_socket(module=True)
+
 
 TEST_STR = b"hello world\n"
 HOST = socket_helper.HOST
@@ -28,14 +29,9 @@
 HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX")
 requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS,
                                             'requires Unix sockets')
-HAVE_FORKING = hasattr(os, "fork")
+HAVE_FORKING = test.support.has_fork_support
 requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking')
 
-def signal_alarm(n):
-    """Call signal.alarm when it exists (i.e. not on Windows)."""
-    if hasattr(signal, 'alarm'):
-        signal.alarm(n)
-
 # Remember real select() to avoid interferences with mocking
 _real_select = select.select
 
@@ -46,14 +42,6 @@ def receive(sock, n, timeout=test.support.SHORT_TIMEOUT):
     else:
         raise RuntimeError("timed out on %r" % (sock,))
 
-if HAVE_UNIX_SOCKETS and HAVE_FORKING:
-    class ForkingUnixStreamServer(socketserver.ForkingMixIn,
-                                  socketserver.UnixStreamServer):
-        pass
-
-    class ForkingUnixDatagramServer(socketserver.ForkingMixIn,
-                                    socketserver.UnixDatagramServer):
-        pass
 
 @test.support.requires_fork() # TODO: RUSTPYTHON, os.fork is currently only supported on Unix-based systems
 @contextlib.contextmanager
@@ -75,12 +63,10 @@ class SocketServerTest(unittest.TestCase):
     """Test all socket servers."""
 
     def setUp(self):
-        signal_alarm(60)  # Kill deadlocks after 60 seconds.
         self.port_seed = 0
         self.test_files = []
 
     def tearDown(self):
-        signal_alarm(0)  # Didn't deadlock.
         reap_children()
 
         for fn in self.test_files:
@@ -96,8 +82,7 @@ def pickaddr(self, proto):
         else:
             # XXX: We need a way to tell AF_UNIX to pick its own name
             # like AF_INET provides port==0.
-            dir = None
-            fn = tempfile.mktemp(prefix='unix_socket.', dir=dir)
+            fn = socket_helper.create_unix_domain_name()
             self.test_files.append(fn)
             return fn
 
@@ -211,7 +196,7 @@ def test_ThreadingUnixStreamServer(self):
     @requires_forking
     def test_ForkingUnixStreamServer(self):
         with simple_subprocess(self):
-            self.run_server(ForkingUnixStreamServer,
+            self.run_server(socketserver.ForkingUnixStreamServer,
                             socketserver.StreamRequestHandler,
                             self.stream_examine)
 
@@ -247,7 +232,7 @@ def test_ThreadingUnixDatagramServer(self):
     @requires_unix_sockets
     @requires_forking
     def test_ForkingUnixDatagramServer(self):
-        self.run_server(ForkingUnixDatagramServer,
+        self.run_server(socketserver.ForkingUnixDatagramServer,
                         socketserver.DatagramRequestHandler,
                         self.dgram_examine)
 

From f0526b9e9a01bb81a76bbaeb3de5b3d1be659722 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 3 Jan 2026 02:29:10 -0500
Subject: [PATCH 161/418] Updated the wsgiref + xmlrpc libraries + associated
 tests - v3.13.11 (#6634)

* Updated the wsgiref library + test

* Uncommented fixed wsgi tests

* Updated the xmlrpc library + test

* Added expectedFailure to test_request_length in test_wsgiref

* Annotated doc_xmlrpc test failures/errors
---
 Lib/test/test_docxmlrpc.py   |  7 ++-
 Lib/test/test_wsgiref.py     | 66 +++++++++-----------------
 Lib/test/test_xmlrpc.py      | 10 ----
 Lib/wsgiref/__init__.py      |  2 +
 Lib/wsgiref/handlers.py      | 38 ++++++++++-----
 Lib/wsgiref/simple_server.py |  7 +--
 Lib/wsgiref/types.py         | 54 +++++++++++++++++++++
 Lib/wsgiref/util.py          | 14 ++----
 Lib/wsgiref/validate.py      | 15 ++----
 Lib/xmlrpc/client.py         | 47 ++++---------------
 Lib/xmlrpc/server.py         | 91 ++++++++++++++++++++----------------
 11 files changed, 179 insertions(+), 172 deletions(-)
 create mode 100644 Lib/wsgiref/types.py

diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
index 99469a58496..3c05412ef57 100644
--- a/Lib/test/test_docxmlrpc.py
+++ b/Lib/test/test_docxmlrpc.py
@@ -100,8 +100,6 @@ def test_valid_get_response(self):
         # Server raises an exception if we don't start to read the data
         response.read()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_get_css(self):
         self.client.request("GET", "/pydoc.css")
         response = self.client.getresponse()
@@ -121,6 +119,7 @@ def test_invalid_get_response(self):
 
         response.read()
 
+    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
     def test_lambda(self):
         """Test that lambda functionality stays the same.  The output produced
         currently is, I suspect invalid because of the unencoded brackets in the
@@ -163,6 +162,7 @@ def test_autolinking(self):
 
     @make_request_and_skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
+    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
     def test_system_methods(self):
         """Test the presence of three consecutive system.* methods.
 
@@ -190,6 +190,7 @@ def test_system_methods(self):
              b'<br>\nThis&nbsp;server&nbsp;does&nbsp;NOT&nbsp;support&nbsp;system'
              b'.methodSignature.</tt></dd></dl>'), response)
 
+    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
     def test_autolink_dotted_methods(self):
         """Test that selfdot values are made strong automatically in the
         documentation."""
@@ -199,6 +200,7 @@ def test_autolink_dotted_methods(self):
         self.assertIn(b"""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""",
                       response.read())
 
+    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
     def test_annotations(self):
         """ Test that annotations works as expected """
         self.client.request("GET", "/")
@@ -212,6 +214,7 @@ def test_annotations(self):
              b'method_annotation</strong></a>(x: bytes)</dt></dl>'),
             response.read())
 
+    @unittest.skip('TODO: RUSTPYTHON; TypeError: HTMLDoc.heading() missing 2 required positional arguments: "fgcol" and "bgcol"')
     def test_server_title_escape(self):
         # bpo-38243: Ensure that the server title and documentation
         # are escaped for HTML.
diff --git a/Lib/test/test_wsgiref.py b/Lib/test/test_wsgiref.py
index b89e181f9f8..1a3b4d4b721 100644
--- a/Lib/test/test_wsgiref.py
+++ b/Lib/test/test_wsgiref.py
@@ -1,6 +1,6 @@
 from unittest import mock
 from test import support
-from test.support import warnings_helper
+from test.support import socket_helper
 from test.test_httpservers import NoLogRequestHandler
 from unittest import TestCase
 from wsgiref.util import setup_testing_defaults
@@ -80,41 +80,26 @@ def run_amock(app=hello_app, data=b"GET / HTTP/1.0\n\n"):
 
     return out.getvalue(), err.getvalue()
 
-def compare_generic_iter(make_it,match):
-    """Utility to compare a generic 2.1/2.2+ iterator with an iterable
 
-    If running under Python 2.2+, this tests the iterator using iter()/next(),
-    as well as __getitem__.  'make_it' must be a function returning a fresh
+def compare_generic_iter(make_it, match):
+    """Utility to compare a generic iterator with an iterable
+
+    This tests the iterator using iter()/next().
+    'make_it' must be a function returning a fresh
     iterator to be tested (since this may test the iterator twice)."""
 
     it = make_it()
-    n = 0
+    if not iter(it) is it:
+        raise AssertionError
     for item in match:
-        if not it[n]==item: raise AssertionError
-        n+=1
-    try:
-        it[n]
-    except IndexError:
-        pass
-    else:
-        raise AssertionError("Too many items from __getitem__",it)
-
+        if not next(it) == item:
+            raise AssertionError
     try:
-        iter, StopIteration
-    except NameError:
+        next(it)
+    except StopIteration:
         pass
     else:
-        # Only test iter mode under 2.2+
-        it = make_it()
-        if not iter(it) is it: raise AssertionError
-        for item in match:
-            if not next(it) == item: raise AssertionError
-        try:
-            next(it)
-        except StopIteration:
-            pass
-        else:
-            raise AssertionError("Too many items from .__next__()", it)
+        raise AssertionError("Too many items from .__next__()", it)
 
 
 class IntegrationTests(TestCase):
@@ -149,10 +134,11 @@ def test_environ(self):
             b"Python test,Python test 2;query=test;/path/"
         )
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; http library needs to be updated
     def test_request_length(self):
         out, err = run_amock(data=b"GET " + (b"x" * 65537) + b" HTTP/1.0\n\n")
         self.assertEqual(out.splitlines()[0],
-                         b"HTTP/1.0 414 Request-URI Too Long")
+                         b"HTTP/1.0 414 URI Too Long")
 
     def test_validated_hello(self):
         out, err = run_amock(validator(hello_app))
@@ -264,7 +250,7 @@ def app(environ, start_response):
         class WsgiHandler(NoLogRequestHandler, WSGIRequestHandler):
             pass
 
-        server = make_server(support.HOST, 0, app, handler_class=WsgiHandler)
+        server = make_server(socket_helper.HOST, 0, app, handler_class=WsgiHandler)
         self.addCleanup(server.server_close)
         interrupted = threading.Event()
 
@@ -339,7 +325,6 @@ def checkReqURI(self,uri,query=1,**kw):
         util.setup_testing_defaults(kw)
         self.assertEqual(util.request_uri(kw,query),uri)
 
-    @warnings_helper.ignore_warnings(category=DeprecationWarning)
     def checkFW(self,text,size,match):
 
         def make_it(text=text,size=size):
@@ -358,15 +343,6 @@ def make_it(text=text,size=size):
         it.close()
         self.assertTrue(it.filelike.closed)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_filewrapper_getitem_deprecation(self):
-        wrapper = util.FileWrapper(StringIO('foobar'), 3)
-        with self.assertWarnsRegex(DeprecationWarning,
-                                   r'Use iterator protocol instead'):
-            # This should have returned 'bar'.
-            self.assertEqual(wrapper[1], 'foo')
-
     def testSimpleShifts(self):
         self.checkShift('','/', '', '/', '')
         self.checkShift('','/x', 'x', '/x', '')
@@ -473,6 +449,10 @@ def testHopByHop(self):
             for alt in hop, hop.title(), hop.upper(), hop.lower():
                 self.assertFalse(util.is_hop_by_hop(alt))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_filewrapper_getitem_deprecation(self):
+        return super().test_filewrapper_getitem_deprecation()
+
 class HeaderTests(TestCase):
 
     def testMappingInterface(self):
@@ -581,7 +561,7 @@ def testEnviron(self):
         # Test handler.environ as a dict
         expected = {}
         setup_testing_defaults(expected)
-        # Handler inherits os_environ variables which are not overriden
+        # Handler inherits os_environ variables which are not overridden
         # by SimpleHandler.add_cgi_vars() (SimpleHandler.base_env)
         for key, value in os_environ.items():
             if key not in expected:
@@ -821,8 +801,6 @@ def flush(self):
             b"Hello, world!",
             written)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testClientConnectionTerminations(self):
         environ = {"SERVER_PROTOCOL": "HTTP/1.0"}
         for exception in (
@@ -841,8 +819,6 @@ def write(self, b):
 
                 self.assertFalse(stderr.getvalue())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testDontResetInternalStateOnException(self):
         class CustomException(ValueError):
             pass
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index cf3f535b190..6b2e6c44ca4 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -1042,55 +1042,46 @@ def test_path2(self):
         self.assertEqual(p.add(6,8), 6+8)
         self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_path3(self):
         p = xmlrpclib.ServerProxy(URL+"/is/broken")
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_invalid_path(self):
         p = xmlrpclib.ServerProxy(URL+"/invalid")
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_path_query_fragment(self):
         p = xmlrpclib.ServerProxy(URL+"/foo?k=v#frag")
         self.assertEqual(p.test(), "/foo?k=v#frag")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_path_fragment(self):
         p = xmlrpclib.ServerProxy(URL+"/foo#frag")
         self.assertEqual(p.test(), "/foo#frag")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_path_query(self):
         p = xmlrpclib.ServerProxy(URL+"/foo?k=v")
         self.assertEqual(p.test(), "/foo?k=v")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_empty_path(self):
         p = xmlrpclib.ServerProxy(URL)
         self.assertEqual(p.test(), "/RPC2")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_root_path(self):
         p = xmlrpclib.ServerProxy(URL + "/")
         self.assertEqual(p.test(), "/")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_empty_path_query(self):
         p = xmlrpclib.ServerProxy(URL + "?k=v")
         self.assertEqual(p.test(), "?k=v")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_resource('walltime')
     def test_empty_path_fragment(self):
         p = xmlrpclib.ServerProxy(URL + "#frag")
@@ -1142,7 +1133,6 @@ def test_two(self):
 
 #test special attribute access on the serverproxy, through the __call__
 #function.
-@unittest.skip("TODO: RUSTPYTHON, appears to hang")
 class KeepaliveServerTestCase2(BaseKeepaliveServerTestCase):
     #ask for two keepalive requests to be handled.
     request_count=2
diff --git a/Lib/wsgiref/__init__.py b/Lib/wsgiref/__init__.py
index 1efbba01a30..59ee48fddec 100644
--- a/Lib/wsgiref/__init__.py
+++ b/Lib/wsgiref/__init__.py
@@ -13,6 +13,8 @@
 * validate -- validation wrapper that sits between an app and a server
   to detect errors in either
 
+* types -- collection of WSGI-related types for static type checking
+
 To-Do:
 
 * cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard)
diff --git a/Lib/wsgiref/handlers.py b/Lib/wsgiref/handlers.py
index f4300b831a4..cafe872c7aa 100644
--- a/Lib/wsgiref/handlers.py
+++ b/Lib/wsgiref/handlers.py
@@ -136,6 +136,10 @@ def run(self, application):
             self.setup_environ()
             self.result = application(self.environ, self.start_response)
             self.finish_response()
+        except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
+            # We expect the client to close the connection abruptly from time
+            # to time.
+            return
         except:
             try:
                 self.handle_error()
@@ -179,7 +183,16 @@ def finish_response(self):
                 for data in self.result:
                     self.write(data)
                 self.finish_content()
-        finally:
+        except:
+            # Call close() on the iterable returned by the WSGI application
+            # in case of an exception.
+            if hasattr(self.result, 'close'):
+                self.result.close()
+            raise
+        else:
+            # We only call close() when no exception is raised, because it
+            # will set status, result, headers, and environ fields to None.
+            # See bpo-29183 for more details.
             self.close()
 
 
@@ -215,8 +228,7 @@ def start_response(self, status, headers,exc_info=None):
         if exc_info:
             try:
                 if self.headers_sent:
-                    # Re-raise original exception if headers sent
-                    raise exc_info[0](exc_info[1]).with_traceback(exc_info[2])
+                    raise
             finally:
                 exc_info = None        # avoid dangling circular ref
         elif self.headers is not None:
@@ -225,18 +237,25 @@ def start_response(self, status, headers,exc_info=None):
         self.status = status
         self.headers = self.headers_class(headers)
         status = self._convert_string_type(status, "Status")
-        assert len(status)>=4,"Status must be at least 4 characters"
-        assert status[:3].isdigit(), "Status message must begin w/3-digit code"
-        assert status[3]==" ", "Status message must have a space after code"
+        self._validate_status(status)
 
         if __debug__:
             for name, val in headers:
                 name = self._convert_string_type(name, "Header name")
                 val = self._convert_string_type(val, "Header value")
-                assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
+                assert not is_hop_by_hop(name),\
+                       f"Hop-by-hop header, '{name}: {val}', not allowed"
 
         return self.write
 
+    def _validate_status(self, status):
+        if len(status) < 4:
+            raise AssertionError("Status must be at least 4 characters")
+        if not status[:3].isdigit():
+            raise AssertionError("Status message must begin w/3-digit code")
+        if status[3] != " ":
+            raise AssertionError("Status message must have a space after code")
+
     def _convert_string_type(self, value, title):
         """Convert/check value type."""
         if type(value) is str:
@@ -456,10 +475,7 @@ def _write(self,data):
         from warnings import warn
         warn("SimpleHandler.stdout.write() should not do partial writes",
             DeprecationWarning)
-        while True:
-            data = data[result:]
-            if not data:
-                break
+        while data := data[result:]:
             result = self.stdout.write(data)
 
     def _flush(self):
diff --git a/Lib/wsgiref/simple_server.py b/Lib/wsgiref/simple_server.py
index f71563a5ae0..a0f2397fcf0 100644
--- a/Lib/wsgiref/simple_server.py
+++ b/Lib/wsgiref/simple_server.py
@@ -84,10 +84,6 @@ def get_environ(self):
 
         env['PATH_INFO'] = urllib.parse.unquote(path, 'iso-8859-1')
         env['QUERY_STRING'] = query
-
-        host = self.address_string()
-        if host != self.client_address[0]:
-            env['REMOTE_HOST'] = host
         env['REMOTE_ADDR'] = self.client_address[0]
 
         if self.headers.get('content-type') is None:
@@ -127,7 +123,8 @@ def handle(self):
             return
 
         handler = ServerHandler(
-            self.rfile, self.wfile, self.get_stderr(), self.get_environ()
+            self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
+            multithread=False,
         )
         handler.request_handler = self      # backpointer for logging
         handler.run(self.server.get_app())
diff --git a/Lib/wsgiref/types.py b/Lib/wsgiref/types.py
new file mode 100644
index 00000000000..ef0aead5b28
--- /dev/null
+++ b/Lib/wsgiref/types.py
@@ -0,0 +1,54 @@
+"""WSGI-related types for static type checking"""
+
+from collections.abc import Callable, Iterable, Iterator
+from types import TracebackType
+from typing import Any, Protocol, TypeAlias
+
+__all__ = [
+    "StartResponse",
+    "WSGIEnvironment",
+    "WSGIApplication",
+    "InputStream",
+    "ErrorStream",
+    "FileWrapper",
+]
+
+_ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
+_OptExcInfo: TypeAlias = _ExcInfo | tuple[None, None, None]
+
+class StartResponse(Protocol):
+    """start_response() callable as defined in PEP 3333"""
+    def __call__(
+        self,
+        status: str,
+        headers: list[tuple[str, str]],
+        exc_info: _OptExcInfo | None = ...,
+        /,
+    ) -> Callable[[bytes], object]: ...
+
+WSGIEnvironment: TypeAlias = dict[str, Any]
+WSGIApplication: TypeAlias = Callable[[WSGIEnvironment, StartResponse],
+    Iterable[bytes]]
+
+class InputStream(Protocol):
+    """WSGI input stream as defined in PEP 3333"""
+    def read(self, size: int = ..., /) -> bytes: ...
+    def readline(self, size: int = ..., /) -> bytes: ...
+    def readlines(self, hint: int = ..., /) -> list[bytes]: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+
+class ErrorStream(Protocol):
+    """WSGI error stream as defined in PEP 3333"""
+    def flush(self) -> object: ...
+    def write(self, s: str, /) -> object: ...
+    def writelines(self, seq: list[str], /) -> object: ...
+
+class _Readable(Protocol):
+    def read(self, size: int = ..., /) -> bytes: ...
+    # Optional: def close(self) -> object: ...
+
+class FileWrapper(Protocol):
+    """WSGI file wrapper as defined in PEP 3333"""
+    def __call__(
+        self, file: _Readable, block_size: int = ..., /,
+    ) -> Iterable[bytes]: ...
diff --git a/Lib/wsgiref/util.py b/Lib/wsgiref/util.py
index 516fe898d01..63b92331737 100644
--- a/Lib/wsgiref/util.py
+++ b/Lib/wsgiref/util.py
@@ -4,7 +4,7 @@
 
 __all__ = [
     'FileWrapper', 'guess_scheme', 'application_uri', 'request_uri',
-    'shift_path_info', 'setup_testing_defaults',
+    'shift_path_info', 'setup_testing_defaults', 'is_hop_by_hop',
 ]
 
 
@@ -17,12 +17,6 @@ def __init__(self, filelike, blksize=8192):
         if hasattr(filelike,'close'):
             self.close = filelike.close
 
-    def __getitem__(self,key):
-        data = self.filelike.read(self.blksize)
-        if data:
-            return data
-        raise IndexError
-
     def __iter__(self):
         return self
 
@@ -155,9 +149,9 @@ def setup_testing_defaults(environ):
 
 
 _hoppish = {
-    'connection':1, 'keep-alive':1, 'proxy-authenticate':1,
-    'proxy-authorization':1, 'te':1, 'trailers':1, 'transfer-encoding':1,
-    'upgrade':1
+    'connection', 'keep-alive', 'proxy-authenticate',
+    'proxy-authorization', 'te', 'trailers', 'transfer-encoding',
+    'upgrade'
 }.__contains__
 
 def is_hop_by_hop(header_name):
diff --git a/Lib/wsgiref/validate.py b/Lib/wsgiref/validate.py
index 6107dcd7a4d..1a1853cd63a 100644
--- a/Lib/wsgiref/validate.py
+++ b/Lib/wsgiref/validate.py
@@ -1,6 +1,6 @@
 # (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
-# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
-# Also licenced under the Apache License, 2.0: http://opensource.org/licenses/apache2.0.php
+# Licensed under the MIT license: https://opensource.org/licenses/mit-license.php
+# Also licenced under the Apache License, 2.0: https://opensource.org/licenses/apache2.0.php
 # Licensed to PSF under a Contributor Agreement
 """
 Middleware to check for obedience to the WSGI specification.
@@ -77,7 +77,7 @@
 
 * That wsgi.input is used properly:
 
-  - .read() is called with zero or one argument
+  - .read() is called with exactly one argument
 
   - That it returns a string
 
@@ -137,7 +137,7 @@ def validator(application):
 
     """
     When applied between a WSGI server and a WSGI application, this
-    middleware will check for WSGI compliancy on a number of levels.
+    middleware will check for WSGI compliance on a number of levels.
     This middleware does not modify the request or response in any
     way, but will raise an AssertionError if anything seems off
     (except for a failure to close the application iterator, which
@@ -214,10 +214,7 @@ def readlines(self, *args):
         return lines
 
     def __iter__(self):
-        while 1:
-            line = self.readline()
-            if not line:
-                return
+        while line := self.readline():
             yield line
 
     def close(self):
@@ -390,7 +387,6 @@ def check_headers(headers):
     assert_(type(headers) is list,
         "Headers (%r) must be of type list: %r"
         % (headers, type(headers)))
-    header_names = {}
     for item in headers:
         assert_(type(item) is tuple,
             "Individual headers (%r) must be of type tuple: %r"
@@ -403,7 +399,6 @@ def check_headers(headers):
             "The Status header cannot be used; it conflicts with CGI "
             "script, and HTTP status is not given through headers "
             "(value: %r)." % value)
-        header_names[name.lower()] = None
         assert_('\n' not in name and ':' not in name,
             "Header names may not contain ':' or '\\n': %r" % name)
         assert_(header_re.search(name), "Bad header name: %r" % name)
diff --git a/Lib/xmlrpc/client.py b/Lib/xmlrpc/client.py
index a614cef6ab2..f441376d09c 100644
--- a/Lib/xmlrpc/client.py
+++ b/Lib/xmlrpc/client.py
@@ -245,41 +245,15 @@ def __repr__(self):
 
 ##
 # Backwards compatibility
-
 boolean = Boolean = bool
 
-##
-# Wrapper for XML-RPC DateTime values.  This converts a time value to
-# the format used by XML-RPC.
-# <p>
-# The value can be given as a datetime object, as a string in the
-# format "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
-# time.localtime()), or an integer value (as returned by time.time()).
-# The wrapper uses time.localtime() to convert an integer to a time
-# tuple.
-#
-# @param value The time, given as a datetime object, an ISO 8601 string,
-#              a time tuple, or an integer time value.
-
 
-# Issue #13305: different format codes across platforms
-_day0 = datetime(1, 1, 1)
-def _try(fmt):
-    try:
-        return _day0.strftime(fmt) == '0001'
-    except ValueError:
-        return False
-if _try('%Y'):      # Mac OS X
-    def _iso8601_format(value):
-        return value.strftime("%Y%m%dT%H:%M:%S")
-elif _try('%4Y'):   # Linux
-    def _iso8601_format(value):
-        return value.strftime("%4Y%m%dT%H:%M:%S")
-else:
-    def _iso8601_format(value):
-        return value.strftime("%Y%m%dT%H:%M:%S").zfill(17)
-del _day0
-del _try
+def _iso8601_format(value):
+    if value.tzinfo is not None:
+        # XML-RPC only uses the naive portion of the datetime
+        value = value.replace(tzinfo=None)
+    # XML-RPC doesn't use '-' separator in the date part
+    return value.isoformat(timespec='seconds').replace('-', '')
 
 
 def _strftime(value):
@@ -850,9 +824,9 @@ def __init__(self, results):
 
     def __getitem__(self, i):
         item = self.results[i]
-        if type(item) == type({}):
+        if isinstance(item, dict):
             raise Fault(item['faultCode'], item['faultString'])
-        elif type(item) == type([]):
+        elif isinstance(item, list):
             return item[0]
         else:
             raise ValueError("unexpected type in multicall result")
@@ -1339,10 +1313,7 @@ def parse_response(self, response):
 
         p, u = self.getparser()
 
-        while 1:
-            data = stream.read(1024)
-            if not data:
-                break
+        while data := stream.read(1024):
             if self.verbose:
                 print("body:", repr(data))
             p.feed(data)
diff --git a/Lib/xmlrpc/server.py b/Lib/xmlrpc/server.py
index 69a260f5b12..4dddb1d10e0 100644
--- a/Lib/xmlrpc/server.py
+++ b/Lib/xmlrpc/server.py
@@ -268,17 +268,11 @@ def _marshaled_dispatch(self, data, dispatch_method = None, path = None):
         except Fault as fault:
             response = dumps(fault, allow_none=self.allow_none,
                              encoding=self.encoding)
-        except:
-            # report exception back to server
-            exc_type, exc_value, exc_tb = sys.exc_info()
-            try:
-                response = dumps(
-                    Fault(1, "%s:%s" % (exc_type, exc_value)),
-                    encoding=self.encoding, allow_none=self.allow_none,
-                    )
-            finally:
-                # Break reference cycle
-                exc_type = exc_value = exc_tb = None
+        except BaseException as exc:
+            response = dumps(
+                Fault(1, "%s:%s" % (type(exc), exc)),
+                encoding=self.encoding, allow_none=self.allow_none,
+                )
 
         return response.encode(self.encoding, 'xmlcharrefreplace')
 
@@ -368,16 +362,11 @@ def system_multicall(self, call_list):
                     {'faultCode' : fault.faultCode,
                      'faultString' : fault.faultString}
                     )
-            except:
-                exc_type, exc_value, exc_tb = sys.exc_info()
-                try:
-                    results.append(
-                        {'faultCode' : 1,
-                         'faultString' : "%s:%s" % (exc_type, exc_value)}
-                        )
-                finally:
-                    # Break reference cycle
-                    exc_type = exc_value = exc_tb = None
+            except BaseException as exc:
+                results.append(
+                    {'faultCode' : 1,
+                     'faultString' : "%s:%s" % (type(exc), exc)}
+                    )
         return results
 
     def _dispatch(self, method, params):
@@ -440,7 +429,7 @@ class SimpleXMLRPCRequestHandler(BaseHTTPRequestHandler):
 
     # Class attribute listing the accessible path components;
     # paths not on this list will result in a 404 error.
-    rpc_paths = ('/', '/RPC2')
+    rpc_paths = ('/', '/RPC2', '/pydoc.css')
 
     #if not None, encode responses larger than this, if possible
     encode_threshold = 1400 #a common MTU
@@ -634,19 +623,14 @@ def _marshaled_dispatch(self, data, dispatch_method = None, path = None):
         try:
             response = self.dispatchers[path]._marshaled_dispatch(
                data, dispatch_method, path)
-        except:
+        except BaseException as exc:
             # report low level exception back to server
             # (each dispatcher should have handled their own
             # exceptions)
-            exc_type, exc_value = sys.exc_info()[:2]
-            try:
-                response = dumps(
-                    Fault(1, "%s:%s" % (exc_type, exc_value)),
-                    encoding=self.encoding, allow_none=self.allow_none)
-                response = response.encode(self.encoding, 'xmlcharrefreplace')
-            finally:
-                # Break reference cycle
-                exc_type = exc_value = None
+            response = dumps(
+                Fault(1, "%s:%s" % (type(exc), exc)),
+                encoding=self.encoding, allow_none=self.allow_none)
+            response = response.encode(self.encoding, 'xmlcharrefreplace')
         return response
 
 class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
@@ -736,9 +720,7 @@ def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
                                 r'RFC[- ]?(\d+)|'
                                 r'PEP[- ]?(\d+)|'
                                 r'(self\.)?((?:\w|\.)+))\b')
-        while 1:
-            match = pattern.search(text, here)
-            if not match: break
+        while match := pattern.search(text, here):
             start, end = match.span()
             results.append(escape(text[here:start]))
 
@@ -747,10 +729,10 @@ def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
                 url = escape(all).replace('"', '&quot;')
                 results.append('<a href="%s">%s</a>' % (url, url))
             elif rfc:
-                url = 'http://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
+                url = 'https://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
             elif pep:
-                url = 'https://www.python.org/dev/peps/pep-%04d/' % int(pep)
+                url = 'https://peps.python.org/pep-%04d/' % int(pep)
                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
             elif text[end:end+1] == '(':
                 results.append(self.namelink(name, methods, funcs, classes))
@@ -801,7 +783,7 @@ def docserver(self, server_name, package_documentation, methods):
 
         server_name = self.escape(server_name)
         head = '<big><big><strong>%s</strong></big></big>' % server_name
-        result = self.heading(head, '#ffffff', '#7799ee')
+        result = self.heading(head)
 
         doc = self.markup(package_documentation, self.preformat, fdict)
         doc = doc and '<tt>%s</tt>' % doc
@@ -812,10 +794,25 @@ def docserver(self, server_name, package_documentation, methods):
         for key, value in method_items:
             contents.append(self.docroutine(value, key, funcs=fdict))
         result = result + self.bigsection(
-            'Methods', '#ffffff', '#eeaa77', ''.join(contents))
+            'Methods', 'functions', ''.join(contents))
 
         return result
 
+
+    def page(self, title, contents):
+        """Format an HTML page."""
+        css_path = "/pydoc.css"
+        css_link = (
+            '<link rel="stylesheet" type="text/css" href="%s">' %
+            css_path)
+        return '''\
+<!DOCTYPE>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Python: %s</title>
+%s</head><body>%s</body></html>''' % (title, css_link, contents)
+
 class XMLRPCDocGenerator:
     """Generates documentation for an XML-RPC server.
 
@@ -907,6 +904,12 @@ class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
     for documentation.
     """
 
+    def _get_css(self, url):
+        path_here = os.path.dirname(os.path.realpath(__file__))
+        css_path = os.path.join(path_here, "..", "pydoc_data", "_pydoc.css")
+        with open(css_path, mode="rb") as fp:
+            return fp.read()
+
     def do_GET(self):
         """Handles the HTTP GET request.
 
@@ -918,9 +921,15 @@ def do_GET(self):
             self.report_404()
             return
 
-        response = self.server.generate_html_documentation().encode('utf-8')
+        if self.path.endswith('.css'):
+            content_type = 'text/css'
+            response = self._get_css(self.path)
+        else:
+            content_type = 'text/html'
+            response = self.server.generate_html_documentation().encode('utf-8')
+
         self.send_response(200)
-        self.send_header("Content-type", "text/html")
+        self.send_header('Content-Type', '%s; charset=UTF-8' % content_type)
         self.send_header("Content-length", str(len(response)))
         self.end_headers()
         self.wfile.write(response)

From eee360822c67ca75795894676f3281165a5ec489 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 09:15:38 +0900
Subject: [PATCH 162/418] Rework compiler about exception handling (#6638)

* asyncgen

* fix coroutine

* rewrite compiler

* tests

* set pyc magic number
---
 .cspell.dict/cpython.txt                      |    1 +
 Lib/_opcode_metadata.py                       |  257 +--
 Lib/importlib/_bootstrap_external.py          |    2 +-
 Lib/test/test__opcode.py                      |    3 +-
 Lib/test/test_asyncgen.py                     |    4 -
 Lib/test/test_compile.py                      |    2 -
 Lib/test/test_contextlib.py                   |    2 -
 Lib/test/test_contextlib_async.py             |    5 +
 Lib/test/test_dis.py                          |    6 +-
 Lib/test/test_exceptions.py                   |    3 -
 Lib/test/test_generators.py                   |    2 -
 Lib/test/test_importlib/test_util.py          |    2 +-
 Lib/test/test_patma.py                        |    1 -
 Lib/test/test_traceback.py                    |    2 -
 crates/codegen/src/compile.rs                 | 1996 +++++++++++++----
 crates/codegen/src/error.rs                   |   11 +
 crates/codegen/src/ir.rs                      |  192 +-
 ...pile__tests__nested_double_async_with.snap |  203 +-
 ...pile__tests__nested_double_async_with.snap |   87 -
 crates/codegen/src/symboltable.rs             |   64 +-
 crates/compiler-core/src/bytecode.rs          |  817 +++++--
 crates/compiler-core/src/lib.rs               |    1 +
 crates/compiler-core/src/varint.rs            |  138 ++
 crates/jit/src/instructions.rs                |   41 +-
 crates/stdlib/src/opcode.rs                   |  147 +-
 crates/vm/src/builtins/asyncgenerator.rs      |   23 +-
 crates/vm/src/builtins/code.rs                |   21 +-
 crates/vm/src/coroutine.rs                    |   29 +-
 crates/vm/src/frame.rs                        |  811 ++++---
 crates/vm/src/version.rs                      |    2 +-
 crates/vm/src/vm/mod.rs                       |   22 +-
 scripts/generate_opcode_metadata.py           |  246 ++
 32 files changed, 3732 insertions(+), 1411 deletions(-)
 delete mode 100644 crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap
 create mode 100644 crates/compiler-core/src/varint.rs
 create mode 100644 scripts/generate_opcode_metadata.py

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 0e4e17e2872..2ac19a4fca0 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -14,6 +14,7 @@ cafile
 cellarg
 cellvar
 cellvars
+CLASSDEREF
 cmpop
 denom
 DICTFLAG
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index b3d7b8103e8..0d6b7f1109e 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -1,198 +1,16 @@
-# This file is generated by Tools/cases_generator/py_metadata_generator.py
-# from:
-#   Python/bytecodes.c
+# This file is generated by scripts/generate_opcode_metadata.py
+# for RustPython bytecode format (CPython 3.13 compatible opcode numbers).
 # Do not edit!
-_specializations = {
-    "RESUME": [
-        "RESUME_CHECK",
-    ],
-    "TO_BOOL": [
-        "TO_BOOL_ALWAYS_TRUE",
-        "TO_BOOL_BOOL",
-        "TO_BOOL_INT",
-        "TO_BOOL_LIST",
-        "TO_BOOL_NONE",
-        "TO_BOOL_STR",
-    ],
-    "BINARY_OP": [
-        "BINARY_OP_MULTIPLY_INT",
-        "BINARY_OP_ADD_INT",
-        "BINARY_OP_SUBTRACT_INT",
-        "BINARY_OP_MULTIPLY_FLOAT",
-        "BINARY_OP_ADD_FLOAT",
-        "BINARY_OP_SUBTRACT_FLOAT",
-        "BINARY_OP_ADD_UNICODE",
-        "BINARY_OP_INPLACE_ADD_UNICODE",
-    ],
-    "BINARY_SUBSCR": [
-        "BINARY_SUBSCR_DICT",
-        "BINARY_SUBSCR_GETITEM",
-        "BINARY_SUBSCR_LIST_INT",
-        "BINARY_SUBSCR_STR_INT",
-        "BINARY_SUBSCR_TUPLE_INT",
-    ],
-    "STORE_SUBSCR": [
-        "STORE_SUBSCR_DICT",
-        "STORE_SUBSCR_LIST_INT",
-    ],
-    "SEND": [
-        "SEND_GEN",
-    ],
-    "UNPACK_SEQUENCE": [
-        "UNPACK_SEQUENCE_TWO_TUPLE",
-        "UNPACK_SEQUENCE_TUPLE",
-        "UNPACK_SEQUENCE_LIST",
-    ],
-    "STORE_ATTR": [
-        "STORE_ATTR_INSTANCE_VALUE",
-        "STORE_ATTR_SLOT",
-        "STORE_ATTR_WITH_HINT",
-    ],
-    "LOAD_GLOBAL": [
-        "LOAD_GLOBAL_MODULE",
-        "LOAD_GLOBAL_BUILTIN",
-    ],
-    "LOAD_SUPER_ATTR": [
-        "LOAD_SUPER_ATTR_ATTR",
-        "LOAD_SUPER_ATTR_METHOD",
-    ],
-    "LOAD_ATTR": [
-        "LOAD_ATTR_INSTANCE_VALUE",
-        "LOAD_ATTR_MODULE",
-        "LOAD_ATTR_WITH_HINT",
-        "LOAD_ATTR_SLOT",
-        "LOAD_ATTR_CLASS",
-        "LOAD_ATTR_PROPERTY",
-        "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN",
-        "LOAD_ATTR_METHOD_WITH_VALUES",
-        "LOAD_ATTR_METHOD_NO_DICT",
-        "LOAD_ATTR_METHOD_LAZY_DICT",
-        "LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES",
-        "LOAD_ATTR_NONDESCRIPTOR_NO_DICT",
-    ],
-    "COMPARE_OP": [
-        "COMPARE_OP_FLOAT",
-        "COMPARE_OP_INT",
-        "COMPARE_OP_STR",
-    ],
-    "CONTAINS_OP": [
-        "CONTAINS_OP_SET",
-        "CONTAINS_OP_DICT",
-    ],
-    "FOR_ITER": [
-        "FOR_ITER_LIST",
-        "FOR_ITER_TUPLE",
-        "FOR_ITER_RANGE",
-        "FOR_ITER_GEN",
-    ],
-    "CALL": [
-        "CALL_BOUND_METHOD_EXACT_ARGS",
-        "CALL_PY_EXACT_ARGS",
-        "CALL_TYPE_1",
-        "CALL_STR_1",
-        "CALL_TUPLE_1",
-        "CALL_BUILTIN_CLASS",
-        "CALL_BUILTIN_O",
-        "CALL_BUILTIN_FAST",
-        "CALL_BUILTIN_FAST_WITH_KEYWORDS",
-        "CALL_LEN",
-        "CALL_ISINSTANCE",
-        "CALL_LIST_APPEND",
-        "CALL_METHOD_DESCRIPTOR_O",
-        "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS",
-        "CALL_METHOD_DESCRIPTOR_NOARGS",
-        "CALL_METHOD_DESCRIPTOR_FAST",
-        "CALL_ALLOC_AND_ENTER_INIT",
-        "CALL_PY_GENERAL",
-        "CALL_BOUND_METHOD_GENERAL",
-        "CALL_NON_PY_GENERAL",
-    ],
-}
 
-_specialized_opmap = {
-    'BINARY_OP_ADD_FLOAT': 150,
-    'BINARY_OP_ADD_INT': 151,
-    'BINARY_OP_ADD_UNICODE': 152,
-    'BINARY_OP_INPLACE_ADD_UNICODE': 3,
-    'BINARY_OP_MULTIPLY_FLOAT': 153,
-    'BINARY_OP_MULTIPLY_INT': 154,
-    'BINARY_OP_SUBTRACT_FLOAT': 155,
-    'BINARY_OP_SUBTRACT_INT': 156,
-    'BINARY_SUBSCR_DICT': 157,
-    'BINARY_SUBSCR_GETITEM': 158,
-    'BINARY_SUBSCR_LIST_INT': 159,
-    'BINARY_SUBSCR_STR_INT': 160,
-    'BINARY_SUBSCR_TUPLE_INT': 161,
-    'CALL_ALLOC_AND_ENTER_INIT': 162,
-    'CALL_BOUND_METHOD_EXACT_ARGS': 163,
-    'CALL_BOUND_METHOD_GENERAL': 164,
-    'CALL_BUILTIN_CLASS': 165,
-    'CALL_BUILTIN_FAST': 166,
-    'CALL_BUILTIN_FAST_WITH_KEYWORDS': 167,
-    'CALL_BUILTIN_O': 168,
-    'CALL_ISINSTANCE': 169,
-    'CALL_LEN': 170,
-    'CALL_LIST_APPEND': 171,
-    'CALL_METHOD_DESCRIPTOR_FAST': 172,
-    'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS': 173,
-    'CALL_METHOD_DESCRIPTOR_NOARGS': 174,
-    'CALL_METHOD_DESCRIPTOR_O': 175,
-    'CALL_NON_PY_GENERAL': 176,
-    'CALL_PY_EXACT_ARGS': 177,
-    'CALL_PY_GENERAL': 178,
-    'CALL_STR_1': 179,
-    'CALL_TUPLE_1': 180,
-    'CALL_TYPE_1': 181,
-    'COMPARE_OP_FLOAT': 182,
-    'COMPARE_OP_INT': 183,
-    'COMPARE_OP_STR': 184,
-    'CONTAINS_OP_DICT': 185,
-    'CONTAINS_OP_SET': 186,
-    'FOR_ITER_GEN': 187,
-    'FOR_ITER_LIST': 188,
-    'FOR_ITER_RANGE': 189,
-    'FOR_ITER_TUPLE': 190,
-    'LOAD_ATTR_CLASS': 191,
-    'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN': 192,
-    'LOAD_ATTR_INSTANCE_VALUE': 193,
-    'LOAD_ATTR_METHOD_LAZY_DICT': 194,
-    'LOAD_ATTR_METHOD_NO_DICT': 195,
-    'LOAD_ATTR_METHOD_WITH_VALUES': 196,
-    'LOAD_ATTR_MODULE': 197,
-    'LOAD_ATTR_NONDESCRIPTOR_NO_DICT': 198,
-    'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES': 199,
-    'LOAD_ATTR_PROPERTY': 200,
-    'LOAD_ATTR_SLOT': 201,
-    'LOAD_ATTR_WITH_HINT': 202,
-    'LOAD_GLOBAL_BUILTIN': 203,
-    'LOAD_GLOBAL_MODULE': 204,
-    'LOAD_SUPER_ATTR_ATTR': 205,
-    'LOAD_SUPER_ATTR_METHOD': 206,
-    'RESUME_CHECK': 207,
-    'SEND_GEN': 208,
-    'STORE_ATTR_INSTANCE_VALUE': 209,
-    'STORE_ATTR_SLOT': 210,
-    'STORE_ATTR_WITH_HINT': 211,
-    'STORE_SUBSCR_DICT': 212,
-    'STORE_SUBSCR_LIST_INT': 213,
-    'TO_BOOL_ALWAYS_TRUE': 214,
-    'TO_BOOL_BOOL': 215,
-    'TO_BOOL_INT': 216,
-    'TO_BOOL_LIST': 217,
-    'TO_BOOL_NONE': 218,
-    'TO_BOOL_STR': 219,
-    'UNPACK_SEQUENCE_LIST': 220,
-    'UNPACK_SEQUENCE_TUPLE': 221,
-    'UNPACK_SEQUENCE_TWO_TUPLE': 222,
-}
+_specializations = {}
+
+_specialized_opmap = {}
 
 opmap = {
     'CACHE': 0,
-    'RESERVED': 17,
-    'RESUME': 149,
-    'INSTRUMENTED_LINE': 254,
     'BEFORE_ASYNC_WITH': 1,
     'BEFORE_WITH': 2,
+    'RESERVED_3': 3,
     'BINARY_SLICE': 4,
     'BINARY_SUBSCR': 5,
     'CHECK_EG_MATCH': 6,
@@ -206,6 +24,7 @@
     'FORMAT_SIMPLE': 14,
     'FORMAT_WITH_SPEC': 15,
     'GET_AITER': 16,
+    'RESERVED_17': 17,
     'GET_ANEXT': 18,
     'GET_ITER': 19,
     'GET_LEN': 20,
@@ -307,37 +126,39 @@
     'UNPACK_EX': 116,
     'UNPACK_SEQUENCE': 117,
     'YIELD_VALUE': 118,
-    'INSTRUMENTED_RESUME': 236,
-    'INSTRUMENTED_END_FOR': 237,
-    'INSTRUMENTED_END_SEND': 238,
-    'INSTRUMENTED_RETURN_VALUE': 239,
-    'INSTRUMENTED_RETURN_CONST': 240,
-    'INSTRUMENTED_YIELD_VALUE': 241,
-    'INSTRUMENTED_LOAD_SUPER_ATTR': 242,
-    'INSTRUMENTED_FOR_ITER': 243,
-    'INSTRUMENTED_CALL': 244,
-    'INSTRUMENTED_CALL_KW': 245,
-    'INSTRUMENTED_CALL_FUNCTION_EX': 246,
-    'INSTRUMENTED_INSTRUCTION': 247,
-    'INSTRUMENTED_JUMP_FORWARD': 248,
-    'INSTRUMENTED_JUMP_BACKWARD': 249,
-    'INSTRUMENTED_POP_JUMP_IF_TRUE': 250,
-    'INSTRUMENTED_POP_JUMP_IF_FALSE': 251,
-    'INSTRUMENTED_POP_JUMP_IF_NONE': 252,
-    'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253,
-    'JUMP': 256,
-    'JUMP_NO_INTERRUPT': 257,
-    'LOAD_CLOSURE': 258,
-    'LOAD_METHOD': 259,
-    'LOAD_SUPER_METHOD': 260,
-    'LOAD_ZERO_SUPER_ATTR': 261,
-    'LOAD_ZERO_SUPER_METHOD': 262,
-    'POP_BLOCK': 263,
-    'SETUP_CLEANUP': 264,
-    'SETUP_FINALLY': 265,
-    'SETUP_WITH': 266,
-    'STORE_FAST_MAYBE_NULL': 267,
+    'BREAK': 119,
+    'BUILD_LIST_UNPACK': 120,
+    'BUILD_MAP_FOR_CALL': 121,
+    'BUILD_SET_UNPACK': 122,
+    'BUILD_TUPLE_ITER': 123,
+    'BUILD_TUPLE_UNPACK': 124,
+    'CALL_METHOD': 125,
+    'CALL_METHOD_KW': 126,
+    'CALL_METHOD_EX': 127,
+    'CONTINUE': 128,
+    'JUMP': 129,
+    'JUMP_IF_FALSE_OR_POP': 130,
+    'JUMP_IF_TRUE_OR_POP': 131,
+    'JUMP_IF_NOT_EXC_MATCH': 132,
+    'LOAD_CLASSDEREF': 133,
+    'LOAD_CLOSURE': 134,
+    'LOAD_METHOD': 135,
+    'POP_BLOCK': 136,
+    'REVERSE': 137,
+    'SET_EXC_INFO': 138,
+    'SUBSCRIPT': 139,
+    'UNARY_OP': 140,
+    'RESERVED_141': 141,
+    'RESERVED_142': 142,
+    'RESERVED_143': 143,
+    'RESERVED_144': 144,
+    'RESERVED_145': 145,
+    'RESERVED_146': 146,
+    'RESERVED_147': 147,
+    'RESERVED_148': 148,
+    'RESUME': 149,
 }
 
+# CPython 3.13 compatible: opcodes < 44 have no argument
 HAVE_ARGUMENT = 44
 MIN_INSTRUMENTED_OPCODE = 236
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index 41f538acb03..ca73eb2fcf7 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -489,7 +489,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3571).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (2997).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index dd4f30ab17d..60dcdc6cd70 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -27,6 +27,7 @@ def test_invalid_opcodes(self):
         self.check_bool_function_result(_opcode.has_local, invalid, False)
         self.check_bool_function_result(_opcode.has_exc, invalid, False)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON - no instrumented opcodes
     def test_is_valid(self):
         names = [
             'CACHE',
@@ -56,7 +57,6 @@ def check_function(self, func, expected):
 
 
 class StackEffectTests(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_stack_effect(self):
         self.assertEqual(stack_effect(dis.opmap['POP_TOP']), -1)
         self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 0), -1)
@@ -111,6 +111,7 @@ def test_stack_effect_jump(self):
 
 
 class SpecializationStatsTests(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON - no specialization stats
     def test_specialization_stats(self):
         stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
         specialized_opcodes = [
diff --git a/Lib/test/test_asyncgen.py b/Lib/test/test_asyncgen.py
index 7039bd7054c..45d220e3e02 100644
--- a/Lib/test/test_asyncgen.py
+++ b/Lib/test/test_asyncgen.py
@@ -1026,8 +1026,6 @@ async def run():
         fut.cancel()
         self.loop.run_until_complete(asyncio.sleep(0.01))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_async_gen_asyncio_gc_aclose_09(self):
         DONE = 0
 
@@ -1514,8 +1512,6 @@ async def main():
         self.assertIn('an error occurred during closing of asynchronous generator',
                       message['message'])
 
-    # TODO: RUSTPYTHON, ValueError: not enough values to unpack (expected 1, got 0)
-    @unittest.expectedFailure
     def test_async_gen_asyncio_shutdown_exception_02(self):
         messages = []
 
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 3ea09354c3c..9f6ad6879c0 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1039,8 +1039,6 @@ def test_big_dict_literal(self):
         the_dict = "{" + ",".join(f"{x}:{x}" for x in range(dict_size)) + "}"
         self.assertEqual(len(eval(the_dict)), dict_size)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_redundant_jump_in_if_else_break(self):
         # Check if bytecode containing jumps that simply point to the next line
         # is generated around if-else-break style structures. See bpo-42615.
diff --git a/Lib/test/test_contextlib.py b/Lib/test/test_contextlib.py
index 9bb3fd0179b..420cc2510a8 100644
--- a/Lib/test/test_contextlib.py
+++ b/Lib/test/test_contextlib.py
@@ -844,8 +844,6 @@ def test_exit_suppress(self):
             stack.push(lambda *exc: True)
             1/0
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exit_exception_traceback(self):
         # This test captures the current behavior of ExitStack so that we know
         # if we ever unintendedly change it. It is not a statement of what the
diff --git a/Lib/test/test_contextlib_async.py b/Lib/test/test_contextlib_async.py
index d7331c4d433..0cf32abb76f 100644
--- a/Lib/test/test_contextlib_async.py
+++ b/Lib/test/test_contextlib_async.py
@@ -535,6 +535,11 @@ def __exit__(self, *exc_details):
         ('__aexit__', 'cb_suppress = cb(*exc_details)'),
     ]
 
+    # TODO: RUSTPYTHON - no _asyncio module, pure Python Task adds extra frame
+    @unittest.expectedFailure
+    def test_exit_exception_traceback(self):
+        super().test_exit_exception_traceback()
+
     async def test_async_callback(self):
         expected = [
             ((), {}),
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index dab8d73e54c..eddfc155619 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -1974,6 +1974,7 @@ def test_baseopname_and_baseopcode(self):
             self.assertIn(name, opcode._specializations[baseopname])
             self.assertEqual(opcode.opmap[baseopname], baseopcode)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD/JUMP_FORWARD are placeholders
     def test_jump_target(self):
         # Non-jump instructions should return None
         instruction = Instruction(opname="NOP", opcode=dis.opmap["NOP"], arg=None, argval=None,
@@ -1999,6 +2000,7 @@ def test_jump_target(self):
                                   positions=None)
         self.assertEqual(10 + 2 + 1*2 + 100*2, instruction.jump_target)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD is a placeholder
     def test_argval_argrepr(self):
         def f(opcode, oparg, offset, *init_args):
             arg_resolver = dis.ArgResolver(*init_args)
@@ -2019,6 +2021,7 @@ def f(opcode, oparg, offset, *init_args):
         self.assertEqual(f(opcode.opmap["BINARY_OP"], 3, *args), (3, '<<'))
         self.assertEqual(f(opcode.opmap["CALL_INTRINSIC_1"], 2, *args), (2, 'INTRINSIC_IMPORT_STAR'))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD is a placeholder
     def test_custom_arg_resolver(self):
         class MyArgResolver(dis.ArgResolver):
             def offset_from_jump_arg(self, op, arg, offset):
@@ -2090,7 +2093,6 @@ def last_item(iterable):
         self.assertEqual(14, instructions[6].offset)
         self.assertEqual(8, instructions[6].start_offset)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cache_offset_and_end_offset(self):
         code = bytes([
             opcode.opmap["LOAD_GLOBAL"], 0x01,
@@ -2189,7 +2191,6 @@ def test_bytecode_co_positions(self):
             assert instr.positions == positions
 
 class TestBytecodeTestCase(BytecodeTestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_not_in_with_op_not_in_bytecode(self):
         code = compile("a = 1", "<string>", "exec")
         self.assertInBytecode(code, "LOAD_CONST", 1)
@@ -2210,7 +2211,6 @@ def test_assert_not_in_with_arg_in_bytecode(self):
             self.assertNotInBytecode(code, "LOAD_CONST", 1)
 
 class TestFinderMethods(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__find_imports(self):
         cases = [
             ("import a.b.c", ('a.b.c', 0, None)),
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 3db9203602e..ceb94df324e 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -1152,7 +1152,6 @@ class C(Exception):
         self.assertIs(c.__context__, b)
         self.assertIsNone(b.__context__)
 
-    @unittest.skip("TODO: RUSTPYTHON; Infinite loop")
     def test_no_hang_on_context_chain_cycle1(self):
         # See issue 25782. Cycle in context chain.
 
@@ -1208,7 +1207,6 @@ class C(Exception):
         self.assertIs(b.__context__, a)
         self.assertIs(a.__context__, c)
 
-    @unittest.skip("TODO: RUSTPYTHON; Infinite loop")
     def test_no_hang_on_context_chain_cycle3(self):
         # See issue 25782. Longer context chain with cycle.
 
@@ -2560,7 +2558,6 @@ def in_finally_except():
                 pass
         self.lineno_after_raise(in_finally_except, 4)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lineno_after_with(self):
         class Noop:
             def __enter__(self):
diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index 8833a102b36..853767135aa 100644
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -725,7 +725,6 @@ def g():
 
 class GeneratorThrowTest(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_exception_context_with_yield(self):
         def f():
             try:
@@ -762,7 +761,6 @@ def f():
         # This ensures that the assertions inside were executed.
         self.assertEqual(actual, 'b')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_exception_context_with_yield_from(self):
         def f():
             yield
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 87b7de9889b..bc47159b235 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -636,7 +636,7 @@ def test_magic_number(self):
         # stakeholders such as OS package maintainers must be notified
         # in advance. Such exceptional releases will then require an
         # adjustment to this test case.
-        EXPECTED_MAGIC_NUMBER = 3531
+        EXPECTED_MAGIC_NUMBER = 2997
         actual = int.from_bytes(importlib.util.MAGIC_NUMBER[:2], 'little')
 
         msg = (
diff --git a/Lib/test/test_patma.py b/Lib/test/test_patma.py
index 847ca001e43..6ca1fa0ba40 100644
--- a/Lib/test/test_patma.py
+++ b/Lib/test/test_patma.py
@@ -3394,7 +3394,6 @@ class Keys:
         self.assertIs(z, None)
 
 class TestSourceLocations(unittest.TestCase):
-    @unittest.expectedFailure   # TODO: RUSTPYTHON
     def test_jump_threading(self):
         # See gh-123048
         def f():
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index f2ec8344b2f..2ba7fbda5c3 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -3749,8 +3749,6 @@ def test_comparison_basic(self):
         self.assertNotEqual(exc, object())
         self.assertEqual(exc, ALWAYS_EQ)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_comparison_params_variations(self):
         def raise_exc():
             try:
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 5cc7d0d2212..2fb22f46a85 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -64,12 +64,28 @@ pub enum FBlockType {
     StopIteration,
 }
 
+/// Stores additional data for fblock unwinding
+// fb_datum
+#[derive(Debug, Clone)]
+pub enum FBlockDatum {
+    None,
+    /// For FinallyTry: stores the finally body statements to compile during unwind
+    FinallyBody(Vec<Stmt>),
+    /// For HandlerCleanup: stores the exception variable name (e.g., "e" in "except X as e")
+    ExceptionName(String),
+}
+
 #[derive(Debug, Clone)]
 pub struct FBlockInfo {
     pub fb_type: FBlockType,
     pub fb_block: BlockIdx,
     pub fb_exit: BlockIdx,
-    // fb_datum is not needed in RustPython
+    // For Python 3.11+ exception table generation
+    pub fb_handler: Option<BlockIdx>, // Exception handler block
+    pub fb_stack_depth: u32,          // Stack depth at block entry
+    pub fb_preserve_lasti: bool,      // Whether to preserve lasti (for SETUP_CLEANUP)
+    // additional data for fblock unwinding
+    pub fb_datum: FBlockDatum,
 }
 
 pub(crate) type InternalResult<T> = Result<T, InternalError>;
@@ -138,6 +154,8 @@ struct CompileContext {
     loop_data: Option<(BlockIdx, BlockIdx)>,
     in_class: bool,
     func: FunctionContext,
+    /// True if we're anywhere inside an async function (even inside nested comprehensions)
+    in_async_scope: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -401,6 +419,7 @@ impl Compiler {
                 loop_data: None,
                 in_class: false,
                 func: FunctionContext::NoFunction,
+                in_async_scope: false,
             },
             opts,
             in_annotation: false,
@@ -453,7 +472,7 @@ impl Compiler {
         // 3. Handle two-element slice specially
         // 4. Otherwise VISIT slice and emit appropriate instruction
 
-        // For Load context, CPython does some checks (we skip for now)
+        // For Load context, some checks are skipped for now
         // if ctx == ExprContext::Load {
         //     check_subscripter(value);
         //     check_index(value, slice);
@@ -470,12 +489,10 @@ impl Compiler {
             };
             match ctx {
                 ExprContext::Load => {
-                    // CPython uses BINARY_SLICE
                     emit!(self, Instruction::BuildSlice { argc });
                     emit!(self, Instruction::Subscript);
                 }
                 ExprContext::Store => {
-                    // CPython uses STORE_SLICE
                     emit!(self, Instruction::BuildSlice { argc });
                     emit!(self, Instruction::StoreSubscript);
                 }
@@ -646,6 +663,14 @@ impl Compiler {
         self.symbol_table_stack.pop().expect("compiler bug")
     }
 
+    /// Check if this is an inlined comprehension context (PEP 709)
+    /// Currently disabled - always returns false to avoid stack issues
+    fn is_inlined_comprehension_context(&self, _comprehension_type: ComprehensionType) -> bool {
+        // TODO: Implement PEP 709 inlined comprehensions properly
+        // For now, disabled to avoid stack underflow issues
+        false
+    }
+
     /// Enter a new scope
     // = compiler_enter_scope
     fn enter_scope(
@@ -880,6 +905,50 @@ impl Compiler {
         fb_type: FBlockType,
         fb_block: BlockIdx,
         fb_exit: BlockIdx,
+    ) -> CompileResult<()> {
+        self.push_fblock_full(
+            fb_type,
+            fb_block,
+            fb_exit,
+            None,
+            0,
+            false,
+            FBlockDatum::None,
+        )
+    }
+
+    /// Push an fblock with exception handler info
+    fn push_fblock_with_handler(
+        &mut self,
+        fb_type: FBlockType,
+        fb_block: BlockIdx,
+        fb_exit: BlockIdx,
+        fb_handler: Option<BlockIdx>,
+        fb_stack_depth: u32,
+        fb_preserve_lasti: bool,
+    ) -> CompileResult<()> {
+        self.push_fblock_full(
+            fb_type,
+            fb_block,
+            fb_exit,
+            fb_handler,
+            fb_stack_depth,
+            fb_preserve_lasti,
+            FBlockDatum::None,
+        )
+    }
+
+    /// Push an fblock with all parameters including fb_datum
+    #[allow(clippy::too_many_arguments)]
+    fn push_fblock_full(
+        &mut self,
+        fb_type: FBlockType,
+        fb_block: BlockIdx,
+        fb_exit: BlockIdx,
+        fb_handler: Option<BlockIdx>,
+        fb_stack_depth: u32,
+        fb_preserve_lasti: bool,
+        fb_datum: FBlockDatum,
     ) -> CompileResult<()> {
         let code = self.current_code_info();
         if code.fblock.len() >= MAXBLOCKS {
@@ -891,6 +960,10 @@ impl Compiler {
             fb_type,
             fb_block,
             fb_exit,
+            fb_handler,
+            fb_stack_depth,
+            fb_preserve_lasti,
+            fb_datum,
         });
         Ok(())
     }
@@ -904,6 +977,233 @@ impl Compiler {
         code.fblock.pop().expect("fblock stack underflow")
     }
 
+    /// Unwind a single fblock, emitting cleanup code
+    /// preserve_tos: if true, preserve the top of stack (e.g., return value)
+    fn unwind_fblock(&mut self, info: &FBlockInfo, preserve_tos: bool) -> CompileResult<()> {
+        match info.fb_type {
+            FBlockType::WhileLoop
+            | FBlockType::ExceptionHandler
+            | FBlockType::ExceptionGroupHandler
+            | FBlockType::AsyncComprehensionGenerator
+            | FBlockType::StopIteration => {
+                // No cleanup needed
+            }
+
+            FBlockType::ForLoop => {
+                // Pop the iterator
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop);
+            }
+
+            FBlockType::TryExcept => {
+                // No POP_BLOCK with exception table, just pop fblock
+            }
+
+            FBlockType::FinallyTry => {
+                // FinallyTry is now handled specially in unwind_fblock_stack
+                // to avoid infinite recursion when the finally body contains return/break/continue.
+                // This branch should not be reached.
+                unreachable!("FinallyTry should be handled by unwind_fblock_stack");
+            }
+
+            FBlockType::FinallyEnd => {
+                // Stack when in FinallyEnd: [..., prev_exc, exc] or
+                // [..., prev_exc, exc, return_value] if preserve_tos
+                // Note: No lasti here - it's only pushed for cleanup handler exceptions
+                // We need to pop: exc, prev_exc (via PopException)
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop); // exc
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopException); // prev_exc is restored
+            }
+
+            FBlockType::With | FBlockType::AsyncWith => {
+                // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
+                // Need to call __exit__(None, None, None)
+
+                emit!(self, Instruction::PopBlock);
+
+                // If preserving return value, swap it below __exit__
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+
+                // Call __exit__(None, None, None) - compiler_call_exit_with_nones
+                // Stack: [..., __exit__] or [..., return_value, __exit__]
+                self.emit_load_const(ConstantData::None);
+                self.emit_load_const(ConstantData::None);
+                self.emit_load_const(ConstantData::None);
+                emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+
+                // For async with, await the result
+                if matches!(info.fb_type, FBlockType::AsyncWith) {
+                    emit!(self, Instruction::GetAwaitable);
+                    self.emit_load_const(ConstantData::None);
+                    self.compile_yield_from_sequence(true)?;
+                }
+
+                // Pop the __exit__ result
+                emit!(self, Instruction::PopTop);
+            }
+
+            FBlockType::HandlerCleanup => {
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopException);
+
+                // If there's an exception name, clean it up
+                if let FBlockDatum::ExceptionName(ref name) = info.fb_datum {
+                    self.emit_load_const(ConstantData::None);
+                    self.store_name(name)?;
+                    self.compile_name(name, NameUsage::Delete)?;
+                }
+            }
+
+            FBlockType::PopValue => {
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop);
+            }
+        }
+        Ok(())
+    }
+
+    /// Unwind the fblock stack, emitting cleanup code for each block
+    /// preserve_tos: if true, preserve the top of stack (e.g., return value)
+    /// stop_at_loop: if true, stop when encountering a loop (for break/continue)
+    fn unwind_fblock_stack(&mut self, preserve_tos: bool, stop_at_loop: bool) -> CompileResult<()> {
+        // Collect the info we need, with indices for FinallyTry blocks
+        #[derive(Clone)]
+        enum UnwindInfo {
+            Normal(FBlockInfo),
+            FinallyTry {
+                body: Vec<ruff_python_ast::Stmt>,
+                fblock_idx: usize,
+            },
+        }
+        let mut unwind_infos = Vec::new();
+
+        {
+            let code = self.current_code_info();
+            for i in (0..code.fblock.len()).rev() {
+                // Check for exception group handler (forbidden)
+                if matches!(code.fblock[i].fb_type, FBlockType::ExceptionGroupHandler) {
+                    return Err(self.error(CodegenErrorType::BreakContinueReturnInExceptStar));
+                }
+
+                // Stop at loop if requested
+                if stop_at_loop
+                    && matches!(
+                        code.fblock[i].fb_type,
+                        FBlockType::WhileLoop | FBlockType::ForLoop
+                    )
+                {
+                    break;
+                }
+
+                if matches!(code.fblock[i].fb_type, FBlockType::FinallyTry) {
+                    if let FBlockDatum::FinallyBody(ref body) = code.fblock[i].fb_datum {
+                        unwind_infos.push(UnwindInfo::FinallyTry {
+                            body: body.clone(),
+                            fblock_idx: i,
+                        });
+                    }
+                } else {
+                    unwind_infos.push(UnwindInfo::Normal(code.fblock[i].clone()));
+                }
+            }
+        }
+
+        // Process each fblock
+        for info in unwind_infos {
+            match info {
+                UnwindInfo::Normal(fblock_info) => {
+                    self.unwind_fblock(&fblock_info, preserve_tos)?;
+                }
+                UnwindInfo::FinallyTry { body, fblock_idx } => {
+                    // Temporarily remove the FinallyTry fblock so nested return/break/continue
+                    // in the finally body won't see it again
+                    let code = self.current_code_info();
+                    let saved_fblock = code.fblock.remove(fblock_idx);
+
+                    // Push PopValue fblock if preserving tos
+                    // IMPORTANT: When preserving TOS (return value), we need to update the
+                    // exception handler's stack_depth to account for the return value on stack.
+                    // Otherwise, if an exception occurs during the finally body, the stack
+                    // will be unwound to the wrong depth and the return value will be lost.
+                    if preserve_tos {
+                        // Get the handler info from the saved fblock (or current handler)
+                        // and create a new handler with stack_depth + 1
+                        let (handler, stack_depth, preserve_lasti) =
+                            if let Some(handler) = saved_fblock.fb_handler {
+                                (
+                                    Some(handler),
+                                    saved_fblock.fb_stack_depth + 1, // +1 for return value
+                                    saved_fblock.fb_preserve_lasti,
+                                )
+                            } else {
+                                // No handler in saved_fblock, check current handler
+                                if let Some(current_handler) = self.current_except_handler() {
+                                    (
+                                        Some(current_handler.handler_block),
+                                        current_handler.stack_depth + 1, // +1 for return value
+                                        current_handler.preserve_lasti,
+                                    )
+                                } else {
+                                    (None, 1, false) // No handler, but still track the return value
+                                }
+                            };
+
+                        self.push_fblock_with_handler(
+                            FBlockType::PopValue,
+                            saved_fblock.fb_block,
+                            saved_fblock.fb_block,
+                            handler,
+                            stack_depth,
+                            preserve_lasti,
+                        )?;
+                    }
+
+                    self.compile_statements(&body)?;
+
+                    if preserve_tos {
+                        self.pop_fblock(FBlockType::PopValue);
+                    }
+
+                    // Restore the fblock
+                    let code = self.current_code_info();
+                    code.fblock.insert(fblock_idx, saved_fblock);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Get the current exception handler from fblock stack
+    fn current_except_handler(&self) -> Option<ir::ExceptHandlerInfo> {
+        let code = self.code_stack.last()?;
+        // Walk fblock stack from top to find the nearest exception handler
+        for fblock in code.fblock.iter().rev() {
+            if let Some(handler) = fblock.fb_handler {
+                return Some(ir::ExceptHandlerInfo {
+                    handler_block: handler,
+                    stack_depth: fblock.fb_stack_depth,
+                    preserve_lasti: fblock.fb_preserve_lasti,
+                });
+            }
+        }
+        None
+    }
+
     // could take impl Into<Cow<str>>, but everything is borrowed from ast structs; we never
     // actually have a `String` to pass
     fn name(&mut self, name: &str) -> bytecode::NameIdx {
@@ -1511,7 +1811,7 @@ impl Compiler {
                             None => bytecode::RaiseKind::Raise,
                         }
                     }
-                    None => bytecode::RaiseKind::Reraise,
+                    None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
                 emit!(self, Instruction::Raise { kind });
@@ -1594,82 +1894,12 @@ impl Compiler {
                 }
             }
             Stmt::Break(_) => {
-                // Find the innermost loop in fblock stack
-                // Error if we encounter ExceptionGroupHandler before finding a loop
-                let found_loop = {
-                    let code = self.current_code_info();
-                    let mut result = Ok(None);
-                    for i in (0..code.fblock.len()).rev() {
-                        match code.fblock[i].fb_type {
-                            FBlockType::WhileLoop | FBlockType::ForLoop => {
-                                result = Ok(Some(code.fblock[i].fb_exit));
-                                break;
-                            }
-                            FBlockType::ExceptionGroupHandler => {
-                                result = Err(());
-                                break;
-                            }
-                            _ => continue,
-                        }
-                    }
-                    result
-                };
-
-                match found_loop {
-                    Ok(Some(exit_block)) => {
-                        emit!(self, Instruction::Break { target: exit_block });
-                    }
-                    Ok(None) => {
-                        return Err(
-                            self.error_ranged(CodegenErrorType::InvalidBreak, statement.range())
-                        );
-                    }
-                    Err(()) => {
-                        return Err(self.error_ranged(
-                            CodegenErrorType::BreakContinueReturnInExceptStar,
-                            statement.range(),
-                        ));
-                    }
-                }
+                // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
+                self.compile_break_continue(statement.range(), true)?;
             }
             Stmt::Continue(_) => {
-                // Find the innermost loop in fblock stack
-                // Error if we encounter ExceptionGroupHandler before finding a loop
-                let found_loop = {
-                    let code = self.current_code_info();
-                    let mut result = Ok(None);
-                    for i in (0..code.fblock.len()).rev() {
-                        match code.fblock[i].fb_type {
-                            FBlockType::WhileLoop | FBlockType::ForLoop => {
-                                result = Ok(Some(code.fblock[i].fb_block));
-                                break;
-                            }
-                            FBlockType::ExceptionGroupHandler => {
-                                result = Err(());
-                                break;
-                            }
-                            _ => continue,
-                        }
-                    }
-                    result
-                };
-
-                match found_loop {
-                    Ok(Some(loop_block)) => {
-                        emit!(self, Instruction::Continue { target: loop_block });
-                    }
-                    Ok(None) => {
-                        return Err(
-                            self.error_ranged(CodegenErrorType::InvalidContinue, statement.range())
-                        );
-                    }
-                    Err(()) => {
-                        return Err(self.error_ranged(
-                            CodegenErrorType::BreakContinueReturnInExceptStar,
-                            statement.range(),
-                        ));
-                    }
-                }
+                // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
+                self.compile_break_continue(statement.range(), false)?;
             }
             Stmt::Return(StmtReturn { value, .. }) => {
                 if !self.ctx.in_func() {
@@ -1677,18 +1907,7 @@ impl Compiler {
                         self.error_ranged(CodegenErrorType::InvalidReturn, statement.range())
                     );
                 }
-                // Check if we're inside an except* block in the current function
-                {
-                    let code = self.current_code_info();
-                    for block in code.fblock.iter().rev() {
-                        if matches!(block.fb_type, FBlockType::ExceptionGroupHandler) {
-                            return Err(self.error_ranged(
-                                CodegenErrorType::BreakContinueReturnInExceptStar,
-                                statement.range(),
-                            ));
-                        }
-                    }
-                }
+
                 match value {
                     Some(v) => {
                         if self.ctx.func == FunctionContext::AsyncFunction
@@ -1703,9 +1922,13 @@ impl Compiler {
                             ));
                         }
                         self.compile_expression(v)?;
+                        // Unwind fblock stack with preserve_tos=true (preserve return value)
+                        self.unwind_fblock_stack(true, false)?;
                         self.emit_return_value();
                     }
                     None => {
+                        // Unwind fblock stack with preserve_tos=false (no value to preserve)
+                        self.unwind_fblock_stack(false, false)?;
                         self.emit_return_const(ConstantData::None);
                     }
                 }
@@ -1926,7 +2149,7 @@ impl Compiler {
     }
 
     /// Store each type parameter so it is accessible to the current scope, and leave a tuple of
-    /// all the type parameters on the stack.
+    /// all the type parameters on the stack. Handles default values per PEP 695.
     fn compile_type_params(&mut self, type_params: &TypeParams) -> CompileResult<()> {
         // First, compile each type parameter and store it
         for type_param in &type_params.type_params {
@@ -1964,7 +2187,6 @@ impl Compiler {
                         );
                     }
 
-                    // Handle default value if present (PEP 695)
                     if let Some(default_expr) = default {
                         let scope_name = format!("<TypeVar default of {name}>");
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
@@ -1990,7 +2212,6 @@ impl Compiler {
                         }
                     );
 
-                    // Handle default value if present (PEP 695)
                     if let Some(default_expr) = default {
                         let scope_name = format!("<ParamSpec default of {name}>");
                         self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
@@ -2016,7 +2237,6 @@ impl Compiler {
                         }
                     );
 
-                    // Handle default value if present (PEP 695)
                     if let Some(default_expr) = default {
                         // TypeVarTuple allows starred expressions
                         let scope_name = format!("<TypeVarTuple default of {name}>");
@@ -2053,32 +2273,178 @@ impl Compiler {
         let handler_block = self.new_block();
         let finally_block = self.new_block();
 
+        // finally needs TWO blocks:
+        // - finally_block: normal path (no exception active)
+        // - finally_except_block: exception path (PUSH_EXC_INFO -> body -> RERAISE)
+        let finally_except_block = if !finalbody.is_empty() {
+            Some(self.new_block())
+        } else {
+            None
+        };
+        let finally_cleanup_block = if finally_except_block.is_some() {
+            Some(self.new_block())
+        } else {
+            None
+        };
+        // End block - continuation point after try-finally
+        // Normal path jumps here to skip exception path blocks
+        let end_block = self.new_block();
+
+        // Calculate the stack depth at this point (for exception table)
+        // SETUP_FINALLY captures current stack depth
+        let current_depth = self.handler_stack_depth();
+
         // Setup a finally block if we have a finally statement.
+        // Push fblock with handler info for exception table generation
+        // IMPORTANT: handler goes to finally_except_block (exception path), not finally_block
         if !finalbody.is_empty() {
-            emit!(
-                self,
-                Instruction::SetupFinally {
-                    handler: finally_block,
-                }
-            );
+            // No SetupFinally emit - exception table handles this
+            // Store finally body in fb_datum for unwind_fblock to compile inline
+            // SETUP_FINALLY doesn't push lasti for try body handler
+            // Exception table: L1 to L2 -> L4 [1] (no lasti)
+            self.push_fblock_full(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                finally_except_block, // Exception path goes to finally_except_block
+                current_depth,
+                false, // No lasti for first finally handler
+                FBlockDatum::FinallyBody(finalbody.to_vec()), // Clone finally body for unwind
+            )?;
         }
 
         let else_block = self.new_block();
 
-        // try:
-        emit!(
-            self,
-            Instruction::SetupExcept {
-                handler: handler_block,
+        // if handlers is empty, compile body directly
+        // without wrapping in TryExcept (only FinallyTry is needed)
+        if handlers.is_empty() {
+            // Just compile body with FinallyTry fblock active (if finalbody exists)
+            self.compile_statements(body)?;
+
+            // Pop FinallyTry fblock BEFORE compiling orelse/finally (normal path)
+            // This prevents exception table from covering the normal path
+            if !finalbody.is_empty() {
+                self.pop_fblock(FBlockType::FinallyTry);
             }
-        );
+
+            // Compile orelse (usually empty for try-finally without except)
+            self.compile_statements(orelse)?;
+
+            // Snapshot sub_tables before first finally compilation
+            // This allows us to restore them for the second compilation (exception path)
+            let sub_tables_snapshot = if !finalbody.is_empty() && finally_except_block.is_some() {
+                Some(
+                    self.symbol_table_stack
+                        .last()
+                        .map(|t| t.sub_tables.clone())
+                        .unwrap_or_default(),
+                )
+            } else {
+                None
+            };
+
+            // Compile finally body inline for normal path
+            if !finalbody.is_empty() {
+                self.compile_statements(finalbody)?;
+            }
+
+            // Jump to end (skip exception path blocks)
+            emit!(self, Instruction::Jump { target: end_block });
+
+            if let Some(finally_except) = finally_except_block {
+                // Restore sub_tables for exception path compilation
+                if let Some(snapshot) = sub_tables_snapshot
+                    && let Some(current_table) = self.symbol_table_stack.last_mut()
+                {
+                    current_table.sub_tables = snapshot;
+                }
+
+                self.switch_to_block(finally_except);
+                // PUSH_EXC_INFO first, THEN push FinallyEnd fblock
+                // Stack after unwind (no lasti): [exc] (depth = current_depth + 1)
+                // Stack after PUSH_EXC_INFO: [prev_exc, exc] (depth = current_depth + 2)
+                emit!(self, Instruction::PushExcInfo);
+                if let Some(cleanup) = finally_cleanup_block {
+                    // FinallyEnd fblock must be pushed AFTER PUSH_EXC_INFO
+                    // Depth = current_depth + 1 (only prev_exc remains after RERAISE pops exc)
+                    // Exception table: L4 to L5 -> L6 [2] lasti (cleanup handler DOES push lasti)
+                    self.push_fblock_with_handler(
+                        FBlockType::FinallyEnd,
+                        cleanup,
+                        cleanup,
+                        Some(cleanup),
+                        current_depth + 1,
+                        true, // Cleanup handler pushes lasti
+                    )?;
+                }
+                self.compile_statements(finalbody)?;
+                // RERAISE 0 is emitted BEFORE pop_fblock
+                // This ensures RERAISE goes to cleanup block (FinallyEnd handler)
+                // which then properly restores prev_exc before going to outer handler
+                emit!(
+                    self,
+                    Instruction::Raise {
+                        kind: bytecode::RaiseKind::ReraiseFromStack
+                    }
+                );
+                if finally_cleanup_block.is_some() {
+                    self.pop_fblock(FBlockType::FinallyEnd);
+                }
+            }
+
+            if let Some(cleanup) = finally_cleanup_block {
+                self.switch_to_block(cleanup);
+                emit!(self, Instruction::CopyItem { index: 3_u32 });
+                emit!(self, Instruction::PopException);
+                emit!(
+                    self,
+                    Instruction::Raise {
+                        kind: bytecode::RaiseKind::ReraiseFromStack
+                    }
+                );
+            }
+
+            self.switch_to_block(end_block);
+            return Ok(());
+        }
+
+        // try:
+        // Push fblock with handler info for exception table generation
+        // No SetupExcept emit - exception table handles this
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept,
+            handler_block,
+            handler_block,
+            Some(handler_block),
+            current_depth, // stack depth for exception handler
+            false,         // no lasti for except
+        )?;
         self.compile_statements(body)?;
-        emit!(self, Instruction::PopBlock);
+        self.pop_fblock(FBlockType::TryExcept);
+        // No PopBlock emit - exception table handles this
         emit!(self, Instruction::Jump { target: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
-        // Exception is on top of stack now
+
+        // SETUP_CLEANUP(cleanup) for except block
+        // This handles exceptions during exception matching
+        // Exception table: L2 to L3 -> L5 [1] lasti
+        // After PUSH_EXC_INFO, stack is [prev_exc, exc]
+        // depth=1 means keep prev_exc on stack when routing to cleanup
+        let cleanup_block = self.new_block();
+        self.push_fblock_with_handler(
+            FBlockType::ExceptionHandler,
+            cleanup_block,
+            cleanup_block,
+            Some(cleanup_block),
+            current_depth + 1, // After PUSH_EXC_INFO: [prev_exc] stays on stack
+            true,              // preserve_lasti for cleanup
+        )?;
+
+        // Exception is on top of stack now, pushed by unwind_blocks
+        // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopException
+        emit!(self, Instruction::PushExcInfo);
         for handler in handlers {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
                 type_, name, body, ..
@@ -2108,11 +2474,76 @@ impl Compiler {
                 emit!(self, Instruction::PopTop);
             }
 
+            // If name is bound, we need a cleanup handler for RERAISE
+            let handler_cleanup_block = if name.is_some() {
+                // SETUP_CLEANUP(cleanup_end) for named handler
+                let cleanup_end = self.new_block();
+                // Stack at handler entry: [prev_exc, exc]
+                // depth = 1 (prev_exc on stack after exception is popped)
+                let handler_depth = current_depth + 1;
+                self.push_fblock_with_handler(
+                    FBlockType::HandlerCleanup,
+                    cleanup_end,
+                    cleanup_end,
+                    Some(cleanup_end),
+                    handler_depth,
+                    true, // preserve_lasti for RERAISE
+                )?;
+                Some(cleanup_end)
+            } else {
+                // no SETUP_CLEANUP for unnamed handler
+                self.push_fblock(FBlockType::HandlerCleanup, finally_block, finally_block)?;
+                None
+            };
+
             // Handler code:
             self.compile_statements(body)?;
+
+            self.pop_fblock(FBlockType::HandlerCleanup);
+
+            // Create a block for normal path continuation (after handler body succeeds)
+            let handler_normal_exit = self.new_block();
+            emit!(
+                self,
+                Instruction::Jump {
+                    target: handler_normal_exit,
+                }
+            );
+
+            // cleanup_end block for named handler
+            // IMPORTANT: In CPython, cleanup_end is within outer SETUP_CLEANUP scope.
+            // so when RERAISE is executed, it goes to the cleanup block which does POP_EXCEPT.
+            // We MUST compile cleanup_end BEFORE popping ExceptionHandler so RERAISE routes to cleanup_block.
+            if let Some(cleanup_end) = handler_cleanup_block {
+                self.switch_to_block(cleanup_end);
+                if let Some(alias) = name {
+                    // name = None; del name; before RERAISE
+                    self.emit_load_const(ConstantData::None);
+                    self.store_name(alias.as_str())?;
+                    self.compile_name(alias.as_str(), NameUsage::Delete)?;
+                }
+                // RERAISE 1 (with lasti) - exception is on stack from exception table routing
+                // Stack at entry: [prev_exc (at handler_depth), lasti, exc]
+                // This RERAISE is within ExceptionHandler scope, so it routes to cleanup_block
+                // which does COPY 3; POP_EXCEPT; RERAISE
+                emit!(
+                    self,
+                    Instruction::Raise {
+                        kind: bytecode::RaiseKind::ReraiseFromStack,
+                    }
+                );
+            }
+
+            // Switch to normal exit block - this is where handler body success continues
+            self.switch_to_block(handler_normal_exit);
+
+            // Now pop ExceptionHandler - the normal path continues from here
+            // POP_BLOCK (HandlerCleanup) then POP_BLOCK (SETUP_CLEANUP)
+            // followed by POP_EXCEPT
+            self.pop_fblock(FBlockType::ExceptionHandler);
             emit!(self, Instruction::PopException);
 
-            // Delete the exception variable if it was bound
+            // Delete the exception variable if it was bound (normal path)
             if let Some(alias) = name {
                 // Set the variable to None before deleting
                 self.emit_load_const(ConstantData::None);
@@ -2120,12 +2551,7 @@ impl Compiler {
                 self.compile_name(alias.as_str(), NameUsage::Delete)?;
             }
 
-            if !finalbody.is_empty() {
-                emit!(self, Instruction::PopBlock); // pop excepthandler block
-                // We enter the finally block, without exception.
-                emit!(self, Instruction::EnterFinally);
-            }
-
+            // Jump to finally block
             emit!(
                 self,
                 Instruction::Jump {
@@ -2133,16 +2559,49 @@ impl Compiler {
                 }
             );
 
+            // Re-push ExceptionHandler for next handler in the loop
+            // This will be popped at the end of handlers loop or when matched
+            self.push_fblock_with_handler(
+                FBlockType::ExceptionHandler,
+                cleanup_block,
+                cleanup_block,
+                Some(cleanup_block),
+                current_depth + 1, // After PUSH_EXC_INFO: [prev_exc] stays on stack
+                true,              // preserve_lasti for cleanup
+            )?;
+
             // Emit a new label for the next handler
             self.switch_to_block(next_handler);
         }
 
         // If code flows here, we have an unhandled exception,
         // raise the exception again!
+        // RERAISE 0
+        // Stack: [prev_exc, exc] - exception is on stack from PUSH_EXC_INFO
+        // NOTE: We emit RERAISE 0 BEFORE popping fblock so it is within cleanup handler scope
+        emit!(
+            self,
+            Instruction::Raise {
+                kind: bytecode::RaiseKind::ReraiseFromStack,
+            }
+        );
+
+        // Pop EXCEPTION_HANDLER fblock
+        // Pop after RERAISE so the instruction has the correct exception handler
+        self.pop_fblock(FBlockType::ExceptionHandler);
+
+        // cleanup block (POP_EXCEPT_AND_RERAISE)
+        // Stack at entry: [prev_exc, lasti, exc] (depth=1 + lasti + exc pushed)
+        // COPY 3: copy prev_exc to top -> [prev_exc, lasti, exc, prev_exc]
+        // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
+        // RERAISE 1: reraise with lasti
+        self.switch_to_block(cleanup_block);
+        emit!(self, Instruction::CopyItem { index: 3_u32 });
+        emit!(self, Instruction::PopException);
         emit!(
             self,
             Instruction::Raise {
-                kind: bytecode::RaiseKind::Reraise,
+                kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
 
@@ -2151,20 +2610,108 @@ impl Compiler {
         self.switch_to_block(else_block);
         self.compile_statements(orelse)?;
 
+        // Pop the FinallyTry fblock before jumping to finally
         if !finalbody.is_empty() {
-            emit!(self, Instruction::PopBlock); // pop finally block
-
-            // We enter the finallyhandler block, without return / exception.
-            emit!(self, Instruction::EnterFinally);
+            // No PopBlock/EnterFinally emit - exception table handles this
+            self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        // finally:
+        // Snapshot sub_tables before first finally compilation (for double compilation issue)
+        let sub_tables_snapshot = if !finalbody.is_empty() && finally_except_block.is_some() {
+            Some(
+                self.symbol_table_stack
+                    .last()
+                    .map(|t| t.sub_tables.clone())
+                    .unwrap_or_default(),
+            )
+        } else {
+            None
+        };
+
+        // finally (normal path):
         self.switch_to_block(finally_block);
         if !finalbody.is_empty() {
             self.compile_statements(finalbody)?;
-            emit!(self, Instruction::EndFinally);
+            // Jump to end_block to skip exception path blocks
+            // This prevents fall-through to finally_except_block
+            emit!(self, Instruction::Jump { target: end_block });
+        }
+
+        // finally (exception path)
+        // This is where exceptions go to run finally before reraise
+        // Stack at entry: [lasti, exc] (from exception table with preserve_lasti=true)
+        if let Some(finally_except) = finally_except_block {
+            // Restore sub_tables for exception path compilation
+            if let Some(snapshot) = sub_tables_snapshot
+                && let Some(current_table) = self.symbol_table_stack.last_mut()
+            {
+                current_table.sub_tables = snapshot;
+            }
+
+            self.switch_to_block(finally_except);
+
+            // SETUP_CLEANUP for finally body
+            // Exceptions during finally body need to go to cleanup block
+            // Stack at entry: [lasti, exc] (lasti from exception table, exc pushed)
+            // After PUSH_EXC_INFO: [lasti, prev_exc, exc]
+            // So depth should account for lasti being on stack
+            if let Some(cleanup) = finally_cleanup_block {
+                self.push_fblock_with_handler(
+                    FBlockType::FinallyEnd,
+                    cleanup,
+                    cleanup,
+                    Some(cleanup),
+                    current_depth + 1, // [lasti] on stack before PUSH_EXC_INFO
+                    true,
+                )?;
+            }
+
+            // PUSH_EXC_INFO: [lasti, exc] -> [lasti, prev_exc, exc]
+            // Sets exc as current VM exception, saves prev_exc for restoration
+            emit!(self, Instruction::PushExcInfo);
+
+            // Run finally body
+            self.compile_statements(finalbody)?;
+
+            // RERAISE 0 is emitted BEFORE pop_fblock
+            // This ensures RERAISE goes to cleanup block (FinallyEnd handler)
+            // which then properly restores prev_exc before going to outer handler
+            // RERAISE 0: reraise the exception on TOS
+            // Stack: [lasti, prev_exc, exc] - exception is on top
+            emit!(
+                self,
+                Instruction::Raise {
+                    kind: bytecode::RaiseKind::ReraiseFromStack,
+                }
+            );
+
+            if finally_cleanup_block.is_some() {
+                self.pop_fblock(FBlockType::FinallyEnd);
+            }
         }
 
+        // finally cleanup block
+        // This handles exceptions that occur during the finally body itself
+        // Stack at entry: [lasti, prev_exc, lasti2, exc2] after exception table routing
+        if let Some(cleanup) = finally_cleanup_block {
+            self.switch_to_block(cleanup);
+            // COPY 3: copy the exception from position 3
+            emit!(self, Instruction::CopyItem { index: 3_u32 });
+            // POP_EXCEPT: restore prev_exc as current exception
+            emit!(self, Instruction::PopException);
+            // RERAISE 1: reraise with lasti from stack
+            emit!(
+                self,
+                Instruction::Raise {
+                    kind: bytecode::RaiseKind::ReraiseFromStack,
+                }
+            );
+        }
+
+        // End block - continuation point after try-finally
+        // Normal execution continues here after the finally block
+        self.switch_to_block(end_block);
+
         Ok(())
     }
 
@@ -2175,47 +2722,58 @@ impl Compiler {
         orelse: &[Stmt],
         finalbody: &[Stmt],
     ) -> CompileResult<()> {
-        // Simplified except* implementation using PrepReraiseStar intrinsic
-        // Stack layout during handler processing: [orig, list, rest]
+        // compiler_try_star_except
+        // Stack layout during handler processing: [prev_exc, orig, list, rest]
         let handler_block = self.new_block();
         let finally_block = self.new_block();
         let else_block = self.new_block();
         let end_block = self.new_block();
         let reraise_star_block = self.new_block();
         let reraise_block = self.new_block();
+        let _cleanup_block = self.new_block();
+
+        // Calculate the stack depth at this point (for exception table)
+        let current_depth = self.handler_stack_depth();
 
+        // Push fblock with handler info for exception table generation
         if !finalbody.is_empty() {
-            emit!(
-                self,
-                Instruction::SetupFinally {
-                    handler: finally_block,
-                }
-            );
+            // No SetupFinally emit - exception table handles this
+            self.push_fblock_with_handler(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                Some(finally_block),
+                current_depth, // stack depth for exception handler
+                true,          // preserve lasti for finally
+            )?;
         }
 
-        emit!(
-            self,
-            Instruction::SetupExcept {
-                handler: handler_block,
-            }
-        );
+        // SETUP_FINALLY for try body
+        // Push fblock with handler info for exception table generation
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept,
+            handler_block,
+            handler_block,
+            Some(handler_block),
+            current_depth, // stack depth for exception handler
+            false,         // no lasti for except
+        )?;
         self.compile_statements(body)?;
-        emit!(self, Instruction::PopBlock);
+        self.pop_fblock(FBlockType::TryExcept);
         emit!(self, Instruction::Jump { target: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
-        // Stack: [exc]
+        // Stack: [exc] (from exception table)
 
-        // Create list for tracking exception results and copy orig
-        emit!(self, Instruction::BuildList { size: 0 });
-        // Stack: [exc, []]
-        // CopyItem is 1-indexed: CopyItem(1)=TOS, CopyItem(2)=second from top
-        // With stack [exc, []], CopyItem(2) copies exc
-        emit!(self, Instruction::CopyItem { index: 2 });
-        // Stack: [exc, [], exc_copy]
+        // PUSH_EXC_INFO
+        emit!(self, Instruction::PushExcInfo);
+        // Stack: [prev_exc, exc]
 
-        // Now stack is: [orig, list, rest]
+        // Push EXCEPTION_GROUP_HANDLER fblock
+        let eg_dummy1 = self.new_block();
+        let eg_dummy2 = self.new_block();
+        self.push_fblock(FBlockType::ExceptionGroupHandler, eg_dummy1, eg_dummy2)?;
 
         let n = handlers.len();
         for (i, handler) in handlers.iter().enumerate() {
@@ -2226,6 +2784,17 @@ impl Compiler {
             let no_match_block = self.new_block();
             let next_block = self.new_block();
 
+            // first handler creates list and copies exc
+            if i == 0 {
+                // ADDOP_I(c, loc, BUILD_LIST, 0);
+                emit!(self, Instruction::BuildList { size: 0 });
+                // Stack: [prev_exc, exc, []]
+                // ADDOP_I(c, loc, COPY, 2);
+                emit!(self, Instruction::CopyItem { index: 2 });
+                // Stack: [prev_exc, exc, [], exc_copy]
+                // Now stack is: [prev_exc, orig, list, rest]
+            }
+
             // Compile exception type
             if let Some(exc_type) = type_ {
                 // Check for unparenthesized tuple
@@ -2243,13 +2812,14 @@ impl Compiler {
                     "except* must specify an exception type".to_owned(),
                 )));
             }
-            // Stack: [orig, list, rest, type]
+            // Stack: [prev_exc, orig, list, rest, type]
 
+            // ADDOP(c, loc, CHECK_EG_MATCH);
             emit!(self, Instruction::CheckEgMatch);
-            // Stack: [orig, list, new_rest, match]
+            // Stack: [prev_exc, orig, list, new_rest, match]
 
-            // Check if match is not None (use identity check, not truthiness)
-            // CopyItem is 1-indexed: CopyItem(1) = TOS, CopyItem(2) = second from top
+            // ADDOP_I(c, loc, COPY, 1);
+            // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
             emit!(self, Instruction::CopyItem { index: 1 });
             self.emit_load_const(ConstantData::None);
             emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
@@ -2261,42 +2831,39 @@ impl Compiler {
             );
 
             // Handler matched
-            // Stack: [orig, list, new_rest, match]
+            // Stack: [prev_exc, orig, list, new_rest, match]
             let handler_except_block = self.new_block();
-            let handler_done_block = self.new_block();
 
-            // Set matched exception as current exception for bare 'raise'
+            // Set matched exception as current exception (for __context__ in handler body)
+            // This ensures that exceptions raised in the handler get the matched part
+            // as their __context__, not the original full exception group
             emit!(self, Instruction::SetExcInfo);
 
-            // Store match to name if provided
+            // Store match to name or pop
             if let Some(alias) = name {
-                // CopyItem(1) copies TOS (match)
-                emit!(self, Instruction::CopyItem { index: 1 });
                 self.store_name(alias.as_str())?;
+            } else {
+                emit!(self, Instruction::PopTop); // pop match
             }
-            // Stack: [orig, list, new_rest, match]
+            // Stack: [prev_exc, orig, list, new_rest]
 
-            // Setup exception handler to catch 'raise' in handler body
-            emit!(
-                self,
-                Instruction::SetupExcept {
-                    handler: handler_except_block,
-                }
-            );
-
-            // Push fblock to disallow break/continue/return in except* handler
-            self.push_fblock(
-                FBlockType::ExceptionGroupHandler,
-                handler_done_block,
+            // HANDLER_CLEANUP fblock for handler body
+            // Stack depth: prev_exc(1) + orig(1) + list(1) + new_rest(1) = 4
+            let eg_handler_depth = self.handler_stack_depth() + 4;
+            self.push_fblock_with_handler(
+                FBlockType::HandlerCleanup,
+                next_block,
                 end_block,
+                Some(handler_except_block),
+                eg_handler_depth,
+                true, // preserve lasti
             )?;
 
             // Execute handler body
             self.compile_statements(body)?;
 
-            // Handler body completed normally (didn't raise)
-            self.pop_fblock(FBlockType::ExceptionGroupHandler);
-            emit!(self, Instruction::PopBlock);
+            // Handler body completed normally
+            self.pop_fblock(FBlockType::HandlerCleanup);
 
             // Cleanup name binding
             if let Some(alias) = name {
@@ -2305,27 +2872,13 @@ impl Compiler {
                 self.compile_name(alias.as_str(), NameUsage::Delete)?;
             }
 
-            // Stack: [orig, list, new_rest, match]
-            // Pop match (handler consumed it)
-            emit!(self, Instruction::PopTop);
-            // Stack: [orig, list, new_rest]
-
-            // Append None to list (exception was consumed, not reraised)
-            self.emit_load_const(ConstantData::None);
-            // Stack: [orig, list, new_rest, None]
-            emit!(self, Instruction::ListAppend { i: 1 });
-            // Stack: [orig, list, new_rest]
-
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: handler_done_block
-                }
-            );
+            // Jump to next handler
+            emit!(self, Instruction::Jump { target: next_block });
 
-            // Handler raised an exception (bare 'raise' or other)
+            // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
-            // Stack: [orig, list, new_rest, match, raised_exc]
+            // Stack: [prev_exc, orig, list, new_rest, lasti, raised_exc]
+            // (lasti is pushed because push_lasti=true in HANDLER_CLEANUP fblock)
 
             // Cleanup name binding
             if let Some(alias) = name {
@@ -2334,37 +2887,42 @@ impl Compiler {
                 self.compile_name(alias.as_str(), NameUsage::Delete)?;
             }
 
-            // Append raised_exc to list (the actual exception that was raised)
-            // Stack: [orig, list, new_rest, match, raised_exc]
-            // ListAppend(2): pop raised_exc, then append to list at stack[4-2-1]=stack[1]
+            // LIST_APPEND(3) - append raised_exc to list
+            // Stack: [prev_exc, orig, list, new_rest, lasti, raised_exc]
+            // After pop: [prev_exc, orig, list, new_rest, lasti] (len=5)
+            // nth_value(i) = stack[len - i - 1], we need stack[2] = list
+            // stack[5 - i - 1] = 2 -> i = 2
             emit!(self, Instruction::ListAppend { i: 2 });
-            // Stack: [orig, list, new_rest, match]
+            // Stack: [prev_exc, orig, list, new_rest, lasti]
 
-            // Pop match (no longer needed)
+            // POP_TOP - pop lasti
             emit!(self, Instruction::PopTop);
-            // Stack: [orig, list, new_rest]
-
-            self.switch_to_block(handler_done_block);
-            // Stack: [orig, list, new_rest]
+            // Stack: [prev_exc, orig, list, new_rest]
 
+            // JUMP except_with_error
+            // We directly JUMP to next_block since no_match_block falls through to it
             emit!(self, Instruction::Jump { target: next_block });
 
-            // No match - pop match (None), keep rest unchanged
+            // No match - pop match (None)
             self.switch_to_block(no_match_block);
             emit!(self, Instruction::PopTop); // pop match (None)
-            // Stack: [orig, list, new_rest]
+            // Stack: [prev_exc, orig, list, new_rest]
+            // Falls through to next_block
 
+            // except_with_error label
+            // All paths merge here at next_block
             self.switch_to_block(next_block);
-            // Stack: [orig, list, rest] (rest may have been updated)
+            // Stack: [prev_exc, orig, list, rest]
 
-            // After last handler, append remaining rest to list
+            // After last handler, append rest to list
             if i == n - 1 {
-                // Stack: [orig, list, rest]
-                // ListAppend(i) pops TOS, then accesses stack[len - i - 1]
-                // After pop, stack is [orig, list], len=2
-                // We want list at index 1, so 2 - i - 1 = 1, i = 0
+                // Stack: [prev_exc, orig, list, rest]
+                // ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1);
+                // PEEK(1) = stack[len-1] after pop
+                // RustPython nth_value(i) = stack[len-i-1] after pop
+                // For LIST_APPEND 1: stack[len-1] = stack[len-i-1] -> i = 0
                 emit!(self, Instruction::ListAppend { i: 0 });
-                // Stack: [orig, list]
+                // Stack: [prev_exc, orig, list]
                 emit!(
                     self,
                     Instruction::Jump {
@@ -2374,19 +2932,28 @@ impl Compiler {
             }
         }
 
+        // Pop EXCEPTION_GROUP_HANDLER fblock
+        self.pop_fblock(FBlockType::ExceptionGroupHandler);
+
         // Reraise star block
         self.switch_to_block(reraise_star_block);
-        // Stack: [orig, list]
+        // Stack: [prev_exc, orig, list]
+
+        // CALL_INTRINSIC_2 PREP_RERAISE_STAR
+        // Takes 2 args (orig, list) and produces result
         emit!(
             self,
             Instruction::CallIntrinsic2 {
                 func: bytecode::IntrinsicFunction2::PrepReraiseStar
             }
         );
-        // Stack: [result] (exception to reraise or None)
+        // Stack: [prev_exc, result]
 
-        // Check if result is not None (use identity check, not truthiness)
+        // COPY 1
         emit!(self, Instruction::CopyItem { index: 1 });
+        // Stack: [prev_exc, result, result]
+
+        // POP_JUMP_IF_NOT_NONE reraise
         self.emit_load_const(ConstantData::None);
         emit!(self, Instruction::IsOp(bytecode::Invert::Yes)); // is not None?
         emit!(
@@ -2395,37 +2962,61 @@ impl Compiler {
                 target: reraise_block
             }
         );
+        // Stack: [prev_exc, result]
 
         // Nothing to reraise
+        // POP_TOP - pop result (None)
         emit!(self, Instruction::PopTop);
+        // Stack: [prev_exc]
+
+        // POP_BLOCK - no-op for us with exception tables (fblocks handle this)
+        // POP_EXCEPT - restore previous exception context
         emit!(self, Instruction::PopException);
+        // Stack: []
 
         if !finalbody.is_empty() {
-            emit!(self, Instruction::PopBlock);
-            emit!(self, Instruction::EnterFinally);
+            self.pop_fblock(FBlockType::FinallyTry);
         }
 
         emit!(self, Instruction::Jump { target: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
-        // Don't call PopException before Raise - it truncates the stack and removes the result.
-        // When Raise is executed, the exception propagates through unwind_blocks which
-        // will properly handle the ExceptHandler block.
-        emit!(
-            self,
-            Instruction::Raise {
-                kind: bytecode::RaiseKind::Raise
-            }
-        );
+        // Stack: [prev_exc, result]
+
+        // POP_BLOCK - no-op for us
+        // SWAP 2
+        emit!(self, Instruction::Swap { index: 2 });
+        // Stack: [result, prev_exc]
+
+        // POP_EXCEPT
+        emit!(self, Instruction::PopException);
+        // Stack: [result]
+
+        // RERAISE 0
+        emit!(self, Instruction::Reraise { depth: 0 });
 
         // try-else path
+        // NOTE: When we reach here in compilation, the nothing-to-reraise path above
+        // has already popped FinallyTry. But else_block is a different execution path
+        // that branches from try body success (where FinallyTry is still active).
+        // We need to re-push FinallyTry to reflect the correct fblock state for else path.
+        if !finalbody.is_empty() {
+            self.push_fblock_with_handler(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                Some(finally_block),
+                current_depth,
+                true,
+            )?;
+        }
         self.switch_to_block(else_block);
         self.compile_statements(orelse)?;
 
         if !finalbody.is_empty() {
-            emit!(self, Instruction::PopBlock);
-            emit!(self, Instruction::EnterFinally);
+            // Pop the FinallyTry fblock we just pushed for the else path
+            self.pop_fblock(FBlockType::FinallyTry);
         }
 
         emit!(self, Instruction::Jump { target: end_block });
@@ -2434,7 +3025,7 @@ impl Compiler {
         if !finalbody.is_empty() {
             self.switch_to_block(finally_block);
             self.compile_statements(finalbody)?;
-            emit!(self, Instruction::EndFinally);
+            // No EndFinally emit - exception table handles this
         }
 
         Ok(())
@@ -2527,6 +3118,8 @@ impl Compiler {
             } else {
                 FunctionContext::Function
             },
+            // A function starts a new async scope only if it's async
+            in_async_scope: is_async,
         };
 
         // Set qualname
@@ -2863,7 +3456,6 @@ impl Compiler {
 
         // Set closure if needed
         if has_freevars {
-            // Closure tuple is already on stack
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
@@ -2874,7 +3466,6 @@ impl Compiler {
 
         // Set annotations if present
         if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
-            // Annotations dict is already on stack
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
@@ -2885,7 +3476,6 @@ impl Compiler {
 
         // Set kwdefaults if present
         if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
-            // kwdefaults dict is already on stack
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
@@ -2896,7 +3486,6 @@ impl Compiler {
 
         // Set defaults if present
         if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
-            // defaults tuple is already on stack
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
@@ -2907,7 +3496,6 @@ impl Compiler {
 
         // Set type_params if present
         if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
-            // type_params tuple is already on stack
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
@@ -3089,6 +3677,7 @@ impl Compiler {
             func: FunctionContext::NoFunction,
             in_class: true,
             loop_data: None,
+            in_async_scope: false,
         };
         let class_code = self.compile_class_body(name, body, type_params, firstlineno)?;
         self.ctx = prev_ctx;
@@ -3195,7 +3784,7 @@ impl Compiler {
         let else_block = self.new_block();
         let after_block = self.new_block();
 
-        emit!(self, Instruction::SetupLoop);
+        // Note: SetupLoop is no longer emitted (break/continue use direct jumps)
         self.switch_to_block(while_block);
 
         // Push fblock for while loop
@@ -3216,7 +3805,7 @@ impl Compiler {
 
         // Pop fblock
         self.pop_fblock(FBlockType::WhileLoop);
-        emit!(self, Instruction::PopBlock);
+        // Note: PopBlock is no longer emitted for loops
         self.compile_statements(orelse)?;
         self.switch_to_block(after_block);
         Ok(())
@@ -3228,45 +3817,89 @@ impl Compiler {
         body: &[Stmt],
         is_async: bool,
     ) -> CompileResult<()> {
+        // Python 3.12+ style with statement:
+        //
+        // BEFORE_WITH          # TOS: ctx_mgr -> [__exit__, __enter__ result]
+        // L1: STORE_NAME f     # exception table: L1 to L2 -> L3 [1] lasti
+        // L2: ... body ...
+        //     LOAD_CONST None  # normal exit
+        //     LOAD_CONST None
+        //     LOAD_CONST None
+        //     CALL 2           # __exit__(None, None, None)
+        //     POP_TOP
+        //     JUMP after
+        // L3: PUSH_EXC_INFO    # exception handler
+        //     WITH_EXCEPT_START # call __exit__(type, value, tb), push result
+        //     TO_BOOL
+        //     POP_JUMP_IF_TRUE suppress
+        //     RERAISE 2
+        // suppress:
+        //     POP_TOP          # pop exit result
+        // L5: POP_EXCEPT
+        //     POP_TOP          # pop __exit__
+        //     POP_TOP          # pop prev_exc (or lasti depending on layout)
+        //     JUMP after
+        // L6: COPY 3           # cleanup handler for reraise
+        //     POP_EXCEPT
+        //     RERAISE 1
+        // after: ...
+
         let with_range = self.current_source_range;
 
         let Some((item, items)) = items.split_first() else {
             return Err(self.error(CodegenErrorType::EmptyWithItems));
         };
 
-        let final_block = {
-            let final_block = self.new_block();
-            self.compile_expression(&item.context_expr)?;
+        let exc_handler_block = self.new_block();
+        let after_block = self.new_block();
 
-            self.set_source_range(with_range);
+        // Compile context expression and BEFORE_WITH
+        self.compile_expression(&item.context_expr)?;
+        self.set_source_range(with_range);
+
+        if is_async {
+            if self.ctx.func != FunctionContext::AsyncFunction {
+                return Err(self.error(CodegenErrorType::InvalidAsyncWith));
+            }
+            emit!(self, Instruction::BeforeAsyncWith);
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+        } else {
+            emit!(self, Instruction::BeforeWith);
+        }
+
+        // Stack: [..., __exit__, enter_result]
+        // Push fblock for exception table - handler goes to exc_handler_block
+        // preserve_lasti=true for with statements
+        // Use handler_stack_depth() to include all items on stack (for loops, etc.)
+        let with_depth = self.handler_stack_depth() + 1; // +1 for current __exit__
+        self.push_fblock_with_handler(
             if is_async {
-                emit!(self, Instruction::BeforeAsyncWith);
-                emit!(self, Instruction::GetAwaitable);
-                self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                emit!(
-                    self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
-                );
-                emit!(self, Instruction::SetupAsyncWith { end: final_block });
+                FBlockType::AsyncWith
             } else {
-                emit!(self, Instruction::SetupWith { end: final_block });
+                FBlockType::With
+            },
+            exc_handler_block, // block start (will become exit target after store)
+            after_block,
+            Some(exc_handler_block),
+            with_depth,
+            true, // preserve_lasti=true
+        )?;
+
+        // Store or pop the enter result
+        match &item.optional_vars {
+            Some(var) => {
+                self.set_source_range(var.range());
+                self.compile_store(var)?;
             }
-
-            match &item.optional_vars {
-                Some(var) => {
-                    self.set_source_range(var.range());
-                    self.compile_store(var)?;
-                }
-                None => {
-                    emit!(self, Instruction::PopTop);
-                }
+            None => {
+                emit!(self, Instruction::PopTop);
             }
-            final_block
-        };
+        }
+        // Stack: [..., __exit__]
 
+        // Compile body or nested with
         if items.is_empty() {
             if body.is_empty() {
                 return Err(self.error(CodegenErrorType::EmptyWithBody));
@@ -3277,29 +3910,123 @@ impl Compiler {
             self.compile_with(items, body, is_async)?;
         }
 
-        // sort of "stack up" the layers of with blocks:
-        // with a, b: body -> start_with(a) start_with(b) body() end_with(b) end_with(a)
-        self.set_source_range(with_range);
-        emit!(self, Instruction::PopBlock);
+        // Pop fblock before normal exit
+        self.pop_fblock(if is_async {
+            FBlockType::AsyncWith
+        } else {
+            FBlockType::With
+        });
 
-        emit!(self, Instruction::EnterFinally);
+        // ===== Normal exit path =====
+        // Stack: [..., __exit__]
+        // Call __exit__(None, None, None)
+        self.set_source_range(with_range);
+        self.emit_load_const(ConstantData::None);
+        self.emit_load_const(ConstantData::None);
+        self.emit_load_const(ConstantData::None);
+        emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+        if is_async {
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+        }
+        emit!(self, Instruction::PopTop); // Pop __exit__ result
+        emit!(
+            self,
+            Instruction::Jump {
+                target: after_block
+            }
+        );
 
-        self.switch_to_block(final_block);
-        emit!(self, Instruction::WithCleanupStart);
+        // ===== Exception handler path =====
+        // Stack at entry (after unwind): [..., __exit__, lasti, exc]
+        // PUSH_EXC_INFO -> [..., __exit__, lasti, prev_exc, exc]
+        self.switch_to_block(exc_handler_block);
+
+        // Create blocks for exception handling
+        let cleanup_block = self.new_block();
+        let suppress_block = self.new_block();
+
+        // Push nested fblock for cleanup handler
+        // Stack at exc_handler_block entry: [..., __exit__, lasti, exc]
+        // After PUSH_EXC_INFO: [..., __exit__, lasti, prev_exc, exc]
+        // If exception in __exit__, cleanup handler entry: [..., __exit__, lasti, prev_exc, lasti2, exc2]
+        // cleanup_depth should be: with_depth + 2 (lasti + prev_exc)
+        let cleanup_depth = with_depth + 2;
+        self.push_fblock_with_handler(
+            FBlockType::ExceptionHandler,
+            exc_handler_block,
+            after_block,
+            Some(cleanup_block),
+            cleanup_depth,
+            true, // preserve_lasti=true
+        )?;
+
+        // PUSH_EXC_INFO: [exc] -> [prev_exc, exc]
+        emit!(self, Instruction::PushExcInfo);
+
+        // WITH_EXCEPT_START: call __exit__(type, value, tb)
+        // Stack: [..., __exit__, lasti, prev_exc, exc]
+        // __exit__ is at TOS-3, call with exception info
+        emit!(self, Instruction::WithExceptStart);
 
         if is_async {
             emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
-            emit!(
-                self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
-                }
-            );
+            self.compile_yield_from_sequence(true)?;
         }
 
-        emit!(self, Instruction::WithCleanupFinish);
+        // TO_BOOL + POP_JUMP_IF_TRUE: check if exception is suppressed
+        emit!(self, Instruction::ToBool);
+        emit!(
+            self,
+            Instruction::PopJumpIfTrue {
+                target: suppress_block
+            }
+        );
+
+        // Pop the nested fblock BEFORE RERAISE so that RERAISE's exception
+        // handler points to the outer handler (try-except), not cleanup_block.
+        // This is critical: when RERAISE propagates the exception, the exception
+        // table should route it to the outer try-except, not back to cleanup.
+        self.pop_fblock(FBlockType::ExceptionHandler);
+
+        // Not suppressed: RERAISE 2
+        emit!(self, Instruction::Reraise { depth: 2 });
+
+        // ===== Suppress block =====
+        // Exception was suppressed, clean up stack
+        // Stack: [..., __exit__, lasti, prev_exc, exc, True]
+        // Need to pop: True, exc, prev_exc, __exit__
+        self.switch_to_block(suppress_block);
+        emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
+        emit!(self, Instruction::PopException); // pop exc and restore prev_exc
+        emit!(self, Instruction::PopTop); // pop __exit__
+        emit!(self, Instruction::PopTop); // pop lasti
+        emit!(
+            self,
+            Instruction::Jump {
+                target: after_block
+            }
+        );
+
+        // ===== Cleanup block (for nested exception during __exit__) =====
+        // Stack: [..., __exit__, lasti, prev_exc, lasti2, exc2]
+        // COPY 3: copy prev_exc to TOS
+        // POP_EXCEPT: restore exception state
+        // RERAISE 1: re-raise with lasti
+        //
+        // NOTE: We DON'T clear the fblock stack here because we want
+        // outer exception handlers (e.g., try-except wrapping this with statement)
+        // to be in the exception table for these instructions.
+        // If we cleared fblock, exceptions here would propagate uncaught.
+        self.switch_to_block(cleanup_block);
+        emit!(self, Instruction::CopyItem { index: 3 });
+        emit!(self, Instruction::PopException);
+        emit!(self, Instruction::Reraise { depth: 1 });
+
+        // ===== After block =====
+        self.switch_to_block(after_block);
 
         Ok(())
     }
@@ -3317,36 +4044,36 @@ impl Compiler {
         let else_block = self.new_block();
         let after_block = self.new_block();
 
-        emit!(self, Instruction::SetupLoop);
-
         // The thing iterated:
         self.compile_expression(iter)?;
 
         if is_async {
+            if self.ctx.func != FunctionContext::AsyncFunction {
+                return Err(self.error(CodegenErrorType::InvalidAsyncFor));
+            }
             emit!(self, Instruction::GetAIter);
 
             self.switch_to_block(for_block);
 
-            // Push fblock for async for loop
-            self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
+            // Push fblock for async for loop with exception handler info
+            // Note: SetupExcept is no longer emitted (exception table handles StopAsyncIteration)
+            // Stack at this point: [..., async_iterator]
+            // We need handler_stack_depth() + 1 to keep parent items + async_iterator on stack when exception occurs
+            let async_for_depth = self.handler_stack_depth() + 1;
+            self.push_fblock_with_handler(
+                FBlockType::ForLoop,
+                for_block,
+                after_block,
+                Some(else_block), // Handler for StopAsyncIteration
+                async_for_depth,  // stack depth: keep async_iterator and parent items
+                false,            // no lasti needed
+            )?;
 
-            emit!(
-                self,
-                Instruction::SetupExcept {
-                    handler: else_block,
-                }
-            );
             emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
-            emit!(
-                self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
-                }
-            );
+            self.compile_yield_from_sequence(true)?;
             self.compile_store(target)?;
-            emit!(self, Instruction::PopBlock);
+            // Note: PopBlock is no longer emitted (exception table handles this)
         } else {
             // Retrieve Iterator
             emit!(self, Instruction::GetIter);
@@ -3375,7 +4102,6 @@ impl Compiler {
         if is_async {
             emit!(self, Instruction::EndAsyncFor);
         }
-        emit!(self, Instruction::PopBlock);
         self.compile_statements(orelse)?;
 
         self.switch_to_block(after_block);
@@ -3961,7 +4687,7 @@ impl Compiler {
         }
 
         // After processing subpatterns, adjust on_top
-        // CPython: "Whatever happens next should consume the tuple of keys and the subject"
+        // "Whatever happens next should consume the tuple of keys and the subject"
         // Stack currently: [subject, keys_tuple, ...any captured values...]
         pc.on_top -= 2;
 
@@ -4465,7 +5191,6 @@ impl Compiler {
             // Special handling for starred annotations (*Ts -> Unpack[Ts])
             let result = match annotation {
                 Expr::Starred(ExprStarred { value, .. }) => {
-                    // Following CPython's approach:
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
@@ -4828,6 +5553,80 @@ impl Compiler {
         Ok(())
     }
 
+    /// Compile the yield-from/await sequence using SEND/END_SEND/CLEANUP_THROW.
+    /// compiler_add_yield_from
+    /// This generates:
+    ///   send:
+    ///     SEND exit
+    ///     SETUP_FINALLY fail (via exception table)
+    ///     YIELD_VALUE 1
+    ///     POP_BLOCK (implicit)
+    ///     RESUME
+    ///     JUMP send
+    ///   fail:
+    ///     CLEANUP_THROW
+    ///   exit:
+    ///     END_SEND
+    fn compile_yield_from_sequence(&mut self, is_await: bool) -> CompileResult<()> {
+        let send_block = self.new_block();
+        let fail_block = self.new_block();
+        let exit_block = self.new_block();
+
+        // send:
+        self.switch_to_block(send_block);
+        emit!(self, Instruction::Send { target: exit_block });
+
+        // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
+        // Stack at this point: [receiver, yielded_value]
+        // handler_depth = base + 2 (receiver + yielded_value)
+        let handler_depth = self.handler_stack_depth() + 2;
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept, // Use TryExcept for exception handler
+            send_block,
+            exit_block,
+            Some(fail_block),
+            handler_depth,
+            false, // no lasti needed
+        )?;
+
+        // YIELD_VALUE with arg=1 (yield-from/await mode - not wrapped for async gen)
+        emit!(self, Instruction::YieldValue { arg: 1 });
+
+        // POP_BLOCK (implicit - pop fblock before RESUME)
+        self.pop_fblock(FBlockType::TryExcept);
+
+        // RESUME
+        emit!(
+            self,
+            Instruction::Resume {
+                arg: if is_await {
+                    bytecode::ResumeType::AfterAwait as u32
+                } else {
+                    bytecode::ResumeType::AfterYieldFrom as u32
+                }
+            }
+        );
+
+        // JUMP_NO_INTERRUPT send (regular JUMP in RustPython)
+        emit!(self, Instruction::Jump { target: send_block });
+
+        // fail: CLEANUP_THROW
+        // Stack when exception: [receiver, yielded_value, exc]
+        // CLEANUP_THROW: [sub_iter, last_sent_val, exc] -> [None, value]
+        // After: stack is [None, value], fall through to exit
+        self.switch_to_block(fail_block);
+        emit!(self, Instruction::CleanupThrow);
+        // Fall through to exit block
+
+        // exit: END_SEND
+        // Stack: [receiver, value] (from SEND) or [None, value] (from CLEANUP_THROW)
+        // END_SEND: [receiver/None, value] -> [value]
+        self.switch_to_block(exit_block);
+        emit!(self, Instruction::EndSend);
+
+        Ok(())
+    }
+
     fn compile_expression(&mut self, expression: &Expr) -> CompileResult<()> {
         use ruff_python_ast::*;
         trace!("Compiling {expression:?}");
@@ -4923,7 +5722,8 @@ impl Compiler {
                     Some(expression) => self.compile_expression(expression)?,
                     Option::None => self.emit_load_const(ConstantData::None),
                 };
-                emit!(self, Instruction::YieldValue);
+                // arg=0: direct yield (wrapped for async generators)
+                emit!(self, Instruction::YieldValue { arg: 0 });
                 emit!(
                     self,
                     Instruction::Resume {
@@ -4938,13 +5738,7 @@ impl Compiler {
                 self.compile_expression(value)?;
                 emit!(self, Instruction::GetAwaitable);
                 self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                emit!(
-                    self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
-                );
+                self.compile_yield_from_sequence(true)?;
             }
             Expr::YieldFrom(ExprYieldFrom { value, .. }) => {
                 match self.ctx.func {
@@ -4958,15 +5752,9 @@ impl Compiler {
                 }
                 self.mark_generator();
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetIter);
+                emit!(self, Instruction::GetYieldFromIter);
                 self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                emit!(
-                    self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterYieldFrom as u32
-                    }
-                );
+                self.compile_yield_from_sequence(false)?;
             }
             Expr::Name(ExprName { id, .. }) => self.load_name(id.as_str())?,
             Expr::Lambda(ExprLambda {
@@ -5036,6 +5824,8 @@ impl Compiler {
                     loop_data: Option::None,
                     in_class: prev_ctx.in_class,
                     func: FunctionContext::Function,
+                    // Lambda is never async, so new scope is not async
+                    in_async_scope: false,
                 };
 
                 self.current_code_info()
@@ -5072,7 +5862,7 @@ impl Compiler {
                         Ok(())
                     },
                     ComprehensionType::List,
-                    Self::contains_await(elt),
+                    Self::contains_await(elt) || Self::generators_contain_await(generators),
                 )?;
             }
             Expr::SetComp(ExprSetComp {
@@ -5095,7 +5885,7 @@ impl Compiler {
                         Ok(())
                     },
                     ComprehensionType::Set,
-                    Self::contains_await(elt),
+                    Self::contains_await(elt) || Self::generators_contain_await(generators),
                 )?;
             }
             Expr::DictComp(ExprDictComp {
@@ -5125,20 +5915,31 @@ impl Compiler {
                         Ok(())
                     },
                     ComprehensionType::Dict,
-                    Self::contains_await(key) || Self::contains_await(value),
+                    Self::contains_await(key)
+                        || Self::contains_await(value)
+                        || Self::generators_contain_await(generators),
                 )?;
             }
             Expr::Generator(ExprGenerator {
                 elt, generators, ..
             }) => {
+                // Check if element or generators contain async content
+                // This makes the generator expression into an async generator
+                let element_contains_await =
+                    Self::contains_await(elt) || Self::generators_contain_await(generators);
                 self.compile_comprehension(
                     "<genexpr>",
                     None,
                     generators,
                     &|compiler| {
+                        // Compile the element expression
+                        // Note: if element is an async comprehension, compile_expression
+                        // already handles awaiting it, so we don't need to await again here
                         compiler.compile_comprehension_element(elt)?;
+
                         compiler.mark_generator();
-                        emit!(compiler, Instruction::YieldValue);
+                        // arg=0: direct yield (wrapped for async generators)
+                        emit!(compiler, Instruction::YieldValue { arg: 0 });
                         emit!(
                             compiler,
                             Instruction::Resume {
@@ -5150,7 +5951,7 @@ impl Compiler {
                         Ok(())
                     },
                     ComprehensionType::Generator,
-                    Self::contains_await(elt),
+                    element_contains_await,
                 )?;
             }
             Expr::Starred(ExprStarred { value, .. }) => {
@@ -5452,30 +6253,47 @@ impl Compiler {
         let prev_ctx = self.ctx;
         let has_an_async_gen = generators.iter().any(|g| g.is_async);
 
-        // async comprehensions are allowed in various contexts:
-        // - list/set/dict comprehensions in async functions
-        // - always for generator expressions
-        // Note: generators have to be treated specially since their async version is a fundamentally
-        // different type (aiter vs iter) instead of just an awaitable.
-
-        // for if it actually is async, we check if any generator is async or if the element contains await
+        // Check for async comprehension outside async function (list/set/dict only, not generator expressions)
+        // Use in_async_scope to allow nested async comprehensions inside an async function
+        if comprehension_type != ComprehensionType::Generator
+            && (has_an_async_gen || element_contains_await)
+            && !prev_ctx.in_async_scope
+        {
+            return Err(self.error(CodegenErrorType::InvalidAsyncComprehension));
+        }
 
-        // if the element expression contains await, but the context doesn't allow for async,
-        // then we continue on here with is_async=false and will produce a syntax once the await is hit
+        // Check if this comprehension should be inlined (PEP 709)
+        let is_inlined = self.is_inlined_comprehension_context(comprehension_type);
 
+        // async comprehensions are allowed in various contexts:
+        // - list/set/dict comprehensions in async functions (or nested within)
+        // - always for generator expressions
         let is_async_list_set_dict_comprehension = comprehension_type
             != ComprehensionType::Generator
-            && (has_an_async_gen || element_contains_await) // does it have to be async? (uses await or async for)
-            && prev_ctx.func == FunctionContext::AsyncFunction; // is it allowed to be async? (in an async function)
+            && (has_an_async_gen || element_contains_await)
+            && prev_ctx.in_async_scope;
 
         let is_async_generator_comprehension = comprehension_type == ComprehensionType::Generator
             && (has_an_async_gen || element_contains_await);
 
-        // since one is for generators, and one for not generators, they should never both be true
         debug_assert!(!(is_async_list_set_dict_comprehension && is_async_generator_comprehension));
 
         let is_async = is_async_list_set_dict_comprehension || is_async_generator_comprehension;
 
+        // We must have at least one generator:
+        assert!(!generators.is_empty());
+
+        if is_inlined {
+            // PEP 709: Inlined comprehension - compile inline without new scope
+            return self.compile_inlined_comprehension(
+                init_collection,
+                generators,
+                compile_element,
+                has_an_async_gen,
+            );
+        }
+
+        // Non-inlined path: create a new code object (generator expressions, etc.)
         self.ctx = CompileContext {
             loop_data: None,
             in_class: prev_ctx.in_class,
@@ -5484,11 +6302,11 @@ impl Compiler {
             } else {
                 FunctionContext::Function
             },
+            // Inherit in_async_scope from parent - nested async comprehensions are allowed
+            // if we're anywhere inside an async function
+            in_async_scope: prev_ctx.in_async_scope || is_async,
         };
 
-        // We must have at least one generator:
-        assert!(!generators.is_empty());
-
         let flags = bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED;
         let flags = if is_async {
             flags | bytecode::CodeFlags::IS_COROUTINE
@@ -5518,8 +6336,6 @@ impl Compiler {
             let loop_block = self.new_block();
             let after_block = self.new_block();
 
-            // emit!(self, Instruction::SetupLoop);
-
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
                 emit!(self, Instruction::LoadFast(arg0));
@@ -5535,26 +6351,26 @@ impl Compiler {
                 }
             }
 
-            loop_labels.push((loop_block, after_block));
+            loop_labels.push((loop_block, after_block, generator.is_async));
             self.switch_to_block(loop_block);
             if generator.is_async {
-                emit!(
-                    self,
-                    Instruction::SetupExcept {
-                        handler: after_block,
-                    }
-                );
                 emit!(self, Instruction::GetANext);
+
+                let current_depth = (init_collection.is_some() as u32)
+                    + u32::try_from(loop_labels.len()).unwrap()
+                    + 1;
+                self.push_fblock_with_handler(
+                    FBlockType::AsyncComprehensionGenerator,
+                    loop_block,
+                    after_block,
+                    Some(after_block),
+                    current_depth,
+                    false,
+                )?;
                 self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                emit!(
-                    self,
-                    Instruction::Resume {
-                        arg: bytecode::ResumeType::AfterAwait as u32
-                    }
-                );
+                self.compile_yield_from_sequence(true)?;
                 self.compile_store(&generator.target)?;
-                emit!(self, Instruction::PopBlock);
+                self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
             } else {
                 emit!(
                     self,
@@ -5573,14 +6389,13 @@ impl Compiler {
 
         compile_element(self)?;
 
-        for (loop_block, after_block) in loop_labels.iter().rev().copied() {
-            // Repeat:
+        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
             emit!(self, Instruction::Jump { target: loop_block });
 
-            // End of for loop:
             self.switch_to_block(after_block);
-            if has_an_async_gen {
+            if is_async {
                 emit!(self, Instruction::EndAsyncFor);
+                emit!(self, Instruction::PopTop);
             }
         }
 
@@ -5588,10 +6403,8 @@ impl Compiler {
             self.emit_load_const(ConstantData::None)
         }
 
-        // Return freshly filled list:
         self.emit_return_value();
 
-        // Fetch code for listcomp function:
         let code = self.exit_scope();
 
         self.ctx = prev_ctx;
@@ -5603,7 +6416,8 @@ impl Compiler {
         self.compile_expression(&generators[0].iter)?;
 
         // Get iterator / turn item into an iterator
-        if has_an_async_gen {
+        // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
+        if generators[0].is_async {
             emit!(self, Instruction::GetAIter);
         } else {
             emit!(self, Instruction::GetIter);
@@ -5612,20 +6426,229 @@ impl Compiler {
         // Call just created <listcomp> function:
         emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
         if is_async_list_set_dict_comprehension {
-            // async, but not a generator and not an async for
-            // in this case, we end up with an awaitable
-            // that evaluates to the list/set/dict, so here we add an await
             emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
+            self.compile_yield_from_sequence(true)?;
+        }
+
+        Ok(())
+    }
+
+    /// Collect variable names from an assignment target expression
+    fn collect_target_names(&self, target: &Expr, names: &mut Vec<String>) {
+        match target {
+            Expr::Name(name) => {
+                let name_str = name.id.to_string();
+                if !names.contains(&name_str) {
+                    names.push(name_str);
+                }
+            }
+            Expr::Tuple(tuple) => {
+                for elt in &tuple.elts {
+                    self.collect_target_names(elt, names);
+                }
+            }
+            Expr::List(list) => {
+                for elt in &list.elts {
+                    self.collect_target_names(elt, names);
+                }
+            }
+            Expr::Starred(starred) => {
+                self.collect_target_names(&starred.value, names);
+            }
+            _ => {
+                // Other targets (attribute, subscript) don't bind local names
+            }
+        }
+    }
+
+    /// Compile an inlined comprehension (PEP 709)
+    /// This generates bytecode inline without creating a new code object
+    fn compile_inlined_comprehension(
+        &mut self,
+        init_collection: Option<Instruction>,
+        generators: &[Comprehension],
+        compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
+        _has_an_async_gen: bool,
+    ) -> CompileResult<()> {
+        // PEP 709: Consume the comprehension's sub_table (but we won't use it as a separate scope)
+        // We need to consume it to keep sub_tables in sync with AST traversal order.
+        // The symbols are already merged into parent scope by analyze_symbol_table.
+        let _comp_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table")
+            .sub_tables
+            .remove(0);
+
+        // Collect local variables that need to be saved/restored
+        // These are variables bound in the comprehension (iteration vars from targets)
+        let mut pushed_locals: Vec<String> = Vec::new();
+        for generator in generators {
+            self.collect_target_names(&generator.target, &mut pushed_locals);
+        }
+
+        // Step 1: Compile the outermost iterator
+        self.compile_expression(&generators[0].iter)?;
+        // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
+        if generators[0].is_async {
+            emit!(self, Instruction::GetAIter);
+        } else {
+            emit!(self, Instruction::GetIter);
+        }
+
+        // Step 2: Save local variables that will be shadowed by the comprehension
+        for name in &pushed_locals {
+            let idx = self.varname(name)?;
+            emit!(self, Instruction::LoadFastAndClear(idx));
+        }
+
+        // Step 3: SWAP iterator to TOS (above saved locals)
+        if !pushed_locals.is_empty() {
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                }
+            );
+        }
+
+        // Step 4: Create the collection (list/set/dict)
+        // For generator expressions, init_collection is None
+        if let Some(init_collection) = init_collection {
+            self._emit(init_collection, OpArg(0), BlockIdx::NULL);
+            // SWAP to get iterator on top
+            emit!(self, Instruction::Swap { index: 2 });
+        }
+
+        // Set up exception handler for cleanup on exception
+        let cleanup_block = self.new_block();
+        let end_block = self.new_block();
+
+        if !pushed_locals.is_empty() {
+            // Calculate stack depth for exception handler
+            // Stack: [saved_locals..., collection?, iterator]
+            let depth = self.handler_stack_depth()
+                + u32::try_from(pushed_locals.len()).unwrap()
+                + init_collection.is_some() as u32
+                + 1;
+            self.push_fblock_with_handler(
+                FBlockType::TryExcept,
+                cleanup_block,
+                end_block,
+                Some(cleanup_block),
+                depth,
+                false,
+            )?;
+        }
+
+        // Step 5: Compile the comprehension loop(s)
+        let mut loop_labels = vec![];
+        for (i, generator) in generators.iter().enumerate() {
+            let loop_block = self.new_block();
+            let after_block = self.new_block();
+
+            if i > 0 {
+                // For nested loops, compile the iterator expression
+                self.compile_expression(&generator.iter)?;
+                if generator.is_async {
+                    emit!(self, Instruction::GetAIter);
+                } else {
+                    emit!(self, Instruction::GetIter);
+                }
+            }
+
+            loop_labels.push((loop_block, after_block, generator.is_async));
+            self.switch_to_block(loop_block);
+
+            if generator.is_async {
+                emit!(self, Instruction::GetANext);
+                self.emit_load_const(ConstantData::None);
+                self.compile_yield_from_sequence(true)?;
+                self.compile_store(&generator.target)?;
+            } else {
+                emit!(
+                    self,
+                    Instruction::ForIter {
+                        target: after_block,
+                    }
+                );
+                self.compile_store(&generator.target)?;
+            }
+
+            // Evaluate the if conditions
+            for if_condition in &generator.ifs {
+                self.compile_jump_if(if_condition, false, loop_block)?;
+            }
+        }
+
+        // Step 6: Compile the element expression and append to collection
+        compile_element(self)?;
+
+        // Step 7: Close all loops
+        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
+            emit!(self, Instruction::Jump { target: loop_block });
+            self.switch_to_block(after_block);
+            if is_async {
+                emit!(self, Instruction::EndAsyncFor);
+            }
+            // Pop the iterator
+            emit!(self, Instruction::PopTop);
+        }
+
+        // Step 8: Clean up - restore saved locals
+        if !pushed_locals.is_empty() {
+            self.pop_fblock(FBlockType::TryExcept);
+
+            // Normal path: jump past cleanup
+            emit!(self, Instruction::Jump { target: end_block });
+
+            // Exception cleanup path
+            self.switch_to_block(cleanup_block);
+            // Stack: [saved_locals..., collection, exception]
+            // Swap to get collection out from under exception
+            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::PopTop); // Pop incomplete collection
+
+            // Restore locals
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                }
+            );
+            for name in pushed_locals.iter().rev() {
+                let idx = self.varname(name)?;
+                emit!(self, Instruction::StoreFast(idx));
+            }
+            // Re-raise the exception
+            emit!(
+                self,
+                Instruction::Raise {
+                    kind: bytecode::RaiseKind::ReraiseFromStack
+                }
+            );
+
+            // Normal end path
+            self.switch_to_block(end_block);
+        }
+
+        // SWAP result to TOS (above saved locals)
+        if !pushed_locals.is_empty() {
             emit!(
                 self,
-                Instruction::Resume {
-                    arg: bytecode::ResumeType::AfterAwait as u32
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
         }
 
+        // Restore saved locals
+        for name in pushed_locals.iter().rev() {
+            let idx = self.varname(name)?;
+            emit!(self, Instruction::StoreFast(idx));
+        }
+
         Ok(())
     }
 
@@ -5656,12 +6679,14 @@ impl Compiler {
         let source = self.source_file.to_source_code();
         let location = source.source_location(range.start(), PositionEncoding::Utf8);
         let end_location = source.source_location(range.end(), PositionEncoding::Utf8);
+        let except_handler = self.current_except_handler();
         self.current_block().instructions.push(ir::InstructionInfo {
             instr,
             arg,
             target,
             location,
             end_location,
+            except_handler,
         });
     }
 
@@ -5709,6 +6734,204 @@ impl Compiler {
         self.code_stack.last_mut().expect("no code on stack")
     }
 
+    /// Compile break or continue statement with proper fblock cleanup.
+    /// compiler_break, compiler_continue
+    /// This handles unwinding through With blocks and exception handlers.
+    fn compile_break_continue(
+        &mut self,
+        range: ruff_text_size::TextRange,
+        is_break: bool,
+    ) -> CompileResult<()> {
+        // unwind_fblock_stack
+        // We need to unwind fblocks and compile cleanup code. For FinallyTry blocks,
+        // we need to compile the finally body inline, but we must temporarily pop
+        // the fblock so that nested break/continue in the finally body don't see it.
+
+        // First, find the loop
+        let code = self.current_code_info();
+        let mut loop_idx = None;
+        let mut is_for_loop = false;
+
+        for i in (0..code.fblock.len()).rev() {
+            match code.fblock[i].fb_type {
+                FBlockType::WhileLoop => {
+                    loop_idx = Some(i);
+                    is_for_loop = false;
+                    break;
+                }
+                FBlockType::ForLoop => {
+                    loop_idx = Some(i);
+                    is_for_loop = true;
+                    break;
+                }
+                FBlockType::ExceptionGroupHandler => {
+                    return Err(
+                        self.error_ranged(CodegenErrorType::BreakContinueReturnInExceptStar, range)
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        let Some(loop_idx) = loop_idx else {
+            if is_break {
+                return Err(self.error_ranged(CodegenErrorType::InvalidBreak, range));
+            } else {
+                return Err(self.error_ranged(CodegenErrorType::InvalidContinue, range));
+            }
+        };
+
+        let loop_block = code.fblock[loop_idx].fb_block;
+        let exit_block = code.fblock[loop_idx].fb_exit;
+
+        // Collect the fblocks we need to unwind through, from top down to (but not including) the loop
+        #[derive(Clone)]
+        enum UnwindAction {
+            With {
+                is_async: bool,
+            },
+            HandlerCleanup,
+            FinallyTry {
+                body: Vec<ruff_python_ast::Stmt>,
+                fblock_idx: usize,
+            },
+            FinallyEnd,
+            PopValue, // Pop return value when continue/break cancels a return
+        }
+        let mut unwind_actions = Vec::new();
+
+        {
+            let code = self.current_code_info();
+            for i in (loop_idx + 1..code.fblock.len()).rev() {
+                match code.fblock[i].fb_type {
+                    FBlockType::With => {
+                        unwind_actions.push(UnwindAction::With { is_async: false });
+                    }
+                    FBlockType::AsyncWith => {
+                        unwind_actions.push(UnwindAction::With { is_async: true });
+                    }
+                    FBlockType::HandlerCleanup => {
+                        unwind_actions.push(UnwindAction::HandlerCleanup);
+                    }
+                    FBlockType::FinallyTry => {
+                        // Need to execute finally body before break/continue
+                        if let FBlockDatum::FinallyBody(ref body) = code.fblock[i].fb_datum {
+                            unwind_actions.push(UnwindAction::FinallyTry {
+                                body: body.clone(),
+                                fblock_idx: i,
+                            });
+                        }
+                    }
+                    FBlockType::FinallyEnd => {
+                        // Inside finally block reached via exception - need to pop exception
+                        unwind_actions.push(UnwindAction::FinallyEnd);
+                    }
+                    FBlockType::PopValue => {
+                        // Pop the return value that was saved on stack
+                        unwind_actions.push(UnwindAction::PopValue);
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        // Emit cleanup for each fblock
+        for action in unwind_actions {
+            match action {
+                UnwindAction::With { is_async } => {
+                    // compiler_call_exit_with_nones
+                    self.emit_load_const(ConstantData::None);
+                    self.emit_load_const(ConstantData::None);
+                    self.emit_load_const(ConstantData::None);
+                    emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+
+                    if is_async {
+                        emit!(self, Instruction::GetAwaitable);
+                        self.emit_load_const(ConstantData::None);
+                        self.compile_yield_from_sequence(true)?;
+                    }
+
+                    emit!(self, Instruction::PopTop);
+                }
+                UnwindAction::HandlerCleanup => {
+                    emit!(self, Instruction::PopException);
+                }
+                UnwindAction::FinallyTry { body, fblock_idx } => {
+                    // compile finally body inline
+                    // Temporarily pop the FinallyTry fblock so nested break/continue
+                    // in the finally body won't see it again.
+                    let code = self.current_code_info();
+                    let saved_fblock = code.fblock.remove(fblock_idx);
+
+                    self.compile_statements(&body)?;
+
+                    // Restore the fblock (though this break/continue will jump away,
+                    // this keeps the fblock stack consistent for error checking)
+                    let code = self.current_code_info();
+                    code.fblock.insert(fblock_idx, saved_fblock);
+                }
+                UnwindAction::FinallyEnd => {
+                    // Stack when in FinallyEnd: [..., prev_exc, exc]
+                    // Note: No lasti here - it's only pushed for cleanup handler exceptions
+                    // We need to pop: exc, prev_exc (via PopException)
+                    emit!(self, Instruction::PopTop); // exc
+                    emit!(self, Instruction::PopException); // prev_exc is restored
+                }
+                UnwindAction::PopValue => {
+                    // Pop the return value - continue/break cancels the pending return
+                    emit!(self, Instruction::PopTop);
+                }
+            }
+        }
+
+        // For break in a for loop, pop the iterator
+        if is_break && is_for_loop {
+            emit!(self, Instruction::PopTop);
+        }
+
+        // Jump to target
+        if is_break {
+            emit!(self, Instruction::Break { target: exit_block });
+        } else {
+            emit!(self, Instruction::Continue { target: loop_block });
+        }
+
+        Ok(())
+    }
+
+    /// Calculate the current exception handler stack depth.
+    /// CPython calculates this based on the SETUP_FINALLY/SETUP_CLEANUP stack depth.
+    fn handler_stack_depth(&self) -> u32 {
+        let code = match self.code_stack.last() {
+            Some(c) => c,
+            None => return 0,
+        };
+        let mut depth = 0u32;
+        for fblock in &code.fblock {
+            match fblock.fb_type {
+                FBlockType::ForLoop => depth += 1,
+                FBlockType::With | FBlockType::AsyncWith => depth += 1,
+                // HandlerCleanup does NOT add to stack depth - it only tracks
+                // cleanup code for named exception handlers. The stack item
+                // (prev_exc) is already counted by ExceptionHandler.
+                // FBlockType::HandlerCleanup => depth += 1,
+                // inside exception handler, prev_exc is on stack
+                FBlockType::ExceptionHandler => depth += 1,
+                // ExceptionGroupHandler: inside except* handler path
+                // Stack has [prev_exc, orig, list, rest] - add 4 for these
+                FBlockType::ExceptionGroupHandler => depth += 4,
+                // FinallyEnd: inside finally exception path
+                // Stack has [prev_exc, exc] - add 2 for these (no lasti at this level)
+                FBlockType::FinallyEnd => depth += 2,
+                // PopValue: preserving a return value on stack during inline finally
+                // The return value adds 1 to the stack depth
+                FBlockType::PopValue => depth += 1,
+                _ => {}
+            }
+        }
+        depth
+    }
+
     fn current_block(&mut self) -> &mut ir::Block {
         let info = self.current_code_info();
         &mut info.blocks[info.current_block]
@@ -5777,6 +7000,11 @@ impl Compiler {
 
                 match expr {
                     Expr::Await(_) => self.found = true,
+                    // Note: We do NOT check for async comprehensions here.
+                    // Async list/set/dict comprehensions are handled by compile_comprehension
+                    // which already awaits the result. A generator expression containing
+                    // an async comprehension as its element does NOT become an async generator,
+                    // because the async comprehension is awaited when evaluating the element.
                     _ => walk_expr(self, expr),
                 }
             }
@@ -5787,6 +7015,24 @@ impl Compiler {
         visitor.found
     }
 
+    /// Check if any of the generators (except the first one's iter) contains an await expression.
+    /// The first generator's iter is evaluated outside the comprehension scope.
+    fn generators_contain_await(generators: &[Comprehension]) -> bool {
+        for (i, generator) in generators.iter().enumerate() {
+            // First generator's iter is evaluated outside the comprehension
+            if i > 0 && Self::contains_await(&generator.iter) {
+                return true;
+            }
+            // Check ifs in all generators
+            for if_expr in &generator.ifs {
+                if Self::contains_await(if_expr) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
     fn compile_expr_fstring(&mut self, fstring: &ExprFString) -> CompileResult<()> {
         let fstring = &fstring.value;
         for part in fstring {
@@ -5872,9 +7118,8 @@ impl Compiler {
                         self.emit_load_const(ConstantData::Str { value: text.into() });
                         element_count += 1;
 
-                        // Match CPython behavior: If debug text is present, apply repr conversion.
-                        // if no `format_spec` specified.
-                        // See: https://github.com/python/cpython/blob/f61afca262d3a0aa6a8a501db0b1936c60858e35/Parser/action_helpers.c#L1456
+                        // If debug text is present, apply repr conversion when no `format_spec` specified.
+                        // See action_helpers.c: fstring_find_expr_replacement
                         if matches!(
                             (conversion, &fstring_expr.format_spec),
                             (ConvertValueOparg::None, None)
@@ -6280,15 +7525,16 @@ if (True and False) or (False and True):
     fn test_nested_double_async_with() {
         assert_dis_snapshot!(compile_exec(
             "\
-for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):
-    with self.subTest(type=type(stop_exc)):
-        try:
-            async with egg():
-                raise stop_exc
-        except Exception as ex:
-            self.assertIs(ex, stop_exc)
-        else:
-            self.fail(f'{stop_exc} was suppressed')
+async def test():
+    for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):
+        with self.subTest(type=type(stop_exc)):
+            try:
+                async with egg():
+                    raise stop_exc
+            except Exception as ex:
+                self.assertIs(ex, stop_exc)
+            else:
+                self.fail(f'{stop_exc} was suppressed')
 "
         ));
     }
diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
index 459ba8e33b5..5bd7c7ecaf0 100644
--- a/crates/codegen/src/error.rs
+++ b/crates/codegen/src/error.rs
@@ -76,6 +76,9 @@ pub enum CodegenErrorType {
     InvalidYield,
     InvalidYieldFrom,
     InvalidAwait,
+    InvalidAsyncFor,
+    InvalidAsyncWith,
+    InvalidAsyncComprehension,
     AsyncYieldFrom,
     AsyncReturnValue,
     InvalidFuturePlacement,
@@ -113,6 +116,14 @@ impl fmt::Display for CodegenErrorType {
             InvalidYield => write!(f, "'yield' outside function"),
             InvalidYieldFrom => write!(f, "'yield from' outside function"),
             InvalidAwait => write!(f, "'await' outside async function"),
+            InvalidAsyncFor => write!(f, "'async for' outside async function"),
+            InvalidAsyncWith => write!(f, "'async with' outside async function"),
+            InvalidAsyncComprehension => {
+                write!(
+                    f,
+                    "asynchronous comprehension outside of an asynchronous function"
+                )
+            }
             AsyncYieldFrom => write!(f, "'yield from' inside async function"),
             AsyncReturnValue => {
                 write!(f, "'return' with value inside async generator")
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 31ee8d8b230..6cc22b438f5 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -4,9 +4,11 @@ use crate::{IndexMap, IndexSet, error::InternalError};
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
-        CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, InstrDisplayContext, Instruction,
-        Label, OpArg, PyCodeLocationInfoKind,
+        CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
+        InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
+        encode_exception_table,
     },
+    varint::{write_signed_varint, write_varint},
 };
 
 /// Metadata for a code unit
@@ -88,6 +90,18 @@ pub struct InstructionInfo {
     pub target: BlockIdx,
     pub location: SourceLocation,
     pub end_location: SourceLocation,
+    pub except_handler: Option<ExceptHandlerInfo>,
+}
+
+/// Exception handler information for an instruction
+#[derive(Debug, Clone)]
+pub struct ExceptHandlerInfo {
+    /// Block to jump to when exception occurs
+    pub handler_block: BlockIdx,
+    /// Stack depth at handler entry
+    pub stack_depth: u32,
+    /// Whether to push lasti before exception
+    pub preserve_lasti: bool,
 }
 
 // spell-checker:ignore petgraph
@@ -176,12 +190,19 @@ impl CodeInfo {
         let mut locations = Vec::new();
 
         let mut block_to_offset = vec![Label(0); blocks.len()];
+        // block_to_index: maps block idx to instruction index (for exception table)
+        // This is the index into the final instructions array, including EXTENDED_ARG
+        let mut block_to_index = vec![0u32; blocks.len()];
         loop {
             let mut num_instructions = 0;
             for (idx, block) in iter_blocks(&blocks) {
                 block_to_offset[idx.idx()] = Label(num_instructions as u32);
+                // block_to_index uses the same value as block_to_offset but as u32
+                // because lasti in frame.rs is the index into instructions array
+                // and instructions array index == byte offset (each instruction is 1 CodeUnit)
+                block_to_index[idx.idx()] = num_instructions as u32;
                 for instr in &block.instructions {
-                    num_instructions += instr.arg.instr_size()
+                    num_instructions += instr.arg.instr_size();
                 }
             }
 
@@ -228,6 +249,9 @@ impl CodeInfo {
             opts.debug_ranges,
         );
 
+        // Generate exception table before moving source_path
+        let exceptiontable = generate_exception_table(&blocks, &block_to_index);
+
         Ok(CodeObject {
             flags,
             posonlyarg_count,
@@ -248,7 +272,7 @@ impl CodeInfo {
             freevars: freevar_cache.into_iter().collect(),
             cell2arg,
             linetable,
-            exceptiontable: Box::new([]), // TODO: Generate actual exception table
+            exceptiontable,
         })
     }
 
@@ -305,12 +329,24 @@ impl CodeInfo {
         start_depths[0] = 0;
         stack.push(BlockIdx(0));
         const DEBUG: bool = false;
-        'process_blocks: while let Some(block) = stack.pop() {
-            let mut depth = start_depths[block.idx()];
+        // Global iteration limit as safety guard
+        // The algorithm is monotonic (depths only increase), so it should converge quickly.
+        // Max iterations = blocks * max_possible_depth_increases per block
+        let max_iterations = self.blocks.len() * 100;
+        let mut iterations = 0usize;
+        'process_blocks: while let Some(block_idx) = stack.pop() {
+            iterations += 1;
+            if iterations > max_iterations {
+                // Safety guard: should never happen in valid code
+                // Return error instead of silently breaking to avoid underestimated stack depth
+                return Err(InternalError::StackOverflow);
+            }
+            let idx = block_idx.idx();
+            let mut depth = start_depths[idx];
             if DEBUG {
-                eprintln!("===BLOCK {}===", block.0);
+                eprintln!("===BLOCK {}===", block_idx.0);
             }
-            let block = &self.blocks[block];
+            let block = &self.blocks[block_idx];
             for ins in &block.instructions {
                 let instr = &ins.instr;
                 let effect = instr.stack_effect(ins.arg, false);
@@ -336,15 +372,8 @@ impl CodeInfo {
                 if new_depth > maxdepth {
                     maxdepth = new_depth
                 }
-                // we don't want to worry about Break/Continue, they use unwinding to jump to
-                // their targets and as such the stack size is taken care of in frame.rs by setting
-                // it back to the level it was at when SetupLoop was run
-                if ins.target != BlockIdx::NULL
-                    && !matches!(
-                        instr,
-                        Instruction::Continue { .. } | Instruction::Break { .. }
-                    )
-                {
+                // Process target blocks for branching instructions
+                if ins.target != BlockIdx::NULL {
                     let effect = instr.stack_effect(ins.arg, true);
                     let target_depth = depth.checked_add_signed(effect).ok_or({
                         if effect < 0 {
@@ -358,6 +387,35 @@ impl CodeInfo {
                     }
                     stackdepth_push(&mut stack, &mut start_depths, ins.target, target_depth);
                 }
+                // Process exception handler blocks
+                // When exception occurs, stack is unwound to handler.stack_depth, then:
+                // - If preserve_lasti: push lasti (+1)
+                // - Push exception (+1)
+                // - Handler block starts with PUSH_EXC_INFO as its first instruction
+                // So the starting depth for the handler block (BEFORE PUSH_EXC_INFO) is:
+                // handler.stack_depth + preserve_lasti + 1 (exc)
+                // PUSH_EXC_INFO will then add +1 when the block is processed
+                if let Some(ref handler) = ins.except_handler {
+                    let handler_depth = handler.stack_depth + 1 + (handler.preserve_lasti as u32); // +1 for exception, +1 for lasti if preserve_lasti
+                    if DEBUG {
+                        eprintln!(
+                            "  HANDLER: block={} depth={} (base={} lasti={})",
+                            handler.handler_block.0,
+                            handler_depth,
+                            handler.stack_depth,
+                            handler.preserve_lasti
+                        );
+                    }
+                    if handler_depth > maxdepth {
+                        maxdepth = handler_depth;
+                    }
+                    stackdepth_push(
+                        &mut stack,
+                        &mut start_depths,
+                        handler.handler_block,
+                        handler_depth,
+                    );
+                }
                 depth = new_depth;
                 if instr.unconditional_branch() {
                     continue 'process_blocks;
@@ -401,8 +459,10 @@ fn stackdepth_push(
     target: BlockIdx,
     depth: u32,
 ) {
-    let block_depth = &mut start_depths[target.idx()];
-    if *block_depth == u32::MAX || depth > *block_depth {
+    let idx = target.idx();
+    let block_depth = &mut start_depths[idx];
+    if depth > *block_depth || *block_depth == u32::MAX {
+        // Found a path with higher depth (or first visit): update max and queue
         *block_depth = depth;
         stack.push(target);
     }
@@ -420,7 +480,7 @@ fn iter_blocks(blocks: &[Block]) -> impl Iterator<Item = (BlockIdx, &Block)> + '
     })
 }
 
-/// Generate CPython 3.11+ format linetable from source locations
+/// Generate Python 3.11+ format linetable from source locations
 fn generate_linetable(
     locations: &[(SourceLocation, SourceLocation)],
     first_line: i32,
@@ -540,27 +600,77 @@ fn generate_linetable(
     linetable.into_boxed_slice()
 }
 
-/// Write a variable-length unsigned integer (6-bit chunks)
-/// Returns the number of bytes written
-fn write_varint(buf: &mut Vec<u8>, mut val: u32) -> usize {
-    let start_len = buf.len();
-    while val >= 64 {
-        buf.push(0x40 | (val & 0x3f) as u8);
-        val >>= 6;
+/// Generate Python 3.11+ exception table from instruction handler info
+fn generate_exception_table(blocks: &[Block], block_to_index: &[u32]) -> Box<[u8]> {
+    let mut entries: Vec<ExceptionTableEntry> = Vec::new();
+    let mut current_entry: Option<(ExceptHandlerInfo, u32)> = None; // (handler_info, start_index)
+    let mut instr_index = 0u32;
+
+    // Iterate through all instructions in block order
+    // instr_index is the index into the final instructions array (including EXTENDED_ARG)
+    // This matches how frame.rs uses lasti
+    for (_, block) in iter_blocks(blocks) {
+        for instr in &block.instructions {
+            // instr_size includes EXTENDED_ARG instructions
+            let instr_size = instr.arg.instr_size() as u32;
+
+            match (&current_entry, &instr.except_handler) {
+                // No current entry, no handler - nothing to do
+                (None, None) => {}
+
+                // No current entry, handler starts - begin new entry
+                (None, Some(handler)) => {
+                    current_entry = Some((handler.clone(), instr_index));
+                }
+
+                // Current entry exists, same handler - continue
+                (Some((curr_handler, _)), Some(handler))
+                    if curr_handler.handler_block == handler.handler_block
+                        && curr_handler.stack_depth == handler.stack_depth
+                        && curr_handler.preserve_lasti == handler.preserve_lasti => {}
+
+                // Current entry exists, different handler - finish current, start new
+                (Some((curr_handler, start)), Some(handler)) => {
+                    let target_index = block_to_index[curr_handler.handler_block.idx()];
+                    entries.push(ExceptionTableEntry::new(
+                        *start,
+                        instr_index,
+                        target_index,
+                        curr_handler.stack_depth as u16,
+                        curr_handler.preserve_lasti,
+                    ));
+                    current_entry = Some((handler.clone(), instr_index));
+                }
+
+                // Current entry exists, no handler - finish current entry
+                (Some((curr_handler, start)), None) => {
+                    let target_index = block_to_index[curr_handler.handler_block.idx()];
+                    entries.push(ExceptionTableEntry::new(
+                        *start,
+                        instr_index,
+                        target_index,
+                        curr_handler.stack_depth as u16,
+                        curr_handler.preserve_lasti,
+                    ));
+                    current_entry = None;
+                }
+            }
+
+            instr_index += instr_size; // Account for EXTENDED_ARG instructions
+        }
+    }
+
+    // Finish any remaining entry
+    if let Some((curr_handler, start)) = current_entry {
+        let target_index = block_to_index[curr_handler.handler_block.idx()];
+        entries.push(ExceptionTableEntry::new(
+            start,
+            instr_index,
+            target_index,
+            curr_handler.stack_depth as u16,
+            curr_handler.preserve_lasti,
+        ));
     }
-    buf.push(val as u8);
-    buf.len() - start_len
-}
 
-/// Write a variable-length signed integer
-/// Returns the number of bytes written
-fn write_signed_varint(buf: &mut Vec<u8>, val: i32) -> usize {
-    let uval = if val < 0 {
-        // (unsigned int)(-val) has an undefined behavior for INT_MIN
-        // So we use (0 - val as u32) to handle it correctly
-        ((0u32.wrapping_sub(val as u32)) << 1) | 1
-    } else {
-        (val as u32) << 1
-    };
-    write_varint(buf, uval)
+    encode_exception_table(&entries)
 }
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index 6cd7d4d523f..679c5ebade4 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -1,86 +1,141 @@
 ---
 source: crates/codegen/src/compile.rs
-expression: "compile_exec(\"\\\nfor stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n    with self.subTest(type=type(stop_exc)):\n        try:\n            async with egg():\n                raise stop_exc\n        except Exception as ex:\n            self.assertIs(ex, stop_exc)\n        else:\n            self.fail(f'{stop_exc} was suppressed')\n\")"
+expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n        with self.subTest(type=type(stop_exc)):\n            try:\n                async with egg():\n                    raise stop_exc\n            except Exception as ex:\n                self.assertIs(ex, stop_exc)\n            else:\n                self.fail(f'{stop_exc} was suppressed')\n\")"
 ---
-  1           0 SETUP_LOOP
-              1 LOAD_NAME_ANY        (0, StopIteration)
-              2 LOAD_CONST           ("spam")
-              3 CALL_FUNCTION_POSITIONAL(1)
-              4 LOAD_NAME_ANY        (1, StopAsyncIteration)
-              5 LOAD_CONST           ("ham")
-              6 CALL_FUNCTION_POSITIONAL(1)
-              7 BUILD_TUPLE          (2)
-              8 GET_ITER
-        >>    9 FOR_ITER             (71)
-             10 STORE_LOCAL          (2, stop_exc)
+  3           0 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RESUME               (0)
 
-  2          11 LOAD_NAME_ANY        (3, self)
-             12 LOAD_METHOD          (4, subTest)
-             13 LOAD_NAME_ANY        (5, type)
-             14 LOAD_NAME_ANY        (2, stop_exc)
-             15 CALL_FUNCTION_POSITIONAL(1)
-             16 LOAD_CONST           (("type"))
-             17 CALL_METHOD_KEYWORD  (1)
-             18 SETUP_WITH           (68)
-             19 POP_TOP
+  2               1 LOAD_GLOBAL          (0, StopIteration)
+                  2 LOAD_CONST           ("spam")
+                  3 CALL                 (1)
+                  4 LOAD_GLOBAL          (1, StopAsyncIteration)
+                  5 LOAD_CONST           ("ham")
+                  6 CALL                 (1)
+                  7 BUILD_TUPLE          (2)
+                  8 GET_ITER
+            >>    9 FOR_ITER             (123)
+                 10 STORE_FAST           (0, stop_exc)
 
-  3          20 SETUP_EXCEPT         (42)
+  3              11 LOAD_GLOBAL          (2, self)
+                 12 LOAD_METHOD          (3, subTest)
+                 13 LOAD_GLOBAL          (4, type)
+                 14 LOAD_FAST            (0, stop_exc)
+                 15 CALL                 (1)
+                 16 LOAD_CONST           (("type"))
+                 17 CALL_METHOD_KW       (1)
+                 18 BEFORE_WITH
+                 19 POP_TOP
 
-  4          21 LOAD_NAME_ANY        (6, egg)
-             22 CALL_FUNCTION_POSITIONAL(0)
-             23 BEFORE_ASYNC_WITH
-             24 GET_AWAITABLE
-             25 LOAD_CONST           (None)
-             26 YIELD_FROM
-             27 RESUME               (3)
-             28 SETUP_ASYNC_WITH     (34)
-             29 POP_TOP
+  5              20 LOAD_GLOBAL          (5, egg)
+                 21 CALL                 (0)
+                 22 BEFORE_ASYNC_WITH
+                 23 GET_AWAITABLE
+                 24 LOAD_CONST           (None)
+            >>   25 SEND                 (30)
+                 26 YIELD_VALUE          (1)
+                 27 RESUME               (3)
+                 28 JUMP                 (25)
+                 29 CLEANUP_THROW
+            >>   30 END_SEND
+                 31 POP_TOP
 
-  5          30 LOAD_NAME_ANY        (2, stop_exc)
-             31 RAISE                (Raise)
+  6              32 LOAD_FAST            (0, stop_exc)
+                 33 RAISE_VARARGS        (Raise)
 
-  4          32 POP_BLOCK
-             33 ENTER_FINALLY
-        >>   34 WITH_CLEANUP_START
-             35 GET_AWAITABLE
-             36 LOAD_CONST           (None)
-             37 YIELD_FROM
-             38 RESUME               (3)
-             39 WITH_CLEANUP_FINISH
-             40 POP_BLOCK
-             41 JUMP                 (58)
-        >>   42 COPY                 (1)
+  5              34 LOAD_CONST           (None)
+                 35 LOAD_CONST           (None)
+                 36 LOAD_CONST           (None)
+                 37 CALL                 (3)
+                 38 GET_AWAITABLE
+                 39 LOAD_CONST           (None)
+            >>   40 SEND                 (45)
+                 41 YIELD_VALUE          (1)
+                 42 RESUME               (3)
+                 43 JUMP                 (40)
+                 44 CLEANUP_THROW
+            >>   45 END_SEND
+                 46 POP_TOP
+                 47 JUMP                 (69)
+                 48 PUSH_EXC_INFO
+                 49 WITH_EXCEPT_START
+                 50 GET_AWAITABLE
+                 51 LOAD_CONST           (None)
+            >>   52 SEND                 (57)
+                 53 YIELD_VALUE          (1)
+                 54 RESUME               (3)
+                 55 JUMP                 (52)
+                 56 CLEANUP_THROW
+            >>   57 END_SEND
+                 58 TO_BOOL
+                 59 POP_JUMP_IF_TRUE     (61)
+                 60 RERAISE              (2)
+            >>   61 POP_TOP
+                 62 POP_EXCEPT
+                 63 POP_TOP
+                 64 POP_TOP
+                 65 JUMP                 (69)
+                 66 COPY                 (3)
+                 67 POP_EXCEPT
+                 68 RERAISE              (1)
+            >>   69 JUMP                 (95)
+                 70 PUSH_EXC_INFO
+                 71 COPY                 (1)
 
-  6          43 LOAD_NAME_ANY        (7, Exception)
-             44 JUMP_IF_NOT_EXC_MATCH(57)
-             45 STORE_LOCAL          (8, ex)
+  7              72 LOAD_GLOBAL          (6, Exception)
+                 73 JUMP_IF_NOT_EXC_MATCH(91)
+                 74 STORE_FAST           (1, ex)
 
-  7          46 LOAD_NAME_ANY        (3, self)
-             47 LOAD_METHOD          (9, assertIs)
-             48 LOAD_NAME_ANY        (8, ex)
-             49 LOAD_NAME_ANY        (2, stop_exc)
-             50 CALL_METHOD_POSITIONAL(2)
-             51 POP_TOP
-             52 POP_EXCEPTION
-             53 LOAD_CONST           (None)
-             54 STORE_LOCAL          (8, ex)
-             55 DELETE_LOCAL         (8, ex)
-             56 JUMP                 (66)
-        >>   57 RAISE                (Reraise)
+  8              75 LOAD_GLOBAL          (2, self)
+                 76 LOAD_METHOD          (7, assertIs)
+                 77 LOAD_FAST            (1, ex)
+                 78 LOAD_FAST            (0, stop_exc)
+                 79 CALL_METHOD          (2)
+                 80 POP_TOP
+                 81 JUMP                 (86)
+                 82 LOAD_CONST           (None)
+                 83 STORE_FAST           (1, ex)
+                 84 DELETE_FAST          (1, ex)
+                 85 RAISE_VARARGS        (ReraiseFromStack)
+            >>   86 POP_EXCEPT
+                 87 LOAD_CONST           (None)
+                 88 STORE_FAST           (1, ex)
+                 89 DELETE_FAST          (1, ex)
+                 90 JUMP                 (103)
+            >>   91 RAISE_VARARGS        (ReraiseFromStack)
+                 92 COPY                 (3)
+                 93 POP_EXCEPT
+                 94 RAISE_VARARGS        (ReraiseFromStack)
 
-  9     >>   58 LOAD_NAME_ANY        (3, self)
-             59 LOAD_METHOD          (10, fail)
-             60 LOAD_NAME_ANY        (2, stop_exc)
-             61 FORMAT_SIMPLE
-             62 LOAD_CONST           (" was suppressed")
-             63 BUILD_STRING         (2)
-             64 CALL_METHOD_POSITIONAL(1)
-             65 POP_TOP
+ 10         >>   95 LOAD_GLOBAL          (2, self)
+                 96 LOAD_METHOD          (8, fail)
+                 97 LOAD_FAST            (0, stop_exc)
+                 98 FORMAT_SIMPLE
+                 99 LOAD_CONST           (" was suppressed")
+                100 BUILD_STRING         (2)
+                101 CALL_METHOD          (1)
+                102 POP_TOP
 
-  2     >>   66 POP_BLOCK
-             67 ENTER_FINALLY
-        >>   68 WITH_CLEANUP_START
-             69 WITH_CLEANUP_FINISH
-             70 JUMP                 (9)
-        >>   71 POP_BLOCK
-             72 RETURN_CONST         (None)
+  3         >>  103 LOAD_CONST           (None)
+                104 LOAD_CONST           (None)
+                105 LOAD_CONST           (None)
+                106 CALL                 (3)
+                107 POP_TOP
+                108 JUMP                 (122)
+                109 PUSH_EXC_INFO
+                110 WITH_EXCEPT_START
+                111 TO_BOOL
+                112 POP_JUMP_IF_TRUE     (114)
+                113 RERAISE              (2)
+            >>  114 POP_TOP
+                115 POP_EXCEPT
+                116 POP_TOP
+                117 POP_TOP
+                118 JUMP                 (122)
+                119 COPY                 (3)
+                120 POP_EXCEPT
+                121 RERAISE              (1)
+            >>  122 JUMP                 (9)
+            >>  123 RETURN_CONST         (None)
+
+              1 MAKE_FUNCTION
+              2 STORE_NAME           (0, test)
+              3 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap
deleted file mode 100644
index 589f3210cfa..00000000000
--- a/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap
+++ /dev/null
@@ -1,87 +0,0 @@
----
-source: compiler/src/compile.rs
-expression: "compile_exec(\"\\\nfor stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n    with self.subTest(type=type(stop_exc)):\n        try:\n            async with woohoo():\n                raise stop_exc\n        except Exception as ex:\n            self.assertIs(ex, stop_exc)\n        else:\n            self.fail(f'{stop_exc} was suppressed')\n\")"
----
-  1           0 SetupLoop            (69)
-              1 LoadNameAny          (0, StopIteration)
-              2 LoadConst            ("spam")
-              3 CallFunctionPositional (1)
-              4 LoadNameAny          (1, StopAsyncIteration)
-              5 LoadConst            ("ham")
-              6 CallFunctionPositional (1)
-              7 BuildTuple           (2, false)
-              8 GetIter
-        >>    9 ForIter              (68)
-             10 StoreLocal           (2, stop_exc)
-
-  2          11 LoadNameAny          (3, self)
-             12 LoadMethod           (subTest)
-             13 LoadNameAny          (5, type)
-             14 LoadNameAny          (2, stop_exc)
-             15 CallFunctionPositional (1)
-             16 LoadConst            (("type"))
-             17 CallMethodKeyword    (1)
-             18 SetupWith            (65)
-             19 Pop
-
-  3          20 SetupExcept          (40)
-
-  4          21 LoadNameAny          (6, woohoo)
-             22 CallFunctionPositional (0)
-             23 BeforeAsyncWith
-             24 GetAwaitable
-             25 LoadConst            (None)
-             26 YieldFrom
-             27 SetupAsyncWith       (33)
-             28 Pop
-
-  5          29 LoadNameAny          (2, stop_exc)
-             30 Raise                (Raise)
-
-  4          31 PopBlock
-             32 EnterFinally
-        >>   33 WithCleanupStart
-             34 GetAwaitable
-             35 LoadConst            (None)
-             36 YieldFrom
-             37 WithCleanupFinish
-             38 PopBlock
-             39 Jump                 (54)
-        >>   40 Duplicate
-
-  6          41 LoadNameAny          (7, Exception)
-             42 TestOperation        (ExceptionMatch)
-             43 PopJumpIfFalse       (53)
-             44 StoreLocal           (8, ex)
-
-  7          45 LoadNameAny          (3, self)
-             46 LoadMethod           (assertIs)
-             47 LoadNameAny          (8, ex)
-             48 LoadNameAny          (2, stop_exc)
-             49 CallMethodPositional (2)
-             50 Pop
-             51 PopException
-             52 Jump                 (63)
-        >>   53 Raise                (Reraise)
-
-  9     >>   54 LoadNameAny          (3, self)
-             55 LoadMethod           (fail)
-             56 LoadConst            ("")
-
-  1          57 LoadNameAny          (2, stop_exc)
-             58 FormatValue          (None)
-
-  9          59 LoadConst            (" was suppressed")
-             60 BuildString          (2)
-             61 CallMethodPositional (1)
-             62 Pop
-
-  2     >>   63 PopBlock
-             64 EnterFinally
-        >>   65 WithCleanupStart
-             66 WithCleanupFinish
-             67 Jump                 (9)
-        >>   68 PopBlock
-        >>   69 LoadConst            (None)
-             70 ReturnValue
-
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 95f9c0cd400..fe4976bb086 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -55,6 +55,10 @@ pub struct SymbolTable {
 
     /// Whether this type param scope can see the parent class scope
     pub can_see_class_scope: bool,
+
+    /// Whether this comprehension scope should be inlined (PEP 709)
+    /// True for list/set/dict comprehensions in non-generator expressions
+    pub comp_inlined: bool,
 }
 
 impl SymbolTable {
@@ -70,6 +74,7 @@ impl SymbolTable {
             needs_class_closure: false,
             needs_classdict: false,
             can_see_class_scope: false,
+            comp_inlined: false,
         }
     }
 
@@ -344,6 +349,37 @@ impl SymbolTableAnalyzer {
 
         symbol_table.symbols = info.0;
 
+        // PEP 709: Merge symbols from inlined comprehensions into parent scope
+        // Only merge symbols that are actually bound in the comprehension,
+        // not references to outer scope variables (Free symbols).
+        const BOUND_FLAGS: SymbolFlags = SymbolFlags::ASSIGNED
+            .union(SymbolFlags::PARAMETER)
+            .union(SymbolFlags::ITER)
+            .union(SymbolFlags::ASSIGNED_IN_COMPREHENSION);
+
+        for sub_table in sub_tables.iter() {
+            if sub_table.comp_inlined {
+                for (name, sub_symbol) in &sub_table.symbols {
+                    // Skip the .0 parameter - it's internal to the comprehension
+                    if name == ".0" {
+                        continue;
+                    }
+                    // Only merge symbols that are bound in the comprehension
+                    // Skip Free references to outer scope variables
+                    if !sub_symbol.flags.intersects(BOUND_FLAGS) {
+                        continue;
+                    }
+                    // If the symbol doesn't exist in parent, add it
+                    if !symbol_table.symbols.contains_key(name) {
+                        let mut symbol = sub_symbol.clone();
+                        // Mark as local in parent scope
+                        symbol.scope = SymbolScope::Local;
+                        symbol_table.symbols.insert(name.clone(), symbol);
+                    }
+                }
+            }
+        }
+
         // Analyze symbols:
         for symbol in symbol_table.symbols.values_mut() {
             self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
@@ -1241,7 +1277,8 @@ impl SymbolTableBuilder {
                 if context == ExpressionContext::IterDefinitionExp {
                     self.in_iter_def_exp = true;
                 }
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                // Generator expression - is_generator = true
+                self.scan_comprehension("<genexpr>", elt, None, generators, *range, true)?;
                 self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::ListComp(ExprListComp {
@@ -1254,7 +1291,8 @@ impl SymbolTableBuilder {
                 if context == ExpressionContext::IterDefinitionExp {
                     self.in_iter_def_exp = true;
                 }
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                // List comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<listcomp>", elt, None, generators, *range, false)?;
                 self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::SetComp(ExprSetComp {
@@ -1267,7 +1305,8 @@ impl SymbolTableBuilder {
                 if context == ExpressionContext::IterDefinitionExp {
                     self.in_iter_def_exp = true;
                 }
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
+                // Set comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<setcomp>", elt, None, generators, *range, false)?;
                 self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::DictComp(ExprDictComp {
@@ -1281,7 +1320,8 @@ impl SymbolTableBuilder {
                 if context == ExpressionContext::IterDefinitionExp {
                     self.in_iter_def_exp = true;
                 }
-                self.scan_comprehension("genexpr", key, Some(value), generators, *range)?;
+                // Dict comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<dictcomp>", key, Some(value), generators, *range, false)?;
                 self.in_iter_def_exp = was_in_iter_def_exp;
             }
             Expr::Call(ExprCall {
@@ -1451,6 +1491,7 @@ impl SymbolTableBuilder {
         elt2: Option<&Expr>,
         generators: &[Comprehension],
         range: TextRange,
+        is_generator: bool,
     ) -> SymbolTableResult {
         // Comprehensions are compiled as functions, so create a scope for them:
         self.enter_scope(
@@ -1459,6 +1500,21 @@ impl SymbolTableBuilder {
             self.line_index_start(range),
         );
 
+        // Mark non-generator comprehensions as inlined (PEP 709)
+        // inline_comp = entry->ste_comprehension && !entry->ste_generator && !ste->ste_can_see_class_scope
+        // We check is_generator and can_see_class_scope of parent
+        let parent_can_see_class = self
+            .tables
+            .get(self.tables.len().saturating_sub(2))
+            .map(|t| t.can_see_class_scope)
+            .unwrap_or(false);
+        if !is_generator
+            && !parent_can_see_class
+            && let Some(table) = self.tables.last_mut()
+        {
+            table.comp_inlined = true;
+        }
+
         // Register the passed argument to the generator function as the name ".0"
         self.register_name(".0", SymbolUsage::Parameter, range)?;
 
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 7675ef34863..08426287307 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -3,9 +3,10 @@
 
 use crate::{
     marshal::MarshalError,
+    varint::{read_varint, read_varint_with_start, write_varint, write_varint_with_start},
     {OneIndexed, SourceLocation},
 };
-use alloc::{collections::BTreeSet, fmt};
+use alloc::{collections::BTreeSet, fmt, vec::Vec};
 use bitflags::bitflags;
 use core::{hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
 use itertools::Itertools;
@@ -13,6 +14,76 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
+/// Exception table entry for zero-cost exception handling
+/// Format: (start, size, target, depth<<1|lasti)
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExceptionTableEntry {
+    /// Start instruction offset (inclusive)
+    pub start: u32,
+    /// End instruction offset (exclusive)
+    pub end: u32,
+    /// Handler target offset
+    pub target: u32,
+    /// Stack depth at handler entry
+    pub depth: u16,
+    /// Whether to push lasti before exception
+    pub push_lasti: bool,
+}
+
+impl ExceptionTableEntry {
+    pub fn new(start: u32, end: u32, target: u32, depth: u16, push_lasti: bool) -> Self {
+        Self {
+            start,
+            end,
+            target,
+            depth,
+            push_lasti,
+        }
+    }
+}
+
+/// Encode exception table entries.
+/// Uses 6-bit varint encoding with start marker (MSB) and continuation bit.
+pub fn encode_exception_table(entries: &[ExceptionTableEntry]) -> alloc::boxed::Box<[u8]> {
+    let mut data = Vec::new();
+    for entry in entries {
+        let size = entry.end.saturating_sub(entry.start);
+        let depth_lasti = ((entry.depth as u32) << 1) | (entry.push_lasti as u32);
+
+        write_varint_with_start(&mut data, entry.start);
+        write_varint(&mut data, size);
+        write_varint(&mut data, entry.target);
+        write_varint(&mut data, depth_lasti);
+    }
+    data.into_boxed_slice()
+}
+
+/// Find exception handler for given instruction offset.
+pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTableEntry> {
+    let mut pos = 0;
+    while pos < table.len() {
+        let start = read_varint_with_start(table, &mut pos)?;
+        let size = read_varint(table, &mut pos)?;
+        let target = read_varint(table, &mut pos)?;
+        let depth_lasti = read_varint(table, &mut pos)?;
+
+        let end = start + size;
+        let depth = (depth_lasti >> 1) as u16;
+        let push_lasti = (depth_lasti & 1) != 0;
+
+        if offset >= start && offset < end {
+            return Some(ExceptionTableEntry {
+                start,
+                end,
+                target,
+                depth,
+                push_lasti,
+            });
+        }
+    }
+    None
+}
+
 /// Oparg values for [`Instruction::ConvertValue`].
 ///
 /// ## See also
@@ -540,9 +611,21 @@ op_arg_enum!(
     #[derive(Copy, Clone, Debug, PartialEq, Eq)]
     #[repr(u8)]
     pub enum RaiseKind {
-        Reraise = 0,
+        /// Bare `raise` statement with no arguments.
+        /// Gets the current exception from VM state (topmost_exception).
+        /// Maps to RAISE_VARARGS with oparg=0.
+        BareRaise = 0,
+        /// `raise exc` - exception is on the stack.
+        /// Maps to RAISE_VARARGS with oparg=1.
         Raise = 1,
+        /// `raise exc from cause` - exception and cause are on the stack.
+        /// Maps to RAISE_VARARGS with oparg=2.
         RaiseCause = 2,
+        /// Reraise exception from the stack top.
+        /// Used in exception handler cleanup blocks (finally, except).
+        /// Gets exception from stack, not from VM state.
+        /// Maps to the RERAISE opcode.
+        ReraiseFromStack = 3,
     }
 );
 
@@ -587,293 +670,449 @@ op_arg_enum!(
 pub type NameIdx = u32;
 
 /// A Single bytecode instruction.
+/// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
+/// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum Instruction {
+    // ==================== No-argument instructions (opcode < 44) ====================
+    // 0: CACHE - placeholder for inline cache (not executed)
+    Cache,
+    // 1: BEFORE_ASYNC_WITH
     BeforeAsyncWith,
+    // 2: BEFORE_WITH
+    BeforeWith,
+    // 3: Reserved (BINARY_OP_INPLACE_ADD_UNICODE in CPython)
+    Reserved3,
+    // 4: BINARY_SLICE - not implemented, placeholder
+    BinarySlice,
+    // 5: BINARY_SUBSCR
+    BinarySubscript,
+    // 6: CHECK_EG_MATCH
+    CheckEgMatch,
+    // 7: CHECK_EXC_MATCH
+    CheckExcMatch,
+    // 8: CLEANUP_THROW
+    CleanupThrow,
+    // 9: DELETE_SUBSCR
+    DeleteSubscript,
+    // 10: END_ASYNC_FOR
+    EndAsyncFor,
+    // 11: END_FOR - not implemented, placeholder
+    EndFor,
+    // 12: END_SEND
+    EndSend,
+    // 13: EXIT_INIT_CHECK - not implemented, placeholder
+    ExitInitCheck,
+    // 14: FORMAT_SIMPLE
+    FormatSimple,
+    // 15: FORMAT_WITH_SPEC
+    FormatWithSpec,
+    // 16: GET_AITER
+    GetAIter,
+    // 17: RESERVED
+    Reserved17,
+    // 18: GET_ANEXT
+    GetANext,
+    // 19: GET_ITER
+    GetIter,
+    // 20: GET_LEN
+    GetLen,
+    // 21: GET_YIELD_FROM_ITER - not implemented, placeholder
+    GetYieldFromIter,
+    // 22: INTERPRETER_EXIT - not implemented, placeholder
+    InterpreterExit,
+    // 23: LOAD_ASSERTION_ERROR - not implemented, placeholder
+    LoadAssertionError,
+    // 24: LOAD_BUILD_CLASS
+    LoadBuildClass,
+    // 25: LOAD_LOCALS - not implemented, placeholder
+    LoadLocals,
+    // 26: MAKE_FUNCTION
+    MakeFunction,
+    // 27: MATCH_KEYS
+    MatchKeys,
+    // 28: MATCH_MAPPING
+    MatchMapping,
+    // 29: MATCH_SEQUENCE
+    MatchSequence,
+    // 30: NOP
+    Nop,
+    // 31: POP_EXCEPT
+    PopException,
+    // 32: POP_TOP
+    PopTop,
+    // 33: PUSH_EXC_INFO
+    PushExcInfo,
+    // 34: PUSH_NULL - not implemented, placeholder
+    PushNull,
+    // 35: RETURN_GENERATOR - not implemented, placeholder
+    ReturnGenerator,
+    // 36: RETURN_VALUE
+    ReturnValue,
+    // 37: SETUP_ANNOTATIONS
+    SetupAnnotation,
+    // 38: STORE_SLICE - not implemented, placeholder
+    StoreSlice,
+    // 39: STORE_SUBSCR
+    StoreSubscript,
+    // 40: TO_BOOL
+    ToBool,
+    // 41: UNARY_INVERT - placeholder (RustPython uses UnaryOperation)
+    UnaryInvert,
+    // 42: UNARY_NEGATIVE - placeholder
+    UnaryNegative,
+    // 43: UNARY_NOT - placeholder
+    UnaryNot,
+    // ==================== With-argument instructions (opcode >= 44) ====================
+    // 44: WITH_EXCEPT_START
+    WithExceptStart,
+    // 45: BINARY_OP
     BinaryOp {
         op: Arg<BinaryOperator>,
     },
-    BinarySubscript,
-    Break {
-        target: Arg<Label>,
-    },
-    BuildListFromTuples {
+    // 46: BUILD_CONST_KEY_MAP - not implemented, placeholder
+    BuildConstKeyMap {
         size: Arg<u32>,
     },
+    // 47: BUILD_LIST
     BuildList {
         size: Arg<u32>,
     },
-    BuildMapForCall {
-        size: Arg<u32>,
-    },
+    // 48: BUILD_MAP
     BuildMap {
         size: Arg<u32>,
     },
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    },
+    // 49: BUILD_SET
     BuildSet {
         size: Arg<u32>,
     },
+    // 50: BUILD_SLICE
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
     },
+    // 51: BUILD_STRING
     BuildString {
         size: Arg<u32>,
     },
-    BuildTupleFromIter,
-    BuildTupleFromTuples {
-        size: Arg<u32>,
-    },
+    // 52: BUILD_TUPLE
     BuildTuple {
         size: Arg<u32>,
     },
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    },
-    CallFunctionKeyword {
-        nargs: Arg<u32>,
-    },
+    // 53: CALL
     CallFunctionPositional {
         nargs: Arg<u32>,
     },
+    // 54: CALL_FUNCTION_EX
+    CallFunctionEx {
+        has_kwargs: Arg<bool>,
+    },
+    // 55: CALL_INTRINSIC_1
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
     },
+    // 56: CALL_INTRINSIC_2
     CallIntrinsic2 {
         func: Arg<IntrinsicFunction2>,
     },
-    CallMethodEx {
-        has_kwargs: Arg<bool>,
-    },
-    CallMethodKeyword {
-        nargs: Arg<u32>,
-    },
-    CallMethodPositional {
+    // 57: CALL_KW
+    CallFunctionKeyword {
         nargs: Arg<u32>,
     },
-    /// Check if exception matches except* handler type.
-    /// Pops exc_value and match_type, pushes (rest, match).
-    CheckEgMatch,
+    // 58: COMPARE_OP
     CompareOperation {
         op: Arg<ComparisonOperator>,
     },
-    /// Performs `in` comparison, or `not in` if `invert` is 1.
+    // 59: CONTAINS_OP
     ContainsOp(Arg<Invert>),
-    Continue {
-        target: Arg<Label>,
-    },
-    /// Convert value to a string, depending on `oparg`:
-    ///
-    /// ```python
-    /// value = STACK.pop()
-    /// result = func(value)
-    /// STACK.append(result)
-    /// ```
-    ///
-    /// Used for implementing formatted string literals (f-strings).
+    // 60: CONVERT_VALUE
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
     },
+    // 61: COPY
     CopyItem {
         index: Arg<u32>,
     },
+    // 62: COPY_FREE_VARS - not implemented, placeholder
+    CopyFreeVars {
+        count: Arg<u32>,
+    },
+    // 63: DELETE_ATTR
     DeleteAttr {
         idx: Arg<NameIdx>,
     },
+    // 64: DELETE_DEREF
     DeleteDeref(Arg<NameIdx>),
+    // 65: DELETE_FAST
     DeleteFast(Arg<NameIdx>),
+    // 66: DELETE_GLOBAL
     DeleteGlobal(Arg<NameIdx>),
+    // 67: DELETE_NAME
     DeleteLocal(Arg<NameIdx>),
-    DeleteSubscript,
+    // 68: DICT_MERGE - not implemented, placeholder
+    DictMerge {
+        index: Arg<u32>,
+    },
+    // 69: DICT_UPDATE
     DictUpdate {
         index: Arg<u32>,
     },
-    EndAsyncFor,
-    /// Marker bytecode for the end of a finally sequence.
-    /// When this bytecode is executed, the eval loop does one of those things:
-    /// - Continue at a certain bytecode position
-    /// - Propagate the exception
-    /// - Return from a function
-    /// - Do nothing at all, just continue
-    EndFinally,
-    /// Enter a finally block, without returning, excepting, just because we are there.
-    EnterFinally,
+    // 70: ENTER_EXECUTOR - not implemented, placeholder
+    EnterExecutor {
+        index: Arg<u32>,
+    },
+    // 71: EXTENDED_ARG
     ExtendedArg,
+    // 72: FOR_ITER
     ForIter {
         target: Arg<Label>,
     },
-    /// Formats the value on top of stack:
-    ///
-    /// ```python
-    /// value = STACK.pop()
-    /// result = value.__format__("")
-    /// STACK.append(result)
-    /// ```
-    ///
-    /// Used for implementing formatted string literals (f-strings).
-    FormatSimple,
-    /// Formats the given value with the given format spec:
-    ///
-    /// ```python
-    /// spec = STACK.pop()
-    /// value = STACK.pop()
-    /// result = value.__format__(spec)
-    /// STACK.append(result)
-    /// ```
-    ///
-    /// Used for implementing formatted string literals (f-strings).
-    FormatWithSpec,
-    GetAIter,
-    GetANext,
+    // 73: GET_AWAITABLE
     GetAwaitable,
-    GetIter,
-    GetLen,
-    /// from ... import ...
+    // 74: IMPORT_FROM
     ImportFrom {
         idx: Arg<NameIdx>,
     },
-    /// Importing by name
+    // 75: IMPORT_NAME
     ImportName {
         idx: Arg<NameIdx>,
     },
-    /// Performs `is` comparison, or `is not` if `invert` is 1.
+    // 76: IS_OP
     IsOp(Arg<Invert>),
-    /// Peek at the top of the stack, and jump if this value is false.
-    /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop {
+    // 77: JUMP_BACKWARD - not implemented, placeholder
+    JumpBackward {
         target: Arg<Label>,
     },
-    /// Performs exception matching for except.
-    /// Tests whether the STACK[-2] is an exception matching STACK[-1].
-    /// Pops STACK[-1] and pushes the boolean result of the test.
-    JumpIfNotExcMatch(Arg<Label>),
-    /// Peek at the top of the stack, and jump if this value is true.
-    /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop {
+    // 78: JUMP_BACKWARD_NO_INTERRUPT - not implemented, placeholder
+    JumpBackwardNoInterrupt {
         target: Arg<Label>,
     },
-    Jump {
+    // 79: JUMP_FORWARD - not implemented, placeholder
+    JumpForward {
         target: Arg<Label>,
     },
+    // 80: LIST_APPEND
     ListAppend {
         i: Arg<u32>,
     },
+    // 81: LIST_EXTEND - not implemented, placeholder
+    ListExtend {
+        i: Arg<u32>,
+    },
+    // 82: LOAD_ATTR
     LoadAttr {
         idx: Arg<NameIdx>,
     },
-    LoadBuildClass,
-    LoadClassDeref(Arg<NameIdx>),
-    LoadClosure(Arg<NameIdx>),
+    // 83: LOAD_CONST
     LoadConst {
-        /// index into constants vec
         idx: Arg<u32>,
     },
+    // 84: LOAD_DEREF
     LoadDeref(Arg<NameIdx>),
+    // 85: LOAD_FAST
     LoadFast(Arg<NameIdx>),
-    LoadGlobal(Arg<NameIdx>),
-    LoadMethod {
-        idx: Arg<NameIdx>,
+    // 86: LOAD_FAST_AND_CLEAR
+    LoadFastAndClear(Arg<NameIdx>),
+    // 87: LOAD_FAST_CHECK - not implemented, placeholder
+    LoadFastCheck(Arg<NameIdx>),
+    // 88: LOAD_FAST_LOAD_FAST - not implemented, placeholder
+    LoadFastLoadFast {
+        arg: Arg<u32>,
     },
+    // 89: LOAD_FROM_DICT_OR_DEREF - not implemented, placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>),
+    // 90: LOAD_FROM_DICT_OR_GLOBALS - not implemented, placeholder
+    LoadFromDictOrGlobals(Arg<NameIdx>),
+    // 91: LOAD_GLOBAL
+    LoadGlobal(Arg<NameIdx>),
+    // 92: LOAD_NAME
     LoadNameAny(Arg<NameIdx>),
-    MakeFunction,
+    // 93: LOAD_SUPER_ATTR - not implemented, placeholder
+    LoadSuperAttr {
+        arg: Arg<u32>,
+    },
+    // 94: MAKE_CELL - not implemented, placeholder
+    MakeCell(Arg<NameIdx>),
+    // 95: MAP_ADD
     MapAdd {
         i: Arg<u32>,
     },
+    // 96: MATCH_CLASS
     MatchClass(Arg<u32>),
-    MatchKeys,
-    MatchMapping,
-    MatchSequence,
-    Nop,
-    PopBlock,
-    PopException,
-    /// Pop the top of the stack, and jump if this value is false.
+    // 97: POP_JUMP_IF_FALSE
     PopJumpIfFalse {
         target: Arg<Label>,
     },
-    /// Pop the top of the stack, and jump if this value is true.
+    // 98: POP_JUMP_IF_NONE - not implemented, placeholder
+    PopJumpIfNone {
+        target: Arg<Label>,
+    },
+    // 99: POP_JUMP_IF_NOT_NONE - not implemented, placeholder
+    PopJumpIfNotNone {
+        target: Arg<Label>,
+    },
+    // 100: POP_JUMP_IF_TRUE
     PopJumpIfTrue {
         target: Arg<Label>,
     },
-    /// Removes the top-of-stack item:
-    /// ```py
-    /// STACK.pop()
-    /// ```
-    PopTop,
+    // 101: RAISE_VARARGS
     Raise {
         kind: Arg<RaiseKind>,
     },
-    /// Resume execution (e.g., at function start, after yield, etc.)
-    Resume {
-        arg: Arg<u32>,
+    // 102: RERAISE
+    Reraise {
+        depth: Arg<u32>,
     },
+    // 103: RETURN_CONST
     ReturnConst {
         idx: Arg<u32>,
     },
-    ReturnValue,
-    Reverse {
-        amount: Arg<u32>,
+    // 104: SEND
+    Send {
+        target: Arg<Label>,
     },
+    // 105: SET_ADD
     SetAdd {
         i: Arg<u32>,
     },
+    // 106: SET_FUNCTION_ATTRIBUTE
     SetFunctionAttribute {
         attr: Arg<MakeFunctionFlags>,
     },
-    SetupAnnotation,
-    SetupAsyncWith {
-        end: Arg<Label>,
-    },
-
-    SetupExcept {
-        handler: Arg<Label>,
-    },
-    /// Setup a finally handler, which will be called whenever one of this events occurs:
-    /// - the block is popped
-    /// - the function returns
-    /// - an exception is returned
-    SetupFinally {
-        handler: Arg<Label>,
-    },
-    SetupLoop,
-    SetupWith {
-        end: Arg<Label>,
+    // 107: SET_UPDATE - not implemented, placeholder
+    SetUpdate {
+        i: Arg<u32>,
     },
+    // 108: STORE_ATTR
     StoreAttr {
         idx: Arg<NameIdx>,
     },
+    // 109: STORE_DEREF
     StoreDeref(Arg<NameIdx>),
+    // 110: STORE_FAST
     StoreFast(Arg<NameIdx>),
+    // 111: STORE_FAST_LOAD_FAST
+    StoreFastLoadFast {
+        store_idx: Arg<NameIdx>,
+        load_idx: Arg<NameIdx>,
+    },
+    // 112: STORE_FAST_STORE_FAST - not implemented, placeholder
+    StoreFastStoreFast {
+        arg: Arg<u32>,
+    },
+    // 113: STORE_GLOBAL
     StoreGlobal(Arg<NameIdx>),
+    // 114: STORE_NAME
     StoreLocal(Arg<NameIdx>),
-    StoreSubscript,
-    Subscript,
+    // 115: SWAP
     Swap {
         index: Arg<u32>,
     },
-    ToBool,
-    UnaryOperation {
-        op: Arg<UnaryOperator>,
-    },
+    // 116: UNPACK_EX
     UnpackEx {
         args: Arg<UnpackExArgs>,
     },
+    // 117: UNPACK_SEQUENCE
     UnpackSequence {
         size: Arg<u32>,
     },
-    WithCleanupFinish,
-    WithCleanupStart,
-    YieldFrom,
-    YieldValue,
-    /// Set the current exception to TOS (for except* handlers).
-    /// Does not pop the value.
+    // 118: YIELD_VALUE
+    YieldValue {
+        arg: Arg<u32>,
+    },
+    // ==================== RustPython-only instructions (119+) ====================
+    // 119: BREAK
+    Break {
+        target: Arg<Label>,
+    },
+    // 120: BUILD_LIST_FROM_TUPLES
+    BuildListFromTuples {
+        size: Arg<u32>,
+    },
+    // 121: BUILD_MAP_FOR_CALL
+    BuildMapForCall {
+        size: Arg<u32>,
+    },
+    // 122: BUILD_SET_FROM_TUPLES
+    BuildSetFromTuples {
+        size: Arg<u32>,
+    },
+    // 123: BUILD_TUPLE_FROM_ITER
+    BuildTupleFromIter,
+    // 124: BUILD_TUPLE_FROM_TUPLES
+    BuildTupleFromTuples {
+        size: Arg<u32>,
+    },
+    // 125: CALL_METHOD
+    CallMethodPositional {
+        nargs: Arg<u32>,
+    },
+    // 126: CALL_METHOD_KW
+    CallMethodKeyword {
+        nargs: Arg<u32>,
+    },
+    // 127: CALL_METHOD_EX
+    CallMethodEx {
+        has_kwargs: Arg<bool>,
+    },
+    // 128: CONTINUE
+    Continue {
+        target: Arg<Label>,
+    },
+    // 129: JUMP (CPython uses pseudo-op 256)
+    Jump {
+        target: Arg<Label>,
+    },
+    // 130: JUMP_IF_FALSE_OR_POP
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
+    },
+    // 131: JUMP_IF_TRUE_OR_POP
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
+    },
+    // 132: JUMP_IF_NOT_EXC_MATCH
+    JumpIfNotExcMatch(Arg<Label>),
+    // 133: LOAD_CLASSDEREF
+    LoadClassDeref(Arg<NameIdx>),
+    // 134: LOAD_CLOSURE (CPython uses pseudo-op 258)
+    LoadClosure(Arg<NameIdx>),
+    // 135: LOAD_METHOD (CPython uses pseudo-op 259)
+    LoadMethod {
+        idx: Arg<NameIdx>,
+    },
+    // 136: POP_BLOCK (CPython uses pseudo-op 263)
+    PopBlock,
+    // 137: REVERSE
+    Reverse {
+        amount: Arg<u32>,
+    },
+    // 138: SET_EXC_INFO
     SetExcInfo,
+    // 139: SUBSCRIPT
+    Subscript,
+    // 140: UNARY_OP (combines UNARY_*)
+    UnaryOperation {
+        op: Arg<UnaryOperator>,
+    },
+    // 141-148: Reserved (padding to keep RESUME at 149)
+    Reserved141,
+    Reserved142,
+    Reserved143,
+    Reserved144,
+    Reserved145,
+    Reserved146,
+    Reserved147,
+    Reserved148,
+    // 149: RESUME
+    Resume {
+        arg: Arg<u32>,
+    },
     // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
 }
 
 // This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::SetExcInfo;
+const LAST_INSTRUCTION: Instruction = Instruction::Resume { arg: Arg::marker() };
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
@@ -1631,12 +1870,15 @@ impl Instruction {
             | JumpIfTrueOrPop { target: l }
             | JumpIfFalseOrPop { target: l }
             | ForIter { target: l }
-            | SetupFinally { handler: l }
-            | SetupExcept { handler: l }
-            | SetupWith { end: l }
-            | SetupAsyncWith { end: l }
             | Break { target: l }
-            | Continue { target: l } => Some(*l),
+            | Continue { target: l }
+            | Send { target: l }
+            // Dummy jump instructions (placeholders)
+            | JumpBackward { target: l }
+            | JumpBackwardNoInterrupt { target: l }
+            | JumpForward { target: l }
+            | PopJumpIfNone { target: l }
+            | PopJumpIfNotNone { target: l } => Some(*l),
             _ => None,
         }
     }
@@ -1659,6 +1901,7 @@ impl Instruction {
                 | ReturnValue
                 | ReturnConst { .. }
                 | Raise { .. }
+                | Reraise { .. }
         )
     }
 
@@ -1678,11 +1921,35 @@ impl Instruction {
     ///
     pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
+            // Dummy/placeholder instructions (never executed)
+            Cache | Reserved3 | Reserved17 | Reserved141 | Reserved142 | Reserved143
+            | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => 0,
+            BinarySlice | EndFor | ExitInitCheck | GetYieldFromIter | InterpreterExit
+            | LoadAssertionError | LoadLocals | PushNull | ReturnGenerator | StoreSlice
+            | UnaryInvert | UnaryNegative | UnaryNot => 0,
+            BuildConstKeyMap { .. }
+            | CopyFreeVars { .. }
+            | DictMerge { .. }
+            | EnterExecutor { .. }
+            | ListExtend { .. }
+            | LoadFastCheck(_)
+            | LoadFastLoadFast { .. }
+            | LoadFromDictOrDeref(_)
+            | LoadFromDictOrGlobals(_)
+            | LoadSuperAttr { .. }
+            | MakeCell(_)
+            | SetUpdate { .. }
+            | StoreFastStoreFast { .. } => 0,
+            JumpBackward { .. } | JumpBackwardNoInterrupt { .. } | JumpForward { .. } => 0,
+            PopJumpIfNone { .. } | PopJumpIfNotNone { .. } => -1,
+
             Nop => 0,
             ImportName { .. } => -1,
             ImportFrom { .. } => 1,
-            LoadFast(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) => 1,
+            LoadFast(_) | LoadFastAndClear(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_)
+            | LoadClassDeref(_) => 1,
             StoreFast(_) | StoreLocal(_) | StoreGlobal(_) | StoreDeref(_) => -1,
+            StoreFastLoadFast { .. } => 0, // pop 1, push 1
             DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
             LoadClosure(_) => 1,
             Subscript => -1,
@@ -1745,16 +2012,34 @@ impl Instruction {
             ReturnValue => -1,
             ReturnConst { .. } => 0,
             Resume { .. } => 0,
-            YieldValue => 0,
-            YieldFrom => -1,
+            YieldValue { .. } => 0,
+            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
+            Send { .. } => 0,
+            // END_SEND: (receiver, value) -> (value)
+            EndSend => -1,
+            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
+            CleanupThrow => -1,
             SetExcInfo => 0,
-            SetupAnnotation | SetupLoop | SetupFinally { .. } | EnterFinally | EndFinally => 0,
-            SetupExcept { .. } => jump as i32,
-            SetupWith { .. } => (!jump) as i32,
-            WithCleanupStart => 0,
-            WithCleanupFinish => -1,
+            PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
+            CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
+            Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
+            SetupAnnotation => 0,
+            BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
+            WithExceptStart => 1, // push __exit__ result
             PopBlock => 0,
-            Raise { kind } => -(kind.get(arg) as u8 as i32),
+            Raise { kind } => {
+                // Stack effects for different raise kinds:
+                // - Reraise (0): gets from VM state, no stack pop
+                // - Raise (1): pops 1 exception
+                // - RaiseCause (2): pops 2 (exception + cause)
+                // - ReraiseFromStack (3): pops 1 exception from stack
+                match kind.get(arg) {
+                    RaiseKind::BareRaise => 0,
+                    RaiseKind::Raise => -1,
+                    RaiseKind::RaiseCause => -2,
+                    RaiseKind::ReraiseFromStack => -1,
+                }
+            }
             BuildString { size }
             | BuildTuple { size, .. }
             | BuildTupleFromTuples { size, .. }
@@ -1775,7 +2060,12 @@ impl Instruction {
             BuildSlice { argc } => {
                 // push 1
                 // pops either 2/3
-                1 - (argc.get(arg).argc().get() as i32)
+                // Default to Two (2 args) if arg is invalid
+                1 - (argc
+                    .try_get(arg)
+                    .unwrap_or(BuildSliceArgCount::Two)
+                    .argc()
+                    .get() as i32)
             }
             ListAppend { .. } | SetAdd { .. } => -1,
             MapAdd { .. } => -2,
@@ -1789,16 +2079,9 @@ impl Instruction {
             Reverse { .. } => 0,
             GetAwaitable => 0,
             BeforeAsyncWith => 1,
-            SetupAsyncWith { .. } => {
-                if jump {
-                    -1
-                } else {
-                    0
-                }
-            }
             GetAIter => 0,
             GetANext => 1,
-            EndAsyncFor => -2,
+            EndAsyncFor => -2,                 // pops (awaitable, exc) from stack
             MatchMapping | MatchSequence => 1, // Push bool result
             MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
             MatchClass(_) => -2,
@@ -1873,31 +2156,71 @@ impl Instruction {
             };
 
         match self {
+            // Dummy/placeholder instructions
+            Cache => w!(CACHE),
+            Reserved3 | Reserved17 | Reserved141 | Reserved142 | Reserved143 | Reserved144
+            | Reserved145 | Reserved146 | Reserved147 | Reserved148 => w!(RESERVED),
+            BinarySlice => w!(BINARY_SLICE),
+            EndFor => w!(END_FOR),
+            ExitInitCheck => w!(EXIT_INIT_CHECK),
+            GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            InterpreterExit => w!(INTERPRETER_EXIT),
+            LoadAssertionError => w!(LOAD_ASSERTION_ERROR),
+            LoadLocals => w!(LOAD_LOCALS),
+            PushNull => w!(PUSH_NULL),
+            ReturnGenerator => w!(RETURN_GENERATOR),
+            StoreSlice => w!(STORE_SLICE),
+            UnaryInvert => w!(UNARY_INVERT),
+            UnaryNegative => w!(UNARY_NEGATIVE),
+            UnaryNot => w!(UNARY_NOT),
+            BuildConstKeyMap { size } => w!(BUILD_CONST_KEY_MAP, size),
+            CopyFreeVars { count } => w!(COPY_FREE_VARS, count),
+            DictMerge { index } => w!(DICT_MERGE, index),
+            EnterExecutor { index } => w!(ENTER_EXECUTOR, index),
+            JumpBackward { target } => w!(JUMP_BACKWARD, target),
+            JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
+            JumpForward { target } => w!(JUMP_FORWARD, target),
+            ListExtend { i } => w!(LIST_EXTEND, i),
+            LoadFastCheck(idx) => w!(LOAD_FAST_CHECK, varname = idx),
+            LoadFastLoadFast { arg } => w!(LOAD_FAST_LOAD_FAST, arg),
+            LoadFromDictOrDeref(idx) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = idx),
+            LoadFromDictOrGlobals(idx) => w!(LOAD_FROM_DICT_OR_GLOBALS, name = idx),
+            LoadSuperAttr { arg } => w!(LOAD_SUPER_ATTR, arg),
+            MakeCell(idx) => w!(MAKE_CELL, cell_name = idx),
+            PopJumpIfNone { target } => w!(POP_JUMP_IF_NONE, target),
+            PopJumpIfNotNone { target } => w!(POP_JUMP_IF_NOT_NONE, target),
+            SetUpdate { i } => w!(SET_UPDATE, i),
+            StoreFastStoreFast { arg } => w!(STORE_FAST_STORE_FAST, arg),
+
+            // Real instructions
             BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
+            BeforeWith => w!(BEFORE_WITH),
             BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            BinarySubscript => w!(BINARY_SUBSCRIPT),
+            BinarySubscript => w!(BINARY_SUBSCR),
             Break { target } => w!(BREAK, target),
-            BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
             BuildList { size } => w!(BUILD_LIST, size),
-            BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
+            BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
             BuildMap { size } => w!(BUILD_MAP, size),
-            BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
+            BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
             BuildSet { size } => w!(BUILD_SET, size),
+            BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
             BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
             BuildString { size } => w!(BUILD_STRING, size),
+            BuildTuple { size } => w!(BUILD_TUPLE, size),
             BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
             BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
-            BuildTuple { size } => w!(BUILD_TUPLE, size),
             CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
-            CallFunctionKeyword { nargs } => w!(CALL_FUNCTION_KEYWORD, nargs),
-            CallFunctionPositional { nargs } => w!(CALL_FUNCTION_POSITIONAL, nargs),
+            CallFunctionKeyword { nargs } => w!(CALL_KW, nargs),
+            CallFunctionPositional { nargs } => w!(CALL, nargs),
             CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
             CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
-            CallMethodKeyword { nargs } => w!(CALL_METHOD_KEYWORD, nargs),
-            CallMethodPositional { nargs } => w!(CALL_METHOD_POSITIONAL, nargs),
+            CallMethodKeyword { nargs } => w!(CALL_METHOD_KW, nargs),
+            CallMethodPositional { nargs } => w!(CALL_METHOD, nargs),
             CheckEgMatch => w!(CHECK_EG_MATCH),
-            CompareOperation { op } => w!(COMPARE_OPERATION, ?op),
+            CheckExcMatch => w!(CHECK_EXC_MATCH),
+            CleanupThrow => w!(CLEANUP_THROW),
+            CompareOperation { op } => w!(COMPARE_OP, ?op),
             ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
             Continue { target } => w!(CONTINUE, target),
             ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
@@ -1906,12 +2229,11 @@ impl Instruction {
             DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
             DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
             DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
-            DeleteLocal(idx) => w!(DELETE_LOCAL, name = idx),
-            DeleteSubscript => w!(DELETE_SUBSCRIPT),
+            DeleteLocal(idx) => w!(DELETE_NAME, name = idx),
+            DeleteSubscript => w!(DELETE_SUBSCR),
             DictUpdate { index } => w!(DICT_UPDATE, index),
             EndAsyncFor => w!(END_ASYNC_FOR),
-            EndFinally => w!(END_FINALLY),
-            EnterFinally => w!(ENTER_FINALLY),
+            EndSend => w!(END_SEND),
             ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
             ForIter { target } => w!(FOR_ITER, target),
             FormatSimple => w!(FORMAT_SIMPLE),
@@ -1924,21 +2246,22 @@ impl Instruction {
             ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
             ImportName { idx } => w!(IMPORT_NAME, name = idx),
             IsOp(inv) => w!(IS_OP, ?inv),
+            Jump { target } => w!(JUMP, target),
             JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
             JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
             JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
-            Jump { target } => w!(JUMP, target),
             ListAppend { i } => w!(LIST_APPEND, i),
             LoadAttr { idx } => w!(LOAD_ATTR, name = idx),
             LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            LoadClassDeref(idx) => w!(LOAD_CLASS_DEREF, cell_name = idx),
+            LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
             LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
             LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
             LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
             LoadFast(idx) => w!(LOAD_FAST, varname = idx),
+            LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
             LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
             LoadMethod { idx } => w!(LOAD_METHOD, name = idx),
-            LoadNameAny(idx) => w!(LOAD_NAME_ANY, name = idx),
+            LoadNameAny(idx) => w!(LOAD_NAME, name = idx),
             MakeFunction => w!(MAKE_FUNCTION),
             MapAdd { i } => w!(MAP_ADD, i),
             MatchClass(arg) => w!(MATCH_CLASS, arg),
@@ -1947,40 +2270,43 @@ impl Instruction {
             MatchSequence => w!(MATCH_SEQUENCE),
             Nop => w!(NOP),
             PopBlock => w!(POP_BLOCK),
-            PopException => w!(POP_EXCEPTION),
+            PopException => w!(POP_EXCEPT),
             PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
             PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
             PopTop => w!(POP_TOP),
-            Raise { kind } => w!(RAISE, ?kind),
+            PushExcInfo => w!(PUSH_EXC_INFO),
+            Raise { kind } => w!(RAISE_VARARGS, ?kind),
+            Reraise { depth } => w!(RERAISE, depth),
             Resume { arg } => w!(RESUME, arg),
             ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
             ReturnValue => w!(RETURN_VALUE),
             Reverse { amount } => w!(REVERSE, amount),
+            Send { target } => w!(SEND, target),
             SetAdd { i } => w!(SET_ADD, i),
+            SetExcInfo => w!(SET_EXC_INFO),
             SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
-            SetupAnnotation => w!(SETUP_ANNOTATION),
-            SetupAsyncWith { end } => w!(SETUP_ASYNC_WITH, end),
-            SetupExcept { handler } => w!(SETUP_EXCEPT, handler),
-            SetupFinally { handler } => w!(SETUP_FINALLY, handler),
-            SetupLoop => w!(SETUP_LOOP),
-            SetupWith { end } => w!(SETUP_WITH, end),
+            SetupAnnotation => w!(SETUP_ANNOTATIONS),
             StoreAttr { idx } => w!(STORE_ATTR, name = idx),
             StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
-            SetExcInfo => w!(SET_EXC_INFO),
             StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                write!(f, "STORE_FAST_LOAD_FAST")?;
+                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
+            }
             StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            StoreLocal(idx) => w!(STORE_LOCAL, name = idx),
-            StoreSubscript => w!(STORE_SUBSCRIPT),
+            StoreLocal(idx) => w!(STORE_NAME, name = idx),
+            StoreSubscript => w!(STORE_SUBSCR),
             Subscript => w!(SUBSCRIPT),
             Swap { index } => w!(SWAP, index),
             ToBool => w!(TO_BOOL),
-            UnaryOperation { op } => w!(UNARY_OPERATION, ?op),
+            UnaryOperation { op } => w!(UNARY_OP, ?op),
             UnpackEx { args } => w!(UNPACK_EX, args),
             UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
-            WithCleanupFinish => w!(WITH_CLEANUP_FINISH),
-            WithCleanupStart => w!(WITH_CLEANUP_START),
-            YieldFrom => w!(YIELD_FROM),
-            YieldValue => w!(YIELD_VALUE),
+            WithExceptStart => w!(WITH_EXCEPT_START),
+            YieldValue { arg } => w!(YIELD_VALUE, arg),
         }
     }
 }
@@ -2037,3 +2363,74 @@ impl<C: Constant> fmt::Debug for CodeObject<C> {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_exception_table_encode_decode() {
+        let entries = vec![
+            ExceptionTableEntry::new(0, 10, 20, 2, false),
+            ExceptionTableEntry::new(15, 25, 30, 1, true),
+        ];
+
+        let encoded = encode_exception_table(&entries);
+
+        // Find handler at offset 5 (in range [0, 10))
+        let handler = find_exception_handler(&encoded, 5);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.start, 0);
+        assert_eq!(handler.end, 10);
+        assert_eq!(handler.target, 20);
+        assert_eq!(handler.depth, 2);
+        assert!(!handler.push_lasti);
+
+        // Find handler at offset 20 (in range [15, 25))
+        let handler = find_exception_handler(&encoded, 20);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.start, 15);
+        assert_eq!(handler.end, 25);
+        assert_eq!(handler.target, 30);
+        assert_eq!(handler.depth, 1);
+        assert!(handler.push_lasti);
+
+        // No handler at offset 12 (not in any range)
+        let handler = find_exception_handler(&encoded, 12);
+        assert!(handler.is_none());
+
+        // No handler at offset 30 (past all ranges)
+        let handler = find_exception_handler(&encoded, 30);
+        assert!(handler.is_none());
+    }
+
+    #[test]
+    fn test_exception_table_empty() {
+        let entries: Vec<ExceptionTableEntry> = vec![];
+        let encoded = encode_exception_table(&entries);
+        assert!(encoded.is_empty());
+        assert!(find_exception_handler(&encoded, 0).is_none());
+    }
+
+    #[test]
+    fn test_exception_table_single_entry() {
+        let entries = vec![ExceptionTableEntry::new(5, 15, 100, 3, true)];
+        let encoded = encode_exception_table(&entries);
+
+        // Inside range
+        let handler = find_exception_handler(&encoded, 10);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.target, 100);
+        assert_eq!(handler.depth, 3);
+        assert!(handler.push_lasti);
+
+        // At start boundary (inclusive)
+        assert!(find_exception_handler(&encoded, 5).is_some());
+
+        // At end boundary (exclusive)
+        assert!(find_exception_handler(&encoded, 15).is_none());
+    }
+}
diff --git a/crates/compiler-core/src/lib.rs b/crates/compiler-core/src/lib.rs
index 11246f6f44c..151d4cdea52 100644
--- a/crates/compiler-core/src/lib.rs
+++ b/crates/compiler-core/src/lib.rs
@@ -7,6 +7,7 @@ pub mod bytecode;
 pub mod frozen;
 pub mod marshal;
 mod mode;
+pub mod varint;
 
 pub use mode::Mode;
 
diff --git a/crates/compiler-core/src/varint.rs b/crates/compiler-core/src/varint.rs
new file mode 100644
index 00000000000..db8eb88b0e3
--- /dev/null
+++ b/crates/compiler-core/src/varint.rs
@@ -0,0 +1,138 @@
+//! Variable-length integer encoding utilities.
+//!
+//! Uses 6-bit chunks with a continuation bit (0x40) to encode integers.
+//! Used for exception tables and line number tables.
+
+/// Write a variable-length unsigned integer using 6-bit chunks.
+/// Returns the number of bytes written.
+#[inline]
+pub fn write_varint(buf: &mut Vec<u8>, mut val: u32) -> usize {
+    let start_len = buf.len();
+    while val >= 64 {
+        buf.push(0x40 | (val & 0x3f) as u8);
+        val >>= 6;
+    }
+    buf.push(val as u8);
+    buf.len() - start_len
+}
+
+/// Write a variable-length signed integer.
+/// Returns the number of bytes written.
+#[inline]
+pub fn write_signed_varint(buf: &mut Vec<u8>, val: i32) -> usize {
+    let uval = if val < 0 {
+        // (0 - val as u32) handles INT_MIN correctly
+        ((0u32.wrapping_sub(val as u32)) << 1) | 1
+    } else {
+        (val as u32) << 1
+    };
+    write_varint(buf, uval)
+}
+
+/// Write a variable-length unsigned integer with a start marker (0x80 bit).
+/// Used for exception table entries where each entry starts with the marker.
+pub fn write_varint_with_start(data: &mut Vec<u8>, val: u32) {
+    let start_pos = data.len();
+    write_varint(data, val);
+    // Set start bit on first byte
+    if let Some(first) = data.get_mut(start_pos) {
+        *first |= 0x80;
+    }
+}
+
+/// Read a variable-length unsigned integer that starts with a start marker (0x80 bit).
+/// Returns None if not at a valid start byte or end of data.
+pub fn read_varint_with_start(data: &[u8], pos: &mut usize) -> Option<u32> {
+    if *pos >= data.len() {
+        return None;
+    }
+    let first = data[*pos];
+    if first & 0x80 == 0 {
+        return None; // Not a start byte
+    }
+    *pos += 1;
+
+    let mut val = (first & 0x3f) as u32;
+    let mut shift = 6;
+    let mut has_continuation = first & 0x40 != 0;
+
+    while has_continuation && *pos < data.len() {
+        let byte = data[*pos];
+        if byte & 0x80 != 0 {
+            break; // Next entry start
+        }
+        *pos += 1;
+        val |= ((byte & 0x3f) as u32) << shift;
+        shift += 6;
+        has_continuation = byte & 0x40 != 0;
+    }
+    Some(val)
+}
+
+/// Read a variable-length unsigned integer.
+/// Returns None if end of data or malformed.
+pub fn read_varint(data: &[u8], pos: &mut usize) -> Option<u32> {
+    if *pos >= data.len() {
+        return None;
+    }
+
+    let mut val = 0u32;
+    let mut shift = 0;
+
+    loop {
+        if *pos >= data.len() {
+            return None;
+        }
+        let byte = data[*pos];
+        if byte & 0x80 != 0 && shift > 0 {
+            break; // Next entry start
+        }
+        *pos += 1;
+        val |= ((byte & 0x3f) as u32) << shift;
+        shift += 6;
+        if byte & 0x40 == 0 {
+            break;
+        }
+    }
+    Some(val)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_write_read_varint() {
+        let mut buf = Vec::new();
+        write_varint(&mut buf, 0);
+        write_varint(&mut buf, 63);
+        write_varint(&mut buf, 64);
+        write_varint(&mut buf, 4095);
+
+        // Values: 0, 63, 64, 4095
+        assert_eq!(buf.len(), 1 + 1 + 2 + 2);
+    }
+
+    #[test]
+    fn test_write_read_signed_varint() {
+        let mut buf = Vec::new();
+        write_signed_varint(&mut buf, 0);
+        write_signed_varint(&mut buf, 1);
+        write_signed_varint(&mut buf, -1);
+        write_signed_varint(&mut buf, i32::MIN);
+
+        assert!(!buf.is_empty());
+    }
+
+    #[test]
+    fn test_varint_with_start() {
+        let mut buf = Vec::new();
+        write_varint_with_start(&mut buf, 42);
+        write_varint_with_start(&mut buf, 100);
+
+        let mut pos = 0;
+        assert_eq!(read_varint_with_start(&buf, &mut pos), Some(42));
+        assert_eq!(read_varint_with_start(&buf, &mut pos), Some(100));
+        assert_eq!(read_varint_with_start(&buf, &mut pos), None);
+    }
+}
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 7f51a5a8a4b..e94bea86f59 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -172,12 +172,21 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 // Create or get the block for this label:
                 let target_block = self.get_or_create_block(label);
 
-                // If the current block isn't terminated, jump:
+                // If the current block isn't terminated, add a fallthrough jump
                 if let Some(cur) = self.builder.current_block()
                     && cur != target_block
-                    && self.builder.func.layout.last_inst(cur).is_none()
                 {
-                    self.builder.ins().jump(target_block, &[]);
+                    // Check if the block needs a terminator by examining the last instruction
+                    let needs_terminator = match self.builder.func.layout.last_inst(cur) {
+                        None => true, // Empty block needs terminator
+                        Some(inst) => {
+                            // Check if the last instruction is a terminator
+                            !self.builder.func.dfg.insts[inst].opcode().is_terminator()
+                        }
+                    };
+                    if needs_terminator {
+                        self.builder.ins().jump(target_block, &[]);
+                    }
                 }
                 // Switch to the target block
                 if self.builder.current_block() != Some(target_block) {
@@ -196,20 +205,26 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             // Actually compile this instruction:
             self.add_instruction(func_ref, bytecode, instruction, arg)?;
 
-            // If that was a return instruction, mark future instructions unreachable
+            // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
-                Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+                Instruction::ReturnValue
+                | Instruction::ReturnConst { .. }
+                | Instruction::Jump { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
             }
         }
 
-        // After processing, if the current block is unterminated, insert a trap or fallthrough
-        if let Some(cur) = self.builder.current_block()
-            && self.builder.func.layout.last_inst(cur).is_none()
-        {
-            self.builder.ins().trap(TrapCode::user(0).unwrap());
+        // After processing, if the current block is unterminated, insert a trap
+        if let Some(cur) = self.builder.current_block() {
+            let needs_terminator = match self.builder.func.layout.last_inst(cur) {
+                None => true,
+                Some(inst) => !self.builder.func.dfg.insts[inst].opcode().is_terminator(),
+            };
+            if needs_terminator {
+                self.builder.ins().trap(TrapCode::user(0).unwrap());
+            }
         }
         Ok(())
     }
@@ -594,12 +609,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::SetupLoop => {
-                let loop_head = self.builder.create_block();
-                self.builder.ins().jump(loop_head, &[]);
-                self.builder.switch_to_block(loop_head);
-                Ok(())
-            }
             Instruction::StoreFast(idx) => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.store_variable(idx.get(arg), val)
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index bd4b9aa750a..0b5c5c8120d 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -37,72 +37,137 @@ mod opcode {
             Ok(Self(instruction))
         }
 
-        /// https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Include/internal/pycore_opcode_metadata.h#L914-L916
+        /// Check if opcode is valid (can be converted to an Instruction)
         #[must_use]
-        pub const fn is_valid(opcode: i32) -> bool {
-            opcode >= 0 && opcode < 268 && opcode != 255
+        pub fn is_valid(opcode: i32) -> bool {
+            if !(0..=255).contains(&opcode) {
+                return false;
+            }
+            Instruction::try_from(opcode as u8).is_ok()
         }
 
-        // All `has_*` methods below mimics
-        // https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Include/internal/pycore_opcode_metadata.h#L966-L1190
-
+        /// Check if instruction has an argument
         #[must_use]
-        pub const fn has_arg(opcode: i32) -> bool {
+        pub fn has_arg(opcode: i32) -> bool {
             Self::is_valid(opcode) && opcode > Self::HAVE_ARGUMENT
         }
 
+        /// Check if instruction uses co_consts
         #[must_use]
-        pub const fn has_const(opcode: i32) -> bool {
-            Self::is_valid(opcode) && matches!(opcode, 83 | 103 | 240)
+        pub fn has_const(opcode: i32) -> bool {
+            if !Self::is_valid(opcode) {
+                return false;
+            }
+            if let Ok(instr) = Instruction::try_from(opcode as u8) {
+                matches!(
+                    instr,
+                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
+                )
+            } else {
+                false
+            }
         }
 
+        /// Check if instruction uses co_names
         #[must_use]
-        pub const fn has_name(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    opcode,
-                    63 | 66
-                        | 67
-                        | 74
-                        | 75
-                        | 82
-                        | 90
-                        | 91
-                        | 92
-                        | 93
-                        | 108
-                        | 113
-                        | 114
-                        | 259
-                        | 260
-                        | 261
-                        | 262
+        pub fn has_name(opcode: i32) -> bool {
+            if !Self::is_valid(opcode) {
+                return false;
+            }
+            if let Ok(instr) = Instruction::try_from(opcode as u8) {
+                matches!(
+                    instr,
+                    Instruction::DeleteAttr { .. }
+                        | Instruction::DeleteGlobal(_)
+                        | Instruction::DeleteLocal(_)
+                        | Instruction::ImportFrom { .. }
+                        | Instruction::ImportName { .. }
+                        | Instruction::LoadAttr { .. }
+                        | Instruction::LoadGlobal(_)
+                        | Instruction::LoadMethod { .. }
+                        | Instruction::LoadNameAny(_)
+                        | Instruction::StoreAttr { .. }
+                        | Instruction::StoreGlobal(_)
+                        | Instruction::StoreLocal(_)
                 )
+            } else {
+                false
+            }
         }
 
+        /// Check if instruction is a jump
         #[must_use]
-        pub const fn has_jump(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    opcode,
-                    72 | 77 | 78 | 79 | 97 | 98 | 99 | 100 | 104 | 256 | 257
+        pub fn has_jump(opcode: i32) -> bool {
+            if !Self::is_valid(opcode) {
+                return false;
+            }
+            if let Ok(instr) = Instruction::try_from(opcode as u8) {
+                matches!(
+                    instr,
+                    Instruction::Break { .. }
+                        | Instruction::Continue { .. }
+                        | Instruction::ForIter { .. }
+                        | Instruction::JumpIfFalseOrPop { .. }
+                        | Instruction::JumpIfNotExcMatch(_)
+                        | Instruction::JumpIfTrueOrPop { .. }
+                        | Instruction::Jump { .. }
+                        | Instruction::PopJumpIfFalse { .. }
+                        | Instruction::PopJumpIfTrue { .. }
+                        | Instruction::PopJumpIfNone { .. }
+                        | Instruction::PopJumpIfNotNone { .. }
+                        | Instruction::Send { .. }
                 )
+            } else {
+                false
+            }
         }
 
+        /// Check if instruction uses co_freevars/co_cellvars
         #[must_use]
-        pub const fn has_free(opcode: i32) -> bool {
-            Self::is_valid(opcode) && matches!(opcode, 64 | 84 | 89 | 94 | 109)
+        pub fn has_free(opcode: i32) -> bool {
+            if !Self::is_valid(opcode) {
+                return false;
+            }
+            if let Ok(instr) = Instruction::try_from(opcode as u8) {
+                matches!(
+                    instr,
+                    Instruction::DeleteDeref(_)
+                        | Instruction::LoadClassDeref(_)
+                        | Instruction::LoadClosure(_)
+                        | Instruction::LoadDeref(_)
+                        | Instruction::StoreDeref(_)
+                )
+            } else {
+                false
+            }
         }
 
+        /// Check if instruction uses co_varnames (local variables)
         #[must_use]
-        pub const fn has_local(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(opcode, 65 | 85 | 86 | 87 | 88 | 110 | 111 | 112 | 258 | 267)
+        pub fn has_local(opcode: i32) -> bool {
+            if !Self::is_valid(opcode) {
+                return false;
+            }
+            if let Ok(instr) = Instruction::try_from(opcode as u8) {
+                matches!(
+                    instr,
+                    Instruction::DeleteFast(_)
+                        | Instruction::LoadFast(_)
+                        | Instruction::LoadFastAndClear(_)
+                        | Instruction::StoreFast(_)
+                        | Instruction::StoreFastLoadFast { .. }
+                )
+            } else {
+                false
+            }
         }
 
+        /// Check if instruction has exception info
         #[must_use]
-        pub const fn has_exc(opcode: i32) -> bool {
-            Self::is_valid(opcode) && matches!(opcode, 264..=266)
+        pub fn has_exc(_opcode: i32) -> bool {
+            // No instructions have exception info in RustPython
+            // (exception handling is done via exception table)
+            false
         }
     }
 
diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 9218ccc8a43..e16cbc6d18d 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -8,7 +8,7 @@ use crate::{
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter},
+    types::{Destructor, IterNext, Iterable, Representable, SelfIter},
 };
 
 use crossbeam_utils::atomic::AtomicCell;
@@ -32,7 +32,7 @@ impl PyPayload for PyAsyncGen {
     }
 }
 
-#[pyclass(flags(DISALLOW_INSTANTIATION), with(PyRef, Representable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(PyRef, Representable, Destructor))]
 impl PyAsyncGen {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
@@ -73,15 +73,13 @@ impl PyAsyncGen {
         Ok(())
     }
 
-    /// Call finalizer hook if set
-    #[allow(dead_code)]
+    /// Call finalizer hook if set.
     fn call_finalizer(zelf: &Py<Self>, vm: &VirtualMachine) {
-        // = gen_dealloc
         let finalizer = zelf.ag_finalizer.lock().clone();
         if let Some(finalizer) = finalizer
             && !zelf.inner.closed.load()
         {
-            // Call finalizer, ignore any errors (PyErr_WriteUnraisable)
+            // Ignore any errors (PyErr_WriteUnraisable)
             let obj: PyObjectRef = zelf.to_owned().into();
             let _ = finalizer.call((obj,), vm);
         }
@@ -646,6 +644,19 @@ impl IterNext for PyAnextAwaitable {
     }
 }
 
+/// _PyGen_Finalize for async generators
+impl Destructor for PyAsyncGen {
+    fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+        // Generator isn't paused, so no need to close
+        if zelf.inner.closed.load() {
+            return Ok(());
+        }
+
+        Self::call_finalizer(zelf, vm);
+        Ok(())
+    }
+}
+
 pub fn init(ctx: &Context) {
     PyAsyncGen::extend_class(ctx, ctx.types.async_generator);
     PyAsyncGenASend::extend_class(ctx, ctx.types.async_generator_asend);
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index 32e53a5d376..111702eac6c 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -1004,7 +1004,26 @@ impl PyCode {
         let idx_err = |vm: &VirtualMachine| vm.new_index_error("tuple index out of range");
 
         let idx = usize::try_from(opcode).map_err(|_| idx_err(vm))?;
-        let name = self.code.varnames.get(idx).ok_or_else(|| idx_err(vm))?;
+
+        let varnames_len = self.code.varnames.len();
+        let cellvars_len = self.code.cellvars.len();
+
+        let name = if idx < varnames_len {
+            // Index in varnames
+            self.code.varnames.get(idx).ok_or_else(|| idx_err(vm))?
+        } else if idx < varnames_len + cellvars_len {
+            // Index in cellvars
+            self.code
+                .cellvars
+                .get(idx - varnames_len)
+                .ok_or_else(|| idx_err(vm))?
+        } else {
+            // Index in freevars
+            self.code
+                .freevars
+                .get(idx - varnames_len - cellvars_len)
+                .ok_or_else(|| idx_err(vm))?
+        };
         Ok(name.to_object())
     }
 }
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
index 13dde152391..19830496e6e 100644
--- a/crates/vm/src/coroutine.rs
+++ b/crates/vm/src/coroutine.rs
@@ -81,11 +81,29 @@ impl Coro {
             return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
         }
 
-        vm.push_exception(self.exception.lock().take());
+        // swap exception state
+        // Get generator's saved exception state from last yield
+        let gen_exc = self.exception.lock().take();
 
-        let result = vm.with_frame(self.frame.clone(), func);
+        // Use a slot to capture generator's exception state before with_frame pops
+        let exception_slot = &self.exception;
 
-        *self.exception.lock() = vm.pop_exception();
+        // Run the generator frame
+        // with_frame does push_exception(None) which creates a new exception context
+        // The caller's exception remains in the chain via prev, so topmost_exception()
+        // will find it if generator's exception is None
+        let result = vm.with_frame(self.frame.clone(), |f| {
+            // with_frame pushed None, creating: { exc: None, prev: caller's exc_info }
+            // Pop None and push generator's exception instead
+            // This maintains the chain: { exc: gen_exc, prev: caller's exc_info }
+            vm.pop_exception();
+            vm.push_exception(gen_exc);
+            let result = func(f);
+            // Save generator's exception state BEFORE with_frame pops
+            // This is the generator's current exception context
+            *exception_slot.lock() = vm.current_exception();
+            result
+        });
 
         self.running.store(false);
         result
@@ -153,6 +171,11 @@ impl Coro {
         if self.closed.load() {
             return Ok(());
         }
+        // If generator hasn't started (FRAME_CREATED), just mark as closed
+        if self.frame.lasti() == 0 {
+            self.closed.store(true);
+            return Ok(());
+        }
         let result = self.run_with_context(jen, vm, |f| {
             f.gen_throw(
                 vm,
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 1f74d07f87c..f066e2fabcb 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -27,34 +27,6 @@ use itertools::Itertools;
 use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
 use rustpython_compiler_core::SourceLocation;
 
-#[derive(Clone, Debug)]
-struct Block {
-    /// The type of block.
-    typ: BlockType,
-    /// The level of the value stack when the block was entered.
-    level: usize,
-}
-
-#[derive(Clone, Debug)]
-enum BlockType {
-    Loop,
-    TryExcept {
-        handler: bytecode::Label,
-    },
-    Finally {
-        handler: bytecode::Label,
-    },
-
-    /// Active finally sequence
-    FinallyHandler {
-        reason: Option<UnwindReason>,
-        prev_exc: Option<PyBaseExceptionRef>,
-    },
-    ExceptHandler {
-        prev_exc: Option<PyBaseExceptionRef>,
-    },
-}
-
 pub type FrameRef = PyRef<Frame>;
 
 /// The reason why we might be unwinding a block.
@@ -82,8 +54,6 @@ struct FrameState {
     // We need 1 stack per frame
     /// The main data frame of the stack machine
     stack: BoxVec<PyObjectRef>,
-    /// Block frames, for controlling loops and exceptions
-    blocks: Vec<Block>,
     /// index of last instruction ran
     #[cfg(feature = "threading")]
     lasti: u32,
@@ -150,7 +120,6 @@ impl Frame {
 
         let state = FrameState {
             stack: BoxVec::new(code.max_stackdepth as usize),
-            blocks: Vec::new(),
             #[cfg(feature = "threading")]
             lasti: 0,
         };
@@ -379,34 +348,73 @@ impl ExecutingFrame<'_> {
                         frame: &mut ExecutingFrame<'_>,
                         exception: PyBaseExceptionRef,
                         idx: usize,
+                        is_reraise: bool,
                         vm: &VirtualMachine,
                     ) -> FrameResult {
                         // 1. Extract traceback from exception's '__traceback__' attr.
                         // 2. Add new entry with current execution position (filename, lineno, code_object) to traceback.
-                        // 3. Unwind block stack till appropriate handler is found.
-
-                        let (loc, _end_loc) = frame.code.locations[idx];
-                        let next = exception.__traceback__();
-                        let new_traceback = PyTraceback::new(
-                            next,
-                            frame.object.to_owned(),
-                            frame.lasti() * 2,
-                            loc.line,
-                        );
-                        vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.line);
-                        exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                        // 3. First, try to find handler in exception table
+
+                        // RERAISE instructions should not add traceback entries - they're just
+                        // re-raising an already-processed exception
+                        if !is_reraise {
+                            // PyTraceBack_Here always adds a new entry without
+                            // checking for duplicates. Each time an exception passes through
+                            // a frame (e.g., in a loop with repeated raise statements),
+                            // a new traceback entry is added.
+                            let (loc, _end_loc) = frame.code.locations[idx];
+                            let next = exception.__traceback__();
+
+                            let new_traceback = PyTraceback::new(
+                                next,
+                                frame.object.to_owned(),
+                                idx as u32 * 2,
+                                loc.line,
+                            );
+                            vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.line);
+                            exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                        }
 
-                        vm.contextualize_exception(&exception);
+                        // Only contextualize exception for new raises, not re-raises
+                        // CPython only calls _PyErr_SetObject (which does chaining) on initial raise
+                        // RERAISE just propagates the exception without modifying __context__
+                        if !is_reraise {
+                            vm.contextualize_exception(&exception);
+                        }
 
+                        // Use exception table for zero-cost exception handling
                         frame.unwind_blocks(vm, UnwindReason::Raising { exception })
                     }
 
-                    match handle_exception(self, exception, idx, vm) {
+                    // Check if this is a RERAISE instruction
+                    // Both Instruction::Raise { kind: Reraise/ReraiseFromStack } and
+                    // Instruction::Reraise are reraise operations that should not add
+                    // new traceback entries
+                    let is_reraise = match op {
+                        bytecode::Instruction::Raise { kind } => matches!(
+                            kind.get(arg),
+                            bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
+                        ),
+                        bytecode::Instruction::Reraise { .. } => true,
+                        _ => false,
+                    };
+
+                    match handle_exception(self, exception, idx, is_reraise, vm) {
                         Ok(None) => {}
                         Ok(Some(result)) => break Ok(result),
-                        // TODO: append line number to traceback?
-                        // traceback.append();
-                        Err(exception) => break Err(exception),
+                        Err(exception) => {
+                            // Restore lasti from traceback so frame.f_lineno matches tb_lineno
+                            // The traceback was created with the correct lasti when exception
+                            // was first raised, but frame.lasti may have changed during cleanup
+                            if let Some(tb) = exception.__traceback__()
+                                && core::ptr::eq::<Py<Frame>>(&*tb.frame, self.object)
+                            {
+                                // This traceback entry is for this frame - restore its lasti
+                                // tb.lasti is in bytes (idx * 2), convert back to instruction index
+                                self.update_lasti(|i| *i = tb.lasti / 2);
+                            }
+                            break Err(exception);
+                        }
                     }
                 }
             }
@@ -417,19 +425,43 @@ impl ExecutingFrame<'_> {
     }
 
     fn yield_from_target(&self) -> Option<&PyObject> {
-        if let Some(bytecode::CodeUnit {
-            op: bytecode::Instruction::YieldFrom,
-            ..
-        }) = self.code.instructions.get(self.lasti() as usize)
-        {
-            Some(self.top_value())
-        } else {
-            None
+        // checks gi_frame_state == FRAME_SUSPENDED_YIELD_FROM
+        // which is set when YIELD_VALUE with oparg >= 1 is executed.
+        // In RustPython, we check:
+        // 1. lasti points to RESUME (after YIELD_VALUE)
+        // 2. The previous instruction was YIELD_VALUE with arg >= 1
+        // 3. Stack top is the delegate (receiver)
+        //
+        // First check if stack is empty - if so, we can't be in yield-from
+        if self.state.stack.is_empty() {
+            return None;
+        }
+        let lasti = self.lasti() as usize;
+        if let Some(unit) = self.code.instructions.get(lasti) {
+            match &unit.op {
+                bytecode::Instruction::Send { .. } => return Some(self.top_value()),
+                bytecode::Instruction::Resume { .. } => {
+                    // Check if previous instruction was YIELD_VALUE with arg >= 1
+                    // This indicates yield-from/await context
+                    if lasti > 0
+                        && let Some(prev_unit) = self.code.instructions.get(lasti - 1)
+                        && let bytecode::Instruction::YieldValue { .. } = &prev_unit.op
+                    {
+                        // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
+                        // OpArgByte.0 is the raw byte value
+                        if prev_unit.arg.0 >= 1 {
+                            // In yield-from/await context, delegate is on top of stack
+                            return Some(self.top_value());
+                        }
+                    }
+                }
+                _ => {}
+            }
         }
+        None
     }
 
-    /// Ok(Err(e)) means that an error occurred while calling throw() and the generator should try
-    /// sending it
+    /// Handle throw() on a generator/coroutine.
     fn gen_throw(
         &mut self,
         vm: &VirtualMachine,
@@ -450,24 +482,48 @@ impl ExecutingFrame<'_> {
                 let ret = match thrower {
                     Either::A(coro) => coro
                         .throw(jen, exc_type, exc_val, exc_tb, vm)
-                        .to_pyresult(vm), // FIXME:
+                        .to_pyresult(vm),
                     Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
                 };
                 return ret.map(ExecutionResult::Yield).or_else(|err| {
-                    self.pop_value();
-                    self.update_lasti(|i| *i += 1);
-                    if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
-                        let val = vm.unwrap_or_none(err.get_arg(0));
-                        self.push_value(val);
-                        self.run(vm)
-                    } else {
-                        let (ty, val, tb) = vm.split_exception(err);
-                        self.gen_throw(vm, ty, val, tb)
+                    // This pushes Py_None to stack and restarts evalloop in exception mode.
+                    // Stack before throw: [receiver] (YIELD_VALUE already popped yielded value)
+                    // After pushing None: [receiver, None]
+                    // Exception handler will push exc: [receiver, None, exc]
+                    // CLEANUP_THROW expects: [sub_iter, last_sent_val, exc]
+                    self.push_value(vm.ctx.none());
+
+                    // Use unwind_blocks to let exception table route to CLEANUP_THROW
+                    match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
+                        Ok(None) => self.run(vm),
+                        Ok(Some(result)) => Ok(result),
+                        Err(exception) => Err(exception),
                     }
                 });
             }
         }
+        // throw_here: no delegate has throw method, or not in yield-from
+        // gen_send_ex pushes Py_None to stack and restarts evalloop in exception mode
         let exception = vm.normalize_exception(exc_type, exc_val, exc_tb)?;
+
+        // Add traceback entry for the generator frame at the yield site
+        let idx = self.lasti().saturating_sub(1) as usize;
+        if idx < self.code.locations.len() {
+            let (loc, _end_loc) = self.code.locations[idx];
+            let next = exception.__traceback__();
+            let new_traceback =
+                PyTraceback::new(next, self.object.to_owned(), idx as u32 * 2, loc.line);
+            exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+        }
+
+        // when raising an exception, set __context__ to the current exception
+        // This is done in _PyErr_SetObject
+        vm.contextualize_exception(&exception);
+
+        // always pushes Py_None before calling gen_send_ex with exc=1
+        // This is needed for exception handler to have correct stack state
+        self.push_value(vm.ctx.none());
+
         match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
             Ok(None) => self.run(vm),
             Ok(Some(result)) => Ok(result),
@@ -724,14 +780,15 @@ impl ExecutingFrame<'_> {
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
                 let idx = index.get(arg) as usize;
-                let value = self
-                    .state
-                    .stack
-                    .len()
-                    .checked_sub(idx)
-                    .map(|i| &self.state.stack[i])
-                    .unwrap();
-                self.push_value(value.clone());
+                let stack_len = self.state.stack.len();
+                if stack_len < idx {
+                    eprintln!("CopyItem ERROR: stack_len={}, idx={}", stack_len, idx);
+                    eprintln!("  code: {}", self.code.obj_name);
+                    eprintln!("  lasti: {}", self.lasti());
+                    panic!("CopyItem: stack underflow");
+                }
+                let value = self.state.stack[stack_len - idx].clone();
+                self.push_value(value);
                 Ok(None)
             }
             bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
@@ -816,42 +873,25 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::EndAsyncFor => {
+                // END_ASYNC_FOR pops (awaitable, exc) from stack
+                // Stack: [awaitable, exc] -> []
+                // exception_unwind pushes exception to stack before jumping to handler
                 let exc = self.pop_value();
-                let except_block = self.pop_block(); // pushed by TryExcept unwind
-                debug_assert_eq!(except_block.level, self.state.stack.len());
-                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
+                let _awaitable = self.pop_value();
+
+                let exc = exc
+                    .downcast::<PyBaseException>()
+                    .expect("EndAsyncFor expects exception on stack");
+
                 if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
-                    vm.take_exception().expect("Should have exception in stack");
+                    // StopAsyncIteration - normal end of async for loop
+                    vm.set_exception(None);
                     Ok(None)
                 } else {
-                    Err(exc.downcast().unwrap())
-                }
-            }
-            bytecode::Instruction::EndFinally => {
-                // Pop the finally handler from the stack, and recall
-                // what was the reason we were in this finally clause.
-                let block = self.pop_block();
-
-                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    if let Some(reason) = reason {
-                        self.unwind_blocks(vm, reason)
-                    } else {
-                        Ok(None)
-                    }
-                } else {
-                    self.fatal(
-                        "Block type must be finally handler when reaching EndFinally instruction!",
-                    );
+                    // Other exception - re-raise
+                    Err(exc)
                 }
             }
-            bytecode::Instruction::EnterFinally => {
-                self.push_block(BlockType::FinallyHandler {
-                    reason: None,
-                    prev_exc: vm.current_exception(),
-                });
-                Ok(None)
-            }
             bytecode::Instruction::ExtendedArg => {
                 *extend_arg = true;
                 Ok(None)
@@ -927,7 +967,13 @@ impl ExecutingFrame<'_> {
                 use crate::protocol::PyIter;
 
                 let awaited_obj = self.pop_value();
-                let awaitable = if awaited_obj.downcastable::<PyCoroutine>() {
+                let awaitable = if let Some(coro) = awaited_obj.downcast_ref::<PyCoroutine>() {
+                    // _PyGen_yf() check - detect if coroutine is already being awaited elsewhere
+                    if coro.as_coro().frame().yield_from_target().is_some() {
+                        return Err(
+                            vm.new_runtime_error("coroutine is being awaited already".to_owned())
+                        );
+                    }
                     awaited_obj
                 } else {
                     let await_method = vm.get_method_or_type_error(
@@ -959,6 +1005,35 @@ impl ExecutingFrame<'_> {
                 self.push_value(iter_obj.into());
                 Ok(None)
             }
+            bytecode::Instruction::GetYieldFromIter => {
+                // GET_YIELD_FROM_ITER: prepare iterator for yield from
+                // If iterable is a coroutine, ensure we're in a coroutine context
+                // If iterable is a generator, use it directly
+                // Otherwise, call iter() on it
+                let iterable = self.pop_value();
+                let iter = if iterable.class().is(vm.ctx.types.coroutine_type) {
+                    // Coroutine requires CO_COROUTINE or CO_ITERABLE_COROUTINE flag
+                    if !self
+                        .code
+                        .flags
+                        .intersects(bytecode::CodeFlags::IS_COROUTINE)
+                    {
+                        return Err(vm.new_type_error(
+                            "cannot 'yield from' a coroutine object in a non-coroutine generator"
+                                .to_owned(),
+                        ));
+                    }
+                    iterable
+                } else if iterable.class().is(vm.ctx.types.generator_type) {
+                    // Generator can be used directly
+                    iterable
+                } else {
+                    // Otherwise, get iterator
+                    iterable.get_iter(vm)?.into()
+                };
+                self.push_value(iter);
+                Ok(None)
+            }
             bytecode::Instruction::GetLen => {
                 // STACK.append(len(STACK[-1]))
                 let obj = self.top_value();
@@ -1086,6 +1161,16 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
+            bytecode::Instruction::LoadFastAndClear(idx) => {
+                // Load value and clear the slot (for inlined comprehensions)
+                // If slot is empty, push None (not an error - variable may not exist yet)
+                let idx = idx.get(arg) as usize;
+                let x = self.fastlocals.lock()[idx]
+                    .take()
+                    .unwrap_or_else(|| vm.ctx.none());
+                self.push_value(x);
+                Ok(None)
+            }
             bytecode::Instruction::LoadGlobal(idx) => {
                 let name = &self.code.names[idx.get(arg) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
@@ -1273,8 +1358,6 @@ impl ExecutingFrame<'_> {
                         .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
                         .transpose()?
                     {
-                        // dummy = object()
-                        // CPython: dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
                         let dummy = vm
                             .ctx
                             .new_base_object(vm.ctx.types.object_type.to_owned(), None);
@@ -1343,18 +1426,25 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::PopBlock => {
-                self.pop_block();
-                Ok(None)
-            }
+            // PopBlock is now a pseudo-instruction - exception table handles this
+            bytecode::Instruction::PopBlock => Ok(None),
             bytecode::Instruction::PopException => {
-                let block = self.pop_block();
-                if let BlockType::ExceptHandler { prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    Ok(None)
-                } else {
-                    self.fatal("block type must be ExceptHandler here.")
+                // Pop prev_exc from value stack and restore it
+                let prev_exc = self.pop_value();
+                if vm.is_none(&prev_exc) {
+                    vm.set_exception(None);
+                } else if let Ok(exc) = prev_exc.downcast::<PyBaseException>() {
+                    vm.set_exception(Some(exc));
                 }
+
+                // NOTE: We do NOT clear the traceback of the exception that was just handled.
+                // Python preserves exception tracebacks even after the exception is no longer
+                // the "current exception". This is important for code that catches an exception,
+                // stores it, and later inspects its traceback.
+                // Reference cycles (Exception → Traceback → Frame → locals) are handled by
+                // Python's garbage collector which can detect and break cycles.
+
+                Ok(None)
             }
             bytecode::Instruction::PopJumpIfFalse { target } => {
                 self.pop_jump_if(vm, target.get(arg), false)
@@ -1412,35 +1502,67 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::SetFunctionAttribute { attr } => {
-                self.execute_set_function_attribute(vm, attr.get(arg))
-            }
-            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
-            bytecode::Instruction::SetupAsyncWith { end } => {
-                let enter_res = self.pop_value();
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
+            bytecode::Instruction::PushExcInfo => {
+                // Stack: [exc] -> [prev_exc, exc]
+                let exc = self.pop_value();
+                let prev_exc = vm
+                    .current_exception()
+                    .map(|e| e.into())
+                    .unwrap_or_else(|| vm.ctx.none());
+
+                // Set exc as the current exception
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>() {
+                    vm.set_exception(Some(exc_ref.to_owned()));
+                }
+
+                self.push_value(prev_exc);
+                self.push_value(exc);
                 Ok(None)
             }
-            bytecode::Instruction::SetupExcept { handler } => {
-                self.push_block(BlockType::TryExcept {
-                    handler: handler.get(arg),
-                });
+            bytecode::Instruction::CheckExcMatch => {
+                // Stack: [exc, type] -> [exc, bool]
+                let exc_type = self.pop_value();
+                let exc = self.top_value();
+
+                // Validate that exc_type is valid for exception matching
+                let result = exc.is_instance(&exc_type, vm)?;
+                self.push_value(vm.ctx.new_bool(result).into());
                 Ok(None)
             }
-            bytecode::Instruction::SetupFinally { handler } => {
-                self.push_block(BlockType::Finally {
-                    handler: handler.get(arg),
-                });
-                Ok(None)
+            bytecode::Instruction::Reraise { depth } => {
+                // inst(RERAISE, (values[oparg], exc -- values[oparg]))
+                //
+                // Stack layout: [values..., exc] where len(values) == oparg
+                // RERAISE pops exc and oparg additional values from the stack.
+                // values[0] is lasti used to set frame->instr_ptr for traceback.
+                // We skip the lasti update since RustPython's traceback is already correct.
+                let depth_val = depth.get(arg) as usize;
+
+                // Pop exception from TOS
+                let exc = self.pop_value();
+
+                // Pop the depth values (lasti and possibly other items like prev_exc)
+                for _ in 0..depth_val {
+                    self.pop_value();
+                }
+
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>() {
+                    Err(exc_ref.to_owned())
+                } else {
+                    // Fallback: use current exception if TOS is not an exception
+                    let exc = vm
+                        .topmost_exception()
+                        .ok_or_else(|| vm.new_runtime_error("No active exception to re-raise"))?;
+                    Err(exc)
+                }
             }
-            bytecode::Instruction::SetupLoop => {
-                self.push_block(BlockType::Loop);
-                Ok(None)
+            bytecode::Instruction::SetFunctionAttribute { attr } => {
+                self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            bytecode::Instruction::SetupWith { end } => {
+            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
+            bytecode::Instruction::BeforeWith => {
+                // TOS: context_manager
+                // Result: [..., __exit__, __enter__ result]
                 let context_manager = self.pop_value();
                 let error_string = || -> String {
                     format!(
@@ -1448,22 +1570,22 @@ impl ExecutingFrame<'_> {
                         context_manager.class().name(),
                     )
                 };
-                let enter_res = vm
-                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
 
+                // Get __exit__ first (before calling __enter__)
                 let exit = context_manager
                     .get_attr(identifier!(vm, __exit__), vm)
                     .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __exit__ method)", error_string())
-                        })
+                        vm.new_type_error(format!("{} (missed __exit__ method)", error_string()))
                     })?;
+
+                // Get and call __enter__
+                let enter_res = vm
+                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
+
+                // Push __exit__ first, then enter result
                 self.push_value(exit);
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
                 self.push_value(enter_res);
                 Ok(None)
             }
@@ -1478,6 +1600,21 @@ impl ExecutingFrame<'_> {
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
+            bytecode::Instruction::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                // Store to one slot and load from another (often the same) - for inlined comprehensions
+                let value = self.pop_value();
+                let mut locals = self.fastlocals.lock();
+                locals[store_idx.get(arg) as usize] = Some(value);
+                let load_value = locals[load_idx.get(arg) as usize]
+                    .clone()
+                    .expect("StoreFastLoadFast: load slot should have value after store");
+                drop(locals);
+                self.push_value(load_value);
+                Ok(None)
+            }
             bytecode::Instruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
@@ -1523,58 +1660,156 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::UnpackSequence { size } => {
                 self.unpack_sequence(size.get(arg), vm)
             }
-            bytecode::Instruction::WithCleanupFinish => {
-                let block = self.pop_block();
-                let (reason, prev_exc) = match block.typ {
-                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
-                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
-                };
-
-                vm.set_exception(prev_exc);
-
-                let suppress_exception = self.pop_value().try_to_bool(vm)?;
+            bytecode::Instruction::WithExceptStart => {
+                // Stack: [..., __exit__, lasti, prev_exc, exc]
+                // Call __exit__(type, value, tb) and push result
+                // __exit__ is at TOS-3 (below lasti, prev_exc, and exc)
+                let exc = vm.current_exception();
 
-                if suppress_exception {
-                    Ok(None)
-                } else if let Some(reason) = reason {
-                    self.unwind_blocks(vm, reason)
-                } else {
-                    Ok(None)
-                }
-            }
-            bytecode::Instruction::WithCleanupStart => {
-                let block = self.current_block().unwrap();
-                let reason = match block.typ {
-                    BlockType::FinallyHandler { reason, .. } => reason,
-                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
-                };
-                let exc = match reason {
-                    Some(UnwindReason::Raising { exception }) => Some(exception),
-                    _ => None,
-                };
-
-                let exit = self.top_value();
+                let stack_len = self.state.stack.len();
+                let exit = self.state.stack[stack_len - 4].clone();
 
-                let args = if let Some(exc) = exc {
-                    vm.split_exception(exc)
+                let args = if let Some(ref exc) = exc {
+                    vm.split_exception(exc.clone())
                 } else {
                     (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
                 };
                 let exit_res = exit.call(args, vm)?;
-                self.replace_top(exit_res);
+                // Push result on top of stack
+                self.push_value(exit_res);
 
                 Ok(None)
             }
-            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
-            bytecode::Instruction::YieldValue => {
+            bytecode::Instruction::YieldValue { arg: oparg } => {
                 let value = self.pop_value();
-                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
+                // arg=0: direct yield (wrapped for async generators)
+                // arg=1: yield from await/yield-from (NOT wrapped)
+                let wrap = oparg.get(arg) == 0;
+                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
                     PyAsyncGenWrappedValue(value).into_pyobject(vm)
                 } else {
                     value
                 };
                 Ok(Some(ExecutionResult::Yield(value)))
             }
+            bytecode::Instruction::Send { target } => {
+                // Stack: (receiver, value) -> (receiver, retval)
+                // On StopIteration: replace value with stop value and jump to target
+                let exit_label = target.get(arg);
+                let val = self.pop_value();
+                let receiver = self.top_value();
+
+                match self._send(receiver, val, vm)? {
+                    PyIterReturn::Return(value) => {
+                        // Value yielded, push it back for YIELD_VALUE
+                        // Stack: (receiver, retval)
+                        self.push_value(value);
+                        Ok(None)
+                    }
+                    PyIterReturn::StopIteration(value) => {
+                        // StopIteration: replace top with stop value, jump to exit
+                        // Stack: (receiver, value) - receiver stays, v replaced
+                        let value = vm.unwrap_or_none(value);
+                        self.push_value(value);
+                        self.jump(exit_label);
+                        Ok(None)
+                    }
+                }
+            }
+            bytecode::Instruction::EndSend => {
+                // Stack: (receiver, value) -> (value)
+                // Pops receiver, leaves value
+                let value = self.pop_value();
+                self.pop_value(); // discard receiver
+                self.push_value(value);
+                Ok(None)
+            }
+            bytecode::Instruction::CleanupThrow => {
+                // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) OR re-raise
+                // If StopIteration: pop all 3, extract value, push (None, value)
+                // Otherwise: pop all 3, return Err(exc) for unwind_blocks to handle
+                //
+                // Unlike CPython where exception_unwind pops the triple as part of
+                // stack cleanup to handler depth, RustPython pops here explicitly
+                // and lets unwind_blocks find outer handlers.
+                // Compiler sets handler_depth = base + 2 (before exc is pushed).
+
+                // First peek at exc_value (top of stack) without popping
+                let exc = self.top_value();
+
+                // Check if it's a StopIteration
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>()
+                    && exc_ref.fast_isinstance(vm.ctx.exceptions.stop_iteration)
+                {
+                    // Extract value from StopIteration
+                    let value = exc_ref.get_arg(0).unwrap_or_else(|| vm.ctx.none());
+                    // Now pop all three
+                    self.pop_value(); // exc
+                    self.pop_value(); // last_sent_val
+                    self.pop_value(); // sub_iter
+                    self.push_value(vm.ctx.none());
+                    self.push_value(value);
+                    return Ok(None);
+                }
+
+                // Re-raise other exceptions: pop all three and return Err(exc)
+                let exc = self.pop_value(); // exc
+                self.pop_value(); // last_sent_val
+                self.pop_value(); // sub_iter
+
+                let exc = exc
+                    .downcast::<PyBaseException>()
+                    .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
+                Err(exc)
+            }
+
+            // Placeholder/dummy instructions - these should never be executed
+            bytecode::Instruction::Cache
+            | bytecode::Instruction::Reserved3
+            | bytecode::Instruction::Reserved17
+            | bytecode::Instruction::BinarySlice
+            | bytecode::Instruction::EndFor
+            | bytecode::Instruction::ExitInitCheck
+            | bytecode::Instruction::InterpreterExit
+            | bytecode::Instruction::LoadAssertionError
+            | bytecode::Instruction::LoadLocals
+            | bytecode::Instruction::PushNull
+            | bytecode::Instruction::ReturnGenerator
+            | bytecode::Instruction::StoreSlice
+            | bytecode::Instruction::UnaryInvert
+            | bytecode::Instruction::UnaryNegative
+            | bytecode::Instruction::UnaryNot
+            | bytecode::Instruction::BuildConstKeyMap { .. }
+            | bytecode::Instruction::CopyFreeVars { .. }
+            | bytecode::Instruction::DictMerge { .. }
+            | bytecode::Instruction::EnterExecutor { .. }
+            | bytecode::Instruction::JumpBackward { .. }
+            | bytecode::Instruction::JumpBackwardNoInterrupt { .. }
+            | bytecode::Instruction::JumpForward { .. }
+            | bytecode::Instruction::ListExtend { .. }
+            | bytecode::Instruction::LoadFastCheck(_)
+            | bytecode::Instruction::LoadFastLoadFast { .. }
+            | bytecode::Instruction::LoadFromDictOrDeref(_)
+            | bytecode::Instruction::LoadFromDictOrGlobals(_)
+            | bytecode::Instruction::LoadSuperAttr { .. }
+            | bytecode::Instruction::MakeCell(_)
+            | bytecode::Instruction::PopJumpIfNone { .. }
+            | bytecode::Instruction::PopJumpIfNotNone { .. }
+            | bytecode::Instruction::SetUpdate { .. }
+            | bytecode::Instruction::StoreFastStoreFast { .. }
+            | bytecode::Instruction::Reserved141
+            | bytecode::Instruction::Reserved142
+            | bytecode::Instruction::Reserved143
+            | bytecode::Instruction::Reserved144
+            | bytecode::Instruction::Reserved145
+            | bytecode::Instruction::Reserved146
+            | bytecode::Instruction::Reserved147
+            | bytecode::Instruction::Reserved148 => {
+                unreachable!(
+                    "placeholder instruction should not be executed: {:?}",
+                    instruction
+                )
+            }
         }
     }
 
@@ -1684,61 +1919,48 @@ impl ExecutingFrame<'_> {
     /// Optionally returns an exception.
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn unwind_blocks(&mut self, vm: &VirtualMachine, reason: UnwindReason) -> FrameResult {
-        // First unwind all existing blocks on the block stack:
-        while let Some(block) = self.current_block() {
-            // eprintln!("unwinding block: {:.60?} {:.60?}", block.typ, reason);
-            match block.typ {
-                BlockType::Loop => match reason {
-                    UnwindReason::Break { target } => {
-                        self.pop_block();
-                        self.jump(target);
-                        return Ok(None);
-                    }
-                    UnwindReason::Continue { target } => {
-                        self.jump(target);
-                        return Ok(None);
-                    }
-                    _ => {
-                        self.pop_block();
-                    }
-                },
-                BlockType::Finally { handler } => {
-                    self.pop_block();
-                    let prev_exc = vm.current_exception();
-                    if let UnwindReason::Raising { exception } = &reason {
-                        vm.set_exception(Some(exception.clone()));
-                    }
-                    self.push_block(BlockType::FinallyHandler {
-                        reason: Some(reason),
-                        prev_exc,
-                    });
-                    self.jump(handler);
-                    return Ok(None);
+        // use exception table for exception handling
+        match reason {
+            UnwindReason::Raising { exception } => {
+                // Look up handler in exception table
+                // lasti points to NEXT instruction (already incremented in run loop)
+                // The exception occurred at the previous instruction
+                // Python uses signed int where INSTR_OFFSET() - 1 = -1 before first instruction
+                // We use u32, so check for 0 explicitly (equivalent to CPython's -1)
+                if self.lasti() == 0 {
+                    // No instruction executed yet, no handler can match
+                    return Err(exception);
                 }
-                BlockType::TryExcept { handler } => {
-                    self.pop_block();
-                    if let UnwindReason::Raising { exception } = reason {
-                        self.push_block(BlockType::ExceptHandler {
-                            prev_exc: vm.current_exception(),
-                        });
-                        vm.contextualize_exception(&exception);
-                        vm.set_exception(Some(exception.clone()));
-                        self.push_value(exception.into());
-                        self.jump(handler);
-                        return Ok(None);
+                let offset = self.lasti() - 1;
+                if let Some(entry) =
+                    bytecode::find_exception_handler(&self.code.exceptiontable, offset)
+                {
+                    // 1. Pop stack to entry.depth
+                    while self.state.stack.len() > entry.depth as usize {
+                        self.pop_value();
                     }
-                }
-                BlockType::FinallyHandler { prev_exc, .. }
-                | BlockType::ExceptHandler { prev_exc } => {
-                    self.pop_block();
-                    vm.set_exception(prev_exc);
+
+                    // 2. If push_lasti=true (SETUP_CLEANUP), push lasti before exception
+                    // pushes lasti as PyLong
+                    if entry.push_lasti {
+                        self.push_value(vm.ctx.new_int(offset as i32).into());
+                    }
+
+                    // 3. Push exception onto stack
+                    // always push exception, PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc]
+                    // Note: Do NOT call vm.set_exception here! PUSH_EXC_INFO will do it.
+                    // PUSH_EXC_INFO needs to get prev_exc from vm.current_exception() BEFORE setting the new one.
+                    self.push_value(exception.into());
+
+                    // 4. Jump to handler
+                    self.jump(bytecode::Label(entry.target));
+
+                    Ok(None)
+                } else {
+                    // No handler found, propagate exception
+                    Err(exception)
                 }
             }
-        }
-
-        // We do not have any more blocks to unwind. Inspect the reason we are here:
-        match reason {
-            UnwindReason::Raising { exception } => Err(exception),
             UnwindReason::Returning { value } => {
                 // Clear tracebacks of exceptions in fastlocals to break reference cycles.
                 // This is needed because when returning from inside an except block,
@@ -1775,9 +1997,11 @@ impl ExecutingFrame<'_> {
                 drop(fastlocals);
                 Ok(Some(ExecutionResult::Return(value)))
             }
-            UnwindReason::Break { .. } | UnwindReason::Continue { .. } => {
-                self.fatal("break or continue must occur within a loop block.")
-            } // UnwindReason::NoWorries => Ok(None),
+            UnwindReason::Break { target } | UnwindReason::Continue { target } => {
+                // Break/continue: jump to the target label
+                self.jump(target);
+                Ok(None)
+            }
         }
     }
 
@@ -1981,15 +2205,30 @@ impl ExecutingFrame<'_> {
                 })
             }
             // if there's no cause arg, we keep the cause as is
-            bytecode::RaiseKind::Raise | bytecode::RaiseKind::Reraise => None,
+            _ => None,
         };
         let exception = match kind {
             bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => {
                 ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?
             }
-            bytecode::RaiseKind::Reraise => vm
-                .topmost_exception()
-                .ok_or_else(|| vm.new_runtime_error("No active exception to reraise"))?,
+            bytecode::RaiseKind::BareRaise => {
+                // RAISE_VARARGS 0: bare `raise` gets exception from VM state
+                // This is the current exception set by PUSH_EXC_INFO
+                vm.topmost_exception().ok_or_else(|| {
+                    vm.new_runtime_error("No active exception to reraise".to_owned())
+                })?
+            }
+            bytecode::RaiseKind::ReraiseFromStack => {
+                // RERAISE: gets exception from stack top
+                // Used in cleanup blocks where exception is on stack after COPY 3
+                let exc = self.pop_value();
+                exc.downcast::<PyBaseException>().map_err(|obj| {
+                    vm.new_type_error(format!(
+                        "exceptions must derive from BaseException, not {}",
+                        obj.class().name()
+                    ))
+                })?
+            }
         };
         #[cfg(debug_assertions)]
         debug!("Exception raised: {exception:?} with cause: {cause:?}");
@@ -2024,27 +2263,6 @@ impl ExecutingFrame<'_> {
         }
     }
 
-    fn execute_yield_from(&mut self, vm: &VirtualMachine) -> FrameResult {
-        // Value send into iterator:
-        let val = self.pop_value();
-        let coro = self.top_value();
-        let result = self._send(coro, val, vm)?;
-
-        // PyIterReturn returned from e.g. gen.__next__() or gen.send()
-        match result {
-            PyIterReturn::Return(value) => {
-                // Set back program counter:
-                self.update_lasti(|i| *i -= 1);
-                Ok(Some(ExecutionResult::Yield(value)))
-            }
-            PyIterReturn::StopIteration(value) => {
-                let value = vm.unwrap_or_none(value);
-                self.replace_top(value);
-                Ok(None)
-            }
-        }
-    }
-
     fn execute_unpack_ex(&mut self, vm: &VirtualMachine, before: u8, after: u8) -> FrameResult {
         let (before, after) = (before as usize, after as usize);
         let value = self.pop_value();
@@ -2159,7 +2377,7 @@ impl ExecutingFrame<'_> {
         vm: &VirtualMachine,
         attr: bytecode::MakeFunctionFlags,
     ) -> FrameResult {
-        // CPython 3.13 style: SET_FUNCTION_ATTRIBUTE sets attributes on a function
+        // SET_FUNCTION_ATTRIBUTE sets attributes on a function
         // Stack: [..., attr_value, func] -> [..., func]
         // Stack order: func is at -1, attr_value is at -2
 
@@ -2364,40 +2582,7 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn push_block(&mut self, typ: BlockType) {
-        // eprintln!("block pushed: {:.60?} {}", typ, self.state.stack.len());
-        self.state.blocks.push(Block {
-            typ,
-            level: self.state.stack.len(),
-        });
-    }
-
-    #[track_caller]
-    fn pop_block(&mut self) -> Block {
-        let block = self.state.blocks.pop().expect("No more blocks to pop!");
-        // eprintln!(
-        //     "block popped: {:.60?}  {} -> {} ",
-        //     block.typ,
-        //     self.state.stack.len(),
-        //     block.level
-        // );
-        #[cfg(debug_assertions)]
-        if self.state.stack.len() < block.level {
-            dbg!(&self);
-            panic!(
-                "stack size reversion: current size({}) < truncates target({}).",
-                self.state.stack.len(),
-                block.level
-            );
-        }
-        self.state.stack.truncate(block.level);
-        block
-    }
-
-    #[inline]
-    fn current_block(&self) -> Option<Block> {
-        self.state.blocks.last().cloned()
-    }
+    // Block stack functions removed - exception table handles all exception/cleanup
 
     #[inline]
     #[track_caller] // not a real track_caller but push_value is not very useful
@@ -2555,6 +2740,21 @@ impl ExecutingFrame<'_> {
 
     fn pop_multiple(&mut self, count: usize) -> crate::common::boxvec::Drain<'_, PyObjectRef> {
         let stack_len = self.state.stack.len();
+        if count > stack_len {
+            let instr = self.code.instructions.get(self.lasti() as usize);
+            let op_name = instr
+                .map(|i| format!("{:?}", i.op))
+                .unwrap_or_else(|| "None".to_string());
+            panic!(
+                "Stack underflow in pop_multiple: trying to pop {} elements from stack with {} elements. lasti={}, code={}, op={}, source_path={}",
+                count,
+                stack_len,
+                self.lasti(),
+                self.code.obj_name,
+                op_name,
+                self.code.source_path
+            );
+        }
         self.state.stack.drain(stack_len - count..)
     }
 
@@ -2601,17 +2801,12 @@ impl fmt::Debug for Frame {
             }
             s
         });
-        let block_str = state.blocks.iter().fold(String::new(), |mut s, elem| {
-            core::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
-            s
-        });
         // TODO: fix this up
         let locals = self.locals.clone();
         write!(
             f,
-            "Frame Object {{ \n Stack:{}\n Blocks:{}\n Locals:{:?}\n}}",
+            "Frame Object {{ \n Stack:{}\n Locals:{:?}\n}}",
             stack_str,
-            block_str,
             locals.into_object()
         )
     }
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index cc118ee5b0e..2b5e82a8d76 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -129,7 +129,7 @@ pub fn get_git_datetime() -> String {
 }
 
 // Must be aligned to Lib/importlib/_bootstrap_external.py
-pub const PYC_MAGIC_NUMBER: u16 = 3531;
+pub const PYC_MAGIC_NUMBER: u16 = 2997;
 
 // CPython format: magic_number | ('\r' << 16) | ('\n' << 24)
 // This protects against text-mode file reads
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 7f7c5ea7674..7b974389418 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -520,7 +520,13 @@ impl VirtualMachine {
     ) -> PyResult<R> {
         self.with_recursion("", || {
             self.frames.borrow_mut().push(frame.clone());
+            // Push a new exception context for frame isolation
+            // Each frame starts with no active exception (None)
+            // This prevents exceptions from leaking between function calls
+            self.push_exception(None);
             let result = f(frame);
+            // Pop the exception context - restores caller's exception state
+            self.pop_exception();
             // defer dec frame
             let _popped = self.frames.borrow_mut().pop();
             result
@@ -829,10 +835,6 @@ impl VirtualMachine {
         cur.exc
     }
 
-    pub(crate) fn take_exception(&self) -> Option<PyBaseExceptionRef> {
-        self.exceptions.borrow_mut().exc.take()
-    }
-
     pub(crate) fn current_exception(&self) -> Option<PyBaseExceptionRef> {
         self.exceptions.borrow().exc.clone()
     }
@@ -847,13 +849,25 @@ impl VirtualMachine {
         if let Some(context_exc) = self.topmost_exception()
             && !context_exc.is(exception)
         {
+            // Traverse the context chain to find `exception` and break cycles
+            // Uses Floyd's cycle detection: o moves every step, slow_o every other step
             let mut o = context_exc.clone();
+            let mut slow_o = context_exc.clone();
+            let mut slow_update_toggle = false;
             while let Some(context) = o.__context__() {
                 if context.is(exception) {
                     o.set___context__(None);
                     break;
                 }
                 o = context;
+                if o.is(&slow_o) {
+                    // Pre-existing cycle detected - all exceptions on the path were visited
+                    break;
+                }
+                if slow_update_toggle && let Some(slow_context) = slow_o.__context__() {
+                    slow_o = slow_context;
+                }
+                slow_update_toggle = !slow_update_toggle;
             }
             exception.set___context__(Some(context_exc))
         }
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
new file mode 100644
index 00000000000..9c440d52568
--- /dev/null
+++ b/scripts/generate_opcode_metadata.py
@@ -0,0 +1,246 @@
+"""Generate _opcode_metadata.py for RustPython bytecode.
+
+This file generates opcode metadata that is compatible with CPython 3.13.
+RustPython's Instruction enum is now ordered to match CPython opcode numbers exactly.
+"""
+
+import re
+
+# Read the bytecode.rs file to get instruction names
+with open("crates/compiler-core/src/bytecode.rs", "r") as f:
+    content = f.read()
+
+# Find the Instruction enum
+match = re.search(r"pub enum Instruction \{(.+?)\n\}", content, re.DOTALL)
+if not match:
+    raise ValueError("Could not find Instruction enum")
+
+enum_body = match.group(1)
+
+# Extract variant names
+variants = []
+for line in enum_body.split("\n"):
+    if line.strip().startswith("///") or line.strip().startswith("//"):
+        continue
+    m = re.match(r"^\s+([A-Z][a-zA-Z0-9]*)", line)
+    if m:
+        variants.append(m.group(1))
+
+print(f"Found {len(variants)} instruction variants")
+
+# Map RustPython variant names to CPython-compatible names
+# The opcode number is the index in the Instruction enum
+name_mapping = {
+    # Dummy/placeholder instructions
+    "Cache": "CACHE",
+    "Reserved3": "RESERVED",
+    "Reserved17": "RESERVED",
+    "Reserved141": "RESERVED",
+    "Reserved142": "RESERVED",
+    "Reserved143": "RESERVED",
+    "Reserved144": "RESERVED",
+    "Reserved145": "RESERVED",
+    "Reserved146": "RESERVED",
+    "Reserved147": "RESERVED",
+    "Reserved148": "RESERVED",
+    "BinarySlice": "BINARY_SLICE",
+    "EndFor": "END_FOR",
+    "ExitInitCheck": "EXIT_INIT_CHECK",
+    "GetYieldFromIter": "GET_YIELD_FROM_ITER",
+    "InterpreterExit": "INTERPRETER_EXIT",
+    "LoadAssertionError": "LOAD_ASSERTION_ERROR",
+    "LoadLocals": "LOAD_LOCALS",
+    "PushNull": "PUSH_NULL",
+    "ReturnGenerator": "RETURN_GENERATOR",
+    "StoreSlice": "STORE_SLICE",
+    "UnaryInvert": "UNARY_INVERT",
+    "UnaryNegative": "UNARY_NEGATIVE",
+    "UnaryNot": "UNARY_NOT",
+    "BuildConstKeyMap": "BUILD_CONST_KEY_MAP",
+    "CopyFreeVars": "COPY_FREE_VARS",
+    "DictMerge": "DICT_MERGE",
+    "EnterExecutor": "ENTER_EXECUTOR",
+    "JumpBackward": "JUMP_BACKWARD",
+    "JumpBackwardNoInterrupt": "JUMP_BACKWARD_NO_INTERRUPT",
+    "JumpForward": "JUMP_FORWARD",
+    "ListExtend": "LIST_EXTEND",
+    "LoadFastCheck": "LOAD_FAST_CHECK",
+    "LoadFastLoadFast": "LOAD_FAST_LOAD_FAST",
+    "LoadFromDictOrDeref": "LOAD_FROM_DICT_OR_DEREF",
+    "LoadFromDictOrGlobals": "LOAD_FROM_DICT_OR_GLOBALS",
+    "LoadSuperAttr": "LOAD_SUPER_ATTR",
+    "MakeCell": "MAKE_CELL",
+    "PopJumpIfNone": "POP_JUMP_IF_NONE",
+    "PopJumpIfNotNone": "POP_JUMP_IF_NOT_NONE",
+    "SetUpdate": "SET_UPDATE",
+    "StoreFastStoreFast": "STORE_FAST_STORE_FAST",
+    # Real instructions
+    "BeforeAsyncWith": "BEFORE_ASYNC_WITH",
+    "BeforeWith": "BEFORE_WITH",
+    "BinaryOp": "BINARY_OP",
+    "BinarySubscript": "BINARY_SUBSCR",
+    "Break": "BREAK",
+    "BuildList": "BUILD_LIST",
+    "BuildListFromTuples": "BUILD_LIST_UNPACK",
+    "BuildMap": "BUILD_MAP",
+    "BuildMapForCall": "BUILD_MAP_FOR_CALL",
+    "BuildSet": "BUILD_SET",
+    "BuildSetFromTuples": "BUILD_SET_UNPACK",
+    "BuildSlice": "BUILD_SLICE",
+    "BuildString": "BUILD_STRING",
+    "BuildTuple": "BUILD_TUPLE",
+    "BuildTupleFromIter": "BUILD_TUPLE_ITER",
+    "BuildTupleFromTuples": "BUILD_TUPLE_UNPACK",
+    "CallFunctionEx": "CALL_FUNCTION_EX",
+    "CallFunctionKeyword": "CALL_KW",
+    "CallFunctionPositional": "CALL",
+    "CallIntrinsic1": "CALL_INTRINSIC_1",
+    "CallIntrinsic2": "CALL_INTRINSIC_2",
+    "CallMethodEx": "CALL_METHOD_EX",
+    "CallMethodKeyword": "CALL_METHOD_KW",
+    "CallMethodPositional": "CALL_METHOD",
+    "CheckEgMatch": "CHECK_EG_MATCH",
+    "CheckExcMatch": "CHECK_EXC_MATCH",
+    "CleanupThrow": "CLEANUP_THROW",
+    "CompareOperation": "COMPARE_OP",
+    "ContainsOp": "CONTAINS_OP",
+    "Continue": "CONTINUE",
+    "ConvertValue": "CONVERT_VALUE",
+    "CopyItem": "COPY",
+    "DeleteAttr": "DELETE_ATTR",
+    "DeleteDeref": "DELETE_DEREF",
+    "DeleteFast": "DELETE_FAST",
+    "DeleteGlobal": "DELETE_GLOBAL",
+    "DeleteLocal": "DELETE_NAME",
+    "DeleteSubscript": "DELETE_SUBSCR",
+    "DictUpdate": "DICT_UPDATE",
+    "EndAsyncFor": "END_ASYNC_FOR",
+    "EndSend": "END_SEND",
+    "ExtendedArg": "EXTENDED_ARG",
+    "ForIter": "FOR_ITER",
+    "FormatSimple": "FORMAT_SIMPLE",
+    "FormatWithSpec": "FORMAT_WITH_SPEC",
+    "GetAIter": "GET_AITER",
+    "GetANext": "GET_ANEXT",
+    "GetAwaitable": "GET_AWAITABLE",
+    "GetIter": "GET_ITER",
+    "GetLen": "GET_LEN",
+    "ImportFrom": "IMPORT_FROM",
+    "ImportName": "IMPORT_NAME",
+    "IsOp": "IS_OP",
+    "Jump": "JUMP",
+    "JumpIfFalseOrPop": "JUMP_IF_FALSE_OR_POP",
+    "JumpIfNotExcMatch": "JUMP_IF_NOT_EXC_MATCH",
+    "JumpIfTrueOrPop": "JUMP_IF_TRUE_OR_POP",
+    "ListAppend": "LIST_APPEND",
+    "LoadAttr": "LOAD_ATTR",
+    "LoadBuildClass": "LOAD_BUILD_CLASS",
+    "LoadClassDeref": "LOAD_CLASSDEREF",
+    "LoadClosure": "LOAD_CLOSURE",
+    "LoadConst": "LOAD_CONST",
+    "LoadDeref": "LOAD_DEREF",
+    "LoadFast": "LOAD_FAST",
+    "LoadFastAndClear": "LOAD_FAST_AND_CLEAR",
+    "LoadGlobal": "LOAD_GLOBAL",
+    "LoadMethod": "LOAD_METHOD",
+    "LoadNameAny": "LOAD_NAME",
+    "MakeFunction": "MAKE_FUNCTION",
+    "MapAdd": "MAP_ADD",
+    "MatchClass": "MATCH_CLASS",
+    "MatchKeys": "MATCH_KEYS",
+    "MatchMapping": "MATCH_MAPPING",
+    "MatchSequence": "MATCH_SEQUENCE",
+    "Nop": "NOP",
+    "PopBlock": "POP_BLOCK",
+    "PopException": "POP_EXCEPT",
+    "PopJumpIfFalse": "POP_JUMP_IF_FALSE",
+    "PopJumpIfTrue": "POP_JUMP_IF_TRUE",
+    "PopTop": "POP_TOP",
+    "PushExcInfo": "PUSH_EXC_INFO",
+    "Raise": "RAISE_VARARGS",
+    "Reraise": "RERAISE",
+    "Resume": "RESUME",
+    "ReturnConst": "RETURN_CONST",
+    "ReturnValue": "RETURN_VALUE",
+    "Reverse": "REVERSE",
+    "Send": "SEND",
+    "SetAdd": "SET_ADD",
+    "SetExcInfo": "SET_EXC_INFO",
+    "SetFunctionAttribute": "SET_FUNCTION_ATTRIBUTE",
+    "SetupAnnotation": "SETUP_ANNOTATIONS",
+    "StoreAttr": "STORE_ATTR",
+    "StoreDeref": "STORE_DEREF",
+    "StoreFast": "STORE_FAST",
+    "StoreFastLoadFast": "STORE_FAST_LOAD_FAST",
+    "StoreGlobal": "STORE_GLOBAL",
+    "StoreLocal": "STORE_NAME",
+    "StoreSubscript": "STORE_SUBSCR",
+    "Subscript": "SUBSCRIPT",
+    "Swap": "SWAP",
+    "ToBool": "TO_BOOL",
+    "UnaryOperation": "UNARY_OP",
+    "UnpackEx": "UNPACK_EX",
+    "UnpackSequence": "UNPACK_SEQUENCE",
+    "WithExceptStart": "WITH_EXCEPT_START",
+    "YieldValue": "YIELD_VALUE",
+}
+
+# Build opmap with RustPython instruction indices
+opmap = {}
+rust_to_cpython_name = {}
+for i, variant in enumerate(variants):
+    cpython_name = name_mapping.get(variant, variant.upper())
+    # Skip adding duplicates (RESERVED appears multiple times)
+    if cpython_name == "RESERVED":
+        # Use unique names for reserved slots
+        cpython_name = f"RESERVED_{i}"
+    if cpython_name not in opmap:
+        opmap[cpython_name] = i
+    rust_to_cpython_name[variant] = cpython_name
+
+
+# Find specific instruction indices for categorization
+def find_opcode(cpython_name):
+    return opmap.get(cpython_name, -1)
+
+
+# Generate the output file
+output = """# This file is generated by scripts/generate_opcode_metadata.py
+# for RustPython bytecode format (CPython 3.13 compatible opcode numbers).
+# Do not edit!
+
+_specializations = {}
+
+_specialized_opmap = {}
+
+opmap = {
+"""
+
+for name, num in sorted(opmap.items(), key=lambda x: x[1]):
+    output += f"    '{name}': {num},\n"
+
+output += """}
+
+# CPython 3.13 compatible: opcodes < 44 have no argument
+HAVE_ARGUMENT = 44
+MIN_INSTRUMENTED_OPCODE = 236
+"""
+
+with open("Lib/_opcode_metadata.py", "w") as f:
+    f.write(output)
+
+print("Generated Lib/_opcode_metadata.py")
+print("\nKey opcode indices (matching CPython 3.13):")
+print(f"  CACHE = {find_opcode('CACHE')} (expected: 0)")
+print(f"  BEFORE_ASYNC_WITH = {find_opcode('BEFORE_ASYNC_WITH')} (expected: 1)")
+print(f"  BINARY_SUBSCR = {find_opcode('BINARY_SUBSCR')} (expected: 5)")
+print(
+    f"  WITH_EXCEPT_START = {find_opcode('WITH_EXCEPT_START')} (expected: 44, HAVE_ARGUMENT)"
+)
+print(f"  BINARY_OP = {find_opcode('BINARY_OP')} (expected: 45)")
+print(f"  LOAD_CONST = {find_opcode('LOAD_CONST')} (expected: 83)")
+print(f"  LOAD_FAST = {find_opcode('LOAD_FAST')} (expected: 85)")
+print(f"  LOAD_GLOBAL = {find_opcode('LOAD_GLOBAL')} (expected: 91)")
+print(f"  STORE_FAST = {find_opcode('STORE_FAST')} (expected: 110)")
+print(f"  YIELD_VALUE = {find_opcode('YIELD_VALUE')} (expected: 118)")
+print(f"  RESUME = {find_opcode('RESUME')} (expected: 149)")

From 4bec6bb6f96fb63106e833cdaf49eec0ea8b12ab Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 3 Jan 2026 19:54:01 -0500
Subject: [PATCH 163/418] Updated the pkgutil + unittest libraries + the
 pkgutil, unittest and import tests - v.3.13.11 (#6610)

* Updated unittest + tests

* Updated pkgutil + the associated test

* Updated test_import

* Fixed import + unittest test errors

* Updated test_dll_dependency_import with expectedFailure
---
 Lib/pkgutil.py                                |   34 +-
 Lib/test/test_import/__init__.py              | 2130 ++++++++++++++++-
 .../data/circular_imports/import_cycle.py     |    3 +
 .../data/circular_imports/singlephase.py      |   13 +
 Lib/test/test_import/data/double_const.py     |   30 +
 .../test_import/data/package3/__init__.py     |    2 +
 .../test_import/data/package3/submodule.py    |    7 +
 .../test_import/data/package4/__init__.py     |    5 +
 .../test_import/data/package4/submodule.py    |    3 +
 Lib/test/test_pkgutil.py                      |  179 +-
 Lib/test/test_unittest/test_async_case.py     |    9 +-
 Lib/test/test_unittest/test_discovery.py      |    4 -
 Lib/test/test_unittest/test_loader.py         |    6 -
 Lib/test/test_unittest/test_program.py        |   24 +-
 Lib/test/test_unittest/test_runner.py         |    3 +-
 Lib/test/test_unittest/testmock/testasync.py  |   36 +-
 .../test_unittest/testmock/testhelpers.py     |    3 +-
 Lib/test/test_unittest/testmock/testpatch.py  |    7 +-
 Lib/unittest/__init__.py                      |   21 +-
 Lib/unittest/async_case.py                    |    8 +-
 Lib/unittest/loader.py                        |  105 +-
 Lib/unittest/main.py                          |    8 +-
 22 files changed, 2373 insertions(+), 267 deletions(-)
 create mode 100644 Lib/test/test_import/data/circular_imports/import_cycle.py
 create mode 100644 Lib/test/test_import/data/circular_imports/singlephase.py
 create mode 100644 Lib/test/test_import/data/double_const.py
 create mode 100644 Lib/test/test_import/data/package3/__init__.py
 create mode 100644 Lib/test/test_import/data/package3/submodule.py
 create mode 100644 Lib/test/test_import/data/package4/__init__.py
 create mode 100644 Lib/test/test_import/data/package4/submodule.py

diff --git a/Lib/pkgutil.py b/Lib/pkgutil.py
index a4c474006ba..dccbec52aa7 100644
--- a/Lib/pkgutil.py
+++ b/Lib/pkgutil.py
@@ -14,7 +14,7 @@
 __all__ = [
     'get_importer', 'iter_importers', 'get_loader', 'find_loader',
     'walk_packages', 'iter_modules', 'get_data',
-    'ImpImporter', 'ImpLoader', 'read_code', 'extend_path',
+    'read_code', 'extend_path',
     'ModuleInfo',
 ]
 
@@ -23,20 +23,6 @@
 ModuleInfo.__doc__ = 'A namedtuple with minimal info about a module.'
 
 
-def _get_spec(finder, name):
-    """Return the finder-specific module spec."""
-    # Works with legacy finders.
-    try:
-        find_spec = finder.find_spec
-    except AttributeError:
-        loader = finder.find_module(name)
-        if loader is None:
-            return None
-        return importlib.util.spec_from_loader(name, loader)
-    else:
-        return find_spec(name)
-
-
 def read_code(stream):
     # This helper is needed in order for the PEP 302 emulation to
     # correctly handle compiled files
@@ -184,6 +170,7 @@ def _iter_file_finder_modules(importer, prefix=''):
 iter_importer_modules.register(
     importlib.machinery.FileFinder, _iter_file_finder_modules)
 
+
 try:
     import zipimport
     from zipimport import zipimporter
@@ -231,6 +218,7 @@ def get_importer(path_item):
     The cache (or part of it) can be cleared manually if a
     rescan of sys.path_hooks is necessary.
     """
+    path_item = os.fsdecode(path_item)
     try:
         importer = sys.path_importer_cache[path_item]
     except KeyError:
@@ -282,6 +270,10 @@ def get_loader(module_or_name):
     If the named module is not already imported, its containing package
     (if any) is imported, in order to establish the package __path__.
     """
+    warnings._deprecated("pkgutil.get_loader",
+                         f"{warnings._DEPRECATED_MSG}; "
+                         "use importlib.util.find_spec() instead",
+                         remove=(3, 14))
     if module_or_name in sys.modules:
         module_or_name = sys.modules[module_or_name]
         if module_or_name is None:
@@ -306,6 +298,10 @@ def find_loader(fullname):
     importlib.util.find_spec that converts most failures to ImportError
     and only returns the loader rather than the full spec
     """
+    warnings._deprecated("pkgutil.find_loader",
+                         f"{warnings._DEPRECATED_MSG}; "
+                         "use importlib.util.find_spec() instead",
+                         remove=(3, 14))
     if fullname.startswith('.'):
         msg = "Relative module name {!r} not supported".format(fullname)
         raise ImportError(msg)
@@ -328,10 +324,10 @@ def extend_path(path, name):
         from pkgutil import extend_path
         __path__ = extend_path(__path__, __name__)
 
-    This will add to the package's __path__ all subdirectories of
-    directories on sys.path named after the package.  This is useful
-    if one wants to distribute different parts of a single logical
-    package as multiple directories.
+    For each directory on sys.path that has a subdirectory that
+    matches the package name, add the subdirectory to the package's
+    __path__.  This is useful if one wants to distribute different
+    parts of a single logical package as multiple directories.
 
     It also looks for *.pkg files beginning where * matches the name
     argument.  This feature is similar to *.pth files (see site.py),
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 51fafd89ceb..abe8b75e7db 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -1,9 +1,16 @@
 import builtins
-import contextlib
 import errno
 import glob
+import json
 import importlib.util
 from importlib._bootstrap_external import _get_sourcefile
+from importlib.machinery import (
+    AppleFrameworkLoader,
+    BuiltinImporter,
+    ExtensionFileLoader,
+    FrozenImporter,
+    SourceFileLoader,
+)
 import marshal
 import os
 import py_compile
@@ -15,27 +22,125 @@
 import textwrap
 import threading
 import time
+import types
 import unittest
 from unittest import mock
+import _imp
 
 from test.support import os_helper
 from test.support import (
-    STDLIB_DIR, is_jython, swap_attr, swap_item, cpython_only, is_emscripten,
-    is_wasi)
+    STDLIB_DIR,
+    swap_attr,
+    swap_item,
+    cpython_only,
+    is_apple_mobile,
+    is_emscripten,
+    is_wasi,
+    run_in_subinterp,
+    run_in_subinterp_with_config,
+    Py_TRACE_REFS,
+    requires_gil_enabled,
+    Py_GIL_DISABLED,
+    force_not_colorized_test_class,
+)
 from test.support.import_helper import (
-    forget, make_legacy_pyc, unlink, unload, DirsOnSysPath, CleanImport)
+    forget, make_legacy_pyc, unlink, unload, ready_to_import,
+    DirsOnSysPath, CleanImport, import_module)
 from test.support.os_helper import (
-    TESTFN, rmtree, temp_umask, TESTFN_UNENCODABLE, temp_dir)
+    TESTFN, rmtree, temp_umask, TESTFN_UNENCODABLE)
 from test.support import script_helper
 from test.support import threading_helper
+from test.support.testcase import ExtraAssertions
 from test.test_importlib.util import uncache
 from types import ModuleType
+try:
+    import _testsinglephase
+except ImportError:
+    _testsinglephase = None
+try:
+    import _testmultiphase
+except ImportError:
+    _testmultiphase = None
+try:
+    import _interpreters
+except ModuleNotFoundError:
+    _interpreters = None
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
 
 
 skip_if_dont_write_bytecode = unittest.skipIf(
         sys.dont_write_bytecode,
         "test meaningful only when writing bytecode")
 
+
+def _require_loader(module, loader, skip):
+    if isinstance(module, str):
+        module = __import__(module)
+
+    MODULE_KINDS = {
+        BuiltinImporter: 'built-in',
+        ExtensionFileLoader: 'extension',
+        AppleFrameworkLoader: 'framework extension',
+        FrozenImporter: 'frozen',
+        SourceFileLoader: 'pure Python',
+    }
+
+    expected = loader
+    assert isinstance(expected, type), expected
+    expected = MODULE_KINDS[expected]
+
+    actual = module.__spec__.loader
+    if not isinstance(actual, type):
+        actual = type(actual)
+    actual = MODULE_KINDS[actual]
+
+    if actual != expected:
+        err = f'expected module to be {expected}, got {module.__spec__}'
+        if skip:
+            raise unittest.SkipTest(err)
+        raise Exception(err)
+    return module
+
+def require_builtin(module, *, skip=False):
+    module = _require_loader(module, BuiltinImporter, skip)
+    assert module.__spec__.origin == 'built-in', module.__spec__
+
+def require_extension(module, *, skip=False):
+    # Apple extensions must be distributed as frameworks. This requires
+    # a specialist loader.
+    if is_apple_mobile:
+        _require_loader(module, AppleFrameworkLoader, skip)
+    else:
+        _require_loader(module, ExtensionFileLoader, skip)
+
+def require_frozen(module, *, skip=True):
+    module = _require_loader(module, FrozenImporter, skip)
+    assert module.__spec__.origin == 'frozen', module.__spec__
+
+def require_pure_python(module, *, skip=False):
+    _require_loader(module, SourceFileLoader, skip)
+
+def create_extension_loader(modname, filename):
+    # Apple extensions must be distributed as frameworks. This requires
+    # a specialist loader.
+    if is_apple_mobile:
+        return AppleFrameworkLoader(modname, filename)
+    else:
+        return ExtensionFileLoader(modname, filename)
+
+def import_extension_from_file(modname, filename, *, put_in_sys_modules=True):
+    loader = create_extension_loader(modname, filename)
+    spec = importlib.util.spec_from_loader(modname, loader)
+    module = importlib.util.module_from_spec(spec)
+    loader.exec_module(module)
+    if put_in_sys_modules:
+        sys.modules[modname] = module
+    return module
+
+
 def remove_files(name):
     for f in (name + ".py",
               name + ".pyc",
@@ -45,28 +150,222 @@ def remove_files(name):
     rmtree('__pycache__')
 
 
-@contextlib.contextmanager
-def _ready_to_import(name=None, source=""):
-    # sets up a temporary directory and removes it
-    # creates the module file
-    # temporarily clears the module from sys.modules (if any)
-    # reverts or removes the module when cleaning up
-    name = name or "spam"
-    with temp_dir() as tempdir:
-        path = script_helper.make_script(tempdir, name, source)
-        old_module = sys.modules.pop(name, None)
+def no_rerun(reason):
+    """Skip rerunning for a particular test.
+
+    WARNING: Use this decorator with care; skipping rerunning makes it
+    impossible to find reference leaks. Provide a clear reason for skipping the
+    test using the 'reason' parameter.
+    """
+    def deco(func):
+        _has_run = False
+        def wrapper(self):
+            nonlocal _has_run
+            if _has_run:
+                self.skipTest(reason)
+            func(self)
+            _has_run = True
+        return wrapper
+    return deco
+
+
+if _testsinglephase is not None:
+    def restore__testsinglephase(*, _orig=_testsinglephase):
+        # We started with the module imported and want to restore
+        # it to its nominal state.
+        sys.modules.pop('_testsinglephase', None)
+        _orig._clear_globals()
+        origin = _orig.__spec__.origin
+        _testinternalcapi.clear_extension('_testsinglephase', origin)
+        import _testsinglephase
+
+
+def requires_singlephase_init(meth):
+    """Decorator to skip if single-phase init modules are not supported."""
+    if not isinstance(meth, type):
+        def meth(self, _meth=meth):
+            try:
+                return _meth(self)
+            finally:
+                restore__testsinglephase()
+    meth = cpython_only(meth)
+    msg = "gh-117694: free-threaded build does not currently support single-phase init modules in sub-interpreters"
+    meth = requires_gil_enabled(msg)(meth)
+    return unittest.skipIf(_testsinglephase is None,
+                           'test requires _testsinglephase module')(meth)
+
+
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(_interpreters is None,
+                           'subinterpreters required')(meth)
+
+
+class ModuleSnapshot(types.SimpleNamespace):
+    """A representation of a module for testing.
+
+    Fields:
+
+    * id - the module's object ID
+    * module - the actual module or an adequate substitute
+       * __file__
+       * __spec__
+          * name
+          * origin
+    * ns - a copy (dict) of the module's __dict__ (or None)
+    * ns_id - the object ID of the module's __dict__
+    * cached - the sys.modules[mod.__spec__.name] entry (or None)
+    * cached_id - the object ID of the sys.modules entry (or None)
+
+    In cases where the value is not available (e.g. due to serialization),
+    the value will be None.
+    """
+    _fields = tuple('id module ns ns_id cached cached_id'.split())
+
+    @classmethod
+    def from_module(cls, mod):
+        name = mod.__spec__.name
+        cached = sys.modules.get(name)
+        return cls(
+            id=id(mod),
+            module=mod,
+            ns=types.SimpleNamespace(**mod.__dict__),
+            ns_id=id(mod.__dict__),
+            cached=cached,
+            cached_id=id(cached),
+        )
+
+    SCRIPT = textwrap.dedent('''
+        {imports}
+
+        name = {name!r}
+
+        {prescript}
+
+        mod = {name}
+
+        {body}
+
+        {postscript}
+        ''')
+    IMPORTS = textwrap.dedent('''
+        import sys
+        ''').strip()
+    SCRIPT_BODY = textwrap.dedent('''
+        # Capture the snapshot data.
+        cached = sys.modules.get(name)
+        snapshot = dict(
+            id=id(mod),
+            module=dict(
+                __file__=mod.__file__,
+                __spec__=dict(
+                    name=mod.__spec__.name,
+                    origin=mod.__spec__.origin,
+                ),
+            ),
+            ns=None,
+            ns_id=id(mod.__dict__),
+            cached=None,
+            cached_id=id(cached) if cached else None,
+        )
+        ''').strip()
+    CLEANUP_SCRIPT = textwrap.dedent('''
+        # Clean up the module.
+        sys.modules.pop(name, None)
+        ''').strip()
+
+    @classmethod
+    def build_script(cls, name, *,
+                     prescript=None,
+                     import_first=False,
+                     postscript=None,
+                     postcleanup=False,
+                     ):
+        if postcleanup is True:
+            postcleanup = cls.CLEANUP_SCRIPT
+        elif isinstance(postcleanup, str):
+            postcleanup = textwrap.dedent(postcleanup).strip()
+            postcleanup = cls.CLEANUP_SCRIPT + os.linesep + postcleanup
+        else:
+            postcleanup = ''
+        prescript = textwrap.dedent(prescript).strip() if prescript else ''
+        postscript = textwrap.dedent(postscript).strip() if postscript else ''
+
+        if postcleanup:
+            if postscript:
+                postscript = postscript + os.linesep * 2 + postcleanup
+            else:
+                postscript = postcleanup
+
+        if import_first:
+            prescript += textwrap.dedent(f'''
+
+                # Now import the module.
+                assert name not in sys.modules
+                import {name}''')
+
+        return cls.SCRIPT.format(
+            imports=cls.IMPORTS.strip(),
+            name=name,
+            prescript=prescript.strip(),
+            body=cls.SCRIPT_BODY.strip(),
+            postscript=postscript,
+        )
+
+    @classmethod
+    def parse(cls, text):
+        raw = json.loads(text)
+        mod = raw['module']
+        mod['__spec__'] = types.SimpleNamespace(**mod['__spec__'])
+        raw['module'] = types.SimpleNamespace(**mod)
+        return cls(**raw)
+
+    @classmethod
+    def from_subinterp(cls, name, interpid=None, *, pipe=None, **script_kwds):
+        if pipe is not None:
+            return cls._from_subinterp(name, interpid, pipe, script_kwds)
+        pipe = os.pipe()
         try:
-            sys.path.insert(0, tempdir)
-            yield name, path
-            sys.path.remove(tempdir)
+            return cls._from_subinterp(name, interpid, pipe, script_kwds)
         finally:
-            if old_module is not None:
-                sys.modules[name] = old_module
-            elif name in sys.modules:
-                del sys.modules[name]
+            r, w = pipe
+            os.close(r)
+            os.close(w)
+
+    @classmethod
+    def _from_subinterp(cls, name, interpid, pipe, script_kwargs):
+        r, w = pipe
+
+        # Build the script.
+        postscript = textwrap.dedent(f'''
+            # Send the result over the pipe.
+            import json
+            import os
+            os.write({w}, json.dumps(snapshot).encode())
+
+            ''')
+        _postscript = script_kwargs.get('postscript')
+        if _postscript:
+            _postscript = textwrap.dedent(_postscript).lstrip()
+            postscript += _postscript
+        script_kwargs['postscript'] = postscript.strip()
+        script = cls.build_script(name, **script_kwargs)
+
+        # Run the script.
+        if interpid is None:
+            ret = run_in_subinterp(script)
+            if ret != 0:
+                raise AssertionError(f'{ret} != 0')
+        else:
+            _interpreters.run_string(interpid, script)
+
+        # Parse the results.
+        text = os.read(r, 1000)
+        return cls.parse(text.decode())
 
 
-class ImportTests(unittest.TestCase):
+@force_not_colorized_test_class
+class ImportTests(unittest.TestCase, ExtraAssertions):
 
     def setUp(self):
         remove_files(TESTFN)
@@ -87,8 +386,7 @@ def test_from_import_missing_attr_raises_ImportError(self):
         with self.assertRaises(ImportError):
             from importlib import something_that_should_not_exist_anywhere
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_missing_attr_has_name_and_path(self):
         with CleanImport('os'):
             import os
@@ -100,15 +398,19 @@ def test_from_import_missing_attr_has_name_and_path(self):
 
     @cpython_only
     def test_from_import_missing_attr_has_name_and_so_path(self):
-        import _testcapi
+        _testcapi = import_module("_testcapi")
         with self.assertRaises(ImportError) as cm:
             from _testcapi import i_dont_exist
         self.assertEqual(cm.exception.name, '_testcapi')
         if hasattr(_testcapi, "__file__"):
-            self.assertEqual(cm.exception.path, _testcapi.__file__)
+            # The path on the exception is strictly the spec origin, not the
+            # module's __file__. For most cases, these are the same; but on
+            # iOS, the Framework relocation process results in the exception
+            # being raised from the spec location.
+            self.assertEqual(cm.exception.path, _testcapi.__spec__.origin)
             self.assertRegex(
                 str(cm.exception),
-                r"cannot import name 'i_dont_exist' from '_testcapi' \(.*\.(so|pyd)\)"
+                r"cannot import name 'i_dont_exist' from '_testcapi' \(.*(\.(so|pyd))?\)"
             )
         else:
             self.assertEqual(
@@ -123,19 +425,17 @@ def test_from_import_missing_attr_has_name(self):
         self.assertEqual(cm.exception.name, '_warning')
         self.assertIsNone(cm.exception.path)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_missing_attr_path_is_canonical(self):
         with self.assertRaises(ImportError) as cm:
             from os.path import i_dont_exist
         self.assertIn(cm.exception.name, {'posixpath', 'ntpath'})
         self.assertIsNotNone(cm.exception)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_star_invalid_type(self):
         import re
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("__all__ = [b'invalid_type']")
             globals = {}
@@ -144,7 +444,7 @@ def test_from_import_star_invalid_type(self):
             ):
                 exec(f"from {name} import *", globals)
             self.assertNotIn(b"invalid_type", globals)
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("globals()[b'invalid_type'] = object()")
             globals = {}
@@ -161,18 +461,18 @@ def test_case_sensitivity(self):
             import RAnDoM
 
     def test_double_const(self):
-        # Another brief digression to test the accuracy of manifest float
-        # constants.
-        from test import double_const  # don't blink -- that *was* the test
+        # Importing double_const checks that float constants
+        # serialiazed by marshal as PYC files don't lose precision
+        # (SF bug 422177).
+        from test.test_import.data import double_const
+        unload('test.test_import.data.double_const')
+        from test.test_import.data import double_const  # noqa: F811
 
     def test_import(self):
         def test_with_extension(ext):
             # The extension is normally ".py", perhaps ".pyw".
             source = TESTFN + ext
-            if is_jython:
-                pyc = TESTFN + "$py.class"
-            else:
-                pyc = TESTFN + ".pyc"
+            pyc = TESTFN + ".pyc"
 
             with open(source, "w", encoding='utf-8') as f:
                 print("# This tests Python's ability to import a",
@@ -274,7 +574,7 @@ def test_import_name_binding(self):
         import test as x
         import test.support
         self.assertIs(x, test, x.__name__)
-        self.assertTrue(hasattr(test.support, "__file__"))
+        self.assertHasAttr(test.support, "__file__")
 
         # import x.y.z as w binds z as w
         import test.support as y
@@ -295,7 +595,7 @@ def test_issue31286(self):
 
         # import in a 'for' loop resulted in segmentation fault
         for i in range(2):
-            import test.support.script_helper as x
+            import test.support.script_helper as x  # noqa: F811
 
     def test_failing_reload(self):
         # A failing reload should leave the module object in sys.modules.
@@ -345,7 +645,7 @@ def test_file_to_source(self):
         sys.path.insert(0, os.curdir)
         try:
             mod = __import__(TESTFN)
-            self.assertTrue(mod.__file__.endswith('.py'))
+            self.assertEndsWith(mod.__file__, '.py')
             os.remove(source)
             del sys.modules[TESTFN]
             make_legacy_pyc(source)
@@ -427,8 +727,7 @@ def test_from_import_message_for_existing_module(self):
         with self.assertRaisesRegex(ImportError, "^cannot import name 'bogus'"):
             from re import bogus
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_AttributeError(self):
         # Issue #24492: trying to import an attribute that raises an
         # AttributeError should lead to an ImportError.
@@ -457,7 +756,6 @@ def test_issue31492(self):
             with self.assertRaises(AttributeError):
                 os.does_not_exist
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Flaky')
     @threading_helper.requires_working_threading()
     def test_concurrency(self):
         # bpo 38091: this is a hack to slow down the code that calls
@@ -493,7 +791,7 @@ def run():
         finally:
             del sys.path[0]
 
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; FileNotFoundError: [WinError 2] No such file or directory: 'built-in'
     @unittest.skipUnless(sys.platform == "win32", "Windows-specific")
     def test_dll_dependency_import(self):
         from _winapi import GetModuleFileName
@@ -539,6 +837,453 @@ def test_dll_dependency_import(self):
                                     env=env,
                                     cwd=os.path.dirname(pyexe))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON _imp.get_frozen_object("x", b"6\'\xd5Cu\x12"). TypeError: expected at most 1 arguments, got 2
+    def test_issue105979(self):
+        # this used to crash
+        with self.assertRaises(ImportError) as cm:
+            _imp.get_frozen_object("x", b"6\'\xd5Cu\x12")
+        self.assertIn("Frozen object named 'x' is invalid",
+                      str(cm.exception))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_frozen_module_from_import_error(self):
+        with self.assertRaises(ImportError) as cm:
+            from os import this_will_never_exist
+        self.assertIn(
+            f"cannot import name 'this_will_never_exist' from 'os' ({os.__file__})",
+            str(cm.exception),
+        )
+        with self.assertRaises(ImportError) as cm:
+            from sys import this_will_never_exist
+        self.assertIn(
+            "cannot import name 'this_will_never_exist' from 'sys' (unknown location)",
+            str(cm.exception),
+        )
+
+        scripts = [
+            """
+import os
+os.__spec__.has_location = False
+os.__file__ = []
+from os import this_will_never_exist
+""",
+            """
+import os
+os.__spec__.has_location = False
+del os.__file__
+from os import this_will_never_exist
+""",
+              """
+import os
+os.__spec__.origin = []
+os.__file__ = []
+from os import this_will_never_exist
+"""
+        ]
+        for script in scripts:
+            with self.subTest(script=script):
+                expected_error = (
+                    b"cannot import name 'this_will_never_exist' "
+                    b"from 'os' (unknown location)"
+                )
+                popen = script_helper.spawn_python("-c", script)
+                stdout, stderr = popen.communicate()
+                self.assertIn(expected_error, stdout)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_non_module_from_import_error(self):
+        prefix = """
+import sys
+class NotAModule: ...
+nm = NotAModule()
+nm.symbol = 123
+sys.modules["not_a_module"] = nm
+from not_a_module import symbol
+"""
+        scripts = [
+            prefix + "from not_a_module import missing_symbol",
+            prefix + "nm.__spec__ = []\nfrom not_a_module import missing_symbol",
+        ]
+        for script in scripts:
+            with self.subTest(script=script):
+                expected_error = (
+                    b"ImportError: cannot import name 'missing_symbol' from "
+                    b"'<unknown module name>' (unknown location)"
+                )
+            popen = script_helper.spawn_python("-c", script)
+            stdout, stderr = popen.communicate()
+            self.assertIn(expected_error, stdout)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib(self):
+        script_errors = [
+            (
+                "import fractions\nfractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*fractions.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                # and there's no error at all when using -P
+                popen = script_helper.spawn_python('-P', 'fractions.py', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')
+
+                tmp_child = os.path.join(tmp, "child")
+                os.mkdir(tmp_child)
+
+                # test the logic with different cwd
+                popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')  # no error
+
+                popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')  # no error
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_package_shadowing_stdlib_module(self):
+        script_errors = [
+            (
+                "fractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                os.mkdir(os.path.join(tmp, "fractions"))
+                with open(
+                    os.path.join(tmp, "fractions", "__init__.py"), "w", encoding='utf-8'
+                ) as f:
+                    f.write("shadowing_module = True")
+                with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                    f.write("import fractions; fractions.shadowing_module\n")
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*[\\/]fractions[\\/]+__init__.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "main.py"), cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'main', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                # and there's no shadowing at all when using -P
+                popen = script_helper.spawn_python('-P', 'main.py', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, b"module 'fractions' has no attribute 'shadowing_module'")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_third_party(self):
+        script_errors = [
+            (
+                "import numpy\nnumpy.array",
+                rb"AttributeError: module 'numpy' has no attribute 'array'"
+            ),
+            (
+                "from numpy import array",
+                rb"ImportError: cannot import name 'array' from 'numpy'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*numpy.py' if it has the "
+                    rb"same name as a library you intended to import\)\s+\Z"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "numpy.py"))
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'numpy', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-c', 'import numpy', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_maybe_not_shadowing_third_party(self):
+        with os_helper.temp_dir() as tmp:
+            with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
+                f.write("this_script_does_not_attempt_to_import_numpy = True")
+
+            expected_error = (
+                rb"AttributeError: module 'numpy' has no attribute 'attr'\s+\Z"
+            )
+            popen = script_helper.spawn_python('-c', 'import numpy; numpy.attr', cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertRegex(stdout, expected_error)
+
+            expected_error = (
+                rb"ImportError: cannot import name 'attr' from 'numpy' \(.*\)\s+\Z"
+            )
+            popen = script_helper.spawn_python('-c', 'from numpy import attr', cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib_edge_cases(self):
+        with os_helper.temp_dir() as tmp:
+            with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                f.write("shadowing_module = True")
+
+            # Unhashable str subclass
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+class substr(str):
+    __hash__ = None
+fractions.__name__ = substr('fractions')
+try:
+    fractions.Fraction
+except TypeError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+class substr(str):
+    __hash__ = None
+fractions.__name__ = substr('fractions')
+try:
+    from fractions import Fraction
+except TypeError as e:
+    print(str(e))
+""")
+
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+
+            # Various issues with sys module
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+
+import sys
+sys.stdlib_module_names = None
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+del sys.stdlib_module_names
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+sys.path = [0]
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 3)
+            for line in lines:
+                self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+
+import sys
+sys.stdlib_module_names = None
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+del sys.stdlib_module_names
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+sys.path = [0]
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 3)
+            for line in lines:
+                self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
+
+            # Various issues with origin
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+del fractions.__spec__.origin
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+fractions.__spec__.origin = []
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+""")
+
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 2)
+            for line in lines:
+                self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+del fractions.__spec__.origin
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+fractions.__spec__.origin = []
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 2)
+            for line in lines:
+                self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
+
+    @unittest.skipIf(sys.platform == 'win32', 'Cannot delete cwd on Windows')
+    @unittest.skipIf(sys.platform == 'sunos5', 'Cannot delete cwd on Solaris/Illumos')
+    @unittest.skipIf(sys.platform.startswith('aix'), 'Cannot delete cwd on AIX')
+    def test_script_shadowing_stdlib_cwd_failure(self):
+        with os_helper.temp_dir() as tmp:
+            subtmp = os.path.join(tmp, "subtmp")
+            os.mkdir(subtmp)
+            with open(os.path.join(subtmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write(f"""
+import sys
+assert sys.path[0] == ''
+
+import os
+import shutil
+shutil.rmtree(os.getcwd())
+
+os.does_not_exist
+""")
+            # Use -c to ensure sys.path[0] is ""
+            popen = script_helper.spawn_python("-c", "import main", cwd=subtmp)
+            stdout, stderr = popen.communicate()
+            expected_error = rb"AttributeError: module 'os' has no attribute 'does_not_exist'"
+            self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib_sys_path_modification(self):
+        script_errors = [
+            (
+                "import fractions\nfractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                    f.write("shadowing_module = True")
+                with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                    f.write('import sys; sys.path.insert(0, "this_folder_does_not_exist")\n')
+                    f.write(script)
+                expected_error = error + (
+                    rb" \(consider renaming '.*fractions.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python("main.py", cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "_imp" has no attribute "create_dynamic"')
+    def test_create_dynamic_null(self):
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec:
+                name = "a\x00b"
+                origin = "abc"
+            _imp.create_dynamic(Spec())
+
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec2:
+                name = "abc"
+                origin = "a\x00b"
+            _imp.create_dynamic(Spec2())
+
 
 @skip_if_dont_write_bytecode
 class FilePermissionTests(unittest.TestCase):
@@ -552,7 +1297,7 @@ class FilePermissionTests(unittest.TestCase):
     )
     def test_creation_mode(self):
         mask = 0o022
-        with temp_umask(mask), _ready_to_import() as (name, path):
+        with temp_umask(mask), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             module = __import__(name)
             if not os.path.exists(cached_path):
@@ -571,7 +1316,7 @@ def test_creation_mode(self):
     def test_cached_mode_issue_2051(self):
         # permissions of .pyc should match those of .py, regardless of mask
         mode = 0o600
-        with temp_umask(0o022), _ready_to_import() as (name, path):
+        with temp_umask(0o022), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             os.chmod(path, mode)
             __import__(name)
@@ -587,7 +1332,7 @@ def test_cached_mode_issue_2051(self):
     @os_helper.skip_unless_working_chmod
     def test_cached_readonly(self):
         mode = 0o400
-        with temp_umask(0o022), _ready_to_import() as (name, path):
+        with temp_umask(0o022), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             os.chmod(path, mode)
             __import__(name)
@@ -602,7 +1347,7 @@ def test_cached_readonly(self):
     def test_pyc_always_writable(self):
         # Initially read-only .pyc files on Windows used to cause problems
         # with later updates, see issue #6074 for details
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             # Write a Python file, make it read-only and import it
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("x = 'original'\n")
@@ -684,8 +1429,7 @@ def test_basics(self):
         self.assertEqual(mod.code_filename, self.file_name)
         self.assertEqual(mod.func_filename, self.file_name)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 'another_module.py' != .../unlikely_module_name.py
     def test_incorrect_code_name(self):
         py_compile.compile(self.file_name, dfile="another_module.py")
         mod = self.import_module()
@@ -721,7 +1465,7 @@ def test_foreign_code(self):
         self.assertEqual(mod.constant.co_filename, foreign_code.co_filename)
 
 
-class PathsTests(unittest.TestCase):
+class PathsTests(unittest.TestCase, ExtraAssertions):
     SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8',
                'test\u00b0\u00b3\u00b2')
     path = TESTFN
@@ -771,11 +1515,11 @@ def test_UNC_path(self):
             self.fail("could not import 'test_unc_path' from %r: %r"
                       % (unc, e))
         self.assertEqual(mod.testdata, 'test_unc_path')
-        self.assertTrue(mod.__file__.startswith(unc), mod.__file__)
+        self.assertStartsWith(mod.__file__, unc)
         unload("test_unc_path")
 
 
-class RelativeImportTests(unittest.TestCase):
+class RelativeImportTests(unittest.TestCase, ExtraAssertions):
 
     def tearDown(self):
         unload("test.relimport")
@@ -784,7 +1528,7 @@ def tearDown(self):
     def test_relimport_star(self):
         # This will import * from .test_import.
         from .. import relimport
-        self.assertTrue(hasattr(relimport, "RelativeImportTests"))
+        self.assertHasAttr(relimport, "RelativeImportTests")
 
     def test_issue3221(self):
         # Note for mergers: the 'absolute' tests from the 2.x branch
@@ -843,10 +1587,37 @@ def test_import_from_unloaded_package(self):
             import package2.submodule1
             package2.submodule1.submodule2
 
+    def test_rebinding(self):
+        # The same data is also used for testing pkgutil.resolve_name()
+        # in test_pkgutil and mock.patch in test_unittest.
+        path = os.path.join(os.path.dirname(__file__), 'data')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            from package3 import submodule
+            self.assertEqual(submodule.attr, 'rebound')
+            import package3.submodule as submodule
+            self.assertEqual(submodule.attr, 'rebound')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            import package3.submodule as submodule
+            self.assertEqual(submodule.attr, 'rebound')
+            from package3 import submodule
+            self.assertEqual(submodule.attr, 'rebound')
+
+    def test_rebinding2(self):
+        path = os.path.join(os.path.dirname(__file__), 'data')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            import package4.submodule as submodule
+            self.assertEqual(submodule.attr, 'submodule')
+            from package4 import submodule
+            self.assertEqual(submodule.attr, 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            from package4 import submodule
+            self.assertEqual(submodule.attr, 'origin')
+            import package4.submodule as submodule
+            self.assertEqual(submodule.attr, 'submodule')
+
 
 class OverridingImportBuiltinTests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_override_builtin(self):
         # Test that overriding builtins.__import__ can bypass sys.modules.
         import os
@@ -1075,7 +1846,7 @@ def test_symlinked_dir_importable(self):
 
 
 @cpython_only
-class ImportlibBootstrapTests(unittest.TestCase):
+class ImportlibBootstrapTests(unittest.TestCase, ExtraAssertions):
     # These tests check that importlib is bootstrapped.
 
     def test_frozen_importlib(self):
@@ -1088,7 +1859,7 @@ def test_frozen_importlib_is_bootstrap(self):
         self.assertIs(mod, _bootstrap)
         self.assertEqual(mod.__name__, 'importlib._bootstrap')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertTrue(mod.__file__.endswith('_bootstrap.py'), mod.__file__)
+        self.assertEndsWith(mod.__file__, '_bootstrap.py')
 
     def test_frozen_importlib_external_is_bootstrap_external(self):
         from importlib import _bootstrap_external
@@ -1096,7 +1867,7 @@ def test_frozen_importlib_external_is_bootstrap_external(self):
         self.assertIs(mod, _bootstrap_external)
         self.assertEqual(mod.__name__, 'importlib._bootstrap_external')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertTrue(mod.__file__.endswith('_bootstrap_external.py'), mod.__file__)
+        self.assertEndsWith(mod.__file__, '_bootstrap_external.py')
 
     def test_there_can_be_only_one(self):
         # Issue #15386 revealed a tricky loophole in the bootstrapping
@@ -1306,8 +2077,7 @@ def exec_module(*args):
             else:
                 importlib.SourceLoader.exec_module = old_exec_module
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(TESTFN_UNENCODABLE, 'need TESTFN_UNENCODABLE')
     def test_unencodable_filename(self):
         # Issue #11619: The Python parser and the import machinery must not
@@ -1358,8 +2128,7 @@ def test_rebinding(self):
         from test.test_import.data.circular_imports.subpkg import util
         self.assertIs(util.util, rebinding.util)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON AttributeError: module "test.test_import.data.circular_imports" has no attribute "binding"
     def test_binding(self):
         try:
             import test.test_import.data.circular_imports.binding
@@ -1370,8 +2139,7 @@ def test_crossreference1(self):
         import test.test_import.data.circular_imports.use
         import test.test_import.data.circular_imports.source
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_crossreference2(self):
         with self.assertRaises(AttributeError) as cm:
             import test.test_import.data.circular_imports.source
@@ -1391,8 +2159,16 @@ def test_circular_from_import(self):
             str(cm.exception),
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_circular_import(self):
+        with self.assertRaisesRegex(
+            AttributeError,
+            r"partially initialized module 'test.test_import.data.circular_imports.import_cycle' "
+            r"from '.*' has no attribute 'some_attribute' \(most likely due to a circular import\)"
+        ):
+            import test.test_import.data.circular_imports.import_cycle
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_absolute_circular_submodule(self):
         with self.assertRaises(AttributeError) as cm:
             import test.test_import.data.circular_imports.subpkg2.parent
@@ -1403,6 +2179,37 @@ def test_absolute_circular_submodule(self):
             str(cm.exception),
         )
 
+    @requires_singlephase_init
+    @unittest.skipIf(_testsinglephase is None, "test requires _testsinglephase module")
+    def test_singlephase_circular(self):
+        """Regression test for gh-123950
+
+        Import a single-phase-init module that imports itself
+        from the PyInit_* function (before it's added to sys.modules).
+        Manages its own cache (which is `static`, and so incompatible
+        with multiple interpreters or interpreter reset).
+        """
+        name = '_testsinglephase_circular'
+        helper_name = 'test.test_import.data.circular_imports.singlephase'
+        with uncache(name, helper_name):
+            filename = _testsinglephase.__file__
+            # We don't put the module in sys.modules: that the *inner*
+            # import should do that.
+            mod = import_extension_from_file(name, filename,
+                                             put_in_sys_modules=False)
+
+            self.assertEqual(mod.helper_mod_name, helper_name)
+            self.assertIn(name, sys.modules)
+            self.assertIn(helper_name, sys.modules)
+
+            self.assertIn(name, sys.modules)
+            self.assertIn(helper_name, sys.modules)
+        self.assertNotIn(name, sys.modules)
+        self.assertNotIn(helper_name, sys.modules)
+        self.assertIs(mod.clear_static_var(), mod)
+        _testinternalcapi.clear_extension('_testsinglephase_circular',
+                                          mod.__spec__.origin)
+
     def test_unwritable_module(self):
         self.addCleanup(unload, "test.test_import.data.unwritable")
         self.addCleanup(unload, "test.test_import.data.unwritable.x")
@@ -1417,6 +2224,1187 @@ def test_unwritable_module(self):
             unwritable.x = 42
 
 
+class SubinterpImportTests(unittest.TestCase):
+
+    RUN_KWARGS = dict(
+        allow_fork=False,
+        allow_exec=False,
+        allow_threads=True,
+        allow_daemon_threads=False,
+        # Isolation-related config values aren't included here.
+    )
+    ISOLATED = dict(
+        use_main_obmalloc=False,
+        gil=2,
+    )
+    NOT_ISOLATED = {k: not v for k, v in ISOLATED.items()}
+    NOT_ISOLATED['gil'] = 1
+
+    @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    def pipe(self):
+        r, w = os.pipe()
+        self.addCleanup(os.close, r)
+        self.addCleanup(os.close, w)
+        if hasattr(os, 'set_blocking'):
+            os.set_blocking(r, False)
+        return (r, w)
+
+    def import_script(self, name, fd, filename=None, check_override=None):
+        override_text = ''
+        if check_override is not None:
+            override_text = f'''
+                import _imp
+                _imp._override_multi_interp_extensions_check({check_override})
+                '''
+        if filename:
+            # Apple extensions must be distributed as frameworks. This requires
+            # a specialist loader.
+            if is_apple_mobile:
+                loader = "AppleFrameworkLoader"
+            else:
+                loader = "ExtensionFileLoader"
+
+            return textwrap.dedent(f'''
+                from importlib.util import spec_from_loader, module_from_spec
+                from importlib.machinery import {loader}
+                import os, sys
+                {override_text}
+                loader = {loader}({name!r}, {filename!r})
+                spec = spec_from_loader({name!r}, loader)
+                try:
+                    module = module_from_spec(spec)
+                    loader.exec_module(module)
+                except ImportError as exc:
+                    text = 'ImportError: ' + str(exc)
+                else:
+                    text = 'okay'
+                os.write({fd}, text.encode('utf-8'))
+                ''')
+        else:
+            return textwrap.dedent(f'''
+                import os, sys
+                {override_text}
+                try:
+                    import {name}
+                except ImportError as exc:
+                    text = 'ImportError: ' + str(exc)
+                else:
+                    text = 'okay'
+                os.write({fd}, text.encode('utf-8'))
+                ''')
+
+    def run_here(self, name, filename=None, *,
+                 check_singlephase_setting=False,
+                 check_singlephase_override=None,
+                 isolated=False,
+                 ):
+        """
+        Try importing the named module in a subinterpreter.
+
+        The subinterpreter will be in the current process.
+        The module will have already been imported in the main interpreter.
+        Thus, for extension/builtin modules, the module definition will
+        have been loaded already and cached globally.
+
+        "check_singlephase_setting" determines whether or not
+        the interpreter will be configured to check for modules
+        that are not compatible with use in multiple interpreters.
+
+        This should always return "okay" for all modules if the
+        setting is False (with no override).
+        """
+        __import__(name)
+
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=check_singlephase_setting,
+        )
+
+        r, w = self.pipe()
+        script = self.import_script(name, w, filename,
+                                    check_singlephase_override)
+
+        ret = run_in_subinterp_with_config(script, **kwargs)
+        self.assertEqual(ret, 0)
+        return os.read(r, 100)
+
+    def check_compatible_here(self, name, filename=None, *,
+                              strict=False,
+                              isolated=False,
+                              ):
+        # Verify that the named module may be imported in a subinterpreter.
+        # (See run_here() for more info.)
+        out = self.run_here(name, filename,
+                            check_singlephase_setting=strict,
+                            isolated=isolated,
+                            )
+        self.assertEqual(out, b'okay')
+
+    def check_incompatible_here(self, name, filename=None, *, isolated=False):
+        # Differences from check_compatible_here():
+        #  * verify that import fails
+        #  * "strict" is always True
+        out = self.run_here(name, filename,
+                            check_singlephase_setting=True,
+                            isolated=isolated,
+                            )
+        self.assertEqual(
+            out.decode('utf-8'),
+            f'ImportError: module {name} does not support loading in subinterpreters',
+        )
+
+    def check_compatible_fresh(self, name, *, strict=False, isolated=False):
+        # Differences from check_compatible_here():
+        #  * subinterpreter in a new process
+        #  * module has never been imported before in that process
+        #  * this tests importing the module for the first time
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=strict,
+        )
+        gil = kwargs['gil']
+        kwargs['gil'] = 'default' if gil == 0 else (
+            'shared' if gil == 1 else 'own' if gil == 2 else gil)
+        _, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
+            import _testinternalcapi, sys
+            assert (
+                {name!r} in sys.builtin_module_names or
+                {name!r} not in sys.modules
+            ), repr({name!r})
+            config = type(sys.implementation)(**{kwargs})
+            ret = _testinternalcapi.run_in_subinterp_with_config(
+                {self.import_script(name, "sys.stdout.fileno()")!r},
+                config,
+            )
+            assert ret == 0, ret
+            '''))
+        self.assertEqual(err, b'')
+        self.assertEqual(out, b'okay')
+
+    def check_incompatible_fresh(self, name, *, isolated=False):
+        # Differences from check_compatible_fresh():
+        #  * verify that import fails
+        #  * "strict" is always True
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=True,
+        )
+        gil = kwargs['gil']
+        kwargs['gil'] = 'default' if gil == 0 else (
+            'shared' if gil == 1 else 'own' if gil == 2 else gil)
+        _, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
+            import _testinternalcapi, sys
+            assert {name!r} not in sys.modules, {name!r}
+            config = type(sys.implementation)(**{kwargs})
+            ret = _testinternalcapi.run_in_subinterp_with_config(
+                {self.import_script(name, "sys.stdout.fileno()")!r},
+                config,
+            )
+            assert ret == 0, ret
+            '''))
+        self.assertEqual(err, b'')
+        self.assertEqual(
+            out.decode('utf-8'),
+            f'ImportError: module {name} does not support loading in subinterpreters',
+        )
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_builtin_compat(self):
+        # For now we avoid using sys or builtins
+        # since they still don't implement multi-phase init.
+        module = '_imp'
+        require_builtin(module)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+
+    @cpython_only
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_frozen_compat(self):
+        module = '_frozen_importlib'
+        require_frozen(module, skip=True)
+        if __import__(module).__spec__.origin != 'frozen':
+            raise unittest.SkipTest(f'{module} is unexpectedly not frozen')
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+
+    @requires_singlephase_init
+    def test_single_init_extension_compat(self):
+        module = '_testsinglephase'
+        require_extension(module)
+        with self.subTest(f'{module}: not strict'):
+            self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_incompatible_here(module)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_incompatible_fresh(module)
+        with self.subTest(f'{module}: isolated, fresh'):
+            self.check_incompatible_fresh(module, isolated=True)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_compat(self):
+        # Module with Py_MOD_PER_INTERPRETER_GIL_SUPPORTED
+        module = '_testmultiphase'
+        require_extension(module)
+
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_non_isolated_compat(self):
+        # Module with Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
+        # and Py_MOD_GIL_NOT_USED
+        modname = '_test_non_isolated'
+        filename = _testmultiphase.__file__
+        module = import_extension_from_file(modname, filename)
+
+        require_extension(module)
+        with self.subTest(f'{modname}: isolated'):
+            self.check_incompatible_here(modname, filename, isolated=True)
+        with self.subTest(f'{modname}: not isolated'):
+            self.check_incompatible_here(modname, filename, isolated=False)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{modname}: not strict'):
+                self.check_compatible_here(modname, filename, strict=False)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_per_interpreter_gil_compat(self):
+
+        # _test_shared_gil_only:
+        #   Explicit Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED (default)
+        #   and Py_MOD_GIL_NOT_USED
+        # _test_no_multiple_interpreter_slot:
+        #   No Py_mod_multiple_interpreters slot
+        #   and Py_MOD_GIL_NOT_USED
+        for modname in ('_test_shared_gil_only',
+                        '_test_no_multiple_interpreter_slot'):
+            with self.subTest(modname=modname):
+
+                filename = _testmultiphase.__file__
+                module = import_extension_from_file(modname, filename)
+
+                require_extension(module)
+                with self.subTest(f'{modname}: isolated, strict'):
+                    self.check_incompatible_here(modname, filename,
+                                                 isolated=True)
+                with self.subTest(f'{modname}: not isolated, strict'):
+                    self.check_compatible_here(modname, filename,
+                                               strict=True, isolated=False)
+                if not Py_GIL_DISABLED:
+                    with self.subTest(f'{modname}: not isolated, not strict'):
+                        self.check_compatible_here(
+                            modname, filename, strict=False, isolated=False)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_python_compat(self):
+        module = 'threading'
+        require_pure_python(module)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True)
+
+    @requires_singlephase_init
+    def test_singlephase_check_with_setting_and_override(self):
+        module = '_testsinglephase'
+        require_extension(module)
+
+        def check_compatible(setting, override):
+            out = self.run_here(
+                module,
+                check_singlephase_setting=setting,
+                check_singlephase_override=override,
+            )
+            self.assertEqual(out, b'okay')
+
+        def check_incompatible(setting, override):
+            out = self.run_here(
+                module,
+                check_singlephase_setting=setting,
+                check_singlephase_override=override,
+            )
+            self.assertNotEqual(out, b'okay')
+
+        with self.subTest('config: check enabled; override: enabled'):
+            check_incompatible(True, 1)
+        with self.subTest('config: check enabled; override: use config'):
+            check_incompatible(True, 0)
+        with self.subTest('config: check enabled; override: disabled'):
+            check_compatible(True, -1)
+
+        with self.subTest('config: check disabled; override: enabled'):
+            check_incompatible(False, 1)
+        with self.subTest('config: check disabled; override: use config'):
+            check_compatible(False, 0)
+        with self.subTest('config: check disabled; override: disabled'):
+            check_compatible(False, -1)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_isolated_config(self):
+        module = 'threading'
+        require_pure_python(module)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True, isolated=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True, isolated=True)
+
+    @requires_subinterpreters
+    @requires_singlephase_init
+    def test_disallowed_reimport(self):
+        # See https://github.com/python/cpython/issues/104621.
+        script = textwrap.dedent('''
+            import _testsinglephase
+            print(_testsinglephase)
+            ''')
+        interpid = _interpreters.create()
+        self.addCleanup(lambda: _interpreters.destroy(interpid))
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
+
+
+class TestSinglePhaseSnapshot(ModuleSnapshot):
+    """A representation of a single-phase init module for testing.
+
+    Fields from ModuleSnapshot:
+
+    * id - id(mod)
+    * module - mod or a SimpleNamespace with __file__ & __spec__
+    * ns - a shallow copy of mod.__dict__
+    * ns_id - id(mod.__dict__)
+    * cached - sys.modules[name] (or None if not there or not snapshotable)
+    * cached_id - id(sys.modules[name]) (or None if not there)
+
+    Extra fields:
+
+    * summed - the result of calling "mod.sum(1, 2)"
+    * lookedup - the result of calling "mod.look_up_self()"
+    * lookedup_id - the object ID of self.lookedup
+    * state_initialized - the result of calling "mod.state_initialized()"
+    * init_count - (optional) the result of calling "mod.initialized_count()"
+
+    Overridden methods from ModuleSnapshot:
+
+    * from_module()
+    * parse()
+
+    Other methods from ModuleSnapshot:
+
+    * build_script()
+    * from_subinterp()
+
+    ----
+
+    There are 5 modules in Modules/_testsinglephase.c:
+
+    * _testsinglephase
+       * has global state
+       * extra loads skip the init function, copy def.m_base.m_copy
+       * counts calls to init function
+    * _testsinglephase_basic_wrapper
+       * _testsinglephase by another name (and separate init function symbol)
+    * _testsinglephase_basic_copy
+       * same as _testsinglephase but with own def (and init func)
+    * _testsinglephase_with_reinit
+       * has no global or module state
+       * mod.state_initialized returns None
+       * an extra load in the main interpreter calls the cached init func
+       * an extra load in legacy subinterpreters does a full load
+    * _testsinglephase_with_state
+       * has module state
+       * an extra load in the main interpreter calls the cached init func
+       * an extra load in legacy subinterpreters does a full load
+
+    (See Modules/_testsinglephase.c for more info.)
+
+    For all those modules, the snapshot after the initial load (not in
+    the global extensions cache) would look like the following:
+
+    * initial load
+       * id: ID of nww module object
+       * ns: exactly what the module init put there
+       * ns_id: ID of new module's __dict__
+       * cached_id: same as self.id
+       * summed: 3  (never changes)
+       * lookedup_id: same as self.id
+       * state_initialized: a timestamp between the time of the load
+         and the time of the snapshot
+       * init_count: 1  (None for _testsinglephase_with_reinit)
+
+    For the other scenarios it varies.
+
+    For the _testsinglephase, _testsinglephase_basic_wrapper, and
+    _testsinglephase_basic_copy modules, the snapshot should look
+    like the following:
+
+    * reloaded
+       * id: no change
+       * ns: matches what the module init function put there,
+         including the IDs of all contained objects,
+         plus any extra attributes added before the reload
+       * ns_id: no change
+       * cached_id: no change
+       * lookedup_id: no change
+       * state_initialized: no change
+       * init_count: no change
+    * already loaded
+       * (same as initial load except for ns and state_initialized)
+       * ns: matches the initial load, incl. IDs of contained objects
+       * state_initialized: no change from initial load
+
+    For _testsinglephase_with_reinit:
+
+    * reloaded: same as initial load (old module & ns is discarded)
+    * already loaded: same as initial load (old module & ns is discarded)
+
+    For _testsinglephase_with_state:
+
+    * reloaded
+       * (same as initial load (old module & ns is discarded),
+         except init_count)
+       * init_count: increase by 1
+    * already loaded: same as reloaded
+    """
+
+    @classmethod
+    def from_module(cls, mod):
+        self = super().from_module(mod)
+        self.summed = mod.sum(1, 2)
+        self.lookedup = mod.look_up_self()
+        self.lookedup_id = id(self.lookedup)
+        self.state_initialized = mod.state_initialized()
+        if hasattr(mod, 'initialized_count'):
+            self.init_count = mod.initialized_count()
+        return self
+
+    SCRIPT_BODY = ModuleSnapshot.SCRIPT_BODY + textwrap.dedent('''
+        snapshot['module'].update(dict(
+            int_const=mod.int_const,
+            str_const=mod.str_const,
+            _module_initialized=mod._module_initialized,
+        ))
+        snapshot.update(dict(
+            summed=mod.sum(1, 2),
+            lookedup_id=id(mod.look_up_self()),
+            state_initialized=mod.state_initialized(),
+            init_count=mod.initialized_count(),
+            has_spam=hasattr(mod, 'spam'),
+            spam=getattr(mod, 'spam', None),
+        ))
+        ''').rstrip()
+
+    @classmethod
+    def parse(cls, text):
+        self = super().parse(text)
+        if not self.has_spam:
+            del self.spam
+        del self.has_spam
+        return self
+
+
+@requires_singlephase_init
+class SinglephaseInitTests(unittest.TestCase, ExtraAssertions):
+
+    NAME = '_testsinglephase'
+
+    @classmethod
+    def setUpClass(cls):
+        spec = importlib.util.find_spec(cls.NAME)
+        cls.LOADER = type(spec.loader)
+
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader, and we need to differentiate between the
+        # spec.origin and the original file location.
+        if is_apple_mobile:
+            assert cls.LOADER is AppleFrameworkLoader
+
+            cls.ORIGIN = spec.origin
+            with open(spec.origin + ".origin", "r") as f:
+                cls.FILE = os.path.join(
+                    os.path.dirname(sys.executable),
+                    f.read().strip()
+                )
+        else:
+            assert cls.LOADER is ExtensionFileLoader
+
+            cls.ORIGIN = spec.origin
+            cls.FILE = spec.origin
+
+        # Start fresh.
+        cls.clean_up()
+
+    def tearDown(self):
+        # Clean up the module.
+        self.clean_up()
+
+    @classmethod
+    def clean_up(cls):
+        name = cls.NAME
+        if name in sys.modules:
+            if hasattr(sys.modules[name], '_clear_globals'):
+                assert sys.modules[name].__file__ == cls.FILE, \
+                    f"{sys.modules[name].__file__} != {cls.FILE}"
+
+                sys.modules[name]._clear_globals()
+            del sys.modules[name]
+        # Clear all internally cached data for the extension.
+        _testinternalcapi.clear_extension(name, cls.ORIGIN)
+
+    #########################
+    # helpers
+
+    def add_module_cleanup(self, name):
+        def clean_up():
+            # Clear all internally cached data for the extension.
+            _testinternalcapi.clear_extension(name, self.ORIGIN)
+        self.addCleanup(clean_up)
+
+    def _load_dynamic(self, name, path):
+        """
+        Load an extension module.
+        """
+        # This is essentially copied from the old imp module.
+        from importlib._bootstrap import _load
+        loader = self.LOADER(name, path)
+
+        # Issue bpo-24748: Skip the sys.modules check in _load_module_shim;
+        # always load new extension.
+        spec = importlib.util.spec_from_file_location(name, path,
+                                                      loader=loader)
+        return _load(spec)
+
+    def load(self, name):
+        try:
+            already_loaded = self.already_loaded
+        except AttributeError:
+            already_loaded = self.already_loaded = {}
+        assert name not in already_loaded
+        mod = self._load_dynamic(name, self.ORIGIN)
+        self.assertNotIn(mod, already_loaded.values())
+        already_loaded[name] = mod
+        return types.SimpleNamespace(
+            name=name,
+            module=mod,
+            snapshot=TestSinglePhaseSnapshot.from_module(mod),
+        )
+
+    def re_load(self, name, mod):
+        assert sys.modules[name] is mod
+        assert mod.__dict__ == mod.__dict__
+        reloaded = self._load_dynamic(name, self.ORIGIN)
+        return types.SimpleNamespace(
+            name=name,
+            module=reloaded,
+            snapshot=TestSinglePhaseSnapshot.from_module(reloaded),
+        )
+
+    # subinterpreters
+
+    def add_subinterpreter(self):
+        interpid = _interpreters.create('legacy')
+        def ensure_destroyed():
+            try:
+                _interpreters.destroy(interpid)
+            except _interpreters.InterpreterNotFoundError:
+                pass
+        self.addCleanup(ensure_destroyed)
+        _interpreters.exec(interpid, textwrap.dedent('''
+            import sys
+            import _testinternalcapi
+            '''))
+        def clean_up():
+            _interpreters.exec(interpid, textwrap.dedent(f'''
+                name = {self.NAME!r}
+                if name in sys.modules:
+                    sys.modules.pop(name)._clear_globals()
+                _testinternalcapi.clear_extension(name, {self.ORIGIN!r})
+                '''))
+            _interpreters.destroy(interpid)
+        self.addCleanup(clean_up)
+        return interpid
+
+    def import_in_subinterp(self, interpid=None, *,
+                            postscript=None,
+                            postcleanup=False,
+                            ):
+        name = self.NAME
+
+        if postcleanup:
+            import_ = 'import _testinternalcapi' if interpid is None else ''
+            postcleanup = f'''
+                {import_}
+                mod._clear_globals()
+                _testinternalcapi.clear_extension(name, {self.ORIGIN!r})
+                '''
+
+        try:
+            pipe = self._pipe
+        except AttributeError:
+            r, w = pipe = self._pipe = os.pipe()
+            self.addCleanup(os.close, r)
+            self.addCleanup(os.close, w)
+
+        snapshot = TestSinglePhaseSnapshot.from_subinterp(
+            name,
+            interpid,
+            pipe=pipe,
+            import_first=True,
+            postscript=postscript,
+            postcleanup=postcleanup,
+        )
+
+        return types.SimpleNamespace(
+            name=name,
+            module=None,
+            snapshot=snapshot,
+        )
+
+    # checks
+
+    def check_common(self, loaded):
+        isolated = False
+
+        mod = loaded.module
+        if not mod:
+            # It came from a subinterpreter.
+            isolated = True
+            mod = loaded.snapshot.module
+        # mod.__name__  might not match, but the spec will.
+        self.assertEqual(mod.__spec__.name, loaded.name)
+        self.assertEqual(mod.__file__, self.FILE)
+        self.assertEqual(mod.__spec__.origin, self.ORIGIN)
+        if not isolated:
+            self.assertIsSubclass(mod.error, Exception)
+        self.assertEqual(mod.int_const, 1969)
+        self.assertEqual(mod.str_const, 'something different')
+        self.assertIsInstance(mod._module_initialized, float)
+        self.assertGreater(mod._module_initialized, 0)
+
+        snap = loaded.snapshot
+        self.assertEqual(snap.summed, 3)
+        if snap.state_initialized is not None:
+            self.assertIsInstance(snap.state_initialized, float)
+            self.assertGreater(snap.state_initialized, 0)
+        if isolated:
+            # The "looked up" module is interpreter-specific
+            # (interp->imports.modules_by_index was set for the module).
+            self.assertEqual(snap.lookedup_id, snap.id)
+            self.assertEqual(snap.cached_id, snap.id)
+            with self.assertRaises(AttributeError):
+                snap.spam
+        else:
+            self.assertIs(snap.lookedup, mod)
+            self.assertIs(snap.cached, mod)
+
+    def check_direct(self, loaded):
+        # The module has its own PyModuleDef, with a matching name.
+        self.assertEqual(loaded.module.__name__, loaded.name)
+        self.assertIs(loaded.snapshot.lookedup, loaded.module)
+
+    def check_indirect(self, loaded, orig):
+        # The module re-uses another's PyModuleDef, with a different name.
+        assert orig is not loaded.module
+        assert orig.__name__ != loaded.name
+        self.assertNotEqual(loaded.module.__name__, loaded.name)
+        self.assertIs(loaded.snapshot.lookedup, loaded.module)
+
+    def check_basic(self, loaded, expected_init_count):
+        # m_size == -1
+        # The module loads fresh the first time and copies m_copy after.
+        snap = loaded.snapshot
+        self.assertIsNot(snap.state_initialized, None)
+        self.assertIsInstance(snap.init_count, int)
+        self.assertGreater(snap.init_count, 0)
+        self.assertEqual(snap.init_count, expected_init_count)
+
+    def check_with_reinit(self, loaded):
+        # m_size >= 0
+        # The module loads fresh every time.
+        pass
+
+    def check_fresh(self, loaded):
+        """
+        The module had not been loaded before (at least since fully reset).
+        """
+        snap = loaded.snapshot
+        # The module's init func was run.
+        # A copy of the module's __dict__ was stored in def->m_base.m_copy.
+        # The previous m_copy was deleted first.
+        # _PyRuntime.imports.extensions was set.
+        self.assertEqual(snap.init_count, 1)
+        # The global state was initialized.
+        # The module attrs were initialized from that state.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+
+    def check_semi_fresh(self, loaded, base, prev):
+        """
+        The module had been loaded before and then reset
+        (but the module global state wasn't).
+        """
+        snap = loaded.snapshot
+        # The module's init func was run again.
+        # A copy of the module's __dict__ was stored in def->m_base.m_copy.
+        # The previous m_copy was deleted first.
+        # The module globals did not get reset.
+        self.assertNotEqual(snap.id, base.snapshot.id)
+        self.assertNotEqual(snap.id, prev.snapshot.id)
+        self.assertEqual(snap.init_count, prev.snapshot.init_count + 1)
+        # The global state was updated.
+        # The module attrs were initialized from that state.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+        self.assertNotEqual(snap.state_initialized,
+                            base.snapshot.state_initialized)
+        self.assertNotEqual(snap.state_initialized,
+                            prev.snapshot.state_initialized)
+
+    def check_copied(self, loaded, base):
+        """
+        The module had been loaded before and never reset.
+        """
+        snap = loaded.snapshot
+        # The module's init func was not run again.
+        # The interpreter copied m_copy, as set by the other interpreter,
+        # with objects owned by the other interpreter.
+        # The module globals did not get reset.
+        self.assertNotEqual(snap.id, base.snapshot.id)
+        self.assertEqual(snap.init_count, base.snapshot.init_count)
+        # The global state was not updated since the init func did not run.
+        # The module attrs were not directly initialized from that state.
+        # The state and module attrs still match the previous loading.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+        self.assertEqual(snap.state_initialized,
+                         base.snapshot.state_initialized)
+
+    #########################
+    # the tests
+
+    def test_cleared_globals(self):
+        loaded = self.load(self.NAME)
+        _testsinglephase = loaded.module
+        init_before = _testsinglephase.state_initialized()
+
+        _testsinglephase._clear_globals()
+        init_after = _testsinglephase.state_initialized()
+        init_count = _testsinglephase.initialized_count()
+
+        self.assertGreater(init_before, 0)
+        self.assertEqual(init_after, 0)
+        self.assertEqual(init_count, -1)
+
+    def test_variants(self):
+        # Exercise the most meaningful variants described in Python/import.c.
+        self.maxDiff = None
+
+        # Check the "basic" module.
+
+        name = self.NAME
+        expected_init_count = 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_direct(loaded)
+            self.check_basic(loaded, expected_init_count)
+        basic = loaded.module
+
+        # Check its indirect variants.
+
+        name = f'{self.NAME}_basic_wrapper'
+        self.add_module_cleanup(name)
+        expected_init_count += 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_indirect(loaded, basic)
+            self.check_basic(loaded, expected_init_count)
+
+            # Currently PyState_AddModule() always replaces the cached module.
+            self.assertIs(basic.look_up_self(), loaded.module)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # The cached module shouldn't change after this point.
+        basic_lookedup = loaded.module
+
+        # Check its direct variant.
+
+        name = f'{self.NAME}_basic_copy'
+        self.add_module_cleanup(name)
+        expected_init_count += 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_direct(loaded)
+            self.check_basic(loaded, expected_init_count)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # Check the non-basic variant that has no state.
+
+        name = f'{self.NAME}_with_reinit'
+        self.add_module_cleanup(name)
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.assertIs(loaded.snapshot.state_initialized, None)
+            self.check_direct(loaded)
+            self.check_with_reinit(loaded)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # Check the basic variant that has state.
+
+        name = f'{self.NAME}_with_state'
+        self.add_module_cleanup(name)
+        with self.subTest(name):
+            loaded = self.load(name)
+            self.addCleanup(loaded.module._clear_module_state)
+
+            self.check_common(loaded)
+            self.assertIsNot(loaded.snapshot.state_initialized, None)
+            self.check_direct(loaded)
+            self.check_with_reinit(loaded)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+    def test_basic_reloaded(self):
+        # m_copy is copied into the existing module object.
+        # Global state is not changed.
+        self.maxDiff = None
+
+        for name in [
+            self.NAME,  # the "basic" module
+            f'{self.NAME}_basic_wrapper',  # the indirect variant
+            f'{self.NAME}_basic_copy',  # the direct variant
+        ]:
+            self.add_module_cleanup(name)
+            with self.subTest(name):
+                loaded = self.load(name)
+                reloaded = self.re_load(name, loaded.module)
+
+                self.check_common(loaded)
+                self.check_common(reloaded)
+
+                # Make sure the original __dict__ did not get replaced.
+                self.assertEqual(id(loaded.module.__dict__),
+                                 loaded.snapshot.ns_id)
+                self.assertEqual(loaded.snapshot.ns.__dict__,
+                                 loaded.module.__dict__)
+
+                self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
+                self.assertEqual(reloaded.module.__name__,
+                                 reloaded.snapshot.ns.__name__)
+
+                self.assertIs(reloaded.module, loaded.module)
+                self.assertIs(reloaded.module.__dict__, loaded.module.__dict__)
+                # It only happens to be the same but that's good enough here.
+                # We really just want to verify that the re-loaded attrs
+                # didn't change.
+                self.assertIs(reloaded.snapshot.lookedup,
+                              loaded.snapshot.lookedup)
+                self.assertEqual(reloaded.snapshot.state_initialized,
+                                 loaded.snapshot.state_initialized)
+                self.assertEqual(reloaded.snapshot.init_count,
+                                 loaded.snapshot.init_count)
+
+                self.assertIs(reloaded.snapshot.cached, reloaded.module)
+
+    def test_with_reinit_reloaded(self):
+        # The module's m_init func is run again.
+        self.maxDiff = None
+
+        # Keep a reference around.
+        basic = self.load(self.NAME)
+
+        for name, has_state in [
+            (f'{self.NAME}_with_reinit', False),  # m_size == 0
+            (f'{self.NAME}_with_state', True),    # m_size > 0
+        ]:
+            self.add_module_cleanup(name)
+            with self.subTest(name=name, has_state=has_state):
+                loaded = self.load(name)
+                if has_state:
+                    self.addCleanup(loaded.module._clear_module_state)
+
+                reloaded = self.re_load(name, loaded.module)
+                if has_state:
+                    self.addCleanup(reloaded.module._clear_module_state)
+
+                self.check_common(loaded)
+                self.check_common(reloaded)
+
+                # Make sure the original __dict__ did not get replaced.
+                self.assertEqual(id(loaded.module.__dict__),
+                                 loaded.snapshot.ns_id)
+                self.assertEqual(loaded.snapshot.ns.__dict__,
+                                 loaded.module.__dict__)
+
+                self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
+                self.assertEqual(reloaded.module.__name__,
+                                 reloaded.snapshot.ns.__name__)
+
+                self.assertIsNot(reloaded.module, loaded.module)
+                self.assertNotEqual(reloaded.module.__dict__,
+                                    loaded.module.__dict__)
+                self.assertIs(reloaded.snapshot.lookedup, reloaded.module)
+                if loaded.snapshot.state_initialized is None:
+                    self.assertIs(reloaded.snapshot.state_initialized, None)
+                else:
+                    self.assertGreater(reloaded.snapshot.state_initialized,
+                                       loaded.snapshot.state_initialized)
+
+                self.assertIs(reloaded.snapshot.cached, reloaded.module)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_check_state_first(self):
+        for variant in ['', '_with_reinit', '_with_state']:
+            name = f'{self.NAME}{variant}_check_cache_first'
+            with self.subTest(name):
+                mod = self._load_dynamic(name, self.ORIGIN)
+                self.assertEqual(mod.__name__, name)
+                sys.modules.pop(name, None)
+                _testinternalcapi.clear_extension(name, self.ORIGIN)
+
+    # Currently, for every single-phrase init module loaded
+    # in multiple interpreters, those interpreters share a
+    # PyModuleDef for that object, which can be a problem.
+    # Also, we test with a single-phase module that has global state,
+    # which is shared by all interpreters.
+
+    @no_rerun(reason="module state is not cleared (see gh-140657)")
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_main_no_reset(self):
+        # without resetting; already loaded in main interpreter
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        main_loaded = self.load(self.NAME)
+        _testsinglephase = main_loaded.module
+        # Attrs set after loading are not in m_copy.
+        _testsinglephase.spam = 'spam, spam, spam, spam, eggs, and spam'
+
+        self.check_common(main_loaded)
+        self.check_fresh(main_loaded)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # At this point:
+        #  * alive in 1 interpreter (main)
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy was copied from the main interpreter (was NULL)
+        #  * module's global state was initialized
+
+        # Use an interpreter that gets destroyed right away.
+        loaded = self.import_in_subinterp()
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 1 interpreter (main)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy is NULL (claered when the interpreter was destroyed)
+        #    (was from main interpreter)
+        #  * module's global state was updated, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded = self.import_in_subinterp(interpid1)
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 2 interpreters (main, interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp1
+        #  * module's global state was updated, not reset
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded = self.import_in_subinterp(interpid2)
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 3 interpreters (main, interp1, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp2 (was from interp1)
+        #  * module's global state was updated, not reset
+
+    @no_rerun(reason="rerun not possible; module state is never cleared (see gh-102251)")
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_deleted_no_reset(self):
+        # without resetting; already loaded in a deleted interpreter
+
+        if Py_TRACE_REFS:
+            # It's a Py_TRACE_REFS build.
+            # This test breaks interpreter isolation a little,
+            # which causes problems on Py_TRACE_REF builds.
+            raise unittest.SkipTest('crashes on Py_TRACE_REFS builds')
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # First, load in the main interpreter but then completely clear it.
+        loaded_main = self.load(self.NAME)
+        loaded_main.module._clear_globals()
+        _testinternalcapi.clear_extension(self.NAME, self.ORIGIN)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def loaded already
+        #  * module def was in _PyRuntime.imports.extensions, but cleared
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy was set, but cleared (was NULL)
+        #  * module's global state was initialized but cleared
+
+        # Start with an interpreter that gets destroyed right away.
+        base = self.import_in_subinterp(
+            postscript='''
+                # Attrs set after loading are not in m_copy.
+                mod.spam = 'spam, spam, mash, spam, eggs, and spam'
+                ''')
+        self.check_common(base)
+        self.check_fresh(base)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset)
+        #  * m_copy is still set (owned by main interpreter)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded_interp1 = self.import_in_subinterp(interpid1)
+        self.check_common(loaded_interp1)
+        self.check_copied(loaded_interp1, base)
+
+        # At this point:
+        #  * alive in 1 interpreter (interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func did not run again
+        #  * m_copy was not changed
+        #  * module's global state was not touched
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded_interp2 = self.import_in_subinterp(interpid2)
+        self.check_common(loaded_interp2)
+        self.check_copied(loaded_interp2, loaded_interp1)
+
+        # At this point:
+        #  * alive in 2 interpreters (interp1, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func did not run again
+        #  * m_copy was not changed
+        #  * module's global state was not touched
+
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_reset_each(self):
+        # resetting between each interpreter
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # Use an interpreter that gets destroyed right away.
+        loaded = self.import_in_subinterp(
+            postscript='''
+            # Attrs set after loading are not in m_copy.
+            mod.spam = 'spam, spam, mash, spam, eggs, and spam'
+            ''',
+            postcleanup=True,
+        )
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy is NULL (claered when the interpreter was destroyed)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded = self.import_in_subinterp(interpid1, postcleanup=True)
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 1 interpreter (interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp1 (was NULL)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded = self.import_in_subinterp(interpid2, postcleanup=True)
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 2 interpreters (interp2, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp2 (was from interp1)
+        #  * module's global state was initialized, not reset
+
+
 if __name__ == '__main__':
     # Test needs to be a package, so we can do relative imports.
     unittest.main()
diff --git a/Lib/test/test_import/data/circular_imports/import_cycle.py b/Lib/test/test_import/data/circular_imports/import_cycle.py
new file mode 100644
index 00000000000..cd9507b5f69
--- /dev/null
+++ b/Lib/test/test_import/data/circular_imports/import_cycle.py
@@ -0,0 +1,3 @@
+import test.test_import.data.circular_imports.import_cycle as m
+
+m.some_attribute
diff --git a/Lib/test/test_import/data/circular_imports/singlephase.py b/Lib/test/test_import/data/circular_imports/singlephase.py
new file mode 100644
index 00000000000..05618bc72f9
--- /dev/null
+++ b/Lib/test/test_import/data/circular_imports/singlephase.py
@@ -0,0 +1,13 @@
+"""Circular import involving a single-phase-init extension.
+
+This module is imported from the _testsinglephase_circular module from
+_testsinglephase, and imports that module again.
+"""
+
+import importlib
+import _testsinglephase
+from test.test_import import import_extension_from_file
+
+name = '_testsinglephase_circular'
+filename = _testsinglephase.__file__
+mod = import_extension_from_file(name, filename)
diff --git a/Lib/test/test_import/data/double_const.py b/Lib/test/test_import/data/double_const.py
new file mode 100644
index 00000000000..67852aaf982
--- /dev/null
+++ b/Lib/test/test_import/data/double_const.py
@@ -0,0 +1,30 @@
+from test.support import TestFailed
+
+# A test for SF bug 422177:  manifest float constants varied way too much in
+# precision depending on whether Python was loading a module for the first
+# time, or reloading it from a precompiled .pyc.  The "expected" failure
+# mode is that when test_import imports this after all .pyc files have been
+# erased, it passes, but when test_import imports this from
+# double_const.pyc, it fails.  This indicates a woeful loss of precision in
+# the marshal format for doubles.  It's also possible that repr() doesn't
+# produce enough digits to get reasonable precision for this box.
+
+PI    = 3.14159265358979324
+TWOPI = 6.28318530717958648
+
+PI_str    = "3.14159265358979324"
+TWOPI_str = "6.28318530717958648"
+
+# Verify that the double x is within a few bits of eval(x_str).
+def check_ok(x, x_str):
+    assert x > 0.0
+    x2 = eval(x_str)
+    assert x2 > 0.0
+    diff = abs(x - x2)
+    # If diff is no larger than 3 ULP (wrt x2), then diff/8 is no larger
+    # than 0.375 ULP, so adding diff/8 to x2 should have no effect.
+    if x2 + (diff / 8.) != x2:
+        raise TestFailed("Manifest const %s lost too much precision " % x_str)
+
+check_ok(PI, PI_str)
+check_ok(TWOPI, TWOPI_str)
diff --git a/Lib/test/test_import/data/package3/__init__.py b/Lib/test/test_import/data/package3/__init__.py
new file mode 100644
index 00000000000..7033c22a719
--- /dev/null
+++ b/Lib/test/test_import/data/package3/__init__.py
@@ -0,0 +1,2 @@
+"""Rebinding the package attribute after importing the module."""
+from .submodule import submodule
diff --git a/Lib/test/test_import/data/package3/submodule.py b/Lib/test/test_import/data/package3/submodule.py
new file mode 100644
index 00000000000..cd7b30db15e
--- /dev/null
+++ b/Lib/test/test_import/data/package3/submodule.py
@@ -0,0 +1,7 @@
+attr = 'submodule'
+class A:
+    attr = 'submodule'
+class submodule:
+    attr = 'rebound'
+    class B:
+        attr = 'rebound'
diff --git a/Lib/test/test_import/data/package4/__init__.py b/Lib/test/test_import/data/package4/__init__.py
new file mode 100644
index 00000000000..d8af60ab38a
--- /dev/null
+++ b/Lib/test/test_import/data/package4/__init__.py
@@ -0,0 +1,5 @@
+"""Binding the package attribute without importing the module."""
+class submodule:
+    attr = 'origin'
+    class B:
+        attr = 'origin'
diff --git a/Lib/test/test_import/data/package4/submodule.py b/Lib/test/test_import/data/package4/submodule.py
new file mode 100644
index 00000000000..c861417aece
--- /dev/null
+++ b/Lib/test/test_import/data/package4/submodule.py
@@ -0,0 +1,3 @@
+attr = 'submodule'
+class A:
+    attr = 'submodule'
diff --git a/Lib/test/test_pkgutil.py b/Lib/test/test_pkgutil.py
index ece4cf2d05f..0d44092dabc 100644
--- a/Lib/test/test_pkgutil.py
+++ b/Lib/test/test_pkgutil.py
@@ -1,5 +1,6 @@
+from pathlib import Path
 from test.support.import_helper import unload, CleanImport
-from test.support.warnings_helper import check_warnings
+from test.support.warnings_helper import check_warnings, ignore_warnings
 import unittest
 import sys
 import importlib
@@ -11,6 +12,10 @@
 import shutil
 import zipfile
 
+from test.support.import_helper import DirsOnSysPath
+from test.support.os_helper import FakePath
+from test.test_importlib.util import uncache
+
 # Note: pkgutil.walk_packages is currently tested in test_runpy. This is
 # a hack to get a major issue resolved for 3.3b2. Longer term, it should
 # be moved back here, perhaps by factoring out the helper code for
@@ -91,6 +96,45 @@ def test_getdata_zipfile(self):
 
         del sys.modules[pkg]
 
+    def test_issue44061_iter_modules(self):
+        #see: issue44061
+        zip = 'test_getdata_zipfile.zip'
+        pkg = 'test_getdata_zipfile'
+
+        # Include a LF and a CRLF, to test that binary data is read back
+        RESOURCE_DATA = b'Hello, world!\nSecond line\r\nThird line'
+
+        # Make a package with some resources
+        zip_file = os.path.join(self.dirname, zip)
+        z = zipfile.ZipFile(zip_file, 'w')
+
+        # Empty init.py
+        z.writestr(pkg + '/__init__.py', "")
+        # Resource files, res.txt
+        z.writestr(pkg + '/res.txt', RESOURCE_DATA)
+        z.close()
+
+        # Check we can read the resources
+        sys.path.insert(0, zip_file)
+        try:
+            res = pkgutil.get_data(pkg, 'res.txt')
+            self.assertEqual(res, RESOURCE_DATA)
+
+            # make sure iter_modules accepts Path objects
+            names = []
+            for moduleinfo in pkgutil.iter_modules([FakePath(zip_file)]):
+                self.assertIsInstance(moduleinfo, pkgutil.ModuleInfo)
+                names.append(moduleinfo.name)
+            self.assertEqual(names, [pkg])
+        finally:
+            del sys.path[0]
+            sys.modules.pop(pkg, None)
+
+        # assert path must be None or list of paths
+        expected_msg = "path must be None or list of paths to look for modules in"
+        with self.assertRaisesRegex(ValueError, expected_msg):
+            list(pkgutil.iter_modules("invalid_path"))
+
     def test_unreadable_dir_on_syspath(self):
         # issue7367 - walk_packages failed if unreadable dir on sys.path
         package_name = "unreadable_package"
@@ -187,8 +231,7 @@ def test_walk_packages_raises_on_string_or_bytes_input(self):
         with self.assertRaises((TypeError, ValueError)):
             list(pkgutil.walk_packages(bytes_input))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_name_resolution(self):
         import logging
         import logging.handlers
@@ -280,6 +323,38 @@ def test_name_resolution(self):
                 with self.assertRaises(exc):
                     pkgutil.resolve_name(s)
 
+    def test_name_resolution_import_rebinding(self):
+        # The same data is also used for testing import in test_import and
+        # mock.patch in test_unittest.
+        path = os.path.join(os.path.dirname(__file__), 'test_import', 'data')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3.submodule.attr'), 'submodule')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3.submodule:attr'), 'submodule')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+            self.assertEqual(pkgutil.resolve_name('package3.submodule.attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+            self.assertEqual(pkgutil.resolve_name('package3.submodule:attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+
+    def test_name_resolution_import_rebinding2(self):
+        path = os.path.join(os.path.dirname(__file__), 'test_import', 'data')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4.submodule.attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4.submodule:attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'origin')
+            self.assertEqual(pkgutil.resolve_name('package4.submodule.attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'origin')
+            self.assertEqual(pkgutil.resolve_name('package4.submodule:attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'submodule')
+
 
 class PkgutilPEP302Tests(unittest.TestCase):
 
@@ -391,7 +466,7 @@ def test_iter_importers(self):
             importers = list(iter_importers(fullname))
             expected_importer = get_importer(pathitem)
             for finder in importers:
-                spec = pkgutil._get_spec(finder, fullname)
+                spec = finder.find_spec(fullname)
                 loader = spec.loader
                 try:
                     loader = loader.loader
@@ -403,7 +478,7 @@ def test_iter_importers(self):
                 self.assertEqual(finder, expected_importer)
                 self.assertIsInstance(loader,
                                       importlib.machinery.SourceFileLoader)
-                self.assertIsNone(pkgutil._get_spec(finder, pkgname))
+                self.assertIsNone(finder.find_spec(pkgname))
 
             with self.assertRaises(ImportError):
                 list(iter_importers('invalid.module'))
@@ -448,7 +523,43 @@ def test_mixed_namespace(self):
         del sys.modules['foo.bar']
         del sys.modules['foo.baz']
 
-    # XXX: test .pkg files
+
+    def test_extend_path_argument_types(self):
+        pkgname = 'foo'
+        dirname_0 = self.create_init(pkgname)
+
+        # If the input path is not a list it is returned unchanged
+        self.assertEqual('notalist', pkgutil.extend_path('notalist', 'foo'))
+        self.assertEqual(('not', 'a', 'list'), pkgutil.extend_path(('not', 'a', 'list'), 'foo'))
+        self.assertEqual(123, pkgutil.extend_path(123, 'foo'))
+        self.assertEqual(None, pkgutil.extend_path(None, 'foo'))
+
+        # Cleanup
+        shutil.rmtree(dirname_0)
+        del sys.path[0]
+
+
+    def test_extend_path_pkg_files(self):
+        pkgname = 'foo'
+        dirname_0 = self.create_init(pkgname)
+
+        with open(os.path.join(dirname_0, 'bar.pkg'), 'w') as pkg_file:
+            pkg_file.write('\n'.join([
+                'baz',
+                '/foo/bar/baz',
+                '',
+                '#comment'
+            ]))
+
+        extended_paths = pkgutil.extend_path(sys.path, 'bar')
+
+        self.assertEqual(extended_paths[:-2], sys.path)
+        self.assertEqual(extended_paths[-2], 'baz')
+        self.assertEqual(extended_paths[-1], '/foo/bar/baz')
+
+        # Cleanup
+        shutil.rmtree(dirname_0)
+        del sys.path[0]
 
 
 class NestedNamespacePackageTest(unittest.TestCase):
@@ -491,36 +602,50 @@ def test_nested(self):
         self.assertEqual(c, 1)
         self.assertEqual(d, 2)
 
+
+class ImportlibMigrationTests(unittest.TestCase):
+    # With full PEP 302 support in the standard import machinery, the
+    # PEP 302 emulation in this module is in the process of being
+    # deprecated in favour of importlib proper
+
     @unittest.skipIf(__name__ == '__main__', 'not compatible with __main__')
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_missing_loader_attribute(self):
         global __loader__
         this_loader = __loader__
         del __loader__
         try:
-            with check_warnings() as w:
-                self.assertIsNotNone(pkgutil.get_loader(__name__))
-                self.assertEqual(len(w.warnings), 0)
+            self.assertIsNotNone(pkgutil.get_loader(__name__))
         finally:
             __loader__ = this_loader
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_missing_spec_attribute(self):
         name = 'spam'
         mod = type(sys)(name)
         del mod.__spec__
         with CleanImport(name):
-            sys.modules[name] = mod
-            loader = pkgutil.get_loader(name)
+            try:
+                sys.modules[name] = mod
+                loader = pkgutil.get_loader(name)
+            finally:
+                sys.modules.pop(name, None)
         self.assertIsNone(loader)
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_spec_attribute_none(self):
         name = 'spam'
         mod = type(sys)(name)
         mod.__spec__ = None
         with CleanImport(name):
-            sys.modules[name] = mod
-            loader = pkgutil.get_loader(name)
+            try:
+                sys.modules[name] = mod
+                loader = pkgutil.get_loader(name)
+            finally:
+                sys.modules.pop(name, None)
         self.assertIsNone(loader)
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_None_in_sys_modules(self):
         name = 'totally bogus'
         sys.modules[name] = None
@@ -530,24 +655,38 @@ def test_get_loader_None_in_sys_modules(self):
             del sys.modules[name]
         self.assertIsNone(loader)
 
+    def test_get_loader_is_deprecated(self):
+        with check_warnings(
+            (r".*\bpkgutil.get_loader\b.*", DeprecationWarning),
+        ):
+            res = pkgutil.get_loader("sys")
+        self.assertIsNotNone(res)
+
+    def test_find_loader_is_deprecated(self):
+        with check_warnings(
+            (r".*\bpkgutil.find_loader\b.*", DeprecationWarning),
+        ):
+            res = pkgutil.find_loader("sys")
+        self.assertIsNotNone(res)
+
+    @ignore_warnings(category=DeprecationWarning)
     def test_find_loader_missing_module(self):
         name = 'totally bogus'
         loader = pkgutil.find_loader(name)
         self.assertIsNone(loader)
 
-    def test_find_loader_avoids_emulation(self):
-        with check_warnings() as w:
-            self.assertIsNotNone(pkgutil.find_loader("sys"))
-            self.assertIsNotNone(pkgutil.find_loader("os"))
-            self.assertIsNotNone(pkgutil.find_loader("test.support"))
-            self.assertEqual(len(w.warnings), 0)
-
     def test_get_importer_avoids_emulation(self):
         # We use an illegal path so *none* of the path hooks should fire
         with check_warnings() as w:
             self.assertIsNone(pkgutil.get_importer("*??"))
             self.assertEqual(len(w.warnings), 0)
 
+    def test_issue44061(self):
+        try:
+            pkgutil.get_importer(Path("/home"))
+        except AttributeError:
+            self.fail("Unexpected AttributeError when calling get_importer")
+
     def test_iter_importers_avoids_emulation(self):
         with check_warnings() as w:
             for importer in pkgutil.iter_importers(): pass
diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index 1d2b87f161c..f77a5888eeb 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -48,8 +48,7 @@ def setUp(self):
         # starting a new event loop
         self.addCleanup(support.gc_collect)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_full_cycle(self):
         expected = ['setUp',
                     'asyncSetUp',
@@ -296,8 +295,7 @@ async def on_cleanup2(self):
         test.doCleanups()
         self.assertEqual(events, ['asyncSetUp', 'test', 'asyncTearDown', 'cleanup2', 'cleanup1'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_deprecation_of_return_val_from_test(self):
         # Issue 41322 - deprecate return of value that is not None from a test
         class Nothing:
@@ -488,8 +486,7 @@ async def test_demo1(self):
         result = test.run()
         self.assertTrue(result.wasSuccessful())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_loop_factory(self):
         asyncio.set_event_loop_policy(None)
 
diff --git a/Lib/test/test_unittest/test_discovery.py b/Lib/test/test_unittest/test_discovery.py
index 9e231ff8d2d..a44b18406c0 100644
--- a/Lib/test/test_unittest/test_discovery.py
+++ b/Lib/test/test_unittest/test_discovery.py
@@ -364,8 +364,6 @@ def __eq__(self, other):
                          [(loader, [], 'test*.py'),
                           (loader, [], 'test*.py')])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_discover(self):
         loader = unittest.TestLoader()
 
@@ -412,8 +410,6 @@ def _find_tests(start_dir, pattern):
         self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
         self.assertIn(top_level_dir, sys.path)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_discover_should_not_persist_top_level_dir_between_calls(self):
         original_isfile = os.path.isfile
         original_isdir = os.path.isdir
diff --git a/Lib/test/test_unittest/test_loader.py b/Lib/test/test_unittest/test_loader.py
index 9881335318e..83dd25ca546 100644
--- a/Lib/test/test_unittest/test_loader.py
+++ b/Lib/test/test_unittest/test_loader.py
@@ -90,8 +90,6 @@ def test_loadTestsFromTestCase__from_TestCase(self):
         self.assertIsInstance(suite, loader.suiteClass)
         self.assertEqual(list(suite), [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # "Do not load any tests from `FunctionTestCase` class."
     def test_loadTestsFromTestCase__from_FunctionTestCase(self):
         loader = unittest.TestLoader()
@@ -121,8 +119,6 @@ def test(self):
         expected = [loader.suiteClass([MyTestCase('test')])]
         self.assertEqual(list(suite), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # "This test ensures that internal `TestCase` subclasses are not loaded"
     def test_loadTestsFromModule__TestCase_subclass_internals(self):
         # See https://github.com/python/cpython/issues/84867
@@ -187,8 +183,6 @@ class NotAModule(object):
         self.assertEqual(list(suite), reference)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Check that loadTestsFromModule honors a module
     # with a load_tests function.
     def test_loadTestsFromModule__load_tests(self):
diff --git a/Lib/test/test_unittest/test_program.py b/Lib/test/test_unittest/test_program.py
index 8256aaeb8c3..2e3a7508478 100644
--- a/Lib/test/test_unittest/test_program.py
+++ b/Lib/test/test_unittest/test_program.py
@@ -75,6 +75,14 @@ def testUnexpectedSuccess(self):
     class Empty(unittest.TestCase):
         pass
 
+    class SetUpClassFailure(unittest.TestCase):
+        @classmethod
+        def setUpClass(cls):
+            super().setUpClass()
+            raise Exception
+        def testPass(self):
+            pass
+
     class TestLoader(unittest.TestLoader):
         """Test loader that returns a suite containing the supplied testcase."""
 
@@ -191,6 +199,18 @@ def test_ExitEmptySuite(self):
         out = stream.getvalue()
         self.assertIn('\nNO TESTS RAN\n', out)
 
+    def test_ExitSetUpClassFailureSuite(self):
+        stream = BufferedWriter()
+        with self.assertRaises(SystemExit) as cm:
+            unittest.main(
+                argv=["setup_class_failure"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                testLoader=self.TestLoader(self.SetUpClassFailure))
+        self.assertEqual(cm.exception.code, 1)
+        out = stream.getvalue()
+        self.assertIn("ERROR: setUpClass", out)
+        self.assertIn("SetUpClassFailure", out)
+
 
 class InitialisableProgram(unittest.TestProgram):
     exit = False
@@ -485,8 +505,8 @@ def testParseArgsSelectedTestNames(self):
 
         self.assertEqual(program.testNamePatterns, ['*foo*', '*bar*', '*pat*'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailureIf(sys.platform != 'win32', "TODO: RUSTPYTHON")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON')
+    
     def testSelectedTestNamesFunctionalTest(self):
         def run_unittest(args):
             # Use -E to ignore PYTHONSAFEPATH env var
diff --git a/Lib/test/test_unittest/test_runner.py b/Lib/test/test_unittest/test_runner.py
index a652c71513d..790c4d29ca2 100644
--- a/Lib/test/test_unittest/test_runner.py
+++ b/Lib/test/test_unittest/test_runner.py
@@ -1297,8 +1297,7 @@ def _makeResult(self):
         expected = ['startTestRun', 'stopTestRun']
         self.assertEqual(events, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickle_unpickle(self):
         # Issue #7197: a TextTestRunner should be (un)pickleable. This is
         # required by test_multiprocessing under Windows (in verbose mode).
diff --git a/Lib/test/test_unittest/testmock/testasync.py b/Lib/test/test_unittest/testmock/testasync.py
index 06ec7ea2045..ddc6f0599c8 100644
--- a/Lib/test/test_unittest/testmock/testasync.py
+++ b/Lib/test/test_unittest/testmock/testasync.py
@@ -340,8 +340,7 @@ def test_spec_async_attributes_instance(self):
         # only the shape of the spec at the time of mock construction matters
         self.assertNotIsInstance(mock_async_instance.later_async_func_attr, AsyncMock)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_spec_mock_type_kw(self):
         def inner_test(mock_type):
             async_mock = mock_type(spec=async_func)
@@ -356,8 +355,7 @@ def inner_test(mock_type):
             with self.subTest(f"test spec kwarg with {mock_type}"):
                 inner_test(mock_type)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_spec_mock_type_positional(self):
         def inner_test(mock_type):
             async_mock = mock_type(async_func)
@@ -736,8 +734,7 @@ def __aiter__(self): pass
 
         async def __anext__(self): pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_aiter_set_return_value(self):
         mock_iter = AsyncMock(name="tester")
         mock_iter.__aiter__.return_value = [1, 2, 3]
@@ -763,8 +760,7 @@ def inner_test(mock_type):
                 inner_test(mock_type)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mock_async_for(self):
         async def iterate(iterator):
             accumulator = []
@@ -810,8 +806,7 @@ async def _runnable_test(self, *args, **kwargs):
     async def _await_coroutine(self, coroutine):
         return await coroutine
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_but_not_awaited(self):
         mock = AsyncMock(AsyncClass)
         with assertNeverAwaited(self):
@@ -852,8 +847,7 @@ def test_assert_called_and_awaited_at_same_time(self):
         self.mock.assert_called_once()
         self.mock.assert_awaited_once()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_twice_and_awaited_once(self):
         mock = AsyncMock(AsyncClass)
         coroutine = mock.async_method()
@@ -868,8 +862,7 @@ def test_assert_called_twice_and_awaited_once(self):
         mock.async_method.assert_awaited()
         mock.async_method.assert_awaited_once()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_once_and_awaited_twice(self):
         mock = AsyncMock(AsyncClass)
         coroutine = mock.async_method()
@@ -894,8 +887,7 @@ def test_assert_awaited_but_not_called(self):
         with self.assertRaises(AssertionError):
             self.mock.assert_called()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_calls_not_awaits(self):
         kalls = [call('foo')]
         with assertNeverAwaited(self):
@@ -904,8 +896,7 @@ def test_assert_has_calls_not_awaits(self):
         with self.assertRaises(AssertionError):
             self.mock.assert_has_awaits(kalls)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_mock_calls_on_async_mock_no_spec(self):
         with assertNeverAwaited(self):
             self.mock()
@@ -919,8 +910,7 @@ def test_assert_has_mock_calls_on_async_mock_no_spec(self):
         mock_kalls = ([call(), call('foo'), call('baz')])
         self.assertEqual(self.mock.mock_calls, mock_kalls)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_mock_calls_on_async_mock_with_spec(self):
         a_class_mock = AsyncMock(AsyncClass)
         with assertNeverAwaited(self):
@@ -936,8 +926,7 @@ def test_assert_has_mock_calls_on_async_mock_with_spec(self):
         self.assertEqual(a_class_mock.async_method.mock_calls, method_kalls)
         self.assertEqual(a_class_mock.mock_calls, mock_kalls)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_async_method_calls_recorded(self):
         with assertNeverAwaited(self):
             self.mock.something(3, fish=None)
@@ -953,8 +942,7 @@ def test_async_method_calls_recorded(self):
                          [("something", (6,), {'cake': sentinel.Cake})],
                          "method calls not recorded correctly")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_async_arg_lists(self):
         def assert_attrs(mock):
             names = ('call_args_list', 'method_calls', 'mock_calls')
diff --git a/Lib/test/test_unittest/testmock/testhelpers.py b/Lib/test/test_unittest/testmock/testhelpers.py
index c83068beb15..a19f04eb88f 100644
--- a/Lib/test/test_unittest/testmock/testhelpers.py
+++ b/Lib/test/test_unittest/testmock/testhelpers.py
@@ -43,8 +43,7 @@ def test_any_and_datetime(self):
         mock.assert_called_with(ANY, foo=ANY)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_any_mock_calls_comparison_order(self):
         mock = Mock()
         class Foo(object):
diff --git a/Lib/test/test_unittest/testmock/testpatch.py b/Lib/test/test_unittest/testmock/testpatch.py
index 62c6221f774..87424e07e4e 100644
--- a/Lib/test/test_unittest/testmock/testpatch.py
+++ b/Lib/test/test_unittest/testmock/testpatch.py
@@ -1778,8 +1778,6 @@ def test(mock):
                             'exception traceback not propagated')
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_resolution_import_rebinding(self):
         # Currently mock.patch uses pkgutil.resolve_name(), but repeat
         # similar tests just for the case.
@@ -1814,8 +1812,6 @@ def check_error(name):
             check('package3:submodule.B.attr')
             check_error('package3:submodule.A.attr')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name_resolution_import_rebinding2(self):
         path = os.path.join(os.path.dirname(test.__file__), 'test_import', 'data')
         def check(name):
@@ -2016,8 +2012,7 @@ def test_patch_and_patch_dict_stopall(self):
         self.assertEqual(dic2, origdic2)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_special_attrs(self):
         def foo(x=0):
             """TEST"""
diff --git a/Lib/unittest/__init__.py b/Lib/unittest/__init__.py
index 7ab3f5e87b4..6878c2a8f5a 100644
--- a/Lib/unittest/__init__.py
+++ b/Lib/unittest/__init__.py
@@ -51,10 +51,6 @@ def testMultiply(self):
            'registerResult', 'removeResult', 'removeHandler',
            'addModuleCleanup', 'doModuleCleanups', 'enterModuleContext']
 
-# Expose obsolete functions for backwards compatibility
-# bpo-5846: Deprecated in Python 3.11, scheduled for removal in Python 3.13.
-__all__.extend(['getTestCaseNames', 'makeSuite', 'findTestCases'])
-
 __unittest = True
 
 from .result import TestResult
@@ -67,20 +63,6 @@ def testMultiply(self):
 from .runner import TextTestRunner, TextTestResult
 from .signals import installHandler, registerResult, removeResult, removeHandler
 # IsolatedAsyncioTestCase will be imported lazily.
-from .loader import makeSuite, getTestCaseNames, findTestCases
-
-# deprecated
-_TextTestResult = TextTestResult
-
-
-# There are no tests here, so don't try to run anything discovered from
-# introspecting the symbols (e.g. FunctionTestCase). Instead, all our
-# tests come from within unittest.test.
-def load_tests(loader, tests, pattern):
-    import os.path
-    # top level directory cached on loader instance
-    this_dir = os.path.dirname(__file__)
-    return loader.discover(start_dir=this_dir, pattern=pattern)
 
 
 # Lazy import of IsolatedAsyncioTestCase from .async_case
@@ -98,6 +80,7 @@ def __getattr__(name):
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
+
 # XXX: RUSTPYTHON
 # This is very useful to reduce platform difference boilerplates in tests.
 def expectedFailureIf(condition, reason):
@@ -111,4 +94,4 @@ def expectedFailureIf(condition, reason):
 # Even more useful because most of them are windows only.
 def expectedFailureIfWindows(reason):
     import sys
-    return expectedFailureIf(sys.platform == 'win32', reason)
+    return expectedFailureIf(sys.platform == 'win32', reason)
\ No newline at end of file
diff --git a/Lib/unittest/async_case.py b/Lib/unittest/async_case.py
index bd2a4711560..e761ba7e53c 100644
--- a/Lib/unittest/async_case.py
+++ b/Lib/unittest/async_case.py
@@ -5,6 +5,7 @@
 
 from .case import TestCase
 
+__unittest = True
 
 class IsolatedAsyncioTestCase(TestCase):
     # Names intentionally have a long prefix
@@ -25,12 +26,15 @@ class IsolatedAsyncioTestCase(TestCase):
     # them inside the same task.
 
     # Note: the test case modifies event loop policy if the policy was not instantiated
-    # yet.
+    # yet, unless loop_factory=asyncio.EventLoop is set.
     # asyncio.get_event_loop_policy() creates a default policy on demand but never
     # returns None
     # I believe this is not an issue in user level tests but python itself for testing
     # should reset a policy in every test module
     # by calling asyncio.set_event_loop_policy(None) in tearDownModule()
+    # or set loop_factory=asyncio.EventLoop
+
+    loop_factory = None
 
     def __init__(self, methodName='runTest'):
         super().__init__(methodName)
@@ -118,7 +122,7 @@ def _callMaybeAsync(self, func, /, *args, **kwargs):
 
     def _setupAsyncioRunner(self):
         assert self._asyncioRunner is None, 'asyncio runner is already initialized'
-        runner = asyncio.Runner(debug=True)
+        runner = asyncio.Runner(debug=True, loop_factory=self.loop_factory)
         self._asyncioRunner = runner
 
     def _tearDownAsyncioRunner(self):
diff --git a/Lib/unittest/loader.py b/Lib/unittest/loader.py
index 7e6ce2f224b..22797b83a68 100644
--- a/Lib/unittest/loader.py
+++ b/Lib/unittest/loader.py
@@ -6,7 +6,6 @@
 import traceback
 import types
 import functools
-import warnings
 
 from fnmatch import fnmatch, fnmatchcase
 
@@ -57,9 +56,7 @@ def testSkipped(self):
     TestClass = type("ModuleSkipped", (case.TestCase,), attrs)
     return suiteClass((TestClass(methodname),))
 
-def _jython_aware_splitext(path):
-    if path.lower().endswith('$py.class'):
-        return path[:-9]
+def _splitext(path):
     return os.path.splitext(path)[0]
 
 
@@ -87,40 +84,26 @@ def loadTestsFromTestCase(self, testCaseClass):
             raise TypeError("Test cases should not be derived from "
                             "TestSuite. Maybe you meant to derive from "
                             "TestCase?")
-        testCaseNames = self.getTestCaseNames(testCaseClass)
-        if not testCaseNames and hasattr(testCaseClass, 'runTest'):
-            testCaseNames = ['runTest']
+        if testCaseClass in (case.TestCase, case.FunctionTestCase):
+            # We don't load any tests from base types that should not be loaded.
+            testCaseNames = []
+        else:
+            testCaseNames = self.getTestCaseNames(testCaseClass)
+            if not testCaseNames and hasattr(testCaseClass, 'runTest'):
+                testCaseNames = ['runTest']
         loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
         return loaded_suite
 
-    # XXX After Python 3.5, remove backward compatibility hacks for
-    # use_load_tests deprecation via *args and **kws.  See issue 16662.
-    def loadTestsFromModule(self, module, *args, pattern=None, **kws):
+    def loadTestsFromModule(self, module, *, pattern=None):
         """Return a suite of all test cases contained in the given module"""
-        # This method used to take an undocumented and unofficial
-        # use_load_tests argument.  For backward compatibility, we still
-        # accept the argument (which can also be the first position) but we
-        # ignore it and issue a deprecation warning if it's present.
-        if len(args) > 0 or 'use_load_tests' in kws:
-            warnings.warn('use_load_tests is deprecated and ignored',
-                          DeprecationWarning)
-            kws.pop('use_load_tests', None)
-        if len(args) > 1:
-            # Complain about the number of arguments, but don't forget the
-            # required `module` argument.
-            complaint = len(args) + 1
-            raise TypeError('loadTestsFromModule() takes 1 positional argument but {} were given'.format(complaint))
-        if len(kws) != 0:
-            # Since the keyword arguments are unsorted (see PEP 468), just
-            # pick the alphabetically sorted first argument to complain about,
-            # if multiple were given.  At least the error message will be
-            # predictable.
-            complaint = sorted(kws)[0]
-            raise TypeError("loadTestsFromModule() got an unexpected keyword argument '{}'".format(complaint))
         tests = []
         for name in dir(module):
             obj = getattr(module, name)
-            if isinstance(obj, type) and issubclass(obj, case.TestCase):
+            if (
+                isinstance(obj, type)
+                and issubclass(obj, case.TestCase)
+                and obj not in (case.TestCase, case.FunctionTestCase)
+            ):
                 tests.append(self.loadTestsFromTestCase(obj))
 
         load_tests = getattr(module, 'load_tests', None)
@@ -189,7 +172,11 @@ def loadTestsFromName(self, name, module=None):
 
         if isinstance(obj, types.ModuleType):
             return self.loadTestsFromModule(obj)
-        elif isinstance(obj, type) and issubclass(obj, case.TestCase):
+        elif (
+            isinstance(obj, type)
+            and issubclass(obj, case.TestCase)
+            and obj not in (case.TestCase, case.FunctionTestCase)
+        ):
             return self.loadTestsFromTestCase(obj)
         elif (isinstance(obj, types.FunctionType) and
               isinstance(parent, type) and
@@ -267,6 +254,7 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
         Paths are sorted before being imported to ensure reproducible execution
         order even on filesystems with non-alphabetical ordering like ext3/4.
         """
+        original_top_level_dir = self._top_level_dir
         set_implicit_top = False
         if top_level_dir is None and self._top_level_dir is not None:
             # make top_level_dir optional if called from load_tests in a package
@@ -320,6 +308,7 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
             raise ImportError('Start directory is not importable: %r' % start_dir)
 
         tests = list(self._find_tests(start_dir, pattern))
+        self._top_level_dir = original_top_level_dir
         return self.suiteClass(tests)
 
     def _get_directory_containing_module(self, module_name):
@@ -337,7 +326,7 @@ def _get_directory_containing_module(self, module_name):
     def _get_name_from_path(self, path):
         if path == self._top_level_dir:
             return '.'
-        path = _jython_aware_splitext(os.path.normpath(path))
+        path = _splitext(os.path.normpath(path))
 
         _relpath = os.path.relpath(path, self._top_level_dir)
         assert not os.path.isabs(_relpath), "Path must be within the project"
@@ -415,13 +404,13 @@ def _find_test_path(self, full_path, pattern):
             else:
                 mod_file = os.path.abspath(
                     getattr(module, '__file__', full_path))
-                realpath = _jython_aware_splitext(
+                realpath = _splitext(
                     os.path.realpath(mod_file))
-                fullpath_noext = _jython_aware_splitext(
+                fullpath_noext = _splitext(
                     os.path.realpath(full_path))
                 if realpath.lower() != fullpath_noext.lower():
                     module_dir = os.path.dirname(realpath)
-                    mod_name = _jython_aware_splitext(
+                    mod_name = _splitext(
                         os.path.basename(full_path))
                     expected_dir = os.path.dirname(full_path)
                     msg = ("%r module incorrectly imported from %r. Expected "
@@ -462,47 +451,3 @@ def _find_test_path(self, full_path, pattern):
 
 
 defaultTestLoader = TestLoader()
-
-
-# These functions are considered obsolete for long time.
-# They will be removed in Python 3.13.
-
-def _makeLoader(prefix, sortUsing, suiteClass=None, testNamePatterns=None):
-    loader = TestLoader()
-    loader.sortTestMethodsUsing = sortUsing
-    loader.testMethodPrefix = prefix
-    loader.testNamePatterns = testNamePatterns
-    if suiteClass:
-        loader.suiteClass = suiteClass
-    return loader
-
-def getTestCaseNames(testCaseClass, prefix, sortUsing=util.three_way_cmp, testNamePatterns=None):
-    import warnings
-    warnings.warn(
-        "unittest.getTestCaseNames() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.getTestCaseNames() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, testNamePatterns=testNamePatterns).getTestCaseNames(testCaseClass)
-
-def makeSuite(testCaseClass, prefix='test', sortUsing=util.three_way_cmp,
-              suiteClass=suite.TestSuite):
-    import warnings
-    warnings.warn(
-        "unittest.makeSuite() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.loadTestsFromTestCase() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(
-        testCaseClass)
-
-def findTestCases(module, prefix='test', sortUsing=util.three_way_cmp,
-                  suiteClass=suite.TestSuite):
-    import warnings
-    warnings.warn(
-        "unittest.findTestCases() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.loadTestsFromModule() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(\
-        module)
diff --git a/Lib/unittest/main.py b/Lib/unittest/main.py
index c3869de3f6f..a0cd8a9f7ea 100644
--- a/Lib/unittest/main.py
+++ b/Lib/unittest/main.py
@@ -269,12 +269,12 @@ def runTests(self):
             testRunner = self.testRunner
         self.result = testRunner.run(self.test)
         if self.exit:
-            if self.result.testsRun == 0 and len(self.result.skipped) == 0:
+            if not self.result.wasSuccessful():
+                sys.exit(1)
+            elif self.result.testsRun == 0 and len(self.result.skipped) == 0:
                 sys.exit(_NO_TESTS_EXITCODE)
-            elif self.result.wasSuccessful():
-                sys.exit(0)
             else:
-                sys.exit(1)
+                sys.exit(0)
 
 
 main = TestProgram

From f929a6eef8862adbc6a5f8946ad77081acc19bbb Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 3 Jan 2026 20:02:24 -0500
Subject: [PATCH 164/418] Updated the platform + plistlib libraries +
 associated tests v.3.13.10 (#6611)

* Updated plistlib + test library

* Updated the platform library + test

* Re-added Rustpython platform version
---
 Lib/platform.py           | 394 +++++++++++++++++++++++++-------------
 Lib/plistlib.py           | 134 ++++++++-----
 Lib/test/test_platform.py | 224 ++++++++++++++++++----
 Lib/test/test_plistlib.py | 225 ++++++++++++++++++++--
 4 files changed, 748 insertions(+), 229 deletions(-)

diff --git a/Lib/platform.py b/Lib/platform.py
index c64c6d2c6f5..1a533688a94 100755
--- a/Lib/platform.py
+++ b/Lib/platform.py
@@ -10,7 +10,8 @@
 """
 #    This module is maintained by Marc-Andre Lemburg <mal@egenix.com>.
 #    If you find problems, please submit bug reports/patches via the
-#    Python bug tracker (http://bugs.python.org) and assign them to "lemburg".
+#    Python issue tracker (https://github.com/python/cpython/issues) and
+#    mention "@malemburg".
 #
 #    Still needed:
 #    * support for MS-DOS (PythonDX ?)
@@ -118,6 +119,10 @@
 import sys
 import functools
 import itertools
+try:
+    import _wmi
+except ImportError:
+    _wmi = None
 
 ### Globals & Constants
 
@@ -136,11 +141,11 @@
     'pl': 200, 'p': 200,
 }
 
-_component_re = re.compile(r'([0-9]+|[._+-])')
 
 def _comparable_version(version):
+    component_re = re.compile(r'([0-9]+|[._+-])')
     result = []
-    for v in _component_re.split(version):
+    for v in component_re.split(version):
         if v not in '._+-':
             try:
                 v = int(v, 10)
@@ -152,11 +157,6 @@ def _comparable_version(version):
 
 ### Platform specific APIs
 
-_libc_search = re.compile(b'(__libc_init)'
-                          b'|'
-                          b'(GLIBC_([0-9.]+))'
-                          b'|'
-                          br'(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)', re.ASCII)
 
 def libc_ver(executable=None, lib='', version='', chunksize=16384):
 
@@ -190,6 +190,12 @@ def libc_ver(executable=None, lib='', version='', chunksize=16384):
             # sys.executable is not set.
             return lib, version
 
+    libc_search = re.compile(b'(__libc_init)'
+                          b'|'
+                          b'(GLIBC_([0-9.]+))'
+                          b'|'
+                          br'(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)', re.ASCII)
+
     V = _comparable_version
     # We use os.path.realpath()
     # here to work around problems with Cygwin not being
@@ -200,7 +206,7 @@ def libc_ver(executable=None, lib='', version='', chunksize=16384):
         pos = 0
         while pos < len(binary):
             if b'libc' in binary or b'GLIBC' in binary:
-                m = _libc_search.search(binary, pos)
+                m = libc_search.search(binary, pos)
             else:
                 m = None
             if not m or m.end() == len(binary):
@@ -247,9 +253,6 @@ def _norm_version(version, build=''):
     version = '.'.join(strings[:3])
     return version
 
-_ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
-                         r'.*'
-                         r'\[.* ([\d.]+)\])')
 
 # Examples of VER command output:
 #
@@ -295,9 +298,13 @@ def _syscmd_ver(system='', release='', version='',
     else:
         return system, release, version
 
+    ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
+                         r'.*'
+                         r'\[.* ([\d.]+)\])')
+
     # Parse the output
     info = info.strip()
-    m = _ver_output.match(info)
+    m = ver_output.match(info)
     if m is not None:
         system, release, version = m.groups()
         # Strip trailing dots from version and release
@@ -310,44 +317,62 @@ def _syscmd_ver(system='', release='', version='',
         version = _norm_version(version)
     return system, release, version
 
-_WIN32_CLIENT_RELEASES = {
-    (5, 0): "2000",
-    (5, 1): "XP",
-    # Strictly, 5.2 client is XP 64-bit, but platform.py historically
-    # has always called it 2003 Server
-    (5, 2): "2003Server",
-    (5, None): "post2003",
-
-    (6, 0): "Vista",
-    (6, 1): "7",
-    (6, 2): "8",
-    (6, 3): "8.1",
-    (6, None): "post8.1",
-
-    (10, 0): "10",
-    (10, None): "post10",
-}
-
-# Server release name lookup will default to client names if necessary
-_WIN32_SERVER_RELEASES = {
-    (5, 2): "2003Server",
 
-    (6, 0): "2008Server",
-    (6, 1): "2008ServerR2",
-    (6, 2): "2012Server",
-    (6, 3): "2012ServerR2",
-    (6, None): "post2012ServerR2",
-}
+def _wmi_query(table, *keys):
+    global _wmi
+    if not _wmi:
+        raise OSError("not supported")
+    table = {
+        "OS": "Win32_OperatingSystem",
+        "CPU": "Win32_Processor",
+    }[table]
+    try:
+        data = _wmi.exec_query("SELECT {} FROM {}".format(
+            ",".join(keys),
+            table,
+        )).split("\0")
+    except OSError:
+        _wmi = None
+        raise OSError("not supported")
+    split_data = (i.partition("=") for i in data)
+    dict_data = {i[0]: i[2] for i in split_data}
+    return (dict_data[k] for k in keys)
+
+
+_WIN32_CLIENT_RELEASES = [
+    ((10, 1, 0), "post11"),
+    ((10, 0, 22000), "11"),
+    ((6, 4, 0), "10"),
+    ((6, 3, 0), "8.1"),
+    ((6, 2, 0), "8"),
+    ((6, 1, 0), "7"),
+    ((6, 0, 0), "Vista"),
+    ((5, 2, 3790), "XP64"),
+    ((5, 2, 0), "XPMedia"),
+    ((5, 1, 0), "XP"),
+    ((5, 0, 0), "2000"),
+]
+
+_WIN32_SERVER_RELEASES = [
+    ((10, 1, 0), "post2025Server"),
+    ((10, 0, 26100), "2025Server"),
+    ((10, 0, 20348), "2022Server"),
+    ((10, 0, 17763), "2019Server"),
+    ((6, 4, 0), "2016Server"),
+    ((6, 3, 0), "2012ServerR2"),
+    ((6, 2, 0), "2012Server"),
+    ((6, 1, 0), "2008ServerR2"),
+    ((6, 0, 0), "2008Server"),
+    ((5, 2, 0), "2003Server"),
+    ((5, 0, 0), "2000Server"),
+]
 
 def win32_is_iot():
     return win32_edition() in ('IoTUAP', 'NanoServer', 'WindowsCoreHeadless', 'IoTEdgeOS')
 
 def win32_edition():
     try:
-        try:
-            import winreg
-        except ImportError:
-            import _winreg as winreg
+        import winreg
     except ImportError:
         pass
     else:
@@ -360,22 +385,40 @@ def win32_edition():
 
     return None
 
-def win32_ver(release='', version='', csd='', ptype=''):
+def _win32_ver(version, csd, ptype):
+    # Try using WMI first, as this is the canonical source of data
+    try:
+        (version, product_type, ptype, spmajor, spminor)  = _wmi_query(
+            'OS',
+            'Version',
+            'ProductType',
+            'BuildType',
+            'ServicePackMajorVersion',
+            'ServicePackMinorVersion',
+        )
+        is_client = (int(product_type) == 1)
+        if spminor and spminor != '0':
+            csd = f'SP{spmajor}.{spminor}'
+        else:
+            csd = f'SP{spmajor}'
+        return version, csd, ptype, is_client
+    except OSError:
+        pass
+
+    # Fall back to a combination of sys.getwindowsversion and "ver"
     try:
         from sys import getwindowsversion
     except ImportError:
-        return release, version, csd, ptype
+        return version, csd, ptype, True
 
     winver = getwindowsversion()
+    is_client = (getattr(winver, 'product_type', 1) == 1)
     try:
-        major, minor, build = map(int, _syscmd_ver()[2].split('.'))
+        version = _syscmd_ver()[2]
+        major, minor, build = map(int, version.split('.'))
     except ValueError:
         major, minor, build = winver.platform_version or winver[:3]
-    version = '{0}.{1}.{2}'.format(major, minor, build)
-
-    release = (_WIN32_CLIENT_RELEASES.get((major, minor)) or
-               _WIN32_CLIENT_RELEASES.get((major, None)) or
-               release)
+        version = '{0}.{1}.{2}'.format(major, minor, build)
 
     # getwindowsversion() reflect the compatibility mode Python is
     # running under, and so the service pack value is only going to be
@@ -387,17 +430,8 @@ def win32_ver(release='', version='', csd='', ptype=''):
             if csd[:13] == 'Service Pack ':
                 csd = 'SP' + csd[13:]
 
-    # VER_NT_SERVER = 3
-    if getattr(winver, 'product_type', None) == 3:
-        release = (_WIN32_SERVER_RELEASES.get((major, minor)) or
-                   _WIN32_SERVER_RELEASES.get((major, None)) or
-                   release)
-
     try:
-        try:
-            import winreg
-        except ImportError:
-            import _winreg as winreg
+        import winreg
     except ImportError:
         pass
     else:
@@ -408,6 +442,18 @@ def win32_ver(release='', version='', csd='', ptype=''):
         except OSError:
             pass
 
+    return version, csd, ptype, is_client
+
+def win32_ver(release='', version='', csd='', ptype=''):
+    is_client = False
+
+    version, csd, ptype, is_client = _win32_ver(version, csd, ptype)
+
+    if version:
+        intversion = tuple(map(int, version.split('.')))
+        releases = _WIN32_CLIENT_RELEASES if is_client else _WIN32_SERVER_RELEASES
+        release = next((r for v, r in releases if v <= intversion), release)
+
     return release, version, csd, ptype
 
 
@@ -452,8 +498,32 @@ def mac_ver(release='', versioninfo=('', '', ''), machine=''):
     # If that also doesn't work return the default values
     return release, versioninfo, machine
 
-def _java_getprop(name, default):
 
+# A namedtuple for iOS version information.
+IOSVersionInfo = collections.namedtuple(
+    "IOSVersionInfo",
+    ["system", "release", "model", "is_simulator"]
+)
+
+
+def ios_ver(system="", release="", model="", is_simulator=False):
+    """Get iOS version information, and return it as a namedtuple:
+        (system, release, model, is_simulator).
+
+    If values can't be determined, they are set to values provided as
+    parameters.
+    """
+    if sys.platform == "ios":
+        import _ios_support
+        result = _ios_support.get_platform_ios()
+        if result is not None:
+            return IOSVersionInfo(*result)
+
+    return IOSVersionInfo(system, release, model, is_simulator)
+
+
+def _java_getprop(name, default):
+    """This private helper is deprecated in 3.13 and will be removed in 3.15"""
     from java.lang import System
     try:
         value = System.getProperty(name)
@@ -475,6 +545,8 @@ def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')):
         given as parameters (which all default to '').
 
     """
+    import warnings
+    warnings._deprecated('java_ver', remove=(3, 15))
     # Import the needed APIs
     try:
         import java.lang
@@ -496,6 +568,47 @@ def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')):
 
     return release, vendor, vminfo, osinfo
 
+
+AndroidVer = collections.namedtuple(
+    "AndroidVer", "release api_level manufacturer model device is_emulator")
+
+def android_ver(release="", api_level=0, manufacturer="", model="", device="",
+                is_emulator=False):
+    if sys.platform == "android":
+        try:
+            from ctypes import CDLL, c_char_p, create_string_buffer
+        except ImportError:
+            pass
+        else:
+            # An NDK developer confirmed that this is an officially-supported
+            # API (https://stackoverflow.com/a/28416743). Use `getattr` to avoid
+            # private name mangling.
+            system_property_get = getattr(CDLL("libc.so"), "__system_property_get")
+            system_property_get.argtypes = (c_char_p, c_char_p)
+
+            def getprop(name, default):
+                # https://android.googlesource.com/platform/bionic/+/refs/tags/android-5.0.0_r1/libc/include/sys/system_properties.h#39
+                PROP_VALUE_MAX = 92
+                buffer = create_string_buffer(PROP_VALUE_MAX)
+                length = system_property_get(name.encode("UTF-8"), buffer)
+                if length == 0:
+                    # This API doesn’t distinguish between an empty property and
+                    # a missing one.
+                    return default
+                else:
+                    return buffer.value.decode("UTF-8", "backslashreplace")
+
+            release = getprop("ro.build.version.release", release)
+            api_level = int(getprop("ro.build.version.sdk", api_level))
+            manufacturer = getprop("ro.product.manufacturer", manufacturer)
+            model = getprop("ro.product.model", model)
+            device = getprop("ro.product.device", device)
+            is_emulator = getprop("ro.kernel.qemu", "0") == "1"
+
+    return AndroidVer(
+        release, api_level, manufacturer, model, device, is_emulator)
+
+
 ### System name aliasing
 
 def system_alias(system, release, version):
@@ -562,12 +675,12 @@ def _platform(*args):
     platform = platform.replace('unknown', '')
 
     # Fold '--'s and remove trailing '-'
-    while 1:
+    while True:
         cleaned = platform.replace('--', '-')
         if cleaned == platform:
             break
         platform = cleaned
-    while platform[-1] == '-':
+    while platform and platform[-1] == '-':
         platform = platform[:-1]
 
     return platform
@@ -608,7 +721,7 @@ def _syscmd_file(target, default=''):
         default in case the command should fail.
 
     """
-    if sys.platform in ('dos', 'win32', 'win16'):
+    if sys.platform in {'dos', 'win32', 'win16', 'ios', 'tvos', 'watchos'}:
         # XXX Others too ?
         return default
 
@@ -702,6 +815,8 @@ def architecture(executable=sys.executable, bits='', linkage=''):
     # Linkage
     if 'ELF' in fileout:
         linkage = 'ELF'
+    elif 'Mach-O' in fileout:
+        linkage = "Mach-O"
     elif 'PE' in fileout:
         # E.g. Windows uses this format
         if 'Windows' in fileout:
@@ -726,6 +841,21 @@ def _get_machine_win32():
     # http://www.geocities.com/rick_lively/MANUALS/ENV/MSWIN/PROCESSI.HTM
 
     # WOW64 processes mask the native architecture
+    try:
+        [arch, *_] = _wmi_query('CPU', 'Architecture')
+    except OSError:
+        pass
+    else:
+        try:
+            arch = ['x86', 'MIPS', 'Alpha', 'PowerPC', None,
+                    'ARM', 'ia64', None, None,
+                    'AMD64', None, None, 'ARM64',
+            ][int(arch)]
+        except (ValueError, IndexError):
+            pass
+        else:
+            if arch:
+                return arch
     return (
         os.environ.get('PROCESSOR_ARCHITEW6432', '') or
         os.environ.get('PROCESSOR_ARCHITECTURE', '')
@@ -739,7 +869,12 @@ def get(cls):
         return func() or ''
 
     def get_win32():
-        return os.environ.get('PROCESSOR_IDENTIFIER', _get_machine_win32())
+        try:
+            manufacturer, caption = _wmi_query('CPU', 'Manufacturer', 'Caption')
+        except OSError:
+            return os.environ.get('PROCESSOR_IDENTIFIER', _get_machine_win32())
+        else:
+            return f'{caption}, {manufacturer}'
 
     def get_OpenVMS():
         try:
@@ -750,6 +885,14 @@ def get_OpenVMS():
             csid, cpu_number = vms_lib.getsyi('SYI$_CPU', 0)
             return 'Alpha' if cpu_number >= 128 else 'VAX'
 
+    # On the iOS simulator, os.uname returns the architecture as uname.machine.
+    # On device it returns the model name for some reason; but there's only one
+    # CPU architecture for iOS devices, so we know the right answer.
+    def get_ios():
+        if sys.implementation._multiarch.endswith("simulator"):
+            return os.uname().machine
+        return 'arm64'
+
     def from_subprocess():
         """
         Fall back to `uname -p`
@@ -904,6 +1047,15 @@ def uname():
         system = 'Windows'
         release = 'Vista'
 
+    # On Android, return the name and version of the OS rather than the kernel.
+    if sys.platform == 'android':
+        system = 'Android'
+        release = android_ver().release
+
+    # Normalize responses on iOS
+    if sys.platform == 'ios':
+        system, release, _, _ = ios_ver()
+
     vals = system, node, release, version, machine
     # Replace 'unknown' values with the more portable ''
     _uname_cache = uname_result(*map(_unknown_as_blank, vals))
@@ -971,32 +1123,6 @@ def processor():
 
 ### Various APIs for extracting information from sys.version
 
-_sys_version_parser = re.compile(
-    r'([\w.+]+)\s*'  # "version<space>"
-    r'\(#?([^,]+)'  # "(#buildno"
-    r'(?:,\s*([\w ]*)'  # ", builddate"
-    r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
-    r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
-
-_ironpython_sys_version_parser = re.compile(
-    r'IronPython\s*'
-    r'([\d\.]+)'
-    r'(?: \(([\d\.]+)\))?'
-    r' on (.NET [\d\.]+)', re.ASCII)
-
-# IronPython covering 2.6 and 2.7
-_ironpython26_sys_version_parser = re.compile(
-    r'([\d.]+)\s*'
-    r'\(IronPython\s*'
-    r'[\d.]+\s*'
-    r'\(([\d.]+)\) on ([\w.]+ [\d.]+(?: \(\d+-bit\))?)\)'
-)
-
-_pypy_sys_version_parser = re.compile(
-    r'([\w.+]+)\s*'
-    r'\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
-    r'\[PyPy [^\]]+\]?')
-
 _sys_version_cache = {}
 
 def _sys_version(sys_version=None):
@@ -1028,28 +1154,16 @@ def _sys_version(sys_version=None):
     if result is not None:
         return result
 
-    # Parse it
-    if 'IronPython' in sys_version:
-        # IronPython
-        name = 'IronPython'
-        if sys_version.startswith('IronPython'):
-            match = _ironpython_sys_version_parser.match(sys_version)
-        else:
-            match = _ironpython26_sys_version_parser.match(sys_version)
-
-        if match is None:
-            raise ValueError(
-                'failed to parse IronPython sys.version: %s' %
-                repr(sys_version))
-
-        version, alt_version, compiler = match.groups()
-        buildno = ''
-        builddate = ''
-
-    elif sys.platform.startswith('java'):
+    if sys.platform.startswith('java'):
         # Jython
+        jython_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'  # "version<space>"
+            r'\(#?([^,]+)'  # "(#buildno"
+            r'(?:,\s*([\w ]*)'  # ", builddate"
+            r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
+            r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
         name = 'Jython'
-        match = _sys_version_parser.match(sys_version)
+        match = jython_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError(
                 'failed to parse Jython sys.version: %s' %
@@ -1061,8 +1175,13 @@ def _sys_version(sys_version=None):
 
     elif "PyPy" in sys_version:
         # PyPy
+        pypy_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'
+            r'\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
+            r'\[PyPy [^\]]+\]?')
+
         name = "PyPy"
-        match = _pypy_sys_version_parser.match(sys_version)
+        match = pypy_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError("failed to parse PyPy sys.version: %s" %
                              repr(sys_version))
@@ -1071,7 +1190,14 @@ def _sys_version(sys_version=None):
 
     else:
         # CPython
-        match = _sys_version_parser.match(sys_version)
+        cpython_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'  # "version<space>"
+            r'(?:experimental free-threading build\s+)?' # "free-threading-build<space>"
+            r'\(#?([^,]+)'  # "(#buildno"
+            r'(?:,\s*([\w ]*)'  # ", builddate"
+            r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
+            r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
+        match = cpython_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError(
                 'failed to parse CPython sys.version: %s' %
@@ -1084,7 +1210,6 @@ def _sys_version(sys_version=None):
             name = "RustPython"
         else:
             name = 'CPython'
-
         if builddate is None:
             builddate = ''
         elif buildtime:
@@ -1115,7 +1240,6 @@ def python_implementation():
 
         Currently, the following implementations are identified:
           'CPython' (C implementation of Python),
-          'IronPython' (.NET implementation of Python),
           'Jython' (Java implementation of Python),
           'PyPy' (Python implementation of Python).
 
@@ -1190,7 +1314,7 @@ def python_compiler():
 
 _platform_cache = {}
 
-def platform(aliased=0, terse=0):
+def platform(aliased=False, terse=False):
 
     """ Returns a single string identifying the underlying platform
         with as much useful information as possible (but no more :).
@@ -1222,11 +1346,14 @@ def platform(aliased=0, terse=0):
         system, release, version = system_alias(system, release, version)
 
     if system == 'Darwin':
-        # macOS (darwin kernel)
-        macos_release = mac_ver()[0]
-        if macos_release:
-            system = 'macOS'
-            release = macos_release
+        # macOS and iOS both report as a "Darwin" kernel
+        if sys.platform == "ios":
+            system, release, _, _ = ios_ver()
+        else:
+            macos_release = mac_ver()[0]
+            if macos_release:
+                system = 'macOS'
+                release = macos_release
 
     if system == 'Windows':
         # MS platforms
@@ -1236,7 +1363,7 @@ def platform(aliased=0, terse=0):
         else:
             platform = _platform(system, release, version, csd)
 
-    elif system in ('Linux',):
+    elif system == 'Linux':
         # check for libc vs. glibc
         libcname, libcversion = libc_ver()
         platform = _platform(system, release, machine, processor,
@@ -1267,13 +1394,6 @@ def platform(aliased=0, terse=0):
 ### freedesktop.org os-release standard
 # https://www.freedesktop.org/software/systemd/man/os-release.html
 
-# NAME=value with optional quotes (' or "). The regular expression is less
-# strict than shell lexer, but that's ok.
-_os_release_line = re.compile(
-    "^(?P<name>[a-zA-Z0-9_]+)=(?P<quote>[\"\']?)(?P<value>.*)(?P=quote)$"
-)
-# unescape five special characters mentioned in the standard
-_os_release_unescape = re.compile(r"\\([\\\$\"\'`])")
 # /etc takes precedence over /usr/lib
 _os_release_candidates = ("/etc/os-release", "/usr/lib/os-release")
 _os_release_cache = None
@@ -1288,10 +1408,18 @@ def _parse_os_release(lines):
         "PRETTY_NAME": "Linux",
     }
 
+    # NAME=value with optional quotes (' or "). The regular expression is less
+    # strict than shell lexer, but that's ok.
+    os_release_line = re.compile(
+        "^(?P<name>[a-zA-Z0-9_]+)=(?P<quote>[\"\']?)(?P<value>.*)(?P=quote)$"
+    )
+    # unescape five special characters mentioned in the standard
+    os_release_unescape = re.compile(r"\\([\\\$\"\'`])")
+
     for line in lines:
-        mo = _os_release_line.match(line)
+        mo = os_release_line.match(line)
         if mo is not None:
-            info[mo.group('name')] = _os_release_unescape.sub(
+            info[mo.group('name')] = os_release_unescape.sub(
                 r"\1", mo.group('value')
             )
 
diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 2eeebe4c9a4..655c51eea3d 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -21,6 +21,9 @@
 
 Generate Plist example:
 
+    import datetime
+    import plistlib
+
     pl = dict(
         aString = "Doodah",
         aList = ["A", "B", 12, 32.1, [1, 2, 3]],
@@ -28,22 +31,28 @@
         anInt = 728,
         aDict = dict(
             anotherString = "<hello & hi there!>",
-            aUnicodeValue = "M\xe4ssig, Ma\xdf",
+            aThirdString = "M\xe4ssig, Ma\xdf",
             aTrueValue = True,
             aFalseValue = False,
         ),
         someData = b"<binary gunk>",
         someMoreData = b"<lots of binary gunk>" * 10,
-        aDate = datetime.datetime.fromtimestamp(time.mktime(time.gmtime())),
+        aDate = datetime.datetime.now()
     )
-    with open(fileName, 'wb') as fp:
-        dump(pl, fp)
+    print(plistlib.dumps(pl).decode())
 
 Parse Plist example:
 
-    with open(fileName, 'rb') as fp:
-        pl = load(fp)
-    print(pl["aKey"])
+    import plistlib
+
+    plist = b'''<plist version="1.0">
+    <dict>
+        <key>foo</key>
+        <string>bar</string>
+    </dict>
+    </plist>'''
+    pl = plistlib.loads(plist)
+    print(pl["foo"])
 """
 __all__ = [
     "InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"
@@ -64,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -131,7 +143,7 @@ def _decode_base64(s):
 _dateParser = re.compile(r"(?P<year>\d\d\d\d)(?:-(?P<month>\d\d)(?:-(?P<day>\d\d)(?:T(?P<hour>\d\d)(?::(?P<minute>\d\d)(?::(?P<second>\d\d))?)?)?)?)?Z", re.ASCII)
 
 
-def _date_from_string(s):
+def _date_from_string(s, aware_datetime):
     order = ('year', 'month', 'day', 'hour', 'minute', 'second')
     gd = _dateParser.match(s).groupdict()
     lst = []
@@ -140,10 +152,14 @@ def _date_from_string(s):
         if val is None:
             break
         lst.append(int(val))
+    if aware_datetime:
+        return datetime.datetime(*lst, tzinfo=datetime.UTC)
     return datetime.datetime(*lst)
 
 
-def _date_to_string(d):
+def _date_to_string(d, aware_datetime):
+    if aware_datetime:
+        d = d.astimezone(datetime.UTC)
     return '%04d-%02d-%02dT%02d:%02d:%02dZ' % (
         d.year, d.month, d.day,
         d.hour, d.minute, d.second
@@ -152,7 +168,7 @@ def _date_to_string(d):
 def _escape(text):
     m = _controlCharPat.search(text)
     if m is not None:
-        raise ValueError("strings can't contains control characters; "
+        raise ValueError("strings can't contain control characters; "
                          "use bytes instead")
     text = text.replace("\r\n", "\n")       # convert DOS line endings
     text = text.replace("\r", "\n")         # convert Mac line endings
@@ -162,11 +178,12 @@ def _escape(text):
     return text
 
 class _PlistParser:
-    def __init__(self, dict_type):
+    def __init__(self, dict_type, aware_datetime=False):
         self.stack = []
         self.current_key = None
         self.root = None
         self._dict_type = dict_type
+        self._aware_datetime = aware_datetime
 
     def parse(self, fileobj):
         self.parser = ParserCreate()
@@ -178,8 +195,8 @@ def parse(self, fileobj):
         return self.root
 
     def handle_entity_decl(self, entity_name, is_parameter_entity, value, base, system_id, public_id, notation_name):
-        # Reject plist files with entity declarations to avoid XML vulnerabilies in expat.
-        # Regular plist files don't contain those declerations, and Apple's plutil tool does not
+        # Reject plist files with entity declarations to avoid XML vulnerabilities in expat.
+        # Regular plist files don't contain those declarations, and Apple's plutil tool does not
         # accept them either.
         raise InvalidFileException("XML entity declarations are not supported in plist files")
 
@@ -199,7 +216,7 @@ def handle_data(self, data):
 
     def add_object(self, value):
         if self.current_key is not None:
-            if not isinstance(self.stack[-1], type({})):
+            if not isinstance(self.stack[-1], dict):
                 raise ValueError("unexpected element at line %d" %
                                  self.parser.CurrentLineNumber)
             self.stack[-1][self.current_key] = value
@@ -208,7 +225,7 @@ def add_object(self, value):
             # this is the root object
             self.root = value
         else:
-            if not isinstance(self.stack[-1], type([])):
+            if not isinstance(self.stack[-1], list):
                 raise ValueError("unexpected element at line %d" %
                                  self.parser.CurrentLineNumber)
             self.stack[-1].append(value)
@@ -232,7 +249,7 @@ def end_dict(self):
         self.stack.pop()
 
     def end_key(self):
-        if self.current_key or not isinstance(self.stack[-1], type({})):
+        if self.current_key or not isinstance(self.stack[-1], dict):
             raise ValueError("unexpected key at line %d" %
                              self.parser.CurrentLineNumber)
         self.current_key = self.get_data()
@@ -268,7 +285,8 @@ def end_data(self):
         self.add_object(_decode_base64(self.get_data()))
 
     def end_date(self):
-        self.add_object(_date_from_string(self.get_data()))
+        self.add_object(_date_from_string(self.get_data(),
+                                          aware_datetime=self._aware_datetime))
 
 
 class _DumbXMLWriter:
@@ -312,13 +330,14 @@ def writeln(self, line):
 class _PlistWriter(_DumbXMLWriter):
     def __init__(
             self, file, indent_level=0, indent=b"\t", writeHeader=1,
-            sort_keys=True, skipkeys=False):
+            sort_keys=True, skipkeys=False, aware_datetime=False):
 
         if writeHeader:
             file.write(PLISTHEADER)
         _DumbXMLWriter.__init__(self, file, indent_level, indent)
         self._sort_keys = sort_keys
         self._skipkeys = skipkeys
+        self._aware_datetime = aware_datetime
 
     def write(self, value):
         self.writeln("<plist version=\"1.0\">")
@@ -351,7 +370,8 @@ def write_value(self, value):
             self.write_bytes(value)
 
         elif isinstance(value, datetime.datetime):
-            self.simple_element("date", _date_to_string(value))
+            self.simple_element("date",
+                                _date_to_string(value, self._aware_datetime))
 
         elif isinstance(value, (tuple, list)):
             self.write_array(value)
@@ -452,8 +472,9 @@ class _BinaryPlistParser:
 
     see also: http://opensource.apple.com/source/CF/CF-744.18/CFBinaryPList.c
     """
-    def __init__(self, dict_type):
+    def __init__(self, dict_type, aware_datetime=False):
         self._dict_type = dict_type
+        self._aware_datime = aware_datetime
 
     def parse(self, fp):
         try:
@@ -490,12 +511,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -547,27 +580,24 @@ def _read_object(self, ref):
             f = struct.unpack('>d', self._fp.read(8))[0]
             # timestamp 0 of binary plists corresponds to 1/1/2001
             # (year of Mac OS X 10.0), instead of 1/1/1970.
-            result = (datetime.datetime(2001, 1, 1) +
-                      datetime.timedelta(seconds=f))
+            if self._aware_datime:
+                epoch = datetime.datetime(2001, 1, 1, tzinfo=datetime.UTC)
+            else:
+                epoch = datetime.datetime(2001, 1, 1)
+            result = epoch + datetime.timedelta(seconds=f)
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
@@ -579,7 +609,8 @@ def _read_object(self, ref):
             obj_refs = self._read_refs(s)
             result = []
             self._objects[ref] = result
-            result.extend(self._read_object(x) for x in obj_refs)
+            for x in obj_refs:
+                result.append(self._read_object(x))
 
         # tokenH == 0xB0 is documented as 'ordset', but is not actually
         # implemented in the Apple reference code.
@@ -620,10 +651,11 @@ def _count_to_size(count):
 _scalars = (str, int, float, datetime.datetime, bytes)
 
 class _BinaryPlistWriter (object):
-    def __init__(self, fp, sort_keys, skipkeys):
+    def __init__(self, fp, sort_keys, skipkeys, aware_datetime=False):
         self._fp = fp
         self._sort_keys = sort_keys
         self._skipkeys = skipkeys
+        self._aware_datetime = aware_datetime
 
     def write(self, value):
 
@@ -769,7 +801,12 @@ def _write_object(self, value):
             self._fp.write(struct.pack('>Bd', 0x23, value))
 
         elif isinstance(value, datetime.datetime):
-            f = (value - datetime.datetime(2001, 1, 1)).total_seconds()
+            if self._aware_datetime:
+                dt = value.astimezone(datetime.UTC)
+                offset = dt - datetime.datetime(2001, 1, 1, tzinfo=datetime.UTC)
+                f = offset.total_seconds()
+            else:
+                f = (value - datetime.datetime(2001, 1, 1)).total_seconds()
             self._fp.write(struct.pack('>Bd', 0x33, f))
 
         elif isinstance(value, (bytes, bytearray)):
@@ -853,7 +890,7 @@ def _is_fmt_binary(header):
 }
 
 
-def load(fp, *, fmt=None, dict_type=dict):
+def load(fp, *, fmt=None, dict_type=dict, aware_datetime=False):
     """Read a .plist file. 'fp' should be a readable and binary file object.
     Return the unpacked root object (which usually is a dictionary).
     """
@@ -871,32 +908,41 @@ def load(fp, *, fmt=None, dict_type=dict):
     else:
         P = _FORMATS[fmt]['parser']
 
-    p = P(dict_type=dict_type)
+    p = P(dict_type=dict_type, aware_datetime=aware_datetime)
     return p.parse(fp)
 
 
-def loads(value, *, fmt=None, dict_type=dict):
+def loads(value, *, fmt=None, dict_type=dict, aware_datetime=False):
     """Read a .plist file from a bytes object.
     Return the unpacked root object (which usually is a dictionary).
     """
+    if isinstance(value, str):
+        if fmt == FMT_BINARY:
+            raise TypeError("value must be bytes-like object when fmt is "
+                            "FMT_BINARY")
+        value = value.encode()
     fp = BytesIO(value)
-    return load(fp, fmt=fmt, dict_type=dict_type)
+    return load(fp, fmt=fmt, dict_type=dict_type, aware_datetime=aware_datetime)
 
 
-def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False):
+def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False,
+         aware_datetime=False):
     """Write 'value' to a .plist file. 'fp' should be a writable,
     binary file object.
     """
     if fmt not in _FORMATS:
         raise ValueError("Unsupported format: %r"%(fmt,))
 
-    writer = _FORMATS[fmt]["writer"](fp, sort_keys=sort_keys, skipkeys=skipkeys)
+    writer = _FORMATS[fmt]["writer"](fp, sort_keys=sort_keys, skipkeys=skipkeys,
+                                     aware_datetime=aware_datetime)
     writer.write(value)
 
 
-def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True):
+def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True,
+          aware_datetime=False):
     """Return a bytes object with the contents for a .plist file.
     """
     fp = BytesIO()
-    dump(value, fp, fmt=fmt, skipkeys=skipkeys, sort_keys=sort_keys)
+    dump(value, fp, fmt=fmt, skipkeys=skipkeys, sort_keys=sort_keys,
+         aware_datetime=aware_datetime)
     return fp.getvalue()
diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py
index c9f27575b51..ed277276b51 100644
--- a/Lib/test/test_platform.py
+++ b/Lib/test/test_platform.py
@@ -10,6 +10,14 @@
 from test import support
 from test.support import os_helper
 
+try:
+    # Some of the iOS tests need ctypes to operate.
+    # Confirm that the ctypes module is available
+    # is available.
+    import _ctypes
+except ImportError:
+    _ctypes = None
+
 FEDORA_OS_RELEASE = """\
 NAME=Fedora
 VERSION="32 (Thirty Two)"
@@ -123,10 +131,6 @@ def test_sys_version(self):
         for input, output in (
             ('2.4.3 (#1, Jun 21 2006, 13:54:21) \n[GCC 3.3.4 (pre 3.3.5 20040809)]',
              ('CPython', '2.4.3', '', '', '1', 'Jun 21 2006 13:54:21', 'GCC 3.3.4 (pre 3.3.5 20040809)')),
-            ('IronPython 1.0.60816 on .NET 2.0.50727.42',
-             ('IronPython', '1.0.60816', '', '', '', '', '.NET 2.0.50727.42')),
-            ('IronPython 1.0 (1.0.61005.1977) on .NET 2.0.50727.42',
-             ('IronPython', '1.0.0', '', '', '', '', '.NET 2.0.50727.42')),
             ('2.4.3 (truncation, date, t) \n[GCC]',
              ('CPython', '2.4.3', '', '', 'truncation', 'date t', 'GCC')),
             ('2.4.3 (truncation, date, ) \n[GCC]',
@@ -161,20 +165,11 @@ def test_sys_version(self):
                  ('r261:67515', 'Dec  6 2008 15:26:00'),
                  'GCC 4.0.1 (Apple Computer, Inc. build 5370)'),
 
-            ("IronPython 2.0 (2.0.0.0) on .NET 2.0.50727.3053", None, "cli")
-            :
-                ("IronPython", "2.0.0", "", "", ("", ""),
-                 ".NET 2.0.50727.3053"),
-
-            ("2.6.1 (IronPython 2.6.1 (2.6.10920.0) on .NET 2.0.50727.1433)", None, "cli")
+            ("3.10.8 (tags/v3.10.8:aaaf517424, Feb 14 2023, 16:28:12) [GCC 9.4.0]",
+             None, "linux")
             :
-                ("IronPython", "2.6.1", "", "", ("", ""),
-                 ".NET 2.0.50727.1433"),
-
-            ("2.7.4 (IronPython 2.7.4 (2.7.0.40) on Mono 4.0.30319.1 (32-bit))", None, "cli")
-            :
-                ("IronPython", "2.7.4", "", "", ("", ""),
-                 "Mono 4.0.30319.1 (32-bit)"),
+                ('CPython', '3.10.8', '', '',
+                ('tags/v3.10.8:aaaf517424', 'Feb 14 2023 16:28:12'), 'GCC 9.4.0'),
 
             ("2.5 (trunk:6107, Mar 26 2009, 13:02:18) \n[Java HotSpot(TM) Client VM (\"Apple Computer, Inc.\")]",
             ('Jython', 'trunk', '6107'), "java1.5.0_16")
@@ -205,6 +200,9 @@ def test_sys_version(self):
             self.assertEqual(platform.python_build(), info[4])
             self.assertEqual(platform.python_compiler(), info[5])
 
+        with self.assertRaises(ValueError):
+            platform._sys_version('2. 4.3 (truncation) \n[GCC]')
+
     def test_system_alias(self):
         res = platform.system_alias(
             platform.system(),
@@ -229,6 +227,38 @@ def test_uname(self):
         self.assertEqual(res[-1], res.processor)
         self.assertEqual(len(res), 6)
 
+        if os.name == "posix":
+            uname = os.uname()
+            self.assertEqual(res.node, uname.nodename)
+            self.assertEqual(res.version, uname.version)
+            self.assertEqual(res.machine, uname.machine)
+
+            if sys.platform == "android":
+                self.assertEqual(res.system, "Android")
+                self.assertEqual(res.release, platform.android_ver().release)
+            elif sys.platform == "ios":
+                # Platform module needs ctypes for full operation. If ctypes
+                # isn't available, there's no ObjC module, and dummy values are
+                # returned.
+                if _ctypes:
+                    self.assertIn(res.system, {"iOS", "iPadOS"})
+                    self.assertEqual(res.release, platform.ios_ver().release)
+                else:
+                    self.assertEqual(res.system, "")
+                    self.assertEqual(res.release, "")
+            else:
+                self.assertEqual(res.system, uname.sysname)
+                self.assertEqual(res.release, uname.release)
+
+
+    @unittest.skipUnless(sys.platform.startswith('win'), "windows only test")
+    def test_uname_win32_without_wmi(self):
+        def raises_oserror(*a):
+            raise OSError()
+
+        with support.swap_attr(platform, '_wmi_query', raises_oserror):
+            self.test_uname()
+
     def test_uname_cast_to_tuple(self):
         res = platform.uname()
         expected = (
@@ -297,28 +327,66 @@ def test_uname_win32_ARCHITEW6432(self):
         # on 64 bit Windows: if PROCESSOR_ARCHITEW6432 exists we should be
         # using it, per
         # http://blogs.msdn.com/david.wang/archive/2006/03/26/HOWTO-Detect-Process-Bitness.aspx
-        try:
+
+        # We also need to suppress WMI checks, as those are reliable and
+        # overrule the environment variables
+        def raises_oserror(*a):
+            raise OSError()
+
+        with support.swap_attr(platform, '_wmi_query', raises_oserror):
             with os_helper.EnvironmentVarGuard() as environ:
-                if 'PROCESSOR_ARCHITEW6432' in environ:
+                try:
                     del environ['PROCESSOR_ARCHITEW6432']
-                environ['PROCESSOR_ARCHITECTURE'] = 'foo'
-                platform._uname_cache = None
-                system, node, release, version, machine, processor = platform.uname()
-                self.assertEqual(machine, 'foo')
-                environ['PROCESSOR_ARCHITEW6432'] = 'bar'
-                platform._uname_cache = None
-                system, node, release, version, machine, processor = platform.uname()
-                self.assertEqual(machine, 'bar')
-        finally:
-            platform._uname_cache = None
+                    environ['PROCESSOR_ARCHITECTURE'] = 'foo'
+                    platform._uname_cache = None
+                    system, node, release, version, machine, processor = platform.uname()
+                    self.assertEqual(machine, 'foo')
+                    environ['PROCESSOR_ARCHITEW6432'] = 'bar'
+                    platform._uname_cache = None
+                    system, node, release, version, machine, processor = platform.uname()
+                    self.assertEqual(machine, 'bar')
+                finally:
+                    platform._uname_cache = None
 
     def test_java_ver(self):
-        res = platform.java_ver()
-        if sys.platform == 'java':
-            self.assertTrue(all(res))
+        import re
+        msg = re.escape(
+            "'java_ver' is deprecated and slated for removal in Python 3.15"
+        )
+        with self.assertWarnsRegex(DeprecationWarning, msg):
+            res = platform.java_ver()
+        self.assertEqual(len(res), 4)
 
+    @unittest.skipUnless(support.MS_WINDOWS, 'This test only makes sense on Windows')
     def test_win32_ver(self):
-        res = platform.win32_ver()
+        release1, version1, csd1, ptype1 = 'a', 'b', 'c', 'd'
+        res = platform.win32_ver(release1, version1, csd1, ptype1)
+        self.assertEqual(len(res), 4)
+        release, version, csd, ptype = res
+        if release:
+            # Currently, release names always come from internal dicts,
+            # but this could change over time. For now, we just check that
+            # release is something different from what we have passed.
+            self.assertNotEqual(release, release1)
+        if version:
+            # It is rather hard to test explicit version without
+            # going deep into the details.
+            self.assertIn('.', version)
+            for v in version.split('.'):
+                int(v)  # should not fail
+        if csd:
+            self.assertTrue(csd.startswith('SP'), msg=csd)
+        if ptype:
+            if os.cpu_count() > 1:
+                self.assertIn('Multiprocessor', ptype)
+            else:
+                self.assertIn('Uniprocessor', ptype)
+
+    @unittest.skipIf(support.MS_WINDOWS, 'This test only makes sense on non Windows')
+    def test_win32_ver_on_non_windows(self):
+        release, version, csd, ptype = 'a', '1.0', 'c', 'd'
+        res = platform.win32_ver(release, version, csd, ptype)
+        self.assertSequenceEqual(res, (release, version, csd, ptype), seq_type=tuple)
 
     def test_mac_ver(self):
         res = platform.mac_ver()
@@ -372,6 +440,56 @@ def test_mac_ver_with_fork(self):
             # parent
             support.wait_process(pid, exitcode=0)
 
+    def test_ios_ver(self):
+        result = platform.ios_ver()
+
+        # ios_ver is only fully available on iOS where ctypes is available.
+        if sys.platform == "ios" and _ctypes:
+            system, release, model, is_simulator = result
+            # Result is a namedtuple
+            self.assertEqual(result.system, system)
+            self.assertEqual(result.release, release)
+            self.assertEqual(result.model, model)
+            self.assertEqual(result.is_simulator, is_simulator)
+
+            # We can't assert specific values without reproducing the logic of
+            # ios_ver(), so we check that the values are broadly what we expect.
+
+            # System is either iOS or iPadOS, depending on the test device
+            self.assertIn(system, {"iOS", "iPadOS"})
+
+            # Release is a numeric version specifier with at least 2 parts
+            parts = release.split(".")
+            self.assertGreaterEqual(len(parts), 2)
+            self.assertTrue(all(part.isdigit() for part in parts))
+
+            # If this is a simulator, we get a high level device descriptor
+            # with no identifying model number. If this is a physical device,
+            # we get a model descriptor like "iPhone13,1"
+            if is_simulator:
+                self.assertIn(model, {"iPhone", "iPad"})
+            else:
+                self.assertTrue(
+                    (model.startswith("iPhone") or model.startswith("iPad"))
+                    and "," in model
+                )
+
+            self.assertEqual(type(is_simulator), bool)
+        else:
+            # On non-iOS platforms, calling ios_ver doesn't fail; you get
+            # default values
+            self.assertEqual(result.system, "")
+            self.assertEqual(result.release, "")
+            self.assertEqual(result.model, "")
+            self.assertFalse(result.is_simulator)
+
+            # Check the fallback values can be overridden by arguments
+            override = platform.ios_ver("Foo", "Bar", "Whiz", True)
+            self.assertEqual(override.system, "Foo")
+            self.assertEqual(override.release, "Bar")
+            self.assertEqual(override.model, "Whiz")
+            self.assertTrue(override.is_simulator)
+
     @unittest.skipIf(support.is_emscripten, "Does not apply to Emscripten")
     def test_libc_ver(self):
         # check that libc_ver(executable) doesn't raise an exception
@@ -421,6 +539,43 @@ def test_libc_ver(self):
         self.assertEqual(platform.libc_ver(filename, chunksize=chunksize),
                          ('glibc', '1.23.4'))
 
+    def test_android_ver(self):
+        res = platform.android_ver()
+        self.assertIsInstance(res, tuple)
+        self.assertEqual(res, (res.release, res.api_level, res.manufacturer,
+                               res.model, res.device, res.is_emulator))
+
+        if sys.platform == "android":
+            for name in ["release", "manufacturer", "model", "device"]:
+                with self.subTest(name):
+                    value = getattr(res, name)
+                    self.assertIsInstance(value, str)
+                    self.assertNotEqual(value, "")
+
+            self.assertIsInstance(res.api_level, int)
+            self.assertGreaterEqual(res.api_level, sys.getandroidapilevel())
+
+            self.assertIsInstance(res.is_emulator, bool)
+
+        # When not running on Android, it should return the default values.
+        else:
+            self.assertEqual(res.release, "")
+            self.assertEqual(res.api_level, 0)
+            self.assertEqual(res.manufacturer, "")
+            self.assertEqual(res.model, "")
+            self.assertEqual(res.device, "")
+            self.assertEqual(res.is_emulator, False)
+
+            # Default values may also be overridden using parameters.
+            res = platform.android_ver(
+                "alpha", 1, "bravo", "charlie", "delta", True)
+            self.assertEqual(res.release, "alpha")
+            self.assertEqual(res.api_level, 1)
+            self.assertEqual(res.manufacturer, "bravo")
+            self.assertEqual(res.model, "charlie")
+            self.assertEqual(res.device, "delta")
+            self.assertEqual(res.is_emulator, True)
+
     @support.cpython_only
     def test__comparable_version(self):
         from platform import _comparable_version as V
@@ -467,7 +622,8 @@ def test_macos(self):
                   'root:xnu-4570.71.2~1/RELEASE_X86_64'),
                  'x86_64', 'i386')
         arch = ('64bit', '')
-        with mock.patch.object(platform, 'uname', return_value=uname), \
+        with mock.patch.object(sys, "platform", "darwin"), \
+             mock.patch.object(platform, 'uname', return_value=uname), \
              mock.patch.object(platform, 'architecture', return_value=arch):
             for mac_ver, expected_terse, expected in [
                 # darwin: mac_ver() returns empty strings
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index c6d4cfe5c6b..cad53c17837 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -6,10 +6,15 @@
 import unittest
 import plistlib
 import os
+import sys
+import json
 import datetime
 import codecs
+import subprocess
 import binascii
 import collections
+import time
+import zoneinfo
 from test import support
 from test.support import os_helper
 from io import BytesIO
@@ -505,6 +510,19 @@ def test_bytes(self):
         data2 = plistlib.dumps(pl2)
         self.assertEqual(data, data2)
 
+    def test_loads_str_with_xml_fmt(self):
+        pl = self._create()
+        b = plistlib.dumps(pl)
+        s = b.decode()
+        self.assertIsInstance(s, str)
+        pl2 = plistlib.loads(s)
+        self.assertEqual(pl, pl2)
+
+    def test_loads_str_with_binary_fmt(self):
+        msg = "value must be bytes-like object when fmt is FMT_BINARY"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.loads('test', fmt=plistlib.FMT_BINARY)
+
     def test_indentation_array(self):
         data = [[[[[[[[{'test': b'aaaaaa'}]]]]]]]]
         self.assertEqual(plistlib.loads(plistlib.dumps(data)), data)
@@ -734,8 +752,7 @@ def test_non_bmp_characters(self):
                 data = plistlib.dumps(pl, fmt=fmt)
                 self.assertEqual(plistlib.loads(data), pl)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         for fmt in ALL_FORMATS:
             with self.subTest(fmt=fmt):
@@ -754,8 +771,7 @@ def test_nondictroot(self):
                 self.assertEqual(test1, result1)
                 self.assertEqual(test2, result2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidarray(self):
         for i in ["<key>key inside an array</key>",
                   "<key>key inside an array2</key><real>3</real>",
@@ -763,8 +779,7 @@ def test_invalidarray(self):
             self.assertRaises(ValueError, plistlib.loads,
                               ("<plist><array>%s</array></plist>"%i).encode())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invaliddict(self):
         for i in ["<key><true/>k</key><string>compound key</string>",
                   "<key>single key</key>",
@@ -776,14 +791,12 @@ def test_invaliddict(self):
             self.assertRaises(ValueError, plistlib.loads,
                               ("<plist><array><dict>%s</dict></array></plist>"%i).encode())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidinteger(self):
         self.assertRaises(ValueError, plistlib.loads,
                           b"<plist><integer>not integer</integer></plist>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidreal(self):
         self.assertRaises(ValueError, plistlib.loads,
                           b"<plist><integer>not real</integer></plist>")
@@ -840,18 +853,64 @@ def test_modified_uid_huge(self):
         with self.assertRaises(OverflowError):
             plistlib.dumps(huge_uid, fmt=plistlib.FMT_BINARY)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xml_plist_with_entity_decl(self):
         with self.assertRaisesRegex(plistlib.InvalidFileException,
                                     "XML entity declarations are not supported"):
             plistlib.loads(XML_PLIST_WITH_ENTITY, fmt=plistlib.FMT_XML)
 
+    def test_load_aware_datetime(self):
+        dt = plistlib.loads(b"<plist><date>2023-12-10T08:03:30Z</date></plist>",
+                            aware_datetime=True)
+        self.assertEqual(dt.tzinfo, datetime.UTC)
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime(self):
+        dt = datetime.datetime(2345, 6, 7, 8, 9, 10,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            loaded_dt = plistlib.loads(s, fmt=fmt, aware_datetime=True)
+            self.assertEqual(loaded_dt.tzinfo, datetime.UTC)
+            self.assertEqual(loaded_dt, dt)
+
+    def test_dump_utc_aware_datetime(self):
+        dt = datetime.datetime(2345, 6, 7, 8, 9, 10, tzinfo=datetime.UTC)
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            loaded_dt = plistlib.loads(s, fmt=fmt, aware_datetime=True)
+            self.assertEqual(loaded_dt.tzinfo, datetime.UTC)
+            self.assertEqual(loaded_dt, dt)
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        s = plistlib.dumps(dt, fmt=plistlib.FMT_XML, aware_datetime=False)
+        self.assertIn(b"2345-06-07T08:00:00Z", s)
+
+    def test_dump_utc_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC)
+        s = plistlib.dumps(dt, fmt=plistlib.FMT_XML, aware_datetime=False)
+        self.assertIn(b"2345-06-07T08:00:00Z", s)
+
+    def test_dump_naive_datetime_with_aware_datetime_option(self):
+        # Save a naive datetime with aware_datetime set to true.  This will lead
+        # to having different time as compared to the current machine's
+        # timezone, which is UTC.
+        dt = datetime.datetime(2003, 6, 7, 8, tzinfo=None)
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            parsed = plistlib.loads(s, aware_datetime=False)
+            expected = dt.astimezone(datetime.UTC).replace(tzinfo=None)
+            self.assertEqual(parsed, expected)
+
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -863,7 +922,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -917,12 +980,12 @@ def test_cycles(self):
         self.assertIs(b['x'], b)
 
     def test_deep_nesting(self):
-        for N in [300, 100000]:
+        for N in [50, 300, 100_000]:
             chunks = [b'\xa1' + (i + 1).to_bytes(4, 'big') for i in range(N)]
             try:
                 result = self.decode(*chunks, b'\x54seed', offset_size=4, ref_size=4)
             except RecursionError:
-                pass
+                self.assertGreater(N, sys.getrecursionlimit())
             else:
                 for i in range(N):
                     self.assertIsInstance(result, list)
@@ -934,7 +997,7 @@ def test_large_timestamp(self):
         # Issue #26709: 32-bit timestamp out of range
         for ts in -2**31-1, 2**31:
             with self.subTest(ts=ts):
-                d = (datetime.datetime.utcfromtimestamp(0) +
+                d = (datetime.datetime(1970, 1, 1, 0, 0) +
                      datetime.timedelta(seconds=ts))
                 data = plistlib.dumps(d, fmt=plistlib.FMT_BINARY)
                 self.assertEqual(plistlib.loads(data), d)
@@ -971,6 +1034,60 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
+    def test_load_aware_datetime(self):
+        data = (b'bplist003B\x04>\xd0d\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00'
+                b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00'
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11')
+        self.assertEqual(plistlib.loads(data, aware_datetime=True),
+                         datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC))
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        msg = "can't subtract offset-naive and offset-aware datetimes"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.dumps(dt, fmt=plistlib.FMT_BINARY, aware_datetime=False)
+
+    # TODO: RUSTPYTHON
+    # The error message is different
+    # In CPython, there is a separate .c file for datetime, which raises a different error message
+    @unittest.expectedFailure
+    def test_dump_utc_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC)
+        msg = "can't subtract offset-naive and offset-aware datetimes"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.dumps(dt, fmt=plistlib.FMT_BINARY, aware_datetime=False)
+
 
 class TestKeyedArchive(unittest.TestCase):
     def test_keyed_archive_data(self):
@@ -1009,6 +1126,78 @@ def test__all__(self):
         not_exported = {"PlistFormat", "PLISTHEADER"}
         support.check__all__(self, plistlib, not_exported=not_exported)
 
+@unittest.skipUnless(sys.platform == "darwin", "plutil utility is for Mac os")
+class TestPlutil(unittest.TestCase):
+    file_name = "plutil_test.plist"
+    properties = {
+            "fname" : "H",
+            "lname":"A",
+            "marks" : {"a":100, "b":0x10}
+        }
+    exptected_properties = {
+        "fname" : "H",
+        "lname": "A",
+        "marks" : {"a":100, "b":16}
+    }
+    pl = {
+            "HexType" : 0x0100000c,
+            "IntType" : 0o123
+        }
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        ## Generate plist file with plistlib and parse with plutil
+        with open(cls.file_name,'wb') as f:
+            plistlib.dump(cls.properties, f, fmt=plistlib.FMT_BINARY)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        os.remove(cls.file_name)
+
+    def get_lint_status(self):
+        return subprocess.run(['plutil', "-lint", self.file_name], capture_output=True, text=True).stdout
+
+    def convert_to_json(self):
+        """Convert binary file to json using plutil
+        """
+        subprocess.run(['plutil', "-convert", 'json', self.file_name])
+
+    def convert_to_bin(self):
+        """Convert file to binary using plutil
+        """
+        subprocess.run(['plutil', "-convert", 'binary1', self.file_name])
+
+    def write_pl(self):
+        """Write Hex properties to file using writePlist
+        """
+        with open(self.file_name, 'wb') as f:
+            plistlib.dump(self.pl, f, fmt=plistlib.FMT_BINARY)
+
+    def test_lint_status(self):
+        # check lint status of file using plutil
+        self.assertEqual(f"{self.file_name}: OK\n", self.get_lint_status())
+
+    def check_content(self):
+        # check file content with plutil converting binary to json
+        self.convert_to_json()
+        with open(self.file_name) as f:
+            ff = json.loads(f.read())
+            self.assertEqual(ff, self.exptected_properties)
+
+    def check_plistlib_parse(self):
+        # Generate plist files with plutil and parse with plistlib
+        self.convert_to_bin()
+        with open(self.file_name, 'rb') as f:
+            self.assertEqual(plistlib.load(f), self.exptected_properties)
+
+    def test_octal_and_hex(self):
+        self.write_pl()
+        self.convert_to_json()
+        with open(self.file_name, 'r') as f:
+            p = json.loads(f.read())
+            self.assertEqual(p.get("HexType"), 16777228)
+            self.assertEqual(p.get("IntType"), 83)
+
 
 if __name__ == '__main__':
     unittest.main()

From 68d65a7280c01d5a428cc2ab92b780eecb4e5f2a Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 3 Jan 2026 20:17:12 -0500
Subject: [PATCH 165/418] Updated token + weakref libraries + weakref test -
 v3.13.11 (#6633)

* Updated the token library

* Updated the weakref library

* Annotated the failing weakref test
---
 Lib/test/_test_multiprocessing.py |  2 +-
 Lib/test/test_weakref.py          | 74 +++++++++++--------------------
 Lib/token.py                      | 29 +++++++-----
 Lib/weakref.py                    |  3 +-
 4 files changed, 45 insertions(+), 63 deletions(-)

diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 093139e45e5..1311641758b 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -1459,7 +1459,7 @@ def _acquire_release(lock, timeout, l=None, n=1):
         for _ in range(n):
             lock.release()
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky test")
+    @unittest.expectedFailureIf(sys.platform == "darwin", "TODO: RUSTPYTHON")
     def test_repr_rlock(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index f47c17b7234..c118987411f 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -289,8 +289,7 @@ def test_ref_reuse(self):
         self.assertEqual(weakref.getweakrefcount(o), 1,
                      "wrong weak ref count for object after deleting proxy")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_reuse(self):
         o = C()
         proxy1 = weakref.proxy(o)
@@ -338,8 +337,7 @@ def __bytes__(self):
         self.assertIn("__bytes__", dir(weakref.proxy(instance)))
         self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_index(self):
         class C:
             def __index__(self):
@@ -348,8 +346,7 @@ def __index__(self):
         p = weakref.proxy(o)
         self.assertEqual(operator.index(p), 10)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_div(self):
         class C:
             def __floordiv__(self, other):
@@ -362,8 +359,7 @@ def __ifloordiv__(self, other):
         p //= 5
         self.assertEqual(p, 21)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_matmul(self):
         class C:
             def __matmul__(self, other):
@@ -387,13 +383,11 @@ def __imatmul__(self, other):
     # was not honored, and was broken in different ways for
     # PyWeakref_NewRef() and PyWeakref_NewProxy().  (Two tests.)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_shared_ref_without_callback(self):
         self.check_shared_without_callback(weakref.ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_shared_proxy_without_callback(self):
         self.check_shared_without_callback(weakref.proxy)
 
@@ -415,8 +409,7 @@ def check_shared_without_callback(self, makeref):
         p2 = makeref(o)
         self.assertIs(p1, p2, "callbacks were None, NULL in the C API")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callable_proxy(self):
         o = Callable()
         ref1 = weakref.proxy(o)
@@ -511,8 +504,7 @@ def __iter__(self):
         # Calls proxy.__next__
         self.assertEqual(list(weak_it), [4, 5, 6])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_bad_next(self):
         # bpo-44720: PyIter_Next() shouldn't be called if the reference
         # isn't an iterator.
@@ -602,8 +594,7 @@ def test_getweakrefs(self):
         self.assertEqual(weakref.getweakrefs(1), [],
                      "list of refs does not match for int")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newstyle_number_ops(self):
         class F(float):
             pass
@@ -770,8 +761,7 @@ class D:
         del c1, c2, C, D
         gc.collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @suppress_immortalization()
     def test_callback_in_cycle_resurrection(self):
         import gc
@@ -819,8 +809,7 @@ def C_went_away(ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callbacks_on_callback(self):
         import gc
 
@@ -859,13 +848,11 @@ def cb(self, ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_ref_creation(self):
         self.check_gc_during_creation(weakref.ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_proxy_creation(self):
         self.check_gc_during_creation(weakref.proxy)
 
@@ -1016,8 +1003,7 @@ def cb(wparent):
         del root
         gc.collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callback_attribute(self):
         x = Object(1)
         callback = lambda ref: None
@@ -1027,8 +1013,7 @@ def test_callback_attribute(self):
         ref2 = weakref.ref(x)
         self.assertIsNone(ref2.__callback__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callback_attribute_after_deletion(self):
         x = Object(1)
         ref = weakref.ref(x, self.callback)
@@ -1080,8 +1065,7 @@ def callback(obj):
 
 class SubclassableWeakrefTestCase(TestBase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs(self):
         class MyRef(weakref.ref):
             def __init__(self, ob, callback=None, value=42):
@@ -1100,8 +1084,7 @@ def __call__(self):
         self.assertIsNone(mr())
         self.assertTrue(mr.called)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs_dont_replace_standard_refs(self):
         class MyRef(weakref.ref):
             pass
@@ -1353,13 +1336,11 @@ def check_len_cycles(self, dict_type, cons):
         self.assertIn(n1, (0, 1))
         self.assertEqual(n2, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_cycles(self):
         self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_cycles(self):
         self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1387,13 +1368,11 @@ def check_len_race(self, dict_type, cons):
             self.assertGreaterEqual(n2, 0)
             self.assertLessEqual(n2, n1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_race(self):
         self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_race(self):
         self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1894,8 +1873,7 @@ def test_weak_valued_delitem(self):
         self.assertEqual(len(d), 1)
         self.assertEqual(list(d.items()), [('something else', o2)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_bad_delitem(self):
         d = weakref.WeakKeyDictionary()
         o = Object('1')
@@ -2088,7 +2066,7 @@ def test_threaded_weak_key_dict_deepcopy(self):
         # copying should not result in a crash.
         self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, True)
 
-    @unittest.skip("TODO: RUSTPYTHON; occasionally crash (Exit code -6)")
+    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (Exit code -6)')
     @threading_helper.requires_working_threading()
     def test_threaded_weak_value_dict_copy(self):
         # Issue #35615: Weakref keys or values getting GC'ed during dict
@@ -2279,7 +2257,7 @@ def error():
         assert f3.atexit == True
         assert f4.atexit == True
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     def test_atexit(self):
         prog = ('from test.test_weakref import FinalizeTestCase;'+
                 'FinalizeTestCase.run_in_child()')
@@ -2290,8 +2268,7 @@ def test_atexit(self):
 
 
 class ModuleTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_names(self):
         for name in ('ReferenceType', 'ProxyType', 'CallableProxyType',
                      'WeakMethod', 'WeakSet', 'WeakKeyDictionary', 'WeakValueDictionary'):
@@ -2392,6 +2369,7 @@ def test_names(self):
 
 def load_tests(loader, tests, pattern):
     # TODO: RUSTPYTHON
+    # The doctest fails
     # tests.addTest(doctest.DocTestSuite())
     return tests
 
diff --git a/Lib/token.py b/Lib/token.py
index 493bf042650..54d7cdccadc 100644
--- a/Lib/token.py
+++ b/Lib/token.py
@@ -1,7 +1,8 @@
 """Token constants."""
-# Auto-generated by Tools/scripts/generate_token.py
+# Auto-generated by Tools/build/generate_token.py
 
-__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF']
+__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF',
+           'EXACT_TOKEN_TYPES']
 
 ENDMARKER = 0
 NAME = 1
@@ -57,17 +58,20 @@
 RARROW = 51
 ELLIPSIS = 52
 COLONEQUAL = 53
-OP = 54
-AWAIT = 55
-ASYNC = 56
-TYPE_IGNORE = 57
-TYPE_COMMENT = 58
+EXCLAMATION = 54
+OP = 55
+TYPE_IGNORE = 56
+TYPE_COMMENT = 57
+SOFT_KEYWORD = 58
+FSTRING_START = 59
+FSTRING_MIDDLE = 60
+FSTRING_END = 61
+COMMENT = 62
+NL = 63
 # These aren't used by the C tokenizer but are needed for tokenize.py
-ERRORTOKEN = 59
-COMMENT = 60
-NL = 61
-ENCODING = 62
-N_TOKENS = 63
+ERRORTOKEN = 64
+ENCODING = 65
+N_TOKENS = 66
 # Special definitions for cooperation with parser
 NT_OFFSET = 256
 
@@ -77,6 +81,7 @@
 __all__.extend(tok_name.values())
 
 EXACT_TOKEN_TYPES = {
+    '!': EXCLAMATION,
     '!=': NOTEQUAL,
     '%': PERCENT,
     '%=': PERCENTEQUAL,
diff --git a/Lib/weakref.py b/Lib/weakref.py
index 994ea8aa37d..25b70927e29 100644
--- a/Lib/weakref.py
+++ b/Lib/weakref.py
@@ -2,7 +2,7 @@
 
 This module is an implementation of PEP 205:
 
-https://www.python.org/dev/peps/pep-0205/
+https://peps.python.org/pep-0205/
 """
 
 # Naming convention: Variables named "wr" are weak reference objects;
@@ -33,7 +33,6 @@
            "WeakSet", "WeakMethod", "finalize"]
 
 
-_collections_abc.Set.register(WeakSet)
 _collections_abc.MutableSet.register(WeakSet)
 
 class WeakMethod(ref):

From 8bfe927de5b4bea6dd7f7a3fc7cd4f1ba041878f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 11:07:58 +0900
Subject: [PATCH 166/418] skip TestTLS_FTPClass (#6640)

---
 Lib/test/test_ftplib.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index ae4ec5dbfb7..10766bc9540 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -940,6 +940,7 @@ def setUp(self, encoding=DEFAULT_ENCODING):
 
 
 @skipUnless(ssl, "SSL not available")
+@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem on darwin")
 @requires_subprocess()
 class TestTLS_FTPClass(TestCase):
     """Specific TLS_FTP class tests."""

From fd27c2d78f27f853d32405e55be5ff398fb356ed Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 17:53:59 +0900
Subject: [PATCH 167/418] Fix SSL handshake partial send (#6635)

* simplify test_ftplib

* mark flaky test

* better ssl handshake, pending tls output

* flush_all_pending

* deadline

* flush pending
---
 Lib/test/_test_multiprocessing.py |   2 +-
 Lib/test/test_ftplib.py           |  24 +-
 crates/stdlib/src/ssl.rs          | 431 +++++++++++++++++++++++++-----
 crates/stdlib/src/ssl/compat.rs   | 173 ++++++++++--
 4 files changed, 513 insertions(+), 117 deletions(-)

diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 1311641758b..2fc206f7d53 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -1459,7 +1459,7 @@ def _acquire_release(lock, timeout, l=None, n=1):
         for _ in range(n):
             lock.release()
 
-    @unittest.expectedFailureIf(sys.platform == "darwin", "TODO: RUSTPYTHON")
+    @unittest.skipIf(sys.platform == 'darwin', "TODO: RUSTPYTHON; flaky on darwin")
     def test_repr_rlock(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index 10766bc9540..2488f64a218 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -593,16 +593,12 @@ def test_quit(self):
     def test_abort(self):
         self.client.abort()
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_retrbinary(self):
         received = []
         self.client.retrbinary('retr', received.append)
         self.check_data(b''.join(received),
                         RETR_DATA.encode(self.client.encoding))
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_retrbinary_rest(self):
         for rest in (0, 10, 20):
             received = []
@@ -610,14 +606,11 @@ def test_retrbinary_rest(self):
             self.check_data(b''.join(received),
                             RETR_DATA[rest:].encode(self.client.encoding))
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_retrlines(self):
         received = []
         self.client.retrlines('retr', received.append)
         self.check_data(''.join(received), RETR_DATA.replace('\r\n', ''))
 
-    @unittest.skip('TODO: RUSTPYTHON; weird limiting to 8192, something w/ buffering?')
     def test_storbinary(self):
         f = io.BytesIO(RETR_DATA.encode(self.client.encoding))
         self.client.storbinary('stor', f)
@@ -629,8 +622,6 @@ def test_storbinary(self):
         self.client.storbinary('stor', f, callback=lambda x: flag.append(None))
         self.assertTrue(flag)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_storbinary_rest(self):
         data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
         f = io.BytesIO(data)
@@ -639,8 +630,6 @@ def test_storbinary_rest(self):
             self.client.storbinary('stor', f, rest=r)
             self.assertEqual(self.server.handler_instance.rest, str(r))
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_storlines(self):
         data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
         f = io.BytesIO(data)
@@ -658,21 +647,15 @@ def test_storlines(self):
         with warnings_helper.check_warnings(('', BytesWarning), quiet=True):
             self.assertRaises(TypeError, self.client.storlines, 'stor foo', f)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_nlst(self):
         self.client.nlst()
         self.assertEqual(self.client.nlst(), NLST_DATA.split('\r\n')[:-1])
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_dir(self):
         l = []
         self.client.dir(l.append)
         self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_mlsd(self):
         list(self.client.mlsd())
         list(self.client.mlsd(path='/'))
@@ -859,8 +842,6 @@ def test_storlines_too_long(self):
         f = io.BytesIO(b'x' * self.client.maxline * 2)
         self.assertRaises(ftplib.Error, self.client.storlines, 'stor', f)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # TimeoutError: The read operation timed out
     def test_encoding_param(self):
         encodings = ['latin-1', 'utf-8']
         for encoding in encodings:
@@ -922,6 +903,7 @@ def retr():
         retr()
 
 
+@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
 @skipUnless(ssl, "SSL not available")
 @requires_subprocess()
 class TestTLS_FTPClassMixin(TestFTPClass):
@@ -940,7 +922,7 @@ def setUp(self, encoding=DEFAULT_ENCODING):
 
 
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem on darwin")
+@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
 @requires_subprocess()
 class TestTLS_FTPClass(TestCase):
     """Specific TLS_FTP class tests."""
@@ -1025,8 +1007,6 @@ def test_context(self):
             self.assertIs(sock.context, ctx)
             self.assertIsInstance(sock, ssl.SSLSocket)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # ssl_error.SSLWantReadError: The operation did not complete (read)
     def test_ccc(self):
         self.assertRaises(ValueError, self.client.ccc)
         self.client.login(secure=True)
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index c22dd303c59..5a219baaf7f 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -1902,6 +1902,7 @@ mod _ssl {
                 pending_context: PyRwLock::new(None),
                 client_hello_buffer: PyMutex::new(None),
                 shutdown_state: PyMutex::new(ShutdownState::NotStarted),
+                pending_tls_output: PyMutex::new(Vec::new()),
                 deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
             };
 
@@ -1972,6 +1973,7 @@ mod _ssl {
                 pending_context: PyRwLock::new(None),
                 client_hello_buffer: PyMutex::new(None),
                 shutdown_state: PyMutex::new(ShutdownState::NotStarted),
+                pending_tls_output: PyMutex::new(Vec::new()),
                 deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
             };
 
@@ -2337,6 +2339,12 @@ mod _ssl {
         // Shutdown state for tracking close-notify exchange
         #[pytraverse(skip)]
         shutdown_state: PyMutex<ShutdownState>,
+        // Pending TLS output buffer for non-blocking sockets
+        // Stores unsent TLS bytes when sock_send() would block
+        // This prevents data loss when write_tls() drains rustls' internal buffer
+        // but the socket cannot accept all the data immediately
+        #[pytraverse(skip)]
+        pub(crate) pending_tls_output: PyMutex<Vec<u8>>,
         // Deferred client certificate verification error (for TLS 1.3)
         // Stores error message if client cert verification failed during handshake
         // Error is raised on first I/O operation after handshake
@@ -2700,7 +2708,7 @@ mod _ssl {
 
         // Helper to call socket methods, bypassing any SSL wrapper
         pub(crate) fn sock_recv(&self, size: usize, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-            // In BIO mode, read from incoming BIO
+            // In BIO mode, read from incoming BIO (flags not supported)
             if let Some(ref bio) = self.incoming_bio {
                 let bio_obj: PyObjectRef = bio.clone().into();
                 let read_method = bio_obj.get_attr("read", vm)?;
@@ -2711,21 +2719,19 @@ mod _ssl {
             let socket_mod = vm.import("socket", 0)?;
             let socket_class = socket_mod.get_attr("socket", vm)?;
 
-            // Call socket.socket.recv(self.sock, size)
+            // Call socket.socket.recv(self.sock, size, flags)
             let recv_method = socket_class.get_attr("recv", vm)?;
             recv_method.call((self.sock.clone(), vm.ctx.new_int(size)), vm)
         }
 
-        pub(crate) fn sock_send(
-            &self,
-            data: Vec<u8>,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyObjectRef> {
+        /// Socket send - just sends data, caller must handle pending flush
+        /// Use flush_pending_tls_output before this if ordering is important
+        pub(crate) fn sock_send(&self, data: &[u8], vm: &VirtualMachine) -> PyResult<PyObjectRef> {
             // In BIO mode, write to outgoing BIO
             if let Some(ref bio) = self.outgoing_bio {
                 let bio_obj: PyObjectRef = bio.clone().into();
                 let write_method = bio_obj.get_attr("write", vm)?;
-                return write_method.call((vm.ctx.new_bytes(data),), vm);
+                return write_method.call((vm.ctx.new_bytes(data.to_vec()),), vm);
             }
 
             // Normal socket mode
@@ -2734,7 +2740,201 @@ mod _ssl {
 
             // Call socket.socket.send(self.sock, data)
             let send_method = socket_class.get_attr("send", vm)?;
-            send_method.call((self.sock.clone(), vm.ctx.new_bytes(data)), vm)
+            send_method.call((self.sock.clone(), vm.ctx.new_bytes(data.to_vec())), vm)
+        }
+
+        /// Flush any pending TLS output data to the socket
+        /// Optional deadline parameter allows respecting a read deadline during flush
+        pub(crate) fn flush_pending_tls_output(
+            &self,
+            vm: &VirtualMachine,
+            deadline: Option<std::time::Instant>,
+        ) -> PyResult<()> {
+            let mut pending = self.pending_tls_output.lock();
+            if pending.is_empty() {
+                return Ok(());
+            }
+
+            let socket_timeout = self.get_socket_timeout(vm)?;
+            let is_non_blocking = socket_timeout.map(|t| t.is_zero()).unwrap_or(false);
+
+            let mut sent_total = 0;
+            while sent_total < pending.len() {
+                // Calculate timeout: use deadline if provided, otherwise use socket timeout
+                let timeout_to_use = if let Some(dl) = deadline {
+                    let now = std::time::Instant::now();
+                    if now >= dl {
+                        // Deadline already passed
+                        *pending = pending[sent_total..].to_vec();
+                        return Err(
+                            timeout_error_msg(vm, "The operation timed out".to_string()).upcast()
+                        );
+                    }
+                    Some(dl - now)
+                } else {
+                    socket_timeout
+                };
+
+                // Use sock_select directly with calculated timeout
+                let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+                let socket = py_socket
+                    .sock()
+                    .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+                let timed_out = sock_select(&socket, SelectKind::Write, timeout_to_use)
+                    .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+                if timed_out {
+                    // Keep unsent data in pending buffer
+                    *pending = pending[sent_total..].to_vec();
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                match self.sock_send(&pending[sent_total..], vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent == 0 {
+                            if is_non_blocking {
+                                // Keep unsent data in pending buffer
+                                *pending = pending[sent_total..].to_vec();
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        sent_total += sent;
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            if is_non_blocking {
+                                // Keep unsent data in pending buffer
+                                *pending = pending[sent_total..].to_vec();
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        // Keep unsent data in pending buffer for other errors too
+                        *pending = pending[sent_total..].to_vec();
+                        return Err(e);
+                    }
+                }
+            }
+
+            // All data sent successfully
+            pending.clear();
+            Ok(())
+        }
+
+        /// Send TLS output data to socket, saving unsent bytes to pending buffer
+        /// This prevents data loss when rustls' write_tls() drains its internal buffer
+        /// but the socket cannot accept all the data immediately
+        fn send_tls_output(&self, buf: Vec<u8>, vm: &VirtualMachine) -> PyResult<()> {
+            if buf.is_empty() {
+                return Ok(());
+            }
+
+            let timeout = self.get_socket_timeout(vm)?;
+            let is_non_blocking = timeout.map(|t| t.is_zero()).unwrap_or(false);
+
+            let mut sent_total = 0;
+            while sent_total < buf.len() {
+                let timed_out = self.sock_wait_for_io_impl(SelectKind::Write, vm)?;
+                if timed_out {
+                    // Save unsent data to pending buffer
+                    self.pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                match self.sock_send(&buf[sent_total..], vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent == 0 {
+                            if is_non_blocking {
+                                // Save unsent data to pending buffer
+                                self.pending_tls_output
+                                    .lock()
+                                    .extend_from_slice(&buf[sent_total..]);
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        sent_total += sent;
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            if is_non_blocking {
+                                // Save unsent data to pending buffer
+                                self.pending_tls_output
+                                    .lock()
+                                    .extend_from_slice(&buf[sent_total..]);
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        // Save unsent data for other errors too
+                        self.pending_tls_output
+                            .lock()
+                            .extend_from_slice(&buf[sent_total..]);
+                        return Err(e);
+                    }
+                }
+            }
+
+            Ok(())
+        }
+
+        /// Flush all pending TLS output data, respecting socket timeout
+        /// Used during handshake completion and shutdown() to ensure all data is sent
+        pub(crate) fn blocking_flush_all_pending(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Get socket timeout to respect during flush
+            let timeout = self.get_socket_timeout(vm)?;
+
+            loop {
+                let pending_data = {
+                    let pending = self.pending_tls_output.lock();
+                    if pending.is_empty() {
+                        return Ok(());
+                    }
+                    pending.clone()
+                };
+
+                // Wait for socket to be writable, respecting socket timeout
+                let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+                let socket = py_socket
+                    .sock()
+                    .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+                let timed_out = sock_select(&socket, SelectKind::Write, timeout)
+                    .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+                if timed_out {
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                // Try to send pending data (use raw to avoid recursion)
+                match self.sock_send(&pending_data, vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent > 0 {
+                            let mut pending = self.pending_tls_output.lock();
+                            pending.drain(..sent);
+                        }
+                        // If sent == 0, socket wasn't ready despite select() saying so
+                        // Continue loop to retry - this avoids infinite loops
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            continue;
+                        }
+                        return Err(e);
+                    }
+                }
+            }
         }
 
         #[pymethod]
@@ -3229,9 +3429,10 @@ mod _ssl {
                 };
             }
 
-            // Ensure handshake is done
+            // Ensure handshake is done - if not, complete it first
+            // This matches OpenSSL behavior where SSL_read() auto-completes handshake
             if !*self.handshake_done.lock() {
-                return Err(vm.new_value_error("Handshake not completed"));
+                self.do_handshake(vm)?;
             }
 
             // Check if connection has been shut down
@@ -3272,7 +3473,7 @@ mod _ssl {
             };
 
             // Use compat layer for unified read logic with proper EOF handling
-            // This matches CPython's SSL_read_ex() approach
+            // This matches SSL_read_ex() approach
             let mut buf = vec![0u8; len];
             let read_result = {
                 let mut conn_guard = self.connection.lock();
@@ -3360,9 +3561,10 @@ mod _ssl {
                 return Ok(0);
             }
 
-            // Ensure handshake is done
+            // Ensure handshake is done - if not, complete it first
+            // This matches OpenSSL behavior where SSL_write() auto-completes handshake
             if !*self.handshake_done.lock() {
-                return Err(vm.new_value_error("Handshake not completed"));
+                self.do_handshake(vm)?;
             }
 
             // Check if connection has been shut down
@@ -3387,6 +3589,13 @@ mod _ssl {
                 let is_bio = self.is_bio_mode();
                 let data: &[u8] = data_bytes.as_ref();
 
+                // CRITICAL: Flush any pending TLS data before writing new data
+                // This ensures TLS 1.3 Finished message reaches server before application data
+                // Without this, server may not be ready to process our data
+                if !is_bio {
+                    self.flush_pending_tls_output(vm, None)?;
+                }
+
                 // Write data in chunks to avoid filling the internal TLS buffer
                 // rustls has a limited internal buffer, so we need to flush periodically
                 const CHUNK_SIZE: usize = 16384; // 16KB chunks (typical TLS record size)
@@ -3403,6 +3612,10 @@ mod _ssl {
                         writer
                             .write_all(chunk)
                             .map_err(|e| vm.new_os_error(format!("Write failed: {e}")))?;
+                        // Flush to ensure data is converted to TLS records
+                        writer
+                            .flush()
+                            .map_err(|e| vm.new_os_error(format!("Flush failed: {e}")))?;
                     }
 
                     written = chunk_end;
@@ -3413,6 +3626,9 @@ mod _ssl {
                             self.write_pending_tls(conn, vm)?;
                         } else {
                             // Socket mode: flush all pending TLS data
+                            // First, try to send any previously pending data
+                            self.flush_pending_tls_output(vm, None)?;
+
                             while conn.wants_write() {
                                 let mut buf = Vec::new();
                                 conn.write_tls(&mut buf).map_err(|e| {
@@ -3420,23 +3636,8 @@ mod _ssl {
                                 })?;
 
                                 if !buf.is_empty() {
-                                    let timed_out =
-                                        self.sock_wait_for_io_impl(SelectKind::Write, vm)?;
-                                    if timed_out {
-                                        return Err(vm.new_os_error("Write operation timed out"));
-                                    }
-
-                                    match self.sock_send(buf, vm) {
-                                        Ok(_) => {}
-                                        Err(e) => {
-                                            if is_blocking_io_error(&e, vm) {
-                                                return Err(
-                                                    create_ssl_want_write_error(vm).upcast()
-                                                );
-                                            }
-                                            return Err(e);
-                                        }
-                                    }
+                                    // Try to send TLS data, saving unsent bytes to pending buffer
+                                    self.send_tls_output(buf, vm)?;
                                 }
                             }
                         }
@@ -3755,8 +3956,35 @@ mod _ssl {
                 .as_mut()
                 .ok_or_else(|| vm.new_value_error("Connection not established"))?;
 
+            let is_bio = self.is_bio_mode();
+
             // Step 1: Send our close_notify if not already sent
             if current_state == ShutdownState::NotStarted {
+                // First, flush ALL pending TLS data BEFORE sending close_notify
+                // This is CRITICAL - close_notify must come AFTER all application data
+                // Otherwise data loss occurs when peer receives close_notify first
+
+                // Step 1a: Flush any pending TLS records from rustls internal buffer
+                // This ensures all application data is converted to TLS records
+                while conn.wants_write() {
+                    let mut buf = Vec::new();
+                    conn.write_tls(&mut buf)
+                        .map_err(|e| vm.new_os_error(format!("TLS write failed: {e}")))?;
+                    if !buf.is_empty() {
+                        self.send_tls_output(buf, vm)?;
+                    }
+                }
+
+                // Step 1b: Flush pending_tls_output buffer to socket
+                if !is_bio {
+                    // Socket mode: blocking flush to ensure data order
+                    // Must complete before sending close_notify
+                    self.blocking_flush_all_pending(vm)?;
+                } else {
+                    // BIO mode: non-blocking flush (caller handles pending data)
+                    let _ = self.flush_pending_tls_output(vm, None);
+                }
+
                 conn.send_close_notify();
 
                 // Write close_notify to outgoing buffer/BIO
@@ -3767,7 +3995,6 @@ mod _ssl {
             }
 
             // Step 2: Try to read and process peer's close_notify
-            let is_bio = self.is_bio_mode();
 
             // First check if we already have peer's close_notify
             // This can happen if it was received during a previous read() call
@@ -3775,46 +4002,84 @@ mod _ssl {
 
             // If peer hasn't closed yet, try to read from socket
             if !peer_closed {
-                // Check if socket is in blocking mode (timeout is None)
-                let is_blocking = if !is_bio {
+                // Check socket timeout mode
+                let timeout_mode = if !is_bio {
                     // Get socket timeout
                     match self.sock.get_attr("gettimeout", vm) {
                         Ok(method) => match method.call((), vm) {
-                            Ok(timeout) => vm.is_none(&timeout),
-                            Err(_) => false,
+                            Ok(timeout) => {
+                                if vm.is_none(&timeout) {
+                                    // timeout=None means blocking
+                                    Some(None)
+                                } else if let Ok(t) = timeout.try_float(vm).map(|f| f.to_f64()) {
+                                    if t == 0.0 {
+                                        // timeout=0 means non-blocking
+                                        Some(Some(0.0))
+                                    } else {
+                                        // timeout>0 means timeout mode
+                                        Some(Some(t))
+                                    }
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(_) => None,
                         },
-                        Err(_) => false,
+                        Err(_) => None,
                     }
                 } else {
-                    false
+                    None // BIO mode
                 };
 
                 if is_bio {
                     // In BIO mode: non-blocking read attempt
-                    let _ = self.try_read_close_notify(conn, vm);
-                } else if is_blocking {
-                    // Blocking socket mode: Return immediately without waiting for peer
-                    //
-                    // Reasons we don't read from socket here:
-                    // 1. STARTTLS scenario: application data may arrive before/instead of close_notify
-                    //    - Example: client sends ENDTLS, immediately sends plain "msg 5"
-                    //    - Server's unwrap() would read "msg 5" and try to parse as TLS → FAIL
-                    // 2. CPython's SSL_shutdown() typically returns immediately without waiting
-                    // 3. Bidirectional shutdown is the application's responsibility
-                    // 4. Reading from socket would consume application data incorrectly
+                    if self.try_read_close_notify(conn, vm)? {
+                        peer_closed = true;
+                    }
+                } else if let Some(timeout) = timeout_mode {
+                    // All socket modes (blocking, timeout, non-blocking):
+                    // Return immediately after sending our close_notify.
                     //
-                    // Therefore: Just send our close_notify and return success immediately.
-                    // The peer's close_notify (if any) will remain in the socket buffer.
+                    // This matches CPython/OpenSSL behavior where SSL_shutdown()
+                    // returns after sending close_notify, allowing the app to
+                    // close the socket without waiting for peer's close_notify.
                     //
-                    // Mark shutdown as complete and return the underlying socket
+                    // Waiting for peer's close_notify can cause deadlock with
+                    // asyncore-based servers where both sides wait for the other's
+                    // close_notify before closing the connection.
+
+                    // Ensure all pending TLS data is sent before returning
+                    // This prevents data loss when rustls drains its buffer
+                    // but the socket couldn't accept all data immediately
                     drop(conn_guard);
+
+                    // Respect socket timeout settings for flushing pending TLS data
+                    match timeout {
+                        Some(0.0) => {
+                            // Non-blocking: best-effort flush, ignore errors
+                            // to avoid deadlock with asyncore-based servers
+                            let _ = self.flush_pending_tls_output(vm, None);
+                        }
+                        Some(_t) => {
+                            // Timeout mode: use flush with socket's timeout
+                            // Errors (including timeout) are propagated to caller
+                            self.flush_pending_tls_output(vm, None)?;
+                        }
+                        None => {
+                            // Blocking mode: wait until all pending data is sent
+                            self.blocking_flush_all_pending(vm)?;
+                        }
+                    }
+
                     *self.shutdown_state.lock() = ShutdownState::Completed;
                     *self.connection.lock() = None;
                     return Ok(self.sock.clone());
                 }
 
                 // Step 3: Check again if peer has sent close_notify (non-blocking/BIO mode only)
-                peer_closed = self.check_peer_closed(conn, vm)?;
+                if !peer_closed {
+                    peer_closed = self.check_peer_closed(conn, vm)?;
+                }
             }
 
             drop(conn_guard); // Release lock before returning
@@ -3836,6 +4101,10 @@ mod _ssl {
 
         // Helper: Write all pending TLS data (including close_notify) to outgoing buffer/BIO
         fn write_pending_tls(&self, conn: &mut TlsConnection, vm: &VirtualMachine) -> PyResult<()> {
+            // First, flush any previously pending TLS output
+            // Must succeed before sending new data to maintain order
+            self.flush_pending_tls_output(vm, None)?;
+
             loop {
                 if !conn.wants_write() {
                     break;
@@ -3850,42 +4119,62 @@ mod _ssl {
                     break;
                 }
 
-                // Send to outgoing BIO or socket
-                self.sock_send(buf[..written].to_vec(), vm)?;
+                // Send TLS data, saving unsent bytes to pending buffer if needed
+                self.send_tls_output(buf[..written].to_vec(), vm)?;
             }
 
             Ok(())
         }
 
-        // Helper: Try to read incoming data from BIO (non-blocking)
+        // Helper: Try to read incoming data from socket/BIO
+        // Returns true if peer closed connection (with or without close_notify)
         fn try_read_close_notify(
             &self,
             conn: &mut TlsConnection,
             vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            // Try to read incoming data from BIO
-            // This is non-blocking in BIO mode - if no data, recv returns empty
+        ) -> PyResult<bool> {
+            // Try to read incoming data
             match self.sock_recv(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
                 Ok(bytes_obj) => {
                     let bytes = ArgBytesLike::try_from_object(vm, bytes_obj)?;
                     let data = bytes.borrow_buf();
 
-                    if !data.is_empty() {
-                        // Feed data to TLS connection
-                        let data_slice: &[u8] = data.as_ref();
-                        let mut cursor = std::io::Cursor::new(data_slice);
-                        let _ = conn.read_tls(&mut cursor);
-
-                        // Process packets
-                        let _ = conn.process_new_packets();
+                    if data.is_empty() {
+                        // Empty read could mean EOF or just "no data yet" in BIO mode
+                        if let Some(ref bio) = self.incoming_bio {
+                            // BIO mode: check if EOF was signaled via write_eof()
+                            let bio_obj: PyObjectRef = bio.clone().into();
+                            let eof_attr = bio_obj.get_attr("eof", vm)?;
+                            let is_eof = eof_attr.try_to_bool(vm)?;
+                            if !is_eof {
+                                // No EOF signaled, just no data available yet
+                                return Ok(false);
+                            }
+                        }
+                        // Socket mode or BIO with EOF: peer closed connection
+                        // This is "ragged EOF" - peer closed without close_notify
+                        return Ok(true);
                     }
+
+                    // Feed data to TLS connection
+                    let data_slice: &[u8] = data.as_ref();
+                    let mut cursor = std::io::Cursor::new(data_slice);
+                    let _ = conn.read_tls(&mut cursor);
+
+                    // Process packets
+                    let _ = conn.process_new_packets();
+                    Ok(false)
                 }
-                Err(_) => {
-                    // No data available or error - that's OK in BIO mode
+                Err(e) => {
+                    // BlockingIOError means no data yet
+                    if is_blocking_io_error(&e, vm) {
+                        return Ok(false);
+                    }
+                    // Connection reset, EOF, or other error means peer closed
+                    // ECONNRESET, EPIPE, broken pipe, etc.
+                    Ok(true)
                 }
             }
-
-            Ok(())
         }
 
         // Helper: Check if peer has sent close_notify
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 2168fcfc91f..00e2c8d3c32 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -1003,6 +1003,80 @@ pub(super) fn is_blocking_io_error(err: &Py<PyBaseException>, vm: &VirtualMachin
     err.fast_isinstance(vm.ctx.exceptions.blocking_io_error)
 }
 
+// Socket I/O Helper Functions
+
+/// Send all bytes to socket, handling partial sends with blocking wait
+///
+/// Loops until all bytes are sent. For blocking sockets, this will wait
+/// until all data is sent. For non-blocking sockets, returns WantWrite
+/// if no progress can be made.
+/// Optional deadline parameter allows respecting a read deadline during flush.
+fn send_all_bytes(
+    socket: &PySSLSocket,
+    buf: Vec<u8>,
+    vm: &VirtualMachine,
+    deadline: Option<std::time::Instant>,
+) -> SslResult<()> {
+    // First, flush any previously pending TLS data with deadline
+    socket
+        .flush_pending_tls_output(vm, deadline)
+        .map_err(SslError::Py)?;
+
+    if buf.is_empty() {
+        return Ok(());
+    }
+
+    let mut sent_total = 0;
+    while sent_total < buf.len() {
+        // Check deadline before each send attempt
+        if let Some(dl) = deadline
+            && std::time::Instant::now() >= dl
+        {
+            socket
+                .pending_tls_output
+                .lock()
+                .extend_from_slice(&buf[sent_total..]);
+            return Err(SslError::Timeout("The operation timed out".to_string()));
+        }
+
+        match socket.sock_send(&buf[sent_total..], vm) {
+            Ok(result) => {
+                let sent: usize = result
+                    .try_to_value::<isize>(vm)
+                    .map_err(SslError::Py)?
+                    .try_into()
+                    .map_err(|_| SslError::Syscall("Invalid send return value".to_string()))?;
+                if sent == 0 {
+                    // No progress - save unsent bytes to pending buffer
+                    socket
+                        .pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(SslError::WantWrite);
+                }
+                sent_total += sent;
+            }
+            Err(e) => {
+                if is_blocking_io_error(&e, vm) {
+                    // Save unsent bytes to pending buffer
+                    socket
+                        .pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(SslError::WantWrite);
+                }
+                // For other errors, also save unsent bytes
+                socket
+                    .pending_tls_output
+                    .lock()
+                    .extend_from_slice(&buf[sent_total..]);
+                return Err(SslError::Py(e));
+            }
+        }
+    }
+    Ok(())
+}
+
 // Handshake Helper Functions
 
 /// Write TLS handshake data to socket/BIO
@@ -1017,6 +1091,12 @@ fn handshake_write_loop(
 ) -> SslResult<bool> {
     let mut made_progress = false;
 
+    // Flush any previously pending TLS data before generating new output
+    // Must succeed before sending new data to maintain order
+    socket
+        .flush_pending_tls_output(vm, None)
+        .map_err(SslError::Py)?;
+
     while conn.wants_write() || force_initial_write {
         if force_initial_write && !conn.wants_write() {
             // No data to write on first iteration - break to avoid infinite loop
@@ -1029,20 +1109,9 @@ fn handshake_write_loop(
             .map_err(SslError::Io)?;
 
         if written > 0 && !buf.is_empty() {
-            // Send directly without select - blocking sockets will wait automatically
-            // Handle BlockingIOError from non-blocking sockets
-            match socket.sock_send(buf, vm) {
-                Ok(_) => {
-                    made_progress = true;
-                }
-                Err(e) => {
-                    if is_blocking_io_error(&e, vm) {
-                        // Non-blocking socket would block - return SSLWantWriteError
-                        return Err(SslError::WantWrite);
-                    }
-                    return Err(SslError::Py(e));
-                }
-            }
+            // Send all bytes to socket, handling partial sends
+            send_all_bytes(socket, buf, vm, None)?;
+            made_progress = true;
         } else if written == 0 {
             // No data written but wants_write is true - should not happen normally
             // Break to avoid infinite loop
@@ -1160,7 +1229,7 @@ fn handle_handshake_complete(
             // Do NOT loop on wants_write() - avoid infinite loop/deadlock
             let tls_data = ssl_write_tls_records(conn)?;
             if !tls_data.is_empty() {
-                socket.sock_send(tls_data, vm).map_err(SslError::Py)?;
+                send_all_bytes(socket, tls_data, vm, None)?;
             }
 
             // IMPORTANT: Don't check wants_write() again!
@@ -1168,15 +1237,30 @@ fn handle_handshake_complete(
         }
     } else if conn.wants_write() {
         // Send all pending data (e.g., TLS 1.3 NewSessionTicket) to socket
+        // Best-effort: WantWrite means socket buffer full, pending data will be
+        // sent in subsequent read/write calls. Don't fail handshake for this.
         while conn.wants_write() {
             let tls_data = ssl_write_tls_records(conn)?;
             if tls_data.is_empty() {
                 break;
             }
-            socket.sock_send(tls_data, vm).map_err(SslError::Py)?;
+            match send_all_bytes(socket, tls_data, vm, None) {
+                Ok(()) => {}
+                Err(SslError::WantWrite) => break,
+                Err(e) => return Err(e),
+            }
         }
     }
 
+    // CRITICAL: Ensure all pending TLS data is sent before returning
+    // TLS 1.3 Finished must reach server before handshake is considered complete
+    // Without this, server may not process application data
+    if !socket.is_bio_mode() {
+        socket
+            .blocking_flush_all_pending(vm)
+            .map_err(SslError::Py)?;
+    }
+
     Ok(true)
 }
 
@@ -1249,11 +1333,14 @@ pub(super) fn ssl_do_handshake(
             // Send close_notify on error
             if !is_bio {
                 conn.send_close_notify();
-                // Actually send the close_notify alert
+                // Flush any pending TLS data before sending close_notify
+                let _ = socket.flush_pending_tls_output(vm, None);
+                // Actually send the close_notify alert using send_all_bytes
+                // for proper partial send handling and retry logic
                 if let Ok(alert_data) = ssl_write_tls_records(conn)
                     && !alert_data.is_empty()
                 {
-                    let _ = socket.sock_send(alert_data, vm);
+                    let _ = send_all_bytes(socket, alert_data, vm, None);
                 }
             }
 
@@ -1304,9 +1391,7 @@ pub(super) fn ssl_do_handshake(
                         break;
                     }
                     // Send to outgoing BIO
-                    socket
-                        .sock_send(buf[..n].to_vec(), vm)
-                        .map_err(SslError::Py)?;
+                    send_all_bytes(socket, buf[..n].to_vec(), vm, None)?;
                     // Check if there's more to write
                     if !conn.wants_write() {
                         break;
@@ -1388,6 +1473,16 @@ pub(super) fn ssl_read(
         None // BIO mode has no deadline
     };
 
+    // CRITICAL: Flush any pending TLS output before reading
+    // This ensures data from previous write() calls is sent before we wait for response.
+    // Without this, write() may leave data in pending_tls_output (if socket buffer was full),
+    // and read() would timeout waiting for a response that the server never received.
+    if !is_bio {
+        socket
+            .flush_pending_tls_output(vm, deadline)
+            .map_err(SslError::Py)?;
+    }
+
     // Loop to handle TLS records and post-handshake messages
     // Matches SSL_read behavior which loops until data is available
     //   - CPython uses OpenSSL's SSL_read which loops on SSL_ERROR_WANT_READ/WANT_WRITE
@@ -1396,6 +1491,7 @@ pub(super) fn ssl_read(
     //   - Blocking sockets: sock_select() and recv() wait at kernel level (no CPU busy-wait)
     //   - Non-blocking sockets: immediate return on first WantRead
     //   - Deadline prevents timeout issues
+
     loop {
         // Check deadline
         if let Some(deadline) = deadline
@@ -1420,11 +1516,43 @@ pub(super) fn ssl_read(
             // Check if connection needs to write data first (e.g., TLS key update, renegotiation)
             // This mirrors the handshake logic which checks both wants_read() and wants_write()
             if conn.wants_write() && !is_bio {
+                // Check deadline BEFORE attempting flush
+                if let Some(deadline) = deadline
+                    && std::time::Instant::now() >= deadline
+                {
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
+                }
+
                 // Flush pending TLS data before continuing
+                // CRITICAL: Pass deadline so flush respects read timeout
                 let tls_data = ssl_write_tls_records(conn)?;
                 if !tls_data.is_empty() {
-                    socket.sock_send(tls_data, vm).map_err(SslError::Py)?;
+                    // Use best-effort send - don't fail READ just because WRITE couldn't complete
+                    match send_all_bytes(socket, tls_data, vm, deadline) {
+                        Ok(()) => {}
+                        Err(SslError::WantWrite) => {
+                            // Socket buffer full - acceptable during READ operation
+                            // Pending data will be sent on next write/read call
+                        }
+                        Err(SslError::Timeout(_)) => {
+                            // Timeout during flush is acceptable during READ
+                            // Pending data stays buffered for next operation
+                        }
+                        Err(e) => return Err(e),
+                    }
                 }
+
+                // Check deadline AFTER flush attempt
+                if let Some(deadline) = deadline
+                    && std::time::Instant::now() >= deadline
+                {
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
+                }
+
                 // After flushing, rustls may want to read again - continue loop
                 continue;
             }
@@ -1487,7 +1615,6 @@ pub(super) fn ssl_read(
         }
 
         // Read and process TLS records
-        // This will block for blocking sockets
         match ssl_ensure_data_available(conn, socket, vm) {
             Ok(_bytes_read) => {
                 // Successfully read and processed TLS data

From bdd036ea6bdf4b133a0a889185d1a9cbaded57fa Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 20:52:35 +0900
Subject: [PATCH 168/418] pythonrun (#6643)

---
 crates/vm/src/vm/compile.rs    | 197 +--------------------------------
 crates/vm/src/vm/mod.rs        |   2 +
 crates/vm/src/vm/python_run.rs | 186 +++++++++++++++++++++++++++++++
 src/lib.rs                     |  76 ++++++++++---
 4 files changed, 257 insertions(+), 204 deletions(-)
 create mode 100644 crates/vm/src/vm/python_run.rs

diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
index 07ab4b833d2..97f0f9e97b8 100644
--- a/crates/vm/src/vm/compile.rs
+++ b/crates/vm/src/vm/compile.rs
@@ -1,9 +1,11 @@
+//! Python code compilation functions.
+//!
+//! For code execution functions, see python_run.rs
+
 use crate::{
-    AsObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
-    builtins::{PyCode, PyDictRef},
+    PyRef, VirtualMachine,
+    builtins::PyCode,
     compiler::{self, CompileError, CompileOpts},
-    convert::TryFromObject,
-    scope::Scope,
 };
 
 impl VirtualMachine {
@@ -25,191 +27,4 @@ impl VirtualMachine {
     ) -> Result<PyRef<PyCode>, CompileError> {
         compiler::compile(source, mode, &source_path, opts).map(|code| self.ctx.new_code(code))
     }
-
-    // pymain_run_file_obj
-    pub fn run_script(&self, scope: Scope, path: &str) -> PyResult<()> {
-        // when pymain_run_module?
-        if get_importer(path, self)?.is_some() {
-            self.insert_sys_path(self.new_pyobj(path))?;
-            let runpy = self.import("runpy", 0)?;
-            let run_module_as_main = runpy.get_attr("_run_module_as_main", self)?;
-            run_module_as_main.call((identifier!(self, __main__).to_owned(), false), self)?;
-            return Ok(());
-        }
-
-        // TODO: check if this is proper place
-        if !self.state.config.settings.safe_path {
-            let dir = std::path::Path::new(path)
-                .parent()
-                .unwrap()
-                .to_str()
-                .unwrap();
-            self.insert_sys_path(self.new_pyobj(dir))?;
-        }
-
-        self.run_any_file(scope, path)
-    }
-
-    // = _PyRun_AnyFileObject
-    fn run_any_file(&self, scope: Scope, path: &str) -> PyResult<()> {
-        let path = if path.is_empty() { "???" } else { path };
-
-        self.run_simple_file(scope, path)
-    }
-
-    // = _PyRun_SimpleFileObject
-    fn run_simple_file(&self, scope: Scope, path: &str) -> PyResult<()> {
-        // __main__ is given by scope
-        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
-        let main_module = sys_modules.get_item(identifier!(self, __main__), self)?;
-        let module_dict = main_module.dict().expect("main module must have __dict__");
-        if !module_dict.contains_key(identifier!(self, __file__), self) {
-            module_dict.set_item(
-                identifier!(self, __file__),
-                self.ctx.new_str(path).into(),
-                self,
-            )?;
-            module_dict.set_item(identifier!(self, __cached__), self.ctx.none(), self)?;
-        }
-
-        // Consider to use enum to distinguish `path`
-        // https://github.com/RustPython/RustPython/pull/6276#discussion_r2529849479
-
-        let pyc = maybe_pyc_file(path);
-        if pyc {
-            // pyc file execution
-            set_main_loader(&module_dict, path, "SourcelessFileLoader", self)?;
-            let loader = module_dict.get_item("__loader__", self)?;
-            let get_code = loader.get_attr("get_code", self)?;
-            let code_obj = get_code.call((identifier!(self, __main__).to_owned(),), self)?;
-            let code = code_obj
-                .downcast::<PyCode>()
-                .map_err(|_| self.new_runtime_error("Bad code object in .pyc file".to_owned()))?;
-            self.run_code_obj(code, scope)?;
-        } else {
-            if path != "<stdin>" {
-                set_main_loader(&module_dict, path, "SourceFileLoader", self)?;
-            }
-            // TODO: replace to something equivalent to py_run_file
-            match std::fs::read_to_string(path) {
-                Ok(source) => {
-                    let code_obj = self
-                        .compile(&source, compiler::Mode::Exec, path.to_owned())
-                        .map_err(|err| self.new_syntax_error(&err, Some(&source)))?;
-                    // trace!("Code object: {:?}", code_obj.borrow());
-                    self.run_code_obj(code_obj, scope)?;
-                }
-                Err(err) => {
-                    error!("Failed reading file '{path}': {err}");
-                    // TODO: Need to change to ExitCode or Termination
-                    std::process::exit(1);
-                }
-            }
-        }
-        Ok(())
-    }
-
-    // TODO: deprecate or reimplement using other primitive functions
-    pub fn run_code_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
-        let code_obj = self
-            .compile(source, compiler::Mode::Exec, source_path.clone())
-            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
-        // trace!("Code object: {:?}", code_obj.borrow());
-        // Only set __file__ for real file paths, not pseudo-paths like <string>
-        if !(source_path.starts_with('<') && source_path.ends_with('>')) {
-            scope.globals.set_item(
-                identifier!(self, __file__),
-                self.new_pyobj(source_path),
-                self,
-            )?;
-        }
-        self.run_code_obj(code_obj, scope)
-    }
-
-    pub fn run_block_expr(&self, scope: Scope, source: &str) -> PyResult {
-        let code_obj = self
-            .compile(source, compiler::Mode::BlockExpr, "<embedded>".to_owned())
-            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
-        // trace!("Code object: {:?}", code_obj.borrow());
-        self.run_code_obj(code_obj, scope)
-    }
-}
-
-fn set_main_loader(
-    module_dict: &PyDictRef,
-    filename: &str,
-    loader_name: &str,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    vm.import("importlib.machinery", 0)?;
-    let sys_modules = vm.sys_module.get_attr(identifier!(vm, modules), vm)?;
-    let machinery = sys_modules.get_item("importlib.machinery", vm)?;
-    let loader_name = vm.ctx.new_str(loader_name);
-    let loader_class = machinery.get_attr(&loader_name, vm)?;
-    let loader = loader_class.call((identifier!(vm, __main__).to_owned(), filename), vm)?;
-    module_dict.set_item("__loader__", loader, vm)?;
-    Ok(())
-}
-
-/// Check whether a file is maybe a pyc file.
-///
-/// Detection is performed by:
-/// 1. Checking if the filename ends with ".pyc"
-/// 2. If not, reading the first 2 bytes and comparing with the magic number
-fn maybe_pyc_file(path: &str) -> bool {
-    // 1. Check if filename ends with ".pyc"
-    if path.ends_with(".pyc") {
-        return true;
-    }
-    maybe_pyc_file_with_magic(path, &crate::version::PYC_MAGIC_NUMBER_BYTES).unwrap_or(false)
-}
-
-fn maybe_pyc_file_with_magic(path: &str, magic_number: &[u8]) -> std::io::Result<bool> {
-    // part of maybe_pyc_file
-    // For non-.pyc extension, check magic number
-    let path_obj = std::path::Path::new(path);
-    if !path_obj.is_file() {
-        return Ok(false);
-    }
-
-    let mut file = std::fs::File::open(path)?;
-    let mut buf = [0u8; 2];
-
-    use std::io::Read;
-    if file.read(&mut buf)? != 2 || magic_number.len() < 2 {
-        return Ok(false);
-    }
-
-    // Read only two bytes of the magic. If the file was opened in
-    // text mode, the bytes 3 and 4 of the magic (\r\n) might not
-    // be read as they are on disk.
-    Ok(buf == magic_number[..2])
-}
-
-fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
-    let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
-    let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;
-    if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {
-        return Ok(Some(importer));
-    }
-    let path = vm.ctx.new_str(path);
-    let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;
-    let mut importer = None;
-    let path_hooks: Vec<PyObjectRef> = path_hooks.try_into_value(vm)?;
-    for path_hook in path_hooks {
-        match path_hook.call((path.clone(),), vm) {
-            Ok(imp) => {
-                importer = Some(imp);
-                break;
-            }
-            Err(e) if e.fast_isinstance(vm.ctx.exceptions.import_error) => continue,
-            Err(e) => return Err(e),
-        }
-    }
-    Ok(if let Some(imp) = importer {
-        let imp = path_importer_cache.get_or_insert(vm, path.into(), || imp.clone())?;
-        Some(imp)
-    } else {
-        None
-    })
 }
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 7b974389418..d3f18bf9f46 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -8,6 +8,8 @@ mod compile;
 mod context;
 mod interpreter;
 mod method;
+#[cfg(feature = "rustpython-compiler")]
+mod python_run;
 mod setting;
 pub mod thread;
 mod vm_new;
diff --git a/crates/vm/src/vm/python_run.rs b/crates/vm/src/vm/python_run.rs
new file mode 100644
index 00000000000..31e8c7be45e
--- /dev/null
+++ b/crates/vm/src/vm/python_run.rs
@@ -0,0 +1,186 @@
+//! Python code execution functions.
+
+use crate::{
+    PyResult, VirtualMachine,
+    builtins::{PyCode, PyDictRef},
+    compiler::{self},
+    scope::Scope,
+};
+
+impl VirtualMachine {
+    /// _PyRun_AnyFileObject (internal)
+    ///
+    /// Execute a Python file. Currently always delegates to run_simple_file
+    /// (interactive mode is handled separately in shell.rs).
+    ///
+    /// Note: This is an internal function. Use `run_file` for the public interface.
+    #[doc(hidden)]
+    pub fn run_any_file(&self, scope: Scope, path: &str) -> PyResult<()> {
+        let path = if path.is_empty() { "???" } else { path };
+        self.run_simple_file(scope, path)
+    }
+
+    /// _PyRun_SimpleFileObject
+    ///
+    /// Execute a Python file with __main__ module setup.
+    /// Sets __file__ and __cached__ before execution, removes them after.
+    fn run_simple_file(&self, scope: Scope, path: &str) -> PyResult<()> {
+        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
+        let main_module = sys_modules.get_item(identifier!(self, __main__), self)?;
+        let module_dict = main_module.dict().expect("main module must have __dict__");
+
+        // Track whether we set __file__ (for cleanup)
+        let set_file_name = !module_dict.contains_key(identifier!(self, __file__), self);
+        if set_file_name {
+            module_dict.set_item(
+                identifier!(self, __file__),
+                self.ctx.new_str(path).into(),
+                self,
+            )?;
+            module_dict.set_item(identifier!(self, __cached__), self.ctx.none(), self)?;
+        }
+
+        let result = self.run_simple_file_inner(&module_dict, scope, path);
+
+        self.flush_io();
+
+        // Cleanup __file__ and __cached__ after execution
+        if set_file_name {
+            let _ = module_dict.del_item(identifier!(self, __file__), self);
+            let _ = module_dict.del_item(identifier!(self, __cached__), self);
+        }
+
+        result
+    }
+
+    fn run_simple_file_inner(
+        &self,
+        module_dict: &PyDictRef,
+        scope: Scope,
+        path: &str,
+    ) -> PyResult<()> {
+        let pyc = maybe_pyc_file(path);
+        if pyc {
+            // pyc file execution
+            set_main_loader(module_dict, path, "SourcelessFileLoader", self)?;
+            let loader = module_dict.get_item("__loader__", self)?;
+            let get_code = loader.get_attr("get_code", self)?;
+            let code_obj = get_code.call((identifier!(self, __main__).to_owned(),), self)?;
+            let code = code_obj
+                .downcast::<PyCode>()
+                .map_err(|_| self.new_runtime_error("Bad code object in .pyc file".to_owned()))?;
+            self.run_code_obj(code, scope)?;
+        } else {
+            if path != "<stdin>" {
+                set_main_loader(module_dict, path, "SourceFileLoader", self)?;
+            }
+            match std::fs::read_to_string(path) {
+                Ok(source) => {
+                    let code_obj = self
+                        .compile(&source, compiler::Mode::Exec, path.to_owned())
+                        .map_err(|err| self.new_syntax_error(&err, Some(&source)))?;
+                    self.run_code_obj(code_obj, scope)?;
+                }
+                Err(err) => {
+                    return Err(self.new_os_error(err.to_string()));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// PyRun_SimpleString
+    ///
+    /// Execute a string of Python code in a new scope with builtins.
+    pub fn run_simple_string(&self, source: &str) -> PyResult {
+        let scope = self.new_scope_with_builtins();
+        self.run_string(scope, source, "<string>".to_owned())
+    }
+
+    /// PyRun_String
+    ///
+    /// Execute a string of Python code with explicit scope and source path.
+    pub fn run_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
+        let code_obj = self
+            .compile(source, compiler::Mode::Exec, source_path)
+            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
+        self.run_code_obj(code_obj, scope)
+    }
+
+    #[deprecated(note = "use run_string instead")]
+    pub fn run_code_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
+        self.run_string(scope, source, source_path)
+    }
+
+    // #[deprecated(note = "use rustpython::run_file instead; if this changes causes problems, please report an issue.")]
+    pub fn run_script(&self, scope: Scope, path: &str) -> PyResult<()> {
+        self.run_any_file(scope, path)
+    }
+
+    pub fn run_block_expr(&self, scope: Scope, source: &str) -> PyResult {
+        let code_obj = self
+            .compile(source, compiler::Mode::BlockExpr, "<embedded>".to_owned())
+            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
+        self.run_code_obj(code_obj, scope)
+    }
+
+    /// flush_io
+    ///
+    /// Flush stdout and stderr. Errors are silently ignored.
+    fn flush_io(&self) {
+        if let Ok(stdout) = self.sys_module.get_attr("stdout", self) {
+            let _ = self.call_method(&stdout, identifier!(self, flush).as_str(), ());
+        }
+        if let Ok(stderr) = self.sys_module.get_attr("stderr", self) {
+            let _ = self.call_method(&stderr, identifier!(self, flush).as_str(), ());
+        }
+    }
+}
+
+fn set_main_loader(
+    module_dict: &PyDictRef,
+    filename: &str,
+    loader_name: &str,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    vm.import("importlib.machinery", 0)?;
+    let sys_modules = vm.sys_module.get_attr(identifier!(vm, modules), vm)?;
+    let machinery = sys_modules.get_item("importlib.machinery", vm)?;
+    let loader_name = vm.ctx.new_str(loader_name);
+    let loader_class = machinery.get_attr(&loader_name, vm)?;
+    let loader = loader_class.call((identifier!(vm, __main__).to_owned(), filename), vm)?;
+    module_dict.set_item("__loader__", loader, vm)?;
+    Ok(())
+}
+
+/// Check whether a file is maybe a pyc file.
+///
+/// Detection is performed by:
+/// 1. Checking if the filename ends with ".pyc"
+/// 2. If not, reading the first 2 bytes and comparing with the magic number
+fn maybe_pyc_file(path: &str) -> bool {
+    if path.ends_with(".pyc") {
+        return true;
+    }
+    maybe_pyc_file_with_magic(path, &crate::version::PYC_MAGIC_NUMBER_BYTES).unwrap_or(false)
+}
+
+fn maybe_pyc_file_with_magic(path: &str, magic_number: &[u8]) -> std::io::Result<bool> {
+    let path_obj = std::path::Path::new(path);
+    if !path_obj.is_file() {
+        return Ok(false);
+    }
+
+    let mut file = std::fs::File::open(path)?;
+    let mut buf = [0u8; 2];
+
+    use std::io::Read;
+    if file.read(&mut buf)? != 2 || magic_number.len() < 2 {
+        return Ok(false);
+    }
+
+    // Read only two bytes of the magic. If the file was opened in
+    // text mode, the bytes 3 and 4 of the magic (\r\n) might not
+    // be read as they are on disk.
+    Ok(buf == magic_number[..2])
+}
diff --git a/src/lib.rs b/src/lib.rs
index 9dff074e20d..ad5894860d2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -49,7 +49,7 @@ mod interpreter;
 mod settings;
 mod shell;
 
-use rustpython_vm::{PyResult, VirtualMachine, scope::Scope};
+use rustpython_vm::{AsObject, PyObjectRef, PyResult, VirtualMachine, scope::Scope};
 use std::env;
 use std::io::IsTerminal;
 use std::process::ExitCode;
@@ -144,7 +144,7 @@ __import__("io").TextIOWrapper(
         .downcast()
         .expect("TextIOWrapper.read() should return str");
     eprintln!("running get-pip.py...");
-    vm.run_code_string(scope, getpip_code.as_str(), "get-pip.py".to_owned())?;
+    vm.run_string(scope, getpip_code.as_str(), "get-pip.py".to_owned())?;
     Ok(())
 }
 
@@ -162,6 +162,60 @@ fn install_pip(installer: InstallPipMode, scope: Scope, vm: &VirtualMachine) ->
     }
 }
 
+// pymain_run_file_obj in Modules/main.c
+fn run_file(vm: &VirtualMachine, scope: Scope, path: &str) -> PyResult<()> {
+    // Check if path is a package/directory with __main__.py
+    if let Some(_importer) = get_importer(path, vm)? {
+        vm.insert_sys_path(vm.new_pyobj(path))?;
+        let runpy = vm.import("runpy", 0)?;
+        let run_module_as_main = runpy.get_attr("_run_module_as_main", vm)?;
+        run_module_as_main.call((vm::identifier!(vm, __main__).to_owned(), false), vm)?;
+        return Ok(());
+    }
+
+    // Add script directory to sys.path[0]
+    if !vm.state.config.settings.safe_path {
+        let dir = std::path::Path::new(path)
+            .parent()
+            .and_then(|p| p.to_str())
+            .unwrap_or("");
+        vm.insert_sys_path(vm.new_pyobj(dir))?;
+    }
+
+    vm.run_any_file(scope, path)
+}
+
+fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
+    use rustpython_vm::builtins::PyDictRef;
+    use rustpython_vm::convert::TryFromObject;
+
+    let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
+    let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;
+    if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {
+        return Ok(Some(importer));
+    }
+    let path_obj = vm.ctx.new_str(path);
+    let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;
+    let mut importer = None;
+    let path_hooks: Vec<PyObjectRef> = path_hooks.try_into_value(vm)?;
+    for path_hook in path_hooks {
+        match path_hook.call((path_obj.clone(),), vm) {
+            Ok(imp) => {
+                importer = Some(imp);
+                break;
+            }
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.import_error) => continue,
+            Err(e) => return Err(e),
+        }
+    }
+    Ok(if let Some(imp) = importer {
+        let imp = path_importer_cache.get_or_insert(vm, path_obj.into(), || imp.clone())?;
+        Some(imp)
+    } else {
+        None
+    })
+}
+
 // pymain_run_python
 fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     #[cfg(feature = "flame-it")]
@@ -199,11 +253,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     // Enable faulthandler if -X faulthandler, PYTHONFAULTHANDLER or -X dev is set
     // _PyFaulthandler_Init()
     if vm.state.config.settings.faulthandler {
-        let _ = vm.run_code_string(
-            vm.new_scope_with_builtins(),
-            "import faulthandler; faulthandler.enable()",
-            "<faulthandler>".to_owned(),
-        );
+        let _ = vm.run_simple_string("import faulthandler; faulthandler.enable()");
     }
 
     let is_repl = matches!(run_mode, RunMode::Repl);
@@ -226,7 +276,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     let res = match run_mode {
         RunMode::Command(command) => {
             debug!("Running command {command}");
-            vm.run_code_string(scope.clone(), &command, "<string>".to_owned())
+            vm.run_string(scope.clone(), &command, "<string>".to_owned())
                 .map(drop)
         }
         RunMode::Module(module) => {
@@ -235,9 +285,9 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         }
         RunMode::InstallPip(installer) => install_pip(installer, scope.clone(), vm),
         RunMode::Script(script_path) => {
-            // pymain_run_file
+            // pymain_run_file_obj
             debug!("Running script {}", &script_path);
-            vm.run_script(scope.clone(), &script_path)
+            run_file(vm, scope.clone(), &script_path)
         }
         RunMode::Repl => Ok(()),
     };
@@ -318,11 +368,11 @@ mod tests {
             vm.unwrap_pyresult((|| {
                 let scope = setup_main_module(vm)?;
                 // test file run
-                vm.run_script(scope, "extra_tests/snippets/dir_main/__main__.py")?;
+                vm.run_any_file(scope, "extra_tests/snippets/dir_main/__main__.py")?;
 
                 let scope = setup_main_module(vm)?;
-                // test module run
-                vm.run_script(scope, "extra_tests/snippets/dir_main")?;
+                // test module run (directory with __main__.py)
+                run_file(vm, scope, "extra_tests/snippets/dir_main")?;
 
                 Ok(())
             })());

From b47337780be32621aa1922aa9f05fd96b9896e9f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 21:10:28 +0900
Subject: [PATCH 169/418] remove ssl from debugger configs (#6644)

---
 .vscode/launch.json | 12 ------------
 .vscode/tasks.json  | 16 ----------------
 2 files changed, 28 deletions(-)

diff --git a/.vscode/launch.json b/.vscode/launch.json
index fa6f96c5fd8..6e00e14aff2 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -16,18 +16,6 @@
             },
             "cwd": "${workspaceFolder}"
         },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'rustpython' without SSL",
-            "preLaunchTask": "Build RustPython Debug without SSL",
-            "program": "target/debug/rustpython",
-            "args": [],
-            "env": {
-                "RUST_BACKTRACE": "1"
-            },
-            "cwd": "${workspaceFolder}"
-        },
         {
             "type": "lldb",
             "request": "launch",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 18a3d6010d1..50a52aaf8be 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,28 +1,12 @@
 {
     "version": "2.0.0",
     "tasks": [
-        {
-            "label": "Build RustPython Debug without SSL",
-            "type": "shell",
-            "command": "cargo",
-            "args": [
-                "build",
-            ],
-            "problemMatcher": [
-                "$rustc",
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true,
-            },
-        },
         {
             "label": "Build RustPython Debug",
             "type": "shell",
             "command": "cargo",
             "args": [
                 "build",
-                "--features=ssl"
             ],
             "problemMatcher": [
                 "$rustc",

From ec564ac1902b0414f233ae60fe7c087748118e20 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sun, 4 Jan 2026 07:15:42 -0500
Subject: [PATCH 170/418] Updated tempfile libraries + associated tests -
 V3.13.11 (#6632)

* Updated subprocess library test

* Updated tempfile library + test

* Skipped the test_cleanup_with_symlink_modes test
---
 Lib/tempfile.py             | 294 +++++++++++++++-------
 Lib/test/test_subprocess.py |  24 +-
 Lib/test/test_tempfile.py   | 483 ++++++++++++++++++++++++++++++++----
 3 files changed, 636 insertions(+), 165 deletions(-)

diff --git a/Lib/tempfile.py b/Lib/tempfile.py
index 3aceb3f70fd..8036e93cd6d 100644
--- a/Lib/tempfile.py
+++ b/Lib/tempfile.py
@@ -46,7 +46,6 @@
 import sys as _sys
 import types as _types
 import weakref as _weakref
-
 import _thread
 _allocate_lock = _thread.allocate_lock
 
@@ -181,7 +180,7 @@ def _candidate_tempdir_list():
 
     return dirlist
 
-def _get_default_tempdir():
+def _get_default_tempdir(dirlist=None):
     """Calculate the default directory to use for temporary files.
     This routine should be called exactly once.
 
@@ -191,7 +190,8 @@ def _get_default_tempdir():
     service, the name of the test file must be randomized."""
 
     namer = _RandomNameSequence()
-    dirlist = _candidate_tempdir_list()
+    if dirlist is None:
+        dirlist = _candidate_tempdir_list()
 
     for dir in dirlist:
         if dir != _os.curdir:
@@ -204,8 +204,7 @@ def _get_default_tempdir():
                 fd = _os.open(filename, _bin_openflags, 0o600)
                 try:
                     try:
-                        with _io.open(fd, 'wb', closefd=False) as fp:
-                            fp.write(b'blat')
+                        _os.write(fd, b'blat')
                     finally:
                         _os.close(fd)
                 finally:
@@ -245,6 +244,7 @@ def _get_candidate_names():
 def _mkstemp_inner(dir, pre, suf, flags, output_type):
     """Code common to mkstemp, TemporaryFile, and NamedTemporaryFile."""
 
+    dir = _os.path.abspath(dir)
     names = _get_candidate_names()
     if output_type is bytes:
         names = map(_os.fsencode, names)
@@ -265,11 +265,27 @@ def _mkstemp_inner(dir, pre, suf, flags, output_type):
                 continue
             else:
                 raise
-        return (fd, _os.path.abspath(file))
+        return fd, file
 
     raise FileExistsError(_errno.EEXIST,
                           "No usable temporary file name found")
 
+def _dont_follow_symlinks(func, path, *args):
+    # Pass follow_symlinks=False, unless not supported on this platform.
+    if func in _os.supports_follow_symlinks:
+        func(path, *args, follow_symlinks=False)
+    elif not _os.path.islink(path):
+        func(path, *args)
+
+def _resetperms(path):
+    try:
+        chflags = _os.chflags
+    except AttributeError:
+        pass
+    else:
+        _dont_follow_symlinks(chflags, path, 0)
+    _dont_follow_symlinks(_os.chmod, path, 0o700)
+
 
 # User visible interfaces.
 
@@ -377,7 +393,7 @@ def mkdtemp(suffix=None, prefix=None, dir=None):
                 continue
             else:
                 raise
-        return file
+        return _os.path.abspath(file)
 
     raise FileExistsError(_errno.EEXIST,
                           "No usable temporary directory name found")
@@ -419,42 +435,42 @@ class _TemporaryFileCloser:
     underlying file object, without adding a __del__ method to the
     temporary file."""
 
-    file = None  # Set here since __del__ checks it
+    cleanup_called = False
     close_called = False
 
-    def __init__(self, file, name, delete=True):
+    def __init__(self, file, name, delete=True, delete_on_close=True):
         self.file = file
         self.name = name
         self.delete = delete
+        self.delete_on_close = delete_on_close
 
-    # NT provides delete-on-close as a primitive, so we don't need
-    # the wrapper to do anything special.  We still use it so that
-    # file.name is useful (i.e. not "(fdopen)") with NamedTemporaryFile.
-    if _os.name != 'nt':
-        # Cache the unlinker so we don't get spurious errors at
-        # shutdown when the module-level "os" is None'd out.  Note
-        # that this must be referenced as self.unlink, because the
-        # name TemporaryFileWrapper may also get None'd out before
-        # __del__ is called.
-
-        def close(self, unlink=_os.unlink):
-            if not self.close_called and self.file is not None:
-                self.close_called = True
-                try:
+    def cleanup(self, windows=(_os.name == 'nt'), unlink=_os.unlink):
+        if not self.cleanup_called:
+            self.cleanup_called = True
+            try:
+                if not self.close_called:
+                    self.close_called = True
                     self.file.close()
-                finally:
-                    if self.delete:
+            finally:
+                # Windows provides delete-on-close as a primitive, in which
+                # case the file was deleted by self.file.close().
+                if self.delete and not (windows and self.delete_on_close):
+                    try:
                         unlink(self.name)
+                    except FileNotFoundError:
+                        pass
 
-        # Need to ensure the file is deleted on __del__
-        def __del__(self):
-            self.close()
-
-    else:
-        def close(self):
-            if not self.close_called:
-                self.close_called = True
+    def close(self):
+        if not self.close_called:
+            self.close_called = True
+            try:
                 self.file.close()
+            finally:
+                if self.delete and self.delete_on_close:
+                    self.cleanup()
+
+    def __del__(self):
+        self.cleanup()
 
 
 class _TemporaryFileWrapper:
@@ -465,11 +481,11 @@ class _TemporaryFileWrapper:
     remove the file when it is no longer needed.
     """
 
-    def __init__(self, file, name, delete=True):
+    def __init__(self, file, name, delete=True, delete_on_close=True):
         self.file = file
         self.name = name
-        self.delete = delete
-        self._closer = _TemporaryFileCloser(file, name, delete)
+        self._closer = _TemporaryFileCloser(file, name, delete,
+                                            delete_on_close)
 
     def __getattr__(self, name):
         # Attribute lookups are delegated to the underlying file
@@ -500,7 +516,7 @@ def __enter__(self):
     # deleted when used in a with statement
     def __exit__(self, exc, value, tb):
         result = self.file.__exit__(exc, value, tb)
-        self.close()
+        self._closer.cleanup()
         return result
 
     def close(self):
@@ -519,10 +535,10 @@ def __iter__(self):
         for line in self.file:
             yield line
 
-
 def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
                        newline=None, suffix=None, prefix=None,
-                       dir=None, delete=True, *, errors=None):
+                       dir=None, delete=True, *, errors=None,
+                       delete_on_close=True):
     """Create and return a temporary file.
     Arguments:
     'prefix', 'suffix', 'dir' -- as for mkstemp.
@@ -530,13 +546,20 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
     'buffering' -- the buffer size argument to io.open (default -1).
     'encoding' -- the encoding argument to io.open (default None)
     'newline' -- the newline argument to io.open (default None)
-    'delete' -- whether the file is deleted on close (default True).
+    'delete' -- whether the file is automatically deleted (default True).
+    'delete_on_close' -- if 'delete', whether the file is deleted on close
+       (default True) or otherwise either on context manager exit
+       (if context manager was used) or on object finalization. .
     'errors' -- the errors argument to io.open (default None)
     The file is created as mkstemp() would do it.
 
     Returns an object with a file-like interface; the name of the file
     is accessible as its 'name' attribute.  The file will be automatically
     deleted when it is closed unless the 'delete' argument is set to False.
+
+    On POSIX, NamedTemporaryFiles cannot be automatically deleted if
+    the creating process is terminated abruptly with a SIGKILL signal.
+    Windows can delete the file even in this case.
     """
 
     prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir)
@@ -545,21 +568,33 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
 
     # Setting O_TEMPORARY in the flags causes the OS to delete
     # the file when it is closed.  This is only supported by Windows.
-    if _os.name == 'nt' and delete:
+    if _os.name == 'nt' and delete and delete_on_close:
         flags |= _os.O_TEMPORARY
 
     if "b" not in mode:
         encoding = _io.text_encoding(encoding)
 
-    (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+    name = None
+    def opener(*args):
+        nonlocal name
+        fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+        return fd
     try:
-        file = _io.open(fd, mode, buffering=buffering,
-                        newline=newline, encoding=encoding, errors=errors)
-
-        return _TemporaryFileWrapper(file, name, delete)
-    except BaseException:
-        _os.unlink(name)
-        _os.close(fd)
+        file = _io.open(dir, mode, buffering=buffering,
+                        newline=newline, encoding=encoding, errors=errors,
+                        opener=opener)
+        try:
+            raw = getattr(file, 'buffer', file)
+            raw = getattr(raw, 'raw', raw)
+            raw.name = name
+            return _TemporaryFileWrapper(file, name, delete, delete_on_close)
+        except:
+            file.close()
+            raise
+    except:
+        if name is not None and not (
+            _os.name == 'nt' and delete and delete_on_close):
+            _os.unlink(name)
         raise
 
 if _os.name != 'posix' or _sys.platform == 'cygwin':
@@ -598,9 +633,20 @@ def TemporaryFile(mode='w+b', buffering=-1, encoding=None,
 
         flags = _bin_openflags
         if _O_TMPFILE_WORKS:
-            try:
+            fd = None
+            def opener(*args):
+                nonlocal fd
                 flags2 = (flags | _os.O_TMPFILE) & ~_os.O_CREAT
                 fd = _os.open(dir, flags2, 0o600)
+                return fd
+            try:
+                file = _io.open(dir, mode, buffering=buffering,
+                                newline=newline, encoding=encoding,
+                                errors=errors, opener=opener)
+                raw = getattr(file, 'buffer', file)
+                raw = getattr(raw, 'raw', raw)
+                raw.name = fd
+                return file
             except IsADirectoryError:
                 # Linux kernel older than 3.11 ignores the O_TMPFILE flag:
                 # O_TMPFILE is read as O_DIRECTORY. Trying to open a directory
@@ -617,26 +663,27 @@ def TemporaryFile(mode='w+b', buffering=-1, encoding=None,
                 # fails with NotADirectoryError, because O_TMPFILE is read as
                 # O_DIRECTORY.
                 pass
-            else:
-                try:
-                    return _io.open(fd, mode, buffering=buffering,
-                                    newline=newline, encoding=encoding,
-                                    errors=errors)
-                except:
-                    _os.close(fd)
-                    raise
             # Fallback to _mkstemp_inner().
 
-        (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
-        try:
-            _os.unlink(name)
-            return _io.open(fd, mode, buffering=buffering,
-                            newline=newline, encoding=encoding, errors=errors)
-        except:
-            _os.close(fd)
-            raise
+        fd = None
+        def opener(*args):
+            nonlocal fd
+            fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+            try:
+                _os.unlink(name)
+            except BaseException as e:
+                _os.close(fd)
+                raise
+            return fd
+        file = _io.open(dir, mode, buffering=buffering,
+                        newline=newline, encoding=encoding, errors=errors,
+                        opener=opener)
+        raw = getattr(file, 'buffer', file)
+        raw = getattr(raw, 'raw', raw)
+        raw.name = fd
+        return file
 
-class SpooledTemporaryFile:
+class SpooledTemporaryFile(_io.IOBase):
     """Temporary file wrapper, specialized to switch from BytesIO
     or StringIO to a real file when it exceeds a certain size or
     when a fileno is needed.
@@ -701,6 +748,16 @@ def __exit__(self, exc, value, tb):
     def __iter__(self):
         return self._file.__iter__()
 
+    def __del__(self):
+        if not self.closed:
+            _warnings.warn(
+                "Unclosed file {!r}".format(self),
+                ResourceWarning,
+                stacklevel=2,
+                source=self
+            )
+            self.close()
+
     def close(self):
         self._file.close()
 
@@ -744,15 +801,30 @@ def name(self):
     def newlines(self):
         return self._file.newlines
 
+    def readable(self):
+        return self._file.readable()
+
     def read(self, *args):
         return self._file.read(*args)
 
+    def read1(self, *args):
+        return self._file.read1(*args)
+
+    def readinto(self, b):
+        return self._file.readinto(b)
+
+    def readinto1(self, b):
+        return self._file.readinto1(b)
+
     def readline(self, *args):
         return self._file.readline(*args)
 
     def readlines(self, *args):
         return self._file.readlines(*args)
 
+    def seekable(self):
+        return self._file.seekable()
+
     def seek(self, *args):
         return self._file.seek(*args)
 
@@ -761,11 +833,14 @@ def tell(self):
 
     def truncate(self, size=None):
         if size is None:
-            self._file.truncate()
+            return self._file.truncate()
         else:
             if size > self._max_size:
                 self.rollover()
-            self._file.truncate(size)
+            return self._file.truncate(size)
+
+    def writable(self):
+        return self._file.writable()
 
     def write(self, s):
         file = self._file
@@ -774,10 +849,17 @@ def write(self, s):
         return rv
 
     def writelines(self, iterable):
-        file = self._file
-        rv = file.writelines(iterable)
-        self._check(file)
-        return rv
+        if self._max_size == 0 or self._rolled:
+            return self._file.writelines(iterable)
+
+        it = iter(iterable)
+        for line in it:
+            self.write(line)
+            if self._rolled:
+                return self._file.writelines(it)
+
+    def detach(self):
+        return self._file.detach()
 
 
 class TemporaryDirectory:
@@ -789,53 +871,74 @@ class TemporaryDirectory:
             ...
 
     Upon exiting the context, the directory and everything contained
-    in it are removed.
+    in it are removed (unless delete=False is passed or an exception
+    is raised during cleanup and ignore_cleanup_errors is not True).
+
+    Optional Arguments:
+        suffix - A str suffix for the directory name.  (see mkdtemp)
+        prefix - A str prefix for the directory name.  (see mkdtemp)
+        dir - A directory to create this temp dir in.  (see mkdtemp)
+        ignore_cleanup_errors - False; ignore exceptions during cleanup?
+        delete - True; whether the directory is automatically deleted.
     """
 
     def __init__(self, suffix=None, prefix=None, dir=None,
-                 ignore_cleanup_errors=False):
+                 ignore_cleanup_errors=False, *, delete=True):
         self.name = mkdtemp(suffix, prefix, dir)
         self._ignore_cleanup_errors = ignore_cleanup_errors
+        self._delete = delete
         self._finalizer = _weakref.finalize(
             self, self._cleanup, self.name,
             warn_message="Implicitly cleaning up {!r}".format(self),
-            ignore_errors=self._ignore_cleanup_errors)
+            ignore_errors=self._ignore_cleanup_errors, delete=self._delete)
 
     @classmethod
-    def _rmtree(cls, name, ignore_errors=False):
-        def onerror(func, path, exc_info):
-            if issubclass(exc_info[0], PermissionError):
-                def resetperms(path):
-                    try:
-                        _os.chflags(path, 0)
-                    except AttributeError:
-                        pass
-                    _os.chmod(path, 0o700)
+    def _rmtree(cls, name, ignore_errors=False, repeated=False):
+        def onexc(func, path, exc):
+            if isinstance(exc, PermissionError):
+                if repeated and path == name:
+                    if ignore_errors:
+                        return
+                    raise
 
                 try:
                     if path != name:
-                        resetperms(_os.path.dirname(path))
-                    resetperms(path)
+                        _resetperms(_os.path.dirname(path))
+                    _resetperms(path)
 
                     try:
                         _os.unlink(path)
-                    # PermissionError is raised on FreeBSD for directories
-                    except (IsADirectoryError, PermissionError):
+                    except IsADirectoryError:
                         cls._rmtree(path, ignore_errors=ignore_errors)
+                    except PermissionError:
+                        # The PermissionError handler was originally added for
+                        # FreeBSD in directories, but it seems that it is raised
+                        # on Windows too.
+                        # bpo-43153: Calling _rmtree again may
+                        # raise NotADirectoryError and mask the PermissionError.
+                        # So we must re-raise the current PermissionError if
+                        # path is not a directory.
+                        if not _os.path.isdir(path) or _os.path.isjunction(path):
+                            if ignore_errors:
+                                return
+                            raise
+                        cls._rmtree(path, ignore_errors=ignore_errors,
+                                    repeated=(path == name))
                 except FileNotFoundError:
                     pass
-            elif issubclass(exc_info[0], FileNotFoundError):
+            elif isinstance(exc, FileNotFoundError):
                 pass
             else:
                 if not ignore_errors:
                     raise
 
-        _shutil.rmtree(name, onerror=onerror)
+        _shutil.rmtree(name, onexc=onexc)
 
     @classmethod
-    def _cleanup(cls, name, warn_message, ignore_errors=False):
-        cls._rmtree(name, ignore_errors=ignore_errors)
-        _warnings.warn(warn_message, ResourceWarning)
+    def _cleanup(cls, name, warn_message, ignore_errors=False, delete=True):
+        if delete:
+            cls._rmtree(name, ignore_errors=ignore_errors)
+            _warnings.warn(warn_message, ResourceWarning)
 
     def __repr__(self):
         return "<{} {!r}>".format(self.__class__.__name__, self.name)
@@ -844,7 +947,8 @@ def __enter__(self):
         return self.name
 
     def __exit__(self, exc, value, tb):
-        self.cleanup()
+        if self._delete:
+            self.cleanup()
 
     def cleanup(self):
         if self._finalizer.detach() or _os.path.exists(self.name):
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 997c98c2c62..4d058652723 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -800,8 +800,7 @@ def test_env(self):
             stdout, stderr = p.communicate()
             self.assertEqual(stdout, b"orange")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.platform == "win32", "Windows only issue")
     def test_win32_duplicate_envs(self):
         newenv = os.environ.copy()
@@ -1292,8 +1291,7 @@ def test_universal_newlines_communicate_stdin_stdout_stderr(self):
         # to stderr at exit of subprocess.
         self.assertTrue(stderr.startswith("eline2\neline6\neline7\n"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_universal_newlines_communicate_encodings(self):
         # Check that universal newlines mode works for various encodings,
         # in particular for encodings in the UTF-16 and UTF-32 families.
@@ -2276,16 +2274,14 @@ def test_group_error(self):
         with self.assertRaises(ValueError):
             subprocess.check_call(ZERO_RETURN_CMD, group=65535)
 
-    # TODO: RUSTPYTHON, observed gids do not match expected gids
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; observed gids do not match expected gids
     @unittest.skipUnless(hasattr(os, 'setgroups'), 'no setgroups() on platform')
     def test_extra_groups(self):
         gid = os.getegid()
         group_list = [65534 if gid != 65534 else 65533]
         self._test_extra_groups_impl(gid=gid, group_list=group_list)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(hasattr(os, 'setgroups'), 'no setgroups() on platform')
     def test_extra_groups_empty_list(self):
         self._test_extra_groups_impl(gid=os.getegid(), group_list=[])
@@ -2321,8 +2317,8 @@ def _test_extra_groups_impl(self, *, gid, group_list):
                 subprocess.check_call(ZERO_RETURN_CMD,
                                       extra_groups=[name_group])
 
-    @unittest.skip("TODO: RUSTPYTHON; clarify failure condition")
     # No skip necessary, this test won't make it to a setgroup() call.
+    @unittest.skip('TODO: RUSTPYTHON; clarify failure condition')
     def test_extra_groups_invalid_gid_t_values(self):
         with self.assertRaises(ValueError):
             subprocess.check_call(ZERO_RETURN_CMD, extra_groups=[-1])
@@ -2449,8 +2445,7 @@ def raise_it():
                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE, preexec_fn=raise_it)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_preexec_gc_module_failure(self):
         # This tests the code that disables garbage collection if the child
         # process will execute any Python.
@@ -3021,7 +3016,7 @@ def kill_p2():
         p1.stdout.close()
         p2.stdout.close()
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_close_fds(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
 
@@ -3149,11 +3144,11 @@ def test_close_fds_when_max_fd_is_lowered(self):
                          msg="Some fds were left open.")
 
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
     # Mac OS X Tiger (10.4) has a kernel bug: sometimes, the file
     # descriptor of a pipe closed in the parent process is valid in the
     # child process according to fstat(), but the mode of the file
     # descriptor is invalid, and read or write raise an error.
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @support.requires_mac_ver(10, 5)
     def test_pass_fds(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
@@ -3566,8 +3561,7 @@ def test_communicate_repeated_call_after_stdout_close(self):
             except subprocess.TimeoutExpired:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_preexec_at_exit(self):
         code = f"""if 1:
         import atexit
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 5674839cd43..d389529ca3b 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,9 @@
 import stat
 import types
 import weakref
+import gc
+import shutil
+import subprocess
 from unittest import mock
 
 import unittest
@@ -60,16 +63,10 @@ def test_infer_return_type_multiples_and_none(self):
             tempfile._infer_return_type(b'', None, '')
 
     def test_infer_return_type_pathlib(self):
-        self.assertIs(str, tempfile._infer_return_type(pathlib.Path('/')))
+        self.assertIs(str, tempfile._infer_return_type(os_helper.FakePath('/')))
 
     def test_infer_return_type_pathlike(self):
-        class Path:
-            def __init__(self, path):
-                self.path = path
-
-            def __fspath__(self):
-                return self.path
-
+        Path = os_helper.FakePath
         self.assertIs(str, tempfile._infer_return_type(Path('/')))
         self.assertIs(bytes, tempfile._infer_return_type(Path(b'/')))
         self.assertIs(str, tempfile._infer_return_type('', Path('')))
@@ -90,14 +87,10 @@ class BaseTestCase(unittest.TestCase):
     b_check = re.compile(br"^[a-z0-9_-]{8}$")
 
     def setUp(self):
-        self._warnings_manager = warnings_helper.check_warnings()
-        self._warnings_manager.__enter__()
+        self.enterContext(warnings_helper.check_warnings())
         warnings.filterwarnings("ignore", category=RuntimeWarning,
                                 message="mktemp", module=__name__)
 
-    def tearDown(self):
-        self._warnings_manager.__exit__(None, None, None)
-
     def nameCheck(self, name, dir, pre, suf):
         (ndir, nbase) = os.path.split(name)
         npre  = nbase[:len(pre)]
@@ -198,8 +191,7 @@ def supports_iter(self):
             if i == 20:
                 break
 
-    @unittest.skipUnless(hasattr(os, 'fork'),
-        "os.fork is required for this test")
+    @support.requires_fork()
     def test_process_awareness(self):
         # ensure that the random source differs between
         # child and parent.
@@ -290,19 +282,14 @@ def our_candidate_list():
                 def raise_OSError(*args, **kwargs):
                     raise OSError()
 
-                with support.swap_attr(io, "open", raise_OSError):
-                    # test again with failing io.open()
+                with support.swap_attr(os, "open", raise_OSError):
+                    # test again with failing os.open()
                     with self.assertRaises(FileNotFoundError):
                         tempfile._get_default_tempdir()
                     self.assertEqual(os.listdir(our_temp_directory), [])
 
-                def bad_writer(*args, **kwargs):
-                    fp = orig_open(*args, **kwargs)
-                    fp.write = raise_OSError
-                    return fp
-
-                with support.swap_attr(io, "open", bad_writer) as orig_open:
-                    # test again with failing write()
+                with support.swap_attr(os, "write", raise_OSError):
+                    # test again with failing os.write()
                     with self.assertRaises(FileNotFoundError):
                         tempfile._get_default_tempdir()
                     self.assertEqual(os.listdir(our_temp_directory), [])
@@ -342,6 +329,9 @@ def _mock_candidate_names(*names):
 
 class TestBadTempdir:
 
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot remove write bits."
+    )
     def test_read_only_directory(self):
         with _inside_empty_temp_dir():
             oldmode = mode = os.stat(tempfile.tempdir).st_mode
@@ -447,11 +437,12 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             self.do_create(dir=dir).write(b"blat")
-            self.do_create(dir=pathlib.Path(dir)).write(b"blat")
+            self.do_create(dir=os_helper.FakePath(dir)).write(b"blat")
         finally:
             support.gc_collect()  # For PyPy or other GCs.
             os.rmdir(dir)
 
+    @os_helper.skip_unless_working_chmod
     def test_file_mode(self):
         # _mkstemp_inner creates files with the proper mode
 
@@ -465,8 +456,8 @@ def test_file_mode(self):
             expected = user * (1 + 8 + 64)
         self.assertEqual(mode, expected)
 
-    @support.requires_fork()
     @unittest.skipUnless(has_spawnl, 'os.spawnl not available')
+    @support.requires_subprocess()
     def test_noinherit(self):
         # _mkstemp_inner file handles are not inherited by child processes
 
@@ -684,7 +675,7 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             self.do_create(dir=dir)
-            self.do_create(dir=pathlib.Path(dir))
+            self.do_create(dir=os_helper.FakePath(dir))
         finally:
             os.rmdir(dir)
 
@@ -785,10 +776,11 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             os.rmdir(self.do_create(dir=dir))
-            os.rmdir(self.do_create(dir=pathlib.Path(dir)))
+            os.rmdir(self.do_create(dir=os_helper.FakePath(dir)))
         finally:
             os.rmdir(dir)
 
+    @os_helper.skip_unless_working_chmod
     def test_mode(self):
         # mkdtemp creates directories with the proper mode
 
@@ -806,6 +798,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
@@ -853,6 +872,15 @@ def test_for_tempdir_is_bytes_issue40701_api_warts(self):
         finally:
             tempfile.tempdir = orig_tempdir
 
+    def test_path_is_absolute(self):
+        # Test that the path returned by mkdtemp with a relative `dir`
+        # argument is absolute
+        try:
+            path = tempfile.mkdtemp(dir=".")
+            self.assertTrue(os.path.isabs(path))
+        finally:
+            os.rmdir(path)
+
 
 class TestMktemp(BaseTestCase):
     """Test mktemp()."""
@@ -978,6 +1006,7 @@ def test_del_on_close(self):
         try:
             with tempfile.NamedTemporaryFile(dir=dir) as f:
                 f.write(b'blat')
+            self.assertEqual(os.listdir(dir), [])
             self.assertFalse(os.path.exists(f.name),
                         "NamedTemporaryFile %s exists after close" % f.name)
         finally:
@@ -1017,18 +1046,101 @@ def use_closed():
                 pass
         self.assertRaises(ValueError, use_closed)
 
-    def test_no_leak_fd(self):
-        # Issue #21058: don't leak file descriptor when io.open() fails
-        closed = []
-        os_close = os.close
-        def close(fd):
-            closed.append(fd)
-            os_close(fd)
+    def test_context_man_not_del_on_close_if_delete_on_close_false(self):
+        # Issue gh-58451: tempfile.NamedTemporaryFile is not particularly useful
+        # on Windows
+        # A NamedTemporaryFile is NOT deleted when closed if
+        # delete_on_close=False, but is deleted on context manager exit
+        dir = tempfile.mkdtemp()
+        try:
+            with tempfile.NamedTemporaryFile(dir=dir,
+                                             delete=True,
+                                             delete_on_close=False) as f:
+                f.write(b'blat')
+                f_name = f.name
+                f.close()
+                with self.subTest():
+                    # Testing that file is not deleted on close
+                    self.assertTrue(os.path.exists(f.name),
+                            f"NamedTemporaryFile {f.name!r} is incorrectly "
+                            f"deleted on closure when delete_on_close=False")
+
+            with self.subTest():
+                # Testing that file is deleted on context manager exit
+                self.assertFalse(os.path.exists(f.name),
+                                 f"NamedTemporaryFile {f.name!r} exists "
+                                 f"after context manager exit")
+
+        finally:
+            os.rmdir(dir)
+
+    def test_context_man_ok_to_delete_manually(self):
+        # In the case of delete=True, a NamedTemporaryFile can be manually
+        # deleted in a with-statement context without causing an error.
+        dir = tempfile.mkdtemp()
+        try:
+            with tempfile.NamedTemporaryFile(dir=dir,
+                                             delete=True,
+                                             delete_on_close=False) as f:
+                f.write(b'blat')
+                f.close()
+                os.unlink(f.name)
+
+        finally:
+            os.rmdir(dir)
+
+    def test_context_man_not_del_if_delete_false(self):
+        # A NamedTemporaryFile is not deleted if delete = False
+        dir = tempfile.mkdtemp()
+        f_name = ""
+        try:
+            # Test that delete_on_close=True has no effect if delete=False.
+            with tempfile.NamedTemporaryFile(dir=dir, delete=False,
+                                             delete_on_close=True) as f:
+                f.write(b'blat')
+                f_name = f.name
+            self.assertTrue(os.path.exists(f.name),
+                        f"NamedTemporaryFile {f.name!r} exists after close")
+        finally:
+            os.unlink(f_name)
+            os.rmdir(dir)
+
+    def test_del_by_finalizer(self):
+        # A NamedTemporaryFile is deleted when finalized in the case of
+        # delete=True, delete_on_close=False, and no with-statement is used.
+        def my_func(dir):
+            f = tempfile.NamedTemporaryFile(dir=dir, delete=True,
+                                            delete_on_close=False)
+            tmp_name = f.name
+            f.write(b'blat')
+            # Testing extreme case, where the file is not explicitly closed
+            # f.close()
+            return tmp_name
+        # Make sure that the garbage collector has finalized the file object.
+        gc.collect()
+        dir = tempfile.mkdtemp()
+        try:
+            tmp_name = my_func(dir)
+            self.assertFalse(os.path.exists(tmp_name),
+                        f"NamedTemporaryFile {tmp_name!r} "
+                        f"exists after finalizer ")
+        finally:
+            os.rmdir(dir)
 
-        with mock.patch('os.close', side_effect=close):
-            with mock.patch('io.open', side_effect=ValueError):
-                self.assertRaises(ValueError, tempfile.NamedTemporaryFile)
-                self.assertEqual(len(closed), 1)
+    def test_correct_finalizer_work_if_already_deleted(self):
+        # There should be no error in the case of delete=True,
+        # delete_on_close=False, no with-statement is used, and the file is
+        # deleted manually.
+        def my_func(dir)->str:
+            f = tempfile.NamedTemporaryFile(dir=dir, delete=True,
+                                            delete_on_close=False)
+            tmp_name = f.name
+            f.write(b'blat')
+            f.close()
+            os.unlink(tmp_name)
+            return tmp_name
+        # Make sure that the garbage collector has finalized the file object.
+        gc.collect()
 
     def test_bad_mode(self):
         dir = tempfile.mkdtemp()
@@ -1039,6 +1151,24 @@ def test_bad_mode(self):
             tempfile.NamedTemporaryFile(mode=2, dir=dir)
         self.assertEqual(os.listdir(dir), [])
 
+    def test_bad_encoding(self):
+        dir = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, dir)
+        with self.assertRaises(LookupError):
+            tempfile.NamedTemporaryFile('w', encoding='bad-encoding', dir=dir)
+        self.assertEqual(os.listdir(dir), [])
+
+    def test_unexpected_error(self):
+        dir = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, dir)
+        with mock.patch('tempfile._TemporaryFileWrapper') as mock_ntf, \
+             mock.patch('io.open', mock.mock_open()) as mock_open:
+            mock_ntf.side_effect = KeyboardInterrupt()
+            with self.assertRaises(KeyboardInterrupt):
+                tempfile.NamedTemporaryFile(dir=dir)
+        mock_open().close.assert_called()
+        self.assertEqual(os.listdir(dir), [])
+
     # How to test the mode and bufsize parameters?
 
 class TestSpooledTemporaryFile(BaseTestCase):
@@ -1059,6 +1189,31 @@ def test_basic(self):
         f = self.do_create(max_size=100, pre="a", suf=".txt")
         self.assertFalse(f._rolled)
 
+    def test_is_iobase(self):
+        # SpooledTemporaryFile should implement io.IOBase
+        self.assertIsInstance(self.do_create(), io.IOBase)
+
+    def test_iobase_interface(self):
+        # SpooledTemporaryFile should implement the io.IOBase interface.
+        # Ensure it has all the required methods and properties.
+        iobase_attrs = {
+            # From IOBase
+            'fileno', 'seek', 'truncate', 'close', 'closed', '__enter__',
+            '__exit__', 'flush', 'isatty', '__iter__', '__next__', 'readable',
+            'readline', 'readlines', 'seekable', 'tell', 'writable',
+            'writelines',
+            # From BufferedIOBase (binary mode) and TextIOBase (text mode)
+            'detach', 'read', 'read1', 'write', 'readinto', 'readinto1',
+            'encoding', 'errors', 'newlines',
+        }
+        spooledtempfile_attrs = set(dir(tempfile.SpooledTemporaryFile))
+        missing_attrs = iobase_attrs - spooledtempfile_attrs
+        self.assertFalse(
+            missing_attrs,
+            'SpooledTemporaryFile missing attributes from '
+            'IOBase/BufferedIOBase/TextIOBase'
+        )
+
     def test_del_on_close(self):
         # A SpooledTemporaryFile is deleted when closed
         dir = tempfile.mkdtemp()
@@ -1069,11 +1224,40 @@ def test_del_on_close(self):
             self.assertTrue(f._rolled)
             filename = f.name
             f.close()
-            self.assertFalse(isinstance(filename, str) and os.path.exists(filename),
-                        "SpooledTemporaryFile %s exists after close" % filename)
+            self.assertEqual(os.listdir(dir), [])
+            if not isinstance(filename, int):
+                self.assertFalse(os.path.exists(filename),
+                    "SpooledTemporaryFile %s exists after close" % filename)
         finally:
             os.rmdir(dir)
 
+    def test_del_unrolled_file(self):
+        # The unrolled SpooledTemporaryFile should raise a ResourceWarning
+        # when deleted since the file was not explicitly closed.
+        f = self.do_create(max_size=10)
+        f.write(b'foo')
+        self.assertEqual(f.name, None)  # Unrolled so no filename/fd
+        with self.assertWarns(ResourceWarning):
+            f.__del__()
+
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot fstat renamed files."
+    )
+    def test_del_rolled_file(self):
+        # The rolled file should be deleted when the SpooledTemporaryFile
+        # object is deleted. This should raise a ResourceWarning since the file
+        # was not explicitly closed.
+        f = self.do_create(max_size=2)
+        f.write(b'foo')
+        name = f.name  # This is a fd on posix+cygwin, a filename everywhere else
+        self.assertTrue(os.path.exists(name))
+        with self.assertWarns(ResourceWarning):
+            f.__del__()
+        self.assertFalse(
+            os.path.exists(name),
+            "Rolled SpooledTemporaryFile (name=%s) exists after delete" % name
+        )
+
     def test_rewrite_small(self):
         # A SpooledTemporaryFile can be written to multiple within the max_size
         f = self.do_create(max_size=30)
@@ -1104,6 +1288,34 @@ def test_writelines(self):
         buf = f.read()
         self.assertEqual(buf, b'xyz')
 
+    def test_writelines_rollover(self):
+        # Verify writelines rolls over before exhausting the iterator
+        f = self.do_create(max_size=2)
+
+        def it():
+            yield b'xy'
+            self.assertFalse(f._rolled)
+            yield b'z'
+            self.assertTrue(f._rolled)
+
+        f.writelines(it())
+        pos = f.seek(0)
+        self.assertEqual(pos, 0)
+        buf = f.read()
+        self.assertEqual(buf, b'xyz')
+
+    def test_writelines_fast_path(self):
+        f = self.do_create(max_size=2)
+        f.write(b'abc')
+        self.assertTrue(f._rolled)
+
+        f.writelines([b'd', b'e', b'f'])
+        pos = f.seek(0)
+        self.assertEqual(pos, 0)
+        buf = f.read()
+        self.assertEqual(buf, b'abcdef')
+
+
     def test_writelines_sequential(self):
         # A SpooledTemporaryFile should hold exactly max_size bytes, and roll
         # over afterward
@@ -1284,6 +1496,9 @@ def use_closed():
                 pass
         self.assertRaises(ValueError, use_closed)
 
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot fstat renamed files."
+    )
     def test_truncate_with_size_parameter(self):
         # A SpooledTemporaryFile can be truncated to zero size
         f = tempfile.SpooledTemporaryFile(max_size=10)
@@ -1357,19 +1572,34 @@ def roundtrip(input, *args, **kwargs):
             roundtrip("\u039B", "w+", encoding="utf-16")
             roundtrip("foo\r\n", "w+", newline="")
 
-        def test_no_leak_fd(self):
-            # Issue #21058: don't leak file descriptor when io.open() fails
-            closed = []
-            os_close = os.close
-            def close(fd):
-                closed.append(fd)
-                os_close(fd)
-
-            with mock.patch('os.close', side_effect=close):
-                with mock.patch('io.open', side_effect=ValueError):
-                    self.assertRaises(ValueError, tempfile.TemporaryFile)
-                    self.assertEqual(len(closed), 1)
+        def test_bad_mode(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with self.assertRaises(ValueError):
+                tempfile.TemporaryFile(mode='wr', dir=dir)
+            with self.assertRaises(TypeError):
+                tempfile.TemporaryFile(mode=2, dir=dir)
+            self.assertEqual(os.listdir(dir), [])
+
+        def test_bad_encoding(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with self.assertRaises(LookupError):
+                tempfile.TemporaryFile('w', encoding='bad-encoding', dir=dir)
+            self.assertEqual(os.listdir(dir), [])
 
+        def test_unexpected_error(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with mock.patch('tempfile._O_TMPFILE_WORKS', False), \
+                 mock.patch('os.unlink') as mock_unlink, \
+                 mock.patch('os.open') as mock_open, \
+                 mock.patch('os.close') as mock_close:
+                mock_unlink.side_effect = KeyboardInterrupt()
+                with self.assertRaises(KeyboardInterrupt):
+                    tempfile.TemporaryFile(dir=dir)
+            mock_close.assert_called()
+            self.assertEqual(os.listdir(dir), [])
 
 
 # Helper for test_del_on_shutdown
@@ -1437,7 +1667,7 @@ def test_explicit_cleanup(self):
         finally:
             os.rmdir(dir)
 
-    def test_explict_cleanup_ignore_errors(self):
+    def test_explicit_cleanup_ignore_errors(self):
         """Test that cleanup doesn't return an error when ignoring them."""
         with tempfile.TemporaryDirectory() as working_dir:
             temp_dir = self.do_create(
@@ -1461,6 +1691,28 @@ def test_explict_cleanup_ignore_errors(self):
                 temp_path.exists(),
                 f"TemporaryDirectory {temp_path!s} exists after cleanup")
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_explicit_cleanup_correct_error(self):
+        with tempfile.TemporaryDirectory() as working_dir:
+            temp_dir = self.do_create(dir=working_dir)
+            with open(os.path.join(temp_dir.name, "example.txt"), 'wb'):
+                # Previously raised NotADirectoryError on some OSes
+                # (e.g. Windows). See bpo-43153.
+                with self.assertRaises(PermissionError):
+                    temp_dir.cleanup()
+
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_cleanup_with_used_directory(self):
+        with tempfile.TemporaryDirectory() as working_dir:
+            temp_dir = self.do_create(dir=working_dir)
+            subdir = os.path.join(temp_dir.name, "subdir")
+            os.mkdir(subdir)
+            with os_helper.change_cwd(subdir):
+                # Previously raised RecursionError on some OSes
+                # (e.g. Windows). See bpo-35144.
+                with self.assertRaises(PermissionError):
+                    temp_dir.cleanup()
+
     @os_helper.skip_unless_symlink
     def test_cleanup_with_symlink_to_a_directory(self):
         # cleanup() should not follow symlinks to directories (issue #12464)
@@ -1482,6 +1734,104 @@ def test_cleanup_with_symlink_to_a_directory(self):
                          "were deleted")
         d2.cleanup()
 
+    @os_helper.skip_unless_symlink
+    @unittest.skip('TODO: RUSTPYTHON; No such file or directory "..."')
+    def test_cleanup_with_symlink_modes(self):
+        # cleanup() should not follow symlinks when fixing mode bits (#91133)
+        with self.do_create(recurse=0) as d2:
+            file1 = os.path.join(d2, 'file1')
+            open(file1, 'wb').close()
+            dir1 = os.path.join(d2, 'dir1')
+            os.mkdir(dir1)
+            for mode in range(8):
+                mode <<= 6
+                with self.subTest(mode=format(mode, '03o')):
+                    def test(target, target_is_directory):
+                        d1 = self.do_create(recurse=0)
+                        symlink = os.path.join(d1.name, 'symlink')
+                        os.symlink(target, symlink,
+                                target_is_directory=target_is_directory)
+                        try:
+                            os.chmod(symlink, mode, follow_symlinks=False)
+                        except NotImplementedError:
+                            pass
+                        try:
+                            os.chmod(symlink, mode)
+                        except FileNotFoundError:
+                            pass
+                        os.chmod(d1.name, mode)
+                        d1.cleanup()
+                        self.assertFalse(os.path.exists(d1.name))
+
+                    with self.subTest('nonexisting file'):
+                        test('nonexisting', target_is_directory=False)
+                    with self.subTest('nonexisting dir'):
+                        test('nonexisting', target_is_directory=True)
+
+                    with self.subTest('existing file'):
+                        os.chmod(file1, mode)
+                        old_mode = os.stat(file1).st_mode
+                        test(file1, target_is_directory=False)
+                        new_mode = os.stat(file1).st_mode
+                        self.assertEqual(new_mode, old_mode,
+                                         '%03o != %03o' % (new_mode, old_mode))
+
+                    with self.subTest('existing dir'):
+                        os.chmod(dir1, mode)
+                        old_mode = os.stat(dir1).st_mode
+                        test(dir1, target_is_directory=True)
+                        new_mode = os.stat(dir1).st_mode
+                        self.assertEqual(new_mode, old_mode,
+                                         '%03o != %03o' % (new_mode, old_mode))
+
+    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.chflags')
+    @os_helper.skip_unless_symlink
+    def test_cleanup_with_symlink_flags(self):
+        # cleanup() should not follow symlinks when fixing flags (#91133)
+        flags = stat.UF_IMMUTABLE | stat.UF_NOUNLINK
+        self.check_flags(flags)
+
+        with self.do_create(recurse=0) as d2:
+            file1 = os.path.join(d2, 'file1')
+            open(file1, 'wb').close()
+            dir1 = os.path.join(d2, 'dir1')
+            os.mkdir(dir1)
+            def test(target, target_is_directory):
+                d1 = self.do_create(recurse=0)
+                symlink = os.path.join(d1.name, 'symlink')
+                os.symlink(target, symlink,
+                           target_is_directory=target_is_directory)
+                try:
+                    os.chflags(symlink, flags, follow_symlinks=False)
+                except NotImplementedError:
+                    pass
+                try:
+                    os.chflags(symlink, flags)
+                except FileNotFoundError:
+                    pass
+                os.chflags(d1.name, flags)
+                d1.cleanup()
+                self.assertFalse(os.path.exists(d1.name))
+
+            with self.subTest('nonexisting file'):
+                test('nonexisting', target_is_directory=False)
+            with self.subTest('nonexisting dir'):
+                test('nonexisting', target_is_directory=True)
+
+            with self.subTest('existing file'):
+                os.chflags(file1, flags)
+                old_flags = os.stat(file1).st_flags
+                test(file1, target_is_directory=False)
+                new_flags = os.stat(file1).st_flags
+                self.assertEqual(new_flags, old_flags)
+
+            with self.subTest('existing dir'):
+                os.chflags(dir1, flags)
+                old_flags = os.stat(dir1).st_flags
+                test(dir1, target_is_directory=True)
+                new_flags = os.stat(dir1).st_flags
+                self.assertEqual(new_flags, old_flags)
+
     @support.cpython_only
     def test_del_on_collection(self):
         # A TemporaryDirectory is deleted when garbage collected
@@ -1654,9 +2004,27 @@ def test_modes(self):
                     d.cleanup()
                 self.assertFalse(os.path.exists(d.name))
 
-    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.lchflags')
+    def check_flags(self, flags):
+        # skip the test if these flags are not supported (ex: FreeBSD 13)
+        filename = os_helper.TESTFN
+        try:
+            open(filename, "w").close()
+            try:
+                os.chflags(filename, flags)
+            except OSError as exc:
+                # "OSError: [Errno 45] Operation not supported"
+                self.skipTest(f"chflags() doesn't support flags "
+                              f"{flags:#b}: {exc}")
+            else:
+                os.chflags(filename, 0)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.chflags')
     def test_flags(self):
         flags = stat.UF_IMMUTABLE | stat.UF_NOUNLINK
+        self.check_flags(flags)
+
         d = self.do_create(recurse=3, dirs=2, files=2)
         with d:
             # Change files and directories flags recursively.
@@ -1667,6 +2035,11 @@ def test_flags(self):
             d.cleanup()
         self.assertFalse(os.path.exists(d.name))
 
+    def test_delete_false(self):
+        with tempfile.TemporaryDirectory(delete=False) as working_dir:
+            pass
+        self.assertTrue(os.path.exists(working_dir))
+        shutil.rmtree(working_dir)
 
 if __name__ == "__main__":
     unittest.main()

From e1b22f19e62d47485bdb55c9f3a4698221374f5b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 4 Jan 2026 22:58:16 +0900
Subject: [PATCH 171/418] vm.run_pyc_bytes (#6645)

* rustpython_vm::import::check_pyc_magic_number_bytes

* vm.new_scope_with_main

* PyCode::from_pyc

* vm.run_pyc_bytes

* add boundary check
---
 crates/vm/src/builtins/code.rs | 42 ++++++++++++++++-
 crates/vm/src/import.rs        |  4 ++
 crates/vm/src/vm/mod.rs        | 86 +++++++++++++++++++++++++++++++++-
 crates/vm/src/vm/python_run.rs | 57 +++++-----------------
 crates/vm/src/vm/vm_new.rs     | 19 +++++++-
 src/lib.rs                     | 21 ++-------
 6 files changed, 160 insertions(+), 69 deletions(-)

diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index 111702eac6c..85816aabb7c 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -2,11 +2,11 @@
 
 use super::{PyBytesRef, PyStrRef, PyTupleRef, PyType};
 use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::PyStrInterned,
     bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
     class::{PyClassImpl, StaticType},
-    convert::ToPyObject,
+    convert::{ToPyException, ToPyObject},
     frozen,
     function::OptionalArg,
     types::{Constructor, Representable},
@@ -336,6 +336,44 @@ impl PyCode {
     pub const fn new(code: CodeObject) -> Self {
         Self { code }
     }
+    pub fn from_pyc_path(path: &std::path::Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        let name = match path.file_stem() {
+            Some(stem) => stem.display().to_string(),
+            None => "".to_owned(),
+        };
+        let content = std::fs::read(path).map_err(|e| e.to_pyexception(vm))?;
+        Self::from_pyc(
+            &content,
+            Some(&name),
+            Some(&path.display().to_string()),
+            Some("<source>"),
+            vm,
+        )
+    }
+    pub fn from_pyc(
+        pyc_bytes: &[u8],
+        name: Option<&str>,
+        bytecode_path: Option<&str>,
+        source_path: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<Self>> {
+        if !crate::import::check_pyc_magic_number_bytes(pyc_bytes) {
+            return Err(vm.new_value_error("pyc bytes has wrong MAGIC"));
+        }
+        let bootstrap_external = vm.import("_frozen_importlib_external", 0)?;
+        let compile_bytecode = bootstrap_external.get_attr("_compile_bytecode", vm)?;
+        // 16 is the pyc header length
+        let Some((_, code_bytes)) = pyc_bytes.split_at_checked(16) else {
+            return Err(vm.new_value_error(format!(
+                "pyc_bytes header is broken. 16 bytes expected but {} bytes given.",
+                pyc_bytes.len()
+            )));
+        };
+        let code_bytes_obj = vm.ctx.new_bytes(code_bytes.to_vec());
+        let compiled =
+            compile_bytecode.call((code_bytes_obj, name, bytecode_path, source_path), vm)?;
+        compiled.try_downcast(vm)
+    }
 }
 
 impl fmt::Debug for PyCode {
diff --git a/crates/vm/src/import.rs b/crates/vm/src/import.rs
index d67bf59b35f..80ccbe30def 100644
--- a/crates/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -8,6 +8,10 @@ use crate::{
     vm::{VirtualMachine, resolve_frozen_alias, thread},
 };
 
+pub(crate) fn check_pyc_magic_number_bytes(buf: &[u8]) -> bool {
+    buf.starts_with(&crate::version::PYC_MAGIC_NUMBER_BYTES[..2])
+}
+
 pub(crate) fn init_importlib_base(vm: &mut VirtualMachine) -> PyResult<PyObjectRef> {
     flame_guard!("init importlib");
 
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index d3f18bf9f46..d2172a43a00 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -19,8 +19,8 @@ mod vm_ops;
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     builtins::{
-        PyBaseExceptionRef, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned, PyStrRef,
-        PyTypeRef, code::PyCode, pystr::AsPyStr, tuple::PyTuple,
+        PyBaseExceptionRef, PyDict, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned,
+        PyStrRef, PyTypeRef, code::PyCode, pystr::AsPyStr, tuple::PyTuple,
     },
     codecs::CodecsRegistry,
     common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
@@ -460,6 +460,42 @@ impl VirtualMachine {
         self.signal_rx = Some(signal_rx);
     }
 
+    /// Execute Python bytecode (`.pyc`) from an in-memory buffer.
+    ///
+    /// When the RustPython CLI is available, `.pyc` files are normally executed by
+    /// invoking `rustpython <input>.pyc`. This method provides an alternative for
+    /// environments where the binary is unavailable or file I/O is restricted
+    /// (e.g. WASM).
+    ///
+    /// ## Preparing a `.pyc` file
+    ///
+    /// First, compile a Python source file into bytecode:
+    ///
+    /// ```sh
+    /// # Generate a .pyc file
+    /// $ rustpython -m py_compile <input>.py
+    /// ```
+    ///
+    /// ## Running the bytecode
+    ///
+    /// Load the resulting `.pyc` file into memory and execute it using the VM:
+    ///
+    /// ```no_run
+    /// use rustpython_vm::Interpreter;
+    /// Interpreter::without_stdlib(Default::default()).enter(|vm| {
+    ///     let bytes = std::fs::read("__pycache__/<input>.rustpython-313.pyc").unwrap();
+    ///     let main_scope = vm.new_scope_with_main().unwrap();
+    ///     vm.run_pyc_bytes(&bytes, main_scope);
+    /// });
+    /// ```
+    pub fn run_pyc_bytes(&self, pyc_bytes: &[u8], scope: Scope) -> PyResult<()> {
+        let code = PyCode::from_pyc(pyc_bytes, Some("<pyc_bytes>"), None, None, self)?;
+        self.with_simple_run("<source>", |_module_dict| {
+            self.run_code_obj(code, scope)?;
+            Ok(())
+        })
+    }
+
     pub fn run_code_obj(&self, code: PyRef<PyCode>, scope: Scope) -> PyResult {
         use crate::builtins::PyFunction;
 
@@ -500,6 +536,52 @@ impl VirtualMachine {
         }
     }
 
+    /// Run `run` with main scope.
+    fn with_simple_run(
+        &self,
+        path: &str,
+        run: impl FnOnce(&Py<PyDict>) -> PyResult<()>,
+    ) -> PyResult<()> {
+        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
+        let main_module = sys_modules.get_item(identifier!(self, __main__), self)?;
+        let module_dict = main_module.dict().expect("main module must have __dict__");
+
+        // Track whether we set __file__ (for cleanup)
+        let set_file_name = !module_dict.contains_key(identifier!(self, __file__), self);
+        if set_file_name {
+            module_dict.set_item(
+                identifier!(self, __file__),
+                self.ctx.new_str(path).into(),
+                self,
+            )?;
+            module_dict.set_item(identifier!(self, __cached__), self.ctx.none(), self)?;
+        }
+
+        let result = run(&module_dict);
+
+        self.flush_io();
+
+        // Cleanup __file__ and __cached__ after execution
+        if set_file_name {
+            let _ = module_dict.del_item(identifier!(self, __file__), self);
+            let _ = module_dict.del_item(identifier!(self, __cached__), self);
+        }
+
+        result
+    }
+
+    /// flush_io
+    ///
+    /// Flush stdout and stderr. Errors are silently ignored.
+    fn flush_io(&self) {
+        if let Ok(stdout) = self.sys_module.get_attr("stdout", self) {
+            let _ = self.call_method(&stdout, identifier!(self, flush).as_str(), ());
+        }
+        if let Ok(stderr) = self.sys_module.get_attr("stderr", self) {
+            let _ = self.call_method(&stderr, identifier!(self, flush).as_str(), ());
+        }
+    }
+
     pub fn current_recursion_depth(&self) -> usize {
         self.recursion_depth.get()
     }
diff --git a/crates/vm/src/vm/python_run.rs b/crates/vm/src/vm/python_run.rs
index 31e8c7be45e..1c712279f8b 100644
--- a/crates/vm/src/vm/python_run.rs
+++ b/crates/vm/src/vm/python_run.rs
@@ -1,8 +1,8 @@
 //! Python code execution functions.
 
 use crate::{
-    PyResult, VirtualMachine,
-    builtins::{PyCode, PyDictRef},
+    Py, PyResult, VirtualMachine,
+    builtins::{PyCode, PyDict},
     compiler::{self},
     scope::Scope,
 };
@@ -25,37 +25,14 @@ impl VirtualMachine {
     /// Execute a Python file with __main__ module setup.
     /// Sets __file__ and __cached__ before execution, removes them after.
     fn run_simple_file(&self, scope: Scope, path: &str) -> PyResult<()> {
-        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
-        let main_module = sys_modules.get_item(identifier!(self, __main__), self)?;
-        let module_dict = main_module.dict().expect("main module must have __dict__");
-
-        // Track whether we set __file__ (for cleanup)
-        let set_file_name = !module_dict.contains_key(identifier!(self, __file__), self);
-        if set_file_name {
-            module_dict.set_item(
-                identifier!(self, __file__),
-                self.ctx.new_str(path).into(),
-                self,
-            )?;
-            module_dict.set_item(identifier!(self, __cached__), self.ctx.none(), self)?;
-        }
-
-        let result = self.run_simple_file_inner(&module_dict, scope, path);
-
-        self.flush_io();
-
-        // Cleanup __file__ and __cached__ after execution
-        if set_file_name {
-            let _ = module_dict.del_item(identifier!(self, __file__), self);
-            let _ = module_dict.del_item(identifier!(self, __cached__), self);
-        }
-
-        result
+        self.with_simple_run(path, |module_dict| {
+            self.run_simple_file_inner(module_dict, scope, path)
+        })
     }
 
     fn run_simple_file_inner(
         &self,
-        module_dict: &PyDictRef,
+        module_dict: &Py<PyDict>,
         scope: Scope,
         path: &str,
     ) -> PyResult<()> {
@@ -123,22 +100,10 @@ impl VirtualMachine {
             .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
         self.run_code_obj(code_obj, scope)
     }
-
-    /// flush_io
-    ///
-    /// Flush stdout and stderr. Errors are silently ignored.
-    fn flush_io(&self) {
-        if let Ok(stdout) = self.sys_module.get_attr("stdout", self) {
-            let _ = self.call_method(&stdout, identifier!(self, flush).as_str(), ());
-        }
-        if let Ok(stderr) = self.sys_module.get_attr("stderr", self) {
-            let _ = self.call_method(&stderr, identifier!(self, flush).as_str(), ());
-        }
-    }
 }
 
 fn set_main_loader(
-    module_dict: &PyDictRef,
+    module_dict: &Py<PyDict>,
     filename: &str,
     loader_name: &str,
     vm: &VirtualMachine,
@@ -162,10 +127,10 @@ fn maybe_pyc_file(path: &str) -> bool {
     if path.ends_with(".pyc") {
         return true;
     }
-    maybe_pyc_file_with_magic(path, &crate::version::PYC_MAGIC_NUMBER_BYTES).unwrap_or(false)
+    maybe_pyc_file_with_magic(path).unwrap_or(false)
 }
 
-fn maybe_pyc_file_with_magic(path: &str, magic_number: &[u8]) -> std::io::Result<bool> {
+fn maybe_pyc_file_with_magic(path: &str) -> std::io::Result<bool> {
     let path_obj = std::path::Path::new(path);
     if !path_obj.is_file() {
         return Ok(false);
@@ -175,12 +140,12 @@ fn maybe_pyc_file_with_magic(path: &str, magic_number: &[u8]) -> std::io::Result
     let mut buf = [0u8; 2];
 
     use std::io::Read;
-    if file.read(&mut buf)? != 2 || magic_number.len() < 2 {
+    if file.read(&mut buf)? != 2 {
         return Ok(false);
     }
 
     // Read only two bytes of the magic. If the file was opened in
     // text mode, the bytes 3 and 4 of the magic (\r\n) might not
     // be read as they are on disk.
-    Ok(buf == magic_number[..2])
+    Ok(crate::import::check_pyc_magic_number_bytes(&buf))
 }
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 4f25d6e2036..c74fb922a82 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -1,5 +1,5 @@
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyRef,
+    AsObject, Py, PyObject, PyObjectRef, PyRef, PyResult,
     builtins::{
         PyBaseException, PyBaseExceptionRef, PyBytesRef, PyDictRef, PyModule, PyOSError, PyStrRef,
         PyType, PyTypeRef,
@@ -62,6 +62,23 @@ impl VirtualMachine {
         Scope::with_builtins(None, self.ctx.new_dict(), self)
     }
 
+    pub fn new_scope_with_main(&self) -> PyResult<Scope> {
+        let scope = self.new_scope_with_builtins();
+        let main_module = self.new_module("__main__", scope.globals.clone(), None);
+        main_module
+            .dict()
+            .set_item("__annotations__", self.ctx.new_dict().into(), self)
+            .expect("Failed to initialize __main__.__annotations__");
+
+        self.sys_module.get_attr("modules", self)?.set_item(
+            "__main__",
+            main_module.into(),
+            self,
+        )?;
+
+        Ok(scope)
+    }
+
     pub fn new_function<F, FKind>(&self, name: &'static str, f: F) -> PyRef<PyNativeFunction>
     where
         F: IntoPyNativeFn<FKind>,
diff --git a/src/lib.rs b/src/lib.rs
index ad5894860d2..c6de6520de8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,21 +114,6 @@ pub fn run(init: impl FnOnce(&mut VirtualMachine) + 'static) -> ExitCode {
     rustpython_vm::common::os::exit_code(exitcode)
 }
 
-fn setup_main_module(vm: &VirtualMachine) -> PyResult<Scope> {
-    let scope = vm.new_scope_with_builtins();
-    let main_module = vm.new_module("__main__", scope.globals.clone(), None);
-    main_module
-        .dict()
-        .set_item("__annotations__", vm.ctx.new_dict().into(), vm)
-        .expect("Failed to initialize __main__.__annotations__");
-
-    vm.sys_module
-        .get_attr("modules", vm)?
-        .set_item("__main__", main_module.into(), vm)?;
-
-    Ok(scope)
-}
-
 fn get_pip(scope: Scope, vm: &VirtualMachine) -> PyResult<()> {
     let get_getpip = rustpython_vm::py_compile!(
         source = r#"\
@@ -221,7 +206,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     #[cfg(feature = "flame-it")]
     let main_guard = flame::start_guard("RustPython main");
 
-    let scope = setup_main_module(vm)?;
+    let scope = vm.new_scope_with_main()?;
 
     // Import site first, before setting sys.path[0]
     // This matches CPython's behavior where site.removeduppaths() runs
@@ -366,11 +351,11 @@ mod tests {
     fn test_run_script() {
         interpreter().enter(|vm| {
             vm.unwrap_pyresult((|| {
-                let scope = setup_main_module(vm)?;
+                let scope = vm.new_scope_with_main()?;
                 // test file run
                 vm.run_any_file(scope, "extra_tests/snippets/dir_main/__main__.py")?;
 
-                let scope = setup_main_module(vm)?;
+                let scope = vm.new_scope_with_main()?;
                 // test module run (directory with __main__.py)
                 run_file(vm, scope, "extra_tests/snippets/dir_main")?;
 

From 6cc103bad359d9a6488e0b97532e80290cf61f19 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 5 Jan 2026 01:35:56 +0900
Subject: [PATCH 172/418] Update README with venv and PIP instructions (#6127)

---
 README.md | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 86d0738ec8e..b3ddbe4e7cf 100644
--- a/README.md
+++ b/README.md
@@ -66,7 +66,25 @@ Welcome to the magnificent Rust Python interpreter
 >>>>>
 ```
 
-You can install pip by
+### venv
+
+Because RustPython currently doesn't provide a well-packaged installation, using venv helps to use pip easier.
+
+```sh
+$ rustpython -m venv <your_env_name>
+$ . <your_env_name>/bin/activate
+$ python # now `python` is the alias of the RustPython for the new env
+```
+
+### PIP
+
+If you'd like to make https requests, you can enable the `ssl` feature, which
+also lets you install the `pip` package manager. Note that on Windows, you may
+need to install OpenSSL, or you can enable the `ssl-vendor` feature instead,
+which compiles OpenSSL for you but requires a C compiler, perl, and `make`.
+OpenSSL version 3 is expected and tested in CI. Older versions may not work.
+
+Once you've installed rustpython with SSL support, you can install pip by
 running:
 
 ```bash

From ce5e1bd4552d12245d447ff788c300d09773b9e5 Mon Sep 17 00:00:00 2001
From: Gyubong Lee <jopemachine@naver.com>
Date: Mon, 5 Jan 2026 08:01:00 +0900
Subject: [PATCH 173/418] Update  `threading` lib and tests from CPython
 3.12.0a0 (#4156)

* Update threading.py from CPython v3.12.0a0

* Update test_threading.py from CPython v3.12.0a0

* mark failing tests

---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 Lib/test/test_threading.py | 133 +++++++++++++++++++++++++++++--------
 Lib/threading.py           |  11 +++
 2 files changed, 117 insertions(+), 27 deletions(-)

diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 8f86792e820..937f5903b5f 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -3,7 +3,7 @@
 """
 
 import test.support
-from test.support import threading_helper
+from test.support import threading_helper, requires_subprocess
 from test.support import verbose, cpython_only, os_helper
 from test.support.import_helper import import_module
 from test.support.script_helper import assert_python_ok, assert_python_failure
@@ -25,6 +25,7 @@
 from test import lock_tests
 from test import support
 
+threading_helper.requires_working_threading(module=True)
 
 # Between fork() and exec(), only async-safe functions are allowed (issues
 # #12316 and #11870), and fork() from a worker thread is known to trigger
@@ -32,9 +33,6 @@
 # on platforms known to behave badly.
 platforms_to_skip = ('netbsd5', 'hp-ux11')
 
-# Is Python built with Py_DEBUG macro defined?
-Py_DEBUG = hasattr(sys, 'gettotalrefcount')
-
 
 def restore_default_excepthook(testcase):
     testcase.addCleanup(setattr, threading, 'excepthook', threading.excepthook)
@@ -123,6 +121,33 @@ def func(): pass
             thread = threading.Thread(target=func)
             self.assertEqual(thread.name, "Thread-5 (func)")
 
+    def test_args_argument(self):
+        # bpo-45735: Using list or tuple as *args* in constructor could
+        # achieve the same effect.
+        num_list = [1]
+        num_tuple = (1,)
+
+        str_list = ["str"]
+        str_tuple = ("str",)
+
+        list_in_tuple = ([1],)
+        tuple_in_list = [(1,)]
+
+        test_cases = (
+            (num_list, lambda arg: self.assertEqual(arg, 1)),
+            (num_tuple, lambda arg: self.assertEqual(arg, 1)),
+            (str_list, lambda arg: self.assertEqual(arg, "str")),
+            (str_tuple, lambda arg: self.assertEqual(arg, "str")),
+            (list_in_tuple, lambda arg: self.assertEqual(arg, [1])),
+            (tuple_in_list, lambda arg: self.assertEqual(arg, (1,)))
+        )
+
+        for args, target in test_cases:
+            with self.subTest(target=target, args=args):
+                t = threading.Thread(target=target, args=args)
+                t.start()
+                t.join()
+
     @cpython_only
     def test_disallow_instantiation(self):
         # Ensure that the type disallows instantiation (bpo-43916)
@@ -509,8 +534,7 @@ def test_daemon_param(self):
         t = threading.Thread(daemon=True)
         self.assertTrue(t.daemon)
 
-    @unittest.skipUnless(hasattr(threading.Lock(), '_at_fork_reinit'), 'TODO: RUSTPYTHON, exit_handler needs lock._at_fork_reinit')
-    @unittest.skipUnless(hasattr(os, 'fork'), 'needs os.fork()')
+    @support.requires_fork()
     def test_fork_at_exit(self):
         # bpo-42350: Calling os.fork() after threading._shutdown() must
         # not log an error.
@@ -538,7 +562,7 @@ def exit_handler():
         self.assertEqual(out, b'')
         self.assertEqual(err.rstrip(), b'child process ok')
 
-    @unittest.skipUnless(hasattr(os, 'fork'), 'test needs fork()')
+    @support.requires_fork()
     def test_dummy_thread_after_fork(self):
         # Issue #14308: a dummy thread in the active list doesn't mess up
         # the after-fork mechanism.
@@ -565,8 +589,7 @@ def background_thread(evt):
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
-    @unittest.skipUnless(hasattr(sys, 'getswitchinterval'), "TODO: RUSTPYTHON, needs sys.getswitchinterval()")
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @support.requires_fork()
     def test_is_alive_after_fork(self):
         # Try hard to trigger #18418: is_alive() could sometimes be True on
         # threads that vanished after a fork.
@@ -600,7 +623,7 @@ def f():
         th.start()
         th.join()
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+    @support.requires_fork()
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     def test_main_thread_after_fork(self):
         code = """if 1:
@@ -622,7 +645,7 @@ def test_main_thread_after_fork(self):
         self.assertEqual(data, "MainThread\nTrue\nTrue\n")
 
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+    @support.requires_fork()
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     @unittest.skipIf(os.name != 'posix', "test needs POSIX semantics")
     def test_main_thread_after_fork_from_nonmain_thread(self):
@@ -837,6 +860,7 @@ def callback():
                 callback()
         finally:
             sys.settrace(old_trace)
+            threading.settrace(old_trace)
 
     def test_gettrace(self):
         def noop_trace(frame, event, arg):
@@ -850,6 +874,37 @@ def noop_trace(frame, event, arg):
         finally:
             threading.settrace(old_trace)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gettrace_all_threads(self):
+        def fn(*args): pass
+        old_trace = threading.gettrace()
+        first_check = threading.Event()
+        second_check = threading.Event()
+
+        trace_funcs = []
+        def checker():
+            trace_funcs.append(sys.gettrace())
+            first_check.set()
+            second_check.wait()
+            trace_funcs.append(sys.gettrace())
+
+        try:
+            t = threading.Thread(target=checker)
+            t.start()
+            first_check.wait()
+            threading.settrace_all_threads(fn)
+            second_check.set()
+            t.join()
+            self.assertEqual(trace_funcs, [None, fn])
+            self.assertEqual(threading.gettrace(), fn)
+            self.assertEqual(sys.gettrace(), fn)
+        finally:
+            threading.settrace_all_threads(old_trace)
+
+        self.assertEqual(threading.gettrace(), old_trace)
+        self.assertEqual(sys.gettrace(), old_trace)
+
     def test_getprofile(self):
         def fn(*args): pass
         old_profile = threading.getprofile()
@@ -859,6 +914,37 @@ def fn(*args): pass
         finally:
             threading.setprofile(old_profile)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getprofile_all_threads(self):
+        def fn(*args): pass
+        old_profile = threading.getprofile()
+        first_check = threading.Event()
+        second_check = threading.Event()
+
+        profile_funcs = []
+        def checker():
+            profile_funcs.append(sys.getprofile())
+            first_check.set()
+            second_check.wait()
+            profile_funcs.append(sys.getprofile())
+
+        try:
+            t = threading.Thread(target=checker)
+            t.start()
+            first_check.wait()
+            threading.setprofile_all_threads(fn)
+            second_check.set()
+            t.join()
+            self.assertEqual(profile_funcs, [None, fn])
+            self.assertEqual(threading.getprofile(), fn)
+            self.assertEqual(sys.getprofile(), fn)
+        finally:
+            threading.setprofile_all_threads(old_profile)
+
+        self.assertEqual(threading.getprofile(), old_profile)
+        self.assertEqual(sys.getprofile(), old_profile)
+
     @cpython_only
     def test_shutdown_locks(self):
         for daemon in (False, True):
@@ -929,16 +1015,6 @@ def noop(): pass
             threading.Thread(target=noop).start()
             # Thread.join() is not called
 
-    @unittest.skipUnless(Py_DEBUG, 'need debug build (Py_DEBUG)')
-    def test_debug_deprecation(self):
-        # bpo-44584: The PYTHONTHREADDEBUG environment variable is deprecated
-        rc, out, err = assert_python_ok("-Wdefault", "-c", "pass",
-                                        PYTHONTHREADDEBUG="1")
-        msg = (b'DeprecationWarning: The threading debug '
-               b'(PYTHONTHREADDEBUG environment variable) '
-               b'is deprecated and will be removed in Python 3.12')
-        self.assertIn(msg, err)
-
     def test_import_from_another_thread(self):
         # bpo-1596321: If the threading module is first import from a thread
         # different than the main thread, threading._shutdown() must handle
@@ -1006,7 +1082,7 @@ def test_1_join_on_shutdown(self):
             """
         self._run_and_join(script)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @support.requires_fork()
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
     # TODO: RUSTPYTHON need to fix test_1_join_on_shutdown then this might work
     @unittest.expectedFailure
@@ -1029,7 +1105,7 @@ def test_2_join_in_forked_process(self):
             """
         self._run_and_join(script)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @support.requires_fork()
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
     @unittest.skip("TODO: RUSTPYTHON, flaky test")
     def test_3_join_in_forked_from_thread(self):
@@ -1075,8 +1151,9 @@ def test_4_daemon_threads(self):
 
             def random_io():
                 '''Loop for a while sleeping random tiny amounts and doing some I/O.'''
+                import test.test_threading as mod
                 while True:
-                    with open(os.__file__, 'rb') as in_f:
+                    with open(mod.__file__, 'rb') as in_f:
                         stuff = in_f.read(200)
                         with open(os.devnull, 'wb') as null_f:
                             null_f.write(stuff)
@@ -1100,7 +1177,7 @@ def main():
         rc, out, err = assert_python_ok('-c', script)
         self.assertFalse(err)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @support.requires_fork()
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
     def test_reinit_tls_after_fork(self):
         # Issue #13817: fork() would deadlock in a multithreaded program with
@@ -1124,8 +1201,9 @@ def do_fork_and_wait():
         for t in threads:
             t.join()
 
-    @unittest.skipUnless(hasattr(sys, '_current_frames'), "TODO: RUSTPYTHON, needs sys._current_frames()")
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @support.requires_fork()
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_clear_threads_states_after_fork(self):
         # Issue #17094: check that threads states are cleared after fork()
 
@@ -1280,6 +1358,7 @@ def test_releasing_unacquired_lock(self):
         self.assertRaises(RuntimeError, lock.release)
 
     @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @requires_subprocess()
     def test_recursion_limit(self):
         # Issue 9670
         # test that excessive recursion within a non-main thread causes
diff --git a/Lib/threading.py b/Lib/threading.py
index 668126523d5..811ea94a126 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -79,6 +79,17 @@ def settrace(func):
     global _trace_hook
     _trace_hook = func
 
+# TODO: RUSTPYTHON
+def settrace_all_threads(func):
+    """Set a trace function for all threads started from the threading module
+    and all Python threads that are currently executing.
+
+    The func will be passed to sys.settrace() for each thread, before its run()
+    method is called.
+    """
+    settrace(func)
+    _sys._settraceallthreads(func)
+
 def gettrace():
     """Get the trace function as set by threading.settrace()."""
     return _trace_hook

From bdf3b3654ef1bdad7173b7740e1441a8b3a1ba75 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 5 Jan 2026 08:01:41 +0900
Subject: [PATCH 174/418] fix syntaxerror ast end_offset (#6646)

---
 Lib/test/test_cmd_line_script.py |  5 +--
 crates/compiler/src/lib.rs       | 30 +++++++++++++--
 crates/vm/src/builtins/type.rs   | 15 ++++++++
 crates/vm/src/exceptions.rs      | 64 +++++++++++++++++++-------------
 crates/vm/src/stdlib/ast.rs      | 16 ++++----
 crates/vm/src/vm/vm_new.rs       | 14 +++++++
 6 files changed, 104 insertions(+), 40 deletions(-)

diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index 9fc240de818..d2b3a7d3e40 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -611,8 +611,6 @@ def test_issue20500_exit_with_exception_value(self):
             text = stderr.decode('ascii')
             self.assertEqual(text.rstrip(), "some text")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_syntaxerror_unindented_caret_position(self):
         script = "1 + 1 = 2\n"
         with os_helper.temp_dir() as script_dir:
@@ -622,8 +620,7 @@ def test_syntaxerror_unindented_caret_position(self):
             # Confirm that the caret is located under the '=' sign
             self.assertIn("\n    ^^^^^\n", text)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_syntaxerror_indented_caret_position(self):
         script = textwrap.dedent("""\
             if True:
diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs
index 7fa695c0c71..11e3bf0d07a 100644
--- a/crates/compiler/src/lib.rs
+++ b/crates/compiler/src/lib.rs
@@ -25,6 +25,7 @@ pub struct ParseError {
     pub error: parser::ParseErrorType,
     pub raw_location: ruff_text_size::TextRange,
     pub location: SourceLocation,
+    pub end_location: SourceLocation,
     pub source_path: String,
 }
 
@@ -44,13 +45,26 @@ pub enum CompileError {
 
 impl CompileError {
     pub fn from_ruff_parse_error(error: parser::ParseError, source_file: &SourceFile) -> Self {
-        let location = source_file
-            .to_source_code()
-            .source_location(error.location.start(), PositionEncoding::Utf8);
+        let source_code = source_file.to_source_code();
+        let location = source_code.source_location(error.location.start(), PositionEncoding::Utf8);
+        let mut end_location =
+            source_code.source_location(error.location.end(), PositionEncoding::Utf8);
+
+        // If the error range ends at the start of a new line (column 1),
+        // adjust it to the end of the previous line
+        if end_location.character_offset.get() == 1 && end_location.line > location.line {
+            // Get the end of the previous line
+            let prev_line_end = error.location.end() - ruff_text_size::TextSize::from(1);
+            end_location = source_code.source_location(prev_line_end, PositionEncoding::Utf8);
+            // Adjust column to be after the last character
+            end_location.character_offset = end_location.character_offset.saturating_add(1);
+        }
+
         Self::Parse(ParseError {
             error: error.error,
             raw_location: error.location,
             location,
+            end_location,
             source_path: source_file.name().to_owned(),
         })
     }
@@ -70,6 +84,16 @@ impl CompileError {
         }
     }
 
+    pub fn python_end_location(&self) -> Option<(usize, usize)> {
+        match self {
+            CompileError::Codegen(_) => None,
+            CompileError::Parse(parse_error) => Some((
+                parse_error.end_location.line.get(),
+                parse_error.end_location.character_offset.get(),
+            )),
+        }
+    }
+
     pub fn source_path(&self) -> &str {
         match self {
             Self::Codegen(codegen_error) => &codegen_error.source_path,
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index b6995d6f595..8660d1f2e27 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1997,6 +1997,8 @@ fn calculate_meta_class(
     let mut winner = metatype;
     for base in bases {
         let base_type = base.class();
+
+        // First try fast_issubclass for PyType instances
         if winner.fast_issubclass(base_type) {
             continue;
         } else if base_type.fast_issubclass(&winner) {
@@ -2004,6 +2006,19 @@ fn calculate_meta_class(
             continue;
         }
 
+        // If fast_issubclass didn't work, fall back to general is_subclass
+        // This handles cases where metaclasses are not PyType subclasses
+        let winner_is_subclass = winner.as_object().is_subclass(base_type.as_object(), vm)?;
+        if winner_is_subclass {
+            continue;
+        }
+
+        let base_type_is_subclass = base_type.as_object().is_subclass(winner.as_object(), vm)?;
+        if base_type_is_subclass {
+            winner = base_type.to_owned();
+            continue;
+        }
+
         return Err(vm.new_type_error(
             "metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass \
              of the metaclasses of all its bases",
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index 5d0c1c6f3ed..a2b08655822 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -223,37 +223,49 @@ impl VirtualMachine {
             if let Some(offset) = maybe_offset {
                 let maybe_end_offset: Option<isize> =
                     getattr("end_offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
-
-                let mut end_offset = match maybe_end_offset {
-                    Some(0) | None => offset,
-                    Some(end_offset) => end_offset,
+                let maybe_end_lineno: Option<isize> =
+                    getattr("end_lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+                let maybe_lineno_int: Option<isize> =
+                    getattr("lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+
+                // Only show caret if end_lineno is same as lineno (or not set)
+                let same_line = match (maybe_lineno_int, maybe_end_lineno) {
+                    (Some(lineno), Some(end_lineno)) => lineno == end_lineno,
+                    _ => true,
                 };
 
-                if offset == end_offset || end_offset == -1 {
-                    end_offset = offset + 1;
-                }
+                if same_line {
+                    let mut end_offset = match maybe_end_offset {
+                        Some(0) | None => offset,
+                        Some(end_offset) => end_offset,
+                    };
 
-                // Convert 1-based column offset to 0-based index into stripped text
-                let colno = offset - 1 - spaces;
-                let end_colno = end_offset - 1 - spaces;
-                if colno >= 0 {
-                    let caret_space = l_text
-                        .chars()
-                        .take(colno as usize)
-                        .map(|c| if c.is_whitespace() { c } else { ' ' })
-                        .collect::<String>();
-
-                    let mut error_width = end_colno - colno;
-                    if error_width < 1 {
-                        error_width = 1;
+                    if offset == end_offset || end_offset == -1 {
+                        end_offset = offset + 1;
                     }
 
-                    writeln!(
-                        output,
-                        "    {}{}",
-                        caret_space,
-                        "^".repeat(error_width as usize)
-                    )?;
+                    // Convert 1-based column offset to 0-based index into stripped text
+                    let colno = offset - 1 - spaces;
+                    let end_colno = end_offset - 1 - spaces;
+                    if colno >= 0 {
+                        let caret_space = l_text
+                            .chars()
+                            .take(colno as usize)
+                            .map(|c| if c.is_whitespace() { c } else { ' ' })
+                            .collect::<String>();
+
+                        let mut error_width = end_colno - colno;
+                        if error_width < 1 {
+                            error_width = 1;
+                        }
+
+                        writeln!(
+                            output,
+                            "    {}{}",
+                            caret_space,
+                            "^".repeat(error_width as usize)
+                        )?;
+                    }
                 }
             }
         }
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
index b8df86fb091..31aad306f96 100644
--- a/crates/vm/src/stdlib/ast.rs
+++ b/crates/vm/src/stdlib/ast.rs
@@ -271,13 +271,15 @@ pub(crate) fn parse(
 ) -> Result<PyObjectRef, CompileError> {
     let source_file = SourceFileBuilder::new("".to_owned(), source.to_owned()).finish();
     let top = parser::parse(source, mode.into())
-        .map_err(|parse_error| ParseError {
-            error: parse_error.error,
-            raw_location: parse_error.location,
-            location: text_range_to_source_range(&source_file, parse_error.location)
-                .start
-                .to_source_location(),
-            source_path: "<unknown>".to_string(),
+        .map_err(|parse_error| {
+            let range = text_range_to_source_range(&source_file, parse_error.location);
+            ParseError {
+                error: parse_error.error,
+                raw_location: parse_error.location,
+                location: range.start.to_source_location(),
+                end_location: range.end.to_source_location(),
+                source_path: "<unknown>".to_string(),
+            }
         })?
         .into_syntax();
     let top = match top {
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index c74fb922a82..119444be75c 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -499,6 +499,20 @@ impl VirtualMachine {
             .set_attr("offset", offset, self)
             .unwrap();
 
+        // Set end_lineno and end_offset if available
+        if let Some((end_lineno, end_offset)) = error.python_end_location() {
+            let end_lineno = self.ctx.new_int(end_lineno);
+            let end_offset = self.ctx.new_int(end_offset);
+            syntax_error
+                .as_object()
+                .set_attr("end_lineno", end_lineno, self)
+                .unwrap();
+            syntax_error
+                .as_object()
+                .set_attr("end_offset", end_offset, self)
+                .unwrap();
+        }
+
         syntax_error
             .as_object()
             .set_attr("text", statement.to_pyobject(self), self)

From 8977c39b60fa8a1d5972e144edfa328f051889d2 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sun, 4 Jan 2026 23:55:07 -0500
Subject: [PATCH 175/418] Updated the re library + test (#6648)

* Updated re library + test

* Copied over generate_sre_constants from cpython/Tools

* Customized `generate_sre_constants.py` + ran to update `constants.rs`

* Clarified `dump_enum` docstring in `generate_sre_constants.py`
---
 Lib/re/__init__.py                 |   7 +-
 Lib/re/_casefix.py                 |   2 +-
 Lib/re/_compiler.py                |  32 +-
 Lib/re/_constants.py               |   9 +-
 Lib/re/_parser.py                  |   7 +-
 Lib/sre_constants.py               |  78 -----
 Lib/test/test_re.py                | 504 ++++++++++++++++++++++-------
 crates/sre_engine/src/constants.rs |  13 +-
 crates/vm/src/stdlib/sre.rs        |   1 -
 scripts/generate_sre_constants.py  | 139 ++++++++
 10 files changed, 565 insertions(+), 227 deletions(-)
 create mode 100644 scripts/generate_sre_constants.py

diff --git a/Lib/re/__init__.py b/Lib/re/__init__.py
index 428d1b0d5fb..7e8abbf6ffe 100644
--- a/Lib/re/__init__.py
+++ b/Lib/re/__init__.py
@@ -117,7 +117,8 @@
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.
 
-This module also defines an exception 'error'.
+This module also defines exception 'PatternError', aliased to 'error' for
+backward compatibility.
 
 """
 
@@ -133,7 +134,7 @@
     "findall", "finditer", "compile", "purge", "escape",
     "error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
     "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
-    "UNICODE", "NOFLAG", "RegexFlag",
+    "UNICODE", "NOFLAG", "RegexFlag", "PatternError"
 ]
 
 __version__ = "2.2.1"
@@ -155,7 +156,7 @@ class RegexFlag:
     _numeric_repr_ = hex
 
 # sre exception
-error = _compiler.error
+PatternError = error = _compiler.PatternError
 
 # --------------------------------------------------------------------
 # public interface
diff --git a/Lib/re/_casefix.py b/Lib/re/_casefix.py
index 06507d08bee..fed2d84fc01 100644
--- a/Lib/re/_casefix.py
+++ b/Lib/re/_casefix.py
@@ -1,4 +1,4 @@
-# Auto-generated by Tools/scripts/generate_re_casefix.py.
+# Auto-generated by Tools/build/generate_re_casefix.py.
 
 # Maps the code of lowercased character to codes of different lowercased
 # characters which have the same uppercase.
diff --git a/Lib/re/_compiler.py b/Lib/re/_compiler.py
index 861bbdb130a..1b1aaa7714b 100644
--- a/Lib/re/_compiler.py
+++ b/Lib/re/_compiler.py
@@ -101,8 +101,6 @@ def _compile(code, pattern, flags):
             else:
                 emit(ANY)
         elif op in REPEATING_CODES:
-            if flags & SRE_FLAG_TEMPLATE:
-                raise error("internal: unsupported template operator %r" % (op,))
             if _simple(av[2]):
                 emit(REPEATING_CODES[op][2])
                 skip = _len(code); emit(0)
@@ -152,7 +150,7 @@ def _compile(code, pattern, flags):
                 if lo > MAXCODE:
                     raise error("looks too much behind")
                 if lo != hi:
-                    raise error("look-behind requires fixed-width pattern")
+                    raise PatternError("look-behind requires fixed-width pattern")
                 emit(lo) # look behind
             _compile(code, av[1], flags)
             emit(SUCCESS)
@@ -211,7 +209,7 @@ def _compile(code, pattern, flags):
             else:
                 code[skipyes] = _len(code) - skipyes + 1
         else:
-            raise error("internal: unsupported operand type %r" % (op,))
+            raise PatternError(f"internal: unsupported operand type {op!r}")
 
 def _compile_charset(charset, flags, code):
     # compile charset subprogram
@@ -237,7 +235,7 @@ def _compile_charset(charset, flags, code):
             else:
                 emit(av)
         else:
-            raise error("internal: unsupported set operator %r" % (op,))
+            raise PatternError(f"internal: unsupported set operator {op!r}")
     emit(FAILURE)
 
 def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
@@ -250,11 +248,11 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
         while True:
             try:
                 if op is LITERAL:
-                    if fixup:
-                        lo = fixup(av)
-                        charmap[lo] = 1
-                        if fixes and lo in fixes:
-                            for k in fixes[lo]:
+                    if fixup: # IGNORECASE and not LOCALE
+                        av = fixup(av)
+                        charmap[av] = 1
+                        if fixes and av in fixes:
+                            for k in fixes[av]:
                                 charmap[k] = 1
                         if not hascased and iscased(av):
                             hascased = True
@@ -262,7 +260,7 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                         charmap[av] = 1
                 elif op is RANGE:
                     r = range(av[0], av[1]+1)
-                    if fixup:
+                    if fixup: # IGNORECASE and not LOCALE
                         if fixes:
                             for i in map(fixup, r):
                                 charmap[i] = 1
@@ -289,8 +287,7 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                 # Character set contains non-BMP character codes.
                 # For range, all BMP characters in the range are already
                 # proceeded.
-                if fixup:
-                    hascased = True
+                if fixup: # IGNORECASE and not LOCALE
                     # For now, IN_UNI_IGNORE+LITERAL and
                     # IN_UNI_IGNORE+RANGE_UNI_IGNORE work for all non-BMP
                     # characters, because two characters (at least one of
@@ -301,7 +298,13 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                     # Also, both c.lower() and c.lower().upper() are single
                     # characters for every non-BMP character.
                     if op is RANGE:
-                        op = RANGE_UNI_IGNORE
+                        if fixes: # not ASCII
+                            op = RANGE_UNI_IGNORE
+                        hascased = True
+                    else:
+                        assert op is LITERAL
+                        if not hascased and iscased(av):
+                            hascased = True
                 tail.append((op, av))
             break
 
@@ -763,4 +766,3 @@ def compile(p, flags=0):
         p.state.groups-1,
         groupindex, tuple(indexgroup)
         )
-
diff --git a/Lib/re/_constants.py b/Lib/re/_constants.py
index 92494e385cf..9c3c294ba44 100644
--- a/Lib/re/_constants.py
+++ b/Lib/re/_constants.py
@@ -13,14 +13,14 @@
 
 # update when constants are added or removed
 
-MAGIC = 20221023
+MAGIC = 20230612
 
 from _sre import MAXREPEAT, MAXGROUPS
 
 # SRE standard exception (access as sre.error)
 # should this really be here?
 
-class error(Exception):
+class PatternError(Exception):
     """Exception raised for invalid regular expressions.
 
     Attributes:
@@ -53,6 +53,9 @@ def __init__(self, msg, pattern=None, pos=None):
         super().__init__(msg)
 
 
+# Backward compatibility after renaming in 3.13
+error = PatternError
+
 class _NamedIntConstant(int):
     def __new__(cls, value, name):
         self = super(_NamedIntConstant, cls).__new__(cls, value)
@@ -204,7 +207,6 @@ def _makecodes(*names):
 }
 
 # flags
-SRE_FLAG_TEMPLATE = 1 # template mode (unknown purpose, deprecated)
 SRE_FLAG_IGNORECASE = 2 # case insensitive
 SRE_FLAG_LOCALE = 4 # honour system locale
 SRE_FLAG_MULTILINE = 8 # treat target as multiline string
@@ -218,4 +220,3 @@ def _makecodes(*names):
 SRE_INFO_PREFIX = 1 # has prefix
 SRE_INFO_LITERAL = 2 # entire pattern is literal (given by prefix)
 SRE_INFO_CHARSET = 4 # pattern starts with character from given set
-RE_INFO_CHARSET = 4 # pattern starts with character from given set
diff --git a/Lib/re/_parser.py b/Lib/re/_parser.py
index 4a492b79e84..f3c779340fe 100644
--- a/Lib/re/_parser.py
+++ b/Lib/re/_parser.py
@@ -61,12 +61,11 @@
     "x": SRE_FLAG_VERBOSE,
     # extensions
     "a": SRE_FLAG_ASCII,
-    "t": SRE_FLAG_TEMPLATE,
     "u": SRE_FLAG_UNICODE,
 }
 
 TYPE_FLAGS = SRE_FLAG_ASCII | SRE_FLAG_LOCALE | SRE_FLAG_UNICODE
-GLOBAL_FLAGS = SRE_FLAG_DEBUG | SRE_FLAG_TEMPLATE
+GLOBAL_FLAGS = SRE_FLAG_DEBUG
 
 # Maximal value returned by SubPattern.getwidth().
 # Must be larger than MAXREPEAT, MAXCODE and sys.maxsize.
@@ -781,8 +780,10 @@ def _parse(source, state, verbose, nested, first=False):
                                            source.tell() - start)
                     if char == "=":
                         subpatternappend((ASSERT, (dir, p)))
-                    else:
+                    elif p:
                         subpatternappend((ASSERT_NOT, (dir, p)))
+                    else:
+                        subpatternappend((FAILURE, ()))
                     continue
 
                 elif char == "(":
diff --git a/Lib/sre_constants.py b/Lib/sre_constants.py
index 8543e2bc8c0..fa09d044292 100644
--- a/Lib/sre_constants.py
+++ b/Lib/sre_constants.py
@@ -5,81 +5,3 @@
 
 from re import _constants as _
 globals().update({k: v for k, v in vars(_).items() if k[:2] != '__'})
-
-if __name__ == "__main__":
-    def dump(f, d, typ, int_t, prefix):
-        items = sorted(d)
-        f.write(f"""\
-#[derive(num_enum::TryFromPrimitive, Debug)]
-#[repr({int_t})]
-#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
-pub enum {typ} {{
-""")
-        for item in items:
-            name = str(item).removeprefix(prefix)
-            val = int(item)
-            f.write(f"    {name} = {val},\n")
-        f.write("""\
-}
-""")
-    import sys
-    if len(sys.argv) > 1:
-        constants_file = sys.argv[1]
-    else:
-        import os
-        constants_file = os.path.join(os.path.dirname(__file__), "../../sre-engine/src/constants.rs")
-    with open(constants_file, "w") as f:
-        f.write("""\
-/*
- * Secret Labs' Regular Expression Engine
- *
- * regular expression matching engine
- *
- * NOTE: This file is generated by sre_constants.py.  If you need
- * to change anything in here, edit sre_constants.py and run it.
- *
- * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
- *
- * See the _sre.c file for information on usage and redistribution.
- */
-
-""")
-
-        f.write("use bitflags::bitflags;\n\n");
-
-        f.write("pub const SRE_MAGIC: usize = %d;\n" % MAGIC)
-
-        dump(f, OPCODES, "SreOpcode", "u32", "")
-        dump(f, ATCODES, "SreAtCode", "u32", "AT_")
-        dump(f, CHCODES, "SreCatCode", "u32", "CATEGORY_")
-
-        def bitflags(typ, int_t, prefix, flags):
-            f.write(f"""\
-bitflags! {{
-    pub struct {typ}: {int_t} {{
-""")
-            for name in flags:
-                val = globals()[prefix + name]
-                f.write(f"        const {name} = {val};\n")
-            f.write("""\
-    }
-}
-""")
-
-        bitflags("SreFlag", "u16", "SRE_FLAG_", [
-            "TEMPLATE",
-            "IGNORECASE",
-            "LOCALE",
-            "MULTILINE",
-            "DOTALL",
-            "UNICODE",
-            "VERBOSE",
-            "DEBUG",
-            "ASCII",
-        ])
-
-        bitflags("SreInfo", "u32", "SRE_INFO_", [
-            "PREFIX", "LITERAL", "CHARSET",
-        ])
-
-    print("done")
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 3c0b6af3c6b..7c5bfba41bf 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -1,7 +1,7 @@
 from test.support import (gc_collect, bigmemtest, _2G,
                           cpython_only, captured_stdout,
                           check_disallow_instantiation, is_emscripten, is_wasi,
-                          SHORT_TIMEOUT, requires_resource)
+                          warnings_helper, SHORT_TIMEOUT, CPUStopwatch, requires_resource)
 import locale
 import re
 import string
@@ -47,7 +47,7 @@ def recurse(actual, expect):
         recurse(actual, expect)
 
     def checkPatternError(self, pattern, errmsg, pos=None):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile(pattern)
         with self.subTest(pattern=pattern):
             err = cm.exception
@@ -56,7 +56,7 @@ def checkPatternError(self, pattern, errmsg, pos=None):
                 self.assertEqual(err.pos, pos)
 
     def checkTemplateError(self, pattern, repl, string, errmsg, pos=None):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.sub(pattern, repl, string)
         with self.subTest(pattern=pattern, repl=repl):
             err = cm.exception
@@ -64,8 +64,10 @@ def checkTemplateError(self, pattern, repl, string, errmsg, pos=None):
             if pos is not None:
                 self.assertEqual(err.pos, pos)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_error_is_PatternError_alias(self):
+        assert re.error is re.PatternError
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keep_buffer(self):
         # See bug 14212
         b = bytearray(b'x')
@@ -129,8 +131,10 @@ def test_basic_re_sub(self):
         self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
                          '9.3 -3 24x100y')
-        self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
-                         '9.3 -3 23x99y')
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
+                             '9.3 -3 23x99y')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', count=3),
                          '9.3 -3 23x99y')
 
@@ -154,7 +158,7 @@ def test_basic_re_sub(self):
                          (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)+chr(8)))
         for c in 'cdehijklmopqsuwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
             with self.subTest(c):
-                with self.assertRaises(re.error):
+                with self.assertRaises(re.PatternError):
                     self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
 
         self.assertEqual(re.sub(r'^\s*', 'X', 'test'), 'Xtest')
@@ -237,9 +241,42 @@ def test_sub_template_numeric_escape(self):
 
     def test_qualified_re_sub(self):
         self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
-        self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.sub('a', 'b', 'aaaaa', count=1), 'baaaa')
 
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) got multiple values for argument 'count'"):
+            re.sub('a', 'b', 'aaaaa', 1, count=1)
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) got multiple values for argument 'flags'"):
+            re.sub('a', 'b', 'aaaaa', 1, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) takes from 3 to 5 positional arguments but 6 "
+                r"were given"):
+            re.sub('a', 'b', 'aaaaa', 1, 0, 0)
+
+    def test_misuse_flags(self):
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.sub('a', 'b', 'aaaaa', re.I)
+        self.assertEqual(result, re.sub('a', 'b', 'aaaaa', count=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'count' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.subn("b*", "x", "xyz", re.I)
+        self.assertEqual(result, re.subn("b*", "x", "xyz", count=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'count' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.split(":", ":a:b::c", re.I)
+        self.assertEqual(result, re.split(":", ":a:b::c", maxsplit=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'maxsplit' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+
     def test_bug_114660(self):
         self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello  there'),
                          'hello there')
@@ -346,9 +383,22 @@ def test_re_subn(self):
         self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
         self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
         self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
-        self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.subn("b*", "x", "xyz", count=2), ('xxxyz', 2))
 
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) got multiple values for argument 'count'"):
+            re.subn('a', 'b', 'aaaaa', 1, count=1)
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) got multiple values for argument 'flags'"):
+            re.subn('a', 'b', 'aaaaa', 1, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) takes from 3 to 5 positional arguments but 6 "
+                r"were given"):
+            re.subn('a', 'b', 'aaaaa', 1, 0, 0)
+
     def test_re_split(self):
         for string in ":a:b::c", S(":a:b::c"):
             self.assertTypedEqual(re.split(":", string),
@@ -403,7 +453,9 @@ def test_re_split(self):
                 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
 
     def test_qualified_re_split(self):
-        self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.split(":", ":a:b::c", maxsplit=2), ['', 'a', 'b::c'])
         self.assertEqual(re.split(':', 'a:b:c:d', maxsplit=2), ['a', 'b', 'c:d'])
         self.assertEqual(re.split("(:)", ":a:b::c", maxsplit=2),
@@ -413,6 +465,17 @@ def test_qualified_re_split(self):
         self.assertEqual(re.split("(:*)", ":a:b::c", maxsplit=2),
                          ['', ':', '', '', 'a:b::c'])
 
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) got multiple values for argument 'maxsplit'"):
+            re.split(":", ":a:b::c", 2, maxsplit=2)
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) got multiple values for argument 'flags'"):
+            re.split(":", ":a:b::c", 2, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) takes from 2 to 4 positional arguments but 5 "
+                r"were given"):
+            re.split(":", ":a:b::c", 2, 0, 0)
+
     def test_re_findall(self):
         self.assertEqual(re.findall(":+", "abc"), [])
         for string in "a:b::c:::d", S("a:b::c:::d"):
@@ -663,8 +726,7 @@ def test_groupdict(self):
                                   'first second').groupdict(),
                          {'first':'first', 'second':'second'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expand(self):
         self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
                                   "first second")
@@ -711,8 +773,7 @@ def test_repeat_minmax(self):
         self.checkPatternError(r'x{2,1}',
                                'min repeat greater than max repeat', 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getattr(self):
         self.assertEqual(re.compile("(?i)(a)(b)").pattern, "(?i)(a)(b)")
         self.assertEqual(re.compile("(?i)(a)(b)").flags, re.I | re.U)
@@ -781,13 +842,12 @@ def test_other_escapes(self):
         re.purge()  # for warnings
         for c in 'ceghijklmopqyzCEFGHIJKLMNOPQRTVXY':
             with self.subTest(c):
-                self.assertRaises(re.error, re.compile, '\\%c' % c)
+                self.assertRaises(re.PatternError, re.compile, '\\%c' % c)
         for c in 'ceghijklmopqyzABCEFGHIJKLMNOPQRTVXYZ':
             with self.subTest(c):
-                self.assertRaises(re.error, re.compile, '[\\%c]' % c)
+                self.assertRaises(re.PatternError, re.compile, '[\\%c]' % c)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_unicode_escapes(self):
         # test individual Unicode named escapes
         self.assertTrue(re.match(r'\N{LESS-THAN SIGN}', '<'))
@@ -828,31 +888,137 @@ def test_named_unicode_escapes(self):
         self.checkPatternError(br'\N{LESS-THAN SIGN}', r'bad escape \N', 0)
         self.checkPatternError(br'[\N{LESS-THAN SIGN}]', r'bad escape \N', 1)
 
-    def test_string_boundaries(self):
+    def test_word_boundaries(self):
         # See http://bugs.python.org/issue10713
-        self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
-                         "abc")
+        self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), "abc")
+        self.assertEqual(re.search(r"\b(abc)\b", "abc", re.ASCII).group(1), "abc")
+        self.assertEqual(re.search(br"\b(abc)\b", b"abc").group(1), b"abc")
+        self.assertEqual(re.search(br"\b(abc)\b", b"abc", re.LOCALE).group(1), b"abc")
+        self.assertEqual(re.search(r"\b(ью�)\b", "ью�").group(1), "ью�")
+        self.assertIsNone(re.search(r"\b(ью�)\b", "ью�", re.ASCII))
+        # There's a word boundary between a word and a non-word.
+        self.assertTrue(re.match(r".\b", "a="))
+        self.assertTrue(re.match(r".\b", "a=", re.ASCII))
+        self.assertTrue(re.match(br".\b", b"a="))
+        self.assertTrue(re.match(br".\b", b"a=", re.LOCALE))
+        self.assertTrue(re.match(r".\b", "�="))
+        self.assertIsNone(re.match(r".\b", "�=", re.ASCII))
+        # There's a word boundary between a non-word and a word.
+        self.assertTrue(re.match(r".\b", "=a"))
+        self.assertTrue(re.match(r".\b", "=a", re.ASCII))
+        self.assertTrue(re.match(br".\b", b"=a"))
+        self.assertTrue(re.match(br".\b", b"=a", re.LOCALE))
+        self.assertTrue(re.match(r".\b", "=�"))
+        self.assertIsNone(re.match(r".\b", "=�", re.ASCII))
+        # There is no word boundary inside a word.
+        self.assertIsNone(re.match(r".\b", "ab"))
+        self.assertIsNone(re.match(r".\b", "ab", re.ASCII))
+        self.assertIsNone(re.match(br".\b", b"ab"))
+        self.assertIsNone(re.match(br".\b", b"ab", re.LOCALE))
+        self.assertIsNone(re.match(r".\b", "ю�"))
+        self.assertIsNone(re.match(r".\b", "ю�", re.ASCII))
+        # There is no word boundary between a non-word characters.
+        self.assertIsNone(re.match(r".\b", "=-"))
+        self.assertIsNone(re.match(r".\b", "=-", re.ASCII))
+        self.assertIsNone(re.match(br".\b", b"=-"))
+        self.assertIsNone(re.match(br".\b", b"=-", re.LOCALE))
+        # There is no non-boundary match between a word and a non-word.
+        self.assertIsNone(re.match(r".\B", "a="))
+        self.assertIsNone(re.match(r".\B", "a=", re.ASCII))
+        self.assertIsNone(re.match(br".\B", b"a="))
+        self.assertIsNone(re.match(br".\B", b"a=", re.LOCALE))
+        self.assertIsNone(re.match(r".\B", "�="))
+        self.assertTrue(re.match(r".\B", "�=", re.ASCII))
+        # There is no non-boundary match between a non-word and a word.
+        self.assertIsNone(re.match(r".\B", "=a"))
+        self.assertIsNone(re.match(r".\B", "=a", re.ASCII))
+        self.assertIsNone(re.match(br".\B", b"=a"))
+        self.assertIsNone(re.match(br".\B", b"=a", re.LOCALE))
+        self.assertIsNone(re.match(r".\B", "=�"))
+        self.assertTrue(re.match(r".\B", "=�", re.ASCII))
+        # There's a non-boundary match inside a word.
+        self.assertTrue(re.match(r".\B", "ab"))
+        self.assertTrue(re.match(r".\B", "ab", re.ASCII))
+        self.assertTrue(re.match(br".\B", b"ab"))
+        self.assertTrue(re.match(br".\B", b"ab", re.LOCALE))
+        self.assertTrue(re.match(r".\B", "ю�"))
+        self.assertTrue(re.match(r".\B", "ю�", re.ASCII))
+        # There's a non-boundary match between a non-word characters.
+        self.assertTrue(re.match(r".\B", "=-"))
+        self.assertTrue(re.match(r".\B", "=-", re.ASCII))
+        self.assertTrue(re.match(br".\B", b"=-"))
+        self.assertTrue(re.match(br".\B", b"=-", re.LOCALE))
         # There's a word boundary at the start of a string.
         self.assertTrue(re.match(r"\b", "abc"))
+        self.assertTrue(re.match(r"\b", "abc", re.ASCII))
+        self.assertTrue(re.match(br"\b", b"abc"))
+        self.assertTrue(re.match(br"\b", b"abc", re.LOCALE))
+        self.assertTrue(re.match(r"\b", "ью�"))
+        self.assertIsNone(re.match(r"\b", "ью�", re.ASCII))
+        # There's a word boundary at the end of a string.
+        self.assertTrue(re.fullmatch(r".+\b", "abc"))
+        self.assertTrue(re.fullmatch(r".+\b", "abc", re.ASCII))
+        self.assertTrue(re.fullmatch(br".+\b", b"abc"))
+        self.assertTrue(re.fullmatch(br".+\b", b"abc", re.LOCALE))
+        self.assertTrue(re.fullmatch(r".+\b", "ью�"))
+        self.assertIsNone(re.search(r"\b", "ью�", re.ASCII))
         # A non-empty string includes a non-boundary zero-length match.
-        self.assertTrue(re.search(r"\B", "abc"))
+        self.assertEqual(re.search(r"\B", "abc").span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "abc", re.ASCII).span(), (1, 1))
+        self.assertEqual(re.search(br"\B", b"abc").span(), (1, 1))
+        self.assertEqual(re.search(br"\B", b"abc", re.LOCALE).span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "ью�").span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "ью�", re.ASCII).span(), (0, 0))
         # There is no non-boundary match at the start of a string.
-        self.assertFalse(re.match(r"\B", "abc"))
+        self.assertIsNone(re.match(r"\B", "abc"))
+        self.assertIsNone(re.match(r"\B", "abc", re.ASCII))
+        self.assertIsNone(re.match(br"\B", b"abc"))
+        self.assertIsNone(re.match(br"\B", b"abc", re.LOCALE))
+        self.assertIsNone(re.match(r"\B", "ью�"))
+        self.assertTrue(re.match(r"\B", "ью�", re.ASCII))
+        # There is no non-boundary match at the end of a string.
+        self.assertIsNone(re.fullmatch(r".+\B", "abc"))
+        self.assertIsNone(re.fullmatch(r".+\B", "abc", re.ASCII))
+        self.assertIsNone(re.fullmatch(br".+\B", b"abc"))
+        self.assertIsNone(re.fullmatch(br".+\B", b"abc", re.LOCALE))
+        self.assertIsNone(re.fullmatch(r".+\B", "ью�"))
+        self.assertTrue(re.fullmatch(r".+\B", "ью�", re.ASCII))
         # However, an empty string contains no word boundaries, and also no
         # non-boundaries.
-        self.assertIsNone(re.search(r"\B", ""))
+        self.assertIsNone(re.search(r"\b", ""))
+        self.assertIsNone(re.search(r"\b", "", re.ASCII))
+        self.assertIsNone(re.search(br"\b", b""))
+        self.assertIsNone(re.search(br"\b", b"", re.LOCALE))
         # This one is questionable and different from the perlre behaviour,
         # but describes current behavior.
-        self.assertIsNone(re.search(r"\b", ""))
+        self.assertIsNone(re.search(r"\B", ""))
+        self.assertIsNone(re.search(r"\B", "", re.ASCII))
+        self.assertIsNone(re.search(br"\B", b""))
+        self.assertIsNone(re.search(br"\B", b"", re.LOCALE))
         # A single word-character string has two boundaries, but no
         # non-boundary gaps.
         self.assertEqual(len(re.findall(r"\b", "a")), 2)
+        self.assertEqual(len(re.findall(r"\b", "a", re.ASCII)), 2)
+        self.assertEqual(len(re.findall(br"\b", b"a")), 2)
+        self.assertEqual(len(re.findall(br"\b", b"a", re.LOCALE)), 2)
         self.assertEqual(len(re.findall(r"\B", "a")), 0)
+        self.assertEqual(len(re.findall(r"\B", "a", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\B", b"a")), 0)
+        self.assertEqual(len(re.findall(br"\B", b"a", re.LOCALE)), 0)
         # If there are no words, there are no boundaries
         self.assertEqual(len(re.findall(r"\b", " ")), 0)
+        self.assertEqual(len(re.findall(r"\b", " ", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\b", b" ")), 0)
+        self.assertEqual(len(re.findall(br"\b", b" ", re.LOCALE)), 0)
         self.assertEqual(len(re.findall(r"\b", "   ")), 0)
+        self.assertEqual(len(re.findall(r"\b", "   ", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\b", b"   ")), 0)
+        self.assertEqual(len(re.findall(br"\b", b"   ", re.LOCALE)), 0)
         # Can match around the whitespace.
         self.assertEqual(len(re.findall(r"\B", " ")), 2)
+        self.assertEqual(len(re.findall(r"\B", " ", re.ASCII)), 2)
+        self.assertEqual(len(re.findall(br"\B", b" ")), 2)
+        self.assertEqual(len(re.findall(br"\B", b" ", re.LOCALE)), 2)
 
     def test_bigcharset(self):
         self.assertEqual(re.match("([\u2222\u2223])",
@@ -917,14 +1083,14 @@ def test_lookbehind(self):
         self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(1)c|x))c', 'abc'))
         self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(1)b|x))c', 'abc'))
         # Group used before defined.
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
         self.assertIsNone(re.match(r'(a)b(?<=(?(1)c|x))(c)', 'abc'))
         self.assertTrue(re.match(r'(a)b(?<=(?(1)b|x))(c)', 'abc'))
         # Group defined in the same lookbehind pattern
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)\2)(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)\2)(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
 
     def test_ignore_case(self):
         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
@@ -975,6 +1141,39 @@ def test_ignore_case_set(self):
         self.assertTrue(re.match(br'[19a]', b'a', re.I))
         self.assertTrue(re.match(br'[19a]', b'A', re.I))
         self.assertTrue(re.match(br'[19A]', b'a', re.I))
+        self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I))
+        self.assertTrue(re.match(r'[19\xc7]', '\xe7', re.I))
+        self.assertTrue(re.match(r'[19\xe7]', '\xc7', re.I))
+        self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0450', re.I))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0400', re.I))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010428', re.I))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010400', re.I))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I))
+
+        self.assertTrue(re.match(br'[19A]', b'A', re.I))
+        self.assertTrue(re.match(br'[19a]', b'a', re.I))
+        self.assertTrue(re.match(br'[19a]', b'A', re.I))
+        self.assertTrue(re.match(br'[19A]', b'a', re.I))
+        self.assertTrue(re.match(r'[19A]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[19a]', 'a', re.I|re.A))
+        self.assertTrue(re.match(r'[19a]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[19A]', 'a', re.I|re.A))
+        self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\xc7]', '\xe7', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\xe7]', '\xc7', re.I|re.A))
+        self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I|re.A))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\u0400]', '\u0450', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\u0450]', '\u0400', re.I|re.A))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I|re.A))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\U00010400]', '\U00010428', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\U00010428]', '\U00010400', re.I|re.A))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I|re.A))
 
         # Two different characters have the same lowercase.
         assert 'K'.lower() == '\u212a'.lower() == 'k' # 'K'
@@ -1011,8 +1210,10 @@ def test_ignore_case_range(self):
         self.assertTrue(re.match(br'[9-a]', b'_', re.I))
         self.assertIsNone(re.match(br'[9-A]', b'_', re.I))
         self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
+        self.assertTrue(re.match(r'[\xc0-\xde]', '\xe7', re.I))
         self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
         self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I))
+        self.assertTrue(re.match(r'[\xe0-\xfe]', '\xc7', re.I))
         self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
         self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I))
         self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0400', re.I))
@@ -1023,6 +1224,26 @@ def test_ignore_case_range(self):
         self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I))
         self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I))
 
+        self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I|re.A))
+        self.assertIsNone(re.match(r'[\xc0-\xde]', '\xe7', re.I|re.A))
+        self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I|re.A))
+        self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xc7', re.I|re.A))
+        self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I|re.A))
+        self.assertIsNone(re.match(r'[\u0430-\u045f]', '\u0400', re.I|re.A))
+        self.assertIsNone(re.match(r'[\u0400-\u042f]', '\u0450', re.I|re.A))
+        self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0400', re.I|re.A))
+        self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010428', re.I|re.A))
+        self.assertIsNone(re.match(r'[\U00010428-\U0001044f]', '\U00010400', re.I|re.A))
+        self.assertIsNone(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I|re.A))
+        self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I|re.A))
+
+        self.assertTrue(re.match(r'[N-\x7f]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\x7f]', 'Z', re.I|re.A))
+        self.assertTrue(re.match(r'[N-\uffff]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\uffff]', 'Z', re.I|re.A))
+        self.assertTrue(re.match(r'[N-\U00010000]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\U00010000]', 'Z', re.I|re.A))
+
         # Two different characters have the same lowercase.
         assert 'K'.lower() == '\u212a'.lower() == 'k' # 'K'
         self.assertTrue(re.match(r'[J-M]', '\u212a', re.I))
@@ -1060,47 +1281,76 @@ def test_not_literal(self):
 
     def test_possible_set_operations(self):
         s = bytes(range(128)).decode()
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
             p = re.compile(r'[0-9--1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('-./0123456789'))
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
+            self.assertEqual(re.findall(r'[0-9--2]', s), list('-./0123456789'))
+        self.assertEqual(w.filename, __file__)
+
         self.assertEqual(re.findall(r'[--1]', s), list('-./01'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
             p = re.compile(r'[%--1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list("%&'()*+,-1"))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference ') as w:
             p = re.compile(r'[%--]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list("%&'()*+,-"))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
             p = re.compile(r'[0-9&&1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('&0123456789'))
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
+            self.assertEqual(re.findall(r'[0-8&&1]', s), list('&012345678'))
+        self.assertEqual(w.filename, __file__)
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
             p = re.compile(r'[\d&&1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('&0123456789'))
+
         self.assertEqual(re.findall(r'[&&1]', s), list('&1'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set union ') as w:
             p = re.compile(r'[0-9||a]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789a|'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set union ') as w:
             p = re.compile(r'[\d||a]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789a|'))
+
         self.assertEqual(re.findall(r'[||1]', s), list('1|'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set symmetric difference ') as w:
             p = re.compile(r'[0-9~~1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789~'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set symmetric difference ') as w:
             p = re.compile(r'[\d~~1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789~'))
+
         self.assertEqual(re.findall(r'[~~1]', s), list('1~'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
             p = re.compile(r'[[0-9]|]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789[]'))
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
+            self.assertEqual(re.findall(r'[[0-8]|]', s), list('012345678[]'))
+        self.assertEqual(w.filename, __file__)
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
             p = re.compile(r'[[:digit:]|]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list(':[]dgit'))
 
     def test_search_coverage(self):
@@ -1175,8 +1425,7 @@ def test_pickling(self):
         # current pickle expects the _compile() reconstructor in re module
         from re import _compile
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_copying(self):
         import copy
         p = re.compile(r'(?P<int>\d+)(?:\.(?P<frac>\d*))?')
@@ -1267,8 +1516,8 @@ def test_sre_byte_literals(self):
             self.assertTrue(re.match((r"\x%02x" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"\x%02x0" % i).encode(), bytes([i])+b"0"))
             self.assertTrue(re.match((r"\x%02xz" % i).encode(), bytes([i])+b"z"))
-        self.assertRaises(re.error, re.compile, br"\u1234")
-        self.assertRaises(re.error, re.compile, br"\U00012345")
+        self.assertRaises(re.PatternError, re.compile, br"\u1234")
+        self.assertRaises(re.PatternError, re.compile, br"\U00012345")
         self.assertTrue(re.match(br"\0", b"\000"))
         self.assertTrue(re.match(br"\08", b"\0008"))
         self.assertTrue(re.match(br"\01", b"\001"))
@@ -1290,8 +1539,8 @@ def test_sre_byte_class_literals(self):
             self.assertTrue(re.match((r"[\x%02x]" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"[\x%02x0]" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"[\x%02xz]" % i).encode(), bytes([i])))
-        self.assertRaises(re.error, re.compile, br"[\u1234]")
-        self.assertRaises(re.error, re.compile, br"[\U00012345]")
+        self.assertRaises(re.PatternError, re.compile, br"[\u1234]")
+        self.assertRaises(re.PatternError, re.compile, br"[\U00012345]")
         self.checkPatternError(br"[\567]",
                                r'octal escape value \567 outside of '
                                r'range 0-0o377', 1)
@@ -1484,8 +1733,7 @@ def test_bug_817234(self):
         self.assertEqual(next(iter).span(), (4, 4))
         self.assertRaises(StopIteration, next, iter)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_6561(self):
         # '\d' should match characters in Unicode category 'Nd'
         # (Number, Decimal Digit), but not those in 'Nl' (Number,
@@ -1507,10 +1755,12 @@ def test_bug_6561(self):
         for x in not_decimal_digits:
             self.assertIsNone(re.match(r'^\d$', x))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON a = array.array(typecode)\n ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)  # gh-80480 array('u')
     def test_empty_array(self):
         # SF buf 1647541
         import array
-        for typecode in 'bBuhHiIlLfd':
+        for typecode in 'bBhuwHiIlLfd':
             a = array.array(typecode)
             self.assertIsNone(re.compile(b"bla").match(a))
             self.assertEqual(re.compile(b"").match(a).groups(), ())
@@ -1625,11 +1875,11 @@ def test_ascii_and_unicode_flag(self):
             self.assertIsNone(pat.match(b'\xe0'))
         # Incompatibilities
         self.assertRaises(ValueError, re.compile, br'\w', re.UNICODE)
-        self.assertRaises(re.error, re.compile, br'(?u)\w')
+        self.assertRaises(re.PatternError, re.compile, br'(?u)\w')
         self.assertRaises(ValueError, re.compile, r'\w', re.UNICODE | re.ASCII)
         self.assertRaises(ValueError, re.compile, r'(?u)\w', re.ASCII)
         self.assertRaises(ValueError, re.compile, r'(?a)\w', re.UNICODE)
-        self.assertRaises(re.error, re.compile, r'(?au)\w')
+        self.assertRaises(re.PatternError, re.compile, r'(?au)\w')
 
     def test_locale_flag(self):
         enc = locale.getpreferredencoding()
@@ -1670,11 +1920,11 @@ def test_locale_flag(self):
             self.assertIsNone(pat.match(bletter))
         # Incompatibilities
         self.assertRaises(ValueError, re.compile, '', re.LOCALE)
-        self.assertRaises(re.error, re.compile, '(?L)')
+        self.assertRaises(re.PatternError, re.compile, '(?L)')
         self.assertRaises(ValueError, re.compile, b'', re.LOCALE | re.ASCII)
         self.assertRaises(ValueError, re.compile, b'(?L)', re.ASCII)
         self.assertRaises(ValueError, re.compile, b'(?a)', re.LOCALE)
-        self.assertRaises(re.error, re.compile, b'(?aL)')
+        self.assertRaises(re.PatternError, re.compile, b'(?aL)')
 
     def test_scoped_flags(self):
         self.assertTrue(re.match(r'(?i:a)b', 'Ab'))
@@ -1854,8 +2104,7 @@ def test_issue17998(self):
                 self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
                                  [b'xyz'], msg=pattern)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_match_repr(self):
         for string in '[abracadabra]', S('[abracadabra]'):
             m = re.search(r'(.+)(.*?)\1', string)
@@ -1935,6 +2184,7 @@ def test_bug_20998(self):
         # with ignore case.
         self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))\n AssertionError: None is not true
     @unittest.skipIf(
         is_emscripten or is_wasi,
         "musl libc issue on Emscripten/WASI, bpo-46390"
@@ -2012,7 +2262,7 @@ def test_locale_compiled(self):
         self.assertIsNone(p4.match(b'\xc5\xc5'))
 
     def test_error(self):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile('(\u20ac))')
         err = cm.exception
         self.assertIsInstance(err.pattern, str)
@@ -2024,14 +2274,14 @@ def test_error(self):
         self.assertIn(' at position 3', str(err))
         self.assertNotIn(' at position 3', err.msg)
         # Bytes pattern
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile(b'(\xa4))')
         err = cm.exception
         self.assertIsInstance(err.pattern, bytes)
         self.assertEqual(err.pattern, b'(\xa4))')
         self.assertEqual(err.pos, 3)
         # Multiline pattern
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile("""
                 (
                     abc
@@ -2231,24 +2481,24 @@ def test_bug_40736(self):
         with self.assertRaisesRegex(TypeError, "got 'type'"):
             re.search("x*", type)
 
-    @unittest.skip("TODO: RUSTPYTHON: flaky, improve perf")
+    # gh-117594: The test is not slow by itself, but it relies on
+    # the absolute computation time and can fail on very slow computers.
+    @unittest.skip('TODO: RUSTPYTHON; flaky, improve perf')
     @requires_resource('cpu')
     def test_search_anchor_at_beginning(self):
         s = 'x'*10**7
-        start = time.perf_counter()
-        for p in r'\Ay', r'^y':
-            self.assertIsNone(re.search(p, s))
-            self.assertEqual(re.split(p, s), [s])
-            self.assertEqual(re.findall(p, s), [])
-            self.assertEqual(list(re.finditer(p, s)), [])
-            self.assertEqual(re.sub(p, '', s), s)
-        t = time.perf_counter() - start
+        with CPUStopwatch() as stopwatch:
+            for p in r'\Ay', r'^y':
+                self.assertIsNone(re.search(p, s))
+                self.assertEqual(re.split(p, s), [s])
+                self.assertEqual(re.findall(p, s), [])
+                self.assertEqual(list(re.finditer(p, s)), [])
+                self.assertEqual(re.sub(p, '', s), s)
         # Without optimization it takes 1 second on my computer.
         # With optimization -- 0.0003 seconds.
-        self.assertLess(t, 0.2)
+        self.assertLess(stopwatch.seconds, 0.1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_possessive_quantifiers(self):
         """Test Possessive Quantifiers
         Test quantifiers of the form @+ for some repetition operator @,
@@ -2288,8 +2538,7 @@ def test_possessive_quantifiers(self):
         self.assertIsNone(re.match("^x{}+$", "xxx"))
         self.assertTrue(re.match("^x{}+$", "x{}"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_possessive_quantifiers(self):
         self.assertTrue(re.fullmatch(r'a++', 'a'))
         self.assertTrue(re.fullmatch(r'a*+', 'a'))
@@ -2342,8 +2591,7 @@ def test_atomic_grouping(self):
         self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
         self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_atomic_grouping(self):
         self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
         self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
@@ -2382,39 +2630,12 @@ def test_findall_atomic_grouping(self):
         self.assertEqual(re.findall(r'(?>(?:ab)?)', 'ababc'), ['ab', 'ab', '', ''])
         self.assertEqual(re.findall(r'(?>(?:ab){1,3})', 'ababc'), ['abab'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_gh91616(self):
         self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\Z', "a.txt")) # reproducer
         self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\Z', "a.txt"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_template_function_and_flag_is_deprecated(self):
-        with self.assertWarns(DeprecationWarning) as cm:
-            template_re1 = re.template(r'a')
-        self.assertIn('re.template()', str(cm.warning))
-        self.assertIn('is deprecated', str(cm.warning))
-        self.assertIn('function', str(cm.warning))
-        self.assertNotIn('flag', str(cm.warning))
-
-        with self.assertWarns(DeprecationWarning) as cm:
-            # we deliberately use more flags here to test that that still
-            # triggers the warning
-            # if paranoid, we could test multiple different combinations,
-            # but it's probably not worth it
-            template_re2 = re.compile(r'a', flags=re.TEMPLATE|re.UNICODE)
-        self.assertIn('re.TEMPLATE', str(cm.warning))
-        self.assertIn('is deprecated', str(cm.warning))
-        self.assertIn('flag', str(cm.warning))
-        self.assertNotIn('function', str(cm.warning))
-
-        # while deprecated, is should still function
-        self.assertEqual(template_re1, template_re2)
-        self.assertTrue(template_re1.match('ahoy'))
-        self.assertFalse(template_re1.match('nope'))
-
-    def test_bug_gh106052(self):
+    def test_bug_gh100061(self):
         # gh-100061
         self.assertEqual(re.match('(?>(?:.(?!D))+)', 'ABCDE').span(), (0, 2))
         self.assertEqual(re.match('(?:.(?!D))++', 'ABCDE').span(), (0, 2))
@@ -2434,8 +2655,13 @@ def test_bug_gh106052(self):
         self.assertEqual(re.match("(?>(?:ab?c){1,3})", "aca").span(), (0, 2))
         self.assertEqual(re.match("(?:ab?c){1,3}+", "aca").span(), (0, 2))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipUnless(sys.platform == 'linux', 'multiprocessing related issue')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))\n AssertionError: Tuples differ: ('x', 'x') != ('z', 'x')
+    def test_bug_gh101955(self):
+        # Possessive quantifier with nested alternative with capture groups
+        self.assertEqual(re.match('((x)|y|z)*+', 'xyz').groups(), ('z', 'x'))
+        self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))
+        self.assertEqual(re.match('((x)|y|z){3,}+', 'xyz').groups(), ('z', 'x'))
+
     @unittest.skipIf(multiprocessing is None, 'test requires multiprocessing')
     def test_regression_gh94675(self):
         pattern = re.compile(r'(?<=[({}])(((//[^\n]*)?[\n])([\000-\040])*)*'
@@ -2456,6 +2682,54 @@ def test_regression_gh94675(self):
                 p.terminate()
                 p.join()
 
+    def test_fail(self):
+        self.assertEqual(re.search(r'12(?!)|3', '123')[0], '3')
+
+    def test_character_set_any(self):
+        # The union of complementary character sets matches any character
+        # and is equivalent to "(?s:.)".
+        s = '1x\n'
+        for p in r'[\s\S]', r'[\d\D]', r'[\w\W]', r'[\S\s]', r'\s|\S':
+            with self.subTest(pattern=p):
+                self.assertEqual(re.findall(p, s), list(s))
+                self.assertEqual(re.fullmatch('(?:' + p + ')+', s).group(), s)
+
+    def test_character_set_none(self):
+        # Negation of the union of complementary character sets does not match
+        # any character.
+        s = '1x\n'
+        for p in r'[^\s\S]', r'[^\d\D]', r'[^\w\W]', r'[^\S\s]':
+            with self.subTest(pattern=p):
+                self.assertIsNone(re.search(p, s))
+                self.assertIsNone(re.search('(?s:.)' + p, s))
+
+    def check_interrupt(self, pattern, string, maxcount):
+        class Interrupt(Exception):
+            pass
+        p = re.compile(pattern)
+        for n in range(maxcount):
+            try:
+                p._fail_after(n, Interrupt)
+                p.match(string)
+                return n
+            except Interrupt:
+                pass
+            finally:
+                p._fail_after(-1, None)
+
+    @unittest.skipUnless(hasattr(re.Pattern, '_fail_after'), 'requires debug build')
+    def test_memory_leaks(self):
+        self.check_interrupt(r'(.)*:', 'abc:', 100)
+        self.check_interrupt(r'([^:])*?:', 'abc:', 100)
+        self.check_interrupt(r'([^:])*+:', 'abc:', 100)
+        self.check_interrupt(r'(.){2,4}:', 'abc:', 100)
+        self.check_interrupt(r'([^:]){2,4}?:', 'abc:', 100)
+        self.check_interrupt(r'([^:]){2,4}+:', 'abc:', 100)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_template_function_and_flag_is_deprecated(self):
+        return super().test_template_function_and_flag_is_deprecated()
+
 
 def get_debug_out(pat):
     with captured_stdout() as out:
@@ -2590,8 +2864,7 @@ def test_inline_flags(self):
         self.check('(?i)pattern',
                    "re.compile('(?i)pattern', re.IGNORECASE)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unknown_flags(self):
         self.check_flags('random pattern', 0x123000,
                          "re.compile('random pattern', 0x123000)")
@@ -2626,8 +2899,6 @@ def test_long_pattern(self):
         self.assertEqual(r[:30], "re.compile('Very long long lon")
         self.assertEqual(r[-16:], ", re.IGNORECASE)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_flags_repr(self):
         self.assertEqual(repr(re.I), "re.IGNORECASE")
         self.assertEqual(repr(re.I|re.S|re.X),
@@ -2636,11 +2907,11 @@ def test_flags_repr(self):
                          "re.IGNORECASE|re.DOTALL|re.VERBOSE|0x100000")
         self.assertEqual(
                 repr(~re.I),
-                "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.TEMPLATE|re.DEBUG")
+                "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.DEBUG|0x1")
         self.assertEqual(repr(~(re.I|re.S|re.X)),
-                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG")
+                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0x1")
         self.assertEqual(repr(~(re.I|re.S|re.X|(1<<20))),
-                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG|0xffe00")
+                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0xffe01")
 
 
 class ImplementationTest(unittest.TestCase):
@@ -2681,8 +2952,7 @@ def test_disallow_instantiation(self):
         pat = re.compile("")
         check_disallow_instantiation(self, type(pat.scanner("")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_deprecated_modules(self):
         deprecated = {
             'sre_compile': ['compile', 'error',
@@ -2813,7 +3083,7 @@ def test_re_tests(self):
 
             with self.subTest(pattern=pattern, string=s):
                 if outcome == SYNTAX_ERROR:  # Expected a syntax error
-                    with self.assertRaises(re.error):
+                    with self.assertRaises(re.PatternError):
                         re.compile(pattern)
                     continue
 
diff --git a/crates/sre_engine/src/constants.rs b/crates/sre_engine/src/constants.rs
index 9fe792ce17d..d90c08cb374 100644
--- a/crates/sre_engine/src/constants.rs
+++ b/crates/sre_engine/src/constants.rs
@@ -3,17 +3,17 @@
  *
  * regular expression matching engine
  *
- * NOTE: This file is generated by sre_constants.py.  If you need
- * to change anything in here, edit sre_constants.py and run it.
+ * Auto-generated by scripts/generate_sre_constants.py from
+ * Lib/re/_constants.py.
  *
  * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
  *
- * See the _sre.c file for information on usage and redistribution.
+ * See the sre.c file for information on usage and redistribution.
  */
 
 use bitflags::bitflags;
 
-pub const SRE_MAGIC: usize = 20221023;
+pub const SRE_MAGIC: usize = 20230612;
 #[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -62,6 +62,7 @@ pub enum SreOpcode {
     NOT_LITERAL_UNI_IGNORE = 41,
     RANGE_UNI_IGNORE = 42,
 }
+
 #[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -79,6 +80,7 @@ pub enum SreAtCode {
     UNI_BOUNDARY = 10,
     UNI_NON_BOUNDARY = 11,
 }
+
 #[derive(num_enum::TryFromPrimitive, Debug)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -102,10 +104,10 @@ pub enum SreCatCode {
     UNI_LINEBREAK = 16,
     UNI_NOT_LINEBREAK = 17,
 }
+
 bitflags! {
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
     pub struct SreFlag: u16 {
-        const TEMPLATE = 1;
         const IGNORECASE = 2;
         const LOCALE = 4;
         const MULTILINE = 8;
@@ -116,6 +118,7 @@ bitflags! {
         const ASCII = 256;
     }
 }
+
 bitflags! {
     pub struct SreInfo: u32 {
         const PREFIX = 1;
diff --git a/crates/vm/src/stdlib/sre.rs b/crates/vm/src/stdlib/sre.rs
index 33f884e1adc..04ff0695b6b 100644
--- a/crates/vm/src/stdlib/sre.rs
+++ b/crates/vm/src/stdlib/sre.rs
@@ -554,7 +554,6 @@ mod _sre {
         #[inline]
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             let flag_names = [
-                ("re.TEMPLATE", SreFlag::TEMPLATE),
                 ("re.IGNORECASE", SreFlag::IGNORECASE),
                 ("re.LOCALE", SreFlag::LOCALE),
                 ("re.MULTILINE", SreFlag::MULTILINE),
diff --git a/scripts/generate_sre_constants.py b/scripts/generate_sre_constants.py
new file mode 100644
index 00000000000..8e4091d2eb9
--- /dev/null
+++ b/scripts/generate_sre_constants.py
@@ -0,0 +1,139 @@
+#! /usr/bin/env python3
+# This script generates crates/sre_engine/src/constants.rs from Lib/re/_constants.py.
+
+SCRIPT_NAME = "scripts/generate_sre_constants.py"
+
+
+def update_file(file, content):
+    try:
+        with open(file, "r") as fobj:
+            if fobj.read() == content:
+                return False
+    except (OSError, ValueError):
+        pass
+    with open(file, "w") as fobj:
+        fobj.write(content)
+    return True
+
+
+sre_constants_header = f"""\
+/*
+ * Secret Labs' Regular Expression Engine
+ *
+ * regular expression matching engine
+ *
+ * Auto-generated by {SCRIPT_NAME} from
+ * Lib/re/_constants.py.
+ *
+ * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
+ *
+ * See the sre.c file for information on usage and redistribution.
+ */
+
+"""
+
+
+def dump_enum(d, enum_name, derives, strip_prefix=""):
+    """Generate Rust enum definitions from a Python dictionary.
+
+    Args:
+        d (list): The list containing the enum variants.
+        enum_name (str): The name of the enum to generate.
+        derives (str): The derive attributes to include.
+        strip_prefix (str, optional): A prefix to strip from the variant names. Defaults to "".
+
+    Returns:
+        list: A list of strings representing the enum definition.
+    """
+    items = sorted(d)
+    print(f"items is {items}")
+    content = [f"{derives}\n"]
+    content.append("#[repr(u32)]\n")
+    content.append("#[allow(non_camel_case_types, clippy::upper_case_acronyms)]\n")
+    content.append(f"pub enum {enum_name} {{\n")
+    for i, item in enumerate(items):
+        name = str(item).removeprefix(strip_prefix)
+        content.append(f"    {name} = {i},\n")
+    content.append("}\n\n")
+    return content
+
+
+def dump_bitflags(d, prefix, derives, struct_name, int_t):
+    """Generate Rust bitflags definitions from a Python dictionary.
+
+    Args:
+        d (dict): The dictionary containing the bitflag variants.
+        prefix (str): The prefix to strip from the variant names.
+        derives (str): The derive attributes to include.
+        struct_name (str): The name of the struct to generate.
+        int_t (str): The integer type to use for the bitflags.
+
+    Returns:
+        list: A list of strings representing the bitflags definition.
+    """
+    items = [(value, name) for name, value in d.items() if name.startswith(prefix)]
+    content = ["bitflags! {\n"]
+    content.append(f"{derives}\n") if derives else None
+    content.append(f"    pub struct {struct_name}: {int_t} {{\n")
+    for value, name in sorted(items):
+        name = str(name).removeprefix(prefix)
+        content.append(f"        const {name} = {value};\n")
+    content.append("    }\n")
+    content.append("}\n\n")
+    return content
+
+
+def main(
+    infile="Lib/re/_constants.py",
+    outfile_constants="crates/sre_engine/src/constants.rs",
+):
+    ns = {}
+    with open(infile) as fp:
+        code = fp.read()
+    exec(code, ns)
+
+    content = [sre_constants_header]
+    content.append("use bitflags::bitflags;\n\n")
+    content.append(f"pub const SRE_MAGIC: usize = {ns['MAGIC']};\n")
+    content.extend(
+        dump_enum(
+            ns["OPCODES"],
+            "SreOpcode",
+            "#[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]",
+        )
+    )
+    content.extend(
+        dump_enum(
+            ns["ATCODES"],
+            "SreAtCode",
+            "#[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]",
+            "AT_",
+        )
+    )
+    content.extend(
+        dump_enum(
+            ns["CHCODES"],
+            "SreCatCode",
+            "#[derive(num_enum::TryFromPrimitive, Debug)]",
+            "CATEGORY_",
+        )
+    )
+
+    content.extend(
+        dump_bitflags(
+            ns,
+            "SRE_FLAG_",
+            "#[derive(Debug, PartialEq, Eq, Clone, Copy)]",
+            "SreFlag",
+            "u16",
+        )
+    )
+    content.extend(dump_bitflags(ns, "SRE_INFO_", "", "SreInfo", "u32"))
+
+    update_file(outfile_constants, "".join(content))
+
+
+if __name__ == "__main__":
+    import sys
+
+    main(*sys.argv[1:])

From 75838e567ea74eeb2aa4e45e633047f6326b9939 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Mon, 5 Jan 2026 00:38:04 -0500
Subject: [PATCH 176/418] Update pty + tty + associated libraries - v3.13.10
 (#6630)

* Update tty + added the test from v3.13.10

* Updated pty.py + test
---
 Lib/pty.py               |  80 +++++++++++-------
 Lib/test/test_builtin.py |   4 +
 Lib/test/test_pty.py     | 177 ++++++++++++++++++---------------------
 Lib/test/test_tty.py     |  96 +++++++++++++++++++++
 Lib/tty.py               |  69 +++++++++++----
 5 files changed, 286 insertions(+), 140 deletions(-)
 create mode 100644 Lib/test/test_tty.py

diff --git a/Lib/pty.py b/Lib/pty.py
index 8d8ce40df54..1d97994abef 100644
--- a/Lib/pty.py
+++ b/Lib/pty.py
@@ -40,6 +40,9 @@ def master_open():
     Open a pty master and return the fd, and the filename of the slave end.
     Deprecated, use openpty() instead."""
 
+    import warnings
+    warnings.warn("Use pty.openpty() instead.", DeprecationWarning, stacklevel=2)  # Remove API in 3.14
+
     try:
         master_fd, slave_fd = os.openpty()
     except (AttributeError, OSError):
@@ -69,6 +72,9 @@ def slave_open(tty_name):
     opened filedescriptor.
     Deprecated, use openpty() instead."""
 
+    import warnings
+    warnings.warn("Use pty.openpty() instead.", DeprecationWarning, stacklevel=2)  # Remove API in 3.14
+
     result = os.open(tty_name, os.O_RDWR)
     try:
         from fcntl import ioctl, I_PUSH
@@ -101,32 +107,14 @@ def fork():
     master_fd, slave_fd = openpty()
     pid = os.fork()
     if pid == CHILD:
-        # Establish a new session.
-        os.setsid()
         os.close(master_fd)
-
-        # Slave becomes stdin/stdout/stderr of child.
-        os.dup2(slave_fd, STDIN_FILENO)
-        os.dup2(slave_fd, STDOUT_FILENO)
-        os.dup2(slave_fd, STDERR_FILENO)
-        if slave_fd > STDERR_FILENO:
-            os.close(slave_fd)
-
-        # Explicitly open the tty to make it become a controlling tty.
-        tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
-        os.close(tmp_fd)
+        os.login_tty(slave_fd)
     else:
         os.close(slave_fd)
 
     # Parent and child process.
     return pid, master_fd
 
-def _writen(fd, data):
-    """Write all the data to a descriptor."""
-    while data:
-        n = os.write(fd, data)
-        data = data[n:]
-
 def _read(fd):
     """Default read function."""
     return os.read(fd, 1024)
@@ -136,9 +124,42 @@ def _copy(master_fd, master_read=_read, stdin_read=_read):
     Copies
             pty master -> standard output   (master_read)
             standard input -> pty master    (stdin_read)"""
-    fds = [master_fd, STDIN_FILENO]
-    while fds:
-        rfds, _wfds, _xfds = select(fds, [], [])
+    if os.get_blocking(master_fd):
+        # If we write more than tty/ndisc is willing to buffer, we may block
+        # indefinitely. So we set master_fd to non-blocking temporarily during
+        # the copy operation.
+        os.set_blocking(master_fd, False)
+        try:
+            _copy(master_fd, master_read=master_read, stdin_read=stdin_read)
+        finally:
+            # restore blocking mode for backwards compatibility
+            os.set_blocking(master_fd, True)
+        return
+    high_waterlevel = 4096
+    stdin_avail = master_fd != STDIN_FILENO
+    stdout_avail = master_fd != STDOUT_FILENO
+    i_buf = b''
+    o_buf = b''
+    while 1:
+        rfds = []
+        wfds = []
+        if stdin_avail and len(i_buf) < high_waterlevel:
+            rfds.append(STDIN_FILENO)
+        if stdout_avail and len(o_buf) < high_waterlevel:
+            rfds.append(master_fd)
+        if stdout_avail and len(o_buf) > 0:
+            wfds.append(STDOUT_FILENO)
+        if len(i_buf) > 0:
+            wfds.append(master_fd)
+
+        rfds, wfds, _xfds = select(rfds, wfds, [])
+
+        if STDOUT_FILENO in wfds:
+            try:
+                n = os.write(STDOUT_FILENO, o_buf)
+                o_buf = o_buf[n:]
+            except OSError:
+                stdout_avail = False
 
         if master_fd in rfds:
             # Some OSes signal EOF by returning an empty byte string,
@@ -150,19 +171,22 @@ def _copy(master_fd, master_read=_read, stdin_read=_read):
             if not data:  # Reached EOF.
                 return    # Assume the child process has exited and is
                           # unreachable, so we clean up.
-            else:
-                os.write(STDOUT_FILENO, data)
+            o_buf += data
+
+        if master_fd in wfds:
+            n = os.write(master_fd, i_buf)
+            i_buf = i_buf[n:]
 
-        if STDIN_FILENO in rfds:
+        if stdin_avail and STDIN_FILENO in rfds:
             data = stdin_read(STDIN_FILENO)
             if not data:
-                fds.remove(STDIN_FILENO)
+                stdin_avail = False
             else:
-                _writen(master_fd, data)
+                i_buf += data
 
 def spawn(argv, master_read=_read, stdin_read=_read):
     """Create a spawned process."""
-    if type(argv) == type(''):
+    if isinstance(argv, str):
         argv = (argv,)
     sys.audit('pty.spawn', argv)
 
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 7d8c7a5e016..55585d9ef84 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -2241,6 +2241,7 @@ def child(wpipe):
             expected = terminal_input.decode(sys.stdin.encoding)  # what else?
         self.assertEqual(input_result, expected)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_input_tty(self):
         # Test input() functionality when wired to a tty (the code path
         # is different and invokes GNU readline if available).
@@ -2257,17 +2258,20 @@ def skip_if_readline(self):
             self.skipTest("the readline module is loaded")
 
     @unittest.skipUnless(hasattr(sys.stdin, 'detach'), 'TODO: RustPython: requires detach function in TextIOWrapper')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_tty_non_ascii(self):
         self.skip_if_readline()
         # Check stdin/stdout encoding is used when invoking PyOS_Readline()
         self.check_input_tty("prompté", b"quux\xe9", "utf-8")
 
     @unittest.skipUnless(hasattr(sys.stdin, 'detach'), 'TODO: RustPython: requires detach function in TextIOWrapper')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_tty_non_ascii_unicode_errors(self):
         self.skip_if_readline()
         # Check stdin/stdout error handler is used when invoking PyOS_Readline()
         self.check_input_tty("prompté", b"quux\xe9", "ascii")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_no_stdout_fileno(self):
         # Issue #24402: If stdin is the original terminal but stdout.fileno()
         # fails, do not use the original stdout file descriptor
diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py
index b1c1f6abffb..6d3c47195c6 100644
--- a/Lib/test/test_pty.py
+++ b/Lib/test/test_pty.py
@@ -1,10 +1,16 @@
-from test import support
-from test.support import verbose, reap_children
+import unittest
+from test.support import (
+    is_android, is_apple_mobile, is_emscripten, is_wasi, reap_children, verbose
+)
 from test.support.import_helper import import_module
+from test.support.os_helper import TESTFN, unlink
 
 # Skip these tests if termios is not available
 import_module('termios')
 
+if is_android or is_apple_mobile or is_emscripten or is_wasi:
+    raise unittest.SkipTest("pty is not available on this platform")
+
 import errno
 import os
 import pty
@@ -14,21 +20,12 @@
 import signal
 import socket
 import io # readline
-import unittest
-
-import struct
-import fcntl
 import warnings
 
 TEST_STRING_1 = b"I wish to buy a fish license.\n"
 TEST_STRING_2 = b"For my pet fish, Eric.\n"
 
-try:
-    _TIOCGWINSZ = tty.TIOCGWINSZ
-    _TIOCSWINSZ = tty.TIOCSWINSZ
-    _HAVE_WINSZ = True
-except AttributeError:
-    _HAVE_WINSZ = False
+_HAVE_WINSZ = hasattr(tty, "TIOCGWINSZ") and hasattr(tty, "TIOCSWINSZ")
 
 if verbose:
     def debug(msg):
@@ -82,90 +79,78 @@ def expectedFailureIfStdinIsTTY(fun):
         pass
     return fun
 
-def _get_term_winsz(fd):
-    s = struct.pack("HHHH", 0, 0, 0, 0)
-    return fcntl.ioctl(fd, _TIOCGWINSZ, s)
 
-def _set_term_winsz(fd, winsz):
-    fcntl.ioctl(fd, _TIOCSWINSZ, winsz)
+def write_all(fd, data):
+    written = os.write(fd, data)
+    if written != len(data):
+        # gh-73256, gh-110673: It should never happen, but check just in case
+        raise Exception(f"short write: os.write({fd}, {len(data)} bytes) "
+                        f"wrote {written} bytes")
 
 
 # Marginal testing of pty suite. Cannot do extensive 'do or fail' testing
 # because pty code is not too portable.
 class PtyTest(unittest.TestCase):
     def setUp(self):
-        old_alarm = signal.signal(signal.SIGALRM, self.handle_sig)
-        self.addCleanup(signal.signal, signal.SIGALRM, old_alarm)
-
         old_sighup = signal.signal(signal.SIGHUP, self.handle_sighup)
         self.addCleanup(signal.signal, signal.SIGHUP, old_sighup)
 
-        # isatty() and close() can hang on some platforms. Set an alarm
-        # before running the test to make sure we don't hang forever.
-        self.addCleanup(signal.alarm, 0)
-        signal.alarm(10)
-
-        # Save original stdin window size
-        self.stdin_rows = None
-        self.stdin_cols = None
+        # Save original stdin window size.
+        self.stdin_dim = None
         if _HAVE_WINSZ:
             try:
-                stdin_dim = os.get_terminal_size(pty.STDIN_FILENO)
-                self.stdin_rows = stdin_dim.lines
-                self.stdin_cols = stdin_dim.columns
-                old_stdin_winsz = struct.pack("HHHH", self.stdin_rows,
-                                              self.stdin_cols, 0, 0)
-                self.addCleanup(_set_term_winsz, pty.STDIN_FILENO, old_stdin_winsz)
-            except OSError:
+                self.stdin_dim = tty.tcgetwinsize(pty.STDIN_FILENO)
+                self.addCleanup(tty.tcsetwinsize, pty.STDIN_FILENO,
+                                self.stdin_dim)
+            except tty.error:
                 pass
 
-    def handle_sig(self, sig, frame):
-        self.fail("isatty hung")
-
     @staticmethod
     def handle_sighup(signum, frame):
         pass
 
     @expectedFailureIfStdinIsTTY
+    @unittest.skip('TODO: RUSTPYTHON; "Not runnable. tty.tcgetwinsize" is required to setUp')
     def test_openpty(self):
         try:
             mode = tty.tcgetattr(pty.STDIN_FILENO)
         except tty.error:
-            # not a tty or bad/closed fd
+            # Not a tty or bad/closed fd.
             debug("tty.tcgetattr(pty.STDIN_FILENO) failed")
             mode = None
 
-        new_stdin_winsz = None
-        if self.stdin_rows is not None and self.stdin_cols is not None:
+        new_dim = None
+        if self.stdin_dim:
             try:
                 # Modify pty.STDIN_FILENO window size; we need to
                 # check if pty.openpty() is able to set pty slave
                 # window size accordingly.
-                debug("Setting pty.STDIN_FILENO window size")
-                debug(f"original size: (rows={self.stdin_rows}, cols={self.stdin_cols})")
-                target_stdin_rows = self.stdin_rows + 1
-                target_stdin_cols = self.stdin_cols + 1
-                debug(f"target size: (rows={target_stdin_rows}, cols={target_stdin_cols})")
-                target_stdin_winsz = struct.pack("HHHH", target_stdin_rows,
-                                                 target_stdin_cols, 0, 0)
-                _set_term_winsz(pty.STDIN_FILENO, target_stdin_winsz)
+                debug("Setting pty.STDIN_FILENO window size.")
+                debug(f"original size: (row, col) = {self.stdin_dim}")
+                target_dim = (self.stdin_dim[0] + 1, self.stdin_dim[1] + 1)
+                debug(f"target size: (row, col) = {target_dim}")
+                tty.tcsetwinsize(pty.STDIN_FILENO, target_dim)
 
                 # Were we able to set the window size
                 # of pty.STDIN_FILENO successfully?
-                new_stdin_winsz = _get_term_winsz(pty.STDIN_FILENO)
-                self.assertEqual(new_stdin_winsz, target_stdin_winsz,
+                new_dim = tty.tcgetwinsize(pty.STDIN_FILENO)
+                self.assertEqual(new_dim, target_dim,
                                  "pty.STDIN_FILENO window size unchanged")
-            except OSError:
-                warnings.warn("Failed to set pty.STDIN_FILENO window size")
+            except OSError as e:
+                logging.getLogger(__name__).warning(
+                    "Failed to set pty.STDIN_FILENO window size.", exc_info=e,
+                )
                 pass
 
         try:
             debug("Calling pty.openpty()")
             try:
-                master_fd, slave_fd = pty.openpty(mode, new_stdin_winsz)
+                master_fd, slave_fd, slave_name = pty.openpty(mode, new_dim,
+                                                              True)
             except TypeError:
                 master_fd, slave_fd = pty.openpty()
-            debug(f"Got master_fd '{master_fd}', slave_fd '{slave_fd}'")
+                slave_name = None
+            debug(f"Got {master_fd=}, {slave_fd=}, {slave_name=}")
         except OSError:
             # " An optional feature could not be imported " ... ?
             raise unittest.SkipTest("Pseudo-terminals (seemingly) not functional.")
@@ -181,8 +166,8 @@ def test_openpty(self):
         if mode:
             self.assertEqual(tty.tcgetattr(slave_fd), mode,
                              "openpty() failed to set slave termios")
-        if new_stdin_winsz:
-            self.assertEqual(_get_term_winsz(slave_fd), new_stdin_winsz,
+        if new_dim:
+            self.assertEqual(tty.tcgetwinsize(slave_fd), new_dim,
                              "openpty() failed to set slave window size")
 
         # Ensure the fd is non-blocking in case there's nothing to read.
@@ -200,18 +185,18 @@ def test_openpty(self):
             os.set_blocking(master_fd, blocking)
 
         debug("Writing to slave_fd")
-        os.write(slave_fd, TEST_STRING_1)
+        write_all(slave_fd, TEST_STRING_1)
         s1 = _readline(master_fd)
         self.assertEqual(b'I wish to buy a fish license.\n',
                          normalize_output(s1))
 
         debug("Writing chunked output")
-        os.write(slave_fd, TEST_STRING_2[:5])
-        os.write(slave_fd, TEST_STRING_2[5:])
+        write_all(slave_fd, TEST_STRING_2[:5])
+        write_all(slave_fd, TEST_STRING_2[5:])
         s2 = _readline(master_fd)
         self.assertEqual(b'For my pet fish, Eric.\n', normalize_output(s2))
 
-    @support.requires_fork()
+    @unittest.skip('TODO: RUSTPYTHON; "Not runnable. tty.tcgetwinsize" is required to setUp')
     def test_fork(self):
         debug("calling pty.fork()")
         pid, master_fd = pty.fork()
@@ -294,6 +279,7 @@ def test_fork(self):
             ##else:
             ##    raise TestFailed("Read from master_fd did not raise exception")
 
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "tty" has no attribute "tcgetwinsize"')
     def test_master_read(self):
         # XXX(nnorwitz):  this test leaks fds when there is an error.
         debug("Calling pty.openpty()")
@@ -313,8 +299,28 @@ def test_master_read(self):
 
         self.assertEqual(data, b"")
 
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "tty" has no attribute "tcgetwinsize"')
     def test_spawn_doesnt_hang(self):
-        pty.spawn([sys.executable, '-c', 'print("hi there")'])
+        self.addCleanup(unlink, TESTFN)
+        with open(TESTFN, 'wb') as f:
+            STDOUT_FILENO = 1
+            dup_stdout = os.dup(STDOUT_FILENO)
+            os.dup2(f.fileno(), STDOUT_FILENO)
+            buf = b''
+            def master_read(fd):
+                nonlocal buf
+                data = os.read(fd, 1024)
+                buf += data
+                return data
+            try:
+                pty.spawn([sys.executable, '-c', 'print("hi there")'],
+                          master_read)
+            finally:
+                os.dup2(dup_stdout, STDOUT_FILENO)
+                os.close(dup_stdout)
+        self.assertEqual(buf, b'hi there\r\n')
+        with open(TESTFN, 'rb') as f:
+            self.assertEqual(f.read(), b'hi there\r\n')
 
 class SmallPtyTests(unittest.TestCase):
     """These tests don't spawn children or hang."""
@@ -332,8 +338,8 @@ def setUp(self):
         self.orig_pty_waitpid = pty.waitpid
         self.fds = []  # A list of file descriptors to close.
         self.files = []
-        self.select_rfds_lengths = []
-        self.select_rfds_results = []
+        self.select_input = []
+        self.select_output = []
         self.tcsetattr_mode_setting = None
 
     def tearDown(self):
@@ -368,11 +374,10 @@ def _socketpair(self):
         self.files.extend(socketpair)
         return socketpair
 
-    def _mock_select(self, rfds, wfds, xfds, timeout=0):
+    def _mock_select(self, rfds, wfds, xfds):
         # This will raise IndexError when no more expected calls exist.
-        # This ignores the timeout
-        self.assertEqual(self.select_rfds_lengths.pop(0), len(rfds))
-        return self.select_rfds_results.pop(0), [], []
+        self.assertEqual((rfds, wfds, xfds), self.select_input.pop(0))
+        return self.select_output.pop(0)
 
     def _make_mock_fork(self, pid):
         def mock_fork():
@@ -392,14 +397,16 @@ def test__copy_to_each(self):
         masters = [s.fileno() for s in socketpair]
 
         # Feed data.  Smaller than PIPEBUF.  These writes will not block.
-        os.write(masters[1], b'from master')
-        os.write(write_to_stdin_fd, b'from stdin')
+        write_all(masters[1], b'from master')
+        write_all(write_to_stdin_fd, b'from stdin')
 
-        # Expect two select calls, the last one will cause IndexError
+        # Expect three select calls, the last one will cause IndexError
         pty.select = self._mock_select
-        self.select_rfds_lengths.append(2)
-        self.select_rfds_results.append([mock_stdin_fd, masters[0]])
-        self.select_rfds_lengths.append(2)
+        self.select_input.append(([mock_stdin_fd, masters[0]], [], []))
+        self.select_output.append(([mock_stdin_fd, masters[0]], [], []))
+        self.select_input.append(([mock_stdin_fd, masters[0]], [mock_stdout_fd, masters[0]], []))
+        self.select_output.append(([], [mock_stdout_fd, masters[0]], []))
+        self.select_input.append(([mock_stdin_fd, masters[0]], [], []))
 
         with self.assertRaises(IndexError):
             pty._copy(masters[0])
@@ -410,28 +417,6 @@ def test__copy_to_each(self):
         self.assertEqual(os.read(read_from_stdout_fd, 20), b'from master')
         self.assertEqual(os.read(masters[1], 20), b'from stdin')
 
-    def test__copy_eof_on_all(self):
-        """Test the empty read EOF case on both master_fd and stdin."""
-        read_from_stdout_fd, mock_stdout_fd = self._pipe()
-        pty.STDOUT_FILENO = mock_stdout_fd
-        mock_stdin_fd, write_to_stdin_fd = self._pipe()
-        pty.STDIN_FILENO = mock_stdin_fd
-        socketpair = self._socketpair()
-        masters = [s.fileno() for s in socketpair]
-
-        socketpair[1].close()
-        os.close(write_to_stdin_fd)
-
-        pty.select = self._mock_select
-        self.select_rfds_lengths.append(2)
-        self.select_rfds_results.append([mock_stdin_fd, masters[0]])
-        # We expect that both fds were removed from the fds list as they
-        # both encountered an EOF before the second select call.
-        self.select_rfds_lengths.append(0)
-
-        # We expect the function to return without error.
-        self.assertEqual(pty._copy(masters[0]), None)
-
     def test__restore_tty_mode_normal_return(self):
         """Test that spawn resets the tty mode no when _copy returns normally."""
 
diff --git a/Lib/test/test_tty.py b/Lib/test/test_tty.py
new file mode 100644
index 00000000000..681772fb519
--- /dev/null
+++ b/Lib/test/test_tty.py
@@ -0,0 +1,96 @@
+import os
+import unittest
+from test.support.import_helper import import_module
+
+termios = import_module('termios')
+tty = import_module('tty')
+
+
+@unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+class TestTty(unittest.TestCase):
+
+    def setUp(self):
+        master_fd, self.fd = os.openpty()
+        self.addCleanup(os.close, master_fd)
+        self.stream = self.enterContext(open(self.fd, 'wb', buffering=0))
+        self.fd = self.stream.fileno()
+        self.mode = termios.tcgetattr(self.fd)
+        self.addCleanup(termios.tcsetattr, self.fd, termios.TCSANOW, self.mode)
+        self.addCleanup(termios.tcsetattr, self.fd, termios.TCSAFLUSH, self.mode)
+
+    def check_cbreak(self, mode):
+        self.assertEqual(mode[3] & termios.ECHO, 0)
+        self.assertEqual(mode[3] & termios.ICANON, 0)
+        self.assertEqual(mode[6][termios.VMIN], 1)
+        self.assertEqual(mode[6][termios.VTIME], 0)
+
+    def check_raw(self, mode):
+        self.check_cbreak(mode)
+        self.assertEqual(mode[0] & termios.ISTRIP, 0)
+        self.assertEqual(mode[0] & termios.ICRNL, 0)
+        self.assertEqual(mode[1] & termios.OPOST, 0)
+        self.assertEqual(mode[2] & termios.PARENB, termios.CS8 & termios.PARENB)
+        self.assertEqual(mode[2] & termios.CSIZE, termios.CS8 & termios.CSIZE)
+        self.assertEqual(mode[2] & termios.CS8, termios.CS8)
+        self.assertEqual(mode[3] & termios.ECHO, 0)
+        self.assertEqual(mode[3] & termios.ICANON, 0)
+        self.assertEqual(mode[3] & termios.ISIG, 0)
+        self.assertEqual(mode[6][termios.VMIN], 1)
+        self.assertEqual(mode[6][termios.VTIME], 0)
+
+    def test_cfmakeraw(self):
+        mode = termios.tcgetattr(self.fd)
+        self.assertEqual(mode, self.mode)
+        tty.cfmakeraw(mode)
+        self.check_raw(mode)
+        self.assertEqual(mode[4], self.mode[4])
+        self.assertEqual(mode[5], self.mode[5])
+
+    def test_cfmakecbreak(self):
+        mode = termios.tcgetattr(self.fd)
+        self.assertEqual(mode, self.mode)
+        tty.cfmakecbreak(mode)
+        self.check_cbreak(mode)
+        self.assertEqual(mode[1], self.mode[1])
+        self.assertEqual(mode[2], self.mode[2])
+        self.assertEqual(mode[4], self.mode[4])
+        self.assertEqual(mode[5], self.mode[5])
+        mode[tty.IFLAG] |= termios.ICRNL
+        tty.cfmakecbreak(mode)
+        self.assertEqual(mode[tty.IFLAG] & termios.ICRNL, termios.ICRNL,
+                         msg="ICRNL should not be cleared by cbreak")
+        mode[tty.IFLAG] &= ~termios.ICRNL
+        tty.cfmakecbreak(mode)
+        self.assertEqual(mode[tty.IFLAG] & termios.ICRNL, 0,
+                         msg="ICRNL should not be set by cbreak")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON TypeError: Expected type "int" but "FileIO" found.
+    def test_setraw(self):
+        mode0 = termios.tcgetattr(self.fd)
+        mode1 = tty.setraw(self.fd)
+        self.assertEqual(mode1, mode0)
+        mode2 = termios.tcgetattr(self.fd)
+        self.check_raw(mode2)
+        mode3 = tty.setraw(self.fd, termios.TCSANOW)
+        self.assertEqual(mode3, mode2)
+        tty.setraw(self.stream)
+        tty.setraw(fd=self.fd, when=termios.TCSANOW)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON TypeError: Expected type "int" but "FileIO" found.
+    def test_setcbreak(self):
+        mode0 = termios.tcgetattr(self.fd)
+        mode1 = tty.setcbreak(self.fd)
+        self.assertEqual(mode1, mode0)
+        mode2 = termios.tcgetattr(self.fd)
+        self.check_cbreak(mode2)
+        ICRNL = termios.ICRNL
+        self.assertEqual(mode2[tty.IFLAG] & ICRNL, mode0[tty.IFLAG] & ICRNL,
+                         msg="ICRNL should not be altered by cbreak")
+        mode3 = tty.setcbreak(self.fd, termios.TCSANOW)
+        self.assertEqual(mode3, mode2)
+        tty.setcbreak(self.stream)
+        tty.setcbreak(fd=self.fd, when=termios.TCSANOW)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/tty.py b/Lib/tty.py
index a72eb675545..5a49e040042 100644
--- a/Lib/tty.py
+++ b/Lib/tty.py
@@ -4,9 +4,9 @@
 
 from termios import *
 
-__all__ = ["setraw", "setcbreak"]
+__all__ = ["cfmakeraw", "cfmakecbreak", "setraw", "setcbreak"]
 
-# Indexes for termios list.
+# Indices for termios list.
 IFLAG = 0
 OFLAG = 1
 CFLAG = 2
@@ -15,22 +15,59 @@
 OSPEED = 5
 CC = 6
 
-def setraw(fd, when=TCSAFLUSH):
-    """Put terminal into a raw mode."""
-    mode = tcgetattr(fd)
-    mode[IFLAG] = mode[IFLAG] & ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
-    mode[OFLAG] = mode[OFLAG] & ~(OPOST)
-    mode[CFLAG] = mode[CFLAG] & ~(CSIZE | PARENB)
-    mode[CFLAG] = mode[CFLAG] | CS8
-    mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON | IEXTEN | ISIG)
+def cfmakeraw(mode):
+    """Make termios mode raw."""
+    # Clear all POSIX.1-2017 input mode flags.
+    # See chapter 11 "General Terminal Interface"
+    # of POSIX.1-2017 Base Definitions.
+    mode[IFLAG] &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
+                     INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF)
+
+    # Do not post-process output.
+    mode[OFLAG] &= ~OPOST
+
+    # Disable parity generation and detection; clear character size mask;
+    # let character size be 8 bits.
+    mode[CFLAG] &= ~(PARENB | CSIZE)
+    mode[CFLAG] |= CS8
+
+    # Clear all POSIX.1-2017 local mode flags.
+    mode[LFLAG] &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON |
+                     IEXTEN | ISIG | NOFLSH | TOSTOP)
+
+    # POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+    # Case B: MIN>0, TIME=0
+    # A pending read shall block until MIN (here 1) bytes are received,
+    # or a signal is received.
+    mode[CC] = list(mode[CC])
     mode[CC][VMIN] = 1
     mode[CC][VTIME] = 0
-    tcsetattr(fd, when, mode)
 
-def setcbreak(fd, when=TCSAFLUSH):
-    """Put terminal into a cbreak mode."""
-    mode = tcgetattr(fd)
-    mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON)
+def cfmakecbreak(mode):
+    """Make termios mode cbreak."""
+    # Do not echo characters; disable canonical input.
+    mode[LFLAG] &= ~(ECHO | ICANON)
+
+    # POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+    # Case B: MIN>0, TIME=0
+    # A pending read shall block until MIN (here 1) bytes are received,
+    # or a signal is received.
+    mode[CC] = list(mode[CC])
     mode[CC][VMIN] = 1
     mode[CC][VTIME] = 0
-    tcsetattr(fd, when, mode)
+
+def setraw(fd, when=TCSAFLUSH):
+    """Put terminal into raw mode."""
+    mode = tcgetattr(fd)
+    new = list(mode)
+    cfmakeraw(new)
+    tcsetattr(fd, when, new)
+    return mode
+
+def setcbreak(fd, when=TCSAFLUSH):
+    """Put terminal into cbreak mode."""
+    mode = tcgetattr(fd)
+    new = list(mode)
+    cfmakecbreak(new)
+    tcsetattr(fd, when, new)
+    return mode

From 4af869b121497c41da0d10151fe9362dde261b4b Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 5 Jan 2026 15:24:56 +0200
Subject: [PATCH 177/418] Fix opcode args (#6649)

---
 crates/stdlib/src/opcode.rs | 96 +++++++++++++------------------------
 1 file changed, 33 insertions(+), 63 deletions(-)

diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 0b5c5c8120d..cf6502181a7 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -4,9 +4,8 @@ pub(crate) use opcode::make_module;
 mod opcode {
     use crate::vm::{
         AsObject, PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyBool, PyInt, PyIntRef, PyNone},
+        builtins::{PyInt, PyIntRef},
         bytecode::Instruction,
-        match_class,
     };
     use core::ops::Deref;
 
@@ -55,29 +54,20 @@ mod opcode {
         /// Check if instruction uses co_consts
         #[must_use]
         pub fn has_const(opcode: i32) -> bool {
-            if !Self::is_valid(opcode) {
-                return false;
-            }
-            if let Ok(instr) = Instruction::try_from(opcode as u8) {
-                matches!(
-                    instr,
-                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
+            Self::is_valid(opcode)
+                && matches!(
+                    Instruction::try_from(opcode as u8),
+                    Ok(Instruction::LoadConst { .. } | Instruction::ReturnConst { .. })
                 )
-            } else {
-                false
-            }
         }
 
         /// Check if instruction uses co_names
         #[must_use]
         pub fn has_name(opcode: i32) -> bool {
-            if !Self::is_valid(opcode) {
-                return false;
-            }
-            if let Ok(instr) = Instruction::try_from(opcode as u8) {
-                matches!(
-                    instr,
-                    Instruction::DeleteAttr { .. }
+            Self::is_valid(opcode)
+                && matches!(
+                    Instruction::try_from(opcode as u8),
+                    Ok(Instruction::DeleteAttr { .. }
                         | Instruction::DeleteGlobal(_)
                         | Instruction::DeleteLocal(_)
                         | Instruction::ImportFrom { .. }
@@ -88,23 +78,17 @@ mod opcode {
                         | Instruction::LoadNameAny(_)
                         | Instruction::StoreAttr { .. }
                         | Instruction::StoreGlobal(_)
-                        | Instruction::StoreLocal(_)
+                        | Instruction::StoreLocal(_))
                 )
-            } else {
-                false
-            }
         }
 
         /// Check if instruction is a jump
         #[must_use]
         pub fn has_jump(opcode: i32) -> bool {
-            if !Self::is_valid(opcode) {
-                return false;
-            }
-            if let Ok(instr) = Instruction::try_from(opcode as u8) {
-                matches!(
-                    instr,
-                    Instruction::Break { .. }
+            Self::is_valid(opcode)
+                && matches!(
+                    Instruction::try_from(opcode as u8),
+                    Ok(Instruction::Break { .. }
                         | Instruction::Continue { .. }
                         | Instruction::ForIter { .. }
                         | Instruction::JumpIfFalseOrPop { .. }
@@ -115,51 +99,36 @@ mod opcode {
                         | Instruction::PopJumpIfTrue { .. }
                         | Instruction::PopJumpIfNone { .. }
                         | Instruction::PopJumpIfNotNone { .. }
-                        | Instruction::Send { .. }
+                        | Instruction::Send { .. })
                 )
-            } else {
-                false
-            }
         }
 
         /// Check if instruction uses co_freevars/co_cellvars
         #[must_use]
         pub fn has_free(opcode: i32) -> bool {
-            if !Self::is_valid(opcode) {
-                return false;
-            }
-            if let Ok(instr) = Instruction::try_from(opcode as u8) {
-                matches!(
-                    instr,
-                    Instruction::DeleteDeref(_)
+            Self::is_valid(opcode)
+                && matches!(
+                    Instruction::try_from(opcode as u8),
+                    Ok(Instruction::DeleteDeref(_)
                         | Instruction::LoadClassDeref(_)
                         | Instruction::LoadClosure(_)
                         | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_)
+                        | Instruction::StoreDeref(_))
                 )
-            } else {
-                false
-            }
         }
 
         /// Check if instruction uses co_varnames (local variables)
         #[must_use]
         pub fn has_local(opcode: i32) -> bool {
-            if !Self::is_valid(opcode) {
-                return false;
-            }
-            if let Ok(instr) = Instruction::try_from(opcode as u8) {
-                matches!(
-                    instr,
-                    Instruction::DeleteFast(_)
+            Self::is_valid(opcode)
+                && matches!(
+                    Instruction::try_from(opcode as u8),
+                    Ok(Instruction::DeleteFast(_)
                         | Instruction::LoadFast(_)
                         | Instruction::LoadFastAndClear(_)
                         | Instruction::StoreFast(_)
-                        | Instruction::StoreFastLoadFast { .. }
+                        | Instruction::StoreFastLoadFast { .. })
                 )
-            } else {
-                false
-            }
         }
 
         /// Check if instruction has exception info
@@ -196,7 +165,12 @@ mod opcode {
                     )));
                 }
                 v.downcast_ref::<PyInt>()
-                    .ok_or_else(|| vm.new_type_error(""))?
+                    .ok_or_else(|| {
+                        vm.new_type_error(format!(
+                            "'{}' object cannot be interpreted as an integer",
+                            v.class().name()
+                        ))
+                    })?
                     .try_to_primitive::<u32>(vm)
             })
             .unwrap_or(Ok(0))?;
@@ -204,12 +178,8 @@ mod opcode {
         let jump = args
             .jump
             .map(|v| {
-                match_class!(match v {
-                    b @ PyBool => Ok(b.is(&vm.ctx.true_value)),
-                    _n @ PyNone => Ok(false),
-                    _ => {
-                        Err(vm.new_value_error("stack_effect: jump must be False, True or None"))
-                    }
+                v.try_to_bool(vm).map_err(|_| {
+                    vm.new_value_error("stack_effect: jump must be False, True or None")
                 })
             })
             .unwrap_or(Ok(false))?;

From dd65baf61738502d357a28f8e3beca343ada0c14 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Jan 2026 22:53:03 +0900
Subject: [PATCH 178/418] Bump insta from 1.45.1 to 1.46.0 (#6650)

Bumps [insta](https://github.com/mitsuhiko/insta) from 1.45.1 to 1.46.0.
- [Release notes](https://github.com/mitsuhiko/insta/releases)
- [Changelog](https://github.com/mitsuhiko/insta/blob/master/CHANGELOG.md)
- [Commits](https://github.com/mitsuhiko/insta/compare/1.45.1...1.46.0)

---
updated-dependencies:
- dependency-name: insta
  dependency-version: 1.46.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0b7436570a8..ccc39cecd00 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1487,9 +1487,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.45.1"
+version = "1.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "983e3b24350c84ab8a65151f537d67afbbf7153bb9f1110e03e9fa9b07f67a5c"
+checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5"
 dependencies = [
  "console",
  "once_cell",
diff --git a/Cargo.toml b/Cargo.toml
index 988e99efacc..5bd392e9d26 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -173,7 +173,7 @@ getrandom = { version = "0.3", features = ["std"] }
 glob = "0.3"
 hex = "0.4.3"
 indexmap = { version = "2.11.3", features = ["std"] }
-insta = "1.45"
+insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
 junction = "1.3.0"

From ab885d37dec6bc435c9ada0e60098f036c3ac12d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Jan 2026 22:53:15 +0900
Subject: [PATCH 179/418] Bump libffi from 5.0.0 to 5.1.0 (#6651)

Bumps [libffi](https://github.com/libffi-rs/libffi-rs) from 5.0.0 to 5.1.0.
- [Commits](https://github.com/libffi-rs/libffi-rs/compare/libffi-v5.0.0...libffi-v5.1.0)

---
updated-dependencies:
- dependency-name: libffi
  dependency-version: 5.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ccc39cecd00..7ef945fccb8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1687,9 +1687,9 @@ checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "libffi"
-version = "5.0.0"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0444124f3ffd67e1b0b0c661a7f81a278a135eb54aaad4078e79fbc8be50c8a5"
+checksum = "0498fe5655f857803e156523e644dcdcdc3b3c7edda42ea2afdae2e09b2db87b"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -1697,9 +1697,9 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "4.0.0"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d722da8817ea580d0669da6babe2262d7b86a1af1103da24102b8bb9c101ce7"
+checksum = "71d4f1d4ce15091955144350b75db16a96d4a63728500122706fb4d29a26afbb"
 dependencies = [
  "cc",
 ]

From 85bafc057a26761ce42d795b3977039b9497f894 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Jan 2026 22:53:46 +0900
Subject: [PATCH 180/418] Bump syn from 2.0.112 to 2.0.113 (#6652)

Bumps [syn](https://github.com/dtolnay/syn) from 2.0.112 to 2.0.113.
- [Release notes](https://github.com/dtolnay/syn/releases)
- [Commits](https://github.com/dtolnay/syn/compare/2.0.112...2.0.113)

---
updated-dependencies:
- dependency-name: syn
  dependency-version: 2.0.113
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7ef945fccb8..55ade0703e7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3668,9 +3668,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.112"
+version = "2.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
+checksum = "678faa00651c9eb72dd2020cbdf275d92eccb2400d568e419efdd64838145cb4"
 dependencies = [
  "proc-macro2",
  "quote",

From ead7e0c39ccf328da2e8f6043680c9ede9f60e64 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 5 Jan 2026 16:40:41 +0200
Subject: [PATCH 181/418] Make use of `Unary` opcodes (#6647)

* Make use of `Unary` opcodes

* Add `Reserved140` opcode

* re-add support for UnaryPositive in JIT

* JIT support for `ToBool` instruction
---
 crates/codegen/src/compile.rs        | 19 ++++++----
 crates/compiler-core/src/bytecode.rs | 50 +++++++++-----------------
 crates/jit/src/instructions.rs       | 53 ++++++++++++++++++----------
 crates/vm/src/frame.rs               | 45 +++++++++++------------
 4 files changed, 85 insertions(+), 82 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 2fb22f46a85..66eb785e962 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -5656,13 +5656,20 @@ impl Compiler {
                 self.compile_expression(operand)?;
 
                 // Perform operation:
-                let op = match op {
-                    UnaryOp::UAdd => bytecode::UnaryOperator::Plus,
-                    UnaryOp::USub => bytecode::UnaryOperator::Minus,
-                    UnaryOp::Not => bytecode::UnaryOperator::Not,
-                    UnaryOp::Invert => bytecode::UnaryOperator::Invert,
+                match op {
+                    UnaryOp::UAdd => emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::UnaryPositive
+                        }
+                    ),
+                    UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
+                    UnaryOp::Not => {
+                        emit!(self, Instruction::ToBool);
+                        emit!(self, Instruction::UnaryNot);
+                    }
+                    UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
                 };
-                emit!(self, Instruction::UnaryOperation { op });
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 08426287307..dc61e3b9b5a 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -640,7 +640,7 @@ op_arg_enum!(
         ImportStar = 2,
         // StopIterationError = 3,
         // AsyncGenWrap = 4,
-        // UnaryPositive = 5,
+        UnaryPositive = 5,
         /// Convert list to tuple
         ListToTuple = 6,
         /// Type parameter related
@@ -758,11 +758,11 @@ pub enum Instruction {
     StoreSubscript,
     // 40: TO_BOOL
     ToBool,
-    // 41: UNARY_INVERT - placeholder (RustPython uses UnaryOperation)
+    // 41: UNARY_INVERT
     UnaryInvert,
-    // 42: UNARY_NEGATIVE - placeholder
+    // 42: UNARY_NEGATIVE
     UnaryNegative,
-    // 43: UNARY_NOT - placeholder
+    // 43: UNARY_NOT
     UnaryNot,
     // ==================== With-argument instructions (opcode >= 44) ====================
     // 44: WITH_EXCEPT_START
@@ -1091,11 +1091,8 @@ pub enum Instruction {
     SetExcInfo,
     // 139: SUBSCRIPT
     Subscript,
-    // 140: UNARY_OP (combines UNARY_*)
-    UnaryOperation {
-        op: Arg<UnaryOperator>,
-    },
-    // 141-148: Reserved (padding to keep RESUME at 149)
+    // 140-148: Reserved (padding to keep RESUME at 149)
+    Reserved140,
     Reserved141,
     Reserved142,
     Reserved143,
@@ -1538,18 +1535,6 @@ impl fmt::Display for BinaryOperator {
     }
 }
 
-op_arg_enum!(
-    /// The possible unary operators
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum UnaryOperator {
-        Not = 0,
-        Invert = 1,
-        Minus = 2,
-        Plus = 3,
-    }
-);
-
 op_arg_enum!(
     /// Whether or not to invert the operation.
     #[repr(u8)]
@@ -1910,23 +1895,21 @@ impl Instruction {
     /// # Examples
     ///
     /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, UnaryOperator};
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
     /// let (target, jump_arg) = Arg::new(Label(0xF));
     /// let jump_instruction = Instruction::Jump { target };
-    /// let (op, invert_arg) = Arg::new(UnaryOperator::Invert);
-    /// let invert_instruction = Instruction::UnaryOperation { op };
     /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// assert_eq!(invert_instruction.stack_effect(invert_arg, false), 0);
     /// ```
     ///
     pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             // Dummy/placeholder instructions (never executed)
-            Cache | Reserved3 | Reserved17 | Reserved141 | Reserved142 | Reserved143
-            | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => 0,
+            Cache | Reserved3 | Reserved17 | Reserved140 | Reserved141 | Reserved142
+            | Reserved143 | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => {
+                0
+            }
             BinarySlice | EndFor | ExitInitCheck | GetYieldFromIter | InterpreterExit
-            | LoadAssertionError | LoadLocals | PushNull | ReturnGenerator | StoreSlice
-            | UnaryInvert | UnaryNegative | UnaryNot => 0,
+            | LoadAssertionError | LoadLocals | PushNull | ReturnGenerator | StoreSlice => 0,
             BuildConstKeyMap { .. }
             | CopyFreeVars { .. }
             | DictMerge { .. }
@@ -1959,7 +1942,6 @@ impl Instruction {
             StoreAttr { .. } => -2,
             DeleteAttr { .. } => -1,
             LoadConst { .. } => 1,
-            UnaryOperation { .. } => 0,
             BinaryOp { .. } | CompareOperation { .. } => -1,
             BinarySubscript => -1,
             CopyItem { .. } => 1,
@@ -2086,6 +2068,9 @@ impl Instruction {
             MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
             MatchClass(_) => -2,
             ExtendedArg => 0,
+            UnaryInvert => 0,
+            UnaryNegative => 0,
+            UnaryNot => 0,
         }
     }
 
@@ -2158,8 +2143,8 @@ impl Instruction {
         match self {
             // Dummy/placeholder instructions
             Cache => w!(CACHE),
-            Reserved3 | Reserved17 | Reserved141 | Reserved142 | Reserved143 | Reserved144
-            | Reserved145 | Reserved146 | Reserved147 | Reserved148 => w!(RESERVED),
+            Reserved3 | Reserved17 | Reserved140 | Reserved141 | Reserved142 | Reserved143
+            | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => w!(RESERVED),
             BinarySlice => w!(BINARY_SLICE),
             EndFor => w!(END_FOR),
             ExitInitCheck => w!(EXIT_INIT_CHECK),
@@ -2302,7 +2287,6 @@ impl Instruction {
             Subscript => w!(SUBSCRIPT),
             Swap { index } => w!(SWAP, index),
             ToBool => w!(TO_BOOL),
-            UnaryOperation { op } => w!(UNARY_OP, ?op),
             UnpackEx { args } => w!(UNPACK_EX, args),
             UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
             WithExceptStart => w!(WITH_EXCEPT_START),
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index e94bea86f59..d6e3a07e111 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -4,8 +4,8 @@ use cranelift::codegen::ir::FuncRef;
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
-    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction, Label,
-    OpArg, OpArgState, UnaryOperator,
+    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction,
+    IntrinsicFunction1, Label, OpArg, OpArgState,
 };
 use std::collections::HashMap;
 
@@ -474,6 +474,21 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
+            Instruction::CallIntrinsic1 { func } => {
+                match func.get(arg) {
+                    IntrinsicFunction1::UnaryPositive => {
+                        match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                            JitValue::Int(val) => {
+                                // Nothing to do
+                                self.stack.push(JitValue::Int(val));
+                                Ok(())
+                            }
+                            _ => Err(JitCompileError::NotSupported),
+                        }
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
+            }
             Instruction::CompareOperation { op, .. } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
@@ -620,28 +635,30 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.swap(i, j);
                 Ok(())
             }
-            Instruction::UnaryOperation { op, .. } => {
-                let op = op.get(arg);
+            Instruction::ToBool => {
                 let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                match (op, a) {
-                    (UnaryOperator::Minus, JitValue::Int(val)) => {
-                        // Compile minus as 0 - a.
+                let value = self.boolean_val(a)?;
+                self.stack.push(JitValue::Bool(value));
+                Ok(())
+            }
+            Instruction::UnaryNot => {
+                let boolean = match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                    JitValue::Bool(val) => val,
+                    _ => return Err(JitCompileError::BadBytecode),
+                };
+                let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
+                self.stack.push(JitValue::Bool(not_boolean));
+                Ok(())
+            }
+            Instruction::UnaryNegative => {
+                match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                    JitValue::Int(val) => {
+                        // Compile minus as 0 - val.
                         let zero = self.builder.ins().iconst(types::I64, 0);
                         let out = self.compile_sub(zero, val);
                         self.stack.push(JitValue::Int(out));
                         Ok(())
                     }
-                    (UnaryOperator::Plus, JitValue::Int(val)) => {
-                        // Nothing to do
-                        self.stack.push(JitValue::Int(val));
-                        Ok(())
-                    }
-                    (UnaryOperator::Not, a) => {
-                        let boolean = self.boolean_val(a)?;
-                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
-                        self.stack.push(JitValue::Bool(not_boolean));
-                        Ok(())
-                    }
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index f066e2fabcb..fc56f50fb3d 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1652,7 +1652,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            bytecode::Instruction::UnaryOperation { op } => self.execute_unary_op(vm, op.get(arg)),
             bytecode::Instruction::UnpackEx { args } => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
@@ -1762,7 +1761,24 @@ impl ExecutingFrame<'_> {
                     .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
                 Err(exc)
             }
-
+            bytecode::Instruction::UnaryInvert => {
+                let a = self.pop_value();
+                let value = vm._invert(&a)?;
+                self.push_value(value);
+                Ok(None)
+            }
+            bytecode::Instruction::UnaryNegative => {
+                let a = self.pop_value();
+                let value = vm._neg(&a)?;
+                self.push_value(value);
+                Ok(None)
+            }
+            bytecode::Instruction::UnaryNot => {
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                self.push_value(vm.ctx.new_bool(!value).into());
+                Ok(None)
+            }
             // Placeholder/dummy instructions - these should never be executed
             bytecode::Instruction::Cache
             | bytecode::Instruction::Reserved3
@@ -1776,9 +1792,6 @@ impl ExecutingFrame<'_> {
             | bytecode::Instruction::PushNull
             | bytecode::Instruction::ReturnGenerator
             | bytecode::Instruction::StoreSlice
-            | bytecode::Instruction::UnaryInvert
-            | bytecode::Instruction::UnaryNegative
-            | bytecode::Instruction::UnaryNot
             | bytecode::Instruction::BuildConstKeyMap { .. }
             | bytecode::Instruction::CopyFreeVars { .. }
             | bytecode::Instruction::DictMerge { .. }
@@ -1797,6 +1810,7 @@ impl ExecutingFrame<'_> {
             | bytecode::Instruction::PopJumpIfNotNone { .. }
             | bytecode::Instruction::SetUpdate { .. }
             | bytecode::Instruction::StoreFastStoreFast { .. }
+            | bytecode::Instruction::Reserved140
             | bytecode::Instruction::Reserved141
             | bytecode::Instruction::Reserved142
             | bytecode::Instruction::Reserved143
@@ -2440,26 +2454,6 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn execute_unary_op(
-        &mut self,
-        vm: &VirtualMachine,
-        op: bytecode::UnaryOperator,
-    ) -> FrameResult {
-        let a = self.pop_value();
-        let value = match op {
-            bytecode::UnaryOperator::Minus => vm._neg(&a)?,
-            bytecode::UnaryOperator::Plus => vm._pos(&a)?,
-            bytecode::UnaryOperator::Invert => vm._invert(&a)?,
-            bytecode::UnaryOperator::Not => {
-                let value = a.try_to_bool(vm)?;
-                vm.ctx.new_bool(!value).into()
-            }
-        };
-        self.push_value(value);
-        Ok(None)
-    }
-
     #[cold]
     fn setup_annotations(&mut self, vm: &VirtualMachine) -> FrameResult {
         let __annotations__ = identifier!(vm, __annotations__);
@@ -2634,6 +2628,7 @@ impl ExecutingFrame<'_> {
                 self.import_star(vm)?;
                 Ok(vm.ctx.none())
             }
+            bytecode::IntrinsicFunction1::UnaryPositive => vm._pos(&arg),
             bytecode::IntrinsicFunction1::SubscriptGeneric => {
                 // Used for PEP 695: Generic[*type_params]
                 crate::builtins::genericalias::subscript_generic(arg, vm)

From cf963b74c804674799a06145b364f815bdbff002 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 6 Jan 2026 10:07:51 +0900
Subject: [PATCH 182/418] Bump libc from 0.2.178 to 0.2.179 (#6654)

* Bump libc from 0.2.178 to 0.2.179

Bumps [libc](https://github.com/rust-lang/libc) from 0.2.178 to 0.2.179.
- [Release notes](https://github.com/rust-lang/libc/releases)
- [Changelog](https://github.com/rust-lang/libc/blob/main/CHANGELOG.md)
- [Commits](https://github.com/rust-lang/libc/compare/0.2.178...0.2.179)

---
updated-dependencies:
- dependency-name: libc
  dependency-version: 0.2.179
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Fix musl and wasi builds after libc 0.2.179 upgrade (#6655)

* Initial plan

* Fix musl and wasi build failures after libc 0.2.179 upgrade

- Remove wasi-specific implementation of get_process_time that used CLOCK_PROCESS_CPUTIME_ID
- Exclude wasi from CLOCK_PROCESS_CPUTIME_ID constant export
- Add musl and wasi to use st_atim/st_mtim/st_ctim timespec fields for stat structure

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Cargo.lock                   |  4 ++--
 Cargo.toml                   |  2 +-
 crates/vm/src/stdlib/os.rs   |  4 ++--
 crates/vm/src/stdlib/time.rs | 16 ++--------------
 4 files changed, 7 insertions(+), 19 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 55ade0703e7..f9741bc50ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1681,9 +1681,9 @@ checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
 name = "libc"
-version = "0.2.178"
+version = "0.2.179"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+checksum = "c5a2d376baa530d1238d133232d15e239abad80d05838b4b59354e5268af431f"
 
 [[package]]
 name = "libffi"
diff --git a/Cargo.toml b/Cargo.toml
index 5bd392e9d26..a0c4a149305 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -177,7 +177,7 @@ insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
 junction = "1.3.0"
-libc = "0.2.178"
+libc = "0.2.179"
 libffi = "5"
 log = "0.4.29"
 nix = { version = "0.30", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 416f26018cb..415097b90d8 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -918,7 +918,7 @@ pub(super) mod _os {
         fn from_stat(stat: &StatStruct, vm: &VirtualMachine) -> Self {
             let (atime, mtime, ctime);
             #[cfg(any(unix, windows))]
-            #[cfg(not(target_os = "netbsd"))]
+            #[cfg(not(any(target_os = "netbsd", target_os = "wasi", target_env = "musl")))]
             {
                 atime = (stat.st_atime, stat.st_atime_nsec);
                 mtime = (stat.st_mtime, stat.st_mtime_nsec);
@@ -930,7 +930,7 @@ pub(super) mod _os {
                 mtime = (stat.st_mtime, stat.st_mtimensec);
                 ctime = (stat.st_ctime, stat.st_ctimensec);
             }
-            #[cfg(target_os = "wasi")]
+            #[cfg(any(target_os = "wasi", target_env = "musl"))]
             {
                 atime = (stat.st_atim.tv_sec, stat.st_atim.tv_nsec);
                 mtime = (stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec);
diff --git a/crates/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs
index 97d60ae98a1..8c368b9cc59 100644
--- a/crates/vm/src/stdlib/time.rs
+++ b/crates/vm/src/stdlib/time.rs
@@ -441,19 +441,6 @@ mod decl {
         ))
     }
 
-    // same as the get_process_time impl for most unixes
-    #[cfg(all(target_arch = "wasm32", target_os = "wasi"))]
-    pub(super) fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
-        let time: libc::timespec = unsafe {
-            let mut time = std::mem::MaybeUninit::uninit();
-            if libc::clock_gettime(libc::CLOCK_PROCESS_CPUTIME_ID, time.as_mut_ptr()) == -1 {
-                return Err(vm.new_os_error("Failed to get clock time".to_owned()));
-            }
-            time.assume_init()
-        };
-        Ok(Duration::new(time.tv_sec as u64, time.tv_nsec as u32))
-    }
-
     #[cfg(not(any(
         windows,
         target_os = "macos",
@@ -466,7 +453,7 @@ mod decl {
         target_os = "solaris",
         target_os = "openbsd",
         target_os = "redox",
-        all(target_arch = "wasm32", not(target_os = "unknown"))
+        all(target_arch = "wasm32", target_os = "emscripten")
     )))]
     fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         Err(vm.new_not_implemented_error("process time unsupported in this system"))
@@ -601,6 +588,7 @@ mod platform {
         target_os = "netbsd",
         target_os = "solaris",
         target_os = "openbsd",
+        target_os = "wasi",
     )))]
     #[pyattr]
     use libc::CLOCK_PROCESS_CPUTIME_ID;

From 906aebf5a1efaf394a1cc791739878846d48973c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 6 Jan 2026 12:15:35 +0900
Subject: [PATCH 183/418] Bump malachite-q from 0.8.0 to 0.9.0 (#6653)

* Bump malachite-q from 0.8.0 to 0.9.0

Bumps [malachite-q](https://github.com/mhogrefe/malachite) from 0.8.0 to 0.9.0.
- [Release notes](https://github.com/mhogrefe/malachite/releases)
- [Commits](https://github.com/mhogrefe/malachite/compare/v0.8.0...v0.9.0)

---
updated-dependencies:
- dependency-name: malachite-q
  dependency-version: 0.9.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Bump all malachite-* crates from 0.8.0 to 0.9.0 (#6656)

* Initial plan

* Update all malachite-* crates to 0.9.0

* Fix ctypes overflow check for malachite 0.9.0 compatibility

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Cargo.lock                            | 16 ++++++++--------
 Cargo.toml                            |  6 +++---
 crates/vm/src/stdlib/ctypes/simple.rs |  7 ++++---
 3 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f9741bc50ce..e03c1221781 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1822,9 +1822,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-base"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0c91cb6071ed9ac48669d3c79bd2792db596c7e542dbadd217b385bb359f42d"
+checksum = "5eb2a098b227df48779e28ed4125dd3161b792a9254961377cea6f5c19e5b417"
 dependencies = [
  "hashbrown 0.16.1",
  "itertools 0.14.0",
@@ -1834,9 +1834,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-bigint"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ff3af5010102f29f2ef4ee6f7b1c5b3f08a6c261b5164e01c41cf43772b6f90"
+checksum = "6eaf19f1b8ba023528050372eafd72ca11f80f70c9dc2af9bb22f888bf079013"
 dependencies = [
  "malachite-base",
  "malachite-nz",
@@ -1847,9 +1847,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-nz"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d9ecf4dd76246fd622de4811097966106aa43f9cd7cc36cb85e774fe84c8adc"
+checksum = "ab7c0ddc4e2681459d70591baf30ca5abd31c25969e76d3605838bec794c8077"
 dependencies = [
  "itertools 0.14.0",
  "libm",
@@ -1859,9 +1859,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-q"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7bc9d9adf5b0a7999d84f761c809bec3dc46fe983e4de547725d2b7730462a0"
+checksum = "e13d19f04fc672f251d477c8d58c13c6c5550553dfba6a665c9ad3604466ac9a"
 dependencies = [
  "itertools 0.14.0",
  "malachite-base",
diff --git a/Cargo.toml b/Cargo.toml
index a0c4a149305..1ef31f825f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -181,9 +181,9 @@ libc = "0.2.179"
 libffi = "5"
 log = "0.4.29"
 nix = { version = "0.30", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
-malachite-bigint = "0.8"
-malachite-q = "0.8"
-malachite-base = "0.8"
+malachite-bigint = "0.9"
+malachite-q = "0.9"
+malachite-base = "0.9"
 memchr = "2.7.4"
 num-complex = "0.4.6"
 num-integer = "0.1.46"
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
index de13dab2202..b2ae0f7cc5b 100644
--- a/crates/vm/src/stdlib/ctypes/simple.rs
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -141,11 +141,12 @@ fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResul
             // Handle int specially to check overflow
             if let Some(int_obj) = value.downcast_ref_if_exact::<PyInt>(vm) {
                 // Check if int can fit in f64
-                if int_obj.as_bigint().to_f64().is_some() {
+                if let Some(f) = int_obj.as_bigint().to_f64()
+                    && f.is_finite()
+                {
                     return Ok(value.to_owned());
-                } else {
-                    return Err(vm.new_overflow_error("int too large to convert to float"));
                 }
+                return Err(vm.new_overflow_error("int too large to convert to float"));
             }
             // __float__ protocol
             if value.try_float(vm).is_ok() {

From 03380dc4ecf6d21f53be9de36a689b5c6534da0d Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Tue, 6 Jan 2026 12:16:51 +0900
Subject: [PATCH 184/418] Ensure __new__ entries in class __dict__ are
 staticmethods (#6659)

* Initial plan

* Wrap __new__ methods as staticmethods in type dicts

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Unmark passing enum test

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Lib/test/test_enum.py                |  1 -
 crates/vm/src/builtins/type.rs       | 10 ++++++++--
 extra_tests/snippets/builtin_type.py |  2 ++
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 8f4b39b4dbb..b9d9cf33e35 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -5208,7 +5208,6 @@ def test_inspect_signatures(self):
                     ]),
                 )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; len is often/always > 256
     def test_test_simple_enum(self):
         @_simple_enum(Enum)
         class SimpleColor:
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 8660d1f2e27..fed9af976f6 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -1,6 +1,6 @@
 use super::{
-    PyClassMethod, PyDictRef, PyList, PyStr, PyStrInterned, PyStrRef, PyTupleRef, PyWeak,
-    mappingproxy::PyMappingProxy, object, union_,
+    PyClassMethod, PyDictRef, PyList, PyStaticMethod, PyStr, PyStrInterned, PyStrRef, PyTupleRef,
+    PyWeak, mappingproxy::PyMappingProxy, object, union_,
 };
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
@@ -1166,6 +1166,12 @@ impl Constructor for PyType {
             *f = PyClassMethod::from(f.clone()).into_pyobject(vm);
         }
 
+        if let Some(f) = attributes.get_mut(identifier!(vm, __new__))
+            && f.class().is(vm.ctx.types.function_type)
+        {
+            *f = PyStaticMethod::from(f.clone()).into_pyobject(vm);
+        }
+
         if let Some(current_frame) = vm.current_frame() {
             let entry = attributes.entry(identifier!(vm, __module__));
             if matches!(entry, Entry::Vacant(_)) {
diff --git a/extra_tests/snippets/builtin_type.py b/extra_tests/snippets/builtin_type.py
index 67269e694c0..8cb0a09a215 100644
--- a/extra_tests/snippets/builtin_type.py
+++ b/extra_tests/snippets/builtin_type.py
@@ -584,6 +584,7 @@ def __new__(cls, *args, **kwargs):
 assert ClassWithNew().__new__.__qualname__ == "ClassWithNew.__new__"
 assert ClassWithNew.__new__.__name__ == "__new__"
 assert ClassWithNew().__new__.__name__ == "__new__"
+assert isinstance(ClassWithNew.__dict__.get("__new__"), staticmethod)
 
 assert ClassWithNew.N.__new__.__qualname__ == "ClassWithNew.N.__new__"
 assert ClassWithNew().N.__new__.__qualname__ == "ClassWithNew.N.__new__"
@@ -593,6 +594,7 @@ def __new__(cls, *args, **kwargs):
 assert ClassWithNew().N().__new__.__qualname__ == "ClassWithNew.N.__new__"
 assert ClassWithNew.N().__new__.__name__ == "__new__"
 assert ClassWithNew().N().__new__.__name__ == "__new__"
+assert isinstance(ClassWithNew.N.__dict__.get("__new__"), staticmethod)
 
 
 # Regression to:

From e367145a4ac9d90332eb5373cc10dd49a43c3cfd Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Tue, 6 Jan 2026 15:10:23 +0900
Subject: [PATCH 185/418] Add Linux pidfd syscalls to expose asyncio pidfd
 watcher (#6660)

* Add pidfd support syscalls

* Validate pidfd signal range

* Clarify pidfd syscall return handling

* Skip flaky is_alive_after_fork test

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 Lib/test/test_threading.py     |  1 +
 crates/vm/src/stdlib/posix.rs  | 17 +++++++++++++++++
 crates/vm/src/stdlib/signal.rs | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 52 insertions(+)

diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 937f5903b5f..031db4a49af 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -589,6 +589,7 @@ def background_thread(evt):
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+    @unittest.skip("TODO: RUSTPYTHON; flaky")
     @support.requires_fork()
     def test_is_alive_after_fork(self):
         # Try hard to trigger #18418: is_alive() could sometimes be True on
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 65a659790b2..05f435649ad 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -1757,6 +1757,23 @@ pub mod module {
         libc::WTERMSIG(status)
     }
 
+    #[cfg(target_os = "linux")]
+    #[pyfunction]
+    fn pidfd_open(
+        pid: libc::pid_t,
+        flags: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<OwnedFd> {
+        let flags = flags.unwrap_or(0);
+        let fd = unsafe { libc::syscall(libc::SYS_pidfd_open, pid, flags) as libc::c_long };
+        if fd == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            // Safety: syscall returns a new owned file descriptor.
+            Ok(unsafe { OwnedFd::from_raw_fd(fd as libc::c_int) })
+        }
+    }
+
     #[pyfunction]
     fn waitpid(pid: libc::pid_t, opt: i32, vm: &VirtualMachine) -> PyResult<(libc::pid_t, i32)> {
         let mut status = 0;
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
index dd0d9a7a96f..b316ea306d0 100644
--- a/crates/vm/src/stdlib/signal.rs
+++ b/crates/vm/src/stdlib/signal.rs
@@ -431,6 +431,40 @@ pub(crate) mod _signal {
         }
     }
 
+    #[cfg(target_os = "linux")]
+    #[pyfunction]
+    fn pidfd_send_signal(
+        pidfd: i32,
+        sig: i32,
+        siginfo: OptionalArg<PyObjectRef>,
+        flags: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        signal::assert_in_range(sig, vm)?;
+        if let OptionalArg::Present(obj) = siginfo
+            && !vm.is_none(&obj)
+        {
+            return Err(vm.new_type_error("siginfo must be None".to_owned()));
+        }
+
+        let flags = flags.unwrap_or(0);
+        let ret = unsafe {
+            libc::syscall(
+                libc::SYS_pidfd_send_signal,
+                pidfd,
+                sig,
+                std::ptr::null::<libc::siginfo_t>(),
+                flags,
+            ) as libc::c_long
+        };
+
+        if ret == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
+    }
+
     #[cfg(all(unix, not(target_os = "redox")))]
     #[pyfunction(name = "siginterrupt")]
     fn py_siginterrupt(signum: i32, flag: i32, vm: &VirtualMachine) -> PyResult<()> {

From cd613edc71d277e9c2061b4ea455f0bda40a3cfd Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Tue, 6 Jan 2026 07:35:21 -0500
Subject: [PATCH 186/418] Update the zipfile + zipimport libraries + tests -
 v3.13.11 (#6639)

* Updated zipimport library + test

* Updated zipfile library + test

* Annotated failing/erroring tests in test_zipfile and test_zipimport

* Changed all skips in `test_core.py` to expectedFailures

* skip EncodedMetadataTests

---------

Co-authored-by: Jeong YunWon <jeong@youknowone.org>
---
 Lib/test/test_zipfile/_path/test_path.py      |  13 +-
 Lib/test/test_zipfile/test_core.py            | 152 ++++--
 Lib/test/test_zipimport.py                    | 473 ++++++++++++------
 .../sparse-zip64-c0-0x000000000.part          | Bin 0 -> 4096 bytes
 .../sparse-zip64-c0-0x100000000.part          | Bin 0 -> 4096 bytes
 .../sparse-zip64-c0-0x200000000.part          | Bin 0 -> 546 bytes
 Lib/zipfile/__init__.py                       |  51 +-
 Lib/zipimport.py                              | 395 ++++++++-------
 8 files changed, 675 insertions(+), 409 deletions(-)
 create mode 100644 Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part
 create mode 100644 Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part
 create mode 100644 Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part

diff --git a/Lib/test/test_zipfile/_path/test_path.py b/Lib/test/test_zipfile/_path/test_path.py
index 2d1c06cd968..5c69c77f7d8 100644
--- a/Lib/test/test_zipfile/_path/test_path.py
+++ b/Lib/test/test_zipfile/_path/test_path.py
@@ -275,7 +275,8 @@ def test_pathlike_construction(self, alpharep):
         """
         zipfile_ondisk = self.zipfile_ondisk(alpharep)
         pathlike = FakePath(str(zipfile_ondisk))
-        zipfile.Path(pathlike)
+        root = zipfile.Path(pathlike)
+        root.root.close()
 
     @pass_alpharep
     def test_traverse_pathlike(self, alpharep):
@@ -374,6 +375,7 @@ def test_root_on_disk(self, alpharep):
         root = zipfile.Path(self.zipfile_ondisk(alpharep))
         assert root.name == 'alpharep.zip' == root.filename.name
         assert root.stem == 'alpharep' == root.filename.stem
+        root.root.close()
 
     @pass_alpharep
     def test_suffix(self, alpharep):
@@ -565,7 +567,7 @@ def test_inheritance(self, alpharep):
         file = cls(alpharep).joinpath('some dir').parent
         assert isinstance(file, cls)
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON, fails on Windows")
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; fails on Windows')
     @parameterize(
         ['alpharep', 'path_type', 'subpath'],
         itertools.product(
@@ -576,11 +578,13 @@ def test_inheritance(self, alpharep):
     )
     def test_pickle(self, alpharep, path_type, subpath):
         zipfile_ondisk = path_type(str(self.zipfile_ondisk(alpharep)))
-
-        saved_1 = pickle.dumps(zipfile.Path(zipfile_ondisk, at=subpath))
+        root = zipfile.Path(zipfile_ondisk, at=subpath)
+        saved_1 = pickle.dumps(root)
+        root.root.close()
         restored_1 = pickle.loads(saved_1)
         first, *rest = restored_1.iterdir()
         assert first.read_text(encoding='utf-8').startswith('content of ')
+        restored_1.root.close()
 
     @pass_alpharep
     def test_extract_orig_with_implied_dirs(self, alpharep):
@@ -592,6 +596,7 @@ def test_extract_orig_with_implied_dirs(self, alpharep):
         # wrap the zipfile for its side effect
         zipfile.Path(zf)
         zf.extractall(source_path.parent)
+        zf.close()
 
     @pass_alpharep
     def test_getinfo_missing(self, alpharep):
diff --git a/Lib/test/test_zipfile/test_core.py b/Lib/test/test_zipfile/test_core.py
index fa1feef00cd..63413d7b944 100644
--- a/Lib/test/test_zipfile/test_core.py
+++ b/Lib/test/test_zipfile/test_core.py
@@ -302,26 +302,26 @@ def test_low_compression(self):
                 self.assertEqual(openobj.read(1), b'2')
 
     def test_writestr_compression(self):
-        zipfp = zipfile.ZipFile(TESTFN2, "w")
-        zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
-        info = zipfp.getinfo('b.txt')
-        self.assertEqual(info.compress_type, self.compression)
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
+            info = zipfp.getinfo('b.txt')
+            self.assertEqual(info.compress_type, self.compression)
 
     def test_writestr_compresslevel(self):
-        zipfp = zipfile.ZipFile(TESTFN2, "w", compresslevel=1)
-        zipfp.writestr("a.txt", "hello world", compress_type=self.compression)
-        zipfp.writestr("b.txt", "hello world", compress_type=self.compression,
-                       compresslevel=2)
+        with zipfile.ZipFile(TESTFN2, "w", compresslevel=1) as zipfp:
+            zipfp.writestr("a.txt", "hello world", compress_type=self.compression)
+            zipfp.writestr("b.txt", "hello world", compress_type=self.compression,
+                           compresslevel=2)
 
-        # Compression level follows the constructor.
-        a_info = zipfp.getinfo('a.txt')
-        self.assertEqual(a_info.compress_type, self.compression)
-        self.assertEqual(a_info.compress_level, 1)
+            # Compression level follows the constructor.
+            a_info = zipfp.getinfo('a.txt')
+            self.assertEqual(a_info.compress_type, self.compression)
+            self.assertEqual(a_info.compress_level, 1)
 
-        # Compression level is overridden.
-        b_info = zipfp.getinfo('b.txt')
-        self.assertEqual(b_info.compress_type, self.compression)
-        self.assertEqual(b_info._compresslevel, 2)
+            # Compression level is overridden.
+            b_info = zipfp.getinfo('b.txt')
+            self.assertEqual(b_info.compress_type, self.compression)
+            self.assertEqual(b_info._compresslevel, 2)
 
     def test_read_return_size(self):
         # Issue #9837: ZipExtFile.read() shouldn't return more bytes
@@ -884,6 +884,8 @@ def make_zip64_file(
         self, file_size_64_set=False, file_size_extra=False,
         compress_size_64_set=False, compress_size_extra=False,
         header_offset_64_set=False, header_offset_extra=False,
+        extensible_data=b'',
+        end_of_central_dir_size=None, offset_to_end_of_central_dir=None,
     ):
         """Generate bytes sequence for a zip with (incomplete) zip64 data.
 
@@ -937,6 +939,12 @@ def make_zip64_file(
 
         central_dir_size = struct.pack('<Q', 58 + 8 * len(central_zip64_fields))
         offset_to_central_dir = struct.pack('<Q', 50 + 8 * len(local_zip64_fields))
+        if end_of_central_dir_size is None:
+            end_of_central_dir_size = 44 + len(extensible_data)
+        if offset_to_end_of_central_dir is None:
+            offset_to_end_of_central_dir = (108
+                                            + 8 * len(local_zip64_fields)
+                                            + 8 * len(central_zip64_fields))
 
         local_extra_length = struct.pack("<H", 4 + 8 * len(local_zip64_fields))
         central_extra_length = struct.pack("<H", 4 + 8 * len(central_zip64_fields))
@@ -965,14 +973,17 @@ def make_zip64_file(
             + filename
             + central_extra
             # Zip64 end of central directory
-            + b"PK\x06\x06,\x00\x00\x00\x00\x00\x00\x00-\x00-"
-            + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00"
+            + b"PK\x06\x06"
+            + struct.pack('<Q', end_of_central_dir_size)
+            + b"-\x00-\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00"
             + b"\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
             + central_dir_size
             + offset_to_central_dir
+            + extensible_data
             # Zip64 end of central directory locator
-            + b"PK\x06\x07\x00\x00\x00\x00l\x00\x00\x00\x00\x00\x00\x00\x01"
-            + b"\x00\x00\x00"
+            + b"PK\x06\x07\x00\x00\x00\x00"
+            + struct.pack('<Q', offset_to_end_of_central_dir)
+            + b"\x01\x00\x00\x00"
             # end of central directory
             + b"PK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00:\x00\x00\x002\x00"
             + b"\x00\x00\x00\x00"
@@ -1003,6 +1014,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_file_size_extra))
         self.assertIn('file size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_file_size_extra)))
 
         # zip64 file size present, zip64 compress size present, one field in
         # extra, expecting two, equals missing compress size.
@@ -1014,6 +1026,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
         self.assertIn('compress size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_compress_size_extra)))
 
         # zip64 compress size present, no fields in extra, expecting one,
         # equals missing compress size.
@@ -1023,6 +1036,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
         self.assertIn('compress size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_compress_size_extra)))
 
         # zip64 file size present, zip64 compress size present, zip64 header
         # offset present, two fields in extra, expecting three, equals missing
@@ -1037,6 +1051,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
         self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
 
         # zip64 compress size present, zip64 header offset present, one field
         # in extra, expecting two, equals missing header offset
@@ -1049,6 +1064,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
         self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
 
         # zip64 file size present, zip64 header offset present, one field in
         # extra, expecting two, equals missing header offset
@@ -1061,6 +1077,7 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
         self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
 
         # zip64 header offset present, no fields in extra, expecting one,
         # equals missing header offset
@@ -1072,6 +1089,63 @@ def test_bad_zip64_extra(self):
         with self.assertRaises(zipfile.BadZipFile) as e:
             zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
         self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
+
+    def test_bad_zip64_end_of_central_dir(self):
+        zipdata = self.make_zip64_file(end_of_central_dir_size=0)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(end_of_central_dir_size=100)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(offset_to_end_of_central_dir=0)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(offset_to_end_of_central_dir=1000)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*locator'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+    def test_zip64_end_of_central_dir_record_not_found(self):
+        zipdata = self.make_zip64_file()
+        zipdata = zipdata.replace(b"PK\x06\x06", b'\x00'*4)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(
+            extensible_data=b'\xca\xfe\x04\x00\x00\x00data')
+        zipdata = zipdata.replace(b"PK\x06\x06", b'\x00'*4)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+    def test_zip64_extensible_data(self):
+        # These values are what is set in the make_zip64_file method.
+        expected_file_size = 8
+        expected_compress_size = 8
+        expected_header_offset = 0
+        expected_content = b"test1234"
+
+        zipdata = self.make_zip64_file(
+            extensible_data=b'\xca\xfe\x04\x00\x00\x00data')
+        with zipfile.ZipFile(io.BytesIO(zipdata)) as zf:
+            zinfo = zf.infolist()[0]
+            self.assertEqual(zinfo.file_size, expected_file_size)
+            self.assertEqual(zinfo.compress_size, expected_compress_size)
+            self.assertEqual(zinfo.header_offset, expected_header_offset)
+            self.assertEqual(zf.read(zinfo), expected_content)
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(b'prepended' + zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(b'prepended' + zipdata)))
 
     def test_generated_valid_zip64_extra(self):
         # These values are what is set in the make_zip64_file method.
@@ -1357,8 +1431,7 @@ def requiresWriteAccess(self, path):
             self.skipTest('requires write access to the installed location')
         unlink(filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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:
@@ -1389,8 +1462,7 @@ def test_write_pyfile(self):
             self.assertNotIn(bn, zipfp.namelist())
             self.assertCompiledIn(bn, zipfp.namelist())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_python_package(self):
         import email
         packagedir = os.path.dirname(email.__file__)
@@ -1405,8 +1477,7 @@ def test_write_python_package(self):
             self.assertCompiledIn('email/__init__.py', names)
             self.assertCompiledIn('email/mime/text.py', names)
 
-    # TODO: RUSTPYTHON - AttributeError: module 'os' has no attribute 'supports_effective_ids'
-    @unittest.expectedFailure
+    @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__)
@@ -1437,8 +1508,7 @@ def filter(path):
                 print(reportStr)
             self.assertTrue('SyntaxError' not in reportStr)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_with_optimization(self):
         import email
         packagedir = os.path.dirname(email.__file__)
@@ -2189,6 +2259,7 @@ def test_empty_zipfile(self):
             zipf = zipfile.ZipFile(TESTFN, mode="r")
         except zipfile.BadZipFile:
             self.fail("Unable to create empty ZIP file in 'w' mode")
+        zipf.close()
 
         zipf = zipfile.ZipFile(TESTFN, mode="a")
         zipf.close()
@@ -2196,6 +2267,7 @@ def test_empty_zipfile(self):
             zipf = zipfile.ZipFile(TESTFN, mode="r")
         except:
             self.fail("Unable to create empty ZIP file in 'a' mode")
+        zipf.close()
 
     def test_open_empty_file(self):
         # Issue 1710703: Check that opening a file with less than 22 bytes
@@ -3020,11 +3092,6 @@ def test_write_after_read(self):
             self.assertEqual(data1, self.data1)
             self.assertEqual(data2, self.data2)
 
-    # TODO: RUSTPYTHON other tests can impact the file descriptor incrementor
-    # by leaving file handles unclosed. If there are more than 100 files in
-    # TESTFN and references to them are left unclosed and ungarbage collected
-    # in another test, then fileno() will always be too high for this test to
-    # pass. The solution is to increase the number of files from 100 to 200
     def test_many_opens(self):
         # Verify that read() and open() promptly close the file descriptor,
         # and don't rely on the garbage collector to free resources.
@@ -3348,8 +3415,7 @@ def test_read_zip_with_exe_prepended(self):
     def test_read_zip64_with_exe_prepended(self):
         self._test_zip_works(self.exe_zip64)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.executable, 'sys.executable required.')
     @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
                          'Test relies on #!/bin/bash working.')
@@ -3358,8 +3424,7 @@ def test_execute_zip2(self):
         output = subprocess.check_output([self.exe_zip, sys.executable])
         self.assertIn(b'number in executable: 5', output)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.executable, 'sys.executable required.')
     @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
                          'Test relies on #!/bin/bash working.')
@@ -3369,7 +3434,6 @@ def test_execute_zip64(self):
         self.assertIn(b'number in executable: 5', output)
 
 
-# TODO: RUSTPYTHON
 @unittest.skip("TODO: RUSTPYTHON shift_jis encoding unsupported")
 class EncodedMetadataTests(unittest.TestCase):
     file_names = ['\u4e00', '\u4e8c', '\u4e09']  # Han 'one', 'two', 'three'
@@ -3377,8 +3441,10 @@ class EncodedMetadataTests(unittest.TestCase):
         "This is pure ASCII.\n".encode('ascii'),
         # This is modern Japanese. (UTF-8)
         "\u3053\u308c\u306f\u73fe\u4ee3\u7684\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('utf-8'),
+        # TODO RUSTPYTHON
+        # Uncomment when Shift JIS is supported
         # This is obsolete Japanese. (Shift JIS)
-        # "\u3053\u308c\u306f\u53e4\u3044\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('shift_jis'),  # TODO: RUSTPYTHON
+        # "\u3053\u308c\u306f\u53e4\u3044\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('shift_jis'),
     ]
 
     def setUp(self):
@@ -3418,11 +3484,13 @@ def _test_read(self, zipfp, expected_names, expected_content):
             self.assertEqual(info.file_size, len(content))
             self.assertEqual(zipfp.read(name), content)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_read_with_metadata_encoding(self):
         # Read the ZIP archive with correct metadata_encoding
         with zipfile.ZipFile(TESTFN, "r", metadata_encoding='shift_jis') as zipfp:
             self._test_read(zipfp, self.file_names, self.file_content)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_read_without_metadata_encoding(self):
         # Read the ZIP archive without metadata_encoding
         expected_names = [name.encode('shift_jis').decode('cp437')
@@ -3430,6 +3498,7 @@ def test_read_without_metadata_encoding(self):
         with zipfile.ZipFile(TESTFN, "r") as zipfp:
             self._test_read(zipfp, expected_names, self.file_content)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_read_with_incorrect_metadata_encoding(self):
         # Read the ZIP archive with incorrect metadata_encoding
         expected_names = [name.encode('shift_jis').decode('koi8-u')
@@ -3437,6 +3506,7 @@ def test_read_with_incorrect_metadata_encoding(self):
         with zipfile.ZipFile(TESTFN, "r", metadata_encoding='koi8-u') as zipfp:
             self._test_read(zipfp, expected_names, self.file_content)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_read_with_unsuitable_metadata_encoding(self):
         # Read the ZIP archive with metadata_encoding unsuitable for
         # decoding metadata
@@ -3445,6 +3515,7 @@ def test_read_with_unsuitable_metadata_encoding(self):
         with self.assertRaises(UnicodeDecodeError):
             zipfile.ZipFile(TESTFN, "r", metadata_encoding='utf-8')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_read_after_append(self):
         newname = '\u56db'  # Han 'four'
         expected_names = [name.encode('shift_jis').decode('cp437')
@@ -3471,6 +3542,7 @@ def test_read_after_append(self):
                 else:
                     self.assertEqual(zipfp.read(name), content)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_write_with_metadata_encoding(self):
         ZF = zipfile.ZipFile
         for mode in ("w", "x", "a"):
@@ -3478,6 +3550,7 @@ def test_write_with_metadata_encoding(self):
                                         "^metadata_encoding is only"):
                 ZF("nonesuch.zip", mode, metadata_encoding="shift_jis")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_cli_with_metadata_encoding(self):
         errmsg = "Non-conforming encodings not supported with -c."
         args = ["--metadata-encoding=shift_jis", "-c", "nonesuch", "nonesuch"]
@@ -3497,6 +3570,7 @@ def test_cli_with_metadata_encoding(self):
         for name in self.file_names:
             self.assertIn(name, listing)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
     def test_cli_with_metadata_encoding_extract(self):
         os.mkdir(TESTFN2)
         self.addCleanup(rmtree, TESTFN2)
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index b9c1fd6134e..a6898e9182d 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -1,8 +1,10 @@
 import sys
 import os
 import marshal
+import glob
 import importlib
 import importlib.util
+import re
 import struct
 import time
 import unittest
@@ -50,10 +52,14 @@ def module_path_to_dotted_name(path):
 
 
 TESTMOD = "ziptestmodule"
+TESTMOD2 = "ziptestmodule2"
+TESTMOD3 = "ziptestmodule3"
 TESTPACK = "ziptestpackage"
 TESTPACK2 = "ziptestpackage2"
+TESTPACK3 = "ziptestpackage3"
 TEMP_DIR = os.path.abspath("junk95142")
 TEMP_ZIP = os.path.abspath("junk95142.zip")
+TEST_DATA_DIR = os.path.join(os.path.dirname(__file__), "zipimport_data")
 
 pyc_file = importlib.util.cache_from_source(TESTMOD + '.py')
 pyc_ext = '.pyc'
@@ -92,8 +98,10 @@ def makeTree(self, files, dirName=TEMP_DIR):
         # defined by files under the directory dirName.
         self.addCleanup(os_helper.rmtree, dirName)
 
-        for name, (mtime, data) in files.items():
-            path = os.path.join(dirName, name)
+        for name, data in files.items():
+            if isinstance(data, tuple):
+                mtime, data = data
+            path = os.path.join(dirName, *name.split('/'))
             if path[-1] == os.sep:
                 if not os.path.isdir(path):
                     os.makedirs(path)
@@ -104,22 +112,18 @@ def makeTree(self, files, dirName=TEMP_DIR):
                 with open(path, 'wb') as fp:
                     fp.write(data)
 
-    def makeZip(self, files, zipName=TEMP_ZIP, **kw):
+    def makeZip(self, files, zipName=TEMP_ZIP, *,
+                comment=None, file_comment=None, stuff=None, prefix='', **kw):
         # Create a zip archive based set of modules/packages
-        # defined by files in the zip file zipName.  If the
-        # key 'stuff' exists in kw it is prepended to the archive.
+        # defined by files in the zip file zipName.
+        # If stuff is not None, it is prepended to the archive.
         self.addCleanup(os_helper.unlink, zipName)
 
-        with ZipFile(zipName, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                z.writestr(zinfo, data)
-            comment = kw.get("comment", None)
+        with ZipFile(zipName, "w", compression=self.compression) as z:
+            self.writeZip(z, files, file_comment=file_comment, prefix=prefix)
             if comment is not None:
                 z.comment = comment
 
-        stuff = kw.get("stuff", None)
         if stuff is not None:
             # Prepend 'stuff' to the start of the zipfile
             with open(zipName, "rb") as f:
@@ -128,20 +132,47 @@ def makeZip(self, files, zipName=TEMP_ZIP, **kw):
                 f.write(stuff)
                 f.write(data)
 
+    def writeZip(self, z, files, *, file_comment=None, prefix=''):
+        for name, data in files.items():
+            if isinstance(data, tuple):
+                mtime, data = data
+            else:
+                mtime = NOW
+            name = name.replace(os.sep, '/')
+            zinfo = ZipInfo(prefix + name, time.localtime(mtime))
+            zinfo.compress_type = self.compression
+            if file_comment is not None:
+                zinfo.comment = file_comment
+            if data is None:
+                zinfo.CRC = 0
+                z.mkdir(zinfo)
+            else:
+                assert name[-1] != '/'
+                z.writestr(zinfo, data)
+
+    def getZip64Files(self):
+        # This is the simplest way to make zipfile generate the zip64 EOCD block
+        return {f"f{n}.py": test_src for n in range(65537)}
+
     def doTest(self, expected_ext, files, *modules, **kw):
+        if 'prefix' not in kw:
+            kw['prefix'] = 'pre/fix/'
         self.makeZip(files, **kw)
+        self.doTestWithPreBuiltZip(expected_ext, *modules, **kw)
 
-        sys.path.insert(0, TEMP_ZIP)
+    def doTestWithPreBuiltZip(self, expected_ext, *modules,
+                              call=None, prefix='', **kw):
+        zip_path = os.path.join(TEMP_ZIP, *prefix.split('/')[:-1])
+        sys.path.insert(0, zip_path)
 
         mod = importlib.import_module(".".join(modules))
 
-        call = kw.get('call')
         if call is not None:
             call(mod)
 
         if expected_ext:
             file = mod.get_file()
-            self.assertEqual(file, os.path.join(TEMP_ZIP,
+            self.assertEqual(file, os.path.join(zip_path,
                                  *modules) + expected_ext)
 
     def testAFakeZlib(self):
@@ -155,7 +186,8 @@ def testAFakeZlib(self):
         # zlib.decompress function object, after which the problem being
         # tested here wouldn't be a problem anymore...
         # (Hence the 'A' in the test method name: to make it the first
-        # item in a list sorted by name, like unittest.makeSuite() does.)
+        # item in a list sorted by name, like
+        # unittest.TestLoader.getTestCaseNames() does.)
         #
         # This test fails on platforms on which the zlib module is
         # statically linked, but the problem it tests for can't
@@ -166,7 +198,7 @@ def testAFakeZlib(self):
             self.skipTest('zlib is a builtin module')
         if "zlib" in sys.modules:
             del sys.modules["zlib"]
-        files = {"zlib.py": (NOW, test_src)}
+        files = {"zlib.py": test_src}
         try:
             self.doTest(".py", files, "zlib")
         except ImportError:
@@ -177,16 +209,16 @@ def testAFakeZlib(self):
                 self.fail("expected test to raise ImportError")
 
     def testPy(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD)
 
     def testPyc(self):
-        files = {TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTMOD)
 
     def testBoth(self):
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTMOD)
 
     def testUncheckedHashBasedPyc(self):
@@ -219,22 +251,22 @@ def check(mod):
         self.doTest(None, files, TESTMOD, call=check)
 
     def testEmptyPy(self):
-        files = {TESTMOD + ".py": (NOW, "")}
+        files = {TESTMOD + ".py": ""}
         self.doTest(None, files, TESTMOD)
 
     def testBadMagic(self):
         # make pyc magic word invalid, forcing loading from .py
         badmagic_pyc = bytearray(test_pyc)
         badmagic_pyc[0] ^= 0x04  # flip an arbitrary bit
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: badmagic_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def testBadMagic2(self):
         # make pyc magic word invalid, causing an ImportError
         badmagic_pyc = bytearray(test_pyc)
         badmagic_pyc[0] ^= 0x04  # flip an arbitrary bit
-        files = {TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
+        files = {TESTMOD + pyc_ext: badmagic_pyc}
         try:
             self.doTest(".py", files, TESTMOD)
             self.fail("This should not be reached")
@@ -247,22 +279,22 @@ def testBadMTime(self):
         # flip the second bit -- not the first as that one isn't stored in the
         # .py's mtime in the zip archive.
         badtime_pyc[11] ^= 0x02
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, badtime_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: badtime_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def test2038MTime(self):
         # Make sure we can handle mtimes larger than what a 32-bit signed number
         # can hold.
         twenty_thirty_eight_pyc = make_pyc(test_co, 2**32 - 1, len(test_src))
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, twenty_thirty_eight_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: twenty_thirty_eight_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def testPackage(self):
         packdir = TESTPACK + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTMOD)
 
     def testSubPackage(self):
@@ -270,9 +302,9 @@ def testSubPackage(self):
         # archives.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTPACK2, TESTMOD)
 
     def testSubNamespacePackage(self):
@@ -281,9 +313,9 @@ def testSubNamespacePackage(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
         # The first two files are just directory entries (so have no data).
-        files = {packdir: (NOW, ""),
-                 packdir2: (NOW, ""),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir: None,
+                 packdir2: None,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTPACK2, TESTMOD)
 
     def testMixedNamespacePackage(self):
@@ -291,19 +323,19 @@ def testMixedNamespacePackage(self):
         # real filesystem and a zip archive.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        packdir3 = packdir2 + TESTPACK + '3' + os.sep
-        files1 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir3: (NOW, ""),
-                  packdir3 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + '3' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
-        files2 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir2 + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        packdir3 = packdir2 + TESTPACK3 + os.sep
+        files1 = {packdir: None,
+                  packdir + TESTMOD + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir3: None,
+                  packdir3 + TESTMOD + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD3 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
+        files2 = {packdir: None,
+                  packdir + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir2 + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
 
         zip1 = os.path.abspath("path1.zip")
         self.makeZip(files1, zip1)
@@ -336,8 +368,8 @@ def testMixedNamespacePackage(self):
         mod = importlib.import_module('.'.join((TESTPACK, TESTMOD)))
         self.assertEqual("path1.zip", mod.__file__.split(os.sep)[-3])
 
-        # And TESTPACK/(TESTMOD + '2') only exists in path2.
-        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD + '2')))
+        # And TESTPACK/(TESTMOD2) only exists in path2.
+        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD2)))
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-3])
 
@@ -354,13 +386,13 @@ def testMixedNamespacePackage(self):
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-4])
 
-        # subpkg.TESTMOD + '2' only exists in zip2.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '2')))
+        # subpkg.TESTMOD2 only exists in zip2.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD2)))
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-4])
 
-        # Finally subpkg.TESTMOD + '3' only exists in zip1.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '3')))
+        # Finally subpkg.TESTMOD3 only exists in zip1.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD3)))
         self.assertEqual('path1.zip', mod.__file__.split(os.sep)[-4])
 
     def testNamespacePackage(self):
@@ -368,22 +400,22 @@ def testNamespacePackage(self):
         # archives.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        packdir3 = packdir2 + TESTPACK + '3' + os.sep
-        files1 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir3: (NOW, ""),
-                  packdir3 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + '3' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        packdir3 = packdir2 + TESTPACK3 + os.sep
+        files1 = {packdir: None,
+                  packdir + TESTMOD + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir3: None,
+                  packdir3 + TESTMOD + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD3 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
         zip1 = os.path.abspath("path1.zip")
         self.makeZip(files1, zip1)
 
-        files2 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir2 + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files2 = {packdir: None,
+                  packdir + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir2 + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
         zip2 = os.path.abspath("path2.zip")
         self.makeZip(files2, zip2)
 
@@ -412,8 +444,8 @@ def testNamespacePackage(self):
         mod = importlib.import_module('.'.join((TESTPACK, TESTMOD)))
         self.assertEqual("path1.zip", mod.__file__.split(os.sep)[-3])
 
-        # And TESTPACK/(TESTMOD + '2') only exists in path2.
-        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD + '2')))
+        # And TESTPACK/(TESTMOD2) only exists in path2.
+        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD2)))
         self.assertEqual("path2.zip", mod.__file__.split(os.sep)[-3])
 
         # One level deeper...
@@ -428,29 +460,22 @@ def testNamespacePackage(self):
         mod = importlib.import_module('.'.join((subpkg, TESTMOD)))
         self.assertEqual('path2.zip', mod.__file__.split(os.sep)[-4])
 
-        # subpkg.TESTMOD + '2' only exists in zip2.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '2')))
+        # subpkg.TESTMOD2 only exists in zip2.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD2)))
         self.assertEqual('path2.zip', mod.__file__.split(os.sep)[-4])
 
-        # Finally subpkg.TESTMOD + '3' only exists in zip1.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '3')))
+        # Finally subpkg.TESTMOD3 only exists in zip1.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD3)))
         self.assertEqual('path1.zip', mod.__file__.split(os.sep)[-4])
 
     def testZipImporterMethods(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                 "spam" + pyc_ext: (NOW, test_pyc)}
-
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
         zi = zipimport.zipimporter(TEMP_ZIP)
         self.assertEqual(zi.archive, TEMP_ZIP)
@@ -459,12 +484,6 @@ def testZipImporterMethods(self):
         # PEP 302
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", DeprecationWarning)
-            find_mod = zi.find_module('spam')
-            self.assertIsNotNone(find_mod)
-            self.assertIsInstance(find_mod, zipimport.zipimporter)
-            self.assertFalse(find_mod.is_package('spam'))
-            load_mod = find_mod.load_module('spam')
-            self.assertEqual(find_mod.get_filename('spam'), load_mod.__file__)
 
             mod = zi.load_module(TESTPACK)
             self.assertEqual(zi.get_filename(TESTPACK), mod.__file__)
@@ -512,58 +531,68 @@ def testZipImporterMethods(self):
     def testInvalidateCaches(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                 "spam" + pyc_ext: (NOW, test_pyc)}
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
         zi = zipimport.zipimporter(TEMP_ZIP)
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         # Check that the file information remains accurate after reloading
         zi.invalidate_caches()
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         # Add a new file to the ZIP archive
-        newfile = {"spam2" + pyc_ext: (NOW, test_pyc)}
+        newfile = {"spam2" + pyc_ext: test_pyc}
         files.update(newfile)
-        with ZipFile(TEMP_ZIP, "a") as z:
-            for name, (mtime, data) in newfile.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        with ZipFile(TEMP_ZIP, "a", compression=self.compression) as z:
+            self.writeZip(z, newfile, file_comment=b"spam")
         # Check that we can detect the new file after invalidating the cache
         zi.invalidate_caches()
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         spec = zi.find_spec('spam2')
         self.assertIsNotNone(spec)
         self.assertIsInstance(spec.loader, zipimport.zipimporter)
         # Check that the cached data is removed if the file is deleted
         os.remove(TEMP_ZIP)
         zi.invalidate_caches()
-        self.assertFalse(zi._files)
+        self.assertFalse(zi._get_files())
         self.assertIsNone(zipimport._zip_directory_cache.get(zi.archive))
         self.assertIsNone(zi.find_spec("name_does_not_matter"))
 
-    def testZipImporterMethodsInSubDirectory(self):
+    def testInvalidateCachesWithMultipleZipimports(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"eggs"
-                z.writestr(zinfo, data)
+        zi = zipimport.zipimporter(TEMP_ZIP)
+        self.assertEqual(zi._get_files().keys(), files.keys())
+        # Zipimporter for the same path.
+        zi2 = zipimport.zipimporter(TEMP_ZIP)
+        self.assertEqual(zi2._get_files().keys(), files.keys())
+        # Add a new file to the ZIP archive to make the cache wrong.
+        newfile = {"spam2" + pyc_ext: test_pyc}
+        files.update(newfile)
+        with ZipFile(TEMP_ZIP, "a", compression=self.compression) as z:
+            self.writeZip(z, newfile, file_comment=b"spam")
+        # Invalidate the cache of the first zipimporter.
+        zi.invalidate_caches()
+        # Check that the second zipimporter detects the new file and isn't using a stale cache.
+        self.assertEqual(zi2._get_files().keys(), files.keys())
+        spec = zi2.find_spec('spam2')
+        self.assertIsNotNone(spec)
+        self.assertIsInstance(spec.loader, zipimport.zipimporter)
+
+    def testZipImporterMethodsInSubDirectory(self):
+        packdir = TESTPACK + os.sep
+        packdir2 = packdir + TESTPACK2 + os.sep
+        files = {packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"eggs")
 
         zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir)
         self.assertEqual(zi.archive, TEMP_ZIP)
@@ -585,16 +614,6 @@ def testZipImporterMethodsInSubDirectory(self):
 
         pkg_path = TEMP_ZIP + os.sep + packdir + TESTPACK2
         zi2 = zipimport.zipimporter(pkg_path)
-        # PEP 302
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            find_mod_dotted = zi2.find_module(TESTMOD)
-            self.assertIsNotNone(find_mod_dotted)
-            self.assertIsInstance(find_mod_dotted, zipimport.zipimporter)
-            self.assertFalse(zi2.is_package(TESTMOD))
-            load_mod = find_mod_dotted.load_module(TESTMOD)
-            self.assertEqual(
-                find_mod_dotted.get_filename(TESTMOD), load_mod.__file__)
 
         # PEP 451
         spec = zi2.find_spec(TESTMOD)
@@ -638,9 +657,9 @@ def get_file():
         if __loader__.get_data("some.data") != b"some data":
             raise AssertionError("bad data")\n"""
         pyc = make_pyc(compile(src, "<???>", "exec"), NOW, len(src))
-        files = {TESTMOD + pyc_ext: (NOW, pyc),
-                 "some.data": (NOW, "some data")}
-        self.doTest(pyc_ext, files, TESTMOD)
+        files = {TESTMOD + pyc_ext: pyc,
+                 "some.data": "some data"}
+        self.doTest(pyc_ext, files, TESTMOD, prefix='')
 
     def testDefaultOptimizationLevel(self):
         # zipimport should use the default optimization level (#28131)
@@ -648,17 +667,20 @@ def testDefaultOptimizationLevel(self):
         def test(val):
             assert(val)
             return val\n"""
-        files = {TESTMOD + '.py': (NOW, src)}
+        files = {TESTMOD + '.py': src}
         self.makeZip(files)
         sys.path.insert(0, TEMP_ZIP)
         mod = importlib.import_module(TESTMOD)
         self.assertEqual(mod.test(1), 1)
-        self.assertRaises(AssertionError, mod.test, False)
+        if __debug__:
+            self.assertRaises(AssertionError, mod.test, False)
+        else:
+            self.assertEqual(mod.test(0), 0)
 
     def testImport_WithStuff(self):
         # try importing from a zipfile which contains additional
         # stuff at the beginning of the file
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD,
                     stuff=b"Some Stuff"*31)
 
@@ -666,18 +688,18 @@ def assertModuleSource(self, module):
         self.assertEqual(inspect.getsource(module), test_src)
 
     def testGetSource(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, call=self.assertModuleSource)
 
     def testGetCompiledSource(self):
         pyc = make_pyc(compile(test_src, "<???>", "exec"), NOW, len(test_src))
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: pyc}
         self.doTest(pyc_ext, files, TESTMOD, call=self.assertModuleSource)
 
     def runDoctest(self, callback):
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 "xyz.txt": (NOW, ">>> log.append(True)\n")}
+        files = {TESTMOD + ".py": test_src,
+                 "xyz.txt": ">>> log.append(True)\n"}
         self.doTest(".py", files, TESTMOD, call=callback)
 
     def doDoctestFile(self, module):
@@ -720,56 +742,177 @@ def doTraceback(self, module):
 
             s = io.StringIO()
             print_tb(tb, 1, s)
-            self.assertTrue(s.getvalue().endswith(raise_src))
+            self.assertTrue(s.getvalue().endswith(
+                '    def do_raise(): raise TypeError\n'
+                '' if support.has_no_debug_ranges() else
+                '                    ^^^^^^^^^^^^^^^\n'
+            ))
         else:
             raise AssertionError("This ought to be impossible")
 
-    # TODO: RUSTPYTHON; empty caret lines from equal col/end_col
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; empty caret lines from equal col/end_col
     def testTraceback(self):
-        files = {TESTMOD + ".py": (NOW, raise_src)}
+        files = {TESTMOD + ".py": raise_src}
         self.doTest(None, files, TESTMOD, call=self.doTraceback)
 
     @unittest.skipIf(os_helper.TESTFN_UNENCODABLE is None,
                      "need an unencodable filename")
     def testUnencodable(self):
         filename = os_helper.TESTFN_UNENCODABLE + ".zip"
-        self.addCleanup(os_helper.unlink, filename)
-        with ZipFile(filename, "w") as z:
-            zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
-            zinfo.compress_type = self.compression
-            z.writestr(zinfo, test_src)
+        self.makeZip({TESTMOD + ".py": test_src}, filename)
         spec = zipimport.zipimporter(filename).find_spec(TESTMOD)
         mod = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(mod)
 
     def testBytesPath(self):
         filename = os_helper.TESTFN + ".zip"
-        self.addCleanup(os_helper.unlink, filename)
-        with ZipFile(filename, "w") as z:
-            zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
-            zinfo.compress_type = self.compression
-            z.writestr(zinfo, test_src)
+        self.makeZip({TESTMOD + ".py": test_src}, filename)
 
         zipimport.zipimporter(filename)
-        zipimport.zipimporter(os.fsencode(filename))
+        with self.assertRaises(TypeError):
+            zipimport.zipimporter(os.fsencode(filename))
         with self.assertRaises(TypeError):
             zipimport.zipimporter(bytearray(os.fsencode(filename)))
         with self.assertRaises(TypeError):
             zipimport.zipimporter(memoryview(os.fsencode(filename)))
 
     def testComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, comment=b"comment")
 
     def testBeginningCruftAndComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, stuff=b"cruft" * 64, comment=b"hi")
 
     def testLargestPossibleComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, comment=b"c" * ((1 << 16) - 1))
 
+    def testZip64(self):
+        files = self.getZip64Files()
+        self.doTest(".py", files, "f6")
+
+    def testZip64CruftAndComment(self):
+        files = self.getZip64Files()
+        self.doTest(".py", files, "f65536", comment=b"c" * ((1 << 16) - 1))
+
+    @unittest.skip('TODO: RUSTPYTHON; (intermittent success/failures); ValueError: name="RustPython/crates/pylib/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part" does not fit expected pattern.')
+    def testZip64LargeFile(self):
+        support.requires(
+            "largefile",
+            f"test generates files >{0xFFFFFFFF} bytes and takes a long time "
+            "to run"
+        )
+
+        # N.B.: We do a lot of gymnastics below in the ZIP_STORED case to save
+        # and reconstruct a sparse zip on systems that support sparse files.
+        # Instead of creating a ~8GB zip file mainly consisting of null bytes
+        # for every run of the test, we create the zip once and save off the
+        # non-null portions of the resulting file as data blobs with offsets
+        # that allow re-creating the zip file sparsely. This drops disk space
+        # usage to ~9KB for the ZIP_STORED case and drops that test time by ~2
+        # orders of magnitude. For the ZIP_DEFLATED case, however, we bite the
+        # bullet. The resulting zip file is ~8MB of non-null data; so the sparse
+        # trick doesn't work and would result in that full ~8MB zip data file
+        # being checked in to source control.
+        parts_glob = f"sparse-zip64-c{self.compression:d}-0x*.part"
+        full_parts_glob = os.path.join(TEST_DATA_DIR, parts_glob)
+        pre_built_zip_parts = glob.glob(full_parts_glob)
+
+        self.addCleanup(os_helper.unlink, TEMP_ZIP)
+        if not pre_built_zip_parts:
+            if self.compression != ZIP_STORED:
+                support.requires(
+                    "cpu",
+                    "test requires a lot of CPU for compression."
+                )
+            self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+            with open(os_helper.TESTFN, "wb") as f:
+                f.write(b"data")
+                f.write(os.linesep.encode())
+                f.seek(0xffff_ffff, os.SEEK_CUR)
+                f.write(os.linesep.encode())
+            os.utime(os_helper.TESTFN, (0.0, 0.0))
+            with ZipFile(
+                TEMP_ZIP,
+                "w",
+                compression=self.compression,
+                strict_timestamps=False
+            ) as z:
+                z.write(os_helper.TESTFN, "data1")
+                z.writestr(
+                    ZipInfo("module.py", (1980, 1, 1, 0, 0, 0)), test_src
+                )
+                z.write(os_helper.TESTFN, "data2")
+
+            # This "works" but relies on the zip format having a non-empty
+            # final page due to the trailing central directory to wind up with
+            # the correct length file.
+            def make_sparse_zip_parts(name):
+                empty_page = b"\0" * 4096
+                with open(name, "rb") as f:
+                    part = None
+                    try:
+                        while True:
+                            offset = f.tell()
+                            data = f.read(len(empty_page))
+                            if not data:
+                                break
+                            if data != empty_page:
+                                if not part:
+                                    part_fullname = os.path.join(
+                                        TEST_DATA_DIR,
+                                        f"sparse-zip64-c{self.compression:d}-"
+                                        f"{offset:#011x}.part",
+                                    )
+                                    os.makedirs(
+                                        os.path.dirname(part_fullname),
+                                        exist_ok=True
+                                    )
+                                    part = open(part_fullname, "wb")
+                                    print("Created", part_fullname)
+                                part.write(data)
+                            else:
+                                if part:
+                                    part.close()
+                                part = None
+                    finally:
+                        if part:
+                            part.close()
+
+            if self.compression == ZIP_STORED:
+                print(f"Creating sparse parts to check in into {TEST_DATA_DIR}:")
+                make_sparse_zip_parts(TEMP_ZIP)
+
+        else:
+            def extract_offset(name):
+                if m := re.search(r"-(0x[0-9a-f]{9})\.part$", name):
+                    return int(m.group(1), base=16)
+                raise ValueError(f"{name=} does not fit expected pattern.")
+            offset_parts = [(extract_offset(n), n) for n in pre_built_zip_parts]
+            with open(TEMP_ZIP, "wb") as f:
+                for offset, part_fn in sorted(offset_parts):
+                    with open(part_fn, "rb") as part:
+                        f.seek(offset, os.SEEK_SET)
+                        f.write(part.read())
+            # Confirm that the reconstructed zip file works and looks right.
+            with ZipFile(TEMP_ZIP, "r") as z:
+                self.assertEqual(
+                    z.getinfo("module.py").date_time, (1980, 1, 1, 0, 0, 0)
+                )
+                self.assertEqual(
+                    z.read("module.py"), test_src.encode(),
+                    msg=f"Recreate {full_parts_glob}, unexpected contents."
+                )
+                def assertDataEntry(name):
+                    zinfo = z.getinfo(name)
+                    self.assertEqual(zinfo.date_time, (1980, 1, 1, 0, 0, 0))
+                    self.assertGreater(zinfo.file_size, 0xffff_ffff)
+                assertDataEntry("data1")
+                assertDataEntry("data2")
+
+        self.doTestWithPreBuiltZip(".py", "module")
+
 
 @support.requires_zlib()
 class CompressedZipImportTestCase(UncompressedZipImportTestCase):
@@ -801,6 +944,7 @@ def testEmptyFile(self):
         os_helper.create_empty_file(TESTMOD)
         self.assertZipFailure(TESTMOD)
 
+    @unittest.skipIf(support.is_wasi, "mode 000 not supported.")
     def testFileUnreadable(self):
         os_helper.unlink(TESTMOD)
         fd = os.open(TESTMOD, os.O_CREAT, 000)
@@ -844,7 +988,6 @@ def _testBogusZipFile(self):
             self.assertRaises(TypeError, z.get_source, None)
 
             error = zipimport.ZipImportError
-            self.assertIsNone(z.find_module('abc'))
             self.assertIsNone(z.find_spec('abc'))
 
             with warnings.catch_warnings():
diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part
new file mode 100644
index 0000000000000000000000000000000000000000..c6beae8e2552d6a7be5c70df6feeb42230270912
GIT binary patch
literal 4096
zcmWIWW@gc4fB;2?DAjhu|4_inAi|K6SdwVS$RNPL3RJ-e#4s8p!3EVeN{xoVXb6mk
kz-S1JhQMeDjE2By2#kinXb6mkz-S1JhQMeD4Dt{F0RIvV#Q*>R

literal 0
HcmV?d00001

diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part
new file mode 100644
index 0000000000000000000000000000000000000000..74ab03b4648948b5a040716f2d0d1dcd6d5f2d8e
GIT binary patch
literal 4096
zcmZQzARBN6cr&wzK(#9}80R11^8oTdm=lO|^HWN5QuPWdQ&Q6u(o;*~^AdAYH8icb
z6o8;8wWPEtPaz&G7$46CQ<IjNgQ*522vh^IP8V)nlxn--e<)yO5MfA3EJ-wCWDsCr
z1u9_#Vi*mQ;DTx!rA9+wGz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONU^E0qLttcv005xg
BD`fxx

literal 0
HcmV?d00001

diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part
new file mode 100644
index 0000000000000000000000000000000000000000..9769a404f675d4d0b38da2a1f8f66cb730d9e3c2
GIT binary patch
literal 546
zcmZQz7zuzYz?+dtmsuC;S4D;>)po=GP{7I{0uO^FjUZ-9Vo9PQBZB|~E0Dto#4sA&
z7~}jSd>%k~5awjy0g@2Vzz8xsH$SB`CsnVYl97Rf!3HP;G78-YRF}v=4Panc(g-pF
z<PsxB1_`(eU@ln=H;#=>2dYVz0p>vl24<)jjJ^rwKL^rGKpf!B#tsrX0CW?G4{;hR
Q8%T^92tn#W4q#va017uX9RL6T

literal 0
HcmV?d00001

diff --git a/Lib/zipfile/__init__.py b/Lib/zipfile/__init__.py
index 05f387a950b..c01f13729e1 100644
--- a/Lib/zipfile/__init__.py
+++ b/Lib/zipfile/__init__.py
@@ -245,7 +245,7 @@ def is_zipfile(filename):
         else:
             with open(filename, "rb") as fp:
                 result = _check_zipfile(fp)
-    except OSError:
+    except (OSError, BadZipFile):
         pass
     return result
 
@@ -253,16 +253,15 @@ def _EndRecData64(fpin, offset, endrec):
     """
     Read the ZIP64 end-of-archive records and use that to update endrec
     """
-    try:
-        fpin.seek(offset - sizeEndCentDir64Locator, 2)
-    except OSError:
-        # If the seek fails, the file is not large enough to contain a ZIP64
+    offset -= sizeEndCentDir64Locator
+    if offset < 0:
+        # The file is not large enough to contain a ZIP64
         # end-of-archive record, so just return the end record we were given.
         return endrec
-
+    fpin.seek(offset)
     data = fpin.read(sizeEndCentDir64Locator)
     if len(data) != sizeEndCentDir64Locator:
-        return endrec
+        raise OSError("Unknown I/O error")
     sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
     if sig != stringEndArchive64Locator:
         return endrec
@@ -270,16 +269,33 @@ def _EndRecData64(fpin, offset, endrec):
     if diskno != 0 or disks > 1:
         raise BadZipFile("zipfiles that span multiple disks are not supported")
 
-    # Assume no 'zip64 extensible data'
-    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
+    offset -= sizeEndCentDir64
+    if reloff > offset:
+        raise BadZipFile("Corrupt zip64 end of central directory locator")
+    # First, check the assumption that there is no prepended data.
+    fpin.seek(reloff)
+    extrasz = offset - reloff
     data = fpin.read(sizeEndCentDir64)
     if len(data) != sizeEndCentDir64:
-        return endrec
+        raise OSError("Unknown I/O error")
+    if not data.startswith(stringEndArchive64) and reloff != offset:
+        # Since we already have seen the Zip64 EOCD Locator, it's
+        # possible we got here because there is prepended data.
+        # Assume no 'zip64 extensible data'
+        fpin.seek(offset)
+        extrasz = 0
+        data = fpin.read(sizeEndCentDir64)
+        if len(data) != sizeEndCentDir64:
+            raise OSError("Unknown I/O error")
+    if not data.startswith(stringEndArchive64):
+        raise BadZipFile("Zip64 end of central directory record not found")
+
     sig, sz, create_version, read_version, disk_num, disk_dir, \
         dircount, dircount2, dirsize, diroffset = \
         struct.unpack(structEndArchive64, data)
-    if sig != stringEndArchive64:
-        return endrec
+    if (diroffset + dirsize != reloff or
+        sz + 12 != sizeEndCentDir64 + extrasz):
+        raise BadZipFile("Corrupt zip64 end of central directory record")
 
     # Update the original endrec using data from the ZIP64 record
     endrec[_ECD_SIGNATURE] = sig
@@ -289,6 +305,7 @@ def _EndRecData64(fpin, offset, endrec):
     endrec[_ECD_ENTRIES_TOTAL] = dircount2
     endrec[_ECD_SIZE] = dirsize
     endrec[_ECD_OFFSET] = diroffset
+    endrec[_ECD_LOCATION] = offset - extrasz
     return endrec
 
 
@@ -322,7 +339,7 @@ def _EndRecData(fpin):
         endrec.append(filesize - sizeEndCentDir)
 
         # Try to read the "Zip64 end of central directory" structure
-        return _EndRecData64(fpin, -sizeEndCentDir, endrec)
+        return _EndRecData64(fpin, filesize - sizeEndCentDir, endrec)
 
     # Either this is not a ZIP file, or it is a ZIP file with an archive
     # comment.  Search the end of the file for the "end of central directory"
@@ -346,8 +363,7 @@ def _EndRecData(fpin):
         endrec.append(maxCommentStart + start)
 
         # Try to read the "Zip64 end of central directory" structure
-        return _EndRecData64(fpin, maxCommentStart + start - filesize,
-                             endrec)
+        return _EndRecData64(fpin, maxCommentStart + start, endrec)
 
     # Unable to find a valid end of central directory structure
     return None
@@ -1458,9 +1474,6 @@ def _RealGetContents(self):
 
         # "concat" is zero, unless zip was concatenated to another file
         concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
-        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
-            # If Zip64 extension structures are present, account for them
-            concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
 
         if self.debug > 2:
             inferred = concat + offset_cd
@@ -2082,7 +2095,7 @@ def _write_end_record(self):
                                    " would require ZIP64 extensions")
             zip64endrec = struct.pack(
                 structEndArchive64, stringEndArchive64,
-                44, 45, 45, 0, 0, centDirCount, centDirCount,
+                sizeEndCentDir64 - 12, 45, 45, 0, 0, centDirCount, centDirCount,
                 centDirSize, centDirOffset)
             self.fp.write(zip64endrec)
 
diff --git a/Lib/zipimport.py b/Lib/zipimport.py
index 25eaee9c0f2..fb312be115e 100644
--- a/Lib/zipimport.py
+++ b/Lib/zipimport.py
@@ -1,11 +1,9 @@
 """zipimport provides support for importing Python modules from Zip archives.
 
-This module exports three objects:
+This module exports two objects:
 - zipimporter: a class; its constructor takes a path to a Zip archive.
 - ZipImportError: exception raised by zipimporter objects. It's a
   subclass of ImportError, so it can be caught as ImportError, too.
-- _zip_directory_cache: a dict, mapping archive paths to zip directory
-  info dicts, as used in zipimporter._files.
 
 It is usually not needed to use the zipimport module explicitly; it is
 used by the builtin import mechanism for sys.path items that are paths
@@ -15,7 +13,7 @@
 #from importlib import _bootstrap_external
 #from importlib import _bootstrap  # for _verbose_message
 import _frozen_importlib_external as _bootstrap_external
-from _frozen_importlib_external import _unpack_uint16, _unpack_uint32
+from _frozen_importlib_external import _unpack_uint16, _unpack_uint32, _unpack_uint64
 import _frozen_importlib as _bootstrap  # for _verbose_message
 import _imp  # for check_hash_based_pycs
 import _io  # for open
@@ -40,8 +38,14 @@ class ZipImportError(ImportError):
 _module_type = type(sys)
 
 END_CENTRAL_DIR_SIZE = 22
-STRING_END_ARCHIVE = b'PK\x05\x06'
+END_CENTRAL_DIR_SIZE_64 = 56
+END_CENTRAL_DIR_LOCATOR_SIZE_64 = 20
+STRING_END_ARCHIVE = b'PK\x05\x06'  # standard EOCD signature
+STRING_END_LOCATOR_64 = b'PK\x06\x07'  # Zip64 EOCD Locator signature
+STRING_END_ZIP_64 = b'PK\x06\x06'  # Zip64 EOCD signature
 MAX_COMMENT_LEN = (1 << 16) - 1
+MAX_UINT32 = 0xffffffff
+ZIP64_EXTRA_TAG = 0x1
 
 class zipimporter(_bootstrap_external._LoaderBasics):
     """zipimporter(archivepath) -> zipimporter object
@@ -63,8 +67,7 @@ class zipimporter(_bootstrap_external._LoaderBasics):
     # if found, or else read it from the archive.
     def __init__(self, path):
         if not isinstance(path, str):
-            import os
-            path = os.fsdecode(path)
+            raise TypeError(f"expected str, not {type(path)!r}")
         if not path:
             raise ZipImportError('archive path is empty', path=path)
         if alt_path_sep:
@@ -89,12 +92,8 @@ def __init__(self, path):
                     raise ZipImportError('not a Zip file', path=path)
                 break
 
-        try:
-            files = _zip_directory_cache[path]
-        except KeyError:
-            files = _read_directory(path)
-            _zip_directory_cache[path] = files
-        self._files = files
+        if path not in _zip_directory_cache:
+            _zip_directory_cache[path] = _read_directory(path)
         self.archive = path
         # a prefix directory following the ZIP file path.
         self.prefix = _bootstrap_external._path_join(*prefix[::-1])
@@ -102,64 +101,6 @@ def __init__(self, path):
             self.prefix += path_sep
 
 
-    # Check whether we can satisfy the import of the module named by
-    # 'fullname', or whether it could be a portion of a namespace
-    # package. Return self if we can load it, a string containing the
-    # full path if it's a possible namespace portion, None if we
-    # can't load it.
-    def find_loader(self, fullname, path=None):
-        """find_loader(fullname, path=None) -> self, str or None.
-
-        Search for a module specified by 'fullname'. 'fullname' must be the
-        fully qualified (dotted) module name. It returns the zipimporter
-        instance itself if the module was found, a string containing the
-        full path name if it's possibly a portion of a namespace package,
-        or None otherwise. The optional 'path' argument is ignored -- it's
-        there for compatibility with the importer protocol.
-
-        Deprecated since Python 3.10. Use find_spec() instead.
-        """
-        _warnings.warn("zipimporter.find_loader() is deprecated and slated for "
-                       "removal in Python 3.12; use find_spec() instead",
-                       DeprecationWarning)
-        mi = _get_module_info(self, fullname)
-        if mi is not None:
-            # This is a module or package.
-            return self, []
-
-        # Not a module or regular package. See if this is a directory, and
-        # therefore possibly a portion of a namespace package.
-
-        # We're only interested in the last path component of fullname
-        # earlier components are recorded in self.prefix.
-        modpath = _get_module_path(self, fullname)
-        if _is_dir(self, modpath):
-            # This is possibly a portion of a namespace
-            # package. Return the string representing its path,
-            # without a trailing separator.
-            return None, [f'{self.archive}{path_sep}{modpath}']
-
-        return None, []
-
-
-    # Check whether we can satisfy the import of the module named by
-    # 'fullname'. Return self if we can, None if we can't.
-    def find_module(self, fullname, path=None):
-        """find_module(fullname, path=None) -> self or None.
-
-        Search for a module specified by 'fullname'. 'fullname' must be the
-        fully qualified (dotted) module name. It returns the zipimporter
-        instance itself if the module was found, or None if it wasn't.
-        The optional 'path' argument is ignored -- it's there for compatibility
-        with the importer protocol.
-
-        Deprecated since Python 3.10. Use find_spec() instead.
-        """
-        _warnings.warn("zipimporter.find_module() is deprecated and slated for "
-                       "removal in Python 3.12; use find_spec() instead",
-                       DeprecationWarning)
-        return self.find_loader(fullname, path)[0]
-
     def find_spec(self, fullname, target=None):
         """Create a ModuleSpec for the specified module.
 
@@ -211,7 +152,7 @@ def get_data(self, pathname):
             key = pathname[len(self.archive + path_sep):]
 
         try:
-            toc_entry = self._files[key]
+            toc_entry = self._get_files()[key]
         except KeyError:
             raise OSError(0, '', key)
         return _get_data(self.archive, toc_entry)
@@ -248,7 +189,7 @@ def get_source(self, fullname):
             fullpath = f'{path}.py'
 
         try:
-            toc_entry = self._files[fullpath]
+            toc_entry = self._get_files()[fullpath]
         except KeyError:
             # we have the module, but no source
             return None
@@ -313,28 +254,28 @@ def load_module(self, fullname):
 
 
     def get_resource_reader(self, fullname):
-        """Return the ResourceReader for a package in a zip file.
-
-        If 'fullname' is a package within the zip file, return the
-        'ResourceReader' object for the package.  Otherwise return None.
-        """
-        try:
-            if not self.is_package(fullname):
-                return None
-        except ZipImportError:
-            return None
+        """Return the ResourceReader for a module in a zip file."""
         from importlib.readers import ZipReader
+
         return ZipReader(self, fullname)
 
 
-    def invalidate_caches(self):
-        """Reload the file data of the archive path."""
+    def _get_files(self):
+        """Return the files within the archive path."""
         try:
-            self._files = _read_directory(self.archive)
-            _zip_directory_cache[self.archive] = self._files
-        except ZipImportError:
-            _zip_directory_cache.pop(self.archive, None)
-            self._files = {}
+            files = _zip_directory_cache[self.archive]
+        except KeyError:
+            try:
+                files = _zip_directory_cache[self.archive] = _read_directory(self.archive)
+            except ZipImportError:
+                files = {}
+
+        return files
+
+
+    def invalidate_caches(self):
+        """Invalidates the cache of file data of the archive path."""
+        _zip_directory_cache.pop(self.archive, None)
 
 
     def __repr__(self):
@@ -364,15 +305,15 @@ def _is_dir(self, path):
     # of a namespace package. We test by seeing if the name, with an
     # appended path separator, exists.
     dirpath = path + path_sep
-    # If dirpath is present in self._files, we have a directory.
-    return dirpath in self._files
+    # If dirpath is present in self._get_files(), we have a directory.
+    return dirpath in self._get_files()
 
 # Return some information about a module.
 def _get_module_info(self, fullname):
     path = _get_module_path(self, fullname)
     for suffix, isbytecode, ispackage in _zip_searchorder:
         fullpath = path + suffix
-        if fullpath in self._files:
+        if fullpath in self._get_files():
             return ispackage
     return None
 
@@ -406,16 +347,11 @@ def _read_directory(archive):
         raise ZipImportError(f"can't open Zip file: {archive!r}", path=archive)
 
     with fp:
+        # GH-87235: On macOS all file descriptors for /dev/fd/N share the same
+        # file offset, reset the file offset after scanning the zipfile directory
+        # to not cause problems when some runs 'python3 /dev/fd/9 9<some_script'
+        start_offset = fp.tell()
         try:
-            fp.seek(-END_CENTRAL_DIR_SIZE, 2)
-            header_position = fp.tell()
-            buffer = fp.read(END_CENTRAL_DIR_SIZE)
-        except OSError:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        if len(buffer) != END_CENTRAL_DIR_SIZE:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        if buffer[:4] != STRING_END_ARCHIVE:
-            # Bad: End of Central Dir signature
             # Check if there's a comment.
             try:
                 fp.seek(0, 2)
@@ -423,97 +359,192 @@ def _read_directory(archive):
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}",
                                      path=archive)
-            max_comment_start = max(file_size - MAX_COMMENT_LEN -
-                                    END_CENTRAL_DIR_SIZE, 0)
+            max_comment_plus_dirs_size = (
+                MAX_COMMENT_LEN + END_CENTRAL_DIR_SIZE +
+                END_CENTRAL_DIR_SIZE_64 + END_CENTRAL_DIR_LOCATOR_SIZE_64)
+            max_comment_start = max(file_size - max_comment_plus_dirs_size, 0)
             try:
                 fp.seek(max_comment_start)
-                data = fp.read()
+                data = fp.read(max_comment_plus_dirs_size)
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}",
                                      path=archive)
             pos = data.rfind(STRING_END_ARCHIVE)
-            if pos < 0:
+            pos64 = data.rfind(STRING_END_ZIP_64)
+
+            if (pos64 >= 0 and pos64+END_CENTRAL_DIR_SIZE_64+END_CENTRAL_DIR_LOCATOR_SIZE_64==pos):
+                # Zip64 at "correct" offset from standard EOCD
+                buffer = data[pos64:pos64 + END_CENTRAL_DIR_SIZE_64]
+                if len(buffer) != END_CENTRAL_DIR_SIZE_64:
+                    raise ZipImportError(
+                        f"corrupt Zip64 file: Expected {END_CENTRAL_DIR_SIZE_64} byte "
+                        f"zip64 central directory, but read {len(buffer)} bytes.",
+                        path=archive)
+                header_position = file_size - len(data) + pos64
+
+                central_directory_size = _unpack_uint64(buffer[40:48])
+                central_directory_position = _unpack_uint64(buffer[48:56])
+                num_entries = _unpack_uint64(buffer[24:32])
+            elif pos >= 0:
+                buffer = data[pos:pos+END_CENTRAL_DIR_SIZE]
+                if len(buffer) != END_CENTRAL_DIR_SIZE:
+                    raise ZipImportError(f"corrupt Zip file: {archive!r}",
+                                         path=archive)
+
+                header_position = file_size - len(data) + pos
+
+                # Buffer now contains a valid EOCD, and header_position gives the
+                # starting position of it.
+                central_directory_size = _unpack_uint32(buffer[12:16])
+                central_directory_position = _unpack_uint32(buffer[16:20])
+                num_entries = _unpack_uint16(buffer[8:10])
+
+                # N.b. if someday you want to prefer the standard (non-zip64) EOCD,
+                # you need to adjust position by 76 for arc to be 0.
+            else:
                 raise ZipImportError(f'not a Zip file: {archive!r}',
                                      path=archive)
-            buffer = data[pos:pos+END_CENTRAL_DIR_SIZE]
-            if len(buffer) != END_CENTRAL_DIR_SIZE:
-                raise ZipImportError(f"corrupt Zip file: {archive!r}",
-                                     path=archive)
-            header_position = file_size - len(data) + pos
-
-        header_size = _unpack_uint32(buffer[12:16])
-        header_offset = _unpack_uint32(buffer[16:20])
-        if header_position < header_size:
-            raise ZipImportError(f'bad central directory size: {archive!r}', path=archive)
-        if header_position < header_offset:
-            raise ZipImportError(f'bad central directory offset: {archive!r}', path=archive)
-        header_position -= header_size
-        arc_offset = header_position - header_offset
-        if arc_offset < 0:
-            raise ZipImportError(f'bad central directory size or offset: {archive!r}', path=archive)
-
-        files = {}
-        # Start of Central Directory
-        count = 0
-        try:
-            fp.seek(header_position)
-        except OSError:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        while True:
-            buffer = fp.read(46)
-            if len(buffer) < 4:
-                raise EOFError('EOF read where not expected')
-            # Start of file header
-            if buffer[:4] != b'PK\x01\x02':
-                break                                # Bad: Central Dir File Header
-            if len(buffer) != 46:
-                raise EOFError('EOF read where not expected')
-            flags = _unpack_uint16(buffer[8:10])
-            compress = _unpack_uint16(buffer[10:12])
-            time = _unpack_uint16(buffer[12:14])
-            date = _unpack_uint16(buffer[14:16])
-            crc = _unpack_uint32(buffer[16:20])
-            data_size = _unpack_uint32(buffer[20:24])
-            file_size = _unpack_uint32(buffer[24:28])
-            name_size = _unpack_uint16(buffer[28:30])
-            extra_size = _unpack_uint16(buffer[30:32])
-            comment_size = _unpack_uint16(buffer[32:34])
-            file_offset = _unpack_uint32(buffer[42:46])
-            header_size = name_size + extra_size + comment_size
-            if file_offset > header_offset:
-                raise ZipImportError(f'bad local header offset: {archive!r}', path=archive)
-            file_offset += arc_offset
 
+            # Buffer now contains a valid EOCD, and header_position gives the
+            # starting position of it.
+            # XXX: These are cursory checks but are not as exact or strict as they
+            # could be.  Checking the arc-adjusted value is probably good too.
+            if header_position < central_directory_size:
+                raise ZipImportError(f'bad central directory size: {archive!r}', path=archive)
+            if header_position < central_directory_position:
+                raise ZipImportError(f'bad central directory offset: {archive!r}', path=archive)
+            header_position -= central_directory_size
+            # On just-a-zipfile these values are the same and arc_offset is zero; if
+            # the file has some bytes prepended, `arc_offset` is the number of such
+            # bytes.  This is used for pex as well as self-extracting .exe.
+            arc_offset = header_position - central_directory_position
+            if arc_offset < 0:
+                raise ZipImportError(f'bad central directory size or offset: {archive!r}', path=archive)
+
+            files = {}
+            # Start of Central Directory
+            count = 0
             try:
-                name = fp.read(name_size)
-            except OSError:
-                raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-            if len(name) != name_size:
-                raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-            # On Windows, calling fseek to skip over the fields we don't use is
-            # slower than reading the data because fseek flushes stdio's
-            # internal buffers.    See issue #8745.
-            try:
-                if len(fp.read(header_size - name_size)) != header_size - name_size:
-                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                fp.seek(header_position)
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+            while True:
+                buffer = fp.read(46)
+                if len(buffer) < 4:
+                    raise EOFError('EOF read where not expected')
+                # Start of file header
+                if buffer[:4] != b'PK\x01\x02':
+                    if count != num_entries:
+                        raise ZipImportError(
+                            f"mismatched num_entries: {count} should be {num_entries} in {archive!r}",
+                            path=archive,
+                        )
+                    break                                # Bad: Central Dir File Header
+                if len(buffer) != 46:
+                    raise EOFError('EOF read where not expected')
+                flags = _unpack_uint16(buffer[8:10])
+                compress = _unpack_uint16(buffer[10:12])
+                time = _unpack_uint16(buffer[12:14])
+                date = _unpack_uint16(buffer[14:16])
+                crc = _unpack_uint32(buffer[16:20])
+                data_size = _unpack_uint32(buffer[20:24])
+                file_size = _unpack_uint32(buffer[24:28])
+                name_size = _unpack_uint16(buffer[28:30])
+                extra_size = _unpack_uint16(buffer[30:32])
+                comment_size = _unpack_uint16(buffer[32:34])
+                file_offset = _unpack_uint32(buffer[42:46])
+                header_size = name_size + extra_size + comment_size
 
-            if flags & 0x800:
-                # UTF-8 file names extension
-                name = name.decode()
-            else:
-                # Historical ZIP filename encoding
                 try:
-                    name = name.decode('ascii')
-                except UnicodeDecodeError:
-                    name = name.decode('latin1').translate(cp437_table)
-
-            name = name.replace('/', path_sep)
-            path = _bootstrap_external._path_join(archive, name)
-            t = (path, compress, data_size, file_size, file_offset, time, date, crc)
-            files[name] = t
-            count += 1
+                    name = fp.read(name_size)
+                except OSError:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                if len(name) != name_size:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                # On Windows, calling fseek to skip over the fields we don't use is
+                # slower than reading the data because fseek flushes stdio's
+                # internal buffers.    See issue #8745.
+                try:
+                    extra_data_len = header_size - name_size
+                    extra_data = memoryview(fp.read(extra_data_len))
+
+                    if len(extra_data) != extra_data_len:
+                        raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                except OSError:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+
+                if flags & 0x800:
+                    # UTF-8 file names extension
+                    name = name.decode()
+                else:
+                    # Historical ZIP filename encoding
+                    try:
+                        name = name.decode('ascii')
+                    except UnicodeDecodeError:
+                        name = name.decode('latin1').translate(cp437_table)
+
+                name = name.replace('/', path_sep)
+                path = _bootstrap_external._path_join(archive, name)
+
+                # Ordering matches unpacking below.
+                if (
+                    file_size == MAX_UINT32 or
+                    data_size == MAX_UINT32 or
+                    file_offset == MAX_UINT32
+                ):
+                    # need to decode extra_data looking for a zip64 extra (which might not
+                    # be present)
+                    while extra_data:
+                        if len(extra_data) < 4:
+                            raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                        tag = _unpack_uint16(extra_data[:2])
+                        size = _unpack_uint16(extra_data[2:4])
+                        if len(extra_data) < 4 + size:
+                            raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                        if tag == ZIP64_EXTRA_TAG:
+                            if (len(extra_data) - 4) % 8 != 0:
+                                raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                            num_extra_values = (len(extra_data) - 4) // 8
+                            if num_extra_values > 3:
+                                raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                            import struct
+                            values = list(struct.unpack_from(f"<{min(num_extra_values, 3)}Q",
+                                                             extra_data, offset=4))
+
+                            # N.b. Here be dragons: the ordering of these is different than
+                            # the header fields, and it's really easy to get it wrong since
+                            # naturally-occuring zips that use all 3 are >4GB
+                            if file_size == MAX_UINT32:
+                                file_size = values.pop(0)
+                            if data_size == MAX_UINT32:
+                                data_size = values.pop(0)
+                            if file_offset == MAX_UINT32:
+                                file_offset = values.pop(0)
+
+                            break
+
+                        # For a typical zip, this bytes-slicing only happens 2-3 times, on
+                        # small data like timestamps and filesizes.
+                        extra_data = extra_data[4+size:]
+                    else:
+                        _bootstrap._verbose_message(
+                            "zipimport: suspected zip64 but no zip64 extra for {!r}",
+                            path,
+                        )
+                # XXX These two statements seem swapped because `central_directory_position`
+                # is a position within the actual file, but `file_offset` (when compared) is
+                # as encoded in the entry, not adjusted for this file.
+                # N.b. this must be after we've potentially read the zip64 extra which can
+                # change `file_offset`.
+                if file_offset > central_directory_position:
+                    raise ZipImportError(f'bad local header offset: {archive!r}', path=archive)
+                file_offset += arc_offset
+
+                t = (path, compress, data_size, file_size, file_offset, time, date, crc)
+                files[name] = t
+                count += 1
+        finally:
+            fp.seek(start_offset)
     _bootstrap._verbose_message('zipimport: found {} names in {!r}', count, archive)
     return files
 
@@ -708,7 +739,7 @@ def _get_mtime_and_size_of_source(self, path):
         # strip 'c' or 'o' from *.py[co]
         assert path[-1:] in ('c', 'o')
         path = path[:-1]
-        toc_entry = self._files[path]
+        toc_entry = self._get_files()[path]
         # fetch the time stamp of the .py file for comparison
         # with an embedded pyc time stamp
         time = toc_entry[5]
@@ -728,7 +759,7 @@ def _get_pyc_source(self, path):
     path = path[:-1]
 
     try:
-        toc_entry = self._files[path]
+        toc_entry = self._get_files()[path]
     except KeyError:
         return None
     else:
@@ -744,7 +775,7 @@ def _get_module_code(self, fullname):
         fullpath = path + suffix
         _bootstrap._verbose_message('trying {}{}{}', self.archive, path_sep, fullpath, verbosity=2)
         try:
-            toc_entry = self._files[fullpath]
+            toc_entry = self._get_files()[fullpath]
         except KeyError:
             pass
         else:

From 7becac9a101ee0ad11458eb12b950ccb3e0e348e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 7 Jan 2026 08:52:40 +0900
Subject: [PATCH 187/418] Bump proc-macro2 from 1.0.104 to 1.0.105 (#6664)

Bumps [proc-macro2](https://github.com/dtolnay/proc-macro2) from 1.0.104 to 1.0.105.
- [Release notes](https://github.com/dtolnay/proc-macro2/releases)
- [Commits](https://github.com/dtolnay/proc-macro2/compare/1.0.104...1.0.105)

---
updated-dependencies:
- dependency-name: proc-macro2
  dependency-version: 1.0.105
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e03c1221781..b0b01ff79ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2447,9 +2447,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.104"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
+checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
 dependencies = [
  "unicode-ident",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 1ef31f825f7..728f657f052 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -193,7 +193,7 @@ optional = "0.5"
 once_cell = "1.20.3"
 parking_lot = "0.12.3"
 paste = "1.0.15"
-proc-macro2 = "1.0.93"
+proc-macro2 = "1.0.105"
 pymath = "0.0.2"
 quote = "1.0.38"
 radium = "1.1.1"

From 8df2df3ed72807559618a2c21e37b62d2e450b4e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 7 Jan 2026 08:52:50 +0900
Subject: [PATCH 188/418] Bump webpki-roots from 1.0.4 to 1.0.5 (#6665)

Bumps [webpki-roots](https://github.com/rustls/webpki-roots) from 1.0.4 to 1.0.5.
- [Release notes](https://github.com/rustls/webpki-roots/releases)
- [Commits](https://github.com/rustls/webpki-roots/compare/v/1.0.4...v/1.0.5)

---
updated-dependencies:
- dependency-name: webpki-roots
  dependency-version: 1.0.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b0b01ff79ff..30a59b5e41c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4339,9 +4339,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.4"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e"
+checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
 dependencies = [
  "rustls-pki-types",
 ]

From 985961b0130021db24fc9d9468cce94d2ae91669 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 7 Jan 2026 08:54:10 +0900
Subject: [PATCH 189/418] Bump rustls from 0.23.35 to 0.23.36 (#6666)

Bumps [rustls](https://github.com/rustls/rustls) from 0.23.35 to 0.23.36.
- [Release notes](https://github.com/rustls/rustls/releases)
- [Changelog](https://github.com/rustls/rustls/blob/main/CHANGELOG.md)
- [Commits](https://github.com/rustls/rustls/compare/v/0.23.35...v/0.23.36)

---
updated-dependencies:
- dependency-name: rustls
  dependency-version: 0.23.36
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock               | 4 ++--
 crates/stdlib/Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 30a59b5e41c..03016e55eec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2872,9 +2872,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.35"
+version = "0.23.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f"
+checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
 dependencies = [
  "aws-lc-rs",
  "once_cell",
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index e943470a3af..d39f0ab43b4 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -119,7 +119,7 @@ openssl-probe = { version = "0.1.5", optional = true }
 foreign-types-shared = { version = "0.1.1", optional = true }
 
 # Rustls dependencies (optional, for ssl-rustls feature)
-rustls = { version = "0.23.35", default-features = false, features = ["std", "tls12", "aws_lc_rs"], optional = true }
+rustls = { version = "0.23.36", default-features = false, features = ["std", "tls12", "aws_lc_rs"], optional = true }
 rustls-native-certs = { version = "0.8", optional = true }
 rustls-pemfile = { version = "2.2", optional = true }
 rustls-platform-verifier = { version = "0.6", optional = true }

From 4fbf617c06e6fb445e8815de798e3731cb2d99ad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 7 Jan 2026 08:54:21 +0900
Subject: [PATCH 190/418] Bump quote from 1.0.42 to 1.0.43 (#6667)

Bumps [quote](https://github.com/dtolnay/quote) from 1.0.42 to 1.0.43.
- [Release notes](https://github.com/dtolnay/quote/releases)
- [Commits](https://github.com/dtolnay/quote/compare/1.0.42...1.0.43)

---
updated-dependencies:
- dependency-name: quote
  dependency-version: 1.0.43
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 03016e55eec..d8b09bf94b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2526,9 +2526,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.42"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
 dependencies = [
  "proc-macro2",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 728f657f052..fe28491b520 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -195,7 +195,7 @@ parking_lot = "0.12.3"
 paste = "1.0.15"
 proc-macro2 = "1.0.105"
 pymath = "0.0.2"
-quote = "1.0.38"
+quote = "1.0.43"
 radium = "1.1.1"
 rand = "0.9"
 rand_core = { version = "0.9", features = ["os_rng"] }

From 6408228b3e7c843786416358c099739db50ce44f Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Wed, 7 Jan 2026 10:09:51 +0900
Subject: [PATCH 191/418] Update DEVELOPMENT.md (#6671)

* Update DEVELOPMENT.md to reflect crates/ directory structure

* Update DEVELOPMENT.md to reflect Ruff parser-related changes
---
 DEVELOPMENT.md | 54 ++++++++++++++++++++++----------------------------
 1 file changed, 24 insertions(+), 30 deletions(-)

diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index d5c675faca6..82364e9b812 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -19,7 +19,7 @@ The contents of the Development Guide include:
 
 RustPython requires the following:
 
-- Rust latest stable version (e.g 1.69.0 as of Apr 20 2023)
+- Rust latest stable version (e.g 1.92.0 as of Jan 7 2026)
     - To check Rust version: `rustc --version` 
     - If you have `rustup` on your system, enter to update to the latest
       stable version: `rustup update stable`
@@ -118,18 +118,17 @@ exists a raw html viewer which is currently broken, and we welcome a PR to fix i
 Understanding a new codebase takes time. Here's a brief view of the
 repository's structure:
 
-- `compiler/src`: python compilation to bytecode
-  - `core/src`: python bytecode representation in rust structures
-  - `parser/src`: python lexing, parsing and ast
-- `derive/src`: Rust language extensions and macros specific to rustpython
+- `crates/compiler/src`: python compilation to bytecode
+  - `crates/compiler-core/src`: python bytecode representation in rust structures
+- `crates/derive/src` and `crates/derive-impl/src`: Rust language extensions and macros specific to rustpython
 - `Lib`: Carefully selected / copied files from CPython sourcecode. This is
    the python side of the standard library.
   - `test`: CPython test suite
-- `vm/src`: python virtual machine
+- `crates/vm/src`: python virtual machine
   - `builtins`: Builtin functions and types
   - `stdlib`: Standard library parts implemented in rust.
 - `src`: using the other subcrates to bring rustpython to life.
-- `wasm`: Binary crate and resources for WebAssembly build
+- `crates/wasm`: Binary crate and resources for WebAssembly build
 - `extra_tests`: extra integration test snippets as a supplement to `Lib/test`.
   Add new RustPython-only regression tests here; do not place new tests under `Lib/test`.
 
@@ -141,9 +140,9 @@ implementation is found in the `src` directory (specifically, `src/lib.rs`).
 
 The top-level `rustpython` binary depends on several lower-level crates including:
 
-- `rustpython-parser` (implementation in `compiler/parser/src`)
-- `rustpython-compiler` (implementation in `compiler/src`)
-- `rustpython-vm` (implementation in `vm/src`)
+- `ruff_python_parser` and `ruff_python_ast` (external dependencies from the Ruff project)
+- `rustpython-compiler` (implementation in `crates/compiler/src`)
+- `rustpython-vm` (implementation in `crates/vm/src`)
 
 Together, these crates provide the functions of a programming language and
 enable a line of code to go through a series of steps:
@@ -154,31 +153,26 @@ enable a line of code to go through a series of steps:
 - compile the AST into bytecode
 - execute the bytecode in the virtual machine (VM).
 
-### rustpython-parser
+### Parser and AST
 
-This crate contains the lexer and parser to convert a line of code to
-an Abstract Syntax Tree (AST):
+RustPython uses the Ruff project's parser and AST implementation:
 
-- Lexer: `compiler/parser/src/lexer.rs` converts Python source code into tokens
-- Parser: `compiler/parser/src/parser.rs` takes the tokens generated by the lexer and parses
-  the tokens into an AST (Abstract Syntax Tree) where the nodes of the syntax
-  tree are Rust structs and enums.
-  - The Parser relies on `LALRPOP`, a Rust parser generator framework. The
-    LALRPOP definition of Python's grammar is in `compiler/parser/src/python.lalrpop`.
-  - More information on parsers and a tutorial can be found in the 
-    [LALRPOP book](https://lalrpop.github.io/lalrpop/).
-- AST: `compiler/ast/` implements in Rust the Python types and expressions
-  represented by the AST nodes.
+- Parser: `ruff_python_parser` is used to convert Python source code into tokens
+  and parse them into an Abstract Syntax Tree (AST)
+- AST: `ruff_python_ast` provides the Rust types and expressions represented by
+  the AST nodes
+- These are external dependencies maintained by the Ruff project
+- For more information, visit the [Ruff GitHub repository](https://github.com/astral-sh/ruff)
 
 ### rustpython-compiler
 
 The `rustpython-compiler` crate's purpose is to transform the AST (Abstract Syntax
 Tree) to bytecode. The implementation of the compiler is found in the
-`compiler/src` directory. The compiler implements Python's symbol table,
+`crates/compiler/src` directory. The compiler implements Python's symbol table,
 ast->bytecode compiler, and bytecode optimizer in Rust.
 
-Implementation of bytecode structure in Rust is found in the `compiler/core/src`
-directory. `compiler/core/src/bytecode.rs` contains the representation of
+Implementation of bytecode structure in Rust is found in the `crates/compiler-core/src`
+directory. `crates/compiler-core/src/bytecode.rs` contains the representation of
 instructions and operations in Rust. Further information about Python's
 bytecode instructions can be found in the
 [Python documentation](https://docs.python.org/3/library/dis.html#bytecodes).
@@ -186,14 +180,14 @@ bytecode instructions can be found in the
 ### rustpython-vm
 
 The `rustpython-vm` crate has the important job of running the virtual machine that
-executes Python's instructions. The `vm/src` directory contains code to
+executes Python's instructions. The `crates/vm/src` directory contains code to
 implement the read and evaluation loop that fetches and dispatches
 instructions. This directory also contains the implementation of the
-Python Standard Library modules in Rust (`vm/src/stdlib`). In Python
-everything can be represented as an object. The `vm/src/builtins` directory holds
+Python Standard Library modules in Rust (`crates/vm/src/stdlib`). In Python
+everything can be represented as an object. The `crates/vm/src/builtins` directory holds
 the Rust code used to represent different Python objects and their methods. The
 core implementation of what a Python object is can be found in
-`vm/src/object/core.rs`.
+`crates/vm/src/object/core.rs`.
 
 ### Code generation
 

From 42cc59a90c35ffd12d4c793cf155ea4e885c5de1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 7 Jan 2026 10:13:13 +0900
Subject: [PATCH 192/418] Bump openssl-probe from 0.1.6 to 0.2.0 (#6663)

* Bump openssl-probe from 0.1.6 to 0.2.0

Bumps [openssl-probe](https://github.com/alexcrichton/openssl-probe) from 0.1.6 to 0.2.0.
- [Release notes](https://github.com/alexcrichton/openssl-probe/releases)
- [Commits](https://github.com/alexcrichton/openssl-probe/compare/0.1.6...0.2.0)

---
updated-dependencies:
- dependency-name: openssl-probe
  dependency-version: 0.2.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Fix openssl-probe 0.2.0 API compatibility (#6669)

* Bump openssl-probe from 0.1.6 to 0.2.0

Bumps [openssl-probe](https://github.com/alexcrichton/openssl-probe) from 0.1.6 to 0.2.0.
- [Release notes](https://github.com/alexcrichton/openssl-probe/releases)
- [Commits](https://github.com/alexcrichton/openssl-probe/compare/0.1.6...0.2.0)

---
updated-dependencies:
- dependency-name: openssl-probe
  dependency-version: 0.2.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Initial plan

* Fix openssl-probe 0.2.0 API compatibility

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Cargo.lock                   | 10 ++--------
 crates/stdlib/Cargo.toml     |  2 +-
 crates/stdlib/src/openssl.rs |  7 ++++---
 3 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d8b09bf94b2..3b676e2a785 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2134,12 +2134,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "openssl-probe"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
-
 [[package]]
 name = "openssl-probe"
 version = "0.2.0"
@@ -2890,7 +2884,7 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
 dependencies = [
- "openssl-probe 0.2.0",
+ "openssl-probe",
  "rustls-pki-types",
  "schannel",
  "security-framework",
@@ -3184,7 +3178,7 @@ dependencies = [
  "num_enum",
  "oid-registry",
  "openssl",
- "openssl-probe 0.1.6",
+ "openssl-probe",
  "openssl-sys",
  "page_size",
  "parking_lot",
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index d39f0ab43b4..4af890b8e69 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -115,7 +115,7 @@ dns-lookup = "3.0"
 # OpenSSL dependencies (optional, for ssl-openssl feature)
 openssl = { version = "0.10.72", optional = true }
 openssl-sys = { version = "0.9.110", optional = true }
-openssl-probe = { version = "0.1.5", optional = true }
+openssl-probe = { version = "0.2.0", optional = true }
 foreign-types-shared = { version = "0.1.1", optional = true }
 
 # Rustls dependencies (optional, for ssl-rustls feature)
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
index 38103a9ab05..df153459f62 100644
--- a/crates/stdlib/src/openssl.rs
+++ b/crates/stdlib/src/openssl.rs
@@ -25,6 +25,7 @@ cfg_if::cfg_if! {
 
 use crate::vm::{PyRef, VirtualMachine, builtins::PyModule};
 use openssl_probe::ProbeResult;
+use std::sync::LazyLock;
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     // if openssl is vendored, it doesn't know the locations
@@ -38,12 +39,12 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 // easily, without having to have a bunch of cfgs
 cfg_if::cfg_if! {
     if #[cfg(openssl_vendored)] {
-        use std::sync::LazyLock;
         static PROBE: LazyLock<ProbeResult> = LazyLock::new(openssl_probe::probe);
         fn probe() -> &'static ProbeResult { &PROBE }
     } else {
+        static EMPTY_PROBE: LazyLock<ProbeResult> = LazyLock::new(|| ProbeResult { cert_file: None, cert_dir: vec![] });
         fn probe() -> &'static ProbeResult {
-            &ProbeResult { cert_file: None, cert_dir: None }
+            &EMPTY_PROBE
         }
     }
 }
@@ -446,7 +447,7 @@ mod _ssl {
             });
         let cert_dir = probe
             .cert_dir
-            .as_ref()
+            .first()
             .map(PathBuf::from)
             .unwrap_or_else(|| {
                 path_from_cstr(unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir()) })

From 09bde28281dfdaaa65c3a44435b3426aa9213547 Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Tue, 6 Jan 2026 21:33:29 -0600
Subject: [PATCH 193/418] Move typeid into vtable (#6231)

* Move typeid into vtable

* Bump rust-version
---
 Cargo.toml                              | 2 +-
 crates/derive-impl/src/pyclass.rs       | 5 +----
 crates/derive-impl/src/pystructseq.rs   | 5 +----
 crates/vm/src/builtins/str.rs           | 4 +---
 crates/vm/src/object/core.rs            | 9 ++-------
 crates/vm/src/object/payload.rs         | 7 ++-----
 crates/vm/src/object/traverse_object.rs | 3 +++
 7 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index fe28491b520..d127630f1ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -131,7 +131,7 @@ members = [
 version = "0.4.0"
 authors = ["RustPython Team"]
 edition = "2024"
-rust-version = "1.89.0"
+rust-version = "1.91.0"
 repository = "https://github.com/RustPython/RustPython"
 license = "MIT"
 
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 028d3d7c292..a81a7bacbad 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -635,10 +635,7 @@ pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<Tok
         quote! {
             // static_assertions::const_assert!(std::mem::size_of::<#base_type>() <= std::mem::size_of::<#ident>());
             impl ::rustpython_vm::PyPayload for #ident {
-                #[inline]
-                fn payload_type_id() -> ::std::any::TypeId {
-                    <#base_type as ::rustpython_vm::PyPayload>::payload_type_id()
-                }
+                const PAYLOAD_TYPE_ID: ::core::any::TypeId = <#base_type as ::rustpython_vm::PyPayload>::PAYLOAD_TYPE_ID;
 
                 #[inline]
                 fn validate_downcastable_from(obj: &::rustpython_vm::PyObject) -> bool {
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
index 32b603fe478..0ee0c2c2e3c 100644
--- a/crates/derive-impl/src/pystructseq.rs
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -592,10 +592,7 @@ pub(crate) fn impl_pystruct_sequence(
 
         // Subtype uses base type's payload_type_id
         impl ::rustpython_vm::PyPayload for #pytype_ident {
-            #[inline]
-            fn payload_type_id() -> ::std::any::TypeId {
-                <::rustpython_vm::builtins::PyTuple as ::rustpython_vm::PyPayload>::payload_type_id()
-            }
+            const PAYLOAD_TYPE_ID: ::core::any::TypeId = <::rustpython_vm::builtins::PyTuple as ::rustpython_vm::PyPayload>::PAYLOAD_TYPE_ID;
 
             #[inline]
             fn validate_downcastable_from(obj: &::rustpython_vm::PyObject) -> bool {
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 4931a748198..640778c8cb9 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -1935,9 +1935,7 @@ impl PyPayload for PyUtf8Str {
         ctx.types.str_type
     }
 
-    fn payload_type_id() -> core::any::TypeId {
-        core::any::TypeId::of::<PyStr>()
-    }
+    const PAYLOAD_TYPE_ID: core::any::TypeId = core::any::TypeId::of::<PyStr>();
 
     fn validate_downcastable_from(obj: &PyObject) -> bool {
         // SAFETY: we know the object is a PyStr in this context
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index e904117b06a..271a9cc34d2 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -105,8 +105,6 @@ pub(super) unsafe fn try_trace_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut T
 #[repr(C)]
 pub(super) struct PyInner<T> {
     pub(super) ref_count: RefCount,
-    // TODO: move typeid into vtable once TypeId::of is const
-    pub(super) typeid: TypeId,
     pub(super) vtable: &'static PyObjVTable,
 
     pub(super) typ: PyAtomicRef<PyType>, // __class__ member
@@ -449,7 +447,6 @@ impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
         let member_count = typ.slots.member_count;
         Box::new(Self {
             ref_count: RefCount::new(),
-            typeid: T::payload_type_id(),
             vtable: PyObjVTable::of::<T>(),
             typ: PyAtomicRef::from(typ),
             dict: dict.map(InstanceDict::new),
@@ -639,7 +636,7 @@ impl PyObject {
     #[deprecated(note = "use downcastable instead")]
     #[inline(always)]
     pub fn payload_is<T: PyPayload>(&self) -> bool {
-        self.0.typeid == T::payload_type_id()
+        self.0.vtable.typeid == T::PAYLOAD_TYPE_ID
     }
 
     /// Force to return payload as T.
@@ -722,7 +719,7 @@ impl PyObject {
 
     #[inline]
     pub(crate) fn typeid(&self) -> TypeId {
-        self.0.typeid
+        self.0.vtable.typeid
     }
 
     /// Check if this object can be downcast to T.
@@ -1276,7 +1273,6 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         let type_type_ptr = Box::into_raw(Box::new(partially_init!(
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
-                typeid: TypeId::of::<PyType>(),
                 vtable: PyObjVTable::of::<PyType>(),
                 dict: None,
                 weak_list: WeakRefList::new(),
@@ -1288,7 +1284,6 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         let object_type_ptr = Box::into_raw(Box::new(partially_init!(
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
-                typeid: TypeId::of::<PyType>(),
                 vtable: PyObjVTable::of::<PyType>(),
                 dict: None,
                 weak_list: WeakRefList::new(),
diff --git a/crates/vm/src/object/payload.rs b/crates/vm/src/object/payload.rs
index 3a2f42675f7..143033ee642 100644
--- a/crates/vm/src/object/payload.rs
+++ b/crates/vm/src/object/payload.rs
@@ -26,15 +26,12 @@ pub(crate) fn cold_downcast_type_error(
 }
 
 pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
-    #[inline]
-    fn payload_type_id() -> core::any::TypeId {
-        core::any::TypeId::of::<Self>()
-    }
+    const PAYLOAD_TYPE_ID: core::any::TypeId = core::any::TypeId::of::<Self>();
 
     /// # Safety: this function should only be called if `payload_type_id` matches the type of `obj`.
     #[inline]
     fn downcastable_from(obj: &PyObject) -> bool {
-        obj.typeid() == Self::payload_type_id() && Self::validate_downcastable_from(obj)
+        obj.typeid() == Self::PAYLOAD_TYPE_ID && Self::validate_downcastable_from(obj)
     }
 
     #[inline]
diff --git a/crates/vm/src/object/traverse_object.rs b/crates/vm/src/object/traverse_object.rs
index 075ce5b9513..7a66f0b35f0 100644
--- a/crates/vm/src/object/traverse_object.rs
+++ b/crates/vm/src/object/traverse_object.rs
@@ -1,4 +1,5 @@
 use alloc::fmt;
+use core::any::TypeId;
 
 use crate::{
     PyObject,
@@ -11,6 +12,7 @@ use crate::{
 use super::{Traverse, TraverseFn};
 
 pub(in crate::object) struct PyObjVTable {
+    pub(in crate::object) typeid: TypeId,
     pub(in crate::object) drop_dealloc: unsafe fn(*mut PyObject),
     pub(in crate::object) debug: unsafe fn(&PyObject, &mut fmt::Formatter<'_>) -> fmt::Result,
     pub(in crate::object) trace: Option<unsafe fn(&PyObject, &mut TraverseFn<'_>)>,
@@ -19,6 +21,7 @@ pub(in crate::object) struct PyObjVTable {
 impl PyObjVTable {
     pub const fn of<T: PyObjectPayload>() -> &'static Self {
         &Self {
+            typeid: T::PAYLOAD_TYPE_ID,
             drop_dealloc: drop_dealloc_obj::<T>,
             debug: debug_obj::<T>,
             trace: const {

From bf80d2715d353d063c9595d4c99639e404d52cec Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Tue, 6 Jan 2026 21:53:44 -0600
Subject: [PATCH 194/418] Update to windows-2025 runner on ci (#5571)

* Update to windows-2025 on ci

* Unmark unexpected successes

* Try adding .dll
---
 .github/workflows/ci.yaml      | 22 ++++------------------
 .github/workflows/release.yml  | 15 +++++----------
 Cargo.toml                     | 10 ----------
 Lib/test/test_shutil.py        |  1 -
 crates/common/src/fileutils.rs |  3 ++-
 5 files changed, 11 insertions(+), 40 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index a873aa2d29d..dc7b4bc502d 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -107,6 +107,8 @@ env:
     test_yield_from
   # Python version targeted by the CI.
   PYTHON_VERSION: "3.13.1"
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_INCLUDE_DIR: C:\Program Files\OpenSSL\include
 
 jobs:
   rust_tests:
@@ -118,7 +120,7 @@ jobs:
     timeout-minutes: 45
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
+        os: [macos-latest, ubuntu-latest, windows-2025]
       fail-fast: false
     steps:
       - uses: actions/checkout@v6.0.1
@@ -127,14 +129,6 @@ jobs:
           components: clippy
       - uses: Swatinem/rust-cache@v2
 
-      # Only for OpenSSL builds
-      # - name: Set up the Windows environment
-      #   shell: bash
-      #   run: |
-      #     git config --system core.longpaths true
-      #     cargo install --target-dir=target -v cargo-vcpkg
-      #     cargo vcpkg -v build
-      #   if: runner.os == 'Windows'
       - name: Set up the Mac environment
         run: brew install autoconf automake libtool
         if: runner.os == 'macOS'
@@ -257,7 +251,7 @@ jobs:
     runs-on:  ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
+        os: [macos-latest, ubuntu-latest, windows-2025]
       fail-fast: false
     steps:
       - uses: actions/checkout@v6.0.1
@@ -266,14 +260,6 @@ jobs:
       - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      # Only for OpenSSL builds
-      # - name: Set up the Windows environment
-      #   shell: bash
-      #   run: |
-      #     git config --system core.longpaths true
-      #     cargo install cargo-vcpkg
-      #     cargo vcpkg build
-      #   if: runner.os == 'Windows'
       - name: Set up the Mac environment
         run: brew install autoconf automake libtool openssl@3
         if: runner.os == 'macOS'
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 5ad2cf3f97a..c11d11d9805 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,6 +17,8 @@ permissions:
 
 env:
   CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,sqlite,ssl
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_INCLUDE_DIR: C:\Program Files\OpenSSL\include
 
 jobs:
   build:
@@ -42,11 +44,11 @@ jobs:
             target: aarch64-apple-darwin
 #          - runner: macos-latest
 #            target: x86_64-apple-darwin
-          - runner: windows-latest
+          - runner: windows-2025
             target: x86_64-pc-windows-msvc
-#          - runner: windows-latest
+#          - runner: windows-2025
 #            target: i686-pc-windows-msvc
-#          - runner: windows-latest
+#          - runner: windows-2025
 #            target: aarch64-pc-windows-msvc
       fail-fast: false
     steps:
@@ -57,13 +59,6 @@ jobs:
       - name: Set up Environment
         shell: bash
         run: rustup target add ${{ matrix.platform.target }}
-      - name: Set up Windows Environment
-        shell: bash
-        run: |
-          git config --global core.longpaths true
-          cargo install --target-dir=target -v cargo-vcpkg
-          cargo vcpkg -v build
-        if: runner.os == 'Windows'
       - name: Set up MacOS Environment
         run: brew install autoconf automake libtool
         if: runner.os == 'macOS'
diff --git a/Cargo.toml b/Cargo.toml
index d127630f1ca..a7ac9ee4999 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -91,16 +91,6 @@ lto = "thin"
 # REDOX START, Uncomment when you want to compile/check with redoxer
 # REDOX END
 
-# Used only on Windows to build the vcpkg dependencies
-[package.metadata.vcpkg]
-git = "https://github.com/microsoft/vcpkg"
-# The revision of the vcpkg repository to use
-# https://github.com/microsoft/vcpkg/tags
-rev = "2025.09.17"
-
-[package.metadata.vcpkg.target]
-x86_64-pc-windows-msvc = { triplet = "x64-windows-static-md", dev-dependencies = ["openssl" ] }
-
 [package.metadata.packager]
 product-name = "RustPython"
 identifier = "com.rustpython.rustpython"
diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py
index 73ad81e871b..0e973255621 100644
--- a/Lib/test/test_shutil.py
+++ b/Lib/test/test_shutil.py
@@ -194,7 +194,6 @@ def test_rmtree_works_on_bytes(self):
         self.assertIsInstance(victim, bytes)
         shutil.rmtree(victim)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; flaky')
     @os_helper.skip_unless_symlink
     def test_rmtree_fails_on_symlink_onerror(self):
         tmp = self.mkdtemp()
diff --git a/crates/common/src/fileutils.rs b/crates/common/src/fileutils.rs
index 9ed5e77afbb..7170b270d95 100644
--- a/crates/common/src/fileutils.rs
+++ b/crates/common/src/fileutils.rs
@@ -303,7 +303,8 @@ pub mod windows {
 
         let GetFileInformationByName = GET_FILE_INFORMATION_BY_NAME
             .get_or_init(|| {
-                let library_name = OsString::from("api-ms-win-core-file-l2-1-4").to_wide_with_nul();
+                let library_name =
+                    OsString::from("api-ms-win-core-file-l2-1-4.dll").to_wide_with_nul();
                 let module = unsafe { LoadLibraryW(library_name.as_ptr()) };
                 if module.is_null() {
                     return None;

From a3425b435e0e17c7f94b33ea7b665a1600ceff02 Mon Sep 17 00:00:00 2001
From: Copilot <198982749+Copilot@users.noreply.github.com>
Date: Fri, 9 Jan 2026 06:32:12 +0900
Subject: [PATCH 195/418] Track symbol table cursors to avoid exhaustion
 (#6670)

* Handle missing symbol table without panic

* Update symbol table error message

* Track symbol table cursors to avoid exhaustion

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/codegen/src/compile.rs     | 71 ++++++++++++++-----------------
 crates/codegen/src/symboltable.rs |  4 ++
 2 files changed, 35 insertions(+), 40 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 66eb785e962..7a6fdc87b26 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -637,25 +637,29 @@ impl Compiler {
     }
 
     /// Push the next symbol table on to the stack
-    fn push_symbol_table(&mut self) -> &SymbolTable {
+    fn push_symbol_table(&mut self) -> CompileResult<&SymbolTable> {
         // Look up the next table contained in the scope of the current table
         let current_table = self
             .symbol_table_stack
             .last_mut()
             .expect("no current symbol table");
 
-        if current_table.sub_tables.is_empty() {
-            panic!(
-                "push_symbol_table: no sub_tables available in {} (type: {:?})",
-                current_table.name, current_table.typ
-            );
+        if current_table.next_sub_table >= current_table.sub_tables.len() {
+            let name = current_table.name.clone();
+            let typ = current_table.typ;
+            return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                "no symbol table available in {} (type: {:?})",
+                name, typ
+            ))));
         }
 
-        let table = current_table.sub_tables.remove(0);
+        let idx = current_table.next_sub_table;
+        current_table.next_sub_table += 1;
+        let table = current_table.sub_tables[idx].clone();
 
         // Push the next table onto the stack
         self.symbol_table_stack.push(table);
-        self.current_symbol_table()
+        Ok(self.current_symbol_table())
     }
 
     /// Pop the current symbol table off the stack
@@ -853,9 +857,9 @@ impl Compiler {
         arg_count: u32,
         kwonlyarg_count: u32,
         obj_name: String,
-    ) {
+    ) -> CompileResult<()> {
         // First push the symbol table
-        let table = self.push_symbol_table();
+        let table = self.push_symbol_table()?;
         let scope_type = table.typ;
 
         // The key is the current position in the symbol table stack
@@ -865,11 +869,7 @@ impl Compiler {
         let lineno = self.get_source_line_number().get();
 
         // Call enter_scope which does most of the work
-        if let Err(e) = self.enter_scope(&obj_name, scope_type, key, lineno.to_u32()) {
-            // In the current implementation, push_output doesn't return an error,
-            // so we panic here. This maintains the same behavior.
-            panic!("enter_scope failed: {e:?}");
-        }
+        self.enter_scope(&obj_name, scope_type, key, lineno.to_u32())?;
 
         // Override the values that push_output sets explicitly
         // enter_scope sets default values based on scope_type, but push_output
@@ -880,6 +880,7 @@ impl Compiler {
             info.metadata.posonlyargcount = posonlyarg_count;
             info.metadata.kwonlyargcount = kwonlyarg_count;
         }
+        Ok(())
     }
 
     // compiler_exit_scope
@@ -1984,7 +1985,7 @@ impl Compiler {
 
                 if let Some(type_params) = type_params {
                     // For TypeAlias, we need to use push_symbol_table to properly handle the TypeAlias scope
-                    self.push_symbol_table();
+                    self.push_symbol_table()?;
 
                     // Compile type params and push to stack
                     self.compile_type_params(type_params)?;
@@ -2067,7 +2068,7 @@ impl Compiler {
             (parameters.posonlyargs.len() + parameters.args.len()).to_u32(),
             parameters.kwonlyargs.len().to_u32(),
             name.to_owned(),
-        );
+        )?;
 
         let args_iter = core::iter::empty()
             .chain(&parameters.posonlyargs)
@@ -2113,7 +2114,7 @@ impl Compiler {
         allow_starred: bool,
     ) -> CompileResult<()> {
         // Push the next symbol table onto the stack
-        self.push_symbol_table();
+        self.push_symbol_table()?;
 
         // Get the current symbol table
         let key = self.symbol_table_stack.len() - 1;
@@ -2332,13 +2333,8 @@ impl Compiler {
 
             // Snapshot sub_tables before first finally compilation
             // This allows us to restore them for the second compilation (exception path)
-            let sub_tables_snapshot = if !finalbody.is_empty() && finally_except_block.is_some() {
-                Some(
-                    self.symbol_table_stack
-                        .last()
-                        .map(|t| t.sub_tables.clone())
-                        .unwrap_or_default(),
-                )
+            let sub_table_cursor = if !finalbody.is_empty() && finally_except_block.is_some() {
+                self.symbol_table_stack.last().map(|t| t.next_sub_table)
             } else {
                 None
             };
@@ -2353,10 +2349,10 @@ impl Compiler {
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
-                if let Some(snapshot) = sub_tables_snapshot
+                if let Some(cursor) = sub_table_cursor
                     && let Some(current_table) = self.symbol_table_stack.last_mut()
                 {
-                    current_table.sub_tables = snapshot;
+                    current_table.next_sub_table = cursor;
                 }
 
                 self.switch_to_block(finally_except);
@@ -2617,13 +2613,8 @@ impl Compiler {
         }
 
         // Snapshot sub_tables before first finally compilation (for double compilation issue)
-        let sub_tables_snapshot = if !finalbody.is_empty() && finally_except_block.is_some() {
-            Some(
-                self.symbol_table_stack
-                    .last()
-                    .map(|t| t.sub_tables.clone())
-                    .unwrap_or_default(),
-            )
+        let sub_table_cursor = if !finalbody.is_empty() && finally_except_block.is_some() {
+            self.symbol_table_stack.last().map(|t| t.next_sub_table)
         } else {
             None
         };
@@ -2642,10 +2633,10 @@ impl Compiler {
         // Stack at entry: [lasti, exc] (from exception table with preserve_lasti=true)
         if let Some(finally_except) = finally_except_block {
             // Restore sub_tables for exception path compilation
-            if let Some(snapshot) = sub_tables_snapshot
+            if let Some(cursor) = sub_table_cursor
                 && let Some(current_table) = self.symbol_table_stack.last_mut()
             {
-                current_table.sub_tables = snapshot;
+                current_table.next_sub_table = cursor;
             }
 
             self.switch_to_block(finally_except);
@@ -3246,7 +3237,7 @@ impl Compiler {
                 num_typeparam_args as u32,
                 0,
                 type_params_name,
-            );
+            )?;
 
             // Add parameter names to varnames for the type params scope
             // These will be passed as arguments when the closure is called
@@ -3554,7 +3545,7 @@ impl Compiler {
     ) -> CompileResult<CodeObject> {
         // 1. Enter class scope
         let key = self.symbol_table_stack.len();
-        self.push_symbol_table();
+        self.push_symbol_table()?;
         self.enter_scope(name, CompilerScope::Class, key, firstlineno)?;
 
         // Set qualname using the new method
@@ -3660,7 +3651,7 @@ impl Compiler {
                 0,
                 0,
                 type_params_name,
-            );
+            )?;
 
             // Set private name for name mangling
             self.code_stack.last_mut().unwrap().private = Some(name.to_owned());
@@ -6322,7 +6313,7 @@ impl Compiler {
         };
 
         // Create magnificent function <listcomp>:
-        self.push_output(flags, 1, 1, 0, name.to_owned());
+        self.push_output(flags, 1, 1, 0, name.to_owned())?;
 
         // Mark that we're in an inlined comprehension
         self.current_code_info().in_inlined_comp = true;
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index fe4976bb086..47a6ccbbf30 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -44,6 +44,9 @@ pub struct SymbolTable {
     /// AST nodes.
     pub sub_tables: Vec<SymbolTable>,
 
+    /// Cursor pointing to the next sub-table to consume during compilation.
+    pub next_sub_table: usize,
+
     /// Variable names in definition order (parameters first, then locals)
     pub varnames: Vec<String>,
 
@@ -70,6 +73,7 @@ impl SymbolTable {
             is_nested,
             symbols: IndexMap::default(),
             sub_tables: vec![],
+            next_sub_table: 0,
             varnames: Vec::new(),
             needs_class_closure: false,
             needs_classdict: false,

From b38cdaa30ebf3379c85092df7d627fccfff143b1 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Fri, 9 Jan 2026 01:28:12 -0500
Subject: [PATCH 196/418] Update the concurrent library + Added tests (#6673)

* Updated concurrent library

* Added test_concurrent_futures from v3.13.11

* Annotated failing tests in test_concurrent_futures
---
 Lib/concurrent/futures/__init__.py            |   3 +-
 Lib/concurrent/futures/_base.py               |  24 +-
 Lib/concurrent/futures/process.py             | 238 ++++++----
 Lib/concurrent/futures/thread.py              |  27 +-
 Lib/test/test_concurrent_futures/__init__.py  |  18 +
 Lib/test/test_concurrent_futures/executor.py  | 162 +++++++
 .../test_as_completed.py                      | 118 +++++
 .../test_concurrent_futures/test_deadlock.py  | 332 ++++++++++++++
 .../test_concurrent_futures/test_future.py    | 291 +++++++++++++
 Lib/test/test_concurrent_futures/test_init.py | 152 +++++++
 .../test_process_pool.py                      | 234 ++++++++++
 .../test_concurrent_futures/test_shutdown.py  | 406 ++++++++++++++++++
 .../test_thread_pool.py                       | 122 ++++++
 Lib/test/test_concurrent_futures/test_wait.py | 205 +++++++++
 Lib/test/test_concurrent_futures/util.py      | 169 ++++++++
 15 files changed, 2400 insertions(+), 101 deletions(-)
 create mode 100644 Lib/test/test_concurrent_futures/__init__.py
 create mode 100644 Lib/test/test_concurrent_futures/executor.py
 create mode 100644 Lib/test/test_concurrent_futures/test_as_completed.py
 create mode 100644 Lib/test/test_concurrent_futures/test_deadlock.py
 create mode 100644 Lib/test/test_concurrent_futures/test_future.py
 create mode 100644 Lib/test/test_concurrent_futures/test_init.py
 create mode 100644 Lib/test/test_concurrent_futures/test_process_pool.py
 create mode 100644 Lib/test/test_concurrent_futures/test_shutdown.py
 create mode 100644 Lib/test/test_concurrent_futures/test_thread_pool.py
 create mode 100644 Lib/test/test_concurrent_futures/test_wait.py
 create mode 100644 Lib/test/test_concurrent_futures/util.py

diff --git a/Lib/concurrent/futures/__init__.py b/Lib/concurrent/futures/__init__.py
index d746aeac50a..72de617a5b6 100644
--- a/Lib/concurrent/futures/__init__.py
+++ b/Lib/concurrent/futures/__init__.py
@@ -23,6 +23,7 @@
     'ALL_COMPLETED',
     'CancelledError',
     'TimeoutError',
+    'InvalidStateError',
     'BrokenExecutor',
     'Future',
     'Executor',
@@ -50,4 +51,4 @@ def __getattr__(name):
         ThreadPoolExecutor = te
         return te
 
-    raise AttributeError(f"module {__name__} has no attribute {name}")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/concurrent/futures/_base.py b/Lib/concurrent/futures/_base.py
index cf119ac6437..7d69a5baead 100644
--- a/Lib/concurrent/futures/_base.py
+++ b/Lib/concurrent/futures/_base.py
@@ -50,9 +50,7 @@ class CancelledError(Error):
     """The Future was cancelled."""
     pass
 
-class TimeoutError(Error):
-    """The operation exceeded the given deadline."""
-    pass
+TimeoutError = TimeoutError  # make local alias for the standard exception
 
 class InvalidStateError(Error):
     """The operation is not allowed in this state."""
@@ -284,7 +282,7 @@ def wait(fs, timeout=None, return_when=ALL_COMPLETED):
         A named 2-tuple of sets. The first set, named 'done', contains the
         futures that completed (is finished or cancelled) before the wait
         completed. The second set, named 'not_done', contains uncompleted
-        futures. Duplicate futures given to *fs* are removed and will be 
+        futures. Duplicate futures given to *fs* are removed and will be
         returned only once.
     """
     fs = set(fs)
@@ -312,6 +310,18 @@ def wait(fs, timeout=None, return_when=ALL_COMPLETED):
     done.update(waiter.finished_futures)
     return DoneAndNotDoneFutures(done, fs - done)
 
+
+def _result_or_cancel(fut, timeout=None):
+    try:
+        try:
+            return fut.result(timeout)
+        finally:
+            fut.cancel()
+    finally:
+        # Break a reference cycle with the exception in self._exception
+        del fut
+
+
 class Future(object):
     """Represents the result of an asynchronous computation."""
 
@@ -386,7 +396,7 @@ def done(self):
             return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]
 
     def __get_result(self):
-        if self._exception:
+        if self._exception is not None:
             try:
                 raise self._exception
             finally:
@@ -606,9 +616,9 @@ def result_iterator():
                 while fs:
                     # Careful not to keep a reference to the popped future
                     if timeout is None:
-                        yield fs.pop().result()
+                        yield _result_or_cancel(fs.pop())
                     else:
-                        yield fs.pop().result(end_time - time.monotonic())
+                        yield _result_or_cancel(fs.pop(), end_time - time.monotonic())
             finally:
                 for future in fs:
                     future.cancel()
diff --git a/Lib/concurrent/futures/process.py b/Lib/concurrent/futures/process.py
index 57941e485d8..0dee8303ba2 100644
--- a/Lib/concurrent/futures/process.py
+++ b/Lib/concurrent/futures/process.py
@@ -49,6 +49,8 @@
 from concurrent.futures import _base
 import queue
 import multiprocessing as mp
+# This import is required to load the multiprocessing.connection submodule
+# so that it can be accessed later as `mp.connection`
 import multiprocessing.connection
 from multiprocessing.queues import Queue
 import threading
@@ -56,7 +58,7 @@
 from functools import partial
 import itertools
 import sys
-import traceback
+from traceback import format_exception
 
 
 _threads_wakeups = weakref.WeakKeyDictionary()
@@ -66,22 +68,31 @@
 class _ThreadWakeup:
     def __init__(self):
         self._closed = False
+        self._lock = threading.Lock()
         self._reader, self._writer = mp.Pipe(duplex=False)
 
     def close(self):
-        if not self._closed:
-            self._closed = True
-            self._writer.close()
-            self._reader.close()
+        # Please note that we do not take the self._lock when
+        # calling clear() (to avoid deadlocking) so this method can
+        # only be called safely from the same thread as all calls to
+        # clear() even if you hold the lock. Otherwise we
+        # might try to read from the closed pipe.
+        with self._lock:
+            if not self._closed:
+                self._closed = True
+                self._writer.close()
+                self._reader.close()
 
     def wakeup(self):
-        if not self._closed:
-            self._writer.send_bytes(b"")
+        with self._lock:
+            if not self._closed:
+                self._writer.send_bytes(b"")
 
     def clear(self):
-        if not self._closed:
-            while self._reader.poll():
-                self._reader.recv_bytes()
+        if self._closed:
+            raise RuntimeError('operation on closed _ThreadWakeup')
+        while self._reader.poll():
+            self._reader.recv_bytes()
 
 
 def _python_exit():
@@ -123,8 +134,7 @@ def __str__(self):
 
 class _ExceptionWithTraceback:
     def __init__(self, exc, tb):
-        tb = traceback.format_exception(type(exc), exc, tb)
-        tb = ''.join(tb)
+        tb = ''.join(format_exception(type(exc), exc, tb))
         self.exc = exc
         # Traceback object needs to be garbage-collected as its frames
         # contain references to all the objects in the exception scope
@@ -145,10 +155,11 @@ def __init__(self, future, fn, args, kwargs):
         self.kwargs = kwargs
 
 class _ResultItem(object):
-    def __init__(self, work_id, exception=None, result=None):
+    def __init__(self, work_id, exception=None, result=None, exit_pid=None):
         self.work_id = work_id
         self.exception = exception
         self.result = result
+        self.exit_pid = exit_pid
 
 class _CallItem(object):
     def __init__(self, work_id, fn, args, kwargs):
@@ -160,20 +171,17 @@ def __init__(self, work_id, fn, args, kwargs):
 
 class _SafeQueue(Queue):
     """Safe Queue set exception to the future object linked to a job"""
-    def __init__(self, max_size=0, *, ctx, pending_work_items, shutdown_lock,
-                 thread_wakeup):
+    def __init__(self, max_size=0, *, ctx, pending_work_items, thread_wakeup):
         self.pending_work_items = pending_work_items
-        self.shutdown_lock = shutdown_lock
         self.thread_wakeup = thread_wakeup
         super().__init__(max_size, ctx=ctx)
 
     def _on_queue_feeder_error(self, e, obj):
         if isinstance(obj, _CallItem):
-            tb = traceback.format_exception(type(e), e, e.__traceback__)
+            tb = format_exception(type(e), e, e.__traceback__)
             e.__cause__ = _RemoteTraceback('\n"""\n{}"""'.format(''.join(tb)))
             work_item = self.pending_work_items.pop(obj.work_id, None)
-            with self.shutdown_lock:
-                self.thread_wakeup.wakeup()
+            self.thread_wakeup.wakeup()
             # work_item can be None if another process terminated. In this
             # case, the executor_manager_thread fails all work_items
             # with BrokenProcessPool
@@ -183,16 +191,6 @@ def _on_queue_feeder_error(self, e, obj):
             super()._on_queue_feeder_error(e, obj)
 
 
-def _get_chunks(*iterables, chunksize):
-    """ Iterates over zip()ed iterables in chunks. """
-    it = zip(*iterables)
-    while True:
-        chunk = tuple(itertools.islice(it, chunksize))
-        if not chunk:
-            return
-        yield chunk
-
-
 def _process_chunk(fn, chunk):
     """ Processes a chunk of an iterable passed to map.
 
@@ -205,17 +203,19 @@ def _process_chunk(fn, chunk):
     return [fn(*args) for args in chunk]
 
 
-def _sendback_result(result_queue, work_id, result=None, exception=None):
+def _sendback_result(result_queue, work_id, result=None, exception=None,
+                     exit_pid=None):
     """Safely send back the given result or exception"""
     try:
         result_queue.put(_ResultItem(work_id, result=result,
-                                     exception=exception))
+                                     exception=exception, exit_pid=exit_pid))
     except BaseException as e:
         exc = _ExceptionWithTraceback(e, e.__traceback__)
-        result_queue.put(_ResultItem(work_id, exception=exc))
+        result_queue.put(_ResultItem(work_id, exception=exc,
+                                     exit_pid=exit_pid))
 
 
-def _process_worker(call_queue, result_queue, initializer, initargs):
+def _process_worker(call_queue, result_queue, initializer, initargs, max_tasks=None):
     """Evaluates calls from call_queue and places the results in result_queue.
 
     This worker is run in a separate process.
@@ -236,25 +236,38 @@ def _process_worker(call_queue, result_queue, initializer, initargs):
             # The parent will notice that the process stopped and
             # mark the pool broken
             return
+    num_tasks = 0
+    exit_pid = None
     while True:
         call_item = call_queue.get(block=True)
         if call_item is None:
             # Wake up queue management thread
             result_queue.put(os.getpid())
             return
+
+        if max_tasks is not None:
+            num_tasks += 1
+            if num_tasks >= max_tasks:
+                exit_pid = os.getpid()
+
         try:
             r = call_item.fn(*call_item.args, **call_item.kwargs)
         except BaseException as e:
             exc = _ExceptionWithTraceback(e, e.__traceback__)
-            _sendback_result(result_queue, call_item.work_id, exception=exc)
+            _sendback_result(result_queue, call_item.work_id, exception=exc,
+                             exit_pid=exit_pid)
         else:
-            _sendback_result(result_queue, call_item.work_id, result=r)
+            _sendback_result(result_queue, call_item.work_id, result=r,
+                             exit_pid=exit_pid)
             del r
 
         # Liberate the resource as soon as possible, to avoid holding onto
         # open files or shared memory that is not needed anymore
         del call_item
 
+        if exit_pid is not None:
+            return
+
 
 class _ExecutorManagerThread(threading.Thread):
     """Manages the communication between this process and the worker processes.
@@ -284,11 +297,10 @@ def __init__(self, executor):
         # if there is no pending work item.
         def weakref_cb(_,
                        thread_wakeup=self.thread_wakeup,
-                       shutdown_lock=self.shutdown_lock):
-            mp.util.debug('Executor collected: triggering callback for'
+                       mp_util_debug=mp.util.debug):
+            mp_util_debug('Executor collected: triggering callback for'
                           ' QueueManager wakeup')
-            with shutdown_lock:
-                thread_wakeup.wakeup()
+            thread_wakeup.wakeup()
 
         self.executor_reference = weakref.ref(executor, weakref_cb)
 
@@ -305,6 +317,10 @@ def weakref_cb(_,
         # A queue.Queue of work ids e.g. Queue([5, 6, ...]).
         self.work_ids_queue = executor._work_ids
 
+        # Maximum number of tasks a worker process can execute before
+        # exiting safely
+        self.max_tasks_per_child = executor._max_tasks_per_child
+
         # A dict mapping work ids to _WorkItems e.g.
         #     {5: <_WorkItem...>, 6: <_WorkItem...>, ...}
         self.pending_work_items = executor._pending_work_items
@@ -315,7 +331,14 @@ def run(self):
         # Main loop for the executor manager thread.
 
         while True:
-            self.add_call_item_to_queue()
+            # gh-109047: During Python finalization, self.call_queue.put()
+            # creation of a thread can fail with RuntimeError.
+            try:
+                self.add_call_item_to_queue()
+            except BaseException as exc:
+                cause = format_exception(exc)
+                self.terminate_broken(cause)
+                return
 
             result_item, is_broken, cause = self.wait_result_broken_or_wakeup()
 
@@ -324,19 +347,32 @@ def run(self):
                 return
             if result_item is not None:
                 self.process_result_item(result_item)
+
+                process_exited = result_item.exit_pid is not None
+                if process_exited:
+                    p = self.processes.pop(result_item.exit_pid)
+                    p.join()
+
                 # Delete reference to result_item to avoid keeping references
                 # while waiting on new results.
                 del result_item
 
-                # attempt to increment idle process count
-                executor = self.executor_reference()
-                if executor is not None:
-                    executor._idle_worker_semaphore.release()
-                del executor
+                if executor := self.executor_reference():
+                    if process_exited:
+                        with self.shutdown_lock:
+                            executor._adjust_process_count()
+                    else:
+                        executor._idle_worker_semaphore.release()
+                    del executor
 
             if self.is_shutting_down():
                 self.flag_executor_shutting_down()
 
+                # When only canceled futures remain in pending_work_items, our
+                # next call to wait_result_broken_or_wakeup would hang forever.
+                # This makes sure we have some running futures or none at all.
+                self.add_call_item_to_queue()
+
                 # Since no new work items can be added, it is safe to shutdown
                 # this thread if there are no pending work items.
                 if not self.pending_work_items:
@@ -386,14 +422,13 @@ def wait_result_broken_or_wakeup(self):
             try:
                 result_item = result_reader.recv()
                 is_broken = False
-            except BaseException as e:
-                cause = traceback.format_exception(type(e), e, e.__traceback__)
+            except BaseException as exc:
+                cause = format_exception(exc)
 
         elif wakeup_reader in ready:
             is_broken = False
 
-        with self.shutdown_lock:
-            self.thread_wakeup.clear()
+        self.thread_wakeup.clear()
 
         return result_item, is_broken, cause
 
@@ -401,24 +436,14 @@ def process_result_item(self, result_item):
         # Process the received a result_item. This can be either the PID of a
         # worker that exited gracefully or a _ResultItem
 
-        if isinstance(result_item, int):
-            # Clean shutdown of a worker using its PID
-            # (avoids marking the executor broken)
-            assert self.is_shutting_down()
-            p = self.processes.pop(result_item)
-            p.join()
-            if not self.processes:
-                self.join_executor_internals()
-                return
-        else:
-            # Received a _ResultItem so mark the future as completed.
-            work_item = self.pending_work_items.pop(result_item.work_id, None)
-            # work_item can be None if another process terminated (see above)
-            if work_item is not None:
-                if result_item.exception:
-                    work_item.future.set_exception(result_item.exception)
-                else:
-                    work_item.future.set_result(result_item.result)
+        # Received a _ResultItem so mark the future as completed.
+        work_item = self.pending_work_items.pop(result_item.work_id, None)
+        # work_item can be None if another process terminated (see above)
+        if work_item is not None:
+            if result_item.exception is not None:
+                work_item.future.set_exception(result_item.exception)
+            else:
+                work_item.future.set_result(result_item.result)
 
     def is_shutting_down(self):
         # Check whether we should start shutting down the executor.
@@ -430,7 +455,7 @@ def is_shutting_down(self):
         return (_global_shutdown or executor is None
                 or executor._shutdown_thread)
 
-    def terminate_broken(self, cause):
+    def _terminate_broken(self, cause):
         # Terminate the executor because it is in a broken state. The cause
         # argument can be used to display more information on the error that
         # lead the executor into becoming broken.
@@ -455,7 +480,14 @@ def terminate_broken(self, cause):
 
         # Mark pending tasks as failed.
         for work_id, work_item in self.pending_work_items.items():
-            work_item.future.set_exception(bpe)
+            try:
+                work_item.future.set_exception(bpe)
+            except _base.InvalidStateError:
+                # set_exception() fails if the future is cancelled: ignore it.
+                # Trying to check if the future is cancelled before calling
+                # set_exception() would leave a race condition if the future is
+                # cancelled between the check and set_exception().
+                pass
             # Delete references to object. See issue16284
             del work_item
         self.pending_work_items.clear()
@@ -465,8 +497,14 @@ def terminate_broken(self, cause):
         for p in self.processes.values():
             p.terminate()
 
+        self.call_queue._terminate_broken()
+
         # clean up resources
-        self.join_executor_internals()
+        self._join_executor_internals(broken=True)
+
+    def terminate_broken(self, cause):
+        with self.shutdown_lock:
+            self._terminate_broken(cause)
 
     def flag_executor_shutting_down(self):
         # Flag the executor as shutting down and cancel remaining tasks if
@@ -509,15 +547,24 @@ def shutdown_workers(self):
                     break
 
     def join_executor_internals(self):
-        self.shutdown_workers()
+        with self.shutdown_lock:
+            self._join_executor_internals()
+
+    def _join_executor_internals(self, broken=False):
+        # If broken, call_queue was closed and so can no longer be used.
+        if not broken:
+            self.shutdown_workers()
+
         # Release the queue's resources as soon as possible.
         self.call_queue.close()
         self.call_queue.join_thread()
-        with self.shutdown_lock:
-            self.thread_wakeup.close()
+        self.thread_wakeup.close()
+
         # If .join() is not called on the created processes then
         # some ctx.Queue methods may deadlock on Mac OS X.
         for p in self.processes.values():
+            if broken:
+                p.terminate()
             p.join()
 
     def get_n_children_alive(self):
@@ -582,22 +629,29 @@ class BrokenProcessPool(_base.BrokenExecutor):
 
 class ProcessPoolExecutor(_base.Executor):
     def __init__(self, max_workers=None, mp_context=None,
-                 initializer=None, initargs=()):
+                 initializer=None, initargs=(), *, max_tasks_per_child=None):
         """Initializes a new ProcessPoolExecutor instance.
 
         Args:
             max_workers: The maximum number of processes that can be used to
                 execute the given calls. If None or not given then as many
                 worker processes will be created as the machine has processors.
-            mp_context: A multiprocessing context to launch the workers. This
+            mp_context: A multiprocessing context to launch the workers created
+                using the multiprocessing.get_context('start method') API. This
                 object should provide SimpleQueue, Queue and Process.
             initializer: A callable used to initialize worker processes.
             initargs: A tuple of arguments to pass to the initializer.
+            max_tasks_per_child: The maximum number of tasks a worker process
+                can complete before it will exit and be replaced with a fresh
+                worker process. The default of None means worker process will
+                live as long as the executor. Requires a non-'fork' mp_context
+                start method. When given, we default to using 'spawn' if no
+                mp_context is supplied.
         """
         _check_system_limits()
 
         if max_workers is None:
-            self._max_workers = os.cpu_count() or 1
+            self._max_workers = os.process_cpu_count() or 1
             if sys.platform == 'win32':
                 self._max_workers = min(_MAX_WINDOWS_WORKERS,
                                         self._max_workers)
@@ -612,7 +666,10 @@ def __init__(self, max_workers=None, mp_context=None,
             self._max_workers = max_workers
 
         if mp_context is None:
-            mp_context = mp.get_context()
+            if max_tasks_per_child is not None:
+                mp_context = mp.get_context("spawn")
+            else:
+                mp_context = mp.get_context()
         self._mp_context = mp_context
 
         # https://github.com/python/cpython/issues/90622
@@ -624,6 +681,18 @@ def __init__(self, max_workers=None, mp_context=None,
         self._initializer = initializer
         self._initargs = initargs
 
+        if max_tasks_per_child is not None:
+            if not isinstance(max_tasks_per_child, int):
+                raise TypeError("max_tasks_per_child must be an integer")
+            elif max_tasks_per_child <= 0:
+                raise ValueError("max_tasks_per_child must be >= 1")
+            if self._mp_context.get_start_method(allow_none=False) == "fork":
+                # https://github.com/python/cpython/issues/90622
+                raise ValueError("max_tasks_per_child is incompatible with"
+                                 " the 'fork' multiprocessing start method;"
+                                 " supply a different mp_context.")
+        self._max_tasks_per_child = max_tasks_per_child
+
         # Management thread
         self._executor_manager_thread = None
 
@@ -646,7 +715,9 @@ def __init__(self, max_workers=None, mp_context=None,
         # as it could result in a deadlock if a worker process dies with the
         # _result_queue write lock still acquired.
         #
-        # _shutdown_lock must be locked to access _ThreadWakeup.
+        # Care must be taken to only call clear and close from the
+        # executor_manager_thread, since _ThreadWakeup.clear() is not protected
+        # by a lock.
         self._executor_manager_thread_wakeup = _ThreadWakeup()
 
         # Create communication channels for the executor
@@ -657,7 +728,6 @@ def __init__(self, max_workers=None, mp_context=None,
         self._call_queue = _SafeQueue(
             max_size=queue_size, ctx=self._mp_context,
             pending_work_items=self._pending_work_items,
-            shutdown_lock=self._shutdown_lock,
             thread_wakeup=self._executor_manager_thread_wakeup)
         # Killed worker processes can produce spurious "broken pipe"
         # tracebacks in the queue's own worker thread. But we detect killed
@@ -677,6 +747,11 @@ def _start_executor_manager_thread(self):
                 self._executor_manager_thread_wakeup
 
     def _adjust_process_count(self):
+        # gh-132969: avoid error when state is reset and executor is still running,
+        # which will happen when shutdown(wait=False) is called.
+        if self._processes is None:
+            return
+
         # if there's an idle process, we don't need to spawn a new one.
         if self._idle_worker_semaphore.acquire(blocking=False):
             return
@@ -705,7 +780,8 @@ def _spawn_process(self):
             args=(self._call_queue,
                   self._result_queue,
                   self._initializer,
-                  self._initargs))
+                  self._initargs,
+                  self._max_tasks_per_child))
         p.start()
         self._processes[p.pid] = p
 
@@ -759,7 +835,7 @@ def map(self, fn, *iterables, timeout=None, chunksize=1):
             raise ValueError("chunksize must be >= 1.")
 
         results = super().map(partial(_process_chunk, fn),
-                              _get_chunks(*iterables, chunksize=chunksize),
+                              itertools.batched(zip(*iterables), chunksize),
                               timeout=timeout)
         return _chain_from_iterable_of_lists(results)
 
diff --git a/Lib/concurrent/futures/thread.py b/Lib/concurrent/futures/thread.py
index 493861d314d..9021dde48ef 100644
--- a/Lib/concurrent/futures/thread.py
+++ b/Lib/concurrent/futures/thread.py
@@ -37,14 +37,14 @@ def _python_exit():
 threading._register_atexit(_python_exit)
 
 # At fork, reinitialize the `_global_shutdown_lock` lock in the child process
-# TODO RUSTPYTHON - _at_fork_reinit is not implemented yet
-if hasattr(os, 'register_at_fork') and hasattr(_global_shutdown_lock, '_at_fork_reinit'):
+if hasattr(os, 'register_at_fork'):
     os.register_at_fork(before=_global_shutdown_lock.acquire,
                         after_in_child=_global_shutdown_lock._at_fork_reinit,
                         after_in_parent=_global_shutdown_lock.release)
+    os.register_at_fork(after_in_child=_threads_queues.clear)
 
 
-class _WorkItem(object):
+class _WorkItem:
     def __init__(self, future, fn, args, kwargs):
         self.future = future
         self.fn = fn
@@ -79,17 +79,20 @@ def _worker(executor_reference, work_queue, initializer, initargs):
             return
     try:
         while True:
-            work_item = work_queue.get(block=True)
-            if work_item is not None:
-                work_item.run()
-                # Delete references to object. See issue16284
-                del work_item
-
-                # attempt to increment idle count
+            try:
+                work_item = work_queue.get_nowait()
+            except queue.Empty:
+                # attempt to increment idle count if queue is empty
                 executor = executor_reference()
                 if executor is not None:
                     executor._idle_semaphore.release()
                 del executor
+                work_item = work_queue.get(block=True)
+
+            if work_item is not None:
+                work_item.run()
+                # Delete references to object. See GH-60488
+                del work_item
                 continue
 
             executor = executor_reference()
@@ -137,10 +140,10 @@ def __init__(self, max_workers=None, thread_name_prefix='',
             # * CPU bound task which releases GIL
             # * I/O bound task (which releases GIL, of course)
             #
-            # We use cpu_count + 4 for both types of tasks.
+            # We use process_cpu_count + 4 for both types of tasks.
             # But we limit it to 32 to avoid consuming surprisingly large resource
             # on many core machine.
-            max_workers = min(32, (os.cpu_count() or 1) + 4)
+            max_workers = min(32, (os.process_cpu_count() or 1) + 4)
         if max_workers <= 0:
             raise ValueError("max_workers must be greater than 0")
 
diff --git a/Lib/test/test_concurrent_futures/__init__.py b/Lib/test/test_concurrent_futures/__init__.py
new file mode 100644
index 00000000000..b38bd38d338
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/__init__.py
@@ -0,0 +1,18 @@
+import os.path
+import unittest
+from test import support
+from test.support import threading_helper
+
+
+# Adjust if we ever have a platform with processes but not threads.
+threading_helper.requires_working_threading(module=True)
+
+
+if support.check_sanitizer(address=True, memory=True):
+    # gh-90791: Skip the test because it is too slow when Python is built
+    # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
+    raise unittest.SkipTest("test too slow on ASAN/MSAN build")
+
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_concurrent_futures/executor.py b/Lib/test/test_concurrent_futures/executor.py
new file mode 100644
index 00000000000..7442d3bee52
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/executor.py
@@ -0,0 +1,162 @@
+import threading
+import time
+import unittest
+import weakref
+from concurrent import futures
+from test import support
+from test.support import Py_GIL_DISABLED
+
+
+def mul(x, y):
+    return x * y
+
+def capture(*args, **kwargs):
+    return args, kwargs
+
+
+class MyObject(object):
+    def my_method(self):
+        pass
+
+
+def make_dummy_object(_):
+    return MyObject()
+
+
+# Used in test_swallows_falsey_exceptions
+def raiser(exception, msg='std'):
+    raise exception(msg)
+
+
+class FalseyBoolException(Exception):
+    def __bool__(self):
+        return False
+
+
+class FalseyLenException(Exception):
+    def __len__(self):
+        return 0
+
+
+class ExecutorTest:
+    # Executor.shutdown() and context manager usage is tested by
+    # ExecutorShutdownTest.
+    def test_submit(self):
+        future = self.executor.submit(pow, 2, 8)
+        self.assertEqual(256, future.result())
+
+    def test_submit_keyword(self):
+        future = self.executor.submit(mul, 2, y=8)
+        self.assertEqual(16, future.result())
+        future = self.executor.submit(capture, 1, self=2, fn=3)
+        self.assertEqual(future.result(), ((1,), {'self': 2, 'fn': 3}))
+        with self.assertRaises(TypeError):
+            self.executor.submit(fn=capture, arg=1)
+        with self.assertRaises(TypeError):
+            self.executor.submit(arg=1)
+
+    def test_map(self):
+        self.assertEqual(
+                list(self.executor.map(pow, range(10), range(10))),
+                list(map(pow, range(10), range(10))))
+
+        self.assertEqual(
+                list(self.executor.map(pow, range(10), range(10), chunksize=3)),
+                list(map(pow, range(10), range(10))))
+
+    def test_map_exception(self):
+        i = self.executor.map(divmod, [1, 1, 1, 1], [2, 3, 0, 5])
+        self.assertEqual(i.__next__(), (0, 1))
+        self.assertEqual(i.__next__(), (0, 1))
+        self.assertRaises(ZeroDivisionError, i.__next__)
+
+    @support.requires_resource('walltime')
+    def test_map_timeout(self):
+        results = []
+        try:
+            for i in self.executor.map(time.sleep,
+                                       [0, 0, 6],
+                                       timeout=5):
+                results.append(i)
+        except futures.TimeoutError:
+            pass
+        else:
+            self.fail('expected TimeoutError')
+
+        self.assertEqual([None, None], results)
+
+    def test_shutdown_race_issue12456(self):
+        # Issue #12456: race condition at shutdown where trying to post a
+        # sentinel in the call queue blocks (the queue is full while processes
+        # have exited).
+        self.executor.map(str, [2] * (self.worker_count + 1))
+        self.executor.shutdown()
+
+    @support.cpython_only
+    def test_no_stale_references(self):
+        # Issue #16284: check that the executors don't unnecessarily hang onto
+        # references.
+        my_object = MyObject()
+        my_object_collected = threading.Event()
+        def set_event():
+            if Py_GIL_DISABLED:
+                # gh-117688 Avoid deadlock by setting the event in a
+                # background thread. The current thread may be in the middle
+                # of the my_object_collected.wait() call, which holds locks
+                # needed by my_object_collected.set().
+                threading.Thread(target=my_object_collected.set).start()
+            else:
+                my_object_collected.set()
+        my_object_callback = weakref.ref(my_object, lambda obj: set_event())
+        # Deliberately discarding the future.
+        self.executor.submit(my_object.my_method)
+        del my_object
+
+        if Py_GIL_DISABLED:
+            # Due to biased reference counting, my_object might only be
+            # deallocated while the thread that created it runs -- if the
+            # thread is paused waiting on an event, it may not merge the
+            # refcount of the queued object. For that reason, we alternate
+            # between running the GC and waiting for the event.
+            wait_time = 0
+            collected = False
+            while not collected and wait_time <= support.SHORT_TIMEOUT:
+                support.gc_collect()
+                collected = my_object_collected.wait(timeout=1.0)
+                wait_time += 1.0
+        else:
+            collected = my_object_collected.wait(timeout=support.SHORT_TIMEOUT)
+        self.assertTrue(collected,
+                        "Stale reference not collected within timeout.")
+
+    def test_max_workers_negative(self):
+        for number in (0, -1):
+            with self.assertRaisesRegex(ValueError,
+                                        "max_workers must be greater "
+                                        "than 0"):
+                self.executor_type(max_workers=number)
+
+    def test_free_reference(self):
+        # Issue #14406: Result iterator should not keep an internal
+        # reference to result objects.
+        for obj in self.executor.map(make_dummy_object, range(10)):
+            wr = weakref.ref(obj)
+            del obj
+            support.gc_collect()  # For PyPy or other GCs.
+
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if wr() is None:
+                    break
+
+    def test_swallows_falsey_exceptions(self):
+        # see gh-132063: Prevent exceptions that evaluate as falsey
+        # from being ignored.
+        # Recall: `x` is falsey if `len(x)` returns 0 or `bool(x)` returns False.
+
+        msg = 'boolbool'
+        with self.assertRaisesRegex(FalseyBoolException, msg):
+            self.executor.submit(raiser, FalseyBoolException, msg).result()
+
+        msg = 'lenlen'
+        with self.assertRaisesRegex(FalseyLenException, msg):
+            self.executor.submit(raiser, FalseyLenException, msg).result()
diff --git a/Lib/test/test_concurrent_futures/test_as_completed.py b/Lib/test/test_concurrent_futures/test_as_completed.py
new file mode 100644
index 00000000000..c90b0021d85
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_as_completed.py
@@ -0,0 +1,118 @@
+import itertools
+import time
+import unittest
+import weakref
+from concurrent import futures
+from concurrent.futures._base import (
+    CANCELLED_AND_NOTIFIED, FINISHED, Future)
+
+from test import support
+
+from .util import (
+    PENDING_FUTURE, RUNNING_FUTURE,
+    CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE, SUCCESSFUL_FUTURE,
+    create_future, create_executor_tests, setup_module)
+
+
+def mul(x, y):
+    return x * y
+
+
+class AsCompletedTests:
+    def test_no_timeout(self):
+        future1 = self.executor.submit(mul, 2, 21)
+        future2 = self.executor.submit(mul, 7, 6)
+
+        completed = set(futures.as_completed(
+                [CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 SUCCESSFUL_FUTURE,
+                 future1, future2]))
+        self.assertEqual(set(
+                [CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 SUCCESSFUL_FUTURE,
+                 future1, future2]),
+                completed)
+
+    def test_future_times_out(self):
+        """Test ``futures.as_completed`` timing out before
+        completing it's final future."""
+        already_completed = {CANCELLED_AND_NOTIFIED_FUTURE,
+                             EXCEPTION_FUTURE,
+                             SUCCESSFUL_FUTURE}
+
+        # Windows clock resolution is around 15.6 ms
+        short_timeout = 0.100
+        for timeout in (0, short_timeout):
+            with self.subTest(timeout):
+
+                completed_futures = set()
+                future = self.executor.submit(time.sleep, short_timeout * 10)
+
+                try:
+                    for f in futures.as_completed(
+                        already_completed | {future},
+                        timeout
+                    ):
+                        completed_futures.add(f)
+                except futures.TimeoutError:
+                    pass
+
+                # Check that ``future`` wasn't completed.
+                self.assertEqual(completed_futures, already_completed)
+
+    def test_duplicate_futures(self):
+        # Issue 20367. Duplicate futures should not raise exceptions or give
+        # duplicate responses.
+        # Issue #31641: accept arbitrary iterables.
+        future1 = self.executor.submit(time.sleep, 2)
+        completed = [
+            f for f in futures.as_completed(itertools.repeat(future1, 3))
+        ]
+        self.assertEqual(len(completed), 1)
+
+    def test_free_reference_yielded_future(self):
+        # Issue #14406: Generator should not keep references
+        # to finished futures.
+        futures_list = [Future() for _ in range(8)]
+        futures_list.append(create_future(state=CANCELLED_AND_NOTIFIED))
+        futures_list.append(create_future(state=FINISHED, result=42))
+
+        with self.assertRaises(futures.TimeoutError):
+            for future in futures.as_completed(futures_list, timeout=0):
+                futures_list.remove(future)
+                wr = weakref.ref(future)
+                del future
+                support.gc_collect()  # For PyPy or other GCs.
+                self.assertIsNone(wr())
+
+        futures_list[0].set_result("test")
+        for future in futures.as_completed(futures_list):
+            futures_list.remove(future)
+            wr = weakref.ref(future)
+            del future
+            support.gc_collect()  # For PyPy or other GCs.
+            self.assertIsNone(wr())
+            if futures_list:
+                futures_list[0].set_result("test")
+
+    def test_correct_timeout_exception_msg(self):
+        futures_list = [CANCELLED_AND_NOTIFIED_FUTURE, PENDING_FUTURE,
+                        RUNNING_FUTURE, SUCCESSFUL_FUTURE]
+
+        with self.assertRaises(futures.TimeoutError) as cm:
+            list(futures.as_completed(futures_list, timeout=0))
+
+        self.assertEqual(str(cm.exception), '2 (of 4) futures unfinished')
+
+
+create_executor_tests(globals(), AsCompletedTests)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_deadlock.py b/Lib/test/test_concurrent_futures/test_deadlock.py
new file mode 100644
index 00000000000..dcc1d68563a
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_deadlock.py
@@ -0,0 +1,332 @@
+import contextlib
+import queue
+import signal
+import sys
+import time
+import unittest
+import unittest.mock
+from pickle import PicklingError
+from concurrent import futures
+from concurrent.futures.process import BrokenProcessPool, _ThreadWakeup
+
+from test import support
+
+from .util import (
+    create_executor_tests, setup_module,
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin)
+
+
+def _crash(delay=None):
+    """Induces a segfault."""
+    if delay:
+        time.sleep(delay)
+    import faulthandler
+    faulthandler.disable()
+    faulthandler._sigsegv()
+
+
+def _crash_with_data(data):
+    """Induces a segfault with dummy data in input."""
+    _crash()
+
+
+def _exit():
+    """Induces a sys exit with exitcode 1."""
+    sys.exit(1)
+
+
+def _raise_error(Err):
+    """Function that raises an Exception in process."""
+    raise Err()
+
+
+def _raise_error_ignore_stderr(Err):
+    """Function that raises an Exception in process and ignores stderr."""
+    import io
+    sys.stderr = io.StringIO()
+    raise Err()
+
+
+def _return_instance(cls):
+    """Function that returns a instance of cls."""
+    return cls()
+
+
+class CrashAtPickle(object):
+    """Bad object that triggers a segfault at pickling time."""
+    def __reduce__(self):
+        _crash()
+
+
+class CrashAtUnpickle(object):
+    """Bad object that triggers a segfault at unpickling time."""
+    def __reduce__(self):
+        return _crash, ()
+
+
+class ExitAtPickle(object):
+    """Bad object that triggers a process exit at pickling time."""
+    def __reduce__(self):
+        _exit()
+
+
+class ExitAtUnpickle(object):
+    """Bad object that triggers a process exit at unpickling time."""
+    def __reduce__(self):
+        return _exit, ()
+
+
+class ErrorAtPickle(object):
+    """Bad object that triggers an error at pickling time."""
+    def __reduce__(self):
+        from pickle import PicklingError
+        raise PicklingError("Error in pickle")
+
+
+class ErrorAtUnpickle(object):
+    """Bad object that triggers an error at unpickling time."""
+    def __reduce__(self):
+        from pickle import UnpicklingError
+        return _raise_error_ignore_stderr, (UnpicklingError, )
+
+
+class ExecutorDeadlockTest:
+    TIMEOUT = support.LONG_TIMEOUT
+
+    def _fail_on_deadlock(self, executor):
+        # If we did not recover before TIMEOUT seconds, consider that the
+        # executor is in a deadlock state and forcefully clean all its
+        # composants.
+        import faulthandler
+        from tempfile import TemporaryFile
+        with TemporaryFile(mode="w+") as f:
+            faulthandler.dump_traceback(file=f)
+            f.seek(0)
+            tb = f.read()
+        for p in executor._processes.values():
+            p.terminate()
+        # This should be safe to call executor.shutdown here as all possible
+        # deadlocks should have been broken.
+        executor.shutdown(wait=True)
+        print(f"\nTraceback:\n {tb}", file=sys.__stderr__)
+        self.fail(f"Executor deadlock:\n\n{tb}")
+
+
+    def _check_crash(self, error, func, *args, ignore_stderr=False):
+        # test for deadlock caused by crashes in a pool
+        self.executor.shutdown(wait=True)
+
+        executor = self.executor_type(
+            max_workers=2, mp_context=self.get_context())
+        res = executor.submit(func, *args)
+
+        if ignore_stderr:
+            cm = support.captured_stderr()
+        else:
+            cm = contextlib.nullcontext()
+
+        try:
+            with self.assertRaises(error):
+                with cm:
+                    res.result(timeout=self.TIMEOUT)
+        except futures.TimeoutError:
+            # If we did not recover before TIMEOUT seconds,
+            # consider that the executor is in a deadlock state
+            self._fail_on_deadlock(executor)
+        executor.shutdown(wait=True)
+
+    def test_error_at_task_pickle(self):
+        # Check problem occurring while pickling a task in
+        # the task_handler thread
+        self._check_crash(PicklingError, id, ErrorAtPickle())
+
+    def test_exit_at_task_unpickle(self):
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, ExitAtUnpickle())
+
+    def test_error_at_task_unpickle(self):
+        # gh-109832: Restore stderr overridden by _raise_error_ignore_stderr()
+        self.addCleanup(setattr, sys, 'stderr', sys.stderr)
+
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, ErrorAtUnpickle())
+
+    def test_crash_at_task_unpickle(self):
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, CrashAtUnpickle())
+
+    def test_crash_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(BrokenProcessPool, _crash)
+
+    def test_exit_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(SystemExit, _exit)
+
+    def test_error_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(RuntimeError, _raise_error, RuntimeError)
+
+    def test_crash_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(BrokenProcessPool, _return_instance, CrashAtPickle)
+
+    def test_exit_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(SystemExit, _return_instance, ExitAtPickle)
+
+    def test_error_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(PicklingError, _return_instance, ErrorAtPickle)
+
+    def test_error_during_result_unpickle_in_result_handler(self):
+        # gh-109832: Restore stderr overridden by _raise_error_ignore_stderr()
+        self.addCleanup(setattr, sys, 'stderr', sys.stderr)
+
+        # Check problem occurring while unpickling a task in
+        # the result_handler thread
+        self._check_crash(BrokenProcessPool,
+                          _return_instance, ErrorAtUnpickle,
+                          ignore_stderr=True)
+
+    def test_exit_during_result_unpickle_in_result_handler(self):
+        # Check problem occurring while unpickling a task in
+        # the result_handler thread
+        self._check_crash(BrokenProcessPool, _return_instance, ExitAtUnpickle)
+
+    def test_shutdown_deadlock(self):
+        # Test that the pool calling shutdown do not cause deadlock
+        # if a worker fails after the shutdown call.
+        self.executor.shutdown(wait=True)
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+            f = executor.submit(_crash, delay=.1)
+            executor.shutdown(wait=True)
+            with self.assertRaises(BrokenProcessPool):
+                f.result()
+
+    def test_shutdown_deadlock_pickle(self):
+        # Test that the pool calling shutdown with wait=False does not cause
+        # a deadlock if a task fails at pickle after the shutdown call.
+        # Reported in bpo-39104.
+        self.executor.shutdown(wait=True)
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+
+            # Start the executor and get the executor_manager_thread to collect
+            # the threads and avoid dangling thread that should be cleaned up
+            # asynchronously.
+            executor.submit(id, 42).result()
+            executor_manager = executor._executor_manager_thread
+
+            # Submit a task that fails at pickle and shutdown the executor
+            # without waiting
+            f = executor.submit(id, ErrorAtPickle())
+            executor.shutdown(wait=False)
+            with self.assertRaises(PicklingError):
+                f.result()
+
+        # Make sure the executor is eventually shutdown and do not leave
+        # dangling threads
+        executor_manager.join()
+
+    def test_crash_big_data(self):
+        # Test that there is a clean exception instad of a deadlock when a
+        # child process crashes while some data is being written into the
+        # queue.
+        # https://github.com/python/cpython/issues/94777
+        self.executor.shutdown(wait=True)
+        data = "a" * support.PIPE_MAX_SIZE
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+            with self.assertRaises(BrokenProcessPool):
+                list(executor.map(_crash_with_data, [data] * 10))
+
+        executor.shutdown(wait=True)
+
+    def test_gh105829_should_not_deadlock_if_wakeup_pipe_full(self):
+        # Issue #105829: The _ExecutorManagerThread wakeup pipe could
+        # fill up and block. See: https://github.com/python/cpython/issues/105829
+
+        # Lots of cargo culting while writing this test, apologies if
+        # something is really stupid...
+
+        self.executor.shutdown(wait=True)
+
+        if not hasattr(signal, 'alarm'):
+            raise unittest.SkipTest(
+                "Tested platform does not support the alarm signal")
+
+        def timeout(_signum, _frame):
+            import faulthandler
+            faulthandler.dump_traceback()
+
+            raise RuntimeError("timed out while submitting jobs?")
+
+        thread_run = futures.process._ExecutorManagerThread.run
+        def mock_run(self):
+            # Delay thread startup so the wakeup pipe can fill up and block
+            time.sleep(3)
+            thread_run(self)
+
+        class MockWakeup(_ThreadWakeup):
+            """Mock wakeup object to force the wakeup to block"""
+            def __init__(self):
+                super().__init__()
+                self._dummy_queue = queue.Queue(maxsize=1)
+
+            def wakeup(self):
+                self._dummy_queue.put(None, block=True)
+                super().wakeup()
+
+            def clear(self):
+                super().clear()
+                try:
+                    while True:
+                        self._dummy_queue.get_nowait()
+                except queue.Empty:
+                    pass
+
+        with (unittest.mock.patch.object(futures.process._ExecutorManagerThread,
+                                         'run', mock_run),
+              unittest.mock.patch('concurrent.futures.process._ThreadWakeup',
+                                  MockWakeup)):
+            with self.executor_type(max_workers=2,
+                                    mp_context=self.get_context()) as executor:
+                self.executor = executor  # Allow clean up in fail_on_deadlock
+
+                job_num = 100
+                job_data = range(job_num)
+
+                # Need to use sigalarm for timeout detection because
+                # Executor.submit is not guarded by any timeout (both
+                # self._work_ids.put(self._queue_count) and
+                # self._executor_manager_thread_wakeup.wakeup() might
+                # timeout, maybe more?). In this specific case it was
+                # the wakeup call that deadlocked on a blocking pipe.
+                old_handler = signal.signal(signal.SIGALRM, timeout)
+                try:
+                    signal.alarm(int(self.TIMEOUT))
+                    self.assertEqual(job_num, len(list(executor.map(int, job_data))))
+                finally:
+                    signal.alarm(0)
+                    signal.signal(signal.SIGALRM, old_handler)
+
+
+create_executor_tests(globals(), ExecutorDeadlockTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_future.py b/Lib/test/test_concurrent_futures/test_future.py
new file mode 100644
index 00000000000..4066ea1ee4b
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_future.py
@@ -0,0 +1,291 @@
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures._base import (
+    PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED, Future)
+
+from test import support
+
+from .util import (
+    PENDING_FUTURE, RUNNING_FUTURE, CANCELLED_FUTURE,
+    CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE, SUCCESSFUL_FUTURE,
+    BaseTestCase, create_future, setup_module)
+
+
+class FutureTests(BaseTestCase):
+    def test_done_callback_with_result(self):
+        callback_result = None
+        def fn(callback_future):
+            nonlocal callback_result
+            callback_result = callback_future.result()
+
+        f = Future()
+        f.add_done_callback(fn)
+        f.set_result(5)
+        self.assertEqual(5, callback_result)
+
+    def test_done_callback_with_exception(self):
+        callback_exception = None
+        def fn(callback_future):
+            nonlocal callback_exception
+            callback_exception = callback_future.exception()
+
+        f = Future()
+        f.add_done_callback(fn)
+        f.set_exception(Exception('test'))
+        self.assertEqual(('test',), callback_exception.args)
+
+    def test_done_callback_with_cancel(self):
+        was_cancelled = None
+        def fn(callback_future):
+            nonlocal was_cancelled
+            was_cancelled = callback_future.cancelled()
+
+        f = Future()
+        f.add_done_callback(fn)
+        self.assertTrue(f.cancel())
+        self.assertTrue(was_cancelled)
+
+    def test_done_callback_raises(self):
+        with support.captured_stderr() as stderr:
+            raising_was_called = False
+            fn_was_called = False
+
+            def raising_fn(callback_future):
+                nonlocal raising_was_called
+                raising_was_called = True
+                raise Exception('doh!')
+
+            def fn(callback_future):
+                nonlocal fn_was_called
+                fn_was_called = True
+
+            f = Future()
+            f.add_done_callback(raising_fn)
+            f.add_done_callback(fn)
+            f.set_result(5)
+            self.assertTrue(raising_was_called)
+            self.assertTrue(fn_was_called)
+            self.assertIn('Exception: doh!', stderr.getvalue())
+
+    def test_done_callback_already_successful(self):
+        callback_result = None
+        def fn(callback_future):
+            nonlocal callback_result
+            callback_result = callback_future.result()
+
+        f = Future()
+        f.set_result(5)
+        f.add_done_callback(fn)
+        self.assertEqual(5, callback_result)
+
+    def test_done_callback_already_failed(self):
+        callback_exception = None
+        def fn(callback_future):
+            nonlocal callback_exception
+            callback_exception = callback_future.exception()
+
+        f = Future()
+        f.set_exception(Exception('test'))
+        f.add_done_callback(fn)
+        self.assertEqual(('test',), callback_exception.args)
+
+    def test_done_callback_already_cancelled(self):
+        was_cancelled = None
+        def fn(callback_future):
+            nonlocal was_cancelled
+            was_cancelled = callback_future.cancelled()
+
+        f = Future()
+        self.assertTrue(f.cancel())
+        f.add_done_callback(fn)
+        self.assertTrue(was_cancelled)
+
+    def test_done_callback_raises_already_succeeded(self):
+        with support.captured_stderr() as stderr:
+            def raising_fn(callback_future):
+                raise Exception('doh!')
+
+            f = Future()
+
+            # Set the result first to simulate a future that runs instantly,
+            # effectively allowing the callback to be run immediately.
+            f.set_result(5)
+            f.add_done_callback(raising_fn)
+
+            self.assertIn('exception calling callback for', stderr.getvalue())
+            self.assertIn('doh!', stderr.getvalue())
+
+
+    def test_repr(self):
+        self.assertRegex(repr(PENDING_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=pending>')
+        self.assertRegex(repr(RUNNING_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=running>')
+        self.assertRegex(repr(CANCELLED_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=cancelled>')
+        self.assertRegex(repr(CANCELLED_AND_NOTIFIED_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=cancelled>')
+        self.assertRegex(
+                repr(EXCEPTION_FUTURE),
+                '<Future at 0x[0-9a-f]+ state=finished raised OSError>')
+        self.assertRegex(
+                repr(SUCCESSFUL_FUTURE),
+                '<Future at 0x[0-9a-f]+ state=finished returned int>')
+
+    def test_cancel(self):
+        f1 = create_future(state=PENDING)
+        f2 = create_future(state=RUNNING)
+        f3 = create_future(state=CANCELLED)
+        f4 = create_future(state=CANCELLED_AND_NOTIFIED)
+        f5 = create_future(state=FINISHED, exception=OSError())
+        f6 = create_future(state=FINISHED, result=5)
+
+        self.assertTrue(f1.cancel())
+        self.assertEqual(f1._state, CANCELLED)
+
+        self.assertFalse(f2.cancel())
+        self.assertEqual(f2._state, RUNNING)
+
+        self.assertTrue(f3.cancel())
+        self.assertEqual(f3._state, CANCELLED)
+
+        self.assertTrue(f4.cancel())
+        self.assertEqual(f4._state, CANCELLED_AND_NOTIFIED)
+
+        self.assertFalse(f5.cancel())
+        self.assertEqual(f5._state, FINISHED)
+
+        self.assertFalse(f6.cancel())
+        self.assertEqual(f6._state, FINISHED)
+
+    def test_cancelled(self):
+        self.assertFalse(PENDING_FUTURE.cancelled())
+        self.assertFalse(RUNNING_FUTURE.cancelled())
+        self.assertTrue(CANCELLED_FUTURE.cancelled())
+        self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.cancelled())
+        self.assertFalse(EXCEPTION_FUTURE.cancelled())
+        self.assertFalse(SUCCESSFUL_FUTURE.cancelled())
+
+    def test_done(self):
+        self.assertFalse(PENDING_FUTURE.done())
+        self.assertFalse(RUNNING_FUTURE.done())
+        self.assertTrue(CANCELLED_FUTURE.done())
+        self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.done())
+        self.assertTrue(EXCEPTION_FUTURE.done())
+        self.assertTrue(SUCCESSFUL_FUTURE.done())
+
+    def test_running(self):
+        self.assertFalse(PENDING_FUTURE.running())
+        self.assertTrue(RUNNING_FUTURE.running())
+        self.assertFalse(CANCELLED_FUTURE.running())
+        self.assertFalse(CANCELLED_AND_NOTIFIED_FUTURE.running())
+        self.assertFalse(EXCEPTION_FUTURE.running())
+        self.assertFalse(SUCCESSFUL_FUTURE.running())
+
+    def test_result_with_timeout(self):
+        self.assertRaises(futures.TimeoutError,
+                          PENDING_FUTURE.result, timeout=0)
+        self.assertRaises(futures.TimeoutError,
+                          RUNNING_FUTURE.result, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_FUTURE.result, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_AND_NOTIFIED_FUTURE.result, timeout=0)
+        self.assertRaises(OSError, EXCEPTION_FUTURE.result, timeout=0)
+        self.assertEqual(SUCCESSFUL_FUTURE.result(timeout=0), 42)
+
+    def test_result_with_success(self):
+        # TODO(brian@sweetapp.com): This test is timing dependent.
+        def notification():
+            # Wait until the main thread is waiting for the result.
+            time.sleep(1)
+            f1.set_result(42)
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertEqual(f1.result(timeout=5), 42)
+        t.join()
+
+    def test_result_with_cancel(self):
+        # TODO(brian@sweetapp.com): This test is timing dependent.
+        def notification():
+            # Wait until the main thread is waiting for the result.
+            time.sleep(1)
+            f1.cancel()
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertRaises(futures.CancelledError,
+                          f1.result, timeout=support.SHORT_TIMEOUT)
+        t.join()
+
+    def test_exception_with_timeout(self):
+        self.assertRaises(futures.TimeoutError,
+                          PENDING_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.TimeoutError,
+                          RUNNING_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_AND_NOTIFIED_FUTURE.exception, timeout=0)
+        self.assertTrue(isinstance(EXCEPTION_FUTURE.exception(timeout=0),
+                                   OSError))
+        self.assertEqual(SUCCESSFUL_FUTURE.exception(timeout=0), None)
+
+    def test_exception_with_success(self):
+        def notification():
+            # Wait until the main thread is waiting for the exception.
+            time.sleep(1)
+            with f1._condition:
+                f1._state = FINISHED
+                f1._exception = OSError()
+                f1._condition.notify_all()
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertTrue(isinstance(f1.exception(timeout=support.SHORT_TIMEOUT), OSError))
+        t.join()
+
+    def test_multiple_set_result(self):
+        f = create_future(state=PENDING)
+        f.set_result(1)
+
+        with self.assertRaisesRegex(
+                futures.InvalidStateError,
+                'FINISHED: <Future at 0x[0-9a-f]+ '
+                'state=finished returned int>'
+        ):
+            f.set_result(2)
+
+        self.assertTrue(f.done())
+        self.assertEqual(f.result(), 1)
+
+    def test_multiple_set_exception(self):
+        f = create_future(state=PENDING)
+        e = ValueError()
+        f.set_exception(e)
+
+        with self.assertRaisesRegex(
+                futures.InvalidStateError,
+                'FINISHED: <Future at 0x[0-9a-f]+ '
+                'state=finished raised ValueError>'
+        ):
+            f.set_exception(Exception())
+
+        self.assertEqual(f.exception(), e)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_init.py b/Lib/test/test_concurrent_futures/test_init.py
new file mode 100644
index 00000000000..df640929309
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_init.py
@@ -0,0 +1,152 @@
+import contextlib
+import logging
+import queue
+import time
+import unittest
+import sys
+import io
+from concurrent.futures._base import BrokenExecutor
+from concurrent.futures.process import _check_system_limits
+
+from logging.handlers import QueueHandler
+
+from test import support
+
+from .util import ExecutorMixin, create_executor_tests, setup_module
+
+
+INITIALIZER_STATUS = 'uninitialized'
+
+def init(x):
+    global INITIALIZER_STATUS
+    INITIALIZER_STATUS = x
+
+def get_init_status():
+    return INITIALIZER_STATUS
+
+def init_fail(log_queue=None):
+    if log_queue is not None:
+        logger = logging.getLogger('concurrent.futures')
+        logger.addHandler(QueueHandler(log_queue))
+        logger.setLevel('CRITICAL')
+        logger.propagate = False
+    time.sleep(0.1)  # let some futures be scheduled
+    raise ValueError('error in initializer')
+
+
+class InitializerMixin(ExecutorMixin):
+    worker_count = 2
+
+    def setUp(self):
+        global INITIALIZER_STATUS
+        INITIALIZER_STATUS = 'uninitialized'
+        self.executor_kwargs = dict(initializer=init,
+                                    initargs=('initialized',))
+        super().setUp()
+
+    def test_initializer(self):
+        futures = [self.executor.submit(get_init_status)
+                   for _ in range(self.worker_count)]
+
+        for f in futures:
+            self.assertEqual(f.result(), 'initialized')
+
+
+class FailingInitializerMixin(ExecutorMixin):
+    worker_count = 2
+
+    def setUp(self):
+        if hasattr(self, "ctx"):
+            # Pass a queue to redirect the child's logging output
+            self.mp_context = self.get_context()
+            self.log_queue = self.mp_context.Queue()
+            self.executor_kwargs = dict(initializer=init_fail,
+                                        initargs=(self.log_queue,))
+        else:
+            # In a thread pool, the child shares our logging setup
+            # (see _assert_logged())
+            self.mp_context = None
+            self.log_queue = None
+            self.executor_kwargs = dict(initializer=init_fail)
+        super().setUp()
+
+    def test_initializer(self):
+        with self._assert_logged('ValueError: error in initializer'):
+            try:
+                future = self.executor.submit(get_init_status)
+            except BrokenExecutor:
+                # Perhaps the executor is already broken
+                pass
+            else:
+                with self.assertRaises(BrokenExecutor):
+                    future.result()
+
+            # At some point, the executor should break
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT,
+                                            "executor not broken"):
+                if self.executor._broken:
+                    break
+
+            # ... and from this point submit() is guaranteed to fail
+            with self.assertRaises(BrokenExecutor):
+                self.executor.submit(get_init_status)
+
+    @contextlib.contextmanager
+    def _assert_logged(self, msg):
+        if self.log_queue is not None:
+            yield
+            output = []
+            try:
+                while True:
+                    output.append(self.log_queue.get_nowait().getMessage())
+            except queue.Empty:
+                pass
+        else:
+            with self.assertLogs('concurrent.futures', 'CRITICAL') as cm:
+                yield
+            output = cm.output
+        self.assertTrue(any(msg in line for line in output),
+                        output)
+
+
+create_executor_tests(globals(), InitializerMixin)
+create_executor_tests(globals(), FailingInitializerMixin)
+
+
+@unittest.skipIf(sys.platform == "win32", "Resource Tracker doesn't run on Windows")
+class FailingInitializerResourcesTest(unittest.TestCase):
+    """
+    Source: https://github.com/python/cpython/issues/104090
+    """
+
+    def _test(self, test_class):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+
+        runner = unittest.TextTestRunner(stream=io.StringIO())
+        runner.run(test_class('test_initializer'))
+
+        # GH-104090:
+        # Stop resource tracker manually now, so we can verify there are not leaked resources by checking
+        # the process exit code
+        from multiprocessing.resource_tracker import _resource_tracker
+        _resource_tracker._stop()
+
+        self.assertEqual(_resource_tracker._exitcode, 0)
+
+    def test_spawn(self):
+        self._test(ProcessPoolSpawnFailingInitializerTest)
+
+    @support.skip_if_sanitizer("TSAN doesn't support threads after fork", thread=True)
+    def test_forkserver(self):
+        self._test(ProcessPoolForkserverFailingInitializerTest)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
new file mode 100644
index 00000000000..17d311888a6
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -0,0 +1,234 @@
+import os
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures.process import BrokenProcessPool
+
+from test import support
+from test.support import hashlib_helper
+
+from .executor import ExecutorTest, mul
+from .util import (
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin,
+    create_executor_tests, setup_module)
+
+
+class EventfulGCObj():
+    def __init__(self, mgr):
+        self.event = mgr.Event()
+
+    def __del__(self):
+        self.event.set()
+
+
+class ProcessPoolExecutorTest(ExecutorTest):
+
+    @unittest.skipUnless(sys.platform=='win32', 'Windows-only process limit')
+    def test_max_workers_too_large(self):
+        with self.assertRaisesRegex(ValueError,
+                                    "max_workers must be <= 61"):
+            futures.ProcessPoolExecutor(max_workers=62)
+
+    def test_killed_child(self):
+        # When a child process is abruptly terminated, the whole pool gets
+        # "broken".
+        futures = [self.executor.submit(time.sleep, 3)]
+        # Get one of the processes, and terminate (kill) it
+        p = next(iter(self.executor._processes.values()))
+        p.terminate()
+        for fut in futures:
+            self.assertRaises(BrokenProcessPool, fut.result)
+        # Submitting other jobs fails as well.
+        self.assertRaises(BrokenProcessPool, self.executor.submit, pow, 2, 8)
+
+    def test_map_chunksize(self):
+        def bad_map():
+            list(self.executor.map(pow, range(40), range(40), chunksize=-1))
+
+        ref = list(map(pow, range(40), range(40)))
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=6)),
+            ref)
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=50)),
+            ref)
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=40)),
+            ref)
+        self.assertRaises(ValueError, bad_map)
+
+    @classmethod
+    def _test_traceback(cls):
+        raise RuntimeError(123) # some comment
+
+    def test_traceback(self):
+        # We want ensure that the traceback from the child process is
+        # contained in the traceback raised in the main process.
+        future = self.executor.submit(self._test_traceback)
+        with self.assertRaises(Exception) as cm:
+            future.result()
+
+        exc = cm.exception
+        self.assertIs(type(exc), RuntimeError)
+        self.assertEqual(exc.args, (123,))
+        cause = exc.__cause__
+        self.assertIs(type(cause), futures.process._RemoteTraceback)
+        self.assertIn('raise RuntimeError(123) # some comment', cause.tb)
+
+        with support.captured_stderr() as f1:
+            try:
+                raise exc
+            except RuntimeError:
+                sys.excepthook(*sys.exc_info())
+        self.assertIn('raise RuntimeError(123) # some comment',
+                      f1.getvalue())
+
+    @hashlib_helper.requires_hashdigest('md5')
+    def test_ressources_gced_in_workers(self):
+        # Ensure that argument for a job are correctly gc-ed after the job
+        # is finished
+        mgr = self.get_context().Manager()
+        obj = EventfulGCObj(mgr)
+        future = self.executor.submit(id, obj)
+        future.result()
+
+        self.assertTrue(obj.event.wait(timeout=1))
+
+        # explicitly destroy the object to ensure that EventfulGCObj.__del__()
+        # is called while manager is still running.
+        support.gc_collect()
+        obj = None
+        support.gc_collect()
+
+        mgr.shutdown()
+        mgr.join()
+
+    def test_saturation(self):
+        executor = self.executor
+        mp_context = self.get_context()
+        sem = mp_context.Semaphore(0)
+        job_count = 15 * executor._max_workers
+        for _ in range(job_count):
+            executor.submit(sem.acquire)
+        self.assertEqual(len(executor._processes), executor._max_workers)
+        for _ in range(job_count):
+            sem.release()
+
+    @support.requires_gil_enabled("gh-117344: test is flaky without the GIL")
+    def test_idle_process_reuse_one(self):
+        executor = self.executor
+        assert executor._max_workers >= 4
+        if self.get_context().get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        executor.submit(mul, 21, 2).result()
+        executor.submit(mul, 6, 7).result()
+        executor.submit(mul, 3, 14).result()
+        self.assertEqual(len(executor._processes), 1)
+
+    def test_idle_process_reuse_multiple(self):
+        executor = self.executor
+        assert executor._max_workers <= 5
+        if self.get_context().get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        executor.submit(mul, 12, 7).result()
+        executor.submit(mul, 33, 25)
+        executor.submit(mul, 25, 26).result()
+        executor.submit(mul, 18, 29)
+        executor.submit(mul, 1, 2).result()
+        executor.submit(mul, 0, 9)
+        self.assertLessEqual(len(executor._processes), 3)
+        executor.shutdown()
+
+    def test_max_tasks_per_child(self):
+        context = self.get_context()
+        if context.get_start_method(allow_none=False) == "fork":
+            with self.assertRaises(ValueError):
+                self.executor_type(1, mp_context=context, max_tasks_per_child=3)
+            return
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(
+                1, mp_context=context, max_tasks_per_child=3)
+        f1 = executor.submit(os.getpid)
+        original_pid = f1.result()
+        # The worker pid remains the same as the worker could be reused
+        f2 = executor.submit(os.getpid)
+        self.assertEqual(f2.result(), original_pid)
+        self.assertEqual(len(executor._processes), 1)
+        f3 = executor.submit(os.getpid)
+        self.assertEqual(f3.result(), original_pid)
+
+        # A new worker is spawned, with a statistically different pid,
+        # while the previous was reaped.
+        f4 = executor.submit(os.getpid)
+        new_pid = f4.result()
+        self.assertNotEqual(original_pid, new_pid)
+        self.assertEqual(len(executor._processes), 1)
+
+        executor.shutdown()
+
+    def test_max_tasks_per_child_defaults_to_spawn_context(self):
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(1, max_tasks_per_child=3)
+        self.assertEqual(executor._mp_context.get_start_method(), "spawn")
+
+    def test_max_tasks_early_shutdown(self):
+        context = self.get_context()
+        if context.get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(
+                3, mp_context=context, max_tasks_per_child=1)
+        futures = []
+        for i in range(6):
+            futures.append(executor.submit(mul, i, i))
+        executor.shutdown()
+        for i, future in enumerate(futures):
+            self.assertEqual(future.result(), mul(i, i))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON AttributeError: module 'threading' has no attribute '_start_joinable_thread'. Did you mean: '_start_new_thread'?
+    def test_python_finalization_error(self):
+        # gh-109047: Catch RuntimeError on thread creation
+        # during Python finalization.
+
+        context = self.get_context()
+
+        # gh-109047: Mock the threading.start_joinable_thread() function to inject
+        # RuntimeError: simulate the error raised during Python finalization.
+        # Block the second creation: create _ExecutorManagerThread, but block
+        # QueueFeederThread.
+        orig_start_new_thread = threading._start_joinable_thread
+        nthread = 0
+        def mock_start_new_thread(func, *args, **kwargs):
+            nonlocal nthread
+            if nthread >= 1:
+                raise RuntimeError("can't create new thread at "
+                                   "interpreter shutdown")
+            nthread += 1
+            return orig_start_new_thread(func, *args, **kwargs)
+
+        with support.swap_attr(threading, '_start_joinable_thread',
+                               mock_start_new_thread):
+            executor = self.executor_type(max_workers=2, mp_context=context)
+            with executor:
+                with self.assertRaises(BrokenProcessPool):
+                    list(executor.map(mul, [(2, 3)] * 10))
+            executor.shutdown()
+
+
+create_executor_tests(globals(), ProcessPoolExecutorTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_shutdown.py b/Lib/test/test_concurrent_futures/test_shutdown.py
new file mode 100644
index 00000000000..c879b6539b1
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_shutdown.py
@@ -0,0 +1,406 @@
+import signal
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+
+from test import support
+from test.support.script_helper import assert_python_ok
+
+from .util import (
+    BaseTestCase, ThreadPoolMixin, ProcessPoolForkMixin,
+    ProcessPoolForkserverMixin, ProcessPoolSpawnMixin,
+    create_executor_tests, setup_module)
+
+
+def sleep_and_print(t, msg):
+    time.sleep(t)
+    print(msg)
+    sys.stdout.flush()
+
+
+class ExecutorShutdownTest:
+    def test_run_after_shutdown(self):
+        self.executor.shutdown()
+        self.assertRaises(RuntimeError,
+                          self.executor.submit,
+                          pow, 2, 5)
+
+    @unittest.skip('TODO: RUSTPYTHON; hangs')
+    def test_interpreter_shutdown(self):
+        # Test the atexit hook for shutdown of worker threads and processes
+        rc, out, err = assert_python_ok('-c', """if 1:
+            from concurrent.futures import {executor_type}
+            from time import sleep
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                context = '{context}'
+                if context == "":
+                    t = {executor_type}(5)
+                else:
+                    from multiprocessing import get_context
+                    context = get_context(context)
+                    t = {executor_type}(5, mp_context=context)
+                t.submit(sleep_and_print, 1.0, "apple")
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, "ctx", "")))
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertFalse(err)
+        self.assertEqual(out.strip(), b"apple")
+
+    @unittest.skip('TODO: RUSTPYTHON; Hangs')
+    def test_submit_after_interpreter_shutdown(self):
+        # Test the atexit hook for shutdown of worker threads and processes
+        rc, out, err = assert_python_ok('-c', """if 1:
+            import atexit
+            @atexit.register
+            def run_last():
+                try:
+                    t.submit(id, None)
+                except RuntimeError:
+                    print("runtime-error")
+                    raise
+            from concurrent.futures import {executor_type}
+            if __name__ == "__main__":
+                context = '{context}'
+                if not context:
+                    t = {executor_type}(5)
+                else:
+                    from multiprocessing import get_context
+                    context = get_context(context)
+                    t = {executor_type}(5, mp_context=context)
+                    t.submit(id, 42).result()
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, "ctx", "")))
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertIn("RuntimeError: cannot schedule new futures", err.decode())
+        self.assertEqual(out.strip(), b"runtime-error")
+
+    def test_hang_issue12364(self):
+        fs = [self.executor.submit(time.sleep, 0.1) for _ in range(50)]
+        self.executor.shutdown()
+        for f in fs:
+            f.result()
+
+    def test_cancel_futures(self):
+        assert self.worker_count <= 5, "test needs few workers"
+        fs = [self.executor.submit(time.sleep, .1) for _ in range(50)]
+        self.executor.shutdown(cancel_futures=True)
+        # We can't guarantee the exact number of cancellations, but we can
+        # guarantee that *some* were cancelled. With few workers, many of
+        # the submitted futures should have been cancelled.
+        cancelled = [fut for fut in fs if fut.cancelled()]
+        self.assertGreater(len(cancelled), 20)
+
+        # Ensure the other futures were able to finish.
+        # Use "not fut.cancelled()" instead of "fut.done()" to include futures
+        # that may have been left in a pending state.
+        others = [fut for fut in fs if not fut.cancelled()]
+        for fut in others:
+            self.assertTrue(fut.done(), msg=f"{fut._state=}")
+            self.assertIsNone(fut.exception())
+
+        # Similar to the number of cancelled futures, we can't guarantee the
+        # exact number that completed. But, we can guarantee that at least
+        # one finished.
+        self.assertGreater(len(others), 0)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON AssertionError: b'' != b'apple'
+    def test_hang_gh83386(self):
+        """shutdown(wait=False) doesn't hang at exit with running futures.
+
+        See https://github.com/python/cpython/issues/83386.
+        """
+        if self.executor_type == futures.ProcessPoolExecutor:
+            raise unittest.SkipTest(
+                "Hangs, see https://github.com/python/cpython/issues/83386")
+
+        rc, out, err = assert_python_ok('-c', """if True:
+            from concurrent.futures import {executor_type}
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                if {context!r}: multiprocessing.set_start_method({context!r})
+                t = {executor_type}(max_workers=3)
+                t.submit(sleep_and_print, 1.0, "apple")
+                t.shutdown(wait=False)
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, 'ctx', None)))
+        self.assertFalse(err)
+        self.assertEqual(out.strip(), b"apple")
+
+    def test_hang_gh94440(self):
+        """shutdown(wait=True) doesn't hang when a future was submitted and
+        quickly canceled right before shutdown.
+
+        See https://github.com/python/cpython/issues/94440.
+        """
+        if not hasattr(signal, 'alarm'):
+            raise unittest.SkipTest(
+                "Tested platform does not support the alarm signal")
+
+        def timeout(_signum, _frame):
+            raise RuntimeError("timed out waiting for shutdown")
+
+        kwargs = {}
+        if getattr(self, 'ctx', None):
+            kwargs['mp_context'] = self.get_context()
+        executor = self.executor_type(max_workers=1, **kwargs)
+        executor.submit(int).result()
+        old_handler = signal.signal(signal.SIGALRM, timeout)
+        try:
+            signal.alarm(5)
+            executor.submit(int).cancel()
+            executor.shutdown(wait=True)
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+
+
+class ThreadPoolShutdownTest(ThreadPoolMixin, ExecutorShutdownTest, BaseTestCase):
+    def test_threads_terminate(self):
+        def acquire_lock(lock):
+            lock.acquire()
+
+        sem = threading.Semaphore(0)
+        for i in range(3):
+            self.executor.submit(acquire_lock, sem)
+        self.assertEqual(len(self.executor._threads), 3)
+        for i in range(3):
+            sem.release()
+        self.executor.shutdown()
+        for t in self.executor._threads:
+            t.join()
+
+    def test_context_manager_shutdown(self):
+        with futures.ThreadPoolExecutor(max_workers=5) as e:
+            executor = e
+            self.assertEqual(list(e.map(abs, range(-5, 5))),
+                             [5, 4, 3, 2, 1, 0, 1, 2, 3, 4])
+
+        for t in executor._threads:
+            t.join()
+
+    def test_del_shutdown(self):
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        res = executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+
+        for t in threads:
+            t.join()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    def test_shutdown_no_wait(self):
+        # Ensure that the executor cleans up the threads when calling
+        # shutdown with wait=False
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        res = executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        executor.shutdown(wait=False)
+        for t in threads:
+            t.join()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+
+    def test_thread_names_assigned(self):
+        executor = futures.ThreadPoolExecutor(
+            max_workers=5, thread_name_prefix='SpecialPool')
+        executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        for t in threads:
+            self.assertRegex(t.name, r'^SpecialPool_[0-4]$')
+            t.join()
+
+    def test_thread_names_default(self):
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        for t in threads:
+            # Ensure that our default name is reasonably sane and unique when
+            # no thread_name_prefix was supplied.
+            self.assertRegex(t.name, r'ThreadPoolExecutor-\d+_[0-4]$')
+            t.join()
+
+    def test_cancel_futures_wait_false(self):
+        # Can only be reliably tested for TPE, since PPE often hangs with
+        # `wait=False` (even without *cancel_futures*).
+        rc, out, err = assert_python_ok('-c', """if True:
+            from concurrent.futures import ThreadPoolExecutor
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                t = ThreadPoolExecutor()
+                t.submit(sleep_and_print, .1, "apple")
+                t.shutdown(wait=False, cancel_futures=True)
+            """)
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertFalse(err)
+        # gh-116682: stdout may be empty if shutdown happens before task
+        # starts executing.
+        self.assertIn(out.strip(), [b"apple", b""])
+
+
+class ProcessPoolShutdownTest(ExecutorShutdownTest):
+    def test_processes_terminate(self):
+        def acquire_lock(lock):
+            lock.acquire()
+
+        mp_context = self.get_context()
+        if mp_context.get_start_method(allow_none=False) == "fork":
+            # fork pre-spawns, not on demand.
+            expected_num_processes = self.worker_count
+        else:
+            expected_num_processes = 3
+
+        sem = mp_context.Semaphore(0)
+        for _ in range(3):
+            self.executor.submit(acquire_lock, sem)
+        self.assertEqual(len(self.executor._processes), expected_num_processes)
+        for _ in range(3):
+            sem.release()
+        processes = self.executor._processes
+        self.executor.shutdown()
+
+        for p in processes.values():
+            p.join()
+
+    def test_context_manager_shutdown(self):
+        with futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context()) as e:
+            processes = e._processes
+            self.assertEqual(list(e.map(abs, range(-5, 5))),
+                             [5, 4, 3, 2, 1, 0, 1, 2, 3, 4])
+
+        for p in processes.values():
+            p.join()
+
+    def test_del_shutdown(self):
+        executor = futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context())
+        res = executor.map(abs, range(-5, 5))
+        executor_manager_thread = executor._executor_manager_thread
+        processes = executor._processes
+        call_queue = executor._call_queue
+        executor_manager_thread = executor._executor_manager_thread
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        # Make sure that all the executor resources were properly cleaned by
+        # the shutdown process
+        executor_manager_thread.join()
+        for p in processes.values():
+            p.join()
+        call_queue.join_thread()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    def test_shutdown_no_wait(self):
+        # Ensure that the executor cleans up the processes when calling
+        # shutdown with wait=False
+        executor = futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context())
+        res = executor.map(abs, range(-5, 5))
+        processes = executor._processes
+        call_queue = executor._call_queue
+        executor_manager_thread = executor._executor_manager_thread
+        executor.shutdown(wait=False)
+
+        # Make sure that all the executor resources were properly cleaned by
+        # the shutdown process
+        executor_manager_thread.join()
+        for p in processes.values():
+            p.join()
+        call_queue.join_thread()
+
+        # Make sure the results were all computed before the executor got
+        # shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    @classmethod
+    def _failing_task_gh_132969(cls, n):
+        raise ValueError("failing task")
+
+    @classmethod
+    def _good_task_gh_132969(cls, n):
+        time.sleep(0.1 * n)
+        return n
+
+    def _run_test_issue_gh_132969(self, max_workers):
+        # max_workers=2 will repro exception
+        # max_workers=4 will repro exception and then hang
+
+        # Repro conditions
+        #   max_tasks_per_child=1
+        #   a task ends abnormally
+        #   shutdown(wait=False) is called
+        start_method = self.get_context().get_start_method()
+        if (start_method == "fork" or
+           (start_method == "forkserver" and sys.platform.startswith("win"))):
+                self.skipTest(f"Skipping test for {start_method = }")
+        executor = futures.ProcessPoolExecutor(
+                max_workers=max_workers,
+                max_tasks_per_child=1,
+                mp_context=self.get_context())
+        f1 = executor.submit(ProcessPoolShutdownTest._good_task_gh_132969, 1)
+        f2 = executor.submit(ProcessPoolShutdownTest._failing_task_gh_132969, 2)
+        f3 = executor.submit(ProcessPoolShutdownTest._good_task_gh_132969, 3)
+        result = 0
+        try:
+            result += f1.result()
+            result += f2.result()
+            result += f3.result()
+        except ValueError:
+            # stop processing results upon first exception
+            pass
+
+        # Ensure that the executor cleans up after called
+        # shutdown with wait=False
+        executor_manager_thread = executor._executor_manager_thread
+        executor.shutdown(wait=False)
+        time.sleep(0.2)
+        executor_manager_thread.join()
+        return result
+
+    def test_shutdown_gh_132969_case_1(self):
+        # gh-132969: test that exception "object of type 'NoneType' has no len()"
+        # is not raised when shutdown(wait=False) is called.
+        result = self._run_test_issue_gh_132969(2)
+        self.assertEqual(result, 1)
+
+    def test_shutdown_gh_132969_case_2(self):
+        # gh-132969: test that process does not hang and
+        # exception "object of type 'NoneType' has no len()" is not raised
+        # when shutdown(wait=False) is called.
+        result = self._run_test_issue_gh_132969(4)
+        self.assertEqual(result, 1)
+
+
+create_executor_tests(globals(), ProcessPoolShutdownTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_thread_pool.py b/Lib/test/test_concurrent_futures/test_thread_pool.py
new file mode 100644
index 00000000000..4a60aff4239
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_thread_pool.py
@@ -0,0 +1,122 @@
+import contextlib
+import multiprocessing as mp
+import multiprocessing.process
+import multiprocessing.util
+import os
+import threading
+import unittest
+from concurrent import futures
+from test import support
+
+from .executor import ExecutorTest, mul
+from .util import BaseTestCase, ThreadPoolMixin, setup_module
+
+
+class ThreadPoolExecutorTest(ThreadPoolMixin, ExecutorTest, BaseTestCase):
+    def test_map_submits_without_iteration(self):
+        """Tests verifying issue 11777."""
+        finished = []
+        def record_finished(n):
+            finished.append(n)
+
+        self.executor.map(record_finished, range(10))
+        self.executor.shutdown(wait=True)
+        self.assertCountEqual(finished, range(10))
+
+    def test_default_workers(self):
+        executor = self.executor_type()
+        expected = min(32, (os.process_cpu_count() or 1) + 4)
+        self.assertEqual(executor._max_workers, expected)
+
+    def test_saturation(self):
+        executor = self.executor_type(4)
+        def acquire_lock(lock):
+            lock.acquire()
+
+        sem = threading.Semaphore(0)
+        for i in range(15 * executor._max_workers):
+            executor.submit(acquire_lock, sem)
+        self.assertEqual(len(executor._threads), executor._max_workers)
+        for i in range(15 * executor._max_workers):
+            sem.release()
+        executor.shutdown(wait=True)
+
+    @support.requires_gil_enabled("gh-117344: test is flaky without the GIL")
+    def test_idle_thread_reuse(self):
+        executor = self.executor_type()
+        executor.submit(mul, 21, 2).result()
+        executor.submit(mul, 6, 7).result()
+        executor.submit(mul, 3, 14).result()
+        self.assertEqual(len(executor._threads), 1)
+        executor.shutdown(wait=True)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
+    @support.requires_resource('cpu')
+    def test_hang_global_shutdown_lock(self):
+        # bpo-45021: _global_shutdown_lock should be reinitialized in the child
+        # process, otherwise it will never exit
+        def submit(pool):
+            pool.submit(submit, pool)
+
+        with futures.ThreadPoolExecutor(1) as pool:
+            pool.submit(submit, pool)
+
+            for _ in range(50):
+                with futures.ProcessPoolExecutor(1, mp_context=mp.get_context('fork')) as workers:
+                    workers.submit(tuple)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
+    @unittest.expectedFailure # TODO: RUSTPYTHON AssertionError: DeprecationWarning not triggered
+    def test_process_fork_from_a_threadpool(self):
+        # bpo-43944: clear concurrent.futures.thread._threads_queues after fork,
+        # otherwise child process will try to join parent thread
+        def fork_process_and_return_exitcode():
+            # Ignore the warning about fork with threads.
+            with self.assertWarnsRegex(DeprecationWarning,
+                                       r"use of fork\(\) may lead to deadlocks in the child"):
+                p = mp.get_context('fork').Process(target=lambda: 1)
+                p.start()
+            p.join()
+            return p.exitcode
+
+        with futures.ThreadPoolExecutor(1) as pool:
+            process_exitcode = pool.submit(fork_process_and_return_exitcode).result()
+
+        self.assertEqual(process_exitcode, 0)
+
+    def test_executor_map_current_future_cancel(self):
+        stop_event = threading.Event()
+        log = []
+
+        def log_n_wait(ident):
+            log.append(f"{ident=} started")
+            try:
+                stop_event.wait()
+            finally:
+                log.append(f"{ident=} stopped")
+
+        with self.executor_type(max_workers=1) as pool:
+            # submit work to saturate the pool
+            fut = pool.submit(log_n_wait, ident="first")
+            try:
+                with contextlib.closing(
+                    pool.map(log_n_wait, ["second", "third"], timeout=0)
+                ) as gen:
+                    with self.assertRaises(TimeoutError):
+                        next(gen)
+            finally:
+                stop_event.set()
+            fut.result()
+        # ident='second' is cancelled as a result of raising a TimeoutError
+        # ident='third' is cancelled because it remained in the collection of futures
+        self.assertListEqual(log, ["ident='first' started", "ident='first' stopped"])
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_wait.py b/Lib/test/test_concurrent_futures/test_wait.py
new file mode 100644
index 00000000000..cc387883141
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_wait.py
@@ -0,0 +1,205 @@
+import sys
+import threading
+import unittest
+from concurrent import futures
+from test import support
+from test.support import threading_helper
+
+from .util import (
+    CANCELLED_FUTURE, CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE,
+    SUCCESSFUL_FUTURE,
+    create_executor_tests, setup_module,
+    BaseTestCase, ThreadPoolMixin,
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin)
+
+
+def mul(x, y):
+    return x * y
+
+def wait_and_raise(e):
+    e.wait()
+    raise Exception('this is an exception')
+
+
+class WaitTests:
+    def test_20369(self):
+        # See https://bugs.python.org/issue20369
+        future = self.executor.submit(mul, 1, 2)
+        done, not_done = futures.wait([future, future],
+                            return_when=futures.ALL_COMPLETED)
+        self.assertEqual({future}, done)
+        self.assertEqual(set(), not_done)
+
+
+    def test_first_completed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(mul, 21, 2)
+        future2 = self.executor.submit(event.wait)
+
+        try:
+            done, not_done = futures.wait(
+                    [CANCELLED_FUTURE, future1, future2],
+                     return_when=futures.FIRST_COMPLETED)
+
+            self.assertEqual(set([future1]), done)
+            self.assertEqual(set([CANCELLED_FUTURE, future2]), not_done)
+        finally:
+            event.set()
+        future2.result()  # wait for job to finish
+
+    def test_first_completed_some_already_completed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                     [CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE, future1],
+                     return_when=futures.FIRST_COMPLETED)
+
+            self.assertEqual(
+                    set([CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE]),
+                    finished)
+            self.assertEqual(set([future1]), pending)
+        finally:
+            event.set()
+        future1.result()  # wait for job to finish
+
+    def test_first_exception(self):
+        event1 = self.create_event()
+        event2 = self.create_event()
+        try:
+            future1 = self.executor.submit(mul, 2, 21)
+            future2 = self.executor.submit(wait_and_raise, event1)
+            future3 = self.executor.submit(event2.wait)
+
+            # Ensure that future1 is completed before future2 finishes
+            def wait_for_future1():
+                future1.result()
+                event1.set()
+
+            t = threading.Thread(target=wait_for_future1)
+            t.start()
+
+            finished, pending = futures.wait(
+                    [future1, future2, future3],
+                    return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([future1, future2]), finished)
+            self.assertEqual(set([future3]), pending)
+
+            threading_helper.join_thread(t)
+        finally:
+            event1.set()
+            event2.set()
+        future3.result()  # wait for job to finish
+
+    def test_first_exception_some_already_complete(self):
+        event = self.create_event()
+        future1 = self.executor.submit(divmod, 21, 0)
+        future2 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                    [SUCCESSFUL_FUTURE,
+                     CANCELLED_FUTURE,
+                     CANCELLED_AND_NOTIFIED_FUTURE,
+                     future1, future2],
+                    return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([SUCCESSFUL_FUTURE,
+                                  CANCELLED_AND_NOTIFIED_FUTURE,
+                                  future1]), finished)
+            self.assertEqual(set([CANCELLED_FUTURE, future2]), pending)
+        finally:
+            event.set()
+        future2.result()  # wait for job to finish
+
+    def test_first_exception_one_already_failed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                     [EXCEPTION_FUTURE, future1],
+                     return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([EXCEPTION_FUTURE]), finished)
+            self.assertEqual(set([future1]), pending)
+        finally:
+            event.set()
+        future1.result()  # wait for job to finish
+
+    def test_all_completed(self):
+        future1 = self.executor.submit(divmod, 2, 0)
+        future2 = self.executor.submit(mul, 2, 21)
+
+        finished, pending = futures.wait(
+                [SUCCESSFUL_FUTURE,
+                 CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 future1,
+                 future2],
+                return_when=futures.ALL_COMPLETED)
+
+        self.assertEqual(set([SUCCESSFUL_FUTURE,
+                              CANCELLED_AND_NOTIFIED_FUTURE,
+                              EXCEPTION_FUTURE,
+                              future1,
+                              future2]), finished)
+        self.assertEqual(set(), pending)
+
+    def test_timeout(self):
+        short_timeout = 0.050
+
+        event = self.create_event()
+        future = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                    [CANCELLED_AND_NOTIFIED_FUTURE,
+                     EXCEPTION_FUTURE,
+                     SUCCESSFUL_FUTURE,
+                     future],
+                    timeout=short_timeout,
+                    return_when=futures.ALL_COMPLETED)
+
+            self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE,
+                                  EXCEPTION_FUTURE,
+                                  SUCCESSFUL_FUTURE]),
+                             finished)
+            self.assertEqual(set([future]), pending)
+        finally:
+            event.set()
+        future.result()  # wait for job to finish
+
+
+class ThreadPoolWaitTests(ThreadPoolMixin, WaitTests, BaseTestCase):
+
+    def test_pending_calls_race(self):
+        # Issue #14406: multi-threaded race condition when waiting on all
+        # futures.
+        event = threading.Event()
+        def future_func():
+            event.wait()
+        oldswitchinterval = sys.getswitchinterval()
+        support.setswitchinterval(1e-6)
+        try:
+            fs = {self.executor.submit(future_func) for i in range(100)}
+            event.set()
+            futures.wait(fs, return_when=futures.ALL_COMPLETED)
+        finally:
+            sys.setswitchinterval(oldswitchinterval)
+
+
+create_executor_tests(globals(), WaitTests,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/util.py b/Lib/test/test_concurrent_futures/util.py
new file mode 100644
index 00000000000..e85ef3b1c91
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/util.py
@@ -0,0 +1,169 @@
+import multiprocessing
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures._base import (
+    PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED, Future,
+    )
+from concurrent.futures.process import _check_system_limits
+
+from test import support
+from test.support import threading_helper
+
+
+def create_future(state=PENDING, exception=None, result=None):
+    f = Future()
+    f._state = state
+    f._exception = exception
+    f._result = result
+    return f
+
+
+PENDING_FUTURE = create_future(state=PENDING)
+RUNNING_FUTURE = create_future(state=RUNNING)
+CANCELLED_FUTURE = create_future(state=CANCELLED)
+CANCELLED_AND_NOTIFIED_FUTURE = create_future(state=CANCELLED_AND_NOTIFIED)
+EXCEPTION_FUTURE = create_future(state=FINISHED, exception=OSError())
+SUCCESSFUL_FUTURE = create_future(state=FINISHED, result=42)
+
+
+class BaseTestCase(unittest.TestCase):
+    def setUp(self):
+        self._thread_key = threading_helper.threading_setup()
+
+    def tearDown(self):
+        support.reap_children()
+        threading_helper.threading_cleanup(*self._thread_key)
+
+
+class ExecutorMixin:
+    worker_count = 5
+    executor_kwargs = {}
+
+    def setUp(self):
+        super().setUp()
+
+        self.t1 = time.monotonic()
+        if hasattr(self, "ctx"):
+            self.executor = self.executor_type(
+                max_workers=self.worker_count,
+                mp_context=self.get_context(),
+                **self.executor_kwargs)
+            self.manager = self.get_context().Manager()
+        else:
+            self.executor = self.executor_type(
+                max_workers=self.worker_count,
+                **self.executor_kwargs)
+            self.manager = None
+
+    def tearDown(self):
+        self.executor.shutdown(wait=True)
+        self.executor = None
+        if self.manager is not None:
+            self.manager.shutdown()
+            self.manager = None
+
+        dt = time.monotonic() - self.t1
+        if support.verbose:
+            print("%.2fs" % dt, end=' ')
+        self.assertLess(dt, 300, "synchronization issue: test lasted too long")
+
+        super().tearDown()
+
+    def get_context(self):
+        return multiprocessing.get_context(self.ctx)
+
+
+class ThreadPoolMixin(ExecutorMixin):
+    executor_type = futures.ThreadPoolExecutor
+
+    def create_event(self):
+        return threading.Event()
+
+
+class ProcessPoolForkMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "fork"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        if sys.platform == "win32":
+            self.skipTest("require unix system")
+        if support.check_sanitizer(thread=True):
+            self.skipTest("TSAN doesn't support threads after fork")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+class ProcessPoolSpawnMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "spawn"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+class ProcessPoolForkserverMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "forkserver"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        if sys.platform == "win32":
+            self.skipTest("require unix system")
+        if support.check_sanitizer(thread=True):
+            self.skipTest("TSAN doesn't support threads after fork")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+def create_executor_tests(remote_globals, mixin, bases=(BaseTestCase,),
+                          executor_mixins=(ThreadPoolMixin,
+                                           ProcessPoolForkMixin,
+                                           ProcessPoolForkserverMixin,
+                                           ProcessPoolSpawnMixin)):
+    def strip_mixin(name):
+        if name.endswith(('Mixin', 'Tests')):
+            return name[:-5]
+        elif name.endswith('Test'):
+            return name[:-4]
+        else:
+            return name
+
+    module = remote_globals['__name__']
+    for exe in executor_mixins:
+        name = ("%s%sTest"
+                % (strip_mixin(exe.__name__), strip_mixin(mixin.__name__)))
+        cls = type(name, (mixin,) + (exe,) + bases, {'__module__': module})
+        remote_globals[name] = cls
+
+
+def setup_module():
+    try:
+        _check_system_limits()
+    except NotImplementedError:
+        pass
+    else:
+        unittest.addModuleCleanup(multiprocessing.util._cleanup_tests)
+
+    thread_info = threading_helper.threading_setup()
+    unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)

From 83a0deac25360cbce36b2bb2237deb687dee17ea Mon Sep 17 00:00:00 2001
From: HueCodes <197298026+HueCodes@users.noreply.github.com>
Date: Fri, 9 Jan 2026 04:31:21 -0800
Subject: [PATCH 197/418] Fix set in-place operators with self argument (#6661)

Co-authored-by: Hugh <HueCodes@users.noreply.github.com>
---
 crates/vm/src/builtins/set.rs       | 30 +++++++++++++++++++++++------
 extra_tests/snippets/builtin_set.py | 12 ++++++++++++
 2 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
index 1c0268e2ed7..c3473809734 100644
--- a/crates/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -24,6 +24,7 @@ use crate::{
     vm::VirtualMachine,
 };
 use alloc::fmt;
+use core::borrow::Borrow;
 use core::ops::Deref;
 use rustpython_common::{
     atomic::{Ordering, PyAtomic, Radium},
@@ -719,8 +720,10 @@ impl PySet {
     }
 
     fn __iand__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .intersection_update(core::iter::once(set.into_iterable(vm)?), vm)?;
+        if !set.is(zelf.as_object()) {
+            zelf.inner
+                .intersection_update(core::iter::once(set.into_iterable(vm)?), vm)?;
+        }
         Ok(zelf)
     }
 
@@ -731,8 +734,12 @@ impl PySet {
     }
 
     fn __isub__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .difference_update(set.into_iterable_iter(vm)?, vm)?;
+        if set.is(zelf.as_object()) {
+            zelf.inner.clear();
+        } else {
+            zelf.inner
+                .difference_update(set.into_iterable_iter(vm)?, vm)?;
+        }
         Ok(zelf)
     }
 
@@ -748,8 +755,12 @@ impl PySet {
     }
 
     fn __ixor__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .symmetric_difference_update(set.into_iterable_iter(vm)?, vm)?;
+        if set.is(zelf.as_object()) {
+            zelf.inner.clear();
+        } else {
+            zelf.inner
+                .symmetric_difference_update(set.into_iterable_iter(vm)?, vm)?;
+        }
         Ok(zelf)
     }
 
@@ -1297,6 +1308,13 @@ struct AnySet {
     object: PyObjectRef,
 }
 
+impl Borrow<PyObject> for AnySet {
+    #[inline(always)]
+    fn borrow(&self) -> &PyObject {
+        &self.object
+    }
+}
+
 impl AnySet {
     /// Check if object is a set or frozenset (including subclasses)
     /// Equivalent to CPython's PyAnySet_Check
diff --git a/extra_tests/snippets/builtin_set.py b/extra_tests/snippets/builtin_set.py
index 1b2f6ff0968..950875ea09a 100644
--- a/extra_tests/snippets/builtin_set.py
+++ b/extra_tests/snippets/builtin_set.py
@@ -200,6 +200,18 @@ class S(set):
 with assert_raises(TypeError):
     a &= [1, 2, 3]
 
+a = set([1, 2, 3])
+a &= a
+assert a == set([1, 2, 3])
+
+a = set([1, 2, 3])
+a -= a
+assert a == set()
+
+a = set([1, 2, 3])
+a ^= a
+assert a == set()
+
 a = set([1, 2, 3])
 a.difference_update([3, 4, 5])
 assert a == set([1, 2])

From c2bfdf30bd32a093f12ac61b486aaf298514e4b2 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 9 Jan 2026 15:52:47 +0200
Subject: [PATCH 198/418] Assign opcode ids (#6637)

---
 Lib/_opcode_metadata.py              |  47 +-
 Lib/test/test__opcode.py             |   1 +
 Lib/test/test_dis.py                 |   1 +
 crates/codegen/src/compile.rs        | 152 +++----
 crates/compiler-core/src/bytecode.rs | 616 +++++++++------------------
 crates/jit/src/instructions.rs       |   4 +-
 crates/jit/tests/common.rs           |   4 +-
 crates/stdlib/src/opcode.rs          |   8 +-
 crates/vm/src/frame.rs               |  72 +---
 scripts/generate_opcode_metadata.py  | 271 +++---------
 10 files changed, 384 insertions(+), 792 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 0d6b7f1109e..529f5cbf656 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -10,7 +10,7 @@
     'CACHE': 0,
     'BEFORE_ASYNC_WITH': 1,
     'BEFORE_WITH': 2,
-    'RESERVED_3': 3,
+    'BINARY_OP_INPLACE_ADD_UNICODE': 3,
     'BINARY_SLICE': 4,
     'BINARY_SUBSCR': 5,
     'CHECK_EG_MATCH': 6,
@@ -24,7 +24,7 @@
     'FORMAT_SIMPLE': 14,
     'FORMAT_WITH_SPEC': 15,
     'GET_AITER': 16,
-    'RESERVED_17': 17,
+    'RESERVED': 17,
     'GET_ANEXT': 18,
     'GET_ITER': 19,
     'GET_LEN': 20,
@@ -127,36 +127,27 @@
     'UNPACK_SEQUENCE': 117,
     'YIELD_VALUE': 118,
     'BREAK': 119,
-    'BUILD_LIST_UNPACK': 120,
+    'BUILD_LIST_FROM_TUPLES': 120,
     'BUILD_MAP_FOR_CALL': 121,
-    'BUILD_SET_UNPACK': 122,
-    'BUILD_TUPLE_ITER': 123,
-    'BUILD_TUPLE_UNPACK': 124,
-    'CALL_METHOD': 125,
-    'CALL_METHOD_KW': 126,
+    'BUILD_SET_FROM_TUPLES': 122,
+    'BUILD_TUPLE_FROM_ITER': 123,
+    'BUILD_TUPLE_FROM_TUPLES': 124,
+    'CALL_METHOD_POSITIONAL': 125,
+    'CALL_METHOD_KEYWORD': 126,
     'CALL_METHOD_EX': 127,
     'CONTINUE': 128,
-    'JUMP': 129,
-    'JUMP_IF_FALSE_OR_POP': 130,
-    'JUMP_IF_TRUE_OR_POP': 131,
-    'JUMP_IF_NOT_EXC_MATCH': 132,
-    'LOAD_CLASSDEREF': 133,
-    'LOAD_CLOSURE': 134,
-    'LOAD_METHOD': 135,
-    'POP_BLOCK': 136,
-    'REVERSE': 137,
-    'SET_EXC_INFO': 138,
-    'SUBSCRIPT': 139,
-    'UNARY_OP': 140,
-    'RESERVED_141': 141,
-    'RESERVED_142': 142,
-    'RESERVED_143': 143,
-    'RESERVED_144': 144,
-    'RESERVED_145': 145,
-    'RESERVED_146': 146,
-    'RESERVED_147': 147,
-    'RESERVED_148': 148,
+    'JUMP_IF_FALSE_OR_POP': 129,
+    'JUMP_IF_TRUE_OR_POP': 130,
+    'JUMP_IF_NOT_EXC_MATCH': 131,
+    'LOAD_CLASS_DEREF': 132,
+    'REVERSE': 133,
+    'SET_EXC_INFO': 134,
+    'SUBSCRIPT': 135,
     'RESUME': 149,
+    'JUMP': 252,
+    'LOAD_CLOSURE': 253,
+    'LOAD_METHOD': 254,
+    'POP_BLOCK': 255,
 }
 
 # CPython 3.13 compatible: opcodes < 44 have no argument
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index 60dcdc6cd70..dabe95f7167 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -16,6 +16,7 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Only supporting u8 ATM
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index eddfc155619..9526bdcbbaa 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -937,6 +937,7 @@ def test_opname(self):
     def test_boundaries(self):
         self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 29 not less than or equal to 20
     def test_widths(self):
         long_opcodes = set(['JUMP_BACKWARD_NO_INTERRUPT',
                             'INSTRUMENTED_CALL_FUNCTION_EX'])
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 7a6fdc87b26..f61b01a43ec 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -494,7 +494,7 @@ impl Compiler {
                 }
                 ExprContext::Store => {
                     emit!(self, Instruction::BuildSlice { argc });
-                    emit!(self, Instruction::StoreSubscript);
+                    emit!(self, Instruction::StoreSubscr);
                 }
                 _ => unreachable!(),
             }
@@ -505,8 +505,8 @@ impl Compiler {
             // Emit appropriate instruction based on context
             match ctx {
                 ExprContext::Load => emit!(self, Instruction::Subscript),
-                ExprContext::Store => emit!(self, Instruction::StoreSubscript),
-                ExprContext::Del => emit!(self, Instruction::DeleteSubscript),
+                ExprContext::Store => emit!(self, Instruction::StoreSubscr),
+                ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
                 ExprContext::Invalid => {
                     return Err(self.error(CodegenErrorType::SyntaxError(
                         "Invalid expression context".to_owned(),
@@ -1013,7 +1013,7 @@ impl Compiler {
                 // Stack when in FinallyEnd: [..., prev_exc, exc] or
                 // [..., prev_exc, exc, return_value] if preserve_tos
                 // Note: No lasti here - it's only pushed for cleanup handler exceptions
-                // We need to pop: exc, prev_exc (via PopException)
+                // We need to pop: exc, prev_exc (via PopExcept)
                 if preserve_tos {
                     emit!(self, Instruction::Swap { index: 2 });
                 }
@@ -1021,7 +1021,7 @@ impl Compiler {
                 if preserve_tos {
                     emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopException); // prev_exc is restored
+                emit!(self, Instruction::PopExcept); // prev_exc is restored
             }
 
             FBlockType::With | FBlockType::AsyncWith => {
@@ -1040,7 +1040,7 @@ impl Compiler {
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+                emit!(self, Instruction::Call { nargs: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
@@ -1057,7 +1057,7 @@ impl Compiler {
                 if preserve_tos {
                     emit!(self, Instruction::Swap { index: 2 });
                 }
-                emit!(self, Instruction::PopException);
+                emit!(self, Instruction::PopExcept);
 
                 // If there's an exception name, clean it up
                 if let FBlockDatum::ExceptionName(ref name) = info.fb_datum {
@@ -1342,7 +1342,7 @@ impl Compiler {
         }
 
         if Self::find_ann(statements) {
-            emit!(self, Instruction::SetupAnnotation);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         self.compile_statements(statements)?;
@@ -1362,7 +1362,7 @@ impl Compiler {
         self.symbol_table_stack.push(symbol_table);
 
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotation);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         if let Some((last, body)) = body.split_last() {
@@ -1594,9 +1594,9 @@ impl Compiler {
             NameOp::Name => {
                 let idx = self.get_global_name_index(&name);
                 let op = match usage {
-                    NameUsage::Load => Instruction::LoadNameAny,
-                    NameUsage::Store => Instruction::StoreLocal,
-                    NameUsage::Delete => Instruction::DeleteLocal,
+                    NameUsage::Load => Instruction::LoadName,
+                    NameUsage::Store => Instruction::StoreName,
+                    NameUsage::Delete => Instruction::DeleteName,
                 };
                 self.emit_arg(idx, op);
             }
@@ -1815,7 +1815,7 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, Instruction::Raise { kind });
+                emit!(self, Instruction::RaiseVarargs { kind });
             }
             Stmt::Try(StmtTry {
                 body,
@@ -1878,15 +1878,15 @@ impl Compiler {
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+                            emit!(self, Instruction::Call { nargs: 1 });
                         }
                         None => {
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+                            emit!(self, Instruction::Call { nargs: 0 });
                         }
                     }
                     emit!(
                         self,
-                        Instruction::Raise {
+                        Instruction::RaiseVarargs {
                             kind: bytecode::RaiseKind::Raise,
                         }
                     );
@@ -2102,7 +2102,7 @@ impl Compiler {
     fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
         // Apply decorators:
         for _ in decorator_list {
-            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+            emit!(self, Instruction::Call { nargs: 1 });
         }
     }
 
@@ -2144,7 +2144,7 @@ impl Compiler {
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
 
         // Call the function immediately
-        emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+        emit!(self, Instruction::Call { nargs: 0 });
 
         Ok(())
     }
@@ -2379,7 +2379,7 @@ impl Compiler {
                 // which then properly restores prev_exc before going to outer handler
                 emit!(
                     self,
-                    Instruction::Raise {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2391,10 +2391,10 @@ impl Compiler {
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
                 emit!(self, Instruction::CopyItem { index: 3_u32 });
-                emit!(self, Instruction::PopException);
+                emit!(self, Instruction::PopExcept);
                 emit!(
                     self,
-                    Instruction::Raise {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
@@ -2439,7 +2439,7 @@ impl Compiler {
         )?;
 
         // Exception is on top of stack now, pushed by unwind_blocks
-        // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopException
+        // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
         emit!(self, Instruction::PushExcInfo);
         for handler in handlers {
             let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
@@ -2524,7 +2524,7 @@ impl Compiler {
                 // which does COPY 3; POP_EXCEPT; RERAISE
                 emit!(
                     self,
-                    Instruction::Raise {
+                    Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack,
                     }
                 );
@@ -2537,7 +2537,7 @@ impl Compiler {
             // POP_BLOCK (HandlerCleanup) then POP_BLOCK (SETUP_CLEANUP)
             // followed by POP_EXCEPT
             self.pop_fblock(FBlockType::ExceptionHandler);
-            emit!(self, Instruction::PopException);
+            emit!(self, Instruction::PopExcept);
 
             // Delete the exception variable if it was bound (normal path)
             if let Some(alias) = name {
@@ -2577,7 +2577,7 @@ impl Compiler {
         // NOTE: We emit RERAISE 0 BEFORE popping fblock so it is within cleanup handler scope
         emit!(
             self,
-            Instruction::Raise {
+            Instruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2593,10 +2593,10 @@ impl Compiler {
         // RERAISE 1: reraise with lasti
         self.switch_to_block(cleanup_block);
         emit!(self, Instruction::CopyItem { index: 3_u32 });
-        emit!(self, Instruction::PopException);
+        emit!(self, Instruction::PopExcept);
         emit!(
             self,
-            Instruction::Raise {
+            Instruction::RaiseVarargs {
                 kind: bytecode::RaiseKind::ReraiseFromStack,
             }
         );
@@ -2671,7 +2671,7 @@ impl Compiler {
             // Stack: [lasti, prev_exc, exc] - exception is on top
             emit!(
                 self,
-                Instruction::Raise {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2689,11 +2689,11 @@ impl Compiler {
             // COPY 3: copy the exception from position 3
             emit!(self, Instruction::CopyItem { index: 3_u32 });
             // POP_EXCEPT: restore prev_exc as current exception
-            emit!(self, Instruction::PopException);
+            emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
             emit!(
                 self,
-                Instruction::Raise {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
@@ -2962,7 +2962,7 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us with exception tables (fblocks handle this)
         // POP_EXCEPT - restore previous exception context
-        emit!(self, Instruction::PopException);
+        emit!(self, Instruction::PopExcept);
         // Stack: []
 
         if !finalbody.is_empty() {
@@ -2981,7 +2981,7 @@ impl Compiler {
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
-        emit!(self, Instruction::PopException);
+        emit!(self, Instruction::PopExcept);
         // Stack: [result]
 
         // RERAISE 0
@@ -3317,13 +3317,13 @@ impl Compiler {
                 );
                 emit!(
                     self,
-                    Instruction::CallFunctionPositional {
+                    Instruction::Call {
                         nargs: num_typeparam_args as u32
                     }
                 );
             } else {
                 // No arguments, just call the closure
-                emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+                emit!(self, Instruction::Call { nargs: 0 });
             }
         }
 
@@ -3561,20 +3561,20 @@ impl Compiler {
         let dunder_name = self.name("__name__");
         emit!(self, Instruction::LoadGlobal(dunder_name));
         let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreLocal(dunder_module));
+        emit!(self, Instruction::StoreName(dunder_module));
 
         // Store __qualname__
         self.emit_load_const(ConstantData::Str {
             value: qualname.into(),
         });
         let qualname_name = self.name("__qualname__");
-        emit!(self, Instruction::StoreLocal(qualname_name));
+        emit!(self, Instruction::StoreName(qualname_name));
 
         // Store __doc__ only if there's an explicit docstring
         if let Some(doc) = doc_str {
             self.emit_load_const(ConstantData::Str { value: doc.into() });
             let doc_name = self.name("__doc__");
-            emit!(self, Instruction::StoreLocal(doc_name));
+            emit!(self, Instruction::StoreName(doc_name));
         }
 
         // Store __firstlineno__ (new in Python 3.12+)
@@ -3582,22 +3582,22 @@ impl Compiler {
             value: BigInt::from(firstlineno),
         });
         let firstlineno_name = self.name("__firstlineno__");
-        emit!(self, Instruction::StoreLocal(firstlineno_name));
+        emit!(self, Instruction::StoreName(firstlineno_name));
 
         // Set __type_params__ if we have type parameters
         if type_params.is_some() {
             // Load .type_params from enclosing scope
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::LoadNameAny(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreLocal(dunder_type_params));
+            emit!(self, Instruction::StoreName(dunder_type_params));
         }
 
         // Setup annotations if needed
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotation);
+            emit!(self, Instruction::SetupAnnotations);
         }
 
         // 3. Compile the class body
@@ -3617,7 +3617,7 @@ impl Compiler {
             emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
             emit!(self, Instruction::CopyItem { index: 1_u32 });
             let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreLocal(classcell));
+            emit!(self, Instruction::StoreName(classcell));
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -3659,7 +3659,7 @@ impl Compiler {
             // Compile type parameters and store as .type_params
             self.compile_type_params(type_params.unwrap())?;
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::StoreLocal(dot_type_params));
+            emit!(self, Instruction::StoreName(dot_type_params));
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -3680,21 +3680,21 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, Instruction::LoadNameAny(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
             emit!(
                 self,
                 Instruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, Instruction::StoreLocal(dot_generic_base));
+            emit!(self, Instruction::StoreName(dot_generic_base));
 
             // Generate class creation code
             emit!(self, Instruction::LoadBuildClass);
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
-            emit!(self, Instruction::LoadNameAny(dot_type_params));
+            emit!(self, Instruction::LoadName(dot_type_params));
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
 
             // Create class function with closure
@@ -3712,7 +3712,7 @@ impl Compiler {
             };
 
             // Load .generic_base as the last base
-            emit!(self, Instruction::LoadNameAny(dot_generic_base));
+            emit!(self, Instruction::LoadName(dot_generic_base));
 
             let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1; // function, name, bases..., generic_base
 
@@ -3730,14 +3730,14 @@ impl Compiler {
                 }
                 emit!(
                     self,
-                    Instruction::CallFunctionKeyword {
+                    Instruction::CallKw {
                         nargs: nargs
                             + u32::try_from(arguments.keywords.len())
                                 .expect("too many keyword arguments")
                     }
                 );
             } else {
-                emit!(self, Instruction::CallFunctionPositional { nargs });
+                emit!(self, Instruction::Call { nargs });
             }
 
             // Return the created class
@@ -3748,7 +3748,7 @@ impl Compiler {
 
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
-            emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
+            emit!(self, Instruction::Call { nargs: 0 });
         } else {
             // Non-generic class: standard path
             emit!(self, Instruction::LoadBuildClass);
@@ -3915,7 +3915,7 @@ impl Compiler {
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+        emit!(self, Instruction::Call { nargs: 3 });
         if is_async {
             emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
@@ -3991,7 +3991,7 @@ impl Compiler {
         // Need to pop: True, exc, prev_exc, __exit__
         self.switch_to_block(suppress_block);
         emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
-        emit!(self, Instruction::PopException); // pop exc and restore prev_exc
+        emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
         emit!(self, Instruction::PopTop); // pop __exit__
         emit!(self, Instruction::PopTop); // pop lasti
         emit!(
@@ -4013,7 +4013,7 @@ impl Compiler {
         // If we cleared fblock, exceptions here would propagate uncaught.
         self.switch_to_block(cleanup_block);
         emit!(self, Instruction::CopyItem { index: 3 });
-        emit!(self, Instruction::PopException);
+        emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
         // ===== After block =====
@@ -4335,7 +4335,7 @@ impl Compiler {
                 );
             }
             // Use BINARY_OP/NB_SUBSCR to extract the element.
-            emit!(self, Instruction::BinarySubscript);
+            emit!(self, Instruction::BinarySubscr);
             // Compile the subpattern in irrefutable mode.
             self.compile_pattern_subpattern(pattern, pc)?;
         }
@@ -4588,7 +4588,7 @@ impl Compiler {
             // Stack: [subject, len, size]
             emit!(
                 self,
-                Instruction::CompareOperation {
+                Instruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -4714,7 +4714,7 @@ impl Compiler {
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
                 emit!(self, Instruction::Swap { index: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
-                emit!(self, Instruction::DeleteSubscript);
+                emit!(self, Instruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
                 remaining -= 1;
             }
@@ -4892,7 +4892,7 @@ impl Compiler {
             self.emit_load_const(ConstantData::Integer { value: size.into() });
             emit!(
                 self,
-                Instruction::CompareOperation {
+                Instruction::CompareOp {
                     op: ComparisonOperator::Equal
                 }
             );
@@ -4905,7 +4905,7 @@ impl Compiler {
             });
             emit!(
                 self,
-                Instruction::CompareOperation {
+                Instruction::CompareOp {
                     op: ComparisonOperator::GreaterOrEqual
                 }
             );
@@ -4934,7 +4934,7 @@ impl Compiler {
         self.compile_expression(&p.value)?;
         emit!(
             self,
-            Instruction::CompareOperation {
+            Instruction::CompareOp {
                 op: bytecode::ComparisonOperator::Equal
             }
         );
@@ -5078,13 +5078,13 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            CmpOp::Eq => emit!(self, Instruction::CompareOperation { op: Equal }),
-            CmpOp::NotEq => emit!(self, Instruction::CompareOperation { op: NotEqual }),
-            CmpOp::Lt => emit!(self, Instruction::CompareOperation { op: Less }),
-            CmpOp::LtE => emit!(self, Instruction::CompareOperation { op: LessOrEqual }),
-            CmpOp::Gt => emit!(self, Instruction::CompareOperation { op: Greater }),
+            CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
+            CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
+            CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
+            CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
             CmpOp::GtE => {
-                emit!(self, Instruction::CompareOperation { op: GreaterOrEqual })
+                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
             }
             CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
             CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
@@ -5219,11 +5219,11 @@ impl Compiler {
         if let Expr::Name(ExprName { id, .. }) = &target {
             // Store as dict entry in __annotations__ dict:
             let annotations = self.name("__annotations__");
-            emit!(self, Instruction::LoadNameAny(annotations));
+            emit!(self, Instruction::LoadName(annotations));
             self.emit_load_const(ConstantData::Str {
                 value: self.mangle(id.as_str()).into_owned().into(),
             });
-            emit!(self, Instruction::StoreSubscript);
+            emit!(self, Instruction::StoreSubscr);
         } else {
             // Drop annotation if not assigned to simple identifier.
             emit!(self, Instruction::PopTop);
@@ -5360,7 +5360,7 @@ impl Compiler {
                 // stack: CONTAINER SLICE RESULT
                 emit!(self, Instruction::Swap { index: 3 });
                 emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreSubscript);
+                emit!(self, Instruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
@@ -6108,9 +6108,9 @@ impl Compiler {
     fn compile_normal_call(&mut self, ty: CallType) {
         match ty {
             CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallFunctionPositional { nargs })
+                emit!(self, Instruction::Call { nargs })
             }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallFunctionKeyword { nargs }),
+            CallType::Keyword { nargs } => emit!(self, Instruction::CallKw { nargs }),
             CallType::Ex { has_kwargs } => emit!(self, Instruction::CallFunctionEx { has_kwargs }),
         }
     }
@@ -6422,7 +6422,7 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
+        emit!(self, Instruction::Call { nargs: 1 });
         if is_async_list_set_dict_comprehension {
             emit!(self, Instruction::GetAwaitable);
             self.emit_load_const(ConstantData::None);
@@ -6622,7 +6622,7 @@ impl Compiler {
             // Re-raise the exception
             emit!(
                 self,
-                Instruction::Raise {
+                Instruction::RaiseVarargs {
                     kind: bytecode::RaiseKind::ReraiseFromStack
                 }
             );
@@ -6841,7 +6841,7 @@ impl Compiler {
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
-                    emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
+                    emit!(self, Instruction::Call { nargs: 3 });
 
                     if is_async {
                         emit!(self, Instruction::GetAwaitable);
@@ -6852,7 +6852,7 @@ impl Compiler {
                     emit!(self, Instruction::PopTop);
                 }
                 UnwindAction::HandlerCleanup => {
-                    emit!(self, Instruction::PopException);
+                    emit!(self, Instruction::PopExcept);
                 }
                 UnwindAction::FinallyTry { body, fblock_idx } => {
                     // compile finally body inline
@@ -6871,9 +6871,9 @@ impl Compiler {
                 UnwindAction::FinallyEnd => {
                     // Stack when in FinallyEnd: [..., prev_exc, exc]
                     // Note: No lasti here - it's only pushed for cleanup handler exceptions
-                    // We need to pop: exc, prev_exc (via PopException)
+                    // We need to pop: exc, prev_exc (via PopExcept)
                     emit!(self, Instruction::PopTop); // exc
-                    emit!(self, Instruction::PopException); // prev_exc is restored
+                    emit!(self, Instruction::PopExcept); // prev_exc is restored
                 }
                 UnwindAction::PopValue => {
                     // Pop the return value - continue/break cancels the pending return
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index dc61e3b9b5a..19380be4713 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -676,441 +676,287 @@ pub type NameIdx = u32;
 #[repr(u8)]
 pub enum Instruction {
     // ==================== No-argument instructions (opcode < 44) ====================
-    // 0: CACHE - placeholder for inline cache (not executed)
-    Cache,
-    // 1: BEFORE_ASYNC_WITH
-    BeforeAsyncWith,
-    // 2: BEFORE_WITH
-    BeforeWith,
-    // 3: Reserved (BINARY_OP_INPLACE_ADD_UNICODE in CPython)
-    Reserved3,
-    // 4: BINARY_SLICE - not implemented, placeholder
-    BinarySlice,
-    // 5: BINARY_SUBSCR
-    BinarySubscript,
-    // 6: CHECK_EG_MATCH
-    CheckEgMatch,
-    // 7: CHECK_EXC_MATCH
-    CheckExcMatch,
-    // 8: CLEANUP_THROW
-    CleanupThrow,
-    // 9: DELETE_SUBSCR
-    DeleteSubscript,
-    // 10: END_ASYNC_FOR
-    EndAsyncFor,
-    // 11: END_FOR - not implemented, placeholder
-    EndFor,
-    // 12: END_SEND
-    EndSend,
-    // 13: EXIT_INIT_CHECK - not implemented, placeholder
-    ExitInitCheck,
-    // 14: FORMAT_SIMPLE
-    FormatSimple,
-    // 15: FORMAT_WITH_SPEC
-    FormatWithSpec,
-    // 16: GET_AITER
-    GetAIter,
-    // 17: RESERVED
-    Reserved17,
-    // 18: GET_ANEXT
-    GetANext,
-    // 19: GET_ITER
-    GetIter,
-    // 20: GET_LEN
-    GetLen,
-    // 21: GET_YIELD_FROM_ITER - not implemented, placeholder
-    GetYieldFromIter,
-    // 22: INTERPRETER_EXIT - not implemented, placeholder
-    InterpreterExit,
-    // 23: LOAD_ASSERTION_ERROR - not implemented, placeholder
-    LoadAssertionError,
-    // 24: LOAD_BUILD_CLASS
-    LoadBuildClass,
-    // 25: LOAD_LOCALS - not implemented, placeholder
-    LoadLocals,
-    // 26: MAKE_FUNCTION
-    MakeFunction,
-    // 27: MATCH_KEYS
-    MatchKeys,
-    // 28: MATCH_MAPPING
-    MatchMapping,
-    // 29: MATCH_SEQUENCE
-    MatchSequence,
-    // 30: NOP
-    Nop,
-    // 31: POP_EXCEPT
-    PopException,
-    // 32: POP_TOP
-    PopTop,
-    // 33: PUSH_EXC_INFO
-    PushExcInfo,
-    // 34: PUSH_NULL - not implemented, placeholder
-    PushNull,
-    // 35: RETURN_GENERATOR - not implemented, placeholder
-    ReturnGenerator,
-    // 36: RETURN_VALUE
-    ReturnValue,
-    // 37: SETUP_ANNOTATIONS
-    SetupAnnotation,
-    // 38: STORE_SLICE - not implemented, placeholder
-    StoreSlice,
-    // 39: STORE_SUBSCR
-    StoreSubscript,
-    // 40: TO_BOOL
-    ToBool,
-    // 41: UNARY_INVERT
-    UnaryInvert,
-    // 42: UNARY_NEGATIVE
-    UnaryNegative,
-    // 43: UNARY_NOT
-    UnaryNot,
-    // ==================== With-argument instructions (opcode >= 44) ====================
-    // 44: WITH_EXCEPT_START
-    WithExceptStart,
-    // 45: BINARY_OP
+    Cache = 0, // Placeholder
+    BeforeAsyncWith = 1,
+    BeforeWith = 2,
+    BinaryOpInplaceAddUnicode = 3, // Placeholder
+    BinarySlice = 4,               // Placeholder
+    BinarySubscr = 5,
+    CheckEgMatch = 6,
+    CheckExcMatch = 7,
+    CleanupThrow = 8,
+    DeleteSubscr = 9,
+    EndAsyncFor = 10,
+    EndFor = 11, // Placeholder
+    EndSend = 12,
+    ExitInitCheck = 13, // Placeholder
+    FormatSimple = 14,
+    FormatWithSpec = 15,
+    GetAIter = 16,
+    Reserved = 17,
+    GetANext = 18,
+    GetIter = 19,
+    GetLen = 20,
+    GetYieldFromIter = 21,
+    InterpreterExit = 22,    // Placeholder
+    LoadAssertionError = 23, // Placeholder
+    LoadBuildClass = 24,
+    LoadLocals = 25, // Placeholder
+    MakeFunction = 26,
+    MatchKeys = 27,
+    MatchMapping = 28,
+    MatchSequence = 29,
+    Nop = 30,
+    PopExcept = 31,
+    PopTop = 32,
+    PushExcInfo = 33,
+    PushNull = 34,        // Placeholder
+    ReturnGenerator = 35, // Placeholder
+    ReturnValue = 36,
+    SetupAnnotations = 37,
+    StoreSlice = 38, // Placeholder
+    StoreSubscr = 39,
+    ToBool = 40,
+    UnaryInvert = 41,
+    UnaryNegative = 42,
+    UnaryNot = 43,
+    WithExceptStart = 44,
+    // ==================== With-argument instructions (opcode > 44) ====================
     BinaryOp {
         op: Arg<BinaryOperator>,
-    },
-    // 46: BUILD_CONST_KEY_MAP - not implemented, placeholder
+    } = 45,
     BuildConstKeyMap {
         size: Arg<u32>,
-    },
-    // 47: BUILD_LIST
+    } = 46, // Placeholder
     BuildList {
         size: Arg<u32>,
-    },
-    // 48: BUILD_MAP
+    } = 47,
     BuildMap {
         size: Arg<u32>,
-    },
-    // 49: BUILD_SET
+    } = 48,
     BuildSet {
         size: Arg<u32>,
-    },
-    // 50: BUILD_SLICE
+    } = 49,
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
-    },
-    // 51: BUILD_STRING
+    } = 50,
     BuildString {
         size: Arg<u32>,
-    },
-    // 52: BUILD_TUPLE
+    } = 51,
     BuildTuple {
         size: Arg<u32>,
-    },
-    // 53: CALL
-    CallFunctionPositional {
+    } = 52,
+    Call {
         nargs: Arg<u32>,
-    },
-    // 54: CALL_FUNCTION_EX
+    } = 53,
     CallFunctionEx {
         has_kwargs: Arg<bool>,
-    },
-    // 55: CALL_INTRINSIC_1
+    } = 54,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
-    },
-    // 56: CALL_INTRINSIC_2
+    } = 55,
     CallIntrinsic2 {
         func: Arg<IntrinsicFunction2>,
-    },
-    // 57: CALL_KW
-    CallFunctionKeyword {
+    } = 56,
+    CallKw {
         nargs: Arg<u32>,
-    },
-    // 58: COMPARE_OP
-    CompareOperation {
+    } = 57,
+    CompareOp {
         op: Arg<ComparisonOperator>,
-    },
-    // 59: CONTAINS_OP
-    ContainsOp(Arg<Invert>),
-    // 60: CONVERT_VALUE
+    } = 58,
+    ContainsOp(Arg<Invert>) = 59,
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
-    },
-    // 61: COPY
+    } = 60,
     CopyItem {
         index: Arg<u32>,
-    },
-    // 62: COPY_FREE_VARS - not implemented, placeholder
+    } = 61,
     CopyFreeVars {
         count: Arg<u32>,
-    },
-    // 63: DELETE_ATTR
+    } = 62, // Placeholder
     DeleteAttr {
         idx: Arg<NameIdx>,
-    },
-    // 64: DELETE_DEREF
-    DeleteDeref(Arg<NameIdx>),
-    // 65: DELETE_FAST
-    DeleteFast(Arg<NameIdx>),
-    // 66: DELETE_GLOBAL
-    DeleteGlobal(Arg<NameIdx>),
-    // 67: DELETE_NAME
-    DeleteLocal(Arg<NameIdx>),
-    // 68: DICT_MERGE - not implemented, placeholder
+    } = 63,
+    DeleteDeref(Arg<NameIdx>) = 64,
+    DeleteFast(Arg<NameIdx>) = 65,
+    DeleteGlobal(Arg<NameIdx>) = 66,
+    DeleteName(Arg<NameIdx>) = 67,
     DictMerge {
         index: Arg<u32>,
-    },
-    // 69: DICT_UPDATE
+    } = 68, // Placeholder
     DictUpdate {
         index: Arg<u32>,
-    },
-    // 70: ENTER_EXECUTOR - not implemented, placeholder
-    EnterExecutor {
-        index: Arg<u32>,
-    },
-    // 71: EXTENDED_ARG
-    ExtendedArg,
-    // 72: FOR_ITER
+    } = 69,
+    EnterExecutor = 70, // Placeholder
+    ExtendedArg = 71,
     ForIter {
         target: Arg<Label>,
-    },
-    // 73: GET_AWAITABLE
-    GetAwaitable,
-    // 74: IMPORT_FROM
+    } = 72,
+    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
     ImportFrom {
         idx: Arg<NameIdx>,
-    },
-    // 75: IMPORT_NAME
+    } = 74,
     ImportName {
         idx: Arg<NameIdx>,
-    },
-    // 76: IS_OP
-    IsOp(Arg<Invert>),
-    // 77: JUMP_BACKWARD - not implemented, placeholder
+    } = 75,
+    IsOp(Arg<Invert>) = 76,
     JumpBackward {
         target: Arg<Label>,
-    },
-    // 78: JUMP_BACKWARD_NO_INTERRUPT - not implemented, placeholder
+    } = 77, // Placeholder
     JumpBackwardNoInterrupt {
         target: Arg<Label>,
-    },
-    // 79: JUMP_FORWARD - not implemented, placeholder
+    } = 78, // Placeholder
     JumpForward {
         target: Arg<Label>,
-    },
-    // 80: LIST_APPEND
+    } = 79, // Placeholder
     ListAppend {
         i: Arg<u32>,
-    },
-    // 81: LIST_EXTEND - not implemented, placeholder
+    } = 80,
     ListExtend {
         i: Arg<u32>,
-    },
-    // 82: LOAD_ATTR
+    } = 81, // Placeholder
     LoadAttr {
         idx: Arg<NameIdx>,
-    },
-    // 83: LOAD_CONST
+    } = 82,
     LoadConst {
         idx: Arg<u32>,
-    },
-    // 84: LOAD_DEREF
-    LoadDeref(Arg<NameIdx>),
-    // 85: LOAD_FAST
-    LoadFast(Arg<NameIdx>),
-    // 86: LOAD_FAST_AND_CLEAR
-    LoadFastAndClear(Arg<NameIdx>),
-    // 87: LOAD_FAST_CHECK - not implemented, placeholder
-    LoadFastCheck(Arg<NameIdx>),
-    // 88: LOAD_FAST_LOAD_FAST - not implemented, placeholder
+    } = 83,
+    LoadDeref(Arg<NameIdx>) = 84,
+    LoadFast(Arg<NameIdx>) = 85,
+    LoadFastAndClear(Arg<NameIdx>) = 86,
+    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
     LoadFastLoadFast {
         arg: Arg<u32>,
-    },
-    // 89: LOAD_FROM_DICT_OR_DEREF - not implemented, placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>),
-    // 90: LOAD_FROM_DICT_OR_GLOBALS - not implemented, placeholder
-    LoadFromDictOrGlobals(Arg<NameIdx>),
-    // 91: LOAD_GLOBAL
-    LoadGlobal(Arg<NameIdx>),
-    // 92: LOAD_NAME
-    LoadNameAny(Arg<NameIdx>),
-    // 93: LOAD_SUPER_ATTR - not implemented, placeholder
+    } = 88, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89, // Placeholder
+    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
+    LoadGlobal(Arg<NameIdx>) = 91,
+    LoadName(Arg<NameIdx>) = 92,
     LoadSuperAttr {
         arg: Arg<u32>,
-    },
-    // 94: MAKE_CELL - not implemented, placeholder
-    MakeCell(Arg<NameIdx>),
-    // 95: MAP_ADD
+    } = 93, // Placeholder
+    MakeCell(Arg<NameIdx>) = 94, // Placeholder
     MapAdd {
         i: Arg<u32>,
-    },
-    // 96: MATCH_CLASS
-    MatchClass(Arg<u32>),
-    // 97: POP_JUMP_IF_FALSE
+    } = 95,
+    MatchClass(Arg<u32>) = 96,
     PopJumpIfFalse {
         target: Arg<Label>,
-    },
-    // 98: POP_JUMP_IF_NONE - not implemented, placeholder
+    } = 97,
     PopJumpIfNone {
         target: Arg<Label>,
-    },
-    // 99: POP_JUMP_IF_NOT_NONE - not implemented, placeholder
+    } = 98, // Placeholder
     PopJumpIfNotNone {
         target: Arg<Label>,
-    },
-    // 100: POP_JUMP_IF_TRUE
+    } = 99, // Placeholder
     PopJumpIfTrue {
         target: Arg<Label>,
-    },
-    // 101: RAISE_VARARGS
-    Raise {
+    } = 100,
+    RaiseVarargs {
         kind: Arg<RaiseKind>,
-    },
-    // 102: RERAISE
+    } = 101,
     Reraise {
         depth: Arg<u32>,
-    },
-    // 103: RETURN_CONST
+    } = 102,
     ReturnConst {
         idx: Arg<u32>,
-    },
-    // 104: SEND
+    } = 103,
     Send {
         target: Arg<Label>,
-    },
-    // 105: SET_ADD
+    } = 104,
     SetAdd {
         i: Arg<u32>,
-    },
-    // 106: SET_FUNCTION_ATTRIBUTE
+    } = 105,
     SetFunctionAttribute {
         attr: Arg<MakeFunctionFlags>,
-    },
-    // 107: SET_UPDATE - not implemented, placeholder
+    } = 106,
     SetUpdate {
         i: Arg<u32>,
-    },
-    // 108: STORE_ATTR
+    } = 107, // Placeholder
     StoreAttr {
         idx: Arg<NameIdx>,
-    },
-    // 109: STORE_DEREF
-    StoreDeref(Arg<NameIdx>),
-    // 110: STORE_FAST
-    StoreFast(Arg<NameIdx>),
-    // 111: STORE_FAST_LOAD_FAST
+    } = 108,
+    StoreDeref(Arg<NameIdx>) = 109,
+    StoreFast(Arg<NameIdx>) = 110,
     StoreFastLoadFast {
         store_idx: Arg<NameIdx>,
         load_idx: Arg<NameIdx>,
-    },
-    // 112: STORE_FAST_STORE_FAST - not implemented, placeholder
+    } = 111,
     StoreFastStoreFast {
         arg: Arg<u32>,
-    },
-    // 113: STORE_GLOBAL
-    StoreGlobal(Arg<NameIdx>),
-    // 114: STORE_NAME
-    StoreLocal(Arg<NameIdx>),
-    // 115: SWAP
+    } = 112, // Placeholder
+    StoreGlobal(Arg<NameIdx>) = 113,
+    StoreName(Arg<NameIdx>) = 114,
     Swap {
         index: Arg<u32>,
-    },
-    // 116: UNPACK_EX
+    } = 115,
     UnpackEx {
         args: Arg<UnpackExArgs>,
-    },
-    // 117: UNPACK_SEQUENCE
+    } = 116,
     UnpackSequence {
         size: Arg<u32>,
-    },
-    // 118: YIELD_VALUE
+    } = 117,
     YieldValue {
         arg: Arg<u32>,
-    },
-    // ==================== RustPython-only instructions (119+) ====================
-    // 119: BREAK
+    } = 118,
+    Resume {
+        arg: Arg<u32>,
+    } = 149,
+    // ==================== RustPython-only instructions (119-135) ====================
+    // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
+    // So we assign random IDs to these opcodes.
     Break {
         target: Arg<Label>,
-    },
-    // 120: BUILD_LIST_FROM_TUPLES
+    } = 119,
     BuildListFromTuples {
         size: Arg<u32>,
-    },
-    // 121: BUILD_MAP_FOR_CALL
+    } = 120,
     BuildMapForCall {
         size: Arg<u32>,
-    },
-    // 122: BUILD_SET_FROM_TUPLES
+    } = 121,
     BuildSetFromTuples {
         size: Arg<u32>,
-    },
-    // 123: BUILD_TUPLE_FROM_ITER
-    BuildTupleFromIter,
-    // 124: BUILD_TUPLE_FROM_TUPLES
+    } = 122,
+    BuildTupleFromIter = 123,
     BuildTupleFromTuples {
         size: Arg<u32>,
-    },
-    // 125: CALL_METHOD
+    } = 124,
     CallMethodPositional {
         nargs: Arg<u32>,
-    },
-    // 126: CALL_METHOD_KW
+    } = 125,
     CallMethodKeyword {
         nargs: Arg<u32>,
-    },
-    // 127: CALL_METHOD_EX
+    } = 126,
     CallMethodEx {
         has_kwargs: Arg<bool>,
-    },
-    // 128: CONTINUE
+    } = 127,
     Continue {
         target: Arg<Label>,
-    },
-    // 129: JUMP (CPython uses pseudo-op 256)
-    Jump {
-        target: Arg<Label>,
-    },
-    // 130: JUMP_IF_FALSE_OR_POP
+    } = 128,
     JumpIfFalseOrPop {
         target: Arg<Label>,
-    },
-    // 131: JUMP_IF_TRUE_OR_POP
+    } = 129,
     JumpIfTrueOrPop {
         target: Arg<Label>,
-    },
-    // 132: JUMP_IF_NOT_EXC_MATCH
-    JumpIfNotExcMatch(Arg<Label>),
-    // 133: LOAD_CLASSDEREF
-    LoadClassDeref(Arg<NameIdx>),
-    // 134: LOAD_CLOSURE (CPython uses pseudo-op 258)
-    LoadClosure(Arg<NameIdx>),
-    // 135: LOAD_METHOD (CPython uses pseudo-op 259)
-    LoadMethod {
-        idx: Arg<NameIdx>,
-    },
-    // 136: POP_BLOCK (CPython uses pseudo-op 263)
-    PopBlock,
-    // 137: REVERSE
+    } = 130,
+    JumpIfNotExcMatch(Arg<Label>) = 131,
+    LoadClassDeref(Arg<NameIdx>) = 132,
     Reverse {
         amount: Arg<u32>,
-    },
-    // 138: SET_EXC_INFO
-    SetExcInfo,
-    // 139: SUBSCRIPT
-    Subscript,
-    // 140-148: Reserved (padding to keep RESUME at 149)
-    Reserved140,
-    Reserved141,
-    Reserved142,
-    Reserved143,
-    Reserved144,
-    Reserved145,
-    Reserved146,
-    Reserved147,
-    Reserved148,
-    // 149: RESUME
-    Resume {
-        arg: Arg<u32>,
-    },
-    // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
+    } = 133,
+    SetExcInfo = 134,
+    Subscript = 135,
+    // ===== Pseudo Opcodes (252+) ======
+    Jump {
+        target: Arg<Label>,
+    } = 252, // CPython uses pseudo-op 256
+    LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
+    LoadMethod {
+        idx: Arg<NameIdx>,
+    } = 254, // CPython uses pseudo-op 259
+    PopBlock = 255,                  // CPython uses pseudo-op 263
 }
 
-// This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::Resume { arg: Arg::marker() };
-
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
 impl From<Instruction> for u8 {
@@ -1126,10 +972,29 @@ impl TryFrom<u8> for Instruction {
 
     #[inline]
     fn try_from(value: u8) -> Result<Self, MarshalError> {
-        if value <= u8::from(LAST_INSTRUCTION) {
+        let cpython_start = u8::from(Self::Cache);
+        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
+
+        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+
+        let custom_start = u8::from(Self::Break {
+            target: Arg::marker(),
+        });
+        let custom_end = u8::from(Self::Subscript);
+
+        let pseudo_start = u8::from(Self::Jump {
+            target: Arg::marker(),
+        });
+        let pseudo_end = u8::from(Self::PopBlock);
+
+        if (cpython_start..=cpython_end).contains(&value)
+            || value == resume_id
+            || (custom_start..=custom_end).contains(&value)
+            || (pseudo_start..=pseudo_end).contains(&value)
+        {
             Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
         } else {
-            Err(MarshalError::InvalidBytecode)
+            Err(Self::Error::InvalidBytecode)
         }
     }
 }
@@ -1857,13 +1722,7 @@ impl Instruction {
             | ForIter { target: l }
             | Break { target: l }
             | Continue { target: l }
-            | Send { target: l }
-            // Dummy jump instructions (placeholders)
-            | JumpBackward { target: l }
-            | JumpBackwardNoInterrupt { target: l }
-            | JumpForward { target: l }
-            | PopJumpIfNone { target: l }
-            | PopJumpIfNotNone { target: l } => Some(*l),
+            | Send { target: l } => Some(*l),
             _ => None,
         }
     }
@@ -1885,7 +1744,7 @@ impl Instruction {
                 | Break { .. }
                 | ReturnValue
                 | ReturnConst { .. }
-                | Raise { .. }
+                | RaiseVarargs { .. }
                 | Reraise { .. }
         )
     }
@@ -1903,47 +1762,25 @@ impl Instruction {
     ///
     pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
-            // Dummy/placeholder instructions (never executed)
-            Cache | Reserved3 | Reserved17 | Reserved140 | Reserved141 | Reserved142
-            | Reserved143 | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => {
-                0
-            }
-            BinarySlice | EndFor | ExitInitCheck | GetYieldFromIter | InterpreterExit
-            | LoadAssertionError | LoadLocals | PushNull | ReturnGenerator | StoreSlice => 0,
-            BuildConstKeyMap { .. }
-            | CopyFreeVars { .. }
-            | DictMerge { .. }
-            | EnterExecutor { .. }
-            | ListExtend { .. }
-            | LoadFastCheck(_)
-            | LoadFastLoadFast { .. }
-            | LoadFromDictOrDeref(_)
-            | LoadFromDictOrGlobals(_)
-            | LoadSuperAttr { .. }
-            | MakeCell(_)
-            | SetUpdate { .. }
-            | StoreFastStoreFast { .. } => 0,
-            JumpBackward { .. } | JumpBackwardNoInterrupt { .. } | JumpForward { .. } => 0,
-            PopJumpIfNone { .. } | PopJumpIfNotNone { .. } => -1,
-
             Nop => 0,
             ImportName { .. } => -1,
             ImportFrom { .. } => 1,
-            LoadFast(_) | LoadFastAndClear(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_)
+            LoadFast(_) | LoadFastAndClear(_) | LoadName(_) | LoadGlobal(_) | LoadDeref(_)
             | LoadClassDeref(_) => 1,
-            StoreFast(_) | StoreLocal(_) | StoreGlobal(_) | StoreDeref(_) => -1,
+            StoreFast(_) | StoreName(_) | StoreGlobal(_) | StoreDeref(_) => -1,
             StoreFastLoadFast { .. } => 0, // pop 1, push 1
-            DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
+            DeleteFast(_) | DeleteName(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
             LoadClosure(_) => 1,
             Subscript => -1,
-            StoreSubscript => -3,
-            DeleteSubscript => -2,
+            StoreSubscr => -3,
+            DeleteSubscr => -2,
             LoadAttr { .. } => 0,
             StoreAttr { .. } => -2,
             DeleteAttr { .. } => -1,
             LoadConst { .. } => 1,
-            BinaryOp { .. } | CompareOperation { .. } => -1,
-            BinarySubscript => -1,
+            Reserved => 0,
+            BinaryOp { .. } | CompareOp { .. } => -1,
+            BinarySubscr => -1,
             CopyItem { .. } => 1,
             PopTop => -1,
             Swap { .. } => 0,
@@ -1971,9 +1808,9 @@ impl Instruction {
                 // pops attribute value and function, pushes function back
                 -2 + 1
             }
-            CallFunctionPositional { nargs } => -(nargs.get(arg) as i32) - 1 + 1,
+            Call { nargs } => -(nargs.get(arg) as i32) - 1 + 1,
             CallMethodPositional { nargs } => -(nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 1 + 1,
+            CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 1 + 1,
             CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
             CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
             CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
@@ -2005,11 +1842,11 @@ impl Instruction {
             PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
             CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
             Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
-            SetupAnnotation => 0,
+            SetupAnnotations => 0,
             BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
             WithExceptStart => 1, // push __exit__ result
             PopBlock => 0,
-            Raise { kind } => {
+            RaiseVarargs { kind } => {
                 // Stack effects for different raise kinds:
                 // - Reraise (0): gets from VM state, no stack pop
                 // - Raise (1): pops 1 exception
@@ -2057,7 +1894,7 @@ impl Instruction {
                 let UnpackExArgs { before, after } = args.get(arg);
                 -1 + before as i32 + 1 + after as i32
             }
-            PopException => 0,
+            PopExcept => 0,
             Reverse { .. } => 0,
             GetAwaitable => 0,
             BeforeAsyncWith => 1,
@@ -2071,6 +1908,8 @@ impl Instruction {
             UnaryInvert => 0,
             UnaryNegative => 0,
             UnaryNot => 0,
+            GetYieldFromIter => 0,
+            _ => 0,
         }
     }
 
@@ -2141,47 +1980,10 @@ impl Instruction {
             };
 
         match self {
-            // Dummy/placeholder instructions
-            Cache => w!(CACHE),
-            Reserved3 | Reserved17 | Reserved140 | Reserved141 | Reserved142 | Reserved143
-            | Reserved144 | Reserved145 | Reserved146 | Reserved147 | Reserved148 => w!(RESERVED),
-            BinarySlice => w!(BINARY_SLICE),
-            EndFor => w!(END_FOR),
-            ExitInitCheck => w!(EXIT_INIT_CHECK),
-            GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
-            InterpreterExit => w!(INTERPRETER_EXIT),
-            LoadAssertionError => w!(LOAD_ASSERTION_ERROR),
-            LoadLocals => w!(LOAD_LOCALS),
-            PushNull => w!(PUSH_NULL),
-            ReturnGenerator => w!(RETURN_GENERATOR),
-            StoreSlice => w!(STORE_SLICE),
-            UnaryInvert => w!(UNARY_INVERT),
-            UnaryNegative => w!(UNARY_NEGATIVE),
-            UnaryNot => w!(UNARY_NOT),
-            BuildConstKeyMap { size } => w!(BUILD_CONST_KEY_MAP, size),
-            CopyFreeVars { count } => w!(COPY_FREE_VARS, count),
-            DictMerge { index } => w!(DICT_MERGE, index),
-            EnterExecutor { index } => w!(ENTER_EXECUTOR, index),
-            JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            JumpForward { target } => w!(JUMP_FORWARD, target),
-            ListExtend { i } => w!(LIST_EXTEND, i),
-            LoadFastCheck(idx) => w!(LOAD_FAST_CHECK, varname = idx),
-            LoadFastLoadFast { arg } => w!(LOAD_FAST_LOAD_FAST, arg),
-            LoadFromDictOrDeref(idx) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = idx),
-            LoadFromDictOrGlobals(idx) => w!(LOAD_FROM_DICT_OR_GLOBALS, name = idx),
-            LoadSuperAttr { arg } => w!(LOAD_SUPER_ATTR, arg),
-            MakeCell(idx) => w!(MAKE_CELL, cell_name = idx),
-            PopJumpIfNone { target } => w!(POP_JUMP_IF_NONE, target),
-            PopJumpIfNotNone { target } => w!(POP_JUMP_IF_NOT_NONE, target),
-            SetUpdate { i } => w!(SET_UPDATE, i),
-            StoreFastStoreFast { arg } => w!(STORE_FAST_STORE_FAST, arg),
-
-            // Real instructions
             BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
             BeforeWith => w!(BEFORE_WITH),
             BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            BinarySubscript => w!(BINARY_SUBSCR),
+            BinarySubscr => w!(BINARY_SUBSCR),
             Break { target } => w!(BREAK, target),
             BuildList { size } => w!(BUILD_LIST, size),
             BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
@@ -2194,9 +1996,9 @@ impl Instruction {
             BuildTuple { size } => w!(BUILD_TUPLE, size),
             BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
             BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
+            Call { nargs } => w!(CALL, nargs),
             CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
-            CallFunctionKeyword { nargs } => w!(CALL_KW, nargs),
-            CallFunctionPositional { nargs } => w!(CALL, nargs),
+            CallKw { nargs } => w!(CALL_KW, nargs),
             CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
             CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
@@ -2205,7 +2007,7 @@ impl Instruction {
             CheckEgMatch => w!(CHECK_EG_MATCH),
             CheckExcMatch => w!(CHECK_EXC_MATCH),
             CleanupThrow => w!(CLEANUP_THROW),
-            CompareOperation { op } => w!(COMPARE_OP, ?op),
+            CompareOp { op } => w!(COMPARE_OP, ?op),
             ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
             Continue { target } => w!(CONTINUE, target),
             ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
@@ -2214,8 +2016,8 @@ impl Instruction {
             DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
             DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
             DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
-            DeleteLocal(idx) => w!(DELETE_NAME, name = idx),
-            DeleteSubscript => w!(DELETE_SUBSCR),
+            DeleteName(idx) => w!(DELETE_NAME, name = idx),
+            DeleteSubscr => w!(DELETE_SUBSCR),
             DictUpdate { index } => w!(DICT_UPDATE, index),
             EndAsyncFor => w!(END_ASYNC_FOR),
             EndSend => w!(END_SEND),
@@ -2226,6 +2028,7 @@ impl Instruction {
             GetAIter => w!(GET_AITER),
             GetANext => w!(GET_ANEXT),
             GetAwaitable => w!(GET_AWAITABLE),
+            Reserved => w!(RESERVED),
             GetIter => w!(GET_ITER),
             GetLen => w!(GET_LEN),
             ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
@@ -2246,7 +2049,7 @@ impl Instruction {
             LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
             LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
             LoadMethod { idx } => w!(LOAD_METHOD, name = idx),
-            LoadNameAny(idx) => w!(LOAD_NAME, name = idx),
+            LoadName(idx) => w!(LOAD_NAME, name = idx),
             MakeFunction => w!(MAKE_FUNCTION),
             MapAdd { i } => w!(MAP_ADD, i),
             MatchClass(arg) => w!(MATCH_CLASS, arg),
@@ -2255,12 +2058,12 @@ impl Instruction {
             MatchSequence => w!(MATCH_SEQUENCE),
             Nop => w!(NOP),
             PopBlock => w!(POP_BLOCK),
-            PopException => w!(POP_EXCEPT),
+            PopExcept => w!(POP_EXCEPT),
             PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
             PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
             PopTop => w!(POP_TOP),
             PushExcInfo => w!(PUSH_EXC_INFO),
-            Raise { kind } => w!(RAISE_VARARGS, ?kind),
+            RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
             Reraise { depth } => w!(RERAISE, depth),
             Resume { arg } => w!(RESUME, arg),
             ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
@@ -2270,7 +2073,7 @@ impl Instruction {
             SetAdd { i } => w!(SET_ADD, i),
             SetExcInfo => w!(SET_EXC_INFO),
             SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
-            SetupAnnotation => w!(SETUP_ANNOTATIONS),
+            SetupAnnotations => w!(SETUP_ANNOTATIONS),
             StoreAttr { idx } => w!(STORE_ATTR, name = idx),
             StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
             StoreFast(idx) => w!(STORE_FAST, varname = idx),
@@ -2282,15 +2085,20 @@ impl Instruction {
                 write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
             }
             StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            StoreLocal(idx) => w!(STORE_NAME, name = idx),
-            StoreSubscript => w!(STORE_SUBSCR),
+            StoreName(idx) => w!(STORE_NAME, name = idx),
+            StoreSubscr => w!(STORE_SUBSCR),
             Subscript => w!(SUBSCRIPT),
             Swap { index } => w!(SWAP, index),
             ToBool => w!(TO_BOOL),
             UnpackEx { args } => w!(UNPACK_EX, args),
             UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
             WithExceptStart => w!(WITH_EXCEPT_START),
+            UnaryInvert => w!(UNARY_INVERT),
+            UnaryNegative => w!(UNARY_NEGATIVE),
+            UnaryNot => w!(UNARY_NOT),
             YieldValue { arg } => w!(YIELD_VALUE, arg),
+            GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
 }
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index d6e3a07e111..4406cf39d49 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -454,7 +454,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::CallFunctionPositional { nargs } => {
+            Instruction::Call { nargs } => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -489,7 +489,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::CompareOperation { op, .. } => {
+            Instruction::CompareOp { op, .. } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 17c280ec3c9..eabf27471b9 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -96,10 +96,10 @@ impl StackMachine {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            Instruction::LoadNameAny(idx) => self
+            Instruction::LoadName(idx) => self
                 .stack
                 .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreLocal(idx) => {
+            Instruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index cf6502181a7..99cc4130b08 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -69,16 +69,16 @@ mod opcode {
                     Instruction::try_from(opcode as u8),
                     Ok(Instruction::DeleteAttr { .. }
                         | Instruction::DeleteGlobal(_)
-                        | Instruction::DeleteLocal(_)
+                        | Instruction::DeleteName(_)
                         | Instruction::ImportFrom { .. }
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
                         | Instruction::LoadGlobal(_)
                         | Instruction::LoadMethod { .. }
-                        | Instruction::LoadNameAny(_)
+                        | Instruction::LoadName(_)
                         | Instruction::StoreAttr { .. }
                         | Instruction::StoreGlobal(_)
-                        | Instruction::StoreLocal(_))
+                        | Instruction::StoreName(_))
                 )
         }
 
@@ -97,8 +97,6 @@ mod opcode {
                         | Instruction::Jump { .. }
                         | Instruction::PopJumpIfFalse { .. }
                         | Instruction::PopJumpIfTrue { .. }
-                        | Instruction::PopJumpIfNone { .. }
-                        | Instruction::PopJumpIfNotNone { .. }
                         | Instruction::Send { .. })
                 )
         }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index fc56f50fb3d..275269c5cbe 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -391,7 +391,7 @@ impl ExecutingFrame<'_> {
                     // Instruction::Reraise are reraise operations that should not add
                     // new traceback entries
                     let is_reraise = match op {
-                        bytecode::Instruction::Raise { kind } => matches!(
+                        bytecode::Instruction::RaiseVarargs { kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
@@ -610,7 +610,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinarySubscript => {
+            bytecode::Instruction::BinarySubscr => {
                 let key = self.pop_value();
                 let container = self.pop_value();
                 self.state
@@ -711,11 +711,11 @@ impl ExecutingFrame<'_> {
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionKeyword { nargs } => {
+            bytecode::Instruction::CallKw { nargs } => {
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionPositional { nargs } => {
+            bytecode::Instruction::Call { nargs } => {
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
@@ -753,7 +753,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
+            bytecode::Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
             bytecode::Instruction::ContainsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -822,7 +822,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteLocal(idx) => {
+            bytecode::Instruction::DeleteName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
@@ -835,7 +835,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
+            bytecode::Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
             bytecode::Instruction::DictUpdate { index } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
@@ -1192,7 +1192,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(func);
                 Ok(None)
             }
-            bytecode::Instruction::LoadNameAny(idx) => {
+            bytecode::Instruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
                 match result {
@@ -1428,7 +1428,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::Nop => Ok(None),
             // PopBlock is now a pseudo-instruction - exception table handles this
             bytecode::Instruction::PopBlock => Ok(None),
-            bytecode::Instruction::PopException => {
+            bytecode::Instruction::PopExcept => {
                 // Pop prev_exc from value stack and restore it
                 let prev_exc = self.pop_value();
                 if vm.is_none(&prev_exc) {
@@ -1457,7 +1457,7 @@ impl ExecutingFrame<'_> {
                 self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::Raise { kind } => self.execute_raise(vm, kind.get(arg)),
+            bytecode::Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
             bytecode::Instruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start
                 // In CPython, this checks instrumentation and eval breaker
@@ -1559,7 +1559,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::SetFunctionAttribute { attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
+            bytecode::Instruction::SetupAnnotations => self.setup_annotations(vm),
             bytecode::Instruction::BeforeWith => {
                 // TOS: context_manager
                 // Result: [..., __exit__, __enter__ result]
@@ -1621,13 +1621,13 @@ impl ExecutingFrame<'_> {
                     .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreLocal(idx) => {
+            bytecode::Instruction::StoreName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
+            bytecode::Instruction::StoreSubscr => self.execute_store_subscript(vm),
             bytecode::Instruction::Subscript => self.execute_subscript(vm),
             bytecode::Instruction::Swap { index } => {
                 let len = self.state.stack.len();
@@ -1779,50 +1779,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(!value).into());
                 Ok(None)
             }
-            // Placeholder/dummy instructions - these should never be executed
-            bytecode::Instruction::Cache
-            | bytecode::Instruction::Reserved3
-            | bytecode::Instruction::Reserved17
-            | bytecode::Instruction::BinarySlice
-            | bytecode::Instruction::EndFor
-            | bytecode::Instruction::ExitInitCheck
-            | bytecode::Instruction::InterpreterExit
-            | bytecode::Instruction::LoadAssertionError
-            | bytecode::Instruction::LoadLocals
-            | bytecode::Instruction::PushNull
-            | bytecode::Instruction::ReturnGenerator
-            | bytecode::Instruction::StoreSlice
-            | bytecode::Instruction::BuildConstKeyMap { .. }
-            | bytecode::Instruction::CopyFreeVars { .. }
-            | bytecode::Instruction::DictMerge { .. }
-            | bytecode::Instruction::EnterExecutor { .. }
-            | bytecode::Instruction::JumpBackward { .. }
-            | bytecode::Instruction::JumpBackwardNoInterrupt { .. }
-            | bytecode::Instruction::JumpForward { .. }
-            | bytecode::Instruction::ListExtend { .. }
-            | bytecode::Instruction::LoadFastCheck(_)
-            | bytecode::Instruction::LoadFastLoadFast { .. }
-            | bytecode::Instruction::LoadFromDictOrDeref(_)
-            | bytecode::Instruction::LoadFromDictOrGlobals(_)
-            | bytecode::Instruction::LoadSuperAttr { .. }
-            | bytecode::Instruction::MakeCell(_)
-            | bytecode::Instruction::PopJumpIfNone { .. }
-            | bytecode::Instruction::PopJumpIfNotNone { .. }
-            | bytecode::Instruction::SetUpdate { .. }
-            | bytecode::Instruction::StoreFastStoreFast { .. }
-            | bytecode::Instruction::Reserved140
-            | bytecode::Instruction::Reserved141
-            | bytecode::Instruction::Reserved142
-            | bytecode::Instruction::Reserved143
-            | bytecode::Instruction::Reserved144
-            | bytecode::Instruction::Reserved145
-            | bytecode::Instruction::Reserved146
-            | bytecode::Instruction::Reserved147
-            | bytecode::Instruction::Reserved148 => {
-                unreachable!(
-                    "placeholder instruction should not be executed: {:?}",
-                    instruction
-                )
+            _ => {
+                unreachable!("{instruction:?} instruction should not be executed")
             }
         }
     }
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index 9c440d52568..4ebdfd81776 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -1,208 +1,60 @@
-"""Generate _opcode_metadata.py for RustPython bytecode.
+"""
+Generate Lib/_opcode_metadata.py for RustPython bytecode.
 
 This file generates opcode metadata that is compatible with CPython 3.13.
-RustPython's Instruction enum is now ordered to match CPython opcode numbers exactly.
 """
 
+import itertools
+import pathlib
 import re
+import typing
+
+ROOT = pathlib.Path(__file__).parents[1]
+BYTECODE_FILE = ROOT / "crates" / "compiler-core" / "src" / "bytecode.rs"
+OPCODE_METADATA_FILE = ROOT / "Lib" / "_opcode_metadata.py"
+
+
+class Opcode(typing.NamedTuple):
+    rust_name: str
+    id: int
+
+    @property
+    def cpython_name(self) -> str:
+        if self.rust_name == "CopyItem":
+            return "COPY"
+        name = self.rust_name
+        name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name)
+        return re.sub(r"(\D)(\d+)$", r"\1_\2", name).upper()
+        return re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", self.rust_name).upper()
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.rust_name).upper()
+
+    @classmethod
+    def from_str(cls, body: str):
+        raw_variants = re.split(r"(\d+),", body.strip())
+        raw_variants.remove("")
+        for raw_name, raw_id in itertools.batched(raw_variants, 2):
+            name = re.findall(r"\b[A-Z][A-Za-z]*\d*\b(?=\s*[\({=])", raw_name)[0]
+            yield cls(rust_name=name.strip(), id=int(raw_id))
+
+    def __lt__(self, other: typing.Self) -> bool:
+        return self.id < other.id
+
+
+def extract_enum_body(contents: str) -> str:
+    res = re.search(r"pub enum Instruction \{(.+?)\n\}", contents, re.DOTALL)
+    if not res:
+        raise ValueError("Could not find Instruction enum")
+
+    return "\n".join(
+        line.split("//")[0].strip()  # Remove any comment. i.e. "foo // some comment"
+        for line in res.group(1).splitlines()
+        if not line.strip().startswith("//")  # Ignore comment lines
+    )
 
-# Read the bytecode.rs file to get instruction names
-with open("crates/compiler-core/src/bytecode.rs", "r") as f:
-    content = f.read()
-
-# Find the Instruction enum
-match = re.search(r"pub enum Instruction \{(.+?)\n\}", content, re.DOTALL)
-if not match:
-    raise ValueError("Could not find Instruction enum")
-
-enum_body = match.group(1)
-
-# Extract variant names
-variants = []
-for line in enum_body.split("\n"):
-    if line.strip().startswith("///") or line.strip().startswith("//"):
-        continue
-    m = re.match(r"^\s+([A-Z][a-zA-Z0-9]*)", line)
-    if m:
-        variants.append(m.group(1))
-
-print(f"Found {len(variants)} instruction variants")
-
-# Map RustPython variant names to CPython-compatible names
-# The opcode number is the index in the Instruction enum
-name_mapping = {
-    # Dummy/placeholder instructions
-    "Cache": "CACHE",
-    "Reserved3": "RESERVED",
-    "Reserved17": "RESERVED",
-    "Reserved141": "RESERVED",
-    "Reserved142": "RESERVED",
-    "Reserved143": "RESERVED",
-    "Reserved144": "RESERVED",
-    "Reserved145": "RESERVED",
-    "Reserved146": "RESERVED",
-    "Reserved147": "RESERVED",
-    "Reserved148": "RESERVED",
-    "BinarySlice": "BINARY_SLICE",
-    "EndFor": "END_FOR",
-    "ExitInitCheck": "EXIT_INIT_CHECK",
-    "GetYieldFromIter": "GET_YIELD_FROM_ITER",
-    "InterpreterExit": "INTERPRETER_EXIT",
-    "LoadAssertionError": "LOAD_ASSERTION_ERROR",
-    "LoadLocals": "LOAD_LOCALS",
-    "PushNull": "PUSH_NULL",
-    "ReturnGenerator": "RETURN_GENERATOR",
-    "StoreSlice": "STORE_SLICE",
-    "UnaryInvert": "UNARY_INVERT",
-    "UnaryNegative": "UNARY_NEGATIVE",
-    "UnaryNot": "UNARY_NOT",
-    "BuildConstKeyMap": "BUILD_CONST_KEY_MAP",
-    "CopyFreeVars": "COPY_FREE_VARS",
-    "DictMerge": "DICT_MERGE",
-    "EnterExecutor": "ENTER_EXECUTOR",
-    "JumpBackward": "JUMP_BACKWARD",
-    "JumpBackwardNoInterrupt": "JUMP_BACKWARD_NO_INTERRUPT",
-    "JumpForward": "JUMP_FORWARD",
-    "ListExtend": "LIST_EXTEND",
-    "LoadFastCheck": "LOAD_FAST_CHECK",
-    "LoadFastLoadFast": "LOAD_FAST_LOAD_FAST",
-    "LoadFromDictOrDeref": "LOAD_FROM_DICT_OR_DEREF",
-    "LoadFromDictOrGlobals": "LOAD_FROM_DICT_OR_GLOBALS",
-    "LoadSuperAttr": "LOAD_SUPER_ATTR",
-    "MakeCell": "MAKE_CELL",
-    "PopJumpIfNone": "POP_JUMP_IF_NONE",
-    "PopJumpIfNotNone": "POP_JUMP_IF_NOT_NONE",
-    "SetUpdate": "SET_UPDATE",
-    "StoreFastStoreFast": "STORE_FAST_STORE_FAST",
-    # Real instructions
-    "BeforeAsyncWith": "BEFORE_ASYNC_WITH",
-    "BeforeWith": "BEFORE_WITH",
-    "BinaryOp": "BINARY_OP",
-    "BinarySubscript": "BINARY_SUBSCR",
-    "Break": "BREAK",
-    "BuildList": "BUILD_LIST",
-    "BuildListFromTuples": "BUILD_LIST_UNPACK",
-    "BuildMap": "BUILD_MAP",
-    "BuildMapForCall": "BUILD_MAP_FOR_CALL",
-    "BuildSet": "BUILD_SET",
-    "BuildSetFromTuples": "BUILD_SET_UNPACK",
-    "BuildSlice": "BUILD_SLICE",
-    "BuildString": "BUILD_STRING",
-    "BuildTuple": "BUILD_TUPLE",
-    "BuildTupleFromIter": "BUILD_TUPLE_ITER",
-    "BuildTupleFromTuples": "BUILD_TUPLE_UNPACK",
-    "CallFunctionEx": "CALL_FUNCTION_EX",
-    "CallFunctionKeyword": "CALL_KW",
-    "CallFunctionPositional": "CALL",
-    "CallIntrinsic1": "CALL_INTRINSIC_1",
-    "CallIntrinsic2": "CALL_INTRINSIC_2",
-    "CallMethodEx": "CALL_METHOD_EX",
-    "CallMethodKeyword": "CALL_METHOD_KW",
-    "CallMethodPositional": "CALL_METHOD",
-    "CheckEgMatch": "CHECK_EG_MATCH",
-    "CheckExcMatch": "CHECK_EXC_MATCH",
-    "CleanupThrow": "CLEANUP_THROW",
-    "CompareOperation": "COMPARE_OP",
-    "ContainsOp": "CONTAINS_OP",
-    "Continue": "CONTINUE",
-    "ConvertValue": "CONVERT_VALUE",
-    "CopyItem": "COPY",
-    "DeleteAttr": "DELETE_ATTR",
-    "DeleteDeref": "DELETE_DEREF",
-    "DeleteFast": "DELETE_FAST",
-    "DeleteGlobal": "DELETE_GLOBAL",
-    "DeleteLocal": "DELETE_NAME",
-    "DeleteSubscript": "DELETE_SUBSCR",
-    "DictUpdate": "DICT_UPDATE",
-    "EndAsyncFor": "END_ASYNC_FOR",
-    "EndSend": "END_SEND",
-    "ExtendedArg": "EXTENDED_ARG",
-    "ForIter": "FOR_ITER",
-    "FormatSimple": "FORMAT_SIMPLE",
-    "FormatWithSpec": "FORMAT_WITH_SPEC",
-    "GetAIter": "GET_AITER",
-    "GetANext": "GET_ANEXT",
-    "GetAwaitable": "GET_AWAITABLE",
-    "GetIter": "GET_ITER",
-    "GetLen": "GET_LEN",
-    "ImportFrom": "IMPORT_FROM",
-    "ImportName": "IMPORT_NAME",
-    "IsOp": "IS_OP",
-    "Jump": "JUMP",
-    "JumpIfFalseOrPop": "JUMP_IF_FALSE_OR_POP",
-    "JumpIfNotExcMatch": "JUMP_IF_NOT_EXC_MATCH",
-    "JumpIfTrueOrPop": "JUMP_IF_TRUE_OR_POP",
-    "ListAppend": "LIST_APPEND",
-    "LoadAttr": "LOAD_ATTR",
-    "LoadBuildClass": "LOAD_BUILD_CLASS",
-    "LoadClassDeref": "LOAD_CLASSDEREF",
-    "LoadClosure": "LOAD_CLOSURE",
-    "LoadConst": "LOAD_CONST",
-    "LoadDeref": "LOAD_DEREF",
-    "LoadFast": "LOAD_FAST",
-    "LoadFastAndClear": "LOAD_FAST_AND_CLEAR",
-    "LoadGlobal": "LOAD_GLOBAL",
-    "LoadMethod": "LOAD_METHOD",
-    "LoadNameAny": "LOAD_NAME",
-    "MakeFunction": "MAKE_FUNCTION",
-    "MapAdd": "MAP_ADD",
-    "MatchClass": "MATCH_CLASS",
-    "MatchKeys": "MATCH_KEYS",
-    "MatchMapping": "MATCH_MAPPING",
-    "MatchSequence": "MATCH_SEQUENCE",
-    "Nop": "NOP",
-    "PopBlock": "POP_BLOCK",
-    "PopException": "POP_EXCEPT",
-    "PopJumpIfFalse": "POP_JUMP_IF_FALSE",
-    "PopJumpIfTrue": "POP_JUMP_IF_TRUE",
-    "PopTop": "POP_TOP",
-    "PushExcInfo": "PUSH_EXC_INFO",
-    "Raise": "RAISE_VARARGS",
-    "Reraise": "RERAISE",
-    "Resume": "RESUME",
-    "ReturnConst": "RETURN_CONST",
-    "ReturnValue": "RETURN_VALUE",
-    "Reverse": "REVERSE",
-    "Send": "SEND",
-    "SetAdd": "SET_ADD",
-    "SetExcInfo": "SET_EXC_INFO",
-    "SetFunctionAttribute": "SET_FUNCTION_ATTRIBUTE",
-    "SetupAnnotation": "SETUP_ANNOTATIONS",
-    "StoreAttr": "STORE_ATTR",
-    "StoreDeref": "STORE_DEREF",
-    "StoreFast": "STORE_FAST",
-    "StoreFastLoadFast": "STORE_FAST_LOAD_FAST",
-    "StoreGlobal": "STORE_GLOBAL",
-    "StoreLocal": "STORE_NAME",
-    "StoreSubscript": "STORE_SUBSCR",
-    "Subscript": "SUBSCRIPT",
-    "Swap": "SWAP",
-    "ToBool": "TO_BOOL",
-    "UnaryOperation": "UNARY_OP",
-    "UnpackEx": "UNPACK_EX",
-    "UnpackSequence": "UNPACK_SEQUENCE",
-    "WithExceptStart": "WITH_EXCEPT_START",
-    "YieldValue": "YIELD_VALUE",
-}
-
-# Build opmap with RustPython instruction indices
-opmap = {}
-rust_to_cpython_name = {}
-for i, variant in enumerate(variants):
-    cpython_name = name_mapping.get(variant, variant.upper())
-    # Skip adding duplicates (RESERVED appears multiple times)
-    if cpython_name == "RESERVED":
-        # Use unique names for reserved slots
-        cpython_name = f"RESERVED_{i}"
-    if cpython_name not in opmap:
-        opmap[cpython_name] = i
-    rust_to_cpython_name[variant] = cpython_name
-
-
-# Find specific instruction indices for categorization
-def find_opcode(cpython_name):
-    return opmap.get(cpython_name, -1)
 
+contents = BYTECODE_FILE.read_text()
+enum_body = extract_enum_body(contents)
+opcodes = list(Opcode.from_str(enum_body))
 
 # Generate the output file
 output = """# This file is generated by scripts/generate_opcode_metadata.py
@@ -216,8 +68,8 @@ def find_opcode(cpython_name):
 opmap = {
 """
 
-for name, num in sorted(opmap.items(), key=lambda x: x[1]):
-    output += f"    '{name}': {num},\n"
+for opcode in sorted(opcodes):
+    output += f"    '{opcode.cpython_name}': {opcode.id},\n"
 
 output += """}
 
@@ -226,21 +78,4 @@ def find_opcode(cpython_name):
 MIN_INSTRUMENTED_OPCODE = 236
 """
 
-with open("Lib/_opcode_metadata.py", "w") as f:
-    f.write(output)
-
-print("Generated Lib/_opcode_metadata.py")
-print("\nKey opcode indices (matching CPython 3.13):")
-print(f"  CACHE = {find_opcode('CACHE')} (expected: 0)")
-print(f"  BEFORE_ASYNC_WITH = {find_opcode('BEFORE_ASYNC_WITH')} (expected: 1)")
-print(f"  BINARY_SUBSCR = {find_opcode('BINARY_SUBSCR')} (expected: 5)")
-print(
-    f"  WITH_EXCEPT_START = {find_opcode('WITH_EXCEPT_START')} (expected: 44, HAVE_ARGUMENT)"
-)
-print(f"  BINARY_OP = {find_opcode('BINARY_OP')} (expected: 45)")
-print(f"  LOAD_CONST = {find_opcode('LOAD_CONST')} (expected: 83)")
-print(f"  LOAD_FAST = {find_opcode('LOAD_FAST')} (expected: 85)")
-print(f"  LOAD_GLOBAL = {find_opcode('LOAD_GLOBAL')} (expected: 91)")
-print(f"  STORE_FAST = {find_opcode('STORE_FAST')} (expected: 110)")
-print(f"  YIELD_VALUE = {find_opcode('YIELD_VALUE')} (expected: 118)")
-print(f"  RESUME = {find_opcode('RESUME')} (expected: 149)")
+OPCODE_METADATA_FILE.write_text(output)

From de0bc732c9838366629b27c6d98b51a4d0c37d80 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 08:25:56 +0900
Subject: [PATCH 199/418] Replace CallMethod/LoadMethod opcodes with plain Call
 (#6674)

* implementing call the correct way

stack is [Option<PyObjectRef>]

* fix again

* list custom instructions

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 Lib/_opcode_metadata.py                       |   5 +-
 Lib/test/test_xml_etree.py                    |   1 -
 crates/codegen/src/compile.rs                 | 242 +++++++++++-------
 ...pile__tests__nested_double_async_with.snap | 240 ++++++++---------
 crates/compiler-core/src/bytecode.rs          |  78 ++++--
 crates/jit/src/instructions.rs                |  19 +-
 crates/stdlib/src/opcode.rs                   |   2 +-
 crates/vm/src/frame.rs                        | 238 +++++++++--------
 crates/vm/src/vm/method.rs                    |  15 +-
 9 files changed, 489 insertions(+), 351 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 529f5cbf656..5734d6141a4 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -132,9 +132,6 @@
     'BUILD_SET_FROM_TUPLES': 122,
     'BUILD_TUPLE_FROM_ITER': 123,
     'BUILD_TUPLE_FROM_TUPLES': 124,
-    'CALL_METHOD_POSITIONAL': 125,
-    'CALL_METHOD_KEYWORD': 126,
-    'CALL_METHOD_EX': 127,
     'CONTINUE': 128,
     'JUMP_IF_FALSE_OR_POP': 129,
     'JUMP_IF_TRUE_OR_POP': 130,
@@ -146,7 +143,7 @@
     'RESUME': 149,
     'JUMP': 252,
     'LOAD_CLOSURE': 253,
-    'LOAD_METHOD': 254,
+    'LOAD_ATTR_METHOD': 254,
     'POP_BLOCK': 255,
 }
 
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index 11c617b5f34..1489fb666ea 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -2301,7 +2301,6 @@ def test_bug_xmltoolkit62(self):
         self.assertEqual(t.find('.//paragraph').text,
             'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.gettrace(), "Skips under coverage.")
     def test_bug_xmltoolkit63(self):
         # Check reference leak.
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index f61b01a43ec..1f12cc87074 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -98,12 +98,6 @@ enum NameUsage {
     Delete,
 }
 
-enum CallType {
-    Positional { nargs: u32 },
-    Keyword { nargs: u32 },
-    Ex { has_kwargs: bool },
-}
-
 fn is_forbidden_name(name: &str) -> bool {
     // See https://docs.python.org/3/library/constants.html#built-in-constants
     const BUILTIN_CONSTANTS: &[&str] = &["__debug__"];
@@ -1034,12 +1028,16 @@ impl Compiler {
                 if preserve_tos {
                     emit!(self, Instruction::Swap { index: 2 });
                 }
+                // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
-                // Call __exit__(None, None, None) - compiler_call_exit_with_nones
-                // Stack: [..., __exit__] or [..., return_value, __exit__]
+                // Call __exit__(None, None, None)
+                // Call protocol: [callable, self_or_null, arg1, arg2, arg3]
+                emit!(self, Instruction::PushNull);
+                // Stack: [..., __exit__, NULL]
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
+                // Stack: [..., __exit__, NULL, None, None, None]
                 emit!(self, Instruction::Call { nargs: 3 });
 
                 // For async with, await the result
@@ -1875,6 +1873,7 @@ impl Compiler {
 
                     let assertion_error = self.name("AssertionError");
                     emit!(self, Instruction::LoadGlobal(assertion_error));
+                    emit!(self, Instruction::PushNull);
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
@@ -2092,15 +2091,21 @@ impl Compiler {
         Ok(())
     }
 
+    /// Push decorators onto the stack in source order.
+    /// For @dec1 @dec2 def foo(): stack becomes [dec1, NULL, dec2, NULL]
     fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
         for decorator in decorator_list {
             self.compile_expression(&decorator.expression)?;
+            emit!(self, Instruction::PushNull);
         }
         Ok(())
     }
 
+    /// Apply decorators in reverse order (LIFO from stack).
+    /// Stack [dec1, NULL, dec2, NULL, func] -> dec2(func) -> dec1(dec2(func))
+    /// The forward loop works because each Call pops from TOS, naturally
+    /// applying decorators bottom-up (innermost first).
     fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
-        // Apply decorators:
         for _ in decorator_list {
             emit!(self, Instruction::Call { nargs: 1 });
         }
@@ -2142,6 +2147,7 @@ impl Compiler {
 
         // Create type params function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
+        emit!(self, Instruction::PushNull);
 
         // Call the function immediately
         emit!(self, Instruction::Call { nargs: 0 });
@@ -3224,11 +3230,6 @@ impl Compiler {
                 num_typeparam_args += 1;
             }
 
-            // SWAP if we have both
-            if num_typeparam_args == 2 {
-                emit!(self, Instruction::Swap { index: 2 });
-            }
-
             // Enter type params scope
             let type_params_name = format!("<generic parameters of {name}>");
             self.push_output(
@@ -3307,14 +3308,29 @@ impl Compiler {
             // Make closure for type params code
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
 
-            // Call the closure
+            // Call the type params closure with defaults/kwdefaults as arguments.
+            // Call protocol: [callable, self_or_null, arg1, ..., argN]
+            // We need to reorder: [args..., closure] -> [closure, NULL, args...]
+            // Using Swap operations to move closure down and insert NULL.
+            // Note: num_typeparam_args is at most 2 (defaults tuple, kwdefaults dict).
             if num_typeparam_args > 0 {
-                emit!(
-                    self,
-                    Instruction::Swap {
-                        index: (num_typeparam_args + 1) as u32
+                match num_typeparam_args {
+                    1 => {
+                        // Stack: [arg1, closure]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
                     }
-                );
+                    2 => {
+                        // Stack: [arg1, arg2, closure]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
+                    }
+                    _ => unreachable!("only defaults and kwdefaults are supported"),
+                }
                 emit!(
                     self,
                     Instruction::Call {
@@ -3322,7 +3338,9 @@ impl Compiler {
                     }
                 );
             } else {
-                // No arguments, just call the closure
+                // Stack: [closure]
+                emit!(self, Instruction::PushNull);
+                // Stack: [closure, NULL]
                 emit!(self, Instruction::Call { nargs: 0 });
             }
         }
@@ -3691,6 +3709,7 @@ impl Compiler {
 
             // Generate class creation code
             emit!(self, Instruction::LoadBuildClass);
+            emit!(self, Instruction::PushNull);
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
@@ -3701,43 +3720,91 @@ impl Compiler {
             self.make_closure(class_code, func_flags)?;
             self.emit_load_const(ConstantData::Str { value: name.into() });
 
-            // Compile original bases
-            let base_count = if let Some(arguments) = arguments {
-                for arg in &arguments.args {
-                    self.compile_expression(arg)?;
+            // Compile bases and call __build_class__
+            // Check for starred bases or **kwargs
+            let has_starred = arguments
+                .is_some_and(|args| args.args.iter().any(|arg| matches!(arg, Expr::Starred(_))));
+            let has_double_star =
+                arguments.is_some_and(|args| args.keywords.iter().any(|kw| kw.arg.is_none()));
+
+            if has_starred || has_double_star {
+                // Use CallFunctionEx for *bases or **kwargs
+                // Stack has: [__build_class__, NULL, class_func, name]
+                // Need to build: args tuple = (class_func, name, *bases, .generic_base)
+
+                // Compile bases with gather_elements (handles starred)
+                let (size, unpack) = if let Some(arguments) = arguments {
+                    self.gather_elements(2, &arguments.args)? // 2 = class_func + name already on stack
+                } else {
+                    // Just class_func and name (no bases)
+                    (2, false)
+                };
+
+                // Add .generic_base as final base
+                emit!(self, Instruction::LoadName(dot_generic_base));
+
+                // Build args tuple
+                if unpack {
+                    // Starred: gather_elements produced tuples on stack
+                    emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)
+                    emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });
+                } else {
+                    // No starred: individual elements on stack
+                    // size includes class_func + name + bases count, +1 for .generic_base
+                    emit!(self, Instruction::BuildTuple { size: size + 1 });
+                }
+
+                // Build kwargs if needed
+                let has_kwargs = arguments.is_some_and(|args| !args.keywords.is_empty());
+                if has_kwargs {
+                    self.compile_keywords(&arguments.unwrap().keywords)?;
                 }
-                arguments.args.len()
+                emit!(self, Instruction::CallFunctionEx { has_kwargs });
             } else {
-                0
-            };
+                // Simple case: no starred bases, no **kwargs
+                // Compile bases normally
+                let base_count = if let Some(arguments) = arguments {
+                    for arg in &arguments.args {
+                        self.compile_expression(arg)?;
+                    }
+                    arguments.args.len()
+                } else {
+                    0
+                };
 
-            // Load .generic_base as the last base
-            emit!(self, Instruction::LoadName(dot_generic_base));
+                // Load .generic_base as the last base
+                emit!(self, Instruction::LoadName(dot_generic_base));
 
-            let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1; // function, name, bases..., generic_base
+                let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
-            // Handle keyword arguments
-            if let Some(arguments) = arguments
-                && !arguments.keywords.is_empty()
-            {
-                for keyword in &arguments.keywords {
-                    if let Some(name) = &keyword.arg {
-                        self.emit_load_const(ConstantData::Str {
+                // Handle keyword arguments (no **kwargs here)
+                if let Some(arguments) = arguments
+                    && !arguments.keywords.is_empty()
+                {
+                    let mut kwarg_names = vec![];
+                    for keyword in &arguments.keywords {
+                        let name = keyword.arg.as_ref().expect(
+                            "keyword argument name must be set (no **kwargs in this branch)",
+                        );
+                        kwarg_names.push(ConstantData::Str {
                             value: name.as_str().into(),
                         });
+                        self.compile_expression(&keyword.value)?;
                     }
-                    self.compile_expression(&keyword.value)?;
+                    self.emit_load_const(ConstantData::Tuple {
+                        elements: kwarg_names,
+                    });
+                    emit!(
+                        self,
+                        Instruction::CallKw {
+                            nargs: nargs
+                                + u32::try_from(arguments.keywords.len())
+                                    .expect("too many keyword arguments")
+                        }
+                    );
+                } else {
+                    emit!(self, Instruction::Call { nargs });
                 }
-                emit!(
-                    self,
-                    Instruction::CallKw {
-                        nargs: nargs
-                            + u32::try_from(arguments.keywords.len())
-                                .expect("too many keyword arguments")
-                    }
-                );
-            } else {
-                emit!(self, Instruction::Call { nargs });
             }
 
             // Return the created class
@@ -3748,21 +3815,22 @@ impl Compiler {
 
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
+            emit!(self, Instruction::PushNull);
             emit!(self, Instruction::Call { nargs: 0 });
         } else {
             // Non-generic class: standard path
             emit!(self, Instruction::LoadBuildClass);
+            emit!(self, Instruction::PushNull);
 
             // Create class function with closure
             self.make_closure(class_code, bytecode::MakeFunctionFlags::empty())?;
             self.emit_load_const(ConstantData::Str { value: name.into() });
 
-            let call = if let Some(arguments) = arguments {
-                self.compile_call_inner(2, arguments)?
+            if let Some(arguments) = arguments {
+                self.compile_call_helper(2, arguments)?;
             } else {
-                CallType::Positional { nargs: 2 }
-            };
-            self.compile_normal_call(call);
+                emit!(self, Instruction::Call { nargs: 2 });
+            }
         }
 
         // Step 4: Apply decorators and store (common to both paths)
@@ -3912,6 +3980,7 @@ impl Compiler {
         // Stack: [..., __exit__]
         // Call __exit__(None, None, None)
         self.set_source_range(with_range);
+        emit!(self, Instruction::PushNull);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
@@ -6087,49 +6156,36 @@ impl Compiler {
     }
 
     fn compile_call(&mut self, func: &Expr, args: &Arguments) -> CompileResult<()> {
-        let method = if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
+        // Method call: obj → LOAD_ATTR_METHOD → [method, self_or_null] → args → CALL
+        // Regular call: func → PUSH_NULL → args → CALL
+        if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
+            // Method call: compile object, then LOAD_ATTR_METHOD
+            // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
             self.compile_expression(value)?;
             let idx = self.name(attr.as_str());
-            emit!(self, Instruction::LoadMethod { idx });
-            true
+            emit!(self, Instruction::LoadAttrMethod { idx });
+            self.compile_call_helper(0, args)?;
         } else {
+            // Regular call: push func, then NULL for self_or_null slot
+            // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
             self.compile_expression(func)?;
-            false
-        };
-        let call = self.compile_call_inner(0, args)?;
-        if method {
-            self.compile_method_call(call)
-        } else {
-            self.compile_normal_call(call)
+            emit!(self, Instruction::PushNull);
+            self.compile_call_helper(0, args)?;
         }
         Ok(())
     }
 
-    fn compile_normal_call(&mut self, ty: CallType) {
-        match ty {
-            CallType::Positional { nargs } => {
-                emit!(self, Instruction::Call { nargs })
-            }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallKw { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallFunctionEx { has_kwargs }),
-        }
-    }
-    fn compile_method_call(&mut self, ty: CallType) {
-        match ty {
-            CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallMethodPositional { nargs })
-            }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallMethodKeyword { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallMethodEx { has_kwargs }),
-        }
-    }
-
-    fn compile_call_inner(
+    /// Compile call arguments and emit the appropriate CALL instruction.
+    /// This is shared between compiler_call and compiler_class.
+    fn compile_call_helper(
         &mut self,
         additional_positional: u32,
         arguments: &Arguments,
-    ) -> CompileResult<CallType> {
-        let count = u32::try_from(arguments.len()).unwrap() + additional_positional;
+    ) -> CompileResult<()> {
+        let args_count = u32::try_from(arguments.len()).expect("too many arguments");
+        let count = args_count
+            .checked_add(additional_positional)
+            .expect("too many arguments");
 
         // Normal arguments:
         let (size, unpack) = self.gather_elements(additional_positional, &arguments.args)?;
@@ -6141,7 +6197,7 @@ impl Compiler {
             }
         }
 
-        let call = if unpack || has_double_star {
+        if unpack || has_double_star {
             // Create a tuple with positional args:
             if unpack {
                 emit!(self, Instruction::BuildTupleFromTuples { size });
@@ -6154,7 +6210,7 @@ impl Compiler {
             if has_kwargs {
                 self.compile_keywords(&arguments.keywords)?;
             }
-            CallType::Ex { has_kwargs }
+            emit!(self, Instruction::CallFunctionEx { has_kwargs });
         } else if !arguments.keywords.is_empty() {
             let mut kwarg_names = vec![];
             for keyword in &arguments.keywords {
@@ -6172,12 +6228,12 @@ impl Compiler {
             self.emit_load_const(ConstantData::Tuple {
                 elements: kwarg_names,
             });
-            CallType::Keyword { nargs: count }
+            emit!(self, Instruction::CallKw { nargs: count });
         } else {
-            CallType::Positional { nargs: count }
-        };
+            emit!(self, Instruction::Call { nargs: count });
+        }
 
-        Ok(call)
+        Ok(())
     }
 
     // Given a vector of expr / star expr generate code which gives either
@@ -6409,6 +6465,7 @@ impl Compiler {
 
         // Create comprehension function with closure
         self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
+        emit!(self, Instruction::PushNull);
 
         // Evaluate iterated item:
         self.compile_expression(&generators[0].iter)?;
@@ -6838,6 +6895,7 @@ impl Compiler {
             match action {
                 UnwindAction::With { is_async } => {
                     // compiler_call_exit_with_nones
+                    emit!(self, Instruction::PushNull);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index 679c5ebade4..44eaca18e11 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -5,136 +5,142 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
   3           0 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RESUME               (0)
 
   2               1 LOAD_GLOBAL          (0, StopIteration)
-                  2 LOAD_CONST           ("spam")
-                  3 CALL                 (1)
-                  4 LOAD_GLOBAL          (1, StopAsyncIteration)
-                  5 LOAD_CONST           ("ham")
-                  6 CALL                 (1)
-                  7 BUILD_TUPLE          (2)
-                  8 GET_ITER
-            >>    9 FOR_ITER             (123)
-                 10 STORE_FAST           (0, stop_exc)
+                  2 PUSH_NULL
+                  3 LOAD_CONST           ("spam")
+                  4 CALL                 (1)
+                  5 LOAD_GLOBAL          (1, StopAsyncIteration)
+                  6 PUSH_NULL
+                  7 LOAD_CONST           ("ham")
+                  8 CALL                 (1)
+                  9 BUILD_TUPLE          (2)
+                 10 GET_ITER
+            >>   11 FOR_ITER             (129)
+                 12 STORE_FAST           (0, stop_exc)
 
-  3              11 LOAD_GLOBAL          (2, self)
-                 12 LOAD_METHOD          (3, subTest)
-                 13 LOAD_GLOBAL          (4, type)
-                 14 LOAD_FAST            (0, stop_exc)
-                 15 CALL                 (1)
-                 16 LOAD_CONST           (("type"))
-                 17 CALL_METHOD_KW       (1)
-                 18 BEFORE_WITH
-                 19 POP_TOP
+  3              13 LOAD_GLOBAL          (2, self)
+                 14 LOAD_ATTR_METHOD     (3, subTest)
+                 15 LOAD_GLOBAL          (4, type)
+                 16 PUSH_NULL
+                 17 LOAD_FAST            (0, stop_exc)
+                 18 CALL                 (1)
+                 19 LOAD_CONST           (("type"))
+                 20 CALL_KW              (1)
+                 21 BEFORE_WITH
+                 22 POP_TOP
 
-  5              20 LOAD_GLOBAL          (5, egg)
-                 21 CALL                 (0)
-                 22 BEFORE_ASYNC_WITH
-                 23 GET_AWAITABLE
-                 24 LOAD_CONST           (None)
-            >>   25 SEND                 (30)
-                 26 YIELD_VALUE          (1)
-                 27 RESUME               (3)
-                 28 JUMP                 (25)
-                 29 CLEANUP_THROW
-            >>   30 END_SEND
-                 31 POP_TOP
+  5              23 LOAD_GLOBAL          (5, egg)
+                 24 PUSH_NULL
+                 25 CALL                 (0)
+                 26 BEFORE_ASYNC_WITH
+                 27 GET_AWAITABLE
+                 28 LOAD_CONST           (None)
+            >>   29 SEND                 (34)
+                 30 YIELD_VALUE          (1)
+                 31 RESUME               (3)
+                 32 JUMP                 (29)
+                 33 CLEANUP_THROW
+            >>   34 END_SEND
+                 35 POP_TOP
 
-  6              32 LOAD_FAST            (0, stop_exc)
-                 33 RAISE_VARARGS        (Raise)
+  6              36 LOAD_FAST            (0, stop_exc)
+                 37 RAISE_VARARGS        (Raise)
 
-  5              34 LOAD_CONST           (None)
-                 35 LOAD_CONST           (None)
-                 36 LOAD_CONST           (None)
-                 37 CALL                 (3)
-                 38 GET_AWAITABLE
+  5              38 PUSH_NULL
                  39 LOAD_CONST           (None)
-            >>   40 SEND                 (45)
-                 41 YIELD_VALUE          (1)
-                 42 RESUME               (3)
-                 43 JUMP                 (40)
-                 44 CLEANUP_THROW
-            >>   45 END_SEND
-                 46 POP_TOP
-                 47 JUMP                 (69)
-                 48 PUSH_EXC_INFO
-                 49 WITH_EXCEPT_START
-                 50 GET_AWAITABLE
-                 51 LOAD_CONST           (None)
-            >>   52 SEND                 (57)
-                 53 YIELD_VALUE          (1)
-                 54 RESUME               (3)
-                 55 JUMP                 (52)
-                 56 CLEANUP_THROW
-            >>   57 END_SEND
-                 58 TO_BOOL
-                 59 POP_JUMP_IF_TRUE     (61)
-                 60 RERAISE              (2)
-            >>   61 POP_TOP
-                 62 POP_EXCEPT
-                 63 POP_TOP
-                 64 POP_TOP
-                 65 JUMP                 (69)
-                 66 COPY                 (3)
+                 40 LOAD_CONST           (None)
+                 41 LOAD_CONST           (None)
+                 42 CALL                 (3)
+                 43 GET_AWAITABLE
+                 44 LOAD_CONST           (None)
+            >>   45 SEND                 (50)
+                 46 YIELD_VALUE          (1)
+                 47 RESUME               (3)
+                 48 JUMP                 (45)
+                 49 CLEANUP_THROW
+            >>   50 END_SEND
+                 51 POP_TOP
+                 52 JUMP                 (74)
+                 53 PUSH_EXC_INFO
+                 54 WITH_EXCEPT_START
+                 55 GET_AWAITABLE
+                 56 LOAD_CONST           (None)
+            >>   57 SEND                 (62)
+                 58 YIELD_VALUE          (1)
+                 59 RESUME               (3)
+                 60 JUMP                 (57)
+                 61 CLEANUP_THROW
+            >>   62 END_SEND
+                 63 TO_BOOL
+                 64 POP_JUMP_IF_TRUE     (66)
+                 65 RERAISE              (2)
+            >>   66 POP_TOP
                  67 POP_EXCEPT
-                 68 RERAISE              (1)
-            >>   69 JUMP                 (95)
-                 70 PUSH_EXC_INFO
-                 71 COPY                 (1)
+                 68 POP_TOP
+                 69 POP_TOP
+                 70 JUMP                 (74)
+                 71 COPY                 (3)
+                 72 POP_EXCEPT
+                 73 RERAISE              (1)
+            >>   74 JUMP                 (100)
+                 75 PUSH_EXC_INFO
+                 76 COPY                 (1)
 
-  7              72 LOAD_GLOBAL          (6, Exception)
-                 73 JUMP_IF_NOT_EXC_MATCH(91)
-                 74 STORE_FAST           (1, ex)
+  7              77 LOAD_GLOBAL          (6, Exception)
+                 78 JUMP_IF_NOT_EXC_MATCH(96)
+                 79 STORE_FAST           (1, ex)
 
-  8              75 LOAD_GLOBAL          (2, self)
-                 76 LOAD_METHOD          (7, assertIs)
-                 77 LOAD_FAST            (1, ex)
-                 78 LOAD_FAST            (0, stop_exc)
-                 79 CALL_METHOD          (2)
-                 80 POP_TOP
-                 81 JUMP                 (86)
-                 82 LOAD_CONST           (None)
-                 83 STORE_FAST           (1, ex)
-                 84 DELETE_FAST          (1, ex)
-                 85 RAISE_VARARGS        (ReraiseFromStack)
-            >>   86 POP_EXCEPT
+  8              80 LOAD_GLOBAL          (2, self)
+                 81 LOAD_ATTR_METHOD     (7, assertIs)
+                 82 LOAD_FAST            (1, ex)
+                 83 LOAD_FAST            (0, stop_exc)
+                 84 CALL                 (2)
+                 85 POP_TOP
+                 86 JUMP                 (91)
                  87 LOAD_CONST           (None)
                  88 STORE_FAST           (1, ex)
                  89 DELETE_FAST          (1, ex)
-                 90 JUMP                 (103)
-            >>   91 RAISE_VARARGS        (ReraiseFromStack)
-                 92 COPY                 (3)
-                 93 POP_EXCEPT
-                 94 RAISE_VARARGS        (ReraiseFromStack)
+                 90 RAISE_VARARGS        (ReraiseFromStack)
+            >>   91 POP_EXCEPT
+                 92 LOAD_CONST           (None)
+                 93 STORE_FAST           (1, ex)
+                 94 DELETE_FAST          (1, ex)
+                 95 JUMP                 (108)
+            >>   96 RAISE_VARARGS        (ReraiseFromStack)
+                 97 COPY                 (3)
+                 98 POP_EXCEPT
+                 99 RAISE_VARARGS        (ReraiseFromStack)
 
- 10         >>   95 LOAD_GLOBAL          (2, self)
-                 96 LOAD_METHOD          (8, fail)
-                 97 LOAD_FAST            (0, stop_exc)
-                 98 FORMAT_SIMPLE
-                 99 LOAD_CONST           (" was suppressed")
-                100 BUILD_STRING         (2)
-                101 CALL_METHOD          (1)
-                102 POP_TOP
-
-  3         >>  103 LOAD_CONST           (None)
-                104 LOAD_CONST           (None)
-                105 LOAD_CONST           (None)
-                106 CALL                 (3)
+ 10         >>  100 LOAD_GLOBAL          (2, self)
+                101 LOAD_ATTR_METHOD     (8, fail)
+                102 LOAD_FAST            (0, stop_exc)
+                103 FORMAT_SIMPLE
+                104 LOAD_CONST           (" was suppressed")
+                105 BUILD_STRING         (2)
+                106 CALL                 (1)
                 107 POP_TOP
-                108 JUMP                 (122)
-                109 PUSH_EXC_INFO
-                110 WITH_EXCEPT_START
-                111 TO_BOOL
-                112 POP_JUMP_IF_TRUE     (114)
-                113 RERAISE              (2)
-            >>  114 POP_TOP
-                115 POP_EXCEPT
-                116 POP_TOP
-                117 POP_TOP
-                118 JUMP                 (122)
-                119 COPY                 (3)
-                120 POP_EXCEPT
-                121 RERAISE              (1)
-            >>  122 JUMP                 (9)
-            >>  123 RETURN_CONST         (None)
+
+  3         >>  108 PUSH_NULL
+                109 LOAD_CONST           (None)
+                110 LOAD_CONST           (None)
+                111 LOAD_CONST           (None)
+                112 CALL                 (3)
+                113 POP_TOP
+                114 JUMP                 (128)
+                115 PUSH_EXC_INFO
+                116 WITH_EXCEPT_START
+                117 TO_BOOL
+                118 POP_JUMP_IF_TRUE     (120)
+                119 RERAISE              (2)
+            >>  120 POP_TOP
+                121 POP_EXCEPT
+                122 POP_TOP
+                123 POP_TOP
+                124 JUMP                 (128)
+                125 COPY                 (3)
+                126 POP_EXCEPT
+                127 RERAISE              (1)
+            >>  128 JUMP                 (11)
+            >>  129 RETURN_CONST         (None)
 
               1 MAKE_FUNCTION
               2 STORE_NAME           (0, test)
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 19380be4713..5020be27c94 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -921,15 +921,6 @@ pub enum Instruction {
     BuildTupleFromTuples {
         size: Arg<u32>,
     } = 124,
-    CallMethodPositional {
-        nargs: Arg<u32>,
-    } = 125,
-    CallMethodKeyword {
-        nargs: Arg<u32>,
-    } = 126,
-    CallMethodEx {
-        has_kwargs: Arg<bool>,
-    } = 127,
     Continue {
         target: Arg<Label>,
     } = 128,
@@ -951,7 +942,7 @@ pub enum Instruction {
         target: Arg<Label>,
     } = 252, // CPython uses pseudo-op 256
     LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
-    LoadMethod {
+    LoadAttrMethod {
         idx: Arg<NameIdx>,
     } = 254, // CPython uses pseudo-op 259
     PopBlock = 255,                  // CPython uses pseudo-op 263
@@ -972,16 +963,51 @@ impl TryFrom<u8> for Instruction {
 
     #[inline]
     fn try_from(value: u8) -> Result<Self, MarshalError> {
+        // CPython-compatible opcodes (0-118)
         let cpython_start = u8::from(Self::Cache);
         let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
 
+        // Resume has a non-contiguous opcode (149)
         let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
 
-        let custom_start = u8::from(Self::Break {
-            target: Arg::marker(),
-        });
-        let custom_end = u8::from(Self::Subscript);
+        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
+        let custom_ops: &[u8] = &[
+            u8::from(Self::Break {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::BuildListFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildMapForCall {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildSetFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildTupleFromIter),
+            u8::from(Self::BuildTupleFromTuples {
+                size: Arg::marker(),
+            }),
+            // 125, 126, 127 are unused
+            u8::from(Self::Continue {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfFalseOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfTrueOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
+            u8::from(Self::LoadClassDeref(Arg::marker())),
+            u8::from(Self::Reverse {
+                amount: Arg::marker(),
+            }),
+            u8::from(Self::SetExcInfo),
+            u8::from(Self::Subscript),
+        ];
 
+        // Pseudo opcodes (252-255)
         let pseudo_start = u8::from(Self::Jump {
             target: Arg::marker(),
         });
@@ -989,7 +1015,7 @@ impl TryFrom<u8> for Instruction {
 
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
-            || (custom_start..=custom_end).contains(&value)
+            || custom_ops.contains(&value)
             || (pseudo_start..=pseudo_end).contains(&value)
         {
             Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
@@ -1775,6 +1801,8 @@ impl Instruction {
             StoreSubscr => -3,
             DeleteSubscr => -2,
             LoadAttr { .. } => 0,
+            // LoadAttrMethod: pop obj, push method + self_or_null
+            LoadAttrMethod { .. } => 1,
             StoreAttr { .. } => -2,
             DeleteAttr { .. } => -1,
             LoadConst { .. } => 1,
@@ -1808,17 +1836,16 @@ impl Instruction {
                 // pops attribute value and function, pushes function back
                 -2 + 1
             }
-            Call { nargs } => -(nargs.get(arg) as i32) - 1 + 1,
-            CallMethodPositional { nargs } => -(nargs.get(arg) as i32) - 3 + 1,
-            CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 1 + 1,
-            CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
-            CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
+            // Call: pops nargs + self_or_null + callable, pushes result
+            Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
+            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
+            CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
+            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
+            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
             CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
             ConvertValue { .. } => 0,
             FormatSimple => 0,
             FormatWithSpec => -1,
-            LoadMethod { .. } => -1 + 3,
             ForIter { .. } => {
                 if jump {
                     -1
@@ -1909,6 +1936,7 @@ impl Instruction {
             UnaryNegative => 0,
             UnaryNot => 0,
             GetYieldFromIter => 0,
+            PushNull => 1, // Push NULL for call protocol
             _ => 0,
         }
     }
@@ -2001,9 +2029,6 @@ impl Instruction {
             CallKw { nargs } => w!(CALL_KW, nargs),
             CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
-            CallMethodEx { has_kwargs } => w!(CALL_METHOD_EX, has_kwargs),
-            CallMethodKeyword { nargs } => w!(CALL_METHOD_KW, nargs),
-            CallMethodPositional { nargs } => w!(CALL_METHOD, nargs),
             CheckEgMatch => w!(CHECK_EG_MATCH),
             CheckExcMatch => w!(CHECK_EXC_MATCH),
             CleanupThrow => w!(CLEANUP_THROW),
@@ -2040,6 +2065,7 @@ impl Instruction {
             JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
             ListAppend { i } => w!(LIST_APPEND, i),
             LoadAttr { idx } => w!(LOAD_ATTR, name = idx),
+            LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             LoadBuildClass => w!(LOAD_BUILD_CLASS),
             LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
             LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
@@ -2048,7 +2074,6 @@ impl Instruction {
             LoadFast(idx) => w!(LOAD_FAST, varname = idx),
             LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
             LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
-            LoadMethod { idx } => w!(LOAD_METHOD, name = idx),
             LoadName(idx) => w!(LOAD_NAME, name = idx),
             MakeFunction => w!(MAKE_FUNCTION),
             MapAdd { i } => w!(MAP_ADD, i),
@@ -2063,6 +2088,7 @@ impl Instruction {
             PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
             PopTop => w!(POP_TOP),
             PushExcInfo => w!(PUSH_EXC_INFO),
+            PushNull => w!(PUSH_NULL),
             RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
             Reraise { depth } => w!(RERAISE, depth),
             Resume { arg } => w!(RESUME, arg),
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 4406cf39d49..055528db7f7 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -27,6 +27,7 @@ enum JitValue {
     Float(Value),
     Bool(Value),
     None,
+    Null,
     Tuple(Vec<JitValue>),
     FuncRef(FuncRef),
 }
@@ -45,14 +46,14 @@ impl JitValue {
             JitValue::Int(_) => Some(JitType::Int),
             JitValue::Float(_) => Some(JitType::Float),
             JitValue::Bool(_) => Some(JitType::Bool),
-            JitValue::None | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
+            JitValue::None | JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
         }
     }
 
     fn into_value(self) -> Option<Value> {
         match self {
             JitValue::Int(val) | JitValue::Float(val) | JitValue::Bool(val) => Some(val),
-            JitValue::None | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
+            JitValue::None | JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
         }
     }
 }
@@ -139,7 +140,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
             JitValue::Bool(val) => Ok(val),
             JitValue::None => Ok(self.builder.ins().iconst(types::I8, 0)),
-            JitValue::Tuple(_) | JitValue::FuncRef(_) => Err(JitCompileError::NotSupported),
+            JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => {
+                Err(JitCompileError::NotSupported)
+            }
         }
     }
 
@@ -463,6 +466,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     args.push(arg.into_value().unwrap());
                 }
 
+                // Pop self_or_null (should be Null for JIT-compiled recursive calls)
+                let self_or_null = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                if !matches!(self_or_null, JitValue::Null) {
+                    return Err(JitCompileError::NotSupported);
+                }
+
                 match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::FuncRef(reference) => {
                         let call = self.builder.ins().call(reference, &args);
@@ -474,6 +483,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
+            Instruction::PushNull => {
+                self.stack.push(JitValue::Null);
+                Ok(())
+            }
             Instruction::CallIntrinsic1 { func } => {
                 match func.get(arg) {
                     IntrinsicFunction1::UnaryPositive => {
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 99cc4130b08..1b920822f5a 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -74,7 +74,7 @@ mod opcode {
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
                         | Instruction::LoadGlobal(_)
-                        | Instruction::LoadMethod { .. }
+                        | Instruction::LoadAttrMethod { .. }
                         | Instruction::LoadName(_)
                         | Instruction::StoreAttr { .. }
                         | Instruction::StoreGlobal(_)
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 275269c5cbe..7e04c900e26 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -53,7 +53,7 @@ enum UnwindReason {
 struct FrameState {
     // We need 1 stack per frame
     /// The main data frame of the stack machine
-    stack: BoxVec<PyObjectRef>,
+    stack: BoxVec<Option<PyObjectRef>>,
     /// index of last instruction ran
     #[cfg(feature = "threading")]
     lasti: u32,
@@ -613,9 +613,8 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::BinarySubscr => {
                 let key = self.pop_value();
                 let container = self.pop_value();
-                self.state
-                    .stack
-                    .push(container.get_item(key.as_object(), vm)?);
+                let result = container.get_item(key.as_object(), vm)?;
+                self.push_value(result);
                 Ok(None)
             }
 
@@ -676,14 +675,11 @@ impl ExecutingFrame<'_> {
             }
             */
             bytecode::Instruction::BuildString { size } => {
-                let s = self
+                let s: Wtf8Buf = self
                     .pop_multiple(size.get(arg) as usize)
-                    .as_slice()
-                    .iter()
-                    .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap())
-                    .collect::<Wtf8Buf>();
-                let str_obj = vm.ctx.new_str(s);
-                self.push_value(str_obj.into());
+                    .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
+                    .collect();
+                self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
             bytecode::Instruction::BuildTupleFromIter => {
@@ -707,16 +703,19 @@ impl ExecutingFrame<'_> {
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+            bytecode::Instruction::Call { nargs } => {
+                // Stack: [callable, self_or_null, arg1, ..., argN]
+                let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
             bytecode::Instruction::CallKw { nargs } => {
+                // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::Call { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
+            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+                // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
             bytecode::Instruction::CallIntrinsic1 { func } => {
@@ -732,18 +731,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CallMethodEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodKeyword { nargs } => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodPositional { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
             bytecode::Instruction::CheckEgMatch => {
                 let match_type = self.pop_value();
                 let exc_value = self.pop_value();
@@ -788,7 +775,7 @@ impl ExecutingFrame<'_> {
                     panic!("CopyItem: stack underflow");
                 }
                 let value = self.state.stack[stack_len - idx].clone();
-                self.push_value(value);
+                self.push_value_opt(value);
                 Ok(None)
             }
             bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
@@ -1177,20 +1164,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadMethod { idx } => {
-                let obj = self.pop_value();
-                let method_name = self.code.names[idx.get(arg) as usize];
-                let method = PyMethod::get(obj, method_name, vm)?;
-                let (target, is_method, func) = match method {
-                    PyMethod::Function { target, func } => (target, true, func),
-                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
-                };
-                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
-                // target==NULL, maybe we could use a sentinel value or something?
-                self.push_value(target);
-                self.push_value(vm.ctx.new_bool(is_method).into());
-                self.push_value(func);
-                Ok(None)
+            bytecode::Instruction::LoadAttrMethod { idx } => {
+                self.load_attr_method(vm, idx.get(arg))
             }
             bytecode::Instruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
@@ -1457,6 +1432,11 @@ impl ExecutingFrame<'_> {
                 self.pop_value();
                 Ok(None)
             }
+            bytecode::Instruction::PushNull => {
+                // Push NULL for self_or_null slot in call protocol
+                self.push_null();
+                Ok(None)
+            }
             bytecode::Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
             bytecode::Instruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start
@@ -1666,7 +1646,10 @@ impl ExecutingFrame<'_> {
                 let exc = vm.current_exception();
 
                 let stack_len = self.state.stack.len();
-                let exit = self.state.stack[stack_len - 4].clone();
+                let exit = expect_unchecked(
+                    self.state.stack[stack_len - 4].clone(),
+                    "WithExceptStart: __exit__ is NULL",
+                );
 
                 let args = if let Some(ref exc) = exc {
                     vm.split_exception(exc.clone())
@@ -1909,7 +1892,7 @@ impl ExecutingFrame<'_> {
                 {
                     // 1. Pop stack to entry.depth
                     while self.state.stack.len() > entry.depth as usize {
-                        self.pop_value();
+                        self.state.stack.pop();
                     }
 
                     // 2. If push_lasti=true (SETUP_CLEANUP), push lasti before exception
@@ -2132,31 +2115,25 @@ impl ExecutingFrame<'_> {
 
     #[inline]
     fn execute_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
-        let func_ref = self.pop_value();
-        let value = func_ref.call(args, vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
-    #[inline]
-    fn execute_method_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
-        let func = self.pop_value();
-        let is_method = self.pop_value().is(&vm.ctx.true_value);
-        let target = self.pop_value();
-
-        // TODO: It was PyMethod before #4873. Check if it's correct.
-        let func = if is_method {
-            if let Some(descr_get) = func.class().slots.descr_get.load() {
-                let cls = target.class().to_owned().into();
-                descr_get(func, Some(target), Some(cls), vm)?
-            } else {
-                func
+        // Stack: [callable, self_or_null, ...]
+        let self_or_null = self.pop_value_opt(); // Option<PyObjectRef>
+        let callable = self.pop_value();
+
+        // If self_or_null is Some (not NULL), prepend it to args
+        let final_args = if let Some(self_val) = self_or_null {
+            // Method call: prepend self to args
+            let mut all_args = vec![self_val];
+            all_args.extend(args.args);
+            FuncArgs {
+                args: all_args,
+                kwargs: args.kwargs,
             }
         } else {
-            drop(target); // should be None
-            func
+            // Regular attribute call: self_or_null is NULL
+            args
         };
-        let value = func.call(args, vm)?;
+
+        let value = callable.call(final_args, vm)?;
         self.push_value(value);
         Ok(None)
     }
@@ -2253,14 +2230,16 @@ impl ExecutingFrame<'_> {
         // Elements on stack from right-to-left:
         self.state
             .stack
-            .extend(elements.drain(before + middle..).rev());
+            .extend(elements.drain(before + middle..).rev().map(Some));
 
         let middle_elements = elements.drain(before..).collect();
         let t = vm.ctx.new_list(middle_elements);
         self.push_value(t.into());
 
         // Lastly the first reversed values:
-        self.state.stack.extend(elements.into_iter().rev());
+        self.state
+            .stack
+            .extend(elements.into_iter().rev().map(Some));
 
         Ok(None)
     }
@@ -2353,8 +2332,8 @@ impl ExecutingFrame<'_> {
         // Stack: [..., attr_value, func] -> [..., func]
         // Stack order: func is at -1, attr_value is at -2
 
-        let func = self.pop_value();
-        let attr_value = self.replace_top(func);
+        let func = self.pop_value_opt();
+        let attr_value = expect_unchecked(self.replace_top(func), "attr_value must not be null");
 
         let func = self.top_value();
         // Get the function reference and call the new method
@@ -2450,7 +2429,10 @@ impl ExecutingFrame<'_> {
         })?;
         let msg = match elements.len().cmp(&(size as usize)) {
             core::cmp::Ordering::Equal => {
-                self.state.stack.extend(elements.into_iter().rev());
+                // Wrap each element in Some() for Option<PyObjectRef> stack
+                self.state
+                    .stack
+                    .extend(elements.into_iter().rev().map(Some));
                 return Ok(None);
             }
             core::cmp::Ordering::Greater => {
@@ -2511,14 +2493,35 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn load_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize];
+    fn load_attr(&mut self, vm: &VirtualMachine, idx: u32) -> FrameResult {
+        // Regular attribute access: pop obj, push attr
+        let attr_name = self.code.names[idx as usize];
         let parent = self.pop_value();
         let obj = parent.get_attr(attr_name, vm)?;
         self.push_value(obj);
         Ok(None)
     }
 
+    fn load_attr_method(&mut self, vm: &VirtualMachine, idx: u32) -> FrameResult {
+        // Method call: pop obj, push [method, self_or_null]
+        let attr_name = self.code.names[idx as usize];
+        let parent = self.pop_value();
+
+        match PyMethod::get(parent, attr_name, vm)? {
+            PyMethod::Function { target, func } => {
+                // Method descriptor found: push [method, self]
+                self.push_value(func);
+                self.push_value(target);
+            }
+            PyMethod::Attribute(val) => {
+                // Regular attribute: push [attr, NULL]
+                self.push_value(val);
+                self.push_null();
+            }
+        }
+        Ok(None)
+    }
+
     fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
         let attr_name = self.code.names[attr as usize];
         let parent = self.pop_value();
@@ -2537,13 +2540,8 @@ impl ExecutingFrame<'_> {
     // Block stack functions removed - exception table handles all exception/cleanup
 
     #[inline]
-    #[track_caller] // not a real track_caller but push_value is not very useful
-    fn push_value(&mut self, obj: PyObjectRef) {
-        // eprintln!(
-        //     "push_value {} / len: {} +1",
-        //     obj.class().name(),
-        //     self.state.stack.len()
-        // );
+    #[track_caller] // not a real track_caller but push_value is less useful for debugging
+    fn push_value_opt(&mut self, obj: Option<PyObjectRef>) {
         match self.state.stack.try_push(obj) {
             Ok(()) => {}
             Err(_e) => self.fatal("tried to push value onto stack but overflowed max_stackdepth"),
@@ -2551,21 +2549,34 @@ impl ExecutingFrame<'_> {
     }
 
     #[inline]
-    #[track_caller] // not a real track_caller but pop_value is not very useful
-    fn pop_value(&mut self) -> PyObjectRef {
+    #[track_caller]
+    fn push_value(&mut self, obj: PyObjectRef) {
+        self.push_value_opt(Some(obj));
+    }
+
+    #[inline]
+    fn push_null(&mut self) {
+        self.push_value_opt(None);
+    }
+
+    /// Pop a value from the stack, returning None if the stack slot is NULL
+    #[inline]
+    fn pop_value_opt(&mut self) -> Option<PyObjectRef> {
         match self.state.stack.pop() {
-            Some(x) => {
-                // eprintln!(
-                //     "pop_value {} / len: {}",
-                //     x.class().name(),
-                //     self.state.stack.len()
-                // );
-                x
-            }
-            None => self.fatal("tried to pop value but there was nothing on the stack"),
+            Some(slot) => slot, // slot is Option<PyObjectRef>
+            None => self.fatal("tried to pop from empty stack"),
         }
     }
 
+    #[inline]
+    #[track_caller]
+    fn pop_value(&mut self) -> PyObjectRef {
+        expect_unchecked(
+            self.pop_value_opt(),
+            "pop value but null found. This is a compiler bug.",
+        )
+    }
+
     fn call_intrinsic_1(
         &mut self,
         func: bytecode::IntrinsicFunction1,
@@ -2691,7 +2702,8 @@ impl ExecutingFrame<'_> {
         }
     }
 
-    fn pop_multiple(&mut self, count: usize) -> crate::common::boxvec::Drain<'_, PyObjectRef> {
+    /// Pop multiple values from the stack. Panics if any slot is NULL.
+    fn pop_multiple(&mut self, count: usize) -> impl ExactSizeIterator<Item = PyObjectRef> + '_ {
         let stack_len = self.state.stack.len();
         if count > stack_len {
             let instr = self.code.instructions.get(self.lasti() as usize);
@@ -2708,21 +2720,24 @@ impl ExecutingFrame<'_> {
                 self.code.source_path
             );
         }
-        self.state.stack.drain(stack_len - count..)
+        self.state.stack.drain(stack_len - count..).map(|obj| {
+            expect_unchecked(obj, "pop_multiple but null found. This is a compiler bug.")
+        })
     }
 
     #[inline]
-    fn replace_top(&mut self, mut top: PyObjectRef) -> PyObjectRef {
+    fn replace_top(&mut self, mut top: Option<PyObjectRef>) -> Option<PyObjectRef> {
         let last = self.state.stack.last_mut().unwrap();
-        core::mem::swap(&mut top, last);
+        core::mem::swap(last, &mut top);
         top
     }
 
     #[inline]
-    #[track_caller] // not a real track_caller but top_value is not very useful
+    #[track_caller]
     fn top_value(&self) -> &PyObject {
         match &*self.state.stack {
-            [.., last] => last,
+            [.., Some(last)] => last,
+            [.., None] => self.fatal("tried to get top of stack but got NULL"),
             [] => self.fatal("tried to get top of stack but stack is empty"),
         }
     }
@@ -2731,7 +2746,10 @@ impl ExecutingFrame<'_> {
     #[track_caller]
     fn nth_value(&self, depth: u32) -> &PyObject {
         let stack = &self.state.stack;
-        &stack[stack.len() - depth as usize - 1]
+        match &stack[stack.len() - depth as usize - 1] {
+            Some(obj) => obj,
+            None => unsafe { std::hint::unreachable_unchecked() },
+        }
     }
 
     #[cold]
@@ -2746,11 +2764,17 @@ impl ExecutingFrame<'_> {
 impl fmt::Debug for Frame {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let state = self.state.lock();
-        let stack_str = state.stack.iter().fold(String::new(), |mut s, elem| {
-            if elem.downcastable::<Self>() {
-                s.push_str("\n  > {frame}");
-            } else {
-                core::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
+        let stack_str = state.stack.iter().fold(String::new(), |mut s, slot| {
+            match slot {
+                Some(elem) if elem.downcastable::<Self>() => {
+                    s.push_str("\n  > {frame}");
+                }
+                Some(elem) => {
+                    core::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
+                }
+                None => {
+                    s.push_str("\n  > NULL");
+                }
             }
             s
         });
@@ -2777,3 +2801,11 @@ fn is_module_initializing(module: &PyObject, vm: &VirtualMachine) -> bool {
     };
     initializing_attr.try_to_bool(vm).unwrap_or(false)
 }
+
+fn expect_unchecked(optional: Option<PyObjectRef>, err_msg: &'static str) -> PyObjectRef {
+    if cfg!(debug_assertions) {
+        optional.expect(err_msg)
+    } else {
+        unsafe { optional.unwrap_unchecked() }
+    }
+}
diff --git a/crates/vm/src/vm/method.rs b/crates/vm/src/vm/method.rs
index ba323391488..b964a974c5a 100644
--- a/crates/vm/src/vm/method.rs
+++ b/crates/vm/src/vm/method.rs
@@ -3,8 +3,8 @@
 
 use super::VirtualMachine;
 use crate::{
-    builtins::{PyBaseObject, PyStr, PyStrInterned},
-    function::IntoFuncArgs,
+    builtins::{PyBaseObject, PyStr, PyStrInterned, descriptor::PyMethodDescriptor},
+    function::{IntoFuncArgs, PyMethodFlags},
     object::{AsObject, Py, PyObject, PyObjectRef, PyResult},
     types::PyTypeFlags,
 };
@@ -38,8 +38,15 @@ impl PyMethod {
                     .flags
                     .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
                 {
-                    is_method = true;
-                    None
+                    // For classmethods, we need descr_get to convert instance to class
+                    if let Some(method_descr) = descr.downcast_ref::<PyMethodDescriptor>()
+                        && method_descr.method.flags.contains(PyMethodFlags::CLASS)
+                    {
+                        descr_cls.slots.descr_get.load()
+                    } else {
+                        is_method = true;
+                        None
+                    }
                 } else {
                     let descr_get = descr_cls.slots.descr_get.load();
                     if let Some(descr_get) = descr_get

From d4be424bf62fcc41fe8a79e2576358f9e9c8d792 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 10 Jan 2026 08:26:12 +0900
Subject: [PATCH 200/418] Bump indexmap from 2.12.1 to 2.13.0 (#6681)

Bumps [indexmap](https://github.com/indexmap-rs/indexmap) from 2.12.1 to 2.13.0.
- [Changelog](https://github.com/indexmap-rs/indexmap/blob/main/RELEASES.md)
- [Commits](https://github.com/indexmap-rs/indexmap/compare/2.12.1...2.13.0)

---
updated-dependencies:
- dependency-name: indexmap
  dependency-version: 2.13.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3b676e2a785..3a0f99ddd44 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1458,9 +1458,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.12.1"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
  "hashbrown 0.16.1",
diff --git a/Cargo.toml b/Cargo.toml
index a7ac9ee4999..13bf531bc0e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -162,7 +162,7 @@ flame = "0.2.2"
 getrandom = { version = "0.3", features = ["std"] }
 glob = "0.3"
 hex = "0.4.3"
-indexmap = { version = "2.11.3", features = ["std"] }
+indexmap = { version = "2.13.0", features = ["std"] }
 insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"

From f2224de8d7c0a1b14189958d9c28a94a7bafc7fb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 10 Jan 2026 08:26:41 +0900
Subject: [PATCH 201/418] Bump cranelift-jit from 0.127.0 to 0.127.1 (#6682)

Bumps [cranelift-jit](https://github.com/bytecodealliance/wasmtime) from 0.127.0 to 0.127.1.
- [Release notes](https://github.com/bytecodealliance/wasmtime/releases)
- [Changelog](https://github.com/bytecodealliance/wasmtime/blob/main/RELEASES.md)
- [Commits](https://github.com/bytecodealliance/wasmtime/commits)

---
updated-dependencies:
- dependency-name: cranelift-jit
  dependency-version: 0.127.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 64 +++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3a0f99ddd44..bf7d5bf1ae3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -702,42 +702,42 @@ dependencies = [
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bd963a645179fa33834ba61fa63353998543b07f877e208da9eb47d4a70d1e7"
+checksum = "ff9edf1a79ff137b5c9bc74aff5d8467a8bea67722d9f4a2a0dc555504e8dc66"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6d5739c9dc6b5553ca758d78d87d127dd19f397f776efecf817b8ba8d0bb01"
+checksum = "0ed408aad286cb6433f3e361268b588566ac138dc0d8cf1c22af822c004250ad"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff402c11bb1c9652b67a3e885e84b1b8d00c13472c8fd85211e06a41a63c3e03"
+checksum = "efddb47bd7fc6fb0fe9387a82c4cf1987b7402fefa694f73be1f3ae2b26663ab"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "769a0d88c2f5539e9c5536a93a7bf164b0dc68d91e3d00723e5b4ffc1440afdc"
+checksum = "2922de888b20fedaff065be5a4044f5c3c13cb1132db8f1f56f7a5c03a768c81"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4351f721fb3b26add1c180f0a75c7474bab2f903c8b777c6ca65238ded59a78"
+checksum = "0d3172ca7ba0bf31cae6dd4dffbfc33e0afe5994eb3ec29608d0ab14bcb674cb"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -761,9 +761,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61f86c0ba5b96713643f4dd0de0df12844de9c7bb137d6829b174b706939aa74"
+checksum = "e2bad8d14320124ea673cb11b7db0176470279b7ec1d0f201f79a7c0213f52f6"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -773,24 +773,24 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f08605eee8d51fd976a970bd5b16c9529b51b624f8af68f80649ffb172eb85a4"
+checksum = "c414fe1c62e61d269a928594bd0f10fb6fa707e112b433fc19cc8d5aeaf08fda"
 
 [[package]]
 name = "cranelift-control"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "623aab0a09e40f0cf0b5d35eb7832bae4c4f13e3768228e051a6c1a60e88ef5f"
+checksum = "fac90ac0e9a0dd900a880ee6b56f36e37ca5017af9f7d1390805dcb6f35e4064"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea0f066e07e3bcbe38884cc5c94c32c7a90267d69df80f187d9dfe421adaa7c4"
+checksum = "5c63209c9b060b3048b2cc6483bdba85e93118268d14b3ce1452615e7cb42010"
 dependencies = [
  "cranelift-bitset",
 ]
@@ -809,15 +809,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "104b3c117ae513e9af1d90679842101193a5ccb96ac9f997966d85ea25be2852"
+checksum = "316dd3048717d1ad577d23fb2773671bc4fe633b651bb0d41be79d1a2dd0121b"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3aa5f855cfb8e4253ed2d0dfc1a0b6ebe4912e67aa8b7ee14026ff55ca17f1fe"
+checksum = "e0c1c762faecc6e30a4ebb8f36ad980a5211afc2e037daf0095983c287f8d0f9"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -835,9 +835,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d01806b191b59f4fc4680293dd5f554caf2de5b62f95eff5beef7acb46c29c"
+checksum = "1d29cd90f94cdc63c56eb7f81813072a654bb9723d9aceb382fad752f9a8e7f8"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -846,9 +846,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5c54e0a358bc05b48f2032e1c320e7f468da068604f2869b77052eab68eb0fe"
+checksum = "5dc065eb9d570d70360d9eceb5be0faf1e5871aa53973389a4a9d37bf2c748b5"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -857,9 +857,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc6f4b039f453b66c75e9f7886e5a2af96276e151f44dc19b24b58f9a0c98009"
+checksum = "4a628782eefce8d87340a08f635d19e55e2900a77706f56b75cf73f1efc880a3"
 
 [[package]]
 name = "crc32fast"
@@ -4293,9 +4293,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "40.0.0"
+version = "40.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0858b470463f3e7c73acd6049046049e64be17b98901c2db5047450cf83df1fe"
+checksum = "3b4462e93068c8d73847a9d69c371b9dd8106cf020a736d43cdca519a20703b3"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -4305,9 +4305,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-math"
-version = "40.0.0"
+version = "40.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222e1a590ece4e898f20af1e541b61d2cb803f2557e7eaff23e6c1db5434454a"
+checksum = "50a77e2f3f9009c5af4abb0c2875f64ab5f7c04875b3bcb8a8a120e22cdffe70"
 dependencies = [
  "libm",
 ]

From 91f0d70c0c7ad7996107ade23a58fd40616e66bc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 10 Jan 2026 08:30:42 +0900
Subject: [PATCH 202/418] Bump syn from 2.0.113 to 2.0.114 (#6679)

Bumps [syn](https://github.com/dtolnay/syn) from 2.0.113 to 2.0.114.
- [Release notes](https://github.com/dtolnay/syn/releases)
- [Commits](https://github.com/dtolnay/syn/compare/2.0.113...2.0.114)

---
updated-dependencies:
- dependency-name: syn
  dependency-version: 2.0.114
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bf7d5bf1ae3..42ca74be034 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3662,9 +3662,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.113"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678faa00651c9eb72dd2020cbdf275d92eccb2400d568e419efdd64838145cb4"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",

From 95f5a5b24011ce20ee612b074f57f73c6d6fab02 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 10 Jan 2026 09:33:40 +0900
Subject: [PATCH 203/418] Bump cranelift from 0.127.0 to 0.127.1 (#6680)

Bumps [cranelift](https://github.com/bytecodealliance/wasmtime) from 0.127.0 to 0.127.1.
- [Release notes](https://github.com/bytecodealliance/wasmtime/releases)
- [Changelog](https://github.com/bytecodealliance/wasmtime/blob/main/RELEASES.md)
- [Commits](https://github.com/bytecodealliance/wasmtime/commits)

---
updated-dependencies:
- dependency-name: cranelift
  dependency-version: 0.127.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 42ca74be034..2694e65e2c7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -691,9 +691,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "513887fe45ce3979a4766ddc9992c3cdbf509add2a31906350649423a1d0d287"
+checksum = "9849e5e1589a1d7b9e8a27cbf55747bd5d262ed72ac06c97d824adfc97a93652"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -797,9 +797,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.127.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40865b02a0e52ca8e580ad64feef530cb1d05f6bb4972b4eef05e3eaeae81701"
+checksum = "e42ad0eeaa7f2c365a06ec50580ff6820f1ef45de1c784e8080f5b24bbe3a634"
 dependencies = [
  "cranelift-codegen",
  "log",

From 53feed592095c415fd402b9dbb442e242797a2ef Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:10:18 +0900
Subject: [PATCH 204/418] Bump libc from 0.2.179 to 0.2.180 (#6683)

* Bump libc from 0.2.179 to 0.2.180

Bumps [libc](https://github.com/rust-lang/libc) from 0.2.179 to 0.2.180.
- [Release notes](https://github.com/rust-lang/libc/releases)
- [Changelog](https://github.com/rust-lang/libc/blob/0.2.180/CHANGELOG.md)
- [Commits](https://github.com/rust-lang/libc/compare/0.2.179...0.2.180)

---
updated-dependencies:
- dependency-name: libc
  dependency-version: 0.2.180
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Fix musl compatibility in libc 0.2.180 bump (#6684)

* Bump libc from 0.2.179 to 0.2.180

Bumps [libc](https://github.com/rust-lang/libc) from 0.2.179 to 0.2.180.
- [Release notes](https://github.com/rust-lang/libc/releases)
- [Changelog](https://github.com/rust-lang/libc/blob/0.2.180/CHANGELOG.md)
- [Commits](https://github.com/rust-lang/libc/compare/0.2.179...0.2.180)

---
updated-dependencies:
- dependency-name: libc
  dependency-version: 0.2.180
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

* Initial plan

* Revert os.rs changes by removing newly added files

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

* Fix musl compatibility by removing target_env musl from cfg

Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>
Co-authored-by: youknowone <69878+youknowone@users.noreply.github.com>
---
 Cargo.lock                 | 4 ++--
 Cargo.toml                 | 2 +-
 crates/vm/src/stdlib/os.rs | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2694e65e2c7..f922088ef99 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1681,9 +1681,9 @@ checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
 name = "libc"
-version = "0.2.179"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5a2d376baa530d1238d133232d15e239abad80d05838b4b59354e5268af431f"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[package]]
 name = "libffi"
diff --git a/Cargo.toml b/Cargo.toml
index 13bf531bc0e..a40744841c5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -167,7 +167,7 @@ insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
 junction = "1.3.0"
-libc = "0.2.179"
+libc = "0.2.180"
 libffi = "5"
 log = "0.4.29"
 nix = { version = "0.30", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
index 415097b90d8..00f2aea1dbd 100644
--- a/crates/vm/src/stdlib/os.rs
+++ b/crates/vm/src/stdlib/os.rs
@@ -918,7 +918,7 @@ pub(super) mod _os {
         fn from_stat(stat: &StatStruct, vm: &VirtualMachine) -> Self {
             let (atime, mtime, ctime);
             #[cfg(any(unix, windows))]
-            #[cfg(not(any(target_os = "netbsd", target_os = "wasi", target_env = "musl")))]
+            #[cfg(not(any(target_os = "netbsd", target_os = "wasi")))]
             {
                 atime = (stat.st_atime, stat.st_atime_nsec);
                 mtime = (stat.st_mtime, stat.st_mtime_nsec);
@@ -930,7 +930,7 @@ pub(super) mod _os {
                 mtime = (stat.st_mtime, stat.st_mtimensec);
                 ctime = (stat.st_ctime, stat.st_ctimensec);
             }
-            #[cfg(any(target_os = "wasi", target_env = "musl"))]
+            #[cfg(target_os = "wasi")]
             {
                 atime = (stat.st_atim.tv_sec, stat.st_atim.tv_nsec);
                 mtime = (stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec);

From 0cd6eb7b13fa0a585e66888127535156ee310c7c Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Sat, 10 Jan 2026 15:26:49 +0900
Subject: [PATCH 205/418] Write profile even if failed (#6685)

---
 src/lib.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index c6de6520de8..77c9095ad41 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -276,11 +276,11 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         }
         RunMode::Repl => Ok(()),
     };
-    if is_repl || vm.state.config.settings.inspect {
-        shell::run_shell(vm, scope)?;
+    let result = if is_repl || vm.state.config.settings.inspect {
+        shell::run_shell(vm, scope)
     } else {
-        res?;
-    }
+        res
+    };
 
     #[cfg(feature = "flame-it")]
     {
@@ -289,7 +289,8 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
             error!("Error writing profile information: {}", e);
         }
     }
-    Ok(())
+
+    result
 }
 
 #[cfg(feature = "flame-it")]

From e835ce92753c0c88b86fa2788be0c4fe7a67b463 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 16:32:26 +0900
Subject: [PATCH 206/418] Make ready_to_import always remove tempdir from
 sys.path (#6687)

---
 Lib/test/support/import_helper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index 2b91bdcf9cd..a4ea5bc6af9 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -303,8 +303,8 @@ def ready_to_import(name=None, source=""):
         try:
             sys.path.insert(0, tempdir)
             yield name, path
-            sys.path.remove(tempdir)
         finally:
+            sys.path.remove(tempdir)
             if old_module is not None:
                 sys.modules[name] = old_module
             else:

From 8c157990cf0f5ab18947a5a75367f9afade0ceab Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 10 Jan 2026 02:38:21 -0500
Subject: [PATCH 207/418] Updated test_contextlib_async.py (#6686)

---
 Lib/test/test_contextlib_async.py | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/Lib/test/test_contextlib_async.py b/Lib/test/test_contextlib_async.py
index 0cf32abb76f..b24599f0581 100644
--- a/Lib/test/test_contextlib_async.py
+++ b/Lib/test/test_contextlib_async.py
@@ -120,8 +120,7 @@ async def woohoo():
                 raise ZeroDivisionError()
         self.assertEqual(state, [1, 42, 999])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_contextmanager_traceback(self):
         @asynccontextmanager
         async def f():
@@ -253,8 +252,7 @@ async def woohoo():
             raise ZeroDivisionError(999)
         self.assertEqual(state, [1, 42, 999])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_contextmanager_except_stopiter(self):
         @asynccontextmanager
         async def woohoo():
@@ -535,11 +533,6 @@ def __exit__(self, *exc_details):
         ('__aexit__', 'cb_suppress = cb(*exc_details)'),
     ]
 
-    # TODO: RUSTPYTHON - no _asyncio module, pure Python Task adds extra frame
-    @unittest.expectedFailure
-    def test_exit_exception_traceback(self):
-        super().test_exit_exception_traceback()
-
     async def test_async_callback(self):
         expected = [
             ((), {}),
@@ -657,8 +650,7 @@ async def __aenter__(self):
                 await stack.enter_async_context(LacksExit())
             self.assertFalse(stack._exit_callbacks)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_async_exit_exception_chaining(self):
         # Ensure exception chaining matches the reference behaviour
         async def raise_exc(exc):
@@ -690,8 +682,7 @@ async def suppress_exc(*exc_details):
         self.assertIsInstance(inner_exc, ValueError)
         self.assertIsInstance(inner_exc.__context__, ZeroDivisionError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     async def test_async_exit_exception_explicit_none_context(self):
         # Ensure AsyncExitStack chaining matches actual nested `with` statements
         # regarding explicit __context__ = None.
@@ -737,6 +728,10 @@ class Example(object): pass
         stack.push_async_exit(cm)
         self.assertIs(stack._exit_callbacks[-1][1], cm)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; - no _asyncio module, pure Python Task adds extra frame
+    def test_exit_exception_traceback(self):
+        return super().test_exit_exception_traceback()
+
 
 class TestAsyncNullcontext(unittest.IsolatedAsyncioTestCase):
     async def test_async_nullcontext(self):

From 9291178b011481d9891ac28e1b59472eefdcd3ab Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 10:33:11 +0200
Subject: [PATCH 208/418] Ci gen opcode metadata (#6677)

* Autogen opcode metadata

* Manually modify opcode metadata
---
 .github/workflows/ci.yaml             | 8 ++++++++
 .github/workflows/pr-auto-commit.yaml | 1 +
 Lib/_opcode_metadata.py               | 4 ++++
 3 files changed, 13 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index dc7b4bc502d..06cf06970a8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -324,12 +324,20 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
         with:
             components: clippy
+
       - name: run clippy on wasm
         run: cargo clippy --manifest-path=crates/wasm/Cargo.toml -- -Dwarnings
 
       - name: Ensure docs generate no warnings
         run: cargo doc
 
+      - name: Ensure Lib/_opcode_metadata is updated
+        run: |
+          python scripts/generate_opcode_metadata.py
+          if [ -z "$(git status --porcelain)" ]; then
+            exit 1
+          fi
+
       - name: Install ruff
         uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
         with:
diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
index 0cbd2bfefb0..203a42a61fe 100644
--- a/.github/workflows/pr-auto-commit.yaml
+++ b/.github/workflows/pr-auto-commit.yaml
@@ -47,6 +47,7 @@ jobs:
 
       - run: ruff format
       - run: ruff check --select I --fix
+      - run: python scripts/generate_opcode_metadata.py
 
       - name: Configure git
         run: |
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 5734d6141a4..5cfb2f40f34 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -4,6 +4,10 @@
 
 _specializations = {}
 
+
+
+
+
 _specialized_opmap = {}
 
 opmap = {

From 6fe05987f0b477b7f0b18805b6ae3ced26389c24 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 11:55:15 +0200
Subject: [PATCH 209/418] Remove `Reverse` bytecode (#6675)

* Remove `Reverse` bytecode

* Update crates/compiler-core/src/bytecode.rs

Co-authored-by: Jeong, YunWon <69878+youknowone@users.noreply.github.com>

* Gen

* Remove Reverse

* Auto-format: cargo fmt --all

* Revert comment

* Remove debug code

* Fix CI

---------

Co-authored-by: Jeong, YunWon <69878+youknowone@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yaml            | 2 +-
 Lib/_opcode_metadata.py              | 5 -----
 crates/compiler-core/src/bytecode.rs | 8 --------
 crates/vm/src/frame.rs               | 5 -----
 scripts/generate_opcode_metadata.py  | 2 --
 5 files changed, 1 insertion(+), 21 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 06cf06970a8..d075a9cd280 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -334,7 +334,7 @@ jobs:
       - name: Ensure Lib/_opcode_metadata is updated
         run: |
           python scripts/generate_opcode_metadata.py
-          if [ -z "$(git status --porcelain)" ]; then
+          if [ -n "$(git status --porcelain)" ]; then
             exit 1
           fi
 
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 5cfb2f40f34..e72a76a576c 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -4,10 +4,6 @@
 
 _specializations = {}
 
-
-
-
-
 _specialized_opmap = {}
 
 opmap = {
@@ -141,7 +137,6 @@
     'JUMP_IF_TRUE_OR_POP': 130,
     'JUMP_IF_NOT_EXC_MATCH': 131,
     'LOAD_CLASS_DEREF': 132,
-    'REVERSE': 133,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
     'RESUME': 149,
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 5020be27c94..0c4522e9f99 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -932,9 +932,6 @@ pub enum Instruction {
     } = 130,
     JumpIfNotExcMatch(Arg<Label>) = 131,
     LoadClassDeref(Arg<NameIdx>) = 132,
-    Reverse {
-        amount: Arg<u32>,
-    } = 133,
     SetExcInfo = 134,
     Subscript = 135,
     // ===== Pseudo Opcodes (252+) ======
@@ -1000,9 +997,6 @@ impl TryFrom<u8> for Instruction {
             }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
             u8::from(Self::LoadClassDeref(Arg::marker())),
-            u8::from(Self::Reverse {
-                amount: Arg::marker(),
-            }),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
         ];
@@ -1922,7 +1916,6 @@ impl Instruction {
                 -1 + before as i32 + 1 + after as i32
             }
             PopExcept => 0,
-            Reverse { .. } => 0,
             GetAwaitable => 0,
             BeforeAsyncWith => 1,
             GetAIter => 0,
@@ -2094,7 +2087,6 @@ impl Instruction {
             Resume { arg } => w!(RESUME, arg),
             ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
             ReturnValue => w!(RETURN_VALUE),
-            Reverse { amount } => w!(REVERSE, amount),
             Send { target } => w!(SEND, target),
             SetAdd { i } => w!(SET_ADD, i),
             SetExcInfo => w!(SET_EXC_INFO),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 7e04c900e26..32429a7d97e 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1458,11 +1458,6 @@ impl ExecutingFrame<'_> {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::Reverse { amount } => {
-                let stack_len = self.state.stack.len();
-                self.state.stack[stack_len - amount.get(arg) as usize..stack_len].reverse();
-                Ok(None)
-            }
             bytecode::Instruction::SetAdd { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index 4ebdfd81776..5c0c3811259 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -25,8 +25,6 @@ def cpython_name(self) -> str:
         name = self.rust_name
         name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name)
         return re.sub(r"(\D)(\d+)$", r"\1_\2", name).upper()
-        return re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", self.rust_name).upper()
-        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.rust_name).upper()
 
     @classmethod
     def from_str(cls, body: str):

From 2d3ef8623139bfbdcdf5a4b4662dc5039bd7340e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 19:49:40 +0900
Subject: [PATCH 210/418] fix SSL callback (#6688)

* fix SSL callback

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/stdlib/src/ssl.rs | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 5a219baaf7f..31973a84f89 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -1,4 +1,4 @@
-// spell-checker: ignore ssleof aesccm aesgcm getblocking setblocking ENDTLS
+// spell-checker: ignore ssleof aesccm aesgcm getblocking setblocking ENDTLS TLSEXT
 
 //! Pure Rust SSL/TLS implementation using rustls
 //!
@@ -2652,7 +2652,31 @@ mod _ssl {
             };
             let initial_context: PyObjectRef = self.context.read().clone().into();
 
-            let result = callback.call((ssl_sock, server_name_py, initial_context), vm)?;
+            // catches exceptions from the callback and reports them as unraisable
+            let result = match callback.call((ssl_sock, server_name_py, initial_context), vm) {
+                Ok(result) => result,
+                Err(exc) => {
+                    vm.run_unraisable(
+                        exc,
+                        Some("in ssl servername callback".to_owned()),
+                        callback.clone(),
+                    );
+                    // Return SSL error like SSL_TLSEXT_ERR_ALERT_FATAL
+                    let ssl_exc: PyBaseExceptionRef = vm
+                        .new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            "SNI callback raised exception",
+                        )
+                        .upcast();
+                    let _ = ssl_exc.as_object().set_attr(
+                        "reason",
+                        vm.ctx.new_str("TLSV1_ALERT_INTERNAL_ERROR"),
+                        vm,
+                    );
+                    return Err(ssl_exc);
+                }
+            };
 
             // Check return value type (must be None or integer)
             if !vm.is_none(&result) {

From aa9fc7fedef2c0f355dfb8d573618193395adbdb Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 19:49:58 +0900
Subject: [PATCH 211/418] Pseudo ops (#6678)

* better expect

* pseudo instruction

* Fix CallKw narg

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/codegen/src/compile.rs                 | 30 ++++++---
 crates/codegen/src/ir.rs                      | 63 ++++++++++++++++--
 ...pile__tests__nested_double_async_with.snap | 28 ++++----
 crates/compiler-core/src/bytecode.rs          | 38 ++++++++++-
 crates/jit/src/instructions.rs                | 10 ++-
 crates/vm/src/frame.rs                        | 64 +++++++++++--------
 6 files changed, 172 insertions(+), 61 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 1f12cc87074..d5fbd194866 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -6212,23 +6212,33 @@ impl Compiler {
             }
             emit!(self, Instruction::CallFunctionEx { has_kwargs });
         } else if !arguments.keywords.is_empty() {
-            let mut kwarg_names = vec![];
+            // No **kwargs in this branch (has_double_star is false),
+            // so all keywords have arg.is_some()
+            let mut kwarg_names = Vec::with_capacity(arguments.keywords.len());
             for keyword in &arguments.keywords {
-                if let Some(name) = &keyword.arg {
-                    kwarg_names.push(ConstantData::Str {
-                        value: name.as_str().into(),
-                    });
-                } else {
-                    // This means **kwargs!
-                    panic!("name must be set");
-                }
+                let name = keyword
+                    .arg
+                    .as_ref()
+                    .expect("has_double_star is false, so arg must be Some");
+                kwarg_names.push(ConstantData::Str {
+                    value: name.as_str().into(),
+                });
                 self.compile_expression(&keyword.value)?;
             }
 
             self.emit_load_const(ConstantData::Tuple {
                 elements: kwarg_names,
             });
-            emit!(self, Instruction::CallKw { nargs: count });
+            // nargs = positional args + keyword args
+            let positional = additional_positional
+                .checked_add(u32::try_from(arguments.args.len()).expect("too many positional args"))
+                .expect("too many positional args");
+            let keyword_count =
+                u32::try_from(arguments.keywords.len()).expect("too many keyword args");
+            let nargs = positional
+                .checked_add(keyword_count)
+                .expect("too many arguments");
+            emit!(self, Instruction::CallKw { nargs });
         } else {
             emit!(self, Instruction::Call { nargs: count });
         }
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 6cc22b438f5..d29b1704c60 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -4,9 +4,9 @@ use crate::{IndexMap, IndexSet, error::InternalError};
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
-        CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
+        Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
         InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
-        encode_exception_table,
+        encode_exception_table, encode_load_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -189,6 +189,34 @@ impl CodeInfo {
         let mut instructions = Vec::new();
         let mut locations = Vec::new();
 
+        // convert_pseudo_ops: instructions before the main loop
+        for block in blocks
+            .iter_mut()
+            .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
+        {
+            for info in &mut block.instructions {
+                match info.instr {
+                    // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
+                    Instruction::LoadAttrMethod { idx } => {
+                        let encoded = encode_load_attr_arg(idx.get(info.arg), true);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                    }
+                    // LOAD_ATTR → encode with method flag=0
+                    Instruction::LoadAttr { idx } => {
+                        let encoded = encode_load_attr_arg(idx.get(info.arg), false);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                    }
+                    // POP_BLOCK pseudo → NOP
+                    Instruction::PopBlock => {
+                        info.instr = Instruction::Nop;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
         let mut block_to_offset = vec![Label(0); blocks.len()];
         // block_to_index: maps block idx to instruction index (for exception table)
         // This is the index into the final instructions array, including EXTENDED_ARG
@@ -213,23 +241,44 @@ impl CodeInfo {
             let mut next_block = BlockIdx(0);
             while next_block != BlockIdx::NULL {
                 let block = &mut blocks[next_block];
+                // Track current instruction offset for jump direction resolution
+                let mut current_offset = block_to_offset[next_block.idx()].0;
                 for info in &mut block.instructions {
-                    let (op, arg, target) = (info.instr, &mut info.arg, info.target);
+                    let target = info.target;
                     if target != BlockIdx::NULL {
                         let new_arg = OpArg(block_to_offset[target.idx()].0);
-                        recompile_extended_arg |= new_arg.instr_size() != arg.instr_size();
-                        *arg = new_arg;
+                        recompile_extended_arg |= new_arg.instr_size() != info.arg.instr_size();
+                        info.arg = new_arg;
                     }
-                    let (extras, lo_arg) = arg.split();
+
+                    // Convert JUMP pseudo to real instructions (direction depends on offset)
+                    let op = match info.instr {
+                        Instruction::Jump { .. } if target != BlockIdx::NULL => {
+                            let target_offset = block_to_offset[target.idx()].0;
+                            if target_offset > current_offset {
+                                Instruction::JumpForward {
+                                    target: Arg::marker(),
+                                }
+                            } else {
+                                Instruction::JumpBackward {
+                                    target: Arg::marker(),
+                                }
+                            }
+                        }
+                        other => other,
+                    };
+
+                    let (extras, lo_arg) = info.arg.split();
                     locations.extend(core::iter::repeat_n(
                         (info.location, info.end_location),
-                        arg.instr_size(),
+                        info.arg.instr_size(),
                     ));
                     instructions.extend(
                         extras
                             .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
                             .chain([CodeUnit { op, arg: lo_arg }]),
                     );
+                    current_offset += info.arg.instr_size() as u32;
                 }
                 next_block = block.next;
             }
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index 44eaca18e11..c4d2ed83796 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -18,7 +18,7 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  12 STORE_FAST           (0, stop_exc)
 
   3              13 LOAD_GLOBAL          (2, self)
-                 14 LOAD_ATTR_METHOD     (3, subTest)
+                 14 LOAD_ATTR            (7, subTest, method=true)
                  15 LOAD_GLOBAL          (4, type)
                  16 PUSH_NULL
                  17 LOAD_FAST            (0, stop_exc)
@@ -37,7 +37,7 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
             >>   29 SEND                 (34)
                  30 YIELD_VALUE          (1)
                  31 RESUME               (3)
-                 32 JUMP                 (29)
+                 32 JUMP_BACKWARD        (29)
                  33 CLEANUP_THROW
             >>   34 END_SEND
                  35 POP_TOP
@@ -55,11 +55,11 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
             >>   45 SEND                 (50)
                  46 YIELD_VALUE          (1)
                  47 RESUME               (3)
-                 48 JUMP                 (45)
+                 48 JUMP_BACKWARD        (45)
                  49 CLEANUP_THROW
             >>   50 END_SEND
                  51 POP_TOP
-                 52 JUMP                 (74)
+                 52 JUMP_FORWARD         (74)
                  53 PUSH_EXC_INFO
                  54 WITH_EXCEPT_START
                  55 GET_AWAITABLE
@@ -67,7 +67,7 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
             >>   57 SEND                 (62)
                  58 YIELD_VALUE          (1)
                  59 RESUME               (3)
-                 60 JUMP                 (57)
+                 60 JUMP_BACKWARD        (57)
                  61 CLEANUP_THROW
             >>   62 END_SEND
                  63 TO_BOOL
@@ -77,11 +77,11 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  67 POP_EXCEPT
                  68 POP_TOP
                  69 POP_TOP
-                 70 JUMP                 (74)
+                 70 JUMP_FORWARD         (74)
                  71 COPY                 (3)
                  72 POP_EXCEPT
                  73 RERAISE              (1)
-            >>   74 JUMP                 (100)
+            >>   74 JUMP_FORWARD         (100)
                  75 PUSH_EXC_INFO
                  76 COPY                 (1)
 
@@ -90,12 +90,12 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  79 STORE_FAST           (1, ex)
 
   8              80 LOAD_GLOBAL          (2, self)
-                 81 LOAD_ATTR_METHOD     (7, assertIs)
+                 81 LOAD_ATTR            (15, assertIs, method=true)
                  82 LOAD_FAST            (1, ex)
                  83 LOAD_FAST            (0, stop_exc)
                  84 CALL                 (2)
                  85 POP_TOP
-                 86 JUMP                 (91)
+                 86 JUMP_FORWARD         (91)
                  87 LOAD_CONST           (None)
                  88 STORE_FAST           (1, ex)
                  89 DELETE_FAST          (1, ex)
@@ -104,14 +104,14 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  92 LOAD_CONST           (None)
                  93 STORE_FAST           (1, ex)
                  94 DELETE_FAST          (1, ex)
-                 95 JUMP                 (108)
+                 95 JUMP_FORWARD         (108)
             >>   96 RAISE_VARARGS        (ReraiseFromStack)
                  97 COPY                 (3)
                  98 POP_EXCEPT
                  99 RAISE_VARARGS        (ReraiseFromStack)
 
  10         >>  100 LOAD_GLOBAL          (2, self)
-                101 LOAD_ATTR_METHOD     (8, fail)
+                101 LOAD_ATTR            (17, fail, method=true)
                 102 LOAD_FAST            (0, stop_exc)
                 103 FORMAT_SIMPLE
                 104 LOAD_CONST           (" was suppressed")
@@ -125,7 +125,7 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                 111 LOAD_CONST           (None)
                 112 CALL                 (3)
                 113 POP_TOP
-                114 JUMP                 (128)
+                114 JUMP_FORWARD         (128)
                 115 PUSH_EXC_INFO
                 116 WITH_EXCEPT_START
                 117 TO_BOOL
@@ -135,11 +135,11 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                 121 POP_EXCEPT
                 122 POP_TOP
                 123 POP_TOP
-                124 JUMP                 (128)
+                124 JUMP_FORWARD         (128)
                 125 COPY                 (3)
                 126 POP_EXCEPT
                 127 RERAISE              (1)
-            >>  128 JUMP                 (11)
+            >>  128 JUMP_BACKWARD        (11)
             >>  129 RETURN_CONST         (None)
 
               1 MAKE_FUNCTION
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 0c4522e9f99..d3a74d8828a 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -84,6 +84,20 @@ pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTabl
     None
 }
 
+/// Encode LOAD_ATTR oparg: bit 0 = method flag, bits 1+ = name index.
+#[inline]
+pub const fn encode_load_attr_arg(name_idx: u32, is_method: bool) -> u32 {
+    (name_idx << 1) | (is_method as u32)
+}
+
+/// Decode LOAD_ATTR oparg: returns (name_idx, is_method).
+#[inline]
+pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
+    let is_method = (oparg & 1) == 1;
+    let name_idx = oparg >> 1;
+    (name_idx, is_method)
+}
+
 /// Oparg values for [`Instruction::ConvertValue`].
 ///
 /// ## See also
@@ -1734,6 +1748,9 @@ impl Instruction {
     pub const fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
             Jump { target: l }
+            | JumpBackward { target: l }
+            | JumpBackwardNoInterrupt { target: l }
+            | JumpForward { target: l }
             | JumpIfNotExcMatch(l)
             | PopJumpIfTrue { target: l }
             | PopJumpIfFalse { target: l }
@@ -1760,6 +1777,9 @@ impl Instruction {
         matches!(
             self,
             Jump { .. }
+                | JumpForward { .. }
+                | JumpBackward { .. }
+                | JumpBackwardNoInterrupt { .. }
                 | Continue { .. }
                 | Break { .. }
                 | ReturnValue
@@ -2053,11 +2073,27 @@ impl Instruction {
             ImportName { idx } => w!(IMPORT_NAME, name = idx),
             IsOp(inv) => w!(IS_OP, ?inv),
             Jump { target } => w!(JUMP, target),
+            JumpBackward { target } => w!(JUMP_BACKWARD, target),
+            JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
+            JumpForward { target } => w!(JUMP_FORWARD, target),
             JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
             JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
             JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
             ListAppend { i } => w!(LIST_APPEND, i),
-            LoadAttr { idx } => w!(LOAD_ATTR, name = idx),
+            LoadAttr { idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, is_method) = decode_load_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                if is_method {
+                    write!(
+                        f,
+                        "{:pad$}({}, {}, method=true)",
+                        "LOAD_ATTR", encoded, attr_name
+                    )
+                } else {
+                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
+                }
+            }
             LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             LoadBuildClass => w!(LOAD_BUILD_CLASS),
             LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 055528db7f7..1901d3e8a49 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -212,7 +212,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             match instruction {
                 Instruction::ReturnValue
                 | Instruction::ReturnConst { .. }
-                | Instruction::Jump { .. } => {
+                | Instruction::Jump { .. }
+                | Instruction::JumpBackward { .. }
+                | Instruction::JumpBackwardNoInterrupt { .. }
+                | Instruction::JumpForward { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
@@ -558,7 +561,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
             Instruction::ExtendedArg => Ok(()),
 
-            Instruction::Jump { target } => {
+            Instruction::Jump { target }
+            | Instruction::JumpBackward { target }
+            | Instruction::JumpBackwardNoInterrupt { target }
+            | Instruction::JumpForward { target } => {
                 let target_block = self.get_or_create_block(target.get(arg));
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 32429a7d97e..a5a9d2b933d 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1082,6 +1082,18 @@ impl ExecutingFrame<'_> {
                 self.jump(target.get(arg));
                 Ok(None)
             }
+            bytecode::Instruction::JumpForward { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            bytecode::Instruction::JumpBackward { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            bytecode::Instruction::JumpBackwardNoInterrupt { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
             bytecode::Instruction::ListAppend { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
@@ -1093,6 +1105,9 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            bytecode::Instruction::LoadAttrMethod { .. } => {
+                unreachable!("LoadAttrMethod is converted to LoadAttr during compilation")
+            }
             bytecode::Instruction::LoadBuildClass => {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
@@ -1164,9 +1179,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttrMethod { idx } => {
-                self.load_attr_method(vm, idx.get(arg))
-            }
             bytecode::Instruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
@@ -1401,8 +1413,9 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             bytecode::Instruction::Nop => Ok(None),
-            // PopBlock is now a pseudo-instruction - exception table handles this
-            bytecode::Instruction::PopBlock => Ok(None),
+            bytecode::Instruction::PopBlock => {
+                unreachable!("PopBlock is converted to Nop during compilation")
+            }
             bytecode::Instruction::PopExcept => {
                 // Pop prev_exc from value stack and restore it
                 let prev_exc = self.pop_value();
@@ -2488,31 +2501,28 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn load_attr(&mut self, vm: &VirtualMachine, idx: u32) -> FrameResult {
-        // Regular attribute access: pop obj, push attr
-        let attr_name = self.code.names[idx as usize];
-        let parent = self.pop_value();
-        let obj = parent.get_attr(attr_name, vm)?;
-        self.push_value(obj);
-        Ok(None)
-    }
-
-    fn load_attr_method(&mut self, vm: &VirtualMachine, idx: u32) -> FrameResult {
-        // Method call: pop obj, push [method, self_or_null]
-        let attr_name = self.code.names[idx as usize];
+    fn load_attr(&mut self, vm: &VirtualMachine, oparg: u32) -> FrameResult {
+        let (name_idx, is_method) = bytecode::decode_load_attr_arg(oparg);
+        let attr_name = self.code.names[name_idx as usize];
         let parent = self.pop_value();
 
-        match PyMethod::get(parent, attr_name, vm)? {
-            PyMethod::Function { target, func } => {
-                // Method descriptor found: push [method, self]
-                self.push_value(func);
-                self.push_value(target);
-            }
-            PyMethod::Attribute(val) => {
-                // Regular attribute: push [attr, NULL]
-                self.push_value(val);
-                self.push_null();
+        if is_method {
+            // Method call: push [method, self_or_null]
+            let method = PyMethod::get(parent.clone(), attr_name, vm)?;
+            match method {
+                PyMethod::Function { target: _, func } => {
+                    self.push_value(func);
+                    self.push_value(parent);
+                }
+                PyMethod::Attribute(val) => {
+                    self.push_value(val);
+                    self.push_null();
+                }
             }
+        } else {
+            // Regular attribute access
+            let obj = parent.get_attr(attr_name, vm)?;
+            self.push_value(obj);
         }
         Ok(None)
     }

From 9e225f52e23ce13342232abb0dea3ab18d729229 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 19:50:25 +0900
Subject: [PATCH 212/418] impl gc finialized (#6689)

* impl gc finialized

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/object/core.rs | 54 ++++++++++++++++++++++++++++++++++--
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index 271a9cc34d2..4e51e296462 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -99,6 +99,31 @@ pub(super) unsafe fn try_trace_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut T
     payload.try_traverse(tracer_fn)
 }
 
+bitflags::bitflags! {
+    /// GC bits for free-threading support (like ob_gc_bits in Py_GIL_DISABLED)
+    /// These bits are stored in a separate atomic field for lock-free access.
+    /// See Include/internal/pycore_gc.h
+    #[derive(Copy, Clone, Debug, Default)]
+    pub(crate) struct GcBits: u8 {
+        /// Tracked by the GC
+        const TRACKED = 1 << 0;
+        /// tp_finalize was called (prevents __del__ from being called twice)
+        const FINALIZED = 1 << 1;
+        /// Object is unreachable (during GC collection)
+        const UNREACHABLE = 1 << 2;
+        /// Object is frozen (immutable)
+        const FROZEN = 1 << 3;
+        /// Memory the object references is shared between multiple threads
+        /// and needs special handling when freeing due to possible in-flight lock-free reads
+        const SHARED = 1 << 4;
+        /// Memory of the object itself is shared between multiple threads
+        /// Objects with this bit that are GC objects will automatically be delay-freed
+        const SHARED_INLINE = 1 << 5;
+        /// Use deferred reference counting
+        const DEFERRED = 1 << 6;
+    }
+}
+
 /// This is an actual python object. It consists of a `typ` which is the
 /// python class, and carries some rust payload optionally. This rust
 /// payload can be a rust float or rust int in case of float and int objects.
@@ -106,6 +131,8 @@ pub(super) unsafe fn try_trace_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut T
 pub(super) struct PyInner<T> {
     pub(super) ref_count: RefCount,
     pub(super) vtable: &'static PyObjVTable,
+    /// GC bits for free-threading (like ob_gc_bits)
+    pub(super) gc_bits: PyAtomic<u8>,
 
     pub(super) typ: PyAtomicRef<PyType>, // __class__ member
     pub(super) dict: Option<InstanceDict>,
@@ -448,6 +475,7 @@ impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
         Box::new(Self {
             ref_count: RefCount::new(),
             vtable: PyObjVTable::of::<T>(),
+            gc_bits: Radium::new(0),
             typ: PyAtomicRef::from(typ),
             dict: dict.map(InstanceDict::new),
             weak_list: WeakRefList::new(),
@@ -780,6 +808,23 @@ impl PyObject {
         self
     }
 
+    /// Check if the object has been finalized (__del__ already called).
+    /// _PyGC_FINALIZED in Py_GIL_DISABLED mode.
+    #[inline]
+    fn gc_finalized(&self) -> bool {
+        use core::sync::atomic::Ordering::Relaxed;
+        GcBits::from_bits_retain(self.0.gc_bits.load(Relaxed)).contains(GcBits::FINALIZED)
+    }
+
+    /// Mark the object as finalized. Should be called before __del__.
+    /// _PyGC_SET_FINALIZED in Py_GIL_DISABLED mode.
+    #[inline]
+    fn set_gc_finalized(&self) {
+        use core::sync::atomic::Ordering::Relaxed;
+        // Atomic RMW to avoid clobbering other concurrent bit updates.
+        self.0.gc_bits.fetch_or(GcBits::FINALIZED.bits(), Relaxed);
+    }
+
     #[inline(always)] // the outer function is never inlined
     fn drop_slow_inner(&self) -> Result<(), ()> {
         // __del__ is mostly not implemented
@@ -809,9 +854,12 @@ impl PyObject {
             }
         }
 
-        // CPython-compatible drop implementation
+        // __del__ should only be called once (like _PyGC_FINALIZED check in GIL_DISABLED)
         let del = self.class().slots.del.load();
-        if let Some(slot_del) = del {
+        if let Some(slot_del) = del
+            && !self.gc_finalized()
+        {
+            self.set_gc_finalized();
             call_slot_del(self, slot_del)?;
         }
         if let Some(wrl) = self.weak_ref_list() {
@@ -1274,6 +1322,7 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
                 vtable: PyObjVTable::of::<PyType>(),
+                gc_bits: Radium::new(0),
                 dict: None,
                 weak_list: WeakRefList::new(),
                 payload: type_payload,
@@ -1285,6 +1334,7 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
                 vtable: PyObjVTable::of::<PyType>(),
+                gc_bits: Radium::new(0),
                 dict: None,
                 weak_list: WeakRefList::new(),
                 payload: object_payload,

From a400386774befa61e207f8f5027c40940c4920c5 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 15:11:53 +0200
Subject: [PATCH 213/418] Remove `_dis` module (#6690)

* Remove `_dis` module

* Adjust CodeFlag
---
 Lib/dis.py                                   |  8 +--
 Lib/test/test_dis.py                         | 10 ----
 Lib/test/test_inspect/test_inspect.py        |  4 +-
 Lib/test/test_unittest/testmock/testasync.py |  2 -
 crates/codegen/src/compile.rs                | 30 +++++-----
 crates/codegen/src/ir.rs                     |  4 +-
 crates/compiler-core/src/bytecode.rs         | 29 +++-------
 crates/stdlib/src/dis.rs                     | 58 --------------------
 crates/stdlib/src/lib.rs                     |  2 -
 crates/vm/src/builtins/function.rs           | 10 ++--
 crates/vm/src/builtins/function/jit.rs       |  2 +-
 crates/vm/src/frame.rs                       | 10 +---
 12 files changed, 36 insertions(+), 133 deletions(-)
 delete mode 100644 crates/stdlib/src/dis.rs

diff --git a/Lib/dis.py b/Lib/dis.py
index 6583cab62b8..797e0f8a088 100644
--- a/Lib/dis.py
+++ b/Lib/dis.py
@@ -19,7 +19,6 @@
 
 from _opcode import get_executor
 
-
 __all__ = ["code_info", "dis", "disassemble", "distb", "disco",
            "findlinestarts", "findlabels", "show_code",
            "get_instructions", "Instruction", "Bytecode"] + _opcodes_all
@@ -1052,9 +1051,6 @@ def dis(self):
             return output.getvalue()
 
 
-from _dis import * # TODO: RUSTPYTHON; Remove this import (and module)
-
-
 def main(args=None):
     import argparse
 
@@ -1073,9 +1069,7 @@ def main(args=None):
         with open(args.infile, 'rb') as infile:
             source = infile.read()
     code = compile(source, name, "exec")
-    # TODO: RUSTPYTHON; Add support for `show_caches` & `show_offsets` arguments
-    # dis(code, show_caches=args.show_caches, show_offsets=args.show_offsets)
-    dis(code)
+    dis(code, show_caches=args.show_caches, show_offsets=args.show_offsets)
 
 if __name__ == "__main__":
     main()
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index 9526bdcbbaa..a585643cba6 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -971,11 +971,9 @@ def test_bug_1333982(self):
 
         self.do_disassembly_test(bug1333982, dis_bug1333982)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_42562(self):
         self.do_disassembly_test(bug42562, dis_bug42562)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_45757(self):
         # Extended arg followed by NOP
         self.do_disassembly_test(code_bug_45757, dis_bug_45757)
@@ -997,7 +995,6 @@ def test_intrinsic_1(self):
         self.do_disassembly_test("+a", dis_intrinsic_1_5)
         self.do_disassembly_test("(*a,)", dis_intrinsic_1_6)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_intrinsic_2(self):
         self.assertIn("CALL_INTRINSIC_2         1 (INTRINSIC_PREP_RERAISE_STAR)",
                       self.get_disassembly("try: pass\nexcept* Exception: x"))
@@ -1059,19 +1056,16 @@ def test_disassemble_static_method(self):
     def test_disassemble_class_method(self):
         self.do_disassembly_test(_C.cm, dis_c_class_method)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_disassemble_generator(self):
         gen_func_disas = self.get_disassembly(_g)  # Generator function
         gen_disas = self.get_disassembly(_g(1))  # Generator iterator
         self.assertEqual(gen_disas, gen_func_disas)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_disassemble_async_generator(self):
         agen_func_disas = self.get_disassembly(_ag)  # Async generator function
         agen_disas = self.get_disassembly(_ag(1))  # Async generator iterator
         self.assertEqual(agen_disas, agen_func_disas)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_disassemble_coroutine(self):
         coro_func_disas = self.get_disassembly(_co)  # Coroutine function
         coro = _co(1)  # Coroutine object
@@ -1096,7 +1090,6 @@ def test_disassemble_try_finally(self):
         self.do_disassembly_test(_tryfinally, dis_tryfinally)
         self.do_disassembly_test(_tryfinallyconst, dis_tryfinallyconst)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dis_none(self):
         try:
             del sys.last_exc
@@ -1108,7 +1101,6 @@ def test_dis_none(self):
             pass
         self.assertRaises(RuntimeError, dis.dis, None)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dis_traceback(self):
         self.maxDiff = None
         try:
@@ -2198,14 +2190,12 @@ def test_assert_not_in_with_op_not_in_bytecode(self):
         self.assertNotInBytecode(code, "LOAD_NAME")
         self.assertNotInBytecode(code, "LOAD_NAME", "a")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_not_in_with_arg_not_in_bytecode(self):
         code = compile("a = 1", "<string>", "exec")
         self.assertInBytecode(code, "LOAD_CONST")
         self.assertInBytecode(code, "LOAD_CONST", 1)
         self.assertNotInBytecode(code, "LOAD_CONST", 2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_not_in_with_arg_in_bytecode(self):
         code = compile("a = 1", "<string>", "exec")
         with self.assertRaises(AssertionError):
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index b9cfca6df21..7d037d0554e 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -384,8 +384,6 @@ def do_something_static():
 
         coro.close(); gen_coro.close(); # silence warnings
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_isawaitable(self):
         def gen(): yield
         self.assertFalse(inspect.isawaitable(gen()))
@@ -6748,4 +6746,4 @@ def f():
 
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_unittest/testmock/testasync.py b/Lib/test/test_unittest/testmock/testasync.py
index ddc6f0599c8..81d9c9c55fd 100644
--- a/Lib/test/test_unittest/testmock/testasync.py
+++ b/Lib/test/test_unittest/testmock/testasync.py
@@ -734,7 +734,6 @@ def __aiter__(self): pass
 
         async def __anext__(self): pass
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_aiter_set_return_value(self):
         mock_iter = AsyncMock(name="tester")
         mock_iter.__aiter__.return_value = [1, 2, 3]
@@ -760,7 +759,6 @@ def inner_test(mock_type):
                 inner_test(mock_type)
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mock_async_for(self):
         async def iterate(iterator):
             accumulator = []
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index d5fbd194866..bbc8d4235fc 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -377,7 +377,7 @@ enum CollectionType {
 impl Compiler {
     fn new(opts: CompileOpts, source_file: SourceFile, code_name: String) -> Self {
         let module_code = ir::CodeInfo {
-            flags: bytecode::CodeFlags::NEW_LOCALS,
+            flags: bytecode::CodeFlags::NEWLOCALS,
             source_path: source_file.name().to_owned(),
             private: None,
             blocks: vec![ir::Block::default()],
@@ -749,19 +749,19 @@ impl Compiler {
             CompilerScope::Module => (bytecode::CodeFlags::empty(), 0, 0, 0),
             CompilerScope::Class => (bytecode::CodeFlags::empty(), 0, 0, 0),
             CompilerScope::Function | CompilerScope::AsyncFunction | CompilerScope::Lambda => (
-                bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
                 0, // Will be set later in enter_function
                 0, // Will be set later in enter_function
                 0, // Will be set later in enter_function
             ),
             CompilerScope::Comprehension => (
-                bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
                 0,
                 1, // comprehensions take one argument (.0)
                 0,
             ),
             CompilerScope::TypeParams => (
-                bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
                 0,
                 0,
                 0,
@@ -1298,7 +1298,7 @@ impl Compiler {
             let parent_obj_name = &parent.metadata.name;
 
             // Determine if parent is a function-like scope
-            let is_function_parent = parent.flags.contains(bytecode::CodeFlags::IS_OPTIMIZED)
+            let is_function_parent = parent.flags.contains(bytecode::CodeFlags::OPTIMIZED)
                 && !parent_obj_name.starts_with("<") // Not a special scope like <lambda>, <listcomp>, etc.
                 && parent_obj_name != "<module>"; // Not the module scope
 
@@ -1914,7 +1914,7 @@ impl Compiler {
                             && self
                                 .current_code_info()
                                 .flags
-                                .contains(bytecode::CodeFlags::IS_GENERATOR)
+                                .contains(bytecode::CodeFlags::GENERATOR)
                         {
                             return Err(self.error_ranged(
                                 CodegenErrorType::AsyncReturnValue,
@@ -2062,7 +2062,7 @@ impl Compiler {
         }
 
         self.push_output(
-            bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
+            bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
             parameters.posonlyargs.len().to_u32(),
             (parameters.posonlyargs.len() + parameters.args.len()).to_u32(),
             parameters.kwonlyargs.len().to_u32(),
@@ -2080,11 +2080,11 @@ impl Compiler {
         }
 
         if let Some(name) = parameters.vararg.as_deref() {
-            self.current_code_info().flags |= bytecode::CodeFlags::HAS_VARARGS;
+            self.current_code_info().flags |= bytecode::CodeFlags::VARARGS;
             self.varname(name.name.as_str())?;
         }
         if let Some(name) = parameters.kwarg.as_deref() {
-            self.current_code_info().flags |= bytecode::CodeFlags::HAS_VARKEYWORDS;
+            self.current_code_info().flags |= bytecode::CodeFlags::VARKEYWORDS;
             self.varname(name.name.as_str())?;
         }
 
@@ -3103,7 +3103,7 @@ impl Compiler {
         self.enter_function(name, parameters)?;
         self.current_code_info()
             .flags
-            .set(bytecode::CodeFlags::IS_COROUTINE, is_async);
+            .set(bytecode::CodeFlags::COROUTINE, is_async);
 
         // Set up context
         let prev_ctx = self.ctx;
@@ -3233,7 +3233,7 @@ impl Compiler {
             // Enter type params scope
             let type_params_name = format!("<generic parameters of {name}>");
             self.push_output(
-                bytecode::CodeFlags::IS_OPTIMIZED | bytecode::CodeFlags::NEW_LOCALS,
+                bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
                 0,
                 num_typeparam_args as u32,
                 0,
@@ -3664,7 +3664,7 @@ impl Compiler {
         if is_generic {
             let type_params_name = format!("<generic parameters of {name}>");
             self.push_output(
-                bytecode::CodeFlags::IS_OPTIMIZED | bytecode::CodeFlags::NEW_LOCALS,
+                bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
                 0,
                 0,
                 0,
@@ -6371,9 +6371,9 @@ impl Compiler {
             in_async_scope: prev_ctx.in_async_scope || is_async,
         };
 
-        let flags = bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED;
+        let flags = bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED;
         let flags = if is_async {
-            flags | bytecode::CodeFlags::IS_COROUTINE
+            flags | bytecode::CodeFlags::COROUTINE
         } else {
             flags
         };
@@ -7040,7 +7040,7 @@ impl Compiler {
     }
 
     fn mark_generator(&mut self) {
-        self.current_code_info().flags |= bytecode::CodeFlags::IS_GENERATOR
+        self.current_code_info().flags |= bytecode::CodeFlags::GENERATOR
     }
 
     /// Whether the expression contains an await expression and
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index d29b1704c60..298566d7ad7 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -332,8 +332,8 @@ impl CodeInfo {
 
         let total_args = self.metadata.argcount
             + self.metadata.kwonlyargcount
-            + self.flags.contains(CodeFlags::HAS_VARARGS) as u32
-            + self.flags.contains(CodeFlags::HAS_VARKEYWORDS) as u32;
+            + self.flags.contains(CodeFlags::VARARGS) as u32
+            + self.flags.contains(CodeFlags::VARKEYWORDS) as u32;
 
         let mut found_cellarg = false;
         let cell2arg = self
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index d3a74d8828a..010e414cc89 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -371,28 +371,15 @@ pub struct CodeObject<C: Constant = ConstantData> {
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub struct CodeFlags: u16 {
-        const NEW_LOCALS = 0x01;
-        const IS_GENERATOR = 0x02;
-        const IS_COROUTINE = 0x04;
-        const HAS_VARARGS = 0x08;
-        const HAS_VARKEYWORDS = 0x10;
-        const IS_OPTIMIZED = 0x20;
+        const OPTIMIZED = 0x0001;
+        const NEWLOCALS = 0x0002;
+        const VARARGS = 0x0004;
+        const VARKEYWORDS = 0x0008;
+        const GENERATOR = 0x0020;
+        const COROUTINE = 0x0080;
     }
 }
 
-impl CodeFlags {
-    pub const NAME_MAPPING: &'static [(&'static str, Self)] = &[
-        ("GENERATOR", Self::IS_GENERATOR),
-        ("COROUTINE", Self::IS_COROUTINE),
-        (
-            "ASYNC_GENERATOR",
-            Self::from_bits_truncate(Self::IS_GENERATOR.bits() | Self::IS_COROUTINE.bits()),
-        ),
-        ("VARARGS", Self::HAS_VARARGS),
-        ("VARKEYWORDS", Self::HAS_VARKEYWORDS),
-    ];
-}
-
 /// an opcode argument that may be extended by a prior ExtendedArg
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(transparent)]
@@ -1564,14 +1551,14 @@ impl<C: Constant> CodeObject<C> {
         let args = &self.varnames[..nargs];
         let kwonlyargs = &self.varnames[nargs..varargs_pos];
 
-        let vararg = if self.flags.contains(CodeFlags::HAS_VARARGS) {
+        let vararg = if self.flags.contains(CodeFlags::VARARGS) {
             let vararg = &self.varnames[varargs_pos];
             varargs_pos += 1;
             Some(vararg)
         } else {
             None
         };
-        let varkwarg = if self.flags.contains(CodeFlags::HAS_VARKEYWORDS) {
+        let varkwarg = if self.flags.contains(CodeFlags::VARKEYWORDS) {
             Some(&self.varnames[varargs_pos])
         } else {
             None
diff --git a/crates/stdlib/src/dis.rs b/crates/stdlib/src/dis.rs
deleted file mode 100644
index 341137f91f4..00000000000
--- a/crates/stdlib/src/dis.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-pub(crate) use decl::make_module;
-
-#[pymodule(name = "dis")]
-mod decl {
-    use crate::vm::{
-        PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyCode, PyDictRef, PyStrRef},
-        bytecode::CodeFlags,
-    };
-
-    #[pyfunction]
-    fn dis(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let co = if let Ok(co) = obj.get_attr("__code__", vm) {
-            // Method or function:
-            PyRef::try_from_object(vm, co)?
-        } else if let Ok(co_str) = PyStrRef::try_from_object(vm, obj.clone()) {
-            #[cfg(not(feature = "compiler"))]
-            {
-                let _ = co_str;
-                return Err(
-                    vm.new_runtime_error("dis.dis() with str argument requires `compiler` feature")
-                );
-            }
-            #[cfg(feature = "compiler")]
-            {
-                vm.compile(
-                    co_str.as_str(),
-                    crate::vm::compiler::Mode::Exec,
-                    "<dis>".to_owned(),
-                )
-                .map_err(|err| vm.new_syntax_error(&err, Some(co_str.as_str())))?
-            }
-        } else {
-            PyRef::try_from_object(vm, obj)?
-        };
-        disassemble(co)
-    }
-
-    #[pyfunction]
-    fn disassemble(co: PyRef<PyCode>) -> PyResult<()> {
-        print!("{}", &co.code);
-        Ok(())
-    }
-
-    #[pyattr(name = "COMPILER_FLAG_NAMES")]
-    fn compiler_flag_names(vm: &VirtualMachine) -> PyDictRef {
-        let dict = vm.ctx.new_dict();
-        for (name, flag) in CodeFlags::NAME_MAPPING {
-            dict.set_item(
-                &*vm.new_pyobj(flag.bits()),
-                vm.ctx.new_str(*name).into(),
-                vm,
-            )
-            .unwrap();
-        }
-        dict
-    }
-}
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
index 6b7796c8bad..567c584d85b 100644
--- a/crates/stdlib/src/lib.rs
+++ b/crates/stdlib/src/lib.rs
@@ -14,7 +14,6 @@ mod bisect;
 mod cmath;
 mod contextvars;
 mod csv;
-mod dis;
 mod gc;
 
 mod bz2;
@@ -132,7 +131,6 @@ pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInit
             "cmath" => cmath::make_module,
             "_contextvars" => contextvars::make_module,
             "_csv" => csv::make_module,
-            "_dis" => dis::make_module,
             "faulthandler" => faulthandler::make_module,
             "gc" => gc::make_module,
             "_hashlib" => hashlib::make_module,
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 3e5048e133f..58c683d3fab 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -124,7 +124,7 @@ impl PyFunction {
 
         let mut vararg_offset = total_args;
         // Pack other positional arguments in to *args:
-        if code.flags.contains(bytecode::CodeFlags::HAS_VARARGS) {
+        if code.flags.contains(bytecode::CodeFlags::VARARGS) {
             let vararg_value = vm.ctx.new_tuple(args_iter.collect());
             fastlocals[vararg_offset] = Some(vararg_value.into());
             vararg_offset += 1;
@@ -155,7 +155,7 @@ impl PyFunction {
         }
 
         // Do we support `**kwargs` ?
-        let kwargs = if code.flags.contains(bytecode::CodeFlags::HAS_VARKEYWORDS) {
+        let kwargs = if code.flags.contains(bytecode::CodeFlags::VARKEYWORDS) {
             let d = vm.ctx.new_dict();
             fastlocals[vararg_offset] = Some(d.clone().into());
             Some(d)
@@ -414,7 +414,7 @@ impl Py<PyFunction> {
 
         let code = self.code.lock().clone();
 
-        let locals = if code.flags.contains(bytecode::CodeFlags::NEW_LOCALS) {
+        let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
             ArgMapping::from_dict_exact(vm.ctx.new_dict())
         } else if let Some(locals) = locals {
             locals
@@ -436,8 +436,8 @@ impl Py<PyFunction> {
         self.fill_locals_from_args(&frame, func_args, vm)?;
 
         // If we have a generator, create a new generator
-        let is_gen = code.flags.contains(bytecode::CodeFlags::IS_GENERATOR);
-        let is_coro = code.flags.contains(bytecode::CodeFlags::IS_COROUTINE);
+        let is_gen = code.flags.contains(bytecode::CodeFlags::GENERATOR);
+        let is_coro = code.flags.contains(bytecode::CodeFlags::COROUTINE);
         match (is_gen, is_coro) {
             (true, false) => {
                 Ok(PyGenerator::new(frame, self.__name__(), self.__qualname__()).into_pyobject(vm))
diff --git a/crates/vm/src/builtins/function/jit.rs b/crates/vm/src/builtins/function/jit.rs
index de0a528b734..a28335900da 100644
--- a/crates/vm/src/builtins/function/jit.rs
+++ b/crates/vm/src/builtins/function/jit.rs
@@ -72,7 +72,7 @@ pub fn get_jit_arg_types(func: &Py<PyFunction>, vm: &VirtualMachine) -> PyResult
 
     if code
         .flags
-        .intersects(CodeFlags::HAS_VARARGS | CodeFlags::HAS_VARKEYWORDS)
+        .intersects(CodeFlags::VARARGS | CodeFlags::VARKEYWORDS)
     {
         return Err(new_jit_error(
             "Can't jit functions with variable number of arguments".to_owned(),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index a5a9d2b933d..dd5fc685643 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -186,7 +186,7 @@ impl Frame {
                 Ok(())
             };
             map_to_dict(&code.cellvars, &self.cells_frees)?;
-            if code.flags.contains(bytecode::CodeFlags::IS_OPTIMIZED) {
+            if code.flags.contains(bytecode::CodeFlags::OPTIMIZED) {
                 map_to_dict(&code.freevars, &self.cells_frees[code.cellvars.len()..])?;
             }
         }
@@ -1000,11 +1000,7 @@ impl ExecutingFrame<'_> {
                 let iterable = self.pop_value();
                 let iter = if iterable.class().is(vm.ctx.types.coroutine_type) {
                     // Coroutine requires CO_COROUTINE or CO_ITERABLE_COROUTINE flag
-                    if !self
-                        .code
-                        .flags
-                        .intersects(bytecode::CodeFlags::IS_COROUTINE)
-                    {
+                    if !self.code.flags.intersects(bytecode::CodeFlags::COROUTINE) {
                         return Err(vm.new_type_error(
                             "cannot 'yield from' a coroutine object in a non-coroutine generator"
                                 .to_owned(),
@@ -1675,7 +1671,7 @@ impl ExecutingFrame<'_> {
                 // arg=0: direct yield (wrapped for async generators)
                 // arg=1: yield from await/yield-from (NOT wrapped)
                 let wrap = oparg.get(arg) == 0;
-                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
+                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::COROUTINE) {
                     PyAsyncGenWrappedValue(value).into_pyobject(vm)
                 } else {
                     value

From 6ff7b3ed278d8bcf38dfb74d672499d8d2d6544e Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 10 Jan 2026 16:16:11 +0200
Subject: [PATCH 214/418] LoadClassDeref -> LoadFromDictOrDeref (#6692)

---
 Lib/_opcode_metadata.py              |  1 -
 crates/codegen/src/compile.rs        |  2 +-
 crates/compiler-core/src/bytecode.rs | 38 +++++++++++++++++++++++-----
 crates/stdlib/src/opcode.rs          |  2 +-
 crates/vm/src/frame.rs               |  2 +-
 5 files changed, 34 insertions(+), 11 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index e72a76a576c..40cd95cca0c 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -136,7 +136,6 @@
     'JUMP_IF_FALSE_OR_POP': 129,
     'JUMP_IF_TRUE_OR_POP': 130,
     'JUMP_IF_NOT_EXC_MATCH': 131,
-    'LOAD_CLASS_DEREF': 132,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
     'RESUME': 149,
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index bbc8d4235fc..3370111e655 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1561,7 +1561,7 @@ impl Compiler {
                     NameUsage::Load => {
                         // Special case for class scope
                         if self.ctx.in_class && !self.ctx.in_func() {
-                            Instruction::LoadClassDeref
+                            Instruction::LoadFromDictOrDeref
                         } else {
                             Instruction::LoadDeref
                         }
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 010e414cc89..8c4790e03ff 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -829,7 +829,7 @@ pub enum Instruction {
     LoadFastLoadFast {
         arg: Arg<u32>,
     } = 88, // Placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>) = 89, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
     LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
     LoadGlobal(Arg<NameIdx>) = 91,
     LoadName(Arg<NameIdx>) = 92,
@@ -932,7 +932,6 @@ pub enum Instruction {
         target: Arg<Label>,
     } = 130,
     JumpIfNotExcMatch(Arg<Label>) = 131,
-    LoadClassDeref(Arg<NameIdx>) = 132,
     SetExcInfo = 134,
     Subscript = 135,
     // ===== Pseudo Opcodes (252+) ======
@@ -997,7 +996,6 @@ impl TryFrom<u8> for Instruction {
                 target: Arg::marker(),
             }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::LoadClassDeref(Arg::marker())),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
         ];
@@ -1792,14 +1790,14 @@ impl Instruction {
             Nop => 0,
             ImportName { .. } => -1,
             ImportFrom { .. } => 1,
-            LoadFast(_) | LoadFastAndClear(_) | LoadName(_) | LoadGlobal(_) | LoadDeref(_)
-            | LoadClassDeref(_) => 1,
+            LoadFast(_) | LoadFastAndClear(_) | LoadName(_) | LoadGlobal(_) | LoadDeref(_) => 1,
             StoreFast(_) | StoreName(_) | StoreGlobal(_) | StoreDeref(_) => -1,
             StoreFastLoadFast { .. } => 0, // pop 1, push 1
             DeleteFast(_) | DeleteName(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
             LoadClosure(_) => 1,
             Subscript => -1,
             StoreSubscr => -3,
+            LoadFromDictOrDeref(_) => 1,
             DeleteSubscr => -2,
             LoadAttr { .. } => 0,
             // LoadAttrMethod: pop obj, push method + self_or_null
@@ -1937,7 +1935,33 @@ impl Instruction {
             UnaryNot => 0,
             GetYieldFromIter => 0,
             PushNull => 1, // Push NULL for call protocol
-            _ => 0,
+            Cache => 0,
+            BinarySlice => 0,
+            BinaryOpInplaceAddUnicode => 0,
+            EndFor => 0,
+            ExitInitCheck => 0,
+            InterpreterExit => 0,
+            LoadAssertionError => 0,
+            LoadLocals => 0,
+            ReturnGenerator => 0,
+            StoreSlice => 0,
+            DictMerge { .. } => 0,
+            BuildConstKeyMap { .. } => 0,
+            CopyFreeVars { .. } => 0,
+            EnterExecutor => 0,
+            JumpBackwardNoInterrupt { .. } => 0,
+            JumpBackward { .. } => 0,
+            JumpForward { .. } => 0,
+            ListExtend { .. } => 0,
+            LoadFastCheck(_) => 0,
+            LoadFastLoadFast { .. } => 0,
+            LoadFromDictOrGlobals(_) => 0,
+            SetUpdate { .. } => 0,
+            MakeCell(_) => 0,
+            LoadSuperAttr { .. } => 0,
+            StoreFastStoreFast { .. } => 0,
+            PopJumpIfNone { .. } => 0,
+            PopJumpIfNotNone { .. } => 0,
         }
     }
 
@@ -2083,7 +2107,7 @@ impl Instruction {
             }
             LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            LoadClassDeref(idx) => w!(LOAD_CLASSDEREF, cell_name = idx),
+            LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
             LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
             LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
             LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 1b920822f5a..3b0d8564ff6 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -108,7 +108,7 @@ mod opcode {
                 && matches!(
                     Instruction::try_from(opcode as u8),
                     Ok(Instruction::DeleteDeref(_)
-                        | Instruction::LoadClassDeref(_)
+                        | Instruction::LoadFromDictOrDeref(_)
                         | Instruction::LoadClosure(_)
                         | Instruction::LoadDeref(_)
                         | Instruction::StoreDeref(_))
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index dd5fc685643..ec3abf5e168 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1108,7 +1108,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::LoadClassDeref(i) => {
+            bytecode::Instruction::LoadFromDictOrDeref(i) => {
                 let i = i.get(arg) as usize;
                 let name = if i < self.code.cellvars.len() {
                     self.code.cellvars[i]

From 3909b18eac642d824cd5c1157f452e8765269a2e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 11 Jan 2026 00:11:41 +0900
Subject: [PATCH 215/418] lib_updater --quick-upgrade (#6695)

---
 scripts/lib_updater.py | 42 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 40 insertions(+), 2 deletions(-)

diff --git a/scripts/lib_updater.py b/scripts/lib_updater.py
index 8573705dd15..a91c26cb686 100755
--- a/scripts/lib_updater.py
+++ b/scripts/lib_updater.py
@@ -2,9 +2,19 @@
 __doc__ = """
 This tool helps with updating test files from CPython.
 
+Quick Upgrade
+-------------
+    ./{fname} --quick-upgrade cpython/Lib/test/test_threading.py
+    ./{fname} --quick-upgrade ../somewhere/Lib/threading.py
+
+    Any path containing `/Lib/` will auto-detect the target:
+    -> Extracts patches from Lib/... (auto-detected from path)
+    -> Applies them to the source file
+    -> Writes result to Lib/...
+
 Examples
 --------
-To move the patches found in `Lib/test/foo.py` to ` ~/cpython/Lib/test/foo.py` then write the contents back to `Lib/test/foo.py`
+To move the patches found in `Lib/test/foo.py` to `~/cpython/Lib/test/foo.py` then write the contents back to `Lib/test/foo.py`
 
 >>> ./{fname} --from Lib/test/foo.py --to ~/cpython/Lib/test/foo.py -o Lib/test/foo.py
 
@@ -288,6 +298,12 @@ def build_argparse() -> argparse.ArgumentParser:
     )
 
     patches_group = parser.add_mutually_exclusive_group(required=True)
+    patches_group.add_argument(
+        "--quick-upgrade",
+        help="Quick upgrade: path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
+        type=pathlib.Path,
+        metavar="PATH",
+    )
     patches_group.add_argument(
         "-p",
         "--patches",
@@ -301,7 +317,7 @@ def build_argparse() -> argparse.ArgumentParser:
         type=pathlib.Path,
     )
 
-    group = parser.add_mutually_exclusive_group(required=True)
+    group = parser.add_mutually_exclusive_group(required=False)
     group.add_argument(
         "--to",
         help="File to apply patches to",
@@ -322,6 +338,28 @@ def build_argparse() -> argparse.ArgumentParser:
     parser = build_argparse()
     args = parser.parse_args()
 
+    # Quick upgrade: auto-fill --from, --to, -o from path
+    if args.quick_upgrade is not None:
+        path_str = str(args.quick_upgrade)
+        lib_marker = "/Lib/"
+
+        if lib_marker not in path_str:
+            parser.error(f"--quick-upgrade path must contain '/Lib/' (got: {path_str})")
+
+        idx = path_str.index(lib_marker)
+        lib_path = pathlib.Path(path_str[idx + 1 :])
+
+        args.gather_from = lib_path
+        args.to = args.quick_upgrade
+        if args.output == "-":
+            args.output = str(lib_path)
+
+    # Validate required arguments
+    if args.patches is None and args.gather_from is None:
+        parser.error("--from or --patches is required (or use --quick-upgrade)")
+    if args.to is None and not args.show_patches:
+        parser.error("--to or --show-patches is required")
+
     if args.patches:
         patches = {
             cls_name: {

From 2a1faf426581b11fb586d36aecaaf4c5e2a19301 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 11 Jan 2026 00:18:18 +0900
Subject: [PATCH 216/418] integrate to lib_updater

---
 scripts/fix_test.py | 77 ++++++++++++++-------------------------------
 1 file changed, 24 insertions(+), 53 deletions(-)

diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index 53b10d63834..49a2e1870ea 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -15,12 +15,11 @@
 """
 
 import argparse
-import ast
-import itertools
-import platform
 import sys
 from pathlib import Path
 
+from lib_updater import apply_patches, PatchSpec, UtMethod
+
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Fix test.")
@@ -102,39 +101,16 @@ def path_to_test(path) -> list[str]:
     return parts[-2:]  # Get class name and method name
 
 
-def find_test_lineno(file: str, test: list[str]) -> tuple[int, int] | None:
-    """Find the line number and column offset of a test function.
-    Returns (lineno, col_offset) or None if not found.
-    """
-    a = ast.parse(file)
-    for key, node in ast.iter_fields(a):
-        if key == "body":
-            for n in node:
-                match n:
-                    case ast.ClassDef():
-                        if len(test) == 2 and test[0] == n.name:
-                            for fn in n.body:
-                                match fn:
-                                    case ast.FunctionDef() | ast.AsyncFunctionDef():
-                                        if fn.name == test[-1]:
-                                            return (fn.lineno, fn.col_offset)
-                    case ast.FunctionDef() | ast.AsyncFunctionDef():
-                        if n.name == test[0] and len(test) == 1:
-                            return (n.lineno, n.col_offset)
-    return None
-
-
-def apply_modifications(file: str, modifications: list[tuple[int, int]]) -> str:
-    """Apply all modifications in reverse order to avoid line number offset issues."""
-    lines = file.splitlines()
-    fixture = "@unittest.expectedFailure"
-    # Sort by line number in descending order
-    modifications.sort(key=lambda x: x[0], reverse=True)
-    for lineno, col_offset in modifications:
-        indent = " " * col_offset
-        lines.insert(lineno - 1, indent + fixture)
-        lines.insert(lineno - 1, indent + "# TODO: RUSTPYTHON")
-    return "\n".join(lines)
+def build_patches(test_parts_set: set[tuple[str, str]]) -> dict:
+    """Convert failing tests to lib_updater patch format."""
+    patches = {}
+    for class_name, method_name in test_parts_set:
+        if class_name not in patches:
+            patches[class_name] = {}
+        patches[class_name][method_name] = [
+            PatchSpec(UtMethod.ExpectedFailure, None, "")
+        ]
+    return patches
 
 
 def run_test(test_name):
@@ -167,26 +143,21 @@ def run_test(test_name):
     tests = run_test(test_name)
     f = test_path.read_text(encoding="utf-8")
 
-    # Collect all modifications first (with deduplication for subtests)
-    modifications = []
+    # Collect failing tests (with deduplication for subtests)
     seen_tests = set()  # Track (class_name, method_name) to avoid duplicates
     for test in tests.tests:
         if test.result == "fail" or test.result == "error":
             test_parts = path_to_test(test.path)
-            test_key = tuple(test_parts)
-            if test_key in seen_tests:
-                continue  # Skip duplicate (same test, different subtest)
-            seen_tests.add(test_key)
-            location = find_test_lineno(f, test_parts)
-            if location:
-                print(f"Modifying test: {test.name} at line {location[0]}")
-                modifications.append(location)
-            else:
-                print(f"Warning: Could not find test: {test.name} ({test_parts})")
-
-    # Apply all modifications in reverse order
-    if modifications:
-        f = apply_modifications(f, modifications)
+            if len(test_parts) == 2:
+                test_key = tuple(test_parts)
+                if test_key not in seen_tests:
+                    seen_tests.add(test_key)
+                    print(f"Marking test: {test_parts[0]}.{test_parts[1]}")
+
+    # Apply patches using lib_updater
+    if seen_tests:
+        patches = build_patches(seen_tests)
+        f = apply_patches(f, patches)
         test_path.write_text(f, encoding="utf-8")
 
-    print(f"Modified {len(modifications)} tests")
+    print(f"Modified {len(seen_tests)} tests")

From 440b8de763d3b3166fed92eda7b7c01d3326983a Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sun, 11 Jan 2026 03:04:24 +0200
Subject: [PATCH 217/418] Move `Instruction` enum to its own file (#6693)

* Move `Instruction` to its own file

* Fix codegen and frame.rs

* Adjust script
---
 crates/codegen/src/compile.rs                 |  62 +-
 crates/compiler-core/src/bytecode.rs          | 795 +----------------
 .../compiler-core/src/bytecode/instruction.rs | 822 ++++++++++++++++++
 crates/vm/src/frame.rs                        |   2 +-
 scripts/generate_opcode_metadata.py           |   9 +-
 5 files changed, 862 insertions(+), 828 deletions(-)
 create mode 100644 crates/compiler-core/src/bytecode/instruction.rs

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 3370111e655..a04f5ad0dfa 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1382,7 +1382,7 @@ impl Compiler {
 
             if let Stmt::Expr(StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -1420,7 +1420,7 @@ impl Compiler {
                 Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
                     let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1938,7 +1938,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::CopyItem { index: 1_u32 });
+                        emit!(self, Instruction::Copy { index: 1_u32 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2205,7 +2205,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
@@ -2230,7 +2230,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
                 TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
@@ -2256,7 +2256,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::CopyItem { index: 1_u32 });
+                    emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
             };
@@ -2396,7 +2396,7 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::CopyItem { index: 3_u32 });
+                emit!(self, Instruction::Copy { index: 3_u32 });
                 emit!(self, Instruction::PopExcept);
                 emit!(
                     self,
@@ -2457,7 +2457,7 @@ impl Compiler {
             // check if this handler can handle the exception:
             if let Some(exc_type) = type_ {
                 // Duplicate exception for test:
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
 
                 // Check exception type:
                 self.compile_expression(exc_type)?;
@@ -2598,7 +2598,7 @@ impl Compiler {
         // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
         // RERAISE 1: reraise with lasti
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::CopyItem { index: 3_u32 });
+        emit!(self, Instruction::Copy { index: 3_u32 });
         emit!(self, Instruction::PopExcept);
         emit!(
             self,
@@ -2693,7 +2693,7 @@ impl Compiler {
         if let Some(cleanup) = finally_cleanup_block {
             self.switch_to_block(cleanup);
             // COPY 3: copy the exception from position 3
-            emit!(self, Instruction::CopyItem { index: 3_u32 });
+            emit!(self, Instruction::Copy { index: 3_u32 });
             // POP_EXCEPT: restore prev_exc as current exception
             emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
@@ -2787,7 +2787,7 @@ impl Compiler {
                 emit!(self, Instruction::BuildList { size: 0 });
                 // Stack: [prev_exc, exc, []]
                 // ADDOP_I(c, loc, COPY, 2);
-                emit!(self, Instruction::CopyItem { index: 2 });
+                emit!(self, Instruction::Copy { index: 2 });
                 // Stack: [prev_exc, exc, [], exc_copy]
                 // Now stack is: [prev_exc, orig, list, rest]
             }
@@ -2817,7 +2817,7 @@ impl Compiler {
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::CopyItem { index: 1 });
+            emit!(self, Instruction::Copy { index: 1 });
             self.emit_load_const(ConstantData::None);
             emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
             emit!(
@@ -2947,7 +2947,7 @@ impl Compiler {
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::CopyItem { index: 1 });
+        emit!(self, Instruction::Copy { index: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
@@ -3149,7 +3149,7 @@ impl Compiler {
 
         // Handle docstring if present
         if let Some(doc) = doc_str {
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.emit_load_const(ConstantData::Str {
                 value: doc.to_string().into(),
             });
@@ -3633,7 +3633,7 @@ impl Compiler {
 
         if let Some(classcell_idx) = classcell_idx {
             emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, Instruction::StoreName(classcell));
         } else {
@@ -4081,7 +4081,7 @@ impl Compiler {
         // to be in the exception table for these instructions.
         // If we cleared fblock, exceptions here would propagate uncaught.
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::CopyItem { index: 3 });
+        emit!(self, Instruction::Copy { index: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -4384,7 +4384,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
@@ -4457,7 +4457,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -4558,7 +4558,7 @@ impl Compiler {
         // 2. Emit MATCH_CLASS with nargs.
         emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
@@ -4723,7 +4723,7 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
+        emit!(self, Instruction::Copy { index: 1_u32 });
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
@@ -4776,7 +4776,7 @@ impl Compiler {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
                 emit!(
                     self,
-                    Instruction::CopyItem {
+                    Instruction::Copy {
                         index: 1 + remaining
                     }
                 );
@@ -4833,7 +4833,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5080,7 +5080,7 @@ impl Compiler {
         for (i, m) in cases.iter().enumerate().take(case_count) {
             // Only copy the subject if not on the last case
             if i != case_count - 1 {
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -5127,7 +5127,7 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(self, Instruction::PopJumpIfFalse { target: end });
                 emit!(self, Instruction::PopTop);
             }
@@ -5207,13 +5207,13 @@ impl Compiler {
 
             // store rhs for the next comparison in chain
             emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::CopyItem { index: 2 });
+            emit!(self, Instruction::Copy { index: 2 });
 
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
             /*
-            emit!(self, Instruction::CopyItem { index: 1 });
+            emit!(self, Instruction::Copy { index: 1 });
             // emit!(self, Instruction::ToBool); // TODO: Uncomment this
             emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
             emit!(self, Instruction::PopTop);
@@ -5398,8 +5398,8 @@ impl Compiler {
                 // But we can't use compile_subscript directly because we need DUP_TOP2
                 self.compile_expression(value)?;
                 self.compile_expression(slice)?;
-                emit!(self, Instruction::CopyItem { index: 2_u32 });
-                emit!(self, Instruction::CopyItem { index: 2_u32 });
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { index: 2_u32 });
                 emit!(self, Instruction::Subscript);
                 AugAssignKind::Subscript
             }
@@ -5407,7 +5407,7 @@ impl Compiler {
                 let attr = attr.as_str();
                 self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 let idx = self.name(attr);
                 emit!(self, Instruction::LoadAttr { idx });
                 AugAssignKind::Attr { idx }
@@ -5564,7 +5564,7 @@ impl Compiler {
         for value in values {
             self.compile_expression(value)?;
 
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
+            emit!(self, Instruction::Copy { index: 1_u32 });
             match op {
                 BoolOp::And => {
                     emit!(
@@ -6062,7 +6062,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
+                emit!(self, Instruction::Copy { index: 1_u32 });
                 self.compile_store(target)?;
             }
             Expr::FString(fstring) => {
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 8c4790e03ff..61707b7757e 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -14,6 +14,10 @@ use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
+pub use crate::bytecode::instruction::Instruction;
+
+mod instruction;
+
 /// Exception table entry for zero-cost exception handling
 /// Format: (start, size, target, depth<<1|lasti)
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -670,354 +674,6 @@ op_arg_enum!(
 
 pub type NameIdx = u32;
 
-/// A Single bytecode instruction.
-/// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
-/// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-#[repr(u8)]
-pub enum Instruction {
-    // ==================== No-argument instructions (opcode < 44) ====================
-    Cache = 0, // Placeholder
-    BeforeAsyncWith = 1,
-    BeforeWith = 2,
-    BinaryOpInplaceAddUnicode = 3, // Placeholder
-    BinarySlice = 4,               // Placeholder
-    BinarySubscr = 5,
-    CheckEgMatch = 6,
-    CheckExcMatch = 7,
-    CleanupThrow = 8,
-    DeleteSubscr = 9,
-    EndAsyncFor = 10,
-    EndFor = 11, // Placeholder
-    EndSend = 12,
-    ExitInitCheck = 13, // Placeholder
-    FormatSimple = 14,
-    FormatWithSpec = 15,
-    GetAIter = 16,
-    Reserved = 17,
-    GetANext = 18,
-    GetIter = 19,
-    GetLen = 20,
-    GetYieldFromIter = 21,
-    InterpreterExit = 22,    // Placeholder
-    LoadAssertionError = 23, // Placeholder
-    LoadBuildClass = 24,
-    LoadLocals = 25, // Placeholder
-    MakeFunction = 26,
-    MatchKeys = 27,
-    MatchMapping = 28,
-    MatchSequence = 29,
-    Nop = 30,
-    PopExcept = 31,
-    PopTop = 32,
-    PushExcInfo = 33,
-    PushNull = 34,        // Placeholder
-    ReturnGenerator = 35, // Placeholder
-    ReturnValue = 36,
-    SetupAnnotations = 37,
-    StoreSlice = 38, // Placeholder
-    StoreSubscr = 39,
-    ToBool = 40,
-    UnaryInvert = 41,
-    UnaryNegative = 42,
-    UnaryNot = 43,
-    WithExceptStart = 44,
-    // ==================== With-argument instructions (opcode > 44) ====================
-    BinaryOp {
-        op: Arg<BinaryOperator>,
-    } = 45,
-    BuildConstKeyMap {
-        size: Arg<u32>,
-    } = 46, // Placeholder
-    BuildList {
-        size: Arg<u32>,
-    } = 47,
-    BuildMap {
-        size: Arg<u32>,
-    } = 48,
-    BuildSet {
-        size: Arg<u32>,
-    } = 49,
-    BuildSlice {
-        argc: Arg<BuildSliceArgCount>,
-    } = 50,
-    BuildString {
-        size: Arg<u32>,
-    } = 51,
-    BuildTuple {
-        size: Arg<u32>,
-    } = 52,
-    Call {
-        nargs: Arg<u32>,
-    } = 53,
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    } = 54,
-    CallIntrinsic1 {
-        func: Arg<IntrinsicFunction1>,
-    } = 55,
-    CallIntrinsic2 {
-        func: Arg<IntrinsicFunction2>,
-    } = 56,
-    CallKw {
-        nargs: Arg<u32>,
-    } = 57,
-    CompareOp {
-        op: Arg<ComparisonOperator>,
-    } = 58,
-    ContainsOp(Arg<Invert>) = 59,
-    ConvertValue {
-        oparg: Arg<ConvertValueOparg>,
-    } = 60,
-    CopyItem {
-        index: Arg<u32>,
-    } = 61,
-    CopyFreeVars {
-        count: Arg<u32>,
-    } = 62, // Placeholder
-    DeleteAttr {
-        idx: Arg<NameIdx>,
-    } = 63,
-    DeleteDeref(Arg<NameIdx>) = 64,
-    DeleteFast(Arg<NameIdx>) = 65,
-    DeleteGlobal(Arg<NameIdx>) = 66,
-    DeleteName(Arg<NameIdx>) = 67,
-    DictMerge {
-        index: Arg<u32>,
-    } = 68, // Placeholder
-    DictUpdate {
-        index: Arg<u32>,
-    } = 69,
-    EnterExecutor = 70, // Placeholder
-    ExtendedArg = 71,
-    ForIter {
-        target: Arg<Label>,
-    } = 72,
-    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
-    ImportFrom {
-        idx: Arg<NameIdx>,
-    } = 74,
-    ImportName {
-        idx: Arg<NameIdx>,
-    } = 75,
-    IsOp(Arg<Invert>) = 76,
-    JumpBackward {
-        target: Arg<Label>,
-    } = 77, // Placeholder
-    JumpBackwardNoInterrupt {
-        target: Arg<Label>,
-    } = 78, // Placeholder
-    JumpForward {
-        target: Arg<Label>,
-    } = 79, // Placeholder
-    ListAppend {
-        i: Arg<u32>,
-    } = 80,
-    ListExtend {
-        i: Arg<u32>,
-    } = 81, // Placeholder
-    LoadAttr {
-        idx: Arg<NameIdx>,
-    } = 82,
-    LoadConst {
-        idx: Arg<u32>,
-    } = 83,
-    LoadDeref(Arg<NameIdx>) = 84,
-    LoadFast(Arg<NameIdx>) = 85,
-    LoadFastAndClear(Arg<NameIdx>) = 86,
-    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
-    LoadFastLoadFast {
-        arg: Arg<u32>,
-    } = 88, // Placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
-    LoadGlobal(Arg<NameIdx>) = 91,
-    LoadName(Arg<NameIdx>) = 92,
-    LoadSuperAttr {
-        arg: Arg<u32>,
-    } = 93, // Placeholder
-    MakeCell(Arg<NameIdx>) = 94, // Placeholder
-    MapAdd {
-        i: Arg<u32>,
-    } = 95,
-    MatchClass(Arg<u32>) = 96,
-    PopJumpIfFalse {
-        target: Arg<Label>,
-    } = 97,
-    PopJumpIfNone {
-        target: Arg<Label>,
-    } = 98, // Placeholder
-    PopJumpIfNotNone {
-        target: Arg<Label>,
-    } = 99, // Placeholder
-    PopJumpIfTrue {
-        target: Arg<Label>,
-    } = 100,
-    RaiseVarargs {
-        kind: Arg<RaiseKind>,
-    } = 101,
-    Reraise {
-        depth: Arg<u32>,
-    } = 102,
-    ReturnConst {
-        idx: Arg<u32>,
-    } = 103,
-    Send {
-        target: Arg<Label>,
-    } = 104,
-    SetAdd {
-        i: Arg<u32>,
-    } = 105,
-    SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
-    } = 106,
-    SetUpdate {
-        i: Arg<u32>,
-    } = 107, // Placeholder
-    StoreAttr {
-        idx: Arg<NameIdx>,
-    } = 108,
-    StoreDeref(Arg<NameIdx>) = 109,
-    StoreFast(Arg<NameIdx>) = 110,
-    StoreFastLoadFast {
-        store_idx: Arg<NameIdx>,
-        load_idx: Arg<NameIdx>,
-    } = 111,
-    StoreFastStoreFast {
-        arg: Arg<u32>,
-    } = 112, // Placeholder
-    StoreGlobal(Arg<NameIdx>) = 113,
-    StoreName(Arg<NameIdx>) = 114,
-    Swap {
-        index: Arg<u32>,
-    } = 115,
-    UnpackEx {
-        args: Arg<UnpackExArgs>,
-    } = 116,
-    UnpackSequence {
-        size: Arg<u32>,
-    } = 117,
-    YieldValue {
-        arg: Arg<u32>,
-    } = 118,
-    Resume {
-        arg: Arg<u32>,
-    } = 149,
-    // ==================== RustPython-only instructions (119-135) ====================
-    // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
-    // So we assign random IDs to these opcodes.
-    Break {
-        target: Arg<Label>,
-    } = 119,
-    BuildListFromTuples {
-        size: Arg<u32>,
-    } = 120,
-    BuildMapForCall {
-        size: Arg<u32>,
-    } = 121,
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    } = 122,
-    BuildTupleFromIter = 123,
-    BuildTupleFromTuples {
-        size: Arg<u32>,
-    } = 124,
-    Continue {
-        target: Arg<Label>,
-    } = 128,
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    } = 129,
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    } = 130,
-    JumpIfNotExcMatch(Arg<Label>) = 131,
-    SetExcInfo = 134,
-    Subscript = 135,
-    // ===== Pseudo Opcodes (252+) ======
-    Jump {
-        target: Arg<Label>,
-    } = 252, // CPython uses pseudo-op 256
-    LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
-    LoadAttrMethod {
-        idx: Arg<NameIdx>,
-    } = 254, // CPython uses pseudo-op 259
-    PopBlock = 255,                  // CPython uses pseudo-op 263
-}
-
-const _: () = assert!(mem::size_of::<Instruction>() == 1);
-
-impl From<Instruction> for u8 {
-    #[inline]
-    fn from(ins: Instruction) -> Self {
-        // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
-    }
-}
-
-impl TryFrom<u8> for Instruction {
-    type Error = MarshalError;
-
-    #[inline]
-    fn try_from(value: u8) -> Result<Self, MarshalError> {
-        // CPython-compatible opcodes (0-118)
-        let cpython_start = u8::from(Self::Cache);
-        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
-
-        // Resume has a non-contiguous opcode (149)
-        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
-
-        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
-        let custom_ops: &[u8] = &[
-            u8::from(Self::Break {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::BuildListFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildMapForCall {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildSetFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildTupleFromIter),
-            u8::from(Self::BuildTupleFromTuples {
-                size: Arg::marker(),
-            }),
-            // 125, 126, 127 are unused
-            u8::from(Self::Continue {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfFalseOrPop {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfTrueOrPop {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::SetExcInfo),
-            u8::from(Self::Subscript),
-        ];
-
-        // Pseudo opcodes (252-255)
-        let pseudo_start = u8::from(Self::Jump {
-            target: Arg::marker(),
-        });
-        let pseudo_end = u8::from(Self::PopBlock);
-
-        if (cpython_start..=cpython_end).contains(&value)
-            || value == resume_id
-            || custom_ops.contains(&value)
-            || (pseudo_start..=pseudo_end).contains(&value)
-        {
-            Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
-        } else {
-            Err(Self::Error::InvalidBytecode)
-        }
-    }
-}
-
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
@@ -1085,8 +741,6 @@ impl Deref for CodeUnits {
     }
 }
 
-use self::Instruction::*;
-
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
     pub struct MakeFunctionFlags: u8 {
@@ -1727,447 +1381,6 @@ impl<C: Constant> fmt::Display for CodeObject<C> {
     }
 }
 
-impl Instruction {
-    /// Gets the label stored inside this instruction, if it exists
-    #[inline]
-    pub const fn label_arg(&self) -> Option<Arg<Label>> {
-        match self {
-            Jump { target: l }
-            | JumpBackward { target: l }
-            | JumpBackwardNoInterrupt { target: l }
-            | JumpForward { target: l }
-            | JumpIfNotExcMatch(l)
-            | PopJumpIfTrue { target: l }
-            | PopJumpIfFalse { target: l }
-            | JumpIfTrueOrPop { target: l }
-            | JumpIfFalseOrPop { target: l }
-            | ForIter { target: l }
-            | Break { target: l }
-            | Continue { target: l }
-            | Send { target: l } => Some(*l),
-            _ => None,
-        }
-    }
-
-    /// Whether this is an unconditional branching
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
-    pub const fn unconditional_branch(&self) -> bool {
-        matches!(
-            self,
-            Jump { .. }
-                | JumpForward { .. }
-                | JumpBackward { .. }
-                | JumpBackwardNoInterrupt { .. }
-                | Continue { .. }
-                | Break { .. }
-                | ReturnValue
-                | ReturnConst { .. }
-                | RaiseVarargs { .. }
-                | Reraise { .. }
-        )
-    }
-
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
-    ///
-    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
-        match self {
-            Nop => 0,
-            ImportName { .. } => -1,
-            ImportFrom { .. } => 1,
-            LoadFast(_) | LoadFastAndClear(_) | LoadName(_) | LoadGlobal(_) | LoadDeref(_) => 1,
-            StoreFast(_) | StoreName(_) | StoreGlobal(_) | StoreDeref(_) => -1,
-            StoreFastLoadFast { .. } => 0, // pop 1, push 1
-            DeleteFast(_) | DeleteName(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
-            LoadClosure(_) => 1,
-            Subscript => -1,
-            StoreSubscr => -3,
-            LoadFromDictOrDeref(_) => 1,
-            DeleteSubscr => -2,
-            LoadAttr { .. } => 0,
-            // LoadAttrMethod: pop obj, push method + self_or_null
-            LoadAttrMethod { .. } => 1,
-            StoreAttr { .. } => -2,
-            DeleteAttr { .. } => -1,
-            LoadConst { .. } => 1,
-            Reserved => 0,
-            BinaryOp { .. } | CompareOp { .. } => -1,
-            BinarySubscr => -1,
-            CopyItem { .. } => 1,
-            PopTop => -1,
-            Swap { .. } => 0,
-            ToBool => 0,
-            GetIter => 0,
-            GetLen => 1,
-            CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
-            CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
-            Continue { .. } => 0,
-            Break { .. } => 0,
-            Jump { .. } => 0,
-            PopJumpIfTrue { .. } | PopJumpIfFalse { .. } => -1,
-            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
-            MakeFunction => {
-                // CPython 3.13 style: MakeFunction only pops code object
-                -1 + 1 // pop code, push function
-            }
-            SetFunctionAttribute { .. } => {
-                // pops attribute value and function, pushes function back
-                -2 + 1
-            }
-            // Call: pops nargs + self_or_null + callable, pushes result
-            Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
-            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
-            CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
-            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
-            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
-            CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
-            ConvertValue { .. } => 0,
-            FormatSimple => 0,
-            FormatWithSpec => -1,
-            ForIter { .. } => {
-                if jump {
-                    -1
-                } else {
-                    1
-                }
-            }
-            IsOp(_) | ContainsOp(_) => -1,
-            JumpIfNotExcMatch(_) => -2,
-            ReturnValue => -1,
-            ReturnConst { .. } => 0,
-            Resume { .. } => 0,
-            YieldValue { .. } => 0,
-            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
-            Send { .. } => 0,
-            // END_SEND: (receiver, value) -> (value)
-            EndSend => -1,
-            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
-            CleanupThrow => -1,
-            SetExcInfo => 0,
-            PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
-            CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
-            Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
-            SetupAnnotations => 0,
-            BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
-            WithExceptStart => 1, // push __exit__ result
-            PopBlock => 0,
-            RaiseVarargs { kind } => {
-                // Stack effects for different raise kinds:
-                // - Reraise (0): gets from VM state, no stack pop
-                // - Raise (1): pops 1 exception
-                // - RaiseCause (2): pops 2 (exception + cause)
-                // - ReraiseFromStack (3): pops 1 exception from stack
-                match kind.get(arg) {
-                    RaiseKind::BareRaise => 0,
-                    RaiseKind::Raise => -1,
-                    RaiseKind::RaiseCause => -2,
-                    RaiseKind::ReraiseFromStack => -1,
-                }
-            }
-            BuildString { size }
-            | BuildTuple { size, .. }
-            | BuildTupleFromTuples { size, .. }
-            | BuildList { size, .. }
-            | BuildListFromTuples { size, .. }
-            | BuildSet { size, .. }
-            | BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
-            BuildTupleFromIter => 0,
-            BuildMap { size } => {
-                let nargs = size.get(arg) * 2;
-                -(nargs as i32) + 1
-            }
-            BuildMapForCall { size } => {
-                let nargs = size.get(arg);
-                -(nargs as i32) + 1
-            }
-            DictUpdate { .. } => -1,
-            BuildSlice { argc } => {
-                // push 1
-                // pops either 2/3
-                // Default to Two (2 args) if arg is invalid
-                1 - (argc
-                    .try_get(arg)
-                    .unwrap_or(BuildSliceArgCount::Two)
-                    .argc()
-                    .get() as i32)
-            }
-            ListAppend { .. } | SetAdd { .. } => -1,
-            MapAdd { .. } => -2,
-            LoadBuildClass => 1,
-            UnpackSequence { size } => -1 + size.get(arg) as i32,
-            UnpackEx { args } => {
-                let UnpackExArgs { before, after } = args.get(arg);
-                -1 + before as i32 + 1 + after as i32
-            }
-            PopExcept => 0,
-            GetAwaitable => 0,
-            BeforeAsyncWith => 1,
-            GetAIter => 0,
-            GetANext => 1,
-            EndAsyncFor => -2,                 // pops (awaitable, exc) from stack
-            MatchMapping | MatchSequence => 1, // Push bool result
-            MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
-            MatchClass(_) => -2,
-            ExtendedArg => 0,
-            UnaryInvert => 0,
-            UnaryNegative => 0,
-            UnaryNot => 0,
-            GetYieldFromIter => 0,
-            PushNull => 1, // Push NULL for call protocol
-            Cache => 0,
-            BinarySlice => 0,
-            BinaryOpInplaceAddUnicode => 0,
-            EndFor => 0,
-            ExitInitCheck => 0,
-            InterpreterExit => 0,
-            LoadAssertionError => 0,
-            LoadLocals => 0,
-            ReturnGenerator => 0,
-            StoreSlice => 0,
-            DictMerge { .. } => 0,
-            BuildConstKeyMap { .. } => 0,
-            CopyFreeVars { .. } => 0,
-            EnterExecutor => 0,
-            JumpBackwardNoInterrupt { .. } => 0,
-            JumpBackward { .. } => 0,
-            JumpForward { .. } => 0,
-            ListExtend { .. } => 0,
-            LoadFastCheck(_) => 0,
-            LoadFastLoadFast { .. } => 0,
-            LoadFromDictOrGlobals(_) => 0,
-            SetUpdate { .. } => 0,
-            MakeCell(_) => 0,
-            LoadSuperAttr { .. } => 0,
-            StoreFastStoreFast { .. } => 0,
-            PopJumpIfNone { .. } => 0,
-            PopJumpIfNotNone { .. } => 0,
-        }
-    }
-
-    pub fn display<'a>(
-        &'a self,
-        arg: OpArg,
-        ctx: &'a impl InstrDisplayContext,
-    ) -> impl fmt::Display + 'a {
-        struct FmtFn<F>(F);
-        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                (self.0)(f)
-            }
-        }
-        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn fmt_dis(
-        &self,
-        arg: OpArg,
-        f: &mut fmt::Formatter<'_>,
-        ctx: &impl InstrDisplayContext,
-        expand_code_objects: bool,
-        pad: usize,
-        level: usize,
-    ) -> fmt::Result {
-        macro_rules! w {
-            ($variant:ident) => {
-                write!(f, stringify!($variant))
-            };
-            ($variant:ident, $map:ident = $arg_marker:expr) => {{
-                let arg = $arg_marker.get(arg);
-                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
-            }};
-            ($variant:ident, $arg_marker:expr) => {
-                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
-            };
-            ($variant:ident, ?$arg_marker:expr) => {
-                write!(
-                    f,
-                    "{:pad$}({:?})",
-                    stringify!($variant),
-                    $arg_marker.get(arg)
-                )
-            };
-        }
-
-        let varname = |i: u32| ctx.get_varname(i as usize);
-        let name = |i: u32| ctx.get_name(i as usize);
-        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
-
-        let fmt_const =
-            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
-                let value = ctx.get_constant(idx.get(arg) as usize);
-                match value.borrow_constant() {
-                    BorrowedConstant::Code { code } if expand_code_objects => {
-                        write!(f, "{op:pad$}({code:?}):")?;
-                        code.display_inner(f, true, level + 1)?;
-                        Ok(())
-                    }
-                    c => {
-                        write!(f, "{op:pad$}(")?;
-                        c.fmt_display(f)?;
-                        write!(f, ")")
-                    }
-                }
-            };
-
-        match self {
-            BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
-            BeforeWith => w!(BEFORE_WITH),
-            BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-            BinarySubscr => w!(BINARY_SUBSCR),
-            Break { target } => w!(BREAK, target),
-            BuildList { size } => w!(BUILD_LIST, size),
-            BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
-            BuildMap { size } => w!(BUILD_MAP, size),
-            BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
-            BuildSet { size } => w!(BUILD_SET, size),
-            BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
-            BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
-            BuildString { size } => w!(BUILD_STRING, size),
-            BuildTuple { size } => w!(BUILD_TUPLE, size),
-            BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
-            BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
-            Call { nargs } => w!(CALL, nargs),
-            CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
-            CallKw { nargs } => w!(CALL_KW, nargs),
-            CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
-            CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
-            CheckEgMatch => w!(CHECK_EG_MATCH),
-            CheckExcMatch => w!(CHECK_EXC_MATCH),
-            CleanupThrow => w!(CLEANUP_THROW),
-            CompareOp { op } => w!(COMPARE_OP, ?op),
-            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            Continue { target } => w!(CONTINUE, target),
-            ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
-            CopyItem { index } => w!(COPY, index),
-            DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
-            DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
-            DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
-            DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
-            DeleteName(idx) => w!(DELETE_NAME, name = idx),
-            DeleteSubscr => w!(DELETE_SUBSCR),
-            DictUpdate { index } => w!(DICT_UPDATE, index),
-            EndAsyncFor => w!(END_ASYNC_FOR),
-            EndSend => w!(END_SEND),
-            ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
-            ForIter { target } => w!(FOR_ITER, target),
-            FormatSimple => w!(FORMAT_SIMPLE),
-            FormatWithSpec => w!(FORMAT_WITH_SPEC),
-            GetAIter => w!(GET_AITER),
-            GetANext => w!(GET_ANEXT),
-            GetAwaitable => w!(GET_AWAITABLE),
-            Reserved => w!(RESERVED),
-            GetIter => w!(GET_ITER),
-            GetLen => w!(GET_LEN),
-            ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
-            ImportName { idx } => w!(IMPORT_NAME, name = idx),
-            IsOp(inv) => w!(IS_OP, ?inv),
-            Jump { target } => w!(JUMP, target),
-            JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            JumpForward { target } => w!(JUMP_FORWARD, target),
-            JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
-            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
-            ListAppend { i } => w!(LIST_APPEND, i),
-            LoadAttr { idx } => {
-                let encoded = idx.get(arg);
-                let (name_idx, is_method) = decode_load_attr_arg(encoded);
-                let attr_name = name(name_idx);
-                if is_method {
-                    write!(
-                        f,
-                        "{:pad$}({}, {}, method=true)",
-                        "LOAD_ATTR", encoded, attr_name
-                    )
-                } else {
-                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
-                }
-            }
-            LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
-            LoadBuildClass => w!(LOAD_BUILD_CLASS),
-            LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
-            LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
-            LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
-            LoadFast(idx) => w!(LOAD_FAST, varname = idx),
-            LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
-            LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
-            LoadName(idx) => w!(LOAD_NAME, name = idx),
-            MakeFunction => w!(MAKE_FUNCTION),
-            MapAdd { i } => w!(MAP_ADD, i),
-            MatchClass(arg) => w!(MATCH_CLASS, arg),
-            MatchKeys => w!(MATCH_KEYS),
-            MatchMapping => w!(MATCH_MAPPING),
-            MatchSequence => w!(MATCH_SEQUENCE),
-            Nop => w!(NOP),
-            PopBlock => w!(POP_BLOCK),
-            PopExcept => w!(POP_EXCEPT),
-            PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
-            PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
-            PopTop => w!(POP_TOP),
-            PushExcInfo => w!(PUSH_EXC_INFO),
-            PushNull => w!(PUSH_NULL),
-            RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
-            Reraise { depth } => w!(RERAISE, depth),
-            Resume { arg } => w!(RESUME, arg),
-            ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
-            ReturnValue => w!(RETURN_VALUE),
-            Send { target } => w!(SEND, target),
-            SetAdd { i } => w!(SET_ADD, i),
-            SetExcInfo => w!(SET_EXC_INFO),
-            SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
-            SetupAnnotations => w!(SETUP_ANNOTATIONS),
-            StoreAttr { idx } => w!(STORE_ATTR, name = idx),
-            StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
-            StoreFast(idx) => w!(STORE_FAST, varname = idx),
-            StoreFastLoadFast {
-                store_idx,
-                load_idx,
-            } => {
-                write!(f, "STORE_FAST_LOAD_FAST")?;
-                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
-            }
-            StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            StoreName(idx) => w!(STORE_NAME, name = idx),
-            StoreSubscr => w!(STORE_SUBSCR),
-            Subscript => w!(SUBSCRIPT),
-            Swap { index } => w!(SWAP, index),
-            ToBool => w!(TO_BOOL),
-            UnpackEx { args } => w!(UNPACK_EX, args),
-            UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
-            WithExceptStart => w!(WITH_EXCEPT_START),
-            UnaryInvert => w!(UNARY_INVERT),
-            UnaryNegative => w!(UNARY_NEGATIVE),
-            UnaryNot => w!(UNARY_NOT),
-            YieldValue { arg } => w!(YIELD_VALUE, arg),
-            GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
-            _ => w!(RUSTPYTHON_PLACEHOLDER),
-        }
-    }
-}
-
 pub trait InstrDisplayContext {
     type Constant: Constant;
 
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
new file mode 100644
index 00000000000..24cccbb3ed2
--- /dev/null
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -0,0 +1,822 @@
+use alloc::fmt;
+use std::mem;
+
+use crate::{
+    bytecode::{
+        Arg, BinaryOperator, BorrowedConstant, BuildSliceArgCount, ComparisonOperator, Constant,
+        ConvertValueOparg, InstrDisplayContext, IntrinsicFunction1, IntrinsicFunction2, Invert,
+        Label, MakeFunctionFlags, NameIdx, OpArg, RaiseKind, UnpackExArgs, decode_load_attr_arg,
+    },
+    marshal::MarshalError,
+};
+
+/// A Single bytecode instruction.
+/// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
+/// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Instruction {
+    // ==================== No-argument instructions (opcode < 44) ====================
+    Cache = 0, // Placeholder
+    BeforeAsyncWith = 1,
+    BeforeWith = 2,
+    BinaryOpInplaceAddUnicode = 3, // Placeholder
+    BinarySlice = 4,               // Placeholder
+    BinarySubscr = 5,
+    CheckEgMatch = 6,
+    CheckExcMatch = 7,
+    CleanupThrow = 8,
+    DeleteSubscr = 9,
+    EndAsyncFor = 10,
+    EndFor = 11, // Placeholder
+    EndSend = 12,
+    ExitInitCheck = 13, // Placeholder
+    FormatSimple = 14,
+    FormatWithSpec = 15,
+    GetAIter = 16,
+    Reserved = 17,
+    GetANext = 18,
+    GetIter = 19,
+    GetLen = 20,
+    GetYieldFromIter = 21,
+    InterpreterExit = 22,    // Placeholder
+    LoadAssertionError = 23, // Placeholder
+    LoadBuildClass = 24,
+    LoadLocals = 25, // Placeholder
+    MakeFunction = 26,
+    MatchKeys = 27,
+    MatchMapping = 28,
+    MatchSequence = 29,
+    Nop = 30,
+    PopExcept = 31,
+    PopTop = 32,
+    PushExcInfo = 33,
+    PushNull = 34,        // Placeholder
+    ReturnGenerator = 35, // Placeholder
+    ReturnValue = 36,
+    SetupAnnotations = 37,
+    StoreSlice = 38, // Placeholder
+    StoreSubscr = 39,
+    ToBool = 40,
+    UnaryInvert = 41,
+    UnaryNegative = 42,
+    UnaryNot = 43,
+    WithExceptStart = 44,
+    // ==================== With-argument instructions (opcode > 44) ====================
+    BinaryOp {
+        op: Arg<BinaryOperator>,
+    } = 45,
+    BuildConstKeyMap {
+        size: Arg<u32>,
+    } = 46, // Placeholder
+    BuildList {
+        size: Arg<u32>,
+    } = 47,
+    BuildMap {
+        size: Arg<u32>,
+    } = 48,
+    BuildSet {
+        size: Arg<u32>,
+    } = 49,
+    BuildSlice {
+        argc: Arg<BuildSliceArgCount>,
+    } = 50,
+    BuildString {
+        size: Arg<u32>,
+    } = 51,
+    BuildTuple {
+        size: Arg<u32>,
+    } = 52,
+    Call {
+        nargs: Arg<u32>,
+    } = 53,
+    CallFunctionEx {
+        has_kwargs: Arg<bool>,
+    } = 54,
+    CallIntrinsic1 {
+        func: Arg<IntrinsicFunction1>,
+    } = 55,
+    CallIntrinsic2 {
+        func: Arg<IntrinsicFunction2>,
+    } = 56,
+    CallKw {
+        nargs: Arg<u32>,
+    } = 57,
+    CompareOp {
+        op: Arg<ComparisonOperator>,
+    } = 58,
+    ContainsOp(Arg<Invert>) = 59,
+    ConvertValue {
+        oparg: Arg<ConvertValueOparg>,
+    } = 60,
+    Copy {
+        index: Arg<u32>,
+    } = 61,
+    CopyFreeVars {
+        count: Arg<u32>,
+    } = 62, // Placeholder
+    DeleteAttr {
+        idx: Arg<NameIdx>,
+    } = 63,
+    DeleteDeref(Arg<NameIdx>) = 64,
+    DeleteFast(Arg<NameIdx>) = 65,
+    DeleteGlobal(Arg<NameIdx>) = 66,
+    DeleteName(Arg<NameIdx>) = 67,
+    DictMerge {
+        index: Arg<u32>,
+    } = 68, // Placeholder
+    DictUpdate {
+        index: Arg<u32>,
+    } = 69,
+    EnterExecutor = 70, // Placeholder
+    ExtendedArg = 71,
+    ForIter {
+        target: Arg<Label>,
+    } = 72,
+    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
+    ImportFrom {
+        idx: Arg<NameIdx>,
+    } = 74,
+    ImportName {
+        idx: Arg<NameIdx>,
+    } = 75,
+    IsOp(Arg<Invert>) = 76,
+    JumpBackward {
+        target: Arg<Label>,
+    } = 77, // Placeholder
+    JumpBackwardNoInterrupt {
+        target: Arg<Label>,
+    } = 78, // Placeholder
+    JumpForward {
+        target: Arg<Label>,
+    } = 79, // Placeholder
+    ListAppend {
+        i: Arg<u32>,
+    } = 80,
+    ListExtend {
+        i: Arg<u32>,
+    } = 81, // Placeholder
+    LoadAttr {
+        idx: Arg<NameIdx>,
+    } = 82,
+    LoadConst {
+        idx: Arg<u32>,
+    } = 83,
+    LoadDeref(Arg<NameIdx>) = 84,
+    LoadFast(Arg<NameIdx>) = 85,
+    LoadFastAndClear(Arg<NameIdx>) = 86,
+    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
+    LoadFastLoadFast {
+        arg: Arg<u32>,
+    } = 88, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
+    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
+    LoadGlobal(Arg<NameIdx>) = 91,
+    LoadName(Arg<NameIdx>) = 92,
+    LoadSuperAttr {
+        arg: Arg<u32>,
+    } = 93, // Placeholder
+    MakeCell(Arg<NameIdx>) = 94, // Placeholder
+    MapAdd {
+        i: Arg<u32>,
+    } = 95,
+    MatchClass(Arg<u32>) = 96,
+    PopJumpIfFalse {
+        target: Arg<Label>,
+    } = 97,
+    PopJumpIfNone {
+        target: Arg<Label>,
+    } = 98, // Placeholder
+    PopJumpIfNotNone {
+        target: Arg<Label>,
+    } = 99, // Placeholder
+    PopJumpIfTrue {
+        target: Arg<Label>,
+    } = 100,
+    RaiseVarargs {
+        kind: Arg<RaiseKind>,
+    } = 101,
+    Reraise {
+        depth: Arg<u32>,
+    } = 102,
+    ReturnConst {
+        idx: Arg<u32>,
+    } = 103,
+    Send {
+        target: Arg<Label>,
+    } = 104,
+    SetAdd {
+        i: Arg<u32>,
+    } = 105,
+    SetFunctionAttribute {
+        attr: Arg<MakeFunctionFlags>,
+    } = 106,
+    SetUpdate {
+        i: Arg<u32>,
+    } = 107, // Placeholder
+    StoreAttr {
+        idx: Arg<NameIdx>,
+    } = 108,
+    StoreDeref(Arg<NameIdx>) = 109,
+    StoreFast(Arg<NameIdx>) = 110,
+    StoreFastLoadFast {
+        store_idx: Arg<NameIdx>,
+        load_idx: Arg<NameIdx>,
+    } = 111,
+    StoreFastStoreFast {
+        arg: Arg<u32>,
+    } = 112, // Placeholder
+    StoreGlobal(Arg<NameIdx>) = 113,
+    StoreName(Arg<NameIdx>) = 114,
+    Swap {
+        index: Arg<u32>,
+    } = 115,
+    UnpackEx {
+        args: Arg<UnpackExArgs>,
+    } = 116,
+    UnpackSequence {
+        size: Arg<u32>,
+    } = 117,
+    YieldValue {
+        arg: Arg<u32>,
+    } = 118,
+    Resume {
+        arg: Arg<u32>,
+    } = 149,
+    // ==================== RustPython-only instructions (119-135) ====================
+    // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
+    // So we assign random IDs to these opcodes.
+    Break {
+        target: Arg<Label>,
+    } = 119,
+    BuildListFromTuples {
+        size: Arg<u32>,
+    } = 120,
+    BuildMapForCall {
+        size: Arg<u32>,
+    } = 121,
+    BuildSetFromTuples {
+        size: Arg<u32>,
+    } = 122,
+    BuildTupleFromIter = 123,
+    BuildTupleFromTuples {
+        size: Arg<u32>,
+    } = 124,
+    Continue {
+        target: Arg<Label>,
+    } = 128,
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
+    } = 129,
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
+    } = 130,
+    JumpIfNotExcMatch(Arg<Label>) = 131,
+    SetExcInfo = 134,
+    Subscript = 135,
+    // ===== Pseudo Opcodes (252+) ======
+    Jump {
+        target: Arg<Label>,
+    } = 252, // CPython uses pseudo-op 256
+    LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
+    LoadAttrMethod {
+        idx: Arg<NameIdx>,
+    } = 254, // CPython uses pseudo-op 259
+    PopBlock = 255,                  // CPython uses pseudo-op 263
+}
+
+const _: () = assert!(mem::size_of::<Instruction>() == 1);
+
+impl From<Instruction> for u8 {
+    #[inline]
+    fn from(ins: Instruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u8> for Instruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u8) -> Result<Self, MarshalError> {
+        // CPython-compatible opcodes (0-118)
+        let cpython_start = u8::from(Self::Cache);
+        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
+
+        // Resume has a non-contiguous opcode (149)
+        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+
+        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
+        let custom_ops: &[u8] = &[
+            u8::from(Self::Break {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::BuildListFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildMapForCall {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildSetFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildTupleFromIter),
+            u8::from(Self::BuildTupleFromTuples {
+                size: Arg::marker(),
+            }),
+            // 125, 126, 127 are unused
+            u8::from(Self::Continue {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfFalseOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfTrueOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
+            u8::from(Self::SetExcInfo),
+            u8::from(Self::Subscript),
+        ];
+
+        // Pseudo opcodes (252-255)
+        let pseudo_start = u8::from(Self::Jump {
+            target: Arg::marker(),
+        });
+        let pseudo_end = u8::from(Self::PopBlock);
+
+        if (cpython_start..=cpython_end).contains(&value)
+            || value == resume_id
+            || custom_ops.contains(&value)
+            || (pseudo_start..=pseudo_end).contains(&value)
+        {
+            Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
+        } else {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
+impl Instruction {
+    /// Gets the label stored inside this instruction, if it exists
+    #[inline]
+    pub const fn label_arg(&self) -> Option<Arg<Label>> {
+        match self {
+            Self::Jump { target: l }
+            | Self::JumpBackward { target: l }
+            | Self::JumpBackwardNoInterrupt { target: l }
+            | Self::JumpForward { target: l }
+            | Self::JumpIfNotExcMatch(l)
+            | Self::PopJumpIfTrue { target: l }
+            | Self::PopJumpIfFalse { target: l }
+            | Self::JumpIfTrueOrPop { target: l }
+            | Self::JumpIfFalseOrPop { target: l }
+            | Self::ForIter { target: l }
+            | Self::Break { target: l }
+            | Self::Continue { target: l }
+            | Self::Send { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    /// Whether this is an unconditional branching
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
+    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
+    pub const fn unconditional_branch(&self) -> bool {
+        matches!(
+            self,
+            Self::Jump { .. }
+                | Self::JumpForward { .. }
+                | Self::JumpBackward { .. }
+                | Self::JumpBackwardNoInterrupt { .. }
+                | Self::Continue { .. }
+                | Self::Break { .. }
+                | Self::ReturnValue
+                | Self::ReturnConst { .. }
+                | Self::RaiseVarargs { .. }
+                | Self::Reraise { .. }
+        )
+    }
+
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = Instruction::Jump { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
+    ///
+    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
+        match self {
+            Self::Nop => 0,
+            Self::ImportName { .. } => -1,
+            Self::ImportFrom { .. } => 1,
+            Self::LoadFast(_) => 1,
+            Self::LoadFastAndClear(_) => 1,
+            Self::LoadName(_) => 1,
+            Self::LoadGlobal(_) => 1,
+            Self::LoadDeref(_) => 1,
+            Self::StoreFast(_) => -1,
+            Self::StoreName(_) => -1,
+            Self::StoreGlobal(_) => -1,
+            Self::StoreDeref(_) => -1,
+            Self::StoreFastLoadFast { .. } => 0, // pop 1, push 1
+            Self::DeleteFast(_) => 0,
+            Self::DeleteName(_) => 0,
+            Self::DeleteGlobal(_) => 0,
+            Self::DeleteDeref(_) => 0,
+            Self::LoadFromDictOrDeref(_) => 1,
+            Self::LoadClosure(_) => 1,
+            Self::Subscript => -1,
+            Self::StoreSubscr => -3,
+            Self::DeleteSubscr => -2,
+            Self::LoadAttr { .. } => 0,
+            // LoadAttrMethod: pop obj, push method + self_or_null
+            Self::LoadAttrMethod { .. } => 1,
+            Self::StoreAttr { .. } => -2,
+            Self::DeleteAttr { .. } => -1,
+            Self::LoadConst { .. } => 1,
+            Self::Reserved => 0,
+            Self::BinaryOp { .. } => -1,
+            Self::CompareOp { .. } => -1,
+            Self::BinarySubscr => -1,
+            Self::Copy { .. } => 1,
+            Self::PopTop => -1,
+            Self::Swap { .. } => 0,
+            Self::ToBool => 0,
+            Self::GetIter => 0,
+            Self::GetLen => 1,
+            Self::CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
+            Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
+            Self::Continue { .. } => 0,
+            Self::Break { .. } => 0,
+            Self::Jump { .. } => 0,
+            Self::PopJumpIfTrue { .. } => -1,
+            Self::PopJumpIfFalse { .. } => -1,
+            Self::JumpIfTrueOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::JumpIfFalseOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::MakeFunction => {
+                // CPython 3.13 style: MakeFunction only pops code object
+                -1 + 1 // pop code, push function
+            }
+            Self::SetFunctionAttribute { .. } => {
+                // pops attribute value and function, pushes function back
+                -2 + 1
+            }
+            // Call: pops nargs + self_or_null + callable, pushes result
+            Self::Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
+            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
+            Self::CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
+            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
+            Self::CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
+            Self::CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
+            Self::ConvertValue { .. } => 0,
+            Self::FormatSimple => 0,
+            Self::FormatWithSpec => -1,
+            Self::ForIter { .. } => {
+                if jump {
+                    -1
+                } else {
+                    1
+                }
+            }
+            Self::IsOp(_) => -1,
+            Self::ContainsOp(_) => -1,
+            Self::JumpIfNotExcMatch(_) => -2,
+            Self::ReturnValue => -1,
+            Self::ReturnConst { .. } => 0,
+            Self::Resume { .. } => 0,
+            Self::YieldValue { .. } => 0,
+            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
+            Self::Send { .. } => 0,
+            // END_SEND: (receiver, value) -> (value)
+            Self::EndSend => -1,
+            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
+            Self::CleanupThrow => -1,
+            Self::SetExcInfo => 0,
+            Self::PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
+            Self::CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
+            Self::Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
+            Self::SetupAnnotations => 0,
+            Self::BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
+            Self::WithExceptStart => 1, // push __exit__ result
+            Self::PopBlock => 0,
+            Self::RaiseVarargs { kind } => {
+                // Stack effects for different raise kinds:
+                // - Reraise (0): gets from VM state, no stack pop
+                // - Raise (1): pops 1 exception
+                // - RaiseCause (2): pops 2 (exception + cause)
+                // - ReraiseFromStack (3): pops 1 exception from stack
+                match kind.get(arg) {
+                    RaiseKind::BareRaise => 0,
+                    RaiseKind::Raise => -1,
+                    RaiseKind::RaiseCause => -2,
+                    RaiseKind::ReraiseFromStack => -1,
+                }
+            }
+            Self::BuildString { size } => -(size.get(arg) as i32) + 1,
+            Self::BuildTuple { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildList { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildListFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSet { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromIter => 0,
+            Self::BuildMap { size } => {
+                let nargs = size.get(arg) * 2;
+                -(nargs as i32) + 1
+            }
+            Self::BuildMapForCall { size } => {
+                let nargs = size.get(arg);
+                -(nargs as i32) + 1
+            }
+            Self::DictUpdate { .. } => -1,
+            Self::BuildSlice { argc } => {
+                // push 1
+                // pops either 2/3
+                // Default to Two (2 args) if arg is invalid
+                1 - (argc
+                    .try_get(arg)
+                    .unwrap_or(BuildSliceArgCount::Two)
+                    .argc()
+                    .get() as i32)
+            }
+            Self::ListAppend { .. } => -1,
+            Self::SetAdd { .. } => -1,
+            Self::MapAdd { .. } => -2,
+            Self::LoadBuildClass => 1,
+            Self::UnpackSequence { size } => -1 + size.get(arg) as i32,
+            Self::UnpackEx { args } => {
+                let UnpackExArgs { before, after } = args.get(arg);
+                -1 + before as i32 + 1 + after as i32
+            }
+            Self::PopExcept => 0,
+            Self::GetAwaitable => 0,
+            Self::BeforeAsyncWith => 1,
+            Self::GetAIter => 0,
+            Self::GetANext => 1,
+            Self::EndAsyncFor => -2,  // pops (awaitable, exc) from stack
+            Self::MatchMapping => 1,  // Push bool result
+            Self::MatchSequence => 1, // Push bool result
+            Self::MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
+            Self::MatchClass(_) => -2,
+            Self::ExtendedArg => 0,
+            Self::UnaryInvert => 0,
+            Self::UnaryNegative => 0,
+            Self::UnaryNot => 0,
+            Self::GetYieldFromIter => 0,
+            Self::PushNull => 1, // Push NULL for call protocol
+            Self::Cache => 0,
+            Self::BinarySlice => 0,
+            Self::BinaryOpInplaceAddUnicode => 0,
+            Self::EndFor => 0,
+            Self::ExitInitCheck => 0,
+            Self::InterpreterExit => 0,
+            Self::LoadAssertionError => 0,
+            Self::LoadLocals => 0,
+            Self::ReturnGenerator => 0,
+            Self::StoreSlice => 0,
+            Self::DictMerge { .. } => 0,
+            Self::BuildConstKeyMap { .. } => 0,
+            Self::CopyFreeVars { .. } => 0,
+            Self::EnterExecutor => 0,
+            Self::JumpBackwardNoInterrupt { .. } => 0,
+            Self::JumpBackward { .. } => 0,
+            Self::JumpForward { .. } => 0,
+            Self::ListExtend { .. } => 0,
+            Self::LoadFastCheck(_) => 0,
+            Self::LoadFastLoadFast { .. } => 0,
+            Self::LoadFromDictOrGlobals(_) => 0,
+            Self::SetUpdate { .. } => 0,
+            Self::MakeCell(_) => 0,
+            Self::LoadSuperAttr { .. } => 0,
+            Self::StoreFastStoreFast { .. } => 0,
+            Self::PopJumpIfNone { .. } => 0,
+            Self::PopJumpIfNotNone { .. } => 0,
+        }
+    }
+
+    pub fn display<'a>(
+        &'a self,
+        arg: OpArg,
+        ctx: &'a impl InstrDisplayContext,
+    ) -> impl fmt::Display + 'a {
+        struct FmtFn<F>(F);
+        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                (self.0)(f)
+            }
+        }
+        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result {
+        macro_rules! w {
+            ($variant:ident) => {
+                write!(f, stringify!($variant))
+            };
+            ($variant:ident, $map:ident = $arg_marker:expr) => {{
+                let arg = $arg_marker.get(arg);
+                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
+            }};
+            ($variant:ident, $arg_marker:expr) => {
+                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
+            };
+            ($variant:ident, ?$arg_marker:expr) => {
+                write!(
+                    f,
+                    "{:pad$}({:?})",
+                    stringify!($variant),
+                    $arg_marker.get(arg)
+                )
+            };
+        }
+
+        let varname = |i: u32| ctx.get_varname(i as usize);
+        let name = |i: u32| ctx.get_name(i as usize);
+        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
+
+        let fmt_const =
+            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
+                let value = ctx.get_constant(idx.get(arg) as usize);
+                match value.borrow_constant() {
+                    BorrowedConstant::Code { code } if expand_code_objects => {
+                        write!(f, "{op:pad$}({code:?}):")?;
+                        code.display_inner(f, true, level + 1)?;
+                        Ok(())
+                    }
+                    c => {
+                        write!(f, "{op:pad$}(")?;
+                        c.fmt_display(f)?;
+                        write!(f, ")")
+                    }
+                }
+            };
+
+        match self {
+            Self::BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
+            Self::BeforeWith => w!(BEFORE_WITH),
+            Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
+            Self::BinarySubscr => w!(BINARY_SUBSCR),
+            Self::Break { target } => w!(BREAK, target),
+            Self::BuildList { size } => w!(BUILD_LIST, size),
+            Self::BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
+            Self::BuildMap { size } => w!(BUILD_MAP, size),
+            Self::BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
+            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
+            Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
+            Self::BuildString { size } => w!(BUILD_STRING, size),
+            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
+            Self::BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
+            Self::BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
+            Self::Call { nargs } => w!(CALL, nargs),
+            Self::CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
+            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
+            Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
+            Self::CheckEgMatch => w!(CHECK_EG_MATCH),
+            Self::CheckExcMatch => w!(CHECK_EXC_MATCH),
+            Self::CleanupThrow => w!(CLEANUP_THROW),
+            Self::CompareOp { op } => w!(COMPARE_OP, ?op),
+            Self::ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Self::Continue { target } => w!(CONTINUE, target),
+            Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
+            Self::Copy { index } => w!(COPY, index),
+            Self::DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
+            Self::DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
+            Self::DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
+            Self::DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
+            Self::DeleteName(idx) => w!(DELETE_NAME, name = idx),
+            Self::DeleteSubscr => w!(DELETE_SUBSCR),
+            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::EndAsyncFor => w!(END_ASYNC_FOR),
+            Self::EndSend => w!(END_SEND),
+            Self::ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
+            Self::ForIter { target } => w!(FOR_ITER, target),
+            Self::FormatSimple => w!(FORMAT_SIMPLE),
+            Self::FormatWithSpec => w!(FORMAT_WITH_SPEC),
+            Self::GetAIter => w!(GET_AITER),
+            Self::GetANext => w!(GET_ANEXT),
+            Self::GetAwaitable => w!(GET_AWAITABLE),
+            Self::Reserved => w!(RESERVED),
+            Self::GetIter => w!(GET_ITER),
+            Self::GetLen => w!(GET_LEN),
+            Self::ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
+            Self::ImportName { idx } => w!(IMPORT_NAME, name = idx),
+            Self::IsOp(inv) => w!(IS_OP, ?inv),
+            Self::Jump { target } => w!(JUMP, target),
+            Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
+            Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
+            Self::JumpForward { target } => w!(JUMP_FORWARD, target),
+            Self::JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
+            Self::JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            Self::JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
+            Self::ListAppend { i } => w!(LIST_APPEND, i),
+            Self::LoadAttr { idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, is_method) = decode_load_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                if is_method {
+                    write!(
+                        f,
+                        "{:pad$}({}, {}, method=true)",
+                        "LOAD_ATTR", encoded, attr_name
+                    )
+                } else {
+                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
+                }
+            }
+            Self::LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
+            Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
+            Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
+            Self::LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
+            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
+            Self::LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
+            Self::LoadFast(idx) => w!(LOAD_FAST, varname = idx),
+            Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
+            Self::LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
+            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::MakeFunction => w!(MAKE_FUNCTION),
+            Self::MapAdd { i } => w!(MAP_ADD, i),
+            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchKeys => w!(MATCH_KEYS),
+            Self::MatchMapping => w!(MATCH_MAPPING),
+            Self::MatchSequence => w!(MATCH_SEQUENCE),
+            Self::Nop => w!(NOP),
+            Self::PopBlock => w!(POP_BLOCK),
+            Self::PopExcept => w!(POP_EXCEPT),
+            Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
+            Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            Self::PopTop => w!(POP_TOP),
+            Self::PushExcInfo => w!(PUSH_EXC_INFO),
+            Self::PushNull => w!(PUSH_NULL),
+            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::Reraise { depth } => w!(RERAISE, depth),
+            Self::Resume { arg } => w!(RESUME, arg),
+            Self::ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
+            Self::ReturnValue => w!(RETURN_VALUE),
+            Self::Send { target } => w!(SEND, target),
+            Self::SetAdd { i } => w!(SET_ADD, i),
+            Self::SetExcInfo => w!(SET_EXC_INFO),
+            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
+            Self::StoreAttr { idx } => w!(STORE_ATTR, name = idx),
+            Self::StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
+            Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            Self::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                write!(f, "STORE_FAST_LOAD_FAST")?;
+                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
+            }
+            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
+            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreSubscr => w!(STORE_SUBSCR),
+            Self::Subscript => w!(SUBSCRIPT),
+            Self::Swap { index } => w!(SWAP, index),
+            Self::ToBool => w!(TO_BOOL),
+            Self::UnpackEx { args } => w!(UNPACK_EX, args),
+            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::WithExceptStart => w!(WITH_EXCEPT_START),
+            Self::UnaryInvert => w!(UNARY_INVERT),
+            Self::UnaryNegative => w!(UNARY_NEGATIVE),
+            Self::UnaryNot => w!(UNARY_NOT),
+            Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
+            Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            _ => w!(RUSTPYTHON_PLACEHOLDER),
+        }
+    }
+}
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index ec3abf5e168..f8e343b1915 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -762,7 +762,7 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::CopyItem { index } => {
+            bytecode::Instruction::Copy { index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index 5c0c3811259..b7d6228ab75 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -10,7 +10,9 @@
 import typing
 
 ROOT = pathlib.Path(__file__).parents[1]
-BYTECODE_FILE = ROOT / "crates" / "compiler-core" / "src" / "bytecode.rs"
+BYTECODE_FILE = (
+    ROOT / "crates" / "compiler-core" / "src" / "bytecode" / "instruction.rs"
+)
 OPCODE_METADATA_FILE = ROOT / "Lib" / "_opcode_metadata.py"
 
 
@@ -20,10 +22,7 @@ class Opcode(typing.NamedTuple):
 
     @property
     def cpython_name(self) -> str:
-        if self.rust_name == "CopyItem":
-            return "COPY"
-        name = self.rust_name
-        name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name)
+        name = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", self.rust_name)
         return re.sub(r"(\D)(\d+)$", r"\1_\2", name).upper()
 
     @classmethod

From f297888317ed7e0d808020cebdc3c26fde8de9cd Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:34:11 -0500
Subject: [PATCH 218/418] Update test/libregrtest to CPython 3.13.10

---
 Lib/test/__main__.py                |    4 +-
 Lib/test/libregrtest/__init__.py    |    5 -
 Lib/test/libregrtest/cmdline.py     |  270 ++++--
 Lib/test/libregrtest/filter.py      |   77 ++
 Lib/test/libregrtest/findtests.py   |  110 +++
 Lib/test/libregrtest/logger.py      |   89 ++
 Lib/test/libregrtest/main.py        | 1175 +++++++++++++++------------
 Lib/test/libregrtest/mypy.ini       |   26 +
 Lib/test/libregrtest/pgo.py         |   55 ++
 Lib/test/libregrtest/refleak.py     |  281 ++++---
 Lib/test/libregrtest/result.py      |  225 +++++
 Lib/test/libregrtest/results.py     |  276 +++++++
 Lib/test/libregrtest/run_workers.py |  621 ++++++++++++++
 Lib/test/libregrtest/runtest.py     |  328 --------
 Lib/test/libregrtest/runtest_mp.py  |  288 -------
 Lib/test/libregrtest/runtests.py    |  222 +++++
 Lib/test/libregrtest/save_env.py    |  144 +++-
 Lib/test/libregrtest/setup.py       |  179 ++--
 Lib/test/libregrtest/single.py      |  322 ++++++++
 Lib/test/libregrtest/testresult.py  |  193 +++++
 Lib/test/libregrtest/tsan.py        |   34 +
 Lib/test/libregrtest/utils.py       |  760 ++++++++++++++++-
 Lib/test/libregrtest/win_utils.py   |  203 +++--
 Lib/test/libregrtest/worker.py      |  123 +++
 24 files changed, 4439 insertions(+), 1571 deletions(-)
 create mode 100644 Lib/test/libregrtest/filter.py
 create mode 100644 Lib/test/libregrtest/findtests.py
 create mode 100644 Lib/test/libregrtest/logger.py
 create mode 100644 Lib/test/libregrtest/mypy.ini
 create mode 100644 Lib/test/libregrtest/pgo.py
 create mode 100644 Lib/test/libregrtest/result.py
 create mode 100644 Lib/test/libregrtest/results.py
 create mode 100644 Lib/test/libregrtest/run_workers.py
 delete mode 100644 Lib/test/libregrtest/runtest.py
 delete mode 100644 Lib/test/libregrtest/runtest_mp.py
 create mode 100644 Lib/test/libregrtest/runtests.py
 create mode 100644 Lib/test/libregrtest/single.py
 create mode 100644 Lib/test/libregrtest/testresult.py
 create mode 100644 Lib/test/libregrtest/tsan.py
 create mode 100644 Lib/test/libregrtest/worker.py

diff --git a/Lib/test/__main__.py b/Lib/test/__main__.py
index 19a6b2b8904..82b50ad2c6e 100644
--- a/Lib/test/__main__.py
+++ b/Lib/test/__main__.py
@@ -1,2 +1,2 @@
-from test.libregrtest import main
-main()
+from test.libregrtest.main import main
+main(_add_python_opts=True)
diff --git a/Lib/test/libregrtest/__init__.py b/Lib/test/libregrtest/__init__.py
index 3427b51b60a..e69de29bb2d 100644
--- a/Lib/test/libregrtest/__init__.py
+++ b/Lib/test/libregrtest/__init__.py
@@ -1,5 +0,0 @@
-# We import importlib *ASAP* in order to test #15386
-import importlib
-
-from test.libregrtest.cmdline import _parse_args, RESOURCE_NAMES, ALL_RESOURCES
-from test.libregrtest.main import main
diff --git a/Lib/test/libregrtest/cmdline.py b/Lib/test/libregrtest/cmdline.py
index 0a97c8c19b1..62bc36ed421 100644
--- a/Lib/test/libregrtest/cmdline.py
+++ b/Lib/test/libregrtest/cmdline.py
@@ -1,8 +1,9 @@
 import argparse
-import os
+import os.path
+import shlex
 import sys
-from test import support
-from test.support import os_helper
+from test.support import os_helper, Py_DEBUG
+from .utils import ALL_RESOURCES, RESOURCE_NAMES, TestFilter
 
 
 USAGE = """\
@@ -27,8 +28,10 @@
 Additional option details:
 
 -r randomizes test execution order. You can use --randseed=int to provide an
-int seed value for the randomizer; this is useful for reproducing troublesome
-test orders.
+int seed value for the randomizer. The randseed value will be used
+to set seeds for all random usages in tests
+(including randomizing the tests order if -r is set).
+By default we always set random seed, but do not randomize test order.
 
 -s On the first invocation of regrtest using -s, the first test file found
 or the first test file given on the command line is run, and the name of
@@ -107,6 +110,8 @@
 
     cpu -       Used for certain CPU-heavy tests.
 
+    walltime -  Long running but not CPU-bound tests.
+
     subprocess  Run all tests for the subprocess module.
 
     urlfetch -  It is okay to download files required on testing.
@@ -128,17 +133,51 @@
 """
 
 
-ALL_RESOURCES = ('audio', 'curses', 'largefile', 'network',
-                 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui')
+class Namespace(argparse.Namespace):
+    def __init__(self, **kwargs) -> None:
+        self.ci = False
+        self.testdir = None
+        self.verbose = 0
+        self.quiet = False
+        self.exclude = False
+        self.cleanup = False
+        self.wait = False
+        self.list_cases = False
+        self.list_tests = False
+        self.single = False
+        self.randomize = False
+        self.fromfile = None
+        self.fail_env_changed = False
+        self.use_resources: list[str] = []
+        self.trace = False
+        self.coverdir = 'coverage'
+        self.runleaks = False
+        self.huntrleaks: tuple[int, int, str] | None = None
+        self.rerun = False
+        self.verbose3 = False
+        self.print_slow = False
+        self.random_seed = None
+        self.use_mp = None
+        self.forever = False
+        self.header = False
+        self.failfast = False
+        self.match_tests: TestFilter = []
+        self.pgo = False
+        self.pgo_extended = False
+        self.tsan = False
+        self.worker_json = None
+        self.start = None
+        self.timeout = None
+        self.memlimit = None
+        self.threshold = None
+        self.fail_rerun = False
+        self.tempdir = None
+        self._add_python_opts = True
+        self.xmlpath = None
+        self.single_process = False
+
+        super().__init__(**kwargs)
 
-# Other resources excluded from --use=all:
-#
-# - extralagefile (ex: test_zipfile64): really too slow to be enabled
-#   "by default"
-# - tzdata: while needed to validate fully test_datetime, it makes
-#   test_datetime too slow (15-20 min on some buildbots) and so is disabled by
-#   default (see bpo-30822).
-RESOURCE_NAMES = ALL_RESOURCES + ('extralargefile', 'tzdata')
 
 class _ArgParser(argparse.ArgumentParser):
 
@@ -146,6 +185,20 @@ def error(self, message):
         super().error(message + "\nPass -h or --help for complete help.")
 
 
+class FilterAction(argparse.Action):
+    def __call__(self, parser, namespace, value, option_string=None):
+        items = getattr(namespace, self.dest)
+        items.append((value, self.const))
+
+
+class FromFileFilterAction(argparse.Action):
+    def __call__(self, parser, namespace, value, option_string=None):
+        items = getattr(namespace, self.dest)
+        with open(value, encoding='utf-8') as fp:
+            for line in fp:
+                items.append((line.strip(), self.const))
+
+
 def _create_parser():
     # Set prog to prevent the uninformative "__main__.py" from displaying in
     # error messages when using "python -m test ...".
@@ -155,6 +208,7 @@ def _create_parser():
                         epilog=EPILOG,
                         add_help=False,
                         formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.set_defaults(match_tests=[])
 
     # Arguments with this clause added to its help are described further in
     # the epilog's "Additional option details" section.
@@ -164,23 +218,35 @@ def _create_parser():
     # We add help explicitly to control what argument group it renders under.
     group.add_argument('-h', '--help', action='help',
                        help='show this help message and exit')
-    group.add_argument('--timeout', metavar='TIMEOUT', type=float,
+    group.add_argument('--fast-ci', action='store_true',
+                       help='Fast Continuous Integration (CI) mode used by '
+                            'GitHub Actions')
+    group.add_argument('--slow-ci', action='store_true',
+                       help='Slow Continuous Integration (CI) mode used by '
+                            'buildbot workers')
+    group.add_argument('--timeout', metavar='TIMEOUT',
                         help='dump the traceback and exit if a test takes '
                              'more than TIMEOUT seconds; disabled if TIMEOUT '
                              'is negative or equals to zero')
     group.add_argument('--wait', action='store_true',
                        help='wait for user input, e.g., allow a debugger '
                             'to be attached')
-    group.add_argument('--worker-args', metavar='ARGS')
     group.add_argument('-S', '--start', metavar='START',
                        help='the name of the test at which to start.' +
                             more_details)
+    group.add_argument('-p', '--python', metavar='PYTHON',
+                       help='Command to run Python test subprocesses with.')
+    group.add_argument('--randseed', metavar='SEED',
+                       dest='random_seed', type=int,
+                       help='pass a global random seed')
 
     group = parser.add_argument_group('Verbosity')
     group.add_argument('-v', '--verbose', action='count',
                        help='run tests in verbose mode with output to stdout')
-    group.add_argument('-w', '--verbose2', action='store_true',
+    group.add_argument('-w', '--rerun', action='store_true',
                        help='re-run failed tests in verbose mode')
+    group.add_argument('--verbose2', action='store_true', dest='rerun',
+                       help='deprecated alias to --rerun')
     group.add_argument('-W', '--verbose3', action='store_true',
                        help='display test output on failure')
     group.add_argument('-q', '--quiet', action='store_true',
@@ -193,10 +259,9 @@ def _create_parser():
     group = parser.add_argument_group('Selecting tests')
     group.add_argument('-r', '--randomize', action='store_true',
                        help='randomize test execution order.' + more_details)
-    group.add_argument('--randseed', metavar='SEED',
-                       dest='random_seed', type=int,
-                       help='pass a random seed to reproduce a previous '
-                            'random run')
+    group.add_argument('--no-randomize', dest='no_randomize', action='store_true',
+                       help='do not randomize test execution order, even if '
+                       'it would be implied by another option')
     group.add_argument('-f', '--fromfile', metavar='FILE',
                        help='read names of tests to run from a file.' +
                             more_details)
@@ -206,12 +271,21 @@ def _create_parser():
                        help='single step through a set of tests.' +
                             more_details)
     group.add_argument('-m', '--match', metavar='PAT',
-                       dest='match_tests', action='append',
+                       dest='match_tests', action=FilterAction, const=True,
                        help='match test cases and methods with glob pattern PAT')
+    group.add_argument('-i', '--ignore', metavar='PAT',
+                       dest='match_tests', action=FilterAction, const=False,
+                       help='ignore test cases and methods with glob pattern PAT')
     group.add_argument('--matchfile', metavar='FILENAME',
-                       dest='match_filename',
+                       dest='match_tests',
+                       action=FromFileFilterAction, const=True,
                        help='similar to --match but get patterns from a '
                             'text file, one pattern per line')
+    group.add_argument('--ignorefile', metavar='FILENAME',
+                       dest='match_tests',
+                       action=FromFileFilterAction, const=False,
+                       help='similar to --matchfile but it receives patterns '
+                            'from text file to ignore')
     group.add_argument('-G', '--failfast', action='store_true',
                        help='fail as soon as a test fails (only with -v or -W)')
     group.add_argument('-u', '--use', metavar='RES1,RES2,...',
@@ -227,9 +301,6 @@ def _create_parser():
                             '(instead of the Python stdlib test suite)')
 
     group = parser.add_argument_group('Special runs')
-    group.add_argument('-l', '--findleaks', action='store_const', const=2,
-                       default=1,
-                       help='deprecated alias to --fail-env-changed')
     group.add_argument('-L', '--runleaks', action='store_true',
                        help='run the leaks(1) command just before exit.' +
                             more_details)
@@ -240,6 +311,12 @@ def _create_parser():
     group.add_argument('-j', '--multiprocess', metavar='PROCESSES',
                        dest='use_mp', type=int,
                        help='run PROCESSES processes at once')
+    group.add_argument('--single-process', action='store_true',
+                       dest='single_process',
+                       help='always run all tests sequentially in '
+                            'a single process, ignore -jN option, '
+                            'and failed tests are also rerun sequentially '
+                            'in the same process')
     group.add_argument('-T', '--coverage', action='store_true',
                        dest='trace',
                        help='turn on code coverage tracing using the trace '
@@ -257,7 +334,7 @@ def _create_parser():
                        help='suppress error message boxes on Windows')
     group.add_argument('-F', '--forever', action='store_true',
                        help='run the specified tests in a loop, until an '
-                            'error happens')
+                            'error happens; imply --failfast')
     group.add_argument('--list-tests', action='store_true',
                        help="only write the name of tests that will be run, "
                             "don't execute them")
@@ -265,16 +342,30 @@ def _create_parser():
                        help='only write the name of test cases that will be run'
                             ' , don\'t execute them')
     group.add_argument('-P', '--pgo', dest='pgo', action='store_true',
-                       help='enable Profile Guided Optimization training')
+                       help='enable Profile Guided Optimization (PGO) training')
+    group.add_argument('--pgo-extended', action='store_true',
+                       help='enable extended PGO training (slower training)')
+    group.add_argument('--tsan', dest='tsan', action='store_true',
+                       help='run a subset of test cases that are proper for the TSAN test')
     group.add_argument('--fail-env-changed', action='store_true',
                        help='if a test file alters the environment, mark '
                             'the test as failed')
+    group.add_argument('--fail-rerun', action='store_true',
+                       help='if a test failed and then passed when re-run, '
+                            'mark the tests as failed')
 
     group.add_argument('--junit-xml', dest='xmlpath', metavar='FILENAME',
                        help='writes JUnit-style XML results to the specified '
                             'file')
-    group.add_argument('--tempdir', dest='tempdir', metavar='PATH',
+    group.add_argument('--tempdir', metavar='PATH',
                        help='override the working directory for the test run')
+    group.add_argument('--cleanup', action='store_true',
+                       help='remove old test_python_* directories')
+    group.add_argument('--bisect', action='store_true',
+                       help='if some tests fail, run test.bisect_cmd on them')
+    group.add_argument('--dont-add-python-opts', dest='_add_python_opts',
+                       action='store_false',
+                       help="internal option, don't use it")
     return parser
 
 
@@ -309,19 +400,12 @@ def resources_list(string):
 
 def _parse_args(args, **kwargs):
     # Defaults
-    ns = argparse.Namespace(testdir=None, verbose=0, quiet=False,
-         exclude=False, single=False, randomize=False, fromfile=None,
-         findleaks=1, use_resources=None, trace=False, coverdir='coverage',
-         runleaks=False, huntrleaks=False, verbose2=False, print_slow=False,
-         random_seed=None, use_mp=None, verbose3=False, forever=False,
-         header=False, failfast=False, match_tests=None, pgo=False)
+    ns = Namespace()
     for k, v in kwargs.items():
         if not hasattr(ns, k):
             raise TypeError('%r is an invalid keyword argument '
                             'for this function' % k)
         setattr(ns, k, v)
-    if ns.use_resources is None:
-        ns.use_resources = []
 
     parser = _create_parser()
     # Issue #14191: argparse doesn't support "intermixed" positional and
@@ -330,19 +414,81 @@ def _parse_args(args, **kwargs):
     for arg in ns.args:
         if arg.startswith('-'):
             parser.error("unrecognized arguments: %s" % arg)
-            sys.exit(1)
 
-    if ns.findleaks > 1:
-        # --findleaks implies --fail-env-changed
+    if ns.timeout is not None:
+        # Support "--timeout=" (no value) so Makefile.pre.pre TESTTIMEOUT
+        # can be used by "make buildbottest" and "make test".
+        if ns.timeout != "":
+            try:
+                ns.timeout = float(ns.timeout)
+            except ValueError:
+                parser.error(f"invalid timeout value: {ns.timeout!r}")
+        else:
+            ns.timeout = None
+
+    # Continuous Integration (CI): common options for fast/slow CI modes
+    if ns.slow_ci or ns.fast_ci:
+        # Similar to options:
+        #   -j0 --randomize --fail-env-changed --rerun --slowest --verbose3
+        if ns.use_mp is None:
+            ns.use_mp = 0
+        ns.randomize = True
         ns.fail_env_changed = True
+        if ns.python is None:
+            ns.rerun = True
+        ns.print_slow = True
+        if not ns.verbose:
+            ns.verbose3 = True
+        else:
+            # --verbose has the priority over --verbose3
+            pass
+    else:
+        ns._add_python_opts = False
+
+    # --singleprocess overrides -jN option
+    if ns.single_process:
+        ns.use_mp = None
+
+    # When both --slow-ci and --fast-ci options are present,
+    # --slow-ci has the priority
+    if ns.slow_ci:
+        # Similar to: -u "all" --timeout=1200
+        if ns.use is None:
+            ns.use = []
+        ns.use.insert(0, ['all'])
+        if ns.timeout is None:
+            ns.timeout = 1200  # 20 minutes
+    elif ns.fast_ci:
+        # Similar to: -u "all,-cpu" --timeout=600
+        if ns.use is None:
+            ns.use = []
+        ns.use.insert(0, ['all', '-cpu'])
+        if ns.timeout is None:
+            ns.timeout = 600  # 10 minutes
+
     if ns.single and ns.fromfile:
         parser.error("-s and -f don't go together!")
-    if ns.use_mp is not None and ns.trace:
-        parser.error("-T and -j don't go together!")
+    if ns.trace:
+        if ns.use_mp is not None:
+            if not Py_DEBUG:
+                parser.error("need --with-pydebug to use -T and -j together")
+        else:
+            print(
+                "Warning: collecting coverage without -j is imprecise. Configure"
+                " --with-pydebug and run -m test -T -j for best results.",
+                file=sys.stderr
+            )
+    if ns.python is not None:
+        if ns.use_mp is None:
+            parser.error("-p requires -j!")
+        # The "executable" may be two or more parts, e.g. "node python.js"
+        ns.python = shlex.split(ns.python)
     if ns.failfast and not (ns.verbose or ns.verbose3):
         parser.error("-G/--failfast needs either -v or -W")
-    if ns.pgo and (ns.verbose or ns.verbose2 or ns.verbose3):
+    if ns.pgo and (ns.verbose or ns.rerun or ns.verbose3):
         parser.error("--pgo/-v don't go together!")
+    if ns.pgo_extended:
+        ns.pgo = True  # pgo_extended implies pgo
 
     if ns.nowindows:
         print("Warning: the --nowindows (-n) option is deprecated. "
@@ -353,10 +499,6 @@ def _parse_args(args, **kwargs):
     if ns.timeout is not None:
         if ns.timeout <= 0:
             ns.timeout = None
-    if ns.use_mp is not None:
-        if ns.use_mp <= 0:
-            # Use all cores + extras for tests that like to sleep
-            ns.use_mp = 2 + (os.cpu_count() or 1)
     if ns.use:
         for a in ns.use:
             for r in a:
@@ -377,18 +519,34 @@ def _parse_args(args, **kwargs):
                     ns.use_resources.append(r)
     if ns.random_seed is not None:
         ns.randomize = True
+    if ns.no_randomize:
+        ns.randomize = False
     if ns.verbose:
         ns.header = True
-    if ns.huntrleaks and ns.verbose3:
+
+    # When -jN option is used, a worker process does not use --verbose3
+    # and so -R 3:3 -jN --verbose3 just works as expected: there is no false
+    # alarm about memory leak.
+    if ns.huntrleaks and ns.verbose3 and ns.use_mp is None:
+        # run_single_test() replaces sys.stdout with io.StringIO if verbose3
+        # is true. In this case, huntrleaks sees an write into StringIO as
+        # a memory leak, whereas it is not (gh-71290).
         ns.verbose3 = False
         print("WARNING: Disable --verbose3 because it's incompatible with "
-              "--huntrleaks: see http://bugs.python.org/issue27103",
+              "--huntrleaks without -jN option",
               file=sys.stderr)
-    if ns.match_filename:
-        if ns.match_tests is None:
-            ns.match_tests = []
-        with open(ns.match_filename) as fp:
-            for line in fp:
-                ns.match_tests.append(line.strip())
+
+    if ns.forever:
+        # --forever implies --failfast
+        ns.failfast = True
+
+    if ns.huntrleaks:
+        warmup, repetitions, _ = ns.huntrleaks
+        if warmup < 1 or repetitions < 1:
+            msg = ("Invalid values for the --huntrleaks/-R parameters. The "
+                   "number of warmups and repetitions must be at least 1 "
+                   "each (1:1).")
+            print(msg, file=sys.stderr, flush=True)
+            sys.exit(2)
 
     return ns
diff --git a/Lib/test/libregrtest/filter.py b/Lib/test/libregrtest/filter.py
new file mode 100644
index 00000000000..41372e427ff
--- /dev/null
+++ b/Lib/test/libregrtest/filter.py
@@ -0,0 +1,77 @@
+import itertools
+import operator
+import re
+
+
+# By default, don't filter tests
+_test_matchers = ()
+_test_patterns = ()
+
+
+def match_test(test):
+    # Function used by support.run_unittest() and regrtest --list-cases
+    result = False
+    for matcher, result in reversed(_test_matchers):
+        if matcher(test.id()):
+            return result
+    return not result
+
+
+def _is_full_match_test(pattern):
+    # If a pattern contains at least one dot, it's considered
+    # as a full test identifier.
+    # Example: 'test.test_os.FileTests.test_access'.
+    #
+    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
+    # or '[!...]'. For example, ignore 'test_access*'.
+    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
+
+
+def get_match_tests():
+    global _test_patterns
+    return _test_patterns
+
+
+def set_match_tests(patterns):
+    global _test_matchers, _test_patterns
+
+    if not patterns:
+        _test_matchers = ()
+        _test_patterns = ()
+    else:
+        itemgetter = operator.itemgetter
+        patterns = tuple(patterns)
+        if patterns != _test_patterns:
+            _test_matchers = [
+                (_compile_match_function(map(itemgetter(0), it)), result)
+                for result, it in itertools.groupby(patterns, itemgetter(1))
+            ]
+            _test_patterns = patterns
+
+
+def _compile_match_function(patterns):
+    patterns = list(patterns)
+
+    if all(map(_is_full_match_test, patterns)):
+        # Simple case: all patterns are full test identifier.
+        # The test.bisect_cmd utility only uses such full test identifiers.
+        return set(patterns).__contains__
+    else:
+        import fnmatch
+        regex = '|'.join(map(fnmatch.translate, patterns))
+        # The search *is* case sensitive on purpose:
+        # don't use flags=re.IGNORECASE
+        regex_match = re.compile(regex).match
+
+        def match_test_regex(test_id, regex_match=regex_match):
+            if regex_match(test_id):
+                # The regex matches the whole identifier, for example
+                # 'test.test_os.FileTests.test_access'.
+                return True
+            else:
+                # Try to match parts of the test identifier.
+                # For example, split 'test.test_os.FileTests.test_access'
+                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
+                return any(map(regex_match, test_id.split(".")))
+
+        return match_test_regex
diff --git a/Lib/test/libregrtest/findtests.py b/Lib/test/libregrtest/findtests.py
new file mode 100644
index 00000000000..f01c1240774
--- /dev/null
+++ b/Lib/test/libregrtest/findtests.py
@@ -0,0 +1,110 @@
+import os
+import sys
+import unittest
+from collections.abc import Container
+
+from test import support
+
+from .filter import match_test, set_match_tests
+from .utils import (
+    StrPath, TestName, TestTuple, TestList, TestFilter,
+    abs_module_name, count, printlist)
+
+
+# If these test directories are encountered recurse into them and treat each
+# "test_*.py" file or each sub-directory as a separate test module. This can
+# increase parallelism.
+#
+# Beware this can't generally be done for any directory with sub-tests as the
+# __init__.py may do things which alter what tests are to be run.
+SPLITTESTDIRS: set[TestName] = {
+    "test_asyncio",
+    "test_concurrent_futures",
+    "test_doctests",
+    "test_future_stmt",
+    "test_gdb",
+    "test_inspect",
+    "test_pydoc",
+    "test_multiprocessing_fork",
+    "test_multiprocessing_forkserver",
+    "test_multiprocessing_spawn",
+}
+
+
+def findtestdir(path: StrPath | None = None) -> StrPath:
+    return path or os.path.dirname(os.path.dirname(__file__)) or os.curdir
+
+
+def findtests(*, testdir: StrPath | None = None, exclude: Container[str] = (),
+              split_test_dirs: set[TestName] = SPLITTESTDIRS,
+              base_mod: str = "") -> TestList:
+    """Return a list of all applicable test modules."""
+    testdir = findtestdir(testdir)
+    tests = []
+    for name in os.listdir(testdir):
+        mod, ext = os.path.splitext(name)
+        if (not mod.startswith("test_")) or (mod in exclude):
+            continue
+        if base_mod:
+            fullname = f"{base_mod}.{mod}"
+        else:
+            fullname = mod
+        if fullname in split_test_dirs:
+            subdir = os.path.join(testdir, mod)
+            if not base_mod:
+                fullname = f"test.{mod}"
+            tests.extend(findtests(testdir=subdir, exclude=exclude,
+                                   split_test_dirs=split_test_dirs,
+                                   base_mod=fullname))
+        elif ext in (".py", ""):
+            tests.append(fullname)
+    return sorted(tests)
+
+
+def split_test_packages(tests, *, testdir: StrPath | None = None,
+                        exclude: Container[str] = (),
+                        split_test_dirs=SPLITTESTDIRS) -> list[TestName]:
+    testdir = findtestdir(testdir)
+    splitted = []
+    for name in tests:
+        if name in split_test_dirs:
+            subdir = os.path.join(testdir, name)
+            splitted.extend(findtests(testdir=subdir, exclude=exclude,
+                                      split_test_dirs=split_test_dirs,
+                                      base_mod=name))
+        else:
+            splitted.append(name)
+    return splitted
+
+
+def _list_cases(suite: unittest.TestSuite) -> None:
+    for test in suite:
+        if isinstance(test, unittest.loader._FailedTest):  # type: ignore[attr-defined]
+            continue
+        if isinstance(test, unittest.TestSuite):
+            _list_cases(test)
+        elif isinstance(test, unittest.TestCase):
+            if match_test(test):
+                print(test.id())
+
+def list_cases(tests: TestTuple, *,
+               match_tests: TestFilter | None = None,
+               test_dir: StrPath | None = None) -> None:
+    support.verbose = False
+    set_match_tests(match_tests)
+
+    skipped = []
+    for test_name in tests:
+        module_name = abs_module_name(test_name, test_dir)
+        try:
+            suite = unittest.defaultTestLoader.loadTestsFromName(module_name)
+            _list_cases(suite)
+        except unittest.SkipTest:
+            skipped.append(test_name)
+
+    if skipped:
+        sys.stdout.flush()
+        stderr = sys.stderr
+        print(file=stderr)
+        print(count(len(skipped), "test"), "skipped:", file=stderr)
+        printlist(skipped, file=stderr)
diff --git a/Lib/test/libregrtest/logger.py b/Lib/test/libregrtest/logger.py
new file mode 100644
index 00000000000..fa1d4d575c8
--- /dev/null
+++ b/Lib/test/libregrtest/logger.py
@@ -0,0 +1,89 @@
+import os
+import time
+
+from test.support import MS_WINDOWS
+from .results import TestResults
+from .runtests import RunTests
+from .utils import print_warning
+
+if MS_WINDOWS:
+    from .win_utils import WindowsLoadTracker
+
+
+class Logger:
+    def __init__(self, results: TestResults, quiet: bool, pgo: bool):
+        self.start_time = time.perf_counter()
+        self.test_count_text = ''
+        self.test_count_width = 3
+        self.win_load_tracker: WindowsLoadTracker | None = None
+        self._results: TestResults = results
+        self._quiet: bool = quiet
+        self._pgo: bool = pgo
+
+    def log(self, line: str = '') -> None:
+        empty = not line
+
+        # add the system load prefix: "load avg: 1.80 "
+        load_avg = self.get_load_avg()
+        if load_avg is not None:
+            line = f"load avg: {load_avg:.2f} {line}"
+
+        # add the timestamp prefix:  "0:01:05 "
+        log_time = time.perf_counter() - self.start_time
+
+        mins, secs = divmod(int(log_time), 60)
+        hours, mins = divmod(mins, 60)
+        formatted_log_time = "%d:%02d:%02d" % (hours, mins, secs)
+
+        line = f"{formatted_log_time} {line}"
+        if empty:
+            line = line[:-1]
+
+        print(line, flush=True)
+
+    def get_load_avg(self) -> float | None:
+        if hasattr(os, 'getloadavg'):
+            try:
+                return os.getloadavg()[0]
+            except OSError:
+                pass
+        if self.win_load_tracker is not None:
+            return self.win_load_tracker.getloadavg()
+        return None
+
+    def display_progress(self, test_index: int, text: str) -> None:
+        if self._quiet:
+            return
+        results = self._results
+
+        # "[ 51/405/1] test_tcl passed"
+        line = f"{test_index:{self.test_count_width}}{self.test_count_text}"
+        fails = len(results.bad) + len(results.env_changed)
+        if fails and not self._pgo:
+            line = f"{line}/{fails}"
+        self.log(f"[{line}] {text}")
+
+    def set_tests(self, runtests: RunTests) -> None:
+        if runtests.forever:
+            self.test_count_text = ''
+            self.test_count_width = 3
+        else:
+            self.test_count_text = '/{}'.format(len(runtests.tests))
+            self.test_count_width = len(self.test_count_text) - 1
+
+    def start_load_tracker(self) -> None:
+        if not MS_WINDOWS:
+            return
+
+        try:
+            self.win_load_tracker = WindowsLoadTracker()
+        except PermissionError as error:
+            # Standard accounts may not have access to the performance
+            # counters.
+            print_warning(f'Failed to create WindowsLoadTracker: {error}')
+
+    def stop_load_tracker(self) -> None:
+        if self.win_load_tracker is None:
+            return
+        self.win_load_tracker.close()
+        self.win_load_tracker = None
diff --git a/Lib/test/libregrtest/main.py b/Lib/test/libregrtest/main.py
index e1d19e1e4ac..54d4cac5d62 100644
--- a/Lib/test/libregrtest/main.py
+++ b/Lib/test/libregrtest/main.py
@@ -1,42 +1,34 @@
-import datetime
-import faulthandler
-import json
-import locale
 import os
-import platform
 import random
 import re
+import shlex
 import sys
 import sysconfig
-import tempfile
 import time
-import unittest
-from test.libregrtest.cmdline import _parse_args
-from test.libregrtest.runtest import (
-    findtests, runtest, get_abs_module,
-    STDTESTS, NOTTESTS, PASSED, FAILED, ENV_CHANGED, SKIPPED, RESOURCE_DENIED,
-    INTERRUPTED, CHILD_ERROR, TEST_DID_NOT_RUN,
-    PROGRESS_MIN_TIME, format_test_result)
-from test.libregrtest.setup import setup_tests
-from test.libregrtest.utils import removepy, count, format_duration, printlist
-from test import support
-from test.support import os_helper, import_helper
-
-
-# When tests are run from the Python build directory, it is best practice
-# to keep the test files in a subfolder.  This eases the cleanup of leftover
-# files using the "make distclean" command.
-if sysconfig.is_python_build():
-    TEMPDIR = sysconfig.get_config_var('abs_builddir')
-    if TEMPDIR is None:
-        # bpo-30284: On Windows, only srcdir is available. Using abs_builddir
-        # mostly matters on UNIX when building Python out of the source tree,
-        # especially when the source tree is read only.
-        TEMPDIR = sysconfig.get_config_var('srcdir')
-    TEMPDIR = os.path.join(TEMPDIR, 'build')
-else:
-    TEMPDIR = tempfile.gettempdir()
-TEMPDIR = os.path.abspath(TEMPDIR)
+import trace
+from typing import NoReturn
+
+from test.support import (os_helper, MS_WINDOWS, flush_std_streams,
+                          can_use_suppress_immortalization,
+                          suppress_immortalization)
+
+from .cmdline import _parse_args, Namespace
+from .findtests import findtests, split_test_packages, list_cases
+from .logger import Logger
+from .pgo import setup_pgo_tests
+from .result import State, TestResult
+from .results import TestResults, EXITCODE_INTERRUPTED
+from .runtests import RunTests, HuntRefleak
+from .setup import setup_process, setup_test_dir
+from .single import run_single_test, PROGRESS_MIN_TIME
+from .tsan import setup_tsan_tests
+from .utils import (
+    StrPath, StrJSON, TestName, TestList, TestTuple, TestFilter,
+    strip_py_suffix, count, format_duration,
+    printlist, get_temp_dir, get_work_dir, exit_timeout,
+    display_header, cleanup_temp_dir, print_warning,
+    is_cross_compiled, get_host_runner,
+    EXIT_TIMEOUT)
 
 
 class Regrtest:
@@ -57,357 +49,356 @@ class Regrtest:
     files beginning with test_ will be used.
 
     The other default arguments (verbose, quiet, exclude,
-    single, randomize, findleaks, use_resources, trace, coverdir,
+    single, randomize, use_resources, trace, coverdir,
     print_slow, and random_seed) allow programmers calling main()
     directly to set the values that would normally be set by flags
     on the command line.
     """
-    def __init__(self):
-        # Namespace of command line options
-        self.ns = None
+    def __init__(self, ns: Namespace, _add_python_opts: bool = False):
+        # Log verbosity
+        self.verbose: int = int(ns.verbose)
+        self.quiet: bool = ns.quiet
+        self.pgo: bool = ns.pgo
+        self.pgo_extended: bool = ns.pgo_extended
+        self.tsan: bool = ns.tsan
+
+        # Test results
+        self.results: TestResults = TestResults()
+        self.first_state: str | None = None
+
+        # Logger
+        self.logger = Logger(self.results, self.quiet, self.pgo)
+
+        # Actions
+        self.want_header: bool = ns.header
+        self.want_list_tests: bool = ns.list_tests
+        self.want_list_cases: bool = ns.list_cases
+        self.want_wait: bool = ns.wait
+        self.want_cleanup: bool = ns.cleanup
+        self.want_rerun: bool = ns.rerun
+        self.want_run_leaks: bool = ns.runleaks
+        self.want_bisect: bool = ns.bisect
+
+        self.ci_mode: bool = (ns.fast_ci or ns.slow_ci)
+        self.want_add_python_opts: bool = (_add_python_opts
+                                           and ns._add_python_opts)
+
+        # Select tests
+        self.match_tests: TestFilter = ns.match_tests
+        self.exclude: bool = ns.exclude
+        self.fromfile: StrPath | None = ns.fromfile
+        self.starting_test: TestName | None = ns.start
+        self.cmdline_args: TestList = ns.args
+
+        # Workers
+        self.single_process: bool = ns.single_process
+        if self.single_process or ns.use_mp is None:
+            num_workers = 0   # run sequentially in a single process
+        elif ns.use_mp <= 0:
+            num_workers = -1  # run in parallel, use the number of CPUs
+        else:
+            num_workers = ns.use_mp  # run in parallel
+        self.num_workers: int = num_workers
+        self.worker_json: StrJSON | None = ns.worker_json
+
+        # Options to run tests
+        self.fail_fast: bool = ns.failfast
+        self.fail_env_changed: bool = ns.fail_env_changed
+        self.fail_rerun: bool = ns.fail_rerun
+        self.forever: bool = ns.forever
+        self.output_on_failure: bool = ns.verbose3
+        self.timeout: float | None = ns.timeout
+        if ns.huntrleaks:
+            warmups, runs, filename = ns.huntrleaks
+            filename = os.path.abspath(filename)
+            self.hunt_refleak: HuntRefleak | None = HuntRefleak(warmups, runs, filename)
+        else:
+            self.hunt_refleak = None
+        self.test_dir: StrPath | None = ns.testdir
+        self.junit_filename: StrPath | None = ns.xmlpath
+        self.memory_limit: str | None = ns.memlimit
+        self.gc_threshold: int | None = ns.threshold
+        self.use_resources: tuple[str, ...] = tuple(ns.use_resources)
+        if ns.python:
+            self.python_cmd: tuple[str, ...] | None = tuple(ns.python)
+        else:
+            self.python_cmd = None
+        self.coverage: bool = ns.trace
+        self.coverage_dir: StrPath | None = ns.coverdir
+        self._tmp_dir: StrPath | None = ns.tempdir
+
+        # Randomize
+        self.randomize: bool = ns.randomize
+        if ('SOURCE_DATE_EPOCH' in os.environ
+            # don't use the variable if empty
+            and os.environ['SOURCE_DATE_EPOCH']
+        ):
+            self.randomize = False
+            # SOURCE_DATE_EPOCH should be an integer, but use a string to not
+            # fail if it's not integer. random.seed() accepts a string.
+            # https://reproducible-builds.org/docs/source-date-epoch/
+            self.random_seed: int | str = os.environ['SOURCE_DATE_EPOCH']
+        elif ns.random_seed is None:
+            self.random_seed = random.getrandbits(32)
+        else:
+            self.random_seed = ns.random_seed
 
         # tests
-        self.tests = []
-        self.selected = []
-
-        # test results
-        self.good = []
-        self.bad = []
-        self.skipped = []
-        self.resource_denieds = []
-        self.environment_changed = []
-        self.run_no_tests = []
-        self.rerun = []
-        self.first_result = None
-        self.interrupted = False
-
-        # used by --slow
-        self.test_times = []
-
-        # used by --coverage, trace.Trace instance
-        self.tracer = None
+        self.first_runtests: RunTests | None = None
+
+        # used by --slowest
+        self.print_slowest: bool = ns.print_slow
 
         # used to display the progress bar "[ 3/100]"
-        self.start_time = time.monotonic()
-        self.test_count = ''
-        self.test_count_width = 1
+        self.start_time = time.perf_counter()
 
         # used by --single
-        self.next_single_test = None
-        self.next_single_filename = None
-
-        # used by --junit-xml
-        self.testsuite_xml = None
-
-        self.win_load_tracker = None
-
-    def get_executed(self):
-        return (set(self.good) | set(self.bad) | set(self.skipped)
-                | set(self.resource_denieds) | set(self.environment_changed)
-                | set(self.run_no_tests))
-
-    def accumulate_result(self, result, rerun=False):
-        test_name = result.test_name
-        ok = result.result
-
-        if ok not in (CHILD_ERROR, INTERRUPTED) and not rerun:
-            self.test_times.append((result.test_time, test_name))
-
-        if ok == PASSED:
-            self.good.append(test_name)
-        elif ok in (FAILED, CHILD_ERROR):
-            if not rerun:
-                self.bad.append(test_name)
-        elif ok == ENV_CHANGED:
-            self.environment_changed.append(test_name)
-        elif ok == SKIPPED:
-            self.skipped.append(test_name)
-        elif ok == RESOURCE_DENIED:
-            self.skipped.append(test_name)
-            self.resource_denieds.append(test_name)
-        elif ok == TEST_DID_NOT_RUN:
-            self.run_no_tests.append(test_name)
-        elif ok == INTERRUPTED:
-            self.interrupted = True
-        else:
-            raise ValueError("invalid test result: %r" % ok)
-
-        if rerun and ok not in {FAILED, CHILD_ERROR, INTERRUPTED}:
-            self.bad.remove(test_name)
-
-        xml_data = result.xml_data
-        if xml_data:
-            import xml.etree.ElementTree as ET
-            for e in xml_data:
-                try:
-                    self.testsuite_xml.append(ET.fromstring(e))
-                except ET.ParseError:
-                    print(xml_data, file=sys.__stderr__)
-                    raise
-
-    def display_progress(self, test_index, text):
-        if self.ns.quiet:
-            return
-
-        # "[ 51/405/1] test_tcl passed"
-        line = f"{test_index:{self.test_count_width}}{self.test_count}"
-        fails = len(self.bad) + len(self.environment_changed)
-        if fails and not self.ns.pgo:
-            line = f"{line}/{fails}"
-        line = f"[{line}] {text}"
-
-        # add the system load prefix: "load avg: 1.80 "
-        load_avg = self.getloadavg()
-        if load_avg is not None:
-            line = f"load avg: {load_avg:.2f} {line}"
-
-        # add the timestamp prefix:  "0:01:05 "
-        test_time = time.monotonic() - self.start_time
-        test_time = datetime.timedelta(seconds=int(test_time))
-        line = f"{test_time} {line}"
-        print(line, flush=True)
-
-    def parse_args(self, kwargs):
-        ns = _parse_args(sys.argv[1:], **kwargs)
-
-        if ns.timeout and not hasattr(faulthandler, 'dump_traceback_later'):
-            print("Warning: The timeout option requires "
-                  "faulthandler.dump_traceback_later", file=sys.stderr)
-            ns.timeout = None
-
-        if ns.xmlpath:
-            support.junit_xml_list = self.testsuite_xml = []
-
-        # Strip .py extensions.
-        removepy(ns.args)
-
-        return ns
-
-    def find_tests(self, tests):
-        self.tests = tests
-
-        if self.ns.single:
-            self.next_single_filename = os.path.join(TEMPDIR, 'pynexttest')
+        self.single_test_run: bool = ns.single
+        self.next_single_test: TestName | None = None
+        self.next_single_filename: StrPath | None = None
+
+    def log(self, line: str = '') -> None:
+        self.logger.log(line)
+
+    def find_tests(self, tests: TestList | None = None) -> tuple[TestTuple, TestList | None]:
+        if tests is None:
+            tests = []
+        if self.single_test_run:
+            self.next_single_filename = os.path.join(self.tmp_dir, 'pynexttest')
             try:
                 with open(self.next_single_filename, 'r') as fp:
                     next_test = fp.read().strip()
-                    self.tests = [next_test]
+                    tests = [next_test]
             except OSError:
                 pass
 
-        if self.ns.fromfile:
-            self.tests = []
+        if self.fromfile:
+            tests = []
             # regex to match 'test_builtin' in line:
             # '0:00:00 [  4/400] test_builtin -- test_dict took 1 sec'
             regex = re.compile(r'\btest_[a-zA-Z0-9_]+\b')
-            with open(os.path.join(os_helper.SAVEDCWD, self.ns.fromfile)) as fp:
+            with open(os.path.join(os_helper.SAVEDCWD, self.fromfile)) as fp:
                 for line in fp:
                     line = line.split('#', 1)[0]
                     line = line.strip()
                     match = regex.search(line)
                     if match is not None:
-                        self.tests.append(match.group())
-
-        removepy(self.tests)
-
-        stdtests = STDTESTS[:]
-        nottests = NOTTESTS.copy()
-        if self.ns.exclude:
-            for arg in self.ns.args:
-                if arg in stdtests:
-                    stdtests.remove(arg)
-                nottests.add(arg)
-            self.ns.args = []
-
-        # if testdir is set, then we are not running the python tests suite, so
-        # don't add default tests to be executed or skipped (pass empty values)
-        if self.ns.testdir:
-            alltests = findtests(self.ns.testdir, list(), set())
+                        tests.append(match.group())
+
+        strip_py_suffix(tests)
+
+        exclude_tests = set()
+        if self.exclude:
+            for arg in self.cmdline_args:
+                exclude_tests.add(arg)
+            self.cmdline_args = []
+
+        if self.pgo:
+            # add default PGO tests if no tests are specified
+            setup_pgo_tests(self.cmdline_args, self.pgo_extended)
+
+        if self.tsan:
+            setup_tsan_tests(self.cmdline_args)
+
+        alltests = findtests(testdir=self.test_dir,
+                             exclude=exclude_tests)
+
+        if not self.fromfile:
+            selected = tests or self.cmdline_args
+            if exclude_tests:
+                # Support "--pgo/--tsan -x test_xxx" command
+                selected = [name for name in selected
+                            if name not in exclude_tests]
+            if selected:
+                selected = split_test_packages(selected)
+            else:
+                selected = alltests
         else:
-            alltests = findtests(self.ns.testdir, stdtests, nottests)
+            selected = tests
 
-        if not self.ns.fromfile:
-            self.selected = self.tests or self.ns.args or alltests
-        else:
-            self.selected = self.tests
-        if self.ns.single:
-            self.selected = self.selected[:1]
+        if self.single_test_run:
+            selected = selected[:1]
             try:
-                pos = alltests.index(self.selected[0])
+                pos = alltests.index(selected[0])
                 self.next_single_test = alltests[pos + 1]
             except IndexError:
                 pass
 
         # Remove all the selected tests that precede start if it's set.
-        if self.ns.start:
+        if self.starting_test:
             try:
-                del self.selected[:self.selected.index(self.ns.start)]
+                del selected[:selected.index(self.starting_test)]
             except ValueError:
-                print("Couldn't find starting test (%s), using all tests"
-                      % self.ns.start, file=sys.stderr)
+                print(f"Cannot find starting test: {self.starting_test}")
+                sys.exit(1)
 
-        if self.ns.randomize:
-            if self.ns.random_seed is None:
-                self.ns.random_seed = random.randrange(10000000)
-            random.seed(self.ns.random_seed)
-            random.shuffle(self.selected)
-
-    def list_tests(self):
-        for name in self.selected:
-            print(name)
+        random.seed(self.random_seed)
+        if self.randomize:
+            random.shuffle(selected)
 
-    def _list_cases(self, suite):
-        for test in suite:
-            if isinstance(test, unittest.loader._FailedTest):
-                continue
-            if isinstance(test, unittest.TestSuite):
-                self._list_cases(test)
-            elif isinstance(test, unittest.TestCase):
-                if support.match_test(test):
-                    print(test.id())
-
-    def list_cases(self):
-        support.verbose = False
-        support.set_match_tests(self.ns.match_tests)
-
-        for test_name in self.selected:
-            abstest = get_abs_module(self.ns, test_name)
-            try:
-                suite = unittest.defaultTestLoader.loadTestsFromName(abstest)
-                self._list_cases(suite)
-            except unittest.SkipTest:
-                self.skipped.append(test_name)
+        return (tuple(selected), tests)
 
-        if self.skipped:
-            print(file=sys.stderr)
-            print(count(len(self.skipped), "test"), "skipped:", file=sys.stderr)
-            printlist(self.skipped, file=sys.stderr)
+    @staticmethod
+    def list_tests(tests: TestTuple) -> None:
+        for name in tests:
+            print(name)
 
-    def rerun_failed_tests(self):
-        self.ns.verbose = True
-        self.ns.failfast = False
-        self.ns.verbose3 = False
+    def _rerun_failed_tests(self, runtests: RunTests) -> RunTests:
+        # Configure the runner to re-run tests
+        if self.num_workers == 0 and not self.single_process:
+            # Always run tests in fresh processes to have more deterministic
+            # initial state. Don't re-run tests in parallel but limit to a
+            # single worker process to have side effects (on the system load
+            # and timings) between tests.
+            self.num_workers = 1
+
+        tests, match_tests_dict = self.results.prepare_rerun()
+
+        # Re-run failed tests
+        runtests = runtests.copy(
+            tests=tests,
+            rerun=True,
+            verbose=True,
+            forever=False,
+            fail_fast=False,
+            match_tests_dict=match_tests_dict,
+            output_on_failure=False)
+        self.logger.set_tests(runtests)
+
+        msg = f"Re-running {len(tests)} failed tests in verbose mode"
+        if not self.single_process:
+            msg = f"{msg} in subprocesses"
+            self.log(msg)
+            self._run_tests_mp(runtests, self.num_workers)
+        else:
+            self.log(msg)
+            self.run_tests_sequentially(runtests)
+        return runtests
+
+    def rerun_failed_tests(self, runtests: RunTests) -> None:
+        if self.python_cmd:
+            # Temp patch for https://github.com/python/cpython/issues/94052
+            self.log(
+                "Re-running failed tests is not supported with --python "
+                "host runner option."
+            )
+            return
 
-        self.first_result = self.get_tests_result()
+        self.first_state = self.get_state()
 
         print()
-        print("Re-running failed tests in verbose mode")
-        self.rerun = self.bad[:]
-        for test_name in self.rerun:
-            print(f"Re-running {test_name} in verbose mode", flush=True)
-            self.ns.verbose = True
-            result = runtest(self.ns, test_name)
+        rerun_runtests = self._rerun_failed_tests(runtests)
 
-            self.accumulate_result(result, rerun=True)
+        if self.results.bad:
+            print(count(len(self.results.bad), 'test'), "failed again:")
+            printlist(self.results.bad)
 
-            if result.result == INTERRUPTED:
-                break
+        self.display_result(rerun_runtests)
 
-        if self.bad:
-            print(count(len(self.bad), 'test'), "failed again:")
-            printlist(self.bad)
+    def _run_bisect(self, runtests: RunTests, test: str, progress: str) -> bool:
+        print()
+        title = f"Bisect {test}"
+        if progress:
+            title = f"{title} ({progress})"
+        print(title)
+        print("#" * len(title))
+        print()
 
-        self.display_result()
+        cmd = runtests.create_python_cmd()
+        cmd.extend([
+            "-u", "-m", "test.bisect_cmd",
+            # Limit to 25 iterations (instead of 100) to not abuse CI resources
+            "--max-iter", "25",
+            "-v",
+            # runtests.match_tests is not used (yet) for bisect_cmd -i arg
+        ])
+        cmd.extend(runtests.bisect_cmd_args())
+        cmd.append(test)
+        print("+", shlex.join(cmd), flush=True)
+
+        flush_std_streams()
+
+        import subprocess
+        proc = subprocess.run(cmd, timeout=runtests.timeout)
+        exitcode = proc.returncode
+
+        title = f"{title}: exit code {exitcode}"
+        print(title)
+        print("#" * len(title))
+        print(flush=True)
+
+        if exitcode:
+            print(f"Bisect failed with exit code {exitcode}")
+            return False
+
+        return True
+
+    def run_bisect(self, runtests: RunTests) -> None:
+        tests, _ = self.results.prepare_rerun(clear=False)
+
+        for index, name in enumerate(tests, 1):
+            if len(tests) > 1:
+                progress = f"{index}/{len(tests)}"
+            else:
+                progress = ""
+            if not self._run_bisect(runtests, name, progress):
+                return
 
-    def display_result(self):
+    def display_result(self, runtests: RunTests) -> None:
         # If running the test suite for PGO then no one cares about results.
-        if self.ns.pgo:
+        if runtests.pgo:
             return
 
+        state = self.get_state()
         print()
-        print("== Tests result: %s ==" % self.get_tests_result())
-
-        if self.interrupted:
-            print("Test suite interrupted by signal SIGINT.")
-
-        omitted = set(self.selected) - self.get_executed()
-        if omitted:
-            print()
-            print(count(len(omitted), "test"), "omitted:")
-            printlist(omitted)
-
-        if self.good and not self.ns.quiet:
-            print()
-            if (not self.bad
-                and not self.skipped
-                and not self.interrupted
-                and len(self.good) > 1):
-                print("All", end=' ')
-            print(count(len(self.good), "test"), "OK.")
-
-        if self.ns.print_slow:
-            self.test_times.sort(reverse=True)
-            print()
-            print("10 slowest tests:")
-            for test_time, test in self.test_times[:10]:
-                print("- %s: %s" % (test, format_duration(test_time)))
-
-        if self.bad:
-            print()
-            print(count(len(self.bad), "test"), "failed:")
-            printlist(self.bad)
-
-        if self.environment_changed:
-            print()
-            print("{} altered the execution environment:".format(
-                     count(len(self.environment_changed), "test")))
-            printlist(self.environment_changed)
-
-        if self.skipped and not self.ns.quiet:
-            print()
-            print(count(len(self.skipped), "test"), "skipped:")
-            printlist(self.skipped)
-
-        if self.rerun:
-            print()
-            print("%s:" % count(len(self.rerun), "re-run test"))
-            printlist(self.rerun)
-
-        if self.run_no_tests:
-            print()
-            print(count(len(self.run_no_tests), "test"), "run no tests:")
-            printlist(self.run_no_tests)
-
-    def run_tests_sequential(self):
-        if self.ns.trace:
-            import trace
-            self.tracer = trace.Trace(trace=False, count=True)
+        print(f"== Tests result: {state} ==")
+
+        self.results.display_result(runtests.tests,
+                                    self.quiet, self.print_slowest)
+
+    def run_test(
+        self, test_name: TestName, runtests: RunTests, tracer: trace.Trace | None
+    ) -> TestResult:
+        if tracer is not None:
+            # If we're tracing code coverage, then we don't exit with status
+            # if on a false return value from main.
+            cmd = ('result = run_single_test(test_name, runtests)')
+            namespace = dict(locals())
+            tracer.runctx(cmd, globals=globals(), locals=namespace)
+            result = namespace['result']
+            result.covered_lines = list(tracer.counts)
+        else:
+            result = run_single_test(test_name, runtests)
+
+        self.results.accumulate_result(result, runtests)
+
+        return result
+
+    def run_tests_sequentially(self, runtests: RunTests) -> None:
+        if self.coverage:
+            tracer = trace.Trace(trace=False, count=True)
+        else:
+            tracer = None
 
         save_modules = set(sys.modules)
 
-        print("Run tests sequentially")
-
-        previous_test = None
-        for test_index, test_name in enumerate(self.tests, 1):
-            start_time = time.monotonic()
-
-            text = test_name
-            if previous_test:
-                text = '%s -- %s' % (text, previous_test)
-            self.display_progress(test_index, text)
-
-            if self.tracer:
-                # If we're tracing code coverage, then we don't exit with status
-                # if on a false return value from main.
-                cmd = ('result = runtest(self.ns, test_name); '
-                       'self.accumulate_result(result)')
-                ns = dict(locals())
-                self.tracer.runctx(cmd, globals=globals(), locals=ns)
-                result = ns['result']
-            else:
-                result = runtest(self.ns, test_name)
-                self.accumulate_result(result)
+        jobs = runtests.get_jobs()
+        if jobs is not None:
+            tests = count(jobs, 'test')
+        else:
+            tests = 'tests'
+        msg = f"Run {tests} sequentially in a single process"
+        if runtests.timeout:
+            msg += " (timeout: %s)" % format_duration(runtests.timeout)
+        self.log(msg)
 
-            if result.result == INTERRUPTED:
-                break
+        tests_iter = runtests.iter_tests()
+        for test_index, test_name in enumerate(tests_iter, 1):
+            start_time = time.perf_counter()
 
-            previous_test = format_test_result(result)
-            test_time = time.monotonic() - start_time
-            if test_time >= PROGRESS_MIN_TIME:
-                previous_test = "%s in %s" % (previous_test, format_duration(test_time))
-            elif result[0] == PASSED:
-                # be quiet: say nothing if the test passed shortly
-                previous_test = None
+            self.logger.display_progress(test_index, test_name)
+
+            result = self.run_test(test_name, runtests, tracer)
 
             # Unload the newly imported test modules (best effort finalization)
             new_modules = [module for module in sys.modules
@@ -422,95 +413,26 @@ def run_tests_sequential(self):
                 except (KeyError, AttributeError):
                     pass
 
-        if previous_test:
-            print(previous_test)
-
-    def _test_forever(self, tests):
-        while True:
-            for test_name in tests:
-                yield test_name
-                if self.bad:
-                    return
-                if self.ns.fail_env_changed and self.environment_changed:
-                    return
-
-    def display_header(self):
-        # Print basic platform information
-        print("==", platform.python_implementation(), *sys.version.split())
-        try:
-            print("==", platform.platform(aliased=True),
-                          "%s-endian" % sys.byteorder)
-        except:
-            print("== RustPython: Need to fix platform.platform")
-        print("== cwd:", os.getcwd())
-        cpu_count = os.cpu_count()
-        if cpu_count:
-            print("== CPU count:", cpu_count)
-        try:
-            print("== encodings: locale=%s, FS=%s"
-              % (locale.getpreferredencoding(False),
-                 sys.getfilesystemencoding()))
-        except:
-            print("== RustPython: Need to fix encoding stuff")
-
-    def get_tests_result(self):
-        result = []
-        if self.bad:
-            result.append("FAILURE")
-        elif self.ns.fail_env_changed and self.environment_changed:
-            result.append("ENV CHANGED")
-        elif not any((self.good, self.bad, self.skipped, self.interrupted,
-            self.environment_changed)):
-            result.append("NO TEST RUN")
-
-        if self.interrupted:
-            result.append("INTERRUPTED")
-
-        if not result:
-            result.append("SUCCESS")
-
-        result = ', '.join(result)
-        if self.first_result:
-            result = '%s then %s' % (self.first_result, result)
-        return result
+            text = str(result)
+            test_time = time.perf_counter() - start_time
+            if test_time >= PROGRESS_MIN_TIME:
+                text = f"{text} in {format_duration(test_time)}"
+            self.logger.display_progress(test_index, text)
 
-    def run_tests(self):
-        # For a partial run, we do not need to clutter the output.
-        if (self.ns.header
-            or not(self.ns.pgo or self.ns.quiet or self.ns.single
-                   or self.tests or self.ns.args)):
-            self.display_header()
-
-        if self.ns.huntrleaks:
-            warmup, repetitions, _ = self.ns.huntrleaks
-            if warmup < 3:
-                msg = ("WARNING: Running tests with --huntrleaks/-R and less than "
-                        "3 warmup repetitions can give false positives!")
-                print(msg, file=sys.stdout, flush=True)
-
-        if self.ns.randomize:
-            print("Using random seed", self.ns.random_seed)
-
-        if self.ns.forever:
-            self.tests = self._test_forever(list(self.selected))
-            self.test_count = ''
-            self.test_count_width = 3
-        else:
-            self.tests = iter(self.selected)
-            self.test_count = '/{}'.format(len(self.selected))
-            self.test_count_width = len(self.test_count) - 1
+            if result.must_stop(self.fail_fast, self.fail_env_changed):
+                break
 
-        if self.ns.use_mp:
-            from test.libregrtest.runtest_mp import run_tests_multiprocess
-            run_tests_multiprocess(self)
-        else:
-            self.run_tests_sequential()
+    def get_state(self) -> str:
+        state = self.results.get_state(self.fail_env_changed)
+        if self.first_state:
+            state = f'{self.first_state} then {state}'
+        return state
 
-    def finalize(self):
-        if self.win_load_tracker is not None:
-            self.win_load_tracker.close()
-            self.win_load_tracker = None
+    def _run_tests_mp(self, runtests: RunTests, num_workers: int) -> None:
+        from .run_workers import RunWorkers
+        RunWorkers(num_workers, runtests, self.logger, self.results).run()
 
+    def finalize_tests(self, coverage: trace.CoverageResults | None) -> None:
         if self.next_single_filename:
             if self.next_single_test:
                 with open(self.next_single_filename, 'w') as fp:
@@ -518,141 +440,336 @@ def finalize(self):
             else:
                 os.unlink(self.next_single_filename)
 
-        if self.tracer:
-            r = self.tracer.results()
-            r.write_results(show_missing=True, summary=True,
-                            coverdir=self.ns.coverdir)
+        if coverage is not None:
+            # uses a new-in-Python 3.13 keyword argument that mypy doesn't know about yet:
+            coverage.write_results(show_missing=True, summary=True,  # type: ignore[call-arg]
+                                   coverdir=self.coverage_dir,
+                                   ignore_missing_files=True)
+
+        if self.want_run_leaks:
+            os.system("leaks %d" % os.getpid())
 
+        if self.junit_filename:
+            self.results.write_junit(self.junit_filename)
+
+    def display_summary(self) -> None:
+        if self.first_runtests is None:
+            raise ValueError(
+                "Should never call `display_summary()` before calling `_run_test()`"
+            )
+
+        duration = time.perf_counter() - self.logger.start_time
+        filtered = bool(self.match_tests)
+
+        # Total duration
         print()
-        duration = time.monotonic() - self.start_time
         print("Total duration: %s" % format_duration(duration))
-        print("Tests result: %s" % self.get_tests_result())
 
-        if self.ns.runleaks:
-            os.system("leaks %d" % os.getpid())
+        self.results.display_summary(self.first_runtests, filtered)
+
+        # Result
+        state = self.get_state()
+        print(f"Result: {state}")
+
+    def create_run_tests(self, tests: TestTuple) -> RunTests:
+        return RunTests(
+            tests,
+            fail_fast=self.fail_fast,
+            fail_env_changed=self.fail_env_changed,
+            match_tests=self.match_tests,
+            match_tests_dict=None,
+            rerun=False,
+            forever=self.forever,
+            pgo=self.pgo,
+            pgo_extended=self.pgo_extended,
+            output_on_failure=self.output_on_failure,
+            timeout=self.timeout,
+            verbose=self.verbose,
+            quiet=self.quiet,
+            hunt_refleak=self.hunt_refleak,
+            test_dir=self.test_dir,
+            use_junit=(self.junit_filename is not None),
+            coverage=self.coverage,
+            memory_limit=self.memory_limit,
+            gc_threshold=self.gc_threshold,
+            use_resources=self.use_resources,
+            python_cmd=self.python_cmd,
+            randomize=self.randomize,
+            random_seed=self.random_seed,
+        )
+
+    def _run_tests(self, selected: TestTuple, tests: TestList | None) -> int:
+        if self.hunt_refleak and self.hunt_refleak.warmups < 3:
+            msg = ("WARNING: Running tests with --huntrleaks/-R and "
+                   "less than 3 warmup repetitions can give false positives!")
+            print(msg, file=sys.stdout, flush=True)
+
+        if self.num_workers < 0:
+            # Use all CPUs + 2 extra worker processes for tests
+            # that like to sleep
+            #
+            # os.process.cpu_count() is new in Python 3.13;
+            # mypy doesn't know about it yet
+            self.num_workers = (os.process_cpu_count() or 1) + 2  # type: ignore[attr-defined]
 
-    def save_xml_result(self):
-        if not self.ns.xmlpath and not self.testsuite_xml:
-            return
+        # For a partial run, we do not need to clutter the output.
+        if (self.want_header
+            or not(self.pgo or self.quiet or self.single_test_run
+                   or tests or self.cmdline_args)):
+            display_header(self.use_resources, self.python_cmd)
 
-        import xml.etree.ElementTree as ET
-        root = ET.Element("testsuites")
+        print("Using random seed:", self.random_seed)
 
-        # Manually count the totals for the overall summary
-        totals = {'tests': 0, 'errors': 0, 'failures': 0}
-        for suite in self.testsuite_xml:
-            root.append(suite)
-            for k in totals:
-                try:
-                    totals[k] += int(suite.get(k, 0))
-                except ValueError:
-                    pass
+        runtests = self.create_run_tests(selected)
+        self.first_runtests = runtests
+        self.logger.set_tests(runtests)
 
-        for k, v in totals.items():
-            root.set(k, str(v))
-
-        xmlpath = os.path.join(os_helper.SAVEDCWD, self.ns.xmlpath)
-        with open(xmlpath, 'wb') as f:
-            for s in ET.tostringlist(root):
-                f.write(s)
-
-    def main(self, tests=None, **kwargs):
-        global TEMPDIR
-        self.ns = self.parse_args(kwargs)
-
-        if self.ns.tempdir:
-            TEMPDIR = self.ns.tempdir
-        elif self.ns.worker_args:
-            ns_dict, _ = json.loads(self.ns.worker_args)
-            TEMPDIR = ns_dict.get("tempdir") or TEMPDIR
-
-        os.makedirs(TEMPDIR, exist_ok=True)
-
-        # Define a writable temp dir that will be used as cwd while running
-        # the tests. The name of the dir includes the pid to allow parallel
-        # testing (see the -j option).
-        test_cwd = 'test_python_{}'.format(os.getpid())
-        test_cwd = os.path.join(TEMPDIR, test_cwd)
-
-        # Run the tests in a context manager that temporarily changes the CWD to a
-        # temporary and writable directory.  If it's not possible to create or
-        # change the CWD, the original CWD will be used.  The original CWD is
-        # available from os_helper.SAVEDCWD.
-        with os_helper.temp_cwd(test_cwd, quiet=True):
-            self._main(tests, kwargs)
-
-    def getloadavg(self):
-        if self.win_load_tracker is not None:
-            return self.win_load_tracker.getloadavg()
-
-        if hasattr(os, 'getloadavg'):
-            return os.getloadavg()[0]
-
-        return None
-
-    def _main(self, tests, kwargs):
-        if self.ns.huntrleaks:
-            warmup, repetitions, _ = self.ns.huntrleaks
-            if warmup < 1 or repetitions < 1:
-                msg = ("Invalid values for the --huntrleaks/-R parameters. The "
-                       "number of warmups and repetitions must be at least 1 "
-                       "each (1:1).")
-                print(msg, file=sys.stderr, flush=True)
-                sys.exit(2)
-
-        if self.ns.worker_args is not None:
-            from test.libregrtest.runtest_mp import run_tests_worker
-            run_tests_worker(self.ns.worker_args)
-
-        if self.ns.wait:
-            input("Press any key to continue...")
+        if (runtests.hunt_refleak is not None) and (not self.num_workers):
+            # gh-109739: WindowsLoadTracker thread interferes with refleak check
+            use_load_tracker = False
+        else:
+            # WindowsLoadTracker is only needed on Windows
+            use_load_tracker = MS_WINDOWS
 
-        support.PGO = self.ns.pgo
+        if use_load_tracker:
+            self.logger.start_load_tracker()
+        try:
+            if self.num_workers:
+                self._run_tests_mp(runtests, self.num_workers)
+            else:
+                # gh-135734: suppress_immortalization() raises SkipTest
+                # if _testinternalcapi is missing and the -R option is set.
+                if not can_use_suppress_immortalization(runtests.hunt_refleak):
+                    print("Module '_testinternalcapi' is missing. "
+                          "Did you disable it with --disable-test-modules?",
+                          file=sys.stderr)
+                    raise SystemExit(1)
+
+                # gh-117783: don't immortalize deferred objects when tracking
+                # refleaks. Only relevant for the free-threaded build.
+                with suppress_immortalization(runtests.hunt_refleak):
+                    self.run_tests_sequentially(runtests)
+
+            coverage = self.results.get_coverage_results()
+            self.display_result(runtests)
+
+            if self.want_rerun and self.results.need_rerun():
+                self.rerun_failed_tests(runtests)
+
+            if self.want_bisect and self.results.need_rerun():
+                self.run_bisect(runtests)
+        finally:
+            if use_load_tracker:
+                self.logger.stop_load_tracker()
+
+        self.display_summary()
+        self.finalize_tests(coverage)
+
+        return self.results.get_exitcode(self.fail_env_changed,
+                                         self.fail_rerun)
+
+    def run_tests(self, selected: TestTuple, tests: TestList | None) -> int:
+        os.makedirs(self.tmp_dir, exist_ok=True)
+        work_dir = get_work_dir(self.tmp_dir)
+
+        # Put a timeout on Python exit
+        with exit_timeout():
+            # Run the tests in a context manager that temporarily changes the
+            # CWD to a temporary and writable directory. If it's not possible
+            # to create or change the CWD, the original CWD will be used.
+            # The original CWD is available from os_helper.SAVEDCWD.
+            with os_helper.temp_cwd(work_dir, quiet=True):
+                # When using multiprocessing, worker processes will use
+                # work_dir as their parent temporary directory. So when the
+                # main process exit, it removes also subdirectories of worker
+                # processes.
+                return self._run_tests(selected, tests)
+
+    def _add_cross_compile_opts(self, regrtest_opts):
+        # WASM/WASI buildbot builders pass multiple PYTHON environment
+        # variables such as PYTHONPATH and _PYTHON_HOSTRUNNER.
+        keep_environ = bool(self.python_cmd)
+        environ = None
+
+        # Are we using cross-compilation?
+        cross_compile = is_cross_compiled()
+
+        # Get HOSTRUNNER
+        hostrunner = get_host_runner()
+
+        if cross_compile:
+            # emulate -E, but keep PYTHONPATH + cross compile env vars,
+            # so test executable can load correct sysconfigdata file.
+            keep = {
+                '_PYTHON_PROJECT_BASE',
+                '_PYTHON_HOST_PLATFORM',
+                '_PYTHON_SYSCONFIGDATA_NAME',
+                "_PYTHON_SYSCONFIGDATA_PATH",
+                'PYTHONPATH'
+            }
+            old_environ = os.environ
+            new_environ = {
+                name: value for name, value in os.environ.items()
+                if not name.startswith(('PYTHON', '_PYTHON')) or name in keep
+            }
+            # Only set environ if at least one variable was removed
+            if new_environ != old_environ:
+                environ = new_environ
+            keep_environ = True
+
+        if cross_compile and hostrunner:
+            if self.num_workers == 0 and not self.single_process:
+                # For now use only two cores for cross-compiled builds;
+                # hostrunner can be expensive.
+                regrtest_opts.extend(['-j', '2'])
+
+            # If HOSTRUNNER is set and -p/--python option is not given, then
+            # use hostrunner to execute python binary for tests.
+            if not self.python_cmd:
+                buildpython = sysconfig.get_config_var("BUILDPYTHON")
+                python_cmd = f"{hostrunner} {buildpython}"
+                regrtest_opts.extend(["--python", python_cmd])
+                keep_environ = True
+
+        return (environ, keep_environ)
+
+    def _add_ci_python_opts(self, python_opts, keep_environ):
+        # --fast-ci and --slow-ci add options to Python.
+        #
+        # Some platforms run tests in embedded mode and cannot change options
+        # after startup, so if this function changes, consider also updating:
+        #  * gradle_task in Android/android.py
+
+        # Unbuffered stdout and stderr. This isn't helpful on Android, because
+        # it would cause lines to be split into multiple log messages.
+        if not sys.stdout.write_through and sys.platform != "android":
+            python_opts.append('-u')
+
+        # Add warnings filter 'error', unless the user specified a different
+        # filter. Ignore BytesWarning since it's controlled by '-b' below.
+        if not [
+            opt for opt in sys.warnoptions
+            if not opt.endswith("::BytesWarning")
+        ]:
+            python_opts.extend(('-W', 'error'))
+
+        # Error on bytes/str comparison
+        if sys.flags.bytes_warning < 2:
+            python_opts.append('-bb')
+
+        if not keep_environ:
+            # Ignore PYTHON* environment variables
+            if not sys.flags.ignore_environment:
+                python_opts.append('-E')
+
+    def _execute_python(self, cmd, environ):
+        # Make sure that messages before execv() are logged
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+        cmd_text = shlex.join(cmd)
+        try:
+            # Android and iOS run tests in embedded mode. To update their
+            # Python options, see the comment in _add_ci_python_opts.
+            if not cmd[0]:
+                raise ValueError("No Python executable is present")
+
+            print(f"+ {cmd_text}", flush=True)
+            if hasattr(os, 'execv') and not MS_WINDOWS:
+                os.execv(cmd[0], cmd)
+                # On success, execv() do no return.
+                # On error, it raises an OSError.
+            else:
+                import subprocess
+                with subprocess.Popen(cmd, env=environ) as proc:
+                    try:
+                        proc.wait()
+                    except KeyboardInterrupt:
+                        # There is no need to call proc.terminate(): on CTRL+C,
+                        # SIGTERM is also sent to the child process.
+                        try:
+                            proc.wait(timeout=EXIT_TIMEOUT)
+                        except subprocess.TimeoutExpired:
+                            proc.kill()
+                            proc.wait()
+                            sys.exit(EXITCODE_INTERRUPTED)
+
+                sys.exit(proc.returncode)
+        except Exception as exc:
+            print_warning(f"Failed to change Python options: {exc!r}\n"
+                          f"Command: {cmd_text}")
+            # continue executing main()
+
+    def _add_python_opts(self) -> None:
+        python_opts: list[str] = []
+        regrtest_opts: list[str] = []
+
+        environ, keep_environ = self._add_cross_compile_opts(regrtest_opts)
+        if self.ci_mode:
+            self._add_ci_python_opts(python_opts, keep_environ)
+
+        if (not python_opts) and (not regrtest_opts) and (environ is None):
+            # Nothing changed: nothing to do
+            return
 
-        setup_tests(self.ns)
+        # Create new command line
+        cmd = list(sys.orig_argv)
+        if python_opts:
+            cmd[1:1] = python_opts
+        if regrtest_opts:
+            cmd.extend(regrtest_opts)
+        cmd.append("--dont-add-python-opts")
 
-        self.find_tests(tests)
+        self._execute_python(cmd, environ)
 
-        if self.ns.list_tests:
-            self.list_tests()
-            sys.exit(0)
+    def _init(self):
+        setup_process()
 
-        if self.ns.list_cases:
-            self.list_cases()
-            sys.exit(0)
+        if self.junit_filename and not os.path.isabs(self.junit_filename):
+            self.junit_filename = os.path.abspath(self.junit_filename)
 
-        # If we're on windows and this is the parent runner (not a worker),
-        # track the load average.
-        # TODO: RUSTPYTHON
-        # if sys.platform == 'win32' and (self.ns.worker_args is None):
-        #     from test.libregrtest.win_utils import WindowsLoadTracker
+        strip_py_suffix(self.cmdline_args)
 
-        #     try:
-        #         self.win_load_tracker = WindowsLoadTracker()
-        #     except FileNotFoundError as error:
-        #         # Windows IoT Core and Windows Nano Server do not provide
-        #         # typeperf.exe for x64, x86 or ARM
-        #         print(f'Failed to create WindowsLoadTracker: {error}')
+        self._tmp_dir = get_temp_dir(self._tmp_dir)
 
-        self.run_tests()
-        self.display_result()
+    @property
+    def tmp_dir(self) -> StrPath:
+        if self._tmp_dir is None:
+            raise ValueError(
+                "Should never use `.tmp_dir` before calling `.main()`"
+            )
+        return self._tmp_dir
 
-        if self.ns.verbose2 and self.bad:
-            self.rerun_failed_tests()
+    def main(self, tests: TestList | None = None) -> NoReturn:
+        if self.want_add_python_opts:
+            self._add_python_opts()
 
-        self.finalize()
+        self._init()
+
+        if self.want_cleanup:
+            cleanup_temp_dir(self.tmp_dir)
+            sys.exit(0)
 
-        self.save_xml_result()
+        if self.want_wait:
+            input("Press any key to continue...")
+
+        setup_test_dir(self.test_dir)
+        selected, tests = self.find_tests(tests)
+
+        exitcode = 0
+        if self.want_list_tests:
+            self.list_tests(selected)
+        elif self.want_list_cases:
+            list_cases(selected,
+                       match_tests=self.match_tests,
+                       test_dir=self.test_dir)
+        else:
+            exitcode = self.run_tests(selected, tests)
 
-        if self.bad:
-            sys.exit(2)
-        if self.interrupted:
-            sys.exit(130)
-        if self.ns.fail_env_changed and self.environment_changed:
-            sys.exit(3)
-        sys.exit(0)
+        sys.exit(exitcode)
 
 
-def main(tests=None, **kwargs):
+def main(tests=None, _add_python_opts=False, **kwargs) -> NoReturn:
     """Run the Python suite."""
-    Regrtest().main(tests=tests, **kwargs)
+    ns = _parse_args(sys.argv[1:], **kwargs)
+    Regrtest(ns, _add_python_opts=_add_python_opts).main(tests=tests)
diff --git a/Lib/test/libregrtest/mypy.ini b/Lib/test/libregrtest/mypy.ini
new file mode 100644
index 00000000000..3fa9afcb7a4
--- /dev/null
+++ b/Lib/test/libregrtest/mypy.ini
@@ -0,0 +1,26 @@
+# Config file for running mypy on libregrtest.
+# Run mypy by invoking `mypy --config-file Lib/test/libregrtest/mypy.ini`
+# on the command-line from the repo root
+
+[mypy]
+files = Lib/test/libregrtest
+explicit_package_bases = True
+python_version = 3.12
+platform = linux
+pretty = True
+
+# Enable most stricter settings
+enable_error_code = ignore-without-code
+strict = True
+
+# Various stricter settings that we can't yet enable
+# Try to enable these in the following order:
+disallow_incomplete_defs = False
+disallow_untyped_calls = False
+disallow_untyped_defs = False
+check_untyped_defs = False
+warn_return_any = False
+
+# Various internal modules that typeshed deliberately doesn't have stubs for:
+[mypy-_abc.*,_opcode.*,_overlapped.*,_testcapi.*,_testinternalcapi.*,test.*]
+ignore_missing_imports = True
diff --git a/Lib/test/libregrtest/pgo.py b/Lib/test/libregrtest/pgo.py
new file mode 100644
index 00000000000..04803ddf644
--- /dev/null
+++ b/Lib/test/libregrtest/pgo.py
@@ -0,0 +1,55 @@
+# Set of tests run by default if --pgo is specified.  The tests below were
+# chosen based on the following criteria: either they exercise a commonly used
+# C extension module or type, or they run some relatively typical Python code.
+# Long running tests should be avoided because the PGO instrumented executable
+# runs slowly.
+PGO_TESTS = [
+    'test_array',
+    'test_base64',
+    'test_binascii',
+    'test_binop',
+    'test_bisect',
+    'test_bytes',
+    'test_bz2',
+    'test_cmath',
+    'test_codecs',
+    'test_collections',
+    'test_complex',
+    'test_dataclasses',
+    'test_datetime',
+    'test_decimal',
+    'test_difflib',
+    'test_float',
+    'test_fstring',
+    'test_functools',
+    'test_generators',
+    'test_hashlib',
+    'test_heapq',
+    'test_int',
+    'test_itertools',
+    'test_json',
+    'test_long',
+    'test_lzma',
+    'test_math',
+    'test_memoryview',
+    'test_operator',
+    'test_ordered_dict',
+    'test_patma',
+    'test_pickle',
+    'test_pprint',
+    'test_re',
+    'test_set',
+    'test_sqlite3',
+    'test_statistics',
+    'test_str',
+    'test_struct',
+    'test_tabnanny',
+    'test_time',
+    'test_xml_etree',
+    'test_xml_etree_c',
+]
+
+def setup_pgo_tests(cmdline_args, pgo_extended: bool) -> None:
+    if not cmdline_args and not pgo_extended:
+        # run default set of tests for PGO training
+        cmdline_args[:] = PGO_TESTS[:]
diff --git a/Lib/test/libregrtest/refleak.py b/Lib/test/libregrtest/refleak.py
index 03747f7f757..75fcd118d72 100644
--- a/Lib/test/libregrtest/refleak.py
+++ b/Lib/test/libregrtest/refleak.py
@@ -1,9 +1,17 @@
 import os
-import re
 import sys
 import warnings
 from inspect import isabstract
+from typing import Any
+import linecache
+
 from test import support
+from test.support import os_helper
+from test.support import refleak_helper
+
+from .runtests import HuntRefleak
+from .utils import clear_caches
+
 try:
     from _abc import _get_dump
 except ImportError:
@@ -17,7 +25,33 @@ def _get_dump(cls):
                 cls._abc_negative_cache, cls._abc_negative_cache_version)
 
 
-def dash_R(ns, test_name, test_func):
+def save_support_xml(filename):
+    if support.junit_xml_list is None:
+        return
+
+    import pickle
+    with open(filename, 'xb') as fp:
+        pickle.dump(support.junit_xml_list, fp)
+    support.junit_xml_list = None
+
+
+def restore_support_xml(filename):
+    try:
+        fp = open(filename, 'rb')
+    except FileNotFoundError:
+        return
+
+    import pickle
+    with fp:
+        xml_list = pickle.load(fp)
+    os.unlink(filename)
+
+    support.junit_xml_list = xml_list
+
+
+def runtest_refleak(test_name, test_func,
+                    hunt_refleak: HuntRefleak,
+                    quiet: bool):
     """Run a test multiple times, looking for reference leaks.
 
     Returns:
@@ -39,12 +73,19 @@ def dash_R(ns, test_name, test_func):
     fs = warnings.filters[:]
     ps = copyreg.dispatch_table.copy()
     pic = sys.path_importer_cache.copy()
+    zdc: dict[str, Any] | None
+    # Linecache holds a cache with the source of interactive code snippets
+    # (e.g. code typed in the REPL). This cache is not cleared by
+    # linecache.clearcache(). We need to save and restore it to avoid false
+    # positives.
+    linecache_data = linecache.cache.copy(), linecache._interactive_cache.copy() # type: ignore[attr-defined]
     try:
         import zipimport
     except ImportError:
         zdc = None # Run unmodified on platforms without zipimport support
     else:
-        zdc = zipimport._zip_directory_cache.copy()
+        # private attribute that mypy doesn't know about:
+        zdc = zipimport._zip_directory_cache.copy()  # type: ignore[attr-defined]
     abcs = {}
     for abc in [getattr(collections.abc, a) for a in collections.abc.__all__]:
         if not isabstract(abc):
@@ -60,9 +101,10 @@ def dash_R(ns, test_name, test_func):
     def get_pooled_int(value):
         return int_pool.setdefault(value, value)
 
-    nwarmup, ntracked, fname = ns.huntrleaks
-    fname = os.path.join(os_helper.SAVEDCWD, fname)
-    repcount = nwarmup + ntracked
+    warmups = hunt_refleak.warmups
+    runs = hunt_refleak.runs
+    filename = hunt_refleak.filename
+    repcount = warmups + runs
 
     # Pre-allocate to ensure that the loop doesn't allocate anything new
     rep_range = list(range(repcount))
@@ -71,45 +113,81 @@ def get_pooled_int(value):
     fd_deltas = [0] * repcount
     getallocatedblocks = sys.getallocatedblocks
     gettotalrefcount = sys.gettotalrefcount
-    fd_count = support.fd_count
-
+    getunicodeinternedsize = sys.getunicodeinternedsize
+    fd_count = os_helper.fd_count
     # initialize variables to make pyflakes quiet
-    rc_before = alloc_before = fd_before = 0
-
-    if not ns.quiet:
-        print("beginning", repcount, "repetitions", file=sys.stderr)
-        print(("1234567890"*(repcount//10 + 1))[:repcount], file=sys.stderr,
-              flush=True)
-
-    dash_R_cleanup(fs, ps, pic, zdc, abcs)
+    rc_before = alloc_before = fd_before = interned_immortal_before = 0
+
+    if not quiet:
+        print("beginning", repcount, "repetitions. Showing number of leaks "
+                "(. for 0 or less, X for 10 or more)",
+              file=sys.stderr)
+        numbers = ("1234567890"*(repcount//10 + 1))[:repcount]
+        numbers = numbers[:warmups] + ':' + numbers[warmups:]
+        print(numbers, file=sys.stderr, flush=True)
+
+    xml_filename = 'refleak-xml.tmp'
+    result = None
+    dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data)
+    support.gc_collect()
 
     for i in rep_range:
-        test_func()
-        dash_R_cleanup(fs, ps, pic, zdc, abcs)
-
-        # dash_R_cleanup() ends with collecting cyclic trash:
-        # read memory statistics immediately after.
-        alloc_after = getallocatedblocks()
+        current = refleak_helper._hunting_for_refleaks
+        refleak_helper._hunting_for_refleaks = True
+        try:
+            result = test_func()
+        finally:
+            refleak_helper._hunting_for_refleaks = current
+
+        save_support_xml(xml_filename)
+        dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data)
+        support.gc_collect()
+
+        # Read memory statistics immediately after the garbage collection.
+        # Also, readjust the reference counts and alloc blocks by ignoring
+        # any strings that might have been interned during test_func. These
+        # strings will be deallocated at runtime shutdown
+        interned_immortal_after = getunicodeinternedsize(
+            # Use an internal-only keyword argument that mypy doesn't know yet
+            _only_immortal=True)  # type: ignore[call-arg]
+        alloc_after = getallocatedblocks() - interned_immortal_after
         rc_after = gettotalrefcount()
         fd_after = fd_count()
 
-        if not ns.quiet:
-            print('.', end='', file=sys.stderr, flush=True)
-
         rc_deltas[i] = get_pooled_int(rc_after - rc_before)
         alloc_deltas[i] = get_pooled_int(alloc_after - alloc_before)
         fd_deltas[i] = get_pooled_int(fd_after - fd_before)
 
+        if not quiet:
+            # use max, not sum, so total_leaks is one of the pooled ints
+            total_leaks = max(rc_deltas[i], alloc_deltas[i], fd_deltas[i])
+            if total_leaks <= 0:
+                symbol = '.'
+            elif total_leaks < 10:
+                symbol = (
+                    '.', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                    )[total_leaks]
+            else:
+                symbol = 'X'
+            if i == warmups:
+                print(' ', end='', file=sys.stderr, flush=True)
+            print(symbol, end='', file=sys.stderr, flush=True)
+            del total_leaks
+            del symbol
+
         alloc_before = alloc_after
         rc_before = rc_after
         fd_before = fd_after
+        interned_immortal_before = interned_immortal_after
+
+        restore_support_xml(xml_filename)
 
-    if not ns.quiet:
+    if not quiet:
         print(file=sys.stderr)
 
     # These checkers return False on success, True on failure
     def check_rc_deltas(deltas):
-        # Checker for reference counters and memomry blocks.
+        # Checker for reference counters and memory blocks.
         #
         # bpo-30776: Try to ignore false positives:
         #
@@ -133,19 +211,25 @@ def check_fd_deltas(deltas):
         (fd_deltas, 'file descriptors', check_fd_deltas)
     ]:
         # ignore warmup runs
-        deltas = deltas[nwarmup:]
-        if checker(deltas):
+        deltas = deltas[warmups:]
+        failing = checker(deltas)
+        suspicious = any(deltas)
+        if failing or suspicious:
             msg = '%s leaked %s %s, sum=%s' % (
                 test_name, deltas, item_name, sum(deltas))
-            print(msg, file=sys.stderr, flush=True)
-            with open(fname, "a") as refrep:
-                print(msg, file=refrep)
-                refrep.flush()
-            failed = True
-    return failed
-
-
-def dash_R_cleanup(fs, ps, pic, zdc, abcs):
+            print(msg, end='', file=sys.stderr)
+            if failing:
+                print(file=sys.stderr, flush=True)
+                with open(filename, "a", encoding="utf-8") as refrep:
+                    print(msg, file=refrep)
+                    refrep.flush()
+                failed = True
+            else:
+                print(' (this is fine)', file=sys.stderr, flush=True)
+    return (failed, result)
+
+
+def dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data):
     import copyreg
     import collections.abc
 
@@ -155,6 +239,11 @@ def dash_R_cleanup(fs, ps, pic, zdc, abcs):
     copyreg.dispatch_table.update(ps)
     sys.path_importer_cache.clear()
     sys.path_importer_cache.update(pic)
+    lcache, linteractive = linecache_data
+    linecache._interactive_cache.clear()
+    linecache._interactive_cache.update(linteractive)
+    linecache.cache.clear()
+    linecache.cache.update(lcache)
     try:
         import zipimport
     except ImportError:
@@ -163,121 +252,29 @@ def dash_R_cleanup(fs, ps, pic, zdc, abcs):
         zipimport._zip_directory_cache.clear()
         zipimport._zip_directory_cache.update(zdc)
 
-    # clear type cache
-    sys._clear_type_cache()
-
     # Clear ABC registries, restoring previously saved ABC registries.
+    # ignore deprecation warning for collections.abc.ByteString
     abs_classes = [getattr(collections.abc, a) for a in collections.abc.__all__]
     abs_classes = filter(isabstract, abs_classes)
     for abc in abs_classes:
         for obj in abc.__subclasses__() + [abc]:
-            for ref in abcs.get(obj, set()):
-                if ref() is not None:
-                    obj.register(ref())
+            refs = abcs.get(obj, None)
+            if refs is not None:
+                obj._abc_registry_clear()
+                for ref in refs:
+                    subclass = ref()
+                    if subclass is not None:
+                        obj.register(subclass)
             obj._abc_caches_clear()
 
+    # Clear caches
     clear_caches()
 
-
-def clear_caches():
-    # Clear the warnings registry, so they can be displayed again
-    for mod in sys.modules.values():
-        if hasattr(mod, '__warningregistry__'):
-            del mod.__warningregistry__
-
-    # Flush standard output, so that buffered data is sent to the OS and
-    # associated Python objects are reclaimed.
-    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
-        if stream is not None:
-            stream.flush()
-
-    # Clear assorted module caches.
-    # Don't worry about resetting the cache if the module is not loaded
-    try:
-        distutils_dir_util = sys.modules['distutils.dir_util']
-    except KeyError:
-        pass
-    else:
-        distutils_dir_util._path_created.clear()
-    re.purge()
-
-    try:
-        _strptime = sys.modules['_strptime']
-    except KeyError:
-        pass
-    else:
-        _strptime._regex_cache.clear()
-
-    try:
-        urllib_parse = sys.modules['urllib.parse']
-    except KeyError:
-        pass
-    else:
-        urllib_parse.clear_cache()
-
-    try:
-        urllib_request = sys.modules['urllib.request']
-    except KeyError:
-        pass
-    else:
-        urllib_request.urlcleanup()
-
-    try:
-        linecache = sys.modules['linecache']
-    except KeyError:
-        pass
-    else:
-        linecache.clearcache()
-
-    try:
-        mimetypes = sys.modules['mimetypes']
-    except KeyError:
-        pass
-    else:
-        mimetypes._default_mime_types()
-
-    try:
-        filecmp = sys.modules['filecmp']
-    except KeyError:
-        pass
-    else:
-        filecmp._cache.clear()
-
-    try:
-        struct = sys.modules['struct']
-    except KeyError:
-        pass
-    else:
-        # TODO: fix
-        # struct._clearcache()
-        pass
-
-    try:
-        doctest = sys.modules['doctest']
-    except KeyError:
-        pass
-    else:
-        doctest.master = None
-
-    try:
-        ctypes = sys.modules['ctypes']
-    except KeyError:
-        pass
-    else:
-        ctypes._reset_cache()
-
-    try:
-        typing = sys.modules['typing']
-    except KeyError:
-        pass
-    else:
-        for f in typing._cleanups:
-            f()
-
-    support.gc_collect()
+    # Clear other caches last (previous function calls can re-populate them):
+    sys._clear_internal_caches()
 
 
-def warm_caches():
+def warm_caches() -> None:
     # char cache
     s = bytes(range(256))
     for i in range(256):
diff --git a/Lib/test/libregrtest/result.py b/Lib/test/libregrtest/result.py
new file mode 100644
index 00000000000..7553efe5e8a
--- /dev/null
+++ b/Lib/test/libregrtest/result.py
@@ -0,0 +1,225 @@
+import dataclasses
+import json
+from typing import Any
+
+from .utils import (
+    StrJSON, TestName, FilterTuple,
+    format_duration, normalize_test_name, print_warning)
+
+
+@dataclasses.dataclass(slots=True)
+class TestStats:
+    tests_run: int = 0
+    failures: int = 0
+    skipped: int = 0
+
+    @staticmethod
+    def from_unittest(result):
+        return TestStats(result.testsRun,
+                         len(result.failures),
+                         len(result.skipped))
+
+    @staticmethod
+    def from_doctest(results):
+        return TestStats(results.attempted,
+                         results.failed,
+                         results.skipped)
+
+    def accumulate(self, stats):
+        self.tests_run += stats.tests_run
+        self.failures += stats.failures
+        self.skipped += stats.skipped
+
+
+# Avoid enum.Enum to reduce the number of imports when tests are run
+class State:
+    PASSED = "PASSED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+    UNCAUGHT_EXC = "UNCAUGHT_EXC"
+    REFLEAK = "REFLEAK"
+    ENV_CHANGED = "ENV_CHANGED"
+    RESOURCE_DENIED = "RESOURCE_DENIED"
+    INTERRUPTED = "INTERRUPTED"
+    WORKER_FAILED = "WORKER_FAILED"   # non-zero worker process exit code
+    WORKER_BUG = "WORKER_BUG"         # exception when running a worker
+    DID_NOT_RUN = "DID_NOT_RUN"
+    TIMEOUT = "TIMEOUT"
+
+    @staticmethod
+    def is_failed(state):
+        return state in {
+            State.FAILED,
+            State.UNCAUGHT_EXC,
+            State.REFLEAK,
+            State.WORKER_FAILED,
+            State.WORKER_BUG,
+            State.TIMEOUT}
+
+    @staticmethod
+    def has_meaningful_duration(state):
+        # Consider that the duration is meaningless for these cases.
+        # For example, if a whole test file is skipped, its duration
+        # is unlikely to be the duration of executing its tests,
+        # but just the duration to execute code which skips the test.
+        return state not in {
+            State.SKIPPED,
+            State.RESOURCE_DENIED,
+            State.INTERRUPTED,
+            State.WORKER_FAILED,
+            State.WORKER_BUG,
+            State.DID_NOT_RUN}
+
+    @staticmethod
+    def must_stop(state):
+        return state in {
+            State.INTERRUPTED,
+            State.WORKER_BUG,
+        }
+
+
+FileName = str
+LineNo = int
+Location = tuple[FileName, LineNo]
+
+
+@dataclasses.dataclass(slots=True)
+class TestResult:
+    test_name: TestName
+    state: str | None = None
+    # Test duration in seconds
+    duration: float | None = None
+    xml_data: list[str] | None = None
+    stats: TestStats | None = None
+
+    # errors and failures copied from support.TestFailedWithDetails
+    errors: list[tuple[str, str]] | None = None
+    failures: list[tuple[str, str]] | None = None
+
+    # partial coverage in a worker run; not used by sequential in-process runs
+    covered_lines: list[Location] | None = None
+
+    def is_failed(self, fail_env_changed: bool) -> bool:
+        if self.state == State.ENV_CHANGED:
+            return fail_env_changed
+        return State.is_failed(self.state)
+
+    def _format_failed(self):
+        if self.errors and self.failures:
+            le = len(self.errors)
+            lf = len(self.failures)
+            error_s = "error" + ("s" if le > 1 else "")
+            failure_s = "failure" + ("s" if lf > 1 else "")
+            return f"{self.test_name} failed ({le} {error_s}, {lf} {failure_s})"
+
+        if self.errors:
+            le = len(self.errors)
+            error_s = "error" + ("s" if le > 1 else "")
+            return f"{self.test_name} failed ({le} {error_s})"
+
+        if self.failures:
+            lf = len(self.failures)
+            failure_s = "failure" + ("s" if lf > 1 else "")
+            return f"{self.test_name} failed ({lf} {failure_s})"
+
+        return f"{self.test_name} failed"
+
+    def __str__(self) -> str:
+        match self.state:
+            case State.PASSED:
+                return f"{self.test_name} passed"
+            case State.FAILED:
+                return self._format_failed()
+            case State.SKIPPED:
+                return f"{self.test_name} skipped"
+            case State.UNCAUGHT_EXC:
+                return f"{self.test_name} failed (uncaught exception)"
+            case State.REFLEAK:
+                return f"{self.test_name} failed (reference leak)"
+            case State.ENV_CHANGED:
+                return f"{self.test_name} failed (env changed)"
+            case State.RESOURCE_DENIED:
+                return f"{self.test_name} skipped (resource denied)"
+            case State.INTERRUPTED:
+                return f"{self.test_name} interrupted"
+            case State.WORKER_FAILED:
+                return f"{self.test_name} worker non-zero exit code"
+            case State.WORKER_BUG:
+                return f"{self.test_name} worker bug"
+            case State.DID_NOT_RUN:
+                return f"{self.test_name} ran no tests"
+            case State.TIMEOUT:
+                assert self.duration is not None, "self.duration is None"
+                return f"{self.test_name} timed out ({format_duration(self.duration)})"
+            case _:
+                raise ValueError("unknown result state: {state!r}")
+
+    def has_meaningful_duration(self):
+        return State.has_meaningful_duration(self.state)
+
+    def set_env_changed(self):
+        if self.state is None or self.state == State.PASSED:
+            self.state = State.ENV_CHANGED
+
+    def must_stop(self, fail_fast: bool, fail_env_changed: bool) -> bool:
+        if State.must_stop(self.state):
+            return True
+        if fail_fast and self.is_failed(fail_env_changed):
+            return True
+        return False
+
+    def get_rerun_match_tests(self) -> FilterTuple | None:
+        match_tests = []
+
+        errors = self.errors or []
+        failures = self.failures or []
+        for error_list, is_error in (
+            (errors, True),
+            (failures, False),
+        ):
+            for full_name, *_ in error_list:
+                match_name = normalize_test_name(full_name, is_error=is_error)
+                if match_name is None:
+                    # 'setUpModule (test.test_sys)': don't filter tests
+                    return None
+                if not match_name:
+                    error_type = "ERROR" if is_error else "FAIL"
+                    print_warning(f"rerun failed to parse {error_type} test name: "
+                                  f"{full_name!r}: don't filter tests")
+                    return None
+                match_tests.append(match_name)
+
+        if not match_tests:
+            return None
+        return tuple(match_tests)
+
+    def write_json_into(self, file) -> None:
+        json.dump(self, file, cls=_EncodeTestResult)
+
+    @staticmethod
+    def from_json(worker_json: StrJSON) -> 'TestResult':
+        return json.loads(worker_json, object_hook=_decode_test_result)
+
+
+class _EncodeTestResult(json.JSONEncoder):
+    def default(self, o: Any) -> dict[str, Any]:
+        if isinstance(o, TestResult):
+            result = dataclasses.asdict(o)
+            result["__test_result__"] = o.__class__.__name__
+            return result
+        else:
+            return super().default(o)
+
+
+def _decode_test_result(data: dict[str, Any]) -> TestResult | dict[str, Any]:
+    if "__test_result__" in data:
+        data.pop('__test_result__')
+        if data['stats'] is not None:
+            data['stats'] = TestStats(**data['stats'])
+        if data['covered_lines'] is not None:
+            data['covered_lines'] = [
+                tuple(loc) for loc in data['covered_lines']
+            ]
+        return TestResult(**data)
+    else:
+        return data
diff --git a/Lib/test/libregrtest/results.py b/Lib/test/libregrtest/results.py
new file mode 100644
index 00000000000..9eda926966d
--- /dev/null
+++ b/Lib/test/libregrtest/results.py
@@ -0,0 +1,276 @@
+import sys
+import trace
+from typing import TYPE_CHECKING
+
+from .runtests import RunTests
+from .result import State, TestResult, TestStats, Location
+from .utils import (
+    StrPath, TestName, TestTuple, TestList, FilterDict,
+    printlist, count, format_duration)
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+# Python uses exit code 1 when an exception is not caught
+# argparse.ArgumentParser.error() uses exit code 2
+EXITCODE_BAD_TEST = 2
+EXITCODE_ENV_CHANGED = 3
+EXITCODE_NO_TESTS_RAN = 4
+EXITCODE_RERUN_FAIL = 5
+EXITCODE_INTERRUPTED = 130   # 128 + signal.SIGINT=2
+
+
+class TestResults:
+    def __init__(self) -> None:
+        self.bad: TestList = []
+        self.good: TestList = []
+        self.rerun_bad: TestList = []
+        self.skipped: TestList = []
+        self.resource_denied: TestList = []
+        self.env_changed: TestList = []
+        self.run_no_tests: TestList = []
+        self.rerun: TestList = []
+        self.rerun_results: list[TestResult] = []
+
+        self.interrupted: bool = False
+        self.worker_bug: bool = False
+        self.test_times: list[tuple[float, TestName]] = []
+        self.stats = TestStats()
+        # used by --junit-xml
+        self.testsuite_xml: list['Element'] = []
+        # used by -T with -j
+        self.covered_lines: set[Location] = set()
+
+    def is_all_good(self) -> bool:
+        return (not self.bad
+                and not self.skipped
+                and not self.interrupted
+                and not self.worker_bug)
+
+    def get_executed(self) -> set[TestName]:
+        return (set(self.good) | set(self.bad) | set(self.skipped)
+                | set(self.resource_denied) | set(self.env_changed)
+                | set(self.run_no_tests))
+
+    def no_tests_run(self) -> bool:
+        return not any((self.good, self.bad, self.skipped, self.interrupted,
+                        self.env_changed))
+
+    def get_state(self, fail_env_changed: bool) -> str:
+        state = []
+        if self.bad:
+            state.append("FAILURE")
+        elif fail_env_changed and self.env_changed:
+            state.append("ENV CHANGED")
+        elif self.no_tests_run():
+            state.append("NO TESTS RAN")
+
+        if self.interrupted:
+            state.append("INTERRUPTED")
+        if self.worker_bug:
+            state.append("WORKER BUG")
+        if not state:
+            state.append("SUCCESS")
+
+        return ', '.join(state)
+
+    def get_exitcode(self, fail_env_changed: bool, fail_rerun: bool) -> int:
+        exitcode = 0
+        if self.bad:
+            exitcode = EXITCODE_BAD_TEST
+        elif self.interrupted:
+            exitcode = EXITCODE_INTERRUPTED
+        elif fail_env_changed and self.env_changed:
+            exitcode = EXITCODE_ENV_CHANGED
+        elif self.no_tests_run():
+            exitcode = EXITCODE_NO_TESTS_RAN
+        elif fail_rerun and self.rerun:
+            exitcode = EXITCODE_RERUN_FAIL
+        elif self.worker_bug:
+            exitcode = EXITCODE_BAD_TEST
+        return exitcode
+
+    def accumulate_result(self, result: TestResult, runtests: RunTests) -> None:
+        test_name = result.test_name
+        rerun = runtests.rerun
+        fail_env_changed = runtests.fail_env_changed
+
+        match result.state:
+            case State.PASSED:
+                self.good.append(test_name)
+            case State.ENV_CHANGED:
+                self.env_changed.append(test_name)
+                self.rerun_results.append(result)
+            case State.SKIPPED:
+                self.skipped.append(test_name)
+            case State.RESOURCE_DENIED:
+                self.resource_denied.append(test_name)
+            case State.INTERRUPTED:
+                self.interrupted = True
+            case State.DID_NOT_RUN:
+                self.run_no_tests.append(test_name)
+            case _:
+                if result.is_failed(fail_env_changed):
+                    self.bad.append(test_name)
+                    self.rerun_results.append(result)
+                else:
+                    raise ValueError(f"invalid test state: {result.state!r}")
+
+        if result.state == State.WORKER_BUG:
+            self.worker_bug = True
+
+        if result.has_meaningful_duration() and not rerun:
+            if result.duration is None:
+                raise ValueError("result.duration is None")
+            self.test_times.append((result.duration, test_name))
+        if result.stats is not None:
+            self.stats.accumulate(result.stats)
+        if rerun:
+            self.rerun.append(test_name)
+        if result.covered_lines:
+            # we don't care about trace counts so we don't have to sum them up
+            self.covered_lines.update(result.covered_lines)
+        xml_data = result.xml_data
+        if xml_data:
+            self.add_junit(xml_data)
+
+    def get_coverage_results(self) -> trace.CoverageResults:
+        counts = {loc: 1 for loc in self.covered_lines}
+        return trace.CoverageResults(counts=counts)
+
+    def need_rerun(self) -> bool:
+        return bool(self.rerun_results)
+
+    def prepare_rerun(self, *, clear: bool = True) -> tuple[TestTuple, FilterDict]:
+        tests: TestList = []
+        match_tests_dict = {}
+        for result in self.rerun_results:
+            tests.append(result.test_name)
+
+            match_tests = result.get_rerun_match_tests()
+            # ignore empty match list
+            if match_tests:
+                match_tests_dict[result.test_name] = match_tests
+
+        if clear:
+            # Clear previously failed tests
+            self.rerun_bad.extend(self.bad)
+            self.bad.clear()
+            self.env_changed.clear()
+            self.rerun_results.clear()
+
+        return (tuple(tests), match_tests_dict)
+
+    def add_junit(self, xml_data: list[str]) -> None:
+        import xml.etree.ElementTree as ET
+        for e in xml_data:
+            try:
+                self.testsuite_xml.append(ET.fromstring(e))
+            except ET.ParseError:
+                print(xml_data, file=sys.__stderr__)
+                raise
+
+    def write_junit(self, filename: StrPath) -> None:
+        if not self.testsuite_xml:
+            # Don't create empty XML file
+            return
+
+        import xml.etree.ElementTree as ET
+        root = ET.Element("testsuites")
+
+        # Manually count the totals for the overall summary
+        totals = {'tests': 0, 'errors': 0, 'failures': 0}
+        for suite in self.testsuite_xml:
+            root.append(suite)
+            for k in totals:
+                try:
+                    totals[k] += int(suite.get(k, 0))
+                except ValueError:
+                    pass
+
+        for k, v in totals.items():
+            root.set(k, str(v))
+
+        with open(filename, 'wb') as f:
+            for s in ET.tostringlist(root):
+                f.write(s)
+
+    def display_result(self, tests: TestTuple, quiet: bool, print_slowest: bool) -> None:
+        if print_slowest:
+            self.test_times.sort(reverse=True)
+            print()
+            print("10 slowest tests:")
+            for test_time, test in self.test_times[:10]:
+                print("- %s: %s" % (test, format_duration(test_time)))
+
+        all_tests = []
+        omitted = set(tests) - self.get_executed()
+
+        # less important
+        all_tests.append((sorted(omitted), "test", "{} omitted:"))
+        if not quiet:
+            all_tests.append((self.skipped, "test", "{} skipped:"))
+            all_tests.append((self.resource_denied, "test", "{} skipped (resource denied):"))
+        all_tests.append((self.run_no_tests, "test", "{} run no tests:"))
+
+        # more important
+        all_tests.append((self.env_changed, "test", "{} altered the execution environment (env changed):"))
+        all_tests.append((self.rerun, "re-run test", "{}:"))
+        all_tests.append((self.bad, "test", "{} failed:"))
+
+        for tests_list, count_text, title_format in all_tests:
+            if tests_list:
+                print()
+                count_text = count(len(tests_list), count_text)
+                print(title_format.format(count_text))
+                printlist(tests_list)
+
+        if self.good and not quiet:
+            print()
+            text = count(len(self.good), "test")
+            text = f"{text} OK."
+            if (self.is_all_good() and len(self.good) > 1):
+                text = f"All {text}"
+            print(text)
+
+        if self.interrupted:
+            print()
+            print("Test suite interrupted by signal SIGINT.")
+
+    def display_summary(self, first_runtests: RunTests, filtered: bool) -> None:
+        # Total tests
+        stats = self.stats
+        text = f'run={stats.tests_run:,}'
+        if filtered:
+            text = f"{text} (filtered)"
+        report = [text]
+        if stats.failures:
+            report.append(f'failures={stats.failures:,}')
+        if stats.skipped:
+            report.append(f'skipped={stats.skipped:,}')
+        print(f"Total tests: {' '.join(report)}")
+
+        # Total test files
+        all_tests = [self.good, self.bad, self.rerun,
+                     self.skipped,
+                     self.env_changed, self.run_no_tests]
+        run = sum(map(len, all_tests))
+        text = f'run={run}'
+        if not first_runtests.forever:
+            ntest = len(first_runtests.tests)
+            text = f"{text}/{ntest}"
+        if filtered:
+            text = f"{text} (filtered)"
+        report = [text]
+        for name, tests in (
+            ('failed', self.bad),
+            ('env_changed', self.env_changed),
+            ('skipped', self.skipped),
+            ('resource_denied', self.resource_denied),
+            ('rerun', self.rerun),
+            ('run_no_tests', self.run_no_tests),
+        ):
+            if tests:
+                report.append(f'{name}={len(tests)}')
+        print(f"Total test files: {' '.join(report)}")
diff --git a/Lib/test/libregrtest/run_workers.py b/Lib/test/libregrtest/run_workers.py
new file mode 100644
index 00000000000..3c6d13215fd
--- /dev/null
+++ b/Lib/test/libregrtest/run_workers.py
@@ -0,0 +1,621 @@
+import contextlib
+import dataclasses
+import faulthandler
+import os.path
+import queue
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import traceback
+from typing import Any, Literal, TextIO
+
+from test import support
+from test.support import os_helper, MS_WINDOWS
+
+from .logger import Logger
+from .result import TestResult, State
+from .results import TestResults
+from .runtests import RunTests, WorkerRunTests, JsonFile, JsonFileType
+from .single import PROGRESS_MIN_TIME
+from .utils import (
+    StrPath, TestName,
+    format_duration, print_warning, count, plural, get_signal_name)
+from .worker import create_worker_process, USE_PROCESS_GROUP
+
+if MS_WINDOWS:
+    import locale
+    import msvcrt
+
+
+
+# Display the running tests if nothing happened last N seconds
+PROGRESS_UPDATE = 30.0   # seconds
+assert PROGRESS_UPDATE >= PROGRESS_MIN_TIME
+
+# Kill the main process after 5 minutes. It is supposed to write an update
+# every PROGRESS_UPDATE seconds. Tolerate 5 minutes for Python slowest
+# buildbot workers.
+MAIN_PROCESS_TIMEOUT = 5 * 60.0
+assert MAIN_PROCESS_TIMEOUT >= PROGRESS_UPDATE
+
+# Time to wait until a worker completes: should be immediate
+WAIT_COMPLETED_TIMEOUT = 30.0   # seconds
+
+# Time to wait a killed process (in seconds)
+WAIT_KILLED_TIMEOUT = 60.0
+
+
+# We do not use a generator so multiple threads can call next().
+class MultiprocessIterator:
+
+    """A thread-safe iterator over tests for multiprocess mode."""
+
+    def __init__(self, tests_iter):
+        self.lock = threading.Lock()
+        self.tests_iter = tests_iter
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        with self.lock:
+            if self.tests_iter is None:
+                raise StopIteration
+            return next(self.tests_iter)
+
+    def stop(self):
+        with self.lock:
+            self.tests_iter = None
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class MultiprocessResult:
+    result: TestResult
+    # bpo-45410: stderr is written into stdout to keep messages order
+    worker_stdout: str | None = None
+    err_msg: str | None = None
+
+
+class WorkerThreadExited:
+    """Indicates that a worker thread has exited"""
+
+ExcStr = str
+QueueOutput = tuple[Literal[False], MultiprocessResult] | tuple[Literal[True], ExcStr]
+QueueContent = QueueOutput | WorkerThreadExited
+
+
+class ExitThread(Exception):
+    pass
+
+
+class WorkerError(Exception):
+    def __init__(self,
+                 test_name: TestName,
+                 err_msg: str | None,
+                 stdout: str | None,
+                 state: str):
+        result = TestResult(test_name, state=state)
+        self.mp_result = MultiprocessResult(result, stdout, err_msg)
+        super().__init__()
+
+
+_NOT_RUNNING = "<not running>"
+
+
+class WorkerThread(threading.Thread):
+    def __init__(self, worker_id: int, runner: "RunWorkers") -> None:
+        super().__init__()
+        self.worker_id = worker_id
+        self.runtests = runner.runtests
+        self.pending = runner.pending
+        self.output = runner.output
+        self.timeout = runner.worker_timeout
+        self.log = runner.log
+        self.test_name = _NOT_RUNNING
+        self.start_time = time.monotonic()
+        self._popen: subprocess.Popen[str] | None = None
+        self._killed = False
+        self._stopped = False
+
+    def __repr__(self) -> str:
+        info = [f'WorkerThread #{self.worker_id}']
+        if self.is_alive():
+            info.append("running")
+        else:
+            info.append('stopped')
+        test = self.test_name
+        if test:
+            info.append(f'test={test}')
+        popen = self._popen
+        if popen is not None:
+            dt = time.monotonic() - self.start_time
+            info.extend((f'pid={popen.pid}',
+                         f'time={format_duration(dt)}'))
+        return '<%s>' % ' '.join(info)
+
+    def _kill(self) -> None:
+        popen = self._popen
+        if popen is None:
+            return
+
+        if self._killed:
+            return
+        self._killed = True
+
+        if USE_PROCESS_GROUP:
+            what = f"{self} process group"
+        else:
+            what = f"{self} process"
+
+        print(f"Kill {what}", file=sys.stderr, flush=True)
+        try:
+            if USE_PROCESS_GROUP:
+                os.killpg(popen.pid, signal.SIGKILL)
+            else:
+                popen.kill()
+        except ProcessLookupError:
+            # popen.kill(): the process completed, the WorkerThread thread
+            # read its exit status, but Popen.send_signal() read the returncode
+            # just before Popen.wait() set returncode.
+            pass
+        except OSError as exc:
+            print_warning(f"Failed to kill {what}: {exc!r}")
+
+    def stop(self) -> None:
+        # Method called from a different thread to stop this thread
+        self._stopped = True
+        self._kill()
+
+    def _run_process(self, runtests: WorkerRunTests, output_fd: int,
+                     tmp_dir: StrPath | None = None) -> int | None:
+        popen = create_worker_process(runtests, output_fd, tmp_dir)
+        self._popen = popen
+        self._killed = False
+
+        try:
+            if self._stopped:
+                # If kill() has been called before self._popen is set,
+                # self._popen is still running. Call again kill()
+                # to ensure that the process is killed.
+                self._kill()
+                raise ExitThread
+
+            try:
+                # gh-94026: stdout+stderr are written to tempfile
+                retcode = popen.wait(timeout=self.timeout)
+                assert retcode is not None
+                return retcode
+            except subprocess.TimeoutExpired:
+                if self._stopped:
+                    # kill() has been called: communicate() fails on reading
+                    # closed stdout
+                    raise ExitThread
+
+                # On timeout, kill the process
+                self._kill()
+
+                # None means TIMEOUT for the caller
+                retcode = None
+                # bpo-38207: Don't attempt to call communicate() again: on it
+                # can hang until all child processes using stdout
+                # pipes completes.
+            except OSError:
+                if self._stopped:
+                    # kill() has been called: communicate() fails
+                    # on reading closed stdout
+                    raise ExitThread
+                raise
+            return None
+        except:
+            self._kill()
+            raise
+        finally:
+            self._wait_completed()
+            self._popen = None
+
+    def create_stdout(self, stack: contextlib.ExitStack) -> TextIO:
+        """Create stdout temporary file (file descriptor)."""
+
+        if MS_WINDOWS:
+            # gh-95027: When stdout is not a TTY, Python uses the ANSI code
+            # page for the sys.stdout encoding. If the main process runs in a
+            # terminal, sys.stdout uses WindowsConsoleIO with UTF-8 encoding.
+            encoding = locale.getencoding()
+        else:
+            encoding = sys.stdout.encoding
+
+        # gh-94026: Write stdout+stderr to a tempfile as workaround for
+        # non-blocking pipes on Emscripten with NodeJS.
+        # gh-109425: Use "backslashreplace" error handler: log corrupted
+        # stdout+stderr, instead of failing with a UnicodeDecodeError and not
+        # logging stdout+stderr at all.
+        stdout_file = tempfile.TemporaryFile('w+',
+                                             encoding=encoding,
+                                             errors='backslashreplace')
+        stack.enter_context(stdout_file)
+        return stdout_file
+
+    def create_json_file(self, stack: contextlib.ExitStack) -> tuple[JsonFile, TextIO | None]:
+        """Create JSON file."""
+
+        json_file_use_stdout = self.runtests.json_file_use_stdout()
+        if json_file_use_stdout:
+            json_file = JsonFile(None, JsonFileType.STDOUT)
+            json_tmpfile = None
+        else:
+            json_tmpfile = tempfile.TemporaryFile('w+', encoding='utf8')
+            stack.enter_context(json_tmpfile)
+
+            json_fd = json_tmpfile.fileno()
+            if MS_WINDOWS:
+                # The msvcrt module is only available on Windows;
+                # we run mypy with `--platform=linux` in CI
+                json_handle: int = msvcrt.get_osfhandle(json_fd)  # type: ignore[attr-defined]
+                json_file = JsonFile(json_handle,
+                                     JsonFileType.WINDOWS_HANDLE)
+            else:
+                json_file = JsonFile(json_fd, JsonFileType.UNIX_FD)
+        return (json_file, json_tmpfile)
+
+    def create_worker_runtests(self, test_name: TestName, json_file: JsonFile) -> WorkerRunTests:
+        tests = (test_name,)
+        if self.runtests.rerun:
+            match_tests = self.runtests.get_match_tests(test_name)
+        else:
+            match_tests = None
+
+        kwargs: dict[str, Any] = {}
+        if match_tests:
+            kwargs['match_tests'] = [(test, True) for test in match_tests]
+        if self.runtests.output_on_failure:
+            kwargs['verbose'] = True
+            kwargs['output_on_failure'] = False
+        return self.runtests.create_worker_runtests(
+            tests=tests,
+            json_file=json_file,
+            **kwargs)
+
+    def run_tmp_files(self, worker_runtests: WorkerRunTests,
+                      stdout_fd: int) -> tuple[int | None, list[StrPath]]:
+        # gh-93353: Check for leaked temporary files in the parent process,
+        # since the deletion of temporary files can happen late during
+        # Python finalization: too late for libregrtest.
+        if not support.is_wasi:
+            # Don't check for leaked temporary files and directories if Python is
+            # run on WASI. WASI doesn't pass environment variables like TMPDIR to
+            # worker processes.
+            tmp_dir = tempfile.mkdtemp(prefix="test_python_")
+            tmp_dir = os.path.abspath(tmp_dir)
+            try:
+                retcode = self._run_process(worker_runtests,
+                                            stdout_fd, tmp_dir)
+            finally:
+                tmp_files = os.listdir(tmp_dir)
+                os_helper.rmtree(tmp_dir)
+        else:
+            retcode = self._run_process(worker_runtests, stdout_fd)
+            tmp_files = []
+
+        return (retcode, tmp_files)
+
+    def read_stdout(self, stdout_file: TextIO) -> str:
+        stdout_file.seek(0)
+        try:
+            return stdout_file.read().strip()
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            raise WorkerError(self.test_name,
+                              f"Cannot read process stdout: {exc}",
+                              stdout=None,
+                              state=State.WORKER_BUG)
+
+    def read_json(self, json_file: JsonFile, json_tmpfile: TextIO | None,
+                  stdout: str) -> tuple[TestResult, str]:
+        try:
+            if json_tmpfile is not None:
+                json_tmpfile.seek(0)
+                worker_json = json_tmpfile.read()
+            elif json_file.file_type == JsonFileType.STDOUT:
+                stdout, _, worker_json = stdout.rpartition("\n")
+                stdout = stdout.rstrip()
+            else:
+                with json_file.open(encoding='utf8') as json_fp:
+                    worker_json = json_fp.read()
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            err_msg = f"Failed to read worker process JSON: {exc}"
+            raise WorkerError(self.test_name, err_msg, stdout,
+                              state=State.WORKER_BUG)
+
+        if not worker_json:
+            raise WorkerError(self.test_name, "empty JSON", stdout,
+                              state=State.WORKER_BUG)
+
+        try:
+            result = TestResult.from_json(worker_json)
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            err_msg = f"Failed to parse worker process JSON: {exc}"
+            raise WorkerError(self.test_name, err_msg, stdout,
+                              state=State.WORKER_BUG)
+
+        return (result, stdout)
+
+    def _runtest(self, test_name: TestName) -> MultiprocessResult:
+        with contextlib.ExitStack() as stack:
+            stdout_file = self.create_stdout(stack)
+            json_file, json_tmpfile = self.create_json_file(stack)
+            worker_runtests = self.create_worker_runtests(test_name, json_file)
+
+            retcode: str | int | None
+            retcode, tmp_files = self.run_tmp_files(worker_runtests,
+                                                    stdout_file.fileno())
+
+            stdout = self.read_stdout(stdout_file)
+
+            if retcode is None:
+                raise WorkerError(self.test_name, stdout=stdout,
+                                  err_msg=None,
+                                  state=State.TIMEOUT)
+            if retcode != 0:
+                name = get_signal_name(retcode)
+                if name:
+                    retcode = f"{retcode} ({name})"
+                raise WorkerError(self.test_name, f"Exit code {retcode}", stdout,
+                                  state=State.WORKER_FAILED)
+
+            result, stdout = self.read_json(json_file, json_tmpfile, stdout)
+
+        if tmp_files:
+            msg = (f'\n\n'
+                   f'Warning -- {test_name} leaked temporary files '
+                   f'({len(tmp_files)}): {", ".join(sorted(tmp_files))}')
+            stdout += msg
+            result.set_env_changed()
+
+        return MultiprocessResult(result, stdout)
+
+    def run(self) -> None:
+        fail_fast = self.runtests.fail_fast
+        fail_env_changed = self.runtests.fail_env_changed
+        try:
+            while not self._stopped:
+                try:
+                    test_name = next(self.pending)
+                except StopIteration:
+                    break
+
+                self.start_time = time.monotonic()
+                self.test_name = test_name
+                try:
+                    mp_result = self._runtest(test_name)
+                except WorkerError as exc:
+                    mp_result = exc.mp_result
+                finally:
+                    self.test_name = _NOT_RUNNING
+                mp_result.result.duration = time.monotonic() - self.start_time
+                self.output.put((False, mp_result))
+
+                if mp_result.result.must_stop(fail_fast, fail_env_changed):
+                    break
+        except ExitThread:
+            pass
+        except BaseException:
+            self.output.put((True, traceback.format_exc()))
+        finally:
+            self.output.put(WorkerThreadExited())
+
+    def _wait_completed(self) -> None:
+        popen = self._popen
+        # only needed for mypy:
+        if popen is None:
+            raise ValueError("Should never access `._popen` before calling `.run()`")
+
+        try:
+            popen.wait(WAIT_COMPLETED_TIMEOUT)
+        except (subprocess.TimeoutExpired, OSError) as exc:
+            print_warning(f"Failed to wait for {self} completion "
+                          f"(timeout={format_duration(WAIT_COMPLETED_TIMEOUT)}): "
+                          f"{exc!r}")
+
+    def wait_stopped(self, start_time: float) -> None:
+        # bpo-38207: RunWorkers.stop_workers() called self.stop()
+        # which killed the process. Sometimes, killing the process from the
+        # main thread does not interrupt popen.communicate() in
+        # WorkerThread thread. This loop with a timeout is a workaround
+        # for that.
+        #
+        # Moreover, if this method fails to join the thread, it is likely
+        # that Python will hang at exit while calling threading._shutdown()
+        # which tries again to join the blocked thread. Regrtest.main()
+        # uses EXIT_TIMEOUT to workaround this second bug.
+        while True:
+            # Write a message every second
+            self.join(1.0)
+            if not self.is_alive():
+                break
+            dt = time.monotonic() - start_time
+            self.log(f"Waiting for {self} thread for {format_duration(dt)}")
+            if dt > WAIT_KILLED_TIMEOUT:
+                print_warning(f"Failed to join {self} in {format_duration(dt)}")
+                break
+
+
+def get_running(workers: list[WorkerThread]) -> str | None:
+    running: list[str] = []
+    for worker in workers:
+        test_name = worker.test_name
+        if test_name == _NOT_RUNNING:
+            continue
+        dt = time.monotonic() - worker.start_time
+        if dt >= PROGRESS_MIN_TIME:
+            text = f'{test_name} ({format_duration(dt)})'
+            running.append(text)
+    if not running:
+        return None
+    return f"running ({len(running)}): {', '.join(running)}"
+
+
+class RunWorkers:
+    def __init__(self, num_workers: int, runtests: RunTests,
+                 logger: Logger, results: TestResults) -> None:
+        self.num_workers = num_workers
+        self.runtests = runtests
+        self.log = logger.log
+        self.display_progress = logger.display_progress
+        self.results: TestResults = results
+        self.live_worker_count = 0
+
+        self.output: queue.Queue[QueueContent] = queue.Queue()
+        tests_iter = runtests.iter_tests()
+        self.pending = MultiprocessIterator(tests_iter)
+        self.timeout = runtests.timeout
+        if self.timeout is not None:
+            # Rely on faulthandler to kill a worker process. This timouet is
+            # when faulthandler fails to kill a worker process. Give a maximum
+            # of 5 minutes to faulthandler to kill the worker.
+            self.worker_timeout: float | None = min(self.timeout * 1.5, self.timeout + 5 * 60)
+        else:
+            self.worker_timeout = None
+        self.workers: list[WorkerThread] = []
+
+        jobs = self.runtests.get_jobs()
+        if jobs is not None:
+            # Don't spawn more threads than the number of jobs:
+            # these worker threads would never get anything to do.
+            self.num_workers = min(self.num_workers, jobs)
+
+    def start_workers(self) -> None:
+        self.workers = [WorkerThread(index, self)
+                        for index in range(1, self.num_workers + 1)]
+        jobs = self.runtests.get_jobs()
+        if jobs is not None:
+            tests = count(jobs, 'test')
+        else:
+            tests = 'tests'
+        nworkers = len(self.workers)
+        processes = plural(nworkers, "process", "processes")
+        msg = (f"Run {tests} in parallel using "
+               f"{nworkers} worker {processes}")
+        if self.timeout and self.worker_timeout is not None:
+            msg += (" (timeout: %s, worker timeout: %s)"
+                    % (format_duration(self.timeout),
+                       format_duration(self.worker_timeout)))
+        self.log(msg)
+        for worker in self.workers:
+            worker.start()
+            self.live_worker_count += 1
+
+    def stop_workers(self) -> None:
+        start_time = time.monotonic()
+        for worker in self.workers:
+            worker.stop()
+        for worker in self.workers:
+            worker.wait_stopped(start_time)
+
+    def _get_result(self) -> QueueOutput | None:
+        pgo = self.runtests.pgo
+        use_faulthandler = (self.timeout is not None)
+
+        # bpo-46205: check the status of workers every iteration to avoid
+        # waiting forever on an empty queue.
+        while self.live_worker_count > 0:
+            if use_faulthandler:
+                faulthandler.dump_traceback_later(MAIN_PROCESS_TIMEOUT,
+                                                  exit=True)
+
+            # wait for a thread
+            try:
+                result = self.output.get(timeout=PROGRESS_UPDATE)
+                if isinstance(result, WorkerThreadExited):
+                    self.live_worker_count -= 1
+                    continue
+                return result
+            except queue.Empty:
+                pass
+
+            if not pgo:
+                # display progress
+                running = get_running(self.workers)
+                if running:
+                    self.log(running)
+        return None
+
+    def display_result(self, mp_result: MultiprocessResult) -> None:
+        result = mp_result.result
+        pgo = self.runtests.pgo
+
+        text = str(result)
+        if mp_result.err_msg:
+            # WORKER_BUG
+            text += ' (%s)' % mp_result.err_msg
+        elif (result.duration and result.duration >= PROGRESS_MIN_TIME and not pgo):
+            text += ' (%s)' % format_duration(result.duration)
+        if not pgo:
+            running = get_running(self.workers)
+            if running:
+                text += f' -- {running}'
+        self.display_progress(self.test_index, text)
+
+    def _process_result(self, item: QueueOutput) -> TestResult:
+        """Returns True if test runner must stop."""
+        if item[0]:
+            # Thread got an exception
+            format_exc = item[1]
+            print_warning(f"regrtest worker thread failed: {format_exc}")
+            result = TestResult("<regrtest worker>", state=State.WORKER_BUG)
+            self.results.accumulate_result(result, self.runtests)
+            return result
+
+        self.test_index += 1
+        mp_result = item[1]
+        result = mp_result.result
+        self.results.accumulate_result(result, self.runtests)
+        self.display_result(mp_result)
+
+        # Display worker stdout
+        if not self.runtests.output_on_failure:
+            show_stdout = True
+        else:
+            # --verbose3 ignores stdout on success
+            show_stdout = (result.state != State.PASSED)
+        if show_stdout:
+            stdout = mp_result.worker_stdout
+            if stdout:
+                print(stdout, flush=True)
+
+        return result
+
+    def run(self) -> None:
+        fail_fast = self.runtests.fail_fast
+        fail_env_changed = self.runtests.fail_env_changed
+
+        self.start_workers()
+
+        self.test_index = 0
+        try:
+            while True:
+                item = self._get_result()
+                if item is None:
+                    break
+
+                result = self._process_result(item)
+                if result.must_stop(fail_fast, fail_env_changed):
+                    break
+        except KeyboardInterrupt:
+            print()
+            self.results.interrupted = True
+        finally:
+            if self.timeout is not None:
+                faulthandler.cancel_dump_traceback_later()
+
+            # Always ensure that all worker processes are no longer
+            # worker when we exit this function
+            self.pending.stop()
+            self.stop_workers()
diff --git a/Lib/test/libregrtest/runtest.py b/Lib/test/libregrtest/runtest.py
deleted file mode 100644
index e2af18f3499..00000000000
--- a/Lib/test/libregrtest/runtest.py
+++ /dev/null
@@ -1,328 +0,0 @@
-import collections
-import faulthandler
-import functools
-# import gc
-import importlib
-import io
-import os
-import sys
-import time
-import traceback
-import unittest
-
-from test import support
-from test.support import os_helper, import_helper
-from test.libregrtest.refleak import dash_R, clear_caches
-from test.libregrtest.save_env import saved_test_environment
-from test.libregrtest.utils import print_warning
-
-
-# Test result constants.
-PASSED = 1
-FAILED = 0
-ENV_CHANGED = -1
-SKIPPED = -2
-RESOURCE_DENIED = -3
-INTERRUPTED = -4
-CHILD_ERROR = -5   # error in a child process
-TEST_DID_NOT_RUN = -6   # error in a child process
-
-_FORMAT_TEST_RESULT = {
-    PASSED: '%s passed',
-    FAILED: '%s failed',
-    ENV_CHANGED: '%s failed (env changed)',
-    SKIPPED: '%s skipped',
-    RESOURCE_DENIED: '%s skipped (resource denied)',
-    INTERRUPTED: '%s interrupted',
-    CHILD_ERROR: '%s crashed',
-    TEST_DID_NOT_RUN: '%s run no tests',
-}
-
-# Minimum duration of a test to display its duration or to mention that
-# the test is running in background
-PROGRESS_MIN_TIME = 30.0   # seconds
-
-# small set of tests to determine if we have a basically functioning interpreter
-# (i.e. if any of these fail, then anything else is likely to follow)
-STDTESTS = [
-    # 'test_grammar',
-    # 'test_opcodes',
-    # 'test_dict',
-    # 'test_builtin',
-    # 'test_exceptions',
-    # 'test_types',
-    # 'test_unittest',
-    # 'test_doctest',
-    # 'test_doctest2',
-    # 'test_support'
-]
-
-# set of tests that we don't want to be executed when using regrtest
-NOTTESTS = set()
-
-
-# used by --findleaks, store for gc.garbage
-FOUND_GARBAGE = []
-
-
-def format_test_result(result):
-    fmt = _FORMAT_TEST_RESULT.get(result.result, "%s")
-    return fmt % result.test_name
-
-
-def findtestdir(path=None):
-    return path or os.path.dirname(os.path.dirname(__file__)) or os.curdir
-
-
-def findtests(testdir=None, stdtests=STDTESTS, nottests=NOTTESTS):
-    """Return a list of all applicable test modules."""
-    testdir = findtestdir(testdir)
-    names = os.listdir(testdir)
-    tests = []
-    others = set(stdtests) | nottests
-    for name in names:
-        mod, ext = os.path.splitext(name)
-        if mod[:5] == "test_" and ext in (".py", "") and mod not in others:
-            tests.append(mod)
-    return stdtests + sorted(tests)
-
-
-def get_abs_module(ns, test_name):
-    if test_name.startswith('test.') or ns.testdir:
-        return test_name
-    else:
-        # Import it from the test package
-        return 'test.' + test_name
-
-
-TestResult = collections.namedtuple('TestResult',
-    'test_name result test_time xml_data')
-
-def _runtest(ns, test_name):
-    # Handle faulthandler timeout, capture stdout+stderr, XML serialization
-    # and measure time.
-
-    output_on_failure = ns.verbose3
-
-    use_timeout = (ns.timeout is not None)
-    if use_timeout:
-        faulthandler.dump_traceback_later(ns.timeout, exit=True)
-
-    start_time = time.perf_counter()
-    try:
-        support.set_match_tests(ns.match_tests)
-        support.junit_xml_list = xml_list = [] if ns.xmlpath else None
-        if ns.failfast:
-            support.failfast = True
-
-        if output_on_failure:
-            support.verbose = True
-
-            stream = io.StringIO()
-            orig_stdout = sys.stdout
-            orig_stderr = sys.stderr
-            try:
-                sys.stdout = stream
-                sys.stderr = stream
-                result = _runtest_inner(ns, test_name,
-                                        display_failure=False)
-                if result != PASSED:
-                    output = stream.getvalue()
-                    orig_stderr.write(output)
-                    orig_stderr.flush()
-            finally:
-                sys.stdout = orig_stdout
-                sys.stderr = orig_stderr
-        else:
-            # Tell tests to be moderately quiet
-            support.verbose = ns.verbose
-
-            result = _runtest_inner(ns, test_name,
-                                    display_failure=not ns.verbose)
-
-        if xml_list:
-            import xml.etree.ElementTree as ET
-            xml_data = [ET.tostring(x).decode('us-ascii') for x in xml_list]
-        else:
-            xml_data = None
-
-        test_time = time.perf_counter() - start_time
-
-        return TestResult(test_name, result, test_time, xml_data)
-    finally:
-        if use_timeout:
-            faulthandler.cancel_dump_traceback_later()
-        support.junit_xml_list = None
-
-
-def runtest(ns, test_name):
-    """Run a single test.
-
-    ns -- regrtest namespace of options
-    test_name -- the name of the test
-
-    Returns the tuple (result, test_time, xml_data), where result is one
-    of the constants:
-
-        INTERRUPTED      KeyboardInterrupt
-        RESOURCE_DENIED  test skipped because resource denied
-        SKIPPED          test skipped for some other reason
-        ENV_CHANGED      test failed because it changed the execution environment
-        FAILED           test failed
-        PASSED           test passed
-        EMPTY_TEST_SUITE test ran no subtests.
-
-    If ns.xmlpath is not None, xml_data is a list containing each
-    generated testsuite element.
-    """
-    try:
-        return _runtest(ns, test_name)
-    except:
-        if not ns.pgo:
-            msg = traceback.format_exc()
-            print(f"test {test_name} crashed -- {msg}",
-                  file=sys.stderr, flush=True)
-        return TestResult(test_name, FAILED, 0.0, None)
-
-
-def _test_module(the_module):
-    loader = unittest.TestLoader()
-    tests = loader.loadTestsFromModule(the_module)
-    for error in loader.errors:
-        print(error, file=sys.stderr)
-    if loader.errors:
-        raise Exception("errors while loading tests")
-    support.run_unittest(tests)
-
-
-def _runtest_inner2(ns, test_name):
-    # Load the test function, run the test function, handle huntrleaks
-    # and findleaks to detect leaks
-
-    abstest = get_abs_module(ns, test_name)
-
-    # remove the module from sys.module to reload it if it was already imported
-    import_helper.unload(abstest)
-
-    the_module = importlib.import_module(abstest)
-
-    # If the test has a test_main, that will run the appropriate
-    # tests.  If not, use normal unittest test loading.
-    test_runner = getattr(the_module, "test_main", None)
-    if test_runner is None:
-        test_runner = functools.partial(_test_module, the_module)
-
-    try:
-        if ns.huntrleaks:
-            # Return True if the test leaked references
-            refleak = dash_R(ns, test_name, test_runner)
-        else:
-            test_runner()
-            refleak = False
-    finally:
-        cleanup_test_droppings(test_name, ns.verbose)
-
-    support.gc_collect()
-
-    # if gc.garbage:
-    #     support.environment_altered = True
-    #     print_warning(f"{test_name} created {len(gc.garbage)} "
-    #                   f"uncollectable object(s).")
-
-    #     # move the uncollectable objects somewhere,
-    #     # so we don't see them again
-    #     FOUND_GARBAGE.extend(gc.garbage)
-    #     gc.garbage.clear()
-
-    support.reap_children()
-
-    return refleak
-
-
-def _runtest_inner(ns, test_name, display_failure=True):
-    # Detect environment changes, handle exceptions.
-
-    # Reset the environment_altered flag to detect if a test altered
-    # the environment
-    support.environment_altered = False
-
-    if ns.pgo:
-        display_failure = False
-
-    try:
-        clear_caches()
-
-        # with saved_test_environment(test_name, ns.verbose, ns.quiet, pgo=ns.pgo) as environment:
-        refleak = _runtest_inner2(ns, test_name)
-    except support.ResourceDenied as msg:
-        if not ns.quiet and not ns.pgo:
-            print(f"{test_name} skipped -- {msg}", flush=True)
-        return RESOURCE_DENIED
-    except unittest.SkipTest as msg:
-        if not ns.quiet and not ns.pgo:
-            print(f"{test_name} skipped -- {msg}", flush=True)
-        return SKIPPED
-    except support.TestFailed as exc:
-        msg = f"test {test_name} failed"
-        if display_failure:
-            msg = f"{msg} -- {exc}"
-        print(msg, file=sys.stderr, flush=True)
-        return FAILED
-    except support.TestDidNotRun:
-        return TEST_DID_NOT_RUN
-    except KeyboardInterrupt:
-        print()
-        return INTERRUPTED
-    except:
-        if not ns.pgo:
-            msg = traceback.format_exc()
-            print(f"test {test_name} crashed -- {msg}",
-                  file=sys.stderr, flush=True)
-        return FAILED
-
-    if refleak:
-        return FAILED
-    # if environment.changed:
-    #     return ENV_CHANGED
-    return PASSED
-
-
-def cleanup_test_droppings(test_name, verbose):
-    # First kill any dangling references to open files etc.
-    # This can also issue some ResourceWarnings which would otherwise get
-    # triggered during the following test run, and possibly produce failures.
-    support.gc_collect()
-
-    # Try to clean up junk commonly left behind.  While tests shouldn't leave
-    # any files or directories behind, when a test fails that can be tedious
-    # for it to arrange.  The consequences can be especially nasty on Windows,
-    # since if a test leaves a file open, it cannot be deleted by name (while
-    # there's nothing we can do about that here either, we can display the
-    # name of the offending test, which is a real help).
-    for name in (os_helper.TESTFN,
-                 "db_home",
-                ):
-        if not os.path.exists(name):
-            continue
-
-        if os.path.isdir(name):
-            import shutil
-            kind, nuker = "directory", shutil.rmtree
-        elif os.path.isfile(name):
-            kind, nuker = "file", os.unlink
-        else:
-            raise RuntimeError(f"os.path says {name!r} exists but is neither "
-                               f"directory nor file")
-
-        if verbose:
-            print_warning("%r left behind %s %r" % (test_name, kind, name))
-            support.environment_altered = True
-
-        try:
-            import stat
-            # fix possible permissions problems that might prevent cleanup
-            os.chmod(name, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
-            nuker(name)
-        except Exception as exc:
-            print_warning(f"{test_name} left behind {kind} {name!r} "
-                          f"and it couldn't be removed: {exc}")
diff --git a/Lib/test/libregrtest/runtest_mp.py b/Lib/test/libregrtest/runtest_mp.py
deleted file mode 100644
index c2177d99955..00000000000
--- a/Lib/test/libregrtest/runtest_mp.py
+++ /dev/null
@@ -1,288 +0,0 @@
-import collections
-import faulthandler
-import json
-import os
-import queue
-import subprocess
-import sys
-import threading
-import time
-import traceback
-import types
-from test import support
-
-from test.libregrtest.runtest import (
-    runtest, INTERRUPTED, CHILD_ERROR, PROGRESS_MIN_TIME,
-    format_test_result, TestResult)
-from test.libregrtest.setup import setup_tests
-from test.libregrtest.utils import format_duration
-from test.support import os_helper
-
-
-# Display the running tests if nothing happened last N seconds
-PROGRESS_UPDATE = 30.0   # seconds
-
-
-def must_stop(result):
-    return result.result in (INTERRUPTED, CHILD_ERROR)
-
-
-def run_test_in_subprocess(testname, ns):
-    ns_dict = vars(ns)
-    worker_args = (ns_dict, testname)
-    worker_args = json.dumps(worker_args)
-
-    cmd = [sys.executable, *support.args_from_interpreter_flags(),
-           '-u',    # Unbuffered stdout and stderr
-           '-m', 'test.regrtest',
-           '--worker-args', worker_args]
-    if ns.pgo:
-        cmd += ['--pgo']
-
-    # Running the child from the same working directory as regrtest's original
-    # invocation ensures that TEMPDIR for the child is the same when
-    # sysconfig.is_python_build() is true. See issue 15300.
-    return subprocess.Popen(cmd,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                            universal_newlines=True,
-                            close_fds=(os.name != 'nt'),
-                            cwd=os_helper.SAVEDCWD)
-
-
-def run_tests_worker(worker_args):
-    ns_dict, testname = json.loads(worker_args)
-    ns = types.SimpleNamespace(**ns_dict)
-
-    setup_tests(ns)
-
-    result = runtest(ns, testname)
-    print()   # Force a newline (just in case)
-    print(json.dumps(result), flush=True)
-    sys.exit(0)
-
-
-# We do not use a generator so multiple threads can call next().
-class MultiprocessIterator:
-
-    """A thread-safe iterator over tests for multiprocess mode."""
-
-    def __init__(self, tests):
-        self.lock = threading.Lock()
-        self.tests = tests
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        with self.lock:
-            return next(self.tests)
-
-
-MultiprocessResult = collections.namedtuple('MultiprocessResult',
-    'result stdout stderr error_msg')
-
-class MultiprocessThread(threading.Thread):
-    def __init__(self, pending, output, ns):
-        super().__init__()
-        self.pending = pending
-        self.output = output
-        self.ns = ns
-        self.current_test_name = None
-        self.start_time = None
-        self._popen = None
-
-    def kill(self):
-        if not self.is_alive():
-            return
-        if self._popen is not None:
-            self._popen.kill()
-
-    def _runtest(self, test_name):
-        try:
-            self.start_time = time.monotonic()
-            self.current_test_name = test_name
-
-            popen = run_test_in_subprocess(test_name, self.ns)
-            self._popen = popen
-            with popen:
-                try:
-                    stdout, stderr = popen.communicate()
-                except:
-                    popen.kill()
-                    popen.wait()
-                    raise
-
-            retcode = popen.wait()
-        finally:
-            self.current_test_name = None
-            self._popen = None
-
-        stdout = stdout.strip()
-        stderr = stderr.rstrip()
-
-        err_msg = None
-        if retcode != 0:
-            err_msg = "Exit code %s" % retcode
-        else:
-            stdout, _, result = stdout.rpartition("\n")
-            stdout = stdout.rstrip()
-            if not result:
-                err_msg = "Failed to parse worker stdout"
-            else:
-                try:
-                    # deserialize run_tests_worker() output
-                    result = json.loads(result)
-                    result = TestResult(*result)
-                except Exception as exc:
-                    err_msg = "Failed to parse worker JSON: %s" % exc
-
-        if err_msg is not None:
-            test_time = time.monotonic() - self.start_time
-            result = TestResult(test_name, CHILD_ERROR, test_time, None)
-
-        return MultiprocessResult(result, stdout, stderr, err_msg)
-
-    def run(self):
-        while True:
-            try:
-                try:
-                    test_name = next(self.pending)
-                except StopIteration:
-                    break
-
-                mp_result = self._runtest(test_name)
-                self.output.put((False, mp_result))
-
-                if must_stop(mp_result.result):
-                    break
-            except BaseException:
-                self.output.put((True, traceback.format_exc()))
-                break
-
-
-def get_running(workers):
-    running = []
-    for worker in workers:
-        current_test_name = worker.current_test_name
-        if not current_test_name:
-            continue
-        dt = time.monotonic() - worker.start_time
-        if dt >= PROGRESS_MIN_TIME:
-            text = '%s (%s)' % (current_test_name, format_duration(dt))
-            running.append(text)
-    return running
-
-
-class MultiprocessRunner:
-    def __init__(self, regrtest):
-        self.regrtest = regrtest
-        self.ns = regrtest.ns
-        self.output = queue.Queue()
-        self.pending = MultiprocessIterator(self.regrtest.tests)
-        if self.ns.timeout is not None:
-            self.test_timeout = self.ns.timeout * 1.5
-        else:
-            self.test_timeout = None
-        self.workers = None
-
-    def start_workers(self):
-        self.workers = [MultiprocessThread(self.pending, self.output, self.ns)
-                        for _ in range(self.ns.use_mp)]
-        print("Run tests in parallel using %s child processes"
-              % len(self.workers))
-        for worker in self.workers:
-            worker.start()
-
-    def wait_workers(self):
-        for worker in self.workers:
-            worker.kill()
-        for worker in self.workers:
-            worker.join()
-
-    def _get_result(self):
-        if not any(worker.is_alive() for worker in self.workers):
-            # all worker threads are done: consume pending results
-            try:
-                return self.output.get(timeout=0)
-            except queue.Empty:
-                return None
-
-        while True:
-            if self.test_timeout is not None:
-                faulthandler.dump_traceback_later(self.test_timeout, exit=True)
-
-            # wait for a thread
-            timeout = max(PROGRESS_UPDATE, PROGRESS_MIN_TIME)
-            try:
-                return self.output.get(timeout=timeout)
-            except queue.Empty:
-                pass
-
-            # display progress
-            running = get_running(self.workers)
-            if running and not self.ns.pgo:
-                print('running: %s' % ', '.join(running), flush=True)
-
-    def display_result(self, mp_result):
-        result = mp_result.result
-
-        text = format_test_result(result)
-        if mp_result.error_msg is not None:
-            # CHILD_ERROR
-            text += ' (%s)' % mp_result.error_msg
-        elif (result.test_time >= PROGRESS_MIN_TIME and not self.ns.pgo):
-            text += ' (%s)' % format_duration(result.test_time)
-        running = get_running(self.workers)
-        if running and not self.ns.pgo:
-            text += ' -- running: %s' % ', '.join(running)
-        self.regrtest.display_progress(self.test_index, text)
-
-    def _process_result(self, item):
-        if item[0]:
-            # Thread got an exception
-            format_exc = item[1]
-            print(f"regrtest worker thread failed: {format_exc}",
-                  file=sys.stderr, flush=True)
-            return True
-
-        self.test_index += 1
-        mp_result = item[1]
-        self.regrtest.accumulate_result(mp_result.result)
-        self.display_result(mp_result)
-
-        if mp_result.stdout:
-            print(mp_result.stdout, flush=True)
-        if mp_result.stderr and not self.ns.pgo:
-            print(mp_result.stderr, file=sys.stderr, flush=True)
-
-        if must_stop(mp_result.result):
-            return True
-
-        return False
-
-    def run_tests(self):
-        self.start_workers()
-
-        self.test_index = 0
-        try:
-            while True:
-                item = self._get_result()
-                if item is None:
-                    break
-
-                stop = self._process_result(item)
-                if stop:
-                    break
-        except KeyboardInterrupt:
-            print()
-            self.regrtest.interrupted = True
-        finally:
-            if self.test_timeout is not None:
-                faulthandler.cancel_dump_traceback_later()
-
-        self.wait_workers()
-
-
-def run_tests_multiprocess(regrtest):
-    MultiprocessRunner(regrtest).run_tests()
diff --git a/Lib/test/libregrtest/runtests.py b/Lib/test/libregrtest/runtests.py
new file mode 100644
index 00000000000..7b607d4a559
--- /dev/null
+++ b/Lib/test/libregrtest/runtests.py
@@ -0,0 +1,222 @@
+import contextlib
+import dataclasses
+import json
+import os
+import shlex
+import subprocess
+import sys
+from typing import Any, Iterator
+
+from test import support
+
+from .utils import (
+    StrPath, StrJSON, TestTuple, TestName, TestFilter, FilterTuple, FilterDict)
+
+
+class JsonFileType:
+    UNIX_FD = "UNIX_FD"
+    WINDOWS_HANDLE = "WINDOWS_HANDLE"
+    STDOUT = "STDOUT"
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class JsonFile:
+    # file type depends on file_type:
+    # - UNIX_FD: file descriptor (int)
+    # - WINDOWS_HANDLE: handle (int)
+    # - STDOUT: use process stdout (None)
+    file: int | None
+    file_type: str
+
+    def configure_subprocess(self, popen_kwargs: dict[str, Any]) -> None:
+        match self.file_type:
+            case JsonFileType.UNIX_FD:
+                # Unix file descriptor
+                popen_kwargs['pass_fds'] = [self.file]
+            case JsonFileType.WINDOWS_HANDLE:
+                # Windows handle
+                # We run mypy with `--platform=linux` so it complains about this:
+                startupinfo = subprocess.STARTUPINFO()  # type: ignore[attr-defined]
+                startupinfo.lpAttributeList = {"handle_list": [self.file]}
+                popen_kwargs['startupinfo'] = startupinfo
+
+    @contextlib.contextmanager
+    def inherit_subprocess(self) -> Iterator[None]:
+        if sys.platform == 'win32' and self.file_type == JsonFileType.WINDOWS_HANDLE:
+            os.set_handle_inheritable(self.file, True)
+            try:
+                yield
+            finally:
+                os.set_handle_inheritable(self.file, False)
+        else:
+            yield
+
+    def open(self, mode='r', *, encoding):
+        if self.file_type == JsonFileType.STDOUT:
+            raise ValueError("for STDOUT file type, just use sys.stdout")
+
+        file = self.file
+        if self.file_type == JsonFileType.WINDOWS_HANDLE:
+            import msvcrt
+            # Create a file descriptor from the handle
+            file = msvcrt.open_osfhandle(file, os.O_WRONLY)
+        return open(file, mode, encoding=encoding)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class HuntRefleak:
+    warmups: int
+    runs: int
+    filename: StrPath
+
+    def bisect_cmd_args(self) -> list[str]:
+        # Ignore filename since it can contain colon (":"),
+        # and usually it's not used. Use the default filename.
+        return ["-R", f"{self.warmups}:{self.runs}:"]
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class RunTests:
+    tests: TestTuple
+    fail_fast: bool
+    fail_env_changed: bool
+    match_tests: TestFilter
+    match_tests_dict: FilterDict | None
+    rerun: bool
+    forever: bool
+    pgo: bool
+    pgo_extended: bool
+    output_on_failure: bool
+    timeout: float | None
+    verbose: int
+    quiet: bool
+    hunt_refleak: HuntRefleak | None
+    test_dir: StrPath | None
+    use_junit: bool
+    coverage: bool
+    memory_limit: str | None
+    gc_threshold: int | None
+    use_resources: tuple[str, ...]
+    python_cmd: tuple[str, ...] | None
+    randomize: bool
+    random_seed: int | str
+
+    def copy(self, **override) -> 'RunTests':
+        state = dataclasses.asdict(self)
+        state.update(override)
+        return RunTests(**state)
+
+    def create_worker_runtests(self, **override) -> 'WorkerRunTests':
+        state = dataclasses.asdict(self)
+        state.update(override)
+        return WorkerRunTests(**state)
+
+    def get_match_tests(self, test_name: TestName) -> FilterTuple | None:
+        if self.match_tests_dict is not None:
+            return self.match_tests_dict.get(test_name, None)
+        else:
+            return None
+
+    def get_jobs(self) -> int | None:
+        # Number of run_single_test() calls needed to run all tests.
+        # None means that there is not bound limit (--forever option).
+        if self.forever:
+            return None
+        return len(self.tests)
+
+    def iter_tests(self) -> Iterator[TestName]:
+        if self.forever:
+            while True:
+                yield from self.tests
+        else:
+            yield from self.tests
+
+    def json_file_use_stdout(self) -> bool:
+        # Use STDOUT in two cases:
+        #
+        # - If --python command line option is used;
+        # - On Emscripten and WASI.
+        #
+        # On other platforms, UNIX_FD or WINDOWS_HANDLE can be used.
+        return (
+            bool(self.python_cmd)
+            or support.is_emscripten
+            or support.is_wasi
+        )
+
+    def create_python_cmd(self) -> list[str]:
+        python_opts = support.args_from_interpreter_flags()
+        if self.python_cmd is not None:
+            executable = self.python_cmd
+            # Remove -E option, since --python=COMMAND can set PYTHON
+            # environment variables, such as PYTHONPATH, in the worker
+            # process.
+            python_opts = [opt for opt in python_opts if opt != "-E"]
+        else:
+            executable = (sys.executable,)
+        cmd = [*executable, *python_opts]
+        if '-u' not in python_opts:
+            cmd.append('-u')  # Unbuffered stdout and stderr
+        if self.coverage:
+            cmd.append("-Xpresite=test.cov")
+        return cmd
+
+    def bisect_cmd_args(self) -> list[str]:
+        args = []
+        if self.fail_fast:
+            args.append("--failfast")
+        if self.fail_env_changed:
+            args.append("--fail-env-changed")
+        if self.timeout:
+            args.append(f"--timeout={self.timeout}")
+        if self.hunt_refleak is not None:
+            args.extend(self.hunt_refleak.bisect_cmd_args())
+        if self.test_dir:
+            args.extend(("--testdir", self.test_dir))
+        if self.memory_limit:
+            args.extend(("--memlimit", self.memory_limit))
+        if self.gc_threshold:
+            args.append(f"--threshold={self.gc_threshold}")
+        if self.use_resources:
+            args.extend(("-u", ','.join(self.use_resources)))
+        if self.python_cmd:
+            cmd = shlex.join(self.python_cmd)
+            args.extend(("--python", cmd))
+        if self.randomize:
+            args.append(f"--randomize")
+        args.append(f"--randseed={self.random_seed}")
+        return args
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class WorkerRunTests(RunTests):
+    json_file: JsonFile
+
+    def as_json(self) -> StrJSON:
+        return json.dumps(self, cls=_EncodeRunTests)
+
+    @staticmethod
+    def from_json(worker_json: StrJSON) -> 'WorkerRunTests':
+        return json.loads(worker_json, object_hook=_decode_runtests)
+
+
+class _EncodeRunTests(json.JSONEncoder):
+    def default(self, o: Any) -> dict[str, Any]:
+        if isinstance(o, WorkerRunTests):
+            result = dataclasses.asdict(o)
+            result["__runtests__"] = True
+            return result
+        else:
+            return super().default(o)
+
+
+def _decode_runtests(data: dict[str, Any]) -> RunTests | dict[str, Any]:
+    if "__runtests__" in data:
+        data.pop('__runtests__')
+        if data['hunt_refleak']:
+            data['hunt_refleak'] = HuntRefleak(**data['hunt_refleak'])
+        if data['json_file']:
+            data['json_file'] = JsonFile(**data['json_file'])
+        return WorkerRunTests(**data)
+    else:
+        return data
diff --git a/Lib/test/libregrtest/save_env.py b/Lib/test/libregrtest/save_env.py
index b9a1c0b3926..02492124a61 100644
--- a/Lib/test/libregrtest/save_env.py
+++ b/Lib/test/libregrtest/save_env.py
@@ -1,20 +1,24 @@
-import asyncio
 import builtins
 import locale
-import logging
 import os
-import shutil
 import sys
-import sysconfig
 import threading
-import warnings
+
 from test import support
 from test.support import os_helper
-from test.libregrtest.utils import print_warning
+
+from .utils import print_warning
+
+# Import termios to save and restore terminal echo.  This is only available on
+# Unix, and it's fine if the module can't be found.
 try:
-    import _multiprocessing, multiprocessing.process
-except ImportError:
-    multiprocessing = None
+    import termios                                # noqa: F401
+except ModuleNotFoundError:
+    pass
+
+
+class SkipTestEnvironment(Exception):
+    pass
 
 
 # Unit tests are supposed to leave the execution environment unchanged
@@ -28,21 +32,19 @@
 class saved_test_environment:
     """Save bits of the test environment and restore them at block exit.
 
-        with saved_test_environment(testname, verbose, quiet):
+        with saved_test_environment(test_name, verbose, quiet):
             #stuff
 
     Unless quiet is True, a warning is printed to stderr if any of
-    the saved items was changed by the test.  The attribute 'changed'
-    is initially False, but is set to True if a change is detected.
+    the saved items was changed by the test. The support.environment_altered
+    attribute is set to True if a change is detected.
 
     If verbose is more than 1, the before and after state of changed
     items is also printed.
     """
 
-    changed = False
-
-    def __init__(self, testname, verbose=0, quiet=False, *, pgo=False):
-        self.testname = testname
+    def __init__(self, test_name, verbose, quiet, *, pgo):
+        self.test_name = test_name
         self.verbose = verbose
         self.quiet = quiet
         self.pgo = pgo
@@ -69,11 +71,40 @@ def __init__(self, testname, verbose=0, quiet=False, *, pgo=False):
                  'files', 'locale', 'warnings.showwarning',
                  'shutil_archive_formats', 'shutil_unpack_formats',
                  'asyncio.events._event_loop_policy',
+                 'urllib.requests._url_tempfiles', 'urllib.requests._opener',
+                 'stty_echo',
                 )
 
+    def get_module(self, name):
+        # function for restore() methods
+        return sys.modules[name]
+
+    def try_get_module(self, name):
+        # function for get() methods
+        try:
+            return self.get_module(name)
+        except KeyError:
+            raise SkipTestEnvironment
+
+    def get_urllib_requests__url_tempfiles(self):
+        urllib_request = self.try_get_module('urllib.request')
+        return list(urllib_request._url_tempfiles)
+    def restore_urllib_requests__url_tempfiles(self, tempfiles):
+        for filename in tempfiles:
+            os_helper.unlink(filename)
+
+    def get_urllib_requests__opener(self):
+        urllib_request = self.try_get_module('urllib.request')
+        return urllib_request._opener
+    def restore_urllib_requests__opener(self, opener):
+        urllib_request = self.get_module('urllib.request')
+        urllib_request._opener = opener
+
     def get_asyncio_events__event_loop_policy(self):
+        self.try_get_module('asyncio')
         return support.maybe_get_event_loop_policy()
     def restore_asyncio_events__event_loop_policy(self, policy):
+        asyncio = self.get_module('asyncio')
         asyncio.set_event_loop_policy(policy)
 
     def get_sys_argv(self):
@@ -132,39 +163,46 @@ def restore___import__(self, import_):
         builtins.__import__ = import_
 
     def get_warnings_filters(self):
+        warnings = self.try_get_module('warnings')
         return id(warnings.filters), warnings.filters, warnings.filters[:]
     def restore_warnings_filters(self, saved_filters):
+        warnings = self.get_module('warnings')
         warnings.filters = saved_filters[1]
         warnings.filters[:] = saved_filters[2]
 
     def get_asyncore_socket_map(self):
-        asyncore = sys.modules.get('asyncore')
+        asyncore = sys.modules.get('test.support.asyncore')
         # XXX Making a copy keeps objects alive until __exit__ gets called.
         return asyncore and asyncore.socket_map.copy() or {}
     def restore_asyncore_socket_map(self, saved_map):
-        asyncore = sys.modules.get('asyncore')
+        asyncore = sys.modules.get('test.support.asyncore')
         if asyncore is not None:
             asyncore.close_all(ignore_all=True)
             asyncore.socket_map.update(saved_map)
 
     def get_shutil_archive_formats(self):
+        shutil = self.try_get_module('shutil')
         # we could call get_archives_formats() but that only returns the
         # registry keys; we want to check the values too (the functions that
         # are registered)
         return shutil._ARCHIVE_FORMATS, shutil._ARCHIVE_FORMATS.copy()
     def restore_shutil_archive_formats(self, saved):
+        shutil = self.get_module('shutil')
         shutil._ARCHIVE_FORMATS = saved[0]
         shutil._ARCHIVE_FORMATS.clear()
         shutil._ARCHIVE_FORMATS.update(saved[1])
 
     def get_shutil_unpack_formats(self):
+        shutil = self.try_get_module('shutil')
         return shutil._UNPACK_FORMATS, shutil._UNPACK_FORMATS.copy()
     def restore_shutil_unpack_formats(self, saved):
+        shutil = self.get_module('shutil')
         shutil._UNPACK_FORMATS = saved[0]
         shutil._UNPACK_FORMATS.clear()
         shutil._UNPACK_FORMATS.update(saved[1])
 
     def get_logging__handlers(self):
+        logging = self.try_get_module('logging')
         # _handlers is a WeakValueDictionary
         return id(logging._handlers), logging._handlers, logging._handlers.copy()
     def restore_logging__handlers(self, saved_handlers):
@@ -172,6 +210,7 @@ def restore_logging__handlers(self, saved_handlers):
         pass
 
     def get_logging__handlerList(self):
+        logging = self.try_get_module('logging')
         # _handlerList is a list of weakrefs to handlers
         return id(logging._handlerList), logging._handlerList, logging._handlerList[:]
     def restore_logging__handlerList(self, saved_handlerList):
@@ -195,39 +234,43 @@ def restore_threading__dangling(self, saved):
 
     # Same for Process objects
     def get_multiprocessing_process__dangling(self):
-        if not multiprocessing:
-            return None
+        multiprocessing_process = self.try_get_module('multiprocessing.process')
         # Unjoined process objects can survive after process exits
-        multiprocessing.process._cleanup()
+        multiprocessing_process._cleanup()
         # This copies the weakrefs without making any strong reference
-        return multiprocessing.process._dangling.copy()
+        return multiprocessing_process._dangling.copy()
     def restore_multiprocessing_process__dangling(self, saved):
-        if not multiprocessing:
-            return
-        multiprocessing.process._dangling.clear()
-        multiprocessing.process._dangling.update(saved)
+        multiprocessing_process = self.get_module('multiprocessing.process')
+        multiprocessing_process._dangling.clear()
+        multiprocessing_process._dangling.update(saved)
 
     def get_sysconfig__CONFIG_VARS(self):
         # make sure the dict is initialized
+        sysconfig = self.try_get_module('sysconfig')
         sysconfig.get_config_var('prefix')
         return (id(sysconfig._CONFIG_VARS), sysconfig._CONFIG_VARS,
                 dict(sysconfig._CONFIG_VARS))
     def restore_sysconfig__CONFIG_VARS(self, saved):
+        sysconfig = self.get_module('sysconfig')
         sysconfig._CONFIG_VARS = saved[1]
         sysconfig._CONFIG_VARS.clear()
         sysconfig._CONFIG_VARS.update(saved[2])
 
     def get_sysconfig__INSTALL_SCHEMES(self):
+        sysconfig = self.try_get_module('sysconfig')
         return (id(sysconfig._INSTALL_SCHEMES), sysconfig._INSTALL_SCHEMES,
                 sysconfig._INSTALL_SCHEMES.copy())
     def restore_sysconfig__INSTALL_SCHEMES(self, saved):
+        sysconfig = self.get_module('sysconfig')
         sysconfig._INSTALL_SCHEMES = saved[1]
         sysconfig._INSTALL_SCHEMES.clear()
         sysconfig._INSTALL_SCHEMES.update(saved[2])
 
     def get_files(self):
+        # XXX: Maybe add an allow-list here?
         return sorted(fn + ('/' if os.path.isdir(fn) else '')
-                      for fn in os.listdir())
+                      for fn in os.listdir()
+                      if not fn.startswith(".hypothesis"))
     def restore_files(self, saved_value):
         fn = os_helper.TESTFN
         if fn not in saved_value and (fn + '/') not in saved_value:
@@ -251,10 +294,30 @@ def restore_locale(self, saved):
             locale.setlocale(lc, setting)
 
     def get_warnings_showwarning(self):
+        warnings = self.try_get_module('warnings')
         return warnings.showwarning
     def restore_warnings_showwarning(self, fxn):
+        warnings = self.get_module('warnings')
         warnings.showwarning = fxn
 
+    def get_stty_echo(self):
+        termios = self.try_get_module('termios')
+        if not os.isatty(fd := sys.__stdin__.fileno()):
+            return None
+        attrs = termios.tcgetattr(fd)
+        lflags = attrs[3]
+        return bool(lflags & termios.ECHO)
+    def restore_stty_echo(self, echo):
+        termios = self.get_module('termios')
+        attrs = termios.tcgetattr(fd := sys.__stdin__.fileno())
+        if echo:
+            # Turn echo on.
+            attrs[3] |= termios.ECHO
+        else:
+            # Turn echo off.
+            attrs[3] &= ~termios.ECHO
+        termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+
     def resource_info(self):
         for name in self.resources:
             method_suffix = name.replace('.', '_')
@@ -263,29 +326,32 @@ def resource_info(self):
             yield name, getattr(self, get_name), getattr(self, restore_name)
 
     def __enter__(self):
-        self.saved_values = dict((name, get()) for name, get, restore
-                                                   in self.resource_info())
+        self.saved_values = []
+        for name, get, restore in self.resource_info():
+            try:
+                original = get()
+            except SkipTestEnvironment:
+                continue
+
+            self.saved_values.append((name, get, restore, original))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         saved_values = self.saved_values
-        del self.saved_values
+        self.saved_values = None
 
         # Some resources use weak references
         support.gc_collect()
 
-        # Read support.environment_altered, set by support helper functions
-        self.changed |= support.environment_altered
-
-        for name, get, restore in self.resource_info():
+        for name, get, restore, original in saved_values:
             current = get()
-            original = saved_values.pop(name)
             # Check for changes to the resource's value
             if current != original:
-                self.changed = True
+                support.environment_altered = True
                 restore(original)
                 if not self.quiet and not self.pgo:
-                    print_warning(f"{name} was modified by {self.testname}")
-                    print(f"  Before: {original}\n  After:  {current} ",
-                          file=sys.stderr, flush=True)
+                    print_warning(
+                        f"{name} was modified by {self.test_name}\n"
+                        f"  Before: {original}\n"
+                        f"  After:  {current} ")
         return False
diff --git a/Lib/test/libregrtest/setup.py b/Lib/test/libregrtest/setup.py
index b1a5ded5254..d50b2155a6b 100644
--- a/Lib/test/libregrtest/setup.py
+++ b/Lib/test/libregrtest/setup.py
@@ -1,17 +1,36 @@
-import atexit
 import faulthandler
+import gc
+import io
 import os
+import random
 import signal
 import sys
 import unittest
 from test import support
-try:
-    import gc
-except ImportError:
-    gc = None
+from test.support.os_helper import TESTFN_UNDECODABLE, FS_NONASCII
+from _colorize import can_colorize  # type: ignore[import-not-found]
 
+from .filter import set_match_tests
+from .runtests import RunTests
+from .utils import (
+    setup_unraisable_hook, setup_threading_excepthook, fix_umask,
+    adjust_rlimit_nofile)
 
-def setup_tests(ns):
+
+UNICODE_GUARD_ENV = "PYTHONREGRTEST_UNICODE_GUARD"
+
+
+def setup_test_dir(testdir: str | None) -> None:
+    if testdir:
+        # Prepend test directory to sys.path, so runtest() will be able
+        # to locate tests
+        sys.path.insert(0, os.path.abspath(testdir))
+
+
+def setup_process() -> None:
+    fix_umask()
+
+    assert sys.__stderr__ is not None, "sys.__stderr__ is None"
     try:
         stderr_fd = sys.__stderr__.fileno()
     except (ValueError, AttributeError):
@@ -19,13 +38,13 @@ def setup_tests(ns):
         # and ValueError on a closed stream.
         #
         # Catch AttributeError for stderr being None.
-        stderr_fd = None
+        pass
     else:
         # Display the Python traceback on fatal errors (e.g. segfault)
         faulthandler.enable(all_threads=True, file=stderr_fd)
 
         # Display the Python traceback on SIGALRM or SIGUSR1 signal
-        signals = []
+        signals: list[signal.Signals] = []
         if hasattr(signal, 'SIGALRM'):
             signals.append(signal.SIGALRM)
         if hasattr(signal, 'SIGUSR1'):
@@ -33,13 +52,17 @@ def setup_tests(ns):
         for signum in signals:
             faulthandler.register(signum, chain=True, file=stderr_fd)
 
-    # replace_stdout()
-    # support.record_original_stdout(sys.stdout)
+    adjust_rlimit_nofile()
 
-    if ns.testdir:
-        # Prepend test directory to sys.path, so runtest() will be able
-        # to locate tests
-        sys.path.insert(0, os.path.abspath(ns.testdir))
+    support.record_original_stdout(sys.stdout)
+
+    # Set sys.stdout encoder error handler to backslashreplace,
+    # similar to sys.stderr error handler, to avoid UnicodeEncodeError
+    # when printing a traceback or any other non-encodable character.
+    #
+    # Use an assertion to fix mypy error.
+    assert isinstance(sys.stdout, io.TextIOWrapper)
+    sys.stdout.reconfigure(errors="backslashreplace")
 
     # Some times __path__ and __file__ are not absolute (e.g. while running from
     # Lib/) and, if we change the CWD to run the tests in a temporary dir, some
@@ -56,79 +79,73 @@ def setup_tests(ns):
             for index, path in enumerate(module.__path__):
                 module.__path__[index] = os.path.abspath(path)
         if getattr(module, '__file__', None):
-            module.__file__ = os.path.abspath(module.__file__)
-
-    # MacOSX (a.k.a. Darwin) has a default stack size that is too small
-    # for deeply recursive regular expressions.  We see this as crashes in
-    # the Python test suite when running test_re.py and test_sre.py.  The
-    # fix is to set the stack limit to 2048.
-    # This approach may also be useful for other Unixy platforms that
-    # suffer from small default stack limits.
-    if sys.platform == 'darwin':
-        try:
-            import resource
-        except ImportError:
+            module.__file__ = os.path.abspath(module.__file__)  # type: ignore[type-var]
+
+    if hasattr(sys, 'addaudithook'):
+        # Add an auditing hook for all tests to ensure PySys_Audit is tested
+        def _test_audit_hook(name, args):
             pass
-        else:
-            soft, hard = resource.getrlimit(resource.RLIMIT_STACK)
-            newsoft = min(hard, max(soft, 1024*2048))
-            resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard))
+        sys.addaudithook(_test_audit_hook)
 
-    if ns.huntrleaks:
-        unittest.BaseTestSuite._cleanup = False
+    setup_unraisable_hook()
+    setup_threading_excepthook()
 
-    if ns.memlimit is not None:
-        support.set_memlimit(ns.memlimit)
+    # Ensure there's a non-ASCII character in env vars at all times to force
+    # tests consider this case. See BPO-44647 for details.
+    if TESTFN_UNDECODABLE and os.supports_bytes_environ:
+        os.environb.setdefault(UNICODE_GUARD_ENV.encode(), TESTFN_UNDECODABLE)
+    elif FS_NONASCII:
+        os.environ.setdefault(UNICODE_GUARD_ENV, FS_NONASCII)
 
-    if ns.threshold is not None:
-        gc.set_threshold(ns.threshold)
 
-    try:
-        import msvcrt
-    except ImportError:
-        pass
+def setup_tests(runtests: RunTests) -> None:
+    support.verbose = runtests.verbose
+    support.failfast = runtests.fail_fast
+    support.PGO = runtests.pgo
+    support.PGO_EXTENDED = runtests.pgo_extended
+
+    set_match_tests(runtests.match_tests)
+
+    if runtests.use_junit:
+        support.junit_xml_list = []
+        from .testresult import RegressionTestResult
+        RegressionTestResult.USE_XML = True
     else:
-        msvcrt.SetErrorMode(msvcrt.SEM_FAILCRITICALERRORS|
-                            msvcrt.SEM_NOALIGNMENTFAULTEXCEPT|
-                            msvcrt.SEM_NOGPFAULTERRORBOX|
-                            msvcrt.SEM_NOOPENFILEERRORBOX)
-        try:
-            msvcrt.CrtSetReportMode
-        except AttributeError:
-            # release build
-            pass
-        else:
-            for m in [msvcrt.CRT_WARN, msvcrt.CRT_ERROR, msvcrt.CRT_ASSERT]:
-                if ns.verbose and ns.verbose >= 2:
-                    msvcrt.CrtSetReportMode(m, msvcrt.CRTDBG_MODE_FILE)
-                    msvcrt.CrtSetReportFile(m, msvcrt.CRTDBG_FILE_STDERR)
-                else:
-                    msvcrt.CrtSetReportMode(m, 0)
+        support.junit_xml_list = None
 
-    support.use_resources = ns.use_resources
+    if runtests.memory_limit is not None:
+        support.set_memlimit(runtests.memory_limit)
 
+    support.suppress_msvcrt_asserts(runtests.verbose >= 2)
 
-def replace_stdout():
-    """Set stdout encoder error handler to backslashreplace (as stderr error
-    handler) to avoid UnicodeEncodeError when printing a traceback"""
-    stdout = sys.stdout
-    try:
-        fd = stdout.fileno()
-    except ValueError:
-        # On IDLE, sys.stdout has no file descriptor and is not a TextIOWrapper
-        # object. Leaving sys.stdout unchanged.
-        #
-        # Catch ValueError to catch io.UnsupportedOperation on TextIOBase
-        # and ValueError on a closed stream.
-        return
-
-    sys.stdout = open(fd, 'w',
-        encoding=stdout.encoding,
-        errors="backslashreplace",
-        closefd=False,
-        newline='\n')
-
-    def restore_stdout():
-        sys.stdout.close()
-        sys.stdout = stdout
-    atexit.register(restore_stdout)
+    support.use_resources = runtests.use_resources
+
+    timeout = runtests.timeout
+    if timeout is not None:
+        # For a slow buildbot worker, increase SHORT_TIMEOUT and LONG_TIMEOUT
+        support.LOOPBACK_TIMEOUT = max(support.LOOPBACK_TIMEOUT, timeout / 120)
+        # don't increase INTERNET_TIMEOUT
+        support.SHORT_TIMEOUT = max(support.SHORT_TIMEOUT, timeout / 40)
+        support.LONG_TIMEOUT = max(support.LONG_TIMEOUT, timeout / 4)
+
+        # If --timeout is short: reduce timeouts
+        support.LOOPBACK_TIMEOUT = min(support.LOOPBACK_TIMEOUT, timeout)
+        support.INTERNET_TIMEOUT = min(support.INTERNET_TIMEOUT, timeout)
+        support.SHORT_TIMEOUT = min(support.SHORT_TIMEOUT, timeout)
+        support.LONG_TIMEOUT = min(support.LONG_TIMEOUT, timeout)
+
+    if runtests.hunt_refleak:
+        # private attribute that mypy doesn't know about:
+        unittest.BaseTestSuite._cleanup = False  # type: ignore[attr-defined]
+
+    if runtests.gc_threshold is not None:
+        gc.set_threshold(runtests.gc_threshold)
+
+    random.seed(runtests.random_seed)
+
+    # sys.stdout is redirected to a StringIO in single process mode on which
+    # color auto-detect fails as StringIO is not a TTY. If the original
+    # sys.stdout supports color pass that through with FORCE_COLOR so that when
+    # results are printed, such as with -W, they get color.
+    if can_colorize(file=sys.stdout):
+        os.environ['FORCE_COLOR'] = "1"
diff --git a/Lib/test/libregrtest/single.py b/Lib/test/libregrtest/single.py
new file mode 100644
index 00000000000..8fc852f86b4
--- /dev/null
+++ b/Lib/test/libregrtest/single.py
@@ -0,0 +1,322 @@
+import faulthandler
+import gc
+import importlib
+import io
+import sys
+import time
+import traceback
+import unittest
+
+from test import support
+from test.support import threading_helper
+
+from .filter import match_test
+from .result import State, TestResult, TestStats
+from .runtests import RunTests
+from .save_env import saved_test_environment
+from .setup import setup_tests
+from .testresult import get_test_runner
+from .utils import (
+    TestName,
+    clear_caches, remove_testfn, abs_module_name, print_warning)
+
+
+# Minimum duration of a test to display its duration or to mention that
+# the test is running in background
+PROGRESS_MIN_TIME = 30.0   # seconds
+
+
+def run_unittest(test_mod):
+    loader = unittest.TestLoader()
+    tests = loader.loadTestsFromModule(test_mod)
+    for error in loader.errors:
+        print(error, file=sys.stderr)
+    if loader.errors:
+        raise Exception("errors while loading tests")
+    _filter_suite(tests, match_test)
+    return _run_suite(tests)
+
+def _filter_suite(suite, pred):
+    """Recursively filter test cases in a suite based on a predicate."""
+    newtests = []
+    for test in suite._tests:
+        if isinstance(test, unittest.TestSuite):
+            _filter_suite(test, pred)
+            newtests.append(test)
+        else:
+            if pred(test):
+                newtests.append(test)
+    suite._tests = newtests
+
+def _run_suite(suite):
+    """Run tests from a unittest.TestSuite-derived class."""
+    runner = get_test_runner(sys.stdout,
+                             verbosity=support.verbose,
+                             capture_output=(support.junit_xml_list is not None))
+
+    result = runner.run(suite)
+
+    if support.junit_xml_list is not None:
+        import xml.etree.ElementTree as ET
+        xml_elem = result.get_xml_element()
+        xml_str = ET.tostring(xml_elem).decode('ascii')
+        support.junit_xml_list.append(xml_str)
+
+    if not result.testsRun and not result.skipped and not result.errors:
+        raise support.TestDidNotRun
+    if not result.wasSuccessful():
+        stats = TestStats.from_unittest(result)
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            err = "multiple errors occurred"
+            if not support.verbose: err += "; run in verbose mode for details"
+        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
+        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
+        raise support.TestFailedWithDetails(err, errors, failures, stats=stats)
+    return result
+
+
+def regrtest_runner(result: TestResult, test_func, runtests: RunTests) -> None:
+    # Run test_func(), collect statistics, and detect reference and memory
+    # leaks.
+    if runtests.hunt_refleak:
+        from .refleak import runtest_refleak
+        refleak, test_result = runtest_refleak(result.test_name, test_func,
+                                               runtests.hunt_refleak,
+                                               runtests.quiet)
+    else:
+        test_result = test_func()
+        refleak = False
+
+    if refleak:
+        result.state = State.REFLEAK
+
+    stats: TestStats | None
+
+    match test_result:
+        case TestStats():
+            stats = test_result
+        case unittest.TestResult():
+            stats = TestStats.from_unittest(test_result)
+        case None:
+            print_warning(f"{result.test_name} test runner returned None: {test_func}")
+            stats = None
+        case _:
+            # Don't import doctest at top level since only few tests return
+            # a doctest.TestResult instance.
+            import doctest
+            if isinstance(test_result, doctest.TestResults):
+                stats = TestStats.from_doctest(test_result)
+            else:
+                print_warning(f"Unknown test result type: {type(test_result)}")
+                stats = None
+
+    result.stats = stats
+
+
+# Storage of uncollectable GC objects (gc.garbage)
+GC_GARBAGE = []
+
+
+def _load_run_test(result: TestResult, runtests: RunTests) -> None:
+    # Load the test module and run the tests.
+    test_name = result.test_name
+    module_name = abs_module_name(test_name, runtests.test_dir)
+    test_mod = importlib.import_module(module_name)
+
+    if hasattr(test_mod, "test_main"):
+        # https://github.com/python/cpython/issues/89392
+        raise Exception(f"Module {test_name} defines test_main() which "
+                        f"is no longer supported by regrtest")
+    def test_func():
+        return run_unittest(test_mod)
+
+    try:
+        regrtest_runner(result, test_func, runtests)
+    finally:
+        # First kill any dangling references to open files etc.
+        # This can also issue some ResourceWarnings which would otherwise get
+        # triggered during the following test run, and possibly produce
+        # failures.
+        support.gc_collect()
+
+        remove_testfn(test_name, runtests.verbose)
+
+    if gc.garbage:
+        support.environment_altered = True
+        print_warning(f"{test_name} created {len(gc.garbage)} "
+                      f"uncollectable object(s)")
+
+        # move the uncollectable objects somewhere,
+        # so we don't see them again
+        GC_GARBAGE.extend(gc.garbage)
+        gc.garbage.clear()
+
+    support.reap_children()
+
+
+def _runtest_env_changed_exc(result: TestResult, runtests: RunTests,
+                             display_failure: bool = True) -> None:
+    # Handle exceptions, detect environment changes.
+
+    # Reset the environment_altered flag to detect if a test altered
+    # the environment
+    support.environment_altered = False
+
+    pgo = runtests.pgo
+    if pgo:
+        display_failure = False
+    quiet = runtests.quiet
+
+    test_name = result.test_name
+    try:
+        clear_caches()
+        support.gc_collect()
+
+        with saved_test_environment(test_name,
+                                    runtests.verbose, quiet, pgo=pgo):
+            _load_run_test(result, runtests)
+    except support.ResourceDenied as exc:
+        if not quiet and not pgo:
+            print(f"{test_name} skipped -- {exc}", flush=True)
+        result.state = State.RESOURCE_DENIED
+        return
+    except unittest.SkipTest as exc:
+        if not quiet and not pgo:
+            print(f"{test_name} skipped -- {exc}", flush=True)
+        result.state = State.SKIPPED
+        return
+    except support.TestFailedWithDetails as exc:
+        msg = f"test {test_name} failed"
+        if display_failure:
+            msg = f"{msg} -- {exc}"
+        print(msg, file=sys.stderr, flush=True)
+        result.state = State.FAILED
+        result.errors = exc.errors
+        result.failures = exc.failures
+        result.stats = exc.stats
+        return
+    except support.TestFailed as exc:
+        msg = f"test {test_name} failed"
+        if display_failure:
+            msg = f"{msg} -- {exc}"
+        print(msg, file=sys.stderr, flush=True)
+        result.state = State.FAILED
+        result.stats = exc.stats
+        return
+    except support.TestDidNotRun:
+        result.state = State.DID_NOT_RUN
+        return
+    except KeyboardInterrupt:
+        print()
+        result.state = State.INTERRUPTED
+        return
+    except:
+        if not pgo:
+            msg = traceback.format_exc()
+            print(f"test {test_name} crashed -- {msg}",
+                  file=sys.stderr, flush=True)
+        result.state = State.UNCAUGHT_EXC
+        return
+
+    if support.environment_altered:
+        result.set_env_changed()
+    # Don't override the state if it was already set (REFLEAK or ENV_CHANGED)
+    if result.state is None:
+        result.state = State.PASSED
+
+
+def _runtest(result: TestResult, runtests: RunTests) -> None:
+    # Capture stdout and stderr, set faulthandler timeout,
+    # and create JUnit XML report.
+    verbose = runtests.verbose
+    output_on_failure = runtests.output_on_failure
+    timeout = runtests.timeout
+
+    if timeout is not None and threading_helper.can_start_thread:
+        use_timeout = True
+        faulthandler.dump_traceback_later(timeout, exit=True)
+    else:
+        use_timeout = False
+
+    try:
+        setup_tests(runtests)
+
+        if output_on_failure or runtests.pgo:
+            support.verbose = True
+
+            stream = io.StringIO()
+            orig_stdout = sys.stdout
+            orig_stderr = sys.stderr
+            print_warning = support.print_warning
+            orig_print_warnings_stderr = print_warning.orig_stderr
+
+            output = None
+            try:
+                sys.stdout = stream
+                sys.stderr = stream
+                # print_warning() writes into the temporary stream to preserve
+                # messages order. If support.environment_altered becomes true,
+                # warnings will be written to sys.stderr below.
+                print_warning.orig_stderr = stream
+
+                _runtest_env_changed_exc(result, runtests, display_failure=False)
+                # Ignore output if the test passed successfully
+                if result.state != State.PASSED:
+                    output = stream.getvalue()
+            finally:
+                sys.stdout = orig_stdout
+                sys.stderr = orig_stderr
+                print_warning.orig_stderr = orig_print_warnings_stderr
+
+            if output is not None:
+                sys.stderr.write(output)
+                sys.stderr.flush()
+        else:
+            # Tell tests to be moderately quiet
+            support.verbose = verbose
+            _runtest_env_changed_exc(result, runtests,
+                                     display_failure=not verbose)
+
+        xml_list = support.junit_xml_list
+        if xml_list:
+            result.xml_data = xml_list
+    finally:
+        if use_timeout:
+            faulthandler.cancel_dump_traceback_later()
+        support.junit_xml_list = None
+
+
+def run_single_test(test_name: TestName, runtests: RunTests) -> TestResult:
+    """Run a single test.
+
+    test_name -- the name of the test
+
+    Returns a TestResult.
+
+    If runtests.use_junit, xml_data is a list containing each generated
+    testsuite element.
+    """
+    start_time = time.perf_counter()
+    result = TestResult(test_name)
+    pgo = runtests.pgo
+    try:
+        # gh-117783: don't immortalize deferred objects when tracking
+        # refleaks. Only releveant for the free-threaded build.
+        with support.suppress_immortalization(runtests.hunt_refleak):
+            _runtest(result, runtests)
+    except:
+        if not pgo:
+            msg = traceback.format_exc()
+            print(f"test {test_name} crashed -- {msg}",
+                  file=sys.stderr, flush=True)
+        result.state = State.UNCAUGHT_EXC
+
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    result.duration = time.perf_counter() - start_time
+    return result
diff --git a/Lib/test/libregrtest/testresult.py b/Lib/test/libregrtest/testresult.py
new file mode 100644
index 00000000000..1820f354572
--- /dev/null
+++ b/Lib/test/libregrtest/testresult.py
@@ -0,0 +1,193 @@
+'''Test runner and result class for the regression test suite.
+
+'''
+
+import functools
+import io
+import sys
+import time
+import traceback
+import unittest
+from test import support
+from test.libregrtest.utils import sanitize_xml
+
+class RegressionTestResult(unittest.TextTestResult):
+    USE_XML = False
+
+    def __init__(self, stream, descriptions, verbosity):
+        super().__init__(stream=stream, descriptions=descriptions,
+                         verbosity=2 if verbosity else 0)
+        self.buffer = True
+        if self.USE_XML:
+            from xml.etree import ElementTree as ET
+            from datetime import datetime, UTC
+            self.__ET = ET
+            self.__suite = ET.Element('testsuite')
+            self.__suite.set('start',
+                             datetime.now(UTC)
+                                     .replace(tzinfo=None)
+                                     .isoformat(' '))
+            self.__e = None
+        self.__start_time = None
+
+    @classmethod
+    def __getId(cls, test):
+        try:
+            test_id = test.id
+        except AttributeError:
+            return str(test)
+        try:
+            return test_id()
+        except TypeError:
+            return str(test_id)
+        return repr(test)
+
+    def startTest(self, test):
+        super().startTest(test)
+        if self.USE_XML:
+            self.__e = e = self.__ET.SubElement(self.__suite, 'testcase')
+        self.__start_time = time.perf_counter()
+
+    def _add_result(self, test, capture=False, **args):
+        if not self.USE_XML:
+            return
+        e = self.__e
+        self.__e = None
+        if e is None:
+            return
+        ET = self.__ET
+
+        e.set('name', args.pop('name', self.__getId(test)))
+        e.set('status', args.pop('status', 'run'))
+        e.set('result', args.pop('result', 'completed'))
+        if self.__start_time:
+            e.set('time', f'{time.perf_counter() - self.__start_time:0.6f}')
+
+        if capture:
+            if self._stdout_buffer is not None:
+                stdout = self._stdout_buffer.getvalue().rstrip()
+                ET.SubElement(e, 'system-out').text = sanitize_xml(stdout)
+            if self._stderr_buffer is not None:
+                stderr = self._stderr_buffer.getvalue().rstrip()
+                ET.SubElement(e, 'system-err').text = sanitize_xml(stderr)
+
+        for k, v in args.items():
+            if not k or not v:
+                continue
+
+            e2 = ET.SubElement(e, k)
+            if hasattr(v, 'items'):
+                for k2, v2 in v.items():
+                    if k2:
+                        e2.set(k2, sanitize_xml(str(v2)))
+                    else:
+                        e2.text = sanitize_xml(str(v2))
+            else:
+                e2.text = sanitize_xml(str(v))
+
+    @classmethod
+    def __makeErrorDict(cls, err_type, err_value, err_tb):
+        if isinstance(err_type, type):
+            if err_type.__module__ == 'builtins':
+                typename = err_type.__name__
+            else:
+                typename = f'{err_type.__module__}.{err_type.__name__}'
+        else:
+            typename = repr(err_type)
+
+        msg = traceback.format_exception(err_type, err_value, None)
+        tb = traceback.format_exception(err_type, err_value, err_tb)
+
+        return {
+            'type': typename,
+            'message': ''.join(msg),
+            '': ''.join(tb),
+        }
+
+    def addError(self, test, err):
+        self._add_result(test, True, error=self.__makeErrorDict(*err))
+        super().addError(test, err)
+
+    def addExpectedFailure(self, test, err):
+        self._add_result(test, True, output=self.__makeErrorDict(*err))
+        super().addExpectedFailure(test, err)
+
+    def addFailure(self, test, err):
+        self._add_result(test, True, failure=self.__makeErrorDict(*err))
+        super().addFailure(test, err)
+        if support.failfast:
+            self.stop()
+
+    def addSkip(self, test, reason):
+        self._add_result(test, skipped=reason)
+        super().addSkip(test, reason)
+
+    def addSuccess(self, test):
+        self._add_result(test)
+        super().addSuccess(test)
+
+    def addUnexpectedSuccess(self, test):
+        self._add_result(test, outcome='UNEXPECTED_SUCCESS')
+        super().addUnexpectedSuccess(test)
+
+    def get_xml_element(self):
+        if not self.USE_XML:
+            raise ValueError("USE_XML is false")
+        e = self.__suite
+        e.set('tests', str(self.testsRun))
+        e.set('errors', str(len(self.errors)))
+        e.set('failures', str(len(self.failures)))
+        return e
+
+class QuietRegressionTestRunner:
+    def __init__(self, stream, buffer=False):
+        self.result = RegressionTestResult(stream, None, 0)
+        self.result.buffer = buffer
+
+    def run(self, test):
+        test(self.result)
+        return self.result
+
+def get_test_runner_class(verbosity, buffer=False):
+    if verbosity:
+        return functools.partial(unittest.TextTestRunner,
+                                 resultclass=RegressionTestResult,
+                                 buffer=buffer,
+                                 verbosity=verbosity)
+    return functools.partial(QuietRegressionTestRunner, buffer=buffer)
+
+def get_test_runner(stream, verbosity, capture_output=False):
+    return get_test_runner_class(verbosity, capture_output)(stream)
+
+if __name__ == '__main__':
+    import xml.etree.ElementTree as ET
+    RegressionTestResult.USE_XML = True
+
+    class TestTests(unittest.TestCase):
+        def test_pass(self):
+            pass
+
+        def test_pass_slow(self):
+            time.sleep(1.0)
+
+        def test_fail(self):
+            print('stdout', file=sys.stdout)
+            print('stderr', file=sys.stderr)
+            self.fail('failure message')
+
+        def test_error(self):
+            print('stdout', file=sys.stdout)
+            print('stderr', file=sys.stderr)
+            raise RuntimeError('error message')
+
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestTests))
+    stream = io.StringIO()
+    runner_cls = get_test_runner_class(sum(a == '-v' for a in sys.argv))
+    runner = runner_cls(sys.stdout)
+    result = runner.run(suite)
+    print('Output:', stream.getvalue())
+    print('XML: ', end='')
+    for s in ET.tostringlist(result.get_xml_element()):
+        print(s.decode(), end='')
+    print()
diff --git a/Lib/test/libregrtest/tsan.py b/Lib/test/libregrtest/tsan.py
new file mode 100644
index 00000000000..0c0ab20fa0b
--- /dev/null
+++ b/Lib/test/libregrtest/tsan.py
@@ -0,0 +1,34 @@
+# Set of tests run by default if --tsan is specified.  The tests below were
+# chosen because they use threads and run in a reasonable amount of time.
+
+TSAN_TESTS = [
+    # TODO: enable more of test_capi once bugs are fixed (GH-116908, GH-116909).
+    'test_capi.test_mem',
+    'test_capi.test_pyatomic',
+    'test_code',
+    'test_enum',
+    'test_functools',
+    'test_httpservers',
+    'test_imaplib',
+    'test_importlib',
+    'test_io',
+    'test_logging',
+    'test_opcache',
+    'test_queue',
+    'test_signal',
+    'test_socket',
+    'test_sqlite3',
+    'test_ssl',
+    'test_syslog',
+    'test_thread',
+    'test_threadedtempfile',
+    'test_threading',
+    'test_threading_local',
+    'test_threadsignals',
+    'test_weakref',
+]
+
+
+def setup_tsan_tests(cmdline_args) -> None:
+    if not cmdline_args:
+        cmdline_args[:] = TSAN_TESTS[:]
diff --git a/Lib/test/libregrtest/utils.py b/Lib/test/libregrtest/utils.py
index fb9971a64f6..d5dca353dcd 100644
--- a/Lib/test/libregrtest/utils.py
+++ b/Lib/test/libregrtest/utils.py
@@ -1,10 +1,64 @@
+import contextlib
+import faulthandler
+import locale
 import math
 import os.path
+import platform
+import random
+import re
+import shlex
+import signal
+import subprocess
 import sys
+import sysconfig
+import tempfile
 import textwrap
+from collections.abc import Callable, Iterable
 
+from test import support
+from test.support import os_helper
+from test.support import threading_helper
 
-def format_duration(seconds):
+
+# All temporary files and temporary directories created by libregrtest should
+# use TMP_PREFIX so cleanup_temp_dir() can remove them all.
+TMP_PREFIX = 'test_python_'
+WORK_DIR_PREFIX = TMP_PREFIX
+WORKER_WORK_DIR_PREFIX = WORK_DIR_PREFIX + 'worker_'
+
+# bpo-38203: Maximum delay in seconds to exit Python (call Py_Finalize()).
+# Used to protect against threading._shutdown() hang.
+# Must be smaller than buildbot "1200 seconds without output" limit.
+EXIT_TIMEOUT = 120.0
+
+
+ALL_RESOURCES = ('audio', 'console', 'curses', 'largefile', 'network',
+                 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui', 'walltime')
+
+# Other resources excluded from --use=all:
+#
+# - extralagefile (ex: test_zipfile64): really too slow to be enabled
+#   "by default"
+# - tzdata: while needed to validate fully test_datetime, it makes
+#   test_datetime too slow (15-20 min on some buildbots) and so is disabled by
+#   default (see bpo-30822).
+RESOURCE_NAMES = ALL_RESOURCES + ('extralargefile', 'tzdata')
+
+
+# Types for types hints
+StrPath = str
+TestName = str
+StrJSON = str
+TestTuple = tuple[TestName, ...]
+TestList = list[TestName]
+# --match and --ignore options: list of patterns
+# ('*' joker character can be used)
+TestFilter = list[tuple[TestName, bool]]
+FilterTuple = tuple[TestName, ...]
+FilterDict = dict[TestName, FilterTuple]
+
+
+def format_duration(seconds: float) -> str:
     ms = math.ceil(seconds * 1e3)
     seconds, ms = divmod(ms, 1000)
     minutes, seconds = divmod(seconds, 60)
@@ -16,17 +70,20 @@ def format_duration(seconds):
     if minutes:
         parts.append('%s min' % minutes)
     if seconds:
-        parts.append('%s sec' % seconds)
-    if ms:
-        parts.append('%s ms' % ms)
+        if parts:
+            # 2 min 1 sec
+            parts.append('%s sec' % seconds)
+        else:
+            # 1.0 sec
+            parts.append('%.1f sec' % (seconds + ms / 1000))
     if not parts:
-        return '0 ms'
+        return '%s ms' % ms
 
     parts = parts[:2]
     return ' '.join(parts)
 
 
-def removepy(names):
+def strip_py_suffix(names: list[str] | None) -> None:
     if not names:
         return
     for idx, name in enumerate(names):
@@ -35,11 +92,20 @@ def removepy(names):
             names[idx] = basename
 
 
-def count(n, word):
+def plural(n: int, singular: str, plural: str | None = None) -> str:
     if n == 1:
-        return "%d %s" % (n, word)
+        return singular
+    elif plural is not None:
+        return plural
     else:
-        return "%d %ss" % (n, word)
+        return singular + 's'
+
+
+def count(n: int, word: str) -> str:
+    if n == 1:
+        return f"{n} {word}"
+    else:
+        return f"{n} {word}s"
 
 
 def printlist(x, width=70, indent=4, file=None):
@@ -57,5 +123,677 @@ def printlist(x, width=70, indent=4, file=None):
           file=file)
 
 
-def print_warning(msg):
-    print(f"Warning -- {msg}", file=sys.stderr, flush=True)
+def print_warning(msg: str) -> None:
+    support.print_warning(msg)
+
+
+orig_unraisablehook: Callable[..., None] | None = None
+
+
+def regrtest_unraisable_hook(unraisable) -> None:
+    global orig_unraisablehook
+    support.environment_altered = True
+    support.print_warning("Unraisable exception")
+    old_stderr = sys.stderr
+    try:
+        support.flush_std_streams()
+        sys.stderr = support.print_warning.orig_stderr
+        assert orig_unraisablehook is not None, "orig_unraisablehook not set"
+        orig_unraisablehook(unraisable)
+        sys.stderr.flush()
+    finally:
+        sys.stderr = old_stderr
+
+
+def setup_unraisable_hook() -> None:
+    global orig_unraisablehook
+    orig_unraisablehook = sys.unraisablehook
+    sys.unraisablehook = regrtest_unraisable_hook
+
+
+orig_threading_excepthook: Callable[..., None] | None = None
+
+
+def regrtest_threading_excepthook(args) -> None:
+    global orig_threading_excepthook
+    support.environment_altered = True
+    support.print_warning(f"Uncaught thread exception: {args.exc_type.__name__}")
+    old_stderr = sys.stderr
+    try:
+        support.flush_std_streams()
+        sys.stderr = support.print_warning.orig_stderr
+        assert orig_threading_excepthook is not None, "orig_threading_excepthook not set"
+        orig_threading_excepthook(args)
+        sys.stderr.flush()
+    finally:
+        sys.stderr = old_stderr
+
+
+def setup_threading_excepthook() -> None:
+    global orig_threading_excepthook
+    import threading
+    orig_threading_excepthook = threading.excepthook
+    threading.excepthook = regrtest_threading_excepthook
+
+
+def clear_caches():
+    # Clear the warnings registry, so they can be displayed again
+    for mod in sys.modules.values():
+        if hasattr(mod, '__warningregistry__'):
+            del mod.__warningregistry__
+
+    # Flush standard output, so that buffered data is sent to the OS and
+    # associated Python objects are reclaimed.
+    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
+        if stream is not None:
+            stream.flush()
+
+    try:
+        re = sys.modules['re']
+    except KeyError:
+        pass
+    else:
+        re.purge()
+
+    try:
+        _strptime = sys.modules['_strptime']
+    except KeyError:
+        pass
+    else:
+        _strptime._regex_cache.clear()
+
+    try:
+        urllib_parse = sys.modules['urllib.parse']
+    except KeyError:
+        pass
+    else:
+        urllib_parse.clear_cache()
+
+    try:
+        urllib_request = sys.modules['urllib.request']
+    except KeyError:
+        pass
+    else:
+        urllib_request.urlcleanup()
+
+    try:
+        linecache = sys.modules['linecache']
+    except KeyError:
+        pass
+    else:
+        linecache.clearcache()
+
+    try:
+        mimetypes = sys.modules['mimetypes']
+    except KeyError:
+        pass
+    else:
+        mimetypes._default_mime_types()
+
+    try:
+        filecmp = sys.modules['filecmp']
+    except KeyError:
+        pass
+    else:
+        filecmp._cache.clear()
+
+    try:
+        struct = sys.modules['struct']
+    except KeyError:
+        pass
+    else:
+        struct._clearcache()
+
+    try:
+        doctest = sys.modules['doctest']
+    except KeyError:
+        pass
+    else:
+        doctest.master = None
+
+    try:
+        ctypes = sys.modules['ctypes']
+    except KeyError:
+        pass
+    else:
+        ctypes._reset_cache()
+
+    try:
+        typing = sys.modules['typing']
+    except KeyError:
+        pass
+    else:
+        for f in typing._cleanups:
+            f()
+
+        import inspect
+        abs_classes = filter(inspect.isabstract, typing.__dict__.values())
+        for abc in abs_classes:
+            for obj in abc.__subclasses__() + [abc]:
+                obj._abc_caches_clear()
+
+    try:
+        fractions = sys.modules['fractions']
+    except KeyError:
+        pass
+    else:
+        fractions._hash_algorithm.cache_clear()
+
+    try:
+        inspect = sys.modules['inspect']
+    except KeyError:
+        pass
+    else:
+        inspect._shadowed_dict_from_weakref_mro_tuple.cache_clear()
+        inspect._filesbymodname.clear()
+        inspect.modulesbyfile.clear()
+
+    try:
+        importlib_metadata = sys.modules['importlib.metadata']
+    except KeyError:
+        pass
+    else:
+        importlib_metadata.FastPath.__new__.cache_clear()
+
+
+def get_build_info():
+    # Get most important configure and build options as a list of strings.
+    # Example: ['debug', 'ASAN+MSAN'] or ['release', 'LTO+PGO'].
+
+    config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''
+    cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
+    cflags += ' ' + (sysconfig.get_config_var('PY_CFLAGS_NODIST') or '')
+    ldflags_nodist = sysconfig.get_config_var('PY_LDFLAGS_NODIST') or ''
+
+    build = []
+
+    # --disable-gil
+    if sysconfig.get_config_var('Py_GIL_DISABLED'):
+        if not sys.flags.ignore_environment:
+            PYTHON_GIL = os.environ.get('PYTHON_GIL', None)
+            if PYTHON_GIL:
+                PYTHON_GIL = (PYTHON_GIL == '1')
+        else:
+            PYTHON_GIL = None
+
+        free_threading = "free_threading"
+        if PYTHON_GIL is not None:
+            free_threading = f"{free_threading} GIL={int(PYTHON_GIL)}"
+        build.append(free_threading)
+
+    if hasattr(sys, 'gettotalrefcount'):
+        # --with-pydebug
+        build.append('debug')
+
+        if '-DNDEBUG' in cflags:
+            build.append('without_assert')
+    else:
+        build.append('release')
+
+        if '--with-assertions' in config_args:
+            build.append('with_assert')
+        elif '-DNDEBUG' not in cflags:
+            build.append('with_assert')
+
+    # --enable-experimental-jit
+    tier2 = re.search('-D_Py_TIER2=([0-9]+)', cflags)
+    if tier2:
+        tier2 = int(tier2.group(1))
+
+    if not sys.flags.ignore_environment:
+        PYTHON_JIT = os.environ.get('PYTHON_JIT', None)
+        if PYTHON_JIT:
+            PYTHON_JIT = (PYTHON_JIT != '0')
+    else:
+        PYTHON_JIT = None
+
+    if tier2 == 1:  # =yes
+        if PYTHON_JIT == False:
+            jit = 'JIT=off'
+        else:
+            jit = 'JIT'
+    elif tier2 == 3:  # =yes-off
+        if PYTHON_JIT:
+            jit = 'JIT'
+        else:
+            jit = 'JIT=off'
+    elif tier2 == 4:  # =interpreter
+        if PYTHON_JIT == False:
+            jit = 'JIT-interpreter=off'
+        else:
+            jit = 'JIT-interpreter'
+    elif tier2 == 6:  # =interpreter-off (Secret option!)
+        if PYTHON_JIT:
+            jit = 'JIT-interpreter'
+        else:
+            jit = 'JIT-interpreter=off'
+    elif '-D_Py_JIT' in cflags:
+        jit = 'JIT'
+    else:
+        jit = None
+    if jit:
+        build.append(jit)
+
+    # --enable-framework=name
+    framework = sysconfig.get_config_var('PYTHONFRAMEWORK')
+    if framework:
+        build.append(f'framework={framework}')
+
+    # --enable-shared
+    shared = int(sysconfig.get_config_var('PY_ENABLE_SHARED') or '0')
+    if shared:
+        build.append('shared')
+
+    # --with-lto
+    optimizations = []
+    if '-flto=thin' in ldflags_nodist:
+        optimizations.append('ThinLTO')
+    elif '-flto' in ldflags_nodist:
+        optimizations.append('LTO')
+
+    if support.check_cflags_pgo():
+        # PGO (--enable-optimizations)
+        optimizations.append('PGO')
+
+    if support.check_bolt_optimized():
+        # BOLT (--enable-bolt)
+        optimizations.append('BOLT')
+
+    if optimizations:
+        build.append('+'.join(optimizations))
+
+    # --with-address-sanitizer
+    sanitizers = []
+    if support.check_sanitizer(address=True):
+        sanitizers.append("ASAN")
+    # --with-memory-sanitizer
+    if support.check_sanitizer(memory=True):
+        sanitizers.append("MSAN")
+    # --with-undefined-behavior-sanitizer
+    if support.check_sanitizer(ub=True):
+        sanitizers.append("UBSAN")
+    # --with-thread-sanitizer
+    if support.check_sanitizer(thread=True):
+        sanitizers.append("TSAN")
+    if sanitizers:
+        build.append('+'.join(sanitizers))
+
+    # --with-trace-refs
+    if hasattr(sys, 'getobjects'):
+        build.append("TraceRefs")
+    # --enable-pystats
+    if hasattr(sys, '_stats_on'):
+        build.append("pystats")
+    # --with-valgrind
+    if sysconfig.get_config_var('WITH_VALGRIND'):
+        build.append("valgrind")
+    # --with-dtrace
+    if sysconfig.get_config_var('WITH_DTRACE'):
+        build.append("dtrace")
+
+    return build
+
+
+def get_temp_dir(tmp_dir: StrPath | None = None) -> StrPath:
+    if tmp_dir:
+        tmp_dir = os.path.expanduser(tmp_dir)
+    else:
+        # When tests are run from the Python build directory, it is best practice
+        # to keep the test files in a subfolder.  This eases the cleanup of leftover
+        # files using the "make distclean" command.
+        if sysconfig.is_python_build():
+            if not support.is_wasi:
+                tmp_dir = sysconfig.get_config_var('abs_builddir')
+                if tmp_dir is None:
+                    tmp_dir = sysconfig.get_config_var('abs_srcdir')
+                    if not tmp_dir:
+                        # gh-74470: On Windows, only srcdir is available. Using
+                        # abs_builddir mostly matters on UNIX when building
+                        # Python out of the source tree, especially when the
+                        # source tree is read only.
+                        tmp_dir = sysconfig.get_config_var('srcdir')
+                        if not tmp_dir:
+                            raise RuntimeError(
+                                "Could not determine the correct value for tmp_dir"
+                            )
+                tmp_dir = os.path.join(tmp_dir, 'build')
+            else:
+                # WASI platform
+                tmp_dir = sysconfig.get_config_var('projectbase')
+                if not tmp_dir:
+                    raise RuntimeError(
+                        "sysconfig.get_config_var('projectbase') "
+                        f"unexpectedly returned {tmp_dir!r} on WASI"
+                    )
+                tmp_dir = os.path.join(tmp_dir, 'build')
+
+                # When get_temp_dir() is called in a worker process,
+                # get_temp_dir() path is different than in the parent process
+                # which is not a WASI process. So the parent does not create
+                # the same "tmp_dir" than the test worker process.
+                os.makedirs(tmp_dir, exist_ok=True)
+        else:
+            tmp_dir = tempfile.gettempdir()
+
+    return os.path.abspath(tmp_dir)
+
+
+def fix_umask() -> None:
+    if support.is_emscripten:
+        # Emscripten has default umask 0o777, which breaks some tests.
+        # see https://github.com/emscripten-core/emscripten/issues/17269
+        old_mask = os.umask(0)
+        if old_mask == 0o777:
+            os.umask(0o027)
+        else:
+            os.umask(old_mask)
+
+
+def get_work_dir(parent_dir: StrPath, worker: bool = False) -> StrPath:
+    # Define a writable temp dir that will be used as cwd while running
+    # the tests. The name of the dir includes the pid to allow parallel
+    # testing (see the -j option).
+    # Emscripten and WASI have stubbed getpid(), Emscripten has only
+    # millisecond clock resolution. Use randint() instead.
+    if support.is_emscripten or support.is_wasi:
+        nounce = random.randint(0, 1_000_000)
+    else:
+        nounce = os.getpid()
+
+    if worker:
+        work_dir = WORK_DIR_PREFIX + str(nounce)
+    else:
+        work_dir = WORKER_WORK_DIR_PREFIX + str(nounce)
+    work_dir += os_helper.FS_NONASCII
+    work_dir = os.path.join(parent_dir, work_dir)
+    return work_dir
+
+
+@contextlib.contextmanager
+def exit_timeout():
+    try:
+        yield
+    except SystemExit as exc:
+        # bpo-38203: Python can hang at exit in Py_Finalize(), especially
+        # on threading._shutdown() call: put a timeout
+        if threading_helper.can_start_thread:
+            faulthandler.dump_traceback_later(EXIT_TIMEOUT, exit=True)
+        sys.exit(exc.code)
+
+
+def remove_testfn(test_name: TestName, verbose: int) -> None:
+    # Try to clean up os_helper.TESTFN if left behind.
+    #
+    # While tests shouldn't leave any files or directories behind, when a test
+    # fails that can be tedious for it to arrange.  The consequences can be
+    # especially nasty on Windows, since if a test leaves a file open, it
+    # cannot be deleted by name (while there's nothing we can do about that
+    # here either, we can display the name of the offending test, which is a
+    # real help).
+    name = os_helper.TESTFN
+    if not os.path.exists(name):
+        return
+
+    nuker: Callable[[str], None]
+    if os.path.isdir(name):
+        import shutil
+        kind, nuker = "directory", shutil.rmtree
+    elif os.path.isfile(name):
+        kind, nuker = "file", os.unlink
+    else:
+        raise RuntimeError(f"os.path says {name!r} exists but is neither "
+                           f"directory nor file")
+
+    if verbose:
+        print_warning(f"{test_name} left behind {kind} {name!r}")
+        support.environment_altered = True
+
+    try:
+        import stat
+        # fix possible permissions problems that might prevent cleanup
+        os.chmod(name, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+        nuker(name)
+    except Exception as exc:
+        print_warning(f"{test_name} left behind {kind} {name!r} "
+                      f"and it couldn't be removed: {exc}")
+
+
+def abs_module_name(test_name: TestName, test_dir: StrPath | None) -> TestName:
+    if test_name.startswith('test.') or test_dir:
+        return test_name
+    else:
+        # Import it from the test package
+        return 'test.' + test_name
+
+
+# gh-90681: When rerunning tests, we might need to rerun the whole
+# class or module suite if some its life-cycle hooks fail.
+# Test level hooks are not affected.
+_TEST_LIFECYCLE_HOOKS = frozenset((
+    'setUpClass', 'tearDownClass',
+    'setUpModule', 'tearDownModule',
+))
+
+def normalize_test_name(test_full_name: str, *,
+                        is_error: bool = False) -> str | None:
+    short_name = test_full_name.split(" ")[0]
+    if is_error and short_name in _TEST_LIFECYCLE_HOOKS:
+        if test_full_name.startswith(('setUpModule (', 'tearDownModule (')):
+            # if setUpModule() or tearDownModule() failed, don't filter
+            # tests with the test file name, don't use filters.
+            return None
+
+        # This means that we have a failure in a life-cycle hook,
+        # we need to rerun the whole module or class suite.
+        # Basically the error looks like this:
+        #    ERROR: setUpClass (test.test_reg_ex.RegTest)
+        # or
+        #    ERROR: setUpModule (test.test_reg_ex)
+        # So, we need to parse the class / module name.
+        lpar = test_full_name.index('(')
+        rpar = test_full_name.index(')')
+        return test_full_name[lpar + 1: rpar].split('.')[-1]
+    return short_name
+
+
+def adjust_rlimit_nofile() -> None:
+    """
+    On macOS the default fd limit (RLIMIT_NOFILE) is sometimes too low (256)
+    for our test suite to succeed. Raise it to something more reasonable. 1024
+    is a common Linux default.
+    """
+    try:
+        import resource
+    except ImportError:
+        return
+
+    fd_limit, max_fds = resource.getrlimit(resource.RLIMIT_NOFILE)
+
+    desired_fds = 1024
+
+    if fd_limit < desired_fds and fd_limit < max_fds:
+        new_fd_limit = min(desired_fds, max_fds)
+        try:
+            resource.setrlimit(resource.RLIMIT_NOFILE,
+                               (new_fd_limit, max_fds))
+            print(f"Raised RLIMIT_NOFILE: {fd_limit} -> {new_fd_limit}")
+        except (ValueError, OSError) as err:
+            print_warning(f"Unable to raise RLIMIT_NOFILE from {fd_limit} to "
+                          f"{new_fd_limit}: {err}.")
+
+
+def get_host_runner() -> str:
+    if (hostrunner := os.environ.get("_PYTHON_HOSTRUNNER")) is None:
+        hostrunner = sysconfig.get_config_var("HOSTRUNNER")
+    return hostrunner
+
+
+def is_cross_compiled() -> bool:
+    return ('_PYTHON_HOST_PLATFORM' in os.environ)
+
+
+def format_resources(use_resources: Iterable[str]) -> str:
+    use_resources = set(use_resources)
+    all_resources = set(ALL_RESOURCES)
+
+    # Express resources relative to "all"
+    relative_all = ['all']
+    for name in sorted(all_resources - use_resources):
+        relative_all.append(f'-{name}')
+    for name in sorted(use_resources - all_resources):
+        relative_all.append(f'{name}')
+    all_text = ','.join(relative_all)
+    all_text = f"resources: {all_text}"
+
+    # List of enabled resources
+    text = ','.join(sorted(use_resources))
+    text = f"resources ({len(use_resources)}): {text}"
+
+    # Pick the shortest string (prefer relative to all if lengths are equal)
+    if len(all_text) <= len(text):
+        return all_text
+    else:
+        return text
+
+
+def display_header(use_resources: tuple[str, ...],
+                   python_cmd: tuple[str, ...] | None) -> None:
+    # Print basic platform information
+    print("==", platform.python_implementation(), *sys.version.split())
+    print("==", platform.platform(aliased=True),
+                  "%s-endian" % sys.byteorder)
+    print("== Python build:", ' '.join(get_build_info()))
+    print("== cwd:", os.getcwd())
+
+    cpu_count: object = os.cpu_count()
+    if cpu_count:
+        # The function is new in Python 3.13; mypy doesn't know about it yet:
+        process_cpu_count = os.process_cpu_count()  # type: ignore[attr-defined]
+        if process_cpu_count and process_cpu_count != cpu_count:
+            cpu_count = f"{process_cpu_count} (process) / {cpu_count} (system)"
+        print("== CPU count:", cpu_count)
+    print("== encodings: locale=%s FS=%s"
+          % (locale.getencoding(), sys.getfilesystemencoding()))
+
+    if use_resources:
+        text = format_resources(use_resources)
+        print(f"== {text}")
+    else:
+        print("== resources: all test resources are disabled, "
+              "use -u option to unskip tests")
+
+    cross_compile = is_cross_compiled()
+    if cross_compile:
+        print("== cross compiled: Yes")
+    if python_cmd:
+        cmd = shlex.join(python_cmd)
+        print(f"== host python: {cmd}")
+
+        get_cmd = [*python_cmd, '-m', 'platform']
+        proc = subprocess.run(
+            get_cmd,
+            stdout=subprocess.PIPE,
+            text=True,
+            cwd=os_helper.SAVEDCWD)
+        stdout = proc.stdout.replace('\n', ' ').strip()
+        if stdout:
+            print(f"== host platform: {stdout}")
+        elif proc.returncode:
+            print(f"== host platform: <command failed with exit code {proc.returncode}>")
+    else:
+        hostrunner = get_host_runner()
+        if hostrunner:
+            print(f"== host runner: {hostrunner}")
+
+    # This makes it easier to remember what to set in your local
+    # environment when trying to reproduce a sanitizer failure.
+    asan = support.check_sanitizer(address=True)
+    msan = support.check_sanitizer(memory=True)
+    ubsan = support.check_sanitizer(ub=True)
+    tsan = support.check_sanitizer(thread=True)
+    sanitizers = []
+    if asan:
+        sanitizers.append("address")
+    if msan:
+        sanitizers.append("memory")
+    if ubsan:
+        sanitizers.append("undefined behavior")
+    if tsan:
+        sanitizers.append("thread")
+    if sanitizers:
+        print(f"== sanitizers: {', '.join(sanitizers)}")
+        for sanitizer, env_var in (
+            (asan, "ASAN_OPTIONS"),
+            (msan, "MSAN_OPTIONS"),
+            (ubsan, "UBSAN_OPTIONS"),
+            (tsan, "TSAN_OPTIONS"),
+        ):
+            options= os.environ.get(env_var)
+            if sanitizer and options is not None:
+                print(f"== {env_var}={options!r}")
+
+    print(flush=True)
+
+
+def cleanup_temp_dir(tmp_dir: StrPath) -> None:
+    import glob
+
+    path = os.path.join(glob.escape(tmp_dir), TMP_PREFIX + '*')
+    print("Cleanup %s directory" % tmp_dir)
+    for name in glob.glob(path):
+        if os.path.isdir(name):
+            print("Remove directory: %s" % name)
+            os_helper.rmtree(name)
+        else:
+            print("Remove file: %s" % name)
+            os_helper.unlink(name)
+
+WINDOWS_STATUS = {
+    0xC0000005: "STATUS_ACCESS_VIOLATION",
+    0xC00000FD: "STATUS_STACK_OVERFLOW",
+    0xC000013A: "STATUS_CONTROL_C_EXIT",
+}
+
+def get_signal_name(exitcode):
+    if exitcode < 0:
+        signum = -exitcode
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    # Shell exit code (ex: WASI build)
+    if 128 < exitcode < 256:
+        signum = exitcode - 128
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    try:
+        return WINDOWS_STATUS[exitcode]
+    except KeyError:
+        pass
+
+    return None
+
+
+ILLEGAL_XML_CHARS_RE = re.compile(
+    '['
+    # Control characters; newline (\x0A and \x0D) and TAB (\x09) are legal
+    '\x00-\x08\x0B\x0C\x0E-\x1F'
+    # Surrogate characters
+    '\uD800-\uDFFF'
+    # Special Unicode characters
+    '\uFFFE'
+    '\uFFFF'
+    # Match multiple sequential invalid characters for better efficiency
+    ']+')
+
+def _sanitize_xml_replace(regs):
+    text = regs[0]
+    return ''.join(f'\\x{ord(ch):02x}' if ch <= '\xff' else ascii(ch)[1:-1]
+                   for ch in text)
+
+def sanitize_xml(text: str) -> str:
+    return ILLEGAL_XML_CHARS_RE.sub(_sanitize_xml_replace, text)
diff --git a/Lib/test/libregrtest/win_utils.py b/Lib/test/libregrtest/win_utils.py
index 95db3def36f..b51fde0af57 100644
--- a/Lib/test/libregrtest/win_utils.py
+++ b/Lib/test/libregrtest/win_utils.py
@@ -1,105 +1,128 @@
+import _overlapped
+import _thread
 import _winapi
-import msvcrt
-import os
-import subprocess
-import uuid
-from test import support
+import math
+import struct
+import winreg
 
 
-# Max size of asynchronous reads
-BUFSIZE = 8192
-# Exponential damping factor (see below)
-LOAD_FACTOR_1 = 0.9200444146293232478931553241
 # Seconds per measurement
-SAMPLING_INTERVAL = 5
-COUNTER_NAME = r'\System\Processor Queue Length'
+SAMPLING_INTERVAL = 1
+# Exponential damping factor to compute exponentially weighted moving average
+# on 1 minute (60 seconds)
+LOAD_FACTOR_1 = 1 / math.exp(SAMPLING_INTERVAL / 60)
+# Initialize the load using the arithmetic mean of the first NVALUE values
+# of the Processor Queue Length
+NVALUE = 5
 
 
 class WindowsLoadTracker():
     """
-    This class asynchronously interacts with the `typeperf` command to read
-    the system load on Windows. Mulitprocessing and threads can't be used
-    here because they interfere with the test suite's cases for those
-    modules.
+    This class asynchronously reads the performance counters to calculate
+    the system load on Windows.  A "raw" thread is used here to prevent
+    interference with the test suite's cases for the threading module.
     """
 
     def __init__(self):
-        self.load = 0.0
-        self.start()
-
-    def start(self):
-        # Create a named pipe which allows for asynchronous IO in Windows
-        pipe_name =  r'\\.\pipe\typeperf_output_' + str(uuid.uuid4())
-
-        open_mode =  _winapi.PIPE_ACCESS_INBOUND
-        open_mode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
-        open_mode |= _winapi.FILE_FLAG_OVERLAPPED
-
-        # This is the read end of the pipe, where we will be grabbing output
-        self.pipe = _winapi.CreateNamedPipe(
-            pipe_name, open_mode, _winapi.PIPE_WAIT,
-            1, BUFSIZE, BUFSIZE, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
-        )
-        # The write end of the pipe which is passed to the created process
-        pipe_write_end = _winapi.CreateFile(
-            pipe_name, _winapi.GENERIC_WRITE, 0, _winapi.NULL,
-            _winapi.OPEN_EXISTING, 0, _winapi.NULL
-        )
-        # Open up the handle as a python file object so we can pass it to
-        # subprocess
-        command_stdout = msvcrt.open_osfhandle(pipe_write_end, 0)
-
-        # Connect to the read end of the pipe in overlap/async mode
-        overlap = _winapi.ConnectNamedPipe(self.pipe, overlapped=True)
-        overlap.GetOverlappedResult(True)
-
-        # Spawn off the load monitor
-        command = ['typeperf', COUNTER_NAME, '-si', str(SAMPLING_INTERVAL)]
-        self.p = subprocess.Popen(command, stdout=command_stdout, cwd=os_helper.SAVEDCWD)
-
-        # Close our copy of the write end of the pipe
-        os.close(command_stdout)
-
-    def close(self):
-        if self.p is None:
+        # make __del__ not fail if pre-flight test fails
+        self._running = None
+        self._stopped = None
+
+        # Pre-flight test for access to the performance data;
+        # `PermissionError` will be raised if not allowed
+        winreg.QueryInfoKey(winreg.HKEY_PERFORMANCE_DATA)
+
+        self._values = []
+        self._load = None
+        self._running = _overlapped.CreateEvent(None, True, False, None)
+        self._stopped = _overlapped.CreateEvent(None, True, False, None)
+
+        _thread.start_new_thread(self._update_load, (), {})
+
+    def _update_load(self,
+                    # localize module access to prevent shutdown errors
+                     _wait=_winapi.WaitForSingleObject,
+                     _signal=_overlapped.SetEvent):
+        # run until signaled to stop
+        while _wait(self._running, 1000):
+            self._calculate_load()
+        # notify stopped
+        _signal(self._stopped)
+
+    def _calculate_load(self,
+                        # localize module access to prevent shutdown errors
+                        _query=winreg.QueryValueEx,
+                        _hkey=winreg.HKEY_PERFORMANCE_DATA,
+                        _unpack=struct.unpack_from):
+        # get the 'System' object
+        data, _ = _query(_hkey, '2')
+        # PERF_DATA_BLOCK {
+        #   WCHAR Signature[4]      8 +
+        #   DWOWD LittleEndian      4 +
+        #   DWORD Version           4 +
+        #   DWORD Revision          4 +
+        #   DWORD TotalByteLength   4 +
+        #   DWORD HeaderLength      = 24 byte offset
+        #   ...
+        # }
+        obj_start, = _unpack('L', data, 24)
+        # PERF_OBJECT_TYPE {
+        #   DWORD TotalByteLength
+        #   DWORD DefinitionLength
+        #   DWORD HeaderLength
+        #   ...
+        # }
+        data_start, defn_start = _unpack('4xLL', data, obj_start)
+        data_base = obj_start + data_start
+        defn_base = obj_start + defn_start
+        # find the 'Processor Queue Length' counter (index=44)
+        while defn_base < data_base:
+            # PERF_COUNTER_DEFINITION {
+            #   DWORD ByteLength
+            #   DWORD CounterNameTitleIndex
+            #   ... [7 DWORDs/28 bytes]
+            #   DWORD CounterOffset
+            # }
+            size, idx, offset = _unpack('LL28xL', data, defn_base)
+            defn_base += size
+            if idx == 44:
+                counter_offset = data_base + offset
+                # the counter is known to be PERF_COUNTER_RAWCOUNT (DWORD)
+                processor_queue_length, = _unpack('L', data, counter_offset)
+                break
+        else:
             return
-        self.p.kill()
-        self.p.wait()
-        self.p = None
 
-    def __del__(self):
-        self.close()
-
-    def read_output(self):
-        import _winapi
-
-        overlapped, _ = _winapi.ReadFile(self.pipe, BUFSIZE, True)
-        bytes_read, res = overlapped.GetOverlappedResult(False)
-        if res != 0:
-            return
-
-        return overlapped.getbuffer().decode()
+        # We use an exponentially weighted moving average, imitating the
+        # load calculation on Unix systems.
+        # https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
+        # https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+        if self._load is not None:
+            self._load = (self._load * LOAD_FACTOR_1
+                            + processor_queue_length  * (1.0 - LOAD_FACTOR_1))
+        elif len(self._values) < NVALUE:
+            self._values.append(processor_queue_length)
+        else:
+            self._load = sum(self._values) / len(self._values)
+
+    def close(self, kill=True):
+        self.__del__()
+        return
+
+    def __del__(self,
+                # localize module access to prevent shutdown errors
+                _wait=_winapi.WaitForSingleObject,
+                _close=_winapi.CloseHandle,
+                _signal=_overlapped.SetEvent):
+        if self._running is not None:
+            # tell the update thread to quit
+            _signal(self._running)
+            # wait for the update thread to signal done
+            _wait(self._stopped, -1)
+            # cleanup events
+            _close(self._running)
+            _close(self._stopped)
+            self._running = self._stopped = None
 
     def getloadavg(self):
-        typeperf_output = self.read_output()
-        # Nothing to update, just return the current load
-        if not typeperf_output:
-            return self.load
-
-        # Process the backlog of load values
-        for line in typeperf_output.splitlines():
-            # typeperf outputs in a CSV format like this:
-            # "07/19/2018 01:32:26.605","3.000000"
-            toks = line.split(',')
-            # Ignore blank lines and the initial header
-            if line.strip() == '' or (COUNTER_NAME in line) or len(toks) != 2:
-                continue
-
-            load = float(toks[1].replace('"', ''))
-            # We use an exponentially weighted moving average, imitating the
-            # load calculation on Unix systems.
-            # https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
-            new_load = self.load * LOAD_FACTOR_1 + load * (1.0 - LOAD_FACTOR_1)
-            self.load = new_load
-
-        return self.load
+        return self._load
diff --git a/Lib/test/libregrtest/worker.py b/Lib/test/libregrtest/worker.py
new file mode 100644
index 00000000000..e0627c4adc0
--- /dev/null
+++ b/Lib/test/libregrtest/worker.py
@@ -0,0 +1,123 @@
+import subprocess
+import sys
+import os
+from _colorize import can_colorize  # type: ignore[import-not-found]
+from typing import Any, NoReturn
+
+from test.support import os_helper, Py_DEBUG
+
+from .setup import setup_process, setup_test_dir
+from .runtests import WorkerRunTests, JsonFile, JsonFileType
+from .single import run_single_test
+from .utils import (
+    StrPath, StrJSON, TestFilter,
+    get_temp_dir, get_work_dir, exit_timeout)
+
+
+USE_PROCESS_GROUP = (hasattr(os, "setsid") and hasattr(os, "killpg"))
+
+
+def create_worker_process(runtests: WorkerRunTests, output_fd: int,
+                          tmp_dir: StrPath | None = None) -> subprocess.Popen[str]:
+    worker_json = runtests.as_json()
+
+    cmd = runtests.create_python_cmd()
+    cmd.extend(['-m', 'test.libregrtest.worker', worker_json])
+
+    env = dict(os.environ)
+    if tmp_dir is not None:
+        env['TMPDIR'] = tmp_dir
+        env['TEMP'] = tmp_dir
+        env['TMP'] = tmp_dir
+
+    # The subcommand is run with a temporary output which means it is not a TTY
+    # and won't auto-color. The test results are printed to stdout so if we can
+    # color that have the subprocess use color.
+    if can_colorize(file=sys.stdout):
+        env['FORCE_COLOR'] = '1'
+
+    # Running the child from the same working directory as regrtest's original
+    # invocation ensures that TEMPDIR for the child is the same when
+    # sysconfig.is_python_build() is true. See issue 15300.
+    #
+    # Emscripten and WASI Python must start in the Python source code directory
+    # to get 'python.js' or 'python.wasm' file. Then worker_process() changes
+    # to a temporary directory created to run tests.
+    work_dir = os_helper.SAVEDCWD
+
+    kwargs: dict[str, Any] = dict(
+        env=env,
+        stdout=output_fd,
+        # bpo-45410: Write stderr into stdout to keep messages order
+        stderr=output_fd,
+        text=True,
+        close_fds=True,
+        cwd=work_dir,
+    )
+    if USE_PROCESS_GROUP:
+        kwargs['start_new_session'] = True
+
+    # Pass json_file to the worker process
+    json_file = runtests.json_file
+    json_file.configure_subprocess(kwargs)
+
+    with json_file.inherit_subprocess():
+        return subprocess.Popen(cmd, **kwargs)
+
+
+def worker_process(worker_json: StrJSON) -> NoReturn:
+    runtests = WorkerRunTests.from_json(worker_json)
+    test_name = runtests.tests[0]
+    match_tests: TestFilter = runtests.match_tests
+    json_file: JsonFile = runtests.json_file
+
+    setup_test_dir(runtests.test_dir)
+    setup_process()
+
+    if runtests.rerun:
+        if match_tests:
+            matching = "matching: " + ", ".join(pattern for pattern, result in match_tests if result)
+            print(f"Re-running {test_name} in verbose mode ({matching})", flush=True)
+        else:
+            print(f"Re-running {test_name} in verbose mode", flush=True)
+
+    result = run_single_test(test_name, runtests)
+    if runtests.coverage:
+        if "test.cov" in sys.modules:  # imported by -Xpresite=
+            result.covered_lines = list(sys.modules["test.cov"].coverage)
+        elif not Py_DEBUG:
+            print(
+                "Gathering coverage in worker processes requires --with-pydebug",
+                flush=True,
+            )
+        else:
+            raise LookupError(
+                "`test.cov` not found in sys.modules but coverage wanted"
+            )
+
+    if json_file.file_type == JsonFileType.STDOUT:
+        print()
+        result.write_json_into(sys.stdout)
+    else:
+        with json_file.open('w', encoding='utf-8') as json_fp:
+            result.write_json_into(json_fp)
+
+    sys.exit(0)
+
+
+def main() -> NoReturn:
+    if len(sys.argv) != 2:
+        print("usage: python -m test.libregrtest.worker JSON")
+        sys.exit(1)
+    worker_json = sys.argv[1]
+
+    tmp_dir = get_temp_dir()
+    work_dir = get_work_dir(tmp_dir, worker=True)
+
+    with exit_timeout():
+        with os_helper.temp_cwd(work_dir, quiet=True):
+            worker_process(worker_json)
+
+
+if __name__ == "__main__":
+    main()

From 5d253d1ec0256a89272d544c51f3acc1ed7d85e3 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:40:26 -0500
Subject: [PATCH 219/418] Re-add try block around platform and encodings info

---
 Lib/test/libregrtest/utils.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/Lib/test/libregrtest/utils.py b/Lib/test/libregrtest/utils.py
index d5dca353dcd..82efd85a469 100644
--- a/Lib/test/libregrtest/utils.py
+++ b/Lib/test/libregrtest/utils.py
@@ -660,8 +660,12 @@ def display_header(use_resources: tuple[str, ...],
                    python_cmd: tuple[str, ...] | None) -> None:
     # Print basic platform information
     print("==", platform.python_implementation(), *sys.version.split())
-    print("==", platform.platform(aliased=True),
-                  "%s-endian" % sys.byteorder)
+    try:
+        print("==", platform.platform(aliased=True),
+                    "%s-endian" % sys.byteorder)
+    except Exception as e:
+        print("==", f"Error: {e}")
+        print("==", "TODO: RUSTPYTHON, Need to fix platform.platform")
     print("== Python build:", ' '.join(get_build_info()))
     print("== cwd:", os.getcwd())
 
@@ -672,8 +676,12 @@ def display_header(use_resources: tuple[str, ...],
         if process_cpu_count and process_cpu_count != cpu_count:
             cpu_count = f"{process_cpu_count} (process) / {cpu_count} (system)"
         print("== CPU count:", cpu_count)
-    print("== encodings: locale=%s FS=%s"
-          % (locale.getencoding(), sys.getfilesystemencoding()))
+    try:
+        print("== encodings: locale=%s FS=%s"
+              % (locale.getencoding(), sys.getfilesystemencoding()))
+    except Exception as e:
+        print("==", f"Error: {e}")
+        print("==", "TODO: RUSTPYTHON, Need to fix encoding stuff")
 
     if use_resources:
         text = format_resources(use_resources)

From 08762a35c27d99903b1ba8ade998d5d8d89ba439 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:41:35 -0500
Subject: [PATCH 220/418] Disable WindowsLoadTracker on Windows

---
 Lib/test/libregrtest/main.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Lib/test/libregrtest/main.py b/Lib/test/libregrtest/main.py
index 54d4cac5d62..3a9c06da47e 100644
--- a/Lib/test/libregrtest/main.py
+++ b/Lib/test/libregrtest/main.py
@@ -529,7 +529,8 @@ def _run_tests(self, selected: TestTuple, tests: TestList | None) -> int:
             use_load_tracker = False
         else:
             # WindowsLoadTracker is only needed on Windows
-            use_load_tracker = MS_WINDOWS
+            # use_load_tracker = MS_WINDOWS  # TODO: RUSTPYTHON, investigate why this was disabled in the first place
+            use_load_tracker = False
 
         if use_load_tracker:
             self.logger.start_load_tracker()

From f436c51ef2229bee788e6a2ccb9fe4094da50074 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:43:40 -0500
Subject: [PATCH 221/418] Disable struct._clearcache()

---
 Lib/test/libregrtest/utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Lib/test/libregrtest/utils.py b/Lib/test/libregrtest/utils.py
index 82efd85a469..6500fd10ce0 100644
--- a/Lib/test/libregrtest/utils.py
+++ b/Lib/test/libregrtest/utils.py
@@ -242,7 +242,8 @@ def clear_caches():
     except KeyError:
         pass
     else:
-        struct._clearcache()
+        # struct._clearcache()  # TODO: RUSTPYTHON, investigate why this was disabled in the first place
+        pass
 
     try:
         doctest = sys.modules['doctest']

From a8e7633f583a7c11397152d13674d63fe334daf3 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:51:28 -0500
Subject: [PATCH 222/418] Disable saved_test_environment context manager

---
 Lib/test/libregrtest/single.py | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/Lib/test/libregrtest/single.py b/Lib/test/libregrtest/single.py
index 8fc852f86b4..84c92dcfe77 100644
--- a/Lib/test/libregrtest/single.py
+++ b/Lib/test/libregrtest/single.py
@@ -1,5 +1,5 @@
 import faulthandler
-import gc
+# import gc  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
 import importlib
 import io
 import sys
@@ -145,15 +145,15 @@ def test_func():
 
         remove_testfn(test_name, runtests.verbose)
 
-    if gc.garbage:
-        support.environment_altered = True
-        print_warning(f"{test_name} created {len(gc.garbage)} "
-                      f"uncollectable object(s)")
+    # if gc.garbage:  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     support.environment_altered = True  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     print_warning(f"{test_name} created {len(gc.garbage)} "  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #                   f"uncollectable object(s)")  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
 
-        # move the uncollectable objects somewhere,
-        # so we don't see them again
-        GC_GARBAGE.extend(gc.garbage)
-        gc.garbage.clear()
+    #     # move the uncollectable objects somewhere,  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     # so we don't see them again  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     GC_GARBAGE.extend(gc.garbage)  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     gc.garbage.clear()  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
 
     support.reap_children()
 
@@ -176,9 +176,10 @@ def _runtest_env_changed_exc(result: TestResult, runtests: RunTests,
         clear_caches()
         support.gc_collect()
 
-        with saved_test_environment(test_name,
-                                    runtests.verbose, quiet, pgo=pgo):
-            _load_run_test(result, runtests)
+        # with saved_test_environment(test_name,  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+        #                             runtests.verbose, quiet, pgo=pgo):  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+        #     _load_run_test(result, runtests)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+        _load_run_test(result, runtests)
     except support.ResourceDenied as exc:
         if not quiet and not pgo:
             print(f"{test_name} skipped -- {exc}", flush=True)

From e4fb263788ac0db6fa590304a9232c6d1176898e Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 4 Dec 2025 21:52:45 -0500
Subject: [PATCH 223/418] Disable support.record_original_stdout()

---
 Lib/test/libregrtest/setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Lib/test/libregrtest/setup.py b/Lib/test/libregrtest/setup.py
index d50b2155a6b..82dbf3855e4 100644
--- a/Lib/test/libregrtest/setup.py
+++ b/Lib/test/libregrtest/setup.py
@@ -54,7 +54,7 @@ def setup_process() -> None:
 
     adjust_rlimit_nofile()
 
-    support.record_original_stdout(sys.stdout)
+    # support.record_original_stdout(sys.stdout)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
 
     # Set sys.stdout encoder error handler to backslashreplace,
     # similar to sys.stderr error handler, to avoid UnicodeEncodeError

From 32fd6bec491f47cb50b50ccae95ce1e7729918a1 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Tue, 30 Dec 2025 20:53:40 -0500
Subject: [PATCH 224/418] Update test/test_regrtest.py to CPython 3.13.11

---
 Lib/test/test_regrtest.py | 1821 +++++++++++++++++++++++++++++++------
 1 file changed, 1561 insertions(+), 260 deletions(-)

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index d9ae2f35487..a95a13436fc 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -5,28 +5,57 @@
 """
 
 import contextlib
-import faulthandler
+import dataclasses
 import glob
 import io
+import locale
 import os.path
 import platform
+import random
 import re
+import shlex
+import signal
 import subprocess
 import sys
 import sysconfig
 import tempfile
 import textwrap
 import unittest
-from test import libregrtest
+from xml.etree import ElementTree
+
 from test import support
-from test.support import os_helper
+from test.support import os_helper, without_optimizer
+from test.libregrtest import cmdline
+from test.libregrtest import main
+from test.libregrtest import setup
 from test.libregrtest import utils
+from test.libregrtest.filter import get_match_tests, set_match_tests, match_test
+from test.libregrtest.result import TestStats
+from test.libregrtest.utils import normalize_test_name
 
+if not support.has_subprocess_support:
+    raise unittest.SkipTest("test module requires subprocess")
 
-Py_DEBUG = hasattr(sys, 'gettotalrefcount')
 ROOT_DIR = os.path.join(os.path.dirname(__file__), '..', '..')
 ROOT_DIR = os.path.abspath(os.path.normpath(ROOT_DIR))
 LOG_PREFIX = r'[0-9]+:[0-9]+:[0-9]+ (?:load avg: [0-9]+\.[0-9]{2} )?'
+RESULT_REGEX = (
+    'passed',
+    'failed',
+    'skipped',
+    'interrupted',
+    'env changed',
+    'timed out',
+    'ran no tests',
+    'worker non-zero exit code',
+)
+RESULT_REGEX = fr'(?:{"|".join(RESULT_REGEX)})'
+
+EXITCODE_BAD_TEST = 2
+EXITCODE_ENV_CHANGED = 3
+EXITCODE_NO_TESTS_RAN = 4
+EXITCODE_RERUN_FAIL = 5
+EXITCODE_INTERRUPTED = 130
 
 TEST_INTERRUPTED = textwrap.dedent("""
     from signal import SIGINT, raise_signal
@@ -43,9 +72,13 @@ class ParseArgsTestCase(unittest.TestCase):
     Test regrtest's argument parsing, function _parse_args().
     """
 
+    @staticmethod
+    def parse_args(args):
+        return cmdline._parse_args(args)
+
     def checkError(self, args, msg):
         with support.captured_stderr() as err, self.assertRaises(SystemExit):
-            libregrtest._parse_args(args)
+            self.parse_args(args)
         self.assertIn(msg, err.getvalue())
 
     def test_help(self):
@@ -53,94 +86,130 @@ def test_help(self):
             with self.subTest(opt=opt):
                 with support.captured_stdout() as out, \
                      self.assertRaises(SystemExit):
-                    libregrtest._parse_args([opt])
+                    self.parse_args([opt])
                 self.assertIn('Run Python regression tests.', out.getvalue())
 
-    @unittest.skipUnless(hasattr(faulthandler, 'dump_traceback_later'),
-                         "faulthandler.dump_traceback_later() required")
     def test_timeout(self):
-        ns = libregrtest._parse_args(['--timeout', '4.2'])
+        ns = self.parse_args(['--timeout', '4.2'])
         self.assertEqual(ns.timeout, 4.2)
+
+        # negative, zero and empty string are treated as "no timeout"
+        for value in ('-1', '0', ''):
+            with self.subTest(value=value):
+                ns = self.parse_args([f'--timeout={value}'])
+                self.assertEqual(ns.timeout, None)
+
         self.checkError(['--timeout'], 'expected one argument')
-        self.checkError(['--timeout', 'foo'], 'invalid float value')
+        self.checkError(['--timeout', 'foo'], 'invalid timeout value:')
 
     def test_wait(self):
-        ns = libregrtest._parse_args(['--wait'])
+        ns = self.parse_args(['--wait'])
         self.assertTrue(ns.wait)
 
-    def test_worker_args(self):
-        ns = libregrtest._parse_args(['--worker-args', '[[], {}]'])
-        self.assertEqual(ns.worker_args, '[[], {}]')
-        self.checkError(['--worker-args'], 'expected one argument')
-
     def test_start(self):
         for opt in '-S', '--start':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.start, 'foo')
                 self.checkError([opt], 'expected one argument')
 
     def test_verbose(self):
-        ns = libregrtest._parse_args(['-v'])
+        ns = self.parse_args(['-v'])
         self.assertEqual(ns.verbose, 1)
-        ns = libregrtest._parse_args(['-vvv'])
+        ns = self.parse_args(['-vvv'])
         self.assertEqual(ns.verbose, 3)
-        ns = libregrtest._parse_args(['--verbose'])
+        ns = self.parse_args(['--verbose'])
         self.assertEqual(ns.verbose, 1)
-        ns = libregrtest._parse_args(['--verbose'] * 3)
+        ns = self.parse_args(['--verbose'] * 3)
         self.assertEqual(ns.verbose, 3)
-        ns = libregrtest._parse_args([])
+        ns = self.parse_args([])
         self.assertEqual(ns.verbose, 0)
 
-    def test_verbose2(self):
-        for opt in '-w', '--verbose2':
+    def test_rerun(self):
+        for opt in '-w', '--rerun', '--verbose2':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
-                self.assertTrue(ns.verbose2)
+                ns = self.parse_args([opt])
+                self.assertTrue(ns.rerun)
 
     def test_verbose3(self):
         for opt in '-W', '--verbose3':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.verbose3)
 
     def test_quiet(self):
         for opt in '-q', '--quiet':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.quiet)
                 self.assertEqual(ns.verbose, 0)
 
     def test_slowest(self):
         for opt in '-o', '--slowest':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.print_slow)
 
     def test_header(self):
-        ns = libregrtest._parse_args(['--header'])
+        ns = self.parse_args(['--header'])
         self.assertTrue(ns.header)
 
-        ns = libregrtest._parse_args(['--verbose'])
+        ns = self.parse_args(['--verbose'])
         self.assertTrue(ns.header)
 
     def test_randomize(self):
-        for opt in '-r', '--randomize':
+        for opt in ('-r', '--randomize'):
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.randomize)
 
+        with os_helper.EnvironmentVarGuard() as env:
+            # with SOURCE_DATE_EPOCH
+            env['SOURCE_DATE_EPOCH'] = '1697839080'
+            ns = self.parse_args(['--randomize'])
+            regrtest = main.Regrtest(ns)
+            self.assertFalse(regrtest.randomize)
+            self.assertIsInstance(regrtest.random_seed, str)
+            self.assertEqual(regrtest.random_seed, '1697839080')
+
+            # without SOURCE_DATE_EPOCH
+            del env['SOURCE_DATE_EPOCH']
+            ns = self.parse_args(['--randomize'])
+            regrtest = main.Regrtest(ns)
+            self.assertTrue(regrtest.randomize)
+            self.assertIsInstance(regrtest.random_seed, int)
+
+    def test_no_randomize(self):
+        ns = self.parse_args([])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--randomize"])
+        self.assertIs(ns.randomize, True)
+
+        ns = self.parse_args(["--no-randomize"])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--randomize", "--no-randomize"])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--no-randomize", "--randomize"])
+        self.assertIs(ns.randomize, False)
+
     def test_randseed(self):
-        ns = libregrtest._parse_args(['--randseed', '12345'])
+        ns = self.parse_args(['--randseed', '12345'])
         self.assertEqual(ns.random_seed, 12345)
         self.assertTrue(ns.randomize)
         self.checkError(['--randseed'], 'expected one argument')
         self.checkError(['--randseed', 'foo'], 'invalid int value')
 
+        ns = self.parse_args(['--randseed', '12345', '--no-randomize'])
+        self.assertEqual(ns.random_seed, 12345)
+        self.assertFalse(ns.randomize)
+
     def test_fromfile(self):
         for opt in '-f', '--fromfile':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.fromfile, 'foo')
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo', '-s'], "don't go together")
@@ -148,46 +217,37 @@ def test_fromfile(self):
     def test_exclude(self):
         for opt in '-x', '--exclude':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.exclude)
 
     def test_single(self):
         for opt in '-s', '--single':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.single)
                 self.checkError([opt, '-f', 'foo'], "don't go together")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_ignore(self):
-        for opt in '-i', '--ignore':
+    def test_match(self):
+        for opt in '-m', '--match':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'pattern'])
-                self.assertEqual(ns.ignore_tests, ['pattern'])
+                ns = self.parse_args([opt, 'pattern'])
+                self.assertEqual(ns.match_tests, [('pattern', True)])
                 self.checkError([opt], 'expected one argument')
 
-        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
-        with open(os_helper.TESTFN, "w") as fp:
-            print('matchfile1', file=fp)
-            print('matchfile2', file=fp)
-
-        filename = os.path.abspath(os_helper.TESTFN)
-        ns = libregrtest._parse_args(['-m', 'match',
-                                      '--ignorefile', filename])
-        self.assertEqual(ns.ignore_tests,
-                         ['matchfile1', 'matchfile2'])
-
-    def test_match(self):
-        for opt in '-m', '--match':
+        for opt in '-i', '--ignore':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'pattern'])
-                self.assertEqual(ns.match_tests, ['pattern'])
+                ns = self.parse_args([opt, 'pattern'])
+                self.assertEqual(ns.match_tests, [('pattern', False)])
                 self.checkError([opt], 'expected one argument')
 
-        ns = libregrtest._parse_args(['-m', 'pattern1',
-                                      '-m', 'pattern2'])
-        self.assertEqual(ns.match_tests, ['pattern1', 'pattern2'])
+        ns = self.parse_args(['-m', 'pattern1', '-m', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', True), ('pattern2', True)])
+
+        ns = self.parse_args(['-m', 'pattern1', '-i', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', True), ('pattern2', False)])
+
+        ns = self.parse_args(['-i', 'pattern1', '-m', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', False), ('pattern2', True)])
 
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         with open(os_helper.TESTFN, "w") as fp:
@@ -195,73 +255,76 @@ def test_match(self):
             print('matchfile2', file=fp)
 
         filename = os.path.abspath(os_helper.TESTFN)
-        ns = libregrtest._parse_args(['-m', 'match',
-                                      '--matchfile', filename])
+        ns = self.parse_args(['-m', 'match', '--matchfile', filename])
+        self.assertEqual(ns.match_tests,
+                         [('match', True), ('matchfile1', True), ('matchfile2', True)])
+
+        ns = self.parse_args(['-i', 'match', '--ignorefile', filename])
         self.assertEqual(ns.match_tests,
-                         ['match', 'matchfile1', 'matchfile2'])
+                         [('match', False), ('matchfile1', False), ('matchfile2', False)])
 
     def test_failfast(self):
         for opt in '-G', '--failfast':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '-v'])
+                ns = self.parse_args([opt, '-v'])
                 self.assertTrue(ns.failfast)
-                ns = libregrtest._parse_args([opt, '-W'])
+                ns = self.parse_args([opt, '-W'])
                 self.assertTrue(ns.failfast)
                 self.checkError([opt], '-G/--failfast needs either -v or -W')
 
     def test_use(self):
         for opt in '-u', '--use':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'gui,network'])
+                ns = self.parse_args([opt, 'gui,network'])
                 self.assertEqual(ns.use_resources, ['gui', 'network'])
 
-                ns = libregrtest._parse_args([opt, 'gui,none,network'])
+                ns = self.parse_args([opt, 'gui,none,network'])
                 self.assertEqual(ns.use_resources, ['network'])
 
-                expected = list(libregrtest.ALL_RESOURCES)
+                expected = list(cmdline.ALL_RESOURCES)
                 expected.remove('gui')
-                ns = libregrtest._parse_args([opt, 'all,-gui'])
+                ns = self.parse_args([opt, 'all,-gui'])
                 self.assertEqual(ns.use_resources, expected)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid resource')
 
                 # all + a resource not part of "all"
-                ns = libregrtest._parse_args([opt, 'all,tzdata'])
+                ns = self.parse_args([opt, 'all,tzdata'])
                 self.assertEqual(ns.use_resources,
-                                 list(libregrtest.ALL_RESOURCES) + ['tzdata'])
+                                 list(cmdline.ALL_RESOURCES) + ['tzdata'])
 
                 # test another resource which is not part of "all"
-                ns = libregrtest._parse_args([opt, 'extralargefile'])
+                ns = self.parse_args([opt, 'extralargefile'])
                 self.assertEqual(ns.use_resources, ['extralargefile'])
 
     def test_memlimit(self):
         for opt in '-M', '--memlimit':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '4G'])
+                ns = self.parse_args([opt, '4G'])
                 self.assertEqual(ns.memlimit, '4G')
                 self.checkError([opt], 'expected one argument')
 
     def test_testdir(self):
-        ns = libregrtest._parse_args(['--testdir', 'foo'])
+        ns = self.parse_args(['--testdir', 'foo'])
         self.assertEqual(ns.testdir, os.path.join(os_helper.SAVEDCWD, 'foo'))
         self.checkError(['--testdir'], 'expected one argument')
 
     def test_runleaks(self):
         for opt in '-L', '--runleaks':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.runleaks)
 
     def test_huntrleaks(self):
         for opt in '-R', '--huntrleaks':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, ':'])
+                ns = self.parse_args([opt, ':'])
                 self.assertEqual(ns.huntrleaks, (5, 4, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, '6:'])
+                ns = self.parse_args([opt, '6:'])
                 self.assertEqual(ns.huntrleaks, (6, 4, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, ':3'])
+                ns = self.parse_args([opt, ':3'])
                 self.assertEqual(ns.huntrleaks, (5, 3, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, '6:3:leaks.log'])
+                ns = self.parse_args([opt, '6:3:leaks.log'])
                 self.assertEqual(ns.huntrleaks, (6, 3, 'leaks.log'))
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, '6'],
@@ -272,23 +335,33 @@ def test_huntrleaks(self):
     def test_multiprocess(self):
         for opt in '-j', '--multiprocess':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '2'])
+                ns = self.parse_args([opt, '2'])
                 self.assertEqual(ns.use_mp, 2)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
-                self.checkError([opt, '2', '-T'], "don't go together")
-                self.checkError([opt, '0', '-T'], "don't go together")
 
-    def test_coverage(self):
+    def test_coverage_sequential(self):
+        for opt in '-T', '--coverage':
+            with self.subTest(opt=opt):
+                with support.captured_stderr() as stderr:
+                    ns = self.parse_args([opt])
+                self.assertTrue(ns.trace)
+                self.assertIn(
+                    "collecting coverage without -j is imprecise",
+                    stderr.getvalue(),
+                )
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def test_coverage_mp(self):
         for opt in '-T', '--coverage':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt, '-j1'])
                 self.assertTrue(ns.trace)
 
     def test_coverdir(self):
         for opt in '-D', '--coverdir':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.coverdir,
                                  os.path.join(os_helper.SAVEDCWD, 'foo'))
                 self.checkError([opt], 'expected one argument')
@@ -296,13 +369,13 @@ def test_coverdir(self):
     def test_nocoverdir(self):
         for opt in '-N', '--nocoverdir':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertIsNone(ns.coverdir)
 
     def test_threshold(self):
         for opt in '-t', '--threshold':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '1000'])
+                ns = self.parse_args([opt, '1000'])
                 self.assertEqual(ns.threshold, 1000)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
@@ -311,7 +384,7 @@ def test_nowindows(self):
         for opt in '-n', '--nowindows':
             with self.subTest(opt=opt):
                 with contextlib.redirect_stderr(io.StringIO()) as stderr:
-                    ns = libregrtest._parse_args([opt])
+                    ns = self.parse_args([opt])
                 self.assertTrue(ns.nowindows)
                 err = stderr.getvalue()
                 self.assertIn('the --nowindows (-n) option is deprecated', err)
@@ -319,39 +392,39 @@ def test_nowindows(self):
     def test_forever(self):
         for opt in '-F', '--forever':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.forever)
 
     def test_unrecognized_argument(self):
         self.checkError(['--xxx'], 'usage:')
 
     def test_long_option__partial(self):
-        ns = libregrtest._parse_args(['--qui'])
+        ns = self.parse_args(['--qui'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
 
     def test_two_options(self):
-        ns = libregrtest._parse_args(['--quiet', '--exclude'])
+        ns = self.parse_args(['--quiet', '--exclude'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertTrue(ns.exclude)
 
     def test_option_with_empty_string_value(self):
-        ns = libregrtest._parse_args(['--start', ''])
+        ns = self.parse_args(['--start', ''])
         self.assertEqual(ns.start, '')
 
     def test_arg(self):
-        ns = libregrtest._parse_args(['foo'])
+        ns = self.parse_args(['foo'])
         self.assertEqual(ns.args, ['foo'])
 
     def test_option_and_arg(self):
-        ns = libregrtest._parse_args(['--quiet', 'foo'])
+        ns = self.parse_args(['--quiet', 'foo'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertEqual(ns.args, ['foo'])
 
     def test_arg_option_arg(self):
-        ns = libregrtest._parse_args(['test_unaryop', '-v', 'test_binop'])
+        ns = self.parse_args(['test_unaryop', '-v', 'test_binop'])
         self.assertEqual(ns.verbose, 1)
         self.assertEqual(ns.args, ['test_unaryop', 'test_binop'])
 
@@ -359,6 +432,118 @@ def test_unknown_option(self):
         self.checkError(['--unknown-option'],
                         'unrecognized arguments: --unknown-option')
 
+    def create_regrtest(self, args):
+        ns = cmdline._parse_args(args)
+
+        # Check Regrtest attributes which are more reliable than Namespace
+        # which has an unclear API
+        with os_helper.EnvironmentVarGuard() as env:
+            # Ignore SOURCE_DATE_EPOCH env var if it's set
+            del env['SOURCE_DATE_EPOCH']
+
+            regrtest = main.Regrtest(ns)
+
+        return regrtest
+
+    def check_ci_mode(self, args, use_resources,
+                      *, rerun=True, randomize=True, output_on_failure=True):
+        regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, -1)
+        self.assertEqual(regrtest.want_rerun, rerun)
+        self.assertEqual(regrtest.fail_rerun, False)
+        self.assertEqual(regrtest.randomize, randomize)
+        self.assertIsInstance(regrtest.random_seed, int)
+        self.assertTrue(regrtest.fail_env_changed)
+        self.assertTrue(regrtest.print_slowest)
+        self.assertEqual(regrtest.output_on_failure, output_on_failure)
+        self.assertEqual(sorted(regrtest.use_resources), sorted(use_resources))
+        return regrtest
+
+    def test_fast_ci(self):
+        args = ['--fast-ci']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources)
+        self.assertEqual(regrtest.timeout, 10 * 60)
+
+    def test_fast_ci_python_cmd(self):
+        args = ['--fast-ci', '--python', 'python -X dev']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources, rerun=False)
+        self.assertEqual(regrtest.timeout, 10 * 60)
+        self.assertEqual(regrtest.python_cmd, ('python', '-X', 'dev'))
+
+    def test_fast_ci_resource(self):
+        # it should be possible to override resources individually
+        args = ['--fast-ci', '-u-network']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        use_resources.remove('network')
+        self.check_ci_mode(args, use_resources)
+
+    def test_fast_ci_verbose(self):
+        args = ['--fast-ci', '--verbose']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources,
+                                      output_on_failure=False)
+        self.assertEqual(regrtest.verbose, True)
+
+    def test_slow_ci(self):
+        args = ['--slow-ci']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        regrtest = self.check_ci_mode(args, use_resources)
+        self.assertEqual(regrtest.timeout, 20 * 60)
+
+    def test_ci_no_randomize(self):
+        all_resources = set(cmdline.ALL_RESOURCES)
+        self.check_ci_mode(
+            ["--slow-ci", "--no-randomize"], all_resources, randomize=False
+        )
+        self.check_ci_mode(
+            ["--fast-ci", "--no-randomize"], all_resources - {'cpu'}, randomize=False
+        )
+
+    def test_dont_add_python_opts(self):
+        args = ['--dont-add-python-opts']
+        ns = cmdline._parse_args(args)
+        self.assertFalse(ns._add_python_opts)
+
+    def test_bisect(self):
+        args = ['--bisect']
+        regrtest = self.create_regrtest(args)
+        self.assertTrue(regrtest.want_bisect)
+
+    def test_verbose3_huntrleaks(self):
+        args = ['-R', '3:10', '--verbose3']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertIsNotNone(regrtest.hunt_refleak)
+        self.assertEqual(regrtest.hunt_refleak.warmups, 3)
+        self.assertEqual(regrtest.hunt_refleak.runs, 10)
+        self.assertFalse(regrtest.output_on_failure)
+
+    def test_single_process(self):
+        args = ['-j2', '--single-process']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, 0)
+        self.assertTrue(regrtest.single_process)
+
+        args = ['--fast-ci', '--single-process']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, 0)
+        self.assertTrue(regrtest.single_process)
+
+
+@dataclasses.dataclass(slots=True)
+class Rerun:
+    name: str
+    match: str | None
+    success: bool
+
 
 class BaseTestCase(unittest.TestCase):
     TEST_UNIQUE_ID = 1
@@ -407,41 +592,61 @@ def regex_search(self, regex, output):
             self.fail("%r not found in %r" % (regex, output))
         return match
 
-    def check_line(self, output, regex):
-        regex = re.compile(r'^' + regex, re.MULTILINE)
+    def check_line(self, output, pattern, full=False, regex=True):
+        if not regex:
+            pattern = re.escape(pattern)
+        if full:
+            pattern += '\n'
+        regex = re.compile(r'^' + pattern, re.MULTILINE)
         self.assertRegex(output, regex)
 
     def parse_executed_tests(self, output):
-        regex = (r'^%s\[ *[0-9]+(?:/ *[0-9]+)*\] (%s)'
-                 % (LOG_PREFIX, self.TESTNAME_REGEX))
+        regex = (fr'^{LOG_PREFIX}\[ *[0-9]+(?:/ *[0-9]+)*\] '
+                 fr'({self.TESTNAME_REGEX}) {RESULT_REGEX}')
         parser = re.finditer(regex, output, re.MULTILINE)
         return list(match.group(1) for match in parser)
 
-    def check_executed_tests(self, output, tests, skipped=(), failed=(),
+    def check_executed_tests(self, output, tests, *, stats,
+                             skipped=(), failed=(),
                              env_changed=(), omitted=(),
-                             rerun=(), no_test_ran=(),
-                             randomize=False, interrupted=False,
-                             fail_env_changed=False):
+                             rerun=None, run_no_tests=(),
+                             resource_denied=(),
+                             randomize=False, parallel=False, interrupted=False,
+                             fail_env_changed=False,
+                             forever=False, filtered=False):
         if isinstance(tests, str):
             tests = [tests]
         if isinstance(skipped, str):
             skipped = [skipped]
+        if isinstance(resource_denied, str):
+            resource_denied = [resource_denied]
         if isinstance(failed, str):
             failed = [failed]
         if isinstance(env_changed, str):
             env_changed = [env_changed]
         if isinstance(omitted, str):
             omitted = [omitted]
-        if isinstance(rerun, str):
-            rerun = [rerun]
-        if isinstance(no_test_ran, str):
-            no_test_ran = [no_test_ran]
+        if isinstance(run_no_tests, str):
+            run_no_tests = [run_no_tests]
+        if isinstance(stats, int):
+            stats = TestStats(stats)
+        if parallel:
+            randomize = True
+
+        rerun_failed = []
+        if rerun is not None and not env_changed:
+            failed = [rerun.name]
+            if not rerun.success:
+                rerun_failed.append(rerun.name)
 
         executed = self.parse_executed_tests(output)
+        total_tests = list(tests)
+        if rerun is not None:
+            total_tests.append(rerun.name)
         if randomize:
-            self.assertEqual(set(executed), set(tests), output)
+            self.assertEqual(set(executed), set(total_tests), output)
         else:
-            self.assertEqual(executed, tests, output)
+            self.assertEqual(executed, total_tests, output)
 
         def plural(count):
             return 's' if count != 1 else ''
@@ -457,12 +662,17 @@ def list_regex(line_format, tests):
             regex = list_regex('%s test%s skipped', skipped)
             self.check_line(output, regex)
 
+        if resource_denied:
+            regex = list_regex(r'%s test%s skipped \(resource denied\)', resource_denied)
+            self.check_line(output, regex)
+
         if failed:
             regex = list_regex('%s test%s failed', failed)
             self.check_line(output, regex)
 
         if env_changed:
-            regex = list_regex('%s test%s altered the execution environment',
+            regex = list_regex(r'%s test%s altered the execution environment '
+                               r'\(env changed\)',
                                env_changed)
             self.check_line(output, regex)
 
@@ -470,73 +680,120 @@ def list_regex(line_format, tests):
             regex = list_regex('%s test%s omitted', omitted)
             self.check_line(output, regex)
 
-        if rerun:
-            regex = list_regex('%s re-run test%s', rerun)
+        if rerun is not None:
+            regex = list_regex('%s re-run test%s', [rerun.name])
             self.check_line(output, regex)
-            regex = LOG_PREFIX + r"Re-running failed tests in verbose mode"
+            regex = LOG_PREFIX + r"Re-running 1 failed tests in verbose mode"
+            self.check_line(output, regex)
+            regex = fr"Re-running {rerun.name} in verbose mode"
+            if rerun.match:
+                regex = fr"{regex} \(matching: {rerun.match}\)"
             self.check_line(output, regex)
-            for test_name in rerun:
-                regex = LOG_PREFIX + f"Re-running {test_name} in verbose mode"
-                self.check_line(output, regex)
 
-        if no_test_ran:
-            regex = list_regex('%s test%s run no tests', no_test_ran)
+        if run_no_tests:
+            regex = list_regex('%s test%s run no tests', run_no_tests)
             self.check_line(output, regex)
 
-        good = (len(tests) - len(skipped) - len(failed)
-                - len(omitted) - len(env_changed) - len(no_test_ran))
+        good = (len(tests) - len(skipped) - len(resource_denied) - len(failed)
+                - len(omitted) - len(env_changed) - len(run_no_tests))
         if good:
-            regex = r'%s test%s OK\.$' % (good, plural(good))
-            if not skipped and not failed and good > 1:
+            regex = r'%s test%s OK\.' % (good, plural(good))
+            if not skipped and not failed and (rerun is None or rerun.success) and good > 1:
                 regex = 'All %s' % regex
-            self.check_line(output, regex)
+            self.check_line(output, regex, full=True)
 
         if interrupted:
             self.check_line(output, 'Test suite interrupted by signal SIGINT.')
 
-        result = []
+        # Total tests
+        text = f'run={stats.tests_run:,}'
+        if filtered:
+            text = fr'{text} \(filtered\)'
+        parts = [text]
+        if stats.failures:
+            parts.append(f'failures={stats.failures:,}')
+        if stats.skipped:
+            parts.append(f'skipped={stats.skipped:,}')
+        line = fr'Total tests: {" ".join(parts)}'
+        self.check_line(output, line, full=True)
+
+        # Total test files
+        run = len(total_tests) - len(resource_denied)
+        if rerun is not None:
+            total_failed = len(rerun_failed)
+            total_rerun = 1
+        else:
+            total_failed = len(failed)
+            total_rerun = 0
+        if interrupted:
+            run = 0
+        text = f'run={run}'
+        if not forever:
+            text = f'{text}/{len(tests)}'
+        if filtered:
+            text = fr'{text} \(filtered\)'
+        report = [text]
+        for name, ntest in (
+            ('failed', total_failed),
+            ('env_changed', len(env_changed)),
+            ('skipped', len(skipped)),
+            ('resource_denied', len(resource_denied)),
+            ('rerun', total_rerun),
+            ('run_no_tests', len(run_no_tests)),
+        ):
+            if ntest:
+                report.append(f'{name}={ntest}')
+        line = fr'Total test files: {" ".join(report)}'
+        self.check_line(output, line, full=True)
+
+        # Result
+        state = []
         if failed:
-            result.append('FAILURE')
+            state.append('FAILURE')
         elif fail_env_changed and env_changed:
-            result.append('ENV CHANGED')
+            state.append('ENV CHANGED')
         if interrupted:
-            result.append('INTERRUPTED')
-        if not any((good, result, failed, interrupted, skipped,
+            state.append('INTERRUPTED')
+        if not any((good, failed, interrupted, skipped,
                     env_changed, fail_env_changed)):
-            result.append("NO TEST RUN")
-        elif not result:
-            result.append('SUCCESS')
-        result = ', '.join(result)
-        if rerun:
-            self.check_line(output, 'Tests result: FAILURE')
-            result = 'FAILURE then %s' % result
-
-        self.check_line(output, 'Tests result: %s' % result)
-
-    def parse_random_seed(self, output):
-        match = self.regex_search(r'Using random seed ([0-9]+)', output)
-        randseed = int(match.group(1))
-        self.assertTrue(0 <= randseed <= 10000000, randseed)
-        return randseed
+            state.append("NO TESTS RAN")
+        elif not state:
+            state.append('SUCCESS')
+        state = ', '.join(state)
+        if rerun is not None:
+            new_state = 'SUCCESS' if rerun.success else 'FAILURE'
+            state = f'{state} then {new_state}'
+        self.check_line(output, f'Result: {state}', full=True)
+
+    def parse_random_seed(self, output: str) -> str:
+        match = self.regex_search(r'Using random seed: (.*)', output)
+        return match.group(1)
 
     def run_command(self, args, input=None, exitcode=0, **kw):
         if not input:
             input = ''
         if 'stderr' not in kw:
-            kw['stderr'] = subprocess.PIPE
+            kw['stderr'] = subprocess.STDOUT
+
+        env = kw.pop('env', None)
+        if env is None:
+            env = dict(os.environ)
+            env.pop('SOURCE_DATE_EPOCH', None)
+
         proc = subprocess.run(args,
-                              universal_newlines=True,
+                              text=True,
                               input=input,
                               stdout=subprocess.PIPE,
+                              env=env,
                               **kw)
         if proc.returncode != exitcode:
-            msg = ("Command %s failed with exit code %s\n"
+            msg = ("Command %s failed with exit code %s, but exit code %s expected!\n"
                    "\n"
                    "stdout:\n"
                    "---\n"
                    "%s\n"
                    "---\n"
-                   % (str(args), proc.returncode, proc.stdout))
+                   % (str(args), proc.returncode, exitcode, proc.stdout))
             if proc.stderr:
                 msg += ("\n"
                         "stderr:\n"
@@ -547,18 +804,24 @@ def run_command(self, args, input=None, exitcode=0, **kw):
             self.fail(msg)
         return proc
 
-    def run_python(self, args, **kw):
-        args = [sys.executable, '-X', 'faulthandler', '-I', *args]
-        proc = self.run_command(args, **kw)
+    def run_python(self, args, isolated=True, **kw):
+        extraargs = []
+        if 'uops' in sys._xoptions:
+            # Pass -X uops along
+            extraargs.extend(['-X', 'uops'])
+        cmd = [sys.executable, *extraargs, '-X', 'faulthandler']
+        if isolated:
+            cmd.append('-I')
+        cmd.extend(args)
+        proc = self.run_command(cmd, **kw)
         return proc.stdout
 
 
 class CheckActualTests(BaseTestCase):
-    """
-    Check that regrtest appears to find the expected set of tests.
-    """
-
     def test_finds_expected_number_of_tests(self):
+        """
+        Check that regrtest appears to find the expected set of tests.
+        """
         args = ['-Wd', '-E', '-bb', '-m', 'test.regrtest', '--list-tests']
         output = self.run_python(args)
         rough_number_of_tests_found = len(output.splitlines())
@@ -578,6 +841,7 @@ def test_finds_expected_number_of_tests(self):
                            f'{", ".join(output.splitlines())}')
 
 
+@support.force_not_colorized_test_class
 class ProgramsTestCase(BaseTestCase):
     """
     Test various ways to run the Python test suite. Use options close
@@ -595,17 +859,19 @@ def setUp(self):
         self.python_args = ['-Wd', '-E', '-bb']
         self.regrtest_args = ['-uall', '-rwW',
                               '--testdir=%s' % self.tmptestdir]
-        if hasattr(faulthandler, 'dump_traceback_later'):
-            self.regrtest_args.extend(('--timeout', '3600', '-j4'))
+        self.regrtest_args.extend(('--timeout', '3600', '-j4'))
         if sys.platform == 'win32':
             self.regrtest_args.append('-n')
 
     def check_output(self, output):
-        self.parse_random_seed(output)
-        self.check_executed_tests(output, self.tests, randomize=True)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
 
-    def run_tests(self, args):
-        output = self.run_python(args)
+        self.check_executed_tests(output, self.tests,
+                                  randomize=True, stats=len(self.tests))
+
+    def run_tests(self, args, env=None, isolated=True):
+        output = self.run_python(args, env=env, isolated=isolated)
         self.check_output(output)
 
     def test_script_regrtest(self):
@@ -627,16 +893,12 @@ def test_module_regrtest(self):
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_module_autotest(self):
         # -m test.autotest
         args = [*self.python_args, '-m', 'test.autotest',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_module_from_test_autotest(self):
         # from test import autotest
         code = 'from test import autotest'
@@ -644,24 +906,17 @@ def test_module_from_test_autotest(self):
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_script_autotest(self):
         # Lib/test/autotest.py
         script = os.path.join(self.testdir, 'autotest.py')
         args = [*self.python_args, script, *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    @unittest.skipUnless(sysconfig.is_python_build(),
-                         'run_tests.py script is not installed')
-    def test_tools_script_run_tests(self):
-        # Tools/scripts/run_tests.py
-        script = os.path.join(ROOT_DIR, 'Tools', 'scripts', 'run_tests.py')
-        args = [script, *self.regrtest_args, *self.tests]
-        self.run_tests(args)
-
     def run_batch(self, *args):
-        proc = self.run_command(args)
+        proc = self.run_command(args,
+                                # gh-133711: cmd.exe uses the OEM code page
+                                # to display the non-ASCII current directory
+                                errors="backslashreplace")
         self.check_output(proc.stdout)
 
     @unittest.skipUnless(sysconfig.is_python_build(),
@@ -673,10 +928,14 @@ def test_tools_buildbot_test(self):
         test_args = ['--testdir=%s' % self.tmptestdir]
         if platform.machine() == 'ARM64':
             test_args.append('-arm64') # ARM 64-bit build
+        elif platform.machine() == 'ARM':
+            test_args.append('-arm32')   # 32-bit ARM build
         elif platform.architecture()[0] == '64bit':
             test_args.append('-x64')   # 64-bit build
-        if not Py_DEBUG:
+        if not support.Py_DEBUG:
             test_args.append('+d')     # Release build, use python.exe
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            test_args.append('--disable-gil')
         self.run_batch(script, *test_args, *self.tests)
 
     @unittest.skipUnless(sys.platform == 'win32', 'Windows only')
@@ -688,13 +947,18 @@ def test_pcbuild_rt(self):
         rt_args = ["-q"]             # Quick, don't run tests twice
         if platform.machine() == 'ARM64':
             rt_args.append('-arm64') # ARM 64-bit build
+        elif platform.machine() == 'ARM':
+            rt_args.append('-arm32')   # 32-bit ARM build
         elif platform.architecture()[0] == '64bit':
             rt_args.append('-x64')   # 64-bit build
-        if Py_DEBUG:
+        if support.Py_DEBUG:
             rt_args.append('-d')     # Debug build, use python_d.exe
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            rt_args.append('--disable-gil')
         self.run_batch(script, *rt_args, *self.regrtest_args, *self.tests)
 
 
+@support.force_not_colorized_test_class
 class ArgsTestCase(BaseTestCase):
     """
     Test arguments of the Python test suite.
@@ -704,6 +968,40 @@ def run_tests(self, *testargs, **kw):
         cmdargs = ['-m', 'test', '--testdir=%s' % self.tmptestdir, *testargs]
         return self.run_python(cmdargs, **kw)
 
+    def test_success(self):
+        code = textwrap.dedent("""
+            import unittest
+
+            class PassingTests(unittest.TestCase):
+                def test_test1(self):
+                    pass
+
+                def test_test2(self):
+                    pass
+
+                def test_test3(self):
+                    pass
+        """)
+        tests = [self.create_test(f'ok{i}', code=code) for i in range(1, 6)]
+
+        output = self.run_tests(*tests)
+        self.check_executed_tests(output, tests,
+                                  stats=3 * len(tests))
+
+    def test_skip(self):
+        code = textwrap.dedent("""
+            import unittest
+            raise unittest.SkipTest("nope")
+        """)
+        test_ok = self.create_test('ok')
+        test_skip = self.create_test('skip', code=code)
+        tests = [test_ok, test_skip]
+
+        output = self.run_tests(*tests)
+        self.check_executed_tests(output, tests,
+                                  skipped=[test_skip],
+                                  stats=1)
+
     def test_failing_test(self):
         # test a failing test
         code = textwrap.dedent("""
@@ -717,8 +1015,9 @@ def test_failing(self):
         test_failing = self.create_test('failing', code=code)
         tests = [test_ok, test_failing]
 
-        output = self.run_tests(*tests, exitcode=2)
-        self.check_executed_tests(output, tests, failed=test_failing)
+        output = self.run_tests(*tests, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, tests, failed=test_failing,
+                                  stats=TestStats(2, 1))
 
     def test_resources(self):
         # test -u command line option
@@ -737,17 +1036,19 @@ def test_pass(self):
 
         # -u all: 2 resources enabled
         output = self.run_tests('-u', 'all', *test_names)
-        self.check_executed_tests(output, test_names)
+        self.check_executed_tests(output, test_names, stats=2)
 
         # -u audio: 1 resource enabled
         output = self.run_tests('-uaudio', *test_names)
         self.check_executed_tests(output, test_names,
-                                  skipped=tests['network'])
+                                  resource_denied=tests['network'],
+                                  stats=1)
 
         # no option: 0 resources enabled
-        output = self.run_tests(*test_names)
+        output = self.run_tests(*test_names, exitcode=EXITCODE_NO_TESTS_RAN)
         self.check_executed_tests(output, test_names,
-                                  skipped=test_names)
+                                  resource_denied=test_names,
+                                  stats=0)
 
     def test_random(self):
         # test -r and --randseed command line option
@@ -758,13 +1059,14 @@ def test_random(self):
         test = self.create_test('random', code)
 
         # first run to get the output with the random seed
-        output = self.run_tests('-r', test)
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN)
         randseed = self.parse_random_seed(output)
         match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
         test_random = int(match.group(1))
 
         # try to reproduce with the random seed
-        output = self.run_tests('-r', '--randseed=%s' % randseed, test)
+        output = self.run_tests('-r', f'--randseed={randseed}', test,
+                                exitcode=EXITCODE_NO_TESTS_RAN)
         randseed2 = self.parse_random_seed(output)
         self.assertEqual(randseed2, randseed)
 
@@ -772,6 +1074,35 @@ def test_random(self):
         test_random2 = int(match.group(1))
         self.assertEqual(test_random2, test_random)
 
+        # check that random.seed is used by default
+        output = self.run_tests(test, exitcode=EXITCODE_NO_TESTS_RAN)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
+
+        # check SOURCE_DATE_EPOCH (integer)
+        timestamp = '1697839080'
+        env = dict(os.environ, SOURCE_DATE_EPOCH=timestamp)
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertEqual(randseed, timestamp)
+        self.check_line(output, 'TESTRANDOM: 520')
+
+        # check SOURCE_DATE_EPOCH (string)
+        env = dict(os.environ, SOURCE_DATE_EPOCH='XYZ')
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertEqual(randseed, 'XYZ')
+        self.check_line(output, 'TESTRANDOM: 22')
+
+        # check SOURCE_DATE_EPOCH (empty string): ignore the env var
+        env = dict(os.environ, SOURCE_DATE_EPOCH='')
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
+
     def test_fromfile(self):
         # test --fromfile
         tests = [self.create_test() for index in range(5)]
@@ -794,7 +1125,8 @@ def test_fromfile(self):
                 previous = name
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        stats = len(tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format '[2/7] test_opcodes'
         with open(filename, "w") as fp:
@@ -802,7 +1134,7 @@ def test_fromfile(self):
                 print("[%s/%s] %s" % (index, len(tests), name), file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format 'test_opcodes'
         with open(filename, "w") as fp:
@@ -810,7 +1142,7 @@ def test_fromfile(self):
                 print(name, file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format 'Lib/test/test_opcodes.py'
         with open(filename, "w") as fp:
@@ -818,20 +1150,20 @@ def test_fromfile(self):
                 print('Lib/test/%s.py' % name, file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
     def test_interrupted(self):
         code = TEST_INTERRUPTED
         test = self.create_test('sigint', code=code)
-        output = self.run_tests(test, exitcode=130)
+        output = self.run_tests(test, exitcode=EXITCODE_INTERRUPTED)
         self.check_executed_tests(output, test, omitted=test,
-                                  interrupted=True)
+                                  interrupted=True, stats=0)
 
     def test_slowest(self):
         # test --slowest
         tests = [self.create_test() for index in range(3)]
         output = self.run_tests("--slowest", *tests)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=len(tests))
         regex = ('10 slowest tests:\n'
                  '(?:- %s: .*\n){%s}'
                  % (self.TESTNAME_REGEX, len(tests)))
@@ -848,20 +1180,19 @@ def test_slowest_interrupted(self):
                     args = ("--slowest", "-j2", test)
                 else:
                     args = ("--slowest", test)
-                output = self.run_tests(*args, exitcode=130)
+                output = self.run_tests(*args, exitcode=EXITCODE_INTERRUPTED)
                 self.check_executed_tests(output, test,
-                                          omitted=test, interrupted=True)
+                                          omitted=test, interrupted=True,
+                                          stats=0)
 
                 regex = ('10 slowest tests:\n')
                 self.check_line(output, regex)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_coverage(self):
         # test --coverage
         test = self.create_test('coverage')
         output = self.run_tests("--coverage", test)
-        self.check_executed_tests(output, [test])
+        self.check_executed_tests(output, [test], stats=1)
         regex = (r'lines +cov% +module +\(path\)\n'
                  r'(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+')
         self.check_line(output, regex)
@@ -890,21 +1221,39 @@ def test_run(self):
                         builtins.__dict__['RUN'] = 1
         """)
         test = self.create_test('forever', code=code)
-        output = self.run_tests('--forever', test, exitcode=2)
-        self.check_executed_tests(output, [test]*3, failed=test)
 
-    def check_leak(self, code, what):
+        # --forever
+        output = self.run_tests('--forever', test, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, [test]*3, failed=test,
+                                  stats=TestStats(3, 1),
+                                  forever=True)
+
+        # --forever --rerun
+        output = self.run_tests('--forever', '--rerun', test, exitcode=0)
+        self.check_executed_tests(output, [test]*3,
+                                  rerun=Rerun(test,
+                                              match='test_run',
+                                              success=True),
+                                  stats=TestStats(4, 1),
+                                  forever=True)
+
+    @without_optimizer
+    def check_leak(self, code, what, *, run_workers=False):
         test = self.create_test('huntrleaks', code=code)
 
         filename = 'reflog.txt'
         self.addCleanup(os_helper.unlink, filename)
-        output = self.run_tests('--huntrleaks', '3:3:', test,
-                                exitcode=2,
+        cmd = ['--huntrleaks', '3:3:']
+        if run_workers:
+            cmd.append('-j1')
+        cmd.append(test)
+        output = self.run_tests(*cmd,
+                                exitcode=EXITCODE_BAD_TEST,
                                 stderr=subprocess.STDOUT)
-        self.check_executed_tests(output, [test], failed=test)
+        self.check_executed_tests(output, [test], failed=test, stats=1)
 
-        line = 'beginning 6 repetitions\n123456\n......\n'
-        self.check_line(output, re.escape(line))
+        line = r'beginning 6 repetitions. .*\n123:456\n[.0-9X]{3} 111\n'
+        self.check_line(output, line)
 
         line2 = '%s leaked [1, 1, 1] %s, sum=3\n' % (test, what)
         self.assertIn(line2, output)
@@ -913,8 +1262,8 @@ def check_leak(self, code, what):
             reflog = fp.read()
             self.assertIn(line2, reflog)
 
-    @unittest.skipUnless(Py_DEBUG, 'need a debug build')
-    def test_huntrleaks(self):
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def check_huntrleaks(self, *, run_workers: bool):
         # test --huntrleaks
         code = textwrap.dedent("""
             import unittest
@@ -925,9 +1274,56 @@ class RefLeakTest(unittest.TestCase):
                 def test_leak(self):
                     GLOBAL_LIST.append(object())
         """)
-        self.check_leak(code, 'references')
+        self.check_leak(code, 'references', run_workers=run_workers)
+
+    def test_huntrleaks(self):
+        self.check_huntrleaks(run_workers=False)
+
+    def test_huntrleaks_mp(self):
+        self.check_huntrleaks(run_workers=True)
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def test_huntrleaks_bisect(self):
+        # test --huntrleaks --bisect
+        code = textwrap.dedent("""
+            import unittest
+
+            GLOBAL_LIST = []
+
+            class RefLeakTest(unittest.TestCase):
+                def test1(self):
+                    pass
+
+                def test2(self):
+                    pass
+
+                def test3(self):
+                    GLOBAL_LIST.append(object())
+
+                def test4(self):
+                    pass
+        """)
+
+        test = self.create_test('huntrleaks', code=code)
 
-    @unittest.skipUnless(Py_DEBUG, 'need a debug build')
+        filename = 'reflog.txt'
+        self.addCleanup(os_helper.unlink, filename)
+        cmd = ['--huntrleaks', '3:3:', '--bisect', test]
+        output = self.run_tests(*cmd,
+                                exitcode=EXITCODE_BAD_TEST,
+                                stderr=subprocess.STDOUT)
+
+        self.assertIn(f"Bisect {test}", output)
+        self.assertIn(f"Bisect {test}: exit code 0", output)
+
+        # test3 is the one which leaks
+        self.assertIn("Bisection completed in", output)
+        self.assertIn(
+            "Tests (1):\n"
+            f"* {test}.RefLeakTest.test3\n",
+            output)
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
     def test_huntrleaks_fd_leak(self):
         # test --huntrleaks for file descriptor leak
         code = textwrap.dedent("""
@@ -981,16 +1377,14 @@ def test_crashed(self):
         crash_test = self.create_test(name="crash", code=code)
 
         tests = [crash_test]
-        output = self.run_tests("-j2", *tests, exitcode=2)
+        output = self.run_tests("-j2", *tests, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, tests, failed=crash_test,
-                                  randomize=True)
+                                  parallel=True, stats=0)
 
     def parse_methods(self, output):
         regex = re.compile("^(test[^ ]+).*ok$", flags=re.MULTILINE)
         return [match.group(1) for match in regex.finditer(output)]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ignorefile(self):
         code = textwrap.dedent("""
             import unittest
@@ -1005,8 +1399,6 @@ def test_method3(self):
                 def test_method4(self):
                     pass
         """)
-        all_methods = ['test_method1', 'test_method2',
-                       'test_method3', 'test_method4']
         testname = self.create_test(code=code)
 
         # only run a subset
@@ -1068,8 +1460,6 @@ def test_method4(self):
         subset = ['test_method1', 'test_method3']
         self.assertEqual(methods, subset)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_env_changed(self):
         code = textwrap.dedent("""
             import unittest
@@ -1082,52 +1472,265 @@ def test_env_changed(self):
 
         # don't fail by default
         output = self.run_tests(testname)
-        self.check_executed_tests(output, [testname], env_changed=testname)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=testname, stats=1)
 
         # fail with --fail-env-changed
-        output = self.run_tests("--fail-env-changed", testname, exitcode=3)
+        output = self.run_tests("--fail-env-changed", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
         self.check_executed_tests(output, [testname], env_changed=testname,
-                                  fail_env_changed=True)
+                                  fail_env_changed=True, stats=1)
+
+        # rerun
+        output = self.run_tests("--rerun", testname)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=testname,
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=True),
+                                  stats=2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_rerun_fail(self):
         # FAILURE then FAILURE
         code = textwrap.dedent("""
             import unittest
 
             class Tests(unittest.TestCase):
-                def test_bug(self):
-                    # test always fail
+                def test_succeed(self):
+                    return
+
+                def test_fail_always(self):
+                    # test that always fails
                     self.fail("bug")
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-w", testname, exitcode=2)
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  failed=testname, rerun=testname)
+                                  rerun=Rerun(testname,
+                                              "test_fail_always",
+                                              success=False),
+                                  stats=TestStats(3, 2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_rerun_success(self):
         # FAILURE then SUCCESS
-        code = textwrap.dedent("""
-            import builtins
+        marker_filename = os.path.abspath("regrtest_marker_filename")
+        self.addCleanup(os_helper.unlink, marker_filename)
+        self.assertFalse(os.path.exists(marker_filename))
+
+        code = textwrap.dedent(f"""
+            import os.path
             import unittest
 
+            marker_filename = {marker_filename!r}
+
             class Tests(unittest.TestCase):
-                failed = False
+                def test_succeed(self):
+                    return
 
                 def test_fail_once(self):
-                    if not hasattr(builtins, '_test_failed'):
-                        builtins._test_failed = True
+                    if not os.path.exists(marker_filename):
+                        open(marker_filename, "w").close()
                         self.fail("bug")
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-w", testname, exitcode=0)
+        # FAILURE then SUCCESS => exit code 0
+        output = self.run_tests("--rerun", testname, exitcode=0)
+        self.check_executed_tests(output, [testname],
+                                  rerun=Rerun(testname,
+                                              match="test_fail_once",
+                                              success=True),
+                                  stats=TestStats(3, 1))
+        os_helper.unlink(marker_filename)
+
+        # with --fail-rerun, exit code EXITCODE_RERUN_FAIL
+        # on "FAILURE then SUCCESS" state.
+        output = self.run_tests("--rerun", "--fail-rerun", testname,
+                                exitcode=EXITCODE_RERUN_FAIL)
+        self.check_executed_tests(output, [testname],
+                                  rerun=Rerun(testname,
+                                              match="test_fail_once",
+                                              success=True),
+                                  stats=TestStats(3, 1))
+        os_helper.unlink(marker_filename)
+
+    def test_rerun_setup_class_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                @classmethod
+                def setUpClass(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="ExampleTests",
+                                              success=False),
+                                  stats=0)
+
+    def test_rerun_teardown_class_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                @classmethod
+                def tearDownClass(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="ExampleTests",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_setup_module_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            def setUpModule():
+                raise RuntimeError('Fail')
+
+            class ExampleTests(unittest.TestCase):
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=False),
+                                  stats=0)
+
+    def test_rerun_teardown_module_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            def tearDownModule():
+                raise RuntimeError('Fail')
+
+            class ExampleTests(unittest.TestCase):
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  rerun=testname)
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_setup_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                def setUp(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_teardown_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                def tearDown(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_async_setup_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.IsolatedAsyncioTestCase):
+                async def asyncSetUp(self):
+                    raise RuntimeError('Fail')
+
+                async def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_async_teardown_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.IsolatedAsyncioTestCase):
+                async def asyncTearDown(self):
+                    raise RuntimeError('Fail')
+
+                async def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
 
     def test_no_tests_ran(self):
         code = textwrap.dedent("""
@@ -1139,8 +1742,11 @@ def test_bug(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests(testname, "-m", "nosuchtest", exitcode=0)
-        self.check_executed_tests(output, [testname], no_test_ran=testname)
+        output = self.run_tests(testname, "-m", "nosuchtest",
+                                exitcode=EXITCODE_NO_TESTS_RAN)
+        self.check_executed_tests(output, [testname],
+                                  run_no_tests=testname,
+                                  stats=0, filtered=True)
 
     def test_no_tests_ran_skip(self):
         code = textwrap.dedent("""
@@ -1152,8 +1758,9 @@ def test_skipped(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests(testname, exitcode=0)
-        self.check_executed_tests(output, [testname])
+        output = self.run_tests(testname)
+        self.check_executed_tests(output, [testname],
+                                  stats=TestStats(1, skipped=1))
 
     def test_no_tests_ran_multiple_tests_nonexistent(self):
         code = textwrap.dedent("""
@@ -1166,9 +1773,11 @@ def test_bug(self):
         testname = self.create_test(code=code)
         testname2 = self.create_test(code=code)
 
-        output = self.run_tests(testname, testname2, "-m", "nosuchtest", exitcode=0)
+        output = self.run_tests(testname, testname2, "-m", "nosuchtest",
+                                exitcode=EXITCODE_NO_TESTS_RAN)
         self.check_executed_tests(output, [testname, testname2],
-                                  no_test_ran=[testname, testname2])
+                                  run_no_tests=[testname, testname2],
+                                  stats=0, filtered=True)
 
     def test_no_test_ran_some_test_exist_some_not(self):
         code = textwrap.dedent("""
@@ -1191,10 +1800,15 @@ def test_other_bug(self):
         output = self.run_tests(testname, testname2, "-m", "nosuchtest",
                                 "-m", "test_other_bug", exitcode=0)
         self.check_executed_tests(output, [testname, testname2],
-                                  no_test_ran=[testname])
+                                  run_no_tests=[testname],
+                                  stats=1, filtered=True)
 
     @support.cpython_only
-    def test_findleaks(self):
+    def test_uncollectable(self):
+        try:
+            import _testcapi
+        except ImportError:
+            raise unittest.SkipTest("requires _testcapi")
         code = textwrap.dedent(r"""
             import _testcapi
             import gc
@@ -1214,19 +1828,13 @@ def test_garbage(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("--fail-env-changed", testname, exitcode=3)
-        self.check_executed_tests(output, [testname],
-                                  env_changed=[testname],
-                                  fail_env_changed=True)
-
-        # --findleaks is now basically an alias to --fail-env-changed
-        output = self.run_tests("--findleaks", testname, exitcode=3)
+        output = self.run_tests("--fail-env-changed", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
         self.check_executed_tests(output, [testname],
                                   env_changed=[testname],
-                                  fail_env_changed=True)
+                                  fail_env_changed=True,
+                                  stats=1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiprocessing_timeout(self):
         code = textwrap.dedent(r"""
             import time
@@ -1248,14 +1856,130 @@ def test_sleep(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-j2", "--timeout=1.0", testname, exitcode=2)
+        output = self.run_tests("-j2", "--timeout=1.0", testname,
+                                exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  failed=testname)
+                                  failed=testname, stats=0)
         self.assertRegex(output,
                          re.compile('%s timed out' % testname, re.MULTILINE))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_unraisable_exc(self):
+        # --fail-env-changed must catch unraisable exception.
+        # The exception must be displayed even if sys.stderr is redirected.
+        code = textwrap.dedent(r"""
+            import unittest
+            import weakref
+            from test.support import captured_stderr
+
+            class MyObject:
+                pass
+
+            def weakref_callback(obj):
+                raise Exception("weakref callback bug")
+
+            class Tests(unittest.TestCase):
+                def test_unraisable_exc(self):
+                    obj = MyObject()
+                    ref = weakref.ref(obj, weakref_callback)
+                    with captured_stderr() as stderr:
+                        # call weakref_callback() which logs
+                        # an unraisable exception
+                        obj = None
+                    self.assertEqual(stderr.getvalue(), '')
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=[testname],
+                                  fail_env_changed=True,
+                                  stats=1)
+        self.assertIn("Warning -- Unraisable exception", output)
+        self.assertIn("Exception: weakref callback bug", output)
+
+    def test_threading_excepthook(self):
+        # --fail-env-changed must catch uncaught thread exception.
+        # The exception must be displayed even if sys.stderr is redirected.
+        code = textwrap.dedent(r"""
+            import threading
+            import unittest
+            from test.support import captured_stderr
+
+            class MyObject:
+                pass
+
+            def func_bug():
+                raise Exception("bug in thread")
+
+            class Tests(unittest.TestCase):
+                def test_threading_excepthook(self):
+                    with captured_stderr() as stderr:
+                        thread = threading.Thread(target=func_bug)
+                        thread.start()
+                        thread.join()
+                    self.assertEqual(stderr.getvalue(), '')
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=[testname],
+                                  fail_env_changed=True,
+                                  stats=1)
+        self.assertIn("Warning -- Uncaught thread exception", output)
+        self.assertIn("Exception: bug in thread", output)
+
+    def test_print_warning(self):
+        # bpo-45410: The order of messages must be preserved when -W and
+        # support.print_warning() are used.
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+            from test import support
+
+            class MyObject:
+                pass
+
+            def func_bug():
+                raise Exception("bug in thread")
+
+            class Tests(unittest.TestCase):
+                def test_print_warning(self):
+                    print("msg1: stdout")
+                    support.print_warning("msg2: print_warning")
+                    # Fail with ENV CHANGED to see print_warning() log
+                    support.environment_altered = True
+        """)
+        testname = self.create_test(code=code)
+
+        # Expect an output like:
+        #
+        #   test_threading_excepthook (test.test_x.Tests) ... msg1: stdout
+        #   Warning -- msg2: print_warning
+        #   ok
+        regex = (r"test_print_warning.*msg1: stdout\n"
+                 r"Warning -- msg2: print_warning\n"
+                 r"ok\n")
+        for option in ("-v", "-W"):
+            with self.subTest(option=option):
+                cmd = ["--fail-env-changed", option, testname]
+                output = self.run_tests(*cmd, exitcode=EXITCODE_ENV_CHANGED)
+                self.check_executed_tests(output, [testname],
+                                          env_changed=[testname],
+                                          fail_env_changed=True,
+                                          stats=1)
+                self.assertRegex(output, regex)
+
+    def test_unicode_guard_env(self):
+        guard = os.environ.get(setup.UNICODE_GUARD_ENV)
+        self.assertIsNotNone(guard, f"{setup.UNICODE_GUARD_ENV} not set")
+        if guard.isascii():
+            # Skip to signify that the env var value was changed by the user;
+            # possibly to something ASCII to work around Unicode issues.
+            self.skipTest("Modified guard")
+
     def test_cleanup(self):
         dirname = os.path.join(self.tmptestdir, "test_python_123")
         os.mkdir(dirname)
@@ -1271,10 +1995,409 @@ def test_cleanup(self):
         for name in names:
             self.assertFalse(os.path.exists(name), name)
 
+    @unittest.skipIf(support.is_wasi,
+                     'checking temp files is not implemented on WASI')
+    def test_leak_tmp_file(self):
+        code = textwrap.dedent(r"""
+            import os.path
+            import tempfile
+            import unittest
+
+            class FileTests(unittest.TestCase):
+                def test_leak_tmp_file(self):
+                    filename = os.path.join(tempfile.gettempdir(), 'mytmpfile')
+                    with open(filename, "wb") as fp:
+                        fp.write(b'content')
+        """)
+        testnames = [self.create_test(code=code) for _ in range(3)]
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j2", *testnames,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, testnames,
+                                  env_changed=testnames,
+                                  fail_env_changed=True,
+                                  parallel=True,
+                                  stats=len(testnames))
+        for testname in testnames:
+            self.assertIn(f"Warning -- {testname} leaked temporary "
+                          f"files (1): mytmpfile",
+                          output)
+
+    def test_worker_decode_error(self):
+        # gh-109425: Use "backslashreplace" error handler to decode stdout.
+        if sys.platform == 'win32':
+            encoding = locale.getencoding()
+        else:
+            encoding = sys.stdout.encoding
+            if encoding is None:
+                encoding = sys.__stdout__.encoding
+                if encoding is None:
+                    self.skipTest("cannot get regrtest worker encoding")
+
+        nonascii = bytes(ch for ch in range(128, 256))
+        corrupted_output = b"nonascii:%s\n" % (nonascii,)
+        # gh-108989: On Windows, assertion errors are written in UTF-16: when
+        # decoded each letter is follow by a NUL character.
+        assertion_failed = 'Assertion failed: tstate_is_alive(tstate)\n'
+        corrupted_output += assertion_failed.encode('utf-16-le')
+        try:
+            corrupted_output.decode(encoding)
+        except UnicodeDecodeError:
+            pass
+        else:
+            self.skipTest(f"{encoding} can decode non-ASCII bytes")
+
+        expected_line = corrupted_output.decode(encoding, 'backslashreplace')
+
+        code = textwrap.dedent(fr"""
+            import sys
+            import unittest
+
+            class Tests(unittest.TestCase):
+                def test_pass(self):
+                    pass
+
+            # bytes which cannot be decoded from UTF-8
+            corrupted_output = {corrupted_output!a}
+            sys.stdout.buffer.write(corrupted_output)
+            sys.stdout.buffer.flush()
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j1", testname)
+        self.check_executed_tests(output, [testname],
+                                  parallel=True,
+                                  stats=1)
+        self.check_line(output, expected_line, regex=False)
+
+    def test_doctest(self):
+        code = textwrap.dedent(r'''
+            import doctest
+            import sys
+            from test import support
+
+            def my_function():
+                """
+                Pass:
+
+                >>> 1 + 1
+                2
+
+                Failure:
+
+                >>> 2 + 3
+                23
+                >>> 1 + 1
+                11
+
+                Skipped test (ignored):
+
+                >>> id(1.0)  # doctest: +SKIP
+                7948648
+                """
+
+            def load_tests(loader, tests, pattern):
+                tests.addTest(doctest.DocTestSuite())
+                return tests
+        ''')
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j1", testname,
+                                exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, [testname],
+                                  failed=[testname],
+                                  parallel=True,
+                                  stats=TestStats(1, 1, 0))
+
+    def _check_random_seed(self, run_workers: bool):
+        # gh-109276: When -r/--randomize is used, random.seed() is called
+        # with the same random seed before running each test file.
+        code = textwrap.dedent(r'''
+            import random
+            import unittest
+
+            class RandomSeedTest(unittest.TestCase):
+                def test_randint(self):
+                    numbers = [random.randint(0, 1000) for _ in range(10)]
+                    print(f"Random numbers: {numbers}")
+        ''')
+        tests = [self.create_test(name=f'test_random{i}', code=code)
+                 for i in range(1, 3+1)]
+
+        random_seed = 856_656_202
+        cmd = ["--randomize", f"--randseed={random_seed}"]
+        if run_workers:
+            # run as many worker processes than the number of tests
+            cmd.append(f'-j{len(tests)}')
+        cmd.extend(tests)
+        output = self.run_tests(*cmd)
+
+        random.seed(random_seed)
+        # Make the assumption that nothing consume entropy between libregrest
+        # setup_tests() which calls random.seed() and RandomSeedTest calling
+        # random.randint().
+        numbers = [random.randint(0, 1000) for _ in range(10)]
+        expected = f"Random numbers: {numbers}"
+
+        regex = r'^Random numbers: .*$'
+        matches = re.findall(regex, output, flags=re.MULTILINE)
+        self.assertEqual(matches, [expected] * len(tests))
+
+    def test_random_seed(self):
+        self._check_random_seed(run_workers=False)
+
+    def test_random_seed_workers(self):
+        self._check_random_seed(run_workers=True)
+
+    def test_python_command(self):
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+
+            class WorkerTests(unittest.TestCase):
+                def test_dev_mode(self):
+                    self.assertTrue(sys.flags.dev_mode)
+        """)
+        tests = [self.create_test(code=code) for _ in range(3)]
+
+        # Custom Python command: "python -X dev"
+        python_cmd = [sys.executable, '-X', 'dev']
+        # test.libregrtest.cmdline uses shlex.split() to parse the Python
+        # command line string
+        python_cmd = shlex.join(python_cmd)
+
+        output = self.run_tests("--python", python_cmd, "-j0", *tests)
+        self.check_executed_tests(output, tests,
+                                  stats=len(tests), parallel=True)
+
+    def test_unload_tests(self):
+        # Test that unloading test modules does not break tests
+        # that import from other tests.
+        # The test execution order matters for this test.
+        # Both test_regrtest_a and test_regrtest_c which are executed before
+        # and after test_regrtest_b import a submodule from the test_regrtest_b
+        # package and use it in testing. test_regrtest_b itself does not import
+        # that submodule.
+        # Previously test_regrtest_c failed because test_regrtest_b.util in
+        # sys.modules was left after test_regrtest_a (making the import
+        # statement no-op), but new test_regrtest_b without the util attribute
+        # was imported for test_regrtest_b.
+        testdir = os.path.join(os.path.dirname(__file__),
+                               'regrtestdata', 'import_from_tests')
+        tests = [f'test_regrtest_{name}' for name in ('a', 'b', 'c')]
+        args = ['-Wd', '-E', '-bb', '-m', 'test', '--testdir=%s' % testdir, *tests]
+        output = self.run_python(args)
+        self.check_executed_tests(output, tests, stats=3)
+
+    def check_add_python_opts(self, option):
+        # --fast-ci and --slow-ci add "-u -W default -bb -E" options to Python
+        try:
+            import _testinternalcapi
+        except ImportError:
+            raise unittest.SkipTest("requires _testinternalcapi")
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+            from test import support
+            try:
+                from _testinternalcapi import get_config
+            except ImportError:
+                get_config = None
+
+            # WASI/WASM buildbots don't use -E option
+            use_environment = (support.is_emscripten or support.is_wasi)
+
+            class WorkerTests(unittest.TestCase):
+                @unittest.skipUnless(get_config is None, 'need get_config()')
+                def test_config(self):
+                    config = get_config()['config']
+                    # -u option
+                    self.assertEqual(config['buffered_stdio'], 0)
+                    # -W default option
+                    self.assertTrue(config['warnoptions'], ['default'])
+                    # -bb option
+                    self.assertTrue(config['bytes_warning'], 2)
+                    # -E option
+                    self.assertTrue(config['use_environment'], use_environment)
+
+                def test_python_opts(self):
+                    # -u option
+                    self.assertTrue(sys.__stdout__.write_through)
+                    self.assertTrue(sys.__stderr__.write_through)
+
+                    # -W default option
+                    self.assertTrue(sys.warnoptions, ['default'])
+
+                    # -bb option
+                    self.assertEqual(sys.flags.bytes_warning, 2)
+
+                    # -E option
+                    self.assertEqual(not sys.flags.ignore_environment,
+                                     use_environment)
+        """)
+        testname = self.create_test(code=code)
+
+        # Use directly subprocess to control the exact command line
+        cmd = [sys.executable,
+               "-m", "test", option,
+               f'--testdir={self.tmptestdir}',
+               testname]
+        proc = subprocess.run(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.STDOUT,
+                              text=True)
+        self.assertEqual(proc.returncode, 0, proc)
+
+    def test_add_python_opts(self):
+        for opt in ("--fast-ci", "--slow-ci"):
+            with self.subTest(opt=opt):
+                self.check_add_python_opts(opt)
+
+    # gh-76319: Raising SIGSEGV on Android may not cause a crash.
+    @unittest.skipIf(support.is_android,
+                     'raising SIGSEGV on Android is unreliable')
+    def test_worker_output_on_failure(self):
+        try:
+            from faulthandler import _sigsegv
+        except ImportError:
+            self.skipTest("need faulthandler._sigsegv")
+
+        code = textwrap.dedent(r"""
+            import faulthandler
+            import unittest
+            from test import support
+
+            class CrashTests(unittest.TestCase):
+                def test_crash(self):
+                    print("just before crash!", flush=True)
+
+                    with support.SuppressCrashReport():
+                        faulthandler._sigsegv(True)
+        """)
+        testname = self.create_test(code=code)
+
+        # Sanitizers must not handle SIGSEGV (ex: for test_enable_fd())
+        env = dict(os.environ)
+        option = 'handle_segv=0'
+        support.set_sanitizer_env_var(env, option)
+
+        output = self.run_tests("-j1", testname,
+                                exitcode=EXITCODE_BAD_TEST,
+                                env=env)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  stats=0, parallel=True)
+        if not support.MS_WINDOWS:
+            exitcode = -int(signal.SIGSEGV)
+            self.assertIn(f"Exit code {exitcode} (SIGSEGV)", output)
+        self.check_line(output, "just before crash!", full=True, regex=False)
+
+    def test_verbose3(self):
+        code = textwrap.dedent(r"""
+            import unittest
+            from test import support
+
+            class VerboseTests(unittest.TestCase):
+                def test_pass(self):
+                    print("SPAM SPAM SPAM")
+        """)
+        testname = self.create_test(code=code)
+
+        # Run sequentially
+        output = self.run_tests("--verbose3", testname)
+        self.check_executed_tests(output, testname, stats=1)
+        self.assertNotIn('SPAM SPAM SPAM', output)
+
+        # -R option needs a debug build
+        if support.Py_DEBUG:
+            # Check for reference leaks, run in parallel
+            output = self.run_tests("-R", "3:3", "-j1", "--verbose3", testname)
+            self.check_executed_tests(output, testname, stats=1, parallel=True)
+            self.assertNotIn('SPAM SPAM SPAM', output)
+
+    def test_xml(self):
+        code = textwrap.dedent(r"""
+            import unittest
+
+            class VerboseTests(unittest.TestCase):
+                def test_failed(self):
+                    print("abc \x1b def")
+                    self.fail()
+        """)
+        testname = self.create_test(code=code)
+
+        # Run sequentially
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        output = self.run_tests(testname, "--junit-xml", filename,
+                                exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=testname,
+                                  stats=TestStats(1, 1, 0))
+
+        # Test generated XML
+        with open(filename, encoding="utf8") as fp:
+            content = fp.read()
+
+        testsuite = ElementTree.fromstring(content)
+        self.assertEqual(int(testsuite.get('tests')), 1)
+        self.assertEqual(int(testsuite.get('errors')), 0)
+        self.assertEqual(int(testsuite.get('failures')), 1)
+
+        testcase = testsuite[0][0]
+        self.assertEqual(testcase.get('status'), 'run')
+        self.assertEqual(testcase.get('result'), 'completed')
+        self.assertGreater(float(testcase.get('time')), 0)
+        for out in testcase.iter('system-out'):
+            self.assertEqual(out.text, r"abc \x1b def")
+
+    def test_nonascii(self):
+        code = textwrap.dedent(r"""
+            import unittest
+
+            class NonASCIITests(unittest.TestCase):
+                def test_docstring(self):
+                    '''docstring:\u20ac'''
+
+                def test_subtest(self):
+                    with self.subTest(param='subtest:\u20ac'):
+                        pass
+
+                def test_skip(self):
+                    self.skipTest('skipped:\u20ac')
+        """)
+        testname = self.create_test(code=code)
+
+        env = dict(os.environ)
+        env['PYTHONIOENCODING'] = 'ascii'
+
+        def check(output):
+            self.check_executed_tests(output, testname, stats=TestStats(3, 0, 1))
+            self.assertIn(r'docstring:\u20ac', output)
+            self.assertIn(r'skipped:\u20ac', output)
+
+        # Run sequentially
+        output = self.run_tests('-v', testname, env=env, isolated=False)
+        check(output)
+
+        # Run in parallel
+        output = self.run_tests('-j1', '-v', testname, env=env, isolated=False)
+        check(output)
+
+    def test_pgo_exclude(self):
+        # Get PGO tests
+        output = self.run_tests('--pgo', '--list-tests')
+        pgo_tests = output.strip().split()
+
+        # Exclude test_re
+        output = self.run_tests('--pgo', '--list-tests', '-x', 'test_re')
+        tests = output.strip().split()
+        self.assertNotIn('test_re', tests)
+        self.assertEqual(len(tests), len(pgo_tests) - 1)
+
 
 class TestUtils(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_duration(self):
         self.assertEqual(utils.format_duration(0),
                          '0 ms')
@@ -1297,6 +2420,184 @@ def test_format_duration(self):
         self.assertEqual(utils.format_duration(3 * 3600 + 1),
                          '3 hour 1 sec')
 
+    def test_normalize_test_name(self):
+        normalize = normalize_test_name
+        self.assertEqual(normalize('test_access (test.test_os.FileTests.test_access)'),
+                         'test_access')
+        self.assertEqual(normalize('setUpClass (test.test_os.ChownFileTests)', is_error=True),
+                         'ChownFileTests')
+        self.assertEqual(normalize('test_success (test.test_bug.ExampleTests.test_success)', is_error=True),
+                         'test_success')
+        self.assertIsNone(normalize('setUpModule (test.test_x)', is_error=True))
+        self.assertIsNone(normalize('tearDownModule (test.test_module)', is_error=True))
+
+    def test_get_signal_name(self):
+        for exitcode, expected in (
+            (-int(signal.SIGINT), 'SIGINT'),
+            (-int(signal.SIGSEGV), 'SIGSEGV'),
+            (128 + int(signal.SIGABRT), 'SIGABRT'),
+            (3221225477, "STATUS_ACCESS_VIOLATION"),
+            (0xC00000FD, "STATUS_STACK_OVERFLOW"),
+        ):
+            self.assertEqual(utils.get_signal_name(exitcode), expected, exitcode)
+
+    def test_format_resources(self):
+        format_resources = utils.format_resources
+        ALL_RESOURCES = utils.ALL_RESOURCES
+        self.assertEqual(
+            format_resources(("network",)),
+            'resources (1): network')
+        self.assertEqual(
+            format_resources(("audio", "decimal", "network")),
+            'resources (3): audio,decimal,network')
+        self.assertEqual(
+            format_resources(ALL_RESOURCES),
+            'resources: all')
+        self.assertEqual(
+            format_resources(tuple(name for name in ALL_RESOURCES
+                                   if name != "cpu")),
+            'resources: all,-cpu')
+        self.assertEqual(
+            format_resources((*ALL_RESOURCES, "tzdata")),
+            'resources: all,tzdata')
+
+    def test_match_test(self):
+        class Test:
+            def __init__(self, test_id):
+                self.test_id = test_id
+
+            def id(self):
+                return self.test_id
+
+        # Restore patterns once the test completes
+        patterns = get_match_tests()
+        self.addCleanup(set_match_tests, patterns)
+
+        test_access = Test('test.test_os.FileTests.test_access')
+        test_chdir = Test('test.test_os.Win32ErrorTests.test_chdir')
+        test_copy = Test('test.test_shutil.TestCopy.test_copy')
+
+        # Test acceptance
+        with support.swap_attr(support, '_test_matchers', ()):
+            # match all
+            set_match_tests([])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match all using None
+            set_match_tests(None)
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match the full test identifier
+            set_match_tests([(test_access.id(), True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+            # match the module name
+            set_match_tests([('test_os', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            # Test '*' pattern
+            set_match_tests([('test_*', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # Test case sensitivity
+            set_match_tests([('filetests', True)])
+            self.assertFalse(match_test(test_access))
+            set_match_tests([('FileTests', True)])
+            self.assertTrue(match_test(test_access))
+
+            # Test pattern containing '.' and a '*' metacharacter
+            set_match_tests([('*test_os.*.test_*', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            # Multiple patterns
+            set_match_tests([(test_access.id(), True), (test_chdir.id(), True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            set_match_tests([('test_access', True), ('DONTMATCH', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+        # Test rejection
+        with support.swap_attr(support, '_test_matchers', ()):
+            # match the full test identifier
+            set_match_tests([(test_access.id(), False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match the module name
+            set_match_tests([('test_os', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            # Test '*' pattern
+            set_match_tests([('test_*', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+            # Test case sensitivity
+            set_match_tests([('filetests', False)])
+            self.assertTrue(match_test(test_access))
+            set_match_tests([('FileTests', False)])
+            self.assertFalse(match_test(test_access))
+
+            # Test pattern containing '.' and a '*' metacharacter
+            set_match_tests([('*test_os.*.test_*', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            # Multiple patterns
+            set_match_tests([(test_access.id(), False), (test_chdir.id(), False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            set_match_tests([('test_access', False), ('DONTMATCH', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+        # Test mixed filters
+        with support.swap_attr(support, '_test_matchers', ()):
+            set_match_tests([('*test_os', False), ('test_access', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            set_match_tests([('*test_os', True), ('test_access', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+    def test_sanitize_xml(self):
+        sanitize_xml = utils.sanitize_xml
+
+        # escape invalid XML characters
+        self.assertEqual(sanitize_xml('abc \x1b\x1f def'),
+                         r'abc \x1b\x1f def')
+        self.assertEqual(sanitize_xml('nul:\x00, bell:\x07'),
+                         r'nul:\x00, bell:\x07')
+        self.assertEqual(sanitize_xml('surrogate:\uDC80'),
+                         r'surrogate:\udc80')
+        self.assertEqual(sanitize_xml('illegal \uFFFE and \uFFFF'),
+                         r'illegal \ufffe and \uffff')
+
+        # no escape for valid XML characters
+        self.assertEqual(sanitize_xml('a\n\tb'),
+                         'a\n\tb')
+        self.assertEqual(sanitize_xml('valid t\xe9xt \u20ac'),
+                         'valid t\xe9xt \u20ac')
+
 
 if __name__ == '__main__':
     unittest.main()

From 404836f187e29965837f8671ca754b0c8cd19fdb Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Tue, 30 Dec 2025 21:05:19 -0500
Subject: [PATCH 225/418] Add autotest shim from CPython 3.13.11

---
 Lib/test/autotest.py | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 Lib/test/autotest.py

diff --git a/Lib/test/autotest.py b/Lib/test/autotest.py
new file mode 100644
index 00000000000..b5a1fab404c
--- /dev/null
+++ b/Lib/test/autotest.py
@@ -0,0 +1,5 @@
+# This should be equivalent to running regrtest.py from the cmdline.
+# It can be especially handy if you're in an interactive shell, e.g.,
+# from test import autotest.
+from test.libregrtest.main import main
+main()

From 4c833fc7145edae5825c35aca58b34b4a0902614 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Tue, 30 Dec 2025 21:04:45 -0500
Subject: [PATCH 226/418] Mark failing tests and skip flaky ones in
 test/test_regrtest.py

---
 Lib/test/test_regrtest.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index a95a13436fc..bef7dd536c6 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -818,6 +818,7 @@ def run_python(self, args, isolated=True, **kw):
 
 
 class CheckActualTests(BaseTestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_finds_expected_number_of_tests(self):
         """
         Check that regrtest appears to find the expected set of tests.
@@ -874,6 +875,7 @@ def run_tests(self, args, env=None, isolated=True):
         output = self.run_python(args, env=env, isolated=isolated)
         self.check_output(output)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_script_regrtest(self):
         # Lib/test/regrtest.py
         script = os.path.join(self.testdir, 'regrtest.py')
@@ -881,24 +883,28 @@ def test_script_regrtest(self):
         args = [*self.python_args, script, *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_test(self):
         # -m test
         args = [*self.python_args, '-m', 'test',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_module_regrtest(self):
         # -m test.regrtest
         args = [*self.python_args, '-m', 'test.regrtest',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_autotest(self):
         # -m test.autotest
         args = [*self.python_args, '-m', 'test.autotest',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_from_test_autotest(self):
         # from test import autotest
         code = 'from test import autotest'
@@ -1188,6 +1194,7 @@ def test_slowest_interrupted(self):
                 regex = ('10 slowest tests:\n')
                 self.check_line(output, regex)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_coverage(self):
         # test --coverage
         test = self.create_test('coverage')
@@ -1460,6 +1467,7 @@ def test_method4(self):
         subset = ['test_method1', 'test_method3']
         self.assertEqual(methods, subset)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_env_changed(self):
         code = textwrap.dedent("""
             import unittest
@@ -1863,6 +1871,7 @@ def test_sleep(self):
         self.assertRegex(output,
                          re.compile('%s timed out' % testname, re.MULTILINE))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unraisable_exc(self):
         # --fail-env-changed must catch unraisable exception.
         # The exception must be displayed even if sys.stderr is redirected.
@@ -1995,6 +2004,7 @@ def test_cleanup(self):
         for name in names:
             self.assertFalse(os.path.exists(name), name)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     @unittest.skipIf(support.is_wasi,
                      'checking temp files is not implemented on WASI')
     def test_leak_tmp_file(self):
@@ -2170,6 +2180,7 @@ def test_dev_mode(self):
         self.check_executed_tests(output, tests,
                                   stats=len(tests), parallel=True)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_unload_tests(self):
         # Test that unloading test modules does not break tests
         # that import from other tests.
@@ -2315,6 +2326,7 @@ def test_pass(self):
             self.check_executed_tests(output, testname, stats=1, parallel=True)
             self.assertNotIn('SPAM SPAM SPAM', output)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_xml(self):
         code = textwrap.dedent(r"""
             import unittest
@@ -2352,6 +2364,7 @@ def test_failed(self):
         for out in testcase.iter('system-out'):
             self.assertEqual(out.text, r"abc \x1b def")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_nonascii(self):
         code = textwrap.dedent(r"""
             import unittest

From 2789ff7a9f32a2c40ff33ff97051ef62751e04ac Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 19:42:16 -0500
Subject: [PATCH 227/418] Mark failing test in test_fstring

---
 Lib/test/test_fstring.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py
index 930e409fb2e..c13606ae9dc 100644
--- a/Lib/test/test_fstring.py
+++ b/Lib/test/test_fstring.py
@@ -1526,6 +1526,7 @@ def test_errors(self):
                              r"f'{1000:j}'",
                             ])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_filename_in_syntaxerror(self):
         # see issue 38964
         with temp_cwd() as cwd:

From 4a559f3ea475e0062ad51d39bba3f2290ad5f0aa Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 21:34:57 -0500
Subject: [PATCH 228/418] Add _test_eintr.py from CPython 3.13.11

---
 Lib/test/_test_eintr.py | 544 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 544 insertions(+)
 create mode 100644 Lib/test/_test_eintr.py

diff --git a/Lib/test/_test_eintr.py b/Lib/test/_test_eintr.py
new file mode 100644
index 00000000000..b7e23660dd0
--- /dev/null
+++ b/Lib/test/_test_eintr.py
@@ -0,0 +1,544 @@
+"""
+This test suite exercises some system calls subject to interruption with EINTR,
+to check that it is actually handled transparently.
+It is intended to be run by the main test suite within a child process, to
+ensure there is no background thread running (so that signals are delivered to
+the correct thread).
+Signals are generated in-process using setitimer(ITIMER_REAL), which allows
+sub-second periodicity (contrarily to signal()).
+"""
+
+import contextlib
+import faulthandler
+import fcntl
+import os
+import platform
+import select
+import signal
+import socket
+import subprocess
+import sys
+import textwrap
+import time
+import unittest
+
+from test import support
+from test.support import os_helper
+from test.support import socket_helper
+
+
+# gh-109592: Tolerate a difference of 20 ms when comparing timings
+# (clock resolution)
+CLOCK_RES = 0.020
+
+
+@contextlib.contextmanager
+def kill_on_error(proc):
+    """Context manager killing the subprocess if a Python exception is raised."""
+    with proc:
+        try:
+            yield proc
+        except:
+            proc.kill()
+            raise
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class EINTRBaseTest(unittest.TestCase):
+    """ Base class for EINTR tests. """
+
+    # delay for initial signal delivery
+    signal_delay = 0.1
+    # signal delivery periodicity
+    signal_period = 0.1
+    # default sleep time for tests - should obviously have:
+    # sleep_time > signal_period
+    sleep_time = 0.2
+
+    def sighandler(self, signum, frame):
+        self.signals += 1
+
+    def setUp(self):
+        self.signals = 0
+        self.orig_handler = signal.signal(signal.SIGALRM, self.sighandler)
+        signal.setitimer(signal.ITIMER_REAL, self.signal_delay,
+                         self.signal_period)
+
+        # Use faulthandler as watchdog to debug when a test hangs
+        # (timeout of 10 minutes)
+        faulthandler.dump_traceback_later(10 * 60, exit=True,
+                                          file=sys.__stderr__)
+
+    @staticmethod
+    def stop_alarm():
+        signal.setitimer(signal.ITIMER_REAL, 0, 0)
+
+    def tearDown(self):
+        self.stop_alarm()
+        signal.signal(signal.SIGALRM, self.orig_handler)
+        faulthandler.cancel_dump_traceback_later()
+
+    def subprocess(self, *args, **kw):
+        cmd_args = (sys.executable, '-c') + args
+        return subprocess.Popen(cmd_args, **kw)
+
+    def check_elapsed_time(self, elapsed):
+        self.assertGreaterEqual(elapsed, self.sleep_time - CLOCK_RES)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class OSEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the os module. """
+
+    def new_sleep_process(self):
+        code = 'import time; time.sleep(%r)' % self.sleep_time
+        return self.subprocess(code)
+
+    def _test_wait_multiple(self, wait_func):
+        num = 3
+        processes = [self.new_sleep_process() for _ in range(num)]
+        for _ in range(num):
+            wait_func()
+        # Call the Popen method to avoid a ResourceWarning
+        for proc in processes:
+            proc.wait()
+
+    def test_wait(self):
+        self._test_wait_multiple(os.wait)
+
+    @unittest.skipUnless(hasattr(os, 'wait3'), 'requires wait3()')
+    def test_wait3(self):
+        self._test_wait_multiple(lambda: os.wait3(0))
+
+    def _test_wait_single(self, wait_func):
+        proc = self.new_sleep_process()
+        wait_func(proc.pid)
+        # Call the Popen method to avoid a ResourceWarning
+        proc.wait()
+
+    def test_waitpid(self):
+        self._test_wait_single(lambda pid: os.waitpid(pid, 0))
+
+    @unittest.skipUnless(hasattr(os, 'wait4'), 'requires wait4()')
+    def test_wait4(self):
+        self._test_wait_single(lambda pid: os.wait4(pid, 0))
+
+    def test_read(self):
+        rd, wr = os.pipe()
+        self.addCleanup(os.close, rd)
+        # wr closed explicitly by parent
+
+        # the payload below are smaller than PIPE_BUF, hence the writes will be
+        # atomic
+        datas = [b"hello", b"world", b"spam"]
+
+        code = '\n'.join((
+            'import os, sys, time',
+            '',
+            'wr = int(sys.argv[1])',
+            'datas = %r' % datas,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            'for data in datas:',
+            '    # let the parent block on read()',
+            '    time.sleep(sleep_time)',
+            '    os.write(wr, data)',
+        ))
+
+        proc = self.subprocess(code, str(wr), pass_fds=[wr])
+        with kill_on_error(proc):
+            os.close(wr)
+            for data in datas:
+                self.assertEqual(data, os.read(rd, len(data)))
+            self.assertEqual(proc.wait(), 0)
+
+    def test_write(self):
+        rd, wr = os.pipe()
+        self.addCleanup(os.close, wr)
+        # rd closed explicitly by parent
+
+        # we must write enough data for the write() to block
+        data = b"x" * support.PIPE_MAX_SIZE
+
+        code = '\n'.join((
+            'import io, os, sys, time',
+            '',
+            'rd = int(sys.argv[1])',
+            'sleep_time = %r' % self.sleep_time,
+            'data = b"x" * %s' % support.PIPE_MAX_SIZE,
+            'data_len = len(data)',
+            '',
+            '# let the parent block on write()',
+            'time.sleep(sleep_time)',
+            '',
+            'read_data = io.BytesIO()',
+            'while len(read_data.getvalue()) < data_len:',
+            '    chunk = os.read(rd, 2 * data_len)',
+            '    read_data.write(chunk)',
+            '',
+            'value = read_data.getvalue()',
+            'if value != data:',
+            '    raise Exception("read error: %s vs %s bytes"',
+            '                    % (len(value), data_len))',
+        ))
+
+        proc = self.subprocess(code, str(rd), pass_fds=[rd])
+        with kill_on_error(proc):
+            os.close(rd)
+            written = 0
+            while written < len(data):
+                written += os.write(wr, memoryview(data)[written:])
+            self.assertEqual(proc.wait(), 0)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class SocketEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the socket module. """
+
+    @unittest.skipUnless(hasattr(socket, 'socketpair'), 'needs socketpair()')
+    def _test_recv(self, recv_func):
+        rd, wr = socket.socketpair()
+        self.addCleanup(rd.close)
+        # wr closed explicitly by parent
+
+        # single-byte payload guard us against partial recv
+        datas = [b"x", b"y", b"z"]
+
+        code = '\n'.join((
+            'import os, socket, sys, time',
+            '',
+            'fd = int(sys.argv[1])',
+            'family = %s' % int(wr.family),
+            'sock_type = %s' % int(wr.type),
+            'datas = %r' % datas,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            'wr = socket.fromfd(fd, family, sock_type)',
+            'os.close(fd)',
+            '',
+            'with wr:',
+            '    for data in datas:',
+            '        # let the parent block on recv()',
+            '        time.sleep(sleep_time)',
+            '        wr.sendall(data)',
+        ))
+
+        fd = wr.fileno()
+        proc = self.subprocess(code, str(fd), pass_fds=[fd])
+        with kill_on_error(proc):
+            wr.close()
+            for data in datas:
+                self.assertEqual(data, recv_func(rd, len(data)))
+            self.assertEqual(proc.wait(), 0)
+
+    def test_recv(self):
+        self._test_recv(socket.socket.recv)
+
+    @unittest.skipUnless(hasattr(socket.socket, 'recvmsg'), 'needs recvmsg()')
+    def test_recvmsg(self):
+        self._test_recv(lambda sock, data: sock.recvmsg(data)[0])
+
+    def _test_send(self, send_func):
+        rd, wr = socket.socketpair()
+        self.addCleanup(wr.close)
+        # rd closed explicitly by parent
+
+        # we must send enough data for the send() to block
+        data = b"xyz" * (support.SOCK_MAX_SIZE // 3)
+
+        code = '\n'.join((
+            'import os, socket, sys, time',
+            '',
+            'fd = int(sys.argv[1])',
+            'family = %s' % int(rd.family),
+            'sock_type = %s' % int(rd.type),
+            'sleep_time = %r' % self.sleep_time,
+            'data = b"xyz" * %s' % (support.SOCK_MAX_SIZE // 3),
+            'data_len = len(data)',
+            '',
+            'rd = socket.fromfd(fd, family, sock_type)',
+            'os.close(fd)',
+            '',
+            'with rd:',
+            '    # let the parent block on send()',
+            '    time.sleep(sleep_time)',
+            '',
+            '    received_data = bytearray(data_len)',
+            '    n = 0',
+            '    while n < data_len:',
+            '        n += rd.recv_into(memoryview(received_data)[n:])',
+            '',
+            'if received_data != data:',
+            '    raise Exception("recv error: %s vs %s bytes"',
+            '                    % (len(received_data), data_len))',
+        ))
+
+        fd = rd.fileno()
+        proc = self.subprocess(code, str(fd), pass_fds=[fd])
+        with kill_on_error(proc):
+            rd.close()
+            written = 0
+            while written < len(data):
+                sent = send_func(wr, memoryview(data)[written:])
+                # sendall() returns None
+                written += len(data) if sent is None else sent
+            self.assertEqual(proc.wait(), 0)
+
+    def test_send(self):
+        self._test_send(socket.socket.send)
+
+    def test_sendall(self):
+        self._test_send(socket.socket.sendall)
+
+    @unittest.skipUnless(hasattr(socket.socket, 'sendmsg'), 'needs sendmsg()')
+    def test_sendmsg(self):
+        self._test_send(lambda sock, data: sock.sendmsg([data]))
+
+    def test_accept(self):
+        sock = socket.create_server((socket_helper.HOST, 0))
+        self.addCleanup(sock.close)
+        port = sock.getsockname()[1]
+
+        code = '\n'.join((
+            'import socket, time',
+            '',
+            'host = %r' % socket_helper.HOST,
+            'port = %s' % port,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            '# let parent block on accept()',
+            'time.sleep(sleep_time)',
+            'with socket.create_connection((host, port)):',
+            '    time.sleep(sleep_time)',
+        ))
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            client_sock, _ = sock.accept()
+            client_sock.close()
+            self.assertEqual(proc.wait(), 0)
+
+    # Issue #25122: There is a race condition in the FreeBSD kernel on
+    # handling signals in the FIFO device. Skip the test until the bug is
+    # fixed in the kernel.
+    # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=203162
+    @support.requires_freebsd_version(10, 3)
+    @unittest.skipUnless(hasattr(os, 'mkfifo'), 'needs mkfifo()')
+    def _test_open(self, do_open_close_reader, do_open_close_writer):
+        filename = os_helper.TESTFN
+
+        # Use a fifo: until the child opens it for reading, the parent will
+        # block when trying to open it for writing.
+        os_helper.unlink(filename)
+        try:
+            os.mkfifo(filename)
+        except PermissionError as e:
+            self.skipTest('os.mkfifo(): %s' % e)
+        self.addCleanup(os_helper.unlink, filename)
+
+        code = '\n'.join((
+            'import os, time',
+            '',
+            'path = %a' % filename,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            '# let the parent block',
+            'time.sleep(sleep_time)',
+            '',
+            do_open_close_reader,
+        ))
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            do_open_close_writer(filename)
+            self.assertEqual(proc.wait(), 0)
+
+    def python_open(self, path):
+        fp = open(path, 'w')
+        fp.close()
+
+    @unittest.skipIf(sys.platform == "darwin",
+                     "hangs under macOS; see bpo-25234, bpo-35363")
+    def test_open(self):
+        self._test_open("fp = open(path, 'r')\nfp.close()",
+                        self.python_open)
+
+    def os_open(self, path):
+        fd = os.open(path, os.O_WRONLY)
+        os.close(fd)
+
+    @unittest.skipIf(sys.platform == "darwin",
+                     "hangs under macOS; see bpo-25234, bpo-35363")
+    @unittest.skipIf(sys.platform.startswith('netbsd'),
+                     "hangs on NetBSD; see gh-137397")
+    def test_os_open(self):
+        self._test_open("fd = os.open(path, os.O_RDONLY)\nos.close(fd)",
+                        self.os_open)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class TimeEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the time module. """
+
+    def test_sleep(self):
+        t0 = time.monotonic()
+        time.sleep(self.sleep_time)
+        self.stop_alarm()
+        dt = time.monotonic() - t0
+        self.check_elapsed_time(dt)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+# bpo-30320: Need pthread_sigmask() to block the signal, otherwise the test
+# is vulnerable to a race condition between the child and the parent processes.
+@unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
+                     'need signal.pthread_sigmask()')
+class SignalEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the signal module. """
+
+    def check_sigwait(self, wait_func):
+        signum = signal.SIGUSR1
+        pid = os.getpid()
+
+        old_handler = signal.signal(signum, lambda *args: None)
+        self.addCleanup(signal.signal, signum, old_handler)
+
+        code = '\n'.join((
+            'import os, time',
+            'pid = %s' % os.getpid(),
+            'signum = %s' % int(signum),
+            'sleep_time = %r' % self.sleep_time,
+            'time.sleep(sleep_time)',
+            'os.kill(pid, signum)',
+        ))
+
+        old_mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
+        self.addCleanup(signal.pthread_sigmask, signal.SIG_UNBLOCK, [signum])
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            wait_func(signum)
+
+        self.assertEqual(proc.wait(), 0)
+
+    @unittest.skipUnless(hasattr(signal, 'sigwaitinfo'),
+                         'need signal.sigwaitinfo()')
+    def test_sigwaitinfo(self):
+        def wait_func(signum):
+            signal.sigwaitinfo([signum])
+
+        self.check_sigwait(wait_func)
+
+    @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
+                         'need signal.sigwaitinfo()')
+    def test_sigtimedwait(self):
+        def wait_func(signum):
+            signal.sigtimedwait([signum], 120.0)
+
+        self.check_sigwait(wait_func)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class SelectEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the select module. """
+
+    def test_select(self):
+        t0 = time.monotonic()
+        select.select([], [], [], self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipIf(sys.platform == "darwin",
+                     "poll may fail on macOS; see issue #28087")
+    @unittest.skipUnless(hasattr(select, 'poll'), 'need select.poll')
+    def test_poll(self):
+        poller = select.poll()
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time * 1e3)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'epoll'), 'need select.epoll')
+    def test_epoll(self):
+        poller = select.epoll()
+        self.addCleanup(poller.close)
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'kqueue'), 'need select.kqueue')
+    def test_kqueue(self):
+        kqueue = select.kqueue()
+        self.addCleanup(kqueue.close)
+
+        t0 = time.monotonic()
+        kqueue.control(None, 1, self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'devpoll'), 'need select.devpoll')
+    def test_devpoll(self):
+        poller = select.devpoll()
+        self.addCleanup(poller.close)
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time * 1e3)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+
+class FCNTLEINTRTest(EINTRBaseTest):
+    def _lock(self, lock_func, lock_name):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        rd1, wr1 = os.pipe()
+        rd2, wr2 = os.pipe()
+        for fd in (rd1, wr1, rd2, wr2):
+            self.addCleanup(os.close, fd)
+        code = textwrap.dedent(f"""
+            import fcntl, os, time
+            with open('{os_helper.TESTFN}', 'wb') as f:
+                fcntl.{lock_name}(f, fcntl.LOCK_EX)
+                os.write({wr1}, b"ok")
+                _ = os.read({rd2}, 2)  # wait for parent process
+                time.sleep({self.sleep_time})
+        """)
+        proc = self.subprocess(code, pass_fds=[wr1, rd2])
+        with kill_on_error(proc):
+            with open(os_helper.TESTFN, 'wb') as f:
+                # synchronize the subprocess
+                ok = os.read(rd1, 2)
+                self.assertEqual(ok, b"ok")
+
+                # notify the child that the parent is ready
+                start_time = time.monotonic()
+                os.write(wr2, b"go")
+
+                # the child locked the file just a moment ago for 'sleep_time' seconds
+                # that means that the lock below will block for 'sleep_time' minus some
+                # potential context switch delay
+                lock_func(f, fcntl.LOCK_EX)
+                dt = time.monotonic() - start_time
+                self.stop_alarm()
+                self.check_elapsed_time(dt)
+            proc.wait()
+
+    # Issue 35633: See https://bugs.python.org/issue35633#msg333662
+    # skip test rather than accept PermissionError from all platforms
+    @unittest.skipIf(platform.system() == "AIX", "AIX returns PermissionError")
+    def test_lockf(self):
+        self._lock(fcntl.lockf, "lockf")
+
+    def test_flock(self):
+        self._lock(fcntl.flock, "flock")
+
+
+if __name__ == "__main__":
+    unittest.main()

From bedcb225e7871dd8cd7a67b3cdf856bbc4c179de Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 21:57:05 -0500
Subject: [PATCH 229/418] Skip long-running test in _test_eintr

---
 Lib/test/_test_eintr.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/_test_eintr.py b/Lib/test/_test_eintr.py
index b7e23660dd0..675a13e5787 100644
--- a/Lib/test/_test_eintr.py
+++ b/Lib/test/_test_eintr.py
@@ -449,6 +449,7 @@ def test_select(self):
         self.stop_alarm()
         self.check_elapsed_time(dt)
 
+    @unittest.skip('TODO: RUSTPYTHON timed out at the 10 minute mark')
     @unittest.skipIf(sys.platform == "darwin",
                      "poll may fail on macOS; see issue #28087")
     @unittest.skipUnless(hasattr(select, 'poll'), 'need select.poll')

From 1f56a0fe0ca367da4298b65f1c82d67fb4cc2c68 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 21:57:22 -0500
Subject: [PATCH 230/418] Mark failing/erroring tests in _test_eintr

---
 Lib/test/_test_eintr.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Lib/test/_test_eintr.py b/Lib/test/_test_eintr.py
index 675a13e5787..c8f04e9625c 100644
--- a/Lib/test/_test_eintr.py
+++ b/Lib/test/_test_eintr.py
@@ -152,6 +152,7 @@ def test_read(self):
                 self.assertEqual(data, os.read(rd, len(data)))
             self.assertEqual(proc.wait(), 0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
     def test_write(self):
         rd, wr = os.pipe()
         self.addCleanup(os.close, wr)
@@ -380,6 +381,7 @@ def test_os_open(self):
 class TimeEINTRTest(EINTRBaseTest):
     """ EINTR tests for the time module. """
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sleep(self):
         t0 = time.monotonic()
         time.sleep(self.sleep_time)
@@ -442,6 +444,7 @@ def wait_func(signum):
 class SelectEINTRTest(EINTRBaseTest):
     """ EINTR tests for the select module. """
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_select(self):
         t0 = time.monotonic()
         select.select([], [], [], self.sleep_time)
@@ -531,12 +534,14 @@ def _lock(self, lock_func, lock_name):
                 self.check_elapsed_time(dt)
             proc.wait()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
     # Issue 35633: See https://bugs.python.org/issue35633#msg333662
     # skip test rather than accept PermissionError from all platforms
     @unittest.skipIf(platform.system() == "AIX", "AIX returns PermissionError")
     def test_lockf(self):
         self._lock(fcntl.lockf, "lockf")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
     def test_flock(self):
         self._lock(fcntl.flock, "flock")
 

From c76e72571e9a0251b21e27100ca5a434f63f4aa0 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 21:59:49 -0500
Subject: [PATCH 231/418] Skip panicking tests in test_io

---
 Lib/test/test_io.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 1e594c49640..893d8f26e7f 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -5167,13 +5167,13 @@ def alarm2(sig, frame):
                 if e.errno != errno.EBADF:
                     raise
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_write_retry_buffered(self):
         self.check_interrupted_write_retry(b"x", mode="wb")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_write_retry_text(self):
@@ -5183,6 +5183,10 @@ def test_interrupted_write_retry_text(self):
 class CSignalsTest(SignalsTest):
     io = io
 
+    @unittest.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
+    def test_interrupted_read_retry_buffered(self):  # TODO: RUSTPYTHON
+        return super().test_interrupted_read_retry_buffered()  # TODO: RUSTPYTHON
+
 class PySignalsTest(SignalsTest):
     io = pyio
 

From cadac344a7623148f611415918e59b6a2d444ee0 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 22:00:04 -0500
Subject: [PATCH 232/418] Unmark passing tests in test_io

---
 Lib/test/test_io.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 893d8f26e7f..3c507c30492 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -5085,14 +5085,12 @@ def alarm_handler(sig, frame):
             os.close(w)
             os.close(r)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_read_retry_buffered(self):
         self.check_interrupted_read_retry(lambda x: x.decode('latin1'),
                                           mode="rb")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_read_retry_text(self):

From 8aafbf2bf71d4e86395cabac6c34bebfff2580cf Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 31 Dec 2025 22:03:51 -0500
Subject: [PATCH 233/418] Mark failing test in test_urllib2net

---
 Lib/test/test_urllib2net.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_urllib2net.py b/Lib/test/test_urllib2net.py
index 41f170a6ad5..c70b522d31d 100644
--- a/Lib/test/test_urllib2net.py
+++ b/Lib/test/test_urllib2net.py
@@ -137,6 +137,7 @@ def setUp(self):
     # XXX The rest of these tests aren't very good -- they don't check much.
     # They do sometimes catch some major disasters, though.
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON urllib.error.URLError: <urlopen error ftp error: error_reply('200 Switching to Binary mode.')>
     @support.requires_resource('walltime')
     def test_ftp(self):
         # Testing the same URL twice exercises the caching in CacheFTPHandler

From 8d2b215ccba1ddc910bc3b1f99853823d381f434 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 1 Jan 2026 12:08:46 -0500
Subject: [PATCH 234/418] Unmark passing test in test_fstring

---
 Lib/test/test_fstring.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py
index c13606ae9dc..930e409fb2e 100644
--- a/Lib/test/test_fstring.py
+++ b/Lib/test/test_fstring.py
@@ -1526,7 +1526,6 @@ def test_errors(self):
                              r"f'{1000:j}'",
                             ])
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_filename_in_syntaxerror(self):
         # see issue 38964
         with temp_cwd() as cwd:

From 472c12cad7a32a1756114a8bf9e8b2d230e39549 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 1 Jan 2026 12:25:37 -0500
Subject: [PATCH 235/418] Time out if any one test takes longer than 10 minutes

---
 .github/workflows/ci.yaml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index d075a9cd280..0ec73ea0243 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -279,23 +279,23 @@ jobs:
       - if: runner.os == 'Linux'
         name: run cpython platform-independent tests
         run:
-          target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+          target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'Linux'
         name: run cpython platform-dependent tests (Linux)
-        run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+        run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'macOS'
         name: run cpython platform-dependent tests (MacOS)
-        run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+        run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'Windows'
         name: run cpython platform-dependent tests (windows partial - fixme)
         run:
-          target/release/rustpython -m test -j 1 --slowest --fail-env-changed -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
+          target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
         timeout-minutes: 45
 
       - if: runner.os != 'Windows'

From 17cc559dd388de8ef1f0618c8401cb1090186980 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Thu, 1 Jan 2026 22:46:18 -0500
Subject: [PATCH 236/418] Skip more flaky tests in test_threading

---
 Lib/test/test_threading.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 031db4a49af..a5ee24859cd 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -1178,6 +1178,7 @@ def main():
         rc, out, err = assert_python_ok('-c', script)
         self.assertFalse(err)
 
+    @unittest.skip('TODO: RUSTPYTHON, flaky')
     @support.requires_fork()
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
     def test_reinit_tls_after_fork(self):

From 1827af100b61529ff7cd427255bd123d1c9c7f91 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 3 Jan 2026 14:34:38 -0500
Subject: [PATCH 237/418] Skip tests that pollute the environment for some
 reason

---
 .github/workflows/ci.yaml                     | 82 +++++++++++++++++++
 Lib/test/test_file_eintr.py                   |  4 +
 .../test_importlib/resources/test_resource.py |  5 ++
 .../test_processes.py                         | 52 ++++++++++++
 .../test_multiprocessing_fork/test_threads.py | 12 +++
 .../test_processes.py                         | 30 +++++++
 .../test_threads.py                           |  8 ++
 .../test_processes.py                         | 30 +++++++
 .../test_threads.py                           |  8 ++
 Lib/test/test_raise.py                        |  5 ++
 Lib/test/test_ssl.py                          |  4 +
 Lib/test/test_subprocess.py                   |  4 +
 Lib/test/test_sys.py                          |  5 ++
 13 files changed, 249 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 0ec73ea0243..23164ff9fe1 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -105,6 +105,33 @@ env:
     test_unpack
     test_weakref
     test_yield_from
+  ENV_POLLUTING_TESTS_COMMON: >-
+    test_raise
+    test_ssl
+    test_sys
+  ENV_POLLUTING_TESTS_LINUX: >-
+    test.test_multiprocessing_fork.test_processes
+    test.test_multiprocessing_fork.test_threads
+    test.test_multiprocessing_forkserver.test_processes
+    test.test_multiprocessing_forkserver.test_threads
+    test.test_multiprocessing_spawn.test_processes
+    test.test_multiprocessing_spawn.test_threads
+    test_file_eintr
+    test_subprocess
+  ENV_POLLUTING_TESTS_MACOS: >-
+    test_multiprocessing_forkserver.test_manager
+    test.test_multiprocessing_forkserver.test_misc
+    test.test_multiprocessing_forkserver.test_processes
+    test.test_multiprocessing_forkserver.test_threads
+    test.test_multiprocessing_spawn.test_manager
+    test.test_multiprocessing_spawn.test_misc
+    test.test_multiprocessing_spawn.test_processes
+    test.test_multiprocessing_spawn.test_threads
+    test_ftplib
+    test_logging
+    test_multiprocessing_main_handling
+    test_subprocess
+  ENV_POLLUTING_TESTS_WINDOWS: >-
   # Python version targeted by the CI.
   PYTHON_VERSION: "3.13.1"
   X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
@@ -278,26 +305,81 @@ jobs:
 
       - if: runner.os == 'Linux'
         name: run cpython platform-independent tests
+        env:
+          RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run:
           target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'Linux'
         name: run cpython platform-dependent tests (Linux)
+        env:
+          RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'macOS'
         name: run cpython platform-dependent tests (MacOS)
+        env:
+          RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'Windows'
         name: run cpython platform-dependent tests (windows partial - fixme)
+        env:
+          RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run:
           target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
         timeout-minutes: 45
 
+      - if: runner.os == 'Linux'
+        name: run cpython tests to check if env polluters have stopped polluting (Common/Linux)
+        shell: bash
+        run: |
+          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_LINUX }}; do
+            set +e
+            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+            exit_code=$?
+            set -e
+            if [ ${exit_code} -ne 3 ]; then
+              echo "Test ${thing} is no longer polluting the environment!"
+              exit 1
+            fi
+          done
+        timeout-minutes: 15
+
+      - if: runner.os == 'macOS'
+        name: run cpython tests to check if env polluters have stopped polluting (Common/macOS)
+        run: |
+          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_MACOS }}; do
+            set +e
+            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+            exit_code=$?
+            set -e
+            if [ ${exit_code} -ne 3 ]; then
+              echo "Test ${thing} is no longer polluting the environment!"
+              exit 1
+            fi
+          done
+        timeout-minutes: 15
+
+      - if: runner.os == 'Windows'
+        name: run cpython tests to check if env polluters have stopped polluting (Common/windows)
+        shell: bash
+        run: |
+          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_WINDOWS }}; do
+            set +e
+            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+            exit_code=$?
+            set -e
+            if [ ${exit_code} -ne 3 ]; then
+              echo "Test ${thing} is no longer polluting the environment!"
+              exit 1
+            fi
+          done
+        timeout-minutes: 15
+
       - if: runner.os != 'Windows'
         name: check that --install-pip succeeds
         run: |
diff --git a/Lib/test/test_file_eintr.py b/Lib/test/test_file_eintr.py
index fa9c6637fd4..f7d859028a2 100644
--- a/Lib/test/test_file_eintr.py
+++ b/Lib/test/test_file_eintr.py
@@ -186,6 +186,10 @@ def test_readall(self):
 class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
+    )
     # TODO: RUSTPYTHON - _io.FileIO.readall uses read_to_end which differs from _pyio.FileIO.readall
     @unittest.expectedFailure
     def test_readall(self):
diff --git a/Lib/test/test_importlib/resources/test_resource.py b/Lib/test/test_importlib/resources/test_resource.py
index 6f75cf57f03..54d32d9b29f 100644
--- a/Lib/test/test_importlib/resources/test_resource.py
+++ b/Lib/test/test_importlib/resources/test_resource.py
@@ -192,6 +192,11 @@ def test_is_file_failure_does_not_keep_open(self):
     def test_as_file_does_not_keep_open(self):  # pragma: no cover
         resources.as_file(resources.files('ziptestdata') / 'binary.file')
 
+    import os  # TODO: RUSTPYTHON see below
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to tmpfile leak"
+    )
     def test_entered_path_does_not_keep_open(self):
         """
         Mimic what certifi does on import to make its bundle
diff --git a/Lib/test/test_multiprocessing_fork/test_processes.py b/Lib/test/test_multiprocessing_fork/test_processes.py
index e64e9afc010..8c7e6b56896 100644
--- a/Lib/test/test_multiprocessing_fork/test_processes.py
+++ b/Lib/test/test_multiprocessing_fork/test_processes.py
@@ -3,5 +3,57 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify_all(self): super().test_notify_all()  # TODO: RUSTPYTHON
+
+class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
+
+class WithProcessesTestManagerRestart(WithProcessesTestManagerRestart):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_rapid_restart(self): super().test_rapid_restart()  # TODO: RUSTPYTHON
+
+class WithProcessesTestProcess(WithProcessesTestProcess):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_args_argument(self): super().test_args_argument()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_process(self): super().test_process()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPoolWorkerLifetime(WithProcessesTestPoolWorkerLifetime):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_pool_worker_lifetime(self): super().test_pool_worker_lifetime()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_pool_worker_lifetime_early_close(self): super().test_pool_worker_lifetime_early_close()  # TODO: RUSTPYTHON
+
+class WithProcessesTestQueue(WithProcessesTestQueue):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_fork(self): super().test_fork()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_get(self): super().test_get()  # TODO: RUSTPYTHON
+
+class WithProcessesTestSharedMemory(WithProcessesTestSharedMemory):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_shared_memory_SharedMemoryManager_basics(self): super().test_shared_memory_SharedMemoryManager_basics()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_fork/test_threads.py b/Lib/test/test_multiprocessing_fork/test_threads.py
index 1670e34cb17..b7b519bcb06 100644
--- a/Lib/test/test_multiprocessing_fork/test_threads.py
+++ b/Lib/test/test_multiprocessing_fork/test_threads.py
@@ -3,5 +3,17 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="threads")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+
+class WithThreadsTestManagerRestart(WithThreadsTestManagerRestart):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_rapid_restart(self): super().test_rapid_restart()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_forkserver/test_processes.py b/Lib/test/test_multiprocessing_forkserver/test_processes.py
index 360967cf1ae..5c159f10dd6 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_processes.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_processes.py
@@ -3,5 +3,35 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux',  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError'
+    )  # TODO: RUSTPYTHON
+    def test_repr_rlock(self): super().test_repr_rlock()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_forkserver/test_threads.py b/Lib/test/test_multiprocessing_forkserver/test_threads.py
index 719c752aa05..1524e7bac31 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_threads.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_threads.py
@@ -3,5 +3,13 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="threads")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_spawn/test_processes.py b/Lib/test/test_multiprocessing_spawn/test_processes.py
index af764b0d848..2d4655807d1 100644
--- a/Lib/test/test_multiprocessing_spawn/test_processes.py
+++ b/Lib/test/test_multiprocessing_spawn/test_processes.py
@@ -3,5 +3,35 @@
 
 install_tests_in_module_dict(globals(), 'spawn', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux',  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError'
+    )  # TODO: RUSTPYTHON
+    def test_repr_rlock(self): super().test_repr_rlock()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_spawn/test_threads.py b/Lib/test/test_multiprocessing_spawn/test_threads.py
index c1257749b9c..136e55ad287 100644
--- a/Lib/test/test_multiprocessing_spawn/test_threads.py
+++ b/Lib/test/test_multiprocessing_spawn/test_threads.py
@@ -3,5 +3,13 @@
 
 install_tests_in_module_dict(globals(), 'spawn', only_type="threads")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_raise.py b/Lib/test/test_raise.py
index 605169f4b40..8a2937ed3be 100644
--- a/Lib/test/test_raise.py
+++ b/Lib/test/test_raise.py
@@ -464,6 +464,11 @@ def f():
 
         f()
 
+    import os  # TODO: RUSTPYTHON see below
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unraisable exception"
+    )
     def test_3611(self):
         import gc
         # A re-raised exception in a __del__ caused the __context__
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 7450cd34143..42de7934955 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -4299,6 +4299,10 @@ def cb_returning_alert(ssl_sock, server_name, initial_context):
                                        sni_name='supermessage')
         self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_ACCESS_DENIED')
 
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unraisable exception"
+    )
     @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sni_callback_raising(self):
         # Raising fails the connection with a TLS handshake failure alert.
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 4d058652723..ce55eb596ed 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -1292,6 +1292,10 @@ def test_universal_newlines_communicate_stdin_stdout_stderr(self):
         self.assertTrue(stderr.startswith("eline2\neline6\neline7\n"))
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
+    )
     def test_universal_newlines_communicate_encodings(self):
         # Check that universal newlines mode works for various encodings,
         # in particular for encodings in the UTF-16 and UTF-32 families.
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 969c2866aac..fa4f9731cba 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -595,6 +595,11 @@ def g456():
             leave_g.set()
             t.join()
 
+    import os  # TODO: RUSTPYTHON see below
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to dangling threads"
+    )
     @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_current_exceptions'
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()

From e831124a21c2b7981a68e01ef67aed6a9a847eea Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 3 Jan 2026 18:43:16 -0500
Subject: [PATCH 238/418] Skip flaky tests in
 test.test_multiprocessing_fork.test_misc

---
 .../test_multiprocessing_fork/test_misc.py    | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/Lib/test/test_multiprocessing_fork/test_misc.py b/Lib/test/test_multiprocessing_fork/test_misc.py
index 891a494020c..bcf0858258e 100644
--- a/Lib/test/test_multiprocessing_fork/test_misc.py
+++ b/Lib/test/test_multiprocessing_fork/test_misc.py
@@ -3,5 +3,24 @@
 
 install_tests_in_module_dict(globals(), 'fork', exclude_types=True)
 
+import sys  # TODO: RUSTPYTHON
+class TestManagerExceptions(TestManagerExceptions):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_queue_get(self): super().test_queue_get()  # TODO: RUSTPYTHON
+
+@unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+class TestInitializers(TestInitializers): pass  # TODO: RUSTPYTHON
+
+class TestStartMethod(TestStartMethod):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_nested_startmethod(self): super().test_nested_startmethod()  # TODO: RUSTPYTHON
+
+@unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+class TestSyncManagerTypes(TestSyncManagerTypes): pass  # TODO: RUSTPYTHON
+
+class MiscTestCase(MiscTestCase):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_forked_thread_not_started(self): super().test_forked_thread_not_started()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()

From 3aa6bf8696f3e574419ef123bc549451aa28e65b Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 3 Jan 2026 19:35:23 -0500
Subject: [PATCH 239/418] Skip flaky tests in
 test.test_multiprocessing_fork.test_manager

Had to go with the nuclear option.
---
 .../test_multiprocessing_fork/test_manager.py   | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/Lib/test/test_multiprocessing_fork/test_manager.py b/Lib/test/test_multiprocessing_fork/test_manager.py
index 9efbb83bbb7..f8d7eddd652 100644
--- a/Lib/test/test_multiprocessing_fork/test_manager.py
+++ b/Lib/test/test_multiprocessing_fork/test_manager.py
@@ -3,5 +3,22 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="manager")
 
+import sys  # TODO: RUSTPYTHON
+class WithManagerTestCondition(WithManagerTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON, times out')
+    def test_notify_all(self): super().test_notify_all()  # TODO: RUSTPYTHON
+
+class WithManagerTestQueue(WithManagerTestQueue):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON, times out')
+    def test_fork(self): super().test_fork()  # TODO: RUSTPYTHON
+
+local_globs = globals().copy()  # TODO: RUSTPYTHON
+for name, base in local_globs.items():  # TODO: RUSTPYTHON
+    if name.startswith('WithManagerTest') and issubclass(base, unittest.TestCase):  # TODO: RUSTPYTHON
+        base = unittest.skipIf(  # TODO: RUSTPYTHON
+            sys.platform == 'linux',  # TODO: RUSTPYTHON
+            'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError'
+        )(base)  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()

From 34fe0f27704ada7147d9bc109bcaf077d845f991 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 3 Jan 2026 20:02:49 -0500
Subject: [PATCH 240/418] Skip flaky tests in test_regrtest

---
 Lib/test/test_regrtest.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index bef7dd536c6..e8b4fcdcde8 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -912,6 +912,7 @@ def test_module_from_test_autotest(self):
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_script_autotest(self):
         # Lib/test/autotest.py
         script = os.path.join(self.testdir, 'autotest.py')
@@ -2156,6 +2157,7 @@ def test_randint(self):
     def test_random_seed(self):
         self._check_random_seed(run_workers=False)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_random_seed_workers(self):
         self._check_random_seed(run_workers=True)
 

From dc9475c26b33464638d748568e94ae607de0459e Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 00:12:56 -0500
Subject: [PATCH 241/418] Mark flaky tests in test_ftplib

---
 Lib/test/test_ftplib.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index 2488f64a218..684f5d438b3 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -971,6 +971,7 @@ def test_data_connection(self):
                              LIST_DATA.encode(self.client.encoding))
         self.assertEqual(self.client.voidresp(), "226 transfer complete")
 
+    @unittest.skip('TODO: RUSTPYTHON flaky TimeoutError')
     def test_login(self):
         # login() is supposed to implicitly secure the control connection
         self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
@@ -983,6 +984,7 @@ def test_auth_issued_twice(self):
         self.client.auth()
         self.assertRaises(ValueError, self.client.auth)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky TimeoutError')
     def test_context(self):
         self.client.quit()
         ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)

From 55c71aa0ee1d252d7a52f57c9031d47a0285c2f3 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 12:45:21 -0500
Subject: [PATCH 242/418] Fix multiprocessing tests on Darwin

---
 .../test_processes.py                              | 14 ++++++++++----
 .../test_threads.py                                |  4 ++--
 .../test_multiprocessing_spawn/test_processes.py   | 12 ++++++++----
 .../test_multiprocessing_spawn/test_threads.py     |  2 +-
 4 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/Lib/test/test_multiprocessing_forkserver/test_processes.py b/Lib/test/test_multiprocessing_forkserver/test_processes.py
index 5c159f10dd6..94a37c5e633 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_processes.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_processes.py
@@ -4,9 +4,15 @@
 install_tests_in_module_dict(globals(), 'forkserver', only_type="processes")
 
 import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify(self): super().test_notify()
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify(self): super().test_notify_n()
+
 class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
@@ -18,17 +24,17 @@ def test_repr_rlock(self): super().test_repr_rlock()  # TODO: RUSTPYTHON
 
 class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
diff --git a/Lib/test/test_multiprocessing_forkserver/test_threads.py b/Lib/test/test_multiprocessing_forkserver/test_threads.py
index 1524e7bac31..1ca30b0bb83 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_threads.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_threads.py
@@ -3,10 +3,10 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="threads")
 
-import os, sys  # TODO: RUSTPYTHON
+import os  # TODO: RUSTPYTHON
 class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
diff --git a/Lib/test/test_multiprocessing_spawn/test_processes.py b/Lib/test/test_multiprocessing_spawn/test_processes.py
index 2d4655807d1..f3468a86a06 100644
--- a/Lib/test/test_multiprocessing_spawn/test_processes.py
+++ b/Lib/test/test_multiprocessing_spawn/test_processes.py
@@ -4,9 +4,13 @@
 install_tests_in_module_dict(globals(), 'spawn', only_type="processes")
 
 import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify(self): super().test_notify()
+
 class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
@@ -18,17 +22,17 @@ def test_repr_rlock(self): super().test_repr_rlock()  # TODO: RUSTPYTHON
 
 class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
diff --git a/Lib/test/test_multiprocessing_spawn/test_threads.py b/Lib/test/test_multiprocessing_spawn/test_threads.py
index 136e55ad287..f6aca3050e4 100644
--- a/Lib/test/test_multiprocessing_spawn/test_threads.py
+++ b/Lib/test/test_multiprocessing_spawn/test_threads.py
@@ -6,7 +6,7 @@
 import os, sys  # TODO: RUSTPYTHON
 class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
         'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )  # TODO: RUSTPYTHON
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON

From 9500f6609bf09a82ed3c5e466561da2e1a5438ed Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 13:49:50 -0500
Subject: [PATCH 243/418] Remove test_sys from list of environment polluters

---
 .github/workflows/ci.yaml | 1 -
 Lib/test/test_sys.py      | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 23164ff9fe1..ec28b35c571 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -108,7 +108,6 @@ env:
   ENV_POLLUTING_TESTS_COMMON: >-
     test_raise
     test_ssl
-    test_sys
   ENV_POLLUTING_TESTS_LINUX: >-
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index fa4f9731cba..969c2866aac 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -595,11 +595,6 @@ def g456():
             leave_g.set()
             t.join()
 
-    import os  # TODO: RUSTPYTHON see below
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to dangling threads"
-    )
     @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_current_exceptions'
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()

From 99168e076c5ac79b637763e1f9210a13b8b7ce31 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 14:24:33 -0500
Subject: [PATCH 244/418] Remove test_ftplib from list of environment polluters

---
 .github/workflows/ci.yaml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ec28b35c571..ea30ecbb219 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -126,7 +126,6 @@ env:
     test.test_multiprocessing_spawn.test_misc
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
-    test_ftplib
     test_logging
     test_multiprocessing_main_handling
     test_subprocess

From 34272156110cbd629df00112f8c8fd0903cb28ff Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 14:42:13 -0500
Subject: [PATCH 245/418] Add test.test_multiprocessing_fork.test_misc to list
 of environment polluters

---
 .github/workflows/ci.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ea30ecbb219..6b641b8a3e5 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -109,6 +109,7 @@ env:
     test_raise
     test_ssl
   ENV_POLLUTING_TESTS_LINUX: >-
+    test.test_multiprocessing_fork.test_misc
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
     test.test_multiprocessing_forkserver.test_processes

From 0d128ccc28bbabfc36869bb748e3aa9f5e09e430 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 15:11:20 -0500
Subject: [PATCH 246/418] Check 10 times if a test is still polluting the
 environment

---
 .github/workflows/ci.yaml | 48 +++++++++++++++++++++++++++------------
 1 file changed, 33 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 6b641b8a3e5..4cb2528a012 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -337,12 +337,18 @@ jobs:
         shell: bash
         run: |
           for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_LINUX }}; do
-            set +e
-            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
-            exit_code=$?
-            set -e
+            for i in $(seq 1 10); do
+              set +e
+              target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+              exit_code=$?
+              set -e
+              if [ ${exit_code} -eq 3 ]; then
+                echo "Test ${thing} polluted the environment on attempt ${i}."
+                break
+              fi
+            done
             if [ ${exit_code} -ne 3 ]; then
-              echo "Test ${thing} is no longer polluting the environment!"
+              echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
               exit 1
             fi
           done
@@ -352,12 +358,18 @@ jobs:
         name: run cpython tests to check if env polluters have stopped polluting (Common/macOS)
         run: |
           for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_MACOS }}; do
-            set +e
-            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
-            exit_code=$?
-            set -e
+            for i in $(seq 1 10); do
+              set +e
+              target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+              exit_code=$?
+              set -e
+              if [ ${exit_code} -eq 3 ]; then
+                echo "Test ${thing} polluted the environment on attempt ${i}."
+                break
+              fi
+            done
             if [ ${exit_code} -ne 3 ]; then
-              echo "Test ${thing} is no longer polluting the environment!"
+              echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
               exit 1
             fi
           done
@@ -368,12 +380,18 @@ jobs:
         shell: bash
         run: |
           for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_WINDOWS }}; do
-            set +e
-            target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
-            exit_code=$?
-            set -e
+            for i in $(seq 1 10); do
+              set +e
+              target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v ${thing}
+              exit_code=$?
+              set -e
+              if [ ${exit_code} -eq 3 ]; then
+                echo "Test ${thing} polluted the environment on attempt ${i}."
+                break
+              fi
+            done
             if [ ${exit_code} -ne 3 ]; then
-              echo "Test ${thing} is no longer polluting the environment!"
+              echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
               exit 1
             fi
           done

From 59b80e30eda1ad3eba81270404bc7447a61e031c Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 15:44:28 -0500
Subject: [PATCH 247/418] Save more of the test environment before a test is
 run

---
 Lib/test/libregrtest/setup.py  | 2 +-
 Lib/test/libregrtest/single.py | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Lib/test/libregrtest/setup.py b/Lib/test/libregrtest/setup.py
index 82dbf3855e4..704a4ccc681 100644
--- a/Lib/test/libregrtest/setup.py
+++ b/Lib/test/libregrtest/setup.py
@@ -54,7 +54,7 @@ def setup_process() -> None:
 
     adjust_rlimit_nofile()
 
-    # support.record_original_stdout(sys.stdout)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+    support.record_original_stdout(sys.stdout)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
 
     # Set sys.stdout encoder error handler to backslashreplace,
     # similar to sys.stderr error handler, to avoid UnicodeEncodeError
diff --git a/Lib/test/libregrtest/single.py b/Lib/test/libregrtest/single.py
index 84c92dcfe77..456eb53543e 100644
--- a/Lib/test/libregrtest/single.py
+++ b/Lib/test/libregrtest/single.py
@@ -176,10 +176,9 @@ def _runtest_env_changed_exc(result: TestResult, runtests: RunTests,
         clear_caches()
         support.gc_collect()
 
-        # with saved_test_environment(test_name,  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
-        #                             runtests.verbose, quiet, pgo=pgo):  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
-        #     _load_run_test(result, runtests)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
-        _load_run_test(result, runtests)
+        with saved_test_environment(test_name,  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+                                    runtests.verbose, quiet, pgo=pgo):  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+            _load_run_test(result, runtests)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
     except support.ResourceDenied as exc:
         if not quiet and not pgo:
             print(f"{test_name} skipped -- {exc}", flush=True)

From 0a826731cbd80b99f56999974ac5aa6886f07618 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 16:27:30 -0500
Subject: [PATCH 248/418] Mark test_import as polluting the environment

---
 .github/workflows/ci.yaml        | 1 +
 Lib/test/test_import/__init__.py | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 4cb2528a012..6e1f9150278 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -106,6 +106,7 @@ env:
     test_weakref
     test_yield_from
   ENV_POLLUTING_TESTS_COMMON: >-
+    test_import
     test_raise
     test_ssl
   ENV_POLLUTING_TESTS_LINUX: >-
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index abe8b75e7db..a8d11f5940f 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -432,6 +432,10 @@ def test_from_import_missing_attr_path_is_canonical(self):
         self.assertIn(cm.exception.name, {'posixpath', 'ntpath'})
         self.assertIsNotNone(cm.exception)
 
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_star_invalid_type(self):
         import re

From 2769c08a0de702966c3ce83fcaa634648a0ecbfe Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 16:29:48 -0500
Subject: [PATCH 249/418] Unmark passing test in test_regrtest

---
 Lib/test/test_regrtest.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index e8b4fcdcde8..9a2be2d48ee 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -1468,7 +1468,6 @@ def test_method4(self):
         subset = ['test_method1', 'test_method3']
         self.assertEqual(methods, subset)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_env_changed(self):
         code = textwrap.dedent("""
             import unittest

From 40da80714c80fb546e28038b01fa6b94b0950610 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 16:42:52 -0500
Subject: [PATCH 250/418] Mark flaky test in test_regrtest

---
 Lib/test/test_regrtest.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index 9a2be2d48ee..9f09413f59c 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -2160,6 +2160,7 @@ def test_random_seed(self):
     def test_random_seed_workers(self):
         self._check_random_seed(run_workers=True)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_python_command(self):
         code = textwrap.dedent(r"""
             import sys

From 8765d86355aa3311459d9fbe8d007c75e72adea8 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 17:10:50 -0500
Subject: [PATCH 251/418] Remove tests from list of environment polluters

---
 .github/workflows/ci.yaml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 6e1f9150278..0164076a556 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -110,7 +110,6 @@ env:
     test_raise
     test_ssl
   ENV_POLLUTING_TESTS_LINUX: >-
-    test.test_multiprocessing_fork.test_misc
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
     test.test_multiprocessing_forkserver.test_processes
@@ -120,12 +119,8 @@ env:
     test_file_eintr
     test_subprocess
   ENV_POLLUTING_TESTS_MACOS: >-
-    test_multiprocessing_forkserver.test_manager
-    test.test_multiprocessing_forkserver.test_misc
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
-    test.test_multiprocessing_spawn.test_manager
-    test.test_multiprocessing_spawn.test_misc
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
     test_logging

From 12811eb40c06c8bf3b1938eafd614947eef7b280 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 18:54:23 -0500
Subject: [PATCH 252/418] Skip flaky test in test_logging

---
 Lib/test/test_logging.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 529cb2dc2f1..752054b7290 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -4058,6 +4058,7 @@ def _mpinit_issue121723(qspec, message_to_log):
         # log a message (this creates a record put in the queue)
         logging.getLogger().info(message_to_log)
 
+    @unittest.skip('TODO: RUSTPYTHON, flaky EOFError')
     # TODO: RUSTPYTHON - SemLock not implemented on Windows
     @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @skip_if_tsan_fork

From d170b0281f2037a0476831cd7b836569d75f338e Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 18:56:08 -0500
Subject: [PATCH 253/418] Remove tests from list of polluting tests

---
 .github/workflows/ci.yaml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 0164076a556..e7d87547961 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -123,8 +123,6 @@ env:
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
-    test_logging
-    test_multiprocessing_main_handling
     test_subprocess
   ENV_POLLUTING_TESTS_WINDOWS: >-
   # Python version targeted by the CI.

From b76c0a20a83edf64b7a5cbdd90075e3a8a7b6a0c Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sun, 4 Jan 2026 22:47:53 -0500
Subject: [PATCH 254/418] Skip certain problematic tests in test_threading

---
 .github/workflows/ci.yaml  |  1 +
 Lib/test/test_threading.py | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index e7d87547961..d7893c18cb3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -118,6 +118,7 @@ env:
     test.test_multiprocessing_spawn.test_threads
     test_file_eintr
     test_subprocess
+    test_threading
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index a5ee24859cd..257ed9fb204 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -875,6 +875,10 @@ def noop_trace(frame, event, arg):
         finally:
             threading.settrace(old_trace)
 
+    @unittest.skipIf(
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
+    )
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_gettrace_all_threads(self):
@@ -915,6 +919,10 @@ def fn(*args): pass
         finally:
             threading.setprofile(old_profile)
 
+    @unittest.skipIf(
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
+    )
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_getprofile_all_threads(self):
@@ -1203,6 +1211,7 @@ def do_fork_and_wait():
         for t in threads:
             t.join()
 
+    @unittest.skip('TODO: RUSTPYTHON FAILURE, WORKER BUG')
     @support.requires_fork()
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -1528,6 +1537,7 @@ def setUp(self):
         restore_default_excepthook(self)
         super().setUp()
 
+    @unittest.skip('TODO: RUSTPYTHON, flaky')
     def test_excepthook(self):
         with support.captured_output("stderr") as stderr:
             thread = ThreadRunFail(name="excepthook thread")

From 98d8ebcc1dafa291724ed8e62cef2f4cc0fad5f0 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Mon, 5 Jan 2026 19:37:10 -0500
Subject: [PATCH 255/418] Skip test causing worker bug in test_builtin

---
 Lib/test/test_builtin.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 55585d9ef84..38fd9ab95ba 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -2271,6 +2271,7 @@ def test_input_tty_non_ascii_unicode_errors(self):
         # Check stdin/stdout error handler is used when invoking PyOS_Readline()
         self.check_input_tty("prompté", b"quux\xe9", "ascii")
 
+    @unittest.skip('TODO: RUSTPYTHON FAILURE, WORKER BUG')
     @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_no_stdout_fileno(self):
         # Issue #24402: If stdin is the original terminal but stdout.fileno()

From d1e75c0ee08352091e398805f6ac9622f28486c6 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Mon, 5 Jan 2026 20:10:35 -0500
Subject: [PATCH 256/418] Make env polluter skip in test_threading os-agnostic

---
 .github/workflows/ci.yaml  | 2 +-
 Lib/test/test_threading.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index d7893c18cb3..1412b5c2213 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -109,6 +109,7 @@ env:
     test_import
     test_raise
     test_ssl
+    test_threading
   ENV_POLLUTING_TESTS_LINUX: >-
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
@@ -118,7 +119,6 @@ env:
     test.test_multiprocessing_spawn.test_threads
     test_file_eintr
     test_subprocess
-    test_threading
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 257ed9fb204..eabc872583f 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -876,7 +876,7 @@ def noop_trace(frame, event, arg):
             threading.settrace(old_trace)
 
     @unittest.skipIf(
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
         "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
     )
     # TODO: RUSTPYTHON
@@ -920,7 +920,7 @@ def fn(*args): pass
             threading.setprofile(old_profile)
 
     @unittest.skipIf(
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
         "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
     )
     # TODO: RUSTPYTHON

From 55c309669bcb895a02e79bf717860300f60eaa75 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Mon, 5 Jan 2026 21:44:06 -0500
Subject: [PATCH 257/418] Remove test_file_eintr from list of polluters

---
 .github/workflows/ci.yaml   | 1 -
 Lib/test/test_file_eintr.py | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 1412b5c2213..94f00eba291 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -117,7 +117,6 @@ env:
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
-    test_file_eintr
     test_subprocess
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
diff --git a/Lib/test/test_file_eintr.py b/Lib/test/test_file_eintr.py
index f7d859028a2..fa9c6637fd4 100644
--- a/Lib/test/test_file_eintr.py
+++ b/Lib/test/test_file_eintr.py
@@ -186,10 +186,6 @@ def test_readall(self):
 class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
     modname = '_io'
 
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
-    )
     # TODO: RUSTPYTHON - _io.FileIO.readall uses read_to_end which differs from _pyio.FileIO.readall
     @unittest.expectedFailure
     def test_readall(self):

From a09ed1bf971d3b8c0efe6a5874da2bd7f689327d Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Tue, 6 Jan 2026 19:16:53 -0500
Subject: [PATCH 258/418] Remove test_subprocess from the list of polluters

---
 .github/workflows/ci.yaml   | 2 --
 Lib/test/test_subprocess.py | 4 ----
 2 files changed, 6 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 94f00eba291..c93eb7cabb3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -117,13 +117,11 @@ env:
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
-    test_subprocess
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
-    test_subprocess
   ENV_POLLUTING_TESTS_WINDOWS: >-
   # Python version targeted by the CI.
   PYTHON_VERSION: "3.13.1"
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index ce55eb596ed..4d058652723 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -1292,10 +1292,6 @@ def test_universal_newlines_communicate_stdin_stdout_stderr(self):
         self.assertTrue(stderr.startswith("eline2\neline6\neline7\n"))
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
-    )
     def test_universal_newlines_communicate_encodings(self):
         # Check that universal newlines mode works for various encodings,
         # in particular for encodings in the UTF-16 and UTF-32 families.

From e6d2ba06b1684e65b617572142abfb67a41b1e2b Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Wed, 7 Jan 2026 20:43:58 -0500
Subject: [PATCH 259/418] Address coderabbit comments

---
 .github/workflows/ci.yaml | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index c93eb7cabb3..8305cbb8e2a 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -341,6 +341,12 @@ jobs:
             done
             if [ ${exit_code} -ne 3 ]; then
               echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
+              echo "Please remove ${thing} from either ENV_POLLUTING_TESTS_COMMON or ENV_POLLUTING_TESTS_LINUX in '.github/workflows/ci.yaml'."
+              echo "Please also remove the skip decorators that include the word 'POLLUTERS' in ${thing}."
+              if [ ${exit_code} -ne 0 ]; then
+                echo "Test ${thing} failed with exit code ${exit_code}."
+                echo "Please investigate which test item in ${thing} is failing and either mark it as an expected failure or a skip."
+              fi
               exit 1
             fi
           done
@@ -348,6 +354,7 @@ jobs:
 
       - if: runner.os == 'macOS'
         name: run cpython tests to check if env polluters have stopped polluting (Common/macOS)
+        shell: bash
         run: |
           for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_MACOS }}; do
             for i in $(seq 1 10); do
@@ -362,6 +369,12 @@ jobs:
             done
             if [ ${exit_code} -ne 3 ]; then
               echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
+              echo "Please remove ${thing} from either ENV_POLLUTING_TESTS_COMMON or ENV_POLLUTING_TESTS_MACOS in '.github/workflows/ci.yaml'."
+              echo "Please also remove the skip decorators that include the word 'POLLUTERS' in ${thing}."
+              if [ ${exit_code} -ne 0 ]; then
+                echo "Test ${thing} failed with exit code ${exit_code}."
+                echo "Please investigate which test item in ${thing} is failing and either mark it as an expected failure or a skip."
+              fi
               exit 1
             fi
           done
@@ -384,6 +397,12 @@ jobs:
             done
             if [ ${exit_code} -ne 3 ]; then
               echo "Test ${thing} is no longer polluting the environment after ${i} attempts!"
+              echo "Please remove ${thing} from either ENV_POLLUTING_TESTS_COMMON or ENV_POLLUTING_TESTS_WINDOWS in '.github/workflows/ci.yaml'."
+              echo "Please also remove the skip decorators that include the word 'POLLUTERS' in ${thing}."
+              if [ ${exit_code} -ne 0 ]; then
+                echo "Test ${thing} failed with exit code ${exit_code}."
+                echo "Please investigate which test item in ${thing} is failing and either mark it as an expected failure or a skip."
+              fi
               exit 1
             fi
           done

From def6974bf689e49a29bc3194a6daf80e454b7277 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sat, 10 Jan 2026 16:01:29 +0900
Subject: [PATCH 260/418] fix threading._dangling

---
 Lib/test/libregrtest/save_env.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Lib/test/libregrtest/save_env.py b/Lib/test/libregrtest/save_env.py
index 02492124a61..f9bd6d87c4c 100644
--- a/Lib/test/libregrtest/save_env.py
+++ b/Lib/test/libregrtest/save_env.py
@@ -227,7 +227,9 @@ def restore_sys_warnoptions(self, saved_options):
     # to track reference leaks.
     def get_threading__dangling(self):
         # This copies the weakrefs without making any strong reference
-        return threading._dangling.copy()
+        # XXX: RUSTPYTHON - filter out dead threads since gc doesn't clean WeakSet. Revert this line when we have a GC
+        # return threading._dangling.copy()
+        return {t for t in threading._dangling if t.is_alive()}
     def restore_threading__dangling(self, saved):
         threading._dangling.clear()
         threading._dangling.update(saved)

From ae6deb7437b6dc5c7f7ba7bdd2805e6f7ed01029 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 12:21:25 -0500
Subject: [PATCH 261/418] Skip environment polluter in
 test.test_concurrent_futures.test_thread_pool

---
 .github/workflows/ci.yaml                     | 31 +++++++++----------
 .../test_thread_pool.py                       |  5 +++
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8305cbb8e2a..b51c59ddf73 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -118,6 +118,7 @@ env:
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_MACOS: >-
+    test.test_concurrent_futures.test_thread_pool
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
@@ -134,7 +135,7 @@ jobs:
     env:
       RUST_BACKTRACE: full
     name: Run rust tests
-    runs-on:  ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     timeout-minutes: 45
     strategy:
       matrix:
@@ -165,8 +166,7 @@ jobs:
         run: cargo check ${{ env.CARGO_ARGS }}
 
       - name: Test openssl build
-        run:
-          cargo build --no-default-features --features ssl-openssl
+        run: cargo build --no-default-features --features ssl-openssl
         if: runner.os == 'Linux'
 
       # - name: Install tk-dev for tkinter build
@@ -178,8 +178,7 @@ jobs:
       #   if: runner.os == 'Linux'
 
       - name: Test example projects
-        run:
-          cargo run --manifest-path example_projects/barebone/Cargo.toml
+        run: cargo run --manifest-path example_projects/barebone/Cargo.toml
           cargo run --manifest-path example_projects/frozen_stdlib/Cargo.toml
         if: runner.os == 'Linux'
 
@@ -266,7 +265,7 @@ jobs:
     env:
       RUST_BACKTRACE: full
     name: Run snippets and cpython tests
-    runs-on:  ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest, windows-2025]
@@ -298,8 +297,7 @@ jobs:
         name: run cpython platform-independent tests
         env:
           RUSTPYTHON_SKIP_ENV_POLLUTERS: true
-        run:
-          target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+        run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
         timeout-minutes: 35
 
       - if: runner.os == 'Linux'
@@ -320,8 +318,7 @@ jobs:
         name: run cpython platform-dependent tests (windows partial - fixme)
         env:
           RUSTPYTHON_SKIP_ENV_POLLUTERS: true
-        run:
-          target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
+        run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
         timeout-minutes: 45
 
       - if: runner.os == 'Linux'
@@ -433,7 +430,7 @@ jobs:
       - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
-            components: clippy
+          components: clippy
 
       - name: run clippy on wasm
         run: cargo clippy --manifest-path=crates/wasm/Cargo.toml -- -Dwarnings
@@ -470,7 +467,7 @@ jobs:
       - name: spell checker
         uses: streetsidesoftware/cspell-action@v8
         with:
-          files: '**/*.rs'
+          files: "**/*.rs"
           incremental_files_only: true
 
   miri:
@@ -485,17 +482,17 @@ jobs:
 
       - uses: dtolnay/rust-toolchain@master
         with:
-            toolchain: ${{ env.NIGHTLY_CHANNEL }}
-            components: miri
+          toolchain: ${{ env.NIGHTLY_CHANNEL }}
+          components: miri
 
       - uses: Swatinem/rust-cache@v2
 
       - name: Run tests under miri
         run: cargo +${{ env.NIGHTLY_CHANNEL }} miri test -p rustpython-vm -- miri_test
         env:
-        # miri-ignore-leaks because the type-object circular reference means that there will always be
-        # a memory leak, at least until we have proper cyclic gc
-          MIRIFLAGS: '-Zmiri-ignore-leaks'
+          # miri-ignore-leaks because the type-object circular reference means that there will always be
+          # a memory leak, at least until we have proper cyclic gc
+          MIRIFLAGS: "-Zmiri-ignore-leaks"
 
   wasm:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
diff --git a/Lib/test/test_concurrent_futures/test_thread_pool.py b/Lib/test/test_concurrent_futures/test_thread_pool.py
index 4a60aff4239..6e51aa5cdae 100644
--- a/Lib/test/test_concurrent_futures/test_thread_pool.py
+++ b/Lib/test/test_concurrent_futures/test_thread_pool.py
@@ -66,6 +66,11 @@ def submit(pool):
                 with futures.ProcessPoolExecutor(1, mp_context=mp.get_context('fork')) as workers:
                     workers.submit(tuple)
 
+    import sys  # TODO: RUSTPYTHON
+    @unittest.skipIf(
+        sys.platform == 'darwin' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        'TODO: RUSTPYTHON, TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )
     @support.requires_fork()
     @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
     @unittest.expectedFailure # TODO: RUSTPYTHON AssertionError: DeprecationWarning not triggered

From 1c07d3545e264226b3630f4d5b8d0c9c97c49ece Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 13:22:21 -0500
Subject: [PATCH 262/418] Make skip in test_thread_pool os-agnostic

---
 .github/workflows/ci.yaml                            | 1 +
 Lib/test/test_concurrent_futures/test_thread_pool.py | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b51c59ddf73..05dedc50d09 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -111,6 +111,7 @@ env:
     test_ssl
     test_threading
   ENV_POLLUTING_TESTS_LINUX: >-
+    test.test_concurrent_futures.test_thread_pool
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
     test.test_multiprocessing_forkserver.test_processes
diff --git a/Lib/test/test_concurrent_futures/test_thread_pool.py b/Lib/test/test_concurrent_futures/test_thread_pool.py
index 6e51aa5cdae..52df01b376c 100644
--- a/Lib/test/test_concurrent_futures/test_thread_pool.py
+++ b/Lib/test/test_concurrent_futures/test_thread_pool.py
@@ -68,8 +68,8 @@ def submit(pool):
 
     import sys  # TODO: RUSTPYTHON
     @unittest.skipIf(
-        sys.platform == 'darwin' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        'TODO: RUSTPYTHON, TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
     )
     @support.requires_fork()
     @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')

From 1642959b927f778edea6aeca9d8f0de5bee5e115 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 14:11:22 -0500
Subject: [PATCH 263/418] Skip problematic tests in test_wait

---
 Lib/test/test_concurrent_futures/test_wait.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/Lib/test/test_concurrent_futures/test_wait.py b/Lib/test/test_concurrent_futures/test_wait.py
index cc387883141..7a7857671a4 100644
--- a/Lib/test/test_concurrent_futures/test_wait.py
+++ b/Lib/test/test_concurrent_futures/test_wait.py
@@ -200,6 +200,20 @@ def future_func():
 def setUpModule():
     setup_module()
 
+class ProcessPoolForkWaitTest(ProcessPoolForkWaitTest):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_first_completed(self): super().test_first_completed()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON Fatal Python error: Segmentation fault")
+    def test_first_completed_some_already_completed(self): super().test_first_completed_some_already_completed()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_first_exception(self): super().test_first_exception()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_first_exception_one_already_failed(self): super().test_first_exception_one_already_failed()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON Fatal Python error: Segmentation fault")
+    def test_first_exception_some_already_complete(self): super().test_first_exception_some_already_complete()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON Fatal Python error: Segmentation fault")
+    def test_timeout(self): super().test_timeout()  # TODO: RUSTPYTHON
+
 
 if __name__ == "__main__":
     unittest.main()

From daaae22077f44f5b9d8e7998c28ac53913e75ccb Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 15:00:46 -0500
Subject: [PATCH 264/418] Skip flaky tests in test_process_pool

---
 Lib/test/test_concurrent_futures/test_process_pool.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
index 17d311888a6..99b71676ae7 100644
--- a/Lib/test/test_concurrent_futures/test_process_pool.py
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -229,6 +229,13 @@ def mock_start_new_thread(func, *args, **kwargs):
 def setUpModule():
     setup_module()
 
+class ProcessPoolSpawnProcessPoolExecutorTest(ProcessPoolSpawnProcessPoolExecutorTest):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_saturation(self): super().test_saturation()  # TODO: RUSTPYTHON
+
+class ProcessPoolForkProcessPoolExecutorTest(ProcessPoolForkProcessPoolExecutorTest):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_ressources_gced_in_workers(self): super().test_ressources_gced_in_workers()  # TODO: RUSTPYTHON
 
 if __name__ == "__main__":
     unittest.main()

From 717265a59a12f17231ec2ca42d3d814ef2187c74 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 16:01:53 -0500
Subject: [PATCH 265/418] Remove test_import from list of polluters

---
 .github/workflows/ci.yaml        | 1 -
 Lib/test/test_import/__init__.py | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 05dedc50d09..5ac838a6bbf 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -106,7 +106,6 @@ env:
     test_weakref
     test_yield_from
   ENV_POLLUTING_TESTS_COMMON: >-
-    test_import
     test_raise
     test_ssl
     test_threading
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index a8d11f5940f..abe8b75e7db 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -432,10 +432,6 @@ def test_from_import_missing_attr_path_is_canonical(self):
         self.assertIn(cm.exception.name, {'posixpath', 'ntpath'})
         self.assertIsNotNone(cm.exception)
 
-    @unittest.skipIf(  # TODO: RUSTPYTHON
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
-        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
-    )  # TODO: RUSTPYTHON
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_star_invalid_type(self):
         import re

From 80af69e625de59a948b45f8d19cc6941ff7e4572 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 18:23:58 -0500
Subject: [PATCH 266/418] Amend skips in
 test.test_multiprocessing_forkserver.test_processes

---
 Lib/test/test_multiprocessing_forkserver/test_processes.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Lib/test/test_multiprocessing_forkserver/test_processes.py b/Lib/test/test_multiprocessing_forkserver/test_processes.py
index 94a37c5e633..a4a2aa21a3c 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_processes.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_processes.py
@@ -5,10 +5,10 @@
 
 import os, sys  # TODO: RUSTPYTHON
 class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
+    @unittest.skip('TODO: RUSTPYTHON flaky timeout')
     def test_notify(self): super().test_notify()
-    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
-    def test_notify(self): super().test_notify_n()
+    @unittest.skip('TODO: RUSTPYTHON flaky timeout')
+    def test_notify_n(self): super().test_notify_n()
 
 class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
     @unittest.skipIf(  # TODO: RUSTPYTHON

From 8d505dc0e50cf929b06037f7208fa02a7edeb9d2 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 18:51:41 -0500
Subject: [PATCH 267/418] Remove test_raise from list of polluters

---
 .github/workflows/ci.yaml | 1 -
 Lib/test/test_raise.py    | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 5ac838a6bbf..2ce5016c4e3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -106,7 +106,6 @@ env:
     test_weakref
     test_yield_from
   ENV_POLLUTING_TESTS_COMMON: >-
-    test_raise
     test_ssl
     test_threading
   ENV_POLLUTING_TESTS_LINUX: >-
diff --git a/Lib/test/test_raise.py b/Lib/test/test_raise.py
index 8a2937ed3be..605169f4b40 100644
--- a/Lib/test/test_raise.py
+++ b/Lib/test/test_raise.py
@@ -464,11 +464,6 @@ def f():
 
         f()
 
-    import os  # TODO: RUSTPYTHON see below
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unraisable exception"
-    )
     def test_3611(self):
         import gc
         # A re-raised exception in a __del__ caused the __context__

From f9a1f2bda8021f56038651c6aefa90f1875d3761 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 21:37:25 -0500
Subject: [PATCH 268/418] Remove test_ssl from list of polluters

---
 .github/workflows/ci.yaml | 1 -
 Lib/test/test_ssl.py      | 4 ----
 2 files changed, 5 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 2ce5016c4e3..b37082bff9e 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -106,7 +106,6 @@ env:
     test_weakref
     test_yield_from
   ENV_POLLUTING_TESTS_COMMON: >-
-    test_ssl
     test_threading
   ENV_POLLUTING_TESTS_LINUX: >-
     test.test_concurrent_futures.test_thread_pool
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 42de7934955..7450cd34143 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -4299,10 +4299,6 @@ def cb_returning_alert(ssl_sock, server_name, initial_context):
                                        sni_name='supermessage')
         self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_ACCESS_DENIED')
 
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unraisable exception"
-    )
     @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sni_callback_raising(self):
         # Raising fails the connection with a TLS handshake failure alert.

From 7445b27083c5e9c5e10a09d1e3472ab452a79ba8 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 21:39:00 -0500
Subject: [PATCH 269/418] Skip flaky test in test_ssl

---
 Lib/test/test_ssl.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 7450cd34143..5384e4caf69 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -2891,6 +2891,7 @@ def test_echo(self):
                 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
                 str(e.exception))
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     @unittest.skipUnless(support.Py_GIL_DISABLED, "test is only useful if the GIL is disabled")
     def test_ssl_in_multiple_threads(self):
         # See GH-124984: OpenSSL is not thread safe.

From 1dcded40b86444c2a359253d8761a8bdf1f17be5 Mon Sep 17 00:00:00 2001
From: Padraic Fanning <fanninpm@miamioh.edu>
Date: Sat, 10 Jan 2026 22:52:29 -0500
Subject: [PATCH 270/418] Fix YAML formatting issue

---
 .github/workflows/ci.yaml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b37082bff9e..d15e01dbd6c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -176,7 +176,8 @@ jobs:
       #   if: runner.os == 'Linux'
 
       - name: Test example projects
-        run: cargo run --manifest-path example_projects/barebone/Cargo.toml
+        run: |
+          cargo run --manifest-path example_projects/barebone/Cargo.toml
           cargo run --manifest-path example_projects/frozen_stdlib/Cargo.toml
         if: runner.os == 'Linux'
 

From f2d559428823b32134c798553993cfb06d28f617 Mon Sep 17 00:00:00 2001
From: Jeong YunWon <jeong@youknowone.org>
Date: Sun, 11 Jan 2026 00:45:55 +0900
Subject: [PATCH 271/418] fix_test --quick-import

---
 scripts/fix_test.py | 49 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 46 insertions(+), 3 deletions(-)

diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index 49a2e1870ea..4b3e0bfddda 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -3,7 +3,15 @@
 It adds @unittest.expectedFailure to the test functions that are failing in RustPython, but not in CPython.
 As well as marking the test with a TODO comment.
 
-How to use:
+Quick Import (recommended):
+    python ./scripts/fix_test.py --quick-import cpython/Lib/test/test_foo.py
+
+    This will:
+    1. Copy cpython/Lib/test/test_foo.py to Lib/test/test_foo.py (if not exists)
+    2. Run the test with RustPython
+    3. Mark failing tests with @unittest.expectedFailure
+
+Manual workflow:
 1. Copy a specific test from the CPython repository to the RustPython repository.
 2. Remove all unexpected failures from the test and skip the tests that hang.
 3. Build RustPython: cargo build --release
@@ -15,6 +23,7 @@
 """
 
 import argparse
+import shutil
 import sys
 from pathlib import Path
 
@@ -23,7 +32,14 @@
 
 def parse_args():
     parser = argparse.ArgumentParser(description="Fix test.")
-    parser.add_argument("--path", type=Path, help="Path to test file")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--path", type=Path, help="Path to test file")
+    group.add_argument(
+        "--quick-import",
+        type=Path,
+        metavar="PATH",
+        help="Import from path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
+    )
     parser.add_argument("--force", action="store_true", help="Force modification")
     parser.add_argument(
         "--platform", action="store_true", help="Platform specific failure"
@@ -122,7 +138,7 @@ def run_test(test_name):
     import subprocess
 
     result = subprocess.run(
-        [rustpython_location, "-m", "test", "-v", test_name],
+        [rustpython_location, "-m", "test", "-v", "-u", "all", "--slowest", test_name],
         capture_output=True,
         text=True,
     )
@@ -131,6 +147,33 @@ def run_test(test_name):
 
 if __name__ == "__main__":
     args = parse_args()
+
+    # Handle --quick-import: extract Lib/... path and copy if needed
+    if args.quick_import is not None:
+        src_str = str(args.quick_import)
+        lib_marker = "/Lib/"
+
+        if lib_marker not in src_str:
+            print(f"Error: --quick-import path must contain '/Lib/' (got: {src_str})")
+            sys.exit(1)
+
+        idx = src_str.index(lib_marker)
+        lib_path = Path(src_str[idx + 1 :])  # Lib/test/foo.py
+        src_path = args.quick_import
+
+        if not src_path.exists():
+            print(f"Error: Source file not found: {src_path}")
+            sys.exit(1)
+
+        if not lib_path.exists():
+            print(f"Copying: {src_path} -> {lib_path}")
+            lib_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(src_path, lib_path)
+        else:
+            print(f"File already exists: {lib_path}")
+
+        args.path = lib_path
+
     test_path = args.path.resolve()
     if not test_path.exists():
         print(f"Error: File not found: {test_path}")

From 29bb8b47cd14991ed3d21a4d90357fcb32c0ddbc Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 11 Jan 2026 17:59:32 +0900
Subject: [PATCH 272/418] Super instructions (#6694)

* super instructions

* Fix classcell

* ZeroArg
---
 Lib/_opcode_metadata.py                       |   3 +
 crates/codegen/src/compile.rs                 | 221 +++++++++++++++++-
 crates/codegen/src/ir.rs                      |  26 ++-
 crates/codegen/src/symboltable.rs             |  68 ++++--
 crates/compiler-core/src/bytecode.rs          |  15 ++
 .../compiler-core/src/bytecode/instruction.rs |  45 +++-
 crates/vm/src/frame.rs                        |  47 ++++
 7 files changed, 389 insertions(+), 36 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 40cd95cca0c..560523bfab2 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -138,6 +138,9 @@
     'JUMP_IF_NOT_EXC_MATCH': 131,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
+    'LOAD_SUPER_METHOD': 136,
+    'LOAD_ZERO_SUPER_ATTR': 137,
+    'LOAD_ZERO_SUPER_METHOD': 138,
     'RESUME': 149,
     'JUMP': 252,
     'LOAD_CLOSURE': 253,
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index a04f5ad0dfa..b7bc3f4d9c7 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -75,6 +75,18 @@ pub enum FBlockDatum {
     ExceptionName(String),
 }
 
+/// Type of super() call optimization detected by can_optimize_super_call()
+#[derive(Debug, Clone)]
+enum SuperCallType<'a> {
+    /// super(class, self) - explicit 2-argument form
+    TwoArg {
+        class_arg: &'a Expr,
+        self_arg: &'a Expr,
+    },
+    /// super() - implicit 0-argument form (uses __class__ cell)
+    ZeroArg,
+}
+
 #[derive(Debug, Clone)]
 pub struct FBlockInfo {
     pub fb_type: FBlockType,
@@ -661,6 +673,153 @@ impl Compiler {
         self.symbol_table_stack.pop().expect("compiler bug")
     }
 
+    /// Check if a super() call can be optimized
+    /// Returns Some(SuperCallType) if optimization is possible, None otherwise
+    fn can_optimize_super_call<'a>(
+        &self,
+        value: &'a Expr,
+        attr: &str,
+    ) -> Option<SuperCallType<'a>> {
+        use ruff_python_ast::*;
+
+        // 1. value must be a Call expression
+        let Expr::Call(ExprCall {
+            func, arguments, ..
+        }) = value
+        else {
+            return None;
+        };
+
+        // 2. func must be Name("super")
+        let Expr::Name(ExprName { id, .. }) = func.as_ref() else {
+            return None;
+        };
+        if id.as_str() != "super" {
+            return None;
+        }
+
+        // 3. attr must not be "__class__"
+        if attr == "__class__" {
+            return None;
+        }
+
+        // 4. No keyword arguments
+        if !arguments.keywords.is_empty() {
+            return None;
+        }
+
+        // 5. Must be inside a function (not at module level or class body)
+        if !self.ctx.in_func() {
+            return None;
+        }
+
+        // 6. "super" must be GlobalImplicit (not redefined locally or at module level)
+        let table = self.current_symbol_table();
+        if let Some(symbol) = table.lookup("super")
+            && symbol.scope != SymbolScope::GlobalImplicit
+        {
+            return None;
+        }
+        // Also check top-level scope to detect module-level shadowing.
+        // Only block if super is actually *bound* at module level (not just used).
+        if let Some(top_table) = self.symbol_table_stack.first()
+            && let Some(sym) = top_table.lookup("super")
+            && sym.scope != SymbolScope::GlobalImplicit
+        {
+            return None;
+        }
+
+        // 7. Check argument pattern
+        let args = &arguments.args;
+
+        // No starred expressions allowed
+        if args.iter().any(|arg| matches!(arg, Expr::Starred(_))) {
+            return None;
+        }
+
+        match args.len() {
+            2 => {
+                // 2-arg: super(class, self)
+                Some(SuperCallType::TwoArg {
+                    class_arg: &args[0],
+                    self_arg: &args[1],
+                })
+            }
+            0 => {
+                // 0-arg: super() - need __class__ cell and first parameter
+                // Enclosing function should have at least one positional argument
+                let info = self.code_stack.last()?;
+                if info.metadata.argcount == 0 && info.metadata.posonlyargcount == 0 {
+                    return None;
+                }
+
+                // Check if __class__ is available as a cell/free variable
+                // The scope must be Free (from enclosing class) or have FREE_CLASS flag
+                if let Some(symbol) = table.lookup("__class__") {
+                    if symbol.scope != SymbolScope::Free
+                        && !symbol.flags.contains(SymbolFlags::FREE_CLASS)
+                    {
+                        return None;
+                    }
+                } else {
+                    // __class__ not in symbol table, optimization not possible
+                    return None;
+                }
+
+                Some(SuperCallType::ZeroArg)
+            }
+            _ => None, // 1 or 3+ args - not optimizable
+        }
+    }
+
+    /// Load arguments for super() optimization onto the stack
+    /// Stack result: [global_super, class, self]
+    fn load_args_for_super(&mut self, super_type: &SuperCallType<'_>) -> CompileResult<()> {
+        // 1. Load global super
+        self.compile_name("super", NameUsage::Load)?;
+
+        match super_type {
+            SuperCallType::TwoArg {
+                class_arg,
+                self_arg,
+            } => {
+                // 2-arg: load provided arguments
+                self.compile_expression(class_arg)?;
+                self.compile_expression(self_arg)?;
+            }
+            SuperCallType::ZeroArg => {
+                // 0-arg: load __class__ cell and first parameter
+                // Load __class__ from cell/free variable
+                let scope = self.get_ref_type("__class__").map_err(|e| self.error(e))?;
+                let idx = match scope {
+                    SymbolScope::Cell => self.get_cell_var_index("__class__")?,
+                    SymbolScope::Free => self.get_free_var_index("__class__")?,
+                    _ => {
+                        return Err(self.error(CodegenErrorType::SyntaxError(
+                            "super(): __class__ cell not found".to_owned(),
+                        )));
+                    }
+                };
+                self.emit_arg(idx, Instruction::LoadDeref);
+
+                // Load first parameter (typically 'self').
+                // Safety: can_optimize_super_call() ensures argcount > 0, and
+                // parameters are always added to varnames first (see symboltable.rs).
+                let first_param = {
+                    let info = self.code_stack.last().unwrap();
+                    info.metadata.varnames.first().cloned()
+                };
+                let first_param = first_param.ok_or_else(|| {
+                    self.error(CodegenErrorType::SyntaxError(
+                        "super(): no arguments and no first parameter".to_owned(),
+                    ))
+                })?;
+                self.compile_name(&first_param, NameUsage::Load)?;
+            }
+        }
+        Ok(())
+    }
+
     /// Check if this is an inlined comprehension context (PEP 709)
     /// Currently disabled - always returns false to avoid stack issues
     fn is_inlined_comprehension_context(&self, _comprehension_type: ComprehensionType) -> bool {
@@ -3357,12 +3516,14 @@ impl Compiler {
     /// Determines if a variable should be CELL or FREE type
     // = get_ref_type
     fn get_ref_type(&self, name: &str) -> Result<SymbolScope, CodegenErrorType> {
+        let table = self.symbol_table_stack.last().unwrap();
+
         // Special handling for __class__ and __classdict__ in class scope
-        if self.ctx.in_class && (name == "__class__" || name == "__classdict__") {
+        // This should only apply when we're actually IN a class body,
+        // not when we're in a method nested inside a class.
+        if table.typ == CompilerScope::Class && (name == "__class__" || name == "__classdict__") {
             return Ok(SymbolScope::Cell);
         }
-
-        let table = self.symbol_table_stack.last().unwrap();
         match table.lookup(name) {
             Some(symbol) => match symbol.scope {
                 SymbolScope::Cell => Ok(SymbolScope::Cell),
@@ -5732,9 +5893,28 @@ impl Compiler {
                 };
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::LoadAttr { idx });
+                // Check for super() attribute access optimization
+                if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
+                    // super().attr or super(cls, self).attr optimization
+                    // Stack: [global_super, class, self] → LOAD_SUPER_ATTR → [attr]
+                    self.load_args_for_super(&super_type)?;
+                    let idx = self.name(attr.as_str());
+                    match super_type {
+                        SuperCallType::TwoArg { .. } => {
+                            // LoadSuperAttr (pseudo) - will be converted to real LoadSuperAttr
+                            // with flags=0b10 (has_class=true, load_method=false) in ir.rs
+                            emit!(self, Instruction::LoadSuperAttr { arg: idx });
+                        }
+                        SuperCallType::ZeroArg => {
+                            emit!(self, Instruction::LoadZeroSuperAttr { idx });
+                        }
+                    }
+                } else {
+                    // Normal attribute access
+                    self.compile_expression(value)?;
+                    let idx = self.name(attr.as_str());
+                    emit!(self, Instruction::LoadAttr { idx });
+                }
             }
             Expr::Compare(ExprCompare {
                 left,
@@ -6159,12 +6339,29 @@ impl Compiler {
         // Method call: obj → LOAD_ATTR_METHOD → [method, self_or_null] → args → CALL
         // Regular call: func → PUSH_NULL → args → CALL
         if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
-            // Method call: compile object, then LOAD_ATTR_METHOD
-            // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
-            self.compile_expression(value)?;
-            let idx = self.name(attr.as_str());
-            emit!(self, Instruction::LoadAttrMethod { idx });
-            self.compile_call_helper(0, args)?;
+            // Check for super() method call optimization
+            if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
+                // super().method() or super(cls, self).method() optimization
+                // Stack: [global_super, class, self] → LOAD_SUPER_METHOD → [method, self]
+                self.load_args_for_super(&super_type)?;
+                let idx = self.name(attr.as_str());
+                match super_type {
+                    SuperCallType::TwoArg { .. } => {
+                        emit!(self, Instruction::LoadSuperMethod { idx });
+                    }
+                    SuperCallType::ZeroArg => {
+                        emit!(self, Instruction::LoadZeroSuperMethod { idx });
+                    }
+                }
+                self.compile_call_helper(0, args)?;
+            } else {
+                // Normal method call: compile object, then LOAD_ATTR_METHOD
+                // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
+                self.compile_expression(value)?;
+                let idx = self.name(attr.as_str());
+                emit!(self, Instruction::LoadAttrMethod { idx });
+                self.compile_call_helper(0, args)?;
+            }
         } else {
             // Regular call: push func, then NULL for self_or_null slot
             // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 298566d7ad7..82b9921911c 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -6,7 +6,7 @@ use rustpython_compiler_core::{
     bytecode::{
         Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
         InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
-        encode_exception_table, encode_load_attr_arg,
+        encode_exception_table, encode_load_attr_arg, encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -212,6 +212,30 @@ impl CodeInfo {
                     Instruction::PopBlock => {
                         info.instr = Instruction::Nop;
                     }
+                    // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
+                    Instruction::LoadSuperMethod { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    }
+                    // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
+                    Instruction::LoadZeroSuperAttr { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    }
+                    // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
+                    Instruction::LoadZeroSuperMethod { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    }
+                    // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
+                    Instruction::LoadSuperAttr { arg: idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, true);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    }
                     _ => {}
                 }
             }
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 47a6ccbbf30..22b5bf358a1 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -21,6 +21,7 @@ use ruff_python_ast::{
 };
 use ruff_text_size::{Ranged, TextRange};
 use rustpython_compiler_core::{PositionEncoding, SourceFile, SourceLocation};
+use std::collections::HashSet;
 
 /// Captures all symbols in the current scope, and has a list of sub-scopes in this scope.
 #[derive(Clone)]
@@ -244,30 +245,29 @@ impl core::fmt::Debug for SymbolTable {
 */
 fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
     let mut analyzer = SymbolTableAnalyzer::default();
-    analyzer.analyze_symbol_table(symbol_table)
+    // Discard the newfree set at the top level - it's only needed for propagation
+    let _newfree = analyzer.analyze_symbol_table(symbol_table)?;
+    Ok(())
 }
 
 /* Drop __class__ and __classdict__ from free variables in class scope
    and set the appropriate flags. Equivalent to CPython's drop_class_free().
    See: https://github.com/python/cpython/blob/main/Python/symtable.c#L884
+
+   This function removes __class__ and __classdict__ from the
+   `newfree` set (which contains free variables collected from all child scopes)
+   and sets the corresponding flags on the class's symbol table entry.
 */
-fn drop_class_free(symbol_table: &mut SymbolTable) {
-    // Check if __class__ is used as a free variable
-    if let Some(class_symbol) = symbol_table.symbols.get("__class__")
-        && class_symbol.scope == SymbolScope::Free
-    {
+fn drop_class_free(symbol_table: &mut SymbolTable, newfree: &mut HashSet<String>) {
+    // Check if __class__ is in the free variables collected from children
+    // If found, it means a child scope (method) references __class__
+    if newfree.remove("__class__") {
         symbol_table.needs_class_closure = true;
-        // Note: In CPython, the symbol is removed from the free set,
-        // but in RustPython we handle this differently during code generation
     }
 
-    // Check if __classdict__ is used as a free variable
-    if let Some(classdict_symbol) = symbol_table.symbols.get("__classdict__")
-        && classdict_symbol.scope == SymbolScope::Free
-    {
+    // Check if __classdict__ is in the free variables collected from children
+    if newfree.remove("__classdict__") {
         symbol_table.needs_classdict = true;
-        // Note: In CPython, the symbol is removed from the free set,
-        // but in RustPython we handle this differently during code generation
     }
 }
 
@@ -337,16 +337,26 @@ struct SymbolTableAnalyzer {
 }
 
 impl SymbolTableAnalyzer {
-    fn analyze_symbol_table(&mut self, symbol_table: &mut SymbolTable) -> SymbolTableResult {
+    /// Analyze a symbol table and return the set of free variables.
+    /// See symtable.c analyze_block().
+    fn analyze_symbol_table(
+        &mut self,
+        symbol_table: &mut SymbolTable,
+    ) -> SymbolTableResult<HashSet<String>> {
         let symbols = core::mem::take(&mut symbol_table.symbols);
         let sub_tables = &mut *symbol_table.sub_tables;
 
+        // Collect free variables from all child scopes
+        let mut newfree = HashSet::new();
+
         let mut info = (symbols, symbol_table.typ);
         self.tables.with_append(&mut info, |list| {
             let inner_scope = unsafe { &mut *(list as *mut _ as *mut Self) };
-            // Analyze sub scopes:
+            // Analyze sub scopes and collect their free variables
             for sub_table in sub_tables.iter_mut() {
-                inner_scope.analyze_symbol_table(sub_table)?;
+                let child_free = inner_scope.analyze_symbol_table(sub_table)?;
+                // Propagate child's free variables to this scope
+                newfree.extend(child_free);
             }
             Ok(())
         })?;
@@ -384,17 +394,25 @@ impl SymbolTableAnalyzer {
             }
         }
 
-        // Analyze symbols:
+        // Analyze symbols in current scope
         for symbol in symbol_table.symbols.values_mut() {
             self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
+
+            // Collect free variables from this scope
+            // These will be propagated to the parent scope
+            if symbol.scope == SymbolScope::Free || symbol.flags.contains(SymbolFlags::FREE_CLASS) {
+                newfree.insert(symbol.name.clone());
+            }
         }
 
-        // Handle class-specific implicit cells (like CPython)
+        // Handle class-specific implicit cells
+        // This removes __class__ and __classdict__ from newfree if present
+        // and sets the corresponding flags on the symbol table
         if symbol_table.typ == CompilerScope::Class {
-            drop_class_free(symbol_table);
+            drop_class_free(symbol_table, &mut newfree);
         }
 
-        Ok(())
+        Ok(newfree)
     }
 
     fn analyze_symbol(
@@ -475,6 +493,14 @@ impl SymbolTableAnalyzer {
             {
                 continue;
             }
+
+            // __class__ is implicitly declared in class scope
+            // This handles the case where super() is called in a nested class method
+            if name == "__class__" && matches!(typ, CompilerScope::Class) {
+                decl_depth = Some(i);
+                break;
+            }
+
             if let Some(sym) = symbols.get(name) {
                 match sym.scope {
                     SymbolScope::GlobalExplicit => return Some(SymbolScope::GlobalExplicit),
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 61707b7757e..5270b89f3ad 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -102,6 +102,21 @@ pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
     (name_idx, is_method)
 }
 
+/// Encode LOAD_SUPER_ATTR oparg: bit 0 = load_method, bit 1 = has_class, bits 2+ = name index.
+#[inline]
+pub const fn encode_load_super_attr_arg(name_idx: u32, load_method: bool, has_class: bool) -> u32 {
+    (name_idx << 2) | ((has_class as u32) << 1) | (load_method as u32)
+}
+
+/// Decode LOAD_SUPER_ATTR oparg: returns (name_idx, load_method, has_class).
+#[inline]
+pub const fn decode_load_super_attr_arg(oparg: u32) -> (u32, bool, bool) {
+    let load_method = (oparg & 1) == 1;
+    let has_class = (oparg & 2) == 2;
+    let name_idx = oparg >> 2;
+    (name_idx, load_method, has_class)
+}
+
 /// Oparg values for [`Instruction::ConvertValue`].
 ///
 /// ## See also
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 24cccbb3ed2..c41da105a3d 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -6,6 +6,7 @@ use crate::{
         Arg, BinaryOperator, BorrowedConstant, BuildSliceArgCount, ComparisonOperator, Constant,
         ConvertValueOparg, InstrDisplayContext, IntrinsicFunction1, IntrinsicFunction2, Invert,
         Label, MakeFunctionFlags, NameIdx, OpArg, RaiseKind, UnpackExArgs, decode_load_attr_arg,
+        decode_load_super_attr_arg,
     },
     marshal::MarshalError,
 };
@@ -175,7 +176,7 @@ pub enum Instruction {
     LoadName(Arg<NameIdx>) = 92,
     LoadSuperAttr {
         arg: Arg<u32>,
-    } = 93, // Placeholder
+    } = 93,
     MakeCell(Arg<NameIdx>) = 94, // Placeholder
     MapAdd {
         i: Arg<u32>,
@@ -243,6 +244,20 @@ pub enum Instruction {
     Resume {
         arg: Arg<u32>,
     } = 149,
+    // ===== LOAD_SUPER_* Pseudo Opcodes (136-138) =====
+    // These are converted to LoadSuperAttr during bytecode finalization.
+    // "Zero" variants are for 0-arg super() calls (has_class=false).
+    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
+    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
+    LoadSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 136, // CPython uses pseudo-op 260
+    LoadZeroSuperAttr {
+        idx: Arg<NameIdx>,
+    } = 137, // CPython uses pseudo-op 261
+    LoadZeroSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 138, // CPython uses pseudo-op 262
     // ==================== RustPython-only instructions (119-135) ====================
     // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
     // So we assign random IDs to these opcodes.
@@ -338,6 +353,10 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
+            // LOAD_SUPER_* pseudo opcodes (136-138)
+            u8::from(Self::LoadSuperMethod { idx: Arg::marker() }),
+            u8::from(Self::LoadZeroSuperAttr { idx: Arg::marker() }),
+            u8::from(Self::LoadZeroSuperMethod { idx: Arg::marker() }),
         ];
 
         // Pseudo opcodes (252-255)
@@ -588,6 +607,16 @@ impl Instruction {
             Self::UnaryNot => 0,
             Self::GetYieldFromIter => 0,
             Self::PushNull => 1, // Push NULL for call protocol
+            // LoadSuperAttr: pop [super, class, self], push [attr] or [method, self_or_null]
+            // stack_effect depends on load_method flag (bit 0 of oparg)
+            Self::LoadSuperAttr { arg: idx } => {
+                let (_, load_method, _) = decode_load_super_attr_arg(idx.get(arg));
+                if load_method { -3 + 2 } else { -3 + 1 }
+            }
+            // Pseudo instructions (calculated before conversion)
+            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
+            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
             Self::Cache => 0,
             Self::BinarySlice => 0,
             Self::BinaryOpInplaceAddUnicode => 0,
@@ -611,7 +640,6 @@ impl Instruction {
             Self::LoadFromDictOrGlobals(_) => 0,
             Self::SetUpdate { .. } => 0,
             Self::MakeCell(_) => 0,
-            Self::LoadSuperAttr { .. } => 0,
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
@@ -768,6 +796,19 @@ impl Instruction {
             Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
             Self::LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
             Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::LoadSuperAttr { arg: idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, load_method, has_class) = decode_load_super_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                write!(
+                    f,
+                    "{:pad$}({}, {}, method={}, class={})",
+                    "LOAD_SUPER_ATTR", encoded, attr_name, load_method, has_class
+                )
+            }
+            Self::LoadSuperMethod { idx } => w!(LOAD_SUPER_METHOD, name = idx),
+            Self::LoadZeroSuperAttr { idx } => w!(LOAD_ZERO_SUPER_ATTR, name = idx),
+            Self::LoadZeroSuperMethod { idx } => w!(LOAD_ZERO_SUPER_METHOD, name = idx),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
             Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index f8e343b1915..5fb44d8a58b 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1104,6 +1104,14 @@ impl ExecutingFrame<'_> {
             bytecode::Instruction::LoadAttrMethod { .. } => {
                 unreachable!("LoadAttrMethod is converted to LoadAttr during compilation")
             }
+            bytecode::Instruction::LoadSuperAttr { arg: idx } => {
+                self.load_super_attr(vm, idx.get(arg))
+            }
+            bytecode::Instruction::LoadSuperMethod { .. }
+            | bytecode::Instruction::LoadZeroSuperAttr { .. }
+            | bytecode::Instruction::LoadZeroSuperMethod { .. } => {
+                unreachable!("LOAD_SUPER_* pseudo instructions are converted during compilation")
+            }
             bytecode::Instruction::LoadBuildClass => {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
@@ -2523,6 +2531,45 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
+    fn load_super_attr(&mut self, vm: &VirtualMachine, oparg: u32) -> FrameResult {
+        let (name_idx, load_method, has_class) = bytecode::decode_load_super_attr_arg(oparg);
+        let attr_name = self.code.names[name_idx as usize];
+
+        // Stack layout (bottom to top): [super, class, self]
+        // Pop in LIFO order: self, class, super
+        let self_obj = self.pop_value();
+        let class = self.pop_value();
+        let global_super = self.pop_value();
+
+        // Create super object - pass args based on has_class flag
+        // When super is shadowed, has_class=false means call with 0 args
+        let super_obj = if has_class {
+            global_super.call((class.clone(), self_obj.clone()), vm)?
+        } else {
+            global_super.call((), vm)?
+        };
+
+        if load_method {
+            // Method load: push [method, self_or_null]
+            let method = PyMethod::get(super_obj, attr_name, vm)?;
+            match method {
+                PyMethod::Function { target: _, func } => {
+                    self.push_value(func);
+                    self.push_value(self_obj);
+                }
+                PyMethod::Attribute(val) => {
+                    self.push_value(val);
+                    self.push_null();
+                }
+            }
+        } else {
+            // Regular attribute access
+            let obj = super_obj.get_attr(attr_name, vm)?;
+            self.push_value(obj);
+        }
+        Ok(None)
+    }
+
     fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
         let attr_name = self.code.names[attr as usize];
         let parent = self.pop_value();

From f3b7f7fd473112a84c13667e1101c08b096852f7 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 12 Jan 2026 08:08:50 +0900
Subject: [PATCH 273/418] Clarify commit message from pr-auto-commit (#6706)

* Clarify commit message from pr-auto-commit

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .github/workflows/pr-auto-commit.yaml | 58 ++++++++++++++++++++++-----
 scripts/fix_test.py                   |  2 +-
 2 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
index 203a42a61fe..d0537c00efa 100644
--- a/.github/workflows/pr-auto-commit.yaml
+++ b/.github/workflows/pr-auto-commit.yaml
@@ -34,10 +34,21 @@ jobs:
         with:
           components: rustfmt
 
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          echo "" > /tmp/committed_commands.txt
+
       - name: Run cargo fmt
         run: |
           echo "Running cargo fmt --all on PR #${{ github.event.pull_request.number }}"
           cargo fmt --all
+          if [ -n "$(git status --porcelain)" ]; then
+            git add -u
+            git commit -m "Auto-format: cargo fmt --all"
+            echo "- \`cargo fmt --all\`" >> /tmp/committed_commands.txt
+          fi
 
       - name: Install ruff
         uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
@@ -45,31 +56,55 @@ jobs:
           version: "0.14.9"
           args: "--version"
 
-      - run: ruff format
-      - run: ruff check --select I --fix
-      - run: python scripts/generate_opcode_metadata.py
+      - name: Run ruff format
+        run: |
+          ruff format
+          if [ -n "$(git status --porcelain)" ]; then
+            git add -u
+            git commit -m "Auto-format: ruff format"
+            echo "- \`ruff format\`" >> /tmp/committed_commands.txt
+          fi
 
-      - name: Configure git
+      - name: Run ruff check import sorting
         run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
+          ruff check --select I --fix
+          if [ -n "$(git status --porcelain)" ]; then
+            git add -u
+            git commit -m "Auto-format: ruff check --select I --fix"
+            echo "- \`ruff check --select I --fix\`" >> /tmp/committed_commands.txt
+          fi
+
+      - name: Run generate_opcode_metadata.py
+        run: |
+          python scripts/generate_opcode_metadata.py
+          if [ -n "$(git status --porcelain)" ]; then
+            git add -u
+            git commit -m "Auto-generate: generate_opcode_metadata.py"
+            echo "- \`python scripts/generate_opcode_metadata.py\`" >> /tmp/committed_commands.txt
+          fi
 
       - name: Check for changes
         id: check-changes
         run: |
-          if [ -n "$(git status --porcelain)" ]; then
+          if [ "$(git rev-parse HEAD)" != "${{ github.event.pull_request.head.sha }}" ]; then
             echo "has_changes=true" >> $GITHUB_OUTPUT
           else
             echo "has_changes=false" >> $GITHUB_OUTPUT
           fi
 
-      - name: Commit and push formatting changes
+      - name: Push formatting changes
         if: steps.check-changes.outputs.has_changes == 'true'
         run: |
-          git add -u
-          git commit -m "Auto-format: cargo fmt --all"
           git push origin HEAD:${{ github.event.pull_request.head.ref }}
 
+      - name: Read committed commands
+        id: committed-commands
+        if: steps.check-changes.outputs.has_changes == 'true'
+        run: |
+          echo "list<<EOF" >> $GITHUB_OUTPUT
+          cat /tmp/committed_commands.txt >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
       - name: Comment on PR
         if: steps.check-changes.outputs.has_changes == 'true'
         uses: marocchino/sticky-pull-request-comment@v2
@@ -78,7 +113,8 @@ jobs:
           message: |
             **Code has been automatically formatted**
 
-            The code in this PR has been formatted using `cargo fmt --all`.
+            The code in this PR has been formatted using:
+            ${{ steps.committed-commands.outputs.list }}
             Please pull the latest changes before pushing again:
             ```bash
             git pull origin ${{ github.event.pull_request.head.ref }}
diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index 4b3e0bfddda..0970531f079 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -27,7 +27,7 @@
 import sys
 from pathlib import Path
 
-from lib_updater import apply_patches, PatchSpec, UtMethod
+from lib_updater import PatchSpec, UtMethod, apply_patches
 
 
 def parse_args():

From 00bfea83bf7c92418d165c494ea0b84cb95281d9 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Mon, 12 Jan 2026 03:52:15 +0200
Subject: [PATCH 274/418] Update ruff to 0.14.11 in the CI (#6708)

* Update ruff to 0.14.11 in the CI

* Auto-format: cargo fmt --all

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yaml             | 2 +-
 .github/workflows/pr-auto-commit.yaml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index d15e01dbd6c..73f1f5f1aa1 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -447,7 +447,7 @@ jobs:
       - name: Install ruff
         uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
         with:
-          version: "0.14.9"
+          version: "0.14.11"
           args: "--version"
 
       - run: ruff check --diff
diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
index d0537c00efa..d4d97b19d18 100644
--- a/.github/workflows/pr-auto-commit.yaml
+++ b/.github/workflows/pr-auto-commit.yaml
@@ -53,7 +53,7 @@ jobs:
       - name: Install ruff
         uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
         with:
-          version: "0.14.9"
+          version: "0.14.11"
           args: "--version"
 
       - name: Run ruff format

From 69601a18a4a5d7baff9e0ffd2c5674bb910dc7fb Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 12 Jan 2026 15:33:28 +0900
Subject: [PATCH 275/418] Upgrade threading to 3.13.11; sys.setprofile & impl
 more threading (#6691)

* Upgrade threading,test_threading from 3.13.11

* increase ci limit to 45mins

* impl more threading

* no static for asyncgen
---
 .github/workflows/ci.yaml                     |   9 +-
 Lib/_dummy_thread.py                          | 149 ++-
 Lib/dummy_threading.py                        |  38 +-
 Lib/test/lock_tests.py                        | 680 +++++++++----
 .../test_process_pool.py                      |   1 -
 .../test_concurrent_futures/test_shutdown.py  |   6 +-
 .../test_thread_pool.py                       |   6 -
 Lib/test/test_importlib/test_locks.py         |   5 +-
 Lib/test/test_sys.py                          |   2 +-
 Lib/test/test_threading.py                    | 927 +++++++++++++-----
 Lib/threading.py                              | 398 ++++----
 crates/vm/src/builtins/asyncgenerator.rs      |   6 +-
 crates/vm/src/stdlib/posix.rs                 |  61 ++
 crates/vm/src/stdlib/sys.rs                   |  54 +-
 crates/vm/src/stdlib/thread.rs                | 613 +++++++++++-
 crates/vm/src/vm/interpreter.rs               |  35 +-
 crates/vm/src/vm/mod.rs                       |  42 +
 crates/vm/src/vm/thread.rs                    |  91 +-
 18 files changed, 2366 insertions(+), 757 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 73f1f5f1aa1..cc7f745afaa 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -106,9 +106,7 @@ env:
     test_weakref
     test_yield_from
   ENV_POLLUTING_TESTS_COMMON: >-
-    test_threading
   ENV_POLLUTING_TESTS_LINUX: >-
-    test.test_concurrent_futures.test_thread_pool
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_fork.test_threads
     test.test_multiprocessing_forkserver.test_processes
@@ -116,7 +114,6 @@ env:
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_MACOS: >-
-    test.test_concurrent_futures.test_thread_pool
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
@@ -297,21 +294,21 @@ jobs:
         env:
           RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v ${{ env.PLATFORM_INDEPENDENT_TESTS }}
-        timeout-minutes: 35
+        timeout-minutes: 45
 
       - if: runner.os == 'Linux'
         name: run cpython platform-dependent tests (Linux)
         env:
           RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
-        timeout-minutes: 35
+        timeout-minutes: 45
 
       - if: runner.os == 'macOS'
         name: run cpython platform-dependent tests (MacOS)
         env:
           RUSTPYTHON_SKIP_ENV_POLLUTERS: true
         run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
-        timeout-minutes: 35
+        timeout-minutes: 45
 
       - if: runner.os == 'Windows'
         name: run cpython platform-dependent tests (windows partial - fixme)
diff --git a/Lib/_dummy_thread.py b/Lib/_dummy_thread.py
index 424b0b3be5e..0630d4e59fa 100644
--- a/Lib/_dummy_thread.py
+++ b/Lib/_dummy_thread.py
@@ -11,15 +11,35 @@
         import _dummy_thread as _thread
 
 """
+
 # Exports only things specified by thread documentation;
 # skipping obsolete synonyms allocate(), start_new(), exit_thread().
-__all__ = ['error', 'start_new_thread', 'exit', 'get_ident', 'allocate_lock',
-           'interrupt_main', 'LockType', 'RLock',
-           '_count']
+__all__ = [
+    "error",
+    "start_new_thread",
+    "exit",
+    "get_ident",
+    "allocate_lock",
+    "interrupt_main",
+    "LockType",
+    "RLock",
+    "_count",
+    "start_joinable_thread",
+    "daemon_threads_allowed",
+    "_shutdown",
+    "_make_thread_handle",
+    "_ThreadHandle",
+    "_get_main_thread_ident",
+    "_is_main_interpreter",
+    "_local",
+]
 
 # A dummy value
 TIMEOUT_MAX = 2**31
 
+# Main thread ident for dummy implementation
+_MAIN_THREAD_IDENT = -1
+
 # NOTE: this module can be imported early in the extension building process,
 # and so top level imports of other modules should be avoided.  Instead, all
 # imports are done when needed on a function-by-function basis.  Since threads
@@ -27,6 +47,7 @@
 
 error = RuntimeError
 
+
 def start_new_thread(function, args, kwargs={}):
     """Dummy implementation of _thread.start_new_thread().
 
@@ -52,6 +73,7 @@ def start_new_thread(function, args, kwargs={}):
         pass
     except:
         import traceback
+
         traceback.print_exc()
     _main = True
     global _interrupt
@@ -59,10 +81,58 @@ def start_new_thread(function, args, kwargs={}):
         _interrupt = False
         raise KeyboardInterrupt
 
+
+def start_joinable_thread(function, handle=None, daemon=True):
+    """Dummy implementation of _thread.start_joinable_thread().
+
+    In dummy thread, we just run the function synchronously.
+    """
+    if handle is None:
+        handle = _ThreadHandle()
+    try:
+        function()
+    except SystemExit:
+        pass
+    except:
+        import traceback
+
+        traceback.print_exc()
+    handle._set_done()
+    return handle
+
+
+def daemon_threads_allowed():
+    """Dummy implementation of _thread.daemon_threads_allowed()."""
+    return True
+
+
+def _shutdown():
+    """Dummy implementation of _thread._shutdown()."""
+    pass
+
+
+def _make_thread_handle(ident):
+    """Dummy implementation of _thread._make_thread_handle()."""
+    handle = _ThreadHandle()
+    handle._ident = ident
+    return handle
+
+
+def _get_main_thread_ident():
+    """Dummy implementation of _thread._get_main_thread_ident()."""
+    return _MAIN_THREAD_IDENT
+
+
+def _is_main_interpreter():
+    """Dummy implementation of _thread._is_main_interpreter()."""
+    return True
+
+
 def exit():
     """Dummy implementation of _thread.exit()."""
     raise SystemExit
 
+
 def get_ident():
     """Dummy implementation of _thread.get_ident().
 
@@ -70,26 +140,31 @@ def get_ident():
     available, it is safe to assume that the current process is the
     only thread.  Thus a constant can be safely returned.
     """
-    return -1
+    return _MAIN_THREAD_IDENT
+
 
 def allocate_lock():
     """Dummy implementation of _thread.allocate_lock()."""
     return LockType()
 
+
 def stack_size(size=None):
     """Dummy implementation of _thread.stack_size()."""
     if size is not None:
         raise error("setting thread stack size not supported")
     return 0
 
+
 def _set_sentinel():
     """Dummy implementation of _thread._set_sentinel()."""
     return LockType()
 
+
 def _count():
     """Dummy implementation of _thread._count()."""
     return 0
 
+
 class LockType(object):
     """Class implementing dummy implementation of _thread.LockType.
 
@@ -125,6 +200,7 @@ def acquire(self, waitflag=None, timeout=-1):
             else:
                 if timeout > 0:
                     import time
+
                     time.sleep(timeout)
                 return False
 
@@ -153,14 +229,41 @@ def __repr__(self):
             "locked" if self.locked_status else "unlocked",
             self.__class__.__module__,
             self.__class__.__qualname__,
-            hex(id(self))
+            hex(id(self)),
         )
 
+
+class _ThreadHandle:
+    """Dummy implementation of _thread._ThreadHandle."""
+
+    def __init__(self):
+        self._ident = _MAIN_THREAD_IDENT
+        self._done = False
+
+    @property
+    def ident(self):
+        return self._ident
+
+    def _set_done(self):
+        self._done = True
+
+    def is_done(self):
+        return self._done
+
+    def join(self, timeout=None):
+        # In dummy thread, thread is always done
+        return
+
+    def __repr__(self):
+        return f"<_ThreadHandle ident={self._ident}>"
+
+
 # Used to signal that interrupt_main was called in a "thread"
 _interrupt = False
 # True when not executing in a "thread"
 _main = True
 
+
 def interrupt_main():
     """Set _interrupt flag to True to have start_new_thread raise
     KeyboardInterrupt upon exiting."""
@@ -170,6 +273,7 @@ def interrupt_main():
         global _interrupt
         _interrupt = True
 
+
 class RLock:
     def __init__(self):
         self.locked_count = 0
@@ -190,7 +294,7 @@ def release(self):
         return True
 
     def locked(self):
-        return self.locked_status != 0
+        return self.locked_count != 0
 
     def __repr__(self):
         return "<%s %s.%s object owner=%s count=%s at %s>" % (
@@ -199,5 +303,36 @@ def __repr__(self):
             self.__class__.__qualname__,
             get_ident() if self.locked_count else 0,
             self.locked_count,
-            hex(id(self))
+            hex(id(self)),
         )
+
+
+class _local:
+    """Dummy implementation of _thread._local (thread-local storage)."""
+
+    def __init__(self):
+        object.__setattr__(self, "_local__impl", {})
+
+    def __getattribute__(self, name):
+        if name.startswith("_local__"):
+            return object.__getattribute__(self, name)
+        impl = object.__getattribute__(self, "_local__impl")
+        try:
+            return impl[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __setattr__(self, name, value):
+        if name.startswith("_local__"):
+            return object.__setattr__(self, name, value)
+        impl = object.__getattribute__(self, "_local__impl")
+        impl[name] = value
+
+    def __delattr__(self, name):
+        if name.startswith("_local__"):
+            return object.__delattr__(self, name)
+        impl = object.__getattribute__(self, "_local__impl")
+        try:
+            del impl[name]
+        except KeyError:
+            raise AttributeError(name)
diff --git a/Lib/dummy_threading.py b/Lib/dummy_threading.py
index 1bb7eee338a..662f3b89a9a 100644
--- a/Lib/dummy_threading.py
+++ b/Lib/dummy_threading.py
@@ -6,6 +6,7 @@
 regardless of whether ``_thread`` was available which is not desired.
 
 """
+
 from sys import modules as sys_modules
 
 import _dummy_thread
@@ -19,35 +20,38 @@
     # Could have checked if ``_thread`` was not in sys.modules and gone
     # a different route, but decided to mirror technique used with
     # ``threading`` below.
-    if '_thread' in sys_modules:
-        held_thread = sys_modules['_thread']
+    if "_thread" in sys_modules:
+        held_thread = sys_modules["_thread"]
         holding_thread = True
     # Must have some module named ``_thread`` that implements its API
     # in order to initially import ``threading``.
-    sys_modules['_thread'] = sys_modules['_dummy_thread']
+    sys_modules["_thread"] = sys_modules["_dummy_thread"]
 
-    if 'threading' in sys_modules:
+    if "threading" in sys_modules:
         # If ``threading`` is already imported, might as well prevent
         # trying to import it more than needed by saving it if it is
         # already imported before deleting it.
-        held_threading = sys_modules['threading']
+        held_threading = sys_modules["threading"]
         holding_threading = True
-        del sys_modules['threading']
+        del sys_modules["threading"]
 
-    if '_threading_local' in sys_modules:
+    if "_threading_local" in sys_modules:
         # If ``_threading_local`` is already imported, might as well prevent
         # trying to import it more than needed by saving it if it is
         # already imported before deleting it.
-        held__threading_local = sys_modules['_threading_local']
+        held__threading_local = sys_modules["_threading_local"]
         holding__threading_local = True
-        del sys_modules['_threading_local']
+        del sys_modules["_threading_local"]
 
     import threading
+
     # Need a copy of the code kept somewhere...
-    sys_modules['_dummy_threading'] = sys_modules['threading']
-    del sys_modules['threading']
-    sys_modules['_dummy__threading_local'] = sys_modules['_threading_local']
-    del sys_modules['_threading_local']
+    sys_modules["_dummy_threading"] = sys_modules["threading"]
+    del sys_modules["threading"]
+    # _threading_local may not be imported if _thread._local is available
+    if "_threading_local" in sys_modules:
+        sys_modules["_dummy__threading_local"] = sys_modules["_threading_local"]
+        del sys_modules["_threading_local"]
     from _dummy_threading import *
     from _dummy_threading import __all__
 
@@ -55,23 +59,23 @@
     # Put back ``threading`` if we overwrote earlier
 
     if holding_threading:
-        sys_modules['threading'] = held_threading
+        sys_modules["threading"] = held_threading
         del held_threading
     del holding_threading
 
     # Put back ``_threading_local`` if we overwrote earlier
 
     if holding__threading_local:
-        sys_modules['_threading_local'] = held__threading_local
+        sys_modules["_threading_local"] = held__threading_local
         del held__threading_local
     del holding__threading_local
 
     # Put back ``thread`` if we overwrote, else del the entry we made
     if holding_thread:
-        sys_modules['_thread'] = held_thread
+        sys_modules["_thread"] = held_thread
         del held_thread
     else:
-        del sys_modules['_thread']
+        del sys_modules["_thread"]
     del holding_thread
 
     del _dummy_thread
diff --git a/Lib/test/lock_tests.py b/Lib/test/lock_tests.py
index 09b91147801..4031bfaeb64 100644
--- a/Lib/test/lock_tests.py
+++ b/Lib/test/lock_tests.py
@@ -2,6 +2,7 @@
 Various tests for synchronization primitives.
 """
 
+import gc
 import sys
 import time
 from _thread import start_new_thread, TIMEOUT_MAX
@@ -13,54 +14,79 @@
 from test.support import threading_helper
 
 
-def _wait():
-    # A crude wait/yield function not relying on synchronization primitives.
-    time.sleep(0.01)
+requires_fork = unittest.skipUnless(support.has_fork_support,
+                                    "platform doesn't support fork "
+                                     "(no _at_fork_reinit method)")
+
+
+def wait_threads_blocked(nthread):
+    # Arbitrary sleep to wait until N threads are blocked,
+    # like waiting for a lock.
+    time.sleep(0.010 * nthread)
+
 
 class Bunch(object):
     """
     A bunch of threads.
     """
-    def __init__(self, f, n, wait_before_exit=False):
+    def __init__(self, func, nthread, wait_before_exit=False):
         """
-        Construct a bunch of `n` threads running the same function `f`.
+        Construct a bunch of `nthread` threads running the same function `func`.
         If `wait_before_exit` is True, the threads won't terminate until
         do_finish() is called.
         """
-        self.f = f
-        self.n = n
+        self.func = func
+        self.nthread = nthread
         self.started = []
         self.finished = []
+        self.exceptions = []
         self._can_exit = not wait_before_exit
-        self.wait_thread = threading_helper.wait_threads_exit()
-        self.wait_thread.__enter__()
+        self._wait_thread = None
 
-        def task():
-            tid = threading.get_ident()
-            self.started.append(tid)
-            try:
-                f()
-            finally:
-                self.finished.append(tid)
-                while not self._can_exit:
-                    _wait()
+    def task(self):
+        tid = threading.get_ident()
+        self.started.append(tid)
+        try:
+            self.func()
+        except BaseException as exc:
+            self.exceptions.append(exc)
+        finally:
+            self.finished.append(tid)
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if self._can_exit:
+                    break
+
+    def __enter__(self):
+        self._wait_thread = threading_helper.wait_threads_exit(support.SHORT_TIMEOUT)
+        self._wait_thread.__enter__()
 
         try:
-            for i in range(n):
-                start_new_thread(task, ())
+            for _ in range(self.nthread):
+                start_new_thread(self.task, ())
         except:
             self._can_exit = True
             raise
 
-    def wait_for_started(self):
-        while len(self.started) < self.n:
-            _wait()
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(self.started) >= self.nthread:
+                break
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(self.finished) >= self.nthread:
+                break
+
+        # Wait until threads completely exit according to _thread._count()
+        self._wait_thread.__exit__(None, None, None)
 
-    def wait_for_finished(self):
-        while len(self.finished) < self.n:
-            _wait()
-        # Wait for threads exit
-        self.wait_thread.__exit__(None, None, None)
+        # Break reference cycle
+        exceptions = self.exceptions
+        self.exceptions = None
+        if exceptions:
+            raise ExceptionGroup(f"{self.func} threads raised exceptions",
+                                 exceptions)
 
     def do_finish(self):
         self._can_exit = True
@@ -88,6 +114,12 @@ class BaseLockTests(BaseTestCase):
     Tests for both recursive and non-recursive locks.
     """
 
+    def wait_phase(self, phase, expected):
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(phase) >= expected:
+                break
+        self.assertEqual(len(phase), expected)
+
     def test_constructor(self):
         lock = self.locktype()
         del lock
@@ -125,44 +157,60 @@ def test_try_acquire_contended(self):
         result = []
         def f():
             result.append(lock.acquire(False))
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(result[0])
         lock.release()
 
-    @unittest.skip("TODO: RUSTPYTHON, sometimes hangs")
+    @unittest.skip('TODO: RUSTPYTHON; sometimes hangs')
     def test_acquire_contended(self):
         lock = self.locktype()
         lock.acquire()
-        N = 5
         def f():
             lock.acquire()
             lock.release()
 
-        b = Bunch(f, N)
-        b.wait_for_started()
-        _wait()
-        self.assertEqual(len(b.finished), 0)
-        lock.release()
-        b.wait_for_finished()
-        self.assertEqual(len(b.finished), N)
+        N = 5
+        with Bunch(f, N) as bunch:
+            # Threads block on lock.acquire()
+            wait_threads_blocked(N)
+            self.assertEqual(len(bunch.finished), 0)
+
+            # Threads unblocked
+            lock.release()
+
+        self.assertEqual(len(bunch.finished), N)
 
     def test_with(self):
         lock = self.locktype()
         def f():
             lock.acquire()
             lock.release()
-        def _with(err=None):
+
+        def with_lock(err=None):
             with lock:
                 if err is not None:
                     raise err
-        _with()
-        # Check the lock is unacquired
-        Bunch(f, 1).wait_for_finished()
-        self.assertRaises(TypeError, _with, TypeError)
-        # Check the lock is unacquired
-        Bunch(f, 1).wait_for_finished()
 
-    @unittest.skip("TODO: RUSTPYTHON, sometimes hangs")
+        # Acquire the lock, do nothing, with releases the lock
+        with lock:
+            pass
+
+        # Check that the lock is unacquired
+        with Bunch(f, 1):
+            pass
+
+        # Acquire the lock, raise an exception, with releases the lock
+        with self.assertRaises(TypeError):
+            with lock:
+                raise TypeError
+
+        # Check that the lock is unacquired even if after an exception
+        # was raised in the previous "with lock:" block
+        with Bunch(f, 1):
+            pass
+
+    @unittest.skip('TODO: RUSTPYTHON; sometimes hangs')
     def test_thread_leak(self):
         # The lock shouldn't leak a Thread instance when used from a foreign
         # (non-threading) thread.
@@ -170,22 +218,16 @@ def test_thread_leak(self):
         def f():
             lock.acquire()
             lock.release()
-        n = len(threading.enumerate())
+
         # We run many threads in the hope that existing threads ids won't
         # be recycled.
-        Bunch(f, 15).wait_for_finished()
-        if len(threading.enumerate()) != n:
-            # There is a small window during which a Thread instance's
-            # target function has finished running, but the Thread is still
-            # alive and registered.  Avoid spurious failures by waiting a
-            # bit more (seen on a buildbot).
-            time.sleep(0.4)
-            self.assertEqual(n, len(threading.enumerate()))
+        with Bunch(f, 15):
+            pass
 
     def test_timeout(self):
         lock = self.locktype()
         # Can't set timeout if not blocking
-        self.assertRaises(ValueError, lock.acquire, 0, 1)
+        self.assertRaises(ValueError, lock.acquire, False, 1)
         # Invalid timeout values
         self.assertRaises(ValueError, lock.acquire, timeout=-100)
         self.assertRaises(OverflowError, lock.acquire, timeout=1e100)
@@ -204,7 +246,8 @@ def f():
             results.append(lock.acquire(timeout=0.5))
             t2 = time.monotonic()
             results.append(t2 - t1)
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(results[0])
         self.assertTimeout(results[1], 0.5)
 
@@ -217,6 +260,7 @@ def test_weakref_deleted(self):
         lock = self.locktype()
         ref = weakref.ref(lock)
         del lock
+        gc.collect()  # For PyPy or other GCs.
         self.assertIsNone(ref())
 
 
@@ -237,15 +281,13 @@ def f():
             phase.append(None)
 
         with threading_helper.wait_threads_exit():
+            # Thread blocked on lock.acquire()
             start_new_thread(f, ())
-            while len(phase) == 0:
-                _wait()
-            _wait()
-            self.assertEqual(len(phase), 1)
+            self.wait_phase(phase, 1)
+
+            # Thread unblocked
             lock.release()
-            while len(phase) == 1:
-                _wait()
-            self.assertEqual(len(phase), 2)
+            self.wait_phase(phase, 2)
 
     def test_different_thread(self):
         # Lock can be released from a different thread.
@@ -253,8 +295,8 @@ def test_different_thread(self):
         lock.acquire()
         def f():
             lock.release()
-        b = Bunch(f, 1)
-        b.wait_for_finished()
+        with Bunch(f, 1):
+            pass
         lock.acquire()
         lock.release()
 
@@ -268,6 +310,25 @@ def test_state_after_timeout(self):
         self.assertFalse(lock.locked())
         self.assertTrue(lock.acquire(blocking=False))
 
+    @requires_fork
+    def test_at_fork_reinit(self):
+        def use_lock(lock):
+            # make sure that the lock still works normally
+            # after _at_fork_reinit()
+            lock.acquire()
+            lock.release()
+
+        # unlocked
+        lock = self.locktype()
+        lock._at_fork_reinit()
+        use_lock(lock)
+
+        # locked: _at_fork_reinit() resets the lock to the unlocked state
+        lock2 = self.locktype()
+        lock2.acquire()
+        lock2._at_fork_reinit()
+        use_lock(lock2)
+
 
 class RLockTests(BaseLockTests):
     """
@@ -306,17 +367,52 @@ def test_release_save_unacquired(self):
         lock.release()
         self.assertRaises(RuntimeError, lock._release_save)
 
+    def test_recursion_count(self):
+        lock = self.locktype()
+        self.assertEqual(0, lock._recursion_count())
+        lock.acquire()
+        self.assertEqual(1, lock._recursion_count())
+        lock.acquire()
+        lock.acquire()
+        self.assertEqual(3, lock._recursion_count())
+        lock.release()
+        self.assertEqual(2, lock._recursion_count())
+        lock.release()
+        lock.release()
+        self.assertEqual(0, lock._recursion_count())
+
+        phase = []
+
+        def f():
+            lock.acquire()
+            phase.append(None)
+
+            self.wait_phase(phase, 2)
+            lock.release()
+            phase.append(None)
+
+        with threading_helper.wait_threads_exit():
+            # Thread blocked on lock.acquire()
+            start_new_thread(f, ())
+            self.wait_phase(phase, 1)
+            self.assertEqual(0, lock._recursion_count())
+
+            # Thread unblocked
+            phase.append(None)
+            self.wait_phase(phase, 3)
+            self.assertEqual(0, lock._recursion_count())
+
     def test_different_thread(self):
         # Cannot release from a different thread
         lock = self.locktype()
         def f():
             lock.acquire()
-        b = Bunch(f, 1, True)
-        try:
-            self.assertRaises(RuntimeError, lock.release)
-        finally:
-            b.do_finish()
-        b.wait_for_finished()
+
+        with Bunch(f, 1, True) as bunch:
+            try:
+                self.assertRaises(RuntimeError, lock.release)
+            finally:
+                bunch.do_finish()
 
     def test__is_owned(self):
         lock = self.locktype()
@@ -328,7 +424,8 @@ def test__is_owned(self):
         result = []
         def f():
             result.append(lock._is_owned())
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(result[0])
         lock.release()
         self.assertTrue(lock._is_owned())
@@ -361,12 +458,15 @@ def _check_notify(self, evt):
         def f():
             results1.append(evt.wait())
             results2.append(evt.wait())
-        b = Bunch(f, N)
-        b.wait_for_started()
-        _wait()
-        self.assertEqual(len(results1), 0)
-        evt.set()
-        b.wait_for_finished()
+
+        with Bunch(f, N):
+            # Threads blocked on first evt.wait()
+            wait_threads_blocked(N)
+            self.assertEqual(len(results1), 0)
+
+            # Threads unblocked
+            evt.set()
+
         self.assertEqual(results1, [True] * N)
         self.assertEqual(results2, [True] * N)
 
@@ -389,46 +489,61 @@ def f():
             r = evt.wait(0.5)
             t2 = time.monotonic()
             results2.append((r, t2 - t1))
-        Bunch(f, N).wait_for_finished()
+
+        with Bunch(f, N):
+            pass
+
         self.assertEqual(results1, [False] * N)
         for r, dt in results2:
             self.assertFalse(r)
             self.assertTimeout(dt, 0.5)
+
         # The event is set
         results1 = []
         results2 = []
         evt.set()
-        Bunch(f, N).wait_for_finished()
+        with Bunch(f, N):
+            pass
+
         self.assertEqual(results1, [True] * N)
         for r, dt in results2:
             self.assertTrue(r)
 
     def test_set_and_clear(self):
-        # Issue #13502: check that wait() returns true even when the event is
+        # gh-57711: check that wait() returns true even when the event is
         # cleared before the waiting thread is woken up.
-        evt = self.eventtype()
+        event = self.eventtype()
         results = []
-        timeout = 0.250
-        N = 5
         def f():
-            results.append(evt.wait(timeout * 4))
-        b = Bunch(f, N)
-        b.wait_for_started()
-        time.sleep(timeout)
-        evt.set()
-        evt.clear()
-        b.wait_for_finished()
+            results.append(event.wait(support.LONG_TIMEOUT))
+
+        N = 5
+        with Bunch(f, N):
+            # Threads blocked on event.wait()
+            wait_threads_blocked(N)
+
+            # Threads unblocked
+            event.set()
+            event.clear()
+
         self.assertEqual(results, [True] * N)
 
-    def test_reset_internal_locks(self):
+    @requires_fork
+    def test_at_fork_reinit(self):
         # ensure that condition is still using a Lock after reset
         evt = self.eventtype()
         with evt._cond:
             self.assertFalse(evt._cond.acquire(False))
-        evt._reset_internal_locks()
+        evt._at_fork_reinit()
         with evt._cond:
             self.assertFalse(evt._cond.acquire(False))
 
+    def test_repr(self):
+        evt = self.eventtype()
+        self.assertRegex(repr(evt), r"<\w+\.Event at .*: unset>")
+        evt.set()
+        self.assertRegex(repr(evt), r"<\w+\.Event at .*: set>")
+
 
 class ConditionTests(BaseTestCase):
     """
@@ -466,15 +581,14 @@ def _check_notify(self, cond):
         # Note that this test is sensitive to timing.  If the worker threads
         # don't execute in a timely fashion, the main thread may think they
         # are further along then they are.  The main thread therefore issues
-        # _wait() statements to try to make sure that it doesn't race ahead
-        # of the workers.
+        # wait_threads_blocked() statements to try to make sure that it doesn't
+        # race ahead of the workers.
         # Secondly, this test assumes that condition variables are not subject
         # to spurious wakeups.  The absence of spurious wakeups is an implementation
         # detail of Condition Variables in current CPython, but in general, not
         # a guaranteed property of condition variables as a programming
         # construct.  In particular, it is possible that this can no longer
         # be conveniently guaranteed should their implementation ever change.
-        N = 5
         ready = []
         results1 = []
         results2 = []
@@ -483,58 +597,83 @@ def f():
             cond.acquire()
             ready.append(phase_num)
             result = cond.wait()
+
             cond.release()
             results1.append((result, phase_num))
+
             cond.acquire()
             ready.append(phase_num)
+
             result = cond.wait()
             cond.release()
             results2.append((result, phase_num))
-        b = Bunch(f, N)
-        b.wait_for_started()
-        # first wait, to ensure all workers settle into cond.wait() before
-        # we continue. See issues #8799 and #30727.
-        while len(ready) < 5:
-            _wait()
-        ready.clear()
-        self.assertEqual(results1, [])
-        # Notify 3 threads at first
-        cond.acquire()
-        cond.notify(3)
-        _wait()
-        phase_num = 1
-        cond.release()
-        while len(results1) < 3:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3)
-        self.assertEqual(results2, [])
-        # make sure all awaken workers settle into cond.wait()
-        while len(ready) < 3:
-            _wait()
-        # Notify 5 threads: they might be in their first or second wait
-        cond.acquire()
-        cond.notify(5)
-        _wait()
-        phase_num = 2
-        cond.release()
-        while len(results1) + len(results2) < 8:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3 + [(True, 2)] * 2)
-        self.assertEqual(results2, [(True, 2)] * 3)
-        # make sure all workers settle into cond.wait()
-        while len(ready) < 5:
-            _wait()
-        # Notify all threads: they are all in their second wait
-        cond.acquire()
-        cond.notify_all()
-        _wait()
-        phase_num = 3
-        cond.release()
-        while len(results2) < 5:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3 + [(True,2)] * 2)
-        self.assertEqual(results2, [(True, 2)] * 3 + [(True, 3)] * 2)
-        b.wait_for_finished()
+
+        N = 5
+        with Bunch(f, N):
+            # first wait, to ensure all workers settle into cond.wait() before
+            # we continue. See issues #8799 and #30727.
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= N:
+                    break
+
+            ready.clear()
+            self.assertEqual(results1, [])
+
+            # Notify 3 threads at first
+            count1 = 3
+            cond.acquire()
+            cond.notify(count1)
+            wait_threads_blocked(count1)
+
+            # Phase 1
+            phase_num = 1
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) >= count1:
+                    break
+
+            self.assertEqual(results1, [(True, 1)] * count1)
+            self.assertEqual(results2, [])
+
+            # Wait until awaken workers are blocked on cond.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= count1 :
+                    break
+
+            # Notify 5 threads: they might be in their first or second wait
+            cond.acquire()
+            cond.notify(5)
+            wait_threads_blocked(N)
+
+            # Phase 2
+            phase_num = 2
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= (N + count1):
+                    break
+
+            count2 = N - count1
+            self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
+            self.assertEqual(results2, [(True, 2)] * count1)
+
+            # Make sure all workers settle into cond.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= N:
+                    break
+
+            # Notify all threads: they are all in their second wait
+            cond.acquire()
+            cond.notify_all()
+            wait_threads_blocked(N)
+
+            # Phase 3
+            phase_num = 3
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results2) >= N:
+                    break
+            self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
+            self.assertEqual(results2, [(True, 2)] * count1 + [(True, 3)] * count2)
 
     def test_notify(self):
         cond = self.condtype()
@@ -544,19 +683,23 @@ def test_notify(self):
 
     def test_timeout(self):
         cond = self.condtype()
+        timeout = 0.5
         results = []
-        N = 5
         def f():
             cond.acquire()
             t1 = time.monotonic()
-            result = cond.wait(0.5)
+            result = cond.wait(timeout)
             t2 = time.monotonic()
             cond.release()
             results.append((t2 - t1, result))
-        Bunch(f, N).wait_for_finished()
+
+        N = 5
+        with Bunch(f, N):
+            pass
         self.assertEqual(len(results), N)
+
         for dt, result in results:
-            self.assertTimeout(dt, 0.5)
+            self.assertTimeout(dt, timeout)
             # Note that conceptually (that"s the condition variable protocol)
             # a wait() may succeed even if no one notifies us and before any
             # timeout occurs.  Spurious wakeups can occur.
@@ -569,17 +712,16 @@ def test_waitfor(self):
         state = 0
         def f():
             with cond:
-                result = cond.wait_for(lambda : state==4)
+                result = cond.wait_for(lambda: state == 4)
                 self.assertTrue(result)
                 self.assertEqual(state, 4)
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        for i in range(4):
-            time.sleep(0.01)
-            with cond:
-                state += 1
-                cond.notify()
-        b.wait_for_finished()
+
+        with Bunch(f, 1):
+            for i in range(4):
+                time.sleep(0.010)
+                with cond:
+                    state += 1
+                    cond.notify()
 
     def test_waitfor_timeout(self):
         cond = self.condtype()
@@ -593,15 +735,15 @@ def f():
                 self.assertFalse(result)
                 self.assertTimeout(dt, 0.1)
                 success.append(None)
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        # Only increment 3 times, so state == 4 is never reached.
-        for i in range(3):
-            time.sleep(0.01)
-            with cond:
-                state += 1
-                cond.notify()
-        b.wait_for_finished()
+
+        with Bunch(f, 1):
+            # Only increment 3 times, so state == 4 is never reached.
+            for i in range(3):
+                time.sleep(0.010)
+                with cond:
+                    state += 1
+                    cond.notify()
+
         self.assertEqual(len(success), 1)
 
 
@@ -630,41 +772,107 @@ def test_acquire_destroy(self):
         del sem
 
     def test_acquire_contended(self):
-        sem = self.semtype(7)
+        sem_value = 7
+        sem = self.semtype(sem_value)
         sem.acquire()
-        N = 10
+
         sem_results = []
         results1 = []
         results2 = []
         phase_num = 0
-        def f():
+
+        def func():
             sem_results.append(sem.acquire())
             results1.append(phase_num)
+
             sem_results.append(sem.acquire())
             results2.append(phase_num)
-        b = Bunch(f, 10)
-        b.wait_for_started()
-        while len(results1) + len(results2) < 6:
-            _wait()
-        self.assertEqual(results1 + results2, [0] * 6)
-        phase_num = 1
-        for i in range(7):
+
+        def wait_count(count):
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= count:
+                    break
+
+        N = 10
+        with Bunch(func, N):
+            # Phase 0
+            count1 = sem_value - 1
+            wait_count(count1)
+            self.assertEqual(results1 + results2, [0] * count1)
+
+            # Phase 1
+            phase_num = 1
+            for i in range(sem_value):
+                sem.release()
+            count2 = sem_value
+            wait_count(count1 + count2)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2)
+
+            # Phase 2
+            phase_num = 2
+            count3 = (sem_value - 1)
+            for i in range(count3):
+                sem.release()
+            wait_count(count1 + count2 + count3)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2 + [2] * count3)
+            # The semaphore is still locked
+            self.assertFalse(sem.acquire(False))
+
+            # Final release, to let the last thread finish
+            count4 = 1
             sem.release()
-        while len(results1) + len(results2) < 13:
-            _wait()
-        self.assertEqual(sorted(results1 + results2), [0] * 6 + [1] * 7)
-        phase_num = 2
-        for i in range(6):
+
+        self.assertEqual(sem_results,
+                         [True] * (count1 + count2 + count3 + count4))
+
+    def test_multirelease(self):
+        sem_value = 7
+        sem = self.semtype(sem_value)
+        sem.acquire()
+
+        results1 = []
+        results2 = []
+        phase_num = 0
+        def func():
+            sem.acquire()
+            results1.append(phase_num)
+
+            sem.acquire()
+            results2.append(phase_num)
+
+        def wait_count(count):
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= count:
+                    break
+
+        with Bunch(func, 10):
+            # Phase 0
+            count1 = sem_value - 1
+            wait_count(count1)
+            self.assertEqual(results1 + results2, [0] * count1)
+
+            # Phase 1
+            phase_num = 1
+            count2 = sem_value
+            sem.release(count2)
+            wait_count(count1 + count2)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2)
+
+            # Phase 2
+            phase_num = 2
+            count3 = sem_value - 1
+            sem.release(count3)
+            wait_count(count1 + count2 + count3)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2 + [2] * count3)
+            # The semaphore is still locked
+            self.assertFalse(sem.acquire(False))
+
+            # Final release, to let the last thread finish
             sem.release()
-        while len(results1) + len(results2) < 19:
-            _wait()
-        self.assertEqual(sorted(results1 + results2), [0] * 6 + [1] * 7 + [2] * 6)
-        # The semaphore is still locked
-        self.assertFalse(sem.acquire(False))
-        # Final release, to let the last thread finish
-        sem.release()
-        b.wait_for_finished()
-        self.assertEqual(sem_results, [True] * (6 + 7 + 6 + 1))
 
     def test_try_acquire(self):
         sem = self.semtype(2)
@@ -681,7 +889,8 @@ def test_try_acquire_contended(self):
         def f():
             results.append(sem.acquire(False))
             results.append(sem.acquire(False))
-        Bunch(f, 5).wait_for_finished()
+        with Bunch(f, 5):
+            pass
         # There can be a thread switch between acquiring the semaphore and
         # appending the result, therefore results will not necessarily be
         # ordered.
@@ -707,12 +916,14 @@ def test_default_value(self):
         def f():
             sem.acquire()
             sem.release()
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        _wait()
-        self.assertFalse(b.finished)
-        sem.release()
-        b.wait_for_finished()
+
+        with Bunch(f, 1) as bunch:
+            # Thread blocked on sem.acquire()
+            wait_threads_blocked(1)
+            self.assertFalse(bunch.finished)
+
+            # Thread unblocked
+            sem.release()
 
     def test_with(self):
         sem = self.semtype(2)
@@ -744,6 +955,15 @@ def test_release_unacquired(self):
         sem.acquire()
         sem.release()
 
+    def test_repr(self):
+        sem = self.semtype(3)
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=3>")
+        sem.acquire()
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=2>")
+        sem.release()
+        sem.release()
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=4>")
+
 
 class BoundedSemaphoreTests(BaseSemaphoreTests):
     """
@@ -758,6 +978,12 @@ def test_release_unacquired(self):
         sem.release()
         self.assertRaises(ValueError, sem.release)
 
+    def test_repr(self):
+        sem = self.semtype(3)
+        self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=3/3>")
+        sem.acquire()
+        self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=2/3>")
+
 
 class BarrierTests(BaseTestCase):
     """
@@ -768,13 +994,13 @@ class BarrierTests(BaseTestCase):
 
     def setUp(self):
         self.barrier = self.barriertype(self.N, timeout=self.defaultTimeout)
+
     def tearDown(self):
         self.barrier.abort()
 
     def run_threads(self, f):
-        b = Bunch(f, self.N-1)
-        f()
-        b.wait_for_finished()
+        with Bunch(f, self.N):
+            pass
 
     def multipass(self, results, n):
         m = self.barrier.parties
@@ -789,6 +1015,10 @@ def multipass(self, results, n):
         self.assertEqual(self.barrier.n_waiting, 0)
         self.assertFalse(self.barrier.broken)
 
+    def test_constructor(self):
+        self.assertRaises(ValueError, self.barriertype, parties=0)
+        self.assertRaises(ValueError, self.barriertype, parties=-1)
+
     def test_barrier(self, passes=1):
         """
         Test that a barrier is passed in lockstep
@@ -865,8 +1095,9 @@ def f():
             i = self.barrier.wait()
             if i == self.N//2:
                 # Wait until the other threads are all in the barrier.
-                while self.barrier.n_waiting < self.N-1:
-                    time.sleep(0.001)
+                for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                    if self.barrier.n_waiting >= (self.N - 1):
+                        break
                 self.barrier.reset()
             else:
                 try:
@@ -926,27 +1157,56 @@ def f():
             i = self.barrier.wait()
             if i == self.N // 2:
                 # One thread is late!
-                time.sleep(1.0)
+                time.sleep(self.defaultTimeout / 2)
             # Default timeout is 2.0, so this is shorter.
             self.assertRaises(threading.BrokenBarrierError,
-                              self.barrier.wait, 0.5)
+                              self.barrier.wait, self.defaultTimeout / 4)
         self.run_threads(f)
 
     def test_default_timeout(self):
         """
         Test the barrier's default timeout
         """
-        # create a barrier with a low default timeout
-        barrier = self.barriertype(self.N, timeout=0.3)
+        timeout = 0.100
+        barrier = self.barriertype(2, timeout=timeout)
         def f():
-            i = barrier.wait()
-            if i == self.N // 2:
-                # One thread is later than the default timeout of 0.3s.
-                time.sleep(1.0)
-            self.assertRaises(threading.BrokenBarrierError, barrier.wait)
-        self.run_threads(f)
+            self.assertRaises(threading.BrokenBarrierError,
+                              barrier.wait)
+
+        start_time = time.monotonic()
+        with Bunch(f, 1):
+            pass
+        dt = time.monotonic() - start_time
+        self.assertGreaterEqual(dt, timeout)
 
     def test_single_thread(self):
         b = self.barriertype(1)
         b.wait()
         b.wait()
+
+    def test_repr(self):
+        barrier = self.barriertype(3)
+        timeout = support.LONG_TIMEOUT
+        self.assertRegex(repr(barrier), r"<\w+\.Barrier at .*: waiters=0/3>")
+        def f():
+            barrier.wait(timeout)
+
+        N = 2
+        with Bunch(f, N):
+            # Threads blocked on barrier.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if barrier.n_waiting >= N:
+                    break
+            self.assertRegex(repr(barrier),
+                             r"<\w+\.Barrier at .*: waiters=2/3>")
+
+            # Threads unblocked
+            barrier.wait(timeout)
+
+        self.assertRegex(repr(barrier),
+                         r"<\w+\.Barrier at .*: waiters=0/3>")
+
+        # Abort the barrier
+        barrier.abort()
+        self.assertRegex(repr(barrier),
+                         r"<\w+\.Barrier at .*: broken>")
diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
index 99b71676ae7..9d3c771eaeb 100644
--- a/Lib/test/test_concurrent_futures/test_process_pool.py
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -190,7 +190,6 @@ def test_max_tasks_early_shutdown(self):
         for i, future in enumerate(futures):
             self.assertEqual(future.result(), mul(i, i))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON AttributeError: module 'threading' has no attribute '_start_joinable_thread'. Did you mean: '_start_new_thread'?
     def test_python_finalization_error(self):
         # gh-109047: Catch RuntimeError on thread creation
         # during Python finalization.
diff --git a/Lib/test/test_concurrent_futures/test_shutdown.py b/Lib/test/test_concurrent_futures/test_shutdown.py
index c879b6539b1..820ea6cf253 100644
--- a/Lib/test/test_concurrent_futures/test_shutdown.py
+++ b/Lib/test/test_concurrent_futures/test_shutdown.py
@@ -108,7 +108,6 @@ def test_cancel_futures(self):
         # one finished.
         self.assertGreater(len(others), 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON AssertionError: b'' != b'apple'
     def test_hang_gh83386(self):
         """shutdown(wait=False) doesn't hang at exit with running futures.
 
@@ -256,6 +255,11 @@ def test_cancel_futures_wait_false(self):
 
 
 class ProcessPoolShutdownTest(ExecutorShutdownTest):
+    # TODO: RUSTPYTHON - flaky, dict changed size during iteration race condition
+    @unittest.skip("TODO: RUSTPYTHON - flaky race condition on macOS")
+    def test_cancel_futures(self):
+        return super().test_cancel_futures()
+
     def test_processes_terminate(self):
         def acquire_lock(lock):
             lock.acquire()
diff --git a/Lib/test/test_concurrent_futures/test_thread_pool.py b/Lib/test/test_concurrent_futures/test_thread_pool.py
index 52df01b376c..4324241b374 100644
--- a/Lib/test/test_concurrent_futures/test_thread_pool.py
+++ b/Lib/test/test_concurrent_futures/test_thread_pool.py
@@ -66,14 +66,8 @@ def submit(pool):
                 with futures.ProcessPoolExecutor(1, mp_context=mp.get_context('fork')) as workers:
                     workers.submit(tuple)
 
-    import sys  # TODO: RUSTPYTHON
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
-    )
     @support.requires_fork()
     @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
-    @unittest.expectedFailure # TODO: RUSTPYTHON AssertionError: DeprecationWarning not triggered
     def test_process_fork_from_a_threadpool(self):
         # bpo-43944: clear concurrent.futures.thread._threads_queues after fork,
         # otherwise child process will try to join parent thread
diff --git a/Lib/test/test_importlib/test_locks.py b/Lib/test/test_importlib/test_locks.py
index 17cce741cce..edf0329c753 100644
--- a/Lib/test/test_importlib/test_locks.py
+++ b/Lib/test/test_importlib/test_locks.py
@@ -29,6 +29,8 @@ class ModuleLockAsRLockTests:
     test_timeout = None
     # _release_save() unsupported
     test_release_save_unacquired = None
+    # _recursion_count() unsupported
+    test_recursion_count = None
     # lock status in repr unsupported
     test_repr = None
     test_locked_repr = None
@@ -92,7 +94,8 @@ def f():
                 b.release()
             if ra:
                 a.release()
-        lock_tests.Bunch(f, NTHREADS).wait_for_finished()
+        with lock_tests.Bunch(f, NTHREADS):
+            pass
         self.assertEqual(len(results), NTHREADS)
         return results
 
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 969c2866aac..e5f88b325e0 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -920,7 +920,7 @@ def test_sys_getwindowsversion_no_instantiation(self):
     def test_clear_type_cache(self):
         sys._clear_type_cache()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; cp424 encoding not supported, causes panic")
     @force_not_colorized
     @support.requires_subprocess()
     def test_ioencoding(self):
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index eabc872583f..910797afa8f 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -3,10 +3,11 @@
 """
 
 import test.support
-from test.support import threading_helper, requires_subprocess
+from test.support import threading_helper, requires_subprocess, requires_gil_enabled
 from test.support import verbose, cpython_only, os_helper
 from test.support.import_helper import import_module
 from test.support.script_helper import assert_python_ok, assert_python_failure
+from test.support import force_not_colorized
 
 import random
 import sys
@@ -20,11 +21,17 @@
 import signal
 import textwrap
 import traceback
+import warnings
 
 from unittest import mock
 from test import lock_tests
 from test import support
 
+try:
+    from test.support import interpreters
+except ImportError:
+    interpreters = None
+
 threading_helper.requires_working_threading(module=True)
 
 # Between fork() and exec(), only async-safe functions are allowed (issues
@@ -34,6 +41,24 @@
 platforms_to_skip = ('netbsd5', 'hp-ux11')
 
 
+def skip_unless_reliable_fork(test):
+    if not support.has_fork_support:
+        return unittest.skip("requires working os.fork()")(test)
+    if sys.platform in platforms_to_skip:
+        return unittest.skip("due to known OS bug related to thread+fork")(test)
+    if support.HAVE_ASAN_FORK_BUG:
+        return unittest.skip("libasan has a pthread_create() dead lock related to thread+fork")(test)
+    if support.check_sanitizer(thread=True):
+        return unittest.skip("TSAN doesn't support threads after fork")(test)
+    return test
+
+
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(interpreters is None,
+                           'subinterpreters required')(meth)
+
+
 def restore_default_excepthook(testcase):
     testcase.addCleanup(setattr, threading, 'excepthook', threading.excepthook)
     threading.excepthook = threading.__excepthook__
@@ -93,6 +118,7 @@ def tearDown(self):
 
 
 class ThreadTests(BaseTestCase):
+    maxDiff = 9999
 
     @cpython_only
     def test_name(self):
@@ -148,11 +174,21 @@ def test_args_argument(self):
                 t.start()
                 t.join()
 
-    @cpython_only
-    def test_disallow_instantiation(self):
-        # Ensure that the type disallows instantiation (bpo-43916)
-        lock = threading.Lock()
-        test.support.check_disallow_instantiation(self, type(lock))
+    def test_lock_no_args(self):
+        threading.Lock()  # works
+        self.assertRaises(TypeError, threading.Lock, 1)
+        self.assertRaises(TypeError, threading.Lock, a=1)
+        self.assertRaises(TypeError, threading.Lock, 1, 2, a=1, b=2)
+
+    def test_lock_no_subclass(self):
+        # Intentionally disallow subclasses of threading.Lock because they have
+        # never been allowed, so why start now just because the type is public?
+        with self.assertRaises(TypeError):
+            class MyLock(threading.Lock): pass
+
+    def test_lock_or_none(self):
+        import types
+        self.assertIsInstance(threading.Lock | None, types.UnionType)
 
     # Create a bunch of threads, let each do some work, wait until all are
     # done.
@@ -204,8 +240,6 @@ def f():
             tid = _thread.start_new_thread(f, ())
             done.wait()
             self.assertEqual(ident[0], tid)
-        # Kill the "immortal" _DummyThread
-        del threading._active[ident[0]]
 
     # run with a small(ish) thread stack size (256 KiB)
     def test_various_ops_small_stack(self):
@@ -233,11 +267,29 @@ def test_various_ops_large_stack(self):
 
     def test_foreign_thread(self):
         # Check that a "foreign" thread can use the threading module.
+        dummy_thread = None
+        error = None
         def f(mutex):
-            # Calling current_thread() forces an entry for the foreign
-            # thread to get made in the threading._active map.
-            threading.current_thread()
-            mutex.release()
+            try:
+                nonlocal dummy_thread
+                nonlocal error
+                # Calling current_thread() forces an entry for the foreign
+                # thread to get made in the threading._active map.
+                dummy_thread = threading.current_thread()
+                tid = dummy_thread.ident
+                self.assertIn(tid, threading._active)
+                self.assertIsInstance(dummy_thread, threading._DummyThread)
+                self.assertIs(threading._active.get(tid), dummy_thread)
+                # gh-29376
+                self.assertTrue(
+                    dummy_thread.is_alive(),
+                    'Expected _DummyThread to be considered alive.'
+                )
+                self.assertIn('_DummyThread', repr(dummy_thread))
+            except BaseException as e:
+                error = e
+            finally:
+                mutex.release()
 
         mutex = threading.Lock()
         mutex.acquire()
@@ -245,16 +297,29 @@ def f(mutex):
             tid = _thread.start_new_thread(f, (mutex,))
             # Wait for the thread to finish.
             mutex.acquire()
-        self.assertIn(tid, threading._active)
-        self.assertIsInstance(threading._active[tid], threading._DummyThread)
-        #Issue 29376
-        self.assertTrue(threading._active[tid].is_alive())
-        self.assertRegex(repr(threading._active[tid]), '_DummyThread')
-        del threading._active[tid]
+        if error is not None:
+            raise error
+        self.assertEqual(tid, dummy_thread.ident)
+        # Issue gh-106236:
+        with self.assertRaises(RuntimeError):
+            dummy_thread.join()
+        dummy_thread._started.clear()
+        with self.assertRaises(RuntimeError):
+            dummy_thread.is_alive()
+        # Busy wait for the following condition: after the thread dies, the
+        # related dummy thread must be removed from threading._active.
+        timeout = 5
+        timeout_at = time.monotonic() + timeout
+        while time.monotonic() < timeout_at:
+            if threading._active.get(dummy_thread.ident) is not dummy_thread:
+                break
+            time.sleep(.1)
+        else:
+            self.fail('It was expected that the created threading._DummyThread was removed from threading._active.')
 
     # PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
     # exposed at the Python level.  This test relies on ctypes to get at it.
-    @unittest.skip("TODO: RUSTPYTHON; expects @cpython_only")
+    @unittest.skip('TODO: RUSTPYTHON; expects @cpython_only')
     def test_PyThreadState_SetAsyncExc(self):
         ctypes = import_module("ctypes")
 
@@ -343,12 +408,13 @@ def run(self):
             t.join()
         # else the thread is still running, and we have no way to kill it
 
+    @unittest.skip('TODO: RUSTPYTHON; threading._start_new_thread not exposed')
     def test_limbo_cleanup(self):
         # Issue 7481: Failure to start thread should cleanup the limbo map.
-        def fail_new_thread(*args):
+        def fail_new_thread(*args, **kwargs):
             raise threading.ThreadError()
-        _start_new_thread = threading._start_new_thread
-        threading._start_new_thread = fail_new_thread
+        _start_joinable_thread = threading._start_joinable_thread
+        threading._start_joinable_thread = fail_new_thread
         try:
             t = threading.Thread(target=lambda: None)
             self.assertRaises(threading.ThreadError, t.start)
@@ -356,13 +422,17 @@ def fail_new_thread(*args):
                 t in threading._limbo,
                 "Failed to cleanup _limbo map on failure of Thread.start().")
         finally:
-            threading._start_new_thread = _start_new_thread
+            threading._start_joinable_thread = _start_joinable_thread
 
-    @unittest.skip("TODO: RUSTPYTHON; ctypes.pythonapi is not supported")
+    @unittest.skip('TODO: RUSTPYTHON; ctypes.pythonapi is not supported')
     def test_finalize_running_thread(self):
         # Issue 1402: the PyGILState_Ensure / _Release functions may be called
         # very late on python exit: on deallocation of a running thread for
         # example.
+        if support.check_sanitizer(thread=True):
+            # the thread running `time.sleep(100)` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
         import_module("ctypes")
 
         rc, out, err = assert_python_failure("-c", """if 1:
@@ -395,6 +465,11 @@ def waitingThread():
     def test_finalize_with_trace(self):
         # Issue1733757
         # Avoid a deadlock when sys.settrace steps into threading._shutdown
+        if support.check_sanitizer(thread=True):
+            # the thread running `time.sleep(2)` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
+
         assert_python_ok("-c", """if 1:
             import sys, threading
 
@@ -417,8 +492,7 @@ def func(frame, event, arg):
             sys.settrace(func)
             """)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_join_nondaemon_on_shutdown(self):
         # Issue 1722344
         # Raising SystemExit skipped threading._shutdown
@@ -446,7 +520,7 @@ def test_enumerate_after_join(self):
         old_interval = sys.getswitchinterval()
         try:
             for i in range(1, 100):
-                sys.setswitchinterval(i * 0.0002)
+                support.setswitchinterval(i * 0.0002)
                 t = threading.Thread(target=lambda: None)
                 t.start()
                 t.join()
@@ -456,6 +530,48 @@ def test_enumerate_after_join(self):
         finally:
             sys.setswitchinterval(old_interval)
 
+    @support.bigmemtest(size=20, memuse=72*2**20, dry_run=False)
+    def test_join_from_multiple_threads(self, size):
+        # Thread.join() should be thread-safe
+        errors = []
+
+        def worker():
+            time.sleep(0.005)
+
+        def joiner(thread):
+            try:
+                thread.join()
+            except Exception as e:
+                errors.append(e)
+
+        for N in range(2, 20):
+            threads = [threading.Thread(target=worker)]
+            for i in range(N):
+                threads.append(threading.Thread(target=joiner,
+                                                args=(threads[0],)))
+            for t in threads:
+                t.start()
+            time.sleep(0.01)
+            for t in threads:
+                t.join()
+            if errors:
+                raise errors[0]
+
+    def test_join_with_timeout(self):
+        lock = _thread.allocate_lock()
+        lock.acquire()
+
+        def worker():
+            lock.acquire()
+
+        thread = threading.Thread(target=worker)
+        thread.start()
+        thread.join(timeout=0.01)
+        assert thread.is_alive()
+        lock.release()
+        thread.join()
+        assert not thread.is_alive()
+
     def test_no_refcycle_through_target(self):
         class RunSelfFunction(object):
             def __init__(self, should_raise):
@@ -534,40 +650,12 @@ def test_daemon_param(self):
         t = threading.Thread(daemon=True)
         self.assertTrue(t.daemon)
 
-    @support.requires_fork()
-    def test_fork_at_exit(self):
-        # bpo-42350: Calling os.fork() after threading._shutdown() must
-        # not log an error.
-        code = textwrap.dedent("""
-            import atexit
-            import os
-            import sys
-            from test.support import wait_process
-
-            # Import the threading module to register its "at fork" callback
-            import threading
-
-            def exit_handler():
-                pid = os.fork()
-                if not pid:
-                    print("child process ok", file=sys.stderr, flush=True)
-                    # child process
-                else:
-                    wait_process(pid, exitcode=0)
-
-            # exit_handler() will be called after threading._shutdown()
-            atexit.register(exit_handler)
-        """)
-        _, out, err = assert_python_ok("-c", code)
-        self.assertEqual(out, b'')
-        self.assertEqual(err.rstrip(), b'child process ok')
-
-    @support.requires_fork()
+    @skip_unless_reliable_fork
     def test_dummy_thread_after_fork(self):
         # Issue #14308: a dummy thread in the active list doesn't mess up
         # the after-fork mechanism.
         code = """if 1:
-            import _thread, threading, os, time
+            import _thread, threading, os, time, warnings
 
             def background_thread(evt):
                 # Creates and registers the _DummyThread instance
@@ -579,18 +667,23 @@ def background_thread(evt):
             _thread.start_new_thread(background_thread, (evt,))
             evt.wait()
             assert threading.active_count() == 2, threading.active_count()
-            if os.fork() == 0:
-                assert threading.active_count() == 1, threading.active_count()
-                os._exit(0)
-            else:
-                os.wait()
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.filterwarnings(
+                        "always", category=DeprecationWarning)
+                if os.fork() == 0:
+                    assert threading.active_count() == 1, threading.active_count()
+                    os._exit(0)
+                else:
+                    assert ws[0].category == DeprecationWarning, ws[0]
+                    assert 'fork' in str(ws[0].message), ws[0]
+                    os.wait()
         """
         _, out, err = assert_python_ok("-c", code)
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky")
-    @support.requires_fork()
+    @unittest.skip('TODO: RUSTPYTHON; flaky')
+    @skip_unless_reliable_fork
     def test_is_alive_after_fork(self):
         # Try hard to trigger #18418: is_alive() could sometimes be True on
         # threads that vanished after a fork.
@@ -603,13 +696,15 @@ def test_is_alive_after_fork(self):
         for i in range(20):
             t = threading.Thread(target=lambda: None)
             t.start()
-            pid = os.fork()
-            if pid == 0:
-                os._exit(11 if t.is_alive() else 10)
-            else:
-                t.join()
+            # Ignore the warning about fork with threads.
+            with warnings.catch_warnings(category=DeprecationWarning,
+                                         action="ignore"):
+                if (pid := os.fork()) == 0:
+                    os._exit(11 if t.is_alive() else 10)
+                else:
+                    t.join()
 
-                support.wait_process(pid, exitcode=10)
+                    support.wait_process(pid, exitcode=10)
 
     def test_main_thread(self):
         main = threading.main_thread()
@@ -624,48 +719,59 @@ def f():
         th.start()
         th.join()
 
-    @support.requires_fork()
+    @skip_unless_reliable_fork
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     def test_main_thread_after_fork(self):
         code = """if 1:
             import os, threading
             from test import support
 
+            ident = threading.get_ident()
             pid = os.fork()
             if pid == 0:
+                print("current ident", threading.get_ident() == ident)
                 main = threading.main_thread()
-                print(main.name)
-                print(main.ident == threading.current_thread().ident)
-                print(main.ident == threading.get_ident())
+                print("main", main.name)
+                print("main ident", main.ident == ident)
+                print("current is main", threading.current_thread() is main)
             else:
                 support.wait_process(pid, exitcode=0)
         """
         _, out, err = assert_python_ok("-c", code)
         data = out.decode().replace('\r', '')
         self.assertEqual(err, b"")
-        self.assertEqual(data, "MainThread\nTrue\nTrue\n")
+        self.assertEqual(data,
+                         "current ident True\n"
+                         "main MainThread\n"
+                         "main ident True\n"
+                         "current is main True\n")
 
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    @support.requires_fork()
+    @skip_unless_reliable_fork
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
-    @unittest.skipIf(os.name != 'posix', "test needs POSIX semantics")
     def test_main_thread_after_fork_from_nonmain_thread(self):
         code = """if 1:
-            import os, threading, sys
+            import os, threading, sys, warnings
             from test import support
 
             def func():
-                pid = os.fork()
-                if pid == 0:
-                    main = threading.main_thread()
-                    print(main.name)
-                    print(main.ident == threading.current_thread().ident)
-                    print(main.ident == threading.get_ident())
-                    # stdout is fully buffered because not a tty,
-                    # we have to flush before exit.
-                    sys.stdout.flush()
-                else:
-                    support.wait_process(pid, exitcode=0)
+                ident = threading.get_ident()
+                with warnings.catch_warnings(record=True) as ws:
+                    warnings.filterwarnings(
+                            "always", category=DeprecationWarning)
+                    pid = os.fork()
+                    if pid == 0:
+                        print("current ident", threading.get_ident() == ident)
+                        main = threading.main_thread()
+                        print("main", main.name, type(main).__name__)
+                        print("main ident", main.ident == ident)
+                        print("current is main", threading.current_thread() is main)
+                        # stdout is fully buffered because not a tty,
+                        # we have to flush before exit.
+                        sys.stdout.flush()
+                    else:
+                        assert ws[0].category == DeprecationWarning, ws[0]
+                        assert 'fork' in str(ws[0].message), ws[0]
+                        support.wait_process(pid, exitcode=0)
 
             th = threading.Thread(target=func)
             th.start()
@@ -673,11 +779,82 @@ def func():
         """
         _, out, err = assert_python_ok("-c", code)
         data = out.decode().replace('\r', '')
-        self.assertEqual(err, b"")
-        self.assertEqual(data, "Thread-1 (func)\nTrue\nTrue\n")
+        self.assertEqual(err.decode('utf-8'), "")
+        self.assertEqual(data,
+                         "current ident True\n"
+                         "main Thread-1 (func) Thread\n"
+                         "main ident True\n"
+                         "current is main True\n"
+                         )
+
+    @skip_unless_reliable_fork
+    @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
+    def test_main_thread_after_fork_from_foreign_thread(self, create_dummy=False):
+        code = """if 1:
+            import os, threading, sys, traceback, _thread
+            from test import support
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+            def func(lock):
+                ident = threading.get_ident()
+                if %s:
+                    # call current_thread() before fork to allocate DummyThread
+                    current = threading.current_thread()
+                    print("current", current.name, type(current).__name__)
+                print("ident in _active", ident in threading._active)
+                # flush before fork, so child won't flush it again
+                sys.stdout.flush()
+                pid = os.fork()
+                if pid == 0:
+                    print("current ident", threading.get_ident() == ident)
+                    main = threading.main_thread()
+                    print("main", main.name, type(main).__name__)
+                    print("main ident", main.ident == ident)
+                    print("current is main", threading.current_thread() is main)
+                    print("_dangling", [t.name for t in list(threading._dangling)])
+                    # stdout is fully buffered because not a tty,
+                    # we have to flush before exit.
+                    sys.stdout.flush()
+                    try:
+                        threading._shutdown()
+                        os._exit(0)
+                    except:
+                        traceback.print_exc()
+                        sys.stderr.flush()
+                        os._exit(1)
+                else:
+                    try:
+                        support.wait_process(pid, exitcode=0)
+                    except Exception:
+                        # avoid 'could not acquire lock for
+                        # <_io.BufferedWriter name='<stderr>'> at interpreter shutdown,'
+                        traceback.print_exc()
+                        sys.stderr.flush()
+                    finally:
+                        lock.release()
+
+            join_lock = _thread.allocate_lock()
+            join_lock.acquire()
+            th = _thread.start_new_thread(func, (join_lock,))
+            join_lock.acquire()
+        """ % create_dummy
+        # "DeprecationWarning: This process is multi-threaded, use of fork()
+        # may lead to deadlocks in the child"
+        _, out, err = assert_python_ok("-W", "ignore::DeprecationWarning", "-c", code)
+        data = out.decode().replace('\r', '')
+        self.assertEqual(err.decode(), "")
+        self.assertEqual(data,
+                         ("current Dummy-1 _DummyThread\n" if create_dummy else "") +
+                         f"ident in _active {create_dummy!s}\n" +
+                         "current ident True\n"
+                         "main MainThread _MainThread\n"
+                         "main ident True\n"
+                         "current is main True\n"
+                         "_dangling ['MainThread']\n")
+
+    def test_main_thread_after_fork_from_dummy_thread(self, create_dummy=False):
+        self.test_main_thread_after_fork_from_foreign_thread(create_dummy=True)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_main_thread_during_shutdown(self):
         # bpo-31516: current_thread() should still point to the main thread
         # at shutdown
@@ -742,41 +919,6 @@ def f():
         rc, out, err = assert_python_ok("-c", code)
         self.assertEqual(err, b"")
 
-    def test_tstate_lock(self):
-        # Test an implementation detail of Thread objects.
-        started = _thread.allocate_lock()
-        finish = _thread.allocate_lock()
-        started.acquire()
-        finish.acquire()
-        def f():
-            started.release()
-            finish.acquire()
-            time.sleep(0.01)
-        # The tstate lock is None until the thread is started
-        t = threading.Thread(target=f)
-        self.assertIs(t._tstate_lock, None)
-        t.start()
-        started.acquire()
-        self.assertTrue(t.is_alive())
-        # The tstate lock can't be acquired when the thread is running
-        # (or suspended).
-        tstate_lock = t._tstate_lock
-        self.assertFalse(tstate_lock.acquire(timeout=0), False)
-        finish.release()
-        # When the thread ends, the state_lock can be successfully
-        # acquired.
-        self.assertTrue(tstate_lock.acquire(timeout=support.SHORT_TIMEOUT), False)
-        # But is_alive() is still True:  we hold _tstate_lock now, which
-        # prevents is_alive() from knowing the thread's end-of-life C code
-        # is done.
-        self.assertTrue(t.is_alive())
-        # Let is_alive() find out the C code is done.
-        tstate_lock.release()
-        self.assertFalse(t.is_alive())
-        # And verify the thread disposed of _tstate_lock.
-        self.assertIsNone(t._tstate_lock)
-        t.join()
-
     def test_repr_stopped(self):
         # Verify that "stopped" shows up in repr(Thread) appropriately.
         started = _thread.allocate_lock()
@@ -824,6 +966,7 @@ def test_BoundedSemaphore_limit(self):
 
     @cpython_only
     def test_frame_tstate_tracing(self):
+        _testcapi = import_module("_testcapi")
         # Issue #14432: Crash when a generator is created in a C thread that is
         # destroyed while the generator is still used. The issue was that a
         # generator contains a frame, and the frame kept a reference to the
@@ -851,7 +994,6 @@ def callback():
             threading.settrace(noop_trace)
 
             # Create a generator in a C thread which exits after the call
-            import _testcapi
             _testcapi.call_in_temporary_c_thread(callback)
 
             # Call the generator in a different Python thread, check that the
@@ -875,12 +1017,7 @@ def noop_trace(frame, event, arg):
         finally:
             threading.settrace(old_trace)
 
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
-    )
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gettrace_all_threads(self):
         def fn(*args): pass
         old_trace = threading.gettrace()
@@ -919,12 +1056,7 @@ def fn(*args): pass
         finally:
             threading.setprofile(old_profile)
 
-    @unittest.skipIf(
-        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
-        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason"
-    )
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getprofile_all_threads(self):
         def fn(*args): pass
         old_profile = threading.getprofile()
@@ -954,32 +1086,7 @@ def checker():
         self.assertEqual(threading.getprofile(), old_profile)
         self.assertEqual(sys.getprofile(), old_profile)
 
-    @cpython_only
-    def test_shutdown_locks(self):
-        for daemon in (False, True):
-            with self.subTest(daemon=daemon):
-                event = threading.Event()
-                thread = threading.Thread(target=event.wait, daemon=daemon)
-
-                # Thread.start() must add lock to _shutdown_locks,
-                # but only for non-daemon thread
-                thread.start()
-                tstate_lock = thread._tstate_lock
-                if not daemon:
-                    self.assertIn(tstate_lock, threading._shutdown_locks)
-                else:
-                    self.assertNotIn(tstate_lock, threading._shutdown_locks)
-
-                # unblock the thread and join it
-                event.set()
-                thread.join()
-
-                # Thread._stop() must remove tstate_lock from _shutdown_locks.
-                # Daemon threads must never add it to _shutdown_locks.
-                self.assertNotIn(tstate_lock, threading._shutdown_locks)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_locals_at_exit(self):
         # bpo-19466: thread locals must not be deleted before destructors
         # are called
@@ -1057,6 +1164,164 @@ def import_threading():
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+    # TODO: RUSTPYTHON - __del__ not called during interpreter finalization (no cyclic GC)
+    @unittest.expectedFailure
+    def test_start_new_thread_at_finalization(self):
+        code = """if 1:
+            import _thread
+
+            def f():
+                print("shouldn't be printed")
+
+            class AtFinalization:
+                def __del__(self):
+                    print("OK")
+                    _thread.start_new_thread(f, ())
+            at_finalization = AtFinalization()
+        """
+        _, out, err = assert_python_ok("-c", code)
+        self.assertEqual(out.strip(), b"OK")
+        self.assertIn(b"can't create new thread at interpreter shutdown", err)
+
+    def test_start_new_thread_failed(self):
+        # gh-109746: if Python fails to start newly created thread
+        # due to failure of underlying PyThread_start_new_thread() call,
+        # its state should be removed from interpreter' thread states list
+        # to avoid its double cleanup
+        try:
+            from resource import setrlimit, RLIMIT_NPROC
+        except ImportError as err:
+            self.skipTest(err)  # RLIMIT_NPROC is specific to Linux and BSD
+        code = """if 1:
+            import resource
+            import _thread
+
+            def f():
+                print("shouldn't be printed")
+
+            limits = resource.getrlimit(resource.RLIMIT_NPROC)
+            [_, hard] = limits
+            resource.setrlimit(resource.RLIMIT_NPROC, (0, hard))
+
+            try:
+                handle = _thread.start_joinable_thread(f)
+            except RuntimeError:
+                print('ok')
+            else:
+                print('!skip!')
+                handle.join()
+        """
+        _, out, err = assert_python_ok("-u", "-c", code)
+        out = out.strip()
+        if b'!skip!' in out:
+            self.skipTest('RLIMIT_NPROC had no effect; probably superuser')
+        self.assertEqual(out, b'ok')
+        self.assertEqual(err, b'')
+
+
+    @skip_unless_reliable_fork
+    @unittest.skipUnless(hasattr(threading, 'get_native_id'), "test needs threading.get_native_id()")
+    def test_native_id_after_fork(self):
+        script = """if True:
+            import threading
+            import os
+            from test import support
+
+            parent_thread_native_id = threading.current_thread().native_id
+            print(parent_thread_native_id, flush=True)
+            assert parent_thread_native_id == threading.get_native_id()
+            childpid = os.fork()
+            if childpid == 0:
+                print(threading.current_thread().native_id, flush=True)
+                assert threading.current_thread().native_id == threading.get_native_id()
+            else:
+                try:
+                    assert parent_thread_native_id == threading.current_thread().native_id
+                    assert parent_thread_native_id == threading.get_native_id()
+                finally:
+                    support.wait_process(childpid, exitcode=0)
+            """
+        rc, out, err = assert_python_ok('-c', script)
+        self.assertEqual(rc, 0)
+        self.assertEqual(err, b"")
+        native_ids = out.strip().splitlines()
+        self.assertEqual(len(native_ids), 2)
+        self.assertNotEqual(native_ids[0], native_ids[1])
+
+    @cpython_only
+    def test_finalize_daemon_thread_hang(self):
+        if support.check_sanitizer(thread=True, memory=True):
+            # the thread running `time.sleep(100)` below will still be alive
+            # at process exit
+            self.skipTest(
+                    "https://github.com/python/cpython/issues/124878 - Known"
+                    " race condition that TSAN identifies.")
+        # gh-87135: tests that daemon threads hang during finalization
+        script = textwrap.dedent('''
+            import os
+            import sys
+            import threading
+            import time
+            import _testcapi
+
+            lock = threading.Lock()
+            lock.acquire()
+            thread_started_event = threading.Event()
+            def thread_func():
+                try:
+                    thread_started_event.set()
+                    _testcapi.finalize_thread_hang(lock.acquire)
+                finally:
+                    # Control must not reach here.
+                    os._exit(2)
+
+            t = threading.Thread(target=thread_func)
+            t.daemon = True
+            t.start()
+            thread_started_event.wait()
+            # Sleep to ensure daemon thread is blocked on `lock.acquire`
+            #
+            # Note: This test is designed so that in the unlikely case that
+            # `0.1` seconds is not sufficient time for the thread to become
+            # blocked on `lock.acquire`, the test will still pass, it just
+            # won't be properly testing the thread behavior during
+            # finalization.
+            time.sleep(0.1)
+
+            def run_during_finalization():
+                # Wake up daemon thread
+                lock.release()
+                # Sleep to give the daemon thread time to crash if it is going
+                # to.
+                #
+                # Note: If due to an exceptionally slow execution this delay is
+                # insufficient, the test will still pass but will simply be
+                # ineffective as a test.
+                time.sleep(0.1)
+                # If control reaches here, the test succeeded.
+                os._exit(0)
+
+            # Replace sys.stderr.flush as a way to run code during finalization
+            orig_flush = sys.stderr.flush
+            def do_flush(*args, **kwargs):
+                orig_flush(*args, **kwargs)
+                if not sys.is_finalizing:
+                    return
+                sys.stderr.flush = orig_flush
+                run_during_finalization()
+
+            sys.stderr.flush = do_flush
+
+            # If the follow exit code is retained, `run_during_finalization`
+            # did not run.
+            sys.exit(1)
+        ''')
+        assert_python_ok("-c", script)
+
+    @unittest.skip('TODO: RUSTPYTHON; Thread._tstate_lock not implemented')
+    def test_tstate_lock(self):
+        return super().test_tstate_lock()
+
 
 class ThreadJoinOnShutdown(BaseTestCase):
 
@@ -1077,8 +1342,6 @@ def joiningfunc(mainthread):
         data = out.decode().replace('\r', '')
         self.assertEqual(data, "end of main\nend of thread\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_1_join_on_shutdown(self):
         # The usual case: on exit, wait for a non-daemon thread
         script = """if 1:
@@ -1091,10 +1354,7 @@ def test_1_join_on_shutdown(self):
             """
         self._run_and_join(script)
 
-    @support.requires_fork()
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    # TODO: RUSTPYTHON need to fix test_1_join_on_shutdown then this might work
-    @unittest.expectedFailure
+    @skip_unless_reliable_fork
     def test_2_join_in_forked_process(self):
         # Like the test above, but from a forked interpreter
         script = """if 1:
@@ -1114,9 +1374,8 @@ def test_2_join_in_forked_process(self):
             """
         self._run_and_join(script)
 
-    @support.requires_fork()
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    @skip_unless_reliable_fork
     def test_3_join_in_forked_from_thread(self):
         # Like the test above, but fork() was called from a worker thread
         # In the forked process, the main Thread object must be marked as stopped.
@@ -1145,10 +1404,16 @@ def worker():
         self._run_and_join(script)
 
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    def test_4_daemon_threads(self):
+    @support.bigmemtest(size=40, memuse=70*2**20, dry_run=False)
+    def test_4_daemon_threads(self, size):
         # Check that a daemon thread cannot crash the interpreter on shutdown
         # by manipulating internal structures that are being disposed of in
         # the main thread.
+        if support.check_sanitizer(thread=True):
+            # some of the threads running `random_io` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
+
         script = """if True:
             import os
             import random
@@ -1186,9 +1451,33 @@ def main():
         rc, out, err = assert_python_ok('-c', script)
         self.assertFalse(err)
 
-    @unittest.skip('TODO: RUSTPYTHON, flaky')
-    @support.requires_fork()
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
+    def test_thread_from_thread(self):
+        script = """if True:
+            import threading
+            import time
+
+            def thread2():
+                time.sleep(0.05)
+                print("OK")
+
+            def thread1():
+                time.sleep(0.05)
+                t2 = threading.Thread(target=thread2)
+                t2.start()
+
+            t = threading.Thread(target=thread1)
+            t.start()
+            # do not join() -- the interpreter waits for non-daemon threads to
+            # finish.
+            """
+        rc, out, err = assert_python_ok('-c', script)
+        self.assertEqual(err, b"")
+        self.assertEqual(out.strip(), b"OK")
+        self.assertEqual(rc, 0)
+
+    # TODO: RUSTPYTHON - parking_lot mutex not fork-safe, child may SIGSEGV
+    @unittest.skip("TODO: RUSTPYTHON - flaky, parking_lot mutex not fork-safe")
+    @skip_unless_reliable_fork
     def test_reinit_tls_after_fork(self):
         # Issue #13817: fork() would deadlock in a multithreaded program with
         # the ad-hoc TLS implementation.
@@ -1201,20 +1490,20 @@ def do_fork_and_wait():
             else:
                 os._exit(50)
 
-        # start a bunch of threads that will fork() child processes
-        threads = []
-        for i in range(16):
-            t = threading.Thread(target=do_fork_and_wait)
-            threads.append(t)
-            t.start()
+        # Ignore the warning about fork with threads.
+        with warnings.catch_warnings(category=DeprecationWarning,
+                                     action="ignore"):
+            # start a bunch of threads that will fork() child processes
+            threads = []
+            for i in range(16):
+                t = threading.Thread(target=do_fork_and_wait)
+                threads.append(t)
+                t.start()
 
-        for t in threads:
-            t.join()
+            for t in threads:
+                t.join()
 
-    @unittest.skip('TODO: RUSTPYTHON FAILURE, WORKER BUG')
-    @support.requires_fork()
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @skip_unless_reliable_fork
     def test_clear_threads_states_after_fork(self):
         # Issue #17094: check that threads states are cleared after fork()
 
@@ -1225,18 +1514,22 @@ def test_clear_threads_states_after_fork(self):
             threads.append(t)
             t.start()
 
-        pid = os.fork()
-        if pid == 0:
-            # check that threads states have been cleared
-            if len(sys._current_frames()) == 1:
-                os._exit(51)
-            else:
-                os._exit(52)
-        else:
-            support.wait_process(pid, exitcode=51)
-
-        for t in threads:
-            t.join()
+        try:
+            # Ignore the warning about fork with threads.
+            with warnings.catch_warnings(category=DeprecationWarning,
+                                         action="ignore"):
+                pid = os.fork()
+                if pid == 0:
+                    # check that threads states have been cleared
+                    if len(sys._current_frames()) == 1:
+                        os._exit(51)
+                    else:
+                        os._exit(52)
+                else:
+                    support.wait_process(pid, exitcode=51)
+        finally:
+            for t in threads:
+                t.join()
 
 
 class SubinterpThreadingTests(BaseTestCase):
@@ -1248,8 +1541,7 @@ def pipe(self):
             os.set_blocking(r, False)
         return (r, w)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_threads_join(self):
         # Non-daemon threads should be joined at subinterpreter shutdown
         # (issue #18808)
@@ -1278,8 +1570,7 @@ def f():
         # The thread was joined properly.
         self.assertEqual(os.read(r, 1), b"x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_threads_join_2(self):
         # Same as above, but a delay gets introduced after the thread's
         # Python code returned but before the thread state is deleted.
@@ -1317,8 +1608,47 @@ def f():
         # The thread was joined properly.
         self.assertEqual(os.read(r, 1), b"x")
 
+    @requires_subinterpreters
+    def test_threads_join_with_no_main(self):
+        r_interp, w_interp = self.pipe()
+
+        INTERP = b'I'
+        FINI = b'F'
+        DONE = b'D'
+
+        interp = interpreters.create()
+        interp.exec(f"""if True:
+            import os
+            import threading
+            import time
+
+            done = False
+
+            def notify_fini():
+                global done
+                done = True
+                os.write({w_interp}, {FINI!r})
+                t.join()
+            threading._register_atexit(notify_fini)
+
+            def task():
+                while not done:
+                    time.sleep(0.1)
+                os.write({w_interp}, {DONE!r})
+            t = threading.Thread(target=task)
+            t.start()
+
+            os.write({w_interp}, {INTERP!r})
+            """)
+        interp.close()
+
+        self.assertEqual(os.read(r_interp, 1), INTERP)
+        self.assertEqual(os.read(r_interp, 1), FINI)
+        self.assertEqual(os.read(r_interp, 1), DONE)
+
     @cpython_only
     def test_daemon_threads_fatal_error(self):
+        import_module("_testcapi")
         subinterp_code = f"""if 1:
             import os
             import threading
@@ -1340,6 +1670,67 @@ def f():
         self.assertIn("Fatal Python error: Py_EndInterpreter: "
                       "not the last thread", err.decode())
 
+    def _check_allowed(self, before_start='', *,
+                       allowed=True,
+                       daemon_allowed=True,
+                       daemon=False,
+                       ):
+        import_module("_testinternalcapi")
+        subinterp_code = textwrap.dedent(f"""
+            import test.support
+            import threading
+            def func():
+                print('this should not have run!')
+            t = threading.Thread(target=func, daemon={daemon})
+            {before_start}
+            t.start()
+            """)
+        check_multi_interp_extensions = bool(support.Py_GIL_DISABLED)
+        script = textwrap.dedent(f"""
+            import test.support
+            test.support.run_in_subinterp_with_config(
+                {subinterp_code!r},
+                use_main_obmalloc=True,
+                allow_fork=True,
+                allow_exec=True,
+                allow_threads={allowed},
+                allow_daemon_threads={daemon_allowed},
+                check_multi_interp_extensions={check_multi_interp_extensions},
+                own_gil=False,
+            )
+            """)
+        with test.support.SuppressCrashReport():
+            _, _, err = assert_python_ok("-c", script)
+        return err.decode()
+
+    @cpython_only
+    def test_threads_not_allowed(self):
+        err = self._check_allowed(
+            allowed=False,
+            daemon_allowed=False,
+            daemon=False,
+        )
+        self.assertIn('RuntimeError', err)
+
+    @cpython_only
+    def test_daemon_threads_not_allowed(self):
+        with self.subTest('via Thread()'):
+            err = self._check_allowed(
+                allowed=True,
+                daemon_allowed=False,
+                daemon=True,
+            )
+            self.assertIn('RuntimeError', err)
+
+        with self.subTest('via Thread.daemon setter'):
+            err = self._check_allowed(
+                't.daemon = True',
+                allowed=True,
+                daemon_allowed=False,
+                daemon=False,
+            )
+            self.assertIn('RuntimeError', err)
+
 
 class ThreadingExceptionTests(BaseTestCase):
     # A RuntimeError should be raised if Thread.start() is called
@@ -1368,7 +1759,7 @@ def test_releasing_unacquired_lock(self):
         lock = threading.Lock()
         self.assertRaises(RuntimeError, lock.release)
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @requires_subprocess()
     def test_recursion_limit(self):
         # Issue 9670
@@ -1378,13 +1769,6 @@ def test_recursion_limit(self):
         # for threads
         script = """if True:
             import threading
-            # TODO: RUSTPYTHON
-            # Following lines set the recursion limit to previous default of 512
-            # for the execution of this process. Without this, the test runners
-            # on Github fail. Ideally, at a future point this should be removed.
-            import os, sys
-            if os.getenv("CI"):
-                sys.setrecursionlimit(512)
 
             def recurse():
                 return recurse()
@@ -1489,6 +1873,37 @@ def run():
         self.assertEqual(out, b'')
         self.assertNotIn("Unhandled exception", err.decode())
 
+    def test_print_exception_gh_102056(self):
+        # This used to crash. See gh-102056.
+        script = r"""if True:
+            import time
+            import threading
+            import _thread
+
+            def f():
+                try:
+                    f()
+                except RecursionError:
+                    f()
+
+            def g():
+                try:
+                    raise ValueError()
+                except* ValueError:
+                    f()
+
+            def h():
+                time.sleep(1)
+                _thread.interrupt_main()
+
+            t = threading.Thread(target=h)
+            t.start()
+            g()
+            t.join()
+            """
+
+        assert_python_failure("-c", script)
+
     def test_bare_raise_in_brand_new_thread(self):
         def bare_raise():
             raise
@@ -1526,6 +1941,23 @@ def modify_file():
             t.start()
             t.join()
 
+    def test_dummy_thread_on_interpreter_shutdown(self):
+        # GH-130522: When `threading` held a reference to itself and then a
+        # _DummyThread() object was created, destruction of the dummy thread
+        # would emit an unraisable exception at shutdown, due to a lock being
+        # destroyed.
+        code = """if True:
+        import sys
+        import threading
+
+        threading.x = sys.modules[__name__]
+        x = threading._DummyThread()
+        """
+        rc, out, err = assert_python_ok("-c", code)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, b"")
+        self.assertEqual(err, b"")
+
 
 class ThreadRunFail(threading.Thread):
     def run(self):
@@ -1537,7 +1969,7 @@ def setUp(self):
         restore_default_excepthook(self)
         super().setUp()
 
-    @unittest.skip('TODO: RUSTPYTHON, flaky')
+    @force_not_colorized
     def test_excepthook(self):
         with support.captured_output("stderr") as stderr:
             thread = ThreadRunFail(name="excepthook thread")
@@ -1551,6 +1983,7 @@ def test_excepthook(self):
         self.assertIn('ValueError: run failed', stderr)
 
     @support.cpython_only
+    @force_not_colorized
     def test_excepthook_thread_None(self):
         # threading.excepthook called with thread=None: log the thread
         # identifier in this case.
@@ -1686,32 +2119,51 @@ class PyRLockTests(lock_tests.RLockTests):
 class CRLockTests(lock_tests.RLockTests):
     locktype = staticmethod(threading._CRLock)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
-    def test_different_thread(self):
-        super().test_different_thread()
+    def test_signature(self):  # gh-102029
+        with warnings.catch_warnings(record=True) as warnings_log:
+            threading.RLock()
+        self.assertEqual(warnings_log, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        arg_types = [
+            ((1,), {}),
+            ((), {'a': 1}),
+            ((1, 2), {'a': 1}),
+        ]
+        for args, kwargs in arg_types:
+            with self.subTest(args=args, kwargs=kwargs):
+                with self.assertWarns(DeprecationWarning):
+                    threading.RLock(*args, **kwargs)
+
+        # Subtypes with custom `__init__` are allowed (but, not recommended):
+        class CustomRLock(self.locktype):
+            def __init__(self, a, *, b) -> None:
+                super().__init__()
+
+        with warnings.catch_warnings(record=True) as warnings_log:
+            CustomRLock(1, b=2)
+        self.assertEqual(warnings_log, [])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_release_save_unacquired(self):
-        super().test_release_save_unacquired()
+        return super().test_release_save_unacquired()
+
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    def test_different_thread(self):
+        return super().test_different_thread()
 
 class EventTests(lock_tests.EventTests):
     eventtype = staticmethod(threading.Event)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reset_internal_locks():  # TODO: RUSTPYTHON; remove this when done
-        super().test_reset_internal_locks()
-
 class ConditionAsRLockTests(lock_tests.RLockTests):
     # Condition uses an RLock by default and exports its API.
     locktype = staticmethod(threading.Condition)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    def test_recursion_count(self):
+        self.skipTest("Condition does not expose _recursion_count()")
+
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_different_thread(self):
-        super().test_different_thread()
+        return super().test_different_thread()
 
 class ConditionTests(lock_tests.ConditionTests):
     condtype = staticmethod(threading.Condition)
@@ -1727,8 +2179,6 @@ class BarrierTests(lock_tests.BarrierTests):
 
 
 class MiscTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test__all__(self):
         restore_default_excepthook(self)
 
@@ -1762,7 +2212,8 @@ def check_interrupt_main_noerror(self, signum):
             # Restore original handler
             signal.signal(signum, handler)
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky")
+    @unittest.skip('TODO: RUSTPYTHON; flaky')
+    @requires_gil_enabled("gh-118433: Flaky due to a longstanding bug")
     def test_interrupt_main_subthread(self):
         # Calling start_new_thread with a function that executes interrupt_main
         # should raise KeyboardInterrupt upon completion.
@@ -1821,8 +2272,6 @@ def worker(started, cont, interrupted):
 
 class AtexitTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_atexit_output(self):
         rc, out, err = assert_python_ok("-c", """if True:
             import threading
@@ -1851,8 +2300,6 @@ def test_atexit_called_once(self):
 
         self.assertFalse(err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_atexit_after_shutdown(self):
         # The only way to do this is by registering an atexit within
         # an atexit, which is intended to raise an exception.
diff --git a/Lib/threading.py b/Lib/threading.py
index 811ea94a126..15bf786a6a9 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -3,11 +3,11 @@
 import os as _os
 import sys as _sys
 import _thread
-import functools
+import warnings
 
 from time import monotonic as _time
 from _weakrefset import WeakSet
-from itertools import islice as _islice, count as _count
+from itertools import count as _count
 try:
     from _collections import deque as _deque
 except ImportError:
@@ -28,13 +28,20 @@
            'Event', 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
            'Barrier', 'BrokenBarrierError', 'Timer', 'ThreadError',
            'setprofile', 'settrace', 'local', 'stack_size',
-           'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile']
+           'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile',
+           'setprofile_all_threads','settrace_all_threads']
 
 # Rename some stuff so "from threading import *" is safe
-_start_new_thread = _thread.start_new_thread
+_start_joinable_thread = _thread.start_joinable_thread
+_daemon_threads_allowed = _thread.daemon_threads_allowed
 _allocate_lock = _thread.allocate_lock
-_set_sentinel = _thread._set_sentinel
+_LockType = _thread.LockType
+_thread_shutdown = _thread._shutdown
+_make_thread_handle = _thread._make_thread_handle
+_ThreadHandle = _thread._ThreadHandle
 get_ident = _thread.get_ident
+_get_main_thread_ident = _thread._get_main_thread_ident
+_is_main_interpreter = _thread._is_main_interpreter
 try:
     get_native_id = _thread.get_native_id
     _HAVE_THREAD_NATIVE_ID = True
@@ -49,6 +56,13 @@
 TIMEOUT_MAX = _thread.TIMEOUT_MAX
 del _thread
 
+# get thread-local implementation, either from the thread
+# module, or from the python fallback
+
+try:
+    from _thread import _local as local
+except ImportError:
+    from _threading_local import local
 
 # Support for profile and trace hooks
 
@@ -60,11 +74,20 @@ def setprofile(func):
 
     The func will be passed to sys.setprofile() for each thread, before its
     run() method is called.
-
     """
     global _profile_hook
     _profile_hook = func
 
+def setprofile_all_threads(func):
+    """Set a profile function for all threads started from the threading module
+    and all Python threads that are currently executing.
+
+    The func will be passed to sys.setprofile() for each thread, before its
+    run() method is called.
+    """
+    setprofile(func)
+    _sys._setprofileallthreads(func)
+
 def getprofile():
     """Get the profiler function as set by threading.setprofile()."""
     return _profile_hook
@@ -74,12 +97,10 @@ def settrace(func):
 
     The func will be passed to sys.settrace() for each thread, before its run()
     method is called.
-
     """
     global _trace_hook
     _trace_hook = func
 
-# TODO: RUSTPYTHON
 def settrace_all_threads(func):
     """Set a trace function for all threads started from the threading module
     and all Python threads that are currently executing.
@@ -96,7 +117,7 @@ def gettrace():
 
 # Synchronization classes
 
-Lock = _allocate_lock
+Lock = _LockType
 
 def RLock(*args, **kwargs):
     """Factory function that returns a new reentrant lock.
@@ -107,6 +128,12 @@ def RLock(*args, **kwargs):
     acquired it.
 
     """
+    if args or kwargs:
+        warnings.warn(
+            'Passing arguments to RLock is deprecated and will be removed in 3.15',
+            DeprecationWarning,
+            stacklevel=2,
+        )
     if _CRLock is None:
         return _PyRLock(*args, **kwargs)
     return _CRLock(*args, **kwargs)
@@ -229,6 +256,13 @@ def _release_save(self):
     def _is_owned(self):
         return self._owner == get_ident()
 
+    # Internal method used for reentrancy checks
+
+    def _recursion_count(self):
+        if self._owner != get_ident():
+            return 0
+        return self._count
+
 _PyRLock = _RLock
 
 
@@ -254,18 +288,12 @@ def __init__(self, lock=None):
         # If the lock defines _release_save() and/or _acquire_restore(),
         # these override the default implementations (which just call
         # release() and acquire() on the lock).  Ditto for _is_owned().
-        try:
+        if hasattr(lock, '_release_save'):
             self._release_save = lock._release_save
-        except AttributeError:
-            pass
-        try:
+        if hasattr(lock, '_acquire_restore'):
             self._acquire_restore = lock._acquire_restore
-        except AttributeError:
-            pass
-        try:
+        if hasattr(lock, '_is_owned'):
             self._is_owned = lock._is_owned
-        except AttributeError:
-            pass
         self._waiters = _deque()
 
     def _at_fork_reinit(self):
@@ -308,7 +336,7 @@ def wait(self, timeout=None):
         awakened or timed out, it re-acquires the lock and returns.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof).
 
         When the underlying lock is an RLock, it is not released using its
@@ -436,6 +464,11 @@ def __init__(self, value=1):
         self._cond = Condition(Lock())
         self._value = value
 
+    def __repr__(self):
+        cls = self.__class__
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" value={self._value}>")
+
     def acquire(self, blocking=True, timeout=None):
         """Acquire a semaphore, decrementing the internal counter by one.
 
@@ -494,8 +527,7 @@ def release(self, n=1):
             raise ValueError('n must be one or more')
         with self._cond:
             self._value += n
-            for i in range(n):
-                self._cond.notify()
+            self._cond.notify(n)
 
     def __exit__(self, t, v, tb):
         self.release()
@@ -519,9 +551,14 @@ class BoundedSemaphore(Semaphore):
     """
 
     def __init__(self, value=1):
-        Semaphore.__init__(self, value)
+        super().__init__(value)
         self._initial_value = value
 
+    def __repr__(self):
+        cls = self.__class__
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" value={self._value}/{self._initial_value}>")
+
     def release(self, n=1):
         """Release a semaphore, incrementing the internal counter by one or more.
 
@@ -538,8 +575,7 @@ def release(self, n=1):
             if self._value + n > self._initial_value:
                 raise ValueError("Semaphore released too many times")
             self._value += n
-            for i in range(n):
-                self._cond.notify()
+            self._cond.notify(n)
 
 
 class Event:
@@ -557,8 +593,13 @@ def __init__(self):
         self._cond = Condition(Lock())
         self._flag = False
 
+    def __repr__(self):
+        cls = self.__class__
+        status = 'set' if self._flag else 'unset'
+        return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: {status}>"
+
     def _at_fork_reinit(self):
-        # Private method called by Thread._reset_internal_locks()
+        # Private method called by Thread._after_fork()
         self._cond._at_fork_reinit()
 
     def is_set(self):
@@ -568,7 +609,7 @@ def is_set(self):
     def isSet(self):
         """Return true if and only if the internal flag is true.
 
-        This method is deprecated, use notify_all() instead.
+        This method is deprecated, use is_set() instead.
 
         """
         import warnings
@@ -605,11 +646,12 @@ def wait(self, timeout=None):
         the optional timeout occurs.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof).
 
         This method returns the internal flag on exit, so it will always return
-        True except if a timeout is given and the operation times out.
+        ``True`` except if a timeout is given and the operation times out, when
+        it will return ``False``.
 
         """
         with self._cond:
@@ -648,6 +690,8 @@ def __init__(self, parties, action=None, timeout=None):
         default for all subsequent 'wait()' calls.
 
         """
+        if parties < 1:
+            raise ValueError("parties must be >= 1")
         self._cond = Condition(Lock())
         self._action = action
         self._timeout = timeout
@@ -655,6 +699,13 @@ def __init__(self, parties, action=None, timeout=None):
         self._state = 0  # 0 filling, 1 draining, -1 resetting, -2 broken
         self._count = 0
 
+    def __repr__(self):
+        cls = self.__class__
+        if self.broken:
+            return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: broken>"
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" waiters={self.n_waiting}/{self.parties}>")
+
     def wait(self, timeout=None):
         """Wait for the barrier.
 
@@ -802,25 +853,6 @@ def _newname(name_template):
 _limbo = {}
 _dangling = WeakSet()
 
-# Set of Thread._tstate_lock locks of non-daemon threads used by _shutdown()
-# to wait until all Python thread states get deleted:
-# see Thread._set_tstate_lock().
-_shutdown_locks_lock = _allocate_lock()
-_shutdown_locks = set()
-
-def _maintain_shutdown_locks():
-    """
-    Drop any shutdown locks that don't correspond to running threads anymore.
-
-    Calling this from time to time avoids an ever-growing _shutdown_locks
-    set when Thread objects are not joined explicitly. See bpo-37788.
-
-    This must be called with _shutdown_locks_lock acquired.
-    """
-    # If a lock was released, the corresponding thread has exited
-    to_remove = [lock for lock in _shutdown_locks if not lock.locked()]
-    _shutdown_locks.difference_update(to_remove)
-
 
 # Main class for threads
 
@@ -848,7 +880,7 @@ class is implemented.
         *name* is the thread name. By default, a unique name is constructed of
         the form "Thread-N" where N is a small decimal number.
 
-        *args* is the argument tuple for the target invocation. Defaults to ().
+        *args* is a list or tuple of arguments for the target invocation. Defaults to ().
 
         *kwargs* is a dictionary of keyword arguments for the target
         invocation. Defaults to {}.
@@ -877,15 +909,16 @@ class is implemented.
         self._args = args
         self._kwargs = kwargs
         if daemon is not None:
+            if daemon and not _daemon_threads_allowed():
+                raise RuntimeError('daemon threads are disabled in this (sub)interpreter')
             self._daemonic = daemon
         else:
             self._daemonic = current_thread().daemon
         self._ident = None
         if _HAVE_THREAD_NATIVE_ID:
             self._native_id = None
-        self._tstate_lock = None
+        self._handle = _ThreadHandle()
         self._started = Event()
-        self._is_stopped = False
         self._initialized = True
         # Copy of sys.stderr used by self._invoke_excepthook()
         self._stderr = _sys.stderr
@@ -893,30 +926,26 @@ class is implemented.
         # For debugging and _after_fork()
         _dangling.add(self)
 
-    def _reset_internal_locks(self, is_alive):
-        # private!  Called by _after_fork() to reset our internal locks as
-        # they may be in an invalid state leading to a deadlock or crash.
+    def _after_fork(self, new_ident=None):
+        # Private!  Called by threading._after_fork().
         self._started._at_fork_reinit()
-        if is_alive:
-            # bpo-42350: If the fork happens when the thread is already stopped
-            # (ex: after threading._shutdown() has been called), _tstate_lock
-            # is None. Do nothing in this case.
-            if self._tstate_lock is not None:
-                self._tstate_lock._at_fork_reinit()
-                self._tstate_lock.acquire()
+        if new_ident is not None:
+            # This thread is alive.
+            self._ident = new_ident
+            assert self._handle.ident == new_ident
+            if _HAVE_THREAD_NATIVE_ID:
+                self._set_native_id()
         else:
-            # The thread isn't alive after fork: it doesn't have a tstate
-            # anymore.
-            self._is_stopped = True
-            self._tstate_lock = None
+            # Otherwise, the thread is dead, Jim.  _PyThread_AfterFork()
+            # already marked our handle done.
+            pass
 
     def __repr__(self):
         assert self._initialized, "Thread.__init__() was not called"
         status = "initial"
         if self._started.is_set():
             status = "started"
-        self.is_alive() # easy way to get ._is_stopped set when appropriate
-        if self._is_stopped:
+        if self._handle.is_done():
             status = "stopped"
         if self._daemonic:
             status += " daemon"
@@ -943,12 +972,14 @@ def start(self):
         with _active_limbo_lock:
             _limbo[self] = self
         try:
-            _start_new_thread(self._bootstrap, ())
+            # Start joinable thread
+            _start_joinable_thread(self._bootstrap, handle=self._handle,
+                                   daemon=self.daemon)
         except Exception:
             with _active_limbo_lock:
                 del _limbo[self]
             raise
-        self._started.wait()
+        self._started.wait()  # Will set ident and native_id
 
     def run(self):
         """Method representing the thread's activity.
@@ -994,23 +1025,9 @@ def _set_ident(self):
         def _set_native_id(self):
             self._native_id = get_native_id()
 
-    def _set_tstate_lock(self):
-        """
-        Set a lock object which will be released by the interpreter when
-        the underlying thread state (see pystate.h) gets deleted.
-        """
-        self._tstate_lock = _set_sentinel()
-        self._tstate_lock.acquire()
-
-        if not self.daemon:
-            with _shutdown_locks_lock:
-                _maintain_shutdown_locks()
-                _shutdown_locks.add(self._tstate_lock)
-
     def _bootstrap_inner(self):
         try:
             self._set_ident()
-            self._set_tstate_lock()
             if _HAVE_THREAD_NATIVE_ID:
                 self._set_native_id()
             self._started.set()
@@ -1028,40 +1045,7 @@ def _bootstrap_inner(self):
             except:
                 self._invoke_excepthook(self)
         finally:
-            with _active_limbo_lock:
-                try:
-                    # We don't call self._delete() because it also
-                    # grabs _active_limbo_lock.
-                    del _active[get_ident()]
-                except:
-                    pass
-
-    def _stop(self):
-        # After calling ._stop(), .is_alive() returns False and .join() returns
-        # immediately.  ._tstate_lock must be released before calling ._stop().
-        #
-        # Normal case:  C code at the end of the thread's life
-        # (release_sentinel in _threadmodule.c) releases ._tstate_lock, and
-        # that's detected by our ._wait_for_tstate_lock(), called by .join()
-        # and .is_alive().  Any number of threads _may_ call ._stop()
-        # simultaneously (for example, if multiple threads are blocked in
-        # .join() calls), and they're not serialized.  That's harmless -
-        # they'll just make redundant rebindings of ._is_stopped and
-        # ._tstate_lock.  Obscure:  we rebind ._tstate_lock last so that the
-        # "assert self._is_stopped" in ._wait_for_tstate_lock() always works
-        # (the assert is executed only if ._tstate_lock is None).
-        #
-        # Special case:  _main_thread releases ._tstate_lock via this
-        # module's _shutdown() function.
-        lock = self._tstate_lock
-        if lock is not None:
-            assert not lock.locked()
-        self._is_stopped = True
-        self._tstate_lock = None
-        if not self.daemon:
-            with _shutdown_locks_lock:
-                # Remove our lock and other released locks from _shutdown_locks
-                _maintain_shutdown_locks()
+            self._delete()
 
     def _delete(self):
         "Remove current thread from the dict of currently running threads."
@@ -1080,7 +1064,7 @@ def join(self, timeout=None):
         or until the optional timeout occurs.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof). As join() always returns None, you must call
         is_alive() after join() to decide whether a timeout happened -- if the
         thread is still alive, the join() call timed out.
@@ -1103,39 +1087,12 @@ def join(self, timeout=None):
         if self is current_thread():
             raise RuntimeError("cannot join current thread")
 
-        if timeout is None:
-            self._wait_for_tstate_lock()
-        else:
-            # the behavior of a negative timeout isn't documented, but
-            # historically .join(timeout=x) for x<0 has acted as if timeout=0
-            self._wait_for_tstate_lock(timeout=max(timeout, 0))
-
-    def _wait_for_tstate_lock(self, block=True, timeout=-1):
-        # Issue #18808: wait for the thread state to be gone.
-        # At the end of the thread's life, after all knowledge of the thread
-        # is removed from C data structures, C code releases our _tstate_lock.
-        # This method passes its arguments to _tstate_lock.acquire().
-        # If the lock is acquired, the C code is done, and self._stop() is
-        # called.  That sets ._is_stopped to True, and ._tstate_lock to None.
-        lock = self._tstate_lock
-        if lock is None:
-            # already determined that the C code is done
-            assert self._is_stopped
-            return
+        # the behavior of a negative timeout isn't documented, but
+        # historically .join(timeout=x) for x<0 has acted as if timeout=0
+        if timeout is not None:
+            timeout = max(timeout, 0)
 
-        try:
-            if lock.acquire(block, timeout):
-                lock.release()
-                self._stop()
-        except:
-            if lock.locked():
-                # bpo-45274: lock.acquire() acquired the lock, but the function
-                # was interrupted with an exception before reaching the
-                # lock.release(). It can happen if a signal handler raises an
-                # exception, like CTRL+C which raises KeyboardInterrupt.
-                lock.release()
-                self._stop()
-            raise
+        self._handle.join(timeout)
 
     @property
     def name(self):
@@ -1186,10 +1143,7 @@ def is_alive(self):
 
         """
         assert self._initialized, "Thread.__init__() not called"
-        if self._is_stopped or not self._started.is_set():
-            return False
-        self._wait_for_tstate_lock(False)
-        return not self._is_stopped
+        return self._started.is_set() and not self._handle.is_done()
 
     @property
     def daemon(self):
@@ -1210,6 +1164,8 @@ def daemon(self):
     def daemon(self, daemonic):
         if not self._initialized:
             raise RuntimeError("Thread.__init__() not called")
+        if daemonic and not _daemon_threads_allowed():
+            raise RuntimeError('daemon threads are disabled in this interpreter')
         if self._started.is_set():
             raise RuntimeError("cannot set daemon status of active thread")
         self._daemonic = daemonic
@@ -1396,19 +1352,45 @@ class _MainThread(Thread):
 
     def __init__(self):
         Thread.__init__(self, name="MainThread", daemon=False)
-        self._set_tstate_lock()
         self._started.set()
-        self._set_ident()
+        self._ident = _get_main_thread_ident()
+        self._handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
             _active[self._ident] = self
 
 
+# Helper thread-local instance to detect when a _DummyThread
+# is collected. Not a part of the public API.
+_thread_local_info = local()
+
+
+class _DeleteDummyThreadOnDel:
+    '''
+    Helper class to remove a dummy thread from threading._active on __del__.
+    '''
+
+    def __init__(self, dummy_thread):
+        self._dummy_thread = dummy_thread
+        self._tident = dummy_thread.ident
+        # Put the thread on a thread local variable so that when
+        # the related thread finishes this instance is collected.
+        #
+        # Note: no other references to this instance may be created.
+        # If any client code creates a reference to this instance,
+        # the related _DummyThread will be kept forever!
+        _thread_local_info._track_dummy_thread_ref = self
+
+    def __del__(self, _active_limbo_lock=_active_limbo_lock, _active=_active):
+        with _active_limbo_lock:
+            if _active.get(self._tident) is self._dummy_thread:
+                _active.pop(self._tident, None)
+
+
 # Dummy thread class to represent threads not started here.
-# These aren't garbage collected when they die, nor can they be waited for.
-# If they invoke anything in threading.py that calls current_thread(), they
-# leave an entry in the _active dict forever after.
+# These should be added to `_active` and removed automatically
+# when they die, although they can't be waited for.
 # Their purpose is to return *something* from current_thread().
 # They are marked as daemon threads so we won't wait for them
 # when we exit (conform previous semantics).
@@ -1416,24 +1398,31 @@ def __init__(self):
 class _DummyThread(Thread):
 
     def __init__(self):
-        Thread.__init__(self, name=_newname("Dummy-%d"), daemon=True)
-
+        Thread.__init__(self, name=_newname("Dummy-%d"),
+                        daemon=_daemon_threads_allowed())
         self._started.set()
         self._set_ident()
+        self._handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
             _active[self._ident] = self
-
-    def _stop(self):
-        pass
+        _DeleteDummyThreadOnDel(self)
 
     def is_alive(self):
-        assert not self._is_stopped and self._started.is_set()
-        return True
+        if not self._handle.is_done() and self._started.is_set():
+            return True
+        raise RuntimeError("thread is not alive")
 
     def join(self, timeout=None):
-        assert False, "cannot join a dummy thread"
+        raise RuntimeError("cannot join a dummy thread")
+
+    def _after_fork(self, new_ident=None):
+        if new_ident is not None:
+            self.__class__ = _MainThread
+            self._name = 'MainThread'
+            self._daemonic = False
+        Thread._after_fork(self, new_ident=new_ident)
 
 
 # Global API functions
@@ -1468,6 +1457,8 @@ def active_count():
     enumerate().
 
     """
+    # NOTE: if the logic in here ever changes, update Modules/posixmodule.c
+    # warn_about_fork_with_threads() to match.
     with _active_limbo_lock:
         return len(_active) + len(_limbo)
 
@@ -1514,8 +1505,7 @@ def _register_atexit(func, *arg, **kwargs):
     if _SHUTTING_DOWN:
         raise RuntimeError("can't register atexit after shutdown")
 
-    call = functools.partial(func, *arg, **kwargs)
-    _threading_atexits.append(call)
+    _threading_atexits.append(lambda: func(*arg, **kwargs))
 
 
 from _thread import stack_size
@@ -1530,12 +1520,11 @@ def _shutdown():
     """
     Wait until the Python thread state of all non-daemon threads get deleted.
     """
-    # Obscure:  other threads may be waiting to join _main_thread.  That's
-    # dubious, but some code does it.  We can't wait for C code to release
-    # the main thread's tstate_lock - that won't happen until the interpreter
-    # is nearly dead.  So we release it here.  Note that just calling _stop()
-    # isn't enough:  other threads may already be waiting on _tstate_lock.
-    if _main_thread._is_stopped:
+    # Obscure: other threads may be waiting to join _main_thread.  That's
+    # dubious, but some code does it. We can't wait for it to be marked as done
+    # normally - that won't happen until the interpreter is nearly dead. So
+    # mark it done here.
+    if _main_thread._handle.is_done() and _is_main_interpreter():
         # _shutdown() was already called
         return
 
@@ -1547,39 +1536,11 @@ def _shutdown():
     for atexit_call in reversed(_threading_atexits):
         atexit_call()
 
-    # Main thread
-    if _main_thread.ident == get_ident():
-        tlock = _main_thread._tstate_lock
-        # The main thread isn't finished yet, so its thread state lock can't
-        # have been released.
-        assert tlock is not None
-        assert tlock.locked()
-        tlock.release()
-        _main_thread._stop()
-    else:
-        # bpo-1596321: _shutdown() must be called in the main thread.
-        # If the threading module was not imported by the main thread,
-        # _main_thread is the thread which imported the threading module.
-        # In this case, ignore _main_thread, similar behavior than for threads
-        # spawned by C libraries or using _thread.start_new_thread().
-        pass
-
-    # Join all non-deamon threads
-    while True:
-        with _shutdown_locks_lock:
-            locks = list(_shutdown_locks)
-            _shutdown_locks.clear()
-
-        if not locks:
-            break
-
-        for lock in locks:
-            # mimic Thread.join()
-            lock.acquire()
-            lock.release()
-
-        # new threads can be spawned while we were waiting for the other
-        # threads to complete
+    if _is_main_interpreter():
+        _main_thread._handle._set_done()
+
+    # Wait for all non-daemon threads to exit.
+    _thread_shutdown()
 
 
 def main_thread():
@@ -1588,16 +1549,9 @@ def main_thread():
     In normal conditions, the main thread is the thread from which the
     Python interpreter was started.
     """
+    # XXX Figure this out for subinterpreters.  (See gh-75698.)
     return _main_thread
 
-# get thread-local implementation, either from the thread
-# module, or from the python fallback
-
-try:
-    from _thread import _local as local
-except ImportError:
-    from _threading_local import local
-
 
 def _after_fork():
     """
@@ -1606,7 +1560,6 @@ def _after_fork():
     # Reset _active_limbo_lock, in case we forked while the lock was held
     # by another (non-forked) thread.  http://bugs.python.org/issue874900
     global _active_limbo_lock, _main_thread
-    global _shutdown_locks_lock, _shutdown_locks
     _active_limbo_lock = RLock()
 
     # fork() only copied the current thread; clear references to others.
@@ -1622,10 +1575,6 @@ def _after_fork():
 
     _main_thread = current
 
-    # reset _shutdown() locks: threads re-register their _tstate_lock below
-    _shutdown_locks_lock = _allocate_lock()
-    _shutdown_locks = set()
-
     with _active_limbo_lock:
         # Dangling thread instances must still have their locks reset,
         # because someone may join() them.
@@ -1635,16 +1584,13 @@ def _after_fork():
             # Any lock/condition variable may be currently locked or in an
             # invalid state, so we reinitialize them.
             if thread is current:
-                # There is only one active thread. We reset the ident to
-                # its new value since it can have changed.
-                thread._reset_internal_locks(True)
+                # This is the one and only active thread.
                 ident = get_ident()
-                thread._ident = ident
+                thread._after_fork(new_ident=ident)
                 new_active[ident] = thread
             else:
                 # All the others are already stopped.
-                thread._reset_internal_locks(False)
-                thread._stop()
+                thread._after_fork()
 
         _limbo.clear()
         _active.clear()
diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index e16cbc6d18d..891083f3e6b 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -57,14 +57,14 @@ impl PyAsyncGen {
 
         zelf.ag_hooks_inited.store(true);
 
-        // Get and store finalizer from thread-local storage
-        let finalizer = crate::vm::thread::ASYNC_GEN_FINALIZER.with_borrow(|f| f.as_ref().cloned());
+        // Get and store finalizer from VM
+        let finalizer = vm.async_gen_finalizer.borrow().clone();
         if let Some(finalizer) = finalizer {
             *zelf.ag_finalizer.lock() = Some(finalizer);
         }
 
         // Call firstiter hook
-        let firstiter = crate::vm::thread::ASYNC_GEN_FIRSTITER.with_borrow(|f| f.as_ref().cloned());
+        let firstiter = vm.async_gen_firstiter.borrow().clone();
         if let Some(firstiter) = firstiter {
             let obj: PyObjectRef = zelf.to_owned().into();
             firstiter.call((obj,), vm)?;
diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
index 05f435649ad..7ac5129d805 100644
--- a/crates/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -661,6 +661,11 @@ pub mod module {
     }
 
     fn py_os_after_fork_child(vm: &VirtualMachine) {
+        // Mark all other threads as done before running Python callbacks
+        // See _PyThread_AfterFork behavior
+        #[cfg(feature = "threading")]
+        crate::stdlib::thread::after_fork_child(vm);
+
         let after_forkers_child: Vec<PyObjectRef> = vm.state.after_forkers_child.lock().clone();
         run_at_forkers(after_forkers_child, false, vm);
     }
@@ -670,8 +675,64 @@ pub mod module {
         run_at_forkers(after_forkers_parent, false, vm);
     }
 
+    /// Warn if forking from a multi-threaded process
+    fn warn_if_multi_threaded(name: &str, vm: &VirtualMachine) {
+        // Only check threading if it was already imported
+        // Avoid vm.import() which can execute arbitrary Python code in the fork path
+        let threading = match vm
+            .sys_module
+            .get_attr("modules", vm)
+            .and_then(|m| m.get_item("threading", vm))
+        {
+            Ok(m) => m,
+            Err(_) => return,
+        };
+        let active = threading.get_attr("_active", vm).ok();
+        let limbo = threading.get_attr("_limbo", vm).ok();
+
+        let count_dict = |obj: Option<crate::PyObjectRef>| -> usize {
+            obj.and_then(|o| o.length_opt(vm))
+                .and_then(|r| r.ok())
+                .unwrap_or(0)
+        };
+
+        let num_threads = count_dict(active) + count_dict(limbo);
+        if num_threads > 1 {
+            // Use Python warnings module to ensure filters are applied correctly
+            let Ok(warnings) = vm.import("warnings", 0) else {
+                return;
+            };
+            let Ok(warn_fn) = warnings.get_attr("warn", vm) else {
+                return;
+            };
+
+            let pid = unsafe { libc::getpid() };
+            let msg = format!(
+                "This process (pid={}) is multi-threaded, use of {}() may lead to deadlocks in the child.",
+                pid, name
+            );
+
+            // Call warnings.warn(message, DeprecationWarning, stacklevel=2)
+            // stacklevel=2 to point to the caller of fork()
+            let args = crate::function::FuncArgs::new(
+                vec![
+                    vm.ctx.new_str(msg).into(),
+                    vm.ctx.exceptions.deprecation_warning.as_object().to_owned(),
+                ],
+                crate::function::KwArgs::new(
+                    [("stacklevel".to_owned(), vm.ctx.new_int(2).into())]
+                        .into_iter()
+                        .collect(),
+                ),
+            );
+            let _ = warn_fn.call(args, vm);
+        }
+    }
+
     #[pyfunction]
     fn fork(vm: &VirtualMachine) -> i32 {
+        warn_if_multi_threaded("fork", vm);
+
         let pid: i32;
         py_os_before_fork(vm);
         unsafe {
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 8295da9486d..8a65a926cb2 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -815,6 +815,32 @@ mod sys {
         }
     }
 
+    /// Return a dictionary mapping each thread's identifier to the topmost stack frame
+    /// currently active in that thread at the time the function is called.
+    #[cfg(feature = "threading")]
+    #[pyfunction]
+    fn _current_frames(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        use crate::AsObject;
+        use crate::stdlib::thread::get_all_current_frames;
+
+        let frames = get_all_current_frames(vm);
+        let dict = vm.ctx.new_dict();
+
+        for (thread_id, frame) in frames {
+            let key = vm.ctx.new_int(thread_id);
+            dict.set_item(key.as_object(), frame.into(), vm)?;
+        }
+
+        Ok(dict)
+    }
+
+    /// Stub for non-threading builds - returns empty dict
+    #[cfg(not(feature = "threading"))]
+    #[pyfunction]
+    fn _current_frames(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        Ok(vm.ctx.new_dict())
+    }
+
     #[pyfunction]
     fn gettrace(vm: &VirtualMachine) -> PyObjectRef {
         vm.trace_func.borrow().clone()
@@ -1107,6 +1133,22 @@ mod sys {
         update_use_tracing(vm);
     }
 
+    #[pyfunction]
+    fn _settraceallthreads(tracefunc: PyObjectRef, vm: &VirtualMachine) {
+        let func = (!vm.is_none(&tracefunc)).then(|| tracefunc.clone());
+        *vm.state.global_trace_func.lock() = func;
+        vm.trace_func.replace(tracefunc);
+        update_use_tracing(vm);
+    }
+
+    #[pyfunction]
+    fn _setprofileallthreads(profilefunc: PyObjectRef, vm: &VirtualMachine) {
+        let func = (!vm.is_none(&profilefunc)).then(|| profilefunc.clone());
+        *vm.state.global_profile_func.lock() = func;
+        vm.profile_func.replace(profilefunc);
+        update_use_tracing(vm);
+    }
+
     #[cfg(feature = "threading")]
     #[pyattr]
     fn thread_info(vm: &VirtualMachine) -> PyTupleRef {
@@ -1187,10 +1229,10 @@ mod sys {
         }
 
         if let Some(finalizer) = args.finalizer.into_option() {
-            crate::vm::thread::ASYNC_GEN_FINALIZER.set(finalizer);
+            *vm.async_gen_finalizer.borrow_mut() = finalizer;
         }
         if let Some(firstiter) = args.firstiter.into_option() {
-            crate::vm::thread::ASYNC_GEN_FIRSTITER.set(firstiter);
+            *vm.async_gen_firstiter.borrow_mut() = firstiter;
         }
 
         Ok(())
@@ -1212,12 +1254,8 @@ mod sys {
     #[pyfunction]
     fn get_asyncgen_hooks(vm: &VirtualMachine) -> AsyncgenHooksData {
         AsyncgenHooksData {
-            firstiter: crate::vm::thread::ASYNC_GEN_FIRSTITER
-                .with_borrow(Clone::clone)
-                .to_pyobject(vm),
-            finalizer: crate::vm::thread::ASYNC_GEN_FINALIZER
-                .with_borrow(Clone::clone)
-                .to_pyobject(vm),
+            firstiter: vm.async_gen_firstiter.borrow().clone().to_pyobject(vm),
+            finalizer: vm.async_gen_finalizer.borrow().clone().to_pyobject(vm),
         }
     }
 
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index b7f00537c26..0e14fe0e4d1 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -1,13 +1,16 @@
 //! Implementation of the _thread module
 #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
-pub(crate) use _thread::{RawRMutex, make_module};
+pub(crate) use _thread::{
+    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, after_fork_child,
+    get_all_current_frames, get_ident, init_main_thread_ident, make_module,
+};
 
 #[pymodule]
 pub(crate) mod _thread {
     use crate::{
         AsObject, Py, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyDictRef, PyStr, PyTupleRef, PyType, PyTypeRef},
-        convert::ToPyException,
+        frame::FrameRef,
         function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
         types::{Constructor, GetAttr, Representable, SetAttr},
     };
@@ -19,7 +22,6 @@ pub(crate) mod _thread {
         lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
     };
     use std::thread;
-    use thread_local::ThreadLocal;
 
     // PYTHREAD_NAME: show current thread name
     pub const PYTHREAD_NAME: Option<&str> = {
@@ -110,7 +112,8 @@ pub(crate) mod _thread {
     }
 
     #[pyattr(name = "LockType")]
-    #[pyclass(module = "thread", name = "lock")]
+    #[pyattr(name = "lock")]
+    #[pyclass(module = "_thread", name = "lock")]
     #[derive(PyPayload)]
     struct Lock {
         mu: RawMutex,
@@ -172,10 +175,10 @@ pub(crate) mod _thread {
     }
 
     impl Constructor for Lock {
-        type Args = FuncArgs;
+        type Args = ();
 
-        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-            Err(vm.new_type_error("cannot create '_thread.lock' instances"))
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self { mu: RawMutex::INIT })
         }
     }
 
@@ -188,7 +191,7 @@ pub(crate) mod _thread {
 
     pub type RawRMutex = RawReentrantMutex<RawMutex, RawThreadId>;
     #[pyattr]
-    #[pyclass(module = "thread", name = "RLock")]
+    #[pyclass(module = "_thread", name = "RLock")]
     #[derive(PyPayload)]
     struct RLock {
         mu: RawRMutex,
@@ -201,7 +204,7 @@ pub(crate) mod _thread {
         }
     }
 
-    #[pyclass(with(Representable))]
+    #[pyclass(with(Representable), flags(BASETYPE))]
     impl RLock {
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
@@ -249,9 +252,10 @@ pub(crate) mod _thread {
             }
             self.count.store(0, core::sync::atomic::Ordering::Relaxed);
             let new_mut = RawRMutex::INIT;
-
-            let old_mutex: AtomicCell<&RawRMutex> = AtomicCell::new(&self.mu);
-            old_mutex.swap(&new_mut);
+            unsafe {
+                let old_mutex: &AtomicCell<RawRMutex> = core::mem::transmute(&self.mu);
+                old_mutex.swap(new_mut);
+            }
 
             Ok(())
         }
@@ -283,12 +287,28 @@ pub(crate) mod _thread {
         }
     }
 
+    /// Get thread identity - uses pthread_self() on Unix for fork compatibility
     #[pyfunction]
-    fn get_ident() -> u64 {
-        thread_to_id(&thread::current())
+    pub fn get_ident() -> u64 {
+        current_thread_id()
+    }
+
+    /// Get OS-level thread ID (pthread_self on Unix)
+    /// This is important for fork compatibility - the ID must remain stable after fork
+    #[cfg(unix)]
+    fn current_thread_id() -> u64 {
+        // pthread_self() like CPython for fork compatibility
+        unsafe { libc::pthread_self() as u64 }
     }
 
-    fn thread_to_id(t: &thread::Thread) -> u64 {
+    #[cfg(not(unix))]
+    fn current_thread_id() -> u64 {
+        thread_to_rust_id(&thread::current())
+    }
+
+    /// Convert Rust thread to ID (used for non-unix platforms)
+    #[cfg(not(unix))]
+    fn thread_to_rust_id(t: &thread::Thread) -> u64 {
         use core::hash::{Hash, Hasher};
         struct U64Hash {
             v: Option<u64>,
@@ -304,13 +324,25 @@ pub(crate) mod _thread {
                 self.v.expect("should have written a u64")
             }
         }
-        // TODO: use id.as_u64() once it's stable, until then, ThreadId is just a wrapper
-        // around NonZeroU64, so this should work (?)
         let mut h = U64Hash { v: None };
         t.id().hash(&mut h);
         h.finish()
     }
 
+    /// Get thread ID for a given thread handle (used by start_new_thread)
+    fn thread_to_id(handle: &thread::JoinHandle<()>) -> u64 {
+        #[cfg(unix)]
+        {
+            // On Unix, use pthread ID from the handle
+            use std::os::unix::thread::JoinHandleExt;
+            handle.as_pthread_t() as u64
+        }
+        #[cfg(not(unix))]
+        {
+            thread_to_rust_id(handle.thread())
+        }
+    }
+
     #[pyfunction]
     const fn allocate_lock() -> Lock {
         Lock { mu: RawMutex::INIT }
@@ -343,9 +375,9 @@ pub(crate) mod _thread {
             )
             .map(|handle| {
                 vm.state.thread_count.fetch_add(1);
-                thread_to_id(handle.thread())
+                thread_to_id(&handle)
             })
-            .map_err(|err| err.to_pyexception(vm))
+            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))
     }
 
     fn run_thread(func: ArgCallable, args: FuncArgs, vm: &VirtualMachine) {
@@ -365,9 +397,24 @@ pub(crate) mod _thread {
                 unsafe { lock.mu.unlock() };
             }
         }
+        // Clean up thread-local storage while VM context is still active
+        // This ensures __del__ methods are called properly
+        cleanup_thread_local_data();
+        // Clean up frame tracking
+        crate::vm::thread::cleanup_current_thread_frames(vm);
         vm.state.thread_count.fetch_sub(1);
     }
 
+    /// Clean up thread-local data for the current thread.
+    /// This triggers __del__ on objects stored in thread-local variables.
+    fn cleanup_thread_local_data() {
+        // Take all guards - this will trigger LocalGuard::drop for each,
+        // which removes the thread's dict from each Local instance
+        LOCAL_GUARDS.with(|guards| {
+            guards.borrow_mut().clear();
+        });
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     #[pyfunction]
     fn interrupt_main(signum: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<()> {
@@ -400,6 +447,107 @@ pub(crate) mod _thread {
         vm.state.thread_count.load()
     }
 
+    #[pyfunction]
+    fn daemon_threads_allowed() -> bool {
+        // RustPython always allows daemon threads
+        true
+    }
+
+    // Registry for non-daemon threads that need to be joined at shutdown
+    pub type ShutdownEntry = (
+        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    );
+
+    #[pyfunction]
+    fn _shutdown(vm: &VirtualMachine) {
+        // Wait for all non-daemon threads to finish
+        let current_ident = get_ident();
+
+        loop {
+            // Find a thread that's not finished and not the current thread
+            let handle_to_join = {
+                let mut handles = vm.state.shutdown_handles.lock();
+                // Clean up finished entries
+                handles.retain(|(inner_weak, _): &ShutdownEntry| {
+                    inner_weak.upgrade().map_or(false, |inner| {
+                        let guard = inner.lock();
+                        guard.state != ThreadHandleState::Done && guard.ident != current_ident
+                    })
+                });
+
+                // Find first unfinished handle
+                handles
+                    .iter()
+                    .find_map(|(inner_weak, done_event_weak): &ShutdownEntry| {
+                        let inner = inner_weak.upgrade()?;
+                        let done_event = done_event_weak.upgrade()?;
+                        let guard = inner.lock();
+                        if guard.state != ThreadHandleState::Done && guard.ident != current_ident {
+                            Some((inner.clone(), done_event.clone()))
+                        } else {
+                            None
+                        }
+                    })
+            };
+
+            match handle_to_join {
+                Some((_, done_event)) => {
+                    // Wait for this thread to finish (infinite timeout)
+                    // Only check done flag to avoid lock ordering issues
+                    // (done_event lock vs inner lock)
+                    let (lock, cvar) = &*done_event;
+                    let mut done = lock.lock();
+                    while !*done {
+                        cvar.wait(&mut done);
+                    }
+                }
+                None => break, // No more threads to wait on
+            }
+        }
+    }
+
+    /// Add a non-daemon thread handle to the shutdown registry
+    fn add_to_shutdown_handles(
+        vm: &VirtualMachine,
+        inner: &std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        done_event: &std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    ) {
+        let mut handles = vm.state.shutdown_handles.lock();
+        handles.push((
+            std::sync::Arc::downgrade(inner),
+            std::sync::Arc::downgrade(done_event),
+        ));
+    }
+
+    #[pyfunction]
+    fn _make_thread_handle(ident: u64, vm: &VirtualMachine) -> PyRef<ThreadHandle> {
+        let handle = ThreadHandle::new(vm);
+        {
+            let mut inner = handle.inner.lock();
+            inner.ident = ident;
+            inner.state = ThreadHandleState::Running;
+        }
+        handle.into_ref(&vm.ctx)
+    }
+
+    #[pyfunction]
+    fn _get_main_thread_ident(vm: &VirtualMachine) -> u64 {
+        vm.state.main_thread_ident.load()
+    }
+
+    #[pyfunction]
+    fn _is_main_interpreter() -> bool {
+        // RustPython only has one interpreter
+        true
+    }
+
+    /// Initialize the main thread ident. Should be called once at interpreter startup.
+    pub fn init_main_thread_ident(vm: &VirtualMachine) {
+        let ident = get_ident();
+        vm.state.main_thread_ident.store(ident);
+    }
+
     /// ExceptHookArgs - simple class to hold exception hook arguments
     /// This allows threading.py to import _excepthook and _ExceptHookArgs from _thread
     #[pyattr]
@@ -532,23 +680,92 @@ pub(crate) mod _thread {
         Ok(())
     }
 
+    // Thread-local storage for cleanup guards
+    // When a thread terminates, the guard is dropped, which triggers cleanup
+    thread_local! {
+        static LOCAL_GUARDS: std::cell::RefCell<Vec<LocalGuard>> = const { std::cell::RefCell::new(Vec::new()) };
+    }
+
+    // Guard that removes thread-local data when dropped
+    struct LocalGuard {
+        local: std::sync::Weak<LocalData>,
+        thread_id: std::thread::ThreadId,
+    }
+
+    impl Drop for LocalGuard {
+        fn drop(&mut self) {
+            if let Some(local_data) = self.local.upgrade() {
+                // Remove from map while holding the lock, but drop the value
+                // outside the lock to prevent deadlock if __del__ accesses _local
+                let removed = local_data.data.lock().remove(&self.thread_id);
+                drop(removed);
+            }
+        }
+    }
+
+    // Shared data structure for Local
+    struct LocalData {
+        data: parking_lot::Mutex<std::collections::HashMap<std::thread::ThreadId, PyDictRef>>,
+    }
+
+    impl std::fmt::Debug for LocalData {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("LocalData").finish_non_exhaustive()
+        }
+    }
+
     #[pyattr]
-    #[pyclass(module = "thread", name = "_local")]
+    #[pyclass(module = "_thread", name = "_local")]
     #[derive(Debug, PyPayload)]
     struct Local {
-        data: ThreadLocal<PyDictRef>,
+        inner: std::sync::Arc<LocalData>,
     }
 
     #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))]
     impl Local {
         fn l_dict(&self, vm: &VirtualMachine) -> PyDictRef {
-            self.data.get_or(|| vm.ctx.new_dict()).clone()
+            let thread_id = std::thread::current().id();
+
+            // Fast path: check if dict exists under lock
+            if let Some(dict) = self.inner.data.lock().get(&thread_id).cloned() {
+                return dict;
+            }
+
+            // Slow path: allocate dict outside lock to reduce lock hold time
+            let new_dict = vm.ctx.new_dict();
+
+            // Insert with double-check to handle races
+            let mut data = self.inner.data.lock();
+            use std::collections::hash_map::Entry;
+            let (dict, need_guard) = match data.entry(thread_id) {
+                Entry::Occupied(e) => (e.get().clone(), false),
+                Entry::Vacant(e) => {
+                    e.insert(new_dict.clone());
+                    (new_dict, true)
+                }
+            };
+            drop(data); // Release lock before TLS access
+
+            // Register cleanup guard only if we inserted a new entry
+            if need_guard {
+                let guard = LocalGuard {
+                    local: std::sync::Arc::downgrade(&self.inner),
+                    thread_id,
+                };
+                LOCAL_GUARDS.with(|guards| {
+                    guards.borrow_mut().push(guard);
+                });
+            }
+
+            dict
         }
 
         #[pyslot]
         fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Self {
-                data: ThreadLocal::new(),
+                inner: std::sync::Arc::new(LocalData {
+                    data: parking_lot::Mutex::new(std::collections::HashMap::new()),
+                }),
             }
             .into_ref_with_type(vm, cls)
             .map(Into::into)
@@ -597,4 +814,354 @@ pub(crate) mod _thread {
             }
         }
     }
+
+    // Registry of all ThreadHandles for fork cleanup
+    // Stores weak references so handles can be garbage collected normally
+    pub type HandleEntry = (
+        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    );
+
+    // Re-export type from vm::thread for PyGlobalState
+    pub use crate::vm::thread::CurrentFrameSlot;
+
+    /// Get all threads' current frames. Used by sys._current_frames().
+    pub fn get_all_current_frames(vm: &VirtualMachine) -> Vec<(u64, FrameRef)> {
+        let registry = vm.state.thread_frames.lock();
+        registry
+            .iter()
+            .filter_map(|(id, slot)| slot.lock().clone().map(|f| (*id, f)))
+            .collect()
+    }
+
+    /// Called after fork() in child process to mark all other threads as done.
+    /// This prevents join() from hanging on threads that don't exist in the child.
+    pub fn after_fork_child(vm: &VirtualMachine) {
+        let current_ident = get_ident();
+
+        // Update main thread ident - after fork, the current thread becomes the main thread
+        vm.state.main_thread_ident.store(current_ident);
+
+        // Reinitialize frame slot for current thread
+        crate::vm::thread::reinit_frame_slot_after_fork(vm);
+
+        // Clean up thread handles if we can acquire the lock.
+        // Use try_lock because the mutex might have been held during fork.
+        // If we can't acquire it, just skip - the child process will work
+        // correctly with new handles it creates.
+        if let Some(mut handles) = vm.state.thread_handles.try_lock() {
+            // Clean up dead weak refs and mark non-current threads as done
+            handles.retain(|(inner_weak, done_event_weak): &HandleEntry| {
+                let Some(inner) = inner_weak.upgrade() else {
+                    return false; // Remove dead entries
+                };
+                let Some(done_event) = done_event_weak.upgrade() else {
+                    return false;
+                };
+
+                // Try to lock the inner state - skip if we can't
+                let Some(mut inner_guard) = inner.try_lock() else {
+                    return false;
+                };
+
+                // Skip current thread and not-started threads
+                if inner_guard.ident == current_ident {
+                    return true;
+                }
+                if inner_guard.state == ThreadHandleState::NotStarted {
+                    return true;
+                }
+
+                // Mark as done and notify waiters
+                inner_guard.state = ThreadHandleState::Done;
+                inner_guard.join_handle = None; // Can't join OS thread from child
+                drop(inner_guard);
+
+                // Try to notify waiters - skip if we can't acquire the lock
+                let (lock, cvar) = &*done_event;
+                if let Some(mut done) = lock.try_lock() {
+                    *done = true;
+                    cvar.notify_all();
+                }
+
+                true
+            });
+        }
+    }
+
+    // Thread handle state enum
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub enum ThreadHandleState {
+        NotStarted,
+        Starting,
+        Running,
+        Done,
+    }
+
+    // Internal shared state for thread handle
+    pub struct ThreadHandleInner {
+        pub state: ThreadHandleState,
+        pub ident: u64,
+        pub join_handle: Option<thread::JoinHandle<()>>,
+        pub joining: bool, // True if a thread is currently joining
+        pub joined: bool,  // Track if join has completed
+    }
+
+    impl fmt::Debug for ThreadHandleInner {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("ThreadHandleInner")
+                .field("state", &self.state)
+                .field("ident", &self.ident)
+                .field("join_handle", &self.join_handle.is_some())
+                .field("joining", &self.joining)
+                .field("joined", &self.joined)
+                .finish()
+        }
+    }
+
+    /// _ThreadHandle - handle for joinable threads
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "_ThreadHandle")]
+    #[derive(Debug, PyPayload)]
+    struct ThreadHandle {
+        inner: std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        // Event to signal thread completion (for timed join support)
+        done_event: std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    }
+
+    #[pyclass]
+    impl ThreadHandle {
+        fn new(vm: &VirtualMachine) -> Self {
+            let inner = std::sync::Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
+                state: ThreadHandleState::NotStarted,
+                ident: 0,
+                join_handle: None,
+                joining: false,
+                joined: false,
+            }));
+            let done_event =
+                std::sync::Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+
+            // Register in global registry for fork cleanup
+            vm.state.thread_handles.lock().push((
+                std::sync::Arc::downgrade(&inner),
+                std::sync::Arc::downgrade(&done_event),
+            ));
+
+            Self { inner, done_event }
+        }
+
+        #[pygetset]
+        fn ident(&self) -> u64 {
+            self.inner.lock().ident
+        }
+
+        #[pymethod]
+        fn is_done(&self) -> bool {
+            self.inner.lock().state == ThreadHandleState::Done
+        }
+
+        #[pymethod]
+        fn _set_done(&self) {
+            self.inner.lock().state = ThreadHandleState::Done;
+            // Signal waiting threads that this thread is done
+            let (lock, cvar) = &*self.done_event;
+            *lock.lock() = true;
+            cvar.notify_all();
+        }
+
+        #[pymethod]
+        fn join(
+            &self,
+            timeout: OptionalArg<Option<Either<f64, i64>>>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Convert timeout to Duration (None or negative = infinite wait)
+            let timeout_duration = match timeout.flatten() {
+                Some(Either::A(t)) if t >= 0.0 => Some(Duration::from_secs_f64(t)),
+                Some(Either::B(t)) if t >= 0 => Some(Duration::from_secs(t as u64)),
+                _ => None,
+            };
+
+            // Check for self-join first
+            {
+                let inner = self.inner.lock();
+                let current_ident = get_ident();
+                if inner.ident == current_ident && inner.state == ThreadHandleState::Running {
+                    return Err(vm.new_runtime_error("cannot join current thread".to_owned()));
+                }
+            }
+
+            // Wait for thread completion using Condvar (supports timeout)
+            // Loop to handle spurious wakeups
+            let (lock, cvar) = &*self.done_event;
+            let mut done = lock.lock();
+
+            while !*done {
+                if let Some(timeout) = timeout_duration {
+                    let result = cvar.wait_for(&mut done, timeout);
+                    if result.timed_out() && !*done {
+                        // Timeout occurred and done is still false
+                        return Ok(());
+                    }
+                } else {
+                    // Infinite wait
+                    cvar.wait(&mut done);
+                }
+            }
+            drop(done);
+
+            // Thread is done, now perform cleanup
+            let join_handle = {
+                let mut inner = self.inner.lock();
+
+                // If already joined, return immediately (idempotent)
+                if inner.joined {
+                    return Ok(());
+                }
+
+                // If another thread is already joining, wait for them to finish
+                if inner.joining {
+                    drop(inner);
+                    // Wait on done_event
+                    let (lock, cvar) = &*self.done_event;
+                    let mut done = lock.lock();
+                    while !*done {
+                        cvar.wait(&mut done);
+                    }
+                    return Ok(());
+                }
+
+                // Mark that we're joining
+                inner.joining = true;
+
+                // Take the join handle if available
+                inner.join_handle.take()
+            };
+
+            // Perform the actual join outside the lock
+            if let Some(handle) = join_handle {
+                // Ignore the result - panics in spawned threads are already handled
+                let _ = handle.join();
+            }
+
+            // Mark as joined and clear joining flag
+            {
+                let mut inner = self.inner.lock();
+                inner.joined = true;
+                inner.joining = false;
+            }
+
+            Ok(())
+        }
+
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            ThreadHandle::new(vm)
+                .into_ref_with_type(vm, cls)
+                .map(Into::into)
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct StartJoinableThreadArgs {
+        #[pyarg(positional)]
+        function: ArgCallable,
+        #[pyarg(any, optional)]
+        handle: OptionalArg<PyRef<ThreadHandle>>,
+        #[pyarg(any, default = true)]
+        daemon: bool,
+    }
+
+    #[pyfunction]
+    fn start_joinable_thread(
+        args: StartJoinableThreadArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<ThreadHandle>> {
+        let handle = match args.handle {
+            OptionalArg::Present(h) => h,
+            OptionalArg::Missing => ThreadHandle::new(vm).into_ref(&vm.ctx),
+        };
+
+        // Mark as starting
+        handle.inner.lock().state = ThreadHandleState::Starting;
+
+        // Add non-daemon threads to shutdown registry so _shutdown() will wait for them
+        if !args.daemon {
+            add_to_shutdown_handles(vm, &handle.inner, &handle.done_event);
+        }
+
+        let func = args.function;
+        let handle_clone = handle.clone();
+        let inner_clone = handle.inner.clone();
+        let done_event_clone = handle.done_event.clone();
+
+        let mut thread_builder = thread::Builder::new();
+        let stacksize = vm.state.stacksize.load();
+        if stacksize != 0 {
+            thread_builder = thread_builder.stack_size(stacksize);
+        }
+
+        let join_handle = thread_builder
+            .spawn(vm.new_thread().make_spawn_func(move |vm| {
+                // Set ident and mark as running
+                {
+                    let mut inner = inner_clone.lock();
+                    inner.ident = get_ident();
+                    inner.state = ThreadHandleState::Running;
+                }
+
+                // Ensure cleanup happens even if the function panics
+                let inner_for_cleanup = inner_clone.clone();
+                let done_event_for_cleanup = done_event_clone.clone();
+                let vm_state = vm.state.clone();
+                scopeguard::defer! {
+                    // Mark as done
+                    inner_for_cleanup.lock().state = ThreadHandleState::Done;
+
+                    // Signal waiting threads that this thread is done
+                    {
+                        let (lock, cvar) = &*done_event_for_cleanup;
+                        *lock.lock() = true;
+                        cvar.notify_all();
+                    }
+
+                    // Handle sentinels
+                    for lock in SENTINELS.take() {
+                        if lock.mu.is_locked() {
+                            unsafe { lock.mu.unlock() };
+                        }
+                    }
+
+                    // Clean up thread-local data while VM context is still active
+                    cleanup_thread_local_data();
+
+                    // Clean up frame tracking
+                    crate::vm::thread::cleanup_current_thread_frames(vm);
+
+                    vm_state.thread_count.fetch_sub(1);
+                }
+
+                // Run the function
+                match func.invoke((), vm) {
+                    Ok(_) => {}
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.system_exit) => {}
+                    Err(exc) => {
+                        vm.run_unraisable(
+                            exc,
+                            Some("Exception ignored in thread started by".to_owned()),
+                            func.into(),
+                        );
+                    }
+                }
+            }))
+            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))?;
+
+        vm.state.thread_count.fetch_add(1);
+
+        // Store the join handle
+        handle.inner.lock().join_handle = Some(join_handle);
+
+        Ok(handle_clone)
+    }
 }
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index 8d37ad6c840..6faef040a0e 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -110,9 +110,10 @@ impl Interpreter {
 
     /// Finalize vm and turns an exception to exit code.
     ///
-    /// Finalization steps including 4 steps:
+    /// Finalization steps including 5 steps:
     /// 1. Flush stdout and stderr.
     /// 1. Handle exit exception and turn it to exit code.
+    /// 1. Wait for non-daemon threads (threading._shutdown).
     /// 1. Run atexit exit functions.
     /// 1. Mark vm as finalized.
     ///
@@ -128,6 +129,9 @@ impl Interpreter {
                 0
             };
 
+            // Wait for non-daemon threads (wait_for_thread_shutdown)
+            wait_for_thread_shutdown(vm);
+
             atexit::_run_exitfuncs(vm);
 
             vm.state.finalizing.store(true, Ordering::Release);
@@ -139,6 +143,35 @@ impl Interpreter {
     }
 }
 
+/// Wait until threading._shutdown completes, provided
+/// the threading module was imported in the first place.
+/// The shutdown routine will wait until all non-daemon
+/// "threading" threads have completed.
+fn wait_for_thread_shutdown(vm: &VirtualMachine) {
+    // Try to get the threading module if it was already imported
+    // Use sys.modules.get("threading") like PyImport_GetModule
+    let threading = match (|| -> PyResult<_> {
+        let sys_modules = vm.sys_module.get_attr("modules", vm)?;
+        let threading = sys_modules.get_item("threading", vm)?;
+        Ok(threading)
+    })() {
+        Ok(module) => module,
+        Err(_) => {
+            // threading not imported, nothing to do
+            return;
+        }
+    };
+
+    // Call threading._shutdown()
+    if let Err(e) = vm.call_method(&threading, "_shutdown", ()) {
+        vm.run_unraisable(
+            e,
+            Some("Exception ignored on threading shutdown".to_owned()),
+            threading,
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index d2172a43a00..7708b5a9176 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -82,6 +82,10 @@ pub struct VirtualMachine {
     pub state: PyRc<PyGlobalState>,
     pub initialized: bool,
     recursion_depth: Cell<usize>,
+    /// Async generator firstiter hook (per-thread, set via sys.set_asyncgen_hooks)
+    pub async_gen_firstiter: RefCell<Option<PyObjectRef>>,
+    /// Async generator finalizer hook (per-thread, set via sys.set_asyncgen_hooks)
+    pub async_gen_finalizer: RefCell<Option<PyObjectRef>>,
 }
 
 #[derive(Debug, Default)]
@@ -107,6 +111,22 @@ pub struct PyGlobalState {
     pub after_forkers_parent: PyMutex<Vec<PyObjectRef>>,
     pub int_max_str_digits: AtomicCell<usize>,
     pub switch_interval: AtomicCell<f64>,
+    /// Global trace function for all threads (set by sys._settraceallthreads)
+    pub global_trace_func: PyMutex<Option<PyObjectRef>>,
+    /// Global profile function for all threads (set by sys._setprofileallthreads)
+    pub global_profile_func: PyMutex<Option<PyObjectRef>>,
+    /// Main thread identifier (pthread_self on Unix)
+    #[cfg(feature = "threading")]
+    pub main_thread_ident: AtomicCell<u64>,
+    /// Registry of all threads' current frames for sys._current_frames()
+    #[cfg(feature = "threading")]
+    pub thread_frames: parking_lot::Mutex<HashMap<u64, stdlib::thread::CurrentFrameSlot>>,
+    /// Registry of all ThreadHandles for fork cleanup
+    #[cfg(feature = "threading")]
+    pub thread_handles: parking_lot::Mutex<Vec<stdlib::thread::HandleEntry>>,
+    /// Registry for non-daemon threads that need to be joined at shutdown
+    #[cfg(feature = "threading")]
+    pub shutdown_handles: parking_lot::Mutex<Vec<stdlib::thread::ShutdownEntry>>,
 }
 
 pub fn process_hash_secret_seed() -> u32 {
@@ -191,9 +211,21 @@ impl VirtualMachine {
                 after_forkers_parent: PyMutex::default(),
                 int_max_str_digits,
                 switch_interval: AtomicCell::new(0.005),
+                global_trace_func: PyMutex::default(),
+                global_profile_func: PyMutex::default(),
+                #[cfg(feature = "threading")]
+                main_thread_ident: AtomicCell::new(0),
+                #[cfg(feature = "threading")]
+                thread_frames: parking_lot::Mutex::new(HashMap::new()),
+                #[cfg(feature = "threading")]
+                thread_handles: parking_lot::Mutex::new(Vec::new()),
+                #[cfg(feature = "threading")]
+                shutdown_handles: parking_lot::Mutex::new(Vec::new()),
             }),
             initialized: false,
             recursion_depth: Cell::new(0),
+            async_gen_firstiter: RefCell::new(None),
+            async_gen_finalizer: RefCell::new(None),
         };
 
         if vm.state.hash_secret.hash_str("")
@@ -299,6 +331,10 @@ impl VirtualMachine {
             panic!("Double Initialize Error");
         }
 
+        // Initialize main thread ident before any threading operations
+        #[cfg(feature = "threading")]
+        stdlib::thread::init_main_thread_ident(self);
+
         stdlib::builtins::init_module(self, &self.builtins);
         stdlib::sys::init_module(self, &self.sys_module, &self.builtins);
 
@@ -604,6 +640,9 @@ impl VirtualMachine {
     ) -> PyResult<R> {
         self.with_recursion("", || {
             self.frames.borrow_mut().push(frame.clone());
+            // Update the current frame slot for sys._current_frames()
+            #[cfg(feature = "threading")]
+            crate::vm::thread::update_current_frame(Some(frame.clone()));
             // Push a new exception context for frame isolation
             // Each frame starts with no active exception (None)
             // This prevents exceptions from leaking between function calls
@@ -613,6 +652,9 @@ impl VirtualMachine {
             self.pop_exception();
             // defer dec frame
             let _popped = self.frames.borrow_mut().pop();
+            // Update the frame slot to the new top frame (or None if empty)
+            #[cfg(feature = "threading")]
+            crate::vm::thread::update_current_frame(self.frames.borrow().last().cloned());
             result
         })
     }
diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs
index 7e8f0f87e56..7188aa6d270 100644
--- a/crates/vm/src/vm/thread.rs
+++ b/crates/vm/src/vm/thread.rs
@@ -1,17 +1,27 @@
-use crate::{AsObject, PyObject, PyObjectRef, VirtualMachine};
+#[cfg(feature = "threading")]
+use crate::frame::FrameRef;
+use crate::{AsObject, PyObject, VirtualMachine};
 use core::{
     cell::{Cell, RefCell},
     ptr::NonNull,
 };
 use itertools::Itertools;
+#[cfg(feature = "threading")]
+use std::sync::Arc;
 use std::thread_local;
 
+/// Type for current frame slot - shared between threads for sys._current_frames()
+#[cfg(feature = "threading")]
+pub type CurrentFrameSlot = Arc<parking_lot::Mutex<Option<FrameRef>>>;
+
 thread_local! {
     pub(super) static VM_STACK: RefCell<Vec<NonNull<VirtualMachine>>> = Vec::with_capacity(1).into();
 
     pub(crate) static COROUTINE_ORIGIN_TRACKING_DEPTH: Cell<u32> = const { Cell::new(0) };
-    pub(crate) static ASYNC_GEN_FINALIZER: RefCell<Option<PyObjectRef>> = const { RefCell::new(None) };
-    pub(crate) static ASYNC_GEN_FIRSTITER: RefCell<Option<PyObjectRef>> = const { RefCell::new(None) };
+
+    /// Current thread's frame slot for sys._current_frames()
+    #[cfg(feature = "threading")]
+    static CURRENT_FRAME_SLOT: RefCell<Option<CurrentFrameSlot>> = const { RefCell::new(None) };
 }
 
 scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);
@@ -26,11 +36,74 @@ pub fn with_current_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {
 pub fn enter_vm<R>(vm: &VirtualMachine, f: impl FnOnce() -> R) -> R {
     VM_STACK.with(|vms| {
         vms.borrow_mut().push(vm.into());
+
+        // Initialize frame slot for this thread if not already done
+        #[cfg(feature = "threading")]
+        init_frame_slot_if_needed(vm);
+
         scopeguard::defer! { vms.borrow_mut().pop(); }
         VM_CURRENT.set(vm, f)
     })
 }
 
+/// Initialize frame slot for current thread if not already initialized.
+/// Called automatically by enter_vm().
+#[cfg(feature = "threading")]
+fn init_frame_slot_if_needed(vm: &VirtualMachine) {
+    CURRENT_FRAME_SLOT.with(|slot| {
+        if slot.borrow().is_none() {
+            let thread_id = crate::stdlib::thread::get_ident();
+            let new_slot = Arc::new(parking_lot::Mutex::new(None));
+            vm.state
+                .thread_frames
+                .lock()
+                .insert(thread_id, new_slot.clone());
+            *slot.borrow_mut() = Some(new_slot);
+        }
+    });
+}
+
+/// Update the current thread's frame. Called when frames are pushed/popped.
+/// This is a hot path - uses only thread-local storage, no locks.
+#[cfg(feature = "threading")]
+pub fn update_current_frame(frame: Option<FrameRef>) {
+    CURRENT_FRAME_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            *s.lock() = frame;
+        }
+    });
+}
+
+/// Cleanup frame tracking for the current thread. Called at thread exit.
+#[cfg(feature = "threading")]
+pub fn cleanup_current_thread_frames(vm: &VirtualMachine) {
+    let thread_id = crate::stdlib::thread::get_ident();
+    vm.state.thread_frames.lock().remove(&thread_id);
+    CURRENT_FRAME_SLOT.with(|s| {
+        *s.borrow_mut() = None;
+    });
+}
+
+/// Reinitialize frame slot after fork. Called in child process.
+/// Creates a fresh slot and registers it for the current thread.
+#[cfg(feature = "threading")]
+pub fn reinit_frame_slot_after_fork(vm: &VirtualMachine) {
+    let current_ident = crate::stdlib::thread::get_ident();
+    let new_slot = Arc::new(parking_lot::Mutex::new(None));
+
+    // Try to update the global registry. If we can't get the lock
+    // (parent thread might have been holding it during fork), skip.
+    if let Some(mut registry) = vm.state.thread_frames.try_lock() {
+        registry.clear();
+        registry.insert(current_ident, new_slot.clone());
+    }
+
+    // Always update thread-local to point to the new slot
+    CURRENT_FRAME_SLOT.with(|s| {
+        *s.borrow_mut() = Some(new_slot);
+    });
+}
+
 pub fn with_vm<F, R>(obj: &PyObject, f: F) -> Option<R>
 where
     F: Fn(&VirtualMachine) -> R,
@@ -139,6 +212,10 @@ impl VirtualMachine {
     /// specific guaranteed behavior.
     #[cfg(feature = "threading")]
     pub fn new_thread(&self) -> ThreadedVirtualMachine {
+        let global_trace = self.state.global_trace_func.lock().clone();
+        let global_profile = self.state.global_profile_func.lock().clone();
+        let use_tracing = global_trace.is_some() || global_profile.is_some();
+
         let vm = Self {
             builtins: self.builtins.clone(),
             sys_module: self.sys_module.clone(),
@@ -147,9 +224,9 @@ impl VirtualMachine {
             wasm_id: self.wasm_id.clone(),
             exceptions: RefCell::default(),
             import_func: self.import_func.clone(),
-            profile_func: RefCell::new(self.ctx.none()),
-            trace_func: RefCell::new(self.ctx.none()),
-            use_tracing: Cell::new(false),
+            profile_func: RefCell::new(global_profile.unwrap_or_else(|| self.ctx.none())),
+            trace_func: RefCell::new(global_trace.unwrap_or_else(|| self.ctx.none())),
+            use_tracing: Cell::new(use_tracing),
             recursion_limit: self.recursion_limit.clone(),
             signal_handlers: None,
             signal_rx: None,
@@ -157,6 +234,8 @@ impl VirtualMachine {
             state: self.state.clone(),
             initialized: self.initialized,
             recursion_depth: Cell::new(0),
+            async_gen_firstiter: RefCell::new(None),
+            async_gen_finalizer: RefCell::new(None),
         };
         ThreadedVirtualMachine { vm }
     }

From 1bb3439711d1b484f3555ed7adeac7e16ae39207 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 13 Jan 2026 10:42:55 +0900
Subject: [PATCH 276/418] Bump winresource from 0.1.28 to 0.1.29 (#6713)

Bumps [winresource](https://github.com/BenjaminRi/winresource) from 0.1.28 to 0.1.29.
- [Commits](https://github.com/BenjaminRi/winresource/commits)

---
updated-dependencies:
- dependency-name: winresource
  dependency-version: 0.1.29
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f922088ef99..febb66e4f1c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4696,9 +4696,9 @@ checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 
 [[package]]
 name = "winresource"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b021990998587d4438bb672b5c5f034cbc927f51b45e3807ab7323645ef4899"
+checksum = "17cdfa8da4b111045a5e47c7c839e6c5e11c942de1309bc624393ed5d87f89c6"
 dependencies = [
  "toml",
  "version_check",

From 10f14fdedd26ee482a99e6bb4b4476d3155cbce2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 13 Jan 2026 10:43:06 +0900
Subject: [PATCH 277/418] Bump rand_core from 0.9.3 to 0.9.4 (#6714)

Bumps [rand_core](https://github.com/rust-random/rand) from 0.9.3 to 0.9.4.
- [Release notes](https://github.com/rust-random/rand/releases)
- [Changelog](https://github.com/rust-random/rand/blob/master/CHANGELOG.md)
- [Commits](https://github.com/rust-random/rand/commits)

---
updated-dependencies:
- dependency-name: rand_core
  dependency-version: 0.9.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index febb66e4f1c..9d95d017003 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1959,7 +1959,7 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df7151a832e54d2d6b2c827a20e5bcdd80359281cd2c354e725d4b82e7c471de"
 dependencies = [
- "rand_core 0.9.3",
+ "rand_core 0.9.4",
 ]
 
 [[package]]
@@ -2592,7 +2592,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
- "rand_core 0.9.3",
+ "rand_core 0.9.4",
 ]
 
 [[package]]
@@ -2612,7 +2612,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
+ "rand_core 0.9.4",
 ]
 
 [[package]]
@@ -2626,9 +2626,9 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+checksum = "4f1b3bc831f92381018fd9c6350b917c7b21f1eed35a65a51900e0e55a3d7afa"
 dependencies = [
  "getrandom 0.3.4",
 ]
@@ -3187,7 +3187,7 @@ dependencies = [
  "phf 0.13.1",
  "pkcs8",
  "pymath",
- "rand_core 0.9.3",
+ "rand_core 0.9.4",
  "rustix",
  "rustls",
  "rustls-native-certs",

From 7e472128865b7aaba37319325f09862a61cd921e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 13 Jan 2026 17:19:38 +0900
Subject: [PATCH 278/418] Bump flate2 from 1.1.5 to 1.1.8 (#6711)

Bumps [flate2](https://github.com/rust-lang/flate2-rs) from 1.1.5 to 1.1.8.
- [Release notes](https://github.com/rust-lang/flate2-rs/releases)
- [Commits](https://github.com/rust-lang/flate2-rs/compare/1.1.5...1.1.8)

---
updated-dependencies:
- dependency-name: flate2
  dependency-version: 1.1.8
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock               | 6 +++---
 crates/stdlib/Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9d95d017003..d8f6ff79a33 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1234,13 +1234,13 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.1.5"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
+checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"
 dependencies = [
  "crc32fast",
- "libz-rs-sys",
  "miniz_oxide",
+ "zlib-rs",
 ]
 
 [[package]]
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index 4af890b8e69..232022452aa 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -83,7 +83,7 @@ unicode-bidi-mirroring = { workspace = true }
 # compression
 adler32 = "1.2.0"
 crc32fast = "1.3.2"
-flate2 = { version = "<=1.1.5", default-features = false, features = ["zlib-rs"] }
+flate2 = { version = "<=1.1.8", default-features = false, features = ["zlib-rs"] }
 libz-sys = { package = "libz-rs-sys", version = "0.5" }
 bzip2 = "0.6"
 

From 4d7a289971e694fd7aed6aa56e041eed731b955c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 13 Jan 2026 19:02:34 +0900
Subject: [PATCH 279/418] fix lib_update backslash support (#6719)

---
 scripts/lib_updater.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/scripts/lib_updater.py b/scripts/lib_updater.py
index a91c26cb686..4e2f7999ec1 100755
--- a/scripts/lib_updater.py
+++ b/scripts/lib_updater.py
@@ -340,11 +340,14 @@ def build_argparse() -> argparse.ArgumentParser:
 
     # Quick upgrade: auto-fill --from, --to, -o from path
     if args.quick_upgrade is not None:
-        path_str = str(args.quick_upgrade)
+        # Normalize path separators to forward slashes for cross-platform support
+        path_str = str(args.quick_upgrade).replace("\\", "/")
         lib_marker = "/Lib/"
 
         if lib_marker not in path_str:
-            parser.error(f"--quick-upgrade path must contain '/Lib/' (got: {path_str})")
+            parser.error(
+                f"--quick-upgrade path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_upgrade})"
+            )
 
         idx = path_str.index(lib_marker)
         lib_path = pathlib.Path(path_str[idx + 1 :])

From e91bc11b0ae53daebec0beb026353eb68a4ebd2c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 13 Jan 2026 21:27:24 +0900
Subject: [PATCH 280/418] Fix dict race condition (#6720)

---
 crates/vm/src/builtins/dict.rs | 18 ++++++++++++++++++
 crates/vm/src/dict_inner.rs    | 16 ++++++++++++++++
 crates/vm/src/vm/mod.rs        | 29 ++++++++++++++++++++++++++++-
 3 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index 43f7100e963..d1adb8a066d 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -62,6 +62,24 @@ impl PyDict {
         &self.entries
     }
 
+    /// Returns all keys as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn keys_vec(&self) -> Vec<PyObjectRef> {
+        self.entries.keys()
+    }
+
+    /// Returns all values as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn values_vec(&self) -> Vec<PyObjectRef> {
+        self.entries.values()
+    }
+
+    /// Returns all items as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn items_vec(&self) -> Vec<(PyObjectRef, PyObjectRef)> {
+        self.entries.items()
+    }
+
     // Used in update and ior.
     pub(crate) fn merge_object(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         let casted: Result<PyRefExact<Self>, _> = other.downcast_exact(vm);
diff --git a/crates/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
index d57f8be0fe7..1d9fe8403ab 100644
--- a/crates/vm/src/dict_inner.rs
+++ b/crates/vm/src/dict_inner.rs
@@ -553,6 +553,22 @@ impl<T: Clone> Dict<T> {
             .collect()
     }
 
+    pub fn values(&self) -> Vec<T> {
+        self.read()
+            .entries
+            .iter()
+            .filter_map(|v| v.as_ref().map(|v| v.value.clone()))
+            .collect()
+    }
+
+    pub fn items(&self) -> Vec<(PyObjectRef, T)> {
+        self.read()
+            .entries
+            .iter()
+            .filter_map(|v| v.as_ref().map(|v| (v.key.clone(), v.value.clone())))
+            .collect()
+    }
+
     pub fn try_fold_keys<Acc, Fold>(&self, init: Acc, f: Fold) -> PyResult<Acc>
     where
         Fold: FnMut(Acc, &PyObject) -> PyResult<Acc>,
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 7708b5a9176..8233df43a2b 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -20,7 +20,11 @@ use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     builtins::{
         PyBaseExceptionRef, PyDict, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned,
-        PyStrRef, PyTypeRef, code::PyCode, pystr::AsPyStr, tuple::PyTuple,
+        PyStrRef, PyTypeRef,
+        code::PyCode,
+        dict::{PyDictItems, PyDictKeys, PyDictValues},
+        pystr::AsPyStr,
+        tuple::PyTuple,
     },
     codecs::CodecsRegistry,
     common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
@@ -808,6 +812,29 @@ impl VirtualMachine {
         } else if cls.is(self.ctx.types.list_type) {
             list_borrow = value.downcast_ref::<PyList>().unwrap().borrow_vec();
             &list_borrow
+        } else if cls.is(self.ctx.types.dict_keys_type) {
+            // Atomic snapshot of dict keys - prevents race condition during iteration
+            let keys = value.downcast_ref::<PyDictKeys>().unwrap().dict.keys_vec();
+            return keys.into_iter().map(func).collect();
+        } else if cls.is(self.ctx.types.dict_values_type) {
+            // Atomic snapshot of dict values - prevents race condition during iteration
+            let values = value
+                .downcast_ref::<PyDictValues>()
+                .unwrap()
+                .dict
+                .values_vec();
+            return values.into_iter().map(func).collect();
+        } else if cls.is(self.ctx.types.dict_items_type) {
+            // Atomic snapshot of dict items - prevents race condition during iteration
+            let items = value
+                .downcast_ref::<PyDictItems>()
+                .unwrap()
+                .dict
+                .items_vec();
+            return items
+                .into_iter()
+                .map(|(k, v)| func(self.ctx.new_tuple(vec![k, v]).into()))
+                .collect();
         } else {
             return self.map_py_iter(value, func);
         };

From f9e2f9d273e626a28cfa7f5affe44e2487ebc3d5 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 13 Jan 2026 22:05:32 +0900
Subject: [PATCH 281/418] Upgrade math,cmath to 3.14.2 and totally delegate to
 pymath (#6705)

* Upgrade test_math, test_cmath from 3.14.2

* pymath 0.1.5
---
 Cargo.lock                            |    9 +-
 Cargo.toml                            |    3 +-
 Lib/test/mathdata/cmath_testcases.txt |   28 +-
 Lib/test/mathdata/ieee754.txt         |   18 +-
 Lib/test/test_cmath.py                |    4 -
 Lib/test/test_math.py                 |   64 +-
 crates/stdlib/src/cmath.rs            |  169 ++--
 crates/stdlib/src/math.rs             | 1345 ++++++++++++-------------
 crates/vm/src/builtins/float.rs       |    2 +-
 9 files changed, 783 insertions(+), 859 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d8f6ff79a33..79681b880ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2450,11 +2450,16 @@ dependencies = [
 
 [[package]]
 name = "pymath"
-version = "0.0.2"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b66ab66a8610ce209d8b36cd0fecc3a15c494f715e0cb26f0586057f293abc9"
+checksum = "bbfb6723b732fc7f0b29a0ee7150c7f70f947bf467b8c3e82530b13589a78b4c"
 dependencies = [
  "libc",
+ "libm",
+ "malachite-bigint",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index a40744841c5..96e821e977c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -116,6 +116,7 @@ members = [
     ".",
     "crates/*",
 ]
+exclude = ["pymath"]
 
 [workspace.package]
 version = "0.4.0"
@@ -184,7 +185,7 @@ once_cell = "1.20.3"
 parking_lot = "0.12.3"
 paste = "1.0.15"
 proc-macro2 = "1.0.105"
-pymath = "0.0.2"
+pymath = { version = "0.1.5", features = ["mul_add", "malachite-bigint", "complex"] }
 quote = "1.0.43"
 radium = "1.1.1"
 rand = "0.9"
diff --git a/Lib/test/mathdata/cmath_testcases.txt b/Lib/test/mathdata/cmath_testcases.txt
index 0165e17634f..7b98b5a2998 100644
--- a/Lib/test/mathdata/cmath_testcases.txt
+++ b/Lib/test/mathdata/cmath_testcases.txt
@@ -371,9 +371,9 @@ acosh1002 acosh 0.0 inf -> inf 1.5707963267948966
 acosh1003 acosh 2.3 inf -> inf 1.5707963267948966
 acosh1004 acosh -0.0 inf -> inf 1.5707963267948966
 acosh1005 acosh -2.3 inf -> inf 1.5707963267948966
-acosh1006 acosh 0.0 nan -> nan nan
+acosh1006 acosh 0.0 nan -> nan 1.5707963267948966         ignore-imag-sign
 acosh1007 acosh 2.3 nan -> nan nan
-acosh1008 acosh -0.0 nan -> nan nan
+acosh1008 acosh -0.0 nan -> nan 1.5707963267948966        ignore-imag-sign
 acosh1009 acosh -2.3 nan -> nan nan
 acosh1010 acosh -inf 0.0 -> inf 3.1415926535897931
 acosh1011 acosh -inf 2.3 -> inf 3.1415926535897931
@@ -1992,9 +1992,9 @@ tanh0065 tanh 1.797e+308 0.0 -> 1.0 0.0
 
 --special values
 tanh1000 tanh 0.0 0.0 -> 0.0 0.0
-tanh1001 tanh 0.0 inf -> nan nan        invalid
+tanh1001 tanh 0.0 inf -> 0.0 nan        invalid
 tanh1002 tanh 2.3 inf -> nan nan        invalid
-tanh1003 tanh 0.0 nan -> nan nan
+tanh1003 tanh 0.0 nan -> 0.0 nan
 tanh1004 tanh 2.3 nan -> nan nan
 tanh1005 tanh inf 0.0 -> 1.0 0.0
 tanh1006 tanh inf 0.7 -> 1.0 0.0
@@ -2009,7 +2009,7 @@ tanh1014 tanh nan 2.3 -> nan nan
 tanh1015 tanh nan inf -> nan nan
 tanh1016 tanh nan nan -> nan nan
 tanh1017 tanh 0.0 -0.0 -> 0.0 -0.0
-tanh1018 tanh 0.0 -inf -> nan nan       invalid
+tanh1018 tanh 0.0 -inf -> 0.0 nan       invalid
 tanh1019 tanh 2.3 -inf -> nan nan       invalid
 tanh1020 tanh inf -0.0 -> 1.0 -0.0
 tanh1021 tanh inf -0.7 -> 1.0 -0.0
@@ -2022,9 +2022,9 @@ tanh1027 tanh nan -0.0 -> nan -0.0
 tanh1028 tanh nan -2.3 -> nan nan
 tanh1029 tanh nan -inf -> nan nan
 tanh1030 tanh -0.0 -0.0 -> -0.0 -0.0
-tanh1031 tanh -0.0 -inf -> nan nan      invalid
+tanh1031 tanh -0.0 -inf -> -0.0 nan      invalid
 tanh1032 tanh -2.3 -inf -> nan nan      invalid
-tanh1033 tanh -0.0 nan -> nan nan
+tanh1033 tanh -0.0 nan -> -0.0 nan
 tanh1034 tanh -2.3 nan -> nan nan
 tanh1035 tanh -inf -0.0 -> -1.0 -0.0
 tanh1036 tanh -inf -0.7 -> -1.0 -0.0
@@ -2035,7 +2035,7 @@ tanh1040 tanh -inf -3.5 -> -1.0 -0.0
 tanh1041 tanh -inf -inf -> -1.0 0.0     ignore-imag-sign
 tanh1042 tanh -inf nan -> -1.0 0.0      ignore-imag-sign
 tanh1043 tanh -0.0 0.0 -> -0.0 0.0
-tanh1044 tanh -0.0 inf -> nan nan       invalid
+tanh1044 tanh -0.0 inf -> -0.0 nan       invalid
 tanh1045 tanh -2.3 inf -> nan nan       invalid
 tanh1046 tanh -inf 0.0 -> -1.0 0.0
 tanh1047 tanh -inf 0.7 -> -1.0 0.0
@@ -2307,9 +2307,9 @@ tan0066 tan -8.79645943005142 0.0 -> 0.7265425280053614098 0.0
 
 -- special values
 tan1000 tan -0.0 0.0 -> -0.0 0.0
-tan1001 tan -inf 0.0 -> nan nan invalid
+tan1001 tan -inf 0.0 -> nan 0.0 invalid
 tan1002 tan -inf 2.2999999999999998 -> nan nan invalid
-tan1003 tan nan 0.0 -> nan nan
+tan1003 tan nan 0.0 -> nan 0.0
 tan1004 tan nan 2.2999999999999998 -> nan nan
 tan1005 tan -0.0 inf -> -0.0 1.0
 tan1006 tan -0.69999999999999996 inf -> -0.0 1.0
@@ -2324,7 +2324,7 @@ tan1014 tan -2.2999999999999998 nan -> nan nan
 tan1015 tan -inf nan -> nan nan
 tan1016 tan nan nan -> nan nan
 tan1017 tan 0.0 0.0 -> 0.0 0.0
-tan1018 tan inf 0.0 -> nan nan invalid
+tan1018 tan inf 0.0 -> nan 0.0 invalid
 tan1019 tan inf 2.2999999999999998 -> nan nan invalid
 tan1020 tan 0.0 inf -> 0.0 1.0
 tan1021 tan 0.69999999999999996 inf -> 0.0 1.0
@@ -2337,9 +2337,9 @@ tan1027 tan 0.0 nan -> 0.0 nan
 tan1028 tan 2.2999999999999998 nan -> nan nan
 tan1029 tan inf nan -> nan nan
 tan1030 tan 0.0 -0.0 -> 0.0 -0.0
-tan1031 tan inf -0.0 -> nan nan invalid
+tan1031 tan inf -0.0 -> nan -0.0 invalid
 tan1032 tan inf -2.2999999999999998 -> nan nan invalid
-tan1033 tan nan -0.0 -> nan nan
+tan1033 tan nan -0.0 -> nan -0.0
 tan1034 tan nan -2.2999999999999998 -> nan nan
 tan1035 tan 0.0 -inf -> 0.0 -1.0
 tan1036 tan 0.69999999999999996 -inf -> 0.0 -1.0
@@ -2350,7 +2350,7 @@ tan1040 tan 3.5 -inf -> 0.0 -1.0
 tan1041 tan inf -inf -> -0.0 -1.0 ignore-real-sign
 tan1042 tan nan -inf -> -0.0 -1.0 ignore-real-sign
 tan1043 tan -0.0 -0.0 -> -0.0 -0.0
-tan1044 tan -inf -0.0 -> nan nan invalid
+tan1044 tan -inf -0.0 -> nan -0.0 invalid
 tan1045 tan -inf -2.2999999999999998 -> nan nan invalid
 tan1046 tan -0.0 -inf -> -0.0 -1.0
 tan1047 tan -0.69999999999999996 -inf -> -0.0 -1.0
diff --git a/Lib/test/mathdata/ieee754.txt b/Lib/test/mathdata/ieee754.txt
index 3e986cdb102..9be667826a6 100644
--- a/Lib/test/mathdata/ieee754.txt
+++ b/Lib/test/mathdata/ieee754.txt
@@ -116,7 +116,7 @@ inf
 >>> 0 ** -1
 Traceback (most recent call last):
 ...
-ZeroDivisionError: 0.0 cannot be raised to a negative power
+ZeroDivisionError: zero to a negative power
 >>> pow(0, NAN)
 nan
 
@@ -127,31 +127,31 @@ Trigonometric Functions
 >>> sin(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> sin(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> sin(NAN)
 nan
 >>> cos(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> cos(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> cos(NAN)
 nan
 >>> tan(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> tan(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> tan(NAN)
 nan
 
@@ -169,11 +169,11 @@ True
 >>> asin(INF), asin(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a number in range from -1 up to 1, got inf
 >>> acos(INF), acos(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a number in range from -1 up to 1, got inf
 >>> equal(atan(INF), PI/2), equal(atan(NINF), -PI/2)
 (True, True)
 
diff --git a/Lib/test/test_cmath.py b/Lib/test/test_cmath.py
index 44f1b2da638..a96a5780b31 100644
--- a/Lib/test/test_cmath.py
+++ b/Lib/test/test_cmath.py
@@ -276,7 +276,6 @@ def test_cmath_matches_math(self):
                 self.rAssertAlmostEqual(math.log(v, base), z.real)
                 self.assertEqual(0., z.imag)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_IEEE_754
     def test_specific_values(self):
         # Some tests need to be skipped on ancient OS X versions.
@@ -530,13 +529,11 @@ def testTanhSign(self):
     # log1p function; If that system function doesn't respect the sign
     # of zero, then atan and atanh will also have difficulties with
     # the sign of complex zeros.
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_IEEE_754
     def testAtanSign(self):
         for z in complex_zeros:
             self.assertComplexesAreIdentical(cmath.atan(z), z)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_IEEE_754
     def testAtanhSign(self):
         for z in complex_zeros:
@@ -583,7 +580,6 @@ def test_complex_near_zero(self):
         self.assertIsClose(0.001-0.001j, 0.001+0.001j, abs_tol=2e-03)
         self.assertIsNotClose(0.001-0.001j, 0.001+0.001j, abs_tol=1e-03)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_complex_special(self):
         self.assertIsNotClose(INF, INF*1j)
         self.assertIsNotClose(INF*1j, INF)
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index 1a4d257586b..d14336f8bac 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -573,6 +573,8 @@ def testFloor(self):
         #self.assertEqual(math.ceil(NINF), NINF)
         #self.assertTrue(math.isnan(math.floor(NAN)))
 
+        class TestFloorIsNone(float):
+            __floor__ = None
         class TestFloor:
             def __floor__(self):
                 return 42
@@ -588,6 +590,7 @@ class TestBadFloor:
         self.assertEqual(math.floor(FloatLike(41.9)), 41)
         self.assertRaises(TypeError, math.floor, TestNoFloor())
         self.assertRaises(ValueError, math.floor, TestBadFloor())
+        self.assertRaises(TypeError, math.floor, TestFloorIsNone(3.5))
 
         t = TestNoFloor()
         t.__floor__ = lambda *args: args
@@ -1125,6 +1128,15 @@ def __index__(self):
                 with self.assertRaises(TypeError):
                     math.isqrt(value)
 
+    @support.bigmemtest(2**32, memuse=0.85)
+    def test_isqrt_huge(self, size):
+        if size & 1:
+            size += 1
+        v = 1 << size
+        w = math.isqrt(v)
+        self.assertEqual(w.bit_length(), size // 2 + 1)
+        self.assertEqual(w.bit_count(), 1)
+
     def test_lcm(self):
         lcm = math.lcm
         self.assertEqual(lcm(0, 0), 0)
@@ -1272,6 +1284,13 @@ def testLog10(self):
         self.assertEqual(math.log(INF), INF)
         self.assertTrue(math.isnan(math.log10(NAN)))
 
+    @support.bigmemtest(2**32, memuse=0.2)
+    def test_log_huge_integer(self, size):
+        v = 1 << size
+        self.assertAlmostEqual(math.log2(v), size)
+        self.assertAlmostEqual(math.log(v), size * 0.6931471805599453)
+        self.assertAlmostEqual(math.log10(v), size * 0.3010299956639812)
+
     def testSumProd(self):
         sumprod = math.sumprod
         Decimal = decimal.Decimal
@@ -1380,7 +1399,6 @@ def test_sumprod_accuracy(self):
         self.assertEqual(sumprod([True, False] * 10, [0.1] * 20), 1.0)
         self.assertEqual(sumprod([1.0, 10E100, 1.0, -10E100], [1.0]*4), 2.0)
 
-    @unittest.skip("TODO: RUSTPYTHON, Taking a few minutes.")
     @support.requires_resource('cpu')
     def test_sumprod_stress(self):
         sumprod = math.sumprod
@@ -2020,7 +2038,6 @@ def test_exceptions(self):
         else:
             self.fail("sqrt(-1) didn't raise ValueError")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_IEEE_754
     def test_testfile(self):
         # Some tests need to be skipped on ancient OS X versions.
@@ -2495,6 +2512,46 @@ def test_input_exceptions(self):
         self.assertRaises(TypeError, math.atan2, 1.0)
         self.assertRaises(TypeError, math.atan2, 1.0, 2.0, 3.0)
 
+    def test_exception_messages(self):
+        x = -1.1
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a nonnegative input, got {x}"):
+            math.sqrt(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(123, x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x, 123)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log2(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log10(x)
+        x = decimal.Decimal('-1.1')
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x)
+        x = fractions.Fraction(1, 10**400)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {float(x)}"):
+            math.log(x)
+        x = -123
+        with self.assertRaisesRegex(ValueError,
+                                    "expected a positive input$"):
+            math.log(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a noninteger or positive integer, got {x}"):
+            math.gamma(x)
+        x = 1.0
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a number between -1 and 1, got {x}"):
+            math.atanh(x)
+
     # Custom assertions.
 
     def assertIsNaN(self, value):
@@ -2724,6 +2781,9 @@ def test_fma_infinities(self):
         or (sys.platform == "android" and platform.machine() == "x86_64")
         or support.linked_to_musl(),  # gh-131032
         f"this platform doesn't implement IEE 754-2008 properly")
+    # gh-131032: musl is fixed but the fix is not yet released; when the fixed
+    # version is known change this to:
+    #   or support.linked_to_musl() < (1, <m>, <p>)
     def test_fma_zero_result(self):
         nonnegative_finites = [0.0, 1e-300, 2.3, 1e300]
 
diff --git a/crates/stdlib/src/cmath.rs b/crates/stdlib/src/cmath.rs
index 6ce471195cc..e7abb3bcad3 100644
--- a/crates/stdlib/src/cmath.rs
+++ b/crates/stdlib/src/cmath.rs
@@ -1,6 +1,5 @@
-// TODO: Keep track of rust-num/num-complex/issues/2. A common trait could help with duplication
-//       that exists between cmath and math.
 pub(crate) use cmath::make_module;
+
 #[pymodule]
 mod cmath {
     use crate::vm::{
@@ -9,137 +8,141 @@ mod cmath {
     };
     use num_complex::Complex64;
 
+    use crate::math::pymath_exception;
+
     // Constants
-    #[pyattr]
-    use core::f64::consts::{E as e, PI as pi, TAU as tau};
+    #[pyattr(name = "e")]
+    const E: f64 = pymath::cmath::E;
+    #[pyattr(name = "pi")]
+    const PI: f64 = pymath::cmath::PI;
+    #[pyattr(name = "tau")]
+    const TAU: f64 = pymath::cmath::TAU;
     #[pyattr(name = "inf")]
-    const INF: f64 = f64::INFINITY;
+    const INF: f64 = pymath::cmath::INF;
     #[pyattr(name = "nan")]
-    const NAN: f64 = f64::NAN;
+    const NAN: f64 = pymath::cmath::NAN;
     #[pyattr(name = "infj")]
-    const INFJ: Complex64 = Complex64::new(0., f64::INFINITY);
+    const INFJ: Complex64 = pymath::cmath::INFJ;
     #[pyattr(name = "nanj")]
-    const NANJ: Complex64 = Complex64::new(0., f64::NAN);
+    const NANJ: Complex64 = pymath::cmath::NANJ;
 
     #[pyfunction]
-    fn phase(z: ArgIntoComplex) -> f64 {
-        z.into_complex().arg()
+    fn phase(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::cmath::phase(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn polar(x: ArgIntoComplex) -> (f64, f64) {
-        x.into_complex().to_polar()
+    fn polar(x: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
+        pymath::cmath::polar(x.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn rect(r: ArgIntoFloat, phi: ArgIntoFloat) -> Complex64 {
-        Complex64::from_polar(r.into_float(), phi.into_float())
+    fn rect(r: ArgIntoFloat, phi: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::rect(r.into_float(), phi.into_float())
+            .map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn isinf(z: ArgIntoComplex) -> bool {
-        let Complex64 { re, im } = z.into_complex();
-        re.is_infinite() || im.is_infinite()
+        pymath::cmath::isinf(z.into_complex())
     }
 
     #[pyfunction]
     fn isfinite(z: ArgIntoComplex) -> bool {
-        z.into_complex().is_finite()
+        pymath::cmath::isfinite(z.into_complex())
     }
 
     #[pyfunction]
     fn isnan(z: ArgIntoComplex) -> bool {
-        z.into_complex().is_nan()
+        pymath::cmath::isnan(z.into_complex())
     }
 
     #[pyfunction]
     fn exp(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
-        let z = z.into_complex();
-        result_or_overflow(z, z.exp(), vm)
+        pymath::cmath::exp(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn sqrt(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().sqrt()
+    fn sqrt(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sqrt(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn sin(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().sin()
+    fn sin(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sin(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn asin(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().asin()
+    fn asin(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::asin(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn cos(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().cos()
+    fn cos(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::cos(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn acos(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().acos()
+    fn acos(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::acos(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn log(z: ArgIntoComplex, base: OptionalArg<ArgIntoComplex>) -> Complex64 {
-        // TODO: Complex64.log with a negative base yields wrong results.
-        //       Issue is with num_complex::Complex64 implementation of log
-        //       which returns NaN when base is negative.
-        //       log10(z) / log10(base) yields correct results but division
-        //       doesn't handle pos/neg zero nicely. (i.e log(1, 0.5))
-        z.into_complex().log(
-            base.into_option()
-                .map(|base| base.into_complex().re)
-                .unwrap_or(core::f64::consts::E),
+    fn log(
+        z: ArgIntoComplex,
+        base: OptionalArg<ArgIntoComplex>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Complex64> {
+        pymath::cmath::log(
+            z.into_complex(),
+            base.into_option().map(|b| b.into_complex()),
         )
+        .map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn log10(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().log(10.0)
+    fn log10(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::log10(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn acosh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().acosh()
+    fn acosh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::acosh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn atan(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().atan()
+    fn atan(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::atan(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn atanh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().atanh()
+    fn atanh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::atanh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn tan(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().tan()
+    fn tan(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::tan(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn tanh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().tanh()
+    fn tanh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::tanh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn sinh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().sinh()
+    fn sinh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sinh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn cosh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().cosh()
+    fn cosh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::cosh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn asinh(z: ArgIntoComplex) -> Complex64 {
-        z.into_complex().asinh()
+    fn asinh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::asinh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[derive(FromArgs)]
@@ -158,52 +161,10 @@ mod cmath {
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
         let a = args.a.into_complex();
         let b = args.b.into_complex();
-        let rel_tol = args.rel_tol.map_or(1e-09, |v| v.into_float());
-        let abs_tol = args.abs_tol.map_or(0.0, |v| v.into_float());
-
-        if rel_tol < 0.0 || abs_tol < 0.0 {
-            return Err(vm.new_value_error("tolerances must be non-negative"));
-        }
-
-        if a == b {
-            /* short circuit exact equality -- needed to catch two infinities of
-            the same sign. And perhaps speeds things up a bit sometimes.
-            */
-            return Ok(true);
-        }
-
-        /* This catches the case of two infinities of opposite sign, or
-        one infinity and one finite number. Two infinities of opposite
-        sign would otherwise have an infinite relative tolerance.
-        Two infinities of the same sign are caught by the equality check
-        above.
-        */
-        if a.is_infinite() || b.is_infinite() {
-            return Ok(false);
-        }
+        let rel_tol = args.rel_tol.into_option().map(|v| v.into_float());
+        let abs_tol = args.abs_tol.into_option().map(|v| v.into_float());
 
-        let diff = c_abs(b - a);
-
-        Ok(diff <= (rel_tol * c_abs(b)) || (diff <= (rel_tol * c_abs(a))) || diff <= abs_tol)
-    }
-
-    #[inline]
-    fn c_abs(Complex64 { re, im }: Complex64) -> f64 {
-        re.hypot(im)
-    }
-
-    #[inline]
-    fn result_or_overflow(
-        value: Complex64,
-        result: Complex64,
-        vm: &VirtualMachine,
-    ) -> PyResult<Complex64> {
-        if !result.is_finite() && value.is_finite() {
-            // CPython doesn't return `inf` when called with finite
-            // values, it raises OverflowError instead.
-            Err(vm.new_overflow_error("math range error"))
-        } else {
-            Ok(result)
-        }
+        pymath::cmath::isclose(a, b, rel_tol, abs_tol)
+            .map_err(|_| vm.new_value_error("tolerances must be non-negative"))
     }
 }
diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
index fb8945c74f7..1e014e49e24 100644
--- a/crates/stdlib/src/math.rs
+++ b/crates/stdlib/src/math.rs
@@ -1,70 +1,48 @@
 pub(crate) use math::make_module;
 
-use crate::{builtins::PyBaseExceptionRef, vm::VirtualMachine};
+use crate::vm::{VirtualMachine, builtins::PyBaseExceptionRef};
 
 #[pymodule]
 mod math {
     use crate::vm::{
-        PyObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
+        AsObject, PyObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
         builtins::{PyFloat, PyInt, PyIntRef, PyStrInterned, try_bigint_to_f64, try_f64_to_bigint},
         function::{ArgIndex, ArgIntoFloat, ArgIterable, Either, OptionalArg, PosArgs},
         identifier,
     };
-    use core::cmp::Ordering;
-    use itertools::Itertools;
     use malachite_bigint::BigInt;
-    use num_traits::{One, Signed, ToPrimitive, Zero};
-    use rustpython_common::{float_ops, int::true_div};
+    use num_traits::{Signed, ToPrimitive};
+
+    use super::{float_repr, pymath_exception};
 
     // Constants
     #[pyattr]
     use core::f64::consts::{E as e, PI as pi, TAU as tau};
 
-    use super::pymath_error_to_exception;
     #[pyattr(name = "inf")]
     const INF: f64 = f64::INFINITY;
     #[pyattr(name = "nan")]
     const NAN: f64 = f64::NAN;
 
-    // Helper macro:
-    macro_rules! call_math_func {
-        ( $fun:ident, $name:ident, $vm:ident ) => {{
-            let value = $name.into_float();
-            let result = value.$fun();
-            result_or_overflow(value, result, $vm)
-        }};
-    }
-
-    #[inline]
-    fn result_or_overflow(value: f64, result: f64, vm: &VirtualMachine) -> PyResult<f64> {
-        if !result.is_finite() && value.is_finite() {
-            // CPython doesn't return `inf` when called with finite
-            // values, it raises OverflowError instead.
-            Err(vm.new_overflow_error("math range error"))
-        } else {
-            Ok(result)
-        }
-    }
-
     // Number theory functions:
     #[pyfunction]
     fn fabs(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(abs, x, vm)
+        pymath::math::fabs(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn isfinite(x: ArgIntoFloat) -> bool {
-        x.into_float().is_finite()
+        pymath::math::isfinite(x.into_float())
     }
 
     #[pyfunction]
     fn isinf(x: ArgIntoFloat) -> bool {
-        x.into_float().is_infinite()
+        pymath::math::isinf(x.into_float())
     }
 
     #[pyfunction]
     fn isnan(x: ArgIntoFloat) -> bool {
-        x.into_float().is_nan()
+        pymath::math::isnan(x.into_float())
     }
 
     #[derive(FromArgs)]
@@ -83,420 +61,286 @@ mod math {
     fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
         let a = args.a.into_float();
         let b = args.b.into_float();
-        let rel_tol = args.rel_tol.map_or(1e-09, |v| v.into_float());
-        let abs_tol = args.abs_tol.map_or(0.0, |v| v.into_float());
-
-        if rel_tol < 0.0 || abs_tol < 0.0 {
-            return Err(vm.new_value_error("tolerances must be non-negative"));
-        }
-
-        if a == b {
-            /* short circuit exact equality -- needed to catch two infinities of
-               the same sign. And perhaps speeds things up a bit sometimes.
-            */
-            return Ok(true);
-        }
+        let rel_tol = args.rel_tol.into_option().map(|v| v.into_float());
+        let abs_tol = args.abs_tol.into_option().map(|v| v.into_float());
 
-        /* This catches the case of two infinities of opposite sign, or
-           one infinity and one finite number. Two infinities of opposite
-           sign would otherwise have an infinite relative tolerance.
-           Two infinities of the same sign are caught by the equality check
-           above.
-        */
-
-        if a.is_infinite() || b.is_infinite() {
-            return Ok(false);
-        }
-
-        let diff = (b - a).abs();
-
-        Ok((diff <= (rel_tol * b).abs()) || (diff <= (rel_tol * a).abs()) || (diff <= abs_tol))
+        pymath::math::isclose(a, b, rel_tol, abs_tol)
+            .map_err(|_| vm.new_value_error("tolerances must be non-negative"))
     }
 
     #[pyfunction]
-    fn copysign(x: ArgIntoFloat, y: ArgIntoFloat) -> f64 {
-        x.into_float().copysign(y.into_float())
+    fn copysign(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::copysign(x.into_float(), y.into_float())
+            .map_err(|err| pymath_exception(err, vm))
     }
 
     // Power and logarithmic functions:
     #[pyfunction]
     fn exp(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp, x, vm)
+        pymath::math::exp(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn exp2(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp2, x, vm)
+        pymath::math::exp2(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn expm1(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp_m1, x, vm)
+        pymath::math::expm1(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn log(x: PyObjectRef, base: OptionalArg<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let base: f64 = base.map(Into::into).unwrap_or(core::f64::consts::E);
-        if base.is_sign_negative() {
-            return Err(vm.new_value_error("math domain error"));
+        let base = base.into_option().map(|v| v.into_float());
+        // Check base first for proper error messages
+        if let Some(b) = base {
+            if b <= 0.0 {
+                return Err(vm.new_value_error(format!(
+                    "expected a positive input, got {}",
+                    super::float_repr(b)
+                )));
+            }
+            if b == 1.0 {
+                return Err(vm.new_value_error("math domain error".to_owned()));
+            }
+        }
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log_bigint(i.as_bigint(), base).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
         }
-        log2(x, vm).map(|log_x| log_x / base.log2())
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log(val, base).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn log1p(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_nan() || x > -1.0_f64 {
-            Ok(x.ln_1p())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
-    }
-
-    /// Generates the base-2 logarithm of a BigInt `x`
-    fn int_log2(x: &BigInt) -> f64 {
-        // log2(x) = log2(2^n * 2^-n * x) = n + log2(x/2^n)
-        // If we set 2^n to be the greatest power of 2 below x, then x/2^n is in [1, 2), and can
-        // thus be converted into a float.
-        let n = x.bits() as u32 - 1;
-        let frac = true_div(x, &BigInt::from(2).pow(n));
-        f64::from(n) + frac.log2()
+        pymath::math::log1p(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn log2(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
-        match x.try_float(vm) {
-            Ok(x) => {
-                let x = x.to_f64();
-                if x.is_nan() || x > 0.0_f64 {
-                    Ok(x.log2())
-                } else {
-                    Err(vm.new_value_error("math domain error"))
-                }
-            }
-            Err(float_err) => {
-                if let Ok(x) = x.try_int(vm) {
-                    let x = x.as_bigint();
-                    if x.is_positive() {
-                        Ok(int_log2(x))
-                    } else {
-                        Err(vm.new_value_error("math domain error"))
-                    }
-                } else {
-                    // Return the float error, as it will be more intuitive to users
-                    Err(float_err)
-                }
-            }
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log2_bigint(i.as_bigint()).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
         }
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log2(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn log10(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
-        log2(x, vm).map(|log_x| log_x / 10f64.log2())
-    }
-
-    #[pyfunction]
-    fn pow(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        let y = y.into_float();
-
-        if x < 0.0 && x.is_finite() && y.fract() != 0.0 && y.is_finite()
-            || x == 0.0 && y < 0.0 && y != f64::NEG_INFINITY
-        {
-            return Err(vm.new_value_error("math domain error"));
-        }
-
-        let value = x.powf(y);
-
-        if x.is_finite() && y.is_finite() && value.is_infinite() {
-            return Err(vm.new_overflow_error("math range error"));
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log10_bigint(i.as_bigint()).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
         }
-
-        Ok(value)
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log10(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
-    fn sqrt(value: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let value = value.into_float();
-        if value.is_nan() {
-            return Ok(value);
-        }
-        if value.is_sign_negative() {
-            if value.is_zero() {
-                return Ok(-0.0f64);
-            }
-            return Err(vm.new_value_error("math domain error"));
-        }
-        Ok(value.sqrt())
+    fn pow(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::pow(x.into_float(), y.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn isqrt(x: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let x = x.into_int_ref();
-        let value = x.as_bigint();
-
-        if value.is_negative() {
-            return Err(vm.new_value_error("isqrt() argument must be nonnegative"));
-        }
-        Ok(value.sqrt())
+    fn sqrt(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::sqrt(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a nonnegative input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     // Trigonometric functions:
     #[pyfunction]
     fn acos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
-            Ok(x.acos())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
+        let val = x.into_float();
+        pymath::math::acos(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number in range from -1 up to 1, got {}",
+                float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn asin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
-            Ok(x.asin())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
+        let val = x.into_float();
+        pymath::math::asin(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number in range from -1 up to 1, got {}",
+                float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn atan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(atan, x, vm)
+        pymath::math::atan(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn atan2(y: ArgIntoFloat, x: ArgIntoFloat) -> f64 {
-        y.into_float().atan2(x.into())
+    fn atan2(y: ArgIntoFloat, x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::atan2(y.into_float(), x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn cos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        result_or_overflow(x, x.cos(), vm)
+        let val = x.into_float();
+        pymath::math::cos(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn hypot(coordinates: PosArgs<ArgIntoFloat>) -> f64 {
-        let mut coordinates = ArgIntoFloat::vec_into_f64(coordinates.into_vec());
-        let mut max = 0.0;
-        let mut has_nan = false;
-        for f in &mut coordinates {
-            *f = f.abs();
-            if f.is_nan() {
-                has_nan = true;
-            } else if *f > max {
-                max = *f
-            }
-        }
-        // inf takes precedence over nan
-        if max.is_infinite() {
-            return max;
-        }
-        if has_nan {
-            return f64::NAN;
-        }
-        coordinates.sort_unstable_by(|x, y| x.total_cmp(y).reverse());
-        vector_norm(&coordinates)
-    }
-
-    /// Implementation of accurate hypotenuse algorithm from Borges 2019.
-    /// See https://arxiv.org/abs/1904.09481.
-    /// This assumes that its arguments are positive finite and have been scaled to avoid overflow
-    /// and underflow.
-    fn accurate_hypot(max: f64, min: f64) -> f64 {
-        if min <= max * (f64::EPSILON / 2.0).sqrt() {
-            return max;
-        }
-        let hypot = max.mul_add(max, min * min).sqrt();
-        let hypot_sq = hypot * hypot;
-        let max_sq = max * max;
-        let correction = (-min).mul_add(min, hypot_sq - max_sq) + hypot.mul_add(hypot, -hypot_sq)
-            - max.mul_add(max, -max_sq);
-        hypot - correction / (2.0 * hypot)
-    }
-
-    /// Calculates the norm of the vector given by `v`.
-    /// `v` is assumed to be a list of non-negative finite floats, sorted in descending order.
-    fn vector_norm(v: &[f64]) -> f64 {
-        // Drop zeros from the vector.
-        let zero_count = v.iter().rev().cloned().take_while(|x| *x == 0.0).count();
-        let v = &v[..v.len() - zero_count];
-        if v.is_empty() {
-            return 0.0;
-        }
-        if v.len() == 1 {
-            return v[0];
-        }
-        // Calculate scaling to avoid overflow / underflow.
-        let max = *v.first().unwrap();
-        let min = *v.last().unwrap();
-        let scale = if max > (f64::MAX / v.len() as f64).sqrt() {
-            max
-        } else if min < f64::MIN_POSITIVE.sqrt() {
-            // ^ This can be an `else if`, because if the max is near f64::MAX and the min is near
-            // f64::MIN_POSITIVE, then the min is relatively unimportant and will be effectively
-            // ignored.
-            min
-        } else {
-            1.0
-        };
-        let mut norm = v
-            .iter()
-            .copied()
-            .map(|x| x / scale)
-            .reduce(accurate_hypot)
-            .unwrap_or_default();
-        if v.len() > 2 {
-            // For larger lists of numbers, we can accumulate a rounding error, so a correction is
-            // needed, similar to that in `accurate_hypot()`.
-            // First, we estimate [sum of squares - norm^2], then we add the first-order
-            // approximation of the square root of that to `norm`.
-            let correction = v
-                .iter()
-                .copied()
-                .map(|x| (x / scale).powi(2))
-                .chain(core::iter::once(-norm * norm))
-                // Pairwise summation of floats gives less rounding error than a naive sum.
-                .tree_reduce(core::ops::Add::add)
-                .expect("expected at least 1 element");
-            norm = norm + correction / (2.0 * norm);
-        }
-        norm * scale
+        let coords = ArgIntoFloat::vec_into_f64(coordinates.into_vec());
+        pymath::math::hypot(&coords)
     }
 
     #[pyfunction]
     fn dist(p: Vec<ArgIntoFloat>, q: Vec<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let mut max = 0.0;
-        let mut has_nan = false;
-
         let p = ArgIntoFloat::vec_into_f64(p);
         let q = ArgIntoFloat::vec_into_f64(q);
-        let mut diffs = vec![];
-
         if p.len() != q.len() {
             return Err(vm.new_value_error("both points must have the same number of dimensions"));
         }
-
-        for i in 0..p.len() {
-            let px = p[i];
-            let qx = q[i];
-
-            let x = (px - qx).abs();
-            if x.is_nan() {
-                has_nan = true;
-            }
-
-            diffs.push(x);
-            if x > max {
-                max = x;
-            }
-        }
-
-        if max.is_infinite() {
-            return Ok(max);
-        }
-        if has_nan {
-            return Ok(f64::NAN);
-        }
-        diffs.sort_unstable_by(|x, y| x.total_cmp(y).reverse());
-        Ok(vector_norm(&diffs))
+        Ok(pymath::math::dist(&p, &q))
     }
 
     #[pyfunction]
     fn sin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        result_or_overflow(x, x.sin(), vm)
+        let val = x.into_float();
+        pymath::math::sin(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn tan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        result_or_overflow(x, x.tan(), vm)
+        let val = x.into_float();
+        pymath::math::tan(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn degrees(x: ArgIntoFloat) -> f64 {
-        x.into_float() * (180.0 / core::f64::consts::PI)
+        pymath::math::degrees(x.into_float())
     }
 
     #[pyfunction]
     fn radians(x: ArgIntoFloat) -> f64 {
-        x.into_float() * (core::f64::consts::PI / 180.0)
+        pymath::math::radians(x.into_float())
     }
 
     // Hyperbolic functions:
 
     #[pyfunction]
     fn acosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x.is_sign_negative() || x.is_zero() {
-            Err(vm.new_value_error("math domain error"))
-        } else {
-            Ok(x.acosh())
-        }
+        pymath::math::acosh(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn asinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(asinh, x, vm)
+        pymath::math::asinh(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn atanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        if x >= 1.0_f64 || x <= -1.0_f64 {
-            Err(vm.new_value_error("math domain error"))
-        } else {
-            Ok(x.atanh())
-        }
+        let val = x.into_float();
+        pymath::math::atanh(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number between -1 and 1, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn cosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(cosh, x, vm)
+        pymath::math::cosh(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn sinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(sinh, x, vm)
+        pymath::math::sinh(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn tanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(tanh, x, vm)
+        pymath::math::tanh(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     // Special functions:
     #[pyfunction]
-    fn erf(x: ArgIntoFloat) -> f64 {
-        pymath::erf(x.into())
+    fn erf(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::erf(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn erfc(x: ArgIntoFloat) -> f64 {
-        pymath::erfc(x.into())
+    fn erfc(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::erfc(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn gamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::gamma(x.into()).map_err(|err| pymath_error_to_exception(err, vm))
+        let val = x.into_float();
+        pymath::math::gamma(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a noninteger or positive integer, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
     }
 
     #[pyfunction]
     fn lgamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::lgamma(x.into()).map_err(|err| pymath_error_to_exception(err, vm))
+        pymath::math::lgamma(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     fn try_magic_method(
@@ -521,37 +365,43 @@ mod math {
 
     #[pyfunction]
     fn ceil(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let result_or_err = try_magic_method(identifier!(vm, __ceil__), vm, &x);
-        if result_or_err.is_err()
-            && let Some(v) = x.try_float_opt(vm)
-        {
+        // Only call __ceil__ if the class defines it - if it exists but is not callable,
+        // the error should be propagated (not fall back to float conversion)
+        if x.class().has_attr(identifier!(vm, __ceil__)) {
+            return try_magic_method(identifier!(vm, __ceil__), vm, &x);
+        }
+        // __ceil__ not defined - fall back to float conversion
+        if let Some(v) = x.try_float_opt(vm) {
             let v = try_f64_to_bigint(v?.to_f64().ceil(), vm)?;
             return Ok(vm.ctx.new_int(v).into());
         }
-        result_or_err
+        Err(vm.new_type_error(format!(
+            "type '{}' doesn't define '__ceil__' method",
+            x.class().name(),
+        )))
     }
 
     #[pyfunction]
     fn floor(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let result_or_err = try_magic_method(identifier!(vm, __floor__), vm, &x);
-        if result_or_err.is_err()
-            && let Some(v) = x.try_float_opt(vm)
-        {
+        // Only call __floor__ if the class defines it - if it exists but is not callable,
+        // the error should be propagated (not fall back to float conversion)
+        if x.class().has_attr(identifier!(vm, __floor__)) {
+            return try_magic_method(identifier!(vm, __floor__), vm, &x);
+        }
+        // __floor__ not defined - fall back to float conversion
+        if let Some(v) = x.try_float_opt(vm) {
             let v = try_f64_to_bigint(v?.to_f64().floor(), vm)?;
             return Ok(vm.ctx.new_int(v).into());
         }
-        result_or_err
+        Err(vm.new_type_error(format!(
+            "type '{}' doesn't define '__floor__' method",
+            x.class().name(),
+        )))
     }
 
     #[pyfunction]
     fn frexp(x: ArgIntoFloat) -> (f64, i32) {
-        let value: f64 = x.into();
-        if value.is_finite() {
-            let (m, exp) = float_ops::decompose_float(value);
-            (m * value.signum(), exp)
-        } else {
-            (value, 0)
-        }
+        pymath::math::frexp(x.into_float())
     }
 
     #[pyfunction]
@@ -564,315 +414,24 @@ mod math {
             Either::A(f) => f.to_f64(),
             Either::B(z) => try_bigint_to_f64(z.as_bigint(), vm)?,
         };
-
-        if value == 0_f64 || !value.is_finite() {
-            // NaNs, zeros and infinities are returned unchanged
-            return Ok(value);
-        }
-
-        // Using IEEE 754 bit manipulation to handle large exponents correctly.
-        // Direct multiplication would overflow for large i values, especially when computing
-        // the largest finite float (i=1024, x<1.0). By directly modifying the exponent bits,
-        // we avoid intermediate overflow to infinity.
-
-        // Scale subnormals to normal range first, then adjust exponent.
-        let (mant, exp0) = if value.abs() < f64::MIN_POSITIVE {
-            let scaled = value * (1u64 << 54) as f64; // multiply by 2^54
-            let (mant_scaled, exp_scaled) = float_ops::decompose_float(scaled);
-            (mant_scaled, exp_scaled - 54) // adjust exponent back
-        } else {
-            float_ops::decompose_float(value)
-        };
-
-        let i_big = i.as_bigint();
-        let overflow_bound = BigInt::from(1024_i32 - exp0); // i > 1024 - exp0 => overflow
-        if i_big > &overflow_bound {
-            return Err(vm.new_overflow_error("math range error"));
-        }
-        if i_big == &overflow_bound && mant == 1.0 {
-            return Err(vm.new_overflow_error("math range error"));
-        }
-        let underflow_bound = BigInt::from(-1074_i32 - exp0); // i < -1074 - exp0 => 0.0 with sign
-        if i_big < &underflow_bound {
-            return Ok(0.0f64.copysign(value));
-        }
-
-        let i_small: i32 = i_big
-            .to_i32()
-            .expect("exponent within [-1074-exp0, 1024-exp0] must fit in i32");
-        let exp = exp0 + i_small;
-
-        const SIGN_MASK: u64 = 0x8000_0000_0000_0000;
-        const FRAC_MASK: u64 = 0x000F_FFFF_FFFF_FFFF;
-        let sign_bit: u64 = if value.is_sign_negative() {
-            SIGN_MASK
-        } else {
-            0
-        };
-        let mant_bits = mant.to_bits() & FRAC_MASK;
-        if exp >= -1021 {
-            let e_bits = (1022_i32 + exp) as u64;
-            let result_bits = sign_bit | (e_bits << 52) | mant_bits;
-            return Ok(f64::from_bits(result_bits));
-        }
-
-        let full_mant: u64 = (1u64 << 52) | mant_bits;
-        let shift: u32 = (-exp - 1021) as u32;
-        let frac_shifted = full_mant >> shift;
-        let lost_bits = full_mant & ((1u64 << shift) - 1);
-
-        let half = 1u64 << (shift - 1);
-        let frac = if (lost_bits > half) || (lost_bits == half && (frac_shifted & 1) == 1) {
-            frac_shifted + 1
-        } else {
-            frac_shifted
-        };
-
-        let result_bits = if frac >= (1u64 << 52) {
-            sign_bit | (1u64 << 52)
-        } else {
-            sign_bit | frac
-        };
-        Ok(f64::from_bits(result_bits))
-    }
-
-    fn math_perf_arb_len_int_op<F>(args: PosArgs<ArgIndex>, op: F, default: BigInt) -> BigInt
-    where
-        F: Fn(&BigInt, &PyInt) -> BigInt,
-    {
-        let arg_vec = args.into_vec();
-
-        if arg_vec.is_empty() {
-            return default;
-        } else if arg_vec.len() == 1 {
-            return op(arg_vec[0].as_ref().as_bigint(), arg_vec[0].as_ref());
-        }
-
-        let mut res = arg_vec[0].as_ref().as_bigint().clone();
-        for num in &arg_vec[1..] {
-            res = op(&res, num.as_ref())
-        }
-        res
+        pymath::math::ldexp_bigint(value, i.as_bigint()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
-    fn gcd(args: PosArgs<ArgIndex>) -> BigInt {
-        use num_integer::Integer;
-        math_perf_arb_len_int_op(args, |x, y| x.gcd(y.as_bigint()), BigInt::zero())
-    }
-
-    #[pyfunction]
-    fn lcm(args: PosArgs<ArgIndex>) -> BigInt {
-        use num_integer::Integer;
-        math_perf_arb_len_int_op(args, |x, y| x.lcm(y.as_bigint()), BigInt::one())
-    }
-
-    #[pyfunction]
-    fn cbrt(x: ArgIntoFloat) -> f64 {
-        x.into_float().cbrt()
+    fn cbrt(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::cbrt(x.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn fsum(seq: ArgIterable<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let mut partials = Vec::with_capacity(32);
-        let mut special_sum = 0.0;
-        let mut inf_sum = 0.0;
-
-        for obj in seq.iter(vm)? {
-            let mut x = obj?.into_float();
-
-            let xsave = x;
-            let mut i = 0;
-            // This inner loop applies `hi`/`lo` summation to each
-            // partial so that the list of partial sums remains exact.
-            for j in 0..partials.len() {
-                let mut y: f64 = partials[j];
-                if x.abs() < y.abs() {
-                    core::mem::swap(&mut x, &mut y);
-                }
-                // Rounded `x+y` is stored in `hi` with round-off stored in
-                // `lo`. Together `hi+lo` are exactly equal to `x+y`.
-                let hi = x + y;
-                let lo = y - (hi - x);
-                if lo != 0.0 {
-                    partials[i] = lo;
-                    i += 1;
-                }
-                x = hi;
-            }
-
-            partials.truncate(i);
-            if x != 0.0 {
-                if !x.is_finite() {
-                    // a non-finite x could arise either as
-                    // a result of intermediate overflow, or
-                    // as a result of a nan or inf in the
-                    // summands
-                    if xsave.is_finite() {
-                        return Err(vm.new_overflow_error("intermediate overflow in fsum"));
-                    }
-                    if xsave.is_infinite() {
-                        inf_sum += xsave;
-                    }
-                    special_sum += xsave;
-                    // reset partials
-                    partials.clear();
-                } else {
-                    partials.push(x);
-                }
-            }
-        }
-        if special_sum != 0.0 {
-            return if inf_sum.is_nan() {
-                Err(vm.new_value_error("-inf + inf in fsum"))
-            } else {
-                Ok(special_sum)
-            };
-        }
-
-        let mut n = partials.len();
-        if n > 0 {
-            n -= 1;
-            let mut hi = partials[n];
-
-            let mut lo = 0.0;
-            while n > 0 {
-                let x = hi;
-
-                n -= 1;
-                let y = partials[n];
-
-                hi = x + y;
-                lo = y - (hi - x);
-                if lo != 0.0 {
-                    break;
-                }
-            }
-            if n > 0 && ((lo < 0.0 && partials[n - 1] < 0.0) || (lo > 0.0 && partials[n - 1] > 0.0))
-            {
-                let y = lo + lo;
-                let x = hi + y;
-
-                // Make half-even rounding work across multiple partials.
-                // Needed so that sum([1e-16, 1, 1e16]) will round-up the last
-                // digit to two instead of down to zero (the 1e-16 makes the 1
-                // slightly closer to two).  With a potential 1 ULP rounding
-                // error fixed-up, math.fsum() can guarantee commutativity.
-                if y == x - hi {
-                    hi = x;
-                }
-            }
-
-            Ok(hi)
-        } else {
-            Ok(0.0)
-        }
-    }
-
-    #[pyfunction]
-    fn factorial(x: PyIntRef, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let value = x.as_bigint();
-        let one = BigInt::one();
-        if value.is_negative() {
-            return Err(vm.new_value_error("factorial() not defined for negative values"));
-        } else if *value <= one {
-            return Ok(one);
-        }
-        // start from 2, since we know that value > 1 and 1*2=2
-        let mut current = one + 1;
-        let mut product = BigInt::from(2u8);
-        while current < *value {
-            current += 1;
-            product *= &current;
-        }
-        Ok(product)
-    }
-
-    #[pyfunction]
-    fn perm(
-        n: ArgIndex,
-        k: OptionalArg<Option<ArgIndex>>,
-        vm: &VirtualMachine,
-    ) -> PyResult<BigInt> {
-        let n = n.into_int_ref();
-        let n = n.as_bigint();
-        let k_ref;
-        let v = match k.flatten() {
-            Some(k) => {
-                k_ref = k.into_int_ref();
-                k_ref.as_bigint()
-            }
-            None => n,
-        };
-
-        if n.is_negative() || v.is_negative() {
-            return Err(vm.new_value_error("perm() not defined for negative values"));
-        }
-        if v > n {
-            return Ok(BigInt::zero());
-        }
-        let mut result = BigInt::one();
-        let mut current = n.clone();
-        let tmp = n - v;
-        while current > tmp {
-            result *= &current;
-            current -= 1;
-        }
-        Ok(result)
-    }
-
-    #[pyfunction]
-    fn comb(n: ArgIndex, k: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let k = k.into_int_ref();
-        let mut k = k.as_bigint();
-        let n = n.into_int_ref();
-        let n = n.as_bigint();
-        let one = BigInt::one();
-        let zero = BigInt::zero();
-
-        if n.is_negative() || k.is_negative() {
-            return Err(vm.new_value_error("comb() not defined for negative values"));
-        }
-
-        let temp = n - k;
-        if temp.is_negative() {
-            return Ok(zero);
-        }
-
-        if temp < *k {
-            k = &temp
-        }
-
-        if k.is_zero() {
-            return Ok(one);
-        }
-
-        let mut result = n.clone();
-        let mut factor = n.clone();
-        let mut current = one;
-        while current < *k {
-            factor -= 1;
-            current += 1;
-
-            result *= &factor;
-            result /= &current;
-        }
-
-        Ok(result)
+        let values: Result<Vec<f64>, _> =
+            seq.iter(vm)?.map(|r| r.map(|v| v.into_float())).collect();
+        pymath::math::fsum(values?).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn modf(x: ArgIntoFloat) -> (f64, f64) {
-        let x = x.into_float();
-        if !x.is_finite() {
-            if x.is_infinite() {
-                return (0.0_f64.copysign(x), x);
-            } else if x.is_nan() {
-                return (x, x);
-            }
-        }
-
-        (x.fract(), x.trunc())
+        pymath::math::modf(x.into_float())
     }
 
     #[derive(FromArgs)]
@@ -887,85 +446,36 @@ mod math {
 
     #[pyfunction]
     fn nextafter(arg: NextAfterArgs, vm: &VirtualMachine) -> PyResult<f64> {
-        let steps: Option<i64> = arg
-            .steps
-            .map(|v| v.into_int_ref().try_to_primitive(vm))
-            .transpose()?
-            .into_option();
-        let x: f64 = arg.x.into();
-        let y: f64 = arg.y.into();
-        match steps {
+        let x = arg.x.into_float();
+        let y = arg.y.into_float();
+
+        let steps = match arg.steps.into_option() {
             Some(steps) => {
+                let steps: i64 = steps.into_int_ref().try_to_primitive(vm)?;
                 if steps < 0 {
                     return Err(vm.new_value_error("steps must be a non-negative integer"));
                 }
-                Ok(float_ops::nextafter_with_steps(x, y, steps as u64))
+                Some(steps as u64)
             }
-            None => Ok(float_ops::nextafter(x, y)),
-        }
+            None => None,
+        };
+        Ok(pymath::math::nextafter(x, y, steps))
     }
 
     #[pyfunction]
     fn ulp(x: ArgIntoFloat) -> f64 {
-        float_ops::ulp(x.into())
-    }
-
-    fn fmod(x: f64, y: f64) -> f64 {
-        if y.is_infinite() && x.is_finite() {
-            return x;
-        }
-
-        x % y
+        pymath::math::ulp(x.into_float())
     }
 
     #[pyfunction(name = "fmod")]
     fn py_fmod(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        let y = y.into_float();
-
-        let r = fmod(x, y);
-
-        if r.is_nan() && !x.is_nan() && !y.is_nan() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-
-        Ok(r)
+        pymath::math::fmod(x.into_float(), y.into_float()).map_err(|err| pymath_exception(err, vm))
     }
 
     #[pyfunction]
     fn remainder(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = x.into_float();
-        let y = y.into_float();
-
-        if x.is_finite() && y.is_finite() {
-            if y == 0.0 {
-                return Err(vm.new_value_error("math domain error"));
-            }
-
-            let abs_x = x.abs();
-            let abs_y = y.abs();
-            let modulus = abs_x % abs_y;
-
-            let c = abs_y - modulus;
-            let r = match modulus.partial_cmp(&c) {
-                Some(Ordering::Less) => modulus,
-                Some(Ordering::Greater) => -c,
-                _ => modulus - 2.0 * fmod(0.5 * (abs_x - modulus), abs_y),
-            };
-
-            return Ok(1.0_f64.copysign(x) * r);
-        }
-        if x.is_infinite() && !y.is_nan() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        if x.is_nan() || y.is_nan() {
-            return Ok(f64::NAN);
-        }
-        if y.is_infinite() {
-            Ok(x)
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
+        pymath::math::remainder(x.into_float(), y.into_float())
+            .map_err(|err| pymath_exception(err, vm))
     }
 
     #[derive(FromArgs)]
@@ -978,15 +488,118 @@ mod math {
 
     #[pyfunction]
     fn prod(args: ProdArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        use crate::vm::builtins::PyInt;
+
         let iter = args.iterable;
+        let start = args.start;
+
+        // Check if start is provided and what type it is (exact types only, not subclasses)
+        let (mut obj_result, start_is_int, start_is_float) = match &start {
+            OptionalArg::Present(s) => {
+                let is_int = s.class().is(vm.ctx.types.int_type);
+                let is_float = s.class().is(vm.ctx.types.float_type);
+                (Some(s.clone()), is_int, is_float)
+            }
+            OptionalArg::Missing => (None, true, false), // Default is int 1
+        };
+
+        let mut item_iter = iter.iter(vm)?;
+
+        // Integer fast path
+        if start_is_int && !start_is_float {
+            let mut int_result: i64 = match &start {
+                OptionalArg::Present(s) => {
+                    if let Some(i) = s.downcast_ref::<PyInt>() {
+                        match i.as_bigint().try_into() {
+                            Ok(v) => v,
+                            Err(_) => {
+                                // Start overflows i64, fall through to generic path
+                                obj_result = Some(s.clone());
+                                i64::MAX // Will be ignored
+                            }
+                        }
+                    } else {
+                        1
+                    }
+                }
+                OptionalArg::Missing => 1,
+            };
 
-        let mut result = args.start.unwrap_or_else(|| vm.new_pyobj(1));
+            if obj_result.is_none() {
+                loop {
+                    let item = match item_iter.next() {
+                        Some(r) => r?,
+                        None => return Ok(vm.ctx.new_int(int_result).into()),
+                    };
+
+                    // Only use fast path for exact int type (not subclasses)
+                    if item.class().is(vm.ctx.types.int_type)
+                        && let Some(int_item) = item.downcast_ref::<PyInt>()
+                        && let Ok(b) = int_item.as_bigint().try_into() as Result<i64, _>
+                        && let Some(product) = int_result.checked_mul(b)
+                    {
+                        int_result = product;
+                        continue;
+                    }
 
-        // TODO: CPython has optimized implementation for this
-        // refer: https://github.com/python/cpython/blob/main/Modules/mathmodule.c#L3093-L3193
-        for obj in iter.iter(vm)? {
-            let obj = obj?;
-            result = vm._mul(&result, &obj)?;
+                    // Overflow or non-int: restore to PyObject and continue
+                    obj_result = Some(vm.ctx.new_int(int_result).into());
+                    let temp = vm._mul(obj_result.as_ref().unwrap(), &item)?;
+                    obj_result = Some(temp);
+                    break;
+                }
+            }
+        }
+
+        // Float fast path
+        let obj_float = obj_result
+            .as_ref()
+            .and_then(|obj| obj.clone().downcast::<PyFloat>().ok());
+        if obj_float.is_some() || start_is_float {
+            let mut flt_result: f64 = if let Some(ref f) = obj_float {
+                f.to_f64()
+            } else if start_is_float && let OptionalArg::Present(s) = &start {
+                s.downcast_ref::<PyFloat>()
+                    .map(|f| f.to_f64())
+                    .unwrap_or(1.0)
+            } else {
+                1.0
+            };
+
+            loop {
+                let item = match item_iter.next() {
+                    Some(r) => r?,
+                    None => return Ok(vm.ctx.new_float(flt_result).into()),
+                };
+
+                // Only use fast path for exact float/int types (not subclasses)
+                if item.class().is(vm.ctx.types.float_type)
+                    && let Some(f) = item.downcast_ref::<PyFloat>()
+                {
+                    flt_result *= f.to_f64();
+                    continue;
+                }
+                if item.class().is(vm.ctx.types.int_type)
+                    && let Some(i) = item.downcast_ref::<PyInt>()
+                    && let Ok(v) = i.as_bigint().try_into() as Result<i64, _>
+                {
+                    flt_result *= v as f64;
+                    continue;
+                }
+
+                // Non-exact-float/int: restore and continue with generic path
+                obj_result = Some(vm.ctx.new_float(flt_result).into());
+                let temp = vm._mul(obj_result.as_ref().unwrap(), &item)?;
+                obj_result = Some(temp);
+                break;
+            }
+        }
+
+        // Generic path for remaining items
+        let mut result = obj_result.unwrap_or_else(|| vm.ctx.new_int(1).into());
+        for item in item_iter {
+            let item = item?;
+            result = vm._mul(&result, &item)?;
         }
 
         Ok(result)
@@ -998,29 +611,145 @@ mod math {
         q: ArgIterable<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyObjectRef> {
+        use crate::vm::builtins::PyInt;
+
         let mut p_iter = p.iter(vm)?;
         let mut q_iter = q.iter(vm)?;
-        // We cannot just create a float because the iterator may contain
-        // anything as long as it supports __add__ and __mul__.
-        let mut result = vm.new_pyobj(0);
+
+        // Fast path state
+        let mut int_path_enabled = true;
+        let mut int_total: i64 = 0;
+        let mut int_total_in_use = false;
+        let mut flt_p_values: Vec<f64> = Vec::new();
+        let mut flt_q_values: Vec<f64> = Vec::new();
+
+        // Fallback accumulator for generic Python path
+        let mut obj_total: Option<PyObjectRef> = None;
+
         loop {
             let m_p = p_iter.next();
             let m_q = q_iter.next();
-            match (m_p, m_q) {
-                (Some(r_p), Some(r_q)) => {
-                    let p = r_p?;
-                    let q = r_q?;
-                    let tmp = vm._mul(&p, &q)?;
-                    result = vm._add(&result, &tmp)?;
+
+            let (p_i, q_i, finished) = match (m_p, m_q) {
+                (Some(r_p), Some(r_q)) => (Some(r_p?), Some(r_q?), false),
+                (None, None) => (None, None, true),
+                _ => return Err(vm.new_value_error("Inputs are not the same length")),
+            };
+
+            // Integer fast path (only for exact int types, not subclasses)
+            if int_path_enabled {
+                if !finished {
+                    let (p_i, q_i) = (p_i.as_ref().unwrap(), q_i.as_ref().unwrap());
+                    if p_i.class().is(vm.ctx.types.int_type)
+                        && q_i.class().is(vm.ctx.types.int_type)
+                        && let (Some(p_int), Some(q_int)) =
+                            (p_i.downcast_ref::<PyInt>(), q_i.downcast_ref::<PyInt>())
+                        && let (Ok(p_val), Ok(q_val)) = (
+                            p_int.as_bigint().try_into() as Result<i64, _>,
+                            q_int.as_bigint().try_into() as Result<i64, _>,
+                        )
+                        && let Some(prod) = p_val.checked_mul(q_val)
+                        && let Some(new_total) = int_total.checked_add(prod)
+                    {
+                        int_total = new_total;
+                        int_total_in_use = true;
+                        continue;
+                    }
                 }
-                (None, None) => break,
-                _ => {
-                    return Err(vm.new_value_error("Inputs are not the same length"));
+                // Finalize int path
+                int_path_enabled = false;
+                if int_total_in_use {
+                    let int_obj: PyObjectRef = vm.ctx.new_int(int_total).into();
+                    obj_total = Some(match obj_total {
+                        Some(total) => vm._add(&total, &int_obj)?,
+                        None => int_obj,
+                    });
+                    int_total = 0;
+                    int_total_in_use = false;
                 }
             }
+
+            // Float fast path - only when at least one value is exact float type
+            // (not subclasses, to preserve custom __mul__/__add__ behavior)
+            {
+                if !finished {
+                    let (p_i, q_i) = (p_i.as_ref().unwrap(), q_i.as_ref().unwrap());
+
+                    let p_is_exact_float = p_i.class().is(vm.ctx.types.float_type);
+                    let q_is_exact_float = q_i.class().is(vm.ctx.types.float_type);
+                    let p_is_exact_int = p_i.class().is(vm.ctx.types.int_type);
+                    let q_is_exact_int = q_i.class().is(vm.ctx.types.int_type);
+                    let p_is_exact_numeric = p_is_exact_float || p_is_exact_int;
+                    let q_is_exact_numeric = q_is_exact_float || q_is_exact_int;
+                    let has_exact_float = p_is_exact_float || q_is_exact_float;
+
+                    // Only use float path if at least one is exact float and both are exact int/float
+                    if has_exact_float && p_is_exact_numeric && q_is_exact_numeric {
+                        let p_flt = if let Some(f) = p_i.downcast_ref::<PyFloat>() {
+                            Some(f.to_f64())
+                        } else if let Some(i) = p_i.downcast_ref::<PyInt>() {
+                            // PyLong_AsDouble fails for integers too large for f64
+                            try_bigint_to_f64(i.as_bigint(), vm).ok()
+                        } else {
+                            None
+                        };
+
+                        let q_flt = if let Some(f) = q_i.downcast_ref::<PyFloat>() {
+                            Some(f.to_f64())
+                        } else if let Some(i) = q_i.downcast_ref::<PyInt>() {
+                            // PyLong_AsDouble fails for integers too large for f64
+                            try_bigint_to_f64(i.as_bigint(), vm).ok()
+                        } else {
+                            None
+                        };
+
+                        if let (Some(p_val), Some(q_val)) = (p_flt, q_flt) {
+                            flt_p_values.push(p_val);
+                            flt_q_values.push(q_val);
+                            continue;
+                        }
+                    }
+                }
+                // Finalize float path
+                if !flt_p_values.is_empty() {
+                    let flt_result = pymath::math::sumprod(&flt_p_values, &flt_q_values);
+                    let flt_obj: PyObjectRef = vm.ctx.new_float(flt_result).into();
+                    obj_total = Some(match obj_total {
+                        Some(total) => vm._add(&total, &flt_obj)?,
+                        None => flt_obj,
+                    });
+                    flt_p_values.clear();
+                    flt_q_values.clear();
+                }
+            }
+
+            if finished {
+                break;
+            }
+
+            // Generic Python path
+            let (p_i, q_i) = (p_i.unwrap(), q_i.unwrap());
+
+            // Collect current + remaining elements
+            let p_remaining: Result<Vec<PyObjectRef>, _> =
+                std::iter::once(Ok(p_i)).chain(p_iter).collect();
+            let q_remaining: Result<Vec<PyObjectRef>, _> =
+                std::iter::once(Ok(q_i)).chain(q_iter).collect();
+            let (p_vec, q_vec) = (p_remaining?, q_remaining?);
+
+            if p_vec.len() != q_vec.len() {
+                return Err(vm.new_value_error("Inputs are not the same length"));
+            }
+
+            let mut total = obj_total.unwrap_or_else(|| vm.ctx.new_int(0).into());
+            for (p_item, q_item) in p_vec.into_iter().zip(q_vec) {
+                let prod = vm._mul(&p_item, &q_item)?;
+                total = vm._add(&total, &prod)?;
+            }
+            return Ok(total);
         }
 
-        Ok(result)
+        Ok(obj_total.unwrap_or_else(|| vm.ctx.new_int(0).into()))
     }
 
     #[pyfunction]
@@ -1030,30 +759,202 @@ mod math {
         z: ArgIntoFloat,
         vm: &VirtualMachine,
     ) -> PyResult<f64> {
-        let x = x.into_float();
-        let y = y.into_float();
-        let z = z.into_float();
-        let result = x.mul_add(y, z);
+        pymath::math::fma(x.into_float(), y.into_float(), z.into_float()).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error("invalid operation in fma"),
+            pymath::Error::ERANGE => vm.new_overflow_error("overflow in fma"),
+        })
+    }
+
+    // Integer functions:
+
+    #[pyfunction]
+    fn isqrt(x: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let value = x.into_int_ref();
+        pymath::math::integer::isqrt(value.as_bigint())
+            .map_err(|_| vm.new_value_error("isqrt() argument must be nonnegative"))
+    }
 
-        if result.is_finite() {
-            return Ok(result);
+    #[pyfunction]
+    fn gcd(args: PosArgs<ArgIndex>) -> BigInt {
+        let ints: Vec<_> = args
+            .into_vec()
+            .into_iter()
+            .map(|x| x.into_int_ref())
+            .collect();
+        let refs: Vec<_> = ints.iter().map(|x| x.as_bigint()).collect();
+        pymath::math::integer::gcd(&refs)
+    }
+
+    #[pyfunction]
+    fn lcm(args: PosArgs<ArgIndex>) -> BigInt {
+        let ints: Vec<_> = args
+            .into_vec()
+            .into_iter()
+            .map(|x| x.into_int_ref())
+            .collect();
+        let refs: Vec<_> = ints.iter().map(|x| x.as_bigint()).collect();
+        pymath::math::integer::lcm(&refs)
+    }
+
+    #[pyfunction]
+    fn factorial(x: PyIntRef, vm: &VirtualMachine) -> PyResult<BigInt> {
+        // Check for negative before overflow - negative values are always invalid
+        if x.as_bigint().is_negative() {
+            return Err(vm.new_value_error("factorial() not defined for negative values"));
         }
+        let n: i64 = x.try_to_primitive(vm).map_err(|_| {
+            vm.new_overflow_error("factorial() argument should not exceed 9223372036854775807")
+        })?;
+        pymath::math::integer::factorial(n)
+            .map(|r| r.into())
+            .map_err(|_| vm.new_value_error("factorial() not defined for negative values"))
+    }
+
+    #[pyfunction]
+    fn perm(
+        n: ArgIndex,
+        k: OptionalArg<Option<ArgIndex>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<BigInt> {
+        let n_int = n.into_int_ref();
+        let n_big = n_int.as_bigint();
 
-        if result.is_nan() {
-            if !x.is_nan() && !y.is_nan() && !z.is_nan() {
-                return Err(vm.new_value_error("invalid operation in fma"));
+        if n_big.is_negative() {
+            return Err(vm.new_value_error("n must be a non-negative integer"));
+        }
+
+        // k = None means k = n (factorial)
+        let k_int = k.flatten().map(|k| k.into_int_ref());
+        let k_big: Option<&BigInt> = k_int.as_ref().map(|k| k.as_bigint());
+
+        if let Some(k_val) = k_big {
+            if k_val.is_negative() {
+                return Err(vm.new_value_error("k must be a non-negative integer"));
+            }
+            if k_val > n_big {
+                return Ok(BigInt::from(0u8));
             }
-        } else if x.is_finite() && y.is_finite() && z.is_finite() {
-            return Err(vm.new_overflow_error("overflow in fma"));
         }
 
-        Ok(result)
+        // Convert k to u64 (required by pymath)
+        let ki: u64 = match k_big {
+            None => match n_big.to_u64() {
+                Some(n) => n,
+                None => {
+                    return Err(vm.new_overflow_error(format!("n must not exceed {}", u64::MAX)));
+                }
+            },
+            Some(k_val) => match k_val.to_u64() {
+                Some(k) => k,
+                None => {
+                    return Err(vm.new_overflow_error(format!("k must not exceed {}", u64::MAX)));
+                }
+            },
+        };
+
+        // Fast path: n fits in i64
+        if let Some(ni) = n_big.to_i64()
+            && ni >= 0
+            && ki > 1
+        {
+            let result = pymath::math::integer::perm(ni, Some(ki as i64))
+                .map_err(|_| vm.new_value_error("perm() error"))?;
+            return Ok(result.into());
+        }
+
+        // BigInt path: use perm_bigint
+        let result = pymath::math::perm_bigint(n_big, ki);
+        Ok(result.into())
+    }
+
+    #[pyfunction]
+    fn comb(n: ArgIndex, k: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let n_int = n.into_int_ref();
+        let n_big = n_int.as_bigint();
+        let k_int = k.into_int_ref();
+        let k_big = k_int.as_bigint();
+
+        if n_big.is_negative() {
+            return Err(vm.new_value_error("n must be a non-negative integer"));
+        }
+        if k_big.is_negative() {
+            return Err(vm.new_value_error("k must be a non-negative integer"));
+        }
+
+        // Fast path: n fits in i64
+        if let Some(ni) = n_big.to_i64()
+            && ni >= 0
+        {
+            // k overflow or k > n means result is 0
+            let ki = match k_big.to_i64() {
+                Some(k) if k >= 0 && k <= ni => k,
+                _ => return Ok(BigInt::from(0u8)),
+            };
+            // Apply symmetry: use min(k, n-k)
+            let ki = ki.min(ni - ki);
+            if ki > 1 {
+                let result = pymath::math::integer::comb(ni, ki)
+                    .map_err(|_| vm.new_value_error("comb() error"))?;
+                return Ok(result.into());
+            }
+            // ki <= 1 cases
+            if ki == 0 {
+                return Ok(BigInt::from(1u8));
+            }
+            return Ok(n_big.clone()); // ki == 1
+        }
+
+        // BigInt path: n doesn't fit in i64
+        // Apply symmetry: k = min(k, n - k)
+        let n_minus_k = n_big - k_big;
+        if n_minus_k.is_negative() {
+            return Ok(BigInt::from(0u8));
+        }
+        let effective_k = if &n_minus_k < k_big {
+            &n_minus_k
+        } else {
+            k_big
+        };
+
+        // k must fit in u64
+        let ki: u64 = match effective_k.to_u64() {
+            Some(k) => k,
+            None => {
+                return Err(
+                    vm.new_overflow_error(format!("min(n - k, k) must not exceed {}", u64::MAX))
+                );
+            }
+        };
+
+        let result = pymath::math::comb_bigint(n_big, ki);
+        Ok(result.into())
     }
 }
 
-fn pymath_error_to_exception(err: pymath::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
+pub(crate) fn pymath_exception(err: pymath::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
     match err {
         pymath::Error::EDOM => vm.new_value_error("math domain error"),
         pymath::Error::ERANGE => vm.new_overflow_error("math range error"),
     }
 }
+
+/// Format a float in Python style (ensures trailing .0 for integers).
+fn float_repr(value: f64) -> String {
+    if value.is_nan() {
+        "nan".to_owned()
+    } else if value.is_infinite() {
+        if value.is_sign_positive() {
+            "inf".to_owned()
+        } else {
+            "-inf".to_owned()
+        }
+    } else {
+        let s = format!("{}", value);
+        // If no decimal point and not in scientific notation, add .0
+        if !s.contains('.') && !s.contains('e') && !s.contains('E') {
+            format!("{}.0", s)
+        } else {
+            s
+        }
+    }
+}
diff --git a/crates/vm/src/builtins/float.rs b/crates/vm/src/builtins/float.rs
index f101a3aa8e3..9941aea9ba2 100644
--- a/crates/vm/src/builtins/float.rs
+++ b/crates/vm/src/builtins/float.rs
@@ -116,7 +116,7 @@ fn inner_divmod(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
 
 pub fn float_pow(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult {
     if v1.is_zero() && v2.is_sign_negative() {
-        let msg = "0.0 cannot be raised to a negative power";
+        let msg = "zero to a negative power";
         Err(vm.new_zero_division_error(msg.to_owned()))
     } else if v1.is_sign_negative() && (v2.floor() - v2).abs() > f64::EPSILON {
         let v1 = Complex64::new(v1, 0.);

From bb57724d3b61bc0d9814a102a62dce99e0cebe0c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 13 Jan 2026 22:05:49 +0900
Subject: [PATCH 282/418] flush on WantWrite (#6717)

---
 crates/stdlib/src/ssl/compat.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 00e2c8d3c32..3c72ccf4e21 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -1237,8 +1237,7 @@ fn handle_handshake_complete(
         }
     } else if conn.wants_write() {
         // Send all pending data (e.g., TLS 1.3 NewSessionTicket) to socket
-        // Best-effort: WantWrite means socket buffer full, pending data will be
-        // sent in subsequent read/write calls. Don't fail handshake for this.
+        // Must drain ALL rustls buffer - don't break on WantWrite
         while conn.wants_write() {
             let tls_data = ssl_write_tls_records(conn)?;
             if tls_data.is_empty() {
@@ -1246,7 +1245,13 @@ fn handle_handshake_complete(
             }
             match send_all_bytes(socket, tls_data, vm, None) {
                 Ok(()) => {}
-                Err(SslError::WantWrite) => break,
+                Err(SslError::WantWrite) => {
+                    // Socket buffer full, data saved to pending_tls_output
+                    // Flush pending and continue draining rustls buffer
+                    socket
+                        .blocking_flush_all_pending(vm)
+                        .map_err(SslError::Py)?;
+                }
                 Err(e) => return Err(e),
             }
         }
@@ -1256,6 +1261,7 @@ fn handle_handshake_complete(
     // TLS 1.3 Finished must reach server before handshake is considered complete
     // Without this, server may not process application data
     if !socket.is_bio_mode() {
+        // Flush pending_tls_output to ensure all TLS data reaches the server
         socket
             .blocking_flush_all_pending(vm)
             .map_err(SslError::Py)?;

From 9eeea925c7072688146b9385f31248d55671ca34 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 01:58:49 +0200
Subject: [PATCH 283/418] Move `OpArg` to its own file (#6703)

* Move OpArg to its own file

* Fix merge

* Fix more merge
---
 crates/compiler-core/src/bytecode.rs          | 661 +-----------------
 .../compiler-core/src/bytecode/instruction.rs |  83 ++-
 crates/compiler-core/src/bytecode/oparg.rs    | 582 +++++++++++++++
 3 files changed, 669 insertions(+), 657 deletions(-)
 create mode 100644 crates/compiler-core/src/bytecode/oparg.rs

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 5270b89f3ad..3595e67c32e 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -8,15 +8,23 @@ use crate::{
 };
 use alloc::{collections::BTreeSet, fmt, vec::Vec};
 use bitflags::bitflags;
-use core::{hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
+use core::{hash, mem, ops::Deref};
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
-pub use crate::bytecode::instruction::Instruction;
+pub use crate::bytecode::{
+    instruction::{Arg, Instruction, decode_load_super_attr_arg, encode_load_super_attr_arg},
+    oparg::{
+        BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
+        IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx, OpArg,
+        OpArgByte, OpArgState, OpArgType, RaiseKind, ResumeType, UnpackExArgs,
+    },
+};
 
 mod instruction;
+mod oparg;
 
 /// Exception table entry for zero-cost exception handling
 /// Format: (start, size, target, depth<<1|lasti)
@@ -102,103 +110,6 @@ pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
     (name_idx, is_method)
 }
 
-/// Encode LOAD_SUPER_ATTR oparg: bit 0 = load_method, bit 1 = has_class, bits 2+ = name index.
-#[inline]
-pub const fn encode_load_super_attr_arg(name_idx: u32, load_method: bool, has_class: bool) -> u32 {
-    (name_idx << 2) | ((has_class as u32) << 1) | (load_method as u32)
-}
-
-/// Decode LOAD_SUPER_ATTR oparg: returns (name_idx, load_method, has_class).
-#[inline]
-pub const fn decode_load_super_attr_arg(oparg: u32) -> (u32, bool, bool) {
-    let load_method = (oparg & 1) == 1;
-    let has_class = (oparg & 2) == 2;
-    let name_idx = oparg >> 2;
-    (name_idx, load_method, has_class)
-}
-
-/// Oparg values for [`Instruction::ConvertValue`].
-///
-/// ## See also
-///
-/// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
-#[repr(u8)]
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-pub enum ConvertValueOparg {
-    /// No conversion.
-    ///
-    /// ```python
-    /// f"{x}"
-    /// f"{x:4}"
-    /// ```
-    None = 0,
-    /// Converts by calling `str(<value>)`.
-    ///
-    /// ```python
-    /// f"{x!s}"
-    /// f"{x!s:2}"
-    /// ```
-    Str = 1,
-    /// Converts by calling `repr(<value>)`.
-    ///
-    /// ```python
-    /// f"{x!r}"
-    /// f"{x!r:2}"
-    /// ```
-    Repr = 2,
-    /// Converts by calling `ascii(<value>)`.
-    ///
-    /// ```python
-    /// f"{x!a}"
-    /// f"{x!a:2}"
-    /// ```
-    Ascii = 3,
-}
-
-impl fmt::Display for ConvertValueOparg {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let out = match self {
-            Self::Str => "1 (str)",
-            Self::Repr => "2 (repr)",
-            Self::Ascii => "3 (ascii)",
-            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
-            Self::None => "",
-        };
-
-        write!(f, "{out}")
-    }
-}
-
-impl OpArgType for ConvertValueOparg {
-    #[inline]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(match x {
-            // Ruff `ConversionFlag::None` is `-1i8`,
-            // when its converted to `u8` its value is `u8::MAX`
-            0 | 255 => Self::None,
-            1 => Self::Str,
-            2 => Self::Repr,
-            3 => Self::Ascii,
-            _ => return None,
-        })
-    }
-
-    #[inline]
-    fn to_op_arg(self) -> u32 {
-        self as u32
-    }
-}
-
-/// Resume type for the RESUME instruction
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-#[repr(u32)]
-pub enum ResumeType {
-    AtFuncStart = 0,
-    AfterYield = 1,
-    AfterYieldFrom = 2,
-    AfterAwait = 3,
-}
-
 /// CPython 3.11+ linetable location info codes
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u8)]
@@ -399,296 +310,6 @@ bitflags! {
     }
 }
 
-/// an opcode argument that may be extended by a prior ExtendedArg
-#[derive(Copy, Clone, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct OpArgByte(pub u8);
-
-impl OpArgByte {
-    pub const fn null() -> Self {
-        Self(0)
-    }
-}
-
-impl From<u8> for OpArgByte {
-    fn from(raw: u8) -> Self {
-        Self(raw)
-    }
-}
-
-impl fmt::Debug for OpArgByte {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-/// a full 32-bit op_arg, including any possible ExtendedArg extension
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)]
-pub struct OpArg(pub u32);
-
-impl OpArg {
-    pub const fn null() -> Self {
-        Self(0)
-    }
-
-    /// Returns how many CodeUnits a instruction with this op_arg will be encoded as
-    #[inline]
-    pub const fn instr_size(self) -> usize {
-        (self.0 > 0xff) as usize + (self.0 > 0xff_ff) as usize + (self.0 > 0xff_ff_ff) as usize + 1
-    }
-
-    /// returns the arg split into any necessary ExtendedArg components (in big-endian order) and
-    /// the arg for the real opcode itself
-    #[inline(always)]
-    pub fn split(self) -> (impl ExactSizeIterator<Item = OpArgByte>, OpArgByte) {
-        let mut it = self
-            .0
-            .to_le_bytes()
-            .map(OpArgByte)
-            .into_iter()
-            .take(self.instr_size());
-        let lo = it.next().unwrap();
-        (it.rev(), lo)
-    }
-}
-
-impl From<u32> for OpArg {
-    fn from(raw: u32) -> Self {
-        Self(raw)
-    }
-}
-
-#[derive(Default, Copy, Clone)]
-#[repr(transparent)]
-pub struct OpArgState {
-    state: u32,
-}
-
-impl OpArgState {
-    #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
-        let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
-            self.reset();
-        }
-        (ins.op, arg)
-    }
-
-    #[inline(always)]
-    pub fn extend(&mut self, arg: OpArgByte) -> OpArg {
-        self.state = (self.state << 8) | u32::from(arg.0);
-        OpArg(self.state)
-    }
-
-    #[inline(always)]
-    pub const fn reset(&mut self) {
-        self.state = 0
-    }
-}
-
-pub trait OpArgType: Copy {
-    fn from_op_arg(x: u32) -> Option<Self>;
-
-    fn to_op_arg(self) -> u32;
-}
-
-impl OpArgType for u32 {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(x)
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self
-    }
-}
-
-impl OpArgType for bool {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(x != 0)
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self as u32
-    }
-}
-
-macro_rules! op_arg_enum_impl {
-    (enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        impl OpArgType for $name {
-            fn to_op_arg(self) -> u32 {
-                self as u32
-            }
-
-            fn from_op_arg(x: u32) -> Option<Self> {
-                Some(match u8::try_from(x).ok()? {
-                    $($value => Self::$var,)*
-                    _ => return None,
-                })
-            }
-        }
-    };
-}
-
-macro_rules! op_arg_enum {
-    ($(#[$attr:meta])* $vis:vis enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        $(#[$attr])*
-        $vis enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        }
-
-        op_arg_enum_impl!(enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        });
-    };
-}
-
-#[derive(Copy, Clone)]
-pub struct Arg<T: OpArgType>(PhantomData<T>);
-
-impl<T: OpArgType> Arg<T> {
-    #[inline]
-    pub const fn marker() -> Self {
-        Self(PhantomData)
-    }
-
-    #[inline]
-    pub fn new(arg: T) -> (Self, OpArg) {
-        (Self(PhantomData), OpArg(arg.to_op_arg()))
-    }
-
-    #[inline]
-    pub fn new_single(arg: T) -> (Self, OpArgByte)
-    where
-        T: Into<u8>,
-    {
-        (Self(PhantomData), OpArgByte(arg.into()))
-    }
-
-    #[inline(always)]
-    pub fn get(self, arg: OpArg) -> T {
-        self.try_get(arg).unwrap()
-    }
-
-    #[inline(always)]
-    pub fn try_get(self, arg: OpArg) -> Option<T> {
-        T::from_op_arg(arg.0)
-    }
-
-    /// # Safety
-    /// T::from_op_arg(self) must succeed
-    #[inline(always)]
-    pub unsafe fn get_unchecked(self, arg: OpArg) -> T {
-        // SAFETY: requirements forwarded from caller
-        unsafe { T::from_op_arg(arg.0).unwrap_unchecked() }
-    }
-}
-
-impl<T: OpArgType> PartialEq for Arg<T> {
-    fn eq(&self, _: &Self) -> bool {
-        true
-    }
-}
-
-impl<T: OpArgType> Eq for Arg<T> {}
-
-impl<T: OpArgType> fmt::Debug for Arg<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Arg<{}>", core::any::type_name::<T>())
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-#[repr(transparent)]
-// XXX: if you add a new instruction that stores a Label, make sure to add it in
-// Instruction::label_arg
-pub struct Label(pub u32);
-
-impl OpArgType for Label {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(Self(x))
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.0
-    }
-}
-
-impl fmt::Display for Label {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-op_arg_enum!(
-    /// The kind of Raise that occurred.
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum RaiseKind {
-        /// Bare `raise` statement with no arguments.
-        /// Gets the current exception from VM state (topmost_exception).
-        /// Maps to RAISE_VARARGS with oparg=0.
-        BareRaise = 0,
-        /// `raise exc` - exception is on the stack.
-        /// Maps to RAISE_VARARGS with oparg=1.
-        Raise = 1,
-        /// `raise exc from cause` - exception and cause are on the stack.
-        /// Maps to RAISE_VARARGS with oparg=2.
-        RaiseCause = 2,
-        /// Reraise exception from the stack top.
-        /// Used in exception handler cleanup blocks (finally, except).
-        /// Gets exception from stack, not from VM state.
-        /// Maps to the RERAISE opcode.
-        ReraiseFromStack = 3,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_1
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction1 {
-        // Invalid = 0,
-        Print = 1,
-        /// Import * operation
-        ImportStar = 2,
-        // StopIterationError = 3,
-        // AsyncGenWrap = 4,
-        UnaryPositive = 5,
-        /// Convert list to tuple
-        ListToTuple = 6,
-        /// Type parameter related
-        TypeVar = 7,
-        ParamSpec = 8,
-        TypeVarTuple = 9,
-        /// Generic subscript for PEP 695
-        SubscriptGeneric = 10,
-        TypeAlias = 11,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_2
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction2 {
-        PrepReraiseStar = 1,
-        TypeVarWithBound = 2,
-        TypeVarWithConstraint = 3,
-        SetFunctionTypeParams = 4,
-        /// Set default value for type parameter (PEP 695)
-        SetTypeparamDefault = 5,
-    }
-);
-
-pub type NameIdx = u32;
-
 #[derive(Copy, Clone)]
 #[repr(C)]
 pub struct CodeUnit {
@@ -756,29 +377,6 @@ impl Deref for CodeUnits {
     }
 }
 
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct MakeFunctionFlags: u8 {
-        const CLOSURE = 0x01;
-        const ANNOTATIONS = 0x02;
-        const KW_ONLY_DEFAULTS = 0x04;
-        const DEFAULTS = 0x08;
-        const TYPE_PARAMS = 0x10;
-    }
-}
-
-impl OpArgType for MakeFunctionFlags {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Self::from_bits(x as u8)
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.bits().into()
-    }
-}
-
 /// A Constant (which usually encapsulates data within it)
 ///
 /// # Examples
@@ -934,245 +532,6 @@ impl<C: Constant> BorrowedConstant<'_, C> {
     }
 }
 
-op_arg_enum!(
-    /// The possible comparison operators
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum ComparisonOperator {
-        // be intentional with bits so that we can do eval_ord with just a bitwise and
-        // bits: | Equal | Greater | Less |
-        Less = 0b001,
-        Greater = 0b010,
-        NotEqual = 0b011,
-        Equal = 0b100,
-        LessOrEqual = 0b101,
-        GreaterOrEqual = 0b110,
-    }
-);
-
-op_arg_enum!(
-    /// The possible Binary operators
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
-    /// let (op, _) = Arg::new(BinaryOperator::Add);
-    /// let instruction = Instruction::BinaryOp { op };
-    /// ```
-    ///
-    /// See also:
-    /// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
-    #[repr(u8)]
-    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-    pub enum BinaryOperator {
-        /// `+`
-        Add = 0,
-        /// `&`
-        And = 1,
-        /// `//`
-        FloorDivide = 2,
-        /// `<<`
-        Lshift = 3,
-        /// `@`
-        MatrixMultiply = 4,
-        /// `*`
-        Multiply = 5,
-        /// `%`
-        Remainder = 6,
-        /// `|`
-        Or = 7,
-        /// `**`
-        Power = 8,
-        /// `>>`
-        Rshift = 9,
-        /// `-`
-        Subtract = 10,
-        /// `/`
-        TrueDivide = 11,
-        /// `^`
-        Xor = 12,
-        /// `+=`
-        InplaceAdd = 13,
-        /// `&=`
-        InplaceAnd = 14,
-        /// `//=`
-        InplaceFloorDivide = 15,
-        /// `<<=`
-        InplaceLshift = 16,
-        /// `@=`
-        InplaceMatrixMultiply = 17,
-        /// `*=`
-        InplaceMultiply = 18,
-        /// `%=`
-        InplaceRemainder = 19,
-        /// `|=`
-        InplaceOr = 20,
-        /// `**=`
-        InplacePower = 21,
-        /// `>>=`
-        InplaceRshift = 22,
-        /// `-=`
-        InplaceSubtract = 23,
-        /// `/=`
-        InplaceTrueDivide = 24,
-        /// `^=`
-        InplaceXor = 25,
-    }
-);
-
-impl BinaryOperator {
-    /// Get the "inplace" version of the operator.
-    /// This has no effect if `self` is already an "inplace" operator.
-    ///
-    /// # Example
-    /// ```rust
-    /// use rustpython_compiler_core::bytecode::BinaryOperator;
-    ///
-    /// assert_eq!(BinaryOperator::Power.as_inplace(), BinaryOperator::InplacePower);
-    ///
-    /// assert_eq!(BinaryOperator::InplaceSubtract.as_inplace(), BinaryOperator::InplaceSubtract);
-    /// ```
-    #[must_use]
-    pub const fn as_inplace(self) -> Self {
-        match self {
-            Self::Add => Self::InplaceAdd,
-            Self::And => Self::InplaceAnd,
-            Self::FloorDivide => Self::InplaceFloorDivide,
-            Self::Lshift => Self::InplaceLshift,
-            Self::MatrixMultiply => Self::InplaceMatrixMultiply,
-            Self::Multiply => Self::InplaceMultiply,
-            Self::Remainder => Self::InplaceRemainder,
-            Self::Or => Self::InplaceOr,
-            Self::Power => Self::InplacePower,
-            Self::Rshift => Self::InplaceRshift,
-            Self::Subtract => Self::InplaceSubtract,
-            Self::TrueDivide => Self::InplaceTrueDivide,
-            Self::Xor => Self::InplaceXor,
-            _ => self,
-        }
-    }
-}
-
-impl fmt::Display for BinaryOperator {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let op = match self {
-            Self::Add => "+",
-            Self::And => "&",
-            Self::FloorDivide => "//",
-            Self::Lshift => "<<",
-            Self::MatrixMultiply => "@",
-            Self::Multiply => "*",
-            Self::Remainder => "%",
-            Self::Or => "|",
-            Self::Power => "**",
-            Self::Rshift => ">>",
-            Self::Subtract => "-",
-            Self::TrueDivide => "/",
-            Self::Xor => "^",
-            Self::InplaceAdd => "+=",
-            Self::InplaceAnd => "&=",
-            Self::InplaceFloorDivide => "//=",
-            Self::InplaceLshift => "<<=",
-            Self::InplaceMatrixMultiply => "@=",
-            Self::InplaceMultiply => "*=",
-            Self::InplaceRemainder => "%=",
-            Self::InplaceOr => "|=",
-            Self::InplacePower => "**=",
-            Self::InplaceRshift => ">>=",
-            Self::InplaceSubtract => "-=",
-            Self::InplaceTrueDivide => "/=",
-            Self::InplaceXor => "^=",
-        };
-        write!(f, "{op}")
-    }
-}
-
-op_arg_enum!(
-    /// Whether or not to invert the operation.
-    #[repr(u8)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    pub enum Invert {
-        /// ```py
-        /// foo is bar
-        /// x in lst
-        /// ```
-        No = 0,
-        /// ```py
-        /// foo is not bar
-        /// x not in lst
-        /// ```
-        Yes = 1,
-    }
-);
-
-/// Specifies if a slice is built with either 2 or 3 arguments.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum BuildSliceArgCount {
-    /// ```py
-    /// x[5:10]
-    /// ```
-    Two,
-    /// ```py
-    /// x[5:10:2]
-    /// ```
-    Three,
-}
-
-impl OpArgType for BuildSliceArgCount {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(match x {
-            2 => Self::Two,
-            3 => Self::Three,
-            _ => return None,
-        })
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from(self.argc().get())
-    }
-}
-
-impl BuildSliceArgCount {
-    /// Get the numeric value of `Self`.
-    #[must_use]
-    pub const fn argc(self) -> NonZeroU8 {
-        let inner = match self {
-            Self::Two => 2,
-            Self::Three => 3,
-        };
-        // Safety: `inner` can be either 2 or 3.
-        unsafe { NonZeroU8::new_unchecked(inner) }
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct UnpackExArgs {
-    pub before: u8,
-    pub after: u8,
-}
-
-impl OpArgType for UnpackExArgs {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        let [before, after, ..] = x.to_le_bytes();
-        Some(Self { before, after })
-    }
-
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from_le_bytes([self.before, self.after, 0, 0])
-    }
-}
-
-impl fmt::Display for UnpackExArgs {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "before: {}, after: {}", self.before, self.after)
-    }
-}
-
 /*
 Maintain a stack of blocks on the VM.
 pub enum BlockType {
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index c41da105a3d..07464f375cb 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -1,12 +1,13 @@
-use alloc::fmt;
-use std::mem;
+use core::{fmt, marker::PhantomData, mem};
 
 use crate::{
     bytecode::{
-        Arg, BinaryOperator, BorrowedConstant, BuildSliceArgCount, ComparisonOperator, Constant,
-        ConvertValueOparg, InstrDisplayContext, IntrinsicFunction1, IntrinsicFunction2, Invert,
-        Label, MakeFunctionFlags, NameIdx, OpArg, RaiseKind, UnpackExArgs, decode_load_attr_arg,
-        decode_load_super_attr_arg,
+        BorrowedConstant, Constant, InstrDisplayContext, decode_load_attr_arg,
+        oparg::{
+            BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
+            IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx,
+            OpArg, OpArgByte, OpArgType, RaiseKind, UnpackExArgs,
+        },
     },
     marshal::MarshalError,
 };
@@ -861,3 +862,73 @@ impl Instruction {
         }
     }
 }
+
+#[derive(Copy, Clone)]
+pub struct Arg<T: OpArgType>(PhantomData<T>);
+
+impl<T: OpArgType> Arg<T> {
+    #[inline]
+    pub const fn marker() -> Self {
+        Self(PhantomData)
+    }
+
+    #[inline]
+    pub fn new(arg: T) -> (Self, OpArg) {
+        (Self(PhantomData), OpArg(arg.to_op_arg()))
+    }
+
+    #[inline]
+    pub fn new_single(arg: T) -> (Self, OpArgByte)
+    where
+        T: Into<u8>,
+    {
+        (Self(PhantomData), OpArgByte(arg.into()))
+    }
+
+    #[inline(always)]
+    pub fn get(self, arg: OpArg) -> T {
+        self.try_get(arg).unwrap()
+    }
+
+    #[inline(always)]
+    pub fn try_get(self, arg: OpArg) -> Option<T> {
+        T::from_op_arg(arg.0)
+    }
+
+    /// # Safety
+    /// T::from_op_arg(self) must succeed
+    #[inline(always)]
+    pub unsafe fn get_unchecked(self, arg: OpArg) -> T {
+        // SAFETY: requirements forwarded from caller
+        unsafe { T::from_op_arg(arg.0).unwrap_unchecked() }
+    }
+}
+
+impl<T: OpArgType> PartialEq for Arg<T> {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+impl<T: OpArgType> Eq for Arg<T> {}
+
+impl<T: OpArgType> fmt::Debug for Arg<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Arg<{}>", core::any::type_name::<T>())
+    }
+}
+
+/// Encode LOAD_SUPER_ATTR oparg: bit 0 = load_method, bit 1 = has_class, bits 2+ = name index.
+#[inline]
+pub const fn encode_load_super_attr_arg(name_idx: u32, load_method: bool, has_class: bool) -> u32 {
+    (name_idx << 2) | ((has_class as u32) << 1) | (load_method as u32)
+}
+
+/// Decode LOAD_SUPER_ATTR oparg: returns (name_idx, load_method, has_class).
+#[inline]
+pub const fn decode_load_super_attr_arg(oparg: u32) -> (u32, bool, bool) {
+    let load_method = (oparg & 1) == 1;
+    let has_class = (oparg & 2) == 2;
+    let name_idx = oparg >> 2;
+    (name_idx, load_method, has_class)
+}
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
new file mode 100644
index 00000000000..ba8a8eb1f25
--- /dev/null
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -0,0 +1,582 @@
+use bitflags::bitflags;
+
+use core::{fmt, num::NonZeroU8};
+
+use crate::bytecode::{CodeUnit, instruction::Instruction};
+
+pub trait OpArgType: Copy {
+    fn from_op_arg(x: u32) -> Option<Self>;
+
+    fn to_op_arg(self) -> u32;
+}
+
+/// Opcode argument that may be extended by a prior ExtendedArg.
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct OpArgByte(pub u8);
+
+impl OpArgByte {
+    pub const fn null() -> Self {
+        Self(0)
+    }
+}
+
+impl From<u8> for OpArgByte {
+    fn from(raw: u8) -> Self {
+        Self(raw)
+    }
+}
+
+impl fmt::Debug for OpArgByte {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+/// Full 32-bit op_arg, including any possible ExtendedArg extension.
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)]
+pub struct OpArg(pub u32);
+
+impl OpArg {
+    pub const fn null() -> Self {
+        Self(0)
+    }
+
+    /// Returns how many CodeUnits a instruction with this op_arg will be encoded as
+    #[inline]
+    pub const fn instr_size(self) -> usize {
+        (self.0 > 0xff) as usize + (self.0 > 0xff_ff) as usize + (self.0 > 0xff_ff_ff) as usize + 1
+    }
+
+    /// returns the arg split into any necessary ExtendedArg components (in big-endian order) and
+    /// the arg for the real opcode itself
+    #[inline(always)]
+    pub fn split(self) -> (impl ExactSizeIterator<Item = OpArgByte>, OpArgByte) {
+        let mut it = self
+            .0
+            .to_le_bytes()
+            .map(OpArgByte)
+            .into_iter()
+            .take(self.instr_size());
+        let lo = it.next().unwrap();
+        (it.rev(), lo)
+    }
+}
+
+impl From<u32> for OpArg {
+    fn from(raw: u32) -> Self {
+        Self(raw)
+    }
+}
+
+#[derive(Default, Copy, Clone)]
+#[repr(transparent)]
+pub struct OpArgState {
+    state: u32,
+}
+
+impl OpArgState {
+    #[inline(always)]
+    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
+        let arg = self.extend(ins.arg);
+        if ins.op != Instruction::ExtendedArg {
+            self.reset();
+        }
+        (ins.op, arg)
+    }
+
+    #[inline(always)]
+    pub fn extend(&mut self, arg: OpArgByte) -> OpArg {
+        self.state = (self.state << 8) | u32::from(arg.0);
+        OpArg(self.state)
+    }
+
+    #[inline(always)]
+    pub const fn reset(&mut self) {
+        self.state = 0
+    }
+}
+
+/// Oparg values for [`Instruction::ConvertValue`].
+///
+/// ## See also
+///
+/// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum ConvertValueOparg {
+    /// No conversion.
+    ///
+    /// ```python
+    /// f"{x}"
+    /// f"{x:4}"
+    /// ```
+    None = 0,
+    /// Converts by calling `str(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!s}"
+    /// f"{x!s:2}"
+    /// ```
+    Str = 1,
+    /// Converts by calling `repr(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!r}"
+    /// f"{x!r:2}"
+    /// ```
+    Repr = 2,
+    /// Converts by calling `ascii(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!a}"
+    /// f"{x!a:2}"
+    /// ```
+    Ascii = 3,
+}
+
+impl fmt::Display for ConvertValueOparg {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let out = match self {
+            Self::Str => "1 (str)",
+            Self::Repr => "2 (repr)",
+            Self::Ascii => "3 (ascii)",
+            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            Self::None => "",
+        };
+
+        write!(f, "{out}")
+    }
+}
+
+impl OpArgType for ConvertValueOparg {
+    #[inline]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(match x {
+            // Ruff `ConversionFlag::None` is `-1i8`,
+            // when its converted to `u8` its value is `u8::MAX`
+            0 | 255 => Self::None,
+            1 => Self::Str,
+            2 => Self::Repr,
+            3 => Self::Ascii,
+            _ => return None,
+        })
+    }
+
+    #[inline]
+    fn to_op_arg(self) -> u32 {
+        self as u32
+    }
+}
+
+/// Resume type for the RESUME instruction
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[repr(u32)]
+pub enum ResumeType {
+    AtFuncStart = 0,
+    AfterYield = 1,
+    AfterYieldFrom = 2,
+    AfterAwait = 3,
+}
+
+impl OpArgType for u32 {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(x)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self
+    }
+}
+
+impl OpArgType for bool {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(x != 0)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self as u32
+    }
+}
+
+macro_rules! op_arg_enum_impl {
+    (enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
+        impl OpArgType for $name {
+            fn to_op_arg(self) -> u32 {
+                self as u32
+            }
+
+            fn from_op_arg(x: u32) -> Option<Self> {
+                Some(match u8::try_from(x).ok()? {
+                    $($value => Self::$var,)*
+                    _ => return None,
+                })
+            }
+        }
+    };
+}
+
+macro_rules! op_arg_enum {
+    ($(#[$attr:meta])* $vis:vis enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
+        $(#[$attr])*
+        $vis enum $name {
+            $($(#[$var_attr])* $var = $value,)*
+        }
+
+        op_arg_enum_impl!(enum $name {
+            $($(#[$var_attr])* $var = $value,)*
+        });
+    };
+}
+
+pub type NameIdx = u32;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+#[repr(transparent)]
+pub struct Label(pub u32);
+
+impl OpArgType for Label {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(Self(x))
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self.0
+    }
+}
+
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+op_arg_enum!(
+    /// The kind of Raise that occurred.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum RaiseKind {
+        /// Bare `raise` statement with no arguments.
+        /// Gets the current exception from VM state (topmost_exception).
+        /// Maps to RAISE_VARARGS with oparg=0.
+        BareRaise = 0,
+        /// `raise exc` - exception is on the stack.
+        /// Maps to RAISE_VARARGS with oparg=1.
+        Raise = 1,
+        /// `raise exc from cause` - exception and cause are on the stack.
+        /// Maps to RAISE_VARARGS with oparg=2.
+        RaiseCause = 2,
+        /// Reraise exception from the stack top.
+        /// Used in exception handler cleanup blocks (finally, except).
+        /// Gets exception from stack, not from VM state.
+        /// Maps to the RERAISE opcode.
+        ReraiseFromStack = 3,
+    }
+);
+
+op_arg_enum!(
+    /// Intrinsic function for CALL_INTRINSIC_1
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum IntrinsicFunction1 {
+        // Invalid = 0,
+        Print = 1,
+        /// Import * operation
+        ImportStar = 2,
+        // StopIterationError = 3,
+        // AsyncGenWrap = 4,
+        UnaryPositive = 5,
+        /// Convert list to tuple
+        ListToTuple = 6,
+        /// Type parameter related
+        TypeVar = 7,
+        ParamSpec = 8,
+        TypeVarTuple = 9,
+        /// Generic subscript for PEP 695
+        SubscriptGeneric = 10,
+        TypeAlias = 11,
+    }
+);
+
+op_arg_enum!(
+    /// Intrinsic function for CALL_INTRINSIC_2
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum IntrinsicFunction2 {
+        PrepReraiseStar = 1,
+        TypeVarWithBound = 2,
+        TypeVarWithConstraint = 3,
+        SetFunctionTypeParams = 4,
+        /// Set default value for type parameter (PEP 695)
+        SetTypeparamDefault = 5,
+    }
+);
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct MakeFunctionFlags: u8 {
+        const CLOSURE = 0x01;
+        const ANNOTATIONS = 0x02;
+        const KW_ONLY_DEFAULTS = 0x04;
+        const DEFAULTS = 0x08;
+        const TYPE_PARAMS = 0x10;
+    }
+}
+
+impl OpArgType for MakeFunctionFlags {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Self::from_bits(x as u8)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self.bits().into()
+    }
+}
+
+op_arg_enum!(
+    /// The possible comparison operators
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum ComparisonOperator {
+        // be intentional with bits so that we can do eval_ord with just a bitwise and
+        // bits: | Equal | Greater | Less |
+        Less = 0b001,
+        Greater = 0b010,
+        NotEqual = 0b011,
+        Equal = 0b100,
+        LessOrEqual = 0b101,
+        GreaterOrEqual = 0b110,
+    }
+);
+
+op_arg_enum!(
+    /// The possible Binary operators
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// let (op, _) = Arg::new(BinaryOperator::Add);
+    /// let instruction = Instruction::BinaryOp { op };
+    /// ```
+    ///
+    /// See also:
+    /// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
+    #[repr(u8)]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    pub enum BinaryOperator {
+        /// `+`
+        Add = 0,
+        /// `&`
+        And = 1,
+        /// `//`
+        FloorDivide = 2,
+        /// `<<`
+        Lshift = 3,
+        /// `@`
+        MatrixMultiply = 4,
+        /// `*`
+        Multiply = 5,
+        /// `%`
+        Remainder = 6,
+        /// `|`
+        Or = 7,
+        /// `**`
+        Power = 8,
+        /// `>>`
+        Rshift = 9,
+        /// `-`
+        Subtract = 10,
+        /// `/`
+        TrueDivide = 11,
+        /// `^`
+        Xor = 12,
+        /// `+=`
+        InplaceAdd = 13,
+        /// `&=`
+        InplaceAnd = 14,
+        /// `//=`
+        InplaceFloorDivide = 15,
+        /// `<<=`
+        InplaceLshift = 16,
+        /// `@=`
+        InplaceMatrixMultiply = 17,
+        /// `*=`
+        InplaceMultiply = 18,
+        /// `%=`
+        InplaceRemainder = 19,
+        /// `|=`
+        InplaceOr = 20,
+        /// `**=`
+        InplacePower = 21,
+        /// `>>=`
+        InplaceRshift = 22,
+        /// `-=`
+        InplaceSubtract = 23,
+        /// `/=`
+        InplaceTrueDivide = 24,
+        /// `^=`
+        InplaceXor = 25,
+    }
+);
+
+impl BinaryOperator {
+    /// Get the "inplace" version of the operator.
+    /// This has no effect if `self` is already an "inplace" operator.
+    ///
+    /// # Example
+    /// ```rust
+    /// use rustpython_compiler_core::bytecode::BinaryOperator;
+    ///
+    /// assert_eq!(BinaryOperator::Power.as_inplace(), BinaryOperator::InplacePower);
+    ///
+    /// assert_eq!(BinaryOperator::InplaceSubtract.as_inplace(), BinaryOperator::InplaceSubtract);
+    /// ```
+    #[must_use]
+    pub const fn as_inplace(self) -> Self {
+        match self {
+            Self::Add => Self::InplaceAdd,
+            Self::And => Self::InplaceAnd,
+            Self::FloorDivide => Self::InplaceFloorDivide,
+            Self::Lshift => Self::InplaceLshift,
+            Self::MatrixMultiply => Self::InplaceMatrixMultiply,
+            Self::Multiply => Self::InplaceMultiply,
+            Self::Remainder => Self::InplaceRemainder,
+            Self::Or => Self::InplaceOr,
+            Self::Power => Self::InplacePower,
+            Self::Rshift => Self::InplaceRshift,
+            Self::Subtract => Self::InplaceSubtract,
+            Self::TrueDivide => Self::InplaceTrueDivide,
+            Self::Xor => Self::InplaceXor,
+            _ => self,
+        }
+    }
+}
+
+impl fmt::Display for BinaryOperator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let op = match self {
+            Self::Add => "+",
+            Self::And => "&",
+            Self::FloorDivide => "//",
+            Self::Lshift => "<<",
+            Self::MatrixMultiply => "@",
+            Self::Multiply => "*",
+            Self::Remainder => "%",
+            Self::Or => "|",
+            Self::Power => "**",
+            Self::Rshift => ">>",
+            Self::Subtract => "-",
+            Self::TrueDivide => "/",
+            Self::Xor => "^",
+            Self::InplaceAdd => "+=",
+            Self::InplaceAnd => "&=",
+            Self::InplaceFloorDivide => "//=",
+            Self::InplaceLshift => "<<=",
+            Self::InplaceMatrixMultiply => "@=",
+            Self::InplaceMultiply => "*=",
+            Self::InplaceRemainder => "%=",
+            Self::InplaceOr => "|=",
+            Self::InplacePower => "**=",
+            Self::InplaceRshift => ">>=",
+            Self::InplaceSubtract => "-=",
+            Self::InplaceTrueDivide => "/=",
+            Self::InplaceXor => "^=",
+        };
+        write!(f, "{op}")
+    }
+}
+
+op_arg_enum!(
+    /// Whether or not to invert the operation.
+    #[repr(u8)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Invert {
+        /// ```py
+        /// foo is bar
+        /// x in lst
+        /// ```
+        No = 0,
+        /// ```py
+        /// foo is not bar
+        /// x not in lst
+        /// ```
+        Yes = 1,
+    }
+);
+
+/// Specifies if a slice is built with either 2 or 3 arguments.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum BuildSliceArgCount {
+    /// ```py
+    /// x[5:10]
+    /// ```
+    Two,
+    /// ```py
+    /// x[5:10:2]
+    /// ```
+    Three,
+}
+
+impl OpArgType for BuildSliceArgCount {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(match x {
+            2 => Self::Two,
+            3 => Self::Three,
+            _ => return None,
+        })
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        u32::from(self.argc().get())
+    }
+}
+
+impl BuildSliceArgCount {
+    /// Get the numeric value of `Self`.
+    #[must_use]
+    pub const fn argc(self) -> NonZeroU8 {
+        let inner = match self {
+            Self::Two => 2,
+            Self::Three => 3,
+        };
+        // Safety: `inner` can be either 2 or 3.
+        unsafe { NonZeroU8::new_unchecked(inner) }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct UnpackExArgs {
+    pub before: u8,
+    pub after: u8,
+}
+
+impl OpArgType for UnpackExArgs {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        let [before, after, ..] = x.to_le_bytes();
+        Some(Self { before, after })
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        u32::from_le_bytes([self.before, self.after, 0, 0])
+    }
+}
+
+impl fmt::Display for UnpackExArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "before: {}, after: {}", self.before, self.after)
+    }
+}

From 49e6931c7edc71688b3d2c3cda43d307b682545a Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Wed, 14 Jan 2026 09:14:05 +0900
Subject: [PATCH 284/418] Introduce flame_guard in rustpython-stdlib too
 (#6722)

---
 Cargo.lock                  | 1 +
 Cargo.toml                  | 2 +-
 crates/stdlib/Cargo.toml    | 2 ++
 crates/stdlib/src/json.rs   | 4 ++++
 crates/stdlib/src/lib.rs    | 3 +++
 crates/stdlib/src/macros.rs | 7 +++++++
 6 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 crates/stdlib/src/macros.rs

diff --git a/Cargo.lock b/Cargo.lock
index 79681b880ed..b3ff4cf6656 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3160,6 +3160,7 @@ dependencies = [
  "digest",
  "dns-lookup",
  "dyn-clone",
+ "flame",
  "flate2",
  "foreign-types-shared",
  "gethostname",
diff --git a/Cargo.toml b/Cargo.toml
index 96e821e977c..083358cf749 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ importlib = ["rustpython-vm/importlib"]
 encodings = ["rustpython-vm/encodings"]
 stdio = ["rustpython-vm/stdio"]
 stdlib = ["rustpython-stdlib", "rustpython-pylib", "encodings"]
-flame-it = ["rustpython-vm/flame-it", "flame", "flamescope"]
+flame-it = ["rustpython-vm/flame-it", "rustpython-stdlib/flame-it", "flame", "flamescope"]
 freeze-stdlib = ["stdlib", "rustpython-vm/freeze-stdlib", "rustpython-pylib?/freeze-stdlib"]
 jit = ["rustpython-vm/jit"]
 threading = ["rustpython-vm/threading", "rustpython-stdlib/threading"]
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
index 232022452aa..e45a0eed15c 100644
--- a/crates/stdlib/Cargo.toml
+++ b/crates/stdlib/Cargo.toml
@@ -22,6 +22,7 @@ ssl-rustls-fips = ["ssl-rustls", "aws-lc-rs/fips"]
 ssl-openssl = ["ssl", "openssl", "openssl-sys", "foreign-types-shared", "openssl-probe"]
 ssl-vendor = ["ssl-openssl", "openssl/vendored"]
 tkinter = ["dep:tk-sys", "dep:tcl-sys", "dep:widestring"]
+flame-it = ["flame"]
 
 [dependencies]
 # rustpython crates
@@ -33,6 +34,7 @@ ahash = { workspace = true }
 ascii = { workspace = true }
 cfg-if = { workspace = true }
 crossbeam-utils = { workspace = true }
+flame = { workspace = true, optional = true }
 hex = { workspace = true }
 itertools = { workspace = true }
 indexmap = { workspace = true }
diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
index a3fd7972126..cc98ad912cc 100644
--- a/crates/stdlib/src/json.rs
+++ b/crates/stdlib/src/json.rs
@@ -74,6 +74,7 @@ mod _json {
             scan_once: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyIterReturn> {
+            flame_guard!("JsonScanner::parse");
             let c = match s.chars().next() {
                 Some(c) => c,
                 None => {
@@ -153,6 +154,7 @@ mod _json {
         }
 
         fn parse_number(&self, s: &str, vm: &VirtualMachine) -> Option<(PyResult, usize)> {
+            flame_guard!("JsonScanner::parse_number");
             let mut has_neg = false;
             let mut has_decimal = false;
             let mut has_exponent = false;
@@ -213,6 +215,7 @@ mod _json {
     }
 
     fn encode_string(s: &str, ascii_only: bool) -> String {
+        flame_guard!("_json::encode_string");
         let mut buf = Vec::<u8>::with_capacity(s.len() + 2);
         machinery::write_json_string(s, ascii_only, &mut buf)
             // SAFETY: writing to a vec can't fail
@@ -253,6 +256,7 @@ mod _json {
         strict: OptionalArg<bool>,
         vm: &VirtualMachine,
     ) -> PyResult<(Wtf8Buf, usize)> {
+        flame_guard!("_json::scanstring");
         machinery::scanstring(s.as_wtf8(), end, strict.unwrap_or(true))
             .map_err(|e| py_decode_error(e, s, vm))
     }
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
index 567c584d85b..dc9bad4bd2f 100644
--- a/crates/stdlib/src/lib.rs
+++ b/crates/stdlib/src/lib.rs
@@ -8,6 +8,9 @@
 extern crate rustpython_derive;
 extern crate alloc;
 
+#[macro_use]
+pub(crate) mod macros;
+
 pub mod array;
 mod binascii;
 mod bisect;
diff --git a/crates/stdlib/src/macros.rs b/crates/stdlib/src/macros.rs
new file mode 100644
index 00000000000..385f4b1c4ab
--- /dev/null
+++ b/crates/stdlib/src/macros.rs
@@ -0,0 +1,7 @@
+#[macro_export]
+macro_rules! flame_guard {
+    ($name:expr) => {
+        #[cfg(feature = "flame-it")]
+        let _guard = ::flame::start_guard($name);
+    };
+}

From 6cb763a332c897ee39fc0f0052ce2c703d4026ad Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Wed, 14 Jan 2026 13:28:25 +0900
Subject: [PATCH 285/418] Fix some parts of cron-ci workflow (#6724)

* Use shared PYTHON_VERSION in cron-ci benchmark job

* Correct extra-tests/jsontests.py script

When the `extra_tests/jsontests.py` script was added, it was presumably during
the time when Python versions 3.5 to 3.8 were in use. At that time,
`test.libregrtest.runtest` was a valid path, but from CPython version 3.11
onwards, the path changed to `test.libregrtest.findtests`.

* Use ssl-rustls feature instead of ssl in cron-ci workflow

Replace the ssl feature with ssl-rustls in both the CARGO_ARGS
environment variable and the cargo-llvm-cov test command to fix
the cron-ci workflow.

Since 1a783fc9ec16bd824967449bc9899661a5ee5761, it is disallowed
to use ssl manually.

* Replace inspect.getargspec with inspect.getfullargspec in custom_text_test_runner

inspect.getargspec() was removed in Python 3.11, causing jsontests.py to
fail with "TypeError: 'NoneType' object is not iterable" when running on
RustPython (which targets Python 3.13).

The get_function_args() function was silently catching the AttributeError
and returning None, which then caused the error in store_class_fields()
when trying to iterate over None.

> https://docs.python.org/3/whatsnew/3.11.html
> The getargspec() function, deprecated since Python 3.0; use
> inspect.signature() or inspect.getfullargspec() instead.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Exclude rustpython-venvlauncher in cron-ci workflow

Since rustpython-venvlauncher is Windows-only,
it disables the project in the cron-ci workflow.

* Apply suggestion from @fanninpm

Co-authored-by: fanninpm <luxverdans@sbcglobal.net>

* Trigger cron-ci workflow in pull_request

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
Co-authored-by: Jeong, YunWon <69878+youknowone@users.noreply.github.com>
Co-authored-by: fanninpm <luxverdans@sbcglobal.net>
---
 .github/workflows/cron-ci.yaml         | 13 ++++++++++---
 extra_tests/custom_text_test_runner.py |  2 +-
 extra_tests/jsontests.py               |  2 +-
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index 59d664e0ea1..d48c5e4cfeb 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -5,11 +5,14 @@ on:
   push:
     paths:
       - .github/workflows/cron-ci.yaml
+  pull_request:
+    paths:
+      - .github/workflows/cron-ci.yaml
 
 name: Periodic checks/tasks
 
 env:
-  CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl,jit
+  CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
   PYTHON_VERSION: "3.13.1"
 
 jobs:
@@ -29,7 +32,7 @@ jobs:
           python-version: ${{ env.PYTHON_VERSION }}
       - run: sudo apt-get update && sudo apt-get -y install lcov
       - name: Run cargo-llvm-cov with Rust tests.
-        run: cargo llvm-cov --no-report --workspace --exclude rustpython_wasm --verbose --no-default-features --features stdlib,importlib,encodings,ssl,jit
+        run: cargo llvm-cov --no-report --workspace --exclude rustpython_wasm --exclude rustpython-compiler-source --exclude rustpython-venvlauncher --verbose --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
       - name: Run cargo-llvm-cov with Python snippets.
         run: python scripts/cargo-llvm-cov.py
         continue-on-error: true
@@ -39,6 +42,7 @@ jobs:
       - name: Prepare code coverage data
         run: cargo llvm-cov report --lcov --output-path='codecov.lcov'
       - name: Upload to Codecov
+        if: ${{ github.event_name != 'pull_request' }}
         uses: codecov/codecov-action@v5
         with:
           file: ./codecov.lcov
@@ -58,6 +62,7 @@ jobs:
         env:
           RUSTPYTHONPATH: ${{ github.workspace }}/Lib
       - name: upload tests data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
           GITHUB_ACTOR: ${{ github.actor }}
@@ -94,6 +99,7 @@ jobs:
         env:
           RUSTPYTHONPATH: ${{ github.workspace }}/Lib
       - name: Upload data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
           GITHUB_ACTOR: ${{ github.actor }}
@@ -141,7 +147,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - uses: actions/setup-python@v6.1.0
         with:
-          python-version: 3.9
+          python-version: ${{ env.PYTHON_VERSION }}
       - run: cargo install cargo-criterion
       - name: build benchmarks
         run: cargo build --release --benches
@@ -162,6 +168,7 @@ jobs:
           mv reports/* .
           rmdir reports
       - name: upload benchmark data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
         run: |
diff --git a/extra_tests/custom_text_test_runner.py b/extra_tests/custom_text_test_runner.py
index 018121f0da4..afec493a66c 100644
--- a/extra_tests/custom_text_test_runner.py
+++ b/extra_tests/custom_text_test_runner.py
@@ -112,7 +112,7 @@ def __call__(self, data_list, totals=None):
 
 def get_function_args(func_ref):
     try:
-        return [p for p in inspect.getargspec(func_ref).args if p != "self"]
+        return [p for p in inspect.getfullargspec(func_ref).args if p != "self"]
     except:
         return None
 
diff --git a/extra_tests/jsontests.py b/extra_tests/jsontests.py
index c1f92509fe7..f3213ac09d1 100644
--- a/extra_tests/jsontests.py
+++ b/extra_tests/jsontests.py
@@ -2,7 +2,7 @@
 import unittest
 
 from custom_text_test_runner import CustomTextTestRunner as Runner
-from test.libregrtest.runtest import findtests
+from test.libregrtest.findtests import findtests
 
 testnames = findtests()
 # idk why this fixes the hanging, if it does

From 2e5257d098fe4bd880aacd8331e6161cfe32550d Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Wed, 14 Jan 2026 14:44:34 +0900
Subject: [PATCH 286/418] Introduce benchmark for json.loads (#6723)

---
 benches/_data/pypi_org__simple__psutil.json | 1 +
 benches/benchmarks/json_loads.py            | 7 +++++++
 2 files changed, 8 insertions(+)
 create mode 100644 benches/_data/pypi_org__simple__psutil.json
 create mode 100644 benches/benchmarks/json_loads.py

diff --git a/benches/_data/pypi_org__simple__psutil.json b/benches/_data/pypi_org__simple__psutil.json
new file mode 100644
index 00000000000..91e2ff6b39e
--- /dev/null
+++ b/benches/_data/pypi_org__simple__psutil.json
@@ -0,0 +1 @@
+{"alternate-locations":[],"files":[{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.1.tar.gz","hashes":{"sha256":"25c6caffbf00d8be77489391a784654e99fcbaf2a5278e80f748be4112ee0188"},"provenance":null,"requires-python":null,"size":44485,"upload-time":"2014-02-06T02:06:57.249874Z","url":"https://files.pythonhosted.org/packages/69/e4/7e36e3e6cbc83b76f1c93a63d4c053a03ca99f1c99b106835cb175b5932a/psutil-0.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.2.tar.gz","hashes":{"sha256":"4a13d7f760b043b263346e48823b1dfd4c202e97b23483e481e5ff696e74509e"},"provenance":null,"requires-python":null,"size":61640,"upload-time":"2014-02-06T02:06:51.674389Z","url":"https://files.pythonhosted.org/packages/6e/51/56198d83577106bf89cb23bffcb273f923aea8d5ffe03e3fce55f830c323/psutil-0.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.3.tar.gz","hashes":{"sha256":"43e327934b4a273da20d3a5797d6abcaab37914f61499d96fcf9e8e1ae75442b"},"provenance":null,"requires-python":null,"size":85749,"upload-time":"2014-02-06T02:06:45.294070Z","url":"https://files.pythonhosted.org/packages/1d/4f/dcfe500fd43e3d6b26d253cb0d7e6e3a7d80224b5059bd50c482aff62eef/psutil-0.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.tar.gz","hashes":{"sha256":"8de8efa92162c94f623297f522e440e818dc7b832f421f9f490324bc7d5d0d92"},"provenance":null,"requires-python":null,"size":129382,"upload-time":"2014-02-06T02:03:03.376283Z","url":"https://files.pythonhosted.org/packages/58/20/3457e441edc1625c6e1dbfcf780d2b22f2e9caa8606c3fd8ce6c48104e87/psutil-0.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"4ce48cbbe3c915a9b720ce6465da34ce79465ffde63de8254cc9c8235fef824d"},"provenance":null,"requires-python":null,"size":291186,"upload-time":"2014-02-06T16:48:27.727869Z","url":"https://files.pythonhosted.org/packages/e6/1d/9a90eec0aec7e015d16f3922328336b4f8cd783f782e9ab81146b47ffee3/psutil-0.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"eeba1fa1f2455219a05775044f7a76741252ea0bd4c762e7b652d281843c79ff"},"provenance":null,"requires-python":null,"size":289973,"upload-time":"2014-02-06T16:48:36.482056Z","url":"https://files.pythonhosted.org/packages/1d/75/7c67bc2c8304b137a8ff709d21cb2dd7f600bc5ee76ecc88f77ec008e69e/psutil-0.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"919dabb5d47dc769a198a5d015c6765ef39b3b920c2ab6d04d05d9aa3ae6bb67"},"provenance":null,"requires-python":null,"size":289890,"upload-time":"2014-02-06T16:48:46.485205Z","url":"https://files.pythonhosted.org/packages/e0/e4/2ec24cecccf111a4dbda892b484bdfd8c00d3da5f99c1a0a79c469c62fb2/psutil-0.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.5.exe","hashes":{"sha256":"92f51445439f1082dab7733b9150b594b3797f4c96578457768c3e761f86c240"},"provenance":null,"requires-python":null,"size":129555,"upload-time":"2014-02-06T16:47:42.630117Z","url":"https://files.pythonhosted.org/packages/04/4f/478408899102af1d0d877be0b67e302fada1bdd8c8faaa4adc0e19550e53/psutil-0.2.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.6.exe","hashes":{"sha256":"c3e3dc863834d03485f6c48a735f76ab9a7cff2911d101c8cbd1e553c03f0fae"},"provenance":null,"requires-python":null,"size":262087,"upload-time":"2014-02-06T16:47:50.995531Z","url":"https://files.pythonhosted.org/packages/d7/f9/984326888f6c519cc813a96640cc9a2900dad85e15b9d368fe1f12a9bd11/psutil-0.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.7.exe","hashes":{"sha256":"08c6f16ac00babe2c54067dbc305c0587cb896a8eb64383290cdafdba74ea123"},"provenance":null,"requires-python":null,"size":261605,"upload-time":"2014-02-06T16:47:58.286157Z","url":"https://files.pythonhosted.org/packages/69/5c/be56c645a254ad83a9aa3055564aae543fdf23186aa5ec9c495a3937300b/psutil-0.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py3.3.exe","hashes":{"sha256":"e1f7cf0158a94e6b50f9a4b6f4258dec1bd89c9485c65d54b89ba2a09f0d51a3"},"provenance":null,"requires-python":null,"size":256763,"upload-time":"2014-02-06T16:48:06.663656Z","url":"https://files.pythonhosted.org/packages/76/42/d6813ce55af42553b2a3136e5159bd71e544bda5fdaed04c72759514e375/psutil-0.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py3.4.exe","hashes":{"sha256":"e49d818a4a49fd1ced40dac31076af622a40407234f717bc6a5c39b3f2335e81"},"provenance":null,"requires-python":null,"size":256718,"upload-time":"2014-02-06T16:48:16.971617Z","url":"https://files.pythonhosted.org/packages/f5/83/45b721a52001c1ba1f196e6b2ba3b12d99cbc03bf3f508f1fe56b4e25c66/psutil-0.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.tar.gz","hashes":{"sha256":"bd33f5f9e04b7677a932cc90d541ceec0050080d1b053ed39488ef39cb0fb4f4"},"provenance":null,"requires-python":null,"size":144657,"upload-time":"2014-02-06T02:06:37.338565Z","url":"https://files.pythonhosted.org/packages/9b/62/03133a1b4d1439227bc9b27389fc7d1137d111cbb15197094225967e21cf/psutil-0.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"ab9d06c0c2a7baadebf66fbc74a2532520b3b6d4a58ba3c1f04311a175ed9e7f"},"provenance":null,"requires-python":null,"size":294651,"upload-time":"2014-02-06T16:46:46.406386Z","url":"https://files.pythonhosted.org/packages/55/3e/e49b7929b9daf9c3dcf31668a43ba669d22bb8606deca52e6f92cb67324d/psutil-0.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"076c9914d8aadccd459e3efedc49c10f14d16918d0af5735c22a2bdcc3f90cac"},"provenance":null,"requires-python":null,"size":293431,"upload-time":"2014-02-06T16:46:54.986513Z","url":"https://files.pythonhosted.org/packages/34/f5/f471c56be91d10c9b83d22aa9f6f29006437f2196c89156f00f56f6e4661/psutil-0.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"2679f8f9f20e61d85177f3fc6ee10bfbd6c4bd122b3f5774ba36d0035cac4f7a"},"provenance":null,"requires-python":null,"size":293352,"upload-time":"2014-02-06T16:47:04.453988Z","url":"https://files.pythonhosted.org/packages/68/ee/fc85a707394d1b374da61c071dee12299e779d87c09a86c727b6f30ad9a6/psutil-0.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.5.exe","hashes":{"sha256":"a8345934d7585c75d500098491f2a434dbba9e378fd908d76fbeb0bc20b8a3d3"},"provenance":null,"requires-python":null,"size":132806,"upload-time":"2014-02-06T16:46:02.328109Z","url":"https://files.pythonhosted.org/packages/ca/6e/5c0a87e2c1bac5e32471eb84b349f0808f6d6ed49b9118784af9d0e71baa/psutil-0.2.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.6.exe","hashes":{"sha256":"9b6294c3327625839fdbe92dca4093ab55e422fb348790b2ffc5c6cde163fe5b"},"provenance":null,"requires-python":null,"size":265263,"upload-time":"2014-02-06T16:46:11.006069Z","url":"https://files.pythonhosted.org/packages/e5/13/b358b509d4996df82ef77758c14c0999c443df537eefacc7bb24b6339758/psutil-0.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.7.exe","hashes":{"sha256":"ac4d86abc4c850141cd1e054a64f1fcb6977c4ccbbd65c5bac9bf9c8c5950cb1"},"provenance":null,"requires-python":null,"size":264780,"upload-time":"2014-02-06T16:46:19.079623Z","url":"https://files.pythonhosted.org/packages/a9/1e/8ad399f44f63de6de262fc503b1d3f091f6a9b22feaf3c273ee8bb7a7c38/psutil-0.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py3.3.exe","hashes":{"sha256":"60048c47698aa20936b7593636dd88454bae6c436852aef95fb9774b0551d06c"},"provenance":null,"requires-python":null,"size":259950,"upload-time":"2014-02-06T16:46:28.163437Z","url":"https://files.pythonhosted.org/packages/75/f3/296f43c033c0453ebfdf125dc9b8907193e31ffb92256e4b702d16ef8ac1/psutil-0.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py3.4.exe","hashes":{"sha256":"4aad401c1a45848107d395f97fc9cdb783acf120553ca1761dd77a7d52adb585"},"provenance":null,"requires-python":null,"size":259910,"upload-time":"2014-02-06T16:46:37.546918Z","url":"https://files.pythonhosted.org/packages/ae/8c/751f1e2fdcaa0ea817a8529468dca052b5de55033ee8539b996497b5be0e/psutil-0.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.tar.gz","hashes":{"sha256":"d70e16e60a575637f9d75a1005a8987d239700c0955134d4c8666a5aefbe16b8"},"provenance":null,"requires-python":null,"size":153990,"upload-time":"2014-02-06T02:06:31.022178Z","url":"https://files.pythonhosted.org/packages/f2/5c/4e74b08905dab9474a53534507e463fe8eec98b2fc0d29964b0c6a7f959d/psutil-0.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"a554abcd10534ff32e3cbc4bd80b3c76a73d0bbb50739ee59482f0151703828b"},"provenance":null,"requires-python":null,"size":297305,"upload-time":"2014-02-06T16:45:05.336122Z","url":"https://files.pythonhosted.org/packages/78/91/21944fbddafa1bdf7c0c0ed7d9f4043cd8470e36a1f7a9f6e8b4406a8e39/psutil-0.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"b33444731c63361ac316657bb305642e562097e870793bc57203cd9a4e4819a4"},"provenance":null,"requires-python":null,"size":296059,"upload-time":"2014-02-06T16:45:13.056233Z","url":"https://files.pythonhosted.org/packages/88/bd/5e9d566e941e165987b8c9bd61583c58242ef4da12b7d9fbb07494580aff/psutil-0.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"89419f0cab4dd3ef4b32933237e34f58799069930fd25ed7f69deb9c64106c85"},"provenance":null,"requires-python":null,"size":296960,"upload-time":"2014-02-06T16:45:22.608830Z","url":"https://files.pythonhosted.org/packages/1f/06/c827177a80996d00f8f46ec99292e9d03fdf230a6e4fcea25ed9d19f3dcf/psutil-0.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.5.exe","hashes":{"sha256":"515b12e23581730c47e181fa163b457b90b6e848de0637d78b7fa8ca84ec2bc6"},"provenance":null,"requires-python":null,"size":135440,"upload-time":"2014-02-06T16:44:20.300778Z","url":"https://files.pythonhosted.org/packages/e5/55/6a353c646e6d15ee618348ed68cf79800f1275ade127f665779b6be0ed19/psutil-0.3.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.6.exe","hashes":{"sha256":"5bc91423ff25ad8dffb3c9979abdafb1ecd2e9a7ef4b9287bb731e76ea2c4b91"},"provenance":null,"requires-python":null,"size":267782,"upload-time":"2014-02-06T16:44:30.319267Z","url":"https://files.pythonhosted.org/packages/61/04/c447b4d468402bfb10d21995b0eae219c8397c00d9e8a2b209fb032ac1aa/psutil-0.3.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.7.exe","hashes":{"sha256":"4b7fbaca98b72f69561d593ef18b5254a8f98482b561db3d906aac4dd307bbcc"},"provenance":null,"requires-python":null,"size":267308,"upload-time":"2014-02-06T16:44:39.895580Z","url":"https://files.pythonhosted.org/packages/e4/2f/b060e631686e6455ff483ea5b6333382c6dddb5727edbfc9dcca1a8f024c/psutil-0.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py3.3.exe","hashes":{"sha256":"005217c21551618085e3323d653d75f9ad8f7418bff4fd5109850fba11950d6e"},"provenance":null,"requires-python":null,"size":262514,"upload-time":"2014-02-06T16:44:47.866655Z","url":"https://files.pythonhosted.org/packages/50/34/7bfc452cb2cd0069a81064db51b484ef135125cf1d246d0ff82c65653c81/psutil-0.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py3.4.exe","hashes":{"sha256":"331ac97b50def25e41bae637642d0131d5c4223b52ab55281d002549632ed5e0"},"provenance":null,"requires-python":null,"size":262479,"upload-time":"2014-02-06T16:44:56.381135Z","url":"https://files.pythonhosted.org/packages/b0/08/1944d2281986237cdaeabfa36195f44dc4c847d5c4fda3523b44c6823e19/psutil-0.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.tar.gz","hashes":{"sha256":"4b0ecc77d6c503449af3d2f0a41ad4cb8338e173f5d655a8239e41b1a49bc278"},"provenance":null,"requires-python":null,"size":167796,"upload-time":"2014-02-06T02:06:24.041544Z","url":"https://files.pythonhosted.org/packages/88/46/a933ab20c6d9b0ca5704b60307b9e80bdc119b759e89b74a2609b4c10eb6/psutil-0.4.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py2.7.exe","hashes":{"sha256":"9689512e5a32508216bd6cc7cb2fbe938e4a47b483cd345b5bec6dda790a9210"},"provenance":null,"requires-python":null,"size":302844,"upload-time":"2014-02-06T16:43:18.853340Z","url":"https://files.pythonhosted.org/packages/a5/06/3ca1c85b733ceaced144cb211c1fc40a6b3b1c4f7a109bbb8e19fe09eac0/psutil-0.4.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py3.3.exe","hashes":{"sha256":"9ee193dec84c2c91ac8712760eaaae0488dee92db37134dfcddc889ecd4f578d"},"provenance":null,"requires-python":null,"size":301654,"upload-time":"2014-02-06T16:43:28.863005Z","url":"https://files.pythonhosted.org/packages/ac/eb/f6923ea1b46803251f2bb42ad9b8ed90f4b8d04cdb2384c9ea535193e4f7/psutil-0.4.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py3.4.exe","hashes":{"sha256":"94d2d0a24fa62f5655e9e21dd558592bf1d3d515d944eee70e9cd2e2bf2bf244"},"provenance":null,"requires-python":null,"size":302558,"upload-time":"2014-02-06T16:43:38.802980Z","url":"https://files.pythonhosted.org/packages/7c/5b/d9057a158b09c377eab80dae60928f8fe29bdd11635ca725098587981eeb/psutil-0.4.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.5.exe","hashes":{"sha256":"fab822fb8968b45695174a2c9b4d40e9ae81126343e24d38b627036579f1ee5e"},"provenance":null,"requires-python":null,"size":140768,"upload-time":"2014-02-06T16:42:35.663297Z","url":"https://files.pythonhosted.org/packages/07/1e/7827d1271248ddef694681747297aeb3f77dafe5c93ff707a625e3947082/psutil-0.4.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.6.exe","hashes":{"sha256":"ca511f56db8f1586612851a2eedbf80e38cf29f4a98f133410a74da284822747"},"provenance":null,"requires-python":null,"size":273280,"upload-time":"2014-02-06T16:42:44.697290Z","url":"https://files.pythonhosted.org/packages/b4/56/78f182bf9c81a978067ba5447eca2ea70ef2bc9ac94228adfae5428cd108/psutil-0.4.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.7.exe","hashes":{"sha256":"5b6cbf5aaeab55db1d9657fc75e4b54fa94d17d03ca97c94aa150e1bfdc8fb2e"},"provenance":null,"requires-python":null,"size":272807,"upload-time":"2014-02-06T16:42:52.281617Z","url":"https://files.pythonhosted.org/packages/7d/38/b719c8867699a71a98e92e61fd1b0f12bad997a9de60bf8f6215184692e8/psutil-0.4.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py3.3.exe","hashes":{"sha256":"dfe18b8eb9ee6dbbd49e28f245794c2fc22b56d770038668cb6e112935c49927"},"provenance":null,"requires-python":null,"size":268022,"upload-time":"2014-02-06T16:43:01.185161Z","url":"https://files.pythonhosted.org/packages/f4/2b/13be095a72c83fdbe11d519310cb34ff8e442d72ab52691218a83c216ac4/psutil-0.4.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py3.4.exe","hashes":{"sha256":"5b63e0e83dde30d62206497320c06b27c489ffb261e95ac1267b7a1b8d4ce72d"},"provenance":null,"requires-python":null,"size":267989,"upload-time":"2014-02-06T16:43:09.528893Z","url":"https://files.pythonhosted.org/packages/b4/8e/028b849600447c45c20582d7ddae1e39d31b83799289f54f1b79af664295/psutil-0.4.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.tar.gz","hashes":{"sha256":"33002c38f916835c949ae39a84f3f6d09ce01818ed805dfd61f8f3844c395c9d"},"provenance":null,"requires-python":null,"size":171549,"upload-time":"2014-02-06T02:06:17.394021Z","url":"https://files.pythonhosted.org/packages/a0/cd/00550e16a2a0357a9c24946160e60fc947bbe23bc276aff1b4d3e7b90345/psutil-0.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"3e408028898b4ad09c207659c1b6cb8e6a74fb39ab3157b761e057a629118fec"},"provenance":null,"requires-python":null,"size":310414,"upload-time":"2014-02-06T16:41:41.640755Z","url":"https://files.pythonhosted.org/packages/06/75/3dc33773b1a1f7055b24245a0c8bec4d5776f1e1125329a13e82449007be/psutil-0.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"457cfdecbf63f813bf86e2f736ab3b20447e8d8c2c516dd2a13a7463177f8bc6"},"provenance":null,"requires-python":null,"size":309169,"upload-time":"2014-02-06T16:41:50.926907Z","url":"https://files.pythonhosted.org/packages/6e/9e/6c7f5baf2529d9bba563cdff0b81413b5870b0681739318112adecd99ad0/psutil-0.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"fc75e094cf573a7b9977be2a9d3a9d94671bc0ab098d52c391dd63227309cbea"},"provenance":null,"requires-python":null,"size":310087,"upload-time":"2014-02-06T16:42:00.068444Z","url":"https://files.pythonhosted.org/packages/cd/e6/9f963b32ab254b8c2bbedf5ce543cace8b08054924fd26fa233f99863ecc/psutil-0.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.5.exe","hashes":{"sha256":"ef4ed886b4d2d664fab5c369543690cda04e04a3b7496d72e369ef5240a8af6b"},"provenance":null,"requires-python":null,"size":148474,"upload-time":"2014-02-06T16:40:57.772154Z","url":"https://files.pythonhosted.org/packages/65/ad/e7828797558dd5f209694b02ce079cd3b6beacf6a5175f38c1973c688494/psutil-0.4.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.6.exe","hashes":{"sha256":"aafe9e328ffc173b26c78897c168858da335c85d4a02d666ad68fe2fe14601d1"},"provenance":null,"requires-python":null,"size":280897,"upload-time":"2014-02-06T16:41:07.265101Z","url":"https://files.pythonhosted.org/packages/1e/a1/594bf54e7c4056bc5284023be97f67c930175b3329e086a4ed8966cb067a/psutil-0.4.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.7.exe","hashes":{"sha256":"cefad502010c78425190498efc54541ae7bbe9eaa73ef4000cf11b032d32a8bb"},"provenance":null,"requires-python":null,"size":280445,"upload-time":"2014-02-06T16:41:15.492817Z","url":"https://files.pythonhosted.org/packages/c6/c4/14807de009a1beab2426b537379a8b05b1d69fef1fde7e23581cc332cdb3/psutil-0.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py3.3.exe","hashes":{"sha256":"a35ce124b2dec01d7632627c9370f5202978fce89ae59235cf4d5e05bbd0e02b"},"provenance":null,"requires-python":null,"size":275668,"upload-time":"2014-02-06T16:41:23.498162Z","url":"https://files.pythonhosted.org/packages/38/7d/407f7586bccdeb80f5da82d8ebb98712bfcc7217e3d7c3fc61b3bba893f2/psutil-0.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py3.4.exe","hashes":{"sha256":"860a039b67ee015a6304e8d05e6dc5c2a447eca331b7d6c9d04f41d7f2fc3a66"},"provenance":null,"requires-python":null,"size":275635,"upload-time":"2014-02-06T16:41:33.515203Z","url":"https://files.pythonhosted.org/packages/c5/b7/d2662ebf114961766c9eb3d9b737cb5541060d35e65b542b0acef470221a/psutil-0.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.tar.gz","hashes":{"sha256":"b10d1c19b9d334bea9f025f3b82b5664d642d26ba32ae0e71e7e20c5a6b4164f"},"provenance":null,"requires-python":null,"size":118411,"upload-time":"2014-02-06T02:06:09.471218Z","url":"https://files.pythonhosted.org/packages/3f/eb/e4115c3ecc189fd345b9a50d521e2ff76990bfb12a91921e93ea6398feef/psutil-0.5.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py2.7.exe","hashes":{"sha256":"5bf7a91fd57be3a63c6b9fa78da63c185b9be909ca49032f3ceda662628be74d"},"provenance":null,"requires-python":null,"size":319335,"upload-time":"2014-02-06T15:53:45.976879Z","url":"https://files.pythonhosted.org/packages/c5/cc/9bb29fdd60e347617c3a09f51a595941ddb4777fc1608068d174ced5bfdd/psutil-0.5.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py3.3.exe","hashes":{"sha256":"0cd9872d0d675b0314d2d15513e8ff3693a417e4ebaa158fc1f8780cc611574c"},"provenance":null,"requires-python":null,"size":317930,"upload-time":"2014-02-06T15:53:57.230392Z","url":"https://files.pythonhosted.org/packages/37/d8/276629523e0477639b33a606f93c2fc2e9c4cafba76b3a4cd1ddc42dd307/psutil-0.5.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py3.4.exe","hashes":{"sha256":"13f71acf1d2fe08db072d890280e985e8414080bcd525c13c66e0e8fbc917710"},"provenance":null,"requires-python":null,"size":318790,"upload-time":"2014-02-06T15:54:08.039630Z","url":"https://files.pythonhosted.org/packages/5f/bc/a026bbb10a4df4cf458b5d6feabc72a0017e6a4f472898280442ff3f9393/psutil-0.5.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.5.exe","hashes":{"sha256":"d6839532038b97792d90341465430520e58ea3d0956a1df710b3fdd733dde587"},"provenance":null,"requires-python":null,"size":156923,"upload-time":"2014-02-06T16:39:37.158716Z","url":"https://files.pythonhosted.org/packages/26/83/d1aed38bad84576e48b9ca6501edcf829ca3b48631c823736c36fa2b24de/psutil-0.5.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.6.exe","hashes":{"sha256":"be79349ecf091470ea4920e45b78914b67f17bec9c23e4bea4ec0ca5fee1feab"},"provenance":null,"requires-python":null,"size":289457,"upload-time":"2014-02-06T15:53:07.782148Z","url":"https://files.pythonhosted.org/packages/4e/b2/bfdeae58283e0fb09e2c6725c01b9429acbd15917c7ead91c96f2df37d05/psutil-0.5.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.7.exe","hashes":{"sha256":"e4fa8e965eb58a885e65a360f1a7ffc7ed476e9227a2de3726091d7560c694a8"},"provenance":null,"requires-python":null,"size":289002,"upload-time":"2014-02-06T15:53:16.212429Z","url":"https://files.pythonhosted.org/packages/2d/62/ed3c23fb8648a916460e95306d58f5ba42b3b20c68f2a55d1fc6396190a5/psutil-0.5.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py3.3.exe","hashes":{"sha256":"0380ece3eeb6f170ba156c58eab2fa36508600b1c7e10bc9b7c651f721236f38"},"provenance":null,"requires-python":null,"size":284089,"upload-time":"2014-02-06T15:53:25.963338Z","url":"https://files.pythonhosted.org/packages/59/3d/25912eb67f01af306d8ec035041c07daa7f783aafa5f4e1dd90de91c4849/psutil-0.5.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py3.4.exe","hashes":{"sha256":"d6a9e67de81fc0fc58c790e1355ddfbb8a0760963868a538f217ac2325a81581"},"provenance":null,"requires-python":null,"size":284045,"upload-time":"2014-02-06T15:53:35.675392Z","url":"https://files.pythonhosted.org/packages/38/74/e6c5bfb482f011d19bb1366cecf7d4f0b5c9c9b7664ef31e951cc4d0757b/psutil-0.5.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.tar.gz","hashes":{"sha256":"f660d244a08373f5e89633650970819a59463b37af1c9d205699fb0d0608986d"},"provenance":null,"requires-python":null,"size":118781,"upload-time":"2014-02-06T02:06:02.078066Z","url":"https://files.pythonhosted.org/packages/aa/06/6ebc13a14c0961d7bb8184da530448d8fc198465eb5ecd1ad36c761807d2/psutil-0.5.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py2.7.exe","hashes":{"sha256":"eff5ed677b6bdb5d75f1de925df774d8029582eea17abc3bbd31b9885d3c649d"},"provenance":null,"requires-python":null,"size":319512,"upload-time":"2014-02-06T16:36:10.664265Z","url":"https://files.pythonhosted.org/packages/8a/26/15751b500afdd0aea141905d5ba5319c38be41e0ca55a374c02827d1a79c/psutil-0.5.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py3.3.exe","hashes":{"sha256":"8a12d8e368bfccfe2074616cae2472dfb1e136a2aaaea5b7dbafdb390166b202"},"provenance":null,"requires-python":null,"size":318245,"upload-time":"2014-02-06T16:36:21.268821Z","url":"https://files.pythonhosted.org/packages/13/9d/49f6fb5e1f75b3d6815bbdbbeb1630f7299d6ff96f85836dbd27989780ae/psutil-0.5.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py3.4.exe","hashes":{"sha256":"9d991aae6b993ac58b540f27b2dff71137db62253f5d7acc5ede1ec845fd6b0b"},"provenance":null,"requires-python":null,"size":319083,"upload-time":"2014-02-06T16:36:31.287414Z","url":"https://files.pythonhosted.org/packages/2c/fa/a0469c75acedccc5006b655434e96a8a6a490725a9ae8208faaf39c043f6/psutil-0.5.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.5.exe","hashes":{"sha256":"ee32be6667bb69ebefc2fb5e23d115d98e307b5246c01ef50e45cfd8ad824d07"},"provenance":null,"requires-python":null,"size":157149,"upload-time":"2014-02-06T16:35:24.026975Z","url":"https://files.pythonhosted.org/packages/2e/30/9ed6283c7f1a716a3bf76a063b278ace2f89d1a8b2af9d35080dc2a0319b/psutil-0.5.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.6.exe","hashes":{"sha256":"f434f546d73366bff6283db907105b2607976ff9be67f2b5a7b35533e5f27219"},"provenance":null,"requires-python":null,"size":289555,"upload-time":"2014-02-06T16:35:32.000842Z","url":"https://files.pythonhosted.org/packages/eb/d9/55f5d02e42dc6c73f66c7cfc99bc3bf97cf10e9f259dbea69e123e0ef459/psutil-0.5.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.7.exe","hashes":{"sha256":"45acf090d65f2f47f3b1444b056cafb1b1ca70a8e266ddf10422734fb0ada897"},"provenance":null,"requires-python":null,"size":289095,"upload-time":"2014-02-06T16:35:40.182115Z","url":"https://files.pythonhosted.org/packages/81/25/cbbb80d1957c28dffb9f20c1eaf349d5642215d7ca15ec5b7015b6a510c8/psutil-0.5.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py3.3.exe","hashes":{"sha256":"9a20a99b6727334c8cc3a10ecc556d2f15a1e92efef97670ed022b86e09df36b"},"provenance":null,"requires-python":null,"size":284290,"upload-time":"2014-02-06T16:35:50.441013Z","url":"https://files.pythonhosted.org/packages/73/a2/ab4f2fa7ba6f8fc51d9cc9a0bb5ec269860a34574d391e39d20c2dca7b56/psutil-0.5.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py3.4.exe","hashes":{"sha256":"d547e164013a4d78909cbac0c176d65aa51c06de2fb888c63b738906f5ccc105"},"provenance":null,"requires-python":null,"size":284247,"upload-time":"2014-02-06T16:36:00.155604Z","url":"https://files.pythonhosted.org/packages/7f/8b/c9abd21cdc79b70744e169b98be06f0828687dfcac6468ed87455099f88d/psutil-0.5.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.tar.gz","hashes":{"sha256":"e918763243371f69bc98b601769df7337e196029dcdb797224f0ede474e17b94"},"provenance":null,"requires-python":null,"size":130803,"upload-time":"2014-02-06T02:05:55.032752Z","url":"https://files.pythonhosted.org/packages/3c/9f/0de622fc62e74f4c154656440c02c8a24a01a997d605a744272eb0d93742/psutil-0.6.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py2.7.exe","hashes":{"sha256":"1792be8fca4b3f88553e1c5cc197e18932c3da9b969ce7f545b741913597d600"},"provenance":null,"requires-python":null,"size":322153,"upload-time":"2014-02-06T16:34:24.006415Z","url":"https://files.pythonhosted.org/packages/5f/fd/fc06aaf69ad438d1354312c728791a1f571b2c59a49b411128911abf647e/psutil-0.6.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py3.3.exe","hashes":{"sha256":"084a1cbeca8e10f0cbba4b9d3f7d3136cb1d03997a868eea334401f82105207a"},"provenance":null,"requires-python":null,"size":320646,"upload-time":"2014-02-06T16:34:33.535927Z","url":"https://files.pythonhosted.org/packages/70/5e/b1d4a1d5238497d48112bc27e3448d05a0acb6c8fcd537565724d916e7c2/psutil-0.6.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py3.4.exe","hashes":{"sha256":"e7233e45ed7505efe46309978edd3e8a1cb4160400c3535512be2e4114615bb9"},"provenance":null,"requires-python":null,"size":321547,"upload-time":"2014-02-06T16:34:44.543150Z","url":"https://files.pythonhosted.org/packages/47/ad/4139c3eaa2ee1da71d071c9b49e8a04ff23f2c71f6fdecc11850b0e7343e/psutil-0.6.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.5.exe","hashes":{"sha256":"469628dea02a7d91837e05777cb66bfcdc2e1639cc8607ed93f19679c4e42cef"},"provenance":null,"requires-python":null,"size":160485,"upload-time":"2014-02-06T16:33:39.286987Z","url":"https://files.pythonhosted.org/packages/10/3a/a0136c299b74224be3b0735812a1544e6962d7c61af41adfcc400791c684/psutil-0.6.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.6.exe","hashes":{"sha256":"a628ad11fefc16d6dd144a8d29a03ac379debcf6c2e4b576e6ee2b2677c15836"},"provenance":null,"requires-python":null,"size":292261,"upload-time":"2014-02-06T16:33:47.696744Z","url":"https://files.pythonhosted.org/packages/2b/79/eec1c63d3ea968cc9754871a1b9d17d50bfc24136ecac415f701b1d240ea/psutil-0.6.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.7.exe","hashes":{"sha256":"71197523bf8acb49e3e909ea945cc6e77a21693428db2f169e33348988c1bb11"},"provenance":null,"requires-python":null,"size":291811,"upload-time":"2014-02-06T16:33:56.338977Z","url":"https://files.pythonhosted.org/packages/e9/64/fe90d0f1ba2dff8ad2511423720aed3569cfe7b5dbb95ede64af25b77e84/psutil-0.6.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py3.3.exe","hashes":{"sha256":"1d7df98f4532e76685fabbd82e9502c91be9a60e4dfdfd5a19c2152936b7d198"},"provenance":null,"requires-python":null,"size":286963,"upload-time":"2014-02-06T16:34:04.390605Z","url":"https://files.pythonhosted.org/packages/d6/d7/91226f8635d3850917b64e94ca4903910a60739ee7c930ef9678d93638eb/psutil-0.6.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py3.4.exe","hashes":{"sha256":"da568edc3b8ec4be5b8cee54851289eb4c24cbaa8ea165858e9bfc279269bf22"},"provenance":null,"requires-python":null,"size":286905,"upload-time":"2014-02-06T16:34:14.322283Z","url":"https://files.pythonhosted.org/packages/56/67/533833832596e5f8c1fb51d3f94cd110d688579be7af46996cf96ad890e7/psutil-0.6.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.tar.gz","hashes":{"sha256":"52eba795281cdd1079f13ded6a851f6d029551ddf552eadc9a2ee3eb26fe994d"},"provenance":null,"requires-python":null,"size":131473,"upload-time":"2014-02-06T02:05:47.971617Z","url":"https://files.pythonhosted.org/packages/4f/e6/989cb0b2f7f0ebe3ab0e7144b78db17387810f1526e98498be96fb755fa9/psutil-0.6.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py2.7.exe","hashes":{"sha256":"566bcec389a77279e10335eb5d0021eb968445720496b70b46d208dbbf8e49a1"},"provenance":null,"requires-python":null,"size":322415,"upload-time":"2014-02-06T16:32:41.593785Z","url":"https://files.pythonhosted.org/packages/9a/bb/cb19a41fa75a2205ac2d337be45183f879aa77e60bbb19387c872c81d451/psutil-0.6.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py3.3.exe","hashes":{"sha256":"fde5e57f9b51057998cce5a030ad481f826832b26cc2a6490d60317c9024724c"},"provenance":null,"requires-python":null,"size":320911,"upload-time":"2014-02-06T16:32:50.930654Z","url":"https://files.pythonhosted.org/packages/7d/d1/9e75848da16a5d165e3918540418f3052e6409357bcce91a7342b22d674f/psutil-0.6.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py3.4.exe","hashes":{"sha256":"402475d1a93306ac025070da9628a0ca0e0d253b0755bf13131318a39aaeea8e"},"provenance":null,"requires-python":null,"size":321810,"upload-time":"2014-02-06T16:33:01.995635Z","url":"https://files.pythonhosted.org/packages/95/82/1f52f8aaa37e07da54da4468c031f59717d3f40cd82b6faaf8f203d84bd7/psutil-0.6.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.5.exe","hashes":{"sha256":"3f5b8afde564c563cd6fa28ac14ed020d91d654ef1efd6c0e1672282fcde8e65"},"provenance":null,"requires-python":null,"size":160754,"upload-time":"2014-02-06T16:31:55.533884Z","url":"https://files.pythonhosted.org/packages/5b/3f/10449a8a3dfb809fbeae3d853453aafb36376d51f33c46e02b5f0723c620/psutil-0.6.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.6.exe","hashes":{"sha256":"1c1763ff214042e7be75fd6eb336322a47193342cddfc70b8547f086968e024c"},"provenance":null,"requires-python":null,"size":292530,"upload-time":"2014-02-06T16:32:04.859349Z","url":"https://files.pythonhosted.org/packages/3e/7a/5d53c99ec66ea86548d95acaf98b32f1cbb761cf2e1fc8ee62d0838f8e24/psutil-0.6.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.7.exe","hashes":{"sha256":"e411f2374994663ad35bc21afe4ff9003e3675e23b07a2a60b57c760da0c5f3f"},"provenance":null,"requires-python":null,"size":292082,"upload-time":"2014-02-06T16:32:13.267526Z","url":"https://files.pythonhosted.org/packages/4a/40/e43e412c55f66b57aee3a418f47b05e7bb92db83df93c0c93b00f11f1357/psutil-0.6.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py3.3.exe","hashes":{"sha256":"03ea1f851920d6ddc286c1940ebd167ed92c1cb7a870f1789510c21c6fa6b7bc"},"provenance":null,"requires-python":null,"size":287227,"upload-time":"2014-02-06T16:32:22.314264Z","url":"https://files.pythonhosted.org/packages/07/12/1ce6196592e01965a375b307a57f68e90488a49a56a647f17ba027382448/psutil-0.6.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py3.4.exe","hashes":{"sha256":"095107d63b176fed2f4a44de3a4d19e8aa6291de0c3ee5e398272c9b72bf2254"},"provenance":null,"requires-python":null,"size":287169,"upload-time":"2014-02-06T16:32:32.819904Z","url":"https://files.pythonhosted.org/packages/f4/88/d20f7eefa6b8cc59f9320c52bf561ba52baea2b9b36568b198bca0b3548d/psutil-0.6.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.tar.gz","hashes":{"sha256":"95089802017ee629b84332deeb367f7f775b42e827ee283d46b7e99d05120d71"},"provenance":null,"requires-python":null,"size":138681,"upload-time":"2014-02-06T02:05:40.485455Z","url":"https://files.pythonhosted.org/packages/0b/8c/aeb6acf5a4610f8d5bb29ade04081d8672c2294c3cefa1f0422c6398bc66/psutil-0.7.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py2.7.exe","hashes":{"sha256":"add60c89c13443617c83116fab34a3c6e4f32ee8b102ff6ffb4cd20ef6f511c3"},"provenance":null,"requires-python":null,"size":325666,"upload-time":"2014-02-06T16:30:51.588803Z","url":"https://files.pythonhosted.org/packages/38/8e/f3023be1a2268b5ee3a20e05ec8997a95c987f6f2b7dadad837674d562e8/psutil-0.7.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py3.3.exe","hashes":{"sha256":"520a43be7fcd21d63c02039cdd7ebfe959b9fa9a865ba9aab6b0194a85184250"},"provenance":null,"requires-python":null,"size":324143,"upload-time":"2014-02-06T16:31:01.226228Z","url":"https://files.pythonhosted.org/packages/7b/03/d6bff7ff8570f3521a1d7949f03741210f11ba5ba807789d37e185a0a780/psutil-0.7.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py3.4.exe","hashes":{"sha256":"0e78c6b441e659d922c5fddd5d5a36a368a61192873a0600ba23171c14dc2a6d"},"provenance":null,"requires-python":null,"size":325001,"upload-time":"2014-02-06T16:31:12.826305Z","url":"https://files.pythonhosted.org/packages/ce/8a/95e7c8b343a92137d82e4635fcb3f5c69c29e2a84ce4d51f2d5d86020b1e/psutil-0.7.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.5.exe","hashes":{"sha256":"532b918d8d2df60c20c69c1f764b9b16373ea22c32595fe801e3cc9b1aa5adfb"},"provenance":null,"requires-python":null,"size":163763,"upload-time":"2014-02-06T16:30:02.815062Z","url":"https://files.pythonhosted.org/packages/9e/6f/a946eeb3c6b8848fcf6d21c52884e2639e7d4393b51f330d4555ec177e83/psutil-0.7.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.6.exe","hashes":{"sha256":"21e1d7880579ef7eea28547c737923eaeee53389d51fa971d9f70bf89e9759ee"},"provenance":null,"requires-python":null,"size":295425,"upload-time":"2014-02-06T16:30:11.405843Z","url":"https://files.pythonhosted.org/packages/14/e9/ac4865772c55a3c09c85d987ac2a0e679c31e897d536f389485019c29450/psutil-0.7.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.7.exe","hashes":{"sha256":"bc36a7350b89e2ada06691583f4c4c2f99988fe6fa710d4f8e4143bed9f9f8bf"},"provenance":null,"requires-python":null,"size":294933,"upload-time":"2014-02-06T16:30:20.866887Z","url":"https://files.pythonhosted.org/packages/12/1c/053e0d5485a39c055e92b845b6311ab54887a091836a3985369cfffa9e53/psutil-0.7.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py3.3.exe","hashes":{"sha256":"9ce0d7a8cedde996eaae1eda3db9b473d441bd6c797b36a166d7b7a70dd4650e"},"provenance":null,"requires-python":null,"size":290006,"upload-time":"2014-02-06T16:30:29.860768Z","url":"https://files.pythonhosted.org/packages/73/19/8009828f3cfcf529570822e52988b95ac1c25c90ba4fb96ae570b5c25e66/psutil-0.7.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py3.4.exe","hashes":{"sha256":"6fdeca414a470d156ebdf1b6e4e9ca0fd9eb1b53e8d9a0cbb7d4a69d31f68bdc"},"provenance":null,"requires-python":null,"size":289986,"upload-time":"2014-02-06T16:30:39.817575Z","url":"https://files.pythonhosted.org/packages/42/7d/8e159acbf98eed98b778c244287b295f06411ac9e1903d2d358ba48b1d36/psutil-0.7.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.tar.gz","hashes":{"sha256":"5236f649318a06dcff8b86947c888d4510abce1783923aa5455b2d62df7204c7"},"provenance":null,"requires-python":null,"size":138525,"upload-time":"2014-02-06T02:05:32.811951Z","url":"https://files.pythonhosted.org/packages/8c/75/1eeb93df943b70c2e18bf412b32d18af3577da831f2bfe8c7d29f8853a67/psutil-0.7.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py2.7.exe","hashes":{"sha256":"47fc6887ec86bd7a422326dfc77e2b43fcbc71e498194f86088bb2268c2372b7"},"provenance":null,"requires-python":null,"size":325663,"upload-time":"2014-02-06T16:29:31.935519Z","url":"https://files.pythonhosted.org/packages/2d/ab/8fde8a7358a21bc2488a5d21a24879ce3cc162d2a99c56f9599c7d759c75/psutil-0.7.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py3.3.exe","hashes":{"sha256":"c00ec6a0e061e31687851c06d542500fd47b0ed415818e0da61c294f2796572b"},"provenance":null,"requires-python":null,"size":324140,"upload-time":"2014-02-06T16:29:41.403650Z","url":"https://files.pythonhosted.org/packages/35/b1/8506f2e78974da833b20b162d70b7e38ac3ab722adf18c03a3e428c9d9c4/psutil-0.7.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py3.4.exe","hashes":{"sha256":"a5238a16cd85d4f3240dfca8ad94cb0bfe8643acb5c21d839a53caa86d8a23ab"},"provenance":null,"requires-python":null,"size":324998,"upload-time":"2014-02-06T16:29:50.929853Z","url":"https://files.pythonhosted.org/packages/cc/29/d00e1011e6db097ffac31c2876fdba51fd1fc251ee472ad6219095739a86/psutil-0.7.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.5.exe","hashes":{"sha256":"facf21db78120afb79ec51685043a5f84e897a84a7678db4381c0e377a481364"},"provenance":null,"requires-python":null,"size":163764,"upload-time":"2014-02-06T16:28:44.337888Z","url":"https://files.pythonhosted.org/packages/06/d8/a34c090687fa4c09bee5b5a06a762eb1af134d847b907d3e63c58e5d2cba/psutil-0.7.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.6.exe","hashes":{"sha256":"709d2e851c161f1ffad6bd7ed925ee90229dbd2067fbc26126c11d473075d7b7"},"provenance":null,"requires-python":null,"size":295427,"upload-time":"2014-02-06T16:28:53.964081Z","url":"https://files.pythonhosted.org/packages/4d/8a/d51e550aa0928ab02e4f6b2531453b2e63c8877e30543e342c8a35c90d4d/psutil-0.7.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.7.exe","hashes":{"sha256":"ee218aa12ee3af563833cf0bf109b15382261a0760a1ce636bf9e26e630f833e"},"provenance":null,"requires-python":null,"size":294930,"upload-time":"2014-02-06T16:29:03.098211Z","url":"https://files.pythonhosted.org/packages/3c/4c/d46a8bc865e58b30dcb160772667abf42f854ec4910ee1100e79961035ce/psutil-0.7.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py3.3.exe","hashes":{"sha256":"fdf22a72f891a45b8a9ebca85b50a055a4ba7a8c05b98f93e1387b8ee88a4562"},"provenance":null,"requires-python":null,"size":290003,"upload-time":"2014-02-06T16:29:12.556491Z","url":"https://files.pythonhosted.org/packages/1a/cf/98fdaf08279cd754414ab6723bbb6bd55d890624b766d64b21c35379d865/psutil-0.7.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py3.4.exe","hashes":{"sha256":"f675a6346e5bd02469b043afff2db1b8e0b180e8a6d1ca94d44d23f26f60e68f"},"provenance":null,"requires-python":null,"size":289983,"upload-time":"2014-02-06T16:29:21.732021Z","url":"https://files.pythonhosted.org/packages/f4/f9/79ac18809795f53197fb5b6bd452d2b52f62e5bff6a66d9b813077a85eb9/psutil-0.7.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.tar.gz","hashes":{"sha256":"af776ebeaf2420709b1ab741f664c048dcfc2890e3e7d151ae868fbdc3d47920"},"provenance":null,"requires-python":null,"size":156516,"upload-time":"2014-02-06T02:05:25.754044Z","url":"https://files.pythonhosted.org/packages/ed/7e/dd4062bfbe9b735793a5e63a38d83ba37292c4ada3615fe54403c54e3260/psutil-1.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"7868ef2ecc1d847620d99b40f8105b6d5303784abbde34da2388b2c18e73a3d2"},"provenance":null,"requires-python":null,"size":327529,"upload-time":"2014-02-06T16:25:06.308578Z","url":"https://files.pythonhosted.org/packages/11/46/8a6581c14d644f747ea66a12c60ffebebd4f8a77af62192aeb20cc16ae17/psutil-1.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"cdced3409a241b9d357b82c72d00ece49602cdc3f694ed988a952761367df560"},"provenance":null,"requires-python":null,"size":326023,"upload-time":"2014-02-06T16:25:15.281576Z","url":"https://files.pythonhosted.org/packages/03/a4/aa6592e676f75705b77df8e319f6aa35cf08a662fb0cfaa34434d273d7c9/psutil-1.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"ef6974ac18407fb15430cd7b81aecc2f3666e75ca83fe3a66848c4c5c086e0a3"},"provenance":null,"requires-python":null,"size":326915,"upload-time":"2014-02-06T16:25:27.390929Z","url":"https://files.pythonhosted.org/packages/5b/c1/003f0071d1e2a4dfe12ac2d66ac14f5a5a93049544c11ac9c78d83d85318/psutil-1.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.5.exe","hashes":{"sha256":"d8213feaa4c560c61514cea4e6a7eec83f6df83694bb97b06d009e919f60c48f"},"provenance":null,"requires-python":null,"size":165576,"upload-time":"2014-02-06T16:24:22.454259Z","url":"https://files.pythonhosted.org/packages/d6/28/5753ba13863c26d8a8fef685690b539a4652f1c4929d13d482eb4d691d99/psutil-1.0.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.6.exe","hashes":{"sha256":"7571d74d351bba723b28666a13da43c07bb3568543be3f9f7404af2b8c1ecf3a"},"provenance":null,"requires-python":null,"size":297205,"upload-time":"2014-02-06T16:24:31.483662Z","url":"https://files.pythonhosted.org/packages/ad/8c/37599876ea078c7c2db10d746f0e0aa805abcacbab96d1cf5dfb0465c40b/psutil-1.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.7.exe","hashes":{"sha256":"3f311d4f060b83d7cd0068dbad867ad17e699d3c335e494dc31db5380154fdf4"},"provenance":null,"requires-python":null,"size":296787,"upload-time":"2014-02-06T16:24:39.921427Z","url":"https://files.pythonhosted.org/packages/99/4e/8c1f5db3e90dbdbde891c34fd2496805a93aa279433bac716098efad1b4c/psutil-1.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py3.3.exe","hashes":{"sha256":"acf6cbc2408869b2843d406a802b6895969a358c762b5ab3e6f5afdd0c918faf"},"provenance":null,"requires-python":null,"size":291856,"upload-time":"2014-02-06T16:24:48.963293Z","url":"https://files.pythonhosted.org/packages/5b/f7/0bad3fc8ff5f226fa933a847b5fb3355562421f0456348747cf18f7137f5/psutil-1.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py3.4.exe","hashes":{"sha256":"191c2e6953426c861d7e100d48a5b522307ffc3de7d9e7bc8509aa45fb3de60c"},"provenance":null,"requires-python":null,"size":291810,"upload-time":"2014-02-06T16:24:57.589702Z","url":"https://files.pythonhosted.org/packages/0a/50/18ebd254b6662c98a8310983fff6795c7ac303d25188fd727888ca1c5211/psutil-1.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.tar.gz","hashes":{"sha256":"ba4c81622434836f6645e8d04e221ca5b22a9bd508c29989407f116b917be5b3"},"provenance":null,"requires-python":null,"size":156516,"upload-time":"2014-02-06T02:05:16.665325Z","url":"https://files.pythonhosted.org/packages/94/50/7c9e94cf6cdbf4e4e41d2e318094c2b0d58d3bb9196017fb6e4897adf277/psutil-1.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"2d6705cf53a7474b992d0d5beac4697cdd37f2c24098d4e1b5bb35a83b70b27e"},"provenance":null,"requires-python":null,"size":327529,"upload-time":"2014-02-06T16:20:20.120751Z","url":"https://files.pythonhosted.org/packages/a9/28/ac3c9da11fbe1ae3ddefb2cb6b410c8ad701f39d86489931e87c871cc4d1/psutil-1.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"6194670fcbddec715846fa9beca4450b4419423b2d466894da2fa1915fc7b712"},"provenance":null,"requires-python":null,"size":326023,"upload-time":"2014-02-06T16:20:43.401705Z","url":"https://files.pythonhosted.org/packages/97/30/094bb08295e15e05a266fcb15c116912f643fbb4dd8090ec64aca801ea72/psutil-1.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"5cf4ddea8dd21b99b90656dafa2d28c32fa9c159ab30580782b65b3b615c62a7"},"provenance":null,"requires-python":null,"size":326915,"upload-time":"2014-02-06T16:20:52.673334Z","url":"https://files.pythonhosted.org/packages/e8/86/e72c22699491573508e85b226f1782eab840b713cd6b8d42655c5329324c/psutil-1.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.5.exe","hashes":{"sha256":"fadf7625c309bc5f6e6d3b9d42836491efabbfda1834db7166775d705db420bf"},"provenance":null,"requires-python":null,"size":165580,"upload-time":"2014-02-06T16:04:23.085098Z","url":"https://files.pythonhosted.org/packages/a5/40/d307abd2ee3015e38cbeeac18c6b0f091cdcac496688f4d2c286145fdc5f/psutil-1.0.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.6.exe","hashes":{"sha256":"84a257b4adea431473089ea4b798bea98ce64452587ba7b71856e150d88e9213"},"provenance":null,"requires-python":null,"size":297208,"upload-time":"2014-02-06T15:59:31.669293Z","url":"https://files.pythonhosted.org/packages/75/3f/c10ca801aff50ce6ea84f71ce69a32de1b4a1f0439ada94adeccd36e1afd/psutil-1.0.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.7.exe","hashes":{"sha256":"4b5047bb4055d48f718bbb5a457c9b1c1c06776ca6353cb310b471c38d51324d"},"provenance":null,"requires-python":null,"size":296787,"upload-time":"2014-02-06T15:59:41.621679Z","url":"https://files.pythonhosted.org/packages/15/6c/944089b8dd730314a8eec9faa4d7d383f31490130e9e0534c882173e2eb6/psutil-1.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py3.3.exe","hashes":{"sha256":"3553a27b4d0e7552d0d863c017e152a88cb689d2090b39e2bca68db7fc27e8b2"},"provenance":null,"requires-python":null,"size":291856,"upload-time":"2014-02-06T15:59:51.241604Z","url":"https://files.pythonhosted.org/packages/4c/51/eb8b12a0124050492faad7fe3e695cb44e4ec5495a64a8570abf6e7cddc3/psutil-1.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py3.4.exe","hashes":{"sha256":"d3ab1b882647d66099adefa8ff780c4144bf8df1bb97bc31c55cbd999807cae8"},"provenance":null,"requires-python":null,"size":291810,"upload-time":"2014-02-06T16:00:00.814707Z","url":"https://files.pythonhosted.org/packages/4d/2a/33063e4a674e3be38d77fbc6e5e988f0e0323cd000cb7eb60f9300493631/psutil-1.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.tar.gz","hashes":{"sha256":"31b4b411d3f6960d26dac1f075709ff6d36f60216bf1f2b47fc4dc62a2d0aa6f"},"provenance":null,"requires-python":null,"size":163785,"upload-time":"2013-09-28T09:48:01.746815Z","url":"https://files.pythonhosted.org/packages/f6/71/1f9049fc7936f7f48f0553abd8bf8394f4ad2d9fb63a881b3a653b67abd6/psutil-1.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"ef250fbe783c0b31d9574d06324abd78ebf23c75981a8d0f9319d080435aa056"},"provenance":null,"requires-python":null,"size":305459,"upload-time":"2013-09-28T09:55:10.368138Z","url":"https://files.pythonhosted.org/packages/28/ff/e0dcc8e0194817191817ff02926a734a51d24a91e1cfc5c47be8c1e8508c/psutil-1.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win-amd64-py3.2.exe","hashes":{"sha256":"a95bf68f2189b7cd3f22558b12a989f368335c905cbd3045ca315514538b3115"},"provenance":null,"requires-python":null,"size":306085,"upload-time":"2013-09-28T09:55:36.198407Z","url":"https://files.pythonhosted.org/packages/a5/be/6f3b8f8ff89eaf480f59bbcd3d18c10ee0206891aa5fb4a25280c031801c/psutil-1.1.0.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.4.exe","hashes":{"sha256":"bc53be7f65ccb8a530e0c496a8db3ecd78b57b1faa443e43e228df327cf26899"},"provenance":null,"requires-python":null,"size":142269,"upload-time":"2013-09-28T09:51:43.685077Z","url":"https://files.pythonhosted.org/packages/ec/60/0a9a96611c77866a2c4140159a57c2702523ebc5371eaa24e0353d88ac2c/psutil-1.1.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.5.exe","hashes":{"sha256":"4a587008d6aae91fd1d3fee21141a27b4a2978fff75c80e57a37678a63a1cfcc"},"provenance":null,"requires-python":null,"size":142249,"upload-time":"2013-09-28T09:52:12.373832Z","url":"https://files.pythonhosted.org/packages/b5/16/dd5a768773cb017c4a66d69ec49abdd33df831215418e4c116639ed41afb/psutil-1.1.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.6.exe","hashes":{"sha256":"be853a268f0f3c3336c9bb648253db85ef2024213b6fc199f84b89643b74b130"},"provenance":null,"requires-python":null,"size":276570,"upload-time":"2013-09-28T09:53:51.099422Z","url":"https://files.pythonhosted.org/packages/cc/e0/adb41ece0bb2c27d75a41d98bd8f9802475d5d488df7d4905229596c0a70/psutil-1.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py3.2.exe","hashes":{"sha256":"dfdce701cfc7799dc1964debb486907b447fbdb361e06be786a9a5e11a1d5309"},"provenance":null,"requires-python":null,"size":275628,"upload-time":"2013-09-28T09:54:16.430842Z","url":"https://files.pythonhosted.org/packages/8f/c9/231df338b0cef518dbde2f98c1e0bb81142dc7dbec4a39267bb60dde1462/psutil-1.1.0.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py3.3.exe","hashes":{"sha256":"b4106508ea96ad24e1102de2a31a99c557ee608abab15d978bfe8d0f626e518c"},"provenance":null,"requires-python":null,"size":270259,"upload-time":"2013-09-28T09:54:43.666687Z","url":"https://files.pythonhosted.org/packages/a7/03/80f426e186dfdb202128c78b421b3ba34de461c32f6ed2c04041fc548d7b/psutil-1.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.tar.gz","hashes":{"sha256":"a5201e4c2a9b57e9e5d8de92b3a4006d093eedd9b56915b8279f365aaedd0f48"},"provenance":null,"requires-python":null,"size":165467,"upload-time":"2013-10-07T22:38:06.357263Z","url":"https://files.pythonhosted.org/packages/8d/0d/1a4bfc94f9cc783a510b3fc7efd5a2ef39858b3a2b6ab40a094a1ca8a54d/psutil-1.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"b8ccaef0a96d7ef40eda7493ffcaa3c5e2d63f531e090c3567e4198b38ca8e33"},"provenance":null,"requires-python":null,"size":305937,"upload-time":"2013-10-07T22:43:47.570605Z","url":"https://files.pythonhosted.org/packages/5a/b8/66489689c8751acd67bdbc8f37534176a14b63f74e74a229c30b230c8a18/psutil-1.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win-amd64-py3.2.exe","hashes":{"sha256":"fdabf11b316b0c406709aabb76f6c3cfdeb448c10ed38193786110f13e5c1248"},"provenance":null,"requires-python":null,"size":306563,"upload-time":"2013-10-07T22:44:09.209012Z","url":"https://files.pythonhosted.org/packages/e3/2d/cd5c620f9e5cb090eea573b2dc16574e746529347b6133b2f0b6e686d917/psutil-1.1.1.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.4.exe","hashes":{"sha256":"74bb1ccf0b28a914bb9d303642c08450ea6c5876851eb71e17f24b3d8672ca7d"},"provenance":null,"requires-python":null,"size":142751,"upload-time":"2013-10-07T22:45:21.036212Z","url":"https://files.pythonhosted.org/packages/28/9a/b83f884add09296894a1223c9c404cb57155c1c4317d318abf8c170e07b5/psutil-1.1.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.5.exe","hashes":{"sha256":"8e52d5b6af64e3eefbda30e0b16c9f29434ef6f79ea10b6fbd4520a6fbdb2481"},"provenance":null,"requires-python":null,"size":142731,"upload-time":"2013-10-07T22:41:32.428090Z","url":"https://files.pythonhosted.org/packages/8b/80/c41382a4f650f47a37300411169b7b248acf0b0925eb92cb22286362c3df/psutil-1.1.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.6.exe","hashes":{"sha256":"1e3a17b2a2f2bc138774f9b4b5ff52767f65ffb6349f9e05eb24f243c550ce1b"},"provenance":null,"requires-python":null,"size":277048,"upload-time":"2013-10-07T22:41:54.149373Z","url":"https://files.pythonhosted.org/packages/16/cd/25a3b9af88d130dd1084acab467b30996884219afc0a1e989d2a015ea54b/psutil-1.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.7.exe","hashes":{"sha256":"2e7691ddbde94b1ec7bb5b4cd986b2f763efc6be5b122dd499e156c9802a195b"},"provenance":null,"requires-python":null,"size":276822,"upload-time":"2013-10-07T22:42:18.407145Z","url":"https://files.pythonhosted.org/packages/42/78/eeacb1210abbe15cf06b9810e84afeabae1f9362abe389e8d5ca2c19df43/psutil-1.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py3.2.exe","hashes":{"sha256":"01276bd695b5cebc7bea7c97814713b0f3030861e30be88a60d40c9daf3d529c"},"provenance":null,"requires-python":null,"size":276106,"upload-time":"2013-10-07T22:42:41.551135Z","url":"https://files.pythonhosted.org/packages/92/14/90b9a4690f04ef1aab89a97a7b5407708f56785ccc264d9f9ce372feaea4/psutil-1.1.1.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py3.3.exe","hashes":{"sha256":"86ce0cfa7a95c7c1bc3e2f5358e446b01fc2be5f0c879c8def21e7ede9dc77de"},"provenance":null,"requires-python":null,"size":270733,"upload-time":"2013-10-07T22:43:07.069809Z","url":"https://files.pythonhosted.org/packages/a7/64/ba4601de7df6130c27f42bcec9f11da4ea905eda26d2f5a41efdb481f377/psutil-1.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.tar.gz","hashes":{"sha256":"adeb1afcb46327bed6603aa8981dce863f052043a52f003e2742ec7c3739677a"},"provenance":null,"requires-python":null,"size":165709,"upload-time":"2013-10-22T18:13:09.038583Z","url":"https://files.pythonhosted.org/packages/e4/b1/34a4bd75027d08c8db4f6301d6562e333c8d9131dca08b7f76f05aeae00a/psutil-1.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"4c9e952a7faf50f11fb8bcd6c12c952b063664d9327957c9f6abd498e6ef3bc8"},"provenance":null,"requires-python":null,"size":306157,"upload-time":"2013-10-22T18:16:38.181306Z","url":"https://files.pythonhosted.org/packages/f9/df/437db01296118d668cf654f097ad2b1c341291ba5dc4b5eb80f0a0a40c52/psutil-1.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win-amd64-py3.2.exe","hashes":{"sha256":"6e8ed376b63b15b09a94eff7998dae1f8506bd174d795e509cc735f875fddabe"},"provenance":null,"requires-python":null,"size":306782,"upload-time":"2013-10-22T18:17:05.663884Z","url":"https://files.pythonhosted.org/packages/c9/d0/1e413f0258d02bf77bc1d94002d041b8853584369e4af039cd5cf89e3270/psutil-1.1.2.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.4.exe","hashes":{"sha256":"ecc5ab4537259db7254c6f6dc7b7cb5a7f398c322a01612c272a8222696334a8"},"provenance":null,"requires-python":null,"size":142969,"upload-time":"2013-10-22T18:13:39.868851Z","url":"https://files.pythonhosted.org/packages/a7/63/fd5770ec4fe87d30bd836989d314b85662c775a52dbd017747fc69fe8f0e/psutil-1.1.2.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.5.exe","hashes":{"sha256":"e05d83d6b53ea24333c8b04d329e28ff11ecad75945f371ff5ce7f785df36aee"},"provenance":null,"requires-python":null,"size":142950,"upload-time":"2013-10-22T18:14:00.511107Z","url":"https://files.pythonhosted.org/packages/8d/e1/22650079452725e44ec790c3e75282f4d341f359b213b2afc7f2ada46930/psutil-1.1.2.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.6.exe","hashes":{"sha256":"f06ee6e1508a12afcfed04a4022ded9f872e2a964a62bd86617ece943d89ab01"},"provenance":null,"requires-python":null,"size":277266,"upload-time":"2013-10-22T18:14:33.903116Z","url":"https://files.pythonhosted.org/packages/3e/a4/5177488368f230acd4708a117c0820fb16843521e2a7a492078a2335bb9f/psutil-1.1.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.7.exe","hashes":{"sha256":"6c5be5538202ed7419911178ded41c65e118104fa634109f528a6d2d3e50a7d0"},"provenance":null,"requires-python":null,"size":277039,"upload-time":"2013-10-22T18:14:56.072979Z","url":"https://files.pythonhosted.org/packages/5e/d6/56f2891f6dd56f950866cc39892e5a56e85331d97c39e2634cfc4014f0df/psutil-1.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py3.2.exe","hashes":{"sha256":"5cfa97b52fb48dbb8255c120b567be4f06802afa7d2fe71b8fe7c7c4ee53ad88"},"provenance":null,"requires-python":null,"size":276327,"upload-time":"2013-10-22T18:15:25.393310Z","url":"https://files.pythonhosted.org/packages/dd/be/1aea1e7a1a3fb44f4c8d887a1d55e960de283d86875f15457a284268e197/psutil-1.1.2.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py3.3.exe","hashes":{"sha256":"f7dc7507fb9d4edb42709b356eb2e4b3da356efa54d83900e4cef59f3adebfbf"},"provenance":null,"requires-python":null,"size":270952,"upload-time":"2013-10-22T18:15:51.874969Z","url":"https://files.pythonhosted.org/packages/f5/7c/1a33b78a66a96e740e197ae55719496ba57bb9cee32f710a5a6affa68cc8/psutil-1.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.tar.gz","hashes":{"sha256":"5e1164086a7ed3b863ebd12315d35086e22252b328401fce901a0862050ef98c"},"provenance":null,"requires-python":null,"size":165550,"upload-time":"2013-11-07T20:47:17.039714Z","url":"https://files.pythonhosted.org/packages/93/fa/1f70b7fcdff77348f4e79d84cc9b568596874ca34940ede78c63d503a095/psutil-1.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"43cbf089cbe160d193e1658fe4eec4a719430432e866334b25dc3acef73c3e61"},"provenance":null,"requires-python":null,"size":306145,"upload-time":"2013-11-07T21:05:00.986042Z","url":"https://files.pythonhosted.org/packages/03/ec/f05db404504d67a19397e17e64f0276cc610a9dc450eb51ed70436f37c43/psutil-1.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.4.exe","hashes":{"sha256":"ef7445e1b0449af34ff51a9e1d3f030b8794c9fcd2b99d072b2e815d00e8a783"},"provenance":null,"requires-python":null,"size":142958,"upload-time":"2013-11-07T21:16:11.539460Z","url":"https://files.pythonhosted.org/packages/37/c2/5d40dd0a36f0280c1dea0f651cfde79b5e99a0e6fab92273fa3ac41055f0/psutil-1.1.3.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.5.exe","hashes":{"sha256":"b7f4103b1058d2ee597f88902ff50f19421b95c18ac9b82ea9e8a00091786131"},"provenance":null,"requires-python":null,"size":142940,"upload-time":"2013-11-07T21:15:50.256574Z","url":"https://files.pythonhosted.org/packages/ee/cb/7d42052f4057c6233ba3f4b7afade92117f58c5d7544ee6ab16e82c515c7/psutil-1.1.3.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.6.exe","hashes":{"sha256":"e21b9c5a26ad3328b6f5b629e30944a9b7e56ea6ac0aa051455c8a352e67fbca"},"provenance":null,"requires-python":null,"size":277254,"upload-time":"2013-11-07T20:58:49.794773Z","url":"https://files.pythonhosted.org/packages/b2/7e/c42d752b333c5846d88a8b56bbab23325b247766c100dc6f68c6bc56019d/psutil-1.1.3.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.7.exe","hashes":{"sha256":"fc9732a4dea2a3f73f9320472aa54e1cfae45d324bea24bd207d88d3a0a281b0"},"provenance":null,"requires-python":null,"size":277028,"upload-time":"2013-11-07T21:16:56.712839Z","url":"https://files.pythonhosted.org/packages/2b/76/eec917b6f74ea9bd20a55dd8b4b01e69689278235335dbedc2b9be212815/psutil-1.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py3.2.exe","hashes":{"sha256":"a141d59c03a28bdd32dfce11a5d51b9a63a8e6c6c4245e416eeffcc1c43f1de9"},"provenance":null,"requires-python":null,"size":276315,"upload-time":"2013-11-07T21:02:04.504719Z","url":"https://files.pythonhosted.org/packages/3a/b9/748bbd0c53c74c682051137830048abd0126ae50e3bf4d5854a0188da143/psutil-1.1.3.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py3.3.exe","hashes":{"sha256":"36e855ea7c872beb04f22d968c55f1ef897df0261ea993ecf5ae6e8216939a55"},"provenance":null,"requires-python":null,"size":270942,"upload-time":"2013-11-07T21:04:24.025560Z","url":"https://files.pythonhosted.org/packages/e6/7b/655e08abdf19d06c8a3fd6fba35932867c80fcff05c97cf909b5d364603c/psutil-1.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.tar.gz","hashes":{"sha256":"c3a2b02e92363837499680760b674b3bf3bd03dd9528a5dc41392625a61b162a"},"provenance":null,"requires-python":null,"size":166747,"upload-time":"2013-11-20T20:02:56.854747Z","url":"https://files.pythonhosted.org/packages/77/89/8ee72ae2b5e3c749e43a9c1e95d61eceff022ab7c929cdde8a3b7539a707/psutil-1.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"2bedcda55618f71bc98d6669bd190e2b51b940e3a3af2512dd77745cb1ebc101"},"provenance":null,"requires-python":null,"size":307021,"upload-time":"2013-11-20T20:08:29.733072Z","url":"https://files.pythonhosted.org/packages/9c/d1/598bcaa9701e06561cb8823a7a04ee44e702b0e327ef0a65bdd97b019613/psutil-1.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.4.exe","hashes":{"sha256":"417695f66562a22ac4f92bf7df1e9dda6264579eb308badd2c3e85df88ab9436"},"provenance":null,"requires-python":null,"size":143831,"upload-time":"2013-11-20T20:18:44.725428Z","url":"https://files.pythonhosted.org/packages/a4/ba/4b54baace7b49b73df74b54815337878137d25fda506e518f2d8dd2472fc/psutil-1.2.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.5.exe","hashes":{"sha256":"40747c59cf92cef26d595a9cefaac9c1a4bc0290abff6004bb092ee2ddec7d7b"},"provenance":null,"requires-python":null,"size":143812,"upload-time":"2013-11-20T20:18:35.170091Z","url":"https://files.pythonhosted.org/packages/88/17/3ba1b45ec63d666c2631f16679adb819564feb775cfd9e774d23e5774a44/psutil-1.2.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.6.exe","hashes":{"sha256":"fb0c3942a48fde9c52828dae4074381556eff8eb5651bdc9c4c107b40dc8318e"},"provenance":null,"requires-python":null,"size":278130,"upload-time":"2013-11-20T20:07:34.211552Z","url":"https://files.pythonhosted.org/packages/ae/4a/e62000dbe462270c30f1e2f2dcc913596f70e264d9a656f881bb9f487283/psutil-1.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.7.exe","hashes":{"sha256":"1024eff34ff14f2899186549ca8f8e461403e5700910e52eb013ffffb078cda3"},"provenance":null,"requires-python":null,"size":277905,"upload-time":"2013-11-20T20:18:07.310116Z","url":"https://files.pythonhosted.org/packages/9d/1a/b8e679a7e47229d07e41439a43fc1be48c0d34774e5e35ad6730398485bd/psutil-1.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py3.2.exe","hashes":{"sha256":"2b588673530d67f45287c31b6dfef02ee4e753aee7e7216448e6dbcb95b482e1"},"provenance":null,"requires-python":null,"size":277189,"upload-time":"2013-11-20T20:05:01.902941Z","url":"https://files.pythonhosted.org/packages/05/10/20a2364e4e69206d66da106288b65bf5bbde0d648aad5bb829f3eb08fabb/psutil-1.2.0.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py3.3.exe","hashes":{"sha256":"3e23d3b1ef5f20a458092887d1df32f55eaf4fc86f2ed49cc68cf164537128d6"},"provenance":null,"requires-python":null,"size":271857,"upload-time":"2013-11-20T20:05:28.007235Z","url":"https://files.pythonhosted.org/packages/24/39/4630dff3d0fa4896db905a118877fce5b72ced6629ca9958e207f7a0b198/psutil-1.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.tar.gz","hashes":{"sha256":"508e4a44c8253a386a0f86d9c9bd4a1b4cbb2f94e88d49a19c1513653ca66c45"},"provenance":null,"requires-python":null,"size":167397,"upload-time":"2013-11-25T20:06:20.566209Z","url":"https://files.pythonhosted.org/packages/8a/45/3b9dbd7a58482018927f756de098388ee252dd230143ddf486b3017117b1/psutil-1.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"f3af7b44925554531dff038e0401976a6b92b089ecca51d50be903420d7a262d"},"provenance":null,"requires-python":null,"size":307074,"upload-time":"2013-11-25T20:09:25.387664Z","url":"https://files.pythonhosted.org/packages/40/47/665755b95ad75e6223af96f2d7c04667f663a53dede0315df9832c38b60d/psutil-1.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"26fd84571ac026861d806a9f64e3bbfd38d619a8195c1edfd31c0a9ee2295b03"},"provenance":null,"requires-python":null,"size":329716,"upload-time":"2014-02-06T00:57:26.931878Z","url":"https://files.pythonhosted.org/packages/d8/65/2e9941492b3d001a87d87b5e5827b1f3cec42e30b7110fa82d24be8c4526/psutil-1.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.4.exe","hashes":{"sha256":"84a4e7e2de1ca6f45359cfd7fd60c807f494385a6d97804bd58759a94b9c5e2d"},"provenance":null,"requires-python":null,"size":143888,"upload-time":"2013-11-25T20:07:25.331363Z","url":"https://files.pythonhosted.org/packages/5c/99/d9147b76eea8c185b6cefbb46de73ae880e5ef0ff36d93cb3f6084e50d59/psutil-1.2.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.5.exe","hashes":{"sha256":"aad7d81607b3ad740fee47b27a9f1434a05fe35dc68abefb1f961f74bae3c3f9"},"provenance":null,"requires-python":null,"size":143868,"upload-time":"2013-11-25T20:07:40.595942Z","url":"https://files.pythonhosted.org/packages/bd/a0/5087d4a5145326a5a07a53ed4f9cd5c09bf5dad4f8d7b9850e6aaa13caa2/psutil-1.2.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.6.exe","hashes":{"sha256":"3ad3a40afd859cf0217a2d643c74be3a12ed2f54ebd4a91c40fa7b13084573c6"},"provenance":null,"requires-python":null,"size":278185,"upload-time":"2013-11-25T20:07:59.926444Z","url":"https://files.pythonhosted.org/packages/c6/e0/67810b602a598488d1f2982451655427effe7c7062184fe036c2b5bc928f/psutil-1.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.7.exe","hashes":{"sha256":"02fb79b9e5336ff179c44ce2017308cf46316e19bea70abb8855afd808db2a0f"},"provenance":null,"requires-python":null,"size":277955,"upload-time":"2013-11-25T20:08:20.641779Z","url":"https://files.pythonhosted.org/packages/5b/7f/9334b57597acabaaf2261c93bb9b1f9f02cdfef5c1b1aa808b262f770adb/psutil-1.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py3.2.exe","hashes":{"sha256":"7e64d065f12e8f941f2dbb2f3df0887b2677fee7b2b4c50ed91e490e094c7273"},"provenance":null,"requires-python":null,"size":277243,"upload-time":"2013-11-25T20:08:40.628203Z","url":"https://files.pythonhosted.org/packages/ae/c5/2842c69c67ae171f219efa8bb11bddc2fcec2cea059721e716fe4d48b50c/psutil-1.2.1.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py3.3.exe","hashes":{"sha256":"1a1c8e6635949a698b6ade3d5d2a8368daff916d8122cf13286c79a52ec8d7a1"},"provenance":null,"requires-python":null,"size":271900,"upload-time":"2013-11-25T20:09:05.464640Z","url":"https://files.pythonhosted.org/packages/86/df/007ca575da6ee7cbb015dc00122028ee0c97fc6a0c9e8bc02333753bfd2f/psutil-1.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.tar.gz","hashes":{"sha256":"38af34b0f40a4f50988a7401b7111ae4468beb5bcce0fbae409504dd3d5f2e8d"},"provenance":null,"requires-python":null,"size":207168,"upload-time":"2014-03-10T11:23:38.510743Z","url":"https://files.pythonhosted.org/packages/9c/2c/d4380234ddc21ecfb03691a982f5f26b03061e165658ac455b61886fe3ff/psutil-2.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"32f27f9be7c03f60f61dc27af2464cfb1edd64525d05b81478e80dc12913fe3b"},"provenance":null,"requires-python":null,"size":310569,"upload-time":"2014-03-10T11:16:14.555076Z","url":"https://files.pythonhosted.org/packages/c3/10/c0e1b505d7d2b4a7f3294c1b4b2bc2644a4629462d777fe2cdcd57b1debe/psutil-2.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"219cf2e5832cf68798e522e815d79a7307dea1f6b1d9b2372704f6e7fea085f3"},"provenance":null,"requires-python":null,"size":309024,"upload-time":"2014-03-10T11:16:29.122028Z","url":"https://files.pythonhosted.org/packages/eb/db/ab023b5ce09f314ee58ee4b9e73e85172dd06272501570a34a1afe6115c2/psutil-2.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"12b9c02e108e887a43e0ed44e3a8e9968e65236d6d0b79c45891471ea2b9e14d"},"provenance":null,"requires-python":null,"size":310130,"upload-time":"2014-03-10T11:16:49.562585Z","url":"https://files.pythonhosted.org/packages/67/94/0dded4aab9c4992bddb311d2ae8fd9a638df5f6039d12a4fe66481f3ea1c/psutil-2.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.4.exe","hashes":{"sha256":"54d8636623a4f676a9a38b0afe3dfad5f1b90f710f2cb6c55e1a0803813d76a5"},"provenance":null,"requires-python":null,"size":143691,"upload-time":"2014-03-10T11:20:46.107824Z","url":"https://files.pythonhosted.org/packages/76/a3/48c0984c0b65be53a9e3e090df0cd5f3e6bddd767c3f8e62cf286be240e1/psutil-2.0.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.5.exe","hashes":{"sha256":"f669fe7e7cab107fb738362366cc9e0ecda532269ac3a9815a28930b474edf0b"},"provenance":null,"requires-python":null,"size":147735,"upload-time":"2014-03-10T11:15:02.487295Z","url":"https://files.pythonhosted.org/packages/f8/ba/346cc719249b9a5281dab059cb8796aff6faf487142f50966fc08330ad79/psutil-2.0.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.6.exe","hashes":{"sha256":"33b580008e0c65073198472da81d0d0c50d2a30e3e82c269713b1e3bdf14c2c6"},"provenance":null,"requires-python":null,"size":280920,"upload-time":"2014-03-10T11:15:17.132174Z","url":"https://files.pythonhosted.org/packages/2f/6f/7326e900c5333d59aa96a574d13321c94a9357ab56b0dd489b8f24ebab78/psutil-2.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.7.exe","hashes":{"sha256":"4f9c78cdd57e1c83242096f8343617ae038efd1c23af3864c25992335eabed3f"},"provenance":null,"requires-python":null,"size":280693,"upload-time":"2014-03-10T11:15:31.704968Z","url":"https://files.pythonhosted.org/packages/18/dd/c81485b54894c35fd8b62822563293db7c4dd17a05ea4eade169cf383266/psutil-2.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py3.3.exe","hashes":{"sha256":"380f8ff680ce3c8fdd7b31a3fe42d697b15a0c8677559691ed90b755051a5acf"},"provenance":null,"requires-python":null,"size":275631,"upload-time":"2014-03-10T11:15:45.735326Z","url":"https://files.pythonhosted.org/packages/77/5a/e87efff3e46862421a9c87847e63ebecd3bb332031305b476399918fea4f/psutil-2.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py3.4.exe","hashes":{"sha256":"4239b2431c825db2ad98e404a96320f0c78fb1c7d5bdf52a49a00d36bedfa0df"},"provenance":null,"requires-python":null,"size":275638,"upload-time":"2014-03-10T11:16:00.263121Z","url":"https://files.pythonhosted.org/packages/c4/80/35eb7f189482d25e3669871e7dcd295ec38f792dc4670b8635d72b4f949a/psutil-2.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.tar.gz","hashes":{"sha256":"d1e3ce46736d86164b6d72070f2cbaf86dcf9db03066b7f36a7b302e334a8d01"},"provenance":null,"requires-python":null,"size":211640,"upload-time":"2014-04-08T14:59:37.598513Z","url":"https://files.pythonhosted.org/packages/6c/d1/69431c4fab9b5cecaf28f2f2e0abee21805c5783c47143db5f0f7d42dbec/psutil-2.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"9dc35f899946d58baf5b805ebed2f723f75d93f6b6bce212f79581d40f7276db"},"provenance":null,"requires-python":null,"size":312139,"upload-time":"2014-04-08T15:13:59.193442Z","url":"https://files.pythonhosted.org/packages/7a/3c/ce6a447030cdb50cf68a3988337df0c42e52abf45c3adfea3b225760eb70/psutil-2.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"46232b7b0eb48c6ec1f12d17b2cc15ec3cc70ed952f2c98edb50aaa405dafa5d"},"provenance":null,"requires-python":null,"size":310591,"upload-time":"2014-04-08T15:14:05.019441Z","url":"https://files.pythonhosted.org/packages/cd/60/7134a7f812ef1eba9373c86b95ce6254f5f58928baba04af161f0066629f/psutil-2.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"fa770a2c9e384924df021aed9aa5a6f92db8062a7f700113ba3943e262028454"},"provenance":null,"requires-python":null,"size":311682,"upload-time":"2014-04-08T15:14:24.701683Z","url":"https://files.pythonhosted.org/packages/45/56/3ac0a63799d54cb9b1914214944aed71e49297fb90de92b8d1fe20de3bd8/psutil-2.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.4.exe","hashes":{"sha256":"15d0d10bbd60e461690188cdd209d6688a1112648589bf291b17cc84e99cb6e7"},"provenance":null,"requires-python":null,"size":145275,"upload-time":"2014-04-08T15:12:04.809516Z","url":"https://files.pythonhosted.org/packages/09/e8/f6e4209b3d6373ea11fa340c2e6e4640a7ee53ef4697c49d610ffdf86674/psutil-2.1.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.5.exe","hashes":{"sha256":"381ac1027a270c04cf6decdc011a28a4270105d009f213d62daec4b3116b92b6"},"provenance":null,"requires-python":null,"size":149378,"upload-time":"2014-04-08T15:12:25.638187Z","url":"https://files.pythonhosted.org/packages/6d/05/0e7213e6f0dc71490a523a70e6ab5e7cd5140d87dc93a4447da58c440d6b/psutil-2.1.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.6.exe","hashes":{"sha256":"7eda949fbdf89548b0e52e7d666e096ea66b30b65bcbe04d305e036a24a76d11"},"provenance":null,"requires-python":null,"size":282509,"upload-time":"2014-04-08T15:12:57.055047Z","url":"https://files.pythonhosted.org/packages/f2/88/a856c5ed36d15b8ad74597f380baa29891ec284e7a1be4cb2f91f8453bd8/psutil-2.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.7.exe","hashes":{"sha256":"f1ec06db1b0d27681a1bea4c9f0b33705bc5a00035c32f168da0ea193883bb91"},"provenance":null,"requires-python":null,"size":282317,"upload-time":"2014-04-08T15:13:11.798772Z","url":"https://files.pythonhosted.org/packages/d0/17/ec99e9252dae834f4a012e13c804c86907fcb1cb474f7b1bc767562bfa7b/psutil-2.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py3.3.exe","hashes":{"sha256":"feccef3ccf09785c6f81e67223cf2d8736a90c8994623dd75f683dd2bf849235"},"provenance":null,"requires-python":null,"size":277268,"upload-time":"2014-04-08T15:13:26.711424Z","url":"https://files.pythonhosted.org/packages/f0/0a/32abfd9b965c9a433b5011574c904372b954330c170c6f92b637d661ecd2/psutil-2.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py3.4.exe","hashes":{"sha256":"4719134be984b0f2ba072ff761f334c2f3dbb8ca6af70ba43d8ca31b7e13c3db"},"provenance":null,"requires-python":null,"size":277279,"upload-time":"2014-04-08T15:13:41.834397Z","url":"https://files.pythonhosted.org/packages/f5/3b/eab6a8d832d805c7a00d0f2398c12a32bea7e8b6eb7d5fbdf869e4bcc9e0/psutil-2.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.tar.gz","hashes":{"sha256":"bf812a4aa6a41147d0e96e63d826eb7582fda6b54ad8f22534354b7f8ac45593"},"provenance":null,"requires-python":null,"size":216796,"upload-time":"2014-04-30T14:27:01.651394Z","url":"https://files.pythonhosted.org/packages/64/4b/70601d39b8e445265ed148affc49f7bfbd246940637785be5c80e007fa6e/psutil-2.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"1b5ee64306535a625b77648e32f1b064c31bf58bfc7a37cde6c7bb3fa4abb6bd"},"provenance":null,"requires-python":null,"size":312763,"upload-time":"2014-04-30T14:31:09.411365Z","url":"https://files.pythonhosted.org/packages/e6/50/df05e0cbfcf20f022756d5e2da32b4f4f37d5bca6f5bd6965b4ef0460e8b/psutil-2.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"9e28fe35e1185d59ba55313d90efc122d45b7a2e3fa304869024d26b0a809bc5"},"provenance":null,"requires-python":null,"size":311262,"upload-time":"2014-04-30T14:31:28.733500Z","url":"https://files.pythonhosted.org/packages/a3/a9/b3f114141a49244739321f221f35c300ac7f34ec9e3a352ea70c9fae41f8/psutil-2.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"3afa327284a218d6a25b2f3520135337cfa4a47eaea030273ad8eb02894d60fe"},"provenance":null,"requires-python":null,"size":312365,"upload-time":"2014-04-30T14:31:47.981590Z","url":"https://files.pythonhosted.org/packages/c7/67/2aae3f66090c2e06fa60c29a2e554fd2a718949aca53bca78d640212cb34/psutil-2.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.4.exe","hashes":{"sha256":"7c76d99bfaeafbcf66096c69b8fca1f7269603d66cad1b14cd8dd93b14bceeb0"},"provenance":null,"requires-python":null,"size":145848,"upload-time":"2014-04-30T14:37:26.909225Z","url":"https://files.pythonhosted.org/packages/27/4e/c9b4802420d6b5d0a844208c9b8a4e25b3c37305428e40bc1da6f5076891/psutil-2.1.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.5.exe","hashes":{"sha256":"6aeb358b66cc4367378edadb928c77e82646f36858b2a516298d1917aa6aca25"},"provenance":null,"requires-python":null,"size":149998,"upload-time":"2014-04-30T14:28:49.630619Z","url":"https://files.pythonhosted.org/packages/5d/e9/69dee6454940bb102fbbcaa1e44b46bfefc4c0bf53e5e3835d3de3ebc9ae/psutil-2.1.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.6.exe","hashes":{"sha256":"a53546550067773920e1f7e6e3f1fad2f2befe45c6ff6c94e22b67f4b54c321a"},"provenance":null,"requires-python":null,"size":283143,"upload-time":"2014-04-30T14:29:06.869445Z","url":"https://files.pythonhosted.org/packages/9f/45/d2dfa6bdd9b64bfd46ad35af774c3819e0d5abf23a99d51adf11984ca658/psutil-2.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.7.exe","hashes":{"sha256":"37ce747f9042c375f62e861d627b5eb7bace24767303f5d0c4c03d17173a551c"},"provenance":null,"requires-python":null,"size":282941,"upload-time":"2014-04-30T14:29:27.059188Z","url":"https://files.pythonhosted.org/packages/78/47/14db8651f9863d301c0673d25fa22b87d13fde2974f94854502886a21fd1/psutil-2.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py3.3.exe","hashes":{"sha256":"8f0f88752e1e9bfeced78daf29d90e0028d17f39b805bb0acf70fefe77ba5ccb"},"provenance":null,"requires-python":null,"size":277944,"upload-time":"2014-04-30T14:29:49.405456Z","url":"https://files.pythonhosted.org/packages/f1/63/2fcaa58b101dce55a12f768508a7f0a0028ccc5a90633d86dd4cc0bcdb52/psutil-2.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py3.4.exe","hashes":{"sha256":"bc353df13a6ea40651cba82810a38590e2439c158cf6f130cd0876d0dda53118"},"provenance":null,"requires-python":null,"size":279092,"upload-time":"2014-04-30T14:30:08.449338Z","url":"https://files.pythonhosted.org/packages/5f/26/0be35c7f3dc9e78d405ed6be3aa76a9ce97b51e0076db98408a6f2c288fb/psutil-2.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp26-none-win32.whl","hashes":{"sha256":"ccb5e28357a4b6c572b97e710a070f349e9b45172315eaed6e0b72e86d333b68"},"provenance":null,"requires-python":null,"size":83869,"upload-time":"2014-09-21T13:47:09.164866Z","url":"https://files.pythonhosted.org/packages/c7/22/811ac7c641191e3b65c053c95eb34f6567bbc5155912630464271ab6f3df/psutil-2.1.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp27-none-win32.whl","hashes":{"sha256":"41992126c0281c2f5f279a0e8583382a3b840bd0d48262dfb7bc3cb67bdc6587"},"provenance":null,"requires-python":null,"size":83672,"upload-time":"2014-09-21T13:47:14.034296Z","url":"https://files.pythonhosted.org/packages/79/9d/154b179a73695ae605856c2d77ab5da2a66ef4819c3c4f97e4ab297a2902/psutil-2.1.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp27-none-win_amd64.whl","hashes":{"sha256":"79cb57bba4cbeebb7e445d19c531107493458a47d0f4c888ce49fc8dec670c32"},"provenance":null,"requires-python":null,"size":85848,"upload-time":"2014-09-21T13:47:30.044802Z","url":"https://files.pythonhosted.org/packages/00/ae/567c30ff44c263cc78dfe50197184e58b62ca9fcfebad144cd235f5d8d2d/psutil-2.1.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp33-none-win32.whl","hashes":{"sha256":"c5e6424833620f0d0a70ebc1305260bfad4b5c73989b8a2e8bd01bf39b4b600c"},"provenance":null,"requires-python":null,"size":83742,"upload-time":"2014-09-21T13:47:18.481401Z","url":"https://files.pythonhosted.org/packages/62/4d/be87c318274ade9d6589e8545dd5d5bb4bcc42e92334d88d948cf8daa36b/psutil-2.1.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp33-none-win_amd64.whl","hashes":{"sha256":"b4c69627c245025b9209acbffc066ff8ac1237d13e2eddd0461f3149969b7da3"},"provenance":null,"requires-python":null,"size":85822,"upload-time":"2014-09-21T13:47:33.681070Z","url":"https://files.pythonhosted.org/packages/bc/52/ab3c88a0574275ec33d9de0fe7dc9b1a32c573de0e468502876bc1df6f84/psutil-2.1.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp34-none-win32.whl","hashes":{"sha256":"97a1d0ddbb028a20feffaf7fa3d0c451004abc74ef7ea1e492d039f8b7278399"},"provenance":null,"requires-python":null,"size":83748,"upload-time":"2014-09-21T13:47:25.367914Z","url":"https://files.pythonhosted.org/packages/ef/4a/c956675314e4a50b319d9894c2ee2d48ce83df4d639d9c2fc06a99415dec/psutil-2.1.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp34-none-win_amd64.whl","hashes":{"sha256":"a78226f9236c674d43b206e7da06478cf2bcf10e5aee647f671878ea2434805f"},"provenance":null,"requires-python":null,"size":85789,"upload-time":"2014-09-21T13:47:38.760178Z","url":"https://files.pythonhosted.org/packages/b9/41/68b5fc38b97e037ef55e6475d618c079fe2b5d148f5e3fda795c21d888a7/psutil-2.1.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.tar.gz","hashes":{"sha256":"897e5163e0669001bf8bcb0557362f14703356336519082a93c38d54e5b392e4"},"provenance":null,"requires-python":null,"size":223595,"upload-time":"2014-09-21T13:50:56.650693Z","url":"https://files.pythonhosted.org/packages/53/6a/8051b913b2f94eb00fd045fe9e14a7182b6e7f088b12c308edd7616a559b/psutil-2.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"3ed7ef4ab59894e6eb94adae0b656733c91906af169b55443329315322cd63b3"},"provenance":null,"requires-python":null,"size":319335,"upload-time":"2014-09-21T13:48:15.057062Z","url":"https://files.pythonhosted.org/packages/a6/88/cc912d38640ddf3441db1f85f8ff8a87f906056554239a4a211970cf6446/psutil-2.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py3.3.exe","hashes":{"sha256":"e20f317187a7186e13dc6fdd6960083c227db86fffbb145fe000e8c167a854a6"},"provenance":null,"requires-python":null,"size":317817,"upload-time":"2014-09-21T13:48:20.665047Z","url":"https://files.pythonhosted.org/packages/d2/b4/887323eb2b0b5becb5a7b77ab04167741346fddffe27bc6ae5deeffcc3c1/psutil-2.1.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py3.4.exe","hashes":{"sha256":"f7f2a61be7a828656dceffdf0d2fa304a144db6ab5ec4e2b033108f3822df6ff"},"provenance":null,"requires-python":null,"size":317804,"upload-time":"2014-09-21T13:48:33.226186Z","url":"https://files.pythonhosted.org/packages/57/e5/c041b08bea32246f53b7cf27b897e882a695f3ea95eb632b384dd35cf41f/psutil-2.1.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.4.exe","hashes":{"sha256":"77aac0179fe0e8b39c9b25ea732285d307bb941e715075366dc467b8609ebf09"},"provenance":null,"requires-python":null,"size":155426,"upload-time":"2014-09-21T13:54:03.017765Z","url":"https://files.pythonhosted.org/packages/ce/3f/7c434baec7ca47e65fb1e3bcbc8fe1c9f504d93c750a7fa4f98b16635920/psutil-2.1.2.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.5.exe","hashes":{"sha256":"982f4568876d10881f9c90fe992d1d9af353a59b5de7771cc4766d7432aee7ab"},"provenance":null,"requires-python":null,"size":155414,"upload-time":"2014-09-21T13:47:47.970150Z","url":"https://files.pythonhosted.org/packages/46/86/2971b31e2637ddc53adce2d997472cee8d4dec366d5a1e140945b95860d5/psutil-2.1.2.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.6.exe","hashes":{"sha256":"f35d91b5fc2b52472c0766fa411ac22f7a5ed8b1ececd96c1486380bdad0bb41"},"provenance":null,"requires-python":null,"size":289714,"upload-time":"2014-09-21T13:47:52.391726Z","url":"https://files.pythonhosted.org/packages/dd/3e/cdc3d4f343e6edc583d0686d1d20d98f9e11de35c51dc7990525ab2ca332/psutil-2.1.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.7.exe","hashes":{"sha256":"dbd9e4fbe08c0ff6d4a87a4d6dfae16fccd03346f980cffa105941de8801d00b"},"provenance":null,"requires-python":null,"size":289515,"upload-time":"2014-09-21T13:47:57.624310Z","url":"https://files.pythonhosted.org/packages/fb/01/73753147113f6db19734db6e7ac994cee5cce0f0935e12320d7aa1b56a14/psutil-2.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py3.3.exe","hashes":{"sha256":"73428e7b695e5889f07f1b37c5ec0cc0f49d3808dc40986050f1b13fd7c4c71e"},"provenance":null,"requires-python":null,"size":284506,"upload-time":"2014-09-21T13:48:02.428235Z","url":"https://files.pythonhosted.org/packages/b0/97/ba13c3915aba7776bb0d23819c04255230c46df1f8582752f7e0382c0b67/psutil-2.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py3.4.exe","hashes":{"sha256":"e2326c7b9f64a0f22891d3b362efcd92389e641023b07bc54567280c0c2e160d"},"provenance":null,"requires-python":null,"size":284538,"upload-time":"2014-09-21T13:48:08.358281Z","url":"https://files.pythonhosted.org/packages/88/bd/843fadc578d62f2888d5a7b4e2a418a28140ac239a5a5039c0d3678df647/psutil-2.1.2.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp26-none-win32.whl","hashes":{"sha256":"331a3b0b6688f95acebe87c02efca53003e613f1c7892a09063a9d3c0af33656"},"provenance":null,"requires-python":null,"size":83927,"upload-time":"2014-09-26T20:26:46.078909Z","url":"https://files.pythonhosted.org/packages/72/4c/f93448dfe2dec286b6eae91a00c32f1fbf65506e089354c51db76f4efdaf/psutil-2.1.3-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp27-none-win32.whl","hashes":{"sha256":"5ee9e17f6e92aaec7c53f6483c6708eec22124060a52ac339d104effcb4af37f"},"provenance":null,"requires-python":null,"size":83731,"upload-time":"2014-09-26T20:26:51.215134Z","url":"https://files.pythonhosted.org/packages/27/c5/a644b5df545c467569c7b8e768717fad6758eab8e2544b7d412d07c30ffe/psutil-2.1.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp27-none-win_amd64.whl","hashes":{"sha256":"47ea728de15c16a7cb476eb4f348be57e9daebfa730b9a4a104e9086da2cf6cd"},"provenance":null,"requires-python":null,"size":85906,"upload-time":"2014-09-26T20:27:07.470817Z","url":"https://files.pythonhosted.org/packages/89/82/1070ecb59d83967ddb2ea58b41ba2b9ffa8f3f686a3f49b8d33dc5684964/psutil-2.1.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp33-none-win32.whl","hashes":{"sha256":"ae0aac37af1d7d6821bb11dcffb12bb885b44773858bd40703e9dcb14325369c"},"provenance":null,"requires-python":null,"size":83804,"upload-time":"2014-09-26T20:26:56.233644Z","url":"https://files.pythonhosted.org/packages/b6/fc/7f2ceac523bb5ce9ea93bd85806ebb2d5327f0e430cbb6e70d32e4306e1d/psutil-2.1.3-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp33-none-win_amd64.whl","hashes":{"sha256":"45ebaf679050a6d64a32a91d901791868a29574f6961629997dcd4661edb4ece"},"provenance":null,"requires-python":null,"size":85884,"upload-time":"2014-09-26T20:27:12.800416Z","url":"https://files.pythonhosted.org/packages/45/33/a50ed3def836cd8fc53ce04d09e50df67a6816fd24a819e8e9c45b93fc74/psutil-2.1.3-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp34-none-win32.whl","hashes":{"sha256":"0ae7d503fc458181af7dd9a2bbf43c4b5fc7cd6e6797ef4a6d58bb8046026d76"},"provenance":null,"requires-python":null,"size":83804,"upload-time":"2014-09-26T20:27:02.155242Z","url":"https://files.pythonhosted.org/packages/55/e9/c122a9d2528cc36ff4f2824a714ee6d5da5462e4b6725e6b1c7098142c4a/psutil-2.1.3-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp34-none-win_amd64.whl","hashes":{"sha256":"da0961ba9a6d97c137381cd59b7d330894dd4f7deb5a8291bc3251375fd6d6ec"},"provenance":null,"requires-python":null,"size":85840,"upload-time":"2014-09-26T20:27:18.296315Z","url":"https://files.pythonhosted.org/packages/6f/97/5e01561cde882306c28e462b427f67d549add65f5fca324bf0bbdf831d21/psutil-2.1.3-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.tar.gz","hashes":{"sha256":"b434c75f01715777391f10f456002e33d0ca14633f96fdbd9ff9139b42d9452c"},"provenance":null,"requires-python":null,"size":224008,"upload-time":"2014-09-30T18:10:37.283557Z","url":"https://files.pythonhosted.org/packages/fe/a3/7cf43f28bbb52c4d680378f99e900ced201ade5073ee3a7b30e7f09e3c66/psutil-2.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"449d07df8f8b9700cfae4ee67f0a73e4f96b55697428ae92cab29e33db4c3102"},"provenance":null,"requires-python":null,"size":319620,"upload-time":"2014-09-26T20:24:42.575161Z","url":"https://files.pythonhosted.org/packages/0e/66/bf4346c9ada08acee7e8f87d270fb4d4e6c86a477630adcfa3caa69aa5bb/psutil-2.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py3.3.exe","hashes":{"sha256":"5b444e5c1f3d3ee7a19a5720c62d6462fe81dd1d1bbb8aa955546ead509b3c4a"},"provenance":null,"requires-python":null,"size":318101,"upload-time":"2014-09-26T20:24:47.973672Z","url":"https://files.pythonhosted.org/packages/bd/a7/888e9fa42c8d475de7b467b9635bb18ed360cb1c261bcf59f5f932d624ea/psutil-2.1.3.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py3.4.exe","hashes":{"sha256":"3d25b4b20aabd360b7eda3dcbf4a14d2b256c2f61a8a569028e1c4b65b4d585a"},"provenance":null,"requires-python":null,"size":318089,"upload-time":"2014-09-26T20:24:55.536742Z","url":"https://files.pythonhosted.org/packages/b1/15/3f657d395213ad90efed423c88f1cb2f3b0a429d12bdea98a28c26de7ff4/psutil-2.1.3.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.4.exe","hashes":{"sha256":"36424b4e683d640291a1723f46a3949ebea37e43492f61027c168fb9dfe2055f"},"provenance":null,"requires-python":null,"size":155710,"upload-time":"2014-09-26T20:29:01.901009Z","url":"https://files.pythonhosted.org/packages/31/2e/d5448240fed09e88bbb59de194e1f2d3ba29f936a3231d718e5373736299/psutil-2.1.3.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.5.exe","hashes":{"sha256":"baa1803aaa4505fcf48bbd50d038d1f686d9e290defeecde41770d8fe876812b"},"provenance":null,"requires-python":null,"size":155699,"upload-time":"2014-09-26T20:24:13.810499Z","url":"https://files.pythonhosted.org/packages/2a/45/10d7b5057b3f941f803ca8ee690e651d2778e731f15ef3eee83c3f05f82f/psutil-2.1.3.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.6.exe","hashes":{"sha256":"55811a125d8a79bed0a65ed855fafc34f7d59cde162542a30cfa518da9e015bc"},"provenance":null,"requires-python":null,"size":289998,"upload-time":"2014-09-26T20:24:18.935804Z","url":"https://files.pythonhosted.org/packages/f3/4d/7f105269ece54ad7344c2a24b42ecb216b2746460f349c0ed1577b5ab8fa/psutil-2.1.3.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.7.exe","hashes":{"sha256":"6a1c8f1884f1983f8b74fda5dc89da07a69e3972fc022c3205f4964e1b01d235"},"provenance":null,"requires-python":null,"size":289802,"upload-time":"2014-09-26T20:24:24.112924Z","url":"https://files.pythonhosted.org/packages/93/64/1432ca27dfd7102a6726161b79b15a2997f461d3835867271a6c1e3353f7/psutil-2.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py3.3.exe","hashes":{"sha256":"8df72fcd30436e78bf8c5c6c796bb6815966511fa0bc8e3065e1aabbe4a2cf3d"},"provenance":null,"requires-python":null,"size":284794,"upload-time":"2014-09-26T20:24:30.110864Z","url":"https://files.pythonhosted.org/packages/0a/bb/d6cc7133624e3532e1d99f6cece35be7bd8d95ff7c82ca28cd502388c225/psutil-2.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py3.4.exe","hashes":{"sha256":"1f353ab0bbe0216e3a1636bfefb70ed366a2b1d95c95689f97e95d603626ef70"},"provenance":null,"requires-python":null,"size":284824,"upload-time":"2014-09-26T20:24:36.842776Z","url":"https://files.pythonhosted.org/packages/4a/66/9b1acf05dba9b9cb012ab3b8ed3d0fd7b01e1620808977fa6f1efe05dee2/psutil-2.1.3.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp26-none-win32.whl","hashes":{"sha256":"c92d2853ac52d5aaf8c2366435fb74892f7503daf2cf56b785f1ecadbf68e712"},"provenance":null,"requires-python":null,"size":82092,"upload-time":"2015-01-06T15:36:18.243917Z","url":"https://files.pythonhosted.org/packages/3c/65/f5bd2f8b54f14d950596c0c63d7b0f98b6dc779f7c61ac0dd2e9fc7e5e74/psutil-2.2.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp27-none-win32.whl","hashes":{"sha256":"6ad0e79b95f57a20f0cace08a063b0fc33fd83da1e5e501bc800bc69329a4501"},"provenance":null,"requires-python":null,"size":81891,"upload-time":"2015-01-06T15:36:28.466138Z","url":"https://files.pythonhosted.org/packages/6a/e6/96a4b4976f0eca169715d975b8c669b78b9afca58f9aadf261915694b73e/psutil-2.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"bbe719046986568ed3e84ce66ed617eebc46251ea8193566b3707abdf635afe6"},"provenance":null,"requires-python":null,"size":84072,"upload-time":"2015-01-06T15:36:58.206788Z","url":"https://files.pythonhosted.org/packages/28/28/4e4f94c9778ed16163f6c3dd696ce5e331121ac1600308830a3e98fa979a/psutil-2.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp33-none-win32.whl","hashes":{"sha256":"73013822a953fc4e3fb269256ec01b261752c590e23851e666201d1bfd32a3a9"},"provenance":null,"requires-python":null,"size":81885,"upload-time":"2015-01-06T15:36:38.776238Z","url":"https://files.pythonhosted.org/packages/66/8d/3143623c2f5bc264197727854040fdc02e3175b4ad991490586db7a512ed/psutil-2.2.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp33-none-win_amd64.whl","hashes":{"sha256":"d664a896feb10ec5bf4c43f4df8b6c7fceeb94677004cc9cf8c9f35b52c0e4fc"},"provenance":null,"requires-python":null,"size":84002,"upload-time":"2015-01-06T15:37:08.775842Z","url":"https://files.pythonhosted.org/packages/bd/08/112807380b8e7b76de8c84f920234a0ebed35e6511271f93f900f691a10c/psutil-2.2.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp34-none-win32.whl","hashes":{"sha256":"84299c41b251bef2a8b0812d651f4715209b3c4dfebe4a5df0f103bbdec78221"},"provenance":null,"requires-python":null,"size":81886,"upload-time":"2015-01-06T15:36:49.808417Z","url":"https://files.pythonhosted.org/packages/ef/0e/0cf2fea8f6e2e5ef84797eefc2c5ce561123e2417d7b931a6c54f9f8d413/psutil-2.2.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp34-none-win_amd64.whl","hashes":{"sha256":"3636879fcbde2b0b63db08abd0e3673c2cc72bb14075e46e15f98774b0c78236"},"provenance":null,"requires-python":null,"size":83954,"upload-time":"2015-01-06T15:37:18.558007Z","url":"https://files.pythonhosted.org/packages/82/ed/ce9c4281fd8a944a725c0f9a5d77f32295777ab22f54b4f706a51d59edd3/psutil-2.2.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.tar.gz","hashes":{"sha256":"b15cc9e7cad0991bd1cb806fa90ea85ba3a95d0f1226625ecef993294ad61521"},"provenance":null,"requires-python":null,"size":223676,"upload-time":"2015-01-06T15:38:45.979998Z","url":"https://files.pythonhosted.org/packages/ba/e4/760f64a8a5a5f1b95f3ce17c0d51134952f930caf1218e6ce21902f6c4ab/psutil-2.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"623baf2a213adc99cbc067e1db04b9e578eb4c38d9535c903e04b6d1ded10cab"},"provenance":null,"requires-python":null,"size":317990,"upload-time":"2015-01-06T15:34:57.187611Z","url":"https://files.pythonhosted.org/packages/30/a8/d1754e9e5492717d1c1afb30970f0677056052859f1af935b48c72c6cd68/psutil-2.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"fc6d348f603ae8465992a7edbc7c62cc16f0493bdd43aa609dcb7437992cac96"},"provenance":null,"requires-python":null,"size":316424,"upload-time":"2015-01-06T15:35:20.860940Z","url":"https://files.pythonhosted.org/packages/32/f1/e98caa1f6be7ba49dfafa0fbb63f50ffa191d316a1b2b3ec431d97ebf494/psutil-2.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"5e4508ca6822839f25310bfc14c050e60362dc29ddea6f5eac91de2c7423a471"},"provenance":null,"requires-python":null,"size":316403,"upload-time":"2015-01-06T15:35:42.094623Z","url":"https://files.pythonhosted.org/packages/dd/46/31505418bd950b09d28c6c21be76a4a51d593ec06b412539797080c0aa6b/psutil-2.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py2.6.exe","hashes":{"sha256":"1f93ccdf415da40f15a84ab6d9d32ddda61bb1b20079dae602356e087f408d28"},"provenance":null,"requires-python":null,"size":288364,"upload-time":"2015-01-06T15:33:25.830661Z","url":"https://files.pythonhosted.org/packages/9c/0d/f360da29c906dafd825edccc219e70dab73370ad2c287fa5baa9f7fa370b/psutil-2.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py2.7.exe","hashes":{"sha256":"83eb1739b7c87a21a65224d77217325e582199bedd0141b29dac81b4e4144c62"},"provenance":null,"requires-python":null,"size":288166,"upload-time":"2015-01-06T15:33:46.994076Z","url":"https://files.pythonhosted.org/packages/7a/30/5bb6644318f2279caf5d334f32df19fe4b2bce11ef418af32124e16f8e98/psutil-2.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py3.3.exe","hashes":{"sha256":"9db585f37d56381c37738e03aa8beb0b501b26adc7c70660ff182e0473f2cb0a"},"provenance":null,"requires-python":null,"size":283089,"upload-time":"2015-01-06T15:34:11.431221Z","url":"https://files.pythonhosted.org/packages/12/c4/cb75d51edb425ff77e2af5bb32e405ed41beb124ad062fb927bbe135c709/psutil-2.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py3.4.exe","hashes":{"sha256":"4a0d8a192d1523a3f02a4028bf4ac296f7da92c935464d302618bd639c03a2c6"},"provenance":null,"requires-python":null,"size":283110,"upload-time":"2015-01-06T15:34:33.472476Z","url":"https://files.pythonhosted.org/packages/17/fb/ae589efdfd076d1961e1f858c969d234a63e26f648a79b3fac0409e95c2f/psutil-2.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp26-none-win32.whl","hashes":{"sha256":"610f08fc0df646e4997b52f2bf2e40118a560738422d540883297c6f4e38be8c"},"provenance":null,"requires-python":null,"size":82104,"upload-time":"2015-02-02T13:08:03.993201Z","url":"https://files.pythonhosted.org/packages/0a/a7/b6323d30a8dde3f6a139809898e4bdcabcae3129314621aa24eb5ca4468e/psutil-2.2.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp27-none-win32.whl","hashes":{"sha256":"84ec9e77cab1d9ecf2d93bf43eba255a11b26d480966ee542bc846be1e272ea5"},"provenance":null,"requires-python":null,"size":81907,"upload-time":"2015-02-02T13:08:14.963426Z","url":"https://files.pythonhosted.org/packages/40/b6/a94c6d00ac18f779c72973639b78519de0c488e8e8e8d00b65cf4287bec3/psutil-2.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"81a6ab277886f233f230c46073fa6fc97ca2a95a44a14b80c6f6054acb7a644b"},"provenance":null,"requires-python":null,"size":84086,"upload-time":"2015-02-02T13:08:42.917519Z","url":"https://files.pythonhosted.org/packages/1c/ff/6b00405e4eeb3c40d4fc07142ef7bdc3a7a7aa2a1640b65e654bdb7682d1/psutil-2.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp33-none-win32.whl","hashes":{"sha256":"f5e0d247b09c9460b896ff89098015b7687a2934d4ed6165a5c3a662fad7ab6b"},"provenance":null,"requires-python":null,"size":81896,"upload-time":"2015-02-02T13:08:24.437138Z","url":"https://files.pythonhosted.org/packages/a2/fe/40b7d42057c5e68ff4c733b5689e9ae9d8785f13576326ba44371689eff7/psutil-2.2.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp33-none-win_amd64.whl","hashes":{"sha256":"07f31cbe5fc1183c8efb52bab9a5382ebd001a6e11b5a5df827f69456219d514"},"provenance":null,"requires-python":null,"size":84011,"upload-time":"2015-02-02T13:08:53.420801Z","url":"https://files.pythonhosted.org/packages/fe/8d/ffc94f092a12fc3cb837b9bda93abd88fb12219bcc6684b9bffea5e1f385/psutil-2.2.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp34-none-win32.whl","hashes":{"sha256":"a98b350251df2658c9be6bf0b6ebbab10fe88ccb513079c2c56fb53330530ee6"},"provenance":null,"requires-python":null,"size":81896,"upload-time":"2015-02-02T13:08:34.116542Z","url":"https://files.pythonhosted.org/packages/7f/3a/4bb24092c3de0a44f2fc1afb7bcaf898f1daba67cba5b9188b0ae6527102/psutil-2.2.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp34-none-win_amd64.whl","hashes":{"sha256":"f49d3ca9150f20269eae79d6efac98f0bbe4e5ceac46fe418d881560a04b6d8e"},"provenance":null,"requires-python":null,"size":83963,"upload-time":"2015-02-02T13:09:03.990685Z","url":"https://files.pythonhosted.org/packages/64/f7/c385e9350abbbb082364596fd4b0066fcb0c51ebc103a7ebf6eb9bc837e9/psutil-2.2.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.tar.gz","hashes":{"sha256":"a0e9b96f1946975064724e242ac159f3260db24ffa591c3da0a355361a3a337f"},"provenance":null,"requires-python":null,"size":223688,"upload-time":"2015-02-02T13:10:14.673714Z","url":"https://files.pythonhosted.org/packages/df/47/ee54ef14dd40f8ce831a7581001a5096494dc99fe71586260ca6b531fe86/psutil-2.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"552eaba2dbc9a49af2da64fc00cedf8847c7c9c2559cc620d9c8855583105764"},"provenance":null,"requires-python":null,"size":317995,"upload-time":"2015-02-02T13:06:42.422390Z","url":"https://files.pythonhosted.org/packages/97/27/e64014166df9efc3d00f987a251938d534d3897d62ef21486559a697a770/psutil-2.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"d25746746f2680d6174c9eb0e2793cb73304ca200d5ec7334000fdb575cd6577"},"provenance":null,"requires-python":null,"size":316429,"upload-time":"2015-02-02T13:07:07.458895Z","url":"https://files.pythonhosted.org/packages/c2/dd/5fdd5fd6102ae546452a5f32a6f75ec44c11d6b84c188dd33cfe1e2809e1/psutil-2.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"298ed760a365a846337750c5089adcec2a87014c61132ae39db671982750f35a"},"provenance":null,"requires-python":null,"size":316409,"upload-time":"2015-02-02T13:07:29.047577Z","url":"https://files.pythonhosted.org/packages/d9/59/0f14daf5797c61db2fec25bca49b49aa0a5d57dec57b4e58ae4652dadb95/psutil-2.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py2.6.exe","hashes":{"sha256":"6e49f72a1cd57918b275fdf7dd041618696fc39d5705ac722fdfccaf0b784a93"},"provenance":null,"requires-python":null,"size":288372,"upload-time":"2015-02-02T13:05:10.073479Z","url":"https://files.pythonhosted.org/packages/0c/a2/63967c61fbfc3f60c1b17e652a52d1afeb3c56403990c5a8f2fb801e2aa1/psutil-2.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py2.7.exe","hashes":{"sha256":"9227949290983df92bb3bb57c5b25605ebbc0e61a3f9baa394f752ed7abc914c"},"provenance":null,"requires-python":null,"size":288171,"upload-time":"2015-02-02T13:05:31.604222Z","url":"https://files.pythonhosted.org/packages/46/f3/d50f059d7d297db7335e340333124eac9441c5897bb29223c85ebaa64e7d/psutil-2.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py3.3.exe","hashes":{"sha256":"f8d94c8228011d1b658c39783596d95244e01950413bfc41fd44e78129ef7075"},"provenance":null,"requires-python":null,"size":283095,"upload-time":"2015-02-02T13:05:54.134208Z","url":"https://files.pythonhosted.org/packages/4a/d6/341767cdc6890adfb19ad60683e66dab3cdde605bc226427c8ec17dbd3f5/psutil-2.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py3.4.exe","hashes":{"sha256":"1e1df017bfa14c0edc87a124b11ca6e7fd8b6b5c9692eb06c1b72077bcca3845"},"provenance":null,"requires-python":null,"size":283115,"upload-time":"2015-02-02T13:06:12.827127Z","url":"https://files.pythonhosted.org/packages/8c/c1/24179e79ab74bde86ee766c4c0d2bb90b98e4e4d14017efeec024caba268/psutil-2.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"data-dist-info-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"filename":"psutil-3.0.0-cp27-none-win32.whl","hashes":{"sha256":"9641677de91769127c82aa032b70a8d9aa75369d0a9965aba880ac335b02eccb"},"provenance":null,"requires-python":null,"size":85709,"upload-time":"2015-06-13T19:16:33.857911Z","url":"https://files.pythonhosted.org/packages/bb/cf/f893fa2fb0888384b5d668e22b6e3652c9ce187e749604027a64a6bd6646/psutil-3.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"data-dist-info-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"filename":"psutil-3.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"11c6b17b37ab1ea04f6a1365bc4598637490819d6b744f3947fd3b8b425366b3"},"provenance":null,"requires-python":null,"size":88043,"upload-time":"2015-06-13T19:16:52.139563Z","url":"https://files.pythonhosted.org/packages/f1/26/a0904455b550f7fd5baa069ca10889825cc22440147813713998cd0676a0/psutil-3.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp33-none-win32.whl","hashes":{"sha256":"8333d2a496fe5d24171360ab1f78468db7a9691d61fd26bf15ca62336c699bac"},"provenance":null,"requires-python":null,"size":85737,"upload-time":"2015-06-13T19:16:39.871421Z","url":"https://files.pythonhosted.org/packages/ea/45/defb71d5009e178ef13e2474627a1070ae291b2dee64ae00e8f2b1a2aec2/psutil-3.0.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp33-none-win_amd64.whl","hashes":{"sha256":"44711a1a683369056d99fd08a05789d217205d72b6dbbe75c0b3743c5e1e3768"},"provenance":null,"requires-python":null,"size":87943,"upload-time":"2015-06-13T19:16:58.439865Z","url":"https://files.pythonhosted.org/packages/3c/0b/648fbaef2a037cc0c05388c0416ba3ca9244c22c4156dba73e4a900540a6/psutil-3.0.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp34-none-win32.whl","hashes":{"sha256":"9036f9c57a8c8a571f36c7d3b2c9a15a22dc9a95137fa60191e2eaa9527209d5"},"provenance":null,"requires-python":null,"size":85695,"upload-time":"2015-06-13T19:16:46.286646Z","url":"https://files.pythonhosted.org/packages/6d/ca/1d5dafae4d7396a825531296b6837b45129b63463b4eb221ac3429eb157d/psutil-3.0.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp34-none-win_amd64.whl","hashes":{"sha256":"18e53256390b299ff03bd58dc134d070bde4871d8c93baf08faea316e87544c8"},"provenance":null,"requires-python":null,"size":87893,"upload-time":"2015-06-13T19:17:05.116909Z","url":"https://files.pythonhosted.org/packages/59/82/51ab7cecaf03c8cbe7eff3b341f6564c3fa80baaa5a37643096cb526cae2/psutil-3.0.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.tar.gz","hashes":{"sha256":"a43cc84c6a2406e8f23785c68a52b792d95eb91e2b43be40f7c814bf80dc5979"},"provenance":null,"requires-python":null,"size":240872,"upload-time":"2015-06-13T19:14:46.063288Z","url":"https://files.pythonhosted.org/packages/ba/18/c5bb52abb67194aabadfd61286b538ee8856c7cb9c0e92dd64c1b132bf5e/psutil-3.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"26b2cf4456e039f490f79457100564ff34718f4257b68dee53b42d17493f0187"},"provenance":null,"requires-python":null,"size":323299,"upload-time":"2015-06-13T19:15:53.089846Z","url":"https://files.pythonhosted.org/packages/0c/b1/fa44dd6ed19e8be6f9f05f776e824ce202822f5d6237093c54d6c5102888/psutil-3.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"32808b29473e788487ee28a65caaab1c9fbd44c2d654ce6d563a89f20e106996"},"provenance":null,"requires-python":null,"size":321705,"upload-time":"2015-06-13T19:16:01.370127Z","url":"https://files.pythonhosted.org/packages/62/4f/89c6ac53e424109639f42033d0e87c4de4ddb610060007c6d5f6081a0fba/psutil-3.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"37a9869ef17680e768bf32d7556252a04f426e5b1e6fa51d5af16305c8a701b6"},"provenance":null,"requires-python":null,"size":321688,"upload-time":"2015-06-13T19:16:11.540515Z","url":"https://files.pythonhosted.org/packages/d2/67/9c988331d40c445ebc9d29d95534ce3908f3949f6a84d640a6c125bc56e2/psutil-3.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py2.6.exe","hashes":{"sha256":"f29ee1aafa452cce77667e75f5e0345b678b8c091b288d0118840df30f303bed"},"provenance":null,"requires-python":null,"size":293522,"upload-time":"2015-06-13T19:15:19.130222Z","url":"https://files.pythonhosted.org/packages/10/19/9e2f8a305f5a6c01feee59dfeb38a73dc1ea4f4af0133cef9a36708f4111/psutil-3.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py2.7.exe","hashes":{"sha256":"7cbcf866faa23e5229ecfe44ff562f406b4806caae66cb255dbb327247e540aa"},"provenance":null,"requires-python":null,"size":293319,"upload-time":"2015-06-13T19:15:27.353152Z","url":"https://files.pythonhosted.org/packages/fc/0f/92e595cd2f2a80cead241d45b4ce4961e2515deff101644f3812c75e9bc7/psutil-3.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py3.3.exe","hashes":{"sha256":"b968771d3db5eef0c17ef6bed2d7756b8ac3cce40e11d5493824863d195dd8e3"},"provenance":null,"requires-python":null,"size":288278,"upload-time":"2015-06-13T19:15:35.880360Z","url":"https://files.pythonhosted.org/packages/fc/29/387c555f9dc38c6bb084a8df8936e607848de9e2e984dbf7eb2a298c1ceb/psutil-3.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py3.4.exe","hashes":{"sha256":"81ac6f54a27d091c75333f7c90082d028db45a1e78de59d28ca9f38cf6186395"},"provenance":null,"requires-python":null,"size":288253,"upload-time":"2015-06-13T19:15:44.871254Z","url":"https://files.pythonhosted.org/packages/fb/29/25ac80b589c0e56214ac64fdd8216992be162a2b2290f9b88b9a5c517cfd/psutil-3.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"data-dist-info-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"filename":"psutil-3.0.1-cp27-none-win32.whl","hashes":{"sha256":"bcb8d23121848953ed295f7e3c0875b0164ee98d3245060beb3623c59ff2a1bc"},"provenance":null,"requires-python":null,"size":85793,"upload-time":"2015-06-18T02:36:50.974286Z","url":"https://files.pythonhosted.org/packages/17/05/b2c807b470464fbe3d357734b68199451574fcd75431fd3e5c77be24b6e0/psutil-3.0.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"data-dist-info-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"filename":"psutil-3.0.1-cp27-none-win_amd64.whl","hashes":{"sha256":"ba56ec5c052489b7a7015c26ed3f917f2df4ffa9799266e86be41815bc358b80"},"provenance":null,"requires-python":null,"size":88128,"upload-time":"2015-06-18T02:37:08.778852Z","url":"https://files.pythonhosted.org/packages/38/bf/0b743c8a07265f2ecb203f8e60310571dcae33036aa6ba7aa16e2641ac7a/psutil-3.0.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp33-none-win32.whl","hashes":{"sha256":"23606e9b42760a8fdeada33281d0c3ce88df220949746e0ddf54d5db7974b4c6"},"provenance":null,"requires-python":null,"size":85819,"upload-time":"2015-06-18T02:36:56.905878Z","url":"https://files.pythonhosted.org/packages/b2/9c/b2c4373b9406eaf33654c4be828d9316ee780f4b3c19d0fa56f55eb64d61/psutil-3.0.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp33-none-win_amd64.whl","hashes":{"sha256":"ae4a7f51f40154d02ab1576e94377171a28cc83fc89c077c152f16ba3dae72f3"},"provenance":null,"requires-python":null,"size":88028,"upload-time":"2015-06-18T02:37:14.406512Z","url":"https://files.pythonhosted.org/packages/7a/59/1a9a10238226dbaed24b8d978e9cc743ac143504b3f4ad8f5e3a169e263a/psutil-3.0.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp34-none-win32.whl","hashes":{"sha256":"b7520db52c7c4e38cdd50bb11be02a826372d8002bf92bbe955823cac32c7f9d"},"provenance":null,"requires-python":null,"size":85783,"upload-time":"2015-06-18T02:37:03.210308Z","url":"https://files.pythonhosted.org/packages/ed/85/1d4d97ce4c9a8c6dd479f5f717694016651170d3731cdecf740db0e4eae3/psutil-3.0.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp34-none-win_amd64.whl","hashes":{"sha256":"1754d4118eaab16f299a37dafaf7d34111e9a8e5ac2a799e2bd9b1a5d9d1122b"},"provenance":null,"requires-python":null,"size":87982,"upload-time":"2015-06-18T02:37:20.490529Z","url":"https://files.pythonhosted.org/packages/1e/e6/0af7e190f74d6f959dfb87f2b56f4711271729952691f843fb91c5e06712/psutil-3.0.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.tar.gz","hashes":{"sha256":"3f213b9ceed3c3068a973e04d7a8b2a29d1076abcb5ef45382517bfc6b808801"},"provenance":null,"requires-python":null,"size":241539,"upload-time":"2015-06-18T02:33:52.119548Z","url":"https://files.pythonhosted.org/packages/aa/5d/cbd3b7227fe7a4c2c77e4031b6c43961563a3ecde2981190e5afe959be51/psutil-3.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"b0a2ed567b31f71ae2e893768f0da0d51d51d12714471d4b7431e70ff5e36577"},"provenance":null,"requires-python":null,"size":323471,"upload-time":"2015-06-18T02:36:04.537383Z","url":"https://files.pythonhosted.org/packages/9d/a4/815181cacd33f0ce62a3c3aa188af65bd3945888aa2f6c16a925837ca517/psutil-3.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"99c593cb459b54209cdb4aed4a607fa8b2920fbd4f3c5a9219a0ede114975758"},"provenance":null,"requires-python":null,"size":321879,"upload-time":"2015-06-18T02:36:14.693044Z","url":"https://files.pythonhosted.org/packages/08/b2/278ac09b03db15b9e51c3ae7f678b3fbf050e895a2eccab66d05017bdef9/psutil-3.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"8f803bfe00a763254581bb6a3d788b3332492fbc67dbf46ad5068b663e44f309"},"provenance":null,"requires-python":null,"size":321861,"upload-time":"2015-06-18T02:36:23.687685Z","url":"https://files.pythonhosted.org/packages/d8/66/d21041db114938ae22d4994ea31f2d8f1353aa61e5f0d0c6c4e185b016a7/psutil-3.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py2.6.exe","hashes":{"sha256":"4a19475c1d6071c685b38f85837f6e6daa2c6ccd4d0132ab840123deb8ea2372"},"provenance":null,"requires-python":null,"size":293700,"upload-time":"2015-06-18T02:35:31.083110Z","url":"https://files.pythonhosted.org/packages/99/67/980b4a9257abaa3f53a60a3441f759301a0aca2922d60e18a05d23fb1b0e/psutil-3.0.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py2.7.exe","hashes":{"sha256":"363d3dbd610ce7bcf7f13b0a31133ee231d0990e99315142ed37f6ba2c1a84e6"},"provenance":null,"requires-python":null,"size":293492,"upload-time":"2015-06-18T02:35:39.030138Z","url":"https://files.pythonhosted.org/packages/5f/64/b994ed73ab49d5c847d97c47600b539603ebf0d6cfd8d3575b80db7aefb5/psutil-3.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py3.3.exe","hashes":{"sha256":"fc7cfe1d6919cb67f4144947acfcefc099d7d8299dd88bb4d863e62c44d041b4"},"provenance":null,"requires-python":null,"size":288451,"upload-time":"2015-06-18T02:35:47.145538Z","url":"https://files.pythonhosted.org/packages/1f/11/4871e823ff0d5a302a7f8ece60358d20ba7fc1620c4c9e2d94e826e1ff0e/psutil-3.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py3.4.exe","hashes":{"sha256":"73091a80ed295f990ab377dfd8cd4f7f00e3abfffb5e500192f1ea9fa58de158"},"provenance":null,"requires-python":null,"size":288427,"upload-time":"2015-06-18T02:35:55.768442Z","url":"https://files.pythonhosted.org/packages/08/af/c78ef8dc09ac61a479968b0c912677d0a0cb138c5ea7813b2a196fa32c53/psutil-3.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp26-none-win32.whl","hashes":{"sha256":"399916a016503c9ae99fd6aafbba4628b86ebdee52d67034e8c3f26e88a3504b"},"provenance":null,"requires-python":null,"size":87753,"upload-time":"2015-07-15T00:41:13.293562Z","url":"https://files.pythonhosted.org/packages/4e/0a/ab710541d02ff3ce4169a0922e4412952332991c4c39a0ea9df20e9279b0/psutil-3.1.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp27-none-win32.whl","hashes":{"sha256":"71af7a30eb6ed694a3624330334bd12da28bffdbe813f4b1080fadeb86f5970f"},"provenance":null,"requires-python":null,"size":87559,"upload-time":"2015-07-15T00:41:27.810047Z","url":"https://files.pythonhosted.org/packages/db/87/34b52811b755db94a7dd123e5c0f1d257885535f08f5f185c17810214d55/psutil-3.1.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp27-none-win_amd64.whl","hashes":{"sha256":"ada1cf324e6aba0affcb23c6fd959dae9f72de6ec135530788cbf17153d4fd3c"},"provenance":null,"requires-python":null,"size":90071,"upload-time":"2015-07-15T00:42:15.297263Z","url":"https://files.pythonhosted.org/packages/0b/7c/90869233a3e4056ddfdd1040d0e7722d3bb023c74b48bf10c09380c26eae/psutil-3.1.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp33-none-win32.whl","hashes":{"sha256":"0a313ebe14b9e277dfd151f4ad021012fb344dd51248e6de2aa1e7062d678541"},"provenance":null,"requires-python":null,"size":87569,"upload-time":"2015-07-15T00:41:43.765697Z","url":"https://files.pythonhosted.org/packages/f4/7c/56b718693e4c41b32af8bbe39160e8a3ea0ca12d3eece3dbbb8d4c046855/psutil-3.1.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp33-none-win_amd64.whl","hashes":{"sha256":"92a7f420bc97f899b5abab30392c23ba652304aec18415f2d1167da04dae9913"},"provenance":null,"requires-python":null,"size":89918,"upload-time":"2015-07-15T00:42:29.864336Z","url":"https://files.pythonhosted.org/packages/c7/5a/4046949e207b72b93540f3e19d699813fd35e290ccdf48080f332226b912/psutil-3.1.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp34-none-win32.whl","hashes":{"sha256":"8f5a0e859ae6dcc349914fb9ea0acc21cfd82a321d1c1b02d3d92c195f523ccd"},"provenance":null,"requires-python":null,"size":87592,"upload-time":"2015-07-15T00:42:00.678342Z","url":"https://files.pythonhosted.org/packages/09/34/09d53d29318a5fea88bd30d629595805064a0e3776e706eca2d79ceaebac/psutil-3.1.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp34-none-win_amd64.whl","hashes":{"sha256":"dcb4f208ec28fb72b35d1edf49aa51f2cc116b439aa40c4c415cbfe1fee54078"},"provenance":null,"requires-python":null,"size":89877,"upload-time":"2015-07-15T00:42:45.261251Z","url":"https://files.pythonhosted.org/packages/0b/f6/62592864eb064763989aa5830706034f9ad3c6ae2255fb7cae0c66b336a1/psutil-3.1.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.tar.gz","hashes":{"sha256":"4cdfeb2a328b6f8a2937f9b21f513c8aeda96dc076ecafda424f5c401dbad876"},"provenance":null,"requires-python":null,"size":246767,"upload-time":"2015-07-15T00:40:47.134419Z","url":"https://files.pythonhosted.org/packages/ce/d2/ab7f80718b4eafb2e474b8b410274d2c0d65341b963d730e653be9ed0ec8/psutil-3.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"6570fb3ddde83597e11c062e20ab86210ff84a1fa97e54bc8bda05e4cd34670a"},"provenance":null,"requires-python":null,"size":326179,"upload-time":"2015-07-15T00:42:09.118162Z","url":"https://files.pythonhosted.org/packages/26/f5/c76bf7ef62736913146b0482879705d1d877c9334092a0739f2b3bbae162/psutil-3.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"578a52f4b108857273d1e32de4d9bebf9b8f842f8c53ab3e242252cfc9bde295"},"provenance":null,"requires-python":null,"size":324540,"upload-time":"2015-07-15T00:42:24.223021Z","url":"https://files.pythonhosted.org/packages/00/51/2dc07e5618adb4a3676ab6c9c1759a3f268eda91808d58f45eb4dfd3d2c5/psutil-3.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"2aea29ca2a5ea318155fb856f24e6c7563c8741ccfeec862f0fd9af0f2d8ae87"},"provenance":null,"requires-python":null,"size":324490,"upload-time":"2015-07-15T00:42:38.312454Z","url":"https://files.pythonhosted.org/packages/da/76/dcefdcf88fd51becaff6c1ec0ba7566ca654a207fe6d69662723c645e3b0/psutil-3.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py2.6.exe","hashes":{"sha256":"271f1b6fcb4861d1b0fc7f612b2abaacb36c0f878fcc2908f1cf673337c3472c"},"provenance":null,"requires-python":null,"size":296215,"upload-time":"2015-07-15T00:41:08.168047Z","url":"https://files.pythonhosted.org/packages/3f/c2/f7ec0a70bc58c1918f814001682cca30f4b168f5b46dce913220e625dee6/psutil-3.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py2.7.exe","hashes":{"sha256":"1bde1cea6b7f9bd66202feee289c282b076c00419dc6404db357b05125f4d692"},"provenance":null,"requires-python":null,"size":296024,"upload-time":"2015-07-15T00:41:21.733811Z","url":"https://files.pythonhosted.org/packages/56/2f/c97adcba8f119a23d3580a3a95939c1a37d37d514b304d90912585a85521/psutil-3.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py3.3.exe","hashes":{"sha256":"667fa795ca5ccde216b769fc8572398598f1e0e2619f78605df1a4c75a475174"},"provenance":null,"requires-python":null,"size":290958,"upload-time":"2015-07-15T00:41:37.038168Z","url":"https://files.pythonhosted.org/packages/37/89/a949b02d66d600c45230a3a622f0d5f491182dbbc96fff9ffbcd869431bd/psutil-3.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py3.4.exe","hashes":{"sha256":"8e637fe2a23fad4f4ea8ae11402b593e09fc587b86a6ced40b6bc1017be8d978"},"provenance":null,"requires-python":null,"size":290975,"upload-time":"2015-07-15T00:41:53.144204Z","url":"https://files.pythonhosted.org/packages/53/3f/249ff2e418313f30a6dcc4995966725f72b00493848ffddeb72b506e8e50/psutil-3.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp26-none-win32.whl","hashes":{"sha256":"13a6377cc8d2859f846058170830127822877e05229c4a43aea893cdcb504d65"},"provenance":null,"requires-python":null,"size":87749,"upload-time":"2015-07-15T12:34:56.810625Z","url":"https://files.pythonhosted.org/packages/e1/9e/721afc99b6fe467b47fa2cad6899acc19b45dee32d30b498dc731b6c09ef/psutil-3.1.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp27-none-win32.whl","hashes":{"sha256":"5b7228cb69fdaea5aeb901704f5ecd21b7846aa60c2c8d408f22573fcbaa7e6f"},"provenance":null,"requires-python":null,"size":87554,"upload-time":"2015-07-15T12:35:15.647007Z","url":"https://files.pythonhosted.org/packages/07/60/c88366202816ba42b3d8e93e793c14d1ac5e71be30dd53c2d0117c106eec/psutil-3.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"da7650e2f3fcf06419d5ad75123e6c68b9bf5ff2a6c91d4c77aaed8e6f444fc4"},"provenance":null,"requires-python":null,"size":90065,"upload-time":"2015-07-15T12:36:14.571710Z","url":"https://files.pythonhosted.org/packages/fa/5b/8834e22cc22b6b0e9c2c68e240ab69754bed7c4c5388fb65abfa716f4a67/psutil-3.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp33-none-win32.whl","hashes":{"sha256":"f3d68eb44ba49e24a18d6f7934463478294a49152f97fea2eefe1e1e1ee957f3"},"provenance":null,"requires-python":null,"size":87562,"upload-time":"2015-07-15T12:35:34.924344Z","url":"https://files.pythonhosted.org/packages/cb/96/0eb8eb289681364d2cda2a22a7d1abeb0196b321ab95694335dd178a5b35/psutil-3.1.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp33-none-win_amd64.whl","hashes":{"sha256":"f9be0ae975b55a3b5d5a8b769560096d76184b60a56c6e88ff6b7ebecf1bc684"},"provenance":null,"requires-python":null,"size":89916,"upload-time":"2015-07-15T12:36:34.374903Z","url":"https://files.pythonhosted.org/packages/eb/13/a38bc1e0ac6f7c42dddd9c17a206877befb822ba3af9c3b0dab9e85911a6/psutil-3.1.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp34-none-win32.whl","hashes":{"sha256":"8f25aad572bde88d5ee0b3a11a75ff2ae3c8b0a334c4128d6f8eb4fc95172734"},"provenance":null,"requires-python":null,"size":87574,"upload-time":"2015-07-15T12:35:55.507642Z","url":"https://files.pythonhosted.org/packages/02/10/439ec497e3e38a8c493d0c67c56e23d106b85c8b9f616e8df9ec6ce1e606/psutil-3.1.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp34-none-win_amd64.whl","hashes":{"sha256":"4be182c273758dcdbd30827fdeecd889e27cb6a30238798e91bddeebc29cdc4f"},"provenance":null,"requires-python":null,"size":89865,"upload-time":"2015-07-15T12:36:55.016343Z","url":"https://files.pythonhosted.org/packages/ec/2e/8d98579399bc1979904455df182a063dd584b285ee8c141f3c94e7814c47/psutil-3.1.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.tar.gz","hashes":{"sha256":"d3290bd4a027fa0b3a2e2ee87728056fe49d4112640e2b8c2ea4dd94ba0cf057"},"provenance":null,"requires-python":null,"size":247284,"upload-time":"2015-07-15T12:33:47.020532Z","url":"https://files.pythonhosted.org/packages/8d/b3/954de176aa8e3a7782bae52ce938f24726c2c68d0f4c60d159271b6b293d/psutil-3.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"9c4fd3cc19bbc04eaa7ef3c61e3db26a41ac5e056f770977211d4569d0bf0086"},"provenance":null,"requires-python":null,"size":326261,"upload-time":"2015-07-15T12:36:07.064169Z","url":"https://files.pythonhosted.org/packages/e8/ac/7fb95ccc69ced76d0920e411b2fdfd3d38398c4bce53ec1dae92800df88a/psutil-3.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"e7cc26f661c9eaa9b32d0543dd7838daea72aad6e9f02fe73715ffd0dcb65170"},"provenance":null,"requires-python":null,"size":324622,"upload-time":"2015-07-15T12:36:27.201153Z","url":"https://files.pythonhosted.org/packages/2f/84/ae41f6bb61d4a93399c621218f99b761171a69a0c9163b9a72db1d53d62a/psutil-3.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"46cbfd86d6762e63c7df4ab0df889f6f2fffa9b5781ea3fc0431237f2a408382"},"provenance":null,"requires-python":null,"size":324571,"upload-time":"2015-07-15T12:36:47.165677Z","url":"https://files.pythonhosted.org/packages/88/d4/ca15a913ab43222e308774845317544e765718a9e56bd4efe5b3cedf1fbd/psutil-3.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py2.6.exe","hashes":{"sha256":"9efbd578d2f400dfe0ecab123b58d8af105854fdbb6222f841151e010e820b75"},"provenance":null,"requires-python":null,"size":296306,"upload-time":"2015-07-15T12:34:49.442980Z","url":"https://files.pythonhosted.org/packages/0c/f6/e81385c7ec989157eb68688a64a69c5a7477ff93d544893a9e1f251588b1/psutil-3.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py2.7.exe","hashes":{"sha256":"e0065e7cade4ac5ac70411674bc32326dee8d11c44469012a2b5164bf6dea97a"},"provenance":null,"requires-python":null,"size":296106,"upload-time":"2015-07-15T12:35:08.277861Z","url":"https://files.pythonhosted.org/packages/6b/fe/51596968f5a6a0970d9424021989f542d5aa715fe21d1a9c6bbbb0e377a9/psutil-3.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py3.3.exe","hashes":{"sha256":"c8ab17e07ea4907d2f9129254e82b6765ae08e61f0ce6dc8e2fc1faf145b166c"},"provenance":null,"requires-python":null,"size":291039,"upload-time":"2015-07-15T12:35:27.250487Z","url":"https://files.pythonhosted.org/packages/83/49/ff116fb9981ef04a5aed1c091ace117c214ed752d37be267ea4e2f28efad/psutil-3.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py3.4.exe","hashes":{"sha256":"3003d8be6e86eb6beb990863a88950f9b9fe53ccaae92edcd8efcd152d7451ea"},"provenance":null,"requires-python":null,"size":291056,"upload-time":"2015-07-15T12:35:47.023807Z","url":"https://files.pythonhosted.org/packages/7b/cd/accf3d7e37006bffe7a569e4fc587eb686d275a19a4e8a37a12930a1e2db/psutil-3.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"data-dist-info-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"filename":"psutil-3.2.0-cp27-none-win32.whl","hashes":{"sha256":"1493041336a591f22c77bcb815a399faf9bdac32f79f4de354eda3507a0d6d6b"},"provenance":null,"requires-python":null,"size":88077,"upload-time":"2015-09-02T11:56:33.437905Z","url":"https://files.pythonhosted.org/packages/5f/fc/5f317fd548909b1bbb111d462c072faf8af3938268f3e7dd3ab2f9181461/psutil-3.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"data-dist-info-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"filename":"psutil-3.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"3744ee760dff697f45731a71e7902514aa043c99800cc8fabeb6bebc9dad973d"},"provenance":null,"requires-python":null,"size":90526,"upload-time":"2015-09-02T11:57:23.745435Z","url":"https://files.pythonhosted.org/packages/84/6c/7efbe64b42748125e7113a90e48c0da9859b7f0363ac85ca5617decbafee/psutil-3.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp33-none-win32.whl","hashes":{"sha256":"8836f77d2c4ae2935431ca66e445435b87b53b4db637fcceb438b78843239210"},"provenance":null,"requires-python":null,"size":88080,"upload-time":"2015-09-02T11:56:48.988091Z","url":"https://files.pythonhosted.org/packages/64/8e/0a06028a1ac093402885febf2aeb18093f1d28ae2110c7eb10b43e7554c1/psutil-3.2.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp33-none-win_amd64.whl","hashes":{"sha256":"b16eb62d9c21efaa2c9ac8a9f8b23bb7a695cb799b597edf4b1289ce8e6973ac"},"provenance":null,"requires-python":null,"size":90372,"upload-time":"2015-09-02T12:03:01.254324Z","url":"https://files.pythonhosted.org/packages/cd/29/a8383040200a3ebe0e985f54f35691cc078a1deb632abb5340d3deb5b7b7/psutil-3.2.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp34-none-win32.whl","hashes":{"sha256":"0ac1d68ab3c5a65641cbbb23d19deda466f73226f9d967f91436851995281777"},"provenance":null,"requires-python":null,"size":88096,"upload-time":"2015-09-02T11:57:08.035697Z","url":"https://files.pythonhosted.org/packages/07/c3/76a50982a82c0e9d93d9614a0cd06644c1d3406c9bb80a43f95abdd4ab97/psutil-3.2.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp34-none-win_amd64.whl","hashes":{"sha256":"0b26ef262fe2d10185ab562cd0530af7f6d9a6744c631c44e64be94796f4ba2d"},"provenance":null,"requires-python":null,"size":90354,"upload-time":"2015-09-02T12:07:12.010031Z","url":"https://files.pythonhosted.org/packages/58/2d/8b7abb9b6f8956d9a6dfc3b1dffce27efab8c7c0497a6366e7fee444ae53/psutil-3.2.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.tar.gz","hashes":{"sha256":"06f9d255f8b12a6a04aa2b468ec453c539f54a464d110b3458c32b0152a5c943"},"provenance":null,"requires-python":null,"size":251988,"upload-time":"2015-09-02T11:59:23.849318Z","url":"https://files.pythonhosted.org/packages/1d/3a/d396274e6f086e342dd43401d4012973af98c00b3aabdb5cc4a432df660e/psutil-3.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"71fd8712715f8e6acc5bee5719a83a61a396067cf2bfb15b4d8f1f2955648637"},"provenance":null,"requires-python":null,"size":326895,"upload-time":"2015-09-02T11:57:17.538160Z","url":"https://files.pythonhosted.org/packages/e1/49/990073ab7e010965a7d0df5e48181d07c212edd7fafb890feda664ea9b3c/psutil-3.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py2.7.exe","hashes":{"sha256":"2a8b5878d4e787d81a1eeddcc09ff28d501a3ceb320c7fffa7e207da5d61d01c"},"provenance":null,"requires-python":null,"size":296802,"upload-time":"2015-09-02T11:56:26.879142Z","url":"https://files.pythonhosted.org/packages/0b/c5/d6ad511c3c17afa9837d08fc26d76e85dc83ebc304c6c7bec3970e74f240/psutil-3.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py3.3.exe","hashes":{"sha256":"adfc63ceede4e8f6bf21e4bdf6fc91f70f9612ec2b1bf9ad306828909bb71c52"},"provenance":null,"requires-python":null,"size":291738,"upload-time":"2015-09-02T11:56:41.826609Z","url":"https://files.pythonhosted.org/packages/e3/35/81842c6c4366d19c87d1a1fb4ad4e4d22a18aa9facaea8b6f12ccd4c1212/psutil-3.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py3.4.exe","hashes":{"sha256":"4098e0ed7930003ef15feb852e64f73180c17a651c4170fb5573f8c44622d068"},"provenance":null,"requires-python":null,"size":291748,"upload-time":"2015-09-02T11:56:58.479934Z","url":"https://files.pythonhosted.org/packages/e9/e8/5b432a0490328cfff86605b574d2aa31b1fac4e61587dff5a7f76d4cb95e/psutil-3.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp26-none-win32.whl","hashes":{"sha256":"a77230ecd6f42d0b549f8eb6aa105f14e4bc5908c754d6e10ff979c900934481"},"provenance":null,"requires-python":null,"size":88306,"upload-time":"2015-09-03T15:37:28.878155Z","url":"https://files.pythonhosted.org/packages/37/46/f348f7728dea66436abdfc9fa14ef017e0148c6bca08a822ee4dd7cb6d75/psutil-3.2.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp27-none-win32.whl","hashes":{"sha256":"9453b8ceb249d4d9ddc69153729761be340dfef9c99509390e4fb0f1fcbb3853"},"provenance":null,"requires-python":null,"size":88111,"upload-time":"2015-09-03T15:30:11.278302Z","url":"https://files.pythonhosted.org/packages/ba/27/f55ca7d15af50e731e9bbbff9b22fc31a40b786c02f85d173568e5084152/psutil-3.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"014714beed46a66370834cebe0bbb53799bddc164f7f0149a4a70e2051f7bc1a"},"provenance":null,"requires-python":null,"size":90561,"upload-time":"2015-09-03T15:35:05.710499Z","url":"https://files.pythonhosted.org/packages/6b/ac/5da840018ce300a258925d4535a55a32b75236d5d777a8de6c3de18e71f3/psutil-3.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp33-none-win32.whl","hashes":{"sha256":"5c0daf045fd7d7f105863a5f9508d1698559ebbdfd70d7d8b6fe6fedde575735"},"provenance":null,"requires-python":null,"size":88117,"upload-time":"2015-09-03T15:32:19.746087Z","url":"https://files.pythonhosted.org/packages/c7/96/3ae14e4bf81f18f404bb5285fcda28e50ae6df87e91ad6bf45a9a4f51ac3/psutil-3.2.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp33-none-win_amd64.whl","hashes":{"sha256":"452622592564cd67f86808c8176720c1443d43e248cfd242d71cff559ed1424c"},"provenance":null,"requires-python":null,"size":90410,"upload-time":"2015-09-03T15:36:13.351055Z","url":"https://files.pythonhosted.org/packages/76/62/fe6f705cb331be5fcc97b268987527dcdb3f3aa104bf830b0ec8bf1e2ad4/psutil-3.2.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp34-none-win32.whl","hashes":{"sha256":"96379bee09d4c6b4d57d72cb7347dbc51b6847977f2fad01cdfefef3b53e44e3"},"provenance":null,"requires-python":null,"size":88131,"upload-time":"2015-09-03T15:33:36.571683Z","url":"https://files.pythonhosted.org/packages/31/ec/1a54f23c767e27dac09d2372f3522f88ef34f3a0ddd44c16122970259f6f/psutil-3.2.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp34-none-win_amd64.whl","hashes":{"sha256":"7a7f4f2ed6d2835c48c24a81b251ba4f9b21f6bba2323291f8205c9ecb6f659d"},"provenance":null,"requires-python":null,"size":90387,"upload-time":"2015-09-03T15:36:29.262691Z","url":"https://files.pythonhosted.org/packages/2e/10/f1590ae942a6b8dd2bdeef6088e30e89b30161a264881b14134f3c4a3a0e/psutil-3.2.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.tar.gz","hashes":{"sha256":"7f6bea8bfe2e5cfffd0f411aa316e837daadced1893b44254bb9a38a654340f7"},"provenance":null,"requires-python":null,"size":251653,"upload-time":"2015-09-03T15:30:34.118573Z","url":"https://files.pythonhosted.org/packages/cd/5f/4fae1036903c01929c48ded6800a8705106ee20f9e39e3f2ad5d1824e210/psutil-3.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"e9a8a44f3847a0e20a54d321ed62de4e9cee5bc4e880e25fe88ae20cfa4e32b2"},"provenance":null,"requires-python":null,"size":327122,"upload-time":"2015-09-03T15:34:58.714500Z","url":"https://files.pythonhosted.org/packages/c5/af/4ab069ba93a037a4acf9bb84248daa44204a46687abc6a9f3a82ad8c5ee2/psutil-3.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"5a62c38852de4513f1816b9c431a94f02531619c1edc60a2cc163c8754f51c50"},"provenance":null,"requires-python":null,"size":325481,"upload-time":"2015-09-03T15:36:01.424492Z","url":"https://files.pythonhosted.org/packages/32/87/82e449ff9573dde3c78685b64ac3d17b5d19db11e976eab27c4dc5dca942/psutil-3.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"da898c0708b99b3892bfb7d5caebb447d14d03c7a655c55e484eb5fcc741c3ca"},"provenance":null,"requires-python":null,"size":325465,"upload-time":"2015-09-03T15:36:22.916532Z","url":"https://files.pythonhosted.org/packages/4b/11/f18b29033a0b383e67f664576eca59fbe8552a9fd97f9f22d6d0ff1c4951/psutil-3.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py2.6.exe","hashes":{"sha256":"0e5fe3d50f9f8d9a5216cfa23f56890aa0c6a6163869434001f4f2ba463dace5"},"provenance":null,"requires-python":null,"size":297224,"upload-time":"2015-09-03T15:37:22.791161Z","url":"https://files.pythonhosted.org/packages/c0/bb/ed28c191c4d9f27b60d9ea6bd7774b44d78778f0b1fb507ee1e789a490d7/psutil-3.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py2.7.exe","hashes":{"sha256":"9fb6f11bdd3fdbe1e611ae02b3ad3dff8f70ef6eaa694d13e8ad0906fd7a7261"},"provenance":null,"requires-python":null,"size":297025,"upload-time":"2015-09-03T15:30:14.327211Z","url":"https://files.pythonhosted.org/packages/9a/c1/075598067efefe25f6a2b0cf1b3eb896322597ee64ba097cc6611b89ada7/psutil-3.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py3.3.exe","hashes":{"sha256":"605cc7dbe2170e89f2f6709cf1577c8a02f89951fe4a0eb48e72530f605141ca"},"provenance":null,"requires-python":null,"size":291964,"upload-time":"2015-09-03T15:32:12.890526Z","url":"https://files.pythonhosted.org/packages/e0/ce/ff1db37cbdf6b3071e89afe4fced6f73d2cdf9c3a87696e7754d207e0ec5/psutil-3.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py3.4.exe","hashes":{"sha256":"0cd127239f527eae6c0f778dd41bb3ced84e6049b919713022c9b72e5f22a1c1"},"provenance":null,"requires-python":null,"size":291976,"upload-time":"2015-09-03T15:33:29.509014Z","url":"https://files.pythonhosted.org/packages/5d/a0/d624d4f5660a476821fe0d920a4c2e995a23151928b15cc3383379228f15/psutil-3.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp26-none-win32.whl","hashes":{"sha256":"5a8ce70327c0da578a31ebbf0042671ed9be6f4b6b022c02f03302b690074966"},"provenance":null,"requires-python":null,"size":88377,"upload-time":"2015-10-04T16:38:11.705751Z","url":"https://files.pythonhosted.org/packages/4d/af/5b8c2471ea942a4b6ee85706e9279284ae9dc86ee30b6f97db2d84a95433/psutil-3.2.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp27-none-win32.whl","hashes":{"sha256":"6c5809582d3d165511d2319401bd0f6c0e825d7853e49da59027c1fb8aa8f897"},"provenance":null,"requires-python":null,"size":88183,"upload-time":"2015-10-04T16:38:39.878475Z","url":"https://files.pythonhosted.org/packages/63/1e/a510f3f310b5f530336fbc708fb1456bf3e49e3b3d85c31d151b6e389c4f/psutil-3.2.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp27-none-win_amd64.whl","hashes":{"sha256":"37f1cc8fc7586cc930ea3737533d6d79c1f761d577fd1bb1bb5798ccd1543b53"},"provenance":null,"requires-python":null,"size":90637,"upload-time":"2015-10-04T16:40:05.379646Z","url":"https://files.pythonhosted.org/packages/e7/b7/f04d64a692159733ed383b4638abd9d3dc4538d4aacb5e193af02a3840a2/psutil-3.2.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp33-none-win32.whl","hashes":{"sha256":"f8fb145f8fa9e223696ff2f99924ea42538f3ad6b9738707292d840acbde528f"},"provenance":null,"requires-python":null,"size":88189,"upload-time":"2015-10-04T16:39:00.887284Z","url":"https://files.pythonhosted.org/packages/77/f3/6b3742040b634692393faf3a81e6c0e40366c22bc338ad3fc62ed21b157a/psutil-3.2.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp33-none-win_amd64.whl","hashes":{"sha256":"65c78ba625cf9761d5966603838cc959f396bd03536c480db69f8cf37bdf9994"},"provenance":null,"requires-python":null,"size":90471,"upload-time":"2015-10-04T16:40:27.009383Z","url":"https://files.pythonhosted.org/packages/59/33/3ccdbec4ef1452758ba80f711af46736717f63d73786744d6251afb68624/psutil-3.2.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp34-none-win32.whl","hashes":{"sha256":"3df8d3e32e2b4f7c2ea91014294844670eddb125ba76c24152c0a155a1f73b5b"},"provenance":null,"requires-python":null,"size":88202,"upload-time":"2015-10-04T16:39:39.989654Z","url":"https://files.pythonhosted.org/packages/62/6e/ee3597f32c650f744359e57fd18bcede773dd7465d392dabbb008bc79b48/psutil-3.2.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp34-none-win_amd64.whl","hashes":{"sha256":"e321d3f029268bc8442a7ff214da43fe91041924898f5e23d88bfda7ecb81acc"},"provenance":null,"requires-python":null,"size":90463,"upload-time":"2015-10-04T16:40:56.120875Z","url":"https://files.pythonhosted.org/packages/ed/fe/f31bb708dfdecfbc59b946ecb9ee3379fe7a8183c37ea6c43d6f4da5117d/psutil-3.2.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"data-dist-info-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"filename":"psutil-3.2.2-cp35-none-win32.whl","hashes":{"sha256":"76c68c9005a2aa983fce440ef98b66e6f200f740f52064a90fdcc30d11771bc2"},"provenance":null,"requires-python":null,"size":90363,"upload-time":"2015-11-06T10:48:59.454097Z","url":"https://files.pythonhosted.org/packages/cb/79/fcedcf009ab9f8c605f2f345b1797b72134ecc6c9c9f786575e34b3471bc/psutil-3.2.2-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"data-dist-info-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"filename":"psutil-3.2.2-cp35-none-win_amd64.whl","hashes":{"sha256":"d3ac8ad04a509819d7b5d58e453749a3ceb37253267dac6e8856ea7953e22ca0"},"provenance":null,"requires-python":null,"size":93288,"upload-time":"2015-11-06T10:50:14.699381Z","url":"https://files.pythonhosted.org/packages/03/c5/15e44d590afc788228e93cdacf55f98828f326de985242bbf03b3545b129/psutil-3.2.2-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.tar.gz","hashes":{"sha256":"f9d848e5bd475ffe7fa3ab1c20d249807e648568af64bb0058412296ec990a0c"},"provenance":null,"requires-python":null,"size":253502,"upload-time":"2015-10-04T16:39:43.138939Z","url":"https://files.pythonhosted.org/packages/dc/b2/ab65a2209b996c891209b8a7444a0c825125fba850efaec07b95bccb3ff5/psutil-3.2.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py2.7.exe","hashes":{"sha256":"1fca15005063b401cbf94cebe3c01ef6ba3d86ba563730d5d5d6be962a637cf4"},"provenance":null,"requires-python":null,"size":327220,"upload-time":"2015-10-04T16:39:56.198669Z","url":"https://files.pythonhosted.org/packages/01/7c/47b7ac498c9dd6ac9f9b4489d3bd9cea8158e774592661a7c956a815dc78/psutil-3.2.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py3.3.exe","hashes":{"sha256":"01a1f55819019ad13c288c41cb233e17a6ee648baf19591a70f6c2c2295dde6c"},"provenance":null,"requires-python":null,"size":325577,"upload-time":"2015-10-04T16:40:17.960471Z","url":"https://files.pythonhosted.org/packages/5d/89/b3bfca24d038b16af09055912e3a5bc35347ebeb0e6af322959b68dbf237/psutil-3.2.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py3.5.exe","hashes":{"sha256":"9afc68c02717fb4416f91b3c2da4c407756f683804383d1499cdc9e1512e7942"},"provenance":null,"requires-python":null,"size":242452,"upload-time":"2015-11-06T10:49:50.288504Z","url":"https://files.pythonhosted.org/packages/1d/0b/9582cadcba005f4eb0207107baeae7eb2382431fea5e4bc0ea7ce683430f/psutil-3.2.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py2.6.exe","hashes":{"sha256":"c7c516a83d072d1a375ed3a0b5a1b1b9307ad839011e8d30aa16b0f932f6c481"},"provenance":null,"requires-python":null,"size":297317,"upload-time":"2015-10-04T16:38:04.476936Z","url":"https://files.pythonhosted.org/packages/66/e4/bb85391bb46b607be0578e0a091bc064daeb2d1c2e80aa2dab89260dff00/psutil-3.2.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.3.exe","hashes":{"sha256":"5168f99f065f6116ad1e8529bd5dd5309815198c6250c9180ff6058c6a3641d9"},"provenance":null,"requires-python":null,"size":292060,"upload-time":"2015-10-04T16:38:46.104177Z","url":"https://files.pythonhosted.org/packages/8e/86/8f1e1c0ffc0530dca5e71777f04fb90833c92d3ffc1d075b8b546874eae5/psutil-3.2.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.4.exe","hashes":{"sha256":"d5c96aa591ba711dfdadb1ab7a0adf08c5e637644a21437f3a39a9e427aa969b"},"provenance":null,"requires-python":null,"size":292515,"upload-time":"2015-11-06T01:39:51.263901Z","url":"https://files.pythonhosted.org/packages/28/fc/08f1098976de5416cd15967d88e03297569e9a34ca875e7dee38ff9150f0/psutil-3.2.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.5.exe","hashes":{"sha256":"f0e88f94f9822fd34bcd927aba4bb606bcb0ad0dda1543c9333e8175d5c05822"},"provenance":null,"requires-python":null,"size":232367,"upload-time":"2015-11-06T10:48:42.065794Z","url":"https://files.pythonhosted.org/packages/1d/b8/b725f9bd884f75ce141a9e871a79b2bdd1b5f31e814fc4e396d9ff7c98a2/psutil-3.2.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp26-none-win32.whl","hashes":{"sha256":"584f0b29fcc5d523b433cb8918b2fc74d67e30ee0b44a95baf031528f424619f"},"provenance":null,"requires-python":null,"size":90099,"upload-time":"2015-11-25T18:49:50.211423Z","url":"https://files.pythonhosted.org/packages/91/75/c20c3b9f4d3feb3436d607f498744e46dd28b265b8a72509812322198c7c/psutil-3.3.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp26-none-win_amd64.whl","hashes":{"sha256":"28ca0b6e9d99aa8dc286e8747a4471362b69812a25291de29b6a8d70a1545a0d"},"provenance":null,"requires-python":null,"size":92645,"upload-time":"2015-11-25T18:50:32.375134Z","url":"https://files.pythonhosted.org/packages/6a/d1/0ce316e4346bcae9dd23911366d894eda65875b88ff447ec8f0402ce556b/psutil-3.3.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp27-none-win32.whl","hashes":{"sha256":"167ad5fff52a672c4ddc1c1a0b25146d6813ebb08a9aab0a3ac45f8a5b669c3b"},"provenance":null,"requires-python":null,"size":90131,"upload-time":"2015-11-25T01:20:43.015358Z","url":"https://files.pythonhosted.org/packages/91/73/1f55b4a19db535759fec5fdbdd0653d7192336557078e3ac9085d7d77cd1/psutil-3.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"e6dea6173a988727bb223d3497349ad5cdef5c0b282eff2d83e5f9065c53f85f"},"provenance":null,"requires-python":null,"size":92586,"upload-time":"2015-11-25T01:22:19.444688Z","url":"https://files.pythonhosted.org/packages/a2/ab/d15a34c6b9090d58601541f8f5564f5b48d01e82f56e07593be969d529e7/psutil-3.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp33-none-win32.whl","hashes":{"sha256":"2af5e0a4aad66049955d0734aa4e3dc8caa17a9eaf8b4c1a27a5f1ee6e40f6fc"},"provenance":null,"requires-python":null,"size":90141,"upload-time":"2015-11-25T01:21:10.374023Z","url":"https://files.pythonhosted.org/packages/c5/1f/5038a2567f5853ea1e0fb55f795c30b339a318717573c5b0c85b8814d733/psutil-3.3.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp33-none-win_amd64.whl","hashes":{"sha256":"d9884dc0dc2e55e2448e495778dc9899c1c8bf37aeb2f434c1bea74af93c2683"},"provenance":null,"requires-python":null,"size":92432,"upload-time":"2015-11-25T01:22:39.035467Z","url":"https://files.pythonhosted.org/packages/b1/9c/a9cd75c8cfbac44397a2ca76430229c5496b21e0ab93cba5987d80e3f262/psutil-3.3.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp34-none-win32.whl","hashes":{"sha256":"e27c2fe6dfcc8738be3d2c5a022f785eb72971057e1a9e1e34fba73bce8a71a6"},"provenance":null,"requires-python":null,"size":90151,"upload-time":"2015-11-25T01:21:33.616930Z","url":"https://files.pythonhosted.org/packages/23/57/6a7c3ab4d04d055cada3b5511c40e0e699d8dd5d8217cae6fb68ae61dff6/psutil-3.3.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp34-none-win_amd64.whl","hashes":{"sha256":"65afd6fecc8f3aed09ee4be63583bc8eb472f06ceaa4fe24c4d1d5a1a3c0e13f"},"provenance":null,"requires-python":null,"size":92416,"upload-time":"2015-11-25T01:23:04.575877Z","url":"https://files.pythonhosted.org/packages/5d/a8/e62ec8105350c1e615ac84b084c7c8799d09e0d1b4530d3e68291dca8976/psutil-3.3.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp35-none-win32.whl","hashes":{"sha256":"ba1c558fbfcdf94515c2394b1155c1dc56e2bc2a9c17d30349827c9ed8a67e46"},"provenance":null,"requires-python":null,"size":91965,"upload-time":"2015-11-25T01:21:52.452732Z","url":"https://files.pythonhosted.org/packages/6e/6d/cf51e672eef1f1fbf9efce429d5411d4a2f3aa239e079b82531389562cd2/psutil-3.3.0-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp35-none-win_amd64.whl","hashes":{"sha256":"ba95ea0022dcb64d36f0c1335c0605fae35bdf3e0fea8d92f5d0f6456a35e55b"},"provenance":null,"requires-python":null,"size":94891,"upload-time":"2015-11-25T01:23:25.107121Z","url":"https://files.pythonhosted.org/packages/90/49/3726db12f0fa7ff8f7e5493cc128ee6b40f5720f7397a4ef01db9e28dd7b/psutil-3.3.0-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.tar.gz","hashes":{"sha256":"421b6591d16b509aaa8d8c15821d66bb94cb4a8dc4385cad5c51b85d4a096d85"},"provenance":null,"requires-python":null,"size":261983,"upload-time":"2015-11-25T01:20:55.681846Z","url":"https://files.pythonhosted.org/packages/fe/69/c0d8e9b9f8a58cbf71aa4cf7f27c27ee0ab05abe32d9157ec22e223edef4/psutil-3.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py2.6.exe","hashes":{"sha256":"326b305cbdb6f94dafbfe2c26b11da88b0ab07b8a07f8188ab9d75ff0c6e841a"},"provenance":null,"requires-python":null,"size":329214,"upload-time":"2015-11-25T18:50:19.881553Z","url":"https://files.pythonhosted.org/packages/a9/c1/7642d44312cffaa1b3efc6ac5252b7f1ab1c528903b55d56d7bd46805d92/psutil-3.3.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"9aede5b2b6fe46b3748ea8e5214443890d1634027bef3d33b7dad16556830278"},"provenance":null,"requires-python":null,"size":329153,"upload-time":"2015-11-25T01:22:03.853435Z","url":"https://files.pythonhosted.org/packages/bb/e0/f8e4e286bf9c075f0e9fb3c0b17cecef04cda5e91f4c54982b91b3baf338/psutil-3.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"73bed1db894d1aa9c3c7e611d302cdeab7ae8a0dc0eeaf76727878db1ac5cd87"},"provenance":null,"requires-python":null,"size":327512,"upload-time":"2015-11-25T01:22:31.545622Z","url":"https://files.pythonhosted.org/packages/fb/20/9438b78a3155b1eb480a4ea09dab6370f06e0a003cf43c3975743e0c9e8d/psutil-3.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"935b5dd6d558af512f42501a7c08f41d7aff139af1bb3959daa3abb859234d6c"},"provenance":null,"requires-python":null,"size":327497,"upload-time":"2015-11-25T01:22:51.620885Z","url":"https://files.pythonhosted.org/packages/ae/71/c68af8e9b05144de969da58e1bf5ebfe0859b1c83b827e05ae3116178bb1/psutil-3.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"4ca0111cf157dcc0f2f69a323c5b5478718d68d45fc9435d84be0ec0f186215b"},"provenance":null,"requires-python":null,"size":243943,"upload-time":"2015-11-25T01:23:16.182734Z","url":"https://files.pythonhosted.org/packages/bd/14/a67db75c827761bf55a50c6ce455cdf0fd7e75d1c7c395b7283359676288/psutil-3.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py2.6.exe","hashes":{"sha256":"b6f13c95398a3fcf0226c4dcfa448560ba5865259cd96ec2810658651e932189"},"provenance":null,"requires-python":null,"size":299025,"upload-time":"2015-11-25T18:49:29.675333Z","url":"https://files.pythonhosted.org/packages/ad/ea/d7c41ad9fab6e89263225c66971f9807a0396925dddf7c20901b637b99e2/psutil-3.3.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py2.7.exe","hashes":{"sha256":"ee6be30d1635bbdea4c4325d507dc8a0dbbde7e1c198bd62ddb9f43198b9e214"},"provenance":null,"requires-python":null,"size":299056,"upload-time":"2015-11-25T01:20:34.764583Z","url":"https://files.pythonhosted.org/packages/15/f7/a34370848c11d7d7933c0c107763ee470b54a7e48aa90a301919a3ad6757/psutil-3.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.3.exe","hashes":{"sha256":"dfa786858c268d7fbbe1b6175e001ec02738d7cfae0a7ce77bf9b651af676729"},"provenance":null,"requires-python":null,"size":293994,"upload-time":"2015-11-25T01:20:57.318743Z","url":"https://files.pythonhosted.org/packages/71/1e/af5675d52b426857441c29ad88d4fccfd55d300867ad02531d77991ab661/psutil-3.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.4.exe","hashes":{"sha256":"aa77f9de72af9c16cc288cd4a24cf58824388f57d7a81e400c4616457629870e"},"provenance":null,"requires-python":null,"size":294006,"upload-time":"2015-11-25T01:21:23.806352Z","url":"https://files.pythonhosted.org/packages/6d/41/cf5b54535ea052a32a76a8e8e56af817deb95f4ffde49277a52ded29763b/psutil-3.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.5.exe","hashes":{"sha256":"f500093357d04da8140d87932cac2e54ef592a54ca8a743abb2850f60c2c22eb"},"provenance":null,"requires-python":null,"size":233858,"upload-time":"2015-11-25T01:21:44.041656Z","url":"https://files.pythonhosted.org/packages/1e/1d/151535e51338efebe453a28d2f14d4d5b1e1f3ce54ccc63866c96dc7e1bd/psutil-3.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp26-none-win32.whl","hashes":{"sha256":"0b1382db1cf76d53fb1d6e5619b5f3c86126e11a933b200c21ed4fa7fe5037aa"},"provenance":null,"requires-python":null,"size":91763,"upload-time":"2016-01-15T12:34:15.511699Z","url":"https://files.pythonhosted.org/packages/8a/a4/6dfd46e45d06da1a4d42814dbbdcffe3a4fc7f9b655e1c2919ac960512c2/psutil-3.4.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp26-none-win_amd64.whl","hashes":{"sha256":"bcf212a926e8cffd3bec2acaeb584bf59a536e569d404bd8ea306f1752fbfc41"},"provenance":null,"requires-python":null,"size":94311,"upload-time":"2016-01-15T12:34:35.252561Z","url":"https://files.pythonhosted.org/packages/85/38/d9882d4e37f4b791bd949a1f45c620e0f2573bb4048eb16d59d469e97ec6/psutil-3.4.1-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp27-none-win32.whl","hashes":{"sha256":"1b8424eaa712fef7da41fc7f391b452e8991a641a54e49c4f46eb72ca2585577"},"provenance":null,"requires-python":null,"size":91570,"upload-time":"2016-01-15T12:25:47.323665Z","url":"https://files.pythonhosted.org/packages/cd/2d/760f774b1325037ea4ef85972f45fc9dee417da33ba225b21a0a8e512f5d/psutil-3.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"46d7429bae3703a0f2980c0299d4d49ada733c7ebd2cfa4e29fa3e31b5b16014"},"provenance":null,"requires-python":null,"size":94024,"upload-time":"2016-01-15T12:29:47.181880Z","url":"https://files.pythonhosted.org/packages/13/06/0104f224dd52bf9e3fb3ef14f6b6b93e9fac72f562842d54445af041f3f0/psutil-3.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp33-none-win32.whl","hashes":{"sha256":"08f4ab9b720310890fa9337321a6e1e8aa525538636526be77e82653588df46b"},"provenance":null,"requires-python":null,"size":91580,"upload-time":"2016-01-15T12:26:59.466185Z","url":"https://files.pythonhosted.org/packages/65/22/f7121341bc75bff65000ecc0c5aad4f2a6d129506c26d5533ade2ca67349/psutil-3.4.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp33-none-win_amd64.whl","hashes":{"sha256":"9e52230373076d0ecdb4aec373afd342c576ab52e11c382e058ed0188181a352"},"provenance":null,"requires-python":null,"size":93869,"upload-time":"2016-01-15T12:30:39.415707Z","url":"https://files.pythonhosted.org/packages/b0/84/a9edadc49ef3dbb89298855ae069b18ec534ca9f79a9294de417b8e46571/psutil-3.4.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp34-none-win32.whl","hashes":{"sha256":"e658cd0e0ad7a2971b2eeb6ee4b1a0ad14245003ea47425846bc8c3e892fd567"},"provenance":null,"requires-python":null,"size":91584,"upload-time":"2016-01-15T12:28:02.007581Z","url":"https://files.pythonhosted.org/packages/b6/cd/59a87e4f10181ee228c4edc7d4927e3d62f652cff9f25f95a7e7e9ab3df0/psutil-3.4.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp34-none-win_amd64.whl","hashes":{"sha256":"9c3e1146003df43aec9274be4741371a06896d70d7d590eb882ad59de2c06120"},"provenance":null,"requires-python":null,"size":93858,"upload-time":"2016-01-15T12:31:25.406165Z","url":"https://files.pythonhosted.org/packages/30/06/cf0559d12ca5ded37e6a32b1671be57fad3bade7f24536b943851aa6393e/psutil-3.4.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp35-none-win32.whl","hashes":{"sha256":"3d3b2df184a31646a7e66cc48304f900a82c18ab3dc69d2d5f693ea97fca0572"},"provenance":null,"requires-python":null,"size":93406,"upload-time":"2016-01-15T12:28:48.357070Z","url":"https://files.pythonhosted.org/packages/c9/57/6e65ff27fa567cd9a7bfbc0a435e33293451b80865bc3a3a7b13c9bf7799/psutil-3.4.1-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp35-none-win_amd64.whl","hashes":{"sha256":"820ed01d84ffcda1c613be80c09318d7560dd3505299c65bb99f101963bfc3dd"},"provenance":null,"requires-python":null,"size":96333,"upload-time":"2016-01-15T12:31:50.145506Z","url":"https://files.pythonhosted.org/packages/f0/f6/ccf16168a627d10ffbd80120cd2c521c4c9ecdb4545e402b7deca79f93ac/psutil-3.4.1-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.tar.gz","hashes":{"sha256":"c7443659674c87d1f9feecee0dfeea765da02181c58d532e0633337e42180c89"},"provenance":null,"requires-python":null,"size":271657,"upload-time":"2016-01-15T12:22:39.420430Z","url":"https://files.pythonhosted.org/packages/a5/56/c64187a9a6889e622f7ec687254cdb3cc3c706e11bba9244e6ac781ecf38/psutil-3.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py2.6.exe","hashes":{"sha256":"e88e43423af984d7f2ecf8babf9d861ff59436794b0fdd2f85e9ea6bf7af6627"},"provenance":null,"requires-python":null,"size":331136,"upload-time":"2016-01-15T12:34:26.229804Z","url":"https://files.pythonhosted.org/packages/f7/90/53adfe2804c9cde062eb5014d88f0d067690fe1457ad2f49a2a553767689/psutil-3.4.1.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"3c08e2c200b222a92a4ecaa8055a48e27e7cfe82d9bf6402b52dd82413a786ed"},"provenance":null,"requires-python":null,"size":330798,"upload-time":"2016-01-15T12:29:26.473954Z","url":"https://files.pythonhosted.org/packages/66/9b/2b58fdab300e5f2a20c3999c485692cfa73cc9d4e50770a19cc871f92743/psutil-3.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"d03b8d081a281ebaa2122f259f7c0b3a464b2b98a3c221b9a54bfb0840355a9f"},"provenance":null,"requires-python":null,"size":329156,"upload-time":"2016-01-15T12:30:04.062459Z","url":"https://files.pythonhosted.org/packages/4c/26/695fa5b3578248f424d9a8e5bf2aafc6f706aeb7ec21ee31a5ebc2f79660/psutil-3.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"66a243c4b9ad93059be391a18e3f75e015ad70b220df4f7f30f9f578b89f27ad"},"provenance":null,"requires-python":null,"size":329140,"upload-time":"2016-01-15T12:31:00.945171Z","url":"https://files.pythonhosted.org/packages/25/63/54f2ba7cf31bb936b9c2cd7a77fd40a698fb232cd7c95c1ce997295a5954/psutil-3.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.5.exe","hashes":{"sha256":"4ee8641803d68a2e48952951336f9474a8914854da088fca673d67a91da7f9a4"},"provenance":null,"requires-python":null,"size":245586,"upload-time":"2016-01-15T12:31:39.398299Z","url":"https://files.pythonhosted.org/packages/43/54/f2d3b8845105fe5f55d5f0fde36773ab94fe1e35a0f4a5219adc818d586b/psutil-3.4.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py2.6.exe","hashes":{"sha256":"a4de0daf0dc7aeff6d45c6a1c782ef30d2b4fc6495196acabcb5cde2fb9b5a74"},"provenance":null,"requires-python":null,"size":300946,"upload-time":"2016-01-15T12:33:59.097771Z","url":"https://files.pythonhosted.org/packages/9e/34/53e1e85df97508df1b3eea711ab2809cc8f01b20e3b2341645673eb5d835/psutil-3.4.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py2.7.exe","hashes":{"sha256":"0efcecb6fcc21d83e9d4354754c6b8a8deb47a5fa06ec5d09fcf9799719eeac2"},"provenance":null,"requires-python":null,"size":300700,"upload-time":"2016-01-15T12:25:12.391548Z","url":"https://files.pythonhosted.org/packages/2f/4c/a07a53ff938e3bbc2ba73e4a484af8d1e02054b0bfcaf0f6d30117187d9f/psutil-3.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.3.exe","hashes":{"sha256":"62d0b529e40262293f39d7455db24f7ee297a1a3fe7f0e3e5923ae8168bd865c"},"provenance":null,"requires-python":null,"size":295638,"upload-time":"2016-01-15T12:26:24.412799Z","url":"https://files.pythonhosted.org/packages/39/6c/03ade7ba131b3952d916ed26c277418234bec0c9a5dfad513b9a5bb51046/psutil-3.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.4.exe","hashes":{"sha256":"6102294d6150f2c072dbc0166348389e8fa5d14a769ad118b697cda5b31c3381"},"provenance":null,"requires-python":null,"size":295651,"upload-time":"2016-01-15T12:27:36.577070Z","url":"https://files.pythonhosted.org/packages/52/d7/c2e9e0cb21482304e39a7681066c32c50e984f109bcda5929a84af926d70/psutil-3.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.5.exe","hashes":{"sha256":"0ffd99167272bb80c6ecf68f4c3d3176bef0f8c2a68f7e2787cab32413830023"},"provenance":null,"requires-python":null,"size":235502,"upload-time":"2016-01-15T12:28:24.463783Z","url":"https://files.pythonhosted.org/packages/1c/06/4d0ec9a6427db9c3b9885c4d724ca299746519b2ee61b724665d49e352c6/psutil-3.4.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp26-none-win32.whl","hashes":{"sha256":"2ac75c13657ab18eac0014e3f4c80def16978507b30e7719e46042ec93316bb0"},"provenance":null,"requires-python":null,"size":91920,"upload-time":"2016-01-20T16:25:20.303966Z","url":"https://files.pythonhosted.org/packages/be/b7/999dcbee8cc5ae32e64b2d0c9d588a3f5a441a07404772af83e86f3c8bc7/psutil-3.4.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp26-none-win_amd64.whl","hashes":{"sha256":"162f76140ca09490b9d218840bd641cbd1439245dcc2a9dd41f86224ed19490c"},"provenance":null,"requires-python":null,"size":94467,"upload-time":"2016-01-20T16:27:40.461506Z","url":"https://files.pythonhosted.org/packages/60/97/f9ea4fa7a4914350d15347a6a583c8a185643bb6bd5dc76d13e9d7dfc150/psutil-3.4.2-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp27-none-win32.whl","hashes":{"sha256":"b5f4bfdaa6389552501253b13b6022b7e3d715e4dca4b5cc1808f58cca181359"},"provenance":null,"requires-python":null,"size":91721,"upload-time":"2016-01-20T16:25:38.512050Z","url":"https://files.pythonhosted.org/packages/d4/19/4e5c376587076c969784762de8024bb30168a548b402e1b432221c5b97b1/psutil-3.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"9267e9bccb5c8b1c5ca872eb1caf88ba0ae47e336eb200be138f51d9f75e1113"},"provenance":null,"requires-python":null,"size":94177,"upload-time":"2016-01-20T16:27:58.779061Z","url":"https://files.pythonhosted.org/packages/d3/19/39f42cdfba58ab593d24f49ffc073c07b9b34ff7d5ba079b975018002e51/psutil-3.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp33-none-win32.whl","hashes":{"sha256":"413800a94815e6bf3e3227823e4d46b06c63bd22ab9e5af112b9220af9a9c9d8"},"provenance":null,"requires-python":null,"size":91738,"upload-time":"2016-01-20T16:25:59.987045Z","url":"https://files.pythonhosted.org/packages/8e/7a/8ba0c9da039b5733edbe17321f0546f08a7066861ffcdb83c31eb061e8f1/psutil-3.4.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp33-none-win_amd64.whl","hashes":{"sha256":"45535c18a0f261f90ff1ebb7d74c5e88d582cfb2006e4588498b9c0c9da5acb3"},"provenance":null,"requires-python":null,"size":94024,"upload-time":"2016-01-20T16:28:42.605657Z","url":"https://files.pythonhosted.org/packages/34/a7/94fc00a023ede02c3a7f525c63997a23c22434cbed65738ee3ef8939e084/psutil-3.4.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp34-none-win32.whl","hashes":{"sha256":"c9ef9a08254c251858cf747703e6fd75fe6e9549b1e040bb4a501feaf44a5a75"},"provenance":null,"requires-python":null,"size":91749,"upload-time":"2016-01-20T16:26:31.788083Z","url":"https://files.pythonhosted.org/packages/dc/8b/df5d7dcfe8fc5db0c303e518ce12b7117cb70e1cbb29c0396ea6e36fc7a2/psutil-3.4.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp34-none-win_amd64.whl","hashes":{"sha256":"0bf8925c3d252178c47bd8f29aff99c57a56f94513354b60069b457ca04bc25b"},"provenance":null,"requires-python":null,"size":94004,"upload-time":"2016-01-20T16:29:27.043903Z","url":"https://files.pythonhosted.org/packages/1c/cf/c9ce0014f43f74b1ce72c004c8f2eda68339cbc19117d9f090ee14afce3e/psutil-3.4.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp35-none-win32.whl","hashes":{"sha256":"461d1431a14e4da5e687cfdc2a8576b1f0e3bc658694ab9c6ef2fa1e4c1a4871"},"provenance":null,"requires-python":null,"size":93563,"upload-time":"2016-01-20T16:27:20.576920Z","url":"https://files.pythonhosted.org/packages/de/51/d1ab564dfe98d5fcbccfcab0afdedb269f7266192721e94688ab3956b123/psutil-3.4.2-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp35-none-win_amd64.whl","hashes":{"sha256":"23d4ea79fea3de81daf9460662e49ff718555779b2f5e5e3610648c0a8cafecc"},"provenance":null,"requires-python":null,"size":96484,"upload-time":"2016-01-20T16:29:53.151921Z","url":"https://files.pythonhosted.org/packages/89/d8/dc9ce7b8862ab2d86975dd5199791b0ab2b2168fc2389223a216c2da1d45/psutil-3.4.2-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.tar.gz","hashes":{"sha256":"b17fa01aa766daa388362d0eda5c215d77e03a8d37676b68971f37bf3913b725"},"provenance":null,"requires-python":null,"size":274361,"upload-time":"2016-01-20T16:26:46.533423Z","url":"https://files.pythonhosted.org/packages/7b/58/2675697b6831e6ac4b7b7bc4e5dcdb24a2f39f8411186573eb0de16eb6d5/psutil-3.4.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py2.6.exe","hashes":{"sha256":"3716cb36373ecfd033c148c8e8e22d815a9b682c87538c5bde2a3faca1a44705"},"provenance":null,"requires-python":null,"size":331279,"upload-time":"2016-01-20T16:27:30.129391Z","url":"https://files.pythonhosted.org/packages/6f/52/26cefb84d714ecdf39f6d4ea62af49af731cf55d8937a252226de41d3fb0/psutil-3.4.2.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py2.7.exe","hashes":{"sha256":"9eba153441fabd6677f9dec95eedbfdcf4fe832a43b91c18f2c15bfd0a12b6c0"},"provenance":null,"requires-python":null,"size":330991,"upload-time":"2016-01-20T16:27:49.025596Z","url":"https://files.pythonhosted.org/packages/1f/85/817b298f6865d7a140897882015096ab25514e113c98ba3896b2e2c0425c/psutil-3.4.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.3.exe","hashes":{"sha256":"2ffc77ec7452675db45174f77e65bfc9abd5780e696c4dd486fff89e18ef104a"},"provenance":null,"requires-python":null,"size":329349,"upload-time":"2016-01-20T16:28:23.729829Z","url":"https://files.pythonhosted.org/packages/2b/05/ccb8e8dc272a6aa126a6066583102b78df8939aeffd910a3ea28a51d48af/psutil-3.4.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.4.exe","hashes":{"sha256":"6b576ea8faa312700953de30b92ff49dcd966dcdbf2e039c3655077826b59812"},"provenance":null,"requires-python":null,"size":329334,"upload-time":"2016-01-20T16:29:12.322779Z","url":"https://files.pythonhosted.org/packages/8f/0e/9b3eedad9ea2aa8e51c3ca6aa6485c0ec85bfc73925fbd4d82bbe03ead18/psutil-3.4.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.5.exe","hashes":{"sha256":"2a987c57ddb06a1e67f75a4dd34d2962f8675c3d60b2104da2d60fdaa378b50f"},"provenance":null,"requires-python":null,"size":245779,"upload-time":"2016-01-20T16:29:45.537968Z","url":"https://files.pythonhosted.org/packages/2f/bb/5483a7a54dfaedcd5bc6d0f9f8beef21d96785589e10d09e246f7092cfe1/psutil-3.4.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py2.6.exe","hashes":{"sha256":"87b657f1021ab4155669f77baf9557657a015b0762854702d64ee7cfa19d5ae2"},"provenance":null,"requires-python":null,"size":301089,"upload-time":"2016-01-20T16:25:11.034218Z","url":"https://files.pythonhosted.org/packages/2e/9b/2bb0317a5113b4a3d597a9bcb94cafacb52f15a10631b1f0eb781ceb8e7a/psutil-3.4.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py2.7.exe","hashes":{"sha256":"d837d654a78fcc6cf7338fc3c3f025e5a43cf646d4d6cf180f0f3573ef255844"},"provenance":null,"requires-python":null,"size":300894,"upload-time":"2016-01-20T16:25:29.293012Z","url":"https://files.pythonhosted.org/packages/8c/3b/bf4d0698153784231768aa79255f1641efde680c4d178ba327546eba69df/psutil-3.4.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.3.exe","hashes":{"sha256":"ef756512c86cf24916f47b2209ff5dc69ef4d5ff8b3b0229863aab3537af58a1"},"provenance":null,"requires-python":null,"size":295833,"upload-time":"2016-01-20T16:25:50.417672Z","url":"https://files.pythonhosted.org/packages/50/be/c4911ae27c944e12183d9ba844ff0eee706b5208f92e4929d8120b79448e/psutil-3.4.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.4.exe","hashes":{"sha256":"13917c61de33518fcdca94a8f1005c4bb0be1f106af773de8c12d6a5a3f349ae"},"provenance":null,"requires-python":null,"size":295845,"upload-time":"2016-01-20T16:26:17.574774Z","url":"https://files.pythonhosted.org/packages/b5/d9/9a15af2703d8a0d7b685511df811fc4930b12d7b85b96573e843a0ba1067/psutil-3.4.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.5.exe","hashes":{"sha256":"75c4484f0e1038c1a37ae37fc80f5b59b456e363c696ed889027e79a831853ec"},"provenance":null,"requires-python":null,"size":235696,"upload-time":"2016-01-20T16:27:12.935221Z","url":"https://files.pythonhosted.org/packages/2c/74/46cf554a4a8d7d2367f058e6c90ba26a66e52e818812ec6de53a5013bd87/psutil-3.4.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp26-none-win32.whl","hashes":{"sha256":"0661261b634f01ec2568136fedf29382f5c94678c34f56b4137b1d019085ca6f"},"provenance":null,"requires-python":null,"size":154479,"upload-time":"2016-02-17T16:42:58.173240Z","url":"https://files.pythonhosted.org/packages/72/e2/24700d1a099dcd824ca7305cf439625a457221459494e677e7649a2f228b/psutil-4.0.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp26-none-win_amd64.whl","hashes":{"sha256":"b613a9fb5c3d2b16c65df3121aa369a28caed83391883bc24918cf16c5de495b"},"provenance":null,"requires-python":null,"size":156749,"upload-time":"2016-02-17T16:45:09.428253Z","url":"https://files.pythonhosted.org/packages/62/c0/1adb11a832d5aab8a984702a4f6fc08e5698fa4bbc8dc6eddac1c711c7ab/psutil-4.0.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-cp27m-win32.whl","hashes":{"sha256":"3eb6bc7e8d92777deb4288178c25455e21109033bb54ec475485b611e92d3b42"},"provenance":null,"requires-python":null,"size":154302,"upload-time":"2016-02-17T16:43:23.863441Z","url":"https://files.pythonhosted.org/packages/e8/c3/542bc833b743e952cbf99017ecb60add0ad3725a82e942b25aa5de523f8c/psutil-4.0.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"c94193f38aa3bc35fd5dbcd24653d1f683c88ec8030997d1d56f92207ba7c523"},"provenance":null,"requires-python":null,"size":156487,"upload-time":"2016-02-24T17:23:02.172281Z","url":"https://files.pythonhosted.org/packages/32/1b/5f3cc96374c4eac441e96bb8698556c6c48eacfdcf843093bebcfd8ce56b/psutil-4.0.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"cb969d3c77db8810aba45e8a04e0b2851cd088e338be2430e1ff452f4e06007c"},"provenance":null,"requires-python":null,"size":156486,"upload-time":"2016-02-17T16:45:40.145586Z","url":"https://files.pythonhosted.org/packages/94/37/dc09e24aa80016ddeaff235d2f724d8aac9813b73cc3bf8a7fe3d1878315/psutil-4.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-cp33m-win32.whl","hashes":{"sha256":"6a372681382b523bc837ee2eff6a84ded0f85b013b7c29ea6211bc928c7cc656"},"provenance":null,"requires-python":null,"size":154244,"upload-time":"2016-02-24T17:21:40.946801Z","url":"https://files.pythonhosted.org/packages/a0/8a/b9352e0daf69b501296715e0fca1b49d861130eb66156ce3b12aeeb039e4/psutil-4.0.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"2bbb75fc2549965b457f313cbdfb98a00624f25fcb36e075322bb8b8912d83b5"},"provenance":null,"requires-python":null,"size":156393,"upload-time":"2016-02-24T17:23:25.807132Z","url":"https://files.pythonhosted.org/packages/4b/77/0fefa732947da69cba7f2580285eff553fe4a416314234f809901bede361/psutil-4.0.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-none-win32.whl","hashes":{"sha256":"d6219c89940d745b614716be7c906660f2108a1d84b8ffc720922596b8306e23"},"provenance":null,"requires-python":null,"size":154245,"upload-time":"2016-02-17T16:43:48.027623Z","url":"https://files.pythonhosted.org/packages/1f/d9/34fb4fab5f1bbfeddc76675b1b5ca00b45ef490e63295af33542cedcd26b/psutil-4.0.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-none-win_amd64.whl","hashes":{"sha256":"a64bb22e264f91a6d80cf8fdd813bd4fdd349dc367b363d517cf8ae1bc2c5db0"},"provenance":null,"requires-python":null,"size":156399,"upload-time":"2016-02-17T16:46:09.673427Z","url":"https://files.pythonhosted.org/packages/97/03/b9485635cb38dfad854754625422a49f434f53f214bff4885580f0fb21e6/psutil-4.0.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-cp34m-win32.whl","hashes":{"sha256":"a521266ac13485772987f00342b53cb230cde98ce91d61154860ba4109fe2ebe"},"provenance":null,"requires-python":null,"size":154269,"upload-time":"2016-02-17T16:44:14.936699Z","url":"https://files.pythonhosted.org/packages/73/32/6399071b097f1251f6fa12770b30a67d5b3c9c0c76e81eacbb6139e1bf6d/psutil-4.0.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"b559b8e8a85cde929e01e94e9635649e8641a88b2d077714933dc7723a967020"},"provenance":null,"requires-python":null,"size":156390,"upload-time":"2016-02-24T17:23:50.194021Z","url":"https://files.pythonhosted.org/packages/71/d7/878b77bad61bd94f4454536e823b6a48cd0af0f23b1506a2c8a49b2578cd/psutil-4.0.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-none-win_amd64.whl","hashes":{"sha256":"02d7291f81e78c506ac2b5481aa9dc6d3888195484ac114ac984b37477f60929"},"provenance":null,"requires-python":null,"size":156397,"upload-time":"2016-02-17T16:46:44.626238Z","url":"https://files.pythonhosted.org/packages/ea/22/5f44e6eaa1e82f5a1497f3dfcf045e1998fca36d70de8a370ec96ce0f789/psutil-4.0.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-cp35m-win32.whl","hashes":{"sha256":"7906302696960a6a788bb8fe1165b4ccd0156553b8a2f61640fd45a836d39024"},"provenance":null,"requires-python":null,"size":156177,"upload-time":"2016-02-24T17:22:25.142667Z","url":"https://files.pythonhosted.org/packages/e2/fe/a5ec73e62878cc2d0451b7029f4406647435dd8036ab15d6ed2fd42558bf/psutil-4.0.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f4214bdb2e96374b4c4a3a818bd8c7867f94571d33b91867b6dfd5f9b328c8ac"},"provenance":null,"requires-python":null,"size":158783,"upload-time":"2016-02-24T17:24:26.439061Z","url":"https://files.pythonhosted.org/packages/1d/a7/9300ad3d4071c191894073a94217ed5c0ca9604c782bdbf083bbedfa9cb1/psutil-4.0.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-none-win32.whl","hashes":{"sha256":"4a1631cb8c4de2b6c9b4b16f8800d43de23c683805f7b6a5aec1c268a73df270"},"provenance":null,"requires-python":null,"size":156183,"upload-time":"2016-02-17T16:44:42.458015Z","url":"https://files.pythonhosted.org/packages/14/f0/a2436cb642ecfec0bfb6338e5fa26581d4dbcf1a00f7d9fe99380eb6779f/psutil-4.0.0-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-none-win_amd64.whl","hashes":{"sha256":"994839b6d99acbf90914fddf2e2817aaffb67ceca5d10134319267e3ffe97258"},"provenance":null,"requires-python":null,"size":158787,"upload-time":"2016-02-17T16:47:18.920483Z","url":"https://files.pythonhosted.org/packages/e8/2a/e215824c785d77119af61802bbb4d16dacc26ec0687709274afa3ac039fa/psutil-4.0.0-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.tar.gz","hashes":{"sha256":"1a7c672f9ee79c84ff16b8de6f6040080f0e25002ac47f115f4a54aa88e5cfcd"},"provenance":null,"requires-python":null,"size":293800,"upload-time":"2016-02-17T16:41:45.938066Z","url":"https://files.pythonhosted.org/packages/c4/3b/44bcae6c0fc53362bb7325fde25a73b7fd46541b57c89b7556ca81b08e7e/psutil-4.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py2.6.exe","hashes":{"sha256":"61bf81cbe84e679a5b619e65775b0674b2c463885e49ddab73778198608198c5"},"provenance":null,"requires-python":null,"size":394157,"upload-time":"2016-02-17T16:45:00.666953Z","url":"https://files.pythonhosted.org/packages/86/50/6303a28a4ab5c9b6b9ef74eef70b141d5bd743ab096c58d225b6212fa057/psutil-4.0.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"23618cbc04e2431d9c4d97f56ab8b4e2e35366c9a9a6e1ef89a3a7287d359864"},"provenance":null,"requires-python":null,"size":393901,"upload-time":"2016-02-17T16:45:21.822412Z","url":"https://files.pythonhosted.org/packages/59/82/93052d6359addea338c528ebd50254806d62bc2b2d1ad1303c49d85162f9/psutil-4.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"b6f16c71be03495eeb4772c1f3f926213e3ea82ea7779bd1143229e6b419760b"},"provenance":null,"requires-python":null,"size":392318,"upload-time":"2016-02-17T16:45:57.189438Z","url":"https://files.pythonhosted.org/packages/e6/14/9ac37705e0753732c7707b000d1e076daac95ee02f35fd43ce906235ea1f/psutil-4.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"24b41e436afbcecb07e485e58a52effdbd7b8065ad8a2e4d555b6d88907f19b7"},"provenance":null,"requires-python":null,"size":392315,"upload-time":"2016-02-17T16:46:29.967466Z","url":"https://files.pythonhosted.org/packages/77/a9/ff7c29d2e244f5bdc7654a626cbfcccd401e78df6e9388713f322c7aa7c7/psutil-4.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.5.exe","hashes":{"sha256":"88edc0e7bfa672c245df74b1ac3b59db432cd75e5704beccc268e177ac2ffbbc"},"provenance":null,"requires-python":null,"size":308678,"upload-time":"2016-02-17T16:47:07.280714Z","url":"https://files.pythonhosted.org/packages/cc/1b/863bee07da70fe61cae804333d64242d9001b54288e8ff54e770225bbc0a/psutil-4.0.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py2.6.exe","hashes":{"sha256":"882a8ac29b63f256f76465d8fcd6e9eaeb9c929acdac26af102da97d66b2b619"},"provenance":null,"requires-python":null,"size":364245,"upload-time":"2016-02-17T16:42:49.267819Z","url":"https://files.pythonhosted.org/packages/41/39/6ea85cb0c748aae2943144118f1696004f5a99c54dab1fc635cffbb0d06c/psutil-4.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py2.7.exe","hashes":{"sha256":"bf3b2e305ca7408df40156c9aa6261c7baaff831441f0c018d0682bd820286f2"},"provenance":null,"requires-python":null,"size":364072,"upload-time":"2016-02-17T16:43:14.467612Z","url":"https://files.pythonhosted.org/packages/8f/0d/3e9cf8abb62d7241531019d78abaa87a19f3fcc017bfb9c2058ba61e8cf1/psutil-4.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.3.exe","hashes":{"sha256":"38d38211bba35c705a007e62b9dcc9be1d222acfcbee812612d4a48f9d8f0230"},"provenance":null,"requires-python":null,"size":358940,"upload-time":"2016-02-17T16:43:38.439349Z","url":"https://files.pythonhosted.org/packages/57/eb/514a71eab624b381473a3df9c3e3a02f5bb15707b12daf02c137271dfd26/psutil-4.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.4.exe","hashes":{"sha256":"bc868653a6502c3a01da32b3a598a8575674975f5586ac0bf9181349588925b9"},"provenance":null,"requires-python":null,"size":358966,"upload-time":"2016-02-17T16:44:02.873748Z","url":"https://files.pythonhosted.org/packages/25/f6/ef4b802658c21d5b79a0e038db941f4b08a7cc2de78df1949ad709542682/psutil-4.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.5.exe","hashes":{"sha256":"38244b0d07d3bece481a6f1c049e6101fdd26f2ee63dadcb63ce993283032fdc"},"provenance":null,"requires-python":null,"size":298915,"upload-time":"2016-02-17T16:44:31.772075Z","url":"https://files.pythonhosted.org/packages/b9/be/b8938c409231dab07d2954ff7b4d1129e725e0e8ab1b016d7f471f3285e9/psutil-4.0.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp26-none-win32.whl","hashes":{"sha256":"13aed96ad945db5c6b3d5fbe92be65330a3f2f757a300c7d1578a16efa0ece7f"},"provenance":null,"requires-python":null,"size":159498,"upload-time":"2016-03-12T17:13:58.069685Z","url":"https://files.pythonhosted.org/packages/77/04/d5a92cb5c0e79b84294f6c99b9725806921d1d88032e9d056ca8a7ba31c1/psutil-4.1.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp26-none-win_amd64.whl","hashes":{"sha256":"90b58cf88e80a4af52b79678df474679d231ed22200e6c25605a42ca71708a47"},"provenance":null,"requires-python":null,"size":161924,"upload-time":"2016-03-12T17:17:01.346400Z","url":"https://files.pythonhosted.org/packages/b5/a5/cf96f9f13f9e20bdb4cd2ca1af2ddd74f76fea4bbfb8505c31a5900b38d2/psutil-4.1.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp27-cp27m-win32.whl","hashes":{"sha256":"ac141a44a5c145e9006bc7081c714b2c317077d158b65fe4624c9cbf2b8ac7bf"},"provenance":null,"requires-python":null,"size":159318,"upload-time":"2016-03-12T17:14:48.199436Z","url":"https://files.pythonhosted.org/packages/8a/31/439614cc2ccd6f3ce1d173c0d7c7a9e45be17cd2bf3ae1f8feaaf0a90cee/psutil-4.1.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"3605b6b9f23f3e186b157b03a95e0158559eb74bcef5d51920b8ddb48cc3a7e7"},"provenance":null,"requires-python":null,"size":161579,"upload-time":"2016-03-12T17:17:24.047978Z","url":"https://files.pythonhosted.org/packages/90/97/0a34c0e98bb794f0fc19f0eae13d26fbf39583c768a9a6c614c917135c00/psutil-4.1.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp33-cp33m-win32.whl","hashes":{"sha256":"5568e21c8eb9de0e56c8a4a38982b725bf42117bca7ac75c7b079e5214aea5c4"},"provenance":null,"requires-python":null,"size":159241,"upload-time":"2016-03-12T17:15:16.355951Z","url":"https://files.pythonhosted.org/packages/bb/de/8e1f8c4ea6035d08e3c87a0cfc8af6f2862da21697c16d1d17311e095117/psutil-4.1.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"3d3f8ae20b04b68e65b46dc2eedf15f32925655dacbb11cb7afe56ac562e112a"},"provenance":null,"requires-python":null,"size":161458,"upload-time":"2016-03-12T17:17:51.825112Z","url":"https://files.pythonhosted.org/packages/ac/cf/6241dd597ef4f995ab8e29746c54890c1acbb322484afed05aa8988118e1/psutil-4.1.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp34-cp34m-win32.whl","hashes":{"sha256":"faafb81bf7717fa8c44bb0f2e826768f561c0311fd0568090c59c9b253b65238"},"provenance":null,"requires-python":null,"size":159266,"upload-time":"2016-03-12T17:15:48.577644Z","url":"https://files.pythonhosted.org/packages/48/2d/46ba91df965d4f0af5fd4252ac249ff408f6cb966fe1208396933275246f/psutil-4.1.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"4ab1ee4152dbb790a37291149b73b1918ab4398c8edb3af7847fa6c884024c93"},"provenance":null,"requires-python":null,"size":161466,"upload-time":"2016-03-12T17:18:23.409579Z","url":"https://files.pythonhosted.org/packages/c0/b1/70868328ddf2cfcde201136bdaf4c9f7fabf868890bc91694fd5fa0fbc19/psutil-4.1.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp35-cp35m-win32.whl","hashes":{"sha256":"2fa06b7ba58e870fdaa1427e82ed427a785493c7a998e059e0806b2c48bdbfaf"},"provenance":null,"requires-python":null,"size":161345,"upload-time":"2016-03-12T17:16:33.062364Z","url":"https://files.pythonhosted.org/packages/dc/f7/5d3f84507c057af85bc70da10b51a827766999f221b42cdf9621ca756e80/psutil-4.1.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"1ca460fea3822d04f332f5dde144accc5ca4610e5bbce53f15d09cd985f30385"},"provenance":null,"requires-python":null,"size":164147,"upload-time":"2016-03-12T17:18:49.483687Z","url":"https://files.pythonhosted.org/packages/f1/65/040624aab6ca646af0c8b68ac54d08e0a33a672feb9405581cd509741367/psutil-4.1.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.tar.gz","hashes":{"sha256":"c6abebec9c8833baaf1c51dd1b0259246d1d50b9b50e9a4aa66f33b1e98b8d17"},"provenance":null,"requires-python":null,"size":301330,"upload-time":"2016-03-12T17:12:53.032151Z","url":"https://files.pythonhosted.org/packages/71/9b/6b6f630ad4262572839033b69905d415ef152d7701ef40aa98941ba75b38/psutil-4.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py2.6.exe","hashes":{"sha256":"30a97a9c3ace92001e419a6bb039b2e899c5ab24cab6ad8bc249506475c84a0c"},"provenance":null,"requires-python":null,"size":399511,"upload-time":"2016-03-12T17:16:48.833953Z","url":"https://files.pythonhosted.org/packages/28/bd/c389af84b684d36010a634834f76932ff60f33505c54413c50eceb720a5d/psutil-4.1.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"3ba9236c38fe85088b9d79bd5871e07f253d225b357ce82db9240e5807f147b6"},"provenance":null,"requires-python":null,"size":399168,"upload-time":"2016-03-12T17:17:14.518227Z","url":"https://files.pythonhosted.org/packages/6c/e8/49ff1b33e9fa6f7ea1232d40bbef9a453424fbf0421a7c53d9ecb9a896e7/psutil-4.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"99a902d1bf5beb13cca4d7a3dc82efb6eaf40aafe916a5b632d47393313bfcfd"},"provenance":null,"requires-python":null,"size":397557,"upload-time":"2016-03-12T17:17:40.792655Z","url":"https://files.pythonhosted.org/packages/c5/3e/47adda552a79480e2a5d38a2f90144ab4e7ea34eba2b707523cdd1c65fc6/psutil-4.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"ecf8b83e038acdda9102aebadb1525f89231463772cbe89e3e8a2cf5a5c6065d"},"provenance":null,"requires-python":null,"size":397564,"upload-time":"2016-03-12T17:18:11.514028Z","url":"https://files.pythonhosted.org/packages/52/9f/5874f391a300feead5519872395cbb4d4588eace24962150a03cd9b6ffdf/psutil-4.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.5.exe","hashes":{"sha256":"448db9bf9db5d162f0282af70688e03d67d756b93d5bed94b0790a27a96af75b"},"provenance":null,"requires-python":null,"size":314216,"upload-time":"2016-03-12T17:18:36.745340Z","url":"https://files.pythonhosted.org/packages/32/34/6588580a1775a0741e14946003bf2722c493c7956c7dcc9a40c85dbe19f5/psutil-4.1.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py2.6.exe","hashes":{"sha256":"11b48d7ec00061960ffbef33a42e919f188e10a6a54c4161692d77a3ac37f1e2"},"provenance":null,"requires-python":null,"size":369441,"upload-time":"2016-03-12T17:13:47.639393Z","url":"https://files.pythonhosted.org/packages/5d/cc/7bf8593a60ed54b47def9a49a60b8bc3517d6fef6ee52a229583a5bc9046/psutil-4.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py2.7.exe","hashes":{"sha256":"c15ddba9f4c278f7d1bbbadc34df89d993171bb328fa1117cbecf68bcc1a01e5"},"provenance":null,"requires-python":null,"size":369263,"upload-time":"2016-03-12T17:14:25.482243Z","url":"https://files.pythonhosted.org/packages/bf/fa/7f0eda490dd5480bb8e6358f9e893fe7f824ec3a5b275b069708272d2260/psutil-4.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.3.exe","hashes":{"sha256":"8f97a836b89b09718b00aedbfd11d8468bbfcb821feadd65e338bd0b972dac54"},"provenance":null,"requires-python":null,"size":364112,"upload-time":"2016-03-12T17:15:06.252090Z","url":"https://files.pythonhosted.org/packages/e8/1c/e7d17500c0f5899f0fd3fd3b6d93c92254aff6de00cabc9c08de5a3803a2/psutil-4.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.4.exe","hashes":{"sha256":"fef37f4e2964043a58b6aa3b3be05ef9b3c7a58feb806d7e49dc91702bac52fa"},"provenance":null,"requires-python":null,"size":364136,"upload-time":"2016-03-12T17:15:29.468205Z","url":"https://files.pythonhosted.org/packages/6d/8e/7acd4079567fc64e1df12be6faeddf0ee19432445210293594444ea980a6/psutil-4.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.5.exe","hashes":{"sha256":"1a9409d2204d397b1ed10528065e45020e0b1c2ee5204bf5a1bc6fdff3f6ab91"},"provenance":null,"requires-python":null,"size":304255,"upload-time":"2016-03-12T17:16:06.024724Z","url":"https://files.pythonhosted.org/packages/5b/30/10f3bef7fa284167a3f9bd3862bcba5cc14fb8509f146a2f696ea5265b93/psutil-4.1.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"data-dist-info-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"filename":"psutil-4.2.0-cp27-cp27m-win32.whl","hashes":{"sha256":"19f6c8bd30d7827ce4d4bbcfe23fe7158fea3d72f59505850c5afa12985184bb"},"provenance":null,"requires-python":null,"size":165248,"upload-time":"2016-05-15T06:36:58.089018Z","url":"https://files.pythonhosted.org/packages/58/a5/2ccc9f6180ea769005405381f6b0d01fe1268f20cc85877b02c04c27d306/psutil-4.2.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"data-dist-info-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"filename":"psutil-4.2.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"92bc2351bb4bc7672b3d0e251a449ac2234bbe4fac11f708614bdc0a8ebffe3b"},"provenance":null,"requires-python":null,"size":167782,"upload-time":"2016-05-15T06:37:06.221707Z","url":"https://files.pythonhosted.org/packages/c8/e5/5d0a1b2e182e41888fc4e9f4f657f37f126f9fdcd431b592442311c2db98/psutil-4.2.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp33-cp33m-win32.whl","hashes":{"sha256":"2e16f792deceb1d33320981aaff7f139561cf6195ee3f1b21256d7f214162517"},"provenance":null,"requires-python":null,"size":165259,"upload-time":"2016-05-15T06:37:12.236981Z","url":"https://files.pythonhosted.org/packages/dd/94/8aeb332d07530b552099eaf207db13d859e09facfa8162892b4f9ef302dd/psutil-4.2.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"3c57a6731b3bd4c4af834b0137493a388b76192f5adc2399825015b777e0b02b"},"provenance":null,"requires-python":null,"size":167667,"upload-time":"2016-05-15T06:37:17.736147Z","url":"https://files.pythonhosted.org/packages/d5/6b/c10a228ef2cdbc077171be3b273cd2f49e4f814bf7dc2deb3a464cc126de/psutil-4.2.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp34-cp34m-win32.whl","hashes":{"sha256":"0cda72a1efacd2b028c9dbf0731111041e6cf9e7be938162811ab32ab3e88254"},"provenance":null,"requires-python":null,"size":165272,"upload-time":"2016-05-15T06:37:23.488252Z","url":"https://files.pythonhosted.org/packages/35/3e/3db756e014fe3e6e22e35c8394057dcf1eef58076d84fdf83ac00a053182/psutil-4.2.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"ce208e1c416e143697a1ee9dd86ae9720c740c11764a1fda88eb28a2ecc0b510"},"provenance":null,"requires-python":null,"size":167627,"upload-time":"2016-05-15T06:37:28.596251Z","url":"https://files.pythonhosted.org/packages/c7/7d/cfb299960cf6923cca782f331b034c09239e9015dedf530dd206177dd6e4/psutil-4.2.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp35-cp35m-win32.whl","hashes":{"sha256":"375b0acad448e49c8bc62e036f948af610b4e0cbe2a9a28eebc06357f20f67ea"},"provenance":null,"requires-python":null,"size":167370,"upload-time":"2016-05-15T06:37:34.104073Z","url":"https://files.pythonhosted.org/packages/4d/bc/f49882e8935f147b8922fc8bb0f430fe0e7b0d3231a601cd12e1c0272f77/psutil-4.2.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bd4b535996d06728b50bc7cd8777c402bf7294ad05229c843701bd1e63583c2c"},"provenance":null,"requires-python":null,"size":170689,"upload-time":"2016-05-15T06:37:39.395642Z","url":"https://files.pythonhosted.org/packages/7b/e2/2e1078a38189d51409f50af50b598309a2bd84ebe8ca71b79515da915c82/psutil-4.2.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.tar.gz","hashes":{"sha256":"544f013a0aea7199e07e3efe5627f5d4165179a04c66050b234cc3be2eca1ace"},"provenance":null,"requires-python":null,"size":311767,"upload-time":"2016-05-15T06:35:49.367304Z","url":"https://files.pythonhosted.org/packages/a6/bf/5ce23dc9f50de662af3b4bf54812438c298634224924c4e18b7c3b57a2aa/psutil-4.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"1329160e09a86029ef4e07f47dbcc39d511c343257a53acf1af429c537caae57"},"provenance":null,"requires-python":null,"size":406095,"upload-time":"2016-05-15T06:37:44.994723Z","url":"https://files.pythonhosted.org/packages/6b/af/9e43a4a4976f1d1291de8be40c848c591c6e48d7e4053a7b26ad88ba750c/psutil-4.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"12623a1e2e264eac8c899b89d78648e241c12eec754a879453b2e0a4a78b10dd"},"provenance":null,"requires-python":null,"size":404495,"upload-time":"2016-05-15T06:37:50.698273Z","url":"https://files.pythonhosted.org/packages/36/85/64244b1e930aa276205f079ba3e2996e8492bd173af019bbdaee47336a6a/psutil-4.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"66a4a7793dc543a3c7413cda3187e3ced45acf302f95c4d596ebcfc663c01b40"},"provenance":null,"requires-python":null,"size":404456,"upload-time":"2016-05-15T06:37:56.103096Z","url":"https://files.pythonhosted.org/packages/30/fa/a734058699f351ef90b757e0fd8d67a6145c8272bbed85c498276acacd2e/psutil-4.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.5.exe","hashes":{"sha256":"c2b7aa0a99b06967fb76e83e7e9c7153a2d9a5df073986a99a4e9656cfaabe28"},"provenance":null,"requires-python":null,"size":321489,"upload-time":"2016-05-15T06:38:02.113109Z","url":"https://files.pythonhosted.org/packages/a9/1b/c90c802a6db438aeebac412ac3ecf389022f4fd93abef9c0441358f46a71/psutil-4.2.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py2.7.exe","hashes":{"sha256":"856480ce003ecd1601bcb83d97e25bfe79f5b08c430ee9f139a5e768173b06ef"},"provenance":null,"requires-python":null,"size":375917,"upload-time":"2016-05-15T06:38:09.945181Z","url":"https://files.pythonhosted.org/packages/e4/63/267b0977027c8a4a2f98a1ffbc2ecc7c0689d12adabee591a1ac99b4c14e/psutil-4.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.3.exe","hashes":{"sha256":"ab83fefffa495813d36300cd3ad3f232cf7c86a5e5a02d8e8ea7ab7dba5a1a90"},"provenance":null,"requires-python":null,"size":370860,"upload-time":"2016-05-15T06:38:16.360218Z","url":"https://files.pythonhosted.org/packages/c0/96/8197557cbebb16be1cfd3c87f1d0972bd2e5b0733b21d0e5d890541634e8/psutil-4.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.4.exe","hashes":{"sha256":"44c9f0e26b93c2cc9437eb88c31df32bd4337c394a959e0c31bf006da6e0f073"},"provenance":null,"requires-python":null,"size":370872,"upload-time":"2016-05-15T06:38:22.312293Z","url":"https://files.pythonhosted.org/packages/22/c9/01646a50e3c52dda4b591aae411e85afc83952107f9906ec8a5806c9fcc0/psutil-4.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.5.exe","hashes":{"sha256":"c0013a6663b794fbe18284e06d4d553a9e2135b5489a2ac6982ad53641966a55"},"provenance":null,"requires-python":null,"size":311007,"upload-time":"2016-05-15T06:38:28.533757Z","url":"https://files.pythonhosted.org/packages/48/6f/2259000fa07a4efcdc843034810eb2f8675ef5b97845912f2265589483f4/psutil-4.2.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"data-dist-info-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"filename":"psutil-4.3.0-cp27-none-win32.whl","hashes":{"sha256":"99c2ab6c8f0d60e0c86775f8e5844e266af48cc1d9ecd1be209cd407a3e9c9a1"},"provenance":null,"requires-python":null,"size":167400,"upload-time":"2016-06-18T17:56:45.275403Z","url":"https://files.pythonhosted.org/packages/7a/a5/002caeac2ff88526cf0788315bad93be61e66477acd54209fb01cc874745/psutil-4.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"data-dist-info-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"filename":"psutil-4.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"a91474d34bf1bc86a0d95e2c198a70723208f9dc9e50258c2060a1bab3796f81"},"provenance":null,"requires-python":null,"size":169895,"upload-time":"2016-06-18T17:56:51.386191Z","url":"https://files.pythonhosted.org/packages/e1/77/fae92fff4ca7092555c7c8fc6e02c5dfc2a9af7e15762b7354d436adeb06/psutil-4.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp33-cp33m-win32.whl","hashes":{"sha256":"c987f0691c01cbe81813b0c895208c474240c96e26f7d1e945e8dabee5c85437"},"provenance":null,"requires-python":null,"size":167414,"upload-time":"2016-06-18T17:56:57.419709Z","url":"https://files.pythonhosted.org/packages/73/46/224a6a3c05df4e282240826f6bef0bd51da5ca283ffe34ed53f5601fbca1/psutil-4.3.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"233a943d3e6636d648f05515a4d21b4dda63499d8ca38d6890a57a3f78a9cceb"},"provenance":null,"requires-python":null,"size":169791,"upload-time":"2016-06-18T17:57:03.096187Z","url":"https://files.pythonhosted.org/packages/6b/4d/29b3d73c27cd8f348bb313376dd98a2e97cc8a075862cf483dea4c27e4bf/psutil-4.3.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp34-cp34m-win32.whl","hashes":{"sha256":"1893fe42b0fb5f11bf84ffe770be5b2e27fb7ec959ba8bf620b704552b738c72"},"provenance":null,"requires-python":null,"size":167396,"upload-time":"2016-06-18T17:57:09.859528Z","url":"https://files.pythonhosted.org/packages/dc/f5/34070d328a578c38131d96c4fe539ebbabf1c31128012755e344c030bb34/psutil-4.3.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"1345217075dd5bb4fecbf7cb0fe4c0c170e93ec57d48494756f4b617cd21b449"},"provenance":null,"requires-python":null,"size":169759,"upload-time":"2016-06-18T17:57:15.923623Z","url":"https://files.pythonhosted.org/packages/8d/91/7ae0835ae1a4bc1043b565dec9c6468d56c80a4f199472a7d005ddcd48e1/psutil-4.3.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp35-cp35m-win32.whl","hashes":{"sha256":"c9c4274f5f95a171437c90f65c3e9b71a871753f0a827f930e1b14aa43041eab"},"provenance":null,"requires-python":null,"size":169508,"upload-time":"2016-06-18T17:57:21.072109Z","url":"https://files.pythonhosted.org/packages/e4/40/801cd906da337a5e7a0afaaa1ce5919d9834c50d804d31ee4a1d2120a51c/psutil-4.3.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"5984ee7b2880abcdaa0819315f69a5f37da963863495c2294392cb3e98141a95"},"provenance":null,"requires-python":null,"size":172803,"upload-time":"2016-06-18T17:57:26.746663Z","url":"https://files.pythonhosted.org/packages/35/54/ddb6e8e583abf2f5a2be52a2223ba4935b382214b696fe334af54fb03dad/psutil-4.3.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.tar.gz","hashes":{"sha256":"86197ae5978f216d33bfff4383d5cc0b80f079d09cf45a2a406d1abb5d0299f0"},"provenance":null,"requires-python":null,"size":316470,"upload-time":"2016-06-18T17:54:55.929749Z","url":"https://files.pythonhosted.org/packages/22/a8/6ab3f0b3b74a36104785808ec874d24203c6a511ffd2732dd215cf32d689/psutil-4.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"1ad0075b6c86c0ea5076149ec39dcecf0c692711c34317d43d73a4d8c4d4ec30"},"provenance":null,"requires-python":null,"size":408495,"upload-time":"2016-06-18T17:57:33.655137Z","url":"https://files.pythonhosted.org/packages/d5/1f/638b17eab913d19203ebd721c4e5c726b57bc50def33ab1ec0070fe2ddc2/psutil-4.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"02c042e1f6c68c807de5caf45547971cf02977abf4cd92c8961186af9c91c488"},"provenance":null,"requires-python":null,"size":406900,"upload-time":"2016-06-18T17:57:40.580278Z","url":"https://files.pythonhosted.org/packages/a6/9b/94598ec4041ee2834f7ca21c9f1ff67e8f8cef4376ee9d9b9e3ff6950d05/psutil-4.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"2bcfeff969f3718bb31effea752d92511f375547d337687db1bd99ccd85b7ad7"},"provenance":null,"requires-python":null,"size":406871,"upload-time":"2016-06-18T17:57:47.827133Z","url":"https://files.pythonhosted.org/packages/79/2a/abe407e5b594b2a7c0432f5605579d33ce21e0049e3dc2e5c4f37402f760/psutil-4.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"34736b91c9785ede9d859a79e28129390f609339014f904c276ad46d0a440730"},"provenance":null,"requires-python":null,"size":323883,"upload-time":"2016-06-18T17:57:54.043353Z","url":"https://files.pythonhosted.org/packages/14/5e/072b19d913b3fc1f86b871c2869d19db3b5fa50c2e9f4980ae8646e189e0/psutil-4.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py2.7.exe","hashes":{"sha256":"da6ee62fb5ffda188c39aacb0499d401c131046e922ba53fb4b908937e771f94"},"provenance":null,"requires-python":null,"size":378354,"upload-time":"2016-06-18T17:58:00.735354Z","url":"https://files.pythonhosted.org/packages/7e/85/a60111c14eb80aa7a74e1a0086c1a1bbc62282df0c913730e558d16e6a8c/psutil-4.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.3.exe","hashes":{"sha256":"6f36fa29aa9ca935405a3cebe03cfbc6dde27088f9ad3d9b2d3baa47d4b89914"},"provenance":null,"requires-python":null,"size":373297,"upload-time":"2016-06-18T17:58:08.504160Z","url":"https://files.pythonhosted.org/packages/8e/6e/744b98493947a11625a4c63adb9a148c69c2a6e0cf7ef2afd6212804df1d/psutil-4.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.4.exe","hashes":{"sha256":"63b75c5374fafdaf3f389229b592f19b88a8c7951d1b973b9113df649ade5cb9"},"provenance":null,"requires-python":null,"size":373279,"upload-time":"2016-06-18T17:58:15.187200Z","url":"https://files.pythonhosted.org/packages/87/ce/a3cfd0e1b7d34fccff488a6a2283e5b947841465f81960bd87eee5f78828/psutil-4.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.5.exe","hashes":{"sha256":"6d0e1e9bbdab5a7d40b57d8f0841eb9e11c2395ac7ec0ddd396116240d733f46"},"provenance":null,"requires-python":null,"size":313430,"upload-time":"2016-06-18T17:58:22.261628Z","url":"https://files.pythonhosted.org/packages/eb/23/d01e7eccd76a096b0675ab9d07c8fd2de9fd31bc8f4c92f1a150bc612ad4/psutil-4.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"data-dist-info-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"filename":"psutil-4.3.1-cp27-none-win32.whl","hashes":{"sha256":"b0c5bf0d2a29a6f18ac22e2d24210730dca458c9f961914289c9e027ccb5ae43"},"provenance":null,"requires-python":null,"size":168476,"upload-time":"2016-09-02T13:58:43.429910Z","url":"https://files.pythonhosted.org/packages/2d/70/0b24c7272efbb1d8cac1be1768aabfb8ddb37bdc9ab8a176f6afc7e52b0d/psutil-4.3.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"data-dist-info-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"filename":"psutil-4.3.1-cp27-none-win_amd64.whl","hashes":{"sha256":"fc78c29075e623b6ea1c4a1620a120a1534ee05370b76c0ec96f6d161d79e7a1"},"provenance":null,"requires-python":null,"size":170725,"upload-time":"2016-09-02T13:58:47.944701Z","url":"https://files.pythonhosted.org/packages/67/d4/0403e6bd1cf78bd597ac960a3a6ad36cea6c12e3b413c0a1d43361128fb5/psutil-4.3.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp33-cp33m-win32.whl","hashes":{"sha256":"aa05f44a77ef83773af39446f99e461aa3b6edb7fdabeefdcf06e913d8884d3a"},"provenance":null,"requires-python":null,"size":168384,"upload-time":"2016-09-02T13:58:52.479199Z","url":"https://files.pythonhosted.org/packages/9c/ec/5f3f06012c54de3b4443a6948fc75fe1e348ca3de408b00815b5976b8877/psutil-4.3.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"6b3882eb16f2f40f1da6208a051800abadb1f82a675d9ef6ca7386e1a208b1ad"},"provenance":null,"requires-python":null,"size":170566,"upload-time":"2016-09-02T13:58:56.870812Z","url":"https://files.pythonhosted.org/packages/de/c6/74f8b4d460d89811b4c8fd426b63530222456bad767fe372ebb4f5f207be/psutil-4.3.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp34-cp34m-win32.whl","hashes":{"sha256":"cf1be0b16b38f0e2081ff0c81a1a4321c206a824ba6bd51903fdd440abb370b6"},"provenance":null,"requires-python":null,"size":168375,"upload-time":"2016-09-02T13:59:01.079445Z","url":"https://files.pythonhosted.org/packages/75/ff/d02c907869d5e4cc260ce72eb253f5007a7cdf0b47326d19693f8f937eb0/psutil-4.3.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"afa94bed972722882264a4df06176f6b6e6acc6bcebcc3f1db5428c7271dacba"},"provenance":null,"requires-python":null,"size":170529,"upload-time":"2016-09-02T13:59:05.507453Z","url":"https://files.pythonhosted.org/packages/c9/72/07da416b1dcf258a0cb0587c823e3611392fe29b1fcae6e078b1c254dce5/psutil-4.3.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp35-cp35m-win32.whl","hashes":{"sha256":"d2254f518624e6b2262f0f878931faa4bdbe8a77d1f8826564bc4576c6a4f85e"},"provenance":null,"requires-python":null,"size":170124,"upload-time":"2016-09-02T13:59:09.837050Z","url":"https://files.pythonhosted.org/packages/cd/b0/07b7083a134c43b58515d59f271734034f8ba06840b1f371eaa6b3ab85b2/psutil-4.3.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"3b377bc8ba5e62adbc709a90ea07dce2d4addbd6e1cc7acede61ddfa1c66e00a"},"provenance":null,"requires-python":null,"size":173545,"upload-time":"2016-09-02T13:59:14.368908Z","url":"https://files.pythonhosted.org/packages/7e/7e/17c1467158ccac5dc54986a657420fc194686653cfb6feddb6717a60d17f/psutil-4.3.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.tar.gz","hashes":{"sha256":"38f74182fb9e15cafd0cdf0821098a95cc17301807aed25634a18b66537ba51b"},"provenance":null,"requires-python":null,"size":315878,"upload-time":"2016-09-01T20:56:06.777431Z","url":"https://files.pythonhosted.org/packages/78/cc/f267a1371f229bf16db6a4e604428c3b032b823b83155bd33cef45e49a53/psutil-4.3.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py2.7.exe","hashes":{"sha256":"733210f39e95744da26f2256bc36035fc463b0ae88e91496e97486ba21c63cab"},"provenance":null,"requires-python":null,"size":408715,"upload-time":"2016-09-01T21:31:30.452539Z","url":"https://files.pythonhosted.org/packages/57/44/09ec7b6a3fc1216ecc2182a64f8b6c2eaf8dd0d983fb98ecbf9cecbf54b4/psutil-4.3.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.3.exe","hashes":{"sha256":"4690f720054beff4fc66551a6a34512faff328588dca8e2dbed94398b6941112"},"provenance":null,"requires-python":null,"size":407063,"upload-time":"2016-09-01T21:31:37.405818Z","url":"https://files.pythonhosted.org/packages/f2/b5/2921abbf7779d2f7bb210aa819dd2d86ecd004430c59aef9cc52c2d4057b/psutil-4.3.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.4.exe","hashes":{"sha256":"fd9b66edb9f8943eda6b39e7bb9bff8b14aa8d785f5b417d7a0bfa53d4781a7a"},"provenance":null,"requires-python":null,"size":407028,"upload-time":"2016-09-01T21:31:44.758391Z","url":"https://files.pythonhosted.org/packages/91/ea/d5fb1ef4615c0febab3a347ffbc98d50177878546c22b3291892f41de8f4/psutil-4.3.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.5.exe","hashes":{"sha256":"9ab5b62c6571ce545b1c40b9740af81276bd5d94439fd54de07ed59be0ce3f4f"},"provenance":null,"requires-python":null,"size":777648,"upload-time":"2016-09-01T21:31:56.074229Z","url":"https://files.pythonhosted.org/packages/0d/d9/626030b223140d88176b5dda42ea081b843249af11fa71d9e36a465b4b18/psutil-4.3.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py2.7.exe","hashes":{"sha256":"ad8857923e9bc5802d5559ab5d70c1abc1a7be8e74e779adde883c5391e2061c"},"provenance":null,"requires-python":null,"size":378819,"upload-time":"2016-09-01T21:30:59.795815Z","url":"https://files.pythonhosted.org/packages/02/99/2cc2981b30b2b1fb5b393c921ad17e4baaa1f95d7de527fe54ee222e5663/psutil-4.3.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.3.exe","hashes":{"sha256":"ae20b76cddb3391ea37de5d2aaa1656d6373161bbc8fd868a0ca055194a46e45"},"provenance":null,"requires-python":null,"size":373653,"upload-time":"2016-09-01T21:31:06.076800Z","url":"https://files.pythonhosted.org/packages/06/2f/bbcae933425945d2c9ca3e30e2f35728827e87cedad113808d3f527fe2ea/psutil-4.3.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.4.exe","hashes":{"sha256":"0613437cc28b8721de92c582d5baf742dfa6dd824c84b578f8c49a60077e969a"},"provenance":null,"requires-python":null,"size":373650,"upload-time":"2016-09-01T21:31:12.717399Z","url":"https://files.pythonhosted.org/packages/fb/a6/28bca55c499426202341f8224f66fcd69e6577211201b02605be779f44b1/psutil-4.3.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.5.exe","hashes":{"sha256":"c2031732cd0fb7536af491bb8d8119c9263020a52450f9999c884fd49d346b26"},"provenance":null,"requires-python":null,"size":644701,"upload-time":"2016-09-01T21:31:22.237380Z","url":"https://files.pythonhosted.org/packages/f3/c7/f5da6e76f69c97ecfabe684f4d9e179ceaf9f7c1a74d6148480b1a6c41a8/psutil-4.3.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"data-dist-info-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"filename":"psutil-4.4.0-cp27-none-win32.whl","hashes":{"sha256":"4b907a0bed62a76422eae4e1ed8c8eca25fc21e57a31fc080158b8a300e21dad"},"provenance":null,"requires-python":null,"size":172746,"upload-time":"2016-10-23T14:08:37.739179Z","url":"https://files.pythonhosted.org/packages/8b/00/f7203827a3b2576bf8162ea3ba41e39c3307651218ab08e22e1433d8dc36/psutil-4.4.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"data-dist-info-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"filename":"psutil-4.4.0-cp27-none-win_amd64.whl","hashes":{"sha256":"f60ab95f5e65c420743d5dd5285bda2a6bba6712e9380fb9a5903ea539507326"},"provenance":null,"requires-python":null,"size":175102,"upload-time":"2016-10-23T14:08:40.758084Z","url":"https://files.pythonhosted.org/packages/61/5c/d1f89100973829813e485e7bfc2f203e0d11937f958109819b62e8995b51/psutil-4.4.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp33-cp33m-win32.whl","hashes":{"sha256":"d45919d8b900a9ae03f3d43c489323842d4051cf7a728169f01a3889f50d24ad"},"provenance":null,"requires-python":null,"size":172612,"upload-time":"2016-10-23T14:08:44.422307Z","url":"https://files.pythonhosted.org/packages/34/16/ecc7366a7d023731b8b051cff64d3bb4bed2efa4947b125a3c9031e3d799/psutil-4.4.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"df706e4a8533b43c1a083c2c94e816c7a605487db49e5d49fc64329e0147c0f5"},"provenance":null,"requires-python":null,"size":174980,"upload-time":"2016-10-23T14:08:48.077823Z","url":"https://files.pythonhosted.org/packages/f7/17/6fc596007c243a12cf8c9e81b150f1e7a49c7c85c0544771398f257d5608/psutil-4.4.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp34-cp34m-win32.whl","hashes":{"sha256":"d119281d253bbcc44b491b7b7e5c38802f0933179af97ab228cfd8d072ad1503"},"provenance":null,"requires-python":null,"size":172623,"upload-time":"2016-10-23T14:08:50.867277Z","url":"https://files.pythonhosted.org/packages/50/8f/e8fcfb1bacd02c743545d58514004978318d8476c8bffeee9fecfc9f1f79/psutil-4.4.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"ff8a22a40bf884f52cf8dd86872b5199e7ed58eef1575e837d1d9b668fb2416a"},"provenance":null,"requires-python":null,"size":174974,"upload-time":"2016-10-23T14:08:53.576968Z","url":"https://files.pythonhosted.org/packages/41/8f/31f1fb4bb639ccaff2192b0b2a760118a05fb108e156d4966c81a246071b/psutil-4.4.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp35-cp35m-win32.whl","hashes":{"sha256":"7b7c850b3afe6c7895cfd3ee630492c4aabe644a6723a583cd56bac0222d7cd8"},"provenance":null,"requires-python":null,"size":174516,"upload-time":"2016-10-23T14:08:56.521588Z","url":"https://files.pythonhosted.org/packages/18/9e/702b1da450a13448f9d96f2d9e2f69eed901c56adb01e173d8307278c883/psutil-4.4.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"321d09e39bb4641c98544e51fba598f894d09355a18d14367468723632cb149e"},"provenance":null,"requires-python":null,"size":178046,"upload-time":"2016-10-23T14:08:59.346105Z","url":"https://files.pythonhosted.org/packages/8a/87/a22b95d91fb1a07591ebf373d1c286a16037bf2e321577a083156d7f6a13/psutil-4.4.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.tar.gz","hashes":{"sha256":"f4da111f473dbf7e813e6610aec1329000536aea5e7d7e73ed20bc42cfda7ecc"},"provenance":null,"requires-python":null,"size":1831734,"upload-time":"2016-10-23T14:09:04.179623Z","url":"https://files.pythonhosted.org/packages/fc/63/af9c6a4f2ab48293f60ec204cc1336f6f17c1cb782ffb0275982ac08d663/psutil-4.4.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py2.7.exe","hashes":{"sha256":"184132916ceb845f12f7cced3a2cf5273097d314f44be8357bdc435a6dee49cd"},"provenance":null,"requires-python":null,"size":413868,"upload-time":"2016-10-23T14:09:10.236158Z","url":"https://files.pythonhosted.org/packages/98/d9/407ee7d17b4e78c45b92639bfbd9b376b6a6022b0c63965946bfd74af6f4/psutil-4.4.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.3.exe","hashes":{"sha256":"7bb1c69a062aaff4a1773cca6bbe33b261293318d72246b9519357260b67be1e"},"provenance":null,"requires-python":null,"size":412259,"upload-time":"2016-10-23T14:09:15.072697Z","url":"https://files.pythonhosted.org/packages/3f/cc/b31fbc28247722ae7ece86f8911459e29a08f5075e3d4e794cef20f920b2/psutil-4.4.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.4.exe","hashes":{"sha256":"887eca39665d3de362693d66db9c15bf93313cde261de93908452241ee439e56"},"provenance":null,"requires-python":null,"size":412252,"upload-time":"2016-10-23T14:09:19.006281Z","url":"https://files.pythonhosted.org/packages/32/72/88e9e57964144ac3868f817f77e269f987c74fa51e503eb0fe8040523d28/psutil-4.4.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.5.exe","hashes":{"sha256":"a289ed4f7be6c535aa4c59c997baf327788d564881c8bf08fee502fab0cdc7cb"},"provenance":null,"requires-python":null,"size":782926,"upload-time":"2016-10-23T14:09:24.493051Z","url":"https://files.pythonhosted.org/packages/45/09/8908f5931a78c90bf2ef7f91a37a752a13d4017347ac2765d0cbb89e82f6/psutil-4.4.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py2.7.exe","hashes":{"sha256":"8a18d0527ac339f5501f0bd5471040d5fb83052453eedf13106feaf99ddef6cb"},"provenance":null,"requires-python":null,"size":383869,"upload-time":"2016-10-23T14:09:28.382095Z","url":"https://files.pythonhosted.org/packages/4a/eb/a131c438621822833e3131c4998741c3b68fb6ff67786d25e9398439a640/psutil-4.4.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.3.exe","hashes":{"sha256":"8700a0373fd0c95c79ad79bc08e0a7b76cabc0c463658cbe398600c69d57293d"},"provenance":null,"requires-python":null,"size":378663,"upload-time":"2016-10-23T14:09:32.358639Z","url":"https://files.pythonhosted.org/packages/be/c8/fd76b7ba3e1cc61d586c5779d9b0a45d1ad020e1de677eb344d2583bd0f1/psutil-4.4.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.4.exe","hashes":{"sha256":"ddd3f76486a366f1dc7adc8a9e8a285ec24b3b213912b8dce0cbbb629f954b8c"},"provenance":null,"requires-python":null,"size":378674,"upload-time":"2016-10-23T14:09:35.849351Z","url":"https://files.pythonhosted.org/packages/ce/0c/efbe5aefdd136bb3e2fc292b0506761a9b04c215d295be07e11263a90923/psutil-4.4.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.5.exe","hashes":{"sha256":"28963853709f6e0958edd8d6d7469152098680800deb98a759a67745d65b164b"},"provenance":null,"requires-python":null,"size":649869,"upload-time":"2016-10-23T14:09:40.045794Z","url":"https://files.pythonhosted.org/packages/fa/b6/b97b6d4dcbc87b91db9fd2753a0c3b999b734595a97155a38003be475a6d/psutil-4.4.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"data-dist-info-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"filename":"psutil-4.4.1-cp27-none-win32.whl","hashes":{"sha256":"7e77ec1a9c75a858781c1fb46fe81c999e1ae0e711198b4aaf59e5f5bd373b11"},"provenance":null,"requires-python":null,"size":172150,"upload-time":"2016-10-25T15:16:10.656877Z","url":"https://files.pythonhosted.org/packages/a9/aa/ff4e5602420cda42e9ff12949eae95abf7d6838fc79d7892b29af416f4c2/psutil-4.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"data-dist-info-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"filename":"psutil-4.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"0f7f830db35c1baeb0131b2bba458b77f7db98944b2fedafc34922168e467d09"},"provenance":null,"requires-python":null,"size":174507,"upload-time":"2016-10-25T15:16:16.530462Z","url":"https://files.pythonhosted.org/packages/62/e8/c3d3e4161e29bd86d6b06d16456defcb114fd74693b15e5692df9e2b611e/psutil-4.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp33-cp33m-win32.whl","hashes":{"sha256":"fa4ad0533adef033bbcbac5e20d06e77f9aadf5d9c1596317d1b668f94b01b99"},"provenance":null,"requires-python":null,"size":172015,"upload-time":"2016-10-25T15:16:19.320410Z","url":"https://files.pythonhosted.org/packages/2c/da/0428f61f2c5eda7c5053ae35a2d57b097e4eb15e48f9d222319df7f4cbd3/psutil-4.4.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"af337d186b07249b86f00a71b4cf6fcfa1964484fe5fb8a7b623f4559c2859c9"},"provenance":null,"requires-python":null,"size":174384,"upload-time":"2016-10-25T15:16:22.634310Z","url":"https://files.pythonhosted.org/packages/da/ce/d36c39da6d387fbfaea68f382319887315e9201e885ef93c418b89209b31/psutil-4.4.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp34-cp34m-win32.whl","hashes":{"sha256":"4e5cb45c9616dd855c07e538f523c838705ce7c24e021e645cdce4c7894e7209"},"provenance":null,"requires-python":null,"size":172026,"upload-time":"2016-10-25T15:16:28.801885Z","url":"https://files.pythonhosted.org/packages/64/63/49aeca2d1a20f5c5203302a25c825be9262f81d8bf74d7d9e0bf0789b189/psutil-4.4.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"0876646748f3db5e1678a94ae3f68dcef3bd51e82b34f06109e6a28bcddc266c"},"provenance":null,"requires-python":null,"size":174374,"upload-time":"2016-10-25T15:16:32.462229Z","url":"https://files.pythonhosted.org/packages/e0/b2/48a62d3204a714b6354105ed540d54d1e272d5b230bc35eddc14a1494dd1/psutil-4.4.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp35-cp35m-win32.whl","hashes":{"sha256":"e4e9033ef5d775ef8a522750688161241e79c7d4669a05784a0a1a8d37dc8c3c"},"provenance":null,"requires-python":null,"size":173920,"upload-time":"2016-10-25T15:16:38.218083Z","url":"https://files.pythonhosted.org/packages/95/e6/d6bad966efeb674bb3357c94f3e89bbd3477a24f2635c3cadc1d0f2aea76/psutil-4.4.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d8464100c62932eeeacce2be0a1041f68b3bfcc7be261cf9486c11ee98eaedd2"},"provenance":null,"requires-python":null,"size":177448,"upload-time":"2016-10-25T15:16:42.121191Z","url":"https://files.pythonhosted.org/packages/00/58/6845a2a2f6fbbc56a58f0605744368164bf68889299f134684cc1478baf6/psutil-4.4.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.tar.gz","hashes":{"sha256":"9da43dbf7c08f5c2a8e5e2c8792f5c438f52435677b1334e9653d23ea028f4f7"},"provenance":null,"requires-python":null,"size":1831794,"upload-time":"2016-10-25T15:16:47.508715Z","url":"https://files.pythonhosted.org/packages/e5/f3/b816daefa9a6757f867f81903f40849dcf0887f588793236b476e6a30ded/psutil-4.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"23ac3e7b6784751ceeb4338d54b0e683c955cd22b86acbc089696aeb0717ab75"},"provenance":null,"requires-python":null,"size":408863,"upload-time":"2016-10-25T15:16:52.293269Z","url":"https://files.pythonhosted.org/packages/88/93/3c8434bd64a5f89f6b0cc58e1394e88dc3c272f83f1877afac9ede222c63/psutil-4.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"8b97ece77d2dce49dd6adbfc0c9bfb7820be4460d00732bb8cf18b77b9ffb07f"},"provenance":null,"requires-python":null,"size":407253,"upload-time":"2016-10-25T15:16:57.006499Z","url":"https://files.pythonhosted.org/packages/50/21/6b462342ab2f091bed70898894322c107493d69e24a834b9f2ab93a1e876/psutil-4.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"a0b5976a5b5a781754b6cebe89f4e21413b04b7f4005f5713f65257bee29be5f"},"provenance":null,"requires-python":null,"size":407244,"upload-time":"2016-10-25T15:17:01.612657Z","url":"https://files.pythonhosted.org/packages/09/94/a7c3c875884adef49f52c19faff68bfd2b04160a5eb0489dbffa60b5c2dc/psutil-4.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.5.exe","hashes":{"sha256":"b0bfe16b9bd095e56b8ec481328ba64094ccd615ee1f789a12a13cfd7bc5e34a"},"provenance":null,"requires-python":null,"size":777920,"upload-time":"2016-10-25T15:17:05.774786Z","url":"https://files.pythonhosted.org/packages/09/bf/3d850244db8e6aa94116db6787edee352692bbb9647e31c056189e6742cc/psutil-4.4.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py2.7.exe","hashes":{"sha256":"392877b5f86977b4a747fb61968e3b44df62c1d6d87536f021c4979b601c68f5"},"provenance":null,"requires-python":null,"size":378863,"upload-time":"2016-10-25T15:17:10.258103Z","url":"https://files.pythonhosted.org/packages/ed/f9/ed4cc19c84086149067d03de7cfb9f3213cf02d58b6f75c2ac16f85e0baf/psutil-4.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.3.exe","hashes":{"sha256":"a571f179f29215f0aa710ec495573a3522f24e8a8ba0be67d094ad6f593fba05"},"provenance":null,"requires-python":null,"size":373657,"upload-time":"2016-10-25T15:17:17.117641Z","url":"https://files.pythonhosted.org/packages/e6/ad/d8ec058821191334cf17db08c32c0308252d7b3c7490417690061dd12096/psutil-4.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.4.exe","hashes":{"sha256":"c2614dc6194cafd74c147e4b95febe8778430c2ecb91197ad140bf45e3e3ada7"},"provenance":null,"requires-python":null,"size":373668,"upload-time":"2016-10-25T15:17:20.392896Z","url":"https://files.pythonhosted.org/packages/26/15/6d03a2171262a1be565d06c87d584c10daa51e787c7cdd2ff932a433419e/psutil-4.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.5.exe","hashes":{"sha256":"5915da802a1648d0baeeee06b0d1a87eb0e4e20654f65b8428a6f4cc8cd32caf"},"provenance":null,"requires-python":null,"size":644863,"upload-time":"2016-10-25T15:17:24.141533Z","url":"https://files.pythonhosted.org/packages/d1/91/89db11eaa91c1de34d77600c47d657fce7b60e847bcf6457dddfc23b387c/psutil-4.4.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"data-dist-info-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"filename":"psutil-4.4.2-cp27-none-win32.whl","hashes":{"sha256":"15aba78f0262d7839702913f5d2ce1e97c89e31456bb26da1a5f9f7d7fe6d336"},"provenance":null,"requires-python":null,"size":172169,"upload-time":"2016-10-26T11:01:25.916580Z","url":"https://files.pythonhosted.org/packages/d7/da/b7895f01868977c9205bf1c8ff6a88290ec443535084e206b7db7f33918f/psutil-4.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"data-dist-info-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"filename":"psutil-4.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"69e30d789c495b781f7cd47c13ee64452c58abfc7132d6dd1b389af312a78239"},"provenance":null,"requires-python":null,"size":174525,"upload-time":"2016-10-26T11:01:29.001553Z","url":"https://files.pythonhosted.org/packages/0c/76/f50742570195a9a13e26ee3e3e32575a9315df90408056c991af85d23792/psutil-4.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp33-cp33m-win32.whl","hashes":{"sha256":"e44d6b758a96539e3e02336430d3f85263d43c470c5bad93572e9b6a86c67f76"},"provenance":null,"requires-python":null,"size":172034,"upload-time":"2016-10-26T11:01:31.931360Z","url":"https://files.pythonhosted.org/packages/f1/58/64db332e3a665d0d0260fcfe39ff8609871a1203ed11afcff0e5991db724/psutil-4.4.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"c2b0d8d1d8b5669b9884d0dd49ccb4094d163858d672d3d13a3fa817bc8a3197"},"provenance":null,"requires-python":null,"size":174401,"upload-time":"2016-10-26T11:01:35.879864Z","url":"https://files.pythonhosted.org/packages/39/31/4b5a2ab9d20d14fa6c821b7fbbf69ae93708e1a4ba335d4e2ead549b2f59/psutil-4.4.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp34-cp34m-win32.whl","hashes":{"sha256":"10fbb631142a3200623f4ab49f8bf82c32b79b8fe179f6056d01da3dfc589da1"},"provenance":null,"requires-python":null,"size":172044,"upload-time":"2016-10-26T11:01:38.950793Z","url":"https://files.pythonhosted.org/packages/67/f6/f034ad76faa7b9bd24d70a663b5dca8d71b6b7ddb4a3ceecd6a0a63afe92/psutil-4.4.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"e423dd9cb12256c742d1d56ec38bc7d2a7fa09287c82c41e475e68b9f932c2af"},"provenance":null,"requires-python":null,"size":174393,"upload-time":"2016-10-26T11:01:41.933150Z","url":"https://files.pythonhosted.org/packages/f8/f2/df2d8de978236067d0fce847e3734c6e78bfd57df9db5a2786cc544ca85f/psutil-4.4.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp35-cp35m-win32.whl","hashes":{"sha256":"7481f299ae0e966a10cb8dd93a327efd8f51995d9bdc8810dcc65d3b12d856ee"},"provenance":null,"requires-python":null,"size":173938,"upload-time":"2016-10-26T11:01:44.870925Z","url":"https://files.pythonhosted.org/packages/57/2d/0cdc3fdb9853ec1d815e0948104f1c51894f47c8ee2152c019ba754ce678/psutil-4.4.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d96d31d83781c7f3d0df8ccb1cc50650ca84d4722c5070b71ce8f1cc112e02e0"},"provenance":null,"requires-python":null,"size":177465,"upload-time":"2016-10-26T11:01:47.925426Z","url":"https://files.pythonhosted.org/packages/cd/50/3c238d67e025701fa18cc37ed445327efcf14ea4d06e357eef92d1a250bf/psutil-4.4.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.tar.gz","hashes":{"sha256":"1c37e6428f7fe3aeea607f9249986d9bb933bb98133c7919837fd9aac4996b07"},"provenance":null,"requires-python":null,"size":1832052,"upload-time":"2016-10-26T11:01:53.029413Z","url":"https://files.pythonhosted.org/packages/6c/49/0f784a247868e167389f6ac76b8699b2f3d6f4e8e85685dfec43e58d1ed1/psutil-4.4.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py2.7.exe","hashes":{"sha256":"11a20c0328206dce68f8da771461aeaef9c44811e639216fd935837e758632dc"},"provenance":null,"requires-python":null,"size":408884,"upload-time":"2016-10-26T11:01:57.830427Z","url":"https://files.pythonhosted.org/packages/58/bc/ac2a052035e945153f0bdc23d7c169e7e64e0729af6ff96f85d960962def/psutil-4.4.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.3.exe","hashes":{"sha256":"642194ebefa573de62406883eb33868917bab2cc2e21b68d551248e194dd0b0a"},"provenance":null,"requires-python":null,"size":407275,"upload-time":"2016-10-26T11:02:00.968973Z","url":"https://files.pythonhosted.org/packages/38/b3/c8244a4858de5f9525f176d72cb06584433446a5b9d7272d5eec7a435f81/psutil-4.4.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.4.exe","hashes":{"sha256":"c02b9fb5f1f3c857938b26a73b1ca92007e8b0b2fd64693b29300fae0ceaf679"},"provenance":null,"requires-python":null,"size":407267,"upload-time":"2016-10-26T11:02:04.291434Z","url":"https://files.pythonhosted.org/packages/cd/4d/8f447ecba1a3d5cae9f3bdd8395b45e2e6d07834a05fa3ce58c766ffcea6/psutil-4.4.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.5.exe","hashes":{"sha256":"6c40dc16b579f645e1804341322364203d0b21045747e62e360fae843d945e20"},"provenance":null,"requires-python":null,"size":777940,"upload-time":"2016-10-26T11:02:10.124058Z","url":"https://files.pythonhosted.org/packages/73/6e/1c58cbdedcf4e2226f8ca182c947e29f29dba6965fdae0aa8e6a361365ce/psutil-4.4.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py2.7.exe","hashes":{"sha256":"c353ecc62e67bf7c7051c087670d49eae9472f1b30bb1623d667b0cd137e8934"},"provenance":null,"requires-python":null,"size":378885,"upload-time":"2016-10-26T11:02:16.586357Z","url":"https://files.pythonhosted.org/packages/37/27/9eba3e29f8291be103a8e5e44c06eefe5357217e9d8d294ff154dc3bff90/psutil-4.4.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.3.exe","hashes":{"sha256":"7106cb3722235ccb6fe4b18c51f60a548d4b111ec2d209abdcd3998661f4593a"},"provenance":null,"requires-python":null,"size":373678,"upload-time":"2016-10-26T11:02:20.035049Z","url":"https://files.pythonhosted.org/packages/62/25/189e73856fa3172d5e785404eb9cf4561b01094363cc39ec267399e401c4/psutil-4.4.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.4.exe","hashes":{"sha256":"de1f53fe955dfba562f7791f72517935010a2e88f9caad36917e8c5c03de9051"},"provenance":null,"requires-python":null,"size":373689,"upload-time":"2016-10-26T11:02:23.073976Z","url":"https://files.pythonhosted.org/packages/10/4a/e50ca35162538645c4d98816757763e4aaaac1ccaf055b39265acb8739e1/psutil-4.4.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.5.exe","hashes":{"sha256":"2eb123ca86057ed4f31cfc9880e098ee7a8e19c7ec02b068c45e7559ae7539a6"},"provenance":null,"requires-python":null,"size":644886,"upload-time":"2016-10-26T11:02:26.650470Z","url":"https://files.pythonhosted.org/packages/c5/97/018f0580bc3d3d85f1e084e683e904bc33cd58ca96e0ecb5ae6f346d6452/psutil-4.4.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"data-dist-info-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"filename":"psutil-5.0.0-cp27-none-win32.whl","hashes":{"sha256":"cc2560b527cd88a9bc062ee4bd055c40b9fc107e37db01997422c75a3f94efe9"},"provenance":null,"requires-python":null,"size":175039,"upload-time":"2016-11-06T18:28:50.896397Z","url":"https://files.pythonhosted.org/packages/bb/82/efee0c83eab6ad3dd4a70b2b91013a50776ff6253f9b71d825914e693dfa/psutil-5.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"data-dist-info-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"filename":"psutil-5.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"8a6cbc7165a476d08a89ee3078a74d111729cf515fd831db9f635012e56f9759"},"provenance":null,"requires-python":null,"size":177395,"upload-time":"2016-11-06T18:28:54.500906Z","url":"https://files.pythonhosted.org/packages/16/bf/09cb9f5286e5037eba1d5fe347c0f622b325e068757f1072c56f9b130cc3/psutil-5.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp33-cp33m-win32.whl","hashes":{"sha256":"9b0f13e325f007a0fd04e9d44cfdb5187c0b3e144f89533324dd9f74c25bd9ec"},"provenance":null,"requires-python":null,"size":174954,"upload-time":"2016-11-06T18:28:57.539707Z","url":"https://files.pythonhosted.org/packages/a2/5d/82b85eb4c24c82064c5c216f52df92f7861ff0a02d3cbcfebfacadc2b28f/psutil-5.0.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"ade8924028b2c23cc9ffe4a0737de38c668d50be5ce19495790154f530ce5389"},"provenance":null,"requires-python":null,"size":177229,"upload-time":"2016-11-06T18:29:00.558809Z","url":"https://files.pythonhosted.org/packages/14/5b/00b74d0ada625090dfaba6244860a9ec4df2e79a6c8440dd490e46c65543/psutil-5.0.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp34-cp34m-win32.whl","hashes":{"sha256":"af01b73fd66f138e06f804508fd33118823fd2abb89f105ae2b99efa4c8fd1a3"},"provenance":null,"requires-python":null,"size":174957,"upload-time":"2016-11-06T18:29:04.527838Z","url":"https://files.pythonhosted.org/packages/fd/e6/5a08cd23cefadd22b8e74d0bd1c525897c9db4dc1d2f44716dee848b8fe3/psutil-5.0.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"846925435e69cc7b802cd7d1a4bd640e180d0db15277c24e196d3a5799bf6760"},"provenance":null,"requires-python":null,"size":177189,"upload-time":"2016-11-06T18:29:08.003063Z","url":"https://files.pythonhosted.org/packages/b4/11/f68bad0d5fc08800006d2355c941e186315987456158a9b06f40e483d4e7/psutil-5.0.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp35-cp35m-win32.whl","hashes":{"sha256":"d7885ff254425c64bcc2dbff256ec1367515c15218bfda0fd3d799092437d908"},"provenance":null,"requires-python":null,"size":176812,"upload-time":"2016-11-06T18:29:11.700563Z","url":"https://files.pythonhosted.org/packages/c4/16/84213b90c78e437eff09285138947d12105ea982cb6f8fda4ab2855014e6/psutil-5.0.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e35cb38037973ff05bc52dac4f382d17028104d77f0bb51792de93f359046902"},"provenance":null,"requires-python":null,"size":180171,"upload-time":"2016-11-06T18:29:15.915700Z","url":"https://files.pythonhosted.org/packages/98/ef/40582d2d3e39fdcc202a33ba6aab15f6ccb36cdcd04f6756cc9afe30df30/psutil-5.0.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"964e9db2641e3be6a80b5a3135f7a9425f87d8416342b4d967202e4854f3eeba"},"provenance":null,"requires-python":null,"size":411778,"upload-time":"2016-11-06T18:29:32.458135Z","url":"https://files.pythonhosted.org/packages/74/f0/e8964d58e12c7716775157821de2e758fece2581bc9f3b7c333a4de29b90/psutil-5.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"d7b933193322523314b0b2d699a43e43a70f43016f73782dfd892bc7ee95ecd1"},"provenance":null,"requires-python":null,"size":410125,"upload-time":"2016-11-06T18:29:37.513499Z","url":"https://files.pythonhosted.org/packages/6e/a9/4438ec3289e3925a638cb079039b748ee4fb7e3ba18a93baed39f4fcd11e/psutil-5.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"8709a5057d42d5e55f3940bb1e70370316defb3da03ad869342755b5a2c17c78"},"provenance":null,"requires-python":null,"size":410086,"upload-time":"2016-11-06T18:29:41.067409Z","url":"https://files.pythonhosted.org/packages/db/85/c2e27aab6db3c4d404f0e81762f5a962b7213caed0a789cb5df2990ac489/psutil-5.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.5.exe","hashes":{"sha256":"c065eaf76a5423341f511e732f1a17e75a55dc4aceee9a321a619a5892aec18f"},"provenance":null,"requires-python":null,"size":780670,"upload-time":"2016-11-06T18:29:45.597507Z","url":"https://files.pythonhosted.org/packages/27/fd/12a4ef4a9940331a5521216e839444dcab0addd3a49fb90c940bdc40e46e/psutil-5.0.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py2.7.exe","hashes":{"sha256":"8eca28511d493209f59fe99cebfb8ecc65b8d6691f8a80fa3ab50dbb4994c81b"},"provenance":null,"requires-python":null,"size":381779,"upload-time":"2016-11-06T18:29:49.728094Z","url":"https://files.pythonhosted.org/packages/bc/77/457ddeac355fe88c8d4ee8062ce66ab5dd142f5c9423d1bfd10a568c7884/psutil-5.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.3.exe","hashes":{"sha256":"7a8e7654789c468d2a6c32508638563741046f138405fea2a4427a9228ac86f4"},"provenance":null,"requires-python":null,"size":376623,"upload-time":"2016-11-06T18:29:53.256127Z","url":"https://files.pythonhosted.org/packages/8d/1a/2f61de7f89602dfd975f961bf057522ff53ef3bdc48610dbdcf306b542df/psutil-5.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.4.exe","hashes":{"sha256":"4db1f1d8655a63832c9ab85d77c969ab95b740128ca9053b5c108a1e5efe6a7c"},"provenance":null,"requires-python":null,"size":376624,"upload-time":"2016-11-06T18:29:56.669027Z","url":"https://files.pythonhosted.org/packages/c1/3f/d8921d1a8672545a390fd874b77c9a30444b64ab5f8c48e2e9d971f4e98f/psutil-5.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.5.exe","hashes":{"sha256":"10f05841e3bf7b060b3779367b9cd953a6c97303c08a0e2630a9e461ce124412"},"provenance":null,"requires-python":null,"size":647782,"upload-time":"2016-11-06T18:30:00.475783Z","url":"https://files.pythonhosted.org/packages/ec/53/dc7d9e33e77efd26f7c4a9ba8d1e23ba9ce432077e16a55f1f755970e7f7/psutil-5.0.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.zip","hashes":{"sha256":"5411e22c63168220f4b8cc42fd05ea96f5b5e65e08b93b675ca50653aea482f8"},"provenance":null,"requires-python":null,"size":374074,"upload-time":"2016-11-06T18:41:47.892123Z","url":"https://files.pythonhosted.org/packages/93/7f/347309562d30c688299727e65f4d76ef34180c406dfb6f2c7b6c8d746e13/psutil-5.0.0.zip","yanked":false},{"core-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"data-dist-info-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"filename":"psutil-5.0.1-cp27-none-win32.whl","hashes":{"sha256":"1f2379809f2182652fc740faefa511f78b5975e6471e5fa419882dd9e082f245"},"provenance":null,"requires-python":null,"size":176737,"upload-time":"2016-12-21T01:35:18.007609Z","url":"https://files.pythonhosted.org/packages/cd/2d/ecb32ce765c52780768e4078d4d2916bdaa790b313c454f52aebe27d559d/psutil-5.0.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"data-dist-info-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"filename":"psutil-5.0.1-cp27-none-win_amd64.whl","hashes":{"sha256":"86d67da7bfed474b5b0d545b29211f16d622e87c4089de5ea41a3fbcfc4872c7"},"provenance":null,"requires-python":null,"size":179100,"upload-time":"2016-12-21T01:35:20.364405Z","url":"https://files.pythonhosted.org/packages/6b/7e/68835630dcc765452b76b61936f75c1ef71fceae8ebaa7ecb27e42bf3f28/psutil-5.0.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp33-cp33m-win32.whl","hashes":{"sha256":"6a95283fd048810811cf971bec5cec3998e1e62e66237ef7a41a42dd0da29f8c"},"provenance":null,"requires-python":null,"size":176612,"upload-time":"2016-12-21T01:35:22.141278Z","url":"https://files.pythonhosted.org/packages/43/46/3fad73a8c581f63f08fb1f93ef5651e939caa5601a50baca7f2af3c54e2b/psutil-5.0.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"8f492b531c4321c7c43ef82b60421f4bcf5ded4ba4e13f534c064ad6c2d910ed"},"provenance":null,"requires-python":null,"size":178930,"upload-time":"2016-12-21T01:35:23.896324Z","url":"https://files.pythonhosted.org/packages/b0/d0/6d9e39115aaab0d8d52422b909e365938a6dcebe5fa04fac3a6b70398aee/psutil-5.0.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp34-cp34m-win32.whl","hashes":{"sha256":"5cc1b91d4848453b74ad8e63275a19e784ef3acd943c3627134a607b602bc31d"},"provenance":null,"requires-python":null,"size":176623,"upload-time":"2016-12-21T01:35:26.391755Z","url":"https://files.pythonhosted.org/packages/31/21/d836f37c8fde1760e889b0ace67e151c6e56f2ce819b227715a5f291452f/psutil-5.0.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"55874a1814faceaa090b7fa7addbf350603fd7042562adaae13eb6e46d3ec907"},"provenance":null,"requires-python":null,"size":178917,"upload-time":"2016-12-21T01:35:28.280103Z","url":"https://files.pythonhosted.org/packages/a1/9c/cb3f68be56ab366dbf4c901002d281e30c50cf951377ca8155c0ad304394/psutil-5.0.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp35-cp35m-win32.whl","hashes":{"sha256":"7f2d7b97faa524f75736dfde418680eff332f4be66d6217b67d09c630c90d02e"},"provenance":null,"requires-python":null,"size":178514,"upload-time":"2016-12-21T01:35:30.152277Z","url":"https://files.pythonhosted.org/packages/f7/f1/dd823eab436db1eac1ca2c8364918786584db996dc4d2bef5a3b0ebd7619/psutil-5.0.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bf4072d4d188802505b9229ec00e141083c127bb19a6c5636c62b0daabda4bd5"},"provenance":null,"requires-python":null,"size":181835,"upload-time":"2016-12-21T01:35:32.091445Z","url":"https://files.pythonhosted.org/packages/2a/3a/107a964dc66cb4f22af9e919dde846b73c0b4ff735b10ede680895ed296c/psutil-5.0.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp36-cp36m-win32.whl","hashes":{"sha256":"786bbbeb3ea98d82ff5cedc86b640bad97bff435c819f26bddaa388da58d47da"},"provenance":null,"requires-python":null,"size":178650,"upload-time":"2017-01-15T18:27:34.549244Z","url":"https://files.pythonhosted.org/packages/c0/a1/c5d0aa766323b150dce5e51a5360542ccb75c109723d2d95e70d8cb248b8/psutil-5.0.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"544c0803760995fe42a2b7050cfd6ed32379b09ce6cd7a1eaf89c221d8669cc3"},"provenance":null,"requires-python":null,"size":181970,"upload-time":"2017-01-15T18:27:39.376642Z","url":"https://files.pythonhosted.org/packages/c0/e4/bf1059c5dd55abf65fe2ac92a0b24a92d09644a9bbc17f1ad2b497ae9d7d/psutil-5.0.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.tar.gz","hashes":{"sha256":"9d8b7f8353a2b2eb6eb7271d42ec99d0d264a9338a37be46424d56b4e473b39e"},"provenance":null,"requires-python":null,"size":326693,"upload-time":"2016-12-21T01:35:34.145966Z","url":"https://files.pythonhosted.org/packages/d9/c8/8c7a2ab8ec108ba9ab9a4762c5a0d67c283d41b13b5ce46be81fdcae3656/psutil-5.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"0c54e3b7cdc0dbb8a19b58c3eb3845a5f9f48d3be2b06ed9aa1e553db8f9db74"},"provenance":null,"requires-python":null,"size":414521,"upload-time":"2016-12-21T01:35:36.513939Z","url":"https://files.pythonhosted.org/packages/3d/90/61f2860cd2c39a4381e415897b7ff94aab21c9aca38690d0c99c1c83b85f/psutil-5.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"0fccb19631d555998fc8c98840c83678244f873486d20d5f24ebb0ac8e19d2f1"},"provenance":null,"requires-python":null,"size":412871,"upload-time":"2016-12-21T01:35:38.959549Z","url":"https://files.pythonhosted.org/packages/05/f7/6ba6efe79620bcaa9af41e0a8501e477815edccc0cad4bd379a8e8bea89c/psutil-5.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"77fde4936f26080aa14b89d292b3ebefabb80be69ef407352cbad6d2ff6882d4"},"provenance":null,"requires-python":null,"size":412858,"upload-time":"2016-12-21T01:35:42.062765Z","url":"https://files.pythonhosted.org/packages/c7/b3/3b83e69b5d96ed052b45f1fe88882b3976a3a066c0497597d3ce1407f17f/psutil-5.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.5.exe","hashes":{"sha256":"a9125b7bc12127174cf7974444ca2b39a3722f59ead1d985053e7358a3d29acd"},"provenance":null,"requires-python":null,"size":783380,"upload-time":"2016-12-21T01:35:44.660601Z","url":"https://files.pythonhosted.org/packages/4e/cf/d1004fa0617f6d6e39adf48d242f76d5d43ecd497f46add2abb513b6ffcd/psutil-5.0.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.6.exe","hashes":{"sha256":"9a3f1413b24b6751e97e51284761e1778ec0cd0a456595edad6c2f7c115b3368"},"provenance":null,"requires-python":null,"size":783511,"upload-time":"2017-01-15T18:25:42.785800Z","url":"https://files.pythonhosted.org/packages/a0/94/1f29e03230504dafeb128a4c6e381606b038ce5d4dc9b8731632eb6b0928/psutil-5.0.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py2.7.exe","hashes":{"sha256":"671c7b2d3fa8deffb879e9cb6cc00d83d1d990bc81f0c487576b70e811f102bf"},"provenance":null,"requires-python":null,"size":384515,"upload-time":"2016-12-21T01:35:47.208014Z","url":"https://files.pythonhosted.org/packages/2d/7c/85aa8efb36c4fcac4a845b9cfc0744c502620394cdb81db574dd20f7dda0/psutil-5.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.3.exe","hashes":{"sha256":"603bd19426b59762ad55ba5a0b8237282868addf2d0930e21b4dca79fc188787"},"provenance":null,"requires-python":null,"size":379325,"upload-time":"2016-12-21T01:35:49.642792Z","url":"https://files.pythonhosted.org/packages/1c/06/201f913389b920c24153fbfdc07c7a451653b00688d6c2ba92428b9a2c23/psutil-5.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.4.exe","hashes":{"sha256":"08e28b4dba54dd6b0d84718c988239c305e58c7f93160496661955de4f6cfe13"},"provenance":null,"requires-python":null,"size":379338,"upload-time":"2016-12-21T01:35:52.592934Z","url":"https://files.pythonhosted.org/packages/58/27/a42b1d12c201880822fd92588321e489c869f4b72eb906f8f79745bee6cb/psutil-5.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.5.exe","hashes":{"sha256":"1e71dd9aa041a7fa55f3bcc78b578e84f31004e6ce9df97229f05c60529fedb1"},"provenance":null,"requires-python":null,"size":650529,"upload-time":"2016-12-21T01:35:55.051616Z","url":"https://files.pythonhosted.org/packages/fb/c6/c60717f25c8ccfddabd57109d03580d24542eedde8d23a673328876b4137/psutil-5.0.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.6.exe","hashes":{"sha256":"c879310328c0c248331dffeea4adbe691fad7b7095cf9c2ac0a4d78a09cd8a17"},"provenance":null,"requires-python":null,"size":650663,"upload-time":"2017-01-15T18:25:51.768008Z","url":"https://files.pythonhosted.org/packages/00/09/04898f2ce604af89d7ca6866632c05a1fb0fbd7b5ea0c7e84a62570c2678/psutil-5.0.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"data-dist-info-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"filename":"psutil-5.1.0-cp27-cp27m-win32.whl","hashes":{"sha256":"85524e46a1c0c7f5274640809deb96c7cdb5133a0eb805bbed0a1f825c8de77e"},"provenance":null,"requires-python":null,"size":183880,"upload-time":"2017-02-01T18:27:27.314031Z","url":"https://files.pythonhosted.org/packages/d9/bf/eae1c0aa2a5a01456e78d5df4c7cefc512854a24f43103034180ff5ea92f/psutil-5.1.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"data-dist-info-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"filename":"psutil-5.1.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"0a64f395295aafe7c22d6cde81076151bf80f26e180e50c00c1cde5857cad224"},"provenance":null,"requires-python":null,"size":186335,"upload-time":"2017-02-01T18:27:35.043588Z","url":"https://files.pythonhosted.org/packages/f6/5d/67120bb4cea2432d333cdf0ab406336ef62122caacb2379e73a88a9cde82/psutil-5.1.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp33-cp33m-win32.whl","hashes":{"sha256":"bd432606d09722220f8f492223e8b69343d30f21e7ed193712632e4fdcf87af2"},"provenance":null,"requires-python":null,"size":183793,"upload-time":"2017-02-01T18:27:43.056910Z","url":"https://files.pythonhosted.org/packages/26/35/ec223413c9301d8eeecf3d319d71a117dbd2847b628b079f3757d5ec693d/psutil-5.1.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"f98c37506e5abfeb2c857794ccfbce86b376cf6344210ea55f41b0ced5fd8d98"},"provenance":null,"requires-python":null,"size":186185,"upload-time":"2017-02-01T18:27:49.896261Z","url":"https://files.pythonhosted.org/packages/9f/20/bb95f30c99837f3c41a8a595752d9cc1afe595f160d0612eea6e4a905de9/psutil-5.1.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp34-cp34m-win32.whl","hashes":{"sha256":"8760214ce01f71cd6766527396607cf2b3b41e6f8a34aaa9f716090750fd9925"},"provenance":null,"requires-python":null,"size":183803,"upload-time":"2017-02-01T18:27:56.955786Z","url":"https://files.pythonhosted.org/packages/0b/f2/90a7288b36a18fb522e00116f7f5c657df9dba3a12636d2fc9bcef97f524/psutil-5.1.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"2309cf46f5db0a78f52e56e06cbb258fe76d3d54cf8ab9fa067b4c26cd722541"},"provenance":null,"requires-python":null,"size":186156,"upload-time":"2017-02-01T18:28:03.790958Z","url":"https://files.pythonhosted.org/packages/51/c6/3757b2bea37edc9889fe85e2ca9b8a2c47b3b758d35f65704f2a5ac5c13e/psutil-5.1.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp35-cp35m-win32.whl","hashes":{"sha256":"6d89d5f68433afe6755bd26ae3ea4587f395c7613d7be5bc4f0f97b1e299228a"},"provenance":null,"requires-python":null,"size":185696,"upload-time":"2017-02-01T18:28:10.369149Z","url":"https://files.pythonhosted.org/packages/30/9c/322df29c490ceb97d8cbbc663424fad94e900a1921d03cc9c61e36f17444/psutil-5.1.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b3c15965b2dfad34ea79494f82007e71b02e1c5352b551d00647fb2be9deabe1"},"provenance":null,"requires-python":null,"size":189130,"upload-time":"2017-02-01T18:28:17.197543Z","url":"https://files.pythonhosted.org/packages/b3/3a/37d6bf7dedf263e1119b03aaee8565182bf2577ed5ecd7975e253e242bd9/psutil-5.1.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp36-cp36m-win32.whl","hashes":{"sha256":"d32551c242c041b0506d13cfd271db56ba57323283b1f952b858505824f3e82a"},"provenance":null,"requires-python":null,"size":185695,"upload-time":"2017-02-01T18:28:25.059542Z","url":"https://files.pythonhosted.org/packages/42/0b/5ee6feda28c2895b0e8cae4d828d356e13e29bf88bc614065e490bfc8b51/psutil-5.1.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"3b821bb59911afdba5c0c28b1e6e7511cfb0869dd8827c3ab6916ead508c9155"},"provenance":null,"requires-python":null,"size":189127,"upload-time":"2017-02-01T18:28:32.228516Z","url":"https://files.pythonhosted.org/packages/af/6f/ef0799221597f367171c0bb8b3f1b22865e6b7507ee26e1a6a16f408a058/psutil-5.1.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.tar.gz","hashes":{"sha256":"7570e1d82345fab3a0adce24baf993adbca4c87a1be2fa6ee79babdaafa817fb"},"provenance":null,"requires-python":null,"size":339603,"upload-time":"2017-02-01T18:29:04.029583Z","url":"https://files.pythonhosted.org/packages/ba/5f/87b151dd53f8790408adf5096fc81c3061313c36a089d9f7ec9e916da0c1/psutil-5.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"07aab3a12c00315a144b2a61d384364e64077c08c0a79966f18b744d867f9727"},"provenance":null,"requires-python":null,"size":422485,"upload-time":"2017-02-01T18:24:47.444024Z","url":"https://files.pythonhosted.org/packages/8c/1c/8bf1c2f6f2b4f012449bd9781d55397e85e30487c2879ed35569c7f616de/psutil-5.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"b78de627c157b4889e055fd00a635ad0fbe107ae4b3059f419738edbfb15b3f4"},"provenance":null,"requires-python":null,"size":420852,"upload-time":"2017-02-01T18:25:00.582537Z","url":"https://files.pythonhosted.org/packages/de/5a/3041f7d07d9699ef148291721ee167608761e223bc26bbe33483cbe90517/psutil-5.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"48fc3945219f6577b61a76f81fbbaa3ce6bdccf0e87650597c88aac38e63904b"},"provenance":null,"requires-python":null,"size":420825,"upload-time":"2017-02-01T18:25:14.404878Z","url":"https://files.pythonhosted.org/packages/d0/83/4e03c76cd202d4a4ead9b468cf2afa611d689b1ae17e4f152b67c05d2a27/psutil-5.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.5.exe","hashes":{"sha256":"98180376d2f0a3b0d24dbd8ef64da4aac46f98ccc84d2e3ebc3a486b97a75915"},"provenance":null,"requires-python":null,"size":791399,"upload-time":"2017-02-01T18:25:37.374511Z","url":"https://files.pythonhosted.org/packages/ff/86/328005e07308a87f4d86108a51f940fba1fb1c4f60d4676f80fc66a9dd7a/psutil-5.1.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.6.exe","hashes":{"sha256":"a574d3fb56514ae98f2836a218b0dcf6daeb31b9945cec9b7daa9b619ad3005a"},"provenance":null,"requires-python":null,"size":791396,"upload-time":"2017-02-01T18:26:00.310591Z","url":"https://files.pythonhosted.org/packages/83/86/88c20e9ebb1565598401b23ece21367bd059d569cb0ce797509ebdc429be/psutil-5.1.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py2.7.exe","hashes":{"sha256":"b014a8df14f00054762a2ef6f9a449ccde18d9c4de48dc8cb1809343f328f83d"},"provenance":null,"requires-python":null,"size":392388,"upload-time":"2017-02-01T18:26:13.878537Z","url":"https://files.pythonhosted.org/packages/a5/e8/1032177e5af2300b39aa50623e0df4d9a91a9b316803aab8f597e6c855e2/psutil-5.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.3.exe","hashes":{"sha256":"01e68d047f5023d4cb55b3a2653e296d86f53abc7e63e74c8abeefa627d9307f"},"provenance":null,"requires-python":null,"size":387232,"upload-time":"2017-02-01T18:26:25.910876Z","url":"https://files.pythonhosted.org/packages/cc/b8/24bf07e83d063f552132e7808d7029663466ebed945c532ba05068c65ae3/psutil-5.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.4.exe","hashes":{"sha256":"bfd279124512ee1b744eb7efa269be2096e0ce7075204daccd6f4b73c359316c"},"provenance":null,"requires-python":null,"size":387243,"upload-time":"2017-02-01T18:26:38.999172Z","url":"https://files.pythonhosted.org/packages/2a/ad/40d39c8911ca0783df9684649038241913fa3119c74030b9d1a02eb28da3/psutil-5.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.5.exe","hashes":{"sha256":"518356f5384a8996eb4056b6fd01a28bb502476e5d0ab9bd112d8e1dc9ce041a"},"provenance":null,"requires-python":null,"size":658437,"upload-time":"2017-02-01T18:26:58.991042Z","url":"https://files.pythonhosted.org/packages/db/b1/023fa6a995356c4a4ae68ba53e1269d693ad66783ee2c0c4ac1d6e556226/psutil-5.1.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.6.exe","hashes":{"sha256":"23670901cfa4308cc6c442e08efcd93c6a2adb3bfdbbf51d4c120fc2a1595899"},"provenance":null,"requires-python":null,"size":658436,"upload-time":"2017-02-01T18:27:18.934060Z","url":"https://files.pythonhosted.org/packages/f8/ee/be644cdded3a5761f22cd0255534f04ad89a6fabdfb85f58100d25b6bf1a/psutil-5.1.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"data-dist-info-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"filename":"psutil-5.1.1-cp27-none-win32.whl","hashes":{"sha256":"b9cc631c31794f8150a034a15448ecbde6c65ab078437eb01e0a71103bced297"},"provenance":null,"requires-python":null,"size":184444,"upload-time":"2017-02-03T12:00:02.925645Z","url":"https://files.pythonhosted.org/packages/e3/6f/3546783d70949aff150555cafb1cdd51cfddbb2fea042ed3d5b930232233/psutil-5.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"data-dist-info-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"filename":"psutil-5.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"d723be81a8db76ad6d78b04effd33e73813567eb1b1b7669c6926da033cb9774"},"provenance":null,"requires-python":null,"size":186898,"upload-time":"2017-02-03T12:00:10.481992Z","url":"https://files.pythonhosted.org/packages/48/98/9f3277e1d4a6d6fbc501146b9f5e8547c793df038dfa7037816edbf90325/psutil-5.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp33-cp33m-win32.whl","hashes":{"sha256":"5fc6d4fe04f014ea68392d1e7ab7103637b9dcbfd7bf3bc6d9d482177bf82777"},"provenance":null,"requires-python":null,"size":184356,"upload-time":"2017-02-03T12:00:18.015691Z","url":"https://files.pythonhosted.org/packages/98/fa/c43ce8992690d3b674259f21c897dab254b3fbbb2758254787e4b0f5aee8/psutil-5.1.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"7d0c6f77ebeb248ee62383340a8bd5a9b067e64618c9056d701eefdccf27f9f4"},"provenance":null,"requires-python":null,"size":186735,"upload-time":"2017-02-03T12:00:25.248665Z","url":"https://files.pythonhosted.org/packages/e1/4f/7d16da2b82d615a7fc57f159e5e7c8776c7b794ca6330a9318ca93eb735b/psutil-5.1.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp34-cp34m-win32.whl","hashes":{"sha256":"d31859dae480bc1a0be48f239bcf3caa26447fae177549a30c4b1a2a2776f299"},"provenance":null,"requires-python":null,"size":184362,"upload-time":"2017-02-03T12:00:31.866390Z","url":"https://files.pythonhosted.org/packages/bc/a8/3f3e69227217d1e7355e6de1980f357f6151ce1543bd520652b47823f93e/psutil-5.1.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"857a3620b12a33ed4169aee959e1640e7323f18dd7726035cc057e1d39639df2"},"provenance":null,"requires-python":null,"size":186740,"upload-time":"2017-02-03T12:00:39.950524Z","url":"https://files.pythonhosted.org/packages/d3/2c/974ced45441b7adf476f1b32ac3f7840f0d7ae295dd4512de21997e2049b/psutil-5.1.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp35-cp35m-win32.whl","hashes":{"sha256":"4ed11e8caff64c452a2eee8c1bea614b717a8e66e97fc88ce272d98a6499cb9a"},"provenance":null,"requires-python":null,"size":186257,"upload-time":"2017-02-03T12:00:46.799733Z","url":"https://files.pythonhosted.org/packages/2f/17/cb34ac2f50ff6499e6b64837a2d34b92696ff1dc14e57933363d94b7301c/psutil-5.1.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"3115d7acbf3cc81345fd7252946a59c3730f7baba546361a535f0a8f00d862c9"},"provenance":null,"requires-python":null,"size":189715,"upload-time":"2017-02-03T12:00:55.165186Z","url":"https://files.pythonhosted.org/packages/09/da/f9f435d53711859d41ee8a0fb87177e8b30b5dbca5bd06dd05b5c4b46ef3/psutil-5.1.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp36-cp36m-win32.whl","hashes":{"sha256":"9f6cb84d0f8e0c993c91d10ef86c637b7f1c1d4d4ca63ec0a73545cc13e9656a"},"provenance":null,"requires-python":null,"size":186256,"upload-time":"2017-02-03T12:01:01.728292Z","url":"https://files.pythonhosted.org/packages/24/19/20a4a33db5d005959458f68816fbb725791ee7843ba4f8a40dfd38e8e840/psutil-5.1.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"35311e26f7138276fa3e7af86bcb8ecbaee945c3549e690a481379075de386ba"},"provenance":null,"requires-python":null,"size":189711,"upload-time":"2017-02-03T12:01:08.476075Z","url":"https://files.pythonhosted.org/packages/6e/2b/44aea26dc3a304285e8eb91af628c9722ba4e1f44f7969cc24fded4aa744/psutil-5.1.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.tar.gz","hashes":{"sha256":"ece06401d719050a84cca97764ff5b0e41aafe6b6a2ec8a1d0bb89ca5e206d0f"},"provenance":null,"requires-python":null,"size":341006,"upload-time":"2017-02-03T12:01:19.347630Z","url":"https://files.pythonhosted.org/packages/49/ed/2a0b13f890e798b6f1f3625f0e87e5b712471d2c1c625bdcd396d36c56dc/psutil-5.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"e75edc462005475da019f82c8a13b215e2e48db8f284d8be14308b611505d185"},"provenance":null,"requires-python":null,"size":423004,"upload-time":"2017-02-03T12:01:32.247678Z","url":"https://files.pythonhosted.org/packages/99/35/96acf109f463ce31cd29ec327d9b3b1c3eb13afbc5635e54c75e1e22c924/psutil-5.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"e18274b77e61b3774bcf11a4aa368032fe3bbc21e4217ca903c77541fbe00eef"},"provenance":null,"requires-python":null,"size":421360,"upload-time":"2017-02-03T12:01:46.775449Z","url":"https://files.pythonhosted.org/packages/b7/56/70fc2173d34f0ee73215a0e88e2702933cf1549e3ff3d8f2d757b9e1351c/psutil-5.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"76307f8ac94adc87509df43bba28706c27d6c5e4b7429fb658dd5905adae4dc3"},"provenance":null,"requires-python":null,"size":421366,"upload-time":"2017-02-03T12:02:01.021939Z","url":"https://files.pythonhosted.org/packages/f1/9b/961442950e039c65938665dcbe6e72bff1a2dbbd6c6c08c55e3e10db38ed/psutil-5.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.5.exe","hashes":{"sha256":"8101a2b83fa3b93fbf5d5edca7169a4289f34ace2ee25d0f758cec5ae553190f"},"provenance":null,"requires-python":null,"size":791943,"upload-time":"2017-02-03T12:02:23.633303Z","url":"https://files.pythonhosted.org/packages/bb/69/95fdd45b2c1cc4735760b81d826a62433d6726ab6e8e6e2e982fb1264c20/psutil-5.1.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.6.exe","hashes":{"sha256":"b16b48868a58322edd240cf55a0855e1b6fead3e5f02a41b73503d5c47acf330"},"provenance":null,"requires-python":null,"size":791938,"upload-time":"2017-02-03T12:02:48.386069Z","url":"https://files.pythonhosted.org/packages/15/b4/1ba8944aaae568f8f4acd7fd3ca46a95077f07b005774f212226c99a82d8/psutil-5.1.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py2.7.exe","hashes":{"sha256":"12aeeaf5269bc75ed605ffc4979cb95c889989b40d307adf067f04f93f6d3365"},"provenance":null,"requires-python":null,"size":392908,"upload-time":"2017-02-03T12:03:01.259012Z","url":"https://files.pythonhosted.org/packages/d0/38/c274e67564aed7475fba4e0f9eaac3235797226df0b68abce7f3fc96bffa/psutil-5.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.3.exe","hashes":{"sha256":"2f51c669bd528982fc5397d9c84b8b389a56611c111159b1710570db33fc9750"},"provenance":null,"requires-python":null,"size":387752,"upload-time":"2017-02-03T12:03:13.897990Z","url":"https://files.pythonhosted.org/packages/d9/51/52e109c7884a6fa931882081e94dfd0e1b6adb054d4fc82943e1c9b691d2/psutil-5.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.4.exe","hashes":{"sha256":"f68ce5d80db909ee655ac8a322cda3abf47f41c134e7cf61b25565f116fce33f"},"provenance":null,"requires-python":null,"size":387758,"upload-time":"2017-02-03T12:03:26.769319Z","url":"https://files.pythonhosted.org/packages/5e/ee/ff6d626da64a799db055bab9f69ff9a50612a645781d14c24078bca418cb/psutil-5.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.5.exe","hashes":{"sha256":"380aa69aa529e4a4e35579d3e0320617e112473240c95b815d3b421c86e2ab6c"},"provenance":null,"requires-python":null,"size":658955,"upload-time":"2017-02-03T12:03:45.921701Z","url":"https://files.pythonhosted.org/packages/62/9b/847c9c6b1c053a15b44ccf809fce54bbd71e466fd8c1b8eecb0f8bbeb2ce/psutil-5.1.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.6.exe","hashes":{"sha256":"bd3b881faa071a5f6f999d036cfc0d744eed223390fde05ae2a74f0f514f8bd0"},"provenance":null,"requires-python":null,"size":658953,"upload-time":"2017-02-03T12:04:04.770301Z","url":"https://files.pythonhosted.org/packages/80/ef/c23e653bbc1a523217d676fac3ac4050e9fe4d673c84680498c02ff89d23/psutil-5.1.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"data-dist-info-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"filename":"psutil-5.1.2-cp27-none-win32.whl","hashes":{"sha256":"caa870244015bb547eeab7377d9fe41c44319fda6862aa56974108a224c04b1a"},"provenance":null,"requires-python":null,"size":185018,"upload-time":"2017-02-03T19:13:24.939112Z","url":"https://files.pythonhosted.org/packages/57/bc/e0a5e35a9b7f407e229db75b24c46bef012609450d7eac6b5e596a604acb/psutil-5.1.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"data-dist-info-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"filename":"psutil-5.1.2-cp27-none-win_amd64.whl","hashes":{"sha256":"d60d978f5a9b4bc9bb22c5c4bbeb50043db6fb70e3270c08f51e81357f8ca556"},"provenance":null,"requires-python":null,"size":187473,"upload-time":"2017-02-03T19:13:32.487659Z","url":"https://files.pythonhosted.org/packages/84/bd/49681360ca11a1aeba5e48b80b6bd576695a67fe15baca144c6bfcbc9285/psutil-5.1.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp33-cp33m-win32.whl","hashes":{"sha256":"61b9104157df03790fae3b138afb64ad3ecb663669ee3548e609306e0b35ca61"},"provenance":null,"requires-python":null,"size":184928,"upload-time":"2017-02-03T19:13:39.838419Z","url":"https://files.pythonhosted.org/packages/59/c7/7f31631d96ba58e81ad03b4f7cee234a35c67edc44b2fe5936e41e7d1e9e/psutil-5.1.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"11bfc49cd680dec42c9a7200f8b0cc4d89a9d5dbad7f3b027cfac3a305343a2a"},"provenance":null,"requires-python":null,"size":187306,"upload-time":"2017-02-03T19:13:47.199966Z","url":"https://files.pythonhosted.org/packages/a3/dc/0c87a42dbff252ab68263f88e3bd8ffaa02d766e56f743cc9074bb28c0e1/psutil-5.1.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp34-cp34m-win32.whl","hashes":{"sha256":"75b27bac9e91e9868723d8964e73a157799c26190978029b0ef294ad7727d91d"},"provenance":null,"requires-python":null,"size":184936,"upload-time":"2017-02-03T19:13:54.487932Z","url":"https://files.pythonhosted.org/packages/e6/2c/fa2d3770ea68f7f7577bfcf3fc00a2a68760e7d78b8ccb4a323fb44b27fa/psutil-5.1.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"abcfbf43eb47372e961278ee7da9a4757d59999462225b358f49c8e69a393f32"},"provenance":null,"requires-python":null,"size":187315,"upload-time":"2017-02-03T19:14:02.683013Z","url":"https://files.pythonhosted.org/packages/ed/bf/cc8cdbfc7e10518e2e1141e0724623f52bc2f41e7bdd327f8ed63e0edc01/psutil-5.1.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp35-cp35m-win32.whl","hashes":{"sha256":"3fd346acebeb84d9d351cabc02ea1bee1536fb7e165e7e5ead0e0912ce40cbb1"},"provenance":null,"requires-python":null,"size":186829,"upload-time":"2017-02-03T19:14:10.158362Z","url":"https://files.pythonhosted.org/packages/bf/60/e78e3455085393ab4902ef9b1c82e52d89f7b212582c58b76407a7078ad6/psutil-5.1.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"69644ed20c08bd257039733c71a47d871f5bdd481d63f8408e28f03f491e2a03"},"provenance":null,"requires-python":null,"size":190288,"upload-time":"2017-02-03T19:14:17.352480Z","url":"https://files.pythonhosted.org/packages/55/0a/46eba44208248da5aaeadeeab57aac3ee172df8a7291ad5d62efbed566ee/psutil-5.1.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp36-cp36m-win32.whl","hashes":{"sha256":"006ea083c66aa2a2be18bce84e35d0f3301d4ee3c869cb9d475fecce68470a71"},"provenance":null,"requires-python":null,"size":186826,"upload-time":"2017-02-03T19:14:24.235507Z","url":"https://files.pythonhosted.org/packages/26/e4/f5316795a709397e911eca478d547a3bb51b8dca447b7ed62d328cafa570/psutil-5.1.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"b64fa3a1ec7e74689b093ee6b3a487979157f81915677b9145585a2babe1b9f5"},"provenance":null,"requires-python":null,"size":190282,"upload-time":"2017-02-03T19:14:31.621854Z","url":"https://files.pythonhosted.org/packages/c0/e2/2c758b825b48eb9ae30676499a862b8475efdf683952efbb63f531413489/psutil-5.1.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.tar.gz","hashes":{"sha256":"43f32b0a392c80cff0f480bd0792763333e46d7062285dd1226b70473c55e8ac"},"provenance":null,"requires-python":null,"size":341325,"upload-time":"2017-02-03T19:14:42.976980Z","url":"https://files.pythonhosted.org/packages/19/2c/41c601cdd5586f601663d6985ff2cf1c5322f1ffd32d67d3001035d9f81d/psutil-5.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"a44f1735f8464b5cde862d76a78843869da02e1454278a38b1026c9cfa172daf"},"provenance":null,"requires-python":null,"size":423677,"upload-time":"2017-02-03T19:14:56.817144Z","url":"https://files.pythonhosted.org/packages/f2/0e/f26bd5b5e0293f715e18b1de0e46eb3378c8b2a2f54ce67bb48ee47dff44/psutil-5.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.3.exe","hashes":{"sha256":"e8bb29ba0e1526de8932025e07c13f6e26ab43a4cc2861b849ab2daf83ef4c3a"},"provenance":null,"requires-python":null,"size":422033,"upload-time":"2017-02-03T19:15:12.278688Z","url":"https://files.pythonhosted.org/packages/82/d1/e86d5892bfeb5b8439a96b39b2acc892aa54b9df9feb75ef7384673fe883/psutil-5.1.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.4.exe","hashes":{"sha256":"71cd26331eb0c26ba19d5acb67716741666a581f90bce35cc5cb733eb6bbb087"},"provenance":null,"requires-python":null,"size":422041,"upload-time":"2017-02-03T19:15:27.020838Z","url":"https://files.pythonhosted.org/packages/9f/75/f9232734ab6cdf3d656a4ef65fbe5440948c38db910002a4570b01e233d2/psutil-5.1.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.5.exe","hashes":{"sha256":"e3ea19ac2c6e1d54cb3de5919040018af2b5a0d846f7f9dc0cc4e2a125725015"},"provenance":null,"requires-python":null,"size":792618,"upload-time":"2017-02-03T19:15:52.787383Z","url":"https://files.pythonhosted.org/packages/e9/3d/cb2444851956cc4c1fe62bc4b266881e07f16b4be3cdc7b5c1ead5d99b76/psutil-5.1.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.6.exe","hashes":{"sha256":"18ad3e6d3b46dc56eda32674e9da77527bb4ac98503e45c89837fba641a2cc16"},"provenance":null,"requires-python":null,"size":792613,"upload-time":"2017-02-03T19:16:17.350579Z","url":"https://files.pythonhosted.org/packages/36/a5/803a7fdb45924ee69221259184bb2766a1a2819d91e806912f53c6dccc6d/psutil-5.1.2.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py2.7.exe","hashes":{"sha256":"1f8e54923b5d80b880d0dbc2ec5bcf51cbf1db7d54e4d2acdeeb02f42a21735a"},"provenance":null,"requires-python":null,"size":393580,"upload-time":"2017-02-03T19:16:30.238524Z","url":"https://files.pythonhosted.org/packages/b6/89/191e13e1ba569fd143c66fe340e820b909fef8599f78237cc505dd59552b/psutil-5.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.3.exe","hashes":{"sha256":"99a77884670999cf6c589539f1af3af66d8f59d9b8a9697b60398434933f56a8"},"provenance":null,"requires-python":null,"size":388425,"upload-time":"2017-02-03T19:16:43.231178Z","url":"https://files.pythonhosted.org/packages/45/ba/764a926681d90302a54494d59665ea906676b974c2ae0af7b44d5d6d9f24/psutil-5.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.4.exe","hashes":{"sha256":"2a7874d2d2718a4648cfaa4ab731f7de4867230bdcd543bf1c1fda05bc34e068"},"provenance":null,"requires-python":null,"size":388433,"upload-time":"2017-02-03T19:16:58.697184Z","url":"https://files.pythonhosted.org/packages/eb/91/98584bf6f6934c5d02b116634d6e00eddb2ec6b057556d77fdda2fe72ab0/psutil-5.1.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.5.exe","hashes":{"sha256":"42cbf7db0ce76431676da30e792b80e1228857e50afe859518b999125b5da673"},"provenance":null,"requires-python":null,"size":659629,"upload-time":"2017-02-03T19:17:19.107384Z","url":"https://files.pythonhosted.org/packages/80/b9/b17a77e77be75640594fba23837490a1dc425c9d6a9fc0b4997f5bfce984/psutil-5.1.2.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.6.exe","hashes":{"sha256":"cfd6bddd0db750b606454791432023a4260184204f4462b2a4206b7802546ead"},"provenance":null,"requires-python":null,"size":659626,"upload-time":"2017-02-03T19:17:39.500599Z","url":"https://files.pythonhosted.org/packages/8b/bd/af0e5d889818caa35fc8dc5157363c38bdb6fcb7fa1389c5daec24857a63/psutil-5.1.2.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"data-dist-info-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"filename":"psutil-5.1.3-cp27-none-win32.whl","hashes":{"sha256":"359a66879068ce609f8c034b3c575e357a92c033357f398490fc77cf8af46bf7"},"provenance":null,"requires-python":null,"size":185714,"upload-time":"2017-02-07T21:33:17.748014Z","url":"https://files.pythonhosted.org/packages/6f/c0/82c15d73633fdee59b5bd064396038a63a8920359c86460cd01d6ddcedfc/psutil-5.1.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"data-dist-info-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"filename":"psutil-5.1.3-cp27-none-win_amd64.whl","hashes":{"sha256":"a0becbbe09bed44f8f5dc3909c7eb383315f932faeb0029abe8d5c737e8dcc7e"},"provenance":null,"requires-python":null,"size":188166,"upload-time":"2017-02-07T21:33:23.089530Z","url":"https://files.pythonhosted.org/packages/80/92/c5136bbade8ba85d0aa2f5d5cbe8af80bac6ea1ef77c5445aa625a8caefb/psutil-5.1.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp33-cp33m-win32.whl","hashes":{"sha256":"5b2cc379287ded7f9a22521318bf010429234c2864b4146fe518f11729821771"},"provenance":null,"requires-python":null,"size":185622,"upload-time":"2017-02-07T21:33:27.925426Z","url":"https://files.pythonhosted.org/packages/b2/fb/8ad6ff1a9169b35a001ea089ab8657156df1b9b9903e218f1839fba0aae3/psutil-5.1.3-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"d0e88d2e8ac9ede745f589049a74ac1e3e614c4e5eed69e507d58bda8fa3c958"},"provenance":null,"requires-python":null,"size":188003,"upload-time":"2017-02-07T21:33:33.107156Z","url":"https://files.pythonhosted.org/packages/a7/8c/8a8bca010487f008ca026e69e76c53a025905a7bd1759567ec70d85d89a0/psutil-5.1.3-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp34-cp34m-win32.whl","hashes":{"sha256":"72b67b988c0a42825a8ca76000fc385dde85652310278cca807db7dfbcba5e7e"},"provenance":null,"requires-python":null,"size":185627,"upload-time":"2017-02-07T21:33:37.199567Z","url":"https://files.pythonhosted.org/packages/81/69/0ea7d353a82df8d8251842c71131f24b8a5cfa6982f7b89e809c37819c0b/psutil-5.1.3-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"474ab9a6abc05fcd7bb5c32cb828f3f9fc54a2cd349d63c94dff0af3b3ba7e64"},"provenance":null,"requires-python":null,"size":188011,"upload-time":"2017-02-07T21:33:41.528046Z","url":"https://files.pythonhosted.org/packages/93/82/2172e0a319e4c1387898b588e4dc9b8f2283fd9eda0a486ebe03ece2bff7/psutil-5.1.3-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp35-cp35m-win32.whl","hashes":{"sha256":"92bfc1f1929593ab7793ddce512295336e3e788b86a1bbf32701aa67c5ce27f4"},"provenance":null,"requires-python":null,"size":187522,"upload-time":"2017-02-07T21:33:45.934959Z","url":"https://files.pythonhosted.org/packages/43/74/08fc07b34eeb8e357dbe6bca02b844cf76cef15b36098611a50720bf7786/psutil-5.1.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7be50561ed0060c86385c2ef4dd8a383298f29728eb6e30955ae2ebbd4554e1a"},"provenance":null,"requires-python":null,"size":190983,"upload-time":"2017-02-07T21:33:51.074513Z","url":"https://files.pythonhosted.org/packages/fa/42/42e547764bf65617077b696c4c49bed6109b00696882a196008de5f8917b/psutil-5.1.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp36-cp36m-win32.whl","hashes":{"sha256":"4de5566d9d8c3695726f9ec3324cd56d3eb363365508ea39854d2ebe5d57b945"},"provenance":null,"requires-python":null,"size":187516,"upload-time":"2017-02-07T21:33:56.040728Z","url":"https://files.pythonhosted.org/packages/c5/5f/71b89c9dede1da356dbbe321ae410786b94e0b516791191c008864844733/psutil-5.1.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"678ef7b4e38281ff16dbdac98fc1d0679d46fed3fadd5d4648096fbb6d6b1b95"},"provenance":null,"requires-python":null,"size":190979,"upload-time":"2017-02-07T21:34:01.058372Z","url":"https://files.pythonhosted.org/packages/bc/21/1823e2349b1f6ec526a55d21497e5d627ac26a6c5a3d49a07b4afad45547/psutil-5.1.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.tar.gz","hashes":{"sha256":"959bd58bdc8152b0a143cb3bd822d4a1b8f7230617b0e3eb2ff6e63812120f2b"},"provenance":null,"requires-python":null,"size":341980,"upload-time":"2017-02-07T21:34:07.636785Z","url":"https://files.pythonhosted.org/packages/78/0a/aa90434c6337dd50d182a81fe4ae4822c953e166a163d1bf5f06abb1ac0b/psutil-5.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"6c288b7a639f341391ba474d4c8fb495a19220015284b46e7b23f626afafc810"},"provenance":null,"requires-python":null,"size":424369,"upload-time":"2017-02-07T21:34:15.354723Z","url":"https://files.pythonhosted.org/packages/07/bb/aac12b9c56722cf8b6ed0c89eccf1e3db75795576b7e3575001248802c0d/psutil-5.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.3.exe","hashes":{"sha256":"c4b53e0630b83c784f807170ae2d12f1cf1e45e3913f35f9784e5556ba4a0786"},"provenance":null,"requires-python":null,"size":422726,"upload-time":"2017-02-07T21:34:24.113585Z","url":"https://files.pythonhosted.org/packages/1e/5d/4804b1d23e0e8c442876c02438c4f89b3512806b034dea5807ca1ddd6535/psutil-5.1.3.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.4.exe","hashes":{"sha256":"57a4e51a0f2fd8f361fcf545eeff54932a29b716ad01e60247d1abaffbc1b954"},"provenance":null,"requires-python":null,"size":422733,"upload-time":"2017-02-07T21:34:32.211085Z","url":"https://files.pythonhosted.org/packages/51/70/34ea430cf5c21540e30b805f0740d81f75c5766c2f68af9207ae18e147dc/psutil-5.1.3.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.5.exe","hashes":{"sha256":"4b26f56f09ad206d9fb8b2fa29926a696419b26e2c5d461afe477481cec1105c"},"provenance":null,"requires-python":null,"size":793310,"upload-time":"2017-02-07T21:34:46.367507Z","url":"https://files.pythonhosted.org/packages/a2/8c/004fabd6406879fd1caa1ed4ea7ab850afad6e27e3c5b8e8a4d0d134de3e/psutil-5.1.3.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.6.exe","hashes":{"sha256":"94ed102897b8c7103ff51e2b2953caf56bb80c3343523fd3013db3ec91bd8c4b"},"provenance":null,"requires-python":null,"size":793304,"upload-time":"2017-02-07T21:35:00.329688Z","url":"https://files.pythonhosted.org/packages/55/18/6a48a9b9dad56c54236260c1e0e2313497b3af176b053a110ea134b9bb9f/psutil-5.1.3.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py2.7.exe","hashes":{"sha256":"9fcac25e01c0f9f1b6d86c860c6d4da627e458f277f24415f15b1b29cce35f60"},"provenance":null,"requires-python":null,"size":394272,"upload-time":"2017-02-07T21:35:07.791551Z","url":"https://files.pythonhosted.org/packages/33/97/442e6eefe2a12cd00d09721fb24ddf726dd62c1073579a860682919cc640/psutil-5.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.3.exe","hashes":{"sha256":"8349494ee9405a31f4f9d9d3564663c870fed5dd62efd2edfdf64c5841bb838f"},"provenance":null,"requires-python":null,"size":389117,"upload-time":"2017-02-07T21:35:16.679190Z","url":"https://files.pythonhosted.org/packages/ca/46/6d9a5c657298d1363cb37ab0f84eb1fd54639fa4b2729523a68cd6a1b043/psutil-5.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.4.exe","hashes":{"sha256":"c8dc71de8ba61604a5cae5dee5330229dc71538c82ef13458cee838b6c0f6435"},"provenance":null,"requires-python":null,"size":389124,"upload-time":"2017-02-07T21:35:24.590876Z","url":"https://files.pythonhosted.org/packages/5b/c4/7056b6c602ff5be0095fe403617cded940a75a80db49bb51846bc235a0bb/psutil-5.1.3.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.5.exe","hashes":{"sha256":"38c1e88f3a8a548d9caa7f56db1cc7d508eda48eb2c4aa484a908bc5d06f87bd"},"provenance":null,"requires-python":null,"size":660318,"upload-time":"2017-02-07T21:35:36.604103Z","url":"https://files.pythonhosted.org/packages/5f/b3/966c2979172a46f9fe42f34ce7321a59102054e26cdf9b26e3d604807953/psutil-5.1.3.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.6.exe","hashes":{"sha256":"0961ebc2ba4b1c811ef164612d0d963532ad0a9af1755e022a99648a9027b065"},"provenance":null,"requires-python":null,"size":660315,"upload-time":"2017-02-07T21:35:48.440270Z","url":"https://files.pythonhosted.org/packages/be/43/8f0099425146c01c2d77e3ac90b28a7f42d69ccb2af6e161f059db132d99/psutil-5.1.3.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"data-dist-info-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"filename":"psutil-5.2.0-cp27-none-win32.whl","hashes":{"sha256":"6eb2f6fb976152f320ee48a90ab732d694b2ae0c835260ce4f5af3907584448a"},"provenance":null,"requires-python":null,"size":187506,"upload-time":"2017-03-05T04:50:46.045903Z","url":"https://files.pythonhosted.org/packages/d2/56/56a15e285c7cf0104ed9fc569b2c75a24f97e7ab5c34567956b266d23ba3/psutil-5.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"data-dist-info-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"filename":"psutil-5.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"35898b80a3f393a7ace8ad5da9a26800676b7fc40628a3a334902b9d0e444c8d"},"provenance":null,"requires-python":null,"size":189973,"upload-time":"2017-03-05T04:50:49.198757Z","url":"https://files.pythonhosted.org/packages/a5/a5/1039829542b856ca4d3d40bb4978fbb679b7f0bb684ece6340ce655aedc9/psutil-5.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp33-cp33m-win32.whl","hashes":{"sha256":"5626533fc459ce1ac4bd017f7a38b99947c039d79175a10a2a6b6246e3a82fc8"},"provenance":null,"requires-python":null,"size":187442,"upload-time":"2017-03-05T04:50:52.517268Z","url":"https://files.pythonhosted.org/packages/8c/1e/7e6ac521b3c393b2f312f1c3795d702f3267dca23d603827d673b8170920/psutil-5.2.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"d34cc4d48245873492e4befc5c58a146f0f6c98038ffa2430e191a6752717c61"},"provenance":null,"requires-python":null,"size":189849,"upload-time":"2017-03-05T04:50:55.188058Z","url":"https://files.pythonhosted.org/packages/b6/d0/6edd271e3ca150104c818ec0f4b2affc447fe79ec1504506cecb2900d391/psutil-5.2.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp34-cp34m-win32.whl","hashes":{"sha256":"5834168071a92037736142616b33691ec4786f8806e28355e74b2e1a037cad4c"},"provenance":null,"requires-python":null,"size":187450,"upload-time":"2017-03-05T04:50:58.524346Z","url":"https://files.pythonhosted.org/packages/89/88/8fb4ce470a2022c33ab3cd16b3f2152f544e264c9db0f2f7159a93e0d2a3/psutil-5.2.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"d29c24bc7c14ecb4e64b3b748814ebe0e3ac049802ea7f129edbfcb068e75c16"},"provenance":null,"requires-python":null,"size":189841,"upload-time":"2017-03-05T04:51:03.287652Z","url":"https://files.pythonhosted.org/packages/43/9b/35cae8c56d3ee2e9a02599fba6a2e1f3fcf3553fe55f70c0ea723f9a9522/psutil-5.2.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp35-cp35m-win32.whl","hashes":{"sha256":"8353692da46bc6024b4001a9ed8849beb863fbb1d022553dd4ed8348745540bb"},"provenance":null,"requires-python":null,"size":189373,"upload-time":"2017-03-05T04:51:07.095988Z","url":"https://files.pythonhosted.org/packages/65/35/fff62f84dc6c165e8a9f7646e2c106bd223a3967a0a3f471979b38b5a5c0/psutil-5.2.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"1e00f5684fb335dacfa750e5e01f83bb79d521eb5f0805b798de0a29a1fb25d4"},"provenance":null,"requires-python":null,"size":192813,"upload-time":"2017-03-05T04:51:10.595180Z","url":"https://files.pythonhosted.org/packages/94/d2/f78b5a0ded0993f4c5127bf17427e4bc10b183dc102a5e469d7f6725ecb9/psutil-5.2.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp36-cp36m-win32.whl","hashes":{"sha256":"55d546333f1423ad219a0798867a9bbf9a90e1912c3336ad275476473624c071"},"provenance":null,"requires-python":null,"size":189376,"upload-time":"2017-03-05T04:51:15.088897Z","url":"https://files.pythonhosted.org/packages/91/8e/bd4f794b9f092d82a5b63b17da95ebd864f544ff62fb70bb1bce0687b013/psutil-5.2.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"548f14e3e21225884904e3ab228a769a73f886a3394399c591ec5f31fedc48ac"},"provenance":null,"requires-python":null,"size":192808,"upload-time":"2017-03-05T04:51:18.018177Z","url":"https://files.pythonhosted.org/packages/75/65/8499f256dc203b94f8a439f52b092742247668365dcb0997aee7349d530d/psutil-5.2.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.tar.gz","hashes":{"sha256":"2fc91d068faa5613c093335f0e758673ef8c722ad4bfa4aded64c13ae69089eb"},"provenance":null,"requires-python":null,"size":345519,"upload-time":"2017-03-05T04:51:23.230758Z","url":"https://files.pythonhosted.org/packages/3c/2f/f3ab91349c666f009077157b12057e613a3152a46a6c3be883777546b6de/psutil-5.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"7cd5dd38e08d74112c68a8f4e9b9e12fac6c6f6270792604c79a9bbd574053fa"},"provenance":null,"requires-python":null,"size":426460,"upload-time":"2017-03-05T04:51:28.726871Z","url":"https://files.pythonhosted.org/packages/ca/6f/6289db524b6aae542fa36d539524e74f25d7f9296aabadb3b5a9f17746e8/psutil-5.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"e5f1688d9bfd9e122edd35adcd8a0050430397094d08d95c380bd9c7dae48da3"},"provenance":null,"requires-python":null,"size":424854,"upload-time":"2017-03-05T04:51:34.189840Z","url":"https://files.pythonhosted.org/packages/93/7c/e92a80f5803be3febbcb40807d5d2bfe66dfe20b256c07616599c14ba2aa/psutil-5.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"11e684bf163821bd73843ebf9a27b7cb6f8a8325b943954b49b1f622264b6e80"},"provenance":null,"requires-python":null,"size":424846,"upload-time":"2017-03-05T04:51:38.965015Z","url":"https://files.pythonhosted.org/packages/4a/82/5a78b9d40c17dc4d01a06345596ac1e3f7ba590f7329d83e80b817d47f9b/psutil-5.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.5.exe","hashes":{"sha256":"9eeae9bef0875432b9aea9504ed4f7c72f8ee3e8d7ded63e484a453ee82d4a98"},"provenance":null,"requires-python":null,"size":793372,"upload-time":"2017-03-05T04:51:43.517651Z","url":"https://files.pythonhosted.org/packages/dd/f1/4bf05d2b34198954b5fd6455ebe06dd08cae5357354f6f142ef4321e41ab/psutil-5.2.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.6.exe","hashes":{"sha256":"461445afc35f98d4b7781ea2f67d0ca4ae6cf36c065ee0f4be61ace59045a2a5"},"provenance":null,"requires-python":null,"size":795416,"upload-time":"2017-03-05T04:51:53.165366Z","url":"https://files.pythonhosted.org/packages/94/59/c54e7f853586561ae42c9bcf1aa0644e8c0298479e4654b4ca36fa9eafe6/psutil-5.2.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py2.7.exe","hashes":{"sha256":"8bbbd02eb474045d201f6617d16dc8ee1d9903d5cec94f7f39cce610fc1e924b"},"provenance":null,"requires-python":null,"size":396349,"upload-time":"2017-03-05T04:51:59.453206Z","url":"https://files.pythonhosted.org/packages/21/79/40ea4e11ef6ca2b044d0aeb28d829a716a565b34c7786f779e99c005b80a/psutil-5.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.3.exe","hashes":{"sha256":"63d4320b0f3498da3551028a6ab9ee1c5aebabe0d23a7c38600c35333953ef6c"},"provenance":null,"requires-python":null,"size":391219,"upload-time":"2017-03-05T04:52:03.289639Z","url":"https://files.pythonhosted.org/packages/2e/9d/def6a3fb8150adfd71889f3e3d48160a1ba6210911baf12ce3ebd294307c/psutil-5.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.4.exe","hashes":{"sha256":"3c06b0162192db85e04846674a55915fca80f728cf626228a6b31684fc6930da"},"provenance":null,"requires-python":null,"size":391229,"upload-time":"2017-03-05T04:52:10.103932Z","url":"https://files.pythonhosted.org/packages/2c/ae/8616ac1eb00a7770d837b15ebb9ae759c43623c182f32fd43d2e6fed8649/psutil-5.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.5.exe","hashes":{"sha256":"0ba082468d6b45fb15cc1c4488aaf3ffcf0616a674c46393bf04eccc8d7c2196"},"provenance":null,"requires-python":null,"size":660405,"upload-time":"2017-03-05T04:52:18.130601Z","url":"https://files.pythonhosted.org/packages/f7/b6/c8cb94fd6696414a66021aa2229747d71612551eade262e9ab52eeb54ee2/psutil-5.2.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.6.exe","hashes":{"sha256":"6ed1cb1c9339493e1f3c379de0155c543a4c8de18224bda894190843f9509cad"},"provenance":null,"requires-python":null,"size":662455,"upload-time":"2017-03-05T04:52:27.540851Z","url":"https://files.pythonhosted.org/packages/5d/9d/8b552e9d4c2a5c3baa00d1baa1468f2a8128acd3eba79ef39e59c182676a/psutil-5.2.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"data-dist-info-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"filename":"psutil-5.2.1-cp27-none-win32.whl","hashes":{"sha256":"4e236c4ec6b0b20171c2477ded7a5b4402e4a877530640f814df839af0a40e30"},"provenance":null,"requires-python":null,"size":187855,"upload-time":"2017-03-24T15:42:20.835636Z","url":"https://files.pythonhosted.org/packages/3d/14/1242a70873873e92732dc35162317df448503a7a32e29c8bdbe30d4fa175/psutil-5.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"data-dist-info-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"filename":"psutil-5.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"e88fe0d0ca5a9623f0d8d6be05a82e33984f27b067f08806bf8a548ba4361b40"},"provenance":null,"requires-python":null,"size":190301,"upload-time":"2017-03-24T15:42:26.623783Z","url":"https://files.pythonhosted.org/packages/4c/03/fffda9f6e1ca56ce989362969b709bf7a7ade16abf7d82661bbec96580f5/psutil-5.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp33-cp33m-win32.whl","hashes":{"sha256":"54275bdbfbd20909d37ed7a2570cf9dd373ac702a89bac4814249cbc10503c03"},"provenance":null,"requires-python":null,"size":187792,"upload-time":"2017-03-24T15:42:30.952153Z","url":"https://files.pythonhosted.org/packages/d7/e0/4fde7667fad4271c06ed5e533a156bd600cdad1b69d8e6f278fe425452d2/psutil-5.2.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"316c3e334b046dc12b4f0a3dafa1d1c394e38106ac519003694fc8aeb672eafd"},"provenance":null,"requires-python":null,"size":190190,"upload-time":"2017-03-24T15:42:35.956721Z","url":"https://files.pythonhosted.org/packages/a8/c5/63453c20ac576ccb58ee56f88388434380f5e2a729aa08885d2655eb83b7/psutil-5.2.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp34-cp34m-win32.whl","hashes":{"sha256":"2249c687088145dcce87ecb90221258f9c0e7b7cea830886656cf07351e50e1b"},"provenance":null,"requires-python":null,"size":187785,"upload-time":"2017-03-24T15:42:40.746327Z","url":"https://files.pythonhosted.org/packages/59/8b/8ebb86ae5c0ba81e95bae8263de81038d3d7ee8a050f31b2b58f1a330198/psutil-5.2.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"f74532c2037fac87b76737798c74102e17f8594ea9de07aa3cb19027a630bdb0"},"provenance":null,"requires-python":null,"size":190213,"upload-time":"2017-03-24T15:42:45.196850Z","url":"https://files.pythonhosted.org/packages/e7/81/c4dd47453864984d1bd5ad0c387efc11aa6791b5abb5b369ebe2e81f7ada/psutil-5.2.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp35-cp35m-win32.whl","hashes":{"sha256":"c7c8ed864a9ef04d4736a998273e3ba0f95f22300f1e082c13a7c824b514f411"},"provenance":null,"requires-python":null,"size":189737,"upload-time":"2017-03-24T15:42:50.097781Z","url":"https://files.pythonhosted.org/packages/76/3b/2e6b3306dd2927fef9c81fdc29bc450beeb6f4bfe4cddec80260ab042900/psutil-5.2.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7a21b9d908a3bf381cc160c157a06bfcea3c6402362b26a2489566914cea9cc5"},"provenance":null,"requires-python":null,"size":193175,"upload-time":"2017-03-24T15:42:55.344665Z","url":"https://files.pythonhosted.org/packages/de/ee/cf9ecf7cea0a984a360bc889bb0bf11335755d5b7d2be9d8399fe5dc01fb/psutil-5.2.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp36-cp36m-win32.whl","hashes":{"sha256":"d1efbfc743555e7fd366956d8fe39690a3ae87e8e9e9ac06cc80bd7e2ca3059b"},"provenance":null,"requires-python":null,"size":189738,"upload-time":"2017-03-24T15:43:00.448274Z","url":"https://files.pythonhosted.org/packages/15/18/e6b1b4288d885218c845f9a340e236f03352358fc83675b9b8ef96e26227/psutil-5.2.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"cf40e944f47000375320ce0e712585321ec624a0ef67e8259f522e51bcb35a35"},"provenance":null,"requires-python":null,"size":193175,"upload-time":"2017-03-24T15:43:06.043078Z","url":"https://files.pythonhosted.org/packages/e8/7c/240fd3dfcec8d839a9a48dd2f88ba5f6e687263adc8b2452ed973b66b862/psutil-5.2.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.tar.gz","hashes":{"sha256":"fe0ea53b302f68fca1c2a3bac289e11344456786141b73391ed4022b412d5455"},"provenance":null,"requires-python":null,"size":347241,"upload-time":"2017-03-24T15:43:12.551784Z","url":"https://files.pythonhosted.org/packages/b8/47/c85fbcd23f40892db6ecc88782beb6ee66d22008c2f9821d777cb1984240/psutil-5.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"60e9bd558d640eaf9c7a4fbb0627b423b1e58fce95b41b8a24fda9145b753471"},"provenance":null,"requires-python":null,"size":426778,"upload-time":"2017-03-24T15:43:20.982480Z","url":"https://files.pythonhosted.org/packages/88/e8/40e20ea582157c81e55e1765139a5f6e969d8c01e47c016d90946b495531/psutil-5.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"318cf7bf546a23564fe4f049eae0bf205895a0524120bd549de3e46599a7f265"},"provenance":null,"requires-python":null,"size":425186,"upload-time":"2017-03-24T15:43:29.554448Z","url":"https://files.pythonhosted.org/packages/dd/55/2a74e973eb217fa5006c910a24abbd720efb7720beae9659be14fe96a413/psutil-5.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"3bcfbe8b8141c8145f1d54c3f9c2c86597508bb7cc2552e333de770a3c9b9368"},"provenance":null,"requires-python":null,"size":425211,"upload-time":"2017-03-24T15:43:39.017569Z","url":"https://files.pythonhosted.org/packages/9d/12/92575d652d33d28e6f8b0f858f3db326db5ffc4c8d55b09ac411b021d86d/psutil-5.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.5.exe","hashes":{"sha256":"979a5804366b47acd0ebf28923ee645e9fc29f4c54cbc44c41d112a1cd36e9ba"},"provenance":null,"requires-python":null,"size":793725,"upload-time":"2017-03-24T15:43:54.421574Z","url":"https://files.pythonhosted.org/packages/7f/58/de0b10442e2f277de4de0ecfae277576a6bfac1a3137fe547a4085dafa32/psutil-5.2.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.6.exe","hashes":{"sha256":"bf7d2cff21e3262d2b3e33a4b9dc27bbae81e851d694667d68dc7405c67ff31f"},"provenance":null,"requires-python":null,"size":795772,"upload-time":"2017-03-24T15:44:09.051326Z","url":"https://files.pythonhosted.org/packages/33/c0/7094de6644330b8dcdfefb0bae0a00379238588a6cf6cc9cd71c69e0cdce/psutil-5.2.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py2.7.exe","hashes":{"sha256":"ad8b603d7cc6d070cf07d39276869683474dace4da51d8050f29893ac2e22baf"},"provenance":null,"requires-python":null,"size":396688,"upload-time":"2017-03-24T15:44:17.148742Z","url":"https://files.pythonhosted.org/packages/a9/7a/5d19102362c28b6a478f9a7f3262f3ca301f8c5fed12e8d0af9e9e82e6a2/psutil-5.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.3.exe","hashes":{"sha256":"71fbaa3649aa8fa92edb1ad2b45de1e9caa7ffc63f448be951d43d6b5c6263b1"},"provenance":null,"requires-python":null,"size":391560,"upload-time":"2017-03-24T15:44:25.069190Z","url":"https://files.pythonhosted.org/packages/0b/01/f2963d84b439b0802c2354d0f777b5ed4bd0c2c11161ba81e7057a0d0523/psutil-5.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.4.exe","hashes":{"sha256":"cab6e8cfab49511f34e7ae40885792d7e655bb107f6f3c89440d5061cb19ad2f"},"provenance":null,"requires-python":null,"size":391554,"upload-time":"2017-03-24T15:44:33.671369Z","url":"https://files.pythonhosted.org/packages/d5/46/b36ff70ba0ba3b92bb5088be595fdb5641ffd982bac8e206e7c4936b2dc5/psutil-5.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.5.exe","hashes":{"sha256":"0e9e3d74f6ee1a6cac503c0bba08563dc3954e723b8392a4c74ce36f46e119ea"},"provenance":null,"requires-python":null,"size":660759,"upload-time":"2017-03-24T15:44:45.335659Z","url":"https://files.pythonhosted.org/packages/62/81/e7431ad75f9d9ae1524ee886c1aff25ec3714058de6568d305de2e0c8373/psutil-5.2.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.6.exe","hashes":{"sha256":"03e419618c3c715489ca5073cbdac6a0b12da41def69d3e4ee83f18fbb5798e5"},"provenance":null,"requires-python":null,"size":662807,"upload-time":"2017-03-24T15:44:56.446939Z","url":"https://files.pythonhosted.org/packages/77/c8/e256a28a63d06fe028f8837b860b7f6440c6ef9a475fb8c4490e1e08498b/psutil-5.2.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"data-dist-info-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"filename":"psutil-5.2.2-cp27-none-win32.whl","hashes":{"sha256":"db473f0d45a56d422502043f3755385fcfd83f5bb0947bc807fcad689230f37f"},"provenance":null,"requires-python":null,"size":187988,"upload-time":"2017-04-10T17:19:35.132698Z","url":"https://files.pythonhosted.org/packages/9c/31/c651e4c475a4d0df9609024a86fcb358a21b7a01872f7c69c7cf501a2896/psutil-5.2.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"data-dist-info-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"filename":"psutil-5.2.2-cp27-none-win_amd64.whl","hashes":{"sha256":"dcd9d3131f83480648da40d2c39403657c63a81e56e4e8d8e905bf65c133d59c"},"provenance":null,"requires-python":null,"size":190432,"upload-time":"2017-04-10T17:19:39.867178Z","url":"https://files.pythonhosted.org/packages/6e/5c/15f41041a321ffd4058ae67aade067924489acba6d277e10571b59b3127c/psutil-5.2.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp33-cp33m-win32.whl","hashes":{"sha256":"3f79a044db0aae96592ef42be459e37095d0c2cebcae4fd7baf486d37a85a8cd"},"provenance":null,"requires-python":null,"size":187924,"upload-time":"2017-04-10T17:19:44.464637Z","url":"https://files.pythonhosted.org/packages/04/a5/a027a8584208fa2cb6a88e6337b06b11388edf7d39feb0a897c9c2024639/psutil-5.2.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"838c66c123cb024bf8c8d2fec902b38c51f75b27988f4487d81383d1d3d8a8ce"},"provenance":null,"requires-python":null,"size":190325,"upload-time":"2017-04-10T17:19:49.563017Z","url":"https://files.pythonhosted.org/packages/bc/95/385e0f7e0299295401d41dd4cb6e568bf50c884af336b92a69d16981f71c/psutil-5.2.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp34-cp34m-win32.whl","hashes":{"sha256":"a155875d2fedb614c2cd687fe47953d03a47f76eb39bd5756931b288b685655f"},"provenance":null,"requires-python":null,"size":187918,"upload-time":"2017-04-10T17:19:54.252736Z","url":"https://files.pythonhosted.org/packages/12/ad/aca0f4f146b25fb2b7e9e0735287ba3ebcc02eb2bf84d49916aef730d860/psutil-5.2.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"a989876ac0cc7942ef9481b96d3bfc02777dc798d4a7a1b4e8f0f284228f3434"},"provenance":null,"requires-python":null,"size":190345,"upload-time":"2017-04-10T17:19:59.043821Z","url":"https://files.pythonhosted.org/packages/f4/45/6cbf2b7a55375f6aafc68f33581aa143f86ae1be9112546f04d8e9ee34da/psutil-5.2.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp35-cp35m-win32.whl","hashes":{"sha256":"32616c5736f1de446e77865305e7f56905c718991f820c8286436adea8192f32"},"provenance":null,"requires-python":null,"size":189869,"upload-time":"2017-04-10T17:20:03.832890Z","url":"https://files.pythonhosted.org/packages/7b/1d/8cef4ee6c1a49b1204dcdca1231ac773e27f2ed0abbbf42deb14aaf2b5cc/psutil-5.2.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"50c8ddc3a6d1cda1de6d7aaf1af10896832c6d686fc7d0fe3d01c1eb51e6f521"},"provenance":null,"requires-python":null,"size":193304,"upload-time":"2017-04-10T17:20:09.444679Z","url":"https://files.pythonhosted.org/packages/82/f4/9d4cb35c5e1c84f93718d1851adf0b4147b253111cb89f1996a08d14dba5/psutil-5.2.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp36-cp36m-win32.whl","hashes":{"sha256":"e8b65a80e978af9bf10be423442155032c589b7042b4a26edc410dc36819d65e"},"provenance":null,"requires-python":null,"size":189868,"upload-time":"2017-04-10T17:20:16.876191Z","url":"https://files.pythonhosted.org/packages/72/9f/5ff6e45db392bc9dad642dffcca44eeee552289595c087a4f1d245fdb4f9/psutil-5.2.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"7a5c0973bd4c1de98d9b225bd4303a0718d31e31d6e2342e825c3e656f7056df"},"provenance":null,"requires-python":null,"size":193305,"upload-time":"2017-04-10T17:20:21.983057Z","url":"https://files.pythonhosted.org/packages/eb/c6/29c695be774c52cca9bb68b94ae4dc866a42ddf29dcd19b7ab4c0d97bdda/psutil-5.2.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.tar.gz","hashes":{"sha256":"44746540c0fab5b95401520d29eb9ffe84b3b4a235bd1d1971cbe36e1f38dd13"},"provenance":null,"requires-python":null,"size":348413,"upload-time":"2017-04-10T17:20:29.132011Z","url":"https://files.pythonhosted.org/packages/57/93/47a2e3befaf194ccc3d05ffbcba2cdcdd22a231100ef7e4cf63f085c900b/psutil-5.2.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py2.7.exe","hashes":{"sha256":"70732850abd11f4d9fa46f0e110af21030e0a6088204f332d335921b36e66305"},"provenance":null,"requires-python":null,"size":427159,"upload-time":"2017-04-10T17:20:36.896101Z","url":"https://files.pythonhosted.org/packages/56/bb/d03fa2260839abbcdd4d323e83c2e91ffaedcb1975b88d5d0bc71c95c1fb/psutil-5.2.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.3.exe","hashes":{"sha256":"5d2f076788d71d2e1c7276f1e5a1bc255f29c2e80eb8879a9ffc633c5bf69481"},"provenance":null,"requires-python":null,"size":425568,"upload-time":"2017-04-10T17:20:45.676662Z","url":"https://files.pythonhosted.org/packages/79/fd/3d2626e6a9fd4d99859fd8eac7d52ff9850d5e4ea62611a1e3ffe6f3d257/psutil-5.2.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.4.exe","hashes":{"sha256":"fecda42b274dc618278bd9139e8493c9459d2174376f82b65ba929557f10e880"},"provenance":null,"requires-python":null,"size":425592,"upload-time":"2017-04-10T17:20:54.334109Z","url":"https://files.pythonhosted.org/packages/24/56/637ef0dfac83cd3e51096436faf7ea030f780aff3da98a79b7e7ac98a8bb/psutil-5.2.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.5.exe","hashes":{"sha256":"92e3500dfaf7a5502ebaf4a7472e2afb9ff0cb36b4e5dc1977b3c774f58332db"},"provenance":null,"requires-python":null,"size":794103,"upload-time":"2017-04-10T17:21:08.107023Z","url":"https://files.pythonhosted.org/packages/09/4d/9cf34797696c0a75fd76606c362ddfbbc0f87d2c19c95ae26e61120241ad/psutil-5.2.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.6.exe","hashes":{"sha256":"ed09521d49ee177f1205ed9791ad62263feacd2fe1cc20d1d33cf37923f240ea"},"provenance":null,"requires-python":null,"size":796151,"upload-time":"2017-04-10T17:21:22.493104Z","url":"https://files.pythonhosted.org/packages/04/74/5ea4412f31c9652335c03537ff4608ff6a12895fb3a34a187578d693b865/psutil-5.2.2.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py2.7.exe","hashes":{"sha256":"147093b75b8874e55e6b26c540544d40e98845bc4ee74dc6054c881fd2a3eed9"},"provenance":null,"requires-python":null,"size":397069,"upload-time":"2017-04-10T17:21:30.834225Z","url":"https://files.pythonhosted.org/packages/b9/aa/b779310ee8a120b5bb90880d22e7b3869f98f7a30381a71188c6fb7ff4a6/psutil-5.2.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.3.exe","hashes":{"sha256":"3d3c5c117e55c486a53ef796cc715035bf4f56419cc32dbd124fe26e9289ad1e"},"provenance":null,"requires-python":null,"size":391941,"upload-time":"2017-04-10T17:21:38.680258Z","url":"https://files.pythonhosted.org/packages/e0/3f/fd40d4edbfac1d7996b6ecb3bfa5f923662e21686727eb070490ab6dcca8/psutil-5.2.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.4.exe","hashes":{"sha256":"0c74c6a494b650966b88da256cab4e507f483c53e85b9b10d3ff9c38f059330b"},"provenance":null,"requires-python":null,"size":391936,"upload-time":"2017-04-10T17:21:46.576288Z","url":"https://files.pythonhosted.org/packages/c7/59/f7aa53e3f72d6dcfce7c60d80e74853a1444a8a4d7fef788441435c645bf/psutil-5.2.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.5.exe","hashes":{"sha256":"b5583d1c2c858056d39bd148ed25839c4f1b76fec8fb2cb9b564c82997a21266"},"provenance":null,"requires-python":null,"size":661141,"upload-time":"2017-04-10T17:21:57.551743Z","url":"https://files.pythonhosted.org/packages/f2/62/0fc0c5459bcc04171ea3bf5603622db6815ddd92a472db06bcd69612177d/psutil-5.2.2.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.6.exe","hashes":{"sha256":"1da0aa70d66612588d77daed7784e623aac1fd038681c3acd0e1c76b2b2f0819"},"provenance":null,"requires-python":null,"size":663188,"upload-time":"2017-04-10T17:22:09.360293Z","url":"https://files.pythonhosted.org/packages/a0/7f/494b600e45a8a25a76658a45747f232d38538d1c177f5b80123902d2b8da/psutil-5.2.2.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"data-dist-info-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"filename":"psutil-5.3.0-cp27-none-win32.whl","hashes":{"sha256":"6f8f858cdb79397509ee067ae9d25bee8f4b4902453ac8d155fa1629f03aa39d"},"provenance":null,"requires-python":null,"size":210071,"upload-time":"2017-09-01T10:50:37.295614Z","url":"https://files.pythonhosted.org/packages/db/36/71afb537f3718a00a9e63b75e8534bf14fee38b67fb7cb72eb60a3378162/psutil-5.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"data-dist-info-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"filename":"psutil-5.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"b31d6d19e445b56559abaa21703a6bc4b162aaf9ab99867b6f2bbbdb2c7fce66"},"provenance":null,"requires-python":null,"size":212901,"upload-time":"2017-09-01T10:50:41.892260Z","url":"https://files.pythonhosted.org/packages/c8/2b/9bc89bb0d8a2ac49ab29954017e65a9c28b83b13453418c8166938281458/psutil-5.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"data-dist-info-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"filename":"psutil-5.3.0-cp33-cp33m-win32.whl","hashes":{"sha256":"7f1ba5011095e39b3f543e9c87008409dd8a57a3e48ea1022c348244b5af77bf"},"provenance":null,"requires-python":null,"size":209934,"upload-time":"2017-09-01T10:50:46.901965Z","url":"https://files.pythonhosted.org/packages/3c/5b/b020c5f5b6fbe69bfe77072a6d35a6c6d68f7ec7fe8b148223d9365bf8b4/psutil-5.3.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"data-dist-info-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"filename":"psutil-5.3.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"853f68a85cec0137acf0504d8ca6d40d899e48ecbe931130f593a072a35b812e"},"provenance":null,"requires-python":null,"size":212722,"upload-time":"2017-09-01T10:50:51.125180Z","url":"https://files.pythonhosted.org/packages/ad/f8/4d7f713241f1786097faf48afb51e6cb9f7966d2fc36656098e182056704/psutil-5.3.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp34-cp34m-win32.whl","hashes":{"sha256":"01d9cb9473eee0e7e88319f9a5205a69e6e160b3ab2bd430a05b93bfae1528c2"},"provenance":null,"requires-python":null,"size":209879,"upload-time":"2017-09-01T10:50:55.651560Z","url":"https://files.pythonhosted.org/packages/d6/77/01a752e6d05061decf570acc800cd490766ea4534eccbe8c523b84fe5cc1/psutil-5.3.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"91d37262095c1a0f97a78f5034e10e0108e3fa326c85baa17f8cdd63fa5f81b9"},"provenance":null,"requires-python":null,"size":212614,"upload-time":"2017-09-01T10:50:59.871475Z","url":"https://files.pythonhosted.org/packages/0f/cf/fd1d752d428c5845fed4904e7bcdbb89ea3327aa063247fddcdca319c615/psutil-5.3.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp35-cp35m-win32.whl","hashes":{"sha256":"bd1776dc14b197388d728db72c103c0ebec834690ef1ce138035abf0123e2268"},"provenance":null,"requires-python":null,"size":212062,"upload-time":"2017-09-01T10:51:04.687879Z","url":"https://files.pythonhosted.org/packages/68/05/6d097706fd9cb43eda36a02a5feaee085aeac21f5bc6ea0b557109bc2eca/psutil-5.3.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7fadb1b1357ef58821b3f1fc2afb6e1601609b0daa3b55c2fabf765e0ea98901"},"provenance":null,"requires-python":null,"size":215734,"upload-time":"2017-09-01T10:51:09.110127Z","url":"https://files.pythonhosted.org/packages/6e/5a/7c688b472ff5b6cb5413acfa5a178b5e8140ffbdf0011b6d0469e97af3b1/psutil-5.3.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp36-cp36m-win32.whl","hashes":{"sha256":"d5f4634a19e7d4692f37d8d67f8418f85f2bc1e2129914ec0e4208bf7838bf63"},"provenance":null,"requires-python":null,"size":212060,"upload-time":"2017-09-01T10:51:14.595884Z","url":"https://files.pythonhosted.org/packages/28/30/4ab277d7e37cd5ee1c47a89d21465c3eec3435b973ca86cd986efdd0aeac/psutil-5.3.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"31505ee459913ef63fa4c1c0d9a11a4da60b5c5ec6a92d6d7f5d12b9653fc61b"},"provenance":null,"requires-python":null,"size":215731,"upload-time":"2017-09-01T10:51:18.736362Z","url":"https://files.pythonhosted.org/packages/c3/e6/98fd6259d8ed834d9a81567d4f41dd3645e12a9aea9d38563efaf245610a/psutil-5.3.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.tar.gz","hashes":{"sha256":"a3940e06e92c84ab6e82b95dad056241beea93c3c9b1d07ddf96485079855185"},"provenance":null,"requires-python":null,"size":397265,"upload-time":"2017-09-01T12:31:14.428985Z","url":"https://files.pythonhosted.org/packages/1c/da/555e3ad3cad30f30bcf0d539cdeae5c8e7ef9e2a6078af645c70aa81e418/psutil-5.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"ba94f021942d6cc27e18dcdccd2c1a0976f0596765ef412316ecb887d4fd3db2"},"provenance":null,"requires-python":null,"size":450426,"upload-time":"2017-09-01T10:51:26.068723Z","url":"https://files.pythonhosted.org/packages/e3/d6/238a22e898d0a3703d5fd486487108bf57d8fab1137bf085d3602d04894a/psutil-5.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"0f2fccf98bc25e8d6d61e24b2cc6350b8dfe8fa7f5251c817e977d8c61146e5d"},"provenance":null,"requires-python":null,"size":448781,"upload-time":"2017-09-01T10:51:33.193333Z","url":"https://files.pythonhosted.org/packages/91/d6/4ccff87a9f93f4837c97c3eb105c4cd1ccd544091658ba1938feca366b59/psutil-5.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"d06f02c53260d16fb445e426410263b2d271cea19136b1bb715cf10b76960359"},"provenance":null,"requires-python":null,"size":448549,"upload-time":"2017-09-01T10:51:40.339200Z","url":"https://files.pythonhosted.org/packages/74/29/91f18e7798a150c922c7da5c2153edecd7af0292332ef4f46e8ebd7184d3/psutil-5.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"724439fb20d083c943a2c62db1aa240fa15fe23644c4d4a1e9f573ffaf0bbddd"},"provenance":null,"requires-python":null,"size":817222,"upload-time":"2017-09-01T10:51:52.173626Z","url":"https://files.pythonhosted.org/packages/41/fe/5081186ce35c0def7db2f8531ccac908b83edf735c2b8b78241633853b34/psutil-5.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.6.exe","hashes":{"sha256":"a58708f3f6f74897450babb012cd8067f8911e7c8a1f2991643ec9937a8f6c15"},"provenance":null,"requires-python":null,"size":817218,"upload-time":"2017-09-01T10:52:03.695382Z","url":"https://files.pythonhosted.org/packages/aa/49/2076044f5f8554232eb5f8fb69b4a59c8f96da6d107d6f6a35aea2fb0344/psutil-5.3.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py2.7.exe","hashes":{"sha256":"108dae5ecb68f6e6212bf0553be055a2a0eec210227d8e14c3a26368b118624a"},"provenance":null,"requires-python":null,"size":419952,"upload-time":"2017-09-01T10:52:12.411324Z","url":"https://files.pythonhosted.org/packages/d1/18/7e1a418aff3f65c3072eb765b0e51445df6309be3da25c5a4cb9f1d1d18b/psutil-5.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.3.exe","hashes":{"sha256":"9832124af1e9ec0f298f17ab11c3bb91164f8068ec9429c39a7f7a0eae637a94"},"provenance":null,"requires-python":null,"size":414764,"upload-time":"2017-09-01T10:52:32.286415Z","url":"https://files.pythonhosted.org/packages/de/46/0ec33721564e235fab9112fecb836eb084d0475ab97d5a6d5c462656e715/psutil-5.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.4.exe","hashes":{"sha256":"7b8d10e7d72862d1e97caba546b60ce263b3fcecd6176e4c94efebef87ee68d3"},"provenance":null,"requires-python":null,"size":414582,"upload-time":"2017-09-01T10:52:41.243220Z","url":"https://files.pythonhosted.org/packages/86/82/254439b29eea5670633a947ec3f67c5ec33b88322a1a443f121d21dc2714/psutil-5.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.5.exe","hashes":{"sha256":"ed1f7cbbbf778a6ed98e25d48fdbdc098e66b360427661712610d72c1b4cf5f5"},"provenance":null,"requires-python":null,"size":684021,"upload-time":"2017-09-01T10:52:51.603711Z","url":"https://files.pythonhosted.org/packages/20/9c/2d84e2926e1a89c4d1ea8fc315e05145e6b10af79459727ebb688b22dab8/psutil-5.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.6.exe","hashes":{"sha256":"3d8d62f3da0b38dbfaf4756a32e18c866530b9066c298da3fc293cfefae22f0a"},"provenance":null,"requires-python":null,"size":684018,"upload-time":"2017-09-01T10:53:02.878374Z","url":"https://files.pythonhosted.org/packages/61/c7/bbcc29ba03d59f1add008245edf0d56d45434b137dde0c0d6b8441ae3be6/psutil-5.3.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"data-dist-info-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"filename":"psutil-5.3.1-cp27-none-win32.whl","hashes":{"sha256":"7a669b1897b8cdce1cea79defdf3a10fd6e4f0a8e42ac2a971dfe74bc1ce5679"},"provenance":null,"requires-python":null,"size":210168,"upload-time":"2017-09-10T05:26:42.273181Z","url":"https://files.pythonhosted.org/packages/34/90/145ff234428b4bd519c20d460d6d51db7820e8120879ca9cdc88602c57f4/psutil-5.3.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"data-dist-info-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"filename":"psutil-5.3.1-cp27-none-win_amd64.whl","hashes":{"sha256":"57be53c045f2085e28d5371eedfce804f5e49e7b35fa79bcf63e271046058002"},"provenance":null,"requires-python":null,"size":212998,"upload-time":"2017-09-10T05:27:13.646528Z","url":"https://files.pythonhosted.org/packages/c8/c9/d8cbfc3844e1a3e8b648fcca317ad8589283a7cbbc232c2c5d29cae88352/psutil-5.3.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"data-dist-info-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"filename":"psutil-5.3.1-cp33-cp33m-win32.whl","hashes":{"sha256":"27d4c5ff3ab97389a9372d246e1aa27e5f02e4709fede48a0599f89d2873ca88"},"provenance":null,"requires-python":null,"size":210025,"upload-time":"2017-09-10T05:27:19.363106Z","url":"https://files.pythonhosted.org/packages/c4/82/7e412884fcf9ae538b1d96e31688b804377803e34f4e3e86bba869eaa9f7/psutil-5.3.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"data-dist-info-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"filename":"psutil-5.3.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"72ba7e4c82879b3781ccced1eeb901f07725a36fab66270e7555e484a460760d"},"provenance":null,"requires-python":null,"size":212814,"upload-time":"2017-09-10T05:27:24.067035Z","url":"https://files.pythonhosted.org/packages/8a/1b/e185f211c9a959739c6789872458b78f6424466819afc5c420af09b222af/psutil-5.3.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp34-cp34m-win32.whl","hashes":{"sha256":"fc11c3a52990ec44064cbe026338dedcfff0e0027ca7516416eaa7d4f206c5af"},"provenance":null,"requires-python":null,"size":209976,"upload-time":"2017-09-10T05:27:29.519738Z","url":"https://files.pythonhosted.org/packages/ae/a9/ba609de04d2350878c6c3d641997dd37fa362775bf79aca3e6d542aae89e/psutil-5.3.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"7b1f9856c2fc9503a8a687db85e4f419ad1a10bfcab92ba786a7d43a6aa8cea0"},"provenance":null,"requires-python":null,"size":212710,"upload-time":"2017-09-10T05:27:34.832459Z","url":"https://files.pythonhosted.org/packages/9e/4e/e35f4e9b3f5dfb8eb88be75ccbc6e6a6428443afa4d641ff5e9e29a8991f/psutil-5.3.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp35-cp35m-win32.whl","hashes":{"sha256":"54781e463d9b9aa8c143033ee0d6a3149f9f143e6cc63099a95d4078f433dd56"},"provenance":null,"requires-python":null,"size":212159,"upload-time":"2017-09-10T05:27:39.270103Z","url":"https://files.pythonhosted.org/packages/79/4b/4531d21a7e428f3f25dc1b05be7e2024d9c2d45845ba005193dd9420e6b7/psutil-5.3.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e9ef8d265298268cad784dfece103ab06bd726512d57fc6ed9f94b55452e4571"},"provenance":null,"requires-python":null,"size":215831,"upload-time":"2017-09-10T05:27:43.869238Z","url":"https://files.pythonhosted.org/packages/aa/a7/1bc0baaea0798c1b29bfb6cec05f18f6a4cbaaf96646818429d998feb2f5/psutil-5.3.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp36-cp36m-win32.whl","hashes":{"sha256":"f5d55618cd5b9270355fb52c0430ff30c4c84c5caf5b1254eec27f80d48e7a12"},"provenance":null,"requires-python":null,"size":212160,"upload-time":"2017-09-10T05:27:51.405015Z","url":"https://files.pythonhosted.org/packages/ba/03/1946dc720fec2083148b1d7b579e789bde85cebad67b22e05d5189871114/psutil-5.3.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"773ba33fe365cb8b0998eedcbe494dc92ce7428998f07dca652a1360a9e2bce8"},"provenance":null,"requires-python":null,"size":215831,"upload-time":"2017-09-10T05:27:56.438641Z","url":"https://files.pythonhosted.org/packages/9b/de/5bd7038f8bb68516eedafc8bba9daf6740011db8afc1bb25cdcc8d654771/psutil-5.3.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.1.tar.gz","hashes":{"sha256":"12dd9c8abbad15f055e9579130035b38617020ce176f4a498b7870e6321ffa67"},"provenance":null,"requires-python":null,"size":397075,"upload-time":"2017-09-10T05:28:34.436466Z","url":"https://files.pythonhosted.org/packages/d3/0a/74dcbb162554909b208e5dbe9f4e7278d78cc27470993e05177005e627d0/psutil-5.3.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"data-dist-info-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"filename":"psutil-5.4.0-cp27-none-win32.whl","hashes":{"sha256":"8121039d2280275ac82f99a0a48110450cbf5b356a11c842c8f5cdeafdf105e1"},"provenance":null,"requires-python":null,"size":218177,"upload-time":"2017-10-12T07:26:59.429237Z","url":"https://files.pythonhosted.org/packages/4c/89/08a536124b4ee1fd850982f59ab7268a359e4160a6bcc1d473f6971fbdd4/psutil-5.4.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"data-dist-info-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"filename":"psutil-5.4.0-cp27-none-win_amd64.whl","hashes":{"sha256":"fcd93acb2602d01b86e0cfa4c2db689a81badae98d9c572348c94f1b2ea4b30d"},"provenance":null,"requires-python":null,"size":220988,"upload-time":"2017-10-12T07:27:04.404602Z","url":"https://files.pythonhosted.org/packages/c9/3d/0cd95044d1245166ddf24144e1b3e7a6b6a81933de3ff48c1851664109fc/psutil-5.4.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"data-dist-info-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"filename":"psutil-5.4.0-cp33-cp33m-win32.whl","hashes":{"sha256":"60a58bfdda1fc6e86ecf95c6eef71252d9049694df9aa0a16c2841a425fc9deb"},"provenance":null,"requires-python":null,"size":218040,"upload-time":"2017-10-12T07:27:13.087638Z","url":"https://files.pythonhosted.org/packages/e5/1a/0f27898ad585d924e768b0c7029c7d7ac429994a3a032419c51f1c1f3e41/psutil-5.4.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"data-dist-info-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"filename":"psutil-5.4.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"9956b370243005d5561a94efa44b0cddb826d1f14d21958003925b008d3b9eb1"},"provenance":null,"requires-python":null,"size":220796,"upload-time":"2017-10-12T07:27:19.356245Z","url":"https://files.pythonhosted.org/packages/19/8e/b42236e04fbd03ffa2a08a393c8800fd7d51b11823c0e18723f0780d9b6a/psutil-5.4.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp34-cp34m-win32.whl","hashes":{"sha256":"104fec73d9ed573351f3efbf1b7ee19eb3b4097e2b3d9ff26b1ac5bca52b6f9e"},"provenance":null,"requires-python":null,"size":217969,"upload-time":"2017-10-12T07:27:24.486998Z","url":"https://files.pythonhosted.org/packages/11/42/0711b59b7f2f2f7de7912d30bc599950011d25401bda8a3330f878ff1e56/psutil-5.4.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"64b2814b30452d854d5f7a7c9c0d77423388b44eb2a8bcab3b84feeceaba8ffb"},"provenance":null,"requires-python":null,"size":220696,"upload-time":"2017-10-12T07:27:29.623184Z","url":"https://files.pythonhosted.org/packages/e6/67/e19ccc78646810cbc432c429e2993315cf50a126379b83b0f8b3eb9172b9/psutil-5.4.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp35-cp35m-win32.whl","hashes":{"sha256":"1a89ba967d4b9a3d5f19ea2c63b09e5ffb3a81de3116ead7bfb67b9c308e8dba"},"provenance":null,"requires-python":null,"size":220150,"upload-time":"2017-10-12T07:27:34.351564Z","url":"https://files.pythonhosted.org/packages/cc/c1/47edb3fccbb1354499297702ca55aec41ff7aab67b4df69aba9db4e52a7c/psutil-5.4.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c8362902d4d94640c61960c18d8aa1af074822a549c3d4f137be3aa62c17f4b9"},"provenance":null,"requires-python":null,"size":223827,"upload-time":"2017-10-12T07:27:46.430105Z","url":"https://files.pythonhosted.org/packages/a9/e4/d399d060bbf40c1480ce2bfbc429edbd42769b048c4c7fdc51a49d74c9cf/psutil-5.4.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp36-cp36m-win32.whl","hashes":{"sha256":"04ed7548dfe61ab2561a94ac848a5b79239bb23e9015596ffd0644efd22461ba"},"provenance":null,"requires-python":null,"size":220151,"upload-time":"2017-10-12T07:27:51.153048Z","url":"https://files.pythonhosted.org/packages/2b/46/88fdd6206f01b04547bb89a6d2ff7eec380e5c59bda56ee03a0759ed397c/psutil-5.4.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"346555603ea903a5524bb37a49b0e0f90960c6c9973ebf794ae0802a4aa875eb"},"provenance":null,"requires-python":null,"size":223825,"upload-time":"2017-10-12T07:27:57.513929Z","url":"https://files.pythonhosted.org/packages/34/e2/8421ca5b99209fa43e48d2f76a21d5d86d7346838053abf7a4d2aa37255e/psutil-5.4.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.0.tar.gz","hashes":{"sha256":"8e6397ec24a2ec09751447d9f169486b68b37ac7a8d794dca003ace4efaafc6a"},"provenance":null,"requires-python":null,"size":406945,"upload-time":"2017-10-12T07:22:51.321681Z","url":"https://files.pythonhosted.org/packages/8d/96/1fc6468be91521192861966c40bd73fdf8b065eae6d82dd0f870b9825a65/psutil-5.4.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"data-dist-info-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"filename":"psutil-5.4.1-cp27-none-win32.whl","hashes":{"sha256":"7ef26ebe728ac821de17df23820e6ffcfd37c409fc865380e4d5ae1388f274a1"},"provenance":null,"requires-python":null,"size":218627,"upload-time":"2017-11-08T13:50:32.260924Z","url":"https://files.pythonhosted.org/packages/dd/dd/1811a99faefd2b5947b4e68bd70767b525fdbad65481a4bd2ee7e6408749/psutil-5.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"data-dist-info-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"filename":"psutil-5.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"692dc72817d157aae522231dd334ea2524c6b07d844db0e7a2d6897820083427"},"provenance":null,"requires-python":null,"size":221450,"upload-time":"2017-11-08T13:50:37.542045Z","url":"https://files.pythonhosted.org/packages/51/c1/eec6a42a9f5fcd564c3fe3c6435c2c00e4e951a37f3ea3d324b04503ca6f/psutil-5.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp34-cp34m-win32.whl","hashes":{"sha256":"92342777d46e4630cf17d437412dc7fce0a8561217e074d36a35eb911ffd570e"},"provenance":null,"requires-python":null,"size":218421,"upload-time":"2017-11-08T13:50:42.728570Z","url":"https://files.pythonhosted.org/packages/e1/bd/d34935cd39f893d6e9ed46df5245aa71b29d2408b98f23755f234d517f80/psutil-5.4.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"f8f2f47a987c32ed3ca2068f3dfa9060dc9ff6cbed023d627d3f27060f4e59c4"},"provenance":null,"requires-python":null,"size":221144,"upload-time":"2017-11-08T13:50:47.928399Z","url":"https://files.pythonhosted.org/packages/24/ae/dcb7394e75b23b71f46742ffdab21d864a7ae74124b7930e5ea4f47b9049/psutil-5.4.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp35-cp35m-win32.whl","hashes":{"sha256":"1fce45549618d1930afefe322834ba91758331725bfdaec73ba6abcc83f6dc11"},"provenance":null,"requires-python":null,"size":220611,"upload-time":"2017-11-08T13:50:52.754745Z","url":"https://files.pythonhosted.org/packages/e8/58/c60fbf66c58d1e4b18902d601a294cb6ee993f3d051b44fdf397b6166852/psutil-5.4.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f8a88553b2b5916f3bd814a91942215822a1dabae6db033cbb019095d6a24bc2"},"provenance":null,"requires-python":null,"size":224288,"upload-time":"2017-11-08T13:50:58.405900Z","url":"https://files.pythonhosted.org/packages/4f/f8/0e4e80114bc58267199c932f9227d09a00dea952b37400f76aa2a3bb9492/psutil-5.4.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp36-cp36m-win32.whl","hashes":{"sha256":"4139f76baa59142b907dd581d7ff3506a5163cb8ef69e8e92060df330bbf5788"},"provenance":null,"requires-python":null,"size":220610,"upload-time":"2017-11-08T13:51:03.361290Z","url":"https://files.pythonhosted.org/packages/8e/16/02eb53ea087776d9f219973e7b52c7d729929a2727c15894842f9b3629e6/psutil-5.4.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d61bc04401ce938576e4c6ec201e812ed4114bfb9712202b87003619116c90c6"},"provenance":null,"requires-python":null,"size":224287,"upload-time":"2017-11-08T13:51:07.991086Z","url":"https://files.pythonhosted.org/packages/4a/89/0610a20ab3d1546fbe288001fb79ec4818ef6de29f89259c39daea85984f/psutil-5.4.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.1.tar.gz","hashes":{"sha256":"42e2de159e3c987435cb3b47d6f37035db190a1499f3af714ba7af5c379b6ba2"},"provenance":null,"requires-python":null,"size":408489,"upload-time":"2017-11-08T13:51:15.716367Z","url":"https://files.pythonhosted.org/packages/fe/17/0f0bf5792b2dfe6003efc5175c76225f7d3426f88e2bf8d360cfab870cd8/psutil-5.4.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"data-dist-info-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"filename":"psutil-5.4.2-cp27-none-win32.whl","hashes":{"sha256":"2fbbc7dce43c5240b9dc6d56302d57412f1c5a0d665d1f04eb05a6b7279f4e9b"},"provenance":null,"requires-python":null,"size":221114,"upload-time":"2017-12-07T12:03:17.419322Z","url":"https://files.pythonhosted.org/packages/e6/e2/09d55a6e899cf1a7b6a22d0cc2a75d45553df5b63d7c9f2eb2553c7207bc/psutil-5.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"data-dist-info-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"filename":"psutil-5.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"259ec8578d19643179eb2377348c63b650b51ba40f58f2620a3d9732b8a0b557"},"provenance":null,"requires-python":null,"size":223996,"upload-time":"2017-12-07T12:03:22.758210Z","url":"https://files.pythonhosted.org/packages/47/fc/e2199322f422e4bb6e25808a335132235fb0f3fabb0ea71ec3442719fdaf/psutil-5.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp34-cp34m-win32.whl","hashes":{"sha256":"d3808be8241433db17fa955566c3b8be61dac8ba8f221dcbb202a9daba918db5"},"provenance":null,"requires-python":null,"size":220935,"upload-time":"2017-12-07T12:03:27.058880Z","url":"https://files.pythonhosted.org/packages/d5/50/044ad4b47bf0e992a11ae7cb060e8c7dd52eb6983c2c4b6fdd5314fcc3b2/psutil-5.4.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"449747f638c221f8ce6ca3548aefef13339aa05b453cc1f233f4d6c31c206198"},"provenance":null,"requires-python":null,"size":223749,"upload-time":"2017-12-07T12:03:31.671187Z","url":"https://files.pythonhosted.org/packages/b5/77/6f8b4c7c6e9e8fa60b0e0627853ba7182f1a2459ad0b557fe3257bbe014b/psutil-5.4.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp35-cp35m-win32.whl","hashes":{"sha256":"f6c2d54abd59ed8691882de7fd6b248f5808a567885f20f50b3b4b9eedaebb1f"},"provenance":null,"requires-python":null,"size":223260,"upload-time":"2017-12-07T12:03:36.139696Z","url":"https://files.pythonhosted.org/packages/ad/fa/ac5b6bc2b25817509fc2e44f910f39b3385d1575262f7802b9c113ab786a/psutil-5.4.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e3d00d8fc3d4217f05d07af45390f072c04cb7c7dddd70b86b728e5fbe485c81"},"provenance":null,"requires-python":null,"size":226950,"upload-time":"2017-12-07T12:03:40.889125Z","url":"https://files.pythonhosted.org/packages/0e/5c/67b33328d4f307608006c3630838b272719125b36e5456a4dd8f4e76eca9/psutil-5.4.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp36-cp36m-win32.whl","hashes":{"sha256":"3473d6abad9d6ec7b8a97f4dc55f0b3483ecf470d85f08f5e23c1c07592b914f"},"provenance":null,"requires-python":null,"size":223259,"upload-time":"2017-12-07T12:03:45.502272Z","url":"https://files.pythonhosted.org/packages/59/75/97862069d3fa20f1f2897fecd5b6822a3c06ee2af1161f1beb320cc4f5f8/psutil-5.4.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"7dc6c3bbb5d28487f791f195d6abfdef295d34c44ce6cb5f2d178613fb3338ab"},"provenance":null,"requires-python":null,"size":226952,"upload-time":"2017-12-07T12:03:51.257182Z","url":"https://files.pythonhosted.org/packages/8f/9a/5dea138e49addd68d8e65d08103dd28428f1ea0b8d4e8beef9b24f069a16/psutil-5.4.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.2.tar.gz","hashes":{"sha256":"00a1f9ff8d1e035fba7bfdd6977fa8ea7937afdb4477339e5df3dba78194fe11"},"provenance":null,"requires-python":null,"size":411888,"upload-time":"2017-12-07T12:03:58.583601Z","url":"https://files.pythonhosted.org/packages/54/24/aa854703715fa161110daa001afce75d21d1840e9ab5eb28708d6a5058b0/psutil-5.4.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"data-dist-info-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"filename":"psutil-5.4.3-cp27-none-win32.whl","hashes":{"sha256":"82a06785db8eeb637b349006cc28a92e40cd190fefae9875246d18d0de7ccac8"},"provenance":null,"requires-python":null,"size":220984,"upload-time":"2018-01-01T20:33:16.515515Z","url":"https://files.pythonhosted.org/packages/e5/cc/6dd427e738a8db6d0b66525856da43d2ef12c4c19269863927f7cf0e2aaf/psutil-5.4.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"data-dist-info-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"filename":"psutil-5.4.3-cp27-none-win_amd64.whl","hashes":{"sha256":"4152ae231709e3e8b80e26b6da20dc965a1a589959c48af1ed024eca6473f60d"},"provenance":null,"requires-python":null,"size":223871,"upload-time":"2018-01-01T20:33:24.887595Z","url":"https://files.pythonhosted.org/packages/b9/e4/6867765edcab8d12a52c84c9b0af492ecb99f8cc565ad552341bcf73ebd9/psutil-5.4.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp34-cp34m-win32.whl","hashes":{"sha256":"230eeb3aeb077814f3a2cd036ddb6e0f571960d327298cc914c02385c3e02a63"},"provenance":null,"requires-python":null,"size":220823,"upload-time":"2018-01-01T20:33:31.019909Z","url":"https://files.pythonhosted.org/packages/5b/fc/745a864190a4221cdb984e666f4218e98d9a53a64b4dcf2eb7a71c1bf693/psutil-5.4.3-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"a3286556d4d2f341108db65d8e20d0cd3fcb9a91741cb5eb496832d7daf2a97c"},"provenance":null,"requires-python":null,"size":223605,"upload-time":"2018-01-01T20:33:38.392793Z","url":"https://files.pythonhosted.org/packages/b0/25/414738d5e8e75418e560a36651d1e1b09c9df05440a2a808d999a5548b1e/psutil-5.4.3-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp35-cp35m-win32.whl","hashes":{"sha256":"94d4e63189f2593960e73acaaf96be235dd8a455fe2bcb37d8ad6f0e87f61556"},"provenance":null,"requires-python":null,"size":223167,"upload-time":"2018-01-01T20:33:43.796884Z","url":"https://files.pythonhosted.org/packages/e9/80/8da216f42050220f37f7133d2accfcd001a1bd0f31d7cdb8660acb46b8fe/psutil-5.4.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c91eee73eea00df5e62c741b380b7e5b6fdd553891bee5669817a3a38d036f13"},"provenance":null,"requires-python":null,"size":226810,"upload-time":"2018-01-01T20:33:50.884798Z","url":"https://files.pythonhosted.org/packages/23/34/b3de39502c2c34899f9e7ae3c8d1050c9317997ab1fe6c647e7a789571a8/psutil-5.4.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp36-cp36m-win32.whl","hashes":{"sha256":"779ec7e7621758ca11a8d99a1064996454b3570154277cc21342a01148a49c28"},"provenance":null,"requires-python":null,"size":223168,"upload-time":"2018-01-01T20:33:56.458784Z","url":"https://files.pythonhosted.org/packages/da/c1/caadba7c64f72118b02f019c60ad85a5668ddf0a32836230b71692b0cbfa/psutil-5.4.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"8a15d773203a1277e57b1d11a7ccdf70804744ef4a9518a87ab8436995c31a4b"},"provenance":null,"requires-python":null,"size":226804,"upload-time":"2018-01-01T20:34:03.130620Z","url":"https://files.pythonhosted.org/packages/71/80/90799d3dc6e33e650ee03f96fa18157faed885593eabea3a6560ebff7de0/psutil-5.4.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.3.tar.gz","hashes":{"sha256":"e2467e9312c2fa191687b89ff4bc2ad8843be4af6fb4dc95a7cc5f7d7a327b18"},"provenance":null,"requires-python":null,"size":412550,"upload-time":"2018-01-01T20:34:13.285899Z","url":"https://files.pythonhosted.org/packages/e2/e1/600326635f97fee89bf8426fef14c5c29f4849c79f68fd79f433d8c1bd96/psutil-5.4.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"data-dist-info-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"filename":"psutil-5.4.4-cp27-none-win32.whl","hashes":{"sha256":"8f208867d41eb3b6de416df098a9a28d08d40b432467d821b8ef5bb589a394ce"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216647,"upload-time":"2018-04-13T09:10:24.220147Z","url":"https://files.pythonhosted.org/packages/e8/cd/dbf537e32de1c9f06a0069bf0ef13c8707f653e9af2b0ea0ed7040b73083/psutil-5.4.4-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"data-dist-info-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"filename":"psutil-5.4.4-cp27-none-win_amd64.whl","hashes":{"sha256":"77b5e310de17085346ef2c4c21b64d5e39616ab4559b8ef6fea9f6f2ab0de66f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219668,"upload-time":"2018-04-13T09:10:29.328807Z","url":"https://files.pythonhosted.org/packages/7f/37/538bb4275d8a26ec369944878a681000e827e72cab9b4f27f4b1b5932446/psutil-5.4.4-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp34-cp34m-win32.whl","hashes":{"sha256":"fec0e59dacbe91db7e063f038301f49da7e9361732fc31d28338ecaa4719520e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216642,"upload-time":"2018-04-13T09:10:33.842941Z","url":"https://files.pythonhosted.org/packages/92/e9/c9c4ec1a0ac55ee1514c1a249d017dd2f7a89e727d236ed6862b493de154/psutil-5.4.4-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"1268fb6959cd8d761c30e13e79908ae73ba5a69c3c3a5d09a7a27278446f9800"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219513,"upload-time":"2018-04-13T09:10:38.041575Z","url":"https://files.pythonhosted.org/packages/83/49/c903f446d28bfb6e92fa08b710f68cd5d17cc2ccfc4a13fe607f8b20f6dd/psutil-5.4.4-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp35-cp35m-win32.whl","hashes":{"sha256":"7eb2d80ef79d90474a03eead13b32e541d1fdeb47468cf04c881f0a7392ddbc5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219220,"upload-time":"2018-04-13T09:10:42.685382Z","url":"https://files.pythonhosted.org/packages/bb/63/c9b3e9ff8d23409896a7e9e7356a730fdfb5a45a1edc0e6d4ca5ce655f29/psutil-5.4.4-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"69f1db4d13f362ce11a6246b20c752c31b87a6fd77452170fd03c26a8a20a4f2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222757,"upload-time":"2018-04-13T09:10:47.950981Z","url":"https://files.pythonhosted.org/packages/72/22/a5ce34af1285679e02d7fd701ff6389f579a17e623dd89236ea1873ce12b/psutil-5.4.4-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp36-cp36m-win32.whl","hashes":{"sha256":"6eb59bcfd48eade8889bae67a16e0d8c7b18af0732ba64dead61206fd7cb4e45"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219224,"upload-time":"2018-04-13T09:10:52.291473Z","url":"https://files.pythonhosted.org/packages/3c/6d/5e9a3683d4532997525aa20d1d9ce0ca1201271d30aad9e5f18c34459478/psutil-5.4.4-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"a4af5d4fcf6022886a30fb3b4fff71ff25f645865a68506680d43a3e634764af"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222759,"upload-time":"2018-04-13T09:10:56.584621Z","url":"https://files.pythonhosted.org/packages/b6/61/eeeab30fa737b8b95b790d3eb8f49ebedeb783e43aef2d8d851687592d6c/psutil-5.4.4-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.4.tar.gz","hashes":{"sha256":"5959e33e0fc69742dd22e88bfc7789a1f2e1fc2297794b543119e10cdac8dfb1"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":417890,"upload-time":"2018-04-13T09:11:03.199870Z","url":"https://files.pythonhosted.org/packages/35/35/7da482448cd9ee3555faa9c5e541e37b18a849fb961e55d6fda6ca936ddb/psutil-5.4.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"data-dist-info-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"filename":"psutil-5.4.5-cp27-none-win32.whl","hashes":{"sha256":"33384065f0014351fa70187548e3e95952c4df4bc5c38648bd0e647d21eaaf01"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216630,"upload-time":"2018-04-13T17:59:43.195295Z","url":"https://files.pythonhosted.org/packages/63/9f/529a599db3057602114a30aa5e3641e78bce6c6e195adb75309c9286cb88/psutil-5.4.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"data-dist-info-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"filename":"psutil-5.4.5-cp27-none-win_amd64.whl","hashes":{"sha256":"f24cd52bafa06917935fe1b68c5a45593abe1f3097dc35b2dfc4718236795890"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219650,"upload-time":"2018-04-13T17:59:53.389911Z","url":"https://files.pythonhosted.org/packages/b6/ca/2d23b37e9b30908174d2cb596f60f06b3858856a2e595c931f7d4d640c03/psutil-5.4.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp34-cp34m-win32.whl","hashes":{"sha256":"99029b6af386b22882f0b6d537ffed5a9c3d5ff31782974aeaa1d683262d8543"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216589,"upload-time":"2018-04-13T18:00:04.166075Z","url":"https://files.pythonhosted.org/packages/bf/bc/f687dfa4679aad782fb78c43fed2626cb0157567a5b06790997e5aa0f166/psutil-5.4.5-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"51e12aa74509832443862373a2655052b20c83cad7322f49d217452500b9a405"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219462,"upload-time":"2018-04-13T18:00:14.637120Z","url":"https://files.pythonhosted.org/packages/32/b5/545953316dd9cb053e4c7d4f70d88aba5362dbbe58422ca6bbec1bbf8956/psutil-5.4.5-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp35-cp35m-win32.whl","hashes":{"sha256":"325c334596ad2d8a178d0e7b4eecc91748096a87489b3701ee16986173000aaa"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219172,"upload-time":"2018-04-13T18:00:28.230677Z","url":"https://files.pythonhosted.org/packages/00/ed/fdf2930c41e76e3a8bc59bf998062ee5ad0c393170a7d2c273dd3b259794/psutil-5.4.5-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"52a91ba928a5e86e0249b4932d6e36972a72d1ad8dcc5b7f753a2ae14825a4ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222706,"upload-time":"2018-04-13T18:00:38.180085Z","url":"https://files.pythonhosted.org/packages/c6/bf/09b13c17f54f0004ccb43cc1c2d36bab2eb75f471564b7856749dcaf62c3/psutil-5.4.5-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp36-cp36m-win32.whl","hashes":{"sha256":"b10703a109cc9225cd588c207f7f93480a420ade35c13515ea8f20063b42a392"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219171,"upload-time":"2018-04-13T18:00:52.610707Z","url":"https://files.pythonhosted.org/packages/3c/ae/34952007b4d64f88a03510866b9cd90207e391f6b2b59b6301ad96fa0fb5/psutil-5.4.5-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ddba952ed256151844d82fb13c8fb1019fe11ecaeacbd659d67ba5661ae73d0d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222710,"upload-time":"2018-04-13T18:01:02.457641Z","url":"https://files.pythonhosted.org/packages/4c/bb/303f15f4a47b96ff0ae5025d89b330e2be314085c418c0b726877476e937/psutil-5.4.5-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.5.tar.gz","hashes":{"sha256":"ebe293be36bb24b95cdefc5131635496e88b17fabbcf1e4bc9b5c01f5e489cfe"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":418003,"upload-time":"2018-04-13T18:01:19.381491Z","url":"https://files.pythonhosted.org/packages/14/a2/8ac7dda36eac03950ec2668ab1b466314403031c83a95c5efc81d2acf163/psutil-5.4.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"data-dist-info-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"filename":"psutil-5.4.6-cp27-none-win32.whl","hashes":{"sha256":"319e12f6bae4d4d988fbff3bed792953fa3b44c791f085b0a1a230f755671ef7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216468,"upload-time":"2018-06-07T15:39:23.967375Z","url":"https://files.pythonhosted.org/packages/b4/00/82c9fb4ffca22f2f6d0d883469584cd0cff71a604a19809015045b1fbab6/psutil-5.4.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"data-dist-info-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"filename":"psutil-5.4.6-cp27-none-win_amd64.whl","hashes":{"sha256":"7789885a72aa3075d28d028236eb3f2b84d908f81d38ad41769a6ddc2fd81b7c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219532,"upload-time":"2018-06-07T15:39:26.297791Z","url":"https://files.pythonhosted.org/packages/c2/23/22df1d36dc8ae002e9f646f9ed06b4f6bfbc7a22b67804c3a497be21d002/psutil-5.4.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp34-cp34m-win32.whl","hashes":{"sha256":"0ff2b16e9045d01edb1dd10d7fbcc184012e37f6cd38029e959f2be9c6223f50"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216464,"upload-time":"2018-06-07T15:39:28.563215Z","url":"https://files.pythonhosted.org/packages/f9/fa/966988e350306e1a1a9024e77ad5f118cbfe11318e8bdfc258c3d5a1c68b/psutil-5.4.6-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"dc85fad15ef98103ecc047a0d81b55bbf5fe1b03313b96e883acc2e2fa87ed5c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219331,"upload-time":"2018-06-07T15:39:31.250304Z","url":"https://files.pythonhosted.org/packages/a5/0d/40b552c2c089523df1f7ab5a0249fbf90cb2e80e89177b0189e41e367adc/psutil-5.4.6-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp35-cp35m-win32.whl","hashes":{"sha256":"7f4616bcb44a6afda930cfc40215e5e9fa7c6896e683b287c771c937712fbe2f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219052,"upload-time":"2018-06-07T15:39:33.732713Z","url":"https://files.pythonhosted.org/packages/00/4d/194ec701de80c704f679bf78495c054994cc403884ffec816787813c4fde/psutil-5.4.6-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"529ae235896efb99a6f77653a7138273ab701ec9f0343a1f5030945108dee3c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222533,"upload-time":"2018-06-07T15:39:36.224840Z","url":"https://files.pythonhosted.org/packages/e3/21/f82f270326e098f211bcc36cbb2ae7100732dcad03bd324e6af8c9d7e407/psutil-5.4.6-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp36-cp36m-win32.whl","hashes":{"sha256":"254adb6a27c888f141d2a6032ae231d8ed4fc5f7583b4c825e5f7d7c78d26d2e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219048,"upload-time":"2018-06-07T15:39:38.273913Z","url":"https://files.pythonhosted.org/packages/d6/e0/0f1b4f61246c4e2b540898b1ca0fa51ee2f52f0366956974f1039e00ed67/psutil-5.4.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"a9b85b335b40a528a8e2a6b549592138de8429c6296e7361892958956e6a73cf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222534,"upload-time":"2018-06-07T15:39:40.675791Z","url":"https://files.pythonhosted.org/packages/36/4b/80d9eb5d39ec4b4d8aec8b098b5097a7291de20bbbe6c2ab233b9d8fe245/psutil-5.4.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp37-cp37m-win32.whl","hashes":{"sha256":"6d981b4d863b20c8ceed98b8ac3d1ca7f96d28707a80845d360fa69c8fc2c44b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219860,"upload-time":"2018-06-28T22:47:57.979619Z","url":"https://files.pythonhosted.org/packages/7a/62/28923c44954b6cf8aee637f3a2f30e0e1ff39ec0f74a4f98069d37f00751/psutil-5.4.6-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"7fdb3d02bfd68f508e6745021311a4a4dbfec53fca03721474e985f310e249ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224296,"upload-time":"2018-06-28T22:48:01.565801Z","url":"https://files.pythonhosted.org/packages/b1/be/78f9d786bddc190c4b394a01531741a11b95f1522cf2759958f13b46407f/psutil-5.4.6-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.6.tar.gz","hashes":{"sha256":"686e5a35fe4c0acc25f3466c32e716f2d498aaae7b7edc03e2305b682226bcf6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":418059,"upload-time":"2018-06-07T15:39:42.364107Z","url":"https://files.pythonhosted.org/packages/51/9e/0f8f5423ce28c9109807024f7bdde776ed0b1161de20b408875de7e030c3/psutil-5.4.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"data-dist-info-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"filename":"psutil-5.4.7-cp27-none-win32.whl","hashes":{"sha256":"b34611280a2d0697f1c499e15e936d88109170194b390599c98bab8072a71f05"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":217777,"upload-time":"2018-08-14T21:01:10.586697Z","url":"https://files.pythonhosted.org/packages/b7/e9/bedbdfecef9d708489cfcd8b9aeada8d8f014fc14644c7129c7177e80d32/psutil-5.4.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"data-dist-info-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"filename":"psutil-5.4.7-cp27-none-win_amd64.whl","hashes":{"sha256":"a890c3e490493f21da2817ffc92822693bc0d6bcac9999caa04ffce8dd4e7132"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220989,"upload-time":"2018-08-14T21:01:13.273922Z","url":"https://files.pythonhosted.org/packages/50/6a/34525bc4e6e153bf6e849a4c4e936742b365f6819c0462cebfa4f082a3c4/psutil-5.4.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp35-cp35m-win32.whl","hashes":{"sha256":"1914bacbd2fc2af8f795daa44b9d2e0649a147460cfd21b1a70a124472f66d40"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220344,"upload-time":"2018-08-14T21:01:15.659359Z","url":"https://files.pythonhosted.org/packages/36/32/5b10d7c3940c64fe92620c368ede8a10016d51aa36079a5cd69944da5a74/psutil-5.4.7-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d081707ef0081920533db30200a2d30d5c0ea9cf6afa7cf8881ae4516cc69c48"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224081,"upload-time":"2018-08-14T21:01:18.052521Z","url":"https://files.pythonhosted.org/packages/ef/fc/8dc7731df7de2f4c65378a7147ecc977221093eee90d9777ca501c2790c5/psutil-5.4.7-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp36-cp36m-win32.whl","hashes":{"sha256":"0d8da7333549a998556c18eb2af3ce902c28d66ceb947505c008f91e9f988abd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220342,"upload-time":"2018-08-14T21:01:20.870660Z","url":"https://files.pythonhosted.org/packages/20/6e/a9a0f84bc3efe970b4c8688b7e7f14ee8342497de8a88cffd35bb485cdcc/psutil-5.4.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"cea2557ee6a9faa2c100947637ded68414e12b851633c4ce26e0311b2a2ed539"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224085,"upload-time":"2018-08-14T21:01:22.891149Z","url":"https://files.pythonhosted.org/packages/97/9e/c056abafcf0fc7ca5bddbc21ad1bb7c67889e16c088b9759f00b95fefcb4/psutil-5.4.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp37-cp37m-win32.whl","hashes":{"sha256":"215d61a901e67b1a35e14c6aedef317f7fa7e6075a20c150fd11bd2c906d2c83"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220347,"upload-time":"2018-08-14T21:01:25.157286Z","url":"https://files.pythonhosted.org/packages/2e/33/5cef36162d94cf0adce428729adeb18b8548ff060781854f3aca71e6b0f0/psutil-5.4.7-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"51057c03aea251ad6667c2bba259bc7ed3210222d3a74152c84e3ab06e1da0ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224087,"upload-time":"2018-08-14T21:01:27.563142Z","url":"https://files.pythonhosted.org/packages/bb/15/aa3d11ae8bf04b7683224f7d3b8f2dd4d3f8a918dcce59bb1f987fca9c6e/psutil-5.4.7-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.7.tar.gz","hashes":{"sha256":"5b6322b167a5ba0c5463b4d30dfd379cd4ce245a1162ebf8fc7ab5c5ffae4f3b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":420300,"upload-time":"2018-08-14T21:01:30.063470Z","url":"https://files.pythonhosted.org/packages/7d/9a/1e93d41708f8ed2b564395edfa3389f0fd6d567597401c2e5e2775118d8b/psutil-5.4.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"data-dist-info-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"filename":"psutil-5.4.8-cp27-none-win32.whl","hashes":{"sha256":"809c9cef0402e3e48b5a1dddc390a8a6ff58b15362ea5714494073fa46c3d293"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220106,"upload-time":"2018-10-30T09:57:34.685390Z","url":"https://files.pythonhosted.org/packages/5a/3f/3f0920df352dae7f824e0e612ff02591378f78405d6c7663dcac023005c4/psutil-5.4.8-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"data-dist-info-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"filename":"psutil-5.4.8-cp27-none-win_amd64.whl","hashes":{"sha256":"3b7a4daf4223dae171a67a89314ac5ca0738e94064a78d99cfd751c55d05f315"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":223347,"upload-time":"2018-10-30T09:57:37.065973Z","url":"https://files.pythonhosted.org/packages/0f/fb/6aecd2c8c9d0ac83d789eaf9f9ec052dd61dd5aea2b47ffa4704175d7a2a/psutil-5.4.8-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp35-cp35m-win32.whl","hashes":{"sha256":"bbffac64cfd01c6bcf90eb1bedc6c80501c4dae8aef4ad6d6dd49f8f05f6fc5a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222713,"upload-time":"2018-10-30T09:57:39.214229Z","url":"https://files.pythonhosted.org/packages/46/2e/ce4ec4b60decc23e0e4d148b6f44c7ddd06ba0ab207dfaee21958bd669df/psutil-5.4.8-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b4d1b735bf5b120813f4c89db8ac22d89162c558cbd7fdd298866125fe906219"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226441,"upload-time":"2018-10-30T09:57:41.411069Z","url":"https://files.pythonhosted.org/packages/7f/28/5ccdb98eff12e7741cc2a6d9dcfdd5d9e06f6d363c2c019d5bfa0e0c1282/psutil-5.4.8-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp36-cp36m-win32.whl","hashes":{"sha256":"3e19be3441134445347af3767fa7770137d472a484070840eee6653b94ac5576"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222711,"upload-time":"2018-10-30T09:57:43.901154Z","url":"https://files.pythonhosted.org/packages/b5/31/8ac896ca77a6aa75ee900698f96ddce46e96bb2484a92457c359a4e4bae6/psutil-5.4.8-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1c19957883e0b93d081d41687089ad630e370e26dc49fd9df6951d6c891c4736"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226440,"upload-time":"2018-10-30T09:57:46.331527Z","url":"https://files.pythonhosted.org/packages/3b/15/62d1eeb4c015e20295e0197f7de0202bd9e5bcb5529b9503932decde2505/psutil-5.4.8-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp37-cp37m-win32.whl","hashes":{"sha256":"bfcea4f189177b2d2ce4a34b03c4ac32c5b4c22e21f5b093d9d315e6e253cd81"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222709,"upload-time":"2018-10-30T09:57:48.860424Z","url":"https://files.pythonhosted.org/packages/21/1e/fe6731e5f03ddf2e57d5b307f25bba294262bc88e27a0fbefdb3515d1727/psutil-5.4.8-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"1c71b9716790e202a00ab0931a6d1e25db1aa1198bcacaea2f5329f75d257fff"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226447,"upload-time":"2018-10-30T09:57:50.676641Z","url":"https://files.pythonhosted.org/packages/50/00/ae52663b879333aa5c65fc9a87ddc24169f8fdd1831762a1ba9c9be7740d/psutil-5.4.8-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.8.tar.gz","hashes":{"sha256":"6e265c8f3da00b015d24b842bfeb111f856b13d24f2c57036582568dc650d6c3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":422742,"upload-time":"2018-10-30T09:57:52.770639Z","url":"https://files.pythonhosted.org/packages/e3/58/0eae6e4466e5abf779d7e2b71fac7fba5f59e00ea36ddb3ed690419ccb0f/psutil-5.4.8.tar.gz","yanked":false},{"core-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"data-dist-info-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"filename":"psutil-5.5.0-cp27-none-win32.whl","hashes":{"sha256":"96f3fdb4ef7467854d46ad5a7e28eb4c6dc6d455d751ddf9640cd6d52bdb03d7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":221314,"upload-time":"2019-01-23T18:23:33.526811Z","url":"https://files.pythonhosted.org/packages/fa/53/53f8c4f1af6f81b169ce76bfd0f56698bc1705da498a47d2ce701f7d7fe3/psutil-5.5.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"data-dist-info-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"filename":"psutil-5.5.0-cp27-none-win_amd64.whl","hashes":{"sha256":"d23f7025bac9b3e38adc6bd032cdaac648ac0074d18e36950a04af35458342e8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224546,"upload-time":"2019-01-23T18:23:36.443393Z","url":"https://files.pythonhosted.org/packages/86/96/a7bfcc3aebedd7112ff353204901db6a1a0c1f3555b2788c68842bb78005/psutil-5.5.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp35-cp35m-win32.whl","hashes":{"sha256":"04d2071100aaad59f9bcbb801be2125d53b2e03b1517d9fed90b45eea51d297e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224084,"upload-time":"2019-01-23T18:23:39.132334Z","url":"https://files.pythonhosted.org/packages/c6/ca/f5d3841ca35e3e3607ed64fe61d2c392054692f05f35e807335299a7952b/psutil-5.5.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d0c4230d60376aee0757d934020b14899f6020cd70ef8d2cb4f228b6ffc43e8f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227536,"upload-time":"2019-01-23T18:23:42.027389Z","url":"https://files.pythonhosted.org/packages/86/0d/a13c15ddccd8e2ccabe63f6d4f139f5a94150b758026e030310e87dded80/psutil-5.5.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp36-cp36m-win32.whl","hashes":{"sha256":"3ac48568f5b85fee44cd8002a15a7733deca056a191d313dbf24c11519c0c4a8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224085,"upload-time":"2019-01-23T18:23:44.450649Z","url":"https://files.pythonhosted.org/packages/45/00/7cdd50ded02e18e50667e2f76ceb645ecdfce59deb39422485f198c7be37/psutil-5.5.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"f0fcb7d3006dd4d9ccf3ccd0595d44c6abbfd433ec31b6ca177300ee3f19e54e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227537,"upload-time":"2019-01-23T18:23:46.937101Z","url":"https://files.pythonhosted.org/packages/48/d1/c9105512328c7f9800c51992b912df6f945eac696dfcd850f719541f67f3/psutil-5.5.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp37-cp37m-win32.whl","hashes":{"sha256":"c8ee08ad1b716911c86f12dc753eb1879006224fd51509f077987bb6493be615"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224078,"upload-time":"2019-01-23T18:23:49.451606Z","url":"https://files.pythonhosted.org/packages/3f/14/5adcad73f22ae0c8fba8b054c0bb7c33c906121b588cc6cbdd686f098947/psutil-5.5.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"b755be689d6fc8ebc401e1d5ce5bac867e35788f10229e166338484eead51b12"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227542,"upload-time":"2019-01-23T18:23:52.035332Z","url":"https://files.pythonhosted.org/packages/38/f1/a822d2b3d973c1ddd9d8a81d269e36987bab20e7bb28ecaa55aef66e8df5/psutil-5.5.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.5.0.tar.gz","hashes":{"sha256":"1aba93430050270750d046a179c5f3d6e1f5f8b96c20399ba38c596b28fc4d37"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":425058,"upload-time":"2019-01-23T18:23:54.951599Z","url":"https://files.pythonhosted.org/packages/6e/a0/833bcbcede5141cc5615e50c7cc5b960ce93d9c9b885fbe3b7d36e48a2d4/psutil-5.5.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"data-dist-info-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"filename":"psutil-5.5.1-cp27-none-win32.whl","hashes":{"sha256":"77c231b4dff8c1c329a4cd1c22b96c8976c597017ff5b09993cd148d6a94500c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":221914,"upload-time":"2019-02-15T19:34:04.528250Z","url":"https://files.pythonhosted.org/packages/cc/cd/64aaf20c945662260026a128a08e46b93a49953224c0dccfdc6f37495d45/psutil-5.5.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"data-dist-info-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"filename":"psutil-5.5.1-cp27-none-win_amd64.whl","hashes":{"sha256":"5ce6b5eb0267233459f4d3980c205828482f450999b8f5b684d9629fea98782a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":225325,"upload-time":"2019-02-15T19:34:07.193210Z","url":"https://files.pythonhosted.org/packages/08/92/97b011d665ade1caf05dd02a3af4ede751c7b80f34812bc81479ec867d85/psutil-5.5.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp35-cp35m-win32.whl","hashes":{"sha256":"a013b4250ccbddc9d22feca0f986a1afc71717ad026c0f2109bbffd007351191"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224822,"upload-time":"2019-02-15T19:34:09.528347Z","url":"https://files.pythonhosted.org/packages/6f/05/70f033e35cd34bc23a08793eaf713347c615674585ccfc7628b40eac4094/psutil-5.5.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"ef3e5e02b3c5d1df366abe7b4820400d5c427579668ad4465ff189d28ded5ebd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228328,"upload-time":"2019-02-15T19:34:12.035704Z","url":"https://files.pythonhosted.org/packages/8e/8d/1854ed30b9f69f4b2cc04ef4364ae8a52ad2988a3223bf6314d2d47f0f04/psutil-5.5.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp36-cp36m-win32.whl","hashes":{"sha256":"ad43b83119eeea6d5751023298cd331637e542cbd332196464799e25a5519f8f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224831,"upload-time":"2019-02-15T19:34:15.031823Z","url":"https://files.pythonhosted.org/packages/e8/c1/32fe16cb90192a9413f3ba303021047c158cbdde5aabd7e26ace8b54f69e/psutil-5.5.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ec1ef313530a9457e48d25e3fdb1723dfa636008bf1b970027462d46f2555d59"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228328,"upload-time":"2019-02-15T19:34:17.494390Z","url":"https://files.pythonhosted.org/packages/3e/6e/c0af4900f18811f09b93064588e53f3997abc051ae43f717d1ba610de3b7/psutil-5.5.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp37-cp37m-win32.whl","hashes":{"sha256":"c177777c787d247d02dae6c855330f9ed3e1abf8ca1744c26dd5ff968949999a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224832,"upload-time":"2019-02-15T19:34:19.685175Z","url":"https://files.pythonhosted.org/packages/00/e6/561fed27453add44af41a52e13e1dfca4d1e35705d698769edea6292339a/psutil-5.5.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"8846ab0be0cdccd6cc92ecd1246a16e2f2e49f53bd73e522c3a75ac291e1b51d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228327,"upload-time":"2019-02-15T19:34:22.218113Z","url":"https://files.pythonhosted.org/packages/3d/22/ed4fa46c5bfd95b4dc57d6544c3fe6568abe398aef3990f6011777f1a3f3/psutil-5.5.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.5.1.tar.gz","hashes":{"sha256":"72cebfaa422b7978a1d3632b65ff734a34c6b34f4578b68a5c204d633756b810"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":426750,"upload-time":"2019-02-15T19:34:24.841527Z","url":"https://files.pythonhosted.org/packages/c7/01/7c30b247cdc5ba29623faa5c8cf1f1bbf7e041783c340414b0ed7e067c64/psutil-5.5.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"data-dist-info-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"filename":"psutil-5.6.0-cp27-none-win32.whl","hashes":{"sha256":"1020a37214c4138e34962881372b40f390582b5c8245680c04349c2afb785a25"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222534,"upload-time":"2019-03-05T12:00:59.141291Z","url":"https://files.pythonhosted.org/packages/04/f5/11b1c93a8882615fdaf6222aaf9d3197f250ab3036d7ecf6b6c8594ddf61/psutil-5.6.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"data-dist-info-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"filename":"psutil-5.6.0-cp27-none-win_amd64.whl","hashes":{"sha256":"d9cdc2e82aeb82200fff3640f375fac39d88b1bed27ce08377cd7fb0e3621cb7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":225803,"upload-time":"2019-03-05T12:01:01.831664Z","url":"https://files.pythonhosted.org/packages/11/88/ed94a7c091fb6ad8fbf545f0f20e140c47286712d6d85dd8cfc40b34fe72/psutil-5.6.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp35-cp35m-win32.whl","hashes":{"sha256":"c4a2f42abee709ed97b4498c21aa608ac31fc1f7cc8aa60ebdcd3c80757a038d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226153,"upload-time":"2019-03-05T12:01:04.695139Z","url":"https://files.pythonhosted.org/packages/ab/5c/dacbb4b6623dc390939e1785a818e6e816eb42c8c96c1f2d30a2fc22a773/psutil-5.6.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"722dc0dcce5272f3c5c41609fdc2c8f0ee3f976550c2d2f2057e26ba760be9c0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230078,"upload-time":"2019-03-05T12:01:07.429607Z","url":"https://files.pythonhosted.org/packages/41/27/9e6d39ae822387ced9a77da904e24e8796c1fa55c5f637cd35221b170980/psutil-5.6.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp36-cp36m-win32.whl","hashes":{"sha256":"1c8e6444ca1cee9a60a1a35913b8409722f7474616e0e21004e4ffadba59964b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226154,"upload-time":"2019-03-05T12:01:10.226359Z","url":"https://files.pythonhosted.org/packages/fb/d0/14b83939ed41c5a80dca6fa072b1a99cd576e33810f691e73a08a7c045b4/psutil-5.6.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"151c9858c268a1523e16fab33e3bc3bae8a0e57b57cf7fcad85fb409cbac6baf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230083,"upload-time":"2019-03-05T12:01:12.681476Z","url":"https://files.pythonhosted.org/packages/ce/3a/ff53c0ee59a864c3614fcaea45f4246e670934ea0d30b632c6e3905533c9/psutil-5.6.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp37-cp37m-win32.whl","hashes":{"sha256":"86f61a1438c026c980a4c3e2dd88a5774a3a0f00d6d0954d6c5cf8d1921b804e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226154,"upload-time":"2019-03-05T12:01:15.084497Z","url":"https://files.pythonhosted.org/packages/17/15/bf444a07aae2200f7b4e786c73bfe959201cb9ab63f737be12d21b5f252e/psutil-5.6.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"da6676a484adec2fdd3e1ce1b70799881ffcb958e40208dd4c5beba0011f3589"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230081,"upload-time":"2019-03-05T12:01:17.936041Z","url":"https://files.pythonhosted.org/packages/88/fd/a32491e77b37ffc00faf79c864975cfd720ae0ac867d93c90640d44adf43/psutil-5.6.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.0.tar.gz","hashes":{"sha256":"dca71c08335fbfc6929438fe3a502f169ba96dd20e50b3544053d6be5cb19d82"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":426596,"upload-time":"2019-03-05T12:01:20.833448Z","url":"https://files.pythonhosted.org/packages/79/e6/a4e3c92fe19d386dcc6149dbf0b76f1c93c5491ae9d9ecf866f6769b45a4/psutil-5.6.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"data-dist-info-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"filename":"psutil-5.6.1-cp27-none-win32.whl","hashes":{"sha256":"23e9cd90db94fbced5151eaaf9033ae9667c033dffe9e709da761c20138d25b6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":223000,"upload-time":"2019-03-11T17:24:48.368476Z","url":"https://files.pythonhosted.org/packages/9d/f2/a84e650af7f04940709466384e94a0894cfe736e7cf43f48fb3bfb01be1b/psutil-5.6.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"data-dist-info-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"filename":"psutil-5.6.1-cp27-none-win_amd64.whl","hashes":{"sha256":"e1494d20ffe7891d07d8cb9a8b306c1a38d48b13575265d090fc08910c56d474"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226302,"upload-time":"2019-03-11T17:24:51.027456Z","url":"https://files.pythonhosted.org/packages/46/51/4007e6188b6d6b68c8b4195d6755bd76585cffd4d286d9f1815ff9f1af01/psutil-5.6.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp35-cp35m-win32.whl","hashes":{"sha256":"ec4b4b638b84d42fc48139f9352f6c6587ee1018d55253542ee28db7480cc653"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226675,"upload-time":"2019-03-11T17:24:53.625833Z","url":"https://files.pythonhosted.org/packages/55/f4/2dc147b66111116f5cb6a85fe42519b2cbfdbf6138562f8b0427bc754fc8/psutil-5.6.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c1fd45931889dc1812ba61a517630d126f6185f688eac1693171c6524901b7de"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230613,"upload-time":"2019-03-11T17:24:56.387303Z","url":"https://files.pythonhosted.org/packages/af/dd/f3bdafb37af7bf417f984db5381a5a27899f93fd2f87d5fd10fb6f3f4087/psutil-5.6.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp36-cp36m-win32.whl","hashes":{"sha256":"d463a142298112426ebd57351b45c39adb41341b91f033aa903fa4c6f76abecc"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226672,"upload-time":"2019-03-11T17:24:58.629155Z","url":"https://files.pythonhosted.org/packages/d5/cc/e3fe388fe3c987973e929cb17cceb33bcd2ff7f8b754cd354826fbb7dfe7/psutil-5.6.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"9c3a768486194b4592c7ae9374faa55b37b9877fd9746fb4028cb0ac38fd4c60"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230621,"upload-time":"2019-03-11T17:25:01.330880Z","url":"https://files.pythonhosted.org/packages/16/6a/cc5ba8d7e3ada0d4621d493dbdcb43ed38f3549642916a14c9e070add21a/psutil-5.6.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp37-cp37m-win32.whl","hashes":{"sha256":"27858d688a58cbfdd4434e1c40f6c79eb5014b709e725c180488ccdf2f721729"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226673,"upload-time":"2019-03-11T17:25:03.865746Z","url":"https://files.pythonhosted.org/packages/a8/8e/3e04eefe955ed94f93c3cde5dc1f1ccd99e2b9a56697fa804ea9f54f7baa/psutil-5.6.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"354601a1d1a1322ae5920ba397c58d06c29728a15113598d1a8158647aaa5385"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230621,"upload-time":"2019-03-11T17:25:06.996226Z","url":"https://files.pythonhosted.org/packages/6a/48/dbcda6d136da319e8bee8196e6c52ff7febf56bd241435cf6a516341a4b1/psutil-5.6.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.1.tar.gz","hashes":{"sha256":"fa0a570e0a30b9dd618bffbece590ae15726b47f9f1eaf7518dfb35f4d7dcd21"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":427472,"upload-time":"2019-03-11T17:25:09.802408Z","url":"https://files.pythonhosted.org/packages/2f/b8/11ec5006d2ec2998cb68349b8d1317c24c284cf918ecd6729739388e4c56/psutil-5.6.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"data-dist-info-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"filename":"psutil-5.6.2-cp27-none-win32.whl","hashes":{"sha256":"76fb0956d6d50e68e3f22e7cc983acf4e243dc0fcc32fd693d398cb21c928802"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226692,"upload-time":"2019-04-26T02:43:03.614779Z","url":"https://files.pythonhosted.org/packages/56/8f/1bfb7e563e413f110ee06ac0cf12bb4b27f78e9cf277892d97ba08de4eac/psutil-5.6.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"data-dist-info-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"filename":"psutil-5.6.2-cp27-none-win_amd64.whl","hashes":{"sha256":"753c5988edc07da00dafd6d3d279d41f98c62cd4d3a548c4d05741a023b0c2e7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230225,"upload-time":"2019-04-26T02:43:08.318806Z","url":"https://files.pythonhosted.org/packages/91/3f/2ae9cd04b2ccc5340838383ba638839a498d2613936b7830079f77de2bf1/psutil-5.6.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp35-cp35m-win32.whl","hashes":{"sha256":"a4c62319ec6bf2b3570487dd72d471307ae5495ce3802c1be81b8a22e438b4bc"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230751,"upload-time":"2019-04-26T02:43:12.014098Z","url":"https://files.pythonhosted.org/packages/ec/39/33a7d6c4e347ffff7784ec4967c04d6319886c5a77c208d29a0980045bc8/psutil-5.6.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"ef342cb7d9b60e6100364f50c57fa3a77d02ff8665d5b956746ac01901247ac4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234724,"upload-time":"2019-04-26T02:43:15.850786Z","url":"https://files.pythonhosted.org/packages/a9/43/87e610adacc3f8e51d61c27a9d48db2c0e7fbac783764fefca4d4ec71dbe/psutil-5.6.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp36-cp36m-win32.whl","hashes":{"sha256":"acba1df9da3983ec3c9c963adaaf530fcb4be0cd400a8294f1ecc2db56499ddd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230749,"upload-time":"2019-04-26T02:43:19.804035Z","url":"https://files.pythonhosted.org/packages/23/2a/0f14e964507adc1732ade6eea3abd92afe34305614515ab856cbccca489a/psutil-5.6.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"206eb909aa8878101d0eca07f4b31889c748f34ed6820a12eb3168c7aa17478e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234728,"upload-time":"2019-04-26T02:43:23.354778Z","url":"https://files.pythonhosted.org/packages/62/b0/54effe77128bdd8b62ca10edf38c22dbe5594ad8b34ce31836011949ac0a/psutil-5.6.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp37-cp37m-win32.whl","hashes":{"sha256":"649f7ffc02114dced8fbd08afcd021af75f5f5b2311bc0e69e53e8f100fe296f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230750,"upload-time":"2019-04-26T02:43:26.831308Z","url":"https://files.pythonhosted.org/packages/86/90/ea3d046bb26aebcbf25fba32cf9ec7d0954ea6b8e4e9d9c87a31633dd96b/psutil-5.6.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"6ebf2b9c996bb8c7198b385bade468ac8068ad8b78c54a58ff288cd5f61992c7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234731,"upload-time":"2019-04-26T02:43:30.698781Z","url":"https://files.pythonhosted.org/packages/98/3c/65f28f78848730c18dfa3ff3a107e3911b6d51d1442cfce8db53356179c3/psutil-5.6.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.2.tar.gz","hashes":{"sha256":"828e1c3ca6756c54ac00f1427fdac8b12e21b8a068c3bb9b631a1734cada25ed"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":432907,"upload-time":"2019-04-26T02:43:34.455685Z","url":"https://files.pythonhosted.org/packages/c6/c1/beed5e4eaa1345901b595048fab1c85aee647ea0fc02d9e8bf9aceb81078/psutil-5.6.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"data-dist-info-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"filename":"psutil-5.6.3-cp27-none-win32.whl","hashes":{"sha256":"d5350cb66690915d60f8b233180f1e49938756fb2d501c93c44f8fb5b970cc63"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226847,"upload-time":"2019-06-11T04:24:07.412816Z","url":"https://files.pythonhosted.org/packages/da/76/7e445566f2c4363691a98f16df0072c6ba92c7c29b4410ef2df6514c9861/psutil-5.6.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"data-dist-info-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"filename":"psutil-5.6.3-cp27-none-win_amd64.whl","hashes":{"sha256":"b6e08f965a305cd84c2d07409bc16fbef4417d67b70c53b299116c5b895e3f45"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230406,"upload-time":"2019-06-11T04:24:10.852056Z","url":"https://files.pythonhosted.org/packages/72/75/43047d7df3ea2af2bcd072e63420b8fa240b729c052295f8c4b964335d36/psutil-5.6.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp35-cp35m-win32.whl","hashes":{"sha256":"cf49178021075d47c61c03c0229ac0c60d5e2830f8cab19e2d88e579b18cdb76"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230912,"upload-time":"2019-06-11T04:24:14.533883Z","url":"https://files.pythonhosted.org/packages/c2/f2/d99eaeefb2c0b1f7f9aca679db17f4072d4cc362f40f809157d4e2d273dd/psutil-5.6.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bc96d437dfbb8865fc8828cf363450001cb04056bbdcdd6fc152c436c8a74c61"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234942,"upload-time":"2019-06-11T04:24:18.128893Z","url":"https://files.pythonhosted.org/packages/90/86/d5ae0eb79cab6acc00d3640a45243e3e0602dc2f7abca29fc2fe6b4819ca/psutil-5.6.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp36-cp36m-win32.whl","hashes":{"sha256":"eba238cf1989dfff7d483c029acb0ac4fcbfc15de295d682901f0e2497e6781a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230914,"upload-time":"2019-06-11T04:24:21.735106Z","url":"https://files.pythonhosted.org/packages/28/0c/e41fd3020662487cf92f0c47b09285d7e53c42ee56cdc3ddb03a147cfa5d/psutil-5.6.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"954f782608bfef9ae9f78e660e065bd8ffcfaea780f9f2c8a133bb7cb9e826d7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234945,"upload-time":"2019-06-11T04:24:26.649579Z","url":"https://files.pythonhosted.org/packages/86/91/f15a3aae2af13f008ed95e02292d1a2e84615ff42b7203357c1c0bbe0651/psutil-5.6.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp37-cp37m-win32.whl","hashes":{"sha256":"503e4b20fa9d3342bcf58191bbc20a4a5ef79ca7df8972e6197cc14c5513e73d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230914,"upload-time":"2019-06-11T04:24:30.881936Z","url":"https://files.pythonhosted.org/packages/3b/92/2a7fb18054ac12483fb72f281c285d21642ca3d29fc6a06f0e44d4b36d83/psutil-5.6.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"028a1ec3c6197eadd11e7b46e8cc2f0720dc18ac6d7aabdb8e8c0d6c9704f000"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234949,"upload-time":"2019-06-11T04:24:34.722512Z","url":"https://files.pythonhosted.org/packages/7c/58/f5d68ddca37480d8557b8566a20bf6108d7e1c6c9b9208ee0786e0cd012b/psutil-5.6.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"991ea9c126c59fb12521c83a1676786ad9a7ea2af4f3985b1e8086af3eda4156"},"data-dist-info-metadata":{"sha256":"991ea9c126c59fb12521c83a1676786ad9a7ea2af4f3985b1e8086af3eda4156"},"filename":"psutil-5.6.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"12542c3642909f4cd1928a2fba59e16fa27e47cbeea60928ebb62a8cbd1ce123"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238041,"upload-time":"2019-10-24T10:11:31.818649Z","url":"https://files.pythonhosted.org/packages/a7/7f/0761489b5467af4e97ae3c5a25f24f8662d69a25692d85490c8ea5d52e45/psutil-5.6.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.3.tar.gz","hashes":{"sha256":"863a85c1c0a5103a12c05a35e59d336e1d665747e531256e061213e2e90f63f3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":435374,"upload-time":"2019-06-11T04:24:39.293855Z","url":"https://files.pythonhosted.org/packages/1c/ca/5b8c1fe032a458c2c4bcbe509d1401dca9dda35c7fc46b36bb81c2834740/psutil-5.6.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"data-dist-info-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"filename":"psutil-5.6.4-cp27-none-win32.whl","hashes":{"sha256":"75d50d1138b2476a11dca33ab1ad2b78707d428418b581966ccedac768358f72"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228290,"upload-time":"2019-11-04T08:38:28.711265Z","url":"https://files.pythonhosted.org/packages/8a/63/0273163f0197ff2d8f026ae0f9c7cac371f8819f6451e6cfd2e1e7132b90/psutil-5.6.4-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"data-dist-info-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"filename":"psutil-5.6.4-cp27-none-win_amd64.whl","hashes":{"sha256":"0ff1f630ee0df7c048ef53e50196437d2c9cebab8ccca0e3078d9300c4b7da47"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231797,"upload-time":"2019-11-04T08:38:33.155488Z","url":"https://files.pythonhosted.org/packages/db/d0/17a47a1876cf408d0dd679f78ba18a206228fdb95928137dd85538a51298/psutil-5.6.4-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp35-cp35m-win32.whl","hashes":{"sha256":"10175ea15b7e4a1bf1a0863da7e17042862b3ea3e7d24285c96fa4cc65ab9788"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232325,"upload-time":"2019-11-04T08:38:37.308918Z","url":"https://files.pythonhosted.org/packages/cb/22/e2ce6539342fb0ebd65fb9e2a0a168585eb5cae9bd5dca7977735f8d430e/psutil-5.6.4-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f6b66a5663700b71bac3d8ecf6533a1550a679823e63b2c92dc4c3c8c244c52e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236342,"upload-time":"2019-11-04T08:38:41.583480Z","url":"https://files.pythonhosted.org/packages/32/9a/beaf5df1f8b38d3ec7ec737f873515813586aa26926738896957c3af0a9d/psutil-5.6.4-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp36-cp36m-win32.whl","hashes":{"sha256":"4f637dd25d3bce4879d0b4032d13f4120ba18ed2d028e85d911d429f447c251c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232330,"upload-time":"2019-11-04T08:38:46.049782Z","url":"https://files.pythonhosted.org/packages/74/3c/61d46eccf9fca27fc11f30d27af11c3886609d5eb52475926a1ad12d6ebd/psutil-5.6.4-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"43f0d7536a98c20a538242ce2bd8c64dbc1f6c396e97f2bdceb496d7583b9b80"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236347,"upload-time":"2019-11-04T08:38:50.265170Z","url":"https://files.pythonhosted.org/packages/2c/59/beae1392ad5188b419709d3e04641cbe93e36184b7b8686af825a2232b2b/psutil-5.6.4-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp37-cp37m-win32.whl","hashes":{"sha256":"f0ec1a3ea56503f4facc1dca364cf3dd66dc39169c4603000d3d34270e05fbb3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-04T08:38:54.615037Z","url":"https://files.pythonhosted.org/packages/e6/2e/e0c14d0fa46afb15b1467daa792f143e675034f8c544d03a2b7365d4926c/psutil-5.6.4-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"512e77ac987105e2d7aa2386d9f260434ad8b71e41484f8d84bfecd4ae3764ca"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236347,"upload-time":"2019-11-04T08:38:58.188759Z","url":"https://files.pythonhosted.org/packages/a3/59/fe32a3ec677990a5ed6b1a44dc2e372c9ee40693890814e8b6d96c290c4d/psutil-5.6.4-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp38-cp38-win32.whl","hashes":{"sha256":"41d645f100c6b4c995ff342ef7d79a936f3f48e9a816d7d655c69b352460341d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234629,"upload-time":"2019-11-04T08:46:40.809419Z","url":"https://files.pythonhosted.org/packages/50/0c/7b2fa0baedd36147beb820f662844b1079e168c06e9fe62d78a4d2666375/psutil-5.6.4-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp38-cp38-win_amd64.whl","hashes":{"sha256":"fb58e87c29ec0fb99937b95c5d473bb786d263aaa767d017a6bd4ad52d694e79"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239057,"upload-time":"2019-11-04T08:46:45.192939Z","url":"https://files.pythonhosted.org/packages/e3/28/fa3a597ed798a5a2cb9c9e53c2d8b6bc1310c4a147c2aaa65c5d3afdb6ed/psutil-5.6.4-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.4.tar.gz","hashes":{"sha256":"512e854d68f8b42f79b2c7864d997b39125baff9bcff00028ce43543867de7c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447564,"upload-time":"2019-11-04T08:39:02.419203Z","url":"https://files.pythonhosted.org/packages/47/ea/d3b6d6fd0b4a6c12984df652525f394e68c8678d2b05075219144eb3a1cf/psutil-5.6.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"data-dist-info-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"filename":"psutil-5.6.5-cp27-none-win32.whl","hashes":{"sha256":"145e0f3ab9138165f9e156c307100905fd5d9b7227504b8a9d3417351052dc3d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228289,"upload-time":"2019-11-06T10:07:27.672551Z","url":"https://files.pythonhosted.org/packages/97/52/9a44db00d4400814384d574f3a2c2b588259c212e457f542c2589dbdac58/psutil-5.6.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"data-dist-info-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"filename":"psutil-5.6.5-cp27-none-win_amd64.whl","hashes":{"sha256":"3feea46fbd634a93437b718518d15b5dd49599dfb59a30c739e201cc79bb759d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231796,"upload-time":"2019-11-06T10:07:31.973662Z","url":"https://files.pythonhosted.org/packages/c4/35/4422a966d304faa401d55dc45caf342722a14c0a9b56d57ecf208f9bb6a3/psutil-5.6.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp35-cp35m-win32.whl","hashes":{"sha256":"348ad4179938c965a27d29cbda4a81a1b2c778ecd330a221aadc7bd33681afbd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232325,"upload-time":"2019-11-06T10:07:36.463607Z","url":"https://files.pythonhosted.org/packages/4c/2f/93ac7f065f8c4c361e422dffff21dea1803cb40f2449e6ea52800caddf9f/psutil-5.6.5-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"474e10a92eeb4100c276d4cc67687adeb9d280bbca01031a3e41fb35dfc1d131"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236340,"upload-time":"2019-11-06T10:07:41.723247Z","url":"https://files.pythonhosted.org/packages/9f/49/fddf3b6138a5d47668e2daf98ac9a6eeea4c28e3eb68b56580f18e8fe6af/psutil-5.6.5-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp36-cp36m-win32.whl","hashes":{"sha256":"e3f5f9278867e95970854e92d0f5fe53af742a7fc4f2eba986943345bcaed05d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-06T10:07:45.647021Z","url":"https://files.pythonhosted.org/packages/ae/5d/11bb7fb7cc004bdf1325c0b40827e67e479ababe47c553ee871494353acf/psutil-5.6.5-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"dfb8c5c78579c226841908b539c2374da54da648ee5a837a731aa6a105a54c00"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236344,"upload-time":"2019-11-06T10:07:49.683064Z","url":"https://files.pythonhosted.org/packages/c6/18/221e8a5084585c6a2550894fb0617dc4691b5216f4aa6bb82c330aa5d99c/psutil-5.6.5-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp37-cp37m-win32.whl","hashes":{"sha256":"021d361439586a0fd8e64f8392eb7da27135db980f249329f1a347b9de99c695"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-06T10:07:53.427002Z","url":"https://files.pythonhosted.org/packages/31/f8/d612f18fed1422a016bb641d3ce1922904a2aa0cc3472ce4abf2716cf542/psutil-5.6.5-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"e9649bb8fc5cea1f7723af53e4212056a6f984ee31784c10632607f472dec5ee"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236346,"upload-time":"2019-11-06T10:07:57.218779Z","url":"https://files.pythonhosted.org/packages/97/c7/9b18c3b429c987796d74647c61030c7029518ac223d1a664951417781fe4/psutil-5.6.5-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp38-cp38-win32.whl","hashes":{"sha256":"47aeb4280e80f27878caae4b572b29f0ec7967554b701ba33cd3720b17ba1b07"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234627,"upload-time":"2019-11-06T10:08:50.811061Z","url":"https://files.pythonhosted.org/packages/03/94/e4ee514cfbc4cca176fcc6b4b1118a724848b570941e90f0b98a9bd234e1/psutil-5.6.5-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp38-cp38-win_amd64.whl","hashes":{"sha256":"73a7e002781bc42fd014dfebb3fc0e45f8d92a4fb9da18baea6fb279fbc1d966"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239056,"upload-time":"2019-11-06T10:08:55.334494Z","url":"https://files.pythonhosted.org/packages/cd/3b/de8a1f1692de2f16716a108a63366aa66692e5a087b6e0458eef9739e652/psutil-5.6.5-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.5.tar.gz","hashes":{"sha256":"d051532ac944f1be0179e0506f6889833cf96e466262523e57a871de65a15147"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447489,"upload-time":"2019-11-06T10:08:01.639000Z","url":"https://files.pythonhosted.org/packages/03/9a/95c4b3d0424426e5fd94b5302ff74cea44d5d4f53466e1228ac8e73e14b4/psutil-5.6.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"data-dist-info-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"filename":"psutil-5.6.6-cp27-none-win32.whl","hashes":{"sha256":"06660136ab88762309775fd47290d7da14094422d915f0466e0adf8e4b22214e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228564,"upload-time":"2019-11-25T12:30:48.823010Z","url":"https://files.pythonhosted.org/packages/c9/c2/4d703fcb5aacd4cb8d472d3c1d0e7d8c21e17f37b515016a7ee34ff3f4a0/psutil-5.6.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"data-dist-info-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"filename":"psutil-5.6.6-cp27-none-win_amd64.whl","hashes":{"sha256":"f21a7bb4b207e4e7c60b3c40ffa89d790997619f04bbecec9db8e3696122bc78"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232093,"upload-time":"2019-11-25T12:30:53.306595Z","url":"https://files.pythonhosted.org/packages/76/4d/6452c4791f9d95b48cca084b7cc6aa8a72b2f4c8d3d8bd38e7f3abfaf364/psutil-5.6.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp35-cp35m-win32.whl","hashes":{"sha256":"5e8dbf31871b0072bcba8d1f2861c0ec6c84c78f13c723bb6e981bce51b58f12"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232818,"upload-time":"2019-11-25T12:30:58.414546Z","url":"https://files.pythonhosted.org/packages/f3/b3/e585b9b0c5a40e6a778e32e8d3040ab2363433990417202bf6cc0261ed77/psutil-5.6.6-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"724390895cff80add7a1c4e7e0a04d9c94f3ee61423a2dcafd83784fabbd1ee9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236751,"upload-time":"2019-11-25T12:31:03.059024Z","url":"https://files.pythonhosted.org/packages/73/38/a8ebf6dc6ada2257591284be45a52dcd19479163b8d3575186333a79a18e/psutil-5.6.6-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp36-cp36m-win32.whl","hashes":{"sha256":"6d81b9714791ef9a3a00b2ca846ee547fc5e53d259e2a6258c3d2054928039ff"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232821,"upload-time":"2019-11-25T12:31:08.161481Z","url":"https://files.pythonhosted.org/packages/5b/04/2223b4fe61d3e5962c08ce5062b09633fcfdd8c3bb08c31b76306f748431/psutil-5.6.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"3004361c6b93dbad71330d992c1ae409cb8314a6041a0b67507cc882357f583e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236759,"upload-time":"2019-11-25T12:31:13.077581Z","url":"https://files.pythonhosted.org/packages/33/6c/6eb959bca82064d42e725dddd3aeeb39d9bed34eed7b513880bcfd8a3d59/psutil-5.6.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp37-cp37m-win32.whl","hashes":{"sha256":"0fc7a5619b47f74331add476fbc6022d7ca801c22865c7069ec0867920858963"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232820,"upload-time":"2019-11-25T12:31:17.411233Z","url":"https://files.pythonhosted.org/packages/76/46/3a8dc20eb9d7d2c44178e71c2412dcc2c6476ab71c05a2cf2f77247c6e53/psutil-5.6.6-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"f60042bef7dc50a78c06334ca8e25580455948ba2fa98f240d034a4fed9141a5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236757,"upload-time":"2019-11-25T12:31:21.816790Z","url":"https://files.pythonhosted.org/packages/40/48/5debf9783077ac71f0d715c1171fde9ef287909f61672ed9a3e5fdca63cc/psutil-5.6.6-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp38-cp38-win32.whl","hashes":{"sha256":"0c11adde31011a286197630ba2671e34651f004cc418d30ae06d2033a43c9e20"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233147,"upload-time":"2019-11-25T12:31:26.294340Z","url":"https://files.pythonhosted.org/packages/c6/10/035c432a15bec90d51f3625d4b70b7d12f1b363062d0d8815213229f69ca/psutil-5.6.6-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp38-cp38-win_amd64.whl","hashes":{"sha256":"0c211eec4185725847cb6c28409646c7cfa56fdb531014b35f97b5dc7fe04ff9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":237165,"upload-time":"2019-11-25T12:31:30.835876Z","url":"https://files.pythonhosted.org/packages/95/81/fb02ea8de73eca26cfa347f5ce81a7963b9dee6e038e0a7389ccbc971093/psutil-5.6.6-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.6.tar.gz","hashes":{"sha256":"ad21281f7bd6c57578dd53913d2d44218e9e29fd25128d10ff7819ef16fa46e7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447805,"upload-time":"2019-11-25T12:31:36.347718Z","url":"https://files.pythonhosted.org/packages/5f/dc/edf6758183afc7591a16bd4b8a44d8eea80aca1327ea60161dd3bad9ad22/psutil-5.6.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"data-dist-info-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"filename":"psutil-5.6.7-cp27-none-win32.whl","hashes":{"sha256":"1b1575240ca9a90b437e5a40db662acd87bbf181f6aa02f0204978737b913c6b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228449,"upload-time":"2019-11-26T07:25:43.864472Z","url":"https://files.pythonhosted.org/packages/13/a7/626f257d22168c954fd3ad69760c02bdec27c0648a62f6ea5060c4d40672/psutil-5.6.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"data-dist-info-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"filename":"psutil-5.6.7-cp27-none-win_amd64.whl","hashes":{"sha256":"28f771129bfee9fc6b63d83a15d857663bbdcae3828e1cb926e91320a9b5b5cd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231969,"upload-time":"2019-11-26T07:25:50.426501Z","url":"https://files.pythonhosted.org/packages/52/44/e1e1954da522ea8640e035c8b101c116a9f8a0e94e04e108e56911064de5/psutil-5.6.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp35-cp35m-win32.whl","hashes":{"sha256":"21231ef1c1a89728e29b98a885b8e0a8e00d09018f6da5cdc1f43f988471a995"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232644,"upload-time":"2019-11-26T07:25:56.230501Z","url":"https://files.pythonhosted.org/packages/d8/39/bf74da6282d9521fe3987b2d67f581b3464e635e6cb56660d0315d1bf1ed/psutil-5.6.7-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b74b43fecce384a57094a83d2778cdfc2e2d9a6afaadd1ebecb2e75e0d34e10d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236538,"upload-time":"2019-11-26T07:26:01.396655Z","url":"https://files.pythonhosted.org/packages/b3/84/0a899c6fac13aedfb4734413a2357a504c4f21cbf8acd7ad4caa6712d8cf/psutil-5.6.7-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp36-cp36m-win32.whl","hashes":{"sha256":"e85f727ffb21539849e6012f47b12f6dd4c44965e56591d8dec6e8bc9ab96f4a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232649,"upload-time":"2019-11-26T07:26:06.727306Z","url":"https://files.pythonhosted.org/packages/7c/d7/be2b607abfab4a98f04dd2155d6a7a40a666618d69c079897f09ce776a34/psutil-5.6.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"b560f5cd86cf8df7bcd258a851ca1ad98f0d5b8b98748e877a0aec4e9032b465"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236541,"upload-time":"2019-11-26T07:26:11.229459Z","url":"https://files.pythonhosted.org/packages/78/e6/ce8a91afd605f254342f1294790f2a77c76202386d6927eb5ff0e36e4449/psutil-5.6.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp37-cp37m-win32.whl","hashes":{"sha256":"094f899ac3ef72422b7e00411b4ed174e3c5a2e04c267db6643937ddba67a05b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232645,"upload-time":"2019-11-26T07:26:15.814275Z","url":"https://files.pythonhosted.org/packages/c4/e1/80c7840db569ad5b1b60987893e066a5536779c0d2402363cbf1230613a2/psutil-5.6.7-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"fd2e09bb593ad9bdd7429e779699d2d47c1268cbde4dda95fcd1bd17544a0217"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236539,"upload-time":"2019-11-26T07:26:20.217732Z","url":"https://files.pythonhosted.org/packages/9d/84/0a2006cc263e9f5b6dfbb2301fbcce5558f0d6d17d0c11c7c6749a45c79e/psutil-5.6.7-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp38-cp38-win32.whl","hashes":{"sha256":"70387772f84fa5c3bb6a106915a2445e20ac8f9821c5914d7cbde148f4d7ff73"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232983,"upload-time":"2019-11-26T07:26:24.615122Z","url":"https://files.pythonhosted.org/packages/55/9d/9a6df5f730a1e2a3938fad0ccf541b30fad34706128b43ed3f965eaf7550/psutil-5.6.7-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp38-cp38-win_amd64.whl","hashes":{"sha256":"10b7f75cc8bd676cfc6fa40cd7d5c25b3f45a0e06d43becd7c2d2871cbb5e806"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236965,"upload-time":"2019-11-26T07:26:28.827408Z","url":"https://files.pythonhosted.org/packages/8a/fa/b573850e912d6ffdad4aef3f5f705f94a64d098a83eec15d1cd3e1223f5e/psutil-5.6.7-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.7.tar.gz","hashes":{"sha256":"ffad8eb2ac614518bbe3c0b8eb9dffdb3a8d2e3a7d5da51c5b974fb723a5c5aa"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":448321,"upload-time":"2019-11-26T07:26:34.515073Z","url":"https://files.pythonhosted.org/packages/73/93/4f8213fbe66fc20cb904f35e6e04e20b47b85bee39845cc66a0bcf5ccdcb/psutil-5.6.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"data-dist-info-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"filename":"psutil-5.7.0-cp27-none-win32.whl","hashes":{"sha256":"298af2f14b635c3c7118fd9183843f4e73e681bb6f01e12284d4d70d48a60953"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227641,"upload-time":"2020-02-18T18:02:31.085536Z","url":"https://files.pythonhosted.org/packages/0b/6b/f613593812c5f379c6d609bf5eca36a409812f508e13c704acd25712a73e/psutil-5.7.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"data-dist-info-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"filename":"psutil-5.7.0-cp27-none-win_amd64.whl","hashes":{"sha256":"75e22717d4dbc7ca529ec5063000b2b294fc9a367f9c9ede1f65846c7955fd38"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230741,"upload-time":"2020-02-18T18:02:35.453910Z","url":"https://files.pythonhosted.org/packages/79/b1/377fa0f28630d855cb6b5bfb2ee4c1bf0df3bc2603c691ceefce59a95181/psutil-5.7.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp35-cp35m-win32.whl","hashes":{"sha256":"f344ca230dd8e8d5eee16827596f1c22ec0876127c28e800d7ae20ed44c4b310"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231151,"upload-time":"2020-02-18T18:02:39.410543Z","url":"https://files.pythonhosted.org/packages/74/e6/4a0ef10b1a4ca43954cd8fd9eac02cc8606f9d2a5a66859a283f5f95452b/psutil-5.7.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e2d0c5b07c6fe5a87fa27b7855017edb0d52ee73b71e6ee368fae268605cc3f5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235435,"upload-time":"2020-02-18T18:02:43.014979Z","url":"https://files.pythonhosted.org/packages/65/c2/0aeb9f0cc7e4be2807aa052b3fd017e59439ed6d830b461f8ecb35b2f367/psutil-5.7.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp36-cp36m-win32.whl","hashes":{"sha256":"a02f4ac50d4a23253b68233b07e7cdb567bd025b982d5cf0ee78296990c22d9e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231156,"upload-time":"2020-02-18T18:02:46.432233Z","url":"https://files.pythonhosted.org/packages/c9/37/b94930ae428b2d67d505aecc5ba84c53a0b75479a8a87cd35cc9a2c6eb7e/psutil-5.7.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1413f4158eb50e110777c4f15d7c759521703bd6beb58926f1d562da40180058"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235439,"upload-time":"2020-02-18T18:02:49.890797Z","url":"https://files.pythonhosted.org/packages/4f/3c/205850b172a14a8b9fdc9b1e84a2c055d6b9aea226431da7685bea644f04/psutil-5.7.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp37-cp37m-win32.whl","hashes":{"sha256":"d008ddc00c6906ec80040d26dc2d3e3962109e40ad07fd8a12d0284ce5e0e4f8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231153,"upload-time":"2020-02-18T18:02:53.653943Z","url":"https://files.pythonhosted.org/packages/54/25/7825fefd62635f7ca556c8e0d44369ce4674aa2ca0eca50b8ae4ff49954b/psutil-5.7.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"73f35ab66c6c7a9ce82ba44b1e9b1050be2a80cd4dcc3352cc108656b115c74f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235439,"upload-time":"2020-02-18T18:02:57.139440Z","url":"https://files.pythonhosted.org/packages/86/f7/385040b90dd190edc28908c4a26af99b00ae37564ee5f5c4526dc1d80c27/psutil-5.7.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp38-cp38-win32.whl","hashes":{"sha256":"60b86f327c198561f101a92be1995f9ae0399736b6eced8f24af41ec64fb88d4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231789,"upload-time":"2020-02-18T18:03:00.808478Z","url":"https://files.pythonhosted.org/packages/63/d5/f34a9433a0299d944605fb5a970306a89e076f5412164179dc59ebf70fa9/psutil-5.7.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"d84029b190c8a66a946e28b4d3934d2ca1528ec94764b180f7d6ea57b0e75e26"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235952,"upload-time":"2020-02-18T18:03:04.130414Z","url":"https://files.pythonhosted.org/packages/86/fe/9f1d1f8c1c8138d42fc0e7c06ca5004e01f38e86e61342374d8e0fa919e4/psutil-5.7.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.0.tar.gz","hashes":{"sha256":"685ec16ca14d079455892f25bd124df26ff9137664af445563c1bd36629b5e0e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":449628,"upload-time":"2020-02-18T18:03:07.566242Z","url":"https://files.pythonhosted.org/packages/c4/b8/3512f0e93e0db23a71d82485ba256071ebef99b227351f0f5540f744af41/psutil-5.7.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"2dfb7b5638ffaa33602a86b39cca60cded2324dabbe2617b1b5e65250e448769"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233646,"upload-time":"2020-07-15T11:14:11.635539Z","url":"https://files.pythonhosted.org/packages/79/e4/cbaa3ecc458c2dd8da64073de983473543b8b6ef4ca21159cea9069d53dd/psutil-5.7.1-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-macosx_10_9_x86_64.whl","hashes":{"sha256":"36c5e6882caf3d385c6c3a0d2f3b302b4cc337c808ea589d9a8c563b545beb8b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233862,"upload-time":"2020-07-15T11:14:27.607855Z","url":"https://files.pythonhosted.org/packages/4d/d9/48c3d16c1dfbbf528bd69254b5a604c9f6860f12169b1b73a5005723c6bf/psutil-5.7.1-cp35-cp35m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-win32.whl","hashes":{"sha256":"3c5ffd00bc1ee809350dca97613985d387a7e13dff61d62fc1bdf4dc10892ddd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238370,"upload-time":"2020-07-15T11:14:34.746888Z","url":"https://files.pythonhosted.org/packages/d0/e2/d4cdadda6a9fba79026ab628fc2b4da5e2e48dcfc6beada0a39363732ba1/psutil-5.7.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"4975c33aebe7de191d745ee3c545e907edd14d65c850a0b185c05024aa77cbcd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242862,"upload-time":"2020-07-15T11:14:37.084757Z","url":"https://files.pythonhosted.org/packages/a0/6b/cdb41805a6bb62c051cfbb1b65a9cb40767e0144b3d40fdd7082d8271701/psutil-5.7.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"436a6e99098eba14b54a149f921c9d4e1df729f02645876af0c828396d36c46a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233861,"upload-time":"2020-07-15T11:14:39.242780Z","url":"https://files.pythonhosted.org/packages/1f/fb/097aeed40c361225cb69d6d04202421f2c172d7e42753130d1b619f68956/psutil-5.7.1-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-win32.whl","hashes":{"sha256":"630ceda48c16b24ffd981fe06ae1a43684af1a3a837d6a3496a1be3dd3c7d332"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238378,"upload-time":"2020-07-15T11:14:45.606142Z","url":"https://files.pythonhosted.org/packages/ae/49/cba9353fd9946eac95031c85763daaf7904d3c3e8b0b4f2801199586b413/psutil-5.7.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d3bb7f65199595a72a3ec53e4d05c159857ab832fadaae9d85e68db467d2d191"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242864,"upload-time":"2020-07-15T11:14:47.861971Z","url":"https://files.pythonhosted.org/packages/7b/38/f27fc6a30f81be1ee657bd4c355c2dc03a5fbb49f304a37c79c0bed05821/psutil-5.7.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"66d085317599684f70d995dd4a770894f518fb34d027d7f742b579bf47732858"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233863,"upload-time":"2020-07-15T11:14:49.991128Z","url":"https://files.pythonhosted.org/packages/23/cb/410a516385c8cd69f090f98c8014636c51d124c96e4d6ab51e1bb2d04232/psutil-5.7.1-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-win32.whl","hashes":{"sha256":"fb442b912fe28d80e0f966adcc3df4e394fbb7ef7575ae21fd171aeb06c8b0df"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238369,"upload-time":"2020-07-15T11:14:57.383010Z","url":"https://files.pythonhosted.org/packages/59/44/e9cfa470dd2790b5475ceb590949842a5f2feb52445e898576b721033f04/psutil-5.7.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"425d6c95ca3ece7ff4da7e67af2954b8eb56b0f15743b237dc84ad975f51c2a4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242865,"upload-time":"2020-07-15T11:14:59.839217Z","url":"https://files.pythonhosted.org/packages/06/76/b4607e0eaf36369ad86f7ac73bde19aeaf32c82fb22675cb8f8dd975c692/psutil-5.7.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"f2817a763c33c19fdefbb832c790bc85b3de90b51fb69dae43097a9885be0332"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234129,"upload-time":"2020-07-15T11:15:01.982258Z","url":"https://files.pythonhosted.org/packages/ba/f7/64bf7fd7a12a40c50408b7d90cdf3addc28071e5463af1dbb7f3884a32d2/psutil-5.7.1-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-win32.whl","hashes":{"sha256":"3cf43d2265ee03fcf70f0f574487ed19435c92a330e15a3e773144811c1275f0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239004,"upload-time":"2020-07-15T11:15:08.125783Z","url":"https://files.pythonhosted.org/packages/7e/64/c3bd24d53f6056ded095e8d147c0ca269bb6d858aea903561bd660d67035/psutil-5.7.1-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-win_amd64.whl","hashes":{"sha256":"006b720a67881037c8b02b1de012a39a2f007bd2b1b244b58fabef8eff0ad6d2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243418,"upload-time":"2020-07-15T11:15:10.044651Z","url":"https://files.pythonhosted.org/packages/ff/5a/1e990cf86f47721225143ed4a903a226685fa1ba0b43500f52d71500b1be/psutil-5.7.1-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"621e2f3b573aa563717ee39c3f052b4cd3cda5e1f25e5973fa77e727433c6ce1"},"data-dist-info-metadata":{"sha256":"621e2f3b573aa563717ee39c3f052b4cd3cda5e1f25e5973fa77e727433c6ce1"},"filename":"psutil-5.7.1-pp27-pypy_73-macosx_10_9_x86_64.whl","hashes":{"sha256":"0c9187ec0c314a128362c3409afea2b80c6d6d2c2cb1d661fe20631a2ff8ad77"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232076,"upload-time":"2020-07-15T11:15:12.408818Z","url":"https://files.pythonhosted.org/packages/80/fd/d91ff7582513d093097678eedd141a4879698da26e6163fbae16905aa75b/psutil-5.7.1-pp27-pypy_73-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.1.tar.gz","hashes":{"sha256":"4ef6845b35e152e6937d4f28388c2440ca89a0089ced0a30a116fa3ceefdfa3a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":460148,"upload-time":"2020-07-15T11:15:21.985314Z","url":"https://files.pythonhosted.org/packages/2c/5c/cb95a715fb635e1ca858ffb8c50a523a16e2dc06aa3e207ab73cb93516af/psutil-5.7.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"data-dist-info-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"filename":"psutil-5.7.2-cp27-none-win32.whl","hashes":{"sha256":"f2018461733b23f308c298653c8903d32aaad7873d25e1d228765e91ae42c3f2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234782,"upload-time":"2020-07-15T13:19:05.321836Z","url":"https://files.pythonhosted.org/packages/d0/da/d7da0365f690e7555f6dda34bcb5bde10266379c9a23ee6a0735c3a7fdfd/psutil-5.7.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"data-dist-info-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"filename":"psutil-5.7.2-cp27-none-win_amd64.whl","hashes":{"sha256":"66c18ca7680a31bf16ee22b1d21b6397869dda8059dbdb57d9f27efa6615f195"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238050,"upload-time":"2020-07-15T13:19:07.922423Z","url":"https://files.pythonhosted.org/packages/7d/9d/30a053a06d598cee4bdbc6ba69df44ced9e6d2ebb16e2de401a2a3bc6d63/psutil-5.7.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp35-cp35m-win32.whl","hashes":{"sha256":"5e9d0f26d4194479a13d5f4b3798260c20cecf9ac9a461e718eb59ea520a360c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238373,"upload-time":"2020-07-15T13:19:10.146779Z","url":"https://files.pythonhosted.org/packages/df/27/e5cf14b0894b4f06c23dc4f58288c60b17e71d8bef9af463f0b32ee46773/psutil-5.7.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"4080869ed93cce662905b029a1770fe89c98787e543fa7347f075ade761b19d6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242862,"upload-time":"2020-07-15T13:19:12.906781Z","url":"https://files.pythonhosted.org/packages/0a/4c/d31d58992314664e69bda6d575c1fd47b86ed5d67e00e300fc909040a9aa/psutil-5.7.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp36-cp36m-win32.whl","hashes":{"sha256":"d8a82162f23c53b8525cf5f14a355f5d1eea86fa8edde27287dd3a98399e4fdf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238380,"upload-time":"2020-07-15T13:19:15.247084Z","url":"https://files.pythonhosted.org/packages/57/c5/0aa3b1513b914a417db7ee149b60579a139111f81f79f5f1d38ae440cebf/psutil-5.7.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"0ee3c36428f160d2d8fce3c583a0353e848abb7de9732c50cf3356dd49ad63f8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242866,"upload-time":"2020-07-15T13:19:17.782781Z","url":"https://files.pythonhosted.org/packages/22/f8/7be159475303a508347efc82c0d5858b1786fe73fc2a6b21d82891791920/psutil-5.7.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp37-cp37m-win32.whl","hashes":{"sha256":"ff1977ba1a5f71f89166d5145c3da1cea89a0fdb044075a12c720ee9123ec818"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238375,"upload-time":"2020-07-15T13:19:20.591814Z","url":"https://files.pythonhosted.org/packages/56/de/6f07749f275d0ba7f9b985cd6a4526e2fa47ad63b5179948c6650117f7d9/psutil-5.7.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"a5b120bb3c0c71dfe27551f9da2f3209a8257a178ed6c628a819037a8df487f1"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242863,"upload-time":"2020-07-15T13:19:23.022907Z","url":"https://files.pythonhosted.org/packages/f8/9b/1d7df5e1747e047abef4ec877d895b642f3a796ab8bd2e0f682516740dfe/psutil-5.7.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp38-cp38-win32.whl","hashes":{"sha256":"10512b46c95b02842c225f58fa00385c08fa00c68bac7da2d9a58ebe2c517498"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239003,"upload-time":"2020-07-15T13:19:25.770960Z","url":"https://files.pythonhosted.org/packages/da/d6/f66bbdbc8831a5cc78ba0e9bf69d924e68eac1a7b4191de93cf4e3643c54/psutil-5.7.2-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp38-cp38-win_amd64.whl","hashes":{"sha256":"68d36986ded5dac7c2dcd42f2682af1db80d4bce3faa126a6145c1637e1b559f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243419,"upload-time":"2020-07-15T13:19:28.240707Z","url":"https://files.pythonhosted.org/packages/6c/e6/f963547a36a96f74244cbe5e4046a02f140e3b7cbc5e5176035b38e2deb2/psutil-5.7.2-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.2.tar.gz","hashes":{"sha256":"90990af1c3c67195c44c9a889184f84f5b2320dce3ee3acbd054e3ba0b4a7beb"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":460198,"upload-time":"2020-07-15T13:19:30.438785Z","url":"https://files.pythonhosted.org/packages/aa/3e/d18f2c04cf2b528e18515999b0c8e698c136db78f62df34eee89cee205f1/psutil-5.7.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"data-dist-info-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"filename":"psutil-5.7.3-cp27-none-win32.whl","hashes":{"sha256":"1cd6a0c9fb35ece2ccf2d1dd733c1e165b342604c67454fd56a4c12e0a106787"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235225,"upload-time":"2020-10-24T14:00:54.139761Z","url":"https://files.pythonhosted.org/packages/1d/a2/b732590561ef9d7dbc078ed0e2635e282115604a478911fef97ddaa3ad43/psutil-5.7.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"data-dist-info-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"filename":"psutil-5.7.3-cp27-none-win_amd64.whl","hashes":{"sha256":"e02c31b2990dcd2431f4524b93491941df39f99619b0d312dfe1d4d530b08b4b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238499,"upload-time":"2020-10-24T14:00:57.724543Z","url":"https://files.pythonhosted.org/packages/b4/4c/c14a9485957b00c20f70e208a03663e81ddc8dafdf5137fee2d50aa1ee5e/psutil-5.7.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp35-cp35m-win32.whl","hashes":{"sha256":"56c85120fa173a5d2ad1d15a0c6e0ae62b388bfb956bb036ac231fbdaf9e4c22"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238813,"upload-time":"2020-10-24T15:02:21.678008Z","url":"https://files.pythonhosted.org/packages/e0/ba/a7c1096470e11c449019690ee9e7fd3adca1a4b9cfa6e5a13b60db3187b4/psutil-5.7.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"fa38ac15dbf161ab1e941ff4ce39abd64b53fec5ddf60c23290daed2bc7d1157"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243298,"upload-time":"2020-10-24T15:02:24.823245Z","url":"https://files.pythonhosted.org/packages/3f/7c/98aada1208462c841788712383f4288b3c31e45504570a818c0c303d78e7/psutil-5.7.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp36-cp36m-win32.whl","hashes":{"sha256":"01bc82813fbc3ea304914581954979e637bcc7084e59ac904d870d6eb8bb2bc7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238821,"upload-time":"2020-10-24T15:02:27.844759Z","url":"https://files.pythonhosted.org/packages/44/a8/ebfcbb4967e74a27049ea6e13b3027ae05c0cb73d1a2b71c2f0519c6d5f2/psutil-5.7.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"6a3e1fd2800ca45083d976b5478a2402dd62afdfb719b30ca46cd28bb25a2eb4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243300,"upload-time":"2020-10-24T15:02:31.552663Z","url":"https://files.pythonhosted.org/packages/9a/c3/3b0023b46fc038eff02fbb69a0e6e50d15a7dce25e717d8469e8eaa837a7/psutil-5.7.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp37-cp37m-win32.whl","hashes":{"sha256":"fbcac492cb082fa38d88587d75feb90785d05d7e12d4565cbf1ecc727aff71b7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238814,"upload-time":"2020-10-24T15:02:34.703606Z","url":"https://files.pythonhosted.org/packages/e1/f0/d4f58ddf077d970440b82b92e909e8e9b2f50e39a2dc2aa716b1e2fde5ef/psutil-5.7.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"5d9106ff5ec2712e2f659ebbd112967f44e7d33f40ba40530c485cc5904360b8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243302,"upload-time":"2020-10-24T15:02:38.016752Z","url":"https://files.pythonhosted.org/packages/f1/a0/094a6e32185bd1288a4681d91ebe362d5b41aa64413bbbd96ed547051f17/psutil-5.7.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp38-cp38-win32.whl","hashes":{"sha256":"ade6af32eb80a536eff162d799e31b7ef92ddcda707c27bbd077238065018df4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239426,"upload-time":"2020-10-24T15:02:41.250786Z","url":"https://files.pythonhosted.org/packages/bd/95/394485321a128f5ddb23f0a559f940309280f57bd6117580868fb2d5a246/psutil-5.7.3-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"2cb55ef9591b03ef0104bedf67cc4edb38a3edf015cf8cf24007b99cb8497542"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243849,"upload-time":"2020-10-24T15:02:44.162783Z","url":"https://files.pythonhosted.org/packages/df/64/8d7b55ac87e67398ffc260d43a5fb327f1e230b09758b7d8caaecf917dd6/psutil-5.7.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.3.tar.gz","hashes":{"sha256":"af73f7bcebdc538eda9cc81d19db1db7bf26f103f91081d780bbacfcb620dee2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":465556,"upload-time":"2020-10-24T14:02:15.604830Z","url":"https://files.pythonhosted.org/packages/33/e0/82d459af36bda999f82c7ea86c67610591cf5556168f48fd6509e5fa154d/psutil-5.7.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"0066a82f7b1b37d334e68697faba68e5ad5e858279fd6351c8ca6024e8d6ba64"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235772,"upload-time":"2020-12-19T01:19:27.017908Z","url":"https://files.pythonhosted.org/packages/f5/7f/a2559a514bdeb2a33e4bf3dc3d2bb17d5acded718893869a82536130cfb3/psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"0ae6f386d8d297177fd288be6e8d1afc05966878704dad9847719650e44fc49c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284461,"upload-time":"2020-12-19T01:19:30.158384Z","url":"https://files.pythonhosted.org/packages/19/2c/9f1bad783faee4e9704868f381913e68dbb69f0de3fcdc71ee7071c47847/psutil-5.8.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"12d844996d6c2b1d3881cfa6fa201fd635971869a9da945cf6756105af73d2df"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287768,"upload-time":"2020-12-19T01:19:33.394809Z","url":"https://files.pythonhosted.org/packages/82/0a/eddb9a51ba5055cc7c242da07c1643a6b146070740c5eb5540277a0f01f4/psutil-5.8.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"02b8292609b1f7fcb34173b25e48d0da8667bc85f81d7476584d889c6e0f2131"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284476,"upload-time":"2020-12-19T01:19:36.479406Z","url":"https://files.pythonhosted.org/packages/15/28/47c28171fd7eeb83df74f78ccac090211f4a49408f376eb8e78a7bb47dc0/psutil-5.8.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"6ffe81843131ee0ffa02c317186ed1e759a145267d54fdef1bc4ea5f5931ab60"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287754,"upload-time":"2020-12-19T01:19:39.219693Z","url":"https://files.pythonhosted.org/packages/26/ef/461e9eec56fba7fa66692c4af00cbd6547b788a7ca818d9b8b5f1951f228/psutil-5.8.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"data-dist-info-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"filename":"psutil-5.8.0-cp27-none-win32.whl","hashes":{"sha256":"ea313bb02e5e25224e518e4352af4bf5e062755160f77e4b1767dd5ccb65f876"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236561,"upload-time":"2020-12-19T01:19:41.916204Z","url":"https://files.pythonhosted.org/packages/a8/b3/6a21c5b7e4f600bd6eaaecd4a5e76230fa34876e48cbc87b2cef0ab91c0a/psutil-5.8.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"data-dist-info-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"filename":"psutil-5.8.0-cp27-none-win_amd64.whl","hashes":{"sha256":"5da29e394bdedd9144c7331192e20c1f79283fb03b06e6abd3a8ae45ffecee65"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239900,"upload-time":"2020-12-19T01:19:45.046259Z","url":"https://files.pythonhosted.org/packages/b2/3d/01ef1f4bf71413078bf2ce2aae04d47bc132cfede58738183a9de41aa122/psutil-5.8.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"74fb2557d1430fff18ff0d72613c5ca30c45cdbfcddd6a5773e9fc1fe9364be8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236013,"upload-time":"2020-12-19T01:19:47.734642Z","url":"https://files.pythonhosted.org/packages/30/81/37ebe0ba2840b76681072e786bae3319cade8a6861029d0ae885c274fa0b/psutil-5.8.0-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-manylinux2010_i686.whl","hashes":{"sha256":"74f2d0be88db96ada78756cb3a3e1b107ce8ab79f65aa885f76d7664e56928f6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289247,"upload-time":"2020-12-19T01:19:50.429849Z","url":"https://files.pythonhosted.org/packages/2e/7c/13a6c3f068aa39ffafd99ae159c1a345521e7dd0074ccadb917e5670dbdc/psutil-5.8.0-cp36-cp36m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-manylinux2010_x86_64.whl","hashes":{"sha256":"99de3e8739258b3c3e8669cb9757c9a861b2a25ad0955f8e53ac662d66de61ac"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291875,"upload-time":"2020-12-19T01:19:53.450222Z","url":"https://files.pythonhosted.org/packages/da/82/56cd16a4c5f53e3e5dd7b2c30d5c803e124f218ebb644ca9c30bc907eadd/psutil-5.8.0-cp36-cp36m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-win32.whl","hashes":{"sha256":"36b3b6c9e2a34b7d7fbae330a85bf72c30b1c827a4366a07443fc4b6270449e2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240337,"upload-time":"2020-12-19T01:19:56.748668Z","url":"https://files.pythonhosted.org/packages/19/29/f7a38ee30083f2caa14cc77a6d34c4d5cfd1a69641e87bf1b3d6ba90d0ba/psutil-5.8.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"52de075468cd394ac98c66f9ca33b2f54ae1d9bff1ef6b67a212ee8f639ec06d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244835,"upload-time":"2020-12-19T01:19:59.102544Z","url":"https://files.pythonhosted.org/packages/44/ed/49d75a29007727d44937ed4d233f116be346bc4657a83b5a9e2f423bca57/psutil-5.8.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"c6a5fd10ce6b6344e616cf01cc5b849fa8103fbb5ba507b6b2dee4c11e84c935"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236013,"upload-time":"2020-12-19T01:20:02.260367Z","url":"https://files.pythonhosted.org/packages/fe/19/83ab423a7b69cafe4078dea751acdff7377e4b59c71e3718125ba3c341f9/psutil-5.8.0-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-manylinux2010_i686.whl","hashes":{"sha256":"61f05864b42fedc0771d6d8e49c35f07efd209ade09a5afe6a5059e7bb7bf83d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":290299,"upload-time":"2020-12-19T01:20:04.653817Z","url":"https://files.pythonhosted.org/packages/cc/5f/2a1967092086acc647962168d0e6fd1c22e14a973f03e3ffb1e2f0da5de9/psutil-5.8.0-cp37-cp37m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-manylinux2010_x86_64.whl","hashes":{"sha256":"0dd4465a039d343925cdc29023bb6960ccf4e74a65ad53e768403746a9207023"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296329,"upload-time":"2020-12-19T01:20:07.174230Z","url":"https://files.pythonhosted.org/packages/84/da/f7efdcf012b51506938553dbe302aecc22f3f43abd5cffa8320e8e0588d5/psutil-5.8.0-cp37-cp37m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-win32.whl","hashes":{"sha256":"1bff0d07e76114ec24ee32e7f7f8d0c4b0514b3fae93e3d2aaafd65d22502394"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240337,"upload-time":"2020-12-19T01:20:10.138302Z","url":"https://files.pythonhosted.org/packages/18/c9/1db6aa0d28831f60408a6aab9d108c2edbd5a9ed11e5957a91d9d8023898/psutil-5.8.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"fcc01e900c1d7bee2a37e5d6e4f9194760a93597c97fee89c4ae51701de03563"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244834,"upload-time":"2020-12-19T01:20:12.840200Z","url":"https://files.pythonhosted.org/packages/71/ce/35107e81e7eae55c847313f872d4258a71d2640fa04f57c5520fc81473ce/psutil-5.8.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"6223d07a1ae93f86451d0198a0c361032c4c93ebd4bf6d25e2fb3edfad9571ef"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236297,"upload-time":"2020-12-19T01:20:15.489742Z","url":"https://files.pythonhosted.org/packages/10/d6/c5c19e40bb05e2cb5f053f480dfe47e9543a8322f1a5985d7352bf689611/psutil-5.8.0-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-manylinux2010_i686.whl","hashes":{"sha256":"d225cd8319aa1d3c85bf195c4e07d17d3cd68636b8fc97e6cf198f782f99af28"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293809,"upload-time":"2020-12-19T01:20:18.539919Z","url":"https://files.pythonhosted.org/packages/e9/d6/7d0bcf272923f6b3433e22effd31860b63ab580d65fb2d8f5cb443a9e6fc/psutil-5.8.0-cp38-cp38-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-manylinux2010_x86_64.whl","hashes":{"sha256":"28ff7c95293ae74bf1ca1a79e8805fcde005c18a122ca983abf676ea3466362b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296040,"upload-time":"2020-12-19T01:20:21.423284Z","url":"https://files.pythonhosted.org/packages/3b/c2/78109a12da9febb2f965abf29da6f81b0a3f2b89a7b59d88b759e68dc6db/psutil-5.8.0-cp38-cp38-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-win32.whl","hashes":{"sha256":"ce8b867423291cb65cfc6d9c4955ee9bfc1e21fe03bb50e177f2b957f1c2469d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240950,"upload-time":"2020-12-19T01:20:24.359373Z","url":"https://files.pythonhosted.org/packages/87/be/6511e1341c203608fe2553249216c40b92cd8a72d8b35fa3c1decee9a616/psutil-5.8.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"90f31c34d25b1b3ed6c40cdd34ff122b1887a825297c017e4cbd6796dd8b672d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245386,"upload-time":"2020-12-19T01:20:26.799194Z","url":"https://files.pythonhosted.org/packages/8e/5c/c4b32c2024daeac35e126b90a1ff7a0209ef8b32675d1d50e55d58e78c81/psutil-5.8.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"6323d5d845c2785efb20aded4726636546b26d3b577aded22492908f7c1bdda7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236274,"upload-time":"2020-12-19T01:20:29.615503Z","url":"https://files.pythonhosted.org/packages/12/80/8d09c345f19af2b29a309f8f9284e3ba1ae1ebd9438419080c14630f743a/psutil-5.8.0-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-manylinux2010_i686.whl","hashes":{"sha256":"245b5509968ac0bd179287d91210cd3f37add77dad385ef238b275bad35fa1c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291032,"upload-time":"2020-12-19T01:20:32.422979Z","url":"https://files.pythonhosted.org/packages/b6/2f/118e23a8f4e59d2c4ffe03a921cc72f364966e25548dc6c5a3011a334dc5/psutil-5.8.0-cp39-cp39-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-manylinux2010_x86_64.whl","hashes":{"sha256":"90d4091c2d30ddd0a03e0b97e6a33a48628469b99585e2ad6bf21f17423b112b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293491,"upload-time":"2020-12-19T01:20:34.915141Z","url":"https://files.pythonhosted.org/packages/91/4d/033cc02ae3a47197d0ced818814e4bb8d9d29ebed4f1eb55badedec160f7/psutil-5.8.0-cp39-cp39-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-win32.whl","hashes":{"sha256":"ea372bcc129394485824ae3e3ddabe67dc0b118d262c568b4d2602a7070afdb0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241508,"upload-time":"2020-12-19T01:20:37.527554Z","url":"https://files.pythonhosted.org/packages/a7/13/7285b74e061da21dfc4f15c8307eb2da1d2137367502d6598f03f4a5b5e7/psutil-5.8.0-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-win_amd64.whl","hashes":{"sha256":"f4634b033faf0d968bb9220dd1c793b897ab7f1189956e1aa9eae752527127d3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246139,"upload-time":"2020-12-19T01:20:39.890196Z","url":"https://files.pythonhosted.org/packages/21/71/33cb528381c443df1ee25cbb451da975421bddb5099b11e7f2eb3fc90d6d/psutil-5.8.0-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.8.0.tar.gz","hashes":{"sha256":"0c9ccb99ab76025f2f0bbecf341d4656e9c1351db8cc8a03ccd62e318ab4b5c6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":470886,"upload-time":"2020-12-19T01:20:42.916847Z","url":"https://files.pythonhosted.org/packages/e1/b0/7276de53321c12981717490516b7e612364f2cb372ee8901bd4a66a000d7/psutil-5.8.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"55ce319452e3d139e25d6c3f85a1acf12d1607ddedea5e35fb47a552c051161b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285348,"upload-time":"2021-12-29T21:26:19.591062Z","url":"https://files.pythonhosted.org/packages/c9/62/5cfcb69c256d469236d4bddeb7ad4ee6a8b37d604dcfc82b7c938fd8ee37/psutil-5.9.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"7336292a13a80eb93c21f36bde4328aa748a04b68c13d01dfddd67fc13fd0618"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288125,"upload-time":"2021-12-29T21:26:24.644701Z","url":"https://files.pythonhosted.org/packages/eb/0d/c19872c9121208bbbb4335bb13a4a2f2b95661fd69d24f26e32f94e5a8a1/psutil-5.9.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"cb8d10461c1ceee0c25a64f2dd54872b70b89c26419e147a05a10b753ad36ec2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285364,"upload-time":"2021-12-29T21:26:28.242468Z","url":"https://files.pythonhosted.org/packages/1a/3e/ff287d01bca130b72cf53a9b20bbc31bf566d503ee63adf8c7dcfd9315e2/psutil-5.9.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"7641300de73e4909e5d148e90cc3142fb890079e1525a840cf0dfd39195239fd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288110,"upload-time":"2021-12-29T21:26:31.963660Z","url":"https://files.pythonhosted.org/packages/d8/49/fbce284331d482703decdc8dec9bfd910fa00a3acd5b974e8efa8c30104a/psutil-5.9.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"data-dist-info-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"filename":"psutil-5.9.0-cp27-none-win32.whl","hashes":{"sha256":"ea42d747c5f71b5ccaa6897b216a7dadb9f52c72a0fe2b872ef7d3e1eacf3ba3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239056,"upload-time":"2021-12-29T21:26:35.738857Z","url":"https://files.pythonhosted.org/packages/ab/d7/a8b076603943ebce7872ca7d4e012f6dcdc33e86eabb117921a6fe6e1f8a/psutil-5.9.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"data-dist-info-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"filename":"psutil-5.9.0-cp27-none-win_amd64.whl","hashes":{"sha256":"ef216cc9feb60634bda2f341a9559ac594e2eeaadd0ba187a4c2eb5b5d40b91c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242517,"upload-time":"2021-12-29T21:26:39.603955Z","url":"https://files.pythonhosted.org/packages/2d/7a/ee32fa2c5712fa0bc6a9f376ffe9d2e1dc856e2e011d2bab4e12293dcd88/psutil-5.9.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"90a58b9fcae2dbfe4ba852b57bd4a1dded6b990a33d6428c7614b7d48eccb492"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238624,"upload-time":"2021-12-29T21:26:42.964503Z","url":"https://files.pythonhosted.org/packages/89/48/2c6f566d35a38fb9f882e51d75425a6f1d097cb946e05b6aff98d450a151/psutil-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"ff0d41f8b3e9ebb6b6110057e40019a432e96aae2008951121ba4e56040b84f3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279343,"upload-time":"2021-12-29T21:26:46.859457Z","url":"https://files.pythonhosted.org/packages/11/46/e790221e8281af5163517a17a20c88b10a75a5642d9c5106a868f2879edd/psutil-5.9.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"742c34fff804f34f62659279ed5c5b723bb0195e9d7bd9907591de9f8f6558e2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281400,"upload-time":"2021-12-29T21:26:51.801761Z","url":"https://files.pythonhosted.org/packages/6f/8a/d1810472a4950a31df385eafbc9bd20cde971814ff6533021dc565bf14ae/psutil-5.9.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-win32.whl","hashes":{"sha256":"8293942e4ce0c5689821f65ce6522ce4786d02af57f13c0195b40e1edb1db61d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241383,"upload-time":"2021-12-29T21:26:55.364799Z","url":"https://files.pythonhosted.org/packages/61/93/4251cfa58e5bbd7f92e1bfb965a0c41376cbcbc83c524a8b60d2678f0edd/psutil-5.9.0-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-win_amd64.whl","hashes":{"sha256":"9b51917c1af3fa35a3f2dabd7ba96a2a4f19df3dec911da73875e1edaf22a40b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245540,"upload-time":"2021-12-29T21:26:59.088538Z","url":"https://files.pythonhosted.org/packages/9f/c9/7fb339d6a04db3b4ab94671536d11e03b23c056d1604e50e564075a96cd8/psutil-5.9.0-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"e9805fed4f2a81de98ae5fe38b75a74c6e6ad2df8a5c479594c7629a1fe35f56"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238331,"upload-time":"2022-01-07T14:28:07.566595Z","url":"https://files.pythonhosted.org/packages/48/cb/6841d4f39b5711652a93359748879f2977ede55c1020f69d038891073592/psutil-5.9.0-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"c51f1af02334e4b516ec221ee26b8fdf105032418ca5a5ab9737e8c87dafe203"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":277267,"upload-time":"2022-01-07T14:28:12.318473Z","url":"https://files.pythonhosted.org/packages/1f/2d/e6640979580db1b51220d3165e256a1d0a31847944a3e2622800a737fe86/psutil-5.9.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"32acf55cb9a8cbfb29167cd005951df81b567099295291bcfd1027365b36591d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279702,"upload-time":"2022-01-07T14:28:16.706587Z","url":"https://files.pythonhosted.org/packages/64/87/461555057b080e1996427098a6c51c64a8a9025ec18571dabfe5be07eeec/psutil-5.9.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-win32.whl","hashes":{"sha256":"e5c783d0b1ad6ca8a5d3e7b680468c9c926b804be83a3a8e95141b05c39c9f64"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243193,"upload-time":"2022-01-07T14:28:20.695929Z","url":"https://files.pythonhosted.org/packages/2b/a3/24d36239a7bfa30b0eb4302b045417796e9f2c7c21b296d2405735e8949e/psutil-5.9.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d62a2796e08dd024b8179bd441cb714e0f81226c352c802fca0fd3f89eeacd94"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247862,"upload-time":"2022-01-07T14:28:23.774803Z","url":"https://files.pythonhosted.org/packages/14/c9/f0bccd60a25197d63a02688ea8f5c5cd5a8b1baf1a7d6bf493d3291132d2/psutil-5.9.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"3d00a664e31921009a84367266b35ba0aac04a2a6cad09c550a89041034d19a0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238334,"upload-time":"2021-12-29T21:27:03.461413Z","url":"https://files.pythonhosted.org/packages/70/40/0a6ca5641f7574b6ea38cdb561c30065659734755a1779db67b56e225f84/psutil-5.9.0-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7779be4025c540d1d65a2de3f30caeacc49ae7a2152108adeaf42c7534a115ce"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278077,"upload-time":"2021-12-29T21:27:07.864433Z","url":"https://files.pythonhosted.org/packages/6b/c0/0f233f87e816c20e5489bca749798255a464282cdd5911d62bb8344c4b5a/psutil-5.9.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"072664401ae6e7c1bfb878c65d7282d4b4391f1bc9a56d5e03b5a490403271b5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280736,"upload-time":"2021-12-29T21:27:11.252493Z","url":"https://files.pythonhosted.org/packages/60/f9/b78291ed21146ece2417bd1ba715564c6d3bdf2f1e9297ed67709bb36eeb/psutil-5.9.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-win32.whl","hashes":{"sha256":"df2c8bd48fb83a8408c8390b143c6a6fa10cb1a674ca664954de193fdcab36a9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241810,"upload-time":"2021-12-29T21:27:14.020326Z","url":"https://files.pythonhosted.org/packages/47/3f/0475146306d02270243e55cad8167d5185c8918933953c90eda846d72ff3/psutil-5.9.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"1d7b433519b9a38192dfda962dd8f44446668c009833e1429a52424624f408b4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246380,"upload-time":"2021-12-29T21:27:17.444889Z","url":"https://files.pythonhosted.org/packages/7c/d6/4ade7cebfe04710a89e2dc5638f712f09dc5e402a8fea95c3d16dc7f64bf/psutil-5.9.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"c3400cae15bdb449d518545cbd5b649117de54e3596ded84aacabfbb3297ead2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238620,"upload-time":"2021-12-29T21:27:21.799788Z","url":"https://files.pythonhosted.org/packages/89/8e/2a8814f903bc06471621f6e0cd3fc1a7085868656106f31aacf2f844eea2/psutil-5.9.0-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b2237f35c4bbae932ee98902a08050a27821f8f6dfa880a47195e5993af4702d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281246,"upload-time":"2021-12-29T21:27:24.591382Z","url":"https://files.pythonhosted.org/packages/4c/95/3c0858c62ec02106cf5f3e79d74223264a6269a16996f31d5ab43abcec86/psutil-5.9.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"1070a9b287846a21a5d572d6dddd369517510b68710fca56b0e9e02fd24bed9a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":283823,"upload-time":"2021-12-29T21:27:27.809766Z","url":"https://files.pythonhosted.org/packages/0a/66/b2188d8e738ee52206a4ee804907f6eab5bcc9fc0e8486e7ab973a8323b7/psutil-5.9.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-win32.whl","hashes":{"sha256":"76cebf84aac1d6da5b63df11fe0d377b46b7b500d892284068bacccf12f20666"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242160,"upload-time":"2021-12-29T21:27:31.512894Z","url":"https://files.pythonhosted.org/packages/d0/cf/7a86fc08f821d66c528939f155079df7d0945678fc474c6a6455c909f6eb/psutil-5.9.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"3151a58f0fbd8942ba94f7c31c7e6b310d2989f4da74fcbf28b934374e9bf841"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246488,"upload-time":"2021-12-29T21:27:36.422809Z","url":"https://files.pythonhosted.org/packages/62/d4/72fc44dfd9939851bd672e94e43d12848a98b1d2c3f6f794d54a220fe4a7/psutil-5.9.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"539e429da49c5d27d5a58e3563886057f8fc3868a5547b4f1876d9c0f007bccf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238613,"upload-time":"2021-12-29T21:27:39.813718Z","url":"https://files.pythonhosted.org/packages/48/6a/c6e88a5584544033dbb8318c380e7e1e3796e5ac336577eb91dc75bdecd7/psutil-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"58c7d923dc209225600aec73aa2c4ae8ea33b1ab31bc11ef8a5933b027476f07"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278536,"upload-time":"2021-12-29T21:27:43.204962Z","url":"https://files.pythonhosted.org/packages/f7/b1/82e95f6368dbde6b7e54ea6b18cf8ac3958223540d0bcbde23ba7be19478/psutil-5.9.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"3611e87eea393f779a35b192b46a164b1d01167c9d323dda9b1e527ea69d697d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280415,"upload-time":"2021-12-29T21:27:47.616041Z","url":"https://files.pythonhosted.org/packages/c4/35/7cec9647be077784d20913404f914fffd8fe6dfd0673e29f7bd822ac1331/psutil-5.9.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-win32.whl","hashes":{"sha256":"4e2fb92e3aeae3ec3b7b66c528981fd327fb93fd906a77215200404444ec1845"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241428,"upload-time":"2021-12-29T21:27:52.616449Z","url":"https://files.pythonhosted.org/packages/5a/c6/923aed22f6c9c5197998fa6907c983e884975a0ae3430ccd8514f5fd0d6a/psutil-5.9.0-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-win_amd64.whl","hashes":{"sha256":"7d190ee2eaef7831163f254dc58f6d2e2a22e27382b936aab51c835fc080c3d3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245606,"upload-time":"2021-12-29T21:27:56.202709Z","url":"https://files.pythonhosted.org/packages/9e/9e/3a48f15a1539505e2f3058a709eee56acfb379f2b0ff409d6291099e2a7e/psutil-5.9.0-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.0.tar.gz","hashes":{"sha256":"869842dbd66bb80c3217158e629d6fceaecc3a3166d3d1faee515b05dd26ca25"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":478322,"upload-time":"2021-12-29T21:27:59.163343Z","url":"https://files.pythonhosted.org/packages/47/b6/ea8a7728f096a597f0032564e8013b705aa992a0990becd773dcc4d7b4a7/psutil-5.9.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"799759d809c31aab5fe4579e50addf84565e71c1dc9f1c31258f159ff70d3f87"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286186,"upload-time":"2022-05-20T20:09:47.558524Z","url":"https://files.pythonhosted.org/packages/77/06/f9fd79449440d7217d6bf2c90998d540e125cfeffe39d214a328dadc46f4/psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"9272167b5f5fbfe16945be3db475b3ce8d792386907e673a209da686176552af"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288858,"upload-time":"2022-05-20T20:09:52.956913Z","url":"https://files.pythonhosted.org/packages/cf/29/ad704a45960bfb52ef8bf0beb9c41c09ce92d61c40333f03e9a03f246c22/psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"data-dist-info-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"filename":"psutil-5.9.1-cp27-cp27m-win32.whl","hashes":{"sha256":"0904727e0b0a038830b019551cf3204dd48ef5c6868adc776e06e93d615fc5fc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239479,"upload-time":"2022-05-20T20:09:57.166474Z","url":"https://files.pythonhosted.org/packages/7e/8d/e0a66123fa98e309597815de518b47a7a6c571a8f886fc8d4db2331fd2ab/psutil-5.9.1-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"data-dist-info-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"filename":"psutil-5.9.1-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"e7e10454cb1ab62cc6ce776e1c135a64045a11ec4c6d254d3f7689c16eb3efd2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242812,"upload-time":"2022-05-20T20:10:01.868774Z","url":"https://files.pythonhosted.org/packages/1b/53/8f0772df0a6d593bc2fcdf12f4f790bab5c4f6a77bb61a8ddaad2cbba7f8/psutil-5.9.1-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"56960b9e8edcca1456f8c86a196f0c3d8e3e361320071c93378d41445ffd28b0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286184,"upload-time":"2022-05-20T20:10:05.575313Z","url":"https://files.pythonhosted.org/packages/2d/56/54b4ed8102ce5a2f5367b4e766c1873c18f9c32cde321435d0e0ee2abcc5/psutil-5.9.1-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"44d1826150d49ffd62035785a9e2c56afcea66e55b43b8b630d7706276e87f22"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288863,"upload-time":"2022-05-20T20:10:09.032899Z","url":"https://files.pythonhosted.org/packages/2c/9d/dc329b7da284677ea843f3ff4b35b8ab3b96b65a58a544b3c3f86d9d032f/psutil-5.9.1-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"c7be9d7f5b0d206f0bbc3794b8e16fb7dbc53ec9e40bbe8787c6f2d38efcf6c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239266,"upload-time":"2022-05-20T20:10:12.541628Z","url":"https://files.pythonhosted.org/packages/d1/16/6239e76ab5d990dc7866bc22a80585f73421588d63b42884d607f5f815e2/psutil-5.9.1-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"abd9246e4cdd5b554a2ddd97c157e292ac11ef3e7af25ac56b08b455c829dca8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280127,"upload-time":"2022-05-20T20:10:16.449769Z","url":"https://files.pythonhosted.org/packages/14/06/39d7e963a6a8bbf26519de208593cdb0ddfe22918b8989f4b2363d4ab49f/psutil-5.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"29a442e25fab1f4d05e2655bb1b8ab6887981838d22effa2396d584b740194de"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282049,"upload-time":"2022-05-20T20:10:19.914788Z","url":"https://files.pythonhosted.org/packages/6d/c6/6a4e46802e8690d50ba6a56c7f79ac283e703fcfa0fdae8e41909c8cef1f/psutil-5.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp310-cp310-win32.whl","hashes":{"sha256":"20b27771b077dcaa0de1de3ad52d22538fe101f9946d6dc7869e6f694f079329"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241699,"upload-time":"2022-05-20T20:10:23.278390Z","url":"https://files.pythonhosted.org/packages/26/b4/a58cf15ea649faa92c54f00c627aef1d50b9f1abf207485f10c967a50c95/psutil-5.9.1-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp310-cp310-win_amd64.whl","hashes":{"sha256":"58678bbadae12e0db55186dc58f2888839228ac9f41cc7848853539b70490021"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245843,"upload-time":"2022-05-20T20:10:26.856840Z","url":"https://files.pythonhosted.org/packages/c0/5a/2ac88d5265b711c8aa4e786825b38d5d0b1e5ecbdd0ce78e9b04a820d247/psutil-5.9.1-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"3a76ad658641172d9c6e593de6fe248ddde825b5866464c3b2ee26c35da9d237"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239007,"upload-time":"2022-05-20T20:10:30.191299Z","url":"https://files.pythonhosted.org/packages/65/1d/6a112f146faee6292a6c3ee2a7f24a8e572697adb7e1c5de3d8508f647cc/psutil-5.9.1-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"a6a11e48cb93a5fa606306493f439b4aa7c56cb03fc9ace7f6bfa21aaf07c453"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278074,"upload-time":"2022-05-20T20:10:33.843171Z","url":"https://files.pythonhosted.org/packages/7e/52/a02dc53e26714a339c8b4972d8e3f268e4db8905f5d1a3a100f1e40b6fa7/psutil-5.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"068935df39055bf27a29824b95c801c7a5130f118b806eee663cad28dca97685"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280402,"upload-time":"2022-05-20T20:10:38.665061Z","url":"https://files.pythonhosted.org/packages/6b/76/a8cb69ed3566877dcbccf408f5f9d6055227ad4fed694e88809fa8506b0b/psutil-5.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-win32.whl","hashes":{"sha256":"0f15a19a05f39a09327345bc279c1ba4a8cfb0172cc0d3c7f7d16c813b2e7d36"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243501,"upload-time":"2022-05-20T20:10:42.164047Z","url":"https://files.pythonhosted.org/packages/85/4d/78173e3dffb74c5fa87914908f143473d0b8b9183f9d275333679a4e4649/psutil-5.9.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"db417f0865f90bdc07fa30e1aadc69b6f4cad7f86324b02aa842034efe8d8c4d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248156,"upload-time":"2022-05-20T20:10:45.327961Z","url":"https://files.pythonhosted.org/packages/73/1a/d78f2f2de2aad6628415d2a48917cabc2c7fb0c3a31c7cdf187cffa4eb36/psutil-5.9.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"91c7ff2a40c373d0cc9121d54bc5f31c4fa09c346528e6a08d1845bce5771ffc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238960,"upload-time":"2022-05-20T20:10:48.678116Z","url":"https://files.pythonhosted.org/packages/d6/ef/fd4dc9085e3879c3af63fe60667dd3b71adf50d030b5549315f4a619271b/psutil-5.9.1-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"fea896b54f3a4ae6f790ac1d017101252c93f6fe075d0e7571543510f11d2676"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278553,"upload-time":"2022-05-20T20:10:52.019471Z","url":"https://files.pythonhosted.org/packages/97/f6/0180e58dd1359da7d6fbc27d04dac6fb500dc758b6f4b65407608bb13170/psutil-5.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"3054e923204b8e9c23a55b23b6df73a8089ae1d075cb0bf711d3e9da1724ded4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281356,"upload-time":"2022-05-20T20:10:55.963864Z","url":"https://files.pythonhosted.org/packages/13/71/c25adbd9b33a2e27edbe1fc84b3111a5ad97611885d7abcbdd8d1f2bb7ca/psutil-5.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp37-cp37m-win32.whl","hashes":{"sha256":"d2d006286fbcb60f0b391741f520862e9b69f4019b4d738a2a45728c7e952f1b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242105,"upload-time":"2022-05-20T20:10:59.100543Z","url":"https://files.pythonhosted.org/packages/2a/32/136cd5bf55728ea64a22b1d817890e35fc17314c46a24ee3268b65f9076f/psutil-5.9.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"b14ee12da9338f5e5b3a3ef7ca58b3cba30f5b66f7662159762932e6d0b8f680"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246671,"upload-time":"2022-05-20T20:11:02.513602Z","url":"https://files.pythonhosted.org/packages/df/88/427f3959855fcb3ab04891e00c026a246892feb11b20433db814b7a24405/psutil-5.9.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"19f36c16012ba9cfc742604df189f2f28d2720e23ff7d1e81602dbe066be9fd1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239250,"upload-time":"2022-05-20T20:11:06.292977Z","url":"https://files.pythonhosted.org/packages/46/80/1de3a9bac336b5c8e4f7b0ff2e80c85ba237f18f2703be68884ee6798432/psutil-5.9.1-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"944c4b4b82dc4a1b805329c980f270f170fdc9945464223f2ec8e57563139cf4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281678,"upload-time":"2022-05-20T20:11:09.990719Z","url":"https://files.pythonhosted.org/packages/fd/ba/c5a3f46f351ab609cc0be6a563e492900c57e3d5c9bda0b79b84d8c3eae9/psutil-5.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4b6750a73a9c4a4e689490ccb862d53c7b976a2a35c4e1846d049dcc3f17d83b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284665,"upload-time":"2022-05-20T20:11:13.584309Z","url":"https://files.pythonhosted.org/packages/9d/41/d5f2db2ab7f5dff2fa795993a0cd6fa8a8f39ca197c3a86857875333ec10/psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp38-cp38-win32.whl","hashes":{"sha256":"a8746bfe4e8f659528c5c7e9af5090c5a7d252f32b2e859c584ef7d8efb1e689"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242461,"upload-time":"2022-05-20T20:11:16.942263Z","url":"https://files.pythonhosted.org/packages/41/ec/5fd3e9388d0ed1edfdeae71799df374f4a117932646a63413fa95a121e9f/psutil-5.9.1-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp38-cp38-win_amd64.whl","hashes":{"sha256":"79c9108d9aa7fa6fba6e668b61b82facc067a6b81517cab34d07a84aa89f3df0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246804,"upload-time":"2022-05-20T20:11:20.322459Z","url":"https://files.pythonhosted.org/packages/b2/ad/65e2b2b97677f98d718388dc11b2a9d7f177ebbae5eef72547a32bc28911/psutil-5.9.1-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"28976df6c64ddd6320d281128817f32c29b539a52bdae5e192537bc338a9ec81"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239248,"upload-time":"2022-05-20T20:11:23.352312Z","url":"https://files.pythonhosted.org/packages/9f/ca/84ce3e48b3ca2f0f74314d89929b3a523220f3f4a8dff395d6ef74dadef3/psutil-5.9.1-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b88f75005586131276634027f4219d06e0561292be8bd6bc7f2f00bdabd63c4e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279320,"upload-time":"2022-05-20T20:11:27.310813Z","url":"https://files.pythonhosted.org/packages/a9/97/b7e3532d97d527349701d2143c3f868733b94e2db6f531b07811b698f549/psutil-5.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"645bd4f7bb5b8633803e0b6746ff1628724668681a434482546887d22c7a9537"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281065,"upload-time":"2022-05-20T20:11:30.617653Z","url":"https://files.pythonhosted.org/packages/62/1f/f14225bda76417ab9bd808ff21d5cd59d5435a9796ca09b34d4cb0edcd88/psutil-5.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp39-cp39-win32.whl","hashes":{"sha256":"32c52611756096ae91f5d1499fe6c53b86f4a9ada147ee42db4991ba1520e574"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241748,"upload-time":"2022-05-20T20:11:34.374569Z","url":"https://files.pythonhosted.org/packages/b1/d2/c5374a784567c1e42ee8a589b1b42e2bd6e14c7be3c234d84360ab3a0a39/psutil-5.9.1-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp39-cp39-win_amd64.whl","hashes":{"sha256":"f65f9a46d984b8cd9b3750c2bdb419b2996895b005aefa6cbaba9a143b1ce2c5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245883,"upload-time":"2022-05-20T20:11:37.840887Z","url":"https://files.pythonhosted.org/packages/e0/ac/fd6f098969d49f046083ac032e6788d9f861903596fb9555a02bf50a1238/psutil-5.9.1-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.1.tar.gz","hashes":{"sha256":"57f1819b5d9e95cdfb0c881a8a5b7d542ed0b7c522d575706a80bedc848c8954"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":479090,"upload-time":"2022-05-20T20:11:41.043143Z","url":"https://files.pythonhosted.org/packages/d6/de/0999ea2562b96d7165812606b18f7169307b60cd378bc29cf3673322c7e9/psutil-5.9.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"8f024fbb26c8daf5d70287bb3edfafa22283c255287cf523c5d81721e8e5d82c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285739,"upload-time":"2022-09-04T20:15:28.668835Z","url":"https://files.pythonhosted.org/packages/37/a4/cb10e4c0faa3091de22eb78fa1c332566e60b9b59001bef326a4c1070417/psutil-5.9.2-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"b2f248ffc346f4f4f0d747ee1947963613216b06688be0be2e393986fe20dbbb"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289461,"upload-time":"2022-09-04T20:15:32.802519Z","url":"https://files.pythonhosted.org/packages/93/40/58dfcab15435b6fedf5385bc7e88a4c162cc6af0056f5d9d97f5ebfd7fa0/psutil-5.9.2-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"data-dist-info-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"filename":"psutil-5.9.2-cp27-cp27m-win32.whl","hashes":{"sha256":"b1928b9bf478d31fdffdb57101d18f9b70ed4e9b0e41af751851813547b2a9ab"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240036,"upload-time":"2022-09-04T20:15:36.698093Z","url":"https://files.pythonhosted.org/packages/42/eb/83470960f2c13a026b07051456ad834f5fea0c80e8cb83fc65005f5f18d5/psutil-5.9.2-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"data-dist-info-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"filename":"psutil-5.9.2-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"404f4816c16a2fcc4eaa36d7eb49a66df2d083e829d3e39ee8759a411dbc9ecf"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243378,"upload-time":"2022-09-04T20:15:40.746927Z","url":"https://files.pythonhosted.org/packages/d1/5b/b9d6ac192d3108e1dc7875ab1579b7f65eb7bf0ef799dadd3f3798d0af2e/psutil-5.9.2-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"94e621c6a4ddb2573d4d30cba074f6d1aa0186645917df42c811c473dd22b339"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285740,"upload-time":"2022-09-04T20:15:44.420732Z","url":"https://files.pythonhosted.org/packages/b6/96/ddf877440f2686eb17933531507fe4822ff1ed76d85df4a093a605b91db8/psutil-5.9.2-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"256098b4f6ffea6441eb54ab3eb64db9ecef18f6a80d7ba91549195d55420f84"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289451,"upload-time":"2022-09-04T20:15:47.573981Z","url":"https://files.pythonhosted.org/packages/d7/df/ff5c766b50350f2a4555d5068127d372bb26201a2a5eeda9efc8dbf570b4/psutil-5.9.2-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"614337922702e9be37a39954d67fdb9e855981624d8011a9927b8f2d3c9625d9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239273,"upload-time":"2022-09-04T20:15:52.215984Z","url":"https://files.pythonhosted.org/packages/04/5d/d52473097582db5d3094bc34acf9874de726327a3166426e22ed0806de6a/psutil-5.9.2-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"39ec06dc6c934fb53df10c1672e299145ce609ff0611b569e75a88f313634969"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280571,"upload-time":"2022-09-04T20:15:55.608887Z","url":"https://files.pythonhosted.org/packages/47/2b/bd12c4f2d1bd3024fe7c5d8388f8a5627cc02fbe11d62bd451aff356415d/psutil-5.9.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"e3ac2c0375ef498e74b9b4ec56df3c88be43fe56cac465627572dbfb21c4be34"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282777,"upload-time":"2022-09-04T20:15:59.840541Z","url":"https://files.pythonhosted.org/packages/4c/85/7a112fb6a8c598a6f5d079228bbc03ae84c472397be79c075e7514b6ed36/psutil-5.9.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-win32.whl","hashes":{"sha256":"e4c4a7636ffc47b7141864f1c5e7d649f42c54e49da2dd3cceb1c5f5d29bfc85"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241713,"upload-time":"2022-09-05T14:16:44.931542Z","url":"https://files.pythonhosted.org/packages/39/07/5cbcf3322031fcf8dcbfa431b1c145f193c96b18964ef374a88d6a83f2c9/psutil-5.9.2-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-win_amd64.whl","hashes":{"sha256":"f4cb67215c10d4657e320037109939b1c1d2fd70ca3d76301992f89fe2edb1f1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245853,"upload-time":"2022-09-05T14:16:48.388734Z","url":"https://files.pythonhosted.org/packages/ae/9c/d29dd82d5fda2c6c6d959d57101c78ddbac8325defe94e1b9f983e7cfff3/psutil-5.9.2-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"dc9bda7d5ced744622f157cc8d8bdd51735dafcecff807e928ff26bdb0ff097d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238998,"upload-time":"2022-09-04T20:16:03.484887Z","url":"https://files.pythonhosted.org/packages/df/aa/8268eee572fb9bdf3486d384e3973ad9d635403841c6e7f2af7781e5525b/psutil-5.9.2-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"d75291912b945a7351d45df682f9644540d564d62115d4a20d45fa17dc2d48f8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278226,"upload-time":"2022-09-04T20:16:07.134877Z","url":"https://files.pythonhosted.org/packages/f0/43/bcb92221f5dd45e155337aae37e412fe02a3e5d99e936156a4dcff89fa55/psutil-5.9.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"b4018d5f9b6651f9896c7a7c2c9f4652e4eea53f10751c4e7d08a9093ab587ec"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280489,"upload-time":"2022-09-04T20:16:10.463113Z","url":"https://files.pythonhosted.org/packages/a4/eb/d841d5bc526641aad65373b0a4850e98284580df967daff5288779090ea3/psutil-5.9.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-win32.whl","hashes":{"sha256":"f40ba362fefc11d6bea4403f070078d60053ed422255bd838cd86a40674364c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243511,"upload-time":"2022-09-05T14:16:51.624881Z","url":"https://files.pythonhosted.org/packages/54/5f/3619e7d22ded096fa6dbd329fc057bfcf53e998b1e2c1ecc07a4155175b1/psutil-5.9.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"9770c1d25aee91417eba7869139d629d6328a9422ce1cdd112bd56377ca98444"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248164,"upload-time":"2022-09-05T14:16:55.091982Z","url":"https://files.pythonhosted.org/packages/53/ac/7c4ff994b1ea7d46a84932f0c8d49e28e36a668173975876353f4ea38588/psutil-5.9.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"42638876b7f5ef43cef8dcf640d3401b27a51ee3fa137cb2aa2e72e188414c32"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238970,"upload-time":"2022-09-04T20:16:14.127339Z","url":"https://files.pythonhosted.org/packages/55/c5/fd2c45a0845e7bae07c8112ed67c21163742cc116732ac2702d9139a9a92/psutil-5.9.2-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"91aa0dac0c64688667b4285fa29354acfb3e834e1fd98b535b9986c883c2ce1d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279452,"upload-time":"2022-09-04T20:16:18.609472Z","url":"https://files.pythonhosted.org/packages/89/cf/b228a7554eda5e72fd8c33b89c628a86336e5cdbd62fe8b8d2a61a099b2d/psutil-5.9.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4fb54941aac044a61db9d8eb56fc5bee207db3bc58645d657249030e15ba3727"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281281,"upload-time":"2022-09-04T20:16:22.476894Z","url":"https://files.pythonhosted.org/packages/3d/73/d8c87b5612c58d1e6c6d91997c1590771d34e4ee27d9c11eb1e64ecbf365/psutil-5.9.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-win32.whl","hashes":{"sha256":"7cbb795dcd8ed8fd238bc9e9f64ab188f3f4096d2e811b5a82da53d164b84c3f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242115,"upload-time":"2022-09-05T14:16:58.770138Z","url":"https://files.pythonhosted.org/packages/98/42/62470fae4e1e9c0f4336acf74af9d4a6d5c6b5788c8435ec387e987a7ebe/psutil-5.9.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"5d39e3a2d5c40efa977c9a8dd4f679763c43c6c255b1340a56489955dbca767c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246680,"upload-time":"2022-09-05T14:17:03.836879Z","url":"https://files.pythonhosted.org/packages/5e/a2/4025f29069010f118eba4bcd681167d547525d40d2c45029db2f64606f86/psutil-5.9.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"fd331866628d18223a4265371fd255774affd86244fc307ef66eaf00de0633d5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239258,"upload-time":"2022-09-04T20:16:26.490949Z","url":"https://files.pythonhosted.org/packages/2b/52/c69f5d0acc4bbd3cf44178f025e498666d2eebc216f5f5725d9142244365/psutil-5.9.2-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b315febaebae813326296872fdb4be92ad3ce10d1d742a6b0c49fb619481ed0b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282623,"upload-time":"2022-09-04T20:16:29.707162Z","url":"https://files.pythonhosted.org/packages/c4/02/5fc4419f47f141ec0dd28db36fb8bcf1eb6e9df332690617b052c8bec76d/psutil-5.9.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"f7929a516125f62399d6e8e026129c8835f6c5a3aab88c3fff1a05ee8feb840d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284813,"upload-time":"2022-09-04T20:16:33.456488Z","url":"https://files.pythonhosted.org/packages/79/61/a8d6d649996494672d8a86fe8be6c81b2880ee30881709d84435f2505b47/psutil-5.9.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-win32.whl","hashes":{"sha256":"561dec454853846d1dd0247b44c2e66a0a0c490f937086930ec4b8f83bf44f06"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242471,"upload-time":"2022-09-05T14:17:07.677347Z","url":"https://files.pythonhosted.org/packages/6f/8d/41c402ae33b1ce3f8e37a0dec691d753cbe66e6784e7fd26ed0cd16d99ab/psutil-5.9.2-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-win_amd64.whl","hashes":{"sha256":"67b33f27fc0427483b61563a16c90d9f3b547eeb7af0ef1b9fe024cdc9b3a6ea"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246816,"upload-time":"2022-09-05T14:17:11.540699Z","url":"https://files.pythonhosted.org/packages/29/07/a35c4127942cce6899d447cb54f9926d33cf1800a37c09192dd9b5a08744/psutil-5.9.2-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"b3591616fa07b15050b2f87e1cdefd06a554382e72866fcc0ab2be9d116486c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239256,"upload-time":"2022-09-04T20:16:37.181485Z","url":"https://files.pythonhosted.org/packages/65/74/0ad485d753b2f0d00ee4ec933da1e169bc4c8f4f58db88132e886efed14b/psutil-5.9.2-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"14b29f581b5edab1f133563272a6011925401804d52d603c5c606936b49c8b97"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279700,"upload-time":"2022-09-04T20:16:40.816901Z","url":"https://files.pythonhosted.org/packages/bb/df/0819b9aed416b0dedf668cc6b3f291899c276cb2b566c4aa0dc212a03d55/psutil-5.9.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4642fd93785a29353d6917a23e2ac6177308ef5e8be5cc17008d885cb9f70f12"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281896,"upload-time":"2022-09-04T20:16:45.773716Z","url":"https://files.pythonhosted.org/packages/b3/61/54822666fbbdd4ae1825f7a0b0cf8925a96fac1f778b4a0d5c9c066cf4b2/psutil-5.9.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-win32.whl","hashes":{"sha256":"ed29ea0b9a372c5188cdb2ad39f937900a10fb5478dc077283bf86eeac678ef1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241759,"upload-time":"2022-09-05T14:17:15.034289Z","url":"https://files.pythonhosted.org/packages/67/cf/f620f740da5bb5895b441248e08b0cd167fb545ecaa3e74ea06f3551975e/psutil-5.9.2-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-win_amd64.whl","hashes":{"sha256":"68b35cbff92d1f7103d8f1db77c977e72f49fcefae3d3d2b91c76b0e7aef48b8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245892,"upload-time":"2022-09-05T14:17:18.376384Z","url":"https://files.pythonhosted.org/packages/10/cf/7595896a7487937c171f53bae2eeb0adcc1690ebeef684ac180a77910639/psutil-5.9.2-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.2.tar.gz","hashes":{"sha256":"feb861a10b6c3bb00701063b37e4afc754f8217f0f09c42280586bd6ac712b5c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":479757,"upload-time":"2022-09-04T20:16:49.093359Z","url":"https://files.pythonhosted.org/packages/8f/57/828ac1f70badc691a716e77bfae258ef5db76bb7830109bf4bcf882de020/psutil-5.9.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"b4a247cd3feaae39bb6085fcebf35b3b8ecd9b022db796d89c8f05067ca28e71"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241919,"upload-time":"2022-10-18T20:12:47.255096Z","url":"https://files.pythonhosted.org/packages/74/42/6268344958236744962c711664de259598fe2005e5818c7d6bc77ae12690/psutil-5.9.3-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"5fa88e3d5d0b480602553d362c4b33a63e0c40bfea7312a7bf78799e01e0810b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293266,"upload-time":"2022-10-18T20:12:51.216028Z","url":"https://files.pythonhosted.org/packages/79/6a/7bb45dddeb348cdb9d91d7bc78e903026870ef7f257c35de250392719cf8/psutil-5.9.3-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"767ef4fa33acda16703725c0473a91e1832d296c37c63896c7153ba81698f1ab"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":297585,"upload-time":"2022-10-18T20:12:54.920684Z","url":"https://files.pythonhosted.org/packages/02/c7/d5a6106cf31cc58f4a8a9d88b1ab8405b645b02c482353dd59f5ef19926f/psutil-5.9.3-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"data-dist-info-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"filename":"psutil-5.9.3-cp27-cp27m-win32.whl","hashes":{"sha256":"9a4af6ed1094f867834f5f07acd1250605a0874169a5fcadbcec864aec2496a6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240677,"upload-time":"2022-10-18T20:12:58.145019Z","url":"https://files.pythonhosted.org/packages/62/0a/27aa8d95995fe97a944939f8fff7183f151814a1052b76d125812bed4800/psutil-5.9.3-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"data-dist-info-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"filename":"psutil-5.9.3-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"fa5e32c7d9b60b2528108ade2929b115167fe98d59f89555574715054f50fa31"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244019,"upload-time":"2022-10-18T20:13:01.999625Z","url":"https://files.pythonhosted.org/packages/2b/0a/36951d279e1d716ab264b04e8ddb12e0c08cc1c7cbd44f2d22c84dc61e33/psutil-5.9.3-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"fe79b4ad4836e3da6c4650cb85a663b3a51aef22e1a829c384e18fae87e5e727"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293262,"upload-time":"2022-10-18T20:13:05.579750Z","url":"https://files.pythonhosted.org/packages/5b/9c/5412473100e3213d970c8b9291371816e57f1e4a74296b2e3b8a5c8ebb47/psutil-5.9.3-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"db8e62016add2235cc87fb7ea000ede9e4ca0aa1f221b40cef049d02d5d2593d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":297584,"upload-time":"2022-10-18T20:13:09.701506Z","url":"https://files.pythonhosted.org/packages/8f/5a/e9e98bb3ade26bc7847d5722d0e4a6d437621fa8fc02269d9cba78f6f241/psutil-5.9.3-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"941a6c2c591da455d760121b44097781bc970be40e0e43081b9139da485ad5b7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242575,"upload-time":"2022-10-18T20:13:13.343655Z","url":"https://files.pythonhosted.org/packages/95/90/822c926e170e8a5769ff11edb92ac59dd523df505b5d56cad0ef3f15c325/psutil-5.9.3-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-macosx_11_0_arm64.whl","hashes":{"sha256":"71b1206e7909792d16933a0d2c1c7f04ae196186c51ba8567abae1d041f06dcb"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243240,"upload-time":"2022-10-18T20:13:17.345095Z","url":"https://files.pythonhosted.org/packages/42/9e/243aa51c3d71355913dafc27c5cb7ffdbe9a42c939a5aace526906bfc721/psutil-5.9.3-cp310-cp310-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"f57d63a2b5beaf797b87024d018772439f9d3103a395627b77d17a8d72009543"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289285,"upload-time":"2022-10-18T20:13:20.535587Z","url":"https://files.pythonhosted.org/packages/f7/b0/6925fbfac4c342cb2f8bad1571b48e12802ac8031e1d4453a31e9a12b64d/psutil-5.9.3-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"e7507f6c7b0262d3e7b0eeda15045bf5881f4ada70473b87bc7b7c93b992a7d7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":292339,"upload-time":"2022-10-18T20:13:26.635784Z","url":"https://files.pythonhosted.org/packages/ed/2c/483ed7332d74b3fef0f5ba13c192d33f21fe95df5468a7ca040f02bd7af9/psutil-5.9.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp310-cp310-win32.whl","hashes":{"sha256":"1b540599481c73408f6b392cdffef5b01e8ff7a2ac8caae0a91b8222e88e8f1e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242906,"upload-time":"2022-10-18T20:13:30.051727Z","url":"https://files.pythonhosted.org/packages/55/07/94730401200098b1119dc9f5d3a271e3bf865b31bfa64a2b58a0bbd9d222/psutil-5.9.3-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp310-cp310-win_amd64.whl","hashes":{"sha256":"547ebb02031fdada635452250ff39942db8310b5c4a8102dfe9384ee5791e650"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247045,"upload-time":"2022-10-18T20:13:34.024950Z","url":"https://files.pythonhosted.org/packages/37/c0/8a102d4ce45dbc5d04932b52327c4385b88023635e57af9d457ca5ea6bb3/psutil-5.9.3-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"d8c3cc6bb76492133474e130a12351a325336c01c96a24aae731abf5a47fe088"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242147,"upload-time":"2022-10-18T20:13:37.172733Z","url":"https://files.pythonhosted.org/packages/61/f2/74908ddbe57863007e3b3a76f39b509bbab9892d0949f1e9d5a888f8ec60/psutil-5.9.3-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"07d880053c6461c9b89cd5d4808f3b8336665fa3acdefd6777662c5ed73a851a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286758,"upload-time":"2022-10-18T20:13:40.932526Z","url":"https://files.pythonhosted.org/packages/30/2f/696c4459864385cc5c63a21f30584dfd99d2130c21c8b3084ffbaa0edd82/psutil-5.9.3-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"5e8b50241dd3c2ed498507f87a6602825073c07f3b7e9560c58411c14fe1e1c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":290363,"upload-time":"2022-10-18T20:13:43.847649Z","url":"https://files.pythonhosted.org/packages/2c/80/2f3072492a7f14faf4f4565dd26fe1baf4b3fd28557f1427b6708064a622/psutil-5.9.3-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"data-dist-info-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"filename":"psutil-5.9.3-cp36-cp36m-win32.whl","hashes":{"sha256":"828c9dc9478b34ab96be75c81942d8df0c2bb49edbb481f597314d92b6441d89"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244701,"upload-time":"2022-10-18T20:13:47.431806Z","url":"https://files.pythonhosted.org/packages/db/e3/10363d747d900f89f7920b8e4060b42cd862b580a69a2b9c9788c4de9035/psutil-5.9.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"data-dist-info-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"filename":"psutil-5.9.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ed15edb14f52925869250b1375f0ff58ca5c4fa8adefe4883cfb0737d32f5c02"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":249356,"upload-time":"2022-10-18T20:13:51.794050Z","url":"https://files.pythonhosted.org/packages/ac/cc/092ca7ae0c5f270bb14720cd8ac86a3fafda25fae31d08d2465eed4498b3/psutil-5.9.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"d266cd05bd4a95ca1c2b9b5aac50d249cf7c94a542f47e0b22928ddf8b80d1ef"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242154,"upload-time":"2022-10-18T20:14:12.425822Z","url":"https://files.pythonhosted.org/packages/16/51/d431f7db3a3a44d9c03ec1681835a5de52d2f0bb7e28f29ecd806ccc46ec/psutil-5.9.3-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7e4939ff75149b67aef77980409f156f0082fa36accc475d45c705bb00c6c16a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287383,"upload-time":"2022-10-18T20:14:15.962130Z","url":"https://files.pythonhosted.org/packages/94/b0/cd3be14dc74a6f262b1de296841a5141a794cc485d4e3af5c1c0ffc9b886/psutil-5.9.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"68fa227c32240c52982cb931801c5707a7f96dd8927f9102d6c7771ea1ff5698"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291396,"upload-time":"2022-10-18T20:14:19.855473Z","url":"https://files.pythonhosted.org/packages/5e/86/856aa554ec7eb843fb006ef125cf4543ee9058cb39ad09d131dd820c71f7/psutil-5.9.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp37-cp37m-win32.whl","hashes":{"sha256":"beb57d8a1ca0ae0eb3d08ccaceb77e1a6d93606f0e1754f0d60a6ebd5c288837"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243306,"upload-time":"2022-10-18T20:14:23.302434Z","url":"https://files.pythonhosted.org/packages/ab/10/547feeec01275dd544a389ba05ecb3c316015d4b402cc7b440ca2d98ebcd/psutil-5.9.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"12500d761ac091f2426567f19f95fd3f15a197d96befb44a5c1e3cbe6db5752c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247870,"upload-time":"2022-10-18T20:14:26.971453Z","url":"https://files.pythonhosted.org/packages/0c/f1/50e71c11ef14c592686dfc60e2b42a381fe57af2d22713e66a72c07cf9d1/psutil-5.9.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"ba38cf9984d5462b506e239cf4bc24e84ead4b1d71a3be35e66dad0d13ded7c1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242611,"upload-time":"2022-10-18T20:14:30.842925Z","url":"https://files.pythonhosted.org/packages/01/d6/9ca99b416dddf4a49855a9ebf4af3a2db9526e94e9693da169fa5ed61788/psutil-5.9.3-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-macosx_11_0_arm64.whl","hashes":{"sha256":"46907fa62acaac364fff0b8a9da7b360265d217e4fdeaca0a2397a6883dffba2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243235,"upload-time":"2022-10-18T20:14:34.363643Z","url":"https://files.pythonhosted.org/packages/2c/ce/daf28e50305fdbba0754ba58ab0346ec6cfa41293110412f4c6bf74738bb/psutil-5.9.3-cp38-cp38-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"a04a1836894c8279e5e0a0127c0db8e198ca133d28be8a2a72b4db16f6cf99c1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291620,"upload-time":"2022-10-18T20:14:38.179697Z","url":"https://files.pythonhosted.org/packages/b9/cf/56278ae450741b6390491aecaa5f6152ff491bf00544799830e98340ff48/psutil-5.9.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"8a4e07611997acf178ad13b842377e3d8e9d0a5bac43ece9bfc22a96735d9a4f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":295598,"upload-time":"2022-10-18T20:14:41.691453Z","url":"https://files.pythonhosted.org/packages/af/5d/9c03a47af929fc12699fcf5174313744eef33a7b9e106e8111f57427b7d7/psutil-5.9.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp38-cp38-win32.whl","hashes":{"sha256":"6ced1ad823ecfa7d3ce26fe8aa4996e2e53fb49b7fed8ad81c80958501ec0619"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243663,"upload-time":"2022-10-18T20:14:45.084651Z","url":"https://files.pythonhosted.org/packages/69/3d/e1a12f505eb0171912b94e4689453639bb0deeb70ab4eddbc7b9266f819e/psutil-5.9.3-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"35feafe232d1aaf35d51bd42790cbccb882456f9f18cdc411532902370d660df"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248005,"upload-time":"2022-10-18T20:14:48.240035Z","url":"https://files.pythonhosted.org/packages/69/cf/47a028bbb4589fdc0494bc60f134c73e319ec78c86c37e2dc66fd118e4db/psutil-5.9.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"538fcf6ae856b5e12d13d7da25ad67f02113c96f5989e6ad44422cb5994ca7fc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242570,"upload-time":"2022-10-18T20:14:51.709705Z","url":"https://files.pythonhosted.org/packages/e5/64/ced1461fd5ebc944d90f9e471149991893bd7ede05b5a88069c1953738dc/psutil-5.9.3-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-macosx_11_0_arm64.whl","hashes":{"sha256":"a3d81165b8474087bb90ec4f333a638ccfd1d69d34a9b4a1a7eaac06648f9fbe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243242,"upload-time":"2022-10-18T20:14:54.641746Z","url":"https://files.pythonhosted.org/packages/ac/55/c108e74f22905382aeeef56110bd6c4b89b5fc64944d21cb83acb66faa4c/psutil-5.9.3-cp39-cp39-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"3a7826e68b0cf4ce2c1ee385d64eab7d70e3133171376cac53d7c1790357ec8f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288533,"upload-time":"2022-10-18T20:14:57.902650Z","url":"https://files.pythonhosted.org/packages/db/6f/2441388c48306f9b9d561080c6ba652b4ebd1199faac237069ec8983c8ef/psutil-5.9.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"9ec296f565191f89c48f33d9544d8d82b0d2af7dd7d2d4e6319f27a818f8d1cc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291401,"upload-time":"2022-10-18T20:15:01.503982Z","url":"https://files.pythonhosted.org/packages/03/47/15604dd812b1b860e81cabaf8c930474c549773389170cd03a093ecf54b6/psutil-5.9.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp39-cp39-win32.whl","hashes":{"sha256":"9ec95df684583b5596c82bb380c53a603bb051cf019d5c849c47e117c5064395"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242954,"upload-time":"2022-10-18T20:15:04.992990Z","url":"https://files.pythonhosted.org/packages/2f/5e/c74dab9858ca67a68a543ad8fefac2aec107383c171019b45ba9ac5223c1/psutil-5.9.3-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp39-cp39-win_amd64.whl","hashes":{"sha256":"4bd4854f0c83aa84a5a40d3b5d0eb1f3c128f4146371e03baed4589fe4f3c931"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247081,"upload-time":"2022-10-18T20:15:08.131670Z","url":"https://files.pythonhosted.org/packages/34/31/9aa19bf0fb0cecae904c9e1ac400c5704d935252515da605aa08fca2be86/psutil-5.9.3-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.3.tar.gz","hashes":{"sha256":"7ccfcdfea4fc4b0a02ca2c31de7fcd186beb9cff8207800e14ab66f79c773af6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":483579,"upload-time":"2022-10-18T20:15:11.635566Z","url":"https://files.pythonhosted.org/packages/de/eb/1c01a34c86ee3b058c556e407ce5b07cb7d186ebe47b3e69d6f152ca5cc5/psutil-5.9.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"c1ca331af862803a42677c120aff8a814a804e09832f166f226bfd22b56feee8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242993,"upload-time":"2022-11-07T18:44:23.237667Z","url":"https://files.pythonhosted.org/packages/60/f8/b92fecd5297edcecda825a04dfde7cb0a2ecd178eb976cb5a7956e375c6a/psutil-5.9.4-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"68908971daf802203f3d37e78d3f8831b6d1014864d7a85937941bb35f09aefe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":294126,"upload-time":"2022-11-07T18:44:28.809923Z","url":"https://files.pythonhosted.org/packages/8e/6b/9a3a5471b74d92dc85bfd71a7f7a55e013b258d86b4c3826ace9d49f7b8c/psutil-5.9.4-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"3ff89f9b835100a825b14c2808a106b6fdcc4b15483141482a12c725e7f78549"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":298394,"upload-time":"2022-11-07T18:44:34.503099Z","url":"https://files.pythonhosted.org/packages/1d/80/e1502ba4ff65390bd17b4612010762075f64f5a0e7c28e889c4820bd95a9/psutil-5.9.4-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"data-dist-info-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"filename":"psutil-5.9.4-cp27-cp27m-win32.whl","hashes":{"sha256":"852dd5d9f8a47169fe62fd4a971aa07859476c2ba22c2254d4a1baa4e10b95ad"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242001,"upload-time":"2022-11-07T18:44:39.844844Z","url":"https://files.pythonhosted.org/packages/53/ae/536719016fe9399187dbf52cdc65aef942f82b75924495918a2f701bcb77/psutil-5.9.4-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"data-dist-info-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"filename":"psutil-5.9.4-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"9120cd39dca5c5e1c54b59a41d205023d436799b1c8c4d3ff71af18535728e94"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245334,"upload-time":"2022-11-07T18:44:44.877461Z","url":"https://files.pythonhosted.org/packages/99/9c/7a5761f9d2e79e6f781db5b25eeb9e74c2dc533bc52ee4749cb055a32ce9/psutil-5.9.4-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"6b92c532979bafc2df23ddc785ed116fced1f492ad90a6830cf24f4d1ea27d24"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":294138,"upload-time":"2022-11-07T18:44:49.025560Z","url":"https://files.pythonhosted.org/packages/ec/be/b8df2071eda861e65a1b2cec35770bb1f4523737e84a10aa41c53e39e9bc/psutil-5.9.4-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"efeae04f9516907be44904cc7ce08defb6b665128992a56957abc9b61dca94b7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":298409,"upload-time":"2022-11-07T18:44:56.505271Z","url":"https://files.pythonhosted.org/packages/89/a8/dd2f0866a7e87de751fb5f7c6eca99cbb953c81be76e1814ab3c8c3b0908/psutil-5.9.4-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"54d5b184728298f2ca8567bf83c422b706200bcbbfafdc06718264f9393cfeb7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243468,"upload-time":"2022-11-07T18:45:00.474371Z","url":"https://files.pythonhosted.org/packages/a5/73/35cea01aad1baf901c915dc95ea33a2f271c8ff8cf2f1c73b7f591f1bdf1/psutil-5.9.4-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"16653106f3b59386ffe10e0bad3bb6299e169d5327d3f187614b1cb8f24cf2e1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":277515,"upload-time":"2022-11-07T18:45:05.428752Z","url":"https://files.pythonhosted.org/packages/5a/37/ef88eed265d93bc28c681316f68762c5e04167519e5627a0187c8878b409/psutil-5.9.4-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"54c0d3d8e0078b7666984e11b12b88af2db11d11249a8ac8920dd5ef68a66e08"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280218,"upload-time":"2022-11-07T18:45:11.831087Z","url":"https://files.pythonhosted.org/packages/6e/c8/784968329c1c67c28cce91991ef9af8a8913aa5a3399a6a8954b1380572f/psutil-5.9.4-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"data-dist-info-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"filename":"psutil-5.9.4-cp36-abi3-win32.whl","hashes":{"sha256":"149555f59a69b33f056ba1c4eb22bb7bf24332ce631c44a319cec09f876aaeff"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247217,"upload-time":"2022-11-08T11:50:03.989781Z","url":"https://files.pythonhosted.org/packages/3e/af/fe14b984e8b0f778d502d387b789d846cb2fcc3989f63be942741266d8c8/psutil-5.9.4-cp36-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"data-dist-info-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"filename":"psutil-5.9.4-cp36-abi3-win_amd64.whl","hashes":{"sha256":"fd8522436a6ada7b4aad6638662966de0d61d241cb821239b2ae7013d41a43d4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":252462,"upload-time":"2022-11-08T11:50:07.829565Z","url":"https://files.pythonhosted.org/packages/25/6e/ba97809175c90cbdcd33b470e466ebf0854d15d1506e605cc0ddd284d5b6/psutil-5.9.4-cp36-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"3c3c1d22a00986e9736611ca6121b0926aba1c13b75f0b3509aebf5f95b0d409"},"data-dist-info-metadata":{"sha256":"3c3c1d22a00986e9736611ca6121b0926aba1c13b75f0b3509aebf5f95b0d409"},"filename":"psutil-5.9.4-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"6001c809253a29599bc0dfd5179d9f8a5779f9dffea1da0f13c53ee568115e1e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244234,"upload-time":"2022-11-07T19:53:20.872251Z","url":"https://files.pythonhosted.org/packages/79/26/f026804298b933b11640cc2d15155a545805df732e5ead3a2ad7cf45a38b/psutil-5.9.4-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.4.tar.gz","hashes":{"sha256":"3d7f9739eb435d4b1338944abe23f49584bde5395f27487d2ee25ad9a8774a62"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":485825,"upload-time":"2022-11-07T19:53:36.245577Z","url":"https://files.pythonhosted.org/packages/3d/7d/d05864a69e452f003c0d77e728e155a89a2a26b09e64860ddd70ad64fb26/psutil-5.9.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"be8929ce4313f9f8146caad4272f6abb8bf99fc6cf59344a3167ecd74f4f203f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244852,"upload-time":"2023-04-17T18:24:26.646150Z","url":"https://files.pythonhosted.org/packages/3b/e4/fee119c206545fd37be1e5fa4eeb0c729a52ec2ade4f728ae1fd1acb2a3a/psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"ab8ed1a1d77c95453db1ae00a3f9c50227ebd955437bcf2a574ba8adbf6a74d5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296014,"upload-time":"2023-04-17T18:24:31.346064Z","url":"https://files.pythonhosted.org/packages/8d/24/ed6b6506f187def39887a91a68e58336eff4cf3e3d5a163ded58bee98624/psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"4aef137f3345082a3d3232187aeb4ac4ef959ba3d7c10c33dd73763fbc063da4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":300274,"upload-time":"2023-04-17T18:24:35.244779Z","url":"https://files.pythonhosted.org/packages/89/fa/ab117fa86195050802207639f5daee857791daaabe9a996935b5b77dbe10/psutil-5.9.5-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"ea8518d152174e1249c4f2a1c89e3e6065941df2fa13a1ab45327716a23c2b48"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":295979,"upload-time":"2023-04-17T18:24:38.850555Z","url":"https://files.pythonhosted.org/packages/99/f5/ec768e107445f18baa907509aaa0562a4d148a602bd97e8114d79bd6c84d/psutil-5.9.5-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"acf2aef9391710afded549ff602b5887d7a2349831ae4c26be7c807c0a39fac4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":300257,"upload-time":"2023-04-17T18:24:42.928863Z","url":"https://files.pythonhosted.org/packages/5f/da/de9d2342db0b7a96863ef84ab94ef1022eec78ece05aac253cddc494e1a7/psutil-5.9.5-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"data-dist-info-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"filename":"psutil-5.9.5-cp27-none-win32.whl","hashes":{"sha256":"5b9b8cb93f507e8dbaf22af6a2fd0ccbe8244bf30b1baad6b3954e935157ae3f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243956,"upload-time":"2023-04-17T18:24:46.410452Z","url":"https://files.pythonhosted.org/packages/cf/e3/6af6ec0cbe72f63e9a16d8b53590489e40ed0ff0c99b6a6f05d6af3bb80e/psutil-5.9.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"data-dist-info-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"filename":"psutil-5.9.5-cp27-none-win_amd64.whl","hashes":{"sha256":"8c5f7c5a052d1d567db4ddd231a9d27a74e8e4a9c3f44b1032762bd7b9fdcd42"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247338,"upload-time":"2023-04-17T18:24:49.089552Z","url":"https://files.pythonhosted.org/packages/26/f2/dcd8a3cc9c9b1fcd7576a54e3603ce4d1f85672f2687a44050340f7d47b0/psutil-5.9.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"3c6f686f4225553615612f6d9bc21f1c0e305f75d7d8454f9b46e901778e7217"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245316,"upload-time":"2023-04-17T18:24:52.864585Z","url":"https://files.pythonhosted.org/packages/9a/76/c0195c3443a725c24b3a479f57636dec89efe53d19d435d1752c5188f7de/psutil-5.9.5-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7a7dd9997128a0d928ed4fb2c2d57e5102bb6089027939f3b722f3a210f9a8da"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279398,"upload-time":"2023-04-17T18:24:56.977087Z","url":"https://files.pythonhosted.org/packages/e5/2e/56db2b45508ad484b3f22888b3e1adaaf09b8766eaa058ed0e4486c1abae/psutil-5.9.5-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"89518112647f1276b03ca97b65cc7f64ca587b1eb0278383017c2a0dcc26cbe4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282082,"upload-time":"2023-04-17T18:25:00.863664Z","url":"https://files.pythonhosted.org/packages/af/4d/389441079ecef400e2551a3933224885a7bde6b8a4810091d628cdd75afe/psutil-5.9.5-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-win32.whl","hashes":{"sha256":"104a5cc0e31baa2bcf67900be36acde157756b9c44017b86b2c049f11957887d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":249834,"upload-time":"2023-04-17T18:25:05.571829Z","url":"https://files.pythonhosted.org/packages/fa/e0/e91277b1cabf5c3f2995c22314553f1be68b17444260101f365c5a5b6ba1/psutil-5.9.5-cp36-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-win_amd64.whl","hashes":{"sha256":"b258c0c1c9d145a1d5ceffab1134441c4c5113b2417fafff7315a917a026c3c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":255148,"upload-time":"2023-04-17T18:25:09.779955Z","url":"https://files.pythonhosted.org/packages/86/f3/23e4e4e7ec7855d506ed928756b04735c246b14d9f778ed7ffaae18d8043/psutil-5.9.5-cp36-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2ae643bfca9fa3b942bf775226368a8ef859018ea312be94e137a8511ba0da07"},"data-dist-info-metadata":{"sha256":"2ae643bfca9fa3b942bf775226368a8ef859018ea312be94e137a8511ba0da07"},"filename":"psutil-5.9.5-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"c607bb3b57dc779d55e1554846352b4e358c10fff3abf3514a7a6601beebdb30"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246094,"upload-time":"2023-04-17T18:25:14.584295Z","url":"https://files.pythonhosted.org/packages/ed/98/2624954f83489ab13fde2b544baa337d5578c07eee304d320d9ba56e1b1f/psutil-5.9.5-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.5.tar.gz","hashes":{"sha256":"5410638e4df39c54d957fc51ce03048acd8e6d60abc0f5107af51e5fb566eb3c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":493489,"upload-time":"2023-04-17T18:25:18.787463Z","url":"https://files.pythonhosted.org/packages/d6/0f/96b7309212a926c1448366e9ce69b081ea79d63265bde33f11cc9cfc2c07/psutil-5.9.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"fb8a697f11b0f5994550555fcfe3e69799e5b060c8ecf9e2f75c69302cc35c0d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245665,"upload-time":"2023-10-15T09:08:50.362285Z","url":"https://files.pythonhosted.org/packages/84/d6/7e23b2b208db3953f630934bc0e9c1736a0a831a781acf8c5891c27b29cf/psutil-5.9.6-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"91ecd2d9c00db9817a4b4192107cf6954addb5d9d67a969a4f436dbc9200f88c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":297167,"upload-time":"2023-10-15T09:08:52.370112Z","url":"https://files.pythonhosted.org/packages/d2/76/f154e5169756f3d18da160359a404f49f476756809ef21a79afdd0d5b552/psutil-5.9.6-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"10e8c17b4f898d64b121149afb136c53ea8b68c7531155147867b7b1ac9e7e28"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":301338,"upload-time":"2023-10-15T09:08:55.187829Z","url":"https://files.pythonhosted.org/packages/35/e8/5cc0e149ec32a91d459fbe51d0ce3c2dd7f8d67bc1400803ff810247d6dc/psutil-5.9.6-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"18cd22c5db486f33998f37e2bb054cc62fd06646995285e02a51b1e08da97017"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":297167,"upload-time":"2023-10-15T09:08:57.863175Z","url":"https://files.pythonhosted.org/packages/8d/f7/074071fa91dab747c8d1fe2eb74da439b3712248d6b254ba0136ada8694f/psutil-5.9.6-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"ca2780f5e038379e520281e4c032dddd086906ddff9ef0d1b9dcf00710e5071c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":301350,"upload-time":"2023-10-15T09:09:00.411072Z","url":"https://files.pythonhosted.org/packages/4a/65/557545149422a7845248641c1c35a0c8ea940c838896320f774072e16523/psutil-5.9.6-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"data-dist-info-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"filename":"psutil-5.9.6-cp27-none-win32.whl","hashes":{"sha256":"70cb3beb98bc3fd5ac9ac617a327af7e7f826373ee64c80efd4eb2856e5051e9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":244900,"upload-time":"2023-10-15T09:09:03.051464Z","url":"https://files.pythonhosted.org/packages/b8/23/d5d9e20c4ae7374abe1f826c69ecf2ab52f93827ca2b92c2c51f9aeb9226/psutil-5.9.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"data-dist-info-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"filename":"psutil-5.9.6-cp27-none-win_amd64.whl","hashes":{"sha256":"51dc3d54607c73148f63732c727856f5febec1c7c336f8f41fcbd6315cce76ac"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248205,"upload-time":"2023-10-15T09:09:05.456917Z","url":"https://files.pythonhosted.org/packages/7a/5e/db765b94cb620c04aaea0cb03d8b589905e50ec278130d25646eead8dff0/psutil-5.9.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c69596f9fc2f8acd574a12d5f8b7b1ba3765a641ea5d60fb4736bf3c08a8214a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246101,"upload-time":"2023-10-15T09:09:08.012635Z","url":"https://files.pythonhosted.org/packages/f8/36/35b12441ba1bc6684c9215191f955415196ca57ca85d88e313bec7f2cf8e/psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"92e0cc43c524834af53e9d3369245e6cc3b130e78e26100d1f63cdb0abeb3d3c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":280854,"upload-time":"2023-10-15T09:09:09.832401Z","url":"https://files.pythonhosted.org/packages/61/c8/e684dea1912943347922ab5c05efc94b4ff3d7470038e8afbe3941ef9efe/psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"748c9dd2583ed86347ed65d0035f45fa8c851e8d90354c122ab72319b5f366f4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":283614,"upload-time":"2023-10-15T09:09:12.314910Z","url":"https://files.pythonhosted.org/packages/19/06/4e3fa3c1b79271e933c5ddbad3a48aa2c3d5f592a0fb7c037f3e0f619f4d/psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-cp36m-win32.whl","hashes":{"sha256":"3ebf2158c16cc69db777e3c7decb3c0f43a7af94a60d72e87b2823aebac3d602"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":250445,"upload-time":"2023-10-15T09:09:14.942143Z","url":"https://files.pythonhosted.org/packages/3f/63/d4a8dace1756b9c84b94683aa80ed0ba8fc7a4421904933b472d59268976/psutil-5.9.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ff18b8d1a784b810df0b0fff3bcb50ab941c3b8e2c8de5726f9c71c601c611aa"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255893,"upload-time":"2023-10-15T09:09:17.467925Z","url":"https://files.pythonhosted.org/packages/ad/00/c87d449746f8962eb9203554b46ab7dcf243be236dcf007372902791b374/psutil-5.9.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"data-dist-info-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"filename":"psutil-5.9.6-cp37-abi3-win32.whl","hashes":{"sha256":"a6f01f03bf1843280f4ad16f4bde26b817847b4c1a0db59bf6419807bc5ce05c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248489,"upload-time":"2023-10-15T09:09:19.912001Z","url":"https://files.pythonhosted.org/packages/06/ac/f31a0faf98267e63fc6ed046ad2aca68bd79521380026e92fd4921c869aa/psutil-5.9.6-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"data-dist-info-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"filename":"psutil-5.9.6-cp37-abi3-win_amd64.whl","hashes":{"sha256":"6e5fb8dc711a514da83098bc5234264e551ad980cec5f85dabf4d38ed6f15e9a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":252327,"upload-time":"2023-10-15T09:09:32.052033Z","url":"https://files.pythonhosted.org/packages/c5/b2/699c50fe0b0402a1ccb64ad71313bcb740e735008dd3ab9abeddbe148e45/psutil-5.9.6-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7298b90db12439da117e2817e35cbbb00312edeb4f885274cd1135a533903d6c"},"data-dist-info-metadata":{"sha256":"7298b90db12439da117e2817e35cbbb00312edeb4f885274cd1135a533903d6c"},"filename":"psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"daecbcbd29b289aac14ece28eca6a3e60aa361754cf6da3dfb20d4d32b6c7f57"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246859,"upload-time":"2023-10-15T09:09:34.494297Z","url":"https://files.pythonhosted.org/packages/9e/cb/e4b83c27eea66bc255effc967053f6fce7c14906dd9b43a348ead9f0cfea/psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.6.tar.gz","hashes":{"sha256":"e4b92ddcd7dd4cdd3f900180ea1e104932c7bce234fb88976e2a3b296441225a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":496866,"upload-time":"2023-10-15T09:08:46.623978Z","url":"https://files.pythonhosted.org/packages/2d/01/beb7331fc6c8d1c49dd051e3611379bfe379e915c808e1301506027fce9d/psutil-5.9.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"0bd41bf2d1463dfa535942b2a8f0e958acf6607ac0be52265ab31f7923bcd5e6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245542,"upload-time":"2023-12-17T11:25:25.875219Z","url":"https://files.pythonhosted.org/packages/3e/16/c86fcf73f02bd0a3d49b0dcabc8ebd4020647be2ea40ff668f717587af97/psutil-5.9.7-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"5794944462509e49d4d458f4dbfb92c47539e7d8d15c796f141f474010084056"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312042,"upload-time":"2023-12-17T11:25:29.439835Z","url":"https://files.pythonhosted.org/packages/93/fc/e45a8e9b2acd54fe80ededa2f7b19de21e776f64e00437417c16c3e139d9/psutil-5.9.7-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"fe361f743cb3389b8efda21980d93eb55c1f1e3898269bc9a2a1d0bb7b1f6508"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312681,"upload-time":"2023-12-17T11:25:33.024609Z","url":"https://files.pythonhosted.org/packages/d7/43/dd7034a3a3a900e95b9dcf47ee710680cfd11a224ab18b31c34370da36a8/psutil-5.9.7-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"e469990e28f1ad738f65a42dcfc17adaed9d0f325d55047593cb9033a0ab63df"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312066,"upload-time":"2023-12-17T11:25:37.010306Z","url":"https://files.pythonhosted.org/packages/ff/ea/a47eecddcd97d65b496ac655c9f9ba8af270c203d5ea1630273cfc5ec740/psutil-5.9.7-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"3c4747a3e2ead1589e647e64aad601981f01b68f9398ddf94d01e3dc0d1e57c7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312684,"upload-time":"2023-12-17T11:25:39.891899Z","url":"https://files.pythonhosted.org/packages/cd/ee/d946d0b758120e724d9cdd9607c304ff1eedb9380bf60597c295dc7def6b/psutil-5.9.7-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"data-dist-info-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"filename":"psutil-5.9.7-cp27-none-win32.whl","hashes":{"sha256":"1d4bc4a0148fdd7fd8f38e0498639ae128e64538faa507df25a20f8f7fb2341c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":244785,"upload-time":"2023-12-17T11:25:42.761256Z","url":"https://files.pythonhosted.org/packages/98/c5/6773a3f1c384ac4863665e167cd4da72433b3020580c0b7c6a7b497e11e2/psutil-5.9.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"data-dist-info-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"filename":"psutil-5.9.7-cp27-none-win_amd64.whl","hashes":{"sha256":"4c03362e280d06bbbfcd52f29acd79c733e0af33d707c54255d21029b8b32ba6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248087,"upload-time":"2023-12-17T11:25:45.316036Z","url":"https://files.pythonhosted.org/packages/2d/91/40ac017db38c9f7f325385dd0dab1be3d4c65e3291100e74d5d7b6a213e8/psutil-5.9.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"ea36cc62e69a13ec52b2f625c27527f6e4479bca2b340b7a452af55b34fcbe2e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245972,"upload-time":"2023-12-17T11:25:48.202730Z","url":"https://files.pythonhosted.org/packages/6c/63/86a4ccc640b4ee1193800f57bbd20b766853c0cdbdbb248a27cdfafe6cbf/psutil-5.9.7-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"1132704b876e58d277168cd729d64750633d5ff0183acf5b3c986b8466cd0284"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":282514,"upload-time":"2023-12-17T11:25:51.371460Z","url":"https://files.pythonhosted.org/packages/58/80/cc6666b3968646f2d94de66bbc63d701d501f4aa04de43dd7d1f5dc477dd/psutil-5.9.7-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"fe8b7f07948f1304497ce4f4684881250cd859b16d06a1dc4d7941eeb6233bfe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":285469,"upload-time":"2023-12-17T11:25:54.250669Z","url":"https://files.pythonhosted.org/packages/be/fa/f1f626620e3b47e6237dcc64cb8cc1472f139e99422e5b9fa5bbcf457f48/psutil-5.9.7-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-cp36m-win32.whl","hashes":{"sha256":"b27f8fdb190c8c03914f908a4555159327d7481dac2f01008d483137ef3311a9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":250357,"upload-time":"2023-12-17T12:38:23.681291Z","url":"https://files.pythonhosted.org/packages/63/16/11dfb52cdccd561da711ee2c127b4c0bd2baf4736d10828c707694f31b90/psutil-5.9.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"44969859757f4d8f2a9bd5b76eba8c3099a2c8cf3992ff62144061e39ba8568e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255808,"upload-time":"2023-12-17T12:38:34.170079Z","url":"https://files.pythonhosted.org/packages/0e/88/9b74b25c63b91ff0403a1b89e258238380b4a88e4116cbae4eaadbb4c17a/psutil-5.9.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"data-dist-info-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"filename":"psutil-5.9.7-cp37-abi3-win32.whl","hashes":{"sha256":"c727ca5a9b2dd5193b8644b9f0c883d54f1248310023b5ad3e92036c5e2ada68"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248406,"upload-time":"2023-12-17T12:38:50.326952Z","url":"https://files.pythonhosted.org/packages/7c/b8/dc6ebfc030b47cccc5f5229eeb15e64142b4782796c3ce169ccd60b4d511/psutil-5.9.7-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"data-dist-info-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"filename":"psutil-5.9.7-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f37f87e4d73b79e6c5e749440c3113b81d1ee7d26f21c19c47371ddea834f414"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":252245,"upload-time":"2023-12-17T12:39:00.686632Z","url":"https://files.pythonhosted.org/packages/50/28/92b74d95dd991c837813ffac0c79a581a3d129eb0fa7c1dd616d9901e0f3/psutil-5.9.7-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c6272489f71a5b9474dff03296e3f8e100ef6f8ed990f7e4ef444ac6e6a3d6fb"},"data-dist-info-metadata":{"sha256":"c6272489f71a5b9474dff03296e3f8e100ef6f8ed990f7e4ef444ac6e6a3d6fb"},"filename":"psutil-5.9.7-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"032f4f2c909818c86cea4fe2cc407f1c0f0cde8e6c6d702b28b8ce0c0d143340"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246739,"upload-time":"2023-12-17T11:25:57.305436Z","url":"https://files.pythonhosted.org/packages/ba/8a/000d0e80156f0b96c55bda6c60f5ed6543d7b5e893ccab83117e50de1400/psutil-5.9.7-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.7.tar.gz","hashes":{"sha256":"3f02134e82cfb5d089fddf20bb2e03fd5cd52395321d1c8458a9e58500ff417c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":498429,"upload-time":"2023-12-17T11:25:21.220127Z","url":"https://files.pythonhosted.org/packages/a0/d0/c9ae661a302931735237791f04cb7086ac244377f78692ba3b3eae3a9619/psutil-5.9.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248274,"upload-time":"2024-01-19T20:47:14.006890Z","url":"https://files.pythonhosted.org/packages/15/9a/c3e2922e2d672bafd37cf3b9681097c350463cdcf0e286e907ddd6cfb014/psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":314796,"upload-time":"2024-01-19T20:47:17.872998Z","url":"https://files.pythonhosted.org/packages/62/e6/6d62285989d53a83def28ea49b46d3e00462d1273c7c47d9678ee28a0a39/psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":315422,"upload-time":"2024-01-19T20:47:21.442877Z","url":"https://files.pythonhosted.org/packages/38/ba/41815f353f79374c1ad82aba998c666c7209793daf12f4799cfaa7302f29/psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":314802,"upload-time":"2024-01-19T20:47:24.219052Z","url":"https://files.pythonhosted.org/packages/a8/2f/ad80cc502c452e1f207307a7d53533505ca47c503ec6e9f7e2c9fbb367e8/psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":315420,"upload-time":"2024-01-19T20:47:26.828052Z","url":"https://files.pythonhosted.org/packages/e4/c3/357a292dee683282f7a46b752a76c5d56c78bf8f5d9def0ca0d39073344a/psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"data-dist-info-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"filename":"psutil-5.9.8-cp27-none-win32.whl","hashes":{"sha256":"36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248660,"upload-time":"2024-01-19T20:47:29.706532Z","url":"https://files.pythonhosted.org/packages/fe/5f/c26deb822fd3daf8fde4bdb658bf87d9ab1ffd3fca483816e89a9a9a9084/psutil-5.9.8-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"data-dist-info-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"filename":"psutil-5.9.8-cp27-none-win_amd64.whl","hashes":{"sha256":"bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":251966,"upload-time":"2024-01-19T20:47:33.134054Z","url":"https://files.pythonhosted.org/packages/32/1d/cf66073d74d6146187e2d0081a7616df4437214afa294ee4f16f80a2f96a/psutil-5.9.8-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248702,"upload-time":"2024-01-19T20:47:36.303498Z","url":"https://files.pythonhosted.org/packages/e7/e3/07ae864a636d70a8a6f58da27cb1179192f1140d5d1da10886ade9405797/psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":285242,"upload-time":"2024-01-19T20:47:39.650099Z","url":"https://files.pythonhosted.org/packages/b3/bd/28c5f553667116b2598b9cc55908ec435cb7f77a34f2bff3e3ca765b0f78/psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":288191,"upload-time":"2024-01-19T20:47:43.078208Z","url":"https://files.pythonhosted.org/packages/c5/4f/0e22aaa246f96d6ac87fe5ebb9c5a693fbe8877f537a1022527c47ca43c5/psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-cp36m-win32.whl","hashes":{"sha256":"7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":253203,"upload-time":"2024-01-19T20:47:46.133427Z","url":"https://files.pythonhosted.org/packages/dd/9e/85c3bd5b466d96c091bbd6339881e99106adb43d5d60bde32ac181ab6fef/psutil-5.9.8-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":258655,"upload-time":"2024-01-19T20:47:48.804624Z","url":"https://files.pythonhosted.org/packages/0b/58/bcffb5ab03ec558e565d2871c01215dde74e11f583fb71e7d2b107200caa/psutil-5.9.8-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"data-dist-info-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"filename":"psutil-5.9.8-cp37-abi3-win32.whl","hashes":{"sha256":"bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":251252,"upload-time":"2024-01-19T20:47:52.880124Z","url":"https://files.pythonhosted.org/packages/6e/f5/2aa3a4acdc1e5940b59d421742356f133185667dd190b166dbcfcf5d7b43/psutil-5.9.8-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"data-dist-info-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"filename":"psutil-5.9.8-cp37-abi3-win_amd64.whl","hashes":{"sha256":"8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255090,"upload-time":"2024-01-19T20:47:56.019799Z","url":"https://files.pythonhosted.org/packages/93/52/3e39d26feae7df0aa0fd510b14012c3678b36ed068f7d78b8d8784d61f0e/psutil-5.9.8-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1526b4912f0f04a9c6523b41c128f4d1c6c666fbbdccb62c6705d7e5747c95cc"},"data-dist-info-metadata":{"sha256":"1526b4912f0f04a9c6523b41c128f4d1c6c666fbbdccb62c6705d7e5747c95cc"},"filename":"psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":249898,"upload-time":"2024-01-19T20:47:59.238740Z","url":"https://files.pythonhosted.org/packages/05/33/2d74d588408caedd065c2497bdb5ef83ce6082db01289a1e1147f6639802/psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.8.tar.gz","hashes":{"sha256":"6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":503247,"upload-time":"2024-01-19T20:47:09.517227Z","url":"https://files.pythonhosted.org/packages/90/c7/6dc0a455d111f68ee43f27793971cf03fe29b6ef972042549db29eec39a2/psutil-5.9.8.tar.gz","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250527,"upload-time":"2024-06-18T21:40:17.061973Z","url":"https://files.pythonhosted.org/packages/13/e5/35ebd7169008752be5561cafdba3f1634be98193b85fe3d22e883f9fe2e1/psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":316838,"upload-time":"2024-06-18T21:40:32.679396Z","url":"https://files.pythonhosted.org/packages/92/a7/083388ef0964a6d74df51c677b3d761e0866d823d37e3a8823551c0d375d/psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":317493,"upload-time":"2024-06-18T21:40:41.710402Z","url":"https://files.pythonhosted.org/packages/52/2f/44b7005f306ea8bfd24aa662b5d0ba6ea1daf29dbd0b6c7bbcd3606373ad/psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":316855,"upload-time":"2024-06-18T21:40:47.752750Z","url":"https://files.pythonhosted.org/packages/81/c9/8cb36769b6636d817be3414ebbb27a9ab3fbe6d13835d00f31e77e1fccce/psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":317519,"upload-time":"2024-06-18T21:40:53.708954Z","url":"https://files.pythonhosted.org/packages/14/c0/024ac5369ca160e9ed45ed09247d9d779c460017fbd9aa801fd6eb0f060c/psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"data-dist-info-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"filename":"psutil-6.0.0-cp27-none-win32.whl","hashes":{"sha256":"02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":249766,"upload-time":"2024-06-18T21:40:58.381272Z","url":"https://files.pythonhosted.org/packages/c5/66/78c9c3020f573c58101dc43a44f6855d01bbbd747e24da2f0c4491200ea3/psutil-6.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"data-dist-info-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"filename":"psutil-6.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":253024,"upload-time":"2024-06-18T21:41:04.548455Z","url":"https://files.pythonhosted.org/packages/e1/3f/2403aa9558bea4d3854b0e5e567bc3dd8e9fbc1fc4453c0aa9aafeb75467/psutil-6.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250961,"upload-time":"2024-06-18T21:41:11.662513Z","url":"https://files.pythonhosted.org/packages/0b/37/f8da2fbd29690b3557cca414c1949f92162981920699cd62095a984983bf/psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287478,"upload-time":"2024-06-18T21:41:16.180526Z","url":"https://files.pythonhosted.org/packages/35/56/72f86175e81c656a01c4401cd3b1c923f891b31fbcebe98985894176d7c9/psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":290455,"upload-time":"2024-06-18T21:41:29.048203Z","url":"https://files.pythonhosted.org/packages/19/74/f59e7e0d392bc1070e9a70e2f9190d652487ac115bb16e2eff6b22ad1d24/psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":292046,"upload-time":"2024-06-18T21:41:33.530555Z","url":"https://files.pythonhosted.org/packages/cd/5f/60038e277ff0a9cc8f0c9ea3d0c5eb6ee1d2470ea3f9389d776432888e47/psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-cp36m-win32.whl","hashes":{"sha256":"fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":255537,"upload-time":"2024-06-18T21:41:38.034852Z","url":"https://files.pythonhosted.org/packages/cd/ff/39c38910cdb8f02fc9965afb520967a1e9307d53d14879dddd0a4f41f6f8/psutil-6.0.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":260973,"upload-time":"2024-06-18T21:41:41.566213Z","url":"https://files.pythonhosted.org/packages/08/88/16dd53af4a84e719e27a5ad7db040231415d8caeb48f019bacafbb4d0002/psutil-6.0.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"data-dist-info-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"filename":"psutil-6.0.0-cp37-abi3-win32.whl","hashes":{"sha256":"a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":253560,"upload-time":"2024-06-18T21:41:46.067057Z","url":"https://files.pythonhosted.org/packages/8b/20/2ff69ad9c35c3df1858ac4e094f20bd2374d33c8643cf41da8fd7cdcb78b/psutil-6.0.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"data-dist-info-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"filename":"psutil-6.0.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":257399,"upload-time":"2024-06-18T21:41:52.100137Z","url":"https://files.pythonhosted.org/packages/73/44/561092313ae925f3acfaace6f9ddc4f6a9c748704317bad9c8c8f8a36a79/psutil-6.0.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c0710bf31d8e9160c90747acceb7692596b32d632efd784e22990fc01fad42dd"},"data-dist-info-metadata":{"sha256":"c0710bf31d8e9160c90747acceb7692596b32d632efd784e22990fc01fad42dd"},"filename":"psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":251988,"upload-time":"2024-06-18T21:41:57.337231Z","url":"https://files.pythonhosted.org/packages/7c/06/63872a64c312a24fb9b4af123ee7007a306617da63ff13bcc1432386ead7/psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.0.0.tar.gz","hashes":{"sha256":"8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508067,"upload-time":"2024-06-18T21:40:10.559591Z","url":"https://files.pythonhosted.org/packages/18/c7/8c6872f7372eb6a6b2e4708b88419fb46b857f7a2e1892966b851cc79fc9/psutil-6.0.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"ff34df86226c0227c52f38b919213157588a678d049688eded74c76c8ba4a5d0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247385,"upload-time":"2024-10-17T21:31:49.162372Z","url":"https://files.pythonhosted.org/packages/cd/8e/87b51bedb52f0fa02a6c9399702912a5059b24c7242fa8ea4fd027cb5238/psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"c0e0c00aa18ca2d3b2b991643b799a15fc8f0563d2ebb6040f64ce8dc027b942"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312067,"upload-time":"2024-10-17T21:31:51.572046Z","url":"https://files.pythonhosted.org/packages/2c/56/99304ecbf1f25a2aa336c66e43a8f9462de70d089d3fbb487991dfd96b37/psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"000d1d1ebd634b4efb383f4034437384e44a6d455260aaee2eca1e9c1b55f047"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312345,"upload-time":"2024-10-17T21:31:53.950865Z","url":"https://files.pythonhosted.org/packages/24/87/7c1eeb2fd86a8eb792b15438a3d25eda05c970924df3457669b50e0c022b/psutil-6.1.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"5cd2bcdc75b452ba2e10f0e8ecc0b57b827dd5d7aaffbc6821b2a9a242823a76"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312058,"upload-time":"2024-10-17T21:31:55.843636Z","url":"https://files.pythonhosted.org/packages/aa/fe/c94a914040c74b2bbe2ddb2c82b3f9a74d8a40401bb1239b0e949331c957/psutil-6.1.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"045f00a43c737f960d273a83973b2511430d61f283a44c96bf13a6e829ba8fdc"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312330,"upload-time":"2024-10-17T21:31:57.551704Z","url":"https://files.pythonhosted.org/packages/44/8c/624823d5a5a9ec8635d63b273c3ab1554a4fcc3513f4d0236ff9706f1025/psutil-6.1.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"data-dist-info-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"filename":"psutil-6.1.0-cp27-none-win32.whl","hashes":{"sha256":"9118f27452b70bb1d9ab3198c1f626c2499384935aaf55388211ad982611407e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":246648,"upload-time":"2024-10-17T21:31:59.369185Z","url":"https://files.pythonhosted.org/packages/da/2b/f4dea5d993d9cd22ad958eea828a41d5d225556123d372f02547c29c4f97/psutil-6.1.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"data-dist-info-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"filename":"psutil-6.1.0-cp27-none-win_amd64.whl","hashes":{"sha256":"a8506f6119cff7015678e2bce904a4da21025cc70ad283a53b099e7620061d85"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":249905,"upload-time":"2024-10-17T21:32:01.974050Z","url":"https://files.pythonhosted.org/packages/9f/14/4aa97a7f2e0ac33a050d990ab31686d651ae4ef8c86661fef067f00437b9/psutil-6.1.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247762,"upload-time":"2024-10-17T21:32:05.991637Z","url":"https://files.pythonhosted.org/packages/01/9e/8be43078a171381953cfee33c07c0d628594b5dbfc5157847b85022c2c1b/psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"31aa42573bd48a390acf1e517f08ce9f05a4954542dc8afb9a8805655df7aa18"},"data-dist-info-metadata":{"sha256":"31aa42573bd48a390acf1e517f08ce9f05a4954542dc8afb9a8805655df7aa18"},"filename":"psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":248777,"upload-time":"2024-10-17T21:32:07.872442Z","url":"https://files.pythonhosted.org/packages/1d/cb/313e80644ea407f04f6602a9e23096540d9dc1878755f3952ea8d3d104be/psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":284259,"upload-time":"2024-10-17T21:32:10.177301Z","url":"https://files.pythonhosted.org/packages/65/8e/bcbe2025c587b5d703369b6a75b65d41d1367553da6e3f788aff91eaf5bd/psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287255,"upload-time":"2024-10-17T21:32:11.964687Z","url":"https://files.pythonhosted.org/packages/58/4d/8245e6f76a93c98aab285a43ea71ff1b171bcd90c9d238bf81f7021fb233/psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":288804,"upload-time":"2024-10-17T21:32:13.785068Z","url":"https://files.pythonhosted.org/packages/27/c2/d034856ac47e3b3cdfa9720d0e113902e615f4190d5d1bdb8df4b2015fb2/psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"data-dist-info-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"filename":"psutil-6.1.0-cp36-cp36m-win32.whl","hashes":{"sha256":"6d3fbbc8d23fcdcb500d2c9f94e07b1342df8ed71b948a2649b5cb060a7c94ca"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":252360,"upload-time":"2024-10-17T21:32:16.434334Z","url":"https://files.pythonhosted.org/packages/43/39/414d7b67f4df35bb9c373d0fb9a75dd40b223d9bd6d02ebdc7658fd461a3/psutil-6.1.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"data-dist-info-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"filename":"psutil-6.1.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1209036fbd0421afde505a4879dee3b2fd7b1e14fee81c0069807adcbbcca747"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":257797,"upload-time":"2024-10-17T21:32:18.946615Z","url":"https://files.pythonhosted.org/packages/ca/da/ef86c99e33be4aa888570e79350caca8c4819b62f84a6d9274c88c40e331/psutil-6.1.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"data-dist-info-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"filename":"psutil-6.1.0-cp37-abi3-win32.whl","hashes":{"sha256":"1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250386,"upload-time":"2024-10-17T21:32:21.399329Z","url":"https://files.pythonhosted.org/packages/ea/55/5389ed243c878725feffc0d6a3bc5ef6764312b6fc7c081faaa2cfa7ef37/psutil-6.1.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"data-dist-info-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"filename":"psutil-6.1.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":254228,"upload-time":"2024-10-17T21:32:23.880601Z","url":"https://files.pythonhosted.org/packages/11/91/87fa6f060e649b1e1a7b19a4f5869709fbf750b7c8c262ee776ec32f3028/psutil-6.1.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.1.0.tar.gz","hashes":{"sha256":"353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508565,"upload-time":"2024-10-17T21:31:45.680545Z","url":"https://files.pythonhosted.org/packages/26/10/2a30b13c61e7cf937f4adf90710776b7918ed0a9c434e2c38224732af310/psutil-6.1.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"9ccc4316f24409159897799b83004cb1e24f9819b0dcf9c0b68bdcb6cefee6a8"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247226,"upload-time":"2024-12-19T18:21:25.276122Z","url":"https://files.pythonhosted.org/packages/09/ea/f8844afff4c8c11d1d0586b737d8d579fd7cb13f1fa3eea599c71877b526/psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"ca9609c77ea3b8481ab005da74ed894035936223422dc591d6772b147421f777"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312292,"upload-time":"2024-12-19T18:21:30.930117Z","url":"https://files.pythonhosted.org/packages/51/f8/e376f9410beb915bbf64cb4ae8ce5cf2d03e9a661a2519ebc6a63045a1ca/psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"8df0178ba8a9e5bc84fed9cfa61d54601b371fbec5c8eebad27575f1e105c0d4"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312542,"upload-time":"2024-12-19T18:21:34.735400Z","url":"https://files.pythonhosted.org/packages/a7/3a/069d6c1e4a7af3cdb162c9ba0737ff9baed1d05cbab6f082f49e3b9ab0a5/psutil-6.1.1-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"1924e659d6c19c647e763e78670a05dbb7feaf44a0e9c94bf9e14dfc6ba50468"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312279,"upload-time":"2024-12-19T18:21:37.897094Z","url":"https://files.pythonhosted.org/packages/81/d5/ee5de2cb8d0c938bb07dcccd4ff7e950359bd6ddbd2fe3118552f863bb52/psutil-6.1.1-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"018aeae2af92d943fdf1da6b58665124897cfc94faa2ca92098838f83e1b1bca"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312521,"upload-time":"2024-12-19T18:21:40.651860Z","url":"https://files.pythonhosted.org/packages/37/98/443eff82762b3f2c6a4bd0cdf3bc5c9f62245376c5486b39ee194e920794/psutil-6.1.1-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"data-dist-info-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"filename":"psutil-6.1.1-cp27-none-win32.whl","hashes":{"sha256":"6d4281f5bbca041e2292be3380ec56a9413b790579b8e593b1784499d0005dac"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":246855,"upload-time":"2024-12-19T18:54:12.657947Z","url":"https://files.pythonhosted.org/packages/d2/d4/8095b53c4950f44dc99b8d983b796f405ae1f58d80978fcc0421491b4201/psutil-6.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"data-dist-info-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"filename":"psutil-6.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"c777eb75bb33c47377c9af68f30e9f11bc78e0f07fbf907be4a5d70b2fe5f030"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250110,"upload-time":"2024-12-19T18:54:16.635901Z","url":"https://files.pythonhosted.org/packages/b1/63/0b6425ea4f2375988209a9934c90d6079cc7537847ed58a28fbe30f4277e/psutil-6.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247511,"upload-time":"2024-12-19T18:21:45.163741Z","url":"https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"f53aa914fe0e63af2de701b5d7b1c28a494b1852f4eddac6bec1c1d8eecc00d7"},"data-dist-info-metadata":{"sha256":"f53aa914fe0e63af2de701b5d7b1c28a494b1852f4eddac6bec1c1d8eecc00d7"},"filename":"psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":248985,"upload-time":"2024-12-19T18:21:49.254078Z","url":"https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":284488,"upload-time":"2024-12-19T18:21:51.638630Z","url":"https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287477,"upload-time":"2024-12-19T18:21:55.306984Z","url":"https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":289017,"upload-time":"2024-12-19T18:21:57.875754Z","url":"https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"data-dist-info-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"filename":"psutil-6.1.1-cp36-cp36m-win32.whl","hashes":{"sha256":"384636b1a64b47814437d1173be1427a7c83681b17a450bfc309a1953e329603"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":252576,"upload-time":"2024-12-19T18:22:01.852822Z","url":"https://files.pythonhosted.org/packages/8e/1f/1aebe4dd5914ccba6f7d6cc6d11fb79f6f23f95b858a7f631446bdc5d67f/psutil-6.1.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"data-dist-info-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"filename":"psutil-6.1.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"8be07491f6ebe1a693f17d4f11e69d0dc1811fa082736500f649f79df7735303"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":258012,"upload-time":"2024-12-19T18:22:04.204308Z","url":"https://files.pythonhosted.org/packages/f4/de/fb4561e59611c19a2d7377c2b2534d11274b8a7df9bb7b7e7f1de5be3641/psutil-6.1.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"data-dist-info-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"filename":"psutil-6.1.1-cp37-abi3-win32.whl","hashes":{"sha256":"eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250602,"upload-time":"2024-12-19T18:22:08.808295Z","url":"https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"data-dist-info-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"filename":"psutil-6.1.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":254444,"upload-time":"2024-12-19T18:22:11.335598Z","url":"https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.1.1.tar.gz","hashes":{"sha256":"cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508502,"upload-time":"2024-12-19T18:21:20.568966Z","url":"https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25"},"provenance":null,"requires-python":">=3.6","size":238051,"upload-time":"2025-02-13T21:54:12.360451Z","url":"https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"65f64bcd26d7284f4f07568c343ced6641bf8235c8c5a09a4986dd2ec5f68de7"},"data-dist-info-metadata":{"sha256":"65f64bcd26d7284f4f07568c343ced6641bf8235c8c5a09a4986dd2ec5f68de7"},"filename":"psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da"},"provenance":null,"requires-python":">=3.6","size":239535,"upload-time":"2025-02-13T21:54:16.070769Z","url":"https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91"},"provenance":null,"requires-python":">=3.6","size":275004,"upload-time":"2025-02-13T21:54:18.662603Z","url":"https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34"},"provenance":null,"requires-python":">=3.6","size":277986,"upload-time":"2025-02-13T21:54:21.811145Z","url":"https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993"},"provenance":null,"requires-python":">=3.6","size":279544,"upload-time":"2025-02-13T21:54:24.680762Z","url":"https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"data-dist-info-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"filename":"psutil-7.0.0-cp36-cp36m-win32.whl","hashes":{"sha256":"84df4eb63e16849689f76b1ffcb36db7b8de703d1bc1fe41773db487621b6c17"},"provenance":null,"requires-python":">=3.6","size":243024,"upload-time":"2025-02-13T21:54:27.767214Z","url":"https://files.pythonhosted.org/packages/98/04/9e7b8afdad85824dec17de92c121d0fb1907ded624f486b86cd5e8189ebe/psutil-7.0.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"data-dist-info-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"filename":"psutil-7.0.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1e744154a6580bc968a0195fd25e80432d3afec619daf145b9e5ba16cc1d688e"},"provenance":null,"requires-python":">=3.6","size":248462,"upload-time":"2025-02-13T21:54:31.148496Z","url":"https://files.pythonhosted.org/packages/25/9b/43f2c5f7794a3eba3fc0bb47020d1da44d43ff41c95637c5d760c3ef33eb/psutil-7.0.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"data-dist-info-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"filename":"psutil-7.0.0-cp37-abi3-win32.whl","hashes":{"sha256":"ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99"},"provenance":null,"requires-python":">=3.6","size":241053,"upload-time":"2025-02-13T21:54:34.310916Z","url":"https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"data-dist-info-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"filename":"psutil-7.0.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553"},"provenance":null,"requires-python":">=3.6","size":244885,"upload-time":"2025-02-13T21:54:37.486453Z","url":"https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.0.0.tar.gz","hashes":{"sha256":"7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456"},"provenance":null,"requires-python":">=3.6","size":497003,"upload-time":"2025-02-13T21:54:07.946974Z","url":"https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"76168cef4397494250e9f4e73eb3752b146de1dd950040b29186d0cce1d5ca13"},"provenance":null,"requires-python":">=3.6","size":245242,"upload-time":"2025-09-17T20:14:56.126572Z","url":"https://files.pythonhosted.org/packages/46/62/ce4051019ee20ce0ed74432dd73a5bb087a6704284a470bb8adff69a0932/psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"5d007560c8c372efdff9e4579c2846d71de737e4605f611437255e81efcca2c5"},"provenance":null,"requires-python":">=3.6","size":246682,"upload-time":"2025-09-17T20:14:58.250040Z","url":"https://files.pythonhosted.org/packages/38/61/f76959fba841bf5b61123fbf4b650886dc4094c6858008b5bf73d9057216/psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"22e4454970b32472ce7deaa45d045b34d3648ce478e26a04c7e858a0a6e75ff3"},"provenance":null,"requires-python":">=3.6","size":287994,"upload-time":"2025-09-17T20:14:59.901485Z","url":"https://files.pythonhosted.org/packages/88/7a/37c99d2e77ec30d63398ffa6a660450b8a62517cabe44b3e9bae97696e8d/psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"8c70e113920d51e89f212dd7be06219a9b88014e63a4cec69b684c327bc474e3"},"provenance":null,"requires-python":">=3.6","size":291163,"upload-time":"2025-09-17T20:15:01.481447Z","url":"https://files.pythonhosted.org/packages/9d/de/04c8c61232f7244aa0a4b9a9fbd63a89d5aeaf94b2fc9d1d16e2faa5cbb0/psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"7d4a113425c037300de3ac8b331637293da9be9713855c4fc9d2d97436d7259d"},"provenance":null,"requires-python":">=3.6","size":293625,"upload-time":"2025-09-17T20:15:04.492789Z","url":"https://files.pythonhosted.org/packages/f4/58/c4f976234bf6d4737bc8c02a81192f045c307b72cf39c9e5c5a2d78927f6/psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"data-dist-info-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"filename":"psutil-7.1.0-cp37-abi3-win32.whl","hashes":{"sha256":"09ad740870c8d219ed8daae0ad3b726d3bf9a028a198e7f3080f6a1888b99bca"},"provenance":null,"requires-python":">=3.6","size":244812,"upload-time":"2025-09-17T20:15:07.462276Z","url":"https://files.pythonhosted.org/packages/79/87/157c8e7959ec39ced1b11cc93c730c4fb7f9d408569a6c59dbd92ceb35db/psutil-7.1.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"data-dist-info-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"filename":"psutil-7.1.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"57f5e987c36d3146c0dd2528cd42151cf96cd359b9d67cfff836995cc5df9a3d"},"provenance":null,"requires-python":">=3.6","size":247965,"upload-time":"2025-09-17T20:15:09.673366Z","url":"https://files.pythonhosted.org/packages/bf/e9/b44c4f697276a7a95b8e94d0e320a7bf7f3318521b23de69035540b39838/psutil-7.1.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"24a51389a00af9d96fada7f4a79aed176d3a74f0ae399a5305d12ce9784f2635"},"data-dist-info-metadata":{"sha256":"24a51389a00af9d96fada7f4a79aed176d3a74f0ae399a5305d12ce9784f2635"},"filename":"psutil-7.1.0-cp37-abi3-win_arm64.whl","hashes":{"sha256":"6937cb68133e7c97b6cc9649a570c9a18ba0efebed46d8c5dae4c07fa1b67a07"},"provenance":null,"requires-python":">=3.6","size":244971,"upload-time":"2025-09-17T20:15:12.262753Z","url":"https://files.pythonhosted.org/packages/26/65/1070a6e3c036f39142c2820c4b52e9243246fcfc3f96239ac84472ba361e/psutil-7.1.0-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.0.tar.gz","hashes":{"sha256":"655708b3c069387c8b77b072fc429a57d0e214221d01c0a772df7dfedcb3bcd2"},"provenance":null,"requires-python":">=3.6","size":497660,"upload-time":"2025-09-17T20:14:52.902036Z","url":"https://files.pythonhosted.org/packages/b3/31/4723d756b59344b643542936e37a31d1d3204bcdc42a7daa8ee9eb06fb50/psutil-7.1.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"8fa59d7b1f01f0337f12cd10dbd76e4312a4d3c730a4fedcbdd4e5447a8b8460"},"provenance":null,"requires-python":">=3.6","size":244221,"upload-time":"2025-10-19T15:44:03.145914Z","url":"https://files.pythonhosted.org/packages/51/30/f97f8fb1f9ecfbeae4b5ca738dcae66ab28323b5cfbc96cb5565f3754056/psutil-7.1.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"2a95104eae85d088891716db676f780c1404fc15d47fde48a46a5d61e8f5ad2c"},"provenance":null,"requires-python":">=3.6","size":245660,"upload-time":"2025-10-19T15:44:05.657308Z","url":"https://files.pythonhosted.org/packages/7b/98/b8d1f61ebf35f4dbdbaabadf9208282d8adc820562f0257e5e6e79e67bf2/psutil-7.1.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"98629cd8567acefcc45afe2f4ba1e9290f579eacf490a917967decce4b74ee9b"},"provenance":null,"requires-python":">=3.6","size":286963,"upload-time":"2025-10-19T15:44:08.877299Z","url":"https://files.pythonhosted.org/packages/f0/4a/b8015d7357fefdfe34bc4a3db48a107bae4bad0b94fb6eb0613f09a08ada/psutil-7.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"92ebc58030fb054fa0f26c3206ef01c31c29d67aee1367e3483c16665c25c8d2"},"provenance":null,"requires-python":">=3.6","size":290118,"upload-time":"2025-10-19T15:44:11.897889Z","url":"https://files.pythonhosted.org/packages/3d/3c/b56076bb35303d0733fc47b110a1c9cce081a05ae2e886575a3587c1ee76/psutil-7.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"146a704f224fb2ded2be3da5ac67fc32b9ea90c45b51676f9114a6ac45616967"},"provenance":null,"requires-python":">=3.6","size":292587,"upload-time":"2025-10-19T15:44:14.670833Z","url":"https://files.pythonhosted.org/packages/dc/af/c13d360c0adc6f6218bf9e2873480393d0f729c8dd0507d171f53061c0d3/psutil-7.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"data-dist-info-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"filename":"psutil-7.1.1-cp37-abi3-win32.whl","hashes":{"sha256":"295c4025b5cd880f7445e4379e6826f7307e3d488947bf9834e865e7847dc5f7"},"provenance":null,"requires-python":">=3.6","size":243772,"upload-time":"2025-10-19T15:44:16.938205Z","url":"https://files.pythonhosted.org/packages/90/2d/c933e7071ba60c7862813f2c7108ec4cf8304f1c79660efeefd0de982258/psutil-7.1.1-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"data-dist-info-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"filename":"psutil-7.1.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"9b4f17c5f65e44f69bd3a3406071a47b79df45cf2236d1f717970afcb526bcd3"},"provenance":null,"requires-python":">=3.6","size":246936,"upload-time":"2025-10-19T15:44:18.663465Z","url":"https://files.pythonhosted.org/packages/be/f3/11fd213fff15427bc2853552138760c720fd65032d99edfb161910d04127/psutil-7.1.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"41f2736f936aaaa81486aad04717acc54669b33ae5ad93df72d7a7b26aa50fa7"},"data-dist-info-metadata":{"sha256":"41f2736f936aaaa81486aad04717acc54669b33ae5ad93df72d7a7b26aa50fa7"},"filename":"psutil-7.1.1-cp37-abi3-win_arm64.whl","hashes":{"sha256":"5457cf741ca13da54624126cd5d333871b454ab133999a9a103fb097a7d7d21a"},"provenance":null,"requires-python":">=3.6","size":243944,"upload-time":"2025-10-19T15:44:20.666512Z","url":"https://files.pythonhosted.org/packages/0a/8d/8a9a45c8b655851f216c1d44f68e3533dc8d2c752ccd0f61f1aa73be4893/psutil-7.1.1-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.1.tar.gz","hashes":{"sha256":"092b6350145007389c1cfe5716050f02030a05219d90057ea867d18fe8d372fc"},"provenance":null,"requires-python":">=3.6","size":487067,"upload-time":"2025-10-19T15:43:59.373160Z","url":"https://files.pythonhosted.org/packages/89/fc/889242351a932d6183eec5df1fc6539b6f36b6a88444f1e63f18668253aa/psutil-7.1.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"0cc5c6889b9871f231ed5455a9a02149e388fffcb30b607fb7a8896a6d95f22e"},"provenance":null,"requires-python":">=3.6","size":238575,"upload-time":"2025-10-25T10:46:38.728747Z","url":"https://files.pythonhosted.org/packages/b8/d9/b56cc9f883140ac10021a8c9b0f4e16eed1ba675c22513cdcbce3ba64014/psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"8e9e77a977208d84aa363a4a12e0f72189d58bbf4e46b49aae29a2c6e93ef206"},"provenance":null,"requires-python":">=3.6","size":239297,"upload-time":"2025-10-25T10:46:41.347184Z","url":"https://files.pythonhosted.org/packages/36/eb/28d22de383888deb252c818622196e709da98816e296ef95afda33f1c0a2/psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"7d9623a5e4164d2220ecceb071f4b333b3c78866141e8887c072129185f41278"},"provenance":null,"requires-python":">=3.6","size":280420,"upload-time":"2025-10-25T10:46:44.122205Z","url":"https://files.pythonhosted.org/packages/89/5d/220039e2f28cc129626e54d63892ab05c0d56a29818bfe7268dcb5008932/psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"364b1c10fe4ed59c89ec49e5f1a70da353b27986fa8233b4b999df4742a5ee2f"},"provenance":null,"requires-python":">=3.6","size":283049,"upload-time":"2025-10-25T10:46:47.095973Z","url":"https://files.pythonhosted.org/packages/ba/7a/286f0e1c167445b2ef4a6cbdfc8c59fdb45a5a493788950cf8467201dc73/psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"f101ef84de7e05d41310e3ccbdd65a6dd1d9eed85e8aaf0758405d022308e204"},"provenance":null,"requires-python":">=3.6","size":248713,"upload-time":"2025-10-25T10:46:49.573269Z","url":"https://files.pythonhosted.org/packages/aa/cc/7eb93260794a42e39b976f3a4dde89725800b9f573b014fac142002a5c98/psutil-7.1.2-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"20c00824048a95de67f00afedc7b08b282aa08638585b0206a9fb51f28f1a165"},"provenance":null,"requires-python":">=3.6","size":244644,"upload-time":"2025-10-25T10:46:51.924062Z","url":"https://files.pythonhosted.org/packages/ab/1a/0681a92b53366e01f0a099f5237d0c8a2f79d322ac589cccde5e30c8a4e2/psutil-7.1.2-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"e09cfe92aa8e22b1ec5e2d394820cf86c5dff6367ac3242366485dfa874d43bc"},"provenance":null,"requires-python":">=3.6","size":238640,"upload-time":"2025-10-25T10:46:54.089898Z","url":"https://files.pythonhosted.org/packages/56/9e/f1c5c746b4ed5320952acd3002d3962fe36f30524c00ea79fdf954cc6779/psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"fa6342cf859c48b19df3e4aa170e4cfb64aadc50b11e06bb569c6c777b089c9e"},"provenance":null,"requires-python":">=3.6","size":239303,"upload-time":"2025-10-25T10:46:56.932071Z","url":"https://files.pythonhosted.org/packages/32/ee/fd26216a735395cc25c3899634e34aeb41fb1f3dbb44acc67d9e594be562/psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"625977443498ee7d6c1e63e93bacca893fd759a66c5f635d05e05811d23fb5ee"},"provenance":null,"requires-python":">=3.6","size":281717,"upload-time":"2025-10-25T10:46:59.116890Z","url":"https://files.pythonhosted.org/packages/3c/cd/7d96eaec4ef7742b845a9ce2759a2769ecce4ab7a99133da24abacbc9e41/psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"4a24bcd7b7f2918d934af0fb91859f621b873d6aa81267575e3655cd387572a7"},"provenance":null,"requires-python":">=3.6","size":284575,"upload-time":"2025-10-25T10:47:00.944625Z","url":"https://files.pythonhosted.org/packages/bc/1a/7f0b84bdb067d35fe7fade5fff888408688caf989806ce2d6dae08c72dd5/psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"329f05610da6380982e6078b9d0881d9ab1e9a7eb7c02d833bfb7340aa634e31"},"provenance":null,"requires-python":">=3.6","size":249491,"upload-time":"2025-10-25T10:47:03.174087Z","url":"https://files.pythonhosted.org/packages/de/05/7820ef8f7b275268917e0c750eada5834581206d9024ca88edce93c4b762/psutil-7.1.2-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"7b04c29e3c0c888e83ed4762b70f31e65c42673ea956cefa8ced0e31e185f582"},"provenance":null,"requires-python":">=3.6","size":244880,"upload-time":"2025-10-25T10:47:05.228789Z","url":"https://files.pythonhosted.org/packages/db/9a/58de399c7cb58489f08498459ff096cd76b3f1ddc4f224ec2c5ef729c7d0/psutil-7.1.2-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c9ba5c19f2d46203ee8c152c7b01df6eec87d883cfd8ee1af2ef2727f6b0f814"},"provenance":null,"requires-python":">=3.6","size":237244,"upload-time":"2025-10-25T10:47:07.086631Z","url":"https://files.pythonhosted.org/packages/ae/89/b9f8d47ddbc52d7301fc868e8224e5f44ed3c7f55e6d0f54ecaf5dd9ff5e/psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"2a486030d2fe81bec023f703d3d155f4823a10a47c36784c84f1cc7f8d39bedb"},"provenance":null,"requires-python":">=3.6","size":238101,"upload-time":"2025-10-25T10:47:09.523680Z","url":"https://files.pythonhosted.org/packages/c8/7a/8628c2f6b240680a67d73d8742bb9ff39b1820a693740e43096d5dcb01e5/psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"3efd8fc791492e7808a51cb2b94889db7578bfaea22df931424f874468e389e3"},"provenance":null,"requires-python":">=3.6","size":258675,"upload-time":"2025-10-25T10:47:11.082823Z","url":"https://files.pythonhosted.org/packages/30/28/5e27f4d5a0e347f8e3cc16cd7d35533dbce086c95807f1f0e9cd77e26c10/psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"e2aeb9b64f481b8eabfc633bd39e0016d4d8bbcd590d984af764d80bf0851b8a"},"provenance":null,"requires-python":">=3.6","size":260203,"upload-time":"2025-10-25T10:47:13.226564Z","url":"https://files.pythonhosted.org/packages/e5/5c/79cf60c9acf36d087f0db0f82066fca4a780e97e5b3a2e4c38209c03d170/psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4e0958cd1551f981a3d0063faf8314b741cd97cb43d1e58934800cb4da537f64"},"data-dist-info-metadata":{"sha256":"4e0958cd1551f981a3d0063faf8314b741cd97cb43d1e58934800cb4da537f64"},"filename":"psutil-7.1.2-cp37-abi3-win_amd64.whl","hashes":{"sha256":"8e17852114c4e7996fe9da4745c2bdef001ebbf2f260dec406290e66628bdb91"},"provenance":null,"requires-python":">=3.6","size":246714,"upload-time":"2025-10-25T10:47:15.093571Z","url":"https://files.pythonhosted.org/packages/f7/03/0a464404c51685dcb9329fdd660b1721e076ccd7b3d97dee066bcc9ffb15/psutil-7.1.2-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp37-abi3-win_arm64.whl","hashes":{"sha256":"3e988455e61c240cc879cb62a008c2699231bf3e3d061d7fce4234463fd2abb4"},"provenance":null,"requires-python":">=3.6","size":243742,"upload-time":"2025-10-25T10:47:17.302139Z","url":"https://files.pythonhosted.org/packages/6a/32/97ca2090f2f1b45b01b6aa7ae161cfe50671de097311975ca6eea3e7aabc/psutil-7.1.2-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.2.tar.gz","hashes":{"sha256":"aa225cdde1335ff9684708ee8c72650f6598d5ed2114b9a7c5802030b1785018"},"provenance":null,"requires-python":">=3.6","size":487424,"upload-time":"2025-10-25T10:46:34.931002Z","url":"https://files.pythonhosted.org/packages/cd/ec/7b8e6b9b1d22708138630ef34c53ab2b61032c04f16adfdbb96791c8c70c/psutil-7.1.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc"},"provenance":null,"requires-python":">=3.6","size":239751,"upload-time":"2025-11-02T12:25:58.161404Z","url":"https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0"},"provenance":null,"requires-python":">=3.6","size":240368,"upload-time":"2025-11-02T12:26:00.491685Z","url":"https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7"},"provenance":null,"requires-python":">=3.6","size":287134,"upload-time":"2025-11-02T12:26:02.613574Z","url":"https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251"},"provenance":null,"requires-python":">=3.6","size":289904,"upload-time":"2025-11-02T12:26:05.207933Z","url":"https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa"},"provenance":null,"requires-python":">=3.6","size":249642,"upload-time":"2025-11-02T12:26:07.447774Z","url":"https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee"},"provenance":null,"requires-python":">=3.6","size":245518,"upload-time":"2025-11-02T12:26:09.719155Z","url":"https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353"},"provenance":null,"requires-python":">=3.6","size":239843,"upload-time":"2025-11-02T12:26:11.968073Z","url":"https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b"},"provenance":null,"requires-python":">=3.6","size":240369,"upload-time":"2025-11-02T12:26:14.358801Z","url":"https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9"},"provenance":null,"requires-python":">=3.6","size":288210,"upload-time":"2025-11-02T12:26:16.699739Z","url":"https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f"},"provenance":null,"requires-python":">=3.6","size":291182,"upload-time":"2025-11-02T12:26:18.848963Z","url":"https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7"},"provenance":null,"requires-python":">=3.6","size":250466,"upload-time":"2025-11-02T12:26:21.183069Z","url":"https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264"},"provenance":null,"requires-python":">=3.6","size":245756,"upload-time":"2025-11-02T12:26:23.148427Z","url":"https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab"},"provenance":null,"requires-python":">=3.6","size":238359,"upload-time":"2025-11-02T12:26:25.284599Z","url":"https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880"},"provenance":null,"requires-python":">=3.6","size":239171,"upload-time":"2025-11-02T12:26:27.230751Z","url":"https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3"},"provenance":null,"requires-python":">=3.6","size":263261,"upload-time":"2025-11-02T12:26:29.480632Z","url":"https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b"},"provenance":null,"requires-python":">=3.6","size":264635,"upload-time":"2025-11-02T12:26:31.740762Z","url":"https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"89db7acafbe66cd8b6a060ae993afda9c8f50aa4342c34c92a284be2c8c8534f"},"data-dist-info-metadata":{"sha256":"89db7acafbe66cd8b6a060ae993afda9c8f50aa4342c34c92a284be2c8c8534f"},"filename":"psutil-7.1.3-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd"},"provenance":null,"requires-python":">=3.6","size":247633,"upload-time":"2025-11-02T12:26:33.887174Z","url":"https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp37-abi3-win_arm64.whl","hashes":{"sha256":"bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1"},"provenance":null,"requires-python":">=3.6","size":244608,"upload-time":"2025-11-02T12:26:36.136434Z","url":"https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.3.tar.gz","hashes":{"sha256":"6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74"},"provenance":null,"requires-python":">=3.6","size":489059,"upload-time":"2025-11-02T12:25:54.619294Z","url":"https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"c31e927555539132a00380c971816ea43d089bf4bd5f3e918ed8c16776d68474"},"provenance":null,"requires-python":">=3.6","size":129593,"upload-time":"2025-12-23T20:26:28.019569Z","url":"https://files.pythonhosted.org/packages/a8/8e/b35aae6ed19bc4e2286cac4832e4d522fcf00571867b0a85a3f77ef96a80/psutil-7.2.0-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"db8e44e766cef86dea47d9a1fa535d38dc76449e5878a92f33683b7dba5bfcb2"},"provenance":null,"requires-python":">=3.6","size":130104,"upload-time":"2025-12-23T20:26:30.270800Z","url":"https://files.pythonhosted.org/packages/61/a2/773d17d74e122bbffe08b97f73f2d4a01ef53fb03b98e61b8e4f64a9c6b9/psutil-7.2.0-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"85ef849ac92169dedc59a7ac2fb565f47b3468fbe1524bf748746bc21afb94c7"},"provenance":null,"requires-python":">=3.6","size":180579,"upload-time":"2025-12-23T20:26:32.628357Z","url":"https://files.pythonhosted.org/packages/0d/e3/d3a9b3f4bd231abbd70a988beb2e3edd15306051bccbfc4472bd34a56e01/psutil-7.2.0-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"26782bdbae2f5c14ce9ebe8ad2411dc2ca870495e0cd90f8910ede7fa5e27117"},"provenance":null,"requires-python":">=3.6","size":183171,"upload-time":"2025-12-23T20:26:34.972726Z","url":"https://files.pythonhosted.org/packages/66/f8/6c73044424aabe1b7824d4d4504029d406648286d8fe7ba8c4682e0d3042/psutil-7.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"b7665f612d3b38a583391b95969667a53aaf6c5706dc27a602c9a4874fbf09e4"},"provenance":null,"requires-python":">=3.6","size":139055,"upload-time":"2025-12-23T20:26:36.848832Z","url":"https://files.pythonhosted.org/packages/48/7d/76d7a863340885d41826562225a566683e653ee6c9ba03c9f3856afa7d80/psutil-7.2.0-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"4413373c174520ae28a24a8974ad8ce6b21f060d27dde94e25f8c73a7effe57a"},"provenance":null,"requires-python":">=3.6","size":134737,"upload-time":"2025-12-23T20:26:38.784066Z","url":"https://files.pythonhosted.org/packages/a0/48/200054ada0ae4872c8a71db54f3eb6a9af4101680ee6830d373b7fda526b/psutil-7.2.0-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"2f2f53fd114e7946dfba3afb98c9b7c7f376009447360ca15bfb73f2066f84c7"},"provenance":null,"requires-python":">=3.6","size":129692,"upload-time":"2025-12-23T20:26:40.623176Z","url":"https://files.pythonhosted.org/packages/44/86/98da45dff471b93ef5ce5bcaefa00e3038295a7880a77cf74018243d37fb/psutil-7.2.0-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"e65c41d7e60068f60ce43b31a3a7fc90deb0dfd34ffc824a2574c2e5279b377e"},"provenance":null,"requires-python":">=3.6","size":130110,"upload-time":"2025-12-23T20:26:42.569228Z","url":"https://files.pythonhosted.org/packages/50/ee/10eae91ba4ad071c92db3c178ba861f30406342de9f0ddbe6d51fd741236/psutil-7.2.0-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"cc66d21366850a4261412ce994ae9976bba9852dafb4f2fa60db68ed17ff5281"},"provenance":null,"requires-python":">=3.6","size":181487,"upload-time":"2025-12-23T20:26:44.633020Z","url":"https://files.pythonhosted.org/packages/87/3a/2b2897443d56fedbbc34ac68a0dc7d55faa05d555372a2f989109052f86d/psutil-7.2.0-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"e025d67b42b8f22b096d5d20f5171de0e0fefb2f0ce983a13c5a1b5ed9872706"},"provenance":null,"requires-python":">=3.6","size":184320,"upload-time":"2025-12-23T20:26:46.830615Z","url":"https://files.pythonhosted.org/packages/11/66/44308428f7333db42c5ea7390c52af1b38f59b80b80c437291f58b5dfdad/psutil-7.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"45f6b91f7ad63414d6454fd609e5e3556d0e1038d5d9c75a1368513bdf763f57"},"provenance":null,"requires-python":">=3.6","size":140372,"upload-time":"2025-12-23T20:26:49.334377Z","url":"https://files.pythonhosted.org/packages/18/28/d2feadc7f18e501c5ce687c377db7dca924585418fd694272b8e488ea99f/psutil-7.2.0-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"87b18a19574139d60a546e88b5f5b9cbad598e26cdc790d204ab95d7024f03ee"},"provenance":null,"requires-python":">=3.6","size":135400,"upload-time":"2025-12-23T20:26:51.585604Z","url":"https://files.pythonhosted.org/packages/b2/1d/48381f5fd0425aa054c4ee3de24f50de3d6c347019f3aec75f357377d447/psutil-7.2.0-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"977a2fcd132d15cb05b32b2d85b98d087cad039b0ce435731670ba74da9e6133"},"provenance":null,"requires-python":">=3.6","size":128116,"upload-time":"2025-12-23T20:26:53.516520Z","url":"https://files.pythonhosted.org/packages/40/c5/a49160bf3e165b7b93a60579a353cf5d939d7f878fe5fd369110f1d18043/psutil-7.2.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"24151011c21fadd94214d7139d7c6c54569290d7e553989bdf0eab73b13beb8c"},"provenance":null,"requires-python":">=3.6","size":128925,"upload-time":"2025-12-23T20:26:55.573324Z","url":"https://files.pythonhosted.org/packages/10/a1/c75feb480f60cd768fb6ed00ac362a16a33e5076ec8475a22d8162fb2659/psutil-7.2.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"91f211ba9279e7c61d9d8f84b713cfc38fa161cb0597d5cb3f1ca742f6848254"},"provenance":null,"requires-python":">=3.6","size":154666,"upload-time":"2025-12-23T20:26:57.312776Z","url":"https://files.pythonhosted.org/packages/12/ff/e93136587c00a543f4bc768b157fac2c47cd77b180d4f4e5c6efb6ea53a2/psutil-7.2.0-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"f37415188b7ea98faf90fed51131181646c59098b077550246e2e092e127418b"},"provenance":null,"requires-python":">=3.6","size":156109,"upload-time":"2025-12-23T20:26:58.851353Z","url":"https://files.pythonhosted.org/packages/b8/dd/4c2de9c3827c892599d277a69d2224136800870a8a88a80981de905de28d/psutil-7.2.0-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-musllinux_1_2_aarch64.whl","hashes":{"sha256":"0d12c7ce6ed1128cd81fd54606afa054ac7dbb9773469ebb58cf2f171c49f2ac"},"provenance":null,"requires-python":">=3.6","size":148081,"upload-time":"2025-12-23T20:27:01.318270Z","url":"https://files.pythonhosted.org/packages/81/3f/090943c682d3629968dd0b04826ddcbc760ee1379021dbe316e2ddfcd01b/psutil-7.2.0-cp36-abi3-musllinux_1_2_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-musllinux_1_2_x86_64.whl","hashes":{"sha256":"ca0faef7976530940dcd39bc5382d0d0d5eb023b186a4901ca341bd8d8684151"},"provenance":null,"requires-python":">=3.6","size":147376,"upload-time":"2025-12-23T20:27:03.347816Z","url":"https://files.pythonhosted.org/packages/c4/88/c39648ebb8ec182d0364af53cdefe6eddb5f3872ba718b5855a8ff65d6d4/psutil-7.2.0-cp36-abi3-musllinux_1_2_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"758019d458979edff64acde45968217765d5828ba125593a164a985cdc0754bd"},"data-dist-info-metadata":{"sha256":"758019d458979edff64acde45968217765d5828ba125593a164a985cdc0754bd"},"filename":"psutil-7.2.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"abdb74137ca232d20250e9ad471f58d500e7743bc8253ba0bfbf26e570c0e437"},"provenance":null,"requires-python":">=3.6","size":136910,"upload-time":"2025-12-23T20:27:05.289344Z","url":"https://files.pythonhosted.org/packages/01/a2/5b39e08bd9b27476bc7cce7e21c71a481ad60b81ffac49baf02687a50d7f/psutil-7.2.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp37-abi3-win_arm64.whl","hashes":{"sha256":"284e71038b3139e7ab3834b63b3eb5aa5565fcd61a681ec746ef9a0a8c457fd2"},"provenance":null,"requires-python":">=3.6","size":133807,"upload-time":"2025-12-23T20:27:06.825130Z","url":"https://files.pythonhosted.org/packages/59/54/53839db1258c1eaeb4ded57ff202144ebc75b23facc05a74fd98d338b0c6/psutil-7.2.0-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.2.0.tar.gz","hashes":{"sha256":"2e4f8e1552f77d14dc96fb0f6240c5b34a37081c0889f0853b3b29a496e5ef64"},"provenance":null,"requires-python":">=3.6","size":489863,"upload-time":"2025-12-23T20:26:24.616214Z","url":"https://files.pythonhosted.org/packages/be/7c/31d1c3ceb1260301f87565f50689dc6da3db427ece1e1e012af22abca54e/psutil-7.2.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"ba9f33bb525b14c3ea563b2fd521a84d2fa214ec59e3e6a2858f78d0844dd60d"},"provenance":null,"requires-python":">=3.6","size":129624,"upload-time":"2025-12-29T08:26:04.255517Z","url":"https://files.pythonhosted.org/packages/77/8e/f0c242053a368c2aa89584ecd1b054a18683f13d6e5a318fc9ec36582c94/psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"81442dac7abfc2f4f4385ea9e12ddf5a796721c0f6133260687fec5c3780fa49"},"provenance":null,"requires-python":">=3.6","size":130132,"upload-time":"2025-12-29T08:26:06.228150Z","url":"https://files.pythonhosted.org/packages/26/97/a58a4968f8990617decee234258a2b4fc7cd9e35668387646c1963e69f26/psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"ea46c0d060491051d39f0d2cff4f98d5c72b288289f57a21556cc7d504db37fc"},"provenance":null,"requires-python":">=3.6","size":180612,"upload-time":"2025-12-29T08:26:08.276538Z","url":"https://files.pythonhosted.org/packages/db/6d/ed44901e830739af5f72a85fa7ec5ff1edea7f81bfbf4875e409007149bd/psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"35630d5af80d5d0d49cfc4d64c1c13838baf6717a13effb35869a5919b854cdf"},"provenance":null,"requires-python":">=3.6","size":183201,"upload-time":"2025-12-29T08:26:10.622093Z","url":"https://files.pythonhosted.org/packages/c7/65/b628f8459bca4efbfae50d4bf3feaab803de9a160b9d5f3bd9295a33f0c2/psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"923f8653416604e356073e6e0bccbe7c09990acef442def2f5640dd0faa9689f"},"provenance":null,"requires-python":">=3.6","size":139081,"upload-time":"2025-12-29T08:26:12.483257Z","url":"https://files.pythonhosted.org/packages/fb/23/851cadc9764edcc18f0effe7d0bf69f727d4cf2442deb4a9f78d4e4f30f2/psutil-7.2.1-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"cfbe6b40ca48019a51827f20d830887b3107a74a79b01ceb8cc8de4ccb17b672"},"provenance":null,"requires-python":">=3.6","size":134767,"upload-time":"2025-12-29T08:26:14.528248Z","url":"https://files.pythonhosted.org/packages/59/82/d63e8494ec5758029f31c6cb06d7d161175d8281e91d011a4a441c8a43b5/psutil-7.2.1-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"494c513ccc53225ae23eec7fe6e1482f1b8a44674241b54561f755a898650679"},"provenance":null,"requires-python":">=3.6","size":129716,"upload-time":"2025-12-29T08:26:16.017500Z","url":"https://files.pythonhosted.org/packages/05/c2/5fb764bd61e40e1fe756a44bd4c21827228394c17414ade348e28f83cd79/psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"3fce5f92c22b00cdefd1645aa58ab4877a01679e901555067b1bd77039aa589f"},"provenance":null,"requires-python":">=3.6","size":130133,"upload-time":"2025-12-29T08:26:18.009017Z","url":"https://files.pythonhosted.org/packages/c9/d2/935039c20e06f615d9ca6ca0ab756cf8408a19d298ffaa08666bc18dc805/psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"93f3f7b0bb07711b49626e7940d6fe52aa9940ad86e8f7e74842e73189712129"},"provenance":null,"requires-python":">=3.6","size":181518,"upload-time":"2025-12-29T08:26:20.241501Z","url":"https://files.pythonhosted.org/packages/77/69/19f1eb0e01d24c2b3eacbc2f78d3b5add8a89bf0bb69465bc8d563cc33de/psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"d34d2ca888208eea2b5c68186841336a7f5e0b990edec929be909353a202768a"},"provenance":null,"requires-python":">=3.6","size":184348,"upload-time":"2025-12-29T08:26:22.215886Z","url":"https://files.pythonhosted.org/packages/e1/6d/7e18b1b4fa13ad370787626c95887b027656ad4829c156bb6569d02f3262/psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"2ceae842a78d1603753561132d5ad1b2f8a7979cb0c283f5b52fb4e6e14b1a79"},"provenance":null,"requires-python":">=3.6","size":140400,"upload-time":"2025-12-29T08:26:23.993885Z","url":"https://files.pythonhosted.org/packages/98/60/1672114392dd879586d60dd97896325df47d9a130ac7401318005aab28ec/psutil-7.2.1-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"08a2f175e48a898c8eb8eace45ce01777f4785bc744c90aa2cc7f2fa5462a266"},"provenance":null,"requires-python":">=3.6","size":135430,"upload-time":"2025-12-29T08:26:25.999852Z","url":"https://files.pythonhosted.org/packages/fb/7b/d0e9d4513c46e46897b46bcfc410d51fc65735837ea57a25170f298326e6/psutil-7.2.1-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"b2e953fcfaedcfbc952b44744f22d16575d3aa78eb4f51ae74165b4e96e55f42"},"provenance":null,"requires-python":">=3.6","size":128137,"upload-time":"2025-12-29T08:26:27.759659Z","url":"https://files.pythonhosted.org/packages/c5/cf/5180eb8c8bdf6a503c6919f1da28328bd1e6b3b1b5b9d5b01ae64f019616/psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"05cc68dbb8c174828624062e73078e7e35406f4ca2d0866c272c2410d8ef06d1"},"provenance":null,"requires-python":">=3.6","size":128947,"upload-time":"2025-12-29T08:26:29.548034Z","url":"https://files.pythonhosted.org/packages/c5/2c/78e4a789306a92ade5000da4f5de3255202c534acdadc3aac7b5458fadef/psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"5e38404ca2bb30ed7267a46c02f06ff842e92da3bb8c5bfdadbd35a5722314d8"},"provenance":null,"requires-python":">=3.6","size":154694,"upload-time":"2025-12-29T08:26:32.147774Z","url":"https://files.pythonhosted.org/packages/29/f8/40e01c350ad9a2b3cb4e6adbcc8a83b17ee50dd5792102b6142385937db5/psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"ab2b98c9fc19f13f59628d94df5cc4cc4844bc572467d113a8b517d634e362c6"},"provenance":null,"requires-python":">=3.6","size":156136,"upload-time":"2025-12-29T08:26:34.079911Z","url":"https://files.pythonhosted.org/packages/06/e4/b751cdf839c011a9714a783f120e6a86b7494eb70044d7d81a25a5cd295f/psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl","hashes":{"sha256":"f78baafb38436d5a128f837fab2d92c276dfb48af01a240b861ae02b2413ada8"},"provenance":null,"requires-python":">=3.6","size":148108,"upload-time":"2025-12-29T08:26:36.225796Z","url":"https://files.pythonhosted.org/packages/44/ad/bbf6595a8134ee1e94a4487af3f132cef7fce43aef4a93b49912a48c3af7/psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl","hashes":{"sha256":"99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67"},"provenance":null,"requires-python":">=3.6","size":147402,"upload-time":"2025-12-29T08:26:39.210698Z","url":"https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"54955c981ab8a8b2b87efc900b6916c908a315660b0c3c5d205c910565bb3261"},"data-dist-info-metadata":{"sha256":"54955c981ab8a8b2b87efc900b6916c908a315660b0c3c5d205c910565bb3261"},"filename":"psutil-7.2.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"b1b0671619343aa71c20ff9767eced0483e4fc9e1f489d50923738caf6a03c17"},"provenance":null,"requires-python":">=3.6","size":136938,"upload-time":"2025-12-29T08:26:41.036253Z","url":"https://files.pythonhosted.org/packages/34/68/d9317542e3f2b180c4306e3f45d3c922d7e86d8ce39f941bb9e2e9d8599e/psutil-7.2.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp37-abi3-win_arm64.whl","hashes":{"sha256":"0d67c1822c355aa6f7314d92018fb4268a76668a536f133599b91edd48759442"},"provenance":null,"requires-python":">=3.6","size":133836,"upload-time":"2025-12-29T08:26:43.086974Z","url":"https://files.pythonhosted.org/packages/3e/73/2ce007f4198c80fcf2cb24c169884f833fe93fbc03d55d302627b094ee91/psutil-7.2.1-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.2.1.tar.gz","hashes":{"sha256":"f7583aec590485b43ca601dd9cea0dcd65bd7bb21d30ef4ddbf4ea6b5ed1bdd3"},"provenance":null,"requires-python":">=3.6","size":490253,"upload-time":"2025-12-29T08:26:00.169622Z","url":"https://files.pythonhosted.org/packages/73/cb/09e5184fb5fc0358d110fc3ca7f6b1d033800734d34cac10f4136cfac10e/psutil-7.2.1.tar.gz","yanked":false}],"meta":{"_last-serial":33241970,"api-version":"1.4"},"name":"psutil","project-status":{"status":"active"},"versions":["0.1.1","0.1.2","0.1.3","0.2.0","0.2.1","0.3.0","0.4.0","0.4.1","0.5.0","0.5.1","0.6.0","0.6.1","0.7.0","0.7.1","1.0.0","1.0.1","1.1.0","1.1.1","1.1.2","1.1.3","1.2.0","1.2.1","2.0.0","2.1.0","2.1.1","2.1.2","2.1.3","2.2.0","2.2.1","3.0.0","3.0.1","3.1.0","3.1.1","3.2.0","3.2.1","3.2.2","3.3.0","3.4.1","3.4.2","4.0.0","4.1.0","4.2.0","4.3.0","4.3.1","4.4.0","4.4.1","4.4.2","5.0.0","5.0.1","5.1.0","5.1.1","5.1.2","5.1.3","5.2.0","5.2.1","5.2.2","5.3.0","5.3.1","5.4.0","5.4.1","5.4.2","5.4.3","5.4.4","5.4.5","5.4.6","5.4.7","5.4.8","5.5.0","5.5.1","5.6.0","5.6.1","5.6.2","5.6.3","5.6.4","5.6.5","5.6.6","5.6.7","5.7.0","5.7.1","5.7.2","5.7.3","5.8.0","5.9.0","5.9.1","5.9.2","5.9.3","5.9.4","5.9.5","5.9.6","5.9.7","5.9.8","6.0.0","6.1.0","6.1.1","7.0.0","7.1.0","7.1.1","7.1.2","7.1.3","7.2.0","7.2.1"]}
diff --git a/benches/benchmarks/json_loads.py b/benches/benchmarks/json_loads.py
new file mode 100644
index 00000000000..f67f14d2d9e
--- /dev/null
+++ b/benches/benchmarks/json_loads.py
@@ -0,0 +1,7 @@
+import json
+
+with open('benches/_data/pypi_org__simple__psutil.json') as f:
+    data = f.read()
+
+
+loaded = json.loads(data)

From 81d89d1d90af56c208bc0ce0b304f4cc5f4c3119 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 14 Jan 2026 16:59:10 +0900
Subject: [PATCH 287/418] Fix flaky multiprocessing tests (#6725)

---
 .github/workflows/ci.yaml         | 2 --
 Lib/test/_test_multiprocessing.py | 6 ++++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index cc7f745afaa..778890a9f3e 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -108,14 +108,12 @@ env:
   ENV_POLLUTING_TESTS_COMMON: >-
   ENV_POLLUTING_TESTS_LINUX: >-
     test.test_multiprocessing_fork.test_processes
-    test.test_multiprocessing_fork.test_threads
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
-    test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_WINDOWS: >-
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 2fc206f7d53..80b663d32f4 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -6597,7 +6597,8 @@ def tearDownClass(cls):
             support.print_warning(f'Dangling processes: {processes}')
         processes = None
 
-        threads = set(threading._dangling) - set(cls.dangling[1])
+        # TODO: RUSTPYTHON: Filter out stopped threads since gc.collect() is a no-op
+        threads = {t for t in threading._dangling if t.is_alive()} - {t for t in cls.dangling[1] if t.is_alive()}
         if threads:
             test.support.environment_altered = True
             support.print_warning(f'Dangling threads: {threads}')
@@ -6794,7 +6795,8 @@ def tearDownModule():
             support.print_warning(f'Dangling processes: {processes}')
         processes = None
 
-        threads = set(threading._dangling) - set(dangling[1])
+        # TODO: RUSTPYTHON: Filter out stopped threads since gc.collect() is a no-op
+        threads = {t for t in threading._dangling if t.is_alive()} - {t for t in dangling[1] if t.is_alive()}
         if threads:
             need_sleep = True
             test.support.environment_altered = True

From 3d4aaaa6c10c12681e66a5b6975d0854cc0230ac Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 14 Jan 2026 17:20:52 +0900
Subject: [PATCH 288/418] thread.setname and context (#6726)

---
 crates/stdlib/src/contextvars.rs | 45 ++++++++++++++++++++++++------
 crates/vm/src/stdlib/thread.rs   | 48 +++++++++++++++++++++++++++++++-
 2 files changed, 84 insertions(+), 9 deletions(-)

diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
index 329342fe6dc..5608b39d1e0 100644
--- a/crates/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -24,12 +24,12 @@ thread_local! {
 mod _contextvars {
     use crate::vm::{
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
-        builtins::{PyGenericAlias, PyStrRef, PyType, PyTypeRef},
+        builtins::{PyGenericAlias, PyList, PyStrRef, PyType, PyTypeRef},
         class::StaticType,
         common::hash::PyHash,
         function::{ArgCallable, FuncArgs, OptionalArg},
         protocol::{PyMappingMethods, PySequenceMethods},
-        types::{AsMapping, AsSequence, Constructor, Hashable, Representable},
+        types::{AsMapping, AsSequence, Constructor, Hashable, Iterable, Representable},
     };
     use core::{
         cell::{Cell, RefCell, UnsafeCell},
@@ -163,7 +163,7 @@ mod _contextvars {
         }
     }
 
-    #[pyclass(with(Constructor, AsMapping, AsSequence))]
+    #[pyclass(with(Constructor, AsMapping, AsSequence, Iterable))]
     impl PyContext {
         #[pymethod]
         fn run(
@@ -205,11 +205,6 @@ mod _contextvars {
             self.borrow_vars().len()
         }
 
-        #[pymethod]
-        fn __iter__(&self) -> PyResult {
-            unimplemented!("Context.__iter__ is currently under construction")
-        }
-
         #[pymethod]
         fn get(
             &self,
@@ -238,6 +233,15 @@ mod _contextvars {
             let vars = zelf.borrow_vars();
             vars.values().map(|value| value.to_owned()).collect()
         }
+
+        // TODO: wrong return type
+        #[pymethod]
+        fn items(zelf: PyRef<Self>, vm: &VirtualMachine) -> Vec<PyObjectRef> {
+            let vars = zelf.borrow_vars();
+            vars.iter()
+                .map(|(k, v)| vm.ctx.new_tuple(vec![k.clone().into(), v.clone()]).into())
+                .collect()
+        }
     }
 
     impl Constructor for PyContext {
@@ -281,6 +285,15 @@ mod _contextvars {
         }
     }
 
+    impl Iterable for PyContext {
+        fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+            let vars = zelf.borrow_vars();
+            let keys: Vec<PyObjectRef> = vars.keys().map(|k| k.clone().into()).collect();
+            let list = vm.ctx.new_list(keys);
+            <PyList as Iterable>::iter(list, vm)
+        }
+    }
+
     #[pyattr]
     #[pyclass(name, traverse)]
     #[derive(PyPayload)]
@@ -574,6 +587,22 @@ mod _contextvars {
         ) -> PyGenericAlias {
             PyGenericAlias::from_args(cls, args, vm)
         }
+
+        #[pymethod]
+        fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
+            zelf
+        }
+
+        #[pymethod]
+        fn __exit__(
+            zelf: &Py<Self>,
+            _ty: PyObjectRef,
+            _val: PyObjectRef,
+            _tb: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            ContextVar::reset(&zelf.var, zelf.to_owned(), vm)
+        }
     }
 
     impl Constructor for ContextToken {
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index 0e14fe0e4d1..d51d78015d6 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -9,7 +9,7 @@ pub(crate) use _thread::{
 pub(crate) mod _thread {
     use crate::{
         AsObject, Py, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStr, PyTupleRef, PyType, PyTypeRef},
+        builtins::{PyDictRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
         frame::FrameRef,
         function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
         types::{Constructor, GetAttr, Representable, SetAttr},
@@ -260,6 +260,11 @@ pub(crate) mod _thread {
             Ok(())
         }
 
+        #[pymethod]
+        fn locked(&self) -> bool {
+            self.mu.is_locked()
+        }
+
         #[pymethod]
         fn _is_owned(&self) -> bool {
             self.mu.is_owned_by_current_thread()
@@ -293,6 +298,47 @@ pub(crate) mod _thread {
         current_thread_id()
     }
 
+    /// Set the name of the current thread
+    #[pyfunction]
+    fn set_name(name: PyStrRef) {
+        #[cfg(target_os = "linux")]
+        {
+            use std::ffi::CString;
+            if let Ok(c_name) = CString::new(name.as_str()) {
+                // pthread_setname_np on Linux has a 16-byte limit including null terminator
+                // TODO: Potential UTF-8 boundary issue when truncating thread name on Linux.
+                // https://github.com/RustPython/RustPython/pull/6726/changes#r2689379171
+                let truncated = if c_name.as_bytes().len() > 15 {
+                    CString::new(&c_name.as_bytes()[..15]).unwrap_or(c_name)
+                } else {
+                    c_name
+                };
+                unsafe {
+                    libc::pthread_setname_np(libc::pthread_self(), truncated.as_ptr());
+                }
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            use std::ffi::CString;
+            if let Ok(c_name) = CString::new(name.as_str()) {
+                unsafe {
+                    libc::pthread_setname_np(c_name.as_ptr());
+                }
+            }
+        }
+        #[cfg(windows)]
+        {
+            // Windows doesn't have a simple pthread_setname_np equivalent
+            // SetThreadDescription requires Windows 10+
+            let _ = name;
+        }
+        #[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
+        {
+            let _ = name;
+        }
+    }
+
     /// Get OS-level thread ID (pthread_self on Unix)
     /// This is important for fork compatibility - the ID must remain stable after fork
     #[cfg(unix)]

From 7a516c44c9e088f8c7a0764f3c27bcd78cc3cacd Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Wed, 14 Jan 2026 23:51:41 +0900
Subject: [PATCH 289/418] Update AI docs (#6728)

* update copilot instructions

* upgrade-pylib command
---
 .claude/commands/upgrade-pylib.md | 32 +++++++++++++++++++++++++++++++
 .github/copilot-instructions.md   | 15 +++++++++++++--
 2 files changed, 45 insertions(+), 2 deletions(-)
 create mode 100644 .claude/commands/upgrade-pylib.md

diff --git a/.claude/commands/upgrade-pylib.md b/.claude/commands/upgrade-pylib.md
new file mode 100644
index 00000000000..520d5deb7ba
--- /dev/null
+++ b/.claude/commands/upgrade-pylib.md
@@ -0,0 +1,32 @@
+# Upgrade Python Library from CPython
+
+Upgrade a Python standard library module from CPython to RustPython.
+
+## Arguments
+- `$ARGUMENTS`: Library name to upgrade (e.g., `inspect`, `asyncio`, `json`)
+
+## Steps
+
+1. **Delete existing library in Lib/**
+   - If `Lib/$ARGUMENTS.py` exists, delete it
+   - If `Lib/$ARGUMENTS/` directory exists, delete it
+
+2. **Copy from cpython/Lib/**
+   - If `cpython/Lib/$ARGUMENTS.py` exists, copy it to `Lib/$ARGUMENTS.py`
+   - If `cpython/Lib/$ARGUMENTS/` directory exists, copy it to `Lib/$ARGUMENTS/`
+
+3. **Upgrade tests**
+   - Run: `python lib_updater.py --quick-upgrade cpython/Lib/test/test_$ARGUMENTS`
+   - This will update the test files with appropriate RustPython markers
+
+## Example Usage
+```
+/upgrade-pylib inspect
+/upgrade-pylib json
+/upgrade-pylib asyncio
+```
+
+## Notes
+- The cpython/ directory should contain the CPython source that we're syncing from
+- lib_updater.py handles adding `# TODO: RUSTPYTHON` markers and `@unittest.expectedFailure` decorators
+- After upgrading, you may need to run tests to verify: `cargo run --release -- -m test test_$ARGUMENTS`
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index a2ab43a695c..4667f4ee17b 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -87,11 +87,14 @@ rm -r target/debug/build/rustpython-* && find . | grep -E "\.pyc$" | xargs rm -r
 # Run Rust unit tests
 cargo test --workspace --exclude rustpython_wasm
 
-# Run Python snippets tests
+# Run Python snippets tests (debug mode recommended for faster compilation)
+cargo run -- extra_tests/snippets/builtin_bytes.py
+
+# Run all Python snippets tests with pytest
 cd extra_tests
 pytest -v
 
-# Run the Python test module
+# Run the Python test module (release mode recommended for better performance)
 cargo run --release -- -m test ${TEST_MODULE}
 cargo run --release -- -m test test_unicode # to test test_unicode.py
 
@@ -99,6 +102,8 @@ cargo run --release -- -m test test_unicode # to test test_unicode.py
 cargo run --release -- -m test test_unicode -k test_unicode_escape
 ```
 
+**Note**: For `extra_tests/snippets` tests, use debug mode (`cargo run`) as compilation is faster. For `unittest` (`-m test`), use release mode (`cargo run --release`) for better runtime performance.
+
 ### Determining What to Implement
 
 Run `./whats_left.py` to get a list of unimplemented methods, which is helpful when looking for contribution opportunities.
@@ -184,6 +189,12 @@ cargo build --target wasm32-wasip1 --no-default-features --features freeze-stdli
 cargo run --features jit
 ```
 
+### Building venvlauncher (Windows)
+
+See DEVELOPMENT.md "CPython Version Upgrade Checklist" section.
+
+**IMPORTANT**: All 4 venvlauncher binaries use the same source code. Do NOT add multiple `[[bin]]` entries to Cargo.toml. Build once and copy with different names.
+
 ## Test Code Modification Rules
 
 **CRITICAL: Test code modification restrictions**

From 13a875f609c5ecf77f0ec1ed17ce79653c6e8513 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 15 Jan 2026 00:01:14 +0900
Subject: [PATCH 290/418] fix backslash handling in fix_test.py (#6729)

---
 scripts/fix_test.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/scripts/fix_test.py b/scripts/fix_test.py
index 0970531f079..1dfea12b8aa 100644
--- a/scripts/fix_test.py
+++ b/scripts/fix_test.py
@@ -150,11 +150,14 @@ def run_test(test_name):
 
     # Handle --quick-import: extract Lib/... path and copy if needed
     if args.quick_import is not None:
-        src_str = str(args.quick_import)
+        # Normalize path separators to forward slashes for cross-platform support
+        src_str = str(args.quick_import).replace("\\", "/")
         lib_marker = "/Lib/"
 
         if lib_marker not in src_str:
-            print(f"Error: --quick-import path must contain '/Lib/' (got: {src_str})")
+            print(
+                f"Error: --quick-import path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_import})"
+            )
             sys.exit(1)
 
         idx = src_str.index(lib_marker)

From e3890f9b4a6fc1a641cb192e4ac73df887713e54 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Wed, 14 Jan 2026 19:52:25 +0200
Subject: [PATCH 291/418] Bytecode pseudo opcodes (#6715)

---
 Lib/_opcode_metadata.py                       |  18 +-
 Lib/test/test__opcode.py                      |   1 -
 crates/codegen/src/compile.rs                 | 160 ++++---
 crates/codegen/src/ir.rs                      |  87 ++--
 crates/compiler-core/src/bytecode.rs          |  20 +-
 .../compiler-core/src/bytecode/instruction.rs | 397 +++++++++++++-----
 crates/compiler-core/src/bytecode/oparg.rs    |   2 +-
 crates/jit/src/instructions.rs                |   8 +-
 crates/stdlib/src/opcode.rs                   | 100 +++--
 crates/vm/src/frame.rs                        | 264 ++++++------
 scripts/generate_opcode_metadata.py           |  11 +-
 11 files changed, 652 insertions(+), 416 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 560523bfab2..3e98489419f 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -138,14 +138,20 @@
     'JUMP_IF_NOT_EXC_MATCH': 131,
     'SET_EXC_INFO': 134,
     'SUBSCRIPT': 135,
-    'LOAD_SUPER_METHOD': 136,
-    'LOAD_ZERO_SUPER_ATTR': 137,
-    'LOAD_ZERO_SUPER_METHOD': 138,
     'RESUME': 149,
-    'JUMP': 252,
     'LOAD_CLOSURE': 253,
-    'LOAD_ATTR_METHOD': 254,
-    'POP_BLOCK': 255,
+    'JUMP': 256,
+    'JUMP_NO_INTERRUPT': 257,
+    'RESERVED_258': 258,
+    'LOAD_ATTR_METHOD': 259,
+    'LOAD_SUPER_METHOD': 260,
+    'LOAD_ZERO_SUPER_ATTR': 261,
+    'LOAD_ZERO_SUPER_METHOD': 262,
+    'POP_BLOCK': 263,
+    'SETUP_CLEANUP': 264,
+    'SETUP_FINALLY': 265,
+    'SETUP_WITH': 266,
+    'STORE_FAST_MAYBE_NULL': 267,
 }
 
 # CPython 3.13 compatible: opcodes < 44 have no argument
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index dabe95f7167..60dcdc6cd70 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -16,7 +16,6 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Only supporting u8 ATM
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index b7bc3f4d9c7..0f52a519f22 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -34,16 +34,17 @@ use ruff_python_ast::{
     visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange};
+use std::collections::HashSet;
+
 use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
-        self, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
+        self, AnyInstruction, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
         ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
-        UnpackExArgs,
+        PseudoInstruction, UnpackExArgs,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
-use std::collections::HashSet;
 
 const MAXBLOCKS: usize = 20;
 
@@ -274,17 +275,24 @@ pub fn compile_expression(
 }
 
 macro_rules! emit {
-    ($c:expr, Instruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| Instruction::$op { $arg: x })
+    // Struct variant with single identifier (e.g., Foo::A { arg })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident $(,)? } $(,)?) => {
+        $c.emit_arg($arg, |x| $enum::$op { $arg: x })
     };
-    ($c:expr, Instruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| Instruction::$op { $arg: x })
+
+    // Struct variant with explicit value (e.g., Foo::A { arg: 42 })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident : $arg_val:expr $(,)? } $(,)?) => {
+        $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
     };
-    ($c:expr, Instruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, Instruction::$op)
+
+    // Tuple variant (e.g., Foo::B(42))
+    ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
+        $c.emit_arg($arg_val, $enum::$op)
     };
-    ($c:expr, Instruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(Instruction::$op)
+
+    // No-arg variant (e.g., Foo::C)
+    ($c:expr, $enum:ident :: $op:ident $(,)?) => {
+        $c.emit_no_arg($enum::$op)
     };
 }
 
@@ -1181,7 +1189,7 @@ impl Compiler {
                 // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
                 // Need to call __exit__(None, None, None)
 
-                emit!(self, Instruction::PopBlock);
+                emit!(self, PseudoInstruction::PopBlock);
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
@@ -1906,7 +1914,7 @@ impl Compiler {
                         self.compile_statements(body)?;
                         emit!(
                             self,
-                            Instruction::Jump {
+                            PseudoInstruction::Jump {
                                 target: after_block
                             }
                         );
@@ -1922,7 +1930,7 @@ impl Compiler {
                             self.compile_statements(&clause.body)?;
                             emit!(
                                 self,
-                                Instruction::Jump {
+                                PseudoInstruction::Jump {
                                     target: after_block
                                 }
                             );
@@ -2510,7 +2518,7 @@ impl Compiler {
             }
 
             // Jump to end (skip exception path blocks)
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
@@ -2583,7 +2591,7 @@ impl Compiler {
         self.compile_statements(body)?;
         self.pop_fblock(FBlockType::TryExcept);
         // No PopBlock emit - exception table handles this
-        emit!(self, Instruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { target: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -2666,7 +2674,7 @@ impl Compiler {
             let handler_normal_exit = self.new_block();
             emit!(
                 self,
-                Instruction::Jump {
+                PseudoInstruction::Jump {
                     target: handler_normal_exit,
                 }
             );
@@ -2715,7 +2723,7 @@ impl Compiler {
             // Jump to finally block
             emit!(
                 self,
-                Instruction::Jump {
+                PseudoInstruction::Jump {
                     target: finally_block,
                 }
             );
@@ -2790,7 +2798,7 @@ impl Compiler {
             self.compile_statements(finalbody)?;
             // Jump to end_block to skip exception path blocks
             // This prevents fall-through to finally_except_block
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
         }
 
         // finally (exception path)
@@ -2916,7 +2924,7 @@ impl Compiler {
         )?;
         self.compile_statements(body)?;
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, Instruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { target: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
@@ -3029,7 +3037,7 @@ impl Compiler {
             }
 
             // Jump to next handler
-            emit!(self, Instruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { target: next_block });
 
             // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
@@ -3057,7 +3065,7 @@ impl Compiler {
 
             // JUMP except_with_error
             // We directly JUMP to next_block since no_match_block falls through to it
-            emit!(self, Instruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { target: next_block });
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
@@ -3081,7 +3089,7 @@ impl Compiler {
                 // Stack: [prev_exc, orig, list]
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: reraise_star_block
                     }
                 );
@@ -3134,7 +3142,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, Instruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { target: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
@@ -3175,7 +3183,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, Instruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { target: end_block });
 
         self.switch_to_block(end_block);
         if !finalbody.is_empty() {
@@ -4017,7 +4025,7 @@ impl Compiler {
         self.ctx.loop_data = was_in_loop;
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: while_block,
             }
         );
@@ -4154,7 +4162,7 @@ impl Compiler {
         emit!(self, Instruction::PopTop); // Pop __exit__ result
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: after_block
             }
         );
@@ -4226,7 +4234,7 @@ impl Compiler {
         emit!(self, Instruction::PopTop); // pop lasti
         emit!(
             self,
-            Instruction::Jump {
+            PseudoInstruction::Jump {
                 target: after_block
             }
         );
@@ -4313,7 +4321,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((for_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(self, Instruction::Jump { target: for_block });
+        emit!(self, PseudoInstruction::Jump { target: for_block });
 
         self.switch_to_block(else_block);
 
@@ -4372,7 +4380,7 @@ impl Compiler {
             JumpOp::Jump => {
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: pc.fail_pop[pops]
                     }
                 );
@@ -5038,7 +5046,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { target: end });
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -5274,7 +5282,7 @@ impl Compiler {
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, Instruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { target: end });
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
@@ -5387,7 +5395,7 @@ impl Compiler {
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
-        emit!(self, Instruction::Jump { target: end });
+        emit!(self, PseudoInstruction::Jump { target: end });
 
         // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
         self.switch_to_block(cleanup);
@@ -5829,7 +5837,7 @@ impl Compiler {
         );
 
         // JUMP_NO_INTERRUPT send (regular JUMP in RustPython)
-        emit!(self, Instruction::Jump { target: send_block });
+        emit!(self, PseudoInstruction::Jump { target: send_block });
 
         // fail: CLEANUP_THROW
         // Stack when exception: [receiver, yielded_value, exc]
@@ -5906,7 +5914,7 @@ impl Compiler {
                             emit!(self, Instruction::LoadSuperAttr { arg: idx });
                         }
                         SuperCallType::ZeroArg => {
-                            emit!(self, Instruction::LoadZeroSuperAttr { idx });
+                            emit!(self, PseudoInstruction::LoadZeroSuperAttr { idx });
                         }
                     }
                 } else {
@@ -6094,9 +6102,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<listcomp>",
-                    Some(Instruction::BuildList {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        Instruction::BuildList {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
@@ -6117,9 +6128,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<setcomp>",
-                    Some(Instruction::BuildSet {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        Instruction::BuildSet {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         compiler.compile_comprehension_element(elt)?;
@@ -6143,9 +6157,12 @@ impl Compiler {
             }) => {
                 self.compile_comprehension(
                     "<dictcomp>",
-                    Some(Instruction::BuildMap {
-                        size: OpArgMarker::marker(),
-                    }),
+                    Some(
+                        Instruction::BuildMap {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
                     generators,
                     &|compiler| {
                         // changed evaluation order for Py38 named expression PEP 572
@@ -6222,7 +6239,7 @@ impl Compiler {
                 self.compile_expression(body)?;
                 emit!(
                     self,
-                    Instruction::Jump {
+                    PseudoInstruction::Jump {
                         target: after_block,
                     }
                 );
@@ -6347,10 +6364,10 @@ impl Compiler {
                 let idx = self.name(attr.as_str());
                 match super_type {
                     SuperCallType::TwoArg { .. } => {
-                        emit!(self, Instruction::LoadSuperMethod { idx });
+                        emit!(self, PseudoInstruction::LoadSuperMethod { idx });
                     }
                     SuperCallType::ZeroArg => {
-                        emit!(self, Instruction::LoadZeroSuperMethod { idx });
+                        emit!(self, PseudoInstruction::LoadZeroSuperMethod { idx });
                     }
                 }
                 self.compile_call_helper(0, args)?;
@@ -6359,7 +6376,7 @@ impl Compiler {
                 // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
-                emit!(self, Instruction::LoadAttrMethod { idx });
+                emit!(self, PseudoInstruction::LoadAttrMethod { idx });
                 self.compile_call_helper(0, args)?;
             }
         } else {
@@ -6505,7 +6522,7 @@ impl Compiler {
     fn compile_comprehension(
         &mut self,
         name: &str,
-        init_collection: Option<Instruction>,
+        init_collection: Option<AnyInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         comprehension_type: ComprehensionType,
@@ -6651,7 +6668,7 @@ impl Compiler {
         compile_element(self)?;
 
         for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, Instruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
@@ -6728,7 +6745,7 @@ impl Compiler {
     /// This generates bytecode inline without creating a new code object
     fn compile_inlined_comprehension(
         &mut self,
-        init_collection: Option<Instruction>,
+        init_collection: Option<AnyInstruction>,
         generators: &[Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         _has_an_async_gen: bool,
@@ -6849,7 +6866,7 @@ impl Compiler {
 
         // Step 7: Close all loops
         for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
-            emit!(self, Instruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
             self.switch_to_block(after_block);
             if is_async {
                 emit!(self, Instruction::EndAsyncFor);
@@ -6863,7 +6880,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::TryExcept);
 
             // Normal path: jump past cleanup
-            emit!(self, Instruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { target: end_block });
 
             // Exception cleanup path
             self.switch_to_block(cleanup_block);
@@ -6936,14 +6953,14 @@ impl Compiler {
     }
 
     // Low level helper functions:
-    fn _emit(&mut self, instr: Instruction, arg: OpArg, target: BlockIdx) {
+    fn _emit<I: Into<AnyInstruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
         let range = self.current_source_range;
         let source = self.source_file.to_source_code();
         let location = source.source_location(range.start(), PositionEncoding::Utf8);
         let end_location = source.source_location(range.end(), PositionEncoding::Utf8);
         let except_handler = self.current_except_handler();
         self.current_block().instructions.push(ir::InstructionInfo {
-            instr,
+            instr: instr.into(),
             arg,
             target,
             location,
@@ -6952,14 +6969,14 @@ impl Compiler {
         });
     }
 
-    fn emit_no_arg(&mut self, ins: Instruction) {
+    fn emit_no_arg<I: Into<AnyInstruction>>(&mut self, ins: I) {
         self._emit(ins, OpArg::null(), BlockIdx::NULL)
     }
 
-    fn emit_arg<A: OpArgType, T: EmitArg<A>>(
+    fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<AnyInstruction>>(
         &mut self,
         arg: T,
-        f: impl FnOnce(OpArgMarker<A>) -> Instruction,
+        f: impl FnOnce(OpArgMarker<A>) -> I,
     ) {
         let (op, arg, target) = arg.emit(f);
         self._emit(op, arg, target)
@@ -6984,9 +7001,9 @@ impl Compiler {
 
     fn emit_return_value(&mut self) {
         if let Some(inst) = self.current_block().instructions.last_mut()
-            && let Instruction::LoadConst { idx } = inst.instr
+            && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr
         {
-            inst.instr = Instruction::ReturnConst { idx };
+            inst.instr = Instruction::ReturnConst { idx }.into();
             return;
         }
         emit!(self, Instruction::ReturnValue)
@@ -7435,23 +7452,28 @@ impl Compiler {
 }
 
 trait EmitArg<Arg: OpArgType> {
-    fn emit(
+    fn emit<I: Into<AnyInstruction>>(
         self,
-        f: impl FnOnce(OpArgMarker<Arg>) -> Instruction,
-    ) -> (Instruction, OpArg, BlockIdx);
+        f: impl FnOnce(OpArgMarker<Arg>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx);
 }
+
 impl<T: OpArgType> EmitArg<T> for T {
-    fn emit(self, f: impl FnOnce(OpArgMarker<T>) -> Instruction) -> (Instruction, OpArg, BlockIdx) {
+    fn emit<I: Into<AnyInstruction>>(
+        self,
+        f: impl FnOnce(OpArgMarker<T>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
         let (marker, arg) = OpArgMarker::new(self);
-        (f(marker), arg, BlockIdx::NULL)
+        (f(marker).into(), arg, BlockIdx::NULL)
     }
 }
+
 impl EmitArg<bytecode::Label> for BlockIdx {
-    fn emit(
+    fn emit<I: Into<AnyInstruction>>(
         self,
-        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> Instruction,
-    ) -> (Instruction, OpArg, BlockIdx) {
-        (f(OpArgMarker::marker()), OpArg::null(), self)
+        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
+        (f(OpArgMarker::marker()).into(), OpArg::null(), self)
     }
 }
 
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 82b9921911c..8935f2063c3 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -1,12 +1,14 @@
 use core::ops;
 
 use crate::{IndexMap, IndexSet, error::InternalError};
+
 use rustpython_compiler_core::{
     OneIndexed, SourceLocation,
     bytecode::{
-        Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData, ExceptionTableEntry,
-        InstrDisplayContext, Instruction, Label, OpArg, PyCodeLocationInfoKind,
-        encode_exception_table, encode_load_attr_arg, encode_load_super_attr_arg,
+        AnyInstruction, Arg, CodeFlags, CodeObject, CodeUnit, CodeUnits, ConstantData,
+        ExceptionTableEntry, InstrDisplayContext, Instruction, InstructionMetadata, Label, OpArg,
+        PseudoInstruction, PyCodeLocationInfoKind, encode_exception_table, encode_load_attr_arg,
+        encode_load_super_attr_arg,
     },
     varint::{write_signed_varint, write_varint},
 };
@@ -85,7 +87,7 @@ impl ops::IndexMut<BlockIdx> for Vec<Block> {
 
 #[derive(Debug, Clone)]
 pub struct InstructionInfo {
-    pub instr: Instruction,
+    pub instr: AnyInstruction,
     pub arg: OpArg,
     pub target: BlockIdx,
     pub location: SourceLocation,
@@ -195,48 +197,73 @@ impl CodeInfo {
             .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
         {
             for info in &mut block.instructions {
-                match info.instr {
+                // Special case for:
+                // - `Instruction::LoadAttr`
+                // - `Instruction::LoadSuperAttr`
+
+                if let Some(instr) = info.instr.real() {
+                    match instr {
+                        // LOAD_ATTR → encode with method flag=0
+                        Instruction::LoadAttr { idx } => {
+                            let encoded = encode_load_attr_arg(idx.get(info.arg), false);
+                            info.arg = OpArg(encoded);
+                            info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
+                        }
+                        // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
+                        Instruction::LoadSuperAttr { arg: idx } => {
+                            let encoded =
+                                encode_load_super_attr_arg(idx.get(info.arg), false, true);
+                            info.arg = OpArg(encoded);
+                            info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        }
+                        _ => {}
+                    }
+
+                    continue;
+                }
+
+                let instr = info.instr.expect_pseudo();
+
+                match instr {
                     // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
-                    Instruction::LoadAttrMethod { idx } => {
+                    PseudoInstruction::LoadAttrMethod { idx } => {
                         let encoded = encode_load_attr_arg(idx.get(info.arg), true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
-                    }
-                    // LOAD_ATTR → encode with method flag=0
-                    Instruction::LoadAttr { idx } => {
-                        let encoded = encode_load_attr_arg(idx.get(info.arg), false);
-                        info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadAttr { idx: Arg::marker() };
+                        info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
                     }
                     // POP_BLOCK pseudo → NOP
-                    Instruction::PopBlock => {
-                        info.instr = Instruction::Nop;
+                    PseudoInstruction::PopBlock => {
+                        info.instr = Instruction::Nop.into();
                     }
                     // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
-                    Instruction::LoadSuperMethod { idx } => {
+                    PseudoInstruction::LoadSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
-                    Instruction::LoadZeroSuperAttr { idx } => {
+                    PseudoInstruction::LoadZeroSuperAttr { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
                     // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
-                    Instruction::LoadZeroSuperMethod { idx } => {
+                    PseudoInstruction::LoadZeroSuperMethod { idx } => {
                         let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
                         info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
-                    // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
-                    Instruction::LoadSuperAttr { arg: idx } => {
-                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, true);
-                        info.arg = OpArg(encoded);
-                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() };
+                    PseudoInstruction::Jump { .. } => {
+                        // PseudoInstruction::Jump instructions are handled later
+                    }
+                    PseudoInstruction::JumpNoInterrupt { .. }
+                    | PseudoInstruction::Reserved258
+                    | PseudoInstruction::SetupCleanup
+                    | PseudoInstruction::SetupFinally
+                    | PseudoInstruction::SetupWith
+                    | PseudoInstruction::StoreFastMaybeNull => {
+                        unimplemented!("Got a placeholder pseudo instruction ({instr:?})")
                     }
-                    _ => {}
                 }
             }
         }
@@ -277,7 +304,9 @@ impl CodeInfo {
 
                     // Convert JUMP pseudo to real instructions (direction depends on offset)
                     let op = match info.instr {
-                        Instruction::Jump { .. } if target != BlockIdx::NULL => {
+                        AnyInstruction::Pseudo(PseudoInstruction::Jump { .. })
+                            if target != BlockIdx::NULL =>
+                        {
                             let target_offset = block_to_offset[target.idx()].0;
                             if target_offset > current_offset {
                                 Instruction::JumpForward {
@@ -289,7 +318,7 @@ impl CodeInfo {
                                 }
                             }
                         }
-                        other => other,
+                        other => other.expect_real(),
                     };
 
                     let (extras, lo_arg) = info.arg.split();
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 3595e67c32e..a0054b28877 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -15,7 +15,11 @@ use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
 
 pub use crate::bytecode::{
-    instruction::{Arg, Instruction, decode_load_super_attr_arg, encode_load_super_attr_arg},
+    instruction::{
+        AnyInstruction, Arg, Instruction, InstructionMetadata, PseudoInstruction,
+        decode_load_attr_arg, decode_load_super_attr_arg, encode_load_attr_arg,
+        encode_load_super_attr_arg,
+    },
     oparg::{
         BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
         IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx, OpArg,
@@ -96,20 +100,6 @@ pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTabl
     None
 }
 
-/// Encode LOAD_ATTR oparg: bit 0 = method flag, bits 1+ = name index.
-#[inline]
-pub const fn encode_load_attr_arg(name_idx: u32, is_method: bool) -> u32 {
-    (name_idx << 1) | (is_method as u32)
-}
-
-/// Decode LOAD_ATTR oparg: returns (name_idx, is_method).
-#[inline]
-pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
-    let is_method = (oparg & 1) == 1;
-    let name_idx = oparg >> 1;
-    (name_idx, is_method)
-}
-
 /// CPython 3.11+ linetable location info codes
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u8)]
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 07464f375cb..3ebb3666ae2 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -2,7 +2,7 @@ use core::{fmt, marker::PhantomData, mem};
 
 use crate::{
     bytecode::{
-        BorrowedConstant, Constant, InstrDisplayContext, decode_load_attr_arg,
+        BorrowedConstant, Constant, InstrDisplayContext,
         oparg::{
             BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
             IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx,
@@ -12,10 +12,13 @@ use crate::{
     marshal::MarshalError,
 };
 
-/// A Single bytecode instruction.
-/// Instructions are ordered to match CPython 3.13 opcode numbers exactly.
-/// HAVE_ARGUMENT = 44: opcodes 0-43 have no argument, 44+ have arguments.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+/// A Single bytecode instruction that are executed by the VM.
+///
+/// Currently aligned with CPython 3.13.
+///
+/// ## See also
+/// - [CPython opcode IDs](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Include/opcode_ids.h)
+#[derive(Clone, Copy, Debug)]
 #[repr(u8)]
 pub enum Instruction {
     // ==================== No-argument instructions (opcode < 44) ====================
@@ -245,20 +248,6 @@ pub enum Instruction {
     Resume {
         arg: Arg<u32>,
     } = 149,
-    // ===== LOAD_SUPER_* Pseudo Opcodes (136-138) =====
-    // These are converted to LoadSuperAttr during bytecode finalization.
-    // "Zero" variants are for 0-arg super() calls (has_class=false).
-    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
-    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
-    LoadSuperMethod {
-        idx: Arg<NameIdx>,
-    } = 136, // CPython uses pseudo-op 260
-    LoadZeroSuperAttr {
-        idx: Arg<NameIdx>,
-    } = 137, // CPython uses pseudo-op 261
-    LoadZeroSuperMethod {
-        idx: Arg<NameIdx>,
-    } = 138, // CPython uses pseudo-op 262
     // ==================== RustPython-only instructions (119-135) ====================
     // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
     // So we assign random IDs to these opcodes.
@@ -290,15 +279,8 @@ pub enum Instruction {
     JumpIfNotExcMatch(Arg<Label>) = 131,
     SetExcInfo = 134,
     Subscript = 135,
-    // ===== Pseudo Opcodes (252+) ======
-    Jump {
-        target: Arg<Label>,
-    } = 252, // CPython uses pseudo-op 256
-    LoadClosure(Arg<NameIdx>) = 253, // CPython uses pseudo-op 258
-    LoadAttrMethod {
-        idx: Arg<NameIdx>,
-    } = 254, // CPython uses pseudo-op 259
-    PopBlock = 255,                  // CPython uses pseudo-op 263
+    // Pseudos (needs to be moved to `PseudoInstruction` enum.
+    LoadClosure(Arg<NameIdx>) = 253, // TODO: Move to pseudos
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -307,7 +289,7 @@ impl From<Instruction> for u8 {
     #[inline]
     fn from(ins: Instruction) -> Self {
         // SAFETY: there's no padding bits
-        unsafe { core::mem::transmute::<Instruction, Self>(ins) }
+        unsafe { mem::transmute::<Instruction, Self>(ins) }
     }
 }
 
@@ -323,6 +305,9 @@ impl TryFrom<u8> for Instruction {
         // Resume has a non-contiguous opcode (149)
         let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
 
+        // TODO: Remove this; This instruction needs to be pseudo
+        let load_closure = u8::from(Self::LoadClosure(Arg::marker()));
+
         // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
         let custom_ops: &[u8] = &[
             u8::from(Self::Break {
@@ -354,37 +339,25 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
-            // LOAD_SUPER_* pseudo opcodes (136-138)
-            u8::from(Self::LoadSuperMethod { idx: Arg::marker() }),
-            u8::from(Self::LoadZeroSuperAttr { idx: Arg::marker() }),
-            u8::from(Self::LoadZeroSuperMethod { idx: Arg::marker() }),
         ];
 
-        // Pseudo opcodes (252-255)
-        let pseudo_start = u8::from(Self::Jump {
-            target: Arg::marker(),
-        });
-        let pseudo_end = u8::from(Self::PopBlock);
-
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
+            || value == load_closure
             || custom_ops.contains(&value)
-            || (pseudo_start..=pseudo_end).contains(&value)
         {
-            Ok(unsafe { core::mem::transmute::<u8, Self>(value) })
+            Ok(unsafe { mem::transmute::<u8, Self>(value) })
         } else {
             Err(Self::Error::InvalidBytecode)
         }
     }
 }
 
-impl Instruction {
-    /// Gets the label stored inside this instruction, if it exists
+impl InstructionMetadata for Instruction {
     #[inline]
-    pub const fn label_arg(&self) -> Option<Arg<Label>> {
+    fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::Jump { target: l }
-            | Self::JumpBackward { target: l }
+            Self::JumpBackward { target: l }
             | Self::JumpBackwardNoInterrupt { target: l }
             | Self::JumpForward { target: l }
             | Self::JumpIfNotExcMatch(l)
@@ -400,20 +373,10 @@ impl Instruction {
         }
     }
 
-    /// Whether this is an unconditional branching
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
-    pub const fn unconditional_branch(&self) -> bool {
+    fn unconditional_branch(&self) -> bool {
         matches!(
             self,
-            Self::Jump { .. }
-                | Self::JumpForward { .. }
+            Self::JumpForward { .. }
                 | Self::JumpBackward { .. }
                 | Self::JumpBackwardNoInterrupt { .. }
                 | Self::Continue { .. }
@@ -425,18 +388,7 @@ impl Instruction {
         )
     }
 
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// ```
-    ///
-    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             Self::Nop => 0,
             Self::ImportName { .. } => -1,
@@ -456,13 +408,10 @@ impl Instruction {
             Self::DeleteGlobal(_) => 0,
             Self::DeleteDeref(_) => 0,
             Self::LoadFromDictOrDeref(_) => 1,
-            Self::LoadClosure(_) => 1,
             Self::Subscript => -1,
             Self::StoreSubscr => -3,
             Self::DeleteSubscr => -2,
             Self::LoadAttr { .. } => 0,
-            // LoadAttrMethod: pop obj, push method + self_or_null
-            Self::LoadAttrMethod { .. } => 1,
             Self::StoreAttr { .. } => -2,
             Self::DeleteAttr { .. } => -1,
             Self::LoadConst { .. } => 1,
@@ -480,7 +429,6 @@ impl Instruction {
             Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
             Self::Continue { .. } => 0,
             Self::Break { .. } => 0,
-            Self::Jump { .. } => 0,
             Self::PopJumpIfTrue { .. } => -1,
             Self::PopJumpIfFalse { .. } => -1,
             Self::JumpIfTrueOrPop { .. } => {
@@ -542,7 +490,6 @@ impl Instruction {
             Self::SetupAnnotations => 0,
             Self::BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
             Self::WithExceptStart => 1, // push __exit__ result
-            Self::PopBlock => 0,
             Self::RaiseVarargs { kind } => {
                 // Stack effects for different raise kinds:
                 // - Reraise (0): gets from VM state, no stack pop
@@ -615,9 +562,6 @@ impl Instruction {
                 if load_method { -3 + 2 } else { -3 + 1 }
             }
             // Pseudo instructions (calculated before conversion)
-            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
-            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
-            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
             Self::Cache => 0,
             Self::BinarySlice => 0,
             Self::BinaryOpInplaceAddUnicode => 0,
@@ -644,25 +588,12 @@ impl Instruction {
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
+            Self::LoadClosure(_) => 1,
         }
     }
 
-    pub fn display<'a>(
-        &'a self,
-        arg: OpArg,
-        ctx: &'a impl InstrDisplayContext,
-    ) -> impl fmt::Display + 'a {
-        struct FmtFn<F>(F);
-        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                (self.0)(f)
-            }
-        }
-        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
-    }
-
     #[allow(clippy::too_many_arguments)]
-    pub(crate) fn fmt_dis(
+    fn fmt_dis(
         &self,
         arg: OpArg,
         f: &mut fmt::Formatter<'_>,
@@ -765,7 +696,6 @@ impl Instruction {
             Self::ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
             Self::ImportName { idx } => w!(IMPORT_NAME, name = idx),
             Self::IsOp(inv) => w!(IS_OP, ?inv),
-            Self::Jump { target } => w!(JUMP, target),
             Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
             Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
             Self::JumpForward { target } => w!(JUMP_FORWARD, target),
@@ -787,7 +717,6 @@ impl Instruction {
                     write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
                 }
             }
-            Self::LoadAttrMethod { idx } => w!(LOAD_ATTR_METHOD, name = idx),
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
             Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
             Self::LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
@@ -807,9 +736,6 @@ impl Instruction {
                     "LOAD_SUPER_ATTR", encoded, attr_name, load_method, has_class
                 )
             }
-            Self::LoadSuperMethod { idx } => w!(LOAD_SUPER_METHOD, name = idx),
-            Self::LoadZeroSuperAttr { idx } => w!(LOAD_ZERO_SUPER_ATTR, name = idx),
-            Self::LoadZeroSuperMethod { idx } => w!(LOAD_ZERO_SUPER_METHOD, name = idx),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
             Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
@@ -817,7 +743,6 @@ impl Instruction {
             Self::MatchMapping => w!(MATCH_MAPPING),
             Self::MatchSequence => w!(MATCH_SEQUENCE),
             Self::Nop => w!(NOP),
-            Self::PopBlock => w!(POP_BLOCK),
             Self::PopExcept => w!(POP_EXCEPT),
             Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
             Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
@@ -863,6 +788,266 @@ impl Instruction {
     }
 }
 
+/// Instructions used by the compiler. They are not executed by the VM.
+#[derive(Clone, Copy, Debug)]
+#[repr(u16)]
+pub enum PseudoInstruction {
+    Jump {
+        target: Arg<Label>,
+    } = 256,
+    JumpNoInterrupt {
+        target: Arg<Label>,
+    } = 257, // Placeholder
+    Reserved258 = 258,
+    LoadAttrMethod {
+        idx: Arg<NameIdx>,
+    } = 259,
+    // "Zero" variants are for 0-arg super() calls (has_class=false).
+    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
+    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
+    LoadSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 260,
+    LoadZeroSuperAttr {
+        idx: Arg<NameIdx>,
+    } = 261,
+    LoadZeroSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 262,
+    PopBlock = 263,
+    SetupCleanup = 264,       // Placeholder
+    SetupFinally = 265,       // Placeholder
+    SetupWith = 266,          // Placeholder
+    StoreFastMaybeNull = 267, // Placeholder
+}
+
+const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
+
+impl From<PseudoInstruction> for u16 {
+    #[inline]
+    fn from(ins: PseudoInstruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { mem::transmute::<PseudoInstruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u16> for PseudoInstruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u16) -> Result<Self, MarshalError> {
+        let start = u16::from(Self::Jump {
+            target: Arg::marker(),
+        });
+        let end = u16::from(Self::StoreFastMaybeNull);
+
+        if (start..=end).contains(&value) {
+            Ok(unsafe { mem::transmute::<u16, Self>(value) })
+        } else {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
+impl InstructionMetadata for PseudoInstruction {
+    fn label_arg(&self) -> Option<Arg<Label>> {
+        match self {
+            Self::Jump { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    fn unconditional_branch(&self) -> bool {
+        matches!(self, Self::Jump { .. },)
+    }
+
+    fn stack_effect(&self, _arg: OpArg, _jump: bool) -> i32 {
+        match self {
+            Self::Jump { .. } => 0,
+            Self::JumpNoInterrupt { .. } => 0,
+            Self::LoadAttrMethod { .. } => 1, // pop obj, push method + self_or_null
+            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
+            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::PopBlock => 0,
+            Self::SetupCleanup => 0,
+            Self::SetupFinally => 0,
+            Self::SetupWith => 0,
+            Self::StoreFastMaybeNull => 0,
+            Self::Reserved258 => 0,
+        }
+    }
+
+    fn fmt_dis(
+        &self,
+        _arg: OpArg,
+        _f: &mut fmt::Formatter<'_>,
+        _ctx: &impl InstrDisplayContext,
+        _expand_code_objects: bool,
+        _pad: usize,
+        _level: usize,
+    ) -> fmt::Result {
+        unimplemented!()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum AnyInstruction {
+    Real(Instruction),
+    Pseudo(PseudoInstruction),
+}
+
+impl From<Instruction> for AnyInstruction {
+    fn from(value: Instruction) -> Self {
+        Self::Real(value)
+    }
+}
+
+impl From<PseudoInstruction> for AnyInstruction {
+    fn from(value: PseudoInstruction) -> Self {
+        Self::Pseudo(value)
+    }
+}
+
+impl TryFrom<u8> for AnyInstruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(Instruction::try_from(value)?.into())
+    }
+}
+
+impl TryFrom<u16> for AnyInstruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match u8::try_from(value) {
+            Ok(v) => v.try_into(),
+            Err(_) => Ok(PseudoInstruction::try_from(value)?.into()),
+        }
+    }
+}
+
+macro_rules! inst_either {
+    (fn $name:ident ( &self $(, $arg:ident : $arg_ty:ty )* ) -> $ret:ty ) => {
+        fn $name(&self $(, $arg : $arg_ty )* ) -> $ret {
+            match self {
+                Self::Real(op) => op.$name($($arg),*),
+                Self::Pseudo(op) => op.$name($($arg),*),
+            }
+        }
+    };
+}
+
+impl InstructionMetadata for AnyInstruction {
+    inst_either!(fn label_arg(&self) -> Option<Arg<Label>>);
+
+    inst_either!(fn unconditional_branch(&self) -> bool);
+
+    inst_either!(fn stack_effect(&self, arg: OpArg, jump: bool) -> i32);
+
+    inst_either!(fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize
+    ) -> fmt::Result);
+}
+
+impl AnyInstruction {
+    /// Gets the inner value of [`Self::Real`].
+    pub const fn real(self) -> Option<Instruction> {
+        match self {
+            Self::Real(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    /// Gets the inner value of [`Self::Pseudo`].
+    pub const fn pseudo(self) -> Option<PseudoInstruction> {
+        match self {
+            Self::Pseudo(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    /// Same as [`Self::real`] but panics if wasn't called on [`Self::Real`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Real`].
+    pub const fn expect_real(self) -> Instruction {
+        self.real()
+            .expect("Expected Instruction::Real, found Instruction::Pseudo")
+    }
+
+    /// Same as [`Self::pseudo`] but panics if wasn't called on [`Self::Pseudo`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Pseudo`].
+    pub const fn expect_pseudo(self) -> PseudoInstruction {
+        self.pseudo()
+            .expect("Expected Instruction::Pseudo, found Instruction::Real")
+    }
+}
+
+pub trait InstructionMetadata {
+    /// Gets the label stored inside this instruction, if it exists.
+    fn label_arg(&self) -> Option<Arg<Label>>;
+
+    /// Whether this is an unconditional branching.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, InstructionMetadata};
+    /// let jump_inst = Instruction::JumpForward { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
+    fn unconditional_branch(&self) -> bool;
+
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, InstructionMetadata};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = Instruction::JumpForward { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
+
+    #[allow(clippy::too_many_arguments)]
+    fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result;
+
+    fn display<'a>(
+        &'a self,
+        arg: OpArg,
+        ctx: &'a impl InstrDisplayContext,
+    ) -> impl fmt::Display + 'a {
+        struct FmtFn<F>(F);
+        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                (self.0)(f)
+            }
+        }
+        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct Arg<T: OpArgType>(PhantomData<T>);
 
@@ -918,6 +1103,20 @@ impl<T: OpArgType> fmt::Debug for Arg<T> {
     }
 }
 
+/// Encode LOAD_ATTR oparg: bit 0 = method flag, bits 1+ = name index.
+#[inline]
+pub const fn encode_load_attr_arg(name_idx: u32, is_method: bool) -> u32 {
+    (name_idx << 1) | (is_method as u32)
+}
+
+/// Decode LOAD_ATTR oparg: returns (name_idx, is_method).
+#[inline]
+pub const fn decode_load_attr_arg(oparg: u32) -> (u32, bool) {
+    let is_method = (oparg & 1) == 1;
+    let name_idx = oparg >> 1;
+    (name_idx, is_method)
+}
+
 /// Encode LOAD_SUPER_ATTR oparg: bit 0 = load_method, bit 1 = has_class, bits 2+ = name index.
 #[inline]
 pub const fn encode_load_super_attr_arg(name_idx: u32, load_method: bool, has_class: bool) -> u32 {
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index ba8a8eb1f25..c662a0a9260 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -80,7 +80,7 @@ impl OpArgState {
     #[inline(always)]
     pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
         let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
+        if !matches!(ins.op, Instruction::ExtendedArg) {
             self.reset();
         }
         (ins.op, arg)
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 1901d3e8a49..64cbb2fd062 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -212,7 +212,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             match instruction {
                 Instruction::ReturnValue
                 | Instruction::ReturnConst { .. }
-                | Instruction::Jump { .. }
                 | Instruction::JumpBackward { .. }
                 | Instruction::JumpBackwardNoInterrupt { .. }
                 | Instruction::JumpForward { .. } => {
@@ -561,8 +560,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
             Instruction::ExtendedArg => Ok(()),
 
-            Instruction::Jump { target }
-            | Instruction::JumpBackward { target }
+            Instruction::JumpBackward { target }
             | Instruction::JumpBackwardNoInterrupt { target }
             | Instruction::JumpForward { target } => {
                 let target_block = self.get_or_create_block(target.get(arg));
@@ -596,10 +594,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
             }
             Instruction::Nop => Ok(()),
-            Instruction::PopBlock => {
-                // TODO: block support
-                Ok(())
-            }
             Instruction::PopJumpIfFalse { target } => {
                 let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 let val = self.boolean_val(cond)?;
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 3b0d8564ff6..fcde0de36ef 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -5,29 +5,43 @@ mod opcode {
     use crate::vm::{
         AsObject, PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyInt, PyIntRef},
-        bytecode::Instruction,
+        bytecode::{AnyInstruction, Instruction, InstructionMetadata, PseudoInstruction},
     };
     use core::ops::Deref;
 
-    struct Opcode(Instruction);
+    #[derive(Clone, Copy)]
+    struct Opcode(AnyInstruction);
 
     impl Deref for Opcode {
-        type Target = Instruction;
+        type Target = AnyInstruction;
 
         fn deref(&self) -> &Self::Target {
             &self.0
         }
     }
 
+    impl TryFrom<i32> for Opcode {
+        type Error = ();
+
+        fn try_from(value: i32) -> Result<Self, Self::Error> {
+            Ok(Self(
+                u16::try_from(value)
+                    .map_err(|_| ())?
+                    .try_into()
+                    .map_err(|_| ())?,
+            ))
+        }
+    }
+
     impl Opcode {
         // https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Include/opcode_ids.h#L238
         const HAVE_ARGUMENT: i32 = 44;
 
         pub fn try_from_pyint(raw: PyIntRef, vm: &VirtualMachine) -> PyResult<Self> {
             let instruction = raw
-                .try_to_primitive::<u8>(vm)
+                .try_to_primitive::<u16>(vm)
                 .and_then(|v| {
-                    Instruction::try_from(v).map_err(|_| {
+                    AnyInstruction::try_from(v).map_err(|_| {
                         vm.new_exception_empty(vm.ctx.exceptions.value_error.to_owned())
                     })
                 })
@@ -36,13 +50,14 @@ mod opcode {
             Ok(Self(instruction))
         }
 
-        /// Check if opcode is valid (can be converted to an Instruction)
+        const fn inner(self) -> AnyInstruction {
+            self.0
+        }
+
+        /// Check if opcode is valid (can be converted to an AnyInstruction)
         #[must_use]
         pub fn is_valid(opcode: i32) -> bool {
-            if !(0..=255).contains(&opcode) {
-                return false;
-            }
-            Instruction::try_from(opcode as u8).is_ok()
+            Self::try_from(opcode).is_ok()
         }
 
         /// Check if instruction has an argument
@@ -54,79 +69,82 @@ mod opcode {
         /// Check if instruction uses co_consts
         #[must_use]
         pub fn has_const(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::LoadConst { .. } | Instruction::ReturnConst { .. })
-                )
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
+                ))
+            )
         }
 
         /// Check if instruction uses co_names
         #[must_use]
         pub fn has_name(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteAttr { .. }
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteAttr { .. }
                         | Instruction::DeleteGlobal(_)
                         | Instruction::DeleteName(_)
                         | Instruction::ImportFrom { .. }
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
                         | Instruction::LoadGlobal(_)
-                        | Instruction::LoadAttrMethod { .. }
                         | Instruction::LoadName(_)
                         | Instruction::StoreAttr { .. }
                         | Instruction::StoreGlobal(_)
-                        | Instruction::StoreName(_))
-                )
+                        | Instruction::StoreName(_)
+                ) | AnyInstruction::Pseudo(PseudoInstruction::LoadAttrMethod { .. }))
+            )
         }
 
         /// Check if instruction is a jump
         #[must_use]
         pub fn has_jump(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::Break { .. }
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::Break { .. }
                         | Instruction::Continue { .. }
                         | Instruction::ForIter { .. }
                         | Instruction::JumpIfFalseOrPop { .. }
                         | Instruction::JumpIfNotExcMatch(_)
                         | Instruction::JumpIfTrueOrPop { .. }
-                        | Instruction::Jump { .. }
                         | Instruction::PopJumpIfFalse { .. }
                         | Instruction::PopJumpIfTrue { .. }
-                        | Instruction::Send { .. })
-                )
+                        | Instruction::Send { .. }
+                ) | AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }))
+            )
         }
 
         /// Check if instruction uses co_freevars/co_cellvars
         #[must_use]
         pub fn has_free(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteDeref(_)
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteDeref(_)
                         | Instruction::LoadFromDictOrDeref(_)
                         | Instruction::LoadClosure(_)
                         | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_))
-                )
+                        | Instruction::StoreDeref(_)
+                ))
+            )
         }
 
         /// Check if instruction uses co_varnames (local variables)
         #[must_use]
         pub fn has_local(opcode: i32) -> bool {
-            Self::is_valid(opcode)
-                && matches!(
-                    Instruction::try_from(opcode as u8),
-                    Ok(Instruction::DeleteFast(_)
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteFast(_)
                         | Instruction::LoadFast(_)
                         | Instruction::LoadFastAndClear(_)
                         | Instruction::StoreFast(_)
-                        | Instruction::StoreFastLoadFast { .. })
-                )
+                        | Instruction::StoreFastLoadFast { .. }
+                ))
+            )
         }
 
         /// Check if instruction has exception info
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 5fb44d8a58b..bd4d01de9f5 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -7,7 +7,7 @@ use crate::{
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
     },
-    bytecode,
+    bytecode::{self, Instruction},
     convert::{IntoObject, ToPyResult},
     coroutine::Coro,
     exceptions::ExceptionCtor,
@@ -24,6 +24,7 @@ use core::iter::zip;
 use core::sync::atomic;
 use indexmap::IndexMap;
 use itertools::Itertools;
+
 use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
 use rustpython_compiler_core::SourceLocation;
 
@@ -387,15 +388,15 @@ impl ExecutingFrame<'_> {
                     }
 
                     // Check if this is a RERAISE instruction
-                    // Both Instruction::Raise { kind: Reraise/ReraiseFromStack } and
-                    // Instruction::Reraise are reraise operations that should not add
+                    // Both AnyInstruction::Raise { kind: Reraise/ReraiseFromStack } and
+                    // AnyInstruction::Reraise are reraise operations that should not add
                     // new traceback entries
                     let is_reraise = match op {
-                        bytecode::Instruction::RaiseVarargs { kind } => matches!(
+                        Instruction::RaiseVarargs { kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
-                        bytecode::Instruction::Reraise { .. } => true,
+                        Instruction::Reraise { .. } => true,
                         _ => false,
                     };
 
@@ -439,13 +440,13 @@ impl ExecutingFrame<'_> {
         let lasti = self.lasti() as usize;
         if let Some(unit) = self.code.instructions.get(lasti) {
             match &unit.op {
-                bytecode::Instruction::Send { .. } => return Some(self.top_value()),
-                bytecode::Instruction::Resume { .. } => {
+                Instruction::Send { .. } => return Some(self.top_value()),
+                Instruction::Resume { .. } => {
                     // Check if previous instruction was YIELD_VALUE with arg >= 1
                     // This indicates yield-from/await context
                     if lasti > 0
                         && let Some(prev_unit) = self.code.instructions.get(lasti - 1)
-                        && let bytecode::Instruction::YieldValue { .. } = &prev_unit.op
+                        && let Instruction::YieldValue { .. } = &prev_unit.op
                     {
                         // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
                         // OpArgByte.0 is the raw byte value
@@ -550,7 +551,7 @@ impl ExecutingFrame<'_> {
     #[inline(always)]
     fn execute_instruction(
         &mut self,
-        instruction: bytecode::Instruction,
+        instruction: Instruction,
         arg: bytecode::OpArg,
         extend_arg: &mut bool,
         vm: &VirtualMachine,
@@ -584,7 +585,7 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            bytecode::Instruction::BeforeAsyncWith => {
+            Instruction::BeforeAsyncWith => {
                 let mgr = self.pop_value();
                 let error_string = || -> String {
                     format!(
@@ -609,8 +610,8 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinarySubscr => {
+            Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
+            Instruction::BinarySubscr => {
                 let key = self.pop_value();
                 let container = self.pop_value();
                 let result = container.get_item(key.as_object(), vm)?;
@@ -618,30 +619,30 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
 
-            bytecode::Instruction::Break { target } => self.unwind_blocks(
+            Instruction::Break { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Break {
                     target: target.get(arg),
                 },
             ),
-            bytecode::Instruction::BuildListFromTuples { size } => {
+            Instruction::BuildListFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildList { size } => {
+            Instruction::BuildList { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildMapForCall { size } => {
+            Instruction::BuildMapForCall { size } => {
                 self.execute_build_map_for_call(vm, size.get(arg))
             }
-            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildSetFromTuples { size } => {
+            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
+            Instruction::BuildSetFromTuples { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     // SAFETY: trust compiler
@@ -653,7 +654,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSet { size } => {
+            Instruction::BuildSet { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
                     set.add(element, vm)?;
@@ -661,11 +662,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildSlice { argc } => {
-                self.execute_build_slice(vm, argc.get(arg))
-            }
+            Instruction::BuildSlice { argc } => self.execute_build_slice(vm, argc.get(arg)),
             /*
-             bytecode::Instruction::ToBool => {
+             Instruction::ToBool => {
                  dbg!("Shouldn't be called outside of match statements for now")
                  let value = self.pop_value();
                  // call __bool__
@@ -674,7 +673,7 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            bytecode::Instruction::BuildString { size } => {
+            Instruction::BuildString { size } => {
                 let s: Wtf8Buf = self
                     .pop_multiple(size.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
@@ -682,7 +681,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTupleFromIter => {
+            Instruction::BuildTupleFromIter => {
                 if !self.top_value().class().is(vm.ctx.types.tuple_type) {
                     let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
                     let list_obj = vm.ctx.new_tuple(elements);
@@ -690,48 +689,48 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::BuildTupleFromTuples { size } => {
+            Instruction::BuildTupleFromTuples { size } => {
                 // SAFETY: compiler guarantees `size` tuples are on the stack
                 let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::BuildTuple { size } => {
+            Instruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::Call { nargs } => {
+            Instruction::Call { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
                 let args = self.collect_positional_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallKw { nargs } => {
+            Instruction::CallKw { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+            Instruction::CallFunctionEx { has_kwargs } => {
                 // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
                 let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
                 self.execute_call(args, vm)
             }
-            bytecode::Instruction::CallIntrinsic1 { func } => {
+            Instruction::CallIntrinsic1 { func } => {
                 let value = self.pop_value();
                 let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic2 { func } => {
+            Instruction::CallIntrinsic2 { func } => {
                 let value2 = self.pop_value();
                 let value1 = self.pop_value();
                 let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
                 self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::CheckEgMatch => {
+            Instruction::CheckEgMatch => {
                 let match_type = self.pop_value();
                 let exc_value = self.pop_value();
                 let (rest, matched) =
@@ -740,8 +739,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            bytecode::Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
-            bytecode::Instruction::ContainsOp(invert) => {
+            Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
+            Instruction::ContainsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
 
@@ -752,17 +751,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            bytecode::Instruction::Continue { target } => self.unwind_blocks(
+            Instruction::Continue { target } => self.unwind_blocks(
                 vm,
                 UnwindReason::Continue {
                     target: target.get(arg),
                 },
             ),
 
-            bytecode::Instruction::ConvertValue { oparg: conversion } => {
+            Instruction::ConvertValue { oparg: conversion } => {
                 self.convert_value(conversion.get(arg), vm)
             }
-            bytecode::Instruction::Copy { index } => {
+            Instruction::Copy { index } => {
                 // CopyItem { index: 1 } copies TOS
                 // CopyItem { index: 2 } copies second from top
                 // This is 1-indexed to match CPython
@@ -778,12 +777,12 @@ impl ExecutingFrame<'_> {
                 self.push_value_opt(value);
                 Ok(None)
             }
-            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteDeref(i) => {
+            Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
+            Instruction::DeleteDeref(i) => {
                 self.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
-            bytecode::Instruction::DeleteFast(idx) => {
+            Instruction::DeleteFast(idx) => {
                 let mut fastlocals = self.fastlocals.lock();
                 let idx = idx.get(arg) as usize;
                 if fastlocals[idx].is_none() {
@@ -798,7 +797,7 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            bytecode::Instruction::DeleteGlobal(idx) => {
+            Instruction::DeleteGlobal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
@@ -809,7 +808,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteName(idx) => {
+            Instruction::DeleteName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let res = self.locals.mapping().ass_subscript(name, None, vm);
 
@@ -822,8 +821,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            bytecode::Instruction::DictUpdate { index } => {
+            Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
+            Instruction::DictUpdate { index } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
@@ -859,7 +858,7 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::EndAsyncFor => {
+            Instruction::EndAsyncFor => {
                 // END_ASYNC_FOR pops (awaitable, exc) from stack
                 // Stack: [awaitable, exc] -> []
                 // exception_unwind pushes exception to stack before jumping to handler
@@ -879,19 +878,19 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            bytecode::Instruction::ExtendedArg => {
+            Instruction::ExtendedArg => {
                 *extend_arg = true;
                 Ok(None)
             }
-            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
-            bytecode::Instruction::FormatSimple => {
+            Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            Instruction::FormatSimple => {
                 let value = self.pop_value();
                 let formatted = vm.format(&value, vm.ctx.new_str(""))?;
                 self.push_value(formatted.into());
 
                 Ok(None)
             }
-            bytecode::Instruction::FormatWithSpec => {
+            Instruction::FormatWithSpec => {
                 let spec = self.pop_value();
                 let value = self.pop_value();
                 let formatted = vm.format(&value, spec.downcast::<PyStr>().unwrap())?;
@@ -899,13 +898,13 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::GetAIter => {
+            Instruction::GetAIter => {
                 let aiterable = self.pop_value();
                 let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
                 self.push_value(aiter);
                 Ok(None)
             }
-            bytecode::Instruction::GetANext => {
+            Instruction::GetANext => {
                 #[cfg(debug_assertions)] // remove when GetANext is fully implemented
                 let orig_stack_len = self.state.stack.len();
 
@@ -950,7 +949,7 @@ impl ExecutingFrame<'_> {
                 debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            bytecode::Instruction::GetAwaitable => {
+            Instruction::GetAwaitable => {
                 use crate::protocol::PyIter;
 
                 let awaited_obj = self.pop_value();
@@ -986,13 +985,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(awaitable);
                 Ok(None)
             }
-            bytecode::Instruction::GetIter => {
+            Instruction::GetIter => {
                 let iterated_obj = self.pop_value();
                 let iter_obj = iterated_obj.get_iter(vm)?;
                 self.push_value(iter_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::GetYieldFromIter => {
+            Instruction::GetYieldFromIter => {
                 // GET_YIELD_FROM_ITER: prepare iterator for yield from
                 // If iterable is a coroutine, ensure we're in a coroutine context
                 // If iterable is a generator, use it directly
@@ -1017,23 +1016,23 @@ impl ExecutingFrame<'_> {
                 self.push_value(iter);
                 Ok(None)
             }
-            bytecode::Instruction::GetLen => {
+            Instruction::GetLen => {
                 // STACK.append(len(STACK[-1]))
                 let obj = self.top_value();
                 let len = obj.length(vm)?;
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            bytecode::Instruction::ImportFrom { idx } => {
+            Instruction::ImportFrom { idx } => {
                 let obj = self.import_from(vm, idx.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            bytecode::Instruction::ImportName { idx } => {
+            Instruction::ImportName { idx } => {
                 self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
                 Ok(None)
             }
-            bytecode::Instruction::IsOp(invert) => {
+            Instruction::IsOp(invert) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1045,10 +1044,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
+            Instruction::JumpIfFalseOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfNotExcMatch(target) => {
+            Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 if let Some(tuple_of_exceptions) = b.downcast_ref::<PyTuple>() {
@@ -1071,26 +1070,22 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
+            Instruction::JumpIfTrueOrPop { target } => {
                 self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            bytecode::Instruction::Jump { target } => {
+            Instruction::JumpForward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::JumpForward { target } => {
+            Instruction::JumpBackward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::JumpBackward { target } => {
+            Instruction::JumpBackwardNoInterrupt { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
             }
-            bytecode::Instruction::JumpBackwardNoInterrupt { target } => {
-                self.jump(target.get(arg));
-                Ok(None)
-            }
-            bytecode::Instruction::ListAppend { i } => {
+            Instruction::ListAppend { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let list: &Py<PyList> = unsafe {
@@ -1100,23 +1095,13 @@ impl ExecutingFrame<'_> {
                 list.append(item);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::LoadAttrMethod { .. } => {
-                unreachable!("LoadAttrMethod is converted to LoadAttr during compilation")
-            }
-            bytecode::Instruction::LoadSuperAttr { arg: idx } => {
-                self.load_super_attr(vm, idx.get(arg))
-            }
-            bytecode::Instruction::LoadSuperMethod { .. }
-            | bytecode::Instruction::LoadZeroSuperAttr { .. }
-            | bytecode::Instruction::LoadZeroSuperMethod { .. } => {
-                unreachable!("LOAD_SUPER_* pseudo instructions are converted during compilation")
-            }
-            bytecode::Instruction::LoadBuildClass => {
+            Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            Instruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
+            Instruction::LoadBuildClass => {
                 self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFromDictOrDeref(i) => {
+            Instruction::LoadFromDictOrDeref(i) => {
                 let i = i.get(arg) as usize;
                 let name = if i < self.code.cellvars.len() {
                     self.code.cellvars[i]
@@ -1132,16 +1117,16 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            bytecode::Instruction::LoadClosure(i) => {
+            Instruction::LoadClosure(i) => {
                 let value = self.cells_frees[i.get(arg) as usize].clone();
                 self.push_value(value.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadConst { idx } => {
+            Instruction::LoadConst { idx } => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadDeref(i) => {
+            Instruction::LoadDeref(i) => {
                 let i = i.get(arg) as usize;
                 let x = self.cells_frees[i]
                     .get()
@@ -1149,7 +1134,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFast(idx) => {
+            Instruction::LoadFast(idx) => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -1167,7 +1152,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadFastAndClear(idx) => {
+            Instruction::LoadFastAndClear(idx) => {
                 // Load value and clear the slot (for inlined comprehensions)
                 // If slot is empty, push None (not an error - variable may not exist yet)
                 let idx = idx.get(arg) as usize;
@@ -1177,13 +1162,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadGlobal(idx) => {
+            Instruction::LoadGlobal(idx) => {
                 let name = &self.code.names[idx.get(arg) as usize];
                 let x = self.load_global_or_builtin(name, vm)?;
                 self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::LoadName(idx) => {
+            Instruction::LoadName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let result = self.locals.mapping().subscript(name, vm);
                 match result {
@@ -1195,8 +1180,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::MapAdd { i } => {
+            Instruction::MakeFunction => self.execute_make_function(vm),
+            Instruction::MapAdd { i } => {
                 let value = self.pop_value();
                 let key = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
@@ -1207,7 +1192,7 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::MatchClass(nargs) => {
+            Instruction::MatchClass(nargs) => {
                 // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
                 // nargs is the number of positional sub-patterns.
                 let kwd_attrs = self.pop_value();
@@ -1328,7 +1313,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MatchKeys => {
+            Instruction::MatchKeys => {
                 // MATCH_KEYS doesn't pop subject and keys, only reads them
                 let keys_tuple = self.top_value(); // stack[-1]
                 let subject = self.nth_value(1); // stack[-2]
@@ -1394,7 +1379,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::MatchMapping => {
+            Instruction::MatchMapping => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1405,7 +1390,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_mapping).into());
                 Ok(None)
             }
-            bytecode::Instruction::MatchSequence => {
+            Instruction::MatchSequence => {
                 // Pop and push back the subject to keep it on stack
                 let subject = self.pop_value();
 
@@ -1416,11 +1401,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(is_sequence).into());
                 Ok(None)
             }
-            bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::PopBlock => {
-                unreachable!("PopBlock is converted to Nop during compilation")
-            }
-            bytecode::Instruction::PopExcept => {
+            Instruction::Nop => Ok(None),
+            Instruction::PopExcept => {
                 // Pop prev_exc from value stack and restore it
                 let prev_exc = self.pop_value();
                 if vm.is_none(&prev_exc) {
@@ -1438,24 +1420,20 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::PopJumpIfFalse { target } => {
-                self.pop_jump_if(vm, target.get(arg), false)
-            }
-            bytecode::Instruction::PopJumpIfTrue { target } => {
-                self.pop_jump_if(vm, target.get(arg), true)
-            }
-            bytecode::Instruction::PopTop => {
+            Instruction::PopJumpIfFalse { target } => self.pop_jump_if(vm, target.get(arg), false),
+            Instruction::PopJumpIfTrue { target } => self.pop_jump_if(vm, target.get(arg), true),
+            Instruction::PopTop => {
                 // Pop value from stack and ignore.
                 self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::PushNull => {
+            Instruction::PushNull => {
                 // Push NULL for self_or_null slot in call protocol
                 self.push_null();
                 Ok(None)
             }
-            bytecode::Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
-            bytecode::Instruction::Resume { arg: resume_arg } => {
+            Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
+            Instruction::Resume { arg: resume_arg } => {
                 // Resume execution after yield, await, or at function start
                 // In CPython, this checks instrumentation and eval breaker
                 // For now, we just check for signals/interrupts
@@ -1467,15 +1445,15 @@ impl ExecutingFrame<'_> {
                 // }
                 Ok(None)
             }
-            bytecode::Instruction::ReturnConst { idx } => {
+            Instruction::ReturnConst { idx } => {
                 let value = self.code.constants[idx.get(arg) as usize].clone().into();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::ReturnValue => {
+            Instruction::ReturnValue => {
                 let value = self.pop_value();
                 self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::SetAdd { i } => {
+            Instruction::SetAdd { i } => {
                 let item = self.pop_value();
                 let obj = self.nth_value(i.get(arg));
                 let set: &Py<PySet> = unsafe {
@@ -1485,7 +1463,7 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::SetExcInfo => {
+            Instruction::SetExcInfo => {
                 // Set the current exception to TOS (for except* handlers)
                 // This updates sys.exc_info() so bare 'raise' will reraise the matched exception
                 let exc = self.top_value();
@@ -1494,7 +1472,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::PushExcInfo => {
+            Instruction::PushExcInfo => {
                 // Stack: [exc] -> [prev_exc, exc]
                 let exc = self.pop_value();
                 let prev_exc = vm
@@ -1511,7 +1489,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(exc);
                 Ok(None)
             }
-            bytecode::Instruction::CheckExcMatch => {
+            Instruction::CheckExcMatch => {
                 // Stack: [exc, type] -> [exc, bool]
                 let exc_type = self.pop_value();
                 let exc = self.top_value();
@@ -1521,7 +1499,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(result).into());
                 Ok(None)
             }
-            bytecode::Instruction::Reraise { depth } => {
+            Instruction::Reraise { depth } => {
                 // inst(RERAISE, (values[oparg], exc -- values[oparg]))
                 //
                 // Stack layout: [values..., exc] where len(values) == oparg
@@ -1548,11 +1526,11 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            bytecode::Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { attr } => {
                 self.execute_set_function_attribute(vm, attr.get(arg))
             }
-            bytecode::Instruction::SetupAnnotations => self.setup_annotations(vm),
-            bytecode::Instruction::BeforeWith => {
+            Instruction::SetupAnnotations => self.setup_annotations(vm),
+            Instruction::BeforeWith => {
                 // TOS: context_manager
                 // Result: [..., __exit__, __enter__ result]
                 let context_manager = self.pop_value();
@@ -1581,18 +1559,18 @@ impl ExecutingFrame<'_> {
                 self.push_value(enter_res);
                 Ok(None)
             }
-            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreDeref(i) => {
+            Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
+            Instruction::StoreDeref(i) => {
                 let value = self.pop_value();
                 self.cells_frees[i.get(arg) as usize].set(Some(value));
                 Ok(None)
             }
-            bytecode::Instruction::StoreFast(idx) => {
+            Instruction::StoreFast(idx) => {
                 let value = self.pop_value();
                 self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
                 Ok(None)
             }
-            bytecode::Instruction::StoreFastLoadFast {
+            Instruction::StoreFastLoadFast {
                 store_idx,
                 load_idx,
             } => {
@@ -1607,21 +1585,21 @@ impl ExecutingFrame<'_> {
                 self.push_value(load_value);
                 Ok(None)
             }
-            bytecode::Instruction::StoreGlobal(idx) => {
+            Instruction::StoreGlobal(idx) => {
                 let value = self.pop_value();
                 self.globals
                     .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreName(idx) => {
+            Instruction::StoreName(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals.mapping().ass_subscript(name, Some(value), vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::StoreSubscr => self.execute_store_subscript(vm),
-            bytecode::Instruction::Subscript => self.execute_subscript(vm),
-            bytecode::Instruction::Swap { index } => {
+            Instruction::StoreSubscr => self.execute_store_subscript(vm),
+            Instruction::Subscript => self.execute_subscript(vm),
+            Instruction::Swap { index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -1638,20 +1616,18 @@ impl ExecutingFrame<'_> {
                 self.state.stack.swap(i, j);
                 Ok(None)
             }
-            bytecode::Instruction::ToBool => {
+            Instruction::ToBool => {
                 let obj = self.pop_value();
                 let bool_val = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            bytecode::Instruction::UnpackEx { args } => {
+            Instruction::UnpackEx { args } => {
                 let args = args.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            bytecode::Instruction::UnpackSequence { size } => {
-                self.unpack_sequence(size.get(arg), vm)
-            }
-            bytecode::Instruction::WithExceptStart => {
+            Instruction::UnpackSequence { size } => self.unpack_sequence(size.get(arg), vm),
+            Instruction::WithExceptStart => {
                 // Stack: [..., __exit__, lasti, prev_exc, exc]
                 // Call __exit__(type, value, tb) and push result
                 // __exit__ is at TOS-3 (below lasti, prev_exc, and exc)
@@ -1674,7 +1650,7 @@ impl ExecutingFrame<'_> {
 
                 Ok(None)
             }
-            bytecode::Instruction::YieldValue { arg: oparg } => {
+            Instruction::YieldValue { arg: oparg } => {
                 let value = self.pop_value();
                 // arg=0: direct yield (wrapped for async generators)
                 // arg=1: yield from await/yield-from (NOT wrapped)
@@ -1686,7 +1662,7 @@ impl ExecutingFrame<'_> {
                 };
                 Ok(Some(ExecutionResult::Yield(value)))
             }
-            bytecode::Instruction::Send { target } => {
+            Instruction::Send { target } => {
                 // Stack: (receiver, value) -> (receiver, retval)
                 // On StopIteration: replace value with stop value and jump to target
                 let exit_label = target.get(arg);
@@ -1710,7 +1686,7 @@ impl ExecutingFrame<'_> {
                     }
                 }
             }
-            bytecode::Instruction::EndSend => {
+            Instruction::EndSend => {
                 // Stack: (receiver, value) -> (value)
                 // Pops receiver, leaves value
                 let value = self.pop_value();
@@ -1718,7 +1694,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::CleanupThrow => {
+            Instruction::CleanupThrow => {
                 // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) OR re-raise
                 // If StopIteration: pop all 3, extract value, push (None, value)
                 // Otherwise: pop all 3, return Err(exc) for unwind_blocks to handle
@@ -1756,19 +1732,19 @@ impl ExecutingFrame<'_> {
                     .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
                 Err(exc)
             }
-            bytecode::Instruction::UnaryInvert => {
+            Instruction::UnaryInvert => {
                 let a = self.pop_value();
                 let value = vm._invert(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::UnaryNegative => {
+            Instruction::UnaryNegative => {
                 let a = self.pop_value();
                 let value = vm._neg(&a)?;
                 self.push_value(value);
                 Ok(None)
             }
-            bytecode::Instruction::UnaryNot => {
+            Instruction::UnaryNot => {
                 let obj = self.pop_value();
                 let value = obj.try_to_bool(vm)?;
                 self.push_value(vm.ctx.new_bool(!value).into());
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
index b7d6228ab75..dc913e1a7ee 100644
--- a/scripts/generate_opcode_metadata.py
+++ b/scripts/generate_opcode_metadata.py
@@ -37,10 +37,10 @@ def __lt__(self, other: typing.Self) -> bool:
         return self.id < other.id
 
 
-def extract_enum_body(contents: str) -> str:
-    res = re.search(r"pub enum Instruction \{(.+?)\n\}", contents, re.DOTALL)
+def extract_enum_body(contents: str, enum_name: str) -> str:
+    res = re.search(f"pub enum {enum_name} " + r"\{(.+?)\n\}", contents, re.DOTALL)
     if not res:
-        raise ValueError("Could not find Instruction enum")
+        raise ValueError(f"Could not find {enum_name} enum")
 
     return "\n".join(
         line.split("//")[0].strip()  # Remove any comment. i.e. "foo // some comment"
@@ -50,7 +50,10 @@ def extract_enum_body(contents: str) -> str:
 
 
 contents = BYTECODE_FILE.read_text()
-enum_body = extract_enum_body(contents)
+enum_body = "\n".join(
+    extract_enum_body(contents, enum_name)
+    for enum_name in ("Instruction", "PseudoInstruction")
+)
 opcodes = list(Opcode.from_str(enum_body))
 
 # Generate the output file

From b214362ca1c4105596a1c79014671f76153fb6ef Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 15 Jan 2026 08:36:56 +0900
Subject: [PATCH 292/418] remove polluting tests (#6733)

---
 .github/workflows/ci.yaml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 778890a9f3e..8095760cd30 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -109,13 +109,11 @@ env:
   ENV_POLLUTING_TESTS_LINUX: >-
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_forkserver.test_processes
-    test.test_multiprocessing_forkserver.test_threads
     test.test_multiprocessing_spawn.test_processes
     test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_spawn.test_processes
-    test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_WINDOWS: >-
   # Python version targeted by the CI.
   PYTHON_VERSION: "3.13.1"

From c06701abc8664dc883ba90864f13bb8e77c43b61 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Thu, 15 Jan 2026 14:29:41 +0900
Subject: [PATCH 293/418] skip
 test_multiprocessing_{fork,spawn}.test_threads.py (#6735)

---
 .github/workflows/ci.yaml                           | 1 -
 Lib/test/test_multiprocessing_fork/test_threads.py  | 5 +----
 Lib/test/test_multiprocessing_spawn/test_threads.py | 5 +----
 3 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8095760cd30..b8263026d51 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -110,7 +110,6 @@ env:
     test.test_multiprocessing_fork.test_processes
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_spawn.test_processes
-    test.test_multiprocessing_spawn.test_threads
   ENV_POLLUTING_TESTS_MACOS: >-
     test.test_multiprocessing_forkserver.test_processes
     test.test_multiprocessing_spawn.test_processes
diff --git a/Lib/test/test_multiprocessing_fork/test_threads.py b/Lib/test/test_multiprocessing_fork/test_threads.py
index b7b519bcb06..1065ebf7fe4 100644
--- a/Lib/test/test_multiprocessing_fork/test_threads.py
+++ b/Lib/test/test_multiprocessing_fork/test_threads.py
@@ -5,10 +5,7 @@
 
 import os, sys  # TODO: RUSTPYTHON
 class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
-    @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
-        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
-    )  # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; flaky environment pollution when running rustpython -m test --fail-env-changed due to unknown reason")
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
 
 class WithThreadsTestManagerRestart(WithThreadsTestManagerRestart):  # TODO: RUSTPYTHON
diff --git a/Lib/test/test_multiprocessing_spawn/test_threads.py b/Lib/test/test_multiprocessing_spawn/test_threads.py
index f6aca3050e4..54c52c4188b 100644
--- a/Lib/test/test_multiprocessing_spawn/test_threads.py
+++ b/Lib/test/test_multiprocessing_spawn/test_threads.py
@@ -5,10 +5,7 @@
 
 import os, sys  # TODO: RUSTPYTHON
 class WithThreadsTestPool(WithThreadsTestPool):  # TODO: RUSTPYTHON
-    @unittest.skipIf(  # TODO: RUSTPYTHON
-        sys.platform in ('darwin', 'linux') and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
-        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
-    )  # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; flaky environment pollution when running rustpython -m test --fail-env-changed due to unknown reason")
     def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
 
 if __name__ == '__main__':

From 2a2caa1897670ad29fc730196e90c7edfe5b54ee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 15 Jan 2026 17:20:34 +0900
Subject: [PATCH 294/418] Bump rand_core from 0.9.4 to 0.9.5 (#6731)

Bumps [rand_core](https://github.com/rust-random/rand) from 0.9.4 to 0.9.5.
- [Release notes](https://github.com/rust-random/rand/releases)
- [Changelog](https://github.com/rust-random/rand/blob/master/CHANGELOG.md)
- [Commits](https://github.com/rust-random/rand/commits)

---
updated-dependencies:
- dependency-name: rand_core
  dependency-version: 0.9.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b3ff4cf6656..fd55efe3231 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1959,7 +1959,7 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df7151a832e54d2d6b2c827a20e5bcdd80359281cd2c354e725d4b82e7c471de"
 dependencies = [
- "rand_core 0.9.4",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2597,7 +2597,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
- "rand_core 0.9.4",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2617,7 +2617,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.4",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2631,9 +2631,9 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f1b3bc831f92381018fd9c6350b917c7b21f1eed35a65a51900e0e55a3d7afa"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
 dependencies = [
  "getrandom 0.3.4",
 ]
@@ -3193,7 +3193,7 @@ dependencies = [
  "phf 0.13.1",
  "pkcs8",
  "pymath",
- "rand_core 0.9.4",
+ "rand_core 0.9.5",
  "rustix",
  "rustls",
  "rustls-native-certs",

From a3d1b5e7acf8e8f52336b17eec1f96a229c964d5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 15 Jan 2026 17:21:22 +0900
Subject: [PATCH 295/418] Bump xml from 1.2.0 to 1.2.1 (#6730)

Bumps [xml](https://github.com/kornelski/xml-rs) from 1.2.0 to 1.2.1.
- [Changelog](https://github.com/kornelski/xml-rs/blob/main/Changelog.md)
- [Commits](https://github.com/kornelski/xml-rs/compare/1.2.0...1.2.1)

---
updated-dependencies:
- dependency-name: xml
  dependency-version: 1.2.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index fd55efe3231..1ce839a96d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4755,9 +4755,9 @@ dependencies = [
 
 [[package]]
 name = "xml"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2df5825faced2427b2da74d9100f1e2e93c533fff063506a81ede1cf517b2e7e"
+checksum = "b8aa498d22c9bbaf482329839bc5620c46be275a19a812e9a22a2b07529a642a"
 
 [[package]]
 name = "xz2"

From c5deb740ac2bed6bde0212fca7dc32e64381c8a6 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Thu, 15 Jan 2026 03:35:01 -0500
Subject: [PATCH 296/418] Update asyncio library (#6601)

* Updated asyncio to v3.13.11

* Removed expectedFailure from `test_async_case.py`
---
 Lib/asyncio/__main__.py                   | 126 +++++++++---
 Lib/asyncio/base_events.py                | 221 ++++++++++++++--------
 Lib/asyncio/base_subprocess.py            |  56 ++++--
 Lib/asyncio/events.py                     |  20 +-
 Lib/asyncio/format_helpers.py             |  22 ++-
 Lib/asyncio/futures.py                    |  25 ++-
 Lib/asyncio/locks.py                      | 153 +++++++++------
 Lib/asyncio/proactor_events.py            |  15 +-
 Lib/asyncio/queues.py                     |  69 ++++++-
 Lib/asyncio/runners.py                    |   1 +
 Lib/asyncio/selector_events.py            | 117 ++++++------
 Lib/asyncio/sslproto.py                   |  11 +-
 Lib/asyncio/staggered.py                  |  93 +++++----
 Lib/asyncio/streams.py                    |  81 ++++----
 Lib/asyncio/taskgroups.py                 |  98 +++++++---
 Lib/asyncio/tasks.py                      | 179 ++++++++++++------
 Lib/asyncio/timeouts.py                   |  20 +-
 Lib/asyncio/transports.py                 |   2 +
 Lib/asyncio/unix_events.py                |  38 +++-
 Lib/asyncio/windows_events.py             |  40 ++--
 Lib/test/test_unittest/test_async_case.py |   1 -
 21 files changed, 936 insertions(+), 452 deletions(-)

diff --git a/Lib/asyncio/__main__.py b/Lib/asyncio/__main__.py
index 18bb87a5bc4..8e9af83cc8a 100644
--- a/Lib/asyncio/__main__.py
+++ b/Lib/asyncio/__main__.py
@@ -1,41 +1,51 @@
 import ast
 import asyncio
-import code
 import concurrent.futures
+import contextvars
 import inspect
+import os
+import site
 import sys
 import threading
 import types
 import warnings
 
+from _colorize import can_colorize, ANSIColors  # type: ignore[import-not-found]
+from _pyrepl.console import InteractiveColoredConsole
+
 from . import futures
 
 
-class AsyncIOInteractiveConsole(code.InteractiveConsole):
+class AsyncIOInteractiveConsole(InteractiveColoredConsole):
 
     def __init__(self, locals, loop):
-        super().__init__(locals)
+        super().__init__(locals, filename="<stdin>")
         self.compile.compiler.flags |= ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
 
         self.loop = loop
+        self.context = contextvars.copy_context()
 
     def runcode(self, code):
+        global return_code
         future = concurrent.futures.Future()
 
         def callback():
+            global return_code
             global repl_future
-            global repl_future_interrupted
+            global keyboard_interrupted
 
             repl_future = None
-            repl_future_interrupted = False
+            keyboard_interrupted = False
 
             func = types.FunctionType(code, self.locals)
             try:
                 coro = func()
-            except SystemExit:
-                raise
+            except SystemExit as se:
+                return_code = se.code
+                self.loop.stop()
+                return
             except KeyboardInterrupt as ex:
-                repl_future_interrupted = True
+                keyboard_interrupted = True
                 future.set_exception(ex)
                 return
             except BaseException as ex:
@@ -47,39 +57,71 @@ def callback():
                 return
 
             try:
-                repl_future = self.loop.create_task(coro)
+                repl_future = self.loop.create_task(coro, context=self.context)
                 futures._chain_future(repl_future, future)
             except BaseException as exc:
                 future.set_exception(exc)
 
-        loop.call_soon_threadsafe(callback)
+        self.loop.call_soon_threadsafe(callback, context=self.context)
 
         try:
             return future.result()
-        except SystemExit:
-            raise
+        except SystemExit as se:
+            return_code = se.code
+            self.loop.stop()
+            return
         except BaseException:
-            if repl_future_interrupted:
-                self.write("\nKeyboardInterrupt\n")
+            if keyboard_interrupted:
+                if not CAN_USE_PYREPL:
+                    self.write("\nKeyboardInterrupt\n")
             else:
                 self.showtraceback()
-
+            return self.STATEMENT_FAILED
 
 class REPLThread(threading.Thread):
 
     def run(self):
+        global return_code
+
         try:
             banner = (
                 f'asyncio REPL {sys.version} on {sys.platform}\n'
                 f'Use "await" directly instead of "asyncio.run()".\n'
                 f'Type "help", "copyright", "credits" or "license" '
                 f'for more information.\n'
-                f'{getattr(sys, "ps1", ">>> ")}import asyncio'
             )
 
-            console.interact(
-                banner=banner,
-                exitmsg='exiting asyncio REPL...')
+            console.write(banner)
+
+            if startup_path := os.getenv("PYTHONSTARTUP"):
+                sys.audit("cpython.run_startup", startup_path)
+
+                import tokenize
+                with tokenize.open(startup_path) as f:
+                    startup_code = compile(f.read(), startup_path, "exec")
+                    exec(startup_code, console.locals)
+
+            ps1 = getattr(sys, "ps1", ">>> ")
+            if can_colorize() and CAN_USE_PYREPL:
+                ps1 = f"{ANSIColors.BOLD_MAGENTA}{ps1}{ANSIColors.RESET}"
+            console.write(f"{ps1}import asyncio\n")
+
+            if CAN_USE_PYREPL:
+                from _pyrepl.simple_interact import (
+                    run_multiline_interactive_console,
+                )
+                try:
+                    run_multiline_interactive_console(console)
+                except SystemExit:
+                    # expected via the `exit` and `quit` commands
+                    pass
+                except BaseException:
+                    # unexpected issue
+                    console.showtraceback()
+                    console.write("Internal error, ")
+                    return_code = 1
+            else:
+                console.interact(banner="", exitmsg="")
         finally:
             warnings.filterwarnings(
                 'ignore',
@@ -88,8 +130,25 @@ def run(self):
 
             loop.call_soon_threadsafe(loop.stop)
 
+    def interrupt(self) -> None:
+        if not CAN_USE_PYREPL:
+            return
+
+        from _pyrepl.simple_interact import _get_reader
+        r = _get_reader()
+        if r.threading_hook is not None:
+            r.threading_hook.add("")  # type: ignore
+
 
 if __name__ == '__main__':
+    sys.audit("cpython.run_stdin")
+
+    if os.getenv('PYTHON_BASIC_REPL'):
+        CAN_USE_PYREPL = False
+    else:
+        from _pyrepl.main import CAN_USE_PYREPL
+
+    return_code = 0
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
 
@@ -102,14 +161,31 @@ def run(self):
     console = AsyncIOInteractiveConsole(repl_locals, loop)
 
     repl_future = None
-    repl_future_interrupted = False
+    keyboard_interrupted = False
 
     try:
         import readline  # NoQA
     except ImportError:
-        pass
+        readline = None
+
+    interactive_hook = getattr(sys, "__interactivehook__", None)
 
-    repl_thread = REPLThread()
+    if interactive_hook is not None:
+        sys.audit("cpython.run_interactivehook", interactive_hook)
+        interactive_hook()
+
+    if interactive_hook is site.register_readline:
+        # Fix the completer function to use the interactive console locals
+        try:
+            import rlcompleter
+        except:
+            pass
+        else:
+            if readline is not None:
+                completer = rlcompleter.Completer(console.locals)
+                readline.set_completer(completer.complete)
+
+    repl_thread = REPLThread(name="Interactive thread")
     repl_thread.daemon = True
     repl_thread.start()
 
@@ -117,9 +193,13 @@ def run(self):
         try:
             loop.run_forever()
         except KeyboardInterrupt:
+            keyboard_interrupted = True
             if repl_future and not repl_future.done():
                 repl_future.cancel()
-                repl_future_interrupted = True
+            repl_thread.interrupt()
             continue
         else:
             break
+
+    console.write('exiting asyncio REPL...\n')
+    sys.exit(return_code)
diff --git a/Lib/asyncio/base_events.py b/Lib/asyncio/base_events.py
index 29eff0499cb..356fc3d7913 100644
--- a/Lib/asyncio/base_events.py
+++ b/Lib/asyncio/base_events.py
@@ -17,7 +17,6 @@
 import collections.abc
 import concurrent.futures
 import errno
-import functools
 import heapq
 import itertools
 import os
@@ -279,7 +278,9 @@ def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
                  ssl_handshake_timeout, ssl_shutdown_timeout=None):
         self._loop = loop
         self._sockets = sockets
-        self._active_count = 0
+        # Weak references so we don't break Transport's ability to
+        # detect abandoned transports
+        self._clients = weakref.WeakSet()
         self._waiters = []
         self._protocol_factory = protocol_factory
         self._backlog = backlog
@@ -292,14 +293,13 @@ def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
     def __repr__(self):
         return f'<{self.__class__.__name__} sockets={self.sockets!r}>'
 
-    def _attach(self):
+    def _attach(self, transport):
         assert self._sockets is not None
-        self._active_count += 1
+        self._clients.add(transport)
 
-    def _detach(self):
-        assert self._active_count > 0
-        self._active_count -= 1
-        if self._active_count == 0 and self._sockets is None:
+    def _detach(self, transport):
+        self._clients.discard(transport)
+        if len(self._clients) == 0 and self._sockets is None:
             self._wakeup()
 
     def _wakeup(self):
@@ -348,9 +348,17 @@ def close(self):
             self._serving_forever_fut.cancel()
             self._serving_forever_fut = None
 
-        if self._active_count == 0:
+        if len(self._clients) == 0:
             self._wakeup()
 
+    def close_clients(self):
+        for transport in self._clients.copy():
+            transport.close()
+
+    def abort_clients(self):
+        for transport in self._clients.copy():
+            transport.abort()
+
     async def start_serving(self):
         self._start_serving()
         # Skip one loop iteration so that all 'loop.add_reader'
@@ -422,6 +430,8 @@ def __init__(self):
         self._clock_resolution = time.get_clock_info('monotonic').resolution
         self._exception_handler = None
         self.set_debug(coroutines._is_debug_mode())
+        # The preserved state of async generator hooks.
+        self._old_agen_hooks = None
         # In debug mode, if the execution of a callback or a step of a task
         # exceed this duration in seconds, the slow callback/task is logged.
         self.slow_callback_duration = 0.1
@@ -448,26 +458,30 @@ def create_future(self):
         """Create a Future object attached to the loop."""
         return futures.Future(loop=self)
 
-    def create_task(self, coro, *, name=None, context=None):
+    def create_task(self, coro, *, name=None, context=None, **kwargs):
         """Schedule a coroutine object.
 
         Return a task object.
         """
         self._check_closed()
-        if self._task_factory is None:
-            task = tasks.Task(coro, loop=self, name=name, context=context)
+        if self._task_factory is not None:
+            if context is not None:
+                kwargs["context"] = context
+
+            task = self._task_factory(self, coro, **kwargs)
+            task.set_name(name)
+
+        else:
+            task = tasks.Task(coro, loop=self, name=name, context=context, **kwargs)
             if task._source_traceback:
                 del task._source_traceback[-1]
-        else:
-            if context is None:
-                # Use legacy API if context is not needed
-                task = self._task_factory(self, coro)
-            else:
-                task = self._task_factory(self, coro, context=context)
-
-            tasks._set_task_name(task, name)
 
-        return task
+        try:
+            return task
+        finally:
+            # gh-128552: prevent a refcycle of
+            # task.exception().__traceback__->BaseEventLoop.create_task->task
+            del task
 
     def set_task_factory(self, factory):
         """Set a task factory that will be used by loop.create_task().
@@ -475,9 +489,10 @@ def set_task_factory(self, factory):
         If factory is None the default task factory will be set.
 
         If factory is a callable, it should have a signature matching
-        '(loop, coro)', where 'loop' will be a reference to the active
-        event loop, 'coro' will be a coroutine object.  The callable
-        must return a Future.
+        '(loop, coro, **kwargs)', where 'loop' will be a reference to the active
+        event loop, 'coro' will be a coroutine object, and **kwargs will be
+        arbitrary keyword arguments that should be passed on to Task.
+        The callable must return a Task.
         """
         if factory is not None and not callable(factory):
             raise TypeError('task factory must be a callable or None')
@@ -624,29 +639,52 @@ def _check_running(self):
             raise RuntimeError(
                 'Cannot run the event loop while another loop is running')
 
-    def run_forever(self):
-        """Run until stop() is called."""
+    def _run_forever_setup(self):
+        """Prepare the run loop to process events.
+
+        This method exists so that custom event loop subclasses (e.g., event loops
+        that integrate a GUI event loop with Python's event loop) have access to all the
+        loop setup logic.
+        """
         self._check_closed()
         self._check_running()
         self._set_coroutine_origin_tracking(self._debug)
 
-        old_agen_hooks = sys.get_asyncgen_hooks()
-        try:
-            self._thread_id = threading.get_ident()
-            sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
-                                   finalizer=self._asyncgen_finalizer_hook)
+        self._old_agen_hooks = sys.get_asyncgen_hooks()
+        self._thread_id = threading.get_ident()
+        sys.set_asyncgen_hooks(
+            firstiter=self._asyncgen_firstiter_hook,
+            finalizer=self._asyncgen_finalizer_hook
+        )
+
+        events._set_running_loop(self)
+
+    def _run_forever_cleanup(self):
+        """Clean up after an event loop finishes the looping over events.
+
+        This method exists so that custom event loop subclasses (e.g., event loops
+        that integrate a GUI event loop with Python's event loop) have access to all the
+        loop cleanup logic.
+        """
+        self._stopping = False
+        self._thread_id = None
+        events._set_running_loop(None)
+        self._set_coroutine_origin_tracking(False)
+        # Restore any pre-existing async generator hooks.
+        if self._old_agen_hooks is not None:
+            sys.set_asyncgen_hooks(*self._old_agen_hooks)
+            self._old_agen_hooks = None
 
-            events._set_running_loop(self)
+    def run_forever(self):
+        """Run until stop() is called."""
+        self._run_forever_setup()
+        try:
             while True:
                 self._run_once()
                 if self._stopping:
                     break
         finally:
-            self._stopping = False
-            self._thread_id = None
-            events._set_running_loop(None)
-            self._set_coroutine_origin_tracking(False)
-            sys.set_asyncgen_hooks(*old_agen_hooks)
+            self._run_forever_cleanup()
 
     def run_until_complete(self, future):
         """Run until the Future is done.
@@ -981,39 +1019,43 @@ async def _connect_sock(self, exceptions, addr_info, local_addr_infos=None):
         family, type_, proto, _, address = addr_info
         sock = None
         try:
-            sock = socket.socket(family=family, type=type_, proto=proto)
-            sock.setblocking(False)
-            if local_addr_infos is not None:
-                for lfamily, _, _, _, laddr in local_addr_infos:
-                    # skip local addresses of different family
-                    if lfamily != family:
-                        continue
-                    try:
-                        sock.bind(laddr)
-                        break
-                    except OSError as exc:
-                        msg = (
-                            f'error while attempting to bind on '
-                            f'address {laddr!r}: '
-                            f'{exc.strerror.lower()}'
-                        )
-                        exc = OSError(exc.errno, msg)
-                        my_exceptions.append(exc)
-                else:  # all bind attempts failed
-                    if my_exceptions:
-                        raise my_exceptions.pop()
-                    else:
-                        raise OSError(f"no matching local address with {family=} found")
-            await self.sock_connect(sock, address)
-            return sock
-        except OSError as exc:
-            my_exceptions.append(exc)
-            if sock is not None:
-                sock.close()
-            raise
+            try:
+                sock = socket.socket(family=family, type=type_, proto=proto)
+                sock.setblocking(False)
+                if local_addr_infos is not None:
+                    for lfamily, _, _, _, laddr in local_addr_infos:
+                        # skip local addresses of different family
+                        if lfamily != family:
+                            continue
+                        try:
+                            sock.bind(laddr)
+                            break
+                        except OSError as exc:
+                            msg = (
+                                f'error while attempting to bind on '
+                                f'address {laddr!r}: {str(exc).lower()}'
+                            )
+                            exc = OSError(exc.errno, msg)
+                            my_exceptions.append(exc)
+                    else:  # all bind attempts failed
+                        if my_exceptions:
+                            raise my_exceptions.pop()
+                        else:
+                            raise OSError(f"no matching local address with {family=} found")
+                await self.sock_connect(sock, address)
+                return sock
+            except OSError as exc:
+                my_exceptions.append(exc)
+                raise
         except:
             if sock is not None:
-                sock.close()
+                try:
+                    sock.close()
+                except OSError:
+                    # An error when closing a newly created socket is
+                    # not important, but it can overwrite more important
+                    # non-OSError error. So ignore it.
+                    pass
             raise
         finally:
             exceptions = my_exceptions = None
@@ -1107,11 +1149,18 @@ async def create_connection(
                     except OSError:
                         continue
             else:  # using happy eyeballs
-                sock, _, _ = await staggered.staggered_race(
-                    (functools.partial(self._connect_sock,
-                                       exceptions, addrinfo, laddr_infos)
-                     for addrinfo in infos),
-                    happy_eyeballs_delay, loop=self)
+                sock = (await staggered.staggered_race(
+                    (
+                        # can't use functools.partial as it keeps a reference
+                        # to exceptions
+                        lambda addrinfo=addrinfo: self._connect_sock(
+                            exceptions, addrinfo, laddr_infos
+                        )
+                        for addrinfo in infos
+                    ),
+                    happy_eyeballs_delay,
+                    loop=self,
+                ))[0]  # can't use sock, _, _ as it keeks a reference to exceptions
 
             if sock is None:
                 exceptions = [exc for sub in exceptions for exc in sub]
@@ -1120,7 +1169,7 @@ async def create_connection(
                         raise ExceptionGroup("create_connection failed", exceptions)
                     if len(exceptions) == 1:
                         raise exceptions[0]
-                    else:
+                    elif exceptions:
                         # If they all have the same str(), raise one.
                         model = str(exceptions[0])
                         if all(str(exc) == model for exc in exceptions):
@@ -1129,6 +1178,9 @@ async def create_connection(
                         # the various error messages.
                         raise OSError('Multiple exceptions: {}'.format(
                             ', '.join(str(exc) for exc in exceptions)))
+                    else:
+                        # No exceptions were collected, raise a timeout error
+                        raise TimeoutError('create_connection failed')
                 finally:
                     exceptions = None
 
@@ -1254,8 +1306,8 @@ async def _sendfile_fallback(self, transp, file, offset, count):
                 read = await self.run_in_executor(None, file.readinto, view)
                 if not read:
                     return total_sent  # EOF
-                await proto.drain()
                 transp.write(view[:read])
+                await proto.drain()
                 total_sent += read
         finally:
             if total_sent > 0 and hasattr(file, 'seek'):
@@ -1474,6 +1526,7 @@ async def create_server(
             ssl=None,
             reuse_address=None,
             reuse_port=None,
+            keep_alive=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
             start_serving=True):
@@ -1545,8 +1598,13 @@ async def create_server(
                     if reuse_address:
                         sock.setsockopt(
                             socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
-                    if reuse_port:
+                    # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+                    # on other address families than AF_INET/AF_INET6.
+                    if reuse_port and af in (socket.AF_INET, socket.AF_INET6):
                         _set_reuseport(sock)
+                    if keep_alive:
+                        sock.setsockopt(
+                            socket.SOL_SOCKET, socket.SO_KEEPALIVE, True)
                     # Disable IPv4/IPv6 dual stack support (enabled by
                     # default on Linux) which makes a single socket
                     # listen on both address families.
@@ -1561,7 +1619,7 @@ async def create_server(
                     except OSError as err:
                         msg = ('error while attempting '
                                'to bind on address %r: %s'
-                               % (sa, err.strerror.lower()))
+                               % (sa, str(err).lower()))
                         if err.errno == errno.EADDRNOTAVAIL:
                             # Assume the family is not enabled (bpo-30945)
                             sockets.pop()
@@ -1833,6 +1891,8 @@ def call_exception_handler(self, context):
         - 'protocol' (optional): Protocol instance;
         - 'transport' (optional): Transport instance;
         - 'socket' (optional): Socket instance;
+        - 'source_traceback' (optional): Traceback of the source;
+        - 'handle_traceback' (optional): Traceback of the handle;
         - 'asyncgen' (optional): Asynchronous generator that caused
                                  the exception.
 
@@ -1943,8 +2003,11 @@ def _run_once(self):
             timeout = 0
         elif self._scheduled:
             # Compute the desired timeout.
-            when = self._scheduled[0]._when
-            timeout = min(max(0, when - self.time()), MAXIMUM_SELECT_TIMEOUT)
+            timeout = self._scheduled[0]._when - self.time()
+            if timeout > MAXIMUM_SELECT_TIMEOUT:
+                timeout = MAXIMUM_SELECT_TIMEOUT
+            elif timeout < 0:
+                timeout = 0
 
         event_list = self._selector.select(timeout)
         self._process_events(event_list)
diff --git a/Lib/asyncio/base_subprocess.py b/Lib/asyncio/base_subprocess.py
index 4c9b0dd5653..321a4e5d5d1 100644
--- a/Lib/asyncio/base_subprocess.py
+++ b/Lib/asyncio/base_subprocess.py
@@ -1,6 +1,9 @@
 import collections
 import subprocess
 import warnings
+import os
+import signal
+import sys
 
 from . import protocols
 from . import transports
@@ -23,6 +26,7 @@ def __init__(self, loop, protocol, args, shell,
         self._pending_calls = collections.deque()
         self._pipes = {}
         self._finished = False
+        self._pipes_connected = False
 
         if stdin == subprocess.PIPE:
             self._pipes[0] = None
@@ -101,7 +105,12 @@ def close(self):
         for proto in self._pipes.values():
             if proto is None:
                 continue
-            proto.pipe.close()
+            # See gh-114177
+            # skip closing the pipe if loop is already closed
+            # this can happen e.g. when loop is closed immediately after
+            # process is killed
+            if self._loop and not self._loop.is_closed():
+                proto.pipe.close()
 
         if (self._proc is not None and
                 # has the child process finished?
@@ -115,7 +124,8 @@ def close(self):
 
             try:
                 self._proc.kill()
-            except ProcessLookupError:
+            except (ProcessLookupError, PermissionError):
+                # the process may have already exited or may be running setuid
                 pass
 
             # Don't clear the _proc reference yet: _post_init() may still run
@@ -141,17 +151,31 @@ def _check_proc(self):
         if self._proc is None:
             raise ProcessLookupError()
 
-    def send_signal(self, signal):
-        self._check_proc()
-        self._proc.send_signal(signal)
+    if sys.platform == 'win32':
+        def send_signal(self, signal):
+            self._check_proc()
+            self._proc.send_signal(signal)
+
+        def terminate(self):
+            self._check_proc()
+            self._proc.terminate()
+
+        def kill(self):
+            self._check_proc()
+            self._proc.kill()
+    else:
+        def send_signal(self, signal):
+            self._check_proc()
+            try:
+                os.kill(self._proc.pid, signal)
+            except ProcessLookupError:
+                pass
 
-    def terminate(self):
-        self._check_proc()
-        self._proc.terminate()
+        def terminate(self):
+            self.send_signal(signal.SIGTERM)
 
-    def kill(self):
-        self._check_proc()
-        self._proc.kill()
+        def kill(self):
+            self.send_signal(signal.SIGKILL)
 
     async def _connect_pipes(self, waiter):
         try:
@@ -190,6 +214,7 @@ async def _connect_pipes(self, waiter):
         else:
             if waiter is not None and not waiter.cancelled():
                 waiter.set_result(None)
+            self._pipes_connected = True
 
     def _call(self, cb, *data):
         if self._pending_calls is not None:
@@ -233,6 +258,15 @@ def _try_finish(self):
         assert not self._finished
         if self._returncode is None:
             return
+        if not self._pipes_connected:
+            # self._pipes_connected can be False if not all pipes were connected
+            # because either the process failed to start or the self._connect_pipes task
+            # got cancelled. In this broken state we consider all pipes disconnected and
+            # to avoid hanging forever in self._wait as otherwise _exit_waiters
+            # would never be woken up, we wake them up here.
+            for waiter in self._exit_waiters:
+                if not waiter.cancelled():
+                    waiter.set_result(self._returncode)
         if all(p is not None and p.disconnected
                for p in self._pipes.values()):
             self._finished = True
diff --git a/Lib/asyncio/events.py b/Lib/asyncio/events.py
index 016852880ca..3b740b9b905 100644
--- a/Lib/asyncio/events.py
+++ b/Lib/asyncio/events.py
@@ -54,7 +54,8 @@ def _repr_info(self):
             info.append('cancelled')
         if self._callback is not None:
             info.append(format_helpers._format_callback_source(
-                self._callback, self._args))
+                self._callback, self._args,
+                debug=self._loop.get_debug()))
         if self._source_traceback:
             frame = self._source_traceback[-1]
             info.append(f'created at {frame[0]}:{frame[1]}')
@@ -90,7 +91,8 @@ def _run(self):
             raise
         except BaseException as exc:
             cb = format_helpers._format_callback_source(
-                self._callback, self._args)
+                self._callback, self._args,
+                debug=self._loop.get_debug())
             msg = f'Exception in callback {cb}'
             context = {
                 'message': msg,
@@ -173,6 +175,14 @@ def close(self):
         """Stop serving.  This leaves existing connections open."""
         raise NotImplementedError
 
+    def close_clients(self):
+        """Close all active connections."""
+        raise NotImplementedError
+
+    def abort_clients(self):
+        """Close all active connections immediately."""
+        raise NotImplementedError
+
     def get_loop(self):
         """Get the event loop the Server object is attached to."""
         raise NotImplementedError
@@ -282,7 +292,7 @@ def create_future(self):
 
     # Method scheduling a coroutine object: create a task.
 
-    def create_task(self, coro, *, name=None, context=None):
+    def create_task(self, coro, **kwargs):
         raise NotImplementedError
 
     # Methods for interacting with threads.
@@ -320,6 +330,7 @@ async def create_server(
             *, family=socket.AF_UNSPEC,
             flags=socket.AI_PASSIVE, sock=None, backlog=100,
             ssl=None, reuse_address=None, reuse_port=None,
+            keep_alive=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
             start_serving=True):
@@ -358,6 +369,9 @@ async def create_server(
         they all set this flag when being created. This option is not
         supported on Windows.
 
+        keep_alive set to True keeps connections active by enabling the
+        periodic transmission of messages.
+
         ssl_handshake_timeout is the time in seconds that an SSL server
         will wait for completion of the SSL handshake before aborting the
         connection. Default is 60s.
diff --git a/Lib/asyncio/format_helpers.py b/Lib/asyncio/format_helpers.py
index 27d11fd4fa9..93737b7708a 100644
--- a/Lib/asyncio/format_helpers.py
+++ b/Lib/asyncio/format_helpers.py
@@ -19,19 +19,26 @@ def _get_function_source(func):
     return None
 
 
-def _format_callback_source(func, args):
-    func_repr = _format_callback(func, args, None)
+def _format_callback_source(func, args, *, debug=False):
+    func_repr = _format_callback(func, args, None, debug=debug)
     source = _get_function_source(func)
     if source:
         func_repr += f' at {source[0]}:{source[1]}'
     return func_repr
 
 
-def _format_args_and_kwargs(args, kwargs):
+def _format_args_and_kwargs(args, kwargs, *, debug=False):
     """Format function arguments and keyword arguments.
 
     Special case for a single parameter: ('hello',) is formatted as ('hello').
+
+    Note that this function only returns argument details when
+    debug=True is specified, as arguments may contain sensitive
+    information.
     """
+    if not debug:
+        return '()'
+
     # use reprlib to limit the length of the output
     items = []
     if args:
@@ -41,10 +48,11 @@ def _format_args_and_kwargs(args, kwargs):
     return '({})'.format(', '.join(items))
 
 
-def _format_callback(func, args, kwargs, suffix=''):
+def _format_callback(func, args, kwargs, *, debug=False, suffix=''):
     if isinstance(func, functools.partial):
-        suffix = _format_args_and_kwargs(args, kwargs) + suffix
-        return _format_callback(func.func, func.args, func.keywords, suffix)
+        suffix = _format_args_and_kwargs(args, kwargs, debug=debug) + suffix
+        return _format_callback(func.func, func.args, func.keywords,
+                                debug=debug, suffix=suffix)
 
     if hasattr(func, '__qualname__') and func.__qualname__:
         func_repr = func.__qualname__
@@ -53,7 +61,7 @@ def _format_callback(func, args, kwargs, suffix=''):
     else:
         func_repr = repr(func)
 
-    func_repr += _format_args_and_kwargs(args, kwargs)
+    func_repr += _format_args_and_kwargs(args, kwargs, debug=debug)
     if suffix:
         func_repr += suffix
     return func_repr
diff --git a/Lib/asyncio/futures.py b/Lib/asyncio/futures.py
index 97fc4e3fcb6..51932639097 100644
--- a/Lib/asyncio/futures.py
+++ b/Lib/asyncio/futures.py
@@ -138,9 +138,6 @@ def _make_cancelled_error(self):
             exc = exceptions.CancelledError()
         else:
             exc = exceptions.CancelledError(self._cancel_message)
-        exc.__context__ = self._cancelled_exc
-        # Remove the reference since we don't need this anymore.
-        self._cancelled_exc = None
         return exc
 
     def cancel(self, msg=None):
@@ -194,8 +191,7 @@ def result(self):
         the future is done and has an exception set, this exception is raised.
         """
         if self._state == _CANCELLED:
-            exc = self._make_cancelled_error()
-            raise exc
+            raise self._make_cancelled_error()
         if self._state != _FINISHED:
             raise exceptions.InvalidStateError('Result is not ready.')
         self.__log_traceback = False
@@ -212,8 +208,7 @@ def exception(self):
         InvalidStateError.
         """
         if self._state == _CANCELLED:
-            exc = self._make_cancelled_error()
-            raise exc
+            raise self._make_cancelled_error()
         if self._state != _FINISHED:
             raise exceptions.InvalidStateError('Exception is not set.')
         self.__log_traceback = False
@@ -272,9 +267,13 @@ def set_exception(self, exception):
             raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
         if isinstance(exception, type):
             exception = exception()
-        if type(exception) is StopIteration:
-            raise TypeError("StopIteration interacts badly with generators "
-                            "and cannot be raised into a Future")
+        if isinstance(exception, StopIteration):
+            new_exc = RuntimeError("StopIteration interacts badly with "
+                                   "generators and cannot be raised into a "
+                                   "Future")
+            new_exc.__cause__ = exception
+            new_exc.__context__ = exception
+            exception = new_exc
         self._exception = exception
         self._exception_tb = exception.__traceback__
         self._state = _FINISHED
@@ -318,11 +317,9 @@ def _set_result_unless_cancelled(fut, result):
 def _convert_future_exc(exc):
     exc_class = type(exc)
     if exc_class is concurrent.futures.CancelledError:
-        return exceptions.CancelledError(*exc.args)
-    elif exc_class is concurrent.futures.TimeoutError:
-        return exceptions.TimeoutError(*exc.args)
+        return exceptions.CancelledError(*exc.args).with_traceback(exc.__traceback__)
     elif exc_class is concurrent.futures.InvalidStateError:
-        return exceptions.InvalidStateError(*exc.args)
+        return exceptions.InvalidStateError(*exc.args).with_traceback(exc.__traceback__)
     else:
         return exc
 
diff --git a/Lib/asyncio/locks.py b/Lib/asyncio/locks.py
index ce5d8d5bfb2..3df4c693a91 100644
--- a/Lib/asyncio/locks.py
+++ b/Lib/asyncio/locks.py
@@ -24,25 +24,23 @@ class Lock(_ContextManagerMixin, mixins._LoopBoundMixin):
     """Primitive lock objects.
 
     A primitive lock is a synchronization primitive that is not owned
-    by a particular coroutine when locked.  A primitive lock is in one
+    by a particular task when locked.  A primitive lock is in one
     of two states, 'locked' or 'unlocked'.
 
     It is created in the unlocked state.  It has two basic methods,
     acquire() and release().  When the state is unlocked, acquire()
     changes the state to locked and returns immediately.  When the
     state is locked, acquire() blocks until a call to release() in
-    another coroutine changes it to unlocked, then the acquire() call
+    another task changes it to unlocked, then the acquire() call
     resets it to locked and returns.  The release() method should only
     be called in the locked state; it changes the state to unlocked
     and returns immediately.  If an attempt is made to release an
     unlocked lock, a RuntimeError will be raised.
 
-    When more than one coroutine is blocked in acquire() waiting for
-    the state to turn to unlocked, only one coroutine proceeds when a
-    release() call resets the state to unlocked; first coroutine which
-    is blocked in acquire() is being processed.
-
-    acquire() is a coroutine and should be called with 'await'.
+    When more than one task is blocked in acquire() waiting for
+    the state to turn to unlocked, only one task proceeds when a
+    release() call resets the state to unlocked; successive release()
+    calls will unblock tasks in FIFO order.
 
     Locks also support the asynchronous context management protocol.
     'async with lock' statement should be used.
@@ -95,6 +93,8 @@ async def acquire(self):
         This method blocks until the lock is unlocked, then sets it to
         locked and returns True.
         """
+        # Implement fair scheduling, where thread always waits
+        # its turn. Jumping the queue if all are cancelled is an optimization.
         if (not self._locked and (self._waiters is None or
                 all(w.cancelled() for w in self._waiters))):
             self._locked = True
@@ -105,19 +105,22 @@ async def acquire(self):
         fut = self._get_loop().create_future()
         self._waiters.append(fut)
 
-        # Finally block should be called before the CancelledError
-        # handling as we don't want CancelledError to call
-        # _wake_up_first() and attempt to wake up itself.
         try:
             try:
                 await fut
             finally:
                 self._waiters.remove(fut)
         except exceptions.CancelledError:
+            # Currently the only exception designed be able to occur here.
+
+            # Ensure the lock invariant: If lock is not claimed (or about
+            # to be claimed by us) and there is a Task in waiters,
+            # ensure that the Task at the head will run.
             if not self._locked:
                 self._wake_up_first()
             raise
 
+        # assert self._locked is False
         self._locked = True
         return True
 
@@ -125,7 +128,7 @@ def release(self):
         """Release a lock.
 
         When the lock is locked, reset it to unlocked, and return.
-        If any other coroutines are blocked waiting for the lock to become
+        If any other tasks are blocked waiting for the lock to become
         unlocked, allow exactly one of them to proceed.
 
         When invoked on an unlocked lock, a RuntimeError is raised.
@@ -139,7 +142,7 @@ def release(self):
             raise RuntimeError('Lock is not acquired.')
 
     def _wake_up_first(self):
-        """Wake up the first waiter if it isn't done."""
+        """Ensure that the first waiter will wake up."""
         if not self._waiters:
             return
         try:
@@ -147,9 +150,7 @@ def _wake_up_first(self):
         except StopIteration:
             return
 
-        # .done() necessarily means that a waiter will wake up later on and
-        # either take the lock, or, if it was cancelled and lock wasn't
-        # taken already, will hit this again and wake up a new waiter.
+        # .done() means that the waiter is already set to wake up.
         if not fut.done():
             fut.set_result(True)
 
@@ -179,8 +180,8 @@ def is_set(self):
         return self._value
 
     def set(self):
-        """Set the internal flag to true. All coroutines waiting for it to
-        become true are awakened. Coroutine that call wait() once the flag is
+        """Set the internal flag to true. All tasks waiting for it to
+        become true are awakened. Tasks that call wait() once the flag is
         true will not block at all.
         """
         if not self._value:
@@ -191,7 +192,7 @@ def set(self):
                     fut.set_result(True)
 
     def clear(self):
-        """Reset the internal flag to false. Subsequently, coroutines calling
+        """Reset the internal flag to false. Subsequently, tasks calling
         wait() will block until set() is called to set the internal flag
         to true again."""
         self._value = False
@@ -200,7 +201,7 @@ async def wait(self):
         """Block until the internal flag is true.
 
         If the internal flag is true on entry, return True
-        immediately.  Otherwise, block until another coroutine calls
+        immediately.  Otherwise, block until another task calls
         set() to set the flag to true, then return True.
         """
         if self._value:
@@ -219,8 +220,8 @@ class Condition(_ContextManagerMixin, mixins._LoopBoundMixin):
     """Asynchronous equivalent to threading.Condition.
 
     This class implements condition variable objects. A condition variable
-    allows one or more coroutines to wait until they are notified by another
-    coroutine.
+    allows one or more tasks to wait until they are notified by another
+    task.
 
     A new Lock object is created and used as the underlying lock.
     """
@@ -247,45 +248,64 @@ def __repr__(self):
     async def wait(self):
         """Wait until notified.
 
-        If the calling coroutine has not acquired the lock when this
+        If the calling task has not acquired the lock when this
         method is called, a RuntimeError is raised.
 
         This method releases the underlying lock, and then blocks
         until it is awakened by a notify() or notify_all() call for
-        the same condition variable in another coroutine.  Once
+        the same condition variable in another task.  Once
         awakened, it re-acquires the lock and returns True.
+
+        This method may return spuriously,
+        which is why the caller should always
+        re-check the state and be prepared to wait() again.
         """
         if not self.locked():
             raise RuntimeError('cannot wait on un-acquired lock')
 
+        fut = self._get_loop().create_future()
         self.release()
         try:
-            fut = self._get_loop().create_future()
-            self._waiters.append(fut)
             try:
-                await fut
-                return True
-            finally:
-                self._waiters.remove(fut)
-
-        finally:
-            # Must reacquire lock even if wait is cancelled
-            cancelled = False
-            while True:
+                self._waiters.append(fut)
                 try:
-                    await self.acquire()
-                    break
-                except exceptions.CancelledError:
-                    cancelled = True
+                    await fut
+                    return True
+                finally:
+                    self._waiters.remove(fut)
 
-            if cancelled:
-                raise exceptions.CancelledError
+            finally:
+                # Must re-acquire lock even if wait is cancelled.
+                # We only catch CancelledError here, since we don't want any
+                # other (fatal) errors with the future to cause us to spin.
+                err = None
+                while True:
+                    try:
+                        await self.acquire()
+                        break
+                    except exceptions.CancelledError as e:
+                        err = e
+
+                if err is not None:
+                    try:
+                        raise err  # Re-raise most recent exception instance.
+                    finally:
+                        err = None  # Break reference cycles.
+        except BaseException:
+            # Any error raised out of here _may_ have occurred after this Task
+            # believed to have been successfully notified.
+            # Make sure to notify another Task instead.  This may result
+            # in a "spurious wakeup", which is allowed as part of the
+            # Condition Variable protocol.
+            self._notify(1)
+            raise
 
     async def wait_for(self, predicate):
         """Wait until a predicate becomes true.
 
-        The predicate should be a callable which result will be
-        interpreted as a boolean value.  The final predicate value is
+        The predicate should be a callable whose result will be
+        interpreted as a boolean value.  The method will repeatedly
+        wait() until it evaluates to true.  The final predicate value is
         the return value.
         """
         result = predicate()
@@ -295,20 +315,22 @@ async def wait_for(self, predicate):
         return result
 
     def notify(self, n=1):
-        """By default, wake up one coroutine waiting on this condition, if any.
-        If the calling coroutine has not acquired the lock when this method
+        """By default, wake up one task waiting on this condition, if any.
+        If the calling task has not acquired the lock when this method
         is called, a RuntimeError is raised.
 
-        This method wakes up at most n of the coroutines waiting for the
-        condition variable; it is a no-op if no coroutines are waiting.
+        This method wakes up n of the tasks waiting for the condition
+         variable; if fewer than n are waiting, they are all awoken.
 
-        Note: an awakened coroutine does not actually return from its
+        Note: an awakened task does not actually return from its
         wait() call until it can reacquire the lock. Since notify() does
         not release the lock, its caller should.
         """
         if not self.locked():
             raise RuntimeError('cannot notify on un-acquired lock')
+        self._notify(n)
 
+    def _notify(self, n):
         idx = 0
         for fut in self._waiters:
             if idx >= n:
@@ -357,6 +379,7 @@ def __repr__(self):
 
     def locked(self):
         """Returns True if semaphore cannot be acquired immediately."""
+        # Due to state, or FIFO rules (must allow others to run first).
         return self._value == 0 or (
             any(not w.cancelled() for w in (self._waiters or ())))
 
@@ -365,11 +388,12 @@ async def acquire(self):
 
         If the internal counter is larger than zero on entry,
         decrement it by one and return True immediately.  If it is
-        zero on entry, block, waiting until some other coroutine has
+        zero on entry, block, waiting until some other task has
         called release() to make it larger than 0, and then return
         True.
         """
         if not self.locked():
+            # Maintain FIFO, wait for others to start even if _value > 0.
             self._value -= 1
             return True
 
@@ -378,29 +402,34 @@ async def acquire(self):
         fut = self._get_loop().create_future()
         self._waiters.append(fut)
 
-        # Finally block should be called before the CancelledError
-        # handling as we don't want CancelledError to call
-        # _wake_up_first() and attempt to wake up itself.
         try:
             try:
                 await fut
             finally:
                 self._waiters.remove(fut)
         except exceptions.CancelledError:
-            if not fut.cancelled():
+            # Currently the only exception designed be able to occur here.
+            if fut.done() and not fut.cancelled():
+                # Our Future was successfully set to True via _wake_up_next(),
+                # but we are not about to successfully acquire(). Therefore we
+                # must undo the bookkeeping already done and attempt to wake
+                # up someone else.
                 self._value += 1
-                self._wake_up_next()
             raise
 
-        if self._value > 0:
-            self._wake_up_next()
+        finally:
+            # New waiters may have arrived but had to wait due to FIFO.
+            # Wake up as many as are allowed.
+            while self._value > 0:
+                if not self._wake_up_next():
+                    break  # There was no-one to wake up.
         return True
 
     def release(self):
         """Release a semaphore, incrementing the internal counter by one.
 
-        When it was zero on entry and another coroutine is waiting for it to
-        become larger than zero again, wake up that coroutine.
+        When it was zero on entry and another task is waiting for it to
+        become larger than zero again, wake up that task.
         """
         self._value += 1
         self._wake_up_next()
@@ -408,13 +437,15 @@ def release(self):
     def _wake_up_next(self):
         """Wake up the first waiter that isn't done."""
         if not self._waiters:
-            return
+            return False
 
         for fut in self._waiters:
             if not fut.done():
                 self._value -= 1
                 fut.set_result(True)
-                return
+                # `fut` is now `done()` and not `cancelled()`.
+                return True
+        return False
 
 
 class BoundedSemaphore(Semaphore):
@@ -454,7 +485,7 @@ class Barrier(mixins._LoopBoundMixin):
     def __init__(self, parties):
         """Create a barrier, initialised to 'parties' tasks."""
         if parties < 1:
-            raise ValueError('parties must be > 0')
+            raise ValueError('parties must be >= 1')
 
         self._cond = Condition() # notify all tasks when state changes
 
diff --git a/Lib/asyncio/proactor_events.py b/Lib/asyncio/proactor_events.py
index 1e2a730cf36..f404273c3ae 100644
--- a/Lib/asyncio/proactor_events.py
+++ b/Lib/asyncio/proactor_events.py
@@ -63,7 +63,7 @@ def __init__(self, loop, sock, protocol, waiter=None,
         self._called_connection_lost = False
         self._eof_written = False
         if self._server is not None:
-            self._server._attach()
+            self._server._attach(self)
         self._loop.call_soon(self._protocol.connection_made, self)
         if waiter is not None:
             # only wake up the waiter when connection_made() has been called
@@ -167,7 +167,7 @@ def _call_connection_lost(self, exc):
             self._sock = None
             server = self._server
             if server is not None:
-                server._detach()
+                server._detach(self)
                 self._server = None
             self._called_connection_lost = True
 
@@ -460,6 +460,8 @@ def _pipe_closed(self, fut):
 class _ProactorDatagramTransport(_ProactorBasePipeTransport,
                                  transports.DatagramTransport):
     max_size = 256 * 1024
+    _header_size = 8
+
     def __init__(self, loop, sock, protocol, address=None,
                  waiter=None, extra=None):
         self._address = address
@@ -487,9 +489,6 @@ def sendto(self, data, addr=None):
             raise TypeError('data argument must be bytes-like object (%r)',
                             type(data))
 
-        if not data:
-            return
-
         if self._address is not None and addr not in (None, self._address):
             raise ValueError(
                 f'Invalid address: must be None or {self._address}')
@@ -502,7 +501,7 @@ def sendto(self, data, addr=None):
 
         # Ensure that what we buffer is immutable.
         self._buffer.append((bytes(data), addr))
-        self._buffer_size += len(data)
+        self._buffer_size += len(data) + self._header_size
 
         if self._write_fut is None:
             # No current write operations are active, kick one off
@@ -529,7 +528,7 @@ def _loop_writing(self, fut=None):
                 return
 
             data, addr = self._buffer.popleft()
-            self._buffer_size -= len(data)
+            self._buffer_size -= len(data) + self._header_size
             if self._address is not None:
                 self._write_fut = self._loop._proactor.send(self._sock,
                                                             data)
@@ -724,6 +723,8 @@ async def sock_sendto(self, sock, data, address):
         return await self._proactor.sendto(sock, data, 0, address)
 
     async def sock_connect(self, sock, address):
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
         return await self._proactor.connect(sock, address)
 
     async def sock_accept(self, sock):
diff --git a/Lib/asyncio/queues.py b/Lib/asyncio/queues.py
index a9656a6df56..084fccaaff2 100644
--- a/Lib/asyncio/queues.py
+++ b/Lib/asyncio/queues.py
@@ -1,4 +1,11 @@
-__all__ = ('Queue', 'PriorityQueue', 'LifoQueue', 'QueueFull', 'QueueEmpty')
+__all__ = (
+    'Queue',
+    'PriorityQueue',
+    'LifoQueue',
+    'QueueFull',
+    'QueueEmpty',
+    'QueueShutDown',
+)
 
 import collections
 import heapq
@@ -18,6 +25,11 @@ class QueueFull(Exception):
     pass
 
 
+class QueueShutDown(Exception):
+    """Raised when putting on to or getting from a shut-down Queue."""
+    pass
+
+
 class Queue(mixins._LoopBoundMixin):
     """A queue, useful for coordinating producer and consumer coroutines.
 
@@ -41,6 +53,7 @@ def __init__(self, maxsize=0):
         self._finished = locks.Event()
         self._finished.set()
         self._init(maxsize)
+        self._is_shutdown = False
 
     # These three are overridable in subclasses.
 
@@ -81,6 +94,8 @@ def _format(self):
             result += f' _putters[{len(self._putters)}]'
         if self._unfinished_tasks:
             result += f' tasks={self._unfinished_tasks}'
+        if self._is_shutdown:
+            result += ' shutdown'
         return result
 
     def qsize(self):
@@ -112,8 +127,12 @@ async def put(self, item):
 
         Put an item into the queue. If the queue is full, wait until a free
         slot is available before adding item.
+
+        Raises QueueShutDown if the queue has been shut down.
         """
         while self.full():
+            if self._is_shutdown:
+                raise QueueShutDown
             putter = self._get_loop().create_future()
             self._putters.append(putter)
             try:
@@ -125,7 +144,7 @@ async def put(self, item):
                     self._putters.remove(putter)
                 except ValueError:
                     # The putter could be removed from self._putters by a
-                    # previous get_nowait call.
+                    # previous get_nowait call or a shutdown call.
                     pass
                 if not self.full() and not putter.cancelled():
                     # We were woken up by get_nowait(), but can't take
@@ -138,7 +157,11 @@ def put_nowait(self, item):
         """Put an item into the queue without blocking.
 
         If no free slot is immediately available, raise QueueFull.
+
+        Raises QueueShutDown if the queue has been shut down.
         """
+        if self._is_shutdown:
+            raise QueueShutDown
         if self.full():
             raise QueueFull
         self._put(item)
@@ -150,8 +173,13 @@ async def get(self):
         """Remove and return an item from the queue.
 
         If queue is empty, wait until an item is available.
+
+        Raises QueueShutDown if the queue has been shut down and is empty, or
+        if the queue has been shut down immediately.
         """
         while self.empty():
+            if self._is_shutdown and self.empty():
+                raise QueueShutDown
             getter = self._get_loop().create_future()
             self._getters.append(getter)
             try:
@@ -163,7 +191,7 @@ async def get(self):
                     self._getters.remove(getter)
                 except ValueError:
                     # The getter could be removed from self._getters by a
-                    # previous put_nowait call.
+                    # previous put_nowait call, or a shutdown call.
                     pass
                 if not self.empty() and not getter.cancelled():
                     # We were woken up by put_nowait(), but can't take
@@ -176,8 +204,13 @@ def get_nowait(self):
         """Remove and return an item from the queue.
 
         Return an item if one is immediately available, else raise QueueEmpty.
+
+        Raises QueueShutDown if the queue has been shut down and is empty, or
+        if the queue has been shut down immediately.
         """
         if self.empty():
+            if self._is_shutdown:
+                raise QueueShutDown
             raise QueueEmpty
         item = self._get()
         self._wakeup_next(self._putters)
@@ -214,6 +247,36 @@ async def join(self):
         if self._unfinished_tasks > 0:
             await self._finished.wait()
 
+    def shutdown(self, immediate=False):
+        """Shut-down the queue, making queue gets and puts raise QueueShutDown.
+
+        By default, gets will only raise once the queue is empty. Set
+        'immediate' to True to make gets raise immediately instead.
+
+        All blocked callers of put() and get() will be unblocked.
+
+        If 'immediate', the queue is drained and unfinished tasks
+        is reduced by the number of drained tasks.  If unfinished tasks
+        is reduced to zero, callers of Queue.join are unblocked.
+        """
+        self._is_shutdown = True
+        if immediate:
+            while not self.empty():
+                self._get()
+                if self._unfinished_tasks > 0:
+                    self._unfinished_tasks -= 1
+            if self._unfinished_tasks == 0:
+                self._finished.set()
+        # All getters need to re-check queue-empty to raise ShutDown
+        while self._getters:
+            getter = self._getters.popleft()
+            if not getter.done():
+                getter.set_result(None)
+        while self._putters:
+            putter = self._putters.popleft()
+            if not putter.done():
+                putter.set_result(None)
+
 
 class PriorityQueue(Queue):
     """A subclass of Queue; retrieves entries in priority order (lowest first).
diff --git a/Lib/asyncio/runners.py b/Lib/asyncio/runners.py
index 1b89236599a..102ae78021b 100644
--- a/Lib/asyncio/runners.py
+++ b/Lib/asyncio/runners.py
@@ -168,6 +168,7 @@ def run(main, *, debug=None, loop_factory=None):
     running in the same thread.
 
     If debug is True, the event loop will be run in debug mode.
+    If loop_factory is passed, it is used for new event loop creation.
 
     This function always creates a new event loop and closes it at the end.
     It should be used as a main entry point for asyncio programs, and should
diff --git a/Lib/asyncio/selector_events.py b/Lib/asyncio/selector_events.py
index 790711f8340..8701467d413 100644
--- a/Lib/asyncio/selector_events.py
+++ b/Lib/asyncio/selector_events.py
@@ -265,22 +265,17 @@ def _ensure_fd_no_transport(self, fd):
             except (AttributeError, TypeError, ValueError):
                 # This code matches selectors._fileobj_to_fd function.
                 raise ValueError(f"Invalid file object: {fd!r}") from None
-        try:
-            transport = self._transports[fileno]
-        except KeyError:
-            pass
-        else:
-            if not transport.is_closing():
-                raise RuntimeError(
-                    f'File descriptor {fd!r} is used by transport '
-                    f'{transport!r}')
+        transport = self._transports.get(fileno)
+        if transport and not transport.is_closing():
+            raise RuntimeError(
+                f'File descriptor {fd!r} is used by transport '
+                f'{transport!r}')
 
     def _add_reader(self, fd, callback, *args):
         self._check_closed()
         handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             self._selector.register(fd, selectors.EVENT_READ,
                                     (handle, None))
         else:
@@ -294,30 +289,27 @@ def _add_reader(self, fd, callback, *args):
     def _remove_reader(self, fd):
         if self.is_closed():
             return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             return False
+        mask, (reader, writer) = key.events, key.data
+        mask &= ~selectors.EVENT_READ
+        if not mask:
+            self._selector.unregister(fd)
         else:
-            mask, (reader, writer) = key.events, key.data
-            mask &= ~selectors.EVENT_READ
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (None, writer))
+            self._selector.modify(fd, mask, (None, writer))
 
-            if reader is not None:
-                reader.cancel()
-                return True
-            else:
-                return False
+        if reader is not None:
+            reader.cancel()
+            return True
+        else:
+            return False
 
     def _add_writer(self, fd, callback, *args):
         self._check_closed()
         handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             self._selector.register(fd, selectors.EVENT_WRITE,
                                     (None, handle))
         else:
@@ -332,24 +324,22 @@ def _remove_writer(self, fd):
         """Remove a writer callback."""
         if self.is_closed():
             return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             return False
+        mask, (reader, writer) = key.events, key.data
+        # Remove both writer and connector.
+        mask &= ~selectors.EVENT_WRITE
+        if not mask:
+            self._selector.unregister(fd)
         else:
-            mask, (reader, writer) = key.events, key.data
-            # Remove both writer and connector.
-            mask &= ~selectors.EVENT_WRITE
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (reader, None))
+            self._selector.modify(fd, mask, (reader, None))
 
-            if writer is not None:
-                writer.cancel()
-                return True
-            else:
-                return False
+        if writer is not None:
+            writer.cancel()
+            return True
+        else:
+            return False
 
     def add_reader(self, fd, callback, *args):
         """Add a reader callback."""
@@ -801,7 +791,7 @@ def __init__(self, loop, sock, protocol, extra=None, server=None):
         self._paused = False  # Set when pause_reading() called
 
         if self._server is not None:
-            self._server._attach()
+            self._server._attach(self)
         loop._transports[self._sock_fd] = self
 
     def __repr__(self):
@@ -878,6 +868,8 @@ def __del__(self, _warn=warnings.warn):
         if self._sock is not None:
             _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
             self._sock.close()
+            if self._server is not None:
+                self._server._detach(self)
 
     def _fatal_error(self, exc, message='Fatal error on transport'):
         # Should be called from exception handler only.
@@ -916,7 +908,7 @@ def _call_connection_lost(self, exc):
             self._loop = None
             server = self._server
             if server is not None:
-                server._detach()
+                server._detach(self)
                 self._server = None
 
     def get_write_buffer_size(self):
@@ -1054,8 +1046,8 @@ def _read_ready__on_eof(self):
 
     def write(self, data):
         if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(f'data argument must be a bytes-like object, '
-                            f'not {type(data).__name__!r}')
+            raise TypeError(f'data argument must be a bytes, bytearray, or memoryview '
+                            f'object, not {type(data).__name__!r}')
         if self._eof:
             raise RuntimeError('Cannot call write() after write_eof()')
         if self._empty_waiter is not None:
@@ -1178,20 +1170,31 @@ def writelines(self, list_of_data):
             raise RuntimeError('unable to writelines; sendfile is in progress')
         if not list_of_data:
             return
+
+        if self._conn_lost:
+            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                logger.warning('socket.send() raised exception.')
+            self._conn_lost += 1
+            return
+
         self._buffer.extend([memoryview(data) for data in list_of_data])
         self._write_ready()
         # If the entire buffer couldn't be written, register a write handler
         if self._buffer:
             self._loop._add_writer(self._sock_fd, self._write_ready)
+            self._maybe_pause_protocol()
 
     def can_write_eof(self):
         return True
 
     def _call_connection_lost(self, exc):
-        super()._call_connection_lost(exc)
-        if self._empty_waiter is not None:
-            self._empty_waiter.set_exception(
-                ConnectionError("Connection is closed by peer"))
+        try:
+            super()._call_connection_lost(exc)
+        finally:
+            self._write_ready = None
+            if self._empty_waiter is not None:
+                self._empty_waiter.set_exception(
+                    ConnectionError("Connection is closed by peer"))
 
     def _make_empty_waiter(self):
         if self._empty_waiter is not None:
@@ -1206,13 +1209,13 @@ def _reset_empty_waiter(self):
 
     def close(self):
         self._read_ready_cb = None
-        self._write_ready = None
         super().close()
 
 
 class _SelectorDatagramTransport(_SelectorTransport, transports.DatagramTransport):
 
     _buffer_factory = collections.deque
+    _header_size = 8
 
     def __init__(self, loop, sock, protocol, address=None,
                  waiter=None, extra=None):
@@ -1251,8 +1254,6 @@ def sendto(self, data, addr=None):
         if not isinstance(data, (bytes, bytearray, memoryview)):
             raise TypeError(f'data argument must be a bytes-like object, '
                             f'not {type(data).__name__!r}')
-        if not data:
-            return
 
         if self._address:
             if addr not in (None, self._address):
@@ -1288,13 +1289,13 @@ def sendto(self, data, addr=None):
 
         # Ensure that what we buffer is immutable.
         self._buffer.append((bytes(data), addr))
-        self._buffer_size += len(data)
+        self._buffer_size += len(data) + self._header_size
         self._maybe_pause_protocol()
 
     def _sendto_ready(self):
         while self._buffer:
             data, addr = self._buffer.popleft()
-            self._buffer_size -= len(data)
+            self._buffer_size -= len(data) + self._header_size
             try:
                 if self._extra['peername']:
                     self._sock.send(data)
@@ -1302,7 +1303,7 @@ def _sendto_ready(self):
                     self._sock.sendto(data, addr)
             except (BlockingIOError, InterruptedError):
                 self._buffer.appendleft((data, addr))  # Try again later.
-                self._buffer_size += len(data)
+                self._buffer_size += len(data) + self._header_size
                 break
             except OSError as exc:
                 self._protocol.error_received(exc)
diff --git a/Lib/asyncio/sslproto.py b/Lib/asyncio/sslproto.py
index e51669a2ab2..74c5f0d5ca0 100644
--- a/Lib/asyncio/sslproto.py
+++ b/Lib/asyncio/sslproto.py
@@ -101,7 +101,7 @@ def get_protocol(self):
         return self._ssl_protocol._app_protocol
 
     def is_closing(self):
-        return self._closed
+        return self._closed or self._ssl_protocol._is_transport_closing()
 
     def close(self):
         """Close the transport.
@@ -379,6 +379,9 @@ def _get_app_transport(self):
             self._app_transport_created = True
         return self._app_transport
 
+    def _is_transport_closing(self):
+        return self._transport is not None and self._transport.is_closing()
+
     def connection_made(self, transport):
         """Called when the low-level connection is made.
 
@@ -542,7 +545,7 @@ def _start_handshake(self):
         # start handshake timeout count down
         self._handshake_timeout_handle = \
             self._loop.call_later(self._ssl_handshake_timeout,
-                                  lambda: self._check_handshake_timeout())
+                                  self._check_handshake_timeout)
 
         self._do_handshake()
 
@@ -623,7 +626,7 @@ def _start_shutdown(self):
             self._set_state(SSLProtocolState.FLUSHING)
             self._shutdown_timeout_handle = self._loop.call_later(
                 self._ssl_shutdown_timeout,
-                lambda: self._check_shutdown_timeout()
+                self._check_shutdown_timeout
             )
             self._do_flush()
 
@@ -762,7 +765,7 @@ def _do_read__buffered(self):
                     else:
                         break
                 else:
-                    self._loop.call_soon(lambda: self._do_read())
+                    self._loop.call_soon(self._do_read)
         except SSLAgainErrors:
             pass
         if offset > 0:
diff --git a/Lib/asyncio/staggered.py b/Lib/asyncio/staggered.py
index 451a53a16f3..0afed64fdf9 100644
--- a/Lib/asyncio/staggered.py
+++ b/Lib/asyncio/staggered.py
@@ -3,7 +3,6 @@
 __all__ = 'staggered_race',
 
 import contextlib
-import typing
 
 from . import events
 from . import exceptions as exceptions_mod
@@ -11,16 +10,7 @@
 from . import tasks
 
 
-async def staggered_race(
-        coro_fns: typing.Iterable[typing.Callable[[], typing.Awaitable]],
-        delay: typing.Optional[float],
-        *,
-        loop: events.AbstractEventLoop = None,
-) -> typing.Tuple[
-    typing.Any,
-    typing.Optional[int],
-    typing.List[typing.Optional[Exception]]
-]:
+async def staggered_race(coro_fns, delay, *, loop=None):
     """Run coroutines with staggered start times and take the first to finish.
 
     This method takes an iterable of coroutine functions. The first one is
@@ -76,11 +66,33 @@ async def staggered_race(
     enum_coro_fns = enumerate(coro_fns)
     winner_result = None
     winner_index = None
+    unhandled_exceptions = []
     exceptions = []
-    running_tasks = []
+    running_tasks = set()
+    on_completed_fut = None
+
+    def task_done(task):
+        running_tasks.discard(task)
+        if (
+            on_completed_fut is not None
+            and not on_completed_fut.done()
+            and not running_tasks
+        ):
+            on_completed_fut.set_result(None)
+
+        if task.cancelled():
+            return
+
+        exc = task.exception()
+        if exc is None:
+            return
+        unhandled_exceptions.append(exc)
 
-    async def run_one_coro(
-            previous_failed: typing.Optional[locks.Event]) -> None:
+    async def run_one_coro(ok_to_start, previous_failed) -> None:
+        # in eager tasks this waits for the calling task to append this task
+        # to running_tasks, in regular tasks this wait is a no-op that does
+        # not yield a future. See gh-124309.
+        await ok_to_start.wait()
         # Wait for the previous task to finish, or for delay seconds
         if previous_failed is not None:
             with contextlib.suppress(exceptions_mod.TimeoutError):
@@ -96,9 +108,13 @@ async def run_one_coro(
             return
         # Start task that will run the next coroutine
         this_failed = locks.Event()
-        next_task = loop.create_task(run_one_coro(this_failed))
-        running_tasks.append(next_task)
-        assert len(running_tasks) == this_index + 2
+        next_ok_to_start = locks.Event()
+        next_task = loop.create_task(run_one_coro(next_ok_to_start, this_failed))
+        running_tasks.add(next_task)
+        next_task.add_done_callback(task_done)
+        # next_task has been appended to running_tasks so next_task is ok to
+        # start.
+        next_ok_to_start.set()
         # Prepare place to put this coroutine's exceptions if not won
         exceptions.append(None)
         assert len(exceptions) == this_index + 1
@@ -123,27 +139,36 @@ async def run_one_coro(
             # up as done() == True, cancelled() == False, exception() ==
             # asyncio.CancelledError. This behavior is specified in
             # https://bugs.python.org/issue30048
-            for i, t in enumerate(running_tasks):
-                if i != this_index:
+            current_task = tasks.current_task(loop)
+            for t in running_tasks:
+                if t is not current_task:
                     t.cancel()
 
-    first_task = loop.create_task(run_one_coro(None))
-    running_tasks.append(first_task)
+    propagate_cancellation_error = None
     try:
-        # Wait for a growing list of tasks to all finish: poor man's version of
-        # curio's TaskGroup or trio's nursery
-        done_count = 0
-        while done_count != len(running_tasks):
-            done, _ = await tasks.wait(running_tasks)
-            done_count = len(done)
+        ok_to_start = locks.Event()
+        first_task = loop.create_task(run_one_coro(ok_to_start, None))
+        running_tasks.add(first_task)
+        first_task.add_done_callback(task_done)
+        # first_task has been appended to running_tasks so first_task is ok to start.
+        ok_to_start.set()
+        propagate_cancellation_error = None
+        # Make sure no tasks are left running if we leave this function
+        while running_tasks:
+            on_completed_fut = loop.create_future()
+            try:
+                await on_completed_fut
+            except exceptions_mod.CancelledError as ex:
+                propagate_cancellation_error = ex
+                for task in running_tasks:
+                    task.cancel(*ex.args)
+            on_completed_fut = None
+        if __debug__ and unhandled_exceptions:
             # If run_one_coro raises an unhandled exception, it's probably a
             # programming error, and I want to see it.
-            if __debug__:
-                for d in done:
-                    if d.done() and not d.cancelled() and d.exception():
-                        raise d.exception()
+            raise ExceptionGroup("staggered race failed", unhandled_exceptions)
+        if propagate_cancellation_error is not None:
+            raise propagate_cancellation_error
         return winner_result, winner_index, exceptions
     finally:
-        # Make sure no tasks are left running if we leave this function
-        for t in running_tasks:
-            t.cancel()
+        del exceptions, propagate_cancellation_error, unhandled_exceptions
diff --git a/Lib/asyncio/streams.py b/Lib/asyncio/streams.py
index f310aa2f367..64aac4cc50d 100644
--- a/Lib/asyncio/streams.py
+++ b/Lib/asyncio/streams.py
@@ -201,7 +201,6 @@ def __init__(self, stream_reader, client_connected_cb=None, loop=None):
             # is established.
             self._strong_reader = stream_reader
         self._reject_connection = False
-        self._stream_writer = None
         self._task = None
         self._transport = None
         self._client_connected_cb = client_connected_cb
@@ -214,10 +213,8 @@ def _stream_reader(self):
             return None
         return self._stream_reader_wr()
 
-    def _replace_writer(self, writer):
+    def _replace_transport(self, transport):
         loop = self._loop
-        transport = writer.transport
-        self._stream_writer = writer
         self._transport = transport
         self._over_ssl = transport.get_extra_info('sslcontext') is not None
 
@@ -239,11 +236,8 @@ def connection_made(self, transport):
             reader.set_transport(transport)
         self._over_ssl = transport.get_extra_info('sslcontext') is not None
         if self._client_connected_cb is not None:
-            self._stream_writer = StreamWriter(transport, self,
-                                               reader,
-                                               self._loop)
-            res = self._client_connected_cb(reader,
-                                            self._stream_writer)
+            writer = StreamWriter(transport, self, reader, self._loop)
+            res = self._client_connected_cb(reader, writer)
             if coroutines.iscoroutine(res):
                 def callback(task):
                     if task.cancelled():
@@ -405,9 +399,9 @@ async def start_tls(self, sslcontext, *,
             ssl_handshake_timeout=ssl_handshake_timeout,
             ssl_shutdown_timeout=ssl_shutdown_timeout)
         self._transport = new_transport
-        protocol._replace_writer(self)
+        protocol._replace_transport(new_transport)
 
-    def __del__(self):
+    def __del__(self, warnings=warnings):
         if not self._transport.is_closing():
             if self._loop.is_closed():
                 warnings.warn("loop is closed", ResourceWarning)
@@ -596,20 +590,34 @@ async def readuntil(self, separator=b'\n'):
         If the data cannot be read because of over limit, a
         LimitOverrunError exception  will be raised, and the data
         will be left in the internal buffer, so it can be read again.
+
+        The ``separator`` may also be a tuple of separators. In this
+        case the return value will be the shortest possible that has any
+        separator as the suffix. For the purposes of LimitOverrunError,
+        the shortest possible separator is considered to be the one that
+        matched.
         """
-        seplen = len(separator)
-        if seplen == 0:
+        if isinstance(separator, tuple):
+            # Makes sure shortest matches wins
+            separator = sorted(separator, key=len)
+        else:
+            separator = [separator]
+        if not separator:
+            raise ValueError('Separator should contain at least one element')
+        min_seplen = len(separator[0])
+        max_seplen = len(separator[-1])
+        if min_seplen == 0:
             raise ValueError('Separator should be at least one-byte string')
 
         if self._exception is not None:
             raise self._exception
 
         # Consume whole buffer except last bytes, which length is
-        # one less than seplen. Let's check corner cases with
-        # separator='SEPARATOR':
+        # one less than max_seplen. Let's check corner cases with
+        # separator[-1]='SEPARATOR':
         # * we have received almost complete separator (without last
         #   byte). i.e buffer='some textSEPARATO'. In this case we
-        #   can safely consume len(separator) - 1 bytes.
+        #   can safely consume max_seplen - 1 bytes.
         # * last byte of buffer is first byte of separator, i.e.
         #   buffer='abcdefghijklmnopqrS'. We may safely consume
         #   everything except that last byte, but this require to
@@ -622,26 +630,35 @@ async def readuntil(self, separator=b'\n'):
         #   messages :)
 
         # `offset` is the number of bytes from the beginning of the buffer
-        # where there is no occurrence of `separator`.
+        # where there is no occurrence of any `separator`.
         offset = 0
 
-        # Loop until we find `separator` in the buffer, exceed the buffer size,
+        # Loop until we find a `separator` in the buffer, exceed the buffer size,
         # or an EOF has happened.
         while True:
             buflen = len(self._buffer)
 
-            # Check if we now have enough data in the buffer for `separator` to
-            # fit.
-            if buflen - offset >= seplen:
-                isep = self._buffer.find(separator, offset)
-
-                if isep != -1:
-                    # `separator` is in the buffer. `isep` will be used later
-                    # to retrieve the data.
+            # Check if we now have enough data in the buffer for shortest
+            # separator to fit.
+            if buflen - offset >= min_seplen:
+                match_start = None
+                match_end = None
+                for sep in separator:
+                    isep = self._buffer.find(sep, offset)
+
+                    if isep != -1:
+                        # `separator` is in the buffer. `match_start` and
+                        # `match_end` will be used later to retrieve the
+                        # data.
+                        end = isep + len(sep)
+                        if match_end is None or end < match_end:
+                            match_end = end
+                            match_start = isep
+                if match_end is not None:
                     break
 
                 # see upper comment for explanation.
-                offset = buflen + 1 - seplen
+                offset = max(0, buflen + 1 - max_seplen)
                 if offset > self._limit:
                     raise exceptions.LimitOverrunError(
                         'Separator is not found, and chunk exceed the limit',
@@ -650,7 +667,7 @@ async def readuntil(self, separator=b'\n'):
             # Complete message (with full separator) may be present in buffer
             # even when EOF flag is set. This may happen when the last chunk
             # adds data which makes separator be found. That's why we check for
-            # EOF *ater* inspecting the buffer.
+            # EOF *after* inspecting the buffer.
             if self._eof:
                 chunk = bytes(self._buffer)
                 self._buffer.clear()
@@ -659,12 +676,12 @@ async def readuntil(self, separator=b'\n'):
             # _wait_for_data() will resume reading if stream was paused.
             await self._wait_for_data('readuntil')
 
-        if isep > self._limit:
+        if match_start > self._limit:
             raise exceptions.LimitOverrunError(
-                'Separator is found, but chunk is longer than limit', isep)
+                'Separator is found, but chunk is longer than limit', match_start)
 
-        chunk = self._buffer[:isep + seplen]
-        del self._buffer[:isep + seplen]
+        chunk = self._buffer[:match_end]
+        del self._buffer[:match_end]
         self._maybe_resume_transport()
         return bytes(chunk)
 
diff --git a/Lib/asyncio/taskgroups.py b/Lib/asyncio/taskgroups.py
index d264e51f1fd..8fda6c8d55e 100644
--- a/Lib/asyncio/taskgroups.py
+++ b/Lib/asyncio/taskgroups.py
@@ -66,6 +66,20 @@ async def __aenter__(self):
         return self
 
     async def __aexit__(self, et, exc, tb):
+        tb = None
+        try:
+            return await self._aexit(et, exc)
+        finally:
+            # Exceptions are heavy objects that can have object
+            # cycles (bad for GC); let's not keep a reference to
+            # a bunch of them. It would be nicer to use a try/finally
+            # in __aexit__ directly but that introduced some diff noise
+            self._parent_task = None
+            self._errors = None
+            self._base_error = None
+            exc = None
+
+    async def _aexit(self, et, exc):
         self._exiting = True
 
         if (exc is not None and
@@ -73,14 +87,10 @@ async def __aexit__(self, et, exc, tb):
                 self._base_error is None):
             self._base_error = exc
 
-        propagate_cancellation_error = \
-            exc if et is exceptions.CancelledError else None
-        if self._parent_cancel_requested:
-            # If this flag is set we *must* call uncancel().
-            if self._parent_task.uncancel() == 0:
-                # If there are no pending cancellations left,
-                # don't propagate CancelledError.
-                propagate_cancellation_error = None
+        if et is not None and issubclass(et, exceptions.CancelledError):
+            propagate_cancellation_error = exc
+        else:
+            propagate_cancellation_error = None
 
         if et is not None:
             if not self._aborting:
@@ -126,25 +136,47 @@ async def __aexit__(self, et, exc, tb):
         assert not self._tasks
 
         if self._base_error is not None:
-            raise self._base_error
+            try:
+                raise self._base_error
+            finally:
+                exc = None
+
+        if self._parent_cancel_requested:
+            # If this flag is set we *must* call uncancel().
+            if self._parent_task.uncancel() == 0:
+                # If there are no pending cancellations left,
+                # don't propagate CancelledError.
+                propagate_cancellation_error = None
 
         # Propagate CancelledError if there is one, except if there
         # are other errors -- those have priority.
-        if propagate_cancellation_error and not self._errors:
-            raise propagate_cancellation_error
-
-        if et is not None and et is not exceptions.CancelledError:
+        try:
+            if propagate_cancellation_error is not None and not self._errors:
+                try:
+                    raise propagate_cancellation_error
+                finally:
+                    exc = None
+        finally:
+            propagate_cancellation_error = None
+
+        if et is not None and not issubclass(et, exceptions.CancelledError):
             self._errors.append(exc)
 
         if self._errors:
-            # Exceptions are heavy objects that can have object
-            # cycles (bad for GC); let's not keep a reference to
-            # a bunch of them.
+            # If the parent task is being cancelled from the outside
+            # of the taskgroup, un-cancel and re-cancel the parent task,
+            # which will keep the cancel count stable.
+            if self._parent_task.cancelling():
+                self._parent_task.uncancel()
+                self._parent_task.cancel()
             try:
-                me = BaseExceptionGroup('unhandled errors in a TaskGroup', self._errors)
-                raise me from None
+                raise BaseExceptionGroup(
+                    'unhandled errors in a TaskGroup',
+                    self._errors,
+                ) from None
             finally:
-                self._errors = None
+                exc = None
+
 
     def create_task(self, coro, *, name=None, context=None):
         """Create a new task in this group and return it.
@@ -152,25 +184,31 @@ def create_task(self, coro, *, name=None, context=None):
         Similar to `asyncio.create_task`.
         """
         if not self._entered:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} has not been entered")
         if self._exiting and not self._tasks:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} is finished")
         if self._aborting:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} is shutting down")
         if context is None:
-            task = self._loop.create_task(coro)
+            task = self._loop.create_task(coro, name=name)
         else:
-            task = self._loop.create_task(coro, context=context)
-        tasks._set_task_name(task, name)
-        # optimization: Immediately call the done callback if the task is
+            task = self._loop.create_task(coro, name=name, context=context)
+
+        # Always schedule the done callback even if the task is
         # already done (e.g. if the coro was able to complete eagerly),
-        # and skip scheduling a done callback
-        if task.done():
-            self._on_task_done(task)
-        else:
-            self._tasks.add(task)
-            task.add_done_callback(self._on_task_done)
-        return task
+        # otherwise if the task completes with an exception then it will cancel
+        # the current task too early. gh-128550, gh-128588
+        self._tasks.add(task)
+        task.add_done_callback(self._on_task_done)
+        try:
+            return task
+        finally:
+            # gh-128552: prevent a refcycle of
+            # task.exception().__traceback__->TaskGroup.create_task->task
+            del task
 
     # Since Python 3.8 Tasks propagate all exceptions correctly,
     # except for KeyboardInterrupt and SystemExit which are
diff --git a/Lib/asyncio/tasks.py b/Lib/asyncio/tasks.py
index 0b22e28d8e0..dadcb5b5f36 100644
--- a/Lib/asyncio/tasks.py
+++ b/Lib/asyncio/tasks.py
@@ -15,8 +15,8 @@
 import functools
 import inspect
 import itertools
+import math
 import types
-import warnings
 import weakref
 from types import GenericAlias
 
@@ -25,6 +25,7 @@
 from . import events
 from . import exceptions
 from . import futures
+from . import queues
 from . import timeouts
 
 # Helper to generate new task names
@@ -67,19 +68,6 @@ def all_tasks(loop=None):
             if futures._get_loop(t) is loop and not t.done()}
 
 
-def _set_task_name(task, name):
-    if name is not None:
-        try:
-            set_name = task.set_name
-        except AttributeError:
-            warnings.warn("Task.set_name() was added in Python 3.8, "
-                      "the method support will be mandatory for third-party "
-                      "task implementations since 3.13.",
-                      DeprecationWarning, stacklevel=3)
-        else:
-            set_name(name)
-
-
 class Task(futures._PyFuture):  # Inherit Python Task implementation
                                 # from a Python Future implementation.
 
@@ -267,6 +255,8 @@ def uncancel(self):
         """
         if self._num_cancels_requested > 0:
             self._num_cancels_requested -= 1
+            if self._num_cancels_requested == 0:
+                self._must_cancel = False
         return self._num_cancels_requested
 
     def __eager_start(self):
@@ -417,11 +407,10 @@ def create_task(coro, *, name=None, context=None):
     loop = events.get_running_loop()
     if context is None:
         # Use legacy API if context is not needed
-        task = loop.create_task(coro)
+        task = loop.create_task(coro, name=name)
     else:
-        task = loop.create_task(coro, context=context)
+        task = loop.create_task(coro, name=name, context=context)
 
-    _set_task_name(task, name)
     return task
 
 
@@ -437,8 +426,6 @@ async def wait(fs, *, timeout=None, return_when=ALL_COMPLETED):
 
     The fs iterable must not be empty.
 
-    Coroutines will be wrapped in Tasks.
-
     Returns two sets of Future: (done, pending).
 
     Usage:
@@ -580,62 +567,125 @@ async def _cancel_and_wait(fut):
         fut.remove_done_callback(cb)
 
 
-# This is *not* a @coroutine!  It is just an iterator (yielding Futures).
+class _AsCompletedIterator:
+    """Iterator of awaitables representing tasks of asyncio.as_completed.
+
+    As an asynchronous iterator, iteration yields futures as they finish. As a
+    plain iterator, new coroutines are yielded that will return or raise the
+    result of the next underlying future to complete.
+    """
+    def __init__(self, aws, timeout):
+        self._done = queues.Queue()
+        self._timeout_handle = None
+
+        loop = events.get_event_loop()
+        todo = {ensure_future(aw, loop=loop) for aw in set(aws)}
+        for f in todo:
+            f.add_done_callback(self._handle_completion)
+        if todo and timeout is not None:
+            self._timeout_handle = (
+                loop.call_later(timeout, self._handle_timeout)
+            )
+        self._todo = todo
+        self._todo_left = len(todo)
+
+    def __aiter__(self):
+        return self
+
+    def __iter__(self):
+        return self
+
+    async def __anext__(self):
+        if not self._todo_left:
+            raise StopAsyncIteration
+        assert self._todo_left > 0
+        self._todo_left -= 1
+        return await self._wait_for_one()
+
+    def __next__(self):
+        if not self._todo_left:
+            raise StopIteration
+        assert self._todo_left > 0
+        self._todo_left -= 1
+        return self._wait_for_one(resolve=True)
+
+    def _handle_timeout(self):
+        for f in self._todo:
+            f.remove_done_callback(self._handle_completion)
+            self._done.put_nowait(None)  # Sentinel for _wait_for_one().
+        self._todo.clear()  # Can't do todo.remove(f) in the loop.
+
+    def _handle_completion(self, f):
+        if not self._todo:
+            return  # _handle_timeout() was here first.
+        self._todo.remove(f)
+        self._done.put_nowait(f)
+        if not self._todo and self._timeout_handle is not None:
+            self._timeout_handle.cancel()
+
+    async def _wait_for_one(self, resolve=False):
+        # Wait for the next future to be done and return it unless resolve is
+        # set, in which case return either the result of the future or raise
+        # an exception.
+        f = await self._done.get()
+        if f is None:
+            # Dummy value from _handle_timeout().
+            raise exceptions.TimeoutError
+        return f.result() if resolve else f
+
+
 def as_completed(fs, *, timeout=None):
-    """Return an iterator whose values are coroutines.
+    """Create an iterator of awaitables or their results in completion order.
 
-    When waiting for the yielded coroutines you'll get the results (or
-    exceptions!) of the original Futures (or coroutines), in the order
-    in which and as soon as they complete.
+    Run the supplied awaitables concurrently. The returned object can be
+    iterated to obtain the results of the awaitables as they finish.
 
-    This differs from PEP 3148; the proper way to use this is:
+    The object returned can be iterated as an asynchronous iterator or a plain
+    iterator. When asynchronous iteration is used, the originally-supplied
+    awaitables are yielded if they are tasks or futures. This makes it easy to
+    correlate previously-scheduled tasks with their results:
 
-        for f in as_completed(fs):
-            result = await f  # The 'await' may raise.
-            # Use result.
+        ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+        ipv6_connect = create_task(open_connection("::1", 80))
+        tasks = [ipv4_connect, ipv6_connect]
 
-    If a timeout is specified, the 'await' will raise
-    TimeoutError when the timeout occurs before all Futures are done.
+        async for earliest_connect in as_completed(tasks):
+            # earliest_connect is done. The result can be obtained by
+            # awaiting it or calling earliest_connect.result()
+            reader, writer = await earliest_connect
 
-    Note: The futures 'f' are not necessarily members of fs.
-    """
-    if futures.isfuture(fs) or coroutines.iscoroutine(fs):
-        raise TypeError(f"expect an iterable of futures, not {type(fs).__name__}")
+            if earliest_connect is ipv6_connect:
+                print("IPv6 connection established.")
+            else:
+                print("IPv4 connection established.")
 
-    from .queues import Queue  # Import here to avoid circular import problem.
-    done = Queue()
+    During asynchronous iteration, implicitly-created tasks will be yielded for
+    supplied awaitables that aren't tasks or futures.
 
-    loop = events.get_event_loop()
-    todo = {ensure_future(f, loop=loop) for f in set(fs)}
-    timeout_handle = None
+    When used as a plain iterator, each iteration yields a new coroutine that
+    returns the result or raises the exception of the next completed awaitable.
+    This pattern is compatible with Python versions older than 3.13:
 
-    def _on_timeout():
-        for f in todo:
-            f.remove_done_callback(_on_completion)
-            done.put_nowait(None)  # Queue a dummy value for _wait_for_one().
-        todo.clear()  # Can't do todo.remove(f) in the loop.
+        ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+        ipv6_connect = create_task(open_connection("::1", 80))
+        tasks = [ipv4_connect, ipv6_connect]
 
-    def _on_completion(f):
-        if not todo:
-            return  # _on_timeout() was here first.
-        todo.remove(f)
-        done.put_nowait(f)
-        if not todo and timeout_handle is not None:
-            timeout_handle.cancel()
+        for next_connect in as_completed(tasks):
+            # next_connect is not one of the original task objects. It must be
+            # awaited to obtain the result value or raise the exception of the
+            # awaitable that finishes next.
+            reader, writer = await next_connect
 
-    async def _wait_for_one():
-        f = await done.get()
-        if f is None:
-            # Dummy value from _on_timeout().
-            raise exceptions.TimeoutError
-        return f.result()  # May raise f.exception().
+    A TimeoutError is raised if the timeout occurs before all awaitables are
+    done. This is raised by the async for loop during asynchronous iteration or
+    by the coroutines yielded during plain iteration.
+    """
+    if inspect.isawaitable(fs):
+        raise TypeError(
+            f"expects an iterable of awaitables, not {type(fs).__name__}"
+        )
 
-    for f in todo:
-        f.add_done_callback(_on_completion)
-    if todo and timeout is not None:
-        timeout_handle = loop.call_later(timeout, _on_timeout)
-    for _ in range(len(todo)):
-        yield _wait_for_one()
+    return _AsCompletedIterator(fs, timeout)
 
 
 @types.coroutine
@@ -656,6 +706,9 @@ async def sleep(delay, result=None):
         await __sleep0()
         return result
 
+    if math.isnan(delay):
+        raise ValueError("Invalid delay: NaN (not a number)")
+
     loop = events.get_running_loop()
     future = loop.create_future()
     h = loop.call_later(delay,
diff --git a/Lib/asyncio/timeouts.py b/Lib/asyncio/timeouts.py
index 30042abb3ad..e6f5100691d 100644
--- a/Lib/asyncio/timeouts.py
+++ b/Lib/asyncio/timeouts.py
@@ -109,10 +109,16 @@ async def __aexit__(
         if self._state is _State.EXPIRING:
             self._state = _State.EXPIRED
 
-            if self._task.uncancel() <= self._cancelling and exc_type is exceptions.CancelledError:
+            if self._task.uncancel() <= self._cancelling and exc_type is not None:
                 # Since there are no new cancel requests, we're
                 # handling this.
-                raise TimeoutError from exc_val
+                if issubclass(exc_type, exceptions.CancelledError):
+                    raise TimeoutError from exc_val
+                elif exc_val is not None:
+                    self._insert_timeout_error(exc_val)
+                    if isinstance(exc_val, ExceptionGroup):
+                        for exc in exc_val.exceptions:
+                            self._insert_timeout_error(exc)
         elif self._state is _State.ENTERED:
             self._state = _State.EXITED
 
@@ -125,6 +131,16 @@ def _on_timeout(self) -> None:
         # drop the reference early
         self._timeout_handler = None
 
+    @staticmethod
+    def _insert_timeout_error(exc_val: BaseException) -> None:
+        while exc_val.__context__ is not None:
+            if isinstance(exc_val.__context__, exceptions.CancelledError):
+                te = TimeoutError()
+                te.__context__ = te.__cause__ = exc_val.__context__
+                exc_val.__context__ = te
+                break
+            exc_val = exc_val.__context__
+
 
 def timeout(delay: Optional[float]) -> Timeout:
     """Timeout async context manager.
diff --git a/Lib/asyncio/transports.py b/Lib/asyncio/transports.py
index 30fd41d49af..34c7ad44ffd 100644
--- a/Lib/asyncio/transports.py
+++ b/Lib/asyncio/transports.py
@@ -181,6 +181,8 @@ def sendto(self, data, addr=None):
         to be sent out asynchronously.
         addr is target socket address.
         If addr is None use target address pointed on transport creation.
+        If data is an empty bytes object a zero-length datagram will be
+        sent.
         """
         raise NotImplementedError
 
diff --git a/Lib/asyncio/unix_events.py b/Lib/asyncio/unix_events.py
index f2e920ada46..41ccf1b78fb 100644
--- a/Lib/asyncio/unix_events.py
+++ b/Lib/asyncio/unix_events.py
@@ -32,6 +32,7 @@
     'FastChildWatcher', 'PidfdChildWatcher',
     'MultiLoopChildWatcher', 'ThreadedChildWatcher',
     'DefaultEventLoopPolicy',
+    'EventLoop',
 )
 
 
@@ -63,6 +64,7 @@ class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
     def __init__(self, selector=None):
         super().__init__(selector)
         self._signal_handlers = {}
+        self._unix_server_sockets = {}
 
     def close(self):
         super().close()
@@ -283,7 +285,7 @@ async def create_unix_server(
             sock=None, backlog=100, ssl=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
-            start_serving=True):
+            start_serving=True, cleanup_socket=True):
         if isinstance(ssl, bool):
             raise TypeError('ssl argument must be an SSLContext or None')
 
@@ -339,6 +341,15 @@ async def create_unix_server(
                 raise ValueError(
                     f'A UNIX Domain Stream Socket was expected, got {sock!r}')
 
+        if cleanup_socket:
+            path = sock.getsockname()
+            # Check for abstract socket. `str` and `bytes` paths are supported.
+            if path[0] not in (0, '\x00'):
+                try:
+                    self._unix_server_sockets[sock] = os.stat(path).st_ino
+                except FileNotFoundError:
+                    pass
+
         sock.setblocking(False)
         server = base_events.Server(self, [sock], protocol_factory,
                                     ssl, backlog, ssl_handshake_timeout,
@@ -393,6 +404,9 @@ def _sock_sendfile_native_impl(self, fut, registered_fd, sock, fileno,
                 fut.set_result(total_sent)
                 return
 
+        # On 32-bit architectures truncate to 1GiB to avoid OverflowError
+        blocksize = min(blocksize, sys.maxsize//2 + 1)
+
         try:
             sent = os.sendfile(fd, fileno, offset, blocksize)
         except (BlockingIOError, InterruptedError):
@@ -456,6 +470,27 @@ def cb(fut):
                     self.remove_writer(fd)
         fut.add_done_callback(cb)
 
+    def _stop_serving(self, sock):
+        # Is this a unix socket that needs cleanup?
+        if sock in self._unix_server_sockets:
+            path = sock.getsockname()
+        else:
+            path = None
+
+        super()._stop_serving(sock)
+
+        if path is not None:
+            prev_ino = self._unix_server_sockets[sock]
+            del self._unix_server_sockets[sock]
+            try:
+                if os.stat(path).st_ino == prev_ino:
+                    os.unlink(path)
+            except FileNotFoundError:
+                pass
+            except OSError as err:
+                logger.error('Unable to clean up listening UNIX socket '
+                             '%r: %r', path, err)
+
 
 class _UnixReadPipeTransport(transports.ReadTransport):
 
@@ -1498,3 +1533,4 @@ def set_child_watcher(self, watcher):
 
 SelectorEventLoop = _UnixSelectorEventLoop
 DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+EventLoop = SelectorEventLoop
diff --git a/Lib/asyncio/windows_events.py b/Lib/asyncio/windows_events.py
index cb613451a58..bf99bc271c7 100644
--- a/Lib/asyncio/windows_events.py
+++ b/Lib/asyncio/windows_events.py
@@ -30,7 +30,7 @@
 __all__ = (
     'SelectorEventLoop', 'ProactorEventLoop', 'IocpProactor',
     'DefaultEventLoopPolicy', 'WindowsSelectorEventLoopPolicy',
-    'WindowsProactorEventLoopPolicy',
+    'WindowsProactorEventLoopPolicy', 'EventLoop',
 )
 
 
@@ -315,24 +315,25 @@ def __init__(self, proactor=None):
             proactor = IocpProactor()
         super().__init__(proactor)
 
-    def run_forever(self):
-        try:
-            assert self._self_reading_future is None
-            self.call_soon(self._loop_self_reading)
-            super().run_forever()
-        finally:
-            if self._self_reading_future is not None:
-                ov = self._self_reading_future._ov
-                self._self_reading_future.cancel()
-                # self_reading_future always uses IOCP, so even though it's
-                # been cancelled, we need to make sure that the IOCP message
-                # is received so that the kernel is not holding on to the
-                # memory, possibly causing memory corruption later. Only
-                # unregister it if IO is complete in all respects. Otherwise
-                # we need another _poll() later to complete the IO.
-                if ov is not None and not ov.pending:
-                    self._proactor._unregister(ov)
-                self._self_reading_future = None
+    def _run_forever_setup(self):
+        assert self._self_reading_future is None
+        self.call_soon(self._loop_self_reading)
+        super()._run_forever_setup()
+
+    def _run_forever_cleanup(self):
+        super()._run_forever_cleanup()
+        if self._self_reading_future is not None:
+            ov = self._self_reading_future._ov
+            self._self_reading_future.cancel()
+            # self_reading_future always uses IOCP, so even though it's
+            # been cancelled, we need to make sure that the IOCP message
+            # is received so that the kernel is not holding on to the
+            # memory, possibly causing memory corruption later. Only
+            # unregister it if IO is complete in all respects. Otherwise
+            # we need another _poll() later to complete the IO.
+            if ov is not None and not ov.pending:
+                self._proactor._unregister(ov)
+            self._self_reading_future = None
 
     async def create_pipe_connection(self, protocol_factory, address):
         f = self._proactor.connect_pipe(address)
@@ -899,3 +900,4 @@ class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
 
 
 DefaultEventLoopPolicy = WindowsProactorEventLoopPolicy
+EventLoop = ProactorEventLoop
diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index f77a5888eeb..8f73f466379 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -486,7 +486,6 @@ async def test_demo1(self):
         result = test.run()
         self.assertTrue(result.wasSuccessful())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_loop_factory(self):
         asyncio.set_event_loop_policy(None)
 

From 3a702ac772d7bee2da7e42c343f35be4f07c2cea Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Thu, 15 Jan 2026 19:53:46 +0900
Subject: [PATCH 297/418] Improve `json.loads` performance (#6704)

* Parse JSON in Rust

* Reuse key when decoding JSON

* Unmark resolved test

* Parse null/true/false directly in call_scan_once

Parse JSON constants (null, true, false) directly in Rust within
call_scan_once() instead of falling back to Python scan_once.
This reduces Python-Rust boundary crossings for array/object values.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Parse numbers directly in call_scan_once

Parse JSON numbers starting with digits (0-9) directly in Rust within
call_scan_once() by reusing the existing parse_number() method.
This reduces Python-Rust boundary crossings for array/object values.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Parse NaN/Infinity/-Infinity in call_scan_once

Parse special JSON constants (NaN, Infinity, -Infinity) and negative
numbers directly in Rust within call_scan_once(). This handles:
- 'N' -> NaN via parse_constant callback
- 'I' -> Infinity via parse_constant callback
- '-' -> -Infinity or negative numbers via parse_constant/parse_number

This reduces Python-Rust boundary crossings for array/object values.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Correct wrong index access

* Leave more flame span

* Refactor json scanstring with byte index

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
---
 Lib/test/test_json/test_decode.py   |   2 -
 crates/stdlib/src/json.rs           | 578 +++++++++++++++++++++++++---
 crates/stdlib/src/json/machinery.rs |  80 +++-
 3 files changed, 587 insertions(+), 73 deletions(-)

diff --git a/Lib/test/test_json/test_decode.py b/Lib/test/test_json/test_decode.py
index f07f7d55339..ad37d47f083 100644
--- a/Lib/test/test_json/test_decode.py
+++ b/Lib/test/test_json/test_decode.py
@@ -138,8 +138,6 @@ def test_limit_int(self):
 class TestPyDecode(TestDecode, PyTest): pass
 
 class TestCDecode(TestDecode, CTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_keys_reuse(self):
         return super().test_keys_reuse()
 
diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
index cc98ad912cc..4bdf4533533 100644
--- a/crates/stdlib/src/json.rs
+++ b/crates/stdlib/src/json.rs
@@ -7,7 +7,7 @@ mod _json {
     use crate::vm::{
         AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
         builtins::{PyBaseExceptionRef, PyStrRef, PyType},
-        convert::{ToPyObject, ToPyResult},
+        convert::ToPyResult,
         function::{IntoFuncArgs, OptionalArg},
         protocol::PyIterReturn,
         types::{Callable, Constructor},
@@ -15,6 +15,29 @@ mod _json {
     use core::str::FromStr;
     use malachite_bigint::BigInt;
     use rustpython_common::wtf8::Wtf8Buf;
+    use std::collections::HashMap;
+
+    /// Skip JSON whitespace characters (space, tab, newline, carriage return).
+    /// Works with a byte slice and returns the number of bytes skipped.
+    /// Since all JSON whitespace chars are ASCII, bytes == chars.
+    #[inline]
+    fn skip_whitespace(bytes: &[u8]) -> usize {
+        flame_guard!("_json::skip_whitespace");
+        let mut count = 0;
+        for &b in bytes {
+            match b {
+                b' ' | b'\t' | b'\n' | b'\r' => count += 1,
+                _ => break,
+            }
+        }
+        count
+    }
+
+    /// Check if a byte slice starts with a given ASCII pattern.
+    #[inline]
+    fn starts_with_bytes(bytes: &[u8], pattern: &[u8]) -> bool {
+        bytes.len() >= pattern.len() && &bytes[..pattern.len()] == pattern
+    }
 
     #[pyattr(name = "make_scanner")]
     #[pyclass(name = "Scanner", traverse)]
@@ -68,58 +91,64 @@ mod _json {
     impl JsonScanner {
         fn parse(
             &self,
-            s: &str,
             pystr: PyStrRef,
-            idx: usize,
+            char_idx: usize,
+            byte_idx: usize,
             scan_once: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyIterReturn> {
             flame_guard!("JsonScanner::parse");
-            let c = match s.chars().next() {
-                Some(c) => c,
+            let bytes = pystr.as_str().as_bytes();
+            let wtf8 = pystr.as_wtf8();
+
+            let first_byte = match bytes.get(byte_idx) {
+                Some(&b) => b,
                 None => {
                     return Ok(PyIterReturn::StopIteration(Some(
-                        vm.ctx.new_int(idx).into(),
+                        vm.ctx.new_int(char_idx).into(),
                     )));
                 }
             };
-            let next_idx = idx + c.len_utf8();
-            match c {
-                '"' => {
-                    return scanstring(pystr, next_idx, OptionalArg::Present(self.strict), vm)
-                        .map(|x| PyIterReturn::Return(x.to_pyobject(vm)));
+
+            match first_byte {
+                b'"' => {
+                    // Parse string - pass slice starting after the quote
+                    let (wtf8_result, chars_consumed, _bytes_consumed) =
+                        machinery::scanstring(&wtf8[byte_idx + 1..], char_idx + 1, self.strict)
+                            .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+                    let end_char_idx = char_idx + 1 + chars_consumed;
+                    return Ok(PyIterReturn::Return(
+                        vm.new_tuple((wtf8_result, end_char_idx)).into(),
+                    ));
                 }
-                '{' => {
-                    // TODO: parse the object in rust
-                    let parse_obj = self.ctx.get_attr("parse_object", vm)?;
-                    let result = parse_obj.call(
-                        (
-                            (pystr, next_idx),
-                            self.strict,
-                            scan_once,
-                            self.object_hook.clone(),
-                            self.object_pairs_hook.clone(),
-                        ),
-                        vm,
-                    );
-                    return PyIterReturn::from_pyresult(result, vm);
+                b'{' => {
+                    // Parse object in Rust
+                    let mut memo = HashMap::new();
+                    return self
+                        .parse_object(pystr, char_idx + 1, byte_idx + 1, &scan_once, &mut memo, vm)
+                        .map(|(obj, end_char, _end_byte)| {
+                            PyIterReturn::Return(vm.new_tuple((obj, end_char)).into())
+                        });
                 }
-                '[' => {
-                    // TODO: parse the array in rust
-                    let parse_array = self.ctx.get_attr("parse_array", vm)?;
-                    return PyIterReturn::from_pyresult(
-                        parse_array.call(((pystr, next_idx), scan_once), vm),
-                        vm,
-                    );
+                b'[' => {
+                    // Parse array in Rust
+                    let mut memo = HashMap::new();
+                    return self
+                        .parse_array(pystr, char_idx + 1, byte_idx + 1, &scan_once, &mut memo, vm)
+                        .map(|(obj, end_char, _end_byte)| {
+                            PyIterReturn::Return(vm.new_tuple((obj, end_char)).into())
+                        });
                 }
                 _ => {}
             }
 
+            let s = &pystr.as_str()[byte_idx..];
+
             macro_rules! parse_const {
                 ($s:literal, $val:expr) => {
                     if s.starts_with($s) {
                         return Ok(PyIterReturn::Return(
-                            vm.new_tuple(($val, idx + $s.len())).into(),
+                            vm.new_tuple(($val, char_idx + $s.len())).into(),
                         ));
                     }
                 };
@@ -130,15 +159,20 @@ mod _json {
             parse_const!("false", false);
 
             if let Some((res, len)) = self.parse_number(s, vm) {
-                return Ok(PyIterReturn::Return(vm.new_tuple((res?, idx + len)).into()));
+                return Ok(PyIterReturn::Return(
+                    vm.new_tuple((res?, char_idx + len)).into(),
+                ));
             }
 
             macro_rules! parse_constant {
                 ($s:literal) => {
                     if s.starts_with($s) {
                         return Ok(PyIterReturn::Return(
-                            vm.new_tuple((self.parse_constant.call(($s,), vm)?, idx + $s.len()))
-                                .into(),
+                            vm.new_tuple((
+                                self.parse_constant.call(($s,), vm)?,
+                                char_idx + $s.len(),
+                            ))
+                            .into(),
                         ));
                     }
                 };
@@ -149,7 +183,7 @@ mod _json {
             parse_constant!("-Infinity");
 
             Ok(PyIterReturn::StopIteration(Some(
-                vm.ctx.new_int(idx).into(),
+                vm.ctx.new_int(char_idx).into(),
             )))
         }
 
@@ -189,28 +223,443 @@ mod _json {
             };
             Some((ret, buf.len()))
         }
+
+        /// Parse a JSON object starting after the opening '{'.
+        /// Returns (parsed_object, end_char_index, end_byte_index).
+        fn parse_object(
+            &self,
+            pystr: PyStrRef,
+            start_char_idx: usize,
+            start_byte_idx: usize,
+            scan_once: &PyObjectRef,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            flame_guard!("JsonScanner::parse_object");
+
+            let bytes = pystr.as_str().as_bytes();
+            let wtf8 = pystr.as_wtf8();
+            let mut char_idx = start_char_idx;
+            let mut byte_idx = start_byte_idx;
+
+            // Skip initial whitespace
+            let ws = skip_whitespace(&bytes[byte_idx..]);
+            char_idx += ws;
+            byte_idx += ws;
+
+            // Check for empty object
+            match bytes.get(byte_idx) {
+                Some(b'}') => {
+                    return self.finalize_object(vec![], char_idx + 1, byte_idx + 1, vm);
+                }
+                Some(b'"') => {
+                    // Continue to parse first key
+                }
+                _ => {
+                    return Err(self.make_decode_error(
+                        "Expecting property name enclosed in double quotes",
+                        pystr,
+                        char_idx,
+                        vm,
+                    ));
+                }
+            }
+
+            let mut pairs: Vec<(PyObjectRef, PyObjectRef)> = Vec::new();
+
+            loop {
+                // We're now at '"', skip it
+                char_idx += 1;
+                byte_idx += 1;
+
+                // Parse key string using scanstring with byte slice
+                let (key_wtf8, chars_consumed, bytes_consumed) =
+                    machinery::scanstring(&wtf8[byte_idx..], char_idx, self.strict)
+                        .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+
+                char_idx += chars_consumed;
+                byte_idx += bytes_consumed;
+
+                // Key memoization - reuse existing key strings
+                let key_str = key_wtf8.to_string();
+                let key: PyObjectRef = match memo.get(&key_str) {
+                    Some(cached) => cached.clone().into(),
+                    None => {
+                        let py_key = vm.ctx.new_str(key_str.clone());
+                        memo.insert(key_str, py_key.clone());
+                        py_key.into()
+                    }
+                };
+
+                // Skip whitespace after key
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Expect ':' delimiter
+                match bytes.get(byte_idx) {
+                    Some(b':') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ':' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+
+                // Skip whitespace after ':'
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Parse value recursively
+                let (value, value_char_end, value_byte_end) =
+                    self.call_scan_once(scan_once, pystr.clone(), char_idx, byte_idx, memo, vm)?;
+
+                pairs.push((key, value));
+                char_idx = value_char_end;
+                byte_idx = value_byte_end;
+
+                // Skip whitespace after value
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Check for ',' or '}'
+                match bytes.get(byte_idx) {
+                    Some(b'}') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                        break;
+                    }
+                    Some(b',') => {
+                        let comma_char_idx = char_idx;
+                        char_idx += 1;
+                        byte_idx += 1;
+
+                        // Skip whitespace after comma
+                        let ws = skip_whitespace(&bytes[byte_idx..]);
+                        char_idx += ws;
+                        byte_idx += ws;
+
+                        // Next must be '"'
+                        match bytes.get(byte_idx) {
+                            Some(b'"') => {
+                                // Continue to next key-value pair
+                            }
+                            Some(b'}') => {
+                                // Trailing comma before end of object
+                                return Err(self.make_decode_error(
+                                    "Illegal trailing comma before end of object",
+                                    pystr,
+                                    comma_char_idx,
+                                    vm,
+                                ));
+                            }
+                            _ => {
+                                return Err(self.make_decode_error(
+                                    "Expecting property name enclosed in double quotes",
+                                    pystr,
+                                    char_idx,
+                                    vm,
+                                ));
+                            }
+                        }
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ',' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+            }
+
+            self.finalize_object(pairs, char_idx, byte_idx, vm)
+        }
+
+        /// Parse a JSON array starting after the opening '['.
+        /// Returns (parsed_array, end_char_index, end_byte_index).
+        fn parse_array(
+            &self,
+            pystr: PyStrRef,
+            start_char_idx: usize,
+            start_byte_idx: usize,
+            scan_once: &PyObjectRef,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            flame_guard!("JsonScanner::parse_array");
+
+            let bytes = pystr.as_str().as_bytes();
+            let mut char_idx = start_char_idx;
+            let mut byte_idx = start_byte_idx;
+
+            // Skip initial whitespace
+            let ws = skip_whitespace(&bytes[byte_idx..]);
+            char_idx += ws;
+            byte_idx += ws;
+
+            // Check for empty array
+            if bytes.get(byte_idx) == Some(&b']') {
+                return Ok((vm.ctx.new_list(vec![]).into(), char_idx + 1, byte_idx + 1));
+            }
+
+            let mut values: Vec<PyObjectRef> = Vec::new();
+
+            loop {
+                // Parse value
+                let (value, value_char_end, value_byte_end) =
+                    self.call_scan_once(scan_once, pystr.clone(), char_idx, byte_idx, memo, vm)?;
+
+                values.push(value);
+                char_idx = value_char_end;
+                byte_idx = value_byte_end;
+
+                // Skip whitespace after value
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                match bytes.get(byte_idx) {
+                    Some(b']') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                        break;
+                    }
+                    Some(b',') => {
+                        let comma_char_idx = char_idx;
+                        char_idx += 1;
+                        byte_idx += 1;
+
+                        // Skip whitespace after comma
+                        let ws = skip_whitespace(&bytes[byte_idx..]);
+                        char_idx += ws;
+                        byte_idx += ws;
+
+                        // Check for trailing comma
+                        if bytes.get(byte_idx) == Some(&b']') {
+                            return Err(self.make_decode_error(
+                                "Illegal trailing comma before end of array",
+                                pystr,
+                                comma_char_idx,
+                                vm,
+                            ));
+                        }
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ',' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+            }
+
+            Ok((vm.ctx.new_list(values).into(), char_idx, byte_idx))
+        }
+
+        /// Finalize object construction with hooks.
+        fn finalize_object(
+            &self,
+            pairs: Vec<(PyObjectRef, PyObjectRef)>,
+            end_char_idx: usize,
+            end_byte_idx: usize,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            let result = if let Some(ref pairs_hook) = self.object_pairs_hook {
+                // object_pairs_hook takes priority - pass list of tuples
+                let pairs_list: Vec<PyObjectRef> = pairs
+                    .into_iter()
+                    .map(|(k, v)| vm.new_tuple((k, v)).into())
+                    .collect();
+                pairs_hook.call((vm.ctx.new_list(pairs_list),), vm)?
+            } else {
+                // Build a dict from pairs
+                let dict = vm.ctx.new_dict();
+                for (key, value) in pairs {
+                    dict.set_item(&*key, value, vm)?;
+                }
+
+                // Apply object_hook if present
+                let dict_obj: PyObjectRef = dict.into();
+                if let Some(ref hook) = self.object_hook {
+                    hook.call((dict_obj,), vm)?
+                } else {
+                    dict_obj
+                }
+            };
+
+            Ok((result, end_char_idx, end_byte_idx))
+        }
+
+        /// Call scan_once and handle the result.
+        /// Returns (value, end_char_idx, end_byte_idx).
+        fn call_scan_once(
+            &self,
+            scan_once: &PyObjectRef,
+            pystr: PyStrRef,
+            char_idx: usize,
+            byte_idx: usize,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            let s = pystr.as_str();
+            let bytes = s.as_bytes();
+            let wtf8 = pystr.as_wtf8();
+
+            let first_byte = match bytes.get(byte_idx) {
+                Some(&b) => b,
+                None => return Err(self.make_decode_error("Expecting value", pystr, char_idx, vm)),
+            };
+
+            match first_byte {
+                b'"' => {
+                    // String - pass slice starting after the quote
+                    let (wtf8_result, chars_consumed, bytes_consumed) =
+                        machinery::scanstring(&wtf8[byte_idx + 1..], char_idx + 1, self.strict)
+                            .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+                    let py_str = vm.ctx.new_str(wtf8_result.to_string());
+                    Ok((
+                        py_str.into(),
+                        char_idx + 1 + chars_consumed,
+                        byte_idx + 1 + bytes_consumed,
+                    ))
+                }
+                b'{' => {
+                    // Object
+                    self.parse_object(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
+                }
+                b'[' => {
+                    // Array
+                    self.parse_array(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
+                }
+                b'n' if starts_with_bytes(&bytes[byte_idx..], b"null") => {
+                    // null
+                    Ok((vm.ctx.none(), char_idx + 4, byte_idx + 4))
+                }
+                b't' if starts_with_bytes(&bytes[byte_idx..], b"true") => {
+                    // true
+                    Ok((vm.ctx.new_bool(true).into(), char_idx + 4, byte_idx + 4))
+                }
+                b'f' if starts_with_bytes(&bytes[byte_idx..], b"false") => {
+                    // false
+                    Ok((vm.ctx.new_bool(false).into(), char_idx + 5, byte_idx + 5))
+                }
+                b'N' if starts_with_bytes(&bytes[byte_idx..], b"NaN") => {
+                    // NaN
+                    let result = self.parse_constant.call(("NaN",), vm)?;
+                    Ok((result, char_idx + 3, byte_idx + 3))
+                }
+                b'I' if starts_with_bytes(&bytes[byte_idx..], b"Infinity") => {
+                    // Infinity
+                    let result = self.parse_constant.call(("Infinity",), vm)?;
+                    Ok((result, char_idx + 8, byte_idx + 8))
+                }
+                b'-' => {
+                    // -Infinity or negative number
+                    if starts_with_bytes(&bytes[byte_idx..], b"-Infinity") {
+                        let result = self.parse_constant.call(("-Infinity",), vm)?;
+                        return Ok((result, char_idx + 9, byte_idx + 9));
+                    }
+                    // Negative number - numbers are ASCII so len == bytes
+                    if let Some((result, len)) = self.parse_number(&s[byte_idx..], vm) {
+                        return Ok((result?, char_idx + len, byte_idx + len));
+                    }
+                    Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                }
+                b'0'..=b'9' => {
+                    // Positive number - numbers are ASCII so len == bytes
+                    if let Some((result, len)) = self.parse_number(&s[byte_idx..], vm) {
+                        return Ok((result?, char_idx + len, byte_idx + len));
+                    }
+                    Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                }
+                _ => {
+                    // Fall back to scan_once for unrecognized input
+                    // Note: This path requires char_idx for Python compatibility
+                    let result = scan_once.call((pystr.clone(), char_idx as isize), vm);
+
+                    match result {
+                        Ok(tuple) => {
+                            use crate::vm::builtins::PyTupleRef;
+                            let tuple: PyTupleRef = tuple.try_into_value(vm)?;
+                            if tuple.len() != 2 {
+                                return Err(vm.new_value_error("scan_once must return 2-tuple"));
+                            }
+                            let value = tuple.as_slice()[0].clone();
+                            let end_char_idx: isize = tuple.as_slice()[1].try_to_value(vm)?;
+                            // For fallback, we need to calculate byte_idx from char_idx
+                            // This is expensive but fallback should be rare
+                            let end_byte_idx = s
+                                .char_indices()
+                                .nth(end_char_idx as usize)
+                                .map(|(i, _)| i)
+                                .unwrap_or(s.len());
+                            Ok((value, end_char_idx as usize, end_byte_idx))
+                        }
+                        Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
+                            Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                        }
+                        Err(err) => Err(err),
+                    }
+                }
+            }
+        }
+
+        /// Create a decode error.
+        fn make_decode_error(
+            &self,
+            msg: &str,
+            s: PyStrRef,
+            pos: usize,
+            vm: &VirtualMachine,
+        ) -> PyBaseExceptionRef {
+            let err = machinery::DecodeError::new(msg, pos);
+            py_decode_error(err, s, vm)
+        }
     }
 
     impl Callable for JsonScanner {
         type Args = (PyStrRef, isize);
-        fn call(zelf: &Py<Self>, (pystr, idx): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if idx < 0 {
+        fn call(zelf: &Py<Self>, (pystr, char_idx): Self::Args, vm: &VirtualMachine) -> PyResult {
+            if char_idx < 0 {
                 return Err(vm.new_value_error("idx cannot be negative"));
             }
-            let idx = idx as usize;
-            let mut chars = pystr.as_str().chars();
-            if idx > 0 && chars.nth(idx - 1).is_none() {
-                PyIterReturn::StopIteration(Some(vm.ctx.new_int(idx).into())).to_pyresult(vm)
+            let char_idx = char_idx as usize;
+            let s = pystr.as_str();
+
+            // Calculate byte index from char index (O(char_idx) but only at entry point)
+            let byte_idx = if char_idx == 0 {
+                0
             } else {
-                zelf.parse(
-                    chars.as_str(),
-                    pystr.clone(),
-                    idx,
-                    zelf.to_owned().into(),
-                    vm,
-                )
-                .and_then(|x| x.to_pyresult(vm))
-            }
+                match s.char_indices().nth(char_idx) {
+                    Some((byte_i, _)) => byte_i,
+                    None => {
+                        // char_idx is beyond the string length
+                        return PyIterReturn::StopIteration(Some(vm.ctx.new_int(char_idx).into()))
+                            .to_pyresult(vm);
+                    }
+                }
+            };
+
+            zelf.parse(
+                pystr.clone(),
+                char_idx,
+                byte_idx,
+                zelf.to_owned().into(),
+                vm,
+            )
+            .and_then(|x| x.to_pyresult(vm))
         }
     }
 
@@ -257,7 +706,28 @@ mod _json {
         vm: &VirtualMachine,
     ) -> PyResult<(Wtf8Buf, usize)> {
         flame_guard!("_json::scanstring");
-        machinery::scanstring(s.as_wtf8(), end, strict.unwrap_or(true))
-            .map_err(|e| py_decode_error(e, s, vm))
+        let wtf8 = s.as_wtf8();
+
+        // Convert char index `end` to byte index
+        let byte_idx = if end == 0 {
+            0
+        } else {
+            wtf8.code_point_indices()
+                .nth(end)
+                .map(|(i, _)| i)
+                .ok_or_else(|| {
+                    py_decode_error(
+                        machinery::DecodeError::new("Unterminated string starting at", end - 1),
+                        s.clone(),
+                        vm,
+                    )
+                })?
+        };
+
+        let (result, chars_consumed, _bytes_consumed) =
+            machinery::scanstring(&wtf8[byte_idx..], end, strict.unwrap_or(true))
+                .map_err(|e| py_decode_error(e, s, vm))?;
+
+        Ok((result, end + chars_consumed))
     }
 }
diff --git a/crates/stdlib/src/json/machinery.rs b/crates/stdlib/src/json/machinery.rs
index 57b8ae441f7..f33a135ab20 100644
--- a/crates/stdlib/src/json/machinery.rs
+++ b/crates/stdlib/src/json/machinery.rs
@@ -30,6 +30,7 @@
 use std::io;
 
 use itertools::Itertools;
+use memchr::memchr2;
 use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
 static ESCAPE_CHARS: [&str; 0x20] = [
@@ -108,7 +109,7 @@ pub struct DecodeError {
     pub pos: usize,
 }
 impl DecodeError {
-    fn new(msg: impl Into<String>, pos: usize) -> Self {
+    pub fn new(msg: impl Into<String>, pos: usize) -> Self {
         let msg = msg.into();
         Self { msg, pos }
     }
@@ -126,24 +127,63 @@ impl StrOrChar<'_> {
         }
     }
 }
+/// Scan a JSON string starting right after the opening quote.
+///
+/// # Arguments
+/// * `s` - The string slice starting at the first character after the opening `"`
+/// * `char_offset` - The character index where this slice starts (for error messages)
+/// * `strict` - Whether to reject control characters
+///
+/// # Returns
+/// * `Ok((result, chars_consumed, bytes_consumed))` - The decoded string and how much was consumed
+/// * `Err(DecodeError)` - If the string is malformed
 pub fn scanstring<'a>(
     s: &'a Wtf8,
-    end: usize,
+    char_offset: usize,
     strict: bool,
-) -> Result<(Wtf8Buf, usize), DecodeError> {
+) -> Result<(Wtf8Buf, usize, usize), DecodeError> {
+    flame_guard!("machinery::scanstring");
+    let unterminated_err = || DecodeError::new("Unterminated string starting at", char_offset - 1);
+
+    let bytes = s.as_bytes();
+
+    // Fast path: use memchr to find " or \ quickly
+    if let Some(pos) = memchr2(b'"', b'\\', bytes)
+        && bytes[pos] == b'"'
+    {
+        let content_bytes = &bytes[..pos];
+
+        // In strict mode, check for control characters (0x00-0x1F)
+        let has_control_char = strict && content_bytes.iter().any(|&b| b < 0x20);
+
+        if !has_control_char {
+            flame_guard!("machinery::scanstring::fast_path");
+            let result_slice = &s[..pos];
+            let char_count = result_slice.code_points().count();
+            let mut out = Wtf8Buf::with_capacity(pos);
+            out.push_wtf8(result_slice);
+            // +1 for the closing quote
+            return Ok((out, char_count + 1, pos + 1));
+        }
+    }
+
+    // Slow path: chunk-based parsing for strings with escapes or control chars
+    flame_guard!("machinery::scanstring::slow_path");
     let mut chunks: Vec<StrOrChar<'a>> = Vec::new();
     let mut output_len = 0usize;
     let mut push_chunk = |chunk: StrOrChar<'a>| {
         output_len += chunk.len();
         chunks.push(chunk);
     };
-    let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);
-    let mut chars = s.code_point_indices().enumerate().skip(end).peekable();
-    let &(_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
+
+    let mut chars = s.code_point_indices().enumerate().peekable();
+    let mut chunk_start: usize = 0;
+
     while let Some((char_i, (byte_i, c))) = chars.next() {
         match c.to_char_lossy() {
             '"' => {
                 push_chunk(StrOrChar::Str(&s[chunk_start..byte_i]));
+                flame_guard!("machinery::scanstring::assemble_chunks");
                 let mut out = Wtf8Buf::with_capacity(output_len);
                 for x in chunks {
                     match x {
@@ -151,11 +191,12 @@ pub fn scanstring<'a>(
                         StrOrChar::Char(c) => out.push(c),
                     }
                 }
-                return Ok((out, char_i + 1));
+                // +1 for the closing quote
+                return Ok((out, char_i + 1, byte_i + 1));
             }
             '\\' => {
                 push_chunk(StrOrChar::Str(&s[chunk_start..byte_i]));
-                let (_, (_, c)) = chars.next().ok_or_else(unterminated_err)?;
+                let (next_char_i, (_, c)) = chars.next().ok_or_else(unterminated_err)?;
                 let esc = match c.to_char_lossy() {
                     '"' => "\"",
                     '\\' => "\\",
@@ -166,20 +207,21 @@ pub fn scanstring<'a>(
                     'r' => "\r",
                     't' => "\t",
                     'u' => {
-                        let mut uni = decode_unicode(&mut chars, char_i)?;
+                        let mut uni = decode_unicode(&mut chars, char_offset + char_i)?;
                         chunk_start = byte_i + 6;
                         if let Some(lead) = uni.to_lead_surrogate() {
                             // uni is a surrogate -- try to find its pair
                             let mut chars2 = chars.clone();
-                            if let Some(((pos2, _), (_, _))) = chars2
+                            if let Some(((_, (byte_pos2, _)), (_, _))) = chars2
                                 .next_tuple()
                                 .filter(|((_, (_, c1)), (_, (_, c2)))| *c1 == '\\' && *c2 == 'u')
                             {
-                                let uni2 = decode_unicode(&mut chars2, pos2)?;
+                                let uni2 =
+                                    decode_unicode(&mut chars2, char_offset + next_char_i + 1)?;
                                 if let Some(trail) = uni2.to_trail_surrogate() {
                                     // ok, we found what we were looking for -- \uXXXX\uXXXX, both surrogates
                                     uni = lead.merge(trail).into();
-                                    chunk_start = pos2 + 6;
+                                    chunk_start = byte_pos2 + 6;
                                     chars = chars2;
                                 }
                             }
@@ -188,7 +230,10 @@ pub fn scanstring<'a>(
                         continue;
                     }
                     _ => {
-                        return Err(DecodeError::new(format!("Invalid \\escape: {c:?}"), char_i));
+                        return Err(DecodeError::new(
+                            format!("Invalid \\escape: {c:?}"),
+                            char_offset + char_i,
+                        ));
                     }
                 };
                 chunk_start = byte_i + 2;
@@ -197,7 +242,7 @@ pub fn scanstring<'a>(
             '\x00'..='\x1f' if strict => {
                 return Err(DecodeError::new(
                     format!("Invalid control character {c:?} at"),
-                    char_i,
+                    char_offset + char_i,
                 ));
             }
             _ => {}
@@ -211,12 +256,13 @@ fn decode_unicode<I>(it: &mut I, pos: usize) -> Result<CodePoint, DecodeError>
 where
     I: Iterator<Item = (usize, (usize, CodePoint))>,
 {
+    flame_guard!("machinery::decode_unicode");
     let err = || DecodeError::new("Invalid \\uXXXX escape", pos);
-    let mut uni = 0;
-    for x in (0..4).rev() {
+    let mut uni = 0u16;
+    for _ in 0..4 {
         let (_, (_, c)) = it.next().ok_or_else(err)?;
         let d = c.to_char().and_then(|c| c.to_digit(16)).ok_or_else(err)? as u16;
-        uni += d * 16u16.pow(x);
+        uni = (uni << 4) | d;
     }
     Ok(uni.into())
 }

From 609dbb14399804fcc230e7798ed5786c4e6d6c21 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Thu, 15 Jan 2026 07:43:22 -0500
Subject: [PATCH 298/418] Downgraded skips in tests (#6716)

* Downgraded skips in tests

* Fixed failing tests

* Fixed test_ftplib + test_socket + test_ssl + test_threaded_import failures

* Removed comments about which tests are run in which environment

* Addressed PR comments

* Annotated skips on failing tests

* Removed unneeded tests

* Removed unneeded sys import from test_ftplib

* Added annotation to test_ftplib

* Readded skipIf to test_cleanup_with_symlink_modes with a more general ENV_POLLUTING_TESTS_WINDOWS

* Addressed PR comments

* Made changes to minimize diff in PR

* Apply suggestion from @youknowone

---------

Co-authored-by: Jeong, YunWon <69878+youknowone@users.noreply.github.com>
---
 Lib/test/test_ast/test_ast.py                 |  2 +-
 Lib/test/test_bdb.py                          | 68 +++++++++----------
 Lib/test/test_bytes.py                        |  2 -
 Lib/test/test_class.py                        |  1 -
 Lib/test/test_compile.py                      |  1 -
 Lib/test/test_configparser.py                 |  2 +-
 Lib/test/test_context.py                      |  1 -
 Lib/test/test_descr.py                        |  4 +-
 Lib/test/test_docxmlrpc.py                    | 10 +--
 Lib/test/test_enum.py                         | 12 ++--
 Lib/test/test_future_stmt/test_future.py      |  2 +-
 Lib/test/test_http_cookiejar.py               |  1 -
 .../test_importlib/test_threaded_import.py    |  4 +-
 Lib/test/test_io.py                           | 24 -------
 Lib/test/test_itertools.py                    |  1 -
 Lib/test/test_logging.py                      |  2 -
 Lib/test/test_marshal.py                      |  4 +-
 Lib/test/test_signal.py                       |  1 -
 Lib/test/test_socket.py                       | 11 ++-
 Lib/test/test_sort.py                         |  2 +-
 Lib/test/test_sqlite3/test_dbapi.py           |  5 +-
 Lib/test/test_str.py                          |  5 +-
 Lib/test/test_tarfile.py                      |  1 -
 Lib/test/test_thread.py                       |  1 -
 Lib/test/test_threading.py                    |  4 +-
 Lib/test/test_time.py                         |  1 -
 Lib/test/test_timeout.py                      |  1 -
 27 files changed, 66 insertions(+), 107 deletions(-)

diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index 3ff1cea2bf8..57c19477ab6 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -2396,7 +2396,7 @@ def test_stdlib_validates(self):
         ast.MatchMapping([], [], rest="_"),
     ]
 
-    @unittest.skip("TODO: RUSTPYTHON; thread 'main' panicked")
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_match_validation_pattern(self):
         name_x = ast.Name("x", ast.Load())
         for pattern in self._MATCH_PATTERNS:
diff --git a/Lib/test/test_bdb.py b/Lib/test/test_bdb.py
index d1c1c786861..c41fb763a16 100644
--- a/Lib/test/test_bdb.py
+++ b/Lib/test/test_bdb.py
@@ -590,7 +590,7 @@ def fail(self, msg=None):
 class StateTestCase(BaseTestCase):
     """Test the step, next, return, until and quit 'set_' methods."""
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -601,7 +601,7 @@ def test_step(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step_next_on_last_statement(self):
         for set_type in ('step', 'next'):
             with self.subTest(set_type=set_type):
@@ -616,8 +616,7 @@ def test_step_next_on_last_statement(self):
                 with TracerRun(self) as tracer:
                     tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',), ('quit',)]
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',), ('quit',)]
     def test_stepinstr(self):
         self.expect_set = [
             ('line',   2, 'tfunc_main'),  ('stepinstr', ),
@@ -627,7 +626,7 @@ def test_stepinstr(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -639,7 +638,7 @@ def test_next(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_over_import(self):
         code = """
             def main():
@@ -654,7 +653,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_on_plain_statement(self):
         # Check that set_next() is equivalent to set_step() on a plain
         # statement.
@@ -667,7 +666,7 @@ def test_next_on_plain_statement(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_in_caller_frame(self):
         # Check that set_next() in the caller frame causes the tracer
         # to stop next in the caller frame.
@@ -681,7 +680,7 @@ def test_next_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),    ('step', ),
@@ -694,7 +693,7 @@ def test_return(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -706,7 +705,7 @@ def test_return_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -718,7 +717,7 @@ def test_until(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_with_too_large_count(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),               break_in_func('tfunc_first'),
@@ -729,7 +728,7 @@ def test_until_with_too_large_count(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -741,7 +740,7 @@ def test_until_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     @patch_list(sys.meta_path)
     def test_skip(self):
         # Check that tracing is skipped over the import statement in
@@ -775,7 +774,7 @@ def test_skip_with_no_name_module(self):
         bdb = Bdb(skip=['anything*'])
         self.assertIs(bdb.is_skipped_module(None), False)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_down(self):
         # Check that set_down() raises BdbError at the newest frame.
         self.expect_set = [
@@ -784,7 +783,7 @@ def test_down(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_main)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_up(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -798,7 +797,7 @@ def test_up(self):
 class BreakpointTestCase(BaseTestCase):
     """Test the breakpoint set method."""
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_on_non_existent_module(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('break', ('/non/existent/module.py', 1))
@@ -806,7 +805,7 @@ def test_bp_on_non_existent_module(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_after_last_statement(self):
         code = """
             def main():
@@ -820,7 +819,7 @@ def main():
             with TracerRun(self) as tracer:
                 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_temporary_bp(self):
         code = """
             def func():
@@ -844,7 +843,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_disabled_temporary_bp(self):
         code = """
             def func():
@@ -873,7 +872,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_condition(self):
         code = """
             def func(a):
@@ -894,7 +893,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_exception_on_condition_evaluation(self):
         code = """
             def func(a):
@@ -914,7 +913,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_ignore_count(self):
         code = """
             def func():
@@ -936,7 +935,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_ignore_count_on_disabled_bp(self):
         code = """
             def func():
@@ -964,7 +963,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_two_bp_on_same_line(self):
         code = """
             def func():
@@ -990,7 +989,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_at_no_bp(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('clear', (__file__, 1))
@@ -1044,7 +1043,7 @@ def test_load_bps_from_previous_Bdb_instance(self):
 class RunTestCase(BaseTestCase):
     """Test run, runeval and set_trace."""
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_run_step(self):
         # Check that the bdb 'run' method stops at the first line event.
         code = """
@@ -1057,7 +1056,7 @@ def test_run_step(self):
         with TracerRun(self) as tracer:
             tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_runeval_step(self):
         # Test bdb 'runeval'.
         code = """
@@ -1080,7 +1079,7 @@ def main():
 class IssuesTestCase(BaseTestCase):
     """Test fixed bdb issues."""
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step_at_return_with_no_trace_in_caller(self):
         # Issue #13183.
         # Check that the tracer does step into the caller frame when the
@@ -1111,7 +1110,7 @@ def func():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_until_return_in_generator(self):
         # Issue #16596.
         # Check that set_next(), set_until() and set_return() do not treat the
@@ -1153,7 +1152,7 @@ def main():
                     with TracerRun(self) as tracer:
                         tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_for_loop(self):
         # Issue #16596.
         code = """
@@ -1185,7 +1184,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1217,7 +1216,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON; Error in atexit._run_exitfuncs')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1249,8 +1248,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip('TODO: RUSTPYTHON')
-    # AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',)]
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',)]
     def test_next_to_botframe(self):
         # gh-125422
         # Check that next command won't go to the bottom frame.
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 8f01f890309..a1a711da70b 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -2138,7 +2138,6 @@ def test_join(self):
         s3 = s1.join([b"abcd"])
         self.assertIs(type(s3), self.basetype)
 
-    @unittest.skip('TODO: RUSTPYTHON; Fails on ByteArraySubclassWithSlotsTest')
     def test_pickle(self):
         a = self.type2test(b"abcd")
         a.x = 10
@@ -2153,7 +2152,6 @@ def test_pickle(self):
             self.assertEqual(type(a.z), type(b.z))
             self.assertFalse(hasattr(b, 'y'))
 
-    @unittest.skip('TODO: RUSTPYTHON; Fails on ByteArraySubclassWithSlotsTest')
     def test_copy(self):
         a = self.type2test(b"abcd")
         a.x = 10
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index 29215f06002..a70a8078977 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -611,7 +611,6 @@ def assertNotOrderable(self, a, b):
         with self.assertRaises(TypeError):
             a >= b
 
-    @unittest.skip("TODO: RUSTPYTHON; unstable result")
     def testHashComparisonOfMethods(self):
         # Test comparison and hash of methods
         class A:
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 9f6ad6879c0..bbaf3c5c190 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -108,7 +108,6 @@ def __getitem__(self, key):
         exec('z = a', g, d)
         self.assertEqual(d['z'], 12)
 
-    @unittest.skip("TODO: RUSTPYTHON; segmentation fault")
     def test_extended_arg(self):
         # default: 1000 * 2.5 = 2500 repetitions
         repeat = int(sys.getrecursionlimit() * 2.5)
diff --git a/Lib/test/test_configparser.py b/Lib/test/test_configparser.py
index d793cc58907..d95b504f826 100644
--- a/Lib/test/test_configparser.py
+++ b/Lib/test/test_configparser.py
@@ -762,7 +762,7 @@ def test_read_returns_file_list(self):
         parsed_files = cf.read([], encoding="utf-8")
         self.assertEqual(parsed_files, [])
 
-    @unittest.skip("TODO: RUSTPYTHON, suspected to make CI hang")
+    # XXX: RUSTPYTHON; This test might cause CI hang
     def test_read_returns_file_list_with_bytestring_path(self):
         if self.delimiters[0] != '=':
             self.skipTest('incompatible format')
diff --git a/Lib/test/test_context.py b/Lib/test/test_context.py
index 06270e161da..aa83c6bbd71 100644
--- a/Lib/test/test_context.py
+++ b/Lib/test/test_context.py
@@ -358,7 +358,6 @@ def ctx2_fun():
 
         ctx1.run(ctx1_fun)
 
-    @unittest.skip("TODO: RUSTPYTHON; threading is not safe")
     @isolated_context
     @threading_helper.requires_working_threading()
     def test_context_threads_1(self):
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index b3d973237df..7420a49b8f7 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -1834,8 +1834,8 @@ def __init__(self, foo):
         object.__init__(A(3))
         self.assertRaises(TypeError, object.__init__, A(3), 5)
 
-    @unittest.skip('TODO: RUSTPYTHON; This passes, but the `expectedFailure` here is from CPython, so this test is an "UNEXPECTED SUCCESS" (not good)')
-    @unittest.expectedFailure
+    # TODO: RUSTPYTHON; The `expectedFailure` here is from CPython, so this test must fail
+    # @unittest.expectedFailure
     def test_restored_object_new(self):
         class A(object):
             def __new__(cls, *args, **kwargs):
diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
index 3c05412ef57..999533a72a1 100644
--- a/Lib/test/test_docxmlrpc.py
+++ b/Lib/test/test_docxmlrpc.py
@@ -119,7 +119,7 @@ def test_invalid_get_response(self):
 
         response.read()
 
-    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_lambda(self):
         """Test that lambda functionality stays the same.  The output produced
         currently is, I suspect invalid because of the unencoded brackets in the
@@ -160,9 +160,9 @@ def test_autolinking(self):
              b'auto-linked,&nbsp;too:<br>\n<a href="http://google.com">'
              b'http://google.com</a>.</tt></dd></dl>'), response)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     @make_request_and_skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
-    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
     def test_system_methods(self):
         """Test the presence of three consecutive system.* methods.
 
@@ -190,7 +190,7 @@ def test_system_methods(self):
              b'<br>\nThis&nbsp;server&nbsp;does&nbsp;NOT&nbsp;support&nbsp;system'
              b'.methodSignature.</tt></dd></dl>'), response)
 
-    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_autolink_dotted_methods(self):
         """Test that selfdot values are made strong automatically in the
         documentation."""
@@ -200,7 +200,7 @@ def test_autolink_dotted_methods(self):
         self.assertIn(b"""Try&nbsp;self.<strong>add</strong>,&nbsp;too.""",
                       response.read())
 
-    @unittest.skip('TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_annotations(self):
         """ Test that annotations works as expected """
         self.client.request("GET", "/")
@@ -214,7 +214,7 @@ def test_annotations(self):
              b'method_annotation</strong></a>(x: bytes)</dt></dl>'),
             response.read())
 
-    @unittest.skip('TODO: RUSTPYTHON; TypeError: HTMLDoc.heading() missing 2 required positional arguments: "fgcol" and "bgcol"')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: HTMLDoc.heading() missing 2 required positional arguments: "fgcol" and "bgcol"
     def test_server_title_escape(self):
         # bpo-38243: Ensure that the server title and documentation
         # are escaped for HTML.
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index b9d9cf33e35..5a961711cce 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -445,7 +445,7 @@ def spam(cls):
         with self.assertRaises(AttributeError):
             del Season.SPRING.name
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance failed in 'BadSuper'
     def test_bad_new_super(self):
         with self.assertRaisesRegex(
@@ -1923,7 +1923,7 @@ def test_wrong_inheritance_order(self):
             class Wrong(Enum, str):
                 NotHere = 'error before this point'
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance INVALID in 'RgbColor'
     def test_raise_custom_error_on_creation(self):
         class InvalidRgbColorError(ValueError):
@@ -2613,7 +2613,7 @@ class Test(Base2):
         self.assertEqual(Test.flash.flash, 'flashy dynamic')
         self.assertEqual(Test.flash.value, 1)
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance grene in 'Color'
     def test_no_duplicates(self):
         class UniqueEnum(Enum):
@@ -3000,7 +3000,7 @@ def test_empty_globals(self):
         local_ls = {}
         exec(code, global_ns, local_ls)
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance one in 'FirstFailedStrEnum'
     def test_strenum(self):
         class GoodStrEnum(StrEnum):
@@ -3126,7 +3126,7 @@ class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance key_type in 'Combined'
     def test_missing_value_error(self):
         with self.assertRaisesRegex(TypeError, "_value_ not set in __new__"):
@@ -3414,7 +3414,7 @@ def __new__(cls, c):
         self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
         self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # RuntimeError: Error calling __set_name__ on '_proto_member' instance A in 'MyEnum'
     def test_init_exception(self):
         class Base:
diff --git a/Lib/test/test_future_stmt/test_future.py b/Lib/test/test_future_stmt/test_future.py
index a7d649b32a6..febd9fb095a 100644
--- a/Lib/test/test_future_stmt/test_future.py
+++ b/Lib/test/test_future_stmt/test_future.py
@@ -195,7 +195,7 @@ def test_syntactical_future_repl(self):
         out = kill_python(p)
         self.assertNotIn(b'SyntaxError: invalid syntax', out)
 
-    @unittest.skip('TODO: RUSTPYTHON')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     # SyntaxError: future feature spam is not defined
     def test_future_dotted_import(self):
         with self.assertRaises(ImportError):
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index f4b9dc6a282..68a693c78b3 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -125,7 +125,6 @@ def test_http2time_garbage(self):
                               "http2time(%s) is not None\n"
                               "http2time(test) %s" % (test, http2time(test)))
 
-    @unittest.skip("TODO: RUSTPYTHON, regressed to cubic complexity")
     def test_http2time_redos_regression_actually_completes(self):
         # LOOSE_HTTP_DATE_RE was vulnerable to malicious input which caused catastrophic backtracking (REDoS).
         # If we regress to cubic complexity, this test will take a very long time to succeed.
diff --git a/Lib/test/test_importlib/test_threaded_import.py b/Lib/test/test_importlib/test_threaded_import.py
index 3ceb86cbea3..f624e7d2c8d 100644
--- a/Lib/test/test_importlib/test_threaded_import.py
+++ b/Lib/test/test_importlib/test_threaded_import.py
@@ -249,14 +249,14 @@ def target():
             __import__(TESTFN)
         del sys.modules[TESTFN]
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
+    @unittest.skip('TODO: RUSTPYTHON; hang; Suspected cause of crashes in Windows CI - PermissionError: [WinError 32] Permission denied: "C:\\Users\\RUNNER~1\\AppData\\Local\\Temp\\test_python_0cdrhhs_\\test_python_6340æ"')
     def test_concurrent_futures_circular_import(self):
         # Regression test for bpo-43515
         fn = os.path.join(os.path.dirname(__file__),
                           'partial', 'cfimport.py')
         script_helper.assert_python_ok(fn)
 
-    @unittest.skip("TODO: RUSTPYTHON - fails on Linux due to multiprocessing issues")
+    @unittest.skip('TODO: RUSTPYTHON; hang')
     def test_multiprocessing_pool_circular_import(self):
         # Regression test for bpo-41567
         fn = os.path.join(os.path.dirname(__file__),
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 3c507c30492..741920a5864 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -1843,13 +1843,6 @@ def test_bad_readinto_type(self):
     def test_error_through_destructor(self):
         return super().test_error_through_destructor()
 
-    def test_truncate_on_read_only(self):
-        return super().test_truncate_on_read_only()
-
-    @unittest.skip('TODO: RUSTPYTHON; fallible allocation')
-    def test_constructor(self):
-        return super().test_constructor()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickling_subclass(self):
         return super().test_pickling_subclass()
@@ -2196,10 +2189,6 @@ def test_args_error(self):
     def test_error_through_destructor(self):
         return super().test_error_through_destructor()
 
-    @unittest.skip('TODO: RUSTPYTHON; fallible allocation')
-    def test_constructor(self):
-        return super().test_constructor()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickling_subclass(self):
         return super().test_pickling_subclass()
@@ -2695,10 +2684,6 @@ def test_args_error(self):
     def test_error_through_destructor(self):
         return super().test_error_through_destructor()
 
-    @unittest.skip('TODO: RUSTPYTHON; fallible allocation')
-    def test_constructor(self):
-        return super().test_constructor()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickling_subclass(self):
         return super().test_pickling_subclass()
@@ -4222,16 +4207,10 @@ def write(self, data):
         self.assertEqual([b"abcdef", b"middle", b"g"*chunk_size],
                          buf._write_stack)
 
-    def test_basic_io(self):
-        return super().test_basic_io()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_constructor(self):
         return super().test_constructor()
 
-    def test_detach(self):
-        return super().test_detach()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newlines(self):
         return super().test_newlines()
@@ -4288,9 +4267,6 @@ def test_error_through_destructor(self):
     def test_repr(self):
         return super().test_repr()
 
-    def test_uninitialized(self):
-        return super().test_uninitialized()
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_recursive_repr(self):
         return super().test_recursive_repr()
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 03dadb71f78..1c0c38ee042 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -1807,7 +1807,6 @@ def __next__(self):
         with self.assertRaisesRegex(RuntimeError, "tee"):
             next(a)
 
-    @unittest.skip("TODO: RUSTPYTHON; , hangs")
     @threading_helper.requires_working_threading()
     def test_tee_concurrent(self):
         start = threading.Event()
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 752054b7290..8ea77d186e4 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -1115,7 +1115,6 @@ class SMTPHandlerTest(BaseTest):
     # bpo-14314, bpo-19665, bpo-34092: don't wait forever
     TIMEOUT = support.LONG_TIMEOUT
 
-    @unittest.skip("TODO: RUSTPYTHON; hangs")
     def test_basic(self):
         sockmap = {}
         server = TestSMTPServer((socket_helper.HOST, 0), self.process_message, 0.001,
@@ -2153,7 +2152,6 @@ def handle_request(self, request):
         request.end_headers()
         self.handled.set()
 
-    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_output(self):
         # The log message sent to the HTTPHandler is properly received.
         logger = logging.getLogger("http")
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 2161e06b2f2..142b45f6a46 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -35,7 +35,7 @@ def test_ints(self):
                 self.helper(expected)
             n = n >> 1
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_int64(self):
         # Simulate int marshaling with TYPE_INT64.
         maxint64 = (1 << 63) - 1
@@ -232,7 +232,7 @@ def check(s):
             self.assertRaises(ValueError, marshal.loads, s)
         run_tests(2**20, check)
 
-    @unittest.skip("TODO: RUSTPYTHON; segfault")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; segfault
     def test_recursion_limit(self):
         # Create a deeply nested structure.
         head = last = []
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index 578bee3172a..2c5cec803d0 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -1351,7 +1351,6 @@ def handler(signum, frame):
         # Python handler
         self.assertEqual(len(sigs), N, "Some signals were lost")
 
-    @unittest.skip('TODO: RUSTPYTHON; hang')
     @unittest.skipIf(is_apple, "crashes due to system bug (FB13453490)")
     @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
                          "test needs SIGUSR1")
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index 08d3dcb5792..57539a3862a 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -6842,7 +6842,6 @@ def test_errors(self):
 
 @unittest.skipUnless(hasattr(os, "sendfile"),
                      'os.sendfile() required for this test.')
-@unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly")
 class SendfileUsingSendfileTest(SendfileUsingSendTest):
     """
     Test the sendfile() implementation of socket.sendfile().
@@ -6850,6 +6849,13 @@ class SendfileUsingSendfileTest(SendfileUsingSendTest):
     def meth_from_sock(self, sock):
         return getattr(sock, "_sendfile_use_sendfile")
 
+    @unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly; flaky")
+    def testWithTimeout(self):
+        super().testWithTimeout()
+
+    @unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly; flaky")
+    def testCount(self):
+        super().testCount()
 
 @unittest.skipUnless(HAVE_SOCKET_ALG, 'AF_ALG required')
 class LinuxKernelCryptoAPI(unittest.TestCase):
@@ -6867,8 +6873,7 @@ def create_alg(self, typ, name):
 
     # bpo-31705: On kernel older than 4.5, sendto() failed with ENOKEY,
     # at least on ppc64le architecture
-    # TODO: RUSTPYTHON - AF_ALG not fully implemented
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON - AF_ALG not fully implemented
     @support.requires_linux_version(4, 5)
     def test_sha256(self):
         expected = bytes.fromhex("ba7816bf8f01cfea414140de5dae2223b00361a396"
diff --git a/Lib/test/test_sort.py b/Lib/test/test_sort.py
index be3d4a8461f..37ce489b79f 100644
--- a/Lib/test/test_sort.py
+++ b/Lib/test/test_sort.py
@@ -149,7 +149,7 @@ def __lt__(self, other):
         L = [C() for i in range(50)]
         self.assertRaises(ValueError, L.sort)
 
-    @unittest.skip("TODO: RUSTPYTHON; figure out how to detect sort mutation that doesn't change list length")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; figure out how to detect sort mutation that doesn't change list length
     def test_undetected_mutation(self):
         # Python 2.4a1 did not always detect mutation
         memorywaster = []
diff --git a/Lib/test/test_sqlite3/test_dbapi.py b/Lib/test/test_sqlite3/test_dbapi.py
index 9a95c489a31..a3ddd660ccb 100644
--- a/Lib/test/test_sqlite3/test_dbapi.py
+++ b/Lib/test/test_sqlite3/test_dbapi.py
@@ -545,9 +545,6 @@ def test_connection_init_good_isolation_levels(self):
                     cx.isolation_level = level
                     self.assertEqual(cx.isolation_level, level)
 
-    # TODO: RUSTPYTHON
-    # @unittest.expectedFailure
-    @unittest.skip("TODO: RUSTPYTHON deadlock")
     def test_connection_reinit(self):
         db = ":memory:"
         cx = sqlite.connect(db)
@@ -587,11 +584,11 @@ def test_connection_bad_reinit(self):
                                    ((v,) for v in range(3)))
 
 
-@unittest.skip("TODO: RUSTPYTHON")
 class UninitialisedConnectionTests(unittest.TestCase):
     def setUp(self):
         self.cx = sqlite.Connection.__new__(sqlite.Connection)
 
+    @unittest.skip('TODO: RUSTPYTHON')
     def test_uninit_operations(self):
         funcs = (
             lambda: self.cx.isolation_level,
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
index 9d43a33cd9e..6b766272a3f 100644
--- a/Lib/test/test_str.py
+++ b/Lib/test/test_str.py
@@ -565,7 +565,6 @@ def __str__(self): return self.sval
         self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
         self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
 
-    @unittest.skip('TODO: RUSTPYTHON; oom handling')
     @unittest.skipIf(sys.maxsize > 2**32,
         'needs too much memory on a 64-bit platform')
     def test_join_overflow(self):
@@ -1460,7 +1459,6 @@ def __getitem__(self, key):
         self.assertRaises(TypeError, '{a}'.format_map, [])
         self.assertRaises(ZeroDivisionError, '{a}'.format_map, BadMapping())
 
-    @unittest.skip('TODO: RUSTPYTHON; killed for chewing up RAM')
     def test_format_huge_precision(self):
         format_string = ".{}f".format(sys.maxsize + 1)
         with self.assertRaises(ValueError):
@@ -2468,7 +2466,6 @@ def test_printable_repr(self):
     # This test only affects 32-bit platforms because expandtabs can only take
     # an int as the max value, not a 64-bit C long.  If expandtabs is changed
     # to take a 64-bit long, this test should apply to all platforms.
-    @unittest.skip('TODO: RUSTPYTHON; oom handling')
     @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
                      'only applies to 32-bit platforms')
     def test_expandtabs_overflows_gracefully(self):
@@ -2479,7 +2476,7 @@ def test_expandtabs_optimization(self):
         s = 'abc'
         self.assertIs(s.expandtabs(), s)
 
-    @unittest.skip('TODO: RUSTPYTHON; aborted: memory allocation of 9223372036854775759 bytes failed')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raiseMemError(self):
         asciifields = "nnb"
         compactfields = asciifields + "nP"
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index d29c6918234..92ce7c32a00 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -456,7 +456,6 @@ def test_premature_end_of_archive(self):
                 with self.assertRaisesRegex(tarfile.ReadError, "unexpected end of data"):
                     tar.extractfile(t).read()
 
-    @unittest.skip("TODO: RUSTPYTHON, infinite recursion")
     def test_length_zero_header(self):
         # bpo-39017 (CVE-2019-20907): reading a zero-length header should fail
         # with an exception
diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py
index f55cf3656ea..4ae8a833b99 100644
--- a/Lib/test/test_thread.py
+++ b/Lib/test/test_thread.py
@@ -105,7 +105,6 @@ def test_nt_and_posix_stack_size(self):
 
         thread.stack_size(0)
 
-    @unittest.skip("TODO: RUSTPYTHON, weakref destructors")
     def test__count(self):
         # Test the _count() function.
         orig = thread._count()
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 910797afa8f..e635a6f9734 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -319,7 +319,7 @@ def f(mutex):
 
     # PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
     # exposed at the Python level.  This test relies on ctypes to get at it.
-    @unittest.skip('TODO: RUSTPYTHON; expects @cpython_only')
+    @cpython_only
     def test_PyThreadState_SetAsyncExc(self):
         ctypes = import_module("ctypes")
 
@@ -424,7 +424,7 @@ def fail_new_thread(*args, **kwargs):
         finally:
             threading._start_joinable_thread = _start_joinable_thread
 
-    @unittest.skip('TODO: RUSTPYTHON; ctypes.pythonapi is not supported')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ctypes.pythonapi is not supported
     def test_finalize_running_thread(self):
         # Issue 1402: the PyGILState_Ensure / _Release functions may be called
         # very late on python exit: on deallocation of a running thread for
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 31a2a920d9e..df3a72e302a 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -622,7 +622,6 @@ def test_large_year(self):
         self.assertEqual(self.yearstr(12345), '12345')
         self.assertEqual(self.yearstr(123456789), '123456789')
 
-@unittest.skip("TODO: RUSTPYTHON, ValueError: invalid struct_time parameter")
 class _TestStrftimeYear:
 
     # Issue 13305:  For years < 1000, the value is not always
diff --git a/Lib/test/test_timeout.py b/Lib/test/test_timeout.py
index f40c7ee48b0..70a0175d771 100644
--- a/Lib/test/test_timeout.py
+++ b/Lib/test/test_timeout.py
@@ -71,7 +71,6 @@ def testTypeCheck(self):
         self.assertRaises(TypeError, self.sock.settimeout, {})
         self.assertRaises(TypeError, self.sock.settimeout, 0j)
 
-    @unittest.skip("TODO: RUSTPYTHON; crash")
     def testRangeCheck(self):
         # Test range checking by settimeout()
         self.assertRaises(ValueError, self.sock.settimeout, -1)

From a0ace054f32d7695f0e9bf5a773cda0b998b495e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 16 Jan 2026 09:12:16 +0900
Subject: [PATCH 299/418] Fix asyncio compile (#6739)

---
 crates/codegen/src/compile.rs | 45 ++++++++++++++++++++++++-----------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 0f52a519f22..0480f94b678 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -2547,18 +2547,28 @@ impl Compiler {
                     )?;
                 }
                 self.compile_statements(finalbody)?;
-                // RERAISE 0 is emitted BEFORE pop_fblock
-                // This ensures RERAISE goes to cleanup block (FinallyEnd handler)
-                // which then properly restores prev_exc before going to outer handler
+
+                // Pop FinallyEnd fblock BEFORE emitting RERAISE
+                // This ensures RERAISE routes to outer exception handler, not cleanup block
+                // Cleanup block is only for new exceptions raised during finally body execution
+                if finally_cleanup_block.is_some() {
+                    self.pop_fblock(FBlockType::FinallyEnd);
+                }
+
+                // Restore prev_exc as current exception before RERAISE
+                // Stack: [prev_exc, exc] -> COPY 2 -> [prev_exc, exc, prev_exc]
+                // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
+                // Stack after POP_EXCEPT: [prev_exc, exc]
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::PopExcept);
+
+                // RERAISE 0: re-raise the original exception to outer handler
                 emit!(
                     self,
                     Instruction::RaiseVarargs {
                         kind: bytecode::RaiseKind::ReraiseFromStack
                     }
                 );
-                if finally_cleanup_block.is_some() {
-                    self.pop_fblock(FBlockType::FinallyEnd);
-                }
             }
 
             if let Some(cleanup) = finally_cleanup_block {
@@ -2837,10 +2847,21 @@ impl Compiler {
             // Run finally body
             self.compile_statements(finalbody)?;
 
-            // RERAISE 0 is emitted BEFORE pop_fblock
-            // This ensures RERAISE goes to cleanup block (FinallyEnd handler)
-            // which then properly restores prev_exc before going to outer handler
-            // RERAISE 0: reraise the exception on TOS
+            // Pop FinallyEnd fblock BEFORE emitting RERAISE
+            // This ensures RERAISE routes to outer exception handler, not cleanup block
+            // Cleanup block is only for new exceptions raised during finally body execution
+            if finally_cleanup_block.is_some() {
+                self.pop_fblock(FBlockType::FinallyEnd);
+            }
+
+            // Restore prev_exc as current exception before RERAISE
+            // Stack: [lasti, prev_exc, exc] -> COPY 2 -> [lasti, prev_exc, exc, prev_exc]
+            // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
+            // Stack after POP_EXCEPT: [lasti, prev_exc, exc]
+            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::PopExcept);
+
+            // RERAISE 0: re-raise the original exception to outer handler
             // Stack: [lasti, prev_exc, exc] - exception is on top
             emit!(
                 self,
@@ -2848,10 +2869,6 @@ impl Compiler {
                     kind: bytecode::RaiseKind::ReraiseFromStack,
                 }
             );
-
-            if finally_cleanup_block.is_some() {
-                self.pop_fblock(FBlockType::FinallyEnd);
-            }
         }
 
         // finally cleanup block

From 746e71af8796f1ec897978e7e8439e518c82cde5 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Fri, 16 Jan 2026 10:18:31 +0900
Subject: [PATCH 300/418] reject SemLock reduce (#6738)

---
 Lib/test/test_concurrent_futures/test_process_pool.py | 8 --------
 crates/stdlib/src/multiprocessing.rs                  | 7 +++++++
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
index 9d3c771eaeb..5d4e9677f5c 100644
--- a/Lib/test/test_concurrent_futures/test_process_pool.py
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -228,13 +228,5 @@ def mock_start_new_thread(func, *args, **kwargs):
 def setUpModule():
     setup_module()
 
-class ProcessPoolSpawnProcessPoolExecutorTest(ProcessPoolSpawnProcessPoolExecutorTest):  # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
-    def test_saturation(self): super().test_saturation()  # TODO: RUSTPYTHON
-
-class ProcessPoolForkProcessPoolExecutorTest(ProcessPoolForkProcessPoolExecutorTest):  # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
-    def test_ressources_gced_in_workers(self): super().test_ressources_gced_in_workers()  # TODO: RUSTPYTHON
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
index 21b7bfa85c7..bda13e6191a 100644
--- a/crates/stdlib/src/multiprocessing.rs
+++ b/crates/stdlib/src/multiprocessing.rs
@@ -547,6 +547,13 @@ mod _multiprocessing {
             self.last_tid.store(0, Ordering::Release);
         }
 
+        /// SemLock objects cannot be pickled directly.
+        /// Use multiprocessing.synchronize.SemLock wrapper which handles pickling.
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle 'SemLock' object".to_owned()))
+        }
+
         /// Num of `acquire()`s minus num of `release()`s for this process.
         // _multiprocessing_SemLock__count_impl
         #[pymethod]

From ef871d227e3b61421fc2b5d731ced70b77cc23be Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Fri, 16 Jan 2026 21:38:15 +0900
Subject: [PATCH 301/418] Update json module to 3.13.11 (#6743)

---
 Lib/json/__init__.py                          | 52 +++++++++++--------
 Lib/json/decoder.py                           |  8 +--
 Lib/json/encoder.py                           | 20 +++----
 .../test_json/test_encode_basestring_ascii.py |  3 +-
 Lib/test/test_json/test_scanstring.py         |  3 +-
 Lib/test/test_json/test_unicode.py            | 52 ++++++++++++++++++-
 6 files changed, 98 insertions(+), 40 deletions(-)

diff --git a/Lib/json/__init__.py b/Lib/json/__init__.py
index ed2c74771ea..c7a6dcdf77e 100644
--- a/Lib/json/__init__.py
+++ b/Lib/json/__init__.py
@@ -128,8 +128,9 @@ def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     instead of raising a ``TypeError``.
 
     If ``ensure_ascii`` is false, then the strings written to ``fp`` can
-    contain non-ASCII characters if they appear in strings contained in
-    ``obj``. Otherwise, all such characters are escaped in JSON strings.
+    contain non-ASCII and non-printable characters if they appear in strings
+    contained in ``obj``. Otherwise, all such characters are escaped in JSON
+    strings.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will
@@ -145,10 +146,11 @@ def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     level of 0 will only insert newlines. ``None`` is the most compact
     representation.
 
-    If specified, ``separators`` should be an ``(item_separator, key_separator)``
-    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
-    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
-    you should specify ``(',', ':')`` to eliminate whitespace.
+    If specified, ``separators`` should be an ``(item_separator,
+    key_separator)`` tuple.  The default is ``(', ', ': ')`` if *indent* is
+    ``None`` and ``(',', ': ')`` otherwise.  To get the most compact JSON
+    representation, you should specify ``(',', ':')`` to eliminate
+    whitespace.
 
     ``default(obj)`` is a function that should return a serializable version
     of obj or raise TypeError. The default simply raises TypeError.
@@ -189,9 +191,10 @@ def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
     instead of raising a ``TypeError``.
 
-    If ``ensure_ascii`` is false, then the return value can contain non-ASCII
-    characters if they appear in strings contained in ``obj``. Otherwise, all
-    such characters are escaped in JSON strings.
+    If ``ensure_ascii`` is false, then the return value can contain
+    non-ASCII and non-printable characters if they appear in strings
+    contained in ``obj``.  Otherwise, all such characters are escaped in
+    JSON strings.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will
@@ -207,10 +210,11 @@ def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     level of 0 will only insert newlines. ``None`` is the most compact
     representation.
 
-    If specified, ``separators`` should be an ``(item_separator, key_separator)``
-    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
-    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
-    you should specify ``(',', ':')`` to eliminate whitespace.
+    If specified, ``separators`` should be an ``(item_separator,
+    key_separator)`` tuple.  The default is ``(', ', ': ')`` if *indent* is
+    ``None`` and ``(',', ': ')`` otherwise.  To get the most compact JSON
+    representation, you should specify ``(',', ':')`` to eliminate
+    whitespace.
 
     ``default(obj)`` is a function that should return a serializable version
     of obj or raise TypeError. The default simply raises TypeError.
@@ -281,11 +285,12 @@ def load(fp, *, cls=None, object_hook=None, parse_float=None,
     ``object_hook`` will be used instead of the ``dict``. This feature
     can be used to implement custom decoders (e.g. JSON-RPC class hinting).
 
-    ``object_pairs_hook`` is an optional function that will be called with the
-    result of any object literal decoded with an ordered list of pairs.  The
-    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
-    This feature can be used to implement custom decoders.  If ``object_hook``
-    is also defined, the ``object_pairs_hook`` takes priority.
+    ``object_pairs_hook`` is an optional function that will be called with
+    the result of any object literal decoded with an ordered list of pairs.
+    The return value of ``object_pairs_hook`` will be used instead of the
+    ``dict``.  This feature can be used to implement custom decoders.  If
+    ``object_hook`` is also defined, the ``object_pairs_hook`` takes
+    priority.
 
     To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
     kwarg; otherwise ``JSONDecoder`` is used.
@@ -306,11 +311,12 @@ def loads(s, *, cls=None, object_hook=None, parse_float=None,
     ``object_hook`` will be used instead of the ``dict``. This feature
     can be used to implement custom decoders (e.g. JSON-RPC class hinting).
 
-    ``object_pairs_hook`` is an optional function that will be called with the
-    result of any object literal decoded with an ordered list of pairs.  The
-    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
-    This feature can be used to implement custom decoders.  If ``object_hook``
-    is also defined, the ``object_pairs_hook`` takes priority.
+    ``object_pairs_hook`` is an optional function that will be called with
+    the result of any object literal decoded with an ordered list of pairs.
+    The return value of ``object_pairs_hook`` will be used instead of the
+    ``dict``.  This feature can be used to implement custom decoders.  If
+    ``object_hook`` is also defined, the ``object_pairs_hook`` takes
+    priority.
 
     ``parse_float``, if specified, will be called with the string
     of every JSON float to be decoded. By default this is equivalent to
diff --git a/Lib/json/decoder.py b/Lib/json/decoder.py
index 9e6ca981d76..db87724a897 100644
--- a/Lib/json/decoder.py
+++ b/Lib/json/decoder.py
@@ -311,10 +311,10 @@ def __init__(self, *, object_hook=None, parse_float=None,
         place of the given ``dict``.  This can be used to provide custom
         deserializations (e.g. to support JSON-RPC class hinting).
 
-        ``object_pairs_hook``, if specified will be called with the result of
-        every JSON object decoded with an ordered list of pairs.  The return
-        value of ``object_pairs_hook`` will be used instead of the ``dict``.
-        This feature can be used to implement custom decoders.
+        ``object_pairs_hook``, if specified will be called with the result
+        of every JSON object decoded with an ordered list of pairs.  The
+        return value of ``object_pairs_hook`` will be used instead of the
+        ``dict``.  This feature can be used to implement custom decoders.
         If ``object_hook`` is also defined, the ``object_pairs_hook`` takes
         priority.
 
diff --git a/Lib/json/encoder.py b/Lib/json/encoder.py
index 08ef39d1592..0671500d106 100644
--- a/Lib/json/encoder.py
+++ b/Lib/json/encoder.py
@@ -111,9 +111,10 @@ def __init__(self, *, skipkeys=False, ensure_ascii=True,
         encoding of keys that are not str, int, float, bool or None.
         If skipkeys is True, such items are simply skipped.
 
-        If ensure_ascii is true, the output is guaranteed to be str
-        objects with all incoming non-ASCII characters escaped.  If
-        ensure_ascii is false, the output can contain non-ASCII characters.
+        If ensure_ascii is true, the output is guaranteed to be str objects
+        with all incoming non-ASCII and non-printable characters escaped.
+        If ensure_ascii is false, the output can contain non-ASCII and
+        non-printable characters.
 
         If check_circular is true, then lists, dicts, and custom encoded
         objects will be checked for circular references during encoding to
@@ -134,14 +135,15 @@ def __init__(self, *, skipkeys=False, ensure_ascii=True,
         indent level.  An indent level of 0 will only insert newlines.
         None is the most compact representation.
 
-        If specified, separators should be an (item_separator, key_separator)
-        tuple.  The default is (', ', ': ') if *indent* is ``None`` and
-        (',', ': ') otherwise.  To get the most compact JSON representation,
-        you should specify (',', ':') to eliminate whitespace.
+        If specified, separators should be an (item_separator,
+        key_separator) tuple.  The default is (', ', ': ') if *indent* is
+        ``None`` and (',', ': ') otherwise.  To get the most compact JSON
+        representation, you should specify (',', ':') to eliminate
+        whitespace.
 
         If specified, default is a function that gets called for objects
-        that can't otherwise be serialized.  It should return a JSON encodable
-        version of the object or raise a ``TypeError``.
+        that can't otherwise be serialized.  It should return a JSON
+        encodable version of the object or raise a ``TypeError``.
 
         """
 
diff --git a/Lib/test/test_json/test_encode_basestring_ascii.py b/Lib/test/test_json/test_encode_basestring_ascii.py
index 6a39b72a09d..c90d3e968e5 100644
--- a/Lib/test/test_json/test_encode_basestring_ascii.py
+++ b/Lib/test/test_json/test_encode_basestring_ascii.py
@@ -8,13 +8,12 @@
     ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
     ('controls', '"controls"'),
     ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    ('\x00\x1f\x7f', '"\\u0000\\u001f\\u007f"'),
     ('{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
     (' s p a c e d ', '" s p a c e d "'),
     ('\U0001d120', '"\\ud834\\udd20"'),
     ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
     ("`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
 ]
 
 class TestEncodeBasestringAscii:
diff --git a/Lib/test/test_json/test_scanstring.py b/Lib/test/test_json/test_scanstring.py
index a5c46bb64b4..d6922c3b1b9 100644
--- a/Lib/test/test_json/test_scanstring.py
+++ b/Lib/test/test_json/test_scanstring.py
@@ -3,6 +3,7 @@
 
 import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
 
+
 class TestScanstring:
     def test_scanstring(self):
         scanstring = self.json.decoder.scanstring
@@ -147,7 +148,7 @@ def test_bad_escapes(self):
     @unittest.expectedFailure
     def test_overflow(self):
         with self.assertRaises(OverflowError):
-            self.json.decoder.scanstring(b"xxx", sys.maxsize+1)
+            self.json.decoder.scanstring("xxx", sys.maxsize+1)
 
 
 class TestPyScanstring(TestScanstring, PyTest): pass
diff --git a/Lib/test/test_json/test_unicode.py b/Lib/test/test_json/test_unicode.py
index 4bdb607e7da..be0ac8823d5 100644
--- a/Lib/test/test_json/test_unicode.py
+++ b/Lib/test/test_json/test_unicode.py
@@ -34,6 +34,29 @@ def test_encoding7(self):
         j = self.dumps(u + "\n", ensure_ascii=False)
         self.assertEqual(j, f'"{u}\\n"')
 
+    def test_ascii_non_printable_encode(self):
+        u = '\b\t\n\f\r\x00\x1f\x7f'
+        self.assertEqual(self.dumps(u),
+                         '"\\b\\t\\n\\f\\r\\u0000\\u001f\\u007f"')
+        self.assertEqual(self.dumps(u, ensure_ascii=False),
+                         '"\\b\\t\\n\\f\\r\\u0000\\u001f\x7f"')
+
+    def test_ascii_non_printable_decode(self):
+        self.assertEqual(self.loads('"\\b\\t\\n\\f\\r"'),
+                         '\b\t\n\f\r')
+        s = ''.join(map(chr, range(32)))
+        for c in s:
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"{c}"')
+        self.assertEqual(self.loads(f'"{s}"', strict=False), s)
+        self.assertEqual(self.loads('"\x7f"'), '\x7f')
+
+    def test_escaped_decode(self):
+        self.assertEqual(self.loads('"\\b\\t\\n\\f\\r"'), '\b\t\n\f\r')
+        self.assertEqual(self.loads('"\\"\\\\\\/"'), '"\\/')
+        for c in set(map(chr, range(0x100))) - set('"\\/bfnrt'):
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"\\{c}"')
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"\\{c}"', strict=False)
+
     def test_big_unicode_encode(self):
         u = '\U0001d120'
         self.assertEqual(self.dumps(u), '"\\ud834\\udd20"')
@@ -50,6 +73,18 @@ def test_unicode_decode(self):
             s = f'"\\u{i:04x}"'
             self.assertEqual(self.loads(s), u)
 
+    def test_single_surrogate_encode(self):
+        self.assertEqual(self.dumps('\uD83D'), '"\\ud83d"')
+        self.assertEqual(self.dumps('\uD83D', ensure_ascii=False), '"\ud83d"')
+        self.assertEqual(self.dumps('\uDC0D'), '"\\udc0d"')
+        self.assertEqual(self.dumps('\uDC0D', ensure_ascii=False), '"\udc0d"')
+
+    def test_single_surrogate_decode(self):
+        self.assertEqual(self.loads('"\uD83D"'), '\ud83d')
+        self.assertEqual(self.loads('"\\uD83D"'), '\ud83d')
+        self.assertEqual(self.loads('"\udc0d"'), '\udc0d')
+        self.assertEqual(self.loads('"\\udc0d"'), '\udc0d')
+
     def test_unicode_preservation(self):
         self.assertEqual(type(self.loads('""')), str)
         self.assertEqual(type(self.loads('"a"')), str)
@@ -104,4 +139,19 @@ def test_object_pairs_hook_with_unicode(self):
 
 
 class TestPyUnicode(TestUnicode, PyTest): pass
-class TestCUnicode(TestUnicode, CTest): pass
+
+class TestCUnicode(TestUnicode, CTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_ascii_non_printable_encode(self):
+        return super().test_ascii_non_printable_encode()
+
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; panics with 'str has surrogates'")
+    def test_single_surrogate_decode(self):
+        return super().test_single_surrogate_decode()
+
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; panics with 'str has surrogates'")
+    def test_single_surrogate_encode(self):
+        return super().test_single_surrogate_encode()

From 4cb3b9d8f02eb301e761ace2f7300d976b6cb529 Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Fri, 16 Jan 2026 09:03:49 -0500
Subject: [PATCH 302/418] Updated the urllib + http libraries + test libraries
 (#6672)

* Updated urllib + urllib tests

* Updated http + test

* Annotated failing tests

* Fixed issues in httpservers, robotparser and urllib2net

* Fixed windows only success

* Annotated flaky test in test_logging
---
 Lib/http/__init__.py              |  74 +++-
 Lib/http/client.py                | 221 ++++++-----
 Lib/http/cookiejar.py             |  64 ++--
 Lib/http/server.py                | 132 +++++--
 Lib/test/test_http_cookiejar.py   | 336 ++++++++++------
 Lib/test/test_httplib.py          | 615 ++++++++++++++++++++++++++----
 Lib/test/test_httpservers.py      | 446 +++++++++++++++++-----
 Lib/test/test_logging.py          |   1 +
 Lib/test/test_robotparser.py      |   4 +
 Lib/test/test_ssl.py              |   3 +-
 Lib/test/test_urllib.py           |   2 -
 Lib/test/test_urllib2.py          | 185 ++++++---
 Lib/test/test_urllib2_localnet.py |  92 ++---
 Lib/test/test_urllib2net.py       |   1 -
 Lib/test/test_urllib_response.py  |   7 +
 Lib/test/test_wsgiref.py          |   1 -
 Lib/urllib/error.py               |  11 +-
 Lib/urllib/parse.py               | 236 +++++++-----
 Lib/urllib/request.py             | 250 ++++++------
 Lib/urllib/robotparser.py         |  35 +-
 20 files changed, 1931 insertions(+), 785 deletions(-)

diff --git a/Lib/http/__init__.py b/Lib/http/__init__.py
index bf8d7d68868..17a47b180e5 100644
--- a/Lib/http/__init__.py
+++ b/Lib/http/__init__.py
@@ -1,14 +1,15 @@
-from enum import IntEnum
+from enum import StrEnum, IntEnum, _simple_enum
 
-__all__ = ['HTTPStatus']
+__all__ = ['HTTPStatus', 'HTTPMethod']
 
 
-class HTTPStatus(IntEnum):
+@_simple_enum(IntEnum)
+class HTTPStatus:
     """HTTP status codes and reason phrases
 
     Status codes from the following RFCs are all observed:
 
-        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+        * RFC 9110: HTTP Semantics, obsoletes 7231, which obsoleted 2616
         * RFC 6585: Additional HTTP Status Codes
         * RFC 3229: Delta encoding in HTTP
         * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
@@ -25,11 +26,30 @@ class HTTPStatus(IntEnum):
     def __new__(cls, value, phrase, description=''):
         obj = int.__new__(cls, value)
         obj._value_ = value
-
         obj.phrase = phrase
         obj.description = description
         return obj
 
+    @property
+    def is_informational(self):
+        return 100 <= self <= 199
+
+    @property
+    def is_success(self):
+        return 200 <= self <= 299
+
+    @property
+    def is_redirection(self):
+        return 300 <= self <= 399
+
+    @property
+    def is_client_error(self):
+        return 400 <= self <= 499
+
+    @property
+    def is_server_error(self):
+        return 500 <= self <= 599
+
     # informational
     CONTINUE = 100, 'Continue', 'Request received, please continue'
     SWITCHING_PROTOCOLS = (101, 'Switching Protocols',
@@ -94,22 +114,25 @@ def __new__(cls, value, phrase, description=''):
         'Client must specify Content-Length')
     PRECONDITION_FAILED = (412, 'Precondition Failed',
         'Precondition in headers is false')
-    REQUEST_ENTITY_TOO_LARGE = (413, 'Request Entity Too Large',
-        'Entity is too large')
-    REQUEST_URI_TOO_LONG = (414, 'Request-URI Too Long',
+    CONTENT_TOO_LARGE = (413, 'Content Too Large',
+        'Content is too large')
+    REQUEST_ENTITY_TOO_LARGE = CONTENT_TOO_LARGE
+    URI_TOO_LONG = (414, 'URI Too Long',
         'URI is too long')
+    REQUEST_URI_TOO_LONG = URI_TOO_LONG
     UNSUPPORTED_MEDIA_TYPE = (415, 'Unsupported Media Type',
         'Entity body in unsupported format')
-    REQUESTED_RANGE_NOT_SATISFIABLE = (416,
-        'Requested Range Not Satisfiable',
+    RANGE_NOT_SATISFIABLE = (416, 'Range Not Satisfiable',
         'Cannot satisfy request range')
+    REQUESTED_RANGE_NOT_SATISFIABLE = RANGE_NOT_SATISFIABLE
     EXPECTATION_FAILED = (417, 'Expectation Failed',
         'Expect condition could not be satisfied')
     IM_A_TEAPOT = (418, 'I\'m a Teapot',
         'Server refuses to brew coffee because it is a teapot.')
     MISDIRECTED_REQUEST = (421, 'Misdirected Request',
         'Server is not able to produce a response')
-    UNPROCESSABLE_ENTITY = 422, 'Unprocessable Entity'
+    UNPROCESSABLE_CONTENT = 422, 'Unprocessable Content'
+    UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
     LOCKED = 423, 'Locked'
     FAILED_DEPENDENCY = 424, 'Failed Dependency'
     TOO_EARLY = 425, 'Too Early'
@@ -148,3 +171,32 @@ def __new__(cls, value, phrase, description=''):
     NETWORK_AUTHENTICATION_REQUIRED = (511,
         'Network Authentication Required',
         'The client needs to authenticate to gain network access')
+
+
+@_simple_enum(StrEnum)
+class HTTPMethod:
+    """HTTP methods and descriptions
+
+    Methods from the following RFCs are all observed:
+
+        * RFC 9110: HTTP Semantics, obsoletes 7231, which obsoleted 2616
+        * RFC 5789: PATCH Method for HTTP
+    """
+    def __new__(cls, value, description):
+        obj = str.__new__(cls, value)
+        obj._value_ = value
+        obj.description = description
+        return obj
+
+    def __repr__(self):
+        return "<%s.%s>" % (self.__class__.__name__, self._name_)
+
+    CONNECT = 'CONNECT', 'Establish a connection to the server.'
+    DELETE = 'DELETE', 'Remove the target.'
+    GET = 'GET', 'Retrieve the target.'
+    HEAD = 'HEAD', 'Same as GET, but only retrieve the status line and header section.'
+    OPTIONS = 'OPTIONS', 'Describe the communication options for the target.'
+    PATCH = 'PATCH', 'Apply partial modifications to a target.'
+    POST = 'POST', 'Perform target-specific processing with the request payload.'
+    PUT = 'PUT', 'Replace the target with the request payload.'
+    TRACE = 'TRACE', 'Perform a message loop-back test along the path to the target.'
diff --git a/Lib/http/client.py b/Lib/http/client.py
index a6ab135b2c3..dd5f4136e9e 100644
--- a/Lib/http/client.py
+++ b/Lib/http/client.py
@@ -111,6 +111,11 @@
 _MAXLINE = 65536
 _MAXHEADERS = 100
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
+
+
 # Header name/value ABNF (http://tools.ietf.org/html/rfc7230#section-3.2)
 #
 # VCHAR          = %x21-7E
@@ -172,6 +177,13 @@ def _encode(data, name='data'):
             "if you want to send it encoded in UTF-8." %
             (name.title(), data[err.start:err.end], name)) from None
 
+def _strip_ipv6_iface(enc_name: bytes) -> bytes:
+    """Remove interface scope from IPv6 address."""
+    enc_name, percent, _ = enc_name.partition(b"%")
+    if percent:
+        assert enc_name.startswith(b'['), enc_name
+        enc_name += b']'
+    return enc_name
 
 class HTTPMessage(email.message.Message):
     # XXX The only usage of this method is in
@@ -221,8 +233,9 @@ def _read_headers(fp):
             break
     return headers
 
-def parse_headers(fp, _class=HTTPMessage):
-    """Parses only RFC2822 headers from a file pointer.
+def _parse_header_lines(header_lines, _class=HTTPMessage):
+    """
+    Parses only RFC 5322 headers from header lines.
 
     email Parser wants to see strings rather than bytes.
     But a TextIOWrapper around self.rfile would buffer too many bytes
@@ -231,10 +244,15 @@ def parse_headers(fp, _class=HTTPMessage):
     to parse.
 
     """
-    headers = _read_headers(fp)
-    hstring = b''.join(headers).decode('iso-8859-1')
+    hstring = b''.join(header_lines).decode('iso-8859-1')
     return email.parser.Parser(_class=_class).parsestr(hstring)
 
+def parse_headers(fp, _class=HTTPMessage):
+    """Parses only RFC 5322 headers from a file pointer."""
+
+    headers = _read_headers(fp)
+    return _parse_header_lines(headers, _class)
+
 
 class HTTPResponse(io.BufferedIOBase):
 
@@ -448,6 +466,7 @@ def isclosed(self):
         return self.fp is None
 
     def read(self, amt=None):
+        """Read and return the response body, or up to the next amt bytes."""
         if self.fp is None:
             return b""
 
@@ -458,7 +477,7 @@ def read(self, amt=None):
         if self.chunked:
             return self._read_chunked(amt)
 
-        if amt is not None:
+        if amt is not None and amt >= 0:
             if self.length is not None and amt > self.length:
                 # clip the read to the "end of response"
                 amt = self.length
@@ -576,13 +595,11 @@ def _get_chunk_left(self):
 
     def _read_chunked(self, amt=None):
         assert self.chunked != _UNKNOWN
+        if amt is not None and amt < 0:
+            amt = None
         value = []
         try:
-            while True:
-                chunk_left = self._get_chunk_left()
-                if chunk_left is None:
-                    break
-
+            while (chunk_left := self._get_chunk_left()) is not None:
                 if amt is not None and amt <= chunk_left:
                     value.append(self._safe_read(amt))
                     self.chunk_left = chunk_left - amt
@@ -593,8 +610,8 @@ def _read_chunked(self, amt=None):
                     amt -= chunk_left
                 self.chunk_left = 0
             return b''.join(value)
-        except IncompleteRead:
-            raise IncompleteRead(b''.join(value))
+        except IncompleteRead as exc:
+            raise IncompleteRead(b''.join(value)) from exc
 
     def _readinto_chunked(self, b):
         assert self.chunked != _UNKNOWN
@@ -627,10 +644,25 @@ def _safe_read(self, amt):
         reading. If the bytes are truly not available (due to EOF), then the
         IncompleteRead exception can be used to detect the problem.
         """
-        data = self.fp.read(amt)
-        if len(data) < amt:
-            raise IncompleteRead(data, amt-len(data))
-        return data
+        cursize = min(amt, _MIN_READ_BUF_SIZE)
+        data = self.fp.read(cursize)
+        if len(data) >= amt:
+            return data
+        if len(data) < cursize:
+            raise IncompleteRead(data, amt - len(data))
+
+        data = io.BytesIO(data)
+        data.seek(0, 2)
+        while True:
+            # This is a geometric increase in read size (never more than
+            # doubling out the current length of data per loop iteration).
+            delta = min(cursize, amt - cursize)
+            data.write(self.fp.read(delta))
+            if data.tell() >= amt:
+                return data.getvalue()
+            cursize += delta
+            if data.tell() < cursize:
+                raise IncompleteRead(data.getvalue(), amt - data.tell())
 
     def _safe_readinto(self, b):
         """Same as _safe_read, but for reading into a buffer."""
@@ -655,6 +687,8 @@ def read1(self, n=-1):
             self._close_conn()
         elif self.length is not None:
             self.length -= len(result)
+            if not self.length:
+                self._close_conn()
         return result
 
     def peek(self, n=-1):
@@ -679,6 +713,8 @@ def readline(self, limit=-1):
             self._close_conn()
         elif self.length is not None:
             self.length -= len(result)
+            if not self.length:
+                self._close_conn()
         return result
 
     def _read1_chunked(self, n):
@@ -786,6 +822,20 @@ def getcode(self):
         '''
         return self.status
 
+
+def _create_https_context(http_version):
+    # Function also used by urllib.request to be able to set the check_hostname
+    # attribute on a context object.
+    context = ssl._create_default_https_context()
+    # send ALPN extension to indicate HTTP/1.1 protocol
+    if http_version == 11:
+        context.set_alpn_protocols(['http/1.1'])
+    # enable PHA for TLS 1.3 connections if available
+    if context.post_handshake_auth is not None:
+        context.post_handshake_auth = True
+    return context
+
+
 class HTTPConnection:
 
     _http_vsn = 11
@@ -847,6 +897,7 @@ def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
         self._tunnel_host = None
         self._tunnel_port = None
         self._tunnel_headers = {}
+        self._raw_proxy_headers = None
 
         (self.host, self.port) = self._get_hostport(host, port)
 
@@ -859,9 +910,9 @@ def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
     def set_tunnel(self, host, port=None, headers=None):
         """Set up host and port for HTTP CONNECT tunnelling.
 
-        In a connection that uses HTTP CONNECT tunneling, the host passed to the
-        constructor is used as a proxy server that relays all communication to
-        the endpoint passed to `set_tunnel`. This done by sending an HTTP
+        In a connection that uses HTTP CONNECT tunnelling, the host passed to
+        the constructor is used as a proxy server that relays all communication
+        to the endpoint passed to `set_tunnel`. This done by sending an HTTP
         CONNECT request to the proxy server when the connection is established.
 
         This method must be called before the HTTP connection has been
@@ -869,6 +920,13 @@ def set_tunnel(self, host, port=None, headers=None):
 
         The headers argument should be a mapping of extra HTTP headers to send
         with the CONNECT request.
+
+        As HTTP/1.1 is used for HTTP CONNECT tunnelling request, as per the RFC
+        (https://tools.ietf.org/html/rfc7231#section-4.3.6), a HTTP Host:
+        header must be provided, matching the authority-form of the request
+        target provided as the destination for the CONNECT request. If a
+        HTTP Host: header is not provided via the headers argument, one
+        is generated and transmitted automatically.
         """
 
         if self.sock:
@@ -876,10 +934,15 @@ def set_tunnel(self, host, port=None, headers=None):
 
         self._tunnel_host, self._tunnel_port = self._get_hostport(host, port)
         if headers:
-            self._tunnel_headers = headers
+            self._tunnel_headers = headers.copy()
         else:
             self._tunnel_headers.clear()
 
+        if not any(header.lower() == "host" for header in self._tunnel_headers):
+            encoded_host = self._tunnel_host.encode("idna").decode("ascii")
+            self._tunnel_headers["Host"] = "%s:%d" % (
+                encoded_host, self._tunnel_port)
+
     def _get_hostport(self, host, port):
         if port is None:
             i = host.rfind(':')
@@ -895,17 +958,24 @@ def _get_hostport(self, host, port):
                 host = host[:i]
             else:
                 port = self.default_port
-            if host and host[0] == '[' and host[-1] == ']':
-                host = host[1:-1]
+        if host and host[0] == '[' and host[-1] == ']':
+            host = host[1:-1]
 
         return (host, port)
 
     def set_debuglevel(self, level):
         self.debuglevel = level
 
+    def _wrap_ipv6(self, ip):
+        if b':' in ip and ip[0] != b'['[0]:
+            return b"[" + ip + b"]"
+        return ip
+
     def _tunnel(self):
-        connect = b"CONNECT %s:%d HTTP/1.0\r\n" % (
-            self._tunnel_host.encode("ascii"), self._tunnel_port)
+        connect = b"CONNECT %s:%d %s\r\n" % (
+            self._wrap_ipv6(self._tunnel_host.encode("idna")),
+            self._tunnel_port,
+            self._http_vsn_str.encode("ascii"))
         headers = [connect]
         for header, value in self._tunnel_headers.items():
             headers.append(f"{header}: {value}\r\n".encode("latin-1"))
@@ -917,23 +987,35 @@ def _tunnel(self):
         del headers
 
         response = self.response_class(self.sock, method=self._method)
-        (version, code, message) = response._read_status()
+        try:
+            (version, code, message) = response._read_status()
 
-        if code != http.HTTPStatus.OK:
-            self.close()
-            raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
-        while True:
-            line = response.fp.readline(_MAXLINE + 1)
-            if len(line) > _MAXLINE:
-                raise LineTooLong("header line")
-            if not line:
-                # for sites which EOF without sending a trailer
-                break
-            if line in (b'\r\n', b'\n', b''):
-                break
+            self._raw_proxy_headers = _read_headers(response.fp)
 
             if self.debuglevel > 0:
-                print('header:', line.decode())
+                for header in self._raw_proxy_headers:
+                    print('header:', header.decode())
+
+            if code != http.HTTPStatus.OK:
+                self.close()
+                raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
+
+        finally:
+            response.close()
+
+    def get_proxy_response_headers(self):
+        """
+        Returns a dictionary with the headers of the response
+        received from the proxy server to the CONNECT request
+        sent to set the tunnel.
+
+        If the CONNECT request was not sent, the method returns None.
+        """
+        return (
+            _parse_header_lines(self._raw_proxy_headers)
+            if self._raw_proxy_headers is not None
+            else None
+        )
 
     def connect(self):
         """Connect to the host and port specified in __init__."""
@@ -942,7 +1024,7 @@ def connect(self):
             (self.host,self.port), self.timeout, self.source_address)
         # Might fail in OSs that don't implement TCP_NODELAY
         try:
-             self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
         except OSError as e:
             if e.errno != errno.ENOPROTOOPT:
                 raise
@@ -980,14 +1062,11 @@ def send(self, data):
             print("send:", repr(data))
         if hasattr(data, "read") :
             if self.debuglevel > 0:
-                print("sendIng a read()able")
+                print("sending a readable")
             encode = self._is_textIO(data)
             if encode and self.debuglevel > 0:
                 print("encoding file using iso-8859-1")
-            while 1:
-                datablock = data.read(self.blocksize)
-                if not datablock:
-                    break
+            while datablock := data.read(self.blocksize):
                 if encode:
                     datablock = datablock.encode("iso-8859-1")
                 sys.audit("http.client.send", self, datablock)
@@ -1013,14 +1092,11 @@ def _output(self, s):
 
     def _read_readable(self, readable):
         if self.debuglevel > 0:
-            print("sendIng a read()able")
+            print("reading a readable")
         encode = self._is_textIO(readable)
         if encode and self.debuglevel > 0:
             print("encoding file using iso-8859-1")
-        while True:
-            datablock = readable.read(self.blocksize)
-            if not datablock:
-                break
+        while datablock := readable.read(self.blocksize):
             if encode:
                 datablock = datablock.encode("iso-8859-1")
             yield datablock
@@ -1157,7 +1233,7 @@ def putrequest(self, method, url, skip_host=False,
                         netloc_enc = netloc.encode("ascii")
                     except UnicodeEncodeError:
                         netloc_enc = netloc.encode("idna")
-                    self.putheader('Host', netloc_enc)
+                    self.putheader('Host', _strip_ipv6_iface(netloc_enc))
                 else:
                     if self._tunnel_host:
                         host = self._tunnel_host
@@ -1173,9 +1249,9 @@ def putrequest(self, method, url, skip_host=False,
 
                     # As per RFC 273, IPv6 address should be wrapped with []
                     # when used as Host header
-
-                    if host.find(':') >= 0:
-                        host_enc = b'[' + host_enc + b']'
+                    host_enc = self._wrap_ipv6(host_enc)
+                    if ":" in host:
+                        host_enc = _strip_ipv6_iface(host_enc)
 
                     if port == self.default_port:
                         self.putheader('Host', host_enc)
@@ -1400,46 +1476,15 @@ class HTTPSConnection(HTTPConnection):
 
         default_port = HTTPS_PORT
 
-        # XXX Should key_file and cert_file be deprecated in favour of context?
-
-        def __init__(self, host, port=None, key_file=None, cert_file=None,
-                     timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
-                     source_address=None, *, context=None,
-                     check_hostname=None, blocksize=8192):
+        def __init__(self, host, port=None,
+                     *, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
+                     source_address=None, context=None, blocksize=8192):
             super(HTTPSConnection, self).__init__(host, port, timeout,
                                                   source_address,
                                                   blocksize=blocksize)
-            if (key_file is not None or cert_file is not None or
-                        check_hostname is not None):
-                import warnings
-                warnings.warn("key_file, cert_file and check_hostname are "
-                              "deprecated, use a custom context instead.",
-                              DeprecationWarning, 2)
-            self.key_file = key_file
-            self.cert_file = cert_file
             if context is None:
-                context = ssl._create_default_https_context()
-                # send ALPN extension to indicate HTTP/1.1 protocol
-                if self._http_vsn == 11:
-                    context.set_alpn_protocols(['http/1.1'])
-                # enable PHA for TLS 1.3 connections if available
-                if context.post_handshake_auth is not None:
-                    context.post_handshake_auth = True
-            will_verify = context.verify_mode != ssl.CERT_NONE
-            if check_hostname is None:
-                check_hostname = context.check_hostname
-            if check_hostname and not will_verify:
-                raise ValueError("check_hostname needs a SSL context with "
-                                 "either CERT_OPTIONAL or CERT_REQUIRED")
-            if key_file or cert_file:
-                context.load_cert_chain(cert_file, key_file)
-                # cert and key file means the user wants to authenticate.
-                # enable TLS 1.3 PHA implicitly even for custom contexts.
-                if context.post_handshake_auth is not None:
-                    context.post_handshake_auth = True
+                context = _create_https_context(self._http_vsn)
             self._context = context
-            if check_hostname is not None:
-                self._context.check_hostname = check_hostname
 
         def connect(self):
             "Connect to a host on a given (SSL) port."
diff --git a/Lib/http/cookiejar.py b/Lib/http/cookiejar.py
index 685f6a0b976..9a2f0fb851c 100644
--- a/Lib/http/cookiejar.py
+++ b/Lib/http/cookiejar.py
@@ -34,10 +34,7 @@
 import re
 import time
 import urllib.parse, urllib.request
-try:
-    import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
+import threading as _threading
 import http.client  # only for the default HTTP port
 from calendar import timegm
 
@@ -92,8 +89,7 @@ def _timegm(tt):
 DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
 MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-MONTHS_LOWER = []
-for month in MONTHS: MONTHS_LOWER.append(month.lower())
+MONTHS_LOWER = [month.lower() for month in MONTHS]
 
 def time2isoz(t=None):
     """Return a string representing time in seconds since epoch, t.
@@ -108,9 +104,9 @@ def time2isoz(t=None):
 
     """
     if t is None:
-        dt = datetime.datetime.utcnow()
+        dt = datetime.datetime.now(tz=datetime.UTC)
     else:
-        dt = datetime.datetime.utcfromtimestamp(t)
+        dt = datetime.datetime.fromtimestamp(t, tz=datetime.UTC)
     return "%04d-%02d-%02d %02d:%02d:%02dZ" % (
         dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
 
@@ -126,9 +122,9 @@ def time2netscape(t=None):
 
     """
     if t is None:
-        dt = datetime.datetime.utcnow()
+        dt = datetime.datetime.now(tz=datetime.UTC)
     else:
-        dt = datetime.datetime.utcfromtimestamp(t)
+        dt = datetime.datetime.fromtimestamp(t, tz=datetime.UTC)
     return "%s, %02d-%s-%04d %02d:%02d:%02d GMT" % (
         DAYS[dt.weekday()], dt.day, MONTHS[dt.month-1],
         dt.year, dt.hour, dt.minute, dt.second)
@@ -434,6 +430,7 @@ def split_header_words(header_values):
         if pairs: result.append(pairs)
     return result
 
+HEADER_JOIN_TOKEN_RE = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
 HEADER_JOIN_ESCAPE_RE = re.compile(r"([\"\\])")
 def join_header_words(lists):
     """Do the inverse (almost) of the conversion done by split_header_words.
@@ -441,10 +438,10 @@ def join_header_words(lists):
     Takes a list of lists of (key, value) pairs and produces a single header
     value.  Attribute values are quoted if needed.
 
-    >>> join_header_words([[("text/plain", None), ("charset", "iso-8859-1")]])
-    'text/plain; charset="iso-8859-1"'
-    >>> join_header_words([[("text/plain", None)], [("charset", "iso-8859-1")]])
-    'text/plain, charset="iso-8859-1"'
+    >>> join_header_words([[("text/plain", None), ("charset", "iso-8859/1")]])
+    'text/plain; charset="iso-8859/1"'
+    >>> join_header_words([[("text/plain", None)], [("charset", "iso-8859/1")]])
+    'text/plain, charset="iso-8859/1"'
 
     """
     headers = []
@@ -452,7 +449,7 @@ def join_header_words(lists):
         attr = []
         for k, v in pairs:
             if v is not None:
-                if not re.search(r"^\w+$", v):
+                if not HEADER_JOIN_TOKEN_RE.fullmatch(v):
                     v = HEADER_JOIN_ESCAPE_RE.sub(r"\\\1", v)  # escape " and \
                     v = '"%s"' % v
                 k = "%s=%s" % (k, v)
@@ -644,7 +641,7 @@ def eff_request_host(request):
 
     """
     erhn = req_host = request_host(request)
-    if req_host.find(".") == -1 and not IPV4_RE.search(req_host):
+    if "." not in req_host:
         erhn = req_host + ".local"
     return req_host, erhn
 
@@ -1047,12 +1044,13 @@ def set_ok_domain(self, cookie, request):
             else:
                 undotted_domain = domain
             embedded_dots = (undotted_domain.find(".") >= 0)
-            if not embedded_dots and domain != ".local":
+            if not embedded_dots and not erhn.endswith(".local"):
                 _debug("   non-local domain %s contains no embedded dot",
                        domain)
                 return False
             if cookie.version == 0:
-                if (not erhn.endswith(domain) and
+                if (not (erhn.endswith(domain) or
+                         erhn.endswith(f"{undotted_domain}.local")) and
                     (not erhn.startswith(".") and
                      not ("."+erhn).endswith(domain))):
                     _debug("   effective request-host %s (even with added "
@@ -1227,14 +1225,9 @@ def path_return_ok(self, path, request):
         _debug("  %s does not path-match %s", req_path, path)
         return False
 
-def vals_sorted_by_key(adict):
-    keys = sorted(adict.keys())
-    return map(adict.get, keys)
-
 def deepvalues(mapping):
-    """Iterates over nested mapping, depth-first, in sorted order by key."""
-    values = vals_sorted_by_key(mapping)
-    for obj in values:
+    """Iterates over nested mapping, depth-first"""
+    for obj in list(mapping.values()):
         mapping = False
         try:
             obj.items
@@ -1898,7 +1891,10 @@ def save(self, filename=None, ignore_discard=False, ignore_expires=False):
             if self.filename is not None: filename = self.filename
             else: raise ValueError(MISSING_FILENAME_TEXT)
 
-        with open(filename, "w") as f:
+        with os.fdopen(
+            os.open(filename, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600),
+            'w',
+        ) as f:
             # There really isn't an LWP Cookies 2.0 format, but this indicates
             # that there is extra information in here (domain_dot and
             # port_spec) while still being compatible with libwww-perl, I hope.
@@ -1923,9 +1919,7 @@ def _really_load(self, f, filename, ignore_discard, ignore_expires):
                        "comment", "commenturl")
 
         try:
-            while 1:
-                line = f.readline()
-                if line == "": break
+            while (line := f.readline()) != "":
                 if not line.startswith(header):
                     continue
                 line = line[len(header):].strip()
@@ -1993,7 +1987,7 @@ class MozillaCookieJar(FileCookieJar):
 
     This class differs from CookieJar only in the format it uses to save and
     load cookies to and from a file.  This class uses the Mozilla/Netscape
-    `cookies.txt' format.  lynx uses this file format, too.
+    `cookies.txt' format.  curl and lynx use this file format, too.
 
     Don't expect cookies saved while the browser is running to be noticed by
     the browser (in fact, Mozilla on unix will overwrite your saved cookies if
@@ -2025,12 +2019,9 @@ def _really_load(self, f, filename, ignore_discard, ignore_expires):
                 filename)
 
         try:
-            while 1:
-                line = f.readline()
+            while (line := f.readline()) != "":
                 rest = {}
 
-                if line == "": break
-
                 # httponly is a cookie flag as defined in rfc6265
                 # when encoded in a netscape cookie file,
                 # the line is prepended with "#HttpOnly_"
@@ -2094,7 +2085,10 @@ def save(self, filename=None, ignore_discard=False, ignore_expires=False):
             if self.filename is not None: filename = self.filename
             else: raise ValueError(MISSING_FILENAME_TEXT)
 
-        with open(filename, "w") as f:
+        with os.fdopen(
+            os.open(filename, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600),
+            'w',
+        ) as f:
             f.write(NETSCAPE_HEADER_TEXT)
             now = time.time()
             for cookie in self:
diff --git a/Lib/http/server.py b/Lib/http/server.py
index 58abadf7377..0ec479003a4 100644
--- a/Lib/http/server.py
+++ b/Lib/http/server.py
@@ -2,18 +2,18 @@
 
 Note: BaseHTTPRequestHandler doesn't implement any HTTP request; see
 SimpleHTTPRequestHandler for simple implementations of GET, HEAD and POST,
-and CGIHTTPRequestHandler for CGI scripts.
+and (deprecated) CGIHTTPRequestHandler for CGI scripts.
 
-It does, however, optionally implement HTTP/1.1 persistent connections,
-as of version 0.3.
+It does, however, optionally implement HTTP/1.1 persistent connections.
 
 Notes on CGIHTTPRequestHandler
 ------------------------------
 
-This class implements GET and POST requests to cgi-bin scripts.
+This class is deprecated. It implements GET and POST requests to cgi-bin scripts.
 
-If the os.fork() function is not present (e.g. on Windows),
-subprocess.Popen() is used as a fallback, with slightly altered semantics.
+If the os.fork() function is not present (Windows), subprocess.Popen() is used,
+with slightly altered but never documented semantics.  Use from a threaded
+process is likely to trigger a warning at os.fork() time.
 
 In all cases, the implementation is intentionally naive -- all
 requests are executed synchronously.
@@ -93,6 +93,7 @@
 import html
 import http.client
 import io
+import itertools
 import mimetypes
 import os
 import posixpath
@@ -109,11 +110,10 @@
 
 # Default error message template
 DEFAULT_ERROR_MESSAGE = """\
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-        "http://www.w3.org/TR/html4/strict.dtd">
-<html>
+<!DOCTYPE HTML>
+<html lang="en">
     <head>
-        <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
+        <meta charset="utf-8">
         <title>Error response</title>
     </head>
     <body>
@@ -127,6 +127,10 @@
 
 DEFAULT_ERROR_CONTENT_TYPE = "text/html;charset=utf-8"
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
+
 class HTTPServer(socketserver.TCPServer):
 
     allow_reuse_address = 1    # Seems to make sense in testing environment
@@ -275,6 +279,7 @@ def parse_request(self):
         error response has already been sent back.
 
         """
+        is_http_0_9 = False
         self.command = None  # set in case of error on the first line
         self.request_version = version = self.default_request_version
         self.close_connection = True
@@ -300,6 +305,10 @@ def parse_request(self):
                 #   - Leading zeros MUST be ignored by recipients.
                 if len(version_number) != 2:
                     raise ValueError
+                if any(not component.isdigit() for component in version_number):
+                    raise ValueError("non digit in http version")
+                if any(len(component) > 10 for component in version_number):
+                    raise ValueError("unreasonable length http version")
                 version_number = int(version_number[0]), int(version_number[1])
             except (ValueError, IndexError):
                 self.send_error(
@@ -328,8 +337,21 @@ def parse_request(self):
                     HTTPStatus.BAD_REQUEST,
                     "Bad HTTP/0.9 request type (%r)" % command)
                 return False
+            is_http_0_9 = True
         self.command, self.path = command, path
 
+        # gh-87389: The purpose of replacing '//' with '/' is to protect
+        # against open redirect attacks possibly triggered if the path starts
+        # with '//' because http clients treat //path as an absolute URI
+        # without scheme (similar to http://path) rather than a path.
+        if self.path.startswith('//'):
+            self.path = '/' + self.path.lstrip('/')  # Reduce to a single /
+
+        # For HTTP/0.9, headers are not expected at all.
+        if is_http_0_9:
+            self.headers = {}
+            return True
+
         # Examine the headers and look for a Connection directive.
         try:
             self.headers = http.client.parse_headers(self.rfile,
@@ -556,6 +578,11 @@ def log_error(self, format, *args):
 
         self.log_message(format, *args)
 
+    # https://en.wikipedia.org/wiki/List_of_Unicode_characters#Control_codes
+    _control_char_table = str.maketrans(
+            {c: fr'\x{c:02x}' for c in itertools.chain(range(0x20), range(0x7f,0xa0))})
+    _control_char_table[ord('\\')] = r'\\'
+
     def log_message(self, format, *args):
         """Log an arbitrary message.
 
@@ -571,12 +598,16 @@ def log_message(self, format, *args):
         The client ip and current date/time are prefixed to
         every message.
 
+        Unicode control characters are replaced with escaped hex
+        before writing the output to stderr.
+
         """
 
+        message = format % args
         sys.stderr.write("%s - - [%s] %s\n" %
                          (self.address_string(),
                           self.log_date_time_string(),
-                          format%args))
+                          message.translate(self._control_char_table)))
 
     def version_string(self):
         """Return the server software version string."""
@@ -637,6 +668,7 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
 
     server_version = "SimpleHTTP/" + __version__
+    index_pages = ("index.html", "index.htm")
     extensions_map = _encodings_map_default = {
         '.gz': 'application/gzip',
         '.Z': 'application/octet-stream',
@@ -680,7 +712,7 @@ def send_head(self):
         f = None
         if os.path.isdir(path):
             parts = urllib.parse.urlsplit(self.path)
-            if not parts.path.endswith('/'):
+            if not parts.path.endswith(('/', '%2f', '%2F')):
                 # redirect browser - doing basically what apache does
                 self.send_response(HTTPStatus.MOVED_PERMANENTLY)
                 new_parts = (parts[0], parts[1], parts[2] + '/',
@@ -690,9 +722,9 @@ def send_head(self):
                 self.send_header("Content-Length", "0")
                 self.end_headers()
                 return None
-            for index in "index.html", "index.htm":
+            for index in self.index_pages:
                 index = os.path.join(path, index)
-                if os.path.exists(index):
+                if os.path.isfile(index):
                     path = index
                     break
             else:
@@ -702,7 +734,7 @@ def send_head(self):
         # The test for this was added in test_httpserver.py
         # However, some OS platforms accept a trailingSlash as a filename
         # See discussion on python-dev and Issue34711 regarding
-        # parseing and rejection of filenames with a trailing slash
+        # parsing and rejection of filenames with a trailing slash
         if path.endswith("/"):
             self.send_error(HTTPStatus.NOT_FOUND, "File not found")
             return None
@@ -770,21 +802,23 @@ def list_directory(self, path):
             return None
         list.sort(key=lambda a: a.lower())
         r = []
+        displaypath = self.path
+        displaypath = displaypath.split('#', 1)[0]
+        displaypath = displaypath.split('?', 1)[0]
         try:
-            displaypath = urllib.parse.unquote(self.path,
+            displaypath = urllib.parse.unquote(displaypath,
                                                errors='surrogatepass')
         except UnicodeDecodeError:
-            displaypath = urllib.parse.unquote(path)
+            displaypath = urllib.parse.unquote(displaypath)
         displaypath = html.escape(displaypath, quote=False)
         enc = sys.getfilesystemencoding()
-        title = 'Directory listing for %s' % displaypath
-        r.append('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" '
-                 '"http://www.w3.org/TR/html4/strict.dtd">')
-        r.append('<html>\n<head>')
-        r.append('<meta http-equiv="Content-Type" '
-                 'content="text/html; charset=%s">' % enc)
-        r.append('<title>%s</title>\n</head>' % title)
-        r.append('<body>\n<h1>%s</h1>' % title)
+        title = f'Directory listing for {displaypath}'
+        r.append('<!DOCTYPE HTML>')
+        r.append('<html lang="en">')
+        r.append('<head>')
+        r.append(f'<meta charset="{enc}">')
+        r.append(f'<title>{title}</title>\n</head>')
+        r.append(f'<body>\n<h1>{title}</h1>')
         r.append('<hr>\n<ul>')
         for name in list:
             fullname = os.path.join(path, name)
@@ -820,14 +854,14 @@ def translate_path(self, path):
 
         """
         # abandon query parameters
-        path = path.split('?',1)[0]
-        path = path.split('#',1)[0]
+        path = path.split('#', 1)[0]
+        path = path.split('?', 1)[0]
         # Don't forget explicit trailing slash when normalizing. Issue17324
-        trailing_slash = path.rstrip().endswith('/')
         try:
             path = urllib.parse.unquote(path, errors='surrogatepass')
         except UnicodeDecodeError:
             path = urllib.parse.unquote(path)
+        trailing_slash = path.endswith('/')
         path = posixpath.normpath(path)
         words = path.split('/')
         words = filter(None, words)
@@ -877,7 +911,7 @@ def guess_type(self, path):
         ext = ext.lower()
         if ext in self.extensions_map:
             return self.extensions_map[ext]
-        guess, _ = mimetypes.guess_type(path)
+        guess, _ = mimetypes.guess_file_type(path)
         if guess:
             return guess
         return 'application/octet-stream'
@@ -966,6 +1000,12 @@ class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
 
     """
 
+    def __init__(self, *args, **kwargs):
+        import warnings
+        warnings._deprecated("http.server.CGIHTTPRequestHandler",
+                             remove=(3, 15))
+        super().__init__(*args, **kwargs)
+
     # Determine platform specifics
     have_fork = hasattr(os, 'fork')
 
@@ -1078,7 +1118,7 @@ def run_cgi(self):
                     "CGI script is not executable (%r)" % scriptname)
                 return
 
-        # Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
+        # Reference: https://www6.uniovi.es/~antonio/ncsa_httpd/cgi/env.html
         # XXX Much of the following could be prepared ahead of time!
         env = copy.deepcopy(os.environ)
         env['SERVER_SOFTWARE'] = self.version_string()
@@ -1198,7 +1238,18 @@ def run_cgi(self):
                                  env = env
                                  )
             if self.command.lower() == "post" and nbytes > 0:
-                data = self.rfile.read(nbytes)
+                cursize = 0
+                data = self.rfile.read(min(nbytes, _MIN_READ_BUF_SIZE))
+                while len(data) < nbytes and len(data) != cursize:
+                    cursize = len(data)
+                    # This is a geometric increase in read size (never more
+                    # than doubling out the current length of data per loop
+                    # iteration).
+                    delta = min(cursize, nbytes - cursize)
+                    try:
+                        data += self.rfile.read(delta)
+                    except TimeoutError:
+                        break
             else:
                 data = None
             # throw away additional data [see bug #427345]
@@ -1258,15 +1309,19 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     parser = argparse.ArgumentParser()
     parser.add_argument('--cgi', action='store_true',
                         help='run as CGI server')
-    parser.add_argument('--bind', '-b', metavar='ADDRESS',
-                        help='specify alternate bind address '
+    parser.add_argument('-b', '--bind', metavar='ADDRESS',
+                        help='bind to this address '
                              '(default: all interfaces)')
-    parser.add_argument('--directory', '-d', default=os.getcwd(),
-                        help='specify alternate directory '
+    parser.add_argument('-d', '--directory', default=os.getcwd(),
+                        help='serve this directory '
                              '(default: current directory)')
-    parser.add_argument('port', action='store', default=8000, type=int,
-                        nargs='?',
-                        help='specify alternate port (default: 8000)')
+    parser.add_argument('-p', '--protocol', metavar='VERSION',
+                        default='HTTP/1.0',
+                        help='conform to this HTTP version '
+                             '(default: %(default)s)')
+    parser.add_argument('port', default=8000, type=int, nargs='?',
+                        help='bind to this port '
+                             '(default: %(default)s)')
     args = parser.parse_args()
     if args.cgi:
         handler_class = CGIHTTPRequestHandler
@@ -1292,4 +1347,5 @@ def finish_request(self, request, client_address):
         ServerClass=DualStackServer,
         port=args.port,
         bind=args.bind,
+        protocol=args.protocol,
     )
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index 68a693c78b3..51fa4a3d413 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -1,14 +1,16 @@
 """Tests for http/cookiejar.py."""
 
 import os
+import stat
+import sys
 import re
-import test.support
+from test import support
 from test.support import os_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 import time
 import unittest
 import urllib.request
-import pathlib
 
 from http.cookiejar import (time2isoz, http2time, iso2time, time2netscape,
      parse_ns_headers, join_header_words, split_header_words, Cookie,
@@ -17,6 +19,7 @@
      reach, is_HDN, domain_match, user_domain_match, request_path,
      request_port, request_host)
 
+mswindows = (sys.platform == "win32")
 
 class DateTimeTests(unittest.TestCase):
 
@@ -104,8 +107,7 @@ def test_http2time_formats(self):
             self.assertEqual(http2time(s.lower()), test_t, s.lower())
             self.assertEqual(http2time(s.upper()), test_t, s.upper())
 
-    def test_http2time_garbage(self):
-        for test in [
+    @support.subTests('test', [
             '',
             'Garbage',
             'Mandag 16. September 1996',
@@ -120,10 +122,9 @@ def test_http2time_garbage(self):
             '08-01-3697739',
             '09 Feb 19942632 22:23:32 GMT',
             'Wed, 09 Feb 1994834 22:23:32 GMT',
-            ]:
-            self.assertIsNone(http2time(test),
-                              "http2time(%s) is not None\n"
-                              "http2time(test) %s" % (test, http2time(test)))
+        ])
+    def test_http2time_garbage(self, test):
+        self.assertIsNone(http2time(test))
 
     def test_http2time_redos_regression_actually_completes(self):
         # LOOSE_HTTP_DATE_RE was vulnerable to malicious input which caused catastrophic backtracking (REDoS).
@@ -148,9 +149,7 @@ def parse_date(text):
         self.assertEqual(parse_date("1994-02-03 19:45:29 +0530"),
                          (1994, 2, 3, 14, 15, 29))
 
-    def test_iso2time_formats(self):
-        # test iso2time for supported dates.
-        tests = [
+    @support.subTests('s', [
             '1994-02-03 00:00:00 -0000', # ISO 8601 format
             '1994-02-03 00:00:00 +0000', # ISO 8601 format
             '1994-02-03 00:00:00',       # zone is optional
@@ -163,16 +162,15 @@ def test_iso2time_formats(self):
             # A few tests with extra space at various places
             '  1994-02-03 ',
             '  1994-02-03T00:00:00  ',
-        ]
-
+        ])
+    def test_iso2time_formats(self, s):
+        # test iso2time for supported dates.
         test_t = 760233600  # assume broken POSIX counting of seconds
-        for s in tests:
-            self.assertEqual(iso2time(s), test_t, s)
-            self.assertEqual(iso2time(s.lower()), test_t, s.lower())
-            self.assertEqual(iso2time(s.upper()), test_t, s.upper())
+        self.assertEqual(iso2time(s), test_t, s)
+        self.assertEqual(iso2time(s.lower()), test_t, s.lower())
+        self.assertEqual(iso2time(s.upper()), test_t, s.upper())
 
-    def test_iso2time_garbage(self):
-        for test in [
+    @support.subTests('test', [
             '',
             'Garbage',
             'Thursday, 03-Feb-94 00:00:00 GMT',
@@ -185,11 +183,10 @@ def test_iso2time_garbage(self):
             '01-01-1980 00:00:62',
             '01-01-1980T00:00:62',
             '19800101T250000Z',
-            ]:
-            self.assertIsNone(iso2time(test),
-                              "iso2time(%r)" % test)
+        ])
+    def test_iso2time_garbage(self, test):
+        self.assertIsNone(iso2time(test))
 
-    @unittest.skip("TODO, RUSTPYTHON, regressed to quadratic complexity")
     def test_iso2time_performance_regression(self):
         # If ISO_DATE_RE regresses to quadratic complexity, this test will take a very long time to succeed.
         # If fixed, it should complete within a fraction of a second.
@@ -199,24 +196,23 @@ def test_iso2time_performance_regression(self):
 
 class HeaderTests(unittest.TestCase):
 
-    def test_parse_ns_headers(self):
-        # quotes should be stripped
-        expected = [[('foo', 'bar'), ('expires', 2209069412), ('version', '0')]]
-        for hdr in [
+    @support.subTests('hdr', [
             'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
             'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
-            ]:
-            self.assertEqual(parse_ns_headers([hdr]), expected)
-
-    def test_parse_ns_headers_version(self):
-
+        ])
+    def test_parse_ns_headers(self, hdr):
         # quotes should be stripped
-        expected = [[('foo', 'bar'), ('version', '1')]]
-        for hdr in [
+        expected = [[('foo', 'bar'), ('expires', 2209069412), ('version', '0')]]
+        self.assertEqual(parse_ns_headers([hdr]), expected)
+
+    @support.subTests('hdr', [
             'foo=bar; version="1"',
             'foo=bar; Version="1"',
-            ]:
-            self.assertEqual(parse_ns_headers([hdr]), expected)
+        ])
+    def test_parse_ns_headers_version(self, hdr):
+        # quotes should be stripped
+        expected = [[('foo', 'bar'), ('version', '1')]]
+        self.assertEqual(parse_ns_headers([hdr]), expected)
 
     def test_parse_ns_headers_special_names(self):
         # names such as 'expires' are not special in first name=value pair
@@ -232,8 +228,7 @@ def test_join_header_words(self):
 
         self.assertEqual(join_header_words([[]]), "")
 
-    def test_split_header_words(self):
-        tests = [
+    @support.subTests('arg,expect', [
             ("foo", [[("foo", None)]]),
             ("foo=bar", [[("foo", "bar")]]),
             ("   foo   ", [[("foo", None)]]),
@@ -250,24 +245,22 @@ def test_split_header_words(self):
             (r'foo; bar=baz, spam=, foo="\,\;\"", bar= ',
              [[("foo", None), ("bar", "baz")],
               [("spam", "")], [("foo", ',;"')], [("bar", "")]]),
-            ]
-
-        for arg, expect in tests:
-            try:
-                result = split_header_words([arg])
-            except:
-                import traceback, io
-                f = io.StringIO()
-                traceback.print_exc(None, f)
-                result = "(error -- traceback follows)\n\n%s" % f.getvalue()
-            self.assertEqual(result,  expect, """
+        ])
+    def test_split_header_words(self, arg, expect):
+        try:
+            result = split_header_words([arg])
+        except:
+            import traceback, io
+            f = io.StringIO()
+            traceback.print_exc(None, f)
+            result = "(error -- traceback follows)\n\n%s" % f.getvalue()
+        self.assertEqual(result,  expect, """
 When parsing: '%s'
 Expected:     '%s'
 Got:          '%s'
 """ % (arg, expect, result))
 
-    def test_roundtrip(self):
-        tests = [
+    @support.subTests('arg,expect', [
             ("foo", "foo"),
             ("foo=bar", "foo=bar"),
             ("   foo   ", "foo"),
@@ -276,23 +269,35 @@ def test_roundtrip(self):
             ("foo=bar;bar=baz", "foo=bar; bar=baz"),
             ('foo bar baz', "foo; bar; baz"),
             (r'foo="\"" bar="\\"', r'foo="\""; bar="\\"'),
+            ("föo=bär", 'föo="bär"'),
             ('foo,,,bar', 'foo, bar'),
             ('foo=bar,bar=baz', 'foo=bar, bar=baz'),
+            ("foo=\n", 'foo=""'),
+            ('foo="\n"', 'foo="\n"'),
+            ('foo=bar\n', 'foo=bar'),
+            ('foo="bar\n"', 'foo="bar\n"'),
+            ('foo=bar\nbaz', 'foo=bar; baz'),
+            ('foo="bar\nbaz"', 'foo="bar\nbaz"'),
 
             ('text/html; charset=iso-8859-1',
-             'text/html; charset="iso-8859-1"'),
+             'text/html; charset=iso-8859-1'),
+
+            ('text/html; charset="iso-8859/1"',
+             'text/html; charset="iso-8859/1"'),
 
             ('foo="bar"; port="80,81"; discard, bar=baz',
              'foo=bar; port="80,81"; discard, bar=baz'),
 
             (r'Basic realm="\"foo\\\\bar\""',
-             r'Basic; realm="\"foo\\\\bar\""')
-            ]
-
-        for arg, expect in tests:
-            input = split_header_words([arg])
-            res = join_header_words(input)
-            self.assertEqual(res, expect, """
+             r'Basic; realm="\"foo\\\\bar\""'),
+
+            ('n; foo="foo;_", bar="foo,_"',
+             'n; foo="foo;_", bar="foo,_"'),
+        ])
+    def test_roundtrip(self, arg, expect):
+        input = split_header_words([arg])
+        res = join_header_words(input)
+        self.assertEqual(res, expect, """
 When parsing: '%s'
 Expected:     '%s'
 Got:          '%s'
@@ -336,9 +341,9 @@ def test_constructor_with_str(self):
         self.assertEqual(c.filename, filename)
 
     def test_constructor_with_path_like(self):
-        filename = pathlib.Path(os_helper.TESTFN)
-        c = LWPCookieJar(filename)
-        self.assertEqual(c.filename, os.fspath(filename))
+        filename = os_helper.TESTFN
+        c = LWPCookieJar(os_helper.FakePath(filename))
+        self.assertEqual(c.filename, filename)
 
     def test_constructor_with_none(self):
         c = LWPCookieJar(None)
@@ -365,10 +370,63 @@ def test_lwp_valueless_cookie(self):
             c = LWPCookieJar()
             c.load(filename, ignore_discard=True)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
         self.assertEqual(c._cookies["www.acme.com"]["/"]["boo"].value, None)
 
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_lwp_filepermissions(self):
+        # Cookie file should only be readable by the creator
+        filename = os_helper.TESTFN
+        c = LWPCookieJar()
+        interact_netscape(c, "http://www.acme.com/", 'boo')
+        try:
+            c.save(filename, ignore_discard=True)
+            st = os.stat(filename)
+            self.assertEqual(stat.S_IMODE(st.st_mode), 0o600)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_mozilla_filepermissions(self):
+        # Cookie file should only be readable by the creator
+        filename = os_helper.TESTFN
+        c = MozillaCookieJar()
+        interact_netscape(c, "http://www.acme.com/", 'boo')
+        try:
+            c.save(filename, ignore_discard=True)
+            st = os.stat(filename)
+            self.assertEqual(stat.S_IMODE(st.st_mode), 0o600)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_cookie_files_are_truncated(self):
+        filename = os_helper.TESTFN
+        for cookiejar_class in (LWPCookieJar, MozillaCookieJar):
+            c = cookiejar_class(filename)
+
+            req = urllib.request.Request("http://www.acme.com/")
+            headers = ["Set-Cookie: pll_lang=en; Max-Age=31536000; path=/"]
+            res = FakeResponse(headers, "http://www.acme.com/")
+            c.extract_cookies(res, req)
+            self.assertEqual(len(c), 1)
+
+            try:
+                # Save the first version with contents:
+                c.save()
+                # Now, clear cookies and re-save:
+                c.clear()
+                c.save()
+                # Check that file was truncated:
+                c.load()
+            finally:
+                os_helper.unlink(filename)
+
+            self.assertEqual(len(c), 0)
+
     def test_bad_magic(self):
         # OSErrors (eg. file doesn't exist) are allowed to propagate
         filename = os_helper.TESTFN
@@ -392,8 +450,7 @@ def test_bad_magic(self):
                     c = cookiejar_class()
                     self.assertRaises(LoadError, c.load, filename)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
 
 class CookieTests(unittest.TestCase):
     # XXX
@@ -442,14 +499,7 @@ class CookieTests(unittest.TestCase):
 ##   just the 7 special TLD's listed in their spec. And folks rely on
 ##   that...
 
-    def test_domain_return_ok(self):
-        # test optimization: .domain_return_ok() should filter out most
-        # domains in the CookieJar before we try to access them (because that
-        # may require disk access -- in particular, with MSIECookieJar)
-        # This is only a rough check for performance reasons, so it's not too
-        # critical as long as it's sufficiently liberal.
-        pol = DefaultCookiePolicy()
-        for url, domain, ok in [
+    @support.subTests('url,domain,ok', [
             ("http://foo.bar.com/", "blah.com", False),
             ("http://foo.bar.com/", "rhubarb.blah.com", False),
             ("http://foo.bar.com/", "rhubarb.foo.bar.com", False),
@@ -469,11 +519,18 @@ def test_domain_return_ok(self):
             ("http://foo/", ".local", True),
             ("http://barfoo.com", ".foo.com", False),
             ("http://barfoo.com", "foo.com", False),
-            ]:
-            request = urllib.request.Request(url)
-            r = pol.domain_return_ok(domain, request)
-            if ok: self.assertTrue(r)
-            else: self.assertFalse(r)
+        ])
+    def test_domain_return_ok(self, url, domain, ok):
+        # test optimization: .domain_return_ok() should filter out most
+        # domains in the CookieJar before we try to access them (because that
+        # may require disk access -- in particular, with MSIECookieJar)
+        # This is only a rough check for performance reasons, so it's not too
+        # critical as long as it's sufficiently liberal.
+        pol = DefaultCookiePolicy()
+        request = urllib.request.Request(url)
+        r = pol.domain_return_ok(domain, request)
+        if ok: self.assertTrue(r)
+        else: self.assertFalse(r)
 
     def test_missing_value(self):
         # missing = sign in Cookie: header is regarded by Mozilla as a missing
@@ -489,7 +546,7 @@ def test_missing_value(self):
         self.assertIsNone(cookie.value)
         self.assertEqual(cookie.name, '"spam"')
         self.assertEqual(lwp_cookie_str(cookie), (
-            r'"spam"; path="/foo/"; domain="www.acme.com"; '
+            r'"spam"; path="/foo/"; domain=www.acme.com; '
             'path_spec; discard; version=0'))
         old_str = repr(c)
         c.save(ignore_expires=True, ignore_discard=True)
@@ -497,7 +554,7 @@ def test_missing_value(self):
             c = MozillaCookieJar(filename)
             c.revert(ignore_expires=True, ignore_discard=True)
         finally:
-            os.unlink(c.filename)
+            os_helper.unlink(c.filename)
         # cookies unchanged apart from lost info re. whether path was specified
         self.assertEqual(
             repr(c),
@@ -507,10 +564,7 @@ def test_missing_value(self):
         self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"),
                          '"spam"; eggs')
 
-    def test_rfc2109_handling(self):
-        # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
-        # dependent on policy settings
-        for rfc2109_as_netscape, rfc2965, version in [
+    @support.subTests('rfc2109_as_netscape,rfc2965,version', [
             # default according to rfc2965 if not explicitly specified
             (None, False, 0),
             (None, True, 1),
@@ -519,24 +573,27 @@ def test_rfc2109_handling(self):
             (False, True, 1),
             (True, False, 0),
             (True, True, 0),
-            ]:
-            policy = DefaultCookiePolicy(
-                rfc2109_as_netscape=rfc2109_as_netscape,
-                rfc2965=rfc2965)
-            c = CookieJar(policy)
-            interact_netscape(c, "http://www.example.com/", "ni=ni; Version=1")
-            try:
-                cookie = c._cookies["www.example.com"]["/"]["ni"]
-            except KeyError:
-                self.assertIsNone(version)  # didn't expect a stored cookie
-            else:
-                self.assertEqual(cookie.version, version)
-                # 2965 cookies are unaffected
-                interact_2965(c, "http://www.example.com/",
-                              "foo=bar; Version=1")
-                if rfc2965:
-                    cookie2965 = c._cookies["www.example.com"]["/"]["foo"]
-                    self.assertEqual(cookie2965.version, 1)
+        ])
+    def test_rfc2109_handling(self, rfc2109_as_netscape, rfc2965, version):
+        # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
+        # dependent on policy settings
+        policy = DefaultCookiePolicy(
+            rfc2109_as_netscape=rfc2109_as_netscape,
+            rfc2965=rfc2965)
+        c = CookieJar(policy)
+        interact_netscape(c, "http://www.example.com/", "ni=ni; Version=1")
+        try:
+            cookie = c._cookies["www.example.com"]["/"]["ni"]
+        except KeyError:
+            self.assertIsNone(version)  # didn't expect a stored cookie
+        else:
+            self.assertEqual(cookie.version, version)
+            # 2965 cookies are unaffected
+            interact_2965(c, "http://www.example.com/",
+                            "foo=bar; Version=1")
+            if rfc2965:
+                cookie2965 = c._cookies["www.example.com"]["/"]["foo"]
+                self.assertEqual(cookie2965.version, 1)
 
     def test_ns_parser(self):
         c = CookieJar()
@@ -597,8 +654,6 @@ def test_ns_parser_special_names(self):
         self.assertIn('expires', cookies)
         self.assertIn('version', cookies)
 
-    # TODO: RUSTPYTHON; need to update http library to remove warnings
-    @unittest.expectedFailure
     def test_expires(self):
         # if expires is in future, keep cookie...
         c = CookieJar()
@@ -706,8 +761,7 @@ def test_default_path_with_query(self):
         # Cookie is sent back to the same URI.
         self.assertEqual(interact_netscape(cj, uri), value)
 
-    def test_escape_path(self):
-        cases = [
+    @support.subTests('arg,result', [
             # quoted safe
             ("/foo%2f/bar", "/foo%2F/bar"),
             ("/foo%2F/bar", "/foo%2F/bar"),
@@ -727,9 +781,9 @@ def test_escape_path(self):
             ("/foo/bar\u00fc", "/foo/bar%C3%BC"),     # UTF-8 encoded
             # unicode
             ("/foo/bar\uabcd", "/foo/bar%EA%AF%8D"),  # UTF-8 encoded
-            ]
-        for arg, result in cases:
-            self.assertEqual(escape_path(arg), result)
+        ])
+    def test_escape_path(self, arg, result):
+        self.assertEqual(escape_path(arg), result)
 
     def test_request_path(self):
         # with parameters
@@ -923,6 +977,48 @@ def test_two_component_domain_ns(self):
 ##         self.assertEqual(len(c), 2)
         self.assertEqual(len(c), 4)
 
+    def test_localhost_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=localhost;")
+
+        self.assertEqual(len(c), 1)
+
+    def test_localhost_domain_contents(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=localhost;")
+
+        self.assertEqual(c._cookies[".localhost"]["/"]["foo"].value, "bar")
+
+    def test_localhost_domain_contents_2(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar;")
+
+        self.assertEqual(c._cookies["localhost.local"]["/"]["foo"].value, "bar")
+
+    def test_evil_nonlocal_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://evil.com", "foo=bar; domain=.localhost")
+
+        self.assertEqual(len(c), 0)
+
+    def test_evil_local_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=.evil.com")
+
+        self.assertEqual(len(c), 0)
+
+    def test_evil_local_domain_2(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=.someother.local")
+
+        self.assertEqual(len(c), 0)
+
     def test_two_component_domain_rfc2965(self):
         pol = DefaultCookiePolicy(rfc2965=True)
         c = CookieJar(pol)
@@ -1254,11 +1350,11 @@ def test_Cookie_iterator(self):
                       r'port="90,100, 80,8080"; '
                       r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
 
-        versions = [1, 1, 1, 0, 1]
-        names = ["bang", "foo", "foo", "spam", "foo"]
-        domains = [".sol.no", "blah.spam.org", "www.acme.com",
-                   "www.acme.com", "www.acme.com"]
-        paths = ["/", "/", "/", "/blah", "/blah/"]
+        versions = [1, 0, 1, 1, 1]
+        names = ["foo", "spam", "foo", "foo", "bang"]
+        domains = ["blah.spam.org", "www.acme.com", "www.acme.com",
+                   "www.acme.com", ".sol.no"]
+        paths = ["/", "/blah", "/blah/", "/", "/"]
 
         for i in range(4):
             i = 0
@@ -1331,7 +1427,7 @@ def cookiejar_from_cookie_headers(headers):
         self.assertIsNone(cookie.expires)
 
 
-class LWPCookieTests(unittest.TestCase):
+class LWPCookieTests(unittest.TestCase, ExtraAssertions):
     # Tests taken from libwww-perl, with a few modifications and additions.
 
     def test_netscape_example_1(self):
@@ -1423,7 +1519,7 @@ def test_netscape_example_1(self):
         h = req.get_header("Cookie")
         self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
         self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
-        self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
+        self.assertStartsWith(h, "SHIPPING=FEDEX;")
 
     def test_netscape_example_2(self):
         # Second Example transaction sequence:
@@ -1727,8 +1823,7 @@ def test_rejection(self):
             c = LWPCookieJar(policy=pol)
             c.load(filename, ignore_discard=True)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
 
         self.assertEqual(old, repr(c))
 
@@ -1787,8 +1882,7 @@ def save_and_restore(cj, ignore_discard):
                                          DefaultCookiePolicy(rfc2965=True))
                 new_c.load(ignore_discard=ignore_discard)
             finally:
-                try: os.unlink(filename)
-                except OSError: pass
+                os_helper.unlink(filename)
             return new_c
 
         new_c = save_and_restore(c, True)
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index d4a6eefe322..275578d53cb 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -1,4 +1,4 @@
-import sys
+import enum
 import errno
 from http import client, HTTPStatus
 import io
@@ -8,7 +8,6 @@
 import re
 import socket
 import threading
-import warnings
 
 import unittest
 from unittest import mock
@@ -17,16 +16,19 @@
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
-from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
+support.requires_working_socket(module=True)
 
 here = os.path.dirname(__file__)
 # Self-signed cert file for 'localhost'
-CERT_localhost = os.path.join(here, 'certdata/keycert.pem')
+CERT_localhost = os.path.join(here, 'certdata', 'keycert.pem')
 # Self-signed cert file for 'fakehostname'
-CERT_fakehostname = os.path.join(here, 'certdata/keycert2.pem')
+CERT_fakehostname = os.path.join(here, 'certdata', 'keycert2.pem')
 # Self-signed cert file for self-signed.pythontest.net
-CERT_selfsigned_pythontestdotnet = os.path.join(here, 'certdata/selfsigned_pythontestdotnet.pem')
+CERT_selfsigned_pythontestdotnet = os.path.join(
+    here, 'certdata', 'selfsigned_pythontestdotnet.pem',
+)
 
 # constants for testing chunked encoding
 chunked_start = (
@@ -133,7 +135,7 @@ def connect(self):
     def create_connection(self, *pos, **kw):
         return FakeSocket(*self.fake_socket_args)
 
-class HeaderTests(TestCase):
+class HeaderTests(TestCase, ExtraAssertions):
     def test_auto_headers(self):
         # Some headers are added automatically, but should not be added by
         # .request() if they are explicitly set.
@@ -272,7 +274,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertTrue(sock.data.startswith(expected))
+        self.assertStartsWith(sock.data, expected)
 
         expected = b'GET /foo HTTP/1.1\r\nHost: [2001:102A::]\r\n' \
                    b'Accept-Encoding: identity\r\n\r\n'
@@ -280,7 +282,23 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertTrue(sock.data.startswith(expected))
+        self.assertStartsWith(sock.data, expected)
+
+        expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]\r\n' \
+                   b'Accept-Encoding: identity\r\n\r\n'
+        conn = client.HTTPConnection('[fe80::%2]')
+        sock = FakeSocket('')
+        conn.sock = sock
+        conn.request('GET', '/foo')
+        self.assertStartsWith(sock.data, expected)
+
+        expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]:81\r\n' \
+                   b'Accept-Encoding: identity\r\n\r\n'
+        conn = client.HTTPConnection('[fe80::%2]:81')
+        sock = FakeSocket('')
+        conn.sock = sock
+        conn.request('GET', '/foo')
+        self.assertStartsWith(sock.data, expected)
 
     def test_malformed_headers_coped_with(self):
         # Issue 19996
@@ -318,9 +336,9 @@ def test_parse_all_octets(self):
         self.assertIsNotNone(resp.getheader('obs-text'))
         self.assertIn('obs-text', resp.msg)
         for folded in (resp.getheader('obs-fold'), resp.msg['obs-fold']):
-            self.assertTrue(folded.startswith('text'))
+            self.assertStartsWith(folded, 'text')
             self.assertIn(' folded with space', folded)
-            self.assertTrue(folded.endswith('folded with tab'))
+            self.assertEndsWith(folded, 'folded with tab')
 
     def test_invalid_headers(self):
         conn = client.HTTPConnection('example.com')
@@ -520,11 +538,203 @@ def _parse_chunked(self, data):
         return b''.join(body)
 
 
-class BasicTest(TestCase):
+class BasicTest(TestCase, ExtraAssertions):
     def test_dir_with_added_behavior_on_status(self):
         # see issue40084
         self.assertTrue({'description', 'name', 'phrase', 'value'} <= set(dir(HTTPStatus(404))))
 
+    def test_simple_httpstatus(self):
+        class CheckedHTTPStatus(enum.IntEnum):
+            """HTTP status codes and reason phrases
+
+            Status codes from the following RFCs are all observed:
+
+                * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+                * RFC 6585: Additional HTTP Status Codes
+                * RFC 3229: Delta encoding in HTTP
+                * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
+                * RFC 5842: Binding Extensions to WebDAV
+                * RFC 7238: Permanent Redirect
+                * RFC 2295: Transparent Content Negotiation in HTTP
+                * RFC 2774: An HTTP Extension Framework
+                * RFC 7725: An HTTP Status Code to Report Legal Obstacles
+                * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
+                * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
+                * RFC 8297: An HTTP Status Code for Indicating Hints
+                * RFC 8470: Using Early Data in HTTP
+            """
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+
+            @property
+            def is_informational(self):
+                return 100 <= self <= 199
+
+            @property
+            def is_success(self):
+                return 200 <= self <= 299
+
+            @property
+            def is_redirection(self):
+                return 300 <= self <= 399
+
+            @property
+            def is_client_error(self):
+                return 400 <= self <= 499
+
+            @property
+            def is_server_error(self):
+                return 500 <= self <= 599
+
+            # informational
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            SWITCHING_PROTOCOLS = (101, 'Switching Protocols',
+                    'Switching to new protocol; obey Upgrade header')
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            # success
+            OK = 200, 'OK', 'Request fulfilled, document follows'
+            CREATED = 201, 'Created', 'Document created, URL follows'
+            ACCEPTED = (202, 'Accepted',
+                'Request accepted, processing continues off-line')
+            NON_AUTHORITATIVE_INFORMATION = (203,
+                'Non-Authoritative Information', 'Request fulfilled from cache')
+            NO_CONTENT = 204, 'No Content', 'Request fulfilled, nothing follows'
+            RESET_CONTENT = 205, 'Reset Content', 'Clear input form for further input'
+            PARTIAL_CONTENT = 206, 'Partial Content', 'Partial content follows'
+            MULTI_STATUS = 207, 'Multi-Status'
+            ALREADY_REPORTED = 208, 'Already Reported'
+            IM_USED = 226, 'IM Used'
+            # redirection
+            MULTIPLE_CHOICES = (300, 'Multiple Choices',
+                'Object has several resources -- see URI list')
+            MOVED_PERMANENTLY = (301, 'Moved Permanently',
+                'Object moved permanently -- see URI list')
+            FOUND = 302, 'Found', 'Object moved temporarily -- see URI list'
+            SEE_OTHER = 303, 'See Other', 'Object moved -- see Method and URL list'
+            NOT_MODIFIED = (304, 'Not Modified',
+                'Document has not changed since given time')
+            USE_PROXY = (305, 'Use Proxy',
+                'You must use proxy specified in Location to access this resource')
+            TEMPORARY_REDIRECT = (307, 'Temporary Redirect',
+                'Object moved temporarily -- see URI list')
+            PERMANENT_REDIRECT = (308, 'Permanent Redirect',
+                'Object moved permanently -- see URI list')
+            # client error
+            BAD_REQUEST = (400, 'Bad Request',
+                'Bad request syntax or unsupported method')
+            UNAUTHORIZED = (401, 'Unauthorized',
+                'No permission -- see authorization schemes')
+            PAYMENT_REQUIRED = (402, 'Payment Required',
+                'No payment -- see charging schemes')
+            FORBIDDEN = (403, 'Forbidden',
+                'Request forbidden -- authorization will not help')
+            NOT_FOUND = (404, 'Not Found',
+                'Nothing matches the given URI')
+            METHOD_NOT_ALLOWED = (405, 'Method Not Allowed',
+                'Specified method is invalid for this resource')
+            NOT_ACCEPTABLE = (406, 'Not Acceptable',
+                'URI not available in preferred format')
+            PROXY_AUTHENTICATION_REQUIRED = (407,
+                'Proxy Authentication Required',
+                'You must authenticate with this proxy before proceeding')
+            REQUEST_TIMEOUT = (408, 'Request Timeout',
+                'Request timed out; try again later')
+            CONFLICT = 409, 'Conflict', 'Request conflict'
+            GONE = (410, 'Gone',
+                'URI no longer exists and has been permanently removed')
+            LENGTH_REQUIRED = (411, 'Length Required',
+                'Client must specify Content-Length')
+            PRECONDITION_FAILED = (412, 'Precondition Failed',
+                'Precondition in headers is false')
+            CONTENT_TOO_LARGE = (413, 'Content Too Large',
+                'Content is too large')
+            REQUEST_ENTITY_TOO_LARGE = CONTENT_TOO_LARGE
+            URI_TOO_LONG = (414, 'URI Too Long', 'URI is too long')
+            REQUEST_URI_TOO_LONG = URI_TOO_LONG
+            UNSUPPORTED_MEDIA_TYPE = (415, 'Unsupported Media Type',
+                'Entity body in unsupported format')
+            RANGE_NOT_SATISFIABLE = (416,
+                'Range Not Satisfiable',
+                'Cannot satisfy request range')
+            REQUESTED_RANGE_NOT_SATISFIABLE = RANGE_NOT_SATISFIABLE
+            EXPECTATION_FAILED = (417, 'Expectation Failed',
+                'Expect condition could not be satisfied')
+            IM_A_TEAPOT = (418, 'I\'m a Teapot',
+                'Server refuses to brew coffee because it is a teapot.')
+            MISDIRECTED_REQUEST = (421, 'Misdirected Request',
+                'Server is not able to produce a response')
+            UNPROCESSABLE_CONTENT = 422, 'Unprocessable Content'
+            UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
+            LOCKED = 423, 'Locked'
+            FAILED_DEPENDENCY = 424, 'Failed Dependency'
+            TOO_EARLY = 425, 'Too Early'
+            UPGRADE_REQUIRED = 426, 'Upgrade Required'
+            PRECONDITION_REQUIRED = (428, 'Precondition Required',
+                'The origin server requires the request to be conditional')
+            TOO_MANY_REQUESTS = (429, 'Too Many Requests',
+                'The user has sent too many requests in '
+                'a given amount of time ("rate limiting")')
+            REQUEST_HEADER_FIELDS_TOO_LARGE = (431,
+                'Request Header Fields Too Large',
+                'The server is unwilling to process the request because its header '
+                'fields are too large')
+            UNAVAILABLE_FOR_LEGAL_REASONS = (451,
+                'Unavailable For Legal Reasons',
+                'The server is denying access to the '
+                'resource as a consequence of a legal demand')
+            # server errors
+            INTERNAL_SERVER_ERROR = (500, 'Internal Server Error',
+                'Server got itself in trouble')
+            NOT_IMPLEMENTED = (501, 'Not Implemented',
+                'Server does not support this operation')
+            BAD_GATEWAY = (502, 'Bad Gateway',
+                'Invalid responses from another server/proxy')
+            SERVICE_UNAVAILABLE = (503, 'Service Unavailable',
+                'The server cannot process the request due to a high load')
+            GATEWAY_TIMEOUT = (504, 'Gateway Timeout',
+                'The gateway server did not receive a timely response')
+            HTTP_VERSION_NOT_SUPPORTED = (505, 'HTTP Version Not Supported',
+                'Cannot fulfill request')
+            VARIANT_ALSO_NEGOTIATES = 506, 'Variant Also Negotiates'
+            INSUFFICIENT_STORAGE = 507, 'Insufficient Storage'
+            LOOP_DETECTED = 508, 'Loop Detected'
+            NOT_EXTENDED = 510, 'Not Extended'
+            NETWORK_AUTHENTICATION_REQUIRED = (511,
+                'Network Authentication Required',
+                'The client needs to authenticate to gain network access')
+        enum._test_simple_enum(CheckedHTTPStatus, HTTPStatus)
+
+    def test_httpstatus_range(self):
+        """Checks that the statuses are in the 100-599 range"""
+
+        for member in HTTPStatus.__members__.values():
+            self.assertGreaterEqual(member, 100)
+            self.assertLessEqual(member, 599)
+
+    def test_httpstatus_category(self):
+        """Checks that the statuses belong to the standard categories"""
+
+        categories = (
+            ((100, 199), "is_informational"),
+            ((200, 299), "is_success"),
+            ((300, 399), "is_redirection"),
+            ((400, 499), "is_client_error"),
+            ((500, 599), "is_server_error"),
+        )
+        for member in HTTPStatus.__members__.values():
+            for (lower, upper), category in categories:
+                category_indicator = getattr(member, category)
+                if lower <= member <= upper:
+                    self.assertTrue(category_indicator)
+                else:
+                    self.assertFalse(category_indicator)
+
     def test_status_lines(self):
         # Test HTTP status lines
 
@@ -780,8 +990,7 @@ def test_send_file(self):
             sock = FakeSocket(body)
             conn.sock = sock
             conn.request('GET', '/foo', body)
-            self.assertTrue(sock.data.startswith(expected), '%r != %r' %
-                    (sock.data[:len(expected)], expected))
+            self.assertStartsWith(sock.data, expected)
 
     def test_send(self):
         expected = b'this is a test this is only a test'
@@ -872,6 +1081,25 @@ def test_chunked(self):
         self.assertEqual(resp.read(), expected)
         resp.close()
 
+        # Explicit full read
+        for n in (-123, -1, None):
+            with self.subTest('full read', n=n):
+                sock = FakeSocket(chunked_start + last_chunk + chunked_end)
+                resp = client.HTTPResponse(sock, method="GET")
+                resp.begin()
+                self.assertTrue(resp.chunked)
+                self.assertEqual(resp.read(n), expected)
+                resp.close()
+
+        # Read first chunk
+        with self.subTest('read1(-1)'):
+            sock = FakeSocket(chunked_start + last_chunk + chunked_end)
+            resp = client.HTTPResponse(sock, method="GET")
+            resp.begin()
+            self.assertTrue(resp.chunked)
+            self.assertEqual(resp.read1(-1), b"hello worl")
+            resp.close()
+
         # Various read sizes
         for n in range(1, 12):
             sock = FakeSocket(chunked_start + last_chunk + chunked_end)
@@ -1227,6 +1455,72 @@ def run_server():
         thread.join()
         self.assertEqual(result, b"proxied data\n")
 
+    def test_large_content_length(self):
+        serv = socket.create_server((HOST, 0))
+        self.addCleanup(serv.close)
+
+        def run_server():
+            [conn, address] = serv.accept()
+            with conn:
+                while conn.recv(1024):
+                    conn.sendall(
+                        b"HTTP/1.1 200 Ok\r\n"
+                        b"Content-Length: %d\r\n"
+                        b"\r\n" % size)
+                    conn.sendall(b'A' * (size//3))
+                    conn.sendall(b'B' * (size - size//3))
+
+        thread = threading.Thread(target=run_server)
+        thread.start()
+        self.addCleanup(thread.join, 1.0)
+
+        conn = client.HTTPConnection(*serv.getsockname())
+        try:
+            for w in range(15, 27):
+                size = 1 << w
+                conn.request("GET", "/")
+                with conn.getresponse() as response:
+                    self.assertEqual(len(response.read()), size)
+        finally:
+            conn.close()
+            thread.join(1.0)
+
+    def test_large_content_length_truncated(self):
+        serv = socket.create_server((HOST, 0))
+        self.addCleanup(serv.close)
+
+        def run_server():
+            while True:
+                [conn, address] = serv.accept()
+                with conn:
+                    conn.recv(1024)
+                    if not size:
+                        break
+                    conn.sendall(
+                        b"HTTP/1.1 200 Ok\r\n"
+                        b"Content-Length: %d\r\n"
+                        b"\r\n"
+                        b"Text" % size)
+
+        thread = threading.Thread(target=run_server)
+        thread.start()
+        self.addCleanup(thread.join, 1.0)
+
+        conn = client.HTTPConnection(*serv.getsockname())
+        try:
+            for w in range(18, 65):
+                size = 1 << w
+                conn.request("GET", "/")
+                with conn.getresponse() as response:
+                    self.assertRaises(client.IncompleteRead, response.read)
+                conn.close()
+        finally:
+            conn.close()
+            size = 0
+            conn.request("GET", "/")
+            conn.close()
+            thread.join(1.0)
+
     def test_putrequest_override_domain_validation(self):
         """
         It should be possible to override the default validation
@@ -1266,7 +1560,7 @@ def _encode_request(self, str_url):
         conn.putrequest('GET', '/☃')
 
 
-class ExtendedReadTest(TestCase):
+class ExtendedReadTest(TestCase, ExtraAssertions):
     """
     Test peek(), read1(), readline()
     """
@@ -1325,7 +1619,7 @@ def mypeek(n=-1):
                 # then unbounded peek
                 p2 = resp.peek()
                 self.assertGreaterEqual(len(p2), len(p))
-                self.assertTrue(p2.startswith(p))
+                self.assertStartsWith(p2, p)
                 next = resp.read(len(p2))
                 self.assertEqual(next, p2)
             else:
@@ -1340,18 +1634,22 @@ def test_readline(self):
         resp = self.resp
         self._verify_readline(self.resp.readline, self.lines_expected)
 
-    def _verify_readline(self, readline, expected):
+    def test_readline_without_limit(self):
+        self._verify_readline(self.resp.readline, self.lines_expected, limit=-1)
+
+    def _verify_readline(self, readline, expected, limit=5):
         all = []
         while True:
             # short readlines
-            line = readline(5)
+            line = readline(limit)
             if line and line != b"foo":
                 if len(line) < 5:
-                    self.assertTrue(line.endswith(b"\n"))
+                    self.assertEndsWith(line, b"\n")
             all.append(line)
             if not line:
                 break
         self.assertEqual(b"".join(all), expected)
+        self.assertTrue(self.resp.isclosed())
 
     def test_read1(self):
         resp = self.resp
@@ -1371,6 +1669,7 @@ def test_read1_unbounded(self):
                 break
             all.append(data)
         self.assertEqual(b"".join(all), self.lines_expected)
+        self.assertTrue(resp.isclosed())
 
     def test_read1_bounded(self):
         resp = self.resp
@@ -1382,15 +1681,22 @@ def test_read1_bounded(self):
             self.assertLessEqual(len(data), 10)
             all.append(data)
         self.assertEqual(b"".join(all), self.lines_expected)
+        self.assertTrue(resp.isclosed())
 
     def test_read1_0(self):
         self.assertEqual(self.resp.read1(0), b"")
+        self.assertFalse(self.resp.isclosed())
 
     def test_peek_0(self):
         p = self.resp.peek(0)
         self.assertLessEqual(0, len(p))
 
 
+class ExtendedReadTestContentLengthKnown(ExtendedReadTest):
+    _header, _body = ExtendedReadTest.lines.split('\r\n\r\n', 1)
+    lines = _header + f'\r\nContent-Length: {len(_body)}\r\n\r\n' + _body
+
+
 class ExtendedReadTestChunked(ExtendedReadTest):
     """
     Test peek(), read1(), readline() in chunked mode
@@ -1447,7 +1753,7 @@ def readline(self, limit):
             raise
 
 
-class OfflineTest(TestCase):
+class OfflineTest(TestCase, ExtraAssertions):
     def test_all(self):
         # Documented objects defined in the module should be in __all__
         expected = {"responses"}  # Allowlist documented dict() object
@@ -1500,13 +1806,17 @@ def test_client_constants(self):
             'GONE',
             'LENGTH_REQUIRED',
             'PRECONDITION_FAILED',
+            'CONTENT_TOO_LARGE',
             'REQUEST_ENTITY_TOO_LARGE',
+            'URI_TOO_LONG',
             'REQUEST_URI_TOO_LONG',
             'UNSUPPORTED_MEDIA_TYPE',
+            'RANGE_NOT_SATISFIABLE',
             'REQUESTED_RANGE_NOT_SATISFIABLE',
             'EXPECTATION_FAILED',
             'IM_A_TEAPOT',
             'MISDIRECTED_REQUEST',
+            'UNPROCESSABLE_CONTENT',
             'UNPROCESSABLE_ENTITY',
             'LOCKED',
             'FAILED_DEPENDENCY',
@@ -1529,7 +1839,7 @@ def test_client_constants(self):
         ]
         for const in expected:
             with self.subTest(constant=const):
-                self.assertTrue(hasattr(client, const))
+                self.assertHasAttr(client, const)
 
 
 class SourceAddressTest(TestCase):
@@ -1766,6 +2076,7 @@ def test_networked_good_cert(self):
             h.close()
             self.assertIn('nginx', server_string)
 
+    @support.requires_resource('walltime')
     def test_networked_bad_cert(self):
         # We feed a "CA" cert that is unrelated to the server's cert
         import ssl
@@ -1778,7 +2089,6 @@ def test_networked_bad_cert(self):
                 h.request('GET', '/')
             self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
 
-    @unittest.skipIf(sys.platform == 'darwin', 'Occasionally success on macOS')
     def test_local_unknown_cert(self):
         # The custom cert isn't known to the default trust bundle
         import ssl
@@ -1788,8 +2098,9 @@ def test_local_unknown_cert(self):
             h.request('GET', '/')
         self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON http.client.RemoteDisconnected: Remote end closed connection without response
     def test_local_good_hostname(self):
-        # The (valid) cert validates the HTTP hostname
+        # The (valid) cert validates the HTTPS hostname
         import ssl
         server = self.make_server(CERT_localhost)
         context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
@@ -1801,8 +2112,9 @@ def test_local_good_hostname(self):
         self.addCleanup(resp.close)
         self.assertEqual(resp.status, 404)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON http.client.RemoteDisconnected: Remote end closed connection without response
     def test_local_bad_hostname(self):
-        # The (valid) cert doesn't validate the HTTP hostname
+        # The (valid) cert doesn't validate the HTTPS hostname
         import ssl
         server = self.make_server(CERT_fakehostname)
         context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
@@ -1810,38 +2122,21 @@ def test_local_bad_hostname(self):
         h = client.HTTPSConnection('localhost', server.port, context=context)
         with self.assertRaises(ssl.CertificateError):
             h.request('GET', '/')
-        # Same with explicit check_hostname=True
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=True)
+
+        # Same with explicit context.check_hostname=True
+        context.check_hostname = True
+        h = client.HTTPSConnection('localhost', server.port, context=context)
         with self.assertRaises(ssl.CertificateError):
             h.request('GET', '/')
-        # With check_hostname=False, the mismatching is ignored
-        context.check_hostname = False
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=False)
-        h.request('GET', '/nonexistent')
-        resp = h.getresponse()
-        resp.close()
-        h.close()
-        self.assertEqual(resp.status, 404)
-        # The context's check_hostname setting is used if one isn't passed to
-        # HTTPSConnection.
+
+        # With context.check_hostname=False, the mismatching is ignored
         context.check_hostname = False
         h = client.HTTPSConnection('localhost', server.port, context=context)
         h.request('GET', '/nonexistent')
         resp = h.getresponse()
-        self.assertEqual(resp.status, 404)
         resp.close()
         h.close()
-        # Passing check_hostname to HTTPSConnection should override the
-        # context's setting.
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=True)
-        with self.assertRaises(ssl.CertificateError):
-            h.request('GET', '/')
+        self.assertEqual(resp.status, 404)
 
     @unittest.skipIf(not hasattr(client, 'HTTPSConnection'),
                      'http.client.HTTPSConnection not available')
@@ -1877,11 +2172,9 @@ def test_tls13_pha(self):
         self.assertIs(h._context, context)
         self.assertFalse(h._context.post_handshake_auth)
 
-        with warnings.catch_warnings():
-            warnings.filterwarnings('ignore', 'key_file, cert_file and check_hostname are deprecated',
-                                    DeprecationWarning)
-            h = client.HTTPSConnection('localhost', 443, context=context,
-                                       cert_file=CERT_localhost)
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT, cert_file=CERT_localhost)
+        context.post_handshake_auth = True
+        h = client.HTTPSConnection('localhost', 443, context=context)
         self.assertTrue(h._context.post_handshake_auth)
 
 
@@ -2016,14 +2309,15 @@ def test_getting_header_defaultint(self):
         header = self.resp.getheader('No-Such-Header',default=42)
         self.assertEqual(header, 42)
 
-class TunnelTests(TestCase):
+class TunnelTests(TestCase, ExtraAssertions):
     def setUp(self):
         response_text = (
-            'HTTP/1.0 200 OK\r\n\r\n' # Reply to CONNECT
+            'HTTP/1.1 200 OK\r\n\r\n' # Reply to CONNECT
             'HTTP/1.1 200 OK\r\n' # Reply to HEAD
             'Content-Length: 42\r\n\r\n'
         )
         self.host = 'proxy.com'
+        self.port = client.HTTP_PORT
         self.conn = client.HTTPConnection(self.host)
         self.conn._create_connection = self._create_connection(response_text)
 
@@ -2035,15 +2329,45 @@ def create_connection(address, timeout=None, source_address=None):
             return FakeSocket(response_text, host=address[0], port=address[1])
         return create_connection
 
-    def test_set_tunnel_host_port_headers(self):
+    def test_set_tunnel_host_port_headers_add_host_missing(self):
         tunnel_host = 'destination.com'
         tunnel_port = 8888
         tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)'}
+        tunnel_headers_after = tunnel_headers.copy()
+        tunnel_headers_after['Host'] = '%s:%d' % (tunnel_host, tunnel_port)
         self.conn.set_tunnel(tunnel_host, port=tunnel_port,
                              headers=tunnel_headers)
         self.conn.request('HEAD', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
-        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertEqual(self.conn._tunnel_host, tunnel_host)
+        self.assertEqual(self.conn._tunnel_port, tunnel_port)
+        self.assertEqual(self.conn._tunnel_headers, tunnel_headers_after)
+
+    def test_set_tunnel_host_port_headers_set_host_identical(self):
+        tunnel_host = 'destination.com'
+        tunnel_port = 8888
+        tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)',
+                          'Host': '%s:%d' % (tunnel_host, tunnel_port)}
+        self.conn.set_tunnel(tunnel_host, port=tunnel_port,
+                             headers=tunnel_headers)
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertEqual(self.conn._tunnel_host, tunnel_host)
+        self.assertEqual(self.conn._tunnel_port, tunnel_port)
+        self.assertEqual(self.conn._tunnel_headers, tunnel_headers)
+
+    def test_set_tunnel_host_port_headers_set_host_different(self):
+        tunnel_host = 'destination.com'
+        tunnel_port = 8888
+        tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)',
+                          'Host': '%s:%d' % ('example.com', 4200)}
+        self.conn.set_tunnel(tunnel_host, port=tunnel_port,
+                             headers=tunnel_headers)
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
         self.assertEqual(self.conn._tunnel_host, tunnel_host)
         self.assertEqual(self.conn._tunnel_port, tunnel_port)
         self.assertEqual(self.conn._tunnel_headers, tunnel_headers)
@@ -2055,17 +2379,96 @@ def test_disallow_set_tunnel_after_connect(self):
                           'destination.com')
 
     def test_connect_with_tunnel(self):
-        self.conn.set_tunnel('destination.com')
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_with_default_port(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'), port=d[b'port'])
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_with_nonstandard_port(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': 8888,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'), port=d[b'port'])
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s:%(port)d\r\n' % d,
+                      self.conn.sock.data)
+
+    # This request is not RFC-valid, but it's been possible with the library
+    # for years, so don't break it unexpectedly... This also tests
+    # case-insensitivity when injecting Host: headers if they're missing.
+    def test_connect_with_tunnel_with_different_host_header(self):
+        d = {
+            b'host': b'destination.com',
+            b'tunnel_host_header': b'example.com:9876',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(
+            d[b'host'].decode('ascii'),
+            headers={'HOST': d[b'tunnel_host_header'].decode('ascii')})
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'HOST: %(tunnel_host_header)s\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_different_host(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_idna(self):
+        dest = '\u03b4\u03c0\u03b8.gr'
+        dest_port = b'%s:%d' % (dest.encode('idna'), client.HTTP_PORT)
+        expected = b'CONNECT %s HTTP/1.1\r\nHost: %s\r\n\r\n' % (
+            dest_port, dest_port)
+        self.conn.set_tunnel(dest)
         self.conn.request('HEAD', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
         self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
-        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
-        # issue22095
-        self.assertNotIn(b'Host: destination.com:None', self.conn.sock.data)
-        self.assertIn(b'Host: destination.com', self.conn.sock.data)
-
-        # This test should be removed when CONNECT gets the HTTP/1.1 blessing
-        self.assertNotIn(b'Host: proxy.com', self.conn.sock.data)
+        self.assertIn(expected, self.conn.sock.data)
 
     def test_tunnel_connect_single_send_connection_setup(self):
         """Regresstion test for https://bugs.python.org/issue43332."""
@@ -2080,17 +2483,39 @@ def test_tunnel_connect_single_send_connection_setup(self):
                 msg=f'unexpected number of send calls: {mock_send.mock_calls}')
         proxy_setup_data_sent = mock_send.mock_calls[0][1][0]
         self.assertIn(b'CONNECT destination.com', proxy_setup_data_sent)
-        self.assertTrue(
-                proxy_setup_data_sent.endswith(b'\r\n\r\n'),
+        self.assertEndsWith(proxy_setup_data_sent, b'\r\n\r\n',
                 msg=f'unexpected proxy data sent {proxy_setup_data_sent!r}')
 
     def test_connect_put_request(self):
-        self.conn.set_tunnel('destination.com')
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('PUT', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'PUT / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_put_request_ipv6(self):
+        self.conn.set_tunnel('[1:2:3::4]', 1234)
+        self.conn.request('PUT', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
+        self.assertIn(b'CONNECT [1:2:3::4]:1234', self.conn.sock.data)
+        self.assertIn(b'Host: [1:2:3::4]:1234', self.conn.sock.data)
+
+    def test_connect_put_request_ipv6_port(self):
+        self.conn.set_tunnel('[1:2:3::4]:1234')
         self.conn.request('PUT', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
         self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
-        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
-        self.assertIn(b'Host: destination.com', self.conn.sock.data)
+        self.assertIn(b'CONNECT [1:2:3::4]:1234', self.conn.sock.data)
+        self.assertIn(b'Host: [1:2:3::4]:1234', self.conn.sock.data)
 
     def test_tunnel_debuglog(self):
         expected_header = 'X-Dummy: 1'
@@ -2105,6 +2530,56 @@ def test_tunnel_debuglog(self):
         lines = output.getvalue().splitlines()
         self.assertIn('header: {}'.format(expected_header), lines)
 
+    def test_proxy_response_headers(self):
+        expected_header = ('X-Dummy', '1')
+        response_text = (
+            'HTTP/1.0 200 OK\r\n'
+            '{0}\r\n\r\n'.format(':'.join(expected_header))
+        )
+
+        self.conn._create_connection = self._create_connection(response_text)
+        self.conn.set_tunnel('destination.com')
+
+        self.conn.request('PUT', '/', '')
+        headers = self.conn.get_proxy_response_headers()
+        self.assertIn(expected_header, headers.items())
+
+    def test_no_proxy_response_headers(self):
+        expected_header = ('X-Dummy', '1')
+        response_text = (
+            'HTTP/1.0 200 OK\r\n'
+            '{0}\r\n\r\n'.format(':'.join(expected_header))
+        )
+
+        self.conn._create_connection = self._create_connection(response_text)
+
+        self.conn.request('PUT', '/', '')
+        headers = self.conn.get_proxy_response_headers()
+        self.assertIsNone(headers)
+
+    def test_tunnel_leak(self):
+        sock = None
+
+        def _create_connection(address, timeout=None, source_address=None):
+            nonlocal sock
+            sock = FakeSocket(
+                'HTTP/1.1 404 NOT FOUND\r\n\r\n',
+                host=address[0],
+                port=address[1],
+            )
+            return sock
+
+        self.conn._create_connection = _create_connection
+        self.conn.set_tunnel('destination.com')
+        exc = None
+        try:
+            self.conn.request('HEAD', '/', '')
+        except OSError as e:
+            # keeping a reference to exc keeps response alive in the traceback
+            exc = e
+        self.assertIsNotNone(exc)
+        self.assertTrue(sock.file_closed)
+
 
 if __name__ == '__main__':
     unittest.main(verbosity=2)
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
index cd689492ca3..63b778d8b97 100644
--- a/Lib/test/test_httpservers.py
+++ b/Lib/test/test_httpservers.py
@@ -8,6 +8,7 @@
      SimpleHTTPRequestHandler, CGIHTTPRequestHandler
 from http import server, HTTPStatus
 
+import contextlib
 import os
 import socket
 import sys
@@ -26,13 +27,16 @@
 import datetime
 import threading
 from unittest import mock
-from io import BytesIO
+from io import BytesIO, StringIO
 
 import unittest
 from test import support
-from test.support import os_helper
-from test.support import threading_helper
+from test.support import (
+    is_apple, os_helper, requires_subprocess, threading_helper
+)
+from test.support.testcase import ExtraAssertions
 
+support.requires_working_socket(module=True)
 
 class NoLogRequestHandler:
     def log_message(self, *args):
@@ -64,7 +68,7 @@ def stop(self):
         self.join()
 
 
-class BaseTestCase(unittest.TestCase):
+class BaseTestCase(unittest.TestCase, ExtraAssertions):
     def setUp(self):
         self._threads = threading_helper.threading_setup()
         os.environ = os_helper.EnvironmentVarGuard()
@@ -163,6 +167,27 @@ def test_version_digits(self):
         res = self.con.getresponse()
         self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
 
+    def test_version_signs_and_underscores(self):
+        self.con._http_vsn_str = 'HTTP/-9_9_9.+9_9_9'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
+    def test_major_version_number_too_long(self):
+        self.con._http_vsn_str = 'HTTP/909876543210.0'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
+    def test_minor_version_number_too_long(self):
+        self.con._http_vsn_str = 'HTTP/1.909876543210'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
     def test_version_none_get(self):
         self.con._http_vsn_str = ''
         self.con.putrequest('GET', '/')
@@ -292,6 +317,44 @@ def test_head_via_send_error(self):
             self.assertEqual(b'', data)
 
 
+class HTTP09ServerTestCase(BaseTestCase):
+
+    class request_handler(NoLogRequestHandler, BaseHTTPRequestHandler):
+        """Request handler for HTTP/0.9 server."""
+
+        def do_GET(self):
+            self.wfile.write(f'OK: here is {self.path}\r\n'.encode())
+
+    def setUp(self):
+        super().setUp()
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock = self.enterContext(self.sock)
+        self.sock.connect((self.HOST, self.PORT))
+
+    def test_simple_get(self):
+        self.sock.send(b'GET /index.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertEqual(res, b"OK: here is /index.html\r\n")
+
+    def test_invalid_request(self):
+        self.sock.send(b'POST /index.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertIn(b"Bad HTTP/0.9 request type ('POST')", res)
+
+    def test_single_request(self):
+        self.sock.send(b'GET /foo.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertEqual(res, b"OK: here is /foo.html\r\n")
+
+        # Ignore errors if the connection is already closed,
+        # as this is the expected behavior of HTTP/0.9.
+        with contextlib.suppress(OSError):
+            self.sock.send(b'GET /bar.html\r\n')
+            res = self.sock.recv(1024)
+            # The server should not process our request.
+            self.assertEqual(res, b'')
+
+
 class RequestHandlerLoggingTestCase(BaseTestCase):
     class request_handler(BaseHTTPRequestHandler):
         protocol_version = 'HTTP/1.1'
@@ -312,8 +375,7 @@ def test_get(self):
             self.con.request('GET', '/')
             self.con.getresponse()
 
-        self.assertTrue(
-            err.getvalue().endswith('"GET / HTTP/1.1" 200 -\n'))
+        self.assertEndsWith(err.getvalue(), '"GET / HTTP/1.1" 200 -\n')
 
     def test_err(self):
         self.con = http.client.HTTPConnection(self.HOST, self.PORT)
@@ -324,8 +386,8 @@ def test_err(self):
             self.con.getresponse()
 
         lines = err.getvalue().split('\n')
-        self.assertTrue(lines[0].endswith('code 404, message File not found'))
-        self.assertTrue(lines[1].endswith('"ERROR / HTTP/1.1" 404 -'))
+        self.assertEndsWith(lines[0], 'code 404, message File not found')
+        self.assertEndsWith(lines[1], '"ERROR / HTTP/1.1" 404 -')
 
 
 class SimpleHTTPServerTestCase(BaseTestCase):
@@ -333,7 +395,7 @@ class request_handler(NoLogRequestHandler, SimpleHTTPRequestHandler):
         pass
 
     def setUp(self):
-        BaseTestCase.setUp(self)
+        super().setUp()
         self.cwd = os.getcwd()
         basetempdir = tempfile.gettempdir()
         os.chdir(basetempdir)
@@ -361,7 +423,7 @@ def tearDown(self):
             except:
                 pass
         finally:
-            BaseTestCase.tearDown(self)
+            super().tearDown()
 
     def check_status_and_reason(self, response, status, data=None):
         def close_conn():
@@ -388,35 +450,175 @@ def close_conn():
         reader.close()
         return body
 
-    @unittest.skipIf(sys.platform == 'darwin',
-                     'undecodable name cannot always be decoded on macOS')
-    @unittest.skipIf(sys.platform == 'win32',
-                     'undecodable name cannot be decoded on win32')
-    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
-                         'need os_helper.TESTFN_UNDECODABLE')
-    def test_undecodable_filename(self):
+    def check_list_dir_dirname(self, dirname, quotedname=None):
+        fullpath = os.path.join(self.tempdir, dirname)
+        try:
+            os.mkdir(os.path.join(self.tempdir, dirname))
+        except (OSError, UnicodeEncodeError):
+            self.skipTest(f'Can not create directory {dirname!a} '
+                          f'on current file system')
+
+        if quotedname is None:
+            quotedname = urllib.parse.quote(dirname, errors='surrogatepass')
+        response = self.request(self.base_url + '/' + quotedname + '/')
+        body = self.check_status_and_reason(response, HTTPStatus.OK)
+        displaypath = html.escape(f'{self.base_url}/{dirname}/', quote=False)
         enc = sys.getfilesystemencoding()
-        filename = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.txt'
-        with open(os.path.join(self.tempdir, filename), 'wb') as f:
-            f.write(os_helper.TESTFN_UNDECODABLE)
+        prefix = f'listing for {displaypath}</'.encode(enc, 'surrogateescape')
+        self.assertIn(prefix + b'title>', body)
+        self.assertIn(prefix + b'h1>', body)
+
+    def check_list_dir_filename(self, filename):
+        fullpath = os.path.join(self.tempdir, filename)
+        content = ascii(fullpath).encode() + (os_helper.TESTFN_UNDECODABLE or b'\xff')
+        try:
+            with open(fullpath, 'wb') as f:
+                f.write(content)
+        except OSError:
+            self.skipTest(f'Can not create file {filename!a} '
+                          f'on current file system')
+
         response = self.request(self.base_url + '/')
-        if sys.platform == 'darwin':
-            # On Mac OS the HFS+ filesystem replaces bytes that aren't valid
-            # UTF-8 into a percent-encoded value.
-            for name in os.listdir(self.tempdir):
-                if name != 'test': # Ignore a filename created in setUp().
-                    filename = name
-                    break
         body = self.check_status_and_reason(response, HTTPStatus.OK)
         quotedname = urllib.parse.quote(filename, errors='surrogatepass')
-        self.assertIn(('href="%s"' % quotedname)
-                      .encode(enc, 'surrogateescape'), body)
-        self.assertIn(('>%s<' % html.escape(filename, quote=False))
-                      .encode(enc, 'surrogateescape'), body)
+        enc = response.headers.get_content_charset()
+        self.assertIsNotNone(enc)
+        self.assertIn((f'href="{quotedname}"').encode('ascii'), body)
+        displayname = html.escape(filename, quote=False)
+        self.assertIn(f'>{displayname}<'.encode(enc, 'surrogateescape'), body)
+
         response = self.request(self.base_url + '/' + quotedname)
-        self.check_status_and_reason(response, HTTPStatus.OK,
-                                     data=os_helper.TESTFN_UNDECODABLE)
+        self.check_status_and_reason(response, HTTPStatus.OK, data=content)
+
+    @unittest.skipUnless(os_helper.TESTFN_NONASCII,
+                         'need os_helper.TESTFN_NONASCII')
+    def test_list_dir_nonascii_dirname(self):
+        dirname = os_helper.TESTFN_NONASCII + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipUnless(os_helper.TESTFN_NONASCII,
+                         'need os_helper.TESTFN_NONASCII')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_nonascii_filename(self):
+        filename = os_helper.TESTFN_NONASCII + '.txt'
+        self.check_list_dir_filename(filename)
+
+    @unittest.skipIf(is_apple,
+                     'undecodable name cannot always be decoded on Apple platforms')
+    @unittest.skipIf(sys.platform == 'win32',
+                     'undecodable name cannot be decoded on win32')
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
+    def test_list_dir_undecodable_dirname(self):
+        dirname = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipIf(is_apple,
+                     'undecodable name cannot always be decoded on Apple platforms')
+    @unittest.skipIf(sys.platform == 'win32',
+                     'undecodable name cannot be decoded on win32')
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_undecodable_filename(self):
+        filename = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.txt'
+        self.check_list_dir_filename(filename)
+
+    def test_list_dir_undecodable_dirname2(self):
+        dirname = '\ufffd.dir'
+        self.check_list_dir_dirname(dirname, quotedname='%ff.dir')
+
+    @unittest.skipUnless(os_helper.TESTFN_UNENCODABLE,
+                         'need os_helper.TESTFN_UNENCODABLE')
+    def test_list_dir_unencodable_dirname(self):
+        dirname = os_helper.TESTFN_UNENCODABLE + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipUnless(os_helper.TESTFN_UNENCODABLE,
+                         'need os_helper.TESTFN_UNENCODABLE')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_unencodable_filename(self):
+        filename = os_helper.TESTFN_UNENCODABLE + '.txt'
+        self.check_list_dir_filename(filename)
+
+    def test_list_dir_escape_dirname(self):
+        # Characters that need special treating in URL or HTML.
+        for name in ('q?', 'f#', '&amp;', '&amp', '<i>', '"dq"', "'sq'",
+                     '%A4', '%E2%82%AC'):
+            with self.subTest(name=name):
+                dirname = name + '.dir'
+                self.check_list_dir_dirname(dirname,
+                        quotedname=urllib.parse.quote(dirname, safe='&<>\'"'))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_escape_filename(self):
+        # Characters that need special treating in URL or HTML.
+        for name in ('q?', 'f#', '&amp;', '&amp', '<i>', '"dq"', "'sq'",
+                     '%A4', '%E2%82%AC'):
+            with self.subTest(name=name):
+                filename = name + '.txt'
+                self.check_list_dir_filename(filename)
+                os_helper.unlink(os.path.join(self.tempdir, filename))
+
+    def test_list_dir_with_query_and_fragment(self):
+        prefix = f'listing for {self.base_url}/</'.encode('latin1')
+        response = self.request(self.base_url + '/#123').read()
+        self.assertIn(prefix + b'title>', response)
+        self.assertIn(prefix + b'h1>', response)
+        response = self.request(self.base_url + '/?x=123').read()
+        self.assertIn(prefix + b'title>', response)
+        self.assertIn(prefix + b'h1>', response)
+
+    def test_get_dir_redirect_location_domain_injection_bug(self):
+        """Ensure //evil.co/..%2f../../X does not put //evil.co/ in Location.
+
+        //netloc/ in a Location header is a redirect to a new host.
+        https://github.com/python/cpython/issues/87389
+
+        This checks that a path resolving to a directory on our server cannot
+        resolve into a redirect to another server.
+        """
+        os.mkdir(os.path.join(self.tempdir, 'existing_directory'))
+        url = f'/python.org/..%2f..%2f..%2f..%2f..%2f../%0a%0d/../{self.tempdir_name}/existing_directory'
+        expected_location = f'{url}/'  # /python.org.../ single slash single prefix, trailing slash
+        # Canonicalizes to /tmp/tempdir_name/existing_directory which does
+        # exist and is a dir, triggering the 301 redirect logic.
+        response = self.request(url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        self.assertEqual(location, expected_location, msg='non-attack failed!')
 
+        # //python.org... multi-slash prefix, no trailing slash
+        attack_url = f'/{url}'
+        response = self.request(attack_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        self.assertNotStartsWith(location, '//')
+        self.assertEqual(location, expected_location,
+                msg='Expected Location header to start with a single / and '
+                'end with a / as this is a directory redirect.')
+
+        # ///python.org... triple-slash prefix, no trailing slash
+        attack3_url = f'//{url}'
+        response = self.request(attack3_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader('Location'), expected_location)
+
+        # If the second word in the http request (Request-URI for the http
+        # method) is a full URI, we don't worry about it, as that'll be parsed
+        # and reassembled as a full URI within BaseHTTPRequestHandler.send_head
+        # so no errant scheme-less //netloc//evil.co/ domain mixup can happen.
+        attack_scheme_netloc_2slash_url = f'https://pypi.org/{url}'
+        expected_scheme_netloc_location = f'{attack_scheme_netloc_2slash_url}/'
+        response = self.request(attack_scheme_netloc_2slash_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        # We're just ensuring that the scheme and domain make it through, if
+        # there are or aren't multiple slashes at the start of the path that
+        # follows that isn't important in this Location: header.
+        self.assertStartsWith(location, 'https://pypi.org/')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get(self):
         #constructs the path relative to the root directory of the HTTPServer
         response = self.request(self.base_url + '/test')
@@ -424,10 +626,19 @@ def test_get(self):
         # check for trailing "/" which should return 404. See Issue17324
         response = self.request(self.base_url + '/test/')
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        response = self.request(self.base_url + '/test%2f')
+        self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        response = self.request(self.base_url + '/test%2F')
+        self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
         response = self.request(self.base_url + '/')
         self.check_status_and_reason(response, HTTPStatus.OK)
+        response = self.request(self.base_url + '%2f')
+        self.check_status_and_reason(response, HTTPStatus.OK)
+        response = self.request(self.base_url + '%2F')
+        self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.base_url)
         self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader("Location"), self.base_url + "/")
         self.assertEqual(response.getheader("Content-Length"), "0")
         response = self.request(self.base_url + '/?hi=2')
         self.check_status_and_reason(response, HTTPStatus.OK)
@@ -439,6 +650,9 @@ def test_get(self):
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
         response = self.request('/' + 'ThisDoesNotExist' + '/')
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        os.makedirs(os.path.join(self.tempdir, 'spam', 'index.html'))
+        response = self.request(self.base_url + '/spam/')
+        self.check_status_and_reason(response, HTTPStatus.OK)
 
         data = b"Dummy index file\r\n"
         with open(os.path.join(self.tempdir_name, 'index.html'), 'wb') as f:
@@ -456,6 +670,7 @@ def test_get(self):
             finally:
                 os.chmod(self.tempdir, 0o755)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_head(self):
         response = self.request(
             self.base_url + '/test', method='HEAD')
@@ -465,6 +680,7 @@ def test_head(self):
         self.assertEqual(response.getheader('content-type'),
                          'application/octet-stream')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache(self):
         """Check that when a request to /test is sent with the request header
         If-Modified-Since set to date of last modification, the server returns
@@ -483,6 +699,7 @@ def test_browser_cache(self):
         response = self.request(self.base_url + '/test', headers=headers)
         self.check_status_and_reason(response, HTTPStatus.NOT_MODIFIED)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache_file_changed(self):
         # with If-Modified-Since earlier than Last-Modified, must return 200
         dt = self.last_modif_datetime
@@ -494,6 +711,7 @@ def test_browser_cache_file_changed(self):
         response = self.request(self.base_url + '/test', headers=headers)
         self.check_status_and_reason(response, HTTPStatus.OK)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache_with_If_None_Match_header(self):
         # if If-None-Match header is present, ignore If-Modified-Since
 
@@ -512,6 +730,7 @@ def test_invalid_requests(self):
         response = self.request('/', method='GETs')
         self.check_status_and_reason(response, HTTPStatus.NOT_IMPLEMENTED)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_last_modified(self):
         """Checks that the datetime returned in Last-Modified response header
         is the actual datetime of last modification, rounded to the second
@@ -521,6 +740,7 @@ def test_last_modified(self):
         last_modif_header = response.headers['Last-modified']
         self.assertEqual(last_modif_header, self.last_modif_header)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_path_without_leading_slash(self):
         response = self.request(self.tempdir_name + '/test')
         self.check_status_and_reason(response, HTTPStatus.OK, data=self.data)
@@ -530,6 +750,8 @@ def test_path_without_leading_slash(self):
         self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.tempdir_name)
         self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader("Location"),
+                         self.tempdir_name + "/")
         response = self.request(self.tempdir_name + '/?hi=2')
         self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.tempdir_name + '?hi=1')
@@ -537,27 +759,6 @@ def test_path_without_leading_slash(self):
         self.assertEqual(response.getheader("Location"),
                          self.tempdir_name + "/?hi=1")
 
-    def test_html_escape_filename(self):
-        filename = '<test&>.txt'
-        fullpath = os.path.join(self.tempdir, filename)
-
-        try:
-            open(fullpath, 'wb').close()
-        except OSError:
-            raise unittest.SkipTest('Can not create file %s on current file '
-                                    'system' % filename)
-
-        try:
-            response = self.request(self.base_url + '/')
-            body = self.check_status_and_reason(response, HTTPStatus.OK)
-            enc = response.headers.get_content_charset()
-        finally:
-            os.unlink(fullpath)  # avoid affecting test_undecodable_filename
-
-        self.assertIsNotNone(enc)
-        html_text = '>%s<' % html.escape(filename, quote=False)
-        self.assertIn(html_text.encode(enc), body)
-
 
 cgi_file1 = """\
 #!%s
@@ -569,14 +770,19 @@ def test_html_escape_filename(self):
 
 cgi_file2 = """\
 #!%s
-import cgi
+import os
+import sys
+import urllib.parse
 
 print("Content-type: text/html")
 print()
 
-form = cgi.FieldStorage()
-print("%%s, %%s, %%s" %% (form.getfirst("spam"), form.getfirst("eggs"),
-                          form.getfirst("bacon")))
+content_length = int(os.environ["CONTENT_LENGTH"])
+query_string = sys.stdin.buffer.read(content_length)
+params = {key.decode("utf-8"): val.decode("utf-8")
+            for key, val in urllib.parse.parse_qsl(query_string)}
+
+print("%%s, %%s, %%s" %% (params["spam"], params["eggs"], params["bacon"]))
 """
 
 cgi_file4 = """\
@@ -607,17 +813,40 @@ def test_html_escape_filename(self):
 print("</pre>")
 """
 
-@unittest.skipIf(not hasattr(os, '_exit'),
-        "TODO: RUSTPYTHON, run_cgi in http/server.py gets stuck as os._exit(127) doesn't currently kill forked processes")
+cgi_file7 = """\
+#!%s
+import os
+import sys
+
+print("Content-type: text/plain")
+print()
+
+content_length = int(os.environ["CONTENT_LENGTH"])
+body = sys.stdin.buffer.read(content_length)
+
+print(f"{content_length} {len(body)}")
+"""
+
+
 @unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0,
         "This test can't be run reliably as root (issue #13308).")
+@requires_subprocess()
 class CGIHTTPServerTestCase(BaseTestCase):
     class request_handler(NoLogRequestHandler, CGIHTTPRequestHandler):
-        pass
+        _test_case_self = None  # populated by each setUp() method call.
+
+        def __init__(self, *args, **kwargs):
+            with self._test_case_self.assertWarnsRegex(
+                    DeprecationWarning,
+                    r'http\.server\.CGIHTTPRequestHandler'):
+                # This context also happens to catch and silence the
+                # threading DeprecationWarning from os.fork().
+                super().__init__(*args, **kwargs)
 
     linesep = os.linesep.encode('ascii')
 
     def setUp(self):
+        self.request_handler._test_case_self = self  # practical, but yuck.
         BaseTestCase.setUp(self)
         self.cwd = os.getcwd()
         self.parent_dir = tempfile.mkdtemp()
@@ -637,12 +866,13 @@ def setUp(self):
         self.file3_path = None
         self.file4_path = None
         self.file5_path = None
+        self.file6_path = None
+        self.file7_path = None
 
         # The shebang line should be pure ASCII: use symlink if possible.
         # See issue #7668.
         self._pythonexe_symlink = None
-        # TODO: RUSTPYTHON; dl_nt not supported yet
-        if os_helper.can_symlink() and sys.platform != 'win32':
+        if os_helper.can_symlink():
             self.pythonexe = os.path.join(self.parent_dir, 'python')
             self._pythonexe_symlink = support.PythonSymlink(self.pythonexe).__enter__()
         else:
@@ -692,9 +922,15 @@ def setUp(self):
             file6.write(cgi_file6 % self.pythonexe)
         os.chmod(self.file6_path, 0o777)
 
+        self.file7_path = os.path.join(self.cgi_dir, 'file7.py')
+        with open(self.file7_path, 'w', encoding='utf-8') as file7:
+            file7.write(cgi_file7 % self.pythonexe)
+        os.chmod(self.file7_path, 0o777)
+
         os.chdir(self.parent_dir)
 
     def tearDown(self):
+        self.request_handler._test_case_self = None
         try:
             os.chdir(self.cwd)
             if self._pythonexe_symlink:
@@ -713,11 +949,16 @@ def tearDown(self):
                 os.remove(self.file5_path)
             if self.file6_path:
                 os.remove(self.file6_path)
+            if self.file7_path:
+                os.remove(self.file7_path)
             os.rmdir(self.cgi_child_dir)
             os.rmdir(self.cgi_dir)
             os.rmdir(self.cgi_dir_in_sub_dir)
             os.rmdir(self.sub_dir_2)
             os.rmdir(self.sub_dir_1)
+            # The 'gmon.out' file can be written in the current working
+            # directory if C-level code profiling with gprof is enabled.
+            os_helper.unlink(os.path.join(self.parent_dir, 'gmon.out'))
             os.rmdir(self.parent_dir)
         finally:
             BaseTestCase.tearDown(self)
@@ -764,8 +1005,7 @@ def test_url_collapse_path(self):
                                  msg='path = %r\nGot:    %r\nWanted: %r' %
                                  (path, actual, expected))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"", None, 200) != (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>)')
     def test_headers_and_content(self):
         res = self.request('/cgi-bin/file1.py')
         self.assertEqual(
@@ -776,9 +1016,7 @@ def test_issue19435(self):
         res = self.request('///////////nocgi.py/../cgi-bin/nothere.sh')
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
-    @unittest.expectedFailure
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; b"" != b"1, python, 123456\n"')
     def test_post(self):
         params = urllib.parse.urlencode(
             {'spam' : 1, 'eggs' : 'python', 'bacon' : 123456})
@@ -787,13 +1025,30 @@ def test_post(self):
 
         self.assertEqual(res.read(), b'1, python, 123456' + self.linesep)
 
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"" != b"32768 32768\n"')
+    def test_large_content_length(self):
+        for w in range(15, 25):
+            size = 1 << w
+            body = b'X' * size
+            headers = {'Content-Length' : str(size)}
+            res = self.request('/cgi-bin/file7.py', 'POST', body, headers)
+            self.assertEqual(res.read(), b'%d %d' % (size, size) + self.linesep)
+
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"" != b"Hello World\n"')
+    def test_large_content_length_truncated(self):
+        with support.swap_attr(self.request_handler, 'timeout', 0.001):
+            for w in range(18, 65):
+                size = 1 << w
+                headers = {'Content-Length' : str(size)}
+                res = self.request('/cgi-bin/file1.py', 'POST', b'x', headers)
+                self.assertEqual(res.read(), b'Hello World' + self.linesep)
+
     def test_invaliduri(self):
         res = self.request('/cgi-bin/invalid')
         res.read()
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_authorization(self):
         headers = {b'Authorization' : b'Basic ' +
                    base64.b64encode(b'username:pass')}
@@ -802,8 +1057,7 @@ def test_authorization(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_no_leading_slash(self):
         # http://bugs.python.org/issue2254
         res = self.request('cgi-bin/file1.py')
@@ -811,8 +1065,7 @@ def test_no_leading_slash(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_os_environ_is_not_altered(self):
         signature = "Test CGI Server"
         os.environ['SERVER_SOFTWARE'] = signature
@@ -822,32 +1075,28 @@ def test_os_environ_is_not_altered(self):
             (res.read(), res.getheader('Content-type'), res.status))
         self.assertEqual(os.environ['SERVER_SOFTWARE'], signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_urlquote_decoding_in_cgi_check(self):
         res = self.request('/cgi-bin%2ffile1.py')
         self.assertEqual(
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_nested_cgi_path_issue21323(self):
         res = self.request('/cgi-bin/child-dir/file3.py')
         self.assertEqual(
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_query_with_multiple_question_mark(self):
         res = self.request('/cgi-bin/file4.py?a=b?c=d')
         self.assertEqual(
             (b'a=b?c=d' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"k=aa%2F%2Fbb&//q//p//=//a//b//\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_query_with_continuous_slashes(self):
         res = self.request('/cgi-bin/file4.py?k=aa%2F%2Fbb&//q//p//=//a//b//')
         self.assertEqual(
@@ -855,8 +1104,7 @@ def test_query_with_continuous_slashes(self):
              'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; Tuples differ: (b"", None, 200) != (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>)')
     def test_cgi_path_in_sub_directories(self):
         try:
             CGIHTTPRequestHandler.cgi_directories.append('/sub/dir/cgi-bin')
@@ -867,8 +1115,7 @@ def test_cgi_path_in_sub_directories(self):
         finally:
             CGIHTTPRequestHandler.cgi_directories.remove('/sub/dir/cgi-bin')
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"HTTP_ACCEPT=text/html,text/plain" not found in b""')
     def test_accept(self):
         browser_accept = \
                     'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
@@ -929,7 +1176,7 @@ def numWrites(self):
         return len(self.datas)
 
 
-class BaseHTTPRequestHandlerTestCase(unittest.TestCase):
+class BaseHTTPRequestHandlerTestCase(unittest.TestCase, ExtraAssertions):
     """Test the functionality of the BaseHTTPServer.
 
        Test the support for the Expect 100-continue header.
@@ -960,6 +1207,27 @@ def verify_http_server_response(self, response):
         match = self.HTTPResponseMatch.search(response)
         self.assertIsNotNone(match)
 
+    def test_unprintable_not_logged(self):
+        # We call the method from the class directly as our Socketless
+        # Handler subclass overrode it... nice for everything BUT this test.
+        self.handler.client_address = ('127.0.0.1', 1337)
+        log_message = BaseHTTPRequestHandler.log_message
+        with mock.patch.object(sys, 'stderr', StringIO()) as fake_stderr:
+            log_message(self.handler, '/foo')
+            log_message(self.handler, '/\033bar\000\033')
+            log_message(self.handler, '/spam %s.', 'a')
+            log_message(self.handler, '/spam %s.', '\033\x7f\x9f\xa0beans')
+            log_message(self.handler, '"GET /foo\\b"ar\007 HTTP/1.0"')
+        stderr = fake_stderr.getvalue()
+        self.assertNotIn('\033', stderr)  # non-printable chars are caught.
+        self.assertNotIn('\000', stderr)  # non-printable chars are caught.
+        lines = stderr.splitlines()
+        self.assertIn('/foo', lines[0])
+        self.assertIn(r'/\x1bbar\x00\x1b', lines[1])
+        self.assertIn('/spam a.', lines[2])
+        self.assertIn('/spam \\x1b\\x7f\\x9f\xa0beans.', lines[3])
+        self.assertIn(r'"GET /foo\\b"ar\x07 HTTP/1.0"', lines[4])
+
     def test_http_1_1(self):
         result = self.send_typical_request(b'GET / HTTP/1.1\r\n\r\n')
         self.verify_http_server_response(result[0])
@@ -996,7 +1264,7 @@ def test_extra_space(self):
             b'Host: dummy\r\n'
             b'\r\n'
         )
-        self.assertTrue(result[0].startswith(b'HTTP/1.1 400 '))
+        self.assertStartsWith(result[0], b'HTTP/1.1 400 ')
         self.verify_expected_headers(result[1:result.index(b'\r\n')])
         self.assertFalse(self.handler.get_called)
 
@@ -1110,7 +1378,7 @@ def test_request_length(self):
         # Issue #10714: huge request lines are discarded, to avoid Denial
         # of Service attacks.
         result = self.send_typical_request(b'GET ' + b'x' * 65537)
-        self.assertEqual(result[0], b'HTTP/1.1 414 Request-URI Too Long\r\n')
+        self.assertEqual(result[0], b'HTTP/1.1 414 URI Too Long\r\n')
         self.assertFalse(self.handler.get_called)
         self.assertIsInstance(self.handler.requestline, str)
 
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 8ea77d186e4..12b61e76423 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -736,6 +736,7 @@ def remove_loop(fname, tries):
     @threading_helper.requires_working_threading()
     @skip_if_asan_fork
     @skip_if_tsan_fork
+    @unittest.skip("TODO: RUSTPYTHON; Flaky")
     def test_post_fork_child_no_deadlock(self):
         """Ensure child logging locks are not held; bpo-6721 & bpo-36533."""
         class _OurHandler(logging.Handler):
diff --git a/Lib/test/test_robotparser.py b/Lib/test/test_robotparser.py
index b0bed431d4b..89cabfe0083 100644
--- a/Lib/test/test_robotparser.py
+++ b/Lib/test/test_robotparser.py
@@ -259,6 +259,10 @@ class EmptyQueryStringTest(BaseRobotTest, unittest.TestCase):
     good = ['/some/path?']
     bad = ['/another/path?']
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertFalse(self.parser.can_fetch(agent, url))\nAssertionError: True is not false
+    def test_bad_urls(self):
+        super().test_bad_urls()
+
 
 class DefaultEntryTest(BaseRequestRateTest, unittest.TestCase):
     robots_txt = """\
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 5384e4caf69..9798a4f59c3 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -3525,6 +3525,7 @@ def test_starttls(self):
             else:
                 s.close()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_socketserver(self):
         """Using socketserver to create and manage SSL connections."""
         server = make_https_server(self, certfile=SIGNED_CERTFILE)
@@ -4596,7 +4597,7 @@ def server_callback(identity):
             with client_context.wrap_socket(socket.socket()) as s:
                 s.connect((HOST, server.port))
 
-    @unittest.skip("TODO: rustpython")
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
     def test_thread_recv_while_main_thread_sends(self):
         # GH-137583: Locking was added to calls to send() and recv() on SSL
         # socket objects. This seemed fine at the surface level because those
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index aee9fb78017..7e3607842fd 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -1556,7 +1556,6 @@ def test_pathname2url_win(self):
 
     @unittest.skipIf(sys.platform == 'win32',
                      'test specific to POSIX pathnames')
-    @unittest.expectedFailure # AssertionError: '//a/b.c' != '////a/b.c'
     def test_pathname2url_posix(self):
         fn = urllib.request.pathname2url
         self.assertEqual(fn('/'), '/')
@@ -1617,7 +1616,6 @@ def test_url2pathname_win(self):
 
     @unittest.skipIf(sys.platform == 'win32',
                      'test specific to POSIX pathnames')
-    @unittest.expectedFailure # AssertionError: '///foo/bar' != '/foo/bar'
     def test_url2pathname_posix(self):
         fn = urllib.request.url2pathname
         self.assertEqual(fn('/foo/bar'), '/foo/bar')
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 399c94213a6..263472499d6 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -1,9 +1,11 @@
 import unittest
 from test import support
 from test.support import os_helper
-from test.support import socket_helper
+from test.support import requires_subprocess
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 from test import test_urllib
+from unittest import mock
 
 import os
 import io
@@ -14,16 +16,19 @@
 import subprocess
 
 import urllib.request
-# The proxy bypass method imported below has logic specific to the OSX
-# proxy config data structure but is testable on all platforms.
+# The proxy bypass method imported below has logic specific to the
+# corresponding system but is testable on all platforms.
 from urllib.request import (Request, OpenerDirector, HTTPBasicAuthHandler,
                             HTTPPasswordMgrWithPriorAuth, _parse_proxy,
+                            _proxy_bypass_winreg_override,
                             _proxy_bypass_macosx_sysconf,
                             AbstractDigestAuthHandler)
 from urllib.parse import urlparse
 import urllib.error
 import http.client
 
+support.requires_working_socket(module=True)
+
 # XXX
 # Request
 # CacheFTPHandler (hard to write)
@@ -483,7 +488,18 @@ def build_test_opener(*handler_instances):
     return opener
 
 
-class MockHTTPHandler(urllib.request.BaseHandler):
+class MockHTTPHandler(urllib.request.HTTPHandler):
+    # Very simple mock HTTP handler with no special behavior other than using a mock HTTP connection
+
+    def __init__(self, debuglevel=None):
+        super(MockHTTPHandler, self).__init__(debuglevel=debuglevel)
+        self.httpconn = MockHTTPClass()
+
+    def http_open(self, req):
+        return self.do_open(self.httpconn, req)
+
+
+class MockHTTPHandlerRedirect(urllib.request.BaseHandler):
     # useful for testing redirections and auth
     # sends supplied headers and code as first response
     # sends 200 OK as second response
@@ -511,16 +527,17 @@ def http_open(self, req):
             return MockResponse(200, "OK", msg, "", req.get_full_url())
 
 
-class MockHTTPSHandler(urllib.request.AbstractHTTPHandler):
-    # Useful for testing the Proxy-Authorization request by verifying the
-    # properties of httpcon
+if hasattr(http.client, 'HTTPSConnection'):
+    class MockHTTPSHandler(urllib.request.HTTPSHandler):
+        # Useful for testing the Proxy-Authorization request by verifying the
+        # properties of httpcon
 
-    def __init__(self, debuglevel=0):
-        urllib.request.AbstractHTTPHandler.__init__(self, debuglevel=debuglevel)
-        self.httpconn = MockHTTPClass()
+        def __init__(self, debuglevel=None, context=None, check_hostname=None):
+            super(MockHTTPSHandler, self).__init__(debuglevel, context, check_hostname)
+            self.httpconn = MockHTTPClass()
 
-    def https_open(self, req):
-        return self.do_open(self.httpconn, req)
+        def https_open(self, req):
+            return self.do_open(self.httpconn, req)
 
 
 class MockHTTPHandlerCheckAuth(urllib.request.BaseHandler):
@@ -701,10 +718,6 @@ def test_processors(self):
 
 
 def sanepathname2url(path):
-    try:
-        path.encode("utf-8")
-    except UnicodeEncodeError:
-        raise unittest.SkipTest("path is not encodable to utf8")
     urlpath = urllib.request.pathname2url(path)
     if os.name == "nt" and urlpath.startswith("///"):
         urlpath = urlpath[2:]
@@ -712,8 +725,9 @@ def sanepathname2url(path):
     return urlpath
 
 
-class HandlerTests(unittest.TestCase):
+class HandlerTests(unittest.TestCase, ExtraAssertions):
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: None != 'image/gif'
     def test_ftp(self):
         class MockFTPWrapper:
             def __init__(self, data):
@@ -761,7 +775,7 @@ def connect_ftp(self, user, passwd, host, port, dirs,
              ["foo", "bar"], "", None),
             ("ftp://localhost/baz.gif;type=a",
              "localhost", ftplib.FTP_PORT, "", "", "A",
-             [], "baz.gif", None),  # XXX really this should guess image/gif
+             [], "baz.gif", "image/gif"),
             ]:
             req = Request(url)
             req.timeout = None
@@ -777,6 +791,7 @@ def connect_ftp(self, user, passwd, host, port, dirs,
             headers = r.info()
             self.assertEqual(headers.get("Content-type"), mimetype)
             self.assertEqual(int(headers["Content-length"]), len(data))
+            r.close()
 
     def test_file(self):
         import email.utils
@@ -984,6 +999,7 @@ def test_http_body_fileobj(self):
 
         file_obj.close()
 
+    @requires_subprocess()
     def test_http_body_pipe(self):
         # A file reading from a pipe.
         # A pipe cannot be seek'ed.  There is no way to determine the
@@ -1047,12 +1063,37 @@ def test_http_body_array(self):
             newreq = h.do_request_(req)
             self.assertEqual(int(newreq.get_header('Content-length')),16)
 
-    def test_http_handler_debuglevel(self):
+    def test_http_handler_global_debuglevel(self):
+        with mock.patch.object(http.client.HTTPConnection, 'debuglevel', 6):
+            o = OpenerDirector()
+            h = MockHTTPHandler()
+            o.add_handler(h)
+            o.open("http://www.example.com")
+            self.assertEqual(h._debuglevel, 6)
+
+    def test_http_handler_local_debuglevel(self):
         o = OpenerDirector()
-        h = MockHTTPSHandler(debuglevel=1)
+        h = MockHTTPHandler(debuglevel=5)
+        o.add_handler(h)
+        o.open("http://www.example.com")
+        self.assertEqual(h._debuglevel, 5)
+
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
+    def test_https_handler_global_debuglevel(self):
+        with mock.patch.object(http.client.HTTPSConnection, 'debuglevel', 7):
+            o = OpenerDirector()
+            h = MockHTTPSHandler()
+            o.add_handler(h)
+            o.open("https://www.example.com")
+            self.assertEqual(h._debuglevel, 7)
+
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
+    def test_https_handler_local_debuglevel(self):
+        o = OpenerDirector()
+        h = MockHTTPSHandler(debuglevel=4)
         o.add_handler(h)
         o.open("https://www.example.com")
-        self.assertEqual(h._debuglevel, 1)
+        self.assertEqual(h._debuglevel, 4)
 
     def test_http_doubleslash(self):
         # Checks the presence of any unnecessary double slash in url does not
@@ -1140,15 +1181,15 @@ def test_errors(self):
         r = MockResponse(200, "OK", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         r = MockResponse(202, "Accepted", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         r = MockResponse(206, "Partial content", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         # anything else calls o.error (and MockOpener returns None, here)
         r = MockResponse(502, "Bad gateway", {}, "", url)
         self.assertIsNone(h.http_response(req, r))
@@ -1179,7 +1220,7 @@ def test_redirect(self):
         o = h.parent = MockOpener()
 
         # ordinary redirect behaviour
-        for code in 301, 302, 303, 307:
+        for code in 301, 302, 303, 307, 308:
             for data in None, "blah\nblah\n":
                 method = getattr(h, "http_error_%s" % code)
                 req = Request(from_url, data)
@@ -1191,10 +1232,11 @@ def test_redirect(self):
                 try:
                     method(req, MockFile(), code, "Blah",
                            MockHeaders({"location": to_url}))
-                except urllib.error.HTTPError:
-                    # 307 in response to POST requires user OK
-                    self.assertEqual(code, 307)
+                except urllib.error.HTTPError as err:
+                    # 307 and 308 in response to POST require user OK
+                    self.assertIn(code, (307, 308))
                     self.assertIsNotNone(data)
+                    err.close()
                 self.assertEqual(o.req.get_full_url(), to_url)
                 try:
                     self.assertEqual(o.req.get_method(), "GET")
@@ -1230,9 +1272,10 @@ def redirect(h, req, url=to_url):
             while 1:
                 redirect(h, req, "http://example.com/")
                 count = count + 1
-        except urllib.error.HTTPError:
+        except urllib.error.HTTPError as err:
             # don't stop until max_repeats, because cookies may introduce state
             self.assertEqual(count, urllib.request.HTTPRedirectHandler.max_repeats)
+            err.close()
 
         # detect endless non-repeating chain of redirects
         req = Request(from_url, origin_req_host="example.com")
@@ -1242,9 +1285,10 @@ def redirect(h, req, url=to_url):
             while 1:
                 redirect(h, req, "http://example.com/%d" % count)
                 count = count + 1
-        except urllib.error.HTTPError:
+        except urllib.error.HTTPError as err:
             self.assertEqual(count,
                              urllib.request.HTTPRedirectHandler.max_redirections)
+            err.close()
 
     def test_invalid_redirect(self):
         from_url = "http://example.com/a.html"
@@ -1258,9 +1302,11 @@ def test_invalid_redirect(self):
 
         for scheme in invalid_schemes:
             invalid_url = scheme + '://' + schemeless_url
-            self.assertRaises(urllib.error.HTTPError, h.http_error_302,
+            with self.assertRaises(urllib.error.HTTPError) as cm:
+                h.http_error_302(
                     req, MockFile(), 302, "Security Loophole",
                     MockHeaders({"location": invalid_url}))
+            cm.exception.close()
 
         for scheme in valid_schemes:
             valid_url = scheme + '://' + schemeless_url
@@ -1288,7 +1334,7 @@ def test_cookie_redirect(self):
 
         cj = CookieJar()
         interact_netscape(cj, "http://www.example.com/", "spam=eggs")
-        hh = MockHTTPHandler(302, "Location: http://www.cracker.com/\r\n\r\n")
+        hh = MockHTTPHandlerRedirect(302, "Location: http://www.cracker.com/\r\n\r\n")
         hdeh = urllib.request.HTTPDefaultErrorHandler()
         hrh = urllib.request.HTTPRedirectHandler()
         cp = urllib.request.HTTPCookieProcessor(cj)
@@ -1298,7 +1344,7 @@ def test_cookie_redirect(self):
 
     def test_redirect_fragment(self):
         redirected_url = 'http://www.example.com/index.html#OK\r\n\r\n'
-        hh = MockHTTPHandler(302, 'Location: ' + redirected_url)
+        hh = MockHTTPHandlerRedirect(302, 'Location: ' + redirected_url)
         hdeh = urllib.request.HTTPDefaultErrorHandler()
         hrh = urllib.request.HTTPRedirectHandler()
         o = build_test_opener(hh, hdeh, hrh)
@@ -1358,7 +1404,16 @@ def http_open(self, req):
                 response = opener.open('http://example.com/')
                 expected = b'GET ' + result + b' '
                 request = handler.last_buf
-                self.assertTrue(request.startswith(expected), repr(request))
+                self.assertStartsWith(request, expected)
+
+    def test_redirect_head_request(self):
+        from_url = "http://example.com/a.html"
+        to_url = "http://example.com/b.html"
+        h = urllib.request.HTTPRedirectHandler()
+        req = Request(from_url, method="HEAD")
+        fp = MockFile()
+        new_req = h.redirect_request(req, fp, 302, "Found", {}, to_url)
+        self.assertEqual(new_req.get_method(), "HEAD")
 
     def test_proxy(self):
         u = "proxy.example.com:3128"
@@ -1379,7 +1434,8 @@ def test_proxy(self):
                              [tup[0:2] for tup in o.calls])
 
     def test_proxy_no_proxy(self):
-        os.environ['no_proxy'] = 'python.org'
+        env = self.enterContext(os_helper.EnvironmentVarGuard())
+        env['no_proxy'] = 'python.org'
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com"))
         o.add_handler(ph)
@@ -1391,10 +1447,10 @@ def test_proxy_no_proxy(self):
         self.assertEqual(req.host, "www.python.org")
         o.open(req)
         self.assertEqual(req.host, "www.python.org")
-        del os.environ['no_proxy']
 
     def test_proxy_no_proxy_all(self):
-        os.environ['no_proxy'] = '*'
+        env = self.enterContext(os_helper.EnvironmentVarGuard())
+        env['no_proxy'] = '*'
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com"))
         o.add_handler(ph)
@@ -1402,7 +1458,6 @@ def test_proxy_no_proxy_all(self):
         self.assertEqual(req.host, "www.python.org")
         o.open(req)
         self.assertEqual(req.host, "www.python.org")
-        del os.environ['no_proxy']
 
     def test_proxy_https(self):
         o = OpenerDirector()
@@ -1420,6 +1475,7 @@ def test_proxy_https(self):
         self.assertEqual([(handlers[0], "https_open")],
                          [tup[0:2] for tup in o.calls])
 
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
     def test_proxy_https_proxy_authorization(self):
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(https='proxy.example.com:3128'))
@@ -1443,6 +1499,30 @@ def test_proxy_https_proxy_authorization(self):
         self.assertEqual(req.host, "proxy.example.com:3128")
         self.assertEqual(req.get_header("Proxy-authorization"), "FooBar")
 
+    @unittest.skipUnless(os.name == "nt", "only relevant for Windows")
+    def test_winreg_proxy_bypass(self):
+        proxy_override = "www.example.com;*.example.net; 192.168.0.1"
+        proxy_bypass = _proxy_bypass_winreg_override
+        for host in ("www.example.com", "www.example.net", "192.168.0.1"):
+            self.assertTrue(proxy_bypass(host, proxy_override),
+                            "expected bypass of %s to be true" % host)
+
+        for host in ("example.com", "www.example.org", "example.net",
+                     "192.168.0.2"):
+            self.assertFalse(proxy_bypass(host, proxy_override),
+                             "expected bypass of %s to be False" % host)
+
+        # check intranet address bypass
+        proxy_override = "example.com; <local>"
+        self.assertTrue(proxy_bypass("example.com", proxy_override),
+                        "expected bypass of %s to be true" % host)
+        self.assertFalse(proxy_bypass("example.net", proxy_override),
+                         "expected bypass of %s to be False" % host)
+        for host in ("test", "localhost"):
+            self.assertTrue(proxy_bypass(host, proxy_override),
+                            "expect <local> to bypass intranet address '%s'"
+                            % host)
+
     @unittest.skipUnless(sys.platform == 'darwin', "only relevant for OSX")
     def test_osx_proxy_bypass(self):
         bypass = {
@@ -1483,7 +1563,7 @@ def check_basic_auth(self, headers, realm):
             password_manager = MockPasswordManager()
             auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
             body = '\r\n'.join(headers) + '\r\n\r\n'
-            http_handler = MockHTTPHandler(401, body)
+            http_handler = MockHTTPHandlerRedirect(401, body)
             opener.add_handler(auth_handler)
             opener.add_handler(http_handler)
             self._test_basic_auth(opener, auth_handler, "Authorization",
@@ -1543,7 +1623,7 @@ def test_proxy_basic_auth(self):
         password_manager = MockPasswordManager()
         auth_handler = urllib.request.ProxyBasicAuthHandler(password_manager)
         realm = "ACME Networks"
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             407, 'Proxy-Authenticate: Basic realm="%s"\r\n\r\n' % realm)
         opener.add_handler(auth_handler)
         opener.add_handler(http_handler)
@@ -1555,11 +1635,11 @@ def test_proxy_basic_auth(self):
 
     def test_basic_and_digest_auth_handlers(self):
         # HTTPDigestAuthHandler raised an exception if it couldn't handle a 40*
-        # response (http://python.org/sf/1479302), where it should instead
+        # response (https://bugs.python.org/issue1479302), where it should instead
         # return None to allow another handler (especially
         # HTTPBasicAuthHandler) to handle the response.
 
-        # Also (http://python.org/sf/14797027, RFC 2617 section 1.2), we must
+        # Also (https://bugs.python.org/issue14797027, RFC 2617 section 1.2), we must
         # try digest first (since it's the strongest auth scheme), so we record
         # order of calls here to check digest comes first:
         class RecordingOpenerDirector(OpenerDirector):
@@ -1587,7 +1667,7 @@ def http_error_401(self, *args, **kwds):
         digest_handler = TestDigestAuthHandler(password_manager)
         basic_handler = TestBasicAuthHandler(password_manager)
         realm = "ACME Networks"
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Basic realm="%s"\r\n\r\n' % realm)
         opener.add_handler(basic_handler)
         opener.add_handler(digest_handler)
@@ -1607,7 +1687,7 @@ def test_unsupported_auth_digest_handler(self):
         opener = OpenerDirector()
         # While using DigestAuthHandler
         digest_auth_handler = urllib.request.HTTPDigestAuthHandler(None)
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Kerberos\r\n\r\n')
         opener.add_handler(digest_auth_handler)
         opener.add_handler(http_handler)
@@ -1617,7 +1697,7 @@ def test_unsupported_auth_basic_handler(self):
         # While using BasicAuthHandler
         opener = OpenerDirector()
         basic_auth_handler = urllib.request.HTTPBasicAuthHandler(None)
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: NTLM\r\n\r\n')
         opener.add_handler(basic_auth_handler)
         opener.add_handler(http_handler)
@@ -1704,7 +1784,7 @@ def test_basic_prior_auth_send_after_first_success(self):
         opener = OpenerDirector()
         opener.add_handler(auth_prior_handler)
 
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Basic realm="%s"\r\n\r\n' % None)
         opener.add_handler(http_handler)
 
@@ -1755,7 +1835,7 @@ def test_invalid_closed(self):
         self.assertTrue(conn.fakesock.closed, "Connection not closed")
 
 
-class MiscTests(unittest.TestCase):
+class MiscTests(unittest.TestCase, ExtraAssertions):
 
     def opener_has_handler(self, opener, handler_class):
         self.assertTrue(any(h.__class__ == handler_class
@@ -1814,14 +1894,21 @@ def test_HTTPError_interface(self):
         url = code = fp = None
         hdrs = 'Content-Length: 42'
         err = urllib.error.HTTPError(url, code, msg, hdrs, fp)
-        self.assertTrue(hasattr(err, 'reason'))
+        self.assertHasAttr(err, 'reason')
         self.assertEqual(err.reason, 'something bad happened')
-        self.assertTrue(hasattr(err, 'headers'))
+        self.assertHasAttr(err, 'headers')
         self.assertEqual(err.headers, 'Content-Length: 42')
         expected_errmsg = 'HTTP Error %s: %s' % (err.code, err.msg)
         self.assertEqual(str(err), expected_errmsg)
         expected_errmsg = '<HTTPError %s: %r>' % (err.code, err.msg)
         self.assertEqual(repr(err), expected_errmsg)
+        err.close()
+
+    def test_gh_98778(self):
+        x = urllib.error.HTTPError("url", 405, "METHOD NOT ALLOWED", None, None)
+        self.assertEqual(getattr(x, "__notes__", ()), ())
+        self.assertIsInstance(x.fp.read(), bytes)
+        x.close()
 
     def test_parse_proxy(self):
         parse_proxy_test_cases = [
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
index 2c54ef85b4b..9a899785116 100644
--- a/Lib/test/test_urllib2_localnet.py
+++ b/Lib/test/test_urllib2_localnet.py
@@ -8,15 +8,18 @@
 import unittest
 import hashlib
 
+from test import support
 from test.support import hashlib_helper
 from test.support import threading_helper
-from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
 try:
     import ssl
 except ImportError:
     ssl = None
 
+support.requires_working_socket(module=True)
+
 here = os.path.dirname(__file__)
 # Self-signed cert file for 'localhost'
 CERT_localhost = os.path.join(here, 'certdata', 'keycert.pem')
@@ -314,7 +317,9 @@ def test_basic_auth_httperror(self):
         ah = urllib.request.HTTPBasicAuthHandler()
         ah.add_password(self.REALM, self.server_url, self.USER, self.INCORRECT_PASSWD)
         urllib.request.install_opener(urllib.request.build_opener(ah))
-        self.assertRaises(urllib.error.HTTPError, urllib.request.urlopen, self.server_url)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            urllib.request.urlopen(self.server_url)
+        cm.exception.close()
 
 
 @hashlib_helper.requires_hashdigest("md5", openssl=True)
@@ -356,23 +361,23 @@ def stop_server(self):
         self.server.stop()
         self.server = None
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_with_bad_password_raises_httperror(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD+"bad")
         self.digest_auth_handler.set_qop("auth")
-        self.assertRaises(urllib.error.HTTPError,
-                          self.opener.open,
-                          self.URL)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            self.opener.open(self.URL)
+        cm.exception.close()
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_with_no_password_raises_httperror(self):
         self.digest_auth_handler.set_qop("auth")
-        self.assertRaises(urllib.error.HTTPError,
-                          self.opener.open,
-                          self.URL)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            self.opener.open(self.URL)
+        cm.exception.close()
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_qop_auth_works(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD)
@@ -381,7 +386,7 @@ def test_proxy_qop_auth_works(self):
             while result.read():
                 pass
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_qop_auth_int_works_or_throws_urlerror(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD)
@@ -442,7 +447,7 @@ def log_message(self, *args):
     return FakeHTTPRequestHandler
 
 
-class TestUrlopen(unittest.TestCase):
+class TestUrlopen(unittest.TestCase, ExtraAssertions):
     """Tests urllib.request.urlopen using the network.
 
     These tests are not exhaustive.  Assuming that testing using files does a
@@ -506,7 +511,7 @@ def start_https_server(self, responses=None, **kwargs):
         handler.port = server.port
         return handler
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_redirection(self):
         expected_response = b"We got here..."
         responses = [
@@ -520,7 +525,7 @@ def test_redirection(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/", "/somewhere_else"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_chunked(self):
         expected_response = b"hello world"
         chunked_start = (
@@ -535,7 +540,7 @@ def test_chunked(self):
         data = self.urlopen("http://localhost:%s/" % handler.port)
         self.assertEqual(data, expected_response)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_404(self):
         expected_response = b"Bad bad bad..."
         handler = self.start_server([(404, [], expected_response)])
@@ -551,7 +556,7 @@ def test_404(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/weeble"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_200(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -559,7 +564,7 @@ def test_200(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/bizarre"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_200_with_parameters(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -568,41 +573,14 @@ def test_200_with_parameters(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/bizarre", b"get=with_feeling"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_https(self):
         handler = self.start_https_server()
         context = ssl.create_default_context(cafile=CERT_localhost)
         data = self.urlopen("https://localhost:%s/bizarre" % handler.port, context=context)
         self.assertEqual(data, b"we care a bit")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
-    def test_https_with_cafile(self):
-        handler = self.start_https_server(certfile=CERT_localhost)
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            # Good cert
-            data = self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                                cafile=CERT_localhost)
-            self.assertEqual(data, b"we care a bit")
-            # Bad cert
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cafile=CERT_fakehostname)
-            # Good cert, but mismatching hostname
-            handler = self.start_https_server(certfile=CERT_fakehostname)
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cafile=CERT_fakehostname)
-
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
-    def test_https_with_cadefault(self):
-        handler = self.start_https_server(certfile=CERT_localhost)
-        # Self-signed cert should fail verification with system certificate store
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cadefault=True)
-
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_https_sni(self):
         if ssl is None:
             self.skipTest("ssl module required")
@@ -619,7 +597,7 @@ def cb_sni(ssl_sock, server_name, initial_context):
         self.urlopen("https://localhost:%s" % handler.port, context=context)
         self.assertEqual(sni_name, "localhost")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_sending_headers(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -628,7 +606,7 @@ def test_sending_headers(self):
             pass
         self.assertEqual(handler.headers_received["Range"], "bytes=20-39")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_sending_headers_camel(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -638,16 +616,15 @@ def test_sending_headers_camel(self):
         self.assertIn("X-Some-Header", handler.headers_received.keys())
         self.assertNotIn("X-SoMe-hEader", handler.headers_received.keys())
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_basic(self):
         handler = self.start_server()
         with urllib.request.urlopen("http://localhost:%s" % handler.port) as open_url:
             for attr in ("read", "close", "info", "geturl"):
-                self.assertTrue(hasattr(open_url, attr), "object returned from "
-                             "urlopen lacks the %s attribute" % attr)
+                self.assertHasAttr(open_url, attr)
             self.assertTrue(open_url.read(), "calling 'read' failed")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_info(self):
         handler = self.start_server()
         open_url = urllib.request.urlopen(
@@ -659,7 +636,7 @@ def test_info(self):
                               "instance of email.message.Message")
         self.assertEqual(info_obj.get_content_subtype(), "plain")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_geturl(self):
         # Make sure same URL as opened is returned by geturl.
         handler = self.start_server()
@@ -668,7 +645,7 @@ def test_geturl(self):
             url = open_url.geturl()
         self.assertEqual(url, "http://localhost:%s" % handler.port)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_iteration(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -676,7 +653,7 @@ def test_iteration(self):
         for line in data:
             self.assertEqual(line, expected_response)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_line_iteration(self):
         lines = [b"We\n", b"got\n", b"here\n", b"verylong " * 8192 + b"\n"]
         expected_response = b"".join(lines)
@@ -689,7 +666,7 @@ def test_line_iteration(self):
                              (index, len(lines[index]), len(line)))
         self.assertEqual(index + 1, len(lines))
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_issue16464(self):
         # See https://bugs.python.org/issue16464
         # and https://bugs.python.org/issue46648
@@ -709,6 +686,7 @@ def test_issue16464(self):
         self.assertEqual(b"1234567890", request.data)
         self.assertEqual("10", request.get_header("Content-length"))
 
+
 def setUpModule():
     thread_info = threading_helper.threading_setup()
     unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
diff --git a/Lib/test/test_urllib2net.py b/Lib/test/test_urllib2net.py
index c70b522d31d..41f170a6ad5 100644
--- a/Lib/test/test_urllib2net.py
+++ b/Lib/test/test_urllib2net.py
@@ -137,7 +137,6 @@ def setUp(self):
     # XXX The rest of these tests aren't very good -- they don't check much.
     # They do sometimes catch some major disasters, though.
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON urllib.error.URLError: <urlopen error ftp error: error_reply('200 Switching to Binary mode.')>
     @support.requires_resource('walltime')
     def test_ftp(self):
         # Testing the same URL twice exercises the caching in CacheFTPHandler
diff --git a/Lib/test/test_urllib_response.py b/Lib/test/test_urllib_response.py
index 73d2ef0424f..d949fa38bfc 100644
--- a/Lib/test/test_urllib_response.py
+++ b/Lib/test/test_urllib_response.py
@@ -4,6 +4,11 @@
 import tempfile
 import urllib.response
 import unittest
+from test import support
+
+if support.is_wasi:
+    raise unittest.SkipTest("Cannot create socket on WASI")
+
 
 class TestResponse(unittest.TestCase):
 
@@ -43,6 +48,7 @@ def test_addinfo(self):
         info = urllib.response.addinfo(self.fp, self.test_headers)
         self.assertEqual(info.info(), self.test_headers)
         self.assertEqual(info.headers, self.test_headers)
+        info.close()
 
     def test_addinfourl(self):
         url = "http://www.python.org"
@@ -55,6 +61,7 @@ def test_addinfourl(self):
         self.assertEqual(infourl.headers, self.test_headers)
         self.assertEqual(infourl.url, url)
         self.assertEqual(infourl.status, code)
+        infourl.close()
 
     def tearDown(self):
         self.sock.close()
diff --git a/Lib/test/test_wsgiref.py b/Lib/test/test_wsgiref.py
index 1a3b4d4b721..d546e3ef219 100644
--- a/Lib/test/test_wsgiref.py
+++ b/Lib/test/test_wsgiref.py
@@ -134,7 +134,6 @@ def test_environ(self):
             b"Python test,Python test 2;query=test;/path/"
         )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; http library needs to be updated
     def test_request_length(self):
         out, err = run_amock(data=b"GET " + (b"x" * 65537) + b" HTTP/1.0\n\n")
         self.assertEqual(out.splitlines()[0],
diff --git a/Lib/urllib/error.py b/Lib/urllib/error.py
index 8cd901f13f8..a9cd1ecadd6 100644
--- a/Lib/urllib/error.py
+++ b/Lib/urllib/error.py
@@ -10,7 +10,7 @@
 an application may want to handle an exception like a regular
 response.
 """
-
+import io
 import urllib.response
 
 __all__ = ['URLError', 'HTTPError', 'ContentTooShortError']
@@ -42,12 +42,9 @@ def __init__(self, url, code, msg, hdrs, fp):
         self.hdrs = hdrs
         self.fp = fp
         self.filename = url
-        # The addinfourl classes depend on fp being a valid file
-        # object.  In some cases, the HTTPError may not have a valid
-        # file object.  If this happens, the simplest workaround is to
-        # not initialize the base classes.
-        if fp is not None:
-            self.__super_init(fp, hdrs, url, code)
+        if fp is None:
+            fp = io.BytesIO()
+        self.__super_init(fp, hdrs, url, code)
 
     def __str__(self):
         return 'HTTP Error %s: %s' % (self.code, self.msg)
diff --git a/Lib/urllib/parse.py b/Lib/urllib/parse.py
index b35997bc00c..c72138a33ca 100644
--- a/Lib/urllib/parse.py
+++ b/Lib/urllib/parse.py
@@ -25,13 +25,19 @@
 scenarios for parsing, and for backward compatibility purposes, some
 parsing quirks from older RFCs are retained. The testcases in
 test_urlparse.py provides a good indicator of parsing behavior.
+
+The WHATWG URL Parser spec should also be considered.  We are not compliant with
+it either due to existing user code API behavior expectations (Hyrum's Law).
+It serves as a useful guide when making changes.
 """
 
+from collections import namedtuple
+import functools
+import math
 import re
-import sys
 import types
-import collections
 import warnings
+import ipaddress
 
 __all__ = ["urlparse", "urlunparse", "urljoin", "urldefrag",
            "urlsplit", "urlunsplit", "urlencode", "parse_qs",
@@ -46,18 +52,18 @@
 
 uses_relative = ['', 'ftp', 'http', 'gopher', 'nntp', 'imap',
                  'wais', 'file', 'https', 'shttp', 'mms',
-                 'prospero', 'rtsp', 'rtspu', 'sftp',
+                 'prospero', 'rtsp', 'rtsps', 'rtspu', 'sftp',
                  'svn', 'svn+ssh', 'ws', 'wss']
 
 uses_netloc = ['', 'ftp', 'http', 'gopher', 'nntp', 'telnet',
                'imap', 'wais', 'file', 'mms', 'https', 'shttp',
-               'snews', 'prospero', 'rtsp', 'rtspu', 'rsync',
+               'snews', 'prospero', 'rtsp', 'rtsps', 'rtspu', 'rsync',
                'svn', 'svn+ssh', 'sftp', 'nfs', 'git', 'git+ssh',
-               'ws', 'wss']
+               'ws', 'wss', 'itms-services']
 
 uses_params = ['', 'ftp', 'hdl', 'prospero', 'http', 'imap',
-               'https', 'shttp', 'rtsp', 'rtspu', 'sip', 'sips',
-               'mms', 'sftp', 'tel']
+               'https', 'shttp', 'rtsp', 'rtsps', 'rtspu', 'sip',
+               'sips', 'mms', 'sftp', 'tel']
 
 # These are not actually used anymore, but should stay for backwards
 # compatibility.  (They are undocumented, but have a public-looking name.)
@@ -66,7 +72,7 @@
                     'telnet', 'wais', 'imap', 'snews', 'sip', 'sips']
 
 uses_query = ['', 'http', 'wais', 'imap', 'https', 'shttp', 'mms',
-              'gopher', 'rtsp', 'rtspu', 'sip', 'sips']
+              'gopher', 'rtsp', 'rtsps', 'rtspu', 'sip', 'sips']
 
 uses_fragment = ['', 'ftp', 'hdl', 'http', 'gopher', 'news',
                  'nntp', 'wais', 'https', 'shttp', 'snews',
@@ -78,18 +84,17 @@
                 '0123456789'
                 '+-.')
 
+# Leading and trailing C0 control and space to be stripped per WHATWG spec.
+# == "".join([chr(i) for i in range(0, 0x20 + 1)])
+_WHATWG_C0_CONTROL_OR_SPACE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f '
+
 # Unsafe bytes to be removed per WHATWG spec
 _UNSAFE_URL_BYTES_TO_REMOVE = ['\t', '\r', '\n']
 
-# XXX: Consider replacing with functools.lru_cache
-MAX_CACHE_SIZE = 20
-_parse_cache = {}
-
 def clear_cache():
-    """Clear the parse cache and the quoters cache."""
-    _parse_cache.clear()
-    _safe_quoters.clear()
-
+    """Clear internal performance caches. Undocumented; some tests want it."""
+    urlsplit.cache_clear()
+    _byte_quoter_factory.cache_clear()
 
 # Helpers for bytes handling
 # For 3.2, we deliberately require applications that
@@ -171,12 +176,11 @@ def hostname(self):
     def port(self):
         port = self._hostinfo[1]
         if port is not None:
-            try:
-                port = int(port, 10)
-            except ValueError:
-                message = f'Port could not be cast to integer value as {port!r}'
-                raise ValueError(message) from None
-            if not ( 0 <= port <= 65535):
+            if port.isdigit() and port.isascii():
+                port = int(port)
+            else:
+                raise ValueError(f"Port could not be cast to integer value as {port!r}")
+            if not (0 <= port <= 65535):
                 raise ValueError("Port out of range 0-65535")
         return port
 
@@ -243,8 +247,6 @@ def _hostinfo(self):
         return hostname, port
 
 
-from collections import namedtuple
-
 _DefragResultBase = namedtuple('DefragResult', 'url fragment')
 _SplitResultBase = namedtuple(
     'SplitResult', 'scheme netloc path query fragment')
@@ -434,6 +436,37 @@ def _checknetloc(netloc):
             raise ValueError("netloc '" + netloc + "' contains invalid " +
                              "characters under NFKC normalization")
 
+def _check_bracketed_netloc(netloc):
+    # Note that this function must mirror the splitting
+    # done in NetlocResultMixins._hostinfo().
+    hostname_and_port = netloc.rpartition('@')[2]
+    before_bracket, have_open_br, bracketed = hostname_and_port.partition('[')
+    if have_open_br:
+        # No data is allowed before a bracket.
+        if before_bracket:
+            raise ValueError("Invalid IPv6 URL")
+        hostname, _, port = bracketed.partition(']')
+        # No data is allowed after the bracket but before the port delimiter.
+        if port and not port.startswith(":"):
+            raise ValueError("Invalid IPv6 URL")
+    else:
+        hostname, _, port = hostname_and_port.partition(':')
+    _check_bracketed_host(hostname)
+
+# Valid bracketed hosts are defined in
+# https://www.rfc-editor.org/rfc/rfc3986#page-49 and https://url.spec.whatwg.org/
+def _check_bracketed_host(hostname):
+    if hostname.startswith('v'):
+        if not re.match(r"\Av[a-fA-F0-9]+\..+\Z", hostname):
+            raise ValueError(f"IPvFuture address is invalid")
+    else:
+        ip = ipaddress.ip_address(hostname) # Throws Value Error if not IPv6 or IPv4
+        if isinstance(ip, ipaddress.IPv4Address):
+            raise ValueError(f"An IPv4 address cannot be in brackets")
+
+# typed=True avoids BytesWarnings being emitted during cache key
+# comparison since this API supports both bytes and str input.
+@functools.lru_cache(typed=True)
 def urlsplit(url, scheme='', allow_fragments=True):
     """Parse a URL into 5 components:
     <scheme>://<netloc>/<path>?<query>#<fragment>
@@ -456,39 +489,37 @@ def urlsplit(url, scheme='', allow_fragments=True):
     """
 
     url, scheme, _coerce_result = _coerce_args(url, scheme)
+    # Only lstrip url as some applications rely on preserving trailing space.
+    # (https://url.spec.whatwg.org/#concept-basic-url-parser would strip both)
+    url = url.lstrip(_WHATWG_C0_CONTROL_OR_SPACE)
+    scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE)
 
     for b in _UNSAFE_URL_BYTES_TO_REMOVE:
         url = url.replace(b, "")
         scheme = scheme.replace(b, "")
 
     allow_fragments = bool(allow_fragments)
-    key = url, scheme, allow_fragments, type(url), type(scheme)
-    cached = _parse_cache.get(key, None)
-    if cached:
-        return _coerce_result(cached)
-    if len(_parse_cache) >= MAX_CACHE_SIZE: # avoid runaway growth
-        clear_cache()
     netloc = query = fragment = ''
     i = url.find(':')
-    if i > 0:
+    if i > 0 and url[0].isascii() and url[0].isalpha():
         for c in url[:i]:
             if c not in scheme_chars:
                 break
         else:
             scheme, url = url[:i].lower(), url[i+1:]
-
     if url[:2] == '//':
         netloc, url = _splitnetloc(url, 2)
         if (('[' in netloc and ']' not in netloc) or
                 (']' in netloc and '[' not in netloc)):
             raise ValueError("Invalid IPv6 URL")
+        if '[' in netloc and ']' in netloc:
+            _check_bracketed_netloc(netloc)
     if allow_fragments and '#' in url:
         url, fragment = url.split('#', 1)
     if '?' in url:
         url, query = url.split('?', 1)
     _checknetloc(netloc)
     v = SplitResult(scheme, netloc, url, query, fragment)
-    _parse_cache[key] = v
     return _coerce_result(v)
 
 def urlunparse(components):
@@ -510,9 +541,13 @@ def urlunsplit(components):
     empty query; the RFC states that these are equivalent)."""
     scheme, netloc, url, query, fragment, _coerce_result = (
                                           _coerce_args(*components))
-    if netloc or (scheme and scheme in uses_netloc and url[:2] != '//'):
+    if netloc:
         if url and url[:1] != '/': url = '/' + url
-        url = '//' + (netloc or '') + url
+        url = '//' + netloc + url
+    elif url[:2] == '//':
+        url = '//' + url
+    elif scheme and scheme in uses_netloc and (not url or url[:1] == '/'):
+        url = '//' + url
     if scheme:
         url = scheme + ':' + url
     if query:
@@ -611,6 +646,9 @@ def urldefrag(url):
 
 def unquote_to_bytes(string):
     """unquote_to_bytes('abc%20def') -> b'abc def'."""
+    return bytes(_unquote_impl(string))
+
+def _unquote_impl(string: bytes | bytearray | str) -> bytes | bytearray:
     # Note: strings are encoded as UTF-8. This is only an issue if it contains
     # unescaped non-ASCII characters, which URIs should not.
     if not string:
@@ -622,8 +660,8 @@ def unquote_to_bytes(string):
     bits = string.split(b'%')
     if len(bits) == 1:
         return string
-    res = [bits[0]]
-    append = res.append
+    res = bytearray(bits[0])
+    append = res.extend
     # Delay the initialization of the table to not waste memory
     # if the function is never called
     global _hextobyte
@@ -637,10 +675,20 @@ def unquote_to_bytes(string):
         except KeyError:
             append(b'%')
             append(item)
-    return b''.join(res)
+    return res
 
 _asciire = re.compile('([\x00-\x7f]+)')
 
+def _generate_unquoted_parts(string, encoding, errors):
+    previous_match_end = 0
+    for ascii_match in _asciire.finditer(string):
+        start, end = ascii_match.span()
+        yield string[previous_match_end:start]  # Non-ASCII
+        # The ascii_match[1] group == string[start:end].
+        yield _unquote_impl(ascii_match[1]).decode(encoding, errors)
+        previous_match_end = end
+    yield string[previous_match_end:]  # Non-ASCII tail
+
 def unquote(string, encoding='utf-8', errors='replace'):
     """Replace %xx escapes by their single-character equivalent. The optional
     encoding and errors parameters specify how to decode percent-encoded
@@ -652,21 +700,16 @@ def unquote(string, encoding='utf-8', errors='replace'):
     unquote('abc%20def') -> 'abc def'.
     """
     if isinstance(string, bytes):
-        return unquote_to_bytes(string).decode(encoding, errors)
+        return _unquote_impl(string).decode(encoding, errors)
     if '%' not in string:
+        # Is it a string-like object?
         string.split
         return string
     if encoding is None:
         encoding = 'utf-8'
     if errors is None:
         errors = 'replace'
-    bits = _asciire.split(string)
-    res = [bits[0]]
-    append = res.append
-    for i in range(1, len(bits), 2):
-        append(unquote_to_bytes(bits[i]).decode(encoding, errors))
-        append(bits[i + 1])
-    return ''.join(res)
+    return ''.join(_generate_unquoted_parts(string, encoding, errors))
 
 
 def parse_qs(qs, keep_blank_values=False, strict_parsing=False,
@@ -740,11 +783,29 @@ def parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 
         Returns a list, as G-d intended.
     """
-    qs, _coerce_result = _coerce_args(qs)
-    separator, _ = _coerce_args(separator)
 
-    if not separator or (not isinstance(separator, (str, bytes))):
+    if not separator or not isinstance(separator, (str, bytes)):
         raise ValueError("Separator must be of type string or bytes.")
+    if isinstance(qs, str):
+        if not isinstance(separator, str):
+            separator = str(separator, 'ascii')
+        eq = '='
+        def _unquote(s):
+            return unquote_plus(s, encoding=encoding, errors=errors)
+    else:
+        if not qs:
+            return []
+        # Use memoryview() to reject integers and iterables,
+        # acceptable by the bytes constructor.
+        qs = bytes(memoryview(qs))
+        if isinstance(separator, str):
+            separator = bytes(separator, 'ascii')
+        eq = b'='
+        def _unquote(s):
+            return unquote_to_bytes(s.replace(b'+', b' '))
+
+    if not qs:
+        return []
 
     # If max_num_fields is defined then check that the number of fields
     # is less than max_num_fields. This prevents a memory exhaustion DOS
@@ -756,25 +817,14 @@ def parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 
     r = []
     for name_value in qs.split(separator):
-        if not name_value and not strict_parsing:
-            continue
-        nv = name_value.split('=', 1)
-        if len(nv) != 2:
-            if strict_parsing:
+        if name_value or strict_parsing:
+            name, has_eq, value = name_value.partition(eq)
+            if not has_eq and strict_parsing:
                 raise ValueError("bad query field: %r" % (name_value,))
-            # Handle case of a control-name with no equal sign
-            if keep_blank_values:
-                nv.append('')
-            else:
-                continue
-        if len(nv[1]) or keep_blank_values:
-            name = nv[0].replace('+', ' ')
-            name = unquote(name, encoding=encoding, errors=errors)
-            name = _coerce_result(name)
-            value = nv[1].replace('+', ' ')
-            value = unquote(value, encoding=encoding, errors=errors)
-            value = _coerce_result(value)
-            r.append((name, value))
+            if value or keep_blank_values:
+                name = _unquote(name)
+                value = _unquote(value)
+                r.append((name, value))
     return r
 
 def unquote_plus(string, encoding='utf-8', errors='replace'):
@@ -791,23 +841,30 @@ def unquote_plus(string, encoding='utf-8', errors='replace'):
                          b'0123456789'
                          b'_.-~')
 _ALWAYS_SAFE_BYTES = bytes(_ALWAYS_SAFE)
-_safe_quoters = {}
 
-class Quoter(collections.defaultdict):
-    """A mapping from bytes (in range(0,256)) to strings.
+def __getattr__(name):
+    if name == 'Quoter':
+        warnings.warn('Deprecated in 3.11. '
+                      'urllib.parse.Quoter will be removed in Python 3.14. '
+                      'It was not intended to be a public API.',
+                      DeprecationWarning, stacklevel=2)
+        return _Quoter
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+
+class _Quoter(dict):
+    """A mapping from bytes numbers (in range(0,256)) to strings.
 
     String values are percent-encoded byte values, unless the key < 128, and
-    in the "safe" set (either the specified safe set, or default set).
+    in either of the specified safe set, or the always safe set.
     """
-    # Keeps a cache internally, using defaultdict, for efficiency (lookups
+    # Keeps a cache internally, via __missing__, for efficiency (lookups
     # of cached keys don't call Python code at all).
     def __init__(self, safe):
         """safe: bytes object."""
         self.safe = _ALWAYS_SAFE.union(safe)
 
     def __repr__(self):
-        # Without this, will just display as a defaultdict
-        return "<%s %r>" % (self.__class__.__name__, dict(self))
+        return f"<Quoter {dict(self)!r}>"
 
     def __missing__(self, b):
         # Handle a cache miss. Store quoted string in cache and return.
@@ -886,6 +943,11 @@ def quote_plus(string, safe='', encoding=None, errors=None):
     string = quote(string, safe + space, encoding, errors)
     return string.replace(' ', '+')
 
+# Expectation: A typical program is unlikely to create more than 5 of these.
+@functools.lru_cache
+def _byte_quoter_factory(safe):
+    return _Quoter(safe).__getitem__
+
 def quote_from_bytes(bs, safe='/'):
     """Like quote(), but accepts a bytes object rather than a str, and does
     not perform string-to-bytes encoding.  It always returns an ASCII string.
@@ -899,14 +961,19 @@ def quote_from_bytes(bs, safe='/'):
         # Normalize 'safe' by converting to bytes and removing non-ASCII chars
         safe = safe.encode('ascii', 'ignore')
     else:
+        # List comprehensions are faster than generator expressions.
         safe = bytes([c for c in safe if c < 128])
     if not bs.rstrip(_ALWAYS_SAFE_BYTES + safe):
         return bs.decode()
-    try:
-        quoter = _safe_quoters[safe]
-    except KeyError:
-        _safe_quoters[safe] = quoter = Quoter(safe).__getitem__
-    return ''.join([quoter(char) for char in bs])
+    quoter = _byte_quoter_factory(safe)
+    if (bs_len := len(bs)) < 200_000:
+        return ''.join(map(quoter, bs))
+    else:
+        # This saves memory - https://github.com/python/cpython/issues/95865
+        chunk_size = math.isqrt(bs_len)
+        chunks = [''.join(map(quoter, bs[i:i+chunk_size]))
+                  for i in range(0, bs_len, chunk_size)]
+        return ''.join(chunks)
 
 def urlencode(query, doseq=False, safe='', encoding=None, errors=None,
               quote_via=quote_plus):
@@ -939,10 +1006,9 @@ def urlencode(query, doseq=False, safe='', encoding=None, errors=None,
             # but that's a minor nit.  Since the original implementation
             # allowed empty dicts that type of behavior probably should be
             # preserved for consistency
-        except TypeError:
-            ty, va, tb = sys.exc_info()
+        except TypeError as err:
             raise TypeError("not a valid non-string sequence "
-                            "or mapping object").with_traceback(tb)
+                            "or mapping object") from err
 
     l = []
     if not doseq:
@@ -1125,15 +1191,15 @@ def splitnport(host, defport=-1):
 def _splitnport(host, defport=-1):
     """Split host and port, returning numeric port.
     Return given default port if no ':' found; defaults to -1.
-    Return numerical port if a valid number are found after ':'.
+    Return numerical port if a valid number is found after ':'.
     Return None if ':' but not a valid number."""
     host, delim, port = host.rpartition(':')
     if not delim:
         host = port
     elif port:
-        try:
+        if port.isdigit() and port.isascii():
             nport = int(port)
-        except ValueError:
+        else:
             nport = None
         return host, nport
     return host, defport
diff --git a/Lib/urllib/request.py b/Lib/urllib/request.py
index a0ef60b30de..21d76913feb 100644
--- a/Lib/urllib/request.py
+++ b/Lib/urllib/request.py
@@ -11,8 +11,8 @@
 Handlers needed to open the requested URL.  For example, the
 HTTPHandler performs HTTP GET and POST requests and deals with
 non-error returns.  The HTTPRedirectHandler automatically deals with
-HTTP 301, 302, 303 and 307 redirect errors, and the HTTPDigestAuthHandler
-deals with digest authentication.
+HTTP 301, 302, 303, 307, and 308 redirect errors, and the
+HTTPDigestAuthHandler deals with digest authentication.
 
 urlopen(url, data=None) -- Basic usage is the same as original
 urllib.  pass the url and optionally data to post to an HTTP URL, and
@@ -88,7 +88,6 @@
 import http.client
 import io
 import os
-import posixpath
 import re
 import socket
 import string
@@ -137,7 +136,7 @@
 
 _opener = None
 def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
-            *, cafile=None, capath=None, cadefault=False, context=None):
+            *, context=None):
     '''Open the URL url, which can be either a string or a Request object.
 
     *data* must be an object specifying additional data to be sent to
@@ -155,14 +154,6 @@ def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
     If *context* is specified, it must be a ssl.SSLContext instance describing
     the various SSL options. See HTTPSConnection for more details.
 
-    The optional *cafile* and *capath* parameters specify a set of trusted CA
-    certificates for HTTPS requests. cafile should point to a single file
-    containing a bundle of CA certificates, whereas capath should point to a
-    directory of hashed certificate files. More information can be found in
-    ssl.SSLContext.load_verify_locations().
-
-    The *cadefault* parameter is ignored.
-
 
     This function always returns an object which can work as a
     context manager and has the properties url, headers, and status.
@@ -188,25 +179,7 @@ def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
 
     '''
     global _opener
-    if cafile or capath or cadefault:
-        import warnings
-        warnings.warn("cafile, capath and cadefault are deprecated, use a "
-                      "custom context instead.", DeprecationWarning, 2)
-        if context is not None:
-            raise ValueError(
-                "You can't pass both context and any of cafile, capath, and "
-                "cadefault"
-            )
-        if not _have_ssl:
-            raise ValueError('SSL support not available')
-        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH,
-                                             cafile=cafile,
-                                             capath=capath)
-        # send ALPN extension to indicate HTTP/1.1 protocol
-        context.set_alpn_protocols(['http/1.1'])
-        https_handler = HTTPSHandler(context=context)
-        opener = build_opener(https_handler)
-    elif context:
+    if context:
         https_handler = HTTPSHandler(context=context)
         opener = build_opener(https_handler)
     elif _opener is None:
@@ -266,10 +239,7 @@ def urlretrieve(url, filename=None, reporthook=None, data=None):
             if reporthook:
                 reporthook(blocknum, bs, size)
 
-            while True:
-                block = fp.read(bs)
-                if not block:
-                    break
+            while block := fp.read(bs):
                 read += len(block)
                 tfp.write(block)
                 blocknum += 1
@@ -661,7 +631,7 @@ def redirect_request(self, req, fp, code, msg, headers, newurl):
         but another Handler might.
         """
         m = req.get_method()
-        if (not (code in (301, 302, 303, 307) and m in ("GET", "HEAD")
+        if (not (code in (301, 302, 303, 307, 308) and m in ("GET", "HEAD")
             or code in (301, 302, 303) and m == "POST")):
             raise HTTPError(req.full_url, code, msg, headers, fp)
 
@@ -680,6 +650,7 @@ def redirect_request(self, req, fp, code, msg, headers, newurl):
         newheaders = {k: v for k, v in req.headers.items()
                       if k.lower() not in CONTENT_HEADERS}
         return Request(newurl,
+                       method="HEAD" if m == "HEAD" else "GET",
                        headers=newheaders,
                        origin_req_host=req.origin_req_host,
                        unverifiable=True)
@@ -748,7 +719,7 @@ def http_error_302(self, req, fp, code, msg, headers):
 
         return self.parent.open(new, timeout=req.timeout)
 
-    http_error_301 = http_error_303 = http_error_307 = http_error_302
+    http_error_301 = http_error_303 = http_error_307 = http_error_308 = http_error_302
 
     inf_msg = "The HTTP server returned a redirect error that would " \
               "lead to an infinite loop.\n" \
@@ -907,9 +878,9 @@ def find_user_password(self, realm, authuri):
 
 class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self):
         self.authenticated = {}
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
     def add_password(self, realm, uri, user, passwd, is_authenticated=False):
         self.update_authenticated(uri, is_authenticated)
@@ -1255,8 +1226,8 @@ def http_error_407(self, req, fp, code, msg, headers):
 
 class AbstractHTTPHandler(BaseHandler):
 
-    def __init__(self, debuglevel=0):
-        self._debuglevel = debuglevel
+    def __init__(self, debuglevel=None):
+        self._debuglevel = debuglevel if debuglevel is not None else http.client.HTTPConnection.debuglevel
 
     def set_http_debuglevel(self, level):
         self._debuglevel = level
@@ -1382,14 +1353,19 @@ def http_open(self, req):
 
     class HTTPSHandler(AbstractHTTPHandler):
 
-        def __init__(self, debuglevel=0, context=None, check_hostname=None):
+        def __init__(self, debuglevel=None, context=None, check_hostname=None):
+            debuglevel = debuglevel if debuglevel is not None else http.client.HTTPSConnection.debuglevel
             AbstractHTTPHandler.__init__(self, debuglevel)
+            if context is None:
+                http_version = http.client.HTTPSConnection._http_vsn
+                context = http.client._create_https_context(http_version)
+            if check_hostname is not None:
+                context.check_hostname = check_hostname
             self._context = context
-            self._check_hostname = check_hostname
 
         def https_open(self, req):
             return self.do_open(http.client.HTTPSConnection, req,
-                context=self._context, check_hostname=self._check_hostname)
+                                context=self._context)
 
         https_request = AbstractHTTPHandler.do_request_
 
@@ -1561,6 +1537,7 @@ def ftp_open(self, req):
         dirs, file = dirs[:-1], dirs[-1]
         if dirs and not dirs[0]:
             dirs = dirs[1:]
+        fw = None
         try:
             fw = self.connect_ftp(user, passwd, host, port, dirs, req.timeout)
             type = file and 'I' or 'D'
@@ -1578,9 +1555,12 @@ def ftp_open(self, req):
                 headers += "Content-length: %d\n" % retrlen
             headers = email.message_from_string(headers)
             return addinfourl(fp, headers, req.full_url)
-        except ftplib.all_errors as exp:
-            exc = URLError('ftp error: %r' % exp)
-            raise exc.with_traceback(sys.exc_info()[2])
+        except Exception as exp:
+            if fw is not None and not fw.keepalive:
+                fw.close()
+            if isinstance(exp, ftplib.all_errors):
+                raise URLError(exp) from exp
+            raise
 
     def connect_ftp(self, user, passwd, host, port, dirs, timeout):
         return ftpwrapper(user, passwd, host, port, dirs, timeout,
@@ -1604,14 +1584,15 @@ def setMaxConns(self, m):
 
     def connect_ftp(self, user, passwd, host, port, dirs, timeout):
         key = user, host, port, '/'.join(dirs), timeout
-        if key in self.cache:
-            self.timeout[key] = time.time() + self.delay
-        else:
-            self.cache[key] = ftpwrapper(user, passwd, host, port,
-                                         dirs, timeout)
-            self.timeout[key] = time.time() + self.delay
+        conn = self.cache.get(key)
+        if conn is None or not conn.keepalive:
+            if conn is not None:
+                conn.close()
+            conn = self.cache[key] = ftpwrapper(user, passwd, host, port,
+                                                dirs, timeout)
+        self.timeout[key] = time.time() + self.delay
         self.check_cache()
-        return self.cache[key]
+        return conn
 
     def check_cache(self):
         # first check for old ones
@@ -1681,12 +1662,27 @@ def data_open(self, req):
     def url2pathname(pathname):
         """OS-specific conversion from a relative URL of the 'file' scheme
         to a file system path; not recommended for general use."""
-        return unquote(pathname)
+        if pathname[:3] == '///':
+            # URL has an empty authority section, so the path begins on the
+            # third character.
+            pathname = pathname[2:]
+        elif pathname[:12] == '//localhost/':
+            # Skip past 'localhost' authority.
+            pathname = pathname[11:]
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        return unquote(pathname, encoding=encoding, errors=errors)
 
     def pathname2url(pathname):
         """OS-specific conversion from a file system path to a relative URL
         of the 'file' scheme; not recommended for general use."""
-        return quote(pathname)
+        if pathname[:2] == '//':
+            # Add explicitly empty authority to avoid interpreting the path
+            # as authority.
+            pathname = '//' + pathname
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        return quote(pathname, encoding=encoding, errors=errors)
 
 
 ftpcache = {}
@@ -1791,7 +1787,7 @@ def open(self, fullurl, data=None):
         except (HTTPError, URLError):
             raise
         except OSError as msg:
-            raise OSError('socket error', msg).with_traceback(sys.exc_info()[2])
+            raise OSError('socket error', msg) from msg
 
     def open_unknown(self, fullurl, data=None):
         """Overridable interface to open unknown URL type."""
@@ -1845,10 +1841,7 @@ def retrieve(self, url, filename=None, reporthook=None, data=None):
                     size = int(headers["Content-Length"])
                 if reporthook:
                     reporthook(blocknum, bs, size)
-                while 1:
-                    block = fp.read(bs)
-                    if not block:
-                        break
+                while block := fp.read(bs):
                     read += len(block)
                     tfp.write(block)
                     blocknum += 1
@@ -1988,9 +1981,17 @@ def http_error_default(self, url, fp, errcode, errmsg, headers):
 
     if _have_ssl:
         def _https_connection(self, host):
-            return http.client.HTTPSConnection(host,
-                                           key_file=self.key_file,
-                                           cert_file=self.cert_file)
+            if self.key_file or self.cert_file:
+                http_version = http.client.HTTPSConnection._http_vsn
+                context = http.client._create_https_context(http_version)
+                context.load_cert_chain(self.cert_file, self.key_file)
+                # cert and key file means the user wants to authenticate.
+                # enable TLS 1.3 PHA implicitly even for custom contexts.
+                if context.post_handshake_auth is not None:
+                    context.post_handshake_auth = True
+            else:
+                context = None
+            return http.client.HTTPSConnection(host, context=context)
 
         def open_https(self, url, data=None):
             """Use HTTPS protocol."""
@@ -2093,7 +2094,7 @@ def open_ftp(self, url):
             headers = email.message_from_string(headers)
             return addinfourl(fp, headers, "ftp:" + url)
         except ftperrors() as exp:
-            raise URLError('ftp error %r' % exp).with_traceback(sys.exc_info()[2])
+            raise URLError(f'ftp error: {exp}') from exp
 
     def open_data(self, url, data=None):
         """Use "data" URL."""
@@ -2211,6 +2212,13 @@ def http_error_307(self, url, fp, errcode, errmsg, headers, data=None):
         else:
             return self.http_error_default(url, fp, errcode, errmsg, headers)
 
+    def http_error_308(self, url, fp, errcode, errmsg, headers, data=None):
+        """Error 308 -- relocated, but turn POST into error."""
+        if data is None:
+            return self.http_error_301(url, fp, errcode, errmsg, headers, data)
+        else:
+            return self.http_error_default(url, fp, errcode, errmsg, headers)
+
     def http_error_401(self, url, fp, errcode, errmsg, headers, data=None,
             retry=False):
         """Error 401 -- authentication required.
@@ -2436,8 +2444,7 @@ def retrfile(self, file, type):
                 conn, retrlen = self.ftp.ntransfercmd(cmd)
             except ftplib.error_perm as reason:
                 if str(reason)[:3] != '550':
-                    raise URLError('ftp error: %r' % reason).with_traceback(
-                        sys.exc_info()[2])
+                    raise URLError(f'ftp error: {reason}') from reason
         if not conn:
             # Set transfer mode to ASCII!
             self.ftp.voidcmd('TYPE A')
@@ -2464,7 +2471,13 @@ def retrfile(self, file, type):
         return (ftpobj, retrlen)
 
     def endtransfer(self):
+        if not self.busy:
+            return
         self.busy = 0
+        try:
+            self.ftp.voidresp()
+        except ftperrors():
+            pass
 
     def close(self):
         self.keepalive = False
@@ -2492,28 +2505,34 @@ def getproxies_environment():
     this seems to be the standard convention.  If you need a
     different way, you can pass a proxies dictionary to the
     [Fancy]URLopener constructor.
-
     """
-    proxies = {}
     # in order to prefer lowercase variables, process environment in
     # two passes: first matches any, second pass matches lowercase only
-    for name, value in os.environ.items():
-        name = name.lower()
-        if value and name[-6:] == '_proxy':
-            proxies[name[:-6]] = value
+
+    # select only environment variables which end in (after making lowercase) _proxy
+    proxies = {}
+    environment = []
+    for name in os.environ:
+        # fast screen underscore position before more expensive case-folding
+        if len(name) > 5 and name[-6] == "_" and name[-5:].lower() == "proxy":
+            value = os.environ[name]
+            proxy_name = name[:-6].lower()
+            environment.append((name, value, proxy_name))
+            if value:
+                proxies[proxy_name] = value
     # CVE-2016-1000110 - If we are running as CGI script, forget HTTP_PROXY
     # (non-all-lowercase) as it may be set from the web server by a "Proxy:"
     # header from the client
     # If "proxy" is lowercase, it will still be used thanks to the next block
     if 'REQUEST_METHOD' in os.environ:
         proxies.pop('http', None)
-    for name, value in os.environ.items():
+    for name, value, proxy_name in environment:
+        # not case-folded, checking here for lower-case env vars only
         if name[-6:] == '_proxy':
-            name = name.lower()
             if value:
-                proxies[name[:-6]] = value
+                proxies[proxy_name] = value
             else:
-                proxies.pop(name[:-6], None)
+                proxies.pop(proxy_name, None)
     return proxies
 
 def proxy_bypass_environment(host, proxies=None):
@@ -2566,6 +2585,7 @@ def _proxy_bypass_macosx_sysconf(host, proxy_settings):
     }
     """
     from fnmatch import fnmatch
+    from ipaddress import AddressValueError, IPv4Address
 
     hostonly, port = _splitport(host)
 
@@ -2582,20 +2602,17 @@ def ip2num(ipAddr):
             return True
 
     hostIP = None
+    try:
+        hostIP = int(IPv4Address(hostonly))
+    except AddressValueError:
+        pass
 
     for value in proxy_settings.get('exceptions', ()):
         # Items in the list are strings like these: *.local, 169.254/16
         if not value: continue
 
         m = re.match(r"(\d+(?:\.\d+)*)(/\d+)?", value)
-        if m is not None:
-            if hostIP is None:
-                try:
-                    hostIP = socket.gethostbyname(hostonly)
-                    hostIP = ip2num(hostIP)
-                except OSError:
-                    continue
-
+        if m is not None and hostIP is not None:
             base = ip2num(m.group(1))
             mask = m.group(2)
             if mask is None:
@@ -2618,6 +2635,31 @@ def ip2num(ipAddr):
     return False
 
 
+# Same as _proxy_bypass_macosx_sysconf, testable on all platforms
+def _proxy_bypass_winreg_override(host, override):
+    """Return True if the host should bypass the proxy server.
+
+    The proxy override list is obtained from the Windows
+    Internet settings proxy override registry value.
+
+    An example of a proxy override value is:
+    "www.example.com;*.example.net; 192.168.0.1"
+    """
+    from fnmatch import fnmatch
+
+    host, _ = _splitport(host)
+    proxy_override = override.split(';')
+    for test in proxy_override:
+        test = test.strip()
+        # "<local>" should bypass the proxy server for all intranet addresses
+        if test == '<local>':
+            if '.' not in host:
+                return True
+        elif fnmatch(host, test):
+            return True
+    return False
+
+
 if sys.platform == 'darwin':
     from _scproxy import _get_proxy_settings, _get_proxies
 
@@ -2716,7 +2758,7 @@ def proxy_bypass_registry(host):
             import winreg
         except ImportError:
             # Std modules, so should be around - but you never know!
-            return 0
+            return False
         try:
             internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                 r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
@@ -2726,40 +2768,10 @@ def proxy_bypass_registry(host):
                                                      'ProxyOverride')[0])
             # ^^^^ Returned as Unicode but problems if not converted to ASCII
         except OSError:
-            return 0
+            return False
         if not proxyEnable or not proxyOverride:
-            return 0
-        # try to make a host list from name and IP address.
-        rawHost, port = _splitport(host)
-        host = [rawHost]
-        try:
-            addr = socket.gethostbyname(rawHost)
-            if addr != rawHost:
-                host.append(addr)
-        except OSError:
-            pass
-        try:
-            fqdn = socket.getfqdn(rawHost)
-            if fqdn != rawHost:
-                host.append(fqdn)
-        except OSError:
-            pass
-        # make a check value list from the registry entry: replace the
-        # '<local>' string by the localhost entry and the corresponding
-        # canonical entry.
-        proxyOverride = proxyOverride.split(';')
-        # now check if we match one of the registry values.
-        for test in proxyOverride:
-            if test == '<local>':
-                if '.' not in rawHost:
-                    return 1
-            test = test.replace(".", r"\.")     # mask dots
-            test = test.replace("*", r".*")     # change glob sequence
-            test = test.replace("?", r".")      # change glob char
-            for val in host:
-                if re.match(test, val, re.I):
-                    return 1
-        return 0
+            return False
+        return _proxy_bypass_winreg_override(host, proxyOverride)
 
     def proxy_bypass(host):
         """Return True, if host should be bypassed.
diff --git a/Lib/urllib/robotparser.py b/Lib/urllib/robotparser.py
index c58565e3945..63689816f30 100644
--- a/Lib/urllib/robotparser.py
+++ b/Lib/urllib/robotparser.py
@@ -11,6 +11,8 @@
 """
 
 import collections
+import re
+import urllib.error
 import urllib.parse
 import urllib.request
 
@@ -19,6 +21,19 @@
 RequestRate = collections.namedtuple("RequestRate", "requests seconds")
 
 
+def normalize(path):
+    unquoted = urllib.parse.unquote(path, errors='surrogateescape')
+    return urllib.parse.quote(unquoted, errors='surrogateescape')
+
+def normalize_path(path):
+    path, sep, query = path.partition('?')
+    path = normalize(path)
+    if sep:
+        query = re.sub(r'[^=&]+', lambda m: normalize(m[0]), query)
+        path += '?' + query
+    return path
+
+
 class RobotFileParser:
     """ This class provides a set of methods to read, parse and answer
     questions about a single robots.txt file.
@@ -54,7 +69,7 @@ def modified(self):
     def set_url(self, url):
         """Sets the URL referring to a robots.txt file."""
         self.url = url
-        self.host, self.path = urllib.parse.urlparse(url)[1:3]
+        self.host, self.path = urllib.parse.urlsplit(url)[1:3]
 
     def read(self):
         """Reads the robots.txt URL and feeds it to the parser."""
@@ -65,9 +80,10 @@ def read(self):
                 self.disallow_all = True
             elif err.code >= 400 and err.code < 500:
                 self.allow_all = True
+            err.close()
         else:
             raw = f.read()
-            self.parse(raw.decode("utf-8").splitlines())
+            self.parse(raw.decode("utf-8", "surrogateescape").splitlines())
 
     def _add_entry(self, entry):
         if "*" in entry.useragents:
@@ -111,7 +127,7 @@ def parse(self, lines):
             line = line.split(':', 1)
             if len(line) == 2:
                 line[0] = line[0].strip().lower()
-                line[1] = urllib.parse.unquote(line[1].strip())
+                line[1] = line[1].strip()
                 if line[0] == "user-agent":
                     if state == 2:
                         self._add_entry(entry)
@@ -165,10 +181,9 @@ def can_fetch(self, useragent, url):
             return False
         # search for given user agent matches
         # the first match counts
-        parsed_url = urllib.parse.urlparse(urllib.parse.unquote(url))
-        url = urllib.parse.urlunparse(('','',parsed_url.path,
-            parsed_url.params,parsed_url.query, parsed_url.fragment))
-        url = urllib.parse.quote(url)
+        parsed_url = urllib.parse.urlsplit(url)
+        url = urllib.parse.urlunsplit(('', '', *parsed_url[2:]))
+        url = normalize_path(url)
         if not url:
             url = "/"
         for entry in self.entries:
@@ -211,7 +226,6 @@ def __str__(self):
             entries = entries + [self.default_entry]
         return '\n\n'.join(map(str, entries))
 
-
 class RuleLine:
     """A rule line is a single "Allow:" (allowance==True) or "Disallow:"
        (allowance==False) followed by a path."""
@@ -219,8 +233,7 @@ def __init__(self, path, allowance):
         if path == '' and not allowance:
             # an empty value means allow all
             allowance = True
-        path = urllib.parse.urlunparse(urllib.parse.urlparse(path))
-        self.path = urllib.parse.quote(path)
+        self.path = normalize_path(path)
         self.allowance = allowance
 
     def applies_to(self, filename):
@@ -266,7 +279,7 @@ def applies_to(self, useragent):
     def allowance(self, filename):
         """Preconditions:
         - our agent applies to this entry
-        - filename is URL decoded"""
+        - filename is URL encoded"""
         for line in self.rulelines:
             if line.applies_to(filename):
                 return line.allowance

From 380fa39eba2742e81ad4d9344b1a4d883a142abb Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Fri, 16 Jan 2026 16:08:06 +0200
Subject: [PATCH 303/418] Bytecode instrumented placeholder (#6741)

* Add all other bytecodes

* Mark passing/failing tests
---
 Lib/_opcode_metadata.py                       |  98 ++++++++-
 Lib/test/test__opcode.py                      |   2 +-
 .../compiler-core/src/bytecode/instruction.rs | 207 +++++++++++++++++-
 3 files changed, 296 insertions(+), 11 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 3e98489419f..abb748519c3 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -136,10 +136,102 @@
     'JUMP_IF_FALSE_OR_POP': 129,
     'JUMP_IF_TRUE_OR_POP': 130,
     'JUMP_IF_NOT_EXC_MATCH': 131,
-    'SET_EXC_INFO': 134,
-    'SUBSCRIPT': 135,
+    'SET_EXC_INFO': 132,
+    'SUBSCRIPT': 133,
     'RESUME': 149,
-    'LOAD_CLOSURE': 253,
+    'BINARY_OP_ADD_FLOAT': 150,
+    'BINARY_OP_ADD_INT': 151,
+    'BINARY_OP_ADD_UNICODE': 152,
+    'BINARY_OP_MULTIPLY_FLOAT': 153,
+    'BINARY_OP_MULTIPLY_INT': 154,
+    'BINARY_OP_SUBTRACT_FLOAT': 155,
+    'BINARY_OP_SUBTRACT_INT': 156,
+    'BINARY_SUBSCR_DICT': 157,
+    'BINARY_SUBSCR_GETITEM': 158,
+    'BINARY_SUBSCR_LIST_INT': 159,
+    'BINARY_SUBSCR_STR_INT': 160,
+    'BINARY_SUBSCR_TUPLE_INT': 161,
+    'CALL_ALLOC_AND_ENTER_INIT': 162,
+    'CALL_BOUND_METHOD_EXACT_ARGS': 163,
+    'CALL_BOUND_METHOD_GENERAL': 164,
+    'CALL_BUILTIN_CLASS': 165,
+    'CALL_BUILTIN_FAST': 166,
+    'CALL_BUILTIN_FAST_WITH_KEYWORDS': 167,
+    'CALL_BUILTIN_O': 168,
+    'CALL_ISINSTANCE': 169,
+    'CALL_LEN': 170,
+    'CALL_LIST_APPEND': 171,
+    'CALL_METHOD_DESCRIPTOR_FAST': 172,
+    'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS': 173,
+    'CALL_METHOD_DESCRIPTOR_NOARGS': 174,
+    'CALL_METHOD_DESCRIPTOR_O': 175,
+    'CALL_NON_PY_GENERAL': 176,
+    'CALL_PY_EXACT_ARGS': 177,
+    'CALL_PY_GENERAL': 178,
+    'CALL_STR_1': 179,
+    'CALL_TUPLE_1': 180,
+    'CALL_TYPE_1': 181,
+    'COMPARE_OP_FLOAT': 182,
+    'COMPARE_OP_INT': 183,
+    'COMPARE_OP_STR': 184,
+    'CONTAINS_OP_DICT': 185,
+    'CONTAINS_OP_SET': 186,
+    'FOR_ITER_GEN': 187,
+    'FOR_ITER_LIST': 188,
+    'FOR_ITER_RANGE': 189,
+    'FOR_ITER_TUPLE': 190,
+    'LOAD_ATTR_CLASS': 191,
+    'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN': 192,
+    'LOAD_ATTR_INSTANCE_VALUE': 193,
+    'LOAD_ATTR_METHOD_LAZY_DICT': 194,
+    'LOAD_ATTR_METHOD_NO_DICT': 195,
+    'LOAD_ATTR_METHOD_WITH_VALUES': 196,
+    'LOAD_ATTR_MODULE': 197,
+    'LOAD_ATTR_NONDESCRIPTOR_NO_DICT': 198,
+    'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES': 199,
+    'LOAD_ATTR_PROPERTY': 200,
+    'LOAD_ATTR_SLOT': 201,
+    'LOAD_ATTR_WITH_HINT': 202,
+    'LOAD_GLOBAL_BUILTIN': 203,
+    'LOAD_GLOBAL_MODULE': 204,
+    'LOAD_SUPER_ATTR_ATTR': 205,
+    'LOAD_SUPER_ATTR_METHOD': 206,
+    'RESUME_CHECK': 207,
+    'SEND_GEN': 208,
+    'STORE_ATTR_INSTANCE_VALUE': 209,
+    'STORE_ATTR_SLOT': 210,
+    'STORE_ATTR_WITH_HINT': 211,
+    'STORE_SUBSCR_DICT': 212,
+    'STORE_SUBSCR_LIST_INT': 213,
+    'TO_BOOL_ALWAYS_TRUE': 214,
+    'TO_BOOL_BOOL': 215,
+    'TO_BOOL_INT': 216,
+    'TO_BOOL_LIST': 217,
+    'TO_BOOL_NONE': 218,
+    'TO_BOOL_STR': 219,
+    'UNPACK_SEQUENCE_LIST': 220,
+    'UNPACK_SEQUENCE_TUPLE': 221,
+    'UNPACK_SEQUENCE_TWO_TUPLE': 222,
+    'INSTRUMENTED_RESUME': 236,
+    'INSTRUMENTED_END_FOR': 237,
+    'INSTRUMENTED_END_SEND': 238,
+    'INSTRUMENTED_RETURN_VALUE': 239,
+    'INSTRUMENTED_RETURN_CONST': 240,
+    'INSTRUMENTED_YIELD_VALUE': 241,
+    'INSTRUMENTED_LOAD_SUPER_ATTR': 242,
+    'INSTRUMENTED_FOR_ITER': 243,
+    'INSTRUMENTED_CALL': 244,
+    'INSTRUMENTED_CALL_KW': 245,
+    'INSTRUMENTED_CALL_FUNCTION_EX': 246,
+    'INSTRUMENTED_INSTRUCTION': 247,
+    'INSTRUMENTED_JUMP_FORWARD': 248,
+    'INSTRUMENTED_JUMP_BACKWARD': 249,
+    'INSTRUMENTED_POP_JUMP_IF_TRUE': 250,
+    'INSTRUMENTED_POP_JUMP_IF_FALSE': 251,
+    'INSTRUMENTED_POP_JUMP_IF_NONE': 252,
+    'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253,
+    'INSTRUMENTED_LINE': 254,
+    'LOAD_CLOSURE': 255,
     'JUMP': 256,
     'JUMP_NO_INTERRUPT': 257,
     'RESERVED_258': 258,
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index 60dcdc6cd70..045e010db4c 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -16,6 +16,7 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Move LoadClosure to psudoes
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
@@ -27,7 +28,6 @@ def test_invalid_opcodes(self):
         self.check_bool_function_result(_opcode.has_local, invalid, False)
         self.check_bool_function_result(_opcode.has_exc, invalid, False)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON - no instrumented opcodes
     def test_is_valid(self):
         names = [
             'CACHE',
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 3ebb3666ae2..44a57c44320 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -245,10 +245,7 @@ pub enum Instruction {
     YieldValue {
         arg: Arg<u32>,
     } = 118,
-    Resume {
-        arg: Arg<u32>,
-    } = 149,
-    // ==================== RustPython-only instructions (119-135) ====================
+    // ==================== RustPython-only instructions (119-133) ====================
     // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
     // So we assign random IDs to these opcodes.
     Break {
@@ -277,10 +274,106 @@ pub enum Instruction {
         target: Arg<Label>,
     } = 130,
     JumpIfNotExcMatch(Arg<Label>) = 131,
-    SetExcInfo = 134,
-    Subscript = 135,
+    SetExcInfo = 132,
+    Subscript = 133,
+    // End of custom instructions
+    Resume {
+        arg: Arg<u32>,
+    } = 149,
+    BinaryOpAddFloat = 150,                     // Placeholder
+    BinaryOpAddInt = 151,                       // Placeholder
+    BinaryOpAddUnicode = 152,                   // Placeholder
+    BinaryOpMultiplyFloat = 153,                // Placeholder
+    BinaryOpMultiplyInt = 154,                  // Placeholder
+    BinaryOpSubtractFloat = 155,                // Placeholder
+    BinaryOpSubtractInt = 156,                  // Placeholder
+    BinarySubscrDict = 157,                     // Placeholder
+    BinarySubscrGetitem = 158,                  // Placeholder
+    BinarySubscrListInt = 159,                  // Placeholder
+    BinarySubscrStrInt = 160,                   // Placeholder
+    BinarySubscrTupleInt = 161,                 // Placeholder
+    CallAllocAndEnterInit = 162,                // Placeholder
+    CallBoundMethodExactArgs = 163,             // Placeholder
+    CallBoundMethodGeneral = 164,               // Placeholder
+    CallBuiltinClass = 165,                     // Placeholder
+    CallBuiltinFast = 166,                      // Placeholder
+    CallBuiltinFastWithKeywords = 167,          // Placeholder
+    CallBuiltinO = 168,                         // Placeholder
+    CallIsinstance = 169,                       // Placeholder
+    CallLen = 170,                              // Placeholder
+    CallListAppend = 171,                       // Placeholder
+    CallMethodDescriptorFast = 172,             // Placeholder
+    CallMethodDescriptorFastWithKeywords = 173, // Placeholder
+    CallMethodDescriptorNoargs = 174,           // Placeholder
+    CallMethodDescriptorO = 175,                // Placeholder
+    CallNonPyGeneral = 176,                     // Placeholder
+    CallPyExactArgs = 177,                      // Placeholder
+    CallPyGeneral = 178,                        // Placeholder
+    CallStr1 = 179,                             // Placeholder
+    CallTuple1 = 180,                           // Placeholder
+    CallType1 = 181,                            // Placeholder
+    CompareOpFloat = 182,                       // Placeholder
+    CompareOpInt = 183,                         // Placeholder
+    CompareOpStr = 184,                         // Placeholder
+    ContainsOpDict = 185,                       // Placeholder
+    ContainsOpSet = 186,                        // Placeholder
+    ForIterGen = 187,                           // Placeholder
+    ForIterList = 188,                          // Placeholder
+    ForIterRange = 189,                         // Placeholder
+    ForIterTuple = 190,                         // Placeholder
+    LoadAttrClass = 191,                        // Placeholder
+    LoadAttrGetattributeOverridden = 192,       // Placeholder
+    LoadAttrInstanceValue = 193,                // Placeholder
+    LoadAttrMethodLazyDict = 194,               // Placeholder
+    LoadAttrMethodNoDict = 195,                 // Placeholder
+    LoadAttrMethodWithValues = 196,             // Placeholder
+    LoadAttrModule = 197,                       // Placeholder
+    LoadAttrNondescriptorNoDict = 198,          // Placeholder
+    LoadAttrNondescriptorWithValues = 199,      // Placeholder
+    LoadAttrProperty = 200,                     // Placeholder
+    LoadAttrSlot = 201,                         // Placeholder
+    LoadAttrWithHint = 202,                     // Placeholder
+    LoadGlobalBuiltin = 203,                    // Placeholder
+    LoadGlobalModule = 204,                     // Placeholder
+    LoadSuperAttrAttr = 205,                    // Placeholder
+    LoadSuperAttrMethod = 206,                  // Placeholder
+    ResumeCheck = 207,                          // Placeholder
+    SendGen = 208,                              // Placeholder
+    StoreAttrInstanceValue = 209,               // Placeholder
+    StoreAttrSlot = 210,                        // Placeholder
+    StoreAttrWithHint = 211,                    // Placeholder
+    StoreSubscrDict = 212,                      // Placeholder
+    StoreSubscrListInt = 213,                   // Placeholder
+    ToBoolAlwaysTrue = 214,                     // Placeholder
+    ToBoolBool = 215,                           // Placeholder
+    ToBoolInt = 216,                            // Placeholder
+    ToBoolList = 217,                           // Placeholder
+    ToBoolNone = 218,                           // Placeholder
+    ToBoolStr = 219,                            // Placeholder
+    UnpackSequenceList = 220,                   // Placeholder
+    UnpackSequenceTuple = 221,                  // Placeholder
+    UnpackSequenceTwoTuple = 222,               // Placeholder
+    InstrumentedResume = 236,                   // Placeholder
+    InstrumentedEndFor = 237,                   // Placeholder
+    InstrumentedEndSend = 238,                  // Placeholder
+    InstrumentedReturnValue = 239,              // Placeholder
+    InstrumentedReturnConst = 240,              // Placeholder
+    InstrumentedYieldValue = 241,               // Placeholder
+    InstrumentedLoadSuperAttr = 242,            // Placeholder
+    InstrumentedForIter = 243,                  // Placeholder
+    InstrumentedCall = 244,                     // Placeholder
+    InstrumentedCallKw = 245,                   // Placeholder
+    InstrumentedCallFunctionEx = 246,           // Placeholder
+    InstrumentedInstruction = 247,              // Placeholder
+    InstrumentedJumpForward = 248,              // Placeholder
+    InstrumentedJumpBackward = 249,             // Placeholder
+    InstrumentedPopJumpIfTrue = 250,            // Placeholder
+    InstrumentedPopJumpIfFalse = 251,           // Placeholder
+    InstrumentedPopJumpIfNone = 252,            // Placeholder
+    InstrumentedPopJumpIfNotNone = 253,         // Placeholder
+    InstrumentedLine = 254,                     // Placeholder
     // Pseudos (needs to be moved to `PseudoInstruction` enum.
-    LoadClosure(Arg<NameIdx>) = 253, // TODO: Move to pseudos
+    LoadClosure(Arg<NameIdx>) = 255, // TODO: Move to pseudos
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -305,6 +398,12 @@ impl TryFrom<u8> for Instruction {
         // Resume has a non-contiguous opcode (149)
         let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
 
+        let specialized_start = u8::from(Self::BinaryOpAddFloat);
+        let specialized_end = u8::from(Self::UnpackSequenceTwoTuple);
+
+        let instrumented_start = u8::from(Self::InstrumentedResume);
+        let instrumented_end = u8::from(Self::InstrumentedLine);
+
         // TODO: Remove this; This instruction needs to be pseudo
         let load_closure = u8::from(Self::LoadClosure(Arg::marker()));
 
@@ -345,6 +444,8 @@ impl TryFrom<u8> for Instruction {
             || value == resume_id
             || value == load_closure
             || custom_ops.contains(&value)
+            || (specialized_start..=specialized_end).contains(&value)
+            || (instrumented_start..=instrumented_end).contains(&value)
         {
             Ok(unsafe { mem::transmute::<u8, Self>(value) })
         } else {
@@ -589,6 +690,98 @@ impl InstructionMetadata for Instruction {
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
             Self::LoadClosure(_) => 1,
+            Self::BinaryOpAddFloat => 0,
+            Self::BinaryOpAddInt => 0,
+            Self::BinaryOpAddUnicode => 0,
+            Self::BinaryOpMultiplyFloat => 0,
+            Self::BinaryOpMultiplyInt => 0,
+            Self::BinaryOpSubtractFloat => 0,
+            Self::BinaryOpSubtractInt => 0,
+            Self::BinarySubscrDict => 0,
+            Self::BinarySubscrGetitem => 0,
+            Self::BinarySubscrListInt => 0,
+            Self::BinarySubscrStrInt => 0,
+            Self::BinarySubscrTupleInt => 0,
+            Self::CallAllocAndEnterInit => 0,
+            Self::CallBoundMethodExactArgs => 0,
+            Self::CallBoundMethodGeneral => 0,
+            Self::CallBuiltinClass => 0,
+            Self::CallBuiltinFast => 0,
+            Self::CallBuiltinFastWithKeywords => 0,
+            Self::CallBuiltinO => 0,
+            Self::CallIsinstance => 0,
+            Self::CallLen => 0,
+            Self::CallListAppend => 0,
+            Self::CallMethodDescriptorFast => 0,
+            Self::CallMethodDescriptorFastWithKeywords => 0,
+            Self::CallMethodDescriptorNoargs => 0,
+            Self::CallMethodDescriptorO => 0,
+            Self::CallNonPyGeneral => 0,
+            Self::CallPyExactArgs => 0,
+            Self::CallPyGeneral => 0,
+            Self::CallStr1 => 0,
+            Self::CallTuple1 => 0,
+            Self::CallType1 => 0,
+            Self::CompareOpFloat => 0,
+            Self::CompareOpInt => 0,
+            Self::CompareOpStr => 0,
+            Self::ContainsOpDict => 0,
+            Self::ContainsOpSet => 0,
+            Self::ForIterGen => 0,
+            Self::ForIterList => 0,
+            Self::ForIterRange => 0,
+            Self::ForIterTuple => 0,
+            Self::LoadAttrClass => 0,
+            Self::LoadAttrGetattributeOverridden => 0,
+            Self::LoadAttrInstanceValue => 0,
+            Self::LoadAttrMethodLazyDict => 0,
+            Self::LoadAttrMethodNoDict => 0,
+            Self::LoadAttrMethodWithValues => 0,
+            Self::LoadAttrModule => 0,
+            Self::LoadAttrNondescriptorNoDict => 0,
+            Self::LoadAttrNondescriptorWithValues => 0,
+            Self::LoadAttrProperty => 0,
+            Self::LoadAttrSlot => 0,
+            Self::LoadAttrWithHint => 0,
+            Self::LoadGlobalBuiltin => 0,
+            Self::LoadGlobalModule => 0,
+            Self::LoadSuperAttrAttr => 0,
+            Self::LoadSuperAttrMethod => 0,
+            Self::ResumeCheck => 0,
+            Self::SendGen => 0,
+            Self::StoreAttrInstanceValue => 0,
+            Self::StoreAttrSlot => 0,
+            Self::StoreAttrWithHint => 0,
+            Self::StoreSubscrDict => 0,
+            Self::StoreSubscrListInt => 0,
+            Self::ToBoolAlwaysTrue => 0,
+            Self::ToBoolBool => 0,
+            Self::ToBoolInt => 0,
+            Self::ToBoolList => 0,
+            Self::ToBoolNone => 0,
+            Self::ToBoolStr => 0,
+            Self::UnpackSequenceList => 0,
+            Self::UnpackSequenceTuple => 0,
+            Self::UnpackSequenceTwoTuple => 0,
+            Self::InstrumentedResume => 0,
+            Self::InstrumentedEndFor => 0,
+            Self::InstrumentedEndSend => 0,
+            Self::InstrumentedReturnValue => 0,
+            Self::InstrumentedReturnConst => 0,
+            Self::InstrumentedYieldValue => 0,
+            Self::InstrumentedLoadSuperAttr => 0,
+            Self::InstrumentedForIter => 0,
+            Self::InstrumentedCall => 0,
+            Self::InstrumentedCallKw => 0,
+            Self::InstrumentedCallFunctionEx => 0,
+            Self::InstrumentedInstruction => 0,
+            Self::InstrumentedJumpForward => 0,
+            Self::InstrumentedJumpBackward => 0,
+            Self::InstrumentedPopJumpIfTrue => 0,
+            Self::InstrumentedPopJumpIfFalse => 0,
+            Self::InstrumentedPopJumpIfNone => 0,
+            Self::InstrumentedPopJumpIfNotNone => 0,
+            Self::InstrumentedLine => 0,
         }
     }
 

From e9a57d172b45c6394aa179eb994555cd70f3e7b2 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 00:00:16 +0900
Subject: [PATCH 304/418] correct builtins type under function (#6745)

* correct buitins type

* Auto-format: ruff format

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 crates/vm/src/builtins/function.rs      | 26 +++++++++++++++----------
 extra_tests/snippets/builtins_module.py | 11 +++++++++++
 2 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 58c683d3fab..3d5159e58c1 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -2,8 +2,8 @@
 mod jit;
 
 use super::{
-    PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyStr, PyStrRef, PyTuple, PyTupleRef,
-    PyType,
+    PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyModule, PyStr, PyStrRef, PyTuple,
+    PyTupleRef, PyType,
 };
 #[cfg(feature = "jit")]
 use crate::common::lock::OnceCell;
@@ -67,9 +67,15 @@ impl PyFunction {
             if let Some(frame) = vm.current_frame() {
                 frame.builtins.clone().into()
             } else {
-                vm.builtins.clone().into()
+                vm.builtins.dict().into()
             }
         });
+        // If builtins is a module, use its __dict__ instead
+        let builtins = if let Some(module) = builtins.downcast_ref::<PyModule>() {
+            module.dict().into()
+        } else {
+            builtins
+        };
 
         let qualname = vm.ctx.new_str(code.qualname.as_str());
         let func = Self {
@@ -679,11 +685,11 @@ pub struct PyFunctionNewArgs {
     #[pyarg(any, optional)]
     name: OptionalArg<PyStrRef>,
     #[pyarg(any, optional)]
-    defaults: OptionalArg<PyTupleRef>,
+    argdefs: Option<PyTupleRef>,
     #[pyarg(any, optional)]
-    closure: OptionalArg<PyTupleRef>,
+    closure: Option<PyTupleRef>,
     #[pyarg(any, optional)]
-    kwdefaults: OptionalArg<PyDictRef>,
+    kwdefaults: Option<PyDictRef>,
 }
 
 impl Constructor for PyFunction {
@@ -691,7 +697,7 @@ impl Constructor for PyFunction {
 
     fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
         // Handle closure - must be a tuple of cells
-        let closure = if let Some(closure_tuple) = args.closure.into_option() {
+        let closure = if let Some(closure_tuple) = args.closure {
             // Check that closure length matches code's free variables
             if closure_tuple.len() != args.code.freevars.len() {
                 return Err(vm.new_value_error(format!(
@@ -722,10 +728,10 @@ impl Constructor for PyFunction {
         if let Some(closure_tuple) = closure {
             func.closure = Some(closure_tuple);
         }
-        if let Some(defaults) = args.defaults.into_option() {
-            func.defaults_and_kwdefaults.lock().0 = Some(defaults);
+        if let Some(argdefs) = args.argdefs {
+            func.defaults_and_kwdefaults.lock().0 = Some(argdefs);
         }
-        if let Some(kwdefaults) = args.kwdefaults.into_option() {
+        if let Some(kwdefaults) = args.kwdefaults {
             func.defaults_and_kwdefaults.lock().1 = Some(kwdefaults);
         }
 
diff --git a/extra_tests/snippets/builtins_module.py b/extra_tests/snippets/builtins_module.py
index 6dea94d8d77..bf762425c89 100644
--- a/extra_tests/snippets/builtins_module.py
+++ b/extra_tests/snippets/builtins_module.py
@@ -22,6 +22,17 @@
 exec("", namespace)
 assert namespace["__builtins__"] == __builtins__.__dict__
 
+
+# function.__builtins__ should be a dict, not a module
+# See: https://docs.python.org/3/reference/datamodel.html
+def test_func():
+    pass
+
+
+assert isinstance(test_func.__builtins__, dict), (
+    f"function.__builtins__ should be dict, got {type(test_func.__builtins__)}"
+)
+
 # with assert_raises(NameError):
 #     exec('print(__builtins__)', {'__builtins__': {}})
 

From c934265304eccd548e0beba86c4c50e191fc8ba0 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 00:11:20 +0900
Subject: [PATCH 305/418] rename fix_test and support removing unexpected
 success (#6748)

* fix_test to remove unexpected success

* rename fix_test

* Auto-format: ruff format

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 scripts/{fix_test.py => auto_mark_test.py} | 151 +++++++++++++++++++--
 1 file changed, 140 insertions(+), 11 deletions(-)
 rename scripts/{fix_test.py => auto_mark_test.py} (54%)

diff --git a/scripts/fix_test.py b/scripts/auto_mark_test.py
similarity index 54%
rename from scripts/fix_test.py
rename to scripts/auto_mark_test.py
index 1dfea12b8aa..78230954162 100644
--- a/scripts/fix_test.py
+++ b/scripts/auto_mark_test.py
@@ -23,11 +23,17 @@
 """
 
 import argparse
+import ast
 import shutil
 import sys
 from pathlib import Path
 
-from lib_updater import PatchSpec, UtMethod, apply_patches
+from lib_updater import (
+    COMMENT,
+    PatchSpec,
+    UtMethod,
+    apply_patches,
+)
 
 
 def parse_args():
@@ -61,15 +67,18 @@ def __str__(self):
 class TestResult:
     tests_result: str = ""
     tests = []
+    unexpected_successes = []  # Tests that passed but were marked as expectedFailure
     stdout = ""
 
     def __str__(self):
-        return f"TestResult(tests_result={self.tests_result},tests={len(self.tests)})"
+        return f"TestResult(tests_result={self.tests_result},tests={len(self.tests)},unexpected_successes={len(self.unexpected_successes)})"
 
 
 def parse_results(result):
     lines = result.stdout.splitlines()
     test_results = TestResult()
+    test_results.tests = []
+    test_results.unexpected_successes = []
     test_results.stdout = result.stdout
     in_test_results = False
     for line in lines:
@@ -107,6 +116,19 @@ def parse_results(result):
             res = line.split("== Tests result: ")[1]
             res = res.split(" ")[0]
             test_results.tests_result = res
+        # Parse: "UNEXPECTED SUCCESS: test_name (path)"
+        elif line.startswith("UNEXPECTED SUCCESS: "):
+            rest = line[len("UNEXPECTED SUCCESS: ") :]
+            # Format: "test_name (path)"
+            first_space = rest.find(" ")
+            if first_space > 0:
+                test = Test()
+                test.name = rest[:first_space]
+                path_part = rest[first_space:].strip()
+                if path_part.startswith("(") and path_part.endswith(")"):
+                    test.path = path_part[1:-1]
+                    test.result = "unexpected_success"
+                    test_results.unexpected_successes.append(test)
     return test_results
 
 
@@ -117,6 +139,95 @@ def path_to_test(path) -> list[str]:
     return parts[-2:]  # Get class name and method name
 
 
+def is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if the method body is just 'return super().method_name()'."""
+    if len(func_node.body) != 1:
+        return False
+    stmt = func_node.body[0]
+    if not isinstance(stmt, ast.Return) or stmt.value is None:
+        return False
+    # Check for super().method_name() pattern
+    call = stmt.value
+    if not isinstance(call, ast.Call):
+        return False
+    if not isinstance(call.func, ast.Attribute):
+        return False
+    super_call = call.func.value
+    if not isinstance(super_call, ast.Call):
+        return False
+    if not isinstance(super_call.func, ast.Name) or super_call.func.id != "super":
+        return False
+    return True
+
+
+def remove_expected_failures(
+    contents: str, tests_to_remove: set[tuple[str, str]]
+) -> str:
+    """Remove @unittest.expectedFailure decorators from tests that now pass."""
+    if not tests_to_remove:
+        return contents
+
+    tree = ast.parse(contents)
+    lines = contents.splitlines()
+    lines_to_remove = set()
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        class_name = node.name
+        for item in node.body:
+            if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            method_name = item.name
+            if (class_name, method_name) not in tests_to_remove:
+                continue
+
+            # Check if we should remove the entire method (super() call only)
+            remove_entire_method = is_super_call_only(item)
+
+            if remove_entire_method:
+                # Remove entire method including decorators and any preceding comment
+                first_line = item.lineno - 1  # 0-indexed, def line
+                if item.decorator_list:
+                    first_line = item.decorator_list[0].lineno - 1
+                # Check for TODO comment before first decorator/def
+                if first_line > 0:
+                    prev_line = lines[first_line - 1].strip()
+                    if prev_line.startswith("#") and COMMENT in prev_line:
+                        first_line -= 1
+                # Remove from first_line to end_lineno (inclusive)
+                for i in range(first_line, item.end_lineno):
+                    lines_to_remove.add(i)
+            else:
+                # Only remove the expectedFailure decorator
+                for dec in item.decorator_list:
+                    dec_line = dec.lineno - 1  # 0-indexed
+                    line_content = lines[dec_line]
+
+                    # Check if it's @unittest.expectedFailure
+                    if "expectedFailure" not in line_content:
+                        continue
+
+                    # Check if TODO: RUSTPYTHON is on the same line or the line before
+                    has_comment_on_line = COMMENT in line_content
+                    has_comment_before = (
+                        dec_line > 0
+                        and lines[dec_line - 1].strip().startswith("#")
+                        and COMMENT in lines[dec_line - 1]
+                    )
+
+                    if has_comment_on_line or has_comment_before:
+                        lines_to_remove.add(dec_line)
+                        if has_comment_before:
+                            lines_to_remove.add(dec_line - 1)
+
+    # Remove lines in reverse order to maintain line numbers
+    for line_idx in sorted(lines_to_remove, reverse=True):
+        del lines[line_idx]
+
+    return "\n".join(lines) + "\n" if lines else ""
+
+
 def build_patches(test_parts_set: set[tuple[str, str]]) -> dict:
     """Convert failing tests to lib_updater patch format."""
     patches = {}
@@ -190,20 +301,38 @@ def run_test(test_name):
     f = test_path.read_text(encoding="utf-8")
 
     # Collect failing tests (with deduplication for subtests)
-    seen_tests = set()  # Track (class_name, method_name) to avoid duplicates
+    failing_tests = set()  # Track (class_name, method_name) to avoid duplicates
     for test in tests.tests:
         if test.result == "fail" or test.result == "error":
             test_parts = path_to_test(test.path)
             if len(test_parts) == 2:
                 test_key = tuple(test_parts)
-                if test_key not in seen_tests:
-                    seen_tests.add(test_key)
-                    print(f"Marking test: {test_parts[0]}.{test_parts[1]}")
-
-    # Apply patches using lib_updater
-    if seen_tests:
-        patches = build_patches(seen_tests)
+                if test_key not in failing_tests:
+                    failing_tests.add(test_key)
+                    print(f"Marking as failing: {test_parts[0]}.{test_parts[1]}")
+
+    # Collect unexpected successes (tests that now pass but have expectedFailure)
+    unexpected_successes = set()
+    for test in tests.unexpected_successes:
+        test_parts = path_to_test(test.path)
+        if len(test_parts) == 2:
+            test_key = tuple(test_parts)
+            if test_key not in unexpected_successes:
+                unexpected_successes.add(test_key)
+                print(f"Removing expectedFailure: {test_parts[0]}.{test_parts[1]}")
+
+    # Remove expectedFailure from tests that now pass
+    if unexpected_successes:
+        f = remove_expected_failures(f, unexpected_successes)
+
+    # Apply patches for failing tests
+    if failing_tests:
+        patches = build_patches(failing_tests)
         f = apply_patches(f, patches)
+
+    # Write changes if any modifications were made
+    if failing_tests or unexpected_successes:
         test_path.write_text(f, encoding="utf-8")
 
-    print(f"Modified {len(seen_tests)} tests")
+    print(f"Added expectedFailure to {len(failing_tests)} tests")
+    print(f"Removed expectedFailure from {len(unexpected_successes)} tests")

From 833f7343c874c284973fe220e274239d5a72cb5e Mon Sep 17 00:00:00 2001
From: Terry Tianlin Luan <44815845+terryluan12@users.noreply.github.com>
Date: Sat, 17 Jan 2026 04:15:35 -0500
Subject: [PATCH 306/418] Update email library  v3.13.11 (#6642)

* Updated the email library + added test suite

* Added Windows altzone + Fixed memory error in `bytes_inner.rs`
---
 Lib/email/_header_value_parser.py             |   35 +-
 Lib/email/_parseaddr.py                       |   13 +-
 Lib/email/_policybase.py                      |    2 +-
 Lib/email/contentmanager.py                   |   12 +-
 Lib/email/feedparser.py                       |    4 +-
 Lib/email/generator.py                        |    2 +-
 Lib/email/header.py                           |   17 +-
 Lib/email/message.py                          |   40 +-
 Lib/email/parser.py                           |   14 +-
 Lib/email/utils.py                            |   10 +-
 Lib/test/test_context.py                      |    2 +
 Lib/test/test_email/__init__.py               |  167 +
 Lib/test/test_email/__main__.py               |    4 +
 Lib/test/test_email/data/msg_01.txt           |   19 +
 Lib/test/test_email/data/msg_02.txt           |  136 +
 Lib/test/test_email/data/msg_03.txt           |   16 +
 Lib/test/test_email/data/msg_04.txt           |   37 +
 Lib/test/test_email/data/msg_05.txt           |   28 +
 Lib/test/test_email/data/msg_06.txt           |   33 +
 Lib/test/test_email/data/msg_07.txt           |   83 +
 Lib/test/test_email/data/msg_08.txt           |   24 +
 Lib/test/test_email/data/msg_09.txt           |   24 +
 Lib/test/test_email/data/msg_10.txt           |   39 +
 Lib/test/test_email/data/msg_11.txt           |    7 +
 Lib/test/test_email/data/msg_12.txt           |   36 +
 Lib/test/test_email/data/msg_12a.txt          |   38 +
 Lib/test/test_email/data/msg_13.txt           |   94 +
 Lib/test/test_email/data/msg_14.txt           |   23 +
 Lib/test/test_email/data/msg_15.txt           |   52 +
 Lib/test/test_email/data/msg_16.txt           |  123 +
 Lib/test/test_email/data/msg_17.txt           |   12 +
 Lib/test/test_email/data/msg_18.txt           |    6 +
 Lib/test/test_email/data/msg_19.txt           |   43 +
 Lib/test/test_email/data/msg_20.txt           |   22 +
 Lib/test/test_email/data/msg_21.txt           |   20 +
 Lib/test/test_email/data/msg_22.txt           |   46 +
 Lib/test/test_email/data/msg_23.txt           |    8 +
 Lib/test/test_email/data/msg_24.txt           |   10 +
 Lib/test/test_email/data/msg_25.txt           |  117 +
 Lib/test/test_email/data/msg_26.txt           |   46 +
 Lib/test/test_email/data/msg_27.txt           |   15 +
 Lib/test/test_email/data/msg_28.txt           |   25 +
 Lib/test/test_email/data/msg_29.txt           |   22 +
 Lib/test/test_email/data/msg_30.txt           |   23 +
 Lib/test/test_email/data/msg_31.txt           |   15 +
 Lib/test/test_email/data/msg_32.txt           |   14 +
 Lib/test/test_email/data/msg_33.txt           |   29 +
 Lib/test/test_email/data/msg_34.txt           |   19 +
 Lib/test/test_email/data/msg_35.txt           |    4 +
 Lib/test/test_email/data/msg_36.txt           |   40 +
 Lib/test/test_email/data/msg_37.txt           |   22 +
 Lib/test/test_email/data/msg_38.txt           |  101 +
 Lib/test/test_email/data/msg_39.txt           |   83 +
 Lib/test/test_email/data/msg_40.txt           |   10 +
 Lib/test/test_email/data/msg_41.txt           |    8 +
 Lib/test/test_email/data/msg_42.txt           |   20 +
 Lib/test/test_email/data/msg_43.txt           |  217 +
 Lib/test/test_email/data/msg_44.txt           |   33 +
 Lib/test/test_email/data/msg_45.txt           |   33 +
 Lib/test/test_email/data/msg_46.txt           |   23 +
 Lib/test/test_email/data/msg_47.txt           |   14 +
 Lib/test/test_email/data/python.bmp           |  Bin 0 -> 1162 bytes
 Lib/test/test_email/data/python.exr           |  Bin 0 -> 2635 bytes
 Lib/test/test_email/data/python.gif           |  Bin 0 -> 405 bytes
 Lib/test/test_email/data/python.jpg           |  Bin 0 -> 543 bytes
 Lib/test/test_email/data/python.pbm           |    3 +
 Lib/test/test_email/data/python.pgm           |  Bin 0 -> 269 bytes
 Lib/test/test_email/data/python.png           |  Bin 0 -> 1020 bytes
 Lib/test/test_email/data/python.ppm           |  Bin 0 -> 781 bytes
 Lib/test/test_email/data/python.ras           |  Bin 0 -> 1056 bytes
 Lib/test/test_email/data/python.sgi           |  Bin 0 -> 1967 bytes
 Lib/test/test_email/data/python.tiff          |  Bin 0 -> 1326 bytes
 Lib/test/test_email/data/python.webp          |  Bin 0 -> 432 bytes
 Lib/test/test_email/data/python.xbm           |    6 +
 Lib/test/test_email/data/sndhdr.aifc          |  Bin 0 -> 106 bytes
 Lib/test/test_email/data/sndhdr.aiff          |  Bin 0 -> 108 bytes
 Lib/test/test_email/data/sndhdr.au            |  Bin 0 -> 28144 bytes
 Lib/test/test_email/data/sndhdr.wav           |  Bin 0 -> 64 bytes
 Lib/test/test_email/test__encoded_words.py    |  208 +
 .../test_email/test__header_value_parser.py   | 3259 +++++++++
 Lib/test/test_email/test_asian_codecs.py      |   81 +
 Lib/test/test_email/test_contentmanager.py    |  836 +++
 Lib/test/test_email/test_defect_handling.py   |  337 +
 Lib/test/test_email/test_email.py             | 5907 +++++++++++++++++
 Lib/test/test_email/test_generator.py         |  477 ++
 Lib/test/test_email/test_headerregistry.py    | 1822 +++++
 Lib/test/test_email/test_inversion.py         |   78 +
 Lib/test/test_email/test_message.py           | 1094 +++
 Lib/test/test_email/test_parser.py            |  110 +
 Lib/test/test_email/test_pickleable.py        |   76 +
 Lib/test/test_email/test_policy.py            |  429 ++
 Lib/test/test_email/test_utils.py             |  186 +
 Lib/test/test_email/torture_test.py           |  127 +
 Lib/test/test_time.py                         |    2 -
 crates/vm/src/stdlib/time.rs                  |   17 +
 95 files changed, 17238 insertions(+), 51 deletions(-)
 create mode 100644 Lib/test/test_email/__init__.py
 create mode 100644 Lib/test/test_email/__main__.py
 create mode 100644 Lib/test/test_email/data/msg_01.txt
 create mode 100644 Lib/test/test_email/data/msg_02.txt
 create mode 100644 Lib/test/test_email/data/msg_03.txt
 create mode 100644 Lib/test/test_email/data/msg_04.txt
 create mode 100644 Lib/test/test_email/data/msg_05.txt
 create mode 100644 Lib/test/test_email/data/msg_06.txt
 create mode 100644 Lib/test/test_email/data/msg_07.txt
 create mode 100644 Lib/test/test_email/data/msg_08.txt
 create mode 100644 Lib/test/test_email/data/msg_09.txt
 create mode 100644 Lib/test/test_email/data/msg_10.txt
 create mode 100644 Lib/test/test_email/data/msg_11.txt
 create mode 100644 Lib/test/test_email/data/msg_12.txt
 create mode 100644 Lib/test/test_email/data/msg_12a.txt
 create mode 100644 Lib/test/test_email/data/msg_13.txt
 create mode 100644 Lib/test/test_email/data/msg_14.txt
 create mode 100644 Lib/test/test_email/data/msg_15.txt
 create mode 100644 Lib/test/test_email/data/msg_16.txt
 create mode 100644 Lib/test/test_email/data/msg_17.txt
 create mode 100644 Lib/test/test_email/data/msg_18.txt
 create mode 100644 Lib/test/test_email/data/msg_19.txt
 create mode 100644 Lib/test/test_email/data/msg_20.txt
 create mode 100644 Lib/test/test_email/data/msg_21.txt
 create mode 100644 Lib/test/test_email/data/msg_22.txt
 create mode 100644 Lib/test/test_email/data/msg_23.txt
 create mode 100644 Lib/test/test_email/data/msg_24.txt
 create mode 100644 Lib/test/test_email/data/msg_25.txt
 create mode 100644 Lib/test/test_email/data/msg_26.txt
 create mode 100644 Lib/test/test_email/data/msg_27.txt
 create mode 100644 Lib/test/test_email/data/msg_28.txt
 create mode 100644 Lib/test/test_email/data/msg_29.txt
 create mode 100644 Lib/test/test_email/data/msg_30.txt
 create mode 100644 Lib/test/test_email/data/msg_31.txt
 create mode 100644 Lib/test/test_email/data/msg_32.txt
 create mode 100644 Lib/test/test_email/data/msg_33.txt
 create mode 100644 Lib/test/test_email/data/msg_34.txt
 create mode 100644 Lib/test/test_email/data/msg_35.txt
 create mode 100644 Lib/test/test_email/data/msg_36.txt
 create mode 100644 Lib/test/test_email/data/msg_37.txt
 create mode 100644 Lib/test/test_email/data/msg_38.txt
 create mode 100644 Lib/test/test_email/data/msg_39.txt
 create mode 100644 Lib/test/test_email/data/msg_40.txt
 create mode 100644 Lib/test/test_email/data/msg_41.txt
 create mode 100644 Lib/test/test_email/data/msg_42.txt
 create mode 100644 Lib/test/test_email/data/msg_43.txt
 create mode 100644 Lib/test/test_email/data/msg_44.txt
 create mode 100644 Lib/test/test_email/data/msg_45.txt
 create mode 100644 Lib/test/test_email/data/msg_46.txt
 create mode 100644 Lib/test/test_email/data/msg_47.txt
 create mode 100644 Lib/test/test_email/data/python.bmp
 create mode 100644 Lib/test/test_email/data/python.exr
 create mode 100644 Lib/test/test_email/data/python.gif
 create mode 100644 Lib/test/test_email/data/python.jpg
 create mode 100644 Lib/test/test_email/data/python.pbm
 create mode 100644 Lib/test/test_email/data/python.pgm
 create mode 100644 Lib/test/test_email/data/python.png
 create mode 100644 Lib/test/test_email/data/python.ppm
 create mode 100644 Lib/test/test_email/data/python.ras
 create mode 100644 Lib/test/test_email/data/python.sgi
 create mode 100644 Lib/test/test_email/data/python.tiff
 create mode 100644 Lib/test/test_email/data/python.webp
 create mode 100644 Lib/test/test_email/data/python.xbm
 create mode 100644 Lib/test/test_email/data/sndhdr.aifc
 create mode 100644 Lib/test/test_email/data/sndhdr.aiff
 create mode 100644 Lib/test/test_email/data/sndhdr.au
 create mode 100644 Lib/test/test_email/data/sndhdr.wav
 create mode 100644 Lib/test/test_email/test__encoded_words.py
 create mode 100644 Lib/test/test_email/test__header_value_parser.py
 create mode 100644 Lib/test/test_email/test_asian_codecs.py
 create mode 100644 Lib/test/test_email/test_contentmanager.py
 create mode 100644 Lib/test/test_email/test_defect_handling.py
 create mode 100644 Lib/test/test_email/test_email.py
 create mode 100644 Lib/test/test_email/test_generator.py
 create mode 100644 Lib/test/test_email/test_headerregistry.py
 create mode 100644 Lib/test/test_email/test_inversion.py
 create mode 100644 Lib/test/test_email/test_message.py
 create mode 100644 Lib/test/test_email/test_parser.py
 create mode 100644 Lib/test/test_email/test_pickleable.py
 create mode 100644 Lib/test/test_email/test_policy.py
 create mode 100644 Lib/test/test_email/test_utils.py
 create mode 100644 Lib/test/test_email/torture_test.py

diff --git a/Lib/email/_header_value_parser.py b/Lib/email/_header_value_parser.py
index ec2215a5e5f..91243378dc0 100644
--- a/Lib/email/_header_value_parser.py
+++ b/Lib/email/_header_value_parser.py
@@ -95,8 +95,16 @@
 NLSET = {'\n', '\r'}
 SPECIALSNL = SPECIALS | NLSET
 
+
+def make_quoted_pairs(value):
+    """Escape dquote and backslash for use within a quoted-string."""
+    return str(value).replace('\\', '\\\\').replace('"', '\\"')
+
+
 def quote_string(value):
-    return '"'+str(value).replace('\\', '\\\\').replace('"', r'\"')+'"'
+    escaped = make_quoted_pairs(value)
+    return f'"{escaped}"'
+
 
 # Match a RFC 2047 word, looks like =?utf-8?q?someword?=
 rfc2047_matcher = re.compile(r'''
@@ -1012,6 +1020,8 @@ def _get_ptext_to_endchars(value, endchars):
     a flag that is True iff there were any quoted printables decoded.
 
     """
+    if not value:
+        return '', '', False
     fragment, *remainder = _wsp_splitter(value, 1)
     vchars = []
     escape = False
@@ -1045,7 +1055,7 @@ def get_fws(value):
     fws = WhiteSpaceTerminal(value[:len(value)-len(newvalue)], 'fws')
     return fws, newvalue
 
-def get_encoded_word(value):
+def get_encoded_word(value, terminal_type='vtext'):
     """ encoded-word = "=?" charset "?" encoding "?" encoded-text "?="
 
     """
@@ -1084,7 +1094,7 @@ def get_encoded_word(value):
             ew.append(token)
             continue
         chars, *remainder = _wsp_splitter(text, 1)
-        vtext = ValueTerminal(chars, 'vtext')
+        vtext = ValueTerminal(chars, terminal_type)
         _validate_xtext(vtext)
         ew.append(vtext)
         text = ''.join(remainder)
@@ -1126,7 +1136,7 @@ def get_unstructured(value):
         valid_ew = True
         if value.startswith('=?'):
             try:
-                token, value = get_encoded_word(value)
+                token, value = get_encoded_word(value, 'utext')
             except _InvalidEwError:
                 valid_ew = False
             except errors.HeaderParseError:
@@ -1155,7 +1165,7 @@ def get_unstructured(value):
         # the parser to go in an infinite loop.
         if valid_ew and rfc2047_matcher.search(tok):
             tok, *remainder = value.partition('=?')
-        vtext = ValueTerminal(tok, 'vtext')
+        vtext = ValueTerminal(tok, 'utext')
         _validate_xtext(vtext)
         unstructured.append(vtext)
         value = ''.join(remainder)
@@ -1565,7 +1575,7 @@ def get_dtext(value):
 def _check_for_early_dl_end(value, domain_literal):
     if value:
         return False
-    domain_literal.append(errors.InvalidHeaderDefect(
+    domain_literal.defects.append(errors.InvalidHeaderDefect(
         "end of input inside domain-literal"))
     domain_literal.append(ValueTerminal(']', 'domain-literal-end'))
     return True
@@ -1584,9 +1594,9 @@ def get_domain_literal(value):
         raise errors.HeaderParseError("expected '[' at start of domain-literal "
                 "but found '{}'".format(value))
     value = value[1:]
+    domain_literal.append(ValueTerminal('[', 'domain-literal-start'))
     if _check_for_early_dl_end(value, domain_literal):
         return domain_literal, value
-    domain_literal.append(ValueTerminal('[', 'domain-literal-start'))
     if value[0] in WSP:
         token, value = get_fws(value)
         domain_literal.append(token)
@@ -2805,7 +2815,7 @@ def _refold_parse_tree(parse_tree, *, policy):
             continue
         tstr = str(part)
         if not want_encoding:
-            if part.token_type == 'ptext':
+            if part.token_type in ('ptext', 'vtext'):
                 # Encode if tstr contains special characters.
                 want_encoding = not SPECIALSNL.isdisjoint(tstr)
             else:
@@ -2905,6 +2915,15 @@ def _refold_parse_tree(parse_tree, *, policy):
         if not hasattr(part, 'encode'):
             # It's not a terminal, try folding the subparts.
             newparts = list(part)
+            if part.token_type == 'bare-quoted-string':
+                # To fold a quoted string we need to create a list of terminal
+                # tokens that will render the leading and trailing quotes
+                # and use quoted pairs in the value as appropriate.
+                newparts = (
+                    [ValueTerminal('"', 'ptext')] +
+                    [ValueTerminal(make_quoted_pairs(p), 'ptext')
+                     for p in newparts] +
+                    [ValueTerminal('"', 'ptext')])
             if not part.as_ew_allowed:
                 wrap_as_ew_blocked += 1
                 newparts.append(end_ew_not_allowed)
diff --git a/Lib/email/_parseaddr.py b/Lib/email/_parseaddr.py
index 0f1bf8e4253..565af0cf361 100644
--- a/Lib/email/_parseaddr.py
+++ b/Lib/email/_parseaddr.py
@@ -146,8 +146,9 @@ def _parsedate_tz(data):
         return None
     # Check for a yy specified in two-digit format, then convert it to the
     # appropriate four-digit format, according to the POSIX standard. RFC 822
-    # calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822)
-    # mandates a 4-digit yy. For more information, see the documentation for
+    # calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822) already
+    # mandated a 4-digit yy, and RFC 5322 (which obsoletes RFC 2822) continues
+    # this requirement. For more information, see the documentation for
     # the time module.
     if yy < 100:
         # The year is between 1969 and 1999 (inclusive).
@@ -233,9 +234,11 @@ def __init__(self, field):
         self.CR = '\r\n'
         self.FWS = self.LWS + self.CR
         self.atomends = self.specials + self.LWS + self.CR
-        # Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it
-        # is obsolete syntax.  RFC 2822 requires that we recognize obsolete
-        # syntax, so allow dots in phrases.
+        # Note that RFC 2822 section 4.1 introduced '.' as obs-phrase to handle
+        # existing practice (periods in display names), even though it was not
+        # allowed in RFC 822. RFC 5322 section 4.1 (which obsoletes RFC 2822)
+        # continues this requirement. We must recognize obsolete syntax, so
+        # allow dots in phrases.
         self.phraseends = self.atomends.replace('.', '')
         self.field = field
         self.commentlist = []
diff --git a/Lib/email/_policybase.py b/Lib/email/_policybase.py
index c9f0d743090..0d486c90a9c 100644
--- a/Lib/email/_policybase.py
+++ b/Lib/email/_policybase.py
@@ -370,7 +370,7 @@ def _fold(self, name, value, sanitize):
             h = value
         if h is not None:
             # The Header class interprets a value of None for maxlinelen as the
-            # default value of 78, as recommended by RFC 2822.
+            # default value of 78, as recommended by RFC 5322 section 2.1.1.
             maxlinelen = 0
             if self.max_line_length is not None:
                 maxlinelen = self.max_line_length
diff --git a/Lib/email/contentmanager.py b/Lib/email/contentmanager.py
index b4f5830bead..11d1536db27 100644
--- a/Lib/email/contentmanager.py
+++ b/Lib/email/contentmanager.py
@@ -2,6 +2,7 @@
 import email.charset
 import email.message
 import email.errors
+import sys
 from email import quoprimime
 
 class ContentManager:
@@ -142,13 +143,15 @@ def _encode_base64(data, max_line_length):
 
 
 def _encode_text(string, charset, cte, policy):
+    # If max_line_length is 0 or None, there is no limit.
+    maxlen = policy.max_line_length or sys.maxsize
     lines = string.encode(charset).splitlines()
     linesep = policy.linesep.encode('ascii')
     def embedded_body(lines): return linesep.join(lines) + linesep
     def normal_body(lines): return b'\n'.join(lines) + b'\n'
     if cte is None:
         # Use heuristics to decide on the "best" encoding.
-        if max((len(x) for x in lines), default=0) <= policy.max_line_length:
+        if max(map(len, lines), default=0) <= maxlen:
             try:
                 return '7bit', normal_body(lines).decode('ascii')
             except UnicodeDecodeError:
@@ -156,8 +159,7 @@ def normal_body(lines): return b'\n'.join(lines) + b'\n'
             if policy.cte_type == '8bit':
                 return '8bit', normal_body(lines).decode('ascii', 'surrogateescape')
         sniff = embedded_body(lines[:10])
-        sniff_qp = quoprimime.body_encode(sniff.decode('latin-1'),
-                                          policy.max_line_length)
+        sniff_qp = quoprimime.body_encode(sniff.decode('latin-1'), maxlen)
         sniff_base64 = binascii.b2a_base64(sniff)
         # This is a little unfair to qp; it includes lineseps, base64 doesn't.
         if len(sniff_qp) > len(sniff_base64):
@@ -172,9 +174,9 @@ def normal_body(lines): return b'\n'.join(lines) + b'\n'
         data = normal_body(lines).decode('ascii', 'surrogateescape')
     elif cte == 'quoted-printable':
         data = quoprimime.body_encode(normal_body(lines).decode('latin-1'),
-                                      policy.max_line_length)
+                                      maxlen)
     elif cte == 'base64':
-        data = _encode_base64(embedded_body(lines), policy.max_line_length)
+        data = _encode_base64(embedded_body(lines), maxlen)
     else:
         raise ValueError("Unknown content transfer encoding {}".format(cte))
     return cte, data
diff --git a/Lib/email/feedparser.py b/Lib/email/feedparser.py
index 06d6b4a3afc..bc773f38030 100644
--- a/Lib/email/feedparser.py
+++ b/Lib/email/feedparser.py
@@ -32,7 +32,7 @@
 NLCRE_bol = re.compile(r'(\r\n|\r|\n)')
 NLCRE_eol = re.compile(r'(\r\n|\r|\n)\Z')
 NLCRE_crack = re.compile(r'(\r\n|\r|\n)')
-# RFC 2822 $3.6.8 Optional fields.  ftext is %d33-57 / %d59-126, Any character
+# RFC 5322 section 3.6.8 Optional fields.  ftext is %d33-57 / %d59-126, Any character
 # except controls, SP, and ":".
 headerRE = re.compile(r'^(From |[\041-\071\073-\176]*:|[\t ])')
 EMPTYSTRING = ''
@@ -294,7 +294,7 @@ def _parsegen(self):
             return
         if self._cur.get_content_maintype() == 'message':
             # The message claims to be a message/* type, then what follows is
-            # another RFC 2822 message.
+            # another RFC 5322 message.
             for retval in self._parsegen():
                 if retval is NeedMoreData:
                     yield NeedMoreData
diff --git a/Lib/email/generator.py b/Lib/email/generator.py
index 47b9df8f4e6..ce94f5c56fe 100644
--- a/Lib/email/generator.py
+++ b/Lib/email/generator.py
@@ -50,7 +50,7 @@ def __init__(self, outfp, mangle_from_=None, maxheaderlen=None, *,
         expanded to 8 spaces) than maxheaderlen, the header will split as
         defined in the Header class.  Set maxheaderlen to zero to disable
         header wrapping.  The default is 78, as recommended (but not required)
-        by RFC 2822.
+        by RFC 5322 section 2.1.1.
 
         The policy keyword specifies a policy object that controls a number of
         aspects of the generator's operation.  If no policy is specified,
diff --git a/Lib/email/header.py b/Lib/email/header.py
index 984851a7d9a..a0aadb97ca6 100644
--- a/Lib/email/header.py
+++ b/Lib/email/header.py
@@ -59,16 +59,22 @@
 def decode_header(header):
     """Decode a message header value without converting charset.
 
-    Returns a list of (string, charset) pairs containing each of the decoded
-    parts of the header.  Charset is None for non-encoded parts of the header,
-    otherwise a lower-case string containing the name of the character set
-    specified in the encoded string.
+    For historical reasons, this function may return either:
+
+    1. A list of length 1 containing a pair (str, None).
+    2. A list of (bytes, charset) pairs containing each of the decoded
+       parts of the header.  Charset is None for non-encoded parts of the header,
+       otherwise a lower-case string containing the name of the character set
+       specified in the encoded string.
 
     header may be a string that may or may not contain RFC2047 encoded words,
     or it may be a Header object.
 
     An email.errors.HeaderParseError may be raised when certain decoding error
     occurs (e.g. a base64 decoding exception).
+
+    This function exists for backwards compatibility only. For new code, we
+    recommend using email.headerregistry.HeaderRegistry instead.
     """
     # If it is a Header object, we can just return the encoded chunks.
     if hasattr(header, '_chunks'):
@@ -161,6 +167,9 @@ def make_header(decoded_seq, maxlinelen=None, header_name=None,
     This function takes one of those sequence of pairs and returns a Header
     instance.  Optional maxlinelen, header_name, and continuation_ws are as in
     the Header constructor.
+
+    This function exists for backwards compatibility only, and is not
+    recommended for use in new code.
     """
     h = Header(maxlinelen=maxlinelen, header_name=header_name,
                continuation_ws=continuation_ws)
diff --git a/Lib/email/message.py b/Lib/email/message.py
index 46bb8c21942..80f01d66a33 100644
--- a/Lib/email/message.py
+++ b/Lib/email/message.py
@@ -74,19 +74,25 @@ def _parseparam(s):
     # RDM This might be a Header, so for now stringify it.
     s = ';' + str(s)
     plist = []
-    while s[:1] == ';':
-        s = s[1:]
-        end = s.find(';')
-        while end > 0 and (s.count('"', 0, end) - s.count('\\"', 0, end)) % 2:
-            end = s.find(';', end + 1)
+    start = 0
+    while s.find(';', start) == start:
+        start += 1
+        end = s.find(';', start)
+        ind, diff = start, 0
+        while end > 0:
+            diff += s.count('"', ind, end) - s.count('\\"', ind, end)
+            if diff % 2 == 0:
+                break
+            end, ind = ind, s.find(';', end + 1)
         if end < 0:
             end = len(s)
-        f = s[:end]
-        if '=' in f:
-            i = f.index('=')
-            f = f[:i].strip().lower() + '=' + f[i+1:].strip()
+        i = s.find('=', start, end)
+        if i == -1:
+            f = s[start:end]
+        else:
+            f = s[start:i].rstrip().lower() + '=' + s[i+1:end].lstrip()
         plist.append(f.strip())
-        s = s[end:]
+        start = end
     return plist
 
 
@@ -135,7 +141,7 @@ def _decode_uu(encoded):
 class Message:
     """Basic message object.
 
-    A message object is defined as something that has a bunch of RFC 2822
+    A message object is defined as something that has a bunch of RFC 5322
     headers and a payload.  It may optionally have an envelope header
     (a.k.a. Unix-From or From_ header).  If the message is a container (i.e. a
     multipart or a message/rfc822), then the payload is a list of Message
@@ -286,8 +292,12 @@ def get_payload(self, i=None, decode=False):
         if i is not None and not isinstance(self._payload, list):
             raise TypeError('Expected list, got %s' % type(self._payload))
         payload = self._payload
-        # cte might be a Header, so for now stringify it.
-        cte = str(self.get('content-transfer-encoding', '')).lower()
+        cte = self.get('content-transfer-encoding', '')
+        if hasattr(cte, 'cte'):
+            cte = cte.cte
+        else:
+            # cte might be a Header, so for now stringify it.
+            cte = str(cte).strip().lower()
         # payload may be bytes here.
         if not decode:
             if isinstance(payload, str) and utils._has_surrogates(payload):
@@ -309,6 +319,8 @@ def get_payload(self, i=None, decode=False):
                 # If it does happen, turn the string into bytes in a way
                 # guaranteed not to fail.
                 bpayload = payload.encode('raw-unicode-escape')
+        else:
+            bpayload = payload
         if cte == 'quoted-printable':
             return quopri.decodestring(bpayload)
         elif cte == 'base64':
@@ -560,7 +572,7 @@ def add_header(self, _name, _value, **_params):
 
         msg.add_header('content-disposition', 'attachment', filename='bud.gif')
         msg.add_header('content-disposition', 'attachment',
-                       filename=('utf-8', '', Fußballer.ppt'))
+                       filename=('utf-8', '', 'Fußballer.ppt'))
         msg.add_header('content-disposition', 'attachment',
                        filename='Fußballer.ppt'))
         """
diff --git a/Lib/email/parser.py b/Lib/email/parser.py
index 06d99b17f2f..e3003118ce1 100644
--- a/Lib/email/parser.py
+++ b/Lib/email/parser.py
@@ -2,7 +2,7 @@
 # Author: Barry Warsaw, Thomas Wouters, Anthony Baxter
 # Contact: email-sig@python.org
 
-"""A parser of RFC 2822 and MIME email messages."""
+"""A parser of RFC 5322 and MIME email messages."""
 
 __all__ = ['Parser', 'HeaderParser', 'BytesParser', 'BytesHeaderParser',
            'FeedParser', 'BytesFeedParser']
@@ -15,14 +15,14 @@
 
 class Parser:
     def __init__(self, _class=None, *, policy=compat32):
-        """Parser of RFC 2822 and MIME email messages.
+        """Parser of RFC 5322 and MIME email messages.
 
         Creates an in-memory object tree representing the email message, which
         can then be manipulated and turned over to a Generator to return the
         textual representation of the message.
 
-        The string must be formatted as a block of RFC 2822 headers and header
-        continuation lines, optionally preceded by a `Unix-from' header.  The
+        The string must be formatted as a block of RFC 5322 headers and header
+        continuation lines, optionally preceded by a 'Unix-from' header.  The
         header block is terminated either by the end of the string or by a
         blank line.
 
@@ -75,14 +75,14 @@ def parsestr(self, text, headersonly=True):
 class BytesParser:
 
     def __init__(self, *args, **kw):
-        """Parser of binary RFC 2822 and MIME email messages.
+        """Parser of binary RFC 5322 and MIME email messages.
 
         Creates an in-memory object tree representing the email message, which
         can then be manipulated and turned over to a Generator to return the
         textual representation of the message.
 
-        The input must be formatted as a block of RFC 2822 headers and header
-        continuation lines, optionally preceded by a `Unix-from' header.  The
+        The input must be formatted as a block of RFC 5322 headers and header
+        continuation lines, optionally preceded by a 'Unix-from' header.  The
         header block is terminated either by the end of the input or by a
         blank line.
 
diff --git a/Lib/email/utils.py b/Lib/email/utils.py
index e42674fa4f3..e4d35f06abc 100644
--- a/Lib/email/utils.py
+++ b/Lib/email/utils.py
@@ -417,8 +417,14 @@ def decode_params(params):
         for name, continuations in rfc2231_params.items():
             value = []
             extended = False
-            # Sort by number
-            continuations.sort()
+            # Sort by number, treating None as 0 if there is no 0,
+            # and ignore it if there is already a 0.
+            has_zero = any(x[0] == 0 for x in continuations)
+            if has_zero:
+                continuations = [x for x in continuations if x[0] is not None]
+            else:
+                continuations = [(x[0] or 0, x[1], x[2]) for x in continuations]
+            continuations.sort(key=lambda x: x[0])
             # And now append all values in numerical order, converting
             # %-encodings for the encoded segments.  If any of the
             # continuation names ends in a *, then the entire string, after
diff --git a/Lib/test/test_context.py b/Lib/test/test_context.py
index aa83c6bbd71..6083b532223 100644
--- a/Lib/test/test_context.py
+++ b/Lib/test/test_context.py
@@ -3,6 +3,7 @@
 import functools
 import gc
 import random
+import sys
 import time
 import unittest
 import weakref
@@ -360,6 +361,7 @@ def ctx2_fun():
 
     @isolated_context
     @threading_helper.requires_working_threading()
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON; Flaky on Mac, self.assertEqual(cvar.get(), num + i) AssertionError: 8 != 12')
     def test_context_threads_1(self):
         cvar = contextvars.ContextVar('cvar')
 
diff --git a/Lib/test/test_email/__init__.py b/Lib/test/test_email/__init__.py
new file mode 100644
index 00000000000..455dc48facf
--- /dev/null
+++ b/Lib/test/test_email/__init__.py
@@ -0,0 +1,167 @@
+import os
+import unittest
+import collections
+import email
+from email.message import Message
+from email._policybase import compat32
+from test.support import load_package_tests
+from test.support.testcase import ExtraAssertions
+from test.test_email import __file__ as landmark
+
+# Load all tests in package
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
+
+
+# helper code used by a number of test modules.
+
+def openfile(filename, *args, **kws):
+    path = os.path.join(os.path.dirname(landmark), 'data', filename)
+    return open(path, *args, **kws)
+
+
+# Base test class
+class TestEmailBase(unittest.TestCase, ExtraAssertions):
+
+    maxDiff = None
+    # Currently the default policy is compat32.  By setting that as the default
+    # here we make minimal changes in the test_email tests compared to their
+    # pre-3.3 state.
+    policy = compat32
+    # Likewise, the default message object is Message.
+    message = Message
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self.addTypeEqualityFunc(bytes, self.assertBytesEqual)
+
+    # Backward compatibility to minimize test_email test changes.
+    ndiffAssertEqual = unittest.TestCase.assertEqual
+
+    def _msgobj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            return email.message_from_file(fp, policy=self.policy)
+
+    def _str_msg(self, string, message=None, policy=None):
+        if policy is None:
+            policy = self.policy
+        if message is None:
+            message = self.message
+        return email.message_from_string(string, message, policy=policy)
+
+    def _bytes_msg(self, bytestring, message=None, policy=None):
+        if policy is None:
+            policy = self.policy
+        if message is None:
+            message = self.message
+        return email.message_from_bytes(bytestring, message, policy=policy)
+
+    def _make_message(self):
+        return self.message(policy=self.policy)
+
+    def _bytes_repr(self, b):
+        return [repr(x) for x in b.splitlines(keepends=True)]
+
+    def assertBytesEqual(self, first, second, msg):
+        """Our byte strings are really encoded strings; improve diff output"""
+        self.assertEqual(self._bytes_repr(first), self._bytes_repr(second))
+
+    def assertDefectsEqual(self, actual, expected):
+        self.assertEqual(len(actual), len(expected), actual)
+        for i in range(len(actual)):
+            self.assertIsInstance(actual[i], expected[i],
+                                    'item {}'.format(i))
+
+
+def parameterize(cls):
+    """A test method parameterization class decorator.
+
+    Parameters are specified as the value of a class attribute that ends with
+    the string '_params'.  Call the portion before '_params' the prefix.  Then
+    a method to be parameterized must have the same prefix, the string
+    '_as_', and an arbitrary suffix.
+
+    The value of the _params attribute may be either a dictionary or a list.
+    The values in the dictionary and the elements of the list may either be
+    single values, or a list.  If single values, they are turned into single
+    element tuples.  However derived, the resulting sequence is passed via
+    *args to the parameterized test function.
+
+    In a _params dictionary, the keys become part of the name of the generated
+    tests.  In a _params list, the values in the list are converted into a
+    string by joining the string values of the elements of the tuple by '_' and
+    converting any blanks into '_'s, and this become part of the name.
+    The  full name of a generated test is a 'test_' prefix, the portion of the
+    test function name after the  '_as_' separator, plus an '_', plus the name
+    derived as explained above.
+
+    For example, if we have:
+
+        count_params = range(2)
+
+        def count_as_foo_arg(self, foo):
+            self.assertEqual(foo+1, myfunc(foo))
+
+    we will get parameterized test methods named:
+        test_foo_arg_0
+        test_foo_arg_1
+        test_foo_arg_2
+
+    Or we could have:
+
+        example_params = {'foo': ('bar', 1), 'bing': ('bang', 2)}
+
+        def example_as_myfunc_input(self, name, count):
+            self.assertEqual(name+str(count), myfunc(name, count))
+
+    and get:
+        test_myfunc_input_foo
+        test_myfunc_input_bing
+
+    Note: if and only if the generated test name is a valid identifier can it
+    be used to select the test individually from the unittest command line.
+
+    The values in the params dict can be a single value, a tuple, or a
+    dict.  If a single value of a tuple, it is passed to the test function
+    as positional arguments.  If a dict, it is a passed via **kw.
+
+    """
+    paramdicts = {}
+    testers = collections.defaultdict(list)
+    for name, attr in cls.__dict__.items():
+        if name.endswith('_params'):
+            if not hasattr(attr, 'keys'):
+                d = {}
+                for x in attr:
+                    if not hasattr(x, '__iter__'):
+                        x = (x,)
+                    n = '_'.join(str(v) for v in x).replace(' ', '_')
+                    d[n] = x
+                attr = d
+            paramdicts[name[:-7] + '_as_'] = attr
+        if '_as_' in name:
+            testers[name.split('_as_')[0] + '_as_'].append(name)
+    testfuncs = {}
+    for name in paramdicts:
+        if name not in testers:
+            raise ValueError("No tester found for {}".format(name))
+    for name in testers:
+        if name not in paramdicts:
+            raise ValueError("No params found for {}".format(name))
+    for name, attr in cls.__dict__.items():
+        for paramsname, paramsdict in paramdicts.items():
+            if name.startswith(paramsname):
+                testnameroot = 'test_' + name[len(paramsname):]
+                for paramname, params in paramsdict.items():
+                    if hasattr(params, 'keys'):
+                        test = (lambda self, name=name, params=params:
+                                    getattr(self, name)(**params))
+                    else:
+                        test = (lambda self, name=name, params=params:
+                                        getattr(self, name)(*params))
+                    testname = testnameroot + '_' + paramname
+                    test.__name__ = testname
+                    testfuncs[testname] = test
+    for key, value in testfuncs.items():
+        setattr(cls, key, value)
+    return cls
diff --git a/Lib/test/test_email/__main__.py b/Lib/test/test_email/__main__.py
new file mode 100644
index 00000000000..4b14f773db4
--- /dev/null
+++ b/Lib/test/test_email/__main__.py
@@ -0,0 +1,4 @@
+from test.test_email import load_tests
+import unittest
+
+unittest.main()
diff --git a/Lib/test/test_email/data/msg_01.txt b/Lib/test/test_email/data/msg_01.txt
new file mode 100644
index 00000000000..7e33bcf96af
--- /dev/null
+++ b/Lib/test/test_email/data/msg_01.txt
@@ -0,0 +1,19 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_02.txt b/Lib/test/test_email/data/msg_02.txt
new file mode 100644
index 00000000000..5d0a7e16c82
--- /dev/null
+++ b/Lib/test/test_email/data/msg_02.txt
@@ -0,0 +1,136 @@
+MIME-version: 1.0
+From: ppp-request@zzz.org
+Sender: ppp-admin@zzz.org
+To: ppp@zzz.org
+Subject: Ppp digest, Vol 1 #2 - 5 msgs
+Date: Fri, 20 Apr 2001 20:18:00 -0400 (EDT)
+X-Mailer: Mailman v2.0.4
+X-Mailman-Version: 2.0.4
+Content-Type: multipart/mixed; boundary="192.168.1.2.889.32614.987812255.500.21814"
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Masthead (Ppp digest, Vol 1 #2)
+
+Send Ppp mailing list submissions to
+	ppp@zzz.org
+
+To subscribe or unsubscribe via the World Wide Web, visit
+	http://www.zzz.org/mailman/listinfo/ppp
+or, via email, send a message with subject or body 'help' to
+	ppp-request@zzz.org
+
+You can reach the person managing the list at
+	ppp-admin@zzz.org
+
+When replying, please edit your Subject line so it is more specific
+than "Re: Contents of Ppp digest..."
+
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Today's Topics (5 msgs)
+
+Today's Topics:
+
+   1. testing #1 (Barry A. Warsaw)
+   2. testing #2 (Barry A. Warsaw)
+   3. testing #3 (Barry A. Warsaw)
+   4. testing #4 (Barry A. Warsaw)
+   5. testing #5 (Barry A. Warsaw)
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-Type: multipart/digest; boundary="__--__--"
+
+--__--__--
+
+Message: 1
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Date: Fri, 20 Apr 2001 20:16:13 -0400
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #1
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 2
+Date: Fri, 20 Apr 2001 20:16:21 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 3
+Date: Fri, 20 Apr 2001 20:16:25 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #3
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 4
+Date: Fri, 20 Apr 2001 20:16:28 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #4
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 5
+Date: Fri, 20 Apr 2001 20:16:32 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #5
+Precedence: bulk
+
+
+hello
+
+
+
+
+--__--__----
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Digest Footer
+
+_______________________________________________
+Ppp mailing list
+Ppp@zzz.org
+http://www.zzz.org/mailman/listinfo/ppp
+
+
+--192.168.1.2.889.32614.987812255.500.21814--
+
+End of Ppp Digest
+
diff --git a/Lib/test/test_email/data/msg_03.txt b/Lib/test/test_email/data/msg_03.txt
new file mode 100644
index 00000000000..c748ebf1176
--- /dev/null
+++ b/Lib/test/test_email/data/msg_03.txt
@@ -0,0 +1,16 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_04.txt b/Lib/test/test_email/data/msg_04.txt
new file mode 100644
index 00000000000..1f633c4496f
--- /dev/null
+++ b/Lib/test/test_email/data/msg_04.txt
@@ -0,0 +1,37 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Received: by mail.python.org (Postfix, from userid 889)
+	id C2BF0D37C6; Tue, 11 Sep 2001 00:05:05 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="h90VIIIKmx"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15261.36209.358846.118674@anthem.python.org>
+From: barry@python.org (Barry A. Warsaw)
+To: barry@python.org
+Subject: a simple multipart
+Date: Tue, 11 Sep 2001 00:05:05 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Make a door into a window
+
+
+--h90VIIIKmx
+Content-Type: text/plain
+Content-Disposition: inline;
+	filename="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx
+Content-Type: text/plain
+Content-Disposition: inline;
+	filename="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx--
+
diff --git a/Lib/test/test_email/data/msg_05.txt b/Lib/test/test_email/data/msg_05.txt
new file mode 100644
index 00000000000..87d5e9cbf8b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_05.txt
@@ -0,0 +1,28 @@
+From: foo
+Subject: bar
+To: baz
+MIME-Version: 1.0
+Content-Type: multipart/report; report-type=delivery-status;
+	boundary="D1690A7AC1.996856090/mail.example.com"
+Message-Id: <20010803162810.0CA8AA7ACC@mail.example.com>
+
+This is a MIME-encapsulated message.
+
+--D1690A7AC1.996856090/mail.example.com
+Content-Type: text/plain
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com
+Content-Type: message/rfc822
+
+From: nobody@python.org
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com--
+
diff --git a/Lib/test/test_email/data/msg_06.txt b/Lib/test/test_email/data/msg_06.txt
new file mode 100644
index 00000000000..f51ac96114b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_06.txt
@@ -0,0 +1,33 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+MIME-Version: 1.0
+Content-Type: message/rfc822
+Content-Description: forwarded message
+Content-Transfer-Encoding: 7bit
+Message-ID: <15265.9482.641338.555352@python.org>
+From: barry@python.org (Barry A. Warsaw)
+Sender: barry@python.org
+To: barry@python.org
+Subject: forwarded message from Barry A. Warsaw
+Date: Thu, 13 Sep 2001 17:28:42 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Be dirty
+X-Url: http://barry.wooz.org
+
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Message-ID: <15265.9468.713530.98441@python.org>
+From: barry@python.org (Barry A. Warsaw)
+Sender: barry@python.org
+To: barry@python.org
+Subject: testing
+Date: Thu, 13 Sep 2001 17:28:28 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Spectrum analysis
+X-Url: http://barry.wooz.org
+
+
diff --git a/Lib/test/test_email/data/msg_07.txt b/Lib/test/test_email/data/msg_07.txt
new file mode 100644
index 00000000000..721f3a0d316
--- /dev/null
+++ b/Lib/test/test_email/data/msg_07.txt
@@ -0,0 +1,83 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+Hi there,
+
+This is the dingus fish.
+
+--BOUNDARY
+Content-Type: image/gif; name="dingusfish.gif"
+Content-Transfer-Encoding: base64
+content-disposition: attachment; filename="dingusfish.gif"
+
+R0lGODdhAAEAAfAAAP///wAAACwAAAAAAAEAAQAC/oSPqcvtD6OctNqLs968+w+G4kiW5omm6sq2
+7gvH8kzX9o3n+s73/g8MCofEovGITGICTKbyCV0FDNOo9SqpQqpOrJfXzTQj2vD3TGtqL+NtGQ2f
+qTXmxzuOd7WXdcc9DyjU53ewFni4s0fGhdiYaEhGBelICTNoV1j5NUnFcrmUqemjNifJVWpaOqaI
+oFq3SspZsSraE7sHq3jr1MZqWvi662vxV4tD+pvKW6aLDOCLyur8PDwbanyDeq0N3DctbQYeLDvR
+RY6t95m6UB0d3mwIrV7e2VGNvjjffukeJp4w7F65KecGFsTHQGAygOrgrWs1jt28Rc88KESYcGLA
+/obvTkH6p+CinWJiJmIMqXGQwH/y4qk0SYjgQTczT3ajKZGfuI0uJ4kkVI/DT5s3/ejkxI0aT4Y+
+YTYgWbImUaXk9nlLmnSh1qJiJFl0OpUqRK4oOy7NyRQtHWofhoYVxkwWXKUSn0YsS+fUV6lhqfYb
+6ayd3Z5qQdG1B7bvQzaJjwUV2lixMUZ7JVsOlfjWVr/3NB/uFvnySBN6Dcb6rGwaRM3wsormw5cC
+M9NxWy/bWdufudCvy8bOAjXjVVwta/uO21sE5RHBCzNFXtgq9ORtH4eYjVP4Yryo026nvkFmCeyA
+B29efV6ravCMK5JwWd5897Qrx7ll38o6iHDZ/rXPR//feevhF4l7wjUGX3xq1eeRfM4RSJGBIV1D
+z1gKPkfWag3mVBVvva1RlX5bAJTPR/2YqNtw/FkIYYEi/pIZiAdpcxpoHtmnYYoZtvhUftzdx5ZX
+JSKDW405zkGcZzzGZ6KEv4FI224oDmijlEf+xp6MJK5ojY/ASeVUR+wsKRuJ+XFZ5o7ZeEime8t1
+ouUsU6YjF5ZtUihhkGfCdFQLWQFJ3UXxmElfhQnR+eCdcDbkFZp6vTRmj56ApCihn5QGpaToNZmR
+n3NVSpZcQpZ2KEONusaiCsKAug0wkQbJSFO+PTSjneGxOuFjPlUk3ovWvdIerjUg9ZGIOtGq/qeX
+eCYrrCX+1UPsgTKGGRSbzd5q156d/gpfbJxe66eD5iQKrXj7RGgruGxs62qebBHUKS32CKluCiqZ
+qh+pmehmEb71noAUoe5e9Zm17S7773V10pjrtG4CmuurCV/n6zLK5turWNhqOvFXbjhZrMD0YhKe
+wR0zOyuvsh6MWrGoIuzvyWu5y1WIFAqmJselypxXh6dKLNOKEB98L88bS2rkNqqlKzCNJp9c0G0j
+Gzh0iRrCbHSXmPR643QS+4rWhgFmnSbSuXCjS0xAOWkU2UdLqyuUNfHSFdUouy3bm5i5GnDM3tG8
+doJ4r5tqu3pPbRSVfvs8uJzeNXhp3n4j/tZ42SwH7eaWUUOjc3qFV9453UHTXZfcLH+OeNs5g36x
+lBnHvTm7EbMbLeuaLncao8vWCXimfo1o+843Ak6y4ChNeGntvAYvfLK4ezmoyNIbNCLTCXO9ZV3A
+E8/s88RczPzDwI4Ob7XZyl7+9Miban29h+tJZPrE21wgvBphDfrrfPdCTPKJD/y98L1rZwHcV6Jq
+Zab0metpuNIX/qAFPoz171WUaUb4HAhBSzHuHfjzHb3kha/2Cctis/ORArVHNYfFyYRH2pYIRzic
+isVOfPWD1b6mRTqpCRBozzof6UZVvFXRxWIr3GGrEviGYgyPMfahheiSaLs/9QeFu7oZ/ndSY8DD
+ya9x+uPed+7mxN2IzIISBOMLFYWVqC3Pew1T2nFuuCiwZS5/v6II10i4t1OJcUH2U9zxKodHsGGv
+Oa+zkvNUYUOa/TCCRutF9MzDwdlUMJADTCGSbDQ5OV4PTamDoPEi6Ecc/RF5RWwkcdSXvSOaDWSn
+I9LlvubFTQpuc6JKXLcKeb+xdbKRBnwREemXyjg6ME65aJiOuBgrktzykfPLJBKR9ClMavJ62/Ff
+BlNIyod9yX9wcSXexnXFpvkrbXk64xsx5Db7wXKP5fSgsvwIMM/9631VLBfkmtbHRXpqmtei52hG
+pUwSlo+BASQoeILDOBgREECxBBh5/iYmNsQ9dIv5+OI++QkqdsJPc3uykz5fkM+OraeekcQF7X4n
+B5S67za5U967PmooGQhUXfF7afXyCD7ONdRe17QogYjVx38uLwtrS6nhTnm15LQUnu9E2uK6CNI/
+1HOABj0ESwOjut4FEpFQpdNAm4K2LHnDWHNcmKB2ioKBogysVZtMO2nSxUdZ8Yk2kJc7URioLVI0
+YgmtIwZj4LoeKemgnOnbUdGnzZ4Oa6scqiolBGqS6RgWNLu0RMhcaE6rhhU4hiuqFXPAG8fGwTPW
+FKeLMtdVmXLSs5YJGF/YeVm7rREMlY3UYE+yCxbaMXX8y15m5zVHq6GOKDMynzII/jdUHdyVqIy0
+ifX2+r/EgtZcvRzSb72gU9ui87M2VecjKildW/aFqaYhKoryUjfB/g4qtyVuc60xFDGmCxwjW+qu
+zjuwl2GkOWn66+3QiiEctvd04OVvcCVzjgT7lrkvjVGKKHmmlDUKowSeikb5kK/mJReuWOxONx+s
+ULsl+Lqb0CVn0SrVyJ6wt4t6yTeSCafhPhAf0OXn6L60UMxiLolFAtmN35S2Ob1lZpQ1r/n0Qb5D
+oQ1zJiRVDgF8N3Q8TYfbi3DyWCy3lT1nxyBs6FT3S2GOzWRlxwKvlRP0RPJA9SjxEy0UoEnkA+M4
+cnzLMJrBGWLFEaaUb5lvpqbq/loOaU5+DFuHPxo82/OZuM8FXG3oVNZhtWpMpb/0Xu5m/LfLhHZQ
+7yuVI0MqZ7NE43imC8jH3IwGZlbPm0xkJYs7+2U48hXTsFSMqgGDvai0kLxyynKNT/waj+q1c1tz
+GjOpPBgdCSq3UKZxCSsqFIY+O6JbAWGWcV1pwqLyj5sGqCF1xb1F3varUWqrJv6cN3PrUXzijtfZ
+FshpBL3Xwr4GIPvU2N8EjrJgS1zl21rbXQMXeXc5jjFyrhpCzijSv/RQtyPSzHCFMhlME95fHglt
+pRsX+dfSQjUeHAlpWzJ5iOo79Ldnaxai6bXTcGO3fp07ri7HLEmXXPlYi8bv/qVxvNcdra6m7Rlb
+6JBTb5fd66VhFRjGArh2n7R1rDW4P5NOT9K0I183T2scYkeZ3q/VFyLb09U9ajzXBS8Kgkhc4mBS
+kYY9cy3Vy9lUnuNJH8HGIclUilwnBtjUOH0gteGOZ4c/XNrhXLSYDyxfnD8z1pDy7rYRvDolhnbe
+UMzxCZUs40s6s7UIvBnLgc0+vKuOkIXeOrDymlp+Zxra4MZLBbVrqD/jTJ597pDmnw5c4+DbyB88
+9Cg9DodYcSuMZT/114pptqc/EuTjRPvH/z5slzI3tluOEBBLqOXLOX+0I5929tO97wkvl/atCz+y
+xJrdwteW2FNW/NSmBP+f/maYtVs/bYyBC7Ox3jsYZHL05CIrBa/nS+b3bHfiYm4Ueil1YZZSgAUI
+fFZ1dxUmeA2oQRQ3RuGXNGLFV9/XbGFGPV6kfzk1TBBCd+izc7q1H+OHMJwmaBX2IQNYVAKHYepV
+SSGCe6CnbYHHETKGNe43EDvFgZr0gB/nVHPHZ80VV1ojOiI3XDvYIkl4ayo4bxQIgrFXWTvBI0nH
+VElWMuw2aLUWCRHHf8ymVCHjFlJnOSojfevCYyyyZDH0IcvHhrsnQ5O1OsWzONuVVKIxSxiFZ/tR
+fKDAf6xFTnw4O9Qig2VCfW2hJQrmMOuHW0W3dLQmCMO2ccdUd/xyfflH/olTiHZVdGwb8nIwRzSE
+J15jFlOJuBZBZ4CiyHyd2IFylFlB+HgHhYabhWOGwYO1ZH/Og1dtQlFMk352CGRSIFTapnWQEUtN
+l4zv8S0aaCFDyGCBqDUxZYpxGHX01y/JuH1xhn7TOCnNCI4eKDs5WGX4R425F4vF1o3BJ4vO0otq
+I3rimI7jJY1jISqnBxknCIvruF83mF5wN4X7qGLIhR8A2Vg0yFERSIXn9Vv3GHy3Vj/WIkKddlYi
+yIMv2I/VMjTLpW7pt05SWIZR0RPyxpB4SIUM9lBPGBl0GC7oSEEwRYLe4pJpZY2P0zbI1n+Oc44w
+qY3PUnmF0ixjVpDD/mJ9wpOBGTVgXlaCaZiPcIWK5NiKBIiPdGaQ0TWGvAiG7nMchdZb7Vgf8zNi
+MuMyzRdy/lePe9iC4TRx7WhhOQI/QiSVNAmAa2lT/piFbuh7ofJoYSZzrSZ1bvmWw3eN2nKUPVky
+uPN5/VRfohRd0VYZoqhKIlU6TXYhJxmPUIloAwc1bPmHEpaZYZORHNlXUJM07hATwHR8MJYqkwWR
+WaIezFhxSFlc8/Fq82hEnpeRozg3ULhhr9lAGtVEkCg5ZNRuuVleBPaZadhG0ZgkyPmDOTOKzViM
+YgOcpukKqQcbjAWS0IleQ2ROjdh6A+md1qWdBRSX7iSYgFRTtRmBpJioieXJiHfJiMGIR9fJOn8I
+MSfXYhspn4ooSa2mSAj4n+8Bmg03fBJZoPOJgsVZRxu1oOMRPXYYjdqjihFaEoZpXBREanuJoRI6
+cibFinq4ngUKh/wQd/H5ofYCZ0HJXR62opZFaAT0iFIZo4DIiUojkjeqKiuoZirKo5Y1a7AWckGa
+BkuYoD5lpDK6eUs6CkDqpETwl1EqpfhJpVeKpVl6EgUAADs=
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_08.txt b/Lib/test/test_email/data/msg_08.txt
new file mode 100644
index 00000000000..132ce7ada9b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_08.txt
@@ -0,0 +1,24 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_09.txt b/Lib/test/test_email/data/msg_09.txt
new file mode 100644
index 00000000000..0cfa6bab2ba
--- /dev/null
+++ b/Lib/test/test_email/data/msg_09.txt
@@ -0,0 +1,24 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: text/plain
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_10.txt b/Lib/test/test_email/data/msg_10.txt
new file mode 100644
index 00000000000..d49e477a818
--- /dev/null
+++ b/Lib/test/test_email/data/msg_10.txt
@@ -0,0 +1,39 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+Content-Transfer-Encoding: 7bit
+
+This is a 7bit encoded message.
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+Content-Transfer-Encoding: Quoted-Printable
+
+=A1This is a Quoted Printable encoded message!
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+Content-Transfer-Encoding: Base64
+
+VGhpcyBpcyBhIEJhc2U2NCBlbmNvZGVkIG1lc3NhZ2Uu
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+Content-Transfer-Encoding: Base64
+
+VGhpcyBpcyBhIEJhc2U2NCBlbmNvZGVkIG1lc3NhZ2UuCg==
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+
+This has no Content-Transfer-Encoding: header.
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_11.txt b/Lib/test/test_email/data/msg_11.txt
new file mode 100644
index 00000000000..8f7f1991cbd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_11.txt
@@ -0,0 +1,7 @@
+Content-Type: message/rfc822
+MIME-Version: 1.0
+Subject: The enclosing message
+
+Subject: An enclosed message
+
+Here is the body of the message.
diff --git a/Lib/test/test_email/data/msg_12.txt b/Lib/test/test_email/data/msg_12.txt
new file mode 100644
index 00000000000..b109b985c8b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_12.txt
@@ -0,0 +1,36 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: multipart/mixed; boundary="ANOTHER"
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-3"
+
+--ANOTHER--
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_12a.txt b/Lib/test/test_email/data/msg_12a.txt
new file mode 100644
index 00000000000..2092aa0c351
--- /dev/null
+++ b/Lib/test/test_email/data/msg_12a.txt
@@ -0,0 +1,38 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: multipart/mixed; boundary="ANOTHER"
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-3"
+
+
+--ANOTHER--
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_13.txt b/Lib/test/test_email/data/msg_13.txt
new file mode 100644
index 00000000000..8e6d52d5bef
--- /dev/null
+++ b/Lib/test/test_email/data/msg_13.txt
@@ -0,0 +1,94 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="OUTER"
+
+--OUTER
+Content-Type: text/plain; charset="us-ascii"
+
+A text/plain part
+
+--OUTER
+Content-Type: multipart/mixed; boundary=BOUNDARY
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+Hi there,
+
+This is the dingus fish.
+
+--BOUNDARY
+Content-Type: image/gif; name="dingusfish.gif"
+Content-Transfer-Encoding: base64
+content-disposition: attachment; filename="dingusfish.gif"
+
+R0lGODdhAAEAAfAAAP///wAAACwAAAAAAAEAAQAC/oSPqcvtD6OctNqLs968+w+G4kiW5omm6sq2
+7gvH8kzX9o3n+s73/g8MCofEovGITGICTKbyCV0FDNOo9SqpQqpOrJfXzTQj2vD3TGtqL+NtGQ2f
+qTXmxzuOd7WXdcc9DyjU53ewFni4s0fGhdiYaEhGBelICTNoV1j5NUnFcrmUqemjNifJVWpaOqaI
+oFq3SspZsSraE7sHq3jr1MZqWvi662vxV4tD+pvKW6aLDOCLyur8PDwbanyDeq0N3DctbQYeLDvR
+RY6t95m6UB0d3mwIrV7e2VGNvjjffukeJp4w7F65KecGFsTHQGAygOrgrWs1jt28Rc88KESYcGLA
+/obvTkH6p+CinWJiJmIMqXGQwH/y4qk0SYjgQTczT3ajKZGfuI0uJ4kkVI/DT5s3/ejkxI0aT4Y+
+YTYgWbImUaXk9nlLmnSh1qJiJFl0OpUqRK4oOy7NyRQtHWofhoYVxkwWXKUSn0YsS+fUV6lhqfYb
+6ayd3Z5qQdG1B7bvQzaJjwUV2lixMUZ7JVsOlfjWVr/3NB/uFvnySBN6Dcb6rGwaRM3wsormw5cC
+M9NxWy/bWdufudCvy8bOAjXjVVwta/uO21sE5RHBCzNFXtgq9ORtH4eYjVP4Yryo026nvkFmCeyA
+B29efV6ravCMK5JwWd5897Qrx7ll38o6iHDZ/rXPR//feevhF4l7wjUGX3xq1eeRfM4RSJGBIV1D
+z1gKPkfWag3mVBVvva1RlX5bAJTPR/2YqNtw/FkIYYEi/pIZiAdpcxpoHtmnYYoZtvhUftzdx5ZX
+JSKDW405zkGcZzzGZ6KEv4FI224oDmijlEf+xp6MJK5ojY/ASeVUR+wsKRuJ+XFZ5o7ZeEime8t1
+ouUsU6YjF5ZtUihhkGfCdFQLWQFJ3UXxmElfhQnR+eCdcDbkFZp6vTRmj56ApCihn5QGpaToNZmR
+n3NVSpZcQpZ2KEONusaiCsKAug0wkQbJSFO+PTSjneGxOuFjPlUk3ovWvdIerjUg9ZGIOtGq/qeX
+eCYrrCX+1UPsgTKGGRSbzd5q156d/gpfbJxe66eD5iQKrXj7RGgruGxs62qebBHUKS32CKluCiqZ
+qh+pmehmEb71noAUoe5e9Zm17S7773V10pjrtG4CmuurCV/n6zLK5turWNhqOvFXbjhZrMD0YhKe
+wR0zOyuvsh6MWrGoIuzvyWu5y1WIFAqmJselypxXh6dKLNOKEB98L88bS2rkNqqlKzCNJp9c0G0j
+Gzh0iRrCbHSXmPR643QS+4rWhgFmnSbSuXCjS0xAOWkU2UdLqyuUNfHSFdUouy3bm5i5GnDM3tG8
+doJ4r5tqu3pPbRSVfvs8uJzeNXhp3n4j/tZ42SwH7eaWUUOjc3qFV9453UHTXZfcLH+OeNs5g36x
+lBnHvTm7EbMbLeuaLncao8vWCXimfo1o+843Ak6y4ChNeGntvAYvfLK4ezmoyNIbNCLTCXO9ZV3A
+E8/s88RczPzDwI4Ob7XZyl7+9Miban29h+tJZPrE21wgvBphDfrrfPdCTPKJD/y98L1rZwHcV6Jq
+Zab0metpuNIX/qAFPoz171WUaUb4HAhBSzHuHfjzHb3kha/2Cctis/ORArVHNYfFyYRH2pYIRzic
+isVOfPWD1b6mRTqpCRBozzof6UZVvFXRxWIr3GGrEviGYgyPMfahheiSaLs/9QeFu7oZ/ndSY8DD
+ya9x+uPed+7mxN2IzIISBOMLFYWVqC3Pew1T2nFuuCiwZS5/v6II10i4t1OJcUH2U9zxKodHsGGv
+Oa+zkvNUYUOa/TCCRutF9MzDwdlUMJADTCGSbDQ5OV4PTamDoPEi6Ecc/RF5RWwkcdSXvSOaDWSn
+I9LlvubFTQpuc6JKXLcKeb+xdbKRBnwREemXyjg6ME65aJiOuBgrktzykfPLJBKR9ClMavJ62/Ff
+BlNIyod9yX9wcSXexnXFpvkrbXk64xsx5Db7wXKP5fSgsvwIMM/9631VLBfkmtbHRXpqmtei52hG
+pUwSlo+BASQoeILDOBgREECxBBh5/iYmNsQ9dIv5+OI++QkqdsJPc3uykz5fkM+OraeekcQF7X4n
+B5S67za5U967PmooGQhUXfF7afXyCD7ONdRe17QogYjVx38uLwtrS6nhTnm15LQUnu9E2uK6CNI/
+1HOABj0ESwOjut4FEpFQpdNAm4K2LHnDWHNcmKB2ioKBogysVZtMO2nSxUdZ8Yk2kJc7URioLVI0
+YgmtIwZj4LoeKemgnOnbUdGnzZ4Oa6scqiolBGqS6RgWNLu0RMhcaE6rhhU4hiuqFXPAG8fGwTPW
+FKeLMtdVmXLSs5YJGF/YeVm7rREMlY3UYE+yCxbaMXX8y15m5zVHq6GOKDMynzII/jdUHdyVqIy0
+ifX2+r/EgtZcvRzSb72gU9ui87M2VecjKildW/aFqaYhKoryUjfB/g4qtyVuc60xFDGmCxwjW+qu
+zjuwl2GkOWn66+3QiiEctvd04OVvcCVzjgT7lrkvjVGKKHmmlDUKowSeikb5kK/mJReuWOxONx+s
+ULsl+Lqb0CVn0SrVyJ6wt4t6yTeSCafhPhAf0OXn6L60UMxiLolFAtmN35S2Ob1lZpQ1r/n0Qb5D
+oQ1zJiRVDgF8N3Q8TYfbi3DyWCy3lT1nxyBs6FT3S2GOzWRlxwKvlRP0RPJA9SjxEy0UoEnkA+M4
+cnzLMJrBGWLFEaaUb5lvpqbq/loOaU5+DFuHPxo82/OZuM8FXG3oVNZhtWpMpb/0Xu5m/LfLhHZQ
+7yuVI0MqZ7NE43imC8jH3IwGZlbPm0xkJYs7+2U48hXTsFSMqgGDvai0kLxyynKNT/waj+q1c1tz
+GjOpPBgdCSq3UKZxCSsqFIY+O6JbAWGWcV1pwqLyj5sGqCF1xb1F3varUWqrJv6cN3PrUXzijtfZ
+FshpBL3Xwr4GIPvU2N8EjrJgS1zl21rbXQMXeXc5jjFyrhpCzijSv/RQtyPSzHCFMhlME95fHglt
+pRsX+dfSQjUeHAlpWzJ5iOo79Ldnaxai6bXTcGO3fp07ri7HLEmXXPlYi8bv/qVxvNcdra6m7Rlb
+6JBTb5fd66VhFRjGArh2n7R1rDW4P5NOT9K0I183T2scYkeZ3q/VFyLb09U9ajzXBS8Kgkhc4mBS
+kYY9cy3Vy9lUnuNJH8HGIclUilwnBtjUOH0gteGOZ4c/XNrhXLSYDyxfnD8z1pDy7rYRvDolhnbe
+UMzxCZUs40s6s7UIvBnLgc0+vKuOkIXeOrDymlp+Zxra4MZLBbVrqD/jTJ597pDmnw5c4+DbyB88
+9Cg9DodYcSuMZT/114pptqc/EuTjRPvH/z5slzI3tluOEBBLqOXLOX+0I5929tO97wkvl/atCz+y
+xJrdwteW2FNW/NSmBP+f/maYtVs/bYyBC7Ox3jsYZHL05CIrBa/nS+b3bHfiYm4Ueil1YZZSgAUI
+fFZ1dxUmeA2oQRQ3RuGXNGLFV9/XbGFGPV6kfzk1TBBCd+izc7q1H+OHMJwmaBX2IQNYVAKHYepV
+SSGCe6CnbYHHETKGNe43EDvFgZr0gB/nVHPHZ80VV1ojOiI3XDvYIkl4ayo4bxQIgrFXWTvBI0nH
+VElWMuw2aLUWCRHHf8ymVCHjFlJnOSojfevCYyyyZDH0IcvHhrsnQ5O1OsWzONuVVKIxSxiFZ/tR
+fKDAf6xFTnw4O9Qig2VCfW2hJQrmMOuHW0W3dLQmCMO2ccdUd/xyfflH/olTiHZVdGwb8nIwRzSE
+J15jFlOJuBZBZ4CiyHyd2IFylFlB+HgHhYabhWOGwYO1ZH/Og1dtQlFMk352CGRSIFTapnWQEUtN
+l4zv8S0aaCFDyGCBqDUxZYpxGHX01y/JuH1xhn7TOCnNCI4eKDs5WGX4R425F4vF1o3BJ4vO0otq
+I3rimI7jJY1jISqnBxknCIvruF83mF5wN4X7qGLIhR8A2Vg0yFERSIXn9Vv3GHy3Vj/WIkKddlYi
+yIMv2I/VMjTLpW7pt05SWIZR0RPyxpB4SIUM9lBPGBl0GC7oSEEwRYLe4pJpZY2P0zbI1n+Oc44w
+qY3PUnmF0ixjVpDD/mJ9wpOBGTVgXlaCaZiPcIWK5NiKBIiPdGaQ0TWGvAiG7nMchdZb7Vgf8zNi
+MuMyzRdy/lePe9iC4TRx7WhhOQI/QiSVNAmAa2lT/piFbuh7ofJoYSZzrSZ1bvmWw3eN2nKUPVky
+uPN5/VRfohRd0VYZoqhKIlU6TXYhJxmPUIloAwc1bPmHEpaZYZORHNlXUJM07hATwHR8MJYqkwWR
+WaIezFhxSFlc8/Fq82hEnpeRozg3ULhhr9lAGtVEkCg5ZNRuuVleBPaZadhG0ZgkyPmDOTOKzViM
+YgOcpukKqQcbjAWS0IleQ2ROjdh6A+md1qWdBRSX7iSYgFRTtRmBpJioieXJiHfJiMGIR9fJOn8I
+MSfXYhspn4ooSa2mSAj4n+8Bmg03fBJZoPOJgsVZRxu1oOMRPXYYjdqjihFaEoZpXBREanuJoRI6
+cibFinq4ngUKh/wQd/H5ofYCZ0HJXR62opZFaAT0iFIZo4DIiUojkjeqKiuoZirKo5Y1a7AWckGa
+BkuYoD5lpDK6eUs6CkDqpETwl1EqpfhJpVeKpVl6EgUAADs=
+
+--BOUNDARY--
+
+--OUTER--
diff --git a/Lib/test/test_email/data/msg_14.txt b/Lib/test/test_email/data/msg_14.txt
new file mode 100644
index 00000000000..5d98d2fd145
--- /dev/null
+++ b/Lib/test/test_email/data/msg_14.txt
@@ -0,0 +1,23 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+I'm sorry but I'm using a drainbread ISP, which although big and
+wealthy can't seem to generate standard compliant email. :(
+
+This message has a Content-Type: header with no subtype.  I hope you
+can still read it.
+
+-Me
diff --git a/Lib/test/test_email/data/msg_15.txt b/Lib/test/test_email/data/msg_15.txt
new file mode 100644
index 00000000000..0025624e750
--- /dev/null
+++ b/Lib/test/test_email/data/msg_15.txt
@@ -0,0 +1,52 @@
+Return-Path: <xx@xx.dk>
+Received: from fepD.post.tele.dk (195.41.46.149) by mail.groupcare.dk (LSMTP for Windows NT v1.1b) with SMTP id <0.0014F8A2@mail.groupcare.dk>; Mon, 30 Apr 2001 12:17:50 +0200
+User-Agent: Microsoft-Outlook-Express-Macintosh-Edition/5.02.2106
+Subject: XX
+From: xx@xx.dk
+To: XX
+Message-ID: <xxxx>
+Mime-version: 1.0
+Content-type: multipart/mixed;
+   boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+> Denne meddelelse er i MIME-format. Da dit postl
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: multipart/alternative;
+   boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: text/plain; charset="ISO-8859-1"
+Content-transfer-encoding: quoted-printable
+
+Some removed test. 
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: text/html; charset="ISO-8859-1"
+Content-transfer-encoding: quoted-printable
+
+<HTML>
+<HEAD>
+<TITLE>Some removed HTML</TITLE>
+</HEAD>
+<BODY>
+Some removed text.
+</BODY>
+</HTML>
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part--
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: image/gif; name="xx.gif";
+ x-mac-creator="6F676C65";
+ x-mac-type="47494666"
+Content-disposition: attachment
+Content-transfer-encoding: base64
+
+Some removed base64 encoded chars.
+
+--MS_Mac_OE_3071477847_720252_MIME_Part--
+
diff --git a/Lib/test/test_email/data/msg_16.txt b/Lib/test/test_email/data/msg_16.txt
new file mode 100644
index 00000000000..56167e9f5b4
--- /dev/null
+++ b/Lib/test/test_email/data/msg_16.txt
@@ -0,0 +1,123 @@
+Return-Path: <>
+Delivered-To: scr-admin@socal-raves.org
+Received: from cougar.noc.ucla.edu (cougar.noc.ucla.edu [169.232.10.18])
+	by babylon.socal-raves.org (Postfix) with ESMTP id CCC2C51B84
+	for <scr-admin@socal-raves.org>; Sun, 23 Sep 2001 20:13:54 -0700 (PDT)
+Received: from sims-ms-daemon by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8Y@cougar.noc.ucla.edu> for scr-admin@socal-raves.org; Sun,
+ 23 Sep 2001 20:14:35 -0700 (PDT)
+Received: from cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8X@cougar.noc.ucla.edu>; Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+Date: Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+From: Internet Mail Delivery <postmaster@ucla.edu>
+Subject: Delivery Notification: Delivery has failed
+To: scr-admin@socal-raves.org
+Message-id: <0GK500B04D0B8X@cougar.noc.ucla.edu>
+MIME-version: 1.0
+Sender: scr-owner@socal-raves.org
+Errors-To: scr-owner@socal-raves.org
+X-BeenThere: scr@socal-raves.org
+X-Mailman-Version: 2.1a3
+Precedence: bulk
+List-Help: <mailto:scr-request@socal-raves.org?subject=help>
+List-Post: <mailto:scr@socal-raves.org>
+List-Subscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+	<mailto:scr-request@socal-raves.org?subject=subscribe>
+List-Id: SoCal-Raves <scr.socal-raves.org>
+List-Unsubscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+	<mailto:scr-request@socal-raves.org?subject=unsubscribe>
+List-Archive: <http://socal-raves.org/mailman/private/scr/>
+Content-Type: multipart/report; boundary="Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)"
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: text/plain; charset=ISO-8859-1
+
+This report relates to a message you sent with the following header fields:
+
+  Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+  Date: Sun, 23 Sep 2001 20:10:55 -0700
+  From: "Ian T. Henry" <henryi@oxy.edu>
+  To: SoCal Raves <scr@socal-raves.org>
+  Subject: [scr] yeah for Ians!!
+
+Your message cannot be delivered to the following recipients:
+
+  Recipient address: jangel1@cougar.noc.ucla.edu
+  Reason: recipient reached disk quota
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: message/DELIVERY-STATUS
+
+Original-envelope-id: 0GK500B4HD0888@cougar.noc.ucla.edu
+Reporting-MTA: dns; cougar.noc.ucla.edu
+
+Action: failed
+Status: 5.0.0 (recipient reached disk quota)
+Original-recipient: rfc822;jangel1@cougar.noc.ucla.edu
+Final-recipient: rfc822;jangel1@cougar.noc.ucla.edu
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: MESSAGE/RFC822
+
+Return-path: scr-admin@socal-raves.org
+Received: from sims-ms-daemon by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8X@cougar.noc.ucla.edu>; Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+Received: from panther.noc.ucla.edu by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ with ESMTP id <0GK500B4GD0888@cougar.noc.ucla.edu> for jangel1@sims-ms-daemon;
+ Sun, 23 Sep 2001 20:14:33 -0700 (PDT)
+Received: from babylon.socal-raves.org
+ (ip-209-85-222-117.dreamhost.com [209.85.222.117])
+ by panther.noc.ucla.edu (8.9.1a/8.9.1) with ESMTP id UAA09793 for
+ <jangel1@ucla.edu>; Sun, 23 Sep 2001 20:14:32 -0700 (PDT)
+Received: from babylon (localhost [127.0.0.1]) by babylon.socal-raves.org
+ (Postfix) with ESMTP id D3B2951B70; Sun, 23 Sep 2001 20:13:47 -0700 (PDT)
+Received: by babylon.socal-raves.org (Postfix, from userid 60001)
+ id A611F51B82; Sun, 23 Sep 2001 20:13:46 -0700 (PDT)
+Received: from tiger.cc.oxy.edu (tiger.cc.oxy.edu [134.69.3.112])
+ by babylon.socal-raves.org (Postfix) with ESMTP id ADA7351B70 for
+ <scr@socal-raves.org>; Sun, 23 Sep 2001 20:13:44 -0700 (PDT)
+Received: from ent (n16h86.dhcp.oxy.edu [134.69.16.86])
+ by tiger.cc.oxy.edu (8.8.8/8.8.8) with SMTP id UAA08100 for
+ <scr@socal-raves.org>; Sun, 23 Sep 2001 20:14:24 -0700 (PDT)
+Date: Sun, 23 Sep 2001 20:10:55 -0700
+From: "Ian T. Henry" <henryi@oxy.edu>
+Subject: [scr] yeah for Ians!!
+Sender: scr-admin@socal-raves.org
+To: SoCal Raves <scr@socal-raves.org>
+Errors-to: scr-admin@socal-raves.org
+Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+MIME-version: 1.0
+X-Mailer: Microsoft Outlook Express 5.50.4522.1200
+Content-type: text/plain; charset=us-ascii
+Precedence: bulk
+Delivered-to: scr-post@babylon.socal-raves.org
+Delivered-to: scr@socal-raves.org
+X-Converted-To-Plain-Text: from multipart/alternative by demime 0.98e
+X-Converted-To-Plain-Text: Alternative section used was text/plain
+X-BeenThere: scr@socal-raves.org
+X-Mailman-Version: 2.1a3
+List-Help: <mailto:scr-request@socal-raves.org?subject=help>
+List-Post: <mailto:scr@socal-raves.org>
+List-Subscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+ <mailto:scr-request@socal-raves.org?subject=subscribe>
+List-Id: SoCal-Raves <scr.socal-raves.org>
+List-Unsubscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+ <mailto:scr-request@socal-raves.org?subject=unsubscribe>
+List-Archive: <http://socal-raves.org/mailman/private/scr/>
+
+I always love to find more Ian's that are over 3 years old!!
+
+Ian
+_______________________________________________
+For event info, list questions, or to unsubscribe, see http://www.socal-raves.org/
+
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)--
+
diff --git a/Lib/test/test_email/data/msg_17.txt b/Lib/test/test_email/data/msg_17.txt
new file mode 100644
index 00000000000..8d86e4180dd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_17.txt
@@ -0,0 +1,12 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+Hi there,
+
+This is the dingus fish.
+
+[Non-text (image/gif) part of message omitted, filename dingusfish.gif]
diff --git a/Lib/test/test_email/data/msg_18.txt b/Lib/test/test_email/data/msg_18.txt
new file mode 100644
index 00000000000..f9f4904d366
--- /dev/null
+++ b/Lib/test/test_email/data/msg_18.txt
@@ -0,0 +1,6 @@
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
+	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
+
diff --git a/Lib/test/test_email/data/msg_19.txt b/Lib/test/test_email/data/msg_19.txt
new file mode 100644
index 00000000000..49bf7fccdd9
--- /dev/null
+++ b/Lib/test/test_email/data/msg_19.txt
@@ -0,0 +1,43 @@
+Send Ppp mailing list submissions to
+	ppp@zzz.org
+
+To subscribe or unsubscribe via the World Wide Web, visit
+	http://www.zzz.org/mailman/listinfo/ppp
+or, via email, send a message with subject or body 'help' to
+	ppp-request@zzz.org
+
+You can reach the person managing the list at
+	ppp-admin@zzz.org
+
+When replying, please edit your Subject line so it is more specific
+than "Re: Contents of Ppp digest..."
+
+Today's Topics:
+
+   1. testing #1 (Barry A. Warsaw)
+   2. testing #2 (Barry A. Warsaw)
+   3. testing #3 (Barry A. Warsaw)
+   4. testing #4 (Barry A. Warsaw)
+   5. testing #5 (Barry A. Warsaw)
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+
+_______________________________________________
+Ppp mailing list
+Ppp@zzz.org
+http://www.zzz.org/mailman/listinfo/ppp
+
diff --git a/Lib/test/test_email/data/msg_20.txt b/Lib/test/test_email/data/msg_20.txt
new file mode 100644
index 00000000000..1a6a88783ee
--- /dev/null
+++ b/Lib/test/test_email/data/msg_20.txt
@@ -0,0 +1,22 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Cc: ccc@zzz.org
+CC: ddd@zzz.org
+cc: eee@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_21.txt b/Lib/test/test_email/data/msg_21.txt
new file mode 100644
index 00000000000..23590b255dd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_21.txt
@@ -0,0 +1,20 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: Test
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+MIME message
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+One
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+Two
+--BOUNDARY--
+End of MIME message
diff --git a/Lib/test/test_email/data/msg_22.txt b/Lib/test/test_email/data/msg_22.txt
new file mode 100644
index 00000000000..af9de5fa27b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_22.txt
@@ -0,0 +1,46 @@
+Mime-Version: 1.0
+Message-Id: <a05001902b7f1c33773e9@[134.84.183.138]>
+Date: Tue, 16 Oct 2001 13:59:25 +0300
+To: a@example.com
+From: b@example.com
+Content-Type: multipart/mixed; boundary="============_-1208892523==_============"
+
+--============_-1208892523==_============
+Content-Type: text/plain; charset="us-ascii" ; format="flowed"
+
+Text text text.
+--============_-1208892523==_============
+Content-Id: <a05001902b7f1c33773e9@[134.84.183.138].0.0>
+Content-Type: image/jpeg; name="wibble.JPG"
+ ; x-mac-type="4A504547"
+ ; x-mac-creator="474B4F4E"
+Content-Disposition: attachment; filename="wibble.JPG"
+Content-Transfer-Encoding: base64
+
+/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAALCAXABIEBAREA
+g6bCjjw/pIZSjO6FWFpldjySOmCNrO7DBZibUXhTwtCixw+GtAijVdqxxaPp0aKvmGXa
+qrbBQvms0mAMeYS/3iTV1dG0hHaRNK01XblnWxtVdjkHLMIgTyqnk9VB7CrP2KzIINpa
+4O7I+zxYO9WV8jZg71Zlb+8rMDkEirAVQFAUAKAFAAAUAYAUDgADgY6DjpRtXj5RxjHA
+4wQRj0wQCMdCAewpaKKK/9k=
+--============_-1208892523==_============
+Content-Id: <a05001902b7f1c33773e9@[134.84.183.138].0.1>
+Content-Type: image/jpeg; name="wibble2.JPG"
+ ; x-mac-type="4A504547"
+ ; x-mac-creator="474B4F4E"
+Content-Disposition: attachment; filename="wibble2.JPG"
+Content-Transfer-Encoding: base64
+
+/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAALCAXABJ0BAREA
+/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA
+W6NFJJBEkU10kKGTcWMDwxuU+0JHvk8qAtOpNwqSR0n8c3BlDyXHlqsUltHEiTvdXLxR
+7vMiGDNJAJWkAMk8ZkCFp5G2oo5W++INrbQtNfTQxJAuXlupz9oS4d5Y1W+E2XlWZJJE
+Y7LWYQxTLE1zuMbfBPxw8X2fibVdIbSbI6nLZxX635t9TjtYreWR7WGKJTLJFFKSlozO
+0ShxIXM43uC3/9k=
+--============_-1208892523==_============
+Content-Type: text/plain; charset="us-ascii" ; format="flowed"
+
+Text text text.
+--============_-1208892523==_============--
+
diff --git a/Lib/test/test_email/data/msg_23.txt b/Lib/test/test_email/data/msg_23.txt
new file mode 100644
index 00000000000..bb2e8ec36bb
--- /dev/null
+++ b/Lib/test/test_email/data/msg_23.txt
@@ -0,0 +1,8 @@
+From: aperson@dom.ain
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain
+
+A message part
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_24.txt b/Lib/test/test_email/data/msg_24.txt
new file mode 100644
index 00000000000..4e52339e86d
--- /dev/null
+++ b/Lib/test/test_email/data/msg_24.txt
@@ -0,0 +1,10 @@
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_25.txt b/Lib/test/test_email/data/msg_25.txt
new file mode 100644
index 00000000000..9e35275fe0d
--- /dev/null
+++ b/Lib/test/test_email/data/msg_25.txt
@@ -0,0 +1,117 @@
+From MAILER-DAEMON Fri Apr 06 16:46:09 2001
+Received: from [204.245.199.98] (helo=zinfandel.lacita.com)
+	by www.linux.org.uk with esmtp (Exim 3.13 #1)
+	id 14lYR6-0008Iv-00
+	for linuxuser-admin@www.linux.org.uk; Fri, 06 Apr 2001 16:46:09 +0100
+Received: from localhost (localhost) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with internal id JAB03225; Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+From: Mail Delivery Subsystem <MAILER-DAEMON@zinfandel.lacita.com>
+Subject: Returned mail: Too many hops 19 (17 max): from <linuxuser-admin@www.linux.org.uk> via [199.164.235.226], to <scoffman@wellpartner.com>
+Message-Id: <200104061723.JAB03225@zinfandel.lacita.com>
+To: <linuxuser-admin@www.linux.org.uk>
+To: postmaster@zinfandel.lacita.com
+MIME-Version: 1.0
+Content-Type: multipart/report; report-type=delivery-status;
+	bo
+Auto-Submitted: auto-generated (failure)
+
+This is a MIME-encapsulated message
+
+--JAB03225.986577786/zinfandel.lacita.com
+
+The original message was received at Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+from [199.164.235.226]
+
+   ----- The following addresses have delivery notifications -----
+<scoffman@wellpartner.com>  (unrecoverable error)
+
+   ----- Transcript of session follows -----
+554 Too many hops 19 (17 max): from <linuxuser-admin@www.linux.org.uk> via [199.164.235.226], to <scoffman@wellpartner.com>
+
+--JAB03225.986577786/zinfandel.lacita.com
+Content-Type: message/delivery-status
+
+Reporting-MTA: dns; zinfandel.lacita.com
+Received-From-MTA: dns; [199.164.235.226]
+Arrival-Date: Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+
+Final-Recipient: rfc822; scoffman@wellpartner.com
+Action: failed
+Status: 5.4.6
+Last-Attempt-Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+
+--JAB03225.986577786/zinfandel.lacita.com
+Content-Type: text/rfc822-headers
+
+Return-Path: linuxuser-admin@www.linux.org.uk
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03225 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03221 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:22:18 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03217 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:21:37 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03213 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:20:56 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03209 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:20:15 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03205 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:19:33 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03201 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:18:52 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03197 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:17:54 -0800 (GMT-0800)
+Received: from www.linux.org.uk (parcelfarce.linux.theplanet.co.uk [195.92.249.252])
+	by
+	fo
+Received: from localhost.localdomain
+	([
+	by
+	id
+Received: from [212.1.130.11] (helo=s1.uklinux.net ident=root)
+	by
+	id
+	fo
+Received: from server (ppp-2-22.cvx4.telinco.net [212.1.149.22])
+	by
+	fo
+From: Daniel James <daniel@linuxuser.co.uk>
+Organization: LinuxUser
+To: linuxuser@www.linux.org.uk
+X-Mailer: KMail [version 1.1.99]
+Content-Type: text/plain;
+  c
+MIME-Version: 1.0
+Message-Id: <01040616033903.00962@server>
+Content-Transfer-Encoding: 8bit
+Subject: [LinuxUser] bulletin no. 45
+Sender: linuxuser-admin@www.linux.org.uk
+Errors-To: linuxuser-admin@www.linux.org.uk
+X-BeenThere: linuxuser@www.linux.org.uk
+X-Mailman-Version: 2.0.3
+Precedence: bulk
+List-Help: <mailto:linuxuser-request@www.linux.org.uk?subject=help>
+List-Post: <mailto:linuxuser@www.linux.org.uk>
+List-Subscribe: <http://www.linux.org.uk/mailman/listinfo/linuxuser>,
+	<m
+List-Id: bulletins from LinuxUser magazine <linuxuser.www.linux.org.uk>
+List-Unsubscribe: <http://www.linux.org.uk/mailman/listinfo/linuxuser>,
+	<m
+List-Archive: <http://www.linux.org.uk/pipermail/linuxuser/>
+Date: Fri, 6 Apr 2001 16:03:39 +0100
+
+--JAB03225.986577786/zinfandel.lacita.com--
+
+
diff --git a/Lib/test/test_email/data/msg_26.txt b/Lib/test/test_email/data/msg_26.txt
new file mode 100644
index 00000000000..58efaa9c9a8
--- /dev/null
+++ b/Lib/test/test_email/data/msg_26.txt
@@ -0,0 +1,46 @@
+Received: from xcar [192.168.0.2] by jeeves.wooster.local
+  (SMTPD32-7.07 EVAL) id AFF92F0214; Sun, 12 May 2002 08:55:37 +0100
+Date: Sun, 12 May 2002 08:56:15 +0100
+From: Father Time <father.time@xcar.wooster.local>
+To: timbo@jeeves.wooster.local
+Subject: IMAP file test
+Message-ID: <6df65d354b.father.time@rpc.wooster.local>
+X-Organization: Home
+User-Agent: Messenger-Pro/2.50a (MsgServe/1.50) (RISC-OS/4.02) POPstar/2.03
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="1618492860--2051301190--113853680"
+Status: R
+X-UIDL: 319998302
+
+This message is in MIME format which your mailer apparently does not support.
+You either require a newer version of your software which supports MIME, or
+a separate MIME decoding utility.  Alternatively, ask the sender of this
+message to resend it in a different format.
+
+--1618492860--2051301190--113853680
+Content-Type: text/plain; charset=us-ascii
+
+Simple email with attachment.
+
+
+--1618492860--2051301190--113853680
+Content-Type: application/riscos; name="clock.bmp,69c"; type=BMP;
+	load=&fff69c4b; exec=&355dd4d1; access=&03
+Content-Disposition: attachment; filename="clock.bmp"
+Content-Transfer-Encoding: base64
+
+Qk12AgAAAAAAAHYAAAAoAAAAIAAAACAAAAABAAQAAAAAAAAAAADXDQAA1w0AAAAAAAAA
+AAAAAAAAAAAAiAAAiAAAAIiIAIgAAACIAIgAiIgAALu7uwCIiIgAERHdACLuIgAz//8A
+zAAAAN0R3QDu7iIA////AAAAAAAAAAAAAAAAAAAAAAAAAAi3AAAAAAAAADeAAAAAAAAA
+C3ADMzMzMANwAAAAAAAAAAAHMAAAAANwAAAAAAAAAACAMAd3zPfwAwgAAAAAAAAIAwd/
+f8x/f3AwgAAAAAAAgDB0x/f3//zPAwgAAAAAAAcHfM9////8z/AwAAAAAAiwd/f3////
+////A4AAAAAAcEx/f///////zAMAAAAAiwfM9////3///8zwOAAAAAcHf3////B/////
+8DAAAAALB/f3///wd3d3//AwAAAABwTPf//wCQAAD/zAMAAAAAsEx/f///B////8wDAA
+AAAHB39////wf/////AwAAAACwf39///8H/////wMAAAAIcHfM9///B////M8DgAAAAA
+sHTH///wf///xAMAAAAACHB3f3//8H////cDgAAAAAALB3zH//D//M9wMAAAAAAAgLB0
+z39///xHAwgAAAAAAAgLB3d3RHd3cDCAAAAAAAAAgLAHd0R3cAMIAAAAAAAAgAgLcAAA
+AAMwgAgAAAAACDAAAAu7t7cwAAgDgAAAAABzcIAAAAAAAAgDMwAAAAAAN7uwgAAAAAgH
+MzMAAAAACH97tzAAAAALu3c3gAAAAAAL+7tzDABAu7f7cAAAAAAACA+3MA7EQAv/sIAA
+AAAAAAAIAAAAAAAAAIAAAAAA
+
+--1618492860--2051301190--113853680--
diff --git a/Lib/test/test_email/data/msg_27.txt b/Lib/test/test_email/data/msg_27.txt
new file mode 100644
index 00000000000..d0191769d73
--- /dev/null
+++ b/Lib/test/test_email/data/msg_27.txt
@@ -0,0 +1,15 @@
+Return-Path: <aperson@dom.ain>
+Received: by mail.dom.ain (Postfix, from userid 889)
+	id B9D0AD35DB; Tue,  4 Jun 2002 21:46:59 -0400 (EDT)
+Message-ID: <15613.28051.707126.569693@dom.ain>
+Date: Tue, 4 Jun 2002 21:46:59 -0400
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Subject: bug demonstration
+	12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+	more text
+From: aperson@dom.ain (Anne P. Erson)
+To: bperson@dom.ain (Barney P. Erson)
+
+test
diff --git a/Lib/test/test_email/data/msg_28.txt b/Lib/test/test_email/data/msg_28.txt
new file mode 100644
index 00000000000..1e4824cabb0
--- /dev/null
+++ b/Lib/test/test_email/data/msg_28.txt
@@ -0,0 +1,25 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/digest; boundary=BOUNDARY
+
+--BOUNDARY
+Content-Type: message/rfc822
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 1
+
+--BOUNDARY
+Content-Type: message/rfc822
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_29.txt b/Lib/test/test_email/data/msg_29.txt
new file mode 100644
index 00000000000..1fab5616173
--- /dev/null
+++ b/Lib/test/test_email/data/msg_29.txt
@@ -0,0 +1,22 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii;
+     title*0*="us-ascii'en'This%20is%20even%20more%20";
+     title*1*="%2A%2A%2Afun%2A%2A%2A%20";
+     title*2="isn't it!"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_30.txt b/Lib/test/test_email/data/msg_30.txt
new file mode 100644
index 00000000000..4334bb6e608
--- /dev/null
+++ b/Lib/test/test_email/data/msg_30.txt
@@ -0,0 +1,23 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/digest; boundary=BOUNDARY
+
+--BOUNDARY
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 1
+
+--BOUNDARY
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_31.txt b/Lib/test/test_email/data/msg_31.txt
new file mode 100644
index 00000000000..1e58e56cf52
--- /dev/null
+++ b/Lib/test/test_email/data/msg_31.txt
@@ -0,0 +1,15 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=BOUNDARY_
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 1
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_32.txt b/Lib/test/test_email/data/msg_32.txt
new file mode 100644
index 00000000000..07ec5af9a3d
--- /dev/null
+++ b/Lib/test/test_email/data/msg_32.txt
@@ -0,0 +1,14 @@
+Delivered-To: freebsd-isp@freebsd.org
+Date: Tue, 26 Sep 2000 12:23:03 -0500
+From: Anne Person <aperson@example.com>
+To: Barney Dude <bdude@example.com>
+Subject: Re: Limiting Perl CPU Utilization...
+Mime-Version: 1.0
+Content-Type: text/plain; charset*=ansi-x3.4-1968''us-ascii
+Content-Disposition: inline
+User-Agent: Mutt/1.3.8i
+Sender: owner-freebsd-isp@FreeBSD.ORG
+Precedence: bulk
+X-Loop: FreeBSD.org
+
+Some message.
diff --git a/Lib/test/test_email/data/msg_33.txt b/Lib/test/test_email/data/msg_33.txt
new file mode 100644
index 00000000000..042787a4fd8
--- /dev/null
+++ b/Lib/test/test_email/data/msg_33.txt
@@ -0,0 +1,29 @@
+Delivered-To: freebsd-isp@freebsd.org
+Date: Wed, 27 Sep 2000 11:11:09 -0500
+From: Anne Person <aperson@example.com>
+To: Barney Dude <bdude@example.com>
+Subject: Re: Limiting Perl CPU Utilization...
+Mime-Version: 1.0
+Content-Type: multipart/signed; micalg*=ansi-x3.4-1968''pgp-md5;
+	protocol*=ansi-x3.4-1968''application%2Fpgp-signature;
+	boundary*="ansi-x3.4-1968''EeQfGwPcQSOJBaQU"
+Content-Disposition: inline
+Sender: owner-freebsd-isp@FreeBSD.ORG
+Precedence: bulk
+X-Loop: FreeBSD.org
+
+
+--EeQfGwPcQSOJBaQU
+Content-Type: text/plain; charset*=ansi-x3.4-1968''us-ascii
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+
+part 1
+
+--EeQfGwPcQSOJBaQU
+Content-Type: text/plain
+Content-Disposition: inline
+
+part 2
+
+--EeQfGwPcQSOJBaQU--
diff --git a/Lib/test/test_email/data/msg_34.txt b/Lib/test/test_email/data/msg_34.txt
new file mode 100644
index 00000000000..055dfea5310
--- /dev/null
+++ b/Lib/test/test_email/data/msg_34.txt
@@ -0,0 +1,19 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Content-Type: multipart/digest; boundary=XYZ
+
+--XYZ
+Content-Type: text/plain
+
+
+This is a text plain part that is counter to recommended practice in
+RFC 2046, $5.1.5, but is not illegal
+
+--XYZ
+
+From: cperson@dom.ain
+To: dperson@dom.ain
+
+A submessage
+
+--XYZ--
diff --git a/Lib/test/test_email/data/msg_35.txt b/Lib/test/test_email/data/msg_35.txt
new file mode 100644
index 00000000000..0e2bbcaf718
--- /dev/null
+++ b/Lib/test/test_email/data/msg_35.txt
@@ -0,0 +1,4 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: here's something interesting
+counter to RFC 5322, there's no separating newline here
diff --git a/Lib/test/test_email/data/msg_36.txt b/Lib/test/test_email/data/msg_36.txt
new file mode 100644
index 00000000000..5632c3062c9
--- /dev/null
+++ b/Lib/test/test_email/data/msg_36.txt
@@ -0,0 +1,40 @@
+Mime-Version: 1.0
+Content-Type: Multipart/Mixed; Boundary="NextPart"
+To: IETF-Announce:;
+From: Internet-Drafts@ietf.org
+Subject: I-D ACTION:draft-ietf-mboned-mix-00.txt
+Date: Tue, 22 Dec 1998 16:55:06 -0500
+
+--NextPart
+
+Blah blah blah
+
+--NextPart
+Content-Type: Multipart/Alternative; Boundary="OtherAccess"
+
+--OtherAccess
+Content-Type: Message/External-body;
+	access-type="mail-server";
+	server="mailserv@ietf.org"
+
+Content-Type: text/plain
+Content-ID: <19981222151406.I-D@ietf.org>
+
+ENCODING mime
+FILE /internet-drafts/draft-ietf-mboned-mix-00.txt
+
+--OtherAccess
+Content-Type: Message/External-body;
+	name="draft-ietf-mboned-mix-00.txt";
+	site="ftp.ietf.org";
+	access-type="anon-ftp";
+	directory="internet-drafts"
+
+Content-Type: text/plain
+Content-ID: <19981222151406.I-D@ietf.org>
+
+
+--OtherAccess--
+
+--NextPart--
+
diff --git a/Lib/test/test_email/data/msg_37.txt b/Lib/test/test_email/data/msg_37.txt
new file mode 100644
index 00000000000..038d34a1a42
--- /dev/null
+++ b/Lib/test/test_email/data/msg_37.txt
@@ -0,0 +1,22 @@
+Content-Type: multipart/mixed; boundary=ABCDE
+
+--ABCDE
+Content-Type: text/x-one
+
+Blah
+
+--ABCDE
+--ABCDE
+Content-Type: text/x-two
+
+Blah
+
+--ABCDE
+--ABCDE
+--ABCDE
+--ABCDE
+Content-Type: text/x-two
+
+Blah
+
+--ABCDE--
diff --git a/Lib/test/test_email/data/msg_38.txt b/Lib/test/test_email/data/msg_38.txt
new file mode 100644
index 00000000000..006df81cb59
--- /dev/null
+++ b/Lib/test/test_email/data/msg_38.txt
@@ -0,0 +1,101 @@
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
+
+------- =_aaaaaaaaaa0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.1@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa2"
+Content-ID: <20592.1022586929.2@example.com>
+
+------- =_aaaaaaaaaa2
+Content-Type: text/plain
+Content-ID: <20592.1022586929.3@example.com>
+Content-Description: very tricky
+Content-Transfer-Encoding: 7bit
+
+
+Unlike the test test_nested-multiples-with-internal-boundary, this
+piece of text not only contains the outer boundary tags 
+------- =_aaaaaaaaaa1 
+and 
+------- =_aaaaaaaaaa0 
+but puts them at the start of a line! And, to be even nastier, it
+even includes a couple of end tags, such as this one:
+
+------- =_aaaaaaaaaa1--
+
+and this one, which is from a multipart we haven't even seen yet!
+
+------- =_aaaaaaaaaa4--
+
+This will, I'm sure, cause much breakage of MIME parsers. But, as 
+far as I can tell, it's perfectly legal. I have not yet ever seen
+a case of this in the wild, but I've seen *similar* things.
+
+
+------- =_aaaaaaaaaa2
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.4@example.com>
+Content-Description: patch2
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa2--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa3"
+Content-ID: <20592.1022586929.6@example.com>
+
+------- =_aaaaaaaaaa3
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.7@example.com>
+Content-Description: patch3
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa3
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.8@example.com>
+Content-Description: patch4
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa3--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa4"
+Content-ID: <20592.1022586929.10@example.com>
+
+------- =_aaaaaaaaaa4
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.11@example.com>
+Content-Description: patch5
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa4
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.12@example.com>
+Content-Description: patch6
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa4--
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa0
+Content-Type: text/plain; charset="us-ascii"
+Content-ID: <20592.1022586929.15@example.com>
+
+--
+It's never too late to have a happy childhood.
+
+------- =_aaaaaaaaaa0--
diff --git a/Lib/test/test_email/data/msg_39.txt b/Lib/test/test_email/data/msg_39.txt
new file mode 100644
index 00000000000..124b2691927
--- /dev/null
+++ b/Lib/test/test_email/data/msg_39.txt
@@ -0,0 +1,83 @@
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
+
+------- =_aaaaaaaaaa0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.1@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.2@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.3@example.com>
+Content-Description: patch1
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.4@example.com>
+Content-Description: patch2
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.6@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.7@example.com>
+Content-Description: patch3
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.8@example.com>
+Content-Description: patch4
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.10@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.11@example.com>
+Content-Description: patch5
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.12@example.com>
+Content-Description: patch6
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa0
+Content-Type: text/plain; charset="us-ascii"
+Content-ID: <20592.1022586929.15@example.com>
+
+--
+It's never too late to have a happy childhood.
+
+------- =_aaaaaaaaaa0--
diff --git a/Lib/test/test_email/data/msg_40.txt b/Lib/test/test_email/data/msg_40.txt
new file mode 100644
index 00000000000..1435fa1e1a0
--- /dev/null
+++ b/Lib/test/test_email/data/msg_40.txt
@@ -0,0 +1,10 @@
+MIME-Version: 1.0
+Content-Type: text/html; boundary="--961284236552522269"
+
+----961284236552522269
+Content-Type: text/html;
+Content-Transfer-Encoding: 7Bit
+
+<html></html>
+
+----961284236552522269--
diff --git a/Lib/test/test_email/data/msg_41.txt b/Lib/test/test_email/data/msg_41.txt
new file mode 100644
index 00000000000..76cdd1cb7f2
--- /dev/null
+++ b/Lib/test/test_email/data/msg_41.txt
@@ -0,0 +1,8 @@
+From: "Allison Dunlap" <xxx@example.com>
+To: yyy@example.com
+Subject: 64423
+Date: Sun, 11 Jul 2004 16:09:27 -0300
+MIME-Version: 1.0
+Content-Type: multipart/alternative;
+
+Blah blah blah
diff --git a/Lib/test/test_email/data/msg_42.txt b/Lib/test/test_email/data/msg_42.txt
new file mode 100644
index 00000000000..a75f8f4a020
--- /dev/null
+++ b/Lib/test/test_email/data/msg_42.txt
@@ -0,0 +1,20 @@
+Content-Type: multipart/mixed; boundary="AAA"
+From: Mail Delivery Subsystem <xxx@example.com>
+To: yyy@example.com
+
+This is a MIME-encapsulated message
+
+--AAA
+
+Stuff
+
+--AAA
+Content-Type: message/rfc822
+
+From: webmaster@python.org
+To: zzz@example.com
+Content-Type: multipart/mixed; boundary="BBB"
+
+--BBB--
+
+--AAA--
diff --git a/Lib/test/test_email/data/msg_43.txt b/Lib/test/test_email/data/msg_43.txt
new file mode 100644
index 00000000000..797d12c5688
--- /dev/null
+++ b/Lib/test/test_email/data/msg_43.txt
@@ -0,0 +1,217 @@
+From SRS0=aO/p=ON=bag.python.org=None@bounce2.pobox.com  Fri Nov 26 21:40:36 2004
+X-VM-v5-Data: ([nil nil nil nil nil nil nil nil nil]
+	[nil nil nil nil nil nil nil "MAILER DAEMON <>" "MAILER DAEMON <>" nil nil "Banned file: auto__mail.python.bat in mail from you" "^From:" nil nil nil nil "Banned file: auto__mail.python.bat in mail from you" nil nil nil nil nil nil nil]
+	nil)
+MIME-Version: 1.0
+Message-Id: <edab.7804f5cb8070@python.org>
+Content-Type: multipart/report; report-type=delivery-status;
+    charset=utf-8;
+    boundary="----------=_1101526904-1956-5"
+X-Virus-Scanned: by XS4ALL Virus Scanner
+X-UIDL: 4\G!!!<c"!UV["!M7C!!
+From: MAILER DAEMON <>
+To: <webmaster@python.org>
+Subject: Banned file: auto__mail.python.bat in mail from you
+Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+This is a multi-part message in MIME format...
+
+------------=_1101526904-1956-5
+Content-Type: text/plain; charset="utf-8"
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+
+BANNED FILENAME ALERT
+
+Your message to: xxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxx@dot.ca.gov, xxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxxxxx@dot.ca.gov
+was blocked by our Spam Firewall. The email you sent with the following subject has NOT BEEN DELIVERED:
+
+Subject: Delivery_failure_notice
+
+An attachment in that mail was of a file type that the Spam Firewall is set to block.
+
+
+
+------------=_1101526904-1956-5
+Content-Type: message/delivery-status
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+Content-Description: Delivery error report
+
+Reporting-MTA: dns; sacspam01.dot.ca.gov
+Received-From-MTA: smtp; sacspam01.dot.ca.gov ([127.0.0.1])
+Arrival-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+------------=_1101526904-1956-5
+Content-Type: text/rfc822-headers
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+Content-Description: Undelivered-message headers
+
+Received: from kgsav.org (ppp-70-242-162-63.dsl.spfdmo.swbell.net [70.242.162.63])
+	by sacspam01.dot.ca.gov (Spam Firewall) with SMTP
+	id A232AD03DE3A; Fri, 26 Nov 2004 19:41:35 -0800 (PST)
+From: webmaster@python.org
+To: xxxxx@dot.ca.gov
+Date: Sat, 27 Nov 2004 03:35:30 UTC
+Subject: Delivery_failure_notice
+Importance: Normal
+X-Priority: 3 (Normal)
+X-MSMail-Priority: Normal
+Message-ID: <edab.7804f5cb8070@python.org>
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="====67bd2b7a5.f99f7"
+Content-Transfer-Encoding: 7bit
+
+------------=_1101526904-1956-5--
+
diff --git a/Lib/test/test_email/data/msg_44.txt b/Lib/test/test_email/data/msg_44.txt
new file mode 100644
index 00000000000..15a225287bd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_44.txt
@@ -0,0 +1,33 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Received: by mail.python.org (Postfix, from userid 889)
+	id C2BF0D37C6; Tue, 11 Sep 2001 00:05:05 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="h90VIIIKmx"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15261.36209.358846.118674@anthem.python.org>
+From: barry@python.org (Barry A. Warsaw)
+To: barry@python.org
+Subject: a simple multipart
+Date: Tue, 11 Sep 2001 00:05:05 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Make a door into a window
+
+
+--h90VIIIKmx
+Content-Type: text/plain; name="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx
+Content-Type: text/plain; name="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx--
+
diff --git a/Lib/test/test_email/data/msg_45.txt b/Lib/test/test_email/data/msg_45.txt
new file mode 100644
index 00000000000..58fde956e71
--- /dev/null
+++ b/Lib/test/test_email/data/msg_45.txt
@@ -0,0 +1,33 @@
+From: <foo@bar.baz>
+To: <baz@bar.foo>
+Subject: test
+X-Long-Line: Some really long line contains a lot of text and thus has to be rewrapped because it is some
+	really long
+        line
+MIME-Version: 1.0
+Content-Type: multipart/signed; boundary="borderline";
+	protocol="application/pgp-signature"; micalg=pgp-sha1
+
+This is an OpenPGP/MIME signed message (RFC 2440 and 3156)
+--borderline
+Content-Type: text/plain
+X-Long-Line: Another really long line contains a lot of text and thus has to be rewrapped because it is another
+	really long
+        line
+
+This is the signed contents.
+
+--borderline
+Content-Type: application/pgp-signature; name="signature.asc"
+Content-Description: OpenPGP digital signature
+Content-Disposition: attachment; filename="signature.asc"
+
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.6 (GNU/Linux)
+
+iD8DBQFG03voRhp6o4m9dFsRApSZAKCCAN3IkJlVRg6NvAiMHlvvIuMGPQCeLZtj
+FGwfnRHFBFO/S4/DKysm0lI=
+=t7+s
+-----END PGP SIGNATURE-----
+
+--borderline--
diff --git a/Lib/test/test_email/data/msg_46.txt b/Lib/test/test_email/data/msg_46.txt
new file mode 100644
index 00000000000..1e22c4f600a
--- /dev/null
+++ b/Lib/test/test_email/data/msg_46.txt
@@ -0,0 +1,23 @@
+Return-Path: <sender@example.net>
+Delivery-Date: Mon, 08 Feb 2010 14:05:16 +0100
+Received: from example.org (example.org [64.5.53.58])
+    by example.net (node=mxbap2) with ESMTP (Nemesis)
+    id UNIQUE for someone@example.com; Mon, 08 Feb 2010 14:05:16 +0100
+Date: Mon, 01 Feb 2010 12:21:16 +0100
+From: "Sender" <sender@example.net>
+To: <someone@example.com>
+Subject: GroupwiseForwardingTest
+Mime-Version: 1.0
+Content-Type: message/rfc822
+
+Return-path: <sender@example.net>
+Message-ID: <4B66B890.4070408@teconcept.de>
+Date: Mon, 01 Feb 2010 12:18:40 +0100
+From: "Dr. Sender" <sender@example.net>
+MIME-Version: 1.0
+To: "Recipient" <recipient@example.com>
+Subject: GroupwiseForwardingTest
+Content-Type: text/plain; charset=ISO-8859-15
+Content-Transfer-Encoding: 7bit
+
+Testing email forwarding with Groupwise 1.2.2010
diff --git a/Lib/test/test_email/data/msg_47.txt b/Lib/test/test_email/data/msg_47.txt
new file mode 100644
index 00000000000..bb48b47d96b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_47.txt
@@ -0,0 +1,14 @@
+Date: 01 Jan 2001 00:01+0000
+From: arthur@example.example
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=foo
+
+--foo
+Content-Type: text/plain
+bar
+
+--foo
+Content-Type: text/html
+<html><body><p>baz</p></body></html>
+
+--foo--
\ No newline at end of file
diff --git a/Lib/test/test_email/data/python.bmp b/Lib/test/test_email/data/python.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..675f95191a45fdb3ae845996d6871b86286f848a
GIT binary patch
literal 1162
zcmZ{kYe<t}6vtn)BJE2|0!uR`6N$?5GMzfz#ku9?3?T~ggZ5#mSsH3&Uee06g_stK
zY2k%57iL-6MKhhHACi*Hv?3#gE-XJ($V<XF{hwWQeb`~YZSQlQ^XHuZ^YF?N^(#3`
z=<!_y*4c33d^uN^vE|v{<sgo;e%KPpl*zfJ#)ZJtM?UL)%S|qlkPwejoi0G4)2(i9
zXmE>mpK|q2sSaMQcOvV!f#cTTaT5pwGN1$s5CJv=mUkMl<G(bbiN&#?H)cLyoXC5O
zXv65@w4i>l5Jgcy;ItSC?Tnd^`$!ZyO|<JR5z}Dd_0r5EEdk!Z4Xgq#V1@131HXa;
zb41$DL>7%HXiN}owe^9#6tKCr10S#!uzCDIGzdHNjmWMc9{p|zePQa{W;AvB4VXGT
z`>Y5WM+&f)Y5BJ0OR`&Y#e7pvBu<7?XPJl`HRPB@gg%1MhyQD<AIuZMRpTk_54~M1
zpSoEfrItJ~se`=_X3s6$V;X7bV?Sm|#4L7=oemlshyEB@4?Sh^d{=QCwV#ww&0(Pd
zYuaO9ez#}-F!O0&mo;SQBLaQcHEez=A6Fz$PnnW#70KzwiCDUvA?#J`_DX?{2B-i#
zf2m@4_K5VonP(b1(8m_cg7x@;i;48Gd=K3zjVD8)jN0;Js3|9k>N3OWN`{bX)5G|R
z)Zkw1O;Wu2St<KK6#mYtfi>}P^<L_~prHrnRMdT1L3S@1vm-6_OoL(5kgI2iq|gvf
zn&(mPKT?zYbf_wc`YP3Q|E!AaUNq;5so|*TKMm|x?VBY^_+;i|CjXwnvpe9PS8Ge2
z={3#0<*JshVtE_RqN6TLWVoag8tStmmNZyB@MJa4f_ZV*!Ha7SUZ95Enf1<U*?PZT
z!>;?17p-|QWcLE;K)~*-(-^GMc0W0vFmLgqB#t_8FRmYt=IheKYf;2%Ew2~5z(0uc
Bxh4Pr

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.exr b/Lib/test/test_email/data/python.exr
new file mode 100644
index 0000000000000000000000000000000000000000..773c81ee1fb850cdbb6cccd3ae5edabb80146481
GIT binary patch
literal 2635
zcmcJROK2NM7{@2=N@|-p=|Qy*&7%~@59(Nt9qrD{DhX+Ai$Y5vmGPwyR7-LMiexOs
zO(7|QBFmSQLUHU%A5d)h)E0`IT#^`yB17rp;>J*toManH+guzM3T?lco%Qb8Dm`_U
z-I?7P&G(!C_n$$NfzZCk5JIEp6S-U}TYyG3Qz)XB;oBLs51zd6n%^((`4Zdn<=mbx
zXf%Ied?HmSWb!#zTTGu!6cZzvTr&R-dOLq9oIy|Xh_W1ln%~JxVLY37_dmyFGr82+
ziDYU5*)0)eJaZ|PJyRG@jTX-(ikUo0XY+|7Qbe56>B8tlDwQ**e<_tK!UU7yG<rf}
z@X9%4B$F(j-!%pLRs=%mHLfR=pJhGzxcUBztP5sP^rx)f_n7_ry=MK9te^Fn@1M*1
z1xfR@tc@ql{%>T>-%92u@w`Iw28!})*_a_yz24^?ozV2MpXdU;Ku^*wQX}p@{+1<}
z944FkwBDgtw7vaJJdewG04sP}-3Z(LT!xbUicALU=?P8sIy(_srzm=b4$^1nJu=^d
zBTi8C4}DIL>D$_D3ywNQ(Kz<w6*Z<d92{K!f9LSy!4qzdTl51uOpnlCL5)@%eMBKQ
z^by^sS6gz-;3Vz@iZM{b$-&cZa%}1z+6EC$LY!e(HNVQ(+i!7nvA^gNWTcJONSWLO
z3OC1P5+{9R4U}kTX{`YiZatc~4jI9CQSAmLd~iEC6v^?MjBI7Z;^02<6Hl+k4zl~g
z84>EC-w6uNF&vqP)gg41WXS+HV-1|4>vshO=jbqgXJ0aejz_j|O*+FQksQ&7#*YR<
z-0ngTv3@tj62*{B6wMpu;8C_tzo6V1ZNeE`jVN%`AlH0dm&q%nli1GSYIuQTo81*0
zo(NZiJ7ZBegHsG~f57|?frD?eRvgR565YZB;5vRSs*mU`IwhRZ6wa6t6miJ)MtC8F
z(Cd&Br!y*oViG8>vrj>fRqS>~RZxt{y@?Rt-cF7sdPk5Kf&99*EXO7B_w*WlgPx!t
zlQ@Q-h{9LrQx`(XAS{a<AS?QqKC5-@?1H202X-4M-UE(#Tm)}ya#!p)uEPK&#5$2U
z>`E}J8F834afDjY<rr{C5nls`M(9<@#D-SY+O><3RnWqx-U*e1eC7kf8IzESL&jM{
zH;x&9vj>vmP2fn1GlOSv&W>&}h`jLQjC0&(JnB;9lNNq$XMTK9IHQKQVJDar7<UT_
zU!VdUYvRlp3Li7xGETcF(%^7}uyBSi@Rg;2WZ+Rh1AjavIkrU(YQmS64pzOWSHef&
z<Z6N%4XsO?iZnsvZgm~B@CAH<avwq?uuFV8LVGFFY!!Z|2!BE_M|`W@4xIZXhtks-
zoK~x0vu~Kbx^vCxeyo54%wke3s+I6ys59v8_x5uNyO>&>V*RY0J)-yFx(5`FA~<58
znssSF0eOYH1h?{Bxu@O-bGmr_xEh`cO$Y4Loog|GW2!ei4_d$vcNN<g6_yqeb`5aN
zZ}+u9vt++YznV15hJr!$9?x;*ur<V@s0UHhcD~ii&x;4F!K$nRe&hb!U3PW|@bGiP
zDhHuavR<IB<1{n(OM~6e$5glK2yMctydJ897DKx-Vop+leL4#iX?BX;bZ0~i_|RCB
l`(@4WIym|Nqmns=cq%=yKsDS6yFCuOawVYjI6D8w=0ET8=T!gz

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.gif b/Lib/test/test_email/data/python.gif
new file mode 100644
index 0000000000000000000000000000000000000000..efa0be3861d79f44b006b876a6408e42a09dc8fd
GIT binary patch
literal 405
zcmV;G0c!q7Nk%w1VGsZi0QElr>$@21z9I9$8v4f>{mUEw%pB{&D*w+T|IZ}<&?W!V
zE$hWJ=*K<((=h+kF#Xjw`qMf8*E#vsKL6M{?9N61+Cl%@ME~AP|KCpk;#L3SSpVl@
z^5Jgv<8S@xYX9qOGGK=`W{@^#kv3_QH)xhOYL+={mO5{nI&hpjaGX4Go;`D-K6Ii#
zcBMdgrb2tFLwu`4eXT`*uSS5eM}e|PgS1G6wn~P&Oo_Zqio8sUzfX<9P>;h>k;ec3
z{{R30A^!_WZDD6+O<`wgV`~RzVQp<;Jum<v`2+<306zdM000005C9MW00x`DpYXT4
z&0;MTX~-1je6tq|RcbPAQC6xnvi@|o7|Rqgm8#6%4p)=8RHxDTm$^uOJRME;f{*?n
zKNl4bUp6#SDrX{r6od*thcGT(O%)Le2R}zHB0n4+8yOfC6AB0fKQU529UmJS7#0x?
z2n7N{D=9y(v8AU41y-;a3=0MU003UGvkeKtUO%!C4hcS~(mxQ-1q0gPLqPyLgI})i

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.jpg b/Lib/test/test_email/data/python.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..21222c09f5a71d9d86a0323e49ebc5da6639b22f
GIT binary patch
literal 543
zcmex=<NpH&0WUXCHwH#VMg|aM_<x(hnSq%J1VAJ+5U{YZfB**@8!H<p2NxG72PY>N
z4?hnVHy<}AC$AtcAHRTrpa2(-kg$+|Fpw<(GK3MNlbMABs8N8MlN%^XBKUuRL6Cz%
zfI)znQHg;`kdaxC@&6G9F|bn^kN`UiD^OfTfPs;Pkp<{tm=q%u(B-V`974i^N(>^L
zhDJbDq9A{w0ydzqvLFK^6Du<-LWYq^keP**O_4#!P*g0j@!|hl3_Q$?KxZ%uGT1YS
zEW4B?U3~DFu+WvMGM@#LpQxtp+ZFXD)74?)Q-w_-OXV+}+VSg?!s=<Z({m=9KAT;B
z{aNmE@y4a$GW9aA3Lkk}UVp3<{7EYF-jzZxi!DtrygRiDGv&_eDq4Shzf-DY&AWwB
zrF~aD)}%(ab~m<GD{9V2Uzt5+r)R4F&J(Sgg5Hf<AF6JCvT3Lb-N*YaX`#cJ7tdzd
z#%y=qe7!0)V&ly~#g6?cJ1&1boWY`b;KIM%HcSs}LfE(Ly;&XdO#OG>{V53|O-aJN
mJA!6tn6q{kRVF+!>dZgf)VDmS=aoY5z6wcs_O<o@Zvp^c43nn-

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.pbm b/Lib/test/test_email/data/python.pbm
new file mode 100644
index 00000000000..1848ba7ff06
--- /dev/null
+++ b/Lib/test/test_email/data/python.pbm
@@ -0,0 +1,3 @@
+P4
+16 16
+ûñ¿úßÕ­±[ñ¥a_ÁX
°
°
ðððð?ÿÿ
\ No newline at end of file
diff --git a/Lib/test/test_email/data/python.pgm b/Lib/test/test_email/data/python.pgm
new file mode 100644
index 0000000000000000000000000000000000000000..8349f2a53a9be1d895a561cc0fd31f91d7d42b33
GIT binary patch
literal 269
zcmWGA<uWu=Ff`*bGBxF50D|V)s?z+-L=Y1U8vd6R<fJ3`HRVOQ8A(unYhz7GPD*@A
zB81=GQeRb)pPiZr<lnn_iJ`Tj8mu`nF_Pid^-BzmP|XRE45zMNzQ9mdQJj~k2eRhC
zwJR6SGE|i0CotT3^638U8$j+!hLVCD{d>=#+*1b_a<elSo;?Q1UOap1)J(AZfZQX8
p5A4~wa~7D(0G2&>3c>-Bw{Bd$c<%p6IREU0^XE<-od)M4GXMy?WS0N{

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.png b/Lib/test/test_email/data/python.png
new file mode 100644
index 0000000000000000000000000000000000000000..1a987f79fcd248a94fcd1c45934136919cc0ffdd
GIT binary patch
literal 1020
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbL!Lb6AYF9SoB8UsT^3j@P1pisjL
z28L1t28LG&3=CE?7#PG0=IjczVPIf98sHP+3RK|Nd%&x0mrdb3^NeXgE;8`zKjPE1
z-=lS#bM0E&l7*Hz)6CK)KokT`Jofjl*UzhVK(0|jJCOW))eK0QW=sN-Z_a^CHp`qW
zZ3toj!K1^je{VVh8E%c6%+e<U8J`~J{e7AB_q4Qg?K&AF@2`*ZKOdBGC|zt@ya*_J
zXqFI=L<TR8+rB<(^7@e0>wSu^cS{_bjjjNq`0qVGWL+OG*#Ek0`S+6kuj7&jreo3K
z(Y(c_ZmmPba-Xg}|NsAYtzYk0xx%hwkyZX|v&<=;t=ruiHab<WvMXI|T`<=?YnnyQ
zbpPIi-W|JLYJs|z*%mLb%$@oFQD{K_VV}-D9xYpe0rmf$_y1dtzTNxW8a7xL%=v%I
z>HjtJ|Ce>W+IPA)ZgQ?!ZC|$Z|8<N1=av6IOZ@*h{QrI5|F@m~U)KA7UgiJmod3@g
z|KE20f8Fx`85t{}_UB3eA4mMZ@Av<*{{P!9|F2v9zijaTg6jVpR{yU68ETU}8JK{6
z4l4=r3uajV_WLAmW(`Ntx&;dtFJHCFLt^juCa!JHZ&kkgci3)=@o~@o?)H6^-?H!D
zuSah_l>gnk%7jDF#&p$6AgEMe;uIFrk^Al-!^-G$=KGCmYgs2(3;7>L0);>u7?Zr+
zU80zGF9pTWS5Ftm5Q)pl2@Fhb%Qk%AND~V)W7Fv9>FVq3?M_c`<y28oQ(eB~SaCs9
zWy~F$JvD!rGCzK7a#Gk=P~{ep7FOnG6QB_864IlnzhA*>nE~Gk@#z{`)21Y8cxw21
z>3R1~7n?p&cm0Yf$tzZ^TRAm6KqTZ*K-kLFYr<0lPM-<7e&I@1Mo!kc?98iSNf$ab
zuUyT}&d+)EA}90hrRNC-25-!=UcY?%`o)|4x37%M5)Dj^w=;awUArbXC-<$z8%Y_N
zxpS(2tNF|^+1Y*g&{5GxRogj(m-%&HD*ImW<qH#c#qS?}uRnd}FKDYgXL3QwL(@X#
zipU8z28Sf4`V+ddp8^9wwZt`|BqgyV)hf9t6-Y4{85o-A8W`#tnS~e`SeaT{8JlYx
r7+Dz@{GP>Lj-nwqKP5A*5>tbL0Yt;W_if978W=oX{an^LB{Ts5zOa#I

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.ppm b/Lib/test/test_email/data/python.ppm
new file mode 100644
index 0000000000000000000000000000000000000000..7d9cdb3215877b4604de4c177fc81ebb645b8290
GIT binary patch
literal 781
zcmWGA<1#c;Ff`*bGBxF5KmvZf2fW&Lc{Fcvsaxw%vD~I`o_WSJBzbhEPuHIR|Npzz
zuXn6mVOO%qDu1?F<`i^ANPN%M?QRVlovK&al`gg}m}{Oj4Xb*;{v$qJ`#oB>IoGbW
zEm>%pGtDe*f<?}Bpkhq*K@*Sp_a5}_*bQ=aEzsG^Y>O9I=FWsDhN%DlDD>}Lub)@#
zfNlxsKkU=F$D?H{#MwaeA<l-VH%e#+s`-D<`~NM+zgNwGY~SvEU}tZDIeQMo*`^tj
zAd26dbNzqI>HjtJ|Ce=v>b=@`x;Jieu32qgw$v<hvb3QqP!J9t9d`YD)A9dx3!viv
z=aqrtZjGBD&NfS*2;_cxnD_T(*8gXT{~w3{zwi71wi8&f-v9F|e@{yT6*$+f1BN!x
z*)m4nUmxfHf1UIHIb5;x|Ld0jFM|~SKO^(`pcGKOL+N7M;zd>kbAW8H;-vqNBmUp_
z`+pmvSRbMosQ%C_A)p#$@c%hf@r&cOuaBC%KBV<}pW^G?5<qlpHo9V<MwrPi|F2v9
zzijaTf-2BhWCPLIfA0aE;qw26)&DC%#cIH`1o0!9GC23+1^Zu@E&pE92Pr-y^Xs_e
Nf$3PB0as590{~zq4y*tG

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.ras b/Lib/test/test_email/data/python.ras
new file mode 100644
index 0000000000000000000000000000000000000000..130e96f817ed9dd45f411f2f93e0749a4b33ba49
GIT binary patch
literal 1056
zcmaKrYe-XJ7{}KQx_pU6V7W@kBBHD4=G0Ahb-6hsh>H49eJC|cLygR|t7(RqR+G|1
z8);jZU5(OAXX%HeBr~nZNTCbM4;67pIQ)B_xycaof#29U=l#9^=Q)>cwJDb*63JXI
zK@!Py`YV~nKND4hwYYUS{>)>TPThw-uO6|7>xAfoRb`4K+Z+=9D|$DBrKlNPhGPxT
zWZ!@~^BN-4Dj-k3xPsR39+MR|<UfS*_#J3-oKR=k5tV)wiWD3B8WQJEAm>?2o>g0l
zp4OQ18|}K>`Z`r+jZ>LwbISLeM?`8lyNrq4fN}nlO{E=3EN+9juxWJWT%NfWs*GwV
z_h0t8J|7s|EQlZDPyX#y&!)Ywv7{ZAv&}G_elRvO<@;v#`Hi7F3v|3517_g8W?1Z%
zhwyR2xfbutxBX_W^vx`UCzY|ANNWp!yfl!j1>P!vp4BS$;|m@k?!;Z_j^0Gfq3ezE
z<O@3j*BdN!jpvOc_`dBMY&QtvI}Okm!7lJ>sgceLMsoF|GdtybORaRS_SfeFg7`fJ
z__7Na+5&t^06tKz$6Z5ih#<ZQ<h}cJxwkyenP%QD3pL;SGn59nQ-QDku8v$K<$7G8
zOXm9BwvhWui_NkNstkHZ(ksn$>~(ij?pDgRQm)Tk%em|_M_gB=VYGfG5lloA;RNN5
zxz2B$Du?@dn8WQ_>2S9MJKRkHOm;_wl(U0~sl+T|9w8<Ca`n`6B=x)w=w8N|>~O{^
zVlgq%yDW$U+%viT<i25dIe!j(zhcRe5u7)Jm_m#%%g^qZu8|(4Aikz~+3k|`k901`
gX)TvV(PHj#vf}%(h~Pf81V1AK5kV{=__}}n1COYt{r~^~

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.sgi b/Lib/test/test_email/data/python.sgi
new file mode 100644
index 0000000000000000000000000000000000000000..ffe9081c7a5b67ed14285041fd0650f4010bc36d
GIT binary patch
literal 1967
zcmeH{?@wD*7{{Np+fpc+%}ygq{ju21#kkGkD3np?r4%Z3oiQ$(aWCdxOgd38fB`4d
zwijB!v0n{LnFfY3tRlK0Q<-xx-CnG5C@LF^BOA#!Gxx$Rrg2Gg{GNLY*&pCLZTrdT
z_c_n^Ip;a|v}}qol4t?mI?`S|IsQNVCr&^-c3lSWf*=?IH;MF5f;uollrj&v!7gx)
z$Z#)!HZ&kt0*k?OpcRY)+#$UKC?E#U-C!g509=L70@i_M<fecuumyC2AK_UDo(22B
zG(1Z|HTV+5;adqdgT2U41BIXlpuX-RJdc73@Cmp9Pd>n2Qm_{T)-x1<D$tGQv46S~
zqyt0p`yI(~KE}I%37`iR5fk~d%=%~bg4=S12ffUBh5onwqMkskD-e6Veg7gR^lVJ@
zV@xt1liEi|EvXM=7nQnlA4(NZltO>rN^pMbxLy_G6F-f|PIYRc(6(ZU`96~>T0F5h
z=V!OAHmNRuLeGKfxp4mM&*S{GCcMRYPb}e?s_@74T!}l(X-toQ9~~LEmNPSbesW?w
zril&0vDgfu%u8EnGVq|B{WyD&rNba`|5g1p|4Cd+9kpJWnLhRX*s+n3E=_OV;I*%M
zY*9vr30g^Al%I|KsQx2=1C!aqq&Vz(WaMm&5w+LVRMRySz`|!@G4`&A^&Z$yl_=u0
zt+1HQ%!HUy73byfyv|lplT)^v|4QTRrbupVsLh(0tH4G@?9=|9@~X-g)~|8emRrp1
ze#Dw4Ie-2zOk+%@P)V`FN;eV)&JrTu-&p@5UHtvBwheY##10Mg?WR|@qDWEhatq5u
zEQEuOdi&zA#aSsemz6pTt(iIsTuMkB^UWdu8?X6R>PR_pZgPU15uvXRef;5G7eX#M
zcNu#GAsr77Z}hlJ<(J}cmC)O3o+>FSSe;|d&Z0lmI_+&uZ*8lq-s-E^L_bXZ$|m4y
zKX&A^Xz%`x$es|nigMU8#8UAPhu4PTu~X=2kJ}~N^CYX1MO^DEw6jHdv!S+1@+q6>
z!W8=jp3sS-Ukvv5bV(5<MCCHGB4*^uuoIr^%tGO3)|R`A9d?^!4H8eVzcC-)y(1iK
ztgm@l@&)PAZ)%<J$<dLafxhl{q)3p~m9YZk`M)vppqs~8fElTcydJmHZnNfEt++#N
zw6nFTv9@wcrO&6z@4g)#=;_$i8HqrKX?u51@4;wP;sJMtcKws5f?50)k_V!RBcDfm
z-|G-QadiXoJ(|J8U2;L5SPX_%E;<)WK^*0S{Rg_{3`^5BgSQNw=I3ZRJDP*r>tC(V
Y#PP3(1`fX8p^CuZbqNQ(CtZT;AGbYjjQ{`u

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.tiff b/Lib/test/test_email/data/python.tiff
new file mode 100644
index 0000000000000000000000000000000000000000..39d0bfcec02533ade8934a8796aebb8990c9d389
GIT binary patch
literal 1326
zcmZ{kYe<t}6vsDjm?h=HvRroylhO*EPTh3QnU^_5iiG@7eOOxN3|FM4&C0HXX`$E+
zFQmCJ%gQLtyp(>(N;1=o3>C6iK^NjBVVur+_Bv<MGyZ$e`#k6O{LgvbcZ-Sf5jZ;t
zW(>`_wuaafkG@48y9bf^^$>oj7DD%5;{sDlOE7sh%6<l9Goe1y0yI=d8bFbK1LXQD
z2-aN&N!mrgG;b8`@!t_s_yD2|cOW9y2=W8f5R!Qn0{4_o@(Kjq|AjS0PxIAho>W8^
zHdQL~>Z@h?%35i9sZpXmZwyK=V=V6<jjV?)pH$rSIN@A7#GPse)^i^9Tm!PK3XtwA
zx3ZHwjBW+<hgj}Uzx*if<C0j^3F^}=5Pkf<wP*CV_DmdU(~gr(n6HH4IDjDqnENH)
z@ZKx_Y%5rLzHQU<6>HA{sU;lGCVYLVIt4=!0B-{U`qtBV%3@DGgv|wwpgepN!VX?X
zuM16{8&xT|rbbb}n^B6<PSsxXI|T;=L5zi0tB8+^Drn>)`JN@ai;Xy^`8kqNWB#&-
zgHJmF#<l@`j0bp+zKrz+c;yA==bjwxt<1YMK+l<a7H^8%{(DS!7fk5@<F>34St<Hj
zSm+VMulB_qR9E<cYMm^riVM!XLiNO1*j?zGjJ_K5on-x(FR`SKOQIai_eVLSR-i&r
z0Wdzre(shTP0#%6OdURTrq&g8re+VOuFIlq%%yi}Im!+-3pF1ln(~drnuD?C4FJ8X
znJ2Cj6M$NWT8f(SE}Mrn9K1(%5ZO1xu3^6i{=CAG5u?b@5hX-T8$Wu()DwNu9`kEI
zj<MM5ME9b>wlYyJCWfFy(}0;bbRJ7kRA&T=p1%qegj$B8b?b1$8thpa^KedR6Wd`-
ze-K0XWzWx3xlVjc$L3-)?<%wt%)z;p*q58of$d3FBAXm{KBj#a@Ua2og?v64if!`O
zVoW}CP;#Loi$%D97{*RGJBs;9e7+@*+OvEFE(6tc^oEg~Ep!#U=uxxlrSfvR8njyW
fXuf-=%w_kUu8C|tS<3P=v-PRE3}1bkRx9`m*;LyH

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.webp b/Lib/test/test_email/data/python.webp
new file mode 100644
index 0000000000000000000000000000000000000000..e824ec7fb1c7fa85716d27454e9d1715a896d4b4
GIT binary patch
literal 432
zcmV;h0Z;x?Nk&Gf0RRA3MM6+kP&il$0000G0000F000jF06|PpNW%aC00AeWsF5V)
zdgmBl=ie%sh?xI$agE?6Fyi5hcQVMq5nO{SFzB#&6^?jOHNglB0#A~lYOqxq9M-mN
zMlVjrc09K2cl)m?t|6lTNzwg}koUSoNhBLOC6P4q6m1U2)8!T*^a~Wekl};38Zw?X
zf`1(;eol4>`-q;ik?)yvM(8qv+xW~#viC(WeIWfd7mOh?RxPF0Ya_f}<E2>@)trH(
z*>09~iWo5uimEJ7H2N@t-@0p1QYp19&*@YY3IPBB09H^qAie+q0FVLzodGHk01yBJ
z05m1A0(3A>2!#xM104t~{pbMx{dA!H0-GO-_d|S~H}=vDuhaiEXyWdty~%GI^s2>U
zuDYL>gx^7;JK9_1@A%8{y?^1a`ak6f?DV^4U;nBp*?-Aw=Z5C2m$~G|^phiuU)_&6
zRUm(rPy9Lf|8LT31L&W;gP3M*vDFj*b{FQc{#}aXpGUv5`oI1i9rF^8{#?(&`uP~c
az0c1dkvX6N{h9$wF)ZG^*?X$20000=+R1SM

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/python.xbm b/Lib/test/test_email/data/python.xbm
new file mode 100644
index 00000000000..cfbee2e9806
--- /dev/null
+++ b/Lib/test/test_email/data/python.xbm
@@ -0,0 +1,6 @@
+#define python_width 16
+#define python_height 16
+static char python_bits[] = {
+  0xDF, 0xFE, 0x8F, 0xFD, 0x5F, 0xFB, 0xAB, 0xFE, 0xB5, 0x8D, 0xDA, 0x8F, 
+  0xA5, 0x86, 0xFA, 0x83, 0x1A, 0x80, 0x0D, 0x80, 0x0D, 0x80, 0x0F, 0xE0, 
+  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xFC, 0xFF, 0xFF, };
diff --git a/Lib/test/test_email/data/sndhdr.aifc b/Lib/test/test_email/data/sndhdr.aifc
new file mode 100644
index 0000000000000000000000000000000000000000..8aae4e730bdafeaf888a40d2e6950fab4de43ec5
GIT binary patch
literal 106
zcmZ?s5AtPTU`TTGbaQqKa}5HrSr#<}Iyn3Lg2dGrn1CcJgMb6y8W$i72>ks0T>0|y
bOB9mxa|?=6i;GiJ7=nZSK(aDm1vm%*H%bt5

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/sndhdr.aiff b/Lib/test/test_email/data/sndhdr.aiff
new file mode 100644
index 0000000000000000000000000000000000000000..8c279a762f1c7074f9e91356b7b81b3da420db03
GIT binary patch
literal 108
zcmZ?s5AtPTU`TQFbaQj|_YDEEr5G4bB$=NDvIGK(@{?1Gi&Ik+k}4H~^CN&NK&pip
bn1CcJgMb6y8W$i72!ezCKr9(B2L}NFoskd!

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/sndhdr.au b/Lib/test/test_email/data/sndhdr.au
new file mode 100644
index 0000000000000000000000000000000000000000..f76b0501b8c61b4fabbb3715b69a9434a42469cb
GIT binary patch
literal 28144
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
Xh!X_U;M@RG_pPOQ?cxro7n}YcFvyK}

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/data/sndhdr.wav b/Lib/test/test_email/data/sndhdr.wav
new file mode 100644
index 0000000000000000000000000000000000000000..0dca36739cde302167f1f9356213ec5ef3148f9e
GIT binary patch
literal 64
ycmWIYbaS&{U|<M$40BD(Em05vvKbke7+lscFbHg9VqjqqU`R<UNfZH!V*>zB;s=5N

literal 0
HcmV?d00001

diff --git a/Lib/test/test_email/test__encoded_words.py b/Lib/test/test_email/test__encoded_words.py
new file mode 100644
index 00000000000..dcac7d34e95
--- /dev/null
+++ b/Lib/test/test_email/test__encoded_words.py
@@ -0,0 +1,208 @@
+import unittest
+from email import _encoded_words as _ew
+from email import errors
+from test.test_email import TestEmailBase
+
+
+class TestDecodeQ(TestEmailBase):
+
+    def _test(self, source, ex_result, ex_defects=[]):
+        result, defects = _ew.decode_q(source)
+        self.assertEqual(result, ex_result)
+        self.assertDefectsEqual(defects, ex_defects)
+
+    def test_no_encoded(self):
+        self._test(b'foobar', b'foobar')
+
+    def test_spaces(self):
+        self._test(b'foo=20bar=20', b'foo bar ')
+        self._test(b'foo_bar_', b'foo bar ')
+
+    def test_run_of_encoded(self):
+        self._test(b'foo=20=20=21=2Cbar', b'foo  !,bar')
+
+
+class TestDecodeB(TestEmailBase):
+
+    def _test(self, source, ex_result, ex_defects=[]):
+        result, defects = _ew.decode_b(source)
+        self.assertEqual(result, ex_result)
+        self.assertDefectsEqual(defects, ex_defects)
+
+    def test_simple(self):
+        self._test(b'Zm9v', b'foo')
+
+    def test_missing_padding(self):
+        # 1 missing padding character
+        self._test(b'dmk', b'vi', [errors.InvalidBase64PaddingDefect])
+        # 2 missing padding characters
+        self._test(b'dg', b'v', [errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_character(self):
+        self._test(b'dm\x01k===', b'vi', [errors.InvalidBase64CharactersDefect])
+
+    def test_invalid_character_and_bad_padding(self):
+        self._test(b'dm\x01k', b'vi', [errors.InvalidBase64CharactersDefect,
+                                       errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_length(self):
+        self._test(b'abcde', b'abcde', [errors.InvalidBase64LengthDefect])
+
+
+class TestDecode(TestEmailBase):
+
+    def test_wrong_format_input_raises(self):
+        with self.assertRaises(ValueError):
+            _ew.decode('=?badone?=')
+        with self.assertRaises(ValueError):
+            _ew.decode('=?')
+        with self.assertRaises(ValueError):
+            _ew.decode('')
+        with self.assertRaises(KeyError):
+            _ew.decode('=?utf-8?X?somevalue?=')
+
+    def _test(self, source, result, charset='us-ascii', lang='', defects=[]):
+        res, char, l, d = _ew.decode(source)
+        self.assertEqual(res, result)
+        self.assertEqual(char, charset)
+        self.assertEqual(l, lang)
+        self.assertDefectsEqual(d, defects)
+
+    def test_simple_q(self):
+        self._test('=?us-ascii?q?foo?=', 'foo')
+
+    def test_simple_b(self):
+        self._test('=?us-ascii?b?dmk=?=', 'vi')
+
+    def test_q_case_ignored(self):
+        self._test('=?us-ascii?Q?foo?=', 'foo')
+
+    def test_b_case_ignored(self):
+        self._test('=?us-ascii?B?dmk=?=', 'vi')
+
+    def test_non_trivial_q(self):
+        self._test('=?latin-1?q?=20F=fcr=20Elise=20?=', ' Für Elise ', 'latin-1')
+
+    def test_q_escaped_bytes_preserved(self):
+        self._test(b'=?us-ascii?q?=20\xACfoo?='.decode('us-ascii',
+                                                       'surrogateescape'),
+                   ' \uDCACfoo',
+                   defects = [errors.UndecodableBytesDefect])
+
+    def test_b_undecodable_bytes_ignored_with_defect(self):
+        self._test(b'=?us-ascii?b?dm\xACk?='.decode('us-ascii',
+                                                   'surrogateescape'),
+                   'vi',
+                   defects = [
+                    errors.InvalidBase64CharactersDefect,
+                    errors.InvalidBase64PaddingDefect])
+
+    def test_b_invalid_bytes_ignored_with_defect(self):
+        self._test('=?us-ascii?b?dm\x01k===?=',
+                   'vi',
+                   defects = [errors.InvalidBase64CharactersDefect])
+
+    def test_b_invalid_bytes_incorrect_padding(self):
+        self._test('=?us-ascii?b?dm\x01k?=',
+                   'vi',
+                   defects = [
+                    errors.InvalidBase64CharactersDefect,
+                    errors.InvalidBase64PaddingDefect])
+
+    def test_b_padding_defect(self):
+        self._test('=?us-ascii?b?dmk?=',
+                   'vi',
+                    defects = [errors.InvalidBase64PaddingDefect])
+
+    def test_nonnull_lang(self):
+        self._test('=?us-ascii*jive?q?test?=', 'test', lang='jive')
+
+    def test_unknown_8bit_charset(self):
+        self._test('=?unknown-8bit?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'unknown-8bit',
+                   defects = [])
+
+    def test_unknown_charset(self):
+        self._test('=?foobar?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'foobar',
+                   # XXX Should this be a new Defect instead?
+                   defects = [errors.CharsetError])
+
+    @unittest.skip("TODO: RUSTPYTHON; str has surrogates")
+    def test_invalid_character_in_charset(self):
+        self._test('=?utf-8\udce2\udc80\udc9d?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'utf-8\udce2\udc80\udc9d',
+                   # XXX Should this be a new Defect instead?
+                   defects = [errors.CharsetError])
+
+    def test_q_nonascii(self):
+        self._test('=?utf-8?q?=C3=89ric?=',
+                   'Éric',
+                   charset='utf-8')
+
+
+class TestEncodeQ(TestEmailBase):
+
+    def _test(self, src, expected):
+        self.assertEqual(_ew.encode_q(src), expected)
+
+    def test_all_safe(self):
+        self._test(b'foobar', 'foobar')
+
+    def test_spaces(self):
+        self._test(b'foo bar ', 'foo_bar_')
+
+    def test_run_of_encodables(self):
+        self._test(b'foo  ,,bar', 'foo__=2C=2Cbar')
+
+
+class TestEncodeB(TestEmailBase):
+
+    def test_simple(self):
+        self.assertEqual(_ew.encode_b(b'foo'), 'Zm9v')
+
+    def test_padding(self):
+        self.assertEqual(_ew.encode_b(b'vi'), 'dmk=')
+
+
+class TestEncode(TestEmailBase):
+
+    def test_q(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8', 'q'), '=?utf-8?q?foo?=')
+
+    def test_b(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8', 'b'), '=?utf-8?b?Zm9v?=')
+
+    def test_auto_q(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8'), '=?utf-8?q?foo?=')
+
+    def test_auto_q_if_short_mostly_safe(self):
+        self.assertEqual(_ew.encode('vi.', 'utf-8'), '=?utf-8?q?vi=2E?=')
+
+    def test_auto_b_if_enough_unsafe(self):
+        self.assertEqual(_ew.encode('.....', 'utf-8'), '=?utf-8?b?Li4uLi4=?=')
+
+    def test_auto_b_if_long_unsafe(self):
+        self.assertEqual(_ew.encode('vi.vi.vi.vi.vi.', 'utf-8'),
+                         '=?utf-8?b?dmkudmkudmkudmkudmku?=')
+
+    def test_auto_q_if_long_mostly_safe(self):
+        self.assertEqual(_ew.encode('vi vi vi.vi ', 'utf-8'),
+                         '=?utf-8?q?vi_vi_vi=2Evi_?=')
+
+    def test_utf8_default(self):
+        self.assertEqual(_ew.encode('foo'), '=?utf-8?q?foo?=')
+
+    def test_lang(self):
+        self.assertEqual(_ew.encode('foo', lang='jive'), '=?utf-8*jive?q?foo?=')
+
+    def test_unknown_8bit(self):
+        self.assertEqual(_ew.encode('foo\uDCACbar', charset='unknown-8bit'),
+                         '=?unknown-8bit?q?foo=ACbar?=')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test__header_value_parser.py b/Lib/test/test_email/test__header_value_parser.py
new file mode 100644
index 00000000000..64bc3677e87
--- /dev/null
+++ b/Lib/test/test_email/test__header_value_parser.py
@@ -0,0 +1,3259 @@
+import string
+import unittest
+from email import _header_value_parser as parser
+from email import errors
+from email import policy
+from test.test_email import TestEmailBase, parameterize
+
+class TestTokens(TestEmailBase):
+
+    # EWWhiteSpaceTerminal
+
+    def test_EWWhiteSpaceTerminal(self):
+        x = parser.EWWhiteSpaceTerminal(' \t', 'fws')
+        self.assertEqual(x, ' \t')
+        self.assertEqual(str(x), '')
+        self.assertEqual(x.value, '')
+        self.assertEqual(x.token_type, 'fws')
+
+
+class TestParserMixin:
+
+    def _assert_results(self, tl, rest, string, value, defects, remainder,
+                        comments=None):
+        self.assertEqual(str(tl), string)
+        self.assertEqual(tl.value, value)
+        self.assertDefectsEqual(tl.all_defects, defects)
+        self.assertEqual(rest, remainder)
+        if comments is not None:
+            self.assertEqual(tl.comments, comments)
+
+    def _test_get_x(self, method, source, string, value, defects,
+                          remainder, comments=None):
+        tl, rest = method(source)
+        self._assert_results(tl, rest, string, value, defects, remainder,
+                             comments=None)
+        return tl
+
+    def _test_parse_x(self, method, input, string, value, defects,
+                             comments=None):
+        tl = method(input)
+        self._assert_results(tl, '', string, value, defects, '', comments)
+        return tl
+
+
+class TestParser(TestParserMixin, TestEmailBase):
+
+    # _wsp_splitter
+
+    rfc_printable_ascii = bytes(range(33, 127)).decode('ascii')
+    rfc_atext_chars = (string.ascii_letters + string.digits +
+                        "!#$%&\'*+-/=?^_`{}|~")
+    rfc_dtext_chars = rfc_printable_ascii.translate(str.maketrans('','',r'\[]'))
+
+    def test__wsp_splitter_one_word(self):
+        self.assertEqual(parser._wsp_splitter('foo', 1), ['foo'])
+
+    def test__wsp_splitter_two_words(self):
+        self.assertEqual(parser._wsp_splitter('foo def', 1),
+                                               ['foo', ' ', 'def'])
+
+    def test__wsp_splitter_ws_runs(self):
+        self.assertEqual(parser._wsp_splitter('foo \t def jik', 1),
+                                              ['foo', ' \t ', 'def jik'])
+
+
+    # get_fws
+
+    def test_get_fws_only(self):
+        fws = self._test_get_x(parser.get_fws, ' \t  ', ' \t  ', ' ', [], '')
+        self.assertEqual(fws.token_type, 'fws')
+
+    def test_get_fws_space(self):
+        self._test_get_x(parser.get_fws, ' foo', ' ', ' ', [], 'foo')
+
+    def test_get_fws_ws_run(self):
+        self._test_get_x(parser.get_fws, ' \t foo ', ' \t ', ' ', [], 'foo ')
+
+    # get_encoded_word
+
+    def test_get_encoded_word_missing_start_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('abc')
+
+    def test_get_encoded_word_missing_end_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?abc')
+
+    def test_get_encoded_word_missing_middle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?abc?=')
+
+    def test_get_encoded_word_invalid_cte(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?utf-8?X?somevalue?=')
+
+    def test_get_encoded_word_valid_ew(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?this_is_a_test?=  bird',
+                         'this is a test',
+                         'this is a test',
+                         [],
+                         '  bird')
+
+    def test_get_encoded_word_internal_spaces(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?this is a test?=  bird',
+                         'this is a test',
+                         'this is a test',
+                         [errors.InvalidHeaderDefect],
+                         '  bird')
+
+    def test_get_encoded_word_gets_first(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first?=  =?utf-8?q?second?=',
+                         'first',
+                         'first',
+                         [],
+                         '  =?utf-8?q?second?=')
+
+    def test_get_encoded_word_gets_first_even_if_no_space(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first?==?utf-8?q?second?=',
+                         'first',
+                         'first',
+                         [errors.InvalidHeaderDefect],
+                         '=?utf-8?q?second?=')
+
+    def test_get_encoded_word_sets_extra_attributes(self):
+        ew = self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii*jive?q?first_second?=',
+                         'first second',
+                         'first second',
+                         [],
+                         '')
+        self.assertEqual(ew.charset, 'us-ascii')
+        self.assertEqual(ew.lang, 'jive')
+
+    def test_get_encoded_word_lang_default_is_blank(self):
+        ew = self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first_second?=',
+                         'first second',
+                         'first second',
+                         [],
+                         '')
+        self.assertEqual(ew.charset, 'us-ascii')
+        self.assertEqual(ew.lang, '')
+
+    def test_get_encoded_word_non_printable_defect(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first\x02second?=',
+                         'first\x02second',
+                         'first\x02second',
+                         [errors.NonPrintableDefect],
+                         '')
+
+    def test_get_encoded_word_leading_internal_space(self):
+        self._test_get_x(parser.get_encoded_word,
+                        '=?us-ascii?q?=20foo?=',
+                        ' foo',
+                        ' foo',
+                        [],
+                        '')
+
+    def test_get_encoded_word_quopri_utf_escape_follows_cte(self):
+        # Issue 18044
+        self._test_get_x(parser.get_encoded_word,
+                        '=?utf-8?q?=C3=89ric?=',
+                        'Éric',
+                        'Éric',
+                        [],
+                        '')
+
+    # get_unstructured
+
+    def _get_unst(self, value):
+        token = parser.get_unstructured(value)
+        return token, ''
+
+    def test_get_unstructured_null(self):
+        self._test_get_x(self._get_unst, '', '', '', [], '')
+
+    def test_get_unstructured_one_word(self):
+        self._test_get_x(self._get_unst, 'foo', 'foo', 'foo', [], '')
+
+    def test_get_unstructured_normal_phrase(self):
+        self._test_get_x(self._get_unst, 'foo bar bird',
+                                         'foo bar bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_normal_phrase_with_whitespace(self):
+        self._test_get_x(self._get_unst, 'foo \t bar      bird',
+                                         'foo \t bar      bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_leading_whitespace(self):
+        self._test_get_x(self._get_unst, '  foo bar',
+                                         '  foo bar',
+                                         ' foo bar',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_trailing_whitespace(self):
+        self._test_get_x(self._get_unst, 'foo bar  ',
+                                         'foo bar  ',
+                                         'foo bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_leading_and_trailing_whitespace(self):
+        self._test_get_x(self._get_unst, '  foo bar  ',
+                                         '  foo bar  ',
+                                         ' foo bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_valid_ew_no_ws(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?=',
+                                         'bar',
+                                         'bar',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_ew_trailing_ws(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?=  ',
+                                         'bar  ',
+                                         'bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_valid_ew_trailing_text(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?= bird',
+                                         'bar bird',
+                                         'bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_phrase_with_ew_in_middle_of_text(self):
+        self._test_get_x(self._get_unst, 'foo =?us-ascii?q?bar?= bird',
+                                         'foo bar bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_phrase_with_two_ew(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?=',
+            'foo barbird',
+            'foo barbird',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_two_ew_trailing_ws(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?=   ',
+            'foo barbird   ',
+            'foo barbird ',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_ew_with_leading_ws(self):
+        self._test_get_x(self._get_unst,
+            '  =?us-ascii?q?bar?=',
+            '  bar',
+            ' bar',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_two_ew_extra_ws(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= \t  =?us-ascii?q?bird?=',
+            'foo barbird',
+            'foo barbird',
+            [],
+            '')
+
+    def test_get_unstructured_two_ew_extra_ws_trailing_text(self):
+        self._test_get_x(self._get_unst,
+            '=?us-ascii?q?test?=   =?us-ascii?q?foo?=  val',
+            'testfoo  val',
+            'testfoo val',
+            [],
+            '')
+
+    def test_get_unstructured_ew_with_internal_ws(self):
+        self._test_get_x(self._get_unst,
+            '=?iso-8859-1?q?hello=20world?=',
+            'hello world',
+            'hello world',
+            [],
+            '')
+
+    def test_get_unstructured_ew_with_internal_leading_ws(self):
+        self._test_get_x(self._get_unst,
+            '   =?us-ascii?q?=20test?=   =?us-ascii?q?=20foo?=  val',
+            '    test foo  val',
+            '  test foo val',
+            [],
+            '')
+
+    def test_get_unstructured_invalid_ew(self):
+        self._test_get_x(self._get_unst,
+            '=?test val',
+            '=?test val',
+            '=?test val',
+            [],
+            '')
+
+    def test_get_unstructured_undecodable_bytes(self):
+        self._test_get_x(self._get_unst,
+            b'test \xACfoo  val'.decode('ascii', 'surrogateescape'),
+            'test \uDCACfoo  val',
+            'test \uDCACfoo val',
+            [errors.UndecodableBytesDefect],
+            '')
+
+    def test_get_unstructured_undecodable_bytes_in_EW(self):
+        self._test_get_x(self._get_unst,
+            (b'=?us-ascii?q?=20test?=   =?us-ascii?q?=20\xACfoo?='
+                b'  val').decode('ascii', 'surrogateescape'),
+            ' test \uDCACfoo  val',
+            ' test \uDCACfoo val',
+            [errors.UndecodableBytesDefect]*2,
+            '')
+
+    def test_get_unstructured_missing_base64_padding(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dmk?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64PaddingDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_character(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dm\x01k===?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64CharactersDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_character_and_bad_padding(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dm\x01k?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64CharactersDefect,
+             errors.InvalidBase64PaddingDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_length(self):
+        # bpo-27397: Return the encoded string since there's no way to decode.
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?abcde?=',
+            'abcde',
+            'abcde',
+            [errors.InvalidBase64LengthDefect],
+            '')
+
+    def test_get_unstructured_no_whitespace_between_ews(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?foo?==?utf-8?q?bar?=',
+            'foobar',
+            'foobar',
+            [errors.InvalidHeaderDefect,
+            errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_ew_without_leading_whitespace(self):
+        self._test_get_x(
+            self._get_unst,
+            'nowhitespace=?utf-8?q?somevalue?=',
+            'nowhitespacesomevalue',
+            'nowhitespacesomevalue',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_ew_without_trailing_whitespace(self):
+        self._test_get_x(
+            self._get_unst,
+            '=?utf-8?q?somevalue?=nowhitespace',
+            'somevaluenowhitespace',
+            'somevaluenowhitespace',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_without_trailing_whitespace_hang_case(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?somevalue?=aa',
+            'somevalueaa',
+            'somevalueaa',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_invalid_ew2(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?=somevalue?=',
+            '=?utf-8?q?=somevalue?=',
+            '=?utf-8?q?=somevalue?=',
+            [],
+            '')
+
+    def test_get_unstructured_invalid_ew_cte(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?X?=somevalue?=',
+            '=?utf-8?X?=somevalue?=',
+            '=?utf-8?X?=somevalue?=',
+            [],
+            '')
+
+    # get_qp_ctext
+
+    def test_get_qp_ctext_only(self):
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                'foobar', 'foobar', ' ', [], '')
+        self.assertEqual(ptext.token_type, 'ptext')
+
+    def test_get_qp_ctext_all_printables(self):
+        with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
+        with_qp = with_qp.  replace('(', r'\(')
+        with_qp = with_qp.replace(')', r'\)')
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                 with_qp, self.rfc_printable_ascii, ' ', [], '')
+
+    def test_get_qp_ctext_two_words_gets_first(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo de', 'foo', ' ', [], ' de')
+
+    def test_get_qp_ctext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo \t\tde', 'foo', ' ', [], ' \t\tde')
+
+    def test_get_qp_ctext_up_to_close_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo)', 'foo', ' ', [], ')')
+
+    def test_get_qp_ctext_wsp_before_close_paren_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo  )', 'foo', ' ', [], '  )')
+
+    def test_get_qp_ctext_close_paren_mid_word(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo)bar', 'foo', ' ', [], ')bar')
+
+    def test_get_qp_ctext_up_to_open_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo(', 'foo', ' ', [], '(')
+
+    def test_get_qp_ctext_wsp_before_open_paren_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo  (', 'foo', ' ', [], '  (')
+
+    def test_get_qp_ctext_open_paren_mid_word(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo(bar', 'foo', ' ', [], '(bar')
+
+    def test_get_qp_ctext_non_printables(self):
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                'foo\x00bar)', 'foo\x00bar', ' ',
+                                [errors.NonPrintableDefect], ')')
+        self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
+
+    def test_get_qp_ctext_close_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        ')', '', ' ', [], ')')
+
+    def test_get_qp_ctext_open_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        '(', '', ' ', [], '(')
+
+    def test_get_qp_ctext_no_end_char(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        '', '', ' ', [], '')
+
+
+    # get_qcontent
+
+    def test_get_qcontent_only(self):
+        ptext = self._test_get_x(parser.get_qcontent,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(ptext.token_type, 'ptext')
+
+    def test_get_qcontent_all_printables(self):
+        with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
+        with_qp = with_qp.  replace('"', r'\"')
+        ptext = self._test_get_x(parser.get_qcontent, with_qp,
+                                 self.rfc_printable_ascii,
+                                 self.rfc_printable_ascii, [], '')
+
+    def test_get_qcontent_two_words_gets_first(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo de', 'foo', 'foo', [], ' de')
+
+    def test_get_qcontent_following_wsp_preserved(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo \t\tde', 'foo', 'foo', [], ' \t\tde')
+
+    def test_get_qcontent_up_to_dquote_only(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo"', 'foo', 'foo', [], '"')
+
+    def test_get_qcontent_wsp_before_close_paren_preserved(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo  "', 'foo', 'foo', [], '  "')
+
+    def test_get_qcontent_close_paren_mid_word(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo"bar', 'foo', 'foo', [], '"bar')
+
+    def test_get_qcontent_non_printables(self):
+        ptext = self._test_get_x(parser.get_qcontent,
+                                'foo\x00fg"', 'foo\x00fg', 'foo\x00fg',
+                                [errors.NonPrintableDefect], '"')
+        self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
+
+    def test_get_qcontent_empty(self):
+        self._test_get_x(parser.get_qcontent,
+                         '"', '', '', [], '"')
+
+    def test_get_qcontent_no_end_char(self):
+        self._test_get_x(parser.get_qcontent,
+                         '', '', '', [], '')
+
+    # get_atext
+
+    def test_get_atext_only(self):
+        atext = self._test_get_x(parser.get_atext,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(atext.token_type, 'atext')
+
+    def test_get_atext_all_atext(self):
+        atext = self._test_get_x(parser.get_atext, self.rfc_atext_chars,
+                                 self.rfc_atext_chars,
+                                 self.rfc_atext_chars, [], '')
+
+    def test_get_atext_two_words_gets_first(self):
+        self._test_get_x(parser.get_atext,
+                        'foo bar', 'foo', 'foo', [], ' bar')
+
+    def test_get_atext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_atext,
+                        'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
+
+    def test_get_atext_up_to_special(self):
+        self._test_get_x(parser.get_atext,
+                        'foo@bar', 'foo', 'foo', [], '@bar')
+
+    def test_get_atext_non_printables(self):
+        atext = self._test_get_x(parser.get_atext,
+                                'foo\x00bar(', 'foo\x00bar', 'foo\x00bar',
+                                [errors.NonPrintableDefect], '(')
+        self.assertEqual(atext.defects[0].non_printables[0], '\x00')
+
+    # get_bare_quoted_string
+
+    def test_get_bare_quoted_string_only(self):
+        bqs = self._test_get_x(parser.get_bare_quoted_string,
+                               '"foo"', '"foo"', 'foo', [], '')
+        self.assertEqual(bqs.token_type, 'bare-quoted-string')
+
+    def test_get_bare_quoted_string_must_start_with_dquote(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_bare_quoted_string('foo"')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_bare_quoted_string('  "foo"')
+
+    def test_get_bare_quoted_string_only_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+                         '""', '""', '', [], '')
+
+    def test_get_bare_quoted_string_missing_endquotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+                         '"', '""', '', [errors.InvalidHeaderDefect], '')
+
+    def test_get_bare_quoted_string_following_wsp_preserved(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo"\t bar', '"foo"', 'foo', [], '\t bar')
+
+    def test_get_bare_quoted_string_multiple_words(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo bar moo"', '"foo bar moo"', 'foo bar moo', [], '')
+
+    def test_get_bare_quoted_string_multiple_words_wsp_preserved(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '" foo  moo\t"', '" foo  moo\t"', ' foo  moo\t', [], '')
+
+    def test_get_bare_quoted_string_end_dquote_mid_word(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo"bar', '"foo"', 'foo', [], 'bar')
+
+    def test_get_bare_quoted_string_quoted_dquote(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             r'"foo\"in"a', r'"foo\"in"', 'foo"in', [], 'a')
+
+    def test_get_bare_quoted_string_non_printables(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"a\x01a"', '"a\x01a"', 'a\x01a',
+             [errors.NonPrintableDefect], '')
+
+    def test_get_bare_quoted_string_no_end_dquote(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo', '"foo"', 'foo',
+             [errors.InvalidHeaderDefect], '')
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo ', '"foo "', 'foo ',
+             [errors.InvalidHeaderDefect], '')
+
+    def test_get_bare_quoted_string_empty_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+            '""', '""', '', [], '')
+
+    # Issue 16983: apply postel's law to some bad encoding.
+    def test_encoded_word_inside_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+            '"=?utf-8?Q?not_really_valid?="',
+            '"not really valid"',
+            'not really valid',
+            [errors.InvalidHeaderDefect,
+             errors.InvalidHeaderDefect],
+            '')
+
+    # get_comment
+
+    def test_get_comment_only(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(comment)', '(comment)', ' ', [], '', ['comment'])
+        self.assertEqual(comment.token_type, 'comment')
+
+    def test_get_comment_must_start_with_paren(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_comment('foo"')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_comment('  (foo"')
+
+    def test_get_comment_following_wsp_preserved(self):
+        self._test_get_x(parser.get_comment,
+            '(comment)  \t', '(comment)', ' ', [], '  \t', ['comment'])
+
+    def test_get_comment_multiple_words(self):
+        self._test_get_x(parser.get_comment,
+            '(foo bar)  \t', '(foo bar)', ' ', [], '  \t', ['foo bar'])
+
+    def test_get_comment_multiple_words_wsp_preserved(self):
+        self._test_get_x(parser.get_comment,
+            '( foo  bar\t )  \t', '( foo  bar\t )', ' ', [], '  \t',
+                [' foo  bar\t '])
+
+    def test_get_comment_end_paren_mid_word(self):
+        self._test_get_x(parser.get_comment,
+            '(foo)bar', '(foo)', ' ', [], 'bar', ['foo'])
+
+    def test_get_comment_quoted_parens(self):
+        self._test_get_x(parser.get_comment,
+            r'(foo\) \(\)bar)', r'(foo\) \(\)bar)', ' ', [], '', ['foo) ()bar'])
+
+    def test_get_comment_non_printable(self):
+        self._test_get_x(parser.get_comment,
+            '(foo\x7Fbar)', '(foo\x7Fbar)', ' ',
+            [errors.NonPrintableDefect], '', ['foo\x7Fbar'])
+
+    def test_get_comment_no_end_paren(self):
+        self._test_get_x(parser.get_comment,
+            '(foo bar', '(foo bar)', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo bar'])
+        self._test_get_x(parser.get_comment,
+            '(foo bar  ', '(foo bar  )', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo bar  '])
+
+    def test_get_comment_nested_comment(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(foo(bar))', '(foo(bar))', ' ', [], '', ['foo(bar)'])
+        self.assertEqual(comment[1].content, 'bar')
+
+    def test_get_comment_nested_comment_wsp(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(foo ( bar ) )', '(foo ( bar ) )', ' ', [], '', ['foo ( bar ) '])
+        self.assertEqual(comment[2].content, ' bar ')
+
+    def test_get_comment_empty_comment(self):
+        self._test_get_x(parser.get_comment,
+            '()', '()', ' ', [], '', [''])
+
+    def test_get_comment_multiple_nesting(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(((((foo)))))', '(((((foo)))))', ' ', [], '', ['((((foo))))'])
+        for i in range(4, 0, -1):
+            self.assertEqual(comment[0].content, '('*(i-1)+'foo'+')'*(i-1))
+            comment = comment[0]
+        self.assertEqual(comment.content, 'foo')
+
+    def test_get_comment_missing_end_of_nesting(self):
+        self._test_get_x(parser.get_comment,
+            '(((((foo)))', '(((((foo)))))', ' ',
+            [errors.InvalidHeaderDefect]*2, '', ['((((foo))))'])
+
+    def test_get_comment_qs_in_nested_comment(self):
+        comment = self._test_get_x(parser.get_comment,
+            r'(foo (b\)))', r'(foo (b\)))', ' ', [], '', [r'foo (b\))'])
+        self.assertEqual(comment[2].content, 'b)')
+
+    # get_cfws
+
+    def test_get_cfws_only_ws(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '  \t \t', '  \t \t', ' ', [], '', [])
+        self.assertEqual(cfws.token_type, 'cfws')
+
+    def test_get_cfws_only_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo)', '(foo)', ' ', [], '', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_only_mixed(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            ' (foo )  ( bar) ', ' (foo )  ( bar) ', ' ', [], '',
+                ['foo ', ' bar'])
+        self.assertEqual(cfws[1].content, 'foo ')
+        self.assertEqual(cfws[3].content, ' bar')
+
+    def test_get_cfws_ends_at_non_leader(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo) bar', '(foo) ', ' ', [], 'bar', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_ends_at_non_printable(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo) \x07', '(foo) ', ' ', [], '\x07', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_non_printable_in_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo \x07) "test"', '(foo \x07) ', ' ',
+            [errors.NonPrintableDefect], '"test"', ['foo \x07'])
+        self.assertEqual(cfws[0].content, 'foo \x07')
+
+    def test_get_cfws_header_ends_in_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '  (foo ', '  (foo )', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo '])
+        self.assertEqual(cfws[1].content, 'foo ')
+
+    def test_get_cfws_multiple_nested_comments(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo (bar)) ((a)(a))', '(foo (bar)) ((a)(a))', ' ', [],
+                '', ['foo (bar)', '(a)(a)'])
+        self.assertEqual(cfws[0].comments, ['foo (bar)'])
+        self.assertEqual(cfws[2].comments, ['(a)(a)'])
+
+    # get_quoted_string
+
+    def test_get_quoted_string_only(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '"bob"', '"bob"', 'bob', [], '')
+        self.assertEqual(qs.token_type, 'quoted-string')
+        self.assertEqual(qs.quoted_value, '"bob"')
+        self.assertEqual(qs.content, 'bob')
+
+    def test_get_quoted_string_with_wsp(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '\t "bob"  ', '\t "bob"  ', ' bob ', [], '')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+        self.assertEqual(qs.content, 'bob')
+
+    def test_get_quoted_string_with_comments_and_wsp(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (foo) "bob"(bar)', ' (foo) "bob"(bar)', ' bob ', [], '')
+        self.assertEqual(qs[0][1].content, 'foo')
+        self.assertEqual(qs[2][0].content, 'bar')
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_with_multiple_comments(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (foo) (bar) "bob"(bird)', ' (foo) (bar) "bob"(bird)', ' bob ',
+                [], '')
+        self.assertEqual(qs[0].comments, ['foo', 'bar'])
+        self.assertEqual(qs[2].comments, ['bird'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_non_printable_in_comment(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (\x0A) "bob"', ' (\x0A) "bob"', ' bob',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(qs[0].comments, ['\x0A'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob"')
+
+    def test_get_quoted_string_non_printable_in_qcontent(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "a\x0B"', ' (a) "a\x0B"', ' a\x0B',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'a\x0B')
+        self.assertEqual(qs.quoted_value, ' "a\x0B"')
+
+    def test_get_quoted_string_internal_ws(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "foo  bar "', ' (a) "foo  bar "', ' foo  bar ',
+                [], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'foo  bar ')
+        self.assertEqual(qs.quoted_value, ' "foo  bar "')
+
+    def test_get_quoted_string_header_ends_in_comment(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "bob" (a', ' (a) "bob" (a)', ' bob ',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs[2].comments, ['a'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_header_ends_in_qcontent(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "bob', ' (a) "bob"', ' bob',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob"')
+
+    def test_get_quoted_string_cfws_only_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_quoted_string(' (foo) ')
+
+    def test_get_quoted_string_no_quoted_string(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_quoted_string(' (ab) xyz')
+
+    def test_get_quoted_string_qs_ends_at_noncfws(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '\t "bob" fee', '\t "bob" ', ' bob ', [], 'fee')
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    # get_atom
+
+    def test_get_atom_only(self):
+        atom = self._test_get_x(parser.get_atom,
+            'bob', 'bob', 'bob', [], '')
+        self.assertEqual(atom.token_type, 'atom')
+
+    def test_get_atom_with_wsp(self):
+        self._test_get_x(parser.get_atom,
+            '\t bob  ', '\t bob  ', ' bob ', [], '')
+
+    def test_get_atom_with_comments_and_wsp(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) bob(bar)', ' (foo) bob(bar)', ' bob ', [], '')
+        self.assertEqual(atom[0][1].content, 'foo')
+        self.assertEqual(atom[2][0].content, 'bar')
+
+    def test_get_atom_with_multiple_comments(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) (bar) bob(bird)', ' (foo) (bar) bob(bird)', ' bob ',
+                [], '')
+        self.assertEqual(atom[0].comments, ['foo', 'bar'])
+        self.assertEqual(atom[2].comments, ['bird'])
+
+    def test_get_atom_non_printable_in_comment(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (\x0A) bob', ' (\x0A) bob', ' bob',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(atom[0].comments, ['\x0A'])
+
+    def test_get_atom_non_printable_in_atext(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (a) a\x0B', ' (a) a\x0B', ' a\x0B',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(atom[0].comments, ['a'])
+
+    def test_get_atom_header_ends_in_comment(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (a) bob (a', ' (a) bob (a)', ' bob ',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(atom[0].comments, ['a'])
+        self.assertEqual(atom[2].comments, ['a'])
+
+    def test_get_atom_no_atom(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_atom(' (ab) ')
+
+    def test_get_atom_no_atom_before_special(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_atom(' (ab) @')
+
+    def test_get_atom_atom_ends_at_special(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) bob(bar)  @bang', ' (foo) bob(bar)  ', ' bob ', [], '@bang')
+        self.assertEqual(atom[0].comments, ['foo'])
+        self.assertEqual(atom[2].comments, ['bar'])
+
+    def test_get_atom_atom_ends_at_noncfws(self):
+        self._test_get_x(parser.get_atom,
+            'bob  fred', 'bob  ', 'bob ', [], 'fred')
+
+    def test_get_atom_rfc2047_atom(self):
+        self._test_get_x(parser.get_atom,
+            '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
+
+    # get_dot_atom_text
+
+    def test_get_dot_atom_text(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo.bar.bang', 'foo.bar.bang', 'foo.bar.bang', [], '')
+        self.assertEqual(dot_atom_text.token_type, 'dot-atom-text')
+        self.assertEqual(len(dot_atom_text), 5)
+
+    def test_get_dot_atom_text_lone_atom_is_valid(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo', 'foo', 'foo', [], '')
+
+    def test_get_dot_atom_text_raises_on_leading_dot(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('.foo.bar')
+
+    def test_get_dot_atom_text_raises_on_trailing_dot(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('foo.bar.')
+
+    def test_get_dot_atom_text_raises_on_leading_non_atext(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text(' foo.bar')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('@foo.bar')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('"foo.bar"')
+
+    def test_get_dot_atom_text_trailing_text_preserved(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo@bar', 'foo', 'foo', [], '@bar')
+
+    def test_get_dot_atom_text_trailing_ws_preserved(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo .bar', 'foo', 'foo', [], ' .bar')
+
+    # get_dot_atom
+
+    def test_get_dot_atom_only(self):
+        dot_atom = self._test_get_x(parser.get_dot_atom,
+            'foo.bar.bing', 'foo.bar.bing', 'foo.bar.bing', [], '')
+        self.assertEqual(dot_atom.token_type, 'dot-atom')
+        self.assertEqual(len(dot_atom), 1)
+
+    def test_get_dot_atom_with_wsp(self):
+        self._test_get_x(parser.get_dot_atom,
+            '\t  foo.bar.bing  ', '\t  foo.bar.bing  ', ' foo.bar.bing ', [], '')
+
+    def test_get_dot_atom_with_comments_and_wsp(self):
+        self._test_get_x(parser.get_dot_atom,
+            ' (sing)  foo.bar.bing (here) ', ' (sing)  foo.bar.bing (here) ',
+                ' foo.bar.bing ', [], '')
+
+    def test_get_dot_atom_space_ends_dot_atom(self):
+        self._test_get_x(parser.get_dot_atom,
+            ' (sing)  foo.bar .bing (here) ', ' (sing)  foo.bar ',
+                ' foo.bar ', [], '.bing (here) ')
+
+    def test_get_dot_atom_no_atom_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) ')
+
+    def test_get_dot_atom_leading_dot_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) .bar')
+
+    def test_get_dot_atom_two_dots_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom('bar..bang')
+
+    def test_get_dot_atom_trailing_dot_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) bar.bang. foo')
+
+    def test_get_dot_atom_rfc2047_atom(self):
+        self._test_get_x(parser.get_dot_atom,
+            '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
+
+    # get_word (if this were black box we'd repeat all the qs/atom tests)
+
+    def test_get_word_atom_yields_atom(self):
+        word = self._test_get_x(parser.get_word,
+            ' (foo) bar (bang) :ah', ' (foo) bar (bang) ', ' bar ', [], ':ah')
+        self.assertEqual(word.token_type, 'atom')
+        self.assertEqual(word[0].token_type, 'cfws')
+
+    def test_get_word_all_CFWS(self):
+        # bpo-29412: Test that we don't raise IndexError when parsing CFWS only
+        # token.
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_word('(Recipients list suppressed')
+
+    def test_get_word_qs_yields_qs(self):
+        word = self._test_get_x(parser.get_word,
+            '"bar " (bang) ah', '"bar " (bang) ', 'bar  ', [], 'ah')
+        self.assertEqual(word.token_type, 'quoted-string')
+        self.assertEqual(word[0].token_type, 'bare-quoted-string')
+        self.assertEqual(word[0].value, 'bar ')
+        self.assertEqual(word.content, 'bar ')
+
+    def test_get_word_ends_at_dot(self):
+        self._test_get_x(parser.get_word,
+            'foo.', 'foo', 'foo', [], '.')
+
+    # get_phrase
+
+    def test_get_phrase_simple(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            '"Fred A. Johnson" is his name, oh.',
+            '"Fred A. Johnson" is his name',
+            'Fred A. Johnson is his name',
+            [],
+            ', oh.')
+        self.assertEqual(phrase.token_type, 'phrase')
+
+    def test_get_phrase_complex(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            ' (A) bird (in (my|your)) "hand  " is messy\t<>\t',
+            ' (A) bird (in (my|your)) "hand  " is messy\t',
+            ' bird hand   is messy ',
+            [],
+            '<>\t')
+        self.assertEqual(phrase[0][0].comments, ['A'])
+        self.assertEqual(phrase[0][2].comments, ['in (my|your)'])
+
+    def test_get_phrase_obsolete(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            'Fred A.(weird).O Johnson',
+            'Fred A.(weird).O Johnson',
+            'Fred A. .O Johnson',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(phrase), 7)
+        self.assertEqual(phrase[3].comments, ['weird'])
+
+    def test_get_phrase_pharse_must_start_with_word(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            '(even weirder).name',
+            '(even weirder).name',
+            ' .name',
+            [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(phrase), 3)
+        self.assertEqual(phrase[0].comments, ['even weirder'])
+
+    def test_get_phrase_ending_with_obsolete(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            'simple phrase.(with trailing comment):boo',
+            'simple phrase.(with trailing comment)',
+            'simple phrase. ',
+            [errors.ObsoleteHeaderDefect]*2,
+            ':boo')
+        self.assertEqual(len(phrase), 4)
+        self.assertEqual(phrase[3].comments, ['with trailing comment'])
+
+    def get_phrase_cfws_only_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_phrase(' (foo) ')
+
+    # get_local_part
+
+    def test_get_local_part_simple(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'dinsdale@python.org', 'dinsdale', 'dinsdale', [], '@python.org')
+        self.assertEqual(local_part.token_type, 'local-part')
+        self.assertEqual(local_part.local_part, 'dinsdale')
+
+    def test_get_local_part_with_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'Fred.A.Johnson@python.org',
+            'Fred.A.Johnson',
+            'Fred.A.Johnson',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_with_whitespace(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' Fred.A.Johnson  @python.org',
+            ' Fred.A.Johnson  ',
+            ' Fred.A.Johnson ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_with_cfws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo) Fred.A.Johnson (bar (bird))  @python.org',
+            ' (foo) Fred.A.Johnson (bar (bird))  ',
+            ' Fred.A.Johnson ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+        self.assertEqual(local_part[0][0].comments, ['foo'])
+        self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
+
+    def test_get_local_part_simple_quoted(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '"dinsdale"@python.org', '"dinsdale"', '"dinsdale"', [], '@python.org')
+        self.assertEqual(local_part.token_type, 'local-part')
+        self.assertEqual(local_part.local_part, 'dinsdale')
+
+    def test_get_local_part_with_quoted_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '"Fred.A.Johnson"@python.org',
+            '"Fred.A.Johnson"',
+            '"Fred.A.Johnson"',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_quoted_with_whitespace(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' "Fred A. Johnson"  @python.org',
+            ' "Fred A. Johnson"  ',
+            ' "Fred A. Johnson" ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred A. Johnson')
+
+    def test_get_local_part_quoted_with_cfws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo) " Fred A. Johnson " (bar (bird))  @python.org',
+            ' (foo) " Fred A. Johnson " (bar (bird))  ',
+            ' " Fred A. Johnson " ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, ' Fred A. Johnson ')
+        self.assertEqual(local_part[0][0].comments, ['foo'])
+        self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
+
+
+    def test_get_local_part_simple_obsolete(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'Fred. A.Johnson@python.org',
+            'Fred. A.Johnson',
+            'Fred. A.Johnson',
+            [errors.ObsoleteHeaderDefect],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_complex_obsolete_1(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and  dogs "@python.org',
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and  dogs "',
+            ' Fred . A. Johnson.and  dogs ',
+            [errors.ObsoleteHeaderDefect],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson.and  dogs ')
+
+    def test_get_local_part_complex_obsolete_invalid(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and  dogs"@python.org',
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and  dogs"',
+            ' Fred . A. Johnson and  dogs',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson and  dogs')
+
+    def test_get_local_part_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part('')
+
+    def test_get_local_part_no_part_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part(' (foo) ')
+
+    def test_get_local_part_special_instead_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part(' (foo) @python.org')
+
+    def test_get_local_part_trailing_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris.@python.org',
+            ' borris.',
+            ' borris.',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris.')
+
+    def test_get_local_part_trailing_dot_with_ws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris. @python.org',
+            ' borris. ',
+            ' borris. ',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris.')
+
+    def test_get_local_part_leading_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '.borris@python.org',
+            '.borris',
+            '.borris',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, '.borris')
+
+    def test_get_local_part_leading_dot_after_ws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' .borris@python.org',
+            ' .borris',
+            ' .borris',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, '.borris')
+
+    def test_get_local_part_double_dot_raises(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris.(foo).natasha@python.org',
+            ' borris.(foo).natasha',
+            ' borris. .natasha',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris..natasha')
+
+    def test_get_local_part_quoted_strings_in_atom_list(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '""example" example"@example.com',
+            '""example" example"',
+            'example example',
+            [errors.InvalidHeaderDefect]*3,
+            '@example.com')
+        self.assertEqual(local_part.local_part, 'example example')
+
+    def test_get_local_part_valid_and_invalid_qp_in_atom_list(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            r'"\\"example\\" example"@example.com',
+            r'"\\"example\\" example"',
+            r'\example\\ example',
+            [errors.InvalidHeaderDefect]*5,
+            '@example.com')
+        self.assertEqual(local_part.local_part, r'\example\\ example')
+
+    def test_get_local_part_unicode_defect(self):
+        # Currently this only happens when parsing unicode, not when parsing
+        # stuff that was originally binary.
+        local_part = self._test_get_x(parser.get_local_part,
+            'exámple@example.com',
+            'exámple',
+            'exámple',
+            [errors.NonASCIILocalPartDefect],
+            '@example.com')
+        self.assertEqual(local_part.local_part, 'exámple')
+
+    # get_dtext
+
+    def test_get_dtext_only(self):
+        dtext = self._test_get_x(parser.get_dtext,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(dtext.token_type, 'ptext')
+
+    def test_get_dtext_all_dtext(self):
+        dtext = self._test_get_x(parser.get_dtext, self.rfc_dtext_chars,
+                                 self.rfc_dtext_chars,
+                                 self.rfc_dtext_chars, [], '')
+
+    def test_get_dtext_two_words_gets_first(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo bar', 'foo', 'foo', [], ' bar')
+
+    def test_get_dtext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
+
+    def test_get_dtext_non_printables(self):
+        dtext = self._test_get_x(parser.get_dtext,
+                                'foo\x00bar]', 'foo\x00bar', 'foo\x00bar',
+                                [errors.NonPrintableDefect], ']')
+        self.assertEqual(dtext.defects[0].non_printables[0], '\x00')
+
+    def test_get_dtext_with_qp(self):
+        ptext = self._test_get_x(parser.get_dtext,
+                                 r'foo\]\[\\bar\b\e\l\l',
+                                 r'foo][\barbell',
+                                 r'foo][\barbell',
+                                 [errors.ObsoleteHeaderDefect],
+                                 '')
+
+    def test_get_dtext_up_to_close_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo]', 'foo', 'foo', [], ']')
+
+    def test_get_dtext_wsp_before_close_bracket_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo  ]', 'foo', 'foo', [], '  ]')
+
+    def test_get_dtext_close_bracket_mid_word(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo]bar', 'foo', 'foo', [], ']bar')
+
+    def test_get_dtext_up_to_open_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo[', 'foo', 'foo', [], '[')
+
+    def test_get_dtext_wsp_before_open_bracket_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo  [', 'foo', 'foo', [], '  [')
+
+    def test_get_dtext_open_bracket_mid_word(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo[bar', 'foo', 'foo', [], '[bar')
+
+    def test_get_dtext_open_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        '[', '', '', [], '[')
+
+    def test_get_dtext_close_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        ']', '', '', [], ']')
+
+    def test_get_dtext_empty(self):
+        self._test_get_x(parser.get_dtext,
+                        '', '', '', [], '')
+
+    # get_domain_literal
+
+    def test_get_domain_literal_only(self):
+        domain_literal = domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '[127.0.0.1]',
+                                '[127.0.0.1]',
+                                '[127.0.0.1]',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.token_type, 'domain-literal')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_with_internal_ws(self):
+        domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '[  127.0.0.1\t ]',
+                                '[  127.0.0.1\t ]',
+                                '[ 127.0.0.1 ]',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_with_surrounding_cfws(self):
+        domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '(foo)[  127.0.0.1] (bar)',
+                                '(foo)[  127.0.0.1] (bar)',
+                                ' [ 127.0.0.1] ',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_no_start_char_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) ')
+
+    def test_get_domain_literal_no_start_char_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) @')
+
+    def test_get_domain_literal_bad_dtext_char_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) [abc[@')
+
+    # get_domain
+
+    def test_get_domain_regular_domain_only(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  'example.com',
+                                  'example.com',
+                                  'example.com',
+                                  [],
+                                  '')
+        self.assertEqual(domain.token_type, 'domain')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_only(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '[127.0.0.1]',
+                                  '[127.0.0.1]',
+                                  '[127.0.0.1]',
+                                  [],
+                                  '')
+        self.assertEqual(domain.token_type, 'domain')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_with_cfws(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo) example.com(bar)\t',
+                                  '(foo) example.com(bar)\t',
+                                  ' example.com ',
+                                  [],
+                                  '')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_with_cfws(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  ' [127.0.0.1] ',
+                                  [],
+                                  '')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_domain_with_cfws_ends_at_special(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)example.com\t(bar), next',
+                                  '(foo)example.com\t(bar)',
+                                  ' example.com ',
+                                  [],
+                                  ', next')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_with_cfws_ends_at_special(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)[127.0.0.1]\t(bar), next',
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  ' [127.0.0.1] ',
+                                  [],
+                                  ', next')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_obsolete(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo) example . (bird)com(bar)\t',
+                                  '(foo) example . (bird)com(bar)\t',
+                                  ' example . com ',
+                                  [errors.ObsoleteHeaderDefect],
+                                  '')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("")
+
+    def test_get_domain_no_non_cfws_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("  (foo)\t")
+
+    def test_get_domain_no_atom_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("  (foo)\t, broken")
+
+
+    # get_addr_spec
+
+    def test_get_addr_spec_normal(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                                    'dinsdale@example.com',
+                                    'dinsdale@example.com',
+                                    'dinsdale@example.com',
+                                    [],
+                                    '')
+        self.assertEqual(addr_spec.token_type, 'addr-spec')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@example.com')
+
+    def test_get_addr_spec_with_doamin_literal(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                                    'dinsdale@[127.0.0.1]',
+                                    'dinsdale@[127.0.0.1]',
+                                    'dinsdale@[127.0.0.1]',
+                                    [],
+                                    '')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, '[127.0.0.1]')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@[127.0.0.1]')
+
+    def test_get_addr_spec_with_cfws(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) dinsdale(bar)@ (bird) example.com (bog)',
+                '(foo) dinsdale(bar)@ (bird) example.com (bog)',
+                ' dinsdale@example.com ',
+                [],
+                '')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@example.com')
+
+    def test_get_addr_spec_with_qouoted_string_and_cfws(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
+                ' "roy a bug"@example.com ',
+                [],
+                '')
+        self.assertEqual(addr_spec.local_part, 'roy a bug')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
+
+    def test_get_addr_spec_ends_at_special(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog) , next',
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog) ',
+                ' "roy a bug"@example.com ',
+                [],
+                ', next')
+        self.assertEqual(addr_spec.local_part, 'roy a bug')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
+
+    def test_get_addr_spec_quoted_strings_in_atom_list(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(addr_spec.local_part, 'example example')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"example example"@example.com')
+
+    def test_get_addr_spec_dot_atom(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+            'star.a.star@example.com',
+            'star.a.star@example.com',
+            'star.a.star@example.com',
+            [],
+            '')
+        self.assertEqual(addr_spec.local_part, 'star.a.star')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'star.a.star@example.com')
+
+    def test_get_addr_spec_multiple_domains(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@a.star@example.com')
+
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@a@example.com')
+
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@172.17.0.1@example.com')
+
+    # get_obs_route
+
+    def test_get_obs_route_simple(self):
+        obs_route = self._test_get_x(parser.get_obs_route,
+            '@example.com, @two.example.com:',
+            '@example.com, @two.example.com:',
+            '@example.com, @two.example.com:',
+            [],
+            '')
+        self.assertEqual(obs_route.token_type, 'obs-route')
+        self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
+
+    def test_get_obs_route_complex(self):
+        obs_route = self._test_get_x(parser.get_obs_route,
+            '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
+            '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
+            ' ,, @example.com ,@two. example.com :',
+            [errors.ObsoleteHeaderDefect],  # This is the obs-domain
+            '')
+        self.assertEqual(obs_route.token_type, 'obs-route')
+        self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
+
+    def test_get_obs_route_no_route_before_end_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com,')
+
+    def test_get_obs_route_no_route_before_end_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com, (foo) ')
+
+    def test_get_obs_route_no_route_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) [abc],')
+
+    def test_get_obs_route_no_route_before_special_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com [abc],')
+
+    def test_get_obs_route_no_domain_after_at_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('@')
+
+    def test_get_obs_route_no_domain_after_at_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('@example.com, @')
+
+    # get_angle_addr
+
+    def test_get_angle_addr_simple(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_empty(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<>',
+            '<>',
+            '<>',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertIsNone(angle_addr.local_part)
+        self.assertIsNone(angle_addr.domain)
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '<>')
+
+    def test_get_angle_addr_qs_only_quotes(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<""@example.com>',
+            '<""@example.com>',
+            '<""@example.com>',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, '')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '""@example.com')
+
+    def test_get_angle_addr_with_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            ' (foo) <dinsdale@example.com>(bar)',
+            ' (foo) <dinsdale@example.com>(bar)',
+            ' <dinsdale@example.com> ',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_qs_and_domain_literal(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<"Fred Perfect"@[127.0.0.1]>',
+            '<"Fred Perfect"@[127.0.0.1]>',
+            '<"Fred Perfect"@[127.0.0.1]>',
+            [],
+            '')
+        self.assertEqual(angle_addr.local_part, 'Fred Perfect')
+        self.assertEqual(angle_addr.domain, '[127.0.0.1]')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '"Fred Perfect"@[127.0.0.1]')
+
+    def test_get_angle_addr_internal_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<(foo) dinsdale@example.com(bar)>',
+            '<(foo) dinsdale@example.com(bar)>',
+            '< dinsdale@example.com >',
+            [],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_obs_route(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '(foo)<@example.com, (bird) @two.example.com: dinsdale@example.com> (bar) ',
+            '(foo)<@example.com, (bird) @two.example.com: dinsdale@example.com> (bar) ',
+            ' <@example.com, @two.example.com: dinsdale@example.com> ',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertEqual(angle_addr.route, ['example.com', 'two.example.com'])
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_missing_closing_angle(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_missing_closing_angle_with_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com (foo)',
+            '<dinsdale@example.com (foo)>',
+            '<dinsdale@example.com >',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_ends_at_special(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com> (foo), next',
+            '<dinsdale@example.com> (foo)',
+            '<dinsdale@example.com> ',
+            [],
+            ', next')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_empty_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('')
+
+    def test_get_angle_addr_left_angle_only_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('<')
+
+    def test_get_angle_addr_no_angle_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) ')
+
+    def test_get_angle_addr_no_angle_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) , next')
+
+    def test_get_angle_addr_no_angle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('bar')
+
+    def test_get_angle_addr_special_after_angle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) <, bar')
+
+    # get_display_name  This is phrase but with a different value.
+
+    def test_get_display_name_simple(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'Fred A Johnson',
+            'Fred A Johnson',
+            'Fred A Johnson',
+            [],
+            '')
+        self.assertEqual(display_name.token_type, 'display-name')
+        self.assertEqual(display_name.display_name, 'Fred A Johnson')
+
+    def test_get_display_name_complex1(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            '"Fred A. Johnson" is his name, oh.',
+            '"Fred A. Johnson" is his name',
+            '"Fred A. Johnson is his name"',
+            [],
+            ', oh.')
+        self.assertEqual(display_name.token_type, 'display-name')
+        self.assertEqual(display_name.display_name, 'Fred A. Johnson is his name')
+
+    def test_get_display_name_complex2(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            ' (A) bird (in (my|your)) "hand  " is messy\t<>\t',
+            ' (A) bird (in (my|your)) "hand  " is messy\t',
+            ' "bird hand   is messy" ',
+            [],
+            '<>\t')
+        self.assertEqual(display_name[0][0].comments, ['A'])
+        self.assertEqual(display_name[0][2].comments, ['in (my|your)'])
+        self.assertEqual(display_name.display_name, 'bird hand   is messy')
+
+    def test_get_display_name_obsolete(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'Fred A.(weird).O Johnson',
+            'Fred A.(weird).O Johnson',
+            '"Fred A. .O Johnson"',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(display_name), 7)
+        self.assertEqual(display_name[3].comments, ['weird'])
+        self.assertEqual(display_name.display_name, 'Fred A. .O Johnson')
+
+    def test_get_display_name_pharse_must_start_with_word(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            '(even weirder).name',
+            '(even weirder).name',
+            ' ".name"',
+            [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(display_name), 3)
+        self.assertEqual(display_name[0].comments, ['even weirder'])
+        self.assertEqual(display_name.display_name, '.name')
+
+    def test_get_display_name_ending_with_obsolete(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'simple phrase.(with trailing comment):boo',
+            'simple phrase.(with trailing comment)',
+            '"simple phrase." ',
+            [errors.ObsoleteHeaderDefect]*2,
+            ':boo')
+        self.assertEqual(len(display_name), 4)
+        self.assertEqual(display_name[3].comments, ['with trailing comment'])
+        self.assertEqual(display_name.display_name, 'simple phrase.')
+
+    def test_get_display_name_for_invalid_address_field(self):
+        # bpo-32178: Test that address fields starting with `:` don't cause
+        # IndexError when parsing the display name.
+        display_name = self._test_get_x(
+            parser.get_display_name,
+            ':Foo ', '', '', [errors.InvalidHeaderDefect], ':Foo ')
+        self.assertEqual(display_name.value, '')
+
+    # get_name_addr
+
+    def test_get_name_addr_angle_addr_only(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.token_type, 'name-addr')
+        self.assertIsNone(name_addr.display_name)
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_atom_name(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            'Dinsdale <dinsdale@example.com>',
+            'Dinsdale <dinsdale@example.com>',
+            'Dinsdale <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.token_type, 'name-addr')
+        self.assertEqual(name_addr.display_name, 'Dinsdale')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_atom_name_with_cfws(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '(foo) Dinsdale (bar) <dinsdale@example.com> (bird)',
+            '(foo) Dinsdale (bar) <dinsdale@example.com> (bird)',
+            ' Dinsdale <dinsdale@example.com> ',
+            [],
+            '')
+        self.assertEqual(name_addr.display_name, 'Dinsdale')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_name_with_cfws_and_dots(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '(foo) Roy.A.Bear (bar) <dinsdale@example.com> (bird)',
+            '(foo) Roy.A.Bear (bar) <dinsdale@example.com> (bird)',
+            ' "Roy.A.Bear" <dinsdale@example.com> ',
+            [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_qs_name(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_ending_with_dot_without_space(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            'John X.<jxd@example.com>',
+            'John X.<jxd@example.com>',
+            '"John X."<jxd@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, 'John X.')
+        self.assertEqual(name_addr.local_part, 'jxd')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'jxd@example.com')
+
+    def test_get_name_addr_starting_with_dot(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '. Doe <jxd@example.com>',
+            '. Doe <jxd@example.com>',
+            '". Doe" <jxd@example.com>',
+            [errors.InvalidHeaderDefect, errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, '. Doe')
+        self.assertEqual(name_addr.local_part, 'jxd')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'jxd@example.com')
+
+    def test_get_name_addr_with_route(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertEqual(name_addr.route, ['two.example.com'])
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_ends_at_special(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <dinsdale@example.com>, next',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            [],
+            ', next')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr('')
+
+    def test_get_name_addr_no_content_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr(' (foo) ')
+
+    def test_get_name_addr_no_content_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr(' (foo) ,')
+
+    def test_get_name_addr_no_angle_after_display_name_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr('foo bar')
+
+    # get_mailbox
+
+    def test_get_mailbox_addr_spec_only(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_angle_addr_only(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_name_addr(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertEqual(mailbox.display_name, 'Roy A. Bear')
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_ends_at_special(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '"Roy A. Bear" <dinsdale@example.com>, rest',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            [],
+            ', rest')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertEqual(mailbox.display_name, 'Roy A. Bear')
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_quoted_strings_in_atom_list(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(mailbox.local_part, 'example example')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertEqual(mailbox.addr_spec, '"example example"@example.com')
+
+    # get_mailbox_list
+
+    def test_get_mailbox_list_single_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(mailbox_list.token_type, 'mailbox-list')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        mailbox = mailbox_list.mailboxes[0]
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_simple_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            'dinsdale@example.com, dinsdale@test.example.com',
+            'dinsdale@example.com, dinsdale@test.example.com',
+            'dinsdale@example.com, dinsdale@test.example.com',
+            [],
+            '')
+        self.assertEqual(mailbox_list.token_type, 'mailbox-list')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_name_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_complex(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('(foo) "Roy A. Bear" <dinsdale@example.com>(bar),'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('(foo) "Roy A. Bear" <dinsdale@example.com>(bar),'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            (' "Roy A. Bear" <dinsdale@example.com> ,'
+                ' "Fred Flintstone" <dinsdale@test. example.com>'),
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_unparseable_mailbox_null(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test. example.com>'),
+            [errors.InvalidHeaderDefect,   # the 'extra' text after the local part
+             errors.InvalidHeaderDefect,   # the local part with no angle-addr
+             errors.ObsoleteHeaderDefect,  # period in extra text (example.com)
+             errors.ObsoleteHeaderDefect], # (bird) in valid address.
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        self.assertEqual(len(mailbox_list.all_mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
+                        'invalid-mailbox')
+        self.assertIsNone(mailbox_list.all_mailboxes[0].display_name)
+        self.assertEqual(mailbox_list.all_mailboxes[0].local_part,
+                        'Roy A. Bear')
+        self.assertIsNone(mailbox_list.all_mailboxes[0].domain)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        '"Roy A. Bear"')
+        self.assertIs(mailbox_list.all_mailboxes[1],
+                        mailbox_list.mailboxes[0])
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_junk_after_valid_address(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        self.assertEqual(len(mailbox_list.all_mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
+                        'invalid-mailbox')
+        self.assertIs(mailbox_list.all_mailboxes[1],
+                        mailbox_list.mailboxes[0])
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_empty_list_element(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, (bird),,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, (bird),,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, ,,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes,
+                         mailbox_list.mailboxes)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_only_empty_elements(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            '(foo),, (bar)',
+            '(foo),, (bar)',
+            ' ,, ',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 0)
+        self.assertEqual(mailbox_list.all_mailboxes,
+                         mailbox_list.mailboxes)
+
+    # get_group_list
+
+    def test_get_group_list_cfws_only(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            '(hidden);',
+            '(hidden)',
+            ' ',
+            [],
+            ';')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    def test_get_group_list_mailbox_list(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            [],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 2)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+        self.assertEqual(group_list.mailboxes[1].display_name,
+                         'Fred A. Bear')
+
+    def test_get_group_list_obs_group_list(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            ', (foo),,(bar)',
+            ', (foo),,(bar)',
+            ', ,, ',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    def test_get_group_list_comment_only_invalid(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            '(bar)',
+            '(bar)',
+            ' ',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    # get_group
+
+    def test_get_group_empty(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python:;',
+            'Monty Python:;',
+            'Monty Python:;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+
+    def test_get_group_null_addr_spec(self):
+        group = self._test_get_x(parser.get_group,
+            'foo: <>;',
+            'foo: <>;',
+            'foo: <>;',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group.display_name, 'foo')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(len(group.all_mailboxes), 1)
+        self.assertEqual(group.all_mailboxes[0].value, '<>')
+
+    def test_get_group_cfws_only(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python: (hidden);',
+            'Monty Python: (hidden);',
+            'Monty Python: ;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+
+    def test_get_group_single_mailbox(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 1)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].addr_spec,
+                         'dinsdale@example.com')
+
+    def test_get_group_mixed_list(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger <ping@exampele.com>, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger <ping@exampele.com>, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                ' Roger <ping@exampele.com>, x@test.example.com;'),
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 3)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].display_name,
+                         'Roger')
+        self.assertEqual(group.mailboxes[2].local_part, 'x')
+
+    def test_get_group_one_invalid(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger ping@exampele.com, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger ping@exampele.com, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                ' Roger ping@exampele.com, x@test.example.com;'),
+            [errors.InvalidHeaderDefect,   # non-angle addr makes local part invalid
+             errors.InvalidHeaderDefect],   # and its not obs-local either: no dots.
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 2)
+        self.assertEqual(len(group.all_mailboxes), 3)
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].local_part, 'x')
+        self.assertIsNone(group.all_mailboxes[1].display_name)
+
+    def test_get_group_missing_final_semicol(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>'),
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>;'),
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>;'),
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 3)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].addr_spec,
+                         'dinsdale@example.com')
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].addr_spec,
+                         'eric@where.test')
+        self.assertEqual(group.mailboxes[2].display_name,
+                         'John')
+        self.assertEqual(group.mailboxes[2].addr_spec,
+                         'jdoe@test')
+    # get_address
+
+    def test_get_address_simple(self):
+        address = self._test_get_x(parser.get_address,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_complex(self):
+        address = self._test_get_x(parser.get_address,
+            '(foo) "Fred A. Bear" <(bird)dinsdale@example.com>',
+            '(foo) "Fred A. Bear" <(bird)dinsdale@example.com>',
+            ' "Fred A. Bear" < dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_rfc2047_display_name(self):
+        address = self._test_get_x(parser.get_address,
+            '=?utf-8?q?=C3=89ric?= <foo@example.com>',
+            'Éric <foo@example.com>',
+            'Éric <foo@example.com>',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].display_name,
+                         'Éric')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_empty_group(self):
+        address = self._test_get_x(parser.get_address,
+            'Monty Python:;',
+            'Monty Python:;',
+            'Monty Python:;',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address[0].token_type,
+                         'group')
+        self.assertEqual(address[0].display_name,
+                         'Monty Python')
+
+    def test_get_address_group(self):
+        address = self._test_get_x(parser.get_address,
+            'Monty Python: x@example.com, y@example.com;',
+            'Monty Python: x@example.com, y@example.com;',
+            'Monty Python: x@example.com, y@example.com;',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 2)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address[0].token_type,
+                         'group')
+        self.assertEqual(address[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address.mailboxes[0].local_part, 'x')
+
+    def test_get_address_quoted_local_part(self):
+        address = self._test_get_x(parser.get_address,
+            '"foo bar"@example.com',
+            '"foo bar"@example.com',
+            '"foo bar"@example.com',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address.mailboxes[0].local_part,
+                         'foo bar')
+        self.assertEqual(address[0].token_type, 'mailbox')
+
+    def test_get_address_ends_at_special(self):
+        address = self._test_get_x(parser.get_address,
+            'dinsdale@example.com, next',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            ', next')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address[0].token_type, 'mailbox')
+
+    def test_get_address_invalid_mailbox_invalid(self):
+        address = self._test_get_x(parser.get_address,
+            'ping example.com, next',
+            'ping example.com',
+            'ping example.com',
+            [errors.InvalidHeaderDefect,    # addr-spec with no domain
+             errors.InvalidHeaderDefect,    # invalid local-part
+             errors.InvalidHeaderDefect,    # missing .s in local-part
+            ],
+            ', next')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertIsNone(address.all_mailboxes[0].domain)
+        self.assertEqual(address.all_mailboxes[0].local_part, 'ping example.com')
+        self.assertEqual(address[0].token_type, 'invalid-mailbox')
+
+    def test_get_address_quoted_strings_in_atom_list(self):
+        address = self._test_get_x(parser.get_address,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(address.all_mailboxes[0].local_part, 'example example')
+        self.assertEqual(address.all_mailboxes[0].domain, 'example.com')
+        self.assertEqual(address.all_mailboxes[0].addr_spec, '"example example"@example.com')
+
+    def test_get_address_with_invalid_domain(self):
+        address = self._test_get_x(parser.get_address,
+            '<T@[',
+            '<T@[]>',
+            '<T@[]>',
+            [errors.InvalidHeaderDefect,    # missing trailing '>' on angle-addr
+             errors.InvalidHeaderDefect,    # end of input inside domain-literal
+            ],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertEqual(address.all_mailboxes[0].domain, '[]')
+        self.assertEqual(address.all_mailboxes[0].local_part, 'T')
+        self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
+        self.assertEqual(address[0].token_type, 'invalid-mailbox')
+
+        address = self._test_get_x(parser.get_address,
+            '!an??:=m==fr2@[C',
+            '!an??:=m==fr2@[C];',
+            '!an??:=m==fr2@[C];',
+            [errors.InvalidHeaderDefect,    # end of header in group
+             errors.InvalidHeaderDefect,    # end of input inside domain-literal
+            ],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertEqual(address.all_mailboxes[0].domain, '[C]')
+        self.assertEqual(address.all_mailboxes[0].local_part, '=m==fr2')
+        self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
+        self.assertEqual(address[0].token_type, 'group')
+
+    # get_address_list
+
+    def test_get_address_list_CFWS(self):
+        address_list = self._test_get_x(parser.get_address_list,
+                                        '(Recipient list suppressed)',
+                                        '(Recipient list suppressed)',
+                                        ' ',
+                                        [errors.ObsoleteHeaderDefect],  # no content in address list
+                                        '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 0)
+        self.assertEqual(address_list.mailboxes, address_list.all_mailboxes)
+
+    def test_get_address_list_mailboxes_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list[0].token_type, 'address')
+        self.assertIsNone(address_list[0].display_name)
+
+    def test_get_address_list_mailboxes_two_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 2)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].local_part, 'foo')
+        self.assertEqual(address_list.mailboxes[1].display_name, "Fred A. Bar")
+
+    def test_get_address_list_mailboxes_complex(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo <x@example.com>,'
+                'Nobody Is. Special <y@(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo <x@example.com>,'
+                'Nobody Is. Special <y@(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                'Foo <x@example.com>,'
+                '"Nobody Is. Special" <y@example. com>'),
+            [errors.ObsoleteHeaderDefect, # period in Is.
+            errors.ObsoleteHeaderDefect], # cfws in domain
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 3)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.mailboxes[1].local_part, 'x')
+        self.assertEqual(address_list.mailboxes[2].display_name,
+                         'Nobody Is. Special')
+
+    def test_get_address_list_mailboxes_invalid_addresses(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo x@example.com[],'
+                'Nobody Is. Special <(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo x@example.com[],'
+                'Nobody Is. Special <(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                'Foo x@example.com[],'
+                '"Nobody Is. Special" < example. com>'),
+             [errors.InvalidHeaderDefect,   # invalid address in list
+              errors.InvalidHeaderDefect,   # 'Foo x' local part invalid.
+              errors.InvalidHeaderDefect,   # Missing . in 'Foo x' local part
+              errors.ObsoleteHeaderDefect,  # period in 'Is.' disp-name phrase
+              errors.InvalidHeaderDefect,   # no domain part in addr-spec
+              errors.ObsoleteHeaderDefect], # addr-spec has comment in it
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(len(address_list.all_mailboxes), 3)
+        self.assertEqual([str(x) for x in address_list.all_mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.addresses[1].token_type, 'address')
+        self.assertEqual(len(address_list.addresses[0].mailboxes), 1)
+        self.assertEqual(len(address_list.addresses[1].mailboxes), 0)
+        self.assertEqual(len(address_list.addresses[1].mailboxes), 0)
+        self.assertEqual(
+            address_list.addresses[1].all_mailboxes[0].local_part, 'Foo x')
+        self.assertEqual(
+            address_list.addresses[2].all_mailboxes[0].display_name,
+                "Nobody Is. Special")
+
+    def test_get_address_list_group_empty(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'Monty Python: ;',
+            'Monty Python: ;',
+            'Monty Python: ;',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 0)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(len(address_list.addresses), 1)
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.addresses[0].display_name, 'Monty Python')
+        self.assertEqual(len(address_list.addresses[0].mailboxes), 0)
+
+    def test_get_address_list_group_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'Monty Python: dinsdale@example.com;',
+            'Monty Python: dinsdale@example.com;',
+            'Monty Python: dinsdale@example.com;',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.addresses[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
+                         'example.com')
+
+    def test_get_address_list_group_and_mailboxes(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 4)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(len(address_list.addresses), 3)
+        self.assertEqual(address_list.mailboxes[0].local_part, 'dinsdale')
+        self.assertEqual(address_list.addresses[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address_list.addresses[0].mailboxes[1].local_part,
+                         'flint')
+        self.assertEqual(address_list.addresses[1].mailboxes[0].local_part,
+                         'x')
+        self.assertEqual(address_list.addresses[2].mailboxes[0].local_part,
+                         'y')
+        self.assertEqual(str(address_list.addresses[1]),
+                         str(address_list.mailboxes[2]))
+
+    def test_invalid_content_disposition(self):
+        content_disp = self._test_parse_x(
+            parser.parse_content_disposition_header,
+            ";attachment", "; attachment", ";attachment",
+            [errors.InvalidHeaderDefect]*2
+        )
+
+    def test_invalid_content_transfer_encoding(self):
+        cte = self._test_parse_x(
+            parser.parse_content_transfer_encoding_header,
+            ";foo", ";foo", ";foo", [errors.InvalidHeaderDefect]*3
+        )
+
+    # get_msg_id
+
+    def test_get_msg_id_empty(self):
+        # bpo-38708: Test that HeaderParseError is raised and not IndexError.
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id('')
+
+    def test_get_msg_id_valid(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simeple.local@example.something.com>",
+            "<simeple.local@example.something.com>",
+            "<simeple.local@example.something.com>",
+            [],
+            '',
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_obsolete_local(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            '<"simeple.local"@example.com>',
+            '<"simeple.local"@example.com>',
+            '<simeple.local@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '',
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_non_folding_literal_domain(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simple.local@[someexamplecom.domain]>",
+            "<simple.local@[someexamplecom.domain]>",
+            "<simple.local@[someexamplecom.domain]>",
+            [],
+            "",
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+
+    def test_get_msg_id_obsolete_domain_part(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal@(old)example.com>",
+            "<simplelocal@(old)example.com>",
+            "<simplelocal@ example.com>",
+            [errors.ObsoleteHeaderDefect],
+            ""
+        )
+
+    def test_get_msg_id_no_id_right_part(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal>",
+            "<simplelocal>",
+            "<simplelocal>",
+            [errors.InvalidHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_invalid_expected_msg_id_not_found(self):
+        text = "935-XPB-567:0:45327:9:90305:17843586-40@example.com"
+        msg_id = parser.parse_message_id(text)
+        self.assertDefectsEqual(
+            msg_id.all_defects,
+            [errors.InvalidHeaderDefect])
+
+    def test_parse_invalid_message_id(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            [errors.InvalidHeaderDefect],
+            )
+        self.assertEqual(message_id.token_type, 'invalid-message-id')
+
+    def test_parse_valid_message_id(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<aperson@somedomain>",
+            "<aperson@somedomain>",
+            "<aperson@somedomain>",
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+
+    def test_parse_message_id_with_invalid_domain(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<T@[",
+            "<T@[]>",
+            "<T@[]>",
+            [errors.ObsoleteHeaderDefect] + [errors.InvalidHeaderDefect] * 2,
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+        self.assertEqual(str(message_id.all_defects[-1]),
+                         "end of input inside domain-literal")
+
+    def test_parse_message_id_with_remaining(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<validmessageid@example>thensomething",
+            "<validmessageid@example>",
+            "<validmessageid@example>",
+            [errors.InvalidHeaderDefect],
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+        self.assertEqual(str(message_id.all_defects[0]),
+                         "Unexpected 'thensomething'")
+
+    def test_get_msg_id_no_angle_start(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("msgwithnoankle")
+
+    def test_get_msg_id_no_angle_end(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal@domain",
+            "<simplelocal@domain>",
+            "<simplelocal@domain>",
+            [errors.InvalidHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_empty_id_left(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<@domain>")
+
+    def test_get_msg_id_empty_id_right(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<simplelocal@>")
+
+    def test_get_msg_id_no_id_right(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<simplelocal@")
+
+    def test_get_msg_id_with_brackets(self):
+        # Microsof Outlook generates non-standard one-off addresses:
+        # https://learn.microsoft.com/en-us/office/client-developer/outlook/mapi/one-off-addresses
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<[abrakadabra@microsoft.com]>")
+
+    def test_get_msg_id_ws_only_local(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "< @domain>",
+            "< @domain>",
+            "< @domain>",
+            [errors.ObsoleteHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+
+
+@parameterize
+class Test_parse_mime_parameters(TestParserMixin, TestEmailBase):
+
+    def mime_parameters_as_value(self,
+                                 value,
+                                 tl_str,
+                                 tl_value,
+                                 params,
+                                 defects):
+        mime_parameters = self._test_parse_x(parser.parse_mime_parameters,
+            value, tl_str, tl_value, defects)
+        self.assertEqual(mime_parameters.token_type, 'mime-parameters')
+        self.assertEqual(list(mime_parameters.params), params)
+
+
+    mime_parameters_params = {
+
+        'simple': (
+            'filename="abc.py"',
+            ' filename="abc.py"',
+            'filename=abc.py',
+            [('filename', 'abc.py')],
+            []),
+
+        'multiple_keys': (
+            'filename="abc.py"; xyz=abc',
+            ' filename="abc.py"; xyz="abc"',
+            'filename=abc.py; xyz=abc',
+            [('filename', 'abc.py'), ('xyz', 'abc')],
+            []),
+
+        'split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            [('filename', '201.tif')],
+            []),
+
+        # Note that it is undefined what we should do for error recovery when
+        # there are duplicate parameter names or duplicate parts in a split
+        # part.  We choose to ignore all duplicate parameters after the first
+        # and to take duplicate or missing rfc 2231 parts in appearance order.
+        # This is backward compatible with get_param's behavior, but the
+        # decisions are arbitrary.
+
+        'duplicate_key': (
+            'filename=abc.gif; filename=def.tiff',
+            ' filename="abc.gif"',
+            "filename=abc.gif; filename=def.tiff",
+            [('filename', 'abc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_key_with_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename=abc.gif",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename=abc.gif",
+            [('filename', '201.tif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_key_with_split_value_other_order': (
+            "filename=abc.gif; "
+                " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            ' filename="abc.gif"',
+            "filename=abc.gif;"
+                " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            [('filename', 'abc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_in_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename*1*=abc.gif",
+            ' filename="201.tifabc.gif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename*1*=abc.gif",
+            [('filename', '201.tifabc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'missing_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
+            [('filename', '201.tif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_and_missing_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
+                " filename*3*=abc.gif",
+            ' filename="201.tifabc.gif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
+                " filename*3*=abc.gif",
+            [('filename', '201.tifabc.gif')],
+            [errors.InvalidHeaderDefect]*2),
+
+        # Here we depart from get_param and assume the *0* was missing.
+        'duplicate_with_broken_split_value': (
+            "filename=abc.gif; "
+                " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
+            ' filename="abc.gif201.tif"',
+            "filename=abc.gif;"
+                " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
+            [('filename', 'abc.gif201.tif')],
+            # Defects are apparent missing *0*, and two 'out of sequence'.
+            [errors.InvalidHeaderDefect]*3),
+
+        # bpo-37461: Check that we don't go into an infinite loop.
+        'extra_dquote': (
+            'r*="\'a\'\\"',
+            ' r="\\""',
+            'r*=\'a\'"',
+            [('r', '"')],
+            [errors.InvalidHeaderDefect]*2),
+    }
+
+@parameterize
+class Test_parse_mime_version(TestParserMixin, TestEmailBase):
+
+    def mime_version_as_value(self,
+                              value,
+                              tl_str,
+                              tl_value,
+                              major,
+                              minor,
+                              defects):
+        mime_version = self._test_parse_x(parser.parse_mime_version,
+            value, tl_str, tl_value, defects)
+        self.assertEqual(mime_version.major, major)
+        self.assertEqual(mime_version.minor, minor)
+
+    mime_version_params = {
+
+        'rfc_2045_1': (
+            '1.0',
+            '1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_2': (
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 ',
+            1,
+            0,
+            []),
+
+        'RFC_2045_3': (
+            '(produced by MetaSend Vx.x) 1.0',
+            '(produced by MetaSend Vx.x) 1.0',
+            ' 1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_4': (
+            '1.(produced by MetaSend Vx.x)0',
+            '1.(produced by MetaSend Vx.x)0',
+            '1. 0',
+            1,
+            0,
+            []),
+
+        'empty': (
+            '',
+            '',
+            '',
+            None,
+            None,
+            [errors.HeaderMissingRequiredValue]),
+
+        }
+
+
+
+class TestFolding(TestEmailBase):
+
+    policy = policy.default
+
+    def _test(self, tl, folded, policy=policy):
+        self.assertEqual(tl.fold(policy=policy), folded, tl.ppstr())
+
+    def test_simple_unstructured_no_folds(self):
+        self._test(parser.get_unstructured("This is a test"),
+                   "This is a test\n")
+
+    def test_simple_unstructured_folded(self):
+        self._test(parser.get_unstructured("This is also a test, but this "
+                        "time there are enough words (and even some "
+                        "symbols) to make it wrap; at least in theory."),
+                   "This is also a test, but this time there are enough "
+                        "words (and even some\n"
+                   " symbols) to make it wrap; at least in theory.\n")
+
+    def test_unstructured_with_unicode_no_folds(self):
+        self._test(parser.get_unstructured("hübsch kleiner beißt"),
+                   "=?utf-8?q?h=C3=BCbsch_kleiner_bei=C3=9Ft?=\n")
+
+    def test_one_ew_on_each_of_two_wrapped_lines(self):
+        self._test(parser.get_unstructured("Mein kleiner Kaktus ist sehr "
+                                           "hübsch.  Es hat viele Stacheln "
+                                           "und oft beißt mich."),
+                   "Mein kleiner Kaktus ist sehr =?utf-8?q?h=C3=BCbsch=2E?=  "
+                        "Es hat viele Stacheln\n"
+                   " und oft =?utf-8?q?bei=C3=9Ft?= mich.\n")
+
+    def test_ews_combined_before_wrap(self):
+        self._test(parser.get_unstructured("Mein Kaktus ist hübsch.  "
+                                           "Es beißt mich.  "
+                                           "And that's all I'm sayin."),
+                   "Mein Kaktus ist =?utf-8?q?h=C3=BCbsch=2E__Es_bei=C3=9Ft?= "
+                        "mich.  And that's\n"
+                   " all I'm sayin.\n")
+
+    def test_unicode_after_unknown_not_combined(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=\xa4"),
+                   "=?unknown-8bit?q?=A4?==?utf-8?q?=C2=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=\xa4"),
+                   prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?=C2=A4?=\n")
+
+    def test_ascii_after_unknown_not_combined(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=abc"),
+                   "=?unknown-8bit?q?=A4?=abc\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=abc"),
+                   prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?abc?=\n")
+
+    def test_unknown_after_unicode_not_combined(self):
+        self._test(parser.get_unstructured("\xa4"
+                                           "=?unknown-8bit?q?=A4?="),
+                   "=?utf-8?q?=C2=A4?==?unknown-8bit?q?=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "\xa4=?unknown-8bit?q?=A4?="),
+                   prefix + "=?utf-8?q?=C2=A4?=\n =?unknown-8bit?q?=A4?=\n")
+
+    def test_unknown_after_ascii_not_combined(self):
+        self._test(parser.get_unstructured("abc"
+                                           "=?unknown-8bit?q?=A4?="),
+                   "abc=?unknown-8bit?q?=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "abcd=?unknown-8bit?q?=A4?="),
+                   prefix + "abcd\n =?unknown-8bit?q?=A4?=\n")
+
+    def test_unknown_after_unknown(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=C2?="
+                                           "=?unknown-8bit?q?=A4?="),
+                   "=?unknown-8bit?q?=C2=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=C2?="
+                                           "=?unknown-8bit?q?=A4?="),
+                   prefix + "=?unknown-8bit?q?=C2?=\n =?unknown-8bit?q?=A4?=\n")
+
+    # XXX Need test of an encoded word so long that it needs to be wrapped
+
+    def test_simple_address(self):
+        self._test(parser.get_address_list("abc <xyz@example.com>")[0],
+                   "abc <xyz@example.com>\n")
+
+    def test_address_list_folding_at_commas(self):
+        self._test(parser.get_address_list('abc <xyz@example.com>, '
+                                            '"Fred Blunt" <sharp@example.com>, '
+                                            '"J.P.Cool" <hot@example.com>, '
+                                            '"K<>y" <key@example.com>, '
+                                            'Firesale <cheap@example.com>, '
+                                            '<end@example.com>')[0],
+                    'abc <xyz@example.com>, "Fred Blunt" <sharp@example.com>,\n'
+                    ' "J.P.Cool" <hot@example.com>, "K<>y" <key@example.com>,\n'
+                    ' Firesale <cheap@example.com>, <end@example.com>\n')
+
+    def test_address_list_with_unicode_names(self):
+        self._test(parser.get_address_list(
+            'Hübsch Kaktus <beautiful@example.com>, '
+                'beißt beißt <biter@example.com>')[0],
+            '=?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>,\n'
+                ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <biter@example.com>\n')
+
+    def test_address_list_with_unicode_names_in_quotes(self):
+        self._test(parser.get_address_list(
+            '"Hübsch Kaktus" <beautiful@example.com>, '
+                '"beißt" beißt <biter@example.com>')[0],
+            '=?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>,\n'
+                ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <biter@example.com>\n')
+
+    def test_address_list_with_specials_in_encoded_word(self):
+        # An encoded-word parsed from a structured header must remain
+        # encoded when it contains specials. Regression for gh-121284.
+        policy = self.policy.clone(max_line_length=40)
+        cases = [
+            # (to, folded)
+            ('=?utf-8?q?A_v=C3=A9ry_long_name_with=2C_comma?= <to@example.com>',
+             'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
+             ' =?utf-8?q?=2C?= comma <to@example.com>\n'),
+            ('=?utf-8?q?This_long_name_does_not_need_encoded=2Dword?= <to@example.com>',
+             'This long name does not need\n'
+             ' encoded-word <to@example.com>\n'),
+            ('"A véry long name with, comma" <to@example.com>',
+             # (This isn't the best fold point, but it's not invalid.)
+             'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
+             ' =?utf-8?q?=2C?= comma <to@example.com>\n'),
+            ('"A véry long name containing a, comma" <to@example.com>',
+             'A =?utf-8?q?v=C3=A9ry?= long name\n'
+             ' containing =?utf-8?q?a=2C?= comma\n'
+             ' <to@example.com>\n'),
+        ]
+        for (to, folded) in cases:
+            with self.subTest(to=to):
+                self._test(parser.get_address_list(to)[0], folded, policy=policy)
+
+    def test_address_list_with_list_separator_after_fold(self):
+        a = 'x' * 66 + '@example.com'
+        to = f'{a}, "Hübsch Kaktus" <beautiful@example.com>'
+        self._test(parser.get_address_list(to)[0],
+            f'{a},\n =?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>\n')
+
+        a = '.' * 79  # ('.' is a special, so must be in quoted-string.)
+        to = f'"{a}" <xyz@example.com>, "Hübsch Kaktus" <beautiful@example.com>'
+        self._test(parser.get_address_list(to)[0],
+            f'"{a}"\n'
+            ' <xyz@example.com>, =?utf-8?q?H=C3=BCbsch?= Kaktus '
+            '<beautiful@example.com>\n')
+
+    def test_address_list_with_specials_in_long_quoted_string(self):
+        # Regression for gh-80222.
+        policy = self.policy.clone(max_line_length=40)
+        cases = [
+            # (to, folded)
+            ('"Exfiltrator <spy@example.org> (unclosed comment?" <to@example.com>',
+             '"Exfiltrator <spy@example.org> (unclosed\n'
+             ' comment?" <to@example.com>\n'),
+            ('"Escaped \\" chars \\\\ in quoted-string stay escaped" <to@example.com>',
+             '"Escaped \\" chars \\\\ in quoted-string\n'
+             ' stay escaped" <to@example.com>\n'),
+            ('This long display name does not need quotes <to@example.com>',
+             'This long display name does not need\n'
+             ' quotes <to@example.com>\n'),
+            ('"Quotes are not required but are retained here" <to@example.com>',
+             '"Quotes are not required but are\n'
+             ' retained here" <to@example.com>\n'),
+            ('"A quoted-string, it can be a valid local-part"@example.com',
+             '"A quoted-string, it can be a valid\n'
+             ' local-part"@example.com\n'),
+            ('"local-part-with-specials@but-no-fws.cannot-fold"@example.com',
+             '"local-part-with-specials@but-no-fws.cannot-fold"@example.com\n'),
+        ]
+        for (to, folded) in cases:
+            with self.subTest(to=to):
+                self._test(parser.get_address_list(to)[0], folded, policy=policy)
+
+    # XXX Need tests with comments on various sides of a unicode token,
+    # and with unicode tokens in the comments.  Spaces inside the quotes
+    # currently don't do the right thing.
+
+    def test_split_at_whitespace_after_header_before_long_token(self):
+        body = parser.get_unstructured('   ' + 'x'*77)
+        header = parser.Header([
+            parser.HeaderLabel([parser.ValueTerminal('test:', 'atext')]),
+            parser.CFWSList([parser.WhiteSpaceTerminal(' ', 'fws')]), body])
+        self._test(header, 'test:   \n ' + 'x'*77 + '\n')
+
+    def test_split_at_whitespace_before_long_token(self):
+        self._test(parser.get_unstructured('xxx   ' + 'y'*77),
+                   'xxx  \n ' + 'y'*77 + '\n')
+
+    def test_overlong_encodeable_is_wrapped(self):
+        first_token_with_whitespace = 'xxx   '
+        chrome_leader = '=?utf-8?q?'
+        len_chrome = len(chrome_leader) + 2
+        len_non_y = len_chrome + len(first_token_with_whitespace)
+        self._test(parser.get_unstructured(first_token_with_whitespace +
+                                           'y'*80),
+                   first_token_with_whitespace + chrome_leader +
+                       'y'*(78-len_non_y) + '?=\n' +
+                       ' ' + chrome_leader + 'y'*(80-(78-len_non_y)) + '?=\n')
+
+    def test_long_filename_attachment(self):
+        self._test(parser.parse_content_disposition_header(
+            'attachment; filename="TEST_TEST_TEST_TEST'
+                '_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TES.txt"'),
+            "attachment;\n"
+            " filename*0*=us-ascii''TEST_TEST_TEST_TEST_TEST_TEST"
+                "_TEST_TEST_TEST_TEST_TEST;\n"
+            " filename*1*=_TEST_TES.txt\n",
+            )
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_asian_codecs.py b/Lib/test/test_email/test_asian_codecs.py
new file mode 100644
index 00000000000..1e0caeeaed0
--- /dev/null
+++ b/Lib/test/test_email/test_asian_codecs.py
@@ -0,0 +1,81 @@
+# Copyright (C) 2002-2006 Python Software Foundation
+# Contact: email-sig@python.org
+# email package unit tests for (optional) Asian codecs
+
+import unittest
+
+from test.test_email import TestEmailBase
+from email.charset import Charset
+from email.header import Header, decode_header
+from email.message import Message
+
+# We're compatible with Python 2.3, but it doesn't have the built-in Asian
+# codecs, so we have to skip all these tests.
+try:
+    str(b'foo', 'euc-jp')
+except LookupError:
+    raise unittest.SkipTest
+
+
+
+class TestEmailAsianCodecs(TestEmailBase):
+    def test_japanese_codecs(self):
+        eq = self.ndiffAssertEqual
+        jcode = "euc-jp"
+        gcode = "iso-8859-1"
+        j = Charset(jcode)
+        g = Charset(gcode)
+        h = Header("Hello World!")
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', jcode)
+        ghello = str(b'Gr\xfc\xdf Gott!', gcode)
+        h.append(jhello, j)
+        h.append(ghello, g)
+        # BAW: This used to -- and maybe should -- fold the two iso-8859-1
+        # chunks into a single encoded word.  However it doesn't violate the
+        # standard to have them as two encoded chunks and maybe it's
+        # reasonable <wink> for each .append() call to result in a separate
+        # encoded word.
+        eq(h.encode(), """\
+Hello World! =?iso-2022-jp?b?GyRCJU8lbSE8JW8hPCVrJUkhKhsoQg==?=
+ =?iso-8859-1?q?Gr=FC=DF_Gott!?=""")
+        eq(decode_header(h.encode()),
+           [(b'Hello World! ', None),
+            (b'\x1b$B%O%m!<%o!<%k%I!*\x1b(B', 'iso-2022-jp'),
+            (b'Gr\xfc\xdf Gott!', gcode)])
+        subject_bytes = (b'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5'
+            b'\xa4\xec\xa4\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2'
+            b'\xf1\xbc\xd4\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3'
+            b'\xa4\xc6\xa4\xa4\xa4\xde\xa4\xb9')
+        subject = str(subject_bytes, jcode)
+        h = Header(subject, j, header_name="Subject")
+        # test a very long header
+        enc = h.encode()
+        # TK: splitting point may differ by codec design and/or Header encoding
+        eq(enc , """\
+=?iso-2022-jp?b?dGVzdC1qYSAbJEIkWEVqOUYkNSRsJD8lYSE8JWskTztKGyhC?=
+ =?iso-2022-jp?b?GyRCMnE8VCROPjVHJyRyQlQkQyRGJCQkXiQ5GyhC?=""")
+        # TK: full decode comparison
+        eq(str(h).encode(jcode), subject_bytes)
+
+    def test_payload_encoding_utf8(self):
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', 'euc-jp')
+        msg = Message()
+        msg.set_payload(jhello, 'utf-8')
+        ustr = msg.get_payload(decode=True).decode(msg.get_content_charset())
+        self.assertEqual(jhello, ustr)
+
+    def test_payload_encoding(self):
+        jcode  = 'euc-jp'
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', jcode)
+        msg = Message()
+        msg.set_payload(jhello, jcode)
+        ustr = msg.get_payload(decode=True).decode(msg.get_content_charset())
+        self.assertEqual(jhello, ustr)
+
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_contentmanager.py b/Lib/test/test_email/test_contentmanager.py
new file mode 100644
index 00000000000..dceb54f15e4
--- /dev/null
+++ b/Lib/test/test_email/test_contentmanager.py
@@ -0,0 +1,836 @@
+import unittest
+from test.test_email import TestEmailBase, parameterize
+import textwrap
+from email import policy
+from email.message import EmailMessage
+from email.contentmanager import ContentManager, raw_data_manager
+
+
+@parameterize
+class TestContentManager(TestEmailBase):
+
+    policy = policy.default
+    message = EmailMessage
+
+    get_key_params = {
+        'full_type':        (1, 'text/plain',),
+        'maintype_only':    (2, 'text',),
+        'null_key':         (3, '',),
+        }
+
+    def get_key_as_get_content_key(self, order, key):
+        def foo_getter(msg, foo=None):
+            bar = msg['X-Bar-Header']
+            return foo, bar
+        cm = ContentManager()
+        cm.add_get_handler(key, foo_getter)
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        m['X-Bar-Header'] = 'foo'
+        self.assertEqual(cm.get_content(m, foo='bar'), ('bar', 'foo'))
+
+    def get_key_as_get_content_key_order(self, order, key):
+        def bar_getter(msg):
+            return msg['X-Bar-Header']
+        def foo_getter(msg):
+            return msg['X-Foo-Header']
+        cm = ContentManager()
+        cm.add_get_handler(key, foo_getter)
+        for precedence, key in self.get_key_params.values():
+            if precedence > order:
+                cm.add_get_handler(key, bar_getter)
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        m['X-Bar-Header'] = 'bar'
+        m['X-Foo-Header'] = 'foo'
+        self.assertEqual(cm.get_content(m), ('foo'))
+
+    def test_get_content_raises_if_unknown_mimetype_and_no_default(self):
+        cm = ContentManager()
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        with self.assertRaisesRegex(KeyError, 'text/plain'):
+            cm.get_content(m)
+
+    class BaseThing(str):
+        pass
+    baseobject_full_path = __name__ + '.' + 'TestContentManager.BaseThing'
+    class Thing(BaseThing):
+        pass
+    testobject_full_path = __name__ + '.' + 'TestContentManager.Thing'
+
+    set_key_params = {
+        'type':             (0,  Thing,),
+        'full_path':        (1,  testobject_full_path,),
+        'qualname':         (2,  'TestContentManager.Thing',),
+        'name':             (3,  'Thing',),
+        'base_type':        (4,  BaseThing,),
+        'base_full_path':   (5,  baseobject_full_path,),
+        'base_qualname':    (6,  'TestContentManager.BaseThing',),
+        'base_name':        (7,  'BaseThing',),
+        'str_type':         (8,  str,),
+        'str_full_path':    (9,  'builtins.str',),
+        'str_name':         (10, 'str',),   # str name and qualname are the same
+        'null_key':         (11, None,),
+        }
+
+    def set_key_as_set_content_key(self, order, key):
+        def foo_setter(msg, obj, foo=None):
+            msg['X-Foo-Header'] = foo
+            msg.set_payload(obj)
+        cm = ContentManager()
+        cm.add_set_handler(key, foo_setter)
+        m = self._make_message()
+        msg_obj = self.Thing()
+        cm.set_content(m, msg_obj, foo='bar')
+        self.assertEqual(m['X-Foo-Header'], 'bar')
+        self.assertEqual(m.get_payload(), msg_obj)
+
+    def set_key_as_set_content_key_order(self, order, key):
+        def foo_setter(msg, obj):
+            msg['X-FooBar-Header'] = 'foo'
+            msg.set_payload(obj)
+        def bar_setter(msg, obj):
+            msg['X-FooBar-Header'] = 'bar'
+        cm = ContentManager()
+        cm.add_set_handler(key, foo_setter)
+        for precedence, key in self.get_key_params.values():
+            if precedence > order:
+                cm.add_set_handler(key, bar_setter)
+        m = self._make_message()
+        msg_obj = self.Thing()
+        cm.set_content(m, msg_obj)
+        self.assertEqual(m['X-FooBar-Header'], 'foo')
+        self.assertEqual(m.get_payload(), msg_obj)
+
+    def test_set_content_raises_if_unknown_type_and_no_default(self):
+        cm = ContentManager()
+        m = self._make_message()
+        msg_obj = self.Thing()
+        with self.assertRaisesRegex(KeyError, self.testobject_full_path):
+            cm.set_content(m, msg_obj)
+
+    def test_set_content_raises_if_called_on_multipart(self):
+        cm = ContentManager()
+        m = self._make_message()
+        m['Content-Type'] = 'multipart/foo'
+        with self.assertRaises(TypeError):
+            cm.set_content(m, 'test')
+
+    def test_set_content_calls_clear_content(self):
+        m = self._make_message()
+        m['Content-Foo'] = 'bar'
+        m['Content-Type'] = 'text/html'
+        m['To'] = 'test'
+        m.set_payload('abc')
+        cm = ContentManager()
+        cm.add_set_handler(str, lambda *args, **kw: None)
+        m.set_content('xyz', content_manager=cm)
+        self.assertIsNone(m['Content-Foo'])
+        self.assertIsNone(m['Content-Type'])
+        self.assertEqual(m['To'], 'test')
+        self.assertIsNone(m.get_payload())
+
+
+@parameterize
+class TestRawDataManager(TestEmailBase):
+    # Note: these tests are dependent on the order in which headers are added
+    # to the message objects by the code.  There's no defined ordering in
+    # RFC5322/MIME, so this makes the tests more fragile than the standards
+    # require.  However, if the header order changes it is best to understand
+    # *why*, and make sure it isn't a subtle bug in whatever change was
+    # applied.
+
+    policy = policy.default.clone(max_line_length=60,
+                                  content_manager=raw_data_manager)
+    message = EmailMessage
+
+    def test_get_text_plain(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain
+
+            Basic text.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basic text.\n")
+
+    def test_get_text_html(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/html
+
+            <p>Basic text.</p>
+            """))
+        self.assertEqual(raw_data_manager.get_content(m),
+                         "<p>Basic text.</p>\n")
+
+    def test_get_text_plain_latin1(self):
+        m = self._bytes_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset=latin1
+
+            Basìc tëxt.
+            """).encode('latin1'))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_latin1_quoted_printable(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="latin-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=ECc t=EBxt.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_utf8_base64(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: base64
+
+            QmFzw6xjIHTDq3h0Lgo=
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_bad_utf8_quoted_printable(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=c3=acc t=c3=abxt=fd.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt�.\n")
+
+    def test_get_text_plain_bad_utf8_quoted_printable_ignore_errors(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=c3=acc t=c3=abxt=fd.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m, errors='ignore'),
+                         "Basìc tëxt.\n")
+
+    def test_get_text_plain_utf8_base64_recoverable_bad_CTE_data(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: base64
+
+            QmFzw6xjIHTDq3h0Lgo\xFF=
+            """))
+        self.assertEqual(raw_data_manager.get_content(m, errors='ignore'),
+                         "Basìc tëxt.\n")
+
+    def test_get_text_invalid_keyword(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain
+
+            Basic text.
+            """))
+        with self.assertRaises(TypeError):
+            raw_data_manager.get_content(m, foo='ignore')
+
+    def test_get_non_text(self):
+        template = textwrap.dedent("""\
+            Content-Type: {}
+            Content-Transfer-Encoding: base64
+
+            Ym9ndXMgZGF0YQ==
+            """)
+        for maintype in 'audio image video application'.split():
+            with self.subTest(maintype=maintype):
+                m = self._str_msg(template.format(maintype+'/foo'))
+                self.assertEqual(raw_data_manager.get_content(m), b"bogus data")
+
+    def test_get_non_text_invalid_keyword(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: image/jpg
+            Content-Transfer-Encoding: base64
+
+            Ym9ndXMgZGF0YQ==
+            """))
+        with self.assertRaises(TypeError):
+            raw_data_manager.get_content(m, errors='ignore')
+
+    def test_get_raises_on_multipart(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: multipart/mixed; boundary="==="
+
+            --===
+            --===--
+            """))
+        with self.assertRaises(KeyError):
+            raw_data_manager.get_content(m)
+
+    def test_get_message_rfc822_and_external_body(self):
+        template = textwrap.dedent("""\
+            Content-Type: message/{}
+
+            To: foo@example.com
+            From: bar@example.com
+            Subject: example
+
+            an example message
+            """)
+        for subtype in 'rfc822 external-body'.split():
+            with self.subTest(subtype=subtype):
+                m = self._str_msg(template.format(subtype))
+                sub_msg = raw_data_manager.get_content(m)
+                self.assertIsInstance(sub_msg, self.message)
+                self.assertEqual(raw_data_manager.get_content(sub_msg),
+                                 "an example message\n")
+                self.assertEqual(sub_msg['to'], 'foo@example.com')
+                self.assertEqual(sub_msg['from'].addresses[0].username, 'bar')
+
+    def test_get_message_non_rfc822_or_external_body_yields_bytes(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: message/partial
+
+            To: foo@example.com
+            From: bar@example.com
+            Subject: example
+
+            The real body is in another message.
+            """))
+        self.assertStartsWith(raw_data_manager.get_content(m), b'To: foo@ex')
+
+    def test_set_text_plain(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_plain_null(self):
+        m = self._make_message()
+        content = ''
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), '\n')
+        self.assertEqual(m.get_content(), '\n')
+
+    def test_set_text_html(self):
+        m = self._make_message()
+        content = "<p>Simple message.</p>\n"
+        raw_data_manager.set_content(m, content, subtype='html')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/html; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+            <p>Simple message.</p>
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_charset_latin_1(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content, charset='latin-1')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_plain_long_line_heuristics(self):
+        m = self._make_message()
+        content = ("Simple but long message that is over 78 characters"
+                   " long to force transfer encoding.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Simple but long message that is over 78 characters long to =
+            force transfer encoding.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_short_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = "et là il est monté sur moi et il commence à m'éto.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            et là il est monté sur moi et il commence à m'éto.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_long_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = ("j'ai un problème de python. il est sorti de son"
+                   " vivarium.  et là il est monté sur moi et il commence"
+                   " à m'éto.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+
+            j'ai un probl=C3=A8me de python. il est sorti de son vivari=
+            um.  et l=C3=A0 il est mont=C3=A9 sur moi et il commence =
+            =C3=A0 m'=C3=A9to.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_long_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = '\n'*10 + (
+                  "j'ai un problème de python. il est sorti de son"
+                  " vivarium.  et là il est monté sur moi et il commence"
+                  " à m'éto.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+            """ + '\n'*10 + """
+            j'ai un probl=C3=A8me de python. il est sorti de son vivari=
+            um.  et l=C3=A0 il est mont=C3=A9 sur moi et il commence =
+            =C3=A0 m'=C3=A9to.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = "áàäéèęöő.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            áàäéèęöő.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = '\n'*10 + "áàäéèęöő.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            """ + '\n'*10 + """
+            áàäéèęöő.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_long_line_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = ("áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            w6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TDqcOoxJnD
+            tsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TDqcOo
+            xJnDtsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TD
+            qcOoxJnDtsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOg
+            w6TDqcOoxJnDtsWRLgo=
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_long_line_maximal_non_ascii_heuristics(self):
+        # Yes, it chooses "wrong" here.  It's a heuristic.  So this result
+        # could change if we come up with a better heuristic.
+        m = self._make_message()
+        content = ('\n'*10 +
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        raw_data_manager.set_content(m, "\n"*10 +
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+            """ + '\n'*10 + """
+            =C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=
+            =A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=
+            =C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=
+            =A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=
+            =C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=
+            =91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=
+            =C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=
+            =A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=
+            =C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=
+            =99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=
+            =C5=91.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_non_ascii_with_cte_7bit_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", cte='7bit')
+
+    def test_set_text_non_ascii_with_charset_ascii_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", charset='ascii')
+
+    def test_set_text_non_ascii_with_cte_7bit_and_charset_ascii_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", cte='7bit', charset='ascii')
+
+    def test_set_message(self):
+        m = self._make_message()
+        m['Subject'] = "Forwarded message"
+        content = self._make_message()
+        content['To'] = 'python@vivarium.org'
+        content['From'] = 'police@monty.org'
+        content['Subject'] = "get back in your box"
+        content.set_content("Or face the comfy chair.")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Subject: Forwarded message
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: python@vivarium.org
+            From: police@monty.org
+            Subject: get back in your box
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            Or face the comfy chair.
+            """))
+        payload = m.get_payload(0)
+        self.assertIsInstance(payload, self.message)
+        self.assertEqual(str(payload), str(content))
+        self.assertIsInstance(m.get_content(), self.message)
+        self.assertEqual(str(m.get_content()), str(content))
+
+    def test_set_message_with_non_ascii_and_coercion_to_7bit(self):
+        m = self._make_message()
+        m['Subject'] = "Escape report"
+        content = self._make_message()
+        content['To'] = 'police@monty.org'
+        content['From'] = 'victim@monty.org'
+        content['Subject'] = "Help"
+        content.set_content("j'ai un problème de python. il est sorti de son"
+                            " vivarium.")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Subject: Escape report
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: police@monty.org
+            From: victim@monty.org
+            Subject: Help
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            j'ai un problème de python. il est sorti de son vivarium.
+            """).encode('utf-8'))
+        # The choice of base64 for the body encoding is because generator
+        # doesn't bother with heuristics and uses it unconditionally for utf-8
+        # text.
+        # XXX: the first cte should be 7bit, too...that's a generator bug.
+        # XXX: the line length in the body also looks like a generator bug.
+        self.assertEqual(m.as_string(maxheaderlen=self.policy.max_line_length),
+                         textwrap.dedent("""\
+            Subject: Escape report
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: police@monty.org
+            From: victim@monty.org
+            Subject: Help
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+            MIME-Version: 1.0
+
+            aidhaSB1biBwcm9ibMOobWUgZGUgcHl0aG9uLiBpbCBlc3Qgc29ydGkgZGUgc29uIHZpdmFyaXVt
+            Lgo=
+            """))
+        self.assertIsInstance(m.get_content(), self.message)
+        self.assertEqual(str(m.get_content()), str(content))
+
+    def test_set_message_invalid_cte_raises(self):
+        m = self._make_message()
+        content = self._make_message()
+        for cte in 'quoted-printable base64'.split():
+            for subtype in 'rfc822 external-body'.split():
+                with self.subTest(cte=cte, subtype=subtype):
+                    with self.assertRaises(ValueError) as ar:
+                        m.set_content(content, subtype, cte=cte)
+                    exc = str(ar.exception)
+                    self.assertIn(cte, exc)
+                    self.assertIn(subtype, exc)
+        subtype = 'external-body'
+        for cte in '8bit binary'.split():
+            with self.subTest(cte=cte, subtype=subtype):
+                with self.assertRaises(ValueError) as ar:
+                    m.set_content(content, subtype, cte=cte)
+                exc = str(ar.exception)
+                self.assertIn(cte, exc)
+                self.assertIn(subtype, exc)
+
+    def test_set_image_jpg(self):
+        for content in (b"bogus content",
+                        bytearray(b"bogus content"),
+                        memoryview(b"bogus content")):
+            with self.subTest(content=content):
+                m = self._make_message()
+                raw_data_manager.set_content(m, content, 'image', 'jpeg')
+                self.assertEqual(str(m), textwrap.dedent("""\
+                    Content-Type: image/jpeg
+                    Content-Transfer-Encoding: base64
+
+                    Ym9ndXMgY29udGVudA==
+                    """))
+                self.assertEqual(m.get_payload(decode=True), content)
+                self.assertEqual(m.get_content(), content)
+
+    def test_set_audio_aif_with_quoted_printable_cte(self):
+        # Why you would use qp, I don't know, but it is technically supported.
+        # XXX: the incorrect line length is because binascii.b2a_qp doesn't
+        # support a line length parameter, but we must use it to get newline
+        # encoding.
+        # XXX: what about that lack of tailing newline?  Do we actually handle
+        # that correctly in all cases?  That is, if the *source* has an
+        # unencoded newline, do we add an extra newline to the returned payload
+        # or not?  And can that actually be disambiguated based on the RFC?
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent ' + b'z'*100
+        m.set_content(content, 'audio', 'aif', cte='quoted-printable')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: audio/aif
+            Content-Transfer-Encoding: quoted-printable
+            MIME-Version: 1.0
+
+            b=FFgus=09con=0At=0Dent=20zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=
+            zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz""").encode('latin-1'))
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_video_mpeg_with_binary_cte(self):
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent ' + b'z'*100
+        m.set_content(content, 'video', 'mpeg', cte='binary')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: video/mpeg
+            Content-Transfer-Encoding: binary
+            MIME-Version: 1.0
+
+            """).encode('ascii') +
+            # XXX: the second \n ought to be a \r, but generator gets it wrong.
+            # THIS MEANS WE DON'T ACTUALLY SUPPORT THE 'binary' CTE.
+            b'b\xFFgus\tcon\nt\nent zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz' +
+            b'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz')
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_application_octet_stream_with_8bit_cte(self):
+        # In 8bit mode, universal line end logic applies.  It is up to the
+        # application to make sure the lines are short enough; we don't check.
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent\n' + b'z'*60 + b'\n'
+        m.set_content(content, 'application', 'octet-stream', cte='8bit')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: application/octet-stream
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            """).encode('ascii') +
+            b'b\xFFgus\tcon\nt\nent\n' +
+            b'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\n')
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_headers_from_header_objects(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        raw_data_manager.set_content(m, content, headers=(
+            header_factory("To", "foo@example.com"),
+            header_factory("From", "foo@example.com"),
+            header_factory("Subject", "I'm talking to myself.")))
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            To: foo@example.com
+            From: foo@example.com
+            Subject: I'm talking to myself.
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+
+    def test_set_headers_from_strings(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content, headers=(
+            "X-Foo-Header: foo",
+            "X-Bar-Header: bar",))
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            X-Foo-Header: foo
+            X-Bar-Header: bar
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+
+    def test_set_headers_with_invalid_duplicate_string_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        with self.assertRaisesRegex(ValueError, 'Content-Type'):
+            raw_data_manager.set_content(m, content, headers=(
+                "Content-Type: foo/bar",)
+                )
+
+    def test_set_headers_with_invalid_duplicate_header_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        with self.assertRaisesRegex(ValueError, 'Content-Type'):
+            raw_data_manager.set_content(m, content, headers=(
+                header_factory("Content-Type", " foo/bar"),)
+                )
+
+    def test_set_headers_with_defective_string_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        with self.assertRaisesRegex(ValueError, 'a@fairly@@invalid@address'):
+            raw_data_manager.set_content(m, content, headers=(
+                'To: a@fairly@@invalid@address',)
+                )
+            print(m['To'].defects)
+
+    def test_set_headers_with_defective_header_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        with self.assertRaisesRegex(ValueError, 'a@fairly@@invalid@address'):
+            raw_data_manager.set_content(m, content, headers=(
+                header_factory('To', 'a@fairly@@invalid@address'),)
+                )
+            print(m['To'].defects)
+
+    def test_set_disposition_inline(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='inline')
+        self.assertEqual(m['Content-Disposition'], 'inline')
+
+    def test_set_disposition_attachment(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='attachment')
+        self.assertEqual(m['Content-Disposition'], 'attachment')
+
+    def test_set_disposition_foo(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='foo')
+        self.assertEqual(m['Content-Disposition'], 'foo')
+
+    # XXX: we should have a 'strict' policy mode (beyond raise_on_defect) that
+    # would cause 'foo' above to raise.
+
+    def test_set_filename(self):
+        m = self._make_message()
+        m.set_content('foo', filename='bar.txt')
+        self.assertEqual(m['Content-Disposition'],
+                         'attachment; filename="bar.txt"')
+
+    def test_set_filename_and_disposition_inline(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='inline', filename='bar.txt')
+        self.assertEqual(m['Content-Disposition'], 'inline; filename="bar.txt"')
+
+    def test_set_non_ascii_filename(self):
+        m = self._make_message()
+        m.set_content('foo', filename='ábárî.txt')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            Content-Disposition: attachment;
+             filename*=utf-8''%C3%A1b%C3%A1r%C3%AE.txt
+            MIME-Version: 1.0
+
+            foo
+            """).encode('ascii'))
+
+    def test_set_content_bytes_cte_7bit(self):
+        m = self._make_message()
+        m.set_content(b'ASCII-only message.\n',
+            maintype='application', subtype='octet-stream', cte='7bit')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: application/octet-stream
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            ASCII-only message.
+            """))
+
+    content_object_params = {
+        'text_plain': ('content', ()),
+        'text_html': ('content', ('html',)),
+        'application_octet_stream': (b'content',
+                                     ('application', 'octet_stream')),
+        'image_jpeg': (b'content', ('image', 'jpeg')),
+        'message_rfc822': (message(), ()),
+        'message_external_body': (message(), ('external-body',)),
+        }
+
+    def content_object_as_header_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, headers=(
+            'To: foo@example.com',
+            'From: bar@simple.net'))
+        self.assertEqual(m['to'], 'foo@example.com')
+        self.assertEqual(m['from'], 'bar@simple.net')
+
+    def content_object_as_disposition_inline_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, disposition='inline')
+        self.assertEqual(m['Content-Disposition'], 'inline')
+
+    def content_object_as_non_ascii_filename_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, disposition='inline', filename='bár.txt')
+        self.assertEqual(m['Content-Disposition'], 'inline; filename="bár.txt"')
+        self.assertEqual(m.get_filename(), "bár.txt")
+        self.assertEqual(m['Content-Disposition'].params['filename'], "bár.txt")
+
+    def content_object_as_cid_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, cid='some_random_stuff')
+        self.assertEqual(m['Content-ID'], 'some_random_stuff')
+
+    def content_object_as_params_receiver(self, obj, mimetype):
+        m = self._make_message()
+        params = {'foo': 'bár', 'abc': 'xyz'}
+        m.set_content(obj, *mimetype, params=params)
+        if isinstance(obj, str):
+            params['charset'] = 'utf-8'
+        self.assertEqual(m['Content-Type'].params, params)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_defect_handling.py b/Lib/test/test_email/test_defect_handling.py
new file mode 100644
index 00000000000..44e76c8ce5e
--- /dev/null
+++ b/Lib/test/test_email/test_defect_handling.py
@@ -0,0 +1,337 @@
+import textwrap
+import unittest
+import contextlib
+from email import policy
+from email import errors
+from test.test_email import TestEmailBase
+
+
+class TestDefectsBase:
+
+    policy = policy.default
+    raise_expected = False
+
+    @contextlib.contextmanager
+    def _raise_point(self, defect):
+        yield
+
+    def test_same_boundary_inner_outer(self):
+        source = textwrap.dedent("""\
+            Subject: XX
+            From: xx@xx.dk
+            To: XX
+            Mime-version: 1.0
+            Content-type: multipart/mixed;
+               boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: multipart/alternative;
+               boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: text/plain; charset="ISO-8859-1"
+            Content-transfer-encoding: quoted-printable
+
+            text
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: text/html; charset="ISO-8859-1"
+            Content-transfer-encoding: quoted-printable
+
+            <HTML></HTML>
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part--
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: image/gif; name="xx.gif";
+            Content-disposition: attachment
+            Content-transfer-encoding: base64
+
+            Some removed base64 encoded chars.
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part--
+
+            """)
+        # XXX better would be to actually detect the duplicate.
+        with self._raise_point(errors.StartBoundaryNotFoundDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        inner = msg.get_payload(0)
+        self.assertHasAttr(inner, 'defects')
+        self.assertEqual(len(self.get_defects(inner)), 1)
+        self.assertIsInstance(self.get_defects(inner)[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    def test_multipart_no_boundary(self):
+        source = textwrap.dedent("""\
+            Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+            From: foobar
+            Subject: broken mail
+            MIME-Version: 1.0
+            Content-Type: multipart/report; report-type=delivery-status;
+
+            --JAB03225.986577786/zinfandel.lacita.com
+
+            One part
+
+            --JAB03225.986577786/zinfandel.lacita.com
+            Content-Type: message/delivery-status
+
+            Header: Another part
+
+            --JAB03225.986577786/zinfandel.lacita.com--
+            """)
+        with self._raise_point(errors.NoBoundaryInMultipartDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertEqual(len(self.get_defects(msg)), 2)
+        self.assertIsInstance(self.get_defects(msg)[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(self.get_defects(msg)[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    multipart_msg = textwrap.dedent("""\
+        Date: Wed, 14 Nov 2007 12:56:23 GMT
+        From: foo@bar.invalid
+        To: foo@bar.invalid
+        Subject: Content-Transfer-Encoding: base64 and multipart
+        MIME-Version: 1.0
+        Content-Type: multipart/mixed;
+            boundary="===============3344438784458119861=="{}
+
+        --===============3344438784458119861==
+        Content-Type: text/plain
+
+        Test message
+
+        --===============3344438784458119861==
+        Content-Type: application/octet-stream
+        Content-Transfer-Encoding: base64
+
+        YWJj
+
+        --===============3344438784458119861==--
+        """)
+
+    def test_multipart_invalid_cte(self):
+        with self._raise_point(
+                errors.InvalidMultipartContentTransferEncodingDefect):
+            msg = self._str_msg(
+                    self.multipart_msg.format(
+                        "\nContent-Transfer-Encoding: base64"))
+        if self.raise_expected: return
+        self.assertEqual(len(self.get_defects(msg)), 1)
+        self.assertIsInstance(self.get_defects(msg)[0],
+            errors.InvalidMultipartContentTransferEncodingDefect)
+
+    def test_multipart_no_cte_no_defect(self):
+        if self.raise_expected: return
+        msg = self._str_msg(self.multipart_msg.format(''))
+        self.assertEqual(len(self.get_defects(msg)), 0)
+
+    def test_multipart_valid_cte_no_defect(self):
+        if self.raise_expected: return
+        for cte in ('7bit', '8bit', 'BINary'):
+            msg = self._str_msg(
+                self.multipart_msg.format("\nContent-Transfer-Encoding: "+cte))
+            self.assertEqual(len(self.get_defects(msg)), 0, "cte="+cte)
+
+    def test_lying_multipart(self):
+        source = textwrap.dedent("""\
+            From: "Allison Dunlap" <xxx@example.com>
+            To: yyy@example.com
+            Subject: 64423
+            Date: Sun, 11 Jul 2004 16:09:27 -0300
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+
+            Blah blah blah
+            """)
+        with self._raise_point(errors.NoBoundaryInMultipartDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertHasAttr(msg, 'defects')
+        self.assertEqual(len(self.get_defects(msg)), 2)
+        self.assertIsInstance(self.get_defects(msg)[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(self.get_defects(msg)[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    def test_missing_start_boundary(self):
+        source = textwrap.dedent("""\
+            Content-Type: multipart/mixed; boundary="AAA"
+            From: Mail Delivery Subsystem <xxx@example.com>
+            To: yyy@example.com
+
+            --AAA
+
+            Stuff
+
+            --AAA
+            Content-Type: message/rfc822
+
+            From: webmaster@python.org
+            To: zzz@example.com
+            Content-Type: multipart/mixed; boundary="BBB"
+
+            --BBB--
+
+            --AAA--
+
+            """)
+        # The message structure is:
+        #
+        # multipart/mixed
+        #    text/plain
+        #    message/rfc822
+        #        multipart/mixed [*]
+        #
+        # [*] This message is missing its start boundary
+        with self._raise_point(errors.StartBoundaryNotFoundDefect):
+            outer = self._str_msg(source)
+        if self.raise_expected: return
+        bad = outer.get_payload(1).get_payload(0)
+        self.assertEqual(len(self.get_defects(bad)), 1)
+        self.assertIsInstance(self.get_defects(bad)[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    def test_first_line_is_continuation_header(self):
+        with self._raise_point(errors.FirstHeaderLineIsContinuationDefect):
+            msg = self._str_msg(' Line 1\nSubject: test\n\nbody')
+        if self.raise_expected: return
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'body')
+        self.assertEqual(len(self.get_defects(msg)), 1)
+        self.assertDefectsEqual(self.get_defects(msg),
+                                 [errors.FirstHeaderLineIsContinuationDefect])
+        self.assertEqual(self.get_defects(msg)[0].line, ' Line 1\n')
+
+    def test_missing_header_body_separator(self):
+        # Our heuristic if we see a line that doesn't look like a header (no
+        # leading whitespace but no ':') is to assume that the blank line that
+        # separates the header from the body is missing, and to stop parsing
+        # headers and start parsing the body.
+        with self._raise_point(errors.MissingHeaderBodySeparatorDefect):
+            msg = self._str_msg('Subject: test\nnot a header\nTo: abc\n\nb\n')
+        if self.raise_expected: return
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'not a header\nTo: abc\n\nb\n')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.MissingHeaderBodySeparatorDefect])
+
+    def test_bad_padding_in_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            dmk
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64PaddingDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'vi')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_chars_in_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            dm\x01k===
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64CharactersDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'vi')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64CharactersDefect])
+
+    def test_invalid_length_of_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            abcde
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64LengthDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'abcde')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64LengthDefect])
+
+    def test_missing_ending_boundary(self):
+        source = textwrap.dedent("""\
+            To: 1@harrydomain4.com
+            Subject: Fwd: 1
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+             boundary="------------000101020201080900040301"
+
+            --------------000101020201080900040301
+            Content-Type: text/plain; charset=ISO-8859-1
+            Content-Transfer-Encoding: 7bit
+
+            Alternative 1
+
+            --------------000101020201080900040301
+            Content-Type: text/html; charset=ISO-8859-1
+            Content-Transfer-Encoding: 7bit
+
+            Alternative 2
+
+            """)
+        with self._raise_point(errors.CloseBoundaryNotFoundDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertEqual(len(msg.get_payload()), 2)
+        self.assertEqual(msg.get_payload(1).get_payload(), 'Alternative 2\n')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.CloseBoundaryNotFoundDefect])
+
+
+class TestDefectDetection(TestDefectsBase, TestEmailBase):
+
+    def get_defects(self, obj):
+        return obj.defects
+
+
+class TestDefectCapture(TestDefectsBase, TestEmailBase):
+
+    class CapturePolicy(policy.EmailPolicy):
+        captured = None
+        def register_defect(self, obj, defect):
+            self.captured.append(defect)
+
+    def setUp(self):
+        self.policy = self.CapturePolicy(captured=list())
+
+    def get_defects(self, obj):
+        return self.policy.captured
+
+
+class TestDefectRaising(TestDefectsBase, TestEmailBase):
+
+    policy = TestDefectsBase.policy
+    policy = policy.clone(raise_on_defect=True)
+    raise_expected = True
+
+    @contextlib.contextmanager
+    def _raise_point(self, defect):
+        with self.assertRaises(defect):
+            yield
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_email.py b/Lib/test/test_email/test_email.py
new file mode 100644
index 00000000000..2d843c7d723
--- /dev/null
+++ b/Lib/test/test_email/test_email.py
@@ -0,0 +1,5907 @@
+# Copyright (C) 2001-2010 Python Software Foundation
+# Contact: email-sig@python.org
+# email package unit tests
+
+import re
+import time
+import base64
+import unittest
+import textwrap
+
+from io import StringIO, BytesIO
+from itertools import chain
+from random import choice
+from threading import Thread
+from unittest.mock import patch
+
+import email
+import email.policy
+import email.utils
+
+from email.charset import Charset
+from email.generator import Generator, DecodedGenerator, BytesGenerator
+from email.header import Header, decode_header, make_header
+from email.headerregistry import HeaderRegistry
+from email.message import Message
+from email.mime.application import MIMEApplication
+from email.mime.audio import MIMEAudio
+from email.mime.base import MIMEBase
+from email.mime.image import MIMEImage
+from email.mime.message import MIMEMessage
+from email.mime.multipart import MIMEMultipart
+from email.mime.nonmultipart import MIMENonMultipart
+from email.mime.text import MIMEText
+from email.parser import Parser, HeaderParser
+from email import base64mime
+from email import encoders
+from email import errors
+from email import iterators
+from email import quoprimime
+from email import utils
+
+from test import support
+from test.support import threading_helper
+from test.support.os_helper import unlink
+from test.test_email import openfile, TestEmailBase
+
+# These imports are documented to work, but we are testing them using a
+# different path, so we import them here just to make sure they are importable.
+from email.parser import FeedParser
+
+NL = '\n'
+EMPTYSTRING = ''
+SPACE = ' '
+
+
+# Test various aspects of the Message class's API
+class TestMessageAPI(TestEmailBase):
+    def test_get_all(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_20.txt')
+        eq(msg.get_all('cc'), ['ccc@zzz.org', 'ddd@zzz.org', 'eee@zzz.org'])
+        eq(msg.get_all('xx', 'n/a'), 'n/a')
+
+    def test_getset_charset(self):
+        eq = self.assertEqual
+        msg = Message()
+        eq(msg.get_charset(), None)
+        charset = Charset('iso-8859-1')
+        msg.set_charset(charset)
+        eq(msg['mime-version'], '1.0')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg['content-type'], 'text/plain; charset="iso-8859-1"')
+        eq(msg.get_param('charset'), 'iso-8859-1')
+        eq(msg['content-transfer-encoding'], 'quoted-printable')
+        eq(msg.get_charset().input_charset, 'iso-8859-1')
+        # Remove the charset
+        msg.set_charset(None)
+        eq(msg.get_charset(), None)
+        eq(msg['content-type'], 'text/plain')
+        # Try adding a charset when there's already MIME headers present
+        msg = Message()
+        msg['MIME-Version'] = '2.0'
+        msg['Content-Type'] = 'text/x-weird'
+        msg['Content-Transfer-Encoding'] = 'quinted-puntable'
+        msg.set_charset(charset)
+        eq(msg['mime-version'], '2.0')
+        eq(msg['content-type'], 'text/x-weird; charset="iso-8859-1"')
+        eq(msg['content-transfer-encoding'], 'quinted-puntable')
+
+    def test_set_charset_from_string(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_charset('us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+
+    def test_set_payload_with_charset(self):
+        msg = Message()
+        charset = Charset('iso-8859-1')
+        msg.set_payload('This is a string payload', charset)
+        self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')
+
+    def test_set_payload_with_8bit_data_and_charset(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        msg = Message()
+        msg.set_payload(data, charset)
+        self.assertEqual(msg['content-transfer-encoding'], 'base64')
+        self.assertEqual(msg.get_payload(decode=True), data)
+        self.assertEqual(msg.get_payload(), '0JDQkdCS\n')
+
+    def test_set_payload_with_non_ascii_and_charset_body_encoding_none(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        charset.body_encoding = None # Disable base64 encoding
+        msg = Message()
+        msg.set_payload(data.decode('utf-8'), charset)
+        self.assertEqual(msg['content-transfer-encoding'], '8bit')
+        self.assertEqual(msg.get_payload(decode=True), data)
+
+    def test_set_payload_with_8bit_data_and_charset_body_encoding_none(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        charset.body_encoding = None # Disable base64 encoding
+        msg = Message()
+        msg.set_payload(data, charset)
+        self.assertEqual(msg['content-transfer-encoding'], '8bit')
+        self.assertEqual(msg.get_payload(decode=True), data)
+
+    def test_set_payload_to_list(self):
+        msg = Message()
+        msg.set_payload([])
+        self.assertEqual(msg.get_payload(), [])
+
+    def test_attach_when_payload_is_string(self):
+        msg = Message()
+        msg['Content-Type'] = 'multipart/mixed'
+        msg.set_payload('string payload')
+        sub_msg = MIMEMessage(Message())
+        self.assertRaisesRegex(TypeError, "[Aa]ttach.*non-multipart",
+                               msg.attach, sub_msg)
+
+    def test_get_charsets(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_08.txt')
+        charsets = msg.get_charsets()
+        eq(charsets, [None, 'us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])
+
+        msg = self._msgobj('msg_09.txt')
+        charsets = msg.get_charsets('dingbat')
+        eq(charsets, ['dingbat', 'us-ascii', 'iso-8859-1', 'dingbat',
+                      'koi8-r'])
+
+        msg = self._msgobj('msg_12.txt')
+        charsets = msg.get_charsets()
+        eq(charsets, [None, 'us-ascii', 'iso-8859-1', None, 'iso-8859-2',
+                      'iso-8859-3', 'us-ascii', 'koi8-r'])
+
+    def test_get_filename(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_04.txt')
+        filenames = [p.get_filename() for p in msg.get_payload()]
+        eq(filenames, ['msg.txt', 'msg.txt'])
+
+        msg = self._msgobj('msg_07.txt')
+        subpart = msg.get_payload(1)
+        eq(subpart.get_filename(), 'dingusfish.gif')
+
+    def test_get_filename_with_name_parameter(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_44.txt')
+        filenames = [p.get_filename() for p in msg.get_payload()]
+        eq(filenames, ['msg.txt', 'msg.txt'])
+
+    def test_get_boundary(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_07.txt')
+        # No quotes!
+        eq(msg.get_boundary(), 'BOUNDARY')
+
+    def test_set_boundary(self):
+        eq = self.assertEqual
+        # This one has no existing boundary parameter, but the Content-Type:
+        # header appears fifth.
+        msg = self._msgobj('msg_01.txt')
+        msg.set_boundary('BOUNDARY')
+        header, value = msg.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'text/plain; charset="us-ascii"; boundary="BOUNDARY"')
+        # This one has a Content-Type: header, with a boundary, stuck in the
+        # middle of its headers.  Make sure the order is preserved; it should
+        # be fifth.
+        msg = self._msgobj('msg_04.txt')
+        msg.set_boundary('BOUNDARY')
+        header, value = msg.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'multipart/mixed; boundary="BOUNDARY"')
+        # And this one has no Content-Type: header at all.
+        msg = self._msgobj('msg_03.txt')
+        self.assertRaises(errors.HeaderParseError,
+                          msg.set_boundary, 'BOUNDARY')
+
+    def test_make_boundary(self):
+        msg = MIMEMultipart('form-data')
+        # Note that when the boundary gets created is an implementation
+        # detail and might change.
+        self.assertEqual(msg.items()[0][1], 'multipart/form-data')
+        # Trigger creation of boundary
+        msg.as_string()
+        self.assertStartsWith(msg.items()[0][1],
+                              'multipart/form-data; boundary="==')
+        # XXX: there ought to be tests of the uniqueness of the boundary, too.
+
+    def test_message_rfc822_only(self):
+        # Issue 7970: message/rfc822 not in multipart parsed by
+        # HeaderParser caused an exception when flattened.
+        with openfile('msg_46.txt', encoding="utf-8") as fp:
+            msgdata = fp.read()
+        parser = HeaderParser()
+        msg = parser.parsestr(msgdata)
+        out = StringIO()
+        gen = Generator(out, True, 0)
+        gen.flatten(msg, False)
+        self.assertEqual(out.getvalue(), msgdata)
+
+    def test_byte_message_rfc822_only(self):
+        # Make sure new bytes header parser also passes this.
+        with openfile('msg_46.txt', encoding="utf-8") as fp:
+            msgdata = fp.read().encode('ascii')
+        parser = email.parser.BytesHeaderParser()
+        msg = parser.parsebytes(msgdata)
+        out = BytesIO()
+        gen = email.generator.BytesGenerator(out)
+        gen.flatten(msg)
+        self.assertEqual(out.getvalue(), msgdata)
+
+    def test_get_decoded_payload(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_10.txt')
+        # The outer message is a multipart
+        eq(msg.get_payload(decode=True), None)
+        # Subpart 1 is 7bit encoded
+        eq(msg.get_payload(0).get_payload(decode=True),
+           b'This is a 7bit encoded message.\n')
+        # Subpart 2 is quopri
+        eq(msg.get_payload(1).get_payload(decode=True),
+           b'\xa1This is a Quoted Printable encoded message!\n')
+        # Subpart 3 is base64
+        eq(msg.get_payload(2).get_payload(decode=True),
+           b'This is a Base64 encoded message.')
+        # Subpart 4 is base64 with a trailing newline, which
+        # used to be stripped (issue 7143).
+        eq(msg.get_payload(3).get_payload(decode=True),
+           b'This is a Base64 encoded message.\n')
+        # Subpart 5 has no Content-Transfer-Encoding: header.
+        eq(msg.get_payload(4).get_payload(decode=True),
+           b'This has no Content-Transfer-Encoding: header.\n')
+
+    def test_get_decoded_uu_payload(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_payload('begin 666 -\n+:&5L;&\\@=V]R;&0 \n \nend\n')
+        for cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
+            msg['content-transfer-encoding'] = cte
+            eq(msg.get_payload(decode=True), b'hello world')
+        # Now try some bogus data
+        msg.set_payload('foo')
+        eq(msg.get_payload(decode=True), b'foo')
+
+    def test_get_payload_n_raises_on_non_multipart(self):
+        msg = Message()
+        self.assertRaises(TypeError, msg.get_payload, 1)
+
+    def test_decoded_generator(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_07.txt')
+        with openfile('msg_17.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        s = StringIO()
+        g = DecodedGenerator(s)
+        g.flatten(msg)
+        eq(s.getvalue(), text)
+
+    def test__contains__(self):
+        msg = Message()
+        msg['From'] = 'Me'
+        msg['to'] = 'You'
+        # Check for case insensitivity
+        self.assertIn('from', msg)
+        self.assertIn('From', msg)
+        self.assertIn('FROM', msg)
+        self.assertIn('to', msg)
+        self.assertIn('To', msg)
+        self.assertIn('TO', msg)
+
+    def test_as_string(self):
+        msg = self._msgobj('msg_01.txt')
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        self.assertEqual(text, str(msg))
+        fullrepr = msg.as_string(unixfrom=True)
+        lines = fullrepr.split('\n')
+        self.assertStartsWith(lines[0], 'From ')
+        self.assertEqual(text, NL.join(lines[1:]))
+
+    def test_as_string_policy(self):
+        msg = self._msgobj('msg_01.txt')
+        newpolicy = msg.policy.clone(linesep='\r\n')
+        fullrepr = msg.as_string(policy=newpolicy)
+        s = StringIO()
+        g = Generator(s, policy=newpolicy)
+        g.flatten(msg)
+        self.assertEqual(fullrepr, s.getvalue())
+
+    def test_nonascii_as_string_without_cte(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="iso-8859-1"
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            F=F6=F6 b=E4r
+            """)
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_nonascii_as_string_with_ascii_charset(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="us-ascii"
+            Content-Transfer-Encoding: 8bit
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = source.decode('ascii', 'replace')
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_nonascii_as_string_without_content_type_and_cte(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+
+            Test if non-ascii messages with no Content-Type nor
+            Content-Transfer-Encoding set can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = source.decode('ascii', 'replace')
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_as_bytes(self):
+        msg = self._msgobj('msg_01.txt')
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            data = fp.read().encode('ascii')
+        self.assertEqual(data, bytes(msg))
+        fullrepr = msg.as_bytes(unixfrom=True)
+        lines = fullrepr.split(b'\n')
+        self.assertStartsWith(lines[0], b'From ')
+        self.assertEqual(data, b'\n'.join(lines[1:]))
+
+    def test_as_bytes_policy(self):
+        msg = self._msgobj('msg_01.txt')
+        newpolicy = msg.policy.clone(linesep='\r\n')
+        fullrepr = msg.as_bytes(policy=newpolicy)
+        s = BytesIO()
+        g = BytesGenerator(s,policy=newpolicy)
+        g.flatten(msg)
+        self.assertEqual(fullrepr, s.getvalue())
+
+    # test_headerregistry.TestContentTypeHeader.bad_params
+    def test_bad_param(self):
+        msg = email.message_from_string("Content-Type: blarg; baz; boo\n")
+        self.assertEqual(msg.get_param('baz'), '')
+
+    def test_continuation_sorting_part_order(self):
+        msg = email.message_from_string(
+            "Content-Disposition: attachment; "
+            "filename*=\"ignored\"; "
+            "filename*0*=\"utf-8''foo%20\"; "
+            "filename*1*=\"bar.txt\"\n"
+        )
+        filename = msg.get_filename()
+        self.assertEqual(filename, 'foo bar.txt')
+
+    def test_sorting_no_continuations(self):
+        msg = email.message_from_string(
+            "Content-Disposition: attachment; "
+            "filename*=\"bar.txt\"; "
+        )
+        filename = msg.get_filename()
+        self.assertEqual(filename, 'bar.txt')
+
+    def test_missing_filename(self):
+        msg = email.message_from_string("From: foo\n")
+        self.assertEqual(msg.get_filename(), None)
+
+    def test_bogus_filename(self):
+        msg = email.message_from_string(
+        "Content-Disposition: blarg; filename\n")
+        self.assertEqual(msg.get_filename(), '')
+
+    def test_missing_boundary(self):
+        msg = email.message_from_string("From: foo\n")
+        self.assertEqual(msg.get_boundary(), None)
+
+    def test_get_params(self):
+        eq = self.assertEqual
+        msg = email.message_from_string(
+            'X-Header: foo=one; bar=two; baz=three\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', 'one'), ('bar', 'two'), ('baz', 'three')])
+        msg = email.message_from_string(
+            'X-Header: foo; bar=one; baz=two\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', ''), ('bar', 'one'), ('baz', 'two')])
+        eq(msg.get_params(), None)
+        msg = email.message_from_string(
+            'X-Header: foo; bar="one"; baz=two\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', ''), ('bar', 'one'), ('baz', 'two')])
+
+    # test_headerregistry.TestContentTypeHeader.spaces_around_param_equals
+    def test_get_param_liberal(self):
+        msg = Message()
+        msg['Content-Type'] = 'Content-Type: Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"'
+        self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')
+
+    def test_get_param(self):
+        eq = self.assertEqual
+        msg = email.message_from_string(
+            "X-Header: foo=one; bar=two; baz=three\n")
+        eq(msg.get_param('bar', header='x-header'), 'two')
+        eq(msg.get_param('quuz', header='x-header'), None)
+        eq(msg.get_param('quuz'), None)
+        msg = email.message_from_string(
+            'X-Header: foo; bar="one"; baz=two\n')
+        eq(msg.get_param('foo', header='x-header'), '')
+        eq(msg.get_param('bar', header='x-header'), 'one')
+        eq(msg.get_param('baz', header='x-header'), 'two')
+        # XXX: We are not RFC-2045 compliant!  We cannot parse:
+        # msg["Content-Type"] = 'text/plain; weird="hey; dolly? [you] @ <\\"home\\">?"'
+        # msg.get_param("weird")
+        # yet.
+
+    # test_headerregistry.TestContentTypeHeader.spaces_around_semis
+    def test_get_param_funky_continuation_lines(self):
+        msg = self._msgobj('msg_22.txt')
+        self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')
+
+    # test_headerregistry.TestContentTypeHeader.semis_inside_quotes
+    def test_get_param_with_semis_in_quotes(self):
+        msg = email.message_from_string(
+            'Content-Type: image/pjpeg; name="Jim&amp;&amp;Jill"\n')
+        self.assertEqual(msg.get_param('name'), 'Jim&amp;&amp;Jill')
+        self.assertEqual(msg.get_param('name', unquote=False),
+                         '"Jim&amp;&amp;Jill"')
+
+    # test_headerregistry.TestContentTypeHeader.quotes_inside_rfc2231_value
+    def test_get_param_with_quotes(self):
+        msg = email.message_from_string(
+            'Content-Type: foo; bar*0="baz\\"foobar"; bar*1="\\"baz"')
+        self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
+        msg = email.message_from_string(
+            "Content-Type: foo; bar*0=\"baz\\\"foobar\"; bar*1=\"\\\"baz\"")
+        self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
+
+    @unittest.skip('TODO: RUSTPYTHON; Takes a long time to the point of timeouting')
+    def test_get_param_linear_complexity(self):
+        # Ensure that email.message._parseparam() is fast.
+        # See https://github.com/python/cpython/issues/136063.
+        N = 100_000
+        for s, r in [
+            ("", ""),
+            ("foo=bar", "foo=bar"),
+            (" FOO = bar    ", "foo=bar"),
+        ]:
+            with self.subTest(s=s, r=r, N=N):
+                src = f'{s};' * (N - 1) + s
+                res = email.message._parseparam(src)
+                self.assertEqual(len(res), N)
+                self.assertEqual(len(set(res)), 1)
+                self.assertEqual(res[0], r)
+
+        # This will be considered as a single parameter.
+        malformed = 's="' + ';' * (N - 1)
+        res = email.message._parseparam(malformed)
+        self.assertEqual(res, [malformed])
+
+    def test_field_containment(self):
+        msg = email.message_from_string('Header: exists')
+        self.assertIn('header', msg)
+        self.assertIn('Header', msg)
+        self.assertIn('HEADER', msg)
+        self.assertNotIn('headerx', msg)
+
+    def test_set_param(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_param('charset', 'iso-2022-jp')
+        eq(msg.get_param('charset'), 'iso-2022-jp')
+        msg.set_param('importance', 'high value')
+        eq(msg.get_param('importance'), 'high value')
+        eq(msg.get_param('importance', unquote=False), '"high value"')
+        eq(msg.get_params(), [('text/plain', ''),
+                              ('charset', 'iso-2022-jp'),
+                              ('importance', 'high value')])
+        eq(msg.get_params(unquote=False), [('text/plain', ''),
+                                       ('charset', '"iso-2022-jp"'),
+                                       ('importance', '"high value"')])
+        msg.set_param('charset', 'iso-9999-xx', header='X-Jimmy')
+        eq(msg.get_param('charset', header='X-Jimmy'), 'iso-9999-xx')
+
+    def test_del_param(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_05.txt')
+        eq(msg.get_params(),
+           [('multipart/report', ''), ('report-type', 'delivery-status'),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])
+        old_val = msg.get_param("report-type")
+        msg.del_param("report-type")
+        eq(msg.get_params(),
+           [('multipart/report', ''),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])
+        msg.set_param("report-type", old_val)
+        eq(msg.get_params(),
+           [('multipart/report', ''),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com'),
+            ('report-type', old_val)])
+
+    def test_del_param_on_other_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')
+        msg.del_param('filename', 'content-disposition')
+        self.assertEqual(msg['content-disposition'], 'attachment')
+
+    def test_del_param_on_nonexistent_header(self):
+        msg = Message()
+        # Deleting param on empty msg should not raise exception.
+        msg.del_param('filename', 'content-disposition')
+
+    def test_del_nonexistent_param(self):
+        msg = Message()
+        msg.add_header('Content-Type', 'text/plain', charset='utf-8')
+        existing_header = msg['Content-Type']
+        msg.del_param('foobar', header='Content-Type')
+        self.assertEqual(msg['Content-Type'], existing_header)
+
+    def test_set_type(self):
+        eq = self.assertEqual
+        msg = Message()
+        self.assertRaises(ValueError, msg.set_type, 'text')
+        msg.set_type('text/plain')
+        eq(msg['content-type'], 'text/plain')
+        msg.set_param('charset', 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        msg.set_type('text/html')
+        eq(msg['content-type'], 'text/html; charset="us-ascii"')
+
+    def test_set_type_on_other_header(self):
+        msg = Message()
+        msg['X-Content-Type'] = 'text/plain'
+        msg.set_type('application/octet-stream', 'X-Content-Type')
+        self.assertEqual(msg['x-content-type'], 'application/octet-stream')
+
+    def test_get_content_type_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_type_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_type(), 'message/rfc822')
+
+    def test_get_content_type_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_type(),
+                         'message/rfc822')
+
+    def test_get_content_type_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_type(),
+                         'message/rfc822')
+
+    def test_get_content_type_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_type_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_maintype_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_maintype_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_maintype_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_subtype_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_subtype_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_subtype_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_maintype_error(self):
+        msg = Message()
+        msg['Content-Type'] = 'no-slash-in-this-string'
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_subtype_error(self):
+        msg = Message()
+        msg['Content-Type'] = 'no-slash-in-this-string'
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_replace_header(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.add_header('First', 'One')
+        msg.add_header('Second', 'Two')
+        msg.add_header('Third', 'Three')
+        eq(msg.keys(), ['First', 'Second', 'Third'])
+        eq(msg.values(), ['One', 'Two', 'Three'])
+        msg.replace_header('Second', 'Twenty')
+        eq(msg.keys(), ['First', 'Second', 'Third'])
+        eq(msg.values(), ['One', 'Twenty', 'Three'])
+        msg.add_header('First', 'Eleven')
+        msg.replace_header('First', 'One Hundred')
+        eq(msg.keys(), ['First', 'Second', 'Third', 'First'])
+        eq(msg.values(), ['One Hundred', 'Twenty', 'Three', 'Eleven'])
+        self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')
+
+    def test_get_content_disposition(self):
+        msg = Message()
+        self.assertIsNone(msg.get_content_disposition())
+        msg.add_header('Content-Disposition', 'attachment',
+                       filename='random.avi')
+        self.assertEqual(msg.get_content_disposition(), 'attachment')
+        msg.replace_header('Content-Disposition', 'inline')
+        self.assertEqual(msg.get_content_disposition(), 'inline')
+        msg.replace_header('Content-Disposition', 'InlinE')
+        self.assertEqual(msg.get_content_disposition(), 'inline')
+
+    # test_defect_handling:test_invalid_chars_in_base64_payload
+    def test_broken_base64_payload(self):
+        x = 'AwDp0P7//y6LwKEAcPa/6Q=9'
+        msg = Message()
+        msg['content-type'] = 'audio/x-midi'
+        msg['content-transfer-encoding'] = 'base64'
+        msg.set_payload(x)
+        self.assertEqual(msg.get_payload(decode=True),
+                         (b'\x03\x00\xe9\xd0\xfe\xff\xff.\x8b\xc0'
+                          b'\xa1\x00p\xf6\xbf\xe9\x0f'))
+        self.assertIsInstance(msg.defects[0],
+                              errors.InvalidBase64CharactersDefect)
+
+    def test_broken_unicode_payload(self):
+        # This test improves coverage but is not a compliance test.
+        # The behavior in this situation is currently undefined by the API.
+        x = 'this is a br\xf6ken thing to do'
+        msg = Message()
+        msg['content-type'] = 'text/plain'
+        msg['content-transfer-encoding'] = '8bit'
+        msg.set_payload(x)
+        self.assertEqual(msg.get_payload(decode=True),
+                         bytes(x, 'raw-unicode-escape'))
+
+    def test_questionable_bytes_payload(self):
+        # This test improves coverage but is not a compliance test,
+        # since it involves poking inside the black box.
+        x = 'this is a quéstionable thing to do'.encode('utf-8')
+        msg = Message()
+        msg['content-type'] = 'text/plain; charset="utf-8"'
+        msg['content-transfer-encoding'] = '8bit'
+        msg._payload = x
+        self.assertEqual(msg.get_payload(decode=True), x)
+
+    # Issue 1078919
+    def test_ascii_add_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+                       filename='bud.gif')
+        self.assertEqual('attachment; filename="bud.gif"',
+            msg['Content-Disposition'])
+
+    def test_noascii_add_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="Fußballer.ppt")
+        self.assertEqual(
+            'attachment; filename*=utf-8\'\'Fu%C3%9Fballer.ppt',
+            msg['Content-Disposition'])
+
+    def test_nonascii_add_header_via_triple(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename=('iso-8859-1', '', 'Fußballer.ppt'))
+        self.assertEqual(
+            'attachment; filename*=iso-8859-1\'\'Fu%DFballer.ppt',
+            msg['Content-Disposition'])
+
+    def test_ascii_add_header_with_tspecial(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="windows [filename].ppt")
+        self.assertEqual(
+            'attachment; filename="windows [filename].ppt"',
+            msg['Content-Disposition'])
+
+    def test_nonascii_add_header_with_tspecial(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="Fußballer [filename].ppt")
+        self.assertEqual(
+            "attachment; filename*=utf-8''Fu%C3%9Fballer%20%5Bfilename%5D.ppt",
+            msg['Content-Disposition'])
+
+    def test_binary_quopri_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            msg = Message()
+            msg['content-type'] = 'text/plain; charset=%s' % charset
+            msg['content-transfer-encoding'] = 'quoted-printable'
+            msg.set_payload(b'foo=e6=96=87bar')
+            self.assertEqual(
+                msg.get_payload(decode=True),
+                b'foo\xe6\x96\x87bar',
+                'get_payload returns wrong result with charset %s.' % charset)
+
+    def test_binary_base64_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            msg = Message()
+            msg['content-type'] = 'text/plain; charset=%s' % charset
+            msg['content-transfer-encoding'] = 'base64'
+            msg.set_payload(b'Zm9v5paHYmFy')
+            self.assertEqual(
+                msg.get_payload(decode=True),
+                b'foo\xe6\x96\x87bar',
+                'get_payload returns wrong result with charset %s.' % charset)
+
+    def test_binary_uuencode_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            for encoding in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
+                msg = Message()
+                msg['content-type'] = 'text/plain; charset=%s' % charset
+                msg['content-transfer-encoding'] = encoding
+                msg.set_payload(b"begin 666 -\n)9F]OYI:'8F%R\n \nend\n")
+                self.assertEqual(
+                    msg.get_payload(decode=True),
+                    b'foo\xe6\x96\x87bar',
+                    str(('get_payload returns wrong result ',
+                         'with charset {0} and encoding {1}.')).\
+                        format(charset, encoding))
+
+    def test_add_header_with_name_only_param(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'inline', foo_bar=None)
+        self.assertEqual("inline; foo-bar", msg['Content-Disposition'])
+
+    def test_add_header_with_no_value(self):
+        msg = Message()
+        msg.add_header('X-Status', None)
+        self.assertEqual('', msg['X-Status'])
+
+    # Issue 5871: reject an attempt to embed a header inside a header value
+    # (header injection attack).
+    def test_embedded_header_via_Header_rejected(self):
+        msg = Message()
+        msg['Dummy'] = Header('dummy\nX-Injected-Header: test')
+        self.assertRaises(errors.HeaderParseError, msg.as_string)
+
+    def test_embedded_header_via_string_rejected(self):
+        msg = Message()
+        msg['Dummy'] = 'dummy\nX-Injected-Header: test'
+        self.assertRaises(errors.HeaderParseError, msg.as_string)
+
+    def test_unicode_header_defaults_to_utf8_encoding(self):
+        # Issue 14291
+        m = MIMEText('abc\n')
+        m['Subject'] = 'É test'
+        self.assertEqual(str(m),textwrap.dedent("""\
+            Content-Type: text/plain; charset="us-ascii"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: 7bit
+            Subject: =?utf-8?q?=C3=89_test?=
+
+            abc
+            """))
+
+    def test_unicode_body_defaults_to_utf8_encoding(self):
+        # Issue 14291
+        m = MIMEText('É testabc\n')
+        self.assertEqual(str(m),textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: base64
+
+            w4kgdGVzdGFiYwo=
+            """))
+
+    def test_string_payload_with_base64_cte(self):
+        msg = email.message_from_string(textwrap.dedent("""\
+        Content-Transfer-Encoding: base64
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg['content-transfer-encoding'].defects, [])
+
+
+
+# Test the email.encoders module
+class TestEncoders(unittest.TestCase):
+
+    def test_EncodersEncode_base64(self):
+        with openfile('python.gif', 'rb') as fp:
+            bindata = fp.read()
+        mimed = email.mime.image.MIMEImage(bindata)
+        base64ed = mimed.get_payload()
+        # the transfer-encoded body lines should all be <=76 characters
+        lines = base64ed.split('\n')
+        self.assertLessEqual(max([ len(x) for x in lines ]), 76)
+
+    def test_encode_empty_payload(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_charset('us-ascii')
+        eq(msg['content-transfer-encoding'], '7bit')
+
+    def test_default_cte(self):
+        eq = self.assertEqual
+        # 7bit data and the default us-ascii _charset
+        msg = MIMEText('hello world')
+        eq(msg['content-transfer-encoding'], '7bit')
+        # Similar, but with 8bit data
+        msg = MIMEText('hello \xf8 world')
+        eq(msg['content-transfer-encoding'], 'base64')
+        # And now with a different charset
+        msg = MIMEText('hello \xf8 world', _charset='iso-8859-1')
+        eq(msg['content-transfer-encoding'], 'quoted-printable')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_encode7or8bit(self):
+        # Make sure a charset whose input character set is 8bit but
+        # whose output character set is 7bit gets a transfer-encoding
+        # of 7bit.
+        eq = self.assertEqual
+        msg = MIMEText('æ–‡\n', _charset='euc-jp')
+        eq(msg['content-transfer-encoding'], '7bit')
+        eq(msg.as_string(), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="iso-2022-jp"
+            Content-Transfer-Encoding: 7bit
+
+            \x1b$BJ8\x1b(B
+            """))
+
+    def test_qp_encode_latin1(self):
+        msg = MIMEText('\xe1\xf6\n', 'text', 'ISO-8859-1')
+        self.assertEqual(str(msg), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/text; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            =E1=F6
+            """))
+
+    def test_qp_encode_non_latin1(self):
+        # Issue 16948
+        msg = MIMEText('\u017c\n', 'text', 'ISO-8859-2')
+        self.assertEqual(str(msg), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/text; charset="iso-8859-2"
+            Content-Transfer-Encoding: quoted-printable
+
+            =BF
+            """))
+
+
+# Test long header wrapping
+class TestLongHeaders(TestEmailBase):
+
+    maxDiff = None
+
+    def test_split_long_continuation(self):
+        eq = self.ndiffAssertEqual
+        msg = email.message_from_string("""\
+Subject: bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text
+
+test
+""")
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+Subject: bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text
+
+test
+""")
+
+    def test_another_long_almost_unsplittable_header(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text"""
+        h = Header(hstr, continuation_ws='\t')
+        eq(h.encode(), """\
+bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text""")
+        h = Header(hstr.replace('\t', ' '))
+        eq(h.encode(), """\
+bug demonstration
+ 12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+ more text""")
+
+    def test_long_nonstring(self):
+        eq = self.ndiffAssertEqual
+        g = Charset("iso-8859-1")
+        cz = Charset("iso-8859-2")
+        utf8 = Charset("utf-8")
+        g_head = (b'Die Mieter treten hier ein werden mit einem Foerderband '
+                  b'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
+                  b'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
+                  b'bef\xf6rdert. ')
+        cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
+                   b'd\xf9vtipu.. ')
+        utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
+                     '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
+                     '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
+                     '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
+                     '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
+                     'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
+                     'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
+                     '\u3044\u307e\u3059\u3002')
+        h = Header(g_head, g, header_name='Subject')
+        h.append(cz_head, cz)
+        h.append(utf8_head, utf8)
+        msg = Message()
+        msg['Subject'] = h
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+Subject: =?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderb?=
+ =?iso-8859-1?q?and_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen?=
+ =?iso-8859-1?q?_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef?=
+ =?iso-8859-1?q?=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hrouti?=
+ =?iso-8859-2?q?ly_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
+ =?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC5LiA?=
+ =?utf-8?b?6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn44Gf44KJ?=
+ =?utf-8?b?44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFzIE51bnN0dWNr?=
+ =?utf-8?b?IGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5kIGRhcyBPZGVyIGRp?=
+ =?utf-8?b?ZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIDjgaPjgabjgYTjgb7jgZk=?=
+ =?utf-8?b?44CC?=
+
+""")
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerde?=
+ =?iso-8859-1?q?rband_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndis?=
+ =?iso-8859-1?q?chen_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klinge?=
+ =?iso-8859-1?q?n_bef=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se?=
+ =?iso-8859-2?q?_hroutily_pod_tlakem_jejich_d=F9vtipu=2E=2E_?=
+ =?utf-8?b?5q2j56K644Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb?=
+ =?utf-8?b?44KT44CC5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go?=
+ =?utf-8?b?44Gv44Gn44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBp?=
+ =?utf-8?b?c3QgZGFzIE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWlo?=
+ =?utf-8?b?ZXJodW5kIGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI0=?=
+ =?utf-8?b?44Go6KiA44Gj44Gm44GE44G+44GZ44CC?=""")
+
+    def test_long_header_encode(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    def test_long_header_encode_with_tab_continuation_is_just_a_hint(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit',
+                   continuation_ws='\t')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    def test_long_header_encode_with_tab_continuation(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals";\t'
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit',
+                   continuation_ws='\t')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+\tspooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_header_encode_with_different_output_charset(self):
+        h = Header('æ–‡', 'euc-jp')
+        self.assertEqual(h.encode(), "=?iso-2022-jp?b?GyRCSjgbKEI=?=")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc-jp
+    def test_long_header_encode_with_different_output_charset(self):
+        h = Header(b'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5\xa4\xec\xa4'
+            b'\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2\xf1\xbc\xd4'
+            b'\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3\xa4\xc6\xa4'
+            b'\xa4\xa4\xde\xa4\xb9'.decode('euc-jp'), 'euc-jp')
+        res = """\
+=?iso-2022-jp?b?dGVzdC1qYSAbJEIkWEVqOUYkNSRsJD8lYSE8JWskTztKMnE8VCROPjUbKEI=?=
+ =?iso-2022-jp?b?GyRCRyckckJUJEMkRiQkJF4kORsoQg==?="""
+        self.assertEqual(h.encode(), res)
+
+    def test_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = MIMEText('')
+        # It'd be great if we could use add_header() here, but that doesn't
+        # guarantee an order of the parameters.
+        msg['X-Foobar-Spoink-Defrobnit'] = (
+            'wasnipoop; giraffes="very-long-necked-animals"; '
+            'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), '''\
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
+
+''')
+
+    def test_no_semis_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join('<%d@dom.ain>' % i for i in range(10))
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <0@dom.ain> <1@dom.ain> <2@dom.ain> <3@dom.ain> <4@dom.ain>
+ <5@dom.ain> <6@dom.ain> <7@dom.ain> <8@dom.ain> <9@dom.ain>
+
+Test""")
+
+    def test_last_split_chunk_does_not_fit(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Subject: the first part of this is short, but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+Subject: the first part of this is short,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_splittable_leading_char_followed_by_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(', but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_multiple_splittable_leading_char_followed_by_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(', , but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+, ,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_trailing_splittable_on_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself;')
+        eq(h.encode(), "this_part_does_not_fit_within_maxlinelen_and_thus_should_"
+            "be_on_a_line_all_by_itself;")
+
+    def test_trailing_splittable_on_overlong_unsplittable_with_leading_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header('; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_long_header_with_multiple_sequential_split_chars(self):
+        eq = self.ndiffAssertEqual
+        h = Header('This is a long line that has two whitespaces  in a row.  '
+            'This used to cause truncation of the header when folded')
+        eq(h.encode(), """\
+This is a long line that has two whitespaces  in a row.  This used to cause
+ truncation of the header when folded""")
+
+    def test_splitter_split_on_punctuation_only_if_fws_with_header(self):
+        eq = self.ndiffAssertEqual
+        h = Header('thisverylongheaderhas;semicolons;and,commas,but'
+            'they;arenotlegal;fold,points')
+        eq(h.encode(), "thisverylongheaderhas;semicolons;and,commas,butthey;"
+                        "arenotlegal;fold,points")
+
+    def test_leading_splittable_in_the_middle_just_before_overlong_last_part(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this is a  test where we need to have more than one line '
+            'before; our final line that is just too big to fit;; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself;')
+        eq(h.encode(), """\
+this is a  test where we need to have more than one line before;
+ our final line that is just too big to fit;;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself;""")
+
+    def test_overlong_last_part_followed_by_split_point(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself ')
+        eq(h.encode(), "this_part_does_not_fit_within_maxlinelen_and_thus_"
+                        "should_be_on_a_line_all_by_itself ")
+
+    def test_multiline_with_overlong_parts_separated_by_two_split_points(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_is_a__test_where_we_need_to_have_more_than_one_line_'
+            'before_our_final_line_; ; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+this_is_a__test_where_we_need_to_have_more_than_one_line_before_our_final_line_;
+ ;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_multiline_with_overlong_last_part_followed_by_split_point(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this is a test where we need to have more than one line '
+            'before our final line; ; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+this is a test where we need to have more than one line before our final line;
+ ;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_long_header_with_whitespace_runs(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join(['<foo@dom.ain>  '] * 10)
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>
+   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>
+   <foo@dom.ain>   <foo@dom.ain>\x20\x20
+
+Test""")
+
+    def test_long_run_with_semi_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join(['<foo@dom.ain>'] * 10) + '; abc'
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain>
+ <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain>
+ <foo@dom.ain>; abc
+
+Test""")
+
+    def test_splitter_split_on_punctuation_only_if_fws(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = ('thisverylongheaderhas;semicolons;and,commas,but'
+            'they;arenotlegal;fold,points')
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        # XXX the space after the header should not be there.
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References:\x20
+ thisverylongheaderhas;semicolons;and,commas,butthey;arenotlegal;fold,points
+
+Test""")
+
+    def test_no_split_long_header(self):
+        eq = self.ndiffAssertEqual
+        hstr = 'References: ' + 'x' * 80
+        h = Header(hstr)
+        # These come on two lines because Headers are really field value
+        # classes and don't really know about their field names.
+        eq(h.encode(), """\
+References:
+ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx""")
+        h = Header('x' * 80)
+        eq(h.encode(), 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+
+    def test_splitting_multiple_long_lines(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+from babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+"""
+        h = Header(hstr, continuation_ws='\t')
+        eq(h.encode(), """\
+from babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)""")
+
+    def test_splitting_first_line_only_is_long(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93] helo=cthulhu.gerg.ca)
+\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
+\tid 17k4h5-00034i-00
+\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400"""
+        h = Header(hstr, maxlinelen=78, header_name='Received',
+                   continuation_ws='\t')
+        eq(h.encode(), """\
+from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93]
+ helo=cthulhu.gerg.ca)
+\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
+\tid 17k4h5-00034i-00
+\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400""")
+
+    def test_long_8bit_header(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        h = Header('Britische Regierung gibt', 'iso-8859-1',
+                    header_name='Subject')
+        h.append('gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte')
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
+ =?iso-8859-1?q?hore-Windkraftprojekte?=""")
+        msg['Subject'] = h
+        eq(msg.as_string(maxheaderlen=76), """\
+Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
+ =?iso-8859-1?q?hore-Windkraftprojekte?=
+
+""")
+        eq(msg.as_string(maxheaderlen=0), """\
+Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offshore-Windkraftprojekte?=
+
+""")
+
+    def test_long_8bit_header_no_charset(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        header_string = ('Britische Regierung gibt gr\xfcnes Licht '
+                         'f\xfcr Offshore-Windkraftprojekte '
+                         '<a-very-long-address@example.com>')
+        msg['Reply-To'] = header_string
+        eq(msg.as_string(maxheaderlen=78), """\
+Reply-To: =?utf-8?q?Britische_Regierung_gibt_gr=C3=BCnes_Licht_f=C3=BCr_Offs?=
+ =?utf-8?q?hore-Windkraftprojekte_=3Ca-very-long-address=40example=2Ecom=3E?=
+
+""")
+        msg = Message()
+        msg['Reply-To'] = Header(header_string,
+                                 header_name='Reply-To')
+        eq(msg.as_string(maxheaderlen=78), """\
+Reply-To: =?utf-8?q?Britische_Regierung_gibt_gr=C3=BCnes_Licht_f=C3=BCr_Offs?=
+ =?utf-8?q?hore-Windkraftprojekte_=3Ca-very-long-address=40example=2Ecom=3E?=
+
+""")
+
+    def test_long_to_header(self):
+        eq = self.ndiffAssertEqual
+        to = ('"Someone Test #A" <someone@eecs.umich.edu>,'
+              '<someone@eecs.umich.edu>, '
+              '"Someone Test #B" <someone@umich.edu>, '
+              '"Someone Test #C" <someone@eecs.umich.edu>, '
+              '"Someone Test #D" <someone@eecs.umich.edu>')
+        msg = Message()
+        msg['To'] = to
+        eq(msg.as_string(maxheaderlen=78), '''\
+To: "Someone Test #A" <someone@eecs.umich.edu>,<someone@eecs.umich.edu>,
+ "Someone Test #B" <someone@umich.edu>,
+ "Someone Test #C" <someone@eecs.umich.edu>,
+ "Someone Test #D" <someone@eecs.umich.edu>
+
+''')
+
+    def test_long_line_after_append(self):
+        eq = self.ndiffAssertEqual
+        s = 'This is an example of string which has almost the limit of header length.'
+        h = Header(s)
+        h.append('Add another line.')
+        eq(h.encode(maxlinelen=76), """\
+This is an example of string which has almost the limit of header length.
+ Add another line.""")
+
+    def test_shorter_line_with_append(self):
+        eq = self.ndiffAssertEqual
+        s = 'This is a shorter line.'
+        h = Header(s)
+        h.append('Add another sentence. (Surprise?)')
+        eq(h.encode(),
+           'This is a shorter line. Add another sentence. (Surprise?)')
+
+    def test_long_field_name(self):
+        eq = self.ndiffAssertEqual
+        fn = 'X-Very-Very-Very-Long-Header-Name'
+        gs = ('Die Mieter treten hier ein werden mit einem Foerderband '
+              'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
+              'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
+              'bef\xf6rdert. ')
+        h = Header(gs, 'iso-8859-1', header_name=fn)
+        # BAW: this seems broken because the first line is too long
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_e?=
+ =?iso-8859-1?q?in_werden_mit_einem_Foerderband_komfortabel_den_Korridor_e?=
+ =?iso-8859-1?q?ntlang=2C_an_s=FCdl=FCndischen_Wandgem=E4lden_vorbei=2C_ge?=
+ =?iso-8859-1?q?gen_die_rotierenden_Klingen_bef=F6rdert=2E_?=""")
+
+    def test_long_received_header(self):
+        h = ('from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) '
+             'by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP; '
+             'Wed, 05 Mar 2003 18:10:18 -0700')
+        msg = Message()
+        msg['Received-1'] = Header(h, continuation_ws='\t')
+        msg['Received-2'] = h
+        # This should be splitting on spaces not semicolons.
+        self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
+Received-1: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by
+ hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
+ Wed, 05 Mar 2003 18:10:18 -0700
+Received-2: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by
+ hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
+ Wed, 05 Mar 2003 18:10:18 -0700
+
+""")
+
+    def test_string_headerinst_eq(self):
+        h = ('<15975.17901.207240.414604@sgigritzmann1.mathematik.'
+             'tu-muenchen.de> (David Bremner\'s message of '
+             '"Thu, 6 Mar 2003 13:58:21 +0100")')
+        msg = Message()
+        msg['Received-1'] = Header(h, header_name='Received-1',
+                                   continuation_ws='\t')
+        msg['Received-2'] = h
+        # XXX The space after the ':' should not be there.
+        self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
+Received-1:\x20
+ <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David
+ Bremner's message of \"Thu, 6 Mar 2003 13:58:21 +0100\")
+Received-2:\x20
+ <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David
+ Bremner's message of \"Thu, 6 Mar 2003 13:58:21 +0100\")
+
+""")
+
+    def test_long_unbreakable_lines_with_continuation(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        t = """\
+iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp"""
+        msg['Face-1'] = t
+        msg['Face-2'] = Header(t, header_name='Face-2')
+        msg['Face-3'] = ' ' + t
+        # XXX This splitting is all wrong.  It the first value line should be
+        # snug against the field name or the space after the header not there.
+        eq(msg.as_string(maxheaderlen=78), """\
+Face-1:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+Face-2:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+Face-3:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+
+""")
+
+    def test_another_long_multiline_header(self):
+        eq = self.ndiffAssertEqual
+        m = ('Received: from siimage.com '
+             '([172.25.1.3]) by zima.siliconimage.com with '
+             'Microsoft SMTPSVC(5.0.2195.4905); '
+             'Wed, 16 Oct 2002 07:41:11 -0700')
+        msg = email.message_from_string(m)
+        eq(msg.as_string(maxheaderlen=78), '''\
+Received: from siimage.com ([172.25.1.3]) by zima.siliconimage.com with
+ Microsoft SMTPSVC(5.0.2195.4905); Wed, 16 Oct 2002 07:41:11 -0700
+
+''')
+
+    def test_long_lines_with_different_header(self):
+        eq = self.ndiffAssertEqual
+        h = ('List-Unsubscribe: '
+             '<http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,'
+             '        <mailto:spamassassin-talk-request@lists.sourceforge.net'
+             '?subject=unsubscribe>')
+        msg = Message()
+        msg['List'] = h
+        msg['List'] = Header(h, header_name='List')
+        eq(msg.as_string(maxheaderlen=78), """\
+List: List-Unsubscribe:
+ <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
+        <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
+List: List-Unsubscribe:
+ <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
+        <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
+
+""")
+
+    def test_long_rfc2047_header_with_embedded_fws(self):
+        h = Header(textwrap.dedent("""\
+            We're going to pretend this header is in a non-ascii character set
+            \tto see if line wrapping with encoded words and embedded
+               folding white space works"""),
+                   charset='utf-8',
+                   header_name='Test')
+        self.assertEqual(h.encode()+'\n', textwrap.dedent("""\
+            =?utf-8?q?We=27re_going_to_pretend_this_header_is_in_a_non-ascii_chara?=
+             =?utf-8?q?cter_set?=
+             =?utf-8?q?_to_see_if_line_wrapping_with_encoded_words_and_embedded?=
+             =?utf-8?q?_folding_white_space_works?=""")+'\n')
+
+
+
+# Test mangling of "From " lines in the body of a message
+class TestFromMangling(unittest.TestCase):
+    def setUp(self):
+        self.msg = Message()
+        self.msg['From'] = 'aaa@bbb.org'
+        self.msg.set_payload("""\
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_mangled_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=True)
+        g.flatten(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+>From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_dont_mangle_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=False)
+        g.flatten(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_mangle_from_in_preamble_and_epilog(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=True)
+        msg = email.message_from_string(textwrap.dedent("""\
+            From: foo@bar.com
+            Mime-Version: 1.0
+            Content-Type: multipart/mixed; boundary=XXX
+
+            From somewhere unknown
+
+            --XXX
+            Content-Type: text/plain
+
+            foo
+
+            --XXX--
+
+            From somewhere unknowable
+            """))
+        g.flatten(msg)
+        self.assertEqual(len([1 for x in s.getvalue().split('\n')
+                                  if x.startswith('>From ')]), 2)
+
+    def test_mangled_from_with_bad_bytes(self):
+        source = textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: 8bit
+            From: aaa@bbb.org
+
+        """).encode('utf-8')
+        msg = email.message_from_bytes(source + b'From R\xc3\xb6lli\n')
+        b = BytesIO()
+        g = BytesGenerator(b, mangle_from_=True)
+        g.flatten(msg)
+        self.assertEqual(b.getvalue(), source + b'>From R\xc3\xb6lli\n')
+
+    def test_multipart_with_bad_bytes_in_cte(self):
+        # bpo30835
+        source = textwrap.dedent("""\
+            From: aperson@example.com
+            Content-Type: multipart/mixed; boundary="1"
+            Content-Transfer-Encoding: \xc8
+        """).encode('utf-8')
+        msg = email.message_from_bytes(source)
+
+
+# Test the basic MIMEAudio class
+class TestMIMEAudio(unittest.TestCase):
+    def _make_audio(self, ext):
+        with openfile(f'sndhdr.{ext}', 'rb') as fp:
+            self._audiodata = fp.read()
+        self._au = MIMEAudio(self._audiodata)
+
+    def test_guess_minor_type(self):
+        for ext, subtype in {
+            'aifc': 'x-aiff',
+            'aiff': 'x-aiff',
+            'wav': 'x-wav',
+            'au': 'basic',
+        }.items():
+            self._make_audio(ext)
+            subtype = ext if subtype is None else subtype
+            self.assertEqual(self._au.get_content_type(), f'audio/{subtype}')
+
+    def test_encoding(self):
+        self._make_audio('au')
+        payload = self._au.get_payload()
+        self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
+                         self._audiodata)
+
+    def test_checkSetMinor(self):
+        self._make_audio('au')
+        au = MIMEAudio(self._audiodata, 'fish')
+        self.assertEqual(au.get_content_type(), 'audio/fish')
+
+    def test_add_header(self):
+        self._make_audio('au')
+        eq = self.assertEqual
+        self._au.add_header('Content-Disposition', 'attachment',
+                            filename='sndhdr.au')
+        eq(self._au['content-disposition'],
+           'attachment; filename="sndhdr.au"')
+        eq(self._au.get_params(header='content-disposition'),
+           [('attachment', ''), ('filename', 'sndhdr.au')])
+        eq(self._au.get_param('filename', header='content-disposition'),
+           'sndhdr.au')
+        missing = []
+        eq(self._au.get_param('attachment', header='content-disposition'), '')
+        self.assertIs(self._au.get_param(
+            'foo', failobj=missing,
+            header='content-disposition'), missing)
+        # Try some missing stuff
+        self.assertIs(self._au.get_param('foobar', missing), missing)
+        self.assertIs(self._au.get_param('attachment', missing,
+                                         header='foobar'), missing)
+
+
+
+# Test the basic MIMEImage class
+class TestMIMEImage(unittest.TestCase):
+    def _make_image(self, ext):
+        with openfile(f'python.{ext}', 'rb') as fp:
+            self._imgdata = fp.read()
+        self._im = MIMEImage(self._imgdata)
+
+    def test_guess_minor_type(self):
+        for ext, subtype in {
+            'bmp': None,
+            'exr': None,
+            'gif': None,
+            'jpg': 'jpeg',
+            'pbm': None,
+            'pgm': None,
+            'png': None,
+            'ppm': None,
+            'ras': 'rast',
+            'sgi': 'rgb',
+            'tiff': None,
+            'webp': None,
+            'xbm': None,
+        }.items():
+            self._make_image(ext)
+            subtype = ext if subtype is None else subtype
+            self.assertEqual(self._im.get_content_type(), f'image/{subtype}')
+
+    def test_encoding(self):
+        self._make_image('gif')
+        payload = self._im.get_payload()
+        self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
+                         self._imgdata)
+
+    def test_checkSetMinor(self):
+        self._make_image('gif')
+        im = MIMEImage(self._imgdata, 'fish')
+        self.assertEqual(im.get_content_type(), 'image/fish')
+
+    def test_add_header(self):
+        self._make_image('gif')
+        eq = self.assertEqual
+        self._im.add_header('Content-Disposition', 'attachment',
+                            filename='dingusfish.gif')
+        eq(self._im['content-disposition'],
+           'attachment; filename="dingusfish.gif"')
+        eq(self._im.get_params(header='content-disposition'),
+           [('attachment', ''), ('filename', 'dingusfish.gif')])
+        eq(self._im.get_param('filename', header='content-disposition'),
+           'dingusfish.gif')
+        missing = []
+        eq(self._im.get_param('attachment', header='content-disposition'), '')
+        self.assertIs(self._im.get_param('foo', failobj=missing,
+                                         header='content-disposition'), missing)
+        # Try some missing stuff
+        self.assertIs(self._im.get_param('foobar', missing), missing)
+        self.assertIs(self._im.get_param('attachment', missing,
+                                         header='foobar'), missing)
+
+
+# Test the basic MIMEApplication class
+class TestMIMEApplication(unittest.TestCase):
+    def test_headers(self):
+        eq = self.assertEqual
+        msg = MIMEApplication(b'\xfa\xfb\xfc\xfd\xfe\xff')
+        eq(msg.get_content_type(), 'application/octet-stream')
+        eq(msg['content-transfer-encoding'], 'base64')
+
+    def test_body(self):
+        eq = self.assertEqual
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata)
+        # whitespace in the cte encoded block is RFC-irrelevant.
+        eq(msg.get_payload().strip(), '+vv8/f7/')
+        eq(msg.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_encode_7or8bit(self):
+        # Issue 17171.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_7or8bit)
+        # Treated as a string, this will be invalid code points.
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg['Content-Transfer-Encoding'], '8bit')
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg2['Content-Transfer-Encoding'], '8bit')
+
+    def test_binary_body_with_encode_noop(self):
+        # Issue 16564: This does not produce an RFC valid message, since to be
+        # valid it should have a CTE of binary.  But the below works in
+        # Python2, and is documented as working this way.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_noop)
+        # Treated as a string, this will be invalid code points.
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_unicode_linend_encode_noop(self):
+        # Issue 19003: This is a variation on #16564.
+        bytesdata = b'\x0b\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_noop)
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_encode_quopri(self):
+        # Issue 14360.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff '
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_quopri)
+        self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg['Content-Transfer-Encoding'], 'quoted-printable')
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg2['Content-Transfer-Encoding'], 'quoted-printable')
+
+    def test_binary_body_with_encode_base64(self):
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_base64)
+        self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+
+# Test the basic MIMEText class
+class TestMIMEText(unittest.TestCase):
+    def setUp(self):
+        self._msg = MIMEText('hello there')
+
+    def test_types(self):
+        eq = self.assertEqual
+        eq(self._msg.get_content_type(), 'text/plain')
+        eq(self._msg.get_param('charset'), 'us-ascii')
+        missing = []
+        self.assertIs(self._msg.get_param('foobar', missing), missing)
+        self.assertIs(self._msg.get_param('charset', missing, header='foobar'),
+                      missing)
+
+    def test_payload(self):
+        self.assertEqual(self._msg.get_payload(), 'hello there')
+        self.assertFalse(self._msg.is_multipart())
+
+    def test_charset(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there', _charset='us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        # Also accept a Charset instance
+        charset = Charset('utf-8')
+        charset.body_encoding = None
+        msg = MIMEText('hello there', _charset=charset)
+        eq(msg.get_charset().input_charset, 'utf-8')
+        eq(msg['content-type'], 'text/plain; charset="utf-8"')
+        eq(msg.get_payload(), 'hello there')
+
+    def test_7bit_input(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there', _charset='us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+
+    def test_7bit_input_no_charset(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there')
+        eq(msg.get_charset(), 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        self.assertIn('hello there', msg.as_string())
+
+    def test_utf8_input(self):
+        teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
+        eq = self.assertEqual
+        msg = MIMEText(teststr, _charset='utf-8')
+        eq(msg.get_charset().output_charset, 'utf-8')
+        eq(msg['content-type'], 'text/plain; charset="utf-8"')
+        eq(msg.get_payload(decode=True), teststr.encode('utf-8'))
+
+    @unittest.skip("can't fix because of backward compat in email5, "
+        "will fix in email6")
+    def test_utf8_input_no_charset(self):
+        teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
+        self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
+
+
+
+# Test complicated multipart/* messages
+class TestMultipart(TestEmailBase):
+    def setUp(self):
+        with openfile('python.gif', 'rb') as fp:
+            data = fp.read()
+        container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')
+        image = MIMEImage(data, name='dingusfish.gif')
+        image.add_header('content-disposition', 'attachment',
+                         filename='dingusfish.gif')
+        intro = MIMEText('''\
+Hi there,
+
+This is the dingus fish.
+''')
+        container.attach(intro)
+        container.attach(image)
+        container['From'] = 'Barry <barry@digicool.com>'
+        container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'
+        container['Subject'] = 'Here is your dingus fish'
+
+        now = 987809702.54848599
+        timetuple = time.localtime(now)
+        if timetuple[-1] == 0:
+            tzsecs = time.timezone
+        else:
+            tzsecs = time.altzone
+        if tzsecs > 0:
+            sign = '-'
+        else:
+            sign = '+'
+        tzoffset = ' %s%04d' % (sign, tzsecs / 36)
+        container['Date'] = time.strftime(
+            '%a, %d %b %Y %H:%M:%S',
+            time.localtime(now)) + tzoffset
+        self._msg = container
+        self._im = image
+        self._txt = intro
+
+    def test_hierarchy(self):
+        # convenience
+        eq = self.assertEqual
+        raises = self.assertRaises
+        # tests
+        m = self._msg
+        self.assertTrue(m.is_multipart())
+        eq(m.get_content_type(), 'multipart/mixed')
+        eq(len(m.get_payload()), 2)
+        raises(IndexError, m.get_payload, 2)
+        m0 = m.get_payload(0)
+        m1 = m.get_payload(1)
+        self.assertIs(m0, self._txt)
+        self.assertIs(m1, self._im)
+        eq(m.get_payload(), [m0, m1])
+        self.assertFalse(m0.is_multipart())
+        self.assertFalse(m1.is_multipart())
+
+    def test_empty_multipart_idempotent(self):
+        text = """\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+
+
+--BOUNDARY--
+"""
+        msg = Parser().parsestr(text)
+        self.ndiffAssertEqual(text, msg.as_string())
+
+    def test_no_parts_in_a_multipart_with_none_epilogue(self):
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.set_boundary('BOUNDARY')
+        self.ndiffAssertEqual(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+
+--BOUNDARY--
+''')
+
+    def test_no_parts_in_a_multipart_with_empty_epilogue(self):
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = ''
+        outer.epilogue = ''
+        outer.set_boundary('BOUNDARY')
+        self.ndiffAssertEqual(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+
+--BOUNDARY--
+''')
+
+    def test_one_part_in_a_multipart(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.set_boundary('BOUNDARY')
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+    def test_seq_parts_in_a_multipart_with_empty_preamble(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = ''
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_none_preamble(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = None
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_none_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = None
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_empty_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = ''
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_nl_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = '\n'
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+
+''')
+
+    def test_message_external_body(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_36.txt')
+        eq(len(msg.get_payload()), 2)
+        msg1 = msg.get_payload(1)
+        eq(msg1.get_content_type(), 'multipart/alternative')
+        eq(len(msg1.get_payload()), 2)
+        for subpart in msg1.get_payload():
+            eq(subpart.get_content_type(), 'message/external-body')
+            eq(len(subpart.get_payload()), 1)
+            subsubpart = subpart.get_payload(0)
+            eq(subsubpart.get_content_type(), 'text/plain')
+
+    def test_double_boundary(self):
+        # msg_37.txt is a multipart that contains two dash-boundary's in a
+        # row.  Our interpretation of RFC 2046 calls for ignoring the second
+        # and subsequent boundaries.
+        msg = self._msgobj('msg_37.txt')
+        self.assertEqual(len(msg.get_payload()), 3)
+
+    def test_nested_inner_contains_outer_boundary(self):
+        eq = self.ndiffAssertEqual
+        # msg_38.txt has an inner part that contains outer boundaries.  My
+        # interpretation of RFC 2046 (based on sections 5.1 and 5.1.2) say
+        # these are illegal and should be interpreted as unterminated inner
+        # parts.
+        msg = self._msgobj('msg_38.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/mixed
+    multipart/mixed
+        multipart/alternative
+            text/plain
+        text/plain
+    text/plain
+    text/plain
+""")
+
+    def test_nested_with_same_boundary(self):
+        eq = self.ndiffAssertEqual
+        # msg 39.txt is similarly evil in that it's got inner parts that use
+        # the same boundary as outer parts.  Again, I believe the way this is
+        # parsed is closest to the spirit of RFC 2046
+        msg = self._msgobj('msg_39.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/mixed
+    multipart/mixed
+        multipart/alternative
+        application/octet-stream
+        application/octet-stream
+    text/plain
+""")
+
+    def test_boundary_in_non_multipart(self):
+        msg = self._msgobj('msg_40.txt')
+        self.assertEqual(msg.as_string(), '''\
+MIME-Version: 1.0
+Content-Type: text/html; boundary="--961284236552522269"
+
+----961284236552522269
+Content-Type: text/html;
+Content-Transfer-Encoding: 7Bit
+
+<html></html>
+
+----961284236552522269--
+''')
+
+    def test_boundary_with_leading_space(self):
+        eq = self.assertEqual
+        msg = email.message_from_string('''\
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="    XXXX"
+
+--    XXXX
+Content-Type: text/plain
+
+
+--    XXXX
+Content-Type: text/plain
+
+--    XXXX--
+''')
+        self.assertTrue(msg.is_multipart())
+        eq(msg.get_boundary(), '    XXXX')
+        eq(len(msg.get_payload()), 2)
+
+    def test_boundary_without_trailing_newline(self):
+        m = Parser().parsestr("""\
+Content-Type: multipart/mixed; boundary="===============0012394164=="
+MIME-Version: 1.0
+
+--===============0012394164==
+Content-Type: image/file1.jpg
+MIME-Version: 1.0
+Content-Transfer-Encoding: base64
+
+YXNkZg==
+--===============0012394164==--""")
+        self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
+
+    def test_mimebase_default_policy(self):
+        m = MIMEBase('multipart', 'mixed')
+        self.assertIs(m.policy, email.policy.compat32)
+
+    def test_mimebase_custom_policy(self):
+        m = MIMEBase('multipart', 'mixed', policy=email.policy.default)
+        self.assertIs(m.policy, email.policy.default)
+
+# Test some badly formatted messages
+class TestNonConformant(TestEmailBase):
+
+    def test_parse_missing_minor_type(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_14.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+
+    # test_defect_handling
+    def test_same_boundary_inner_outer(self):
+        msg = self._msgobj('msg_15.txt')
+        # XXX We can probably eventually do better
+        inner = msg.get_payload(0)
+        self.assertHasAttr(inner, 'defects')
+        self.assertEqual(len(inner.defects), 1)
+        self.assertIsInstance(inner.defects[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    # test_defect_handling
+    def test_multipart_no_boundary(self):
+        msg = self._msgobj('msg_25.txt')
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertEqual(len(msg.defects), 2)
+        self.assertIsInstance(msg.defects[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(msg.defects[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    multipart_msg = textwrap.dedent("""\
+        Date: Wed, 14 Nov 2007 12:56:23 GMT
+        From: foo@bar.invalid
+        To: foo@bar.invalid
+        Subject: Content-Transfer-Encoding: base64 and multipart
+        MIME-Version: 1.0
+        Content-Type: multipart/mixed;
+            boundary="===============3344438784458119861=="{}
+
+        --===============3344438784458119861==
+        Content-Type: text/plain
+
+        Test message
+
+        --===============3344438784458119861==
+        Content-Type: application/octet-stream
+        Content-Transfer-Encoding: base64
+
+        YWJj
+
+        --===============3344438784458119861==--
+        """)
+
+    # test_defect_handling
+    def test_multipart_invalid_cte(self):
+        msg = self._str_msg(
+            self.multipart_msg.format("\nContent-Transfer-Encoding: base64"))
+        self.assertEqual(len(msg.defects), 1)
+        self.assertIsInstance(msg.defects[0],
+            errors.InvalidMultipartContentTransferEncodingDefect)
+
+    # test_defect_handling
+    def test_multipart_no_cte_no_defect(self):
+        msg = self._str_msg(self.multipart_msg.format(''))
+        self.assertEqual(len(msg.defects), 0)
+
+    # test_defect_handling
+    def test_multipart_valid_cte_no_defect(self):
+        for cte in ('7bit', '8bit', 'BINary'):
+            msg = self._str_msg(
+                self.multipart_msg.format(
+                    "\nContent-Transfer-Encoding: {}".format(cte)))
+            self.assertEqual(len(msg.defects), 0)
+
+    # test_headerregistry.TestContentTypeHeader invalid_1 and invalid_2.
+    def test_invalid_content_type(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        msg = Message()
+        # RFC 2045, $5.2 says invalid yields text/plain
+        msg['Content-Type'] = 'text'
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_content_type(), 'text/plain')
+        # Clear the old value and try something /really/ invalid
+        del msg['content-type']
+        msg['Content-Type'] = 'foo'
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_content_type(), 'text/plain')
+        # Still, make sure that the message is idempotently generated
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(msg)
+        neq(s.getvalue(), 'Content-Type: foo\n\n')
+
+    def test_no_start_boundary(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_31.txt')
+        eq(msg.get_payload(), """\
+--BOUNDARY
+Content-Type: text/plain
+
+message 1
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 2
+
+--BOUNDARY--
+""")
+
+    def test_no_separating_blank_line(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_35.txt')
+        eq(msg.as_string(), """\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: here's something interesting
+
+counter to RFC 5322, there's no separating newline here
+""")
+
+    # test_defect_handling
+    def test_lying_multipart(self):
+        msg = self._msgobj('msg_41.txt')
+        self.assertHasAttr(msg, 'defects')
+        self.assertEqual(len(msg.defects), 2)
+        self.assertIsInstance(msg.defects[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(msg.defects[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    # test_defect_handling
+    def test_missing_start_boundary(self):
+        outer = self._msgobj('msg_42.txt')
+        # The message structure is:
+        #
+        # multipart/mixed
+        #    text/plain
+        #    message/rfc822
+        #        multipart/mixed [*]
+        #
+        # [*] This message is missing its start boundary
+        bad = outer.get_payload(1).get_payload(0)
+        self.assertEqual(len(bad.defects), 1)
+        self.assertIsInstance(bad.defects[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    # test_defect_handling
+    def test_first_line_is_continuation_header(self):
+        eq = self.assertEqual
+        m = ' Line 1\nSubject: test\n\nbody'
+        msg = email.message_from_string(m)
+        eq(msg.keys(), ['Subject'])
+        eq(msg.get_payload(), 'body')
+        eq(len(msg.defects), 1)
+        self.assertDefectsEqual(msg.defects,
+                                 [errors.FirstHeaderLineIsContinuationDefect])
+        eq(msg.defects[0].line, ' Line 1\n')
+
+    # test_defect_handling
+    def test_missing_header_body_separator(self):
+        # Our heuristic if we see a line that doesn't look like a header (no
+        # leading whitespace but no ':') is to assume that the blank line that
+        # separates the header from the body is missing, and to stop parsing
+        # headers and start parsing the body.
+        msg = self._str_msg('Subject: test\nnot a header\nTo: abc\n\nb\n')
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'not a header\nTo: abc\n\nb\n')
+        self.assertDefectsEqual(msg.defects,
+                                [errors.MissingHeaderBodySeparatorDefect])
+
+    def test_string_payload_with_extra_space_after_cte(self):
+        # https://github.com/python/cpython/issues/98188
+        cte = "base64 "
+        msg = email.message_from_string(textwrap.dedent(f"""\
+        Content-Transfer-Encoding: {cte}
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg['content-transfer-encoding'].defects, [])
+
+    def test_string_payload_with_extra_text_after_cte(self):
+        msg = email.message_from_string(textwrap.dedent("""\
+        Content-Transfer-Encoding: base64 some text
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        cte = msg['content-transfer-encoding']
+        self.assertDefectsEqual(cte.defects, [email.errors.InvalidHeaderDefect])
+
+    def test_string_payload_with_extra_space_after_cte_compat32(self):
+        cte = "base64 "
+        msg = email.message_from_string(textwrap.dedent(f"""\
+        Content-Transfer-Encoding: {cte}
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.compat32)
+        pasted_cte = msg['content-transfer-encoding']
+        self.assertEqual(pasted_cte, cte)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg.defects, [])
+
+
+
+# Test RFC 2047 header encoding and decoding
+class TestRFC2047(TestEmailBase):
+    def test_rfc2047_multiline(self):
+        eq = self.assertEqual
+        s = """Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz
+ foo bar =?mac-iceland?q?r=8Aksm=9Arg=8Cs?="""
+        dh = decode_header(s)
+        eq(dh, [
+            (b'Re: ', None),
+            (b'r\x8aksm\x9arg\x8cs', 'mac-iceland'),
+            (b' baz foo bar ', None),
+            (b'r\x8aksm\x9arg\x8cs', 'mac-iceland')])
+        header = make_header(dh)
+        eq(str(header),
+           'Re: r\xe4ksm\xf6rg\xe5s baz foo bar r\xe4ksm\xf6rg\xe5s')
+        self.ndiffAssertEqual(header.encode(maxlinelen=76), """\
+Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz foo bar =?mac-iceland?q?r=8Aksm?=
+ =?mac-iceland?q?=9Arg=8Cs?=""")
+
+    def test_whitespace_keeper_unicode(self):
+        eq = self.assertEqual
+        s = '=?ISO-8859-1?Q?Andr=E9?= Pirard <pirard@dom.ain>'
+        dh = decode_header(s)
+        eq(dh, [(b'Andr\xe9', 'iso-8859-1'),
+                (b' Pirard <pirard@dom.ain>', None)])
+        header = str(make_header(dh))
+        eq(header, 'Andr\xe9 Pirard <pirard@dom.ain>')
+
+    def test_whitespace_keeper_unicode_2(self):
+        eq = self.assertEqual
+        s = 'The =?iso-8859-1?b?cXVpY2sgYnJvd24gZm94?= jumped over the =?iso-8859-1?b?bGF6eSBkb2c=?='
+        dh = decode_header(s)
+        eq(dh, [(b'The ', None), (b'quick brown fox', 'iso-8859-1'),
+                (b' jumped over the ', None), (b'lazy dog', 'iso-8859-1')])
+        hu = str(make_header(dh))
+        eq(hu, 'The quick brown fox jumped over the lazy dog')
+
+    def test_rfc2047_missing_whitespace(self):
+        s = 'Sm=?ISO-8859-1?B?9g==?=rg=?ISO-8859-1?B?5Q==?=sbord'
+        dh = decode_header(s)
+        self.assertEqual(dh, [(b'Sm', None), (b'\xf6', 'iso-8859-1'),
+                              (b'rg', None), (b'\xe5', 'iso-8859-1'),
+                              (b'sbord', None)])
+
+    def test_rfc2047_with_whitespace(self):
+        s = 'Sm =?ISO-8859-1?B?9g==?= rg =?ISO-8859-1?B?5Q==?= sbord'
+        dh = decode_header(s)
+        self.assertEqual(dh, [(b'Sm ', None), (b'\xf6', 'iso-8859-1'),
+                              (b' rg ', None), (b'\xe5', 'iso-8859-1'),
+                              (b' sbord', None)])
+
+    def test_rfc2047_B_bad_padding(self):
+        s = '=?iso-8859-1?B?%s?='
+        data = [                                # only test complete bytes
+            ('dm==', b'v'), ('dm=', b'v'), ('dm', b'v'),
+            ('dmk=', b'vi'), ('dmk', b'vi')
+          ]
+        for q, a in data:
+            dh = decode_header(s % q)
+            self.assertEqual(dh, [(a, 'iso-8859-1')])
+
+    def test_rfc2047_Q_invalid_digits(self):
+        # issue 10004.
+        s = '=?iso-8859-1?Q?andr=e9=zz?='
+        self.assertEqual(decode_header(s),
+                        [(b'andr\xe9=zz', 'iso-8859-1')])
+
+    def test_rfc2047_rfc2047_1(self):
+        # 1st testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_2(self):
+        # 2nd testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= b)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b' b)', None)])
+
+    def test_rfc2047_rfc2047_3(self):
+        # 3rd testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_4(self):
+        # 4th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?=  =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_5a(self):
+        # 5th testcase at end of RFC 2047 newline is \r\n
+        s = '(=?ISO-8859-1?Q?a?=\r\n    =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_5b(self):
+        # 5th testcase at end of RFC 2047 newline is \n
+        s = '(=?ISO-8859-1?Q?a?=\n    =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_6(self):
+        # 6th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a_b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a b', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_7(self):
+        # 7th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= =?ISO-8859-2?Q?_b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b' b', 'iso-8859-2'),
+             (b')', None)])
+        self.assertEqual(make_header(decode_header(s)).encode(), s.lower())
+        self.assertEqual(str(make_header(decode_header(s))), '(a b)')
+
+    def test_multiline_header(self):
+        s = '=?windows-1252?q?=22M=FCller_T=22?=\r\n <T.Mueller@xxx.com>'
+        self.assertEqual(decode_header(s),
+            [(b'"M\xfcller T"', 'windows-1252'),
+             (b'<T.Mueller@xxx.com>', None)])
+        self.assertEqual(make_header(decode_header(s)).encode(),
+                         ''.join(s.splitlines()))
+        self.assertEqual(str(make_header(decode_header(s))),
+                         '"Müller T" <T.Mueller@xxx.com>')
+
+    def test_unencoded_ascii(self):
+        # bpo-22833/gh-67022: returns [(str, None)] rather than [(bytes, None)]
+        s = 'header without encoded words'
+        self.assertEqual(decode_header(s),
+            [('header without encoded words', None)])
+
+    def test_unencoded_utf8(self):
+        # bpo-22833/gh-67022: returns [(str, None)] rather than [(bytes, None)]
+        s = 'header with unexpected non ASCII caract\xe8res'
+        self.assertEqual(decode_header(s),
+            [('header with unexpected non ASCII caract\xe8res', None)])
+
+
+# Test the MIMEMessage class
+class TestMIMEMessage(TestEmailBase):
+    def setUp(self):
+        with openfile('msg_11.txt', encoding="utf-8") as fp:
+            self._text = fp.read()
+
+    def test_type_error(self):
+        self.assertRaises(TypeError, MIMEMessage, 'a plain string')
+
+    def test_valid_argument(self):
+        eq = self.assertEqual
+        subject = 'A sub-message'
+        m = Message()
+        m['Subject'] = subject
+        r = MIMEMessage(m)
+        eq(r.get_content_type(), 'message/rfc822')
+        payload = r.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        subpart = payload[0]
+        self.assertIs(subpart, m)
+        eq(subpart['subject'], subject)
+
+    def test_bad_multipart(self):
+        msg1 = Message()
+        msg1['Subject'] = 'subpart 1'
+        msg2 = Message()
+        msg2['Subject'] = 'subpart 2'
+        r = MIMEMessage(msg1)
+        self.assertRaises(errors.MultipartConversionError, r.attach, msg2)
+
+    def test_generate(self):
+        # First craft the message to be encapsulated
+        m = Message()
+        m['Subject'] = 'An enclosed message'
+        m.set_payload('Here is the body of the message.\n')
+        r = MIMEMessage(m)
+        r['Subject'] = 'The enclosing message'
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(r)
+        self.assertEqual(s.getvalue(), """\
+Content-Type: message/rfc822
+MIME-Version: 1.0
+Subject: The enclosing message
+
+Subject: An enclosed message
+
+Here is the body of the message.
+""")
+
+    def test_parse_message_rfc822(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_11.txt')
+        eq(msg.get_content_type(), 'message/rfc822')
+        payload = msg.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        submsg = payload[0]
+        self.assertIsInstance(submsg, Message)
+        eq(submsg['subject'], 'An enclosed message')
+        eq(submsg.get_payload(), 'Here is the body of the message.\n')
+
+    def test_dsn(self):
+        eq = self.assertEqual
+        # msg 16 is a Delivery Status Notification, see RFC 1894
+        msg = self._msgobj('msg_16.txt')
+        eq(msg.get_content_type(), 'multipart/report')
+        self.assertTrue(msg.is_multipart())
+        eq(len(msg.get_payload()), 3)
+        # Subpart 1 is a text/plain, human readable section
+        subpart = msg.get_payload(0)
+        eq(subpart.get_content_type(), 'text/plain')
+        eq(subpart.get_payload(), """\
+This report relates to a message you sent with the following header fields:
+
+  Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+  Date: Sun, 23 Sep 2001 20:10:55 -0700
+  From: "Ian T. Henry" <henryi@oxy.edu>
+  To: SoCal Raves <scr@socal-raves.org>
+  Subject: [scr] yeah for Ians!!
+
+Your message cannot be delivered to the following recipients:
+
+  Recipient address: jangel1@cougar.noc.ucla.edu
+  Reason: recipient reached disk quota
+
+""")
+        # Subpart 2 contains the machine parsable DSN information.  It
+        # consists of two blocks of headers, represented by two nested Message
+        # objects.
+        subpart = msg.get_payload(1)
+        eq(subpart.get_content_type(), 'message/delivery-status')
+        eq(len(subpart.get_payload()), 2)
+        # message/delivery-status should treat each block as a bunch of
+        # headers, i.e. a bunch of Message objects.
+        dsn1 = subpart.get_payload(0)
+        self.assertIsInstance(dsn1, Message)
+        eq(dsn1['original-envelope-id'], '0GK500B4HD0888@cougar.noc.ucla.edu')
+        eq(dsn1.get_param('dns', header='reporting-mta'), '')
+        # Try a missing one <wink>
+        eq(dsn1.get_param('nsd', header='reporting-mta'), None)
+        dsn2 = subpart.get_payload(1)
+        self.assertIsInstance(dsn2, Message)
+        eq(dsn2['action'], 'failed')
+        eq(dsn2.get_params(header='original-recipient'),
+           [('rfc822', ''), ('jangel1@cougar.noc.ucla.edu', '')])
+        eq(dsn2.get_param('rfc822', header='final-recipient'), '')
+        # Subpart 3 is the original message
+        subpart = msg.get_payload(2)
+        eq(subpart.get_content_type(), 'message/rfc822')
+        payload = subpart.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        subsubpart = payload[0]
+        self.assertIsInstance(subsubpart, Message)
+        eq(subsubpart.get_content_type(), 'text/plain')
+        eq(subsubpart['message-id'],
+           '<002001c144a6$8752e060$56104586@oxy.edu>')
+
+    def test_epilogue(self):
+        eq = self.ndiffAssertEqual
+        with openfile('msg_21.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = Message()
+        msg['From'] = 'aperson@dom.ain'
+        msg['To'] = 'bperson@dom.ain'
+        msg['Subject'] = 'Test'
+        msg.preamble = 'MIME message'
+        msg.epilogue = 'End of MIME message\n'
+        msg1 = MIMEText('One')
+        msg2 = MIMEText('Two')
+        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
+        msg.attach(msg1)
+        msg.attach(msg2)
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), text)
+
+    def test_no_nl_preamble(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'aperson@dom.ain'
+        msg['To'] = 'bperson@dom.ain'
+        msg['Subject'] = 'Test'
+        msg.preamble = 'MIME message'
+        msg.epilogue = ''
+        msg1 = MIMEText('One')
+        msg2 = MIMEText('Two')
+        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
+        msg.attach(msg1)
+        msg.attach(msg2)
+        eq(msg.as_string(), """\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: Test
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+MIME message
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+One
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+Two
+--BOUNDARY--
+""")
+
+    def test_default_type(self):
+        eq = self.assertEqual
+        with openfile('msg_30.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        container1 = msg.get_payload(0)
+        eq(container1.get_default_type(), 'message/rfc822')
+        eq(container1.get_content_type(), 'message/rfc822')
+        container2 = msg.get_payload(1)
+        eq(container2.get_default_type(), 'message/rfc822')
+        eq(container2.get_content_type(), 'message/rfc822')
+        container1a = container1.get_payload(0)
+        eq(container1a.get_default_type(), 'text/plain')
+        eq(container1a.get_content_type(), 'text/plain')
+        container2a = container2.get_payload(0)
+        eq(container2a.get_default_type(), 'text/plain')
+        eq(container2a.get_content_type(), 'text/plain')
+
+    def test_default_type_with_explicit_container_type(self):
+        eq = self.assertEqual
+        with openfile('msg_28.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        container1 = msg.get_payload(0)
+        eq(container1.get_default_type(), 'message/rfc822')
+        eq(container1.get_content_type(), 'message/rfc822')
+        container2 = msg.get_payload(1)
+        eq(container2.get_default_type(), 'message/rfc822')
+        eq(container2.get_content_type(), 'message/rfc822')
+        container1a = container1.get_payload(0)
+        eq(container1a.get_default_type(), 'text/plain')
+        eq(container1a.get_content_type(), 'text/plain')
+        container2a = container2.get_payload(0)
+        eq(container2a.get_default_type(), 'text/plain')
+        eq(container2a.get_content_type(), 'text/plain')
+
+    def test_default_type_non_parsed(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        # Set up container
+        container = MIMEMultipart('digest', 'BOUNDARY')
+        container.epilogue = ''
+        # Set up subparts
+        subpart1a = MIMEText('message 1\n')
+        subpart2a = MIMEText('message 2\n')
+        subpart1 = MIMEMessage(subpart1a)
+        subpart2 = MIMEMessage(subpart2a)
+        container.attach(subpart1)
+        container.attach(subpart2)
+        eq(subpart1.get_content_type(), 'message/rfc822')
+        eq(subpart1.get_default_type(), 'message/rfc822')
+        eq(subpart2.get_content_type(), 'message/rfc822')
+        eq(subpart2.get_default_type(), 'message/rfc822')
+        neq(container.as_string(0), '''\
+Content-Type: multipart/digest; boundary="BOUNDARY"
+MIME-Version: 1.0
+
+--BOUNDARY
+Content-Type: message/rfc822
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 1
+
+--BOUNDARY
+Content-Type: message/rfc822
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 2
+
+--BOUNDARY--
+''')
+        del subpart1['content-type']
+        del subpart1['mime-version']
+        del subpart2['content-type']
+        del subpart2['mime-version']
+        eq(subpart1.get_content_type(), 'message/rfc822')
+        eq(subpart1.get_default_type(), 'message/rfc822')
+        eq(subpart2.get_content_type(), 'message/rfc822')
+        eq(subpart2.get_default_type(), 'message/rfc822')
+        neq(container.as_string(0), '''\
+Content-Type: multipart/digest; boundary="BOUNDARY"
+MIME-Version: 1.0
+
+--BOUNDARY
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 1
+
+--BOUNDARY
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 2
+
+--BOUNDARY--
+''')
+
+    def test_mime_attachments_in_constructor(self):
+        eq = self.assertEqual
+        text1 = MIMEText('')
+        text2 = MIMEText('')
+        msg = MIMEMultipart(_subparts=(text1, text2))
+        eq(len(msg.get_payload()), 2)
+        eq(msg.get_payload(0), text1)
+        eq(msg.get_payload(1), text2)
+
+    def test_default_multipart_constructor(self):
+        msg = MIMEMultipart()
+        self.assertTrue(msg.is_multipart())
+
+    def test_multipart_default_policy(self):
+        msg = MIMEMultipart()
+        msg['To'] = 'a@b.com'
+        msg['To'] = 'c@d.com'
+        self.assertEqual(msg.get_all('to'), ['a@b.com', 'c@d.com'])
+
+    def test_multipart_custom_policy(self):
+        msg = MIMEMultipart(policy=email.policy.default)
+        msg['To'] = 'a@b.com'
+        with self.assertRaises(ValueError) as cm:
+            msg['To'] = 'c@d.com'
+        self.assertEqual(str(cm.exception),
+                         'There may be at most 1 To headers in a message')
+
+
+# Test the NonMultipart class
+class TestNonMultipart(TestEmailBase):
+    def test_nonmultipart_is_not_multipart(self):
+        msg = MIMENonMultipart('text', 'plain')
+        self.assertFalse(msg.is_multipart())
+
+    def test_attach_raises_exception(self):
+        msg = Message()
+        msg['Subject'] = 'subpart 1'
+        r = MIMENonMultipart('text', 'plain')
+        self.assertRaises(errors.MultipartConversionError, r.attach, msg)
+
+
+# A general test of parser->model->generator idempotency.  IOW, read a message
+# in, parse it into a message object tree, then without touching the tree,
+# regenerate the plain text.  The original text and the transformed text
+# should be identical.  Note: that we ignore the Unix-From since that may
+# contain a changed date.
+class TestIdempotent(TestEmailBase):
+
+    linesep = '\n'
+
+    def _msgobj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            data = fp.read()
+        msg = email.message_from_string(data)
+        return msg, data
+
+    def _idempotent(self, msg, text, unixfrom=False):
+        eq = self.ndiffAssertEqual
+        s = StringIO()
+        g = Generator(s, maxheaderlen=0)
+        g.flatten(msg, unixfrom=unixfrom)
+        eq(text, s.getvalue())
+
+    def test_parse_text_message(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_01.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_params()[1], ('charset', 'us-ascii'))
+        eq(msg.get_param('charset'), 'us-ascii')
+        eq(msg.preamble, None)
+        eq(msg.epilogue, None)
+        self._idempotent(msg, text)
+
+    def test_parse_untyped_message(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_03.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_params(), None)
+        eq(msg.get_param('charset'), None)
+        self._idempotent(msg, text)
+
+    def test_simple_multipart(self):
+        msg, text = self._msgobj('msg_04.txt')
+        self._idempotent(msg, text)
+
+    def test_MIME_digest(self):
+        msg, text = self._msgobj('msg_02.txt')
+        self._idempotent(msg, text)
+
+    def test_long_header(self):
+        msg, text = self._msgobj('msg_27.txt')
+        self._idempotent(msg, text)
+
+    def test_MIME_digest_with_part_headers(self):
+        msg, text = self._msgobj('msg_28.txt')
+        self._idempotent(msg, text)
+
+    def test_mixed_with_image(self):
+        msg, text = self._msgobj('msg_06.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_report(self):
+        msg, text = self._msgobj('msg_05.txt')
+        self._idempotent(msg, text)
+
+    def test_dsn(self):
+        msg, text = self._msgobj('msg_16.txt')
+        self._idempotent(msg, text)
+
+    def test_preamble_epilogue(self):
+        msg, text = self._msgobj('msg_21.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_one_part(self):
+        msg, text = self._msgobj('msg_23.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_no_parts(self):
+        msg, text = self._msgobj('msg_24.txt')
+        self._idempotent(msg, text)
+
+    def test_no_start_boundary(self):
+        msg, text = self._msgobj('msg_31.txt')
+        self._idempotent(msg, text)
+
+    def test_rfc2231_charset(self):
+        msg, text = self._msgobj('msg_32.txt')
+        self._idempotent(msg, text)
+
+    def test_more_rfc2231_parameters(self):
+        msg, text = self._msgobj('msg_33.txt')
+        self._idempotent(msg, text)
+
+    def test_text_plain_in_a_multipart_digest(self):
+        msg, text = self._msgobj('msg_34.txt')
+        self._idempotent(msg, text)
+
+    def test_nested_multipart_mixeds(self):
+        msg, text = self._msgobj('msg_12a.txt')
+        self._idempotent(msg, text)
+
+    def test_message_external_body_idempotent(self):
+        msg, text = self._msgobj('msg_36.txt')
+        self._idempotent(msg, text)
+
+    def test_message_delivery_status(self):
+        msg, text = self._msgobj('msg_43.txt')
+        self._idempotent(msg, text, unixfrom=True)
+
+    def test_message_signed_idempotent(self):
+        msg, text = self._msgobj('msg_45.txt')
+        self._idempotent(msg, text)
+
+    def test_content_type(self):
+        eq = self.assertEqual
+        # Get a message object and reset the seek pointer for other tests
+        msg, text = self._msgobj('msg_05.txt')
+        eq(msg.get_content_type(), 'multipart/report')
+        # Test the Content-Type: parameters
+        params = {}
+        for pk, pv in msg.get_params():
+            params[pk] = pv
+        eq(params['report-type'], 'delivery-status')
+        eq(params['boundary'], 'D1690A7AC1.996856090/mail.example.com')
+        eq(msg.preamble, 'This is a MIME-encapsulated message.' + self.linesep)
+        eq(msg.epilogue, self.linesep)
+        eq(len(msg.get_payload()), 3)
+        # Make sure the subparts are what we expect
+        msg1 = msg.get_payload(0)
+        eq(msg1.get_content_type(), 'text/plain')
+        eq(msg1.get_payload(), 'Yadda yadda yadda' + self.linesep)
+        msg2 = msg.get_payload(1)
+        eq(msg2.get_content_type(), 'text/plain')
+        eq(msg2.get_payload(), 'Yadda yadda yadda' + self.linesep)
+        msg3 = msg.get_payload(2)
+        eq(msg3.get_content_type(), 'message/rfc822')
+        self.assertIsInstance(msg3, Message)
+        payload = msg3.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        msg4 = payload[0]
+        self.assertIsInstance(msg4, Message)
+        eq(msg4.get_payload(), 'Yadda yadda yadda' + self.linesep)
+
+    def test_parser(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_06.txt')
+        # Check some of the outer headers
+        eq(msg.get_content_type(), 'message/rfc822')
+        # Make sure the payload is a list of exactly one sub-Message, and that
+        # that submessage has a type of text/plain
+        payload = msg.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        msg1 = payload[0]
+        self.assertIsInstance(msg1, Message)
+        eq(msg1.get_content_type(), 'text/plain')
+        self.assertIsInstance(msg1.get_payload(), str)
+        eq(msg1.get_payload(), self.linesep)
+
+
+
+# Test various other bits of the package's functionality
+class TestMiscellaneous(TestEmailBase):
+    def test_message_from_string(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = email.message_from_string(text)
+        s = StringIO()
+        # Don't wrap/continue long headers since we're trying to test
+        # idempotency.
+        g = Generator(s, maxheaderlen=0)
+        g.flatten(msg)
+        self.assertEqual(text, s.getvalue())
+
+    def test_message_from_file(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+            fp.seek(0)
+            msg = email.message_from_file(fp)
+            s = StringIO()
+            # Don't wrap/continue long headers since we're trying to test
+            # idempotency.
+            g = Generator(s, maxheaderlen=0)
+            g.flatten(msg)
+            self.assertEqual(text, s.getvalue())
+
+    def test_message_from_string_with_class(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+
+        msg = email.message_from_string(text, MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+        # Try something more complicated
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = email.message_from_string(text, MyMessage)
+        for subpart in msg.walk():
+            self.assertIsInstance(subpart, MyMessage)
+
+    def test_message_from_file_with_class(self):
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp, MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+        # Try something more complicated
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp, MyMessage)
+        for subpart in msg.walk():
+            self.assertIsInstance(subpart, MyMessage)
+
+    def test_custom_message_does_not_require_arguments(self):
+        class MyMessage(Message):
+            def __init__(self):
+                super().__init__()
+        msg = self._str_msg("Subject: test\n\ntest", MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+
+    def test__all__(self):
+        module = __import__('email')
+        self.assertEqual(sorted(module.__all__), [
+            'base64mime', 'charset', 'encoders', 'errors', 'feedparser',
+            'generator', 'header', 'iterators', 'message',
+            'message_from_binary_file', 'message_from_bytes',
+            'message_from_file', 'message_from_string', 'mime', 'parser',
+            'quoprimime', 'utils',
+            ])
+
+    def test_formatdate(self):
+        now = time.time()
+        self.assertEqual(utils.parsedate(utils.formatdate(now))[:6],
+                         time.gmtime(now)[:6])
+
+    def test_formatdate_localtime(self):
+        now = time.time()
+        self.assertEqual(
+            utils.parsedate(utils.formatdate(now, localtime=True))[:6],
+            time.localtime(now)[:6])
+
+    def test_formatdate_usegmt(self):
+        now = time.time()
+        self.assertEqual(
+            utils.formatdate(now, localtime=False),
+            time.strftime('%a, %d %b %Y %H:%M:%S -0000', time.gmtime(now)))
+        self.assertEqual(
+            utils.formatdate(now, localtime=False, usegmt=True),
+            time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(now)))
+
+    # parsedate and parsedate_tz will become deprecated interfaces someday
+    def test_parsedate_returns_None_for_invalid_strings(self):
+        # See also test_parsedate_to_datetime_with_invalid_raises_valueerror
+        # in test_utils.
+        invalid_dates = [
+            '',
+            ' ',
+            '0',
+            'A Complete Waste of Time',
+            'Wed, 3 Apr 2002 12.34.56.78+0800',
+            '17 June , 2022',
+            'Friday, -Nov-82 16:14:55 EST',
+            'Friday, Nov--82 16:14:55 EST',
+            'Friday, 19-Nov- 16:14:55 EST',
+        ]
+        for dtstr in invalid_dates:
+            with self.subTest(dtstr=dtstr):
+                self.assertIsNone(utils.parsedate(dtstr))
+                self.assertIsNone(utils.parsedate_tz(dtstr))
+        # Not a part of the spec but, but this has historically worked:
+        self.assertIsNone(utils.parsedate(None))
+        self.assertIsNone(utils.parsedate_tz(None))
+
+    def test_parsedate_compact(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        # The FWS after the comma is optional
+        self.assertEqual(utils.parsedate_tz('Wed,3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        # The comma is optional
+        self.assertEqual(utils.parsedate_tz('Wed 3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+
+    def test_parsedate_no_dayofweek(self):
+        eq = self.assertEqual
+        eq(utils.parsedate_tz('5 Feb 2003 13:47:26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+        eq(utils.parsedate_tz('February 5, 2003 13:47:26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+
+    def test_parsedate_no_space_before_positive_offset(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26+0800'),
+           (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+
+    def test_parsedate_no_space_before_negative_offset(self):
+        # Issue 1155362: we already handled '+' for this case.
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26-0800'),
+           (2002, 4, 3, 14, 58, 26, 0, 1, -1, -28800))
+
+    def test_parsedate_accepts_time_with_dots(self):
+        eq = self.assertEqual
+        eq(utils.parsedate_tz('5 Feb 2003 13.47.26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+        eq(utils.parsedate_tz('5 Feb 2003 13.47 -0800'),
+           (2003, 2, 5, 13, 47, 0, 0, 1, -1, -28800))
+
+    def test_parsedate_rfc_850(self):
+        self.assertEqual(utils.parsedate_tz('Friday, 19-Nov-82 16:14:55 EST'),
+           (1982, 11, 19, 16, 14, 55, 0, 1, -1, -18000))
+
+    def test_parsedate_no_seconds(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58 +0800'),
+                         (2002, 4, 3, 14, 58, 0, 0, 1, -1, 28800))
+
+    def test_parsedate_dot_time_delimiter(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58.26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58 +0800'),
+                         (2002, 4, 3, 14, 58, 0, 0, 1, -1, 28800))
+
+    def test_parsedate_acceptable_to_time_functions(self):
+        eq = self.assertEqual
+        timetup = utils.parsedate('5 Feb 2003 13:47:26 -0800')
+        t = int(time.mktime(timetup))
+        eq(time.localtime(t)[:6], timetup[:6])
+        eq(int(time.strftime('%Y', timetup)), 2003)
+        timetup = utils.parsedate_tz('5 Feb 2003 13:47:26 -0800')
+        t = int(time.mktime(timetup[:9]))
+        eq(time.localtime(t)[:6], timetup[:6])
+        eq(int(time.strftime('%Y', timetup[:9])), 2003)
+
+    def test_mktime_tz(self):
+        self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
+                                          -1, -1, -1, 0)), 0)
+        self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
+                                          -1, -1, -1, 1234)), -1234)
+
+    def test_parsedate_y2k(self):
+        """Test for parsing a date with a two-digit year.
+
+        Parsing a date with a two-digit year should return the correct
+        four-digit year. RFC 822 allows two-digit years, but RFC 5322 (which
+        obsoletes RFC 2822, which obsoletes RFC 822) requires four-digit years.
+
+        """
+        self.assertEqual(utils.parsedate_tz('25 Feb 03 13:47:26 -0800'),
+                         utils.parsedate_tz('25 Feb 2003 13:47:26 -0800'))
+        self.assertEqual(utils.parsedate_tz('25 Feb 71 13:47:26 -0800'),
+                         utils.parsedate_tz('25 Feb 1971 13:47:26 -0800'))
+
+    def test_parseaddr_empty(self):
+        self.assertEqual(utils.parseaddr('<>'), ('', ''))
+        self.assertEqual(utils.formataddr(utils.parseaddr('<>')), '')
+
+    def test_parseaddr_multiple_domains(self):
+        self.assertEqual(
+            utils.parseaddr('a@b@c'),
+            ('', '')
+        )
+        self.assertEqual(
+            utils.parseaddr('a@b.c@c'),
+            ('', '')
+        )
+        self.assertEqual(
+            utils.parseaddr('a@172.17.0.1@c'),
+            ('', '')
+        )
+
+    def test_noquote_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A Silly Person', 'person@dom.ain')),
+            'A Silly Person <person@dom.ain>')
+
+    def test_escape_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A (Very) Silly Person', 'person@dom.ain')),
+            r'"A (Very) Silly Person" <person@dom.ain>')
+        self.assertEqual(
+            utils.parseaddr(r'"A \(Very\) Silly Person" <person@dom.ain>'),
+            ('A (Very) Silly Person', 'person@dom.ain'))
+        a = r'A \(Special\) Person'
+        b = 'person@dom.ain'
+        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
+
+    def test_escape_backslashes(self):
+        self.assertEqual(
+            utils.formataddr((r'Arthur \Backslash\ Foobar', 'person@dom.ain')),
+            r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>')
+        a = r'Arthur \Backslash\ Foobar'
+        b = 'person@dom.ain'
+        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
+
+    def test_quotes_unicode_names(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        utf8_base64 = "=?utf-8?b?SMOkbnMgV8O8cnN0?= <person@dom.ain>"
+        latin1_quopri = "=?iso-8859-1?q?H=E4ns_W=FCrst?= <person@dom.ain>"
+        self.assertEqual(utils.formataddr((name, addr)), utf8_base64)
+        self.assertEqual(utils.formataddr((name, addr), 'iso-8859-1'),
+            latin1_quopri)
+
+    def test_accepts_any_charset_like_object(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        utf8_base64 = "=?utf-8?b?SMOkbnMgV8O8cnN0?= <person@dom.ain>"
+        foobar = "FOOBAR"
+        class CharsetMock:
+            def header_encode(self, string):
+                return foobar
+        mock = CharsetMock()
+        mock_expected = "%s <%s>" % (foobar, addr)
+        self.assertEqual(utils.formataddr((name, addr), mock), mock_expected)
+        self.assertEqual(utils.formataddr((name, addr), Charset('utf-8')),
+            utf8_base64)
+
+    def test_invalid_charset_like_object_raises_error(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        # An object without a header_encode method:
+        bad_charset = object()
+        self.assertRaises(AttributeError, utils.formataddr, (name, addr),
+            bad_charset)
+
+    def test_unicode_address_raises_error(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        addr = 'pers\u00f6n@dom.in'
+        self.assertRaises(UnicodeError, utils.formataddr, (None, addr))
+        self.assertRaises(UnicodeError, utils.formataddr, ("Name", addr))
+
+    def test_name_with_dot(self):
+        x = 'John X. Doe <jxd@example.com>'
+        y = '"John X. Doe" <jxd@example.com>'
+        a, b = ('John X. Doe', 'jxd@example.com')
+        self.assertEqual(utils.parseaddr(x), (a, b))
+        self.assertEqual(utils.parseaddr(y), (a, b))
+        # formataddr() quotes the name if there's a dot in it
+        self.assertEqual(utils.formataddr((a, b)), y)
+
+    def test_parseaddr_preserves_quoted_pairs_in_addresses(self):
+        # issue 10005.  Note that in the third test the second pair of
+        # backslashes is not actually a quoted pair because it is not inside a
+        # comment or quoted string: the address being parsed has a quoted
+        # string containing a quoted backslash, followed by 'example' and two
+        # backslashes, followed by another quoted string containing a space and
+        # the word 'example'.  parseaddr copies those two backslashes
+        # literally.  Per RFC 5322 this is not technically correct since a \ may
+        # not appear in an address outside of a quoted string.  It is probably
+        # a sensible Postel interpretation, though.
+        eq = self.assertEqual
+        eq(utils.parseaddr('""example" example"@example.com'),
+          ('', '""example" example"@example.com'))
+        eq(utils.parseaddr('"\\"example\\" example"@example.com'),
+          ('', '"\\"example\\" example"@example.com'))
+        eq(utils.parseaddr('"\\\\"example\\\\" example"@example.com'),
+          ('', '"\\\\"example\\\\" example"@example.com'))
+
+    def test_parseaddr_preserves_spaces_in_local_part(self):
+        # issue 9286.  A normal RFC 5322 local part should not contain any
+        # folding white space, but legacy local parts can (they are a sequence
+        # of atoms, not dotatoms).  On the other hand we strip whitespace from
+        # before the @ and around dots, on the assumption that the whitespace
+        # around the punctuation is a mistake in what would otherwise be
+        # an RFC 5322 local part.  Leading whitespace is, usual, stripped as well.
+        self.assertEqual(('', "merwok wok@xample.com"),
+            utils.parseaddr("merwok wok@xample.com"))
+        self.assertEqual(('', "merwok  wok@xample.com"),
+            utils.parseaddr("merwok  wok@xample.com"))
+        self.assertEqual(('', "merwok  wok@xample.com"),
+            utils.parseaddr(" merwok  wok  @xample.com"))
+        self.assertEqual(('', 'merwok"wok"  wok@xample.com'),
+            utils.parseaddr('merwok"wok"  wok@xample.com'))
+        self.assertEqual(('', 'merwok.wok.wok@xample.com'),
+            utils.parseaddr('merwok. wok .  wok@xample.com'))
+
+    def test_formataddr_does_not_quote_parens_in_quoted_string(self):
+        addr = ("'foo@example.com' (foo@example.com)",
+                'foo@example.com')
+        addrstr = ('"\'foo@example.com\' '
+                            '(foo@example.com)" <foo@example.com>')
+        self.assertEqual(utils.parseaddr(addrstr), addr)
+        self.assertEqual(utils.formataddr(addr), addrstr)
+
+
+    def test_multiline_from_comment(self):
+        x = """\
+Foo
+\tBar <foo@example.com>"""
+        self.assertEqual(utils.parseaddr(x), ('Foo Bar', 'foo@example.com'))
+
+    def test_quote_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A Silly; Person', 'person@dom.ain')),
+            r'"A Silly; Person" <person@dom.ain>')
+
+    def test_charset_richcomparisons(self):
+        eq = self.assertEqual
+        ne = self.assertNotEqual
+        cset1 = Charset()
+        cset2 = Charset()
+        eq(cset1, 'us-ascii')
+        eq(cset1, 'US-ASCII')
+        eq(cset1, 'Us-AsCiI')
+        eq('us-ascii', cset1)
+        eq('US-ASCII', cset1)
+        eq('Us-AsCiI', cset1)
+        ne(cset1, 'usascii')
+        ne(cset1, 'USASCII')
+        ne(cset1, 'UsAsCiI')
+        ne('usascii', cset1)
+        ne('USASCII', cset1)
+        ne('UsAsCiI', cset1)
+        eq(cset1, cset2)
+        eq(cset2, cset1)
+
+    def test_getaddresses(self):
+        eq = self.assertEqual
+        eq(utils.getaddresses(['aperson@dom.ain (Al Person)',
+                               'Bud Person <bperson@dom.ain>']),
+           [('Al Person', 'aperson@dom.ain'),
+            ('Bud Person', 'bperson@dom.ain')])
+
+    def test_getaddresses_comma_in_name(self):
+        """GH-106669 regression test."""
+        self.assertEqual(
+            utils.getaddresses(
+                [
+                    '"Bud, Person" <bperson@dom.ain>',
+                    'aperson@dom.ain (Al Person)',
+                    '"Mariusz Felisiak" <to@example.com>',
+                ]
+            ),
+            [
+                ('Bud, Person', 'bperson@dom.ain'),
+                ('Al Person', 'aperson@dom.ain'),
+                ('Mariusz Felisiak', 'to@example.com'),
+            ],
+        )
+
+    def test_parsing_errors(self):
+        """Test for parsing errors from CVE-2023-27043 and CVE-2019-16056"""
+        alice = 'alice@example.org'
+        bob = 'bob@example.com'
+        empty = ('', '')
+
+        # Test utils.getaddresses() and utils.parseaddr() on malformed email
+        # addresses: default behavior (strict=True) rejects malformed address,
+        # and strict=False which tolerates malformed address.
+        for invalid_separator, expected_non_strict in (
+            ('(', [(f'<{bob}>', alice)]),
+            (')', [('', alice), empty, ('', bob)]),
+            ('<', [('', alice), empty, ('', bob), empty]),
+            ('>', [('', alice), empty, ('', bob)]),
+            ('[', [('', f'{alice}[<{bob}>]')]),
+            (']', [('', alice), empty, ('', bob)]),
+            ('@', [empty, empty, ('', bob)]),
+            (';', [('', alice), empty, ('', bob)]),
+            (':', [('', alice), ('', bob)]),
+            ('.', [('', alice + '.'), ('', bob)]),
+            ('"', [('', alice), ('', f'<{bob}>')]),
+        ):
+            address = f'{alice}{invalid_separator}<{bob}>'
+            with self.subTest(address=address):
+                self.assertEqual(utils.getaddresses([address]),
+                                 [empty])
+                self.assertEqual(utils.getaddresses([address], strict=False),
+                                 expected_non_strict)
+
+                self.assertEqual(utils.parseaddr([address]),
+                                 empty)
+                self.assertEqual(utils.parseaddr([address], strict=False),
+                                 ('', address))
+
+        # Comma (',') is treated differently depending on strict parameter.
+        # Comma without quotes.
+        address = f'{alice},<{bob}>'
+        self.assertEqual(utils.getaddresses([address]),
+                         [('', alice), ('', bob)])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('', alice), ('', bob)])
+        self.assertEqual(utils.parseaddr([address]),
+                         empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Real name between quotes containing comma.
+        address = '"Alice, alice@example.org" <bob@example.com>'
+        expected_strict = ('Alice, alice@example.org', 'bob@example.com')
+        self.assertEqual(utils.getaddresses([address]), [expected_strict])
+        self.assertEqual(utils.getaddresses([address], strict=False), [expected_strict])
+        self.assertEqual(utils.parseaddr([address]), expected_strict)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Valid parenthesis in comments.
+        address = 'alice@example.org (Alice)'
+        expected_strict = ('Alice', 'alice@example.org')
+        self.assertEqual(utils.getaddresses([address]), [expected_strict])
+        self.assertEqual(utils.getaddresses([address], strict=False), [expected_strict])
+        self.assertEqual(utils.parseaddr([address]), expected_strict)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Invalid parenthesis in comments.
+        address = 'alice@example.org )Alice('
+        self.assertEqual(utils.getaddresses([address]), [empty])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('', 'alice@example.org'), ('', ''), ('', 'Alice')])
+        self.assertEqual(utils.parseaddr([address]), empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Two addresses with quotes separated by comma.
+        address = '"Jane Doe" <jane@example.net>, "John Doe" <john@example.net>'
+        self.assertEqual(utils.getaddresses([address]),
+                         [('Jane Doe', 'jane@example.net'),
+                          ('John Doe', 'john@example.net')])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('Jane Doe', 'jane@example.net'),
+                          ('John Doe', 'john@example.net')])
+        self.assertEqual(utils.parseaddr([address]), empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Test email.utils.supports_strict_parsing attribute
+        self.assertEqual(email.utils.supports_strict_parsing, True)
+
+    def test_getaddresses_nasty(self):
+        for addresses, expected in (
+            (['"Sürname, Firstname" <to@example.com>'],
+             [('Sürname, Firstname', 'to@example.com')]),
+
+            (['foo: ;'],
+             [('', '')]),
+
+            (['foo: ;', '"Jason R. Mastaler" <jason@dom.ain>'],
+             [('', ''), ('Jason R. Mastaler', 'jason@dom.ain')]),
+
+            ([r'Pete(A nice \) chap) <pete(his account)@silly.test(his host)>'],
+             [('Pete (A nice ) chap his account his host)', 'pete@silly.test')]),
+
+            (['(Empty list)(start)Undisclosed recipients  :(nobody(I know))'],
+             [('', '')]),
+
+            (['Mary <@machine.tld:mary@example.net>, , jdoe@test   . example'],
+             [('Mary', 'mary@example.net'), ('', ''), ('', 'jdoe@test.example')]),
+
+            (['John Doe <jdoe@machine(comment).  example>'],
+             [('John Doe (comment)', 'jdoe@machine.example')]),
+
+            (['"Mary Smith: Personal Account" <smith@home.example>'],
+             [('Mary Smith: Personal Account', 'smith@home.example')]),
+
+            (['Undisclosed recipients:;'],
+             [('', '')]),
+
+            ([r'<boss@nil.test>, "Giant; \"Big\" Box" <bob@example.net>'],
+             [('', 'boss@nil.test'), ('Giant; "Big" Box', 'bob@example.net')]),
+        ):
+            with self.subTest(addresses=addresses):
+                self.assertEqual(utils.getaddresses(addresses),
+                                 expected)
+                self.assertEqual(utils.getaddresses(addresses, strict=False),
+                                 expected)
+
+        addresses = ['[]*-- =~$']
+        self.assertEqual(utils.getaddresses(addresses),
+                         [('', '')])
+        self.assertEqual(utils.getaddresses(addresses, strict=False),
+                         [('', ''), ('', ''), ('', '*--')])
+
+    def test_getaddresses_embedded_comment(self):
+        """Test proper handling of a nested comment"""
+        eq = self.assertEqual
+        addrs = utils.getaddresses(['User ((nested comment)) <foo@bar.com>'])
+        eq(addrs[0][1], 'foo@bar.com')
+
+    def test_getaddresses_header_obj(self):
+        """Test the handling of a Header object."""
+        addrs = utils.getaddresses([Header('Al Person <aperson@dom.ain>')])
+        self.assertEqual(addrs[0][1], 'aperson@dom.ain')
+
+    @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
+    def test_make_msgid_collisions(self):
+        # Test make_msgid uniqueness, even with multiple threads
+        class MsgidsThread(Thread):
+            def run(self):
+                # generate msgids for 3 seconds
+                self.msgids = []
+                append = self.msgids.append
+                make_msgid = utils.make_msgid
+                clock = time.monotonic
+                tfin = clock() + 3.0
+                while clock() < tfin:
+                    append(make_msgid(domain='testdomain-string'))
+
+        threads = [MsgidsThread() for i in range(5)]
+        with threading_helper.start_threads(threads):
+            pass
+        all_ids = sum([t.msgids for t in threads], [])
+        self.assertEqual(len(set(all_ids)), len(all_ids))
+
+    def test_utils_quote_unquote(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.add_header('content-disposition', 'attachment',
+                       filename='foo\\wacky"name')
+        eq(msg.get_filename(), 'foo\\wacky"name')
+
+    def test_get_body_encoding_with_bogus_charset(self):
+        charset = Charset('not a charset')
+        self.assertEqual(charset.get_body_encoding(), 'base64')
+
+    def test_get_body_encoding_with_uppercase_charset(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg['Content-Type'] = 'text/plain; charset=UTF-8'
+        eq(msg['content-type'], 'text/plain; charset=UTF-8')
+        charsets = msg.get_charsets()
+        eq(len(charsets), 1)
+        eq(charsets[0], 'utf-8')
+        charset = Charset(charsets[0])
+        eq(charset.get_body_encoding(), 'base64')
+        msg.set_payload(b'hello world', charset=charset)
+        eq(msg.get_payload(), 'aGVsbG8gd29ybGQ=\n')
+        eq(msg.get_payload(decode=True), b'hello world')
+        eq(msg['content-transfer-encoding'], 'base64')
+        # Try another one
+        msg = Message()
+        msg['Content-Type'] = 'text/plain; charset="US-ASCII"'
+        charsets = msg.get_charsets()
+        eq(len(charsets), 1)
+        eq(charsets[0], 'us-ascii')
+        charset = Charset(charsets[0])
+        eq(charset.get_body_encoding(), encoders.encode_7or8bit)
+        msg.set_payload('hello world', charset=charset)
+        eq(msg.get_payload(), 'hello world')
+        eq(msg['content-transfer-encoding'], '7bit')
+
+    def test_charsets_case_insensitive(self):
+        lc = Charset('us-ascii')
+        uc = Charset('US-ASCII')
+        self.assertEqual(lc.get_body_encoding(), uc.get_body_encoding())
+
+    def test_partial_falls_inside_message_delivery_status(self):
+        eq = self.ndiffAssertEqual
+        # The Parser interface provides chunks of data to FeedParser in 8192
+        # byte gulps.  SF bug #1076485 found one of those chunks inside
+        # message/delivery-status header block, which triggered an
+        # unreadline() of NeedMoreData.
+        msg = self._msgobj('msg_43.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/report
+    text/plain
+    message/delivery-status
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+    text/rfc822-headers
+""")
+
+    def test_make_msgid_domain(self):
+        self.assertEqual(
+            email.utils.make_msgid(domain='testdomain-string')[-19:],
+            '@testdomain-string>')
+
+    def test_make_msgid_idstring(self):
+        self.assertEqual(
+            email.utils.make_msgid(idstring='test-idstring',
+                domain='testdomain-string')[-33:],
+            '.test-idstring@testdomain-string>')
+
+    def test_make_msgid_default_domain(self):
+        with patch('socket.getfqdn') as mock_getfqdn:
+            mock_getfqdn.return_value = domain = 'pythontest.example.com'
+            self.assertEndsWith(email.utils.make_msgid(), '@' + domain + '>')
+
+    def test_Generator_linend(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as f:
+            msgtxt = f.read()
+        msgtxt_nl = msgtxt.replace('\r\n', '\n')
+        msg = email.message_from_string(msgtxt)
+        s = StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), msgtxt_nl)
+
+    def test_BytesGenerator_linend(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as f:
+            msgtxt = f.read()
+        msgtxt_nl = msgtxt.replace('\r\n', '\n')
+        msg = email.message_from_string(msgtxt_nl)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue().decode('ascii'), msgtxt)
+
+    def test_BytesGenerator_linend_with_non_ascii(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', 'rb') as f:
+            msgtxt = f.read()
+        msgtxt = msgtxt.replace(b'with attachment', b'fo\xf6')
+        msgtxt_nl = msgtxt.replace(b'\r\n', b'\n')
+        msg = email.message_from_bytes(msgtxt_nl)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), msgtxt)
+
+    def test_mime_classes_policy_argument(self):
+        with openfile('sndhdr.au', 'rb') as fp:
+            audiodata = fp.read()
+        with openfile('python.gif', 'rb') as fp:
+            bindata = fp.read()
+        classes = [
+            (MIMEApplication, ('',)),
+            (MIMEAudio, (audiodata,)),
+            (MIMEImage, (bindata,)),
+            (MIMEMessage, (Message(),)),
+            (MIMENonMultipart, ('multipart', 'mixed')),
+            (MIMEText, ('',)),
+        ]
+        for cls, constructor in classes:
+            with self.subTest(cls=cls.__name__, policy='compat32'):
+                m = cls(*constructor)
+                self.assertIs(m.policy, email.policy.compat32)
+            with self.subTest(cls=cls.__name__, policy='default'):
+                m = cls(*constructor, policy=email.policy.default)
+                self.assertIs(m.policy, email.policy.default)
+
+    def test_iter_escaped_chars(self):
+        self.assertEqual(list(utils._iter_escaped_chars(r'a\\b\"c\\"d')),
+                         [(0, 'a'),
+                          (2, '\\\\'),
+                          (3, 'b'),
+                          (5, '\\"'),
+                          (6, 'c'),
+                          (8, '\\\\'),
+                          (9, '"'),
+                          (10, 'd')])
+        self.assertEqual(list(utils._iter_escaped_chars('a\\')),
+                         [(0, 'a'), (1, '\\')])
+
+    def test_strip_quoted_realnames(self):
+        def check(addr, expected):
+            self.assertEqual(utils._strip_quoted_realnames(addr), expected)
+
+        check('"Jane Doe" <jane@example.net>, "John Doe" <john@example.net>',
+              ' <jane@example.net>,  <john@example.net>')
+        check(r'"Jane \"Doe\"." <jane@example.net>',
+              ' <jane@example.net>')
+
+        # special cases
+        check(r'before"name"after', 'beforeafter')
+        check(r'before"name"', 'before')
+        check(r'b"name"', 'b')  # single char
+        check(r'"name"after', 'after')
+        check(r'"name"a', 'a')  # single char
+        check(r'"name"', '')
+
+        # no change
+        for addr in (
+            'Jane Doe <jane@example.net>, John Doe <john@example.net>',
+            'lone " quote',
+        ):
+            self.assertEqual(utils._strip_quoted_realnames(addr), addr)
+
+
+    def test_check_parenthesis(self):
+        addr = 'alice@example.net'
+        self.assertTrue(utils._check_parenthesis(f'{addr} (Alice)'))
+        self.assertFalse(utils._check_parenthesis(f'{addr} )Alice('))
+        self.assertFalse(utils._check_parenthesis(f'{addr} (Alice))'))
+        self.assertFalse(utils._check_parenthesis(f'{addr} ((Alice)'))
+
+        # Ignore real name between quotes
+        self.assertTrue(utils._check_parenthesis(f'")Alice((" {addr}'))
+
+
+# Test the iterator/generators
+class TestIterators(TestEmailBase):
+    def test_body_line_iterator(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        # First a simple non-multipart message
+        msg = self._msgobj('msg_01.txt')
+        it = iterators.body_line_iterator(msg)
+        lines = list(it)
+        eq(len(lines), 6)
+        neq(EMPTYSTRING.join(lines), msg.get_payload())
+        # Now a more complicated multipart
+        msg = self._msgobj('msg_02.txt')
+        it = iterators.body_line_iterator(msg)
+        lines = list(it)
+        eq(len(lines), 43)
+        with openfile('msg_19.txt', encoding="utf-8") as fp:
+            neq(EMPTYSTRING.join(lines), fp.read())
+
+    def test_typed_subpart_iterator(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_04.txt')
+        it = iterators.typed_subpart_iterator(msg, 'text')
+        lines = []
+        subparts = 0
+        for subpart in it:
+            subparts += 1
+            lines.append(subpart.get_payload())
+        eq(subparts, 2)
+        eq(EMPTYSTRING.join(lines), """\
+a simple kind of mirror
+to reflect upon our own
+a simple kind of mirror
+to reflect upon our own
+""")
+
+    def test_typed_subpart_iterator_default_type(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_03.txt')
+        it = iterators.typed_subpart_iterator(msg, 'text', 'plain')
+        lines = []
+        subparts = 0
+        for subpart in it:
+            subparts += 1
+            lines.append(subpart.get_payload())
+        eq(subparts, 1)
+        eq(EMPTYSTRING.join(lines), """\
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_pushCR_LF(self):
+        '''FeedParser BufferedSubFile.push() assumed it received complete
+           line endings.  A CR ending one push() followed by a LF starting
+           the next push() added an empty line.
+        '''
+        imt = [
+            ("a\r \n",  2),
+            ("b",       0),
+            ("c\n",     1),
+            ("",        0),
+            ("d\r\n",   1),
+            ("e\r",     0),
+            ("\nf",     1),
+            ("\r\n",    1),
+          ]
+        from email.feedparser import BufferedSubFile, NeedMoreData
+        bsf = BufferedSubFile()
+        om = []
+        nt = 0
+        for il, n in imt:
+            bsf.push(il)
+            nt += n
+            n1 = 0
+            for ol in iter(bsf.readline, NeedMoreData):
+                om.append(ol)
+                n1 += 1
+            self.assertEqual(n, n1)
+        self.assertEqual(len(om), nt)
+        self.assertEqual(''.join([il for il, n in imt]), ''.join(om))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_push_random(self):
+        from email.feedparser import BufferedSubFile, NeedMoreData
+
+        n = 10000
+        chunksize = 5
+        chars = 'abcd \t\r\n'
+
+        s = ''.join(choice(chars) for i in range(n)) + '\n'
+        target = s.splitlines(True)
+
+        bsf = BufferedSubFile()
+        lines = []
+        for i in range(0, len(s), chunksize):
+            chunk = s[i:i+chunksize]
+            bsf.push(chunk)
+            lines.extend(iter(bsf.readline, NeedMoreData))
+        self.assertEqual(lines, target)
+
+
+class TestFeedParsers(TestEmailBase):
+
+    def parse(self, chunks):
+        feedparser = FeedParser()
+        for chunk in chunks:
+            feedparser.feed(chunk)
+        return feedparser.close()
+
+    def test_empty_header_name_handled(self):
+        # Issue 19996
+        msg = self.parse("First: val\n: bad\nSecond: val")
+        self.assertEqual(msg['First'], 'val')
+        self.assertEqual(msg['Second'], 'val')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Feedparser.feed -> Feedparser._input.push, Feedparser._call_parse -> Feedparser._parse does not keep _input state between calls
+    def test_newlines(self):
+        m = self.parse(['a:\nb:\rc:\r\nd:\n'])
+        self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
+        m = self.parse(['a:\nb:\rc:\r\nd:'])
+        self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
+        m = self.parse(['a:\rb', 'c:\n'])
+        self.assertEqual(m.keys(), ['a', 'bc'])
+        m = self.parse(['a:\r', 'b:\n'])
+        self.assertEqual(m.keys(), ['a', 'b'])
+        m = self.parse(['a:\r', '\nb:\n'])
+        self.assertEqual(m.keys(), ['a', 'b'])
+
+        # Only CR and LF should break header fields
+        m = self.parse(['a:\x85b:\u2028c:\n'])
+        self.assertEqual(m.items(), [('a', '\x85b:\u2028c:')])
+        m = self.parse(['a:\r', 'b:\x85', 'c:\n'])
+        self.assertEqual(m.items(), [('a', ''), ('b', '\x85c:')])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_long_lines(self):
+        # Expected peak memory use on 32-bit platform: 6*N*M bytes.
+        M, N = 1000, 20000
+        m = self.parse(['a:b\n\n'] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), 'x'*M*N)
+        m = self.parse(['a:b\r\r'] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), 'x'*M*N)
+        m = self.parse(['a:b\r\r'] + ['x'*M+'\x85'] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), ('x'*M+'\x85')*N)
+        m = self.parse(['a:\r', 'b: '] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', ''), ('b', 'x'*M*N)])
+
+
+class TestParsers(TestEmailBase):
+
+    def test_header_parser(self):
+        eq = self.assertEqual
+        # Parse only the headers of a complex multipart MIME document
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            msg = HeaderParser().parse(fp)
+        eq(msg['from'], 'ppp-request@zzz.org')
+        eq(msg['to'], 'ppp@zzz.org')
+        eq(msg.get_content_type(), 'multipart/mixed')
+        self.assertFalse(msg.is_multipart())
+        self.assertIsInstance(msg.get_payload(), str)
+
+    def test_bytes_header_parser(self):
+        eq = self.assertEqual
+        # Parse only the headers of a complex multipart MIME document
+        with openfile('msg_02.txt', 'rb') as fp:
+            msg = email.parser.BytesHeaderParser().parse(fp)
+        eq(msg['from'], 'ppp-request@zzz.org')
+        eq(msg['to'], 'ppp@zzz.org')
+        eq(msg.get_content_type(), 'multipart/mixed')
+        self.assertFalse(msg.is_multipart())
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertIsInstance(msg.get_payload(decode=True), bytes)
+
+    def test_header_parser_multipart_is_valid(self):
+        # Don't flag valid multipart emails as having defects
+        with openfile('msg_47.txt', encoding="utf-8") as fp:
+            msgdata = fp.read()
+
+        parser = email.parser.Parser(policy=email.policy.default)
+        parsed_msg = parser.parsestr(msgdata, headersonly=True)
+
+        self.assertEqual(parsed_msg.defects, [])
+
+    def test_bytes_parser_does_not_close_file(self):
+        with openfile('msg_02.txt', 'rb') as fp:
+            email.parser.BytesParser().parse(fp)
+            self.assertFalse(fp.closed)
+
+    def test_bytes_parser_on_exception_does_not_close_file(self):
+        with openfile('msg_15.txt', 'rb') as fp:
+            bytesParser = email.parser.BytesParser
+            self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
+                              bytesParser(policy=email.policy.strict).parse,
+                              fp)
+            self.assertFalse(fp.closed)
+
+    def test_parser_does_not_close_file(self):
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            email.parser.Parser().parse(fp)
+            self.assertFalse(fp.closed)
+
+    def test_parser_on_exception_does_not_close_file(self):
+        with openfile('msg_15.txt', encoding="utf-8") as fp:
+            parser = email.parser.Parser
+            self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
+                              parser(policy=email.policy.strict).parse, fp)
+            self.assertFalse(fp.closed)
+
+    def test_whitespace_continuation(self):
+        eq = self.assertEqual
+        # This message contains a line after the Subject: header that has only
+        # whitespace, but it is not empty!
+        msg = email.message_from_string("""\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: the next line has a space on it
+\x20
+Date: Mon, 8 Apr 2002 15:09:19 -0400
+Message-ID: spam
+
+Here's the message body
+""")
+        eq(msg['subject'], 'the next line has a space on it\n ')
+        eq(msg['message-id'], 'spam')
+        eq(msg.get_payload(), "Here's the message body\n")
+
+    def test_whitespace_continuation_last_header(self):
+        eq = self.assertEqual
+        # Like the previous test, but the subject line is the last
+        # header.
+        msg = email.message_from_string("""\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Date: Mon, 8 Apr 2002 15:09:19 -0400
+Message-ID: spam
+Subject: the next line has a space on it
+\x20
+
+Here's the message body
+""")
+        eq(msg['subject'], 'the next line has a space on it\n ')
+        eq(msg['message-id'], 'spam')
+        eq(msg.get_payload(), "Here's the message body\n")
+
+    def test_crlf_separation(self):
+        eq = self.assertEqual
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as fp:
+            msg = Parser().parse(fp)
+        eq(len(msg.get_payload()), 2)
+        part1 = msg.get_payload(0)
+        eq(part1.get_content_type(), 'text/plain')
+        eq(part1.get_payload(), 'Simple email with attachment.\r\n\r\n')
+        part2 = msg.get_payload(1)
+        eq(part2.get_content_type(), 'application/riscos')
+
+    def test_crlf_flatten(self):
+        # Using newline='\n' preserves the crlfs in this input file.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as fp:
+            text = fp.read()
+        msg = email.message_from_string(text)
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), text)
+
+    maxDiff = None
+
+    def test_multipart_digest_with_extra_mime_headers(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        with openfile('msg_28.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        # Structure is:
+        # multipart/digest
+        #   message/rfc822
+        #     text/plain
+        #   message/rfc822
+        #     text/plain
+        eq(msg.is_multipart(), 1)
+        eq(len(msg.get_payload()), 2)
+        part1 = msg.get_payload(0)
+        eq(part1.get_content_type(), 'message/rfc822')
+        eq(part1.is_multipart(), 1)
+        eq(len(part1.get_payload()), 1)
+        part1a = part1.get_payload(0)
+        eq(part1a.is_multipart(), 0)
+        eq(part1a.get_content_type(), 'text/plain')
+        neq(part1a.get_payload(), 'message 1\n')
+        # next message/rfc822
+        part2 = msg.get_payload(1)
+        eq(part2.get_content_type(), 'message/rfc822')
+        eq(part2.is_multipart(), 1)
+        eq(len(part2.get_payload()), 1)
+        part2a = part2.get_payload(0)
+        eq(part2a.is_multipart(), 0)
+        eq(part2a.get_content_type(), 'text/plain')
+        neq(part2a.get_payload(), 'message 2\n')
+
+    def test_three_lines(self):
+        # A bug report by Andrew McNamara
+        lines = ['From: Andrew Person <aperson@dom.ain',
+                 'Subject: Test',
+                 'Date: Tue, 20 Aug 2002 16:43:45 +1000']
+        msg = email.message_from_string(NL.join(lines))
+        self.assertEqual(msg['date'], 'Tue, 20 Aug 2002 16:43:45 +1000')
+
+    def test_strip_line_feed_and_carriage_return_in_headers(self):
+        eq = self.assertEqual
+        # For [ 1002475 ] email message parser doesn't handle \r\n correctly
+        value1 = 'text'
+        value2 = 'more text'
+        m = 'Header: %s\r\nNext-Header: %s\r\n\r\nBody\r\n\r\n' % (
+            value1, value2)
+        msg = email.message_from_string(m)
+        eq(msg.get('Header'), value1)
+        eq(msg.get('Next-Header'), value2)
+
+    def test_rfc2822_header_syntax(self):
+        eq = self.assertEqual
+        m = '>From: foo\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
+        msg = email.message_from_string(m)
+        eq(len(msg), 3)
+        eq(sorted(field for field in msg), ['!"#QUX;~', '>From', 'From'])
+        eq(msg.get_payload(), 'body')
+
+    def test_rfc2822_space_not_allowed_in_header(self):
+        eq = self.assertEqual
+        m = '>From foo@example.com 11:25:53\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
+        msg = email.message_from_string(m)
+        eq(len(msg.keys()), 0)
+
+    def test_rfc2822_one_character_header(self):
+        eq = self.assertEqual
+        m = 'A: first header\nB: second header\nCC: third header\n\nbody'
+        msg = email.message_from_string(m)
+        headers = msg.keys()
+        headers.sort()
+        eq(headers, ['A', 'B', 'CC'])
+        eq(msg.get_payload(), 'body')
+
+    def test_CRLFLF_at_end_of_part(self):
+        # issue 5610: feedparser should not eat two chars from body part ending
+        # with "\r\n\n".
+        m = (
+            "From: foo@bar.com\n"
+            "To: baz\n"
+            "Mime-Version: 1.0\n"
+            "Content-Type: multipart/mixed; boundary=BOUNDARY\n"
+            "\n"
+            "--BOUNDARY\n"
+            "Content-Type: text/plain\n"
+            "\n"
+            "body ending with CRLF newline\r\n"
+            "\n"
+            "--BOUNDARY--\n"
+          )
+        msg = email.message_from_string(m)
+        self.assertEndsWith(msg.get_payload(0).get_payload(), '\r\n')
+
+
+class Test8BitBytesHandling(TestEmailBase):
+    # In Python3 all input is string, but that doesn't work if the actual input
+    # uses an 8bit transfer encoding.  To hack around that, in email 5.1 we
+    # decode byte streams using the surrogateescape error handler, and
+    # reconvert to binary at appropriate places if we detect surrogates.  This
+    # doesn't allow us to transform headers with 8bit bytes (they get munged),
+    # but it does allow us to parse and preserve them, and to decode body
+    # parts that use an 8bit CTE.
+
+    bodytest_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: baz
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset={charset}
+        Content-Transfer-Encoding: {cte}
+
+        {bodyline}
+        """)
+
+    def test_known_8bit_CTE(self):
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='8bit',
+                                     bodyline='pöstal').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "pöstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+    def test_unknown_8bit_CTE(self):
+        m = self.bodytest_msg.format(charset='notavalidcharset',
+                                     cte='8bit',
+                                     bodyline='pöstal').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "p\uFFFD\uFFFDstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+    def test_8bit_in_quopri_body(self):
+        # This is non-RFC compliant data...without 'decode' the library code
+        # decodes the body using the charset from the headers, and because the
+        # source byte really is utf-8 this works.  This is likely to fail
+        # against real dirty data (ie: produce mojibake), but the data is
+        # invalid anyway so it is as good a guess as any.  But this means that
+        # this test just confirms the current behavior; that behavior is not
+        # necessarily the best possible behavior.  With 'decode' it is
+        # returning the raw bytes, so that test should be of correct behavior,
+        # or at least produce the same result that email4 did.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='quoted-printable',
+                                     bodyline='p=C3=B6stál').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), 'p=C3=B6stál\n')
+        self.assertEqual(msg.get_payload(decode=True),
+                         'pöstál\n'.encode('utf-8'))
+
+    def test_invalid_8bit_in_non_8bit_cte_uses_replace(self):
+        # This is similar to the previous test, but proves that if the 8bit
+        # byte is undecodeable in the specified charset, it gets replaced
+        # by the unicode 'unknown' character.  Again, this may or may not
+        # be the ideal behavior.  Note that if decode=False none of the
+        # decoders will get involved, so this is the only test we need
+        # for this behavior.
+        m = self.bodytest_msg.format(charset='ascii',
+                                     cte='quoted-printable',
+                                     bodyline='p=C3=B6stál').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), 'p=C3=B6st\uFFFD\uFFFDl\n')
+        self.assertEqual(msg.get_payload(decode=True),
+                        'pöstál\n'.encode('utf-8'))
+
+    # test_defect_handling:test_invalid_chars_in_base64_payload
+    def test_8bit_in_base64_body(self):
+        # If we get 8bit bytes in a base64 body, we can just ignore them
+        # as being outside the base64 alphabet and decode anyway.  But
+        # we register a defect.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='base64',
+                                     bodyline='cMO2c3RhbAá=').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(decode=True),
+                         'pöstal'.encode('utf-8'))
+        self.assertIsInstance(msg.defects[0],
+                              errors.InvalidBase64CharactersDefect)
+
+    def test_8bit_in_uuencode_body(self):
+        # Sticking an 8bit byte in a uuencode block makes it undecodable by
+        # normal means, so the block is returned undecoded, but as bytes.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='uuencode',
+                                     bodyline='<,.V<W1A; á ').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(decode=True),
+                         '<,.V<W1A; á \n'.encode('utf-8'))
+
+    def test_rfc2231_charset_8bit_CTE(self):
+        m = textwrap.dedent("""\
+        From: foo@bar.com
+        To: baz
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset*=ansi-x3.4-1968''utf-8
+        Content-Transfer-Encoding: 8bit
+
+        pöstal
+        """).encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "pöstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+
+    headertest_headers = (
+        ('From: foo@bar.com', ('From', 'foo@bar.com')),
+        ('To: báz', ('To', '=?unknown-8bit?q?b=C3=A1z?=')),
+        ('Subject: Maintenant je vous présente mon collègue, le pouf célèbre\n'
+            '\tJean de Baddie',
+            ('Subject', '=?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
+                'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=\n'
+                ' =?unknown-8bit?q?_Jean_de_Baddie?=')),
+        ('From: göst', ('From', '=?unknown-8bit?b?Z8O2c3Q=?=')),
+        )
+    headertest_msg = ('\n'.join([src for (src, _) in headertest_headers]) +
+        '\nYes, they are flying.\n').encode('utf-8')
+
+    def test_get_8bit_header(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertEqual(str(msg.get('to')), 'b\uFFFD\uFFFDz')
+        self.assertEqual(str(msg['to']), 'b\uFFFD\uFFFDz')
+
+    def test_print_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertEqual(str(msg),
+                         textwrap.dedent("""\
+                            From: {}
+                            To: {}
+                            Subject: {}
+                            From: {}
+
+                            Yes, they are flying.
+                            """).format(*[expected[1] for (_, expected) in
+                                        self.headertest_headers]))
+
+    def test_values_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([str(x) for x in msg.values()],
+                              ['foo@bar.com',
+                               'b\uFFFD\uFFFDz',
+                               'Maintenant je vous pr\uFFFD\uFFFDsente mon '
+                                   'coll\uFFFD\uFFFDgue, le pouf '
+                                   'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
+                                   '\tJean de Baddie',
+                               "g\uFFFD\uFFFDst"])
+
+    def test_items_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([(str(x), str(y)) for (x, y) in msg.items()],
+                              [('From', 'foo@bar.com'),
+                               ('To', 'b\uFFFD\uFFFDz'),
+                               ('Subject', 'Maintenant je vous '
+                                  'pr\uFFFD\uFFFDsente '
+                                  'mon coll\uFFFD\uFFFDgue, le pouf '
+                                  'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
+                                  '\tJean de Baddie'),
+                               ('From', 'g\uFFFD\uFFFDst')])
+
+    def test_get_all_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([str(x) for x in msg.get_all('from')],
+                              ['foo@bar.com',
+                               'g\uFFFD\uFFFDst'])
+
+    def test_get_content_type_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/pl\xA7in; charset=utf-8
+            """).encode('latin-1'))
+        self.assertEqual(msg.get_content_type(), "text/pl\uFFFDin")
+        self.assertEqual(msg.get_content_maintype(), "text")
+        self.assertEqual(msg.get_content_subtype(), "pl\uFFFDin")
+
+    # test_headerregistry.TestContentTypeHeader.non_ascii_in_params
+    def test_get_params_with_8bit(self):
+        msg = email.message_from_bytes(
+            'X-Header: foo=\xa7ne; b\xa7r=two; baz=three\n'.encode('latin-1'))
+        self.assertEqual(msg.get_params(header='x-header'),
+           [('foo', '\uFFFDne'), ('b\uFFFDr', 'two'), ('baz', 'three')])
+        self.assertEqual(msg.get_param('Foo', header='x-header'), '\uFFFdne')
+        # XXX: someday you might be able to get 'b\xa7r', for now you can't.
+        self.assertEqual(msg.get_param('b\xa7r', header='x-header'), None)
+
+    # test_headerregistry.TestContentTypeHeader.non_ascii_in_rfc2231_value
+    def test_get_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        self.assertEqual(msg.get_param('title'),
+            ('us-ascii', 'en', 'This is not f\uFFFDn'))
+
+    def test_set_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        msg.set_param('title', 'test')
+        self.assertEqual(msg.get_param('title'), 'test')
+
+    def test_del_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        msg.del_param('title')
+        self.assertEqual(msg.get_param('title'), None)
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_payload_with_8bit_cte_header(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Transfer-Encoding: b\xa7se64
+            Content-Type: text/plain; charset=latin-1
+
+            payload
+            """).encode('latin-1'))
+        self.assertEqual(msg.get_payload(), 'payload\n')
+        self.assertEqual(msg.get_payload(decode=True), b'payload\n')
+
+    non_latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: báz
+        Subject: Maintenant je vous présente mon collègue, le pouf célèbre
+        \tJean de Baddie
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: 8bit
+
+        Да, они лет�т.
+        """).encode('utf-8')
+
+    def test_bytes_generator(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), self.non_latin_bin_msg)
+
+    def test_bytes_generator_handles_None_body(self):
+        #Issue 11019
+        msg = email.message.Message()
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), b"\n")
+
+    non_latin_bin_msg_as7bit_wrapped = textwrap.dedent("""\
+        From: foo@bar.com
+        To: =?unknown-8bit?q?b=C3=A1z?=
+        Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_coll=C3=A8gue?=
+         =?unknown-8bit?q?=2C_le_pouf_c=C3=A9l=C3=A8bre?=
+         =?unknown-8bit?q?_Jean_de_Baddie?=
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: base64
+
+        0JTQsCwg0L7QvdC4INC70LXRgtGP0YIuCg==
+        """)
+
+    def test_generator_handles_8bit(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = StringIO()
+        email.generator.Generator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), self.non_latin_bin_msg_as7bit_wrapped)
+
+    def test_str_generator_should_not_mutate_msg_when_handling_8bit(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        BytesGenerator(out).flatten(msg)
+        orig_value = out.getvalue()
+        Generator(StringIO()).flatten(msg) # Should not mutate msg!
+        out = BytesIO()
+        BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), orig_value)
+
+    def test_bytes_generator_with_unix_from(self):
+        # The unixfrom contains a current date, so we can't check it
+        # literally.  Just make sure the first word is 'From' and the
+        # rest of the message matches the input.
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg, unixfrom=True)
+        lines = out.getvalue().split(b'\n')
+        self.assertEqual(lines[0].split()[0], b'From')
+        self.assertEqual(b'\n'.join(lines[1:]), self.non_latin_bin_msg)
+
+    non_latin_bin_msg_as7bit = non_latin_bin_msg_as7bit_wrapped.split('\n')
+    non_latin_bin_msg_as7bit[2:4] = [
+        'Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
+         'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=']
+    non_latin_bin_msg_as7bit = '\n'.join(non_latin_bin_msg_as7bit)
+
+    def test_message_from_binary_file(self):
+        fn = 'test.msg'
+        self.addCleanup(unlink, fn)
+        with open(fn, 'wb') as testfile:
+            testfile.write(self.non_latin_bin_msg)
+        with open(fn, 'rb') as testfile:
+            m = email.parser.BytesParser().parse(testfile)
+        self.assertEqual(str(m), self.non_latin_bin_msg_as7bit)
+
+    latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: Dinsdale
+        Subject: Nudge nudge, wink, wink
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="latin-1"
+        Content-Transfer-Encoding: 8bit
+
+        oh là là, know what I mean, know what I mean?
+        """).encode('latin-1')
+
+    latin_bin_msg_as7bit = textwrap.dedent("""\
+        From: foo@bar.com
+        To: Dinsdale
+        Subject: Nudge nudge, wink, wink
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="iso-8859-1"
+        Content-Transfer-Encoding: quoted-printable
+
+        oh l=E0 l=E0, know what I mean, know what I mean?
+        """)
+
+    def test_string_generator_reencodes_to_quopri_when_appropriate(self):
+        m = email.message_from_bytes(self.latin_bin_msg)
+        self.assertEqual(str(m), self.latin_bin_msg_as7bit)
+
+    def test_decoded_generator_emits_unicode_body(self):
+        m = email.message_from_bytes(self.latin_bin_msg)
+        out = StringIO()
+        email.generator.DecodedGenerator(out).flatten(m)
+        #DecodedHeader output contains an extra blank line compared
+        #to the input message.  RDM: not sure if this is a bug or not,
+        #but it is not specific to the 8bit->7bit conversion.
+        self.assertEqual(out.getvalue(),
+            self.latin_bin_msg.decode('latin-1')+'\n')
+
+    def test_bytes_feedparser(self):
+        bfp = email.feedparser.BytesFeedParser()
+        for i in range(0, len(self.latin_bin_msg), 10):
+            bfp.feed(self.latin_bin_msg[i:i+10])
+        m = bfp.close()
+        self.assertEqual(str(m), self.latin_bin_msg_as7bit)
+
+    def test_crlf_flatten(self):
+        with openfile('msg_26.txt', 'rb') as fp:
+            text = fp.read()
+        msg = email.message_from_bytes(text)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), text)
+
+    def test_8bit_multipart(self):
+        # Issue 11605
+        source = textwrap.dedent("""\
+            Date: Fri, 18 Mar 2011 17:15:43 +0100
+            To: foo@example.com
+            From: foodwatch-Newsletter <bar@example.com>
+            Subject: Aktuelles zu Japan, Klonfleisch und Smiley-System
+            Message-ID: <76a486bee62b0d200f33dc2ca08220ad@localhost.localdomain>
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+                    boundary="b1_76a486bee62b0d200f33dc2ca08220ad"
+
+            --b1_76a486bee62b0d200f33dc2ca08220ad
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            Guten Tag, ,
+
+            mit großer Betroffenheit verfolgen auch wir im foodwatch-Team die
+            Nachrichten aus Japan.
+
+
+            --b1_76a486bee62b0d200f33dc2ca08220ad
+            Content-Type: text/html; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+                "http://www.w3.org/TR/html4/loose.dtd">
+            <html lang="de">
+            <head>
+                    <title>foodwatch - Newsletter</title>
+            </head>
+            <body>
+              <p>mit gro&szlig;er Betroffenheit verfolgen auch wir im foodwatch-Team
+                 die Nachrichten aus Japan.</p>
+            </body>
+            </html>
+            --b1_76a486bee62b0d200f33dc2ca08220ad--
+
+            """).encode('utf-8')
+        msg = email.message_from_bytes(source)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), source)
+
+    def test_bytes_generator_b_encoding_linesep(self):
+        # Issue 14062: b encoding was tacking on an extra \n.
+        m = Message()
+        # This has enough non-ascii that it should always end up b encoded.
+        m['Subject'] = Header('žluťou�ký kůň')
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(m, linesep='\r\n')
+        self.assertEqual(
+            s.getvalue(),
+            b'Subject: =?utf-8?b?xb5sdcWlb3XEjWvDvSBrxa/FiA==?=\r\n\r\n')
+
+    def test_generator_b_encoding_linesep(self):
+        # Since this broke in ByteGenerator, test Generator for completeness.
+        m = Message()
+        # This has enough non-ascii that it should always end up b encoded.
+        m['Subject'] = Header('žluťou�ký kůň')
+        s = StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(m, linesep='\r\n')
+        self.assertEqual(
+            s.getvalue(),
+            'Subject: =?utf-8?b?xb5sdcWlb3XEjWvDvSBrxa/FiA==?=\r\n\r\n')
+
+    maxDiff = None
+
+
+class BaseTestBytesGeneratorIdempotent:
+
+    maxDiff = None
+
+    def _msgobj(self, filename):
+        with openfile(filename, 'rb') as fp:
+            data = fp.read()
+        data = self.normalize_linesep_regex.sub(self.blinesep, data)
+        msg = email.message_from_bytes(data)
+        return msg, data
+
+    def _idempotent(self, msg, data, unixfrom=False):
+        b = BytesIO()
+        g = email.generator.BytesGenerator(b, maxheaderlen=0)
+        g.flatten(msg, unixfrom=unixfrom, linesep=self.linesep)
+        self.assertEqual(data, b.getvalue())
+
+
+class TestBytesGeneratorIdempotentNL(BaseTestBytesGeneratorIdempotent,
+                                    TestIdempotent):
+    linesep = '\n'
+    blinesep = b'\n'
+    normalize_linesep_regex = re.compile(br'\r\n')
+
+
+class TestBytesGeneratorIdempotentCRLF(BaseTestBytesGeneratorIdempotent,
+                                       TestIdempotent):
+    linesep = '\r\n'
+    blinesep = b'\r\n'
+    normalize_linesep_regex = re.compile(br'(?<!\r)\n')
+
+
+class TestBase64(unittest.TestCase):
+    def test_len(self):
+        eq = self.assertEqual
+        eq(base64mime.header_length('hello'),
+           len(base64mime.body_encode(b'hello', eol='')))
+        for size in range(15):
+            if   size == 0 : bsize = 0
+            elif size <= 3 : bsize = 4
+            elif size <= 6 : bsize = 8
+            elif size <= 9 : bsize = 12
+            elif size <= 12: bsize = 16
+            else           : bsize = 20
+            eq(base64mime.header_length('x' * size), bsize)
+
+    def test_decode(self):
+        eq = self.assertEqual
+        eq(base64mime.decode(''), b'')
+        eq(base64mime.decode('aGVsbG8='), b'hello')
+
+    def test_encode(self):
+        eq = self.assertEqual
+        eq(base64mime.body_encode(b''), '')
+        eq(base64mime.body_encode(b'hello'), 'aGVsbG8=\n')
+        # Test the binary flag
+        eq(base64mime.body_encode(b'hello\n'), 'aGVsbG8K\n')
+        # Test the maxlinelen arg
+        eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40), """\
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IA==
+""")
+        # Test the eol argument
+        eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40, eol='\r\n'),
+           """\
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IA==\r
+""")
+
+    def test_header_encode(self):
+        eq = self.assertEqual
+        he = base64mime.header_encode
+        eq(he('hello'), '=?iso-8859-1?b?aGVsbG8=?=')
+        eq(he('hello\r\nworld'), '=?iso-8859-1?b?aGVsbG8NCndvcmxk?=')
+        eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
+        # Test the charset option
+        eq(he('hello', charset='iso-8859-2'), '=?iso-8859-2?b?aGVsbG8=?=')
+        eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
+
+
+class TestQuopri(unittest.TestCase):
+    def setUp(self):
+        # Set of characters (as byte integers) that don't need to be encoded
+        # in headers.
+        self.hlit = list(chain(
+            range(ord('a'), ord('z') + 1),
+            range(ord('A'), ord('Z') + 1),
+            range(ord('0'), ord('9') + 1),
+            (c for c in b'!*+-/')))
+        # Set of characters (as byte integers) that do need to be encoded in
+        # headers.
+        self.hnon = [c for c in range(256) if c not in self.hlit]
+        assert len(self.hlit) + len(self.hnon) == 256
+        # Set of characters (as byte integers) that don't need to be encoded
+        # in bodies.
+        self.blit = list(range(ord(' '), ord('~') + 1))
+        self.blit.append(ord('\t'))
+        self.blit.remove(ord('='))
+        # Set of characters (as byte integers) that do need to be encoded in
+        # bodies.
+        self.bnon = [c for c in range(256) if c not in self.blit]
+        assert len(self.blit) + len(self.bnon) == 256
+
+    def test_quopri_header_check(self):
+        for c in self.hlit:
+            self.assertFalse(quoprimime.header_check(c),
+                        'Should not be header quopri encoded: %s' % chr(c))
+        for c in self.hnon:
+            self.assertTrue(quoprimime.header_check(c),
+                            'Should be header quopri encoded: %s' % chr(c))
+
+    def test_quopri_body_check(self):
+        for c in self.blit:
+            self.assertFalse(quoprimime.body_check(c),
+                        'Should not be body quopri encoded: %s' % chr(c))
+        for c in self.bnon:
+            self.assertTrue(quoprimime.body_check(c),
+                            'Should be body quopri encoded: %s' % chr(c))
+
+    def test_header_quopri_len(self):
+        eq = self.assertEqual
+        eq(quoprimime.header_length(b'hello'), 5)
+        # RFC 2047 chrome is not included in header_length().
+        eq(len(quoprimime.header_encode(b'hello', charset='xxx')),
+           quoprimime.header_length(b'hello') +
+           # =?xxx?q?...?= means 10 extra characters
+           10)
+        eq(quoprimime.header_length(b'h@e@l@l@o@'), 20)
+        # RFC 2047 chrome is not included in header_length().
+        eq(len(quoprimime.header_encode(b'h@e@l@l@o@', charset='xxx')),
+           quoprimime.header_length(b'h@e@l@l@o@') +
+           # =?xxx?q?...?= means 10 extra characters
+           10)
+        for c in self.hlit:
+            eq(quoprimime.header_length(bytes([c])), 1,
+               'expected length 1 for %r' % chr(c))
+        for c in self.hnon:
+            # Space is special; it's encoded to _
+            if c == ord(' '):
+                continue
+            eq(quoprimime.header_length(bytes([c])), 3,
+               'expected length 3 for %r' % chr(c))
+        eq(quoprimime.header_length(b' '), 1)
+
+    def test_body_quopri_len(self):
+        eq = self.assertEqual
+        for c in self.blit:
+            eq(quoprimime.body_length(bytes([c])), 1)
+        for c in self.bnon:
+            eq(quoprimime.body_length(bytes([c])), 3)
+
+    def test_quote_unquote_idempotent(self):
+        for x in range(256):
+            c = chr(x)
+            self.assertEqual(quoprimime.unquote(quoprimime.quote(c)), c)
+
+    def _test_header_encode(self, header, expected_encoded_header, charset=None):
+        if charset is None:
+            encoded_header = quoprimime.header_encode(header)
+        else:
+            encoded_header = quoprimime.header_encode(header, charset)
+        self.assertEqual(encoded_header, expected_encoded_header)
+
+    def test_header_encode_null(self):
+        self._test_header_encode(b'', '')
+
+    def test_header_encode_one_word(self):
+        self._test_header_encode(b'hello', '=?iso-8859-1?q?hello?=')
+
+    def test_header_encode_two_lines(self):
+        self._test_header_encode(b'hello\nworld',
+                                '=?iso-8859-1?q?hello=0Aworld?=')
+
+    def test_header_encode_non_ascii(self):
+        self._test_header_encode(b'hello\xc7there',
+                                '=?iso-8859-1?q?hello=C7there?=')
+
+    def test_header_encode_alt_charset(self):
+        self._test_header_encode(b'hello', '=?iso-8859-2?q?hello?=',
+                charset='iso-8859-2')
+
+    def _test_header_decode(self, encoded_header, expected_decoded_header):
+        decoded_header = quoprimime.header_decode(encoded_header)
+        self.assertEqual(decoded_header, expected_decoded_header)
+
+    def test_header_decode_null(self):
+        self._test_header_decode('', '')
+
+    def test_header_decode_one_word(self):
+        self._test_header_decode('hello', 'hello')
+
+    def test_header_decode_two_lines(self):
+        self._test_header_decode('hello=0Aworld', 'hello\nworld')
+
+    def test_header_decode_non_ascii(self):
+        self._test_header_decode('hello=C7there', 'hello\xc7there')
+
+    def test_header_decode_re_bug_18380(self):
+        # Issue 18380: Call re.sub with a positional argument for flags in the wrong position
+        self.assertEqual(quoprimime.header_decode('=30' * 257), '0' * 257)
+
+    def _test_decode(self, encoded, expected_decoded, eol=None):
+        if eol is None:
+            decoded = quoprimime.decode(encoded)
+        else:
+            decoded = quoprimime.decode(encoded, eol=eol)
+        self.assertEqual(decoded, expected_decoded)
+
+    def test_decode_null_word(self):
+        self._test_decode('', '')
+
+    def test_decode_null_line_null_word(self):
+        self._test_decode('\r\n', '\n')
+
+    def test_decode_one_word(self):
+        self._test_decode('hello', 'hello')
+
+    def test_decode_one_word_eol(self):
+        self._test_decode('hello', 'hello', eol='X')
+
+    def test_decode_one_line(self):
+        self._test_decode('hello\r\n', 'hello\n')
+
+    def test_decode_one_line_lf(self):
+        self._test_decode('hello\n', 'hello\n')
+
+    def test_decode_one_line_cr(self):
+        self._test_decode('hello\r', 'hello\n')
+
+    def test_decode_one_line_nl(self):
+        self._test_decode('hello\n', 'helloX', eol='X')
+
+    def test_decode_one_line_crnl(self):
+        self._test_decode('hello\r\n', 'helloX', eol='X')
+
+    def test_decode_one_line_one_word(self):
+        self._test_decode('hello\r\nworld', 'hello\nworld')
+
+    def test_decode_one_line_one_word_eol(self):
+        self._test_decode('hello\r\nworld', 'helloXworld', eol='X')
+
+    def test_decode_two_lines(self):
+        self._test_decode('hello\r\nworld\r\n', 'hello\nworld\n')
+
+    def test_decode_two_lines_eol(self):
+        self._test_decode('hello\r\nworld\r\n', 'helloXworldX', eol='X')
+
+    def test_decode_one_long_line(self):
+        self._test_decode('Spam' * 250, 'Spam' * 250)
+
+    def test_decode_one_space(self):
+        self._test_decode(' ', '')
+
+    def test_decode_multiple_spaces(self):
+        self._test_decode(' ' * 5, '')
+
+    def test_decode_one_line_trailing_spaces(self):
+        self._test_decode('hello    \r\n', 'hello\n')
+
+    def test_decode_two_lines_trailing_spaces(self):
+        self._test_decode('hello    \r\nworld   \r\n', 'hello\nworld\n')
+
+    def test_decode_quoted_word(self):
+        self._test_decode('=22quoted=20words=22', '"quoted words"')
+
+    def test_decode_uppercase_quoting(self):
+        self._test_decode('ab=CD=EF', 'ab\xcd\xef')
+
+    def test_decode_lowercase_quoting(self):
+        self._test_decode('ab=cd=ef', 'ab\xcd\xef')
+
+    def test_decode_soft_line_break(self):
+        self._test_decode('soft line=\r\nbreak', 'soft linebreak')
+
+    def test_decode_false_quoting(self):
+        self._test_decode('A=1,B=A ==> A+B==2', 'A=1,B=A ==> A+B==2')
+
+    def _test_encode(self, body, expected_encoded_body, maxlinelen=None, eol=None):
+        kwargs = {}
+        if maxlinelen is None:
+            # Use body_encode's default.
+            maxlinelen = 76
+        else:
+            kwargs['maxlinelen'] = maxlinelen
+        if eol is None:
+            # Use body_encode's default.
+            eol = '\n'
+        else:
+            kwargs['eol'] = eol
+        encoded_body = quoprimime.body_encode(body, **kwargs)
+        self.assertEqual(encoded_body, expected_encoded_body)
+        if eol == '\n' or eol == '\r\n':
+            # We know how to split the result back into lines, so maxlinelen
+            # can be checked.
+            for line in encoded_body.splitlines():
+                self.assertLessEqual(len(line), maxlinelen)
+
+    def test_encode_null(self):
+        self._test_encode('', '')
+
+    def test_encode_null_lines(self):
+        self._test_encode('\n\n', '\n\n')
+
+    def test_encode_one_line(self):
+        self._test_encode('hello\n', 'hello\n')
+
+    def test_encode_one_line_crlf(self):
+        self._test_encode('hello\r\n', 'hello\n')
+
+    def test_encode_one_line_eol(self):
+        self._test_encode('hello\n', 'hello\r\n', eol='\r\n')
+
+    def test_encode_one_line_eol_after_non_ascii(self):
+        # issue 20206; see changeset 0cf700464177 for why the encode/decode.
+        self._test_encode('hello\u03c5\n'.encode('utf-8').decode('latin1'),
+                          'hello=CF=85\r\n', eol='\r\n')
+
+    def test_encode_one_space(self):
+        self._test_encode(' ', '=20')
+
+    def test_encode_one_line_one_space(self):
+        self._test_encode(' \n', '=20\n')
+
+# XXX: body_encode() expect strings, but uses ord(char) from these strings
+# to index into a 256-entry list.  For code points above 255, this will fail.
+# Should there be a check for 8-bit only ord() values in body, or at least
+# a comment about the expected input?
+
+    def test_encode_two_lines_one_space(self):
+        self._test_encode(' \n \n', '=20\n=20\n')
+
+    def test_encode_one_word_trailing_spaces(self):
+        self._test_encode('hello   ', 'hello  =20')
+
+    def test_encode_one_line_trailing_spaces(self):
+        self._test_encode('hello   \n', 'hello  =20\n')
+
+    def test_encode_one_word_trailing_tab(self):
+        self._test_encode('hello  \t', 'hello  =09')
+
+    def test_encode_one_line_trailing_tab(self):
+        self._test_encode('hello  \t\n', 'hello  =09\n')
+
+    def test_encode_trailing_space_before_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abcd =\n\n1234', maxlinelen=6)
+
+    def test_encode_trailing_space_at_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abcd=\n=20\n1234', maxlinelen=5)
+
+    def test_encode_trailing_space_beyond_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abc=\nd=20\n1234', maxlinelen=4)
+
+    def test_encode_whitespace_lines(self):
+        self._test_encode(' \n' * 5, '=20\n' * 5)
+
+    def test_encode_quoted_equals(self):
+        self._test_encode('a = b', 'a =3D b')
+
+    def test_encode_one_long_string(self):
+        self._test_encode('x' * 100, 'x' * 75 + '=\n' + 'x' * 25)
+
+    def test_encode_one_long_line(self):
+        self._test_encode('x' * 100 + '\n', 'x' * 75 + '=\n' + 'x' * 25 + '\n')
+
+    def test_encode_one_very_long_line(self):
+        self._test_encode('x' * 200 + '\n',
+                2 * ('x' * 75 + '=\n') + 'x' * 50 + '\n')
+
+    def test_encode_shortest_maxlinelen(self):
+        self._test_encode('=' * 5, '=3D=\n' * 4 + '=3D', maxlinelen=4)
+
+    def test_encode_maxlinelen_too_small(self):
+        self.assertRaises(ValueError, self._test_encode, '', '', maxlinelen=3)
+
+    def test_encode(self):
+        eq = self.assertEqual
+        eq(quoprimime.body_encode(''), '')
+        eq(quoprimime.body_encode('hello'), 'hello')
+        # Test the binary flag
+        eq(quoprimime.body_encode('hello\r\nworld'), 'hello\nworld')
+        # Test the maxlinelen arg
+        eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40), """\
+xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=
+ xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=
+x xxxx xxxx xxxx xxxx=20""")
+        # Test the eol argument
+        eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40, eol='\r\n'),
+           """\
+xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=\r
+ xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=\r
+x xxxx xxxx xxxx xxxx=20""")
+        eq(quoprimime.body_encode("""\
+one line
+
+two line"""), """\
+one line
+
+two line""")
+
+
+
+# Test the Charset class
+class TestCharset(unittest.TestCase):
+    def tearDown(self):
+        from email import charset as CharsetModule
+        try:
+            del CharsetModule.CHARSETS['fake']
+        except KeyError:
+            pass
+
+    def test_codec_encodeable(self):
+        eq = self.assertEqual
+        # Make sure us-ascii = no Unicode conversion
+        c = Charset('us-ascii')
+        eq(c.header_encode('Hello World!'), 'Hello World!')
+        # Test 8-bit idempotency with us-ascii
+        s = '\xa4\xa2\xa4\xa4\xa4\xa6\xa4\xa8\xa4\xaa'
+        self.assertRaises(UnicodeError, c.header_encode, s)
+        c = Charset('utf-8')
+        eq(c.header_encode(s), '=?utf-8?b?wqTCosKkwqTCpMKmwqTCqMKkwqo=?=')
+
+    def test_body_encode(self):
+        eq = self.assertEqual
+        # Try a charset with QP body encoding
+        c = Charset('iso-8859-1')
+        eq('hello w=F6rld', c.body_encode('hello w\xf6rld'))
+        # Try a charset with Base64 body encoding
+        c = Charset('utf-8')
+        eq('aGVsbG8gd29ybGQ=\n', c.body_encode(b'hello world'))
+        # Try a charset with None body encoding
+        c = Charset('us-ascii')
+        eq('hello world', c.body_encode('hello world'))
+        # Try the convert argument, where input codec != output codec
+        c = Charset('euc-jp')
+        # With apologies to Tokio Kikuchi ;)
+        # XXX FIXME
+##         try:
+##             eq('\x1b$B5FCO;~IW\x1b(B',
+##                c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7'))
+##             eq('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7',
+##                c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7', False))
+##         except LookupError:
+##             # We probably don't have the Japanese codecs installed
+##             pass
+        # Testing SF bug #625509, which we have to fake, since there are no
+        # built-in encodings where the header encoding is QP but the body
+        # encoding is not.
+        from email import charset as CharsetModule
+        CharsetModule.add_charset('fake', CharsetModule.QP, None, 'utf-8')
+        c = Charset('fake')
+        eq('hello world', c.body_encode('hello world'))
+
+    def test_unicode_charset_name(self):
+        charset = Charset('us-ascii')
+        self.assertEqual(str(charset), 'us-ascii')
+        self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')
+
+
+
+# Test multilingual MIME headers.
+class TestHeader(TestEmailBase):
+    def test_simple(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Hello World!')
+        eq(h.encode(), 'Hello World!')
+        h.append(' Goodbye World!')
+        eq(h.encode(), 'Hello World!  Goodbye World!')
+
+    def test_simple_surprise(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Hello World!')
+        eq(h.encode(), 'Hello World!')
+        h.append('Goodbye World!')
+        eq(h.encode(), 'Hello World! Goodbye World!')
+
+    def test_header_needs_no_decoding(self):
+        h = 'no decoding needed'
+        self.assertEqual(decode_header(h), [(h, None)])
+
+    def test_long(self):
+        h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",
+                   maxlinelen=76)
+        for l in h.encode(splitchars=' ').split('\n '):
+            self.assertLessEqual(len(l), 76)
+
+    def test_multilingual(self):
+        eq = self.ndiffAssertEqual
+        g = Charset("iso-8859-1")
+        cz = Charset("iso-8859-2")
+        utf8 = Charset("utf-8")
+        g_head = (b'Die Mieter treten hier ein werden mit einem '
+                  b'Foerderband komfortabel den Korridor entlang, '
+                  b'an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, '
+                  b'gegen die rotierenden Klingen bef\xf6rdert. ')
+        cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
+                   b'd\xf9vtipu.. ')
+        utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
+                     '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
+                     '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
+                     '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
+                     '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
+                     'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
+                     'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
+                     '\u3044\u307e\u3059\u3002')
+        h = Header(g_head, g)
+        h.append(cz_head, cz)
+        h.append(utf8_head, utf8)
+        enc = h.encode(maxlinelen=76)
+        eq(enc, """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderband_kom?=
+ =?iso-8859-1?q?fortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen_Wand?=
+ =?iso-8859-1?q?gem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef=F6r?=
+ =?iso-8859-1?q?dert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hroutily?=
+ =?iso-8859-2?q?_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
+ =?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC?=
+ =?utf-8?b?5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn?=
+ =?utf-8?b?44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFz?=
+ =?utf-8?b?IE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5k?=
+ =?utf-8?b?IGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIA=?=
+ =?utf-8?b?44Gj44Gm44GE44G+44GZ44CC?=""")
+        decoded = decode_header(enc)
+        eq(len(decoded), 3)
+        eq(decoded[0], (g_head, 'iso-8859-1'))
+        eq(decoded[1], (cz_head, 'iso-8859-2'))
+        eq(decoded[2], (utf8_head.encode('utf-8'), 'utf-8'))
+        ustr = str(h)
+        eq(ustr,
+           (b'Die Mieter treten hier ein werden mit einem Foerderband '
+            b'komfortabel den Korridor entlang, an s\xc3\xbcdl\xc3\xbcndischen '
+            b'Wandgem\xc3\xa4lden vorbei, gegen die rotierenden Klingen '
+            b'bef\xc3\xb6rdert. Finan\xc4\x8dni metropole se hroutily pod '
+            b'tlakem jejich d\xc5\xafvtipu.. \xe6\xad\xa3\xe7\xa2\xba\xe3\x81'
+            b'\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3'
+            b'\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3'
+            b'\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'
+            b'\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e'
+            b'\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3'
+            b'\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82'
+            b'\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b'
+            b'\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git '
+            b'und Slotermeyer? Ja! Beiherhund das Oder die Flipperwaldt '
+            b'gersput.\xe3\x80\x8d\xe3\x81\xa8\xe8\xa8\x80\xe3\x81\xa3\xe3\x81'
+            b'\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x99\xe3\x80\x82'
+            ).decode('utf-8'))
+        # Test make_header()
+        newh = make_header(decode_header(enc))
+        eq(newh, h)
+
+    def test_empty_header_encode(self):
+        h = Header()
+        self.assertEqual(h.encode(), '')
+
+    def test_header_ctor_default_args(self):
+        eq = self.ndiffAssertEqual
+        h = Header()
+        eq(h, '')
+        h.append('foo', Charset('iso-8859-1'))
+        eq(h, 'foo')
+
+    def test_explicit_maxlinelen(self):
+        eq = self.ndiffAssertEqual
+        hstr = ('A very long line that must get split to something other '
+                'than at the 76th character boundary to test the non-default '
+                'behavior')
+        h = Header(hstr)
+        eq(h.encode(), '''\
+A very long line that must get split to something other than at the 76th
+ character boundary to test the non-default behavior''')
+        eq(str(h), hstr)
+        h = Header(hstr, header_name='Subject')
+        eq(h.encode(), '''\
+A very long line that must get split to something other than at the
+ 76th character boundary to test the non-default behavior''')
+        eq(str(h), hstr)
+        h = Header(hstr, maxlinelen=1024, header_name='Subject')
+        eq(h.encode(), hstr)
+        eq(str(h), hstr)
+
+    def test_quopri_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(charset='iso-8859-1', maxlinelen=20)
+        x = 'xxxx ' * 20
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?iso-8859-1?q?xxx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_?=""")
+        eq(x, str(make_header(decode_header(s))))
+        h = Header(charset='iso-8859-1', maxlinelen=40)
+        h.append('xxxx ' * 20)
+        s = h.encode()
+        eq(s, """\
+=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xxx?=
+ =?iso-8859-1?q?x_xxxx_xxxx_xxxx_xxxx_?=
+ =?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xx?=
+ =?iso-8859-1?q?xx_xxxx_xxxx_xxxx_xxxx?=
+ =?iso-8859-1?q?_xxxx_xxxx_?=""")
+        eq(x, str(make_header(decode_header(s))))
+
+    def test_base64_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(charset='koi8-r', maxlinelen=20)
+        x = 'xxxx ' * 20
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IA==?=""")
+        eq(x, str(make_header(decode_header(s))))
+        h = Header(charset='koi8-r', maxlinelen=40)
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?koi8-r?b?eHh4eCB4eHh4IHh4eHggeHh4?=
+ =?koi8-r?b?eCB4eHh4IHh4eHggeHh4eCB4?=
+ =?koi8-r?b?eHh4IHh4eHggeHh4eCB4eHh4?=
+ =?koi8-r?b?IHh4eHggeHh4eCB4eHh4IHh4?=
+ =?koi8-r?b?eHggeHh4eCB4eHh4IHh4eHgg?=
+ =?koi8-r?b?eHh4eCB4eHh4IA==?=""")
+        eq(x, str(make_header(decode_header(s))))
+
+    def test_us_ascii_header(self):
+        eq = self.assertEqual
+        s = 'hello'
+        x = decode_header(s)
+        eq(x, [('hello', None)])
+        h = make_header(x)
+        eq(s, h.encode())
+
+    def test_string_charset(self):
+        eq = self.assertEqual
+        h = Header()
+        h.append('hello', 'iso-8859-1')
+        eq(h, 'hello')
+
+##    def test_unicode_error(self):
+##        raises = self.assertRaises
+##        raises(UnicodeError, Header, u'[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, Header, '[P\xf6stal]', 'us-ascii')
+##        h = Header()
+##        raises(UnicodeError, h.append, u'[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, h.append, '[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, Header, u'\u83ca\u5730\u6642\u592b', 'iso-8859-1')
+
+    def test_utf8_shortest(self):
+        eq = self.assertEqual
+        h = Header('p\xf6stal', 'utf-8')
+        eq(h.encode(), '=?utf-8?q?p=C3=B6stal?=')
+        h = Header('\u83ca\u5730\u6642\u592b', 'utf-8')
+        eq(h.encode(), '=?utf-8?b?6I+K5Zyw5pmC5aSr?=')
+
+    def test_bad_8bit_header(self):
+        raises = self.assertRaises
+        eq = self.assertEqual
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        raises(UnicodeError, Header, x)
+        h = Header()
+        raises(UnicodeError, h.append, x)
+        e = x.decode('utf-8', 'replace')
+        eq(str(Header(x, errors='replace')), e)
+        h.append(x, errors='replace')
+        eq(str(h), e)
+
+    def test_escaped_8bit_header(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        e = x.decode('ascii', 'surrogateescape')
+        h = Header(e, charset=email.charset.UNKNOWN8BIT)
+        self.assertEqual(str(h),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
+
+    def test_header_handles_binary_unknown8bit(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        h = Header(x, charset=email.charset.UNKNOWN8BIT)
+        self.assertEqual(str(h),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
+
+    def test_make_header_handles_binary_unknown8bit(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        h = Header(x, charset=email.charset.UNKNOWN8BIT)
+        h2 = email.header.make_header(email.header.decode_header(h))
+        self.assertEqual(str(h2),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h2), [(x, 'unknown-8bit')])
+
+    def test_modify_returned_list_does_not_change_header(self):
+        h = Header('test')
+        chunks = email.header.decode_header(h)
+        chunks.append(('ascii', 'test2'))
+        self.assertEqual(str(h), 'test')
+
+    def test_encoded_adjacent_nonencoded(self):
+        eq = self.assertEqual
+        h = Header()
+        h.append('hello', 'iso-8859-1')
+        h.append('world')
+        s = h.encode()
+        eq(s, '=?iso-8859-1?q?hello?= world')
+        h = make_header(decode_header(s))
+        eq(h.encode(), s)
+
+    def test_whitespace_keeper(self):
+        eq = self.assertEqual
+        s = 'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztk=?= =?koi8-r?q?=CA?= zz.'
+        parts = decode_header(s)
+        eq(parts, [(b'Subject: ', None), (b'\xf0\xd2\xcf\xd7\xc5\xd2\xcb\xc1 \xce\xc1 \xc6\xc9\xce\xc1\xcc\xd8\xce\xd9\xca', 'koi8-r'), (b' zz.', None)])
+        hdr = make_header(parts)
+        eq(hdr.encode(),
+           'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztnK?= zz.')
+
+    def test_broken_base64_header(self):
+        raises = self.assertRaises
+        s = 'Subject: =?EUC-KR?B?CSixpLDtKSC/7Liuvsax4iC6uLmwMcijIKHaILzSwd/H0SC8+LCjwLsgv7W/+Mj3I ?='
+        raises(errors.HeaderParseError, decode_header, s)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_shift_jis_charset(self):
+        h = Header('æ–‡', charset='shift_jis')
+        self.assertEqual(h.encode(), '=?iso-2022-jp?b?GyRCSjgbKEI=?=')
+
+    def test_flatten_header_with_no_value(self):
+        # Issue 11401 (regression from email 4.x)  Note that the space after
+        # the header doesn't reflect the input, but this is also the way
+        # email 4.x behaved.  At some point it would be nice to fix that.
+        msg = email.message_from_string("EmptyHeader:")
+        self.assertEqual(str(msg), "EmptyHeader: \n\n")
+
+    def test_encode_preserves_leading_ws_on_value(self):
+        msg = Message()
+        msg['SomeHeader'] = '   value with leading ws'
+        self.assertEqual(str(msg), "SomeHeader:    value with leading ws\n\n")
+
+    def test_whitespace_header(self):
+        self.assertEqual(Header(' ').encode(), ' ')
+
+
+
+# Test RFC 2231 header parameters (en/de)coding
+class TestRFC2231(TestEmailBase):
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_with_double_quotes
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_inside_double_quotes
+    def test_get_param(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_29.txt')
+        eq(msg.get_param('title'),
+           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))
+        eq(msg.get_param('title', unquote=False),
+           ('us-ascii', 'en', '"This is even more ***fun*** isn\'t it!"'))
+
+    def test_set_param(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii')
+        eq(msg.get_param('title'),
+           ('us-ascii', '', 'This is even more ***fun*** isn\'t it!'))
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii', language='en')
+        eq(msg.get_param('title'),
+           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))
+        msg = self._msgobj('msg_01.txt')
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii', language='en')
+        eq(msg.as_string(maxheaderlen=78), """\
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+\tid 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+Content-Type: text/plain; charset=us-ascii;
+ title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
+
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    def test_set_param_requote(self):
+        msg = Message()
+        msg.set_param('title', 'foo')
+        self.assertEqual(msg['content-type'], 'text/plain; title="foo"')
+        msg.set_param('title', 'bar', requote=False)
+        self.assertEqual(msg['content-type'], 'text/plain; title=bar')
+        # tspecial is still quoted.
+        msg.set_param('title', "(bar)bell", requote=False)
+        self.assertEqual(msg['content-type'], 'text/plain; title="(bar)bell"')
+
+    def test_del_param(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_01.txt')
+        msg.set_param('foo', 'bar', charset='us-ascii', language='en')
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+            charset='us-ascii', language='en')
+        msg.del_param('foo', header='Content-Type')
+        eq(msg.as_string(maxheaderlen=78), """\
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+\tid 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+Content-Type: text/plain; charset="us-ascii";
+ title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
+
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_charset
+    # I changed the charset name, though, because the one in the file isn't
+    # a legal charset name.  Should add a test for an illegal charset.
+    def test_rfc2231_get_content_charset(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_32.txt')
+        eq(msg.get_content_charset(), 'us-ascii')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_no_double_quotes
+    def test_rfc2231_parse_rfc_quoting(self):
+        m = textwrap.dedent('''\
+            Content-Disposition: inline;
+            \tfilename*0*=''This%20is%20even%20more%20;
+            \tfilename*1*=%2A%2A%2Afun%2A%2A%2A%20;
+            \tfilename*2="is it not.pdf"
+
+            ''')
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+        self.assertEqual(m, msg.as_string())
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_with_double_quotes
+    def test_rfc2231_parse_extra_quoting(self):
+        m = textwrap.dedent('''\
+            Content-Disposition: inline;
+            \tfilename*0*="''This%20is%20even%20more%20";
+            \tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+            \tfilename*2="is it not.pdf"
+
+            ''')
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+        self.assertEqual(m, msg.as_string())
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_no_language_or_charset
+    # but new test uses *0* because otherwise lang/charset is not valid.
+    # test_headerregistry.TestContentTypeHeader.rfc2231_segmented_normal_values
+    def test_rfc2231_no_language_or_charset(self):
+        m = '''\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename="file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm"
+Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEM; NAME*1=P_nsmail.htm
+
+'''
+        msg = email.message_from_string(m)
+        param = msg.get_param('NAME')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(
+            param,
+            'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_no_charset
+    def test_rfc2231_no_language_or_charset_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    # Duplicate of previous test?
+    def test_rfc2231_no_language_or_charset_in_filename_encoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_partly_encoded,
+    # but the test below is wrong (the first part should be decoded).
+    def test_rfc2231_partly_encoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            'This%20is%20even%20more%20***fun*** is it not.pdf')
+
+    def test_rfc2231_partly_nonencoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0="This%20is%20even%20more%20";
+\tfilename*1="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20is it not.pdf')
+
+    def test_rfc2231_no_language_or_charset_in_boundary(self):
+        m = '''\
+Content-Type: multipart/alternative;
+\tboundary*0*="''This%20is%20even%20more%20";
+\tboundary*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tboundary*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_boundary(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    def test_rfc2231_no_language_or_charset_in_charset(self):
+        # This is a nonsensical charset value, but tests the code anyway
+        m = '''\
+Content-Type: text/plain;
+\tcharset*0*="This%20is%20even%20more%20";
+\tcharset*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tcharset*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_content_charset(),
+                         'this is even more ***fun*** is it not.pdf')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_unknown_charset_treated_as_ascii
+    def test_rfc2231_bad_encoding_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="bogus'xx'This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    def test_rfc2231_bad_encoding_in_charset(self):
+        m = """\
+Content-Type: text/plain; charset*=bogus''utf-8%E2%80%9D
+
+"""
+        msg = email.message_from_string(m)
+        # This should return None because non-ascii characters in the charset
+        # are not allowed.
+        self.assertEqual(msg.get_content_charset(), None)
+
+    def test_rfc2231_bad_character_in_charset(self):
+        m = """\
+Content-Type: text/plain; charset*=ascii''utf-8%E2%80%9D
+
+"""
+        msg = email.message_from_string(m)
+        # This should return None because non-ascii characters in the charset
+        # are not allowed.
+        self.assertEqual(msg.get_content_charset(), None)
+
+    def test_rfc2231_bad_character_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="ascii'xx'This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2*="is it not.pdf%E2"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf\ufffd')
+
+    def test_rfc2231_unknown_encoding(self):
+        m = """\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename*=X-UNKNOWN''myfile.txt
+
+"""
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(), 'myfile.txt')
+
+    def test_rfc2231_bad_character_in_encoding(self):
+        m = """\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename*=utf-8\udce2\udc80\udc9d''myfile.txt
+
+"""
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(), 'myfile.txt')
+
+    def test_rfc2231_single_tick_in_filename_extended(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"Frank's\"; name*1*=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, None)
+        eq(language, None)
+        eq(s, "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_inside_double_quotes
+    def test_rfc2231_single_tick_in_filename(self):
+        m = """\
+Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        param = msg.get_param('name')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(param, "Frank's Document")
+
+    def test_rfc2231_missing_tick(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="'This%20is%20broken";
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            "'This is broken")
+
+    def test_rfc2231_missing_tick_with_encoded_non_ascii(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="'This%20is%E2broken";
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            "'This is\ufffdbroken")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_in_value_with_charset_and_lang
+    def test_rfc2231_tick_attack_extended(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_in_non_encoded_value
+    def test_rfc2231_tick_attack(self):
+        m = """\
+Content-Type: application/x-foo;
+\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        param = msg.get_param('name')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(param, "us-ascii'en-us'Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quotes_inside_quotes
+    def test_rfc2231_no_extended_values(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo; name=\"Frank's Document\"
+
+"""
+        msg = email.message_from_string(m)
+        eq(msg.get_param('name'), "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_then_unencoded_segments
+    def test_rfc2231_encoded_then_unencoded_segments(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"us-ascii'en-us'My\";
+\tname*1=\" Document\";
+\tname*2*=\" For You\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, 'My Document For You')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_unencoded_then_encoded_segments
+    # test_headerregistry.TestContentTypeHeader.rfc2231_quoted_unencoded_then_encoded_segments
+    def test_rfc2231_unencoded_then_encoded_segments(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0=\"us-ascii'en-us'My\";
+\tname*1*=\" Document\";
+\tname*2*=\" For You\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, 'My Document For You')
+
+    def test_should_not_hang_on_invalid_ew_messages(self):
+        messages = ["""From: user@host.com
+To: user@host.com
+Bad-Header:
+ =?us-ascii?Q?LCSwrV11+IB0rSbSker+M9vWR7wEDSuGqmHD89Gt=ea0nJFSaiz4vX3XMJPT4vrE?=
+ =?us-ascii?Q?xGUZeOnp0o22pLBB7CYLH74Js=wOlK6Tfru2U47qR?=
+ =?us-ascii?Q?72OfyEY2p2=2FrA9xNFyvH+fBTCmazxwzF8nGkK6D?=
+
+Hello!
+""", """From: ����� �������� <xxx@xxx>
+To: "xxx" <xxx@xxx>
+Subject:   ��� ���������� ����� ����� � ��������� �� ����
+MIME-Version: 1.0
+Content-Type: text/plain; charset="windows-1251";
+Content-Transfer-Encoding: 8bit
+
+�� ����� � ���� ������ ��� ��������
+"""]
+        for m in messages:
+            with self.subTest(m=m):
+                msg = email.message_from_string(m)
+
+
+# Tests to ensure that signed parts of an email are completely preserved, as
+# required by RFC1847 section 2.1.  Note that these are incomplete, because the
+# email package does not currently always preserve the body.  See issue 1670765.
+class TestSigned(TestEmailBase):
+
+    def _msg_and_obj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            original = fp.read()
+            msg = email.message_from_string(original)
+        return original, msg
+
+    def _signed_parts_eq(self, original, result):
+        # Extract the first mime part of each message
+        import re
+        repart = re.compile(r'^--([^\n]+)\n(.*?)\n--\1$', re.S | re.M)
+        inpart = repart.search(original).group(2)
+        outpart = repart.search(result).group(2)
+        self.assertEqual(outpart, inpart)
+
+    def test_long_headers_as_string(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        result = msg.as_string()
+        self._signed_parts_eq(original, result)
+
+    def test_long_headers_as_string_maxheaderlen(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        result = msg.as_string(maxheaderlen=60)
+        self._signed_parts_eq(original, result)
+
+    def test_long_headers_flatten(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        fp = StringIO()
+        Generator(fp).flatten(msg)
+        result = fp.getvalue()
+        self._signed_parts_eq(original, result)
+
+class TestHeaderRegistry(TestEmailBase):
+    # See issue gh-93010.
+    def test_HeaderRegistry(self):
+        reg = HeaderRegistry()
+        a = reg('Content-Disposition', 'attachment; 0*00="foo"')
+        self.assertIsInstance(a.defects[0], errors.InvalidHeaderDefect)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_generator.py b/Lib/test/test_email/test_generator.py
new file mode 100644
index 00000000000..c75a842c335
--- /dev/null
+++ b/Lib/test/test_email/test_generator.py
@@ -0,0 +1,477 @@
+import io
+import textwrap
+import unittest
+from email import message_from_string, message_from_bytes
+from email.message import EmailMessage
+from email.generator import Generator, BytesGenerator
+from email.headerregistry import Address
+from email import policy
+import email.errors
+from test.test_email import TestEmailBase, parameterize
+
+
+@parameterize
+class TestGeneratorBase:
+
+    policy = policy.default
+
+    def msgmaker(self, msg, policy=None):
+        policy = self.policy if policy is None else policy
+        return self.msgfunc(msg, policy=policy)
+
+    refold_long_expected = {
+        0: textwrap.dedent("""\
+            To: whom_it_may_concern@example.com
+            From: nobody_you_want_to_know@example.com
+            Subject: We the willing led by the unknowing are doing the
+             impossible for the ungrateful. We have done so much for so long with so little
+             we are now qualified to do anything with nothing.
+
+            None
+            """),
+        40: textwrap.dedent("""\
+            To: whom_it_may_concern@example.com
+            From:
+             nobody_you_want_to_know@example.com
+            Subject: We the willing led by the
+             unknowing are doing the impossible for
+             the ungrateful. We have done so much
+             for so long with so little we are now
+             qualified to do anything with nothing.
+
+            None
+            """),
+        20: textwrap.dedent("""\
+            To:
+             whom_it_may_concern@example.com
+            From:
+             nobody_you_want_to_know@example.com
+            Subject: We the
+             willing led by the
+             unknowing are doing
+             the impossible for
+             the ungrateful. We
+             have done so much
+             for so long with so
+             little we are now
+             qualified to do
+             anything with
+             nothing.
+
+            None
+            """),
+        }
+    refold_long_expected[100] = refold_long_expected[0]
+
+    refold_all_expected = refold_long_expected.copy()
+    refold_all_expected[0] = (
+            "To: whom_it_may_concern@example.com\n"
+            "From: nobody_you_want_to_know@example.com\n"
+            "Subject: We the willing led by the unknowing are doing the "
+              "impossible for the ungrateful. We have done so much for "
+              "so long with so little we are now qualified to do anything "
+              "with nothing.\n"
+              "\n"
+              "None\n")
+    refold_all_expected[100] = (
+            "To: whom_it_may_concern@example.com\n"
+            "From: nobody_you_want_to_know@example.com\n"
+            "Subject: We the willing led by the unknowing are doing the "
+                "impossible for the ungrateful. We have\n"
+              " done so much for so long with so little we are now qualified "
+                "to do anything with nothing.\n"
+              "\n"
+              "None\n")
+
+    length_params = [n for n in refold_long_expected]
+
+    def length_as_maxheaderlen_parameter(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, maxheaderlen=n, policy=self.policy)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_max_line_length_policy(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_maxheaderlen_parm_overrides_policy(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, maxheaderlen=n,
+                          policy=self.policy.clone(max_line_length=10))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_max_line_length_with_refold_none_does_not_fold(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='none',
+                                                      max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[0]))
+
+    def length_as_max_line_length_with_refold_all_folds(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all',
+                                                      max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_all_expected[n]))
+
+    def test_crlf_control_via_policy(self):
+        source = "Subject: test\r\n\r\ntest body\r\n"
+        expected = source
+        msg = self.msgmaker(self.typ(source))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.SMTP)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_linesep_overrides_policy(self):
+        source = "Subject: test\n\ntest body\n"
+        expected = source
+        msg = self.msgmaker(self.typ(source))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.SMTP)
+        g.flatten(msg, linesep='\n')
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_linesep(self):
+        source = 'Subject: one\n two\r three\r\n four\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one two three four')
+
+        expected = 'Subject: one\n two\n three\n four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        expected = 'Subject: one two three four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_control_linesep(self):
+        source = 'Subject: one\v two\f three\x1c four\x1d five\x1e six\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one\v two\f three\x1c four\x1d five\x1e six')
+
+        expected = 'Subject: one\v two\f three\x1c four\x1d five\x1e six\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_set_mangle_from_via_policy(self):
+        source = textwrap.dedent("""\
+            Subject: test that
+             from is mangled in the body!
+
+            From time to time I write a rhyme.
+            """)
+        variants = (
+            (None, True),
+            (policy.compat32, True),
+            (policy.default, False),
+            (policy.default.clone(mangle_from_=True), True),
+            )
+        for p, mangle in variants:
+            expected = source.replace('From ', '>From ') if mangle else source
+            with self.subTest(policy=p, mangle_from_=mangle):
+                msg = self.msgmaker(self.typ(source))
+                s = self.ioclass()
+                g = self.genclass(s, policy=p)
+                g.flatten(msg)
+                self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_compat32_max_line_length_does_not_fold_when_none(self):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.compat32.clone(max_line_length=None))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[0]))
+
+    def test_rfc2231_wrapping(self):
+        # This is pretty much just to make sure we don't have an infinite
+        # loop; I don't expect anyone to hit this in the field.
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename="afilenamelongenoghtowraphere"
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename*0*=us-ascii''afilename;
+             filename*1*=longenoghtowraphere
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=33))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_rfc2231_wrapping_switches_to_default_len_if_too_narrow(self):
+        # This is just to make sure we don't have an infinite loop; I don't
+        # expect anyone to hit this in the field, so I'm not bothering to make
+        # the result optimal (the encoding isn't needed).
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename="afilenamelongenoghtowraphere"
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Content-Disposition:
+             attachment;
+             filename*0*=us-ascii''afilenamelongenoghtowraphere
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=20))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_keep_encoded_newlines(self):
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=80))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_keep_long_encoded_newlines(self):
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject
+             =?utf-8?q?=0A?=Bcc:
+             injection@example.com
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=30))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+
+class TestGenerator(TestGeneratorBase, TestEmailBase):
+
+    msgfunc = staticmethod(message_from_string)
+    genclass = Generator
+    ioclass = io.StringIO
+    typ = str
+
+    def test_flatten_unicode_linesep(self):
+        source = 'Subject: one\x85 two\u2028 three\u2029 four\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one\x85 two\u2028 three\u2029 four')
+
+        expected = 'Subject: =?utf-8?b?b25lwoUgdHdv4oCoIHRocmVl4oCp?= four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_verify_generated_headers(self):
+        """gh-121650: by default the generator prevents header injection"""
+        class LiteralHeader(str):
+            name = 'Header'
+            def fold(self, **kwargs):
+                return self
+
+        for text in (
+            'Value\r\nBad Injection\r\n',
+            'NoNewLine'
+        ):
+            with self.subTest(text=text):
+                message = message_from_string(
+                    "Header: Value\r\n\r\nBody",
+                    policy=self.policy,
+                )
+
+                del message['Header']
+                message['Header'] = LiteralHeader(text)
+
+                with self.assertRaises(email.errors.HeaderWriteError):
+                    message.as_string()
+
+
+class TestBytesGenerator(TestGeneratorBase, TestEmailBase):
+
+    msgfunc = staticmethod(message_from_bytes)
+    genclass = BytesGenerator
+    ioclass = io.BytesIO
+    typ = lambda self, x: x.encode('ascii')
+
+    def test_defaults_handle_spaces_between_encoded_words_when_folded(self):
+        source = ("Уведомление о прин�тии в работу обращени� дл�"
+                  " подключени� у�луги")
+        expected = ('Subject: =?utf-8?b?0KPQstC10LTQvtC80LvQtdC90LjQtSDQviDQv9GA0LjQvdGP0YLQuNC4?=\n'
+                    ' =?utf-8?b?INCyINGA0LDQsdC+0YLRgyDQvtCx0YDQsNGJ0LXQvdC40Y8g0LTQu9GPINC/0L4=?=\n'
+                    ' =?utf-8?b?0LTQutC70Y7Rh9C10L3QuNGPINGD0YHQu9GD0LPQuA==?=\n\n').encode('ascii')
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_when_encoded_words_is_folded_in_middle(self):
+        source = ('A very long long long long long long long long long long long long '
+                  'long long long long long long long long long long long súmmäry')
+        expected = ('Subject: A very long long long long long long long long long long long long\n'
+                    ' long long long long long long long long long long long =?utf-8?q?s=C3=BAmm?=\n'
+                    ' =?utf-8?q?=C3=A4ry?=\n\n').encode('ascii')
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_at_start_of_subject(self):
+        source = " Уведомление"
+        expected = b"Subject:  =?utf-8?b?0KPQstC10LTQvtC80LvQtdC90LjQtQ==?=\n\n"
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_at_start_of_continuation_line(self):
+        source = " Ñ„ Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„Ñ„ Ñ„ Ñ„"
+        expected = (b"Subject:  "
+                    b"=?utf-8?b?0YQg0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YQ=?=\n"
+                    b" =?utf-8?b?INGEINGE?=\n\n")
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_cte_type_7bit_handles_unknown_8bit(self):
+        source = ("Subject: Maintenant je vous présente mon "
+                 "collègue\n\n").encode('utf-8')
+        expected = ('Subject: Maintenant je vous =?unknown-8bit?q?'
+                    'pr=C3=A9sente_mon_coll=C3=A8gue?=\n\n').encode('ascii')
+        msg = message_from_bytes(source)
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=self.policy.clone(cte_type='7bit'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_cte_type_7bit_transforms_8bit_cte(self):
+        source = textwrap.dedent("""\
+            From: foo@bar.com
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink
+            Mime-Version: 1.0
+            Content-Type: text/plain; charset="latin-1"
+            Content-Transfer-Encoding: 8bit
+
+            oh là là, know what I mean, know what I mean?
+            """).encode('latin1')
+        msg = message_from_bytes(source)
+        expected =  textwrap.dedent("""\
+            From: foo@bar.com
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink
+            Mime-Version: 1.0
+            Content-Type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            oh l=E0 l=E0, know what I mean, know what I mean?
+            """).encode('ascii')
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=self.policy.clone(cte_type='7bit',
+                                                       linesep='\n'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_smtputf8_policy(self):
+        msg = EmailMessage()
+        msg['From'] = "Páolo <főo@bar.com>"
+        msg['To'] = 'Dinsdale'
+        msg['Subject'] = 'Nudge nudge, wink, wink \u1F609'
+        msg.set_content("oh là là, know what I mean, know what I mean?")
+        expected = textwrap.dedent("""\
+            From: Páolo <főo@bar.com>
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink \u1F609
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            oh là là, know what I mean, know what I mean?
+            """).encode('utf-8').replace(b'\n', b'\r\n')
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=policy.SMTPUTF8)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_smtp_policy(self):
+        msg = EmailMessage()
+        msg["From"] = Address(addr_spec="foo@bar.com", display_name="Páolo")
+        msg["To"] = Address(addr_spec="bar@foo.com", display_name="Dinsdale")
+        msg["Subject"] = "Nudge nudge, wink, wink"
+        msg.set_content("oh boy, know what I mean, know what I mean?")
+        expected = textwrap.dedent("""\
+            From: =?utf-8?q?P=C3=A1olo?= <foo@bar.com>
+            To: Dinsdale <bar@foo.com>
+            Subject: Nudge nudge, wink, wink
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            oh boy, know what I mean, know what I mean?
+            """).encode().replace(b"\n", b"\r\n")
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=policy.SMTP)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_headerregistry.py b/Lib/test/test_email/test_headerregistry.py
new file mode 100644
index 00000000000..d2c571299bc
--- /dev/null
+++ b/Lib/test/test_email/test_headerregistry.py
@@ -0,0 +1,1822 @@
+import datetime
+import textwrap
+import unittest
+from email import errors
+from email import policy
+from email.message import Message
+from test.test_email import TestEmailBase, parameterize
+from email import headerregistry
+from email.headerregistry import Address, Group
+from email.header import decode_header
+from test.support import ALWAYS_EQ
+
+
+DITTO = object()
+
+
+class TestHeaderRegistry(TestEmailBase):
+
+    def test_arbitrary_name_unstructured(self):
+        factory = headerregistry.HeaderRegistry()
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_name_case_ignored(self):
+        factory = headerregistry.HeaderRegistry()
+        # Whitebox check that test is valid
+        self.assertNotIn('Subject', factory.registry)
+        h = factory('Subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UniqueUnstructuredHeader)
+
+    class FooBase:
+        def __init__(self, *args, **kw):
+            pass
+
+    def test_override_default_base_class(self):
+        factory = headerregistry.HeaderRegistry(base_class=self.FooBase)
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, self.FooBase)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    class FooDefault:
+        parse = headerregistry.UnstructuredHeader.parse
+
+    def test_override_default_class(self):
+        factory = headerregistry.HeaderRegistry(default_class=self.FooDefault)
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, self.FooDefault)
+
+    def test_override_default_class_only_overrides_default(self):
+        factory = headerregistry.HeaderRegistry(default_class=self.FooDefault)
+        h = factory('subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UniqueUnstructuredHeader)
+
+    def test_dont_use_default_map(self):
+        factory = headerregistry.HeaderRegistry(use_default_map=False)
+        h = factory('subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_map_to_type(self):
+        factory = headerregistry.HeaderRegistry()
+        h1 = factory('foobar', 'test')
+        factory.map_to_type('foobar', headerregistry.UniqueUnstructuredHeader)
+        h2 = factory('foobar', 'test')
+        self.assertIsInstance(h1, headerregistry.BaseHeader)
+        self.assertIsInstance(h1, headerregistry.UnstructuredHeader)
+        self.assertIsInstance(h2, headerregistry.BaseHeader)
+        self.assertIsInstance(h2, headerregistry.UniqueUnstructuredHeader)
+
+
+class TestHeaderBase(TestEmailBase):
+
+    factory = headerregistry.HeaderRegistry()
+
+    def make_header(self, name, value):
+        return self.factory(name, value)
+
+
+class TestBaseHeaderFeatures(TestHeaderBase):
+
+    def test_str(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertIsInstance(h, str)
+        self.assertEqual(h, 'this is a test')
+        self.assertEqual(str(h), 'this is a test')
+
+    def test_substr(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h[5:7], 'is')
+
+    def test_has_name(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h.name, 'subject')
+
+    def _test_attr_ro(self, attr):
+        h = self.make_header('subject', 'this is a test')
+        with self.assertRaises(AttributeError):
+            setattr(h, attr, 'foo')
+
+    def test_name_read_only(self):
+        self._test_attr_ro('name')
+
+    def test_defects_read_only(self):
+        self._test_attr_ro('defects')
+
+    def test_defects_is_tuple(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(len(h.defects), 0)
+        self.assertIsInstance(h.defects, tuple)
+        # Make sure it is still true when there are defects.
+        h = self.make_header('date', '')
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects, tuple)
+
+    # XXX: FIXME
+    #def test_CR_in_value(self):
+    #    # XXX: this also re-raises the issue of embedded headers,
+    #    # need test and solution for that.
+    #    value = '\r'.join(['this is', ' a test'])
+    #    h = self.make_header('subject', value)
+    #    self.assertEqual(h, value)
+    #    self.assertDefectsEqual(h.defects, [errors.ObsoleteHeaderDefect])
+
+
+@parameterize
+class TestUnstructuredHeader(TestHeaderBase):
+
+    def string_as_value(self,
+                        source,
+                        decoded,
+                        *args):
+        # TODO: RUSTPYTHON; RustPython currently does not support non-utf8 encoding
+        if source == '=?gb2312?b?1eLKx9bQzsSy4srUo6E=?=':
+            raise unittest.SkipTest("TODO: RUSTPYTHON; RustPython currently does not support non-utf8 encoding")
+        # RUSTPYTHON: End
+        # ------------------------------------------------------------------
+        l = len(args)
+        defects = args[0] if l>0 else []
+        header = 'Subject:' + (' ' if source else '')
+        folded = header + (args[1] if l>1 else source) + '\n'
+        h = self.make_header('Subject', source)
+        self.assertEqual(h, decoded)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    string_params = {
+
+        'rfc2047_simple_quopri': (
+            '=?utf-8?q?this_is_a_test?=',
+            'this is a test',
+            [],
+            'this is a test'),
+
+        'rfc2047_gb2312_base64': (
+            '=?gb2312?b?1eLKx9bQzsSy4srUo6E=?=',
+            '\u8fd9\u662f\u4e2d\u6587\u6d4b\u8bd5\uff01',
+            [],
+            '=?utf-8?b?6L+Z5piv5Lit5paH5rWL6K+V77yB?='),
+
+        'rfc2047_simple_nonascii_quopri': (
+            '=?utf-8?q?=C3=89ric?=',
+            'Éric'),
+
+        'rfc2047_quopri_with_regular_text': (
+            'The =?utf-8?q?=C3=89ric=2C?= Himself',
+            'The Éric, Himself'),
+
+    }
+
+
+@parameterize
+class TestDateHeader(TestHeaderBase):
+
+    datestring = 'Sun, 23 Sep 2001 20:10:55 -0700'
+    utcoffset = datetime.timedelta(hours=-7)
+    tz = datetime.timezone(utcoffset)
+    dt = datetime.datetime(2001, 9, 23, 20, 10, 55, tzinfo=tz)
+
+    def test_parse_date(self):
+        h = self.make_header('date', self.datestring)
+        self.assertEqual(h, self.datestring)
+        self.assertEqual(h.datetime, self.dt)
+        self.assertEqual(h.datetime.utcoffset(), self.utcoffset)
+        self.assertEqual(h.defects, ())
+
+    def test_set_from_datetime(self):
+        h = self.make_header('date', self.dt)
+        self.assertEqual(h, self.datestring)
+        self.assertEqual(h.datetime, self.dt)
+        self.assertEqual(h.defects, ())
+
+    def test_date_header_properties(self):
+        h = self.make_header('date', self.datestring)
+        self.assertIsInstance(h, headerregistry.UniqueDateHeader)
+        self.assertEqual(h.max_count, 1)
+        self.assertEqual(h.defects, ())
+
+    def test_resent_date_header_properties(self):
+        h = self.make_header('resent-date', self.datestring)
+        self.assertIsInstance(h, headerregistry.DateHeader)
+        self.assertEqual(h.max_count, None)
+        self.assertEqual(h.defects, ())
+
+    def test_no_value_is_defect(self):
+        h = self.make_header('date', '')
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.HeaderMissingRequiredValue)
+
+    def test_invalid_date_format(self):
+        s = 'Not a date header'
+        h = self.make_header('date', s)
+        self.assertEqual(h, s)
+        self.assertIsNone(h.datetime)
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.InvalidDateDefect)
+
+    def test_invalid_date_value(self):
+        s = 'Tue, 06 Jun 2017 27:39:33 +0600'
+        h = self.make_header('date', s)
+        self.assertEqual(h, s)
+        self.assertIsNone(h.datetime)
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.InvalidDateDefect)
+
+    def test_datetime_read_only(self):
+        h = self.make_header('date', self.datestring)
+        with self.assertRaises(AttributeError):
+            h.datetime = 'foo'
+
+    def test_set_date_header_from_datetime(self):
+        m = Message(policy=policy.default)
+        m['Date'] = self.dt
+        self.assertEqual(m['Date'], self.datestring)
+        self.assertEqual(m['Date'].datetime, self.dt)
+
+
+@parameterize
+class TestContentTypeHeader(TestHeaderBase):
+
+    def content_type_as_value(self,
+                              source,
+                              content_type,
+                              maintype,
+                              subtype,
+                              *args):
+        l = len(args)
+        parmdict = args[0] if l>0 else {}
+        defects =  args[1] if l>1 else []
+        decoded =  args[2] if l>2 and args[2] is not DITTO else source
+        header = 'Content-Type:' + ' ' if source else ''
+        folded = args[3] if l>3 else header + decoded + '\n'
+        h = self.make_header('Content-Type', source)
+        self.assertEqual(h.content_type, content_type)
+        self.assertEqual(h.maintype, maintype)
+        self.assertEqual(h.subtype, subtype)
+        self.assertEqual(h.params, parmdict)
+        with self.assertRaises(TypeError):
+            h.params['abc'] = 'xyz'   # make sure params is read-only.
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    content_type_params = {
+
+        # Examples from RFC 2045.
+
+        'RFC_2045_1': (
+            'text/plain; charset=us-ascii (Plain text)',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        'RFC_2045_2': (
+            'text/plain; charset=us-ascii',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        'RFC_2045_3': (
+            'text/plain; charset="us-ascii"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'}),
+
+        # RFC 2045 5.2 says syntactically invalid values are to be treated as
+        # text/plain.
+
+        'no_subtype_in_content_type': (
+            'text/',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'no_slash_in_content_type': (
+            'foo',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'junk_text_in_content_type': (
+            '<crazy "stuff">',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'too_many_slashes_in_content_type': (
+            'image/jpeg/foo',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        # But unknown names are OK.  We could make non-IANA names a defect, but
+        # by not doing so we make ourselves future proof.  The fact that they
+        # are unknown will be detectable by the fact that they don't appear in
+        # the mime_registry...and the application is free to extend that list
+        # to handle them even if the core library doesn't.
+
+        'unknown_content_type': (
+            'bad/names',
+            'bad/names',
+            'bad',
+            'names'),
+
+        # The content type is case insensitive, and CFWS is ignored.
+
+        'mixed_case_content_type': (
+            'ImAge/JPeg',
+            'image/jpeg',
+            'image',
+            'jpeg'),
+
+        'spaces_in_content_type': (
+            '  text  /  plain  ',
+            'text/plain',
+            'text',
+            'plain'),
+
+        'cfws_in_content_type': (
+            '(foo) text (bar)/(baz)plain(stuff)',
+            'text/plain',
+            'text',
+            'plain'),
+
+        # test some parameters (more tests could be added for parameters
+        # associated with other content types, but since parameter parsing is
+        # generic they would be redundant for the current implementation).
+
+        'charset_param': (
+            'text/plain; charset="utf-8"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8'}),
+
+        'capitalized_charset': (
+            'text/plain; charset="US-ASCII"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'US-ASCII'}),
+
+        'unknown_charset': (
+            'text/plain; charset="fOo"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'fOo'}),
+
+        'capitalized_charset_param_name_and_comment': (
+            'text/plain; (interjection) Charset="utf-8"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8'},
+            [],
+            # Should the parameter name be lowercased here?
+            'text/plain; Charset="utf-8"'),
+
+        # Since this is pretty much the ur-mimeheader, we'll put all the tests
+        # that exercise the parameter parsing and formatting here.  Note that
+        # when we refold we may canonicalize, so things like whitespace,
+        # quoting, and rfc2231 encoding may change from what was in the input
+        # header.
+
+        'unquoted_param_value': (
+            'text/plain; title=foo',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': 'foo'},
+            [],
+            'text/plain; title="foo"',
+            ),
+
+        'param_value_with_tspecials': (
+            'text/plain; title="(bar)foo blue"',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': '(bar)foo blue'}),
+
+        'param_with_extra_quoted_whitespace': (
+            'text/plain; title="  a     loong  way \t home   "',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': '  a     loong  way \t home   '}),
+
+        'bad_params': (
+            'blarg; baz; boo',
+            'text/plain',
+            'text',
+            'plain',
+            {'baz': '', 'boo': ''},
+            [errors.InvalidHeaderDefect]*3),
+
+        'spaces_around_param_equals': (
+            'Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"',
+            'multipart/mixed',
+            'multipart',
+            'mixed',
+            {'boundary': 'CPIMSSMTPC06p5f3tG'},
+            [],
+            'Multipart/mixed; boundary="CPIMSSMTPC06p5f3tG"',
+            ),
+
+        'spaces_around_semis': (
+            ('image/jpeg; name="wibble.JPG" ; x-mac-type="4A504547" ; '
+                'x-mac-creator="474B4F4E"'),
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'wibble.JPG',
+             'x-mac-type': '4A504547',
+             'x-mac-creator': '474B4F4E'},
+            [],
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"'),
+            ('Content-Type: image/jpeg; name="wibble.JPG";'
+                ' x-mac-type="4A504547";\n'
+             ' x-mac-creator="474B4F4E"\n'),
+            ),
+
+        'lots_of_mime_params': (
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"; x-extrastuff="make it longer"'),
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'wibble.JPG',
+             'x-mac-type': '4A504547',
+             'x-mac-creator': '474B4F4E',
+             'x-extrastuff': 'make it longer'},
+            [],
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"; x-extrastuff="make it longer"'),
+            # In this case the whole of the MimeParameters does *not* fit
+            # one one line, so we break at a lower syntactic level.
+            ('Content-Type: image/jpeg; name="wibble.JPG";'
+                ' x-mac-type="4A504547";\n'
+             ' x-mac-creator="474B4F4E"; x-extrastuff="make it longer"\n'),
+            ),
+
+        'semis_inside_quotes': (
+            'image/jpeg; name="Jim&amp;&amp;Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'Jim&amp;&amp;Jill'}),
+
+        'single_quotes_inside_quotes': (
+            'image/jpeg; name="Jim \'Bob\' Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': "Jim 'Bob' Jill"}),
+
+        'double_quotes_inside_quotes': (
+            r'image/jpeg; name="Jim \"Bob\" Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'Jim "Bob" Jill'},
+            [],
+            r'image/jpeg; name="Jim \"Bob\" Jill"'),
+
+        'non_ascii_in_params': (
+            ('foo\xa7/bar; b\xa7r=two; '
+                'baz=thr\xa7e'.encode('latin-1').decode('us-ascii',
+                                                        'surrogateescape')),
+            'foo\uFFFD/bar',
+            'foo\uFFFD',
+            'bar',
+            {'b\uFFFDr': 'two', 'baz': 'thr\uFFFDe'},
+            [errors.UndecodableBytesDefect]*3,
+            'foo�/bar; b�r="two"; baz="thr�e"',
+            # XXX Two bugs here: the mime type is not allowed to be an encoded
+            # word, and we shouldn't be emitting surrogates in the parameter
+            # names.  But I don't know what the behavior should be here, so I'm
+            # punting for now.  In practice this is unlikely to be encountered
+            # since headers with binary in them only come from a binary source
+            # and are almost certain to be re-emitted without refolding.
+            'Content-Type: =?unknown-8bit?q?foo=A7?=/bar; b\udca7r="two";\n'
+            " baz*=unknown-8bit''thr%A7e\n",
+            ),
+
+        # RFC 2231 parameter tests.
+
+        'rfc2231_segmented_normal_values': (
+            'image/jpeg; name*0="abc"; name*1=".html"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': "abc.html"},
+            [],
+            'image/jpeg; name="abc.html"'),
+
+        'quotes_inside_rfc2231_value': (
+            r'image/jpeg; bar*0="baz\"foobar"; bar*1="\"baz"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'bar': 'baz"foobar"baz'},
+            [],
+            r'image/jpeg; bar="baz\"foobar\"baz"'),
+
+        'non_ascii_rfc2231_value': (
+            ('text/plain; charset=us-ascii; '
+             "title*=us-ascii'en'This%20is%20"
+             'not%20f\xa7n').encode('latin-1').decode('us-ascii',
+                                                     'surrogateescape'),
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii', 'title': 'This is not f\uFFFDn'},
+             [errors.UndecodableBytesDefect],
+             'text/plain; charset="us-ascii"; title="This is not f�n"',
+            'Content-Type: text/plain; charset="us-ascii";\n'
+            " title*=unknown-8bit''This%20is%20not%20f%A7n\n",
+            ),
+
+        'rfc2231_encoded_charset': (
+            'text/plain; charset*=ansi-x3.4-1968\'\'us-ascii',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        # This follows the RFC: no double quotes around encoded values.
+        'rfc2231_encoded_no_double_quotes': (
+            ("text/plain;"
+                "\tname*0*=''This%20is%20;"
+                "\tname*1*=%2A%2A%2Afun%2A%2A%2A%20;"
+                '\tname*2="is it not.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is ***fun*** is it not.pdf'},
+            [],
+            'text/plain; name="This is ***fun*** is it not.pdf"',
+            ),
+
+        # Make sure we also handle it if there are spurious double quotes.
+        'rfc2231_encoded_with_double_quotes': (
+            ("text/plain;"
+                '\tname*0*="us-ascii\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it not.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it not.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it not.pdf"',
+            ),
+
+        'rfc2231_single_quote_inside_double_quotes': (
+            ('text/plain; charset=us-ascii;'
+               '\ttitle*0*="us-ascii\'en\'This%20is%20really%20";'
+               '\ttitle*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+               '\ttitle*2="isn\'t it!"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii', 'title': "This is really ***fun*** isn't it!"},
+            [errors.InvalidHeaderDefect]*2,
+            ('text/plain; charset="us-ascii"; '
+               'title="This is really ***fun*** isn\'t it!"'),
+            ('Content-Type: text/plain; charset="us-ascii";\n'
+                ' title="This is really ***fun*** isn\'t it!"\n'),
+            ),
+
+        'rfc2231_single_quote_in_value_with_charset_and_lang': (
+            ('application/x-foo;'
+                "\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\""),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "Frank's Document"},
+            [errors.InvalidHeaderDefect]*2,
+            'application/x-foo; name="Frank\'s Document"',
+            ),
+
+        'rfc2231_single_quote_in_non_encoded_value': (
+            ('application/x-foo;'
+                "\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\""),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "us-ascii'en-us'Frank's Document"},
+            [],
+            'application/x-foo; name="us-ascii\'en-us\'Frank\'s Document"',
+             ),
+
+        'rfc2231_no_language_or_charset': (
+            'text/plain; NAME*0*=english_is_the_default.html',
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'english_is_the_default.html'},
+            [errors.InvalidHeaderDefect],
+            'text/plain; NAME="english_is_the_default.html"'),
+
+        'rfc2231_encoded_no_charset': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it.pdf"',
+            ),
+
+        'rfc2231_partly_encoded': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it.pdf"',
+            ),
+
+        'rfc2231_partly_encoded_2': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more %2A%2A%2Afun%2A%2A%2A%20is it.pdf'},
+            [errors.InvalidHeaderDefect],
+            ('text/plain;'
+             ' name="This is even more %2A%2A%2Afun%2A%2A%2A%20is it.pdf"'),
+            ('Content-Type: text/plain;\n'
+             ' name="This is even more %2A%2A%2Afun%2A%2A%2A%20is'
+                ' it.pdf"\n'),
+            ),
+
+        'rfc2231_unknown_charset_treated_as_ascii': (
+            "text/plain; name*0*=bogus'xx'ascii_is_the_default",
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'ascii_is_the_default'},
+            [],
+            'text/plain; name="ascii_is_the_default"'),
+
+        'rfc2231_bad_character_in_charset_parameter_value': (
+            "text/plain; charset*=ascii''utf-8%F1%F2%F3",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8\uFFFD\uFFFD\uFFFD'},
+            [errors.UndecodableBytesDefect],
+            'text/plain; charset="utf-8\uFFFD\uFFFD\uFFFD"',
+            "Content-Type: text/plain;"
+            " charset*=unknown-8bit''utf-8%F1%F2%F3\n",
+            ),
+
+        'rfc2231_utf8_in_supposedly_ascii_charset_parameter_value': (
+            "text/plain; charset*=ascii''utf-8%E2%80%9D",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8�'},
+            [errors.UndecodableBytesDefect],
+            'text/plain; charset="utf-8�"',
+            # XXX Should folding change the charset to utf8?  Currently it just
+            # reproduces the original, which is arguably fine.
+            "Content-Type: text/plain;"
+            " charset*=unknown-8bit''utf-8%E2%80%9D\n",
+            ),
+
+        'rfc2231_nonascii_in_charset_of_charset_parameter_value': (
+            "text/plain; charset*=utf-8�''utf-8%E2%80%9D",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8�'},
+            [],
+            'text/plain; charset="utf-8�"',
+            "Content-Type: text/plain;"
+            " charset*=utf-8''utf-8%E2%80%9D\n",
+            ),
+
+        'rfc2231_encoded_then_unencoded_segments': (
+            ('application/x-foo;'
+                '\tname*0*="us-ascii\'en-us\'My";'
+                '\tname*1=" Document";'
+                '\tname*2=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': 'My Document For You'},
+            [errors.InvalidHeaderDefect],
+            'application/x-foo; name="My Document For You"',
+            ),
+
+        # My reading of the RFC is that this is an invalid header.  The RFC
+        # says that if charset and language information is given, the first
+        # segment *must* be encoded.
+        'rfc2231_unencoded_then_encoded_segments': (
+            ('application/x-foo;'
+                '\tname*0=us-ascii\'en-us\'My;'
+                '\tname*1*=" Document";'
+                '\tname*2*=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': 'My Document For You'},
+            [errors.InvalidHeaderDefect]*3,
+            'application/x-foo; name="My Document For You"',
+            ),
+
+        # XXX: I would say this one should default to ascii/en for the
+        # "encoded" segment, since the first segment is not encoded and is
+        # in double quotes, making the value a valid non-encoded string.  The
+        # old parser decodes this just like the previous case, which may be the
+        # better Postel rule, but could equally result in borking headers that
+        # intentionally have quoted quotes in them.  We could get this 98%
+        # right if we treat it as a quoted string *unless* it matches the
+        # charset'lang'value pattern exactly *and* there is at least one
+        # encoded segment.  Implementing that algorithm will require some
+        # refactoring, so I haven't done it (yet).
+        'rfc2231_quoted_unencoded_then_encoded_segments': (
+            ('application/x-foo;'
+                '\tname*0="us-ascii\'en-us\'My";'
+                '\tname*1*=" Document";'
+                '\tname*2*=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "us-ascii'en-us'My Document For You"},
+            [errors.InvalidHeaderDefect]*2,
+            'application/x-foo; name="us-ascii\'en-us\'My Document For You"',
+            ),
+
+        # Make sure our folding algorithm produces multiple sections correctly.
+        # We could mix encoded and non-encoded segments, but we don't, we just
+        # make them all encoded.  It might be worth fixing that, since the
+        # sections can get used for wrapping ascii text.
+        'rfc2231_folded_segments_correctly_formatted': (
+            ('application/x-foo;'
+                '\tname="' + "with spaces"*8 + '"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "with spaces"*8},
+            [],
+            'application/x-foo; name="' + "with spaces"*8 + '"',
+            "Content-Type: application/x-foo;\n"
+            " name*0*=us-ascii''with%20spaceswith%20spaceswith%20spaceswith"
+                "%20spaceswith;\n"
+            " name*1*=%20spaceswith%20spaceswith%20spaceswith%20spaces\n"
+            ),
+
+    }
+
+
+@parameterize
+class TestContentTransferEncoding(TestHeaderBase):
+
+    def cte_as_value(self,
+                     source,
+                     cte,
+                     *args):
+        l = len(args)
+        defects =  args[0] if l>0 else []
+        decoded =  args[1] if l>1 and args[1] is not DITTO else source
+        header = 'Content-Transfer-Encoding:' + ' ' if source else ''
+        folded = args[2] if l>2 else header + source + '\n'
+        h = self.make_header('Content-Transfer-Encoding', source)
+        self.assertEqual(h.cte, cte)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    cte_params = {
+
+        'RFC_2183_1': (
+            'base64',
+            'base64',),
+
+        'no_value': (
+            '',
+            '7bit',
+            [errors.HeaderMissingRequiredValue],
+            '',
+            'Content-Transfer-Encoding:\n',
+            ),
+
+        'junk_after_cte': (
+            '7bit and a bunch more',
+            '7bit',
+            [errors.InvalidHeaderDefect]),
+
+        'extra_space_after_cte': (
+            'base64 ',
+            'base64',
+            []),
+
+    }
+
+
+@parameterize
+class TestContentDisposition(TestHeaderBase):
+
+    def content_disp_as_value(self,
+                              source,
+                              content_disposition,
+                              *args):
+        l = len(args)
+        parmdict = args[0] if l>0 else {}
+        defects =  args[1] if l>1 else []
+        decoded =  args[2] if l>2 and args[2] is not DITTO else source
+        header = 'Content-Disposition:' + ' ' if source else ''
+        folded = args[3] if l>3 else header + source + '\n'
+        h = self.make_header('Content-Disposition', source)
+        self.assertEqual(h.content_disposition, content_disposition)
+        self.assertEqual(h.params, parmdict)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    content_disp_params = {
+
+        # Examples from RFC 2183.
+
+        'RFC_2183_1': (
+            'inline',
+            'inline',),
+
+        'RFC_2183_2': (
+            ('attachment; filename=genome.jpeg;'
+             '  modification-date="Wed, 12 Feb 1997 16:29:51 -0500";'),
+            'attachment',
+            {'filename': 'genome.jpeg',
+             'modification-date': 'Wed, 12 Feb 1997 16:29:51 -0500'},
+            [],
+            ('attachment; filename="genome.jpeg"; '
+                 'modification-date="Wed, 12 Feb 1997 16:29:51 -0500"'),
+            ('Content-Disposition: attachment; filename="genome.jpeg";\n'
+             ' modification-date="Wed, 12 Feb 1997 16:29:51 -0500"\n'),
+            ),
+
+        'no_value': (
+            '',
+            None,
+            {},
+            [errors.HeaderMissingRequiredValue],
+            '',
+            'Content-Disposition:\n'),
+
+        'invalid_value': (
+            'ab./k',
+            'ab.',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'invalid_value_with_params': (
+            'ab./k; filename="foo"',
+            'ab.',
+            {'filename': 'foo'},
+            [errors.InvalidHeaderDefect]),
+
+        'invalid_parameter_value_with_fws_between_ew': (
+            'attachment; filename="=?UTF-8?Q?Schulbesuchsbest=C3=A4ttigung=2E?='
+            '               =?UTF-8?Q?pdf?="',
+            'attachment',
+            {'filename': 'Schulbesuchsbestättigung.pdf'},
+            [errors.InvalidHeaderDefect]*3,
+            ('attachment; filename="Schulbesuchsbestättigung.pdf"'),
+            ('Content-Disposition: attachment;\n'
+             ' filename*=utf-8\'\'Schulbesuchsbest%C3%A4ttigung.pdf\n'),
+            ),
+
+        'parameter_value_with_fws_between_tokens': (
+            'attachment; filename="File =?utf-8?q?Name?= With Spaces.pdf"',
+            'attachment',
+            {'filename': 'File Name With Spaces.pdf'},
+            [errors.InvalidHeaderDefect],
+            'attachment; filename="File Name With Spaces.pdf"',
+            ('Content-Disposition: attachment; filename="File Name With Spaces.pdf"\n'),
+            )
+    }
+
+
+@parameterize
+class TestMIMEVersionHeader(TestHeaderBase):
+
+    def version_string_as_MIME_Version(self,
+                                       source,
+                                       decoded,
+                                       version,
+                                       major,
+                                       minor,
+                                       defects):
+        h = self.make_header('MIME-Version', source)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.version, version)
+        self.assertEqual(h.major, major)
+        self.assertEqual(h.minor, minor)
+        self.assertDefectsEqual(h.defects, defects)
+        if source:
+            source = ' ' + source
+        self.assertEqual(h.fold(policy=policy.default),
+                         'MIME-Version:' + source + '\n')
+
+    version_string_params = {
+
+        # Examples from the RFC.
+
+        'RFC_2045_1': (
+            '1.0',
+            '1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_2': (
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_3': (
+            '(produced by MetaSend Vx.x) 1.0',
+            '(produced by MetaSend Vx.x) 1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_4': (
+            '1.(produced by MetaSend Vx.x)0',
+            '1.(produced by MetaSend Vx.x)0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        # Other valid values.
+
+        '1_1': (
+            '1.1',
+            '1.1',
+            '1.1',
+            1,
+            1,
+            []),
+
+        '2_1': (
+            '2.1',
+            '2.1',
+            '2.1',
+            2,
+            1,
+            []),
+
+        'whitespace': (
+            '1 .0',
+            '1 .0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'leading_trailing_whitespace_ignored': (
+            '  1.0  ',
+            '  1.0  ',
+            '1.0',
+            1,
+            0,
+            []),
+
+        # Recoverable invalid values.  We can recover here only because we
+        # already have a valid value by the time we encounter the garbage.
+        # Anywhere else, and we don't know where the garbage ends.
+
+        'non_comment_garbage_after': (
+            '1.0 <abc>',
+            '1.0 <abc>',
+            '1.0',
+            1,
+            0,
+            [errors.InvalidHeaderDefect]),
+
+        # Unrecoverable invalid values.  We *could* apply more heuristics to
+        # get something out of the first two, but doing so is not worth the
+        # effort.
+
+        'non_comment_garbage_before': (
+            '<abc> 1.0',
+            '<abc> 1.0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'non_comment_garbage_inside': (
+            '1.<abc>0',
+            '1.<abc>0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'two_periods': (
+            '1..0',
+            '1..0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        '2_x': (
+            '2.x',
+            '2.x',
+            None,  # This could be 2, but it seems safer to make it None.
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'foo': (
+            'foo',
+            'foo',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'missing': (
+            '',
+            '',
+            None,
+            None,
+            None,
+            [errors.HeaderMissingRequiredValue]),
+
+        }
+
+
+@parameterize
+class TestAddressHeader(TestHeaderBase):
+
+    example_params = {
+
+        'empty':
+            ('<>',
+             [errors.InvalidHeaderDefect],
+             '<>',
+             '',
+             '<>',
+             '',
+             '',
+             None),
+
+        'address_only':
+            ('zippy@pinhead.com',
+             [],
+             'zippy@pinhead.com',
+             '',
+             'zippy@pinhead.com',
+             'zippy',
+             'pinhead.com',
+             None),
+
+        'name_and_address':
+            ('Zaphrod Beblebrux <zippy@pinhead.com>',
+             [],
+             'Zaphrod Beblebrux <zippy@pinhead.com>',
+             'Zaphrod Beblebrux',
+             'zippy@pinhead.com',
+             'zippy',
+             'pinhead.com',
+             None),
+
+        'quoted_local_part':
+            ('Zaphrod Beblebrux <"foo bar"@pinhead.com>',
+             [],
+             'Zaphrod Beblebrux <"foo bar"@pinhead.com>',
+             'Zaphrod Beblebrux',
+             '"foo bar"@pinhead.com',
+             'foo bar',
+             'pinhead.com',
+             None),
+
+        'quoted_parens_in_name':
+            (r'"A \(Special\) Person" <person@dom.ain>',
+             [],
+             '"A (Special) Person" <person@dom.ain>',
+             'A (Special) Person',
+             'person@dom.ain',
+             'person',
+             'dom.ain',
+             None),
+
+        'quoted_backslashes_in_name':
+            (r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>',
+             [],
+             r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>',
+             r'Arthur \Backslash\ Foobar',
+             'person@dom.ain',
+             'person',
+             'dom.ain',
+             None),
+
+        'name_with_dot':
+            ('John X. Doe <jxd@example.com>',
+             [errors.ObsoleteHeaderDefect],
+             '"John X. Doe" <jxd@example.com>',
+             'John X. Doe',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        'quoted_strings_in_local_part':
+            ('""example" example"@example.com',
+             [errors.InvalidHeaderDefect]*3,
+             '"example example"@example.com',
+             '',
+             '"example example"@example.com',
+             'example example',
+             'example.com',
+             None),
+
+        'escaped_quoted_strings_in_local_part':
+            (r'"\"example\" example"@example.com',
+             [],
+             r'"\"example\" example"@example.com',
+             '',
+             r'"\"example\" example"@example.com',
+             r'"example" example',
+             'example.com',
+            None),
+
+        'escaped_escapes_in_local_part':
+            (r'"\\"example\\" example"@example.com',
+             [errors.InvalidHeaderDefect]*5,
+             r'"\\example\\\\ example"@example.com',
+             '',
+             r'"\\example\\\\ example"@example.com',
+             r'\example\\ example',
+             'example.com',
+            None),
+
+        'spaces_in_unquoted_local_part_collapsed':
+            ('merwok  wok  @example.com',
+             [errors.InvalidHeaderDefect]*2,
+             '"merwok wok"@example.com',
+             '',
+             '"merwok wok"@example.com',
+             'merwok wok',
+             'example.com',
+             None),
+
+        'spaces_around_dots_in_local_part_removed':
+            ('merwok. wok .  wok@example.com',
+             [errors.ObsoleteHeaderDefect],
+             'merwok.wok.wok@example.com',
+             '',
+             'merwok.wok.wok@example.com',
+             'merwok.wok.wok',
+             'example.com',
+             None),
+
+        'rfc2047_atom_is_decoded':
+            ('=?utf-8?q?=C3=89ric?= <foo@example.com>',
+            [],
+            'Éric <foo@example.com>',
+            'Éric',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'rfc2047_atom_in_phrase_is_decoded':
+            ('The =?utf-8?q?=C3=89ric=2C?= Himself <foo@example.com>',
+            [],
+            '"The Éric, Himself" <foo@example.com>',
+            'The Éric, Himself',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'rfc2047_atom_in_quoted_string_is_decoded':
+            ('"=?utf-8?q?=C3=89ric?=" <foo@example.com>',
+            [errors.InvalidHeaderDefect,
+            errors.InvalidHeaderDefect],
+            'Éric <foo@example.com>',
+            'Éric',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'name_ending_with_dot_without_space':
+            ('John X.<jxd@example.com>',
+             [errors.ObsoleteHeaderDefect],
+             '"John X." <jxd@example.com>',
+             'John X.',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        'name_starting_with_dot':
+            ('. Doe <jxd@example.com>',
+             [errors.InvalidHeaderDefect, errors.ObsoleteHeaderDefect],
+             '". Doe" <jxd@example.com>',
+             '. Doe',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        }
+
+        # XXX: Need many more examples, and in particular some with names in
+        # trailing comments, which aren't currently handled.  comments in
+        # general are not handled yet.
+
+    def example_as_address(self, source, defects, decoded, display_name,
+                           addr_spec, username, domain, comment):
+        h = self.make_header('sender', source)
+        self.assertEqual(h, decoded)
+        self.assertDefectsEqual(h.defects, defects)
+        a = h.address
+        self.assertEqual(str(a), decoded)
+        self.assertEqual(len(h.groups), 1)
+        self.assertEqual([a], list(h.groups[0].addresses))
+        self.assertEqual([a], list(h.addresses))
+        self.assertEqual(a.display_name, display_name)
+        self.assertEqual(a.addr_spec, addr_spec)
+        self.assertEqual(a.username, username)
+        self.assertEqual(a.domain, domain)
+        # XXX: we have no comment support yet.
+        #self.assertEqual(a.comment, comment)
+
+    def example_as_group(self, source, defects, decoded, display_name,
+                         addr_spec, username, domain, comment):
+        source = 'foo: {};'.format(source)
+        gdecoded = 'foo: {};'.format(decoded) if decoded else 'foo:;'
+        h = self.make_header('to', source)
+        self.assertEqual(h, gdecoded)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h.groups[0].addresses, h.addresses)
+        self.assertEqual(len(h.groups), 1)
+        self.assertEqual(len(h.addresses), 1)
+        a = h.addresses[0]
+        self.assertEqual(str(a), decoded)
+        self.assertEqual(a.display_name, display_name)
+        self.assertEqual(a.addr_spec, addr_spec)
+        self.assertEqual(a.username, username)
+        self.assertEqual(a.domain, domain)
+
+    def test_simple_address_list(self):
+        value = ('Fred <dinsdale@python.org>, foo@example.com, '
+                    '"Harry W. Hastings" <hasty@example.com>')
+        h = self.make_header('to', value)
+        self.assertEqual(h, value)
+        self.assertEqual(len(h.groups), 3)
+        self.assertEqual(len(h.addresses), 3)
+        for i in range(3):
+            self.assertEqual(h.groups[i].addresses[0], h.addresses[i])
+        self.assertEqual(str(h.addresses[0]), 'Fred <dinsdale@python.org>')
+        self.assertEqual(str(h.addresses[1]), 'foo@example.com')
+        self.assertEqual(str(h.addresses[2]),
+            '"Harry W. Hastings" <hasty@example.com>')
+        self.assertEqual(h.addresses[2].display_name,
+            'Harry W. Hastings')
+
+    def test_complex_address_list(self):
+        examples = list(self.example_params.values())
+        source = ('dummy list:;, another: (empty);,' +
+                 ', '.join([x[0] for x in examples[:4]]) + ', ' +
+                 r'"A \"list\"": ' +
+                    ', '.join([x[0] for x in examples[4:6]]) + ';,' +
+                 ', '.join([x[0] for x in examples[6:]])
+            )
+        # XXX: the fact that (empty) disappears here is a potential API design
+        # bug.  We don't currently have a way to preserve comments.
+        expected = ('dummy list:;, another:;, ' +
+                 ', '.join([x[2] for x in examples[:4]]) + ', ' +
+                 r'"A \"list\"": ' +
+                    ', '.join([x[2] for x in examples[4:6]]) + ';, ' +
+                 ', '.join([x[2] for x in examples[6:]])
+            )
+
+        h = self.make_header('to', source)
+        self.assertEqual(h.split(','), expected.split(','))
+        self.assertEqual(h, expected)
+        self.assertEqual(len(h.groups), 7 + len(examples) - 6)
+        self.assertEqual(h.groups[0].display_name, 'dummy list')
+        self.assertEqual(h.groups[1].display_name, 'another')
+        self.assertEqual(h.groups[6].display_name, 'A "list"')
+        self.assertEqual(len(h.addresses), len(examples))
+        for i in range(4):
+            self.assertIsNone(h.groups[i+2].display_name)
+            self.assertEqual(str(h.groups[i+2].addresses[0]), examples[i][2])
+        for i in range(7, 7 + len(examples) - 6):
+            self.assertIsNone(h.groups[i].display_name)
+            self.assertEqual(str(h.groups[i].addresses[0]), examples[i-1][2])
+        for i in range(len(examples)):
+            self.assertEqual(str(h.addresses[i]), examples[i][2])
+            self.assertEqual(h.addresses[i].addr_spec, examples[i][4])
+
+    def test_address_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.address = 'foo'
+
+    def test_addresses_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.addresses = 'foo'
+
+    def test_groups_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.groups = 'foo'
+
+    def test_addresses_types(self):
+        source = 'me <who@example.com>'
+        h = self.make_header('to', source)
+        self.assertIsInstance(h.addresses, tuple)
+        self.assertIsInstance(h.addresses[0], Address)
+
+    def test_groups_types(self):
+        source = 'me <who@example.com>'
+        h = self.make_header('to', source)
+        self.assertIsInstance(h.groups, tuple)
+        self.assertIsInstance(h.groups[0], Group)
+
+    def test_set_from_Address(self):
+        h = self.make_header('to', Address('me', 'foo', 'example.com'))
+        self.assertEqual(h, 'me <foo@example.com>')
+
+    def test_set_from_Address_list(self):
+        h = self.make_header('to', [Address('me', 'foo', 'example.com'),
+                                    Address('you', 'bar', 'example.com')])
+        self.assertEqual(h, 'me <foo@example.com>, you <bar@example.com>')
+
+    def test_set_from_Address_and_Group_list(self):
+        h = self.make_header('to', [Address('me', 'foo', 'example.com'),
+                                    Group('bing', [Address('fiz', 'z', 'b.com'),
+                                                   Address('zif', 'f', 'c.com')]),
+                                    Address('you', 'bar', 'example.com')])
+        self.assertEqual(h, 'me <foo@example.com>, bing: fiz <z@b.com>, '
+                            'zif <f@c.com>;, you <bar@example.com>')
+        self.assertEqual(h.fold(policy=policy.default.clone(max_line_length=40)),
+                        'to: me <foo@example.com>,\n'
+                        ' bing: fiz <z@b.com>, zif <f@c.com>;,\n'
+                        ' you <bar@example.com>\n')
+
+    def test_set_from_Group_list(self):
+        h = self.make_header('to', [Group('bing', [Address('fiz', 'z', 'b.com'),
+                                                   Address('zif', 'f', 'c.com')])])
+        self.assertEqual(h, 'bing: fiz <z@b.com>, zif <f@c.com>;')
+
+
+class TestAddressAndGroup(TestEmailBase):
+
+    def _test_attr_ro(self, obj, attr):
+        with self.assertRaises(AttributeError):
+            setattr(obj, attr, 'foo')
+
+    def test_address_display_name_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'display_name')
+
+    def test_address_username_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'username')
+
+    def test_address_domain_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'domain')
+
+    def test_group_display_name_ro(self):
+        self._test_attr_ro(Group('foo'), 'display_name')
+
+    def test_group_addresses_ro(self):
+        self._test_attr_ro(Group('foo'), 'addresses')
+
+    def test_address_from_username_domain(self):
+        a = Address('foo', 'bar', 'baz')
+        self.assertEqual(a.display_name, 'foo')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'foo <bar@baz>')
+
+    def test_address_from_addr_spec(self):
+        a = Address('foo', addr_spec='bar@baz')
+        self.assertEqual(a.display_name, 'foo')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'foo <bar@baz>')
+
+    def test_address_with_no_display_name(self):
+        a = Address(addr_spec='bar@baz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'bar@baz')
+
+    def test_null_address(self):
+        a = Address()
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, '<>')
+        self.assertEqual(str(a), '<>')
+
+    def test_domain_only(self):
+        # This isn't really a valid address.
+        a = Address(domain='buzz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, 'buzz')
+        self.assertEqual(a.addr_spec, '@buzz')
+        self.assertEqual(str(a), '@buzz')
+
+    def test_username_only(self):
+        # This isn't really a valid address.
+        a = Address(username='buzz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, 'buzz')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, 'buzz')
+        self.assertEqual(str(a), 'buzz')
+
+    def test_display_name_only(self):
+        a = Address('buzz')
+        self.assertEqual(a.display_name, 'buzz')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, '<>')
+        self.assertEqual(str(a), 'buzz <>')
+
+    def test_quoting(self):
+        # Ideally we'd check every special individually, but I'm not up for
+        # writing that many tests.
+        a = Address('Sara J.', 'bad name', 'example.com')
+        self.assertEqual(a.display_name, 'Sara J.')
+        self.assertEqual(a.username, 'bad name')
+        self.assertEqual(a.domain, 'example.com')
+        self.assertEqual(a.addr_spec, '"bad name"@example.com')
+        self.assertEqual(str(a), '"Sara J." <"bad name"@example.com>')
+
+    def test_il8n(self):
+        a = Address('Éric', 'wok', 'exàmple.com')
+        self.assertEqual(a.display_name, 'Éric')
+        self.assertEqual(a.username, 'wok')
+        self.assertEqual(a.domain, 'exàmple.com')
+        self.assertEqual(a.addr_spec, 'wok@exàmple.com')
+        self.assertEqual(str(a), 'Éric <wok@exàmple.com>')
+
+    # XXX: there is an API design issue that needs to be solved here.
+    #def test_non_ascii_username_raises(self):
+    #    with self.assertRaises(ValueError):
+    #        Address('foo', 'wők', 'example.com')
+
+    def test_crlf_in_constructor_args_raises(self):
+        cases = (
+            dict(display_name='foo\r'),
+            dict(display_name='foo\n'),
+            dict(display_name='foo\r\n'),
+            dict(domain='example.com\r'),
+            dict(domain='example.com\n'),
+            dict(domain='example.com\r\n'),
+            dict(username='wok\r'),
+            dict(username='wok\n'),
+            dict(username='wok\r\n'),
+            dict(addr_spec='wok@example.com\r'),
+            dict(addr_spec='wok@example.com\n'),
+            dict(addr_spec='wok@example.com\r\n')
+        )
+        for kwargs in cases:
+            with self.subTest(kwargs=kwargs), self.assertRaisesRegex(ValueError, "invalid arguments"):
+                Address(**kwargs)
+
+    def test_non_ascii_username_in_addr_spec_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec='wők@example.com')
+
+    def test_address_addr_spec_and_username_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', username='bing', addr_spec='bar@baz')
+
+    def test_address_addr_spec_and_domain_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', domain='bing', addr_spec='bar@baz')
+
+    def test_address_addr_spec_and_username_and_domain_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', username='bong', domain='bing', addr_spec='bar@baz')
+
+    def test_space_in_addr_spec_username_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec="bad name@example.com")
+
+    def test_bad_addr_sepc_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec="name@ex[]ample.com")
+
+    def test_empty_group(self):
+        g = Group('foo')
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo:;')
+
+    def test_empty_group_list(self):
+        g = Group('foo', addresses=[])
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo:;')
+
+    def test_null_group(self):
+        g = Group()
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'None:;')
+
+    def test_group_with_addresses(self):
+        addrs = [Address('b', 'b', 'c'), Address('a', 'b','c')]
+        g = Group('foo', addrs)
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'foo: b <b@c>, a <b@c>;')
+
+    def test_group_with_addresses_no_display_name(self):
+        addrs = [Address('b', 'b', 'c'), Address('a', 'b','c')]
+        g = Group(addresses=addrs)
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'None: b <b@c>, a <b@c>;')
+
+    def test_group_with_one_address_no_display_name(self):
+        addrs = [Address('b', 'b', 'c')]
+        g = Group(addresses=addrs)
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'b <b@c>')
+
+    def test_display_name_quoting(self):
+        g = Group('foo.bar')
+        self.assertEqual(g.display_name, 'foo.bar')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), '"foo.bar":;')
+
+    def test_display_name_blanks_not_quoted(self):
+        g = Group('foo bar')
+        self.assertEqual(g.display_name, 'foo bar')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo bar:;')
+
+    def test_set_message_header_from_address(self):
+        a = Address('foo', 'bar', 'example.com')
+        m = Message(policy=policy.default)
+        m['To'] = a
+        self.assertEqual(m['to'], 'foo <bar@example.com>')
+        self.assertEqual(m['to'].addresses, (a,))
+
+    def test_set_message_header_from_group(self):
+        g = Group('foo bar')
+        m = Message(policy=policy.default)
+        m['To'] = g
+        self.assertEqual(m['to'], 'foo bar:;')
+        self.assertEqual(m['to'].addresses, g.addresses)
+
+    def test_address_comparison(self):
+        a = Address('foo', 'bar', 'example.com')
+        self.assertEqual(Address('foo', 'bar', 'example.com'), a)
+        self.assertNotEqual(Address('baz', 'bar', 'example.com'), a)
+        self.assertNotEqual(Address('foo', 'baz', 'example.com'), a)
+        self.assertNotEqual(Address('foo', 'bar', 'baz'), a)
+        self.assertFalse(a == object())
+        self.assertTrue(a == ALWAYS_EQ)
+
+    def test_group_comparison(self):
+        a = Address('foo', 'bar', 'example.com')
+        g = Group('foo bar', [a])
+        self.assertEqual(Group('foo bar', (a,)), g)
+        self.assertNotEqual(Group('baz', [a]), g)
+        self.assertNotEqual(Group('foo bar', []), g)
+        self.assertFalse(g == object())
+        self.assertTrue(g == ALWAYS_EQ)
+
+
+class TestFolding(TestHeaderBase):
+
+    def test_address_display_names(self):
+        """Test the folding and encoding of address headers."""
+        for name, result in (
+                ('Foo Bar, France', '"Foo Bar, France"'),
+                ('Foo Bar (France)', '"Foo Bar (France)"'),
+                ('Foo Bar, España', 'Foo =?utf-8?q?Bar=2C_Espa=C3=B1a?='),
+                ('Foo Bar (España)', 'Foo Bar =?utf-8?b?KEVzcGHDsWEp?='),
+                ('Foo, Bar España', '=?utf-8?q?Foo=2C_Bar_Espa=C3=B1a?='),
+                ('Foo, Bar [España]', '=?utf-8?q?Foo=2C_Bar_=5BEspa=C3=B1a=5D?='),
+                ('Foo Bär, France', 'Foo =?utf-8?q?B=C3=A4r=2C?= France'),
+                ('Foo Bär <France>', 'Foo =?utf-8?q?B=C3=A4r_=3CFrance=3E?='),
+                (
+                    'Lôrem ipsum dôlôr sit amet, cônsectetuer adipiscing. '
+                    'Suspendisse pôtenti. Aliquam nibh. Suspendisse pôtenti.',
+                    '=?utf-8?q?L=C3=B4rem_ipsum_d=C3=B4l=C3=B4r_sit_amet=2C_c'
+                    '=C3=B4nsectetuer?=\n =?utf-8?q?_adipiscing=2E_Suspendisse'
+                    '_p=C3=B4tenti=2E_Aliquam_nibh=2E?=\n Suspendisse =?utf-8'
+                    '?q?p=C3=B4tenti=2E?=',
+                    ),
+                ):
+            h = self.make_header('To', Address(name, addr_spec='a@b.com'))
+            self.assertEqual(h.fold(policy=policy.default),
+                                    'To: %s <a@b.com>\n' % result)
+
+    def test_short_unstructured(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h.fold(policy=policy.default),
+                         'subject: this is a test\n')
+
+    def test_long_unstructured(self):
+        h = self.make_header('Subject', 'This is a long header '
+            'line that will need to be folded into two lines '
+            'and will demonstrate basic folding')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Subject: This is a long header line that will '
+                            'need to be folded into two lines\n'
+                        ' and will demonstrate basic folding\n')
+
+    def test_unstructured_short_max_line_length(self):
+        h = self.make_header('Subject', 'this is a short header '
+            'that will be folded anyway')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            textwrap.dedent("""\
+                Subject: this is a
+                 short header that
+                 will be folded
+                 anyway
+                """))
+
+    def test_fold_unstructured_single_word(self):
+        h = self.make_header('Subject', 'test')
+        self.assertEqual(h.fold(policy=policy.default), 'Subject: test\n')
+
+    def test_fold_unstructured_short(self):
+        h = self.make_header('Subject', 'test test test')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Subject: test test test\n')
+
+    def test_fold_unstructured_with_overlong_word(self):
+        h = self.make_header('Subject', 'thisisaverylonglineconsistingofa'
+            'singlewordthatwontfit')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Subject: \n'
+            ' =?utf-8?q?thisisa?=\n'
+            ' =?utf-8?q?verylon?=\n'
+            ' =?utf-8?q?glineco?=\n'
+            ' =?utf-8?q?nsistin?=\n'
+            ' =?utf-8?q?gofasin?=\n'
+            ' =?utf-8?q?gleword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit?=\n'
+            )
+
+    def test_fold_unstructured_with_two_overlong_words(self):
+        h = self.make_header('Subject', 'thisisaverylonglineconsistingofa'
+            'singlewordthatwontfit plusanotherverylongwordthatwontfit')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Subject: \n'
+            ' =?utf-8?q?thisisa?=\n'
+            ' =?utf-8?q?verylon?=\n'
+            ' =?utf-8?q?glineco?=\n'
+            ' =?utf-8?q?nsistin?=\n'
+            ' =?utf-8?q?gofasin?=\n'
+            ' =?utf-8?q?gleword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit_pl?=\n'
+            ' =?utf-8?q?usanoth?=\n'
+            ' =?utf-8?q?erveryl?=\n'
+            ' =?utf-8?q?ongword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit?=\n'
+            )
+
+    # XXX Need test for when max_line_length is less than the chrome size.
+
+    def test_fold_unstructured_with_slightly_long_word(self):
+        h = self.make_header('Subject', 'thislongwordislessthanmaxlinelen')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=35)),
+            'Subject:\n thislongwordislessthanmaxlinelen\n')
+
+    def test_fold_unstructured_with_commas(self):
+        # The old wrapper would fold this at the commas.
+        h = self.make_header('Subject', "This header is intended to "
+            "demonstrate, in a fairly succinct way, that we now do "
+            "not give a , special treatment in unstructured headers.")
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=60)),
+            textwrap.dedent("""\
+                Subject: This header is intended to demonstrate, in a fairly
+                 succinct way, that we now do not give a , special treatment
+                 in unstructured headers.
+                 """))
+
+    def test_fold_address_list(self):
+        h = self.make_header('To', '"Theodore H. Perfect" <yes@man.com>, '
+            '"My address is very long because my name is long" <foo@bar.com>, '
+            '"Only A. Friend" <no@yes.com>')
+        self.assertEqual(h.fold(policy=policy.default), textwrap.dedent("""\
+            To: "Theodore H. Perfect" <yes@man.com>,
+             "My address is very long because my name is long" <foo@bar.com>,
+             "Only A. Friend" <no@yes.com>
+             """))
+
+    def test_fold_date_header(self):
+        h = self.make_header('Date', 'Sat, 2 Feb 2002 17:00:06 -0800')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Date: Sat, 02 Feb 2002 17:00:06 -0800\n')
+
+    def test_fold_overlong_words_using_RFC2047(self):
+        h = self.make_header(
+            'X-Report-Abuse',
+            '<https://www.mailitapp.com/report_abuse.php?'
+              'mid=xxx-xxx-xxxxxxxxxxxxxxxxxxxxxxxx==-xxx-xx-xx>')
+        self.assertEqual(
+            h.fold(policy=policy.default),
+            'X-Report-Abuse: =?utf-8?q?=3Chttps=3A//www=2Emailitapp=2E'
+                'com/report=5Fabuse?=\n'
+            ' =?utf-8?q?=2Ephp=3Fmid=3Dxxx-xxx-xxxx'
+                'xxxxxxxxxxxxxxxxxxxx=3D=3D-xxx-xx-xx?=\n'
+            ' =?utf-8?q?=3E?=\n')
+
+    def test_message_id_header_is_not_folded(self):
+        h = self.make_header(
+            'Message-ID',
+            '<somemessageidlongerthan@maxlinelength.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID: <somemessageidlongerthan@maxlinelength.com>\n')
+
+        # Test message-id isn't folded when id-right is no-fold-literal.
+        h = self.make_header(
+            'Message-ID',
+            '<somemessageidlongerthan@[127.0.0.0.0.0.0.0.0.1]>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID: <somemessageidlongerthan@[127.0.0.0.0.0.0.0.0.1]>\n')
+
+        # Test message-id isn't folded when id-right is non-ascii characters.
+        h = self.make_header('Message-ID', '<ईमेल@wők.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=30)),
+            'Message-ID: <ईमेल@wők.com>\n')
+
+        # Test message-id is folded without breaking the msg-id token into
+        # encoded words, *even* if they don't fit into max_line_length.
+        h = self.make_header('Message-ID', '<ईमेलfromMessage@wők.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID:\n <ईमेलfromMessage@wők.com>\n')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_inversion.py b/Lib/test/test_email/test_inversion.py
new file mode 100644
index 00000000000..7bd7f2a7206
--- /dev/null
+++ b/Lib/test/test_email/test_inversion.py
@@ -0,0 +1,78 @@
+"""Test the parser and generator are inverses.
+
+Note that this is only strictly true if we are parsing RFC valid messages and
+producing RFC valid messages.
+"""
+
+import io
+import unittest
+from email import policy, message_from_bytes
+from email.message import EmailMessage
+from email.generator import BytesGenerator
+from test.test_email import TestEmailBase, parameterize
+
+# This is like textwrap.dedent for bytes, except that it uses \r\n for the line
+# separators on the rebuilt string.
+def dedent(bstr):
+    lines = bstr.splitlines()
+    if not lines[0].strip():
+        raise ValueError("First line must contain text")
+    stripamt = len(lines[0]) - len(lines[0].lstrip())
+    return b'\r\n'.join(
+        [x[stripamt:] if len(x)>=stripamt else b''
+            for x in lines])
+
+
+@parameterize
+class TestInversion(TestEmailBase):
+
+    policy = policy.default
+    message = EmailMessage
+
+    def msg_as_input(self, msg):
+        m = message_from_bytes(msg, policy=policy.SMTP)
+        b = io.BytesIO()
+        g = BytesGenerator(b)
+        g.flatten(m)
+        self.assertEqual(b.getvalue(), msg)
+
+    # XXX: spaces are not preserved correctly here yet in the general case.
+    msg_params = {
+        'header_with_one_space_body': (dedent(b"""\
+            From: abc@xyz.com
+            X-Status:\x20
+            Subject: test
+
+            foo
+            """),),
+
+        'header_with_invalid_date': (dedent(b"""\
+            Date: Tue, 06 Jun 2017 27:39:33 +0600
+            From: abc@xyz.com
+            Subject: timezones
+
+            How do they work even?
+            """),),
+
+            }
+
+    payload_params = {
+        'plain_text': dict(payload='This is a test\n'*20),
+        'base64_text': dict(payload=(('xy a'*40+'\n')*5), cte='base64'),
+        'qp_text': dict(payload=(('xy a'*40+'\n')*5), cte='quoted-printable'),
+        }
+
+    def payload_as_body(self, payload, **kw):
+        msg = self._make_message()
+        msg['From'] = 'foo'
+        msg['To'] = 'bar'
+        msg['Subject'] = 'payload round trip test'
+        msg.set_content(payload, **kw)
+        b = bytes(msg)
+        msg2 = message_from_bytes(b, policy=self.policy)
+        self.assertEqual(bytes(msg2), b)
+        self.assertEqual(msg2.get_content(), payload)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_message.py b/Lib/test/test_email/test_message.py
new file mode 100644
index 00000000000..966615dcc1d
--- /dev/null
+++ b/Lib/test/test_email/test_message.py
@@ -0,0 +1,1094 @@
+import textwrap
+import unittest
+from email import message_from_bytes, message_from_string, policy
+from email.message import EmailMessage, MIMEPart
+from test.test_email import TestEmailBase, parameterize
+
+
+# Helper.
+def first(iterable):
+    return next(filter(lambda x: x is not None, iterable), None)
+
+
+class Test(TestEmailBase):
+
+    policy = policy.default
+
+    def test_error_on_setitem_if_max_count_exceeded(self):
+        m = self._str_msg("")
+        m['To'] = 'abc@xyz'
+        with self.assertRaises(ValueError):
+            m['To'] = 'xyz@abc'
+
+    def test_rfc2043_auto_decoded_and_emailmessage_used(self):
+        m = message_from_string(textwrap.dedent("""\
+            Subject: Ayons asperges pour le =?utf-8?q?d=C3=A9jeuner?=
+            From: =?utf-8?q?Pep=C3=A9?= Le Pew <pepe@example.com>
+            To: "Penelope Pussycat" <"penelope@example.com">
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+
+            sample text
+            """), policy=policy.default)
+        self.assertEqual(m['subject'], "Ayons asperges pour le déjeuner")
+        self.assertEqual(m['from'], "Pepé Le Pew <pepe@example.com>")
+        self.assertIsInstance(m, EmailMessage)
+
+
+@parameterize
+class TestEmailMessageBase:
+
+    policy = policy.default
+
+    # The first argument is a triple (related, html, plain) of indices into the
+    # list returned by 'walk' called on a Message constructed from the third.
+    # The indices indicate which part should match the corresponding part-type
+    # when passed to get_body (ie: the "first" part of that type in the
+    # message).  The second argument is a list of indices into the 'walk' list
+    # of the attachments that should be returned by a call to
+    # 'iter_attachments'.  The third argument is a list of indices into 'walk'
+    # that should be returned by a call to 'iter_parts'.  Note that the first
+    # item returned by 'walk' is the Message itself.
+
+    message_params = {
+
+        'empty_message': (
+            (None, None, 0),
+            (),
+            (),
+            ""),
+
+        'non_mime_plain': (
+            (None, None, 0),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+
+                simple text body
+                """)),
+
+        'mime_non_text': (
+            (None, None, None),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: image/jpg
+
+                bogus body.
+                """)),
+
+        'plain_html_alternative': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/alternative; boundary="==="
+
+                preamble
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+                --===--
+                """)),
+
+        'plain_html_mixed': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                preamble
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'plain_html_attachment_mixed': (
+            (None, None, 1),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+                Content-Disposition: attachment
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'html_text_attachment_mixed': (
+            (None, 2, None),
+            (1,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+                Content-Disposition: AtTaChment
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'html_text_attachment_inline_mixed': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+                Content-Disposition: InLine
+
+                simple body
+
+                --===
+                Content-Type: text/html
+                Content-Disposition: inline
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        # RFC 2387
+        'related': (
+            (0, 1, None),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/related; boundary="==="; type=text/html
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===
+                Content-Type: image/jpg
+                Content-ID: <image1>
+
+                bogus data
+
+                --===--
+                """)),
+
+        # This message structure will probably never be seen in the wild, but
+        # it proves we distinguish between text parts based on 'start'.  The
+        # content would not, of course, actually work :)
+        'related_with_start': (
+            (0, 2, None),
+            (1,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/related; boundary="==="; type=text/html;
+                 start="<body>"
+
+                --===
+                Content-Type: text/html
+                Content-ID: <include>
+
+                useless text
+
+                --===
+                Content-Type: text/html
+                Content-ID: <body>
+
+                <p>simple body</p>
+                <!--#include file="<include>"-->
+
+                --===--
+                """)),
+
+
+        'mixed_alternative_plain_related': (
+            (3, 4, 2),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/alternative; boundary="+++"
+
+                --+++
+                Content-Type: text/plain
+
+                simple body
+
+                --+++
+                Content-Type: multipart/related; boundary="___"
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --___--
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: AttacHmenT
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        # This structure suggested by Stephen J. Turnbull...may not exist/be
+        # supported in the wild, but we want to support it.
+        'mixed_related_alternative_plain_html': (
+            (1, 4, 3),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/related; boundary="+++"
+
+                --+++
+                Content-Type: multipart/alternative; boundary="___"
+
+                --___
+                Content-Type: text/plain
+
+                simple body
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___--
+
+                --+++
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        # Same thing, but proving we only look at the root part, which is the
+        # first one if there isn't any start parameter.  That is, this is a
+        # broken related.
+        'mixed_related_alternative_plain_html_wrong_order': (
+            (1, None, None),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/related; boundary="+++"
+
+                --+++
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --+++
+                Content-Type: multipart/alternative; boundary="___"
+
+                --___
+                Content-Type: text/plain
+
+                simple body
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___--
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        'message_rfc822': (
+            (None, None, None),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: message/rfc822
+
+                To: bar@example.com
+                From: robot@examp.com
+
+                this is a message body.
+                """)),
+
+        'mixed_text_message_rfc822': (
+            (None, None, 1),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+
+                Your message has bounced, sir.
+
+                --===
+                Content-Type: message/rfc822
+
+                To: bar@example.com
+                From: robot@examp.com
+
+                this is a message body.
+
+                --===--
+                """)),
+
+         }
+
+    def message_as_get_body(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        expected = [None if n is None else allparts[n] for n in body_parts]
+        related = 0; html = 1; plain = 2
+        self.assertEqual(m.get_body(), first(expected))
+        self.assertEqual(m.get_body(preferencelist=(
+                                        'related', 'html', 'plain')),
+                         first(expected))
+        self.assertEqual(m.get_body(preferencelist=('related', 'html')),
+                         first(expected[related:html+1]))
+        self.assertEqual(m.get_body(preferencelist=('related', 'plain')),
+                         first([expected[related], expected[plain]]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'plain')),
+                         first(expected[html:plain+1]))
+        self.assertEqual(m.get_body(preferencelist=['related']),
+                         expected[related])
+        self.assertEqual(m.get_body(preferencelist=['html']), expected[html])
+        self.assertEqual(m.get_body(preferencelist=['plain']), expected[plain])
+        self.assertEqual(m.get_body(preferencelist=('plain', 'html')),
+                         first(expected[plain:html-1:-1]))
+        self.assertEqual(m.get_body(preferencelist=('plain', 'related')),
+                         first([expected[plain], expected[related]]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'related')),
+                         first(expected[html::-1]))
+        self.assertEqual(m.get_body(preferencelist=('plain', 'html', 'related')),
+                         first(expected[::-1]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'plain', 'related')),
+                         first([expected[html],
+                                expected[plain],
+                                expected[related]]))
+
+    def message_as_iter_attachment(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        attachments = [allparts[n] for n in attachments]
+        self.assertEqual(list(m.iter_attachments()), attachments)
+
+    def message_as_iter_parts(self, body_parts, attachments, parts, msg):
+        def _is_multipart_msg(msg):
+            return 'Content-Type: multipart' in msg
+
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        parts = [allparts[n] for n in parts]
+        iter_parts = list(m.iter_parts()) if _is_multipart_msg(msg) else []
+        self.assertEqual(iter_parts, parts)
+
+    class _TestContentManager:
+        def get_content(self, msg, *args, **kw):
+            return msg, args, kw
+        def set_content(self, msg, *args, **kw):
+            self.msg = msg
+            self.args = args
+            self.kw = kw
+
+    def test_get_content_with_cm(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertEqual(m.get_content(content_manager=cm), (m, (), {}))
+        msg, args, kw = m.get_content('foo', content_manager=cm, bar=1, k=2)
+        self.assertEqual(msg, m)
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(kw, dict(bar=1, k=2))
+
+    def test_get_content_default_cm_comes_from_policy(self):
+        p = policy.default.clone(content_manager=self._TestContentManager())
+        m = self._str_msg('', policy=p)
+        self.assertEqual(m.get_content(), (m, (), {}))
+        msg, args, kw = m.get_content('foo', bar=1, k=2)
+        self.assertEqual(msg, m)
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(kw, dict(bar=1, k=2))
+
+    def test_set_content_with_cm(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        m.set_content(content_manager=cm)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ())
+        self.assertEqual(cm.kw, {})
+        m.set_content('foo', content_manager=cm, bar=1, k=2)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ('foo',))
+        self.assertEqual(cm.kw, dict(bar=1, k=2))
+
+    def test_set_content_default_cm_comes_from_policy(self):
+        cm = self._TestContentManager()
+        p = policy.default.clone(content_manager=cm)
+        m = self._str_msg('', policy=p)
+        m.set_content()
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ())
+        self.assertEqual(cm.kw, {})
+        m.set_content('foo', bar=1, k=2)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ('foo',))
+        self.assertEqual(cm.kw, dict(bar=1, k=2))
+
+    # outcome is whether xxx_method should raise ValueError error when called
+    # on multipart/subtype.  Blank outcome means it depends on xxx (add
+    # succeeds, make raises).  Note: 'none' means there are content-type
+    # headers but payload is None...this happening in practice would be very
+    # unusual, so treating it as if there were content seems reasonable.
+    #    method          subtype           outcome
+    subtype_params = (
+        ('related',      'no_content',     'succeeds'),
+        ('related',      'none',           'succeeds'),
+        ('related',      'plain',          'succeeds'),
+        ('related',      'related',        ''),
+        ('related',      'alternative',    'raises'),
+        ('related',      'mixed',          'raises'),
+        ('alternative',  'no_content',     'succeeds'),
+        ('alternative',  'none',           'succeeds'),
+        ('alternative',  'plain',          'succeeds'),
+        ('alternative',  'related',        'succeeds'),
+        ('alternative',  'alternative',    ''),
+        ('alternative',  'mixed',          'raises'),
+        ('mixed',        'no_content',     'succeeds'),
+        ('mixed',        'none',           'succeeds'),
+        ('mixed',        'plain',          'succeeds'),
+        ('mixed',        'related',        'succeeds'),
+        ('mixed',        'alternative',    'succeeds'),
+        ('mixed',        'mixed',          ''),
+        )
+
+    def _make_subtype_test_message(self, subtype):
+        m = self.message()
+        payload = None
+        msg_headers =  [
+            ('To', 'foo@bar.com'),
+            ('From', 'bar@foo.com'),
+            ]
+        if subtype != 'no_content':
+            ('content-shadow', 'Logrus'),
+        msg_headers.append(('X-Random-Header', 'Corwin'))
+        if subtype == 'text':
+            payload = ''
+            msg_headers.append(('Content-Type', 'text/plain'))
+            m.set_payload('')
+        elif subtype != 'no_content':
+            payload = []
+            msg_headers.append(('Content-Type', 'multipart/' + subtype))
+        msg_headers.append(('X-Trump', 'Random'))
+        m.set_payload(payload)
+        for name, value in msg_headers:
+            m[name] = value
+        return m, msg_headers, payload
+
+    def _check_disallowed_subtype_raises(self, m, method_name, subtype, method):
+        with self.assertRaises(ValueError) as ar:
+            getattr(m, method)()
+        exc_text = str(ar.exception)
+        self.assertIn(subtype, exc_text)
+        self.assertIn(method_name, exc_text)
+
+    def _check_make_multipart(self, m, msg_headers, payload):
+        count = 0
+        for name, value in msg_headers:
+            if not name.lower().startswith('content-'):
+                self.assertEqual(m[name], value)
+                count += 1
+        self.assertEqual(len(m), count+1) # +1 for new Content-Type
+        part = next(m.iter_parts())
+        count = 0
+        for name, value in msg_headers:
+            if name.lower().startswith('content-'):
+                self.assertEqual(part[name], value)
+                count += 1
+        self.assertEqual(len(part), count)
+        self.assertEqual(part.get_payload(), payload)
+
+    def subtype_as_make(self, method, subtype, outcome):
+        m, msg_headers, payload = self._make_subtype_test_message(subtype)
+        make_method = 'make_' + method
+        if outcome in ('', 'raises'):
+            self._check_disallowed_subtype_raises(m, method, subtype, make_method)
+            return
+        getattr(m, make_method)()
+        self.assertEqual(m.get_content_maintype(), 'multipart')
+        self.assertEqual(m.get_content_subtype(), method)
+        if subtype == 'no_content':
+            self.assertEqual(len(m.get_payload()), 0)
+            self.assertEqual(m.items(),
+                             msg_headers + [('Content-Type',
+                                             'multipart/'+method)])
+        else:
+            self.assertEqual(len(m.get_payload()), 1)
+            self._check_make_multipart(m, msg_headers, payload)
+
+    def subtype_as_make_with_boundary(self, method, subtype, outcome):
+        # Doing all variation is a bit of overkill...
+        m = self.message()
+        if outcome in ('', 'raises'):
+            m['Content-Type'] = 'multipart/' + subtype
+            with self.assertRaises(ValueError) as cm:
+                getattr(m, 'make_' + method)()
+            return
+        if subtype == 'plain':
+            m['Content-Type'] = 'text/plain'
+        elif subtype != 'no_content':
+            m['Content-Type'] = 'multipart/' + subtype
+        getattr(m, 'make_' + method)(boundary="abc")
+        self.assertTrue(m.is_multipart())
+        self.assertEqual(m.get_boundary(), 'abc')
+
+    def test_policy_on_part_made_by_make_comes_from_message(self):
+        for method in ('make_related', 'make_alternative', 'make_mixed'):
+            m = self.message(policy=self.policy.clone(content_manager='foo'))
+            m['Content-Type'] = 'text/plain'
+            getattr(m, method)()
+            self.assertEqual(m.get_payload(0).policy.content_manager, 'foo')
+
+    class _TestSetContentManager:
+        def set_content(self, msg, content, *args, **kw):
+            msg['Content-Type'] = 'text/plain'
+            msg.set_payload(content)
+
+    def subtype_as_add(self, method, subtype, outcome):
+        m, msg_headers, payload = self._make_subtype_test_message(subtype)
+        cm = self._TestSetContentManager()
+        add_method = 'add_attachment' if method=='mixed' else 'add_' + method
+        if outcome == 'raises':
+            self._check_disallowed_subtype_raises(m, method, subtype, add_method)
+            return
+        getattr(m, add_method)('test', content_manager=cm)
+        self.assertEqual(m.get_content_maintype(), 'multipart')
+        self.assertEqual(m.get_content_subtype(), method)
+        if method == subtype or subtype == 'no_content':
+            self.assertEqual(len(m.get_payload()), 1)
+            for name, value in msg_headers:
+                self.assertEqual(m[name], value)
+            part = m.get_payload()[0]
+        else:
+            self.assertEqual(len(m.get_payload()), 2)
+            self._check_make_multipart(m, msg_headers, payload)
+            part = m.get_payload()[1]
+        self.assertEqual(part.get_content_type(), 'text/plain')
+        self.assertEqual(part.get_payload(), 'test')
+        if method=='mixed':
+            self.assertEqual(part['Content-Disposition'], 'attachment')
+        elif method=='related':
+            self.assertEqual(part['Content-Disposition'], 'inline')
+        else:
+            # Otherwise we don't guess.
+            self.assertIsNone(part['Content-Disposition'])
+
+    class _TestSetRaisingContentManager:
+        class CustomError(Exception):
+            pass
+        def set_content(self, msg, content, *args, **kw):
+            raise self.CustomError('test')
+
+    def test_default_content_manager_for_add_comes_from_policy(self):
+        cm = self._TestSetRaisingContentManager()
+        m = self.message(policy=self.policy.clone(content_manager=cm))
+        for method in ('add_related', 'add_alternative', 'add_attachment'):
+            with self.assertRaises(self._TestSetRaisingContentManager.CustomError) as ar:
+                getattr(m, method)('')
+            self.assertEqual(str(ar.exception), 'test')
+
+    def message_as_clear(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        m.clear()
+        self.assertEqual(len(m), 0)
+        self.assertEqual(list(m.items()), [])
+        self.assertIsNone(m.get_payload())
+        self.assertEqual(list(m.iter_parts()), [])
+
+    def message_as_clear_content(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        expected_headers = [h for h in m.keys()
+                            if not h.lower().startswith('content-')]
+        m.clear_content()
+        self.assertEqual(list(m.keys()), expected_headers)
+        self.assertIsNone(m.get_payload())
+        self.assertEqual(list(m.iter_parts()), [])
+
+    def test_is_attachment(self):
+        m = self._make_message()
+        self.assertFalse(m.is_attachment())
+        m['Content-Disposition'] = 'inline'
+        self.assertFalse(m.is_attachment())
+        m.replace_header('Content-Disposition', 'attachment')
+        self.assertTrue(m.is_attachment())
+        m.replace_header('Content-Disposition', 'AtTachMent')
+        self.assertTrue(m.is_attachment())
+        m.set_param('filename', 'abc.png', 'Content-Disposition')
+        self.assertTrue(m.is_attachment())
+
+    def test_iter_attachments_mutation(self):
+        # We had a bug where iter_attachments was mutating the list.
+        m = self._make_message()
+        m.set_content('arbitrary text as main part')
+        m.add_related('more text as a related part')
+        m.add_related('yet more text as a second "attachment"')
+        orig = m.get_payload().copy()
+        self.assertEqual(len(list(m.iter_attachments())), 2)
+        self.assertEqual(m.get_payload(), orig)
+
+    get_payload_surrogate_params = {
+
+        'good_surrogateescape': (
+            "String that can be encod\udcc3\udcabd with surrogateescape",
+            b'String that can be encod\xc3\xabd with surrogateescape'
+            ),
+
+        'string_with_utf8': (
+            "String with utf-8 charactër",
+            b'String with utf-8 charact\xebr'
+            ),
+
+        'surrogate_and_utf8': (
+            "String that cannot be ëncod\udcc3\udcabd with surrogateescape",
+             b'String that cannot be \xebncod\\udcc3\\udcabd with surrogateescape'
+            ),
+
+        'out_of_range_surrogate': (
+            "String with \udfff cannot be encoded with surrogateescape",
+             b'String with \\udfff cannot be encoded with surrogateescape'
+            ),
+    }
+
+    def get_payload_surrogate_as_gh_94606(self, msg, expected):
+        """test for GH issue 94606"""
+        m = self._str_msg(msg)
+        payload = m.get_payload(decode=True)
+        self.assertEqual(expected, payload)
+
+
+class TestEmailMessage(TestEmailMessageBase, TestEmailBase):
+    message = EmailMessage
+
+    def test_set_content_adds_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertEqual(m['MIME-Version'], '1.0')
+
+    class _MIME_Version_adding_CM:
+        def set_content(self, msg, *args, **kw):
+            msg['MIME-Version'] = '1.0'
+
+    def test_set_content_does_not_duplicate_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._MIME_Version_adding_CM()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertEqual(m['MIME-Version'], '1.0')
+
+    def test_as_string_uses_max_header_length_by_default(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(m.as_string().strip().splitlines()), 3)
+
+    def test_as_string_allows_maxheaderlen(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(m.as_string(maxheaderlen=0).strip().splitlines()),
+                         1)
+        self.assertEqual(len(m.as_string(maxheaderlen=34).strip().splitlines()),
+                         6)
+
+    def test_as_string_unixform(self):
+        m = self._str_msg('test')
+        m.set_unixfrom('From foo@bar Thu Jan  1 00:00:00 1970')
+        self.assertEqual(m.as_string(unixfrom=True),
+                        'From foo@bar Thu Jan  1 00:00:00 1970\n\ntest')
+        self.assertEqual(m.as_string(unixfrom=False), '\ntest')
+
+    def test_str_defaults_to_policy_max_line_length(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(str(m).strip().splitlines()), 3)
+
+    def test_str_defaults_to_utf8(self):
+        m = EmailMessage()
+        m['Subject'] = 'unicöde'
+        self.assertEqual(str(m), 'Subject: unicöde\n\n')
+
+    def test_folding_with_utf8_encoding_1(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached within an ASCII
+        # word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello Wörld! Hello Wörld! '            \
+                       'Hello Wörld! Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: Hello =?utf-8?q?W=C3=B6rld!_Hello_W'
+                         b'=C3=B6rld!_Hello_W=C3=B6rld!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+
+    def test_folding_with_utf8_encoding_2(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached at the end of an
+        # encoded word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello Wörld! Hello Wörld! '                \
+                       'Hello Wörlds123! Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: Hello =?utf-8?q?W=C3=B6rld!_Hello_W'
+                         b'=C3=B6rld!_Hello_W=C3=B6rlds123!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_3(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached at the end of the
+        # first word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello-Wörld!-Hello-Wörld!-Hello-Wörlds123! ' \
+                       'Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m), \
+                         b'Subject: =?utf-8?q?Hello-W=C3=B6rld!-Hello-W'
+                         b'=C3=B6rld!-Hello-W=C3=B6rlds123!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_4(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the fold point, where the first
+        # word is UTF-8 and the fold point is within
+        # the word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello-Wörld!-Hello-Wörld!-Hello-Wörlds123!-Hello' \
+                       ' Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: =?utf-8?q?Hello-W=C3=B6rld!-Hello-W'
+                         b'=C3=B6rld!-Hello-W=C3=B6rlds123!?=\n'
+                         b' =?utf-8?q?-Hello_W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_5(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a UTF-8 word after
+        # the fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 123456789 123456789 123456789' \
+                       ' 123456789 123456789 Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 123456789 123456789'
+                         b' 123456789 123456789 123456789\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_6(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a UTF-8 word before
+        # the fold point and ASCII words after
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 123456789 123456789 Hello Wörld!' \
+                       ' 123456789 123456789 123456789 123456789 123456789'   \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 123456789 123456789'
+                         b' Hello =?utf-8?q?W=C3=B6rld!?=\n 123456789 '
+                         b'123456789 123456789 123456789 123456789 '
+                         b'123456789\n\n')
+
+    def test_folding_with_utf8_encoding_7(self):
+        # bpo-36520
+        #
+        # Fold a line twice that contains UTF-8 words before
+        # and after the first fold point, and ASCII words
+        # after the second fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 Hello Wörld! Hello Wörld! '       \
+                       '123456789-123456789 123456789 Hello Wörld! 123456789' \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 Hello =?utf-8?q?'
+                         b'W=C3=B6rld!_Hello_W=C3=B6rld!?=\n'
+                         b' 123456789-123456789 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!?= 123456789\n 123456789\n\n')
+
+    def test_folding_with_utf8_encoding_8(self):
+        # bpo-36520
+        #
+        # Fold a line twice that contains UTF-8 words before
+        # the first fold point, and ASCII words after the
+        # first fold point, and UTF-8 words after the second
+        # fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 Hello Wörld! Hello Wörld! '       \
+                       '123456789 123456789 123456789 123456789 123456789 '   \
+                       '123456789-123456789 123456789 Hello Wörld! 123456789' \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!_Hello_W=C3=B6rld!?=\n 123456789 '
+                         b'123456789 123456789 123456789 123456789 '
+                         b'123456789-123456789\n 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!?= 123456789 123456789\n\n')
+
+    def test_folding_with_short_nospace_1(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a long whitespace after
+        # the fold point.
+
+        m = EmailMessage(policy.default)
+        m['Message-ID'] = '123456789' * 3
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_default_policy_1(self):
+        # Fixed: https://github.com/python/cpython/issues/124452
+        #
+        # When the value is too long, it should be converted back
+        # to its original form without any modifications.
+
+        m = EmailMessage(policy.default)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        self.assertEqual(m.as_bytes(),
+                         f'Message-ID:\n {message}\n\n'.encode())
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_compat32_policy_1(self):
+        m = EmailMessage(policy.compat32)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_smtp_policy_1(self):
+        m = EmailMessage(policy.SMTP)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_http_policy_1(self):
+        m = EmailMessage(policy.HTTP)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_no_wrapping_max_line_length(self):
+        # Test that falsey 'max_line_length' are converted to sys.maxsize.
+        for n in [0, None]:
+            with self.subTest(max_line_length=n):
+                self.do_test_no_wrapping_max_line_length(n)
+
+    def do_test_no_wrapping_max_line_length(self, falsey):
+        self.assertFalse(falsey)
+        pol = policy.default.clone(max_line_length=falsey)
+        subj = "S" * 100
+        body = "B" * 100
+        msg = EmailMessage(policy=pol)
+        msg["From"] = "a@ex.com"
+        msg["To"] = "b@ex.com"
+        msg["Subject"] = subj
+        msg.set_content(body)
+
+        raw = msg.as_bytes()
+        self.assertNotIn(b"=\n", raw,
+                         "Found fold indicator; wrapping not disabled")
+
+        parsed = message_from_bytes(raw, policy=policy.default)
+        self.assertEqual(parsed["Subject"], subj)
+        parsed_body = parsed.get_body().get_content().rstrip('\n')
+        self.assertEqual(parsed_body, body)
+
+    def test_get_body_malformed(self):
+        """test for bpo-42892"""
+        msg = textwrap.dedent("""\
+            Message-ID: <674392CA.4347091@email.au>
+            Date: Wed, 08 Nov 2017 08:50:22 +0700
+            From: Foo Bar <email@email.au>
+            MIME-Version: 1.0
+            To: email@email.com <email@email.com>
+            Subject: Python Email
+            Content-Type: multipart/mixed;
+            boundary="------------879045806563892972123996"
+            X-Global-filter:Messagescannedforspamandviruses:passedalltests
+
+            This is a multi-part message in MIME format.
+            --------------879045806563892972123996
+            Content-Type: text/plain; charset=ISO-8859-1; format=flowed
+            Content-Transfer-Encoding: 7bit
+
+            Your message is ready to be sent with the following file or link
+            attachments:
+            XU89 - 08.11.2017
+            """)
+        m = self._str_msg(msg)
+        # In bpo-42892, this would raise
+        # AttributeError: 'str' object has no attribute 'is_attachment'
+        m.get_body()
+
+    def test_get_bytes_payload_with_quoted_printable_encoding(self):
+        # We use a memoryview to avoid directly changing the private payload
+        # and to prevent using the dedicated paths for string or bytes objects.
+        payload = memoryview(b'Some payload')
+        m = self._make_message()
+        m.add_header('Content-Transfer-Encoding', 'quoted-printable')
+        m.set_payload(payload)
+        self.assertEqual(m.get_payload(decode=True), payload)
+
+
+class TestMIMEPart(TestEmailMessageBase, TestEmailBase):
+    # Doing the full test run here may seem a bit redundant, since the two
+    # classes are almost identical.  But what if they drift apart?  So we do
+    # the full tests so that any future drift doesn't introduce bugs.
+    message = MIMEPart
+
+    def test_set_content_does_not_add_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertNotIn('MIME-Version', m)
+
+    def test_string_payload_with_multipart_content_type(self):
+        msg = message_from_string(textwrap.dedent("""\
+        Content-Type: multipart/mixed; charset="utf-8"
+
+        sample text
+        """), policy=policy.default)
+        attachments = msg.iter_attachments()
+        self.assertEqual(list(attachments), [])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_parser.py b/Lib/test/test_email/test_parser.py
new file mode 100644
index 00000000000..06c86408ab5
--- /dev/null
+++ b/Lib/test/test_email/test_parser.py
@@ -0,0 +1,110 @@
+import io
+import email
+import unittest
+from email.message import Message, EmailMessage
+from email.policy import default
+from test.test_email import TestEmailBase
+
+
+class TestCustomMessage(TestEmailBase):
+
+    class MyMessage(Message):
+        def __init__(self, policy):
+            self.check_policy = policy
+            super().__init__()
+
+    MyPolicy = TestEmailBase.policy.clone(linesep='boo')
+
+    def test_custom_message_gets_policy_if_possible_from_string(self):
+        msg = email.message_from_string("Subject: bogus\n\nmsg\n",
+                                        self.MyMessage,
+                                        policy=self.MyPolicy)
+        self.assertIsInstance(msg, self.MyMessage)
+        self.assertIs(msg.check_policy, self.MyPolicy)
+
+    def test_custom_message_gets_policy_if_possible_from_file(self):
+        source_file = io.StringIO("Subject: bogus\n\nmsg\n")
+        msg = email.message_from_file(source_file,
+                                      self.MyMessage,
+                                      policy=self.MyPolicy)
+        self.assertIsInstance(msg, self.MyMessage)
+        self.assertIs(msg.check_policy, self.MyPolicy)
+
+    # XXX add tests for other functions that take Message arg.
+
+
+class TestParserBase:
+
+    def test_only_split_on_cr_lf(self):
+        # The unicode line splitter splits on unicode linebreaks, which are
+        # more numerous than allowed by the email RFCs; make sure we are only
+        # splitting on those two.
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                msg = parser(
+                    "Next-Line: not\x85broken\r\n"
+                    "Null: not\x00broken\r\n"
+                    "Vertical-Tab: not\vbroken\r\n"
+                    "Form-Feed: not\fbroken\r\n"
+                    "File-Separator: not\x1Cbroken\r\n"
+                    "Group-Separator: not\x1Dbroken\r\n"
+                    "Record-Separator: not\x1Ebroken\r\n"
+                    "Line-Separator: not\u2028broken\r\n"
+                    "Paragraph-Separator: not\u2029broken\r\n"
+                    "\r\n",
+                    policy=default,
+                )
+                self.assertEqual(msg.items(), [
+                    ("Next-Line", "not\x85broken"),
+                    ("Null", "not\x00broken"),
+                    ("Vertical-Tab", "not\vbroken"),
+                    ("Form-Feed", "not\fbroken"),
+                    ("File-Separator", "not\x1Cbroken"),
+                    ("Group-Separator", "not\x1Dbroken"),
+                    ("Record-Separator", "not\x1Ebroken"),
+                    ("Line-Separator", "not\u2028broken"),
+                    ("Paragraph-Separator", "not\u2029broken"),
+                ])
+                self.assertEqual(msg.get_payload(), "")
+
+    class MyMessage(EmailMessage):
+        pass
+
+    def test_custom_message_factory_on_policy(self):
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                MyPolicy = default.clone(message_factory=self.MyMessage)
+                msg = parser("To: foo\n\ntest", policy=MyPolicy)
+                self.assertIsInstance(msg, self.MyMessage)
+
+    def test_factory_arg_overrides_policy(self):
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                MyPolicy = default.clone(message_factory=self.MyMessage)
+                msg = parser("To: foo\n\ntest", Message, policy=MyPolicy)
+                self.assertNotIsInstance(msg, self.MyMessage)
+                self.assertIsInstance(msg, Message)
+
+# Play some games to get nice output in subTest.  This code could be clearer
+# if staticmethod supported __name__.
+
+def message_from_file(s, *args, **kw):
+    f = io.StringIO(s)
+    return email.message_from_file(f, *args, **kw)
+
+class TestParser(TestParserBase, TestEmailBase):
+    parsers = (email.message_from_string, message_from_file)
+
+def message_from_bytes(s, *args, **kw):
+    return email.message_from_bytes(s.encode(), *args, **kw)
+
+def message_from_binary_file(s, *args, **kw):
+    f = io.BytesIO(s.encode())
+    return email.message_from_binary_file(f, *args, **kw)
+
+class TestBytesParser(TestParserBase, TestEmailBase):
+    parsers = (message_from_bytes, message_from_binary_file)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_pickleable.py b/Lib/test/test_email/test_pickleable.py
new file mode 100644
index 00000000000..16b44671146
--- /dev/null
+++ b/Lib/test/test_email/test_pickleable.py
@@ -0,0 +1,76 @@
+import unittest
+import textwrap
+import copy
+import pickle
+import email
+import email.message
+from email import policy
+from email.headerregistry import HeaderRegistry
+from test.test_email import TestEmailBase, parameterize
+
+
+@parameterize
+class TestPickleCopyHeader(TestEmailBase):
+
+    header_factory = HeaderRegistry()
+
+    unstructured = header_factory('subject', 'this is a test')
+
+    header_params = {
+        'subject': ('subject', 'this is a test'),
+        'from':    ('from',    'frodo@mordor.net'),
+        'to':      ('to',      'a: k@b.com, y@z.com;, j@f.com'),
+        'date':    ('date',    'Tue, 29 May 2012 09:24:26 +1000'),
+        }
+
+    def header_as_deepcopy(self, name, value):
+        header = self.header_factory(name, value)
+        h = copy.deepcopy(header)
+        self.assertEqual(str(h), str(header))
+
+    def header_as_pickle(self, name, value):
+        header = self.header_factory(name, value)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            p = pickle.dumps(header, proto)
+            h = pickle.loads(p)
+            self.assertEqual(str(h), str(header))
+
+
+@parameterize
+class TestPickleCopyMessage(TestEmailBase):
+
+    # Message objects are a sequence, so we have to make them a one-tuple in
+    # msg_params so they get passed to the parameterized test method as a
+    # single argument instead of as a list of headers.
+    msg_params = {}
+
+    # Note: there will be no custom header objects in the parsed message.
+    msg_params['parsed'] = (email.message_from_string(textwrap.dedent("""\
+        Date: Tue, 29 May 2012 09:24:26 +1000
+        From: frodo@mordor.net
+        To: bilbo@underhill.org
+        Subject: help
+
+        I think I forgot the ring.
+        """), policy=policy.default),)
+
+    msg_params['created'] = (email.message.Message(policy=policy.default),)
+    msg_params['created'][0]['Date'] = 'Tue, 29 May 2012 09:24:26 +1000'
+    msg_params['created'][0]['From'] = 'frodo@mordor.net'
+    msg_params['created'][0]['To'] = 'bilbo@underhill.org'
+    msg_params['created'][0]['Subject'] = 'help'
+    msg_params['created'][0].set_payload('I think I forgot the ring.')
+
+    def msg_as_deepcopy(self, msg):
+        msg2 = copy.deepcopy(msg)
+        self.assertEqual(msg2.as_string(), msg.as_string())
+
+    def msg_as_pickle(self, msg):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            p = pickle.dumps(msg, proto)
+            msg2 = pickle.loads(p)
+            self.assertEqual(msg2.as_string(), msg.as_string())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_policy.py b/Lib/test/test_email/test_policy.py
new file mode 100644
index 00000000000..baa35fd68e4
--- /dev/null
+++ b/Lib/test/test_email/test_policy.py
@@ -0,0 +1,429 @@
+import io
+import types
+import textwrap
+import unittest
+import email.errors
+import email.policy
+import email.parser
+import email.generator
+import email.message
+from email import headerregistry
+
+def make_defaults(base_defaults, differences):
+    defaults = base_defaults.copy()
+    defaults.update(differences)
+    return defaults
+
+class PolicyAPITests(unittest.TestCase):
+
+    longMessage = True
+
+    # Base default values.
+    compat32_defaults = {
+        'max_line_length':          78,
+        'linesep':                  '\n',
+        'cte_type':                 '8bit',
+        'raise_on_defect':          False,
+        'mangle_from_':             True,
+        'message_factory':          None,
+        'verify_generated_headers': True,
+        }
+    # These default values are the ones set on email.policy.default.
+    # If any of these defaults change, the docs must be updated.
+    policy_defaults = compat32_defaults.copy()
+    policy_defaults.update({
+        'utf8':                     False,
+        'raise_on_defect':          False,
+        'header_factory':           email.policy.EmailPolicy.header_factory,
+        'refold_source':            'long',
+        'content_manager':          email.policy.EmailPolicy.content_manager,
+        'mangle_from_':             False,
+        'message_factory':          email.message.EmailMessage,
+        })
+
+    # For each policy under test, we give here what we expect the defaults to
+    # be for that policy.  The second argument to make defaults is the
+    # difference between the base defaults and that for the particular policy.
+    new_policy = email.policy.EmailPolicy()
+    policies = {
+        email.policy.compat32: make_defaults(compat32_defaults, {}),
+        email.policy.default: make_defaults(policy_defaults, {}),
+        email.policy.SMTP: make_defaults(policy_defaults,
+                                         {'linesep': '\r\n'}),
+        email.policy.SMTPUTF8: make_defaults(policy_defaults,
+                                             {'linesep': '\r\n',
+                                              'utf8': True}),
+        email.policy.HTTP: make_defaults(policy_defaults,
+                                         {'linesep': '\r\n',
+                                          'max_line_length': None}),
+        email.policy.strict: make_defaults(policy_defaults,
+                                           {'raise_on_defect': True}),
+        new_policy: make_defaults(policy_defaults, {}),
+        }
+    # Creating a new policy creates a new header factory.  There is a test
+    # later that proves this.
+    policies[new_policy]['header_factory'] = new_policy.header_factory
+
+    def test_defaults(self):
+        for policy, expected in self.policies.items():
+            for attr, value in expected.items():
+                with self.subTest(policy=policy, attr=attr):
+                    self.assertEqual(getattr(policy, attr), value,
+                                    ("change {} docs/docstrings if defaults have "
+                                    "changed").format(policy))
+
+    def test_all_attributes_covered(self):
+        for policy, expected in self.policies.items():
+            for attr in dir(policy):
+                with self.subTest(policy=policy, attr=attr):
+                    if (attr.startswith('_') or
+                            isinstance(getattr(email.policy.EmailPolicy, attr),
+                                  types.FunctionType)):
+                        continue
+                    else:
+                        self.assertIn(attr, expected,
+                                      "{} is not fully tested".format(attr))
+
+    def test_abc(self):
+        with self.assertRaises(TypeError) as cm:
+            email.policy.Policy()
+        msg = str(cm.exception)
+        abstract_methods = ('fold',
+                            'fold_binary',
+                            'header_fetch_parse',
+                            'header_source_parse',
+                            'header_store_parse')
+        for method in abstract_methods:
+            self.assertIn(method, msg)
+
+    def test_policy_is_immutable(self):
+        for policy, defaults in self.policies.items():
+            for attr in defaults:
+                with self.assertRaisesRegex(AttributeError, attr+".*read-only"):
+                    setattr(policy, attr, None)
+            with self.assertRaisesRegex(AttributeError, 'no attribute.*foo'):
+                policy.foo = None
+
+    def test_set_policy_attrs_when_cloned(self):
+        # None of the attributes has a default value of None, so we set them
+        # all to None in the clone call and check that it worked.
+        for policyclass, defaults in self.policies.items():
+            testattrdict = {attr: None for attr in defaults}
+            policy = policyclass.clone(**testattrdict)
+            for attr in defaults:
+                self.assertIsNone(getattr(policy, attr))
+
+    def test_reject_non_policy_keyword_when_called(self):
+        for policyclass in self.policies:
+            with self.assertRaises(TypeError):
+                policyclass(this_keyword_should_not_be_valid=None)
+            with self.assertRaises(TypeError):
+                policyclass(newtline=None)
+
+    def test_policy_addition(self):
+        expected = self.policy_defaults.copy()
+        p1 = email.policy.default.clone(max_line_length=100)
+        p2 = email.policy.default.clone(max_line_length=50)
+        added = p1 + p2
+        expected.update(max_line_length=50)
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+        added = p2 + p1
+        expected.update(max_line_length=100)
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+        added = added + email.policy.default
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+
+    def test_fold_utf8(self):
+        expected_ascii = 'Subject: =?utf-8?q?=C3=A1?=\n'
+        expected_utf8 = 'Subject: á\n'
+
+        msg = email.message.EmailMessage()
+        s = 'á'
+        msg['Subject'] = s
+
+        p_ascii = email.policy.default.clone()
+        p_utf8 = email.policy.default.clone(utf8=True)
+
+        self.assertEqual(p_ascii.fold('Subject', msg['Subject']), expected_ascii)
+        self.assertEqual(p_utf8.fold('Subject', msg['Subject']), expected_utf8)
+
+        self.assertEqual(p_ascii.fold('Subject', s), expected_ascii)
+        self.assertEqual(p_utf8.fold('Subject', s), expected_utf8)
+
+    def test_fold_zero_max_line_length(self):
+        expected = 'Subject: =?utf-8?q?=C3=A1?=\n'
+
+        msg = email.message.EmailMessage()
+        msg['Subject'] = 'á'
+
+        p1 = email.policy.default.clone(max_line_length=0)
+        p2 = email.policy.default.clone(max_line_length=None)
+
+        self.assertEqual(p1.fold('Subject', msg['Subject']), expected)
+        self.assertEqual(p2.fold('Subject', msg['Subject']), expected)
+
+    def test_register_defect(self):
+        class Dummy:
+            def __init__(self):
+                self.defects = []
+        obj = Dummy()
+        defect = object()
+        policy = email.policy.EmailPolicy()
+        policy.register_defect(obj, defect)
+        self.assertEqual(obj.defects, [defect])
+        defect2 = object()
+        policy.register_defect(obj, defect2)
+        self.assertEqual(obj.defects, [defect, defect2])
+
+    class MyObj:
+        def __init__(self):
+            self.defects = []
+
+    class MyDefect(Exception):
+        pass
+
+    def test_handle_defect_raises_on_strict(self):
+        foo = self.MyObj()
+        defect = self.MyDefect("the telly is broken")
+        with self.assertRaisesRegex(self.MyDefect, "the telly is broken"):
+            email.policy.strict.handle_defect(foo, defect)
+
+    def test_handle_defect_registers_defect(self):
+        foo = self.MyObj()
+        defect1 = self.MyDefect("one")
+        email.policy.default.handle_defect(foo, defect1)
+        self.assertEqual(foo.defects, [defect1])
+        defect2 = self.MyDefect("two")
+        email.policy.default.handle_defect(foo, defect2)
+        self.assertEqual(foo.defects, [defect1, defect2])
+
+    class MyPolicy(email.policy.EmailPolicy):
+        defects = None
+        def __init__(self, *args, **kw):
+            super().__init__(*args, defects=[], **kw)
+        def register_defect(self, obj, defect):
+            self.defects.append(defect)
+
+    def test_overridden_register_defect_still_raises(self):
+        foo = self.MyObj()
+        defect = self.MyDefect("the telly is broken")
+        with self.assertRaisesRegex(self.MyDefect, "the telly is broken"):
+            self.MyPolicy(raise_on_defect=True).handle_defect(foo, defect)
+
+    def test_overridden_register_defect_works(self):
+        foo = self.MyObj()
+        defect1 = self.MyDefect("one")
+        my_policy = self.MyPolicy()
+        my_policy.handle_defect(foo, defect1)
+        self.assertEqual(my_policy.defects, [defect1])
+        self.assertEqual(foo.defects, [])
+        defect2 = self.MyDefect("two")
+        my_policy.handle_defect(foo, defect2)
+        self.assertEqual(my_policy.defects, [defect1, defect2])
+        self.assertEqual(foo.defects, [])
+
+    def test_default_header_factory(self):
+        h = email.policy.default.header_factory('Test', 'test')
+        self.assertEqual(h.name, 'Test')
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+
+    class Foo:
+        parse = headerregistry.UnstructuredHeader.parse
+
+    def test_each_Policy_gets_unique_factory(self):
+        policy1 = email.policy.EmailPolicy()
+        policy2 = email.policy.EmailPolicy()
+        policy1.header_factory.map_to_type('foo', self.Foo)
+        h = policy1.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+        self.assertNotIsInstance(h, headerregistry.UnstructuredHeader)
+        h = policy2.header_factory('foo', 'test')
+        self.assertNotIsInstance(h, self.Foo)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_clone_copies_factory(self):
+        policy1 = email.policy.EmailPolicy()
+        policy2 = policy1.clone()
+        policy1.header_factory.map_to_type('foo', self.Foo)
+        h = policy1.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+        h = policy2.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+
+    def test_new_factory_overrides_default(self):
+        mypolicy = email.policy.EmailPolicy()
+        myfactory = mypolicy.header_factory
+        newpolicy = mypolicy + email.policy.strict
+        self.assertEqual(newpolicy.header_factory, myfactory)
+        newpolicy = email.policy.strict + mypolicy
+        self.assertEqual(newpolicy.header_factory, myfactory)
+
+    def test_adding_default_policies_preserves_default_factory(self):
+        newpolicy = email.policy.default + email.policy.strict
+        self.assertEqual(newpolicy.header_factory,
+                         email.policy.EmailPolicy.header_factory)
+        self.assertEqual(newpolicy.__dict__, {'raise_on_defect': True})
+
+    def test_non_ascii_chars_do_not_cause_inf_loop(self):
+        policy = email.policy.default.clone(max_line_length=20)
+        actual = policy.fold('Subject', 'Ä…' * 12)
+        self.assertEqual(
+            actual,
+            'Subject: \n' +
+            12 * ' =?utf-8?q?=C4=85?=\n')
+
+    def test_short_maxlen_error(self):
+        # RFC 2047 chrome takes up 7 characters, plus the length of the charset
+        # name, so folding should fail if maxlen is lower than the minimum
+        # required length for a line.
+
+        # Note: This is only triggered when there is a single word longer than
+        # max_line_length, hence the 1234567890 at the end of this whimsical
+        # subject. This is because when we encounter a word longer than
+        # max_line_length, it is broken down into encoded words to fit
+        # max_line_length. If the max_line_length isn't large enough to even
+        # contain the RFC 2047 chrome (`?=<charset>?q??=`), we fail.
+        subject = "Melt away the pounds with this one simple trick! 1234567890"
+
+        for maxlen in [3, 7, 9]:
+            with self.subTest(maxlen=maxlen):
+                policy = email.policy.default.clone(max_line_length=maxlen)
+                with self.assertRaises(email.errors.HeaderParseError):
+                    policy.fold("Subject", subject)
+
+    def test_verify_generated_headers(self):
+        """Turning protection off allows header injection"""
+        policy = email.policy.default.clone(verify_generated_headers=False)
+        for text in (
+            'Header: Value\r\nBad: Injection\r\n',
+            'Header: NoNewLine'
+        ):
+            with self.subTest(text=text):
+                message = email.message_from_string(
+                    "Header: Value\r\n\r\nBody",
+                    policy=policy,
+                )
+                class LiteralHeader(str):
+                    name = 'Header'
+                    def fold(self, **kwargs):
+                        return self
+
+                del message['Header']
+                message['Header'] = LiteralHeader(text)
+
+                self.assertEqual(
+                    message.as_string(),
+                    f"{text}\nBody",
+                )
+
+    # XXX: Need subclassing tests.
+    # For adding subclassed objects, make sure the usual rules apply (subclass
+    # wins), but that the order still works (right overrides left).
+
+
+class TestException(Exception):
+    pass
+
+class TestPolicyPropagation(unittest.TestCase):
+
+    # The abstract methods are used by the parser but not by the wrapper
+    # functions that call it, so if the exception gets raised we know that the
+    # policy was actually propagated all the way to feedparser.
+    class MyPolicy(email.policy.Policy):
+        def badmethod(self, *args, **kw):
+            raise TestException("test")
+        fold = fold_binary = header_fetch_parser = badmethod
+        header_source_parse = header_store_parse = badmethod
+
+    def test_message_from_string(self):
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_string("Subject: test\n\n",
+                                      policy=self.MyPolicy)
+
+    def test_message_from_bytes(self):
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_bytes(b"Subject: test\n\n",
+                                     policy=self.MyPolicy)
+
+    def test_message_from_file(self):
+        f = io.StringIO('Subject: test\n\n')
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_file(f, policy=self.MyPolicy)
+
+    def test_message_from_binary_file(self):
+        f = io.BytesIO(b'Subject: test\n\n')
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_binary_file(f, policy=self.MyPolicy)
+
+    # These are redundant, but we need them for black-box completeness.
+
+    def test_parser(self):
+        p = email.parser.Parser(policy=self.MyPolicy)
+        with self.assertRaisesRegex(TestException, "^test$"):
+            p.parsestr('Subject: test\n\n')
+
+    def test_bytes_parser(self):
+        p = email.parser.BytesParser(policy=self.MyPolicy)
+        with self.assertRaisesRegex(TestException, "^test$"):
+            p.parsebytes(b'Subject: test\n\n')
+
+    # Now that we've established that all the parse methods get the
+    # policy in to feedparser, we can use message_from_string for
+    # the rest of the propagation tests.
+
+    def _make_msg(self, source='Subject: test\n\n', policy=None):
+        self.policy = email.policy.default.clone() if policy is None else policy
+        return email.message_from_string(source, policy=self.policy)
+
+    def test_parser_propagates_policy_to_message(self):
+        msg = self._make_msg()
+        self.assertIs(msg.policy, self.policy)
+
+    def test_parser_propagates_policy_to_sub_messages(self):
+        msg = self._make_msg(textwrap.dedent("""\
+            Subject: mime test
+            MIME-Version: 1.0
+            Content-Type: multipart/mixed, boundary="XXX"
+
+            --XXX
+            Content-Type: text/plain
+
+            test
+            --XXX
+            Content-Type: text/plain
+
+            test2
+            --XXX--
+            """))
+        for part in msg.walk():
+            self.assertIs(part.policy, self.policy)
+
+    def test_message_policy_propagates_to_generator(self):
+        msg = self._make_msg("Subject: test\nTo: foo\n\n",
+                             policy=email.policy.default.clone(linesep='X'))
+        s = io.StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), "Subject: testXTo: fooXX")
+
+    def test_message_policy_used_by_as_string(self):
+        msg = self._make_msg("Subject: test\nTo: foo\n\n",
+                             policy=email.policy.default.clone(linesep='X'))
+        self.assertEqual(msg.as_string(), "Subject: testXTo: fooXX")
+
+
+class TestConcretePolicies(unittest.TestCase):
+
+    def test_header_store_parse_rejects_newlines(self):
+        instance = email.policy.EmailPolicy()
+        self.assertRaises(ValueError,
+                          instance.header_store_parse,
+                          'From', 'spam\negg@foo.py')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_utils.py b/Lib/test/test_email/test_utils.py
new file mode 100644
index 00000000000..d04b3909efa
--- /dev/null
+++ b/Lib/test/test_email/test_utils.py
@@ -0,0 +1,186 @@
+import datetime
+from email import utils
+import test.support
+import time
+import unittest
+import sys
+import os.path
+import zoneinfo
+
+class DateTimeTests(unittest.TestCase):
+
+    datestring = 'Sun, 23 Sep 2001 20:10:55'
+    dateargs = (2001, 9, 23, 20, 10, 55)
+    offsetstring = ' -0700'
+    utcoffset = datetime.timedelta(hours=-7)
+    tz = datetime.timezone(utcoffset)
+    naive_dt = datetime.datetime(*dateargs)
+    aware_dt = datetime.datetime(*dateargs, tzinfo=tz)
+
+    def test_naive_datetime(self):
+        self.assertEqual(utils.format_datetime(self.naive_dt),
+                         self.datestring + ' -0000')
+
+    def test_aware_datetime(self):
+        self.assertEqual(utils.format_datetime(self.aware_dt),
+                         self.datestring + self.offsetstring)
+
+    def test_usegmt(self):
+        utc_dt = datetime.datetime(*self.dateargs,
+                                   tzinfo=datetime.timezone.utc)
+        self.assertEqual(utils.format_datetime(utc_dt, usegmt=True),
+                         self.datestring + ' GMT')
+
+    def test_usegmt_with_naive_datetime_raises(self):
+        with self.assertRaises(ValueError):
+            utils.format_datetime(self.naive_dt, usegmt=True)
+
+    def test_usegmt_with_non_utc_datetime_raises(self):
+        with self.assertRaises(ValueError):
+            utils.format_datetime(self.aware_dt, usegmt=True)
+
+    def test_parsedate_to_datetime(self):
+        self.assertEqual(
+            utils.parsedate_to_datetime(self.datestring + self.offsetstring),
+            self.aware_dt)
+
+    def test_parsedate_to_datetime_naive(self):
+        self.assertEqual(
+            utils.parsedate_to_datetime(self.datestring + ' -0000'),
+            self.naive_dt)
+
+    def test_parsedate_to_datetime_with_invalid_raises_valueerror(self):
+        # See also test_parsedate_returns_None_for_invalid_strings in test_email.
+        invalid_dates = [
+            '',
+            ' ',
+            '0',
+            'A Complete Waste of Time',
+            'Wed, 3 Apr 2002 12.34.56.78+0800'
+            'Tue, 06 Jun 2017 27:39:33 +0600',
+            'Tue, 06 Jun 2017 07:39:33 +2600',
+            'Tue, 06 Jun 2017 27:39:33',
+            '17 June , 2022',
+            'Friday, -Nov-82 16:14:55 EST',
+            'Friday, Nov--82 16:14:55 EST',
+            'Friday, 19-Nov- 16:14:55 EST',
+        ]
+        for dtstr in invalid_dates:
+            with self.subTest(dtstr=dtstr):
+                self.assertRaises(ValueError, utils.parsedate_to_datetime, dtstr)
+
+class LocaltimeTests(unittest.TestCase):
+
+    def test_localtime_is_tz_aware_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t = utils.localtime()
+        self.assertIsNotNone(t.tzinfo)
+
+    def test_localtime_is_tz_aware_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t = utils.localtime()
+        self.assertIsNotNone(t.tzinfo)
+
+    def test_localtime_daylight_true_dst_false(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    def test_localtime_daylight_false_dst_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_localtime_daylight_true_dst_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_localtime_daylight_false_dst_true(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
+    def test_localtime_epoch_utc_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(1990, 1, 1, tzinfo = datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        t2 = t0 - datetime.timedelta(hours=5)
+        t2 = t2.replace(tzinfo = datetime.timezone(datetime.timedelta(hours=-5)))
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
+    def test_localtime_epoch_utc_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(1990, 1, 1, tzinfo = datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        t2 = t0 - datetime.timedelta(hours=5)
+        t2 = t2.replace(tzinfo = datetime.timezone(datetime.timedelta(hours=-5)))
+        self.assertEqual(t1, t2)
+
+    def test_localtime_epoch_notz_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(1990, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t0.replace(tzinfo=None))
+        self.assertEqual(t1, t2)
+
+    def test_localtime_epoch_notz_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(1990, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t0.replace(tzinfo=None))
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Kyiv')
+    def test_variable_tzname(self):
+        t0 = datetime.datetime(1984, 1, 1, tzinfo=datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        if t1.tzname() in ('Europe', 'UTC'):
+            self.skipTest("Can't find a Kyiv timezone database")
+        self.assertEqual(t1.tzname(), 'MSK')
+        t0 = datetime.datetime(1994, 1, 1, tzinfo=datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        self.assertEqual(t1.tzname(), 'EET')
+
+    def test_isdst_deprecation(self):
+        with self.assertWarns(DeprecationWarning):
+            t0 = datetime.datetime(1990, 1, 1)
+            t1 = utils.localtime(t0, isdst=True)
+
+# Issue #24836: The timezone files are out of date (pre 2011k)
+# on Mac OS X Snow Leopard.
+@test.support.requires_mac_ver(10, 7)
+class FormatDateTests(unittest.TestCase):
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_formatdate(self):
+        timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
+        string = utils.formatdate(timeval, localtime=False, usegmt=False)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 -0000')
+        string = utils.formatdate(timeval, localtime=False, usegmt=True)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 GMT')
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_formatdate_with_localtime(self):
+        timeval = time.mktime((2011, 1, 1, 18, 0, 0, 6, 1, 0))
+        string = utils.formatdate(timeval, localtime=True)
+        self.assertEqual(string, 'Sat, 01 Jan 2011 18:00:00 +0200')
+        # Minsk moved from +0200 (with DST) to +0300 (without DST) in 2011
+        timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
+        string = utils.formatdate(timeval, localtime=True)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 18:00:00 +0300')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/torture_test.py b/Lib/test/test_email/torture_test.py
new file mode 100644
index 00000000000..9cf9362c9b7
--- /dev/null
+++ b/Lib/test/test_email/torture_test.py
@@ -0,0 +1,127 @@
+# Copyright (C) 2002-2004 Python Software Foundation
+#
+# A torture test of the email package.  This should not be run as part of the
+# standard Python test suite since it requires several meg of email messages
+# collected in the wild.  These source messages are not checked into the
+# Python distro, but are available as part of the standalone email package at
+# http://sf.net/projects/mimelib
+
+import sys
+import os
+import unittest
+from io import StringIO
+
+from test.test_email import TestEmailBase
+
+import email
+from email import __file__ as testfile
+from email.iterators import _structure
+
+def openfile(filename):
+    from os.path import join, dirname, abspath
+    path = abspath(join(dirname(testfile), os.pardir, 'moredata', filename))
+    return open(path, 'r')
+
+# Prevent this test from running in the Python distro
+def setUpModule():
+    try:
+        openfile('crispin-torture.txt')
+    except OSError:
+        raise unittest.SkipTest
+
+
+
+class TortureBase(TestEmailBase):
+    def _msgobj(self, filename):
+        fp = openfile(filename)
+        try:
+            msg = email.message_from_file(fp)
+        finally:
+            fp.close()
+        return msg
+
+
+
+class TestCrispinTorture(TortureBase):
+    # Mark Crispin's torture test from the SquirrelMail project
+    def test_mondo_message(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        msg = self._msgobj('crispin-torture.txt')
+        payload = msg.get_payload()
+        eq(type(payload), list)
+        eq(len(payload), 12)
+        eq(msg.preamble, None)
+        eq(msg.epilogue, '\n')
+        # Probably the best way to verify the message is parsed correctly is to
+        # dump its structure and compare it against the known structure.
+        fp = StringIO()
+        _structure(msg, fp=fp)
+        neq(fp.getvalue(), """\
+multipart/mixed
+    text/plain
+    message/rfc822
+        multipart/alternative
+            text/plain
+            multipart/mixed
+                text/richtext
+            application/andrew-inset
+    message/rfc822
+        audio/basic
+    audio/basic
+    image/pbm
+    message/rfc822
+        multipart/mixed
+            multipart/mixed
+                text/plain
+                audio/x-sun
+            multipart/mixed
+                image/gif
+                image/gif
+                application/x-be2
+                application/atomicmail
+            audio/x-sun
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pgm
+            text/plain
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pbm
+    message/rfc822
+        application/postscript
+    image/gif
+    message/rfc822
+        multipart/mixed
+            audio/basic
+            audio/basic
+    message/rfc822
+        multipart/mixed
+            application/postscript
+            text/plain
+            message/rfc822
+                multipart/mixed
+                    text/plain
+                    multipart/parallel
+                        image/gif
+                        audio/basic
+                    application/atomicmail
+                    message/rfc822
+                        audio/x-sun
+""")
+
+def _testclasses():
+    mod = sys.modules[__name__]
+    return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
+
+
+def load_tests(loader, tests, pattern):
+    suite = loader.suiteClass()
+    for testclass in _testclasses():
+        suite.addTest(loader.loadTestsFromTestCase(testclass))
+    return suite
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index df3a72e302a..35055e03b8e 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -53,8 +53,6 @@ class TimeTestCase(unittest.TestCase):
     def setUp(self):
         self.t = time.time()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'time' has no attribute 'altzone'
-    @unittest.expectedFailure
     def test_data_attributes(self):
         time.altzone
         time.daylight
diff --git a/crates/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs
index 8c368b9cc59..8539e69bacb 100644
--- a/crates/vm/src/stdlib/time.rs
+++ b/crates/vm/src/stdlib/time.rs
@@ -197,6 +197,23 @@ mod decl {
     //     unsafe { super::_tzset() };
     // }
 
+    #[cfg(not(target_env = "msvc"))]
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr]
+    fn altzone(_vm: &VirtualMachine) -> core::ffi::c_long {
+        // TODO: RUSTPYTHON; Add support for using the C altzone
+        unsafe { super::c_timezone - 3600 }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr]
+    fn altzone(_vm: &VirtualMachine) -> i32 {
+        let info = get_tz_info();
+        // https://users.rust-lang.org/t/accessing-tzname-and-similar-constants-in-windows/125771/3
+        (info.Bias + info.StandardBias) * 60 - 3600
+    }
+
     #[cfg(not(target_env = "msvc"))]
     #[cfg(not(target_arch = "wasm32"))]
     #[pyattr]

From 02cc257b42727a60de5377dd4385b79bdef588c4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 18:37:16 +0900
Subject: [PATCH 307/418] Support pickle better with __getnewargs_ex__ (#6749)

* Implement pickle more

* add weakref check

* check exports in __setstate__

* remove reducelib
---
 Lib/test/test_copy.py                        |   4 -
 Lib/test/test_csv.py                         |   1 -
 Lib/test/test_descr.py                       |   3 -
 Lib/test/test_enum.py                        |   1 -
 Lib/test/test_lzma.py                        |   4 +-
 Lib/test/test_memoryio.py                    |  12 -
 Lib/test/test_pickle.py                      |  20 --
 Lib/test/test_pickletools.py                 |   8 -
 Lib/test/test_typing.py                      |   1 -
 Lib/test/test_unittest/test_runner.py        |   1 -
 Lib/test/test_zlib.py                        |   6 -
 crates/vm/Lib/python_builtins/__reducelib.py |  86 -------
 crates/vm/src/builtins/object.rs             | 229 +++++++++++++++++--
 crates/vm/src/stdlib/io.rs                   | 128 ++++++++++-
 crates/vm/src/stdlib/thread.rs               |   2 +-
 crates/vm/src/vm/context.rs                  |   1 +
 16 files changed, 334 insertions(+), 173 deletions(-)
 delete mode 100644 crates/vm/Lib/python_builtins/__reducelib.py

diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 456767bbe0c..e543cc236c1 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -207,8 +207,6 @@ def __eq__(self, other):
         self.assertIsNot(y, x)
         self.assertEqual(y.foo, x.foo)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_copy_inst_getnewargs_ex(self):
         class C(int):
             def __new__(cls, *, foo):
@@ -507,8 +505,6 @@ def __eq__(self, other):
         self.assertEqual(y.foo, x.foo)
         self.assertIsNot(y.foo, x.foo)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_deepcopy_inst_getnewargs_ex(self):
         class C(int):
             def __new__(cls, *, foo):
diff --git a/Lib/test/test_csv.py b/Lib/test/test_csv.py
index b7f93d1bac9..bf9b1875573 100644
--- a/Lib/test/test_csv.py
+++ b/Lib/test/test_csv.py
@@ -698,7 +698,6 @@ def test_copy(self):
             dialect = csv.get_dialect(name)
             self.assertRaises(TypeError, copy.copy, dialect)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickle(self):
         for name in csv.list_dialects():
             dialect = csv.get_dialect(name)
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 7420a49b8f7..2ad302690c0 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -5258,7 +5258,6 @@ def _check_reduce(self, proto, obj, args=(), kwargs={}, state=None,
             self.assertEqual(obj.__reduce_ex__(proto), reduce_value)
             self.assertEqual(obj.__reduce__(), reduce_value)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_reduce(self):
         protocols = range(pickle.HIGHEST_PROTOCOL + 1)
         args = (-101, "spam")
@@ -5382,7 +5381,6 @@ class C16(list):
         for proto in protocols:
             self._check_reduce(proto, obj, listitems=list(obj))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_special_method_lookup(self):
         protocols = range(pickle.HIGHEST_PROTOCOL + 1)
         class Picky:
@@ -5515,7 +5513,6 @@ class E(C):
                 y = pickle_copier.copy(x)
                 self._assert_is_copy(x, y)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_reduce_copying(self):
         # Tests pickling and copying new-style classes and objects.
         global C1
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 5a961711cce..21a3b8edd4e 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -2130,7 +2130,6 @@ class NEI(NamedInt, Enum):
         test_pickle_dump_load(self.assertIs, NEI.y)
         test_pickle_dump_load(self.assertIs, NEI)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; fails on pickle
     def test_subclasses_with_getnewargs_ex(self):
         class NamedInt(int):
             __qualname__ = 'NamedInt'       # needed for pickle protocol 4
diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
index 1bac61f59e1..4010ef9c340 100644
--- a/Lib/test/test_lzma.py
+++ b/Lib/test/test_lzma.py
@@ -409,8 +409,6 @@ def test_decompressor_bigmem(self, size):
 
     # Pickling raises an exception; there's no way to serialize an lzma_stream.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises(TypeError):
@@ -2194,4 +2192,4 @@ def test_filter_properties_roundtrip(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index 07d9d38d6e4..343e5dd7a6c 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -745,8 +745,6 @@ def test_init(self):
     def test_issue5449(self):
         super().test_issue5449()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickling(self):
         super().test_pickling()
 
@@ -777,8 +775,6 @@ def test_truncate(self):
     def test_write(self):
         super().test_write()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getstate(self):
         memio = self.ioclass()
         state = memio.__getstate__()
@@ -911,8 +907,6 @@ def test_newline_none(self):
     def test_newlines_property(self):
         super().test_newlines_property()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickling(self):
         super().test_pickling()
 
@@ -954,8 +948,6 @@ def test_widechar(self):
         self.assertEqual(memio.tell(), len(buf) * 2)
         self.assertEqual(memio.getvalue(), buf + buf)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getstate(self):
         memio = self.ioclass()
         state = memio.__getstate__()
@@ -1006,8 +998,6 @@ def test_newline_cr(self):
     def test_newline_crlf(self):
         super().test_newline_crlf()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_newline_default(self):
         super().test_newline_default()
 
@@ -1016,8 +1006,6 @@ def test_newline_default(self):
     def test_newline_empty(self):
         super().test_newline_empty()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_newline_lf(self):
         super().test_newline_lf()
 
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index ea51b9d0916..7271696a191 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -97,10 +97,6 @@ def dumps(self, arg, proto=None, **kwargs):
     def test_picklebuffer_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_picklebuffer_error()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_bad_getattr(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_bad_getattr()
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -135,15 +131,7 @@ def loads(self, buf, **kwds):
     def test_c_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_c_methods()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_complex_newobj_ex()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_py_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_py_methods()
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -239,10 +227,6 @@ def loads(self, buf, **kwds):
     def test_c_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_c_methods()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_complex_newobj_ex()
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -259,10 +243,6 @@ def test_correctly_quoted_string(self): # TODO(RUSTPYTHON): Remove this test whe
     def test_load_python2_str_as_bytes(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_load_python2_str_as_bytes()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_py_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_py_methods()
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
diff --git a/Lib/test/test_pickletools.py b/Lib/test/test_pickletools.py
index 492f57cce22..42a20da00b1 100644
--- a/Lib/test/test_pickletools.py
+++ b/Lib/test/test_pickletools.py
@@ -97,15 +97,7 @@ def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers_writable_to_readonly()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_py_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_py_methods()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO(RUSTPYTHON): Remove this test when it passes
-        return super().test_complex_newobj_ex()
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index 3e6c530cecc..17cbaa92218 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -10328,7 +10328,6 @@ def test_special_attrs(self):
 
     TypeName = typing.NewType('SpecialAttrsTests.TypeName', Any)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_special_attrs2(self):
         # Forward refs provide a different introspection API. __name__ and
         # __qualname__ make little sense for forward refs as they can store
diff --git a/Lib/test/test_unittest/test_runner.py b/Lib/test/test_unittest/test_runner.py
index 790c4d29ca2..4d3cfd60b8d 100644
--- a/Lib/test/test_unittest/test_runner.py
+++ b/Lib/test/test_unittest/test_runner.py
@@ -1297,7 +1297,6 @@ def _makeResult(self):
         expected = ['startTestRun', 'stopTestRun']
         self.assertEqual(events, expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickle_unpickle(self):
         # Issue #7197: a TextTestRunner should be (un)pickleable. This is
         # required by test_multiprocessing under Windows (in verbose mode).
diff --git a/Lib/test/test_zlib.py b/Lib/test/test_zlib.py
index 0a75457ad85..c9f7b183408 100644
--- a/Lib/test/test_zlib.py
+++ b/Lib/test/test_zlib.py
@@ -747,15 +747,11 @@ def test_baddecompresscopy(self):
         self.assertRaises(ValueError, copy.copy, d)
         self.assertRaises(ValueError, copy.deepcopy, d)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compresspickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises((TypeError, pickle.PicklingError)):
                 pickle.dumps(zlib.compressobj(zlib.Z_BEST_COMPRESSION), proto)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decompresspickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises((TypeError, pickle.PicklingError)):
@@ -1006,8 +1002,6 @@ def testDecompress4G(self, size):
             compressed = None
             decompressed = None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testPickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises(TypeError):
diff --git a/crates/vm/Lib/python_builtins/__reducelib.py b/crates/vm/Lib/python_builtins/__reducelib.py
deleted file mode 100644
index 0067cd0a818..00000000000
--- a/crates/vm/Lib/python_builtins/__reducelib.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Modified from code from the PyPy project:
-# https://bitbucket.org/pypy/pypy/src/default/pypy/objspace/std/objectobject.py
-
-# The MIT License
-
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-import copyreg
-
-
-def _abstract_method_error(typ):
-    methods = ", ".join(sorted(typ.__abstractmethods__))
-    err = "Can't instantiate abstract class %s with abstract methods %s"
-    raise TypeError(err % (typ.__name__, methods))
-
-
-def reduce_2(obj):
-    cls = obj.__class__
-
-    try:
-        getnewargs = obj.__getnewargs__
-    except AttributeError:
-        args = ()
-    else:
-        args = getnewargs()
-        if not isinstance(args, tuple):
-            raise TypeError("__getnewargs__ should return a tuple")
-
-    try:
-        getstate = obj.__getstate__
-    except AttributeError:
-        state = getattr(obj, "__dict__", None)
-        names = slotnames(cls)  # not checking for list
-        if names is not None:
-            slots = {}
-            for name in names:
-                try:
-                    value = getattr(obj, name)
-                except AttributeError:
-                    pass
-                else:
-                    slots[name] = value
-            if slots:
-                state = state, slots
-    else:
-        state = getstate()
-
-    listitems = iter(obj) if isinstance(obj, list) else None
-    dictitems = iter(obj.items()) if isinstance(obj, dict) else None
-
-    newobj = copyreg.__newobj__
-
-    args2 = (cls,) + args
-    return newobj, args2, state, listitems, dictitems
-
-
-def slotnames(cls):
-    if not isinstance(cls, type):
-        return None
-
-    try:
-        return cls.__dict__["__slotnames__"]
-    except KeyError:
-        pass
-
-    slotnames = copyreg._slotnames(cls)
-    if not isinstance(slotnames, list) and slotnames is not None:
-        raise TypeError("copyreg._slotnames didn't return a list or None")
-    return slotnames
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 6f072542547..982e11afd00 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -184,15 +184,12 @@ fn type_slot_names(typ: &Py<PyType>, vm: &VirtualMachine) -> PyResult<Option<sup
     Ok(result)
 }
 
-// object_getstate_default in CPython
+// object_getstate_default
 fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
-    // TODO: itemsize
-    // if required && obj.class().slots.itemsize > 0 {
-    //     return vm.new_type_error(format!(
-    //         "cannot pickle {:.200} objects",
-    //         obj.class().name()
-    //     ));
-    // }
+    // Check itemsize
+    if required && obj.class().slots.itemsize > 0 {
+        return Err(vm.new_type_error(format!("cannot pickle {:.200} objects", obj.class().name())));
+    }
 
     let state = if obj.dict().is_none_or(|d| d.is_empty()) {
         vm.ctx.none()
@@ -208,22 +205,36 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
         type_slot_names(obj.class(), vm).map_err(|_| vm.new_type_error("cannot pickle object"))?;
 
     if required {
-        let mut basicsize = obj.class().slots.basicsize;
-        // if obj.class().slots.dict_offset > 0
-        //     && !obj.class().slots.flags.has_feature(PyTypeFlags::MANAGED_DICT)
-        // {
-        //     basicsize += std::mem::size_of::<PyObjectRef>();
-        // }
-        // if obj.class().slots.weaklist_offset > 0 {
-        //     basicsize += std::mem::size_of::<PyObjectRef>();
-        // }
+        // Start with PyBaseObject_Type's basicsize
+        let mut basicsize = vm.ctx.types.object_type.slots.basicsize;
+
+        // Add __dict__ size if type has dict
+        if obj.class().slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+            basicsize += core::mem::size_of::<PyObjectRef>();
+        }
+
+        // Add __weakref__ size if type has weakref support
+        let has_weakref = if let Some(ref ext) = obj.class().heaptype_ext {
+            match &ext.slots {
+                None => true, // Heap type without __slots__ has automatic weakref
+                Some(slots) => slots.iter().any(|s| s.as_str() == "__weakref__"),
+            }
+        } else {
+            let weakref_name = vm.ctx.intern_str("__weakref__");
+            obj.class().attributes.read().contains_key(weakref_name)
+        };
+        if has_weakref {
+            basicsize += core::mem::size_of::<PyObjectRef>();
+        }
+
+        // Add slots size
         if let Some(ref slot_names) = slot_names {
             basicsize += core::mem::size_of::<PyObjectRef>() * slot_names.__len__();
         }
+
+        // Fail if actual type's basicsize > expected basicsize
         if obj.class().slots.basicsize > basicsize {
-            return Err(
-                vm.new_type_error(format!("cannot pickle {:.200} object", obj.class().name()))
-            );
+            return Err(vm.new_type_error(format!("cannot pickle '{}' object", obj.class().name())));
         }
     }
 
@@ -249,7 +260,7 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
     Ok(state)
 }
 
-// object_getstate in CPython
+// object_getstate
 // fn object_getstate(
 //     obj: &PyObject,
 //     required: bool,
@@ -550,11 +561,181 @@ pub fn init(ctx: &Context) {
     PyBaseObject::extend_class(ctx, ctx.types.object_type);
 }
 
+/// Get arguments for __new__ from __getnewargs_ex__ or __getnewargs__
+/// Returns (args, kwargs) tuple where either can be None
+fn get_new_arguments(
+    obj: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<(Option<super::PyTupleRef>, Option<super::PyDictRef>)> {
+    // First try __getnewargs_ex__
+    if let Some(getnewargs_ex) = vm.get_special_method(obj, identifier!(vm, __getnewargs_ex__))? {
+        let newargs = getnewargs_ex.invoke((), vm)?;
+
+        let newargs_tuple: PyRef<super::PyTuple> = newargs.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "__getnewargs_ex__ should return a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        if newargs_tuple.len() != 2 {
+            return Err(vm.new_value_error(format!(
+                "__getnewargs_ex__ should return a tuple of length 2, not {}",
+                newargs_tuple.len()
+            )));
+        }
+
+        let args = newargs_tuple.as_slice()[0].clone();
+        let kwargs = newargs_tuple.as_slice()[1].clone();
+
+        let args_tuple: PyRef<super::PyTuple> = args.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "first item of the tuple returned by __getnewargs_ex__ must be a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        let kwargs_dict: PyRef<super::PyDict> = kwargs.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "second item of the tuple returned by __getnewargs_ex__ must be a dict, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        return Ok((Some(args_tuple), Some(kwargs_dict)));
+    }
+
+    // Fall back to __getnewargs__
+    if let Some(getnewargs) = vm.get_special_method(obj, identifier!(vm, __getnewargs__))? {
+        let args = getnewargs.invoke((), vm)?;
+
+        let args_tuple: PyRef<super::PyTuple> = args.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "__getnewargs__ should return a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        return Ok((Some(args_tuple), None));
+    }
+
+    // No __getnewargs_ex__ or __getnewargs__
+    Ok((None, None))
+}
+
+/// Check if __getstate__ is overridden by comparing with object.__getstate__
+fn is_getstate_overridden(obj: &PyObject, vm: &VirtualMachine) -> bool {
+    let obj_cls = obj.class();
+    let object_type = vm.ctx.types.object_type;
+
+    // If the class is object itself, not overridden
+    if obj_cls.is(object_type) {
+        return false;
+    }
+
+    // Check if __getstate__ in the MRO comes from object or elsewhere
+    // If the type has its own __getstate__, it's overridden
+    if let Some(getstate) = obj_cls.get_attr(identifier!(vm, __getstate__))
+        && let Some(obj_getstate) = object_type.get_attr(identifier!(vm, __getstate__))
+    {
+        return !getstate.is(&obj_getstate);
+    }
+    false
+}
+
+/// object_getstate - calls __getstate__ method or default implementation
+fn object_getstate(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
+    // If __getstate__ is not overridden, use the default implementation with required flag
+    if !is_getstate_overridden(obj, vm) {
+        return object_getstate_default(obj, required, vm);
+    }
+
+    // __getstate__ is overridden, call it without required
+    let getstate = obj.get_attr(identifier!(vm, __getstate__), vm)?;
+    getstate.call((), vm)
+}
+
+/// Get list items iterator if obj is a list (or subclass), None iterator otherwise
+fn get_items_iter(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, PyObjectRef)> {
+    let listitems: PyObjectRef = if obj.fast_isinstance(vm.ctx.types.list_type) {
+        obj.get_iter(vm)?.into()
+    } else {
+        vm.ctx.none()
+    };
+
+    let dictitems: PyObjectRef = if obj.fast_isinstance(vm.ctx.types.dict_type) {
+        let items = vm.call_method(obj, "items", ())?;
+        items.get_iter(vm)?.into()
+    } else {
+        vm.ctx.none()
+    };
+
+    Ok((listitems, dictitems))
+}
+
+/// reduce_newobj - creates reduce tuple for protocol >= 2
+fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Check if type has tp_new
+    let cls = obj.class();
+    if cls.slots.new.load().is_none() {
+        return Err(vm.new_type_error(format!("cannot pickle '{}' object", cls.name())));
+    }
+
+    let (args, kwargs) = get_new_arguments(&obj, vm)?;
+
+    let copyreg = vm.import("copyreg", 0)?;
+
+    let has_args = args.is_some();
+
+    let (newobj, newargs): (PyObjectRef, PyObjectRef) = if kwargs.is_none()
+        || kwargs.as_ref().is_some_and(|k| k.is_empty())
+    {
+        // Use copyreg.__newobj__
+        let newobj = copyreg.get_attr("__newobj__", vm)?;
+
+        let args_vec: Vec<PyObjectRef> = args.map(|a| a.as_slice().to_vec()).unwrap_or_default();
+
+        // Create (cls, *args) tuple
+        let mut newargs_vec: Vec<PyObjectRef> = vec![cls.to_owned().into()];
+        newargs_vec.extend(args_vec);
+        let newargs = vm.ctx.new_tuple(newargs_vec);
+
+        (newobj, newargs.into())
+    } else {
+        // Use copyreg.__newobj_ex__
+        let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
+        let args_tuple: PyObjectRef = args
+            .map(|a| a.into())
+            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into());
+        let kwargs_dict: PyObjectRef = kwargs
+            .map(|k| k.into())
+            .unwrap_or_else(|| vm.ctx.new_dict().into());
+
+        let newargs = vm
+            .ctx
+            .new_tuple(vec![cls.to_owned().into(), args_tuple, kwargs_dict]);
+        (newobj, newargs.into())
+    };
+
+    // Determine if state is required
+    // required = !(has_args || is_list || is_dict)
+    let is_list = obj.fast_isinstance(vm.ctx.types.list_type);
+    let is_dict = obj.fast_isinstance(vm.ctx.types.dict_type);
+    let required = !(has_args || is_list || is_dict);
+
+    let state = object_getstate(&obj, required, vm)?;
+
+    let (listitems, dictitems) = get_items_iter(&obj, vm)?;
+
+    let result = vm
+        .ctx
+        .new_tuple(vec![newobj, newargs, state, listitems, dictitems]);
+    Ok(result.into())
+}
+
 fn common_reduce(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
     if proto >= 2 {
-        let reducelib = vm.import("__reducelib", 0)?;
-        let reduce_2 = reducelib.get_attr("reduce_2", vm)?;
-        reduce_2.call((obj,), vm)
+        reduce_newobj(obj, vm)
     } else {
         let copyreg = vm.import("copyreg", 0)?;
         let reduce_ex = copyreg.get_attr("_reduce_ex", vm)?;
diff --git a/crates/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
index 54a38ef20e6..9cb0b7d7d2a 100644
--- a/crates/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -158,8 +158,8 @@ mod _io {
         AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
         TryFromBorrowedObject, TryFromObject,
         builtins::{
-            PyBaseExceptionRef, PyBool, PyByteArray, PyBytes, PyBytesRef, PyMemoryView, PyStr,
-            PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef,
+            PyBaseExceptionRef, PyBool, PyByteArray, PyBytes, PyBytesRef, PyDict, PyMemoryView,
+            PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef,
         },
         class::StaticType,
         common::lock::{
@@ -4077,6 +4077,71 @@ mod _io {
         const fn line_buffering(&self) -> bool {
             false
         }
+
+        #[pymethod]
+        fn __getstate__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            let buffer = zelf.buffer(vm)?;
+            let content = Wtf8Buf::from_bytes(buffer.getvalue())
+                .map_err(|_| vm.new_value_error("Error Retrieving Value"))?;
+            let pos = buffer.tell();
+            drop(buffer);
+
+            // Get __dict__ if it exists and is non-empty
+            let dict_obj: PyObjectRef = match zelf.as_object().dict() {
+                Some(d) if !d.is_empty() => d.into(),
+                _ => vm.ctx.none(),
+            };
+
+            // Return (content, newline, position, dict)
+            // TODO: store actual newline setting when it's implemented
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_str(content).into(),
+                vm.ctx.new_str("\n").into(),
+                vm.ctx.new_int(pos).into(),
+                dict_obj,
+            ]))
+        }
+
+        #[pymethod]
+        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+            // Check closed state first (like CHECK_CLOSED)
+            if zelf.closed.load() {
+                return Err(vm.new_value_error("__setstate__ on closed file"));
+            }
+            if state.len() != 4 {
+                return Err(vm.new_type_error(format!(
+                    "__setstate__ argument should be 4-tuple, got {}",
+                    state.len()
+                )));
+            }
+
+            let content: PyStrRef = state[0].clone().try_into_value(vm)?;
+            // state[1] is newline - TODO: use when newline handling is implemented
+            let pos: u64 = state[2].clone().try_into_value(vm)?;
+            let dict = &state[3];
+
+            // Set content and position
+            let raw_bytes = content.as_bytes().to_vec();
+            let mut buffer = zelf.buffer.write();
+            *buffer = BufferedIO::new(Cursor::new(raw_bytes));
+            buffer
+                .seek(SeekFrom::Start(pos))
+                .map_err(|err| os_err(vm, err))?;
+            drop(buffer);
+
+            // Set __dict__ if provided
+            if !vm.is_none(dict) {
+                let dict_ref: PyRef<PyDict> = dict.clone().try_into_value(vm)?;
+                if let Some(obj_dict) = zelf.as_object().dict() {
+                    obj_dict.clear();
+                    for (key, value) in dict_ref.into_iter() {
+                        obj_dict.set_item(&*key, value, vm)?;
+                    }
+                }
+            }
+
+            Ok(())
+        }
     }
 
     #[pyattr]
@@ -4225,6 +4290,65 @@ mod _io {
             self.closed.store(true);
             Ok(())
         }
+
+        #[pymethod]
+        fn __getstate__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            let buffer = zelf.buffer(vm)?;
+            let content = buffer.getvalue();
+            let pos = buffer.tell();
+            drop(buffer);
+
+            // Get __dict__ if it exists and is non-empty
+            let dict_obj: PyObjectRef = match zelf.as_object().dict() {
+                Some(d) if !d.is_empty() => d.into(),
+                _ => vm.ctx.none(),
+            };
+
+            // Return (content, position, dict)
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_bytes(content).into(),
+                vm.ctx.new_int(pos).into(),
+                dict_obj,
+            ]))
+        }
+
+        #[pymethod]
+        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+            if zelf.closed.load() {
+                return Err(vm.new_value_error("__setstate__ on closed file"));
+            }
+            if state.len() != 3 {
+                return Err(vm.new_type_error(format!(
+                    "__setstate__ argument should be 3-tuple, got {}",
+                    state.len()
+                )));
+            }
+
+            let content: PyBytesRef = state[0].clone().try_into_value(vm)?;
+            let pos: u64 = state[1].clone().try_into_value(vm)?;
+            let dict = &state[2];
+
+            // Check exports and set content (like CHECK_EXPORTS)
+            let mut buffer = zelf.try_resizable(vm)?;
+            *buffer = BufferedIO::new(Cursor::new(content.as_bytes().to_vec()));
+            buffer
+                .seek(SeekFrom::Start(pos))
+                .map_err(|err| os_err(vm, err))?;
+            drop(buffer);
+
+            // Set __dict__ if provided
+            if !vm.is_none(dict) {
+                let dict_ref: PyRef<PyDict> = dict.clone().try_into_value(vm)?;
+                if let Some(obj_dict) = zelf.as_object().dict() {
+                    obj_dict.clear();
+                    for (key, value) in dict_ref.into_iter() {
+                        obj_dict.set_item(&*key, value, vm)?;
+                    }
+                }
+            }
+
+            Ok(())
+        }
     }
 
     #[pyclass]
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index d51d78015d6..db588e5eab7 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -516,7 +516,7 @@ pub(crate) mod _thread {
                 let mut handles = vm.state.shutdown_handles.lock();
                 // Clean up finished entries
                 handles.retain(|(inner_weak, _): &ShutdownEntry| {
-                    inner_weak.upgrade().map_or(false, |inner| {
+                    inner_weak.upgrade().is_some_and(|inner| {
                         let guard = inner.lock();
                         guard.state != ThreadHandleState::Done && guard.ident != current_ident
                     })
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index b12352f6eee..65c742e4915 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -135,6 +135,7 @@ declare_const_name! {
     __getformat__,
     __getitem__,
     __getnewargs__,
+    __getnewargs_ex__,
     __getstate__,
     __gt__,
     __hash__,

From f4363a6b27af0d7a14c8a52b9389a193b4986329 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 18:41:40 +0900
Subject: [PATCH 308/418] PEP 750 tstring (#6744)

---
 Lib/_opcode_metadata.py                       |   2 +
 crates/codegen/src/compile.rs                 | 120 ++++++-
 crates/codegen/src/symboltable.rs             |  21 +-
 .../compiler-core/src/bytecode/instruction.rs |  29 +-
 crates/vm/src/builtins/interpolation.rs       | 219 ++++++++++++
 crates/vm/src/builtins/mod.rs                 |   4 +
 crates/vm/src/builtins/template.rs            | 338 ++++++++++++++++++
 crates/vm/src/frame.rs                        |  53 ++-
 crates/vm/src/stdlib/ast/expression.rs        |   2 +-
 crates/vm/src/stdlib/ast/pyast.rs             |  16 +
 crates/vm/src/stdlib/ast/string.rs            | 331 ++++++++++++++---
 crates/vm/src/types/zoo.rs                    |  14 +-
 crates/vm/src/vm/vm_ops.rs                    |  13 +-
 13 files changed, 1086 insertions(+), 76 deletions(-)
 create mode 100644 crates/vm/src/builtins/interpolation.rs
 create mode 100644 crates/vm/src/builtins/template.rs

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index abb748519c3..34e73bf31b4 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -132,6 +132,8 @@
     'BUILD_SET_FROM_TUPLES': 122,
     'BUILD_TUPLE_FROM_ITER': 123,
     'BUILD_TUPLE_FROM_TUPLES': 124,
+    'BUILD_TEMPLATE': 125,
+    'BUILD_INTERPOLATION': 126,
     'CONTINUE': 128,
     'JUMP_IF_FALSE_OR_POP': 129,
     'JUMP_IF_TRUE_OR_POP': 130,
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 0480f94b678..7782e6ec485 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -24,13 +24,13 @@ use num_traits::{Num, ToPrimitive};
 use ruff_python_ast::{
     Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem,
     ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprContext,
-    ExprFString, ExprList, ExprName, ExprSlice, ExprStarred, ExprSubscript, ExprTuple, ExprUnaryOp,
-    FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedStringElement,
+    ExprFString, ExprList, ExprName, ExprSlice, ExprStarred, ExprSubscript, ExprTString, ExprTuple,
+    ExprUnaryOp, FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedStringElement,
     InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
     Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
     PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
-    Stmt, StmtExpr, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple,
-    TypeParams, UnaryOp, WithItem,
+    Stmt, StmtExpr, TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
+    TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
     visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange};
@@ -6282,8 +6282,8 @@ impl Compiler {
             Expr::FString(fstring) => {
                 self.compile_expr_fstring(fstring)?;
             }
-            Expr::TString(_) => {
-                return Err(self.error(CodegenErrorType::NotImplementedYet));
+            Expr::TString(tstring) => {
+                self.compile_expr_tstring(tstring)?;
             }
             Expr::StringLiteral(string) => {
                 let value = string.value.to_str();
@@ -7466,6 +7466,114 @@ impl Compiler {
 
         Ok(())
     }
+
+    fn compile_expr_tstring(&mut self, expr_tstring: &ExprTString) -> CompileResult<()> {
+        // TStringValue can contain multiple TString parts (implicit concatenation)
+        // Each TString part should be compiled and the results merged into a single Template
+        let tstring_value = &expr_tstring.value;
+
+        // Collect all strings and compile all interpolations
+        let mut all_strings: Vec<Wtf8Buf> = Vec::new();
+        let mut current_string = Wtf8Buf::new();
+        let mut interp_count: u32 = 0;
+
+        for tstring in tstring_value.iter() {
+            self.compile_tstring_into(
+                tstring,
+                &mut all_strings,
+                &mut current_string,
+                &mut interp_count,
+            )?;
+        }
+
+        // Add trailing string
+        all_strings.push(std::mem::take(&mut current_string));
+
+        // Now build the Template:
+        // Stack currently has all interpolations from compile_tstring_into calls
+
+        // 1. Build interpolations tuple from the interpolations on the stack
+        emit!(self, Instruction::BuildTuple { size: interp_count });
+
+        // 2. Load all string parts
+        let string_count: u32 = all_strings
+            .len()
+            .try_into()
+            .expect("t-string string count overflowed");
+        for s in &all_strings {
+            self.emit_load_const(ConstantData::Str { value: s.clone() });
+        }
+
+        // 3. Build strings tuple
+        emit!(self, Instruction::BuildTuple { size: string_count });
+
+        // 4. Swap so strings is below interpolations: [interps, strings] -> [strings, interps]
+        emit!(self, Instruction::Swap { index: 2 });
+
+        // 5. Build the Template
+        emit!(self, Instruction::BuildTemplate);
+
+        Ok(())
+    }
+
+    fn compile_tstring_into(
+        &mut self,
+        tstring: &TString,
+        strings: &mut Vec<Wtf8Buf>,
+        current_string: &mut Wtf8Buf,
+        interp_count: &mut u32,
+    ) -> CompileResult<()> {
+        for element in &tstring.elements {
+            match element {
+                InterpolatedStringElement::Literal(lit) => {
+                    // Accumulate literal parts into current_string
+                    current_string.push_str(&lit.value);
+                }
+                InterpolatedStringElement::Interpolation(interp) => {
+                    // Finish current string segment
+                    strings.push(std::mem::take(current_string));
+
+                    // Compile the interpolation value
+                    self.compile_expression(&interp.expression)?;
+
+                    // Load the expression source string
+                    let expr_range = interp.expression.range();
+                    let expr_source = self.source_file.slice(expr_range);
+                    self.emit_load_const(ConstantData::Str {
+                        value: expr_source.to_string().into(),
+                    });
+
+                    // Determine conversion code
+                    let conversion: u32 = match interp.conversion {
+                        ConversionFlag::None => 0,
+                        ConversionFlag::Str => 1,
+                        ConversionFlag::Repr => 2,
+                        ConversionFlag::Ascii => 3,
+                    };
+
+                    // Handle format_spec
+                    let has_format_spec = interp.format_spec.is_some();
+                    if let Some(format_spec) = &interp.format_spec {
+                        // Compile format_spec as a string using fstring element compilation
+                        // Use default FStringFlags since format_spec syntax is independent of t-string flags
+                        self.compile_fstring_elements(
+                            FStringFlags::empty(),
+                            &format_spec.elements,
+                        )?;
+                    }
+
+                    // Emit BUILD_INTERPOLATION
+                    // oparg encoding: (conversion << 2) | has_format_spec
+                    let oparg = (conversion << 2) | (has_format_spec as u32);
+                    emit!(self, Instruction::BuildInterpolation { oparg });
+
+                    *interp_count += 1;
+                }
+            }
+        }
+
+        Ok(())
+    }
 }
 
 trait EmitArg<Arg: OpArgType> {
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 22b5bf358a1..e8eb3c7fee3 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -1441,14 +1441,19 @@ impl SymbolTableBuilder {
                 }
             }
             Expr::TString(tstring) => {
-                return Err(SymbolTableError {
-                    error: "not yet implemented".into(),
-                    location: Some(
-                        self.source_file
-                            .to_source_code()
-                            .source_location(tstring.range.start(), PositionEncoding::Utf8),
-                    ),
-                });
+                // Scan t-string interpolation expressions (similar to f-strings)
+                for expr in tstring
+                    .value
+                    .elements()
+                    .filter_map(|x| x.as_interpolation())
+                {
+                    self.scan_expression(&expr.expression, ExpressionContext::Load)?;
+                    if let Some(format_spec) = &expr.format_spec {
+                        for element in format_spec.elements.interpolations() {
+                            self.scan_expression(&element.expression, ExpressionContext::Load)?
+                        }
+                    }
+                }
             }
             // Constants
             Expr::StringLiteral(_)
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 44a57c44320..2cca03127cf 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -264,6 +264,19 @@ pub enum Instruction {
     BuildTupleFromTuples {
         size: Arg<u32>,
     } = 124,
+    /// Build a Template from strings tuple and interpolations tuple on stack.
+    /// Stack: [strings_tuple, interpolations_tuple] -> [template]
+    BuildTemplate = 125,
+    /// Build an Interpolation from value, expression string, and optional format_spec on stack.
+    ///
+    /// oparg encoding: (conversion << 2) | has_format_spec
+    /// - has_format_spec (bit 0): if 1, format_spec is on stack
+    /// - conversion (bits 2+): 0=None, 1=Str, 2=Repr, 3=Ascii
+    ///
+    /// Stack: [value, expression_str, format_spec?] -> [interpolation]
+    BuildInterpolation {
+        oparg: Arg<u32>,
+    } = 126,
     Continue {
         target: Arg<Label>,
     } = 128,
@@ -425,7 +438,11 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::BuildTupleFromTuples {
                 size: Arg::marker(),
             }),
-            // 125, 126, 127 are unused
+            u8::from(Self::BuildTemplate),
+            u8::from(Self::BuildInterpolation {
+                oparg: Arg::marker(),
+            }),
+            // 127 is unused
             u8::from(Self::Continue {
                 target: Arg::marker(),
             }),
@@ -782,6 +799,14 @@ impl InstructionMetadata for Instruction {
             Self::InstrumentedPopJumpIfNone => 0,
             Self::InstrumentedPopJumpIfNotNone => 0,
             Self::InstrumentedLine => 0,
+            // BuildTemplate: pops [strings_tuple, interpolations_tuple], pushes [template]
+            Self::BuildTemplate => -1,
+            // BuildInterpolation: pops [value, expr_str, format_spec?], pushes [interpolation]
+            // has_format_spec is bit 0 of oparg
+            Self::BuildInterpolation { oparg } => {
+                let has_format_spec = oparg.get(arg) & 1 != 0;
+                if has_format_spec { -2 } else { -1 }
+            }
         }
     }
 
@@ -976,6 +1001,8 @@ impl InstructionMetadata for Instruction {
             Self::UnaryNot => w!(UNARY_NOT),
             Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            Self::BuildTemplate => w!(BUILD_TEMPLATE),
+            Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
diff --git a/crates/vm/src/builtins/interpolation.rs b/crates/vm/src/builtins/interpolation.rs
new file mode 100644
index 00000000000..1d29ad7b49e
--- /dev/null
+++ b/crates/vm/src/builtins/interpolation.rs
@@ -0,0 +1,219 @@
+use super::{PyStr, PyStrRef, PyTupleRef, PyType, tuple::IntoPyTuple};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    common::hash::PyHash,
+    convert::ToPyObject,
+    function::{OptionalArg, PyComparisonValue},
+    types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+};
+
+/// Interpolation object for t-strings (PEP 750).
+///
+/// Represents an interpolated expression within a template string.
+#[pyclass(module = "string.templatelib", name = "Interpolation")]
+#[derive(Debug, Clone)]
+pub struct PyInterpolation {
+    pub value: PyObjectRef,
+    pub expression: PyStrRef,
+    pub conversion: PyObjectRef, // None or 's', 'r', 'a'
+    pub format_spec: PyStrRef,
+}
+
+impl PyPayload for PyInterpolation {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.interpolation_type
+    }
+}
+
+impl PyInterpolation {
+    pub fn new(
+        value: PyObjectRef,
+        expression: PyStrRef,
+        conversion: PyObjectRef,
+        format_spec: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        // Validate conversion like _PyInterpolation_Build does
+        let is_valid = vm.is_none(&conversion)
+            || conversion
+                .downcast_ref::<PyStr>()
+                .is_some_and(|s| matches!(s.as_str(), "s" | "r" | "a"));
+        if !is_valid {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.system_error.to_owned(),
+                "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'".to_owned(),
+            ));
+        }
+        Ok(Self {
+            value,
+            expression,
+            conversion,
+            format_spec,
+        })
+    }
+}
+
+impl Constructor for PyInterpolation {
+    type Args = InterpolationArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        let conversion = match args.conversion {
+            OptionalArg::Present(c) => {
+                if vm.is_none(&c) {
+                    vm.ctx.none()
+                } else {
+                    let s = c.downcast::<PyStr>().map_err(|_| {
+                        vm.new_type_error(
+                            "Interpolation() argument 'conversion' must be str or None",
+                        )
+                    })?;
+                    let s_str = s.as_str();
+                    if s_str.len() != 1 || !matches!(s_str.chars().next(), Some('s' | 'r' | 'a')) {
+                        return Err(vm.new_value_error(
+                            "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'",
+                        ));
+                    }
+                    s.into()
+                }
+            }
+            OptionalArg::Missing => vm.ctx.none(),
+        };
+
+        let expression = args
+            .expression
+            .unwrap_or_else(|| vm.ctx.empty_str.to_owned());
+        let format_spec = args
+            .format_spec
+            .unwrap_or_else(|| vm.ctx.empty_str.to_owned());
+
+        Ok(PyInterpolation {
+            value: args.value,
+            expression,
+            conversion,
+            format_spec,
+        })
+    }
+}
+
+#[derive(FromArgs)]
+pub struct InterpolationArgs {
+    #[pyarg(positional)]
+    value: PyObjectRef,
+    #[pyarg(any, optional)]
+    expression: OptionalArg<PyStrRef>,
+    #[pyarg(any, optional)]
+    conversion: OptionalArg<PyObjectRef>,
+    #[pyarg(any, optional)]
+    format_spec: OptionalArg<PyStrRef>,
+}
+
+#[pyclass(with(Constructor, Comparable, Hashable, Representable))]
+impl PyInterpolation {
+    #[pyattr]
+    fn __match_args__(ctx: &Context) -> PyTupleRef {
+        ctx.new_tuple(vec![
+            ctx.intern_str("value").to_owned().into(),
+            ctx.intern_str("expression").to_owned().into(),
+            ctx.intern_str("conversion").to_owned().into(),
+            ctx.intern_str("format_spec").to_owned().into(),
+        ])
+    }
+
+    #[pygetset]
+    fn value(&self) -> PyObjectRef {
+        self.value.clone()
+    }
+
+    #[pygetset]
+    fn expression(&self) -> PyStrRef {
+        self.expression.clone()
+    }
+
+    #[pygetset]
+    fn conversion(&self) -> PyObjectRef {
+        self.conversion.clone()
+    }
+
+    #[pygetset]
+    fn format_spec(&self) -> PyStrRef {
+        self.format_spec.clone()
+    }
+
+    #[pymethod]
+    fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
+        let cls = zelf.class().to_owned();
+        let args = (
+            zelf.value.clone(),
+            zelf.expression.clone(),
+            zelf.conversion.clone(),
+            zelf.format_spec.clone(),
+        );
+        (cls, args.to_pyobject(vm)).into_pytuple(vm)
+    }
+}
+
+impl Comparable for PyInterpolation {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+
+            let eq = vm.bool_eq(&zelf.value, &other.value)?
+                && vm.bool_eq(zelf.expression.as_object(), other.expression.as_object())?
+                && vm.bool_eq(&zelf.conversion, &other.conversion)?
+                && vm.bool_eq(zelf.format_spec.as_object(), other.format_spec.as_object())?;
+
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Hashable for PyInterpolation {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        // Hash based on (value, expression, conversion, format_spec)
+        let value_hash = zelf.value.hash(vm)?;
+        let expr_hash = zelf.expression.as_object().hash(vm)?;
+        let conv_hash = zelf.conversion.hash(vm)?;
+        let spec_hash = zelf.format_spec.as_object().hash(vm)?;
+
+        // Combine hashes
+        Ok(value_hash
+            .wrapping_add(expr_hash.wrapping_mul(3))
+            .wrapping_add(conv_hash.wrapping_mul(5))
+            .wrapping_add(spec_hash.wrapping_mul(7)))
+    }
+}
+
+impl Representable for PyInterpolation {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let value_repr = zelf.value.repr(vm)?;
+        let expr_repr = zelf.expression.repr(vm)?;
+
+        let conv_str = if vm.is_none(&zelf.conversion) {
+            "None".to_owned()
+        } else {
+            zelf.conversion.repr(vm)?.as_str().to_owned()
+        };
+
+        let spec_repr = zelf.format_spec.repr(vm)?;
+
+        Ok(format!(
+            "Interpolation({}, {}, {}, {})",
+            value_repr.as_str(),
+            expr_repr.as_str(),
+            conv_str,
+            spec_repr.as_str()
+        ))
+    }
+}
+
+pub fn init(context: &Context) {
+    PyInterpolation::extend_class(context, context.types.interpolation_type);
+}
diff --git a/crates/vm/src/builtins/mod.rs b/crates/vm/src/builtins/mod.rs
index 6f379a4babf..c40f09bdef0 100644
--- a/crates/vm/src/builtins/mod.rs
+++ b/crates/vm/src/builtins/mod.rs
@@ -36,6 +36,8 @@ pub(crate) mod getset;
 pub use getset::PyGetSet;
 pub(crate) mod int;
 pub use int::{PyInt, PyIntRef};
+pub(crate) mod interpolation;
+pub use interpolation::PyInterpolation;
 pub(crate) mod iter;
 pub use iter::*;
 pub(crate) mod list;
@@ -76,6 +78,8 @@ pub(crate) mod slice;
 pub use slice::{PyEllipsis, PySlice};
 pub(crate) mod staticmethod;
 pub use staticmethod::PyStaticMethod;
+pub(crate) mod template;
+pub use template::{PyTemplate, PyTemplateIter};
 pub(crate) mod traceback;
 pub use traceback::PyTraceback;
 pub(crate) mod tuple;
diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs
new file mode 100644
index 00000000000..2433c9082e5
--- /dev/null
+++ b/crates/vm/src/builtins/template.rs
@@ -0,0 +1,338 @@
+use super::{PyStr, PyTupleRef, PyType};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    atomic_func,
+    class::PyClassImpl,
+    function::{FuncArgs, PyComparisonValue},
+    protocol::{PyIterReturn, PySequenceMethods},
+    types::{
+        AsSequence, Comparable, Constructor, IterNext, Iterable, PyComparisonOp, Representable,
+        SelfIter,
+    },
+};
+use std::sync::LazyLock;
+
+use super::interpolation::PyInterpolation;
+
+/// Template object for t-strings (PEP 750).
+///
+/// Represents a template string with interpolated expressions.
+#[pyclass(module = "string.templatelib", name = "Template")]
+#[derive(Debug, Clone)]
+pub struct PyTemplate {
+    pub strings: PyTupleRef,
+    pub interpolations: PyTupleRef,
+}
+
+impl PyPayload for PyTemplate {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.template_type
+    }
+}
+
+impl PyTemplate {
+    pub fn new(strings: PyTupleRef, interpolations: PyTupleRef) -> Self {
+        Self {
+            strings,
+            interpolations,
+        }
+    }
+}
+
+impl Constructor for PyTemplate {
+    type Args = FuncArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        if !args.kwargs.is_empty() {
+            return Err(vm.new_type_error("Template.__new__ only accepts *args arguments"));
+        }
+
+        let mut strings: Vec<PyObjectRef> = Vec::new();
+        let mut interpolations: Vec<PyObjectRef> = Vec::new();
+        let mut last_was_str = false;
+
+        for item in args.args.iter() {
+            if let Ok(s) = item.clone().downcast::<PyStr>() {
+                if last_was_str {
+                    // Concatenate adjacent strings
+                    if let Some(last) = strings.last_mut() {
+                        let last_str = last.downcast_ref::<PyStr>().unwrap();
+                        let concatenated = format!("{}{}", last_str.as_str(), s.as_str());
+                        *last = vm.ctx.new_str(concatenated).into();
+                    }
+                } else {
+                    strings.push(s.into());
+                }
+                last_was_str = true;
+            } else if item.class().is(vm.ctx.types.interpolation_type) {
+                if !last_was_str {
+                    // Add empty string before interpolation
+                    strings.push(vm.ctx.empty_str.to_owned().into());
+                }
+                interpolations.push(item.clone());
+                last_was_str = false;
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "Template.__new__ *args need to be of type 'str' or 'Interpolation', got {}",
+                    item.class().name()
+                )));
+            }
+        }
+
+        if !last_was_str {
+            // Add trailing empty string
+            strings.push(vm.ctx.empty_str.to_owned().into());
+        }
+
+        Ok(PyTemplate {
+            strings: vm.ctx.new_tuple(strings),
+            interpolations: vm.ctx.new_tuple(interpolations),
+        })
+    }
+}
+
+#[pyclass(with(Constructor, Comparable, Iterable, Representable, AsSequence))]
+impl PyTemplate {
+    #[pygetset]
+    fn strings(&self) -> PyTupleRef {
+        self.strings.clone()
+    }
+
+    #[pygetset]
+    fn interpolations(&self) -> PyTupleRef {
+        self.interpolations.clone()
+    }
+
+    #[pygetset]
+    fn values(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let values: Vec<PyObjectRef> = self
+            .interpolations
+            .iter()
+            .map(|interp| {
+                interp
+                    .downcast_ref::<PyInterpolation>()
+                    .map(|i| i.value.clone())
+                    .unwrap_or_else(|| interp.clone())
+            })
+            .collect();
+        vm.ctx.new_tuple(values)
+    }
+
+    fn concat(&self, other: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        let other = other.downcast_ref::<PyTemplate>().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "can only concatenate Template (not '{}') to Template",
+                other.class().name()
+            ))
+        })?;
+
+        // Concatenate the two templates
+        let mut new_strings: Vec<PyObjectRef> = Vec::new();
+        let mut new_interps: Vec<PyObjectRef> = Vec::new();
+
+        // Add all strings from self except the last one
+        let self_strings_len = self.strings.len();
+        for i in 0..self_strings_len.saturating_sub(1) {
+            new_strings.push(self.strings.get(i).unwrap().clone());
+        }
+
+        // Add all interpolations from self
+        for interp in self.interpolations.iter() {
+            new_interps.push(interp.clone());
+        }
+
+        // Concatenate last string of self with first string of other
+        let last_self = self
+            .strings
+            .get(self_strings_len.saturating_sub(1))
+            .and_then(|s| s.downcast_ref::<PyStr>().map(|s| s.as_str().to_owned()))
+            .unwrap_or_default();
+        let first_other = other
+            .strings
+            .first()
+            .and_then(|s| s.downcast_ref::<PyStr>().map(|s| s.as_str().to_owned()))
+            .unwrap_or_default();
+        let concatenated = format!("{}{}", last_self, first_other);
+        new_strings.push(vm.ctx.new_str(concatenated).into());
+
+        // Add remaining strings from other (skip first)
+        for i in 1..other.strings.len() {
+            new_strings.push(other.strings.get(i).unwrap().clone());
+        }
+
+        // Add all interpolations from other
+        for interp in other.interpolations.iter() {
+            new_interps.push(interp.clone());
+        }
+
+        let template = PyTemplate {
+            strings: vm.ctx.new_tuple(new_strings),
+            interpolations: vm.ctx.new_tuple(new_interps),
+        };
+
+        Ok(template.into_ref(&vm.ctx))
+    }
+
+    fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        self.concat(&other, vm)
+    }
+
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        // Import string.templatelib._template_unpickle
+        // We need to import string first, then get templatelib from it,
+        // because import("string.templatelib", 0) with empty from_list returns the top-level module
+        let string_mod = vm.import("string.templatelib", 0)?;
+        let templatelib = string_mod.get_attr("templatelib", vm)?;
+        let unpickle_func = templatelib.get_attr("_template_unpickle", vm)?;
+
+        // Return (func, (strings, interpolations))
+        let args = vm.ctx.new_tuple(vec![
+            self.strings.clone().into(),
+            self.interpolations.clone().into(),
+        ]);
+        Ok(vm.ctx.new_tuple(vec![unpickle_func, args.into()]))
+    }
+}
+
+impl AsSequence for PyTemplate {
+    fn as_sequence() -> &'static PySequenceMethods {
+        static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            concat: atomic_func!(|seq, other, vm| {
+                let zelf = PyTemplate::sequence_downcast(seq);
+                zelf.concat(other, vm).map(|t| t.into())
+            }),
+            ..PySequenceMethods::NOT_IMPLEMENTED
+        });
+        &AS_SEQUENCE
+    }
+}
+
+impl Comparable for PyTemplate {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+
+            let eq = vm.bool_eq(zelf.strings.as_object(), other.strings.as_object())?
+                && vm.bool_eq(
+                    zelf.interpolations.as_object(),
+                    other.interpolations.as_object(),
+                )?;
+
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Iterable for PyTemplate {
+    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+        Ok(PyTemplateIter::new(zelf).into_pyobject(vm))
+    }
+}
+
+impl Representable for PyTemplate {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let mut parts = Vec::new();
+
+        let strings_len = zelf.strings.len();
+        let interps_len = zelf.interpolations.len();
+
+        for i in 0..strings_len.max(interps_len * 2 + 1) {
+            if i % 2 == 0 {
+                // String position
+                let idx = i / 2;
+                if idx < strings_len {
+                    let s = zelf.strings.get(idx).unwrap();
+                    parts.push(s.repr(vm)?.as_str().to_owned());
+                }
+            } else {
+                // Interpolation position
+                let idx = i / 2;
+                if idx < interps_len {
+                    let interp = zelf.interpolations.get(idx).unwrap();
+                    parts.push(interp.repr(vm)?.as_str().to_owned());
+                }
+            }
+        }
+
+        Ok(format!("Template({})", parts.join(", ")))
+    }
+}
+
+/// Iterator for Template objects
+#[pyclass(module = "string.templatelib", name = "TemplateIter")]
+#[derive(Debug)]
+pub struct PyTemplateIter {
+    template: PyRef<PyTemplate>,
+    index: std::sync::atomic::AtomicUsize,
+    from_strings: std::sync::atomic::AtomicBool,
+}
+
+impl PyPayload for PyTemplateIter {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.template_iter_type
+    }
+}
+
+impl PyTemplateIter {
+    fn new(template: PyRef<PyTemplate>) -> Self {
+        Self {
+            template,
+            index: std::sync::atomic::AtomicUsize::new(0),
+            from_strings: std::sync::atomic::AtomicBool::new(true),
+        }
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyTemplateIter {}
+
+impl SelfIter for PyTemplateIter {}
+
+impl IterNext for PyTemplateIter {
+    fn next(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        use std::sync::atomic::Ordering;
+
+        loop {
+            let from_strings = zelf.from_strings.load(Ordering::SeqCst);
+            let index = zelf.index.load(Ordering::SeqCst);
+
+            if from_strings {
+                if index < zelf.template.strings.len() {
+                    let item = zelf.template.strings.get(index).unwrap();
+                    zelf.from_strings.store(false, Ordering::SeqCst);
+
+                    // Skip empty strings
+                    if let Some(s) = item.downcast_ref::<PyStr>()
+                        && s.as_str().is_empty()
+                    {
+                        continue;
+                    }
+                    return Ok(PyIterReturn::Return(item.clone()));
+                } else {
+                    return Ok(PyIterReturn::StopIteration(None));
+                }
+            } else if index < zelf.template.interpolations.len() {
+                let item = zelf.template.interpolations.get(index).unwrap();
+                zelf.index.fetch_add(1, Ordering::SeqCst);
+                zelf.from_strings.store(true, Ordering::SeqCst);
+                return Ok(PyIterReturn::Return(item.clone()));
+            } else {
+                return Ok(PyIterReturn::StopIteration(None));
+            }
+        }
+    }
+}
+
+pub fn init(context: &Context) {
+    PyTemplate::extend_class(context, context.types.template_type);
+    PyTemplateIter::extend_class(context, context.types.template_iter_type);
+}
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index bd4d01de9f5..3e356466e5c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -2,7 +2,8 @@ use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{
         PyBaseException, PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator,
-        PyList, PySet, PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyType,
+        PyInterpolation, PyList, PySet, PySlice, PyStr, PyStrInterned, PyStrRef, PyTemplate,
+        PyTraceback, PyType,
         asyncgenerator::PyAsyncGenWrappedValue,
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
@@ -702,6 +703,56 @@ impl ExecutingFrame<'_> {
                 self.push_value(list_obj.into());
                 Ok(None)
             }
+            Instruction::BuildTemplate => {
+                // Stack: [strings_tuple, interpolations_tuple] -> [template]
+                let interpolations = self.pop_value();
+                let strings = self.pop_value();
+
+                let strings = strings
+                    .downcast::<PyTuple>()
+                    .map_err(|_| vm.new_type_error("BUILD_TEMPLATE expected tuple for strings"))?;
+                let interpolations = interpolations.downcast::<PyTuple>().map_err(|_| {
+                    vm.new_type_error("BUILD_TEMPLATE expected tuple for interpolations")
+                })?;
+
+                let template = PyTemplate::new(strings, interpolations);
+                self.push_value(template.into_pyobject(vm));
+                Ok(None)
+            }
+            Instruction::BuildInterpolation { oparg } => {
+                // oparg encoding: (conversion << 2) | has_format_spec
+                // Stack: [value, expression_str, (format_spec)?] -> [interpolation]
+                let oparg_val = oparg.get(arg);
+                let has_format_spec = (oparg_val & 1) != 0;
+                let conversion_code = oparg_val >> 2;
+
+                let format_spec = if has_format_spec {
+                    self.pop_value().downcast::<PyStr>().map_err(|_| {
+                        vm.new_type_error("BUILD_INTERPOLATION expected str for format_spec")
+                    })?
+                } else {
+                    vm.ctx.empty_str.to_owned()
+                };
+
+                let expression = self.pop_value().downcast::<PyStr>().map_err(|_| {
+                    vm.new_type_error("BUILD_INTERPOLATION expected str for expression")
+                })?;
+                let value = self.pop_value();
+
+                // conversion: 0=None, 1=Str, 2=Repr, 3=Ascii
+                let conversion: PyObjectRef = match conversion_code {
+                    0 => vm.ctx.none(),
+                    1 => vm.ctx.new_str("s").into(),
+                    2 => vm.ctx.new_str("r").into(),
+                    3 => vm.ctx.new_str("a").into(),
+                    _ => vm.ctx.none(), // should not happen
+                };
+
+                let interpolation =
+                    PyInterpolation::new(value, expression, conversion, format_spec, vm)?;
+                self.push_value(interpolation.into_pyobject(vm));
+                Ok(None)
+            }
             Instruction::Call { nargs } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
                 let args = self.collect_positional_args(nargs.get(arg));
diff --git a/crates/vm/src/stdlib/ast/expression.rs b/crates/vm/src/stdlib/ast/expression.rs
index 83d77374380..c63d0e0df68 100644
--- a/crates/vm/src/stdlib/ast/expression.rs
+++ b/crates/vm/src/stdlib/ast/expression.rs
@@ -36,7 +36,7 @@ impl Node for ruff::Expr {
             Self::NumberLiteral(cons) => constant::number_literal_to_object(vm, source_file, cons),
             Self::StringLiteral(cons) => constant::string_literal_to_object(vm, source_file, cons),
             Self::FString(cons) => string::fstring_to_object(vm, source_file, cons),
-            Self::TString(_) => unimplemented!(),
+            Self::TString(cons) => string::tstring_to_object(vm, source_file, cons),
             Self::BytesLiteral(cons) => constant::bytes_literal_to_object(vm, source_file, cons),
             Self::BooleanLiteral(cons) => {
                 constant::boolean_literal_to_object(vm, source_file, cons)
diff --git a/crates/vm/src/stdlib/ast/pyast.rs b/crates/vm/src/stdlib/ast/pyast.rs
index e36635fe4b9..f5e9d9f6d93 100644
--- a/crates/vm/src/stdlib/ast/pyast.rs
+++ b/crates/vm/src/stdlib/ast/pyast.rs
@@ -448,6 +448,20 @@ impl_node!(
     attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
 );
 
+impl_node!(
+    #[pyclass(module = "_ast", name = "TemplateStr", base = NodeExpr)]
+    pub(crate) struct NodeExprTemplateStr,
+    fields: ["values"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Interpolation", base = NodeExpr)]
+    pub(crate) struct NodeExprInterpolation,
+    fields: ["value", "str", "conversion", "format_spec"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
 impl_node!(
     #[pyclass(module = "_ast", name = "Constant", base = NodeExpr)]
     pub(crate) struct NodeExprConstant,
@@ -918,6 +932,8 @@ pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
         "Call" => NodeExprCall::make_class(&vm.ctx),
         "FormattedValue" => NodeExprFormattedValue::make_class(&vm.ctx),
         "JoinedStr" => NodeExprJoinedStr::make_class(&vm.ctx),
+        "TemplateStr" => NodeExprTemplateStr::make_class(&vm.ctx),
+        "Interpolation" => NodeExprInterpolation::make_class(&vm.ctx),
         "Constant" => NodeExprConstant::make_class(&vm.ctx),
         "Attribute" => NodeExprAttribute::make_class(&vm.ctx),
         "Subscript" => NodeExprSubscript::make_class(&vm.ctx),
diff --git a/crates/vm/src/stdlib/ast/string.rs b/crates/vm/src/stdlib/ast/string.rs
index ffa5a3a958a..c68e378bc74 100644
--- a/crates/vm/src/stdlib/ast/string.rs
+++ b/crates/vm/src/stdlib/ast/string.rs
@@ -1,60 +1,20 @@
 use super::constant::{Constant, ConstantLiteral};
 use super::*;
 
-fn ruff_fstring_value_into_iter(
-    mut fstring_value: ruff::FStringValue,
-) -> impl Iterator<Item = ruff::FStringPart> + 'static {
-    let default = ruff::FStringPart::FString(ruff::FString {
-        node_index: Default::default(),
-        range: Default::default(),
-        elements: Default::default(),
-        flags: ruff::FStringFlags::empty(),
-    });
-    (0..fstring_value.as_slice().len()).map(move |i| {
-        let tmp = fstring_value.iter_mut().nth(i).unwrap();
-        core::mem::replace(tmp, default.clone())
-    })
-}
-
 fn ruff_fstring_element_into_iter(
     mut fstring_element: ruff::InterpolatedStringElements,
-) -> impl Iterator<Item = ruff::InterpolatedStringElement> + 'static {
+) -> impl Iterator<Item = ruff::InterpolatedStringElement> {
     let default =
         ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
             node_index: Default::default(),
             range: Default::default(),
             value: Default::default(),
         });
-    (0..fstring_element.into_iter().len()).map(move |i| {
-        let fstring_element = &mut fstring_element;
-        let tmp = fstring_element.into_iter().nth(i).unwrap();
-        core::mem::replace(tmp, default.clone())
-    })
-}
-
-fn fstring_part_to_joined_str_part(fstring_part: ruff::FStringPart) -> Vec<JoinedStrPart> {
-    match fstring_part {
-        ruff::FStringPart::Literal(ruff::StringLiteral {
-            range,
-            value,
-            flags,
-            node_index: _,
-        }) => {
-            vec![JoinedStrPart::Constant(Constant::new_str(
-                value,
-                flags.prefix(),
-                range,
-            ))]
-        }
-        ruff::FStringPart::FString(ruff::FString {
-            range: _,
-            elements,
-            flags: _, // TODO
-            node_index: _,
-        }) => ruff_fstring_element_into_iter(elements)
-            .map(ruff_fstring_element_to_joined_str_part)
-            .collect(),
-    }
+    fstring_element
+        .iter_mut()
+        .map(move |elem| core::mem::replace(elem, default.clone()))
+        .collect::<Vec<_>>()
+        .into_iter()
 }
 
 fn ruff_fstring_element_to_joined_str_part(
@@ -357,13 +317,280 @@ pub(super) fn fstring_to_object(
 ) -> PyObjectRef {
     let ruff::ExprFString {
         range,
-        value,
+        mut value,
         node_index: _,
     } = expression;
-    let values: Vec<_> = ruff_fstring_value_into_iter(value)
-        .flat_map(fstring_part_to_joined_str_part)
-        .collect();
-    let values = values.into_boxed_slice();
-    let c = JoinedStr { range, values };
+    let default_part = ruff::FStringPart::FString(ruff::FString {
+        node_index: Default::default(),
+        range: Default::default(),
+        elements: Default::default(),
+        flags: ruff::FStringFlags::empty(),
+    });
+    let mut values = Vec::new();
+    for i in 0..value.as_slice().len() {
+        let part = core::mem::replace(value.iter_mut().nth(i).unwrap(), default_part.clone());
+        match part {
+            ruff::FStringPart::Literal(ruff::StringLiteral {
+                range,
+                value,
+                flags,
+                node_index: _,
+            }) => {
+                values.push(JoinedStrPart::Constant(Constant::new_str(
+                    value,
+                    flags.prefix(),
+                    range,
+                )));
+            }
+            ruff::FStringPart::FString(ruff::FString {
+                range: _,
+                elements,
+                flags: _,
+                node_index: _,
+            }) => {
+                for element in ruff_fstring_element_into_iter(elements) {
+                    values.push(ruff_fstring_element_to_joined_str_part(element));
+                }
+            }
+        }
+    }
+    let c = JoinedStr {
+        range,
+        values: values.into_boxed_slice(),
+    };
+    c.ast_to_object(vm, source_file)
+}
+
+// ===== TString (Template String) Support =====
+
+fn ruff_tstring_element_to_template_str_part(
+    element: ruff::InterpolatedStringElement,
+    source_file: &SourceFile,
+) -> TemplateStrPart {
+    match element {
+        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            range,
+            value,
+            node_index: _,
+        }) => TemplateStrPart::Constant(Constant::new_str(
+            value,
+            ruff::str_prefix::StringLiteralPrefix::Empty,
+            range,
+        )),
+        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            range,
+            expression,
+            debug_text,
+            conversion,
+            format_spec,
+            node_index: _,
+        }) => {
+            // Get the expression source text for the "str" field
+            let expr_str = debug_text
+                .map(|dt| dt.leading.to_string() + &dt.trailing)
+                .unwrap_or_else(|| source_file.slice(expression.range()).to_string());
+            TemplateStrPart::Interpolation(TStringInterpolation {
+                value: expression,
+                str: expr_str,
+                conversion,
+                format_spec: ruff_format_spec_to_template_str(format_spec, source_file),
+                range,
+            })
+        }
+    }
+}
+
+fn ruff_format_spec_to_template_str(
+    format_spec: Option<Box<ruff::InterpolatedStringFormatSpec>>,
+    source_file: &SourceFile,
+) -> Option<Box<TemplateStr>> {
+    match format_spec {
+        None => None,
+        Some(format_spec) => {
+            let ruff::InterpolatedStringFormatSpec {
+                range,
+                elements,
+                node_index: _,
+            } = *format_spec;
+            let values: Vec<_> = ruff_fstring_element_into_iter(elements)
+                .map(|e| ruff_tstring_element_to_template_str_part(e, source_file))
+                .collect();
+            let values = values.into_boxed_slice();
+            Some(Box::new(TemplateStr { range, values }))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct TemplateStr {
+    pub(super) range: TextRange,
+    pub(super) values: Box<[TemplateStrPart]>,
+}
+
+// constructor
+impl Node for TemplateStr {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { values, range } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprTemplateStr::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item(
+            "values",
+            BoxedSlice(values).ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let values: BoxedSlice<_> = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "values", "TemplateStr")?,
+        )?;
+        Ok(Self {
+            values: values.0,
+            range: range_from_object(vm, source_file, object, "TemplateStr")?,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum TemplateStrPart {
+    Interpolation(TStringInterpolation),
+    Constant(Constant),
+}
+
+// constructor
+impl Node for TemplateStrPart {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::Interpolation(value) => value.ast_to_object(vm, source_file),
+            Self::Constant(value) => value.ast_to_object(vm, source_file),
+        }
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let cls = object.class();
+        if cls.is(pyast::NodeExprInterpolation::static_type()) {
+            Ok(Self::Interpolation(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        } else {
+            Ok(Self::Constant(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct TStringInterpolation {
+    value: Box<ruff::Expr>,
+    str: String,
+    conversion: ruff::ConversionFlag,
+    format_spec: Option<Box<TemplateStr>>,
+    range: TextRange,
+}
+
+// constructor
+impl Node for TStringInterpolation {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            value,
+            str,
+            conversion,
+            format_spec,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprInterpolation::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("str", vm.ctx.new_str(str).into(), vm)
+            .unwrap();
+        dict.set_item("conversion", conversion.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "format_spec",
+            format_spec.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let str_obj = get_node_field(vm, &object, "str", "Interpolation")?;
+        let str_val: String = str_obj.try_into_value(vm)?;
+        Ok(Self {
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Interpolation")?,
+            )?,
+            str: str_val,
+            conversion: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "conversion", "Interpolation")?,
+            )?,
+            format_spec: get_node_field_opt(vm, &object, "format_spec")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "Interpolation")?,
+        })
+    }
+}
+
+pub(super) fn tstring_to_object(
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+    expression: ruff::ExprTString,
+) -> PyObjectRef {
+    let ruff::ExprTString {
+        range,
+        mut value,
+        node_index: _,
+    } = expression;
+    let default_tstring = ruff::TString {
+        node_index: Default::default(),
+        range: Default::default(),
+        elements: Default::default(),
+        flags: ruff::TStringFlags::empty(),
+    };
+    let mut values = Vec::new();
+    for i in 0..value.as_slice().len() {
+        let tstring = core::mem::replace(value.iter_mut().nth(i).unwrap(), default_tstring.clone());
+        for element in ruff_fstring_element_into_iter(tstring.elements) {
+            values.push(ruff_tstring_element_to_template_str_part(
+                element,
+                source_file,
+            ));
+        }
+    }
+    let c = TemplateStr {
+        range,
+        values: values.into_boxed_slice(),
+    };
     c.ast_to_object(vm, source_file)
 }
diff --git a/crates/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
index c4aa7258c07..9fa4e777a1a 100644
--- a/crates/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -3,9 +3,9 @@ use crate::{
     builtins::{
         asyncgenerator, bool_, builtin_func, bytearray, bytes, classmethod, code, complex,
         coroutine, descriptor, dict, enumerate, filter, float, frame, function, generator,
-        genericalias, getset, int, iter, list, map, mappingproxy, memory, module, namespace,
-        object, property, pystr, range, set, singletons, slice, staticmethod, super_, traceback,
-        tuple,
+        genericalias, getset, int, interpolation, iter, list, map, mappingproxy, memory, module,
+        namespace, object, property, pystr, range, set, singletons, slice, staticmethod, super_,
+        template, traceback, tuple,
         type_::{self, PyType},
         union_, weakproxy, weakref, zip,
     },
@@ -93,6 +93,9 @@ pub struct TypeZoo {
     pub not_implemented_type: &'static Py<PyType>,
     pub generic_alias_type: &'static Py<PyType>,
     pub union_type: &'static Py<PyType>,
+    pub interpolation_type: &'static Py<PyType>,
+    pub template_type: &'static Py<PyType>,
+    pub template_iter_type: &'static Py<PyType>,
     pub member_descriptor_type: &'static Py<PyType>,
     pub wrapper_descriptor_type: &'static Py<PyType>,
     pub method_wrapper_type: &'static Py<PyType>,
@@ -188,6 +191,9 @@ impl TypeZoo {
             not_implemented_type: singletons::PyNotImplemented::init_builtin_type(),
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
+            interpolation_type: interpolation::PyInterpolation::init_builtin_type(),
+            template_type: template::PyTemplate::init_builtin_type(),
+            template_iter_type: template::PyTemplateIter::init_builtin_type(),
             member_descriptor_type: descriptor::PyMemberDescriptor::init_builtin_type(),
             wrapper_descriptor_type: descriptor::PyWrapper::init_builtin_type(),
             method_wrapper_type: descriptor::PyMethodWrapper::init_builtin_type(),
@@ -243,6 +249,8 @@ impl TypeZoo {
         traceback::init(context);
         genericalias::init(context);
         union_::init(context);
+        interpolation::init(context);
+        template::init(context);
         descriptor::init(context);
         crate::stdlib::typing::init(context);
     }
diff --git a/crates/vm/src/vm/vm_ops.rs b/crates/vm/src/vm/vm_ops.rs
index 1d466984377..1a362d67bed 100644
--- a/crates/vm/src/vm/vm_ops.rs
+++ b/crates/vm/src/vm/vm_ops.rs
@@ -380,8 +380,10 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = a.try_sequence(self) {
-            let result = seq_a.concat(b, self)?;
+        // Check if concat slot is available directly, matching PyNumber_Add behavior
+        let seq = a.sequence_unchecked();
+        if let Some(f) = seq.slots().concat.load() {
+            let result = f(seq, b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
             }
@@ -394,8 +396,11 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = a.try_sequence(self) {
-            let result = seq_a.inplace_concat(b, self)?;
+        // Check inplace_concat or concat slot directly, matching PyNumber_InPlaceAdd behavior
+        let seq = a.sequence_unchecked();
+        let slots = seq.slots();
+        if let Some(f) = slots.inplace_concat.load().or_else(|| slots.concat.load()) {
+            let result = f(seq, b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
             }

From 299f1ea0aa3e58b355c5bc99a80e5b9fd874eaf1 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 19:18:54 +0900
Subject: [PATCH 309/418] skip flaky
 test_concurrent_futures.test_process_pool.test_ressources_gced_in_workers
 (#6750)

---
 Lib/test/test_concurrent_futures/test_process_pool.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
index 5d4e9677f5c..46dbdedd435 100644
--- a/Lib/test/test_concurrent_futures/test_process_pool.py
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -85,6 +85,7 @@ def test_traceback(self):
         self.assertIn('raise RuntimeError(123) # some comment',
                       f1.getvalue())
 
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky EOFError')
     @hashlib_helper.requires_hashdigest('md5')
     def test_ressources_gced_in_workers(self):
         # Ensure that argument for a job are correctly gc-ed after the job

From ea1e60e9ca25f7807c6ae27aaf60b141cef2f75e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 18:24:30 +0900
Subject: [PATCH 310/418] mark version to 3.14

---
 .github/copilot-instructions.md     | 2 +-
 .github/workflows/ci.yaml           | 2 +-
 .github/workflows/cron-ci.yaml      | 2 +-
 .github/workflows/update-doc-db.yml | 2 +-
 DEVELOPMENT.md                      | 2 +-
 README.md                           | 2 +-
 crates/venvlauncher/src/main.rs     | 6 +++---
 crates/vm/src/version.rs            | 4 ++--
 crates/vm/src/vm/mod.rs             | 2 +-
 whats_left.py                       | 6 +++---
 10 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 4667f4ee17b..a03de550681 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -4,7 +4,7 @@ This document provides guidelines for working with GitHub Copilot when contribut
 
 ## Project Overview
 
-RustPython is a Python 3 interpreter written in Rust, implementing Python 3.13.0+ compatibility. The project aims to provide:
+RustPython is a Python 3 interpreter written in Rust, implementing Python 3.14.0+ compatibility. The project aims to provide:
 
 - A complete Python-3 environment entirely in Rust (not CPython bindings)
 - A clean implementation without compatibility hacks
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b8263026d51..7fc4c653189 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -115,7 +115,7 @@ env:
     test.test_multiprocessing_spawn.test_processes
   ENV_POLLUTING_TESTS_WINDOWS: >-
   # Python version targeted by the CI.
-  PYTHON_VERSION: "3.13.1"
+  PYTHON_VERSION: "3.14.2"
   X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
   X86_64_PC_WINDOWS_MSVC_OPENSSL_INCLUDE_DIR: C:\Program Files\OpenSSL\include
 
diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index d48c5e4cfeb..9d549602bc6 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -13,7 +13,7 @@ name: Periodic checks/tasks
 
 env:
   CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
-  PYTHON_VERSION: "3.13.1"
+  PYTHON_VERSION: "3.14.2"
 
 jobs:
   # codecov collects code coverage data from the rust tests, python snippets and python test suite.
diff --git a/.github/workflows/update-doc-db.yml b/.github/workflows/update-doc-db.yml
index c580e7d0eaf..37cf56504d2 100644
--- a/.github/workflows/update-doc-db.yml
+++ b/.github/workflows/update-doc-db.yml
@@ -9,7 +9,7 @@ on:
       python-version:
         description: Target python version to generate doc db for
         type: string
-        default: "3.13.9"
+        default: "3.14.2"
       ref:
         description: Branch to commit to (leave empty for current branch)
         type: string
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index 82364e9b812..f515bef1a1a 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -25,7 +25,7 @@ RustPython requires the following:
       stable version: `rustup update stable`
     - If you do not have Rust installed, use [rustup](https://rustup.rs/) to
       do so.
-- CPython version 3.13 or higher
+- CPython version 3.14 or higher
     - CPython can be installed by your operating system's package manager,
       from the [Python website](https://www.python.org/downloads/), or
       using a third-party distribution, such as 
diff --git a/README.md b/README.md
index b3ddbe4e7cf..c4f7bfb1d60 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 # [RustPython](https://rustpython.github.io/)
 
-A Python-3 (CPython >= 3.13.0) Interpreter written in Rust :snake: :scream:
+A Python-3 (CPython >= 3.14.0) Interpreter written in Rust :snake: :scream:
 :metal:.
 
 [![Build Status](https://github.com/RustPython/RustPython/workflows/CI/badge.svg)](https://github.com/RustPython/RustPython/actions?query=workflow%3ACI)
diff --git a/crates/venvlauncher/src/main.rs b/crates/venvlauncher/src/main.rs
index fe147ce7ff3..7087e791e37 100644
--- a/crates/venvlauncher/src/main.rs
+++ b/crates/venvlauncher/src/main.rs
@@ -114,12 +114,12 @@ mod tests {
         let cfg_path = temp_dir.join("test_pyvenv.cfg");
 
         let mut file = fs::File::create(&cfg_path).unwrap();
-        writeln!(file, "home = C:\\Python313").unwrap();
+        writeln!(file, "home = C:\\Python314").unwrap();
         writeln!(file, "include-system-site-packages = false").unwrap();
-        writeln!(file, "version = 3.13.0").unwrap();
+        writeln!(file, "version = 3.14.0").unwrap();
 
         let home = read_home(&cfg_path).unwrap();
-        assert_eq!(home, "C:\\Python313");
+        assert_eq!(home, "C:\\Python314");
 
         fs::remove_file(&cfg_path).unwrap();
     }
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index 2b5e82a8d76..bd42341ef76 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -4,9 +4,9 @@ use chrono::{Local, prelude::DateTime};
 use core::time::Duration;
 use std::time::UNIX_EPOCH;
 
-// = 3.13.0alpha
+// = 3.14.0alpha
 pub const MAJOR: usize = 3;
-pub const MINOR: usize = 13;
+pub const MINOR: usize = 14;
 pub const MICRO: usize = 0;
 pub const RELEASELEVEL: &str = "alpha";
 pub const RELEASELEVEL_N: usize = 0xA;
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 8233df43a2b..27b70e321cf 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -523,7 +523,7 @@ impl VirtualMachine {
     /// ```no_run
     /// use rustpython_vm::Interpreter;
     /// Interpreter::without_stdlib(Default::default()).enter(|vm| {
-    ///     let bytes = std::fs::read("__pycache__/<input>.rustpython-313.pyc").unwrap();
+    ///     let bytes = std::fs::read("__pycache__/<input>.rustpython-314.pyc").unwrap();
     ///     let main_scope = vm.new_scope_with_main().unwrap();
     ///     vm.run_pyc_bytes(&bytes, main_scope);
     /// });
diff --git a/whats_left.py b/whats_left.py
index c5b0be6eadc..3ae2d2c0fe0 100755
--- a/whats_left.py
+++ b/whats_left.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env -S python3 -I
 # /// script
-# requires-python = ">=3.13"
+# requires-python = ">=3.14"
 # ///
 
 # This script generates Lib/snippets/whats_left_data.py with these variables defined:
@@ -37,9 +37,9 @@
 implementation = platform.python_implementation()
 if implementation != "CPython":
     sys.exit(f"whats_left.py must be run under CPython, got {implementation} instead")
-if sys.version_info[:2] < (3, 13):
+if sys.version_info[:2] < (3, 14):
     sys.exit(
-        f"whats_left.py must be run under CPython 3.13 or newer, got {implementation} {sys.version} instead. If you have uv, try `uv run python -I whats_left.py` to select a proper Python interpreter easier."
+        f"whats_left.py must be run under CPython 3.14 or newer, got {implementation} {sys.version} instead. If you have uv, try `uv run python -I whats_left.py` to select a proper Python interpreter easier."
     )
 
 

From 7594ef5121f1142931e9b44e1ecffcb18b48a4d8 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 18:37:31 +0900
Subject: [PATCH 311/418] upgrade site to 3.14.2

---
 Lib/site.py           | 30 ++++++++++++++++++------------
 Lib/test/test_site.py | 31 ++++++++++++++++++++++---------
 2 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/Lib/site.py b/Lib/site.py
index 2983ca71544..5305d67b3b8 100644
--- a/Lib/site.py
+++ b/Lib/site.py
@@ -73,7 +73,7 @@
 import os
 import builtins
 import _sitebuiltins
-import io
+import _io as io
 import stat
 import errno
 
@@ -95,6 +95,12 @@ def _trace(message):
         print(message, file=sys.stderr)
 
 
+def _warn(*args, **kwargs):
+    import warnings
+
+    warnings.warn(*args, **kwargs)
+
+
 def makepath(*paths):
     dir = os.path.join(*paths)
     try:
@@ -444,9 +450,9 @@ def setcopyright():
     """Set 'copyright' and 'credits' in builtins"""
     builtins.copyright = _sitebuiltins._Printer("copyright", sys.copyright)
     builtins.credits = _sitebuiltins._Printer("credits", """\
-    Thanks to CWI, CNRI, BeOpen, Zope Corporation, the Python Software
-    Foundation, and a cast of thousands for supporting Python
-    development.  See www.python.org for more information.""")
+Thanks to CWI, CNRI, BeOpen, Zope Corporation, the Python Software
+Foundation, and a cast of thousands for supporting Python
+development.  See www.python.org for more information.""")
     files, dirs = [], []
     # Not all modules are required to have a __file__ attribute.  See
     # PEP 420 for more details.
@@ -574,7 +580,7 @@ def register_readline():
         def write_history():
             try:
                 readline_module.write_history_file(history)
-            except (FileNotFoundError, PermissionError):
+            except FileNotFoundError, PermissionError:
                 # home directory does not exist or is not writable
                 # https://bugs.python.org/issue19891
                 pass
@@ -626,17 +632,17 @@ def venv(known_paths):
                     elif key == 'home':
                         sys._home = value
 
-        sys.prefix = sys.exec_prefix = site_prefix
+        if sys.prefix != site_prefix:
+            _warn(f'Unexpected value in sys.prefix, expected {site_prefix}, got {sys.prefix}', RuntimeWarning)
+        if sys.exec_prefix != site_prefix:
+            _warn(f'Unexpected value in sys.exec_prefix, expected {site_prefix}, got {sys.exec_prefix}', RuntimeWarning)
 
         # Doing this here ensures venv takes precedence over user-site
         addsitepackages(known_paths, [sys.prefix])
 
-        # addsitepackages will process site_prefix again if its in PREFIXES,
-        # but that's ok; known_paths will prevent anything being added twice
         if system_site == "true":
-            PREFIXES.insert(0, sys.prefix)
+            PREFIXES += [sys.base_prefix, sys.base_exec_prefix]
         else:
-            PREFIXES = [sys.prefix]
             ENABLE_USER_SITE = False
 
     return known_paths
@@ -646,7 +652,7 @@ def execsitecustomize():
     """Run custom site specific code, if available."""
     try:
         try:
-            import sitecustomize
+            import sitecustomize  # noqa: F401
         except ImportError as exc:
             if exc.name == 'sitecustomize':
                 pass
@@ -666,7 +672,7 @@ def execusercustomize():
     """Run custom user specific code, if available."""
     try:
         try:
-            import usercustomize
+            import usercustomize  # noqa: F401
         except ImportError as exc:
             if exc.name == 'usercustomize':
                 pass
diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py
index df279bd9652..56ed457882c 100644
--- a/Lib/test/test_site.py
+++ b/Lib/test/test_site.py
@@ -8,6 +8,7 @@
 import test.support
 from test import support
 from test.support.script_helper import assert_python_ok
+from test.support import import_helper
 from test.support import os_helper
 from test.support import socket_helper
 from test.support import captured_stderr
@@ -308,8 +309,7 @@ def test_getuserbase(self):
 
         with EnvironmentVarGuard() as environ:
             environ['PYTHONUSERBASE'] = 'xoxo'
-            self.assertTrue(site.getuserbase().startswith('xoxo'),
-                            site.getuserbase())
+            self.assertTrue(site.getuserbase().startswith('xoxo'))
 
     @unittest.skipUnless(HAS_USER_SITE, 'need user site')
     def test_getusersitepackages(self):
@@ -319,7 +319,7 @@ def test_getusersitepackages(self):
 
         # the call sets USER_BASE *and* USER_SITE
         self.assertEqual(site.USER_SITE, user_site)
-        self.assertTrue(user_site.startswith(site.USER_BASE), user_site)
+        self.assertTrue(user_site.startswith(site.USER_BASE))
         self.assertEqual(site.USER_BASE, site.getuserbase())
 
     def test_getsitepackages(self):
@@ -362,11 +362,10 @@ def test_no_home_directory(self):
             environ.unset('PYTHONUSERBASE', 'APPDATA')
 
             user_base = site.getuserbase()
-            self.assertTrue(user_base.startswith('~' + os.sep),
-                            user_base)
+            self.assertTrue(user_base.startswith('~' + os.sep))
 
             user_site = site.getusersitepackages()
-            self.assertTrue(user_site.startswith(user_base), user_site)
+            self.assertTrue(user_site.startswith(user_base))
 
         with mock.patch('os.path.isdir', return_value=False) as mock_isdir, \
              mock.patch.object(site, 'addsitedir') as mock_addsitedir, \
@@ -515,7 +514,7 @@ def test_sitecustomize_executed(self):
         # If sitecustomize is available, it should have been imported.
         if "sitecustomize" not in sys.modules:
             try:
-                import sitecustomize
+                import sitecustomize  # noqa: F401
             except ImportError:
                 pass
             else:
@@ -578,6 +577,17 @@ def test_license_exists_at_url(self):
             code = e.code
         self.assertEqual(code, 200, msg="Can't find " + url)
 
+    @support.cpython_only
+    def test_lazy_imports(self):
+        import_helper.ensure_lazy_imports("site", [
+            "io",
+            "locale",
+            "traceback",
+            "atexit",
+            "warnings",
+            "textwrap",
+        ])
+
 
 class StartupImportTests(unittest.TestCase):
 
@@ -843,12 +853,15 @@ def get_excepted_output(self, *args):
             return 10, None
 
     def invoke_command_line(self, *args):
-        args = ["-m", "site", *args]
+        cmd_args = []
+        if sys.flags.no_user_site:
+            cmd_args.append("-s")
+        cmd_args.extend(["-m", "site", *args])
 
         with EnvironmentVarGuard() as env:
             env["PYTHONUTF8"] = "1"
             env["PYTHONIOENCODING"] = "utf-8"
-            proc = spawn_python(*args, text=True, env=env,
+            proc = spawn_python(*cmd_args, text=True, env=env,
                                 encoding='utf-8', errors='replace')
 
         output = kill_python(proc)

From 280caea5792628cf3d8d6461a2468c751e27d10d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 18:37:37 +0900
Subject: [PATCH 312/418] upgrade venvlauncher

---
 Lib/venv/scripts/nt/venvlauncher.exe   | Bin 268800 -> 268800 bytes
 Lib/venv/scripts/nt/venvlaunchert.exe  | Bin 268800 -> 268800 bytes
 Lib/venv/scripts/nt/venvwlauncher.exe  | Bin 268800 -> 268800 bytes
 Lib/venv/scripts/nt/venvwlaunchert.exe | Bin 268800 -> 268800 bytes
 4 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/Lib/venv/scripts/nt/venvlauncher.exe b/Lib/venv/scripts/nt/venvlauncher.exe
index 2439c22aa932798bbb5e7ce13c34622d7dd7aff0..c6863b56e57f182bac434720bd5ed155b283259e 100644
GIT binary patch
delta 114
zcmZqJBG9l!V8Rb(W5Kk>->ttHTYocc{moq2Y7G>~WB>vtAl3xpFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`px$=AXyJt>uZ0hv`^K{woZQaQ!Te()0A~&%B>(^b

delta 114
zcmZqJBG9l!V8Rb(TVvnG->ttHTYocc{moq2Y7G>~WB>vtAl3xpFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`Ao|9n)kABp!}2R$Qbs}V?``MkVE!=?0A=|gYXATM

diff --git a/Lib/venv/scripts/nt/venvlaunchert.exe b/Lib/venv/scripts/nt/venvlaunchert.exe
index 99f5f5e9fca3531bdf05b627409794529eacf0d8..c12a7a869f4748dcb538df74635e5f0d42a02a1a 100644
GIT binary patch
delta 114
zcmZqJBG9l!V8Rb(W5Kk>->ttHTYocc{moq2Y7G>~WB>vtAl3rnFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`Ai`_nTyA#8ubrF2|JLbsTefp_F#nhc06b71HUIzs

delta 114
zcmZqJBG9l!V8Rb(TVvnG->ttHTYocc{moq2Y7G>~WB>vtAl3rnFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`ptW^HP&3B?@7d~St~5^CW3Zj0gZalq0C6!P0{{R3

diff --git a/Lib/venv/scripts/nt/venvwlauncher.exe b/Lib/venv/scripts/nt/venvwlauncher.exe
index 6c43c2e9d9365ab5ff80adb25b143c6580d177fd..d0d3733266fc992ffbb2431dbcf64377113663fc 100644
GIT binary patch
delta 114
zcmZqJBG9l!V8Rb(W5Kk>->ttHTYocc{moq2Y7G>~WB>vtAl3rnFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`@WH`(`gVh9zAdMY=|{YndT~2P2lJ1K0BC<9qyPW_

delta 114
zcmZqJBG9l!V8Rb(TVvnG->ttHTYocc{moq2Y7G>~WB>vtAl3rnFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`&>-^au+_|9r`8>T>UTb`=iScH!Te()0Cb}v8~^|S

diff --git a/Lib/venv/scripts/nt/venvwlaunchert.exe b/Lib/venv/scripts/nt/venvwlaunchert.exe
index 74f40deb0467b055fe42c80480144f3ecd542da5..9456a9e9b4a5c6fffe2faf5db6490e7161f07ddc 100644
GIT binary patch
delta 114
zcmZqJBG9l!V8Rb(W5Kk>->ttHTYocc{moq2Y7G>~WB>vtAl3%rFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`@c*Uulb^|dJeE!gRG0m(dv!ZU2lJ1K0Dd+iMgRZ+

delta 114
zcmZqJBG9l!V8Rb(TVvnG->ttHTYocc{moq2Y7G>~WB>vtAl3%rFAJF&zO*xggcx9Q
wJV3Sx5GyQVW>DyW%WYrZ#_Y)`&@3!{b=i??-m9ifJ)r+VYWjAL4(1;d0eiq9ssI20


From 8d901a7300bae8bb952910473787299517d52da5 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 18:42:52 +0900
Subject: [PATCH 313/418] Implement bool(NotImplemented)

---
 Lib/test/test_builtin.py             | 21 +++++++++------------
 crates/vm/src/builtins/singletons.rs |  9 +++++----
 extra_tests/snippets/builtin_bool.py |  4 +++-
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 38fd9ab95ba..cbba54a3bf9 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -2010,21 +2010,18 @@ def test_construct_singletons(self):
             self.assertRaises(TypeError, tp, 1, 2)
             self.assertRaises(TypeError, tp, a=1, b=2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_warning_notimplemented(self):
-        # Issue #35712: NotImplemented is a sentinel value that should never
+    def test_bool_notimplemented(self):
+        # GH-79893: NotImplemented is a sentinel value that should never
         # be evaluated in a boolean context (virtually all such use cases
         # are a result of accidental misuse implementing rich comparison
         # operations in terms of one another).
-        # For the time being, it will continue to evaluate as a true value, but
-        # issue a deprecation warning (with the eventual intent to make it
-        # a TypeError).
-        self.assertWarns(DeprecationWarning, bool, NotImplemented)
-        with self.assertWarns(DeprecationWarning):
-            self.assertTrue(NotImplemented)
-        with self.assertWarns(DeprecationWarning):
-            self.assertFalse(not NotImplemented)
+        msg = "NotImplemented should not be used in a boolean context"
+        self.assertRaisesRegex(TypeError, msg, bool, NotImplemented)
+        with self.assertRaisesRegex(TypeError, msg):
+            if NotImplemented:
+                pass
+        with self.assertRaisesRegex(TypeError, msg):
+            not NotImplemented
 
 
 class TestBreakpoint(unittest.TestCase):
diff --git a/crates/vm/src/builtins/singletons.rs b/crates/vm/src/builtins/singletons.rs
index 61ab1968a45..169104efeb3 100644
--- a/crates/vm/src/builtins/singletons.rs
+++ b/crates/vm/src/builtins/singletons.rs
@@ -108,11 +108,12 @@ impl PyNotImplemented {
 
 impl AsNumber for PyNotImplemented {
     fn as_number() -> &'static PyNumberMethods {
-        // TODO: As per https://bugs.python.org/issue35712, using NotImplemented
-        // in boolean contexts will need to raise a DeprecationWarning in 3.9
-        // and, eventually, a TypeError.
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            boolean: Some(|_number, _vm| Ok(true)),
+            boolean: Some(|_number, vm| {
+                Err(vm.new_type_error(
+                    "NotImplemented should not be used in a boolean context".to_owned(),
+                ))
+            }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
         &AS_NUMBER
diff --git a/extra_tests/snippets/builtin_bool.py b/extra_tests/snippets/builtin_bool.py
index 6b6b4e0e08b..902ed0cced0 100644
--- a/extra_tests/snippets/builtin_bool.py
+++ b/extra_tests/snippets/builtin_bool.py
@@ -18,7 +18,9 @@
 assert bool(1) is True
 assert bool({}) is False
 
-assert bool(NotImplemented) is True
+# NotImplemented cannot be used in a boolean context (Python 3.14+)
+with assert_raises(TypeError):
+    bool(NotImplemented)
 assert bool(...) is True
 
 if not 1:

From 2fe140fdb9c85b4db120d1ad6e28743d1914a5a1 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 22:54:49 +0900
Subject: [PATCH 314/418] Fix bytes/bytearray fromhex

---
 crates/vm/src/builtins/bytearray.rs       |  4 +--
 crates/vm/src/builtins/bytes.rs           |  4 +--
 crates/vm/src/bytes_inner.rs              | 43 +++++++++++++++++------
 extra_tests/snippets/builtin_bytearray.py | 31 ++++++++++++++--
 extra_tests/snippets/builtin_bytes.py     | 31 ++++++++++++++--
 5 files changed, 93 insertions(+), 20 deletions(-)

diff --git a/crates/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
index 0f9dce7230b..5a3aee59072 100644
--- a/crates/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -322,8 +322,8 @@ impl PyByteArray {
     }
 
     #[pyclassmethod]
-    fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let bytes = PyBytesInner::fromhex(string.as_bytes(), vm)?;
+    fn fromhex(cls: PyTypeRef, string: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let bytes = PyBytesInner::fromhex_object(string, vm)?;
         let bytes = vm.ctx.new_bytes(bytes);
         let args = vec![bytes.into()].into();
         PyType::call(&cls, args, vm)
diff --git a/crates/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
index 01e67358aae..64e00cdc919 100644
--- a/crates/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -316,8 +316,8 @@ impl PyBytes {
     }
 
     #[pyclassmethod]
-    fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let bytes = PyBytesInner::fromhex(string.as_bytes(), vm)?;
+    fn fromhex(cls: PyTypeRef, string: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let bytes = PyBytesInner::fromhex_object(string, vm)?;
         let bytes = vm.ctx.new_bytes(bytes).into();
         PyType::call(&cls, vec![bytes].into(), vm)
     }
diff --git a/crates/vm/src/bytes_inner.rs b/crates/vm/src/bytes_inner.rs
index bb5db442c35..7e1c1c2220c 100644
--- a/crates/vm/src/bytes_inner.rs
+++ b/crates/vm/src/bytes_inner.rs
@@ -423,12 +423,13 @@ impl PyBytesInner {
 
     pub fn fromhex(bytes: &[u8], vm: &VirtualMachine) -> PyResult<Vec<u8>> {
         let mut iter = bytes.iter().enumerate();
-        let mut bytes: Vec<u8> = Vec::with_capacity(bytes.len() / 2);
-        let i = loop {
+        let mut result: Vec<u8> = Vec::with_capacity(bytes.len() / 2);
+        // None means odd number of hex digits, Some(i) means invalid char at position i
+        let invalid_char: Option<usize> = loop {
             let (i, &b) = match iter.next() {
                 Some(val) => val,
                 None => {
-                    return Ok(bytes);
+                    return Ok(result);
                 }
             };
 
@@ -440,27 +441,49 @@ impl PyBytesInner {
                 b'0'..=b'9' => b - b'0',
                 b'a'..=b'f' => 10 + b - b'a',
                 b'A'..=b'F' => 10 + b - b'A',
-                _ => break i,
+                _ => break Some(i),
             };
 
             let (i, b) = match iter.next() {
                 Some(val) => val,
-                None => break i + 1,
+                None => break None, // odd number of hex digits
             };
 
             let bot = match b {
                 b'0'..=b'9' => b - b'0',
                 b'a'..=b'f' => 10 + b - b'a',
                 b'A'..=b'F' => 10 + b - b'A',
-                _ => break i,
+                _ => break Some(i),
             };
 
-            bytes.push((top << 4) + bot);
+            result.push((top << 4) + bot);
         };
 
-        Err(vm.new_value_error(format!(
-            "non-hexadecimal number found in fromhex() arg at position {i}"
-        )))
+        match invalid_char {
+            None => Err(vm.new_value_error(
+                "fromhex() arg must contain an even number of hexadecimal digits".to_owned(),
+            )),
+            Some(i) => Err(vm.new_value_error(format!(
+                "non-hexadecimal number found in fromhex() arg at position {i}"
+            ))),
+        }
+    }
+
+    /// Parse hex string from str or bytes-like object
+    pub fn fromhex_object(string: PyObjectRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        if let Some(s) = string.downcast_ref::<PyStr>() {
+            Self::fromhex(s.as_bytes(), vm)
+        } else if let Ok(buffer) = PyBuffer::try_from_borrowed_object(vm, &string) {
+            let borrowed = buffer.as_contiguous().ok_or_else(|| {
+                vm.new_buffer_error("fromhex() requires a contiguous buffer".to_owned())
+            })?;
+            Self::fromhex(&borrowed, vm)
+        } else {
+            Err(vm.new_type_error(format!(
+                "fromhex() argument must be str or bytes-like, not {}",
+                string.class().name()
+            )))
+        }
     }
 
     #[inline]
diff --git a/extra_tests/snippets/builtin_bytearray.py b/extra_tests/snippets/builtin_bytearray.py
index 0b7e419390e..ee11e913ff2 100644
--- a/extra_tests/snippets/builtin_bytearray.py
+++ b/extra_tests/snippets/builtin_bytearray.py
@@ -153,16 +153,41 @@ class B(bytearray):
 # # hex from hex
 assert bytearray([0, 1, 9, 23, 90, 234]).hex() == "000109175aea"
 
-bytearray.fromhex("62 6c7a 34350a ") == b"blz45\n"
+# fromhex with str
+assert bytearray.fromhex("62 6c7a 34350a ") == b"blz45\n"
+
+# fromhex with bytes
+assert bytearray.fromhex(b"62 6c7a 34350a ") == b"blz45\n"
+assert bytearray.fromhex(b"B9 01EF") == b"\xb9\x01\xef"
+
+# fromhex with bytearray (bytes-like object)
+assert bytearray.fromhex(bytearray(b"4142")) == b"AB"
+
+# fromhex with memoryview (bytes-like object)
+assert bytearray.fromhex(memoryview(b"4142")) == b"AB"
+
+# fromhex error: non-hexadecimal character
 try:
     bytearray.fromhex("62 a 21")
 except ValueError as e:
-    str(e) == "non-hexadecimal number found in fromhex() arg at position 4"
+    assert str(e) == "non-hexadecimal number found in fromhex() arg at position 4"
 try:
     bytearray.fromhex("6Z2")
 except ValueError as e:
-    str(e) == "non-hexadecimal number found in fromhex() arg at position 1"
+    assert str(e) == "non-hexadecimal number found in fromhex() arg at position 1"
+
+# fromhex error: odd number of hex digits
+try:
+    bytearray.fromhex("abc")
+except ValueError as e:
+    assert str(e) == "fromhex() arg must contain an even number of hexadecimal digits"
+
+# fromhex error: wrong type
 with assert_raises(TypeError):
+    bytearray.fromhex(123)
+
+# fromhex with bytes containing invalid hex raises ValueError
+with assert_raises(ValueError):
     bytearray.fromhex(b"hhjjk")
 # center
 assert [bytearray(b"koki").center(i, b"|") for i in range(3, 10)] == [
diff --git a/extra_tests/snippets/builtin_bytes.py b/extra_tests/snippets/builtin_bytes.py
index 4cb743baa6f..2cb4c317f49 100644
--- a/extra_tests/snippets/builtin_bytes.py
+++ b/extra_tests/snippets/builtin_bytes.py
@@ -137,16 +137,41 @@
 # hex from hex
 assert bytes([0, 1, 9, 23, 90, 234]).hex() == "000109175aea"
 
-bytes.fromhex("62 6c7a 34350a ") == b"blz45\n"
+# fromhex with str
+assert bytes.fromhex("62 6c7a 34350a ") == b"blz45\n"
+
+# fromhex with bytes
+assert bytes.fromhex(b"62 6c7a 34350a ") == b"blz45\n"
+assert bytes.fromhex(b"B9 01EF") == b"\xb9\x01\xef"
+
+# fromhex with bytearray (bytes-like object)
+assert bytes.fromhex(bytearray(b"4142")) == b"AB"
+
+# fromhex with memoryview (bytes-like object)
+assert bytes.fromhex(memoryview(b"4142")) == b"AB"
+
+# fromhex error: non-hexadecimal character
 try:
     bytes.fromhex("62 a 21")
 except ValueError as e:
-    str(e) == "non-hexadecimal number found in fromhex() arg at position 4"
+    assert str(e) == "non-hexadecimal number found in fromhex() arg at position 4"
 try:
     bytes.fromhex("6Z2")
 except ValueError as e:
-    str(e) == "non-hexadecimal number found in fromhex() arg at position 1"
+    assert str(e) == "non-hexadecimal number found in fromhex() arg at position 1"
+
+# fromhex error: odd number of hex digits
+try:
+    bytes.fromhex("abc")
+except ValueError as e:
+    assert str(e) == "fromhex() arg must contain an even number of hexadecimal digits"
+
+# fromhex error: wrong type
 with assert_raises(TypeError):
+    bytes.fromhex(123)
+
+# fromhex with bytes containing invalid hex raises ValueError
+with assert_raises(ValueError):
     bytes.fromhex(b"hhjjk")
 # center
 assert [b"koki".center(i, b"|") for i in range(3, 10)] == [

From db01a1d653f577baa563e2074ae845816d319e36 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:18:08 +0900
Subject: [PATCH 315/418] Remove pickle from itertools

---
 Lib/test/test_itertools.py               |  10 +
 crates/vm/src/stdlib/itertools.rs        | 391 +----------------------
 extra_tests/snippets/stdlib_itertools.py | 134 --------
 3 files changed, 24 insertions(+), 511 deletions(-)

diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 1c0c38ee042..e4d44e3d38c 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -248,6 +248,7 @@ def test_chain_from_iterable(self):
         self.assertRaises(TypeError, list, chain.from_iterable([2, 3]))
         self.assertEqual(list(islice(chain.from_iterable(repeat(range(5))), 2)), [0, 1])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_chain_reducible(self):
         for oper in [copy.deepcopy] + picklecopiers:
@@ -567,6 +568,7 @@ def test_combinatorics(self):
                 self.assertEqual(comb, list(filter(set(perm).__contains__, cwr)))     # comb: cwr that is a perm
                 self.assertEqual(comb, sorted(set(cwr) & set(perm)))            # comb: both a cwr and a perm
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_compress(self):
         self.assertEqual(list(compress(data='ABCDEF', selectors=[1,0,1,0,1,1])), list('ACEF'))
@@ -601,6 +603,7 @@ def test_compress(self):
                     next(testIntermediate)
                     self.assertEqual(list(op(testIntermediate)), list(result2))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_count(self):
         self.assertEqual(lzip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
@@ -1035,6 +1038,7 @@ def test_filter(self):
             c = filter(isEven, range(6))
             self.pickletest(proto, c)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_filterfalse(self):
         self.assertEqual(list(filterfalse(isEven, range(6))), [1,3,5])
@@ -1142,6 +1146,7 @@ def test_zip_longest_tuple_reuse(self):
         ids = list(map(id, list(zip_longest('abc', 'def'))))
         self.assertEqual(len(dict.fromkeys(ids)), len(ids))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_zip_longest_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -1365,6 +1370,7 @@ def test_product_tuple_reuse(self):
         self.assertEqual(len(set(map(id, product('abc', 'def')))), 1)
         self.assertNotEqual(len(set(map(id, list(product('abc', 'def'))))), 1)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_product_pickling(self):
         # check copy, deepcopy, pickle
@@ -1393,6 +1399,7 @@ def test_product_issue_25021(self):
         p.__setstate__((0, 0, 0x1000))  # will access tuple element 1 if not clamped
         self.assertRaises(StopIteration, next, p)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_repeat(self):
         self.assertEqual(list(repeat(object='a', times=3)), ['a', 'a', 'a'])
@@ -1458,6 +1465,7 @@ def test_map(self):
             c = map(tupleize, 'abc', count())
             self.pickletest(proto, c)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_starmap(self):
         self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
@@ -1582,6 +1590,7 @@ def __index__(self):
         self.assertEqual(list(islice(range(100), IntLike(10), IntLike(50), IntLike(5))),
                          list(range(10,50,5)))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_takewhile(self):
         data = [1, 3, 5, 20, 2, 4, 6, 8]
@@ -1941,6 +1950,7 @@ class TestExamples(unittest.TestCase):
     def test_accumulate(self):
         self.assertEqual(list(accumulate([1,2,3,4,5])), [1, 3, 6, 10, 15])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_accumulate_reducible(self):
         # check copy, deepcopy, pickle
diff --git a/crates/vm/src/stdlib/itertools.rs b/crates/vm/src/stdlib/itertools.rs
index 1eedbde7a22..f1761315cee 100644
--- a/crates/vm/src/stdlib/itertools.rs
+++ b/crates/vm/src/stdlib/itertools.rs
@@ -2,23 +2,18 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "itertools")]
 mod decl {
-    use crate::stdlib::itertools::decl::int::get_value;
     use crate::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, PyWeakRef, TryFromObject,
-        VirtualMachine,
-        builtins::{
-            PyGenericAlias, PyInt, PyIntRef, PyList, PyTuple, PyTupleRef, PyType, PyTypeRef, int,
-            tuple::IntoPyTuple,
-        },
+        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, PyWeakRef, VirtualMachine,
+        builtins::{PyGenericAlias, PyInt, PyIntRef, PyList, PyTuple, PyType, PyTypeRef, int},
         common::{
             lock::{PyMutex, PyRwLock, PyRwLockWriteGuard},
             rc::PyRc,
         },
         convert::ToPyObject,
-        function::{ArgCallable, ArgIntoBool, FuncArgs, OptionalArg, OptionalOption, PosArgs},
+        function::{ArgCallable, FuncArgs, OptionalArg, OptionalOption, PosArgs},
         protocol::{PyIter, PyIterReturn, PyNumber},
         raise_if_stop,
-        stdlib::{sys, warnings},
+        stdlib::sys,
         types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
     use crossbeam_utils::atomic::AtomicCell;
@@ -28,15 +23,6 @@ mod decl {
     use alloc::fmt;
     use num_traits::{Signed, ToPrimitive};
 
-    fn pickle_deprecation(vm: &VirtualMachine) -> PyResult<()> {
-        warnings::warn(
-            vm.ctx.exceptions.deprecation_warning,
-            "Itertool pickle/copy/deepcopy support will be removed in a Python 3.14.".to_owned(),
-            1,
-            vm,
-        )
-    }
-
     #[pyattr]
     #[pyclass(name = "chain")]
     #[derive(Debug, PyPayload)]
@@ -79,55 +65,6 @@ mod decl {
         ) -> PyGenericAlias {
             PyGenericAlias::from_args(cls, args, vm)
         }
-
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            pickle_deprecation(vm)?;
-            let source = zelf.source.read().clone();
-            let active = zelf.active.read().clone();
-            let cls = zelf.class().to_owned();
-            let empty_tuple = vm.ctx.empty_tuple.clone();
-            let reduced = match source {
-                Some(source) => match active {
-                    Some(active) => vm.new_tuple((cls, empty_tuple, (source, active))),
-                    None => vm.new_tuple((cls, empty_tuple, (source,))),
-                },
-                None => vm.new_tuple((cls, empty_tuple)),
-            };
-            Ok(reduced)
-        }
-
-        #[pymethod]
-        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
-            let args = state.as_slice();
-            if args.is_empty() {
-                return Err(vm.new_type_error("function takes at least 1 arguments (0 given)"));
-            }
-            if args.len() > 2 {
-                return Err(vm.new_type_error(format!(
-                    "function takes at most 2 arguments ({} given)",
-                    args.len()
-                )));
-            }
-            let source = &args[0];
-            if args.len() == 1 {
-                if !PyIter::check(source.as_ref()) {
-                    return Err(vm.new_type_error("Arguments must be iterators."));
-                }
-                *zelf.source.write() = source.to_owned().try_into_value(vm)?;
-                return Ok(());
-            }
-            let active = &args[1];
-
-            if !PyIter::check(source.as_ref()) || !PyIter::check(active.as_ref()) {
-                return Err(vm.new_type_error("Arguments must be iterators."));
-            }
-            let mut source_lock = zelf.source.write();
-            let mut active_lock = zelf.active.write();
-            *source_lock = source.to_owned().try_into_value(vm)?;
-            *active_lock = active.to_owned().try_into_value(vm)?;
-            Ok(())
-        }
     }
 
     impl SelfIter for PyItertoolsChain {}
@@ -209,16 +146,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-    impl PyItertoolsCompress {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyTypeRef, (PyIter, PyIter)) {
-            let _ = pickle_deprecation(vm);
-            (
-                zelf.class().to_owned(),
-                (zelf.data.clone(), zelf.selectors.clone()),
-            )
-        }
-    }
+    impl PyItertoolsCompress {}
 
     impl SelfIter for PyItertoolsCompress {}
 
@@ -275,16 +203,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor, Representable))]
-    impl PyItertoolsCount {
-        // TODO: Implement this
-        // if (lz->cnt == PY_SSIZE_T_MAX)
-        //      return Py_BuildValue("0(00)", Py_TYPE(lz), lz->long_cnt, lz->long_step);
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyTypeRef, (PyObjectRef,)) {
-            let _ = pickle_deprecation(vm);
-            (zelf.class().to_owned(), (zelf.cur.read().clone(),))
-        }
-    }
+    impl PyItertoolsCount {}
 
     impl SelfIter for PyItertoolsCount {}
 
@@ -406,16 +325,6 @@ mod decl {
                 .ok_or_else(|| vm.new_type_error("length of unsized object."))?;
             Ok(*times.read())
         }
-
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            pickle_deprecation(vm)?;
-            let cls = zelf.class().to_owned();
-            Ok(match zelf.times {
-                Some(ref times) => vm.new_tuple((cls, (zelf.object.clone(), *times.read()))),
-                None => vm.new_tuple((cls, (zelf.object.clone(),))),
-            })
-        }
     }
 
     impl SelfIter for PyItertoolsRepeat {}
@@ -474,19 +383,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-    impl PyItertoolsStarmap {
-        #[pymethod]
-        fn __reduce__(
-            zelf: PyRef<Self>,
-            vm: &VirtualMachine,
-        ) -> (PyTypeRef, (PyObjectRef, PyIter)) {
-            let _ = pickle_deprecation(vm);
-            (
-                zelf.class().to_owned(),
-                (zelf.function.clone(), zelf.iterable.clone()),
-            )
-        }
-    }
+    impl PyItertoolsStarmap {}
 
     impl SelfIter for PyItertoolsStarmap {}
 
@@ -541,31 +438,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-    impl PyItertoolsTakewhile {
-        #[pymethod]
-        fn __reduce__(
-            zelf: PyRef<Self>,
-            vm: &VirtualMachine,
-        ) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
-            let _ = pickle_deprecation(vm);
-            (
-                zelf.class().to_owned(),
-                (zelf.predicate.clone(), zelf.iterable.clone()),
-                zelf.stop_flag.load() as _,
-            )
-        }
-        #[pymethod]
-        fn __setstate__(
-            zelf: PyRef<Self>,
-            state: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.stop_flag.store(obj.into_bool());
-            }
-            Ok(())
-        }
-    }
+    impl PyItertoolsTakewhile {}
 
     impl SelfIter for PyItertoolsTakewhile {}
 
@@ -627,32 +500,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-    impl PyItertoolsDropwhile {
-        #[pymethod]
-        fn __reduce__(
-            zelf: PyRef<Self>,
-            vm: &VirtualMachine,
-        ) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
-            let _ = pickle_deprecation(vm);
-            (
-                zelf.class().to_owned(),
-                (zelf.predicate.clone().into(), zelf.iterable.clone()),
-                (zelf.start_flag.load() as _),
-            )
-        }
-
-        #[pymethod]
-        fn __setstate__(
-            zelf: PyRef<Self>,
-            state: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.start_flag.store(obj.into_bool());
-            }
-            Ok(())
-        }
-    }
+    impl PyItertoolsDropwhile {}
 
     impl SelfIter for PyItertoolsDropwhile {}
 
@@ -942,38 +790,6 @@ mod decl {
             .into_ref_with_type(vm, cls)
             .map(Into::into)
         }
-
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            pickle_deprecation(vm)?;
-            let cls = zelf.class().to_owned();
-            let itr = zelf.iterable.clone();
-            let cur = zelf.cur.take();
-            let next = zelf.next.take();
-            let step = zelf.step;
-            match zelf.stop {
-                Some(stop) => Ok(vm.new_tuple((cls, (itr, next, stop, step), (cur,)))),
-                _ => Ok(vm.new_tuple((cls, (itr, next, vm.new_pyobj(()), step), (cur,)))),
-            }
-        }
-
-        #[pymethod]
-        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
-            let args = state.as_slice();
-            if args.len() != 1 {
-                return Err(vm.new_type_error(format!(
-                    "function takes exactly 1 argument ({} given)",
-                    args.len()
-                )));
-            }
-            let cur = &args[0];
-            if let Ok(cur) = cur.try_to_value(vm) {
-                zelf.cur.store(cur);
-            } else {
-                return Err(vm.new_type_error("Argument must be usize."));
-            }
-            Ok(())
-        }
     }
 
     impl SelfIter for PyItertoolsIslice {}
@@ -1037,19 +853,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-    impl PyItertoolsFilterFalse {
-        #[pymethod]
-        fn __reduce__(
-            zelf: PyRef<Self>,
-            vm: &VirtualMachine,
-        ) -> (PyTypeRef, (PyObjectRef, PyIter)) {
-            let _ = pickle_deprecation(vm);
-            (
-                zelf.class().to_owned(),
-                (zelf.predicate.clone(), zelf.iterable.clone()),
-            )
-        }
-    }
+    impl PyItertoolsFilterFalse {}
 
     impl SelfIter for PyItertoolsFilterFalse {}
 
@@ -1106,59 +910,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor))]
-    impl PyItertoolsAccumulate {
-        #[pymethod]
-        fn __setstate__(
-            zelf: PyRef<Self>,
-            state: PyObjectRef,
-            _vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            *zelf.acc_value.write() = Some(state);
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
-            let _ = pickle_deprecation(vm);
-            let class = zelf.class().to_owned();
-            let bin_op = zelf.bin_op.clone();
-            let it = zelf.iterable.clone();
-            let acc_value = zelf.acc_value.read().clone();
-            if let Some(initial) = &zelf.initial {
-                let chain_args = PyList::from(vec![initial.clone(), it.to_pyobject(vm)]);
-                let chain = PyItertoolsChain {
-                    source: PyRwLock::new(Some(chain_args.to_pyobject(vm).get_iter(vm).unwrap())),
-                    active: PyRwLock::new(None),
-                };
-                let tup = vm.new_tuple((chain, bin_op));
-                return vm.new_tuple((class, tup, acc_value));
-            }
-            match acc_value {
-                Some(obj) if obj.is(&vm.ctx.none) => {
-                    let chain_args = PyList::from(vec![]);
-                    let chain = PyItertoolsChain {
-                        source: PyRwLock::new(Some(
-                            chain_args.to_pyobject(vm).get_iter(vm).unwrap(),
-                        )),
-                        active: PyRwLock::new(None),
-                    }
-                    .into_pyobject(vm);
-                    let acc = Self {
-                        iterable: PyIter::new(chain),
-                        bin_op,
-                        initial: None,
-                        acc_value: PyRwLock::new(None),
-                    };
-                    let tup = vm.new_tuple((acc, 1, None::<PyObjectRef>));
-                    let islice_cls = PyItertoolsIslice::class(&vm.ctx).to_owned();
-                    return vm.new_tuple((islice_cls, tup));
-                }
-                _ => {}
-            }
-            let tup = vm.new_tuple((it, bin_op));
-            vm.new_tuple((class, tup, acc_value))
-        }
-    }
+    impl PyItertoolsAccumulate {}
 
     impl SelfIter for PyItertoolsAccumulate {}
 
@@ -1359,58 +1111,6 @@ mod decl {
                 self.cur.store(idxs.len() - 1);
             }
         }
-
-        #[pymethod]
-        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
-            let args = state.as_slice();
-            if args.len() != zelf.pools.len() {
-                return Err(vm.new_type_error("Invalid number of arguments"));
-            }
-            let mut idxs: PyRwLockWriteGuard<'_, Vec<usize>> = zelf.idxs.write();
-            idxs.clear();
-            for s in 0..args.len() {
-                let index = get_value(state.get(s).unwrap()).to_usize().unwrap();
-                let pool_size = zelf.pools.get(s).unwrap().len();
-                if pool_size == 0 {
-                    zelf.stop.store(true);
-                    return Ok(());
-                }
-                if index >= pool_size {
-                    idxs.push(pool_size - 1);
-                } else {
-                    idxs.push(index);
-                }
-            }
-            zelf.stop.store(false);
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
-            let _ = pickle_deprecation(vm);
-            let class = zelf.class().to_owned();
-
-            if zelf.stop.load() {
-                return vm.new_tuple((class, (vm.ctx.empty_tuple.clone(),)));
-            }
-
-            let mut pools: Vec<PyObjectRef> = Vec::new();
-            for element in &zelf.pools {
-                pools.push(element.clone().into_pytuple(vm).into());
-            }
-
-            let mut indices: Vec<PyObjectRef> = Vec::new();
-
-            for item in &zelf.idxs.read()[..] {
-                indices.push(vm.new_pyobj(*item));
-            }
-
-            vm.new_tuple((
-                class,
-                pools.clone().into_pytuple(vm),
-                indices.into_pytuple(vm),
-            ))
-        }
     }
 
     impl SelfIter for PyItertoolsProduct {}
@@ -1492,36 +1192,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor))]
-    impl PyItertoolsCombinations {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
-            let _ = pickle_deprecation(vm);
-            let r = zelf.r.load();
-
-            let class = zelf.class().to_owned();
-
-            if zelf.exhausted.load() {
-                return vm.new_tuple((
-                    class,
-                    vm.new_tuple((vm.ctx.empty_tuple.clone(), vm.ctx.new_int(r))),
-                ));
-            }
-
-            let tup = vm.new_tuple((zelf.pool.clone().into_pytuple(vm), vm.ctx.new_int(r)));
-
-            if zelf.result.read().is_none() {
-                vm.new_tuple((class, tup))
-            } else {
-                let mut indices: Vec<PyObjectRef> = Vec::new();
-
-                for item in &zelf.indices.read()[..r] {
-                    indices.push(vm.new_pyobj(*item));
-                }
-
-                vm.new_tuple((class, tup, indices.into_pytuple(vm)))
-            }
-        }
-    }
+    impl PyItertoolsCombinations {}
 
     impl SelfIter for PyItertoolsCombinations {}
     impl IterNext for PyItertoolsCombinations {
@@ -1730,16 +1401,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor))]
-    impl PyItertoolsPermutations {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRef<PyTuple> {
-            let _ = pickle_deprecation(vm);
-            vm.new_tuple((
-                zelf.class().to_owned(),
-                vm.new_tuple((zelf.pool.clone(), vm.ctx.new_int(zelf.r.load()))),
-            ))
-        }
-    }
+    impl PyItertoolsPermutations {}
 
     impl SelfIter for PyItertoolsPermutations {}
 
@@ -1846,32 +1508,7 @@ mod decl {
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor))]
-    impl PyItertoolsZipLongest {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            pickle_deprecation(vm)?;
-            let args: Vec<PyObjectRef> = zelf
-                .iterators
-                .iter()
-                .map(|i| i.clone().to_pyobject(vm))
-                .collect();
-            Ok(vm.new_tuple((
-                zelf.class().to_owned(),
-                vm.new_tuple(args),
-                zelf.fillvalue.read().to_owned(),
-            )))
-        }
-
-        #[pymethod]
-        fn __setstate__(
-            zelf: PyRef<Self>,
-            state: PyObjectRef,
-            _vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            *zelf.fillvalue.write() = state;
-            Ok(())
-        }
-    }
+    impl PyItertoolsZipLongest {}
 
     impl SelfIter for PyItertoolsZipLongest {}
 
diff --git a/extra_tests/snippets/stdlib_itertools.py b/extra_tests/snippets/stdlib_itertools.py
index 4d2e9f6e1f7..ce7a494713a 100644
--- a/extra_tests/snippets/stdlib_itertools.py
+++ b/extra_tests/snippets/stdlib_itertools.py
@@ -1,5 +1,4 @@
 import itertools
-import pickle
 
 from testutils import assert_raises
 
@@ -181,10 +180,6 @@
 
 
 # itertools.takewhile tests
-def underten(x):
-    return x < 10
-
-
 from itertools import takewhile as tw
 
 t = tw(lambda n: n < 5, [1, 2, 5, 1, 3])
@@ -226,70 +221,6 @@ def underten(x):
 with assert_raises(StopIteration):
     next(t)
 
-it = tw(underten, [1, 3, 5, 20, 2, 4, 6, 8])
-assert (
-    pickle.dumps(it, 0)
-    == b"citertools\ntakewhile\np0\n(c__main__\nunderten\np1\nc__builtin__\niter\np2\n((lp3\nI1\naI3\naI5\naI20\naI2\naI4\naI6\naI8\natp4\nRp5\nI0\nbtp6\nRp7\nI0\nb."
-)
-assert (
-    pickle.dumps(it, 1)
-    == b"citertools\ntakewhile\nq\x00(c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02(]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08etq\x04Rq\x05K\x00btq\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 2)
-    == b"\x80\x02citertools\ntakewhile\nq\x00c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x00b\x86q\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 3)
-    == b"\x80\x03citertools\ntakewhile\nq\x00c__main__\nunderten\nq\x01cbuiltins\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x00b\x86q\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 4)
-    == b"\x80\x04\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\ttakewhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x00b\x86\x94R\x94K\x00b."
-)
-assert (
-    pickle.dumps(it, 5)
-    == b"\x80\x05\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\ttakewhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x00b\x86\x94R\x94K\x00b."
-)
-next(it)
-next(it)
-next(it)
-try:
-    next(it)
-except StopIteration:
-    pass
-assert (
-    pickle.dumps(it, 0)
-    == b"citertools\ntakewhile\np0\n(c__main__\nunderten\np1\nc__builtin__\niter\np2\n((lp3\nI1\naI3\naI5\naI20\naI2\naI4\naI6\naI8\natp4\nRp5\nI4\nbtp6\nRp7\nI1\nb."
-)
-assert (
-    pickle.dumps(it, 1)
-    == b"citertools\ntakewhile\nq\x00(c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02(]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08etq\x04Rq\x05K\x04btq\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 2)
-    == b"\x80\x02citertools\ntakewhile\nq\x00c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x04b\x86q\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 3)
-    == b"\x80\x03citertools\ntakewhile\nq\x00c__main__\nunderten\nq\x01cbuiltins\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x04b\x86q\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 4)
-    == b"\x80\x04\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\ttakewhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x04b\x86\x94R\x94K\x01b."
-)
-assert (
-    pickle.dumps(it, 5)
-    == b"\x80\x05\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\ttakewhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x04b\x86\x94R\x94K\x01b."
-)
-for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-    try:
-        next(pickle.loads(pickle.dumps(it, proto)))
-        assert False
-    except StopIteration:
-        pass
-
-
 # itertools.islice tests
 
 
@@ -297,40 +228,28 @@ def assert_matches_seq(it, seq):
     assert list(it) == list(seq)
 
 
-def test_islice_pickle(it):
-    for p in range(pickle.HIGHEST_PROTOCOL + 1):
-        it == pickle.loads(pickle.dumps(it, p))
-
-
 i = itertools.islice
 
 it = i([1, 2, 3, 4, 5], 3)
 assert_matches_seq(it, [1, 2, 3])
-test_islice_pickle(it)
 
 it = i([0.5, 1, 1.5, 2, 2.5, 3, 4, 5], 1, 6, 2)
 assert_matches_seq(it, [1, 2, 3])
-test_islice_pickle(it)
 
 it = i([1, 2], None)
 assert_matches_seq(it, [1, 2])
-test_islice_pickle(it)
 
 it = i([1, 2, 3], None, None, None)
 assert_matches_seq(it, [1, 2, 3])
-test_islice_pickle(it)
 
 it = i([1, 2, 3], 1, None, None)
 assert_matches_seq(it, [2, 3])
-test_islice_pickle(it)
 
 it = i([1, 2, 3], None, 2, None)
 assert_matches_seq(it, [1, 2])
-test_islice_pickle(it)
 
 it = i([1, 2, 3], None, None, 3)
 assert_matches_seq(it, [1])
-test_islice_pickle(it)
 
 # itertools.filterfalse
 it = itertools.filterfalse(lambda x: x % 2, range(10))
@@ -359,59 +278,6 @@ def test_islice_pickle(it):
 with assert_raises(StopIteration):
     next(it)
 
-it = itertools.dropwhile(underten, [1, 3, 5, 20, 2, 4, 6, 8])
-assert (
-    pickle.dumps(it, 0)
-    == b"citertools\ndropwhile\np0\n(c__main__\nunderten\np1\nc__builtin__\niter\np2\n((lp3\nI1\naI3\naI5\naI20\naI2\naI4\naI6\naI8\natp4\nRp5\nI0\nbtp6\nRp7\nI0\nb."
-)
-assert (
-    pickle.dumps(it, 1)
-    == b"citertools\ndropwhile\nq\x00(c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02(]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08etq\x04Rq\x05K\x00btq\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 2)
-    == b"\x80\x02citertools\ndropwhile\nq\x00c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x00b\x86q\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 3)
-    == b"\x80\x03citertools\ndropwhile\nq\x00c__main__\nunderten\nq\x01cbuiltins\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x00b\x86q\x06Rq\x07K\x00b."
-)
-assert (
-    pickle.dumps(it, 4)
-    == b"\x80\x04\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\tdropwhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x00b\x86\x94R\x94K\x00b."
-)
-assert (
-    pickle.dumps(it, 5)
-    == b"\x80\x05\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\tdropwhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x00b\x86\x94R\x94K\x00b."
-)
-next(it)
-assert (
-    pickle.dumps(it, 0)
-    == b"citertools\ndropwhile\np0\n(c__main__\nunderten\np1\nc__builtin__\niter\np2\n((lp3\nI1\naI3\naI5\naI20\naI2\naI4\naI6\naI8\natp4\nRp5\nI4\nbtp6\nRp7\nI1\nb."
-)
-assert (
-    pickle.dumps(it, 1)
-    == b"citertools\ndropwhile\nq\x00(c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02(]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08etq\x04Rq\x05K\x04btq\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 2)
-    == b"\x80\x02citertools\ndropwhile\nq\x00c__main__\nunderten\nq\x01c__builtin__\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x04b\x86q\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 3)
-    == b"\x80\x03citertools\ndropwhile\nq\x00c__main__\nunderten\nq\x01cbuiltins\niter\nq\x02]q\x03(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85q\x04Rq\x05K\x04b\x86q\x06Rq\x07K\x01b."
-)
-assert (
-    pickle.dumps(it, 4)
-    == b"\x80\x04\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\tdropwhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x04b\x86\x94R\x94K\x01b."
-)
-assert (
-    pickle.dumps(it, 5)
-    == b"\x80\x05\x95i\x00\x00\x00\x00\x00\x00\x00\x8c\titertools\x94\x8c\tdropwhile\x94\x93\x94\x8c\x08__main__\x94\x8c\x08underten\x94\x93\x94\x8c\x08builtins\x94\x8c\x04iter\x94\x93\x94]\x94(K\x01K\x03K\x05K\x14K\x02K\x04K\x06K\x08e\x85\x94R\x94K\x04b\x86\x94R\x94K\x01b."
-)
-for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-    assert next(pickle.loads(pickle.dumps(it, proto))) == 2
-
 
 # itertools.accumulate
 it = itertools.accumulate([6, 3, 7, 1, 0, 9, 8, 8])

From eafa0c01491924da2f11fae3c014f027cc6f653f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:23:22 +0900
Subject: [PATCH 316/418] Fix int rounding

---
 crates/vm/src/builtins/int.rs       | 7 ++++---
 extra_tests/snippets/builtin_int.py | 5 +++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index 9b74b66e3a7..ad897ce0ce9 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -12,7 +12,8 @@ use crate::{
     },
     convert::{IntoPyException, ToPyObject, ToPyResult},
     function::{
-        ArgByteOrder, ArgIntoBool, FuncArgs, OptionalArg, PyArithmeticValue, PyComparisonValue,
+        ArgByteOrder, ArgIntoBool, FuncArgs, OptionalArg, OptionalOption, PyArithmeticValue,
+        PyComparisonValue,
     },
     protocol::{PyNumberMethods, handle_bytes_to_int_err},
     types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
@@ -381,10 +382,10 @@ impl PyInt {
     #[pymethod]
     fn __round__(
         zelf: PyRef<Self>,
-        ndigits: OptionalArg<PyIntRef>,
+        ndigits: OptionalOption<PyIntRef>,
         vm: &VirtualMachine,
     ) -> PyResult<PyRef<Self>> {
-        if let OptionalArg::Present(ndigits) = ndigits {
+        if let Some(ndigits) = ndigits.flatten() {
             let ndigits = ndigits.as_bigint();
             // round(12345, -2) == 12300
             // If precision >= 0, then any integer is already rounded correctly
diff --git a/extra_tests/snippets/builtin_int.py b/extra_tests/snippets/builtin_int.py
index bc3cd5fd996..aab24cbb4cc 100644
--- a/extra_tests/snippets/builtin_int.py
+++ b/extra_tests/snippets/builtin_int.py
@@ -318,8 +318,9 @@ def __int__(self):
 assert isinstance((1).__round__(0), int)
 assert (0).__round__(0) == 0
 assert (1).__round__(0) == 1
-assert_raises(TypeError, lambda: (0).__round__(None))
-assert_raises(TypeError, lambda: (1).__round__(None))
+# Python 3.14+: __round__(None) is now allowed, same as __round__()
+assert (0).__round__(None) == 0
+assert (1).__round__(None) == 1
 assert_raises(TypeError, lambda: (0).__round__(0.0))
 assert_raises(TypeError, lambda: (1).__round__(0.0))
 

From 24bff8d5bf46c1faa337f98967ea764f246aaaa4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:34:53 +0900
Subject: [PATCH 317/418] fix unsigned validation

---
 crates/vm/src/builtins/int.rs         | 7 +++++++
 extra_tests/snippets/stdlib_socket.py | 5 +++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
index ad897ce0ce9..765f5e2454b 100644
--- a/crates/vm/src/builtins/int.rs
+++ b/crates/vm/src/builtins/int.rs
@@ -287,6 +287,13 @@ impl PyInt {
     where
         I: PrimInt + TryFrom<&'a BigInt>,
     {
+        // TODO: Python 3.14+: ValueError for negative int to unsigned type
+        // See stdlib_socket.py socket.htonl(-1)
+        //
+        // if I::min_value() == I::zero() && self.as_bigint().sign() == Sign::Minus {
+        //     return Err(vm.new_value_error("Cannot convert negative int".to_owned()));
+        // }
+
         I::try_from(self.as_bigint()).map_err(|_| {
             vm.new_overflow_error(format!(
                 "Python int too large to convert to Rust {}",
diff --git a/extra_tests/snippets/stdlib_socket.py b/extra_tests/snippets/stdlib_socket.py
index b49fdcf08c2..3f56d2b926e 100644
--- a/extra_tests/snippets/stdlib_socket.py
+++ b/extra_tests/snippets/stdlib_socket.py
@@ -131,8 +131,9 @@
 with assert_raises(OSError):
     socket.inet_aton("test")
 
-with assert_raises(OverflowError):
-    socket.htonl(-1)
+# TODO: RUSTPYTHON
+# with assert_raises(ValueError):
+#     socket.htonl(-1)
 
 assert socket.htonl(0) == 0
 assert socket.htonl(10) == 167772160

From f5b44f505a06695fdcde76f9570a570d279bc3a3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:24:12 +0900
Subject: [PATCH 318/418] Fix Exception.__init__

---
 crates/derive-impl/src/pyclass.rs          |  34 +-----
 crates/stdlib/src/hashlib.rs               |   2 +-
 crates/stdlib/src/ssl/error.rs             |   2 +-
 crates/vm/src/exception_group.rs           |  14 ++-
 crates/vm/src/exceptions.rs                | 129 ++++++++++++++-------
 extra_tests/snippets/builtin_exceptions.py |  39 +++++--
 6 files changed, 135 insertions(+), 85 deletions(-)

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index a81a7bacbad..57cbf67de5a 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -778,36 +778,10 @@ pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> R
         }
     };
 
-    // We need this method, because of how `CPython` copies `__init__`
-    // from `BaseException` in `SimpleExtendsException` macro.
-    // See: `(initproc)BaseException_init`
-    // spell-checker:ignore initproc
-    let slot_init = if with_contains(&with_items, "Initializer") {
-        quote!()
-    } else {
-        with_items.push(Ident::new("Initializer", Span::call_site()));
-        quote! {
-            impl ::rustpython_vm::types::Initializer for #self_ty {
-                type Args = ::rustpython_vm::function::FuncArgs;
-
-                fn slot_init(
-                    zelf: ::rustpython_vm::PyObjectRef,
-                    args: ::rustpython_vm::function::FuncArgs,
-                    vm: &::rustpython_vm::VirtualMachine,
-                ) -> ::rustpython_vm::PyResult<()> {
-                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
-                }
-
-                fn init(
-                    _zelf: ::rustpython_vm::PyRef<Self>,
-                    _args: Self::Args,
-                    _vm: &::rustpython_vm::VirtualMachine
-                ) -> ::rustpython_vm::PyResult<()> {
-                    unreachable!("slot_init is defined")
-                }
-            }
-        }
-    };
+    // SimpleExtendsException: inherits BaseException_init from the base class via MRO.
+    // Only exceptions that explicitly specify `with(Initializer)` will have
+    // their own __init__ in __dict__.
+    let slot_init = quote!();
 
     let extra_attrs_tokens = if extra_attrs.is_empty() {
         quote!()
diff --git a/crates/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
index 2da47ceb740..261663c8564 100644
--- a/crates/stdlib/src/hashlib.rs
+++ b/crates/stdlib/src/hashlib.rs
@@ -11,7 +11,7 @@ pub mod _hashlib {
         class::StaticType,
         convert::ToPyObject,
         function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
-        types::{Constructor, Initializer, Representable},
+        types::{Constructor, Representable},
     };
     use blake2::{Blake2b512, Blake2s256};
     use digest::{DynDigest, core_api::BlockSizeUser};
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
index d77910f6aa1..6219eff41b5 100644
--- a/crates/stdlib/src/ssl/error.rs
+++ b/crates/stdlib/src/ssl/error.rs
@@ -7,7 +7,7 @@ pub(crate) mod ssl_error {
     use crate::vm::{
         Py, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyBaseException, PyOSError, PyStrRef},
-        types::{Constructor, Initializer},
+        types::Constructor,
     };
 
     // Error type constants - exposed as pyattr and available for internal use
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
index a55273480f6..7ad27c078af 100644
--- a/crates/vm/src/exception_group.rs
+++ b/crates/vm/src/exception_group.rs
@@ -348,8 +348,18 @@ pub(super) mod types {
     impl Initializer for PyBaseExceptionGroup {
         type Args = FuncArgs;
 
-        fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
-            // No-op: __new__ already set up the correct args (message, exceptions_tuple)
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // BaseExceptionGroup_init: no kwargs allowed
+            if !args.kwargs.is_empty() {
+                return Err(vm.new_type_error(format!(
+                    "{} does not take keyword arguments",
+                    zelf.class().name()
+                )));
+            }
+            // Do NOT call PyBaseException::slot_init here.
+            // slot_new already set args to (message, exceptions_tuple).
+            // Calling base init would overwrite with original args (message, exceptions_list).
+            let _ = (zelf, args, vm);
             Ok(())
         }
 
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
index a2b08655822..dc25b6d2c03 100644
--- a/crates/vm/src/exceptions.rs
+++ b/crates/vm/src/exceptions.rs
@@ -1086,15 +1086,16 @@ fn syntax_error_set_msg(
 }
 
 fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
-    exc.args.read().first().map(|code| {
-        match_class!(match code {
-            ref tup @ PyTuple => match tup.as_slice() {
-                [x] => x.clone(),
-                _ => code.clone(),
-            },
-            other => other.clone(),
-        })
-    })
+    // SystemExit.code based on args length:
+    // - size == 0: code is None
+    // - size == 1: code is args[0]
+    // - size > 1: code is args (the whole tuple)
+    let args = exc.args.read();
+    match args.len() {
+        0 => None,
+        1 => Some(args.first().unwrap().clone()),
+        _ => Some(args.as_object().to_owned()),
+    }
 }
 
 #[cfg(feature = "serde")]
@@ -1255,7 +1256,7 @@ pub(super) mod types {
         },
         convert::ToPyObject,
         convert::ToPyResult,
-        function::{ArgBytesLike, FuncArgs},
+        function::{ArgBytesLike, FuncArgs, KwArgs},
         types::{Constructor, Initializer},
     };
     use crossbeam_utils::atomic::AtomicCell;
@@ -1393,11 +1394,29 @@ pub(super) mod types {
         pub(super) args: PyRwLock<PyTupleRef>,
     }
 
-    #[pyexception(name, base = PyBaseException, ctx = "system_exit", impl)]
+    #[pyexception(name, base = PyBaseException, ctx = "system_exit")]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PySystemExit(PyBaseException);
 
+    // SystemExit_init: has its own __init__ that sets the code attribute
+    #[pyexception(with(Initializer))]
+    impl PySystemExit {}
+
+    impl Initializer for PySystemExit {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Call BaseException_init first (handles args)
+            PyBaseException::slot_init(zelf, args, vm)
+            // Note: code is computed dynamically via system_exit_code getter
+            // so we don't need to set it here explicitly
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyexception(name, base = PyBaseException, ctx = "generator_exit", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
@@ -1474,16 +1493,25 @@ pub(super) mod types {
         type Args = FuncArgs;
 
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.set_attr(
-                "name",
-                vm.unwrap_or_none(args.kwargs.get("name").cloned()),
-                vm,
-            )?;
-            zelf.set_attr(
-                "obj",
-                vm.unwrap_or_none(args.kwargs.get("obj").cloned()),
-                vm,
-            )?;
+            // Only 'name' and 'obj' kwargs are allowed
+            let mut kwargs = args.kwargs.clone();
+            let name = kwargs.swap_remove("name");
+            let obj = kwargs.swap_remove("obj");
+
+            // Reject unknown kwargs
+            if let Some(invalid_key) = kwargs.keys().next() {
+                return Err(vm.new_type_error(format!(
+                    "AttributeError() got an unexpected keyword argument '{invalid_key}'"
+                )));
+            }
+
+            // Pass args without kwargs to BaseException_init
+            let base_args = FuncArgs::new(args.args.clone(), KwArgs::default());
+            PyBaseException::slot_init(zelf.clone(), base_args, vm)?;
+
+            // Set attributes
+            zelf.set_attr("name", vm.unwrap_or_none(name), vm)?;
+            zelf.set_attr("obj", vm.unwrap_or_none(obj), vm)?;
             Ok(())
         }
 
@@ -1529,9 +1557,11 @@ pub(super) mod types {
         type Args = FuncArgs;
 
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Only 'name', 'path', 'name_from' kwargs are allowed
             let mut kwargs = args.kwargs.clone();
             let name = kwargs.swap_remove("name");
             let path = kwargs.swap_remove("path");
+            let name_from = kwargs.swap_remove("name_from");
 
             // Check for any remaining invalid keyword arguments
             if let Some(invalid_key) = kwargs.keys().next() {
@@ -1543,6 +1573,7 @@ pub(super) mod types {
             let dict = zelf.dict().unwrap();
             dict.set_item("name", vm.unwrap_or_none(name), vm)?;
             dict.set_item("path", vm.unwrap_or_none(path), vm)?;
+            dict.set_item("name_from", vm.unwrap_or_none(name_from), vm)?;
             PyBaseException::slot_init(zelf, args, vm)
         }
 
@@ -1592,11 +1623,45 @@ pub(super) mod types {
     #[repr(transparent)]
     pub struct PyMemoryError(PyException);
 
-    #[pyexception(name, base = PyException, ctx = "name_error", impl)]
+    #[pyexception(name, base = PyException, ctx = "name_error")]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PyNameError(PyException);
 
+    // NameError_init: handles the .name. kwarg
+    #[pyexception(with(Initializer))]
+    impl PyNameError {}
+
+    impl Initializer for PyNameError {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Only 'name' kwarg is allowed
+            let mut kwargs = args.kwargs.clone();
+            let name = kwargs.swap_remove("name");
+
+            // Reject unknown kwargs
+            if let Some(invalid_key) = kwargs.keys().next() {
+                return Err(vm.new_type_error(format!(
+                    "NameError() got an unexpected keyword argument '{invalid_key}'"
+                )));
+            }
+
+            // Pass args without kwargs to BaseException_init
+            let base_args = FuncArgs::new(args.args.clone(), KwArgs::default());
+            PyBaseException::slot_init(zelf.clone(), base_args, vm)?;
+
+            // Set name attribute if provided
+            if let Some(name) = name {
+                zelf.set_attr("name", name, vm)?;
+            }
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
     #[pyexception(name, base = PyNameError, ctx = "unbound_local_error", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
@@ -2232,31 +2297,17 @@ pub(super) mod types {
         }
     }
 
+    // MiddlingExtendsException: inherits __init__ from SyntaxError via MRO
     #[pyexception(
         name = "_IncompleteInputError",
         base = PySyntaxError,
-        ctx = "incomplete_input_error"
+        ctx = "incomplete_input_error",
+        impl
     )]
     #[derive(Debug)]
     #[repr(transparent)]
     pub struct PyIncompleteInputError(PySyntaxError);
 
-    #[pyexception(with(Initializer))]
-    impl PyIncompleteInputError {}
-
-    impl Initializer for PyIncompleteInputError {
-        type Args = FuncArgs;
-
-        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.set_attr("name", vm.ctx.new_str("SyntaxError"), vm)?;
-            PySyntaxError::slot_init(zelf, args, vm)
-        }
-
-        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
-            unreachable!("slot_init is defined")
-        }
-    }
-
     #[pyexception(name, base = PySyntaxError, ctx = "indentation_error", impl)]
     #[derive(Debug)]
     #[repr(transparent)]
diff --git a/extra_tests/snippets/builtin_exceptions.py b/extra_tests/snippets/builtin_exceptions.py
index 246be3b8fda..8879e130bc2 100644
--- a/extra_tests/snippets/builtin_exceptions.py
+++ b/extra_tests/snippets/builtin_exceptions.py
@@ -239,12 +239,10 @@ class SubError(MyError):
     raise e
 except MyError as exc:
     # It was a segmentation fault before, will print info to stdout:
-    if platform.python_implementation() == "RustPython":
-        # For some reason `CPython` hangs on this code:
-        sys.excepthook(type(exc), exc, exc.__traceback__)
-        assert isinstance(exc, MyError)
-        assert exc.__cause__ is None
-        assert exc.__context__ is e
+    sys.excepthook(type(exc), exc, exc.__traceback__)
+    assert isinstance(exc, MyError)
+    assert exc.__cause__ is None
+    assert exc.__context__ is e
 
 
 # Regression to
@@ -255,26 +253,42 @@ class SubError(MyError):
 assert BaseException.__init__.__qualname__ == "BaseException.__init__"
 assert BaseException().__dict__ == {}
 
+# Exception inherits __init__ from BaseException
 assert Exception.__new__.__qualname__ == "Exception.__new__", (
     Exception.__new__.__qualname__
 )
-assert Exception.__init__.__qualname__ == "Exception.__init__", (
+assert Exception.__init__.__qualname__ == "BaseException.__init__", (
     Exception.__init__.__qualname__
 )
 assert Exception().__dict__ == {}
 
 
-# Extends `BaseException`, simple:
+# Extends `BaseException`, simple - inherits __init__ from BaseException:
 assert KeyboardInterrupt.__new__.__qualname__ == "KeyboardInterrupt.__new__", (
     KeyboardInterrupt.__new__.__qualname__
 )
-assert KeyboardInterrupt.__init__.__qualname__ == "KeyboardInterrupt.__init__"
+assert KeyboardInterrupt.__init__.__qualname__ == "BaseException.__init__"
 assert KeyboardInterrupt().__dict__ == {}
 
 
-# Extends `Exception`, simple:
+# Extends `BaseException`, complex - has its own __init__:
+# SystemExit_init sets self.code based on args length
+assert SystemExit.__init__.__qualname__ == "SystemExit.__init__"
+assert SystemExit.__dict__.get("__init__") is not None, (
+    "SystemExit must have its own __init__"
+)
+assert SystemExit.__init__ is not BaseException.__init__
+assert SystemExit().__dict__ == {}
+# SystemExit.code behavior:
+assert SystemExit().code is None
+assert SystemExit(1).code == 1
+assert SystemExit(1, 2).code == (1, 2)
+assert SystemExit(1, 2, 3).code == (1, 2, 3)
+
+
+# Extends `Exception`, simple - inherits __init__ from BaseException:
 assert TypeError.__new__.__qualname__ == "TypeError.__new__"
-assert TypeError.__init__.__qualname__ == "TypeError.__init__"
+assert TypeError.__init__.__qualname__ == "BaseException.__init__"
 assert TypeError().__dict__ == {}
 
 
@@ -356,7 +370,8 @@ class SubError(MyError):
 # Custom `__new__` and `__init__`:
 assert ImportError.__init__.__qualname__ == "ImportError.__init__"
 assert ImportError(name="a").name == "a"
-assert ModuleNotFoundError.__init__.__qualname__ == "ModuleNotFoundError.__init__"
+# ModuleNotFoundError inherits __init__ from ImportError via MRO (MiddlingExtendsException)
+assert ModuleNotFoundError.__init__.__qualname__ == "ImportError.__init__"
 assert ModuleNotFoundError(name="a").name == "a"
 
 

From 0793bd3d086dd5275b80b44ad14ecdfd94cde9ee Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:46:37 +0900
Subject: [PATCH 319/418] co_consts

---
 crates/codegen/src/compile.rs               |  34 +++----
 crates/compiler-core/src/bytecode.rs        |   5 +-
 crates/compiler-core/src/marshal.rs         |   4 +-
 crates/vm/src/builtins/code.rs              |   6 +-
 crates/vm/src/builtins/function.rs          |  13 ++-
 crates/vm/src/builtins/object.rs            |  14 ++-
 extra_tests/snippets/code_co_consts.py      | 105 +++++++++++++++++---
 extra_tests/snippets/example_interactive.py |   4 +-
 8 files changed, 138 insertions(+), 47 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 7782e6ec485..b0608d11513 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -3306,12 +3306,19 @@ impl Compiler {
         // Set qualname
         self.set_qualname();
 
-        // Handle docstring
+        // Handle docstring - store in co_consts[0] if present
         let (doc_str, body) = split_doc(body, &self.opts);
-        self.current_code_info()
-            .metadata
-            .consts
-            .insert_full(ConstantData::None);
+        if let Some(doc) = &doc_str {
+            // Docstring present: store in co_consts[0] and set HAS_DOCSTRING flag
+            self.current_code_info()
+                .metadata
+                .consts
+                .insert_full(ConstantData::Str {
+                    value: doc.to_string().into(),
+                });
+            self.current_code_info().flags |= bytecode::CodeFlags::HAS_DOCSTRING;
+        }
+        // If no docstring, don't add None to co_consts
 
         // Compile body statements
         self.compile_statements(body)?;
@@ -3331,16 +3338,8 @@ impl Compiler {
         // Create function object with closure
         self.make_closure(code, funcflags)?;
 
-        // Handle docstring if present
-        if let Some(doc) = doc_str {
-            emit!(self, Instruction::Copy { index: 1_u32 });
-            self.emit_load_const(ConstantData::Str {
-                value: doc.to_string().into(),
-            });
-            emit!(self, Instruction::Swap { index: 2 });
-            let doc_attr = self.name("__doc__");
-            emit!(self, Instruction::StoreAttr { idx: doc_attr });
-        }
+        // Note: docstring is now retrieved from co_consts[0] by the VM
+        // when HAS_DOCSTRING flag is set, so no runtime __doc__ assignment needed
 
         Ok(())
     }
@@ -6100,10 +6099,7 @@ impl Compiler {
                     in_async_scope: false,
                 };
 
-                self.current_code_info()
-                    .metadata
-                    .consts
-                    .insert_full(ConstantData::None);
+                // Lambda cannot have docstrings, so no None is added to co_consts
 
                 self.compile_expression(body)?;
                 self.emit_return_value();
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index a0054b28877..c59a64fea3d 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -290,13 +290,16 @@ pub struct CodeObject<C: Constant = ConstantData> {
 
 bitflags! {
     #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct CodeFlags: u16 {
+    pub struct CodeFlags: u32 {
         const OPTIMIZED = 0x0001;
         const NEWLOCALS = 0x0002;
         const VARARGS = 0x0004;
         const VARKEYWORDS = 0x0008;
         const GENERATOR = 0x0020;
         const COROUTINE = 0x0080;
+        /// If a code object represents a function and has a docstring,
+        /// this bit is set and the first item in co_consts is the docstring.
+        const HAS_DOCSTRING = 0x4000000;
     }
 }
 
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
index 5b528fe7e50..d9bf368ecab 100644
--- a/crates/compiler-core/src/marshal.rs
+++ b/crates/compiler-core/src/marshal.rs
@@ -202,7 +202,7 @@ pub fn deserialize_code<R: Read, Bag: ConstantBag>(
         })
         .collect::<Result<Box<[(SourceLocation, SourceLocation)]>>>()?;
 
-    let flags = CodeFlags::from_bits_truncate(rdr.read_u16()?);
+    let flags = CodeFlags::from_bits_truncate(rdr.read_u32()?);
 
     let posonlyarg_count = rdr.read_u32()?;
     let arg_count = rdr.read_u32()?;
@@ -660,7 +660,7 @@ pub fn serialize_code<W: Write, C: Constant>(buf: &mut W, code: &CodeObject<C>)
         buf.write_u32(end.character_offset.to_zero_indexed() as _);
     }
 
-    buf.write_u16(code.flags.bits());
+    buf.write_u32(code.flags.bits());
 
     buf.write_u32(code.posonlyarg_count);
     buf.write_u32(code.arg_count);
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index 85816aabb7c..6507af342c1 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -152,7 +152,7 @@ pub struct ReplaceArgs {
     #[pyarg(named, optional)]
     co_names: OptionalArg<Vec<PyObjectRef>>,
     #[pyarg(named, optional)]
-    co_flags: OptionalArg<u16>,
+    co_flags: OptionalArg<u32>,
     #[pyarg(named, optional)]
     co_varnames: OptionalArg<Vec<PyObjectRef>>,
     #[pyarg(named, optional)]
@@ -411,7 +411,7 @@ pub struct PyCodeNewArgs {
     kwonlyargcount: u32,
     nlocals: u32,
     stacksize: u32,
-    flags: u16,
+    flags: u32,
     co_code: PyBytesRef,
     consts: PyTupleRef,
     names: PyTupleRef,
@@ -628,7 +628,7 @@ impl PyCode {
     }
 
     #[pygetset]
-    const fn co_flags(&self) -> u16 {
+    const fn co_flags(&self) -> u32 {
         self.code.flags.bits()
     }
 
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 3d5159e58c1..27a3b8fee5f 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -77,6 +77,17 @@ impl PyFunction {
             builtins
         };
 
+        // Get docstring from co_consts[0] if HAS_DOCSTRING flag is set
+        let doc = if code.code.flags.contains(bytecode::CodeFlags::HAS_DOCSTRING) {
+            code.code
+                .constants
+                .first()
+                .map(|c| c.as_object().to_owned())
+                .unwrap_or_else(|| vm.ctx.none())
+        } else {
+            vm.ctx.none()
+        };
+
         let qualname = vm.ctx.new_str(code.qualname.as_str());
         let func = Self {
             code: PyMutex::new(code.clone()),
@@ -89,7 +100,7 @@ impl PyFunction {
             type_params: PyMutex::new(vm.ctx.empty_tuple.clone()),
             annotations: PyMutex::new(vm.ctx.new_dict()),
             module: PyMutex::new(module),
-            doc: PyMutex::new(vm.ctx.none()),
+            doc: PyMutex::new(doc),
             #[cfg(feature = "jit")]
             jitted_code: OnceCell::new(),
         };
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
index 982e11afd00..eb9d226acb4 100644
--- a/crates/vm/src/builtins/object.rs
+++ b/crates/vm/src/builtins/object.rs
@@ -244,6 +244,12 @@ fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine)
             let slots = vm.ctx.new_dict();
             for i in 0..slot_names_len {
                 let borrowed_names = slot_names.borrow_vec();
+                // Check if slotnames changed during iteration
+                if borrowed_names.len() != slot_names_len {
+                    return Err(vm.new_runtime_error(
+                        "__slotnames__ changed size during iteration".to_owned(),
+                    ));
+                }
                 let name = borrowed_names[i].downcast_ref::<PyStr>().unwrap();
                 let Ok(value) = obj.get_attr(name, vm) else {
                     continue;
@@ -702,11 +708,13 @@ fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 
         (newobj, newargs.into())
     } else {
+        // args == NULL with non-empty kwargs is BadInternalCall
+        let Some(args) = args else {
+            return Err(vm.new_system_error("bad internal call".to_owned()));
+        };
         // Use copyreg.__newobj_ex__
         let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
-        let args_tuple: PyObjectRef = args
-            .map(|a| a.into())
-            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into());
+        let args_tuple: PyObjectRef = args.into();
         let kwargs_dict: PyObjectRef = kwargs
             .map(|k| k.into())
             .unwrap_or_else(|| vm.ctx.new_dict().into());
diff --git a/extra_tests/snippets/code_co_consts.py b/extra_tests/snippets/code_co_consts.py
index 58355652682..13f76a0d13e 100644
--- a/extra_tests/snippets/code_co_consts.py
+++ b/extra_tests/snippets/code_co_consts.py
@@ -1,39 +1,112 @@
+"""
+Test co_consts behavior for Python 3.14+
+
+In Python 3.14+:
+- Functions with docstrings have the docstring as co_consts[0]
+- CO_HAS_DOCSTRING flag (0x4000000) indicates docstring presence
+- Functions without docstrings do NOT have None added as placeholder for docstring
+
+Note: Other constants (small integers, code objects, etc.) may still appear in co_consts
+depending on optimization level. This test focuses on docstring behavior.
+"""
+
+
+# Test function with docstring - docstring should be co_consts[0]
+def with_doc():
+    """This is a docstring"""
+    return 1
+
+
+assert with_doc.__code__.co_consts[0] == "This is a docstring", (
+    with_doc.__code__.co_consts
+)
+assert with_doc.__doc__ == "This is a docstring"
+# Check CO_HAS_DOCSTRING flag (0x4000000)
+assert with_doc.__code__.co_flags & 0x4000000, hex(with_doc.__code__.co_flags)
+
+
+# Test function without docstring - should NOT have HAS_DOCSTRING flag
+def no_doc():
+    return 1
+
+
+assert not (no_doc.__code__.co_flags & 0x4000000), hex(no_doc.__code__.co_flags)
+assert no_doc.__doc__ is None
+
+
+# Test async function with docstring
 from asyncio import sleep
 
 
-def f():
-    def g():
-        return 1
+async def async_with_doc():
+    """Async docstring"""
+    await sleep(1)
+    return 1
 
-    assert g.__code__.co_consts[0] == None
-    return 2
 
+assert async_with_doc.__code__.co_consts[0] == "Async docstring", (
+    async_with_doc.__code__.co_consts
+)
+assert async_with_doc.__doc__ == "Async docstring"
+assert async_with_doc.__code__.co_flags & 0x4000000
 
-assert f.__code__.co_consts[0] == None
 
+# Test async function without docstring
+async def async_no_doc():
+    await sleep(1)
+    return 1
+
+
+assert not (async_no_doc.__code__.co_flags & 0x4000000)
+assert async_no_doc.__doc__ is None
 
-def generator():
+
+# Test generator with docstring
+def gen_with_doc():
+    """Generator docstring"""
     yield 1
     yield 2
 
 
-assert generator().gi_code.co_consts[0] == None
+assert gen_with_doc.__code__.co_consts[0] == "Generator docstring"
+assert gen_with_doc.__doc__ == "Generator docstring"
+assert gen_with_doc.__code__.co_flags & 0x4000000
 
 
-async def async_f():
-    await sleep(1)
-    return 1
+# Test generator without docstring
+def gen_no_doc():
+    yield 1
+    yield 2
+
 
+assert not (gen_no_doc.__code__.co_flags & 0x4000000)
+assert gen_no_doc.__doc__ is None
 
-assert async_f.__code__.co_consts[0] == None
 
+# Test lambda - cannot have docstring
 lambda_f = lambda: 0
-assert lambda_f.__code__.co_consts[0] == None
+assert not (lambda_f.__code__.co_flags & 0x4000000)
+assert lambda_f.__doc__ is None
+
+
+# Test class method with docstring
+class cls_with_doc:
+    def method():
+        """Method docstring"""
+        return 1
+
 
+assert cls_with_doc.method.__code__.co_consts[0] == "Method docstring"
+assert cls_with_doc.method.__doc__ == "Method docstring"
 
-class cls:
-    def f():
+
+# Test class method without docstring
+class cls_no_doc:
+    def method():
         return 1
 
 
-assert cls().f.__code__.co_consts[0] == None
+assert not (cls_no_doc.method.__code__.co_flags & 0x4000000)
+assert cls_no_doc.method.__doc__ is None
+
+print("All co_consts tests passed!")
diff --git a/extra_tests/snippets/example_interactive.py b/extra_tests/snippets/example_interactive.py
index f9484f15dcf..5958dd11707 100644
--- a/extra_tests/snippets/example_interactive.py
+++ b/extra_tests/snippets/example_interactive.py
@@ -4,7 +4,7 @@
 
 
 def f(x, y, *args, power=1, **kwargs):
-    print("Constant String", 2, None, (2, 4))
+    print("Constant String", 256, None, (2, 4))
     assert code_class == type(c1)
     z = x * y
     return z**power
@@ -19,7 +19,7 @@ def f(x, y, *args, power=1, **kwargs):
 # assert isinstance(c2.co_code, bytes)
 assert "Constant String" in c2.co_consts, c2.co_consts
 print(c2.co_consts)
-assert 2 in c2.co_consts, c2.co_consts
+assert 256 in c2.co_consts, c2.co_consts
 assert "example_interactive.py" in c2.co_filename
 assert c2.co_firstlineno == 6, str(c2.co_firstlineno)
 # assert isinstance(c2.co_flags, int) # 'OPTIMIZED, NEWLOCALS, NOFREE'

From fdfede75457fe1cae50800e301f3f990f1f07f69 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Fri, 16 Jan 2026 13:07:12 +0900
Subject: [PATCH 320/418] fix win clippy

---
 crates/vm/src/stdlib/thread.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index db588e5eab7..9f0c0535d71 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -1,8 +1,10 @@
 //! Implementation of the _thread module
+#[cfg(unix)]
+pub(crate) use _thread::after_fork_child;
 #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
 pub(crate) use _thread::{
-    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, after_fork_child,
-    get_all_current_frames, get_ident, init_main_thread_ident, make_module,
+    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, get_all_current_frames, get_ident,
+    init_main_thread_ident, make_module,
 };
 
 #[pymodule]
@@ -882,6 +884,7 @@ pub(crate) mod _thread {
 
     /// Called after fork() in child process to mark all other threads as done.
     /// This prevents join() from hanging on threads that don't exist in the child.
+    #[cfg(unix)]
     pub fn after_fork_child(vm: &VirtualMachine) {
         let current_ident = get_ident();
 

From 51b628642cc04a1a073a8e7de5c7f4a2274476d3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:03:57 +0900
Subject: [PATCH 321/418] PEP 649 annotation phase 1

---
 crates/vm/src/builtins/function.rs |  93 ++++++++++++++++++++--
 crates/vm/src/builtins/module.rs   |  97 ++++++++++++++++++++++-
 crates/vm/src/builtins/type.rs     | 123 +++++++++++++++++++++++------
 crates/vm/src/vm/context.rs        |   3 +
 4 files changed, 285 insertions(+), 31 deletions(-)

diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 27a3b8fee5f..01ef987ae39 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -36,7 +36,8 @@ pub struct PyFunction {
     name: PyMutex<PyStrRef>,
     qualname: PyMutex<PyStrRef>,
     type_params: PyMutex<PyTupleRef>,
-    annotations: PyMutex<PyDictRef>,
+    annotations: PyMutex<Option<PyDictRef>>,
+    annotate: PyMutex<Option<PyObjectRef>>,
     module: PyMutex<PyObjectRef>,
     doc: PyMutex<PyObjectRef>,
     #[cfg(feature = "jit")]
@@ -98,7 +99,8 @@ impl PyFunction {
             name,
             qualname: PyMutex::new(qualname),
             type_params: PyMutex::new(vm.ctx.empty_tuple.clone()),
-            annotations: PyMutex::new(vm.ctx.new_dict()),
+            annotations: PyMutex::new(None),
+            annotate: PyMutex::new(None),
             module: PyMutex::new(module),
             doc: PyMutex::new(doc),
             #[cfg(feature = "jit")]
@@ -375,7 +377,7 @@ impl PyFunction {
                     )));
                 }
             };
-            *self.annotations.lock() = annotations;
+            *self.annotations.lock() = Some(annotations);
         } else if attr == bytecode::MakeFunctionFlags::CLOSURE {
             // For closure, we need special handling
             // The closure tuple contains cell objects
@@ -585,13 +587,90 @@ impl PyFunction {
     }
 
     #[pygetset]
-    fn __annotations__(&self) -> PyDictRef {
-        self.annotations.lock().clone()
+    fn __annotations__(&self, vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        let mut annotations = self.annotations.lock();
+        let annotate = self.annotate.lock();
+
+        if annotations.is_none() {
+            // If we have a callable __annotate__, call it to get annotations
+            if let Some(ref annotate_fn) = *annotate {
+                if annotate_fn.is_callable() {
+                    // Call __annotate__(1) where 1 = Format.VALUE
+                    let one = vm.ctx.new_int(1);
+                    let ann_dict = annotate_fn.call((one,), vm)?;
+                    let ann_dict =
+                        ann_dict
+                            .downcast::<crate::builtins::PyDict>()
+                            .map_err(|obj| {
+                                vm.new_type_error(format!(
+                                    "__annotate__ returned non-dict of type '{}'",
+                                    obj.class().name()
+                                ))
+                            })?;
+                    *annotations = Some(ann_dict.clone());
+                    return Ok(ann_dict);
+                }
+            }
+            // No __annotate__ or not callable, create empty dict
+            let new_dict = vm.ctx.new_dict();
+            *annotations = Some(new_dict.clone());
+            return Ok(new_dict);
+        }
+
+        Ok(annotations.clone().unwrap())
+    }
+
+    #[pygetset(setter)]
+    fn set___annotations__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                if vm.is_none(&value) {
+                    *self.annotations.lock() = None;
+                } else {
+                    let annotations =
+                        value.downcast::<crate::builtins::PyDict>().map_err(|_| {
+                            vm.new_type_error("__annotations__ must be set to a dict object")
+                        })?;
+                    *self.annotations.lock() = Some(annotations);
+                }
+                // Clear __annotate__ when __annotations__ is set
+                *self.annotate.lock() = None;
+            }
+            PySetterValue::Delete => {
+                *self.annotations.lock() = None;
+                *self.annotate.lock() = None;
+            }
+        }
+        Ok(())
+    }
+
+    #[pygetset]
+    fn __annotate__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        self.annotate
+            .lock()
+            .clone()
+            .unwrap_or_else(|| vm.ctx.none())
     }
 
     #[pygetset(setter)]
-    fn set___annotations__(&self, annotations: PyDictRef) {
-        *self.annotations.lock() = annotations
+    fn set___annotate__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                if vm.is_none(&value) {
+                    *self.annotate.lock() = Some(value);
+                } else if value.is_callable() {
+                    *self.annotate.lock() = Some(value);
+                    // Clear cached __annotations__ when __annotate__ is set
+                    *self.annotations.lock() = None;
+                } else {
+                    return Err(vm.new_type_error("__annotate__ must be callable or None"));
+                }
+            }
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("__annotate__ cannot be deleted"));
+            }
+        }
+        Ok(())
     }
 
     #[pygetset]
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
index faa6e4813fd..2f0592f4e1b 100644
--- a/crates/vm/src/builtins/module.rs
+++ b/crates/vm/src/builtins/module.rs
@@ -4,7 +4,7 @@ use crate::{
     builtins::{PyStrInterned, pystr::AsPyStr},
     class::PyClassImpl,
     convert::ToPyObject,
-    function::{FuncArgs, PyMethodDef},
+    function::{FuncArgs, PyMethodDef, PySetterValue},
     types::{GetAttr, Initializer, Representable},
 };
 
@@ -182,6 +182,101 @@ impl PyModule {
         let attrs = dict.into_iter().map(|(k, _v)| k).collect();
         Ok(attrs)
     }
+
+    #[pygetset]
+    fn __annotate__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let dict = zelf.dict();
+        // Get __annotate__ from dict, set to None if not present
+        if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
+            Ok(annotate)
+        } else {
+            let none = vm.ctx.none();
+            dict.set_item(identifier!(vm, __annotate__), none.clone(), vm)?;
+            Ok(none)
+        }
+    }
+
+    #[pygetset(setter)]
+    fn set___annotate__(
+        zelf: &Py<Self>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                if !vm.is_none(&value) && !value.is_callable() {
+                    return Err(vm.new_type_error("__annotate__ must be callable or None"));
+                }
+                let dict = zelf.dict();
+                dict.set_item(identifier!(vm, __annotate__), value.clone(), vm)?;
+                // Clear __annotations__ if value is not None
+                if !vm.is_none(&value) {
+                    dict.del_item(identifier!(vm, __annotations__), vm).ok();
+                }
+                Ok(())
+            }
+            PySetterValue::Delete => Err(vm.new_type_error("cannot delete __annotate__ attribute")),
+        }
+    }
+
+    #[pygetset]
+    fn __annotations__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let dict = zelf.dict();
+
+        // Check if __annotations__ is already in dict
+        if let Some(annotations) = dict.get_item_opt(identifier!(vm, __annotations__), vm)? {
+            return Ok(annotations);
+        }
+
+        // Get __annotate__ and call it if callable
+        let annotations =
+            if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
+                if annotate.is_callable() {
+                    // Call __annotate__(1) where 1 is FORMAT_VALUE
+                    let result = annotate.call((1i32,), vm)?;
+                    if !result.class().is(vm.ctx.types.dict_type) {
+                        return Err(vm.new_type_error(format!(
+                            "__annotate__ returned non-dict of type '{}'",
+                            result.class().name()
+                        )));
+                    }
+                    result
+                } else {
+                    vm.ctx.new_dict().into()
+                }
+            } else {
+                vm.ctx.new_dict().into()
+            };
+
+        // Cache the result (TODO: check if module is initializing)
+        dict.set_item(identifier!(vm, __annotations__), annotations.clone(), vm)?;
+        Ok(annotations)
+    }
+
+    #[pygetset(setter)]
+    fn set___annotations__(
+        zelf: &Py<Self>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let dict = zelf.dict();
+        match value {
+            PySetterValue::Assign(value) => {
+                dict.set_item(identifier!(vm, __annotations__), value, vm)?;
+                // Clear __annotate__ from dict
+                dict.del_item(identifier!(vm, __annotate__), vm).ok();
+                Ok(())
+            }
+            PySetterValue::Delete => {
+                if dict.del_item(identifier!(vm, __annotations__), vm).is_err() {
+                    return Err(vm.new_attribute_error("__annotations__".to_owned()));
+                }
+                // Also clear __annotate__
+                dict.del_item(identifier!(vm, __annotate__), vm).ok();
+                Ok(())
+            }
+        }
+    }
 }
 
 impl Initializer for PyModule {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index fed9af976f6..4bc326b38a2 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -851,6 +851,62 @@ impl PyType {
         Ok(())
     }
 
+    #[pygetset]
+    fn __annotate__(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
+            return Err(vm.new_attribute_error(format!(
+                "type object '{}' has no attribute '__annotate__'",
+                self.name()
+            )));
+        }
+
+        let attrs = self.attributes.read();
+        // First try __annotate__, in case that's been set explicitly
+        if let Some(annotate) = attrs.get(identifier!(vm, __annotate__)).cloned() {
+            return Ok(annotate);
+        }
+        // Then try __annotate_func__
+        if let Some(annotate) = attrs.get(identifier!(vm, __annotate_func__)).cloned() {
+            return Ok(annotate);
+        }
+        drop(attrs);
+
+        // Set None if not found
+        let none = vm.ctx.none();
+        self.attributes
+            .write()
+            .insert(identifier!(vm, __annotate_func__), none.clone());
+        Ok(none)
+    }
+
+    #[pygetset(setter)]
+    fn set___annotate__(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
+        if value.is_none() {
+            return Err(vm.new_type_error("cannot delete __annotate__ attribute".to_owned()));
+        }
+        let value = value.unwrap();
+
+        if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            return Err(vm.new_type_error(format!(
+                "cannot set '__annotate__' attribute of immutable type '{}'",
+                self.name()
+            )));
+        }
+
+        if !vm.is_none(&value) && !value.is_callable() {
+            return Err(vm.new_type_error("__annotate__ must be callable or None".to_owned()));
+        }
+
+        let mut attrs = self.attributes.write();
+        attrs.insert(identifier!(vm, __annotate_func__), value.clone());
+        // Clear cached annotations if value is not None
+        if !vm.is_none(&value) {
+            attrs.swap_remove(identifier!(vm, __annotations_cache__));
+        }
+
+        Ok(())
+    }
+
     #[pygetset]
     fn __annotations__(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
@@ -860,20 +916,37 @@ impl PyType {
             )));
         }
 
-        let __annotations__ = identifier!(vm, __annotations__);
-        let annotations = self.attributes.read().get(__annotations__).cloned();
+        // First try __annotations__ (e.g. for "from __future__ import annotations")
+        let attrs = self.attributes.read();
+        if let Some(annotations) = attrs.get(identifier!(vm, __annotations__)).cloned() {
+            return Ok(annotations);
+        }
+        // Then try __annotations_cache__
+        if let Some(annotations) = attrs.get(identifier!(vm, __annotations_cache__)).cloned() {
+            return Ok(annotations);
+        }
+        drop(attrs);
 
-        let annotations = if let Some(annotations) = annotations {
-            annotations
+        // Get __annotate__ and call it if callable
+        let annotate = self.__annotate__(vm)?;
+        let annotations = if annotate.is_callable() {
+            // Call __annotate__(1) where 1 is FORMAT_VALUE
+            let result = annotate.call((1i32,), vm)?;
+            if !result.class().is(vm.ctx.types.dict_type) {
+                return Err(vm.new_type_error(format!(
+                    "__annotate__ returned non-dict of type '{}'",
+                    result.class().name()
+                )));
+            }
+            result
         } else {
-            let annotations: PyObjectRef = vm.ctx.new_dict().into();
-            let removed = self
-                .attributes
-                .write()
-                .insert(__annotations__, annotations.clone());
-            debug_assert!(removed.is_none());
-            annotations
+            vm.ctx.new_dict().into()
         };
+
+        // Cache the result in __annotations_cache__
+        self.attributes
+            .write()
+            .insert(identifier!(vm, __annotations_cache__), annotations.clone());
         Ok(annotations)
     }
 
@@ -886,20 +959,24 @@ impl PyType {
             )));
         }
 
-        let __annotations__ = identifier!(vm, __annotations__);
+        let mut attrs = self.attributes.write();
         if let Some(value) = value {
-            self.attributes.write().insert(__annotations__, value);
+            attrs.insert(identifier!(vm, __annotations__), value);
+            // Clear __annotate__ when __annotations__ is set
+            attrs.swap_remove(identifier!(vm, __annotate__));
         } else {
-            self.attributes
-                .read()
-                .get(__annotations__)
-                .cloned()
-                .ok_or_else(|| {
-                    vm.new_attribute_error(format!(
-                        "'{}' object has no attribute '__annotations__'",
-                        self.name()
-                    ))
-                })?;
+            // Delete
+            if attrs
+                .swap_remove(identifier!(vm, __annotations__))
+                .is_none()
+            {
+                return Err(vm.new_attribute_error(format!(
+                    "'{}' object has no attribute '__annotations__'",
+                    self.name()
+                )));
+            }
+            // Also clear __annotate__
+            attrs.swap_remove(identifier!(vm, __annotate__));
         }
 
         Ok(())
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index 65c742e4915..9978554bcc4 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -91,7 +91,10 @@ declare_const_name! {
     __all__,
     __and__,
     __anext__,
+    __annotate__,
+    __annotate_func__,
     __annotations__,
+    __annotations_cache__,
     __args__,
     __await__,
     __bases__,

From 353a9f61043bea82a61ae1f783da813f81ad2692 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:16:02 +0900
Subject: [PATCH 322/418] PEP 649 annotation phase 2

---
 crates/codegen/src/compile.rs              | 91 ++++++++++++++++++++++
 crates/compiler-core/src/bytecode/oparg.rs |  2 +
 crates/vm/src/builtins/function.rs         | 72 ++++++++++-------
 crates/vm/src/builtins/type.rs             |  6 +-
 4 files changed, 141 insertions(+), 30 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index b0608d11513..776b5f820da 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -3384,6 +3384,94 @@ impl Compiler {
         Ok(num_annotations)
     }
 
+    /// Compile function annotations as a closure (PEP 649)
+    /// Returns true if an __annotate__ closure was created
+    /// NOTE: This requires symbol table support for annotation scopes.
+    /// Currently unused - kept for future implementation reference.
+    #[allow(dead_code, clippy::cast_possible_truncation)]
+    fn compile_annotations_closure(
+        &mut self,
+        func_name: &str,
+        parameters: &Parameters,
+        returns: Option<&Expr>,
+    ) -> CompileResult<bool> {
+        // Count annotations first
+        let parameters_iter = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .chain(&parameters.kwonlyargs)
+            .map(|x| &x.parameter)
+            .chain(parameters.vararg.as_deref())
+            .chain(parameters.kwarg.as_deref());
+
+        let num_annotations: u32 = parameters_iter.filter(|p| p.annotation.is_some()).count()
+            as u32
+            + if returns.is_some() { 1 } else { 0 };
+
+        if num_annotations == 0 {
+            return Ok(false);
+        }
+
+        // Create a new scope for the __annotate__ function
+        let annotate_name = format!("<annotate of {func_name}>");
+        self.push_output(
+            bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
+            0, // posonlyarg_count
+            1, // arg_count (format parameter)
+            0, // kwonlyarg_count
+            annotate_name,
+        )?;
+
+        // Add 'format' parameter to varnames
+        self.current_code_info()
+            .metadata
+            .varnames
+            .insert("format".to_owned());
+
+        // Compile annotations inside the new scope
+        let parameters_iter = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .chain(&parameters.kwonlyargs)
+            .map(|x| &x.parameter)
+            .chain(parameters.vararg.as_deref())
+            .chain(parameters.kwarg.as_deref());
+
+        for param in parameters_iter {
+            if let Some(annotation) = &param.annotation {
+                self.emit_load_const(ConstantData::Str {
+                    value: self.mangle(param.name.as_str()).into_owned().into(),
+                });
+                self.compile_annotation(annotation)?;
+            }
+        }
+
+        // Handle return annotation
+        if let Some(annotation) = returns {
+            self.emit_load_const(ConstantData::Str {
+                value: "return".into(),
+            });
+            self.compile_annotation(annotation)?;
+        }
+
+        // Build the map and return it
+        emit!(
+            self,
+            Instruction::BuildMap {
+                size: num_annotations,
+            }
+        );
+        emit!(self, Instruction::ReturnValue);
+
+        // Exit the scope and get the code object
+        let annotate_code = self.exit_scope();
+
+        // Make a closure from the code object
+        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
+
+        Ok(true)
+    }
+
     // = compiler_function
     #[allow(clippy::too_many_arguments)]
     fn compile_function_def(
@@ -3449,6 +3537,9 @@ impl Compiler {
         }
 
         // Compile annotations
+        // TODO: Full PEP 649 deferred annotation compilation requires symbol table changes.
+        // Currently using immediate evaluation (like PEP 563 without string conversion).
+        // The __annotate__ infrastructure is in place in function.rs, module.rs, type.rs.
         let mut annotations_flag = bytecode::MakeFunctionFlags::empty();
         let num_annotations = self.visit_annotations(parameters, returns)?;
         if num_annotations > 0 {
diff --git a/crates/compiler-core/src/bytecode/oparg.rs b/crates/compiler-core/src/bytecode/oparg.rs
index c662a0a9260..3130da59750 100644
--- a/crates/compiler-core/src/bytecode/oparg.rs
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -327,6 +327,8 @@ bitflags! {
         const KW_ONLY_DEFAULTS = 0x04;
         const DEFAULTS = 0x08;
         const TYPE_PARAMS = 0x10;
+        /// PEP 649: __annotate__ function closure (instead of __annotations__ dict)
+        const ANNOTATE = 0x20;
     }
 }
 
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 01ef987ae39..55d9d046651 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -401,6 +401,12 @@ impl PyFunction {
                 ))
             })?;
             *self.type_params.lock() = type_params;
+        } else if attr == bytecode::MakeFunctionFlags::ANNOTATE {
+            // PEP 649: Store the __annotate__ function closure
+            if !attr_value.is_callable() {
+                return Err(vm.new_type_error("__annotate__ must be callable".to_owned()));
+            }
+            *self.annotate.lock() = Some(attr_value);
         } else {
             unreachable!("This is a compiler bug");
         }
@@ -588,36 +594,50 @@ impl PyFunction {
 
     #[pygetset]
     fn __annotations__(&self, vm: &VirtualMachine) -> PyResult<PyDictRef> {
-        let mut annotations = self.annotations.lock();
-        let annotate = self.annotate.lock();
-
-        if annotations.is_none() {
-            // If we have a callable __annotate__, call it to get annotations
-            if let Some(ref annotate_fn) = *annotate {
-                if annotate_fn.is_callable() {
-                    // Call __annotate__(1) where 1 = Format.VALUE
-                    let one = vm.ctx.new_int(1);
-                    let ann_dict = annotate_fn.call((one,), vm)?;
-                    let ann_dict =
-                        ann_dict
-                            .downcast::<crate::builtins::PyDict>()
-                            .map_err(|obj| {
-                                vm.new_type_error(format!(
-                                    "__annotate__ returned non-dict of type '{}'",
-                                    obj.class().name()
-                                ))
-                            })?;
-                    *annotations = Some(ann_dict.clone());
-                    return Ok(ann_dict);
+        // First check if we have cached annotations
+        {
+            let annotations = self.annotations.lock();
+            if let Some(ref ann) = *annotations {
+                return Ok(ann.clone());
+            }
+        }
+
+        // Check for callable __annotate__ and clone it before calling
+        let annotate_fn = {
+            let annotate = self.annotate.lock();
+            if let Some(ref func) = *annotate {
+                if func.is_callable() {
+                    Some(func.clone())
+                } else {
+                    None
                 }
+            } else {
+                None
             }
-            // No __annotate__ or not callable, create empty dict
-            let new_dict = vm.ctx.new_dict();
-            *annotations = Some(new_dict.clone());
-            return Ok(new_dict);
+        };
+
+        // Release locks before calling __annotate__ to avoid deadlock
+        if let Some(annotate_fn) = annotate_fn {
+            let one = vm.ctx.new_int(1);
+            let ann_dict = annotate_fn.call((one,), vm)?;
+            let ann_dict = ann_dict
+                .downcast::<crate::builtins::PyDict>()
+                .map_err(|obj| {
+                    vm.new_type_error(format!(
+                        "__annotate__ returned non-dict of type '{}'",
+                        obj.class().name()
+                    ))
+                })?;
+
+            // Cache the result
+            *self.annotations.lock() = Some(ann_dict.clone());
+            return Ok(ann_dict);
         }
 
-        Ok(annotations.clone().unwrap())
+        // No __annotate__ or not callable, create empty dict
+        let new_dict = vm.ctx.new_dict();
+        *self.annotations.lock() = Some(new_dict.clone());
+        Ok(new_dict)
     }
 
     #[pygetset(setter)]
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 4bc326b38a2..b3e4956d236 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -899,10 +899,8 @@ impl PyType {
 
         let mut attrs = self.attributes.write();
         attrs.insert(identifier!(vm, __annotate_func__), value.clone());
-        // Clear cached annotations if value is not None
-        if !vm.is_none(&value) {
-            attrs.swap_remove(identifier!(vm, __annotations_cache__));
-        }
+        // Always clear cached annotations when __annotate__ is updated
+        attrs.swap_remove(identifier!(vm, __annotations_cache__));
 
         Ok(())
     }

From a78b569d924264228ae7c0ed6250f543715ba621 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 13 Jan 2026 23:49:40 +0900
Subject: [PATCH 323/418] PEP 649 annotation phase 3

---
 crates/codegen/src/compile.rs             | 340 +++++++++++++++-------
 crates/codegen/src/symboltable.rs         | 147 +++++++++-
 crates/vm/src/builtins/module.rs          |  40 ++-
 crates/vm/src/vm/vm_new.rs                |   6 +-
 extra_tests/snippets/syntax_assignment.py |  13 +-
 extra_tests/snippets/syntax_function2.py  |   3 +-
 6 files changed, 409 insertions(+), 140 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 776b5f820da..6e2be2c72c2 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -29,7 +29,7 @@ use ruff_python_ast::{
     InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
     Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
     PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
-    Stmt, StmtExpr, TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
+    Stmt, StmtAnnAssign, StmtExpr, TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
     TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
     visitor::{Visitor, walk_expr},
 };
@@ -676,6 +676,62 @@ impl Compiler {
         Ok(self.current_symbol_table())
     }
 
+    /// Push the annotation symbol table from the next sub_table's annotation_block
+    /// The annotation_block is stored in the function's scope, which is the next sub_table
+    /// Returns true if annotation_block exists, false otherwise
+    fn push_annotation_symbol_table(&mut self) -> bool {
+        let current_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table");
+
+        // The annotation_block is in the next sub_table (function scope)
+        let next_idx = current_table.next_sub_table;
+        if next_idx >= current_table.sub_tables.len() {
+            return false;
+        }
+
+        let next_table = &mut current_table.sub_tables[next_idx];
+        if let Some(annotation_block) = next_table.annotation_block.take() {
+            self.symbol_table_stack.push(*annotation_block);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Push the annotation symbol table for module/class level annotations
+    /// This takes annotation_block from the current symbol table (not sub_tables)
+    fn push_current_annotation_symbol_table(&mut self) -> bool {
+        let current_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table");
+
+        // For modules/classes, annotation_block is directly in the current table
+        if let Some(annotation_block) = current_table.annotation_block.take() {
+            self.symbol_table_stack.push(*annotation_block);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Pop the annotation symbol table and restore it to the function scope's annotation_block
+    fn pop_annotation_symbol_table(&mut self) {
+        let annotation_table = self.symbol_table_stack.pop().expect("compiler bug");
+        let current_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table");
+
+        // Restore to the next sub_table (function scope) where it came from
+        let next_idx = current_table.next_sub_table;
+        if next_idx < current_table.sub_tables.len() {
+            current_table.sub_tables[next_idx].annotation_block = Some(Box::new(annotation_table));
+        }
+    }
+
     /// Pop the current symbol table off the stack
     fn pop_symbol_table(&mut self) -> SymbolTable {
         self.symbol_table_stack.pop().expect("compiler bug")
@@ -933,6 +989,12 @@ impl Compiler {
                 0,
                 0,
             ),
+            CompilerScope::Annotation => (
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
+                0,
+                1, // annotation scope takes one argument (format)
+                0,
+            ),
         };
 
         // Get private name from parent scope
@@ -1060,6 +1122,43 @@ impl Compiler {
         unwrap_internal(self, stack_top.finalize_code(&self.opts))
     }
 
+    /// Exit annotation scope - similar to exit_scope but restores annotation_block to parent
+    fn exit_annotation_scope(&mut self) -> CodeObject {
+        self.pop_annotation_symbol_table();
+
+        let pop = self.code_stack.pop();
+        let stack_top = compiler_unwrap_option(self, pop);
+        unwrap_internal(self, stack_top.finalize_code(&self.opts))
+    }
+
+    /// Enter annotation scope using the symbol table's annotation_block
+    /// Returns false if no annotation_block exists
+    fn enter_annotation_scope(&mut self, func_name: &str) -> CompileResult<bool> {
+        if !self.push_annotation_symbol_table() {
+            return Ok(false);
+        }
+
+        let key = self.symbol_table_stack.len() - 1;
+        let lineno = self.get_source_line_number().get();
+        let annotate_name = format!("<annotate of {func_name}>");
+
+        self.enter_scope(
+            &annotate_name,
+            CompilerScope::Annotation,
+            key,
+            lineno.to_u32(),
+        )?;
+
+        // Override arg_count since enter_scope sets it to 1 but we need the varnames
+        // setup to be correct too
+        self.current_code_info()
+            .metadata
+            .varnames
+            .insert("format".to_owned());
+
+        Ok(true)
+    }
+
     /// Push a new fblock
     // = compiler_push_fblock
     fn push_fblock(
@@ -1506,8 +1605,9 @@ impl Compiler {
             emit!(self, Instruction::StoreGlobal(doc))
         }
 
+        // PEP 649: Generate __annotate__ function instead of SetupAnnotations
         if Self::find_ann(statements) {
-            emit!(self, Instruction::SetupAnnotations);
+            self.compile_module_annotate(statements)?;
         }
 
         self.compile_statements(statements)?;
@@ -1526,8 +1626,9 @@ impl Compiler {
     ) -> CompileResult<()> {
         self.symbol_table_stack.push(symbol_table);
 
+        // PEP 649: Generate __annotate__ function instead of SetupAnnotations
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotations);
+            self.compile_module_annotate(body)?;
         }
 
         if let Some((last, body)) = body.split_last() {
@@ -1666,16 +1767,17 @@ impl Compiler {
         // Determine the operation type based on symbol scope
         let is_function_like = self.ctx.in_func();
 
-        // Look up the symbol, handling TypeParams scope specially
-        let (symbol_scope, _is_typeparams) = {
+        // Look up the symbol, handling TypeParams and Annotation scopes specially
+        let (symbol_scope, _is_special_scope) = {
             let current_table = self.current_symbol_table();
             let is_typeparams = current_table.typ == CompilerScope::TypeParams;
+            let is_annotation = current_table.typ == CompilerScope::Annotation;
 
             // First try to find in current table
             let symbol = current_table.lookup(name.as_ref());
 
-            // If not found and we're in TypeParams scope, try parent scope
-            let symbol = if symbol.is_none() && is_typeparams {
+            // If not found and we're in TypeParams or Annotation scope, try parent scope
+            let symbol = if symbol.is_none() && (is_typeparams || is_annotation) {
                 self.symbol_table_stack
                     .get(self.symbol_table_stack.len() - 2) // Try to get parent index
                     .expect("Symbol has no parent! This is a compiler bug.")
@@ -1684,7 +1786,7 @@ impl Compiler {
                 symbol
             };
 
-            (symbol.map(|s| s.scope), is_typeparams)
+            (symbol.map(|s| s.scope), is_typeparams || is_annotation)
         };
 
         let actual_scope = symbol_scope.ok_or_else(|| {
@@ -3344,16 +3446,35 @@ impl Compiler {
         Ok(())
     }
 
-    /// Compile function annotations
-    // = compiler_visit_annotations
-    fn visit_annotations(
+    /// Compile function annotations as a closure (PEP 649)
+    /// Returns true if an __annotate__ closure was created
+    /// Uses symbol table's annotation_block for proper scoping.
+    fn compile_annotations_closure(
         &mut self,
+        func_name: &str,
         parameters: &Parameters,
         returns: Option<&Expr>,
-    ) -> CompileResult<u32> {
-        let mut num_annotations = 0;
+    ) -> CompileResult<bool> {
+        // Try to enter annotation scope - returns false if no annotation_block exists
+        if !self.enter_annotation_scope(func_name)? {
+            return Ok(false);
+        }
 
-        // Handle parameter annotations
+        // Count annotations
+        let parameters_iter = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .chain(&parameters.kwonlyargs)
+            .map(|x| &x.parameter)
+            .chain(parameters.vararg.as_deref())
+            .chain(parameters.kwarg.as_deref());
+
+        let num_annotations: u32 =
+            u32::try_from(parameters_iter.filter(|p| p.annotation.is_some()).count())
+                .expect("too many annotations")
+                + if returns.is_some() { 1 } else { 0 };
+
+        // Compile annotations inside the annotation scope
         let parameters_iter = core::iter::empty()
             .chain(&parameters.posonlyargs)
             .chain(&parameters.args)
@@ -3368,58 +3489,79 @@ impl Compiler {
                     value: self.mangle(param.name.as_str()).into_owned().into(),
                 });
                 self.compile_annotation(annotation)?;
-                num_annotations += 1;
             }
         }
 
-        // Handle return annotation last
+        // Handle return annotation
         if let Some(annotation) = returns {
             self.emit_load_const(ConstantData::Str {
                 value: "return".into(),
             });
             self.compile_annotation(annotation)?;
-            num_annotations += 1;
         }
 
-        Ok(num_annotations)
+        // Build the map and return it
+        emit!(
+            self,
+            Instruction::BuildMap {
+                size: num_annotations,
+            }
+        );
+        emit!(self, Instruction::ReturnValue);
+
+        // Exit the annotation scope and get the code object
+        let annotate_code = self.exit_annotation_scope();
+
+        // Make a closure from the code object
+        self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
+
+        Ok(true)
     }
 
-    /// Compile function annotations as a closure (PEP 649)
-    /// Returns true if an __annotate__ closure was created
-    /// NOTE: This requires symbol table support for annotation scopes.
-    /// Currently unused - kept for future implementation reference.
-    #[allow(dead_code, clippy::cast_possible_truncation)]
-    fn compile_annotations_closure(
-        &mut self,
-        func_name: &str,
-        parameters: &Parameters,
-        returns: Option<&Expr>,
-    ) -> CompileResult<bool> {
-        // Count annotations first
-        let parameters_iter = core::iter::empty()
-            .chain(&parameters.posonlyargs)
-            .chain(&parameters.args)
-            .chain(&parameters.kwonlyargs)
-            .map(|x| &x.parameter)
-            .chain(parameters.vararg.as_deref())
-            .chain(parameters.kwarg.as_deref());
+    /// Collect simple (non-conditional) annotations from module body
+    /// Returns list of (name, annotation_expr) pairs
+    fn collect_simple_annotations(body: &[Stmt]) -> Vec<(&str, &Expr)> {
+        let mut annotations = Vec::new();
+        for stmt in body {
+            if let Stmt::AnnAssign(StmtAnnAssign {
+                target,
+                annotation,
+                simple,
+                ..
+            }) = stmt
+                && *simple
+                && let Expr::Name(ExprName { id, .. }) = target.as_ref()
+            {
+                annotations.push((id.as_str(), annotation.as_ref()));
+            }
+        }
+        annotations
+    }
 
-        let num_annotations: u32 = parameters_iter.filter(|p| p.annotation.is_some()).count()
-            as u32
-            + if returns.is_some() { 1 } else { 0 };
+    /// Compile module-level __annotate__ function (PEP 649)
+    /// Returns true if __annotate__ was created and stored
+    fn compile_module_annotate(&mut self, body: &[Stmt]) -> CompileResult<bool> {
+        // Collect simple annotations from module body first
+        let annotations = Self::collect_simple_annotations(body);
+        let num_annotations = u32::try_from(annotations.len()).expect("too many annotations");
 
         if num_annotations == 0 {
             return Ok(false);
         }
 
-        // Create a new scope for the __annotate__ function
-        let annotate_name = format!("<annotate of {func_name}>");
-        self.push_output(
-            bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
-            0, // posonlyarg_count
-            1, // arg_count (format parameter)
-            0, // kwonlyarg_count
-            annotate_name,
+        // Try to push annotation symbol table from current scope
+        if !self.push_current_annotation_symbol_table() {
+            return Ok(false);
+        }
+
+        // Enter annotation scope for code generation
+        let key = self.symbol_table_stack.len() - 1;
+        let lineno = self.get_source_line_number().get();
+        self.enter_scope(
+            "<annotate of module>",
+            CompilerScope::Annotation,
+            key,
+            lineno.to_u32(),
         )?;
 
         // Add 'format' parameter to varnames
@@ -3428,28 +3570,10 @@ impl Compiler {
             .varnames
             .insert("format".to_owned());
 
-        // Compile annotations inside the new scope
-        let parameters_iter = core::iter::empty()
-            .chain(&parameters.posonlyargs)
-            .chain(&parameters.args)
-            .chain(&parameters.kwonlyargs)
-            .map(|x| &x.parameter)
-            .chain(parameters.vararg.as_deref())
-            .chain(parameters.kwarg.as_deref());
-
-        for param in parameters_iter {
-            if let Some(annotation) = &param.annotation {
-                self.emit_load_const(ConstantData::Str {
-                    value: self.mangle(param.name.as_str()).into_owned().into(),
-                });
-                self.compile_annotation(annotation)?;
-            }
-        }
-
-        // Handle return annotation
-        if let Some(annotation) = returns {
+        // Compile annotations inside the annotation scope
+        for (name, annotation) in annotations {
             self.emit_load_const(ConstantData::Str {
-                value: "return".into(),
+                value: self.mangle(name).into_owned().into(),
             });
             self.compile_annotation(annotation)?;
         }
@@ -3463,12 +3587,26 @@ impl Compiler {
         );
         emit!(self, Instruction::ReturnValue);
 
-        // Exit the scope and get the code object
-        let annotate_code = self.exit_scope();
+        // Exit annotation scope - pop symbol table, restore to parent's annotation_block, and get code
+        let annotation_table = self.pop_symbol_table();
+        // Restore annotation_block to module's symbol table
+        self.symbol_table_stack
+            .last_mut()
+            .expect("no module symbol table")
+            .annotation_block = Some(Box::new(annotation_table));
+        // Exit code scope
+        let pop = self.code_stack.pop();
+        let annotate_code = unwrap_internal(
+            self,
+            compiler_unwrap_option(self, pop).finalize_code(&self.opts),
+        );
 
         // Make a closure from the code object
         self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
 
+        // Store as __annotate__
+        self.store_name("__annotate__")?;
+
         Ok(true)
     }
 
@@ -3536,21 +3674,12 @@ impl Compiler {
             }
         }
 
-        // Compile annotations
-        // TODO: Full PEP 649 deferred annotation compilation requires symbol table changes.
-        // Currently using immediate evaluation (like PEP 563 without string conversion).
-        // The __annotate__ infrastructure is in place in function.rs, module.rs, type.rs.
-        let mut annotations_flag = bytecode::MakeFunctionFlags::empty();
-        let num_annotations = self.visit_annotations(parameters, returns)?;
-        if num_annotations > 0 {
-            annotations_flag = bytecode::MakeFunctionFlags::ANNOTATIONS;
-            emit!(
-                self,
-                Instruction::BuildMap {
-                    size: num_annotations,
-                }
-            );
-        }
+        // Compile annotations as closure (PEP 649)
+        let annotations_flag = if self.compile_annotations_closure(name, parameters, returns)? {
+            bytecode::MakeFunctionFlags::ANNOTATE
+        } else {
+            bytecode::MakeFunctionFlags::empty()
+        };
 
         // Compile function body
         let final_funcflags = funcflags | annotations_flag;
@@ -3759,6 +3888,16 @@ impl Compiler {
             );
         }
 
+        // Set __annotate__ closure if present (PEP 649)
+        if flags.contains(bytecode::MakeFunctionFlags::ANNOTATE) {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::ANNOTATE
+                }
+            );
+        }
+
         // Set kwdefaults if present
         if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
             emit!(
@@ -3889,9 +4028,9 @@ impl Compiler {
             emit!(self, Instruction::StoreName(dunder_type_params));
         }
 
-        // Setup annotations if needed
+        // PEP 649: Generate __annotate__ function for class annotations
         if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotations);
+            self.compile_module_annotate(body)?;
         }
 
         // 3. Compile the class body
@@ -5553,26 +5692,11 @@ impl Compiler {
             self.compile_store(target)?;
         }
 
-        // Annotations are only evaluated in a module or class.
-        if self.ctx.in_func() {
-            return Ok(());
-        }
-
-        // Compile annotation:
-        self.compile_annotation(annotation)?;
-
-        if let Expr::Name(ExprName { id, .. }) = &target {
-            // Store as dict entry in __annotations__ dict:
-            let annotations = self.name("__annotations__");
-            emit!(self, Instruction::LoadName(annotations));
-            self.emit_load_const(ConstantData::Str {
-                value: self.mangle(id.as_str()).into_owned().into(),
-            });
-            emit!(self, Instruction::StoreSubscr);
-        } else {
-            // Drop annotation if not assigned to simple identifier.
-            emit!(self, Instruction::PopTop);
-        }
+        // PEP 649: Annotations in module/class scope are handled by __annotate__
+        // function, so we don't compile them here. Only in function scope do we
+        // evaluate annotations (though they're also ignored at runtime).
+        // In function scope, annotations are not evaluated at all.
+        let _ = annotation; // Mark as intentionally unused
 
         Ok(())
     }
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index e8eb3c7fee3..4b85aaac502 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -63,6 +63,10 @@ pub struct SymbolTable {
     /// Whether this comprehension scope should be inlined (PEP 709)
     /// True for list/set/dict comprehensions in non-generator expressions
     pub comp_inlined: bool,
+
+    /// PEP 649: Reference to annotation scope for this block
+    /// Annotations are compiled as a separate `__annotate__` function
+    pub annotation_block: Option<Box<SymbolTable>>,
 }
 
 impl SymbolTable {
@@ -80,6 +84,7 @@ impl SymbolTable {
             needs_classdict: false,
             can_see_class_scope: false,
             comp_inlined: false,
+            annotation_block: None,
         }
     }
 
@@ -109,6 +114,8 @@ pub enum CompilerScope {
     Lambda,
     Comprehension,
     TypeParams,
+    /// PEP 649: Annotation scope for deferred evaluation
+    Annotation,
 }
 
 impl fmt::Display for CompilerScope {
@@ -121,9 +128,8 @@ impl fmt::Display for CompilerScope {
             Self::Lambda => write!(f, "lambda"),
             Self::Comprehension => write!(f, "comprehension"),
             Self::TypeParams => write!(f, "type parameter"),
+            Self::Annotation => write!(f, "annotation"),
             // TODO missing types from the C implementation
-            // if self._table.type == _symtable.TYPE_ANNOTATION:
-            //     return "annotation"
             // if self._table.type == _symtable.TYPE_TYPE_VAR_BOUND:
             //     return "TypeVar bound"
             // if self._table.type == _symtable.TYPE_TYPE_ALIAS:
@@ -349,6 +355,8 @@ impl SymbolTableAnalyzer {
         // Collect free variables from all child scopes
         let mut newfree = HashSet::new();
 
+        let annotation_block = &mut symbol_table.annotation_block;
+
         let mut info = (symbols, symbol_table.typ);
         self.tables.with_append(&mut info, |list| {
             let inner_scope = unsafe { &mut *(list as *mut _ as *mut Self) };
@@ -358,6 +366,12 @@ impl SymbolTableAnalyzer {
                 // Propagate child's free variables to this scope
                 newfree.extend(child_free);
             }
+            // PEP 649: Analyze annotation block if present
+            if let Some(annotation_table) = annotation_block {
+                let child_free = inner_scope.analyze_symbol_table(annotation_table)?;
+                // Propagate annotation's free variables to this scope
+                newfree.extend(child_free);
+            }
             Ok(())
         })?;
 
@@ -657,6 +671,13 @@ impl SymbolTableAnalyzer {
                     location: None,
                 });
             }
+            CompilerScope::Annotation => {
+                // Named expression is not allowed in annotation scope
+                return Err(SymbolTableError {
+                    error: "named expression cannot be used within an annotation".to_string(),
+                    location: None,
+                });
+            }
         }
         Ok(())
     }
@@ -782,6 +803,43 @@ impl SymbolTableBuilder {
         self.tables.last_mut().unwrap().sub_tables.push(table);
     }
 
+    /// Enter annotation scope (PEP 649)
+    /// Creates or reuses the annotation block for the current scope
+    fn enter_annotation_scope(&mut self, line_number: u32) {
+        let current = self.tables.last_mut().unwrap();
+        let can_see_class_scope = current.typ == CompilerScope::Class;
+
+        // Create annotation block if not exists
+        if current.annotation_block.is_none() {
+            let mut annotation_table = SymbolTable::new(
+                "__annotate__".to_owned(),
+                CompilerScope::Annotation,
+                line_number,
+                true, // is_nested
+            );
+            // Annotation scope in class can see class scope
+            annotation_table.can_see_class_scope = can_see_class_scope;
+            // Add 'format' parameter
+            annotation_table.varnames.push("format".to_owned());
+            current.annotation_block = Some(Box::new(annotation_table));
+        }
+
+        // Take the annotation block and push to stack for processing
+        let annotation_table = current.annotation_block.take().unwrap();
+        self.tables.push(*annotation_table);
+        self.current_varnames.clear();
+    }
+
+    /// Leave annotation scope (PEP 649)
+    /// Stores the annotation block back to parent instead of sub_tables
+    fn leave_annotation_scope(&mut self) {
+        let mut table = self.tables.pop().unwrap();
+        // Save the collected varnames to the symbol table
+        table.varnames = core::mem::take(&mut self.current_varnames);
+        // Store back to parent's annotation_block (not sub_tables)
+        self.tables.last_mut().unwrap().annotation_block = Some(Box::new(table));
+    }
+
     fn line_index_start(&self, range: TextRange) -> u32 {
         self.source_file
             .to_source_code()
@@ -831,12 +889,28 @@ impl SymbolTableBuilder {
 
     fn scan_annotation(&mut self, annotation: &Expr) -> SymbolTableResult {
         if self.future_annotations {
+            // PEP 563: annotations are stringified
             Ok(())
         } else {
+            // PEP 649: annotations are deferred in a separate scope
+            let line_number = self.line_index_start(annotation.range());
+            self.enter_annotation_scope(line_number);
+
             let was_in_annotation = self.in_annotation;
             self.in_annotation = true;
             let result = self.scan_expression(annotation, ExpressionContext::Load);
             self.in_annotation = was_in_annotation;
+
+            self.leave_annotation_scope();
+
+            // Also scan in parent scope for immediate evaluation compatibility
+            // This ensures symbols like builtins are available in the module scope
+            // TODO: Remove this once full PEP 649 deferred compilation is implemented
+            let was_in_annotation = self.in_annotation;
+            self.in_annotation = true;
+            let _ = self.scan_expression(annotation, ExpressionContext::Load);
+            self.in_annotation = was_in_annotation;
+
             result
         }
     }
@@ -873,9 +947,26 @@ impl SymbolTableBuilder {
             }) => {
                 self.scan_decorators(decorator_list, ExpressionContext::Load)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
-                if let Some(expression) = returns {
+
+                // When in class scope, save the class's annotation_block before scanning
+                // function annotations, so method annotations don't interfere with class annotations
+                let parent_is_class = self
+                    .tables
+                    .last()
+                    .map(|t| t.typ == CompilerScope::Class)
+                    .unwrap_or(false);
+                let saved_annotation_block = if parent_is_class {
+                    self.tables.last_mut().unwrap().annotation_block.take()
+                } else {
+                    None
+                };
+
+                let has_return_annotation = if let Some(expression) = returns {
                     self.scan_annotation(expression)?;
-                }
+                    true
+                } else {
+                    false
+                };
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         &format!("<generic parameters of {}>", name.as_str()),
@@ -887,12 +978,18 @@ impl SymbolTableBuilder {
                     name.as_str(),
                     parameters,
                     self.line_index_start(*range),
+                    has_return_annotation,
                 )?;
                 self.scan_statements(body)?;
                 self.leave_scope();
                 if type_params.is_some() {
                     self.leave_scope();
                 }
+
+                // Restore class's annotation_block after processing the function
+                if let Some(block) = saved_annotation_block {
+                    self.tables.last_mut().unwrap().annotation_block = Some(block);
+                }
             }
             Stmt::ClassDef(StmtClassDef {
                 name,
@@ -1037,6 +1134,14 @@ impl SymbolTableBuilder {
                 match &**target {
                     Expr::Name(ast::ExprName { id, .. }) if *simple => {
                         self.register_name(id.as_str(), SymbolUsage::AnnotationAssigned, *range)?;
+                        // PEP 649: Register __annotate__ in module/class scope for deferred annotations
+                        let current_scope = self.tables.last().map(|t| t.typ);
+                        if matches!(
+                            current_scope,
+                            Some(CompilerScope::Module) | Some(CompilerScope::Class)
+                        ) {
+                            self.register_name("__annotate__", SymbolUsage::Assigned, *range)?;
+                        }
                     }
                     _ => {
                         self.scan_expression(target, ExpressionContext::Store)?;
@@ -1412,6 +1517,7 @@ impl SymbolTableBuilder {
                         "lambda",
                         parameters,
                         self.line_index_start(expression.range()),
+                        false, // lambdas have no return annotation
                     )?;
                 } else {
                     self.enter_scope(
@@ -1774,6 +1880,7 @@ impl SymbolTableBuilder {
         name: &str,
         parameters: &Parameters,
         line_number: u32,
+        has_return_annotation: bool,
     ) -> SymbolTableResult {
         // Evaluate eventual default parameters:
         for default in parameters
@@ -1811,8 +1918,40 @@ impl SymbolTableBuilder {
             self.scan_annotation(annotation)?;
         }
 
+        // Check if this function has any annotations (parameter or return)
+        let has_param_annotations = parameters
+            .posonlyargs
+            .iter()
+            .chain(parameters.args.iter())
+            .chain(parameters.kwonlyargs.iter())
+            .any(|p| p.parameter.annotation.is_some())
+            || parameters
+                .vararg
+                .as_ref()
+                .is_some_and(|p| p.annotation.is_some())
+            || parameters
+                .kwarg
+                .as_ref()
+                .is_some_and(|p| p.annotation.is_some());
+
+        let has_any_annotations = has_param_annotations || has_return_annotation;
+
+        // Take annotation_block if this function has any annotations.
+        // When in class scope, the class's annotation_block was saved before scanning
+        // function annotations, so the current annotation_block belongs to this function.
+        let annotation_block = if has_any_annotations {
+            self.tables.last_mut().unwrap().annotation_block.take()
+        } else {
+            None
+        };
+
         self.enter_scope(name, CompilerScope::Function, line_number);
 
+        // Move annotation_block to function scope only if we have one
+        if let Some(block) = annotation_block {
+            self.tables.last_mut().unwrap().annotation_block = Some(block);
+        }
+
         // Fill scope with parameter names:
         self.scan_parameters(&parameters.posonlyargs)?;
         self.scan_parameters(&parameters.args)?;
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
index 2f0592f4e1b..2daac15ceae 100644
--- a/crates/vm/src/builtins/module.rs
+++ b/crates/vm/src/builtins/module.rs
@@ -223,34 +223,30 @@ impl PyModule {
     fn __annotations__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         let dict = zelf.dict();
 
-        // Check if __annotations__ is already in dict
+        // Check if __annotations__ is already in dict (explicitly set)
         if let Some(annotations) = dict.get_item_opt(identifier!(vm, __annotations__), vm)? {
             return Ok(annotations);
         }
 
-        // Get __annotate__ and call it if callable
-        let annotations =
-            if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
-                if annotate.is_callable() {
-                    // Call __annotate__(1) where 1 is FORMAT_VALUE
-                    let result = annotate.call((1i32,), vm)?;
-                    if !result.class().is(vm.ctx.types.dict_type) {
-                        return Err(vm.new_type_error(format!(
-                            "__annotate__ returned non-dict of type '{}'",
-                            result.class().name()
-                        )));
-                    }
-                    result
-                } else {
-                    vm.ctx.new_dict().into()
+        // PEP 649: Get __annotate__ and call it if callable
+        // Don't cache the result to dict - __annotations__ should only appear
+        // in __dict__ if explicitly set
+        if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
+            if annotate.is_callable() {
+                // Call __annotate__(1) where 1 is FORMAT_VALUE
+                let result = annotate.call((1i32,), vm)?;
+                if !result.class().is(vm.ctx.types.dict_type) {
+                    return Err(vm.new_type_error(format!(
+                        "__annotate__ returned non-dict of type '{}'",
+                        result.class().name()
+                    )));
                 }
-            } else {
-                vm.ctx.new_dict().into()
-            };
+                return Ok(result);
+            }
+        }
 
-        // Cache the result (TODO: check if module is initializing)
-        dict.set_item(identifier!(vm, __annotations__), annotations.clone(), vm)?;
-        Ok(annotations)
+        // No __annotate__ or not callable - return empty dict
+        Ok(vm.ctx.new_dict().into())
     }
 
     #[pygetset(setter)]
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 119444be75c..517fa23aa32 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -65,10 +65,8 @@ impl VirtualMachine {
     pub fn new_scope_with_main(&self) -> PyResult<Scope> {
         let scope = self.new_scope_with_builtins();
         let main_module = self.new_module("__main__", scope.globals.clone(), None);
-        main_module
-            .dict()
-            .set_item("__annotations__", self.ctx.new_dict().into(), self)
-            .expect("Failed to initialize __main__.__annotations__");
+        // PEP 649: Don't automatically initialize __annotations__
+        // It will be lazily created by the descriptor when accessed
 
         self.sys_module.get_attr("modules", self)?.set_item(
             "__main__",
diff --git a/extra_tests/snippets/syntax_assignment.py b/extra_tests/snippets/syntax_assignment.py
index 8635dc5d795..851558a9db0 100644
--- a/extra_tests/snippets/syntax_assignment.py
+++ b/extra_tests/snippets/syntax_assignment.py
@@ -59,7 +59,18 @@ def g():
 assert a == 1337
 assert b == False
 
-assert __annotations__['a'] == bool
+# PEP 649: In Python 3.14, __annotations__ is not automatically defined at module level
+# Accessing it raises NameError
+from testutils import assert_raises
+
+with assert_raises(NameError):
+    __annotations__
+
+# Use __annotate__ to get annotations (PEP 649)
+assert callable(__annotate__)
+annotations = __annotate__(1)  # 1 = FORMAT_VALUE
+assert annotations['a'] == bool
+assert annotations['b'] == bool
 
 n = 0
 
diff --git a/extra_tests/snippets/syntax_function2.py b/extra_tests/snippets/syntax_function2.py
index d0901af6a14..4a04acd51c1 100644
--- a/extra_tests/snippets/syntax_function2.py
+++ b/extra_tests/snippets/syntax_function2.py
@@ -80,6 +80,7 @@ def nested():
 
 
 def f7():
+    # PEP 649: annotations are deferred, so void is not evaluated at definition time
     try:
         def t() -> void: # noqa: F821
             pass
@@ -87,7 +88,7 @@ def t() -> void: # noqa: F821
         return True
     return False
 
-assert f7()
+assert not f7()  # PEP 649: no NameError because annotation is deferred
 
 
 def f8() -> int:

From 566b6f438be32e022d0a00df8b348c89cb3d2d20 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Wed, 14 Jan 2026 23:43:45 +0900
Subject: [PATCH 324/418] PEP 649 annotation phase 4

---
 .cspell.dict/python-more.txt          |   1 +
 Lib/typing.py                         |   4 +-
 crates/codegen/src/compile.rs         | 367 ++++++++++++++++++++++----
 crates/codegen/src/symboltable.rs     | 293 ++++++++++++++++----
 crates/vm/src/builtins/module.rs      |  51 ++--
 crates/vm/src/builtins/type.rs        |  49 ++--
 crates/vm/src/frame.rs                |  23 ++
 extra_tests/snippets/stdlib_typing.py |  23 ++
 8 files changed, 679 insertions(+), 132 deletions(-)

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index a13f345eece..c4a419c5ffe 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -5,6 +5,7 @@ aexit
 aiter
 anext
 anextawaitable
+annotationlib
 appendleft
 argcount
 arrayiterator
diff --git a/Lib/typing.py b/Lib/typing.py
index a7397356d65..b89e24e2ce0 100644
--- a/Lib/typing.py
+++ b/Lib/typing.py
@@ -1918,6 +1918,7 @@ class _TypingEllipsis:
     '__init__', '__module__', '__new__', '__slots__',
     '__subclasshook__', '__weakref__', '__class_getitem__',
     '__match_args__', '__static_attributes__', '__firstlineno__',
+    '__annotate__', '__annotate_func__', '__annotations_cache__',
 })
 
 # These special attributes will be not collected as protocol members.
@@ -2992,7 +2993,8 @@ def _make_nmtuple(name, types, module, defaults = ()):
                          '_fields', '_field_defaults',
                          '_make', '_replace', '_asdict', '_source'})
 
-_special = frozenset({'__module__', '__name__', '__annotations__'})
+_special = frozenset({'__module__', '__name__', '__annotations__', '__annotate__',
+                      '__annotate_func__', '__annotations_cache__'})
 
 
 class NamedTupleMeta(type):
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 6e2be2c72c2..2d3603c74ed 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -130,6 +130,10 @@ struct Compiler {
     ctx: CompileContext,
     opts: CompileOpts,
     in_annotation: bool,
+    // PEP 649: Track if we're inside a conditional block (if/for/while/etc.)
+    in_conditional_block: bool,
+    // PEP 649: Next index for conditional annotation tracking
+    next_conditional_annotation_index: u32,
 }
 
 enum DoneWithFuture {
@@ -437,6 +441,8 @@ impl Compiler {
             },
             opts,
             in_annotation: false,
+            in_conditional_block: false,
+            next_conditional_annotation_index: 0,
         }
     }
 
@@ -952,6 +958,12 @@ impl Compiler {
             cellvar_cache.insert("__classdict__".to_string());
         }
 
+        // Handle implicit __conditional_annotations__ cell if needed
+        // Only for class scope - module scope uses NAME operations, not DEREF
+        if ste.has_conditional_annotations && scope_type == CompilerScope::Class {
+            cellvar_cache.insert("__conditional_annotations__".to_string());
+        }
+
         // Build freevars using dictbytype (FREE scope, offset by cellvars size)
         let mut freevar_cache = IndexSet::default();
         let mut free_names: Vec<_> = ste
@@ -1156,9 +1168,52 @@ impl Compiler {
             .varnames
             .insert("format".to_owned());
 
+        // Emit format validation: if format > VALUE_WITH_FAKE_GLOBALS: raise NotImplementedError
+        // VALUE_WITH_FAKE_GLOBALS = 2 (from annotationlib.Format)
+        self.emit_format_validation()?;
+
         Ok(true)
     }
 
+    /// Emit format parameter validation for annotation scope
+    /// if format > VALUE_WITH_FAKE_GLOBALS (2): raise NotImplementedError
+    fn emit_format_validation(&mut self) -> CompileResult<()> {
+        use bytecode::ComparisonOperator::Greater;
+
+        // Load format parameter (first local variable, index 0)
+        emit!(self, Instruction::LoadFast(0));
+
+        // Load VALUE_WITH_FAKE_GLOBALS constant (2)
+        self.emit_load_const(ConstantData::Integer { value: 2.into() });
+
+        // Compare: format > 2
+        emit!(self, Instruction::CompareOp { op: Greater });
+
+        // Jump to body if format <= 2 (comparison is false)
+        let body_block = self.new_block();
+        emit!(
+            self,
+            Instruction::PopJumpIfFalse {
+                target: body_block,
+            }
+        );
+
+        // Raise NotImplementedError
+        let not_implemented_error = self.name("NotImplementedError");
+        emit!(self, Instruction::LoadGlobal(not_implemented_error));
+        emit!(
+            self,
+            Instruction::RaiseVarargs {
+                kind: bytecode::RaiseKind::Raise
+            }
+        );
+
+        // Body label - continue with annotation evaluation
+        self.switch_to_block(body_block);
+
+        Ok(())
+    }
+
     /// Push a new fblock
     // = compiler_push_fblock
     fn push_fblock(
@@ -1594,6 +1649,8 @@ impl Compiler {
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
         let size_before = self.code_stack.len();
+        // Set future_annotations from symbol table (detected during symbol table scan)
+        self.future_annotations = symbol_table.future_annotations;
         self.symbol_table_stack.push(symbol_table);
 
         let (doc, statements) = split_doc(&body.body, &self.opts);
@@ -1605,11 +1662,24 @@ impl Compiler {
             emit!(self, Instruction::StoreGlobal(doc))
         }
 
-        // PEP 649: Generate __annotate__ function instead of SetupAnnotations
+        // Handle annotations based on future_annotations flag
         if Self::find_ann(statements) {
-            self.compile_module_annotate(statements)?;
+            if self.future_annotations {
+                // PEP 563: Initialize __annotations__ dict
+                emit!(self, Instruction::SetupAnnotations);
+            } else {
+                // PEP 649: Generate __annotate__ function FIRST (before statements)
+                self.compile_module_annotate(statements)?;
+
+                // PEP 649: Initialize __conditional_annotations__ set after __annotate__
+                if self.current_symbol_table().has_conditional_annotations {
+                    emit!(self, Instruction::BuildSet { size: 0 });
+                    self.store_name("__conditional_annotations__")?;
+                }
+            }
         }
 
+        // Compile all statements
         self.compile_statements(statements)?;
 
         assert_eq!(self.code_stack.len(), size_before);
@@ -1624,11 +1694,25 @@ impl Compiler {
         body: &[Stmt],
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
+        // Set future_annotations from symbol table (detected during symbol table scan)
+        self.future_annotations = symbol_table.future_annotations;
         self.symbol_table_stack.push(symbol_table);
 
-        // PEP 649: Generate __annotate__ function instead of SetupAnnotations
+        // Handle annotations based on future_annotations flag
         if Self::find_ann(body) {
-            self.compile_module_annotate(body)?;
+            if self.future_annotations {
+                // PEP 563: Initialize __annotations__ dict
+                emit!(self, Instruction::SetupAnnotations);
+            } else {
+                // PEP 649: Generate __annotate__ function FIRST (before statements)
+                self.compile_module_annotate(body)?;
+
+                // PEP 649: Initialize __conditional_annotations__ set after __annotate__
+                if self.current_symbol_table().has_conditional_annotations {
+                    emit!(self, Instruction::BuildSet { size: 0 });
+                    self.store_name("__conditional_annotations__")?;
+                }
+            }
         }
 
         if let Some((last, body)) = body.split_last() {
@@ -1751,6 +1835,7 @@ impl Compiler {
             Global,
             Deref,
             Name,
+            DictOrGlobals, // PEP 649: can_see_class_scope
         }
 
         let name = self.mangle(name);
@@ -1768,10 +1853,11 @@ impl Compiler {
         let is_function_like = self.ctx.in_func();
 
         // Look up the symbol, handling TypeParams and Annotation scopes specially
-        let (symbol_scope, _is_special_scope) = {
+        let (symbol_scope, can_see_class_scope) = {
             let current_table = self.current_symbol_table();
             let is_typeparams = current_table.typ == CompilerScope::TypeParams;
             let is_annotation = current_table.typ == CompilerScope::Annotation;
+            let can_see_class = current_table.can_see_class_scope;
 
             // First try to find in current table
             let symbol = current_table.lookup(name.as_ref());
@@ -1786,14 +1872,46 @@ impl Compiler {
                 symbol
             };
 
-            (symbol.map(|s| s.scope), is_typeparams || is_annotation)
+            (symbol.map(|s| s.scope), can_see_class)
+        };
+
+        // Special handling for class scope implicit cell variables
+        // These are treated as Cell even if not explicitly marked in symbol table
+        // Only for LOAD operations - explicit stores like `__class__ = property(...)`
+        // should use STORE_NAME to store in class namespace dict
+        let symbol_scope = {
+            let current_table = self.current_symbol_table();
+            if current_table.typ == CompilerScope::Class
+                && usage == NameUsage::Load
+                && (name == "__class__"
+                    || name == "__classdict__"
+                    || name == "__conditional_annotations__")
+            {
+                Some(SymbolScope::Cell)
+            } else {
+                symbol_scope
+            }
         };
 
-        let actual_scope = symbol_scope.ok_or_else(|| {
-            self.error(CodegenErrorType::SyntaxError(format!(
-                "The symbol '{name}' must be present in the symbol table"
-            )))
-        })?;
+        // In annotation or type params scope, missing symbols are treated as global implicit
+        // This allows referencing global names like Union, Optional, etc. that are imported
+        // at module level but not explicitly bound in the function scope
+        let actual_scope = match symbol_scope {
+            Some(scope) => scope,
+            None => {
+                let current_table = self.current_symbol_table();
+                if matches!(
+                    current_table.typ,
+                    CompilerScope::Annotation | CompilerScope::TypeParams
+                ) {
+                    SymbolScope::GlobalImplicit
+                } else {
+                    return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                        "the symbol '{name}' must be present in the symbol table"
+                    ))));
+                }
+            }
+        };
 
         // Determine operation type based on scope
         let op_type = match actual_scope {
@@ -1807,7 +1925,11 @@ impl Compiler {
                 }
             }
             SymbolScope::GlobalImplicit => {
-                if is_function_like {
+                // PEP 649: In annotation scope with class visibility, use DictOrGlobals
+                // to check classdict first before globals
+                if can_see_class_scope {
+                    NameOp::DictOrGlobals
+                } else if is_function_like {
                     NameOp::Global
                 } else {
                     NameOp::Name
@@ -1867,6 +1989,25 @@ impl Compiler {
                 };
                 self.emit_arg(idx, op);
             }
+            NameOp::DictOrGlobals => {
+                // PEP 649: First check classdict (from __classdict__ freevar), then globals
+                let idx = self.get_global_name_index(&name);
+                match usage {
+                    NameUsage::Load => {
+                        // Load __classdict__ first (it's a free variable in annotation scope)
+                        let classdict_idx = self.get_free_var_index("__classdict__")?;
+                        self.emit_arg(classdict_idx, Instruction::LoadDeref);
+                        self.emit_arg(idx, Instruction::LoadFromDictOrGlobals);
+                    }
+                    // Store/Delete in annotation scope should use Name ops
+                    NameUsage::Store => {
+                        self.emit_arg(idx, Instruction::StoreName);
+                    }
+                    NameUsage::Delete => {
+                        self.emit_arg(idx, Instruction::DeleteName);
+                    }
+                }
+            }
         }
 
         Ok(())
@@ -2219,8 +2360,9 @@ impl Compiler {
                 target,
                 annotation,
                 value,
+                simple,
                 ..
-            }) => self.compile_annotated_assign(target, annotation, value.as_deref())?,
+            }) => self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?,
             Stmt::Delete(StmtDelete { targets, .. }) => {
                 for target in targets {
                     self.compile_delete(target)?;
@@ -3543,12 +3685,24 @@ impl Compiler {
     fn compile_module_annotate(&mut self, body: &[Stmt]) -> CompileResult<bool> {
         // Collect simple annotations from module body first
         let annotations = Self::collect_simple_annotations(body);
-        let num_annotations = u32::try_from(annotations.len()).expect("too many annotations");
 
-        if num_annotations == 0 {
+        if annotations.is_empty() {
             return Ok(false);
         }
 
+        // Check if we have conditional annotations
+        let has_conditional = self.current_symbol_table().has_conditional_annotations;
+
+        // Get parent scope type and name BEFORE pushing annotation symbol table
+        let parent_scope_type = self.current_symbol_table().typ;
+        let parent_name = self
+            .symbol_table_stack
+            .last()
+            .map(|t| t.name.as_str())
+            .unwrap_or("module")
+            .to_owned();
+        let scope_name = format!("<annotate of {parent_name}>");
+
         // Try to push annotation symbol table from current scope
         if !self.push_current_annotation_symbol_table() {
             return Ok(false);
@@ -3557,12 +3711,7 @@ impl Compiler {
         // Enter annotation scope for code generation
         let key = self.symbol_table_stack.len() - 1;
         let lineno = self.get_source_line_number().get();
-        self.enter_scope(
-            "<annotate of module>",
-            CompilerScope::Annotation,
-            key,
-            lineno.to_u32(),
-        )?;
+        self.enter_scope(&scope_name, CompilerScope::Annotation, key, lineno.to_u32())?;
 
         // Add 'format' parameter to varnames
         self.current_code_info()
@@ -3570,22 +3719,78 @@ impl Compiler {
             .varnames
             .insert("format".to_owned());
 
-        // Compile annotations inside the annotation scope
-        for (name, annotation) in annotations {
-            self.emit_load_const(ConstantData::Str {
-                value: self.mangle(name).into_owned().into(),
-            });
-            self.compile_annotation(annotation)?;
-        }
+        // Emit format validation: if format > VALUE_WITH_FAKE_GLOBALS: raise NotImplementedError
+        self.emit_format_validation()?;
 
-        // Build the map and return it
-        emit!(
-            self,
-            Instruction::BuildMap {
-                size: num_annotations,
+        if has_conditional {
+            // PEP 649: Build dict incrementally, checking conditional annotations
+            // Start with empty dict
+            emit!(self, Instruction::BuildMap { size: 0 });
+
+            // Process each annotation
+            for (idx, (name, annotation)) in annotations.iter().enumerate() {
+                // Check if index is in __conditional_annotations__
+                let not_set_block = self.new_block();
+
+                // LOAD_CONST index
+                self.emit_load_const(ConstantData::Integer { value: idx.into() });
+                // Load __conditional_annotations__ from appropriate scope
+                // Class scope: LoadDeref (freevars), Module scope: LoadGlobal
+                if parent_scope_type == CompilerScope::Class {
+                    let idx = self.get_free_var_index("__conditional_annotations__")?;
+                    emit!(self, Instruction::LoadDeref(idx));
+                } else {
+                    let cond_annotations_name = self.name("__conditional_annotations__");
+                    emit!(self, Instruction::LoadGlobal(cond_annotations_name));
+                }
+                // CONTAINS_OP (in)
+                emit!(self, Instruction::ContainsOp(bytecode::Invert::No));
+                // POP_JUMP_IF_FALSE not_set
+                emit!(
+                    self,
+                    Instruction::PopJumpIfFalse {
+                        target: not_set_block
+                    }
+                );
+
+                // Annotation value
+                self.compile_annotation(annotation)?;
+                // COPY dict to TOS
+                emit!(self, Instruction::Copy { index: 2 });
+                // LOAD_CONST name
+                self.emit_load_const(ConstantData::Str {
+                    value: self.mangle(name).into_owned().into(),
+                });
+                // STORE_SUBSCR - dict[name] = value
+                emit!(self, Instruction::StoreSubscr);
+
+                // not_set label
+                self.switch_to_block(not_set_block);
             }
-        );
-        emit!(self, Instruction::ReturnValue);
+
+            // Return the dict
+            emit!(self, Instruction::ReturnValue);
+        } else {
+            // No conditional annotations - use simple BuildMap
+            let num_annotations = u32::try_from(annotations.len()).expect("too many annotations");
+
+            // Compile annotations inside the annotation scope
+            for (name, annotation) in annotations {
+                self.emit_load_const(ConstantData::Str {
+                    value: self.mangle(name).into_owned().into(),
+                });
+                self.compile_annotation(annotation)?;
+            }
+
+            // Build the map and return it
+            emit!(
+                self,
+                Instruction::BuildMap {
+                    size: num_annotations,
+                }
+            );
+            emit!(self, Instruction::ReturnValue);
+        }
 
         // Exit annotation scope - pop symbol table, restore to parent's annotation_block, and get code
         let annotation_table = self.pop_symbol_table();
@@ -3604,8 +3809,13 @@ impl Compiler {
         // Make a closure from the code object
         self.make_closure(annotate_code, bytecode::MakeFunctionFlags::empty())?;
 
-        // Store as __annotate__
-        self.store_name("__annotate__")?;
+        // Store as __annotate_func__ for classes, __annotate__ for modules
+        let name = if parent_scope_type == CompilerScope::Class {
+            "__annotate_func__"
+        } else {
+            "__annotate__"
+        };
+        self.store_name(name)?;
 
         Ok(true)
     }
@@ -3762,10 +3972,14 @@ impl Compiler {
     fn get_ref_type(&self, name: &str) -> Result<SymbolScope, CodegenErrorType> {
         let table = self.symbol_table_stack.last().unwrap();
 
-        // Special handling for __class__ and __classdict__ in class scope
+        // Special handling for __class__, __classdict__, and __conditional_annotations__ in class scope
         // This should only apply when we're actually IN a class body,
         // not when we're in a method nested inside a class.
-        if table.typ == CompilerScope::Class && (name == "__class__" || name == "__classdict__") {
+        if table.typ == CompilerScope::Class
+            && (name == "__class__"
+                || name == "__classdict__"
+                || name == "__conditional_annotations__")
+        {
             return Ok(SymbolScope::Cell);
         }
         match table.lookup(name) {
@@ -4028,9 +4242,31 @@ impl Compiler {
             emit!(self, Instruction::StoreName(dunder_type_params));
         }
 
-        // PEP 649: Generate __annotate__ function for class annotations
+        // PEP 649: Initialize __classdict__ cell for class annotation scope
+        if self.current_symbol_table().needs_classdict {
+            let locals_name = self.name("locals");
+            emit!(self, Instruction::LoadName(locals_name));
+            emit!(self, Instruction::PushNull);
+            emit!(self, Instruction::Call { nargs: 0 });
+            let classdict_idx = self.get_cell_var_index("__classdict__")?;
+            emit!(self, Instruction::StoreDeref(classdict_idx));
+        }
+
+        // Handle class annotations based on future_annotations flag
         if Self::find_ann(body) {
-            self.compile_module_annotate(body)?;
+            if self.future_annotations {
+                // PEP 563: Initialize __annotations__ dict for class
+                emit!(self, Instruction::SetupAnnotations);
+            } else {
+                // PEP 649: Initialize __conditional_annotations__ set if needed for class
+                if self.current_symbol_table().has_conditional_annotations {
+                    emit!(self, Instruction::BuildSet { size: 0 });
+                    self.store_name("__conditional_annotations__")?;
+                }
+
+                // PEP 649: Generate __annotate__ function for class annotations
+                self.compile_module_annotate(body)?;
+            }
         }
 
         // 3. Compile the class body
@@ -5686,17 +5922,56 @@ impl Compiler {
         target: &Expr,
         annotation: &Expr,
         value: Option<&Expr>,
+        simple: bool,
     ) -> CompileResult<()> {
+        // Perform the actual assignment first
         if let Some(value) = value {
             self.compile_expression(value)?;
             self.compile_store(target)?;
         }
 
-        // PEP 649: Annotations in module/class scope are handled by __annotate__
-        // function, so we don't compile them here. Only in function scope do we
-        // evaluate annotations (though they're also ignored at runtime).
-        // In function scope, annotations are not evaluated at all.
-        let _ = annotation; // Mark as intentionally unused
+        // If we have a simple name in module or class scope, store annotation
+        if simple
+            && !self.ctx.in_func()
+            && let Expr::Name(ExprName { id, .. }) = target
+        {
+            if self.future_annotations {
+                // PEP 563: Store stringified annotation directly to __annotations__
+                // Compile annotation as string
+                self.compile_annotation(annotation)?;
+                // Load __annotations__
+                let annotations_name = self.name("__annotations__");
+                emit!(self, Instruction::LoadName(annotations_name));
+                // Load the variable name
+                self.emit_load_const(ConstantData::Str {
+                    value: self.mangle(id.as_str()).into_owned().into(),
+                });
+                // Store: __annotations__[name] = annotation
+                emit!(self, Instruction::StoreSubscr);
+            } else {
+                // PEP 649: Handle conditional annotations
+                if self.current_symbol_table().has_conditional_annotations {
+                    // Determine if this annotation is conditional
+                    let is_module = self.current_symbol_table().typ == CompilerScope::Module;
+                    let is_conditional = is_module || self.in_conditional_block;
+
+                    if is_conditional {
+                        // Get the current annotation index and increment
+                        let annotation_index = self.next_conditional_annotation_index;
+                        self.next_conditional_annotation_index += 1;
+
+                        // Add index to __conditional_annotations__ set
+                        let cond_annotations_name = self.name("__conditional_annotations__");
+                        emit!(self, Instruction::LoadName(cond_annotations_name));
+                        self.emit_load_const(ConstantData::Integer {
+                            value: annotation_index.into(),
+                        });
+                        emit!(self, Instruction::SetAdd { i: 0_u32 });
+                        emit!(self, Instruction::PopTop);
+                    }
+                }
+            }
+        }
 
         Ok(())
     }
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 4b85aaac502..0bc76b897dc 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -67,6 +67,13 @@ pub struct SymbolTable {
     /// PEP 649: Reference to annotation scope for this block
     /// Annotations are compiled as a separate `__annotate__` function
     pub annotation_block: Option<Box<SymbolTable>>,
+
+    /// PEP 649: Whether this scope has conditional annotations
+    /// (annotations inside if/for/while/etc. blocks or at module level)
+    pub has_conditional_annotations: bool,
+
+    /// Whether `from __future__ import annotations` is active
+    pub future_annotations: bool,
 }
 
 impl SymbolTable {
@@ -85,6 +92,8 @@ impl SymbolTable {
             can_see_class_scope: false,
             comp_inlined: false,
             annotation_block: None,
+            has_conditional_annotations: false,
+            future_annotations: false,
         }
     }
 
@@ -252,7 +261,8 @@ impl core::fmt::Debug for SymbolTable {
 fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
     let mut analyzer = SymbolTableAnalyzer::default();
     // Discard the newfree set at the top level - it's only needed for propagation
-    let _newfree = analyzer.analyze_symbol_table(symbol_table)?;
+    // Pass None for class_entry at top level
+    let _newfree = analyzer.analyze_symbol_table(symbol_table, None)?;
     Ok(())
 }
 
@@ -275,6 +285,12 @@ fn drop_class_free(symbol_table: &mut SymbolTable, newfree: &mut HashSet<String>
     if newfree.remove("__classdict__") {
         symbol_table.needs_classdict = true;
     }
+
+    // Check if __conditional_annotations__ is in the free variables collected from children
+    // Remove it from free set - it's handled specially in class scope
+    if newfree.remove("__conditional_annotations__") {
+        symbol_table.has_conditional_annotations = true;
+    }
 }
 
 type SymbolMap = IndexMap<String, Symbol>;
@@ -345,9 +361,11 @@ struct SymbolTableAnalyzer {
 impl SymbolTableAnalyzer {
     /// Analyze a symbol table and return the set of free variables.
     /// See symtable.c analyze_block().
+    /// class_entry: PEP 649 - enclosing class symbols for annotation scopes
     fn analyze_symbol_table(
         &mut self,
         symbol_table: &mut SymbolTable,
+        class_entry: Option<&SymbolMap>,
     ) -> SymbolTableResult<HashSet<String>> {
         let symbols = core::mem::take(&mut symbol_table.symbols);
         let sub_tables = &mut *symbol_table.sub_tables;
@@ -357,18 +375,38 @@ impl SymbolTableAnalyzer {
 
         let annotation_block = &mut symbol_table.annotation_block;
 
+        // PEP 649: Determine class_entry to pass to children
+        // If current scope is a class with annotation block that can_see_class_scope,
+        // we need to pass class symbols to the annotation scope
+        let is_class = symbol_table.typ == CompilerScope::Class;
+
+        // Clone class symbols if needed for annotation scope (to avoid borrow conflict)
+        let class_symbols_for_ann = if is_class
+            && annotation_block
+                .as_ref()
+                .is_some_and(|b| b.can_see_class_scope)
+        {
+            Some(symbols.clone())
+        } else {
+            None
+        };
+
         let mut info = (symbols, symbol_table.typ);
         self.tables.with_append(&mut info, |list| {
             let inner_scope = unsafe { &mut *(list as *mut _ as *mut Self) };
             // Analyze sub scopes and collect their free variables
             for sub_table in sub_tables.iter_mut() {
-                let child_free = inner_scope.analyze_symbol_table(sub_table)?;
+                // Sub-scopes (functions, nested classes) don't inherit class_entry
+                let child_free = inner_scope.analyze_symbol_table(sub_table, None)?;
                 // Propagate child's free variables to this scope
                 newfree.extend(child_free);
             }
             // PEP 649: Analyze annotation block if present
             if let Some(annotation_table) = annotation_block {
-                let child_free = inner_scope.analyze_symbol_table(annotation_table)?;
+                // Pass class symbols to annotation scope if can_see_class_scope
+                let ann_class_entry = class_symbols_for_ann.as_ref().or(class_entry);
+                let child_free =
+                    inner_scope.analyze_symbol_table(annotation_table, ann_class_entry)?;
                 // Propagate annotation's free variables to this scope
                 newfree.extend(child_free);
             }
@@ -410,7 +448,7 @@ impl SymbolTableAnalyzer {
 
         // Analyze symbols in current scope
         for symbol in symbol_table.symbols.values_mut() {
-            self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
+            self.analyze_symbol(symbol, symbol_table.typ, sub_tables, class_entry)?;
 
             // Collect free variables from this scope
             // These will be propagated to the parent scope
@@ -434,6 +472,7 @@ impl SymbolTableAnalyzer {
         symbol: &mut Symbol,
         st_typ: CompilerScope,
         sub_tables: &[SymbolTable],
+        class_entry: Option<&SymbolMap>,
     ) -> SymbolTableResult {
         if symbol
             .flags
@@ -453,7 +492,8 @@ impl SymbolTableAnalyzer {
                         // check if the name is already defined in any outer scope
                         // therefore
                         if scope_depth < 2
-                            || self.found_in_outer_scope(&symbol.name) != Some(SymbolScope::Free)
+                            || self.found_in_outer_scope(&symbol.name, st_typ)
+                                != Some(SymbolScope::Free)
                         {
                             return Err(SymbolTableError {
                                 error: format!("no binding for nonlocal '{}' found", symbol.name),
@@ -479,11 +519,23 @@ impl SymbolTableAnalyzer {
                     // all is well
                 }
                 SymbolScope::Unknown => {
+                    // PEP 649: Check class_entry first (like analyze_name)
+                    // If name is bound in enclosing class, mark as GlobalImplicit
+                    if let Some(class_symbols) = class_entry
+                        && let Some(class_sym) = class_symbols.get(&symbol.name)
+                    {
+                        // DEF_BOUND && !DEF_NONLOCAL -> GLOBAL_IMPLICIT
+                        if class_sym.is_bound() && class_sym.scope != SymbolScope::Free {
+                            symbol.scope = SymbolScope::GlobalImplicit;
+                            return Ok(());
+                        }
+                    }
+
                     // Try hard to figure out what the scope of this symbol is.
                     let scope = if symbol.is_bound() {
                         self.found_in_inner_scope(sub_tables, &symbol.name, st_typ)
                             .unwrap_or(SymbolScope::Local)
-                    } else if let Some(scope) = self.found_in_outer_scope(&symbol.name) {
+                    } else if let Some(scope) = self.found_in_outer_scope(&symbol.name, st_typ) {
                         scope
                     } else if self.tables.is_empty() {
                         // Don't make assumptions when we don't know.
@@ -499,18 +551,40 @@ impl SymbolTableAnalyzer {
         Ok(())
     }
 
-    fn found_in_outer_scope(&mut self, name: &str) -> Option<SymbolScope> {
+    fn found_in_outer_scope(&mut self, name: &str, st_typ: CompilerScope) -> Option<SymbolScope> {
         let mut decl_depth = None;
         for (i, (symbols, typ)) in self.tables.iter().rev().enumerate() {
             if matches!(typ, CompilerScope::Module)
-                || matches!(typ, CompilerScope::Class if name != "__class__")
+                || matches!(typ, CompilerScope::Class if name != "__class__" && name != "__classdict__" && name != "__conditional_annotations__")
+            {
+                continue;
+            }
+
+            // PEP 649: Annotation scope is conceptually a sibling of the function,
+            // not a child. Skip the immediate parent function scope when looking
+            // for outer variables from annotation scope.
+            if st_typ == CompilerScope::Annotation
+                && i == 0
+                && matches!(
+                    typ,
+                    CompilerScope::Function | CompilerScope::AsyncFunction | CompilerScope::Lambda
+                )
             {
                 continue;
             }
 
-            // __class__ is implicitly declared in class scope
-            // This handles the case where super() is called in a nested class method
-            if name == "__class__" && matches!(typ, CompilerScope::Class) {
+            // __class__ and __classdict__ are implicitly declared in class scope
+            // This handles the case where nested scopes reference them
+            if (name == "__class__" || name == "__classdict__")
+                && matches!(typ, CompilerScope::Class)
+            {
+                decl_depth = Some(i);
+                break;
+            }
+
+            // __conditional_annotations__ is implicitly declared in class scope
+            // for classes with conditional annotations
+            if name == "__conditional_annotations__" && matches!(typ, CompilerScope::Class) {
                 decl_depth = Some(i);
                 break;
             }
@@ -716,6 +790,8 @@ struct SymbolTableBuilder {
     in_comp_inner_loop_target: bool,
     // Scope info for error messages (e.g., "a TypeVar bound")
     scope_info: Option<&'static str>,
+    // PEP 649: Track if we're inside a conditional block (if/for/while/etc.)
+    in_conditional_block: bool,
 }
 
 /// Enum to indicate in what mode an expression
@@ -744,6 +820,7 @@ impl SymbolTableBuilder {
             in_type_alias: false,
             in_comp_inner_loop_target: false,
             scope_info: None,
+            in_conditional_block: false,
         };
         this.enter_scope("top", CompilerScope::Module, 0);
         this
@@ -754,6 +831,8 @@ impl SymbolTableBuilder {
         let mut symbol_table = self.tables.pop().unwrap();
         // Save varnames for the top-level module scope
         symbol_table.varnames = self.current_varnames;
+        // Propagate future_annotations to the symbol table
+        symbol_table.future_annotations = self.future_annotations;
         analyze_symbol_table(&mut symbol_table)?;
         Ok(symbol_table)
     }
@@ -808,6 +887,7 @@ impl SymbolTableBuilder {
     fn enter_annotation_scope(&mut self, line_number: u32) {
         let current = self.tables.last_mut().unwrap();
         let can_see_class_scope = current.typ == CompilerScope::Class;
+        let has_conditional = current.has_conditional_annotations;
 
         // Create annotation block if not exists
         if current.annotation_block.is_none() {
@@ -828,6 +908,14 @@ impl SymbolTableBuilder {
         let annotation_table = current.annotation_block.take().unwrap();
         self.tables.push(*annotation_table);
         self.current_varnames.clear();
+
+        if can_see_class_scope && !self.future_annotations {
+            self.add_classdict_freevar();
+            // Also add __conditional_annotations__ as free var if parent has conditional annotations
+            if has_conditional {
+                self.add_conditional_annotations_freevar();
+            }
+        }
     }
 
     /// Leave annotation scope (PEP 649)
@@ -837,7 +925,34 @@ impl SymbolTableBuilder {
         // Save the collected varnames to the symbol table
         table.varnames = core::mem::take(&mut self.current_varnames);
         // Store back to parent's annotation_block (not sub_tables)
-        self.tables.last_mut().unwrap().annotation_block = Some(Box::new(table));
+        let parent = self.tables.last_mut().unwrap();
+        parent.annotation_block = Some(Box::new(table));
+    }
+
+    fn add_classdict_freevar(&mut self) {
+        let table = self.tables.last_mut().unwrap();
+        let name = "__classdict__";
+        let symbol = table
+            .symbols
+            .entry(name.to_owned())
+            .or_insert_with(|| Symbol::new(name));
+        symbol.scope = SymbolScope::Free;
+        symbol
+            .flags
+            .insert(SymbolFlags::REFERENCED | SymbolFlags::FREE_CLASS);
+    }
+
+    fn add_conditional_annotations_freevar(&mut self) {
+        let table = self.tables.last_mut().unwrap();
+        let name = "__conditional_annotations__";
+        let symbol = table
+            .symbols
+            .entry(name.to_owned())
+            .or_insert_with(|| Symbol::new(name));
+        symbol.scope = SymbolScope::Free;
+        symbol
+            .flags
+            .insert(SymbolFlags::REFERENCED | SymbolFlags::FREE_CLASS);
     }
 
     fn line_index_start(&self, range: TextRange) -> u32 {
@@ -888,31 +1003,58 @@ impl SymbolTableBuilder {
     }
 
     fn scan_annotation(&mut self, annotation: &Expr) -> SymbolTableResult {
-        if self.future_annotations {
-            // PEP 563: annotations are stringified
-            Ok(())
-        } else {
-            // PEP 649: annotations are deferred in a separate scope
-            let line_number = self.line_index_start(annotation.range());
-            self.enter_annotation_scope(line_number);
+        let current_scope = self.tables.last().map(|t| t.typ);
+
+        // PEP 649: Check if this is a conditional annotation
+        // Module-level: always conditional (module may be partially executed)
+        // Class-level: conditional only when inside if/for/while/etc.
+        if !self.future_annotations {
+            let is_conditional = matches!(current_scope, Some(CompilerScope::Module))
+                || (matches!(current_scope, Some(CompilerScope::Class))
+                    && self.in_conditional_block);
+
+            if is_conditional && !self.tables.last().unwrap().has_conditional_annotations {
+                self.tables.last_mut().unwrap().has_conditional_annotations = true;
+                // Register __conditional_annotations__ symbol in the scope (USE flag, not DEF)
+                self.register_name(
+                    "__conditional_annotations__",
+                    SymbolUsage::Used,
+                    annotation.range(),
+                )?;
+            }
+        }
 
-            let was_in_annotation = self.in_annotation;
-            self.in_annotation = true;
-            let result = self.scan_expression(annotation, ExpressionContext::Load);
-            self.in_annotation = was_in_annotation;
+        // Create annotation scope for deferred evaluation
+        let line_number = self.line_index_start(annotation.range());
+        self.enter_annotation_scope(line_number);
 
+        if self.future_annotations {
+            // PEP 563: annotations are stringified at compile time
+            // Don't scan expression - symbols would fail to resolve
+            // Just create the annotation_block structure
             self.leave_annotation_scope();
+            return Ok(());
+        }
+
+        // PEP 649: scan expression for symbol references
+        // Class annotations are evaluated in class locals (not module globals)
+        let was_in_annotation = self.in_annotation;
+        self.in_annotation = true;
+        let result = self.scan_expression(annotation, ExpressionContext::Load);
+        self.in_annotation = was_in_annotation;
+
+        self.leave_annotation_scope();
 
-            // Also scan in parent scope for immediate evaluation compatibility
-            // This ensures symbols like builtins are available in the module scope
-            // TODO: Remove this once full PEP 649 deferred compilation is implemented
+        // Module scope: re-scan to register symbols (builtins like str, int)
+        // Class scope: do NOT re-scan to preserve class-local symbol resolution
+        if matches!(current_scope, Some(CompilerScope::Module)) {
             let was_in_annotation = self.in_annotation;
             self.in_annotation = true;
             let _ = self.scan_expression(annotation, ExpressionContext::Load);
             self.in_annotation = was_in_annotation;
-
-            result
         }
+
+        result
     }
 
     fn scan_statement(&mut self, statement: &Stmt) -> SymbolTableResult {
@@ -948,25 +1090,22 @@ impl SymbolTableBuilder {
                 self.scan_decorators(decorator_list, ExpressionContext::Load)?;
                 self.register_ident(name, SymbolUsage::Assigned)?;
 
-                // When in class scope, save the class's annotation_block before scanning
-                // function annotations, so method annotations don't interfere with class annotations
-                let parent_is_class = self
-                    .tables
-                    .last()
-                    .map(|t| t.typ == CompilerScope::Class)
-                    .unwrap_or(false);
-                let saved_annotation_block = if parent_is_class {
+                // Save the parent's annotation_block before scanning function annotations,
+                // so function annotations don't interfere with parent scope annotations.
+                // This applies to both class scope (methods) and module scope (top-level functions).
+                let parent_scope_typ = self.tables.last().map(|t| t.typ);
+                let should_save_annotation_block = matches!(
+                    parent_scope_typ,
+                    Some(CompilerScope::Class) | Some(CompilerScope::Module)
+                );
+                let saved_annotation_block = if should_save_annotation_block {
                     self.tables.last_mut().unwrap().annotation_block.take()
                 } else {
                     None
                 };
 
-                let has_return_annotation = if let Some(expression) = returns {
-                    self.scan_annotation(expression)?;
-                    true
-                } else {
-                    false
-                };
+                // For generic functions, enter type_param block FIRST so that
+                // annotation scopes are nested inside and can see type parameters.
                 if let Some(type_params) = type_params {
                     self.enter_type_param_block(
                         &format!("<generic parameters of {}>", name.as_str()),
@@ -974,6 +1113,12 @@ impl SymbolTableBuilder {
                     )?;
                     self.scan_type_params(type_params)?;
                 }
+                let has_return_annotation = if let Some(expression) = returns {
+                    self.scan_annotation(expression)?;
+                    true
+                } else {
+                    false
+                };
                 self.enter_scope_with_parameters(
                     name.as_str(),
                     parameters,
@@ -986,7 +1131,7 @@ impl SymbolTableBuilder {
                     self.leave_scope();
                 }
 
-                // Restore class's annotation_block after processing the function
+                // Restore parent's annotation_block after processing the function
                 if let Some(block) = saved_annotation_block {
                     self.tables.last_mut().unwrap().annotation_block = Some(block);
                 }
@@ -1012,6 +1157,10 @@ impl SymbolTableBuilder {
                     CompilerScope::Class,
                     self.line_index_start(*range),
                 );
+                // Reset in_conditional_block for new class scope
+                // (each scope has its own conditional context)
+                let saved_in_conditional = self.in_conditional_block;
+                self.in_conditional_block = false;
                 let prev_class = self.class_name.replace(name.to_string());
                 self.register_name("__module__", SymbolUsage::Assigned, *range)?;
                 self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
@@ -1019,6 +1168,7 @@ impl SymbolTableBuilder {
                 self.register_name("__class__", SymbolUsage::Assigned, *range)?;
                 self.scan_statements(body)?;
                 self.leave_scope();
+                self.in_conditional_block = saved_in_conditional;
                 self.class_name = prev_class;
                 if let Some(arguments) = arguments {
                     self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
@@ -1042,6 +1192,9 @@ impl SymbolTableBuilder {
                 ..
             }) => {
                 self.scan_expression(test, ExpressionContext::Load)?;
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 self.scan_statements(body)?;
                 for elif in elif_else_clauses {
                     if let Some(test) = &elif.test {
@@ -1049,6 +1202,7 @@ impl SymbolTableBuilder {
                     }
                     self.scan_statements(&elif.body)?;
                 }
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::For(StmtFor {
                 target,
@@ -1059,15 +1213,23 @@ impl SymbolTableBuilder {
             }) => {
                 self.scan_expression(target, ExpressionContext::Store)?;
                 self.scan_expression(iter, ExpressionContext::Load)?;
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 self.scan_statements(body)?;
                 self.scan_statements(orelse)?;
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::While(StmtWhile {
                 test, body, orelse, ..
             }) => {
                 self.scan_expression(test, ExpressionContext::Load)?;
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 self.scan_statements(body)?;
                 self.scan_statements(orelse)?;
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::Break(_) | Stmt::Continue(_) | Stmt::Pass(_) => {
                 // No symbols here.
@@ -1134,13 +1296,20 @@ impl SymbolTableBuilder {
                 match &**target {
                     Expr::Name(ast::ExprName { id, .. }) if *simple => {
                         self.register_name(id.as_str(), SymbolUsage::AnnotationAssigned, *range)?;
-                        // PEP 649: Register __annotate__ in module/class scope for deferred annotations
+                        // PEP 649: Register annotate function in module/class scope
                         let current_scope = self.tables.last().map(|t| t.typ);
-                        if matches!(
-                            current_scope,
-                            Some(CompilerScope::Module) | Some(CompilerScope::Class)
-                        ) {
-                            self.register_name("__annotate__", SymbolUsage::Assigned, *range)?;
+                        match current_scope {
+                            Some(CompilerScope::Module) => {
+                                self.register_name("__annotate__", SymbolUsage::Assigned, *range)?;
+                            }
+                            Some(CompilerScope::Class) => {
+                                self.register_name(
+                                    "__annotate_func__",
+                                    SymbolUsage::Assigned,
+                                    *range,
+                                )?;
+                            }
+                            _ => {}
                         }
                     }
                     _ => {
@@ -1159,7 +1328,11 @@ impl SymbolTableBuilder {
                         self.scan_expression(expression, ExpressionContext::Store)?;
                     }
                 }
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 self.scan_statements(body)?;
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::Try(StmtTry {
                 body,
@@ -1168,6 +1341,9 @@ impl SymbolTableBuilder {
                 finalbody,
                 ..
             }) => {
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 self.scan_statements(body)?;
                 for handler in handlers {
                     let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
@@ -1186,9 +1362,13 @@ impl SymbolTableBuilder {
                 }
                 self.scan_statements(orelse)?;
                 self.scan_statements(finalbody)?;
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::Match(StmtMatch { subject, cases, .. }) => {
                 self.scan_expression(subject, ExpressionContext::Load)?;
+                // PEP 649: Track conditional block for annotations
+                let saved_in_conditional_block = self.in_conditional_block;
+                self.in_conditional_block = true;
                 for case in cases {
                     self.scan_pattern(&case.pattern)?;
                     if let Some(guard) = &case.guard {
@@ -1196,6 +1376,7 @@ impl SymbolTableBuilder {
                     }
                     self.scan_statements(&case.body)?;
                 }
+                self.in_conditional_block = saved_in_conditional_block;
             }
             Stmt::Raise(StmtRaise { exc, cause, .. }) => {
                 if let Some(expression) = exc {
@@ -1980,6 +2161,20 @@ impl SymbolTableBuilder {
             .to_source_code()
             .source_location(range.start(), PositionEncoding::Utf8);
         let location = Some(location);
+
+        // Check for forbidden names like __debug__
+        if name == "__debug__"
+            && matches!(
+                role,
+                SymbolUsage::Parameter | SymbolUsage::AnnotationParameter | SymbolUsage::Assigned
+            )
+        {
+            return Err(SymbolTableError {
+                error: "cannot assign to __debug__".to_owned(),
+                location,
+            });
+        }
+
         let scope_depth = self.tables.len();
         let table = self.tables.last_mut().unwrap();
 
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
index 2daac15ceae..27cc7135278 100644
--- a/crates/vm/src/builtins/module.rs
+++ b/crates/vm/src/builtins/module.rs
@@ -186,7 +186,8 @@ impl PyModule {
     #[pygetset]
     fn __annotate__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
         let dict = zelf.dict();
-        // Get __annotate__ from dict, set to None if not present
+        // Get __annotate__ from dict; if not present, insert None and return it
+        // See: module_get_annotate()
         if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
             Ok(annotate)
         } else {
@@ -228,25 +229,43 @@ impl PyModule {
             return Ok(annotations);
         }
 
+        // Check if module is initializing
+        let is_initializing = Self::is_initializing(&dict, vm);
+
         // PEP 649: Get __annotate__ and call it if callable
-        // Don't cache the result to dict - __annotations__ should only appear
-        // in __dict__ if explicitly set
-        if let Some(annotate) = dict.get_item_opt(identifier!(vm, __annotate__), vm)? {
-            if annotate.is_callable() {
-                // Call __annotate__(1) where 1 is FORMAT_VALUE
-                let result = annotate.call((1i32,), vm)?;
-                if !result.class().is(vm.ctx.types.dict_type) {
-                    return Err(vm.new_type_error(format!(
-                        "__annotate__ returned non-dict of type '{}'",
-                        result.class().name()
-                    )));
-                }
-                return Ok(result);
+        let annotations = if let Some(annotate) =
+            dict.get_item_opt(identifier!(vm, __annotate__), vm)?
+            && annotate.is_callable()
+        {
+            // Call __annotate__(1) where 1 is FORMAT_VALUE
+            let result = annotate.call((1i32,), vm)?;
+            if !result.class().is(vm.ctx.types.dict_type) {
+                return Err(vm.new_type_error(format!(
+                    "__annotate__ returned non-dict of type '{}'",
+                    result.class().name()
+                )));
             }
+            result
+        } else {
+            vm.ctx.new_dict().into()
+        };
+
+        // Cache result unless module is initializing
+        if !is_initializing {
+            dict.set_item(identifier!(vm, __annotations__), annotations.clone(), vm)?;
         }
 
-        // No __annotate__ or not callable - return empty dict
-        Ok(vm.ctx.new_dict().into())
+        Ok(annotations)
+    }
+
+    /// Check if module is initializing via __spec__._initializing
+    fn is_initializing(dict: &PyDictRef, vm: &VirtualMachine) -> bool {
+        if let Ok(Some(spec)) = dict.get_item_opt(vm.ctx.intern_str("__spec__"), vm)
+            && let Ok(initializing) = spec.get_attr(vm.ctx.intern_str("_initializing"), vm)
+        {
+            return initializing.try_to_bool(vm).unwrap_or(false);
+        }
+        false
     }
 
     #[pygetset(setter)]
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index b3e4956d236..829f7d4439a 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -860,22 +860,19 @@ impl PyType {
             )));
         }
 
-        let attrs = self.attributes.read();
+        let mut attrs = self.attributes.write();
         // First try __annotate__, in case that's been set explicitly
         if let Some(annotate) = attrs.get(identifier!(vm, __annotate__)).cloned() {
             return Ok(annotate);
         }
         // Then try __annotate_func__
         if let Some(annotate) = attrs.get(identifier!(vm, __annotate_func__)).cloned() {
+            // TODO: Apply descriptor tp_descr_get if needed
             return Ok(annotate);
         }
-        drop(attrs);
-
-        // Set None if not found
+        // Set __annotate_func__ = None and return None
         let none = vm.ctx.none();
-        self.attributes
-            .write()
-            .insert(identifier!(vm, __annotate_func__), none.clone());
+        attrs.insert(identifier!(vm, __annotate_func__), none.clone());
         Ok(none)
     }
 
@@ -898,6 +895,7 @@ impl PyType {
         }
 
         let mut attrs = self.attributes.write();
+        // Store to __annotate_func__
         attrs.insert(identifier!(vm, __annotate_func__), value.clone());
         // Always clear cached annotations when __annotate__ is updated
         attrs.swap_remove(identifier!(vm, __annotations_cache__));
@@ -958,24 +956,35 @@ impl PyType {
         }
 
         let mut attrs = self.attributes.write();
-        if let Some(value) = value {
-            attrs.insert(identifier!(vm, __annotations__), value);
-            // Clear __annotate__ when __annotations__ is set
-            attrs.swap_remove(identifier!(vm, __annotate__));
-        } else {
-            // Delete
-            if attrs
+        // conditional update based on __annotations__ presence
+        let has_annotations = attrs.contains_key(identifier!(vm, __annotations__));
+
+        if has_annotations {
+            // If __annotations__ is in dict, update it
+            if let Some(value) = value {
+                attrs.insert(identifier!(vm, __annotations__), value);
+            } else if attrs
                 .swap_remove(identifier!(vm, __annotations__))
                 .is_none()
             {
-                return Err(vm.new_attribute_error(format!(
-                    "'{}' object has no attribute '__annotations__'",
-                    self.name()
-                )));
+                return Err(vm.new_attribute_error("__annotations__".to_owned()));
+            }
+            // Also clear __annotations_cache__
+            attrs.swap_remove(identifier!(vm, __annotations_cache__));
+        } else {
+            // Otherwise update only __annotations_cache__
+            if let Some(value) = value {
+                attrs.insert(identifier!(vm, __annotations_cache__), value);
+            } else if attrs
+                .swap_remove(identifier!(vm, __annotations_cache__))
+                .is_none()
+            {
+                return Err(vm.new_attribute_error("__annotations__".to_owned()));
             }
-            // Also clear __annotate__
-            attrs.swap_remove(identifier!(vm, __annotate__));
         }
+        // Always clear __annotate_func__ and __annotate__
+        attrs.swap_remove(identifier!(vm, __annotate_func__));
+        attrs.swap_remove(identifier!(vm, __annotate__));
 
         Ok(())
     }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 3e356466e5c..d83be841275 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1168,6 +1168,29 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
+            Instruction::LoadFromDictOrGlobals(idx) => {
+                // PEP 649: Pop dict from stack (classdict), check there first, then globals
+                let dict = self.pop_value();
+                let name = self.code.names[idx.get(arg) as usize];
+
+                // Only treat KeyError as "not found", propagate other exceptions
+                let value = if let Some(dict_obj) = dict.downcast_ref::<PyDict>() {
+                    dict_obj.get_item_opt(name, vm)?
+                } else {
+                    // Not an exact dict, use mapping protocol
+                    match dict.get_item(name, vm) {
+                        Ok(v) => Some(v),
+                        Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => None,
+                        Err(e) => return Err(e),
+                    }
+                };
+
+                self.push_value(match value {
+                    Some(v) => v,
+                    None => self.load_global_or_builtin(name, vm)?,
+                });
+                Ok(None)
+            }
             Instruction::LoadClosure(i) => {
                 let value = self.cells_frees[i.get(arg) as usize].clone();
                 self.push_value(value.into());
diff --git a/extra_tests/snippets/stdlib_typing.py b/extra_tests/snippets/stdlib_typing.py
index 681790abd0b..433d728c067 100644
--- a/extra_tests/snippets/stdlib_typing.py
+++ b/extra_tests/snippets/stdlib_typing.py
@@ -12,3 +12,26 @@ def abort_signal_handler(
 
 # Ensure PEP 604 unions work with typing.Callable aliases.
 TracebackFilter = bool | Callable[[int], int]
+
+
+# Test that Union/Optional in function parameter annotations work correctly.
+# This tests that annotation scopes can access global implicit symbols (like Union)
+# that are imported at module level but not explicitly bound in the function scope.
+# Regression test for: rich
+from typing import Union, Optional
+
+
+def function_with_union_param(x: Optional[Union[int, str]] = None) -> None:
+    pass
+
+
+class ClassWithUnionParams:
+    def __init__(
+        self,
+        color: Optional[Union[str, int]] = None,
+        bold: Optional[bool] = None,
+    ) -> None:
+        pass
+
+    def method(self, value: Union[int, float]) -> Union[str, bytes]:
+        return str(value)

From dc93614f5a7799aa027a401f70869fad69b1bdd4 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Fri, 16 Jan 2026 00:36:21 +0900
Subject: [PATCH 325/418] Add annotationlib,ann_module from 3.14.2

also partially update test_module
---
 Lib/annotationlib.py                 | 1143 ++++++++++++++++++++++++++
 Lib/test/test_module/__init__.py     |    6 +-
 Lib/test/typinganndata/ann_module.py |    4 -
 3 files changed, 1148 insertions(+), 5 deletions(-)
 create mode 100644 Lib/annotationlib.py

diff --git a/Lib/annotationlib.py b/Lib/annotationlib.py
new file mode 100644
index 00000000000..a5788cdbfae
--- /dev/null
+++ b/Lib/annotationlib.py
@@ -0,0 +1,1143 @@
+"""Helpers for introspecting and wrapping annotations."""
+
+import ast
+import builtins
+import enum
+import keyword
+import sys
+import types
+
+__all__ = [
+    "Format",
+    "ForwardRef",
+    "call_annotate_function",
+    "call_evaluate_function",
+    "get_annotate_from_class_namespace",
+    "get_annotations",
+    "annotations_to_string",
+    "type_repr",
+]
+
+
+class Format(enum.IntEnum):
+    VALUE = 1
+    VALUE_WITH_FAKE_GLOBALS = 2
+    FORWARDREF = 3
+    STRING = 4
+
+
+_sentinel = object()
+# Following `NAME_ERROR_MSG` in `ceval_macros.h`:
+_NAME_ERROR_MSG = "name '{name:.200}' is not defined"
+
+
+# Slots shared by ForwardRef and _Stringifier. The __forward__ names must be
+# preserved for compatibility with the old typing.ForwardRef class. The remaining
+# names are private.
+_SLOTS = (
+    "__forward_is_argument__",
+    "__forward_is_class__",
+    "__forward_module__",
+    "__weakref__",
+    "__arg__",
+    "__globals__",
+    "__extra_names__",
+    "__code__",
+    "__ast_node__",
+    "__cell__",
+    "__owner__",
+    "__stringifier_dict__",
+)
+
+
+class ForwardRef:
+    """Wrapper that holds a forward reference.
+
+    Constructor arguments:
+    * arg: a string representing the code to be evaluated.
+    * module: the module where the forward reference was created.
+      Must be a string, not a module object.
+    * owner: The owning object (module, class, or function).
+    * is_argument: Does nothing, retained for compatibility.
+    * is_class: True if the forward reference was created in class scope.
+
+    """
+
+    __slots__ = _SLOTS
+
+    def __init__(
+        self,
+        arg,
+        *,
+        module=None,
+        owner=None,
+        is_argument=True,
+        is_class=False,
+    ):
+        if not isinstance(arg, str):
+            raise TypeError(f"Forward reference must be a string -- got {arg!r}")
+
+        self.__arg__ = arg
+        self.__forward_is_argument__ = is_argument
+        self.__forward_is_class__ = is_class
+        self.__forward_module__ = module
+        self.__owner__ = owner
+        # These are always set to None here but may be non-None if a ForwardRef
+        # is created through __class__ assignment on a _Stringifier object.
+        self.__globals__ = None
+        # This may be either a cell object (for a ForwardRef referring to a single name)
+        # or a dict mapping cell names to cell objects (for a ForwardRef containing references
+        # to multiple names).
+        self.__cell__ = None
+        self.__extra_names__ = None
+        # These are initially None but serve as a cache and may be set to a non-None
+        # value later.
+        self.__code__ = None
+        self.__ast_node__ = None
+
+    def __init_subclass__(cls, /, *args, **kwds):
+        raise TypeError("Cannot subclass ForwardRef")
+
+    def evaluate(
+        self,
+        *,
+        globals=None,
+        locals=None,
+        type_params=None,
+        owner=None,
+        format=Format.VALUE,
+    ):
+        """Evaluate the forward reference and return the value.
+
+        If the forward reference cannot be evaluated, raise an exception.
+        """
+        match format:
+            case Format.STRING:
+                return self.__forward_arg__
+            case Format.VALUE:
+                is_forwardref_format = False
+            case Format.FORWARDREF:
+                is_forwardref_format = True
+            case _:
+                raise NotImplementedError(format)
+        if isinstance(self.__cell__, types.CellType):
+            try:
+                return self.__cell__.cell_contents
+            except ValueError:
+                pass
+        if owner is None:
+            owner = self.__owner__
+
+        if globals is None and self.__forward_module__ is not None:
+            globals = getattr(
+                sys.modules.get(self.__forward_module__, None), "__dict__", None
+            )
+        if globals is None:
+            globals = self.__globals__
+        if globals is None:
+            if isinstance(owner, type):
+                module_name = getattr(owner, "__module__", None)
+                if module_name:
+                    module = sys.modules.get(module_name, None)
+                    if module:
+                        globals = getattr(module, "__dict__", None)
+            elif isinstance(owner, types.ModuleType):
+                globals = getattr(owner, "__dict__", None)
+            elif callable(owner):
+                globals = getattr(owner, "__globals__", None)
+
+        # If we pass None to eval() below, the globals of this module are used.
+        if globals is None:
+            globals = {}
+
+        if type_params is None and owner is not None:
+            type_params = getattr(owner, "__type_params__", None)
+
+        if locals is None:
+            locals = {}
+            if isinstance(owner, type):
+                locals.update(vars(owner))
+        elif (
+            type_params is not None
+            or isinstance(self.__cell__, dict)
+            or self.__extra_names__
+        ):
+            # Create a new locals dict if necessary,
+            # to avoid mutating the argument.
+            locals = dict(locals)
+
+        # "Inject" type parameters into the local namespace
+        # (unless they are shadowed by assignments *in* the local namespace),
+        # as a way of emulating annotation scopes when calling `eval()`
+        if type_params is not None:
+            for param in type_params:
+                locals.setdefault(param.__name__, param)
+
+        # Similar logic can be used for nonlocals, which should not
+        # override locals.
+        if isinstance(self.__cell__, dict):
+            for cell_name, cell in self.__cell__.items():
+                try:
+                    cell_value = cell.cell_contents
+                except ValueError:
+                    pass
+                else:
+                    locals.setdefault(cell_name, cell_value)
+
+        if self.__extra_names__:
+            locals.update(self.__extra_names__)
+
+        arg = self.__forward_arg__
+        if arg.isidentifier() and not keyword.iskeyword(arg):
+            if arg in locals:
+                return locals[arg]
+            elif arg in globals:
+                return globals[arg]
+            elif hasattr(builtins, arg):
+                return getattr(builtins, arg)
+            elif is_forwardref_format:
+                return self
+            else:
+                raise NameError(_NAME_ERROR_MSG.format(name=arg), name=arg)
+        else:
+            code = self.__forward_code__
+            try:
+                return eval(code, globals=globals, locals=locals)
+            except Exception:
+                if not is_forwardref_format:
+                    raise
+
+            # All variables, in scoping order, should be checked before
+            # triggering __missing__ to create a _Stringifier.
+            new_locals = _StringifierDict(
+                {**builtins.__dict__, **globals, **locals},
+                globals=globals,
+                owner=owner,
+                is_class=self.__forward_is_class__,
+                format=format,
+            )
+            try:
+                result = eval(code, globals=globals, locals=new_locals)
+            except Exception:
+                return self
+            else:
+                new_locals.transmogrify(self.__cell__)
+                return result
+
+    def _evaluate(self, globalns, localns, type_params=_sentinel, *, recursive_guard):
+        import typing
+        import warnings
+
+        if type_params is _sentinel:
+            typing._deprecation_warning_for_no_type_params_passed(
+                "typing.ForwardRef._evaluate"
+            )
+            type_params = ()
+        warnings._deprecated(
+            "ForwardRef._evaluate",
+            "{name} is a private API and is retained for compatibility, but will be removed"
+            " in Python 3.16. Use ForwardRef.evaluate() or typing.evaluate_forward_ref() instead.",
+            remove=(3, 16),
+        )
+        return typing.evaluate_forward_ref(
+            self,
+            globals=globalns,
+            locals=localns,
+            type_params=type_params,
+            _recursive_guard=recursive_guard,
+        )
+
+    @property
+    def __forward_arg__(self):
+        if self.__arg__ is not None:
+            return self.__arg__
+        if self.__ast_node__ is not None:
+            self.__arg__ = ast.unparse(self.__ast_node__)
+            return self.__arg__
+        raise AssertionError(
+            "Attempted to access '__forward_arg__' on an uninitialized ForwardRef"
+        )
+
+    @property
+    def __forward_code__(self):
+        if self.__code__ is not None:
+            return self.__code__
+        arg = self.__forward_arg__
+        try:
+            self.__code__ = compile(_rewrite_star_unpack(arg), "<string>", "eval")
+        except SyntaxError:
+            raise SyntaxError(f"Forward reference must be an expression -- got {arg!r}")
+        return self.__code__
+
+    def __eq__(self, other):
+        if not isinstance(other, ForwardRef):
+            return NotImplemented
+        return (
+            self.__forward_arg__ == other.__forward_arg__
+            and self.__forward_module__ == other.__forward_module__
+            # Use "is" here because we use id() for this in __hash__
+            # because dictionaries are not hashable.
+            and self.__globals__ is other.__globals__
+            and self.__forward_is_class__ == other.__forward_is_class__
+            and self.__cell__ == other.__cell__
+            and self.__owner__ == other.__owner__
+            and (
+                (tuple(sorted(self.__extra_names__.items())) if self.__extra_names__ else None) ==
+                (tuple(sorted(other.__extra_names__.items())) if other.__extra_names__ else None)
+            )
+        )
+
+    def __hash__(self):
+        return hash((
+            self.__forward_arg__,
+            self.__forward_module__,
+            id(self.__globals__),  # dictionaries are not hashable, so hash by identity
+            self.__forward_is_class__,
+            tuple(sorted(self.__cell__.items())) if isinstance(self.__cell__, dict) else self.__cell__,
+            self.__owner__,
+            tuple(sorted(self.__extra_names__.items())) if self.__extra_names__ else None,
+        ))
+
+    def __or__(self, other):
+        return types.UnionType[self, other]
+
+    def __ror__(self, other):
+        return types.UnionType[other, self]
+
+    def __repr__(self):
+        extra = []
+        if self.__forward_module__ is not None:
+            extra.append(f", module={self.__forward_module__!r}")
+        if self.__forward_is_class__:
+            extra.append(", is_class=True")
+        if self.__owner__ is not None:
+            extra.append(f", owner={self.__owner__!r}")
+        return f"ForwardRef({self.__forward_arg__!r}{''.join(extra)})"
+
+
+_Template = type(t"")
+
+
+class _Stringifier:
+    # Must match the slots on ForwardRef, so we can turn an instance of one into an
+    # instance of the other in place.
+    __slots__ = _SLOTS
+
+    def __init__(
+        self,
+        node,
+        globals=None,
+        owner=None,
+        is_class=False,
+        cell=None,
+        *,
+        stringifier_dict,
+        extra_names=None,
+    ):
+        # Either an AST node or a simple str (for the common case where a ForwardRef
+        # represent a single name).
+        assert isinstance(node, (ast.AST, str))
+        self.__arg__ = None
+        self.__forward_is_argument__ = False
+        self.__forward_is_class__ = is_class
+        self.__forward_module__ = None
+        self.__code__ = None
+        self.__ast_node__ = node
+        self.__globals__ = globals
+        self.__extra_names__ = extra_names
+        self.__cell__ = cell
+        self.__owner__ = owner
+        self.__stringifier_dict__ = stringifier_dict
+
+    def __convert_to_ast(self, other):
+        if isinstance(other, _Stringifier):
+            if isinstance(other.__ast_node__, str):
+                return ast.Name(id=other.__ast_node__), other.__extra_names__
+            return other.__ast_node__, other.__extra_names__
+        elif type(other) is _Template:
+            return _template_to_ast(other), None
+        elif (
+            # In STRING format we don't bother with the create_unique_name() dance;
+            # it's better to emit the repr() of the object instead of an opaque name.
+            self.__stringifier_dict__.format == Format.STRING
+            or other is None
+            or type(other) in (str, int, float, bool, complex)
+        ):
+            return ast.Constant(value=other), None
+        elif type(other) is dict:
+            extra_names = {}
+            keys = []
+            values = []
+            for key, value in other.items():
+                new_key, new_extra_names = self.__convert_to_ast(key)
+                if new_extra_names is not None:
+                    extra_names.update(new_extra_names)
+                keys.append(new_key)
+                new_value, new_extra_names = self.__convert_to_ast(value)
+                if new_extra_names is not None:
+                    extra_names.update(new_extra_names)
+                values.append(new_value)
+            return ast.Dict(keys, values), extra_names
+        elif type(other) in (list, tuple, set):
+            extra_names = {}
+            elts = []
+            for elt in other:
+                new_elt, new_extra_names = self.__convert_to_ast(elt)
+                if new_extra_names is not None:
+                    extra_names.update(new_extra_names)
+                elts.append(new_elt)
+            ast_class = {list: ast.List, tuple: ast.Tuple, set: ast.Set}[type(other)]
+            return ast_class(elts), extra_names
+        else:
+            name = self.__stringifier_dict__.create_unique_name()
+            return ast.Name(id=name), {name: other}
+
+    def __convert_to_ast_getitem(self, other):
+        if isinstance(other, slice):
+            extra_names = {}
+
+            def conv(obj):
+                if obj is None:
+                    return None
+                new_obj, new_extra_names = self.__convert_to_ast(obj)
+                if new_extra_names is not None:
+                    extra_names.update(new_extra_names)
+                return new_obj
+
+            return ast.Slice(
+                lower=conv(other.start),
+                upper=conv(other.stop),
+                step=conv(other.step),
+            ), extra_names
+        else:
+            return self.__convert_to_ast(other)
+
+    def __get_ast(self):
+        node = self.__ast_node__
+        if isinstance(node, str):
+            return ast.Name(id=node)
+        return node
+
+    def __make_new(self, node, extra_names=None):
+        new_extra_names = {}
+        if self.__extra_names__ is not None:
+            new_extra_names.update(self.__extra_names__)
+        if extra_names is not None:
+            new_extra_names.update(extra_names)
+        stringifier = _Stringifier(
+            node,
+            self.__globals__,
+            self.__owner__,
+            self.__forward_is_class__,
+            stringifier_dict=self.__stringifier_dict__,
+            extra_names=new_extra_names or None,
+        )
+        self.__stringifier_dict__.stringifiers.append(stringifier)
+        return stringifier
+
+    # Must implement this since we set __eq__. We hash by identity so that
+    # stringifiers in dict keys are kept separate.
+    def __hash__(self):
+        return id(self)
+
+    def __getitem__(self, other):
+        # Special case, to avoid stringifying references to class-scoped variables
+        # as '__classdict__["x"]'.
+        if self.__ast_node__ == "__classdict__":
+            raise KeyError
+        if isinstance(other, tuple):
+            extra_names = {}
+            elts = []
+            for elt in other:
+                new_elt, new_extra_names = self.__convert_to_ast_getitem(elt)
+                if new_extra_names is not None:
+                    extra_names.update(new_extra_names)
+                elts.append(new_elt)
+            other = ast.Tuple(elts)
+        else:
+            other, extra_names = self.__convert_to_ast_getitem(other)
+        assert isinstance(other, ast.AST), repr(other)
+        return self.__make_new(ast.Subscript(self.__get_ast(), other), extra_names)
+
+    def __getattr__(self, attr):
+        return self.__make_new(ast.Attribute(self.__get_ast(), attr))
+
+    def __call__(self, *args, **kwargs):
+        extra_names = {}
+        ast_args = []
+        for arg in args:
+            new_arg, new_extra_names = self.__convert_to_ast(arg)
+            if new_extra_names is not None:
+                extra_names.update(new_extra_names)
+            ast_args.append(new_arg)
+        ast_kwargs = []
+        for key, value in kwargs.items():
+            new_value, new_extra_names = self.__convert_to_ast(value)
+            if new_extra_names is not None:
+                extra_names.update(new_extra_names)
+            ast_kwargs.append(ast.keyword(key, new_value))
+        return self.__make_new(ast.Call(self.__get_ast(), ast_args, ast_kwargs), extra_names)
+
+    def __iter__(self):
+        yield self.__make_new(ast.Starred(self.__get_ast()))
+
+    def __repr__(self):
+        if isinstance(self.__ast_node__, str):
+            return self.__ast_node__
+        return ast.unparse(self.__ast_node__)
+
+    def __format__(self, format_spec):
+        raise TypeError("Cannot stringify annotation containing string formatting")
+
+    def _make_binop(op: ast.AST):
+        def binop(self, other):
+            rhs, extra_names = self.__convert_to_ast(other)
+            return self.__make_new(
+                ast.BinOp(self.__get_ast(), op, rhs), extra_names
+            )
+
+        return binop
+
+    __add__ = _make_binop(ast.Add())
+    __sub__ = _make_binop(ast.Sub())
+    __mul__ = _make_binop(ast.Mult())
+    __matmul__ = _make_binop(ast.MatMult())
+    __truediv__ = _make_binop(ast.Div())
+    __mod__ = _make_binop(ast.Mod())
+    __lshift__ = _make_binop(ast.LShift())
+    __rshift__ = _make_binop(ast.RShift())
+    __or__ = _make_binop(ast.BitOr())
+    __xor__ = _make_binop(ast.BitXor())
+    __and__ = _make_binop(ast.BitAnd())
+    __floordiv__ = _make_binop(ast.FloorDiv())
+    __pow__ = _make_binop(ast.Pow())
+
+    del _make_binop
+
+    def _make_rbinop(op: ast.AST):
+        def rbinop(self, other):
+            new_other, extra_names = self.__convert_to_ast(other)
+            return self.__make_new(
+                ast.BinOp(new_other, op, self.__get_ast()), extra_names
+            )
+
+        return rbinop
+
+    __radd__ = _make_rbinop(ast.Add())
+    __rsub__ = _make_rbinop(ast.Sub())
+    __rmul__ = _make_rbinop(ast.Mult())
+    __rmatmul__ = _make_rbinop(ast.MatMult())
+    __rtruediv__ = _make_rbinop(ast.Div())
+    __rmod__ = _make_rbinop(ast.Mod())
+    __rlshift__ = _make_rbinop(ast.LShift())
+    __rrshift__ = _make_rbinop(ast.RShift())
+    __ror__ = _make_rbinop(ast.BitOr())
+    __rxor__ = _make_rbinop(ast.BitXor())
+    __rand__ = _make_rbinop(ast.BitAnd())
+    __rfloordiv__ = _make_rbinop(ast.FloorDiv())
+    __rpow__ = _make_rbinop(ast.Pow())
+
+    del _make_rbinop
+
+    def _make_compare(op):
+        def compare(self, other):
+            rhs, extra_names = self.__convert_to_ast(other)
+            return self.__make_new(
+                ast.Compare(
+                    left=self.__get_ast(),
+                    ops=[op],
+                    comparators=[rhs],
+                ),
+                extra_names,
+            )
+
+        return compare
+
+    __lt__ = _make_compare(ast.Lt())
+    __le__ = _make_compare(ast.LtE())
+    __eq__ = _make_compare(ast.Eq())
+    __ne__ = _make_compare(ast.NotEq())
+    __gt__ = _make_compare(ast.Gt())
+    __ge__ = _make_compare(ast.GtE())
+
+    del _make_compare
+
+    def _make_unary_op(op):
+        def unary_op(self):
+            return self.__make_new(ast.UnaryOp(op, self.__get_ast()))
+
+        return unary_op
+
+    __invert__ = _make_unary_op(ast.Invert())
+    __pos__ = _make_unary_op(ast.UAdd())
+    __neg__ = _make_unary_op(ast.USub())
+
+    del _make_unary_op
+
+
+def _template_to_ast_constructor(template):
+    """Convert a `template` instance to a non-literal AST."""
+    args = []
+    for part in template:
+        match part:
+            case str():
+                args.append(ast.Constant(value=part))
+            case _:
+                interp = ast.Call(
+                    func=ast.Name(id="Interpolation"),
+                    args=[
+                        ast.Constant(value=part.value),
+                        ast.Constant(value=part.expression),
+                        ast.Constant(value=part.conversion),
+                        ast.Constant(value=part.format_spec),
+                    ]
+                )
+                args.append(interp)
+    return ast.Call(func=ast.Name(id="Template"), args=args, keywords=[])
+
+
+def _template_to_ast_literal(template, parsed):
+    """Convert a `template` instance to a t-string literal AST."""
+    values = []
+    interp_count = 0
+    for part in template:
+        match part:
+            case str():
+                values.append(ast.Constant(value=part))
+            case _:
+                interp = ast.Interpolation(
+                    str=part.expression,
+                    value=parsed[interp_count],
+                    conversion=ord(part.conversion) if part.conversion else -1,
+                    format_spec=ast.Constant(value=part.format_spec)
+                    if part.format_spec
+                    else None,
+                )
+                values.append(interp)
+                interp_count += 1
+    return ast.TemplateStr(values=values)
+
+
+def _template_to_ast(template):
+    """Make a best-effort conversion of a `template` instance to an AST."""
+    # gh-138558: Not all Template instances can be represented as t-string
+    # literals. Return the most accurate AST we can. See issue for details.
+
+    # If any expr is empty or whitespace only, we cannot convert to a literal.
+    if any(part.expression.strip() == "" for part in template.interpolations):
+        return _template_to_ast_constructor(template)
+
+    try:
+        # Wrap in parens to allow whitespace inside interpolation curly braces
+        parsed = tuple(
+            ast.parse(f"({part.expression})", mode="eval").body
+            for part in template.interpolations
+        )
+    except SyntaxError:
+        return _template_to_ast_constructor(template)
+
+    return _template_to_ast_literal(template, parsed)
+
+
+class _StringifierDict(dict):
+    def __init__(self, namespace, *, globals=None, owner=None, is_class=False, format):
+        super().__init__(namespace)
+        self.namespace = namespace
+        self.globals = globals
+        self.owner = owner
+        self.is_class = is_class
+        self.stringifiers = []
+        self.next_id = 1
+        self.format = format
+
+    def __missing__(self, key):
+        fwdref = _Stringifier(
+            key,
+            globals=self.globals,
+            owner=self.owner,
+            is_class=self.is_class,
+            stringifier_dict=self,
+        )
+        self.stringifiers.append(fwdref)
+        return fwdref
+
+    def transmogrify(self, cell_dict):
+        for obj in self.stringifiers:
+            obj.__class__ = ForwardRef
+            obj.__stringifier_dict__ = None  # not needed for ForwardRef
+            if isinstance(obj.__ast_node__, str):
+                obj.__arg__ = obj.__ast_node__
+                obj.__ast_node__ = None
+            if cell_dict is not None and obj.__cell__ is None:
+                obj.__cell__ = cell_dict
+
+    def create_unique_name(self):
+        name = f"__annotationlib_name_{self.next_id}__"
+        self.next_id += 1
+        return name
+
+
+def call_evaluate_function(evaluate, format, *, owner=None):
+    """Call an evaluate function. Evaluate functions are normally generated for
+    the value of type aliases and the bounds, constraints, and defaults of
+    type parameter objects.
+    """
+    return call_annotate_function(evaluate, format, owner=owner, _is_evaluate=True)
+
+
+def call_annotate_function(annotate, format, *, owner=None, _is_evaluate=False):
+    """Call an __annotate__ function. __annotate__ functions are normally
+    generated by the compiler to defer the evaluation of annotations. They
+    can be called with any of the format arguments in the Format enum, but
+    compiler-generated __annotate__ functions only support the VALUE format.
+    This function provides additional functionality to call __annotate__
+    functions with the FORWARDREF and STRING formats.
+
+    *annotate* must be an __annotate__ function, which takes a single argument
+    and returns a dict of annotations.
+
+    *format* must be a member of the Format enum or one of the corresponding
+    integer values.
+
+    *owner* can be the object that owns the annotations (i.e., the module,
+    class, or function that the __annotate__ function derives from). With the
+    FORWARDREF format, it is used to provide better evaluation capabilities
+    on the generated ForwardRef objects.
+
+    """
+    if format == Format.VALUE_WITH_FAKE_GLOBALS:
+        raise ValueError("The VALUE_WITH_FAKE_GLOBALS format is for internal use only")
+    try:
+        return annotate(format)
+    except NotImplementedError:
+        pass
+    if format == Format.STRING:
+        # STRING is implemented by calling the annotate function in a special
+        # environment where every name lookup results in an instance of _Stringifier.
+        # _Stringifier supports every dunder operation and returns a new _Stringifier.
+        # At the end, we get a dictionary that mostly contains _Stringifier objects (or
+        # possibly constants if the annotate function uses them directly). We then
+        # convert each of those into a string to get an approximation of the
+        # original source.
+
+        # Attempt to call with VALUE_WITH_FAKE_GLOBALS to check if it is implemented
+        # See: https://github.com/python/cpython/issues/138764
+        # Only fail on NotImplementedError
+        try:
+            annotate(Format.VALUE_WITH_FAKE_GLOBALS)
+        except NotImplementedError:
+            # Both STRING and VALUE_WITH_FAKE_GLOBALS are not implemented: fallback to VALUE
+            return annotations_to_string(annotate(Format.VALUE))
+        except Exception:
+            pass
+
+        globals = _StringifierDict({}, format=format)
+        is_class = isinstance(owner, type)
+        closure, _ = _build_closure(
+            annotate, owner, is_class, globals, allow_evaluation=False
+        )
+        func = types.FunctionType(
+            annotate.__code__,
+            globals,
+            closure=closure,
+            argdefs=annotate.__defaults__,
+            kwdefaults=annotate.__kwdefaults__,
+        )
+        annos = func(Format.VALUE_WITH_FAKE_GLOBALS)
+        if _is_evaluate:
+            return _stringify_single(annos)
+        return {
+            key: _stringify_single(val)
+            for key, val in annos.items()
+        }
+    elif format == Format.FORWARDREF:
+        # FORWARDREF is implemented similarly to STRING, but there are two changes,
+        # at the beginning and the end of the process.
+        # First, while STRING uses an empty dictionary as the namespace, so that all
+        # name lookups result in _Stringifier objects, FORWARDREF uses the globals
+        # and builtins, so that defined names map to their real values.
+        # Second, instead of returning strings, we want to return either real values
+        # or ForwardRef objects. To do this, we keep track of all _Stringifier objects
+        # created while the annotation is being evaluated, and at the end we convert
+        # them all to ForwardRef objects by assigning to __class__. To make this
+        # technique work, we have to ensure that the _Stringifier and ForwardRef
+        # classes share the same attributes.
+        # We use this technique because while the annotations are being evaluated,
+        # we want to support all operations that the language allows, including even
+        # __getattr__ and __eq__, and return new _Stringifier objects so we can accurately
+        # reconstruct the source. But in the dictionary that we eventually return, we
+        # want to return objects with more user-friendly behavior, such as an __eq__
+        # that returns a bool and an defined set of attributes.
+        namespace = {**annotate.__builtins__, **annotate.__globals__}
+        is_class = isinstance(owner, type)
+        globals = _StringifierDict(
+            namespace,
+            globals=annotate.__globals__,
+            owner=owner,
+            is_class=is_class,
+            format=format,
+        )
+        closure, cell_dict = _build_closure(
+            annotate, owner, is_class, globals, allow_evaluation=True
+        )
+        func = types.FunctionType(
+            annotate.__code__,
+            globals,
+            closure=closure,
+            argdefs=annotate.__defaults__,
+            kwdefaults=annotate.__kwdefaults__,
+        )
+        try:
+            result = func(Format.VALUE_WITH_FAKE_GLOBALS)
+        except NotImplementedError:
+            # FORWARDREF and VALUE_WITH_FAKE_GLOBALS not supported, fall back to VALUE
+            return annotate(Format.VALUE)
+        except Exception:
+            pass
+        else:
+            globals.transmogrify(cell_dict)
+            return result
+
+        # Try again, but do not provide any globals. This allows us to return
+        # a value in certain cases where an exception gets raised during evaluation.
+        globals = _StringifierDict(
+            {},
+            globals=annotate.__globals__,
+            owner=owner,
+            is_class=is_class,
+            format=format,
+        )
+        closure, cell_dict = _build_closure(
+            annotate, owner, is_class, globals, allow_evaluation=False
+        )
+        func = types.FunctionType(
+            annotate.__code__,
+            globals,
+            closure=closure,
+            argdefs=annotate.__defaults__,
+            kwdefaults=annotate.__kwdefaults__,
+        )
+        result = func(Format.VALUE_WITH_FAKE_GLOBALS)
+        globals.transmogrify(cell_dict)
+        if _is_evaluate:
+            if isinstance(result, ForwardRef):
+                return result.evaluate(format=Format.FORWARDREF)
+            else:
+                return result
+        else:
+            return {
+                key: (
+                    val.evaluate(format=Format.FORWARDREF)
+                    if isinstance(val, ForwardRef)
+                    else val
+                )
+                for key, val in result.items()
+            }
+    elif format == Format.VALUE:
+        # Should be impossible because __annotate__ functions must not raise
+        # NotImplementedError for this format.
+        raise RuntimeError("annotate function does not support VALUE format")
+    else:
+        raise ValueError(f"Invalid format: {format!r}")
+
+
+def _build_closure(annotate, owner, is_class, stringifier_dict, *, allow_evaluation):
+    if not annotate.__closure__:
+        return None, None
+    new_closure = []
+    cell_dict = {}
+    for name, cell in zip(annotate.__code__.co_freevars, annotate.__closure__, strict=True):
+        cell_dict[name] = cell
+        new_cell = None
+        if allow_evaluation:
+            try:
+                cell.cell_contents
+            except ValueError:
+                pass
+            else:
+                new_cell = cell
+        if new_cell is None:
+            fwdref = _Stringifier(
+                name,
+                cell=cell,
+                owner=owner,
+                globals=annotate.__globals__,
+                is_class=is_class,
+                stringifier_dict=stringifier_dict,
+            )
+            stringifier_dict.stringifiers.append(fwdref)
+            new_cell = types.CellType(fwdref)
+        new_closure.append(new_cell)
+    return tuple(new_closure), cell_dict
+
+
+def _stringify_single(anno):
+    if anno is ...:
+        return "..."
+    # We have to handle str specially to support PEP 563 stringified annotations.
+    elif isinstance(anno, str):
+        return anno
+    elif isinstance(anno, _Template):
+        return ast.unparse(_template_to_ast(anno))
+    else:
+        return repr(anno)
+
+
+def get_annotate_from_class_namespace(obj):
+    """Retrieve the annotate function from a class namespace dictionary.
+
+    Return None if the namespace does not contain an annotate function.
+    This is useful in metaclass ``__new__`` methods to retrieve the annotate function.
+    """
+    try:
+        return obj["__annotate__"]
+    except KeyError:
+        return obj.get("__annotate_func__", None)
+
+
+def get_annotations(
+    obj, *, globals=None, locals=None, eval_str=False, format=Format.VALUE
+):
+    """Compute the annotations dict for an object.
+
+    obj may be a callable, class, module, or other object with
+    __annotate__ or __annotations__ attributes.
+    Passing any other object raises TypeError.
+
+    The *format* parameter controls the format in which annotations are returned,
+    and must be a member of the Format enum or its integer equivalent.
+    For the VALUE format, the __annotations__ is tried first; if it
+    does not exist, the __annotate__ function is called. The
+    FORWARDREF format uses __annotations__ if it exists and can be
+    evaluated, and otherwise falls back to calling the __annotate__ function.
+    The SOURCE format tries __annotate__ first, and falls back to
+    using __annotations__, stringified using annotations_to_string().
+
+    This function handles several details for you:
+
+      * If eval_str is true, values of type str will
+        be un-stringized using eval().  This is intended
+        for use with stringized annotations
+        ("from __future__ import annotations").
+      * If obj doesn't have an annotations dict, returns an
+        empty dict.  (Functions and methods always have an
+        annotations dict; classes, modules, and other types of
+        callables may not.)
+      * Ignores inherited annotations on classes.  If a class
+        doesn't have its own annotations dict, returns an empty dict.
+      * All accesses to object members and dict values are done
+        using getattr() and dict.get() for safety.
+      * Always, always, always returns a freshly-created dict.
+
+    eval_str controls whether or not values of type str are replaced
+    with the result of calling eval() on those values:
+
+      * If eval_str is true, eval() is called on values of type str.
+      * If eval_str is false (the default), values of type str are unchanged.
+
+    globals and locals are passed in to eval(); see the documentation
+    for eval() for more information.  If either globals or locals is
+    None, this function may replace that value with a context-specific
+    default, contingent on type(obj):
+
+      * If obj is a module, globals defaults to obj.__dict__.
+      * If obj is a class, globals defaults to
+        sys.modules[obj.__module__].__dict__ and locals
+        defaults to the obj class namespace.
+      * If obj is a callable, globals defaults to obj.__globals__,
+        although if obj is a wrapped function (using
+        functools.update_wrapper()) it is first unwrapped.
+    """
+    if eval_str and format != Format.VALUE:
+        raise ValueError("eval_str=True is only supported with format=Format.VALUE")
+
+    match format:
+        case Format.VALUE:
+            # For VALUE, we first look at __annotations__
+            ann = _get_dunder_annotations(obj)
+
+            # If it's not there, try __annotate__ instead
+            if ann is None:
+                ann = _get_and_call_annotate(obj, format)
+        case Format.FORWARDREF:
+            # For FORWARDREF, we use __annotations__ if it exists
+            try:
+                ann = _get_dunder_annotations(obj)
+            except Exception:
+                pass
+            else:
+                if ann is not None:
+                    return dict(ann)
+
+            # But if __annotations__ threw a NameError, we try calling __annotate__
+            ann = _get_and_call_annotate(obj, format)
+            if ann is None:
+                # If that didn't work either, we have a very weird object: evaluating
+                # __annotations__ threw NameError and there is no __annotate__. In that case,
+                # we fall back to trying __annotations__ again.
+                ann = _get_dunder_annotations(obj)
+        case Format.STRING:
+            # For STRING, we try to call __annotate__
+            ann = _get_and_call_annotate(obj, format)
+            if ann is not None:
+                return dict(ann)
+            # But if we didn't get it, we use __annotations__ instead.
+            ann = _get_dunder_annotations(obj)
+            if ann is not None:
+                return annotations_to_string(ann)
+        case Format.VALUE_WITH_FAKE_GLOBALS:
+            raise ValueError("The VALUE_WITH_FAKE_GLOBALS format is for internal use only")
+        case _:
+            raise ValueError(f"Unsupported format {format!r}")
+
+    if ann is None:
+        if isinstance(obj, type) or callable(obj):
+            return {}
+        raise TypeError(f"{obj!r} does not have annotations")
+
+    if not ann:
+        return {}
+
+    if not eval_str:
+        return dict(ann)
+
+    if globals is None or locals is None:
+        if isinstance(obj, type):
+            # class
+            obj_globals = None
+            module_name = getattr(obj, "__module__", None)
+            if module_name:
+                module = sys.modules.get(module_name, None)
+                if module:
+                    obj_globals = getattr(module, "__dict__", None)
+            obj_locals = dict(vars(obj))
+            unwrap = obj
+        elif isinstance(obj, types.ModuleType):
+            # module
+            obj_globals = getattr(obj, "__dict__")
+            obj_locals = None
+            unwrap = None
+        elif callable(obj):
+            # this includes types.Function, types.BuiltinFunctionType,
+            # types.BuiltinMethodType, functools.partial, functools.singledispatch,
+            # "class funclike" from Lib/test/test_inspect... on and on it goes.
+            obj_globals = getattr(obj, "__globals__", None)
+            obj_locals = None
+            unwrap = obj
+        else:
+            obj_globals = obj_locals = unwrap = None
+
+        if unwrap is not None:
+            while True:
+                if hasattr(unwrap, "__wrapped__"):
+                    unwrap = unwrap.__wrapped__
+                    continue
+                if functools := sys.modules.get("functools"):
+                    if isinstance(unwrap, functools.partial):
+                        unwrap = unwrap.func
+                        continue
+                break
+            if hasattr(unwrap, "__globals__"):
+                obj_globals = unwrap.__globals__
+
+        if globals is None:
+            globals = obj_globals
+        if locals is None:
+            locals = obj_locals
+
+    # "Inject" type parameters into the local namespace
+    # (unless they are shadowed by assignments *in* the local namespace),
+    # as a way of emulating annotation scopes when calling `eval()`
+    if type_params := getattr(obj, "__type_params__", ()):
+        if locals is None:
+            locals = {}
+        locals = {param.__name__: param for param in type_params} | locals
+
+    return_value = {
+        key: value if not isinstance(value, str)
+        else eval(_rewrite_star_unpack(value), globals, locals)
+        for key, value in ann.items()
+    }
+    return return_value
+
+
+def type_repr(value):
+    """Convert a Python value to a format suitable for use with the STRING format.
+
+    This is intended as a helper for tools that support the STRING format but do
+    not have access to the code that originally produced the annotations. It uses
+    repr() for most objects.
+
+    """
+    if isinstance(value, (type, types.FunctionType, types.BuiltinFunctionType)):
+        if value.__module__ == "builtins":
+            return value.__qualname__
+        return f"{value.__module__}.{value.__qualname__}"
+    elif isinstance(value, _Template):
+        tree = _template_to_ast(value)
+        return ast.unparse(tree)
+    if value is ...:
+        return "..."
+    return repr(value)
+
+
+def annotations_to_string(annotations):
+    """Convert an annotation dict containing values to approximately the STRING format.
+
+    Always returns a fresh a dictionary.
+    """
+    return {
+        n: t if isinstance(t, str) else type_repr(t)
+        for n, t in annotations.items()
+    }
+
+
+def _rewrite_star_unpack(arg):
+    """If the given argument annotation expression is a star unpack e.g. `'*Ts'`
+       rewrite it to a valid expression.
+       """
+    if arg.startswith("*"):
+        return f"({arg},)[0]"  # E.g. (*Ts,)[0] or (*tuple[int, int],)[0]
+    else:
+        return arg
+
+
+def _get_and_call_annotate(obj, format):
+    """Get the __annotate__ function and call it.
+
+    May not return a fresh dictionary.
+    """
+    annotate = getattr(obj, "__annotate__", None)
+    if annotate is not None:
+        ann = call_annotate_function(annotate, format, owner=obj)
+        if not isinstance(ann, dict):
+            raise ValueError(f"{obj!r}.__annotate__ returned a non-dict")
+        return ann
+    return None
+
+
+_BASE_GET_ANNOTATIONS = type.__dict__["__annotations__"].__get__
+
+
+def _get_dunder_annotations(obj):
+    """Return the annotations for an object, checking that it is a dictionary.
+
+    Does not return a fresh dictionary.
+    """
+    # This special case is needed to support types defined under
+    # from __future__ import annotations, where accessing the __annotations__
+    # attribute directly might return annotations for the wrong class.
+    if isinstance(obj, type):
+        try:
+            ann = _BASE_GET_ANNOTATIONS(obj)
+        except AttributeError:
+            # For static types, the descriptor raises AttributeError.
+            return None
+    else:
+        ann = getattr(obj, "__annotations__", None)
+        if ann is None:
+            return None
+
+    if not isinstance(ann, dict):
+        raise ValueError(f"{obj!r}.__annotations__ is neither a dict nor None")
+    return ann
diff --git a/Lib/test/test_module/__init__.py b/Lib/test/test_module/__init__.py
index b599c6d8c8d..9d2b9b55ada 100644
--- a/Lib/test/test_module/__init__.py
+++ b/Lib/test/test_module/__init__.py
@@ -334,7 +334,11 @@ def test_annotations_getset_raises(self):
             del foo.__annotations__
 
     def test_annotations_are_created_correctly(self):
-        ann_module4 = import_helper.import_fresh_module('test.typinganndata.ann_module4')
+        ann_module4 = import_helper.import_fresh_module(
+            'test.typinganndata.ann_module4',
+        )
+        self.assertFalse("__annotations__" in ann_module4.__dict__)
+        self.assertEqual(ann_module4.__annotations__, {"a": int, "b": str})
         self.assertTrue("__annotations__" in ann_module4.__dict__)
         del ann_module4.__annotations__
         self.assertFalse("__annotations__" in ann_module4.__dict__)
diff --git a/Lib/test/typinganndata/ann_module.py b/Lib/test/typinganndata/ann_module.py
index 5081e6b5834..e1a1792cb4a 100644
--- a/Lib/test/typinganndata/ann_module.py
+++ b/Lib/test/typinganndata/ann_module.py
@@ -8,8 +8,6 @@
 from typing import Optional
 from functools import wraps
 
-__annotations__[1] = 2
-
 class C:
 
     x = 5; y: Optional['C'] = None
@@ -18,8 +16,6 @@ class C:
 x: int = 5; y: str = x; f: Tuple[int, int]
 
 class M(type):
-
-    __annotations__['123'] = 123
     o: type = object
 
 (pars): bool = True

From 37cc6b44f92f7fcd5eddbfb1d1569cf9255ab210 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Fri, 16 Jan 2026 21:47:45 +0900
Subject: [PATCH 326/418] fix whats_left to support __annotate__

---
 whats_left.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/whats_left.py b/whats_left.py
index 3ae2d2c0fe0..99b840f9da7 100755
--- a/whats_left.py
+++ b/whats_left.py
@@ -195,6 +195,9 @@ def gen_methods():
         typ = eval(typ_code)
         attrs = []
         for attr in dir(typ):
+            # Skip attributes in dir() but not actually accessible (e.g., descriptor that raises)
+            if not hasattr(typ, attr):
+                continue
             if attr_is_not_inherited(typ, attr):
                 attrs.append((attr, extra_info(getattr(typ, attr))))
         methods[typ.__name__] = (typ_code, extra_info(typ), attrs)

From 96038e48c5b0803d95093acf2305edea10c694c8 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Thu, 15 Jan 2026 00:44:20 +0900
Subject: [PATCH 327/418] partially patch inspect for PEP 649 in 3.13

---
 Lib/inspect.py | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/Lib/inspect.py b/Lib/inspect.py
index 5a814f97b5b..d2a04546959 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -220,13 +220,26 @@ def get_annotations(obj, *, globals=None, locals=None, eval_str=False):
     """
     if isinstance(obj, type):
         # class
-        obj_dict = getattr(obj, '__dict__', None)
-        if obj_dict and hasattr(obj_dict, 'get'):
-            ann = obj_dict.get('__annotations__', None)
-            if isinstance(ann, types.GetSetDescriptorType):
-                ann = None
-        else:
+        # XXX: RUSTPYTHON
+        # PEP 649: Use descriptor access to get __annotations__
+        # The __annotations__ attribute is now provided via a descriptor
+        # that calls __annotate__ to compute the annotations lazily
+        try:
+            ann = obj.__annotations__
+        except AttributeError:
             ann = None
+        # Ensure we got this class's own annotations, not inherited
+        if ann is not None:
+            # Check if __annotations__ is in this class's __dict__
+            # or is computed by a descriptor (both are valid)
+            obj_dict = getattr(obj, '__dict__', None)
+            if obj_dict is not None:
+                dict_ann = obj_dict.get('__annotations__', None)
+                # If it's a descriptor or cached dict, use what we got from attribute access
+                # If it's inherited (not in __dict__ at all and no __annotate__), return empty
+                # XXX: RUSTPYTHON - also check __annotate_func__ (PEP 649 descriptor)
+                if dict_ann is None and '__annotate__' not in obj_dict and '__annotations_cache__' not in obj_dict and not hasattr(obj, '__annotate_func__'):
+                    ann = None
 
         obj_globals = None
         module_name = getattr(obj, '__module__', None)

From 346481d95e87bd94da00affee525e6247fcb1590 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Thu, 15 Jan 2026 22:40:22 +0900
Subject: [PATCH 328/418] partially patch Lib/typing to 3.14

---
 Lib/typing.py | 85 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 70 insertions(+), 15 deletions(-)

diff --git a/Lib/typing.py b/Lib/typing.py
index b89e24e2ce0..77caac9eed1 100644
--- a/Lib/typing.py
+++ b/Lib/typing.py
@@ -161,7 +161,17 @@
 ]
 
 
-def _type_convert(arg, module=None, *, allow_special_forms=False):
+class _LazyAnnotationLib:
+    def __getattr__(self, attr):
+        global _lazy_annotationlib
+        import annotationlib
+        _lazy_annotationlib = annotationlib
+        return getattr(annotationlib, attr)
+
+_lazy_annotationlib = _LazyAnnotationLib()
+
+
+def _type_convert(arg, module=None, *, allow_special_forms=False, owner=None):
     """For converting None to type(None), and strings to ForwardRef."""
     if arg is None:
         return type(None)
@@ -170,7 +180,7 @@ def _type_convert(arg, module=None, *, allow_special_forms=False):
     return arg
 
 
-def _type_check(arg, msg, is_argument=True, module=None, *, allow_special_forms=False):
+def _type_check(arg, msg, is_argument=True, module=None, *, allow_special_forms=False, owner=None):
     """Check that the argument is a type, and return it (internal helper).
 
     As a special case, accept None and return type(None) instead. Also wrap strings
@@ -188,7 +198,7 @@ def _type_check(arg, msg, is_argument=True, module=None, *, allow_special_forms=
         if is_argument:
             invalid_generic_forms += (Final,)
 
-    arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms)
+    arg = _type_convert(arg, module=module, allow_special_forms=allow_special_forms, owner=owner)
     if (isinstance(arg, _GenericAlias) and
             arg.__origin__ in invalid_generic_forms):
         raise TypeError(f"{arg} is not valid as type argument")
@@ -2443,7 +2453,7 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
                 base_globals = getattr(sys.modules.get(base.__module__, None), '__dict__', {})
             else:
                 base_globals = globalns
-            ann = base.__dict__.get('__annotations__', {})
+            ann = _lazy_annotationlib.get_annotations(base)
             if isinstance(ann, types.GetSetDescriptorType):
                 ann = {}
             base_locals = dict(vars(base)) if localns is None else localns
@@ -2477,7 +2487,10 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
             localns = globalns
     elif localns is None:
         localns = globalns
-    hints = getattr(obj, '__annotations__', None)
+    try:
+        hints = _lazy_annotationlib.get_annotations(obj)
+    except TypeError:
+        hints = getattr(obj, '__annotations__', None)
     if hints is None:
         # Return empty annotations for something that _could_ have them.
         if isinstance(obj, _allowed_types):
@@ -3005,7 +3018,13 @@ def __new__(cls, typename, bases, ns):
                 raise TypeError(
                     'can only inherit from a NamedTuple type and Generic')
         bases = tuple(tuple if base is _NamedTuple else base for base in bases)
-        types = ns.get('__annotations__', {})
+        if "__annotations__" in ns:
+            types = ns["__annotations__"]
+        elif (annotate := _lazy_annotationlib.get_annotate_from_class_namespace(ns)) is not None:
+            types = _lazy_annotationlib.call_annotate_function(
+                annotate, _lazy_annotationlib.Format.VALUE)
+        else:
+            types = {}
         default_names = []
         for field_name in types:
             if field_name in ns:
@@ -3160,16 +3179,26 @@ def __new__(cls, name, bases, ns, total=True):
         else:
             generic_base = ()
 
+        ns_annotations = ns.pop('__annotations__', None)
+
         tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict), ns)
 
         if not hasattr(tp_dict, '__orig_bases__'):
             tp_dict.__orig_bases__ = bases
 
-        annotations = {}
-        own_annotations = ns.get('__annotations__', {})
+        if ns_annotations is not None:
+            own_annotate = None
+            own_annotations = ns_annotations
+        elif (own_annotate := _lazy_annotationlib.get_annotate_from_class_namespace(ns)) is not None:
+            own_annotations = _lazy_annotationlib.call_annotate_function(
+                own_annotate, _lazy_annotationlib.Format.FORWARDREF, owner=tp_dict
+            )
+        else:
+            own_annotate = None
+            own_annotations = {}
         msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
-        own_annotations = {
-            n: _type_check(tp, msg, module=tp_dict.__module__)
+        own_checked_annotations = {
+            n: _type_check(tp, msg, owner=tp_dict, module=tp_dict.__module__)
             for n, tp in own_annotations.items()
         }
         required_keys = set()
@@ -3178,8 +3207,6 @@ def __new__(cls, name, bases, ns, total=True):
         mutable_keys = set()
 
         for base in bases:
-            annotations.update(base.__dict__.get('__annotations__', {}))
-
             base_required = base.__dict__.get('__required_keys__', set())
             required_keys |= base_required
             optional_keys -= base_required
@@ -3191,8 +3218,7 @@ def __new__(cls, name, bases, ns, total=True):
             readonly_keys.update(base.__dict__.get('__readonly_keys__', ()))
             mutable_keys.update(base.__dict__.get('__mutable_keys__', ()))
 
-        annotations.update(own_annotations)
-        for annotation_key, annotation_type in own_annotations.items():
+        for annotation_key, annotation_type in own_checked_annotations.items():
             qualifiers = set(_get_typeddict_qualifiers(annotation_type))
             if Required in qualifiers:
                 is_required = True
@@ -3223,7 +3249,36 @@ def __new__(cls, name, bases, ns, total=True):
             f"Required keys overlap with optional keys in {name}:"
             f" {required_keys=}, {optional_keys=}"
         )
-        tp_dict.__annotations__ = annotations
+
+        def __annotate__(format):
+            annos = {}
+            for base in bases:
+                if base is Generic:
+                    continue
+                base_annotate = base.__annotate__
+                if base_annotate is None:
+                    continue
+                base_annos = _lazy_annotationlib.call_annotate_function(
+                    base_annotate, format, owner=base)
+                annos.update(base_annos)
+            if own_annotate is not None:
+                own = _lazy_annotationlib.call_annotate_function(
+                    own_annotate, format, owner=tp_dict)
+                if format != _lazy_annotationlib.Format.STRING:
+                    own = {
+                        n: _type_check(tp, msg, module=tp_dict.__module__)
+                        for n, tp in own.items()
+                    }
+            elif format == _lazy_annotationlib.Format.STRING:
+                own = _lazy_annotationlib.annotations_to_string(own_annotations)
+            elif format in (_lazy_annotationlib.Format.FORWARDREF, _lazy_annotationlib.Format.VALUE):
+                own = own_checked_annotations
+            else:
+                raise NotImplementedError(format)
+            annos.update(own)
+            return annos
+
+        tp_dict.__annotate__ = __annotate__
         tp_dict.__required_keys__ = frozenset(required_keys)
         tp_dict.__optional_keys__ = frozenset(optional_keys)
         tp_dict.__readonly_keys__ = frozenset(readonly_keys)

From 076d692b42ad6e61d8f7ca9441f399782a04b2cd Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Fri, 16 Jan 2026 00:12:45 +0900
Subject: [PATCH 329/418] Upgrade string from CPython 3.14.2

---
 Lib/{string.py => string/__init__.py} | 60 +++++++++++++++++----------
 Lib/string/templatelib.py             | 33 +++++++++++++++
 2 files changed, 71 insertions(+), 22 deletions(-)
 rename Lib/{string.py => string/__init__.py} (87%)
 create mode 100644 Lib/string/templatelib.py

diff --git a/Lib/string.py b/Lib/string/__init__.py
similarity index 87%
rename from Lib/string.py
rename to Lib/string/__init__.py
index 2eab6d4f595..eab5067c9b1 100644
--- a/Lib/string.py
+++ b/Lib/string/__init__.py
@@ -49,11 +49,18 @@ def capwords(s, sep=None):
 
 
 ####################################################################
-import re as _re
-from collections import ChainMap as _ChainMap
-
 _sentinel_dict = {}
 
+
+class _TemplatePattern:
+    # This descriptor is overwritten in ``Template._compile_pattern()``.
+    def __get__(self, instance, cls=None):
+        if cls is None:
+            return self
+        return cls._compile_pattern()
+_TemplatePattern = _TemplatePattern()
+
+
 class Template:
     """A string class for supporting $-substitutions."""
 
@@ -64,14 +71,21 @@ class Template:
     # See https://bugs.python.org/issue31672
     idpattern = r'(?a:[_a-z][_a-z0-9]*)'
     braceidpattern = None
-    flags = _re.IGNORECASE
+    flags = None  # default: re.IGNORECASE
+
+    pattern = _TemplatePattern  # use a descriptor to compile the pattern
 
     def __init_subclass__(cls):
         super().__init_subclass__()
-        if 'pattern' in cls.__dict__:
-            pattern = cls.pattern
-        else:
-            delim = _re.escape(cls.delimiter)
+        cls._compile_pattern()
+
+    @classmethod
+    def _compile_pattern(cls):
+        import re  # deferred import, for performance
+
+        pattern = cls.__dict__.get('pattern', _TemplatePattern)
+        if pattern is _TemplatePattern:
+            delim = re.escape(cls.delimiter)
             id = cls.idpattern
             bid = cls.braceidpattern or cls.idpattern
             pattern = fr"""
@@ -82,7 +96,10 @@ def __init_subclass__(cls):
               (?P<invalid>)             # Other ill-formed delimiter exprs
             )
             """
-        cls.pattern = _re.compile(pattern, cls.flags | _re.VERBOSE)
+        if cls.flags is None:
+            cls.flags = re.IGNORECASE
+        pat = cls.pattern = re.compile(pattern, cls.flags | re.VERBOSE)
+        return pat
 
     def __init__(self, template):
         self.template = template
@@ -105,7 +122,8 @@ def substitute(self, mapping=_sentinel_dict, /, **kws):
         if mapping is _sentinel_dict:
             mapping = kws
         elif kws:
-            mapping = _ChainMap(kws, mapping)
+            from collections import ChainMap
+            mapping = ChainMap(kws, mapping)
         # Helper function for .sub()
         def convert(mo):
             # Check the most common path first.
@@ -124,7 +142,8 @@ def safe_substitute(self, mapping=_sentinel_dict, /, **kws):
         if mapping is _sentinel_dict:
             mapping = kws
         elif kws:
-            mapping = _ChainMap(kws, mapping)
+            from collections import ChainMap
+            mapping = ChainMap(kws, mapping)
         # Helper function for .sub()
         def convert(mo):
             named = mo.group('named') or mo.group('braced')
@@ -170,10 +189,6 @@ def get_identifiers(self):
                     self.pattern)
         return ids
 
-# Initialize Template.pattern.  __init_subclass__() is automatically called
-# only for subclasses, not for the Template class itself.
-Template.__init_subclass__()
-
 
 ########################################################################
 # the Formatter class
@@ -212,19 +227,20 @@ def _vformat(self, format_string, args, kwargs, used_args, recursion_depth,
                 # this is some markup, find the object and do
                 #  the formatting
 
-                # handle arg indexing when empty field_names are given.
-                if field_name == '':
+                # handle arg indexing when empty field first parts are given.
+                field_first, _ = _string.formatter_field_name_split(field_name)
+                if field_first == '':
                     if auto_arg_index is False:
                         raise ValueError('cannot switch from manual field '
                                          'specification to automatic field '
                                          'numbering')
-                    field_name = str(auto_arg_index)
+                    field_name = str(auto_arg_index) + field_name
                     auto_arg_index += 1
-                elif field_name.isdigit():
+                elif isinstance(field_first, int):
                     if auto_arg_index:
-                        raise ValueError('cannot switch from manual field '
-                                         'specification to automatic field '
-                                         'numbering')
+                        raise ValueError('cannot switch from automatic field '
+                                         'numbering to manual field '
+                                         'specification')
                     # disable auto arg incrementing, if it gets
                     # used later on, then an exception will be raised
                     auto_arg_index = False
diff --git a/Lib/string/templatelib.py b/Lib/string/templatelib.py
new file mode 100644
index 00000000000..8164872432a
--- /dev/null
+++ b/Lib/string/templatelib.py
@@ -0,0 +1,33 @@
+"""Support for template string literals (t-strings)."""
+
+t = t"{0}"
+Template = type(t)
+Interpolation = type(t.interpolations[0])
+del t
+
+def convert(obj, /, conversion):
+    """Convert *obj* using formatted string literal semantics."""
+    if conversion is None:
+        return obj
+    if conversion == 'r':
+        return repr(obj)
+    if conversion == 's':
+        return str(obj)
+    if conversion == 'a':
+        return ascii(obj)
+    raise ValueError(f'invalid conversion specifier: {conversion}')
+
+def _template_unpickle(*args):
+    import itertools
+
+    if len(args) != 2:
+        raise ValueError('Template expects tuple of length 2 to unpickle')
+
+    strings, interpolations = args
+    parts = []
+    for string, interpolation in itertools.zip_longest(strings, interpolations):
+        if string is not None:
+            parts.append(string)
+        if interpolation is not None:
+            parts.append(interpolation)
+    return Template(*parts)

From 522793850a2757ad7cce5a2a1b3dad09008b60f3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sat, 17 Jan 2026 19:21:38 +0900
Subject: [PATCH 330/418]  mark and unmark unittest functions

---
 Lib/test/test_grammar.py         |  2 ++
 Lib/test/test_memoryio.py        | 12 ------------
 Lib/test/test_module/__init__.py |  2 --
 Lib/test/test_opcodes.py         |  4 ++++
 Lib/test/test_pickle.py          |  4 ----
 Lib/test/test_pickletools.py     |  2 --
 Lib/test/test_typing.py          |  2 ++
 7 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 323f4ee4c61..aae5c2b1ce3 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -374,6 +374,7 @@ class F(C, A):
         self.assertEqual(F.__annotations__, {})
 
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_metaclass_semantics(self):
         class CMeta(type):
             @classmethod
@@ -403,6 +404,7 @@ def test_var_annot_in_module(self):
         with self.assertRaises(NameError):
             ann_module3.D_bad_ann(5)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_simple_exec(self):
         gns = {}; lns= {}
         exec("'docstring'\n"
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index 343e5dd7a6c..b6b95143621 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -745,9 +745,6 @@ def test_init(self):
     def test_issue5449(self):
         super().test_issue5449()
 
-    def test_pickling(self):
-        super().test_pickling()
-
     def test_read(self):
         super().test_read()
 
@@ -907,9 +904,6 @@ def test_newline_none(self):
     def test_newlines_property(self):
         super().test_newlines_property()
 
-    def test_pickling(self):
-        super().test_pickling()
-
     def test_read(self):
         super().test_read()
 
@@ -998,17 +992,11 @@ def test_newline_cr(self):
     def test_newline_crlf(self):
         super().test_newline_crlf()
 
-    def test_newline_default(self):
-        super().test_newline_default()
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_newline_empty(self):
         super().test_newline_empty()
 
-    def test_newline_lf(self):
-        super().test_newline_lf()
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_newline_none(self):
diff --git a/Lib/test/test_module/__init__.py b/Lib/test/test_module/__init__.py
index 9d2b9b55ada..59c74fd0d41 100644
--- a/Lib/test/test_module/__init__.py
+++ b/Lib/test/test_module/__init__.py
@@ -293,8 +293,6 @@ class M(ModuleType):
             melon = Descr()
         self.assertRaises(RuntimeError, getattr, M("mymod"), "melon")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_lazy_create_annotations(self):
         # module objects lazy create their __annotations__ dict on demand.
         # the annotations dict is stored in module.__dict__.
diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py
index 72488b2bb6b..0e1a4fc50d2 100644
--- a/Lib/test/test_opcodes.py
+++ b/Lib/test/test_opcodes.py
@@ -36,11 +36,15 @@ def test_default_annotations_exist(self):
         class C: pass
         self.assertEqual(C.__annotations__, {})
 
+    # TODO: RustPython - test expectation changed in 3.14 due to PEP 649
+    @unittest.expectedFailure
     def test_use_existing_annotations(self):
         ns = {'__annotations__': {1: 2}}
         exec('x: int', ns)
         self.assertEqual(ns['__annotations__'], {'x': int, 1: 2})
 
+    # TODO: RustPython - test expectation changed in 3.14 due to PEP 649
+    @unittest.expectedFailure
     def test_do_not_recreate_annotations(self):
         # Don't rely on the existence of the '__annotations__' global.
         with support.swap_item(globals(), '__annotations__', {}):
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index 7271696a191..0b634ea5dd0 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -131,8 +131,6 @@ def loads(self, buf, **kwds):
     def test_c_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_c_methods()
 
-
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
@@ -227,7 +225,6 @@ def loads(self, buf, **kwds):
     def test_c_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_c_methods()
 
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_badly_escaped_string(self): # TODO(RUSTPYTHON): Remove this test when it passes
@@ -243,7 +240,6 @@ def test_correctly_quoted_string(self): # TODO(RUSTPYTHON): Remove this test whe
     def test_load_python2_str_as_bytes(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_load_python2_str_as_bytes()
 
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
diff --git a/Lib/test/test_pickletools.py b/Lib/test/test_pickletools.py
index 42a20da00b1..f4ce1c75b87 100644
--- a/Lib/test/test_pickletools.py
+++ b/Lib/test/test_pickletools.py
@@ -97,8 +97,6 @@ def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
     def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
         return super().test_oob_buffers_writable_to_readonly()
 
-
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_c_methods(self): # TODO(RUSTPYTHON): Remove this test when it passes
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index 17cbaa92218..d96a3a6a5d4 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -3803,6 +3803,7 @@ def __init__(self):
         self.assertNotIsInstance(B(), P)
         self.assertNotIsInstance(C(), P)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; test doesn't include PEP 649 attrs
     def test_non_protocol_subclasses(self):
         class P(Protocol):
             x = 1
@@ -6868,6 +6869,7 @@ def test_get_type_hints_modules_forwardref(self):
                      'default_b': Optional[mod_generics_cache.B]}
         self.assertEqual(gth(mod_generics_cache), mgc_hints)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; test expects outdated result
     def test_get_type_hints_classes(self):
         self.assertEqual(gth(ann_module.C),  # gth will find the right globalns
                          {'y': Optional[ann_module.C]})

From 33689c1d0f252316e67946a9368491e444154264 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Thu, 15 Jan 2026 00:16:37 +0900
Subject: [PATCH 331/418] Fix jit failure

---
 crates/jit/tests/common.rs | 96 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 91 insertions(+), 5 deletions(-)

diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index eabf27471b9..da324088d32 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -63,6 +63,72 @@ impl From<ConstantData> for StackValue {
     }
 }
 
+/// Extract annotations from an annotate function's bytecode.
+/// The annotate function uses BUILD_MAP with key-value pairs loaded before it.
+/// Keys are parameter names (from LOAD_CONST), values are type names (from LOAD_NAME/LOAD_GLOBAL).
+fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<String, StackValue> {
+    let mut annotations = HashMap::new();
+    let mut stack: Vec<(bool, usize)> = Vec::new(); // (is_const, index)
+    let mut op_arg_state = OpArgState::default();
+
+    for &word in code.instructions.iter() {
+        let (instruction, arg) = op_arg_state.get(word);
+
+        match instruction {
+            Instruction::LoadConst { idx } => {
+                stack.push((true, idx.get(arg) as usize));
+            }
+            Instruction::LoadName(idx) | Instruction::LoadGlobal(idx) => {
+                stack.push((false, idx.get(arg) as usize));
+            }
+            Instruction::BuildMap { size, .. } => {
+                let count = size.get(arg) as usize;
+                // Stack has key-value pairs in order: k1, v1, k2, v2, ...
+                // So we need count * 2 items from the stack
+                let start = stack.len().saturating_sub(count * 2);
+                let pairs: Vec<_> = stack.drain(start..).collect();
+
+                for chunk in pairs.chunks(2) {
+                    if chunk.len() == 2 {
+                        let (key_is_const, key_idx) = chunk[0];
+                        let (_val_is_const, val_idx) = chunk[1];
+
+                        // Key should be a const string (parameter name)
+                        if key_is_const
+                            && let ConstantData::Str { value } = &code.constants[key_idx]
+                        {
+                            let param_name = value.to_string_lossy().into_owned();
+                            // Value should be a name (type name)
+                            if let Some(type_name) = code.names.get(val_idx) {
+                                annotations
+                                    .insert(param_name, StackValue::String(type_name.clone()));
+                            }
+                        }
+                    }
+                }
+                // Return after processing BUILD_MAP - we got our annotations
+                return annotations;
+            }
+            Instruction::Resume { .. }
+            | Instruction::LoadFast(_)
+            | Instruction::CompareOp { .. }
+            | Instruction::ExtendedArg => {
+                // Ignore these instructions for annotation extraction
+            }
+            Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+                // End of function - return what we have
+                return annotations;
+            }
+            _ => {
+                // For other instructions, clear the stack tracking as we don't understand the effect
+                stack.clear();
+            }
+        }
+    }
+
+    annotations
+}
+
 pub struct StackMachine {
     stack: Vec<StackValue>,
     locals: HashMap<String, StackValue>,
@@ -92,6 +158,9 @@ impl StackMachine {
         names: &[String],
     ) -> ControlFlow<()> {
         match instruction {
+            Instruction::Resume { .. } => {
+                // No-op for JIT tests - just marks function entry point
+            }
             Instruction::LoadConst { idx } => {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
@@ -143,13 +212,31 @@ impl StackMachine {
                 };
                 let attr_value = self.stack.pop().expect("Expected attribute value on stack");
 
-                // For now, we only handle ANNOTATIONS flag in JIT tests
-                if attr
-                    .get(arg)
+                let flags = attr.get(arg);
+
+                // Handle ANNOTATE flag (PEP 649 style - Python 3.14+)
+                // The attr_value is a function that returns annotations when called
+                if flags.contains(rustpython_compiler_core::bytecode::MakeFunctionFlags::ANNOTATE) {
+                    if let StackValue::Function(annotate_func) = attr_value {
+                        // Parse the annotate function's bytecode to extract annotations
+                        // The pattern is: LOAD_CONST (key), LOAD_NAME (value), ... BUILD_MAP
+                        let annotate_code = &annotate_func.code;
+                        let annotations = extract_annotations_from_annotate_code(annotate_code);
+
+                        let updated_func = Function {
+                            code: func.code,
+                            annotations,
+                        };
+                        self.stack.push(StackValue::Function(updated_func));
+                    } else {
+                        panic!("Expected annotate function for ANNOTATE flag");
+                    }
+                }
+                // Handle old ANNOTATIONS flag (Python 3.12 style)
+                else if flags
                     .contains(rustpython_compiler_core::bytecode::MakeFunctionFlags::ANNOTATIONS)
                 {
                     if let StackValue::Map(annotations) = attr_value {
-                        // Update function's annotations
                         let updated_func = Function {
                             code: func.code,
                             annotations,
@@ -160,7 +247,6 @@ impl StackMachine {
                     }
                 } else {
                     // For other attributes, just push the function back unchanged
-                    // (since JIT tests mainly care about type annotations)
                     self.stack.push(StackValue::Function(func));
                 }
             }

From 65e08c02b650d5cfbe3b3679500bd3977f1d8d88 Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Fri, 16 Jan 2026 20:01:09 +0900
Subject: [PATCH 332/418] Update ensurepip from 3.14.2

---
 Lib/ensurepip/__init__.py                     |   4 ++--
 ...none-any.whl => pip-25.3-py3-none-any.whl} | Bin 1764055 -> 1778622 bytes
 Lib/ensurepip/_uninstall.py                   |   2 +-
 Lib/test/test_ensurepip.py                    |   1 -
 4 files changed, 3 insertions(+), 4 deletions(-)
 rename Lib/ensurepip/_bundled/{pip-25.2-py3-none-any.whl => pip-25.3-py3-none-any.whl} (78%)

diff --git a/Lib/ensurepip/__init__.py b/Lib/ensurepip/__init__.py
index ab6d32478e4..21bbfad0fe6 100644
--- a/Lib/ensurepip/__init__.py
+++ b/Lib/ensurepip/__init__.py
@@ -10,7 +10,7 @@
 
 
 __all__ = ["version", "bootstrap"]
-_PIP_VERSION = "25.2"
+_PIP_VERSION = "25.3"
 
 # Directory of system wheel packages. Some Linux distribution packaging
 # policies recommend against bundling dependencies. For example, Fedora
@@ -205,7 +205,7 @@ def _uninstall_helper(*, verbosity=0):
 
 def _main(argv=None):
     import argparse
-    parser = argparse.ArgumentParser(prog="python -m ensurepip")
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument(
         "--version",
         action="version",
diff --git a/Lib/ensurepip/_bundled/pip-25.2-py3-none-any.whl b/Lib/ensurepip/_bundled/pip-25.3-py3-none-any.whl
similarity index 78%
rename from Lib/ensurepip/_bundled/pip-25.2-py3-none-any.whl
rename to Lib/ensurepip/_bundled/pip-25.3-py3-none-any.whl
index 4db7e7207189d3d95b8377b8481112995f8c95c9..755e1aa0c3dc5a90defba25ab35f4b8877ca95ab 100644
GIT binary patch
delta 306086
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%0ADZ
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

delta 314035
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%0D6!jK~hOo))9uk4YvRLlSmk
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
Dgrc@J

diff --git a/Lib/ensurepip/_uninstall.py b/Lib/ensurepip/_uninstall.py
index b257904328d..4183c28a809 100644
--- a/Lib/ensurepip/_uninstall.py
+++ b/Lib/ensurepip/_uninstall.py
@@ -6,7 +6,7 @@
 
 
 def _main(argv=None):
-    parser = argparse.ArgumentParser(prog="python -m ensurepip._uninstall")
+    parser = argparse.ArgumentParser()
     parser.add_argument(
         "--version",
         action="version",
diff --git a/Lib/test/test_ensurepip.py b/Lib/test/test_ensurepip.py
index a4b36a90d88..6d3c91b0b6d 100644
--- a/Lib/test/test_ensurepip.py
+++ b/Lib/test/test_ensurepip.py
@@ -6,7 +6,6 @@
 import test.support
 import unittest
 import unittest.mock
-from importlib.resources.abc import Traversable
 from pathlib import Path
 
 import ensurepip

From ef22bf4774ff44f868e9259b31adc9759d488265 Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Fri, 16 Jan 2026 20:06:23 +0900
Subject: [PATCH 333/418] Update _colorize from CPython 3.14.2

---
 Lib/_colorize.py           | 263 +++++++++++++++++++++++++++++++++++--
 Lib/test/test__colorize.py |  48 +++++++
 2 files changed, 301 insertions(+), 10 deletions(-)

diff --git a/Lib/_colorize.py b/Lib/_colorize.py
index 9eb6f0933b8..d6673f6692f 100644
--- a/Lib/_colorize.py
+++ b/Lib/_colorize.py
@@ -1,13 +1,16 @@
-from __future__ import annotations
-import io
 import os
 import sys
 
+from collections.abc import Callable, Iterator, Mapping
+from dataclasses import dataclass, field, Field
+
 COLORIZE = True
 
+
 # types
 if False:
-    from typing import IO
+    from typing import IO, Self, ClassVar
+    _theme: Theme
 
 
 class ANSIColors:
@@ -17,11 +20,13 @@ class ANSIColors:
     BLUE = "\x1b[34m"
     CYAN = "\x1b[36m"
     GREEN = "\x1b[32m"
+    GREY = "\x1b[90m"
     MAGENTA = "\x1b[35m"
     RED = "\x1b[31m"
     WHITE = "\x1b[37m"  # more like LIGHT GRAY
     YELLOW = "\x1b[33m"
 
+    BOLD = "\x1b[1m"
     BOLD_BLACK = "\x1b[1;30m"  # DARK GRAY
     BOLD_BLUE = "\x1b[1;34m"
     BOLD_CYAN = "\x1b[1;36m"
@@ -60,13 +65,196 @@ class ANSIColors:
     INTENSE_BACKGROUND_YELLOW = "\x1b[103m"
 
 
+ColorCodes = set()
 NoColors = ANSIColors()
 
-for attr in dir(NoColors):
+for attr, code in ANSIColors.__dict__.items():
     if not attr.startswith("__"):
+        ColorCodes.add(code)
         setattr(NoColors, attr, "")
 
 
+#
+# Experimental theming support (see gh-133346)
+#
+
+# - Create a theme by copying an existing `Theme` with one or more sections
+#   replaced, using `default_theme.copy_with()`;
+# - create a theme section by copying an existing `ThemeSection` with one or
+#   more colors replaced, using for example `default_theme.syntax.copy_with()`;
+# - create a theme from scratch by instantiating a `Theme` data class with
+#   the required sections (which are also dataclass instances).
+#
+# Then call `_colorize.set_theme(your_theme)` to set it.
+#
+# Put your theme configuration in $PYTHONSTARTUP for the interactive shell,
+# or sitecustomize.py in your virtual environment or Python installation for
+# other uses.  Your applications can call `_colorize.set_theme()` too.
+#
+# Note that thanks to the dataclasses providing default values for all fields,
+# creating a new theme or theme section from scratch is possible without
+# specifying all keys.
+#
+# For example, here's a theme that makes punctuation and operators less prominent:
+#
+#   try:
+#       from _colorize import set_theme, default_theme, Syntax, ANSIColors
+#   except ImportError:
+#       pass
+#   else:
+#       theme_with_dim_operators = default_theme.copy_with(
+#           syntax=Syntax(op=ANSIColors.INTENSE_BLACK),
+#       )
+#       set_theme(theme_with_dim_operators)
+#       del set_theme, default_theme, Syntax, ANSIColors, theme_with_dim_operators
+#
+# Guarding the import ensures that your .pythonstartup file will still work in
+# Python 3.13 and older. Deleting the variables ensures they don't remain in your
+# interactive shell's global scope.
+
+class ThemeSection(Mapping[str, str]):
+    """A mixin/base class for theme sections.
+
+    It enables dictionary access to a section, as well as implements convenience
+    methods.
+    """
+
+    # The two types below are just that: types to inform the type checker that the
+    # mixin will work in context of those fields existing
+    __dataclass_fields__: ClassVar[dict[str, Field[str]]]
+    _name_to_value: Callable[[str], str]
+
+    def __post_init__(self) -> None:
+        name_to_value = {}
+        for color_name in self.__dataclass_fields__:
+            name_to_value[color_name] = getattr(self, color_name)
+        super().__setattr__('_name_to_value', name_to_value.__getitem__)
+
+    def copy_with(self, **kwargs: str) -> Self:
+        color_state: dict[str, str] = {}
+        for color_name in self.__dataclass_fields__:
+            color_state[color_name] = getattr(self, color_name)
+        color_state.update(kwargs)
+        return type(self)(**color_state)
+
+    @classmethod
+    def no_colors(cls) -> Self:
+        color_state: dict[str, str] = {}
+        for color_name in cls.__dataclass_fields__:
+            color_state[color_name] = ""
+        return cls(**color_state)
+
+    def __getitem__(self, key: str) -> str:
+        return self._name_to_value(key)
+
+    def __len__(self) -> int:
+        return len(self.__dataclass_fields__)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.__dataclass_fields__)
+
+
+@dataclass(frozen=True, kw_only=True)
+class Argparse(ThemeSection):
+    usage: str = ANSIColors.BOLD_BLUE
+    prog: str = ANSIColors.BOLD_MAGENTA
+    prog_extra: str = ANSIColors.MAGENTA
+    heading: str = ANSIColors.BOLD_BLUE
+    summary_long_option: str = ANSIColors.CYAN
+    summary_short_option: str = ANSIColors.GREEN
+    summary_label: str = ANSIColors.YELLOW
+    summary_action: str = ANSIColors.GREEN
+    long_option: str = ANSIColors.BOLD_CYAN
+    short_option: str = ANSIColors.BOLD_GREEN
+    label: str = ANSIColors.BOLD_YELLOW
+    action: str = ANSIColors.BOLD_GREEN
+    reset: str = ANSIColors.RESET
+
+
+@dataclass(frozen=True)
+class Syntax(ThemeSection):
+    prompt: str = ANSIColors.BOLD_MAGENTA
+    keyword: str = ANSIColors.BOLD_BLUE
+    keyword_constant: str = ANSIColors.BOLD_BLUE
+    builtin: str = ANSIColors.CYAN
+    comment: str = ANSIColors.RED
+    string: str = ANSIColors.GREEN
+    number: str = ANSIColors.YELLOW
+    op: str = ANSIColors.RESET
+    definition: str = ANSIColors.BOLD
+    soft_keyword: str = ANSIColors.BOLD_BLUE
+    reset: str = ANSIColors.RESET
+
+
+@dataclass(frozen=True)
+class Traceback(ThemeSection):
+    type: str = ANSIColors.BOLD_MAGENTA
+    message: str = ANSIColors.MAGENTA
+    filename: str = ANSIColors.MAGENTA
+    line_no: str = ANSIColors.MAGENTA
+    frame: str = ANSIColors.MAGENTA
+    error_highlight: str = ANSIColors.BOLD_RED
+    error_range: str = ANSIColors.RED
+    reset: str = ANSIColors.RESET
+
+
+@dataclass(frozen=True)
+class Unittest(ThemeSection):
+    passed: str = ANSIColors.GREEN
+    warn: str = ANSIColors.YELLOW
+    fail: str = ANSIColors.RED
+    fail_info: str = ANSIColors.BOLD_RED
+    reset: str = ANSIColors.RESET
+
+
+@dataclass(frozen=True)
+class Theme:
+    """A suite of themes for all sections of Python.
+
+    When adding a new one, remember to also modify `copy_with` and `no_colors`
+    below.
+    """
+    argparse: Argparse = field(default_factory=Argparse)
+    syntax: Syntax = field(default_factory=Syntax)
+    traceback: Traceback = field(default_factory=Traceback)
+    unittest: Unittest = field(default_factory=Unittest)
+
+    def copy_with(
+        self,
+        *,
+        argparse: Argparse | None = None,
+        syntax: Syntax | None = None,
+        traceback: Traceback | None = None,
+        unittest: Unittest | None = None,
+    ) -> Self:
+        """Return a new Theme based on this instance with some sections replaced.
+
+        Themes are immutable to protect against accidental modifications that
+        could lead to invalid terminal states.
+        """
+        return type(self)(
+            argparse=argparse or self.argparse,
+            syntax=syntax or self.syntax,
+            traceback=traceback or self.traceback,
+            unittest=unittest or self.unittest,
+        )
+
+    @classmethod
+    def no_colors(cls) -> Self:
+        """Return a new Theme where colors in all sections are empty strings.
+
+        This allows writing user code as if colors are always used. The color
+        fields will be ANSI color code strings when colorization is desired
+        and possible, and empty strings otherwise.
+        """
+        return cls(
+            argparse=Argparse.no_colors(),
+            syntax=Syntax.no_colors(),
+            traceback=Traceback.no_colors(),
+            unittest=Unittest.no_colors(),
+        )
+
+
 def get_colors(
     colorize: bool = False, *, file: IO[str] | IO[bytes] | None = None
 ) -> ANSIColors:
@@ -76,22 +264,37 @@ def get_colors(
         return NoColors
 
 
+def decolor(text: str) -> str:
+    """Remove ANSI color codes from a string."""
+    for code in ColorCodes:
+        text = text.replace(code, "")
+    return text
+
+
 def can_colorize(*, file: IO[str] | IO[bytes] | None = None) -> bool:
+
+    def _safe_getenv(k: str, fallback: str | None = None) -> str | None:
+        """Exception-safe environment retrieval. See gh-128636."""
+        try:
+            return os.environ.get(k, fallback)
+        except Exception:
+            return fallback
+
     if file is None:
         file = sys.stdout
 
     if not sys.flags.ignore_environment:
-        if os.environ.get("PYTHON_COLORS") == "0":
+        if _safe_getenv("PYTHON_COLORS") == "0":
             return False
-        if os.environ.get("PYTHON_COLORS") == "1":
+        if _safe_getenv("PYTHON_COLORS") == "1":
             return True
-    if os.environ.get("NO_COLOR"):
+    if _safe_getenv("NO_COLOR"):
         return False
     if not COLORIZE:
         return False
-    if os.environ.get("FORCE_COLOR"):
+    if _safe_getenv("FORCE_COLOR"):
         return True
-    if os.environ.get("TERM") == "dumb":
+    if _safe_getenv("TERM") == "dumb":
         return False
 
     if not hasattr(file, "fileno"):
@@ -108,5 +311,45 @@ def can_colorize(*, file: IO[str] | IO[bytes] | None = None) -> bool:
 
     try:
         return os.isatty(file.fileno())
-    except io.UnsupportedOperation:
+    except OSError:
         return hasattr(file, "isatty") and file.isatty()
+
+
+default_theme = Theme()
+theme_no_color = default_theme.no_colors()
+
+
+def get_theme(
+    *,
+    tty_file: IO[str] | IO[bytes] | None = None,
+    force_color: bool = False,
+    force_no_color: bool = False,
+) -> Theme:
+    """Returns the currently set theme, potentially in a zero-color variant.
+
+    In cases where colorizing is not possible (see `can_colorize`), the returned
+    theme contains all empty strings in all color definitions.
+    See `Theme.no_colors()` for more information.
+
+    It is recommended not to cache the result of this function for extended
+    periods of time because the user might influence theme selection by
+    the interactive shell, a debugger, or application-specific code. The
+    environment (including environment variable state and console configuration
+    on Windows) can also change in the course of the application life cycle.
+    """
+    if force_color or (not force_no_color and
+                       can_colorize(file=tty_file)):
+        return _theme
+    return theme_no_color
+
+
+def set_theme(t: Theme) -> None:
+    global _theme
+
+    if not isinstance(t, Theme):
+        raise ValueError(f"Expected Theme object, found {t}")
+
+    _theme = t
+
+
+set_theme(default_theme)
diff --git a/Lib/test/test__colorize.py b/Lib/test/test__colorize.py
index b2f0bb1386f..31dc60fec35 100644
--- a/Lib/test/test__colorize.py
+++ b/Lib/test/test__colorize.py
@@ -1,4 +1,5 @@
 import contextlib
+import dataclasses
 import io
 import sys
 import unittest
@@ -21,6 +22,42 @@ def supports_virtual_terminal():
         return contextlib.nullcontext()
 
 
+class TestTheme(unittest.TestCase):
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_attributes(self):
+        # only theme configurations attributes by default
+        for field in dataclasses.fields(_colorize.Theme):
+            with self.subTest(field.name):
+                self.assertIsSubclass(field.type, _colorize.ThemeSection)
+                self.assertIsNotNone(field.default_factory)
+
+    def test_copy_with(self):
+        theme = _colorize.Theme()
+
+        copy = theme.copy_with()
+        self.assertEqual(theme, copy)
+
+        unittest_no_colors = _colorize.Unittest.no_colors()
+        copy = theme.copy_with(unittest=unittest_no_colors)
+        self.assertEqual(copy.argparse, theme.argparse)
+        self.assertEqual(copy.syntax, theme.syntax)
+        self.assertEqual(copy.traceback, theme.traceback)
+        self.assertEqual(copy.unittest, unittest_no_colors)
+
+    def test_no_colors(self):
+        # idempotence test
+        theme_no_colors = _colorize.Theme().no_colors()
+        theme_no_colors_no_colors = theme_no_colors.no_colors()
+        self.assertEqual(theme_no_colors, theme_no_colors_no_colors)
+
+        # attributes check
+        for section in dataclasses.fields(_colorize.Theme):
+            with self.subTest(section.name):
+                section_theme = getattr(theme_no_colors, section.name)
+                self.assertEqual(section_theme, section.type.no_colors())
+
+
 class TestColorizeFunction(unittest.TestCase):
     def test_colorized_detection_checks_for_environment_variables(self):
         def check(env, fallback, expected):
@@ -129,6 +166,17 @@ def test_colorized_detection_checks_for_file(self):
                 file.isatty.return_value = False
                 self.assertEqual(_colorize.can_colorize(file=file), False)
 
+            # The documentation for file.fileno says:
+            # > An OSError is raised if the IO object does not use a file descriptor.
+            # gh-141570: Check OSError is caught and handled
+            with unittest.mock.patch("os.isatty", side_effect=ZeroDivisionError):
+                file = unittest.mock.MagicMock()
+                file.fileno.side_effect = OSError
+                file.isatty.return_value = True
+                self.assertEqual(_colorize.can_colorize(file=file), True)
+                file.isatty.return_value = False
+                self.assertEqual(_colorize.can_colorize(file=file), False)
+
 
 if __name__ == "__main__":
     unittest.main()

From d75f272c8b7436c5b609a16cd85d78469793ce00 Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Fri, 16 Jan 2026 20:10:26 +0900
Subject: [PATCH 334/418] Update argparse from CPython 3.14.2

---
 Lib/argparse.py           | 379 ++++++++++-----
 Lib/test/test_argparse.py | 995 ++++++++++++++++++++++++++++++--------
 2 files changed, 1048 insertions(+), 326 deletions(-)

diff --git a/Lib/argparse.py b/Lib/argparse.py
index bd088ea0e66..88c1f5a7ef3 100644
--- a/Lib/argparse.py
+++ b/Lib/argparse.py
@@ -18,11 +18,12 @@
         'integers', metavar='int', nargs='+', type=int,
         help='an integer to be summed')
     parser.add_argument(
-        '--log', default=sys.stdout, type=argparse.FileType('w'),
+        '--log',
         help='the file where the sum should be written')
     args = parser.parse_args()
-    args.log.write('%s' % sum(args.integers))
-    args.log.close()
+    with (open(args.log, 'w') if args.log is not None
+          else contextlib.nullcontext(sys.stdout)) as log:
+        log.write('%s' % sum(args.integers))
 
 The module contains the following public classes:
 
@@ -39,7 +40,8 @@
 
     - FileType -- A factory for defining types of files to be created. As the
         example above shows, instances of FileType are typically passed as
-        the type= argument of add_argument() calls.
+        the type= argument of add_argument() calls. Deprecated since
+        Python 3.14.
 
     - Action -- The base class for parser actions. Typically actions are
         selected by passing strings like 'store_true' or 'append_const' to
@@ -159,18 +161,21 @@ class HelpFormatter(object):
     provided by the class are considered an implementation detail.
     """
 
-    def __init__(self,
-                 prog,
-                 indent_increment=2,
-                 max_help_position=24,
-                 width=None):
-
+    def __init__(
+        self,
+        prog,
+        indent_increment=2,
+        max_help_position=24,
+        width=None,
+        color=True,
+    ):
         # default setting for width
         if width is None:
             import shutil
             width = shutil.get_terminal_size().columns
             width -= 2
 
+        self._set_color(color)
         self._prog = prog
         self._indent_increment = indent_increment
         self._max_help_position = min(max_help_position,
@@ -187,6 +192,16 @@ def __init__(self,
         self._whitespace_matcher = _re.compile(r'\s+', _re.ASCII)
         self._long_break_matcher = _re.compile(r'\n\n\n+')
 
+    def _set_color(self, color):
+        from _colorize import can_colorize, decolor, get_theme
+
+        if color and can_colorize():
+            self._theme = get_theme(force_color=True).argparse
+            self._decolor = decolor
+        else:
+            self._theme = get_theme(force_no_color=True).argparse
+            self._decolor = lambda text: text
+
     # ===============================
     # Section and indentation methods
     # ===============================
@@ -225,7 +240,11 @@ def format_help(self):
             if self.heading is not SUPPRESS and self.heading is not None:
                 current_indent = self.formatter._current_indent
                 heading_text = _('%(heading)s:') % dict(heading=self.heading)
-                heading = '%*s%s\n' % (current_indent, '', heading_text)
+                t = self.formatter._theme
+                heading = (
+                    f'{" " * current_indent}'
+                    f'{t.heading}{heading_text}{t.reset}\n'
+                )
             else:
                 heading = ''
 
@@ -262,7 +281,7 @@ def add_argument(self, action):
         if action.help is not SUPPRESS:
 
             # find all invocations
-            get_invocation = self._format_action_invocation
+            get_invocation = lambda x: self._decolor(self._format_action_invocation(x))
             invocation_lengths = [len(get_invocation(action)) + self._current_indent]
             for subaction in self._iter_indented_subactions(action):
                 invocation_lengths.append(len(get_invocation(subaction)) + self._current_indent)
@@ -296,16 +315,23 @@ def _join_parts(self, part_strings):
                         if part and part is not SUPPRESS])
 
     def _format_usage(self, usage, actions, groups, prefix):
+        t = self._theme
+
         if prefix is None:
             prefix = _('usage: ')
 
         # if usage is specified, use that
         if usage is not None:
-            usage = usage % dict(prog=self._prog)
+            usage = (
+                t.prog_extra
+                + usage
+                % {"prog": f"{t.prog}{self._prog}{t.reset}{t.prog_extra}"}
+                + t.reset
+            )
 
         # if no optionals or positionals are available, usage is just prog
         elif usage is None and not actions:
-            usage = '%(prog)s' % dict(prog=self._prog)
+            usage = f"{t.prog}{self._prog}{t.reset}"
 
         # if optionals and positionals are available, calculate usage
         elif usage is None:
@@ -327,7 +353,7 @@ def _format_usage(self, usage, actions, groups, prefix):
 
             # wrap the usage parts if it's too long
             text_width = self._width - self._current_indent
-            if len(prefix) + len(usage) > text_width:
+            if len(prefix) + len(self._decolor(usage)) > text_width:
 
                 # break usage into wrappable parts
                 opt_parts = self._get_actions_usage_parts(optionals, groups)
@@ -343,12 +369,13 @@ def get_lines(parts, indent, prefix=None):
                     else:
                         line_len = indent_length - 1
                     for part in parts:
-                        if line_len + 1 + len(part) > text_width and line:
+                        part_len = len(self._decolor(part))
+                        if line_len + 1 + part_len > text_width and line:
                             lines.append(indent + ' '.join(line))
                             line = []
                             line_len = indent_length - 1
                         line.append(part)
-                        line_len += len(part) + 1
+                        line_len += part_len + 1
                     if line:
                         lines.append(indent + ' '.join(line))
                     if prefix is not None:
@@ -356,8 +383,9 @@ def get_lines(parts, indent, prefix=None):
                     return lines
 
                 # if prog is short, follow it with optionals or positionals
-                if len(prefix) + len(prog) <= 0.75 * text_width:
-                    indent = ' ' * (len(prefix) + len(prog) + 1)
+                prog_len = len(self._decolor(prog))
+                if len(prefix) + prog_len <= 0.75 * text_width:
+                    indent = ' ' * (len(prefix) + prog_len + 1)
                     if opt_parts:
                         lines = get_lines([prog] + opt_parts, indent, prefix)
                         lines.extend(get_lines(pos_parts, indent))
@@ -380,12 +408,18 @@ def get_lines(parts, indent, prefix=None):
                 # join lines into usage
                 usage = '\n'.join(lines)
 
+            usage = usage.removeprefix(prog)
+            usage = f"{t.prog}{prog}{t.reset}{usage}"
+
         # prefix with 'usage:'
-        return '%s%s\n\n' % (prefix, usage)
+        return f'{t.usage}{prefix}{t.reset}{usage}\n\n'
 
     def _format_actions_usage(self, actions, groups):
         return ' '.join(self._get_actions_usage_parts(actions, groups))
 
+    def _is_long_option(self, string):
+        return len(string) > 2
+
     def _get_actions_usage_parts(self, actions, groups):
         # find group indices and identify actions in groups
         group_actions = set()
@@ -398,17 +432,18 @@ def _get_actions_usage_parts(self, actions, groups):
                 continue
 
             try:
-                start = actions.index(group._group_actions[0])
+                start = min(actions.index(item) for item in group._group_actions)
             except ValueError:
                 continue
             else:
                 end = start + len(group._group_actions)
-                if actions[start:end] == group._group_actions:
+                if set(actions[start:end]) == set(group._group_actions):
                     group_actions.update(group._group_actions)
                     inserts[start, end] = group
 
         # collect all actions format strings
         parts = []
+        t = self._theme
         for action in actions:
 
             # suppressed arguments are marked with None
@@ -418,7 +453,11 @@ def _get_actions_usage_parts(self, actions, groups):
             # produce all arg strings
             elif not action.option_strings:
                 default = self._get_default_metavar_for_positional(action)
-                part = self._format_args(action, default)
+                part = (
+                    t.summary_action
+                    + self._format_args(action, default)
+                    + t.reset
+                )
 
                 # if it's in a group, strip the outer []
                 if action in group_actions:
@@ -428,18 +467,26 @@ def _get_actions_usage_parts(self, actions, groups):
             # produce the first way to invoke the option in brackets
             else:
                 option_string = action.option_strings[0]
+                if self._is_long_option(option_string):
+                    option_color = t.summary_long_option
+                else:
+                    option_color = t.summary_short_option
 
                 # if the Optional doesn't take a value, format is:
                 #    -s or --long
                 if action.nargs == 0:
                     part = action.format_usage()
+                    part = f"{option_color}{part}{t.reset}"
 
                 # if the Optional takes a value, format is:
                 #    -s ARGS or --long ARGS
                 else:
                     default = self._get_default_metavar_for_optional(action)
                     args_string = self._format_args(action, default)
-                    part = '%s %s' % (option_string, args_string)
+                    part = (
+                        f"{option_color}{option_string} "
+                        f"{t.summary_label}{args_string}{t.reset}"
+                    )
 
                 # make it look optional if it's not required or in a group
                 if not action.required and action not in group_actions:
@@ -486,6 +533,7 @@ def _format_action(self, action):
         help_width = max(self._width - help_position, 11)
         action_width = help_position - self._current_indent - 2
         action_header = self._format_action_invocation(action)
+        action_header_no_color = self._decolor(action_header)
 
         # no help; start on same line and add a final newline
         if not action.help:
@@ -493,9 +541,15 @@ def _format_action(self, action):
             action_header = '%*s%s\n' % tup
 
         # short action name; start on the same line and pad two spaces
-        elif len(action_header) <= action_width:
-            tup = self._current_indent, '', action_width, action_header
+        elif len(action_header_no_color) <= action_width:
+            # calculate widths without color codes
+            action_header_color = action_header
+            tup = self._current_indent, '', action_width, action_header_no_color
             action_header = '%*s%-*s  ' % tup
+            # swap in the colored header
+            action_header = action_header.replace(
+                action_header_no_color, action_header_color
+            )
             indent_first = 0
 
         # long action name; start on the next line
@@ -528,23 +582,42 @@ def _format_action(self, action):
         return self._join_parts(parts)
 
     def _format_action_invocation(self, action):
+        t = self._theme
+
         if not action.option_strings:
             default = self._get_default_metavar_for_positional(action)
-            return ' '.join(self._metavar_formatter(action, default)(1))
+            return (
+                t.action
+                + ' '.join(self._metavar_formatter(action, default)(1))
+                + t.reset
+            )
 
         else:
 
+            def color_option_strings(strings):
+                parts = []
+                for s in strings:
+                    if self._is_long_option(s):
+                        parts.append(f"{t.long_option}{s}{t.reset}")
+                    else:
+                        parts.append(f"{t.short_option}{s}{t.reset}")
+                return parts
+
             # if the Optional doesn't take a value, format is:
             #    -s, --long
             if action.nargs == 0:
-                return ', '.join(action.option_strings)
+                option_strings = color_option_strings(action.option_strings)
+                return ', '.join(option_strings)
 
             # if the Optional takes a value, format is:
             #    -s, --long ARGS
             else:
                 default = self._get_default_metavar_for_optional(action)
-                args_string = self._format_args(action, default)
-                return ', '.join(action.option_strings) + ' ' + args_string
+                option_strings = color_option_strings(action.option_strings)
+                args_string = (
+                    f"{t.label}{self._format_args(action, default)}{t.reset}"
+                )
+                return ', '.join(option_strings) + ' ' + args_string
 
     def _metavar_formatter(self, action, default_metavar):
         if action.metavar is not None:
@@ -590,16 +663,19 @@ def _format_args(self, action, default_metavar):
         return result
 
     def _expand_help(self, action):
+        help_string = self._get_help_string(action)
+        if '%' not in help_string:
+            return help_string
         params = dict(vars(action), prog=self._prog)
         for name in list(params):
-            if params[name] is SUPPRESS:
+            value = params[name]
+            if value is SUPPRESS:
                 del params[name]
-        for name in list(params):
-            if hasattr(params[name], '__name__'):
-                params[name] = params[name].__name__
+            elif hasattr(value, '__name__'):
+                params[name] = value.__name__
         if params.get('choices') is not None:
             params['choices'] = ', '.join(map(str, params['choices']))
-        return self._get_help_string(action) % params
+        return help_string % params
 
     def _iter_indented_subactions(self, action):
         try:
@@ -844,22 +920,16 @@ def format_usage(self):
         return self.option_strings[0]
 
     def __call__(self, parser, namespace, values, option_string=None):
-        raise NotImplementedError(_('.__call__() not defined'))
-
+        raise NotImplementedError('.__call__() not defined')
 
-# FIXME: remove together with `BooleanOptionalAction` deprecated arguments.
-_deprecated_default = object()
 
 class BooleanOptionalAction(Action):
     def __init__(self,
                  option_strings,
                  dest,
                  default=None,
-                 type=_deprecated_default,
-                 choices=_deprecated_default,
                  required=False,
                  help=None,
-                 metavar=_deprecated_default,
                  deprecated=False):
 
         _option_strings = []
@@ -867,38 +937,19 @@ def __init__(self,
             _option_strings.append(option_string)
 
             if option_string.startswith('--'):
+                if option_string.startswith('--no-'):
+                    raise ValueError(f'invalid option name {option_string!r} '
+                                     f'for BooleanOptionalAction')
                 option_string = '--no-' + option_string[2:]
                 _option_strings.append(option_string)
 
-        # We need `_deprecated` special value to ban explicit arguments that
-        # match default value. Like:
-        #   parser.add_argument('-f', action=BooleanOptionalAction, type=int)
-        for field_name in ('type', 'choices', 'metavar'):
-            if locals()[field_name] is not _deprecated_default:
-                import warnings
-                warnings._deprecated(
-                    field_name,
-                    "{name!r} is deprecated as of Python 3.12 and will be "
-                    "removed in Python {remove}.",
-                    remove=(3, 14))
-
-        if type is _deprecated_default:
-            type = None
-        if choices is _deprecated_default:
-            choices = None
-        if metavar is _deprecated_default:
-            metavar = None
-
         super().__init__(
             option_strings=_option_strings,
             dest=dest,
             nargs=0,
             default=default,
-            type=type,
-            choices=choices,
             required=required,
             help=help,
-            metavar=metavar,
             deprecated=deprecated)
 
 
@@ -1180,6 +1231,7 @@ def __init__(self,
         self._name_parser_map = {}
         self._choices_actions = []
         self._deprecated = set()
+        self._color = True
 
         super(_SubParsersAction, self).__init__(
             option_strings=option_strings,
@@ -1195,23 +1247,30 @@ def add_parser(self, name, *, deprecated=False, **kwargs):
         if kwargs.get('prog') is None:
             kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
 
+        # set color
+        if kwargs.get('color') is None:
+            kwargs['color'] = self._color
+
         aliases = kwargs.pop('aliases', ())
 
         if name in self._name_parser_map:
-            raise ArgumentError(self, _('conflicting subparser: %s') % name)
+            raise ValueError(f'conflicting subparser: {name}')
         for alias in aliases:
             if alias in self._name_parser_map:
-                raise ArgumentError(
-                    self, _('conflicting subparser alias: %s') % alias)
+                raise ValueError(f'conflicting subparser alias: {alias}')
 
         # create a pseudo-action to hold the choice help
         if 'help' in kwargs:
             help = kwargs.pop('help')
             choice_action = self._ChoicesPseudoAction(name, aliases, help)
             self._choices_actions.append(choice_action)
+        else:
+            choice_action = None
 
         # create the parser and add it to the map
         parser = self._parser_class(**kwargs)
+        if choice_action is not None:
+            parser._check_help(choice_action)
         self._name_parser_map[name] = parser
 
         # make parser available under aliases also
@@ -1276,7 +1335,7 @@ def __call__(self, parser, namespace, values, option_string=None):
 # ==============
 
 class FileType(object):
-    """Factory for creating file object types
+    """Deprecated factory for creating file object types
 
     Instances of FileType are typically passed as type= arguments to the
     ArgumentParser add_argument() method.
@@ -1293,6 +1352,12 @@ class FileType(object):
     """
 
     def __init__(self, mode='r', bufsize=-1, encoding=None, errors=None):
+        import warnings
+        warnings.warn(
+            "FileType is deprecated. Simply open files after parsing arguments.",
+            category=PendingDeprecationWarning,
+            stacklevel=2
+        )
         self._mode = mode
         self._bufsize = bufsize
         self._encoding = encoding
@@ -1396,7 +1461,7 @@ def __init__(self,
         self._defaults = {}
 
         # determines whether an "option" looks like a negative number
-        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
+        self._negative_number_matcher = _re.compile(r'-\.?\d')
 
         # whether or not there are any optionals that look like negative
         # numbers -- uses a list so it can be shared and edited
@@ -1449,7 +1514,8 @@ def add_argument(self, *args, **kwargs):
         chars = self.prefix_chars
         if not args or len(args) == 1 and args[0][0] not in chars:
             if args and 'dest' in kwargs:
-                raise ValueError('dest supplied twice for positional argument')
+                raise TypeError('dest supplied twice for positional argument,'
+                                ' did you mean metavar?')
             kwargs = self._get_positional_kwargs(*args, **kwargs)
 
         # otherwise, we're adding an optional argument
@@ -1465,27 +1531,34 @@ def add_argument(self, *args, **kwargs):
                 kwargs['default'] = self.argument_default
 
         # create the action object, and add it to the parser
+        action_name = kwargs.get('action')
         action_class = self._pop_action_class(kwargs)
         if not callable(action_class):
-            raise ValueError('unknown action "%s"' % (action_class,))
+            raise ValueError(f'unknown action {action_class!r}')
         action = action_class(**kwargs)
 
+        # raise an error if action for positional argument does not
+        # consume arguments
+        if not action.option_strings and action.nargs == 0:
+            raise ValueError(f'action {action_name!r} is not valid for positional arguments')
+
         # raise an error if the action type is not callable
         type_func = self._registry_get('type', action.type, action.type)
         if not callable(type_func):
-            raise ValueError('%r is not callable' % (type_func,))
+            raise TypeError(f'{type_func!r} is not callable')
 
         if type_func is FileType:
-            raise ValueError('%r is a FileType class object, instance of it'
-                             ' must be passed' % (type_func,))
+            raise TypeError(f'{type_func!r} is a FileType class object, '
+                            f'instance of it must be passed')
 
         # raise an error if the metavar does not match the type
         if hasattr(self, "_get_formatter"):
+            formatter = self._get_formatter()
             try:
-                self._get_formatter()._format_args(action, None)
+                formatter._format_args(action, None)
             except TypeError:
                 raise ValueError("length of metavar tuple does not match nargs")
-
+        self._check_help(action)
         return self._add_action(action)
 
     def add_argument_group(self, *args, **kwargs):
@@ -1529,8 +1602,8 @@ def _add_container_actions(self, container):
             if group.title in title_group_map:
                 # This branch could happen if a derived class added
                 # groups with duplicated titles in __init__
-                msg = _('cannot merge actions - two groups are named %r')
-                raise ValueError(msg % (group.title))
+                msg = f'cannot merge actions - two groups are named {group.title!r}'
+                raise ValueError(msg)
             title_group_map[group.title] = group
 
         # map each action to its group
@@ -1571,13 +1644,15 @@ def _add_container_actions(self, container):
     def _get_positional_kwargs(self, dest, **kwargs):
         # make sure required is not specified
         if 'required' in kwargs:
-            msg = _("'required' is an invalid argument for positionals")
+            msg = "'required' is an invalid argument for positionals"
             raise TypeError(msg)
 
         # mark positional arguments as required if at least one is
         # always required
         nargs = kwargs.get('nargs')
-        if nargs not in [OPTIONAL, ZERO_OR_MORE, REMAINDER, SUPPRESS, 0]:
+        if nargs == 0:
+            raise ValueError('nargs for positionals must be != 0')
+        if nargs not in [OPTIONAL, ZERO_OR_MORE, REMAINDER, SUPPRESS]:
             kwargs['required'] = True
 
         # return the keyword arguments with no option strings
@@ -1590,11 +1665,9 @@ def _get_optional_kwargs(self, *args, **kwargs):
         for option_string in args:
             # error on strings that don't start with an appropriate prefix
             if not option_string[0] in self.prefix_chars:
-                args = {'option': option_string,
-                        'prefix_chars': self.prefix_chars}
-                msg = _('invalid option string %(option)r: '
-                        'must start with a character %(prefix_chars)r')
-                raise ValueError(msg % args)
+                raise ValueError(
+                    f'invalid option string {option_string!r}: '
+                    f'must start with a character {self.prefix_chars!r}')
 
             # strings starting with two prefix characters are long options
             option_strings.append(option_string)
@@ -1610,8 +1683,8 @@ def _get_optional_kwargs(self, *args, **kwargs):
                 dest_option_string = option_strings[0]
             dest = dest_option_string.lstrip(self.prefix_chars)
             if not dest:
-                msg = _('dest= is required for options like %r')
-                raise ValueError(msg % option_string)
+                msg = f'dest= is required for options like {option_string!r}'
+                raise TypeError(msg)
             dest = dest.replace('-', '_')
 
         # return the updated keyword arguments
@@ -1627,8 +1700,8 @@ def _get_handler(self):
         try:
             return getattr(self, handler_func_name)
         except AttributeError:
-            msg = _('invalid conflict_resolution value: %r')
-            raise ValueError(msg % self.conflict_handler)
+            msg = f'invalid conflict_resolution value: {self.conflict_handler!r}'
+            raise ValueError(msg)
 
     def _check_conflict(self, action):
 
@@ -1667,10 +1740,26 @@ def _handle_conflict_resolve(self, action, conflicting_actions):
             if not action.option_strings:
                 action.container._remove_action(action)
 
+    def _check_help(self, action):
+        if action.help and hasattr(self, "_get_formatter"):
+            formatter = self._get_formatter()
+            try:
+                formatter._expand_help(action)
+            except (ValueError, TypeError, KeyError) as exc:
+                raise ValueError('badly formed help string') from exc
+
 
 class _ArgumentGroup(_ActionsContainer):
 
     def __init__(self, container, title=None, description=None, **kwargs):
+        if 'prefix_chars' in kwargs:
+            import warnings
+            depr_msg = (
+                "The use of the undocumented 'prefix_chars' parameter in "
+                "ArgumentParser.add_argument_group() is deprecated."
+            )
+            warnings.warn(depr_msg, DeprecationWarning, stacklevel=3)
+
         # add any missing keyword arguments by checking the container
         update = kwargs.setdefault
         update('conflict_handler', container.conflict_handler)
@@ -1702,14 +1791,7 @@ def _remove_action(self, action):
         self._group_actions.remove(action)
 
     def add_argument_group(self, *args, **kwargs):
-        import warnings
-        warnings.warn(
-            "Nesting argument groups is deprecated.",
-            category=DeprecationWarning,
-            stacklevel=2
-        )
-        return super().add_argument_group(*args, **kwargs)
-
+        raise ValueError('argument groups cannot be nested')
 
 class _MutuallyExclusiveGroup(_ArgumentGroup):
 
@@ -1720,7 +1802,7 @@ def __init__(self, container, required=False):
 
     def _add_action(self, action):
         if action.required:
-            msg = _('mutually exclusive arguments must be optional')
+            msg = 'mutually exclusive arguments must be optional'
             raise ValueError(msg)
         action = self._container._add_action(action)
         self._group_actions.append(action)
@@ -1730,14 +1812,29 @@ def _remove_action(self, action):
         self._container._remove_action(action)
         self._group_actions.remove(action)
 
-    def add_mutually_exclusive_group(self, *args, **kwargs):
-        import warnings
-        warnings.warn(
-            "Nesting mutually exclusive groups is deprecated.",
-            category=DeprecationWarning,
-            stacklevel=2
-        )
-        return super().add_mutually_exclusive_group(*args, **kwargs)
+    def add_mutually_exclusive_group(self, **kwargs):
+        raise ValueError('mutually exclusive groups cannot be nested')
+
+def _prog_name(prog=None):
+    if prog is not None:
+        return prog
+    arg0 = _sys.argv[0]
+    try:
+        modspec = _sys.modules['__main__'].__spec__
+    except (KeyError, AttributeError):
+        # possibly PYTHONSTARTUP or -X presite or other weird edge case
+        # no good answer here, so fall back to the default
+        modspec = None
+    if modspec is None:
+        # simple script
+        return _os.path.basename(arg0)
+    py = _os.path.basename(_sys.executable)
+    if modspec.name != '__main__':
+        # imported module or package
+        modname = modspec.name.removesuffix('.__main__')
+        return f'{py} -m {modname}'
+    # directory or ZIP file
+    return f'{py} {arg0}'
 
 
 class ArgumentParser(_AttributeHolder, _ActionsContainer):
@@ -1760,6 +1857,9 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
         - allow_abbrev -- Allow long options to be abbreviated unambiguously
         - exit_on_error -- Determines whether or not ArgumentParser exits with
             error info when an error occurs
+        - suggest_on_error - Enables suggestions for mistyped argument choices
+            and subparser names (default: ``False``)
+        - color - Allow color output in help messages (default: ``False``)
     """
 
     def __init__(self,
@@ -1775,19 +1875,18 @@ def __init__(self,
                  conflict_handler='error',
                  add_help=True,
                  allow_abbrev=True,
-                 exit_on_error=True):
-
+                 exit_on_error=True,
+                 *,
+                 suggest_on_error=False,
+                 color=True,
+                 ):
         superinit = super(ArgumentParser, self).__init__
         superinit(description=description,
                   prefix_chars=prefix_chars,
                   argument_default=argument_default,
                   conflict_handler=conflict_handler)
 
-        # default setting for prog
-        if prog is None:
-            prog = _os.path.basename(_sys.argv[0])
-
-        self.prog = prog
+        self.prog = _prog_name(prog)
         self.usage = usage
         self.epilog = epilog
         self.formatter_class = formatter_class
@@ -1795,6 +1894,8 @@ def __init__(self,
         self.add_help = add_help
         self.allow_abbrev = allow_abbrev
         self.exit_on_error = exit_on_error
+        self.suggest_on_error = suggest_on_error
+        self.color = color
 
         add_group = self.add_argument_group
         self._positionals = add_group(_('positional arguments'))
@@ -1844,7 +1945,7 @@ def _get_kwargs(self):
 
     def add_subparsers(self, **kwargs):
         if self._subparsers is not None:
-            raise ArgumentError(None, _('cannot have multiple subparser arguments'))
+            raise ValueError('cannot have multiple subparser arguments')
 
         # add the parser class to the arguments if it's not present
         kwargs.setdefault('parser_class', type(self))
@@ -1859,15 +1960,19 @@ def add_subparsers(self, **kwargs):
         # prog defaults to the usage message of this parser, skipping
         # optional arguments and with no "usage:" prefix
         if kwargs.get('prog') is None:
-            formatter = self._get_formatter()
+            # Create formatter without color to avoid storing ANSI codes in prog
+            formatter = self.formatter_class(prog=self.prog)
+            formatter._set_color(False)
             positionals = self._get_positional_actions()
             groups = self._mutually_exclusive_groups
-            formatter.add_usage(self.usage, positionals, groups, '')
+            formatter.add_usage(None, positionals, groups, '')
             kwargs['prog'] = formatter.format_help().strip()
 
         # create the parsers action and add it to the positionals list
         parsers_class = self._pop_action_class(kwargs, 'parsers')
         action = parsers_class(option_strings=[], **kwargs)
+        action._color = self.color
+        self._check_help(action)
         self._subparsers._add_action(action)
 
         # return the created parsers action
@@ -2498,7 +2603,6 @@ def _get_values(self, action, arg_strings):
                 value = action.default
             if isinstance(value, str) and value is not SUPPRESS:
                 value = self._get_value(action, value)
-                self._check_value(action, value)
 
         # when nargs='*' on a positional, if there were no command-line
         # args, use the default if it is anything other than None
@@ -2506,11 +2610,8 @@ def _get_values(self, action, arg_strings):
               not action.option_strings):
             if action.default is not None:
                 value = action.default
-                self._check_value(action, value)
             else:
-                # since arg_strings is always [] at this point
-                # there is no need to use self._check_value(action, value)
-                value = arg_strings
+                value = []
 
         # single argument or optional argument produces a single value
         elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
@@ -2543,8 +2644,7 @@ def _get_values(self, action, arg_strings):
     def _get_value(self, action, arg_string):
         type_func = self._registry_get('type', action.type, action.type)
         if not callable(type_func):
-            msg = _('%r is not callable')
-            raise ArgumentError(action, msg % type_func)
+            raise TypeError(f'{type_func!r} is not callable')
 
         # convert the value to the appropriate type
         try:
@@ -2568,14 +2668,27 @@ def _get_value(self, action, arg_string):
     def _check_value(self, action, value):
         # converted value must be one of the choices (if specified)
         choices = action.choices
-        if choices is not None:
-            if isinstance(choices, str):
-                choices = iter(choices)
-            if value not in choices:
-                args = {'value': str(value),
-                        'choices': ', '.join(map(str, action.choices))}
-                msg = _('invalid choice: %(value)r (choose from %(choices)s)')
-                raise ArgumentError(action, msg % args)
+        if choices is None:
+            return
+
+        if isinstance(choices, str):
+            choices = iter(choices)
+
+        if value not in choices:
+            args = {'value': str(value),
+                    'choices': ', '.join(map(str, action.choices))}
+            msg = _('invalid choice: %(value)r (choose from %(choices)s)')
+
+            if self.suggest_on_error and isinstance(value, str):
+                if all(isinstance(choice, str) for choice in action.choices):
+                    import difflib
+                    suggestions = difflib.get_close_matches(value, action.choices, 1)
+                    if suggestions:
+                        args['closest'] = suggestions[0]
+                        msg = _('invalid choice: %(value)r, maybe you meant %(closest)r? '
+                                '(choose from %(choices)s)')
+
+            raise ArgumentError(action, msg % args)
 
     # =======================
     # Help-formatting methods
@@ -2611,7 +2724,9 @@ def format_help(self):
         return formatter.format_help()
 
     def _get_formatter(self):
-        return self.formatter_class(prog=self.prog)
+        formatter = self.formatter_class(prog=self.prog)
+        formatter._set_color(self.color)
+        return formatter
 
     # =====================
     # Help-printing methods
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index b7e995334fe..beda61be8a4 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -1,11 +1,13 @@
 # Author: Steven J. Bethard <steven.bethard@gmail.com>.
 
+import _colorize
 import contextlib
 import functools
 import inspect
 import io
 import operator
 import os
+import py_compile
 import shutil
 import stat
 import sys
@@ -16,12 +18,22 @@
 import warnings
 
 from enum import StrEnum
-from test.support import captured_stderr
+from test.support import (
+    captured_stderr,
+    force_not_colorized,
+    force_not_colorized_test_class,
+    swap_attr,
+)
+from test.support import import_helper
 from test.support import os_helper
+from test.support import script_helper
 from test.support.i18n_helper import TestTranslationsBase, update_translation_snapshots
 from unittest import mock
 
 
+py = os.path.basename(sys.executable)
+
+
 class StdIOBuffer(io.TextIOWrapper):
     '''Replacement for writable io.StringIO that behaves more like real file
 
@@ -631,9 +643,9 @@ class TestOptionalsNargsOptional(ParserTestCase):
         Sig('-w', nargs='?'),
         Sig('-x', nargs='?', const=42),
         Sig('-y', nargs='?', default='spam'),
-        Sig('-z', nargs='?', type=int, const='42', default='84'),
+        Sig('-z', nargs='?', type=int, const='42', default='84', choices=[1, 2]),
     ]
-    failures = ['2']
+    failures = ['2', '-z a', '-z 42', '-z 84']
     successes = [
         ('', NS(w=None, x=None, y='spam', z=84)),
         ('-w', NS(w=None, x=None, y='spam', z=84)),
@@ -777,48 +789,12 @@ def test_const(self):
 
         self.assertIn("got an unexpected keyword argument 'const'", str(cm.exception))
 
-    def test_deprecated_init_kw(self):
-        # See gh-92248
+    def test_invalid_name(self):
         parser = argparse.ArgumentParser()
-
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-a',
-                action=argparse.BooleanOptionalAction,
-                type=None,
-            )
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-b',
-                action=argparse.BooleanOptionalAction,
-                type=bool,
-            )
-
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-c',
-                action=argparse.BooleanOptionalAction,
-                metavar=None,
-            )
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-d',
-                action=argparse.BooleanOptionalAction,
-                metavar='d',
-            )
-
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-e',
-                action=argparse.BooleanOptionalAction,
-                choices=None,
-            )
-        with self.assertWarns(DeprecationWarning):
-            parser.add_argument(
-                '-f',
-                action=argparse.BooleanOptionalAction,
-                choices=(),
-            )
+        with self.assertRaises(ValueError) as cm:
+            parser.add_argument('--no-foo', action=argparse.BooleanOptionalAction)
+        self.assertEqual(str(cm.exception),
+                         "invalid option name '--no-foo' for BooleanOptionalAction")
 
 class TestBooleanOptionalActionRequired(ParserTestCase):
     """Tests BooleanOptionalAction required"""
@@ -1036,6 +1012,7 @@ def test_parse_enum_value(self):
         args = parser.parse_args(['--color', 'red'])
         self.assertEqual(args.color, self.Color.RED)
 
+    @force_not_colorized
     def test_help_message_contains_enum_choices(self):
         parser = argparse.ArgumentParser()
         parser.add_argument('--color', choices=self.Color, help='Choose a color')
@@ -1101,8 +1078,8 @@ class TestPositionalsNargsZeroOrMore(ParserTestCase):
 class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):
     """Test a Positional that specifies unlimited nargs and a default"""
 
-    argument_signatures = [Sig('foo', nargs='*', default='bar')]
-    failures = ['-x']
+    argument_signatures = [Sig('foo', nargs='*', default='bar', choices=['a', 'b'])]
+    failures = ['-x', 'bar', 'a c']
     successes = [
         ('', NS(foo='bar')),
         ('a', NS(foo=['a'])),
@@ -1135,8 +1112,8 @@ class TestPositionalsNargsOptional(ParserTestCase):
 class TestPositionalsNargsOptionalDefault(ParserTestCase):
     """Tests an Optional Positional with a default value"""
 
-    argument_signatures = [Sig('foo', nargs='?', default=42)]
-    failures = ['-x', 'a b']
+    argument_signatures = [Sig('foo', nargs='?', default=42, choices=['a', 'b'])]
+    failures = ['-x', 'a b', '42']
     successes = [
         ('', NS(foo=42)),
         ('a', NS(foo='a')),
@@ -1149,9 +1126,9 @@ class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):
     """
 
     argument_signatures = [
-        Sig('foo', nargs='?', type=int, default='42'),
+        Sig('foo', nargs='?', type=int, default='42', choices=[1, 2]),
     ]
-    failures = ['-x', 'a b', '1 2']
+    failures = ['-x', 'a b', '1 2', '42']
     successes = [
         ('', NS(foo=42)),
         ('1', NS(foo=1)),
@@ -1811,27 +1788,43 @@ def convert_arg_line_to_args(self, arg_line):
 # Type conversion tests
 # =====================
 
+def FileType(*args, **kwargs):
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', 'FileType is deprecated',
+                                PendingDeprecationWarning, __name__)
+        return argparse.FileType(*args, **kwargs)
+
+
+class TestFileTypeDeprecation(TestCase):
+
+    def test(self):
+        with self.assertWarns(PendingDeprecationWarning) as cm:
+            argparse.FileType()
+        self.assertIn('FileType is deprecated', str(cm.warning))
+        self.assertEqual(cm.filename, __file__)
+
+
 class TestFileTypeRepr(TestCase):
 
     def test_r(self):
-        type = argparse.FileType('r')
+        type = FileType('r')
         self.assertEqual("FileType('r')", repr(type))
 
     def test_wb_1(self):
-        type = argparse.FileType('wb', 1)
+        type = FileType('wb', 1)
         self.assertEqual("FileType('wb', 1)", repr(type))
 
     def test_r_latin(self):
-        type = argparse.FileType('r', encoding='latin_1')
+        type = FileType('r', encoding='latin_1')
         self.assertEqual("FileType('r', encoding='latin_1')", repr(type))
 
     def test_w_big5_ignore(self):
-        type = argparse.FileType('w', encoding='big5', errors='ignore')
+        type = FileType('w', encoding='big5', errors='ignore')
         self.assertEqual("FileType('w', encoding='big5', errors='ignore')",
                          repr(type))
 
     def test_r_1_replace(self):
-        type = argparse.FileType('r', 1, errors='replace')
+        type = FileType('r', 1, errors='replace')
         self.assertEqual("FileType('r', 1, errors='replace')", repr(type))
 
 
@@ -1885,7 +1878,6 @@ def __eq__(self, other):
             text = text.decode('ascii')
         return self.name == other.name == text
 
-
 class TestFileTypeR(TempDirMixin, ParserTestCase):
     """Test the FileType option/argument type for reading files"""
 
@@ -1898,8 +1890,8 @@ def setUp(self):
         self.create_readonly_file('readonly')
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType()),
-        Sig('spam', type=argparse.FileType('r')),
+        Sig('-x', type=FileType()),
+        Sig('spam', type=FileType('r')),
     ]
     failures = ['-x', '', 'non-existent-file.txt']
     successes = [
@@ -1919,7 +1911,7 @@ def setUp(self):
         file.close()
 
     argument_signatures = [
-        Sig('-c', type=argparse.FileType('r'), default='no-file.txt'),
+        Sig('-c', type=FileType('r'), default='no-file.txt'),
     ]
     # should provoke no such file error
     failures = ['']
@@ -1938,8 +1930,8 @@ def setUp(self):
                 file.write(file_name)
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType('rb')),
-        Sig('spam', type=argparse.FileType('rb')),
+        Sig('-x', type=FileType('rb')),
+        Sig('spam', type=FileType('rb')),
     ]
     failures = ['-x', '']
     successes = [
@@ -1977,8 +1969,8 @@ def setUp(self):
         self.create_writable_file('writable')
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType('w')),
-        Sig('spam', type=argparse.FileType('w')),
+        Sig('-x', type=FileType('w')),
+        Sig('spam', type=FileType('w')),
     ]
     failures = ['-x', '', 'readonly']
     successes = [
@@ -2000,8 +1992,8 @@ def setUp(self):
         self.create_writable_file('writable')
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType('x')),
-        Sig('spam', type=argparse.FileType('x')),
+        Sig('-x', type=FileType('x')),
+        Sig('spam', type=FileType('x')),
     ]
     failures = ['-x', '', 'readonly', 'writable']
     successes = [
@@ -2015,8 +2007,8 @@ class TestFileTypeWB(TempDirMixin, ParserTestCase):
     """Test the FileType option/argument type for writing binary files"""
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType('wb')),
-        Sig('spam', type=argparse.FileType('wb')),
+        Sig('-x', type=FileType('wb')),
+        Sig('spam', type=FileType('wb')),
     ]
     failures = ['-x', '']
     successes = [
@@ -2032,8 +2024,8 @@ class TestFileTypeXB(TestFileTypeX):
     "Test the FileType option/argument type for writing new binary files only"
 
     argument_signatures = [
-        Sig('-x', type=argparse.FileType('xb')),
-        Sig('spam', type=argparse.FileType('xb')),
+        Sig('-x', type=FileType('xb')),
+        Sig('spam', type=FileType('xb')),
     ]
     successes = [
         ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),
@@ -2045,7 +2037,7 @@ class TestFileTypeOpenArgs(TestCase):
     """Test that open (the builtin) is correctly called"""
 
     def test_open_args(self):
-        FT = argparse.FileType
+        FT = FileType
         cases = [
             (FT('rb'), ('rb', -1, None, None)),
             (FT('w', 1), ('w', 1, None, None)),
@@ -2060,7 +2052,7 @@ def test_open_args(self):
 
     def test_invalid_file_type(self):
         with self.assertRaises(ValueError):
-            argparse.FileType('b')('-test')
+            FileType('b')('-test')
 
 
 class TestFileTypeMissingInitialization(TestCase):
@@ -2071,7 +2063,7 @@ class TestFileTypeMissingInitialization(TestCase):
 
     def test(self):
         parser = argparse.ArgumentParser()
-        with self.assertRaises(ValueError) as cm:
+        with self.assertRaises(TypeError) as cm:
             parser.add_argument('-x', type=argparse.FileType)
 
         self.assertEqual(
@@ -2256,6 +2248,130 @@ class TestActionExtend(ParserTestCase):
     ]
 
 
+class TestNegativeNumber(ParserTestCase):
+    """Test parsing negative numbers"""
+
+    argument_signatures = [
+        Sig('--int', type=int),
+        Sig('--float', type=float),
+        Sig('--complex', type=complex),
+    ]
+    failures = [
+        '--float -_.45',
+        '--float -1__000.0',
+        '--float -1.0.0',
+        '--int -1__000',
+        '--int -1.0',
+        '--complex -1__000.0j',
+        '--complex -1.0jj',
+        '--complex -_.45j',
+    ]
+    successes = [
+        ('--int -1000 --float -1000.0', NS(int=-1000, float=-1000.0, complex=None)),
+        ('--int -1_000 --float -1_000.0', NS(int=-1000, float=-1000.0, complex=None)),
+        ('--int -1_000_000 --float -1_000_000.0', NS(int=-1000000, float=-1000000.0, complex=None)),
+        ('--float -1_000.0', NS(int=None, float=-1000.0, complex=None)),
+        ('--float -1_000_000.0_0', NS(int=None, float=-1000000.0, complex=None)),
+        ('--float -.5', NS(int=None, float=-0.5, complex=None)),
+        ('--float -.5_000', NS(int=None, float=-0.5, complex=None)),
+        ('--float -1e3', NS(int=None, float=-1000, complex=None)),
+        ('--float -1e-3', NS(int=None, float=-0.001, complex=None)),
+        ('--complex -1j', NS(int=None, float=None, complex=-1j)),
+        ('--complex -1_000j', NS(int=None, float=None, complex=-1000j)),
+        ('--complex -1_000.0j', NS(int=None, float=None, complex=-1000.0j)),
+        ('--complex -1e3j', NS(int=None, float=None, complex=-1000j)),
+        ('--complex -1e-3j', NS(int=None, float=None, complex=-0.001j)),
+    ]
+
+class TestArgumentAndSubparserSuggestions(TestCase):
+    """Test error handling and suggestion when a user makes a typo"""
+
+    def test_wrong_argument_error_with_suggestions(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=True)
+        parser.add_argument('foo', choices=['bar', 'baz'])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('bazz',))
+        self.assertIn(
+            "error: argument foo: invalid choice: 'bazz', maybe you meant 'baz'? (choose from bar, baz)",
+            excinfo.exception.stderr
+        )
+
+    def test_wrong_argument_error_no_suggestions(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=False)
+        parser.add_argument('foo', choices=['bar', 'baz'])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('bazz',))
+        self.assertIn(
+            "error: argument foo: invalid choice: 'bazz' (choose from bar, baz)",
+            excinfo.exception.stderr,
+        )
+
+    def test_wrong_argument_subparsers_with_suggestions(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=True)
+        subparsers = parser.add_subparsers(required=True)
+        subparsers.add_parser('foo')
+        subparsers.add_parser('bar')
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('baz',))
+        self.assertIn(
+            "error: argument {foo,bar}: invalid choice: 'baz', maybe you meant"
+             " 'bar'? (choose from foo, bar)",
+            excinfo.exception.stderr,
+        )
+
+    def test_wrong_argument_subparsers_no_suggestions(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=False)
+        subparsers = parser.add_subparsers(required=True)
+        subparsers.add_parser('foo')
+        subparsers.add_parser('bar')
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('baz',))
+        self.assertIn(
+            "error: argument {foo,bar}: invalid choice: 'baz' (choose from foo, bar)",
+            excinfo.exception.stderr,
+        )
+
+    def test_wrong_argument_no_suggestion_implicit(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('foo', choices=['bar', 'baz'])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('bazz',))
+        self.assertIn(
+            "error: argument foo: invalid choice: 'bazz' (choose from bar, baz)",
+            excinfo.exception.stderr,
+        )
+
+    def test_suggestions_choices_empty(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=True)
+        parser.add_argument('foo', choices=[])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('bazz',))
+        self.assertIn(
+            "error: argument foo: invalid choice: 'bazz' (choose from )",
+            excinfo.exception.stderr,
+        )
+
+    def test_suggestions_choices_int(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=True)
+        parser.add_argument('foo', choices=[1, 2])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('3',))
+        self.assertIn(
+            "error: argument foo: invalid choice: '3' (choose from 1, 2)",
+            excinfo.exception.stderr,
+        )
+
+    def test_suggestions_choices_mixed_types(self):
+        parser = ErrorRaisingArgumentParser(suggest_on_error=True)
+        parser.add_argument('foo', choices=[1, '2'])
+        with self.assertRaises(ArgumentParserError) as excinfo:
+            parser.parse_args(('3',))
+        self.assertIn(
+            "error: argument foo: invalid choice: '3' (choose from 1, 2)",
+            excinfo.exception.stderr,
+        )
+
+
 class TestInvalidAction(TestCase):
     """Test invalid user defined Action"""
 
@@ -2269,17 +2385,31 @@ def test_invalid_type(self):
         self.assertRaises(NotImplementedError, parser.parse_args, ['--foo', 'bar'])
 
     def test_modified_invalid_action(self):
-        parser = ErrorRaisingArgumentParser()
+        parser = argparse.ArgumentParser(exit_on_error=False)
         action = parser.add_argument('--foo')
         # Someone got crazy and did this
         action.type = 1
-        self.assertRaises(ArgumentParserError, parser.parse_args, ['--foo', 'bar'])
+        self.assertRaisesRegex(TypeError, '1 is not callable',
+                               parser.parse_args, ['--foo', 'bar'])
+        action.type = ()
+        self.assertRaisesRegex(TypeError, r'\(\) is not callable',
+                               parser.parse_args, ['--foo', 'bar'])
+        # It is impossible to distinguish a TypeError raised due to a mismatch
+        # of the required function arguments from a TypeError raised for an incorrect
+        # argument value, and using the heavy inspection machinery is not worthwhile
+        # as it does not reliably work in all cases.
+        # Therefore, a generic ArgumentError is raised to handle this logical error.
+        action.type = pow
+        self.assertRaisesRegex(argparse.ArgumentError,
+                               "argument --foo: invalid pow value: 'bar'",
+                               parser.parse_args, ['--foo', 'bar'])
 
 
 # ================
 # Subparsers tests
 # ================
 
+@force_not_colorized_test_class
 class TestAddSubparsers(TestCase):
     """Test the add_subparsers method"""
 
@@ -2287,16 +2417,17 @@ def assertArgumentParserError(self, *args, **kwargs):
         self.assertRaises(ArgumentParserError, *args, **kwargs)
 
     def _get_parser(self, subparser_help=False, prefix_chars=None,
-                    aliases=False):
+                    aliases=False, usage=None):
         # create a parser with a subparsers argument
         if prefix_chars:
             parser = ErrorRaisingArgumentParser(
-                prog='PROG', description='main description', prefix_chars=prefix_chars)
+                prog='PROG', description='main description', usage=usage,
+                prefix_chars=prefix_chars)
             parser.add_argument(
                 prefix_chars[0] * 2 + 'foo', action='store_true', help='foo help')
         else:
             parser = ErrorRaisingArgumentParser(
-                prog='PROG', description='main description')
+                prog='PROG', description='main description', usage=usage)
             parser.add_argument(
                 '--foo', action='store_true', help='foo help')
         parser.add_argument(
@@ -2310,7 +2441,7 @@ def _get_parser(self, subparser_help=False, prefix_chars=None,
         else:
             subparsers_kwargs['help'] = 'command help'
         subparsers = parser.add_subparsers(**subparsers_kwargs)
-        self.assertRaisesRegex(argparse.ArgumentError,
+        self.assertRaisesRegex(ValueError,
                                'cannot have multiple subparser arguments',
                                parser.add_subparsers)
 
@@ -2333,7 +2464,8 @@ def _get_parser(self, subparser_help=False, prefix_chars=None,
         parser2.add_argument('z', type=complex, nargs='*', help='z help')
 
         # add third sub-parser
-        parser3_kwargs = dict(description='3 description')
+        parser3_kwargs = dict(description='3 description',
+                              usage='PROG --foo bar 3 t ...')
         if subparser_help:
             parser3_kwargs['help'] = '3 help'
         parser3 = subparsers.add_parser('3', **parser3_kwargs)
@@ -2355,6 +2487,47 @@ def test_parse_args_failures(self):
             args = args_str.split()
             self.assertArgumentParserError(self.parser.parse_args, args)
 
+    def test_parse_args_failures_details(self):
+        for args_str, usage_str, error_str in [
+            ('',
+             'usage: PROG [-h] [--foo] bar {1,2,3} ...',
+             'PROG: error: the following arguments are required: bar'),
+            ('0.5 1 -y',
+             'usage: PROG bar 1 [-h] [-w W] {a,b,c}',
+             'PROG bar 1: error: the following arguments are required: x'),
+            ('0.5 3',
+             'usage: PROG --foo bar 3 t ...',
+             'PROG bar 3: error: the following arguments are required: t'),
+        ]:
+            with self.subTest(args_str):
+                args = args_str.split()
+                with self.assertRaises(ArgumentParserError) as cm:
+                    self.parser.parse_args(args)
+                self.assertEqual(cm.exception.args[0], 'SystemExit')
+                self.assertEqual(cm.exception.args[2], f'{usage_str}\n{error_str}\n')
+
+    def test_parse_args_failures_details_custom_usage(self):
+        parser = self._get_parser(usage='PROG [--foo] bar 1 [-w W] {a,b,c}\n'
+                                 '       PROG --foo bar 3 t ...')
+        for args_str, usage_str, error_str in [
+            ('',
+             'usage: PROG [--foo] bar 1 [-w W] {a,b,c}\n'
+             '       PROG --foo bar 3 t ...',
+             'PROG: error: the following arguments are required: bar'),
+            ('0.5 1 -y',
+             'usage: PROG bar 1 [-h] [-w W] {a,b,c}',
+             'PROG bar 1: error: the following arguments are required: x'),
+            ('0.5 3',
+             'usage: PROG --foo bar 3 t ...',
+             'PROG bar 3: error: the following arguments are required: t'),
+        ]:
+            with self.subTest(args_str):
+                args = args_str.split()
+                with self.assertRaises(ArgumentParserError) as cm:
+                    parser.parse_args(args)
+                self.assertEqual(cm.exception.args[0], 'SystemExit')
+                self.assertEqual(cm.exception.args[2], f'{usage_str}\n{error_str}\n')
+
     def test_parse_args(self):
         # check some non-failure cases:
         self.assertEqual(
@@ -2508,18 +2681,6 @@ def test_required_subparsers_no_destination_error(self):
             'error: the following arguments are required: {foo,bar}\n$'
         )
 
-    def test_wrong_argument_subparsers_no_destination_error(self):
-        parser = ErrorRaisingArgumentParser()
-        subparsers = parser.add_subparsers(required=True)
-        subparsers.add_parser('foo')
-        subparsers.add_parser('bar')
-        with self.assertRaises(ArgumentParserError) as excinfo:
-            parser.parse_args(('baz',))
-        self.assertRegex(
-            excinfo.exception.stderr,
-            r"error: argument {foo,bar}: invalid choice: 'baz' \(choose from foo, bar\)\n$"
-        )
-
     def test_optional_subparsers(self):
         parser = ErrorRaisingArgumentParser()
         subparsers = parser.add_subparsers(dest='command', required=False)
@@ -2655,6 +2816,29 @@ def test_parser_command_help(self):
               --foo       foo help
             '''))
 
+    def assert_bad_help(self, context_type, func, *args, **kwargs):
+        with self.assertRaisesRegex(ValueError, 'badly formed help string') as cm:
+            func(*args, **kwargs)
+        self.assertIsInstance(cm.exception.__context__, context_type)
+
+    def test_invalid_subparsers_help(self):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        self.assert_bad_help(ValueError, parser.add_subparsers, help='%Y-%m-%d')
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        self.assert_bad_help(KeyError, parser.add_subparsers, help='%(spam)s')
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        self.assert_bad_help(TypeError, parser.add_subparsers, help='%(prog)d')
+
+    def test_invalid_subparser_help(self):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        subparsers = parser.add_subparsers()
+        self.assert_bad_help(ValueError, subparsers.add_parser, '1',
+                             help='%Y-%m-%d')
+        self.assert_bad_help(KeyError, subparsers.add_parser, '1',
+                             help='%(spam)s')
+        self.assert_bad_help(TypeError, subparsers.add_parser, '1',
+                             help='%(prog)d')
+
     def test_subparser_title_help(self):
         parser = ErrorRaisingArgumentParser(prog='PROG',
                                             description='main description')
@@ -2796,10 +2980,43 @@ def test_interleaved_groups(self):
         result = parser.parse_args('1 2 3 4'.split())
         self.assertEqual(expected, result)
 
+class TestGroupConstructor(TestCase):
+    def test_group_prefix_chars(self):
+        parser = ErrorRaisingArgumentParser()
+        msg = (
+            "The use of the undocumented 'prefix_chars' parameter in "
+            "ArgumentParser.add_argument_group() is deprecated."
+        )
+        with self.assertWarns(DeprecationWarning) as cm:
+            parser.add_argument_group(prefix_chars='-+')
+        self.assertEqual(msg, str(cm.warning))
+        self.assertEqual(cm.filename, __file__)
+
+    def test_group_prefix_chars_default(self):
+        # "default" isn't quite the right word here, but it's the same as
+        # the parser's default prefix so it's a good test
+        parser = ErrorRaisingArgumentParser()
+        msg = (
+            "The use of the undocumented 'prefix_chars' parameter in "
+            "ArgumentParser.add_argument_group() is deprecated."
+        )
+        with self.assertWarns(DeprecationWarning) as cm:
+            parser.add_argument_group(prefix_chars='-')
+        self.assertEqual(msg, str(cm.warning))
+        self.assertEqual(cm.filename, __file__)
+
+    def test_nested_argument_group(self):
+        parser = argparse.ArgumentParser()
+        g = parser.add_argument_group()
+        self.assertRaisesRegex(ValueError,
+                                 'argument groups cannot be nested',
+                                 g.add_argument_group)
+
 # ===================
 # Parent parser tests
 # ===================
 
+@force_not_colorized_test_class
 class TestParentParsers(TestCase):
     """Tests that parsers can be created with parent parsers"""
 
@@ -2832,8 +3049,6 @@ def setUp(self):
         group.add_argument('-a', action='store_true')
         group.add_argument('-b', action='store_true')
 
-        self.main_program = os.path.basename(sys.argv[0])
-
     def test_single_parent(self):
         parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])
         self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),
@@ -2844,7 +3059,7 @@ def test_single_parent_mutex(self):
         parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])
         self._test_mutex_ab(parser.parse_args)
 
-    def test_single_granparent_mutex(self):
+    def test_single_grandparent_mutex(self):
         parents = [self.ab_mutex_parent]
         parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)
         parser = ErrorRaisingArgumentParser(parents=[parser])
@@ -2923,11 +3138,10 @@ def test_subparser_parents_mutex(self):
 
     def test_parent_help(self):
         parents = [self.abcd_parent, self.wxyz_parent]
-        parser = ErrorRaisingArgumentParser(parents=parents)
+        parser = ErrorRaisingArgumentParser(prog='PROG', parents=parents)
         parser_help = parser.format_help()
-        progname = self.main_program
         self.assertEqual(parser_help, textwrap.dedent('''\
-            usage: {}{}[-h] [-b B] [--d D] [--w W] [-y Y] a z
+            usage: PROG [-h] [-b B] [--d D] [--w W] [-y Y] a z
 
             positional arguments:
               a
@@ -2943,7 +3157,7 @@ def test_parent_help(self):
 
             x:
               -y Y
-        '''.format(progname, ' ' if progname else '' )))
+        '''))
 
     def test_groups_parents(self):
         parent = ErrorRaisingArgumentParser(add_help=False)
@@ -2953,15 +3167,14 @@ def test_groups_parents(self):
         m = parent.add_mutually_exclusive_group()
         m.add_argument('-y')
         m.add_argument('-z')
-        parser = ErrorRaisingArgumentParser(parents=[parent])
+        parser = ErrorRaisingArgumentParser(prog='PROG', parents=[parent])
 
         self.assertRaises(ArgumentParserError, parser.parse_args,
             ['-y', 'Y', '-z', 'Z'])
 
         parser_help = parser.format_help()
-        progname = self.main_program
         self.assertEqual(parser_help, textwrap.dedent('''\
-            usage: {}{}[-h] [-w W] [-x X] [-y Y | -z Z]
+            usage: PROG [-h] [-w W] [-x X] [-y Y | -z Z]
 
             options:
               -h, --help  show this help message and exit
@@ -2973,7 +3186,7 @@ def test_groups_parents(self):
 
               -w W
               -x X
-        '''.format(progname, ' ' if progname else '' )))
+        '''))
 
     def test_wrong_type_parents(self):
         self.assertRaises(TypeError, ErrorRaisingArgumentParser, parents=[1])
@@ -3011,6 +3224,7 @@ def test_mutex_groups_parents(self):
 # Mutually exclusive group tests
 # ==============================
 
+@force_not_colorized_test_class
 class TestMutuallyExclusiveGroupErrors(TestCase):
 
     def test_invalid_add_argument_group(self):
@@ -3049,6 +3263,29 @@ def test_help(self):
               '''
         self.assertEqual(parser.format_help(), textwrap.dedent(expected))
 
+    def test_optional_order(self):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('--foo')
+        group.add_argument('bar', nargs='?')
+        expected = '''\
+            usage: PROG [-h] (--foo FOO | bar)
+
+            positional arguments:
+              bar
+
+            options:
+              -h, --help  show this help message and exit
+              --foo FOO
+              '''
+        self.assertEqual(parser.format_help(), textwrap.dedent(expected))
+
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('bar', nargs='?')
+        group.add_argument('--foo')
+        self.assertEqual(parser.format_help(), textwrap.dedent(expected))
+
     def test_help_subparser_all_mutually_exclusive_group_members_suppressed(self):
         self.maxDiff = None
         parser = ErrorRaisingArgumentParser(prog='PROG')
@@ -3077,6 +3314,14 @@ def test_empty_group(self):
         with self.assertRaises(ValueError):
             parser.parse_args(['-h'])
 
+    def test_nested_mutex_groups(self):
+        parser = argparse.ArgumentParser(prog='PROG')
+        g = parser.add_mutually_exclusive_group()
+        g.add_argument("--spam")
+        self.assertRaisesRegex(ValueError,
+                               'mutually exclusive groups cannot be nested',
+                               g.add_mutually_exclusive_group)
+
 class MEMixin(object):
 
     def test_failures_when_not_required(self):
@@ -3108,21 +3353,25 @@ def test_successes_when_required(self):
                 actual_ns = parse_args(args_string.split())
                 self.assertEqual(actual_ns, expected_ns)
 
+    @force_not_colorized
     def test_usage_when_not_required(self):
         format_usage = self.get_parser(required=False).format_usage
         expected_usage = self.usage_when_not_required
         self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
 
+    @force_not_colorized
     def test_usage_when_required(self):
         format_usage = self.get_parser(required=True).format_usage
         expected_usage = self.usage_when_required
         self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
 
+    @force_not_colorized
     def test_help_when_not_required(self):
         format_help = self.get_parser(required=False).format_help
         help = self.usage_when_not_required + self.help
         self.assertEqual(format_help(), textwrap.dedent(help))
 
+    @force_not_colorized
     def test_help_when_required(self):
         format_help = self.get_parser(required=True).format_help
         help = self.usage_when_required + self.help
@@ -3444,55 +3693,6 @@ def get_parser(self, required):
           -c          c help
         '''
 
-class TestMutuallyExclusiveNested(MEMixin, TestCase):
-
-    # Nesting mutually exclusive groups is an undocumented feature
-    # that came about by accident through inheritance and has been
-    # the source of many bugs. It is deprecated and this test should
-    # eventually be removed along with it.
-
-    def get_parser(self, required):
-        parser = ErrorRaisingArgumentParser(prog='PROG')
-        group = parser.add_mutually_exclusive_group(required=required)
-        group.add_argument('-a')
-        group.add_argument('-b')
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore', DeprecationWarning)
-            group2 = group.add_mutually_exclusive_group(required=required)
-        group2.add_argument('-c')
-        group2.add_argument('-d')
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore', DeprecationWarning)
-            group3 = group2.add_mutually_exclusive_group(required=required)
-        group3.add_argument('-e')
-        group3.add_argument('-f')
-        return parser
-
-    usage_when_not_required = '''\
-        usage: PROG [-h] [-a A | -b B | [-c C | -d D | [-e E | -f F]]]
-        '''
-    usage_when_required = '''\
-        usage: PROG [-h] (-a A | -b B | (-c C | -d D | (-e E | -f F)))
-        '''
-
-    help = '''\
-
-        options:
-          -h, --help  show this help message and exit
-          -a A
-          -b B
-          -c C
-          -d D
-          -e E
-          -f F
-        '''
-
-    # We are only interested in testing the behavior of format_usage().
-    test_failures_when_not_required = None
-    test_failures_when_required = None
-    test_successes_when_not_required = None
-    test_successes_when_required = None
-
 
 class TestMutuallyExclusiveOptionalOptional(MEMixin, TestCase):
     def get_parser(self, required=None):
@@ -3843,11 +4043,13 @@ def _test(self, tester, parser_text):
                 tester.maxDiff = None
                 tester.assertEqual(expected_text, parser_text)
 
+            @force_not_colorized
             def test_format(self, tester):
                 parser = self._get_parser(tester)
                 format = getattr(parser, 'format_%s' % self.func_suffix)
                 self._test(tester, format())
 
+            @force_not_colorized
             def test_print(self, tester):
                 parser = self._get_parser(tester)
                 print_ = getattr(parser, 'print_%s' % self.func_suffix)
@@ -3860,6 +4062,7 @@ def test_print(self, tester):
                     setattr(sys, self.std_name, old_stream)
                 self._test(tester, parser_text)
 
+            @force_not_colorized
             def test_print_file(self, tester):
                 parser = self._get_parser(tester)
                 print_ = getattr(parser, 'print_%s' % self.func_suffix)
@@ -4601,6 +4804,7 @@ class TestHelpUsageMetavarsSpacesParentheses(HelpTestCase):
     version = ''
 
 
+@force_not_colorized_test_class
 class TestHelpUsageNoWhitespaceCrash(TestCase):
 
     def test_all_suppressed_mutex_followed_by_long_arg(self):
@@ -4663,25 +4867,6 @@ def test_all_suppressed_mutex_with_optional_nargs(self):
         usage = 'usage: PROG [-h]\n'
         self.assertEqual(parser.format_usage(), usage)
 
-    def test_nested_mutex_groups(self):
-        parser = argparse.ArgumentParser(prog='PROG')
-        g = parser.add_mutually_exclusive_group()
-        g.add_argument("--spam")
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore', DeprecationWarning)
-            gg = g.add_mutually_exclusive_group()
-        gg.add_argument("--hax")
-        gg.add_argument("--hox", help=argparse.SUPPRESS)
-        gg.add_argument("--hex")
-        g.add_argument("--eggs")
-        parser.add_argument("--num")
-
-        usage = textwrap.dedent('''\
-        usage: PROG [-h] [--spam SPAM | [--hax HAX | --hex HEX] | --eggs EGGS]
-                    [--num NUM]
-        ''')
-        self.assertEqual(parser.format_usage(), usage)
-
     def test_long_mutex_groups_wrap(self):
         parser = argparse.ArgumentParser(prog='PROG')
         g = parser.add_mutually_exclusive_group()
@@ -5301,11 +5486,61 @@ def custom_type(string):
     version = ''
 
 
-class TestHelpUsageLongSubparserCommand(TestCase):
-    """Test that subparser commands are formatted correctly in help"""
+@force_not_colorized_test_class
+class TestHelpCustomHelpFormatter(TestCase):
     maxDiff = None
 
-    def test_parent_help(self):
+    def test_custom_formatter_function(self):
+        def custom_formatter(prog):
+            return argparse.RawTextHelpFormatter(prog, indent_increment=5)
+
+        parser = argparse.ArgumentParser(
+                prog='PROG',
+                prefix_chars='-+',
+                formatter_class=custom_formatter
+        )
+        parser.add_argument('+f', '++foo', help="foo help")
+        parser.add_argument('spam', help="spam help")
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: PROG [-h] [+f FOO] spam
+
+            positional arguments:
+                 spam           spam help
+
+            options:
+                 -h, --help     show this help message and exit
+                 +f, ++foo FOO  foo help
+        '''))
+
+    def test_custom_formatter_class(self):
+        class CustomFormatter(argparse.RawTextHelpFormatter):
+            def __init__(self, prog):
+                super().__init__(prog, indent_increment=5)
+
+        parser = argparse.ArgumentParser(
+                prog='PROG',
+                prefix_chars='-+',
+                formatter_class=CustomFormatter
+        )
+        parser.add_argument('+f', '++foo', help="foo help")
+        parser.add_argument('spam', help="spam help")
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: PROG [-h] [+f FOO] spam
+
+            positional arguments:
+                 spam           spam help
+
+            options:
+                 -h, --help     show this help message and exit
+                 +f, ++foo FOO  foo help
+        '''))
+
+    def test_usage_long_subparser_command(self):
+        """Test that subparser commands are formatted correctly in help"""
         def custom_formatter(prog):
             return argparse.RawTextHelpFormatter(prog, max_help_position=50)
 
@@ -5371,29 +5606,45 @@ def test_missing_destination(self):
                 self.assertTypeError(action=action)
 
     def test_invalid_option_strings(self):
-        self.assertValueError('--')
-        self.assertValueError('---')
+        self.assertTypeError('-', errmsg='dest= is required')
+        self.assertTypeError('--', errmsg='dest= is required')
+        self.assertTypeError('---', errmsg='dest= is required')
 
     def test_invalid_prefix(self):
-        self.assertValueError('--foo', '+foo')
+        self.assertValueError('--foo', '+foo',
+                              errmsg='must start with a character')
 
     def test_invalid_type(self):
-        self.assertValueError('--foo', type='int')
-        self.assertValueError('--foo', type=(int, float))
+        self.assertTypeError('--foo', type='int',
+                             errmsg="'int' is not callable")
+        self.assertTypeError('--foo', type=(int, float),
+                             errmsg='is not callable')
 
     def test_invalid_action(self):
-        self.assertValueError('-x', action='foo')
-        self.assertValueError('foo', action='baz')
-        self.assertValueError('--foo', action=('store', 'append'))
+        self.assertValueError('-x', action='foo',
+                              errmsg='unknown action')
+        self.assertValueError('foo', action='baz',
+                              errmsg='unknown action')
+        self.assertValueError('--foo', action=('store', 'append'),
+                              errmsg='unknown action')
         self.assertValueError('--foo', action="store-true",
                               errmsg='unknown action')
 
+    def test_invalid_help(self):
+        self.assertValueError('--foo', help='%Y-%m-%d',
+                              errmsg='badly formed help string')
+        self.assertValueError('--foo', help='%(spam)s',
+                              errmsg='badly formed help string')
+        self.assertValueError('--foo', help='%(prog)d',
+                              errmsg='badly formed help string')
+
     def test_multiple_dest(self):
         parser = argparse.ArgumentParser()
         parser.add_argument(dest='foo')
-        with self.assertRaises(ValueError) as cm:
+        with self.assertRaises(TypeError) as cm:
             parser.add_argument('bar', dest='baz')
-        self.assertIn('dest supplied twice for positional argument',
+        self.assertIn('dest supplied twice for positional argument,'
+                      ' did you mean metavar?',
                       str(cm.exception))
 
     def test_no_argument_actions(self):
@@ -5405,8 +5656,11 @@ def test_no_argument_actions(self):
                     with self.subTest(attrs=attrs):
                         self.assertTypeError('-x', action=action, **attrs)
                         self.assertTypeError('x', action=action, **attrs)
+                self.assertValueError('x', action=action,
+                    errmsg=f"action '{action}' is not valid for positional arguments")
                 self.assertTypeError('-x', action=action, nargs=0)
-                self.assertTypeError('x', action=action, nargs=0)
+                self.assertValueError('x', action=action, nargs=0,
+                    errmsg='nargs for positionals must be != 0')
 
     def test_no_argument_no_const_actions(self):
         # options with zero arguments
@@ -5426,7 +5680,7 @@ def test_more_than_one_argument_actions(self):
                 self.assertValueError('-x', nargs=0, action=action,
                     errmsg=f'nargs for {action_name} actions must be != 0')
                 self.assertValueError('spam', nargs=0, action=action,
-                    errmsg=f'nargs for {action_name} actions must be != 0')
+                    errmsg='nargs for positionals must be != 0')
 
                 # const is disallowed with non-optional arguments
                 for nargs in [1, '*', '+']:
@@ -5529,6 +5783,7 @@ def test_conflict_error(self):
         self.assertRaises(argparse.ArgumentError,
                           parser.add_argument, '--spam')
 
+    @force_not_colorized
     def test_resolve_error(self):
         get_parser = argparse.ArgumentParser
         parser = get_parser(prog='PROG', conflict_handler='resolve')
@@ -5558,20 +5813,25 @@ def test_subparser_conflict(self):
         parser = argparse.ArgumentParser()
         sp = parser.add_subparsers()
         sp.add_parser('fullname', aliases=['alias'])
-        self.assertRaises(argparse.ArgumentError,
-                          sp.add_parser, 'fullname')
-        self.assertRaises(argparse.ArgumentError,
-                          sp.add_parser, 'alias')
-        self.assertRaises(argparse.ArgumentError,
-                          sp.add_parser, 'other', aliases=['fullname'])
-        self.assertRaises(argparse.ArgumentError,
-                          sp.add_parser, 'other', aliases=['alias'])
+        self.assertRaisesRegex(ValueError,
+                               'conflicting subparser: fullname',
+                               sp.add_parser, 'fullname')
+        self.assertRaisesRegex(ValueError,
+                               'conflicting subparser: alias',
+                               sp.add_parser, 'alias')
+        self.assertRaisesRegex(ValueError,
+                               'conflicting subparser alias: fullname',
+                               sp.add_parser, 'other', aliases=['fullname'])
+        self.assertRaisesRegex(ValueError,
+                               'conflicting subparser alias: alias',
+                               sp.add_parser, 'other', aliases=['alias'])
 
 
 # =============================
 # Help and Version option tests
 # =============================
 
+@force_not_colorized_test_class
 class TestOptionalsHelpVersionActions(TestCase):
     """Test the help and version actions"""
 
@@ -5791,6 +6051,7 @@ def test_argument_error(self):
 
 class TestArgumentTypeError(TestCase):
 
+    @force_not_colorized
     def test_argument_type_error(self):
 
         def spam(string):
@@ -6563,9 +6824,10 @@ def test_nargs_zero(self):
 
 class TestImportStar(TestCase):
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test(self):
         for name in argparse.__all__:
-            self.assertTrue(hasattr(argparse, name))
+            self.assertHasAttr(argparse, name)
 
     def test_all_exports_everything_but_modules(self):
         items = [
@@ -6589,6 +6851,7 @@ def setUp(self):
         metavar = '<http[s]://example:1234>'
         self.parser.add_argument('--proxy', metavar=metavar)
 
+    @force_not_colorized
     def test_help_with_metavar(self):
         help_text = self.parser.format_help()
         self.assertEqual(help_text, textwrap.dedent('''\
@@ -6754,6 +7017,99 @@ def test_os_error(self):
                                self.parser.parse_args, ['@no-such-file'])
 
 
+@force_not_colorized_test_class
+class TestProgName(TestCase):
+    source = textwrap.dedent('''\
+        import argparse
+        parser = argparse.ArgumentParser()
+        parser.parse_args()
+    ''')
+
+    def setUp(self):
+        self.dirname = 'package' + os_helper.FS_NONASCII
+        self.addCleanup(os_helper.rmtree, self.dirname)
+        os.mkdir(self.dirname)
+
+    def make_script(self, dirname, basename, *, compiled=False):
+        script_name = script_helper.make_script(dirname, basename, self.source)
+        if not compiled:
+            return script_name
+        py_compile.compile(script_name, doraise=True)
+        os.remove(script_name)
+        pyc_file = import_helper.make_legacy_pyc(script_name)
+        return pyc_file
+
+    def make_zip_script(self, script_name, name_in_zip=None):
+        zip_name, _ = script_helper.make_zip_script(self.dirname, 'test_zip',
+                                                    script_name, name_in_zip)
+        return zip_name
+
+    def check_usage(self, expected, *args, **kwargs):
+        res = script_helper.assert_python_ok('-Xutf8', *args, '-h', **kwargs)
+        self.assertEqual(os.fsdecode(res.out.splitlines()[0]),
+                         f'usage: {expected} [-h]')
+
+    def test_script(self, compiled=False):
+        basename = os_helper.TESTFN
+        script_name = self.make_script(self.dirname, basename, compiled=compiled)
+        self.check_usage(os.path.basename(script_name), script_name, '-h')
+
+    def test_script_compiled(self):
+        self.test_script(compiled=True)
+
+    def test_directory(self, compiled=False):
+        dirname = os.path.join(self.dirname, os_helper.TESTFN)
+        os.mkdir(dirname)
+        self.make_script(dirname, '__main__', compiled=compiled)
+        self.check_usage(f'{py} {dirname}', dirname)
+        dirname2 = os.path.join(os.curdir, dirname)
+        self.check_usage(f'{py} {dirname2}', dirname2)
+
+    def test_directory_compiled(self):
+        self.test_directory(compiled=True)
+
+    def test_module(self, compiled=False):
+        basename = 'module' + os_helper.FS_NONASCII
+        modulename = f'{self.dirname}.{basename}'
+        self.make_script(self.dirname, basename, compiled=compiled)
+        self.check_usage(f'{py} -m {modulename}',
+                         '-m', modulename, PYTHONPATH=os.curdir)
+
+    def test_module_compiled(self):
+        self.test_module(compiled=True)
+
+    def test_package(self, compiled=False):
+        basename = 'subpackage' + os_helper.FS_NONASCII
+        packagename = f'{self.dirname}.{basename}'
+        subdirname = os.path.join(self.dirname, basename)
+        os.mkdir(subdirname)
+        self.make_script(subdirname, '__main__', compiled=compiled)
+        self.check_usage(f'{py} -m {packagename}',
+                         '-m', packagename, PYTHONPATH=os.curdir)
+        self.check_usage(f'{py} -m {packagename}',
+                         '-m', packagename + '.__main__', PYTHONPATH=os.curdir)
+
+    def test_package_compiled(self):
+        self.test_package(compiled=True)
+
+    def test_zipfile(self, compiled=False):
+        script_name = self.make_script(self.dirname, '__main__', compiled=compiled)
+        zip_name = self.make_zip_script(script_name)
+        self.check_usage(f'{py} {zip_name}', zip_name)
+
+    def test_zipfile_compiled(self):
+        self.test_zipfile(compiled=True)
+
+    def test_directory_in_zipfile(self, compiled=False):
+        script_name = self.make_script(self.dirname, '__main__', compiled=compiled)
+        name_in_zip = 'package/subpackage/__main__' + ('.py', '.pyc')[compiled]
+        zip_name = self.make_zip_script(script_name, name_in_zip)
+        dirname = os.path.join(zip_name, 'package', 'subpackage')
+        self.check_usage(f'{py} {dirname}', dirname)
+
+    def test_directory_in_zipfile_compiled(self):
+        self.test_directory_in_zipfile(compiled=True)
+
 # =================
 # Translation tests
 # =================
@@ -6764,6 +7120,257 @@ def test_translations(self):
         self.assertMsgidsEqual(argparse)
 
 
+# ===========
+# Color tests
+# ===========
+
+
+class TestColorized(TestCase):
+    maxDiff = None
+
+    def setUp(self):
+        super().setUp()
+        # Ensure color even if ran with NO_COLOR=1
+        self.enterContext(swap_attr(_colorize, 'can_colorize',
+                                     lambda *args, **kwargs: True))
+        self.theme = _colorize.get_theme(force_color=True).argparse
+
+    def test_argparse_color(self):
+        # Arrange: create a parser with a bit of everything
+        parser = argparse.ArgumentParser(
+            color=True,
+            description="Colorful help",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+            prefix_chars="-+",
+            prog="PROG",
+        )
+        group = parser.add_mutually_exclusive_group()
+        group.add_argument(
+            "-v", "--verbose", action="store_true", help="more spam"
+        )
+        group.add_argument(
+            "-q", "--quiet", action="store_true", help="less spam"
+        )
+        parser.add_argument("x", type=int, help="the base")
+        parser.add_argument(
+            "y", type=int, help="the exponent", deprecated=True
+        )
+        parser.add_argument(
+            "this_indeed_is_a_very_long_action_name",
+            type=int,
+            help="the exponent",
+        )
+        parser.add_argument(
+            "-o", "--optional1", action="store_true", deprecated=True
+        )
+        parser.add_argument("--optional2", help="pick one")
+        parser.add_argument("--optional3", choices=("X", "Y", "Z"))
+        parser.add_argument(
+            "--optional4", choices=("X", "Y", "Z"), help="pick one"
+        )
+        parser.add_argument(
+            "--optional5", choices=("X", "Y", "Z"), help="pick one"
+        )
+        parser.add_argument(
+            "--optional6", choices=("X", "Y", "Z"), help="pick one"
+        )
+        parser.add_argument(
+            "-p",
+            "--optional7",
+            choices=("Aaaaa", "Bbbbb", "Ccccc", "Ddddd"),
+            help="pick one",
+        )
+
+        parser.add_argument("+f")
+        parser.add_argument("++bar")
+        parser.add_argument("-+baz")
+        parser.add_argument("-c", "--count")
+
+        subparsers = parser.add_subparsers(
+            title="subcommands",
+            description="valid subcommands",
+            help="additional help",
+        )
+        subparsers.add_parser("sub1", deprecated=True, help="sub1 help")
+        sub2 = subparsers.add_parser("sub2", deprecated=True, help="sub2 help")
+        sub2.add_argument("--baz", choices=("X", "Y", "Z"), help="baz help")
+
+        prog = self.theme.prog
+        heading = self.theme.heading
+        long = self.theme.summary_long_option
+        short = self.theme.summary_short_option
+        label = self.theme.summary_label
+        pos = self.theme.summary_action
+        long_b = self.theme.long_option
+        short_b = self.theme.short_option
+        label_b = self.theme.label
+        pos_b = self.theme.action
+        reset = self.theme.reset
+
+        # Act
+        help_text = parser.format_help()
+
+        # Assert
+        self.assertEqual(
+            help_text,
+            textwrap.dedent(
+                f"""\
+                {heading}usage: {reset}{prog}PROG{reset} [{short}-h{reset}] [{short}-v{reset} | {short}-q{reset}] [{short}-o{reset}] [{long}--optional2 {label}OPTIONAL2{reset}] [{long}--optional3 {label}{{X,Y,Z}}{reset}]
+                            [{long}--optional4 {label}{{X,Y,Z}}{reset}] [{long}--optional5 {label}{{X,Y,Z}}{reset}] [{long}--optional6 {label}{{X,Y,Z}}{reset}]
+                            [{short}-p {label}{{Aaaaa,Bbbbb,Ccccc,Ddddd}}{reset}] [{short}+f {label}F{reset}] [{long}++bar {label}BAR{reset}] [{long}-+baz {label}BAZ{reset}]
+                            [{short}-c {label}COUNT{reset}]
+                            {pos}x{reset} {pos}y{reset} {pos}this_indeed_is_a_very_long_action_name{reset} {pos}{{sub1,sub2}} ...{reset}
+
+                Colorful help
+
+                {heading}positional arguments:{reset}
+                  {pos_b}x{reset}                     the base
+                  {pos_b}y{reset}                     the exponent
+                  {pos_b}this_indeed_is_a_very_long_action_name{reset}
+                                        the exponent
+
+                {heading}options:{reset}
+                  {short_b}-h{reset}, {long_b}--help{reset}            show this help message and exit
+                  {short_b}-v{reset}, {long_b}--verbose{reset}         more spam (default: False)
+                  {short_b}-q{reset}, {long_b}--quiet{reset}           less spam (default: False)
+                  {short_b}-o{reset}, {long_b}--optional1{reset}
+                  {long_b}--optional2{reset} {label_b}OPTIONAL2{reset}
+                                        pick one (default: None)
+                  {long_b}--optional3{reset} {label_b}{{X,Y,Z}}{reset}
+                  {long_b}--optional4{reset} {label_b}{{X,Y,Z}}{reset}   pick one (default: None)
+                  {long_b}--optional5{reset} {label_b}{{X,Y,Z}}{reset}   pick one (default: None)
+                  {long_b}--optional6{reset} {label_b}{{X,Y,Z}}{reset}   pick one (default: None)
+                  {short_b}-p{reset}, {long_b}--optional7{reset} {label_b}{{Aaaaa,Bbbbb,Ccccc,Ddddd}}{reset}
+                                        pick one (default: None)
+                  {short_b}+f{reset} {label_b}F{reset}
+                  {long_b}++bar{reset} {label_b}BAR{reset}
+                  {long_b}-+baz{reset} {label_b}BAZ{reset}
+                  {short_b}-c{reset}, {long_b}--count{reset} {label_b}COUNT{reset}
+
+                {heading}subcommands:{reset}
+                  valid subcommands
+
+                  {pos_b}{{sub1,sub2}}{reset}           additional help
+                    {pos_b}sub1{reset}                sub1 help
+                    {pos_b}sub2{reset}                sub2 help
+                """
+            ),
+        )
+
+    def test_argparse_color_usage(self):
+        # Arrange
+        parser = argparse.ArgumentParser(
+            add_help=False,
+            color=True,
+            description="Test prog and usage colors",
+            prog="PROG",
+            usage="[prefix] %(prog)s [suffix]",
+        )
+        heading = self.theme.heading
+        prog = self.theme.prog
+        reset = self.theme.reset
+        usage = self.theme.prog_extra
+
+        # Act
+        help_text = parser.format_help()
+
+        # Assert
+        self.assertEqual(
+            help_text,
+            textwrap.dedent(
+                f"""\
+                {heading}usage: {reset}{usage}[prefix] {prog}PROG{reset}{usage} [suffix]{reset}
+
+                Test prog and usage colors
+                """
+            ),
+        )
+
+    def test_custom_formatter_function(self):
+        def custom_formatter(prog):
+            return argparse.RawTextHelpFormatter(prog, indent_increment=5)
+
+        parser = argparse.ArgumentParser(
+            prog="PROG",
+            prefix_chars="-+",
+            formatter_class=custom_formatter,
+            color=True,
+        )
+        parser.add_argument('+f', '++foo', help="foo help")
+        parser.add_argument('spam', help="spam help")
+
+        prog = self.theme.prog
+        heading = self.theme.heading
+        short = self.theme.summary_short_option
+        label = self.theme.summary_label
+        pos = self.theme.summary_action
+        long_b = self.theme.long_option
+        short_b = self.theme.short_option
+        label_b = self.theme.label
+        pos_b = self.theme.action
+        reset = self.theme.reset
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent(f'''\
+            {heading}usage: {reset}{prog}PROG{reset} [{short}-h{reset}] [{short}+f {label}FOO{reset}] {pos}spam{reset}
+
+            {heading}positional arguments:{reset}
+                 {pos_b}spam{reset}           spam help
+
+            {heading}options:{reset}
+                 {short_b}-h{reset}, {long_b}--help{reset}     show this help message and exit
+                 {short_b}+f{reset}, {long_b}++foo{reset} {label_b}FOO{reset}  foo help
+        '''))
+
+    def test_custom_formatter_class(self):
+        class CustomFormatter(argparse.RawTextHelpFormatter):
+            def __init__(self, prog):
+                super().__init__(prog, indent_increment=5)
+
+        parser = argparse.ArgumentParser(
+            prog="PROG",
+            prefix_chars="-+",
+            formatter_class=CustomFormatter,
+            color=True,
+        )
+        parser.add_argument('+f', '++foo', help="foo help")
+        parser.add_argument('spam', help="spam help")
+
+        prog = self.theme.prog
+        heading = self.theme.heading
+        short = self.theme.summary_short_option
+        label = self.theme.summary_label
+        pos = self.theme.summary_action
+        long_b = self.theme.long_option
+        short_b = self.theme.short_option
+        label_b = self.theme.label
+        pos_b = self.theme.action
+        reset = self.theme.reset
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent(f'''\
+            {heading}usage: {reset}{prog}PROG{reset} [{short}-h{reset}] [{short}+f {label}FOO{reset}] {pos}spam{reset}
+
+            {heading}positional arguments:{reset}
+                 {pos_b}spam{reset}           spam help
+
+            {heading}options:{reset}
+                 {short_b}-h{reset}, {long_b}--help{reset}     show this help message and exit
+                 {short_b}+f{reset}, {long_b}++foo{reset} {label_b}FOO{reset}  foo help
+        '''))
+
+    def test_subparser_prog_is_stored_without_color(self):
+        parser = argparse.ArgumentParser(prog='complex', color=True)
+        sub = parser.add_subparsers(dest='command')
+        demo_parser = sub.add_parser('demo')
+
+        self.assertNotIn('\x1b[', demo_parser.prog)
+
+        demo_parser.color = False
+        help_text = demo_parser.format_help()
+        self.assertNotIn('\x1b[', help_text)
+
+
 def tearDownModule():
     # Remove global references to avoid looking like we have refleaks.
     RFile.seen = {}

From 314a61562c69bb3ca9f76ebf12699c696b9e4b6e Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Fri, 16 Jan 2026 21:13:34 +0900
Subject: [PATCH 335/418] Update calendar from CPython 3.14.2

---
 Lib/calendar.py           | 125 ++++++++++++++++++++++++++++++++++++--
 Lib/test/test_calendar.py |   6 +-
 2 files changed, 123 insertions(+), 8 deletions(-)

diff --git a/Lib/calendar.py b/Lib/calendar.py
index 8c1c646da46..18f76d52ff8 100644
--- a/Lib/calendar.py
+++ b/Lib/calendar.py
@@ -428,6 +428,7 @@ def formatyear(self, theyear, w=2, l=1, c=6, m=3):
             headers = (header for k in months)
             a(formatstring(headers, colwidth, c).rstrip())
             a('\n'*l)
+
             # max number of weeks for this row
             height = max(len(cal) for cal in row)
             for j in range(height):
@@ -646,6 +647,117 @@ def formatmonthname(self, theyear, themonth, withyear=True):
         with different_locale(self.locale):
             return super().formatmonthname(theyear, themonth, withyear)
 
+
+class _CLIDemoCalendar(TextCalendar):
+    def __init__(self, highlight_day=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.highlight_day = highlight_day
+
+    def formatweek(self, theweek, width, *, highlight_day=None):
+        """
+        Returns a single week in a string (no newline).
+        """
+        if highlight_day:
+            from _colorize import get_colors
+
+            ansi = get_colors()
+            highlight = f"{ansi.BLACK}{ansi.BACKGROUND_YELLOW}"
+            reset = ansi.RESET
+        else:
+            highlight = reset = ""
+
+        return ' '.join(
+            (
+                f"{highlight}{self.formatday(d, wd, width)}{reset}"
+                if d == highlight_day
+                else self.formatday(d, wd, width)
+            )
+            for (d, wd) in theweek
+        )
+
+    def formatmonth(self, theyear, themonth, w=0, l=0):
+        """
+        Return a month's calendar string (multi-line).
+        """
+        if (
+            self.highlight_day
+            and self.highlight_day.year == theyear
+            and self.highlight_day.month == themonth
+        ):
+            highlight_day = self.highlight_day.day
+        else:
+            highlight_day = None
+        w = max(2, w)
+        l = max(1, l)
+        s = self.formatmonthname(theyear, themonth, 7 * (w + 1) - 1)
+        s = s.rstrip()
+        s += '\n' * l
+        s += self.formatweekheader(w).rstrip()
+        s += '\n' * l
+        for week in self.monthdays2calendar(theyear, themonth):
+            s += self.formatweek(week, w, highlight_day=highlight_day).rstrip()
+            s += '\n' * l
+        return s
+
+    def formatyear(self, theyear, w=2, l=1, c=6, m=3):
+        """
+        Returns a year's calendar as a multi-line string.
+        """
+        w = max(2, w)
+        l = max(1, l)
+        c = max(2, c)
+        colwidth = (w + 1) * 7 - 1
+        v = []
+        a = v.append
+        a(repr(theyear).center(colwidth*m+c*(m-1)).rstrip())
+        a('\n'*l)
+        header = self.formatweekheader(w)
+        for (i, row) in enumerate(self.yeardays2calendar(theyear, m)):
+            # months in this row
+            months = range(m*i+1, min(m*(i+1)+1, 13))
+            a('\n'*l)
+            names = (self.formatmonthname(theyear, k, colwidth, False)
+                     for k in months)
+            a(formatstring(names, colwidth, c).rstrip())
+            a('\n'*l)
+            headers = (header for k in months)
+            a(formatstring(headers, colwidth, c).rstrip())
+            a('\n'*l)
+
+            if (
+                self.highlight_day
+                and self.highlight_day.year == theyear
+                and self.highlight_day.month in months
+            ):
+                month_pos = months.index(self.highlight_day.month)
+            else:
+                month_pos = None
+
+            # max number of weeks for this row
+            height = max(len(cal) for cal in row)
+            for j in range(height):
+                weeks = []
+                for k, cal in enumerate(row):
+                    if j >= len(cal):
+                        weeks.append('')
+                    else:
+                        day = (
+                            self.highlight_day.day if k == month_pos else None
+                        )
+                        weeks.append(
+                            self.formatweek(cal[j], w, highlight_day=day)
+                        )
+                a(formatstring(weeks, colwidth, c).rstrip())
+                a('\n' * l)
+        return ''.join(v)
+
+
+class _CLIDemoLocaleCalendar(LocaleTextCalendar, _CLIDemoCalendar):
+    def __init__(self, highlight_day=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.highlight_day = highlight_day
+
+
 # Support for old module level interface
 c = TextCalendar()
 
@@ -698,7 +810,7 @@ def timegm(tuple):
 
 def main(args=None):
     import argparse
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     textgroup = parser.add_argument_group('text only arguments')
     htmlgroup = parser.add_argument_group('html only arguments')
     textgroup.add_argument(
@@ -765,6 +877,7 @@ def main(args=None):
         sys.exit(1)
 
     locale = options.locale, options.encoding
+    today = datetime.date.today()
 
     if options.type == "html":
         if options.month:
@@ -781,23 +894,23 @@ def main(args=None):
         optdict = dict(encoding=encoding, css=options.css)
         write = sys.stdout.buffer.write
         if options.year is None:
-            write(cal.formatyearpage(datetime.date.today().year, **optdict))
+            write(cal.formatyearpage(today.year, **optdict))
         else:
             write(cal.formatyearpage(options.year, **optdict))
     else:
         if options.locale:
-            cal = LocaleTextCalendar(locale=locale)
+            cal = _CLIDemoLocaleCalendar(highlight_day=today, locale=locale)
         else:
-            cal = TextCalendar()
+            cal = _CLIDemoCalendar(highlight_day=today)
         cal.setfirstweekday(options.first_weekday)
         optdict = dict(w=options.width, l=options.lines)
         if options.month is None:
             optdict["c"] = options.spacing
             optdict["m"] = options.months
-        if options.month is not None:
+        else:
             _validate_month(options.month)
         if options.year is None:
-            result = cal.formatyear(datetime.date.today().year, **optdict)
+            result = cal.formatyear(today.year, **optdict)
         elif options.month is None:
             result = cal.formatyear(options.year, **optdict)
         else:
diff --git a/Lib/test/test_calendar.py b/Lib/test/test_calendar.py
index df102fe1986..35573fd9f01 100644
--- a/Lib/test/test_calendar.py
+++ b/Lib/test/test_calendar.py
@@ -987,10 +987,11 @@ def assertFailure(self, *args):
         self.assertCLIFails(*args)
         self.assertCmdFails(*args)
 
+    @support.force_not_colorized
     def test_help(self):
         stdout = self.run_cmd_ok('-h')
         self.assertIn(b'usage:', stdout)
-        self.assertIn(b'calendar.py', stdout)
+        self.assertIn(b' -m calendar ', stdout)
         self.assertIn(b'--help', stdout)
 
         # special case: stdout but sys.exit()
@@ -1089,6 +1090,7 @@ def test_option_months(self):
             output = run('--months', '1', '2004')
             self.assertIn(conv('\nMo Tu We Th Fr Sa Su\n'), output)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_option_type(self):
         self.assertFailure('-t')
         self.assertFailure('--type')
@@ -1097,7 +1099,7 @@ def test_option_type(self):
             output = run('--type', 'text', '2004')
             self.assertEqual(output, conv(result_2004_text))
             output = run('--type', 'html', '2004')
-            self.assertEqual(output[:6], b'<?xml ')
+            self.assertStartsWith(output, b'<?xml ')
             self.assertIn(b'<title>Calendar for 2004</title>', output)
 
     def test_html_output_current_year(self):

From 133bdf655e239f7ed89c36dfc6285f1c530bc745 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sat, 17 Jan 2026 19:21:45 +0900
Subject: [PATCH 336/418] auto_mark_test uses regex to check Run tests?
 sequentially

---
 scripts/auto_mark_test.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scripts/auto_mark_test.py b/scripts/auto_mark_test.py
index 78230954162..2e3aef52599 100644
--- a/scripts/auto_mark_test.py
+++ b/scripts/auto_mark_test.py
@@ -24,6 +24,7 @@
 
 import argparse
 import ast
+import re
 import shutil
 import sys
 from pathlib import Path
@@ -82,7 +83,7 @@ def parse_results(result):
     test_results.stdout = result.stdout
     in_test_results = False
     for line in lines:
-        if line == "Run tests sequentially":
+        if re.match(r"Run tests? sequentially", line):
             in_test_results = True
         elif line.startswith("-----------"):
             in_test_results = False

From faeed2cdcc8eb25f16f009e2ce4bc0f27cdb0bb7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sat, 17 Jan 2026 19:05:29 +0900
Subject: [PATCH 337/418] clean up

---
 crates/codegen/src/compile.rs      |  7 +--
 crates/vm/src/builtins/function.rs | 71 +++++++++++++++---------------
 crates/vm/src/vm/vm_new.rs         |  2 -
 3 files changed, 36 insertions(+), 44 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 2d3603c74ed..d479c0d0e69 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -1191,12 +1191,7 @@ impl Compiler {
 
         // Jump to body if format <= 2 (comparison is false)
         let body_block = self.new_block();
-        emit!(
-            self,
-            Instruction::PopJumpIfFalse {
-                target: body_block,
-            }
-        );
+        emit!(self, Instruction::PopJumpIfFalse { target: body_block });
 
         // Raise NotImplementedError
         let not_implemented_error = self.name("NotImplementedError");
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 55d9d046651..9297cf07201 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -605,12 +605,10 @@ impl PyFunction {
         // Check for callable __annotate__ and clone it before calling
         let annotate_fn = {
             let annotate = self.annotate.lock();
-            if let Some(ref func) = *annotate {
-                if func.is_callable() {
-                    Some(func.clone())
-                } else {
-                    None
-                }
+            if let Some(ref func) = *annotate
+                && func.is_callable()
+            {
+                Some(func.clone())
             } else {
                 None
             }
@@ -641,26 +639,24 @@ impl PyFunction {
     }
 
     #[pygetset(setter)]
-    fn set___annotations__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
-        match value {
-            PySetterValue::Assign(value) => {
-                if vm.is_none(&value) {
-                    *self.annotations.lock() = None;
-                } else {
-                    let annotations =
-                        value.downcast::<crate::builtins::PyDict>().map_err(|_| {
-                            vm.new_type_error("__annotations__ must be set to a dict object")
-                        })?;
-                    *self.annotations.lock() = Some(annotations);
-                }
-                // Clear __annotate__ when __annotations__ is set
-                *self.annotate.lock() = None;
-            }
-            PySetterValue::Delete => {
-                *self.annotations.lock() = None;
-                *self.annotate.lock() = None;
+    fn set___annotations__(
+        &self,
+        value: PySetterValue<Option<PyObjectRef>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let annotations = match value {
+            PySetterValue::Assign(Some(value)) => {
+                let annotations = value.downcast::<crate::builtins::PyDict>().map_err(|_| {
+                    vm.new_type_error("__annotations__ must be set to a dict object")
+                })?;
+                Some(annotations)
             }
-        }
+            PySetterValue::Assign(None) | PySetterValue::Delete => None,
+        };
+        *self.annotations.lock() = annotations;
+
+        // Clear __annotate__ when __annotations__ is set
+        *self.annotate.lock() = None;
         Ok(())
     }
 
@@ -673,23 +669,26 @@ impl PyFunction {
     }
 
     #[pygetset(setter)]
-    fn set___annotate__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
-        match value {
-            PySetterValue::Assign(value) => {
-                if vm.is_none(&value) {
-                    *self.annotate.lock() = Some(value);
-                } else if value.is_callable() {
-                    *self.annotate.lock() = Some(value);
-                    // Clear cached __annotations__ when __annotate__ is set
-                    *self.annotations.lock() = None;
-                } else {
+    fn set___annotate__(
+        &self,
+        value: PySetterValue<Option<PyObjectRef>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let annotate = match value {
+            PySetterValue::Assign(Some(value)) => {
+                if !value.is_callable() {
                     return Err(vm.new_type_error("__annotate__ must be callable or None"));
                 }
+                // Clear cached __annotations__ when __annotate__ is set
+                *self.annotations.lock() = None;
+                Some(value)
             }
+            PySetterValue::Assign(None) => None,
             PySetterValue::Delete => {
                 return Err(vm.new_type_error("__annotate__ cannot be deleted"));
             }
-        }
+        };
+        *self.annotate.lock() = annotate;
         Ok(())
     }
 
diff --git a/crates/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
index 517fa23aa32..8fc8108b6a3 100644
--- a/crates/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -65,8 +65,6 @@ impl VirtualMachine {
     pub fn new_scope_with_main(&self) -> PyResult<Scope> {
         let scope = self.new_scope_with_builtins();
         let main_module = self.new_module("__main__", scope.globals.clone(), None);
-        // PEP 649: Don't automatically initialize __annotations__
-        // It will be lazily created by the descriptor when accessed
 
         self.sys_module.get_attr("modules", self)?.set_item(
             "__main__",

From 60fb4384e15c15e0b19d92fb54e7db9b9f30a5d4 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Sat, 17 Jan 2026 10:34:53 +0000
Subject: [PATCH 338/418] Auto-format: ruff check --select I --fix

---
 extra_tests/snippets/stdlib_typing.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/extra_tests/snippets/stdlib_typing.py b/extra_tests/snippets/stdlib_typing.py
index 433d728c067..07348945842 100644
--- a/extra_tests/snippets/stdlib_typing.py
+++ b/extra_tests/snippets/stdlib_typing.py
@@ -18,7 +18,7 @@ def abort_signal_handler(
 # This tests that annotation scopes can access global implicit symbols (like Union)
 # that are imported at module level but not explicitly bound in the function scope.
 # Regression test for: rich
-from typing import Union, Optional
+from typing import Optional, Union
 
 
 def function_with_union_param(x: Optional[Union[int, str]] = None) -> None:

From c490a357fd54d578ae92681b8b1b4bae5006d843 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 21:52:53 +0900
Subject: [PATCH 339/418] relocate scripts (#6753)

---
 .github/copilot-instructions.md                    |  2 +-
 .github/workflows/ci.yaml                          |  2 +-
 .github/workflows/cron-ci.yaml                     |  4 ++--
 README.md                                          |  2 +-
 demo_closures.py                                   | 12 ------------
 crawl_sourcecode.py => scripts/crawl_sourcecode.py |  0
 whats_left.py => scripts/whats_left.py             |  4 ++--
 7 files changed, 7 insertions(+), 19 deletions(-)
 delete mode 100644 demo_closures.py
 rename crawl_sourcecode.py => scripts/crawl_sourcecode.py (100%)
 rename whats_left.py => scripts/whats_left.py (99%)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index a03de550681..35bffdd148f 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -106,7 +106,7 @@ cargo run --release -- -m test test_unicode -k test_unicode_escape
 
 ### Determining What to Implement
 
-Run `./whats_left.py` to get a list of unimplemented methods, which is helpful when looking for contribution opportunities.
+Run `./scripts/whats_left.py` to get a list of unimplemented methods, which is helpful when looking for contribution opportunities.
 
 ## Coding Guidelines
 
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 7fc4c653189..5b756e8af7e 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -412,7 +412,7 @@ jobs:
           target/release/rustpython -m venv testvenv
           testvenv/bin/rustpython -m pip install wheel
       - name: Check whats_left is not broken
-        run: python -I whats_left.py
+        run: python -I scripts/whats_left.py
 
   lint:
     name: Check Rust code with clippy
diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index 9d549602bc6..c942364064c 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -94,8 +94,8 @@ jobs:
         run: cargo build --release --verbose
       - name: Collect what is left data
         run: |
-          chmod +x ./whats_left.py
-          ./whats_left.py --features "ssl,sqlite" > whats_left.temp
+          chmod +x ./scripts/whats_left.py
+          ./scripts/whats_left.py --features "ssl,sqlite" > whats_left.temp
         env:
           RUSTPYTHONPATH: ${{ github.workspace }}/Lib
       - name: Upload data to the website
diff --git a/README.md b/README.md
index c4f7bfb1d60..6949c6e66e2 100644
--- a/README.md
+++ b/README.md
@@ -245,7 +245,7 @@ To enhance CPython compatibility, try to increase unittest coverage by checking
 Another approach is to checkout the source code: builtin functions and object
 methods are often the simplest and easiest way to contribute.
 
-You can also simply run `python -I whats_left.py` to assist in finding any unimplemented
+You can also simply run `python -I scripts/whats_left.py` to assist in finding any unimplemented
 method.
 
 ## Compiling to WebAssembly
diff --git a/demo_closures.py b/demo_closures.py
deleted file mode 100644
index 0ed673a94fd..00000000000
--- a/demo_closures.py
+++ /dev/null
@@ -1,12 +0,0 @@
-def foo(x):
-    def bar(z):
-        return z + x
-
-    return bar
-
-
-f = foo(9)
-g = foo(10)
-
-print(f(2))
-print(g(2))
diff --git a/crawl_sourcecode.py b/scripts/crawl_sourcecode.py
similarity index 100%
rename from crawl_sourcecode.py
rename to scripts/crawl_sourcecode.py
diff --git a/whats_left.py b/scripts/whats_left.py
similarity index 99%
rename from whats_left.py
rename to scripts/whats_left.py
index 99b840f9da7..f2019ba4eb1 100755
--- a/whats_left.py
+++ b/scripts/whats_left.py
@@ -29,7 +29,7 @@
 
 if not sys.flags.isolated:
     print("running without -I option.")
-    print("python -I whats_left.py")
+    print("python -I scripts/whats_left.py")
     exit(1)
 
 GENERATED_FILE = "extra_tests/not_impl.py"
@@ -39,7 +39,7 @@
     sys.exit(f"whats_left.py must be run under CPython, got {implementation} instead")
 if sys.version_info[:2] < (3, 14):
     sys.exit(
-        f"whats_left.py must be run under CPython 3.14 or newer, got {implementation} {sys.version} instead. If you have uv, try `uv run python -I whats_left.py` to select a proper Python interpreter easier."
+        f"whats_left.py must be run under CPython 3.14 or newer, got {implementation} {sys.version} instead. If you have uv, try `uv run python -I scripts/whats_left.py` to select a proper Python interpreter easier."
     )
 
 

From 4eb49491a3724aed3a15286f1979d18c4b1f6d49 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 17 Jan 2026 21:53:13 +0900
Subject: [PATCH 340/418] Change dockerfile to be available on aarch64 (#6751)

---
 .devcontainer/Dockerfile |  2 +-
 DEVELOPMENT.md           | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index 339cdb69bbf..cdd54a47d5b 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -1,4 +1,4 @@
-FROM mcr.microsoft.com/vscode/devcontainers/rust:1-bullseye
+FROM rust:bullseye
 
 # Install clang
 RUN apt-get update \
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index f515bef1a1a..24c149eebef 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -95,6 +95,41 @@ To run only `test_cmath` (located at `Lib/test/test_cmath`) verbosely:
 $ cargo run --release -- -m test test_cmath -v
 ```
 
+### Testing on Linux from macOS
+
+You can test RustPython on Linux from macOS using Apple's `container` CLI.
+
+**Setup (one-time):**
+
+```shell
+# Install container CLI
+$ brew install container
+
+# Disable Rosetta requirement for arm64-only builds
+$ defaults write com.apple.container.defaults build.rosetta -bool false
+
+# Build the development image
+$ container build --arch arm64 -t rustpython-dev -f .devcontainer/Dockerfile .
+```
+
+**Running tests:**
+
+```shell
+# Start a persistent container in background (8GB memory, 4 CPUs for compilation)
+$ container run -d --name rustpython-test -m 8G -c 4 \
+    --mount type=bind,source=$(pwd),target=/workspace \
+    -w /workspace rustpython-dev sleep infinity
+
+# Run tests inside the container
+$ container exec rustpython-test sh -c "cargo run --release -- -m test test_ensurepip"
+
+# Run any command
+$ container exec rustpython-test sh -c "cargo test --workspace"
+
+# Stop and remove the container when done
+$ container rm -f rustpython-test
+```
+
 ## Profiling
 
 To profile RustPython, build it in `release` mode with the `flame-it` feature.

From 3d86b26cafa4c0a5b83d3b858ecc112297bcef53 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Sat, 17 Jan 2026 21:54:16 +0900
Subject: [PATCH 341/418] Complement upgrade-pylib Claude Code command (#6742)

* Insert unittest import line if it doesn't exist

* Complement upgrade-pylib Claude Code command

* Ensure test module having import statement at least one
---
 .claude/commands/upgrade-pylib.md | 86 +++++++++++++++++++++++++++++--
 scripts/lib_updater.py            | 31 +++++++++++
 2 files changed, 112 insertions(+), 5 deletions(-)

diff --git a/.claude/commands/upgrade-pylib.md b/.claude/commands/upgrade-pylib.md
index 520d5deb7ba..02ec7c0d376 100644
--- a/.claude/commands/upgrade-pylib.md
+++ b/.claude/commands/upgrade-pylib.md
@@ -15,9 +15,62 @@ Upgrade a Python standard library module from CPython to RustPython.
    - If `cpython/Lib/$ARGUMENTS.py` exists, copy it to `Lib/$ARGUMENTS.py`
    - If `cpython/Lib/$ARGUMENTS/` directory exists, copy it to `Lib/$ARGUMENTS/`
 
-3. **Upgrade tests**
-   - Run: `python lib_updater.py --quick-upgrade cpython/Lib/test/test_$ARGUMENTS`
-   - This will update the test files with appropriate RustPython markers
+3. **Upgrade tests (quick upgrade with lib_updater)**
+   - If `cpython/Lib/test/test_$ARGUMENTS.py` is a single file:
+     - Run: `python3 scripts/lib_updater.py --quick-upgrade cpython/Lib/test/test_$ARGUMENTS.py`
+   - If `cpython/Lib/test/test_$ARGUMENTS/` is a directory:
+     - Run the script for each `.py` file in the directory:
+       ```bash
+       for f in cpython/Lib/test/test_$ARGUMENTS/*.py; do
+           python3 scripts/lib_updater.py --quick-upgrade "$f"
+       done
+       ```
+   - This will update the test files with basic RustPython markers (`@unittest.expectedFailure`, `@unittest.skip`, etc.)
+   - **Handle lib_updater warnings**: If you see warnings like `WARNING: TestCFoo does not exist in remote file`, it means the class structure changed between versions and markers couldn't be transferred automatically. These need to be manually restored in step 4 or added in step 5.
+
+4. **Review git diff and restore RUSTPYTHON-specific changes**
+   - Run `git diff Lib/test/test_$ARGUMENTS` to review all changes
+   - **Only restore changes that have explicit `RUSTPYTHON` comments**. Look for:
+     - `# XXX: RUSTPYTHON` or `# XXX RUSTPYTHON` - Comments marking RustPython-specific code modifications
+     - `# TODO: RUSTPYTHON` - Comments marking tests that need work
+     - Code changes with inline `# ... RUSTPYTHON` comments
+   - **Do NOT restore other diff changes** - these are likely upstream CPython changes, not RustPython-specific modifications
+   - When restoring, preserve the original context and formatting
+
+5. **Verify tests**
+   - Run: `cargo run --release -- -m test test_$ARGUMENTS -v`
+   - The `-v` flag shows detailed output to identify which tests fail and why
+   - For each new failure, add appropriate markers based on the failure type:
+     - **Test assertion failure** → `@unittest.expectedFailure` with `# TODO: RUSTPYTHON` comment
+     - **Panic/crash** → `@unittest.skip("TODO: RUSTPYTHON; <panic message>")`
+   - **Class-specific markers**: If a test fails only in the C implementation (TestCFoo) but passes in the Python implementation (TestPyFoo), or vice versa, add the marker to the specific subclass, not the base class:
+     ```python
+     # Base class - no marker here
+     class TestFoo:
+         def test_something(self):
+             ...
+
+     class TestPyFoo(TestFoo, PyTest): pass
+
+     class TestCFoo(TestFoo, CTest):
+         # TODO: RUSTPYTHON
+         @unittest.expectedFailure
+         def test_something(self):
+             return super().test_something()
+     ```
+   - **New tests from CPython**: The upgrade may bring in entirely new tests that didn't exist before. These won't have any RUSTPYTHON markers in the diff - they just need to be tested and marked if they fail.
+   - Example markers:
+     ```python
+     # TODO: RUSTPYTHON
+     @unittest.expectedFailure
+     def test_something(self):
+         ...
+
+     # TODO: RUSTPYTHON
+     @unittest.skip("TODO: RUSTPYTHON; panics with 'index out of bounds'")
+     def test_crashes(self):
+         ...
+     ```
 
 ## Example Usage
 ```
@@ -26,7 +79,30 @@ Upgrade a Python standard library module from CPython to RustPython.
 /upgrade-pylib asyncio
 ```
 
+## Example: Restoring RUSTPYTHON changes
+
+When git diff shows removed RUSTPYTHON-specific code like:
+```diff
+-# XXX RUSTPYTHON: we don't import _json as fresh since...
+-cjson = import_helper.import_fresh_module('json') #, fresh=['_json'])
++cjson = import_helper.import_fresh_module('json', fresh=['_json'])
+```
+
+You should restore the RustPython version:
+```python
+# XXX RUSTPYTHON: we don't import _json as fresh since...
+cjson = import_helper.import_fresh_module('json') #, fresh=['_json'])
+```
+
 ## Notes
 - The cpython/ directory should contain the CPython source that we're syncing from
-- lib_updater.py handles adding `# TODO: RUSTPYTHON` markers and `@unittest.expectedFailure` decorators
-- After upgrading, you may need to run tests to verify: `cargo run --release -- -m test test_$ARGUMENTS`
+- `scripts/lib_updater.py` handles basic patching:
+  - Transfers `@unittest.expectedFailure` and `@unittest.skip` decorators with `TODO: RUSTPYTHON` markers
+  - Adds `import unittest # XXX: RUSTPYTHON` if needed for the decorators
+  - **Limitation**: If a class was restructured (e.g., method overrides removed), lib_updater will warn and skip those markers
+- The script does NOT preserve all RustPython-specific changes - you must review `git diff` and restore them
+- Common RustPython markers to look for:
+  - `# XXX: RUSTPYTHON` or `# XXX RUSTPYTHON` - Inline comments for code modifications
+  - `# TODO: RUSTPYTHON` - Test skip/failure markers
+  - Any code with `RUSTPYTHON` in comments that was removed in the diff
+- **Important**: Not all changes in the git diff need to be restored. Only restore changes that have explicit `RUSTPYTHON` comments. Other changes are upstream CPython updates.
diff --git a/scripts/lib_updater.py b/scripts/lib_updater.py
index 4e2f7999ec1..6176bd54431 100755
--- a/scripts/lib_updater.py
+++ b/scripts/lib_updater.py
@@ -270,11 +270,42 @@ def {test_name}(self):
             yield (lineno, textwrap.indent(patch_lines, DEFAULT_INDENT))
 
 
+def has_unittest_import(tree: ast.Module) -> bool:
+    """Check if 'import unittest' is already present in the file."""
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == UT and alias.asname is None:
+                    return True
+    return False
+
+
+def find_import_insert_line(tree: ast.Module) -> int:
+    """Find the line number after the last import statement."""
+    last_import_line = None
+    for node in tree.body:
+        if isinstance(node, (ast.Import, ast.ImportFrom)):
+            last_import_line = node.end_lineno or node.lineno
+    assert last_import_line is not None
+    return last_import_line
+
+
 def apply_patches(contents: str, patches: Patches) -> str:
     tree = ast.parse(contents)
     lines = contents.splitlines()
 
     modifications = list(iter_patch_lines(tree, patches))
+
+    # If we have modifications and unittest is not imported, add it
+    if modifications and not has_unittest_import(tree):
+        import_line = find_import_insert_line(tree)
+        modifications.append(
+            (
+                import_line,
+                "\nimport unittest # XXX: RUSTPYTHON; importing to be able to skip tests",
+            )
+        )
+
     # Going in reverse to not distrupt the line offset
     for lineno, patch in sorted(modifications, reverse=True):
         lines.insert(lineno, patch)

From 6dd5e36d029e0a72acf5dc0d0c569afc5e62622b Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 17 Jan 2026 15:53:00 +0200
Subject: [PATCH 342/418] Remove misleading placeholder comments (#6757)

---
 crates/compiler-core/src/bytecode/instruction.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 2cca03127cf..fe448f4574b 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -56,7 +56,7 @@ pub enum Instruction {
     PopExcept = 31,
     PopTop = 32,
     PushExcInfo = 33,
-    PushNull = 34,        // Placeholder
+    PushNull = 34,
     ReturnGenerator = 35, // Placeholder
     ReturnValue = 36,
     SetupAnnotations = 37,
@@ -148,13 +148,13 @@ pub enum Instruction {
     IsOp(Arg<Invert>) = 76,
     JumpBackward {
         target: Arg<Label>,
-    } = 77, // Placeholder
+    } = 77,
     JumpBackwardNoInterrupt {
         target: Arg<Label>,
     } = 78, // Placeholder
     JumpForward {
         target: Arg<Label>,
-    } = 79, // Placeholder
+    } = 79,
     ListAppend {
         i: Arg<u32>,
     } = 80,

From 892116c009d0ff37249f25e5720cb36393f73c35 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 17 Jan 2026 17:26:06 +0200
Subject: [PATCH 343/418] Add some compiler tests from 3.13.11 (#6752)

* Add some compiler tests from 3.13.11

* Unmark passing test
---
 Lib/test/test_compiler_assemble.py |  147 ++++
 Lib/test/test_compiler_codegen.py  |  159 ++++
 Lib/test/test_peepholer.py         | 1215 ++++++++++++++++++++++++++++
 3 files changed, 1521 insertions(+)
 create mode 100644 Lib/test/test_compiler_assemble.py
 create mode 100644 Lib/test/test_compiler_codegen.py
 create mode 100644 Lib/test/test_peepholer.py

diff --git a/Lib/test/test_compiler_assemble.py b/Lib/test/test_compiler_assemble.py
new file mode 100644
index 00000000000..1b98b0d97ed
--- /dev/null
+++ b/Lib/test/test_compiler_assemble.py
@@ -0,0 +1,147 @@
+import dis
+import io
+import textwrap
+import types
+
+from test.support.bytecode_helper import AssemblerTestCase
+
+
+# Tests for the code-object creation stage of the compiler.
+
+class IsolatedAssembleTests(AssemblerTestCase):
+
+    def complete_metadata(self, metadata, filename="myfile.py"):
+        if metadata is None:
+            metadata = {}
+        for key in ['name', 'qualname']:
+            metadata.setdefault(key, key)
+        for key in ['consts']:
+            metadata.setdefault(key, [])
+        for key in ['names', 'varnames', 'cellvars', 'freevars', 'fasthidden']:
+            metadata.setdefault(key, {})
+        for key in ['argcount', 'posonlyargcount', 'kwonlyargcount']:
+            metadata.setdefault(key, 0)
+        metadata.setdefault('firstlineno', 1)
+        metadata.setdefault('filename', filename)
+        return metadata
+
+    def insts_to_code_object(self, insts, metadata):
+        metadata = self.complete_metadata(metadata)
+        seq = self.seq_from_insts(insts)
+        return self.get_code_object(metadata['filename'], seq, metadata)
+
+    def assemble_test(self, insts, metadata, expected):
+        co = self.insts_to_code_object(insts, metadata)
+        self.assertIsInstance(co, types.CodeType)
+
+        expected_metadata = {}
+        for key, value in metadata.items():
+            if key == "fasthidden":
+                # not exposed on code object
+                continue
+            if isinstance(value, list):
+                expected_metadata[key] = tuple(value)
+            elif isinstance(value, dict):
+                expected_metadata[key] = tuple(value.keys())
+            else:
+                expected_metadata[key] = value
+
+        for key, value in expected_metadata.items():
+            self.assertEqual(getattr(co, "co_" + key), value)
+
+        f = types.FunctionType(co, {})
+        for args, res in expected.items():
+            self.assertEqual(f(*args), res)
+
+    def test_simple_expr(self):
+        metadata = {
+            'filename' : 'avg.py',
+            'name'     : 'avg',
+            'qualname' : 'stats.avg',
+            'consts'   : {2 : 0},
+            'argcount' : 2,
+            'varnames' : {'x' : 0, 'y' : 1},
+        }
+
+        # code for "return (x+y)/2"
+        insts = [
+            ('RESUME', 0),
+            ('LOAD_FAST', 0, 1),   # 'x'
+            ('LOAD_FAST', 1, 1),   # 'y'
+            ('BINARY_OP', 0, 1),   # '+'
+            ('LOAD_CONST', 0, 1),  # 2
+            ('BINARY_OP', 11, 1),   # '/'
+            ('RETURN_VALUE', None, 1),
+        ]
+        expected = {(3, 4) : 3.5, (-100, 200) : 50, (10, 18) : 14}
+        self.assemble_test(insts, metadata, expected)
+
+
+    def test_expression_with_pseudo_instruction_load_closure(self):
+
+        def mod_two(x):
+            def inner():
+                return x
+            return inner() % 2
+
+        inner_code = mod_two.__code__.co_consts[1]
+        assert isinstance(inner_code, types.CodeType)
+
+        metadata = {
+            'filename' : 'mod_two.py',
+            'name'     : 'mod_two',
+            'qualname' : 'nested.mod_two',
+            'cellvars' : {'x' : 0},
+            'consts': {None: 0, inner_code: 1, 2: 2},
+            'argcount' : 1,
+            'varnames' : {'x' : 0},
+        }
+
+        instructions = [
+            ('RESUME', 0,),
+            ('LOAD_CLOSURE', 0, 1),
+            ('BUILD_TUPLE', 1, 1),
+            ('LOAD_CONST', 1, 1),
+            ('MAKE_FUNCTION', None, 2),
+            ('SET_FUNCTION_ATTRIBUTE', 8, 2),
+            ('PUSH_NULL', None, 1),
+            ('CALL', 0, 2),                     # (lambda: x)()
+            ('LOAD_CONST', 2, 2),               # 2
+            ('BINARY_OP', 6, 2),                # %
+            ('RETURN_VALUE', None, 2)
+        ]
+
+        expected = {(0,): 0, (1,): 1, (2,): 0, (120,): 0, (121,): 1}
+        self.assemble_test(instructions, metadata, expected)
+
+
+    def test_exception_table(self):
+        metadata = {
+            'filename' : 'exc.py',
+            'name'     : 'exc',
+            'consts'   : {2 : 0},
+        }
+
+        # code for "try: pass\n except: pass"
+        insts = [
+            ('RESUME', 0),
+            ('SETUP_FINALLY', 3),
+            ('RETURN_CONST', 0),
+            ('SETUP_CLEANUP', 8),
+            ('PUSH_EXC_INFO', None),
+            ('POP_TOP', None),
+            ('POP_EXCEPT', None),
+            ('RETURN_CONST', 0),
+            ('COPY', 3),
+            ('POP_EXCEPT', None),
+            ('RERAISE', 1),
+        ]
+        co = self.insts_to_code_object(insts, metadata)
+        output = io.StringIO()
+        dis.dis(co, file=output)
+        exc_table = textwrap.dedent("""
+                                       ExceptionTable:
+                                         L1 to L2 -> L2 [0]
+                                         L2 to L3 -> L3 [1] lasti
+                                    """)
+        self.assertTrue(output.getvalue().endswith(exc_table))
diff --git a/Lib/test/test_compiler_codegen.py b/Lib/test/test_compiler_codegen.py
new file mode 100644
index 00000000000..8a15c400a44
--- /dev/null
+++ b/Lib/test/test_compiler_codegen.py
@@ -0,0 +1,159 @@
+
+import textwrap
+from test.support.bytecode_helper import CodegenTestCase
+
+# Tests for the code-generation stage of the compiler.
+# Examine the un-optimized code generated from the AST.
+
+class IsolatedCodeGenTests(CodegenTestCase):
+
+    def assertInstructionsMatch_recursive(self, insts, expected_insts):
+        expected_nested = [i for i in expected_insts if isinstance(i, list)]
+        expected_insts = [i for i in expected_insts if not isinstance(i, list)]
+        self.assertInstructionsMatch(insts, expected_insts)
+        self.assertEqual(len(insts.get_nested()), len(expected_nested))
+        for n_insts, n_expected in zip(insts.get_nested(), expected_nested):
+            self.assertInstructionsMatch_recursive(n_insts, n_expected)
+
+    def codegen_test(self, snippet, expected_insts):
+        import ast
+        a = ast.parse(snippet, "my_file.py", "exec")
+        insts = self.generate_code(a)
+        self.assertInstructionsMatch_recursive(insts, expected_insts)
+
+    def test_if_expression(self):
+        snippet = "42 if True else 24"
+        false_lbl = self.Label()
+        expected = [
+            ('RESUME', 0, 0),
+            ('LOAD_CONST', 0, 1),
+            ('TO_BOOL', 0, 1),
+            ('POP_JUMP_IF_FALSE', false_lbl := self.Label(), 1),
+            ('LOAD_CONST', 1, 1),
+            ('JUMP_NO_INTERRUPT', exit_lbl := self.Label()),
+            false_lbl,
+            ('LOAD_CONST', 2, 1),
+            exit_lbl,
+            ('POP_TOP', None),
+            ('LOAD_CONST', 3),
+            ('RETURN_VALUE', None),
+        ]
+        self.codegen_test(snippet, expected)
+
+    def test_for_loop(self):
+        snippet = "for x in l:\n\tprint(x)"
+        false_lbl = self.Label()
+        expected = [
+            ('RESUME', 0, 0),
+            ('LOAD_NAME', 0, 1),
+            ('GET_ITER', None, 1),
+            loop_lbl := self.Label(),
+            ('FOR_ITER', exit_lbl := self.Label(), 1),
+            ('NOP', None, 1, 1),
+            ('STORE_NAME', 1, 1),
+            ('LOAD_NAME', 2, 2),
+            ('PUSH_NULL', None, 2),
+            ('LOAD_NAME', 1, 2),
+            ('CALL', 1, 2),
+            ('POP_TOP', None),
+            ('JUMP', loop_lbl),
+            exit_lbl,
+            ('END_FOR', None),
+            ('POP_TOP', None),
+            ('LOAD_CONST', 0),
+            ('RETURN_VALUE', None),
+        ]
+        self.codegen_test(snippet, expected)
+
+    def test_function(self):
+        snippet = textwrap.dedent("""
+            def f(x):
+                return x + 42
+        """)
+        expected = [
+            # Function definition
+            ('RESUME', 0),
+            ('LOAD_CONST', 0),
+            ('MAKE_FUNCTION', None),
+            ('STORE_NAME', 0),
+            ('LOAD_CONST', 1),
+            ('RETURN_VALUE', None),
+            [
+                # Function body
+                ('RESUME', 0),
+                ('LOAD_FAST', 0),
+                ('LOAD_CONST', 1),
+                ('BINARY_OP', 0),
+                ('RETURN_VALUE', None),
+                ('LOAD_CONST', 0),
+                ('RETURN_VALUE', None),
+            ]
+        ]
+        self.codegen_test(snippet, expected)
+
+    def test_nested_functions(self):
+        snippet = textwrap.dedent("""
+            def f():
+                def h():
+                    return 12
+                def g():
+                    x = 1
+                    y = 2
+                    z = 3
+                    u = 4
+                    return 42
+        """)
+        expected = [
+            # Function definition
+            ('RESUME', 0),
+            ('LOAD_CONST', 0),
+            ('MAKE_FUNCTION', None),
+            ('STORE_NAME', 0),
+            ('LOAD_CONST', 1),
+            ('RETURN_VALUE', None),
+            [
+                # Function body
+                ('RESUME', 0),
+                ('LOAD_CONST', 1),
+                ('MAKE_FUNCTION', None),
+                ('STORE_FAST', 0),
+                ('LOAD_CONST', 2),
+                ('MAKE_FUNCTION', None),
+                ('STORE_FAST', 1),
+                ('LOAD_CONST', 0),
+                ('RETURN_VALUE', None),
+                [
+                    ('RESUME', 0),
+                    ('NOP', None),
+                    ('LOAD_CONST', 1),
+                    ('RETURN_VALUE', None),
+                    ('LOAD_CONST', 0),
+                    ('RETURN_VALUE', None),
+                ],
+                [
+                    ('RESUME', 0),
+                    ('LOAD_CONST', 1),
+                    ('STORE_FAST', 0),
+                    ('LOAD_CONST', 2),
+                    ('STORE_FAST', 1),
+                    ('LOAD_CONST', 3),
+                    ('STORE_FAST', 2),
+                    ('LOAD_CONST', 4),
+                    ('STORE_FAST', 3),
+                    ('NOP', None),
+                    ('LOAD_CONST', 5),
+                    ('RETURN_VALUE', None),
+                    ('LOAD_CONST', 0),
+                    ('RETURN_VALUE', None),
+                ],
+            ],
+        ]
+        self.codegen_test(snippet, expected)
+
+    def test_syntax_error__return_not_in_function(self):
+        snippet = "return 42"
+        with self.assertRaisesRegex(SyntaxError, "'return' outside function") as cm:
+            self.codegen_test(snippet, None)
+        self.assertIsNone(cm.exception.text)
+        self.assertEqual(cm.exception.offset, 1)
+        self.assertEqual(cm.exception.end_offset, 10)
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
new file mode 100644
index 00000000000..50ac8aef2f3
--- /dev/null
+++ b/Lib/test/test_peepholer.py
@@ -0,0 +1,1215 @@
+import dis
+from itertools import combinations, product
+import opcode
+import sys
+import textwrap
+import unittest
+
+from test import support
+from test.support.bytecode_helper import BytecodeTestCase, CfgOptimizationTestCase
+
+
+def compile_pattern_with_fast_locals(pattern):
+    source = textwrap.dedent(
+        f"""
+        def f(x):
+            match x:
+                case {pattern}:
+                    pass
+        """
+    )
+    namespace = {}
+    exec(source, namespace)
+    return namespace["f"].__code__
+
+
+def count_instr_recursively(f, opname):
+    count = 0
+    for instr in dis.get_instructions(f):
+        if instr.opname == opname:
+            count += 1
+    if hasattr(f, '__code__'):
+        f = f.__code__
+    for c in f.co_consts:
+        if hasattr(c, 'co_code'):
+            count += count_instr_recursively(c, opname)
+    return count
+
+
+class TestTranforms(BytecodeTestCase):
+
+    def check_jump_targets(self, code):
+        instructions = list(dis.get_instructions(code))
+        targets = {instr.offset: instr for instr in instructions}
+        for instr in instructions:
+            if 'JUMP_' not in instr.opname:
+                continue
+            tgt = targets[instr.argval]
+            # jump to unconditional jump
+            if tgt.opname in ('JUMP_BACKWARD', 'JUMP_FORWARD'):
+                self.fail(f'{instr.opname} at {instr.offset} '
+                          f'jumps to {tgt.opname} at {tgt.offset}')
+            # unconditional jump to RETURN_VALUE
+            if (instr.opname in ('JUMP_BACKWARD', 'JUMP_FORWARD') and
+                tgt.opname == 'RETURN_VALUE'):
+                self.fail(f'{instr.opname} at {instr.offset} '
+                          f'jumps to {tgt.opname} at {tgt.offset}')
+
+    def check_lnotab(self, code):
+        "Check that the lnotab byte offsets are sensible."
+        code = dis._get_code_object(code)
+        lnotab = list(dis.findlinestarts(code))
+        # Don't bother checking if the line info is sensible, because
+        # most of the line info we can get at comes from lnotab.
+        min_bytecode = min(t[0] for t in lnotab)
+        max_bytecode = max(t[0] for t in lnotab)
+        self.assertGreaterEqual(min_bytecode, 0)
+        self.assertLess(max_bytecode, len(code.co_code))
+        # This could conceivably test more (and probably should, as there
+        # aren't very many tests of lnotab), if peepholer wasn't scheduled
+        # to be replaced anyway.
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_unot(self):
+        # UNARY_NOT POP_JUMP_IF_FALSE  -->  POP_JUMP_IF_TRUE'
+        def unot(x):
+            if not x == 2:
+                del x
+        self.assertNotInBytecode(unot, 'UNARY_NOT')
+        self.assertNotInBytecode(unot, 'POP_JUMP_IF_FALSE')
+        self.assertInBytecode(unot, 'POP_JUMP_IF_TRUE')
+        self.check_lnotab(unot)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_inversion_of_is_or_in(self):
+        for line, cmp_op, invert in (
+            ('not a is b', 'IS_OP', 1,),
+            ('not a is not b', 'IS_OP', 0,),
+            ('not a in b', 'CONTAINS_OP', 1,),
+            ('not a not in b', 'CONTAINS_OP', 0,),
+            ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertInBytecode(code, cmp_op, invert)
+                self.check_lnotab(code)
+
+    def test_global_as_constant(self):
+        # LOAD_GLOBAL None/True/False  -->  LOAD_CONST None/True/False
+        def f():
+            x = None
+            x = None
+            return x
+        def g():
+            x = True
+            return x
+        def h():
+            x = False
+            return x
+
+        for func, elem in ((f, None), (g, True), (h, False)):
+            with self.subTest(func=func):
+                self.assertNotInBytecode(func, 'LOAD_GLOBAL')
+                self.assertInBytecode(func, 'LOAD_CONST', elem)
+                self.check_lnotab(func)
+
+        def f():
+            'Adding a docstring made this test fail in Py2.5.0'
+            return None
+
+        self.assertNotInBytecode(f, 'LOAD_GLOBAL')
+        self.assertInBytecode(f, 'RETURN_CONST', None)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_while_one(self):
+        # Skip over:  LOAD_CONST trueconst  POP_JUMP_IF_FALSE xx
+        def f():
+            while 1:
+                pass
+            return list
+        for elem in ('LOAD_CONST', 'POP_JUMP_IF_FALSE'):
+            self.assertNotInBytecode(f, elem)
+        for elem in ('JUMP_BACKWARD',):
+            self.assertInBytecode(f, elem)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pack_unpack(self):
+        for line, elem in (
+            ('a, = a,', 'RETURN_CONST',),
+            ('a, b = a, b', 'SWAP',),
+            ('a, b, c = a, b, c', 'SWAP',),
+            ):
+            with self.subTest(line=line):
+                code = compile(line,'','single')
+                self.assertInBytecode(code, elem)
+                self.assertNotInBytecode(code, 'BUILD_TUPLE')
+                self.assertNotInBytecode(code, 'UNPACK_SEQUENCE')
+                self.check_lnotab(code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_folding_of_tuples_of_constants(self):
+        for line, elem in (
+            ('a = 1,2,3', (1, 2, 3)),
+            ('("a","b","c")', ('a', 'b', 'c')),
+            ('a,b,c = 1,2,3', (1, 2, 3)),
+            ('(None, 1, None)', (None, 1, None)),
+            ('((1, 2), 3, 4)', ((1, 2), 3, 4)),
+            ):
+            with self.subTest(line=line):
+                code = compile(line,'','single')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                self.assertNotInBytecode(code, 'BUILD_TUPLE')
+                self.check_lnotab(code)
+
+        # Long tuples should be folded too.
+        code = compile(repr(tuple(range(10000))),'','single')
+        self.assertNotInBytecode(code, 'BUILD_TUPLE')
+        # One LOAD_CONST for the tuple, one for the None return value
+        load_consts = [instr for instr in dis.get_instructions(code)
+                              if instr.opname == 'LOAD_CONST']
+        self.assertEqual(len(load_consts), 1)
+        self.check_lnotab(code)
+
+        # Bug 1053819:  Tuple of constants misidentified when presented with:
+        # . . . opcode_with_arg 100   unary_opcode   BUILD_TUPLE 1  . . .
+        # The following would segfault upon compilation
+        def crater():
+            (~[
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+            ],)
+        self.check_lnotab(crater)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_folding_of_lists_of_constants(self):
+        for line, elem in (
+            # in/not in constants with BUILD_LIST should be folded to a tuple:
+            ('a in [1,2,3]', (1, 2, 3)),
+            ('a not in ["a","b","c"]', ('a', 'b', 'c')),
+            ('a in [None, 1, None]', (None, 1, None)),
+            ('a not in [(1, 2), 3, 4]', ((1, 2), 3, 4)),
+            ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                self.assertNotInBytecode(code, 'BUILD_LIST')
+                self.check_lnotab(code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_folding_of_sets_of_constants(self):
+        for line, elem in (
+            # in/not in constants with BUILD_SET should be folded to a frozenset:
+            ('a in {1,2,3}', frozenset({1, 2, 3})),
+            ('a not in {"a","b","c"}', frozenset({'a', 'c', 'b'})),
+            ('a in {None, 1, None}', frozenset({1, None})),
+            ('a not in {(1, 2), 3, 4}', frozenset({(1, 2), 3, 4})),
+            ('a in {1, 2, 3, 3, 2, 1}', frozenset({1, 2, 3})),
+            ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertNotInBytecode(code, 'BUILD_SET')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                self.check_lnotab(code)
+
+        # Ensure that the resulting code actually works:
+        def f(a):
+            return a in {1, 2, 3}
+
+        def g(a):
+            return a not in {1, 2, 3}
+
+        self.assertTrue(f(3))
+        self.assertTrue(not f(4))
+        self.check_lnotab(f)
+
+        self.assertTrue(not g(3))
+        self.assertTrue(g(4))
+        self.check_lnotab(g)
+
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_folding_of_binops_on_constants(self):
+        for line, elem in (
+            ('a = 2+3+4', 9),                   # chained fold
+            ('"@"*4', '@@@@'),                  # check string ops
+            ('a="abc" + "def"', 'abcdef'),      # check string ops
+            ('a = 3**4', 81),                   # binary power
+            ('a = 3*4', 12),                    # binary multiply
+            ('a = 13//4', 3),                   # binary floor divide
+            ('a = 14%4', 2),                    # binary modulo
+            ('a = 2+3', 5),                     # binary add
+            ('a = 13-4', 9),                    # binary subtract
+            ('a = (12,13)[1]', 13),             # binary subscr
+            ('a = 13 << 2', 52),                # binary lshift
+            ('a = 13 >> 2', 3),                 # binary rshift
+            ('a = 13 & 7', 5),                  # binary and
+            ('a = 13 ^ 7', 10),                 # binary xor
+            ('a = 13 | 7', 15),                 # binary or
+            ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                for instr in dis.get_instructions(code):
+                    self.assertFalse(instr.opname.startswith('BINARY_'))
+                self.check_lnotab(code)
+
+        # Verify that unfoldables are skipped
+        code = compile('a=2+"b"', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', 2)
+        self.assertInBytecode(code, 'LOAD_CONST', 'b')
+        self.check_lnotab(code)
+
+        # Verify that large sequences do not result from folding
+        code = compile('a="x"*10000', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', 10000)
+        self.assertNotIn("x"*10000, code.co_consts)
+        self.check_lnotab(code)
+        code = compile('a=1<<1000', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', 1000)
+        self.assertNotIn(1<<1000, code.co_consts)
+        self.check_lnotab(code)
+        code = compile('a=2**1000', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', 1000)
+        self.assertNotIn(2**1000, code.co_consts)
+        self.check_lnotab(code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_binary_subscr_on_unicode(self):
+        # valid code get optimized
+        code = compile('"foo"[0]', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', 'f')
+        self.assertNotInBytecode(code, 'BINARY_SUBSCR')
+        self.check_lnotab(code)
+        code = compile('"\u0061\uffff"[1]', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', '\uffff')
+        self.assertNotInBytecode(code,'BINARY_SUBSCR')
+        self.check_lnotab(code)
+
+        # With PEP 393, non-BMP char get optimized
+        code = compile('"\U00012345"[0]', '', 'single')
+        self.assertInBytecode(code, 'LOAD_CONST', '\U00012345')
+        self.assertNotInBytecode(code, 'BINARY_SUBSCR')
+        self.check_lnotab(code)
+
+        # invalid code doesn't get optimized
+        # out of range
+        code = compile('"fuu"[10]', '', 'single')
+        self.assertInBytecode(code, 'BINARY_SUBSCR')
+        self.check_lnotab(code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_folding_of_unaryops_on_constants(self):
+        for line, elem in (
+            ('-0.5', -0.5),                     # unary negative
+            ('-0.0', -0.0),                     # -0.0
+            ('-(1.0-1.0)', -0.0),               # -0.0 after folding
+            ('-0', 0),                          # -0
+            ('~-2', 1),                         # unary invert
+            ('+1', 1),                          # unary positive
+        ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                for instr in dis.get_instructions(code):
+                    self.assertFalse(instr.opname.startswith('UNARY_'))
+                self.check_lnotab(code)
+
+        # Check that -0.0 works after marshaling
+        def negzero():
+            return -(1.0-1.0)
+
+        for instr in dis.get_instructions(negzero):
+            self.assertFalse(instr.opname.startswith('UNARY_'))
+        self.check_lnotab(negzero)
+
+        # Verify that unfoldables are skipped
+        for line, elem, opname in (
+            ('-"abc"', 'abc', 'UNARY_NEGATIVE'),
+            ('~"abc"', 'abc', 'UNARY_INVERT'),
+        ):
+            with self.subTest(line=line):
+                code = compile(line, '', 'single')
+                self.assertInBytecode(code, 'LOAD_CONST', elem)
+                self.assertInBytecode(code, opname)
+                self.check_lnotab(code)
+
+    def test_elim_extra_return(self):
+        # RETURN LOAD_CONST None RETURN  -->  RETURN
+        def f(x):
+            return x
+        self.assertNotInBytecode(f, 'LOAD_CONST', None)
+        returns = [instr for instr in dis.get_instructions(f)
+                          if instr.opname == 'RETURN_VALUE']
+        self.assertEqual(len(returns), 1)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_to_return(self):
+        # JUMP_FORWARD to RETURN -->  RETURN
+        def f(cond, true_value, false_value):
+            # Intentionally use two-line expression to test issue37213.
+            return (true_value if cond
+                    else false_value)
+        self.check_jump_targets(f)
+        self.assertNotInBytecode(f, 'JUMP_FORWARD')
+        self.assertNotInBytecode(f, 'JUMP_BACKWARD')
+        returns = [instr for instr in dis.get_instructions(f)
+                          if instr.opname == 'RETURN_VALUE']
+        self.assertEqual(len(returns), 2)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_to_uncond_jump(self):
+        # POP_JUMP_IF_FALSE to JUMP_FORWARD --> POP_JUMP_IF_FALSE to non-jump
+        def f():
+            if a:
+                # Intentionally use two-line expression to test issue37213.
+                if (c
+                    or d):
+                    foo()
+            else:
+                baz()
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_to_uncond_jump2(self):
+        # POP_JUMP_IF_FALSE to JUMP_BACKWARD --> POP_JUMP_IF_FALSE to non-jump
+        def f():
+            while a:
+                # Intentionally use two-line expression to test issue37213.
+                if (c
+                    or d):
+                    a = foo()
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_to_uncond_jump3(self):
+        # Intentionally use two-line expressions to test issue37213.
+        # POP_JUMP_IF_FALSE to POP_JUMP_IF_FALSE --> POP_JUMP_IF_FALSE to non-jump
+        def f(a, b, c):
+            return ((a and b)
+                    and c)
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_FALSE'), 2)
+        # POP_JUMP_IF_TRUE to POP_JUMP_IF_TRUE --> POP_JUMP_IF_TRUE to non-jump
+        def f(a, b, c):
+            return ((a or b)
+                    or c)
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_TRUE'), 2)
+        # JUMP_IF_FALSE_OR_POP to JUMP_IF_TRUE_OR_POP --> POP_JUMP_IF_FALSE to non-jump
+        def f(a, b, c):
+            return ((a and b)
+                    or c)
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_FALSE'), 1)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_TRUE'), 1)
+        # POP_JUMP_IF_TRUE to POP_JUMP_IF_FALSE --> POP_JUMP_IF_TRUE to non-jump
+        def f(a, b, c):
+            return ((a or b)
+                    and c)
+        self.check_jump_targets(f)
+        self.check_lnotab(f)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_FALSE'), 1)
+        self.assertEqual(count_instr_recursively(f, 'POP_JUMP_IF_TRUE'), 1)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_to_uncond_jump4(self):
+        def f():
+            for i in range(5):
+                if i > 3:
+                    print(i)
+        self.check_jump_targets(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_elim_jump_after_return1(self):
+        # Eliminate dead code: jumps immediately after returns can't be reached
+        def f(cond1, cond2):
+            if cond1: return 1
+            if cond2: return 2
+            while 1:
+                return 3
+            while 1:
+                if cond1: return 4
+                return 5
+            return 6
+        self.assertNotInBytecode(f, 'JUMP_FORWARD')
+        self.assertNotInBytecode(f, 'JUMP_BACKWARD')
+        returns = [instr for instr in dis.get_instructions(f)
+                          if instr.opname == 'RETURN_VALUE']
+        self.assertLessEqual(len(returns), 6)
+        self.check_lnotab(f)
+
+    def test_make_function_doesnt_bail(self):
+        def f():
+            def g()->1+1:
+                pass
+            return g
+        self.assertNotInBytecode(f, 'BINARY_OP')
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_constant_folding(self):
+        # Issue #11244: aggressive constant folding.
+        exprs = [
+            '3 * -5',
+            '-3 * 5',
+            '2 * (3 * 4)',
+            '(2 * 3) * 4',
+            '(-1, 2, 3)',
+            '(1, -2, 3)',
+            '(1, 2, -3)',
+            '(1, 2, -3) * 6',
+            'lambda x: x in {(3 * -5) + (-1 - 6), (1, -2, 3) * 2, None}',
+        ]
+        for e in exprs:
+            with self.subTest(e=e):
+                code = compile(e, '', 'single')
+                for instr in dis.get_instructions(code):
+                    self.assertFalse(instr.opname.startswith('UNARY_'))
+                    self.assertFalse(instr.opname.startswith('BINARY_'))
+                    self.assertFalse(instr.opname.startswith('BUILD_'))
+                self.check_lnotab(code)
+
+    def test_in_literal_list(self):
+        def containtest():
+            return x in [a, b]
+        self.assertEqual(count_instr_recursively(containtest, 'BUILD_LIST'), 0)
+        self.check_lnotab(containtest)
+
+    def test_iterate_literal_list(self):
+        def forloop():
+            for x in [a, b]:
+                pass
+        self.assertEqual(count_instr_recursively(forloop, 'BUILD_LIST'), 0)
+        self.check_lnotab(forloop)
+
+    def test_condition_with_binop_with_bools(self):
+        def f():
+            if True or False:
+                return 1
+            return 0
+        self.assertEqual(f(), 1)
+        self.check_lnotab(f)
+
+    def test_if_with_if_expression(self):
+        # Check bpo-37289
+        def f(x):
+            if (True if x else False):
+                return True
+            return False
+        self.assertTrue(f(True))
+        self.check_lnotab(f)
+
+    def test_trailing_nops(self):
+        # Check the lnotab of a function that even after trivial
+        # optimization has trailing nops, which the lnotab adjustment has to
+        # handle properly (bpo-38115).
+        def f(x):
+            while 1:
+                return 3
+            while 1:
+                return 5
+            return 6
+        self.check_lnotab(f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assignment_idiom_in_comprehensions(self):
+        def listcomp():
+            return [y for x in a for y in [f(x)]]
+        self.assertEqual(count_instr_recursively(listcomp, 'FOR_ITER'), 1)
+        def setcomp():
+            return {y for x in a for y in [f(x)]}
+        self.assertEqual(count_instr_recursively(setcomp, 'FOR_ITER'), 1)
+        def dictcomp():
+            return {y: y for x in a for y in [f(x)]}
+        self.assertEqual(count_instr_recursively(dictcomp, 'FOR_ITER'), 1)
+        def genexpr():
+            return (y for x in a for y in [f(x)])
+        self.assertEqual(count_instr_recursively(genexpr, 'FOR_ITER'), 1)
+
+    @support.requires_resource('cpu')
+    def test_format_combinations(self):
+        flags = '-+ #0'
+        testcases = [
+            *product(('', '1234', 'абвг'), 'sra'),
+            *product((1234, -1234), 'duioxX'),
+            *product((1234.5678901, -1234.5678901), 'duifegFEG'),
+            *product((float('inf'), -float('inf')), 'fegFEG'),
+        ]
+        width_precs = [
+            *product(('', '1', '30'), ('', '.', '.0', '.2')),
+            ('', '.40'),
+            ('30', '.40'),
+        ]
+        for value, suffix in testcases:
+            for width, prec in width_precs:
+                for r in range(len(flags) + 1):
+                    for spec in combinations(flags, r):
+                        fmt = '%' + ''.join(spec) + width + prec + suffix
+                        with self.subTest(fmt=fmt, value=value):
+                            s1 = fmt % value
+                            s2 = eval(f'{fmt!r} % (x,)', {'x': value})
+                            self.assertEqual(s2, s1, f'{fmt = }')
+
+    def test_format_misc(self):
+        def format(fmt, *values):
+            vars = [f'x{i+1}' for i in range(len(values))]
+            if len(vars) == 1:
+                args = '(' + vars[0] + ',)'
+            else:
+                args = '(' + ', '.join(vars) + ')'
+            return eval(f'{fmt!r} % {args}', dict(zip(vars, values)))
+
+        self.assertEqual(format('string'), 'string')
+        self.assertEqual(format('x = %s!', 1234), 'x = 1234!')
+        self.assertEqual(format('x = %d!', 1234), 'x = 1234!')
+        self.assertEqual(format('x = %x!', 1234), 'x = 4d2!')
+        self.assertEqual(format('x = %f!', 1234), 'x = 1234.000000!')
+        self.assertEqual(format('x = %s!', 1234.0000625), 'x = 1234.0000625!')
+        self.assertEqual(format('x = %f!', 1234.0000625), 'x = 1234.000063!')
+        self.assertEqual(format('x = %d!', 1234.0000625), 'x = 1234!')
+        self.assertEqual(format('x = %s%% %%%%', 1234), 'x = 1234% %%')
+        self.assertEqual(format('x = %s!', '%% %s'), 'x = %% %s!')
+        self.assertEqual(format('x = %s, y = %d', 12, 34), 'x = 12, y = 34')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_format_errors(self):
+        with self.assertRaisesRegex(TypeError,
+                    'not enough arguments for format string'):
+            eval("'%s' % ()")
+        with self.assertRaisesRegex(TypeError,
+                    'not all arguments converted during string formatting'):
+            eval("'%s' % (x, y)", {'x': 1, 'y': 2})
+        with self.assertRaisesRegex(ValueError, 'incomplete format'):
+            eval("'%s%' % (x,)", {'x': 1234})
+        with self.assertRaisesRegex(ValueError, 'incomplete format'):
+            eval("'%s%%%' % (x,)", {'x': 1234})
+        with self.assertRaisesRegex(TypeError,
+                    'not enough arguments for format string'):
+            eval("'%s%z' % (x,)", {'x': 1234})
+        with self.assertRaisesRegex(ValueError, 'unsupported format character'):
+            eval("'%s%z' % (x, 5)", {'x': 1234})
+        with self.assertRaisesRegex(TypeError, 'a real number is required, not str'):
+            eval("'%d' % (x,)", {'x': '1234'})
+        with self.assertRaisesRegex(TypeError, 'an integer is required, not float'):
+            eval("'%x' % (x,)", {'x': 1234.56})
+        with self.assertRaisesRegex(TypeError, 'an integer is required, not str'):
+            eval("'%x' % (x,)", {'x': '1234'})
+        with self.assertRaisesRegex(TypeError, 'must be real number, not str'):
+            eval("'%f' % (x,)", {'x': '1234'})
+        with self.assertRaisesRegex(TypeError,
+                    'not enough arguments for format string'):
+            eval("'%s, %s' % (x, *y)", {'x': 1, 'y': []})
+        with self.assertRaisesRegex(TypeError,
+                    'not all arguments converted during string formatting'):
+            eval("'%s, %s' % (x, *y)", {'x': 1, 'y': [2, 3]})
+
+    def test_static_swaps_unpack_two(self):
+        def f(a, b):
+            a, b = a, b
+            b, a = a, b
+        self.assertNotInBytecode(f, "SWAP")
+
+    def test_static_swaps_unpack_three(self):
+        def f(a, b, c):
+            a, b, c = a, b, c
+            a, c, b = a, b, c
+            b, a, c = a, b, c
+            b, c, a = a, b, c
+            c, a, b = a, b, c
+            c, b, a = a, b, c
+        self.assertNotInBytecode(f, "SWAP")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_static_swaps_match_mapping(self):
+        for a, b, c in product("_a", "_b", "_c"):
+            pattern = f"{{'a': {a}, 'b': {b}, 'c': {c}}}"
+            with self.subTest(pattern):
+                code = compile_pattern_with_fast_locals(pattern)
+                self.assertNotInBytecode(code, "SWAP")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_static_swaps_match_class(self):
+        forms = [
+            "C({}, {}, {})",
+            "C({}, {}, c={})",
+            "C({}, b={}, c={})",
+            "C(a={}, b={}, c={})"
+        ]
+        for a, b, c in product("_a", "_b", "_c"):
+            for form in forms:
+                pattern = form.format(a, b, c)
+                with self.subTest(pattern):
+                    code = compile_pattern_with_fast_locals(pattern)
+                    self.assertNotInBytecode(code, "SWAP")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_static_swaps_match_sequence(self):
+        swaps = {"*_, b, c", "a, *_, c", "a, b, *_"}
+        forms = ["{}, {}, {}", "{}, {}, *{}", "{}, *{}, {}", "*{}, {}, {}"]
+        for a, b, c in product("_a", "_b", "_c"):
+            for form in forms:
+                pattern = form.format(a, b, c)
+                with self.subTest(pattern):
+                    code = compile_pattern_with_fast_locals(pattern)
+                    if pattern in swaps:
+                        # If this fails... great! Remove this pattern from swaps
+                        # to prevent regressing on any improvement:
+                        self.assertInBytecode(code, "SWAP")
+                    else:
+                        self.assertNotInBytecode(code, "SWAP")
+
+
+class TestBuglets(unittest.TestCase):
+
+    def test_bug_11510(self):
+        # folded constant set optimization was commingled with the tuple
+        # unpacking optimization which would fail if the set had duplicate
+        # elements so that the set length was unexpected
+        def f():
+            x, y = {1, 1}
+            return x, y
+        with self.assertRaises(ValueError):
+            f()
+
+    def test_bpo_42057(self):
+        for i in range(10):
+            try:
+                raise Exception
+            except Exception or Exception:
+                pass
+
+    def test_bpo_45773_pop_jump_if_true(self):
+        compile("while True or spam: pass", "<test>", "exec")
+
+    def test_bpo_45773_pop_jump_if_false(self):
+        compile("while True or not spam: pass", "<test>", "exec")
+
+
+class TestMarkingVariablesAsUnKnown(BytecodeTestCase):
+
+    def setUp(self):
+        self.addCleanup(sys.settrace, sys.gettrace())
+        sys.settrace(None)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_known_simple(self):
+        def f():
+            x = 1
+            y = x + x
+        self.assertInBytecode(f, 'LOAD_FAST_LOAD_FAST')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_unknown_simple(self):
+        def f():
+            if condition():
+                x = 1
+            print(x)
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK')
+        self.assertNotInBytecode(f, 'LOAD_FAST')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_unknown_because_del(self):
+        def f():
+            x = 1
+            del x
+            print(x)
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK')
+        self.assertNotInBytecode(f, 'LOAD_FAST')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_known_because_parameter(self):
+        def f1(x):
+            print(x)
+        self.assertInBytecode(f1, 'LOAD_FAST')
+        self.assertNotInBytecode(f1, 'LOAD_FAST_CHECK')
+
+        def f2(*, x):
+            print(x)
+        self.assertInBytecode(f2, 'LOAD_FAST')
+        self.assertNotInBytecode(f2, 'LOAD_FAST_CHECK')
+
+        def f3(*args):
+            print(args)
+        self.assertInBytecode(f3, 'LOAD_FAST')
+        self.assertNotInBytecode(f3, 'LOAD_FAST_CHECK')
+
+        def f4(**kwargs):
+            print(kwargs)
+        self.assertInBytecode(f4, 'LOAD_FAST')
+        self.assertNotInBytecode(f4, 'LOAD_FAST_CHECK')
+
+        def f5(x=0):
+            print(x)
+        self.assertInBytecode(f5, 'LOAD_FAST')
+        self.assertNotInBytecode(f5, 'LOAD_FAST_CHECK')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_known_because_already_loaded(self):
+        def f():
+            if condition():
+                x = 1
+            print(x)
+            print(x)
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK')
+        self.assertInBytecode(f, 'LOAD_FAST')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_known_multiple_branches(self):
+        def f():
+            if condition():
+                x = 1
+            else:
+                x = 2
+            print(x)
+        self.assertInBytecode(f, 'LOAD_FAST')
+        self.assertNotInBytecode(f, 'LOAD_FAST_CHECK')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_unknown_after_error(self):
+        def f():
+            try:
+                res = 1 / 0
+            except ZeroDivisionError:
+                pass
+            return res
+        # LOAD_FAST (known) still occurs in the no-exception branch.
+        # Assert that it doesn't occur in the LOAD_FAST_CHECK branch.
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_unknown_after_error_2(self):
+        def f():
+            try:
+                1 / 0
+            except:
+                print(a, b, c, d, e, f, g)
+            a = b = c = d = e = f = g = 1
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK')
+        self.assertNotInBytecode(f, 'LOAD_FAST')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_load_fast_too_many_locals(self):
+        # When there get to be too many locals to analyze completely,
+        # later locals are all converted to LOAD_FAST_CHECK, except
+        # when a store or prior load occurred in the same basicblock.
+        def f():
+            a00 = a01 = a02 = a03 = a04 = a05 = a06 = a07 = a08 = a09 = 1
+            a10 = a11 = a12 = a13 = a14 = a15 = a16 = a17 = a18 = a19 = 1
+            a20 = a21 = a22 = a23 = a24 = a25 = a26 = a27 = a28 = a29 = 1
+            a30 = a31 = a32 = a33 = a34 = a35 = a36 = a37 = a38 = a39 = 1
+            a40 = a41 = a42 = a43 = a44 = a45 = a46 = a47 = a48 = a49 = 1
+            a50 = a51 = a52 = a53 = a54 = a55 = a56 = a57 = a58 = a59 = 1
+            a60 = a61 = a62 = a63 = a64 = a65 = a66 = a67 = a68 = a69 = 1
+            a70 = a71 = a72 = a73 = a74 = a75 = a76 = a77 = a78 = a79 = 1
+            del a72, a73
+            print(a73)
+            print(a70, a71, a72, a73)
+            while True:
+                print(a00, a01, a62, a63)
+                print(a64, a65, a78, a79)
+
+        self.assertInBytecode(f, 'LOAD_FAST_LOAD_FAST', ("a00", "a01"))
+        self.assertNotInBytecode(f, 'LOAD_FAST_CHECK', "a00")
+        self.assertNotInBytecode(f, 'LOAD_FAST_CHECK', "a01")
+        for i in 62, 63:
+            # First 64 locals: analyze completely
+            self.assertInBytecode(f, 'LOAD_FAST', f"a{i:02}")
+            self.assertNotInBytecode(f, 'LOAD_FAST_CHECK', f"a{i:02}")
+        for i in 64, 65, 78, 79:
+            # Locals >=64 not in the same basicblock
+            self.assertInBytecode(f, 'LOAD_FAST_CHECK', f"a{i:02}")
+            self.assertNotInBytecode(f, 'LOAD_FAST', f"a{i:02}")
+        for i in 70, 71:
+            # Locals >=64 in the same basicblock
+            self.assertInBytecode(f, 'LOAD_FAST', f"a{i:02}")
+            self.assertNotInBytecode(f, 'LOAD_FAST_CHECK', f"a{i:02}")
+        # del statements should invalidate within basicblocks.
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK', "a72")
+        self.assertNotInBytecode(f, 'LOAD_FAST', "a72")
+        # previous checked loads within a basicblock enable unchecked loads
+        self.assertInBytecode(f, 'LOAD_FAST_CHECK', "a73")
+        self.assertInBytecode(f, 'LOAD_FAST', "a73")
+
+    def test_setting_lineno_no_undefined(self):
+        code = textwrap.dedent("""\
+            def f():
+                x = y = 2
+                if not x:
+                    return 4
+                for i in range(55):
+                    x + 6
+                L = 7
+                L = 8
+                L = 9
+                L = 10
+        """)
+        ns = {}
+        exec(code, ns)
+        f = ns['f']
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        co_code = f.__code__.co_code
+        def trace(frame, event, arg):
+            if event == 'line' and frame.f_lineno == 9:
+                frame.f_lineno = 3
+                sys.settrace(None)
+                return None
+            return trace
+        sys.settrace(trace)
+        result = f()
+        self.assertIsNone(result)
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        self.assertEqual(f.__code__.co_code, co_code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_setting_lineno_one_undefined(self):
+        code = textwrap.dedent("""\
+            def f():
+                x = y = 2
+                if not x:
+                    return 4
+                for i in range(55):
+                    x + 6
+                del x
+                L = 8
+                L = 9
+                L = 10
+        """)
+        ns = {}
+        exec(code, ns)
+        f = ns['f']
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        co_code = f.__code__.co_code
+        def trace(frame, event, arg):
+            if event == 'line' and frame.f_lineno == 9:
+                frame.f_lineno = 3
+                sys.settrace(None)
+                return None
+            return trace
+        e = r"assigning None to 1 unbound local"
+        with self.assertWarnsRegex(RuntimeWarning, e):
+            sys.settrace(trace)
+            result = f()
+        self.assertEqual(result, 4)
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        self.assertEqual(f.__code__.co_code, co_code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_setting_lineno_two_undefined(self):
+        code = textwrap.dedent("""\
+            def f():
+                x = y = 2
+                if not x:
+                    return 4
+                for i in range(55):
+                    x + 6
+                del x, y
+                L = 8
+                L = 9
+                L = 10
+        """)
+        ns = {}
+        exec(code, ns)
+        f = ns['f']
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        co_code = f.__code__.co_code
+        def trace(frame, event, arg):
+            if event == 'line' and frame.f_lineno == 9:
+                frame.f_lineno = 3
+                sys.settrace(None)
+                return None
+            return trace
+        e = r"assigning None to 2 unbound locals"
+        with self.assertWarnsRegex(RuntimeWarning, e):
+            sys.settrace(trace)
+            result = f()
+        self.assertEqual(result, 4)
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        self.assertEqual(f.__code__.co_code, co_code)
+
+    def make_function_with_no_checks(self):
+        code = textwrap.dedent("""\
+            def f():
+                x = 2
+                L = 3
+                L = 4
+                L = 5
+                if not L:
+                    x + 7
+                    y = 2
+        """)
+        ns = {}
+        exec(code, ns)
+        f = ns['f']
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+        return f
+
+    def test_modifying_local_does_not_add_check(self):
+        f = self.make_function_with_no_checks()
+        def trace(frame, event, arg):
+            if event == 'line' and frame.f_lineno == 4:
+                frame.f_locals["x"] = 42
+                sys.settrace(None)
+                return None
+            return trace
+        sys.settrace(trace)
+        f()
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+
+    def test_initializing_local_does_not_add_check(self):
+        f = self.make_function_with_no_checks()
+        def trace(frame, event, arg):
+            if event == 'line' and frame.f_lineno == 4:
+                frame.f_locals["y"] = 42
+                sys.settrace(None)
+                return None
+            return trace
+        sys.settrace(trace)
+        f()
+        self.assertInBytecode(f, "LOAD_FAST")
+        self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
+
+
+class DirectCfgOptimizerTests(CfgOptimizationTestCase):
+
+    def cfg_optimization_test(self, insts, expected_insts,
+                              consts=None, expected_consts=None,
+                              nlocals=0):
+
+        self.check_instructions(insts)
+        self.check_instructions(expected_insts)
+
+        if expected_consts is None:
+            expected_consts = consts
+        seq = self.seq_from_insts(insts)
+        opt_insts, opt_consts = self.get_optimized(seq, consts, nlocals)
+        expected_insts = self.seq_from_insts(expected_insts).get_instructions()
+        self.assertInstructionsMatch(opt_insts, expected_insts)
+        self.assertEqual(opt_consts, expected_consts)
+
+    def test_conditional_jump_forward_non_const_condition(self):
+        insts = [
+            ('LOAD_NAME', 1, 11),
+            ('POP_JUMP_IF_TRUE', lbl := self.Label(), 12),
+            ('LOAD_CONST', 2, 13),
+            ('RETURN_VALUE', None, 13),
+            lbl,
+            ('LOAD_CONST', 3, 14),
+            ('RETURN_VALUE', None, 14),
+        ]
+        expected_insts = [
+            ('LOAD_NAME', 1, 11),
+            ('POP_JUMP_IF_TRUE', lbl := self.Label(), 12),
+            ('RETURN_CONST', 1, 13),
+            lbl,
+            ('RETURN_CONST', 2, 14),
+        ]
+        self.cfg_optimization_test(insts,
+                                   expected_insts,
+                                   consts=[0, 1, 2, 3, 4],
+                                   expected_consts=[0, 2, 3])
+
+    def test_conditional_jump_forward_const_condition(self):
+        # The unreachable branch of the jump is removed, the jump
+        # becomes redundant and is replaced by a NOP (for the lineno)
+
+        insts = [
+            ('LOAD_CONST', 3, 11),
+            ('POP_JUMP_IF_TRUE', lbl := self.Label(), 12),
+            ('LOAD_CONST', 2, 13),
+            lbl,
+            ('LOAD_CONST', 3, 14),
+            ('RETURN_VALUE', None, 14),
+        ]
+        expected_insts = [
+            ('NOP', None, 11),
+            ('NOP', None, 12),
+            ('RETURN_CONST', 1, 14),
+        ]
+        self.cfg_optimization_test(insts,
+                                   expected_insts,
+                                   consts=[0, 1, 2, 3, 4],
+                                   expected_consts=[0, 3])
+
+    def test_conditional_jump_backward_non_const_condition(self):
+        insts = [
+            lbl1 := self.Label(),
+            ('LOAD_NAME', 1, 11),
+            ('POP_JUMP_IF_TRUE', lbl1, 12),
+            ('LOAD_NAME', 2, 13),
+            ('RETURN_VALUE', None, 13),
+        ]
+        expected = [
+            lbl := self.Label(),
+            ('LOAD_NAME', 1, 11),
+            ('POP_JUMP_IF_TRUE', lbl, 12),
+            ('LOAD_NAME', 2, 13),
+            ('RETURN_VALUE', None, 13),
+        ]
+        self.cfg_optimization_test(insts, expected, consts=list(range(5)))
+
+    def test_conditional_jump_backward_const_condition(self):
+        # The unreachable branch of the jump is removed
+        insts = [
+            lbl1 := self.Label(),
+            ('LOAD_CONST', 3, 11),
+            ('POP_JUMP_IF_TRUE', lbl1, 12),
+            ('LOAD_CONST', 2, 13),
+            ('RETURN_VALUE', None, 13),
+        ]
+        expected_insts = [
+            lbl := self.Label(),
+            ('NOP', None, 11),
+            ('JUMP', lbl, 12),
+        ]
+        self.cfg_optimization_test(insts, expected_insts, consts=list(range(5)))
+
+    def test_except_handler_label(self):
+        insts = [
+            ('SETUP_FINALLY', handler := self.Label(), 10),
+            ('POP_BLOCK', None, -1),
+            ('RETURN_CONST', 1, 11),
+            handler,
+            ('RETURN_CONST', 2, 12),
+        ]
+        expected_insts = [
+            ('SETUP_FINALLY', handler := self.Label(), 10),
+            ('RETURN_CONST', 1, 11),
+            handler,
+            ('RETURN_CONST', 2, 12),
+        ]
+        self.cfg_optimization_test(insts, expected_insts, consts=list(range(5)))
+
+    def test_no_unsafe_static_swap(self):
+        # We can't change order of two stores to the same location
+        insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('LOAD_CONST', 2, 3),
+            ('SWAP', 3, 4),
+            ('STORE_FAST', 1, 4),
+            ('STORE_FAST', 1, 4),
+            ('POP_TOP', None, 4),
+            ('LOAD_CONST', 0, 5),
+            ('RETURN_VALUE', None, 5)
+        ]
+        expected_insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('NOP', None, 3),
+            ('STORE_FAST', 1, 4),
+            ('POP_TOP', None, 4),
+            ('RETURN_CONST', 0)
+        ]
+        self.cfg_optimization_test(insts, expected_insts, consts=list(range(3)), nlocals=1)
+
+    def test_dead_store_elimination_in_same_lineno(self):
+        insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('LOAD_CONST', 2, 3),
+            ('STORE_FAST', 1, 4),
+            ('STORE_FAST', 1, 4),
+            ('STORE_FAST', 1, 4),
+            ('LOAD_CONST', 0, 5),
+            ('RETURN_VALUE', None, 5)
+        ]
+        expected_insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('NOP', None, 3),
+            ('POP_TOP', None, 4),
+            ('STORE_FAST', 1, 4),
+            ('RETURN_CONST', 0, 5)
+        ]
+        self.cfg_optimization_test(insts, expected_insts, consts=list(range(3)), nlocals=1)
+
+    def test_no_dead_store_elimination_in_different_lineno(self):
+        insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('LOAD_CONST', 2, 3),
+            ('STORE_FAST', 1, 4),
+            ('STORE_FAST', 1, 5),
+            ('STORE_FAST', 1, 6),
+            ('LOAD_CONST', 0, 5),
+            ('RETURN_VALUE', None, 5)
+        ]
+        expected_insts = [
+            ('LOAD_CONST', 0, 1),
+            ('LOAD_CONST', 1, 2),
+            ('LOAD_CONST', 2, 3),
+            ('STORE_FAST', 1, 4),
+            ('STORE_FAST', 1, 5),
+            ('STORE_FAST', 1, 6),
+            ('RETURN_CONST', 0, 5)
+        ]
+        self.cfg_optimization_test(insts, expected_insts, consts=list(range(3)), nlocals=1)
+
+    def test_unconditional_jump_threading(self):
+
+        def get_insts(lno1, lno2, op1, op2):
+            return [
+                       lbl2 := self.Label(),
+                       ('LOAD_NAME', 0, 10),
+                       (op1, lbl1 := self.Label(), lno1),
+                       ('LOAD_NAME', 1, 20),
+                       lbl1,
+                       (op2, lbl2, lno2),
+                   ]
+
+
+        for op1 in ('JUMP', 'JUMP_NO_INTERRUPT'):
+            for op2 in ('JUMP', 'JUMP_NO_INTERRUPT'):
+                # different lines
+                lno1, lno2 = (4, 5)
+                with self.subTest(lno = (lno1, lno2), ops = (op1, op2)):
+                    insts = get_insts(lno1, lno2, op1, op2)
+                    op = 'JUMP' if 'JUMP' in (op1, op2) else 'JUMP_NO_INTERRUPT'
+                    expected_insts = [
+                        ('LOAD_NAME', 0, 10),
+                        ('NOP', None, 4),
+                        (op, 0, 5),
+                    ]
+                    self.cfg_optimization_test(insts, expected_insts, consts=list(range(5)))
+
+                # Threading
+                for lno1, lno2 in [(-1, -1), (-1, 5), (6, -1), (7, 7)]:
+                    with self.subTest(lno = (lno1, lno2), ops = (op1, op2)):
+                        insts = get_insts(lno1, lno2, op1, op2)
+                        lno = lno1 if lno1 != -1 else lno2
+                        if lno == -1:
+                            lno = 10  # Propagated from the line before
+
+                        op = 'JUMP' if 'JUMP' in (op1, op2) else 'JUMP_NO_INTERRUPT'
+                        expected_insts = [
+                            ('LOAD_NAME', 0, 10),
+                            (op, 0, lno),
+                        ]
+                        self.cfg_optimization_test(insts, expected_insts, consts=list(range(5)))
+
+if __name__ == "__main__":
+    unittest.main()

From 6df3753229b2792f63f84fd2df5275776daf9b2d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 01:02:40 +0900
Subject: [PATCH 344/418] Py 3.14 changes fix (#6755)

* marshal v5

* conditional blclk

* fix jit don't use lossy string

* add varname

* symboltable takes responsibility of __debug__
---
 Cargo.lock                                    |  1 +
 Lib/test/test_future_stmt/test_future.py      |  3 -
 crates/codegen/src/compile.rs                 | 98 +++++++++----------
 crates/codegen/src/ir.rs                      | 10 ++
 crates/codegen/src/symboltable.rs             | 94 +++++++++++++-----
 crates/compiler-core/src/marshal.rs           | 10 +-
 crates/jit/Cargo.toml                         |  1 +
 crates/jit/tests/common.rs                    | 61 +++++++++---
 extra_tests/snippets/syntax_forbidden_name.py | 10 +-
 9 files changed, 198 insertions(+), 90 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1ce839a96d6..41ab3280428 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3104,6 +3104,7 @@ dependencies = [
  "num-traits",
  "rustpython-compiler-core",
  "rustpython-derive",
+ "rustpython-wtf8",
  "thiserror 2.0.17",
 ]
 
diff --git a/Lib/test/test_future_stmt/test_future.py b/Lib/test/test_future_stmt/test_future.py
index febd9fb095a..e57c7227cec 100644
--- a/Lib/test/test_future_stmt/test_future.py
+++ b/Lib/test/test_future_stmt/test_future.py
@@ -459,9 +459,6 @@ def test_infinity_numbers(self):
         self.assertAnnotationEqual("('inf', 1e1000, 'infxxx', 1e1000j)", expected=f"('inf', {inf}, 'infxxx', {infj})")
         self.assertAnnotationEqual("(1e1000, (1e1000j,))", expected=f"({inf}, ({infj},))")
 
-    # TODO: RUSTPYTHON
-    # AssertionError: SyntaxError not raised
-    @unittest.expectedFailure
     def test_annotation_with_complex_target(self):
         with self.assertRaises(SyntaxError):
             exec(
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index d479c0d0e69..c531c5ff258 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -110,14 +110,6 @@ enum NameUsage {
     Store,
     Delete,
 }
-
-fn is_forbidden_name(name: &str) -> bool {
-    // See https://docs.python.org/3/library/constants.html#built-in-constants
-    const BUILTIN_CONSTANTS: &[&str] = &["__debug__"];
-
-    BUILTIN_CONSTANTS.contains(&name)
-}
-
 /// Main structure holding the state of compilation.
 struct Compiler {
     code_stack: Vec<ir::CodeInfo>,
@@ -130,10 +122,6 @@ struct Compiler {
     ctx: CompileContext,
     opts: CompileOpts,
     in_annotation: bool,
-    // PEP 649: Track if we're inside a conditional block (if/for/while/etc.)
-    in_conditional_block: bool,
-    // PEP 649: Next index for conditional annotation tracking
-    next_conditional_annotation_index: u32,
 }
 
 enum DoneWithFuture {
@@ -424,6 +412,8 @@ impl Compiler {
             in_inlined_comp: false,
             fblock: Vec::with_capacity(MAXBLOCKS),
             symbol_table_index: 0, // Module is always the first symbol table
+            in_conditional_block: 0,
+            next_conditional_annotation_index: 0,
         };
         Self {
             code_stack: vec![module_code],
@@ -441,8 +431,6 @@ impl Compiler {
             },
             opts,
             in_annotation: false,
-            in_conditional_block: false,
-            next_conditional_annotation_index: 0,
         }
     }
 
@@ -1045,6 +1033,8 @@ impl Compiler {
             in_inlined_comp: false,
             fblock: Vec::with_capacity(MAXBLOCKS),
             symbol_table_index: key,
+            in_conditional_block: 0,
+            next_conditional_annotation_index: 0,
         };
 
         // Push the old compiler unit on the stack (like PyCapsule)
@@ -1525,11 +1515,7 @@ impl Compiler {
         self._name_inner(name, |i| &mut i.metadata.names)
     }
     fn varname(&mut self, name: &str) -> CompileResult<bytecode::NameIdx> {
-        if Self::is_forbidden_arg_name(name) {
-            return Err(self.error(CodegenErrorType::SyntaxError(format!(
-                "cannot assign to {name}",
-            ))));
-        }
+        // Note: __debug__ checks are now handled in symboltable phase
         Ok(self._name_inner(name, |i| &mut i.metadata.varnames))
     }
     fn _name_inner(
@@ -1814,15 +1800,6 @@ impl Compiler {
         symboltable::mangle_name(private, name)
     }
 
-    fn check_forbidden_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
-        let msg = match usage {
-            NameUsage::Store if is_forbidden_name(name) => "cannot assign to",
-            NameUsage::Delete if is_forbidden_name(name) => "cannot delete",
-            _ => return Ok(()),
-        };
-        Err(self.error(CodegenErrorType::SyntaxError(format!("{msg} {name}"))))
-    }
-
     // = compiler_nameop
     fn compile_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
         enum NameOp {
@@ -1834,7 +1811,6 @@ impl Compiler {
         }
 
         let name = self.mangle(name);
-        self.check_forbidden_name(&name, usage)?;
 
         // Special handling for __debug__
         if NameUsage::Load == usage && name == "__debug__" {
@@ -2135,6 +2111,7 @@ impl Compiler {
                 elif_else_clauses,
                 ..
             }) => {
+                self.enter_conditional_block();
                 match elif_else_clauses.as_slice() {
                     // Only if
                     [] => {
@@ -2182,6 +2159,7 @@ impl Compiler {
                         self.switch_to_block(after_block);
                     }
                 }
+                self.leave_conditional_block();
             }
             Stmt::While(StmtWhile {
                 test, body, orelse, ..
@@ -2228,11 +2206,13 @@ impl Compiler {
                 is_star,
                 ..
             }) => {
+                self.enter_conditional_block();
                 if *is_star {
                     self.compile_try_star_except(body, handlers, orelse, finalbody)?
                 } else {
                     self.compile_try_statement(body, handlers, orelse, finalbody)?
                 }
+                self.leave_conditional_block();
             }
             Stmt::FunctionDef(StmtFunctionDef {
                 name,
@@ -2432,7 +2412,6 @@ impl Compiler {
         match &expression {
             Expr::Name(ExprName { id, .. }) => self.compile_name(id.as_str(), NameUsage::Delete)?,
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
                 emit!(self, Instruction::DeleteAttr { idx });
@@ -3451,10 +3430,6 @@ impl Compiler {
         Ok(())
     }
 
-    fn is_forbidden_arg_name(name: &str) -> bool {
-        is_forbidden_name(name)
-    }
-
     /// Compile default arguments
     // = compiler_default_arguments
     fn compile_default_arguments(
@@ -4485,6 +4460,8 @@ impl Compiler {
     }
 
     fn compile_while(&mut self, test: &Expr, body: &[Stmt], orelse: &[Stmt]) -> CompileResult<()> {
+        self.enter_conditional_block();
+
         let while_block = self.new_block();
         let else_block = self.new_block();
         let after_block = self.new_block();
@@ -4513,6 +4490,8 @@ impl Compiler {
         // Note: PopBlock is no longer emitted for loops
         self.compile_statements(orelse)?;
         self.switch_to_block(after_block);
+
+        self.leave_conditional_block();
         Ok(())
     }
 
@@ -4522,6 +4501,8 @@ impl Compiler {
         body: &[Stmt],
         is_async: bool,
     ) -> CompileResult<()> {
+        self.enter_conditional_block();
+
         // Python 3.12+ style with statement:
         //
         // BEFORE_WITH          # TOS: ctx_mgr -> [__exit__, __enter__ result]
@@ -4734,6 +4715,7 @@ impl Compiler {
         // ===== After block =====
         self.switch_to_block(after_block);
 
+        self.leave_conditional_block();
         Ok(())
     }
 
@@ -4745,6 +4727,8 @@ impl Compiler {
         orelse: &[Stmt],
         is_async: bool,
     ) -> CompileResult<()> {
+        self.enter_conditional_block();
+
         // Start loop
         let for_block = self.new_block();
         let else_block = self.new_block();
@@ -4812,6 +4796,7 @@ impl Compiler {
 
         self.switch_to_block(after_block);
 
+        self.leave_conditional_block();
         Ok(())
     }
 
@@ -5784,8 +5769,10 @@ impl Compiler {
     }
 
     fn compile_match(&mut self, subject: &Expr, cases: &[MatchCase]) -> CompileResult<()> {
+        self.enter_conditional_block();
         let mut pattern_context = PatternContext::new();
         self.compile_match_inner(subject, cases, &mut pattern_context)?;
+        self.leave_conditional_block();
         Ok(())
     }
 
@@ -5946,16 +5933,22 @@ impl Compiler {
             } else {
                 // PEP 649: Handle conditional annotations
                 if self.current_symbol_table().has_conditional_annotations {
-                    // Determine if this annotation is conditional
-                    let is_module = self.current_symbol_table().typ == CompilerScope::Module;
-                    let is_conditional = is_module || self.in_conditional_block;
+                    // Allocate an index for every annotation when has_conditional_annotations
+                    // This keeps indices aligned with compile_module_annotate's enumeration
+                    let code_info = self.current_code_info();
+                    let annotation_index = code_info.next_conditional_annotation_index;
+                    code_info.next_conditional_annotation_index += 1;
 
+                    // Determine if this annotation is conditional
+                    // Module and Class scopes both need all annotations tracked
+                    let scope_type = self.current_symbol_table().typ;
+                    let in_conditional_block = self.current_code_info().in_conditional_block > 0;
+                    let is_conditional =
+                        matches!(scope_type, CompilerScope::Module | CompilerScope::Class)
+                            || in_conditional_block;
+
+                    // Only add to __conditional_annotations__ set if actually conditional
                     if is_conditional {
-                        // Get the current annotation index and increment
-                        let annotation_index = self.next_conditional_annotation_index;
-                        self.next_conditional_annotation_index += 1;
-
-                        // Add index to __conditional_annotations__ set
                         let cond_annotations_name = self.name("__conditional_annotations__");
                         emit!(self, Instruction::LoadName(cond_annotations_name));
                         self.emit_load_const(ConstantData::Integer {
@@ -5980,7 +5973,6 @@ impl Compiler {
                 self.compile_subscript(value, slice, *ctx)?;
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
                 emit!(self, Instruction::StoreAttr { idx });
@@ -6075,7 +6067,6 @@ impl Compiler {
             }
             Expr::Attribute(ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
-                self.check_forbidden_name(attr, NameUsage::Store)?;
                 self.compile_expression(value)?;
                 emit!(self, Instruction::Copy { index: 1_u32 });
                 let idx = self.name(attr);
@@ -6903,12 +6894,6 @@ impl Compiler {
         let (size, unpack) = self.gather_elements(additional_positional, &arguments.args)?;
         let has_double_star = arguments.keywords.iter().any(|k| k.arg.is_none());
 
-        for keyword in &arguments.keywords {
-            if let Some(name) = &keyword.arg {
-                self.check_forbidden_name(name.as_str(), NameUsage::Store)?;
-            }
-        }
-
         if unpack || has_double_star {
             // Create a tuple with positional args:
             if unpack {
@@ -7511,6 +7496,19 @@ impl Compiler {
         self.code_stack.last_mut().expect("no code on stack")
     }
 
+    /// Enter a conditional block (if/for/while/match/try/with)
+    /// PEP 649: Track conditional annotation context
+    fn enter_conditional_block(&mut self) {
+        self.current_code_info().in_conditional_block += 1;
+    }
+
+    /// Leave a conditional block
+    fn leave_conditional_block(&mut self) {
+        let code_info = self.current_code_info();
+        debug_assert!(code_info.in_conditional_block > 0);
+        code_info.in_conditional_block -= 1;
+    }
+
     /// Compile break or continue statement with proper fblock cleanup.
     /// compiler_break, compiler_continue
     /// This handles unwinding through With blocks and exception handlers.
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 8935f2063c3..bb350abeebf 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -145,6 +145,14 @@ pub struct CodeInfo {
 
     // Reference to the symbol table for this scope
     pub symbol_table_index: usize,
+
+    // PEP 649: Track nesting depth inside conditional blocks (if/for/while/etc.)
+    // u_in_conditional_block
+    pub in_conditional_block: u32,
+
+    // PEP 649: Next index for conditional annotation tracking
+    // u_next_conditional_annotation_index
+    pub next_conditional_annotation_index: u32,
 }
 
 impl CodeInfo {
@@ -171,6 +179,8 @@ impl CodeInfo {
             in_inlined_comp: _,
             fblock: _,
             symbol_table_index: _,
+            in_conditional_block: _,
+            next_conditional_annotation_index: _,
         } = self;
 
         let CodeUnitMetadata {
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 0bc76b897dc..63b330db92f 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -780,6 +780,8 @@ struct SymbolTableBuilder {
     source_file: SourceFile,
     // Current scope's varnames being collected (temporary storage)
     current_varnames: Vec<String>,
+    // Stack to preserve parent varnames when entering nested scopes
+    varnames_stack: Vec<Vec<String>>,
     // Track if we're inside an iterable definition expression (for nested comprehensions)
     in_iter_def_exp: bool,
     // Track if we're inside an annotation (yield/await/named expr not allowed)
@@ -815,6 +817,7 @@ impl SymbolTableBuilder {
             future_annotations: false,
             source_file,
             current_varnames: Vec::new(),
+            varnames_stack: Vec::new(),
             in_iter_def_exp: false,
             in_annotation: false,
             in_type_alias: false,
@@ -845,8 +848,9 @@ impl SymbolTableBuilder {
             .unwrap_or(false);
         let table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
         self.tables.push(table);
-        // Clear current_varnames for the new scope
-        self.current_varnames.clear();
+        // Save parent's varnames and start fresh for the new scope
+        self.varnames_stack
+            .push(core::mem::take(&mut self.current_varnames));
     }
 
     fn enter_type_param_block(&mut self, name: &str, line_number: u32) -> SymbolTableResult {
@@ -880,6 +884,8 @@ impl SymbolTableBuilder {
         // Save the collected varnames to the symbol table
         table.varnames = core::mem::take(&mut self.current_varnames);
         self.tables.last_mut().unwrap().sub_tables.push(table);
+        // Restore parent's varnames
+        self.current_varnames = self.varnames_stack.pop().unwrap_or_default();
     }
 
     /// Enter annotation scope (PEP 649)
@@ -907,7 +913,10 @@ impl SymbolTableBuilder {
         // Take the annotation block and push to stack for processing
         let annotation_table = current.annotation_block.take().unwrap();
         self.tables.push(*annotation_table);
-        self.current_varnames.clear();
+        // Save parent's varnames and seed with existing annotation varnames (e.g., "format")
+        self.varnames_stack
+            .push(core::mem::take(&mut self.current_varnames));
+        self.current_varnames = self.tables.last().unwrap().varnames.clone();
 
         if can_see_class_scope && !self.future_annotations {
             self.add_classdict_freevar();
@@ -927,6 +936,8 @@ impl SymbolTableBuilder {
         // Store back to parent's annotation_block (not sub_tables)
         let parent = self.tables.last_mut().unwrap();
         parent.annotation_block = Some(Box::new(table));
+        // Restore parent's varnames
+        self.current_varnames = self.varnames_stack.pop().unwrap_or_default();
     }
 
     fn add_classdict_freevar(&mut self) {
@@ -977,6 +988,12 @@ impl SymbolTableBuilder {
     }
 
     fn scan_parameter(&mut self, parameter: &Parameter) -> SymbolTableResult {
+        self.check_name(
+            parameter.name.as_str(),
+            ExpressionContext::Store,
+            parameter.name.range,
+        )?;
+
         let usage = if parameter.annotation.is_some() {
             SymbolUsage::AnnotationParameter
         } else {
@@ -1239,6 +1256,7 @@ impl SymbolTableBuilder {
                 for name in names {
                     if let Some(alias) = &name.asname {
                         // `import my_module as my_alias`
+                        self.check_name(alias.as_str(), ExpressionContext::Store, alias.range)?;
                         self.register_ident(alias, SymbolUsage::Imported)?;
                     } else if name.name.as_str() == "*" {
                         // Star imports are only allowed at module level
@@ -1253,12 +1271,10 @@ impl SymbolTableBuilder {
                         }
                         // Don't register star imports as symbols
                     } else {
-                        // `import module`
-                        self.register_name(
-                            name.name.split('.').next().unwrap(),
-                            SymbolUsage::Imported,
-                            name.name.range,
-                        )?;
+                        // `import module` or `from x import name`
+                        let imported_name = name.name.split('.').next().unwrap();
+                        self.check_name(imported_name, ExpressionContext::Store, name.name.range)?;
+                        self.register_name(imported_name, SymbolUsage::Imported, name.name.range)?;
                     }
                 }
             }
@@ -1295,7 +1311,11 @@ impl SymbolTableBuilder {
                 // https://github.com/python/cpython/blob/main/Python/symtable.c#L1233
                 match &**target {
                     Expr::Name(ast::ExprName { id, .. }) if *simple => {
-                        self.register_name(id.as_str(), SymbolUsage::AnnotationAssigned, *range)?;
+                        let id_str = id.as_str();
+
+                        self.check_name(id_str, ExpressionContext::Store, *range)?;
+
+                        self.register_name(id_str, SymbolUsage::AnnotationAssigned, *range)?;
                         // PEP 649: Register annotate function in module/class scope
                         let current_scope = self.tables.last().map(|t| t.typ);
                         match current_scope {
@@ -1512,8 +1532,9 @@ impl SymbolTableBuilder {
                 self.scan_expression(slice, ExpressionContext::Load)?;
             }
             Expr::Attribute(ExprAttribute {
-                value, range: _, ..
+                value, attr, range, ..
             }) => {
+                self.check_name(attr.as_str(), context, *range)?;
                 self.scan_expression(value, ExpressionContext::Load)?;
             }
             Expr::Dict(ExprDict {
@@ -1657,11 +1678,17 @@ impl SymbolTableBuilder {
 
                 self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
                 for keyword in &arguments.keywords {
+                    if let Some(arg) = &keyword.arg {
+                        self.check_name(arg.as_str(), ExpressionContext::Store, keyword.range)?;
+                    }
                     self.scan_expression(&keyword.value, ExpressionContext::Load)?;
                 }
             }
             Expr::Name(ExprName { id, range, .. }) => {
                 let id = id.as_str();
+
+                self.check_name(id, context, *range)?;
+
                 // Determine the contextual usage of this symbol:
                 match context {
                     ExpressionContext::Delete => {
@@ -1785,6 +1812,7 @@ impl SymbolTableBuilder {
                 // propagate inner names.
                 if let Expr::Name(ExprName { id, .. }) = &**target {
                     let id = id.as_str();
+                    self.check_name(id, ExpressionContext::Store, *range)?;
                     let table = self.tables.last().unwrap();
                     if table.typ == CompilerScope::Comprehension {
                         self.register_name(
@@ -2150,6 +2178,37 @@ impl SymbolTableBuilder {
         self.register_name(ident.as_str(), role, ident.range)
     }
 
+    fn check_name(
+        &self,
+        name: &str,
+        context: ExpressionContext,
+        range: TextRange,
+    ) -> SymbolTableResult {
+        if name == "__debug__" {
+            let location = Some(
+                self.source_file
+                    .to_source_code()
+                    .source_location(range.start(), PositionEncoding::Utf8),
+            );
+            match context {
+                ExpressionContext::Store | ExpressionContext::Iter => {
+                    return Err(SymbolTableError {
+                        error: "cannot assign to __debug__".to_owned(),
+                        location,
+                    });
+                }
+                ExpressionContext::Delete => {
+                    return Err(SymbolTableError {
+                        error: "cannot delete __debug__".to_owned(),
+                        location,
+                    });
+                }
+                _ => {}
+            }
+        }
+        Ok(())
+    }
+
     fn register_name(
         &mut self,
         name: &str,
@@ -2162,18 +2221,7 @@ impl SymbolTableBuilder {
             .source_location(range.start(), PositionEncoding::Utf8);
         let location = Some(location);
 
-        // Check for forbidden names like __debug__
-        if name == "__debug__"
-            && matches!(
-                role,
-                SymbolUsage::Parameter | SymbolUsage::AnnotationParameter | SymbolUsage::Assigned
-            )
-        {
-            return Err(SymbolTableError {
-                error: "cannot assign to __debug__".to_owned(),
-                location,
-            });
-        }
+        // Note: __debug__ checks are handled by check_name function, so no check needed here.
 
         let scope_depth = self.tables.len();
         let table = self.tables.last_mut().unwrap();
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
index d9bf368ecab..6a6100ca003 100644
--- a/crates/compiler-core/src/marshal.rs
+++ b/crates/compiler-core/src/marshal.rs
@@ -4,7 +4,7 @@ use malachite_bigint::{BigInt, Sign};
 use num_complex::Complex64;
 use rustpython_wtf8::Wtf8;
 
-pub const FORMAT_VERSION: u32 = 4;
+pub const FORMAT_VERSION: u32 = 5;
 
 #[derive(Debug)]
 pub enum MarshalError {
@@ -65,6 +65,7 @@ enum Type {
     // Unknown = b'?',
     Set = b'<',
     FrozenSet = b'>',
+    Slice = b':', // Added in version 5
     Ascii = b'a',
     // AsciiInterned = b'A',
     // SmallTuple = b')',
@@ -101,6 +102,7 @@ impl TryFrom<u8> for Type {
             // b'?' => Unknown,
             b'<' => Set,
             b'>' => FrozenSet,
+            b':' => Slice,
             b'a' => Ascii,
             // b'A' => AsciiInterned,
             // b')' => SmallTuple,
@@ -466,6 +468,12 @@ pub fn deserialize_value<R: Read, Bag: MarshalBag>(rdr: &mut R, bag: Bag) -> Res
             bag.make_bytes(value)
         }
         Type::Code => bag.make_code(deserialize_code(rdr, bag.constant_bag())?),
+        Type::Slice => {
+            // Slice constants are not yet supported in RustPython
+            // This would require adding a Slice variant to ConstantData enum
+            // For now, return an error if we encounter a slice in marshal data
+            return Err(MarshalError::BadType);
+        }
     };
     Ok(value)
 }
diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
index fde10b7c006..77776e9eefe 100644
--- a/crates/jit/Cargo.toml
+++ b/crates/jit/Cargo.toml
@@ -23,6 +23,7 @@ cranelift-module = "0.127"
 
 [dev-dependencies]
 rustpython-derive = { workspace = true }
+rustpython-wtf8 = { workspace = true }
 
 approx = "0.5.1"
 
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index da324088d32..ef5a25f0843 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -3,19 +3,20 @@ use rustpython_compiler_core::bytecode::{
     CodeObject, ConstantData, Instruction, OpArg, OpArgState,
 };
 use rustpython_jit::{CompiledCode, JitType};
+use rustpython_wtf8::{Wtf8, Wtf8Buf};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone)]
 pub struct Function {
     code: Box<CodeObject>,
-    annotations: HashMap<String, StackValue>,
+    annotations: HashMap<Wtf8Buf, StackValue>,
 }
 
 impl Function {
     pub fn compile(self) -> CompiledCode {
         let mut arg_types = Vec::new();
         for arg in self.code.arg_names().args {
-            let arg_type = match self.annotations.get(arg) {
+            let arg_type = match self.annotations.get(AsRef::<Wtf8>::as_ref(arg.as_str())) {
                 Some(StackValue::String(annotation)) => match annotation.as_str() {
                     "int" => JitType::Int,
                     "float" => JitType::Float,
@@ -27,7 +28,7 @@ impl Function {
             arg_types.push(arg_type);
         }
 
-        let ret_type = match self.annotations.get("return") {
+        let ret_type = match self.annotations.get(AsRef::<Wtf8>::as_ref("return")) {
             Some(StackValue::String(annotation)) => match annotation.as_str() {
                 "int" => Some(JitType::Int),
                 "float" => Some(JitType::Float),
@@ -45,7 +46,7 @@ impl Function {
 enum StackValue {
     String(String),
     None,
-    Map(HashMap<String, StackValue>),
+    Map(HashMap<Wtf8Buf, StackValue>),
     Code(Box<CodeObject>),
     Function(Function),
 }
@@ -66,7 +67,7 @@ impl From<ConstantData> for StackValue {
 /// Extract annotations from an annotate function's bytecode.
 /// The annotate function uses BUILD_MAP with key-value pairs loaded before it.
 /// Keys are parameter names (from LOAD_CONST), values are type names (from LOAD_NAME/LOAD_GLOBAL).
-fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<String, StackValue> {
+fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf, StackValue> {
     let mut annotations = HashMap::new();
     let mut stack: Vec<(bool, usize)> = Vec::new(); // (is_const, index)
     let mut op_arg_state = OpArgState::default();
@@ -91,17 +92,55 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<String,
                 for chunk in pairs.chunks(2) {
                     if chunk.len() == 2 {
                         let (key_is_const, key_idx) = chunk[0];
-                        let (_val_is_const, val_idx) = chunk[1];
+                        let (val_is_const, val_idx) = chunk[1];
 
                         // Key should be a const string (parameter name)
                         if key_is_const
                             && let ConstantData::Str { value } = &code.constants[key_idx]
                         {
-                            let param_name = value.to_string_lossy().into_owned();
-                            // Value should be a name (type name)
-                            if let Some(type_name) = code.names.get(val_idx) {
+                            let param_name = value;
+                            // Value can be a name (type ref) or a const string (forward ref)
+                            let type_name = if val_is_const {
+                                match code.constants.get(val_idx) {
+                                    Some(ConstantData::Str { value }) => {
+                                        Some(value.as_str().map(|s| s.to_owned()).unwrap_or_else(
+                                            |_| value.to_string_lossy().into_owned(),
+                                        ))
+                                    }
+                                    Some(other) => {
+                                        eprintln!(
+                                            "Warning: Malformed annotation for '{:?}': expected string constant at index {}, got {:?}",
+                                            param_name, val_idx, other
+                                        );
+                                        None
+                                    }
+                                    None => {
+                                        eprintln!(
+                                            "Warning: Malformed annotation for '{:?}': constant index {} out of bounds (len={})",
+                                            param_name,
+                                            val_idx,
+                                            code.constants.len()
+                                        );
+                                        None
+                                    }
+                                }
+                            } else {
+                                match code.names.get(val_idx) {
+                                    Some(name) => Some(name.clone()),
+                                    None => {
+                                        eprintln!(
+                                            "Warning: Malformed annotation for '{}': name index {} out of bounds (len={})",
+                                            param_name,
+                                            val_idx,
+                                            code.names.len()
+                                        );
+                                        None
+                                    }
+                                }
+                            };
+                            if let Some(type_name) = type_name {
                                 annotations
-                                    .insert(param_name, StackValue::String(type_name.clone()));
+                                    .insert(param_name.clone(), StackValue::String(type_name));
                             }
                         }
                     }
@@ -183,7 +222,7 @@ impl StackMachine {
                 for _ in 0..size.get(arg) {
                     let value = self.stack.pop().unwrap();
                     let name = if let Some(StackValue::String(name)) = self.stack.pop() {
-                        name
+                        Wtf8Buf::from(name)
                     } else {
                         unimplemented!("no string keys isn't yet supported in py_function!")
                     };
diff --git a/extra_tests/snippets/syntax_forbidden_name.py b/extra_tests/snippets/syntax_forbidden_name.py
index 2e114fe8800..3bd8148436e 100644
--- a/extra_tests/snippets/syntax_forbidden_name.py
+++ b/extra_tests/snippets/syntax_forbidden_name.py
@@ -21,6 +21,12 @@ def raisesSyntaxError(parse_stmt, exec_stmt=None):
 raisesSyntaxError("", "del __debug__")
 raisesSyntaxError("", "(a, __debug__, c) = (1, 2, 3)")
 raisesSyntaxError("", "(a, *__debug__, c) = (1, 2, 3)")
+raisesSyntaxError("", "__debug__ : int")
+raisesSyntaxError("", "__debug__ : int = 1")
 
-# TODO:
-#  raisesSyntaxError("", "__debug__ : int")
+# Import statements
+raisesSyntaxError("import sys as __debug__")
+raisesSyntaxError("from sys import path as __debug__")
+
+# Comprehension iteration targets
+raisesSyntaxError("[x for __debug__ in range(5)]")

From 8ce5f49908d6f43ad52c0eadec2122af0f75cb17 Mon Sep 17 00:00:00 2001
From: Shahar Naveh <50263213+ShaharNaveh@users.noreply.github.com>
Date: Sat, 17 Jan 2026 18:23:34 +0200
Subject: [PATCH 345/418] Update `graphlib, heapq, ipaddress` to 3.14.2 (#6758)

---
 Lib/graphlib.py            |  16 +--
 Lib/heapq.py               |  74 +++++++-------
 Lib/ipaddress.py           | 109 ++++++++------------
 Lib/test/test_graphlib.py  |  14 ++-
 Lib/test/test_heapq.py     | 197 ++++++++++++++++++++++++++++++++++---
 Lib/test/test_ipaddress.py |  40 ++++++++
 6 files changed, 328 insertions(+), 122 deletions(-)

diff --git a/Lib/graphlib.py b/Lib/graphlib.py
index 9512865a8e5..7961c9c5cac 100644
--- a/Lib/graphlib.py
+++ b/Lib/graphlib.py
@@ -90,20 +90,24 @@ def prepare(self):
         still be used to obtain as many nodes as possible until cycles block more
         progress. After a call to this function, the graph cannot be modified and
         therefore no more nodes can be added using "add".
+
+        Raise ValueError if nodes have already been passed out of the sorter.
+
         """
-        if self._ready_nodes is not None:
-            raise ValueError("cannot prepare() more than once")
+        if self._npassedout > 0:
+            raise ValueError("cannot prepare() after starting sort")
 
-        self._ready_nodes = [
-            i.node for i in self._node2info.values() if i.npredecessors == 0
-        ]
+        if self._ready_nodes is None:
+            self._ready_nodes = [
+                i.node for i in self._node2info.values() if i.npredecessors == 0
+            ]
         # ready_nodes is set before we look for cycles on purpose:
         # if the user wants to catch the CycleError, that's fine,
         # they can continue using the instance to grab as many
         # nodes as possible before cycles block more progress
         cycle = self._find_cycle()
         if cycle:
-            raise CycleError(f"nodes are in a cycle", cycle)
+            raise CycleError("nodes are in a cycle", cycle)
 
     def get_ready(self):
         """Return a tuple of all the nodes that are ready.
diff --git a/Lib/heapq.py b/Lib/heapq.py
index 2fd9d1ff4bf..17f62dd2d58 100644
--- a/Lib/heapq.py
+++ b/Lib/heapq.py
@@ -42,7 +42,7 @@
 property of a heap is that a[0] is always its smallest element.
 
 The strange invariant above is meant to be an efficient memory
-representation for a tournament.  The numbers below are `k', not a[k]:
+representation for a tournament.  The numbers below are 'k', not a[k]:
 
                                    0
 
@@ -55,7 +55,7 @@
     15 16   17 18   19 20   21 22   23 24   25 26   27 28   29 30
 
 
-In the tree above, each cell `k' is topping `2*k+1' and `2*k+2'.  In
+In the tree above, each cell 'k' is topping '2*k+1' and '2*k+2'.  In
 a usual binary tournament we see in sports, each cell is the winner
 over the two cells it tops, and we can trace the winner down the tree
 to see all opponents s/he had.  However, in many computer applications
@@ -78,7 +78,7 @@
 not "better" than the last 0'th element you extracted.  This is
 especially useful in simulation contexts, where the tree holds all
 incoming events, and the "win" condition means the smallest scheduled
-time.  When an event schedule other events for execution, they are
+time.  When an event schedules other events for execution, they are
 scheduled into the future, so they can easily go into the heap.  So, a
 heap is a good structure for implementing schedulers (this is what I
 used for my MIDI sequencer :-).
@@ -91,14 +91,14 @@
 
 Heaps are also very useful in big disk sorts.  You most probably all
 know that a big sort implies producing "runs" (which are pre-sorted
-sequences, which size is usually related to the amount of CPU memory),
+sequences, whose size is usually related to the amount of CPU memory),
 followed by a merging passes for these runs, which merging is often
 very cleverly organised[1].  It is very important that the initial
 sort produces the longest runs possible.  Tournaments are a good way
-to that.  If, using all the memory available to hold a tournament, you
-replace and percolate items that happen to fit the current run, you'll
-produce runs which are twice the size of the memory for random input,
-and much better for input fuzzily ordered.
+to achieve that.  If, using all the memory available to hold a
+tournament, you replace and percolate items that happen to fit the
+current run, you'll produce runs which are twice the size of the
+memory for random input, and much better for input fuzzily ordered.
 
 Moreover, if you output the 0'th item on disk and get an input which
 may not fit in the current tournament (because the value "wins" over
@@ -110,7 +110,7 @@
 effective!
 
 In a word, heaps are useful memory structures to know.  I use them in
-a few applications, and I think it is good to keep a `heap' module
+a few applications, and I think it is good to keep a 'heap' module
 around. :-)
 
 --------------------
@@ -126,8 +126,9 @@
 From all times, sorting has always been a Great Art! :-)
 """
 
-__all__ = ['heappush', 'heappop', 'heapify', 'heapreplace', 'merge',
-           'nlargest', 'nsmallest', 'heappushpop']
+__all__ = ['heappush', 'heappop', 'heapify', 'heapreplace', 'heappushpop',
+           'heappush_max', 'heappop_max', 'heapify_max', 'heapreplace_max',
+           'heappushpop_max', 'nlargest', 'nsmallest', 'merge']
 
 def heappush(heap, item):
     """Push item onto heap, maintaining the heap invariant."""
@@ -178,7 +179,7 @@ def heapify(x):
     for i in reversed(range(n//2)):
         _siftup(x, i)
 
-def _heappop_max(heap):
+def heappop_max(heap):
     """Maxheap version of a heappop."""
     lastelt = heap.pop()    # raises appropriate IndexError if heap is empty
     if heap:
@@ -188,19 +189,32 @@ def _heappop_max(heap):
         return returnitem
     return lastelt
 
-def _heapreplace_max(heap, item):
+def heapreplace_max(heap, item):
     """Maxheap version of a heappop followed by a heappush."""
     returnitem = heap[0]    # raises appropriate IndexError if heap is empty
     heap[0] = item
     _siftup_max(heap, 0)
     return returnitem
 
-def _heapify_max(x):
+def heappush_max(heap, item):
+    """Maxheap version of a heappush."""
+    heap.append(item)
+    _siftdown_max(heap, 0, len(heap)-1)
+
+def heappushpop_max(heap, item):
+    """Maxheap fast version of a heappush followed by a heappop."""
+    if heap and item < heap[0]:
+        item, heap[0] = heap[0], item
+        _siftup_max(heap, 0)
+    return item
+
+def heapify_max(x):
     """Transform list into a maxheap, in-place, in O(len(x)) time."""
     n = len(x)
     for i in reversed(range(n//2)):
         _siftup_max(x, i)
 
+
 # 'heap' is a heap at all indices >= startpos, except possibly for pos.  pos
 # is the index of a leaf with a possibly out-of-order value.  Restore the
 # heap invariant.
@@ -335,9 +349,9 @@ def merge(*iterables, key=None, reverse=False):
     h_append = h.append
 
     if reverse:
-        _heapify = _heapify_max
-        _heappop = _heappop_max
-        _heapreplace = _heapreplace_max
+        _heapify = heapify_max
+        _heappop = heappop_max
+        _heapreplace = heapreplace_max
         direction = -1
     else:
         _heapify = heapify
@@ -490,10 +504,10 @@ def nsmallest(n, iterable, key=None):
         result = [(elem, i) for i, elem in zip(range(n), it)]
         if not result:
             return result
-        _heapify_max(result)
+        heapify_max(result)
         top = result[0][0]
         order = n
-        _heapreplace = _heapreplace_max
+        _heapreplace = heapreplace_max
         for elem in it:
             if elem < top:
                 _heapreplace(result, (elem, order))
@@ -507,10 +521,10 @@ def nsmallest(n, iterable, key=None):
     result = [(key(elem), i, elem) for i, elem in zip(range(n), it)]
     if not result:
         return result
-    _heapify_max(result)
+    heapify_max(result)
     top = result[0][0]
     order = n
-    _heapreplace = _heapreplace_max
+    _heapreplace = heapreplace_max
     for elem in it:
         k = key(elem)
         if k < top:
@@ -583,19 +597,13 @@ def nlargest(n, iterable, key=None):
     from _heapq import *
 except ImportError:
     pass
-try:
-    from _heapq import _heapreplace_max
-except ImportError:
-    pass
-try:
-    from _heapq import _heapify_max
-except ImportError:
-    pass
-try:
-    from _heapq import _heappop_max
-except ImportError:
-    pass
 
+# For backwards compatibility
+_heappop_max  = heappop_max
+_heapreplace_max = heapreplace_max
+_heappush_max = heappush_max
+_heappushpop_max = heappushpop_max
+_heapify_max = heapify_max
 
 if __name__ == "__main__":
 
diff --git a/Lib/ipaddress.py b/Lib/ipaddress.py
index 67e45450fc1..ca732e4f2e8 100644
--- a/Lib/ipaddress.py
+++ b/Lib/ipaddress.py
@@ -239,7 +239,7 @@ def summarize_address_range(first, last):
     else:
         raise ValueError('unknown IP version')
 
-    ip_bits = first._max_prefixlen
+    ip_bits = first.max_prefixlen
     first_int = first._ip
     last_int = last._ip
     while first_int <= last_int:
@@ -326,12 +326,12 @@ def collapse_addresses(addresses):
     # split IP addresses and networks
     for ip in addresses:
         if isinstance(ip, _BaseAddress):
-            if ips and ips[-1]._version != ip._version:
+            if ips and ips[-1].version != ip.version:
                 raise TypeError("%s and %s are not of the same version" % (
                                  ip, ips[-1]))
             ips.append(ip)
-        elif ip._prefixlen == ip._max_prefixlen:
-            if ips and ips[-1]._version != ip._version:
+        elif ip._prefixlen == ip.max_prefixlen:
+            if ips and ips[-1].version != ip.version:
                 raise TypeError("%s and %s are not of the same version" % (
                                  ip, ips[-1]))
             try:
@@ -339,7 +339,7 @@ def collapse_addresses(addresses):
             except AttributeError:
                 ips.append(ip.network_address)
         else:
-            if nets and nets[-1]._version != ip._version:
+            if nets and nets[-1].version != ip.version:
                 raise TypeError("%s and %s are not of the same version" % (
                                  ip, nets[-1]))
             nets.append(ip)
@@ -407,26 +407,21 @@ def reverse_pointer(self):
         """
         return self._reverse_pointer()
 
-    @property
-    def version(self):
-        msg = '%200s has no version specified' % (type(self),)
-        raise NotImplementedError(msg)
-
     def _check_int_address(self, address):
         if address < 0:
             msg = "%d (< 0) is not permitted as an IPv%d address"
-            raise AddressValueError(msg % (address, self._version))
+            raise AddressValueError(msg % (address, self.version))
         if address > self._ALL_ONES:
             msg = "%d (>= 2**%d) is not permitted as an IPv%d address"
-            raise AddressValueError(msg % (address, self._max_prefixlen,
-                                           self._version))
+            raise AddressValueError(msg % (address, self.max_prefixlen,
+                                           self.version))
 
     def _check_packed_address(self, address, expected_len):
         address_len = len(address)
         if address_len != expected_len:
             msg = "%r (len %d != %d) is not permitted as an IPv%d address"
             raise AddressValueError(msg % (address, address_len,
-                                           expected_len, self._version))
+                                           expected_len, self.version))
 
     @classmethod
     def _ip_int_from_prefix(cls, prefixlen):
@@ -455,12 +450,12 @@ def _prefix_from_ip_int(cls, ip_int):
             ValueError: If the input intermingles zeroes & ones
         """
         trailing_zeroes = _count_righthand_zero_bits(ip_int,
-                                                     cls._max_prefixlen)
-        prefixlen = cls._max_prefixlen - trailing_zeroes
+                                                     cls.max_prefixlen)
+        prefixlen = cls.max_prefixlen - trailing_zeroes
         leading_ones = ip_int >> trailing_zeroes
         all_ones = (1 << prefixlen) - 1
         if leading_ones != all_ones:
-            byteslen = cls._max_prefixlen // 8
+            byteslen = cls.max_prefixlen // 8
             details = ip_int.to_bytes(byteslen, 'big')
             msg = 'Netmask pattern %r mixes zeroes & ones'
             raise ValueError(msg % details)
@@ -492,7 +487,7 @@ def _prefix_from_prefix_string(cls, prefixlen_str):
             prefixlen = int(prefixlen_str)
         except ValueError:
             cls._report_invalid_netmask(prefixlen_str)
-        if not (0 <= prefixlen <= cls._max_prefixlen):
+        if not (0 <= prefixlen <= cls.max_prefixlen):
             cls._report_invalid_netmask(prefixlen_str)
         return prefixlen
 
@@ -542,7 +537,7 @@ def _split_addr_prefix(cls, address):
         """
         # a packed address or integer
         if isinstance(address, (bytes, int)):
-            return address, cls._max_prefixlen
+            return address, cls.max_prefixlen
 
         if not isinstance(address, tuple):
             # Assume input argument to be string or any object representation
@@ -552,7 +547,7 @@ def _split_addr_prefix(cls, address):
         # Constructing from a tuple (addr, [mask])
         if len(address) > 1:
             return address
-        return address[0], cls._max_prefixlen
+        return address[0], cls.max_prefixlen
 
     def __reduce__(self):
         return self.__class__, (str(self),)
@@ -577,14 +572,14 @@ def __int__(self):
     def __eq__(self, other):
         try:
             return (self._ip == other._ip
-                    and self._version == other._version)
+                    and self.version == other.version)
         except AttributeError:
             return NotImplemented
 
     def __lt__(self, other):
         if not isinstance(other, _BaseAddress):
             return NotImplemented
-        if self._version != other._version:
+        if self.version != other.version:
             raise TypeError('%s and %s are not of the same version' % (
                              self, other))
         if self._ip != other._ip:
@@ -613,7 +608,7 @@ def __hash__(self):
         return hash(hex(int(self._ip)))
 
     def _get_address_key(self):
-        return (self._version, self)
+        return (self.version, self)
 
     def __reduce__(self):
         return self.__class__, (self._ip,)
@@ -649,15 +644,15 @@ def __format__(self, fmt):
 
         # Set some defaults
         if fmt_base == 'n':
-            if self._version == 4:
+            if self.version == 4:
                 fmt_base = 'b'  # Binary is default for ipv4
             else:
                 fmt_base = 'x'  # Hex is default for ipv6
 
         if fmt_base == 'b':
-            padlen = self._max_prefixlen
+            padlen = self.max_prefixlen
         else:
-            padlen = self._max_prefixlen // 4
+            padlen = self.max_prefixlen // 4
 
         if grouping:
             padlen += padlen // 4 - 1
@@ -716,7 +711,7 @@ def __getitem__(self, n):
     def __lt__(self, other):
         if not isinstance(other, _BaseNetwork):
             return NotImplemented
-        if self._version != other._version:
+        if self.version != other.version:
             raise TypeError('%s and %s are not of the same version' % (
                              self, other))
         if self.network_address != other.network_address:
@@ -727,7 +722,7 @@ def __lt__(self, other):
 
     def __eq__(self, other):
         try:
-            return (self._version == other._version and
+            return (self.version == other.version and
                     self.network_address == other.network_address and
                     int(self.netmask) == int(other.netmask))
         except AttributeError:
@@ -738,7 +733,7 @@ def __hash__(self):
 
     def __contains__(self, other):
         # always false if one is v4 and the other is v6.
-        if self._version != other._version:
+        if self.version != other.version:
             return False
         # dealing with another network.
         if isinstance(other, _BaseNetwork):
@@ -829,7 +824,7 @@ def address_exclude(self, other):
             ValueError: If other is not completely contained by self.
 
         """
-        if not self._version == other._version:
+        if not self.version == other.version:
             raise TypeError("%s and %s are not of the same version" % (
                              self, other))
 
@@ -901,10 +896,10 @@ def compare_networks(self, other):
 
         """
         # does this need to raise a ValueError?
-        if self._version != other._version:
+        if self.version != other.version:
             raise TypeError('%s and %s are not of the same type' % (
                              self, other))
-        # self._version == other._version below here:
+        # self.version == other.version below here:
         if self.network_address < other.network_address:
             return -1
         if self.network_address > other.network_address:
@@ -924,7 +919,7 @@ def _get_networks_key(self):
         and list.sort().
 
         """
-        return (self._version, self.network_address, self.netmask)
+        return (self.version, self.network_address, self.netmask)
 
     def subnets(self, prefixlen_diff=1, new_prefix=None):
         """The subnets which join to make the current subnet.
@@ -952,7 +947,7 @@ def subnets(self, prefixlen_diff=1, new_prefix=None):
               number means a larger network)
 
         """
-        if self._prefixlen == self._max_prefixlen:
+        if self._prefixlen == self.max_prefixlen:
             yield self
             return
 
@@ -967,7 +962,7 @@ def subnets(self, prefixlen_diff=1, new_prefix=None):
             raise ValueError('prefix length diff must be > 0')
         new_prefixlen = self._prefixlen + prefixlen_diff
 
-        if new_prefixlen > self._max_prefixlen:
+        if new_prefixlen > self.max_prefixlen:
             raise ValueError(
                 'prefix length diff %d is invalid for netblock %s' % (
                     new_prefixlen, self))
@@ -1036,7 +1031,7 @@ def is_multicast(self):
     def _is_subnet_of(a, b):
         try:
             # Always false if one is v4 and the other is v6.
-            if a._version != b._version:
+            if a.version != b.version:
                 raise TypeError(f"{a} and {b} are not of the same version")
             return (b.network_address <= a.network_address and
                     b.broadcast_address >= a.broadcast_address)
@@ -1146,11 +1141,11 @@ class _BaseV4:
     """
 
     __slots__ = ()
-    _version = 4
+    version = 4
     # Equivalent to 255.255.255.255 or 32 bits of 1's.
     _ALL_ONES = (2**IPV4LENGTH) - 1
 
-    _max_prefixlen = IPV4LENGTH
+    max_prefixlen = IPV4LENGTH
     # There are only a handful of valid v4 netmasks, so we cache them all
     # when constructed (see _make_netmask()).
     _netmask_cache = {}
@@ -1170,7 +1165,7 @@ def _make_netmask(cls, arg):
         if arg not in cls._netmask_cache:
             if isinstance(arg, int):
                 prefixlen = arg
-                if not (0 <= prefixlen <= cls._max_prefixlen):
+                if not (0 <= prefixlen <= cls.max_prefixlen):
                     cls._report_invalid_netmask(prefixlen)
             else:
                 try:
@@ -1268,15 +1263,6 @@ def _reverse_pointer(self):
         reverse_octets = str(self).split('.')[::-1]
         return '.'.join(reverse_octets) + '.in-addr.arpa'
 
-    @property
-    def max_prefixlen(self):
-        return self._max_prefixlen
-
-    @property
-    def version(self):
-        return self._version
-
-
 class IPv4Address(_BaseV4, _BaseAddress):
 
     """Represent and manipulate single IPv4 Addresses."""
@@ -1556,10 +1542,10 @@ def __init__(self, address, strict=True):
                 self.network_address = IPv4Address(packed &
                                                    int(self.netmask))
 
-        if self._prefixlen == (self._max_prefixlen - 1):
+        if self._prefixlen == (self.max_prefixlen - 1):
             self.hosts = self.__iter__
-        elif self._prefixlen == (self._max_prefixlen):
-            self.hosts = lambda: [IPv4Address(addr)]
+        elif self._prefixlen == (self.max_prefixlen):
+            self.hosts = lambda: iter((IPv4Address(addr),))
 
     @property
     @functools.lru_cache()
@@ -1628,11 +1614,11 @@ class _BaseV6:
     """
 
     __slots__ = ()
-    _version = 6
+    version = 6
     _ALL_ONES = (2**IPV6LENGTH) - 1
     _HEXTET_COUNT = 8
     _HEX_DIGITS = frozenset('0123456789ABCDEFabcdef')
-    _max_prefixlen = IPV6LENGTH
+    max_prefixlen = IPV6LENGTH
 
     # There are only a bunch of valid v6 netmasks, so we cache them all
     # when constructed (see _make_netmask()).
@@ -1650,7 +1636,7 @@ def _make_netmask(cls, arg):
         if arg not in cls._netmask_cache:
             if isinstance(arg, int):
                 prefixlen = arg
-                if not (0 <= prefixlen <= cls._max_prefixlen):
+                if not (0 <= prefixlen <= cls.max_prefixlen):
                     cls._report_invalid_netmask(prefixlen)
             else:
                 prefixlen = cls._prefix_from_prefix_string(arg)
@@ -1921,15 +1907,6 @@ def _split_scope_id(ip_str):
             raise AddressValueError('Invalid IPv6 address: "%r"' % ip_str)
         return addr, scope_id
 
-    @property
-    def max_prefixlen(self):
-        return self._max_prefixlen
-
-    @property
-    def version(self):
-        return self._version
-
-
 class IPv6Address(_BaseV6, _BaseAddress):
 
     """Represent and manipulate single IPv6 Addresses."""
@@ -2356,10 +2333,10 @@ def __init__(self, address, strict=True):
                 self.network_address = IPv6Address(packed &
                                                    int(self.netmask))
 
-        if self._prefixlen == (self._max_prefixlen - 1):
+        if self._prefixlen == (self.max_prefixlen - 1):
             self.hosts = self.__iter__
-        elif self._prefixlen == self._max_prefixlen:
-            self.hosts = lambda: [IPv6Address(addr)]
+        elif self._prefixlen == self.max_prefixlen:
+            self.hosts = lambda: iter((IPv6Address(addr),))
 
     def hosts(self):
         """Generate Iterator over usable hosts in a network.
diff --git a/Lib/test/test_graphlib.py b/Lib/test/test_graphlib.py
index 5f38af4024c..66722e0b049 100644
--- a/Lib/test/test_graphlib.py
+++ b/Lib/test/test_graphlib.py
@@ -140,9 +140,21 @@ def test_calls_before_prepare(self):
     def test_prepare_multiple_times(self):
         ts = graphlib.TopologicalSorter()
         ts.prepare()
-        with self.assertRaisesRegex(ValueError, r"cannot prepare\(\) more than once"):
+        ts.prepare()
+
+    def test_prepare_after_pass_out(self):
+        ts = graphlib.TopologicalSorter({'a': 'bc'})
+        ts.prepare()
+        self.assertEqual(set(ts.get_ready()), {'b', 'c'})
+        with self.assertRaisesRegex(ValueError, r"cannot prepare\(\) after starting sort"):
             ts.prepare()
 
+    def test_prepare_cycleerror_each_time(self):
+        ts = graphlib.TopologicalSorter({'a': 'b', 'b': 'a'})
+        for attempt in range(1, 4):
+            with self.assertRaises(graphlib.CycleError, msg=f"{attempt=}"):
+                ts.prepare()
+
     def test_invalid_nodes_in_done(self):
         ts = graphlib.TopologicalSorter()
         ts.add(1, 2, 3, 4)
diff --git a/Lib/test/test_heapq.py b/Lib/test/test_heapq.py
index 1aa8e4e2897..d6623fee9bb 100644
--- a/Lib/test/test_heapq.py
+++ b/Lib/test/test_heapq.py
@@ -13,8 +13,9 @@
 
 # _heapq.nlargest/nsmallest are saved in heapq._nlargest/_smallest when
 # _heapq is imported, so check them there
-func_names = ['heapify', 'heappop', 'heappush', 'heappushpop', 'heapreplace',
-              '_heappop_max', '_heapreplace_max', '_heapify_max']
+func_names = ['heapify', 'heappop', 'heappush', 'heappushpop', 'heapreplace']
+# Add max-heap variants
+func_names += [func + '_max' for func in func_names]
 
 class TestModules(TestCase):
     def test_py_functions(self):
@@ -24,7 +25,7 @@ def test_py_functions(self):
     @skipUnless(c_heapq, 'requires _heapq')
     def test_c_functions(self):
         for fname in func_names:
-            self.assertEqual(getattr(c_heapq, fname).__module__, '_heapq')
+            self.assertEqual(getattr(c_heapq, fname).__module__, '_heapq', fname)
 
 
 def load_tests(loader, tests, ignore):
@@ -74,6 +75,34 @@ def test_push_pop(self):
         except AttributeError:
             pass
 
+    def test_max_push_pop(self):
+        # 1) Push 256 random numbers and pop them off, verifying all's OK.
+        heap = []
+        data = []
+        self.check_max_invariant(heap)
+        for i in range(256):
+            item = random.random()
+            data.append(item)
+            self.module.heappush_max(heap, item)
+            self.check_max_invariant(heap)
+        results = []
+        while heap:
+            item = self.module.heappop_max(heap)
+            self.check_max_invariant(heap)
+            results.append(item)
+        data_sorted = data[:]
+        data_sorted.sort(reverse=True)
+
+        self.assertEqual(data_sorted, results)
+        # 2) Check that the invariant holds for a sorted array
+        self.check_max_invariant(results)
+
+        self.assertRaises(TypeError, self.module.heappush_max, [])
+
+        exc_types = (AttributeError, TypeError)
+        self.assertRaises(exc_types, self.module.heappush_max, None, None)
+        self.assertRaises(exc_types, self.module.heappop_max, None)
+
     def check_invariant(self, heap):
         # Check the heap invariant.
         for pos, item in enumerate(heap):
@@ -81,6 +110,11 @@ def check_invariant(self, heap):
                 parentpos = (pos-1) >> 1
                 self.assertTrue(heap[parentpos] <= item)
 
+    def check_max_invariant(self, heap):
+        for pos, item in enumerate(heap[1:], start=1):
+            parentpos = (pos - 1) >> 1
+            self.assertGreaterEqual(heap[parentpos], item)
+
     def test_heapify(self):
         for size in list(range(30)) + [20000]:
             heap = [random.random() for dummy in range(size)]
@@ -89,6 +123,14 @@ def test_heapify(self):
 
         self.assertRaises(TypeError, self.module.heapify, None)
 
+    def test_heapify_max(self):
+        for size in list(range(30)) + [20000]:
+            heap = [random.random() for dummy in range(size)]
+            self.module.heapify_max(heap)
+            self.check_max_invariant(heap)
+
+        self.assertRaises(TypeError, self.module.heapify_max, None)
+
     def test_naive_nbest(self):
         data = [random.randrange(2000) for i in range(1000)]
         heap = []
@@ -109,10 +151,7 @@ def heapiter(self, heap):
 
     def test_nbest(self):
         # Less-naive "N-best" algorithm, much faster (if len(data) is big
-        # enough <wink>) than sorting all of data.  However, if we had a max
-        # heap instead of a min heap, it could go faster still via
-        # heapify'ing all of data (linear time), then doing 10 heappops
-        # (10 log-time steps).
+        # enough <wink>) than sorting all of data.
         data = [random.randrange(2000) for i in range(1000)]
         heap = data[:10]
         self.module.heapify(heap)
@@ -125,6 +164,17 @@ def test_nbest(self):
         self.assertRaises(TypeError, self.module.heapreplace, None, None)
         self.assertRaises(IndexError, self.module.heapreplace, [], None)
 
+    def test_nbest_maxheap(self):
+        # With a max heap instead of a min heap, the "N-best" algorithm can
+        # go even faster still via heapify'ing all of data (linear time), then
+        # doing 10 heappops (10 log-time steps).
+        data = [random.randrange(2000) for i in range(1000)]
+        heap = data[:]
+        self.module.heapify_max(heap)
+        result = [self.module.heappop_max(heap) for _ in range(10)]
+        result.reverse()
+        self.assertEqual(result, sorted(data)[-10:])
+
     def test_nbest_with_pushpop(self):
         data = [random.randrange(2000) for i in range(1000)]
         heap = data[:10]
@@ -134,6 +184,62 @@ def test_nbest_with_pushpop(self):
         self.assertEqual(list(self.heapiter(heap)), sorted(data)[-10:])
         self.assertEqual(self.module.heappushpop([], 'x'), 'x')
 
+    def test_naive_nworst(self):
+        # Max-heap variant of "test_naive_nbest"
+        data = [random.randrange(2000) for i in range(1000)]
+        heap = []
+        for item in data:
+            self.module.heappush_max(heap, item)
+            if len(heap) > 10:
+                self.module.heappop_max(heap)
+        heap.sort()
+        expected = sorted(data)[:10]
+        self.assertEqual(heap, expected)
+
+    def heapiter_max(self, heap):
+        # An iterator returning a max-heap's elements, largest-first.
+        try:
+            while 1:
+                yield self.module.heappop_max(heap)
+        except IndexError:
+            pass
+
+    def test_nworst(self):
+        # Max-heap variant of "test_nbest"
+        data = [random.randrange(2000) for i in range(1000)]
+        heap = data[:10]
+        self.module.heapify_max(heap)
+        for item in data[10:]:
+            if item < heap[0]:  # this gets rarer the longer we run
+                self.module.heapreplace_max(heap, item)
+        expected = sorted(data, reverse=True)[-10:]
+        self.assertEqual(list(self.heapiter_max(heap)), expected)
+
+        self.assertRaises(TypeError, self.module.heapreplace_max, None)
+        self.assertRaises(TypeError, self.module.heapreplace_max, None, None)
+        self.assertRaises(IndexError, self.module.heapreplace_max, [], None)
+
+    def test_nworst_minheap(self):
+        # Min-heap variant of "test_nbest_maxheap"
+        data = [random.randrange(2000) for i in range(1000)]
+        heap = data[:]
+        self.module.heapify(heap)
+        result = [self.module.heappop(heap) for _ in range(10)]
+        result.reverse()
+        expected = sorted(data, reverse=True)[-10:]
+        self.assertEqual(result, expected)
+
+    def test_nworst_with_pushpop(self):
+        # Max-heap variant of "test_nbest_with_pushpop"
+        data = [random.randrange(2000) for i in range(1000)]
+        heap = data[:10]
+        self.module.heapify_max(heap)
+        for item in data[10:]:
+            self.module.heappushpop_max(heap, item)
+        expected = sorted(data, reverse=True)[-10:]
+        self.assertEqual(list(self.heapiter_max(heap)), expected)
+        self.assertEqual(self.module.heappushpop_max([], 'x'), 'x')
+
     def test_heappushpop(self):
         h = []
         x = self.module.heappushpop(h, 10)
@@ -153,12 +259,31 @@ def test_heappushpop(self):
         x = self.module.heappushpop(h, 11)
         self.assertEqual((h, x), ([11], 10))
 
+    def test_heappushpop_max(self):
+        h = []
+        x = self.module.heappushpop_max(h, 10)
+        self.assertTupleEqual((h, x), ([], 10))
+
+        h = [10]
+        x = self.module.heappushpop_max(h, 10.0)
+        self.assertTupleEqual((h, x), ([10], 10.0))
+        self.assertIsInstance(h[0], int)
+        self.assertIsInstance(x, float)
+
+        h = [10]
+        x = self.module.heappushpop_max(h, 11)
+        self.assertTupleEqual((h, x), ([10], 11))
+
+        h = [10]
+        x = self.module.heappushpop_max(h, 9)
+        self.assertTupleEqual((h, x), ([9], 10))
+
     def test_heappop_max(self):
-        # _heapop_max has an optimization for one-item lists which isn't
+        # heapop_max has an optimization for one-item lists which isn't
         # covered in other tests, so test that case explicitly here
         h = [3, 2]
-        self.assertEqual(self.module._heappop_max(h), 3)
-        self.assertEqual(self.module._heappop_max(h), 2)
+        self.assertEqual(self.module.heappop_max(h), 3)
+        self.assertEqual(self.module.heappop_max(h), 2)
 
     def test_heapsort(self):
         # Exercise everything with repeated heapsort checks
@@ -175,6 +300,20 @@ def test_heapsort(self):
             heap_sorted = [self.module.heappop(heap) for i in range(size)]
             self.assertEqual(heap_sorted, sorted(data))
 
+    def test_heapsort_max(self):
+        for trial in range(100):
+            size = random.randrange(50)
+            data = [random.randrange(25) for i in range(size)]
+            if trial & 1:     # Half of the time, use heapify_max
+                heap = data[:]
+                self.module.heapify_max(heap)
+            else:             # The rest of the time, use heappush_max
+                heap = []
+                for item in data:
+                    self.module.heappush_max(heap, item)
+            heap_sorted = [self.module.heappop_max(heap) for i in range(size)]
+            self.assertEqual(heap_sorted, sorted(data, reverse=True))
+
     def test_merge(self):
         inputs = []
         for i in range(random.randrange(25)):
@@ -377,16 +516,20 @@ def __lt__(self, other):
 class TestErrorHandling:
 
     def test_non_sequence(self):
-        for f in (self.module.heapify, self.module.heappop):
+        for f in (self.module.heapify, self.module.heappop,
+                  self.module.heapify_max, self.module.heappop_max):
             self.assertRaises((TypeError, AttributeError), f, 10)
         for f in (self.module.heappush, self.module.heapreplace,
+                  self.module.heappush_max, self.module.heapreplace_max,
                   self.module.nlargest, self.module.nsmallest):
             self.assertRaises((TypeError, AttributeError), f, 10, 10)
 
     def test_len_only(self):
-        for f in (self.module.heapify, self.module.heappop):
+        for f in (self.module.heapify, self.module.heappop,
+                  self.module.heapify_max, self.module.heappop_max):
             self.assertRaises((TypeError, AttributeError), f, LenOnly())
-        for f in (self.module.heappush, self.module.heapreplace):
+        for f in (self.module.heappush, self.module.heapreplace,
+                  self.module.heappush_max, self.module.heapreplace_max):
             self.assertRaises((TypeError, AttributeError), f, LenOnly(), 10)
         for f in (self.module.nlargest, self.module.nsmallest):
             self.assertRaises(TypeError, f, 2, LenOnly())
@@ -395,7 +538,8 @@ def test_cmp_err(self):
         seq = [CmpErr(), CmpErr(), CmpErr()]
         for f in (self.module.heapify, self.module.heappop):
             self.assertRaises(ZeroDivisionError, f, seq)
-        for f in (self.module.heappush, self.module.heapreplace):
+        for f in (self.module.heappush, self.module.heapreplace,
+                  self.module.heappush_max, self.module.heapreplace_max):
             self.assertRaises(ZeroDivisionError, f, seq, 10)
         for f in (self.module.nlargest, self.module.nsmallest):
             self.assertRaises(ZeroDivisionError, f, 2, seq)
@@ -403,6 +547,8 @@ def test_cmp_err(self):
     def test_arg_parsing(self):
         for f in (self.module.heapify, self.module.heappop,
                   self.module.heappush, self.module.heapreplace,
+                  self.module.heapify_max, self.module.heappop_max,
+                  self.module.heappush_max, self.module.heapreplace_max,
                   self.module.nlargest, self.module.nsmallest):
             self.assertRaises((TypeError, AttributeError), f, 10)
 
@@ -424,6 +570,10 @@ def test_heappush_mutating_heap(self):
         # Python version raises IndexError, C version RuntimeError
         with self.assertRaises((IndexError, RuntimeError)):
             self.module.heappush(heap, SideEffectLT(5, heap))
+        heap = []
+        heap.extend(SideEffectLT(i, heap) for i in range(200))
+        with self.assertRaises((IndexError, RuntimeError)):
+            self.module.heappush_max(heap, SideEffectLT(5, heap))
 
     def test_heappop_mutating_heap(self):
         heap = []
@@ -431,8 +581,12 @@ def test_heappop_mutating_heap(self):
         # Python version raises IndexError, C version RuntimeError
         with self.assertRaises((IndexError, RuntimeError)):
             self.module.heappop(heap)
+        heap = []
+        heap.extend(SideEffectLT(i, heap) for i in range(200))
+        with self.assertRaises((IndexError, RuntimeError)):
+            self.module.heappop_max(heap)
 
-    def test_comparison_operator_modifiying_heap(self):
+    def test_comparison_operator_modifying_heap(self):
         # See bpo-39421: Strong references need to be taken
         # when comparing objects as they can alter the heap
         class EvilClass(int):
@@ -444,7 +598,7 @@ def __lt__(self, o):
         self.module.heappush(heap, EvilClass(0))
         self.assertRaises(IndexError, self.module.heappushpop, heap, 1)
 
-    def test_comparison_operator_modifiying_heap_two_heaps(self):
+    def test_comparison_operator_modifying_heap_two_heaps(self):
 
         class h(int):
             def __lt__(self, o):
@@ -464,6 +618,17 @@ def __lt__(self, o):
         self.assertRaises((IndexError, RuntimeError), self.module.heappush, list1, g(1))
         self.assertRaises((IndexError, RuntimeError), self.module.heappush, list2, h(1))
 
+        list1, list2 = [], []
+
+        self.module.heappush_max(list1, h(0))
+        self.module.heappush_max(list2, g(0))
+        self.module.heappush_max(list1, g(1))
+        self.module.heappush_max(list2, h(1))
+
+        self.assertRaises((IndexError, RuntimeError), self.module.heappush_max, list1, g(1))
+        self.assertRaises((IndexError, RuntimeError), self.module.heappush_max, list2, h(1))
+
+
 class TestErrorHandlingPython(TestErrorHandling, TestCase):
     module = py_heapq
 
diff --git a/Lib/test/test_ipaddress.py b/Lib/test/test_ipaddress.py
index e69e12495ad..8af91e857d8 100644
--- a/Lib/test/test_ipaddress.py
+++ b/Lib/test/test_ipaddress.py
@@ -12,6 +12,7 @@
 import pickle
 import ipaddress
 import weakref
+from collections.abc import Iterator
 from test.support import LARGEST, SMALLEST
 
 
@@ -1472,18 +1473,27 @@ def testGetSupernet4(self):
                          self.ipv6_scoped_network.supernet(new_prefix=62))
 
     def testHosts(self):
+        hosts = self.ipv4_network.hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), next(hosts))
         hosts = list(self.ipv4_network.hosts())
         self.assertEqual(254, len(hosts))
         self.assertEqual(ipaddress.IPv4Address('1.2.3.1'), hosts[0])
         self.assertEqual(ipaddress.IPv4Address('1.2.3.254'), hosts[-1])
 
         ipv6_network = ipaddress.IPv6Network('2001:658:22a:cafe::/120')
+        hosts = ipv6_network.hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), next(hosts))
         hosts = list(ipv6_network.hosts())
         self.assertEqual(255, len(hosts))
         self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
         self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::ff'), hosts[-1])
 
         ipv6_scoped_network = ipaddress.IPv6Network('2001:658:22a:cafe::%scope/120')
+        hosts = ipv6_scoped_network.hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual((ipaddress.IPv6Address('2001:658:22a:cafe::1')), next(hosts))
         hosts = list(ipv6_scoped_network.hosts())
         self.assertEqual(255, len(hosts))
         self.assertEqual(ipaddress.IPv6Address('2001:658:22a:cafe::1'), hosts[0])
@@ -1494,6 +1504,12 @@ def testHosts(self):
                  ipaddress.IPv4Address('2.0.0.1')]
         str_args = '2.0.0.0/31'
         tpl_args = ('2.0.0.0', 31)
+        hosts = ipaddress.ip_network(str_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
+        hosts = ipaddress.ip_network(tpl_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
         self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
         self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
         self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
@@ -1503,6 +1519,12 @@ def testHosts(self):
         addrs = [ipaddress.IPv4Address('1.2.3.4')]
         str_args = '1.2.3.4/32'
         tpl_args = ('1.2.3.4', 32)
+        hosts = ipaddress.ip_network(str_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
+        hosts = ipaddress.ip_network(tpl_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
         self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
         self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
         self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
@@ -1512,6 +1534,12 @@ def testHosts(self):
                  ipaddress.IPv6Address('2001:658:22a:cafe::1')]
         str_args = '2001:658:22a:cafe::/127'
         tpl_args = ('2001:658:22a:cafe::', 127)
+        hosts = ipaddress.ip_network(str_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
+        hosts = ipaddress.ip_network(tpl_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
         self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
         self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
         self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
@@ -1520,6 +1548,12 @@ def testHosts(self):
         addrs = [ipaddress.IPv6Address('2001:658:22a:cafe::1'), ]
         str_args = '2001:658:22a:cafe::1/128'
         tpl_args = ('2001:658:22a:cafe::1', 128)
+        hosts = ipaddress.ip_network(str_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
+        hosts = ipaddress.ip_network(tpl_args).hosts()
+        self.assertIsInstance(hosts, Iterator)
+        self.assertEqual(next(hosts), addrs[0])
         self.assertEqual(addrs, list(ipaddress.ip_network(str_args).hosts()))
         self.assertEqual(addrs, list(ipaddress.ip_network(tpl_args).hosts()))
         self.assertEqual(list(ipaddress.ip_network(str_args).hosts()),
@@ -2214,12 +2248,18 @@ def testIPv6AddressTooLarge(self):
                           ipaddress.ip_address('ffff::c0a8:ffff%scope'))
 
     def testIPVersion(self):
+        self.assertEqual(ipaddress.IPv4Address.version, 4)
+        self.assertEqual(ipaddress.IPv6Address.version, 6)
+
         self.assertEqual(self.ipv4_address.version, 4)
         self.assertEqual(self.ipv6_address.version, 6)
         self.assertEqual(self.ipv6_scoped_address.version, 6)
         self.assertEqual(self.ipv6_with_ipv4_part.version, 6)
 
     def testMaxPrefixLength(self):
+        self.assertEqual(ipaddress.IPv4Address.max_prefixlen, 32)
+        self.assertEqual(ipaddress.IPv6Address.max_prefixlen, 128)
+
         self.assertEqual(self.ipv4_interface.max_prefixlen, 32)
         self.assertEqual(self.ipv6_interface.max_prefixlen, 128)
         self.assertEqual(self.ipv6_scoped_interface.max_prefixlen, 128)

From 11c9b0e7831e38fc71e2ce8d571a0e47cfbfe1fd Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 01:54:16 +0900
Subject: [PATCH 346/418] fix finalizing and atexit timing (#6626)

* fix finalizing and atexit timing

* fix shutdown
---
 Lib/test/test_warnings/__init__.py |  2 -
 crates/vm/src/vm/interpreter.rs    | 55 ++++++++++----------------
 crates/vm/src/vm/mod.rs            | 63 ++++++++++++++++++++++++++++++
 3 files changed, 83 insertions(+), 37 deletions(-)

diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index 123d51b77ea..a8d39dc55c6 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -834,8 +834,6 @@ class CWCmdLineTests(WCmdLineTests, unittest.TestCase):
 class PyWCmdLineTests(WCmdLineTests, unittest.TestCase):
     module = py_warnings
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_improper_option(self):
         # Same as above, but check that the message is printed out when
         # the interpreter is executed. This also checks that options are
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index 6faef040a0e..567bc40a2c3 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -110,10 +110,11 @@ impl Interpreter {
 
     /// Finalize vm and turns an exception to exit code.
     ///
-    /// Finalization steps including 5 steps:
+    /// Finalization steps (matching Py_FinalizeEx):
     /// 1. Flush stdout and stderr.
     /// 1. Handle exit exception and turn it to exit code.
-    /// 1. Wait for non-daemon threads (threading._shutdown).
+    /// 1. Wait for thread shutdown (call threading._shutdown).
+    /// 1. Mark vm as finalizing.
     /// 1. Run atexit exit functions.
     /// 1. Mark vm as finalized.
     ///
@@ -129,13 +130,26 @@ impl Interpreter {
                 0
             };
 
-            // Wait for non-daemon threads (wait_for_thread_shutdown)
-            wait_for_thread_shutdown(vm);
+            // Wait for thread shutdown - call threading._shutdown() if available.
+            // This waits for all non-daemon threads to complete.
+            // threading module may not be imported, so ignore import errors.
+            if let Ok(threading) = vm.import("threading", 0)
+                && let Ok(shutdown) = threading.get_attr("_shutdown", vm)
+                && let Err(e) = shutdown.call((), vm)
+            {
+                vm.run_unraisable(
+                    e,
+                    Some("Exception ignored in threading shutdown".to_owned()),
+                    threading,
+                );
+            }
+
+            // Mark as finalizing AFTER thread shutdown
+            vm.state.finalizing.store(true, Ordering::Release);
 
+            // Run atexit exit functions
             atexit::_run_exitfuncs(vm);
 
-            vm.state.finalizing.store(true, Ordering::Release);
-
             vm.flush_std();
 
             exit_code
@@ -143,35 +157,6 @@ impl Interpreter {
     }
 }
 
-/// Wait until threading._shutdown completes, provided
-/// the threading module was imported in the first place.
-/// The shutdown routine will wait until all non-daemon
-/// "threading" threads have completed.
-fn wait_for_thread_shutdown(vm: &VirtualMachine) {
-    // Try to get the threading module if it was already imported
-    // Use sys.modules.get("threading") like PyImport_GetModule
-    let threading = match (|| -> PyResult<_> {
-        let sys_modules = vm.sys_module.get_attr("modules", vm)?;
-        let threading = sys_modules.get_item("threading", vm)?;
-        Ok(threading)
-    })() {
-        Ok(module) => module,
-        Err(_) => {
-            // threading not imported, nothing to do
-            return;
-        }
-    };
-
-    // Call threading._shutdown()
-    if let Err(e) = vm.call_method(&threading, "_shutdown", ()) {
-        vm.run_unraisable(
-            e,
-            Some("Exception ignored on threading shutdown".to_owned()),
-            threading,
-        );
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 27b70e321cf..0c29d34ef88 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -550,6 +550,18 @@ impl VirtualMachine {
 
     #[cold]
     pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
+        // During interpreter finalization, sys.unraisablehook may not be available,
+        // but we still need to report exceptions (especially from atexit callbacks).
+        // Write directly to stderr like PyErr_FormatUnraisable.
+        if self
+            .state
+            .finalizing
+            .load(std::sync::atomic::Ordering::Acquire)
+        {
+            self.write_unraisable_to_stderr(&e, msg.as_deref(), &object);
+            return;
+        }
+
         let sys_module = self.import("sys", 0).unwrap();
         let unraisablehook = sys_module.get_attr("unraisablehook", self).unwrap();
 
@@ -568,6 +580,57 @@ impl VirtualMachine {
         }
     }
 
+    /// Write unraisable exception to stderr during finalization.
+    /// Similar to _PyErr_WriteUnraisableDefaultHook in CPython.
+    fn write_unraisable_to_stderr(
+        &self,
+        e: &PyBaseExceptionRef,
+        msg: Option<&str>,
+        object: &PyObjectRef,
+    ) {
+        // Get stderr once and reuse it
+        let stderr = crate::stdlib::sys::get_stderr(self).ok();
+
+        let write_to_stderr = |s: &str, stderr: &Option<PyObjectRef>, vm: &VirtualMachine| {
+            if let Some(stderr) = stderr {
+                let _ = vm.call_method(stderr, "write", (s.to_owned(),));
+            } else {
+                eprint!("{}", s);
+            }
+        };
+
+        // Format: "Exception ignored {msg} {object_repr}\n"
+        if let Some(msg) = msg {
+            write_to_stderr(&format!("Exception ignored {}", msg), &stderr, self);
+        } else {
+            write_to_stderr("Exception ignored in: ", &stderr, self);
+        }
+
+        if let Ok(repr) = object.repr(self) {
+            write_to_stderr(&format!("{}\n", repr.as_str()), &stderr, self);
+        } else {
+            write_to_stderr("<object repr failed>\n", &stderr, self);
+        }
+
+        // Write exception type and message
+        let exc_type_name = e.class().name();
+        if let Ok(exc_str) = e.as_object().str(self) {
+            let exc_str = exc_str.as_str();
+            if exc_str.is_empty() {
+                write_to_stderr(&format!("{}\n", exc_type_name), &stderr, self);
+            } else {
+                write_to_stderr(&format!("{}: {}\n", exc_type_name, exc_str), &stderr, self);
+            }
+        } else {
+            write_to_stderr(&format!("{}\n", exc_type_name), &stderr, self);
+        }
+
+        // Flush stderr to ensure output is visible
+        if let Some(ref stderr) = stderr {
+            let _ = self.call_method(stderr, "flush", ());
+        }
+    }
+
     #[inline(always)]
     pub fn run_frame(&self, frame: FrameRef) -> PyResult {
         match self.with_frame(frame, |f| f.run(self))? {

From ca76cb7bb054a4e65eebb26693be89e19f6a1c6c Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 08:53:41 +0900
Subject: [PATCH 347/418] thread_inherit_context, upgrade threading &
 contextvar  (#6727)

* thread_inherit_context

* Update contextvar, threading from CPython 3.14.2

* partially patch test_sys to 3.14.2

---------

Co-authored-by: CPython Devleopers <>
---
 Lib/contextvars.py          |  4 +++
 Lib/test/test_sys.py        |  5 +--
 Lib/threading.py            | 72 ++++++++++++++++++++++++++++---------
 crates/vm/src/stdlib/sys.rs |  3 ++
 crates/vm/src/vm/setting.rs |  4 +++
 src/settings.rs             | 28 +++++++++++++++
 6 files changed, 98 insertions(+), 18 deletions(-)

diff --git a/Lib/contextvars.py b/Lib/contextvars.py
index d78c80dfe6f..14514f185e0 100644
--- a/Lib/contextvars.py
+++ b/Lib/contextvars.py
@@ -1,4 +1,8 @@
+import _collections_abc
 from _contextvars import Context, ContextVar, Token, copy_context
 
 
 __all__ = ('Context', 'ContextVar', 'Token', 'copy_context')
+
+
+_collections_abc.Mapping.register(Context)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index e5f88b325e0..b65e1291bbc 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -889,10 +889,11 @@ def test_sys_flags(self):
                  "dont_write_bytecode", "no_user_site", "no_site",
                  "ignore_environment", "verbose", "bytes_warning", "quiet",
                  "hash_randomization", "isolated", "dev_mode", "utf8_mode",
-                 "warn_default_encoding", "safe_path", "int_max_str_digits")
+                 "warn_default_encoding", "safe_path", "int_max_str_digits",
+                 "thread_inherit_context")
         for attr in attrs:
             self.assertTrue(hasattr(sys.flags, attr), attr)
-            attr_type = bool if attr in ("dev_mode", "safe_path") else int
+            attr_type = bool if attr in ("dev_mode", "safe_path", "thread_inherit_context") else int
             self.assertEqual(type(getattr(sys.flags, attr)), attr_type, attr)
         self.assertTrue(repr(sys.flags))
         self.assertEqual(len(sys.flags), len(attrs))
diff --git a/Lib/threading.py b/Lib/threading.py
index 15bf786a6a9..c03b0b5370c 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -3,7 +3,7 @@
 import os as _os
 import sys as _sys
 import _thread
-import warnings
+import _contextvars
 
 from time import monotonic as _time
 from _weakrefset import WeakSet
@@ -48,6 +48,10 @@
     __all__.append('get_native_id')
 except AttributeError:
     _HAVE_THREAD_NATIVE_ID = False
+try:
+    _set_name = _thread.set_name
+except AttributeError:
+    _set_name = None
 ThreadError = _thread.error
 try:
     _CRLock = _thread.RLock
@@ -129,6 +133,7 @@ def RLock(*args, **kwargs):
 
     """
     if args or kwargs:
+        import warnings
         warnings.warn(
             'Passing arguments to RLock is deprecated and will be removed in 3.15',
             DeprecationWarning,
@@ -160,7 +165,7 @@ def __repr__(self):
         except KeyError:
             pass
         return "<%s %s.%s object owner=%r count=%d at %s>" % (
-            "locked" if self._block.locked() else "unlocked",
+            "locked" if self.locked() else "unlocked",
             self.__class__.__module__,
             self.__class__.__qualname__,
             owner,
@@ -237,6 +242,10 @@ def release(self):
     def __exit__(self, t, v, tb):
         self.release()
 
+    def locked(self):
+        """Return whether this object is locked."""
+        return self._block.locked()
+
     # Internal methods used by condition variables
 
     def _acquire_restore(self, state):
@@ -282,9 +291,10 @@ def __init__(self, lock=None):
         if lock is None:
             lock = RLock()
         self._lock = lock
-        # Export the lock's acquire() and release() methods
+        # Export the lock's acquire(), release(), and locked() methods
         self.acquire = lock.acquire
         self.release = lock.release
+        self.locked = lock.locked
         # If the lock defines _release_save() and/or _acquire_restore(),
         # these override the default implementations (which just call
         # release() and acquire() on the lock).  Ditto for _is_owned().
@@ -868,7 +878,7 @@ class Thread:
     _initialized = False
 
     def __init__(self, group=None, target=None, name=None,
-                 args=(), kwargs=None, *, daemon=None):
+                 args=(), kwargs=None, *, daemon=None, context=None):
         """This constructor should always be called with keyword arguments. Arguments are:
 
         *group* should be None; reserved for future extension when a ThreadGroup
@@ -885,6 +895,14 @@ class is implemented.
         *kwargs* is a dictionary of keyword arguments for the target
         invocation. Defaults to {}.
 
+        *context* is the contextvars.Context value to use for the thread.
+        The default value is None, which means to check
+        sys.flags.thread_inherit_context.  If that flag is true, use a copy
+        of the context of the caller.  If false, use an empty context.  To
+        explicitly start with an empty context, pass a new instance of
+        contextvars.Context().  To explicitly start with a copy of the current
+        context, pass the value from contextvars.copy_context().
+
         If a subclass overrides the constructor, it must make sure to invoke
         the base class constructor (Thread.__init__()) before doing anything
         else to the thread.
@@ -914,10 +932,11 @@ class is implemented.
             self._daemonic = daemon
         else:
             self._daemonic = current_thread().daemon
+        self._context = context
         self._ident = None
         if _HAVE_THREAD_NATIVE_ID:
             self._native_id = None
-        self._handle = _ThreadHandle()
+        self._os_thread_handle = _ThreadHandle()
         self._started = Event()
         self._initialized = True
         # Copy of sys.stderr used by self._invoke_excepthook()
@@ -932,7 +951,7 @@ def _after_fork(self, new_ident=None):
         if new_ident is not None:
             # This thread is alive.
             self._ident = new_ident
-            assert self._handle.ident == new_ident
+            assert self._os_thread_handle.ident == new_ident
             if _HAVE_THREAD_NATIVE_ID:
                 self._set_native_id()
         else:
@@ -945,7 +964,7 @@ def __repr__(self):
         status = "initial"
         if self._started.is_set():
             status = "started"
-        if self._handle.is_done():
+        if self._os_thread_handle.is_done():
             status = "stopped"
         if self._daemonic:
             status += " daemon"
@@ -971,9 +990,19 @@ def start(self):
 
         with _active_limbo_lock:
             _limbo[self] = self
+
+        if self._context is None:
+            # No context provided
+            if _sys.flags.thread_inherit_context:
+                # start with a copy of the context of the caller
+                self._context = _contextvars.copy_context()
+            else:
+                # start with an empty context
+                self._context = _contextvars.Context()
+
         try:
             # Start joinable thread
-            _start_joinable_thread(self._bootstrap, handle=self._handle,
+            _start_joinable_thread(self._bootstrap, handle=self._os_thread_handle,
                                    daemon=self.daemon)
         except Exception:
             with _active_limbo_lock:
@@ -1025,11 +1054,20 @@ def _set_ident(self):
         def _set_native_id(self):
             self._native_id = get_native_id()
 
+    def _set_os_name(self):
+        if _set_name is None or not self._name:
+            return
+        try:
+            _set_name(self._name)
+        except OSError:
+            pass
+
     def _bootstrap_inner(self):
         try:
             self._set_ident()
             if _HAVE_THREAD_NATIVE_ID:
                 self._set_native_id()
+            self._set_os_name()
             self._started.set()
             with _active_limbo_lock:
                 _active[self._ident] = self
@@ -1041,7 +1079,7 @@ def _bootstrap_inner(self):
                 _sys.setprofile(_profile_hook)
 
             try:
-                self.run()
+                self._context.run(self.run)
             except:
                 self._invoke_excepthook(self)
         finally:
@@ -1092,7 +1130,7 @@ def join(self, timeout=None):
         if timeout is not None:
             timeout = max(timeout, 0)
 
-        self._handle.join(timeout)
+        self._os_thread_handle.join(timeout)
 
     @property
     def name(self):
@@ -1109,6 +1147,8 @@ def name(self):
     def name(self, name):
         assert self._initialized, "Thread.__init__() not called"
         self._name = str(name)
+        if get_ident() == self._ident:
+            self._set_os_name()
 
     @property
     def ident(self):
@@ -1143,7 +1183,7 @@ def is_alive(self):
 
         """
         assert self._initialized, "Thread.__init__() not called"
-        return self._started.is_set() and not self._handle.is_done()
+        return self._started.is_set() and not self._os_thread_handle.is_done()
 
     @property
     def daemon(self):
@@ -1354,7 +1394,7 @@ def __init__(self):
         Thread.__init__(self, name="MainThread", daemon=False)
         self._started.set()
         self._ident = _get_main_thread_ident()
-        self._handle = _make_thread_handle(self._ident)
+        self._os_thread_handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
@@ -1402,7 +1442,7 @@ def __init__(self):
                         daemon=_daemon_threads_allowed())
         self._started.set()
         self._set_ident()
-        self._handle = _make_thread_handle(self._ident)
+        self._os_thread_handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
@@ -1410,7 +1450,7 @@ def __init__(self):
         _DeleteDummyThreadOnDel(self)
 
     def is_alive(self):
-        if not self._handle.is_done() and self._started.is_set():
+        if not self._os_thread_handle.is_done() and self._started.is_set():
             return True
         raise RuntimeError("thread is not alive")
 
@@ -1524,7 +1564,7 @@ def _shutdown():
     # dubious, but some code does it. We can't wait for it to be marked as done
     # normally - that won't happen until the interpreter is nearly dead. So
     # mark it done here.
-    if _main_thread._handle.is_done() and _is_main_interpreter():
+    if _main_thread._os_thread_handle.is_done() and _is_main_interpreter():
         # _shutdown() was already called
         return
 
@@ -1537,7 +1577,7 @@ def _shutdown():
         atexit_call()
 
     if _is_main_interpreter():
-        _main_thread._handle._set_done()
+        _main_thread._os_thread_handle._set_done()
 
     # Wait for all non-daemon threads to exit.
     _thread_shutdown()
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 8a65a926cb2..66a43427f83 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1301,6 +1301,8 @@ mod sys {
         safe_path: bool,
         /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
         warn_default_encoding: u8,
+        /// -X thread_inherit_context, whether new threads inherit context from parent
+        thread_inherit_context: bool,
     }
 
     impl FlagsData {
@@ -1324,6 +1326,7 @@ mod sys {
                 int_max_str_digits: settings.int_max_str_digits,
                 safe_path: settings.safe_path,
                 warn_default_encoding: settings.warn_default_encoding as u8,
+                thread_inherit_context: settings.thread_inherit_context,
             }
         }
     }
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index 9be21b4484e..a7779156f8c 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -88,6 +88,9 @@ pub struct Settings {
     /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
     pub warn_default_encoding: bool,
 
+    /// -X thread_inherit_context, whether new threads inherit context from parent
+    pub thread_inherit_context: bool,
+
     /// -i
     pub inspect: bool,
 
@@ -190,6 +193,7 @@ impl Default for Settings {
             isolated: false,
             dev_mode: false,
             warn_default_encoding: false,
+            thread_inherit_context: false,
             warnoptions: vec![],
             path_list: vec![],
             argv: vec![],
diff --git a/src/settings.rs b/src/settings.rs
index 7dd3c1a7714..71a9c5a3f06 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -285,6 +285,20 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
                     }
                 };
             }
+            "thread_inherit_context" => {
+                settings.thread_inherit_context = match value {
+                    Some("1") => true,
+                    Some("0") => false,
+                    _ => {
+                        error!(
+                            "Fatal Python error: config_init_thread_inherit_context: \
+                             -X thread_inherit_context=n: n is missing or invalid\n\
+                             Python runtime state: preinitialized"
+                        );
+                        std::process::exit(1);
+                    }
+                };
+            }
             _ => {}
         }
         (name, value.map(str::to_owned))
@@ -297,6 +311,20 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
     if env_bool("PYTHONNODEBUGRANGES") {
         settings.code_debug_ranges = false;
     }
+    if let Some(val) = get_env("PYTHON_THREAD_INHERIT_CONTEXT") {
+        settings.thread_inherit_context = match val.to_str() {
+            Some("1") => true,
+            Some("0") => false,
+            _ => {
+                error!(
+                    "Fatal Python error: config_init_thread_inherit_context: \
+                     PYTHON_THREAD_INHERIT_CONTEXT=N: N is missing or invalid\n\
+                     Python runtime state: preinitialized"
+                );
+                std::process::exit(1);
+            }
+        };
+    }
 
     // Parse PYTHONIOENCODING=encoding[:errors]
     if let Some(val) = get_env("PYTHONIOENCODING")

From abea6bd11472bf84d5fa480cc43dfbc5395eb057 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 09:36:09 +0900
Subject: [PATCH 348/418] traverse for generator (#6760)

---
 crates/vm/src/builtins/asyncgenerator.rs | 50 +++++++++++++++++++++---
 crates/vm/src/builtins/coroutine.rs      | 17 +++++++-
 crates/vm/src/builtins/generator.rs      |  9 ++++-
 crates/vm/src/coroutine.rs               | 10 +++++
 4 files changed, 78 insertions(+), 8 deletions(-)

diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 891083f3e6b..8f7518f0eae 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -7,13 +7,14 @@ use crate::{
     coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
+    object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
     types::{Destructor, IterNext, Iterable, Representable, SelfIter},
 };
 
 use crossbeam_utils::atomic::AtomicCell;
 
-#[pyclass(name = "async_generator", module = false)]
+#[pyclass(name = "async_generator", module = false, traverse = "manual")]
 #[derive(Debug)]
 pub struct PyAsyncGen {
     inner: Coro,
@@ -23,6 +24,13 @@ pub struct PyAsyncGen {
     // ag_origin_or_finalizer - stores the finalizer callback
     ag_finalizer: PyMutex<Option<PyObjectRef>>,
 }
+
+unsafe impl Traverse for PyAsyncGen {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.inner.traverse(tracer_fn);
+        self.ag_finalizer.traverse(tracer_fn);
+    }
+}
 type PyAsyncGenRef = PyRef<PyAsyncGen>;
 
 impl PyPayload for PyAsyncGen {
@@ -199,9 +207,20 @@ impl Representable for PyAsyncGen {
     }
 }
 
-#[pyclass(module = false, name = "async_generator_wrapped_value")]
+#[pyclass(
+    module = false,
+    name = "async_generator_wrapped_value",
+    traverse = "manual"
+)]
 #[derive(Debug)]
 pub(crate) struct PyAsyncGenWrappedValue(pub PyObjectRef);
+
+unsafe impl Traverse for PyAsyncGenWrappedValue {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.0.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyAsyncGenWrappedValue {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
@@ -244,7 +263,7 @@ enum AwaitableState {
     Closed,
 }
 
-#[pyclass(module = false, name = "async_generator_asend")]
+#[pyclass(module = false, name = "async_generator_asend", traverse = "manual")]
 #[derive(Debug)]
 pub(crate) struct PyAsyncGenASend {
     ag: PyAsyncGenRef,
@@ -252,6 +271,13 @@ pub(crate) struct PyAsyncGenASend {
     value: PyObjectRef,
 }
 
+unsafe impl Traverse for PyAsyncGenASend {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.ag.traverse(tracer_fn);
+        self.value.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyAsyncGenASend {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
@@ -338,7 +364,7 @@ impl IterNext for PyAsyncGenASend {
     }
 }
 
-#[pyclass(module = false, name = "async_generator_athrow")]
+#[pyclass(module = false, name = "async_generator_athrow", traverse = "manual")]
 #[derive(Debug)]
 pub(crate) struct PyAsyncGenAThrow {
     ag: PyAsyncGenRef,
@@ -347,6 +373,13 @@ pub(crate) struct PyAsyncGenAThrow {
     value: (PyObjectRef, PyObjectRef, PyObjectRef),
 }
 
+unsafe impl Traverse for PyAsyncGenAThrow {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.ag.traverse(tracer_fn);
+        self.value.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyAsyncGenAThrow {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
@@ -489,7 +522,7 @@ impl IterNext for PyAsyncGenAThrow {
 
 /// Awaitable wrapper for anext() builtin with default value.
 /// When StopAsyncIteration is raised, it converts it to StopIteration(default).
-#[pyclass(module = false, name = "anext_awaitable")]
+#[pyclass(module = false, name = "anext_awaitable", traverse = "manual")]
 #[derive(Debug)]
 pub struct PyAnextAwaitable {
     wrapped: PyObjectRef,
@@ -497,6 +530,13 @@ pub struct PyAnextAwaitable {
     state: AtomicCell<AwaitableState>,
 }
 
+unsafe impl Traverse for PyAnextAwaitable {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.wrapped.traverse(tracer_fn);
+        self.default_value.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyAnextAwaitable {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/builtins/coroutine.rs b/crates/vm/src/builtins/coroutine.rs
index 9e8d5d534f1..961c352f8df 100644
--- a/crates/vm/src/builtins/coroutine.rs
+++ b/crates/vm/src/builtins/coroutine.rs
@@ -5,18 +5,25 @@ use crate::{
     coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
+    object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
     types::{IterNext, Iterable, Representable, SelfIter},
 };
 use crossbeam_utils::atomic::AtomicCell;
 
-#[pyclass(module = false, name = "coroutine")]
+#[pyclass(module = false, name = "coroutine", traverse = "manual")]
 #[derive(Debug)]
 // PyCoro_Type in CPython
 pub struct PyCoroutine {
     inner: Coro,
 }
 
+unsafe impl Traverse for PyCoroutine {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.inner.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyCoroutine {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
@@ -138,7 +145,7 @@ impl IterNext for PyCoroutine {
     }
 }
 
-#[pyclass(module = false, name = "coroutine_wrapper")]
+#[pyclass(module = false, name = "coroutine_wrapper", traverse = "manual")]
 #[derive(Debug)]
 // PyCoroWrapper_Type in CPython
 pub struct PyCoroutineWrapper {
@@ -146,6 +153,12 @@ pub struct PyCoroutineWrapper {
     closed: AtomicCell<bool>,
 }
 
+unsafe impl Traverse for PyCoroutineWrapper {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.coro.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyCoroutineWrapper {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/builtins/generator.rs b/crates/vm/src/builtins/generator.rs
index 9a1e737500b..ceae2e61c3b 100644
--- a/crates/vm/src/builtins/generator.rs
+++ b/crates/vm/src/builtins/generator.rs
@@ -9,16 +9,23 @@ use crate::{
     coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
+    object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
     types::{IterNext, Iterable, Representable, SelfIter},
 };
 
-#[pyclass(module = false, name = "generator")]
+#[pyclass(module = false, name = "generator", traverse = "manual")]
 #[derive(Debug)]
 pub struct PyGenerator {
     inner: Coro,
 }
 
+unsafe impl Traverse for PyGenerator {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.inner.traverse(tracer_fn);
+    }
+}
+
 impl PyPayload for PyGenerator {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
index 19830496e6e..236388ecf8b 100644
--- a/crates/vm/src/coroutine.rs
+++ b/crates/vm/src/coroutine.rs
@@ -5,6 +5,7 @@ use crate::{
     exceptions::types::PyBaseException,
     frame::{ExecutionResult, FrameRef},
     function::OptionalArg,
+    object::{Traverse, TraverseFn},
     protocol::PyIterReturn,
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -38,6 +39,15 @@ pub struct Coro {
     exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
 }
 
+unsafe impl Traverse for Coro {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.frame.traverse(tracer_fn);
+        self.name.traverse(tracer_fn);
+        self.qualname.traverse(tracer_fn);
+        self.exception.traverse(tracer_fn);
+    }
+}
+
 fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
     let typ = jen.class();
     if typ.is(vm.ctx.types.coroutine_type) {

From 6616961d087d4c5606bac7cd1d0060dc52878f4f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 11:16:25 +0900
Subject: [PATCH 349/418] skip flaky tests (#6764)

---
 Lib/test/_test_multiprocessing.py               | 2 +-
 Lib/test/test_importlib/test_threaded_import.py | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 80b663d32f4..f6c1f292867 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -1459,7 +1459,7 @@ def _acquire_release(lock, timeout, l=None, n=1):
         for _ in range(n):
             lock.release()
 
-    @unittest.skipIf(sys.platform == 'darwin', "TODO: RUSTPYTHON; flaky on darwin")
+    @unittest.skip("TODO: RUSTPYTHON; flaky timeout")
     def test_repr_rlock(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
diff --git a/Lib/test/test_importlib/test_threaded_import.py b/Lib/test/test_importlib/test_threaded_import.py
index f624e7d2c8d..140be1e6619 100644
--- a/Lib/test/test_importlib/test_threaded_import.py
+++ b/Lib/test/test_importlib/test_threaded_import.py
@@ -136,8 +136,7 @@ def check_parallel_module_init(self, mock_os):
             if verbose:
                 print("OK.")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON; flaky")
     def test_parallel_module_init(self):
         self.check_parallel_module_init()
 

From 96e08a425edb5b5b01c9c3495ed186f3bda29aaf Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 13:15:40 +0900
Subject: [PATCH 350/418] Initialize warnings module during interpreter startup
 to process (#6766)

---
 Lib/test/test_warnings/__init__.py | 2 --
 src/lib.rs                         | 6 ++++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index a8d39dc55c6..ae9a365e1c9 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -841,8 +841,6 @@ def test_improper_option(self):
         rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")
         self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warnings_bootstrap(self):
         # Check that the warnings module does get loaded when -W<some option>
         # is used (see issue #10372 for an example of silent bootstrap failure).
diff --git a/src/lib.rs b/src/lib.rs
index 77c9095ad41..11f6dc01c35 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -219,6 +219,12 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         );
     }
 
+    // Initialize warnings module to process sys.warnoptions
+    // _PyWarnings_Init()
+    if vm.import("warnings", 0).is_err() {
+        warn!("Failed to import warnings module");
+    }
+
     // _PyPathConfig_ComputeSysPath0 - set sys.path[0] after site import
     if !vm.state.config.settings.safe_path {
         let path0: Option<String> = match &run_mode {

From e4ce70bbda04605354622c47e1c44a36fa53df96 Mon Sep 17 00:00:00 2001
From: fanninpm <luxverdans@sbcglobal.net>
Date: Sat, 17 Jan 2026 23:59:49 -0500
Subject: [PATCH 351/418] Update Lib/warnings to CPython 3.14 (#6762)

* Update Lib/warnings to CPython 3.14

* Add context_aware_warnings setting

XXX- The default setting of this and thread_inherit_context should be
true.

* Unmark passing test

* Mark failing tests

* Skip failing test in test_sys for now

Updating test_sys to CPython 3.14 is beyond the scope of this PR.

* test_improper_option is fixed

---------

Co-authored-by: Jeong, YunWon <jeong@youknowone.org>
---
 Lib/_py_warnings.py                       | 869 ++++++++++++++++++++++
 Lib/test/test_sys.py                      |   1 +
 Lib/test/test_warnings/__init__.py        | 753 +++++++++++++------
 Lib/test/test_warnings/data/stacklevel.py |  10 +-
 Lib/warnings.py                           | 802 +++-----------------
 crates/vm/src/stdlib/sys.rs               |   3 +
 crates/vm/src/vm/setting.rs               |   4 +
 7 files changed, 1479 insertions(+), 963 deletions(-)
 create mode 100644 Lib/_py_warnings.py

diff --git a/Lib/_py_warnings.py b/Lib/_py_warnings.py
new file mode 100644
index 00000000000..55f8c069591
--- /dev/null
+++ b/Lib/_py_warnings.py
@@ -0,0 +1,869 @@
+"""Python part of the warnings subsystem."""
+
+import sys
+import _contextvars
+import _thread
+
+
+__all__ = ["warn", "warn_explicit", "showwarning",
+           "formatwarning", "filterwarnings", "simplefilter",
+           "resetwarnings", "catch_warnings", "deprecated"]
+
+
+# Normally '_wm' is sys.modules['warnings'] but for unit tests it can be
+# a different module.  User code is allowed to reassign global attributes
+# of the 'warnings' module, commonly 'filters' or 'showwarning'. So we
+# need to lookup these global attributes dynamically on the '_wm' object,
+# rather than binding them earlier.  The code in this module consistently uses
+# '_wm.<something>' rather than using the globals of this module.  If the
+# '_warnings' C extension is in use, some globals are replaced by functions
+# and variables defined in that extension.
+_wm = None
+
+
+def _set_module(module):
+    global _wm
+    _wm = module
+
+
+# filters contains a sequence of filter 5-tuples
+# The components of the 5-tuple are:
+# - an action: error, ignore, always, all, default, module, or once
+# - a compiled regex that must match the warning message
+# - a class representing the warning category
+# - a compiled regex that must match the module that is being warned
+# - a line number for the line being warning, or 0 to mean any line
+# If either if the compiled regexs are None, match anything.
+filters = []
+
+
+defaultaction = "default"
+onceregistry = {}
+_lock = _thread.RLock()
+_filters_version = 1
+
+
+# If true, catch_warnings() will use a context var to hold the modified
+# filters list.  Otherwise, catch_warnings() will operate on the 'filters'
+# global of the warnings module.
+_use_context = sys.flags.context_aware_warnings
+
+
+class _Context:
+    def __init__(self, filters):
+        self._filters = filters
+        self.log = None  # if set to a list, logging is enabled
+
+    def copy(self):
+        context = _Context(self._filters[:])
+        if self.log is not None:
+            context.log = self.log
+        return context
+
+    def _record_warning(self, msg):
+        self.log.append(msg)
+
+
+class _GlobalContext(_Context):
+    def __init__(self):
+        self.log = None
+
+    @property
+    def _filters(self):
+        # Since there is quite a lot of code that assigns to
+        # warnings.filters, this needs to return the current value of
+        # the module global.
+        try:
+            return _wm.filters
+        except AttributeError:
+            # 'filters' global was deleted.  Do we need to actually handle this case?
+            return []
+
+
+_global_context = _GlobalContext()
+
+
+_warnings_context = _contextvars.ContextVar('warnings_context')
+
+
+def _get_context():
+    if not _use_context:
+        return _global_context
+    try:
+        return _wm._warnings_context.get()
+    except LookupError:
+        return _global_context
+
+
+def _set_context(context):
+    assert _use_context
+    _wm._warnings_context.set(context)
+
+
+def _new_context():
+    assert _use_context
+    old_context = _wm._get_context()
+    new_context = old_context.copy()
+    _wm._set_context(new_context)
+    return old_context, new_context
+
+
+def _get_filters():
+    """Return the current list of filters.  This is a non-public API used by
+    module functions and by the unit tests."""
+    return _wm._get_context()._filters
+
+
+def _filters_mutated_lock_held():
+    _wm._filters_version += 1
+
+
+def showwarning(message, category, filename, lineno, file=None, line=None):
+    """Hook to write a warning to a file; replace if you like."""
+    msg = _wm.WarningMessage(message, category, filename, lineno, file, line)
+    _wm._showwarnmsg_impl(msg)
+
+
+def formatwarning(message, category, filename, lineno, line=None):
+    """Function to format a warning the standard way."""
+    msg = _wm.WarningMessage(message, category, filename, lineno, None, line)
+    return _wm._formatwarnmsg_impl(msg)
+
+
+def _showwarnmsg_impl(msg):
+    context = _wm._get_context()
+    if context.log is not None:
+        context._record_warning(msg)
+        return
+    file = msg.file
+    if file is None:
+        file = sys.stderr
+        if file is None:
+            # sys.stderr is None when run with pythonw.exe:
+            # warnings get lost
+            return
+    text = _wm._formatwarnmsg(msg)
+    try:
+        file.write(text)
+    except OSError:
+        # the file (probably stderr) is invalid - this warning gets lost.
+        pass
+
+
+def _formatwarnmsg_impl(msg):
+    category = msg.category.__name__
+    s =  f"{msg.filename}:{msg.lineno}: {category}: {msg.message}\n"
+
+    if msg.line is None:
+        try:
+            import linecache
+            line = linecache.getline(msg.filename, msg.lineno)
+        except Exception:
+            # When a warning is logged during Python shutdown, linecache
+            # and the import machinery don't work anymore
+            line = None
+            linecache = None
+    else:
+        line = msg.line
+    if line:
+        line = line.strip()
+        s += "  %s\n" % line
+
+    if msg.source is not None:
+        try:
+            import tracemalloc
+        # Logging a warning should not raise a new exception:
+        # catch Exception, not only ImportError and RecursionError.
+        except Exception:
+            # don't suggest to enable tracemalloc if it's not available
+            suggest_tracemalloc = False
+            tb = None
+        else:
+            try:
+                suggest_tracemalloc = not tracemalloc.is_tracing()
+                tb = tracemalloc.get_object_traceback(msg.source)
+            except Exception:
+                # When a warning is logged during Python shutdown, tracemalloc
+                # and the import machinery don't work anymore
+                suggest_tracemalloc = False
+                tb = None
+
+        if tb is not None:
+            s += 'Object allocated at (most recent call last):\n'
+            for frame in tb:
+                s += ('  File "%s", lineno %s\n'
+                      % (frame.filename, frame.lineno))
+
+                try:
+                    if linecache is not None:
+                        line = linecache.getline(frame.filename, frame.lineno)
+                    else:
+                        line = None
+                except Exception:
+                    line = None
+                if line:
+                    line = line.strip()
+                    s += '    %s\n' % line
+        elif suggest_tracemalloc:
+            s += (f'{category}: Enable tracemalloc to get the object '
+                  f'allocation traceback\n')
+    return s
+
+
+# Keep a reference to check if the function was replaced
+_showwarning_orig = showwarning
+
+
+def _showwarnmsg(msg):
+    """Hook to write a warning to a file; replace if you like."""
+    try:
+        sw = _wm.showwarning
+    except AttributeError:
+        pass
+    else:
+        if sw is not _showwarning_orig:
+            # warnings.showwarning() was replaced
+            if not callable(sw):
+                raise TypeError("warnings.showwarning() must be set to a "
+                                "function or method")
+
+            sw(msg.message, msg.category, msg.filename, msg.lineno,
+               msg.file, msg.line)
+            return
+    _wm._showwarnmsg_impl(msg)
+
+
+# Keep a reference to check if the function was replaced
+_formatwarning_orig = formatwarning
+
+
+def _formatwarnmsg(msg):
+    """Function to format a warning the standard way."""
+    try:
+        fw = _wm.formatwarning
+    except AttributeError:
+        pass
+    else:
+        if fw is not _formatwarning_orig:
+            # warnings.formatwarning() was replaced
+            return fw(msg.message, msg.category,
+                      msg.filename, msg.lineno, msg.line)
+    return _wm._formatwarnmsg_impl(msg)
+
+
+def filterwarnings(action, message="", category=Warning, module="", lineno=0,
+                   append=False):
+    """Insert an entry into the list of warnings filters (at the front).
+
+    'action' -- one of "error", "ignore", "always", "all", "default", "module",
+                or "once"
+    'message' -- a regex that the warning message must match
+    'category' -- a class that the warning must be a subclass of
+    'module' -- a regex that the module name must match
+    'lineno' -- an integer line number, 0 matches all warnings
+    'append' -- if true, append to the list of filters
+    """
+    if action not in {"error", "ignore", "always", "all", "default", "module", "once"}:
+        raise ValueError(f"invalid action: {action!r}")
+    if not isinstance(message, str):
+        raise TypeError("message must be a string")
+    if not isinstance(category, type) or not issubclass(category, Warning):
+        raise TypeError("category must be a Warning subclass")
+    if not isinstance(module, str):
+        raise TypeError("module must be a string")
+    if not isinstance(lineno, int):
+        raise TypeError("lineno must be an int")
+    if lineno < 0:
+        raise ValueError("lineno must be an int >= 0")
+
+    if message or module:
+        import re
+
+    if message:
+        message = re.compile(message, re.I)
+    else:
+        message = None
+    if module:
+        module = re.compile(module)
+    else:
+        module = None
+
+    _wm._add_filter(action, message, category, module, lineno, append=append)
+
+
+def simplefilter(action, category=Warning, lineno=0, append=False):
+    """Insert a simple entry into the list of warnings filters (at the front).
+
+    A simple filter matches all modules and messages.
+    'action' -- one of "error", "ignore", "always", "all", "default", "module",
+                or "once"
+    'category' -- a class that the warning must be a subclass of
+    'lineno' -- an integer line number, 0 matches all warnings
+    'append' -- if true, append to the list of filters
+    """
+    if action not in {"error", "ignore", "always", "all", "default", "module", "once"}:
+        raise ValueError(f"invalid action: {action!r}")
+    if not isinstance(lineno, int):
+        raise TypeError("lineno must be an int")
+    if lineno < 0:
+        raise ValueError("lineno must be an int >= 0")
+    _wm._add_filter(action, None, category, None, lineno, append=append)
+
+
+def _filters_mutated():
+    # Even though this function is not part of the public API, it's used by
+    # a fair amount of user code.
+    with _wm._lock:
+        _wm._filters_mutated_lock_held()
+
+
+def _add_filter(*item, append):
+    with _wm._lock:
+        filters = _wm._get_filters()
+        if not append:
+            # Remove possible duplicate filters, so new one will be placed
+            # in correct place. If append=True and duplicate exists, do nothing.
+            try:
+                filters.remove(item)
+            except ValueError:
+                pass
+            filters.insert(0, item)
+        else:
+            if item not in filters:
+                filters.append(item)
+        _wm._filters_mutated_lock_held()
+
+
+def resetwarnings():
+    """Clear the list of warning filters, so that no filters are active."""
+    with _wm._lock:
+        del _wm._get_filters()[:]
+        _wm._filters_mutated_lock_held()
+
+
+class _OptionError(Exception):
+    """Exception used by option processing helpers."""
+    pass
+
+
+# Helper to process -W options passed via sys.warnoptions
+def _processoptions(args):
+    for arg in args:
+        try:
+            _wm._setoption(arg)
+        except _wm._OptionError as msg:
+            print("Invalid -W option ignored:", msg, file=sys.stderr)
+
+
+# Helper for _processoptions()
+def _setoption(arg):
+    parts = arg.split(':')
+    if len(parts) > 5:
+        raise _wm._OptionError("too many fields (max 5): %r" % (arg,))
+    while len(parts) < 5:
+        parts.append('')
+    action, message, category, module, lineno = [s.strip()
+                                                 for s in parts]
+    action = _wm._getaction(action)
+    category = _wm._getcategory(category)
+    if message or module:
+        import re
+    if message:
+        message = re.escape(message)
+    if module:
+        module = re.escape(module) + r'\z'
+    if lineno:
+        try:
+            lineno = int(lineno)
+            if lineno < 0:
+                raise ValueError
+        except (ValueError, OverflowError):
+            raise _wm._OptionError("invalid lineno %r" % (lineno,)) from None
+    else:
+        lineno = 0
+    _wm.filterwarnings(action, message, category, module, lineno)
+
+
+# Helper for _setoption()
+def _getaction(action):
+    if not action:
+        return "default"
+    for a in ('default', 'always', 'all', 'ignore', 'module', 'once', 'error'):
+        if a.startswith(action):
+            return a
+    raise _wm._OptionError("invalid action: %r" % (action,))
+
+
+# Helper for _setoption()
+def _getcategory(category):
+    if not category:
+        return Warning
+    if '.' not in category:
+        import builtins as m
+        klass = category
+    else:
+        module, _, klass = category.rpartition('.')
+        try:
+            m = __import__(module, None, None, [klass])
+        except ImportError:
+            raise _wm._OptionError("invalid module name: %r" % (module,)) from None
+    try:
+        cat = getattr(m, klass)
+    except AttributeError:
+        raise _wm._OptionError("unknown warning category: %r" % (category,)) from None
+    if not issubclass(cat, Warning):
+        raise _wm._OptionError("invalid warning category: %r" % (category,))
+    return cat
+
+
+def _is_internal_filename(filename):
+    return 'importlib' in filename and '_bootstrap' in filename
+
+
+def _is_filename_to_skip(filename, skip_file_prefixes):
+    return any(filename.startswith(prefix) for prefix in skip_file_prefixes)
+
+
+def _is_internal_frame(frame):
+    """Signal whether the frame is an internal CPython implementation detail."""
+    return _is_internal_filename(frame.f_code.co_filename)
+
+
+def _next_external_frame(frame, skip_file_prefixes):
+    """Find the next frame that doesn't involve Python or user internals."""
+    frame = frame.f_back
+    while frame is not None and (
+            _is_internal_filename(filename := frame.f_code.co_filename) or
+            _is_filename_to_skip(filename, skip_file_prefixes)):
+        frame = frame.f_back
+    return frame
+
+
+# Code typically replaced by _warnings
+def warn(message, category=None, stacklevel=1, source=None,
+         *, skip_file_prefixes=()):
+    """Issue a warning, or maybe ignore it or raise an exception."""
+    # Check if message is already a Warning object
+    if isinstance(message, Warning):
+        category = message.__class__
+    # Check category argument
+    if category is None:
+        category = UserWarning
+    if not (isinstance(category, type) and issubclass(category, Warning)):
+        raise TypeError("category must be a Warning subclass, "
+                        "not '{:s}'".format(type(category).__name__))
+    if not isinstance(skip_file_prefixes, tuple):
+        # The C version demands a tuple for implementation performance.
+        raise TypeError('skip_file_prefixes must be a tuple of strs.')
+    if skip_file_prefixes:
+        stacklevel = max(2, stacklevel)
+    # Get context information
+    try:
+        if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)):
+            # If frame is too small to care or if the warning originated in
+            # internal code, then do not try to hide any frames.
+            frame = sys._getframe(stacklevel)
+        else:
+            frame = sys._getframe(1)
+            # Look for one frame less since the above line starts us off.
+            for x in range(stacklevel-1):
+                frame = _next_external_frame(frame, skip_file_prefixes)
+                if frame is None:
+                    raise ValueError
+    except ValueError:
+        globals = sys.__dict__
+        filename = "<sys>"
+        lineno = 0
+    else:
+        globals = frame.f_globals
+        filename = frame.f_code.co_filename
+        lineno = frame.f_lineno
+    if '__name__' in globals:
+        module = globals['__name__']
+    else:
+        module = "<string>"
+    registry = globals.setdefault("__warningregistry__", {})
+    _wm.warn_explicit(
+        message,
+        category,
+        filename,
+        lineno,
+        module,
+        registry,
+        globals,
+        source=source,
+    )
+
+
+def warn_explicit(message, category, filename, lineno,
+                  module=None, registry=None, module_globals=None,
+                  source=None):
+    lineno = int(lineno)
+    if module is None:
+        module = filename or "<unknown>"
+        if module[-3:].lower() == ".py":
+            module = module[:-3] # XXX What about leading pathname?
+    if isinstance(message, Warning):
+        text = str(message)
+        category = message.__class__
+    else:
+        text = message
+        message = category(message)
+    key = (text, category, lineno)
+    with _wm._lock:
+        if registry is None:
+            registry = {}
+        if registry.get('version', 0) != _wm._filters_version:
+            registry.clear()
+            registry['version'] = _wm._filters_version
+        # Quick test for common case
+        if registry.get(key):
+            return
+        # Search the filters
+        for item in _wm._get_filters():
+            action, msg, cat, mod, ln = item
+            if ((msg is None or msg.match(text)) and
+                issubclass(category, cat) and
+                (mod is None or mod.match(module)) and
+                (ln == 0 or lineno == ln)):
+                break
+        else:
+            action = _wm.defaultaction
+        # Early exit actions
+        if action == "ignore":
+            return
+
+        if action == "error":
+            raise message
+        # Other actions
+        if action == "once":
+            registry[key] = 1
+            oncekey = (text, category)
+            if _wm.onceregistry.get(oncekey):
+                return
+            _wm.onceregistry[oncekey] = 1
+        elif action in {"always", "all"}:
+            pass
+        elif action == "module":
+            registry[key] = 1
+            altkey = (text, category, 0)
+            if registry.get(altkey):
+                return
+            registry[altkey] = 1
+        elif action == "default":
+            registry[key] = 1
+        else:
+            # Unrecognized actions are errors
+            raise RuntimeError(
+                  "Unrecognized action (%r) in warnings.filters:\n %s" %
+                  (action, item))
+
+    # Prime the linecache for formatting, in case the
+    # "file" is actually in a zipfile or something.
+    import linecache
+    linecache.getlines(filename, module_globals)
+
+    # Print message and context
+    msg = _wm.WarningMessage(message, category, filename, lineno, source=source)
+    _wm._showwarnmsg(msg)
+
+
+class WarningMessage(object):
+
+    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
+                        "line", "source")
+
+    def __init__(self, message, category, filename, lineno, file=None,
+                 line=None, source=None):
+        self.message = message
+        self.category = category
+        self.filename = filename
+        self.lineno = lineno
+        self.file = file
+        self.line = line
+        self.source = source
+        self._category_name = category.__name__ if category else None
+
+    def __str__(self):
+        return ("{message : %r, category : %r, filename : %r, lineno : %s, "
+                    "line : %r}" % (self.message, self._category_name,
+                                    self.filename, self.lineno, self.line))
+
+    def __repr__(self):
+        return f'<{type(self).__qualname__} {self}>'
+
+
+class catch_warnings(object):
+
+    """A context manager that copies and restores the warnings filter upon
+    exiting the context.
+
+    The 'record' argument specifies whether warnings should be captured by a
+    custom implementation of warnings.showwarning() and be appended to a list
+    returned by the context manager. Otherwise None is returned by the context
+    manager. The objects appended to the list are arguments whose attributes
+    mirror the arguments to showwarning().
+
+    The 'module' argument is to specify an alternative module to the module
+    named 'warnings' and imported under that name. This argument is only useful
+    when testing the warnings module itself.
+
+    If the 'action' argument is not None, the remaining arguments are passed
+    to warnings.simplefilter() as if it were called immediately on entering the
+    context.
+    """
+
+    def __init__(self, *, record=False, module=None,
+                 action=None, category=Warning, lineno=0, append=False):
+        """Specify whether to record warnings and if an alternative module
+        should be used other than sys.modules['warnings'].
+
+        """
+        self._record = record
+        self._module = sys.modules['warnings'] if module is None else module
+        self._entered = False
+        if action is None:
+            self._filter = None
+        else:
+            self._filter = (action, category, lineno, append)
+
+    def __repr__(self):
+        args = []
+        if self._record:
+            args.append("record=True")
+        if self._module is not sys.modules['warnings']:
+            args.append("module=%r" % self._module)
+        name = type(self).__name__
+        return "%s(%s)" % (name, ", ".join(args))
+
+    def __enter__(self):
+        if self._entered:
+            raise RuntimeError("Cannot enter %r twice" % self)
+        self._entered = True
+        with _wm._lock:
+            if _use_context:
+                self._saved_context, context = self._module._new_context()
+            else:
+                context = None
+                self._filters = self._module.filters
+                self._module.filters = self._filters[:]
+                self._showwarning = self._module.showwarning
+                self._showwarnmsg_impl = self._module._showwarnmsg_impl
+            self._module._filters_mutated_lock_held()
+            if self._record:
+                if _use_context:
+                    context.log = log = []
+                else:
+                    log = []
+                    self._module._showwarnmsg_impl = log.append
+                    # Reset showwarning() to the default implementation to make sure
+                    # that _showwarnmsg() calls _showwarnmsg_impl()
+                    self._module.showwarning = self._module._showwarning_orig
+            else:
+                log = None
+        if self._filter is not None:
+            self._module.simplefilter(*self._filter)
+        return log
+
+    def __exit__(self, *exc_info):
+        if not self._entered:
+            raise RuntimeError("Cannot exit %r without entering first" % self)
+        with _wm._lock:
+            if _use_context:
+                self._module._warnings_context.set(self._saved_context)
+            else:
+                self._module.filters = self._filters
+                self._module.showwarning = self._showwarning
+                self._module._showwarnmsg_impl = self._showwarnmsg_impl
+            self._module._filters_mutated_lock_held()
+
+
+class deprecated:
+    """Indicate that a class, function or overload is deprecated.
+
+    When this decorator is applied to an object, the type checker
+    will generate a diagnostic on usage of the deprecated object.
+
+    Usage:
+
+        @deprecated("Use B instead")
+        class A:
+            pass
+
+        @deprecated("Use g instead")
+        def f():
+            pass
+
+        @overload
+        @deprecated("int support is deprecated")
+        def g(x: int) -> int: ...
+        @overload
+        def g(x: str) -> int: ...
+
+    The warning specified by *category* will be emitted at runtime
+    on use of deprecated objects. For functions, that happens on calls;
+    for classes, on instantiation and on creation of subclasses.
+    If the *category* is ``None``, no warning is emitted at runtime.
+    The *stacklevel* determines where the
+    warning is emitted. If it is ``1`` (the default), the warning
+    is emitted at the direct caller of the deprecated object; if it
+    is higher, it is emitted further up the stack.
+    Static type checker behavior is not affected by the *category*
+    and *stacklevel* arguments.
+
+    The deprecation message passed to the decorator is saved in the
+    ``__deprecated__`` attribute on the decorated object.
+    If applied to an overload, the decorator
+    must be after the ``@overload`` decorator for the attribute to
+    exist on the overload as returned by ``get_overloads()``.
+
+    See PEP 702 for details.
+
+    """
+    def __init__(
+        self,
+        message: str,
+        /,
+        *,
+        category: type[Warning] | None = DeprecationWarning,
+        stacklevel: int = 1,
+    ) -> None:
+        if not isinstance(message, str):
+            raise TypeError(
+                f"Expected an object of type str for 'message', not {type(message).__name__!r}"
+            )
+        self.message = message
+        self.category = category
+        self.stacklevel = stacklevel
+
+    def __call__(self, arg, /):
+        # Make sure the inner functions created below don't
+        # retain a reference to self.
+        msg = self.message
+        category = self.category
+        stacklevel = self.stacklevel
+        if category is None:
+            arg.__deprecated__ = msg
+            return arg
+        elif isinstance(arg, type):
+            import functools
+            from types import MethodType
+
+            original_new = arg.__new__
+
+            @functools.wraps(original_new)
+            def __new__(cls, /, *args, **kwargs):
+                if cls is arg:
+                    _wm.warn(msg, category=category, stacklevel=stacklevel + 1)
+                if original_new is not object.__new__:
+                    return original_new(cls, *args, **kwargs)
+                # Mirrors a similar check in object.__new__.
+                elif cls.__init__ is object.__init__ and (args or kwargs):
+                    raise TypeError(f"{cls.__name__}() takes no arguments")
+                else:
+                    return original_new(cls)
+
+            arg.__new__ = staticmethod(__new__)
+
+            if "__init_subclass__" in arg.__dict__:
+                # __init_subclass__ is directly present on the decorated class.
+                # Synthesize a wrapper that calls this method directly.
+                original_init_subclass = arg.__init_subclass__
+                # We need slightly different behavior if __init_subclass__
+                # is a bound method (likely if it was implemented in Python).
+                # Otherwise, it likely means it's a builtin such as
+                # object's implementation of __init_subclass__.
+                if isinstance(original_init_subclass, MethodType):
+                    original_init_subclass = original_init_subclass.__func__
+
+                @functools.wraps(original_init_subclass)
+                def __init_subclass__(*args, **kwargs):
+                    _wm.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return original_init_subclass(*args, **kwargs)
+            else:
+                def __init_subclass__(cls, *args, **kwargs):
+                    _wm.warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return super(arg, cls).__init_subclass__(*args, **kwargs)
+
+            arg.__init_subclass__ = classmethod(__init_subclass__)
+
+            arg.__deprecated__ = __new__.__deprecated__ = msg
+            __init_subclass__.__deprecated__ = msg
+            return arg
+        elif callable(arg):
+            import functools
+            import inspect
+
+            @functools.wraps(arg)
+            def wrapper(*args, **kwargs):
+                _wm.warn(msg, category=category, stacklevel=stacklevel + 1)
+                return arg(*args, **kwargs)
+
+            if inspect.iscoroutinefunction(arg):
+                wrapper = inspect.markcoroutinefunction(wrapper)
+
+            arg.__deprecated__ = wrapper.__deprecated__ = msg
+            return wrapper
+        else:
+            raise TypeError(
+                "@deprecated decorator with non-None category must be applied to "
+                f"a class or callable, not {arg!r}"
+            )
+
+
+_DEPRECATED_MSG = "{name!r} is deprecated and slated for removal in Python {remove}"
+
+
+def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_info):
+    """Warn that *name* is deprecated or should be removed.
+
+    RuntimeError is raised if *remove* specifies a major/minor tuple older than
+    the current Python version or the same version but past the alpha.
+
+    The *message* argument is formatted with *name* and *remove* as a Python
+    version tuple (e.g. (3, 11)).
+
+    """
+    remove_formatted = f"{remove[0]}.{remove[1]}"
+    if (_version[:2] > remove) or (_version[:2] == remove and _version[3] != "alpha"):
+        msg = f"{name!r} was slated for removal after Python {remove_formatted} alpha"
+        raise RuntimeError(msg)
+    else:
+        msg = message.format(name=name, remove=remove_formatted)
+        _wm.warn(msg, DeprecationWarning, stacklevel=3)
+
+
+# Private utility function called by _PyErr_WarnUnawaitedCoroutine
+def _warn_unawaited_coroutine(coro):
+    msg_lines = [
+        f"coroutine '{coro.__qualname__}' was never awaited\n"
+    ]
+    if coro.cr_origin is not None:
+        import linecache, traceback
+        def extract():
+            for filename, lineno, funcname in reversed(coro.cr_origin):
+                line = linecache.getline(filename, lineno)
+                yield (filename, lineno, funcname, line)
+        msg_lines.append("Coroutine created at (most recent call last)\n")
+        msg_lines += traceback.format_list(list(extract()))
+    msg = "".join(msg_lines).rstrip("\n")
+    # Passing source= here means that if the user happens to have tracemalloc
+    # enabled and tracking where the coroutine was created, the warning will
+    # contain that traceback. This does mean that if they have *both*
+    # coroutine origin tracking *and* tracemalloc enabled, they'll get two
+    # partially-redundant tracebacks. If we wanted to be clever we could
+    # probably detect this case and avoid it, but for now we don't bother.
+    _wm.warn(
+        msg, category=RuntimeWarning, stacklevel=2, source=coro
+    )
+
+
+def _setup_defaults():
+    # Several warning categories are ignored by default in regular builds
+    if hasattr(sys, 'gettotalrefcount'):
+        return
+    _wm.filterwarnings("default", category=DeprecationWarning, module="__main__", append=1)
+    _wm.simplefilter("ignore", category=DeprecationWarning, append=1)
+    _wm.simplefilter("ignore", category=PendingDeprecationWarning, append=1)
+    _wm.simplefilter("ignore", category=ImportWarning, append=1)
+    _wm.simplefilter("ignore", category=ResourceWarning, append=1)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index b65e1291bbc..c3a23ffa666 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -882,6 +882,7 @@ def test_subinterp_intern_singleton(self):
                     '''))
                 self.assertTrue(sys._is_interned(s))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON needs update for context_aware_warnings
     def test_sys_flags(self):
         self.assertTrue(sys.flags)
         attrs = ("debug",
diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index ae9a365e1c9..fb324294f47 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -24,10 +24,13 @@
 from warnings import deprecated
 
 
-py_warnings = import_helper.import_fresh_module('warnings',
-                                                blocked=['_warnings'])
-c_warnings = import_helper.import_fresh_module('warnings',
-                                               fresh=['_warnings'])
+py_warnings = import_helper.import_fresh_module('_py_warnings')
+py_warnings._set_module(py_warnings)
+
+c_warnings = import_helper.import_fresh_module(
+    "warnings", fresh=["_warnings", "_py_warnings"]
+)
+c_warnings._set_module(c_warnings)
 
 @contextmanager
 def warnings_state(module):
@@ -43,15 +46,21 @@ def warnings_state(module):
     except NameError:
         pass
     original_warnings = warning_tests.warnings
-    original_filters = module.filters
-    try:
+    if module._use_context:
+        saved_context, context = module._new_context()
+    else:
+        original_filters = module.filters
         module.filters = original_filters[:]
+    try:
         module.simplefilter("once")
         warning_tests.warnings = module
         yield
     finally:
         warning_tests.warnings = original_warnings
-        module.filters = original_filters
+        if module._use_context:
+            module._set_context(saved_context)
+        else:
+            module.filters = original_filters
 
 
 class TestWarning(Warning):
@@ -92,8 +101,9 @@ class PublicAPITests(BaseTest):
     public API.
     """
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON 'PyPublicAPITests' object has no attribute 'assertHasAttr'
     def test_module_all_attribute(self):
-        self.assertTrue(hasattr(self.module, '__all__'))
+        self.assertHasAttr(self.module, '__all__')
         target_api = ["warn", "warn_explicit", "showwarning",
                       "formatwarning", "filterwarnings", "simplefilter",
                       "resetwarnings", "catch_warnings", "deprecated"]
@@ -111,14 +121,14 @@ class FilterTests(BaseTest):
     """Testing the filtering functionality."""
 
     def test_error(self):
-        with original_warnings.catch_warnings(module=self.module) as w:
+        with self.module.catch_warnings() as w:
             self.module.resetwarnings()
             self.module.filterwarnings("error", category=UserWarning)
             self.assertRaises(UserWarning, self.module.warn,
                                 "FilterTests.test_error")
 
     def test_error_after_default(self):
-        with original_warnings.catch_warnings(module=self.module) as w:
+        with self.module.catch_warnings() as w:
             self.module.resetwarnings()
             message = "FilterTests.test_ignore_after_default"
             def f():
@@ -136,8 +146,7 @@ def f():
             self.assertRaises(UserWarning, f)
 
     def test_ignore(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("ignore", category=UserWarning)
             self.module.warn("FilterTests.test_ignore", UserWarning)
@@ -145,8 +154,7 @@ def test_ignore(self):
             self.assertEqual(list(__warningregistry__), ['version'])
 
     def test_ignore_after_default(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             message = "FilterTests.test_ignore_after_default"
             def f():
@@ -157,44 +165,43 @@ def f():
             f()
             self.assertEqual(len(w), 1)
 
-    def test_always(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
-            self.module.resetwarnings()
-            self.module.filterwarnings("always", category=UserWarning)
-            message = "FilterTests.test_always"
-            def f():
-                self.module.warn(message, UserWarning)
-            f()
-            self.assertEqual(len(w), 1)
-            self.assertEqual(w[-1].message.args[0], message)
-            f()
-            self.assertEqual(len(w), 2)
-            self.assertEqual(w[-1].message.args[0], message)
+    def test_always_and_all(self):
+        for mode in {"always", "all"}:
+            with self.module.catch_warnings(record=True) as w:
+                self.module.resetwarnings()
+                self.module.filterwarnings(mode, category=UserWarning)
+                message = "FilterTests.test_always_and_all"
+                def f():
+                    self.module.warn(message, UserWarning)
+                f()
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[-1].message.args[0], message)
+                f()
+                self.assertEqual(len(w), 2)
+                self.assertEqual(w[-1].message.args[0], message)
 
-    def test_always_after_default(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
-            self.module.resetwarnings()
-            message = "FilterTests.test_always_after_ignore"
-            def f():
-                self.module.warn(message, UserWarning)
-            f()
-            self.assertEqual(len(w), 1)
-            self.assertEqual(w[-1].message.args[0], message)
-            f()
-            self.assertEqual(len(w), 1)
-            self.module.filterwarnings("always", category=UserWarning)
-            f()
-            self.assertEqual(len(w), 2)
-            self.assertEqual(w[-1].message.args[0], message)
-            f()
-            self.assertEqual(len(w), 3)
-            self.assertEqual(w[-1].message.args[0], message)
+    def test_always_and_all_after_default(self):
+        for mode in {"always", "all"}:
+            with self.module.catch_warnings(record=True) as w:
+                self.module.resetwarnings()
+                message = "FilterTests.test_always_and_all_after_ignore"
+                def f():
+                    self.module.warn(message, UserWarning)
+                f()
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[-1].message.args[0], message)
+                f()
+                self.assertEqual(len(w), 1)
+                self.module.filterwarnings(mode, category=UserWarning)
+                f()
+                self.assertEqual(len(w), 2)
+                self.assertEqual(w[-1].message.args[0], message)
+                f()
+                self.assertEqual(len(w), 3)
+                self.assertEqual(w[-1].message.args[0], message)
 
     def test_default(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("default", category=UserWarning)
             message = UserWarning("FilterTests.test_default")
@@ -209,8 +216,7 @@ def test_default(self):
                     raise ValueError("loop variant unhandled")
 
     def test_module(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("module", category=UserWarning)
             message = UserWarning("FilterTests.test_module")
@@ -221,8 +227,7 @@ def test_module(self):
             self.assertEqual(len(w), 0)
 
     def test_once(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("once", category=UserWarning)
             message = UserWarning("FilterTests.test_once")
@@ -237,9 +242,88 @@ def test_once(self):
                                     42)
             self.assertEqual(len(w), 0)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON re.PatternError: bad escape \z at position 15
+    def test_filter_module(self):
+        MS_WINDOWS = (sys.platform == 'win32')
+        with self.module.catch_warnings(record=True) as w:
+            self.module.simplefilter('error')
+            self.module.filterwarnings('always', module=r'package\.module\z')
+            self.module.warn_explicit('msg', UserWarning, 'filename', 42,
+                                      module='package.module')
+            self.assertEqual(len(w), 1)
+            with self.assertRaises(UserWarning):
+                self.module.warn_explicit('msg', UserWarning, '/path/to/package/module', 42)
+            with self.assertRaises(UserWarning):
+                self.module.warn_explicit('msg', UserWarning, '/path/to/package/module.py', 42)
+
+        with self.module.catch_warnings(record=True) as w:
+            self.module.simplefilter('error')
+            self.module.filterwarnings('always', module='package')
+            self.module.warn_explicit('msg', UserWarning, 'filename', 42,
+                                      module='package.module')
+            self.assertEqual(len(w), 1)
+            with self.assertRaises(UserWarning):
+                self.module.warn_explicit('msg', UserWarning, 'filename', 42,
+                                          module='other.package.module')
+            with self.assertRaises(UserWarning):
+                self.module.warn_explicit('msg', UserWarning, '/path/to/otherpackage/module.py', 42)
+
+        with self.module.catch_warnings(record=True) as w:
+            self.module.simplefilter('error')
+            self.module.filterwarnings('always', module=r'/path/to/package/module\z')
+            self.module.warn_explicit('msg', UserWarning, '/path/to/package/module', 42)
+            self.assertEqual(len(w), 1)
+            self.module.warn_explicit('msg', UserWarning, '/path/to/package/module.py', 42)
+            self.assertEqual(len(w), 2)
+            with self.assertRaises(UserWarning):
+                self.module.warn_explicit('msg', UserWarning, '/PATH/TO/PACKAGE/MODULE', 42)
+            if MS_WINDOWS:
+                if self.module is py_warnings:
+                    self.module.warn_explicit('msg', UserWarning, r'/path/to/package/module.PY', 42)
+                    self.assertEqual(len(w), 3)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'/path/to/package/module/__init__.py', 42)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'/path/to/package/module.pyw', 42)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'\path\to\package\module', 42)
+
+        with self.module.catch_warnings(record=True) as w:
+            self.module.simplefilter('error')
+            self.module.filterwarnings('always', module=r'/path/to/package/__init__\z')
+            self.module.warn_explicit('msg', UserWarning, '/path/to/package/__init__.py', 42)
+            self.assertEqual(len(w), 1)
+            self.module.warn_explicit('msg', UserWarning, '/path/to/package/__init__', 42)
+            self.assertEqual(len(w), 2)
+
+        if MS_WINDOWS:
+            with self.module.catch_warnings(record=True) as w:
+                self.module.simplefilter('error')
+                self.module.filterwarnings('always', module=r'C:\\path\\to\\package\\module\z')
+                self.module.warn_explicit('msg', UserWarning, r'C:\path\to\package\module', 42)
+                self.assertEqual(len(w), 1)
+                self.module.warn_explicit('msg', UserWarning, r'C:\path\to\package\module.py', 42)
+                self.assertEqual(len(w), 2)
+                if self.module is py_warnings:
+                    self.module.warn_explicit('msg', UserWarning, r'C:\path\to\package\module.PY', 42)
+                    self.assertEqual(len(w), 3)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'C:\path\to\package\module.pyw', 42)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'C:\PATH\TO\PACKAGE\MODULE', 42)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'C:/path/to/package/module', 42)
+                with self.assertRaises(UserWarning):
+                    self.module.warn_explicit('msg', UserWarning, r'C:\path\to\package\module\__init__.py', 42)
+
+        with self.module.catch_warnings(record=True) as w:
+            self.module.simplefilter('error')
+            self.module.filterwarnings('always', module=r'<unknown>\z')
+            self.module.warn_explicit('msg', UserWarning, '', 42)
+            self.assertEqual(len(w), 1)
+
     def test_module_globals(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.simplefilter("always", UserWarning)
 
             # bpo-33509: module_globals=None must not crash
@@ -259,15 +343,14 @@ def test_module_globals(self):
             self.assertEqual(len(w), 2)
 
     def test_inheritance(self):
-        with original_warnings.catch_warnings(module=self.module) as w:
+        with self.module.catch_warnings() as w:
             self.module.resetwarnings()
             self.module.filterwarnings("error", category=Warning)
             self.assertRaises(UserWarning, self.module.warn,
                                 "FilterTests.test_inheritance", UserWarning)
 
     def test_ordering(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("ignore", category=UserWarning)
             self.module.filterwarnings("error", category=UserWarning,
@@ -282,8 +365,7 @@ def test_ordering(self):
     def test_filterwarnings(self):
         # Test filterwarnings().
         # Implicitly also tests resetwarnings().
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.filterwarnings("error", "", Warning, "", 0)
             self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 
@@ -307,8 +389,7 @@ def test_filterwarnings(self):
             self.assertIs(w[-1].category, UserWarning)
 
     def test_message_matching(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.simplefilter("ignore", UserWarning)
             self.module.filterwarnings("error", "match", UserWarning)
             self.assertRaises(UserWarning, self.module.warn, "match")
@@ -324,54 +405,52 @@ def match(self, a):
                 L[:] = []
 
         L = [("default",X(),UserWarning,X(),0) for i in range(2)]
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.filters = L
             self.module.warn_explicit(UserWarning("b"), None, "f.py", 42)
             self.assertEqual(str(w[-1].message), "b")
 
     def test_filterwarnings_duplicate_filters(self):
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.resetwarnings()
             self.module.filterwarnings("error", category=UserWarning)
-            self.assertEqual(len(self.module.filters), 1)
+            self.assertEqual(len(self.module._get_filters()), 1)
             self.module.filterwarnings("ignore", category=UserWarning)
             self.module.filterwarnings("error", category=UserWarning)
             self.assertEqual(
-                len(self.module.filters), 2,
+                len(self.module._get_filters()), 2,
                 "filterwarnings inserted duplicate filter"
             )
             self.assertEqual(
-                self.module.filters[0][0], "error",
+                self.module._get_filters()[0][0], "error",
                 "filterwarnings did not promote filter to "
                 "the beginning of list"
             )
 
     def test_simplefilter_duplicate_filters(self):
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.resetwarnings()
             self.module.simplefilter("error", category=UserWarning)
-            self.assertEqual(len(self.module.filters), 1)
+            self.assertEqual(len(self.module._get_filters()), 1)
             self.module.simplefilter("ignore", category=UserWarning)
             self.module.simplefilter("error", category=UserWarning)
             self.assertEqual(
-                len(self.module.filters), 2,
+                len(self.module._get_filters()), 2,
                 "simplefilter inserted duplicate filter"
             )
             self.assertEqual(
-                self.module.filters[0][0], "error",
+                self.module._get_filters()[0][0], "error",
                 "simplefilter did not promote filter to the beginning of list"
             )
 
     def test_append_duplicate(self):
-        with original_warnings.catch_warnings(module=self.module,
-                record=True) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.simplefilter("ignore")
             self.module.simplefilter("error", append=True)
             self.module.simplefilter("ignore", append=True)
             self.module.warn("test_append_duplicate", category=UserWarning)
-            self.assertEqual(len(self.module.filters), 2,
+            self.assertEqual(len(self.module._get_filters()), 2,
                 "simplefilter inserted duplicate filter"
             )
             self.assertEqual(len(w), 0,
@@ -401,19 +480,17 @@ def test_argument_validation(self):
             self.module.simplefilter('ignore', lineno=-1)
 
     def test_catchwarnings_with_simplefilter_ignore(self):
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings(module=self.module):
             self.module.resetwarnings()
             self.module.simplefilter("error")
-            with self.module.catch_warnings(
-                module=self.module, action="ignore"
-            ):
+            with self.module.catch_warnings(action="ignore"):
                 self.module.warn("This will be ignored")
 
     def test_catchwarnings_with_simplefilter_error(self):
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.resetwarnings()
             with self.module.catch_warnings(
-                module=self.module, action="error", category=FutureWarning
+                action="error", category=FutureWarning
             ):
                 with support.captured_stderr() as stderr:
                     error_msg = "Other types of warnings are not errors"
@@ -435,8 +512,7 @@ class WarnTests(BaseTest):
     """Test warnings.warn() and warnings.warn_explicit()."""
 
     def test_message(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.simplefilter("once")
             for i in range(4):
                 text = 'multi %d' %i  # Different text on each call.
@@ -448,8 +524,7 @@ def test_message(self):
     def test_warn_nonstandard_types(self):
         # warn() should handle non-standard types without issue.
         for ob in (Warning, None, 42):
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 self.module.simplefilter("once")
                 self.module.warn(ob)
                 # Don't directly compare objects since
@@ -458,8 +533,7 @@ def test_warn_nonstandard_types(self):
 
     def test_filename(self):
         with warnings_state(self.module):
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 warning_tests.inner("spam1")
                 self.assertEqual(os.path.basename(w[-1].filename),
                                     "stacklevel.py")
@@ -471,8 +545,7 @@ def test_stacklevel(self):
         # Test stacklevel argument
         # make sure all messages are different, so the warning won't be skipped
         with warnings_state(self.module):
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 warning_tests.inner("spam3", stacklevel=1)
                 self.assertEqual(os.path.basename(w[-1].filename),
                                     "stacklevel.py")
@@ -494,23 +567,20 @@ def test_stacklevel(self):
                 self.assertEqual(os.path.basename(w[-1].filename),
                                     "<sys>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_stacklevel_import(self):
         # Issue #24305: With stacklevel=2, module-level warnings should work.
         import_helper.unload('test.test_warnings.data.import_warning')
         with warnings_state(self.module):
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 self.module.simplefilter('always')
-                import test.test_warnings.data.import_warning
+                import test.test_warnings.data.import_warning  # noqa: F401
                 self.assertEqual(len(w), 1)
                 self.assertEqual(w[0].filename, __file__)
 
     def test_skip_file_prefixes(self):
         with warnings_state(self.module):
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 self.module.simplefilter('always')
 
                 # Warning never attributed to the data/ package.
@@ -533,6 +603,16 @@ def test_skip_file_prefixes(self):
                 warning_tests.package("prefix02", stacklevel=3)
                 self.assertIn("unittest", w[-1].filename)
 
+    def test_skip_file_prefixes_file_path(self):
+        # see: gh-126209
+        with warnings_state(self.module):
+            skipped = warning_tests.__file__
+            with self.module.catch_warnings(record=True) as w:
+                warning_tests.outer("msg", skip_file_prefixes=(skipped,))
+
+            self.assertEqual(len(w), 1)
+            self.assertNotEqual(w[-1].filename, skipped)
+
     def test_skip_file_prefixes_type_errors(self):
         with warnings_state(self.module):
             warn = warning_tests.warnings.warn
@@ -548,23 +628,16 @@ def test_exec_filename(self):
         codeobj = compile(("import warnings\n"
                            "warnings.warn('hello', UserWarning)"),
                           filename, "exec")
-        with original_warnings.catch_warnings(record=True) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.simplefilter("always", category=UserWarning)
             exec(codeobj)
         self.assertEqual(w[0].filename, filename)
 
     def test_warn_explicit_non_ascii_filename(self):
-        with original_warnings.catch_warnings(record=True,
-                module=self.module) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("always", category=UserWarning)
-            filenames = ["nonascii\xe9\u20ac"]
-            if not support.is_emscripten:
-                # JavaScript does not like surrogates.
-                # Invalid UTF-8 leading byte 0x80 encountered when
-                # deserializing a UTF-8 string in wasm memory to a JS
-                # string!
-                filenames.append("surrogate\udc80")
+            filenames = ["nonascii\xe9\u20ac", "surrogate\udc80"]
             for filename in filenames:
                 try:
                     os.fsencode(filename)
@@ -625,7 +698,7 @@ class NonWarningSubclass:
         self.assertIn('category must be a Warning subclass, not ',
                       str(cm.exception))
 
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.resetwarnings()
             self.module.filterwarnings('default')
             with self.assertWarns(MyWarningClass) as cm:
@@ -641,7 +714,7 @@ class NonWarningSubclass:
             self.assertIsInstance(cm.warning, Warning)
 
     def check_module_globals(self, module_globals):
-        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.filterwarnings('default')
             self.module.warn_explicit(
                 'eggs', UserWarning, 'bar', 1,
@@ -654,7 +727,7 @@ def check_module_globals_error(self, module_globals, errmsg, errtype=ValueError)
         if self.module is py_warnings:
             self.check_module_globals(module_globals)
             return
-        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.filterwarnings('always')
             with self.assertRaisesRegex(errtype, re.escape(errmsg)):
                 self.module.warn_explicit(
@@ -666,7 +739,7 @@ def check_module_globals_deprecated(self, module_globals, msg):
         if self.module is py_warnings:
             self.check_module_globals(module_globals)
             return
-        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+        with self.module.catch_warnings(record=True) as w:
             self.module.filterwarnings('always')
             self.module.warn_explicit(
                 'eggs', UserWarning, 'bar', 1,
@@ -734,62 +807,54 @@ def test_gh86298_no_loader_with_spec_loader_okay(self):
 class CWarnTests(WarnTests, unittest.TestCase):
     module = c_warnings
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # As an early adopter, we sanity check the
     # test.import_helper.import_fresh_module utility function
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_accelerated(self):
         self.assertIsNot(original_warnings, self.module)
-        self.assertFalse(hasattr(self.module.warn, '__code__'))
+        self.assertNotHasAttr(self.module.warn, '__code__')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gh86298_no_loader_and_spec_is_none(self):
-        return super().test_gh86298_no_loader_and_spec_is_none()
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_gh86298_loader_and_spec_loader_disagree(self):
+        return super().test_gh86298_loader_and_spec_loader_disagree()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gh86298_loader_is_none_and_spec_is_none(self):
         return super().test_gh86298_loader_is_none_and_spec_is_none()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
         return super().test_gh86298_loader_is_none_and_spec_loader_is_none()
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_gh86298_no_loader_and_no_spec_loader(self):
+        return super().test_gh86298_no_loader_and_no_spec_loader()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_gh86298_no_loader_and_spec_is_none(self):
+        return super().test_gh86298_no_loader_and_spec_is_none()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gh86298_no_spec(self):
         return super().test_gh86298_no_spec()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gh86298_spec_is_none(self):
-        return super().test_gh86298_spec_is_none()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gh86298_no_spec_loader(self):
         return super().test_gh86298_no_spec_loader()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gh86298_loader_and_spec_loader_disagree(self):
-        return super().test_gh86298_loader_and_spec_loader_disagree()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_gh86298_no_loader_and_no_spec_loader(self):
-        return super().test_gh86298_no_loader_and_no_spec_loader()
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_gh86298_spec_is_none(self):
+        return super().test_gh86298_spec_is_none()
 
 class PyWarnTests(WarnTests, unittest.TestCase):
     module = py_warnings
 
     # As an early adopter, we sanity check the
     # test.import_helper.import_fresh_module utility function
+    @unittest.expectedFailure # TODO: RUSTPYTHON 'PyWarnTests' object has no attribute 'assertHasAttr'
     def test_pure_python(self):
         self.assertIsNot(original_warnings, self.module)
-        self.assertTrue(hasattr(self.module.warn, '__code__'))
+        self.assertHasAttr(self.module.warn, '__code__')
 
 
 class WCmdLineTests(BaseTest):
@@ -797,7 +862,7 @@ class WCmdLineTests(BaseTest):
     def test_improper_input(self):
         # Uses the private _setoption() function to test the parsing
         # of command-line warning arguments
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.assertRaises(self.module._OptionError,
                               self.module._setoption, '1:2:3:4:5:6')
             self.assertRaises(self.module._OptionError,
@@ -816,7 +881,7 @@ def test_improper_input(self):
             self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 
     def test_import_from_module(self):
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module._setoption('ignore::Warning')
             with self.assertRaises(self.module._OptionError):
                 self.module._setoption('ignore::TestWarning')
@@ -857,11 +922,10 @@ class _WarningsTests(BaseTest, unittest.TestCase):
 
     module = c_warnings
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_filter(self):
         # Everything should function even if 'filters' is not in warnings.
-        with original_warnings.catch_warnings(module=self.module) as w:
+        with self.module.catch_warnings() as w:
             self.module.filterwarnings("error", "", Warning, "", 0)
             self.assertRaises(UserWarning, self.module.warn,
                                 'convert to error')
@@ -869,8 +933,7 @@ def test_filter(self):
             self.assertRaises(UserWarning, self.module.warn,
                                 'convert to error')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_onceregistry(self):
         # Replacing or removing the onceregistry should be okay.
         global __warningregistry__
@@ -878,8 +941,7 @@ def test_onceregistry(self):
         try:
             original_registry = self.module.onceregistry
             __warningregistry__ = {}
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 self.module.resetwarnings()
                 self.module.filterwarnings("once", category=UserWarning)
                 self.module.warn_explicit(message, UserWarning, "file", 42)
@@ -901,15 +963,13 @@ def test_onceregistry(self):
         finally:
             self.module.onceregistry = original_registry
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_default_action(self):
         # Replacing or removing defaultaction should be okay.
         message = UserWarning("defaultaction test")
         original = self.module.defaultaction
         try:
-            with original_warnings.catch_warnings(record=True,
-                    module=self.module) as w:
+            with self.module.catch_warnings(record=True) as w:
                 self.module.resetwarnings()
                 registry = {}
                 self.module.warn_explicit(message, UserWarning, "<test>", 42,
@@ -942,8 +1002,12 @@ def test_default_action(self):
 
     def test_showwarning_missing(self):
         # Test that showwarning() missing is okay.
+        if self.module._use_context:
+            # If _use_context is true, the warnings module does not
+            # override/restore showwarning()
+            return
         text = 'del showwarning test'
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.filterwarnings("always", category=UserWarning)
             del self.module.showwarning
             with support.captured_output('stderr') as stream:
@@ -951,12 +1015,11 @@ def test_showwarning_missing(self):
                 result = stream.getvalue()
         self.assertIn(text, result)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_showwarnmsg_missing(self):
         # Test that _showwarnmsg() missing is okay.
         text = 'del _showwarnmsg test'
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.filterwarnings("always", category=UserWarning)
 
             show = self.module._showwarnmsg
@@ -970,50 +1033,55 @@ def test_showwarnmsg_missing(self):
         self.assertIn(text, result)
 
     def test_showwarning_not_callable(self):
-        with original_warnings.catch_warnings(module=self.module):
-            self.module.filterwarnings("always", category=UserWarning)
-            self.module.showwarning = print
-            with support.captured_output('stdout'):
-                self.module.warn('Warning!')
-            self.module.showwarning = 23
-            self.assertRaises(TypeError, self.module.warn, "Warning!")
+        orig = self.module.showwarning
+        try:
+            with self.module.catch_warnings():
+                self.module.filterwarnings("always", category=UserWarning)
+                self.module.showwarning = print
+                with support.captured_output('stdout'):
+                    self.module.warn('Warning!')
+                self.module.showwarning = 23
+                self.assertRaises(TypeError, self.module.warn, "Warning!")
+        finally:
+            self.module.showwarning = orig
 
     def test_show_warning_output(self):
         # With showwarning() missing, make sure that output is okay.
-        text = 'test show_warning'
-        with original_warnings.catch_warnings(module=self.module):
-            self.module.filterwarnings("always", category=UserWarning)
-            del self.module.showwarning
-            with support.captured_output('stderr') as stream:
-                warning_tests.inner(text)
-                result = stream.getvalue()
-        self.assertEqual(result.count('\n'), 2,
-                             "Too many newlines in %r" % result)
-        first_line, second_line = result.split('\n', 1)
-        expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
-        first_line_parts = first_line.rsplit(':', 3)
-        path, line, warning_class, message = first_line_parts
-        line = int(line)
-        self.assertEqual(expected_file, path)
-        self.assertEqual(warning_class, ' ' + UserWarning.__name__)
-        self.assertEqual(message, ' ' + text)
-        expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
-        assert expected_line
-        self.assertEqual(second_line, expected_line)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        orig = self.module.showwarning
+        try:
+            text = 'test show_warning'
+            with self.module.catch_warnings():
+                self.module.filterwarnings("always", category=UserWarning)
+                del self.module.showwarning
+                with support.captured_output('stderr') as stream:
+                    warning_tests.inner(text)
+                    result = stream.getvalue()
+            self.assertEqual(result.count('\n'), 2,
+                                 "Too many newlines in %r" % result)
+            first_line, second_line = result.split('\n', 1)
+            expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
+            first_line_parts = first_line.rsplit(':', 3)
+            path, line, warning_class, message = first_line_parts
+            line = int(line)
+            self.assertEqual(expected_file, path)
+            self.assertEqual(warning_class, ' ' + UserWarning.__name__)
+            self.assertEqual(message, ' ' + text)
+            expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
+            assert expected_line
+            self.assertEqual(second_line, expected_line)
+        finally:
+            self.module.showwarning = orig
+
     def test_filename_none(self):
         # issue #12467: race condition if a warning is emitted at shutdown
         globals_dict = globals()
         oldfile = globals_dict['__file__']
         try:
-            catch = original_warnings.catch_warnings(record=True,
-                                                     module=self.module)
+            catch = self.module.catch_warnings(record=True)
             with catch as w:
                 self.module.filterwarnings("always", category=UserWarning)
                 globals_dict['__file__'] = None
-                original_warnings.warn('test', UserWarning)
+                self.module.warn('test', UserWarning)
                 self.assertTrue(len(w))
         finally:
             globals_dict['__file__'] = oldfile
@@ -1027,8 +1095,7 @@ def test_stderr_none(self):
         self.assertNotIn(b'Warning!', stderr)
         self.assertNotIn(b'Error', stderr)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue31285(self):
         # warn_explicit() should neither raise a SystemError nor cause an
         # assertion failure, in case the return value of get_source() has a
@@ -1052,7 +1119,7 @@ def get_source(self, fullname):
 
 
         wmod = self.module
-        with original_warnings.catch_warnings(module=wmod):
+        with wmod.catch_warnings():
             wmod.filterwarnings('default', category=UserWarning)
 
             linecache.clearcache()
@@ -1079,7 +1146,7 @@ def test_issue31411(self):
         # warn_explicit() shouldn't raise a SystemError in case
         # warnings.onceregistry isn't a dictionary.
         wmod = self.module
-        with original_warnings.catch_warnings(module=wmod):
+        with wmod.catch_warnings():
             wmod.filterwarnings('once')
             with support.swap_attr(wmod, 'onceregistry', None):
                 with self.assertRaises(TypeError):
@@ -1090,12 +1157,12 @@ def test_issue31416(self):
         # warn_explicit() shouldn't cause an assertion failure in case of a
         # bad warnings.filters or warnings.defaultaction.
         wmod = self.module
-        with original_warnings.catch_warnings(module=wmod):
-            wmod.filters = [(None, None, Warning, None, 0)]
+        with wmod.catch_warnings():
+            wmod._get_filters()[:] = [(None, None, Warning, None, 0)]
             with self.assertRaises(TypeError):
                 wmod.warn_explicit('foo', Warning, 'bar', 1)
 
-            wmod.filters = []
+            wmod._get_filters()[:] = []
             with support.swap_attr(wmod, 'defaultaction', None), \
                  self.assertRaises(TypeError):
                 wmod.warn_explicit('foo', Warning, 'bar', 1)
@@ -1104,7 +1171,7 @@ def test_issue31416(self):
     def test_issue31566(self):
         # warn() shouldn't cause an assertion failure in case of a bad
         # __name__ global.
-        with original_warnings.catch_warnings(module=self.module):
+        with self.module.catch_warnings():
             self.module.filterwarnings('error', category=UserWarning)
             with support.swap_item(globals(), '__name__', b'foo'), \
                  support.swap_item(globals(), '__file__', None):
@@ -1181,8 +1248,7 @@ class CWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
 class PyWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
     module = py_warnings
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tracemalloc(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
 
@@ -1234,16 +1300,18 @@ class CatchWarningTests(BaseTest):
     """Test catch_warnings()."""
 
     def test_catch_warnings_restore(self):
+        if self.module._use_context:
+            return  # test disabled if using context vars
         wmod = self.module
         orig_filters = wmod.filters
         orig_showwarning = wmod.showwarning
         # Ensure both showwarning and filters are restored when recording
-        with wmod.catch_warnings(module=wmod, record=True):
+        with wmod.catch_warnings(record=True):
             wmod.filters = wmod.showwarning = object()
         self.assertIs(wmod.filters, orig_filters)
         self.assertIs(wmod.showwarning, orig_showwarning)
         # Same test, but with recording disabled
-        with wmod.catch_warnings(module=wmod, record=False):
+        with wmod.catch_warnings(record=False):
             wmod.filters = wmod.showwarning = object()
         self.assertIs(wmod.filters, orig_filters)
         self.assertIs(wmod.showwarning, orig_showwarning)
@@ -1251,7 +1319,7 @@ def test_catch_warnings_restore(self):
     def test_catch_warnings_recording(self):
         wmod = self.module
         # Ensure warnings are recorded when requested
-        with wmod.catch_warnings(module=wmod, record=True) as w:
+        with wmod.catch_warnings(record=True) as w:
             self.assertEqual(w, [])
             self.assertIs(type(w), list)
             wmod.simplefilter("always")
@@ -1265,44 +1333,48 @@ def test_catch_warnings_recording(self):
             self.assertEqual(w, [])
         # Ensure warnings are not recorded when not requested
         orig_showwarning = wmod.showwarning
-        with wmod.catch_warnings(module=wmod, record=False) as w:
+        with wmod.catch_warnings(record=False) as w:
             self.assertIsNone(w)
             self.assertIs(wmod.showwarning, orig_showwarning)
 
     def test_catch_warnings_reentry_guard(self):
         wmod = self.module
         # Ensure catch_warnings is protected against incorrect usage
-        x = wmod.catch_warnings(module=wmod, record=True)
+        x = wmod.catch_warnings(record=True)
         self.assertRaises(RuntimeError, x.__exit__)
         with x:
             self.assertRaises(RuntimeError, x.__enter__)
         # Same test, but with recording disabled
-        x = wmod.catch_warnings(module=wmod, record=False)
+        x = wmod.catch_warnings(record=False)
         self.assertRaises(RuntimeError, x.__exit__)
         with x:
             self.assertRaises(RuntimeError, x.__enter__)
 
     def test_catch_warnings_defaults(self):
         wmod = self.module
-        orig_filters = wmod.filters
+        orig_filters = wmod._get_filters()
         orig_showwarning = wmod.showwarning
         # Ensure default behaviour is not to record warnings
-        with wmod.catch_warnings(module=wmod) as w:
+        with wmod.catch_warnings() as w:
             self.assertIsNone(w)
             self.assertIs(wmod.showwarning, orig_showwarning)
-            self.assertIsNot(wmod.filters, orig_filters)
-        self.assertIs(wmod.filters, orig_filters)
+            self.assertIsNot(wmod._get_filters(), orig_filters)
+        self.assertIs(wmod._get_filters(), orig_filters)
         if wmod is sys.modules['warnings']:
             # Ensure the default module is this one
             with wmod.catch_warnings() as w:
                 self.assertIsNone(w)
                 self.assertIs(wmod.showwarning, orig_showwarning)
-                self.assertIsNot(wmod.filters, orig_filters)
-            self.assertIs(wmod.filters, orig_filters)
+                self.assertIsNot(wmod._get_filters(), orig_filters)
+            self.assertIs(wmod._get_filters(), orig_filters)
 
     def test_record_override_showwarning_before(self):
         # Issue #28835: If warnings.showwarning() was overridden, make sure
         # that catch_warnings(record=True) overrides it again.
+        if self.module._use_context:
+            # If _use_context is true, the warnings module does not restore
+            # showwarning()
+            return
         text = "This is a warning"
         wmod = self.module
         my_log = []
@@ -1313,7 +1385,7 @@ def my_logger(message, category, filename, lineno, file=None, line=None):
 
         # Override warnings.showwarning() before calling catch_warnings()
         with support.swap_attr(wmod, 'showwarning', my_logger):
-            with wmod.catch_warnings(module=wmod, record=True) as log:
+            with wmod.catch_warnings(record=True) as log:
                 self.assertIsNot(wmod.showwarning, my_logger)
 
                 wmod.simplefilter("always")
@@ -1328,6 +1400,10 @@ def my_logger(message, category, filename, lineno, file=None, line=None):
     def test_record_override_showwarning_inside(self):
         # Issue #28835: It is possible to override warnings.showwarning()
         # in the catch_warnings(record=True) context manager.
+        if self.module._use_context:
+            # If _use_context is true, the warnings module does not restore
+            # showwarning()
+            return
         text = "This is a warning"
         wmod = self.module
         my_log = []
@@ -1336,7 +1412,7 @@ def my_logger(message, category, filename, lineno, file=None, line=None):
             nonlocal my_log
             my_log.append(message)
 
-        with wmod.catch_warnings(module=wmod, record=True) as log:
+        with wmod.catch_warnings(record=True) as log:
             wmod.simplefilter("always")
             wmod.showwarning = my_logger
             wmod.warn(text)
@@ -1385,8 +1461,7 @@ class PyCatchWarningTests(CatchWarningTests, unittest.TestCase):
 
 class EnvironmentVariableTests(BaseTest):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_single_warning(self):
         rc, stdout, stderr = assert_python_ok("-c",
             "import sys; sys.stdout.write(str(sys.warnoptions))",
@@ -1394,8 +1469,7 @@ def test_single_warning(self):
             PYTHONDEVMODE="")
         self.assertEqual(stdout, b"['ignore::DeprecationWarning']")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_comma_separated_warnings(self):
         rc, stdout, stderr = assert_python_ok("-c",
             "import sys; sys.stdout.write(str(sys.warnoptions))",
@@ -1404,8 +1478,7 @@ def test_comma_separated_warnings(self):
         self.assertEqual(stdout,
             b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @force_not_colorized
     def test_envvar_and_command_line(self):
         rc, stdout, stderr = assert_python_ok("-Wignore::UnicodeWarning", "-c",
@@ -1415,8 +1488,7 @@ def test_envvar_and_command_line(self):
         self.assertEqual(stdout,
             b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @force_not_colorized
     def test_conflicting_envvar_and_command_line(self):
         rc, stdout, stderr = assert_python_failure("-Werror::DeprecationWarning", "-c",
@@ -1458,7 +1530,7 @@ def test_default_filter_configuration(self):
             code = "import sys; sys.modules.pop('warnings', None); sys.modules['_warnings'] = None; "
         else:
             code = ""
-        code += "import warnings; [print(f) for f in warnings.filters]"
+        code += "import warnings; [print(f) for f in warnings._get_filters()]"
 
         rc, stdout, stderr = assert_python_ok("-c", code, __isolated=True)
         stdout_lines = [line.strip() for line in stdout.splitlines()]
@@ -1466,8 +1538,7 @@ def test_default_filter_configuration(self):
         self.assertEqual(stdout_lines, expected_output)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii',
                          'requires non-ascii filesystemencoding')
     def test_nonascii(self):
@@ -1481,18 +1552,24 @@ def test_nonascii(self):
 
 class CEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
     module = c_warnings
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_default_filter_configuration(self):
-        # XXX: RUSTPYHTON; remove the entire function when fixed
-        super().test_default_filter_configuration()
-
+    @unittest.expectedFailure # TODO: RUSTPYTHON Lists differ
+    def test_default_filter_configuration(self): super().test_default_filter_configuration()  # TODO: RUSTPYTHON
 
 class PyEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
     module = py_warnings
 
 
+class LocksTest(unittest.TestCase):
+    @support.cpython_only
+    @unittest.skipUnless(c_warnings, 'C module is required')
+    def test_release_lock_no_lock(self):
+        with self.assertRaisesRegex(
+            RuntimeError,
+            'cannot release un-acquired lock',
+        ):
+            c_warnings._release_lock()
+
+
 class _DeprecatedTest(BaseTest, unittest.TestCase):
 
     """Test _deprecated()."""
@@ -1547,8 +1624,7 @@ def test_issue_8766(self):
 
 
 class FinalizationTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_finalization(self):
         # Issue #19421: warnings.warn() should not crash
         # during Python finalization
@@ -1566,8 +1642,7 @@ def __del__(self):
         self.assertEqual(err.decode().rstrip(),
                          '<string>:7: UserWarning: test')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_late_resource_warning(self):
         # Issue #21925: Emitting a ResourceWarning late during the Python
         # shutdown must be logged.
@@ -1578,15 +1653,178 @@ def test_late_resource_warning(self):
         # (_warnings will try to import it)
         code = "f = open(%a)" % __file__
         rc, out, err = assert_python_ok("-Wd", "-c", code)
-        self.assertTrue(err.startswith(expected), ascii(err))
+        self.assertStartsWith(err, expected)
 
         # import the warnings module
         code = "import warnings; f = open(%a)" % __file__
         rc, out, err = assert_python_ok("-Wd", "-c", code)
-        self.assertTrue(err.startswith(expected), ascii(err))
+        self.assertStartsWith(err, expected)
+
+
+class AsyncTests(BaseTest):
+    """Verifies that the catch_warnings() context manager behaves
+    as expected when used inside async co-routines.  This requires
+    that the context_aware_warnings flag is enabled, so that
+    the context manager uses a context variable.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.module.resetwarnings()
+
+    @unittest.skipIf(not sys.flags.context_aware_warnings,
+                     "requires context aware warnings")
+    def test_async_context(self):
+        import asyncio
+
+        # Events to force the execution interleaving we want.
+        step_a1 = asyncio.Event()
+        step_a2 = asyncio.Event()
+        step_b1 = asyncio.Event()
+        step_b2 = asyncio.Event()
+
+        async def run_a():
+            with self.module.catch_warnings(record=True) as w:
+                await step_a1.wait()
+                # The warning emitted here should be caught be the enclosing
+                # context manager.
+                self.module.warn('run_a warning', UserWarning)
+                step_b1.set()
+                await step_a2.wait()
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].message.args[0], 'run_a warning')
+                step_b2.set()
+
+        async def run_b():
+            with self.module.catch_warnings(record=True) as w:
+                step_a1.set()
+                await step_b1.wait()
+                # The warning emitted here should be caught be the enclosing
+                # context manager.
+                self.module.warn('run_b warning', UserWarning)
+                step_a2.set()
+                await step_b2.wait()
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].message.args[0], 'run_b warning')
+
+        async def run_tasks():
+            await asyncio.gather(run_a(), run_b())
 
+        asyncio.run(run_tasks())
 
-class DeprecatedTests(unittest.TestCase):
+    @unittest.skipIf(not sys.flags.context_aware_warnings,
+                     "requires context aware warnings")
+    def test_async_task_inherit(self):
+        """Check that a new asyncio task inherits warnings context from the
+        coroutine that spawns it.
+        """
+        import asyncio
+
+        step1 = asyncio.Event()
+        step2 = asyncio.Event()
+
+        async def run_child1():
+            await step1.wait()
+            # This should be recorded by the run_parent() catch_warnings
+            # context.
+            self.module.warn('child warning', UserWarning)
+            step2.set()
+
+        async def run_child2():
+            # This establishes a new catch_warnings() context.  The
+            # run_child1() task should still be using the context from
+            # run_parent() if context-aware warnings are enabled.
+            with self.module.catch_warnings(record=True) as w:
+                step1.set()
+                await step2.wait()
+
+        async def run_parent():
+            with self.module.catch_warnings(record=True) as w:
+                await asyncio.gather(run_child1(), run_child2())
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].message.args[0], 'child warning')
+
+        asyncio.run(run_parent())
+
+
+class CAsyncTests(AsyncTests, unittest.TestCase):
+    module = c_warnings
+
+
+class PyAsyncTests(AsyncTests, unittest.TestCase):
+    module = py_warnings
+
+
+class ThreadTests(BaseTest):
+    """Verifies that the catch_warnings() context manager behaves as
+    expected when used within threads.  This requires that both the
+    context_aware_warnings flag and thread_inherit_context flags are enabled.
+    """
+
+    ENABLE_THREAD_TESTS = (sys.flags.context_aware_warnings and
+                           sys.flags.thread_inherit_context)
+
+    def setUp(self):
+        super().setUp()
+        self.module.resetwarnings()
+
+    @unittest.skipIf(not ENABLE_THREAD_TESTS,
+                     "requires thread-safe warnings flags")
+    def test_threaded_context(self):
+        import threading
+
+        barrier = threading.Barrier(2, timeout=2)
+
+        def run_a():
+            with self.module.catch_warnings(record=True) as w:
+                barrier.wait()
+                # The warning emitted here should be caught be the enclosing
+                # context manager.
+                self.module.warn('run_a warning', UserWarning)
+                barrier.wait()
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].message.args[0], 'run_a warning')
+            # Should be caught be the catch_warnings() context manager of run_threads()
+            self.module.warn('main warning', UserWarning)
+
+        def run_b():
+            with self.module.catch_warnings(record=True) as w:
+                barrier.wait()
+                # The warning emitted here should be caught be the enclosing
+                # context manager.
+                barrier.wait()
+                self.module.warn('run_b warning', UserWarning)
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].message.args[0], 'run_b warning')
+            # Should be caught be the catch_warnings() context manager of run_threads()
+            self.module.warn('main warning', UserWarning)
+
+        def run_threads():
+            threads = [
+                threading.Thread(target=run_a),
+                threading.Thread(target=run_b),
+                ]
+            with self.module.catch_warnings(record=True) as w:
+                for thread in threads:
+                    thread.start()
+                for thread in threads:
+                    thread.join()
+                self.assertEqual(len(w), 2)
+                self.assertEqual(w[0].message.args[0], 'main warning')
+                self.assertEqual(w[1].message.args[0], 'main warning')
+
+        run_threads()
+
+
+class CThreadTests(ThreadTests, unittest.TestCase):
+    module = c_warnings
+
+
+class PyThreadTests(ThreadTests, unittest.TestCase):
+    module = py_warnings
+
+
+class DeprecatedTests(PyPublicAPITests):
     def test_dunder_deprecated(self):
         @deprecated("A will go away soon")
         class A:
@@ -1614,6 +1852,7 @@ def h(x):
         self.assertEqual(len(overloads), 2)
         self.assertEqual(overloads[0].__deprecated__, "no more ints")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_class(self):
         @deprecated("A will go away soon")
         class A:
@@ -1625,6 +1864,7 @@ class A:
             with self.assertRaises(TypeError):
                 A(42)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_class_with_init(self):
         @deprecated("HasInit will go away soon")
         class HasInit:
@@ -1635,6 +1875,7 @@ def __init__(self, x):
             instance = HasInit(42)
         self.assertEqual(instance.x, 42)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_class_with_new(self):
         has_new_called = False
 
@@ -1653,6 +1894,7 @@ def __init__(self, x) -> None:
         self.assertEqual(instance.x, 42)
         self.assertTrue(has_new_called)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_class_with_inherited_new(self):
         new_base_called = False
 
@@ -1674,6 +1916,7 @@ class HasInheritedNew(NewBase):
         self.assertEqual(instance.x, 42)
         self.assertTrue(new_base_called)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_class_with_new_but_no_init(self):
         new_called = False
 
@@ -1691,6 +1934,7 @@ def __new__(cls, x):
         self.assertEqual(instance.x, 42)
         self.assertTrue(new_called)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_mixin_class(self):
         @deprecated("Mixin will go away soon")
         class Mixin:
@@ -1707,6 +1951,7 @@ class Child(Base, Mixin):
         instance = Child(42)
         self.assertEqual(instance.a, 42)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_do_not_shadow_user_arguments(self):
         new_called = False
         new_called_cls = None
@@ -1726,6 +1971,7 @@ class Foo(metaclass=MyMeta, cls='haha'):
         self.assertTrue(new_called)
         self.assertEqual(new_called_cls, 'haha')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_existing_init_subclass(self):
         @deprecated("C will go away soon")
         class C:
@@ -1742,6 +1988,7 @@ class D(C):
         self.assertTrue(D.inited)
         self.assertIsInstance(D(), D)  # no deprecation
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_existing_init_subclass_in_base(self):
         class Base:
             def __init_subclass__(cls, x) -> None:
@@ -1762,6 +2009,27 @@ class D(C, x=3):
 
         self.assertEqual(D.inited, 3)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
+    def test_existing_init_subclass_in_sibling_base(self):
+        @deprecated("A will go away soon")
+        class A:
+            pass
+        class B:
+            def __init_subclass__(cls, x):
+                super().__init_subclass__()
+                cls.inited = x
+
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            class C(A, B, x=42):
+                pass
+        self.assertEqual(C.inited, 42)
+
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            class D(B, A, x=42):
+                pass
+        self.assertEqual(D.inited, 42)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_init_subclass_has_correct_cls(self):
         init_subclass_saw = None
 
@@ -1779,6 +2047,7 @@ class C(Base):
 
         self.assertIs(init_subclass_saw, C)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_init_subclass_with_explicit_classmethod(self):
         init_subclass_saw = None
 
@@ -1797,6 +2066,7 @@ class C(Base):
 
         self.assertIs(init_subclass_saw, C)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_function(self):
         @deprecated("b will go away soon")
         def b():
@@ -1805,6 +2075,7 @@ def b():
         with self.assertWarnsRegex(DeprecationWarning, "b will go away soon"):
             b()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_method(self):
         class Capybara:
             @deprecated("x will go away soon")
@@ -1815,6 +2086,7 @@ def x(self):
         with self.assertWarnsRegex(DeprecationWarning, "x will go away soon"):
             instance.x()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON DeprecationWarning not triggered
     def test_property(self):
         class Capybara:
             @property
@@ -1842,6 +2114,7 @@ def no_more_setting(self, value):
         with self.assertWarnsRegex(DeprecationWarning, "no more setting"):
             instance.no_more_setting = 42
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON RuntimeWarning not triggered
     def test_category(self):
         @deprecated("c will go away soon", category=RuntimeWarning)
         def c():
diff --git a/Lib/test/test_warnings/data/stacklevel.py b/Lib/test/test_warnings/data/stacklevel.py
index c6dd24733b3..fe36242d3d2 100644
--- a/Lib/test/test_warnings/data/stacklevel.py
+++ b/Lib/test/test_warnings/data/stacklevel.py
@@ -4,11 +4,13 @@
 import warnings
 from test.test_warnings.data import package_helper
 
-def outer(message, stacklevel=1):
-    inner(message, stacklevel)
 
-def inner(message, stacklevel=1):
-    warnings.warn(message, stacklevel=stacklevel)
+def outer(message, stacklevel=1, skip_file_prefixes=()):
+    inner(message, stacklevel, skip_file_prefixes)
+
+def inner(message, stacklevel=1, skip_file_prefixes=()):
+    warnings.warn(message, stacklevel=stacklevel,
+                  skip_file_prefixes=skip_file_prefixes)
 
 def package(message, *, stacklevel):
     package_helper.inner_api(message, stacklevel=stacklevel,
diff --git a/Lib/warnings.py b/Lib/warnings.py
index f83aaf231ea..6759857d909 100644
--- a/Lib/warnings.py
+++ b/Lib/warnings.py
@@ -1,735 +1,99 @@
-"""Python part of the warnings subsystem."""
-
 import sys
 
+__all__ = [
+    "warn",
+    "warn_explicit",
+    "showwarning",
+    "formatwarning",
+    "filterwarnings",
+    "simplefilter",
+    "resetwarnings",
+    "catch_warnings",
+    "deprecated",
+]
+
+from _py_warnings import (
+    WarningMessage,
+    _DEPRECATED_MSG,
+    _OptionError,
+    _add_filter,
+    _deprecated,
+    _filters_mutated,
+    _filters_mutated_lock_held,
+    _filters_version,
+    _formatwarning_orig,
+    _formatwarnmsg,
+    _formatwarnmsg_impl,
+    _get_context,
+    _get_filters,
+    _getaction,
+    _getcategory,
+    _is_filename_to_skip,
+    _is_internal_filename,
+    _is_internal_frame,
+    _lock,
+    _new_context,
+    _next_external_frame,
+    _processoptions,
+    _set_context,
+    _set_module,
+    _setoption,
+    _setup_defaults,
+    _showwarning_orig,
+    _showwarnmsg,
+    _showwarnmsg_impl,
+    _use_context,
+    _warn_unawaited_coroutine,
+    _warnings_context,
+    catch_warnings,
+    defaultaction,
+    deprecated,
+    filters,
+    filterwarnings,
+    formatwarning,
+    onceregistry,
+    resetwarnings,
+    showwarning,
+    simplefilter,
+    warn,
+    warn_explicit,
+)
 
-__all__ = ["warn", "warn_explicit", "showwarning",
-           "formatwarning", "filterwarnings", "simplefilter",
-           "resetwarnings", "catch_warnings", "deprecated"]
-
-def showwarning(message, category, filename, lineno, file=None, line=None):
-    """Hook to write a warning to a file; replace if you like."""
-    msg = WarningMessage(message, category, filename, lineno, file, line)
-    _showwarnmsg_impl(msg)
-
-def formatwarning(message, category, filename, lineno, line=None):
-    """Function to format a warning the standard way."""
-    msg = WarningMessage(message, category, filename, lineno, None, line)
-    return _formatwarnmsg_impl(msg)
-
-def _showwarnmsg_impl(msg):
-    file = msg.file
-    if file is None:
-        file = sys.stderr
-        if file is None:
-            # sys.stderr is None when run with pythonw.exe:
-            # warnings get lost
-            return
-    text = _formatwarnmsg(msg)
-    try:
-        file.write(text)
-    except OSError:
-        # the file (probably stderr) is invalid - this warning gets lost.
-        pass
-
-def _formatwarnmsg_impl(msg):
-    category = msg.category.__name__
-    s =  f"{msg.filename}:{msg.lineno}: {category}: {msg.message}\n"
-
-    if msg.line is None:
-        try:
-            import linecache
-            line = linecache.getline(msg.filename, msg.lineno)
-        except Exception:
-            # When a warning is logged during Python shutdown, linecache
-            # and the import machinery don't work anymore
-            line = None
-            linecache = None
-    else:
-        line = msg.line
-    if line:
-        line = line.strip()
-        s += "  %s\n" % line
-
-    if msg.source is not None:
-        try:
-            import tracemalloc
-        # Logging a warning should not raise a new exception:
-        # catch Exception, not only ImportError and RecursionError.
-        except Exception:
-            # don't suggest to enable tracemalloc if it's not available
-            suggest_tracemalloc = False
-            tb = None
-        else:
-            try:
-                suggest_tracemalloc = not tracemalloc.is_tracing()
-                tb = tracemalloc.get_object_traceback(msg.source)
-            except Exception:
-                # When a warning is logged during Python shutdown, tracemalloc
-                # and the import machinery don't work anymore
-                suggest_tracemalloc = False
-                tb = None
-
-        if tb is not None:
-            s += 'Object allocated at (most recent call last):\n'
-            for frame in tb:
-                s += ('  File "%s", lineno %s\n'
-                      % (frame.filename, frame.lineno))
-
-                try:
-                    if linecache is not None:
-                        line = linecache.getline(frame.filename, frame.lineno)
-                    else:
-                        line = None
-                except Exception:
-                    line = None
-                if line:
-                    line = line.strip()
-                    s += '    %s\n' % line
-        elif suggest_tracemalloc:
-            s += (f'{category}: Enable tracemalloc to get the object '
-                  f'allocation traceback\n')
-    return s
-
-# Keep a reference to check if the function was replaced
-_showwarning_orig = showwarning
-
-def _showwarnmsg(msg):
-    """Hook to write a warning to a file; replace if you like."""
-    try:
-        sw = showwarning
-    except NameError:
-        pass
-    else:
-        if sw is not _showwarning_orig:
-            # warnings.showwarning() was replaced
-            if not callable(sw):
-                raise TypeError("warnings.showwarning() must be set to a "
-                                "function or method")
-
-            sw(msg.message, msg.category, msg.filename, msg.lineno,
-               msg.file, msg.line)
-            return
-    _showwarnmsg_impl(msg)
-
-# Keep a reference to check if the function was replaced
-_formatwarning_orig = formatwarning
-
-def _formatwarnmsg(msg):
-    """Function to format a warning the standard way."""
-    try:
-        fw = formatwarning
-    except NameError:
-        pass
-    else:
-        if fw is not _formatwarning_orig:
-            # warnings.formatwarning() was replaced
-            return fw(msg.message, msg.category,
-                      msg.filename, msg.lineno, msg.line)
-    return _formatwarnmsg_impl(msg)
-
-def filterwarnings(action, message="", category=Warning, module="", lineno=0,
-                   append=False):
-    """Insert an entry into the list of warnings filters (at the front).
-
-    'action' -- one of "error", "ignore", "always", "default", "module",
-                or "once"
-    'message' -- a regex that the warning message must match
-    'category' -- a class that the warning must be a subclass of
-    'module' -- a regex that the module name must match
-    'lineno' -- an integer line number, 0 matches all warnings
-    'append' -- if true, append to the list of filters
-    """
-    if action not in {"error", "ignore", "always", "default", "module", "once"}:
-        raise ValueError(f"invalid action: {action!r}")
-    if not isinstance(message, str):
-        raise TypeError("message must be a string")
-    if not isinstance(category, type) or not issubclass(category, Warning):
-        raise TypeError("category must be a Warning subclass")
-    if not isinstance(module, str):
-        raise TypeError("module must be a string")
-    if not isinstance(lineno, int):
-        raise TypeError("lineno must be an int")
-    if lineno < 0:
-        raise ValueError("lineno must be an int >= 0")
-
-    if message or module:
-        import re
-
-    if message:
-        message = re.compile(message, re.I)
-    else:
-        message = None
-    if module:
-        module = re.compile(module)
-    else:
-        module = None
-
-    _add_filter(action, message, category, module, lineno, append=append)
-
-def simplefilter(action, category=Warning, lineno=0, append=False):
-    """Insert a simple entry into the list of warnings filters (at the front).
-
-    A simple filter matches all modules and messages.
-    'action' -- one of "error", "ignore", "always", "default", "module",
-                or "once"
-    'category' -- a class that the warning must be a subclass of
-    'lineno' -- an integer line number, 0 matches all warnings
-    'append' -- if true, append to the list of filters
-    """
-    if action not in {"error", "ignore", "always", "default", "module", "once"}:
-        raise ValueError(f"invalid action: {action!r}")
-    if not isinstance(lineno, int):
-        raise TypeError("lineno must be an int")
-    if lineno < 0:
-        raise ValueError("lineno must be an int >= 0")
-    _add_filter(action, None, category, None, lineno, append=append)
-
-def _add_filter(*item, append):
-    # Remove possible duplicate filters, so new one will be placed
-    # in correct place. If append=True and duplicate exists, do nothing.
-    if not append:
-        try:
-            filters.remove(item)
-        except ValueError:
-            pass
-        filters.insert(0, item)
-    else:
-        if item not in filters:
-            filters.append(item)
-    _filters_mutated()
-
-def resetwarnings():
-    """Clear the list of warning filters, so that no filters are active."""
-    filters[:] = []
-    _filters_mutated()
-
-class _OptionError(Exception):
-    """Exception used by option processing helpers."""
-    pass
-
-# Helper to process -W options passed via sys.warnoptions
-def _processoptions(args):
-    for arg in args:
-        try:
-            _setoption(arg)
-        except _OptionError as msg:
-            print("Invalid -W option ignored:", msg, file=sys.stderr)
-
-# Helper for _processoptions()
-def _setoption(arg):
-    parts = arg.split(':')
-    if len(parts) > 5:
-        raise _OptionError("too many fields (max 5): %r" % (arg,))
-    while len(parts) < 5:
-        parts.append('')
-    action, message, category, module, lineno = [s.strip()
-                                                 for s in parts]
-    action = _getaction(action)
-    category = _getcategory(category)
-    if message or module:
-        import re
-    if message:
-        message = re.escape(message)
-    if module:
-        module = re.escape(module) + r'\Z'
-    if lineno:
-        try:
-            lineno = int(lineno)
-            if lineno < 0:
-                raise ValueError
-        except (ValueError, OverflowError):
-            raise _OptionError("invalid lineno %r" % (lineno,)) from None
-    else:
-        lineno = 0
-    filterwarnings(action, message, category, module, lineno)
-
-# Helper for _setoption()
-def _getaction(action):
-    if not action:
-        return "default"
-    if action == "all": return "always" # Alias
-    for a in ('default', 'always', 'ignore', 'module', 'once', 'error'):
-        if a.startswith(action):
-            return a
-    raise _OptionError("invalid action: %r" % (action,))
-
-# Helper for _setoption()
-def _getcategory(category):
-    if not category:
-        return Warning
-    if '.' not in category:
-        import builtins as m
-        klass = category
-    else:
-        module, _, klass = category.rpartition('.')
-        try:
-            m = __import__(module, None, None, [klass])
-        except ImportError:
-            raise _OptionError("invalid module name: %r" % (module,)) from None
-    try:
-        cat = getattr(m, klass)
-    except AttributeError:
-        raise _OptionError("unknown warning category: %r" % (category,)) from None
-    if not issubclass(cat, Warning):
-        raise _OptionError("invalid warning category: %r" % (category,))
-    return cat
-
-
-def _is_internal_filename(filename):
-    return 'importlib' in filename and '_bootstrap' in filename
-
-
-def _is_filename_to_skip(filename, skip_file_prefixes):
-    return any(filename.startswith(prefix) for prefix in skip_file_prefixes)
-
-
-def _is_internal_frame(frame):
-    """Signal whether the frame is an internal CPython implementation detail."""
-    return _is_internal_filename(frame.f_code.co_filename)
-
-
-def _next_external_frame(frame, skip_file_prefixes):
-    """Find the next frame that doesn't involve Python or user internals."""
-    frame = frame.f_back
-    while frame is not None and (
-            _is_internal_filename(filename := frame.f_code.co_filename) or
-            _is_filename_to_skip(filename, skip_file_prefixes)):
-        frame = frame.f_back
-    return frame
-
-
-# Code typically replaced by _warnings
-def warn(message, category=None, stacklevel=1, source=None,
-         *, skip_file_prefixes=()):
-    """Issue a warning, or maybe ignore it or raise an exception."""
-    # Check if message is already a Warning object
-    if isinstance(message, Warning):
-        category = message.__class__
-    # Check category argument
-    if category is None:
-        category = UserWarning
-    if not (isinstance(category, type) and issubclass(category, Warning)):
-        raise TypeError("category must be a Warning subclass, "
-                        "not '{:s}'".format(type(category).__name__))
-    if not isinstance(skip_file_prefixes, tuple):
-        # The C version demands a tuple for implementation performance.
-        raise TypeError('skip_file_prefixes must be a tuple of strs.')
-    if skip_file_prefixes:
-        stacklevel = max(2, stacklevel)
-    # Get context information
-    try:
-        if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)):
-            # If frame is too small to care or if the warning originated in
-            # internal code, then do not try to hide any frames.
-            frame = sys._getframe(stacklevel)
-        else:
-            frame = sys._getframe(1)
-            # Look for one frame less since the above line starts us off.
-            for x in range(stacklevel-1):
-                frame = _next_external_frame(frame, skip_file_prefixes)
-                if frame is None:
-                    raise ValueError
-    except ValueError:
-        globals = sys.__dict__
-        filename = "<sys>"
-        lineno = 0
-    else:
-        globals = frame.f_globals
-        filename = frame.f_code.co_filename
-        lineno = frame.f_lineno
-    if '__name__' in globals:
-        module = globals['__name__']
-    else:
-        module = "<string>"
-    registry = globals.setdefault("__warningregistry__", {})
-    warn_explicit(message, category, filename, lineno, module, registry,
-                  globals, source)
-
-def warn_explicit(message, category, filename, lineno,
-                  module=None, registry=None, module_globals=None,
-                  source=None):
-    lineno = int(lineno)
-    if module is None:
-        module = filename or "<unknown>"
-        if module[-3:].lower() == ".py":
-            module = module[:-3] # XXX What about leading pathname?
-    if registry is None:
-        registry = {}
-    if registry.get('version', 0) != _filters_version:
-        registry.clear()
-        registry['version'] = _filters_version
-    if isinstance(message, Warning):
-        text = str(message)
-        category = message.__class__
-    else:
-        text = message
-        message = category(message)
-    key = (text, category, lineno)
-    # Quick test for common case
-    if registry.get(key):
-        return
-    # Search the filters
-    for item in filters:
-        action, msg, cat, mod, ln = item
-        if ((msg is None or msg.match(text)) and
-            issubclass(category, cat) and
-            (mod is None or mod.match(module)) and
-            (ln == 0 or lineno == ln)):
-            break
-    else:
-        action = defaultaction
-    # Early exit actions
-    if action == "ignore":
-        return
-
-    # Prime the linecache for formatting, in case the
-    # "file" is actually in a zipfile or something.
-    import linecache
-    linecache.getlines(filename, module_globals)
-
-    if action == "error":
-        raise message
-    # Other actions
-    if action == "once":
-        registry[key] = 1
-        oncekey = (text, category)
-        if onceregistry.get(oncekey):
-            return
-        onceregistry[oncekey] = 1
-    elif action == "always":
-        pass
-    elif action == "module":
-        registry[key] = 1
-        altkey = (text, category, 0)
-        if registry.get(altkey):
-            return
-        registry[altkey] = 1
-    elif action == "default":
-        registry[key] = 1
-    else:
-        # Unrecognized actions are errors
-        raise RuntimeError(
-              "Unrecognized action (%r) in warnings.filters:\n %s" %
-              (action, item))
-    # Print message and context
-    msg = WarningMessage(message, category, filename, lineno, source=source)
-    _showwarnmsg(msg)
-
-
-class WarningMessage(object):
-
-    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
-                        "line", "source")
-
-    def __init__(self, message, category, filename, lineno, file=None,
-                 line=None, source=None):
-        self.message = message
-        self.category = category
-        self.filename = filename
-        self.lineno = lineno
-        self.file = file
-        self.line = line
-        self.source = source
-        self._category_name = category.__name__ if category else None
-
-    def __str__(self):
-        return ("{message : %r, category : %r, filename : %r, lineno : %s, "
-                    "line : %r}" % (self.message, self._category_name,
-                                    self.filename, self.lineno, self.line))
-
-
-class catch_warnings(object):
-
-    """A context manager that copies and restores the warnings filter upon
-    exiting the context.
-
-    The 'record' argument specifies whether warnings should be captured by a
-    custom implementation of warnings.showwarning() and be appended to a list
-    returned by the context manager. Otherwise None is returned by the context
-    manager. The objects appended to the list are arguments whose attributes
-    mirror the arguments to showwarning().
-
-    The 'module' argument is to specify an alternative module to the module
-    named 'warnings' and imported under that name. This argument is only useful
-    when testing the warnings module itself.
-
-    If the 'action' argument is not None, the remaining arguments are passed
-    to warnings.simplefilter() as if it were called immediately on entering the
-    context.
-    """
-
-    def __init__(self, *, record=False, module=None,
-                 action=None, category=Warning, lineno=0, append=False):
-        """Specify whether to record warnings and if an alternative module
-        should be used other than sys.modules['warnings'].
-
-        For compatibility with Python 3.0, please consider all arguments to be
-        keyword-only.
-
-        """
-        self._record = record
-        self._module = sys.modules['warnings'] if module is None else module
-        self._entered = False
-        if action is None:
-            self._filter = None
-        else:
-            self._filter = (action, category, lineno, append)
-
-    def __repr__(self):
-        args = []
-        if self._record:
-            args.append("record=True")
-        if self._module is not sys.modules['warnings']:
-            args.append("module=%r" % self._module)
-        name = type(self).__name__
-        return "%s(%s)" % (name, ", ".join(args))
-
-    def __enter__(self):
-        if self._entered:
-            raise RuntimeError("Cannot enter %r twice" % self)
-        self._entered = True
-        self._filters = self._module.filters
-        self._module.filters = self._filters[:]
-        self._module._filters_mutated()
-        self._showwarning = self._module.showwarning
-        self._showwarnmsg_impl = self._module._showwarnmsg_impl
-        if self._filter is not None:
-            simplefilter(*self._filter)
-        if self._record:
-            log = []
-            self._module._showwarnmsg_impl = log.append
-            # Reset showwarning() to the default implementation to make sure
-            # that _showwarnmsg() calls _showwarnmsg_impl()
-            self._module.showwarning = self._module._showwarning_orig
-            return log
-        else:
-            return None
-
-    def __exit__(self, *exc_info):
-        if not self._entered:
-            raise RuntimeError("Cannot exit %r without entering first" % self)
-        self._module.filters = self._filters
-        self._module._filters_mutated()
-        self._module.showwarning = self._showwarning
-        self._module._showwarnmsg_impl = self._showwarnmsg_impl
-
-
-class deprecated:
-    """Indicate that a class, function or overload is deprecated.
-
-    When this decorator is applied to an object, the type checker
-    will generate a diagnostic on usage of the deprecated object.
-
-    Usage:
-
-        @deprecated("Use B instead")
-        class A:
-            pass
-
-        @deprecated("Use g instead")
-        def f():
-            pass
-
-        @overload
-        @deprecated("int support is deprecated")
-        def g(x: int) -> int: ...
-        @overload
-        def g(x: str) -> int: ...
-
-    The warning specified by *category* will be emitted at runtime
-    on use of deprecated objects. For functions, that happens on calls;
-    for classes, on instantiation and on creation of subclasses.
-    If the *category* is ``None``, no warning is emitted at runtime.
-    The *stacklevel* determines where the
-    warning is emitted. If it is ``1`` (the default), the warning
-    is emitted at the direct caller of the deprecated object; if it
-    is higher, it is emitted further up the stack.
-    Static type checker behavior is not affected by the *category*
-    and *stacklevel* arguments.
-
-    The deprecation message passed to the decorator is saved in the
-    ``__deprecated__`` attribute on the decorated object.
-    If applied to an overload, the decorator
-    must be after the ``@overload`` decorator for the attribute to
-    exist on the overload as returned by ``get_overloads()``.
-
-    See PEP 702 for details.
-
-    """
-    def __init__(
-        self,
-        message: str,
-        /,
-        *,
-        category: type[Warning] | None = DeprecationWarning,
-        stacklevel: int = 1,
-    ) -> None:
-        if not isinstance(message, str):
-            raise TypeError(
-                f"Expected an object of type str for 'message', not {type(message).__name__!r}"
-            )
-        self.message = message
-        self.category = category
-        self.stacklevel = stacklevel
-
-    def __call__(self, arg, /):
-        # Make sure the inner functions created below don't
-        # retain a reference to self.
-        msg = self.message
-        category = self.category
-        stacklevel = self.stacklevel
-        if category is None:
-            arg.__deprecated__ = msg
-            return arg
-        elif isinstance(arg, type):
-            import functools
-            from types import MethodType
-
-            original_new = arg.__new__
-
-            @functools.wraps(original_new)
-            def __new__(cls, /, *args, **kwargs):
-                if cls is arg:
-                    warn(msg, category=category, stacklevel=stacklevel + 1)
-                if original_new is not object.__new__:
-                    return original_new(cls, *args, **kwargs)
-                # Mirrors a similar check in object.__new__.
-                elif cls.__init__ is object.__init__ and (args or kwargs):
-                    raise TypeError(f"{cls.__name__}() takes no arguments")
-                else:
-                    return original_new(cls)
-
-            arg.__new__ = staticmethod(__new__)
-
-            original_init_subclass = arg.__init_subclass__
-            # We need slightly different behavior if __init_subclass__
-            # is a bound method (likely if it was implemented in Python)
-            if isinstance(original_init_subclass, MethodType):
-                original_init_subclass = original_init_subclass.__func__
-
-                @functools.wraps(original_init_subclass)
-                def __init_subclass__(*args, **kwargs):
-                    warn(msg, category=category, stacklevel=stacklevel + 1)
-                    return original_init_subclass(*args, **kwargs)
-
-                arg.__init_subclass__ = classmethod(__init_subclass__)
-            # Or otherwise, which likely means it's a builtin such as
-            # object's implementation of __init_subclass__.
-            else:
-                @functools.wraps(original_init_subclass)
-                def __init_subclass__(*args, **kwargs):
-                    warn(msg, category=category, stacklevel=stacklevel + 1)
-                    return original_init_subclass(*args, **kwargs)
-
-                arg.__init_subclass__ = __init_subclass__
-
-            arg.__deprecated__ = __new__.__deprecated__ = msg
-            __init_subclass__.__deprecated__ = msg
-            return arg
-        elif callable(arg):
-            import functools
-            import inspect
-
-            @functools.wraps(arg)
-            def wrapper(*args, **kwargs):
-                warn(msg, category=category, stacklevel=stacklevel + 1)
-                return arg(*args, **kwargs)
-
-            if inspect.iscoroutinefunction(arg):
-                wrapper = inspect.markcoroutinefunction(wrapper)
-
-            arg.__deprecated__ = wrapper.__deprecated__ = msg
-            return wrapper
-        else:
-            raise TypeError(
-                "@deprecated decorator with non-None category must be applied to "
-                f"a class or callable, not {arg!r}"
-            )
-
-
-_DEPRECATED_MSG = "{name!r} is deprecated and slated for removal in Python {remove}"
-
-def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_info):
-    """Warn that *name* is deprecated or should be removed.
-
-    RuntimeError is raised if *remove* specifies a major/minor tuple older than
-    the current Python version or the same version but past the alpha.
-
-    The *message* argument is formatted with *name* and *remove* as a Python
-    version tuple (e.g. (3, 11)).
-
-    """
-    remove_formatted = f"{remove[0]}.{remove[1]}"
-    if (_version[:2] > remove) or (_version[:2] == remove and _version[3] != "alpha"):
-        msg = f"{name!r} was slated for removal after Python {remove_formatted} alpha"
-        raise RuntimeError(msg)
-    else:
-        msg = message.format(name=name, remove=remove_formatted)
-        warn(msg, DeprecationWarning, stacklevel=3)
-
-
-# Private utility function called by _PyErr_WarnUnawaitedCoroutine
-def _warn_unawaited_coroutine(coro):
-    msg_lines = [
-        f"coroutine '{coro.__qualname__}' was never awaited\n"
-    ]
-    if coro.cr_origin is not None:
-        import linecache, traceback
-        def extract():
-            for filename, lineno, funcname in reversed(coro.cr_origin):
-                line = linecache.getline(filename, lineno)
-                yield (filename, lineno, funcname, line)
-        msg_lines.append("Coroutine created at (most recent call last)\n")
-        msg_lines += traceback.format_list(list(extract()))
-    msg = "".join(msg_lines).rstrip("\n")
-    # Passing source= here means that if the user happens to have tracemalloc
-    # enabled and tracking where the coroutine was created, the warning will
-    # contain that traceback. This does mean that if they have *both*
-    # coroutine origin tracking *and* tracemalloc enabled, they'll get two
-    # partially-redundant tracebacks. If we wanted to be clever we could
-    # probably detect this case and avoid it, but for now we don't bother.
-    warn(msg, category=RuntimeWarning, stacklevel=2, source=coro)
-
-
-# filters contains a sequence of filter 5-tuples
-# The components of the 5-tuple are:
-# - an action: error, ignore, always, default, module, or once
-# - a compiled regex that must match the warning message
-# - a class representing the warning category
-# - a compiled regex that must match the module that is being warned
-# - a line number for the line being warning, or 0 to mean any line
-# If either if the compiled regexs are None, match anything.
 try:
-    from _warnings import (filters, _defaultaction, _onceregistry,
-                           warn, warn_explicit, _filters_mutated)
-    defaultaction = _defaultaction
-    onceregistry = _onceregistry
+    # Try to use the C extension, this will replace some parts of the
+    # _py_warnings implementation imported above.
+    from _warnings import (
+        _acquire_lock,
+        _defaultaction as defaultaction,
+        _filters_mutated_lock_held,
+        _onceregistry as onceregistry,
+        _release_lock,
+        _warnings_context,
+        filters,
+        warn,
+        warn_explicit,
+    )
+
     _warnings_defaults = True
-except ImportError:
-    filters = []
-    defaultaction = "default"
-    onceregistry = {}
 
-    _filters_version = 1
+    class _Lock:
+        def __enter__(self):
+            _acquire_lock()
+            return self
 
-    def _filters_mutated():
-        global _filters_version
-        _filters_version += 1
+        def __exit__(self, *args):
+            _release_lock()
 
+    _lock = _Lock()
+except ImportError:
     _warnings_defaults = False
 
 
 # Module initialization
+_set_module(sys.modules[__name__])
 _processoptions(sys.warnoptions)
 if not _warnings_defaults:
-    # Several warning categories are ignored by default in regular builds
-    if not hasattr(sys, 'gettotalrefcount'):
-        filterwarnings("default", category=DeprecationWarning,
-                       module="__main__", append=1)
-        simplefilter("ignore", category=DeprecationWarning, append=1)
-        simplefilter("ignore", category=PendingDeprecationWarning, append=1)
-        simplefilter("ignore", category=ImportWarning, append=1)
-        simplefilter("ignore", category=ResourceWarning, append=1)
+    _setup_defaults()
 
 del _warnings_defaults
+del _setup_defaults
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 66a43427f83..4917e3e43c6 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1303,6 +1303,8 @@ mod sys {
         warn_default_encoding: u8,
         /// -X thread_inherit_context, whether new threads inherit context from parent
         thread_inherit_context: bool,
+        /// -X context_aware_warnings, whether warnings are context aware
+        context_aware_warnings: bool,
     }
 
     impl FlagsData {
@@ -1327,6 +1329,7 @@ mod sys {
                 safe_path: settings.safe_path,
                 warn_default_encoding: settings.warn_default_encoding as u8,
                 thread_inherit_context: settings.thread_inherit_context,
+                context_aware_warnings: settings.context_aware_warnings,
             }
         }
     }
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index a7779156f8c..06cc35e933f 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -91,6 +91,9 @@ pub struct Settings {
     /// -X thread_inherit_context, whether new threads inherit context from parent
     pub thread_inherit_context: bool,
 
+    /// -X context_aware_warnings, whether warnings are context aware
+    pub context_aware_warnings: bool,
+
     /// -i
     pub inspect: bool,
 
@@ -194,6 +197,7 @@ impl Default for Settings {
             dev_mode: false,
             warn_default_encoding: false,
             thread_inherit_context: false,
+            context_aware_warnings: false,
             warnoptions: vec![],
             path_list: vec![],
             argv: vec![],

From 7c7b824aa983789d7adb6e4c39a34a7d64d37a01 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 14:18:30 +0900
Subject: [PATCH 352/418] fix asyncgen  finalizer (#6761)

---
 crates/vm/src/builtins/asyncgenerator.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/vm/src/builtins/asyncgenerator.rs b/crates/vm/src/builtins/asyncgenerator.rs
index 8f7518f0eae..8b7c107d4b8 100644
--- a/crates/vm/src/builtins/asyncgenerator.rs
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -87,9 +87,14 @@ impl PyAsyncGen {
         if let Some(finalizer) = finalizer
             && !zelf.inner.closed.load()
         {
-            // Ignore any errors (PyErr_WriteUnraisable)
+            // Create a strong reference for the finalizer call.
+            // This keeps the object alive during the finalizer execution.
             let obj: PyObjectRef = zelf.to_owned().into();
-            let _ = finalizer.call((obj,), vm);
+
+            // Call the finalizer. Any exceptions are handled as unraisable.
+            if let Err(e) = finalizer.call((obj,), vm) {
+                vm.run_unraisable(e, Some("async generator finalizer".to_owned()), finalizer);
+            }
         }
     }
 
@@ -496,11 +501,13 @@ impl PyAsyncGenAThrow {
     }
     fn yield_close(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
         self.ag.running_async.store(false);
+        self.ag.inner.closed.store(true);
         self.state.store(AwaitableState::Closed);
         vm.new_runtime_error("async generator ignored GeneratorExit")
     }
     fn check_error(&self, exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyBaseExceptionRef {
         self.ag.running_async.store(false);
+        self.ag.inner.closed.store(true);
         self.state.store(AwaitableState::Closed);
         if self.aclose
             && (exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
@@ -687,12 +694,14 @@ impl IterNext for PyAnextAwaitable {
 /// _PyGen_Finalize for async generators
 impl Destructor for PyAsyncGen {
     fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
-        // Generator isn't paused, so no need to close
+        // Generator is already closed, nothing to do
         if zelf.inner.closed.load() {
             return Ok(());
         }
 
+        // Call the async generator finalizer hook if set.
         Self::call_finalizer(zelf, vm);
+
         Ok(())
     }
 }

From eb50246b41140b774401348eba81af0e7e5d8e96 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 15:24:17 +0900
Subject: [PATCH 353/418] fix annotation (#6767)

---
 crates/codegen/src/compile.rs | 77 ++++++++++++++++++++++++++++-------
 crates/jit/tests/common.rs    | 57 ++++++++++----------------
 2 files changed, 84 insertions(+), 50 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index c531c5ff258..c58f3746ec0 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -29,8 +29,9 @@ use ruff_python_ast::{
     InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
     Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
     PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
-    Stmt, StmtAnnAssign, StmtExpr, TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
-    TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
+    Stmt, StmtAnnAssign, StmtExpr, StmtFor, StmtIf, StmtMatch, StmtTry, StmtWhile, StmtWith,
+    TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams,
+    UnaryOp, WithItem,
     visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange};
@@ -3630,23 +3631,69 @@ impl Compiler {
         Ok(true)
     }
 
-    /// Collect simple (non-conditional) annotations from module body
+    /// Collect simple annotations from module body in AST order (including nested blocks)
     /// Returns list of (name, annotation_expr) pairs
+    /// This must match the order that annotations are compiled to ensure
+    /// conditional_annotation_index stays in sync with __annotate__ enumeration.
     fn collect_simple_annotations(body: &[Stmt]) -> Vec<(&str, &Expr)> {
-        let mut annotations = Vec::new();
-        for stmt in body {
-            if let Stmt::AnnAssign(StmtAnnAssign {
-                target,
-                annotation,
-                simple,
-                ..
-            }) = stmt
-                && *simple
-                && let Expr::Name(ExprName { id, .. }) = target.as_ref()
-            {
-                annotations.push((id.as_str(), annotation.as_ref()));
+        fn walk<'a>(stmts: &'a [Stmt], out: &mut Vec<(&'a str, &'a Expr)>) {
+            for stmt in stmts {
+                match stmt {
+                    Stmt::AnnAssign(StmtAnnAssign {
+                        target,
+                        annotation,
+                        simple,
+                        ..
+                    }) if *simple && matches!(target.as_ref(), Expr::Name(_)) => {
+                        if let Expr::Name(ExprName { id, .. }) = target.as_ref() {
+                            out.push((id.as_str(), annotation.as_ref()));
+                        }
+                    }
+                    Stmt::If(StmtIf {
+                        body,
+                        elif_else_clauses,
+                        ..
+                    }) => {
+                        walk(body, out);
+                        for clause in elif_else_clauses {
+                            walk(&clause.body, out);
+                        }
+                    }
+                    Stmt::For(StmtFor { body, orelse, .. })
+                    | Stmt::While(StmtWhile { body, orelse, .. }) => {
+                        walk(body, out);
+                        walk(orelse, out);
+                    }
+                    Stmt::With(StmtWith { body, .. }) => walk(body, out),
+                    Stmt::Try(StmtTry {
+                        body,
+                        handlers,
+                        orelse,
+                        finalbody,
+                        ..
+                    }) => {
+                        walk(body, out);
+                        for handler in handlers {
+                            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
+                                body,
+                                ..
+                            }) = handler;
+                            walk(body, out);
+                        }
+                        walk(orelse, out);
+                        walk(finalbody, out);
+                    }
+                    Stmt::Match(StmtMatch { cases, .. }) => {
+                        for case in cases {
+                            walk(&case.body, out);
+                        }
+                    }
+                    _ => {}
+                }
             }
         }
+        let mut annotations = Vec::new();
+        walk(body, &mut annotations);
         annotations
     }
 
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index ef5a25f0843..49cc7168dd4 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -102,46 +102,33 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
                             // Value can be a name (type ref) or a const string (forward ref)
                             let type_name = if val_is_const {
                                 match code.constants.get(val_idx) {
-                                    Some(ConstantData::Str { value }) => {
-                                        Some(value.as_str().map(|s| s.to_owned()).unwrap_or_else(
-                                            |_| value.to_string_lossy().into_owned(),
-                                        ))
-                                    }
-                                    Some(other) => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{:?}': expected string constant at index {}, got {:?}",
-                                            param_name, val_idx, other
-                                        );
-                                        None
-                                    }
-                                    None => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{:?}': constant index {} out of bounds (len={})",
-                                            param_name,
-                                            val_idx,
-                                            code.constants.len()
-                                        );
-                                        None
-                                    }
+                                    Some(ConstantData::Str { value }) => value
+                                        .as_str()
+                                        .map(|s| s.to_owned())
+                                        .unwrap_or_else(|_| value.to_string_lossy().into_owned()),
+                                    Some(other) => panic!(
+                                        "Unsupported annotation const for '{:?}' at idx {}: {:?}",
+                                        param_name, val_idx, other
+                                    ),
+                                    None => panic!(
+                                        "Annotation const idx out of bounds for '{:?}': {} (len={})",
+                                        param_name,
+                                        val_idx,
+                                        code.constants.len()
+                                    ),
                                 }
                             } else {
                                 match code.names.get(val_idx) {
-                                    Some(name) => Some(name.clone()),
-                                    None => {
-                                        eprintln!(
-                                            "Warning: Malformed annotation for '{}': name index {} out of bounds (len={})",
-                                            param_name,
-                                            val_idx,
-                                            code.names.len()
-                                        );
-                                        None
-                                    }
+                                    Some(name) => name.clone(),
+                                    None => panic!(
+                                        "Annotation name idx out of bounds for '{:?}': {} (len={})",
+                                        param_name,
+                                        val_idx,
+                                        code.names.len()
+                                    ),
                                 }
                             };
-                            if let Some(type_name) = type_name {
-                                annotations
-                                    .insert(param_name.clone(), StackValue::String(type_name));
-                            }
+                            annotations.insert(param_name.clone(), StackValue::String(type_name));
                         }
                     }
                 }

From 1ccd99ea209c273b3a179707477d9d08cd5c3fd9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 17:30:36 +0900
Subject: [PATCH 354/418] use ast namespace (#6769)

---
 crates/codegen/src/compile.rs                | 845 ++++++++++---------
 crates/codegen/src/lib.rs                    |   4 +-
 crates/codegen/src/string_parser.rs          |  13 +-
 crates/codegen/src/symboltable.rs            |  85 +-
 crates/codegen/src/unparse.rs                | 138 ++-
 crates/vm/src/stdlib/ast.rs                  |  12 +-
 crates/vm/src/stdlib/ast/argument.rs         |  20 +-
 crates/vm/src/stdlib/ast/basic.rs            |   4 +-
 crates/vm/src/stdlib/ast/constant.rs         |  84 +-
 crates/vm/src/stdlib/ast/elif_else_clause.rs |  20 +-
 crates/vm/src/stdlib/ast/exception.rs        |   6 +-
 crates/vm/src/stdlib/ast/expression.rs       | 114 ++-
 crates/vm/src/stdlib/ast/module.rs           |  18 +-
 crates/vm/src/stdlib/ast/operator.rs         |   8 +-
 crates/vm/src/stdlib/ast/other.rs            |  14 +-
 crates/vm/src/stdlib/ast/parameter.rs        |  30 +-
 crates/vm/src/stdlib/ast/pattern.rs          |  64 +-
 crates/vm/src/stdlib/ast/statement.rs        | 132 ++-
 crates/vm/src/stdlib/ast/string.rs           | 111 ++-
 crates/vm/src/stdlib/ast/type_parameters.rs  |  18 +-
 20 files changed, 863 insertions(+), 877 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index c58f3746ec0..c39c11892f9 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -21,19 +21,7 @@ use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex;
 use num_traits::{Num, ToPrimitive};
-use ruff_python_ast::{
-    Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem,
-    ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprContext,
-    ExprFString, ExprList, ExprName, ExprSlice, ExprStarred, ExprSubscript, ExprTString, ExprTuple,
-    ExprUnaryOp, FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedStringElement,
-    InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
-    Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
-    PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
-    Stmt, StmtAnnAssign, StmtExpr, StmtFor, StmtIf, StmtMatch, StmtTry, StmtWhile, StmtWith,
-    TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams,
-    UnaryOp, WithItem,
-    visitor::{Visitor, walk_expr},
-};
+use ruff_python_ast as ast;
 use ruff_text_size::{Ranged, TextRange};
 use std::collections::HashSet;
 
@@ -72,7 +60,7 @@ pub enum FBlockType {
 pub enum FBlockDatum {
     None,
     /// For FinallyTry: stores the finally body statements to compile during unwind
-    FinallyBody(Vec<Stmt>),
+    FinallyBody(Vec<ast::Stmt>),
     /// For HandlerCleanup: stores the exception variable name (e.g., "e" in "except X as e")
     ExceptionName(String),
 }
@@ -82,8 +70,8 @@ pub enum FBlockDatum {
 enum SuperCallType<'a> {
     /// super(class, self) - explicit 2-argument form
     TwoArg {
-        class_arg: &'a Expr,
-        self_arg: &'a Expr,
+        class_arg: &'a ast::Expr,
+        self_arg: &'a ast::Expr,
     },
     /// super() - implicit 0-argument form (uses __class__ cell)
     ZeroArg,
@@ -179,7 +167,7 @@ enum ComprehensionType {
     Dict,
 }
 
-fn validate_duplicate_params(params: &Parameters) -> Result<(), CodegenErrorType> {
+fn validate_duplicate_params(params: &ast::Parameters) -> Result<(), CodegenErrorType> {
     let mut seen_params = HashSet::new();
     for param in params {
         let param_name = param.name().as_str();
@@ -212,7 +200,7 @@ pub fn compile_top(
 
 /// Compile a standard Python program to bytecode
 pub fn compile_program(
-    ast: &ModModule,
+    ast: &ast::ModModule,
     source_file: SourceFile,
     opts: CompileOpts,
 ) -> CompileResult<CodeObject> {
@@ -227,7 +215,7 @@ pub fn compile_program(
 
 /// Compile a Python program to bytecode for the context of a REPL
 pub fn compile_program_single(
-    ast: &ModModule,
+    ast: &ast::ModModule,
     source_file: SourceFile,
     opts: CompileOpts,
 ) -> CompileResult<CodeObject> {
@@ -241,7 +229,7 @@ pub fn compile_program_single(
 }
 
 pub fn compile_block_expression(
-    ast: &ModModule,
+    ast: &ast::ModModule,
     source_file: SourceFile,
     opts: CompileOpts,
 ) -> CompileResult<CodeObject> {
@@ -255,7 +243,7 @@ pub fn compile_block_expression(
 }
 
 pub fn compile_expression(
-    ast: &ModExpression,
+    ast: &ast::ModExpression,
     source_file: SourceFile,
     opts: CompileOpts,
 ) -> CompileResult<CodeObject> {
@@ -437,13 +425,13 @@ impl Compiler {
 
     /// Check if the slice is a two-element slice (no step)
     // = is_two_element_slice
-    const fn is_two_element_slice(slice: &Expr) -> bool {
-        matches!(slice, Expr::Slice(s) if s.step.is_none())
+    const fn is_two_element_slice(slice: &ast::Expr) -> bool {
+        matches!(slice, ast::Expr::Slice(s) if s.step.is_none())
     }
 
     /// Compile a slice expression
     // = compiler_slice
-    fn compile_slice(&mut self, s: &ExprSlice) -> CompileResult<BuildSliceArgCount> {
+    fn compile_slice(&mut self, s: &ast::ExprSlice) -> CompileResult<BuildSliceArgCount> {
         // Compile lower
         if let Some(lower) = &s.lower {
             self.compile_expression(lower)?;
@@ -472,9 +460,9 @@ impl Compiler {
     // = compiler_subscript
     fn compile_subscript(
         &mut self,
-        value: &Expr,
-        slice: &Expr,
-        ctx: ExprContext,
+        value: &ast::Expr,
+        slice: &ast::Expr,
+        ctx: ast::ExprContext,
     ) -> CompileResult<()> {
         // 1. Check subscripter and index for Load context
         // 2. VISIT value
@@ -482,7 +470,7 @@ impl Compiler {
         // 4. Otherwise VISIT slice and emit appropriate instruction
 
         // For Load context, some checks are skipped for now
-        // if ctx == ExprContext::Load {
+        // if ctx == ast::ExprContext::Load {
         //     check_subscripter(value);
         //     check_index(value, slice);
         // }
@@ -491,17 +479,19 @@ impl Compiler {
         self.compile_expression(value)?;
 
         // Handle two-element slice (for Load/Store, not Del)
-        if Self::is_two_element_slice(slice) && !matches!(ctx, ExprContext::Del) {
+        if Self::is_two_element_slice(slice) && !matches!(ctx, ast::ExprContext::Del) {
             let argc = match slice {
-                Expr::Slice(s) => self.compile_slice(s)?,
-                _ => unreachable!("is_two_element_slice should only return true for Expr::Slice"),
+                ast::Expr::Slice(s) => self.compile_slice(s)?,
+                _ => unreachable!(
+                    "is_two_element_slice should only return true for ast::Expr::Slice"
+                ),
             };
             match ctx {
-                ExprContext::Load => {
+                ast::ExprContext::Load => {
                     emit!(self, Instruction::BuildSlice { argc });
                     emit!(self, Instruction::Subscript);
                 }
-                ExprContext::Store => {
+                ast::ExprContext::Store => {
                     emit!(self, Instruction::BuildSlice { argc });
                     emit!(self, Instruction::StoreSubscr);
                 }
@@ -513,10 +503,10 @@ impl Compiler {
 
             // Emit appropriate instruction based on context
             match ctx {
-                ExprContext::Load => emit!(self, Instruction::Subscript),
-                ExprContext::Store => emit!(self, Instruction::StoreSubscr),
-                ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
-                ExprContext::Invalid => {
+                ast::ExprContext::Load => emit!(self, Instruction::Subscript),
+                ast::ExprContext::Store => emit!(self, Instruction::StoreSubscr),
+                ast::ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
+                ast::ExprContext::Invalid => {
                     return Err(self.error(CodegenErrorType::SyntaxError(
                         "Invalid expression context".to_owned(),
                     )));
@@ -529,7 +519,7 @@ impl Compiler {
 
     /// Helper function for compiling tuples/lists/sets with starred expressions
     ///
-    /// Parameters:
+    /// ast::Parameters:
     /// - elts: The elements to compile
     /// - pushed: Number of items already on the stack
     /// - collection_type: What type of collection to build (tuple, list, set)
@@ -537,7 +527,7 @@ impl Compiler {
     // = starunpack_helper in compile.c
     fn starunpack_helper(
         &mut self,
-        elts: &[Expr],
+        elts: &[ast::Expr],
         pushed: u32,
         collection_type: CollectionType,
     ) -> CompileResult<()> {
@@ -736,13 +726,11 @@ impl Compiler {
     /// Returns Some(SuperCallType) if optimization is possible, None otherwise
     fn can_optimize_super_call<'a>(
         &self,
-        value: &'a Expr,
+        value: &'a ast::Expr,
         attr: &str,
     ) -> Option<SuperCallType<'a>> {
-        use ruff_python_ast::*;
-
         // 1. value must be a Call expression
-        let Expr::Call(ExprCall {
+        let ast::Expr::Call(ast::ExprCall {
             func, arguments, ..
         }) = value
         else {
@@ -750,7 +738,7 @@ impl Compiler {
         };
 
         // 2. func must be Name("super")
-        let Expr::Name(ExprName { id, .. }) = func.as_ref() else {
+        let ast::Expr::Name(ast::ExprName { id, .. }) = func.as_ref() else {
             return None;
         };
         if id.as_str() != "super" {
@@ -792,7 +780,7 @@ impl Compiler {
         let args = &arguments.args;
 
         // No starred expressions allowed
-        if args.iter().any(|arg| matches!(arg, Expr::Starred(_))) {
+        if args.iter().any(|arg| matches!(arg, ast::Expr::Starred(_))) {
             return None;
         }
 
@@ -1114,7 +1102,7 @@ impl Compiler {
         let _table = self.pop_symbol_table();
 
         // Various scopes can have sub_tables:
-        // - TypeParams scope can have sub_tables (the function body's symbol table)
+        // - ast::TypeParams scope can have sub_tables (the function body's symbol table)
         // - Module scope can have sub_tables (for TypeAlias scopes, nested functions, classes)
         // - Function scope can have sub_tables (for nested functions, classes)
         // - Class scope can have sub_tables (for nested classes, methods)
@@ -1554,7 +1542,7 @@ impl Compiler {
         let mut parent_idx = stack_size - 2;
         let mut parent = &self.code_stack[parent_idx];
 
-        // If parent is TypeParams scope, look at grandparent
+        // If parent is ast::TypeParams scope, look at grandparent
         // Check if parent is a type params scope by name pattern
         if parent.metadata.name.starts_with("<generic parameters of ") {
             if stack_size == 2 {
@@ -1627,7 +1615,7 @@ impl Compiler {
 
     fn compile_program(
         &mut self,
-        body: &ModModule,
+        body: &ast::ModModule,
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
         let size_before = self.code_stack.len();
@@ -1673,7 +1661,7 @@ impl Compiler {
 
     fn compile_program_single(
         &mut self,
-        body: &[Stmt],
+        body: &[ast::Stmt],
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
         // Set future_annotations from symbol table (detected during symbol table scan)
@@ -1699,7 +1687,7 @@ impl Compiler {
 
         if let Some((last, body)) = body.split_last() {
             for statement in body {
-                if let Stmt::Expr(StmtExpr { value, .. }) = &statement {
+                if let ast::Stmt::Expr(ast::StmtExpr { value, .. }) = &statement {
                     self.compile_expression(value)?;
                     emit!(
                         self,
@@ -1714,7 +1702,7 @@ impl Compiler {
                 }
             }
 
-            if let Stmt::Expr(StmtExpr { value, .. }) = &last {
+            if let ast::Stmt::Expr(ast::StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
                 emit!(self, Instruction::Copy { index: 1_u32 });
                 emit!(
@@ -1739,7 +1727,7 @@ impl Compiler {
 
     fn compile_block_expr(
         &mut self,
-        body: &[Stmt],
+        body: &[ast::Stmt],
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
         self.symbol_table_stack.push(symbol_table);
@@ -1748,10 +1736,10 @@ impl Compiler {
 
         if let Some(last_statement) = body.last() {
             match last_statement {
-                Stmt::Expr(_) => {
+                ast::Stmt::Expr(_) => {
                     self.current_block().instructions.pop(); // pop Instruction::PopTop
                 }
-                Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
+                ast::Stmt::FunctionDef(_) | ast::Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
                     let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
                     emit!(self, Instruction::Copy { index: 1_u32 });
@@ -1768,7 +1756,7 @@ impl Compiler {
     // Compile statement in eval mode:
     fn compile_eval(
         &mut self,
-        expression: &ModExpression,
+        expression: &ast::ModExpression,
         symbol_table: SymbolTable,
     ) -> CompileResult<()> {
         self.symbol_table_stack.push(symbol_table);
@@ -1777,7 +1765,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_statements(&mut self, statements: &[Stmt]) -> CompileResult<()> {
+    fn compile_statements(&mut self, statements: &[ast::Stmt]) -> CompileResult<()> {
         for statement in statements {
             self.compile_statement(statement)?
         }
@@ -1824,7 +1812,7 @@ impl Compiler {
         // Determine the operation type based on symbol scope
         let is_function_like = self.ctx.in_func();
 
-        // Look up the symbol, handling TypeParams and Annotation scopes specially
+        // Look up the symbol, handling ast::TypeParams and Annotation scopes specially
         let (symbol_scope, can_see_class_scope) = {
             let current_table = self.current_symbol_table();
             let is_typeparams = current_table.typ == CompilerScope::TypeParams;
@@ -1834,7 +1822,7 @@ impl Compiler {
             // First try to find in current table
             let symbol = current_table.lookup(name.as_ref());
 
-            // If not found and we're in TypeParams or Annotation scope, try parent scope
+            // If not found and we're in ast::TypeParams or Annotation scope, try parent scope
             let symbol = if symbol.is_none() && (is_typeparams || is_annotation) {
                 self.symbol_table_stack
                     .get(self.symbol_table_stack.len() - 2) // Try to get parent index
@@ -1985,22 +1973,21 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_statement(&mut self, statement: &Stmt) -> CompileResult<()> {
-        use ruff_python_ast::*;
+    fn compile_statement(&mut self, statement: &ast::Stmt) -> CompileResult<()> {
         trace!("Compiling {statement:?}");
         self.set_source_range(statement.range());
 
         match &statement {
             // we do this here because `from __future__` still executes that `from` statement at runtime,
             // we still need to compile the ImportFrom down below
-            Stmt::ImportFrom(StmtImportFrom { module, names, .. })
+            ast::Stmt::ImportFrom(ast::StmtImportFrom { module, names, .. })
                 if module.as_ref().map(|id| id.as_str()) == Some("__future__") =>
             {
                 self.compile_future_features(names)?
             }
             // ignore module-level doc comments
-            Stmt::Expr(StmtExpr { value, .. })
-                if matches!(&**value, Expr::StringLiteral(..))
+            ast::Stmt::Expr(ast::StmtExpr { value, .. })
+                if matches!(&**value, ast::Expr::StringLiteral(..))
                     && matches!(self.done_with_future_stmts, DoneWithFuture::No) =>
             {
                 self.done_with_future_stmts = DoneWithFuture::DoneWithDoc
@@ -2010,7 +1997,7 @@ impl Compiler {
         }
 
         match &statement {
-            Stmt::Import(StmtImport { names, .. }) => {
+            ast::Stmt::Import(ast::StmtImport { names, .. }) => {
                 // import a, b, c as d
                 for name in names {
                     let name = &name;
@@ -2031,7 +2018,7 @@ impl Compiler {
                     }
                 }
             }
-            Stmt::ImportFrom(StmtImportFrom {
+            ast::Stmt::ImportFrom(ast::StmtImportFrom {
                 level,
                 module,
                 names,
@@ -2097,16 +2084,16 @@ impl Compiler {
                     emit!(self, Instruction::PopTop);
                 }
             }
-            Stmt::Expr(StmtExpr { value, .. }) => {
+            ast::Stmt::Expr(ast::StmtExpr { value, .. }) => {
                 self.compile_expression(value)?;
 
                 // Pop result of stack, since we not use it:
                 emit!(self, Instruction::PopTop);
             }
-            Stmt::Global(_) | Stmt::Nonlocal(_) => {
+            ast::Stmt::Global(_) | ast::Stmt::Nonlocal(_) => {
                 // Handled during symbol table construction.
             }
-            Stmt::If(StmtIf {
+            ast::Stmt::If(ast::StmtIf {
                 test,
                 body,
                 elif_else_clauses,
@@ -2162,16 +2149,16 @@ impl Compiler {
                 }
                 self.leave_conditional_block();
             }
-            Stmt::While(StmtWhile {
+            ast::Stmt::While(ast::StmtWhile {
                 test, body, orelse, ..
             }) => self.compile_while(test, body, orelse)?,
-            Stmt::With(StmtWith {
+            ast::Stmt::With(ast::StmtWith {
                 items,
                 body,
                 is_async,
                 ..
             }) => self.compile_with(items, body, *is_async)?,
-            Stmt::For(StmtFor {
+            ast::Stmt::For(ast::StmtFor {
                 target,
                 iter,
                 body,
@@ -2179,8 +2166,10 @@ impl Compiler {
                 is_async,
                 ..
             }) => self.compile_for(target, iter, body, orelse, *is_async)?,
-            Stmt::Match(StmtMatch { subject, cases, .. }) => self.compile_match(subject, cases)?,
-            Stmt::Raise(StmtRaise {
+            ast::Stmt::Match(ast::StmtMatch { subject, cases, .. }) => {
+                self.compile_match(subject, cases)?
+            }
+            ast::Stmt::Raise(ast::StmtRaise {
                 exc, cause, range, ..
             }) => {
                 let kind = match exc {
@@ -2199,7 +2188,7 @@ impl Compiler {
                 self.set_source_range(*range);
                 emit!(self, Instruction::RaiseVarargs { kind });
             }
-            Stmt::Try(StmtTry {
+            ast::Stmt::Try(ast::StmtTry {
                 body,
                 handlers,
                 orelse,
@@ -2215,7 +2204,7 @@ impl Compiler {
                 }
                 self.leave_conditional_block();
             }
-            Stmt::FunctionDef(StmtFunctionDef {
+            ast::Stmt::FunctionDef(ast::StmtFunctionDef {
                 name,
                 parameters,
                 body,
@@ -2237,7 +2226,7 @@ impl Compiler {
                     type_params.as_deref(),
                 )?
             }
-            Stmt::ClassDef(StmtClassDef {
+            ast::Stmt::ClassDef(ast::StmtClassDef {
                 name,
                 body,
                 decorator_list,
@@ -2251,7 +2240,7 @@ impl Compiler {
                 type_params.as_deref(),
                 arguments.as_deref(),
             )?,
-            Stmt::Assert(StmtAssert { test, msg, .. }) => {
+            ast::Stmt::Assert(ast::StmtAssert { test, msg, .. }) => {
                 // if some flag, ignore all assert statements!
                 if self.opts.optimize == 0 {
                     let after_block = self.new_block();
@@ -2279,15 +2268,15 @@ impl Compiler {
                     self.switch_to_block(after_block);
                 }
             }
-            Stmt::Break(_) => {
+            ast::Stmt::Break(_) => {
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), true)?;
             }
-            Stmt::Continue(_) => {
+            ast::Stmt::Continue(_) => {
                 // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
                 self.compile_break_continue(statement.range(), false)?;
             }
-            Stmt::Return(StmtReturn { value, .. }) => {
+            ast::Stmt::Return(ast::StmtReturn { value, .. }) => {
                 if !self.ctx.in_func() {
                     return Err(
                         self.error_ranged(CodegenErrorType::InvalidReturn, statement.range())
@@ -2319,7 +2308,7 @@ impl Compiler {
                     }
                 }
             }
-            Stmt::Assign(StmtAssign { targets, value, .. }) => {
+            ast::Stmt::Assign(ast::StmtAssign { targets, value, .. }) => {
                 self.compile_expression(value)?;
 
                 for (i, target) in targets.iter().enumerate() {
@@ -2329,25 +2318,25 @@ impl Compiler {
                     self.compile_store(target)?;
                 }
             }
-            Stmt::AugAssign(StmtAugAssign {
+            ast::Stmt::AugAssign(ast::StmtAugAssign {
                 target, op, value, ..
             }) => self.compile_augassign(target, op, value)?,
-            Stmt::AnnAssign(StmtAnnAssign {
+            ast::Stmt::AnnAssign(ast::StmtAnnAssign {
                 target,
                 annotation,
                 value,
                 simple,
                 ..
             }) => self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?,
-            Stmt::Delete(StmtDelete { targets, .. }) => {
+            ast::Stmt::Delete(ast::StmtDelete { targets, .. }) => {
                 for target in targets {
                     self.compile_delete(target)?;
                 }
             }
-            Stmt::Pass(_) => {
+            ast::Stmt::Pass(_) => {
                 // No need to emit any code here :)
             }
-            Stmt::TypeAlias(StmtTypeAlias {
+            ast::Stmt::TypeAlias(ast::StmtTypeAlias {
                 name,
                 type_params,
                 value,
@@ -2403,31 +2392,33 @@ impl Compiler {
                 );
                 self.store_name(&name_string)?;
             }
-            Stmt::IpyEscapeCommand(_) => todo!(),
+            ast::Stmt::IpyEscapeCommand(_) => todo!(),
         }
         Ok(())
     }
 
-    fn compile_delete(&mut self, expression: &Expr) -> CompileResult<()> {
-        use ruff_python_ast::*;
+    fn compile_delete(&mut self, expression: &ast::Expr) -> CompileResult<()> {
         match &expression {
-            Expr::Name(ExprName { id, .. }) => self.compile_name(id.as_str(), NameUsage::Delete)?,
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+            ast::Expr::Name(ast::ExprName { id, .. }) => {
+                self.compile_name(id.as_str(), NameUsage::Delete)?
+            }
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
                 emit!(self, Instruction::DeleteAttr { idx });
             }
-            Expr::Subscript(ExprSubscript {
+            ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
             }) => {
                 self.compile_subscript(value, slice, *ctx)?;
             }
-            Expr::Tuple(ExprTuple { elts, .. }) | Expr::List(ExprList { elts, .. }) => {
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. })
+            | ast::Expr::List(ast::ExprList { elts, .. }) => {
                 for element in elts {
                     self.compile_delete(element)?;
                 }
             }
-            Expr::BinOp(_) | Expr::UnaryOp(_) => {
+            ast::Expr::BinOp(_) | ast::Expr::UnaryOp(_) => {
                 return Err(self.error(CodegenErrorType::Delete("expression")));
             }
             _ => return Err(self.error(CodegenErrorType::Delete(expression.python_name()))),
@@ -2435,7 +2426,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn enter_function(&mut self, name: &str, parameters: &Parameters) -> CompileResult<()> {
+    fn enter_function(&mut self, name: &str, parameters: &ast::Parameters) -> CompileResult<()> {
         // TODO: partition_in_place
         let mut kw_without_defaults = vec![];
         let mut kw_with_defaults = vec![];
@@ -2479,7 +2470,7 @@ impl Compiler {
 
     /// Push decorators onto the stack in source order.
     /// For @dec1 @dec2 def foo(): stack becomes [dec1, NULL, dec2, NULL]
-    fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
+    fn prepare_decorators(&mut self, decorator_list: &[ast::Decorator]) -> CompileResult<()> {
         for decorator in decorator_list {
             self.compile_expression(&decorator.expression)?;
             emit!(self, Instruction::PushNull);
@@ -2491,7 +2482,7 @@ impl Compiler {
     /// Stack [dec1, NULL, dec2, NULL, func] -> dec2(func) -> dec1(dec2(func))
     /// The forward loop works because each Call pops from TOS, naturally
     /// applying decorators bottom-up (innermost first).
-    fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
+    fn apply_decorators(&mut self, decorator_list: &[ast::Decorator]) {
         for _ in decorator_list {
             emit!(self, Instruction::Call { nargs: 1 });
         }
@@ -2500,7 +2491,7 @@ impl Compiler {
     /// Compile type parameter bound or default in a separate scope and return closure
     fn compile_type_param_bound_or_default(
         &mut self,
-        expr: &Expr,
+        expr: &ast::Expr,
         name: &str,
         allow_starred: bool,
     ) -> CompileResult<()> {
@@ -2515,8 +2506,8 @@ impl Compiler {
         self.enter_scope(name, CompilerScope::TypeParams, key, lineno)?;
 
         // Compile the expression
-        if allow_starred && matches!(expr, Expr::Starred(_)) {
-            if let Expr::Starred(starred) = expr {
+        if allow_starred && matches!(expr, ast::Expr::Starred(_)) {
+            if let ast::Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
                 emit!(self, Instruction::UnpackSequence { size: 1 });
             }
@@ -2543,11 +2534,11 @@ impl Compiler {
 
     /// Store each type parameter so it is accessible to the current scope, and leave a tuple of
     /// all the type parameters on the stack. Handles default values per PEP 695.
-    fn compile_type_params(&mut self, type_params: &TypeParams) -> CompileResult<()> {
+    fn compile_type_params(&mut self, type_params: &ast::TypeParams) -> CompileResult<()> {
         // First, compile each type parameter and store it
         for type_param in &type_params.type_params {
             match type_param {
-                TypeParam::TypeVar(TypeParamTypeVar {
+                ast::TypeParam::TypeVar(ast::TypeParamTypeVar {
                     name,
                     bound,
                     default,
@@ -2594,7 +2585,7 @@ impl Compiler {
                     emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
-                TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
+                ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, default, .. }) => {
                     self.emit_load_const(ConstantData::Str {
                         value: name.as_str().into(),
                     });
@@ -2619,7 +2610,9 @@ impl Compiler {
                     emit!(self, Instruction::Copy { index: 1_u32 });
                     self.store_name(name.as_ref())?;
                 }
-                TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
+                ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
+                    name, default, ..
+                }) => {
                     self.emit_load_const(ConstantData::Str {
                         value: name.as_str().into(),
                     });
@@ -2658,10 +2651,10 @@ impl Compiler {
 
     fn compile_try_statement(
         &mut self,
-        body: &[Stmt],
-        handlers: &[ExceptHandler],
-        orelse: &[Stmt],
-        finalbody: &[Stmt],
+        body: &[ast::Stmt],
+        handlers: &[ast::ExceptHandler],
+        orelse: &[ast::Stmt],
+        finalbody: &[ast::Stmt],
     ) -> CompileResult<()> {
         let handler_block = self.new_block();
         let finally_block = self.new_block();
@@ -2844,8 +2837,11 @@ impl Compiler {
         // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
         emit!(self, Instruction::PushExcInfo);
         for handler in handlers {
-            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
-                type_, name, body, ..
+            let ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+                type_,
+                name,
+                body,
+                ..
             }) = &handler;
             let next_handler = self.new_block();
 
@@ -3117,10 +3113,10 @@ impl Compiler {
 
     fn compile_try_star_except(
         &mut self,
-        body: &[Stmt],
-        handlers: &[ExceptHandler],
-        orelse: &[Stmt],
-        finalbody: &[Stmt],
+        body: &[ast::Stmt],
+        handlers: &[ast::ExceptHandler],
+        orelse: &[ast::Stmt],
+        finalbody: &[ast::Stmt],
     ) -> CompileResult<()> {
         // compiler_try_star_except
         // Stack layout during handler processing: [prev_exc, orig, list, rest]
@@ -3177,8 +3173,11 @@ impl Compiler {
 
         let n = handlers.len();
         for (i, handler) in handlers.iter().enumerate() {
-            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
-                type_, name, body, ..
+            let ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+                type_,
+                name,
+                body,
+                ..
             }) = handler;
 
             let no_match_block = self.new_block();
@@ -3198,7 +3197,7 @@ impl Compiler {
             // Compile exception type
             if let Some(exc_type) = type_ {
                 // Check for unparenthesized tuple
-                if let Expr::Tuple(ExprTuple { elts, range, .. }) = exc_type.as_ref()
+                if let ast::Expr::Tuple(ast::ExprTuple { elts, range, .. }) = exc_type.as_ref()
                     && let Some(first) = elts.first()
                     && range.start().to_u32() == first.range().start().to_u32()
                 {
@@ -3435,7 +3434,7 @@ impl Compiler {
     // = compiler_default_arguments
     fn compile_default_arguments(
         &mut self,
-        parameters: &Parameters,
+        parameters: &ast::Parameters,
     ) -> CompileResult<bytecode::MakeFunctionFlags> {
         let mut funcflags = bytecode::MakeFunctionFlags::empty();
 
@@ -3493,8 +3492,8 @@ impl Compiler {
     fn compile_function_body(
         &mut self,
         name: &str,
-        parameters: &Parameters,
-        body: &[Stmt],
+        parameters: &ast::Parameters,
+        body: &[ast::Stmt],
         is_async: bool,
         funcflags: bytecode::MakeFunctionFlags,
     ) -> CompileResult<()> {
@@ -3540,7 +3539,7 @@ impl Compiler {
 
         // Emit None at end if needed
         match body.last() {
-            Some(Stmt::Return(_)) => {}
+            Some(ast::Stmt::Return(_)) => {}
             _ => {
                 self.emit_return_const(ConstantData::None);
             }
@@ -3565,8 +3564,8 @@ impl Compiler {
     fn compile_annotations_closure(
         &mut self,
         func_name: &str,
-        parameters: &Parameters,
-        returns: Option<&Expr>,
+        parameters: &ast::Parameters,
+        returns: Option<&ast::Expr>,
     ) -> CompileResult<bool> {
         // Try to enter annotation scope - returns false if no annotation_block exists
         if !self.enter_annotation_scope(func_name)? {
@@ -3635,21 +3634,21 @@ impl Compiler {
     /// Returns list of (name, annotation_expr) pairs
     /// This must match the order that annotations are compiled to ensure
     /// conditional_annotation_index stays in sync with __annotate__ enumeration.
-    fn collect_simple_annotations(body: &[Stmt]) -> Vec<(&str, &Expr)> {
-        fn walk<'a>(stmts: &'a [Stmt], out: &mut Vec<(&'a str, &'a Expr)>) {
+    fn collect_simple_annotations(body: &[ast::Stmt]) -> Vec<(&str, &ast::Expr)> {
+        fn walk<'a>(stmts: &'a [ast::Stmt], out: &mut Vec<(&'a str, &'a ast::Expr)>) {
             for stmt in stmts {
                 match stmt {
-                    Stmt::AnnAssign(StmtAnnAssign {
+                    ast::Stmt::AnnAssign(ast::StmtAnnAssign {
                         target,
                         annotation,
                         simple,
                         ..
-                    }) if *simple && matches!(target.as_ref(), Expr::Name(_)) => {
-                        if let Expr::Name(ExprName { id, .. }) = target.as_ref() {
+                    }) if *simple && matches!(target.as_ref(), ast::Expr::Name(_)) => {
+                        if let ast::Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
                             out.push((id.as_str(), annotation.as_ref()));
                         }
                     }
-                    Stmt::If(StmtIf {
+                    ast::Stmt::If(ast::StmtIf {
                         body,
                         elif_else_clauses,
                         ..
@@ -3659,13 +3658,13 @@ impl Compiler {
                             walk(&clause.body, out);
                         }
                     }
-                    Stmt::For(StmtFor { body, orelse, .. })
-                    | Stmt::While(StmtWhile { body, orelse, .. }) => {
+                    ast::Stmt::For(ast::StmtFor { body, orelse, .. })
+                    | ast::Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
                         walk(body, out);
                         walk(orelse, out);
                     }
-                    Stmt::With(StmtWith { body, .. }) => walk(body, out),
-                    Stmt::Try(StmtTry {
+                    ast::Stmt::With(ast::StmtWith { body, .. }) => walk(body, out),
+                    ast::Stmt::Try(ast::StmtTry {
                         body,
                         handlers,
                         orelse,
@@ -3674,16 +3673,15 @@ impl Compiler {
                     }) => {
                         walk(body, out);
                         for handler in handlers {
-                            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
-                                body,
-                                ..
-                            }) = handler;
+                            let ast::ExceptHandler::ExceptHandler(
+                                ast::ExceptHandlerExceptHandler { body, .. },
+                            ) = handler;
                             walk(body, out);
                         }
                         walk(orelse, out);
                         walk(finalbody, out);
                     }
-                    Stmt::Match(StmtMatch { cases, .. }) => {
+                    ast::Stmt::Match(ast::StmtMatch { cases, .. }) => {
                         for case in cases {
                             walk(&case.body, out);
                         }
@@ -3699,7 +3697,7 @@ impl Compiler {
 
     /// Compile module-level __annotate__ function (PEP 649)
     /// Returns true if __annotate__ was created and stored
-    fn compile_module_annotate(&mut self, body: &[Stmt]) -> CompileResult<bool> {
+    fn compile_module_annotate(&mut self, body: &[ast::Stmt]) -> CompileResult<bool> {
         // Collect simple annotations from module body first
         let annotations = Self::collect_simple_annotations(body);
 
@@ -3842,12 +3840,12 @@ impl Compiler {
     fn compile_function_def(
         &mut self,
         name: &str,
-        parameters: &Parameters,
-        body: &[Stmt],
-        decorator_list: &[Decorator],
-        returns: Option<&Expr>, // TODO: use type hint somehow..
+        parameters: &ast::Parameters,
+        body: &[ast::Stmt],
+        decorator_list: &[ast::Decorator],
+        returns: Option<&ast::Expr>, // TODO: use type hint somehow..
         is_async: bool,
-        type_params: Option<&TypeParams>,
+        type_params: Option<&ast::TypeParams>,
     ) -> CompileResult<()> {
         self.prepare_decorators(decorator_list)?;
 
@@ -4163,15 +4161,14 @@ impl Compiler {
     }
 
     // Python/compile.c find_ann
-    fn find_ann(body: &[Stmt]) -> bool {
-        use ruff_python_ast::*;
+    fn find_ann(body: &[ast::Stmt]) -> bool {
         for statement in body {
             let res = match &statement {
-                Stmt::AnnAssign(_) => true,
-                Stmt::For(StmtFor { body, orelse, .. }) => {
+                ast::Stmt::AnnAssign(_) => true,
+                ast::Stmt::For(ast::StmtFor { body, orelse, .. }) => {
                     Self::find_ann(body) || Self::find_ann(orelse)
                 }
-                Stmt::If(StmtIf {
+                ast::Stmt::If(ast::StmtIf {
                     body,
                     elif_else_clauses,
                     ..
@@ -4179,11 +4176,11 @@ impl Compiler {
                     Self::find_ann(body)
                         || elif_else_clauses.iter().any(|x| Self::find_ann(&x.body))
                 }
-                Stmt::While(StmtWhile { body, orelse, .. }) => {
+                ast::Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
                     Self::find_ann(body) || Self::find_ann(orelse)
                 }
-                Stmt::With(StmtWith { body, .. }) => Self::find_ann(body),
-                Stmt::Try(StmtTry {
+                ast::Stmt::With(ast::StmtWith { body, .. }) => Self::find_ann(body),
+                ast::Stmt::Try(ast::StmtTry {
                     body,
                     orelse,
                     finalbody,
@@ -4203,8 +4200,8 @@ impl Compiler {
     fn compile_class_body(
         &mut self,
         name: &str,
-        body: &[Stmt],
-        type_params: Option<&TypeParams>,
+        body: &[ast::Stmt],
+        type_params: Option<&ast::TypeParams>,
         firstlineno: u32,
     ) -> CompileResult<CodeObject> {
         // 1. Enter class scope
@@ -4318,10 +4315,10 @@ impl Compiler {
     fn compile_class_def(
         &mut self,
         name: &str,
-        body: &[Stmt],
-        decorator_list: &[Decorator],
-        type_params: Option<&TypeParams>,
-        arguments: Option<&Arguments>,
+        body: &[ast::Stmt],
+        decorator_list: &[ast::Decorator],
+        type_params: Option<&ast::TypeParams>,
+        arguments: Option<&ast::Arguments>,
     ) -> CompileResult<()> {
         self.prepare_decorators(decorator_list)?;
 
@@ -4390,8 +4387,11 @@ impl Compiler {
 
             // Compile bases and call __build_class__
             // Check for starred bases or **kwargs
-            let has_starred = arguments
-                .is_some_and(|args| args.args.iter().any(|arg| matches!(arg, Expr::Starred(_))));
+            let has_starred = arguments.is_some_and(|args| {
+                args.args
+                    .iter()
+                    .any(|arg| matches!(arg, ast::Expr::Starred(_)))
+            });
             let has_double_star =
                 arguments.is_some_and(|args| args.keywords.iter().any(|kw| kw.arg.is_none()));
 
@@ -4506,7 +4506,12 @@ impl Compiler {
         self.store_name(name)
     }
 
-    fn compile_while(&mut self, test: &Expr, body: &[Stmt], orelse: &[Stmt]) -> CompileResult<()> {
+    fn compile_while(
+        &mut self,
+        test: &ast::Expr,
+        body: &[ast::Stmt],
+        orelse: &[ast::Stmt],
+    ) -> CompileResult<()> {
         self.enter_conditional_block();
 
         let while_block = self.new_block();
@@ -4544,8 +4549,8 @@ impl Compiler {
 
     fn compile_with(
         &mut self,
-        items: &[WithItem],
-        body: &[Stmt],
+        items: &[ast::WithItem],
+        body: &[ast::Stmt],
         is_async: bool,
     ) -> CompileResult<()> {
         self.enter_conditional_block();
@@ -4768,10 +4773,10 @@ impl Compiler {
 
     fn compile_for(
         &mut self,
-        target: &Expr,
-        iter: &Expr,
-        body: &[Stmt],
-        orelse: &[Stmt],
+        target: &ast::Expr,
+        iter: &ast::Expr,
+        body: &[ast::Stmt],
+        orelse: &[ast::Stmt],
         is_async: bool,
     ) -> CompileResult<()> {
         self.enter_conditional_block();
@@ -4956,7 +4961,7 @@ impl Compiler {
     /// to the list of captured names.
     fn pattern_helper_store_name(
         &mut self,
-        n: Option<&Identifier>,
+        n: Option<&ast::Identifier>,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         match n {
@@ -4990,7 +4995,7 @@ impl Compiler {
         }
     }
 
-    fn pattern_unpack_helper(&mut self, elts: &[Pattern]) -> CompileResult<()> {
+    fn pattern_unpack_helper(&mut self, elts: &[ast::Pattern]) -> CompileResult<()> {
         let n = elts.len();
         let mut seen_star = false;
         for (i, elt) in elts.iter().enumerate() {
@@ -5026,7 +5031,7 @@ impl Compiler {
 
     fn pattern_helper_sequence_unpack(
         &mut self,
-        patterns: &[Pattern],
+        patterns: &[ast::Pattern],
         _star: Option<usize>,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
@@ -5046,7 +5051,7 @@ impl Compiler {
 
     fn pattern_helper_sequence_subscr(
         &mut self,
-        patterns: &[Pattern],
+        patterns: &[ast::Pattern],
         star: usize,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
@@ -5094,7 +5099,7 @@ impl Compiler {
 
     fn compile_pattern_subpattern(
         &mut self,
-        p: &Pattern,
+        p: &ast::Pattern,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // Save the current allow_irrefutable state.
@@ -5110,7 +5115,7 @@ impl Compiler {
 
     fn compile_pattern_as(
         &mut self,
-        p: &PatternMatchAs,
+        p: &ast::PatternMatchAs,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // If there is no sub-pattern, then it's an irrefutable match.
@@ -5147,7 +5152,7 @@ impl Compiler {
 
     fn compile_pattern_star(
         &mut self,
-        p: &PatternMatchStar,
+        p: &ast::PatternMatchStar,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         self.pattern_helper_store_name(p.name.as_ref(), pc)?;
@@ -5158,8 +5163,8 @@ impl Compiler {
     /// and not duplicated.
     fn validate_kwd_attrs(
         &mut self,
-        attrs: &[Identifier],
-        _patterns: &[Pattern],
+        attrs: &[ast::Identifier],
+        _patterns: &[ast::Pattern],
     ) -> CompileResult<()> {
         let n_attrs = attrs.len();
         for i in 0..n_attrs {
@@ -5182,7 +5187,7 @@ impl Compiler {
 
     fn compile_pattern_class(
         &mut self,
-        p: &PatternMatchClass,
+        p: &ast::PatternMatchClass,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // Extract components from the MatchClass pattern.
@@ -5261,7 +5266,7 @@ impl Compiler {
         for subpattern in patterns.iter().chain(kwd_patterns.iter()) {
             // Check if this is a true wildcard (underscore pattern without name binding)
             let is_true_wildcard = match subpattern {
-                Pattern::MatchAs(match_as) => {
+                ast::Pattern::MatchAs(match_as) => {
                     // Only consider it wildcard if both pattern and name are None (i.e., "_")
                     match_as.pattern.is_none() && match_as.name.is_none()
                 }
@@ -5284,7 +5289,7 @@ impl Compiler {
 
     fn compile_pattern_mapping(
         &mut self,
-        p: &PatternMatchMapping,
+        p: &ast::PatternMatchMapping,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         let mapping = p;
@@ -5357,14 +5362,14 @@ impl Compiler {
             // Validate and compile keys
             let mut seen = HashSet::new();
             for key in keys {
-                let is_attribute = matches!(key, Expr::Attribute(_));
+                let is_attribute = matches!(key, ast::Expr::Attribute(_));
                 let is_literal = matches!(
                     key,
-                    Expr::NumberLiteral(_)
-                        | Expr::StringLiteral(_)
-                        | Expr::BytesLiteral(_)
-                        | Expr::BooleanLiteral(_)
-                        | Expr::NoneLiteral(_)
+                    ast::Expr::NumberLiteral(_)
+                        | ast::Expr::StringLiteral(_)
+                        | ast::Expr::BytesLiteral(_)
+                        | ast::Expr::BooleanLiteral(_)
+                        | ast::Expr::NoneLiteral(_)
                 );
                 let key_repr = if is_literal {
                     UnparseExpr::new(key, &self.source_file).to_string()
@@ -5487,7 +5492,7 @@ impl Compiler {
 
     fn compile_pattern_or(
         &mut self,
-        p: &PatternMatchOr,
+        p: &ast::PatternMatchOr,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // Ensure the pattern is a MatchOr.
@@ -5595,11 +5600,11 @@ impl Compiler {
 
     fn compile_pattern_sequence(
         &mut self,
-        p: &PatternMatchSequence,
+        p: &ast::PatternMatchSequence,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // Ensure the pattern is a MatchSequence.
-        let patterns = &p.patterns; // a slice of Pattern
+        let patterns = &p.patterns; // a slice of ast::Pattern
         let size = patterns.len();
         let mut star: Option<usize> = None;
         let mut only_wildcard = true;
@@ -5662,7 +5667,7 @@ impl Compiler {
         // Whatever comes next should consume the subject.
         pc.on_top -= 1;
         if only_wildcard {
-            // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
+            // ast::Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
             emit!(self, Instruction::PopTop);
         } else if star_wildcard {
             self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
@@ -5674,7 +5679,7 @@ impl Compiler {
 
     fn compile_pattern_value(
         &mut self,
-        p: &PatternMatchValue,
+        p: &ast::PatternMatchValue,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // TODO: ensure literal or attribute lookup
@@ -5692,14 +5697,14 @@ impl Compiler {
 
     fn compile_pattern_singleton(
         &mut self,
-        p: &PatternMatchSingleton,
+        p: &ast::PatternMatchSingleton,
         pc: &mut PatternContext,
     ) -> CompileResult<()> {
         // Load the singleton constant value.
         self.emit_load_const(match p.value {
-            Singleton::None => ConstantData::None,
-            Singleton::False => ConstantData::Boolean { value: false },
-            Singleton::True => ConstantData::Boolean { value: true },
+            ast::Singleton::None => ConstantData::None,
+            ast::Singleton::False => ConstantData::Boolean { value: false },
+            ast::Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
         emit!(self, Instruction::IsOp(Invert::No));
@@ -5710,32 +5715,32 @@ impl Compiler {
 
     fn compile_pattern(
         &mut self,
-        pattern_type: &Pattern,
+        pattern_type: &ast::Pattern,
         pattern_context: &mut PatternContext,
     ) -> CompileResult<()> {
         match &pattern_type {
-            Pattern::MatchValue(pattern_type) => {
+            ast::Pattern::MatchValue(pattern_type) => {
                 self.compile_pattern_value(pattern_type, pattern_context)
             }
-            Pattern::MatchSingleton(pattern_type) => {
+            ast::Pattern::MatchSingleton(pattern_type) => {
                 self.compile_pattern_singleton(pattern_type, pattern_context)
             }
-            Pattern::MatchSequence(pattern_type) => {
+            ast::Pattern::MatchSequence(pattern_type) => {
                 self.compile_pattern_sequence(pattern_type, pattern_context)
             }
-            Pattern::MatchMapping(pattern_type) => {
+            ast::Pattern::MatchMapping(pattern_type) => {
                 self.compile_pattern_mapping(pattern_type, pattern_context)
             }
-            Pattern::MatchClass(pattern_type) => {
+            ast::Pattern::MatchClass(pattern_type) => {
                 self.compile_pattern_class(pattern_type, pattern_context)
             }
-            Pattern::MatchStar(pattern_type) => {
+            ast::Pattern::MatchStar(pattern_type) => {
                 self.compile_pattern_star(pattern_type, pattern_context)
             }
-            Pattern::MatchAs(pattern_type) => {
+            ast::Pattern::MatchAs(pattern_type) => {
                 self.compile_pattern_as(pattern_type, pattern_context)
             }
-            Pattern::MatchOr(pattern_type) => {
+            ast::Pattern::MatchOr(pattern_type) => {
                 self.compile_pattern_or(pattern_type, pattern_context)
             }
         }
@@ -5743,8 +5748,8 @@ impl Compiler {
 
     fn compile_match_inner(
         &mut self,
-        subject: &Expr,
-        cases: &[MatchCase],
+        subject: &ast::Expr,
+        cases: &[ast::MatchCase],
         pattern_context: &mut PatternContext,
     ) -> CompileResult<()> {
         self.compile_expression(subject)?;
@@ -5815,7 +5820,11 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_match(&mut self, subject: &Expr, cases: &[MatchCase]) -> CompileResult<()> {
+    fn compile_match(
+        &mut self,
+        subject: &ast::Expr,
+        cases: &[ast::MatchCase],
+    ) -> CompileResult<()> {
         self.enter_conditional_block();
         let mut pattern_context = PatternContext::new();
         self.compile_match_inner(subject, cases, &mut pattern_context)?;
@@ -5824,21 +5833,21 @@ impl Compiler {
     }
 
     /// [CPython `compiler_addcompare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L2880-L2924)
-    fn compile_addcompare(&mut self, op: &CmpOp) {
+    fn compile_addcompare(&mut self, op: &ast::CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
-            CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
-            CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
-            CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
-            CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
-            CmpOp::GtE => {
+            ast::CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
+            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
+            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
+            ast::CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
+            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
+            ast::CmpOp::GtE => {
                 emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
             }
-            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
-            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
-            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
-            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+            ast::CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
+            ast::CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
+            ast::CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
+            ast::CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
         }
     }
 
@@ -5862,9 +5871,9 @@ impl Compiler {
     /// - [CPython `compiler_compare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L4678-L4717)
     fn compile_compare(
         &mut self,
-        left: &Expr,
-        ops: &[CmpOp],
-        comparators: &[Expr],
+        left: &ast::Expr,
+        ops: &[ast::CmpOp],
+        comparators: &[ast::Expr],
     ) -> CompileResult<()> {
         let (last_op, mid_ops) = ops.split_last().unwrap();
         let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
@@ -5917,7 +5926,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_annotation(&mut self, annotation: &Expr) -> CompileResult<()> {
+    fn compile_annotation(&mut self, annotation: &ast::Expr) -> CompileResult<()> {
         if self.future_annotations {
             self.emit_load_const(ConstantData::Str {
                 value: UnparseExpr::new(annotation, &self.source_file)
@@ -5930,7 +5939,7 @@ impl Compiler {
 
             // Special handling for starred annotations (*Ts -> Unpack[Ts])
             let result = match annotation {
-                Expr::Starred(ExprStarred { value, .. }) => {
+                ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
@@ -5948,9 +5957,9 @@ impl Compiler {
 
     fn compile_annotated_assign(
         &mut self,
-        target: &Expr,
-        annotation: &Expr,
-        value: Option<&Expr>,
+        target: &ast::Expr,
+        annotation: &ast::Expr,
+        value: Option<&ast::Expr>,
         simple: bool,
     ) -> CompileResult<()> {
         // Perform the actual assignment first
@@ -5962,7 +5971,7 @@ impl Compiler {
         // If we have a simple name in module or class scope, store annotation
         if simple
             && !self.ctx.in_func()
-            && let Expr::Name(ExprName { id, .. }) = target
+            && let ast::Expr::Name(ast::ExprName { id, .. }) = target
         {
             if self.future_annotations {
                 // PEP 563: Store stringified annotation directly to __annotations__
@@ -6011,25 +6020,26 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_store(&mut self, target: &Expr) -> CompileResult<()> {
+    fn compile_store(&mut self, target: &ast::Expr) -> CompileResult<()> {
         match &target {
-            Expr::Name(ExprName { id, .. }) => self.store_name(id.as_str())?,
-            Expr::Subscript(ExprSubscript {
+            ast::Expr::Name(ast::ExprName { id, .. }) => self.store_name(id.as_str())?,
+            ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
             }) => {
                 self.compile_subscript(value, slice, *ctx)?;
             }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
                 emit!(self, Instruction::StoreAttr { idx });
             }
-            Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
+            ast::Expr::List(ast::ExprList { elts, .. })
+            | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
                 let mut seen_star = false;
 
                 // Scan for star args:
                 for (i, element) in elts.iter().enumerate() {
-                    if let Expr::Starred(_) = &element {
+                    if let ast::Expr::Starred(_) = &element {
                         if seen_star {
                             return Err(self.error(CodegenErrorType::MultipleStarArgs));
                         } else {
@@ -6059,7 +6069,7 @@ impl Compiler {
                 }
 
                 for element in elts {
-                    if let Expr::Starred(ExprStarred { value, .. }) = &element {
+                    if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = &element {
                         self.compile_store(value)?;
                     } else {
                         self.compile_store(element)?;
@@ -6068,7 +6078,7 @@ impl Compiler {
             }
             _ => {
                 return Err(self.error(match target {
-                    Expr::Starred(_) => CodegenErrorType::SyntaxError(
+                    ast::Expr::Starred(_) => CodegenErrorType::SyntaxError(
                         "starred assignment target must be in a list or tuple".to_owned(),
                     ),
                     _ => CodegenErrorType::Assign(target.python_name()),
@@ -6081,9 +6091,9 @@ impl Compiler {
 
     fn compile_augassign(
         &mut self,
-        target: &Expr,
-        op: &Operator,
-        value: &Expr,
+        target: &ast::Expr,
+        op: &ast::Operator,
+        value: &ast::Expr,
     ) -> CompileResult<()> {
         enum AugAssignKind<'a> {
             Name { id: &'a str },
@@ -6092,12 +6102,12 @@ impl Compiler {
         }
 
         let kind = match &target {
-            Expr::Name(ExprName { id, .. }) => {
+            ast::Expr::Name(ast::ExprName { id, .. }) => {
                 let id = id.as_str();
                 self.compile_name(id, NameUsage::Load)?;
                 AugAssignKind::Name { id }
             }
-            Expr::Subscript(ExprSubscript {
+            ast::Expr::Subscript(ast::ExprSubscript {
                 value,
                 slice,
                 ctx: _,
@@ -6112,7 +6122,7 @@ impl Compiler {
                 emit!(self, Instruction::Subscript);
                 AugAssignKind::Subscript
             }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.compile_expression(value)?;
                 emit!(self, Instruction::Copy { index: 1_u32 });
@@ -6149,21 +6159,21 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_op(&mut self, op: &Operator, inplace: bool) {
+    fn compile_op(&mut self, op: &ast::Operator, inplace: bool) {
         let bin_op = match op {
-            Operator::Add => BinaryOperator::Add,
-            Operator::Sub => BinaryOperator::Subtract,
-            Operator::Mult => BinaryOperator::Multiply,
-            Operator::MatMult => BinaryOperator::MatrixMultiply,
-            Operator::Div => BinaryOperator::TrueDivide,
-            Operator::FloorDiv => BinaryOperator::FloorDivide,
-            Operator::Mod => BinaryOperator::Remainder,
-            Operator::Pow => BinaryOperator::Power,
-            Operator::LShift => BinaryOperator::Lshift,
-            Operator::RShift => BinaryOperator::Rshift,
-            Operator::BitOr => BinaryOperator::Or,
-            Operator::BitXor => BinaryOperator::Xor,
-            Operator::BitAnd => BinaryOperator::And,
+            ast::Operator::Add => BinaryOperator::Add,
+            ast::Operator::Sub => BinaryOperator::Subtract,
+            ast::Operator::Mult => BinaryOperator::Multiply,
+            ast::Operator::MatMult => BinaryOperator::MatrixMultiply,
+            ast::Operator::Div => BinaryOperator::TrueDivide,
+            ast::Operator::FloorDiv => BinaryOperator::FloorDivide,
+            ast::Operator::Mod => BinaryOperator::Remainder,
+            ast::Operator::Pow => BinaryOperator::Power,
+            ast::Operator::LShift => BinaryOperator::Lshift,
+            ast::Operator::RShift => BinaryOperator::Rshift,
+            ast::Operator::BitOr => BinaryOperator::Or,
+            ast::Operator::BitXor => BinaryOperator::Xor,
+            ast::Operator::BitAnd => BinaryOperator::And,
         };
 
         let op = if inplace { bin_op.as_inplace() } else { bin_op };
@@ -6180,15 +6190,15 @@ impl Compiler {
     /// (indicated by the condition parameter).
     fn compile_jump_if(
         &mut self,
-        expression: &Expr,
+        expression: &ast::Expr,
         condition: bool,
         target_block: BlockIdx,
     ) -> CompileResult<()> {
         // Compile expression for test, and jump to label if false
         match &expression {
-            Expr::BoolOp(ExprBoolOp { op, values, .. }) => {
+            ast::Expr::BoolOp(ast::ExprBoolOp { op, values, .. }) => {
                 match op {
-                    BoolOp::And => {
+                    ast::BoolOp::And => {
                         if condition {
                             // If all values are true.
                             let end_block = self.new_block();
@@ -6209,7 +6219,7 @@ impl Compiler {
                             }
                         }
                     }
-                    BoolOp::Or => {
+                    ast::BoolOp::Or => {
                         if condition {
                             // If any of the values is true.
                             for value in values {
@@ -6232,8 +6242,8 @@ impl Compiler {
                     }
                 }
             }
-            Expr::UnaryOp(ExprUnaryOp {
-                op: UnaryOp::Not,
+            ast::Expr::UnaryOp(ast::ExprUnaryOp {
+                op: ast::UnaryOp::Not,
                 operand,
                 ..
             }) => {
@@ -6264,7 +6274,7 @@ impl Compiler {
 
     /// Compile a boolean operation as an expression.
     /// This means, that the last value remains on the stack.
-    fn compile_bool_op(&mut self, op: &BoolOp, values: &[Expr]) -> CompileResult<()> {
+    fn compile_bool_op(&mut self, op: &ast::BoolOp, values: &[ast::Expr]) -> CompileResult<()> {
         let after_block = self.new_block();
 
         let (last_value, values) = values.split_last().unwrap();
@@ -6274,7 +6284,7 @@ impl Compiler {
 
             emit!(self, Instruction::Copy { index: 1_u32 });
             match op {
-                BoolOp::And => {
+                ast::BoolOp::And => {
                     emit!(
                         self,
                         Instruction::PopJumpIfFalse {
@@ -6282,7 +6292,7 @@ impl Compiler {
                         }
                     );
                 }
-                BoolOp::Or => {
+                ast::BoolOp::Or => {
                     emit!(
                         self,
                         Instruction::PopJumpIfTrue {
@@ -6301,7 +6311,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_dict(&mut self, items: &[DictItem]) -> CompileResult<()> {
+    fn compile_dict(&mut self, items: &[ast::DictItem]) -> CompileResult<()> {
         // FIXME: correct order to build map, etc d = {**a, 'key': 2} should override
         // 'key' in dict a
         let mut size = 0;
@@ -6395,18 +6405,19 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_expression(&mut self, expression: &Expr) -> CompileResult<()> {
-        use ruff_python_ast::*;
+    fn compile_expression(&mut self, expression: &ast::Expr) -> CompileResult<()> {
         trace!("Compiling {expression:?}");
         let range = expression.range();
         self.set_source_range(range);
 
         match &expression {
-            Expr::Call(ExprCall {
+            ast::Expr::Call(ast::ExprCall {
                 func, arguments, ..
             }) => self.compile_call(func, arguments)?,
-            Expr::BoolOp(ExprBoolOp { op, values, .. }) => self.compile_bool_op(op, values)?,
-            Expr::BinOp(ExprBinOp {
+            ast::Expr::BoolOp(ast::ExprBoolOp { op, values, .. }) => {
+                self.compile_bool_op(op, values)?
+            }
+            ast::Expr::BinOp(ast::ExprBinOp {
                 left, op, right, ..
             }) => {
                 self.compile_expression(left)?;
@@ -6415,31 +6426,31 @@ impl Compiler {
                 // Perform operation:
                 self.compile_op(op, false);
             }
-            Expr::Subscript(ExprSubscript {
+            ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
             }) => {
                 self.compile_subscript(value, slice, *ctx)?;
             }
-            Expr::UnaryOp(ExprUnaryOp { op, operand, .. }) => {
+            ast::Expr::UnaryOp(ast::ExprUnaryOp { op, operand, .. }) => {
                 self.compile_expression(operand)?;
 
                 // Perform operation:
                 match op {
-                    UnaryOp::UAdd => emit!(
+                    ast::UnaryOp::UAdd => emit!(
                         self,
                         Instruction::CallIntrinsic1 {
                             func: bytecode::IntrinsicFunction1::UnaryPositive
                         }
                     ),
-                    UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
-                    UnaryOp::Not => {
+                    ast::UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
+                    ast::UnaryOp::Not => {
                         emit!(self, Instruction::ToBool);
                         emit!(self, Instruction::UnaryNot);
                     }
-                    UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
+                    ast::UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
                 };
             }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 // Check for super() attribute access optimization
                 if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
                     // super().attr or super(cls, self).attr optimization
@@ -6463,7 +6474,7 @@ impl Compiler {
                     emit!(self, Instruction::LoadAttr { idx });
                 }
             }
-            Expr::Compare(ExprCompare {
+            ast::Expr::Compare(ast::ExprCompare {
                 left,
                 ops,
                 comparators,
@@ -6471,25 +6482,25 @@ impl Compiler {
             }) => {
                 self.compile_compare(left, ops, comparators)?;
             }
-            // Expr::Constant(ExprConstant { value, .. }) => {
+            // ast::Expr::Constant(ExprConstant { value, .. }) => {
             //     self.emit_load_const(compile_constant(value));
             // }
-            Expr::List(ExprList { elts, .. }) => {
+            ast::Expr::List(ast::ExprList { elts, .. }) => {
                 self.starunpack_helper(elts, 0, CollectionType::List)?;
             }
-            Expr::Tuple(ExprTuple { elts, .. }) => {
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
                 self.starunpack_helper(elts, 0, CollectionType::Tuple)?;
             }
-            Expr::Set(ExprSet { elts, .. }) => {
+            ast::Expr::Set(ast::ExprSet { elts, .. }) => {
                 self.starunpack_helper(elts, 0, CollectionType::Set)?;
             }
-            Expr::Dict(ExprDict { items, .. }) => {
+            ast::Expr::Dict(ast::ExprDict { items, .. }) => {
                 self.compile_dict(items)?;
             }
-            Expr::Slice(ExprSlice {
+            ast::Expr::Slice(ast::ExprSlice {
                 lower, upper, step, ..
             }) => {
-                let mut compile_bound = |bound: Option<&Expr>| match bound {
+                let mut compile_bound = |bound: Option<&ast::Expr>| match bound {
                     Some(exp) => self.compile_expression(exp),
                     None => {
                         self.emit_load_const(ConstantData::None);
@@ -6507,7 +6518,7 @@ impl Compiler {
                 };
                 emit!(self, Instruction::BuildSlice { argc });
             }
-            Expr::Yield(ExprYield { value, .. }) => {
+            ast::Expr::Yield(ast::ExprYield { value, .. }) => {
                 if !self.ctx.in_func() {
                     return Err(self.error(CodegenErrorType::InvalidYield));
                 }
@@ -6525,7 +6536,7 @@ impl Compiler {
                     }
                 );
             }
-            Expr::Await(ExprAwait { value, .. }) => {
+            ast::Expr::Await(ast::ExprAwait { value, .. }) => {
                 if self.ctx.func != FunctionContext::AsyncFunction {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
@@ -6534,7 +6545,7 @@ impl Compiler {
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(true)?;
             }
-            Expr::YieldFrom(ExprYieldFrom { value, .. }) => {
+            ast::Expr::YieldFrom(ast::ExprYieldFrom { value, .. }) => {
                 match self.ctx.func {
                     FunctionContext::NoFunction => {
                         return Err(self.error(CodegenErrorType::InvalidYieldFrom));
@@ -6550,11 +6561,11 @@ impl Compiler {
                 self.emit_load_const(ConstantData::None);
                 self.compile_yield_from_sequence(false)?;
             }
-            Expr::Name(ExprName { id, .. }) => self.load_name(id.as_str())?,
-            Expr::Lambda(ExprLambda {
+            ast::Expr::Name(ast::ExprName { id, .. }) => self.load_name(id.as_str())?,
+            ast::Expr::Lambda(ast::ExprLambda {
                 parameters, body, ..
             }) => {
-                let default_params = Parameters::default();
+                let default_params = ast::Parameters::default();
                 let params = parameters.as_deref().unwrap_or(&default_params);
                 validate_duplicate_params(params).map_err(|e| self.error(e))?;
 
@@ -6633,7 +6644,7 @@ impl Compiler {
 
                 self.ctx = prev_ctx;
             }
-            Expr::ListComp(ExprListComp {
+            ast::Expr::ListComp(ast::ExprListComp {
                 elt, generators, ..
             }) => {
                 self.compile_comprehension(
@@ -6659,7 +6670,7 @@ impl Compiler {
                     Self::contains_await(elt) || Self::generators_contain_await(generators),
                 )?;
             }
-            Expr::SetComp(ExprSetComp {
+            ast::Expr::SetComp(ast::ExprSetComp {
                 elt, generators, ..
             }) => {
                 self.compile_comprehension(
@@ -6685,7 +6696,7 @@ impl Compiler {
                     Self::contains_await(elt) || Self::generators_contain_await(generators),
                 )?;
             }
-            Expr::DictComp(ExprDictComp {
+            ast::Expr::DictComp(ast::ExprDictComp {
                 key,
                 value,
                 generators,
@@ -6720,7 +6731,7 @@ impl Compiler {
                         || Self::generators_contain_await(generators),
                 )?;
             }
-            Expr::Generator(ExprGenerator {
+            ast::Expr::Generator(ast::ExprGenerator {
                 elt, generators, ..
             }) => {
                 // Check if element or generators contain async content
@@ -6754,7 +6765,7 @@ impl Compiler {
                     element_contains_await,
                 )?;
             }
-            Expr::Starred(ExprStarred { value, .. }) => {
+            ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
                 if self.in_annotation {
                     // In annotation context, starred expressions are allowed (PEP 646)
                     // For now, just compile the inner value without wrapping with Unpack
@@ -6764,7 +6775,7 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidStarExpr));
                 }
             }
-            Expr::If(ExprIf {
+            ast::Expr::If(ast::ExprIf {
                 test, body, orelse, ..
             }) => {
                 let else_block = self.new_block();
@@ -6788,7 +6799,7 @@ impl Compiler {
                 self.switch_to_block(after_block);
             }
 
-            Expr::Named(ExprNamed {
+            ast::Expr::Named(ast::ExprNamed {
                 target,
                 value,
                 node_index: _,
@@ -6798,13 +6809,13 @@ impl Compiler {
                 emit!(self, Instruction::Copy { index: 1_u32 });
                 self.compile_store(target)?;
             }
-            Expr::FString(fstring) => {
+            ast::Expr::FString(fstring) => {
                 self.compile_expr_fstring(fstring)?;
             }
-            Expr::TString(tstring) => {
+            ast::Expr::TString(tstring) => {
                 self.compile_expr_tstring(tstring)?;
             }
-            Expr::StringLiteral(string) => {
+            ast::Expr::StringLiteral(string) => {
                 let value = string.value.to_str();
                 if value.contains(char::REPLACEMENT_CHARACTER) {
                     let value = string
@@ -6823,42 +6834,42 @@ impl Compiler {
                     });
                 }
             }
-            Expr::BytesLiteral(bytes) => {
+            ast::Expr::BytesLiteral(bytes) => {
                 let iter = bytes.value.iter().flat_map(|x| x.iter().copied());
                 let v: Vec<u8> = iter.collect();
                 self.emit_load_const(ConstantData::Bytes { value: v });
             }
-            Expr::NumberLiteral(number) => match &number.value {
-                Number::Int(int) => {
+            ast::Expr::NumberLiteral(number) => match &number.value {
+                ast::Number::Int(int) => {
                     let value = ruff_int_to_bigint(int).map_err(|e| self.error(e))?;
                     self.emit_load_const(ConstantData::Integer { value });
                 }
-                Number::Float(float) => {
+                ast::Number::Float(float) => {
                     self.emit_load_const(ConstantData::Float { value: *float });
                 }
-                Number::Complex { real, imag } => {
+                ast::Number::Complex { real, imag } => {
                     self.emit_load_const(ConstantData::Complex {
                         value: Complex::new(*real, *imag),
                     });
                 }
             },
-            Expr::BooleanLiteral(b) => {
+            ast::Expr::BooleanLiteral(b) => {
                 self.emit_load_const(ConstantData::Boolean { value: b.value });
             }
-            Expr::NoneLiteral(_) => {
+            ast::Expr::NoneLiteral(_) => {
                 self.emit_load_const(ConstantData::None);
             }
-            Expr::EllipsisLiteral(_) => {
+            ast::Expr::EllipsisLiteral(_) => {
                 self.emit_load_const(ConstantData::Ellipsis);
             }
-            Expr::IpyEscapeCommand(_) => {
+            ast::Expr::IpyEscapeCommand(_) => {
                 panic!("unexpected ipy escape command");
             }
         }
         Ok(())
     }
 
-    fn compile_keywords(&mut self, keywords: &[Keyword]) -> CompileResult<()> {
+    fn compile_keywords(&mut self, keywords: &[ast::Keyword]) -> CompileResult<()> {
         let mut size = 0;
         let groupby = keywords.iter().chunk_by(|e| e.arg.is_none());
         for (is_unpacking, sub_keywords) in &groupby {
@@ -6888,10 +6899,10 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_call(&mut self, func: &Expr, args: &Arguments) -> CompileResult<()> {
+    fn compile_call(&mut self, func: &ast::Expr, args: &ast::Arguments) -> CompileResult<()> {
         // Method call: obj → LOAD_ATTR_METHOD → [method, self_or_null] → args → CALL
         // Regular call: func → PUSH_NULL → args → CALL
-        if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
+        if let ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) = &func {
             // Check for super() method call optimization
             if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
                 // super().method() or super(cls, self).method() optimization
@@ -6930,7 +6941,7 @@ impl Compiler {
     fn compile_call_helper(
         &mut self,
         additional_positional: u32,
-        arguments: &Arguments,
+        arguments: &ast::Arguments,
     ) -> CompileResult<()> {
         let args_count = u32::try_from(arguments.len()).expect("too many arguments");
         let count = args_count
@@ -6992,9 +7003,13 @@ impl Compiler {
 
     // Given a vector of expr / star expr generate code which gives either
     // a list of expressions on the stack, or a list of tuples.
-    fn gather_elements(&mut self, before: u32, elements: &[Expr]) -> CompileResult<(u32, bool)> {
+    fn gather_elements(
+        &mut self,
+        before: u32,
+        elements: &[ast::Expr],
+    ) -> CompileResult<(u32, bool)> {
         // First determine if we have starred elements:
-        let has_stars = elements.iter().any(|e| matches!(e, Expr::Starred(_)));
+        let has_stars = elements.iter().any(|e| matches!(e, ast::Expr::Starred(_)));
 
         let size = if has_stars {
             let mut size = 0;
@@ -7002,14 +7017,17 @@ impl Compiler {
             let mut run_size = before;
 
             loop {
-                if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
+                if iter
+                    .peek()
+                    .is_none_or(|e| matches!(e, ast::Expr::Starred(_)))
+                {
                     emit!(self, Instruction::BuildTuple { size: run_size });
                     run_size = 0;
                     size += 1;
                 }
 
                 match iter.next() {
-                    Some(Expr::Starred(ExprStarred { value, .. })) => {
+                    Some(ast::Expr::Starred(ast::ExprStarred { value, .. })) => {
                         self.compile_expression(value)?;
                         // We need to collect each unpacked element into a
                         // tuple, since any side-effects during the conversion
@@ -7037,7 +7055,7 @@ impl Compiler {
         Ok((size, has_stars))
     }
 
-    fn compile_comprehension_element(&mut self, element: &Expr) -> CompileResult<()> {
+    fn compile_comprehension_element(&mut self, element: &ast::Expr) -> CompileResult<()> {
         self.compile_expression(element).map_err(|e| {
             if let CodegenErrorType::InvalidStarExpr = e.error {
                 self.error(CodegenErrorType::SyntaxError(
@@ -7053,7 +7071,7 @@ impl Compiler {
         &mut self,
         name: &str,
         init_collection: Option<AnyInstruction>,
-        generators: &[Comprehension],
+        generators: &[ast::Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         comprehension_type: ComprehensionType,
         element_contains_await: bool,
@@ -7244,25 +7262,25 @@ impl Compiler {
     }
 
     /// Collect variable names from an assignment target expression
-    fn collect_target_names(&self, target: &Expr, names: &mut Vec<String>) {
+    fn collect_target_names(&self, target: &ast::Expr, names: &mut Vec<String>) {
         match target {
-            Expr::Name(name) => {
+            ast::Expr::Name(name) => {
                 let name_str = name.id.to_string();
                 if !names.contains(&name_str) {
                     names.push(name_str);
                 }
             }
-            Expr::Tuple(tuple) => {
+            ast::Expr::Tuple(tuple) => {
                 for elt in &tuple.elts {
                     self.collect_target_names(elt, names);
                 }
             }
-            Expr::List(list) => {
+            ast::Expr::List(list) => {
                 for elt in &list.elts {
                     self.collect_target_names(elt, names);
                 }
             }
-            Expr::Starred(starred) => {
+            ast::Expr::Starred(starred) => {
                 self.collect_target_names(&starred.value, names);
             }
             _ => {
@@ -7276,7 +7294,7 @@ impl Compiler {
     fn compile_inlined_comprehension(
         &mut self,
         init_collection: Option<AnyInstruction>,
-        generators: &[Comprehension],
+        generators: &[ast::Comprehension],
         compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
         _has_an_async_gen: bool,
     ) -> CompileResult<()> {
@@ -7461,7 +7479,7 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_future_features(&mut self, features: &[Alias]) -> Result<(), CodegenError> {
+    fn compile_future_features(&mut self, features: &[ast::Alias]) -> Result<(), CodegenError> {
         if let DoneWithFuture::Yes = self.done_with_future_stmts {
             return Err(self.error(CodegenErrorType::InvalidFuturePlacement));
         }
@@ -7809,26 +7827,28 @@ impl Compiler {
     /// async for: ...
     /// ```
     /// are statements, so we won't check for them here
-    fn contains_await(expression: &Expr) -> bool {
+    fn contains_await(expression: &ast::Expr) -> bool {
+        use ast::visitor::Visitor;
+
         #[derive(Default)]
         struct AwaitVisitor {
             found: bool,
         }
 
-        impl Visitor<'_> for AwaitVisitor {
-            fn visit_expr(&mut self, expr: &Expr) {
+        impl ast::visitor::Visitor<'_> for AwaitVisitor {
+            fn visit_expr(&mut self, expr: &ast::Expr) {
                 if self.found {
                     return;
                 }
 
                 match expr {
-                    Expr::Await(_) => self.found = true,
+                    ast::Expr::Await(_) => self.found = true,
                     // Note: We do NOT check for async comprehensions here.
                     // Async list/set/dict comprehensions are handled by compile_comprehension
                     // which already awaits the result. A generator expression containing
                     // an async comprehension as its element does NOT become an async generator,
                     // because the async comprehension is awaited when evaluating the element.
-                    _ => walk_expr(self, expr),
+                    _ => ast::visitor::walk_expr(self, expr),
                 }
             }
         }
@@ -7840,7 +7860,7 @@ impl Compiler {
 
     /// Check if any of the generators (except the first one's iter) contains an await expression.
     /// The first generator's iter is evaluated outside the comprehension scope.
-    fn generators_contain_await(generators: &[Comprehension]) -> bool {
+    fn generators_contain_await(generators: &[ast::Comprehension]) -> bool {
         for (i, generator) in generators.iter().enumerate() {
             // First generator's iter is evaluated outside the comprehension
             if i > 0 && Self::contains_await(&generator.iter) {
@@ -7856,7 +7876,7 @@ impl Compiler {
         false
     }
 
-    fn compile_expr_fstring(&mut self, fstring: &ExprFString) -> CompileResult<()> {
+    fn compile_expr_fstring(&mut self, fstring: &ast::ExprFString) -> CompileResult<()> {
         let fstring = &fstring.value;
         for part in fstring {
             self.compile_fstring_part(part)?;
@@ -7873,9 +7893,9 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_fstring_part(&mut self, part: &FStringPart) -> CompileResult<()> {
+    fn compile_fstring_part(&mut self, part: &ast::FStringPart) -> CompileResult<()> {
         match part {
-            FStringPart::Literal(string) => {
+            ast::FStringPart::Literal(string) => {
                 if string.value.contains(char::REPLACEMENT_CHARACTER) {
                     // might have a surrogate literal; should reparse to be sure
                     let source = self.source_file.slice(string.range);
@@ -7891,24 +7911,24 @@ impl Compiler {
                 }
                 Ok(())
             }
-            FStringPart::FString(fstring) => self.compile_fstring(fstring),
+            ast::FStringPart::FString(fstring) => self.compile_fstring(fstring),
         }
     }
 
-    fn compile_fstring(&mut self, fstring: &FString) -> CompileResult<()> {
+    fn compile_fstring(&mut self, fstring: &ast::FString) -> CompileResult<()> {
         self.compile_fstring_elements(fstring.flags, &fstring.elements)
     }
 
     fn compile_fstring_elements(
         &mut self,
-        flags: FStringFlags,
-        fstring_elements: &InterpolatedStringElements,
+        flags: ast::FStringFlags,
+        fstring_elements: &ast::InterpolatedStringElements,
     ) -> CompileResult<()> {
         let mut element_count = 0;
         for element in fstring_elements {
             element_count += 1;
             match element {
-                InterpolatedStringElement::Literal(string) => {
+                ast::InterpolatedStringElement::Literal(string) => {
                     if string.value.contains(char::REPLACEMENT_CHARACTER) {
                         // might have a surrogate literal; should reparse to be sure
                         let source = self.source_file.slice(string.range);
@@ -7925,15 +7945,15 @@ impl Compiler {
                         });
                     }
                 }
-                InterpolatedStringElement::Interpolation(fstring_expr) => {
+                ast::InterpolatedStringElement::Interpolation(fstring_expr) => {
                     let mut conversion = match fstring_expr.conversion {
-                        ConversionFlag::None => ConvertValueOparg::None,
-                        ConversionFlag::Str => ConvertValueOparg::Str,
-                        ConversionFlag::Repr => ConvertValueOparg::Repr,
-                        ConversionFlag::Ascii => ConvertValueOparg::Ascii,
+                        ast::ConversionFlag::None => ConvertValueOparg::None,
+                        ast::ConversionFlag::Str => ConvertValueOparg::Str,
+                        ast::ConversionFlag::Repr => ConvertValueOparg::Repr,
+                        ast::ConversionFlag::Ascii => ConvertValueOparg::Ascii,
                     };
 
-                    if let Some(DebugText { leading, trailing }) = &fstring_expr.debug_text {
+                    if let Some(ast::DebugText { leading, trailing }) = &fstring_expr.debug_text {
                         let range = fstring_expr.expression.range();
                         let source = self.source_file.slice(range);
                         let text = [leading, source, trailing].concat();
@@ -7993,9 +8013,9 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_expr_tstring(&mut self, expr_tstring: &ExprTString) -> CompileResult<()> {
-        // TStringValue can contain multiple TString parts (implicit concatenation)
-        // Each TString part should be compiled and the results merged into a single Template
+    fn compile_expr_tstring(&mut self, expr_tstring: &ast::ExprTString) -> CompileResult<()> {
+        // ast::TStringValue can contain multiple ast::TString parts (implicit concatenation)
+        // Each ast::TString part should be compiled and the results merged into a single Template
         let tstring_value = &expr_tstring.value;
 
         // Collect all strings and compile all interpolations
@@ -8044,18 +8064,18 @@ impl Compiler {
 
     fn compile_tstring_into(
         &mut self,
-        tstring: &TString,
+        tstring: &ast::TString,
         strings: &mut Vec<Wtf8Buf>,
         current_string: &mut Wtf8Buf,
         interp_count: &mut u32,
     ) -> CompileResult<()> {
         for element in &tstring.elements {
             match element {
-                InterpolatedStringElement::Literal(lit) => {
+                ast::InterpolatedStringElement::Literal(lit) => {
                     // Accumulate literal parts into current_string
                     current_string.push_str(&lit.value);
                 }
-                InterpolatedStringElement::Interpolation(interp) => {
+                ast::InterpolatedStringElement::Interpolation(interp) => {
                     // Finish current string segment
                     strings.push(std::mem::take(current_string));
 
@@ -8071,19 +8091,19 @@ impl Compiler {
 
                     // Determine conversion code
                     let conversion: u32 = match interp.conversion {
-                        ConversionFlag::None => 0,
-                        ConversionFlag::Str => 1,
-                        ConversionFlag::Repr => 2,
-                        ConversionFlag::Ascii => 3,
+                        ast::ConversionFlag::None => 0,
+                        ast::ConversionFlag::Str => 1,
+                        ast::ConversionFlag::Repr => 2,
+                        ast::ConversionFlag::Ascii => 3,
                     };
 
                     // Handle format_spec
                     let has_format_spec = interp.format_spec.is_some();
                     if let Some(format_spec) = &interp.format_spec {
                         // Compile format_spec as a string using fstring element compilation
-                        // Use default FStringFlags since format_spec syntax is independent of t-string flags
+                        // Use default ast::FStringFlags since format_spec syntax is independent of t-string flags
                         self.compile_fstring_elements(
-                            FStringFlags::empty(),
+                            ast::FStringFlags::empty(),
                             &format_spec.elements,
                         )?;
                     }
@@ -8193,12 +8213,12 @@ fn expandtabs(input: &str, tab_size: usize) -> String {
     expanded_str
 }
 
-fn split_doc<'a>(body: &'a [Stmt], opts: &CompileOpts) -> (Option<String>, &'a [Stmt]) {
-    if let Some((Stmt::Expr(expr), body_rest)) = body.split_first() {
+fn split_doc<'a>(body: &'a [ast::Stmt], opts: &CompileOpts) -> (Option<String>, &'a [ast::Stmt]) {
+    if let Some((ast::Stmt::Expr(expr), body_rest)) = body.split_first() {
         let doc_comment = match &*expr.value {
-            Expr::StringLiteral(value) => Some(&value.value),
+            ast::Expr::StringLiteral(value) => Some(&value.value),
             // f-strings are not allowed in Python doc comments.
-            Expr::FString(_) => None,
+            ast::Expr::FString(_) => None,
             _ => None,
         };
         if let Some(doc) = doc_comment {
@@ -8212,7 +8232,7 @@ fn split_doc<'a>(body: &'a [Stmt], opts: &CompileOpts) -> (Option<String>, &'a [
     (None, body)
 }
 
-pub fn ruff_int_to_bigint(int: &Int) -> Result<BigInt, CodegenErrorType> {
+pub fn ruff_int_to_bigint(int: &ast::Int) -> Result<BigInt, CodegenErrorType> {
     if let Some(small) = int.as_u64() {
         Ok(BigInt::from(small))
     } else {
@@ -8222,7 +8242,7 @@ pub fn ruff_int_to_bigint(int: &Int) -> Result<BigInt, CodegenErrorType> {
 
 /// Converts a `ruff` ast integer into a `BigInt`.
 /// Unlike small integers, big integers may be stored in one of four possible radix representations.
-fn parse_big_integer(int: &Int) -> Result<BigInt, CodegenErrorType> {
+fn parse_big_integer(int: &ast::Int) -> Result<BigInt, CodegenErrorType> {
     // TODO: Improve ruff API
     // Can we avoid this copy?
     let s = format!("{int}");
@@ -8265,35 +8285,34 @@ impl ToU32 for usize {
 #[cfg(test)]
 mod ruff_tests {
     use super::*;
-    use ruff_python_ast::name::Name;
-    use ruff_python_ast::*;
+    use ast::name::Name;
 
     /// Test if the compiler can correctly identify fstrings containing an `await` expression.
     #[test]
     fn test_fstring_contains_await() {
         let range = TextRange::default();
-        let flags = FStringFlags::empty();
+        let flags = ast::FStringFlags::empty();
 
         // f'{x}'
-        let expr_x = Expr::Name(ExprName {
-            node_index: AtomicNodeIndex::NONE,
+        let expr_x = ast::Expr::Name(ast::ExprName {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
             id: Name::new("x"),
-            ctx: ExprContext::Load,
+            ctx: ast::ExprContext::Load,
         });
-        let not_present = &Expr::FString(ExprFString {
-            node_index: AtomicNodeIndex::NONE,
+        let not_present = &ast::Expr::FString(ast::ExprFString {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
-            value: FStringValue::single(FString {
-                node_index: AtomicNodeIndex::NONE,
+            value: ast::FStringValue::single(ast::FString {
+                node_index: ast::AtomicNodeIndex::NONE,
                 range,
-                elements: vec![InterpolatedStringElement::Interpolation(
-                    InterpolatedElement {
-                        node_index: AtomicNodeIndex::NONE,
+                elements: vec![ast::InterpolatedStringElement::Interpolation(
+                    ast::InterpolatedElement {
+                        node_index: ast::AtomicNodeIndex::NONE,
                         range,
                         expression: Box::new(expr_x),
                         debug_text: None,
-                        conversion: ConversionFlag::None,
+                        conversion: ast::ConversionFlag::None,
                         format_spec: None,
                     },
                 )]
@@ -8304,29 +8323,29 @@ mod ruff_tests {
         assert!(!Compiler::contains_await(not_present));
 
         // f'{await x}'
-        let expr_await_x = Expr::Await(ExprAwait {
-            node_index: AtomicNodeIndex::NONE,
+        let expr_await_x = ast::Expr::Await(ast::ExprAwait {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
-            value: Box::new(Expr::Name(ExprName {
-                node_index: AtomicNodeIndex::NONE,
+            value: Box::new(ast::Expr::Name(ast::ExprName {
+                node_index: ast::AtomicNodeIndex::NONE,
                 range,
                 id: Name::new("x"),
-                ctx: ExprContext::Load,
+                ctx: ast::ExprContext::Load,
             })),
         });
-        let present = &Expr::FString(ExprFString {
-            node_index: AtomicNodeIndex::NONE,
+        let present = &ast::Expr::FString(ast::ExprFString {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
-            value: FStringValue::single(FString {
-                node_index: AtomicNodeIndex::NONE,
+            value: ast::FStringValue::single(ast::FString {
+                node_index: ast::AtomicNodeIndex::NONE,
                 range,
-                elements: vec![InterpolatedStringElement::Interpolation(
-                    InterpolatedElement {
-                        node_index: AtomicNodeIndex::NONE,
+                elements: vec![ast::InterpolatedStringElement::Interpolation(
+                    ast::InterpolatedElement {
+                        node_index: ast::AtomicNodeIndex::NONE,
                         range,
                         expression: Box::new(expr_await_x),
                         debug_text: None,
-                        conversion: ConversionFlag::None,
+                        conversion: ast::ConversionFlag::None,
                         format_spec: None,
                     },
                 )]
@@ -8337,45 +8356,45 @@ mod ruff_tests {
         assert!(Compiler::contains_await(present));
 
         // f'{x:{await y}}'
-        let expr_x = Expr::Name(ExprName {
-            node_index: AtomicNodeIndex::NONE,
+        let expr_x = ast::Expr::Name(ast::ExprName {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
             id: Name::new("x"),
-            ctx: ExprContext::Load,
+            ctx: ast::ExprContext::Load,
         });
-        let expr_await_y = Expr::Await(ExprAwait {
-            node_index: AtomicNodeIndex::NONE,
+        let expr_await_y = ast::Expr::Await(ast::ExprAwait {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
-            value: Box::new(Expr::Name(ExprName {
-                node_index: AtomicNodeIndex::NONE,
+            value: Box::new(ast::Expr::Name(ast::ExprName {
+                node_index: ast::AtomicNodeIndex::NONE,
                 range,
                 id: Name::new("y"),
-                ctx: ExprContext::Load,
+                ctx: ast::ExprContext::Load,
             })),
         });
-        let present = &Expr::FString(ExprFString {
-            node_index: AtomicNodeIndex::NONE,
+        let present = &ast::Expr::FString(ast::ExprFString {
+            node_index: ast::AtomicNodeIndex::NONE,
             range,
-            value: FStringValue::single(FString {
-                node_index: AtomicNodeIndex::NONE,
+            value: ast::FStringValue::single(ast::FString {
+                node_index: ast::AtomicNodeIndex::NONE,
                 range,
-                elements: vec![InterpolatedStringElement::Interpolation(
-                    InterpolatedElement {
-                        node_index: AtomicNodeIndex::NONE,
+                elements: vec![ast::InterpolatedStringElement::Interpolation(
+                    ast::InterpolatedElement {
+                        node_index: ast::AtomicNodeIndex::NONE,
                         range,
                         expression: Box::new(expr_x),
                         debug_text: None,
-                        conversion: ConversionFlag::None,
-                        format_spec: Some(Box::new(InterpolatedStringFormatSpec {
-                            node_index: AtomicNodeIndex::NONE,
+                        conversion: ast::ConversionFlag::None,
+                        format_spec: Some(Box::new(ast::InterpolatedStringFormatSpec {
+                            node_index: ast::AtomicNodeIndex::NONE,
                             range,
-                            elements: vec![InterpolatedStringElement::Interpolation(
-                                InterpolatedElement {
-                                    node_index: AtomicNodeIndex::NONE,
+                            elements: vec![ast::InterpolatedStringElement::Interpolation(
+                                ast::InterpolatedElement {
+                                    node_index: ast::AtomicNodeIndex::NONE,
                                     range,
                                     expression: Box::new(expr_await_y),
                                     debug_text: None,
-                                    conversion: ConversionFlag::None,
+                                    conversion: ast::ConversionFlag::None,
                                     format_spec: None,
                                 },
                             )]
diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs
index 34d3870ae91..9dd7384170a 100644
--- a/crates/codegen/src/lib.rs
+++ b/crates/codegen/src/lib.rs
@@ -18,7 +18,7 @@ pub mod symboltable;
 mod unparse;
 
 pub use compile::CompileOpts;
-use ruff_python_ast::Expr;
+use ruff_python_ast as ast;
 
 pub(crate) use compile::InternalResult;
 
@@ -27,7 +27,7 @@ pub trait ToPythonName {
     fn python_name(&self) -> &'static str;
 }
 
-impl ToPythonName for Expr {
+impl ToPythonName for ast::Expr {
     fn python_name(&self) -> &'static str {
         match self {
             Self::BoolOp { .. } | Self::BinOp { .. } | Self::UnaryOp { .. } => "operator",
diff --git a/crates/codegen/src/string_parser.rs b/crates/codegen/src/string_parser.rs
index 175e75c1a26..7e1558d2b17 100644
--- a/crates/codegen/src/string_parser.rs
+++ b/crates/codegen/src/string_parser.rs
@@ -7,7 +7,7 @@
 
 use core::convert::Infallible;
 
-use ruff_python_ast::{AnyStringFlags, StringFlags};
+use ruff_python_ast::{self as ast, StringFlags as _};
 use rustpython_wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
 // use ruff_python_parser::{LexicalError, LexicalErrorType};
@@ -24,11 +24,11 @@ struct StringParser {
     /// Current position of the parser in the source.
     cursor: usize,
     /// Flags that can be used to query information about the string.
-    flags: AnyStringFlags,
+    flags: ast::AnyStringFlags,
 }
 
 impl StringParser {
-    const fn new(source: Box<str>, flags: AnyStringFlags) -> Self {
+    const fn new(source: Box<str>, flags: ast::AnyStringFlags) -> Self {
         Self {
             source,
             cursor: 0,
@@ -272,7 +272,7 @@ impl StringParser {
     }
 }
 
-pub(crate) fn parse_string_literal(source: &str, flags: AnyStringFlags) -> Box<Wtf8> {
+pub(crate) fn parse_string_literal(source: &str, flags: ast::AnyStringFlags) -> Box<Wtf8> {
     let source = &source[flags.opener_len().to_usize()..];
     let source = &source[..source.len() - flags.quote_len().to_usize()];
     StringParser::new(source.into(), flags)
@@ -280,7 +280,10 @@ pub(crate) fn parse_string_literal(source: &str, flags: AnyStringFlags) -> Box<W
         .unwrap_or_else(|x| match x {})
 }
 
-pub(crate) fn parse_fstring_literal_element(source: Box<str>, flags: AnyStringFlags) -> Box<Wtf8> {
+pub(crate) fn parse_fstring_literal_element(
+    source: Box<str>,
+    flags: ast::AnyStringFlags,
+) -> Box<Wtf8> {
     StringParser::new(source, flags)
         .parse_fstring_middle()
         .unwrap_or_else(|x| match x {})
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
index 63b330db92f..129900133fa 100644
--- a/crates/codegen/src/symboltable.rs
+++ b/crates/codegen/src/symboltable.rs
@@ -13,12 +13,7 @@ use crate::{
 };
 use alloc::{borrow::Cow, fmt};
 use bitflags::bitflags;
-use ruff_python_ast::{
-    self as ast, Comprehension, Decorator, Expr, Identifier, ModExpression, ModModule, Parameter,
-    ParameterWithDefault, Parameters, Pattern, PatternMatchAs, PatternMatchClass,
-    PatternMatchMapping, PatternMatchOr, PatternMatchSequence, PatternMatchStar, PatternMatchValue,
-    Stmt, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams,
-};
+use ruff_python_ast as ast;
 use ruff_text_size::{Ranged, TextRange};
 use rustpython_compiler_core::{PositionEncoding, SourceFile, SourceLocation};
 use std::collections::HashSet;
@@ -97,13 +92,19 @@ impl SymbolTable {
         }
     }
 
-    pub fn scan_program(program: &ModModule, source_file: SourceFile) -> SymbolTableResult<Self> {
+    pub fn scan_program(
+        program: &ast::ModModule,
+        source_file: SourceFile,
+    ) -> SymbolTableResult<Self> {
         let mut builder = SymbolTableBuilder::new(source_file);
         builder.scan_statements(program.body.as_ref())?;
         builder.finish()
     }
 
-    pub fn scan_expr(expr: &ModExpression, source_file: SourceFile) -> SymbolTableResult<Self> {
+    pub fn scan_expr(
+        expr: &ast::ModExpression,
+        source_file: SourceFile,
+    ) -> SymbolTableResult<Self> {
         let mut builder = SymbolTableBuilder::new(source_file);
         builder.scan_expression(expr.body.as_ref(), ExpressionContext::Load)?;
         builder.finish()
@@ -973,21 +974,21 @@ impl SymbolTableBuilder {
             .get() as _
     }
 
-    fn scan_statements(&mut self, statements: &[Stmt]) -> SymbolTableResult {
+    fn scan_statements(&mut self, statements: &[ast::Stmt]) -> SymbolTableResult {
         for statement in statements {
             self.scan_statement(statement)?;
         }
         Ok(())
     }
 
-    fn scan_parameters(&mut self, parameters: &[ParameterWithDefault]) -> SymbolTableResult {
+    fn scan_parameters(&mut self, parameters: &[ast::ParameterWithDefault]) -> SymbolTableResult {
         for parameter in parameters {
             self.scan_parameter(&parameter.parameter)?;
         }
         Ok(())
     }
 
-    fn scan_parameter(&mut self, parameter: &Parameter) -> SymbolTableResult {
+    fn scan_parameter(&mut self, parameter: &ast::Parameter) -> SymbolTableResult {
         self.check_name(
             parameter.name.as_str(),
             ExpressionContext::Store,
@@ -1019,7 +1020,7 @@ impl SymbolTableBuilder {
         self.register_ident(&parameter.name, usage)
     }
 
-    fn scan_annotation(&mut self, annotation: &Expr) -> SymbolTableResult {
+    fn scan_annotation(&mut self, annotation: &ast::Expr) -> SymbolTableResult {
         let current_scope = self.tables.last().map(|t| t.typ);
 
         // PEP 649: Check if this is a conditional annotation
@@ -1074,8 +1075,8 @@ impl SymbolTableBuilder {
         result
     }
 
-    fn scan_statement(&mut self, statement: &Stmt) -> SymbolTableResult {
-        use ruff_python_ast::*;
+    fn scan_statement(&mut self, statement: &ast::Stmt) -> SymbolTableResult {
+        use ast::*;
         if let Stmt::ImportFrom(StmtImportFrom { module, names, .. }) = &statement
             && module.as_ref().map(|id| id.as_str()) == Some("__future__")
         {
@@ -1435,7 +1436,7 @@ impl SymbolTableBuilder {
 
     fn scan_decorators(
         &mut self,
-        decorators: &[Decorator],
+        decorators: &[ast::Decorator],
         context: ExpressionContext,
     ) -> SymbolTableResult {
         for decorator in decorators {
@@ -1446,7 +1447,7 @@ impl SymbolTableBuilder {
 
     fn scan_expressions(
         &mut self,
-        expressions: &[Expr],
+        expressions: &[ast::Expr],
         context: ExpressionContext,
     ) -> SymbolTableResult {
         for expression in expressions {
@@ -1457,10 +1458,10 @@ impl SymbolTableBuilder {
 
     fn scan_expression(
         &mut self,
-        expression: &Expr,
+        expression: &ast::Expr,
         context: ExpressionContext,
     ) -> SymbolTableResult {
-        use ruff_python_ast::*;
+        use ast::*;
 
         // Check for expressions not allowed in certain contexts
         // (type parameters, annotations, type aliases, TypeVar bounds/defaults)
@@ -1837,9 +1838,9 @@ impl SymbolTableBuilder {
     fn scan_comprehension(
         &mut self,
         scope_name: &str,
-        elt1: &Expr,
-        elt2: Option<&Expr>,
-        generators: &[Comprehension],
+        elt1: &ast::Expr,
+        elt2: Option<&ast::Expr>,
+        generators: &[ast::Comprehension],
         range: TextRange,
         is_generator: bool,
     ) -> SymbolTableResult {
@@ -1906,7 +1907,7 @@ impl SymbolTableBuilder {
     // = symtable_visit_type_param_bound_or_default
     fn scan_type_param_bound_or_default(
         &mut self,
-        expr: &Expr,
+        expr: &ast::Expr,
         scope_name: &str,
         scope_info: &'static str,
     ) -> SymbolTableResult {
@@ -1932,14 +1933,14 @@ impl SymbolTableBuilder {
         result
     }
 
-    fn scan_type_params(&mut self, type_params: &TypeParams) -> SymbolTableResult {
+    fn scan_type_params(&mut self, type_params: &ast::TypeParams) -> SymbolTableResult {
         // Check for duplicate type parameter names
         let mut seen_names: std::collections::HashSet<&str> = std::collections::HashSet::new();
         for type_param in &type_params.type_params {
             let (name, range) = match type_param {
-                TypeParam::TypeVar(tv) => (tv.name.as_str(), tv.range),
-                TypeParam::ParamSpec(ps) => (ps.name.as_str(), ps.range),
-                TypeParam::TypeVarTuple(tvt) => (tvt.name.as_str(), tvt.range),
+                ast::TypeParam::TypeVar(tv) => (tv.name.as_str(), tv.range),
+                ast::TypeParam::ParamSpec(ps) => (ps.name.as_str(), ps.range),
+                ast::TypeParam::TypeVarTuple(tvt) => (tvt.name.as_str(), tvt.range),
             };
             if !seen_names.insert(name) {
                 return Err(SymbolTableError {
@@ -1959,7 +1960,7 @@ impl SymbolTableBuilder {
         // First register all type parameters
         for type_param in &type_params.type_params {
             match type_param {
-                TypeParam::TypeVar(TypeParamTypeVar {
+                ast::TypeParam::TypeVar(ast::TypeParamTypeVar {
                     name,
                     bound,
                     range: type_var_range,
@@ -1991,7 +1992,7 @@ impl SymbolTableBuilder {
                         )?;
                     }
                 }
-                TypeParam::ParamSpec(TypeParamParamSpec {
+                ast::TypeParam::ParamSpec(ast::TypeParamParamSpec {
                     name,
                     range: param_spec_range,
                     default,
@@ -2009,7 +2010,7 @@ impl SymbolTableBuilder {
                         )?;
                     }
                 }
-                TypeParam::TypeVarTuple(TypeParamTypeVarTuple {
+                ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
                     name,
                     range: type_var_tuple_range,
                     default,
@@ -2032,22 +2033,24 @@ impl SymbolTableBuilder {
         Ok(())
     }
 
-    fn scan_patterns(&mut self, patterns: &[Pattern]) -> SymbolTableResult {
+    fn scan_patterns(&mut self, patterns: &[ast::Pattern]) -> SymbolTableResult {
         for pattern in patterns {
             self.scan_pattern(pattern)?;
         }
         Ok(())
     }
 
-    fn scan_pattern(&mut self, pattern: &Pattern) -> SymbolTableResult {
-        use Pattern::*;
+    fn scan_pattern(&mut self, pattern: &ast::Pattern) -> SymbolTableResult {
+        use ast::Pattern::*;
         match pattern {
-            MatchValue(PatternMatchValue { value, .. }) => {
+            MatchValue(ast::PatternMatchValue { value, .. }) => {
                 self.scan_expression(value, ExpressionContext::Load)?
             }
             MatchSingleton(_) => {}
-            MatchSequence(PatternMatchSequence { patterns, .. }) => self.scan_patterns(patterns)?,
-            MatchMapping(PatternMatchMapping {
+            MatchSequence(ast::PatternMatchSequence { patterns, .. }) => {
+                self.scan_patterns(patterns)?
+            }
+            MatchMapping(ast::PatternMatchMapping {
                 keys,
                 patterns,
                 rest,
@@ -2059,19 +2062,19 @@ impl SymbolTableBuilder {
                     self.register_ident(rest, SymbolUsage::Assigned)?;
                 }
             }
-            MatchClass(PatternMatchClass { cls, arguments, .. }) => {
+            MatchClass(ast::PatternMatchClass { cls, arguments, .. }) => {
                 self.scan_expression(cls, ExpressionContext::Load)?;
                 self.scan_patterns(&arguments.patterns)?;
                 for kw in &arguments.keywords {
                     self.scan_pattern(&kw.pattern)?;
                 }
             }
-            MatchStar(PatternMatchStar { name, .. }) => {
+            MatchStar(ast::PatternMatchStar { name, .. }) => {
                 if let Some(name) = name {
                     self.register_ident(name, SymbolUsage::Assigned)?;
                 }
             }
-            MatchAs(PatternMatchAs { pattern, name, .. }) => {
+            MatchAs(ast::PatternMatchAs { pattern, name, .. }) => {
                 if let Some(pattern) = pattern {
                     self.scan_pattern(pattern)?;
                 }
@@ -2079,7 +2082,7 @@ impl SymbolTableBuilder {
                     self.register_ident(name, SymbolUsage::Assigned)?;
                 }
             }
-            MatchOr(PatternMatchOr { patterns, .. }) => self.scan_patterns(patterns)?,
+            MatchOr(ast::PatternMatchOr { patterns, .. }) => self.scan_patterns(patterns)?,
         }
         Ok(())
     }
@@ -2087,7 +2090,7 @@ impl SymbolTableBuilder {
     fn enter_scope_with_parameters(
         &mut self,
         name: &str,
-        parameters: &Parameters,
+        parameters: &ast::Parameters,
         line_number: u32,
         has_return_annotation: bool,
     ) -> SymbolTableResult {
@@ -2174,7 +2177,7 @@ impl SymbolTableBuilder {
         Ok(())
     }
 
-    fn register_ident(&mut self, ident: &Identifier, role: SymbolUsage) -> SymbolTableResult {
+    fn register_ident(&mut self, ident: &ast::Identifier, role: SymbolUsage) -> SymbolTableResult {
         self.register_name(ident.as_str(), role, ident.range)
     }
 
diff --git a/crates/codegen/src/unparse.rs b/crates/codegen/src/unparse.rs
index 7b26d229187..849544ab946 100644
--- a/crates/codegen/src/unparse.rs
+++ b/crates/codegen/src/unparse.rs
@@ -1,9 +1,6 @@
 use alloc::fmt;
 use core::fmt::Display as _;
-use ruff_python_ast::{
-    self as ruff, Arguments, BoolOp, Comprehension, ConversionFlag, Expr, Identifier, Operator,
-    Parameter, ParameterWithDefault, Parameters,
-};
+use ruff_python_ast as ast;
 use ruff_text_size::Ranged;
 use rustpython_compiler_core::SourceFile;
 use rustpython_literal::escape::{AsciiEscape, UnicodeEscape};
@@ -40,7 +37,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         self.f.write_str(s)
     }
 
-    fn p_id(&mut self, s: &Identifier) -> fmt::Result {
+    fn p_id(&mut self, s: &ast::Identifier) -> fmt::Result {
         self.f.write_str(s.as_str())
     }
 
@@ -59,7 +56,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         self.f.write_fmt(f)
     }
 
-    fn unparse_expr(&mut self, ast: &Expr, level: u8) -> fmt::Result {
+    fn unparse_expr(&mut self, ast: &ast::Expr, level: u8) -> fmt::Result {
         macro_rules! op_prec {
             ($op_ty:ident, $x:expr, $enu:path, $($var:ident($op:literal, $prec:ident)),*$(,)?) => {
                 match $x {
@@ -83,13 +80,13 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             }};
         }
         match &ast {
-            Expr::BoolOp(ruff::ExprBoolOp {
+            ast::Expr::BoolOp(ast::ExprBoolOp {
                 op,
                 values,
                 node_index: _,
                 range: _range,
             }) => {
-                let (op, prec) = op_prec!(bin, op, BoolOp, And("and", AND), Or("or", OR));
+                let (op, prec) = op_prec!(bin, op, ast::BoolOp, And("and", AND), Or("or", OR));
                 group_if!(prec, {
                     let mut first = true;
                     for val in values {
@@ -98,7 +95,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     }
                 })
             }
-            Expr::Named(ruff::ExprNamed {
+            ast::Expr::Named(ast::ExprNamed {
                 target,
                 value,
                 node_index: _,
@@ -110,18 +107,18 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(value, precedence::ATOM)?;
                 })
             }
-            Expr::BinOp(ruff::ExprBinOp {
+            ast::Expr::BinOp(ast::ExprBinOp {
                 left,
                 op,
                 right,
                 node_index: _,
                 range: _range,
             }) => {
-                let right_associative = matches!(op, Operator::Pow);
+                let right_associative = matches!(op, ast::Operator::Pow);
                 let (op, prec) = op_prec!(
                     bin,
                     op,
-                    Operator,
+                    ast::Operator,
                     Add("+", ARITH),
                     Sub("-", ARITH),
                     Mult("*", TERM),
@@ -142,7 +139,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(right, prec + !right_associative as u8)?;
                 })
             }
-            Expr::UnaryOp(ruff::ExprUnaryOp {
+            ast::Expr::UnaryOp(ast::ExprUnaryOp {
                 op,
                 operand,
                 node_index: _,
@@ -151,7 +148,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 let (op, prec) = op_prec!(
                     un,
                     op,
-                    ruff::UnaryOp,
+                    ast::UnaryOp,
                     Invert("~", FACTOR),
                     Not("not ", NOT),
                     UAdd("+", FACTOR),
@@ -162,7 +159,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(operand, prec)?;
                 })
             }
-            Expr::Lambda(ruff::ExprLambda {
+            ast::Expr::Lambda(ast::ExprLambda {
                 parameters,
                 body,
                 node_index: _,
@@ -178,7 +175,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     write!(self, ": {}", UnparseExpr::new(body, self.source))?;
                 })
             }
-            Expr::If(ruff::ExprIf {
+            ast::Expr::If(ast::ExprIf {
                 test,
                 body,
                 orelse,
@@ -193,7 +190,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(orelse, precedence::TEST)?;
                 })
             }
-            Expr::Dict(ruff::ExprDict {
+            ast::Expr::Dict(ast::ExprDict {
                 items,
                 node_index: _,
                 range: _range,
@@ -211,7 +208,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 }
                 self.p("}")?;
             }
-            Expr::Set(ruff::ExprSet {
+            ast::Expr::Set(ast::ExprSet {
                 elts,
                 node_index: _,
                 range: _range,
@@ -224,7 +221,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 }
                 self.p("}")?;
             }
-            Expr::ListComp(ruff::ExprListComp {
+            ast::Expr::ListComp(ast::ExprListComp {
                 elt,
                 generators,
                 node_index: _,
@@ -235,7 +232,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.unparse_comp(generators)?;
                 self.p("]")?;
             }
-            Expr::SetComp(ruff::ExprSetComp {
+            ast::Expr::SetComp(ast::ExprSetComp {
                 elt,
                 generators,
                 node_index: _,
@@ -246,7 +243,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.unparse_comp(generators)?;
                 self.p("}")?;
             }
-            Expr::DictComp(ruff::ExprDictComp {
+            ast::Expr::DictComp(ast::ExprDictComp {
                 key,
                 value,
                 generators,
@@ -260,7 +257,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.unparse_comp(generators)?;
                 self.p("}")?;
             }
-            Expr::Generator(ruff::ExprGenerator {
+            ast::Expr::Generator(ast::ExprGenerator {
                 parenthesized: _,
                 elt,
                 generators,
@@ -272,7 +269,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.unparse_comp(generators)?;
                 self.p(")")?;
             }
-            Expr::Await(ruff::ExprAwait {
+            ast::Expr::Await(ast::ExprAwait {
                 value,
                 node_index: _,
                 range: _range,
@@ -282,7 +279,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(value, precedence::ATOM)?;
                 })
             }
-            Expr::Yield(ruff::ExprYield {
+            ast::Expr::Yield(ast::ExprYield {
                 value,
                 node_index: _,
                 range: _range,
@@ -293,7 +290,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.p("(yield)")?;
                 }
             }
-            Expr::YieldFrom(ruff::ExprYieldFrom {
+            ast::Expr::YieldFrom(ast::ExprYieldFrom {
                 value,
                 node_index: _,
                 range: _range,
@@ -304,7 +301,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     UnparseExpr::new(value, self.source)
                 )?;
             }
-            Expr::Compare(ruff::ExprCompare {
+            ast::Expr::Compare(ast::ExprCompare {
                 left,
                 ops,
                 comparators,
@@ -322,9 +319,9 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     }
                 })
             }
-            Expr::Call(ruff::ExprCall {
+            ast::Expr::Call(ast::ExprCall {
                 func,
-                arguments: Arguments { args, keywords, .. },
+                arguments: ast::Arguments { args, keywords, .. },
                 node_index: _,
                 range: _range,
             }) => {
@@ -332,7 +329,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.p("(")?;
                 if let (
                     [
-                        Expr::Generator(ruff::ExprGenerator {
+                        ast::Expr::Generator(ast::ExprGenerator {
                             elt,
                             generators,
                             node_index: _,
@@ -365,9 +362,9 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 }
                 self.p(")")?;
             }
-            Expr::FString(ruff::ExprFString { value, .. }) => self.unparse_fstring(value)?,
-            Expr::TString(_) => self.p("t\"\"")?,
-            Expr::StringLiteral(ruff::ExprStringLiteral { value, .. }) => {
+            ast::Expr::FString(ast::ExprFString { value, .. }) => self.unparse_fstring(value)?,
+            ast::Expr::TString(_) => self.p("t\"\"")?,
+            ast::Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
                 if value.is_unicode() {
                     self.p("u")?
                 }
@@ -375,12 +372,12 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     .str_repr()
                     .fmt(self.f)?
             }
-            Expr::BytesLiteral(ruff::ExprBytesLiteral { value, .. }) => {
+            ast::Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => {
                 AsciiEscape::new_repr(&value.bytes().collect::<Vec<_>>())
                     .bytes_repr()
                     .fmt(self.f)?
             }
-            Expr::NumberLiteral(ruff::ExprNumberLiteral { value, .. }) => {
+            ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => {
                 #[allow(clippy::correctness, clippy::assertions_on_constants)]
                 const {
                     assert!(f64::MAX_10_EXP == 308)
@@ -388,28 +385,28 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
 
                 let inf_str = "1e309";
                 match value {
-                    ruff::Number::Int(int) => int.fmt(self.f)?,
-                    &ruff::Number::Float(fp) => {
+                    ast::Number::Int(int) => int.fmt(self.f)?,
+                    &ast::Number::Float(fp) => {
                         if fp.is_infinite() {
                             self.p(inf_str)?
                         } else {
                             self.p(&rustpython_literal::float::to_string(fp))?
                         }
                     }
-                    &ruff::Number::Complex { real, imag } => self
+                    &ast::Number::Complex { real, imag } => self
                         .p(&rustpython_literal::complex::to_string(real, imag)
                             .replace("inf", inf_str))?,
                 }
             }
-            Expr::BooleanLiteral(ruff::ExprBooleanLiteral { value, .. }) => {
+            ast::Expr::BooleanLiteral(ast::ExprBooleanLiteral { value, .. }) => {
                 self.p(if *value { "True" } else { "False" })?
             }
-            Expr::NoneLiteral(ruff::ExprNoneLiteral { .. }) => self.p("None")?,
-            Expr::EllipsisLiteral(ruff::ExprEllipsisLiteral { .. }) => self.p("...")?,
-            Expr::Attribute(ruff::ExprAttribute { value, attr, .. }) => {
+            ast::Expr::NoneLiteral(ast::ExprNoneLiteral { .. }) => self.p("None")?,
+            ast::Expr::EllipsisLiteral(ast::ExprEllipsisLiteral { .. }) => self.p("...")?,
+            ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.unparse_expr(value, precedence::ATOM)?;
-                let period = if let Expr::NumberLiteral(ruff::ExprNumberLiteral {
-                    value: ruff::Number::Int(_),
+                let period = if let ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    value: ast::Number::Int(_),
                     ..
                 }) = value.as_ref()
                 {
@@ -420,19 +417,19 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.p(period)?;
                 self.p_id(attr)?;
             }
-            Expr::Subscript(ruff::ExprSubscript { value, slice, .. }) => {
+            ast::Expr::Subscript(ast::ExprSubscript { value, slice, .. }) => {
                 self.unparse_expr(value, precedence::ATOM)?;
                 let lvl = precedence::TUPLE;
                 self.p("[")?;
                 self.unparse_expr(slice, lvl)?;
                 self.p("]")?;
             }
-            Expr::Starred(ruff::ExprStarred { value, .. }) => {
+            ast::Expr::Starred(ast::ExprStarred { value, .. }) => {
                 self.p("*")?;
                 self.unparse_expr(value, precedence::EXPR)?;
             }
-            Expr::Name(ruff::ExprName { id, .. }) => self.p(id.as_str())?,
-            Expr::List(ruff::ExprList { elts, .. }) => {
+            ast::Expr::Name(ast::ExprName { id, .. }) => self.p(id.as_str())?,
+            ast::Expr::List(ast::ExprList { elts, .. }) => {
                 self.p("[")?;
                 let mut first = true;
                 for elt in elts {
@@ -441,7 +438,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 }
                 self.p("]")?;
             }
-            Expr::Tuple(ruff::ExprTuple { elts, .. }) => {
+            ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
                 if elts.is_empty() {
                     self.p("()")?;
                 } else {
@@ -455,7 +452,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     })
                 }
             }
-            Expr::Slice(ruff::ExprSlice {
+            ast::Expr::Slice(ast::ExprSlice {
                 lower,
                 upper,
                 step,
@@ -474,12 +471,12 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     self.unparse_expr(step, precedence::TEST)?;
                 }
             }
-            Expr::IpyEscapeCommand(_) => {}
+            ast::Expr::IpyEscapeCommand(_) => {}
         }
         Ok(())
     }
 
-    fn unparse_arguments(&mut self, args: &Parameters) -> fmt::Result {
+    fn unparse_arguments(&mut self, args: &ast::Parameters) -> fmt::Result {
         let mut first = true;
         for (i, arg) in args.posonlyargs.iter().chain(&args.args).enumerate() {
             self.p_delim(&mut first, ", ")?;
@@ -504,7 +501,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         }
         Ok(())
     }
-    fn unparse_function_arg(&mut self, arg: &ParameterWithDefault) -> fmt::Result {
+    fn unparse_function_arg(&mut self, arg: &ast::ParameterWithDefault) -> fmt::Result {
         self.unparse_arg(&arg.parameter)?;
         if let Some(default) = &arg.default {
             write!(self, "={}", UnparseExpr::new(default, self.source))?;
@@ -512,7 +509,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_arg(&mut self, arg: &Parameter) -> fmt::Result {
+    fn unparse_arg(&mut self, arg: &ast::Parameter) -> fmt::Result {
         self.p_id(&arg.name)?;
         if let Some(ann) = &arg.annotation {
             write!(self, ": {}", UnparseExpr::new(ann, self.source))?;
@@ -520,7 +517,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_comp(&mut self, generators: &[Comprehension]) -> fmt::Result {
+    fn unparse_comp(&mut self, generators: &[ast::Comprehension]) -> fmt::Result {
         for comp in generators {
             self.p(if comp.is_async {
                 " async for "
@@ -538,10 +535,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_fstring_body(
-        &mut self,
-        elements: &[ruff::InterpolatedStringElement],
-    ) -> fmt::Result {
+    fn unparse_fstring_body(&mut self, elements: &[ast::InterpolatedStringElement]) -> fmt::Result {
         for elem in elements {
             self.unparse_fstring_elem(elem)?;
         }
@@ -550,15 +544,15 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
 
     fn unparse_formatted(
         &mut self,
-        val: &Expr,
-        debug_text: Option<&ruff::DebugText>,
-        conversion: ConversionFlag,
-        spec: Option<&ruff::InterpolatedStringFormatSpec>,
+        val: &ast::Expr,
+        debug_text: Option<&ast::DebugText>,
+        conversion: ast::ConversionFlag,
+        spec: Option<&ast::InterpolatedStringFormatSpec>,
     ) -> fmt::Result {
         let buffered = to_string_fmt(|f| {
             Unparser::new(f, self.source).unparse_expr(val, precedence::TEST + 1)
         });
-        if let Some(ruff::DebugText { leading, trailing }) = debug_text {
+        if let Some(ast::DebugText { leading, trailing }) = debug_text {
             self.p(leading)?;
             self.p(self.source.slice(val.range()))?;
             self.p(trailing)?;
@@ -573,7 +567,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         self.p(&buffered)?;
         drop(buffered);
 
-        if conversion != ConversionFlag::None {
+        if conversion != ast::ConversionFlag::None {
             self.p("!")?;
             let buf = &[conversion as u8];
             let c = core::str::from_utf8(buf).unwrap();
@@ -590,9 +584,9 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_fstring_elem(&mut self, elem: &ruff::InterpolatedStringElement) -> fmt::Result {
+    fn unparse_fstring_elem(&mut self, elem: &ast::InterpolatedStringElement) -> fmt::Result {
         match elem {
-            ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
                 expression,
                 debug_text,
                 conversion,
@@ -604,7 +598,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 *conversion,
                 format_spec.as_deref(),
             ),
-            ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
                 value,
                 ..
             }) => self.unparse_fstring_str(value),
@@ -616,12 +610,12 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         self.p(&s)
     }
 
-    fn unparse_fstring(&mut self, value: &ruff::FStringValue) -> fmt::Result {
+    fn unparse_fstring(&mut self, value: &ast::FStringValue) -> fmt::Result {
         self.p("f")?;
         let body = to_string_fmt(|f| {
             value.iter().try_for_each(|part| match part {
-                ruff::FStringPart::Literal(lit) => f.write_str(lit),
-                ruff::FStringPart::FString(ruff::FString { elements, .. }) => {
+                ast::FStringPart::Literal(lit) => f.write_str(lit),
+                ast::FStringPart::FString(ast::FString { elements, .. }) => {
                     Unparser::new(f, self.source).unparse_fstring_body(elements)
                 }
             })
@@ -634,12 +628,12 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
 }
 
 pub struct UnparseExpr<'a> {
-    expr: &'a Expr,
+    expr: &'a ast::Expr,
     source: &'a SourceFile,
 }
 
 impl<'a> UnparseExpr<'a> {
-    pub const fn new(expr: &'a Expr, source: &'a SourceFile) -> Self {
+    pub const fn new(expr: &'a ast::Expr, source: &'a SourceFile) -> Self {
         Self { expr, source }
     }
 }
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
index 31aad306f96..116d239c033 100644
--- a/crates/vm/src/stdlib/ast.rs
+++ b/crates/vm/src/stdlib/ast.rs
@@ -19,7 +19,7 @@ use crate::{
     convert::ToPyObject,
 };
 use node::Node;
-use ruff_python_ast as ruff;
+use ruff_python_ast as ast;
 use ruff_text_size::{Ranged, TextRange, TextSize};
 use rustpython_compiler_core::{
     LineIndex, OneIndexed, PositionEncoding, SourceFile, SourceFileBuilder, SourceLocation,
@@ -283,8 +283,8 @@ pub(crate) fn parse(
         })?
         .into_syntax();
     let top = match top {
-        ruff::Mod::Module(m) => Mod::Module(m),
-        ruff::Mod::Expression(e) => Mod::Expression(e),
+        ast::Mod::Module(m) => Mod::Module(m),
+        ast::Mod::Expression(e) => Mod::Expression(e),
     };
     Ok(top.ast_to_object(vm, &source_file))
 }
@@ -305,13 +305,13 @@ pub(crate) fn compile(
     let source_file = SourceFileBuilder::new(filename.to_owned(), "".to_owned()).finish();
     let ast: Mod = Node::ast_from_object(vm, &source_file, object)?;
     let ast = match ast {
-        Mod::Module(m) => ruff::Mod::Module(m),
-        Mod::Interactive(ModInteractive { range, body }) => ruff::Mod::Module(ruff::ModModule {
+        Mod::Module(m) => ast::Mod::Module(m),
+        Mod::Interactive(ModInteractive { range, body }) => ast::Mod::Module(ast::ModModule {
             node_index: Default::default(),
             range,
             body,
         }),
-        Mod::Expression(e) => ruff::Mod::Expression(e),
+        Mod::Expression(e) => ast::Mod::Expression(e),
         Mod::FunctionType(_) => todo!(),
     };
     // TODO: create a textual representation of the ast
diff --git a/crates/vm/src/stdlib/ast/argument.rs b/crates/vm/src/stdlib/ast/argument.rs
index a13200e6502..626024f5bd6 100644
--- a/crates/vm/src/stdlib/ast/argument.rs
+++ b/crates/vm/src/stdlib/ast/argument.rs
@@ -3,7 +3,7 @@ use rustpython_compiler_core::SourceFile;
 
 pub(super) struct PositionalArguments {
     pub range: TextRange,
-    pub args: Box<[ruff::Expr]>,
+    pub args: Box<[ast::Expr]>,
 }
 
 impl Node for PositionalArguments {
@@ -27,7 +27,7 @@ impl Node for PositionalArguments {
 
 pub(super) struct KeywordArguments {
     pub range: TextRange,
-    pub keywords: Box<[ruff::Keyword]>,
+    pub keywords: Box<[ast::Keyword]>,
 }
 
 impl Node for KeywordArguments {
@@ -53,10 +53,10 @@ impl Node for KeywordArguments {
 pub(super) fn merge_function_call_arguments(
     pos_args: PositionalArguments,
     key_args: KeywordArguments,
-) -> ruff::Arguments {
+) -> ast::Arguments {
     let range = pos_args.range.cover(key_args.range);
 
-    ruff::Arguments {
+    ast::Arguments {
         node_index: Default::default(),
         range,
         args: pos_args.args,
@@ -65,9 +65,9 @@ pub(super) fn merge_function_call_arguments(
 }
 
 pub(super) fn split_function_call_arguments(
-    args: ruff::Arguments,
+    args: ast::Arguments,
 ) -> (PositionalArguments, KeywordArguments) {
-    let ruff::Arguments {
+    let ast::Arguments {
         node_index: _,
         range: _,
         args,
@@ -100,13 +100,13 @@ pub(super) fn split_function_call_arguments(
 }
 
 pub(super) fn split_class_def_args(
-    args: Option<Box<ruff::Arguments>>,
+    args: Option<Box<ast::Arguments>>,
 ) -> (Option<PositionalArguments>, Option<KeywordArguments>) {
     let args = match args {
         None => return (None, None),
         Some(args) => *args,
     };
-    let ruff::Arguments {
+    let ast::Arguments {
         node_index: _,
         range: _,
         args,
@@ -141,7 +141,7 @@ pub(super) fn split_class_def_args(
 pub(super) fn merge_class_def_args(
     positional_arguments: Option<PositionalArguments>,
     keyword_arguments: Option<KeywordArguments>,
-) -> Option<Box<ruff::Arguments>> {
+) -> Option<Box<ast::Arguments>> {
     if positional_arguments.is_none() && keyword_arguments.is_none() {
         return None;
     }
@@ -157,7 +157,7 @@ pub(super) fn merge_class_def_args(
         vec![].into_boxed_slice()
     };
 
-    Some(Box::new(ruff::Arguments {
+    Some(Box::new(ast::Arguments {
         node_index: Default::default(),
         range: Default::default(), // TODO
         args,
diff --git a/crates/vm/src/stdlib/ast/basic.rs b/crates/vm/src/stdlib/ast/basic.rs
index d8565029d6c..612b6144eea 100644
--- a/crates/vm/src/stdlib/ast/basic.rs
+++ b/crates/vm/src/stdlib/ast/basic.rs
@@ -2,7 +2,7 @@ use super::*;
 use rustpython_codegen::compile::ruff_int_to_bigint;
 use rustpython_compiler_core::SourceFile;
 
-impl Node for ruff::Identifier {
+impl Node for ast::Identifier {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let id = self.as_str();
         vm.ctx.new_str(id).into()
@@ -18,7 +18,7 @@ impl Node for ruff::Identifier {
     }
 }
 
-impl Node for ruff::Int {
+impl Node for ast::Int {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         vm.ctx.new_int(ruff_int_to_bigint(&self).unwrap()).into()
     }
diff --git a/crates/vm/src/stdlib/ast/constant.rs b/crates/vm/src/stdlib/ast/constant.rs
index 83b2a7f7015..a6aac224585 100644
--- a/crates/vm/src/stdlib/ast/constant.rs
+++ b/crates/vm/src/stdlib/ast/constant.rs
@@ -1,6 +1,6 @@
 use super::*;
 use crate::builtins::{PyComplex, PyFrozenSet, PyTuple};
-use ruff::str_prefix::StringLiteralPrefix;
+use ast::str_prefix::StringLiteralPrefix;
 use rustpython_compiler_core::SourceFile;
 
 #[derive(Debug)]
@@ -22,7 +22,7 @@ impl Constant {
         }
     }
 
-    pub(super) const fn new_int(value: ruff::Int, range: TextRange) -> Self {
+    pub(super) const fn new_int(value: ast::Int, range: TextRange) -> Self {
         Self {
             range,
             value: ConstantLiteral::Int(value),
@@ -71,7 +71,7 @@ impl Constant {
         }
     }
 
-    pub(crate) fn into_expr(self) -> ruff::Expr {
+    pub(crate) fn into_expr(self) -> ast::Expr {
         constant_to_ruff_expr(self)
     }
 }
@@ -85,7 +85,7 @@ pub(crate) enum ConstantLiteral {
         prefix: StringLiteralPrefix,
     },
     Bytes(Box<[u8]>),
-    Int(ruff::Int),
+    Int(ast::Int),
     Tuple(Vec<ConstantLiteral>),
     FrozenSet(Vec<ConstantLiteral>),
     Float(f64),
@@ -244,48 +244,48 @@ impl Node for ConstantLiteral {
     }
 }
 
-fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
+fn constant_to_ruff_expr(value: Constant) -> ast::Expr {
     let Constant { value, range } = value;
     match value {
-        ConstantLiteral::None => ruff::Expr::NoneLiteral(ruff::ExprNoneLiteral {
+        ConstantLiteral::None => ast::Expr::NoneLiteral(ast::ExprNoneLiteral {
             node_index: Default::default(),
             range,
         }),
-        ConstantLiteral::Bool(value) => ruff::Expr::BooleanLiteral(ruff::ExprBooleanLiteral {
+        ConstantLiteral::Bool(value) => ast::Expr::BooleanLiteral(ast::ExprBooleanLiteral {
             node_index: Default::default(),
             range,
             value,
         }),
         ConstantLiteral::Str { value, prefix } => {
-            ruff::Expr::StringLiteral(ruff::ExprStringLiteral {
+            ast::Expr::StringLiteral(ast::ExprStringLiteral {
                 node_index: Default::default(),
                 range,
-                value: ruff::StringLiteralValue::single(ruff::StringLiteral {
+                value: ast::StringLiteralValue::single(ast::StringLiteral {
                     node_index: Default::default(),
                     range,
                     value,
-                    flags: ruff::StringLiteralFlags::empty().with_prefix(prefix),
+                    flags: ast::StringLiteralFlags::empty().with_prefix(prefix),
                 }),
             })
         }
         ConstantLiteral::Bytes(value) => {
-            ruff::Expr::BytesLiteral(ruff::ExprBytesLiteral {
+            ast::Expr::BytesLiteral(ast::ExprBytesLiteral {
                 node_index: Default::default(),
                 range,
-                value: ruff::BytesLiteralValue::single(ruff::BytesLiteral {
+                value: ast::BytesLiteralValue::single(ast::BytesLiteral {
                     node_index: Default::default(),
                     range,
                     value,
-                    flags: ruff::BytesLiteralFlags::empty(), // TODO
+                    flags: ast::BytesLiteralFlags::empty(), // TODO
                 }),
             })
         }
-        ConstantLiteral::Int(value) => ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+        ConstantLiteral::Int(value) => ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
             node_index: Default::default(),
             range,
-            value: ruff::Number::Int(value),
+            value: ast::Number::Int(value),
         }),
-        ConstantLiteral::Tuple(value) => ruff::Expr::Tuple(ruff::ExprTuple {
+        ConstantLiteral::Tuple(value) => ast::Expr::Tuple(ast::ExprTuple {
             node_index: Default::default(),
             range,
             elts: value
@@ -297,21 +297,21 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
                     })
                 })
                 .collect(),
-            ctx: ruff::ExprContext::Load,
+            ctx: ast::ExprContext::Load,
             // TODO: Does this matter?
             parenthesized: true,
         }),
-        ConstantLiteral::FrozenSet(value) => ruff::Expr::Call(ruff::ExprCall {
+        ConstantLiteral::FrozenSet(value) => ast::Expr::Call(ast::ExprCall {
             node_index: Default::default(),
             range,
             // idk lol
-            func: Box::new(ruff::Expr::Name(ruff::ExprName {
+            func: Box::new(ast::Expr::Name(ast::ExprName {
                 node_index: Default::default(),
                 range: TextRange::default(),
-                id: ruff::name::Name::new_static("frozenset"),
-                ctx: ruff::ExprContext::Load,
+                id: ast::name::Name::new_static("frozenset"),
+                ctx: ast::ExprContext::Load,
             })),
-            arguments: ruff::Arguments {
+            arguments: ast::Arguments {
                 node_index: Default::default(),
                 range,
                 args: value
@@ -326,19 +326,19 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
                 keywords: Box::default(),
             },
         }),
-        ConstantLiteral::Float(value) => ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+        ConstantLiteral::Float(value) => ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
             node_index: Default::default(),
             range,
-            value: ruff::Number::Float(value),
+            value: ast::Number::Float(value),
         }),
         ConstantLiteral::Complex { real, imag } => {
-            ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+            ast::Expr::NumberLiteral(ast::ExprNumberLiteral {
                 node_index: Default::default(),
                 range,
-                value: ruff::Number::Complex { real, imag },
+                value: ast::Number::Complex { real, imag },
             })
         }
-        ConstantLiteral::Ellipsis => ruff::Expr::EllipsisLiteral(ruff::ExprEllipsisLiteral {
+        ConstantLiteral::Ellipsis => ast::Expr::EllipsisLiteral(ast::ExprEllipsisLiteral {
             node_index: Default::default(),
             range,
         }),
@@ -348,17 +348,17 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
 pub(super) fn number_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprNumberLiteral,
+    constant: ast::ExprNumberLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprNumberLiteral {
+    let ast::ExprNumberLiteral {
         node_index: _,
         range,
         value,
     } = constant;
     let c = match value {
-        ruff::Number::Int(n) => Constant::new_int(n, range),
-        ruff::Number::Float(n) => Constant::new_float(n, range),
-        ruff::Number::Complex { real, imag } => Constant::new_complex(real, imag, range),
+        ast::Number::Int(n) => Constant::new_int(n, range),
+        ast::Number::Float(n) => Constant::new_float(n, range),
+        ast::Number::Complex { real, imag } => Constant::new_complex(real, imag, range),
     };
     c.ast_to_object(vm, source_file)
 }
@@ -366,9 +366,9 @@ pub(super) fn number_literal_to_object(
 pub(super) fn string_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprStringLiteral,
+    constant: ast::ExprStringLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprStringLiteral {
+    let ast::ExprStringLiteral {
         node_index: _,
         range,
         value,
@@ -384,9 +384,9 @@ pub(super) fn string_literal_to_object(
 pub(super) fn bytes_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprBytesLiteral,
+    constant: ast::ExprBytesLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprBytesLiteral {
+    let ast::ExprBytesLiteral {
         node_index: _,
         range,
         value,
@@ -399,9 +399,9 @@ pub(super) fn bytes_literal_to_object(
 pub(super) fn boolean_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprBooleanLiteral,
+    constant: ast::ExprBooleanLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprBooleanLiteral {
+    let ast::ExprBooleanLiteral {
         node_index: _,
         range,
         value,
@@ -413,9 +413,9 @@ pub(super) fn boolean_literal_to_object(
 pub(super) fn none_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprNoneLiteral,
+    constant: ast::ExprNoneLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprNoneLiteral {
+    let ast::ExprNoneLiteral {
         node_index: _,
         range,
     } = constant;
@@ -426,9 +426,9 @@ pub(super) fn none_literal_to_object(
 pub(super) fn ellipsis_literal_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    constant: ruff::ExprEllipsisLiteral,
+    constant: ast::ExprEllipsisLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprEllipsisLiteral {
+    let ast::ExprEllipsisLiteral {
         node_index: _,
         range,
     } = constant;
diff --git a/crates/vm/src/stdlib/ast/elif_else_clause.rs b/crates/vm/src/stdlib/ast/elif_else_clause.rs
index e2a8789dd08..b27e956077e 100644
--- a/crates/vm/src/stdlib/ast/elif_else_clause.rs
+++ b/crates/vm/src/stdlib/ast/elif_else_clause.rs
@@ -2,12 +2,12 @@ use super::*;
 use rustpython_compiler_core::SourceFile;
 
 pub(super) fn ast_to_object(
-    clause: ruff::ElifElseClause,
-    mut rest: alloc::vec::IntoIter<ruff::ElifElseClause>,
+    clause: ast::ElifElseClause,
+    mut rest: alloc::vec::IntoIter<ast::ElifElseClause>,
     vm: &VirtualMachine,
     source_file: &SourceFile,
 ) -> PyObjectRef {
-    let ruff::ElifElseClause {
+    let ast::ElifElseClause {
         node_index: _,
         range,
         test,
@@ -48,18 +48,18 @@ pub(super) fn ast_from_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
     object: PyObjectRef,
-) -> PyResult<ruff::StmtIf> {
+) -> PyResult<ast::StmtIf> {
     let test = Node::ast_from_object(vm, source_file, get_node_field(vm, &object, "test", "If")?)?;
     let body = Node::ast_from_object(vm, source_file, get_node_field(vm, &object, "body", "If")?)?;
-    let orelse: Vec<ruff::Stmt> = Node::ast_from_object(
+    let orelse: Vec<ast::Stmt> = Node::ast_from_object(
         vm,
         source_file,
         get_node_field(vm, &object, "orelse", "If")?,
     )?;
     let range = range_from_object(vm, source_file, object, "If")?;
 
-    let elif_else_clauses = if let [ruff::Stmt::If(_)] = &*orelse {
-        let Some(ruff::Stmt::If(ruff::StmtIf {
+    let elif_else_clauses = if let [ast::Stmt::If(_)] = &*orelse {
+        let Some(ast::Stmt::If(ast::StmtIf {
             node_index: _,
             range,
             test,
@@ -71,7 +71,7 @@ pub(super) fn ast_from_object(
         };
         elif_else_clauses.insert(
             0,
-            ruff::ElifElseClause {
+            ast::ElifElseClause {
                 node_index: Default::default(),
                 range,
                 test: Some(*test),
@@ -80,7 +80,7 @@ pub(super) fn ast_from_object(
         );
         elif_else_clauses
     } else {
-        vec![ruff::ElifElseClause {
+        vec![ast::ElifElseClause {
             node_index: Default::default(),
             range,
             test: None,
@@ -88,7 +88,7 @@ pub(super) fn ast_from_object(
         }]
     };
 
-    Ok(ruff::StmtIf {
+    Ok(ast::StmtIf {
         node_index: Default::default(),
         test,
         body,
diff --git a/crates/vm/src/stdlib/ast/exception.rs b/crates/vm/src/stdlib/ast/exception.rs
index b5b3ca2709a..bdb8b7ad9ac 100644
--- a/crates/vm/src/stdlib/ast/exception.rs
+++ b/crates/vm/src/stdlib/ast/exception.rs
@@ -2,7 +2,7 @@ use super::*;
 use rustpython_compiler_core::SourceFile;
 
 // sum
-impl Node for ruff::ExceptHandler {
+impl Node for ast::ExceptHandler {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::ExceptHandler(cons) => cons.ast_to_object(vm, source_file),
@@ -16,7 +16,7 @@ impl Node for ruff::ExceptHandler {
         let _cls = _object.class();
         Ok(
             if _cls.is(pyast::NodeExceptHandlerExceptHandler::static_type()) {
-                Self::ExceptHandler(ruff::ExceptHandlerExceptHandler::ast_from_object(
+                Self::ExceptHandler(ast::ExceptHandlerExceptHandler::ast_from_object(
                     _vm,
                     source_file,
                     _object,
@@ -32,7 +32,7 @@ impl Node for ruff::ExceptHandler {
 }
 
 // constructor
-impl Node for ruff::ExceptHandlerExceptHandler {
+impl Node for ast::ExceptHandlerExceptHandler {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
diff --git a/crates/vm/src/stdlib/ast/expression.rs b/crates/vm/src/stdlib/ast/expression.rs
index c63d0e0df68..3bf1470795d 100644
--- a/crates/vm/src/stdlib/ast/expression.rs
+++ b/crates/vm/src/stdlib/ast/expression.rs
@@ -7,7 +7,7 @@ use crate::stdlib::ast::{
 use rustpython_compiler_core::SourceFile;
 
 // sum
-impl Node for ruff::Expr {
+impl Node for ast::Expr {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::BoolOp(cons) => cons.ast_to_object(vm, source_file),
@@ -59,77 +59,69 @@ impl Node for ruff::Expr {
     ) -> PyResult<Self> {
         let cls = object.class();
         Ok(if cls.is(pyast::NodeExprBoolOp::static_type()) {
-            Self::BoolOp(ruff::ExprBoolOp::ast_from_object(vm, source_file, object)?)
+            Self::BoolOp(ast::ExprBoolOp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprNamedExpr::static_type()) {
-            Self::Named(ruff::ExprNamed::ast_from_object(vm, source_file, object)?)
+            Self::Named(ast::ExprNamed::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprBinOp::static_type()) {
-            Self::BinOp(ruff::ExprBinOp::ast_from_object(vm, source_file, object)?)
+            Self::BinOp(ast::ExprBinOp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprUnaryOp::static_type()) {
-            Self::UnaryOp(ruff::ExprUnaryOp::ast_from_object(vm, source_file, object)?)
+            Self::UnaryOp(ast::ExprUnaryOp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprLambda::static_type()) {
-            Self::Lambda(ruff::ExprLambda::ast_from_object(vm, source_file, object)?)
+            Self::Lambda(ast::ExprLambda::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprIfExp::static_type()) {
-            Self::If(ruff::ExprIf::ast_from_object(vm, source_file, object)?)
+            Self::If(ast::ExprIf::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprDict::static_type()) {
-            Self::Dict(ruff::ExprDict::ast_from_object(vm, source_file, object)?)
+            Self::Dict(ast::ExprDict::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprSet::static_type()) {
-            Self::Set(ruff::ExprSet::ast_from_object(vm, source_file, object)?)
+            Self::Set(ast::ExprSet::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprListComp::static_type()) {
-            Self::ListComp(ruff::ExprListComp::ast_from_object(
-                vm,
-                source_file,
-                object,
-            )?)
+            Self::ListComp(ast::ExprListComp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprSetComp::static_type()) {
-            Self::SetComp(ruff::ExprSetComp::ast_from_object(vm, source_file, object)?)
+            Self::SetComp(ast::ExprSetComp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprDictComp::static_type()) {
-            Self::DictComp(ruff::ExprDictComp::ast_from_object(
-                vm,
-                source_file,
-                object,
-            )?)
+            Self::DictComp(ast::ExprDictComp::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprGeneratorExp::static_type()) {
-            Self::Generator(ruff::ExprGenerator::ast_from_object(
+            Self::Generator(ast::ExprGenerator::ast_from_object(
                 vm,
                 source_file,
                 object,
             )?)
         } else if cls.is(pyast::NodeExprAwait::static_type()) {
-            Self::Await(ruff::ExprAwait::ast_from_object(vm, source_file, object)?)
+            Self::Await(ast::ExprAwait::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprYield::static_type()) {
-            Self::Yield(ruff::ExprYield::ast_from_object(vm, source_file, object)?)
+            Self::Yield(ast::ExprYield::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprYieldFrom::static_type()) {
-            Self::YieldFrom(ruff::ExprYieldFrom::ast_from_object(
+            Self::YieldFrom(ast::ExprYieldFrom::ast_from_object(
                 vm,
                 source_file,
                 object,
             )?)
         } else if cls.is(pyast::NodeExprCompare::static_type()) {
-            Self::Compare(ruff::ExprCompare::ast_from_object(vm, source_file, object)?)
+            Self::Compare(ast::ExprCompare::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprCall::static_type()) {
-            Self::Call(ruff::ExprCall::ast_from_object(vm, source_file, object)?)
+            Self::Call(ast::ExprCall::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprAttribute::static_type()) {
-            Self::Attribute(ruff::ExprAttribute::ast_from_object(
+            Self::Attribute(ast::ExprAttribute::ast_from_object(
                 vm,
                 source_file,
                 object,
             )?)
         } else if cls.is(pyast::NodeExprSubscript::static_type()) {
-            Self::Subscript(ruff::ExprSubscript::ast_from_object(
+            Self::Subscript(ast::ExprSubscript::ast_from_object(
                 vm,
                 source_file,
                 object,
             )?)
         } else if cls.is(pyast::NodeExprStarred::static_type()) {
-            Self::Starred(ruff::ExprStarred::ast_from_object(vm, source_file, object)?)
+            Self::Starred(ast::ExprStarred::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprName::static_type()) {
-            Self::Name(ruff::ExprName::ast_from_object(vm, source_file, object)?)
+            Self::Name(ast::ExprName::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprList::static_type()) {
-            Self::List(ruff::ExprList::ast_from_object(vm, source_file, object)?)
+            Self::List(ast::ExprList::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprTuple::static_type()) {
-            Self::Tuple(ruff::ExprTuple::ast_from_object(vm, source_file, object)?)
+            Self::Tuple(ast::ExprTuple::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprSlice::static_type()) {
-            Self::Slice(ruff::ExprSlice::ast_from_object(vm, source_file, object)?)
+            Self::Slice(ast::ExprSlice::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeExprConstant::static_type()) {
             Constant::ast_from_object(vm, source_file, object)?.into_expr()
         } else if cls.is(pyast::NodeExprJoinedStr::static_type()) {
@@ -144,7 +136,7 @@ impl Node for ruff::Expr {
 }
 
 // constructor
-impl Node for ruff::ExprBoolOp {
+impl Node for ast::ExprBoolOp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -187,7 +179,7 @@ impl Node for ruff::ExprBoolOp {
 }
 
 // constructor
-impl Node for ruff::ExprNamed {
+impl Node for ast::ExprNamed {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -230,7 +222,7 @@ impl Node for ruff::ExprNamed {
 }
 
 // constructor
-impl Node for ruff::ExprBinOp {
+impl Node for ast::ExprBinOp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -281,7 +273,7 @@ impl Node for ruff::ExprBinOp {
 }
 
 // constructor
-impl Node for ruff::ExprUnaryOp {
+impl Node for ast::ExprUnaryOp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -323,7 +315,7 @@ impl Node for ruff::ExprUnaryOp {
 }
 
 // constructor
-impl Node for ruff::ExprLambda {
+impl Node for ast::ExprLambda {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -366,7 +358,7 @@ impl Node for ruff::ExprLambda {
 }
 
 // constructor
-impl Node for ruff::ExprIf {
+impl Node for ast::ExprIf {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -417,7 +409,7 @@ impl Node for ruff::ExprIf {
 }
 
 // constructor
-impl Node for ruff::ExprDict {
+impl Node for ast::ExprDict {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -449,7 +441,7 @@ impl Node for ruff::ExprDict {
         source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let keys: Vec<Option<ruff::Expr>> = Node::ast_from_object(
+        let keys: Vec<Option<ast::Expr>> = Node::ast_from_object(
             vm,
             source_file,
             get_node_field(vm, &object, "keys", "Dict")?,
@@ -462,7 +454,7 @@ impl Node for ruff::ExprDict {
         let items = keys
             .into_iter()
             .zip(values)
-            .map(|(key, value)| ruff::DictItem { key, value })
+            .map(|(key, value)| ast::DictItem { key, value })
             .collect();
         Ok(Self {
             node_index: Default::default(),
@@ -473,7 +465,7 @@ impl Node for ruff::ExprDict {
 }
 
 // constructor
-impl Node for ruff::ExprSet {
+impl Node for ast::ExprSet {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -507,7 +499,7 @@ impl Node for ruff::ExprSet {
 }
 
 // constructor
-impl Node for ruff::ExprListComp {
+impl Node for ast::ExprListComp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -550,7 +542,7 @@ impl Node for ruff::ExprListComp {
 }
 
 // constructor
-impl Node for ruff::ExprSetComp {
+impl Node for ast::ExprSetComp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -593,7 +585,7 @@ impl Node for ruff::ExprSetComp {
 }
 
 // constructor
-impl Node for ruff::ExprDictComp {
+impl Node for ast::ExprDictComp {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -644,7 +636,7 @@ impl Node for ruff::ExprDictComp {
 }
 
 // constructor
-impl Node for ruff::ExprGenerator {
+impl Node for ast::ExprGenerator {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -690,7 +682,7 @@ impl Node for ruff::ExprGenerator {
 }
 
 // constructor
-impl Node for ruff::ExprAwait {
+impl Node for ast::ExprAwait {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -724,7 +716,7 @@ impl Node for ruff::ExprAwait {
 }
 
 // constructor
-impl Node for ruff::ExprYield {
+impl Node for ast::ExprYield {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -757,7 +749,7 @@ impl Node for ruff::ExprYield {
 }
 
 // constructor
-impl Node for ruff::ExprYieldFrom {
+impl Node for ast::ExprYieldFrom {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -792,7 +784,7 @@ impl Node for ruff::ExprYieldFrom {
 }
 
 // constructor
-impl Node for ruff::ExprCompare {
+impl Node for ast::ExprCompare {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -853,7 +845,7 @@ impl Node for ruff::ExprCompare {
 }
 
 // constructor
-impl Node for ruff::ExprCall {
+impl Node for ast::ExprCall {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -914,7 +906,7 @@ impl Node for ruff::ExprCall {
 }
 
 // constructor
-impl Node for ruff::ExprAttribute {
+impl Node for ast::ExprAttribute {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -965,7 +957,7 @@ impl Node for ruff::ExprAttribute {
 }
 
 // constructor
-impl Node for ruff::ExprSubscript {
+impl Node for ast::ExprSubscript {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1015,7 +1007,7 @@ impl Node for ruff::ExprSubscript {
 }
 
 // constructor
-impl Node for ruff::ExprStarred {
+impl Node for ast::ExprStarred {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1057,7 +1049,7 @@ impl Node for ruff::ExprStarred {
 }
 
 // constructor
-impl Node for ruff::ExprName {
+impl Node for ast::ExprName {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1095,7 +1087,7 @@ impl Node for ruff::ExprName {
 }
 
 // constructor
-impl Node for ruff::ExprList {
+impl Node for ast::ExprList {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1138,7 +1130,7 @@ impl Node for ruff::ExprList {
 }
 
 // constructor
-impl Node for ruff::ExprTuple {
+impl Node for ast::ExprTuple {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1183,7 +1175,7 @@ impl Node for ruff::ExprTuple {
 }
 
 // constructor
-impl Node for ruff::ExprSlice {
+impl Node for ast::ExprSlice {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1228,7 +1220,7 @@ impl Node for ruff::ExprSlice {
 }
 
 // sum
-impl Node for ruff::ExprContext {
+impl Node for ast::ExprContext {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let node_type = match self {
             Self::Load => pyast::NodeExprContextLoad::static_type(),
@@ -1266,7 +1258,7 @@ impl Node for ruff::ExprContext {
 }
 
 // product
-impl Node for ruff::Comprehension {
+impl Node for ast::Comprehension {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
diff --git a/crates/vm/src/stdlib/ast/module.rs b/crates/vm/src/stdlib/ast/module.rs
index 6fae8f10a33..78f897b8930 100644
--- a/crates/vm/src/stdlib/ast/module.rs
+++ b/crates/vm/src/stdlib/ast/module.rs
@@ -18,9 +18,9 @@ use rustpython_compiler_core::SourceFile;
 /// - `FunctionType`: A function signature with argument and return type
 ///   annotations, representing the type hints of a function (e.g., `def add(x: int, y: int) -> int`).
 pub(super) enum Mod {
-    Module(ruff::ModModule),
+    Module(ast::ModModule),
     Interactive(ModInteractive),
-    Expression(ruff::ModExpression),
+    Expression(ast::ModExpression),
     FunctionType(ModFunctionType),
 }
 
@@ -42,11 +42,11 @@ impl Node for Mod {
     ) -> PyResult<Self> {
         let cls = object.class();
         Ok(if cls.is(pyast::NodeModModule::static_type()) {
-            Self::Module(ruff::ModModule::ast_from_object(vm, source_file, object)?)
+            Self::Module(ast::ModModule::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeModInteractive::static_type()) {
             Self::Interactive(ModInteractive::ast_from_object(vm, source_file, object)?)
         } else if cls.is(pyast::NodeModExpression::static_type()) {
-            Self::Expression(ruff::ModExpression::ast_from_object(
+            Self::Expression(ast::ModExpression::ast_from_object(
                 vm,
                 source_file,
                 object,
@@ -63,7 +63,7 @@ impl Node for Mod {
 }
 
 // constructor
-impl Node for ruff::ModModule {
+impl Node for ast::ModModule {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -113,7 +113,7 @@ impl Node for ruff::ModModule {
 
 pub(super) struct ModInteractive {
     pub(crate) range: TextRange,
-    pub(crate) body: Vec<ruff::Stmt>,
+    pub(crate) body: Vec<ast::Stmt>,
 }
 
 // constructor
@@ -147,7 +147,7 @@ impl Node for ModInteractive {
 }
 
 // constructor
-impl Node for ruff::ModExpression {
+impl Node for ast::ModExpression {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -182,8 +182,8 @@ impl Node for ruff::ModExpression {
 }
 
 pub(super) struct ModFunctionType {
-    pub(crate) argtypes: Box<[ruff::Expr]>,
-    pub(crate) returns: ruff::Expr,
+    pub(crate) argtypes: Box<[ast::Expr]>,
+    pub(crate) returns: ast::Expr,
     pub(crate) range: TextRange,
 }
 
diff --git a/crates/vm/src/stdlib/ast/operator.rs b/crates/vm/src/stdlib/ast/operator.rs
index c394152da2c..23aa63c7031 100644
--- a/crates/vm/src/stdlib/ast/operator.rs
+++ b/crates/vm/src/stdlib/ast/operator.rs
@@ -2,7 +2,7 @@ use super::*;
 use rustpython_compiler_core::SourceFile;
 
 // sum
-impl Node for ruff::BoolOp {
+impl Node for ast::BoolOp {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let node_type = match self {
             Self::And => pyast::NodeBoolOpAnd::static_type(),
@@ -34,7 +34,7 @@ impl Node for ruff::BoolOp {
 }
 
 // sum
-impl Node for ruff::Operator {
+impl Node for ast::Operator {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let node_type = match self {
             Self::Add => pyast::NodeOperatorAdd::static_type(),
@@ -99,7 +99,7 @@ impl Node for ruff::Operator {
 }
 
 // sum
-impl Node for ruff::UnaryOp {
+impl Node for ast::UnaryOp {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let node_type = match self {
             Self::Invert => pyast::NodeUnaryOpInvert::static_type(),
@@ -137,7 +137,7 @@ impl Node for ruff::UnaryOp {
 }
 
 // sum
-impl Node for ruff::CmpOp {
+impl Node for ast::CmpOp {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         let node_type = match self {
             Self::Eq => pyast::NodeCmpOpEq::static_type(),
diff --git a/crates/vm/src/stdlib/ast/other.rs b/crates/vm/src/stdlib/ast/other.rs
index ce7d5fe4807..8a89a740682 100644
--- a/crates/vm/src/stdlib/ast/other.rs
+++ b/crates/vm/src/stdlib/ast/other.rs
@@ -1,7 +1,7 @@
 use super::*;
 use rustpython_compiler_core::SourceFile;
 
-impl Node for ruff::ConversionFlag {
+impl Node for ast::ConversionFlag {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         vm.ctx.new_int(self as u8).into()
     }
@@ -24,7 +24,7 @@ impl Node for ruff::ConversionFlag {
 }
 
 // /// This is just a string, not strictly an AST node. But it makes AST conversions easier.
-impl Node for ruff::name::Name {
+impl Node for ast::name::Name {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         vm.ctx.new_str(self.as_str()).to_pyobject(vm)
     }
@@ -41,9 +41,9 @@ impl Node for ruff::name::Name {
     }
 }
 
-impl Node for ruff::Decorator {
+impl Node for ast::Decorator {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
-        ruff::Expr::ast_to_object(self.expression, vm, source_file)
+        ast::Expr::ast_to_object(self.expression, vm, source_file)
     }
 
     fn ast_from_object(
@@ -51,7 +51,7 @@ impl Node for ruff::Decorator {
         source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let expression = ruff::Expr::ast_from_object(vm, source_file, object)?;
+        let expression = ast::Expr::ast_from_object(vm, source_file, object)?;
         let range = expression.range();
         Ok(Self {
             node_index: Default::default(),
@@ -62,7 +62,7 @@ impl Node for ruff::Decorator {
 }
 
 // product
-impl Node for ruff::Alias {
+impl Node for ast::Alias {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -103,7 +103,7 @@ impl Node for ruff::Alias {
 }
 
 // product
-impl Node for ruff::WithItem {
+impl Node for ast::WithItem {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
diff --git a/crates/vm/src/stdlib/ast/parameter.rs b/crates/vm/src/stdlib/ast/parameter.rs
index 44fcbb2b464..1e411d41ab6 100644
--- a/crates/vm/src/stdlib/ast/parameter.rs
+++ b/crates/vm/src/stdlib/ast/parameter.rs
@@ -2,7 +2,7 @@ use super::*;
 use rustpython_compiler_core::SourceFile;
 
 // product
-impl Node for ruff::Parameters {
+impl Node for ast::Parameters {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -101,7 +101,7 @@ impl Node for ruff::Parameters {
 }
 
 // product
-impl Node for ruff::Parameter {
+impl Node for ast::Parameter {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -156,7 +156,7 @@ impl Node for ruff::Parameter {
 }
 
 // product
-impl Node for ruff::Keyword {
+impl Node for ast::Keyword {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -197,7 +197,7 @@ impl Node for ruff::Keyword {
 
 struct PositionalParameters {
     pub _range: TextRange, // TODO: Use this
-    pub args: Box<[ruff::Parameter]>,
+    pub args: Box<[ast::Parameter]>,
 }
 
 impl Node for PositionalParameters {
@@ -220,7 +220,7 @@ impl Node for PositionalParameters {
 
 struct KeywordParameters {
     pub _range: TextRange, // TODO: Use this
-    pub keywords: Box<[ruff::Parameter]>,
+    pub keywords: Box<[ast::Parameter]>,
 }
 
 impl Node for KeywordParameters {
@@ -243,7 +243,7 @@ impl Node for KeywordParameters {
 
 struct ParameterDefaults {
     pub _range: TextRange, // TODO: Use this
-    defaults: Box<[Option<Box<ruff::Expr>>]>,
+    defaults: Box<[Option<Box<ast::Expr>>]>,
 }
 
 impl Node for ParameterDefaults {
@@ -265,8 +265,8 @@ impl Node for ParameterDefaults {
 }
 
 fn extract_positional_parameter_defaults(
-    pos_only_args: Vec<ruff::ParameterWithDefault>,
-    args: Vec<ruff::ParameterWithDefault>,
+    pos_only_args: Vec<ast::ParameterWithDefault>,
+    args: Vec<ast::ParameterWithDefault>,
 ) -> (
     PositionalParameters,
     PositionalParameters,
@@ -325,15 +325,15 @@ fn merge_positional_parameter_defaults(
     args: PositionalParameters,
     defaults: ParameterDefaults,
 ) -> (
-    Vec<ruff::ParameterWithDefault>,
-    Vec<ruff::ParameterWithDefault>,
+    Vec<ast::ParameterWithDefault>,
+    Vec<ast::ParameterWithDefault>,
 ) {
     let posonlyargs = posonlyargs.args;
     let args = args.args;
     let defaults = defaults.defaults;
 
     let mut posonlyargs: Vec<_> = <Box<[_]> as IntoIterator>::into_iter(posonlyargs)
-        .map(|parameter| ruff::ParameterWithDefault {
+        .map(|parameter| ast::ParameterWithDefault {
             node_index: Default::default(),
             range: Default::default(),
             parameter,
@@ -341,7 +341,7 @@ fn merge_positional_parameter_defaults(
         })
         .collect();
     let mut args: Vec<_> = <Box<[_]> as IntoIterator>::into_iter(args)
-        .map(|parameter| ruff::ParameterWithDefault {
+        .map(|parameter| ast::ParameterWithDefault {
             node_index: Default::default(),
             range: Default::default(),
             parameter,
@@ -366,7 +366,7 @@ fn merge_positional_parameter_defaults(
 }
 
 fn extract_keyword_parameter_defaults(
-    kw_only_args: Vec<ruff::ParameterWithDefault>,
+    kw_only_args: Vec<ast::ParameterWithDefault>,
 ) -> (KeywordParameters, ParameterDefaults) {
     let mut defaults = vec![];
     defaults.extend(kw_only_args.iter().map(|item| item.default.clone()));
@@ -402,9 +402,9 @@ fn extract_keyword_parameter_defaults(
 fn merge_keyword_parameter_defaults(
     kw_only_args: KeywordParameters,
     defaults: ParameterDefaults,
-) -> Vec<ruff::ParameterWithDefault> {
+) -> Vec<ast::ParameterWithDefault> {
     core::iter::zip(kw_only_args.keywords, defaults.defaults)
-        .map(|(parameter, default)| ruff::ParameterWithDefault {
+        .map(|(parameter, default)| ast::ParameterWithDefault {
             node_index: Default::default(),
             parameter,
             default,
diff --git a/crates/vm/src/stdlib/ast/pattern.rs b/crates/vm/src/stdlib/ast/pattern.rs
index d8128cb0622..4531a989cb3 100644
--- a/crates/vm/src/stdlib/ast/pattern.rs
+++ b/crates/vm/src/stdlib/ast/pattern.rs
@@ -2,7 +2,7 @@ use super::*;
 use rustpython_compiler_core::SourceFile;
 
 // product
-impl Node for ruff::MatchCase {
+impl Node for ast::MatchCase {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -50,7 +50,7 @@ impl Node for ruff::MatchCase {
 }
 
 // sum
-impl Node for ruff::Pattern {
+impl Node for ast::Pattern {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::MatchValue(cons) => cons.ast_to_object(vm, source_file),
@@ -70,49 +70,49 @@ impl Node for ruff::Pattern {
     ) -> PyResult<Self> {
         let _cls = _object.class();
         Ok(if _cls.is(pyast::NodePatternMatchValue::static_type()) {
-            Self::MatchValue(ruff::PatternMatchValue::ast_from_object(
+            Self::MatchValue(ast::PatternMatchValue::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchSingleton::static_type()) {
-            Self::MatchSingleton(ruff::PatternMatchSingleton::ast_from_object(
+            Self::MatchSingleton(ast::PatternMatchSingleton::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchSequence::static_type()) {
-            Self::MatchSequence(ruff::PatternMatchSequence::ast_from_object(
+            Self::MatchSequence(ast::PatternMatchSequence::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchMapping::static_type()) {
-            Self::MatchMapping(ruff::PatternMatchMapping::ast_from_object(
+            Self::MatchMapping(ast::PatternMatchMapping::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchClass::static_type()) {
-            Self::MatchClass(ruff::PatternMatchClass::ast_from_object(
+            Self::MatchClass(ast::PatternMatchClass::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchStar::static_type()) {
-            Self::MatchStar(ruff::PatternMatchStar::ast_from_object(
+            Self::MatchStar(ast::PatternMatchStar::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchAs::static_type()) {
-            Self::MatchAs(ruff::PatternMatchAs::ast_from_object(
+            Self::MatchAs(ast::PatternMatchAs::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodePatternMatchOr::static_type()) {
-            Self::MatchOr(ruff::PatternMatchOr::ast_from_object(
+            Self::MatchOr(ast::PatternMatchOr::ast_from_object(
                 _vm,
                 source_file,
                 _object,
@@ -126,7 +126,7 @@ impl Node for ruff::Pattern {
     }
 }
 // constructor
-impl Node for ruff::PatternMatchValue {
+impl Node for ast::PatternMatchValue {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -161,7 +161,7 @@ impl Node for ruff::PatternMatchValue {
 }
 
 // constructor
-impl Node for ruff::PatternMatchSingleton {
+impl Node for ast::PatternMatchSingleton {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -198,12 +198,12 @@ impl Node for ruff::PatternMatchSingleton {
     }
 }
 
-impl Node for ruff::Singleton {
+impl Node for ast::Singleton {
     fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
         match self {
-            ruff::Singleton::None => vm.ctx.none(),
-            ruff::Singleton::True => vm.ctx.new_bool(true).into(),
-            ruff::Singleton::False => vm.ctx.new_bool(false).into(),
+            ast::Singleton::None => vm.ctx.none(),
+            ast::Singleton::True => vm.ctx.new_bool(true).into(),
+            ast::Singleton::False => vm.ctx.new_bool(false).into(),
         }
     }
 
@@ -213,11 +213,11 @@ impl Node for ruff::Singleton {
         object: PyObjectRef,
     ) -> PyResult<Self> {
         if vm.is_none(&object) {
-            Ok(ruff::Singleton::None)
+            Ok(ast::Singleton::None)
         } else if object.is(&vm.ctx.true_value) {
-            Ok(ruff::Singleton::True)
+            Ok(ast::Singleton::True)
         } else if object.is(&vm.ctx.false_value) {
-            Ok(ruff::Singleton::False)
+            Ok(ast::Singleton::False)
         } else {
             Err(vm.new_value_error(format!(
                 "Expected None, True, or False, got {:?}",
@@ -228,7 +228,7 @@ impl Node for ruff::Singleton {
 }
 
 // constructor
-impl Node for ruff::PatternMatchSequence {
+impl Node for ast::PatternMatchSequence {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -266,7 +266,7 @@ impl Node for ruff::PatternMatchSequence {
 }
 
 // constructor
-impl Node for ruff::PatternMatchMapping {
+impl Node for ast::PatternMatchMapping {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -318,7 +318,7 @@ impl Node for ruff::PatternMatchMapping {
 }
 
 // constructor
-impl Node for ruff::PatternMatchClass {
+impl Node for ast::PatternMatchClass {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -377,7 +377,7 @@ impl Node for ruff::PatternMatchClass {
                 get_node_field(vm, &object, "cls", "MatchClass")?,
             )?,
             range: range_from_object(vm, source_file, object, "MatchClass")?,
-            arguments: ruff::PatternArguments {
+            arguments: ast::PatternArguments {
                 node_index: Default::default(),
                 range: Default::default(),
                 patterns,
@@ -387,7 +387,7 @@ impl Node for ruff::PatternMatchClass {
     }
 }
 
-struct PatternMatchClassPatterns(Vec<ruff::Pattern>);
+struct PatternMatchClassPatterns(Vec<ast::Pattern>);
 
 impl Node for PatternMatchClassPatterns {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
@@ -403,7 +403,7 @@ impl Node for PatternMatchClassPatterns {
     }
 }
 
-struct PatternMatchClassKeywordAttributes(Vec<ruff::Identifier>);
+struct PatternMatchClassKeywordAttributes(Vec<ast::Identifier>);
 
 impl Node for PatternMatchClassKeywordAttributes {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
@@ -419,7 +419,7 @@ impl Node for PatternMatchClassKeywordAttributes {
     }
 }
 
-struct PatternMatchClassKeywordPatterns(Vec<ruff::Pattern>);
+struct PatternMatchClassKeywordPatterns(Vec<ast::Pattern>);
 
 impl Node for PatternMatchClassKeywordPatterns {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
@@ -435,7 +435,7 @@ impl Node for PatternMatchClassKeywordPatterns {
     }
 }
 // constructor
-impl Node for ruff::PatternMatchStar {
+impl Node for ast::PatternMatchStar {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -468,7 +468,7 @@ impl Node for ruff::PatternMatchStar {
 }
 
 // constructor
-impl Node for ruff::PatternMatchAs {
+impl Node for ast::PatternMatchAs {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -507,7 +507,7 @@ impl Node for ruff::PatternMatchAs {
 }
 
 // constructor
-impl Node for ruff::PatternMatchOr {
+impl Node for ast::PatternMatchOr {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -541,7 +541,7 @@ impl Node for ruff::PatternMatchOr {
 }
 
 fn split_pattern_match_class(
-    arguments: ruff::PatternArguments,
+    arguments: ast::PatternArguments,
 ) -> (
     PatternMatchClassPatterns,
     PatternMatchClassKeywordAttributes,
@@ -562,12 +562,12 @@ fn merge_pattern_match_class(
     patterns: PatternMatchClassPatterns,
     kwd_attrs: PatternMatchClassKeywordAttributes,
     kwd_patterns: PatternMatchClassKeywordPatterns,
-) -> (Vec<ruff::Pattern>, Vec<ruff::PatternKeyword>) {
+) -> (Vec<ast::Pattern>, Vec<ast::PatternKeyword>) {
     let keywords = kwd_attrs
         .0
         .into_iter()
         .zip(kwd_patterns.0)
-        .map(|(attr, pattern)| ruff::PatternKeyword {
+        .map(|(attr, pattern)| ast::PatternKeyword {
             range: Default::default(),
             node_index: Default::default(),
             attr,
diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/ast/statement.rs
index f1d36c52e2e..7716181fc5b 100644
--- a/crates/vm/src/stdlib/ast/statement.rs
+++ b/crates/vm/src/stdlib/ast/statement.rs
@@ -3,7 +3,7 @@ use crate::stdlib::ast::argument::{merge_class_def_args, split_class_def_args};
 use rustpython_compiler_core::SourceFile;
 
 // sum
-impl Node for ruff::Stmt {
+impl Node for ast::Stmt {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::FunctionDef(cons) => cons.ast_to_object(vm, source_file),
@@ -44,117 +44,93 @@ impl Node for ruff::Stmt {
     ) -> PyResult<Self> {
         let _cls = _object.class();
         Ok(if _cls.is(pyast::NodeStmtFunctionDef::static_type()) {
-            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
+            Self::FunctionDef(ast::StmtFunctionDef::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type()) {
-            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
+            Self::FunctionDef(ast::StmtFunctionDef::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtClassDef::static_type()) {
-            Self::ClassDef(ruff::StmtClassDef::ast_from_object(
+            Self::ClassDef(ast::StmtClassDef::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtReturn::static_type()) {
-            Self::Return(ruff::StmtReturn::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Return(ast::StmtReturn::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtDelete::static_type()) {
-            Self::Delete(ruff::StmtDelete::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Delete(ast::StmtDelete::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtAssign::static_type()) {
-            Self::Assign(ruff::StmtAssign::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Assign(ast::StmtAssign::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtTypeAlias::static_type()) {
-            Self::TypeAlias(ruff::StmtTypeAlias::ast_from_object(
+            Self::TypeAlias(ast::StmtTypeAlias::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtAugAssign::static_type()) {
-            Self::AugAssign(ruff::StmtAugAssign::ast_from_object(
+            Self::AugAssign(ast::StmtAugAssign::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtAnnAssign::static_type()) {
-            Self::AnnAssign(ruff::StmtAnnAssign::ast_from_object(
+            Self::AnnAssign(ast::StmtAnnAssign::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtFor::static_type()) {
-            Self::For(ruff::StmtFor::ast_from_object(_vm, source_file, _object)?)
+            Self::For(ast::StmtFor::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtAsyncFor::static_type()) {
-            Self::For(ruff::StmtFor::ast_from_object(_vm, source_file, _object)?)
+            Self::For(ast::StmtFor::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtWhile::static_type()) {
-            Self::While(ruff::StmtWhile::ast_from_object(_vm, source_file, _object)?)
+            Self::While(ast::StmtWhile::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtIf::static_type()) {
-            Self::If(ruff::StmtIf::ast_from_object(_vm, source_file, _object)?)
+            Self::If(ast::StmtIf::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtWith::static_type()) {
-            Self::With(ruff::StmtWith::ast_from_object(_vm, source_file, _object)?)
+            Self::With(ast::StmtWith::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtAsyncWith::static_type()) {
-            Self::With(ruff::StmtWith::ast_from_object(_vm, source_file, _object)?)
+            Self::With(ast::StmtWith::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtMatch::static_type()) {
-            Self::Match(ruff::StmtMatch::ast_from_object(_vm, source_file, _object)?)
+            Self::Match(ast::StmtMatch::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtRaise::static_type()) {
-            Self::Raise(ruff::StmtRaise::ast_from_object(_vm, source_file, _object)?)
+            Self::Raise(ast::StmtRaise::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtTry::static_type()) {
-            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_file, _object)?)
+            Self::Try(ast::StmtTry::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtTryStar::static_type()) {
-            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_file, _object)?)
+            Self::Try(ast::StmtTry::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtAssert::static_type()) {
-            Self::Assert(ruff::StmtAssert::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Assert(ast::StmtAssert::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtImport::static_type()) {
-            Self::Import(ruff::StmtImport::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Import(ast::StmtImport::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtImportFrom::static_type()) {
-            Self::ImportFrom(ruff::StmtImportFrom::ast_from_object(
+            Self::ImportFrom(ast::StmtImportFrom::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtGlobal::static_type()) {
-            Self::Global(ruff::StmtGlobal::ast_from_object(
-                _vm,
-                source_file,
-                _object,
-            )?)
+            Self::Global(ast::StmtGlobal::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtNonlocal::static_type()) {
-            Self::Nonlocal(ruff::StmtNonlocal::ast_from_object(
+            Self::Nonlocal(ast::StmtNonlocal::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeStmtExpr::static_type()) {
-            Self::Expr(ruff::StmtExpr::ast_from_object(_vm, source_file, _object)?)
+            Self::Expr(ast::StmtExpr::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtPass::static_type()) {
-            Self::Pass(ruff::StmtPass::ast_from_object(_vm, source_file, _object)?)
+            Self::Pass(ast::StmtPass::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtBreak::static_type()) {
-            Self::Break(ruff::StmtBreak::ast_from_object(_vm, source_file, _object)?)
+            Self::Break(ast::StmtBreak::ast_from_object(_vm, source_file, _object)?)
         } else if _cls.is(pyast::NodeStmtContinue::static_type()) {
-            Self::Continue(ruff::StmtContinue::ast_from_object(
+            Self::Continue(ast::StmtContinue::ast_from_object(
                 _vm,
                 source_file,
                 _object,
@@ -169,7 +145,7 @@ impl Node for ruff::Stmt {
 }
 
 // constructor
-impl Node for ruff::StmtFunctionDef {
+impl Node for ast::StmtFunctionDef {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -266,7 +242,7 @@ impl Node for ruff::StmtFunctionDef {
 }
 
 // constructor
-impl Node for ruff::StmtClassDef {
+impl Node for ast::StmtClassDef {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -348,7 +324,7 @@ impl Node for ruff::StmtClassDef {
     }
 }
 // constructor
-impl Node for ruff::StmtReturn {
+impl Node for ast::StmtReturn {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -379,7 +355,7 @@ impl Node for ruff::StmtReturn {
     }
 }
 // constructor
-impl Node for ruff::StmtDelete {
+impl Node for ast::StmtDelete {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -413,7 +389,7 @@ impl Node for ruff::StmtDelete {
 }
 
 // constructor
-impl Node for ruff::StmtAssign {
+impl Node for ast::StmtAssign {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -461,7 +437,7 @@ impl Node for ruff::StmtAssign {
 }
 
 // constructor
-impl Node for ruff::StmtTypeAlias {
+impl Node for ast::StmtTypeAlias {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -516,7 +492,7 @@ impl Node for ruff::StmtTypeAlias {
 }
 
 // constructor
-impl Node for ruff::StmtAugAssign {
+impl Node for ast::StmtAugAssign {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -566,7 +542,7 @@ impl Node for ruff::StmtAugAssign {
 }
 
 // constructor
-impl Node for ruff::StmtAnnAssign {
+impl Node for ast::StmtAnnAssign {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -626,7 +602,7 @@ impl Node for ruff::StmtAnnAssign {
 }
 
 // constructor
-impl Node for ruff::StmtFor {
+impl Node for ast::StmtFor {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -704,7 +680,7 @@ impl Node for ruff::StmtFor {
 }
 
 // constructor
-impl Node for ruff::StmtWhile {
+impl Node for ast::StmtWhile {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -754,7 +730,7 @@ impl Node for ruff::StmtWhile {
     }
 }
 // constructor
-impl Node for ruff::StmtIf {
+impl Node for ast::StmtIf {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -764,7 +740,7 @@ impl Node for ruff::StmtIf {
             elif_else_clauses,
         } = self;
         elif_else_clause::ast_to_object(
-            ruff::ElifElseClause {
+            ast::ElifElseClause {
                 node_index: Default::default(),
                 range,
                 test: Some(*test),
@@ -784,7 +760,7 @@ impl Node for ruff::StmtIf {
     }
 }
 // constructor
-impl Node for ruff::StmtWith {
+impl Node for ast::StmtWith {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -844,7 +820,7 @@ impl Node for ruff::StmtWith {
     }
 }
 // constructor
-impl Node for ruff::StmtMatch {
+impl Node for ast::StmtMatch {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -885,7 +861,7 @@ impl Node for ruff::StmtMatch {
     }
 }
 // constructor
-impl Node for ruff::StmtRaise {
+impl Node for ast::StmtRaise {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -922,7 +898,7 @@ impl Node for ruff::StmtRaise {
     }
 }
 // constructor
-impl Node for ruff::StmtTry {
+impl Node for ast::StmtTry {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -996,7 +972,7 @@ impl Node for ruff::StmtTry {
     }
 }
 // constructor
-impl Node for ruff::StmtAssert {
+impl Node for ast::StmtAssert {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1035,7 +1011,7 @@ impl Node for ruff::StmtAssert {
     }
 }
 // constructor
-impl Node for ruff::StmtImport {
+impl Node for ast::StmtImport {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1068,7 +1044,7 @@ impl Node for ruff::StmtImport {
     }
 }
 // constructor
-impl Node for ruff::StmtImportFrom {
+impl Node for ast::StmtImportFrom {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1117,7 +1093,7 @@ impl Node for ruff::StmtImportFrom {
     }
 }
 // constructor
-impl Node for ruff::StmtGlobal {
+impl Node for ast::StmtGlobal {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1150,7 +1126,7 @@ impl Node for ruff::StmtGlobal {
     }
 }
 // constructor
-impl Node for ruff::StmtNonlocal {
+impl Node for ast::StmtNonlocal {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1183,7 +1159,7 @@ impl Node for ruff::StmtNonlocal {
     }
 }
 // constructor
-impl Node for ruff::StmtExpr {
+impl Node for ast::StmtExpr {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1216,7 +1192,7 @@ impl Node for ruff::StmtExpr {
     }
 }
 // constructor
-impl Node for ruff::StmtPass {
+impl Node for ast::StmtPass {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1241,7 +1217,7 @@ impl Node for ruff::StmtPass {
     }
 }
 // constructor
-impl Node for ruff::StmtBreak {
+impl Node for ast::StmtBreak {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -1268,7 +1244,7 @@ impl Node for ruff::StmtBreak {
 }
 
 // constructor
-impl Node for ruff::StmtContinue {
+impl Node for ast::StmtContinue {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
diff --git a/crates/vm/src/stdlib/ast/string.rs b/crates/vm/src/stdlib/ast/string.rs
index c68e378bc74..2533fb8c6b9 100644
--- a/crates/vm/src/stdlib/ast/string.rs
+++ b/crates/vm/src/stdlib/ast/string.rs
@@ -2,14 +2,13 @@ use super::constant::{Constant, ConstantLiteral};
 use super::*;
 
 fn ruff_fstring_element_into_iter(
-    mut fstring_element: ruff::InterpolatedStringElements,
-) -> impl Iterator<Item = ruff::InterpolatedStringElement> {
-    let default =
-        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
-            node_index: Default::default(),
-            range: Default::default(),
-            value: Default::default(),
-        });
+    mut fstring_element: ast::InterpolatedStringElements,
+) -> impl Iterator<Item = ast::InterpolatedStringElement> {
+    let default = ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
+        node_index: Default::default(),
+        range: Default::default(),
+        value: Default::default(),
+    });
     fstring_element
         .iter_mut()
         .map(move |elem| core::mem::replace(elem, default.clone()))
@@ -18,19 +17,19 @@ fn ruff_fstring_element_into_iter(
 }
 
 fn ruff_fstring_element_to_joined_str_part(
-    element: ruff::InterpolatedStringElement,
+    element: ast::InterpolatedStringElement,
 ) -> JoinedStrPart {
     match element {
-        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+        ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
             range,
             value,
             node_index: _,
         }) => JoinedStrPart::Constant(Constant::new_str(
             value,
-            ruff::str_prefix::StringLiteralPrefix::Empty,
+            ast::str_prefix::StringLiteralPrefix::Empty,
             range,
         )),
-        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+        ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
             range,
             expression,
             debug_text: _, // TODO: What is this?
@@ -47,12 +46,12 @@ fn ruff_fstring_element_to_joined_str_part(
 }
 
 fn ruff_format_spec_to_joined_str(
-    format_spec: Option<Box<ruff::InterpolatedStringFormatSpec>>,
+    format_spec: Option<Box<ast::InterpolatedStringFormatSpec>>,
 ) -> Option<Box<JoinedStr>> {
     match format_spec {
         None => None,
         Some(format_spec) => {
-            let ruff::InterpolatedStringFormatSpec {
+            let ast::InterpolatedStringFormatSpec {
                 range,
                 elements,
                 node_index: _,
@@ -67,36 +66,36 @@ fn ruff_format_spec_to_joined_str(
 }
 
 fn ruff_fstring_element_to_ruff_fstring_part(
-    element: ruff::InterpolatedStringElement,
-) -> ruff::FStringPart {
+    element: ast::InterpolatedStringElement,
+) -> ast::FStringPart {
     match element {
-        ruff::InterpolatedStringElement::Literal(value) => {
-            let ruff::InterpolatedStringLiteralElement {
+        ast::InterpolatedStringElement::Literal(value) => {
+            let ast::InterpolatedStringLiteralElement {
                 node_index,
                 range,
                 value,
             } = value;
-            ruff::FStringPart::Literal(ruff::StringLiteral {
+            ast::FStringPart::Literal(ast::StringLiteral {
                 node_index,
                 range,
                 value,
-                flags: ruff::StringLiteralFlags::empty(),
+                flags: ast::StringLiteralFlags::empty(),
             })
         }
-        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+        ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
             range, ..
-        }) => ruff::FStringPart::FString(ruff::FString {
+        }) => ast::FStringPart::FString(ast::FString {
             node_index: Default::default(),
             range,
             elements: vec![element].into(),
-            flags: ruff::FStringFlags::empty(),
+            flags: ast::FStringFlags::empty(),
         }),
     }
 }
 
 fn joined_str_to_ruff_format_spec(
     joined_str: Option<Box<JoinedStr>>,
-) -> Option<Box<ruff::InterpolatedStringFormatSpec>> {
+) -> Option<Box<ast::InterpolatedStringFormatSpec>> {
     match joined_str {
         None => None,
         Some(joined_str) => {
@@ -104,7 +103,7 @@ fn joined_str_to_ruff_format_spec(
             let elements: Vec<_> = Box::into_iter(values)
                 .map(joined_str_part_to_ruff_fstring_element)
                 .collect();
-            let format_spec = ruff::InterpolatedStringFormatSpec {
+            let format_spec = ast::InterpolatedStringFormatSpec {
                 node_index: Default::default(),
                 range,
                 elements: elements.into(),
@@ -121,32 +120,32 @@ pub(super) struct JoinedStr {
 }
 
 impl JoinedStr {
-    pub(super) fn into_expr(self) -> ruff::Expr {
+    pub(super) fn into_expr(self) -> ast::Expr {
         let Self { range, values } = self;
-        ruff::Expr::FString(ruff::ExprFString {
+        ast::Expr::FString(ast::ExprFString {
             node_index: Default::default(),
             range: Default::default(),
             value: match values.len() {
                 // ruff represents an empty fstring like this:
-                0 => ruff::FStringValue::single(ruff::FString {
+                0 => ast::FStringValue::single(ast::FString {
                     node_index: Default::default(),
                     range,
                     elements: vec![].into(),
-                    flags: ruff::FStringFlags::empty(),
+                    flags: ast::FStringFlags::empty(),
                 }),
-                1 => ruff::FStringValue::single(
+                1 => ast::FStringValue::single(
                     Box::<[_]>::into_iter(values)
                         .map(joined_str_part_to_ruff_fstring_element)
-                        .map(|element| ruff::FString {
+                        .map(|element| ast::FString {
                             node_index: Default::default(),
                             range,
                             elements: vec![element].into(),
-                            flags: ruff::FStringFlags::empty(),
+                            flags: ast::FStringFlags::empty(),
                         })
                         .next()
                         .expect("FString has exactly one part"),
                 ),
-                _ => ruff::FStringValue::concatenated(
+                _ => ast::FStringValue::concatenated(
                     Box::<[_]>::into_iter(values)
                         .map(joined_str_part_to_ruff_fstring_element)
                         .map(ruff_fstring_element_to_ruff_fstring_part)
@@ -157,10 +156,10 @@ impl JoinedStr {
     }
 }
 
-fn joined_str_part_to_ruff_fstring_element(part: JoinedStrPart) -> ruff::InterpolatedStringElement {
+fn joined_str_part_to_ruff_fstring_element(part: JoinedStrPart) -> ast::InterpolatedStringElement {
     match part {
         JoinedStrPart::FormattedValue(value) => {
-            ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
                 node_index: Default::default(),
                 range: value.range,
                 expression: value.value.clone(),
@@ -170,7 +169,7 @@ fn joined_str_part_to_ruff_fstring_element(part: JoinedStrPart) -> ruff::Interpo
             })
         }
         JoinedStrPart::Constant(value) => {
-            ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
                 node_index: Default::default(),
                 range: value.range,
                 value: match value.value {
@@ -254,8 +253,8 @@ impl Node for JoinedStrPart {
 
 #[derive(Debug)]
 pub(super) struct FormattedValue {
-    value: Box<ruff::Expr>,
-    conversion: ruff::ConversionFlag,
+    value: Box<ast::Expr>,
+    conversion: ast::ConversionFlag,
     format_spec: Option<Box<JoinedStr>>,
     range: TextRange,
 }
@@ -313,24 +312,24 @@ impl Node for FormattedValue {
 pub(super) fn fstring_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    expression: ruff::ExprFString,
+    expression: ast::ExprFString,
 ) -> PyObjectRef {
-    let ruff::ExprFString {
+    let ast::ExprFString {
         range,
         mut value,
         node_index: _,
     } = expression;
-    let default_part = ruff::FStringPart::FString(ruff::FString {
+    let default_part = ast::FStringPart::FString(ast::FString {
         node_index: Default::default(),
         range: Default::default(),
         elements: Default::default(),
-        flags: ruff::FStringFlags::empty(),
+        flags: ast::FStringFlags::empty(),
     });
     let mut values = Vec::new();
     for i in 0..value.as_slice().len() {
         let part = core::mem::replace(value.iter_mut().nth(i).unwrap(), default_part.clone());
         match part {
-            ruff::FStringPart::Literal(ruff::StringLiteral {
+            ast::FStringPart::Literal(ast::StringLiteral {
                 range,
                 value,
                 flags,
@@ -342,7 +341,7 @@ pub(super) fn fstring_to_object(
                     range,
                 )));
             }
-            ruff::FStringPart::FString(ruff::FString {
+            ast::FStringPart::FString(ast::FString {
                 range: _,
                 elements,
                 flags: _,
@@ -364,20 +363,20 @@ pub(super) fn fstring_to_object(
 // ===== TString (Template String) Support =====
 
 fn ruff_tstring_element_to_template_str_part(
-    element: ruff::InterpolatedStringElement,
+    element: ast::InterpolatedStringElement,
     source_file: &SourceFile,
 ) -> TemplateStrPart {
     match element {
-        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+        ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
             range,
             value,
             node_index: _,
         }) => TemplateStrPart::Constant(Constant::new_str(
             value,
-            ruff::str_prefix::StringLiteralPrefix::Empty,
+            ast::str_prefix::StringLiteralPrefix::Empty,
             range,
         )),
-        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+        ast::InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
             range,
             expression,
             debug_text,
@@ -401,13 +400,13 @@ fn ruff_tstring_element_to_template_str_part(
 }
 
 fn ruff_format_spec_to_template_str(
-    format_spec: Option<Box<ruff::InterpolatedStringFormatSpec>>,
+    format_spec: Option<Box<ast::InterpolatedStringFormatSpec>>,
     source_file: &SourceFile,
 ) -> Option<Box<TemplateStr>> {
     match format_spec {
         None => None,
         Some(format_spec) => {
-            let ruff::InterpolatedStringFormatSpec {
+            let ast::InterpolatedStringFormatSpec {
                 range,
                 elements,
                 node_index: _,
@@ -499,9 +498,9 @@ impl Node for TemplateStrPart {
 
 #[derive(Debug)]
 pub(super) struct TStringInterpolation {
-    value: Box<ruff::Expr>,
+    value: Box<ast::Expr>,
     str: String,
-    conversion: ruff::ConversionFlag,
+    conversion: ast::ConversionFlag,
     format_spec: Option<Box<TemplateStr>>,
     range: TextRange,
 }
@@ -565,18 +564,18 @@ impl Node for TStringInterpolation {
 pub(super) fn tstring_to_object(
     vm: &VirtualMachine,
     source_file: &SourceFile,
-    expression: ruff::ExprTString,
+    expression: ast::ExprTString,
 ) -> PyObjectRef {
-    let ruff::ExprTString {
+    let ast::ExprTString {
         range,
         mut value,
         node_index: _,
     } = expression;
-    let default_tstring = ruff::TString {
+    let default_tstring = ast::TString {
         node_index: Default::default(),
         range: Default::default(),
         elements: Default::default(),
-        flags: ruff::TStringFlags::empty(),
+        flags: ast::TStringFlags::empty(),
     };
     let mut values = Vec::new();
     for i in 0..value.as_slice().len() {
diff --git a/crates/vm/src/stdlib/ast/type_parameters.rs b/crates/vm/src/stdlib/ast/type_parameters.rs
index 017470f7e64..4801a9a4b28 100644
--- a/crates/vm/src/stdlib/ast/type_parameters.rs
+++ b/crates/vm/src/stdlib/ast/type_parameters.rs
@@ -1,7 +1,7 @@
 use super::*;
 use rustpython_compiler_core::SourceFile;
 
-impl Node for ruff::TypeParams {
+impl Node for ast::TypeParams {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         self.type_params.ast_to_object(vm, source_file)
     }
@@ -11,7 +11,7 @@ impl Node for ruff::TypeParams {
         _source_file: &SourceFile,
         _object: PyObjectRef,
     ) -> PyResult<Self> {
-        let type_params: Vec<ruff::TypeParam> = Node::ast_from_object(_vm, _source_file, _object)?;
+        let type_params: Vec<ast::TypeParam> = Node::ast_from_object(_vm, _source_file, _object)?;
         let range = Option::zip(type_params.first(), type_params.last())
             .map(|(first, last)| first.range().cover(last.range()))
             .unwrap_or_default();
@@ -28,7 +28,7 @@ impl Node for ruff::TypeParams {
 }
 
 // sum
-impl Node for ruff::TypeParam {
+impl Node for ast::TypeParam {
     fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::TypeVar(cons) => cons.ast_to_object(vm, source_file),
@@ -44,19 +44,19 @@ impl Node for ruff::TypeParam {
     ) -> PyResult<Self> {
         let _cls = _object.class();
         Ok(if _cls.is(pyast::NodeTypeParamTypeVar::static_type()) {
-            Self::TypeVar(ruff::TypeParamTypeVar::ast_from_object(
+            Self::TypeVar(ast::TypeParamTypeVar::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeTypeParamParamSpec::static_type()) {
-            Self::ParamSpec(ruff::TypeParamParamSpec::ast_from_object(
+            Self::ParamSpec(ast::TypeParamParamSpec::ast_from_object(
                 _vm,
                 source_file,
                 _object,
             )?)
         } else if _cls.is(pyast::NodeTypeParamTypeVarTuple::static_type()) {
-            Self::TypeVarTuple(ruff::TypeParamTypeVarTuple::ast_from_object(
+            Self::TypeVarTuple(ast::TypeParamTypeVarTuple::ast_from_object(
                 _vm,
                 source_file,
                 _object,
@@ -71,7 +71,7 @@ impl Node for ruff::TypeParam {
 }
 
 // constructor
-impl Node for ruff::TypeParamTypeVar {
+impl Node for ast::TypeParamTypeVar {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -118,7 +118,7 @@ impl Node for ruff::TypeParamTypeVar {
 }
 
 // constructor
-impl Node for ruff::TypeParamParamSpec {
+impl Node for ast::TypeParamParamSpec {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,
@@ -165,7 +165,7 @@ impl Node for ruff::TypeParamParamSpec {
 }
 
 // constructor
-impl Node for ruff::TypeParamTypeVarTuple {
+impl Node for ast::TypeParamTypeVarTuple {
     fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
             node_index: _,

From 941a7bb784bd315e25fab907d4f50fccc83c7bc6 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 18:02:57 +0900
Subject: [PATCH 355/418] setup ndk on CI (#6773)

---
 .github/workflows/ci.yaml | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 5b756e8af7e..b626503c5b4 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -210,8 +210,19 @@ jobs:
         with:
           target: aarch64-linux-android
 
+      - name: Setup Android NDK
+        id: setup-ndk
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r27
+          add-to-path: true
+
       - name: Check compilation for android
         run: cargo check --target aarch64-linux-android ${{ env.CARGO_ARGS_NO_SSL }}
+        env:
+          CC_aarch64_linux_android: ${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang
+          AR_aarch64_linux_android: ${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar
+          CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: ${{ steps.setup-ndk.outputs.ndk-path }}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang
 
       - uses: dtolnay/rust-toolchain@stable
         with:

From f8a78e6ab632e9a1825bd90099b58343756802d9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 18:09:55 +0900
Subject: [PATCH 356/418] stack soft limit (#6754)

---
 Cargo.lock                 |  29 +++++++++
 crates/vm/Cargo.toml       |   1 +
 crates/vm/src/vm/mod.rs    | 119 +++++++++++++++++++++++++++++++++++++
 crates/vm/src/vm/thread.rs |   1 +
 4 files changed, 150 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 41ab3280428..8df208e4aaa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -142,6 +142,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "ar_archive_writer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
+dependencies = [
+ "object",
+]
+
 [[package]]
 name = "arbitrary"
 version = "1.4.2"
@@ -2081,6 +2090,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "oid-registry"
 version = "0.8.1"
@@ -2448,6 +2466,16 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "psm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d11f2fedc3b7dafdc2851bc52f277377c5473d378859be234bc7ebb593144d01"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+
 [[package]]
 name = "pymath"
 version = "0.1.5"
@@ -3280,6 +3308,7 @@ dependencies = [
  "optional",
  "parking_lot",
  "paste",
+ "psm",
  "result-like",
  "ruff_python_ast",
  "ruff_python_parser",
diff --git a/crates/vm/Cargo.toml b/crates/vm/Cargo.toml
index b74aba41145..da01eff65b9 100644
--- a/crates/vm/Cargo.toml
+++ b/crates/vm/Cargo.toml
@@ -77,6 +77,7 @@ memchr = { workspace = true }
 caseless = "0.2.2"
 flamer = { version = "0.5", optional = true }
 half = "2"
+psm = "0.1"
 optional = { workspace = true }
 result-like = "0.5.0"
 timsort = "0.1.2"
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 0c29d34ef88..5bd2b9e8297 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -86,6 +86,8 @@ pub struct VirtualMachine {
     pub state: PyRc<PyGlobalState>,
     pub initialized: bool,
     recursion_depth: Cell<usize>,
+    /// C stack soft limit for detecting stack overflow (like c_stack_soft_limit)
+    c_stack_soft_limit: Cell<usize>,
     /// Async generator firstiter hook (per-thread, set via sys.set_asyncgen_hooks)
     pub async_gen_firstiter: RefCell<Option<PyObjectRef>>,
     /// Async generator finalizer hook (per-thread, set via sys.set_asyncgen_hooks)
@@ -228,6 +230,7 @@ impl VirtualMachine {
             }),
             initialized: false,
             recursion_depth: Cell::new(0),
+            c_stack_soft_limit: Cell::new(Self::calculate_c_stack_soft_limit()),
             async_gen_firstiter: RefCell::new(None),
             async_gen_finalizer: RefCell::new(None),
         };
@@ -689,11 +692,127 @@ impl VirtualMachine {
         self.recursion_depth.get()
     }
 
+    /// Stack margin bytes (like _PyOS_STACK_MARGIN_BYTES).
+    /// 2048 * sizeof(void*) = 16KB for 64-bit.
+    const STACK_MARGIN_BYTES: usize = 2048 * std::mem::size_of::<usize>();
+
+    /// Get the stack boundaries using platform-specific APIs.
+    /// Returns (base, top) where base is the lowest address and top is the highest.
+    #[cfg(all(not(miri), windows))]
+    fn get_stack_bounds() -> (usize, usize) {
+        use windows_sys::Win32::System::Threading::{
+            GetCurrentThreadStackLimits, SetThreadStackGuarantee,
+        };
+        let mut low: usize = 0;
+        let mut high: usize = 0;
+        unsafe {
+            GetCurrentThreadStackLimits(&mut low as *mut usize, &mut high as *mut usize);
+            // Add the guaranteed stack space (reserved for exception handling)
+            let mut guarantee: u32 = 0;
+            SetThreadStackGuarantee(&mut guarantee);
+            low += guarantee as usize;
+        }
+        (low, high)
+    }
+
+    /// Get stack boundaries on non-Windows platforms.
+    /// Falls back to estimating based on current stack pointer.
+    #[cfg(all(not(miri), not(windows)))]
+    fn get_stack_bounds() -> (usize, usize) {
+        // Use pthread_attr_getstack on platforms that support it
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        {
+            use libc::{
+                pthread_attr_destroy, pthread_attr_getstack, pthread_attr_t, pthread_getattr_np,
+                pthread_self,
+            };
+            let mut attr: pthread_attr_t = unsafe { std::mem::zeroed() };
+            unsafe {
+                if pthread_getattr_np(pthread_self(), &mut attr) == 0 {
+                    let mut stack_addr: *mut libc::c_void = std::ptr::null_mut();
+                    let mut stack_size: libc::size_t = 0;
+                    if pthread_attr_getstack(&attr, &mut stack_addr, &mut stack_size) == 0 {
+                        pthread_attr_destroy(&mut attr);
+                        let base = stack_addr as usize;
+                        let top = base + stack_size;
+                        return (base, top);
+                    }
+                    pthread_attr_destroy(&mut attr);
+                }
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            use libc::{pthread_get_stackaddr_np, pthread_get_stacksize_np, pthread_self};
+            unsafe {
+                let thread = pthread_self();
+                let stack_top = pthread_get_stackaddr_np(thread) as usize;
+                let stack_size = pthread_get_stacksize_np(thread);
+                let stack_base = stack_top - stack_size;
+                return (stack_base, stack_top);
+            }
+        }
+
+        // Fallback: estimate based on current SP and a default stack size
+        #[allow(unreachable_code)]
+        {
+            let current_sp = psm::stack_pointer() as usize;
+            // Assume 8MB stack, estimate base
+            let estimated_size = 8 * 1024 * 1024;
+            let base = current_sp.saturating_sub(estimated_size);
+            let top = current_sp + 1024 * 1024; // Assume we're not at the very top
+            (base, top)
+        }
+    }
+
+    /// Calculate the C stack soft limit based on actual stack boundaries.
+    /// soft_limit = base + 2 * margin (for downward-growing stacks)
+    #[cfg(not(miri))]
+    fn calculate_c_stack_soft_limit() -> usize {
+        let (base, _top) = Self::get_stack_bounds();
+        // Soft limit is 2 margins above the base
+        base + Self::STACK_MARGIN_BYTES * 2
+    }
+
+    /// Miri doesn't support inline assembly, so disable C stack checking.
+    #[cfg(miri)]
+    fn calculate_c_stack_soft_limit() -> usize {
+        0
+    }
+
+    /// Check if we're near the C stack limit (like _Py_MakeRecCheck).
+    /// Returns true only when stack pointer is in the "danger zone" between
+    /// soft_limit and hard_limit (soft_limit - 2*margin).
+    #[cfg(not(miri))]
+    #[inline(always)]
+    fn check_c_stack_overflow(&self) -> bool {
+        let current_sp = psm::stack_pointer() as usize;
+        let soft_limit = self.c_stack_soft_limit.get();
+        // Stack grows downward: check if we're below soft limit but above hard limit
+        // This matches CPython's _Py_MakeRecCheck behavior
+        current_sp < soft_limit
+            && current_sp >= soft_limit.saturating_sub(Self::STACK_MARGIN_BYTES * 2)
+    }
+
+    /// Miri doesn't support inline assembly, so always return false.
+    #[cfg(miri)]
+    #[inline(always)]
+    fn check_c_stack_overflow(&self) -> bool {
+        false
+    }
+
     /// Used to run the body of a (possibly) recursive function. It will raise a
     /// RecursionError if recursive functions are nested far too many times,
     /// preventing a stack overflow.
     pub fn with_recursion<R, F: FnOnce() -> PyResult<R>>(&self, _where: &str, f: F) -> PyResult<R> {
         self.check_recursive_call(_where)?;
+
+        // Native stack guard: check C stack like _Py_MakeRecCheck
+        if self.check_c_stack_overflow() {
+            return Err(self.new_recursion_error(_where.to_string()));
+        }
+
         self.recursion_depth.set(self.recursion_depth.get() + 1);
         let result = f();
         self.recursion_depth.set(self.recursion_depth.get() - 1);
diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs
index 7188aa6d270..bfbfc4f6a04 100644
--- a/crates/vm/src/vm/thread.rs
+++ b/crates/vm/src/vm/thread.rs
@@ -234,6 +234,7 @@ impl VirtualMachine {
             state: self.state.clone(),
             initialized: self.initialized,
             recursion_depth: Cell::new(0),
+            c_stack_soft_limit: Cell::new(VirtualMachine::calculate_c_stack_soft_limit()),
             async_gen_firstiter: RefCell::new(None),
             async_gen_finalizer: RefCell::new(None),
         };

From e8dd5826e6be1fff6af77c46da8c9fdeebe68ed2 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 19:16:02 +0900
Subject: [PATCH 357/418] init warnings before site (#6771)

---
 src/lib.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 11f6dc01c35..cf5227a70dd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -208,6 +208,12 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
 
     let scope = vm.new_scope_with_main()?;
 
+    // Initialize warnings module to process sys.warnoptions
+    // _PyWarnings_Init()
+    if vm.import("warnings", 0).is_err() {
+        warn!("Failed to import warnings module");
+    }
+
     // Import site first, before setting sys.path[0]
     // This matches CPython's behavior where site.removeduppaths() runs
     // before sys.path[0] is set, preventing '' from being converted to cwd
@@ -219,12 +225,6 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         );
     }
 
-    // Initialize warnings module to process sys.warnoptions
-    // _PyWarnings_Init()
-    if vm.import("warnings", 0).is_err() {
-        warn!("Failed to import warnings module");
-    }
-
     // _PyPathConfig_ComputeSysPath0 - set sys.path[0] after site import
     if !vm.state.config.settings.safe_path {
         let path0: Option<String> = match &run_mode {

From 5242ff5243086b306e72be2713b76db7868d67e6 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Sun, 18 Jan 2026 19:16:48 +0900
Subject: [PATCH 358/418] Bump json to 3.14.2 (#6774)

---
 Lib/json/__init__.py                  |   6 +-
 Lib/json/__main__.py                  |  20 ++++
 Lib/json/encoder.py                   | 119 +++++++++++----------
 Lib/json/tool.py                      |  64 +++++++++---
 Lib/test/test_json/__init__.py        |   3 +-
 Lib/test/test_json/test_decode.py     |   6 +-
 Lib/test/test_json/test_default.py    |  21 ++++
 Lib/test/test_json/test_fail.py       |  27 ++++-
 Lib/test/test_json/test_recursion.py  |  39 ++++---
 Lib/test/test_json/test_scanstring.py |   3 +-
 Lib/test/test_json/test_speedups.py   |   9 +-
 Lib/test/test_json/test_tool.py       | 143 ++++++++++++++++++++++----
 Lib/test/test_json/test_unicode.py    |   3 +-
 13 files changed, 340 insertions(+), 123 deletions(-)
 create mode 100644 Lib/json/__main__.py

diff --git a/Lib/json/__init__.py b/Lib/json/__init__.py
index c7a6dcdf77e..9eaa4f3fbc1 100644
--- a/Lib/json/__init__.py
+++ b/Lib/json/__init__.py
@@ -86,13 +86,13 @@
     '[2.0, 1.0]'
 
 
-Using json.tool from the shell to validate and pretty-print::
+Using json from the shell to validate and pretty-print::
 
-    $ echo '{"json":"obj"}' | python -m json.tool
+    $ echo '{"json":"obj"}' | python -m json
     {
         "json": "obj"
     }
-    $ echo '{ 1.2:3.4}' | python -m json.tool
+    $ echo '{ 1.2:3.4}' | python -m json
     Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
 """
 __version__ = '2.0.9'
diff --git a/Lib/json/__main__.py b/Lib/json/__main__.py
new file mode 100644
index 00000000000..1808eaddb62
--- /dev/null
+++ b/Lib/json/__main__.py
@@ -0,0 +1,20 @@
+"""Command-line tool to validate and pretty-print JSON
+
+Usage::
+
+    $ echo '{"json":"obj"}' | python -m json
+    {
+        "json": "obj"
+    }
+    $ echo '{ 1.2:3.4}' | python -m json
+    Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
+
+"""
+import json.tool
+
+
+if __name__ == '__main__':
+    try:
+        json.tool.main()
+    except BrokenPipeError as exc:
+        raise SystemExit(exc.errno)
diff --git a/Lib/json/encoder.py b/Lib/json/encoder.py
index 0671500d106..5cf6d64f3ea 100644
--- a/Lib/json/encoder.py
+++ b/Lib/json/encoder.py
@@ -295,37 +295,40 @@ def _iterencode_list(lst, _current_indent_level):
         else:
             newline_indent = None
             separator = _item_separator
-        first = True
-        for value in lst:
-            if first:
-                first = False
-            else:
+        for i, value in enumerate(lst):
+            if i:
                 buf = separator
-            if isinstance(value, str):
-                yield buf + _encoder(value)
-            elif value is None:
-                yield buf + 'null'
-            elif value is True:
-                yield buf + 'true'
-            elif value is False:
-                yield buf + 'false'
-            elif isinstance(value, int):
-                # Subclasses of int/float may override __repr__, but we still
-                # want to encode them as integers/floats in JSON. One example
-                # within the standard library is IntEnum.
-                yield buf + _intstr(value)
-            elif isinstance(value, float):
-                # see comment above for int
-                yield buf + _floatstr(value)
-            else:
-                yield buf
-                if isinstance(value, (list, tuple)):
-                    chunks = _iterencode_list(value, _current_indent_level)
-                elif isinstance(value, dict):
-                    chunks = _iterencode_dict(value, _current_indent_level)
+            try:
+                if isinstance(value, str):
+                    yield buf + _encoder(value)
+                elif value is None:
+                    yield buf + 'null'
+                elif value is True:
+                    yield buf + 'true'
+                elif value is False:
+                    yield buf + 'false'
+                elif isinstance(value, int):
+                    # Subclasses of int/float may override __repr__, but we still
+                    # want to encode them as integers/floats in JSON. One example
+                    # within the standard library is IntEnum.
+                    yield buf + _intstr(value)
+                elif isinstance(value, float):
+                    # see comment above for int
+                    yield buf + _floatstr(value)
                 else:
-                    chunks = _iterencode(value, _current_indent_level)
-                yield from chunks
+                    yield buf
+                    if isinstance(value, (list, tuple)):
+                        chunks = _iterencode_list(value, _current_indent_level)
+                    elif isinstance(value, dict):
+                        chunks = _iterencode_dict(value, _current_indent_level)
+                    else:
+                        chunks = _iterencode(value, _current_indent_level)
+                    yield from chunks
+            except GeneratorExit:
+                raise
+            except BaseException as exc:
+                exc.add_note(f'when serializing {type(lst).__name__} item {i}')
+                raise
         if newline_indent is not None:
             _current_indent_level -= 1
             yield '\n' + _indent * _current_indent_level
@@ -385,28 +388,34 @@ def _iterencode_dict(dct, _current_indent_level):
                 yield item_separator
             yield _encoder(key)
             yield _key_separator
-            if isinstance(value, str):
-                yield _encoder(value)
-            elif value is None:
-                yield 'null'
-            elif value is True:
-                yield 'true'
-            elif value is False:
-                yield 'false'
-            elif isinstance(value, int):
-                # see comment for int/float in _make_iterencode
-                yield _intstr(value)
-            elif isinstance(value, float):
-                # see comment for int/float in _make_iterencode
-                yield _floatstr(value)
-            else:
-                if isinstance(value, (list, tuple)):
-                    chunks = _iterencode_list(value, _current_indent_level)
-                elif isinstance(value, dict):
-                    chunks = _iterencode_dict(value, _current_indent_level)
+            try:
+                if isinstance(value, str):
+                    yield _encoder(value)
+                elif value is None:
+                    yield 'null'
+                elif value is True:
+                    yield 'true'
+                elif value is False:
+                    yield 'false'
+                elif isinstance(value, int):
+                    # see comment for int/float in _make_iterencode
+                    yield _intstr(value)
+                elif isinstance(value, float):
+                    # see comment for int/float in _make_iterencode
+                    yield _floatstr(value)
                 else:
-                    chunks = _iterencode(value, _current_indent_level)
-                yield from chunks
+                    if isinstance(value, (list, tuple)):
+                        chunks = _iterencode_list(value, _current_indent_level)
+                    elif isinstance(value, dict):
+                        chunks = _iterencode_dict(value, _current_indent_level)
+                    else:
+                        chunks = _iterencode(value, _current_indent_level)
+                    yield from chunks
+            except GeneratorExit:
+                raise
+            except BaseException as exc:
+                exc.add_note(f'when serializing {type(dct).__name__} item {key!r}')
+                raise
         if not first and newline_indent is not None:
             _current_indent_level -= 1
             yield '\n' + _indent * _current_indent_level
@@ -439,8 +448,14 @@ def _iterencode(o, _current_indent_level):
                 if markerid in markers:
                     raise ValueError("Circular reference detected")
                 markers[markerid] = o
-            o = _default(o)
-            yield from _iterencode(o, _current_indent_level)
+            newobj = _default(o)
+            try:
+                yield from _iterencode(newobj, _current_indent_level)
+            except GeneratorExit:
+                raise
+            except BaseException as exc:
+                exc.add_note(f'when serializing {type(o).__name__} object')
+                raise
             if markers is not None:
                 del markers[markerid]
     return _iterencode
diff --git a/Lib/json/tool.py b/Lib/json/tool.py
index fdfc3372bcc..1967817add8 100644
--- a/Lib/json/tool.py
+++ b/Lib/json/tool.py
@@ -1,25 +1,50 @@
-r"""Command-line tool to validate and pretty-print JSON
-
-Usage::
-
-    $ echo '{"json":"obj"}' | python -m json.tool
-    {
-        "json": "obj"
-    }
-    $ echo '{ 1.2:3.4}' | python -m json.tool
-    Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
+"""Command-line tool to validate and pretty-print JSON
 
+See `json.__main__` for a usage example (invocation as
+`python -m json.tool` is supported for backwards compatibility).
 """
 import argparse
 import json
+import re
 import sys
+from _colorize import get_theme, can_colorize
+
+
+# The string we are colorizing is valid JSON,
+# so we can use a looser but simpler regex to match
+# the various parts, most notably strings and numbers,
+# where the regex given by the spec is much more complex.
+_color_pattern = re.compile(r'''
+    (?P<key>"(\\.|[^"\\])*")(?=:)           |
+    (?P<string>"(\\.|[^"\\])*")             |
+    (?P<number>NaN|-?Infinity|[0-9\-+.Ee]+) |
+    (?P<boolean>true|false)                 |
+    (?P<null>null)
+''', re.VERBOSE)
+
+_group_to_theme_color = {
+    "key": "definition",
+    "string": "string",
+    "number": "number",
+    "boolean": "keyword",
+    "null": "keyword",
+}
+
+
+def _colorize_json(json_str, theme):
+    def _replace_match_callback(match):
+        for group, color in _group_to_theme_color.items():
+            if m := match.group(group):
+                return f"{theme[color]}{m}{theme.reset}"
+        return match.group()
+
+    return re.sub(_color_pattern, _replace_match_callback, json_str)
 
 
 def main():
-    prog = 'python -m json.tool'
     description = ('A simple command line interface for json module '
                    'to validate and pretty-print JSON objects.')
-    parser = argparse.ArgumentParser(prog=prog, description=description)
+    parser = argparse.ArgumentParser(description=description, color=True)
     parser.add_argument('infile', nargs='?',
                         help='a JSON file to be validated or pretty-printed',
                         default='-')
@@ -75,9 +100,16 @@ def main():
         else:
             outfile = open(options.outfile, 'w', encoding='utf-8')
         with outfile:
-            for obj in objs:
-                json.dump(obj, outfile, **dump_args)
-                outfile.write('\n')
+            if can_colorize(file=outfile):
+                t = get_theme(tty_file=outfile).syntax
+                for obj in objs:
+                    json_str = json.dumps(obj, **dump_args)
+                    outfile.write(_colorize_json(json_str, t))
+                    outfile.write('\n')
+            else:
+                for obj in objs:
+                    json.dump(obj, outfile, **dump_args)
+                    outfile.write('\n')
     except ValueError as e:
         raise SystemExit(e)
 
@@ -86,4 +118,4 @@ def main():
     try:
         main()
     except BrokenPipeError as exc:
-        sys.exit(exc.errno)
+        raise SystemExit(exc.errno)
diff --git a/Lib/test/test_json/__init__.py b/Lib/test/test_json/__init__.py
index b919af2328f..7091364cddb 100644
--- a/Lib/test/test_json/__init__.py
+++ b/Lib/test/test_json/__init__.py
@@ -41,8 +41,7 @@ def test_pyjson(self):
                          'json.encoder')
 
 class TestCTest(CTest):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cjson(self):
         self.assertEqual(self.json.scanner.make_scanner.__module__, '_json')
         self.assertEqual(self.json.decoder.scanstring.__module__, '_json')
diff --git a/Lib/test/test_json/test_decode.py b/Lib/test/test_json/test_decode.py
index ad37d47f083..b6531b237c0 100644
--- a/Lib/test/test_json/test_decode.py
+++ b/Lib/test/test_json/test_decode.py
@@ -18,8 +18,7 @@ def test_float(self):
         self.assertIsInstance(rval, float)
         self.assertEqual(rval, 1.0)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON; called `Result::unwrap()` on an `Err` value: ParseFloatError { kind: Invalid }")
+    @unittest.skip('TODO: RUSTPYTHON; called `Result::unwrap()` on an `Err` value: ParseFloatError { kind: Invalid }')
     def test_nonascii_digits_rejected(self):
         # JSON specifies only ascii digits, see gh-125687
         for num in ["1\uff10", "0.\uff10", "0e\uff10"]:
@@ -138,9 +137,6 @@ def test_limit_int(self):
 class TestPyDecode(TestDecode, PyTest): pass
 
 class TestCDecode(TestDecode, CTest):
-    def test_keys_reuse(self):
-        return super().test_keys_reuse()
-
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_limit_int(self):
diff --git a/Lib/test/test_json/test_default.py b/Lib/test/test_json/test_default.py
index 3ce16684a08..b576947c4f2 100644
--- a/Lib/test/test_json/test_default.py
+++ b/Lib/test/test_json/test_default.py
@@ -1,4 +1,5 @@
 import collections
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
 from test.test_json import PyTest, CTest
 
 
@@ -8,6 +9,26 @@ def test_default(self):
             self.dumps(type, default=repr),
             self.dumps(repr(type)))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bad_default(self):
+        def default(obj):
+            if obj is NotImplemented:
+                raise ValueError
+            if obj is ...:
+                return NotImplemented
+            if obj is type:
+                return collections
+            return [...]
+
+        with self.assertRaises(ValueError) as cm:
+            self.dumps(type, default=default)
+        self.assertEqual(cm.exception.__notes__,
+                         ['when serializing ellipsis object',
+                          'when serializing list item 0',
+                          'when serializing module object',
+                          'when serializing type object'])
+
     def test_ordereddict(self):
         od = collections.OrderedDict(a=1, b=2, c=3, d=4)
         od.move_to_end('b')
diff --git a/Lib/test/test_json/test_fail.py b/Lib/test/test_json/test_fail.py
index 7a85665c816..48c974a3300 100644
--- a/Lib/test/test_json/test_fail.py
+++ b/Lib/test/test_json/test_fail.py
@@ -1,7 +1,7 @@
-from test.test_json import PyTest, CTest
-
 import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
 
+from test.test_json import PyTest, CTest
+
 # 2007-10-05
 JSONDOCS = [
     # https://json.org/JSON_checker/test/fail1.json
@@ -99,11 +99,32 @@ def test_non_string_keys_dict(self):
                 'keys must be str, int, float, bool or None, not tuple'):
             self.dumps(data)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_not_serializable(self):
         import sys
         with self.assertRaisesRegex(TypeError,
-                'Object of type module is not JSON serializable'):
+                'Object of type module is not JSON serializable') as cm:
             self.dumps(sys)
+        self.assertNotHasAttr(cm.exception, '__notes__')
+
+        with self.assertRaises(TypeError) as cm:
+            self.dumps([1, [2, 3, sys]])
+        self.assertEqual(cm.exception.__notes__,
+                         ['when serializing list item 2',
+                          'when serializing list item 1'])
+
+        with self.assertRaises(TypeError) as cm:
+            self.dumps((1, (2, 3, sys)))
+        self.assertEqual(cm.exception.__notes__,
+                         ['when serializing tuple item 2',
+                          'when serializing tuple item 1'])
+
+        with self.assertRaises(TypeError) as cm:
+            self.dumps({'a': {'b': sys}})
+        self.assertEqual(cm.exception.__notes__,
+                         ["when serializing dict item 'b'",
+                          "when serializing dict item 'a'"])
 
     def test_truncated_input(self):
         test_cases = [
diff --git a/Lib/test/test_json/test_recursion.py b/Lib/test/test_json/test_recursion.py
index 59f6f2c4b19..2a24edef629 100644
--- a/Lib/test/test_json/test_recursion.py
+++ b/Lib/test/test_json/test_recursion.py
@@ -14,8 +14,8 @@ def test_listrecursion(self):
         x.append(x)
         try:
             self.dumps(x)
-        except ValueError:
-            pass
+        except ValueError as exc:
+            self.assertEqual(exc.__notes__, ["when serializing list item 0"])
         else:
             self.fail("didn't raise ValueError on list recursion")
         x = []
@@ -23,8 +23,8 @@ def test_listrecursion(self):
         x.append(y)
         try:
             self.dumps(x)
-        except ValueError:
-            pass
+        except ValueError as exc:
+            self.assertEqual(exc.__notes__, ["when serializing list item 0"]*2)
         else:
             self.fail("didn't raise ValueError on alternating list recursion")
         y = []
@@ -37,8 +37,8 @@ def test_dictrecursion(self):
         x["test"] = x
         try:
             self.dumps(x)
-        except ValueError:
-            pass
+        except ValueError as exc:
+            self.assertEqual(exc.__notes__, ["when serializing dict item 'test'"])
         else:
             self.fail("didn't raise ValueError on dict recursion")
         x = {}
@@ -62,31 +62,41 @@ def default(self, o):
         enc.recurse = True
         try:
             enc.encode(JSONTestObject)
-        except ValueError:
-            pass
+        except ValueError as exc:
+            self.assertEqual(exc.__notes__,
+                             ["when serializing list item 0",
+                              "when serializing type object"])
         else:
             self.fail("didn't raise ValueError on default recursion")
 
+
     # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON; crashes")
+    @unittest.skip('TODO: RUSTPYTHON; crashes')
+    # TODO: RUSTPYHTON; needs to upgrade test.support to 3.14 above
+    # @support.skip_emscripten_stack_overflow()
+    # @support.skip_wasi_stack_overflow()
     def test_highly_nested_objects_decoding(self):
+        very_deep = 200000
         # test that loading highly-nested objects doesn't segfault when C
         # accelerations are used. See #12017
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('{"a":' * 100000 + '1' + '}' * 100000)
+                self.loads('{"a":' * very_deep + '1' + '}' * very_deep)
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('{"a":' * 100000 + '[1]' + '}' * 100000)
+                self.loads('{"a":' * very_deep + '[1]' + '}' * very_deep)
         with self.assertRaises(RecursionError):
             with support.infinite_recursion():
-                self.loads('[' * 100000 + '1' + ']' * 100000)
+                self.loads('[' * very_deep + '1' + ']' * very_deep)
 
+    # TODO: RUSTPYHTON; needs to upgrade test.support to 3.14 above
+    # @support.skip_wasi_stack_overflow()
+    # @support.skip_emscripten_stack_overflow()
     @support.requires_resource('cpu')
     def test_highly_nested_objects_encoding(self):
         # See #12051
         l, d = [], {}
-        for x in range(100000):
+        for x in range(200_000):
             l, d = [l], {'k':d}
         with self.assertRaises(RecursionError):
             with support.infinite_recursion(5000):
@@ -95,6 +105,9 @@ def test_highly_nested_objects_encoding(self):
             with support.infinite_recursion(5000):
                 self.dumps(d)
 
+    # TODO: RUSTPYHTON; needs to upgrade test.support to 3.14 above
+    # @support.skip_emscripten_stack_overflow()
+    # @support.skip_wasi_stack_overflow()
     def test_endless_recursion(self):
         # See #12051
         class EndlessJSONEncoder(self.json.JSONEncoder):
diff --git a/Lib/test/test_json/test_scanstring.py b/Lib/test/test_json/test_scanstring.py
index d6922c3b1b9..c7fc30f2235 100644
--- a/Lib/test/test_json/test_scanstring.py
+++ b/Lib/test/test_json/test_scanstring.py
@@ -144,8 +144,7 @@ def test_bad_escapes(self):
             with self.assertRaises(self.JSONDecodeError, msg=s):
                 scanstring(s, 1, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_overflow(self):
         with self.assertRaises(OverflowError):
             self.json.decoder.scanstring("xxx", sys.maxsize+1)
diff --git a/Lib/test/test_json/test_speedups.py b/Lib/test/test_json/test_speedups.py
index ada96729123..25b51b307e1 100644
--- a/Lib/test/test_json/test_speedups.py
+++ b/Lib/test/test_json/test_speedups.py
@@ -40,8 +40,7 @@ def test_make_encoder(self):
             b"\xCD\x7D\x3D\x4E\x12\x4C\xF9\x79\xD7\x52\xBA\x82\xF2\x27\x4A\x7D\xA0\xCA\x75",
             None)
 
-    # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not callable
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not callable
     def test_bad_str_encoder(self):
         # Issue #31505: There shouldn't be an assertion failure in case
         # c_make_encoder() receives a bad encoder() argument.
@@ -63,8 +62,7 @@ def bad_encoder2(*args):
         with self.assertRaises(ZeroDivisionError):
             enc('spam', 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_markers_argument_to_encoder(self):
         # https://bugs.python.org/issue45269
         with self.assertRaisesRegex(
@@ -74,8 +72,7 @@ def test_bad_markers_argument_to_encoder(self):
             self.json.encoder.c_make_encoder(1, None, None, None, ': ', ', ',
                                              False, False, False)
 
-    # TODO: RUSTPYTHON; ZeroDivisionError not raised by test
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ZeroDivisionError not raised by test
     def test_bad_bool_args(self):
         def test(name):
             self.json.encoder.JSONEncoder(**{name: BadBool()}).encode({'a': 1})
diff --git a/Lib/test/test_json/test_tool.py b/Lib/test/test_json/test_tool.py
index 2b63810d539..c60e58526f4 100644
--- a/Lib/test/test_json/test_tool.py
+++ b/Lib/test/test_json/test_tool.py
@@ -6,12 +6,23 @@
 import subprocess
 
 from test import support
-from test.support import os_helper
+from test.support import force_not_colorized, os_helper
 from test.support.script_helper import assert_python_ok
 
+from _colorize import get_theme
+
+# XXX: RUSTPYTHON; force_colorized not available in test.support
+def force_colorized(func):
+    """Placeholder decorator for RustPython - force_colorized not available."""
+    import functools
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        raise unittest.SkipTest("TODO: RUSTPYTHON; force_colorized not available")
+    return wrapper
+
 
 @support.requires_subprocess()
-class TestTool(unittest.TestCase):
+class TestMain(unittest.TestCase):
     data = """
 
         [["blorpie"],[ "whoops" ] , [
@@ -19,6 +30,7 @@ class TestTool(unittest.TestCase):
         "i-vhbjkhnth", {"nifty":87}, {"morefield" :\tfalse,"field"
             :"yes"}  ]
            """
+    module = 'json'
 
     expect_without_sort_keys = textwrap.dedent("""\
     [
@@ -86,8 +98,9 @@ class TestTool(unittest.TestCase):
     }
     """)
 
+    @force_not_colorized
     def test_stdin_stdout(self):
-        args = sys.executable, '-m', 'json.tool'
+        args = sys.executable, '-m', self.module
         process = subprocess.run(args, input=self.data, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, self.expect)
         self.assertEqual(process.stderr, '')
@@ -101,7 +114,8 @@ def _create_infile(self, data=None):
 
     def test_infile_stdout(self):
         infile = self._create_infile()
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile)
+        rc, out, err = assert_python_ok('-m', self.module, infile,
+                                        PYTHON_COLORS='0')
         self.assertEqual(rc, 0)
         self.assertEqual(out.splitlines(), self.expect.encode().splitlines())
         self.assertEqual(err, b'')
@@ -115,7 +129,8 @@ def test_non_ascii_infile(self):
         ''').encode()
 
         infile = self._create_infile(data)
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile)
+        rc, out, err = assert_python_ok('-m', self.module, infile,
+                                        PYTHON_COLORS='0')
 
         self.assertEqual(rc, 0)
         self.assertEqual(out.splitlines(), expect.splitlines())
@@ -124,7 +139,8 @@ def test_non_ascii_infile(self):
     def test_infile_outfile(self):
         infile = self._create_infile()
         outfile = os_helper.TESTFN + '.out'
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile, outfile)
+        rc, out, err = assert_python_ok('-m', self.module, infile, outfile,
+                                        PYTHON_COLORS='0')
         self.addCleanup(os.remove, outfile)
         with open(outfile, "r", encoding="utf-8") as fp:
             self.assertEqual(fp.read(), self.expect)
@@ -134,33 +150,39 @@ def test_infile_outfile(self):
 
     def test_writing_in_place(self):
         infile = self._create_infile()
-        rc, out, err = assert_python_ok('-m', 'json.tool', infile, infile)
+        rc, out, err = assert_python_ok('-m', self.module, infile, infile,
+                                        PYTHON_COLORS='0')
         with open(infile, "r", encoding="utf-8") as fp:
             self.assertEqual(fp.read(), self.expect)
         self.assertEqual(rc, 0)
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+    @force_not_colorized
     def test_jsonlines(self):
-        args = sys.executable, '-m', 'json.tool', '--json-lines'
+        args = sys.executable, '-m', self.module, '--json-lines'
         process = subprocess.run(args, input=self.jsonlines_raw, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, self.jsonlines_expect)
         self.assertEqual(process.stderr, '')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_help_flag(self):
-        rc, out, err = assert_python_ok('-m', 'json.tool', '-h')
+        rc, out, err = assert_python_ok('-m', self.module, '-h',
+                                        PYTHON_COLORS='0')
         self.assertEqual(rc, 0)
-        self.assertTrue(out.startswith(b'usage: '))
+        self.assertStartsWith(out, b'usage: ')
         self.assertEqual(err, b'')
 
     def test_sort_keys_flag(self):
         infile = self._create_infile()
-        rc, out, err = assert_python_ok('-m', 'json.tool', '--sort-keys', infile)
+        rc, out, err = assert_python_ok('-m', self.module, '--sort-keys', infile,
+                                        PYTHON_COLORS='0')
         self.assertEqual(rc, 0)
         self.assertEqual(out.splitlines(),
                          self.expect_without_sort_keys.encode().splitlines())
         self.assertEqual(err, b'')
 
+    @force_not_colorized
     def test_indent(self):
         input_ = '[1, 2]'
         expect = textwrap.dedent('''\
@@ -169,31 +191,34 @@ def test_indent(self):
           2
         ]
         ''')
-        args = sys.executable, '-m', 'json.tool', '--indent', '2'
+        args = sys.executable, '-m', self.module, '--indent', '2'
         process = subprocess.run(args, input=input_, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, expect)
         self.assertEqual(process.stderr, '')
 
+    @force_not_colorized
     def test_no_indent(self):
         input_ = '[1,\n2]'
         expect = '[1, 2]\n'
-        args = sys.executable, '-m', 'json.tool', '--no-indent'
+        args = sys.executable, '-m', self.module, '--no-indent'
         process = subprocess.run(args, input=input_, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, expect)
         self.assertEqual(process.stderr, '')
 
+    @force_not_colorized
     def test_tab(self):
         input_ = '[1, 2]'
         expect = '[\n\t1,\n\t2\n]\n'
-        args = sys.executable, '-m', 'json.tool', '--tab'
+        args = sys.executable, '-m', self.module, '--tab'
         process = subprocess.run(args, input=input_, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, expect)
         self.assertEqual(process.stderr, '')
 
+    @force_not_colorized
     def test_compact(self):
         input_ = '[ 1 ,\n 2]'
         expect = '[1,2]\n'
-        args = sys.executable, '-m', 'json.tool', '--compact'
+        args = sys.executable, '-m', self.module, '--compact'
         process = subprocess.run(args, input=input_, capture_output=True, text=True, check=True)
         self.assertEqual(process.stdout, expect)
         self.assertEqual(process.stderr, '')
@@ -202,7 +227,8 @@ def test_no_ensure_ascii_flag(self):
         infile = self._create_infile('{"key":"💩"}')
         outfile = os_helper.TESTFN + '.out'
         self.addCleanup(os.remove, outfile)
-        assert_python_ok('-m', 'json.tool', '--no-ensure-ascii', infile, outfile)
+        assert_python_ok('-m', self.module, '--no-ensure-ascii', infile,
+                         outfile, PYTHON_COLORS='0')
         with open(outfile, "rb") as f:
             lines = f.read().splitlines()
         # asserting utf-8 encoded output file
@@ -213,20 +239,99 @@ def test_ensure_ascii_default(self):
         infile = self._create_infile('{"key":"💩"}')
         outfile = os_helper.TESTFN + '.out'
         self.addCleanup(os.remove, outfile)
-        assert_python_ok('-m', 'json.tool', infile, outfile)
+        assert_python_ok('-m', self.module, infile, outfile, PYTHON_COLORS='0')
         with open(outfile, "rb") as f:
             lines = f.read().splitlines()
         # asserting an ascii encoded output file
         expected = [b'{', rb'    "key": "\ud83d\udca9"', b"}"]
         self.assertEqual(lines, expected)
 
+    @force_not_colorized
     @unittest.skipIf(sys.platform =="win32", "The test is failed with ValueError on Windows")
     def test_broken_pipe_error(self):
-        cmd = [sys.executable, '-m', 'json.tool']
+        cmd = [sys.executable, '-m', self.module]
         proc = subprocess.Popen(cmd,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
-        # bpo-39828: Closing before json.tool attempts to write into stdout.
+        # bpo-39828: Closing before json attempts to write into stdout.
         proc.stdout.close()
         proc.communicate(b'"{}"')
         self.assertEqual(proc.returncode, errno.EPIPE)
+
+    @force_colorized
+    def test_colors(self):
+        infile = os_helper.TESTFN
+        self.addCleanup(os.remove, infile)
+
+        t = get_theme().syntax
+        ob = "{"
+        cb = "}"
+
+        cases = (
+            ('{}', '{}'),
+            ('[]', '[]'),
+            ('null', f'{t.keyword}null{t.reset}'),
+            ('true', f'{t.keyword}true{t.reset}'),
+            ('false', f'{t.keyword}false{t.reset}'),
+            ('NaN', f'{t.number}NaN{t.reset}'),
+            ('Infinity', f'{t.number}Infinity{t.reset}'),
+            ('-Infinity', f'{t.number}-Infinity{t.reset}'),
+            ('"foo"', f'{t.string}"foo"{t.reset}'),
+            (r'" \"foo\" "', f'{t.string}" \\"foo\\" "{t.reset}'),
+            ('"α"', f'{t.string}"\\u03b1"{t.reset}'),
+            ('123', f'{t.number}123{t.reset}'),
+            ('-1.25e+23', f'{t.number}-1.25e+23{t.reset}'),
+            (r'{"\\": ""}',
+             f'''\
+{ob}
+    {t.definition}"\\\\"{t.reset}: {t.string}""{t.reset}
+{cb}'''),
+            (r'{"\\\\": ""}',
+             f'''\
+{ob}
+    {t.definition}"\\\\\\\\"{t.reset}: {t.string}""{t.reset}
+{cb}'''),
+            ('''\
+{
+    "foo": "bar",
+    "baz": 1234,
+    "qux": [true, false, null],
+    "xyz": [NaN, -Infinity, Infinity]
+}''',
+             f'''\
+{ob}
+    {t.definition}"foo"{t.reset}: {t.string}"bar"{t.reset},
+    {t.definition}"baz"{t.reset}: {t.number}1234{t.reset},
+    {t.definition}"qux"{t.reset}: [
+        {t.keyword}true{t.reset},
+        {t.keyword}false{t.reset},
+        {t.keyword}null{t.reset}
+    ],
+    {t.definition}"xyz"{t.reset}: [
+        {t.number}NaN{t.reset},
+        {t.number}-Infinity{t.reset},
+        {t.number}Infinity{t.reset}
+    ]
+{cb}'''),
+        )
+
+        for input_, expected in cases:
+            with self.subTest(input=input_):
+                with open(infile, "w", encoding="utf-8") as fp:
+                    fp.write(input_)
+                _, stdout_b, _ = assert_python_ok(
+                    '-m', self.module, infile, FORCE_COLOR='1', __isolated='1'
+                )
+                stdout = stdout_b.decode()
+                stdout = stdout.replace('\r\n', '\n')  # normalize line endings
+                stdout = stdout.strip()
+                self.assertEqual(stdout, expected)
+
+
+@support.requires_subprocess()
+class TestTool(TestMain):
+    module = 'json.tool'
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_json/test_unicode.py b/Lib/test/test_json/test_unicode.py
index be0ac8823d5..2118c9827ea 100644
--- a/Lib/test/test_json/test_unicode.py
+++ b/Lib/test/test_json/test_unicode.py
@@ -94,8 +94,7 @@ def test_bytes_encode(self):
         self.assertRaises(TypeError, self.dumps, b"hi")
         self.assertRaises(TypeError, self.dumps, [b"hi"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bytes_decode(self):
         for encoding, bom in [
                 ('utf-8', codecs.BOM_UTF8),

From dfed341ec8df64fefff5abe03ffb10c634cf069b Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Sun, 18 Jan 2026 13:49:21 +0900
Subject: [PATCH 359/418] Upgrade unittest from 3.14.2

---
 Lib/test/test_unittest/__init__.py        |   1 +
 Lib/test/test_unittest/__main__.py        |   3 +-
 Lib/test/test_unittest/_test_warnings.py  |   1 +
 Lib/test/test_unittest/test_assertions.py |   5 +-
 Lib/test/test_unittest/test_async_case.py |  12 +-
 Lib/test/test_unittest/test_break.py      |   4 +-
 Lib/test/test_unittest/test_case.py       | 369 ++++++++++++++++++++--
 Lib/test/test_unittest/test_discovery.py  |  64 +++-
 Lib/test/test_unittest/test_loader.py     |   4 +-
 Lib/test/test_unittest/test_program.py    |  16 +-
 Lib/test/test_unittest/test_result.py     |  26 +-
 Lib/test/test_unittest/test_runner.py     |   5 +-
 Lib/test/test_unittest/test_setups.py     |   1 -
 Lib/test/test_unittest/test_skipping.py   |   3 +
 Lib/test/test_unittest/test_suite.py      |   5 +-
 Lib/test/test_unittest/test_util.py       |   6 +-
 Lib/unittest/__init__.py                  |  33 +-
 Lib/unittest/__main__.py                  |   1 +
 Lib/unittest/_log.py                      |   3 +-
 Lib/unittest/async_case.py                |  24 +-
 Lib/unittest/case.py                      | 185 ++++++++++-
 Lib/unittest/loader.py                    |  62 +++-
 Lib/unittest/main.py                      |   6 +-
 Lib/unittest/mock.py                      |  52 ++-
 Lib/unittest/result.py                    |   7 +-
 Lib/unittest/runner.py                    | 101 +++---
 Lib/unittest/signals.py                   |   1 -
 Lib/unittest/suite.py                     |   3 +-
 Lib/unittest/util.py                      |   2 +-
 29 files changed, 826 insertions(+), 179 deletions(-)

diff --git a/Lib/test/test_unittest/__init__.py b/Lib/test/test_unittest/__init__.py
index bc502ef32d2..365f26d6438 100644
--- a/Lib/test/test_unittest/__init__.py
+++ b/Lib/test/test_unittest/__init__.py
@@ -1,4 +1,5 @@
 import os.path
+
 from test.support import load_package_tests
 
 
diff --git a/Lib/test/test_unittest/__main__.py b/Lib/test/test_unittest/__main__.py
index 40a23a297ec..0d53bfab847 100644
--- a/Lib/test/test_unittest/__main__.py
+++ b/Lib/test/test_unittest/__main__.py
@@ -1,4 +1,5 @@
-from . import load_tests
 import unittest
 
+from . import load_tests
+
 unittest.main()
diff --git a/Lib/test/test_unittest/_test_warnings.py b/Lib/test/test_unittest/_test_warnings.py
index 08b846ee47e..d9f41a4144b 100644
--- a/Lib/test/test_unittest/_test_warnings.py
+++ b/Lib/test/test_unittest/_test_warnings.py
@@ -14,6 +14,7 @@
 import unittest
 import warnings
 
+
 def warnfun():
     warnings.warn('rw', RuntimeWarning)
 
diff --git a/Lib/test/test_unittest/test_assertions.py b/Lib/test/test_unittest/test_assertions.py
index 1dec947ea76..3d782573d7b 100644
--- a/Lib/test/test_unittest/test_assertions.py
+++ b/Lib/test/test_unittest/test_assertions.py
@@ -1,10 +1,11 @@
 import datetime
+import unittest
 import warnings
 import weakref
-import unittest
-from test.support import gc_collect
 from itertools import product
 
+from test.support import gc_collect
+
 
 class Test_Assertions(unittest.TestCase):
     def test_AlmostEqual(self):
diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index 8f73f466379..87808fcbaaf 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -1,7 +1,9 @@
 import asyncio
 import contextvars
 import unittest
+
 from test import support
+from test.support import force_not_colorized
 
 support.requires_working_socket(module=True)
 
@@ -11,7 +13,7 @@ class MyException(Exception):
 
 
 def tearDownModule():
-    asyncio.set_event_loop_policy(None)
+    asyncio.events._set_event_loop_policy(None)
 
 
 class TestCM:
@@ -253,6 +255,7 @@ async def on_cleanup(self):
         test.doCleanups()
         self.assertEqual(events, ['asyncSetUp', 'test', 'asyncTearDown', 'cleanup'])
 
+    @force_not_colorized
     def test_exception_in_tear_clean_up(self):
         class Test(unittest.IsolatedAsyncioTestCase):
             async def asyncSetUp(self):
@@ -314,18 +317,21 @@ async def test3(self):
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test1', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn("returned 'int'", str(w.warning))
 
         with self.assertWarns(DeprecationWarning) as w:
             Test('test2').run()
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test2', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn("returned 'async_generator'", str(w.warning))
 
         with self.assertWarns(DeprecationWarning) as w:
             Test('test3').run()
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test3', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn(f'returned {Nothing.__name__!r}', str(w.warning))
 
     def test_cleanups_interleave_order(self):
         events = []
@@ -477,7 +483,7 @@ def test_setup_get_event_loop(self):
 
         class TestCase1(unittest.IsolatedAsyncioTestCase):
             def setUp(self):
-                asyncio.get_event_loop_policy().get_event_loop()
+                asyncio.events._get_event_loop_policy().get_event_loop()
 
             async def test_demo1(self):
                 pass
@@ -487,7 +493,7 @@ async def test_demo1(self):
         self.assertTrue(result.wasSuccessful())
 
     def test_loop_factory(self):
-        asyncio.set_event_loop_policy(None)
+        asyncio.events._set_event_loop_policy(None)
 
         class TestCase1(unittest.IsolatedAsyncioTestCase):
             loop_factory = asyncio.EventLoop
diff --git a/Lib/test/test_unittest/test_break.py b/Lib/test/test_unittest/test_break.py
index 1da98af3e74..8aa20008ac7 100644
--- a/Lib/test/test_unittest/test_break.py
+++ b/Lib/test/test_unittest/test_break.py
@@ -1,10 +1,10 @@
 import gc
 import io
 import os
-import sys
 import signal
-import weakref
+import sys
 import unittest
+import weakref
 
 from test import support
 
diff --git a/Lib/test/test_unittest/test_case.py b/Lib/test/test_unittest/test_case.py
index 82a442a04e6..6e77040c265 100644
--- a/Lib/test/test_unittest/test_case.py
+++ b/Lib/test/test_unittest/test_case.py
@@ -1,26 +1,27 @@
 import contextlib
 import difflib
-import pprint
+import inspect
+import logging
 import pickle
+import pprint
 import re
 import sys
-import logging
+import types
+import unittest
 import warnings
 import weakref
-import inspect
-import types
-
+from collections import UserString
 from copy import deepcopy
-from test import support
-
-import unittest
 
+from test import support
+from test.support import captured_stderr, gc_collect
 from test.test_unittest.support import (
-    TestEquality, TestHashing, LoggingResult, LegacyLoggingResult,
-    ResultWithNoStartTestRunStopTestRun
+    LegacyLoggingResult,
+    LoggingResult,
+    ResultWithNoStartTestRunStopTestRun,
+    TestEquality,
+    TestHashing,
 )
-from test.support import captured_stderr, gc_collect
-
 
 log_foo = logging.getLogger('foo')
 log_foobar = logging.getLogger('foo.bar')
@@ -54,6 +55,10 @@ def tearDown(self):
             self.events.append('tearDown')
 
 
+class List(list):
+    pass
+
+
 class Test_TestCase(unittest.TestCase, TestEquality, TestHashing):
 
     ### Set up attributes used by inherited tests
@@ -85,7 +90,7 @@ class Test(unittest.TestCase):
             def runTest(self): raise MyException()
             def test(self): pass
 
-        self.assertEqual(Test().id()[-13:], '.Test.runTest')
+        self.assertEndsWith(Test().id(), '.Test.runTest')
 
         # test that TestCase can be instantiated with no args
         # primarily for use at the interactive interpreter
@@ -106,7 +111,7 @@ class Test(unittest.TestCase):
             def runTest(self): raise MyException()
             def test(self): pass
 
-        self.assertEqual(Test('test').id()[-10:], '.Test.test')
+        self.assertEndsWith(Test('test').id(), '.Test.test')
 
     # "class TestCase([methodName])"
     # ...
@@ -325,18 +330,40 @@ def test3(self):
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test1', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn("returned 'int'", str(w.warning))
 
         with self.assertWarns(DeprecationWarning) as w:
             Foo('test2').run()
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test2', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn("returned 'generator'", str(w.warning))
 
         with self.assertWarns(DeprecationWarning) as w:
             Foo('test3').run()
         self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
         self.assertIn('test3', str(w.warning))
         self.assertEqual(w.filename, __file__)
+        self.assertIn(f'returned {Nothing.__name__!r}', str(w.warning))
+
+    def test_deprecation_of_return_val_from_test_async_method(self):
+        class Foo(unittest.TestCase):
+            async def test1(self):
+                return 1
+
+        with self.assertWarns(DeprecationWarning) as w:
+            warnings.filterwarnings('ignore',
+                    'coroutine .* was never awaited', RuntimeWarning)
+            Foo('test1').run()
+            support.gc_collect()
+        self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
+        self.assertIn('test1', str(w.warning))
+        self.assertEqual(w.filename, __file__)
+        self.assertIn("returned 'coroutine'", str(w.warning))
+        self.assertIn(
+            'Maybe you forgot to use IsolatedAsyncioTestCase as the base class?',
+            str(w.warning),
+        )
 
     def _check_call_order__subtests(self, result, events, expected_events):
         class Foo(Test.LoggingTestCase):
@@ -678,16 +705,136 @@ def testAssertIsNot(self):
         self.assertRaises(self.failureException, self.assertIsNot, thing, thing)
 
     def testAssertIsInstance(self):
-        thing = []
+        thing = List()
         self.assertIsInstance(thing, list)
-        self.assertRaises(self.failureException, self.assertIsInstance,
-                          thing, dict)
+        self.assertIsInstance(thing, (int, list))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsInstance(thing, int)
+        self.assertEqual(str(cm.exception),
+                "[] is not an instance of <class 'int'>")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsInstance(thing, (int, float))
+        self.assertEqual(str(cm.exception),
+                "[] is not an instance of any of (<class 'int'>, <class 'float'>)")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsInstance(thing, int, 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsInstance(thing, int, msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
 
     def testAssertNotIsInstance(self):
-        thing = []
-        self.assertNotIsInstance(thing, dict)
-        self.assertRaises(self.failureException, self.assertNotIsInstance,
-                          thing, list)
+        thing = List()
+        self.assertNotIsInstance(thing, int)
+        self.assertNotIsInstance(thing, (int, float))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsInstance(thing, list)
+        self.assertEqual(str(cm.exception),
+                "[] is an instance of <class 'list'>")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsInstance(thing, (int, list))
+        self.assertEqual(str(cm.exception),
+                "[] is an instance of <class 'list'>")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsInstance(thing, list, 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsInstance(thing, list, msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertIsSubclass(self):
+        self.assertIsSubclass(List, list)
+        self.assertIsSubclass(List, (int, list))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsSubclass(List, int)
+        self.assertEqual(str(cm.exception),
+                f"{List!r} is not a subclass of <class 'int'>")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsSubclass(List, (int, float))
+        self.assertEqual(str(cm.exception),
+                f"{List!r} is not a subclass of any of (<class 'int'>, <class 'float'>)")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsSubclass(1, int)
+        self.assertEqual(str(cm.exception), "1 is not a class")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsSubclass(List, int, 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertIsSubclass(List, int, msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertNotIsSubclass(self):
+        self.assertNotIsSubclass(List, int)
+        self.assertNotIsSubclass(List, (int, float))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsSubclass(List, list)
+        self.assertEqual(str(cm.exception),
+                f"{List!r} is a subclass of <class 'list'>")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsSubclass(List, (int, list))
+        self.assertEqual(str(cm.exception),
+                f"{List!r} is a subclass of <class 'list'>")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsSubclass(1, int)
+        self.assertEqual(str(cm.exception), "1 is not a class")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsSubclass(List, list, 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotIsSubclass(List, list, msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertHasAttr(self):
+        a = List()
+        a.x = 1
+        self.assertHasAttr(a, 'x')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertHasAttr(a, 'y')
+        self.assertEqual(str(cm.exception),
+                "'List' object has no attribute 'y'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertHasAttr(List, 'spam')
+        self.assertEqual(str(cm.exception),
+                "type object 'List' has no attribute 'spam'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertHasAttr(sys, 'nonexistent')
+        self.assertEqual(str(cm.exception),
+                "module 'sys' has no attribute 'nonexistent'")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertHasAttr(a, 'y', 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertHasAttr(a, 'y', msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertNotHasAttr(self):
+        a = List()
+        a.x = 1
+        self.assertNotHasAttr(a, 'y')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotHasAttr(a, 'x')
+        self.assertEqual(str(cm.exception),
+                "'List' object has unexpected attribute 'x'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotHasAttr(List, 'append')
+        self.assertEqual(str(cm.exception),
+                "type object 'List' has unexpected attribute 'append'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotHasAttr(sys, 'modules')
+        self.assertEqual(str(cm.exception),
+                "module 'sys' has unexpected attribute 'modules'")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotHasAttr(a, 'x', 'ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotHasAttr(a, 'x', msg='ababahalamaha')
+        self.assertIn('ababahalamaha', str(cm.exception))
 
     def testAssertIn(self):
         animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
@@ -1842,6 +1989,186 @@ def testAssertNoLogsYieldsNone(self):
             pass
         self.assertIsNone(value)
 
+    def testAssertStartsWith(self):
+        self.assertStartsWith('ababahalamaha', 'ababa')
+        self.assertStartsWith('ababahalamaha', ('x', 'ababa', 'y'))
+        self.assertStartsWith(UserString('ababahalamaha'), 'ababa')
+        self.assertStartsWith(UserString('ababahalamaha'), ('x', 'ababa', 'y'))
+        self.assertStartsWith(bytearray(b'ababahalamaha'), b'ababa')
+        self.assertStartsWith(bytearray(b'ababahalamaha'), (b'x', b'ababa', b'y'))
+        self.assertStartsWith(b'ababahalamaha', bytearray(b'ababa'))
+        self.assertStartsWith(b'ababahalamaha',
+                (bytearray(b'x'), bytearray(b'ababa'), bytearray(b'y')))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', 'amaha')
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' doesn't start with 'amaha'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', ('x', 'y'))
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' doesn't start with any of ('x', 'y')")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith(b'ababahalamaha', 'ababa')
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith(b'ababahalamaha', ('amaha', 'ababa'))
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith([], 'ababa')
+        self.assertEqual(str(cm.exception), 'Expected str, not list')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', b'ababa')
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', (b'amaha', b'ababa'))
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(TypeError):
+            self.assertStartsWith('ababahalamaha', ord('a'))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', 'amaha', 'abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertStartsWith('ababahalamaha', 'amaha', msg='abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertNotStartsWith(self):
+        self.assertNotStartsWith('ababahalamaha', 'amaha')
+        self.assertNotStartsWith('ababahalamaha', ('x', 'amaha', 'y'))
+        self.assertNotStartsWith(UserString('ababahalamaha'), 'amaha')
+        self.assertNotStartsWith(UserString('ababahalamaha'), ('x', 'amaha', 'y'))
+        self.assertNotStartsWith(bytearray(b'ababahalamaha'), b'amaha')
+        self.assertNotStartsWith(bytearray(b'ababahalamaha'), (b'x', b'amaha', b'y'))
+        self.assertNotStartsWith(b'ababahalamaha', bytearray(b'amaha'))
+        self.assertNotStartsWith(b'ababahalamaha',
+                (bytearray(b'x'), bytearray(b'amaha'), bytearray(b'y')))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', 'ababa')
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' starts with 'ababa'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', ('x', 'ababa', 'y'))
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' starts with 'ababa'")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith(b'ababahalamaha', 'ababa')
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith(b'ababahalamaha', ('amaha', 'ababa'))
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith([], 'ababa')
+        self.assertEqual(str(cm.exception), 'Expected str, not list')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', b'ababa')
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', (b'amaha', b'ababa'))
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(TypeError):
+            self.assertNotStartsWith('ababahalamaha', ord('a'))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', 'ababa', 'abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotStartsWith('ababahalamaha', 'ababa', msg='abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertEndsWith(self):
+        self.assertEndsWith('ababahalamaha', 'amaha')
+        self.assertEndsWith('ababahalamaha', ('x', 'amaha', 'y'))
+        self.assertEndsWith(UserString('ababahalamaha'), 'amaha')
+        self.assertEndsWith(UserString('ababahalamaha'), ('x', 'amaha', 'y'))
+        self.assertEndsWith(bytearray(b'ababahalamaha'), b'amaha')
+        self.assertEndsWith(bytearray(b'ababahalamaha'), (b'x', b'amaha', b'y'))
+        self.assertEndsWith(b'ababahalamaha', bytearray(b'amaha'))
+        self.assertEndsWith(b'ababahalamaha',
+                (bytearray(b'x'), bytearray(b'amaha'), bytearray(b'y')))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', 'ababa')
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' doesn't end with 'ababa'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', ('x', 'y'))
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' doesn't end with any of ('x', 'y')")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith(b'ababahalamaha', 'amaha')
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith(b'ababahalamaha', ('ababa', 'amaha'))
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith([], 'amaha')
+        self.assertEqual(str(cm.exception), 'Expected str, not list')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', b'amaha')
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', (b'ababa', b'amaha'))
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(TypeError):
+            self.assertEndsWith('ababahalamaha', ord('a'))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', 'ababa', 'abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertEndsWith('ababahalamaha', 'ababa', msg='abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
+    def testAssertNotEndsWith(self):
+        self.assertNotEndsWith('ababahalamaha', 'ababa')
+        self.assertNotEndsWith('ababahalamaha', ('x', 'ababa', 'y'))
+        self.assertNotEndsWith(UserString('ababahalamaha'), 'ababa')
+        self.assertNotEndsWith(UserString('ababahalamaha'), ('x', 'ababa', 'y'))
+        self.assertNotEndsWith(bytearray(b'ababahalamaha'), b'ababa')
+        self.assertNotEndsWith(bytearray(b'ababahalamaha'), (b'x', b'ababa', b'y'))
+        self.assertNotEndsWith(b'ababahalamaha', bytearray(b'ababa'))
+        self.assertNotEndsWith(b'ababahalamaha',
+                (bytearray(b'x'), bytearray(b'ababa'), bytearray(b'y')))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', 'amaha')
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' ends with 'amaha'")
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', ('x', 'amaha', 'y'))
+        self.assertEqual(str(cm.exception),
+                "'ababahalamaha' ends with 'amaha'")
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith(b'ababahalamaha', 'amaha')
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith(b'ababahalamaha', ('ababa', 'amaha'))
+        self.assertEqual(str(cm.exception), 'Expected str, not bytes')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith([], 'amaha')
+        self.assertEqual(str(cm.exception), 'Expected str, not list')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', b'amaha')
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', (b'ababa', b'amaha'))
+        self.assertEqual(str(cm.exception), 'Expected bytes, not str')
+        with self.assertRaises(TypeError):
+            self.assertNotEndsWith('ababahalamaha', ord('a'))
+
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', 'amaha', 'abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+        with self.assertRaises(self.failureException) as cm:
+            self.assertNotEndsWith('ababahalamaha', 'amaha', msg='abracadabra')
+        self.assertIn('ababahalamaha', str(cm.exception))
+
     def testDeprecatedFailMethods(self):
         """Test that the deprecated fail* methods get removed in 3.12"""
         deprecated_names = [
diff --git a/Lib/test/test_unittest/test_discovery.py b/Lib/test/test_unittest/test_discovery.py
index a44b18406c0..a60064d2919 100644
--- a/Lib/test/test_unittest/test_discovery.py
+++ b/Lib/test/test_unittest/test_discovery.py
@@ -1,15 +1,17 @@
 import os.path
-from os.path import abspath
+import pickle
 import re
 import sys
 import types
-import pickle
-from test import support
-from test.support import import_helper
-
 import unittest
 import unittest.mock
+from importlib._bootstrap_external import NamespaceLoader
+from os.path import abspath
+
 import test.test_unittest
+from test import support
+from test.support import import_helper
+from test.test_importlib import util as test_util
 
 
 class TestableTestProgram(unittest.TestProgram):
@@ -395,7 +397,7 @@ def restore_isdir():
         self.addCleanup(restore_isdir)
 
         _find_tests_args = []
-        def _find_tests(start_dir, pattern):
+        def _find_tests(start_dir, pattern, namespace=None):
             _find_tests_args.append((start_dir, pattern))
             return ['tests']
         loader._find_tests = _find_tests
@@ -815,7 +817,7 @@ def test_discovery_from_dotted_path(self):
         expectedPath = os.path.abspath(os.path.dirname(test.test_unittest.__file__))
 
         self.wasRun = False
-        def _find_tests(start_dir, pattern):
+        def _find_tests(start_dir, pattern, namespace=None):
             self.wasRun = True
             self.assertEqual(start_dir, expectedPath)
             return tests
@@ -848,6 +850,54 @@ def restore():
                          'Can not use builtin modules '
                          'as dotted module names')
 
+    def test_discovery_from_dotted_namespace_packages(self):
+        loader = unittest.TestLoader()
+
+        package = types.ModuleType('package')
+        package.__name__ = "tests"
+        package.__path__ = ['/a', '/b']
+        package.__file__ = None
+        package.__spec__ = types.SimpleNamespace(
+            name=package.__name__,
+            loader=NamespaceLoader(package.__name__, package.__path__, None),
+            submodule_search_locations=['/a', '/b']
+        )
+
+        def _import(packagename, *args, **kwargs):
+            sys.modules[packagename] = package
+            return package
+
+        _find_tests_args = []
+        def _find_tests(start_dir, pattern, namespace=None):
+            _find_tests_args.append((start_dir, pattern))
+            return ['%s/tests' % start_dir]
+
+        loader._find_tests = _find_tests
+        loader.suiteClass = list
+
+        with unittest.mock.patch('builtins.__import__', _import):
+            # Since loader.discover() can modify sys.path, restore it when done.
+            with import_helper.DirsOnSysPath():
+                # Make sure to remove 'package' from sys.modules when done.
+                with test_util.uncache('package'):
+                    suite = loader.discover('package')
+
+        self.assertEqual(suite, ['/a/tests', '/b/tests'])
+
+    def test_discovery_start_dir_is_namespace(self):
+        """Subdirectory discovery not affected if start_dir is a namespace pkg."""
+        loader = unittest.TestLoader()
+        with (
+            import_helper.DirsOnSysPath(os.path.join(os.path.dirname(__file__))),
+            test_util.uncache('namespace_test_pkg')
+        ):
+            suite = loader.discover('namespace_test_pkg')
+        self.assertEqual(
+            {list(suite)[0]._tests[0].__module__ for suite in suite._tests if list(suite)},
+            # files under namespace_test_pkg.noop not discovered.
+            {'namespace_test_pkg.test_foo', 'namespace_test_pkg.bar.test_bar'},
+        )
+
     def test_discovery_failed_discovery(self):
         from test.test_importlib import util
 
diff --git a/Lib/test/test_unittest/test_loader.py b/Lib/test/test_unittest/test_loader.py
index 83dd25ca546..0acefccf7f6 100644
--- a/Lib/test/test_unittest/test_loader.py
+++ b/Lib/test/test_unittest/test_loader.py
@@ -1,9 +1,9 @@
 import functools
 import sys
 import types
-
 import unittest
 
+
 class Test_TestLoader(unittest.TestCase):
 
     ### Basic object tests
@@ -76,7 +76,7 @@ def runTest(self):
 
         loader = unittest.TestLoader()
         # This has to be false for the test to succeed
-        self.assertFalse('runTest'.startswith(loader.testMethodPrefix))
+        self.assertNotStartsWith('runTest', loader.testMethodPrefix)
 
         suite = loader.loadTestsFromTestCase(Foo)
         self.assertIsInstance(suite, loader.suiteClass)
diff --git a/Lib/test/test_unittest/test_program.py b/Lib/test/test_unittest/test_program.py
index 2e3a7508478..99c5ec48b67 100644
--- a/Lib/test/test_unittest/test_program.py
+++ b/Lib/test/test_unittest/test_program.py
@@ -1,9 +1,10 @@
 import os
-import sys
 import subprocess
-from test import support
+import sys
 import unittest
+
 import test.test_unittest
+from test import support
 from test.test_unittest.test_result import BufferedWriter
 
 
@@ -135,14 +136,14 @@ def test_NonExit(self):
                                 argv=["foobar"],
                                 testRunner=unittest.TextTestRunner(stream=stream),
                                 testLoader=self.TestLoader(self.FooBar))
-        self.assertTrue(hasattr(program, 'result'))
+        self.assertHasAttr(program, 'result')
         out = stream.getvalue()
         self.assertIn('\nFAIL: testFail ', out)
         self.assertIn('\nERROR: testError ', out)
         self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
         expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
                     'expected failures=1, unexpected successes=1)\n')
-        self.assertTrue(out.endswith(expected))
+        self.assertEndsWith(out, expected)
 
     def test_Exit(self):
         stream = BufferedWriter()
@@ -159,7 +160,7 @@ def test_Exit(self):
         self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
         expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
                     'expected failures=1, unexpected successes=1)\n')
-        self.assertTrue(out.endswith(expected))
+        self.assertEndsWith(out, expected)
 
     def test_ExitAsDefault(self):
         stream = BufferedWriter()
@@ -174,7 +175,7 @@ def test_ExitAsDefault(self):
         self.assertIn('\nUNEXPECTED SUCCESS: testUnexpectedSuccess ', out)
         expected = ('\n\nFAILED (failures=1, errors=1, skipped=1, '
                     'expected failures=1, unexpected successes=1)\n')
-        self.assertTrue(out.endswith(expected))
+        self.assertEndsWith(out, expected)
 
     def test_ExitSkippedSuite(self):
         stream = BufferedWriter()
@@ -186,7 +187,7 @@ def test_ExitSkippedSuite(self):
         self.assertEqual(cm.exception.code, 0)
         out = stream.getvalue()
         expected = '\n\nOK (skipped=1)\n'
-        self.assertTrue(out.endswith(expected))
+        self.assertEndsWith(out, expected)
 
     def test_ExitEmptySuite(self):
         stream = BufferedWriter()
@@ -506,7 +507,6 @@ def testParseArgsSelectedTestNames(self):
         self.assertEqual(program.testNamePatterns, ['*foo*', '*bar*', '*pat*'])
 
     @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON')
-    
     def testSelectedTestNamesFunctionalTest(self):
         def run_unittest(args):
             # Use -E to ignore PYTHONSAFEPATH env var
diff --git a/Lib/test/test_unittest/test_result.py b/Lib/test/test_unittest/test_result.py
index 4d552d54e9a..c260f90bf03 100644
--- a/Lib/test/test_unittest/test_result.py
+++ b/Lib/test/test_unittest/test_result.py
@@ -4,8 +4,12 @@
 import traceback
 import unittest
 from unittest.util import strclass
-from test.support import warnings_helper
-from test.support import captured_stdout, force_not_colorized_test_class
+
+from test.support import (
+    captured_stdout,
+    force_not_colorized_test_class,
+    warnings_helper,
+)
 from test.test_unittest.support import BufferedWriter
 
 
@@ -13,7 +17,7 @@ class MockTraceback(object):
     class TracebackException:
         def __init__(self, *args, **kwargs):
             self.capture_locals = kwargs.get('capture_locals', False)
-        def format(self):
+        def format(self, **kwargs):
             result = ['A traceback']
             if self.capture_locals:
                 result.append('locals')
@@ -186,7 +190,7 @@ def test_1(self):
         test = Foo('test_1')
         try:
             test.fail("foo")
-        except:
+        except AssertionError:
             exc_info_tuple = sys.exc_info()
 
         result = unittest.TestResult()
@@ -214,7 +218,7 @@ def test_1(self):
         def get_exc_info():
             try:
                 test.fail("foo")
-            except:
+            except AssertionError:
                 return sys.exc_info()
 
         exc_info_tuple = get_exc_info()
@@ -241,9 +245,9 @@ def get_exc_info():
             try:
                 try:
                     test.fail("foo")
-                except:
+                except AssertionError:
                     raise ValueError(42)
-            except:
+            except ValueError:
                 return sys.exc_info()
 
         exc_info_tuple = get_exc_info()
@@ -271,7 +275,7 @@ def get_exc_info():
                 loop.__cause__ = loop
                 loop.__context__ = loop
                 raise loop
-            except:
+            except Exception:
                 return sys.exc_info()
 
         exc_info_tuple = get_exc_info()
@@ -300,7 +304,7 @@ def get_exc_info():
                     ex1.__cause__ = ex2
                     ex2.__context__ = ex1
                 raise C
-            except:
+            except Exception:
                 return sys.exc_info()
 
         exc_info_tuple = get_exc_info()
@@ -345,7 +349,7 @@ def test_1(self):
         test = Foo('test_1')
         try:
             raise TypeError()
-        except:
+        except TypeError:
             exc_info_tuple = sys.exc_info()
 
         result = unittest.TestResult()
@@ -454,7 +458,7 @@ def test(result):
             self.assertTrue(result.failfast)
         result = runner.run(test)
         stream.flush()
-        self.assertTrue(stream.getvalue().endswith('\n\nOK\n'))
+        self.assertEndsWith(stream.getvalue(), '\n\nOK\n')
 
 
 @force_not_colorized_test_class
diff --git a/Lib/test/test_unittest/test_runner.py b/Lib/test/test_unittest/test_runner.py
index 4d3cfd60b8d..b215a3664d1 100644
--- a/Lib/test/test_unittest/test_runner.py
+++ b/Lib/test/test_unittest/test_runner.py
@@ -1,13 +1,12 @@
 import io
 import os
-import sys
 import pickle
 import subprocess
-from test import support
-
+import sys
 import unittest
 from unittest.case import _Outcome
 
+from test import support
 from test.test_unittest.support import (
     BufferedWriter,
     LoggingResult,
diff --git a/Lib/test/test_unittest/test_setups.py b/Lib/test/test_unittest/test_setups.py
index 2df703ed934..2468681003b 100644
--- a/Lib/test/test_unittest/test_setups.py
+++ b/Lib/test/test_unittest/test_setups.py
@@ -1,6 +1,5 @@
 import io
 import sys
-
 import unittest
 
 
diff --git a/Lib/test/test_unittest/test_skipping.py b/Lib/test/test_unittest/test_skipping.py
index f146dcac18e..f5cb860c60b 100644
--- a/Lib/test/test_unittest/test_skipping.py
+++ b/Lib/test/test_unittest/test_skipping.py
@@ -1,5 +1,6 @@
 import unittest
 
+from test.support import force_not_colorized
 from test.test_unittest.support import LoggingResult
 
 
@@ -293,6 +294,7 @@ def test_die(self):
         self.assertFalse(result.unexpectedSuccesses)
         self.assertTrue(result.wasSuccessful())
 
+    @force_not_colorized
     def test_expected_failure_and_fail_in_cleanup(self):
         class Foo(unittest.TestCase):
             @unittest.expectedFailure
@@ -372,6 +374,7 @@ def test_die(self):
         self.assertEqual(result.unexpectedSuccesses, [test])
         self.assertFalse(result.wasSuccessful())
 
+    @force_not_colorized
     def test_unexpected_success_and_fail_in_cleanup(self):
         class Foo(unittest.TestCase):
             @unittest.expectedFailure
diff --git a/Lib/test/test_unittest/test_suite.py b/Lib/test/test_unittest/test_suite.py
index ca52ee9d9c0..11c8c859f3d 100644
--- a/Lib/test/test_unittest/test_suite.py
+++ b/Lib/test/test_unittest/test_suite.py
@@ -1,10 +1,9 @@
-import unittest
-
 import gc
 import sys
+import unittest
 import weakref
-from test.test_unittest.support import LoggingResult, TestEquality
 
+from test.test_unittest.support import LoggingResult, TestEquality
 
 ### Support code for Test_TestSuite
 ################################################################
diff --git a/Lib/test/test_unittest/test_util.py b/Lib/test/test_unittest/test_util.py
index d590a333930..abadcb96601 100644
--- a/Lib/test/test_unittest/test_util.py
+++ b/Lib/test/test_unittest/test_util.py
@@ -1,5 +1,9 @@
 import unittest
-from unittest.util import safe_repr, sorted_list_difference, unorderable_list_difference
+from unittest.util import (
+    safe_repr,
+    sorted_list_difference,
+    unorderable_list_difference,
+)
 
 
 class TestUtil(unittest.TestCase):
diff --git a/Lib/unittest/__init__.py b/Lib/unittest/__init__.py
index 6878c2a8f5a..b049402eed7 100644
--- a/Lib/unittest/__init__.py
+++ b/Lib/unittest/__init__.py
@@ -27,7 +27,7 @@ def testMultiply(self):
   http://docs.python.org/library/unittest.html
 
 Copyright (c) 1999-2003 Steve Purcell
-Copyright (c) 2003-2010 Python Software Foundation
+Copyright (c) 2003 Python Software Foundation
 This module is free software, and you may redistribute it and/or modify
 it under the same terms as Python itself, so long as this copyright message
 and disclaimer are retained in their original form.
@@ -53,15 +53,30 @@ def testMultiply(self):
 
 __unittest = True
 
-from .result import TestResult
-from .case import (addModuleCleanup, TestCase, FunctionTestCase, SkipTest, skip,
-                   skipIf, skipUnless, expectedFailure, doModuleCleanups,
-                   enterModuleContext)
-from .suite import BaseTestSuite, TestSuite
+from .case import (
+    FunctionTestCase,
+    SkipTest,
+    TestCase,
+    addModuleCleanup,
+    doModuleCleanups,
+    enterModuleContext,
+    expectedFailure,
+    skip,
+    skipIf,
+    skipUnless,
+)
 from .loader import TestLoader, defaultTestLoader
-from .main import TestProgram, main
-from .runner import TextTestRunner, TextTestResult
-from .signals import installHandler, registerResult, removeResult, removeHandler
+from .main import TestProgram, main  # noqa: F401
+from .result import TestResult
+from .runner import TextTestResult, TextTestRunner
+from .signals import (
+    installHandler,
+    registerResult,
+    removeHandler,
+    removeResult,
+)
+from .suite import BaseTestSuite, TestSuite  # noqa: F401
+
 # IsolatedAsyncioTestCase will be imported lazily.
 
 
diff --git a/Lib/unittest/__main__.py b/Lib/unittest/__main__.py
index e5876f569b5..50111190eee 100644
--- a/Lib/unittest/__main__.py
+++ b/Lib/unittest/__main__.py
@@ -1,6 +1,7 @@
 """Main entry point"""
 
 import sys
+
 if sys.argv[0].endswith("__main__.py"):
     import os.path
     # We change sys.argv[0] to make help message more useful
diff --git a/Lib/unittest/_log.py b/Lib/unittest/_log.py
index 94868e5bb95..c61abb15745 100644
--- a/Lib/unittest/_log.py
+++ b/Lib/unittest/_log.py
@@ -1,9 +1,8 @@
-import logging
 import collections
+import logging
 
 from .case import _BaseTestCaseContext
 
-
 _LoggingWatcher = collections.namedtuple("_LoggingWatcher",
                                          ["records", "output"])
 
diff --git a/Lib/unittest/async_case.py b/Lib/unittest/async_case.py
index e761ba7e53c..a1c0d6c368c 100644
--- a/Lib/unittest/async_case.py
+++ b/Lib/unittest/async_case.py
@@ -75,9 +75,17 @@ async def enterAsyncContext(self, cm):
             enter = cls.__aenter__
             exit = cls.__aexit__
         except AttributeError:
-            raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
-                            f"not support the asynchronous context manager protocol"
-                           ) from None
+            msg = (f"'{cls.__module__}.{cls.__qualname__}' object does "
+                   "not support the asynchronous context manager protocol")
+            try:
+                cls.__enter__
+                cls.__exit__
+            except AttributeError:
+                pass
+            else:
+                msg += (" but it supports the context manager protocol. "
+                        "Did you mean to use enterContext()?")
+            raise TypeError(msg) from None
         result = await enter(cm)
         self.addAsyncCleanup(exit, cm, None, None, None)
         return result
@@ -91,9 +99,13 @@ def _callSetUp(self):
         self._callAsync(self.asyncSetUp)
 
     def _callTestMethod(self, method):
-        if self._callMaybeAsync(method) is not None:
-            warnings.warn(f'It is deprecated to return a value that is not None from a '
-                          f'test case ({method})', DeprecationWarning, stacklevel=4)
+        result = self._callMaybeAsync(method)
+        if result is not None:
+            msg = (
+                f'It is deprecated to return a value that is not None '
+                f'from a test case ({method} returned {type(result).__name__!r})',
+            )
+            warnings.warn(msg, DeprecationWarning, stacklevel=4)
 
     def _callTearDown(self):
         self._callAsync(self.asyncTearDown)
diff --git a/Lib/unittest/case.py b/Lib/unittest/case.py
index 36daa61fa31..b09836d6747 100644
--- a/Lib/unittest/case.py
+++ b/Lib/unittest/case.py
@@ -1,20 +1,25 @@
 """Test case implementation"""
 
-import sys
-import functools
+import collections
+import contextlib
 import difflib
+import functools
 import pprint
 import re
-import warnings
-import collections
-import contextlib
-import traceback
+import sys
 import time
+import traceback
 import types
+import warnings
 
 from . import result
-from .util import (strclass, safe_repr, _count_diff_all_purpose,
-                   _count_diff_hashable, _common_shorten_repr)
+from .util import (
+    _common_shorten_repr,
+    _count_diff_all_purpose,
+    _count_diff_hashable,
+    safe_repr,
+    strclass,
+)
 
 __unittest = True
 
@@ -111,8 +116,17 @@ def _enter_context(cm, addcleanup):
         enter = cls.__enter__
         exit = cls.__exit__
     except AttributeError:
-        raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
-                        f"not support the context manager protocol") from None
+        msg = (f"'{cls.__module__}.{cls.__qualname__}' object does "
+               "not support the context manager protocol")
+        try:
+            cls.__aenter__
+            cls.__aexit__
+        except AttributeError:
+            pass
+        else:
+            msg += (" but it supports the asynchronous context manager "
+                    "protocol. Did you mean to use enterAsyncContext()?")
+        raise TypeError(msg) from None
     result = enter(cm)
     addcleanup(exit, cm, None, None, None)
     return result
@@ -603,9 +617,18 @@ def _callSetUp(self):
         self.setUp()
 
     def _callTestMethod(self, method):
-        if method() is not None:
-            warnings.warn(f'It is deprecated to return a value that is not None from a '
-                          f'test case ({method})', DeprecationWarning, stacklevel=3)
+        result = method()
+        if result is not None:
+            import inspect
+            msg = (
+                f'It is deprecated to return a value that is not None '
+                f'from a test case ({method} returned {type(result).__name__!r})'
+            )
+            if inspect.iscoroutine(result):
+                msg += (
+                    '. Maybe you forgot to use IsolatedAsyncioTestCase as the base class?'
+                )
+            warnings.warn(msg, DeprecationWarning, stacklevel=3)
 
     def _callTearDown(self):
         self.tearDown()
@@ -1312,13 +1335,71 @@ def assertIsInstance(self, obj, cls, msg=None):
         """Same as self.assertTrue(isinstance(obj, cls)), with a nicer
         default message."""
         if not isinstance(obj, cls):
-            standardMsg = '%s is not an instance of %r' % (safe_repr(obj), cls)
+            if isinstance(cls, tuple):
+                standardMsg = f'{safe_repr(obj)} is not an instance of any of {cls!r}'
+            else:
+                standardMsg = f'{safe_repr(obj)} is not an instance of {cls!r}'
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertNotIsInstance(self, obj, cls, msg=None):
         """Included for symmetry with assertIsInstance."""
         if isinstance(obj, cls):
-            standardMsg = '%s is an instance of %r' % (safe_repr(obj), cls)
+            if isinstance(cls, tuple):
+                for x in cls:
+                    if isinstance(obj, x):
+                        cls = x
+                        break
+            standardMsg = f'{safe_repr(obj)} is an instance of {cls!r}'
+            self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertIsSubclass(self, cls, superclass, msg=None):
+        try:
+            if issubclass(cls, superclass):
+                return
+        except TypeError:
+            if not isinstance(cls, type):
+                self.fail(self._formatMessage(msg, f'{cls!r} is not a class'))
+            raise
+        if isinstance(superclass, tuple):
+            standardMsg = f'{cls!r} is not a subclass of any of {superclass!r}'
+        else:
+            standardMsg = f'{cls!r} is not a subclass of {superclass!r}'
+        self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertNotIsSubclass(self, cls, superclass, msg=None):
+        try:
+            if not issubclass(cls, superclass):
+                return
+        except TypeError:
+            if not isinstance(cls, type):
+                self.fail(self._formatMessage(msg, f'{cls!r} is not a class'))
+            raise
+        if isinstance(superclass, tuple):
+            for x in superclass:
+                if issubclass(cls, x):
+                    superclass = x
+                    break
+        standardMsg = f'{cls!r} is a subclass of {superclass!r}'
+        self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertHasAttr(self, obj, name, msg=None):
+        if not hasattr(obj, name):
+            if isinstance(obj, types.ModuleType):
+                standardMsg = f'module {obj.__name__!r} has no attribute {name!r}'
+            elif isinstance(obj, type):
+                standardMsg = f'type object {obj.__name__!r} has no attribute {name!r}'
+            else:
+                standardMsg = f'{type(obj).__name__!r} object has no attribute {name!r}'
+            self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertNotHasAttr(self, obj, name, msg=None):
+        if hasattr(obj, name):
+            if isinstance(obj, types.ModuleType):
+                standardMsg = f'module {obj.__name__!r} has unexpected attribute {name!r}'
+            elif isinstance(obj, type):
+                standardMsg = f'type object {obj.__name__!r} has unexpected attribute {name!r}'
+            else:
+                standardMsg = f'{type(obj).__name__!r} object has unexpected attribute {name!r}'
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertRaisesRegex(self, expected_exception, expected_regex,
@@ -1382,6 +1463,80 @@ def assertNotRegex(self, text, unexpected_regex, msg=None):
             msg = self._formatMessage(msg, standardMsg)
             raise self.failureException(msg)
 
+    def _tail_type_check(self, s, tails, msg):
+        if not isinstance(tails, tuple):
+            tails = (tails,)
+        for tail in tails:
+            if isinstance(tail, str):
+                if not isinstance(s, str):
+                    self.fail(self._formatMessage(msg,
+                            f'Expected str, not {type(s).__name__}'))
+            elif isinstance(tail, (bytes, bytearray)):
+                if not isinstance(s, (bytes, bytearray)):
+                    self.fail(self._formatMessage(msg,
+                            f'Expected bytes, not {type(s).__name__}'))
+
+    def assertStartsWith(self, s, prefix, msg=None):
+        try:
+            if s.startswith(prefix):
+                return
+        except (AttributeError, TypeError):
+            self._tail_type_check(s, prefix, msg)
+            raise
+        a = safe_repr(s, short=True)
+        b = safe_repr(prefix)
+        if isinstance(prefix, tuple):
+            standardMsg = f"{a} doesn't start with any of {b}"
+        else:
+            standardMsg = f"{a} doesn't start with {b}"
+        self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertNotStartsWith(self, s, prefix, msg=None):
+        try:
+            if not s.startswith(prefix):
+                return
+        except (AttributeError, TypeError):
+            self._tail_type_check(s, prefix, msg)
+            raise
+        if isinstance(prefix, tuple):
+            for x in prefix:
+                if s.startswith(x):
+                    prefix = x
+                    break
+        a = safe_repr(s, short=True)
+        b = safe_repr(prefix)
+        self.fail(self._formatMessage(msg, f"{a} starts with {b}"))
+
+    def assertEndsWith(self, s, suffix, msg=None):
+        try:
+            if s.endswith(suffix):
+                return
+        except (AttributeError, TypeError):
+            self._tail_type_check(s, suffix, msg)
+            raise
+        a = safe_repr(s, short=True)
+        b = safe_repr(suffix)
+        if isinstance(suffix, tuple):
+            standardMsg = f"{a} doesn't end with any of {b}"
+        else:
+            standardMsg = f"{a} doesn't end with {b}"
+        self.fail(self._formatMessage(msg, standardMsg))
+
+    def assertNotEndsWith(self, s, suffix, msg=None):
+        try:
+            if not s.endswith(suffix):
+                return
+        except (AttributeError, TypeError):
+            self._tail_type_check(s, suffix, msg)
+            raise
+        if isinstance(suffix, tuple):
+            for x in suffix:
+                if s.endswith(x):
+                    suffix = x
+                    break
+        a = safe_repr(s, short=True)
+        b = safe_repr(suffix)
+        self.fail(self._formatMessage(msg, f"{a} ends with {b}"))
 
 
 class FunctionTestCase(TestCase):
diff --git a/Lib/unittest/loader.py b/Lib/unittest/loader.py
index 22797b83a68..fa8d647ad8a 100644
--- a/Lib/unittest/loader.py
+++ b/Lib/unittest/loader.py
@@ -1,12 +1,11 @@
 """Loading unittests."""
 
+import functools
 import os
 import re
 import sys
 import traceback
 import types
-import functools
-
 from fnmatch import fnmatch, fnmatchcase
 
 from . import case, suite, util
@@ -274,6 +273,8 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
         self._top_level_dir = top_level_dir
 
         is_not_importable = False
+        is_namespace = False
+        tests = []
         if os.path.isdir(os.path.abspath(start_dir)):
             start_dir = os.path.abspath(start_dir)
             if start_dir != top_level_dir:
@@ -286,12 +287,25 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
                 is_not_importable = True
             else:
                 the_module = sys.modules[start_dir]
-                top_part = start_dir.split('.')[0]
-                try:
-                    start_dir = os.path.abspath(
-                        os.path.dirname((the_module.__file__)))
-                except AttributeError:
-                    if the_module.__name__ in sys.builtin_module_names:
+                if not hasattr(the_module, "__file__") or the_module.__file__ is None:
+                    # look for namespace packages
+                    try:
+                        spec = the_module.__spec__
+                    except AttributeError:
+                        spec = None
+
+                    if spec and spec.submodule_search_locations is not None:
+                        is_namespace = True
+
+                        for path in the_module.__path__:
+                            if (not set_implicit_top and
+                                not path.startswith(top_level_dir)):
+                                continue
+                            self._top_level_dir = \
+                                (path.split(the_module.__name__
+                                        .replace(".", os.path.sep))[0])
+                            tests.extend(self._find_tests(path, pattern, namespace=True))
+                    elif the_module.__name__ in sys.builtin_module_names:
                         # builtin module
                         raise TypeError('Can not use builtin modules '
                                         'as dotted module names') from None
@@ -300,14 +314,27 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
                             f"don't know how to discover from {the_module!r}"
                             ) from None
 
+                else:
+                    top_part = start_dir.split('.')[0]
+                    start_dir = os.path.abspath(os.path.dirname((the_module.__file__)))
+
                 if set_implicit_top:
-                    self._top_level_dir = self._get_directory_containing_module(top_part)
+                    if not is_namespace:
+                        if sys.modules[top_part].__file__ is None:
+                            self._top_level_dir = os.path.dirname(the_module.__file__)
+                            if self._top_level_dir not in sys.path:
+                                sys.path.insert(0, self._top_level_dir)
+                        else:
+                            self._top_level_dir = \
+                                self._get_directory_containing_module(top_part)
                     sys.path.remove(top_level_dir)
 
         if is_not_importable:
             raise ImportError('Start directory is not importable: %r' % start_dir)
 
-        tests = list(self._find_tests(start_dir, pattern))
+        if not is_namespace:
+            tests = list(self._find_tests(start_dir, pattern))
+
         self._top_level_dir = original_top_level_dir
         return self.suiteClass(tests)
 
@@ -343,7 +370,7 @@ def _match_path(self, path, full_path, pattern):
         # override this method to use alternative matching strategy
         return fnmatch(path, pattern)
 
-    def _find_tests(self, start_dir, pattern):
+    def _find_tests(self, start_dir, pattern, namespace=False):
         """Used by discovery. Yields test suites it loads."""
         # Handle the __init__ in this package
         name = self._get_name_from_path(start_dir)
@@ -352,7 +379,8 @@ def _find_tests(self, start_dir, pattern):
         if name != '.' and name not in self._loading_packages:
             # name is in self._loading_packages while we have called into
             # loadTestsFromModule with name.
-            tests, should_recurse = self._find_test_path(start_dir, pattern)
+            tests, should_recurse = self._find_test_path(
+                start_dir, pattern, namespace)
             if tests is not None:
                 yield tests
             if not should_recurse:
@@ -363,7 +391,8 @@ def _find_tests(self, start_dir, pattern):
         paths = sorted(os.listdir(start_dir))
         for path in paths:
             full_path = os.path.join(start_dir, path)
-            tests, should_recurse = self._find_test_path(full_path, pattern)
+            tests, should_recurse = self._find_test_path(
+                full_path, pattern, False)
             if tests is not None:
                 yield tests
             if should_recurse:
@@ -371,11 +400,11 @@ def _find_tests(self, start_dir, pattern):
                 name = self._get_name_from_path(full_path)
                 self._loading_packages.add(name)
                 try:
-                    yield from self._find_tests(full_path, pattern)
+                    yield from self._find_tests(full_path, pattern, False)
                 finally:
                     self._loading_packages.discard(name)
 
-    def _find_test_path(self, full_path, pattern):
+    def _find_test_path(self, full_path, pattern, namespace=False):
         """Used by discovery.
 
         Loads tests from a single file, or a directories' __init__.py when
@@ -419,7 +448,8 @@ def _find_test_path(self, full_path, pattern):
                         msg % (mod_name, module_dir, expected_dir))
                 return self.loadTestsFromModule(module, pattern=pattern), False
         elif os.path.isdir(full_path):
-            if not os.path.isfile(os.path.join(full_path, '__init__.py')):
+            if (not namespace and
+                not os.path.isfile(os.path.join(full_path, '__init__.py'))):
                 return None, False
 
             load_tests = None
diff --git a/Lib/unittest/main.py b/Lib/unittest/main.py
index a0cd8a9f7ea..1855fccf336 100644
--- a/Lib/unittest/main.py
+++ b/Lib/unittest/main.py
@@ -1,8 +1,8 @@
 """Unittest main program"""
 
-import sys
 import argparse
 import os
+import sys
 
 from . import loader, runner
 from .signals import installHandler
@@ -197,7 +197,7 @@ def _getParentArgParser(self):
         return parser
 
     def _getMainArgParser(self, parent):
-        parser = argparse.ArgumentParser(parents=[parent])
+        parser = argparse.ArgumentParser(parents=[parent], color=True)
         parser.prog = self.progName
         parser.print_help = self._print_help
 
@@ -208,7 +208,7 @@ def _getMainArgParser(self, parent):
         return parser
 
     def _getDiscoveryArgParser(self, parent):
-        parser = argparse.ArgumentParser(parents=[parent])
+        parser = argparse.ArgumentParser(parents=[parent], color=True)
         parser.prog = '%s discover' % self.progName
         parser.epilog = ('For test discovery all test modules must be '
                          'importable from the top level directory of the '
diff --git a/Lib/unittest/mock.py b/Lib/unittest/mock.py
index 6cec61ff35c..1089dcb11f1 100644
--- a/Lib/unittest/mock.py
+++ b/Lib/unittest/mock.py
@@ -25,19 +25,20 @@
 
 
 import asyncio
+import builtins
 import contextlib
-import io
 import inspect
+import io
+import pkgutil
 import pprint
 import sys
-import builtins
-import pkgutil
-from asyncio import iscoroutinefunction
 import threading
-from types import CodeType, ModuleType, MethodType
-from unittest.util import safe_repr
-from functools import wraps, partial
+from dataclasses import fields, is_dataclass
+from functools import partial, wraps
+from inspect import iscoroutinefunction
 from threading import RLock
+from types import CodeType, MethodType, ModuleType
+from unittest.util import safe_repr
 
 
 class InvalidSpecError(Exception):
@@ -568,6 +569,11 @@ def _mock_add_spec(self, spec, spec_set, _spec_as_instance=False,
         __dict__['_mock_methods'] = spec
         __dict__['_spec_asyncs'] = _spec_asyncs
 
+    def _mock_extend_spec_methods(self, spec_methods):
+        methods = self.__dict__.get('_mock_methods') or []
+        methods.extend(spec_methods)
+        self.__dict__['_mock_methods'] = methods
+
     def __get_return_value(self):
         ret = self._mock_return_value
         if self._mock_delegate is not None:
@@ -1766,7 +1772,7 @@ def patch(
     the patch is undone.
 
     If `new` is omitted, then the target is replaced with an
-    `AsyncMock if the patched object is an async function or a
+    `AsyncMock` if the patched object is an async function or a
     `MagicMock` otherwise. If `patch` is used as a decorator and `new` is
     omitted, the created mock is passed in as an extra argument to the
     decorated function. If `patch` is used as a context manager the created
@@ -1840,7 +1846,8 @@ def patch(
 class _patch_dict(object):
     """
     Patch a dictionary, or dictionary like object, and restore the dictionary
-    to its original state after the test.
+    to its original state after the test, where the restored dictionary is
+    a copy of the dictionary as it was before the test.
 
     `in_dict` can be a dictionary or a mapping like container. If it is a
     mapping then it must at least support getting, setting and deleting items
@@ -2176,8 +2183,6 @@ def _mock_set_magics(self):
 
         if getattr(self, "_mock_methods", None) is not None:
             these_magics = orig_magics.intersection(self._mock_methods)
-
-            remove_magics = set()
             remove_magics = orig_magics - these_magics
 
             for entry in remove_magics:
@@ -2477,7 +2482,7 @@ class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock):
     recognized as an async function, and the result of a call is an awaitable:
 
     >>> mock = AsyncMock()
-    >>> iscoroutinefunction(mock)
+    >>> inspect.iscoroutinefunction(mock)
     True
     >>> inspect.isawaitable(mock())
     True
@@ -2767,6 +2772,16 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
                                f'[object={spec!r}]')
     is_async_func = _is_async_func(spec)
     _kwargs = {'spec': spec}
+
+    entries = [(entry, _missing) for entry in dir(spec)]
+    if is_type and instance and is_dataclass(spec):
+        is_dataclass_spec = True
+        dataclass_fields = fields(spec)
+        entries.extend((f.name, f.type) for f in dataclass_fields)
+        dataclass_spec_list = [f.name for f in dataclass_fields]
+    else:
+        is_dataclass_spec = False
+
     if spec_set:
         _kwargs = {'spec_set': spec}
     elif spec is None:
@@ -2802,6 +2817,8 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
 
     mock = Klass(parent=_parent, _new_parent=_parent, _new_name=_new_name,
                  name=_name, **_kwargs)
+    if is_dataclass_spec:
+        mock._mock_extend_spec_methods(dataclass_spec_list)
 
     if isinstance(spec, FunctionTypes):
         # should only happen at the top level because we don't
@@ -2823,7 +2840,7 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
                                             _name='()', _parent=mock,
                                             wraps=wrapped)
 
-    for entry in dir(spec):
+    for entry, original in entries:
         if _is_magic(entry):
             # MagicMock already does the useful magic methods for us
             continue
@@ -2837,10 +2854,11 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         # AttributeError on being fetched?
         # we could be resilient against it, or catch and propagate the
         # exception when the attribute is fetched from the mock
-        try:
-            original = getattr(spec, entry)
-        except AttributeError:
-            continue
+        if original is _missing:
+            try:
+                original = getattr(spec, entry)
+            except AttributeError:
+                continue
 
         child_kwargs = {'spec': original}
         # Wrap child attributes also.
diff --git a/Lib/unittest/result.py b/Lib/unittest/result.py
index 3ace0a5b7bf..8eafb3891c9 100644
--- a/Lib/unittest/result.py
+++ b/Lib/unittest/result.py
@@ -3,9 +3,9 @@
 import io
 import sys
 import traceback
+from functools import wraps
 
 from . import util
-from functools import wraps
 
 __unittest = True
 
@@ -189,7 +189,10 @@ def _exc_info_to_string(self, err, test):
         tb_e = traceback.TracebackException(
             exctype, value, tb,
             capture_locals=self.tb_locals, compact=True)
-        msgLines = list(tb_e.format())
+        from _colorize import can_colorize
+
+        colorize = hasattr(self, "stream") and can_colorize(file=self.stream)
+        msgLines = list(tb_e.format(colorize=colorize))
 
         if self.buffer:
             output = sys.stdout.getvalue()
diff --git a/Lib/unittest/runner.py b/Lib/unittest/runner.py
index 2bcadf0c998..5f22d91aebd 100644
--- a/Lib/unittest/runner.py
+++ b/Lib/unittest/runner.py
@@ -4,6 +4,8 @@
 import time
 import warnings
 
+from _colorize import get_theme
+
 from . import result
 from .case import _SubTest
 from .signals import registerResult
@@ -13,18 +15,18 @@
 
 class _WritelnDecorator(object):
     """Used to decorate file-like objects with a handy 'writeln' method"""
-    def __init__(self,stream):
+    def __init__(self, stream):
         self.stream = stream
 
     def __getattr__(self, attr):
         if attr in ('stream', '__getstate__'):
             raise AttributeError(attr)
-        return getattr(self.stream,attr)
+        return getattr(self.stream, attr)
 
     def writeln(self, arg=None):
         if arg:
             self.write(arg)
-        self.write('\n') # text-mode streams translate to \r\n if needed
+        self.write('\n')  # text-mode streams translate to \r\n if needed
 
 
 class TextTestResult(result.TestResult):
@@ -43,6 +45,7 @@ def __init__(self, stream, descriptions, verbosity, *, durations=None):
         self.showAll = verbosity > 1
         self.dots = verbosity == 1
         self.descriptions = descriptions
+        self._theme = get_theme(tty_file=stream).unittest
         self._newline = True
         self.durations = durations
 
@@ -76,86 +79,100 @@ def _write_status(self, test, status):
 
     def addSubTest(self, test, subtest, err):
         if err is not None:
+            t = self._theme
             if self.showAll:
                 if issubclass(err[0], subtest.failureException):
-                    self._write_status(subtest, "FAIL")
+                    self._write_status(subtest, f"{t.fail}FAIL{t.reset}")
                 else:
-                    self._write_status(subtest, "ERROR")
+                    self._write_status(subtest, f"{t.fail}ERROR{t.reset}")
             elif self.dots:
                 if issubclass(err[0], subtest.failureException):
-                    self.stream.write('F')
+                    self.stream.write(f"{t.fail}F{t.reset}")
                 else:
-                    self.stream.write('E')
+                    self.stream.write(f"{t.fail}E{t.reset}")
                 self.stream.flush()
         super(TextTestResult, self).addSubTest(test, subtest, err)
 
     def addSuccess(self, test):
         super(TextTestResult, self).addSuccess(test)
+        t = self._theme
         if self.showAll:
-            self._write_status(test, "ok")
+            self._write_status(test, f"{t.passed}ok{t.reset}")
         elif self.dots:
-            self.stream.write('.')
+            self.stream.write(f"{t.passed}.{t.reset}")
             self.stream.flush()
 
     def addError(self, test, err):
         super(TextTestResult, self).addError(test, err)
+        t = self._theme
         if self.showAll:
-            self._write_status(test, "ERROR")
+            self._write_status(test, f"{t.fail}ERROR{t.reset}")
         elif self.dots:
-            self.stream.write('E')
+            self.stream.write(f"{t.fail}E{t.reset}")
             self.stream.flush()
 
     def addFailure(self, test, err):
         super(TextTestResult, self).addFailure(test, err)
+        t = self._theme
         if self.showAll:
-            self._write_status(test, "FAIL")
+            self._write_status(test, f"{t.fail}FAIL{t.reset}")
         elif self.dots:
-            self.stream.write('F')
+            self.stream.write(f"{t.fail}F{t.reset}")
             self.stream.flush()
 
     def addSkip(self, test, reason):
         super(TextTestResult, self).addSkip(test, reason)
+        t = self._theme
         if self.showAll:
-            self._write_status(test, "skipped {0!r}".format(reason))
+            self._write_status(test, f"{t.warn}skipped{t.reset} {reason!r}")
         elif self.dots:
-            self.stream.write("s")
+            self.stream.write(f"{t.warn}s{t.reset}")
             self.stream.flush()
 
     def addExpectedFailure(self, test, err):
         super(TextTestResult, self).addExpectedFailure(test, err)
+        t = self._theme
         if self.showAll:
-            self.stream.writeln("expected failure")
+            self.stream.writeln(f"{t.warn}expected failure{t.reset}")
             self.stream.flush()
         elif self.dots:
-            self.stream.write("x")
+            self.stream.write(f"{t.warn}x{t.reset}")
             self.stream.flush()
 
     def addUnexpectedSuccess(self, test):
         super(TextTestResult, self).addUnexpectedSuccess(test)
+        t = self._theme
         if self.showAll:
-            self.stream.writeln("unexpected success")
+            self.stream.writeln(f"{t.fail}unexpected success{t.reset}")
             self.stream.flush()
         elif self.dots:
-            self.stream.write("u")
+            self.stream.write(f"{t.fail}u{t.reset}")
             self.stream.flush()
 
     def printErrors(self):
+        t = self._theme
         if self.dots or self.showAll:
             self.stream.writeln()
             self.stream.flush()
-        self.printErrorList('ERROR', self.errors)
-        self.printErrorList('FAIL', self.failures)
-        unexpectedSuccesses = getattr(self, 'unexpectedSuccesses', ())
+        self.printErrorList(f"{t.fail}ERROR{t.reset}", self.errors)
+        self.printErrorList(f"{t.fail}FAIL{t.reset}", self.failures)
+        unexpectedSuccesses = getattr(self, "unexpectedSuccesses", ())
         if unexpectedSuccesses:
             self.stream.writeln(self.separator1)
             for test in unexpectedSuccesses:
-                self.stream.writeln(f"UNEXPECTED SUCCESS: {self.getDescription(test)}")
+                self.stream.writeln(
+                    f"{t.fail}UNEXPECTED SUCCESS{t.fail_info}: "
+                    f"{self.getDescription(test)}{t.reset}"
+                )
             self.stream.flush()
 
     def printErrorList(self, flavour, errors):
+        t = self._theme
         for test, err in errors:
             self.stream.writeln(self.separator1)
-            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
+            self.stream.writeln(
+                f"{flavour}{t.fail_info}: {self.getDescription(test)}{t.reset}"
+            )
             self.stream.writeln(self.separator2)
             self.stream.writeln("%s" % err)
             self.stream.flush()
@@ -232,7 +249,7 @@ def run(self, test):
             if self.warnings:
                 # if self.warnings is set, use it to filter all the warnings
                 warnings.simplefilter(self.warnings)
-            startTime = time.perf_counter()
+            start_time = time.perf_counter()
             startTestRun = getattr(result, 'startTestRun', None)
             if startTestRun is not None:
                 startTestRun()
@@ -242,8 +259,8 @@ def run(self, test):
                 stopTestRun = getattr(result, 'stopTestRun', None)
                 if stopTestRun is not None:
                     stopTestRun()
-            stopTime = time.perf_counter()
-        timeTaken = stopTime - startTime
+            stop_time = time.perf_counter()
+        time_taken = stop_time - start_time
         result.printErrors()
         if self.durations is not None:
             self._printDurations(result)
@@ -253,10 +270,10 @@ def run(self, test):
 
         run = result.testsRun
         self.stream.writeln("Ran %d test%s in %.3fs" %
-                            (run, run != 1 and "s" or "", timeTaken))
+                            (run, run != 1 and "s" or "", time_taken))
         self.stream.writeln()
 
-        expectedFails = unexpectedSuccesses = skipped = 0
+        expected_fails = unexpected_successes = skipped = 0
         try:
             results = map(len, (result.expectedFailures,
                                 result.unexpectedSuccesses,
@@ -264,26 +281,30 @@ def run(self, test):
         except AttributeError:
             pass
         else:
-            expectedFails, unexpectedSuccesses, skipped = results
+            expected_fails, unexpected_successes, skipped = results
 
         infos = []
+        t = get_theme(tty_file=self.stream).unittest
+
         if not result.wasSuccessful():
-            self.stream.write("FAILED")
+            self.stream.write(f"{t.fail_info}FAILED{t.reset}")
             failed, errored = len(result.failures), len(result.errors)
             if failed:
-                infos.append("failures=%d" % failed)
+                infos.append(f"{t.fail_info}failures={failed}{t.reset}")
             if errored:
-                infos.append("errors=%d" % errored)
+                infos.append(f"{t.fail_info}errors={errored}{t.reset}")
         elif run == 0 and not skipped:
-            self.stream.write("NO TESTS RAN")
+            self.stream.write(f"{t.warn}NO TESTS RAN{t.reset}")
         else:
-            self.stream.write("OK")
+            self.stream.write(f"{t.passed}OK{t.reset}")
         if skipped:
-            infos.append("skipped=%d" % skipped)
-        if expectedFails:
-            infos.append("expected failures=%d" % expectedFails)
-        if unexpectedSuccesses:
-            infos.append("unexpected successes=%d" % unexpectedSuccesses)
+            infos.append(f"{t.warn}skipped={skipped}{t.reset}")
+        if expected_fails:
+            infos.append(f"{t.warn}expected failures={expected_fails}{t.reset}")
+        if unexpected_successes:
+            infos.append(
+                f"{t.fail}unexpected successes={unexpected_successes}{t.reset}"
+            )
         if infos:
             self.stream.writeln(" (%s)" % (", ".join(infos),))
         else:
diff --git a/Lib/unittest/signals.py b/Lib/unittest/signals.py
index e6a5fc52439..4e654c2c5db 100644
--- a/Lib/unittest/signals.py
+++ b/Lib/unittest/signals.py
@@ -1,6 +1,5 @@
 import signal
 import weakref
-
 from functools import wraps
 
 __unittest = True
diff --git a/Lib/unittest/suite.py b/Lib/unittest/suite.py
index 6f45b6fe5f6..3c40176f070 100644
--- a/Lib/unittest/suite.py
+++ b/Lib/unittest/suite.py
@@ -2,8 +2,7 @@
 
 import sys
 
-from . import case
-from . import util
+from . import case, util
 
 __unittest = True
 
diff --git a/Lib/unittest/util.py b/Lib/unittest/util.py
index 050eaed0b3f..b81b6a4219b 100644
--- a/Lib/unittest/util.py
+++ b/Lib/unittest/util.py
@@ -1,6 +1,6 @@
 """Various utility functions."""
 
-from collections import namedtuple, Counter
+from collections import Counter, namedtuple
 from os.path import commonprefix
 
 __unittest = True

From e0185aefb1bf0661748e22e22986af32b4a146b7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sun, 18 Jan 2026 13:54:15 +0900
Subject: [PATCH 360/418] mark failing tests

---
 Lib/test/test_unittest/test_async_case.py | 6 +++++-
 Lib/test/test_unittest/test_discovery.py  | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index 87808fcbaaf..7b3cb949e4c 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -13,7 +13,9 @@ class MyException(Exception):
 
 
 def tearDownModule():
-    asyncio.events._set_event_loop_policy(None)
+    # XXX: RUSTPYTHON; asyncio.events._set_event_loop_policy is not implemented
+    # asyncio.events._set_event_loop_policy(None)
+    pass
 
 
 class TestCM:
@@ -476,6 +478,7 @@ async def cleanup(self, fut):
         test.doCleanups()
         self.assertEqual(events, ['asyncSetUp', 'test', 'cleanup'])
 
+    @unittest.expectedFailure
     def test_setup_get_event_loop(self):
         # See https://github.com/python/cpython/issues/95736
         # Make sure the default event loop is not used
@@ -492,6 +495,7 @@ async def test_demo1(self):
         result = test.run()
         self.assertTrue(result.wasSuccessful())
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; asyncio.events._set_event_loop_policy is not implemented
     def test_loop_factory(self):
         asyncio.events._set_event_loop_policy(None)
 
diff --git a/Lib/test/test_unittest/test_discovery.py b/Lib/test/test_unittest/test_discovery.py
index a60064d2919..9ed3d04b1f8 100644
--- a/Lib/test/test_unittest/test_discovery.py
+++ b/Lib/test/test_unittest/test_discovery.py
@@ -884,6 +884,7 @@ def _find_tests(start_dir, pattern, namespace=None):
 
         self.assertEqual(suite, ['/a/tests', '/b/tests'])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_discovery_start_dir_is_namespace(self):
         """Subdirectory discovery not affected if start_dir is a namespace pkg."""
         loader = unittest.TestLoader()

From 005014a3f9e1e9e1b6c447c53f7320a1e4b94675 Mon Sep 17 00:00:00 2001
From: CPython Devleopers <>
Date: Sun, 18 Jan 2026 13:39:54 +0900
Subject: [PATCH 361/418] Update test.support from 3.14.2

---
 Lib/test/support/__init__.py                  | 735 +++++++++++-------
 .../support/_hypothesis_stubs/__init__.py     |   2 +-
 Lib/test/support/ast_helper.py                |   4 +
 Lib/test/support/asynchat.py                  |   2 +-
 Lib/test/support/asyncore.py                  |  24 +-
 Lib/test/support/bytecode_helper.py           |   5 +-
 .../support/{interpreters => }/channels.py    | 111 ++-
 Lib/test/support/hashlib_helper.py            | 335 +++++++-
 Lib/test/support/hypothesis_helper.py         |   3 +-
 Lib/test/support/i18n_helper.py               |   2 +-
 Lib/test/support/import_helper.py             | 137 +++-
 Lib/test/support/interpreters/__init__.py     | 258 ------
 Lib/test/support/interpreters/_crossinterp.py | 102 ---
 Lib/test/support/interpreters/queues.py       | 313 --------
 Lib/test/support/logging_helper.py            |   1 +
 Lib/test/support/os_helper.py                 |  28 +-
 Lib/test/support/pty_helper.py                |   1 +
 Lib/test/support/script_helper.py             |  43 +-
 Lib/test/support/smtpd.py                     |  30 +-
 Lib/test/support/socket_helper.py             |   2 +-
 Lib/test/support/strace_helper.py             | 210 +++++
 Lib/test/support/testcase.py                  |   1 +
 Lib/test/support/testresult.py                | 191 -----
 Lib/test/support/threading_helper.py          |  25 +-
 Lib/test/support/venv.py                      |  13 +-
 Lib/test/support/warnings_helper.py           |  14 +-
 Lib/test/test_support.py                      |  68 +-
 27 files changed, 1371 insertions(+), 1289 deletions(-)
 rename Lib/test/support/{interpreters => }/channels.py (73%)
 delete mode 100644 Lib/test/support/interpreters/__init__.py
 delete mode 100644 Lib/test/support/interpreters/_crossinterp.py
 delete mode 100644 Lib/test/support/interpreters/queues.py
 mode change 100644 => 100755 Lib/test/support/smtpd.py
 create mode 100644 Lib/test/support/strace_helper.py
 delete mode 100644 Lib/test/support/testresult.py

diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index 444ca2219cf..e221ee04630 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -3,11 +3,11 @@
 if __name__ != 'test.support':
     raise ImportError('support must be imported from the test package')
 
+import _opcode
 import contextlib
-import dataclasses
 import functools
+import inspect
 import logging
-import _opcode
 import os
 import re
 import stat
@@ -19,6 +19,7 @@
 import unittest
 import warnings
 
+import annotationlib
 
 __all__ = [
     # globals
@@ -32,7 +33,7 @@
     "is_resource_enabled", "requires", "requires_freebsd_version",
     "requires_gil_enabled", "requires_linux_version", "requires_mac_ver",
     "check_syntax_error",
-    "requires_gzip", "requires_bz2", "requires_lzma",
+    "requires_gzip", "requires_bz2", "requires_lzma", "requires_zstd",
     "bigmemtest", "bigaddrspacetest", "cpython_only", "get_attribute",
     "requires_IEEE_754", "requires_zlib",
     "has_fork_support", "requires_fork",
@@ -41,10 +42,11 @@
     "anticipate_failure", "load_package_tests", "detect_api_mismatch",
     "check__all__", "skip_if_buggy_ucrt_strfptime",
     "check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer",
-    "requires_limited_api", "requires_specialization",
+    "requires_limited_api", "requires_specialization", "thread_unsafe",
     # sys
     "MS_WINDOWS", "is_jython", "is_android", "is_emscripten", "is_wasi",
     "is_apple_mobile", "check_impl_detail", "unix_shell", "setswitchinterval",
+    "support_remote_exec_only",
     # os
     "get_pagesize",
     # network
@@ -57,13 +59,16 @@
     "run_with_tz", "PGO", "missing_compiler_executable",
     "ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",
     "LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",
-    "Py_DEBUG", "exceeds_recursion_limit", "get_c_recursion_limit",
-    "skip_on_s390x",
-    "without_optimizer",
+    "Py_DEBUG", "exceeds_recursion_limit", "skip_on_s390x",
+    "requires_jit_enabled",
+    "requires_jit_disabled",
     "force_not_colorized",
     "force_not_colorized_test_class",
     "make_clean_env",
     "BrokenIter",
+    "in_systemd_nspawn_sync_suppressed",
+    "run_no_yield_async_fn", "run_yielding_async_fn", "async_yield",
+    "reset_code", "on_github_actions"
     ]
 
 
@@ -389,6 +394,21 @@ def wrapper(*args, **kw):
     return decorator
 
 
+def thread_unsafe(reason):
+    """Mark a test as not thread safe. When the test runner is run with
+    --parallel-threads=N, the test will be run in a single thread."""
+    def decorator(test_item):
+        test_item.__unittest_thread_unsafe__ = True
+        # the reason is not currently used
+        test_item.__unittest_thread_unsafe__why__ = reason
+        return test_item
+    if isinstance(reason, types.FunctionType):
+        test_item = reason
+        reason = ''
+        return decorator(test_item)
+    return decorator
+
+
 def skip_if_buildbot(reason=None):
     """Decorator raising SkipTest if running on a buildbot."""
     import getpass
@@ -401,7 +421,8 @@ def skip_if_buildbot(reason=None):
         isbuildbot = False
     return unittest.skipIf(isbuildbot, reason)
 
-def check_sanitizer(*, address=False, memory=False, ub=False, thread=False):
+def check_sanitizer(*, address=False, memory=False, ub=False, thread=False,
+                    function=True):
     """Returns True if Python is compiled with sanitizer support"""
     if not (address or memory or ub or thread):
         raise ValueError('At least one of address, memory, ub or thread must be True')
@@ -425,11 +446,15 @@ def check_sanitizer(*, address=False, memory=False, ub=False, thread=False):
         '-fsanitize=thread' in cflags or
         '--with-thread-sanitizer' in config_args
     )
+    function_sanitizer = (
+        '-fsanitize=function' in cflags
+    )
     return (
         (memory and memory_sanitizer) or
         (address and address_sanitizer) or
         (ub and ub_sanitizer) or
-        (thread and thread_sanitizer)
+        (thread and thread_sanitizer) or
+        (function and function_sanitizer)
     )
 
 
@@ -514,13 +539,19 @@ def requires_lzma(reason='requires lzma'):
     lzma = None # XXX: RUSTPYTHON; xz is not supported yet
     return unittest.skipUnless(lzma, reason)
 
+def requires_zstd(reason='requires zstd'):
+    try:
+        from compression import zstd
+    except ImportError:
+        zstd = None
+    return unittest.skipUnless(zstd, reason)
+
 def has_no_debug_ranges():
     try:
-        import _testinternalcapi
+        import _testcapi
     except ImportError:
         raise unittest.SkipTest("_testinternalcapi required")
-    config = _testinternalcapi.get_config()
-    return not bool(config['code_debug_ranges'])
+    return not _testcapi.config_get('code_debug_ranges')
 
 def requires_debug_ranges(reason='requires co_positions / debug_ranges'):
     try:
@@ -531,6 +562,7 @@ def requires_debug_ranges(reason='requires co_positions / debug_ranges'):
     return unittest.skipIf(skip, reason)
 
 
+# XXX: RUSTPYTHON; this is not belong to 3.14
 def can_use_suppress_immortalization(suppress=True):
     """Check if suppress_immortalization(suppress) can be used.
 
@@ -583,6 +615,11 @@ def skip_if_suppress_immortalization():
 
 is_android = sys.platform == "android"
 
+def skip_android_selinux(name):
+    return unittest.skipIf(
+        sys.platform == "android", f"Android blocks {name} with SELinux"
+    )
+
 if sys.platform not in {"win32", "vxworks", "ios", "tvos", "watchos"}:
     unix_shell = '/system/bin/sh' if is_android else '/bin/sh'
 else:
@@ -593,6 +630,15 @@ def skip_if_suppress_immortalization():
 is_emscripten = sys.platform == "emscripten"
 is_wasi = sys.platform == "wasi"
 
+# Use is_wasm32 as a generic check for WebAssembly platforms.
+is_wasm32 = is_emscripten or is_wasi
+
+def skip_emscripten_stack_overflow():
+    return unittest.skipIf(is_emscripten, "Exhausts stack on Emscripten")
+
+def skip_wasi_stack_overflow():
+    return unittest.skipIf(is_wasi, "Exhausts stack on WASI")
+
 is_apple_mobile = sys.platform in {"ios", "tvos", "watchos"}
 is_apple = is_apple_mobile or sys.platform == "darwin"
 
@@ -715,9 +761,11 @@ def sortdict(dict):
     return "{%s}" % withcommas
 
 
-def run_code(code: str) -> dict[str, object]:
+def run_code(code: str, extra_names: dict[str, object] | None = None) -> dict[str, object]:
     """Run a piece of code after dedenting it, and return its global namespace."""
     ns = {}
+    if extra_names:
+        ns.update(extra_names)
     exec(textwrap.dedent(code), ns)
     return ns
 
@@ -735,7 +783,9 @@ def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=N
 
 
 def open_urlresource(url, *args, **kw):
-    import urllib.request, urllib.parse
+    import urllib.parse
+    import urllib.request
+
     from .os_helper import unlink
     try:
         import gzip
@@ -953,8 +1003,16 @@ def calcvobjsize(fmt):
     return struct.calcsize(_vheader + fmt + _align)
 
 
-_TPFLAGS_HAVE_GC = 1<<14
+_TPFLAGS_STATIC_BUILTIN = 1<<1
+_TPFLAGS_DISALLOW_INSTANTIATION = 1<<7
+_TPFLAGS_IMMUTABLETYPE = 1<<8
 _TPFLAGS_HEAPTYPE = 1<<9
+_TPFLAGS_BASETYPE = 1<<10
+_TPFLAGS_READY = 1<<12
+_TPFLAGS_READYING = 1<<13
+_TPFLAGS_HAVE_GC = 1<<14
+_TPFLAGS_BASE_EXC_SUBCLASS = 1<<30
+_TPFLAGS_TYPE_SUBCLASS = 1<<31
 
 def check_sizeof(test, o, size):
     try:
@@ -1318,6 +1376,26 @@ def coverage_wrapper(*args, **kwargs):
     return coverage_wrapper
 
 
+def no_rerun(reason):
+    """Skip rerunning for a particular test.
+
+    WARNING: Use this decorator with care; skipping rerunning makes it
+    impossible to find reference leaks. Provide a clear reason for skipping the
+    test using the 'reason' parameter.
+    """
+    def deco(func):
+        assert not isinstance(func, type), func
+        _has_run = False
+        def wrapper(self):
+            nonlocal _has_run
+            if _has_run:
+                self.skipTest(reason)
+            func(self)
+            _has_run = True
+        return wrapper
+    return deco
+
+
 def refcount_test(test):
     """Decorator for tests which involve reference counting.
 
@@ -1331,8 +1409,9 @@ def refcount_test(test):
 
 def requires_limited_api(test):
     try:
-        import _testcapi
-        import _testlimitedcapi
+        import _testcapi  # noqa: F401
+
+        import _testlimitedcapi  # noqa: F401
     except ImportError:
         return unittest.skip('needs _testcapi and _testlimitedcapi modules')(test)
     return test
@@ -1347,6 +1426,18 @@ def requires_specialization(test):
         _opcode.ENABLE_SPECIALIZATION, "requires specialization")(test)
 
 
+def requires_specialization_ft(test):
+    return unittest.skipUnless(
+        _opcode.ENABLE_SPECIALIZATION_FT, "requires specialization")(test)
+
+
+def reset_code(f: types.FunctionType) -> types.FunctionType:
+    """Clear all specializations, local instrumentation, and JIT code for the given function."""
+    f.__code__ = f.__code__.replace()
+    return f
+
+on_github_actions = "GITHUB_ACTIONS" in os.environ
+
 #=======================================================================
 # Check for the presence of docstrings.
 
@@ -1575,8 +1666,8 @@ def __init__(self, link=None):
 
     if sys.platform == "win32":
         def _platform_specific(self):
-            import glob
             import _winapi
+            import glob
 
             if os.path.lexists(self.real) and not os.path.exists(self.real):
                 # App symlink appears to not exist, but we want the
@@ -1972,10 +2063,11 @@ def missing_compiler_executable(cmd_names=[]):
     missing.
 
     """
-    from setuptools._distutils import ccompiler, sysconfig
-    from setuptools import errors
     import shutil
 
+    from setuptools import errors
+    from setuptools._distutils import ccompiler, sysconfig
+
     compiler = ccompiler.new_compiler()
     sysconfig.customize_compiler(compiler)
     if compiler.compiler_type == "msvc":
@@ -2304,7 +2396,15 @@ def skip_if_broken_multiprocessing_synchronize():
             # bpo-38377: On Linux, creating a semaphore fails with OSError
             # if the current user does not have the permission to create
             # a file in /dev/shm/ directory.
-            synchronize.Lock(ctx=None)
+            import multiprocessing
+            synchronize.Lock(ctx=multiprocessing.get_context('fork'))
+            # The explicit fork mp context is required in order for
+            # TestResourceTracker.test_resource_tracker_reused to work.
+            # synchronize creates a new multiprocessing.resource_tracker
+            # process at module import time via the above call in that
+            # scenario. Awkward. This enables gh-84559. No code involved
+            # should have threads at that point so fork() should be safe.
+
         except OSError as exc:
             raise unittest.SkipTest(f"broken multiprocessing SemLock: {exc!r}")
 
@@ -2396,8 +2496,9 @@ def clear_ignored_deprecations(*tokens: object) -> None:
         raise ValueError("Provide token or tokens returned by ignore_deprecations_from")
 
     new_filters = []
+    old_filters = warnings._get_filters()
     endswith = tuple(rf"(?#support{id(token)})" for token in tokens)
-    for action, message, category, module, lineno in warnings.filters:
+    for action, message, category, module, lineno in old_filters:
         if action == "ignore" and category is DeprecationWarning:
             if isinstance(message, re.Pattern):
                 msg = message.pattern
@@ -2406,8 +2507,8 @@ def clear_ignored_deprecations(*tokens: object) -> None:
             if msg.endswith(endswith):
                 continue
         new_filters.append((action, message, category, module, lineno))
-    if warnings.filters != new_filters:
-        warnings.filters[:] = new_filters
+    if old_filters != new_filters:
+        old_filters[:] = new_filters
         warnings._filters_mutated()
 
 
@@ -2415,7 +2516,7 @@ def clear_ignored_deprecations(*tokens: object) -> None:
 def requires_venv_with_pip():
     # ensurepip requires zlib to open ZIP archives (.whl binary wheel packages)
     try:
-        import zlib
+        import zlib  # noqa: F401
     except ImportError:
         return unittest.skipIf(True, "venv: ensurepip requires zlib")
 
@@ -2455,6 +2556,7 @@ def _findwheel(pkgname):
 @contextlib.contextmanager
 def setup_venv_with_pip_setuptools(venv_dir):
     import subprocess
+
     from .os_helper import temp_cwd
 
     def run_command(cmd):
@@ -2610,30 +2712,30 @@ def sleeping_retry(timeout, err_msg=None, /,
         delay = min(delay * 2, max_delay)
 
 
-class CPUStopwatch:
+class Stopwatch:
     """Context manager to roughly time a CPU-bound operation.
 
-    Disables GC. Uses CPU time if it can (i.e. excludes sleeps & time of
-    other processes).
+    Disables GC. Uses perf_counter, which is a clock with the highest
+    available resolution. It is chosen even though it does include
+    time elapsed during sleep and is system-wide, because the
+    resolution of process_time is too coarse on Windows and
+    process_time does not exist everywhere (for example, WASM).
 
-    N.B.:
-    - This *includes* time spent in other threads.
+    Note:
+    - This *includes* time spent in other threads/processes.
     - Some systems only have a coarse resolution; check
-      stopwatch.clock_info.rseolution if.
+      stopwatch.clock_info.resolution when using the results.
 
     Usage:
 
-    with ProcessStopwatch() as stopwatch:
+    with Stopwatch() as stopwatch:
         ...
     elapsed = stopwatch.seconds
     resolution = stopwatch.clock_info.resolution
     """
     def __enter__(self):
-        get_time = time.process_time
-        clock_info = time.get_clock_info('process_time')
-        if get_time() <= 0:  # some platforms like WASM lack process_time()
-            get_time = time.monotonic
-            clock_info = time.get_clock_info('monotonic')
+        get_time = time.perf_counter
+        clock_info = time.get_clock_info('perf_counter')
         self.context = disable_gc()
         self.context.__enter__()
         self.get_time = get_time
@@ -2661,6 +2763,7 @@ def adjust_int_max_str_digits(max_digits):
         sys.set_int_max_str_digits(current)
 
 
+# XXX: RUSTPYTHON; removed in 3.14
 def get_c_recursion_limit():
     try:
         import _testcapi
@@ -2671,7 +2774,7 @@ def get_c_recursion_limit():
 
 def exceeds_recursion_limit():
     """For recursion tests, easily exceeds default recursion limit."""
-    return get_c_recursion_limit() * 3
+    return 150_000
 
 
 # Windows doesn't have os.uname() but it doesn't support s390x.
@@ -2680,21 +2783,11 @@ def exceeds_recursion_limit():
 
 Py_TRACE_REFS = hasattr(sys, 'getobjects')
 
-# Decorator to disable optimizer while a function run
-def without_optimizer(func):
-    try:
-        from _testinternalcapi import get_optimizer, set_optimizer
-    except ImportError:
-        return func
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        save_opt = get_optimizer()
-        try:
-            set_optimizer(None)
-            return func(*args, **kwargs)
-        finally:
-            set_optimizer(save_opt)
-    return wrapper
+# XXX: RUSTPYTHON; we don't have sys._jit yet
+# _JIT_ENABLED = sys._jit.is_enabled()
+_JIT_ENABLED = False
+requires_jit_enabled = unittest.skipUnless(_JIT_ENABLED, "requires JIT enabled")
+requires_jit_disabled = unittest.skipIf(_JIT_ENABLED, "requires JIT disabled")
 
 
 _BASE_COPY_SRC_DIR_IGNORED_NAMES = frozenset({
@@ -2724,19 +2817,121 @@ def copy_python_src_ignore(path, names):
     return ignored
 
 
-def iter_builtin_types():
-    for obj in __builtins__.values():
-        if not isinstance(obj, type):
+# XXX Move this to the inspect module?
+def walk_class_hierarchy(top, *, topdown=True):
+    # This is based on the logic in os.walk().
+    assert isinstance(top, type), repr(top)
+    stack = [top]
+    while stack:
+        top = stack.pop()
+        if isinstance(top, tuple):
+            yield top
             continue
-        cls = obj
-        if cls.__module__ != 'builtins':
+
+        subs = type(top).__subclasses__(top)
+        if topdown:
+            # Yield before subclass traversal if going top down.
+            yield top, subs
+            # Traverse into subclasses.
+            for sub in reversed(subs):
+                stack.append(sub)
+        else:
+            # Yield after subclass traversal if going bottom up.
+            stack.append((top, subs))
+            # Traverse into subclasses.
+            for sub in reversed(subs):
+                stack.append(sub)
+
+
+def iter_builtin_types():
+    # First try the explicit route.
+    try:
+        import _testinternalcapi
+    except ImportError:
+        _testinternalcapi = None
+    if _testinternalcapi is not None:
+        yield from _testinternalcapi.get_static_builtin_types()
+        return
+
+    # Fall back to making a best-effort guess.
+    if hasattr(object, '__flags__'):
+        # Look for any type object with the Py_TPFLAGS_STATIC_BUILTIN flag set.
+        import datetime
+        seen = set()
+        for cls, subs in walk_class_hierarchy(object):
+            if cls in seen:
+                continue
+            seen.add(cls)
+            if not (cls.__flags__ & _TPFLAGS_STATIC_BUILTIN):
+                # Do not walk its subclasses.
+                subs[:] = []
+                continue
+            yield cls
+    else:
+        # Fall back to a naive approach.
+        seen = set()
+        for obj in __builtins__.values():
+            if not isinstance(obj, type):
+                continue
+            cls = obj
+            # XXX?
+            if cls.__module__ != 'builtins':
+                continue
+            if cls == ExceptionGroup:
+                # It's a heap type.
+                continue
+            if cls in seen:
+                continue
+            seen.add(cls)
+            yield cls
+
+
+# XXX Move this to the inspect module?
+def iter_name_in_mro(cls, name):
+    """Yield matching items found in base.__dict__ across the MRO.
+
+    The descriptor protocol is not invoked.
+
+    list(iter_name_in_mro(cls, name))[0] is roughly equivalent to
+    find_name_in_mro() in Objects/typeobject.c (AKA PyType_Lookup()).
+
+    inspect.getattr_static() is similar.
+    """
+    # This can fail if "cls" is weird.
+    for base in inspect._static_getmro(cls):
+        # This can fail if "base" is weird.
+        ns = inspect._get_dunder_dict_of_class(base)
+        try:
+            obj = ns[name]
+        except KeyError:
             continue
-        yield cls
+        yield obj, base
 
 
-def iter_slot_wrappers(cls):
-    assert cls.__module__ == 'builtins', cls
+# XXX Move this to the inspect module?
+def find_name_in_mro(cls, name, default=inspect._sentinel):
+    for res in iter_name_in_mro(cls, name):
+        # Return the first one.
+        return res
+    if default is not inspect._sentinel:
+        return default, None
+    raise AttributeError(name)
+
 
+# XXX The return value should always be exactly the same...
+def identify_type_slot_wrappers():
+    try:
+        import _testinternalcapi
+    except ImportError:
+        _testinternalcapi = None
+    if _testinternalcapi is not None:
+        names = {n: None for n in _testinternalcapi.identify_type_slot_wrappers()}
+        return list(names)
+    else:
+        raise NotImplementedError
+
+
+def iter_slot_wrappers(cls):
     def is_slot_wrapper(name, value):
         if not isinstance(value, types.WrapperDescriptorType):
             assert not repr(value).startswith('<slot wrapper '), (cls, name, value)
@@ -2746,6 +2941,19 @@ def is_slot_wrapper(name, value):
         assert name.startswith('__') and name.endswith('__'), (cls, name, value)
         return True
 
+    try:
+        attrs = identify_type_slot_wrappers()
+    except NotImplementedError:
+        attrs = None
+    if attrs is not None:
+        for attr in sorted(attrs):
+            obj, base = find_name_in_mro(cls, attr, None)
+            if obj is not None and is_slot_wrapper(attr, obj):
+                yield attr, base is cls
+        return
+
+    # Fall back to a naive best-effort approach.
+
     ns = vars(cls)
     unused = set(ns)
     for name in dir(cls):
@@ -2780,36 +2988,60 @@ def is_slot_wrapper(name, value):
 
 
 @contextlib.contextmanager
-def no_color():
+def force_color(color: bool):
     import _colorize
+
     from .os_helper import EnvironmentVarGuard
 
     with (
-        swap_attr(_colorize, "can_colorize", lambda *, file=None: False),
+        swap_attr(_colorize, "can_colorize", lambda *, file=None: color),
         EnvironmentVarGuard() as env,
     ):
         env.unset("FORCE_COLOR", "NO_COLOR", "PYTHON_COLORS")
-        env.set("NO_COLOR", "1")
+        env.set("FORCE_COLOR" if color else "NO_COLOR", "1")
         yield
 
 
+def force_colorized(func):
+    """Force the terminal to be colorized."""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        with force_color(True):
+            return func(*args, **kwargs)
+    return wrapper
+
+
 def force_not_colorized(func):
-    """Force the terminal not to be colorized."""
+    """Force the terminal NOT to be colorized."""
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        with no_color():
+        with force_color(False):
             return func(*args, **kwargs)
     return wrapper
 
 
+def force_colorized_test_class(cls):
+    """Force the terminal to be colorized for the entire test class."""
+    original_setUpClass = cls.setUpClass
+
+    @classmethod
+    @functools.wraps(cls.setUpClass)
+    def new_setUpClass(cls):
+        cls.enterClassContext(force_color(True))
+        original_setUpClass()
+
+    cls.setUpClass = new_setUpClass
+    return cls
+
+
 def force_not_colorized_test_class(cls):
-    """Force the terminal not to be colorized for the entire test class."""
+    """Force the terminal NOT to be colorized for the entire test class."""
     original_setUpClass = cls.setUpClass
 
     @classmethod
     @functools.wraps(cls.setUpClass)
     def new_setUpClass(cls):
-        cls.enterClassContext(no_color())
+        cls.enterClassContext(force_color(False))
         original_setUpClass()
 
     cls.setUpClass = new_setUpClass
@@ -2826,11 +3058,36 @@ def make_clean_env() -> dict[str, str]:
     return clean_env
 
 
-def initialized_with_pyrepl():
-    """Detect whether PyREPL was used during Python initialization."""
-    # If the main module has a __file__ attribute it's a Python module, which means PyREPL.
-    return hasattr(sys.modules["__main__"], "__file__")
+WINDOWS_STATUS = {
+    0xC0000005: "STATUS_ACCESS_VIOLATION",
+    0xC00000FD: "STATUS_STACK_OVERFLOW",
+    0xC000013A: "STATUS_CONTROL_C_EXIT",
+}
+
+def get_signal_name(exitcode):
+    import signal
+
+    if exitcode < 0:
+        signum = -exitcode
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    # Shell exit code (ex: WASI build)
+    if 128 < exitcode < 256:
+        signum = exitcode - 128
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    try:
+        return WINDOWS_STATUS[exitcode]
+    except KeyError:
+        pass
 
+    return None
 
 class BrokenIter:
     def __init__(self, init_raises=False, next_raises=False, iter_raises=False):
@@ -2849,222 +3106,166 @@ def __iter__(self):
         return self
 
 
-def linked_to_musl():
+def in_systemd_nspawn_sync_suppressed() -> bool:
     """
-    Test if the Python executable is linked to the musl C library.
+    Test whether the test suite is runing in systemd-nspawn
+    with ``--suppress-sync=true``.
+
+    This can be used to skip tests that rely on ``fsync()`` calls
+    and similar not being intercepted.
     """
-    if sys.platform != 'linux':
+
+    if not hasattr(os, "O_SYNC"):
         return False
 
-    import subprocess
-    exe = getattr(sys, '_base_executable', sys.executable)
-    cmd = ['ldd', exe]
     try:
-        stdout = subprocess.check_output(cmd,
-                                         text=True,
-                                         stderr=subprocess.STDOUT)
-    except (OSError, subprocess.CalledProcessError):
+        with open("/run/systemd/container", "rb") as fp:
+            if fp.read().rstrip() != b"systemd-nspawn":
+                return False
+    except FileNotFoundError:
         return False
-    return ('musl' in stdout)
 
+    # If systemd-nspawn is used, O_SYNC flag will immediately
+    # trigger EINVAL.  Otherwise, ENOENT will be given instead.
+    import errno
+    try:
+        fd = os.open(__file__, os.O_RDONLY | os.O_SYNC)
+    except OSError as err:
+        if err.errno == errno.EINVAL:
+            return True
+    else:
+        os.close(fd)
 
-# TODO: RUSTPYTHON
-# Every line of code below allowed us to update `Lib/test/support/__init__.py` without
-# needing to update `libregtest` and its dependencies.
-# Ideally we want to remove all code below and update `libregtest`.
-#
-# Code below was copied from: https://github.com/RustPython/RustPython/blob/9499d39f55b73535e2405bf208d5380241f79ada/Lib/test/support/__init__.py
+    return False
 
-from .testresult import get_test_runner
+def run_no_yield_async_fn(async_fn, /, *args, **kwargs):
+    coro = async_fn(*args, **kwargs)
+    try:
+        coro.send(None)
+    except StopIteration as e:
+        return e.value
+    else:
+        raise AssertionError("coroutine did not complete")
+    finally:
+        coro.close()
 
-def _filter_suite(suite, pred):
-    """Recursively filter test cases in a suite based on a predicate."""
-    newtests = []
-    for test in suite._tests:
-        if isinstance(test, unittest.TestSuite):
-            _filter_suite(test, pred)
-            newtests.append(test)
-        else:
-            if pred(test):
-                newtests.append(test)
-    suite._tests = newtests
 
-# By default, don't filter tests
-_match_test_func = None
+@types.coroutine
+def async_yield(v):
+    return (yield v)
 
-_accept_test_patterns = None
-_ignore_test_patterns = None
 
-def match_test(test):
-    # Function used by support.run_unittest() and regrtest --list-cases
-    if _match_test_func is None:
-        return True
-    else:
-        return _match_test_func(test.id())
+def run_yielding_async_fn(async_fn, /, *args, **kwargs):
+    coro = async_fn(*args, **kwargs)
+    try:
+        while True:
+            try:
+                coro.send(None)
+            except StopIteration as e:
+                return e.value
+    finally:
+        coro.close()
 
-def _is_full_match_test(pattern):
-    # If a pattern contains at least one dot, it's considered
-    # as a full test identifier.
-    # Example: 'test.test_os.FileTests.test_access'.
-    #
-    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
-    # or '[!...]'. For example, ignore 'test_access*'.
-    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
-
-def set_match_tests(accept_patterns=None, ignore_patterns=None):
-    global _match_test_func, _accept_test_patterns, _ignore_test_patterns
-
-    if accept_patterns is None:
-        accept_patterns = ()
-    if ignore_patterns is None:
-        ignore_patterns = ()
-
-    accept_func = ignore_func = None
-
-    if accept_patterns != _accept_test_patterns:
-        accept_patterns, accept_func = _compile_match_function(accept_patterns)
-    if ignore_patterns != _ignore_test_patterns:
-        ignore_patterns, ignore_func = _compile_match_function(ignore_patterns)
-
-    # Create a copy since patterns can be mutable and so modified later
-    _accept_test_patterns = tuple(accept_patterns)
-    _ignore_test_patterns = tuple(ignore_patterns)
-
-    if accept_func is not None or ignore_func is not None:
-        def match_function(test_id):
-            accept = True
-            ignore = False
-            if accept_func:
-                accept = accept_func(test_id)
-            if ignore_func:
-                ignore = ignore_func(test_id)
-            return accept and not ignore
-
-        _match_test_func = match_function
-
-def _compile_match_function(patterns):
-    if not patterns:
-        func = None
-        # set_match_tests(None) behaves as set_match_tests(())
-        patterns = ()
-    elif all(map(_is_full_match_test, patterns)):
-        # Simple case: all patterns are full test identifier.
-        # The test.bisect_cmd utility only uses such full test identifiers.
-        func = set(patterns).__contains__
-    else:
-        import fnmatch
-        regex = '|'.join(map(fnmatch.translate, patterns))
-        # The search *is* case sensitive on purpose:
-        # don't use flags=re.IGNORECASE
-        regex_match = re.compile(regex).match
-
-        def match_test_regex(test_id):
-            if regex_match(test_id):
-                # The regex matches the whole identifier, for example
-                # 'test.test_os.FileTests.test_access'.
-                return True
-            else:
-                # Try to match parts of the test identifier.
-                # For example, split 'test.test_os.FileTests.test_access'
-                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
-                return any(map(regex_match, test_id.split(".")))
-
-        func = match_test_regex
-
-    return patterns, func
-
-def run_unittest(*classes):
-    """Run tests from unittest.TestCase-derived classes."""
-    valid_types = (unittest.TestSuite, unittest.TestCase)
-    loader = unittest.TestLoader()
-    suite = unittest.TestSuite()
-    for cls in classes:
-        if isinstance(cls, str):
-            if cls in sys.modules:
-                suite.addTest(loader.loadTestsFromModule(sys.modules[cls]))
-            else:
-                raise ValueError("str arguments must be keys in sys.modules")
-        elif isinstance(cls, valid_types):
-            suite.addTest(cls)
-        else:
-            suite.addTest(loader.loadTestsFromTestCase(cls))
-    _filter_suite(suite, match_test)
-    return _run_suite(suite)
-
-def _run_suite(suite):
-    """Run tests from a unittest.TestSuite-derived class."""
-    runner = get_test_runner(sys.stdout,
-                             verbosity=verbose,
-                             capture_output=(junit_xml_list is not None))
-
-    result = runner.run(suite)
-
-    if junit_xml_list is not None:
-        junit_xml_list.append(result.get_xml_element())
-
-    if not result.testsRun and not result.skipped and not result.errors:
-        raise TestDidNotRun
-    if not result.wasSuccessful():
-        stats = TestStats.from_unittest(result)
-        if len(result.errors) == 1 and not result.failures:
-            err = result.errors[0][1]
-        elif len(result.failures) == 1 and not result.errors:
-            err = result.failures[0][1]
-        else:
-            err = "multiple errors occurred"
-            if not verbose: err += "; run in verbose mode for details"
-        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
-        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
-        raise TestFailedWithDetails(err, errors, failures, stats=stats)
-    return result
 
-@dataclasses.dataclass(slots=True)
-class TestStats:
-    tests_run: int = 0
-    failures: int = 0
-    skipped: int = 0
+def is_libssl_fips_mode():
+    try:
+        from _hashlib import get_fips_mode  # ask _hashopenssl.c
+    except ImportError:
+        return False  # more of a maybe, unless we add this to the _ssl module.
+    return get_fips_mode() != 0
+
+def _supports_remote_attaching():
+    PROCESS_VM_READV_SUPPORTED = False
+
+    try:
+        from _remote_debugging import PROCESS_VM_READV_SUPPORTED
+    except ImportError:
+        pass
 
-    @staticmethod
-    def from_unittest(result):
-        return TestStats(result.testsRun,
-                         len(result.failures),
-                         len(result.skipped))
+    return PROCESS_VM_READV_SUPPORTED
 
-    @staticmethod
-    def from_doctest(results):
-        return TestStats(results.attempted,
-                         results.failed)
+def _support_remote_exec_only_impl():
+    if not sys.is_remote_debug_enabled():
+        return unittest.skip("Remote debugging is not enabled")
+    if sys.platform not in ("darwin", "linux", "win32"):
+        return unittest.skip("Test only runs on Linux, Windows and macOS")
+    if sys.platform == "linux" and not _supports_remote_attaching():
+        return unittest.skip("Test only runs on Linux with process_vm_readv support")
+    return _id
 
-    def accumulate(self, stats):
-        self.tests_run += stats.tests_run
-        self.failures += stats.failures
-        self.skipped += stats.skipped
+def support_remote_exec_only(test):
+    return _support_remote_exec_only_impl()(test)
 
+class EqualToForwardRef:
+    """Helper to ease use of annotationlib.ForwardRef in tests.
 
-def run_doctest(module, verbosity=None, optionflags=0):
-    """Run doctest on the given module.  Return (#failures, #tests).
+    This checks only attributes that can be set using the constructor.
 
-    If optional argument verbosity is not specified (or is None), pass
-    support's belief about verbosity on to doctest.  Else doctest's
-    usual behavior is used (it searches sys.argv for -v).
     """
 
-    import doctest
+    def __init__(
+        self,
+        arg,
+        *,
+        module=None,
+        owner=None,
+        is_class=False,
+    ):
+        self.__forward_arg__ = arg
+        self.__forward_is_class__ = is_class
+        self.__forward_module__ = module
+        self.__owner__ = owner
 
-    if verbosity is None:
-        verbosity = verbose
-    else:
-        verbosity = None
-
-    results = doctest.testmod(module,
-                             verbose=verbosity,
-                             optionflags=optionflags)
-    if results.failed:
-        stats = TestStats.from_doctest(results)
-        raise TestFailed(f"{results.failed} of {results.attempted} "
-                         f"doctests failed",
-                         stats=stats)
-    if verbose:
-        print('doctest (%s) ... %d tests with zero failures' %
-              (module.__name__, results.attempted))
-    return results
+    def __eq__(self, other):
+        if not isinstance(other, (EqualToForwardRef, annotationlib.ForwardRef)):
+            return NotImplemented
+        return (
+            self.__forward_arg__ == other.__forward_arg__
+            and self.__forward_module__ == other.__forward_module__
+            and self.__forward_is_class__ == other.__forward_is_class__
+            and self.__owner__ == other.__owner__
+        )
+
+    def __repr__(self):
+        extra = []
+        if self.__forward_module__ is not None:
+            extra.append(f", module={self.__forward_module__!r}")
+        if self.__forward_is_class__:
+            extra.append(", is_class=True")
+        if self.__owner__ is not None:
+            extra.append(f", owner={self.__owner__!r}")
+        return f"EqualToForwardRef({self.__forward_arg__!r}{''.join(extra)})"
+
+
+_linked_to_musl = None
+def linked_to_musl():
+    """
+    Report if the Python executable is linked to the musl C library.
+
+    Return False if we don't think it is, or a version triple otherwise.
+    """
+    # This is can be a relatively expensive check, so we use a cache.
+    global _linked_to_musl
+    if _linked_to_musl is not None:
+        return _linked_to_musl
+
+    # emscripten (at least as far as we're concerned) and wasi use musl,
+    # but platform doesn't know how to get the version, so set it to zero.
+    if is_wasm32:
+        _linked_to_musl = (0, 0, 0)
+        return _linked_to_musl
+
+    # On all other non-linux platforms assume no musl.
+    if sys.platform != 'linux':
+        _linked_to_musl = False
+        return _linked_to_musl
+
+    # On linux, we'll depend on the platform module to do the check, so new
+    # musl platforms should add support in that module if possible.
+    import platform
+    lib, version = platform.libc_ver()
+    if lib != 'musl':
+        _linked_to_musl = False
+        return _linked_to_musl
+    _linked_to_musl = tuple(map(int, version.split('.')))
+    return _linked_to_musl
diff --git a/Lib/test/support/_hypothesis_stubs/__init__.py b/Lib/test/support/_hypothesis_stubs/__init__.py
index 6ba5bb814b9..9a57c309616 100644
--- a/Lib/test/support/_hypothesis_stubs/__init__.py
+++ b/Lib/test/support/_hypothesis_stubs/__init__.py
@@ -1,6 +1,6 @@
-from enum import Enum
 import functools
 import unittest
+from enum import Enum
 
 __all__ = [
     "given",
diff --git a/Lib/test/support/ast_helper.py b/Lib/test/support/ast_helper.py
index 8a0415b6aae..98eaf0b2721 100644
--- a/Lib/test/support/ast_helper.py
+++ b/Lib/test/support/ast_helper.py
@@ -1,5 +1,6 @@
 import ast
 
+
 class ASTTestMixin:
     """Test mixing to have basic assertions for AST nodes."""
 
@@ -16,6 +17,9 @@ def traverse_compare(a, b, missing=object()):
                 self.fail(f"{type(a)!r} is not {type(b)!r}")
             if isinstance(a, ast.AST):
                 for field in a._fields:
+                    if isinstance(a, ast.Constant) and field == "kind":
+                        # Skip the 'kind' field for ast.Constant
+                        continue
                     value1 = getattr(a, field, missing)
                     value2 = getattr(b, field, missing)
                     # Singletons are equal by definition, so further
diff --git a/Lib/test/support/asynchat.py b/Lib/test/support/asynchat.py
index 38c47a1fda6..a8c6b28a9e1 100644
--- a/Lib/test/support/asynchat.py
+++ b/Lib/test/support/asynchat.py
@@ -1,5 +1,5 @@
 # TODO: This module was deprecated and removed from CPython 3.12
-# Now it is a test-only helper. Any attempts to rewrite exising tests that
+# Now it is a test-only helper. Any attempts to rewrite existing tests that
 # are using this module and remove it completely are appreciated!
 # See: https://github.com/python/cpython/issues/72719
 
diff --git a/Lib/test/support/asyncore.py b/Lib/test/support/asyncore.py
index b397aca5568..658c22fdcee 100644
--- a/Lib/test/support/asyncore.py
+++ b/Lib/test/support/asyncore.py
@@ -1,5 +1,5 @@
 # TODO: This module was deprecated and removed from CPython 3.12
-# Now it is a test-only helper. Any attempts to rewrite exising tests that
+# Now it is a test-only helper. Any attempts to rewrite existing tests that
 # are using this module and remove it completely are appreciated!
 # See: https://github.com/python/cpython/issues/72719
 
@@ -51,17 +51,27 @@
 sophisticated high-performance network servers and clients a snap.
 """
 
+import os
 import select
 import socket
 import sys
 import time
 import warnings
-
-import os
-from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, EINVAL, \
-     ENOTCONN, ESHUTDOWN, EISCONN, EBADF, ECONNABORTED, EPIPE, EAGAIN, \
-     errorcode
-
+from errno import (
+    EAGAIN,
+    EALREADY,
+    EBADF,
+    ECONNABORTED,
+    ECONNRESET,
+    EINPROGRESS,
+    EINVAL,
+    EISCONN,
+    ENOTCONN,
+    EPIPE,
+    ESHUTDOWN,
+    EWOULDBLOCK,
+    errorcode,
+)
 
 _DISCONNECTED = frozenset({ECONNRESET, ENOTCONN, ESHUTDOWN, ECONNABORTED, EPIPE,
                            EBADF})
diff --git a/Lib/test/support/bytecode_helper.py b/Lib/test/support/bytecode_helper.py
index 85bcd1f0f1c..4a3c8c2c4f1 100644
--- a/Lib/test/support/bytecode_helper.py
+++ b/Lib/test/support/bytecode_helper.py
@@ -1,9 +1,10 @@
 """bytecode_helper - support tools for testing correct bytecode generation"""
 
-import unittest
 import dis
 import io
 import opcode
+import unittest
+
 try:
     import _testinternalcapi
 except ImportError:
@@ -71,7 +72,7 @@ class Label:
 
     def assertInstructionsMatch(self, actual_seq, expected):
         # get an InstructionSequence and an expected list, where each
-        # entry is a label or an instruction tuple. Construct an expcted
+        # entry is a label or an instruction tuple. Construct an expected
         # instruction sequence and compare with the one given.
 
         self.assertIsInstance(expected, list)
diff --git a/Lib/test/support/interpreters/channels.py b/Lib/test/support/channels.py
similarity index 73%
rename from Lib/test/support/interpreters/channels.py
rename to Lib/test/support/channels.py
index d2bd93d77f7..3f7b46030fd 100644
--- a/Lib/test/support/interpreters/channels.py
+++ b/Lib/test/support/channels.py
@@ -1,19 +1,23 @@
 """Cross-interpreter Channels High Level Module."""
 
 import time
+from concurrent.interpreters import _crossinterp
+from concurrent.interpreters._crossinterp import (
+    UNBOUND_ERROR,
+    UNBOUND_REMOVE,
+)
+
 import _interpchannels as _channels
-from . import _crossinterp
 
 # aliases:
 from _interpchannels import (
-    ChannelError, ChannelNotFoundError, ChannelClosedError,
-    ChannelEmptyError, ChannelNotEmptyError,
-)
-from ._crossinterp import (
-    UNBOUND_ERROR, UNBOUND_REMOVE,
+    ChannelClosedError,
+    ChannelEmptyError,
+    ChannelError,
+    ChannelNotEmptyError,
+    ChannelNotFoundError,
 )
 
-
 __all__ = [
     'UNBOUND', 'UNBOUND_ERROR', 'UNBOUND_REMOVE',
     'create', 'list_all',
@@ -55,15 +59,23 @@ def create(*, unbounditems=UNBOUND):
     """
     unbound = _serialize_unbound(unbounditems)
     unboundop, = unbound
-    cid = _channels.create(unboundop)
-    recv, send = RecvChannel(cid), SendChannel(cid, _unbound=unbound)
+    cid = _channels.create(unboundop, -1)
+    recv, send = RecvChannel(cid), SendChannel(cid)
+    send._set_unbound(unboundop, unbounditems)
     return recv, send
 
 
 def list_all():
     """Return a list of (recv, send) for all open channels."""
-    return [(RecvChannel(cid), SendChannel(cid, _unbound=unbound))
-            for cid, unbound in _channels.list_all()]
+    channels = []
+    for cid, unboundop, _ in _channels.list_all():
+        chan = _, send = RecvChannel(cid), SendChannel(cid)
+        if not hasattr(send, '_unboundop'):
+            send._set_unbound(unboundop)
+        else:
+            assert send._unbound[0] == unboundop
+        channels.append(chan)
+    return channels
 
 
 class _ChannelEnd:
@@ -97,12 +109,8 @@ def __eq__(self, other):
         return other._id == self._id
 
     # for pickling:
-    def __getnewargs__(self):
-        return (int(self._id),)
-
-    # for pickling:
-    def __getstate__(self):
-        return None
+    def __reduce__(self):
+        return (type(self), (int(self._id),))
 
     @property
     def id(self):
@@ -175,16 +183,33 @@ class SendChannel(_ChannelEnd):
 
     _end = 'send'
 
-    def __new__(cls, cid, *, _unbound=None):
-        if _unbound is None:
-            try:
-                op = _channels.get_channel_defaults(cid)
-                _unbound = (op,)
-            except ChannelNotFoundError:
-                _unbound = _serialize_unbound(UNBOUND)
-        self = super().__new__(cls, cid)
-        self._unbound = _unbound
-        return self
+#    def __new__(cls, cid, *, _unbound=None):
+#        if _unbound is None:
+#            try:
+#                op = _channels.get_channel_defaults(cid)
+#                _unbound = (op,)
+#            except ChannelNotFoundError:
+#                _unbound = _serialize_unbound(UNBOUND)
+#        self = super().__new__(cls, cid)
+#        self._unbound = _unbound
+#        return self
+
+    def _set_unbound(self, op, items=None):
+        assert not hasattr(self, '_unbound')
+        if items is None:
+            items = _resolve_unbound(op)
+        unbound = (op, items)
+        self._unbound = unbound
+        return unbound
+
+    @property
+    def unbounditems(self):
+        try:
+            _, items = self._unbound
+        except AttributeError:
+            op, _ = _channels.get_queue_defaults(self._id)
+            _, items = self._set_unbound(op)
+        return items
 
     @property
     def is_closed(self):
@@ -192,61 +217,61 @@ def is_closed(self):
         return info.closed or info.closing
 
     def send(self, obj, timeout=None, *,
-             unbound=None,
+             unbounditems=None,
              ):
         """Send the object (i.e. its data) to the channel's receiving end.
 
         This blocks until the object is received.
         """
-        if unbound is None:
-            unboundop, = self._unbound
+        if unbounditems is None:
+            unboundop = -1
         else:
-            unboundop, = _serialize_unbound(unbound)
+            unboundop, = _serialize_unbound(unbounditems)
         _channels.send(self._id, obj, unboundop, timeout=timeout, blocking=True)
 
     def send_nowait(self, obj, *,
-                    unbound=None,
+                    unbounditems=None,
                     ):
         """Send the object to the channel's receiving end.
 
         If the object is immediately received then return True
         (else False).  Otherwise this is the same as send().
         """
-        if unbound is None:
-            unboundop, = self._unbound
+        if unbounditems is None:
+            unboundop = -1
         else:
-            unboundop, = _serialize_unbound(unbound)
+            unboundop, = _serialize_unbound(unbounditems)
         # XXX Note that at the moment channel_send() only ever returns
         # None.  This should be fixed when channel_send_wait() is added.
         # See bpo-32604 and gh-19829.
         return _channels.send(self._id, obj, unboundop, blocking=False)
 
     def send_buffer(self, obj, timeout=None, *,
-                    unbound=None,
+                    unbounditems=None,
                     ):
         """Send the object's buffer to the channel's receiving end.
 
         This blocks until the object is received.
         """
-        if unbound is None:
-            unboundop, = self._unbound
+        if unbounditems is None:
+            unboundop = -1
         else:
-            unboundop, = _serialize_unbound(unbound)
+            unboundop, = _serialize_unbound(unbounditems)
         _channels.send_buffer(self._id, obj, unboundop,
                               timeout=timeout, blocking=True)
 
     def send_buffer_nowait(self, obj, *,
-                           unbound=None,
+                           unbounditems=None,
                            ):
         """Send the object's buffer to the channel's receiving end.
 
         If the object is immediately received then return True
         (else False).  Otherwise this is the same as send().
         """
-        if unbound is None:
-            unboundop, = self._unbound
+        if unbounditems is None:
+            unboundop = -1
         else:
-            unboundop, = _serialize_unbound(unbound)
+            unboundop, = _serialize_unbound(unbounditems)
         return _channels.send_buffer(self._id, obj, unboundop, blocking=False)
 
     def close(self):
diff --git a/Lib/test/support/hashlib_helper.py b/Lib/test/support/hashlib_helper.py
index a4e6c92203a..75dc2ba7506 100644
--- a/Lib/test/support/hashlib_helper.py
+++ b/Lib/test/support/hashlib_helper.py
@@ -1,51 +1,330 @@
 import functools
 import hashlib
+import importlib
 import unittest
 
+from test.support.import_helper import import_module
+
 try:
     import _hashlib
 except ImportError:
     _hashlib = None
 
+try:
+    import _hmac
+except ImportError:
+    _hmac = None
+
+
+def requires_hashlib():
+    return unittest.skipIf(_hashlib is None, "requires _hashlib")
+
+
+def requires_builtin_hmac():
+    return unittest.skipIf(_hmac is None, "requires _hmac")
+
+
+def _missing_hash(digestname, implementation=None, *, exc=None):
+    parts = ["missing", implementation, f"hash algorithm: {digestname!r}"]
+    msg = " ".join(filter(None, parts))
+    raise unittest.SkipTest(msg) from exc
+
+
+def _openssl_availabillity(digestname, *, usedforsecurity):
+    try:
+        _hashlib.new(digestname, usedforsecurity=usedforsecurity)
+    except AttributeError:
+        assert _hashlib is None
+        _missing_hash(digestname, "OpenSSL")
+    except ValueError as exc:
+        _missing_hash(digestname, "OpenSSL", exc=exc)
+
+
+def _decorate_func_or_class(func_or_class, decorator_func):
+    if not isinstance(func_or_class, type):
+        return decorator_func(func_or_class)
+
+    decorated_class = func_or_class
+    setUpClass = decorated_class.__dict__.get('setUpClass')
+    if setUpClass is None:
+        def setUpClass(cls):
+            super(decorated_class, cls).setUpClass()
+        setUpClass.__qualname__ = decorated_class.__qualname__ + '.setUpClass'
+        setUpClass.__module__ = decorated_class.__module__
+    else:
+        setUpClass = setUpClass.__func__
+    setUpClass = classmethod(decorator_func(setUpClass))
+    decorated_class.setUpClass = setUpClass
+    return decorated_class
+
 
 def requires_hashdigest(digestname, openssl=None, usedforsecurity=True):
-    """Decorator raising SkipTest if a hashing algorithm is not available
+    """Decorator raising SkipTest if a hashing algorithm is not available.
 
-    The hashing algorithm could be missing or blocked by a strict crypto
-    policy.
+    The hashing algorithm may be missing, blocked by a strict crypto policy,
+    or Python may be configured with `--with-builtin-hashlib-hashes=no`.
 
     If 'openssl' is True, then the decorator checks that OpenSSL provides
-    the algorithm. Otherwise the check falls back to built-in
-    implementations. The usedforsecurity flag is passed to the constructor.
+    the algorithm. Otherwise the check falls back to (optional) built-in
+    HACL* implementations.
 
+    The usedforsecurity flag is passed to the constructor but has no effect
+    on HACL* implementations.
+
+    Examples of exceptions being suppressed:
     ValueError: [digital envelope routines: EVP_DigestInit_ex] disabled for FIPS
     ValueError: unsupported hash type md4
     """
+    if openssl and _hashlib is not None:
+        def test_availability():
+            _hashlib.new(digestname, usedforsecurity=usedforsecurity)
+    else:
+        def test_availability():
+            hashlib.new(digestname, usedforsecurity=usedforsecurity)
+
+    def decorator_func(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                test_availability()
+            except ValueError as exc:
+                _missing_hash(digestname, exc=exc)
+            return func(*args, **kwargs)
+        return wrapper
+
+    def decorator(func_or_class):
+        return _decorate_func_or_class(func_or_class, decorator_func)
+    return decorator
+
+
+def requires_openssl_hashdigest(digestname, *, usedforsecurity=True):
+    """Decorator raising SkipTest if an OpenSSL hashing algorithm is missing.
+
+    The hashing algorithm may be missing or blocked by a strict crypto policy.
+    """
+    def decorator_func(func):
+        @requires_hashlib()  # avoid checking at each call
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            _openssl_availabillity(digestname, usedforsecurity=usedforsecurity)
+            return func(*args, **kwargs)
+        return wrapper
+
     def decorator(func_or_class):
-        if isinstance(func_or_class, type):
-            setUpClass = func_or_class.__dict__.get('setUpClass')
-            if setUpClass is None:
-                def setUpClass(cls):
-                    super(func_or_class, cls).setUpClass()
-                setUpClass.__qualname__ = func_or_class.__qualname__ + '.setUpClass'
-                setUpClass.__module__ = func_or_class.__module__
-            else:
-                setUpClass = setUpClass.__func__
-            setUpClass = classmethod(decorator(setUpClass))
-            func_or_class.setUpClass = setUpClass
-            return func_or_class
-
-        @functools.wraps(func_or_class)
+        return _decorate_func_or_class(func_or_class, decorator_func)
+    return decorator
+
+
+def find_openssl_hashdigest_constructor(digestname, *, usedforsecurity=True):
+    """Find the OpenSSL hash function constructor by its name."""
+    assert isinstance(digestname, str), digestname
+    _openssl_availabillity(digestname, usedforsecurity=usedforsecurity)
+    # This returns a function of the form _hashlib.openssl_<name> and
+    # not a lambda function as it is rejected by _hashlib.hmac_new().
+    return getattr(_hashlib, f"openssl_{digestname}")
+
+
+def requires_builtin_hashdigest(
+    module_name, digestname, *, usedforsecurity=True
+):
+    """Decorator raising SkipTest if a HACL* hashing algorithm is missing.
+
+    - The *module_name* is the C extension module name based on HACL*.
+    - The *digestname* is one of its member, e.g., 'md5'.
+    """
+    def decorator_func(func):
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
+            module = import_module(module_name)
             try:
-                if openssl and _hashlib is not None:
-                    _hashlib.new(digestname, usedforsecurity=usedforsecurity)
-                else:
-                    hashlib.new(digestname, usedforsecurity=usedforsecurity)
-            except ValueError:
-                raise unittest.SkipTest(
-                    f"hash digest '{digestname}' is not available."
-                )
-            return func_or_class(*args, **kwargs)
+                getattr(module, digestname)
+            except AttributeError:
+                fullname = f'{module_name}.{digestname}'
+                _missing_hash(fullname, implementation="HACL")
+            return func(*args, **kwargs)
         return wrapper
+
+    def decorator(func_or_class):
+        return _decorate_func_or_class(func_or_class, decorator_func)
     return decorator
+
+
+def find_builtin_hashdigest_constructor(
+    module_name, digestname, *, usedforsecurity=True
+):
+    """Find the HACL* hash function constructor.
+
+    - The *module_name* is the C extension module name based on HACL*.
+    - The *digestname* is one of its member, e.g., 'md5'.
+    """
+    module = import_module(module_name)
+    try:
+        constructor = getattr(module, digestname)
+        constructor(b'', usedforsecurity=usedforsecurity)
+    except (AttributeError, TypeError, ValueError):
+        _missing_hash(f'{module_name}.{digestname}', implementation="HACL")
+    return constructor
+
+
+class HashFunctionsTrait:
+    """Mixin trait class containing hash functions.
+
+    This class is assumed to have all unitest.TestCase methods but should
+    not directly inherit from it to prevent the test suite being run on it.
+
+    Subclasses should implement the hash functions by returning an object
+    that can be recognized as a valid digestmod parameter for both hashlib
+    and HMAC. In particular, it cannot be a lambda function as it will not
+    be recognized by hashlib (it will still be accepted by the pure Python
+    implementation of HMAC).
+    """
+
+    ALGORITHMS = [
+        'md5', 'sha1',
+        'sha224', 'sha256', 'sha384', 'sha512',
+        'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512',
+    ]
+
+    # Default 'usedforsecurity' to use when looking up a hash function.
+    usedforsecurity = True
+
+    def _find_constructor(self, name):
+        # By default, a missing algorithm skips the test that uses it.
+        self.assertIn(name, self.ALGORITHMS)
+        self.skipTest(f"missing hash function: {name}")
+
+    @property
+    def md5(self):
+        return self._find_constructor("md5")
+
+    @property
+    def sha1(self):
+        return self._find_constructor("sha1")
+
+    @property
+    def sha224(self):
+        return self._find_constructor("sha224")
+
+    @property
+    def sha256(self):
+        return self._find_constructor("sha256")
+
+    @property
+    def sha384(self):
+        return self._find_constructor("sha384")
+
+    @property
+    def sha512(self):
+        return self._find_constructor("sha512")
+
+    @property
+    def sha3_224(self):
+        return self._find_constructor("sha3_224")
+
+    @property
+    def sha3_256(self):
+        return self._find_constructor("sha3_256")
+
+    @property
+    def sha3_384(self):
+        return self._find_constructor("sha3_384")
+
+    @property
+    def sha3_512(self):
+        return self._find_constructor("sha3_512")
+
+
+class NamedHashFunctionsTrait(HashFunctionsTrait):
+    """Trait containing named hash functions.
+
+    Hash functions are available if and only if they are available in hashlib.
+    """
+
+    def _find_constructor(self, name):
+        self.assertIn(name, self.ALGORITHMS)
+        return name
+
+
+class OpenSSLHashFunctionsTrait(HashFunctionsTrait):
+    """Trait containing OpenSSL hash functions.
+
+    Hash functions are available if and only if they are available in _hashlib.
+    """
+
+    def _find_constructor(self, name):
+        self.assertIn(name, self.ALGORITHMS)
+        return find_openssl_hashdigest_constructor(
+            name, usedforsecurity=self.usedforsecurity
+        )
+
+
+class BuiltinHashFunctionsTrait(HashFunctionsTrait):
+    """Trait containing HACL* hash functions.
+
+    Hash functions are available if and only if they are available in C.
+    In particular, HACL* HMAC-MD5 may be available even though HACL* md5
+    is not since the former is unconditionally built.
+    """
+
+    def _find_constructor_in(self, module, name):
+        self.assertIn(name, self.ALGORITHMS)
+        return find_builtin_hashdigest_constructor(module, name)
+
+    @property
+    def md5(self):
+        return self._find_constructor_in("_md5", "md5")
+
+    @property
+    def sha1(self):
+        return self._find_constructor_in("_sha1", "sha1")
+
+    @property
+    def sha224(self):
+        return self._find_constructor_in("_sha2", "sha224")
+
+    @property
+    def sha256(self):
+        return self._find_constructor_in("_sha2", "sha256")
+
+    @property
+    def sha384(self):
+        return self._find_constructor_in("_sha2", "sha384")
+
+    @property
+    def sha512(self):
+        return self._find_constructor_in("_sha2", "sha512")
+
+    @property
+    def sha3_224(self):
+        return self._find_constructor_in("_sha3", "sha3_224")
+
+    @property
+    def sha3_256(self):
+        return self._find_constructor_in("_sha3","sha3_256")
+
+    @property
+    def sha3_384(self):
+        return self._find_constructor_in("_sha3","sha3_384")
+
+    @property
+    def sha3_512(self):
+        return self._find_constructor_in("_sha3","sha3_512")
+
+
+def find_gil_minsize(modules_names, default=2048):
+    """Get the largest GIL_MINSIZE value for the given cryptographic modules.
+
+    The valid module names are the following:
+
+    - _hashlib
+    - _md5, _sha1, _sha2, _sha3, _blake2
+    - _hmac
+    """
+    sizes = []
+    for module_name in modules_names:
+        try:
+            module = importlib.import_module(module_name)
+        except ImportError:
+            continue
+        sizes.append(getattr(module, '_GIL_MINSIZE', default))
+    return max(sizes, default=default)
diff --git a/Lib/test/support/hypothesis_helper.py b/Lib/test/support/hypothesis_helper.py
index a99a4963ffe..6e9e168f63a 100644
--- a/Lib/test/support/hypothesis_helper.py
+++ b/Lib/test/support/hypothesis_helper.py
@@ -7,9 +7,10 @@
 else:
     # Regrtest changes to use a tempdir as the working directory, so we have
     # to tell Hypothesis to use the original in order to persist the database.
+    from hypothesis.configuration import set_hypothesis_home_dir
+
     from test.support import has_socket_support
     from test.support.os_helper import SAVEDCWD
-    from hypothesis.configuration import set_hypothesis_home_dir
 
     set_hypothesis_home_dir(os.path.join(SAVEDCWD, ".hypothesis"))
 
diff --git a/Lib/test/support/i18n_helper.py b/Lib/test/support/i18n_helper.py
index 2e304f29e8b..af97cdc9cb5 100644
--- a/Lib/test/support/i18n_helper.py
+++ b/Lib/test/support/i18n_helper.py
@@ -3,10 +3,10 @@
 import sys
 import unittest
 from pathlib import Path
+
 from test.support import REPO_ROOT, TEST_HOME_DIR, requires_subprocess
 from test.test_tools import skip_if_missing
 
-
 pygettext = Path(REPO_ROOT) / 'Tools' / 'i18n' / 'pygettext.py'
 
 msgid_pattern = re.compile(r'msgid(.*?)(?:msgid_plural|msgctxt|msgstr)',
diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index a4ea5bc6af9..d31713b8651 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -1,14 +1,16 @@
-import contextlib
 import _imp
+import contextlib
 import importlib
+import importlib.machinery
 import importlib.util
 import os
 import shutil
 import sys
+import textwrap
 import unittest
 import warnings
 
-from .os_helper import unlink, temp_dir
+from .os_helper import temp_dir, unlink
 
 
 @contextlib.contextmanager
@@ -303,9 +305,138 @@ def ready_to_import(name=None, source=""):
         try:
             sys.path.insert(0, tempdir)
             yield name, path
-        finally:
             sys.path.remove(tempdir)
+        finally:
             if old_module is not None:
                 sys.modules[name] = old_module
             else:
                 sys.modules.pop(name, None)
+
+
+def ensure_lazy_imports(imported_module, modules_to_block):
+    """Test that when imported_module is imported, none of the modules in
+    modules_to_block are imported as a side effect."""
+    modules_to_block = frozenset(modules_to_block)
+    script = textwrap.dedent(
+        f"""
+        import sys
+        modules_to_block = {modules_to_block}
+        if unexpected := modules_to_block & sys.modules.keys():
+            startup = ", ".join(unexpected)
+            raise AssertionError(f'unexpectedly imported at startup: {{startup}}')
+
+        import {imported_module}
+        if unexpected := modules_to_block & sys.modules.keys():
+            after = ", ".join(unexpected)
+            raise AssertionError(f'unexpectedly imported after importing {imported_module}: {{after}}')
+        """
+    )
+    from .script_helper import assert_python_ok
+    assert_python_ok("-S", "-c", script)
+
+
+@contextlib.contextmanager
+def module_restored(name):
+    """A context manager that restores a module to the original state."""
+    missing = object()
+    orig = sys.modules.get(name, missing)
+    if orig is None:
+        mod = importlib.import_module(name)
+    else:
+        mod = type(sys)(name)
+        mod.__dict__.update(orig.__dict__)
+        sys.modules[name] = mod
+    try:
+        yield mod
+    finally:
+        if orig is missing:
+            sys.modules.pop(name, None)
+        else:
+            sys.modules[name] = orig
+
+
+def create_module(name, loader=None, *, ispkg=False):
+    """Return a new, empty module."""
+    spec = importlib.machinery.ModuleSpec(
+        name,
+        loader,
+        origin='<import_helper>',
+        is_package=ispkg,
+    )
+    return importlib.util.module_from_spec(spec)
+
+
+def _ensure_module(name, ispkg, addparent, clearnone):
+    try:
+        mod = orig = sys.modules[name]
+    except KeyError:
+        mod = orig = None
+        missing = True
+    else:
+        missing = False
+        if mod is not None:
+            # It was already imported.
+            return mod, orig, missing
+        # Otherwise, None means it was explicitly disabled.
+
+    assert name != '__main__'
+    if not missing:
+        assert orig is None, (name, sys.modules[name])
+        if not clearnone:
+            raise ModuleNotFoundError(name)
+        del sys.modules[name]
+    # Try normal import, then fall back to adding the module.
+    try:
+        mod = importlib.import_module(name)
+    except ModuleNotFoundError:
+        if addparent and not clearnone:
+            addparent = None
+        mod = _add_module(name, ispkg, addparent)
+    return mod, orig, missing
+
+
+def _add_module(spec, ispkg, addparent):
+    if isinstance(spec, str):
+        name = spec
+        mod = create_module(name, ispkg=ispkg)
+        spec = mod.__spec__
+    else:
+        name = spec.name
+        mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    if addparent is not False and spec.parent:
+        _ensure_module(spec.parent, True, addparent, bool(addparent))
+    return mod
+
+
+def add_module(spec, *, parents=True):
+    """Return the module after creating it and adding it to sys.modules.
+
+    If parents is True then also create any missing parents.
+    """
+    return _add_module(spec, False, parents)
+
+
+def add_package(spec, *, parents=True):
+    """Return the module after creating it and adding it to sys.modules.
+
+    If parents is True then also create any missing parents.
+    """
+    return _add_module(spec, True, parents)
+
+
+def ensure_module_imported(name, *, clearnone=True):
+    """Return the corresponding module.
+
+    If it was already imported then return that.  Otherwise, try
+    importing it (optionally clear it first if None).  If that fails
+    then create a new empty module.
+
+    It can be helpful to combine this with ready_to_import() and/or
+    isolated_modules().
+    """
+    if sys.modules.get(name) is not None:
+        mod = sys.modules[name]
+    else:
+        mod, _, _ = _ensure_module(name, False, True, clearnone)
+    return mod
diff --git a/Lib/test/support/interpreters/__init__.py b/Lib/test/support/interpreters/__init__.py
deleted file mode 100644
index e067f259364..00000000000
--- a/Lib/test/support/interpreters/__init__.py
+++ /dev/null
@@ -1,258 +0,0 @@
-"""Subinterpreters High Level Module."""
-
-import threading
-import weakref
-import _interpreters
-
-# aliases:
-from _interpreters import (
-    InterpreterError, InterpreterNotFoundError, NotShareableError,
-    is_shareable,
-)
-
-
-__all__ = [
-    'get_current', 'get_main', 'create', 'list_all', 'is_shareable',
-    'Interpreter',
-    'InterpreterError', 'InterpreterNotFoundError', 'ExecutionFailed',
-    'NotShareableError',
-    'create_queue', 'Queue', 'QueueEmpty', 'QueueFull',
-]
-
-
-_queuemod = None
-
-def __getattr__(name):
-    if name in ('Queue', 'QueueEmpty', 'QueueFull', 'create_queue'):
-        global create_queue, Queue, QueueEmpty, QueueFull
-        ns = globals()
-        from .queues import (
-            create as create_queue,
-            Queue, QueueEmpty, QueueFull,
-        )
-        return ns[name]
-    else:
-        raise AttributeError(name)
-
-
-_EXEC_FAILURE_STR = """
-{superstr}
-
-Uncaught in the interpreter:
-
-{formatted}
-""".strip()
-
-class ExecutionFailed(InterpreterError):
-    """An unhandled exception happened during execution.
-
-    This is raised from Interpreter.exec() and Interpreter.call().
-    """
-
-    def __init__(self, excinfo):
-        msg = excinfo.formatted
-        if not msg:
-            if excinfo.type and excinfo.msg:
-                msg = f'{excinfo.type.__name__}: {excinfo.msg}'
-            else:
-                msg = excinfo.type.__name__ or excinfo.msg
-        super().__init__(msg)
-        self.excinfo = excinfo
-
-    def __str__(self):
-        try:
-            formatted = self.excinfo.errdisplay
-        except Exception:
-            return super().__str__()
-        else:
-            return _EXEC_FAILURE_STR.format(
-                superstr=super().__str__(),
-                formatted=formatted,
-            )
-
-
-def create():
-    """Return a new (idle) Python interpreter."""
-    id = _interpreters.create(reqrefs=True)
-    return Interpreter(id, _ownsref=True)
-
-
-def list_all():
-    """Return all existing interpreters."""
-    return [Interpreter(id, _whence=whence)
-            for id, whence in _interpreters.list_all(require_ready=True)]
-
-
-def get_current():
-    """Return the currently running interpreter."""
-    id, whence = _interpreters.get_current()
-    return Interpreter(id, _whence=whence)
-
-
-def get_main():
-    """Return the main interpreter."""
-    id, whence = _interpreters.get_main()
-    assert whence == _interpreters.WHENCE_RUNTIME, repr(whence)
-    return Interpreter(id, _whence=whence)
-
-
-_known = weakref.WeakValueDictionary()
-
-class Interpreter:
-    """A single Python interpreter.
-
-    Attributes:
-
-    "id" - the unique process-global ID number for the interpreter
-    "whence" - indicates where the interpreter was created
-
-    If the interpreter wasn't created by this module
-    then any method that modifies the interpreter will fail,
-    i.e. .close(), .prepare_main(), .exec(), and .call()
-    """
-
-    _WHENCE_TO_STR = {
-       _interpreters.WHENCE_UNKNOWN: 'unknown',
-       _interpreters.WHENCE_RUNTIME: 'runtime init',
-       _interpreters.WHENCE_LEGACY_CAPI: 'legacy C-API',
-       _interpreters.WHENCE_CAPI: 'C-API',
-       _interpreters.WHENCE_XI: 'cross-interpreter C-API',
-       _interpreters.WHENCE_STDLIB: '_interpreters module',
-    }
-
-    def __new__(cls, id, /, _whence=None, _ownsref=None):
-        # There is only one instance for any given ID.
-        if not isinstance(id, int):
-            raise TypeError(f'id must be an int, got {id!r}')
-        id = int(id)
-        if _whence is None:
-            if _ownsref:
-                _whence = _interpreters.WHENCE_STDLIB
-            else:
-                _whence = _interpreters.whence(id)
-        assert _whence in cls._WHENCE_TO_STR, repr(_whence)
-        if _ownsref is None:
-            _ownsref = (_whence == _interpreters.WHENCE_STDLIB)
-        try:
-            self = _known[id]
-            assert hasattr(self, '_ownsref')
-        except KeyError:
-            self = super().__new__(cls)
-            _known[id] = self
-            self._id = id
-            self._whence = _whence
-            self._ownsref = _ownsref
-            if _ownsref:
-                # This may raise InterpreterNotFoundError:
-                _interpreters.incref(id)
-        return self
-
-    def __repr__(self):
-        return f'{type(self).__name__}({self.id})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __del__(self):
-        self._decref()
-
-    # for pickling:
-    def __getnewargs__(self):
-        return (self._id,)
-
-    # for pickling:
-    def __getstate__(self):
-        return None
-
-    def _decref(self):
-        if not self._ownsref:
-            return
-        self._ownsref = False
-        try:
-            _interpreters.decref(self._id)
-        except InterpreterNotFoundError:
-            pass
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def whence(self):
-        return self._WHENCE_TO_STR[self._whence]
-
-    def is_running(self):
-        """Return whether or not the identified interpreter is running."""
-        return _interpreters.is_running(self._id)
-
-    # Everything past here is available only to interpreters created by
-    # interpreters.create().
-
-    def close(self):
-        """Finalize and destroy the interpreter.
-
-        Attempting to destroy the current interpreter results
-        in an InterpreterError.
-        """
-        return _interpreters.destroy(self._id, restrict=True)
-
-    def prepare_main(self, ns=None, /, **kwargs):
-        """Bind the given values into the interpreter's __main__.
-
-        The values must be shareable.
-        """
-        ns = dict(ns, **kwargs) if ns is not None else kwargs
-        _interpreters.set___main___attrs(self._id, ns, restrict=True)
-
-    def exec(self, code, /):
-        """Run the given source code in the interpreter.
-
-        This is essentially the same as calling the builtin "exec"
-        with this interpreter, using the __dict__ of its __main__
-        module as both globals and locals.
-
-        There is no return value.
-
-        If the code raises an unhandled exception then an ExecutionFailed
-        exception is raised, which summarizes the unhandled exception.
-        The actual exception is discarded because objects cannot be
-        shared between interpreters.
-
-        This blocks the current Python thread until done.  During
-        that time, the previous interpreter is allowed to run
-        in other threads.
-        """
-        excinfo = _interpreters.exec(self._id, code, restrict=True)
-        if excinfo is not None:
-            raise ExecutionFailed(excinfo)
-
-    def call(self, callable, /):
-        """Call the object in the interpreter with given args/kwargs.
-
-        Only functions that take no arguments and have no closure
-        are supported.
-
-        The return value is discarded.
-
-        If the callable raises an exception then the error display
-        (including full traceback) is send back between the interpreters
-        and an ExecutionFailed exception is raised, much like what
-        happens with Interpreter.exec().
-        """
-        # XXX Support args and kwargs.
-        # XXX Support arbitrary callables.
-        # XXX Support returning the return value (e.g. via pickle).
-        excinfo = _interpreters.call(self._id, callable, restrict=True)
-        if excinfo is not None:
-            raise ExecutionFailed(excinfo)
-
-    def call_in_thread(self, callable, /):
-        """Return a new thread that calls the object in the interpreter.
-
-        The return value and any raised exception are discarded.
-        """
-        def task():
-            self.call(callable)
-        t = threading.Thread(target=task)
-        t.start()
-        return t
diff --git a/Lib/test/support/interpreters/_crossinterp.py b/Lib/test/support/interpreters/_crossinterp.py
deleted file mode 100644
index 544e197ba4c..00000000000
--- a/Lib/test/support/interpreters/_crossinterp.py
+++ /dev/null
@@ -1,102 +0,0 @@
-"""Common code between queues and channels."""
-
-
-class ItemInterpreterDestroyed(Exception):
-    """Raised when trying to get an item whose interpreter was destroyed."""
-
-
-class classonly:
-    """A non-data descriptor that makes a value only visible on the class.
-
-    This is like the "classmethod" builtin, but does not show up on
-    instances of the class.  It may be used as a decorator.
-    """
-
-    def __init__(self, value):
-        self.value = value
-        self.getter = classmethod(value).__get__
-        self.name = None
-
-    def __set_name__(self, cls, name):
-        if self.name is not None:
-            raise TypeError('already used')
-        self.name = name
-
-    def __get__(self, obj, cls):
-        if obj is not None:
-            raise AttributeError(self.name)
-        # called on the class
-        return self.getter(None, cls)
-
-
-class UnboundItem:
-    """Represents a cross-interpreter item no longer bound to an interpreter.
-
-    An item is unbound when the interpreter that added it to the
-    cross-interpreter container is destroyed.
-    """
-
-    __slots__ = ()
-
-    @classonly
-    def singleton(cls, kind, module, name='UNBOUND'):
-        doc = cls.__doc__.replace('cross-interpreter container', kind)
-        doc = doc.replace('cross-interpreter', kind)
-        subclass = type(
-            f'Unbound{kind.capitalize()}Item',
-            (cls,),
-            dict(
-                _MODULE=module,
-                _NAME=name,
-                __doc__=doc,
-            ),
-        )
-        return object.__new__(subclass)
-
-    _MODULE = __name__
-    _NAME = 'UNBOUND'
-
-    def __new__(cls):
-        raise Exception(f'use {cls._MODULE}.{cls._NAME}')
-
-    def __repr__(self):
-        return f'{self._MODULE}.{self._NAME}'
-#        return f'interpreters.queues.UNBOUND'
-
-
-UNBOUND = object.__new__(UnboundItem)
-UNBOUND_ERROR = object()
-UNBOUND_REMOVE = object()
-
-_UNBOUND_CONSTANT_TO_FLAG = {
-    UNBOUND_REMOVE: 1,
-    UNBOUND_ERROR: 2,
-    UNBOUND: 3,
-}
-_UNBOUND_FLAG_TO_CONSTANT = {v: k
-                             for k, v in _UNBOUND_CONSTANT_TO_FLAG.items()}
-
-
-def serialize_unbound(unbound):
-    op = unbound
-    try:
-        flag = _UNBOUND_CONSTANT_TO_FLAG[op]
-    except KeyError:
-        raise NotImplementedError(f'unsupported unbound replacement op {op!r}')
-    return flag,
-
-
-def resolve_unbound(flag, exctype_destroyed):
-    try:
-        op = _UNBOUND_FLAG_TO_CONSTANT[flag]
-    except KeyError:
-        raise NotImplementedError(f'unsupported unbound replacement op {flag!r}')
-    if op is UNBOUND_REMOVE:
-        # "remove" not possible here
-        raise NotImplementedError
-    elif op is UNBOUND_ERROR:
-        raise exctype_destroyed("item's original interpreter destroyed")
-    elif op is UNBOUND:
-        return UNBOUND
-    else:
-        raise NotImplementedError(repr(op))
diff --git a/Lib/test/support/interpreters/queues.py b/Lib/test/support/interpreters/queues.py
deleted file mode 100644
index deb8e8613af..00000000000
--- a/Lib/test/support/interpreters/queues.py
+++ /dev/null
@@ -1,313 +0,0 @@
-"""Cross-interpreter Queues High Level Module."""
-
-import pickle
-import queue
-import time
-import weakref
-import _interpqueues as _queues
-from . import _crossinterp
-
-# aliases:
-from _interpqueues import (
-    QueueError, QueueNotFoundError,
-)
-from ._crossinterp import (
-    UNBOUND_ERROR, UNBOUND_REMOVE,
-)
-
-__all__ = [
-    'UNBOUND', 'UNBOUND_ERROR', 'UNBOUND_REMOVE',
-    'create', 'list_all',
-    'Queue',
-    'QueueError', 'QueueNotFoundError', 'QueueEmpty', 'QueueFull',
-    'ItemInterpreterDestroyed',
-]
-
-
-class QueueEmpty(QueueError, queue.Empty):
-    """Raised from get_nowait() when the queue is empty.
-
-    It is also raised from get() if it times out.
-    """
-
-
-class QueueFull(QueueError, queue.Full):
-    """Raised from put_nowait() when the queue is full.
-
-    It is also raised from put() if it times out.
-    """
-
-
-class ItemInterpreterDestroyed(QueueError,
-                               _crossinterp.ItemInterpreterDestroyed):
-    """Raised from get() and get_nowait()."""
-
-
-_SHARED_ONLY = 0
-_PICKLED = 1
-
-
-UNBOUND = _crossinterp.UnboundItem.singleton('queue', __name__)
-
-
-def _serialize_unbound(unbound):
-    if unbound is UNBOUND:
-        unbound = _crossinterp.UNBOUND
-    return _crossinterp.serialize_unbound(unbound)
-
-
-def _resolve_unbound(flag):
-    resolved = _crossinterp.resolve_unbound(flag, ItemInterpreterDestroyed)
-    if resolved is _crossinterp.UNBOUND:
-        resolved = UNBOUND
-    return resolved
-
-
-def create(maxsize=0, *, syncobj=False, unbounditems=UNBOUND):
-    """Return a new cross-interpreter queue.
-
-    The queue may be used to pass data safely between interpreters.
-
-    "syncobj" sets the default for Queue.put()
-    and Queue.put_nowait().
-
-    "unbounditems" likewise sets the default.  See Queue.put() for
-    supported values.  The default value is UNBOUND, which replaces
-    the unbound item.
-    """
-    fmt = _SHARED_ONLY if syncobj else _PICKLED
-    unbound = _serialize_unbound(unbounditems)
-    unboundop, = unbound
-    qid = _queues.create(maxsize, fmt, unboundop)
-    return Queue(qid, _fmt=fmt, _unbound=unbound)
-
-
-def list_all():
-    """Return a list of all open queues."""
-    return [Queue(qid, _fmt=fmt, _unbound=(unboundop,))
-            for qid, fmt, unboundop in _queues.list_all()]
-
-
-_known_queues = weakref.WeakValueDictionary()
-
-class Queue:
-    """A cross-interpreter queue."""
-
-    def __new__(cls, id, /, *, _fmt=None, _unbound=None):
-        # There is only one instance for any given ID.
-        if isinstance(id, int):
-            id = int(id)
-        else:
-            raise TypeError(f'id must be an int, got {id!r}')
-        if _fmt is None:
-            if _unbound is None:
-                _fmt, op = _queues.get_queue_defaults(id)
-                _unbound = (op,)
-            else:
-                _fmt, _ = _queues.get_queue_defaults(id)
-        elif _unbound is None:
-            _, op = _queues.get_queue_defaults(id)
-            _unbound = (op,)
-        try:
-            self = _known_queues[id]
-        except KeyError:
-            self = super().__new__(cls)
-            self._id = id
-            self._fmt = _fmt
-            self._unbound = _unbound
-            _known_queues[id] = self
-            _queues.bind(id)
-        return self
-
-    def __del__(self):
-        try:
-            _queues.release(self._id)
-        except QueueNotFoundError:
-            pass
-        try:
-            del _known_queues[self._id]
-        except KeyError:
-            pass
-
-    def __repr__(self):
-        return f'{type(self).__name__}({self.id})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    # for pickling:
-    def __getnewargs__(self):
-        return (self._id,)
-
-    # for pickling:
-    def __getstate__(self):
-        return None
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def maxsize(self):
-        try:
-            return self._maxsize
-        except AttributeError:
-            self._maxsize = _queues.get_maxsize(self._id)
-            return self._maxsize
-
-    def empty(self):
-        return self.qsize() == 0
-
-    def full(self):
-        return _queues.is_full(self._id)
-
-    def qsize(self):
-        return _queues.get_count(self._id)
-
-    def put(self, obj, timeout=None, *,
-            syncobj=None,
-            unbound=None,
-            _delay=10 / 1000,  # 10 milliseconds
-            ):
-        """Add the object to the queue.
-
-        This blocks while the queue is full.
-
-        If "syncobj" is None (the default) then it uses the
-        queue's default, set with create_queue().
-
-        If "syncobj" is false then all objects are supported,
-        at the expense of worse performance.
-
-        If "syncobj" is true then the object must be "shareable".
-        Examples of "shareable" objects include the builtin singletons,
-        str, and memoryview.  One benefit is that such objects are
-        passed through the queue efficiently.
-
-        The key difference, though, is conceptual: the corresponding
-        object returned from Queue.get() will be strictly equivalent
-        to the given obj.  In other words, the two objects will be
-        effectively indistinguishable from each other, even if the
-        object is mutable.  The received object may actually be the
-        same object, or a copy (immutable values only), or a proxy.
-        Regardless, the received object should be treated as though
-        the original has been shared directly, whether or not it
-        actually is.  That's a slightly different and stronger promise
-        than just (initial) equality, which is all "syncobj=False"
-        can promise.
-
-        "unbound" controls the behavior of Queue.get() for the given
-        object if the current interpreter (calling put()) is later
-        destroyed.
-
-        If "unbound" is None (the default) then it uses the
-        queue's default, set with create_queue(),
-        which is usually UNBOUND.
-
-        If "unbound" is UNBOUND_ERROR then get() will raise an
-        ItemInterpreterDestroyed exception if the original interpreter
-        has been destroyed.  This does not otherwise affect the queue;
-        the next call to put() will work like normal, returning the next
-        item in the queue.
-
-        If "unbound" is UNBOUND_REMOVE then the item will be removed
-        from the queue as soon as the original interpreter is destroyed.
-        Be aware that this will introduce an imbalance between put()
-        and get() calls.
-
-        If "unbound" is UNBOUND then it is returned by get() in place
-        of the unbound item.
-        """
-        if syncobj is None:
-            fmt = self._fmt
-        else:
-            fmt = _SHARED_ONLY if syncobj else _PICKLED
-        if unbound is None:
-            unboundop, = self._unbound
-        else:
-            unboundop, = _serialize_unbound(unbound)
-        if timeout is not None:
-            timeout = int(timeout)
-            if timeout < 0:
-                raise ValueError(f'timeout value must be non-negative')
-            end = time.time() + timeout
-        if fmt is _PICKLED:
-            obj = pickle.dumps(obj)
-        while True:
-            try:
-                _queues.put(self._id, obj, fmt, unboundop)
-            except QueueFull as exc:
-                if timeout is not None and time.time() >= end:
-                    raise  # re-raise
-                time.sleep(_delay)
-            else:
-                break
-
-    def put_nowait(self, obj, *, syncobj=None, unbound=None):
-        if syncobj is None:
-            fmt = self._fmt
-        else:
-            fmt = _SHARED_ONLY if syncobj else _PICKLED
-        if unbound is None:
-            unboundop, = self._unbound
-        else:
-            unboundop, = _serialize_unbound(unbound)
-        if fmt is _PICKLED:
-            obj = pickle.dumps(obj)
-        _queues.put(self._id, obj, fmt, unboundop)
-
-    def get(self, timeout=None, *,
-            _delay=10 / 1000,  # 10 milliseconds
-            ):
-        """Return the next object from the queue.
-
-        This blocks while the queue is empty.
-
-        If the next item's original interpreter has been destroyed
-        then the "next object" is determined by the value of the
-        "unbound" argument to put().
-        """
-        if timeout is not None:
-            timeout = int(timeout)
-            if timeout < 0:
-                raise ValueError(f'timeout value must be non-negative')
-            end = time.time() + timeout
-        while True:
-            try:
-                obj, fmt, unboundop = _queues.get(self._id)
-            except QueueEmpty as exc:
-                if timeout is not None and time.time() >= end:
-                    raise  # re-raise
-                time.sleep(_delay)
-            else:
-                break
-        if unboundop is not None:
-            assert obj is None, repr(obj)
-            return _resolve_unbound(unboundop)
-        if fmt == _PICKLED:
-            obj = pickle.loads(obj)
-        else:
-            assert fmt == _SHARED_ONLY
-        return obj
-
-    def get_nowait(self):
-        """Return the next object from the channel.
-
-        If the queue is empty then raise QueueEmpty.  Otherwise this
-        is the same as get().
-        """
-        try:
-            obj, fmt, unboundop = _queues.get(self._id)
-        except QueueEmpty as exc:
-            raise  # re-raise
-        if unboundop is not None:
-            assert obj is None, repr(obj)
-            return _resolve_unbound(unboundop)
-        if fmt == _PICKLED:
-            obj = pickle.loads(obj)
-        else:
-            assert fmt == _SHARED_ONLY
-        return obj
-
-
-_queues._register_heap_types(Queue, QueueEmpty, QueueFull)
diff --git a/Lib/test/support/logging_helper.py b/Lib/test/support/logging_helper.py
index 12fcca4f0f0..db556c7f5ad 100644
--- a/Lib/test/support/logging_helper.py
+++ b/Lib/test/support/logging_helper.py
@@ -1,5 +1,6 @@
 import logging.handlers
 
+
 class TestHandler(logging.handlers.BufferingHandler):
     def __init__(self, matcher):
         # BufferingHandler takes a "capacity" argument
diff --git a/Lib/test/support/os_helper.py b/Lib/test/support/os_helper.py
index 26c467a7ad2..d3d6fa632f9 100644
--- a/Lib/test/support/os_helper.py
+++ b/Lib/test/support/os_helper.py
@@ -13,7 +13,6 @@
 
 from test import support
 
-
 # Filename used for testing
 TESTFN_ASCII = '@test'
 
@@ -295,6 +294,33 @@ def skip_unless_working_chmod(test):
     return test if ok else unittest.skip(msg)(test)
 
 
+@contextlib.contextmanager
+def save_mode(path, *, quiet=False):
+    """Context manager that restores the mode (permissions) of *path* on exit.
+
+    Arguments:
+
+      path: Path of the file to restore the mode of.
+
+      quiet: if False (the default), the context manager raises an exception
+        on error.  Otherwise, it issues only a warning and keeps the current
+        working directory the same.
+
+    """
+    saved_mode = os.stat(path)
+    try:
+        yield
+    finally:
+        try:
+            os.chmod(path, saved_mode.st_mode)
+        except OSError as exc:
+            if not quiet:
+                raise
+            warnings.warn(f'tests may fail, unable to restore the mode of '
+                          f'{path!r} to {saved_mode.st_mode}: {exc}',
+                          RuntimeWarning, stacklevel=3)
+
+
 # Check whether the current effective user has the capability to override
 # DAC (discretionary access control). Typically user root is able to
 # bypass file read, write, and execute permission checks. The capability
diff --git a/Lib/test/support/pty_helper.py b/Lib/test/support/pty_helper.py
index 6587fd40333..7e1ae9e59b8 100644
--- a/Lib/test/support/pty_helper.py
+++ b/Lib/test/support/pty_helper.py
@@ -10,6 +10,7 @@
 
 from test.support.import_helper import import_module
 
+
 def run_pty(script, input=b"dummy input\r", env=None):
     pty = import_module('pty')
     output = bytearray()
diff --git a/Lib/test/support/script_helper.py b/Lib/test/support/script_helper.py
index 04458077d51..a338f484449 100644
--- a/Lib/test/support/script_helper.py
+++ b/Lib/test/support/script_helper.py
@@ -3,17 +3,16 @@
 
 import collections
 import importlib
-import sys
 import os
 import os.path
-import subprocess
 import py_compile
-
+import subprocess
+import sys
 from importlib.util import source_from_cache
+
 from test import support
 from test.support.import_helper import make_legacy_pyc
 
-
 # Cached result of the expensive test performed in the function below.
 __cached_interp_requires_environment = None
 
@@ -70,23 +69,25 @@ def fail(self, cmd_line):
             out = b'(... truncated stdout ...)' + out[-maxlen:]
         if len(err) > maxlen:
             err = b'(... truncated stderr ...)' + err[-maxlen:]
-        out = out.decode('ascii', 'replace').rstrip()
-        err = err.decode('ascii', 'replace').rstrip()
-        raise AssertionError("Process return code is %d\n"
-                             "command line: %r\n"
-                             "\n"
-                             "stdout:\n"
-                             "---\n"
-                             "%s\n"
-                             "---\n"
-                             "\n"
-                             "stderr:\n"
-                             "---\n"
-                             "%s\n"
-                             "---"
-                             % (self.rc, cmd_line,
-                                out,
-                                err))
+        out = out.decode('utf8', 'replace').rstrip()
+        err = err.decode('utf8', 'replace').rstrip()
+
+        exitcode = self.rc
+        signame = support.get_signal_name(exitcode)
+        if signame:
+            exitcode = f"{exitcode} ({signame})"
+        raise AssertionError(f"Process return code is {exitcode}\n"
+                             f"command line: {cmd_line!r}\n"
+                             f"\n"
+                             f"stdout:\n"
+                             f"---\n"
+                             f"{out}\n"
+                             f"---\n"
+                             f"\n"
+                             f"stderr:\n"
+                             f"---\n"
+                             f"{err}\n"
+                             f"---")
 
 
 # Executing the interpreter in a subprocess
diff --git a/Lib/test/support/smtpd.py b/Lib/test/support/smtpd.py
old mode 100644
new mode 100755
index 6052232ec2b..cf333aaf6b0
--- a/Lib/test/support/smtpd.py
+++ b/Lib/test/support/smtpd.py
@@ -7,7 +7,7 @@
 
     --nosetuid
     -n
-        This program generally tries to setuid `nobody', unless this flag is
+        This program generally tries to setuid 'nobody', unless this flag is
         set.  The setuid call will fail if this program is not run as root (in
         which case, use this flag).
 
@@ -17,7 +17,7 @@
 
     --class classname
     -c classname
-        Use `classname' as the concrete SMTP proxy class.  Uses `PureProxy' by
+        Use 'classname' as the concrete SMTP proxy class.  Uses 'PureProxy' by
         default.
 
     --size limit
@@ -39,8 +39,8 @@
 
 Version: %(__version__)s
 
-If localhost is not given then `localhost' is used, and if localport is not
-given then 8025 is used.  If remotehost is not given then `localhost' is used,
+If localhost is not given then 'localhost' is used, and if localport is not
+given then 8025 is used.  If remotehost is not given then 'localhost' is used,
 and if remoteport is not given, then 25 is used.
 """
 
@@ -70,16 +70,17 @@
 # - Handle more ESMTP extensions
 # - handle error codes from the backend smtpd
 
-import sys
-import os
+import collections
 import errno
 import getopt
-import time
+import os
 import socket
-import collections
-from test.support import asyncore, asynchat
-from warnings import warn
+import sys
+import time
 from email._header_value_parser import get_addr_spec, get_angle_addr
+from warnings import warn
+
+from test.support import asynchat, asyncore
 
 __all__ = [
     "SMTPChannel", "SMTPServer", "DebuggingServer", "PureProxy",
@@ -633,7 +634,8 @@ def __init__(self, localaddr, remoteaddr,
                              " be set to True at the same time")
         asyncore.dispatcher.__init__(self, map=map)
         try:
-            gai_results = socket.getaddrinfo(*localaddr,
+            family = 0 if socket.has_ipv6 else socket.AF_INET
+            gai_results = socket.getaddrinfo(*localaddr, family=family,
                                              type=socket.SOCK_STREAM)
             self.create_socket(gai_results[0][0], gai_results[0][1])
             # try to re-use a server port if possible
@@ -672,9 +674,9 @@ def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
         message to.
 
         data is a string containing the entire full text of the message,
-        headers (if supplied) and all.  It has been `de-transparencied'
+        headers (if supplied) and all.  It has been 'de-transparencied'
         according to RFC 821, Section 4.5.2.  In other words, a line
-        containing a `.' followed by other text has had the leading dot
+        containing a '.' followed by other text has had the leading dot
         removed.
 
         kwargs is a dictionary containing additional information.  It is
@@ -685,7 +687,7 @@ def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
                             ['BODY=8BITMIME', 'SMTPUTF8'].
             'rcpt_options': same, for the rcpt command.
 
-        This function should return None for a normal `250 Ok' response;
+        This function should return None for a normal '250 Ok' response;
         otherwise, it should return the desired response string in RFC 821
         format.
 
diff --git a/Lib/test/support/socket_helper.py b/Lib/test/support/socket_helper.py
index a41e487f3e4..655ffbea0db 100644
--- a/Lib/test/support/socket_helper.py
+++ b/Lib/test/support/socket_helper.py
@@ -2,8 +2,8 @@
 import errno
 import os.path
 import socket
-import sys
 import subprocess
+import sys
 import tempfile
 import unittest
 
diff --git a/Lib/test/support/strace_helper.py b/Lib/test/support/strace_helper.py
new file mode 100644
index 00000000000..abc93dee2ce
--- /dev/null
+++ b/Lib/test/support/strace_helper.py
@@ -0,0 +1,210 @@
+import os
+import re
+import sys
+import textwrap
+import unittest
+from dataclasses import dataclass
+from functools import cache
+
+from test import support
+from test.support.script_helper import run_python_until_end
+
+_strace_binary = "/usr/bin/strace"
+_syscall_regex = re.compile(
+    r"(?P<syscall>[^(]*)\((?P<args>[^)]*)\)\s*[=]\s*(?P<returncode>.+)")
+_returncode_regex = re.compile(
+    br"\+\+\+ exited with (?P<returncode>\d+) \+\+\+")
+
+
+@dataclass
+class StraceEvent:
+    syscall: str
+    args: list[str]
+    returncode: str
+
+
+@dataclass
+class StraceResult:
+    strace_returncode: int
+    python_returncode: int
+
+    """The event messages generated by strace. This is very similar to the
+    stderr strace produces with returncode marker section removed."""
+    event_bytes: bytes
+    stdout: bytes
+    stderr: bytes
+
+    def events(self):
+        """Parse event_bytes data into system calls for easier processing.
+
+        This assumes the program under inspection doesn't print any non-utf8
+        strings which would mix into the strace output."""
+        decoded_events = self.event_bytes.decode('utf-8', 'surrogateescape')
+        matches = [
+            _syscall_regex.match(event)
+            for event in decoded_events.splitlines()
+        ]
+        return [
+            StraceEvent(match["syscall"],
+                        [arg.strip() for arg in (match["args"].split(","))],
+                        match["returncode"]) for match in matches if match
+        ]
+
+    def sections(self):
+        """Find all "MARK <X>" writes and use them to make groups of events.
+
+        This is useful to avoid variable / overhead events, like those at
+        interpreter startup or when opening a file so a test can verify just
+        the small case under study."""
+        current_section = "__startup"
+        sections = {current_section: []}
+        for event in self.events():
+            if event.syscall == 'write' and len(
+                    event.args) > 2 and event.args[1].startswith("\"MARK "):
+                # Found a new section, don't include the write in the section
+                # but all events until next mark should be in that section
+                current_section = event.args[1].split(
+                    " ", 1)[1].removesuffix('\\n"')
+                if current_section not in sections:
+                    sections[current_section] = list()
+            else:
+                sections[current_section].append(event)
+
+        return sections
+
+def _filter_memory_call(call):
+    # mmap can operate on a fd or "MAP_ANONYMOUS" which gives a block of memory.
+    # Ignore "MAP_ANONYMOUS + the "MAP_ANON" alias.
+    if call.syscall == "mmap" and "MAP_ANON" in call.args[3]:
+        return True
+
+    if call.syscall in ("munmap", "mprotect"):
+        return True
+
+    return False
+
+
+def filter_memory(syscalls):
+    """Filter out memory allocation calls from File I/O calls.
+
+    Some calls (mmap, munmap, etc) can be used on files or to just get a block
+    of memory. Use this function to filter out the memory related calls from
+    other calls."""
+
+    return [call for call in syscalls if not _filter_memory_call(call)]
+
+
+@support.requires_subprocess()
+def strace_python(code, strace_flags, check=True):
+    """Run strace and return the trace.
+
+    Sets strace_returncode and python_returncode to `-1` on error."""
+    res = None
+
+    def _make_error(reason, details):
+        return StraceResult(
+            strace_returncode=-1,
+            python_returncode=-1,
+            event_bytes= f"error({reason},details={details!r}) = -1".encode('utf-8'),
+            stdout=res.out if res else b"",
+            stderr=res.err if res else b"")
+
+    # Run strace, and get out the raw text
+    try:
+        res, cmd_line = run_python_until_end(
+            "-c",
+            textwrap.dedent(code),
+            __run_using_command=[_strace_binary] + strace_flags,
+        )
+    except OSError as err:
+        return _make_error("Caught OSError", err)
+
+    if check and res.rc:
+        res.fail(cmd_line)
+
+    # Get out program returncode
+    stripped = res.err.strip()
+    output = stripped.rsplit(b"\n", 1)
+    if len(output) != 2:
+        return _make_error("Expected strace events and exit code line",
+                           stripped[-50:])
+
+    returncode_match = _returncode_regex.match(output[1])
+    if not returncode_match:
+        return _make_error("Expected to find returncode in last line.",
+                           output[1][:50])
+
+    python_returncode = int(returncode_match["returncode"])
+    if check and python_returncode:
+        res.fail(cmd_line)
+
+    return StraceResult(strace_returncode=res.rc,
+                        python_returncode=python_returncode,
+                        event_bytes=output[0],
+                        stdout=res.out,
+                        stderr=res.err)
+
+
+def get_events(code, strace_flags, prelude, cleanup):
+    # NOTE: The flush is currently required to prevent the prints from getting
+    # buffered and done all at once at exit
+    prelude = textwrap.dedent(prelude)
+    code = textwrap.dedent(code)
+    cleanup = textwrap.dedent(cleanup)
+    to_run = f"""
+print("MARK prelude", flush=True)
+{prelude}
+print("MARK code", flush=True)
+{code}
+print("MARK cleanup", flush=True)
+{cleanup}
+print("MARK __shutdown", flush=True)
+    """
+    trace = strace_python(to_run, strace_flags)
+    all_sections = trace.sections()
+    return all_sections['code']
+
+
+def get_syscalls(code, strace_flags, prelude="", cleanup="",
+                 ignore_memory=True):
+    """Get the syscalls which a given chunk of python code generates"""
+    events = get_events(code, strace_flags, prelude=prelude, cleanup=cleanup)
+
+    if ignore_memory:
+        events = filter_memory(events)
+
+    return [ev.syscall for ev in events]
+
+
+# Moderately expensive (spawns a subprocess), so share results when possible.
+@cache
+def _can_strace():
+    res = strace_python("import sys; sys.exit(0)",
+                        # --trace option needs strace 5.5 (gh-133741)
+                        ["--trace=%process"],
+                        check=False)
+    if res.strace_returncode == 0 and res.python_returncode == 0:
+        assert res.events(), "Should have parsed multiple calls"
+        return True
+    return False
+
+
+def requires_strace():
+    if sys.platform != "linux":
+        return unittest.skip("Linux only, requires strace.")
+
+    if "LD_PRELOAD" in os.environ:
+        # Distribution packaging (ex. Debian `fakeroot` and Gentoo `sandbox`)
+        # use LD_PRELOAD to intercept system calls, which changes the overall
+        # set of system calls which breaks tests expecting a specific set of
+        # system calls).
+        return unittest.skip("Not supported when LD_PRELOAD is intercepting system calls.")
+
+    if support.check_sanitizer(address=True, memory=True):
+        return unittest.skip("LeakSanitizer does not work under ptrace (strace, gdb, etc)")
+
+    return unittest.skipUnless(_can_strace(), "Requires working strace")
+
+
+__all__ = ["filter_memory", "get_events", "get_syscalls", "requires_strace",
+           "strace_python", "StraceEvent", "StraceResult"]
diff --git a/Lib/test/support/testcase.py b/Lib/test/support/testcase.py
index fd32457d146..e617b19b6ac 100644
--- a/Lib/test/support/testcase.py
+++ b/Lib/test/support/testcase.py
@@ -1,6 +1,7 @@
 from math import copysign, isnan
 
 
+# XXX: RUSTPYTHON: removed in 3.14
 class ExtraAssertions:
 
     def assertIsSubclass(self, cls, superclass, msg=None):
diff --git a/Lib/test/support/testresult.py b/Lib/test/support/testresult.py
deleted file mode 100644
index de23fdd59de..00000000000
--- a/Lib/test/support/testresult.py
+++ /dev/null
@@ -1,191 +0,0 @@
-'''Test runner and result class for the regression test suite.
-
-'''
-
-import functools
-import io
-import sys
-import time
-import traceback
-import unittest
-from test import support
-
-class RegressionTestResult(unittest.TextTestResult):
-    USE_XML = False
-
-    def __init__(self, stream, descriptions, verbosity):
-        super().__init__(stream=stream, descriptions=descriptions,
-                         verbosity=2 if verbosity else 0)
-        self.buffer = True
-        if self.USE_XML:
-            from xml.etree import ElementTree as ET
-            from datetime import datetime, UTC
-            self.__ET = ET
-            self.__suite = ET.Element('testsuite')
-            self.__suite.set('start',
-                             datetime.now(UTC)
-                                     .replace(tzinfo=None)
-                                     .isoformat(' '))
-            self.__e = None
-        self.__start_time = None
-
-    @classmethod
-    def __getId(cls, test):
-        try:
-            test_id = test.id
-        except AttributeError:
-            return str(test)
-        try:
-            return test_id()
-        except TypeError:
-            return str(test_id)
-        return repr(test)
-
-    def startTest(self, test):
-        super().startTest(test)
-        if self.USE_XML:
-            self.__e = e = self.__ET.SubElement(self.__suite, 'testcase')
-        self.__start_time = time.perf_counter()
-
-    def _add_result(self, test, capture=False, **args):
-        if not self.USE_XML:
-            return
-        e = self.__e
-        self.__e = None
-        if e is None:
-            return
-        ET = self.__ET
-
-        e.set('name', args.pop('name', self.__getId(test)))
-        e.set('status', args.pop('status', 'run'))
-        e.set('result', args.pop('result', 'completed'))
-        if self.__start_time:
-            e.set('time', f'{time.perf_counter() - self.__start_time:0.6f}')
-
-        if capture:
-            if self._stdout_buffer is not None:
-                stdout = self._stdout_buffer.getvalue().rstrip()
-                ET.SubElement(e, 'system-out').text = stdout
-            if self._stderr_buffer is not None:
-                stderr = self._stderr_buffer.getvalue().rstrip()
-                ET.SubElement(e, 'system-err').text = stderr
-
-        for k, v in args.items():
-            if not k or not v:
-                continue
-            e2 = ET.SubElement(e, k)
-            if hasattr(v, 'items'):
-                for k2, v2 in v.items():
-                    if k2:
-                        e2.set(k2, str(v2))
-                    else:
-                        e2.text = str(v2)
-            else:
-                e2.text = str(v)
-
-    @classmethod
-    def __makeErrorDict(cls, err_type, err_value, err_tb):
-        if isinstance(err_type, type):
-            if err_type.__module__ == 'builtins':
-                typename = err_type.__name__
-            else:
-                typename = f'{err_type.__module__}.{err_type.__name__}'
-        else:
-            typename = repr(err_type)
-
-        msg = traceback.format_exception(err_type, err_value, None)
-        tb = traceback.format_exception(err_type, err_value, err_tb)
-
-        return {
-            'type': typename,
-            'message': ''.join(msg),
-            '': ''.join(tb),
-        }
-
-    def addError(self, test, err):
-        self._add_result(test, True, error=self.__makeErrorDict(*err))
-        super().addError(test, err)
-
-    def addExpectedFailure(self, test, err):
-        self._add_result(test, True, output=self.__makeErrorDict(*err))
-        super().addExpectedFailure(test, err)
-
-    def addFailure(self, test, err):
-        self._add_result(test, True, failure=self.__makeErrorDict(*err))
-        super().addFailure(test, err)
-        if support.failfast:
-            self.stop()
-
-    def addSkip(self, test, reason):
-        self._add_result(test, skipped=reason)
-        super().addSkip(test, reason)
-
-    def addSuccess(self, test):
-        self._add_result(test)
-        super().addSuccess(test)
-
-    def addUnexpectedSuccess(self, test):
-        self._add_result(test, outcome='UNEXPECTED_SUCCESS')
-        super().addUnexpectedSuccess(test)
-
-    def get_xml_element(self):
-        if not self.USE_XML:
-            raise ValueError("USE_XML is false")
-        e = self.__suite
-        e.set('tests', str(self.testsRun))
-        e.set('errors', str(len(self.errors)))
-        e.set('failures', str(len(self.failures)))
-        return e
-
-class QuietRegressionTestRunner:
-    def __init__(self, stream, buffer=False):
-        self.result = RegressionTestResult(stream, None, 0)
-        self.result.buffer = buffer
-
-    def run(self, test):
-        test(self.result)
-        return self.result
-
-def get_test_runner_class(verbosity, buffer=False):
-    if verbosity:
-        return functools.partial(unittest.TextTestRunner,
-                                 resultclass=RegressionTestResult,
-                                 buffer=buffer,
-                                 verbosity=verbosity)
-    return functools.partial(QuietRegressionTestRunner, buffer=buffer)
-
-def get_test_runner(stream, verbosity, capture_output=False):
-    return get_test_runner_class(verbosity, capture_output)(stream)
-
-if __name__ == '__main__':
-    import xml.etree.ElementTree as ET
-    RegressionTestResult.USE_XML = True
-
-    class TestTests(unittest.TestCase):
-        def test_pass(self):
-            pass
-
-        def test_pass_slow(self):
-            time.sleep(1.0)
-
-        def test_fail(self):
-            print('stdout', file=sys.stdout)
-            print('stderr', file=sys.stderr)
-            self.fail('failure message')
-
-        def test_error(self):
-            print('stdout', file=sys.stdout)
-            print('stderr', file=sys.stderr)
-            raise RuntimeError('error message')
-
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestTests))
-    stream = io.StringIO()
-    runner_cls = get_test_runner_class(sum(a == '-v' for a in sys.argv))
-    runner = runner_cls(sys.stdout)
-    result = runner.run(suite)
-    print('Output:', stream.getvalue())
-    print('XML: ', end='')
-    for s in ET.tostringlist(result.get_xml_element()):
-        print(s.decode(), end='')
-    print()
diff --git a/Lib/test/support/threading_helper.py b/Lib/test/support/threading_helper.py
index afa25a76f63..9b2b8f2dff0 100644
--- a/Lib/test/support/threading_helper.py
+++ b/Lib/test/support/threading_helper.py
@@ -8,7 +8,6 @@
 
 from test import support
 
-
 #=======================================================================
 # Threading support to prevent reporting refleaks when running regrtest.py -R
 
@@ -248,3 +247,27 @@ def requires_working_threading(*, module=False):
             raise unittest.SkipTest(msg)
     else:
         return unittest.skipUnless(can_start_thread, msg)
+
+
+def run_concurrently(worker_func, nthreads, args=(), kwargs={}):
+    """
+    Run the worker function concurrently in multiple threads.
+    """
+    barrier = threading.Barrier(nthreads)
+
+    def wrapper_func(*args, **kwargs):
+        # Wait for all threads to reach this point before proceeding.
+        barrier.wait()
+        worker_func(*args, **kwargs)
+
+    with catch_threading_exception() as cm:
+        workers = [
+            threading.Thread(target=wrapper_func, args=args, kwargs=kwargs)
+            for _ in range(nthreads)
+        ]
+        with start_threads(workers):
+            pass
+
+        # If a worker thread raises an exception, re-raise it.
+        if cm.exc_value is not None:
+            raise cm.exc_value
diff --git a/Lib/test/support/venv.py b/Lib/test/support/venv.py
index 78e6a51ec18..b60f6097e65 100644
--- a/Lib/test/support/venv.py
+++ b/Lib/test/support/venv.py
@@ -1,8 +1,8 @@
 import contextlib
 import logging
 import os
-import subprocess
 import shlex
+import subprocess
 import sys
 import sysconfig
 import tempfile
@@ -68,3 +68,14 @@ def run(self, *args, **subprocess_args):
             raise
         else:
             return result
+
+
+class VirtualEnvironmentMixin:
+    def venv(self, name=None, **venv_create_args):
+        venv_name = self.id()
+        if name:
+            venv_name += f'-{name}'
+        return VirtualEnvironment.from_tmpdir(
+            prefix=f'{venv_name}-venv-',
+            **venv_create_args,
+        )
diff --git a/Lib/test/support/warnings_helper.py b/Lib/test/support/warnings_helper.py
index c1bf0562300..5f6f14afd74 100644
--- a/Lib/test/support/warnings_helper.py
+++ b/Lib/test/support/warnings_helper.py
@@ -23,8 +23,7 @@ def check_syntax_warning(testcase, statement, errtext='',
     testcase.assertEqual(len(warns), 1, warns)
 
     warn, = warns
-    testcase.assertTrue(issubclass(warn.category, SyntaxWarning),
-                        warn.category)
+    testcase.assertIsSubclass(warn.category, SyntaxWarning)
     if errtext:
         testcase.assertRegex(str(warn.message), errtext)
     testcase.assertEqual(warn.filename, '<testcase>')
@@ -160,11 +159,12 @@ def _filterwarnings(filters, quiet=False):
     registry = frame.f_globals.get('__warningregistry__')
     if registry:
         registry.clear()
-    with warnings.catch_warnings(record=True) as w:
-        # Set filter "always" to record all warnings.  Because
-        # test_warnings swap the module, we need to look up in
-        # the sys.modules dictionary.
-        sys.modules['warnings'].simplefilter("always")
+    # Because test_warnings swap the module, we need to look up in the
+    # sys.modules dictionary.
+    wmod = sys.modules['warnings']
+    with wmod.catch_warnings(record=True) as w:
+        # Set filter "always" to record all warnings.
+        wmod.simplefilter("always")
         yield WarningsRecorder(w)
     # Filter the recorded warnings
     reraise = list(w)
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index d66afdc833c..813a639d1c4 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -5,6 +5,7 @@
 import logging
 import os
 import shutil
+import signal
 import socket
 import stat
 import subprocess
@@ -16,12 +17,13 @@
 import warnings
 
 from test import support
-from test.support import import_helper
-from test.support import os_helper
-from test.support import script_helper
-from test.support import socket_helper
-from test.support import warnings_helper
-from test.support.testcase import ExtraAssertions
+from test.support import (
+    import_helper,
+    os_helper,
+    script_helper,
+    socket_helper,
+    warnings_helper,
+)
 
 TESTFN = os_helper.TESTFN
 
@@ -51,26 +53,26 @@ def _caplog():
         root_logger.removeHandler(handler)
 
 
-class TestSupport(unittest.TestCase, ExtraAssertions):
+class TestSupport(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        orig_filter_len = len(warnings.filters)
+        orig_filter_len = len(warnings._get_filters())
         cls._warnings_helper_token = support.ignore_deprecations_from(
             "test.support.warnings_helper", like=".*used in test_support.*"
         )
         cls._test_support_token = support.ignore_deprecations_from(
             __name__, like=".*You should NOT be seeing this.*"
         )
-        assert len(warnings.filters) == orig_filter_len + 2
+        assert len(warnings._get_filters()) == orig_filter_len + 2
 
     @classmethod
     def tearDownClass(cls):
-        orig_filter_len = len(warnings.filters)
+        orig_filter_len = len(warnings._get_filters())
         support.clear_ignored_deprecations(
             cls._warnings_helper_token,
             cls._test_support_token,
         )
-        assert len(warnings.filters) == orig_filter_len - 2
+        assert len(warnings._get_filters()) == orig_filter_len - 2
 
     def test_ignored_deprecations_are_silent(self):
         """Test support.ignore_deprecations_from() silences warnings"""
@@ -98,7 +100,7 @@ def test_get_original_stdout(self):
         self.assertEqual(support.get_original_stdout(), sys.stdout)
 
     def test_unload(self):
-        import sched
+        import sched  # noqa: F401
         self.assertIn("sched", sys.modules)
         import_helper.unload("sched")
         self.assertNotIn("sched", sys.modules)
@@ -407,10 +409,10 @@ class Obj:
         with support.swap_attr(obj, "y", 5) as y:
             self.assertEqual(obj.y, 5)
             self.assertIsNone(y)
-        self.assertFalse(hasattr(obj, 'y'))
+        self.assertNotHasAttr(obj, 'y')
         with support.swap_attr(obj, "y", 5):
             del obj.y
-        self.assertFalse(hasattr(obj, 'y'))
+        self.assertNotHasAttr(obj, 'y')
 
     def test_swap_item(self):
         D = {"x":1}
@@ -469,7 +471,6 @@ def test_check__all__(self):
         extra = {
             'TextTestResult',
             'installHandler',
-            'IsolatedAsyncioTestCase',
         }
         not_exported = {'load_tests', "TestProgram", "BaseTestSuite"}
         support.check__all__(self,
@@ -562,6 +563,7 @@ def test_args_from_interpreter_flags(self):
             ['-Wignore', '-X', 'dev'],
             ['-X', 'faulthandler'],
             ['-X', 'importtime'],
+            ['-X', 'importtime=2'],
             ['-X', 'showrefcount'],
             ['-X', 'tracemalloc'],
             ['-X', 'tracemalloc=3'],
@@ -586,7 +588,6 @@ def test_optim_args_from_interpreter_flags(self):
                 self.check_options(opts, 'optim_args_from_interpreter_flags')
 
     @unittest.skipIf(support.is_apple_mobile, "Unstable on Apple Mobile")
-    @unittest.skipIf(support.is_emscripten, "Unstable in Emscripten")
     @unittest.skipIf(support.is_wasi, "Unavailable on WASI")
     def test_fd_count(self):
         # We cannot test the absolute value of fd_count(): on old Linux kernel
@@ -614,17 +615,13 @@ def test_print_warning(self):
         self.check_print_warning("a\nb",
                                  'Warning -- a\nWarning -- b\n')
 
-    # TODO: RUSTPYTHON - strftime extension not fully supported on non-Windows
-    @unittest.skipUnless(sys.platform == "win32" or support.is_emscripten,
-                         "strftime extension not fully supported on non-Windows")
     def test_has_strftime_extensions(self):
-        if support.is_emscripten or sys.platform == "win32":
+        if sys.platform == "win32":
             self.assertFalse(support.has_strftime_extensions)
         else:
             self.assertTrue(support.has_strftime_extensions)
 
-    # TODO: RUSTPYTHON - _testinternalcapi module not available
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; - _testinternalcapi module not available
     def test_get_recursion_depth(self):
         # test support.get_recursion_depth()
         code = textwrap.dedent("""
@@ -668,8 +665,7 @@ def test_recursive(depth, limit):
         """)
         script_helper.assert_python_ok("-c", code)
 
-    # TODO: RUSTPYTHON - stack overflow in debug mode with deep recursion
-    @unittest.skip("TODO: RUSTPYTHON - causes segfault in debug builds")
+    @unittest.skip('TODO: RUSTPYTHON; - causes segfault in debug builds')
     def test_recursion(self):
         # Test infinite_recursion() and get_recursion_available() functions.
         def recursive_function(depth):
@@ -778,9 +774,31 @@ def test_copy_python_src_ignore(self):
         self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)),
                          ignored)
 
+    def test_get_signal_name(self):
+        for exitcode, expected in (
+            (-int(signal.SIGINT), 'SIGINT'),
+            (-int(signal.SIGSEGV), 'SIGSEGV'),
+            (128 + int(signal.SIGABRT), 'SIGABRT'),
+            (3221225477, "STATUS_ACCESS_VIOLATION"),
+            (0xC00000FD, "STATUS_STACK_OVERFLOW"),
+        ):
+            self.assertEqual(support.get_signal_name(exitcode), expected,
+                             exitcode)
+
     def test_linked_to_musl(self):
         linked = support.linked_to_musl()
-        self.assertIsInstance(linked, bool)
+        self.assertIsNotNone(linked)
+        if support.is_wasm32:
+            self.assertTrue(linked)
+        # The value is cached, so make sure it returns the same value again.
+        self.assertIs(linked, support.linked_to_musl())
+        # The musl version is either triple or just a major version number.
+        if linked:
+            self.assertIsInstance(linked, tuple)
+            self.assertIn(len(linked), (1, 3))
+            for v in linked:
+                self.assertIsInstance(v, int)
+
 
     # XXX -follows a list of untested API
     # make_legacy_pyc

From 3836958eaac9d89165d822dc6fbfe028c3e63249 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sat, 10 Jan 2026 16:32:26 +0900
Subject: [PATCH 362/418] Make ready_to_import always remove tempdir from
 sys.path (re-apply #6687)

---
 Lib/test/support/import_helper.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index d31713b8651..2d80b663dd5 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -305,8 +305,8 @@ def ready_to_import(name=None, source=""):
         try:
             sys.path.insert(0, tempdir)
             yield name, path
-            sys.path.remove(tempdir)
         finally:
+            sys.path.remove(tempdir)
             if old_module is not None:
                 sys.modules[name] = old_module
             else:

From 8f7b1343bcbcaff375edb88d392622acbf9f993f Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sun, 18 Jan 2026 14:00:21 +0900
Subject: [PATCH 363/418] mark and unmark successful/failing tests

---
 Lib/test/test__colorize.py         |  1 -
 Lib/test/test_argparse.py          |  1 -
 Lib/test/test_ast/test_ast.py      |  2 --
 Lib/test/test_calendar.py          |  1 -
 Lib/test/test_int.py               | 12 ++++++------
 Lib/test/test_json/test_fail.py    |  2 --
 Lib/test/test_json/test_tool.py    |  1 -
 Lib/test/test_re.py                |  4 ++--
 Lib/test/test_regrtest.py          |  4 ++--
 Lib/test/test_support.py           |  2 ++
 Lib/test/test_warnings/__init__.py |  2 --
 11 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/Lib/test/test__colorize.py b/Lib/test/test__colorize.py
index 31dc60fec35..026277267e0 100644
--- a/Lib/test/test__colorize.py
+++ b/Lib/test/test__colorize.py
@@ -24,7 +24,6 @@ def supports_virtual_terminal():
 
 class TestTheme(unittest.TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_attributes(self):
         # only theme configurations attributes by default
         for field in dataclasses.fields(_colorize.Theme):
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index beda61be8a4..9b8179ef969 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -6824,7 +6824,6 @@ def test_nargs_zero(self):
 
 class TestImportStar(TestCase):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test(self):
         for name in argparse.__all__:
             self.assertHasAttr(argparse, name)
diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
index 57c19477ab6..5309939777f 100644
--- a/Lib/test/test_ast/test_ast.py
+++ b/Lib/test/test_ast/test_ast.py
@@ -3023,7 +3023,6 @@ def visit_Expr(self, node: ast.Expr):
 
         self.assertASTTransformation(YieldRemover, code, expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; <class 'object'> is not <class 'NoneType'>
     def test_node_return_list(self):
         code = """
         class DSL(Base, kw1=True): ...
@@ -3064,7 +3063,6 @@ def visit_Call(self, node: ast.Call):
 
         self.assertASTTransformation(PrintToLog, code, expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; <class 'object'> is not <class 'NoneType'>
     def test_node_replace(self):
         code = """
         def func(arg):
diff --git a/Lib/test/test_calendar.py b/Lib/test/test_calendar.py
index 35573fd9f01..7ade4271b7a 100644
--- a/Lib/test/test_calendar.py
+++ b/Lib/test/test_calendar.py
@@ -1090,7 +1090,6 @@ def test_option_months(self):
             output = run('--months', '1', '2004')
             self.assertIn(conv('\nMo Tu We Th Fr Sa Su\n'), output)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_option_type(self):
         self.assertFailure('-t')
         self.assertFailure('--type')
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
index 1ab7a1fb6dd..7f62ac067c4 100644
--- a/Lib/test/test_int.py
+++ b/Lib/test/test_int.py
@@ -681,7 +681,7 @@ def test_denial_of_service_prevented_int_to_str(self):
         digits = 78_268
         with (
                 support.adjust_int_max_str_digits(digits),
-                support.CPUStopwatch() as sw_convert):
+                support.Stopwatch() as sw_convert):
             huge_decimal = str(huge_int)
         self.assertEqual(len(huge_decimal), digits)
         # Ensuring that we chose a slow enough conversion to measure.
@@ -696,7 +696,7 @@ def test_denial_of_service_prevented_int_to_str(self):
         with support.adjust_int_max_str_digits(int(.995 * digits)):
             with (
                     self.assertRaises(ValueError) as err,
-                    support.CPUStopwatch() as sw_fail_huge):
+                    support.Stopwatch() as sw_fail_huge):
                 str(huge_int)
         self.assertIn('conversion', str(err.exception))
         self.assertLessEqual(sw_fail_huge.seconds, sw_convert.seconds/2)
@@ -706,7 +706,7 @@ def test_denial_of_service_prevented_int_to_str(self):
         extra_huge_int = int(f'0x{"c"*500_000}', base=16)  # 602060 digits.
         with (
                 self.assertRaises(ValueError) as err,
-                support.CPUStopwatch() as sw_fail_extra_huge):
+                support.Stopwatch() as sw_fail_extra_huge):
             # If not limited, 8 seconds said Zen based cloud VM.
             str(extra_huge_int)
         self.assertIn('conversion', str(err.exception))
@@ -722,7 +722,7 @@ def test_denial_of_service_prevented_str_to_int(self):
         huge = '8'*digits
         with (
                 support.adjust_int_max_str_digits(digits),
-                support.CPUStopwatch() as sw_convert):
+                support.Stopwatch() as sw_convert):
             int(huge)
         # Ensuring that we chose a slow enough conversion to measure.
         # It takes 0.1 seconds on a Zen based cloud VM in an opt build.
@@ -734,7 +734,7 @@ def test_denial_of_service_prevented_str_to_int(self):
         with support.adjust_int_max_str_digits(digits - 1):
             with (
                     self.assertRaises(ValueError) as err,
-                    support.CPUStopwatch() as sw_fail_huge):
+                    support.Stopwatch() as sw_fail_huge):
                 int(huge)
         self.assertIn('conversion', str(err.exception))
         self.assertLessEqual(sw_fail_huge.seconds, sw_convert.seconds/2)
@@ -744,7 +744,7 @@ def test_denial_of_service_prevented_str_to_int(self):
         extra_huge = '7'*1_200_000
         with (
                 self.assertRaises(ValueError) as err,
-                support.CPUStopwatch() as sw_fail_extra_huge):
+                support.Stopwatch() as sw_fail_extra_huge):
             # If not limited, 8 seconds in the Zen based cloud VM.
             int(extra_huge)
         self.assertIn('conversion', str(err.exception))
diff --git a/Lib/test/test_json/test_fail.py b/Lib/test/test_json/test_fail.py
index 48c974a3300..cb88e317b4e 100644
--- a/Lib/test/test_json/test_fail.py
+++ b/Lib/test/test_json/test_fail.py
@@ -99,8 +99,6 @@ def test_non_string_keys_dict(self):
                 'keys must be str, int, float, bool or None, not tuple'):
             self.dumps(data)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_not_serializable(self):
         import sys
         with self.assertRaisesRegex(TypeError,
diff --git a/Lib/test/test_json/test_tool.py b/Lib/test/test_json/test_tool.py
index c60e58526f4..068a7acb651 100644
--- a/Lib/test/test_json/test_tool.py
+++ b/Lib/test/test_json/test_tool.py
@@ -165,7 +165,6 @@ def test_jsonlines(self):
         self.assertEqual(process.stdout, self.jsonlines_expect)
         self.assertEqual(process.stderr, '')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_help_flag(self):
         rc, out, err = assert_python_ok('-m', self.module, '-h',
                                         PYTHON_COLORS='0')
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 7c5bfba41bf..04c8ee71a99 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -1,7 +1,7 @@
 from test.support import (gc_collect, bigmemtest, _2G,
                           cpython_only, captured_stdout,
                           check_disallow_instantiation, is_emscripten, is_wasi,
-                          warnings_helper, SHORT_TIMEOUT, CPUStopwatch, requires_resource)
+                          warnings_helper, SHORT_TIMEOUT, Stopwatch, requires_resource)
 import locale
 import re
 import string
@@ -2487,7 +2487,7 @@ def test_bug_40736(self):
     @requires_resource('cpu')
     def test_search_anchor_at_beginning(self):
         s = 'x'*10**7
-        with CPUStopwatch() as stopwatch:
+        with Stopwatch() as stopwatch:
             for p in r'\Ay', r'^y':
                 self.assertIsNone(re.search(p, s))
                 self.assertEqual(re.split(p, s), [s])
diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index 9f09413f59c..ba038f18b4c 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -24,7 +24,7 @@
 from xml.etree import ElementTree
 
 from test import support
-from test.support import os_helper, without_optimizer
+from test.support import os_helper, requires_jit_disabled
 from test.libregrtest import cmdline
 from test.libregrtest import main
 from test.libregrtest import setup
@@ -1245,7 +1245,7 @@ def test_run(self):
                                   stats=TestStats(4, 1),
                                   forever=True)
 
-    @without_optimizer
+    @requires_jit_disabled
     def check_leak(self, code, what, *, run_workers=False):
         test = self.create_test('huntrleaks', code=code)
 
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 813a639d1c4..481be2bff92 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -460,6 +460,7 @@ def test_detect_api_mismatch__ignore(self):
                 self.OtherClass, self.RefClass, ignore=ignore)
         self.assertEqual(set(), missing_items)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_check__all__(self):
         extra = {'tempdir'}
         not_exported = {'template'}
@@ -615,6 +616,7 @@ def test_print_warning(self):
         self.check_print_warning("a\nb",
                                  'Warning -- a\nWarning -- b\n')
 
+    @unittest.expectedFailureIf(sys.platform != "win32", "TODO: RUSTPYTHON; no has_strftime_extensions yet")
     def test_has_strftime_extensions(self):
         if sys.platform == "win32":
             self.assertFalse(support.has_strftime_extensions)
diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index fb324294f47..abdf7b32df2 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -101,7 +101,6 @@ class PublicAPITests(BaseTest):
     public API.
     """
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON 'PyPublicAPITests' object has no attribute 'assertHasAttr'
     def test_module_all_attribute(self):
         self.assertHasAttr(self.module, '__all__')
         target_api = ["warn", "warn_explicit", "showwarning",
@@ -851,7 +850,6 @@ class PyWarnTests(WarnTests, unittest.TestCase):
 
     # As an early adopter, we sanity check the
     # test.import_helper.import_fresh_module utility function
-    @unittest.expectedFailure # TODO: RUSTPYTHON 'PyWarnTests' object has no attribute 'assertHasAttr'
     def test_pure_python(self):
         self.assertIsNot(original_warnings, self.module)
         self.assertHasAttr(self.module.warn, '__code__')

From e0b19c833cb5cd0bb9375389658a8cc870bf707d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Sun, 18 Jan 2026 20:33:12 +0900
Subject: [PATCH 364/418] skip flaky test

---
 Lib/test/_test_multiprocessing.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index f6c1f292867..0855e384f24 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -4417,6 +4417,7 @@ def test_shared_memory_across_processes(self):
 
         sms.close()
 
+    @unittest.skip("TODO: RUSTPYTHON; flaky")
     @unittest.skipIf(os.name != "posix", "not feasible in non-posix platforms")
     def test_shared_memory_SharedMemoryServer_ignores_sigint(self):
         # bpo-36368: protect SharedMemoryManager server process from

From 6f266651c0896210015e0304e8a9e50fd562b9e9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 21:10:35 +0900
Subject: [PATCH 365/418] better ssl write handling (#6763)

* ssl_write

* Fix thread count timing
---
 crates/stdlib/src/ssl.rs        | 199 ++++++++++++++++-----------
 crates/stdlib/src/ssl/compat.rs | 233 ++++++++++++++++++++++++++++----
 crates/stdlib/src/ssl/error.rs  |  11 ++
 crates/vm/src/stdlib/thread.rs  |  28 ++--
 4 files changed, 356 insertions(+), 115 deletions(-)

diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 31973a84f89..6c62a24397b 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -50,7 +50,7 @@ mod _ssl {
 
     // Import error types used in this module (others are exposed via pymodule(with(...)))
     use super::error::{
-        PySSLEOFError, PySSLError, create_ssl_want_read_error, create_ssl_want_write_error,
+        PySSLError, create_ssl_eof_error, create_ssl_want_read_error, create_ssl_want_write_error,
     };
     use alloc::sync::Arc;
     use core::{
@@ -1903,6 +1903,7 @@ mod _ssl {
                 client_hello_buffer: PyMutex::new(None),
                 shutdown_state: PyMutex::new(ShutdownState::NotStarted),
                 pending_tls_output: PyMutex::new(Vec::new()),
+                write_buffered_len: PyMutex::new(0),
                 deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
             };
 
@@ -1974,6 +1975,7 @@ mod _ssl {
                 client_hello_buffer: PyMutex::new(None),
                 shutdown_state: PyMutex::new(ShutdownState::NotStarted),
                 pending_tls_output: PyMutex::new(Vec::new()),
+                write_buffered_len: PyMutex::new(0),
                 deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
             };
 
@@ -2345,6 +2347,10 @@ mod _ssl {
         // but the socket cannot accept all the data immediately
         #[pytraverse(skip)]
         pub(crate) pending_tls_output: PyMutex<Vec<u8>>,
+        // Tracks bytes already buffered in rustls for the current write operation
+        // Prevents duplicate writes when retrying after WantWrite/WantRead
+        #[pytraverse(skip)]
+        pub(crate) write_buffered_len: PyMutex<usize>,
         // Deferred client certificate verification error (for TLS 1.3)
         // Stores error message if client cert verification failed during handshake
         // Error is raised on first I/O operation after handshake
@@ -2604,6 +2610,36 @@ mod _ssl {
             Ok(timed_out)
         }
 
+        // Internal implementation with explicit timeout override
+        pub(crate) fn sock_wait_for_io_with_timeout(
+            &self,
+            kind: SelectKind,
+            timeout: Option<std::time::Duration>,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            if self.is_bio_mode() {
+                // BIO mode doesn't use select
+                return Ok(false);
+            }
+
+            if let Some(t) = timeout
+                && t.is_zero()
+            {
+                // Non-blocking mode - don't use select
+                return Ok(false);
+            }
+
+            let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+            let socket = py_socket
+                .sock()
+                .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+
+            let timed_out = sock_select(&socket, kind, timeout)
+                .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+            Ok(timed_out)
+        }
+
         // SNI (Server Name Indication) Helper Methods:
         // These methods support the server-side handshake SNI callback mechanism
 
@@ -2783,6 +2819,7 @@ mod _ssl {
             let is_non_blocking = socket_timeout.map(|t| t.is_zero()).unwrap_or(false);
 
             let mut sent_total = 0;
+
             while sent_total < pending.len() {
                 // Calculate timeout: use deadline if provided, otherwise use socket timeout
                 let timeout_to_use = if let Some(dl) = deadline {
@@ -2810,6 +2847,9 @@ mod _ssl {
                 if timed_out {
                     // Keep unsent data in pending buffer
                     *pending = pending[sent_total..].to_vec();
+                    if is_non_blocking {
+                        return Err(create_ssl_want_write_error(vm).upcast());
+                    }
                     return Err(
                         timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
                     );
@@ -2824,6 +2864,7 @@ mod _ssl {
                                 *pending = pending[sent_total..].to_vec();
                                 return Err(create_ssl_want_write_error(vm).upcast());
                             }
+                            // Socket said ready but sent 0 bytes - retry
                             continue;
                         }
                         sent_total += sent;
@@ -2916,6 +2957,9 @@ mod _ssl {
         pub(crate) fn blocking_flush_all_pending(&self, vm: &VirtualMachine) -> PyResult<()> {
             // Get socket timeout to respect during flush
             let timeout = self.get_socket_timeout(vm)?;
+            if timeout.map(|t| t.is_zero()).unwrap_or(false) {
+                return self.flush_pending_tls_output(vm, None);
+            }
 
             loop {
                 let pending_data = {
@@ -2948,8 +2992,7 @@ mod _ssl {
                             let mut pending = self.pending_tls_output.lock();
                             pending.drain(..sent);
                         }
-                        // If sent == 0, socket wasn't ready despite select() saying so
-                        // Continue loop to retry - this avoids infinite loops
+                        // If sent == 0, loop will retry with sock_select
                     }
                     Err(e) => {
                         if is_blocking_io_error(&e, vm) {
@@ -3515,16 +3558,60 @@ mod _ssl {
                     return_data(buf, &buffer, vm)
                 }
                 Err(crate::ssl::compat::SslError::Eof) => {
+                    // If plaintext is still buffered, return it before EOF.
+                    let pending = {
+                        let mut conn_guard = self.connection.lock();
+                        let conn = match conn_guard.as_mut() {
+                            Some(conn) => conn,
+                            None => return Err(create_ssl_eof_error(vm).upcast()),
+                        };
+                        use std::io::BufRead;
+                        let mut reader = conn.reader();
+                        reader.fill_buf().map(|buf| buf.len()).unwrap_or(0)
+                    };
+                    if pending > 0 {
+                        let mut buf = vec![0u8; pending.min(len)];
+                        let read_retry = {
+                            let mut conn_guard = self.connection.lock();
+                            let conn = conn_guard
+                                .as_mut()
+                                .ok_or_else(|| vm.new_value_error("Connection not established"))?;
+                            crate::ssl::compat::ssl_read(conn, &mut buf, self, vm)
+                        };
+                        if let Ok(n) = read_retry {
+                            buf.truncate(n);
+                            return return_data(buf, &buffer, vm);
+                        }
+                    }
                     // EOF occurred in violation of protocol (unexpected closure)
-                    Err(vm
-                        .new_os_subtype_error(
-                            PySSLEOFError::class(&vm.ctx).to_owned(),
-                            None,
-                            "EOF occurred in violation of protocol",
-                        )
-                        .upcast())
+                    Err(create_ssl_eof_error(vm).upcast())
                 }
                 Err(crate::ssl::compat::SslError::ZeroReturn) => {
+                    // If plaintext is still buffered, return it before clean EOF.
+                    let pending = {
+                        let mut conn_guard = self.connection.lock();
+                        let conn = match conn_guard.as_mut() {
+                            Some(conn) => conn,
+                            None => return return_data(vec![], &buffer, vm),
+                        };
+                        use std::io::BufRead;
+                        let mut reader = conn.reader();
+                        reader.fill_buf().map(|buf| buf.len()).unwrap_or(0)
+                    };
+                    if pending > 0 {
+                        let mut buf = vec![0u8; pending.min(len)];
+                        let read_retry = {
+                            let mut conn_guard = self.connection.lock();
+                            let conn = conn_guard
+                                .as_mut()
+                                .ok_or_else(|| vm.new_value_error("Connection not established"))?;
+                            crate::ssl::compat::ssl_read(conn, &mut buf, self, vm)
+                        };
+                        if let Ok(n) = read_retry {
+                            buf.truncate(n);
+                            return return_data(buf, &buffer, vm);
+                        }
+                    }
                     // Clean closure with close_notify - return empty data
                     return_data(vec![], &buffer, vm)
                 }
@@ -3580,21 +3667,17 @@ mod _ssl {
             let data_bytes = data.borrow_buf();
             let data_len = data_bytes.len();
 
-            // return 0 immediately for empty write
             if data_len == 0 {
                 return Ok(0);
             }
 
-            // Ensure handshake is done - if not, complete it first
-            // This matches OpenSSL behavior where SSL_write() auto-completes handshake
+            // Ensure handshake is done (SSL_write auto-completes handshake)
             if !*self.handshake_done.lock() {
                 self.do_handshake(vm)?;
             }
 
-            // Check if connection has been shut down
-            // After unwrap()/shutdown(), write operations should fail with SSLError
-            let shutdown_state = *self.shutdown_state.lock();
-            if shutdown_state != ShutdownState::NotStarted {
+            // Check shutdown state
+            if *self.shutdown_state.lock() != ShutdownState::NotStarted {
                 return Err(vm
                     .new_os_subtype_error(
                         PySSLError::class(&vm.ctx).to_owned(),
@@ -3604,76 +3687,32 @@ mod _ssl {
                     .upcast());
             }
 
-            {
+            // Call ssl_write (matches CPython's SSL_write_ex loop)
+            let result = {
                 let mut conn_guard = self.connection.lock();
                 let conn = conn_guard
                     .as_mut()
                     .ok_or_else(|| vm.new_value_error("Connection not established"))?;
 
-                let is_bio = self.is_bio_mode();
-                let data: &[u8] = data_bytes.as_ref();
+                crate::ssl::compat::ssl_write(conn, data_bytes.as_ref(), self, vm)
+            };
 
-                // CRITICAL: Flush any pending TLS data before writing new data
-                // This ensures TLS 1.3 Finished message reaches server before application data
-                // Without this, server may not be ready to process our data
-                if !is_bio {
-                    self.flush_pending_tls_output(vm, None)?;
+            match result {
+                Ok(n) => {
+                    self.check_deferred_cert_error(vm)?;
+                    Ok(n)
                 }
-
-                // Write data in chunks to avoid filling the internal TLS buffer
-                // rustls has a limited internal buffer, so we need to flush periodically
-                const CHUNK_SIZE: usize = 16384; // 16KB chunks (typical TLS record size)
-                let mut written = 0;
-
-                while written < data.len() {
-                    let chunk_end = core::cmp::min(written + CHUNK_SIZE, data.len());
-                    let chunk = &data[written..chunk_end];
-
-                    // Write chunk to TLS layer
-                    {
-                        let mut writer = conn.writer();
-                        use std::io::Write;
-                        writer
-                            .write_all(chunk)
-                            .map_err(|e| vm.new_os_error(format!("Write failed: {e}")))?;
-                        // Flush to ensure data is converted to TLS records
-                        writer
-                            .flush()
-                            .map_err(|e| vm.new_os_error(format!("Flush failed: {e}")))?;
-                    }
-
-                    written = chunk_end;
-
-                    // Flush TLS data to socket after each chunk
-                    if conn.wants_write() {
-                        if is_bio {
-                            self.write_pending_tls(conn, vm)?;
-                        } else {
-                            // Socket mode: flush all pending TLS data
-                            // First, try to send any previously pending data
-                            self.flush_pending_tls_output(vm, None)?;
-
-                            while conn.wants_write() {
-                                let mut buf = Vec::new();
-                                conn.write_tls(&mut buf).map_err(|e| {
-                                    vm.new_os_error(format!("TLS write failed: {e}"))
-                                })?;
-
-                                if !buf.is_empty() {
-                                    // Try to send TLS data, saving unsent bytes to pending buffer
-                                    self.send_tls_output(buf, vm)?;
-                                }
-                            }
-                        }
-                    }
+                Err(crate::ssl::compat::SslError::WantRead) => {
+                    Err(create_ssl_want_read_error(vm).upcast())
+                }
+                Err(crate::ssl::compat::SslError::WantWrite) => {
+                    Err(create_ssl_want_write_error(vm).upcast())
+                }
+                Err(crate::ssl::compat::SslError::Timeout(msg)) => {
+                    Err(timeout_error_msg(vm, msg).upcast())
                 }
+                Err(e) => Err(e.into_py_err(vm)),
             }
-
-            // Check for deferred certificate verification errors (TLS 1.3)
-            // Must be checked AFTER write completes, as the error may be set during I/O
-            self.check_deferred_cert_error(vm)?;
-
-            Ok(data_len)
         }
 
         #[pymethod]
@@ -4013,6 +4052,10 @@ mod _ssl {
 
                 // Write close_notify to outgoing buffer/BIO
                 self.write_pending_tls(conn, vm)?;
+                // Ensure close_notify and any pending TLS data are flushed
+                if !is_bio {
+                    self.flush_pending_tls_output(vm, None)?;
+                }
 
                 // Update state
                 *self.shutdown_state.lock() = ShutdownState::SentCloseNotify;
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
index 3c72ccf4e21..322fdde5b9a 100644
--- a/crates/stdlib/src/ssl/compat.rs
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -36,8 +36,8 @@ use super::_ssl::PySSLSocket;
 
 // Import error types and helper functions from error module
 use super::error::{
-    PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,
-    create_ssl_want_write_error, create_ssl_zero_return_error,
+    PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_syscall_error,
+    create_ssl_want_read_error, create_ssl_want_write_error, create_ssl_zero_return_error,
 };
 
 // SSL Verification Flags
@@ -553,8 +553,8 @@ impl SslError {
             SslError::WantWrite => create_ssl_want_write_error(vm).upcast(),
             SslError::Timeout(msg) => timeout_error_msg(vm, msg).upcast(),
             SslError::Syscall(msg) => {
-                // Create SSLError with library=None for syscall errors during SSL operations
-                Self::create_ssl_error_with_reason(vm, None, &msg, msg.clone())
+                // SSLSyscallError with errno=SSL_ERROR_SYSCALL (5)
+                create_ssl_syscall_error(vm, msg).upcast()
             }
             SslError::Ssl(msg) => vm
                 .new_os_subtype_error(
@@ -1039,6 +1039,36 @@ fn send_all_bytes(
             return Err(SslError::Timeout("The operation timed out".to_string()));
         }
 
+        // Wait for socket to be writable before sending
+        let timed_out = if let Some(dl) = deadline {
+            let now = std::time::Instant::now();
+            if now >= dl {
+                socket
+                    .pending_tls_output
+                    .lock()
+                    .extend_from_slice(&buf[sent_total..]);
+                return Err(SslError::Timeout(
+                    "The write operation timed out".to_string(),
+                ));
+            }
+            socket
+                .sock_wait_for_io_with_timeout(SelectKind::Write, Some(dl - now), vm)
+                .map_err(SslError::Py)?
+        } else {
+            socket
+                .sock_wait_for_io_impl(SelectKind::Write, vm)
+                .map_err(SslError::Py)?
+        };
+        if timed_out {
+            socket
+                .pending_tls_output
+                .lock()
+                .extend_from_slice(&buf[sent_total..]);
+            return Err(SslError::Timeout(
+                "The write operation timed out".to_string(),
+            ));
+        }
+
         match socket.sock_send(&buf[sent_total..], vm) {
             Ok(result) => {
                 let sent: usize = result
@@ -1443,9 +1473,17 @@ pub(super) fn ssl_do_handshake(
         }
     }
 
-    // If we exit the loop without completing handshake, return error
-    // Check rustls state to provide better error message
+    // If we exit the loop without completing handshake, return appropriate error
     if conn.is_handshaking() {
+        // For non-blocking sockets, return WantRead/WantWrite to signal caller
+        // should retry when socket is ready. This matches OpenSSL behavior.
+        if conn.wants_write() {
+            return Err(SslError::WantWrite);
+        }
+        if conn.wants_read() {
+            return Err(SslError::WantRead);
+        }
+        // Neither wants_read nor wants_write - this is a real error
         Err(SslError::Syscall(format!(
             "SSL handshake failed: incomplete after {iteration_count} iterations",
         )))
@@ -1581,6 +1619,14 @@ pub(super) fn ssl_read(
                 if let Some(t) = timeout
                     && t.is_zero()
                 {
+                    // Non-blocking socket: check if peer has closed before returning WantRead
+                    // If close_notify was received, we should return ZeroReturn (EOF), not WantRead
+                    // This is critical for asyncore-based applications that rely on recv() returning
+                    // 0 or raising SSL_ERROR_ZERO_RETURN to detect connection close.
+                    let io_state = conn.process_new_packets().map_err(SslError::from_rustls)?;
+                    if io_state.peer_has_closed() {
+                        return Err(SslError::ZeroReturn);
+                    }
                     // Non-blocking socket: return immediately
                     return Err(SslError::WantRead);
                 }
@@ -1605,7 +1651,13 @@ pub(super) fn ssl_read(
                     .unwrap_or(0);
 
                 if bytes_read == 0 {
-                    // No more data available - connection might be closed
+                    // No more data available - check if this is clean shutdown or unexpected EOF
+                    // If close_notify was already received, return ZeroReturn (clean closure)
+                    // Otherwise, return Eof (unexpected EOF)
+                    let io_state = conn.process_new_packets().map_err(SslError::from_rustls)?;
+                    if io_state.peer_has_closed() {
+                        return Err(SslError::ZeroReturn);
+                    }
                     return Err(SslError::Eof);
                 }
 
@@ -1648,6 +1700,138 @@ pub(super) fn ssl_read(
     }
 }
 
+/// Equivalent to OpenSSL's SSL_write()
+///
+/// Writes application data to TLS connection.
+/// Automatically handles TLS record I/O as needed.
+///
+/// = SSL_write_ex()
+pub(super) fn ssl_write(
+    conn: &mut TlsConnection,
+    data: &[u8],
+    socket: &PySSLSocket,
+    vm: &VirtualMachine,
+) -> SslResult<usize> {
+    if data.is_empty() {
+        return Ok(0);
+    }
+
+    let is_bio = socket.is_bio_mode();
+
+    // Get socket timeout and calculate deadline (= _PyDeadline_Init)
+    let deadline = if !is_bio {
+        match socket.get_socket_timeout(vm).map_err(SslError::Py)? {
+            Some(timeout) if !timeout.is_zero() => Some(std::time::Instant::now() + timeout),
+            _ => None,
+        }
+    } else {
+        None
+    };
+
+    // Flush any pending TLS output before writing new data
+    if !is_bio {
+        socket
+            .flush_pending_tls_output(vm, deadline)
+            .map_err(SslError::Py)?;
+    }
+
+    // Check if we already have data buffered from a previous retry
+    // (prevents duplicate writes when retrying after WantWrite/WantRead)
+    let already_buffered = *socket.write_buffered_len.lock();
+
+    // Only write plaintext if not already buffered
+    if already_buffered == 0 {
+        // Write plaintext to rustls (= SSL_write_ex internal buffer write)
+        {
+            let mut writer = conn.writer();
+            use std::io::Write;
+            writer
+                .write_all(data)
+                .map_err(|e| SslError::Syscall(format!("Write failed: {e}")))?;
+        }
+        // Mark data as buffered
+        *socket.write_buffered_len.lock() = data.len();
+    } else if already_buffered != data.len() {
+        // Caller is retrying with different data - this is a protocol error
+        // Clear the buffer state and return an SSL error (bad write retry)
+        *socket.write_buffered_len.lock() = 0;
+        return Err(SslError::Ssl("bad write retry".to_string()));
+    }
+    // else: already_buffered == data.len(), this is a valid retry
+
+    // Loop to send TLS records, handling WANT_READ/WANT_WRITE
+    // Matches CPython's do-while loop on SSL_ERROR_WANT_READ/WANT_WRITE
+    loop {
+        // Check deadline
+        if let Some(dl) = deadline
+            && std::time::Instant::now() >= dl
+        {
+            return Err(SslError::Timeout(
+                "The write operation timed out".to_string(),
+            ));
+        }
+
+        // Check if rustls has TLS data to send
+        if !conn.wants_write() {
+            // All TLS data sent successfully
+            break;
+        }
+
+        // Get TLS records from rustls
+        let tls_data = ssl_write_tls_records(conn)?;
+        if tls_data.is_empty() {
+            break;
+        }
+
+        // Send TLS data to socket
+        match send_all_bytes(socket, tls_data, vm, deadline) {
+            Ok(()) => {
+                // Successfully sent, continue loop to check for more data
+            }
+            Err(SslError::WantWrite) => {
+                // Non-blocking socket would block - return WANT_WRITE
+                // Keep write_buffered_len set so we don't re-buffer on retry
+                return Err(SslError::WantWrite);
+            }
+            Err(SslError::WantRead) => {
+                // Need to read before write can complete (e.g., renegotiation)
+                // This matches CPython's handling of SSL_ERROR_WANT_READ in write
+                if is_bio {
+                    // Keep write_buffered_len set so we don't re-buffer on retry
+                    return Err(SslError::WantRead);
+                }
+                // For socket mode, try to read TLS data
+                let recv_result = socket.sock_recv(4096, vm).map_err(SslError::Py)?;
+                ssl_read_tls_records(conn, recv_result, false, vm)?;
+                conn.process_new_packets().map_err(SslError::from_rustls)?;
+                // Continue loop
+            }
+            Err(e @ SslError::Timeout(_)) => {
+                // Preserve buffered state so retry doesn't duplicate data
+                // (send_all_bytes saved unsent TLS bytes to pending_tls_output)
+                return Err(e);
+            }
+            Err(e) => {
+                // Clear buffer state on error
+                *socket.write_buffered_len.lock() = 0;
+                return Err(e);
+            }
+        }
+    }
+
+    // Final flush to ensure all data is sent
+    if !is_bio {
+        socket
+            .flush_pending_tls_output(vm, deadline)
+            .map_err(SslError::Py)?;
+    }
+
+    // Write completed successfully - clear buffer state
+    *socket.write_buffered_len.lock() = 0;
+
+    Ok(data.len())
+}
+
 // Helper functions (private-ish, used by public SSL functions)
 
 /// Write TLS records from rustls to socket
@@ -1684,26 +1868,24 @@ fn ssl_read_tls_records(
             // 1. Clean shutdown: received TLS close_notify → return ZeroReturn (0 bytes)
             // 2. Unexpected EOF: no close_notify → return Eof (SSLEOFError)
             //
-            // SSL_ERROR_ZERO_RETURN vs SSL_ERROR_SYSCALL(errno=0) logic
+            // SSL_ERROR_ZERO_RETURN vs SSL_ERROR_EOF logic
             // CPython checks SSL_get_shutdown() & SSL_RECEIVED_SHUTDOWN
             //
             // Process any buffered TLS records (may contain close_notify)
-            let _ = conn.process_new_packets();
-
-            // IMPORTANT: CPython's default behavior (suppress_ragged_eofs=True)
-            // treats empty recv() as clean shutdown, returning 0 bytes instead of raising SSLEOFError.
-            //
-            // This is necessary for HTTP/1.0 servers that:
-            // 1. Send response without Content-Length header
-            // 2. Signal end-of-response by closing connection (TCP FIN)
-            // 3. Don't send TLS close_notify before TCP close
-            //
-            // While this could theoretically allow truncation attacks,
-            // it's the standard behavior for compatibility with real-world servers.
-            // Python only raises SSLEOFError when suppress_ragged_eofs=False is explicitly set.
-            //
-            // TODO: Implement suppress_ragged_eofs parameter if needed for strict security mode.
-            return Err(SslError::ZeroReturn);
+            match conn.process_new_packets() {
+                Ok(io_state) => {
+                    if io_state.peer_has_closed() {
+                        // Received close_notify - normal SSL closure (SSL_ERROR_ZERO_RETURN)
+                        return Err(SslError::ZeroReturn);
+                    } else {
+                        // No close_notify - ragged EOF (SSL_ERROR_EOF → SSLEOFError)
+                        // CPython raises SSLEOFError here, which SSLSocket.read() handles
+                        // based on suppress_ragged_eofs setting
+                        return Err(SslError::Eof);
+                    }
+                }
+                Err(e) => return Err(SslError::from_rustls(e)),
+            }
         }
     }
 
@@ -1816,6 +1998,9 @@ fn ssl_ensure_data_available(
         let data = match socket.sock_recv(2048, vm) {
             Ok(data) => data,
             Err(e) => {
+                if is_blocking_io_error(&e, vm) {
+                    return Err(SslError::WantRead);
+                }
                 // Before returning socket error, check if rustls already has a queued TLS alert
                 // This mirrors CPython/OpenSSL behavior: SSL errors take precedence over socket errors
                 // On Windows, TCP RST may arrive before we read the alert, but rustls may have
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
index 6219eff41b5..cbc59e0e8f6 100644
--- a/crates/stdlib/src/ssl/error.rs
+++ b/crates/stdlib/src/ssl/error.rs
@@ -132,4 +132,15 @@ pub(crate) mod ssl_error {
             "TLS/SSL connection has been closed (EOF)",
         )
     }
+
+    pub fn create_ssl_syscall_error(
+        vm: &VirtualMachine,
+        msg: impl Into<String>,
+    ) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLSyscallError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_SYSCALL),
+            msg.into(),
+        )
+    }
 }
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
index 9f0c0535d71..f7e47b15deb 100644
--- a/crates/vm/src/stdlib/thread.rs
+++ b/crates/vm/src/stdlib/thread.rs
@@ -421,14 +421,14 @@ pub(crate) mod _thread {
                 vm.new_thread()
                     .make_spawn_func(move |vm| run_thread(func, args, vm)),
             )
-            .map(|handle| {
-                vm.state.thread_count.fetch_add(1);
-                thread_to_id(&handle)
-            })
+            .map(|handle| thread_to_id(&handle))
             .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))
     }
 
     fn run_thread(func: ArgCallable, args: FuncArgs, vm: &VirtualMachine) {
+        // Increment thread count when thread actually starts executing
+        vm.state.thread_count.fetch_add(1);
+
         match func.invoke(args, vm) {
             Ok(_obj) => {}
             Err(e) if e.fast_isinstance(vm.ctx.exceptions.system_exit) => {}
@@ -1168,13 +1168,6 @@ pub(crate) mod _thread {
                     // Mark as done
                     inner_for_cleanup.lock().state = ThreadHandleState::Done;
 
-                    // Signal waiting threads that this thread is done
-                    {
-                        let (lock, cvar) = &*done_event_for_cleanup;
-                        *lock.lock() = true;
-                        cvar.notify_all();
-                    }
-
                     // Handle sentinels
                     for lock in SENTINELS.take() {
                         if lock.mu.is_locked() {
@@ -1189,8 +1182,19 @@ pub(crate) mod _thread {
                     crate::vm::thread::cleanup_current_thread_frames(vm);
 
                     vm_state.thread_count.fetch_sub(1);
+
+                    // Signal waiting threads that this thread is done
+                    // This must be LAST to ensure all cleanup is complete before join() returns
+                    {
+                        let (lock, cvar) = &*done_event_for_cleanup;
+                        *lock.lock() = true;
+                        cvar.notify_all();
+                    }
                 }
 
+                // Increment thread count when thread actually starts executing
+                vm_state.thread_count.fetch_add(1);
+
                 // Run the function
                 match func.invoke((), vm) {
                     Ok(_) => {}
@@ -1206,8 +1210,6 @@ pub(crate) mod _thread {
             }))
             .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))?;
 
-        vm.state.thread_count.fetch_add(1);
-
         // Store the join handle
         handle.inner.lock().join_handle = Some(join_handle);
 

From d3d63ea2d3e7f3dbe568437e941959c562c92001 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 21:33:37 +0900
Subject: [PATCH 366/418] enable test_bytes (#6777)

---
 Lib/test/test_bytes.py | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index a1a711da70b..fcef9c0c972 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -1288,11 +1288,20 @@ class SubBytes(bytes):
         self.assertNotEqual(id(s), id(1 * s))
         self.assertNotEqual(id(s), id(s * 2))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_fromhex(self):
+        return super().test_fromhex()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_mod(self):
+        return super().test_mod()
+
 
 class ByteArrayTest(BaseBytesTest, unittest.TestCase):
     type2test = bytearray
 
-    _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
+    # XXX: RUSTPYTHON; import_helper.import_module here cause the entire test stopping
+    _testlimitedcapi = None  # import_helper.import_module('_testlimitedcapi')
 
     def test_getitem_error(self):
         b = bytearray(b'python')
@@ -1385,6 +1394,7 @@ def by(s):
         b = by("Hello, world")
         self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_setitem(self):
         def setitem_as_mapping(b, i, val):
             b[i] = val
@@ -1432,6 +1442,7 @@ def do_tests(setitem):
         with self.subTest("tp_as_sequence"):
             do_tests(setitem_as_sequence)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_delitem(self):
         def del_as_mapping(b, i):
             del b[i]
@@ -1618,6 +1629,7 @@ def g():
         alloc = b.__alloc__()
         self.assertGreaterEqual(alloc, len(b))  # NOTE: RUSTPYTHON patched
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_extend(self):
         orig = b'hello'
         a = bytearray(orig)
@@ -1840,6 +1852,7 @@ def test_repeat_after_setslice(self):
         self.assertEqual(b1, b)
         self.assertEqual(b3, b'xcxcxc')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mutating_index(self):
         # bytearray slice assignment can call into python code
         # that reallocates the internal buffer
@@ -1860,6 +1873,7 @@ def __index__(self):
             with self.assertRaises(IndexError):
                 self._testlimitedcapi.sequence_setitem(b, 0, Boom())
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mutating_index_inbounds(self):
         # gh-91153 continued
         # Ensure buffer is not broken even if length is correct
@@ -1893,6 +1907,14 @@ def __index__(self):
             self.assertEqual(instance.ba[0], ord("?"), "Assigned bytearray not altered")
             self.assertEqual(instance.new_ba, bytearray(0x180), "Wrong object altered")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_fromhex(self):
+        return super().test_fromhex()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_mod(self):
+        return super().test_mod()
+
 
 class AssortedBytesTest(unittest.TestCase):
     #
@@ -1912,6 +1934,7 @@ def test_bytes_repr(self, f=repr):
         self.assertEqual(f(b"'\"'"), r"""b'\'"\''""") # '\'"\''
         self.assertEqual(f(BytesSubclass(b"abc")), "b'abc'")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bytearray_repr(self, f=repr):
         self.assertEqual(f(bytearray()), "bytearray(b'')")
         self.assertEqual(f(bytearray(b'abc')), "bytearray(b'abc')")
@@ -1933,6 +1956,7 @@ def test_bytearray_repr(self, f=repr):
     def test_bytes_str(self):
         self.test_bytes_repr(str)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @check_bytes_warnings
     def test_bytearray_str(self):
         self.test_bytearray_repr(str)
@@ -2233,6 +2257,14 @@ class ByteArraySubclassWithSlotsTest(SubclassTest, unittest.TestCase):
     basetype = bytearray
     type2test = ByteArraySubclassWithSlots
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_copy(self):
+        return super().test_copy()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pickle(self):
+        return super().test_pickle()
+
 class BytesSubclassTest(SubclassTest, unittest.TestCase):
     basetype = bytes
     type2test = BytesSubclass

From 4b5e73577a1d1fa543cd824bffa99a9df6cb900e Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Sun, 18 Jan 2026 21:51:39 +0900
Subject: [PATCH 367/418] Add metadata when uploading benchmark data (#6759)

Generate a metadata file alongside criterion benchmark data containing
the commit hash, ref name, and timestamp for tracking purposes.

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
---
 .github/workflows/cron-ci.yaml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index c942364064c..46b45249445 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -180,7 +180,11 @@ jobs:
           cd website
           rm -rf ./assets/criterion
           cp -r ../target/criterion ./assets/criterion
-          git add ./assets/criterion
+          printf '{\n  "generated_at": "%s",\n  "rustpython_commit": "%s",\n  "rustpython_ref": "%s"\n}\n' \
+            "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+            "${{ github.sha }}" \
+            "${{ github.ref_name }}" > ./_data/criterion-metadata.json
+          git add ./assets/criterion ./_data/criterion-metadata.json
           if git -c user.name="Github Actions" -c user.email="actions@github.com" commit -m "Update benchmark results"; then
             git push
           fi

From 252fa816d66f5984b1a724f9860230eff0deb2ab Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 21:54:44 +0900
Subject: [PATCH 368/418] sys._jit (#6779)

---
 Lib/test/support/__init__.py |  4 +---
 crates/vm/src/stdlib/sys.rs  | 29 +++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index e221ee04630..cc5a48738fd 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -2783,9 +2783,7 @@ def exceeds_recursion_limit():
 
 Py_TRACE_REFS = hasattr(sys, 'getobjects')
 
-# XXX: RUSTPYTHON; we don't have sys._jit yet
-# _JIT_ENABLED = sys._jit.is_enabled()
-_JIT_ENABLED = False
+_JIT_ENABLED = sys._jit.is_enabled()
 requires_jit_enabled = unittest.skipUnless(_JIT_ENABLED, "requires JIT enabled")
 requires_jit_disabled = unittest.skipIf(_JIT_ENABLED, "requires JIT disabled")
 
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 4917e3e43c6..5446b04c6d5 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -4,6 +4,30 @@ pub(crate) use sys::{
     __module_def, DOC, MAXSIZE, RUST_MULTIARCH, UnraisableHookArgsData, multiarch,
 };
 
+#[pymodule(name = "_jit")]
+mod sys_jit {
+    /// Return True if the current Python executable supports JIT compilation,
+    /// and False otherwise.
+    #[pyfunction]
+    const fn is_available() -> bool {
+        false // RustPython has no JIT
+    }
+
+    /// Return True if JIT compilation is enabled for the current Python process,
+    /// and False otherwise.
+    #[pyfunction]
+    const fn is_enabled() -> bool {
+        false // RustPython has no JIT
+    }
+
+    /// Return True if the topmost Python frame is currently executing JIT code,
+    /// and False otherwise.
+    #[pyfunction]
+    const fn is_active() -> bool {
+        false // RustPython has no JIT
+    }
+}
+
 #[pymodule]
 mod sys {
     use crate::{
@@ -1554,9 +1578,14 @@ pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins:
     modules
         .set_item("builtins", builtins.to_owned().into(), vm)
         .unwrap();
+
+    // Create sys._jit submodule
+    let jit_module = sys_jit::make_module(vm);
+
     extend_module!(vm, module, {
         "__doc__" => sys::DOC.to_owned().to_pyobject(vm),
         "modules" => modules,
+        "_jit" => jit_module,
     });
 }
 

From 2b8fac3af3c27605ca26e363389afc48483123ed Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 22:06:07 +0900
Subject: [PATCH 369/418]  auto mark parent tests (#6778)

* don't skip auto-format

* auto mark parent
---
 .github/workflows/pr-auto-commit.yaml |  1 -
 scripts/auto_mark_test.py             | 76 ++++++++++++++++++++++++++-
 scripts/lib_updater.py                |  7 ++-
 3 files changed, 79 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
index d4d97b19d18..0d85dc78926 100644
--- a/.github/workflows/pr-auto-commit.yaml
+++ b/.github/workflows/pr-auto-commit.yaml
@@ -14,7 +14,6 @@ concurrency:
 
 jobs:
   auto_format:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     permissions:
       contents: write
       pull-requests: write
diff --git a/scripts/auto_mark_test.py b/scripts/auto_mark_test.py
index 2e3aef52599..59c7d8a05b0 100644
--- a/scripts/auto_mark_test.py
+++ b/scripts/auto_mark_test.py
@@ -83,7 +83,7 @@ def parse_results(result):
     test_results.stdout = result.stdout
     in_test_results = False
     for line in lines:
-        if re.match(r"Run tests? sequentially", line):
+        if re.search(r"Run \d+ tests? sequentially", line):
             in_test_results = True
         elif line.startswith("-----------"):
             in_test_results = False
@@ -161,6 +161,66 @@ def is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> boo
     return True
 
 
+def build_inheritance_info(tree: ast.Module) -> tuple[dict, dict]:
+    """
+    Build inheritance information from AST.
+
+    Returns:
+        class_bases: dict[str, list[str]] - parent classes for each class (only those defined in the file)
+        class_methods: dict[str, set[str]] - methods directly defined in each class
+    """
+    all_classes = {
+        node.name for node in ast.walk(tree) if isinstance(node, ast.ClassDef)
+    }
+    class_bases = {}
+    class_methods = {}
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            # Collect only parent classes defined in this file
+            bases = [
+                base.id
+                for base in node.bases
+                if isinstance(base, ast.Name) and base.id in all_classes
+            ]
+            class_bases[node.name] = bases
+
+            # Collect directly defined methods
+            methods = {
+                item.name
+                for item in node.body
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+            }
+            class_methods[node.name] = methods
+
+    return class_bases, class_methods
+
+
+def find_method_definition(
+    class_name: str, method_name: str, class_bases: dict, class_methods: dict
+) -> str | None:
+    """Find the class where a method is actually defined. Traverses inheritance chain (BFS)."""
+    # Check current class first
+    if method_name in class_methods.get(class_name, set()):
+        return class_name
+
+    # Search parent classes
+    visited = set()
+    queue = list(class_bases.get(class_name, []))
+
+    while queue:
+        current = queue.pop(0)
+        if current in visited:
+            continue
+        visited.add(current)
+
+        if method_name in class_methods.get(current, set()):
+            return current
+        queue.extend(class_bases.get(current, []))
+
+    return None
+
+
 def remove_expected_failures(
     contents: str, tests_to_remove: set[tuple[str, str]]
 ) -> str:
@@ -172,6 +232,18 @@ def remove_expected_failures(
     lines = contents.splitlines()
     lines_to_remove = set()
 
+    # Build inheritance information
+    class_bases, class_methods = build_inheritance_info(tree)
+
+    # Resolve to actual defining classes
+    resolved_tests = set()
+    for class_name, method_name in tests_to_remove:
+        defining_class = find_method_definition(
+            class_name, method_name, class_bases, class_methods
+        )
+        if defining_class:
+            resolved_tests.add((defining_class, method_name))
+
     for node in ast.walk(tree):
         if not isinstance(node, ast.ClassDef):
             continue
@@ -180,7 +252,7 @@ def remove_expected_failures(
             if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 continue
             method_name = item.name
-            if (class_name, method_name) not in tests_to_remove:
+            if (class_name, method_name) not in resolved_tests:
                 continue
 
             # Check if we should remove the entire method (super() call only)
diff --git a/scripts/lib_updater.py b/scripts/lib_updater.py
index 6176bd54431..712ea7bc838 100755
--- a/scripts/lib_updater.py
+++ b/scripts/lib_updater.py
@@ -236,11 +236,14 @@ def build_patch_dict(it: "Iterator[PatchEntry]") -> Patches:
 
 
 def iter_patch_lines(tree: ast.Module, patches: Patches) -> "Iterator[tuple[int, str]]":
-    cache = {}  # Used in phase 2. Stores the end line location of a class name.
+    # Build cache of all classes (for Phase 2 to find classes without methods)
+    cache = {}
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef):
+            cache[node.name] = node.end_lineno
 
     # Phase 1: Iterate and mark existing tests
     for cls_node, fn_node in iter_tests(tree):
-        cache[cls_node.name] = cls_node.end_lineno
         specs = patches.get(cls_node.name, {}).pop(fn_node.name, None)
         if not specs:
             continue

From 9301ae274640af4530377d730b0640aac0d3eff5 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 23:23:11 +0900
Subject: [PATCH 370/418] traverse and clear (#6780)

---
 crates/derive-impl/src/pyclass.rs       | 117 +++++++++++++++---------
 crates/derive-impl/src/pystructseq.rs   |   7 ++
 crates/derive-impl/src/util.rs          |   1 +
 crates/vm/src/builtins/dict.rs          |  18 +++-
 crates/vm/src/builtins/function.rs      |  64 +++++++++++++
 crates/vm/src/builtins/list.rs          |  19 +++-
 crates/vm/src/builtins/str.rs           |   7 ++
 crates/vm/src/builtins/tuple.rs         |  16 +++-
 crates/vm/src/dict_inner.rs             |  11 +++
 crates/vm/src/frame.rs                  |  24 ++++-
 crates/vm/src/object/core.rs            |   2 +-
 crates/vm/src/object/traverse.rs        |  11 ++-
 crates/vm/src/object/traverse_object.rs |   6 +-
 13 files changed, 250 insertions(+), 53 deletions(-)

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
index 57cbf67de5a..e54c1a867fd 100644
--- a/crates/derive-impl/src/pyclass.rs
+++ b/crates/derive-impl/src/pyclass.rs
@@ -574,51 +574,80 @@ pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<Tok
     )?;
 
     const ALLOWED_TRAVERSE_OPTS: &[&str] = &["manual"];
-    // try to know if it have a `#[pyclass(trace)]` exist on this struct
-    // TODO(discord9): rethink on auto detect `#[Derive(PyTrace)]`
-
-    // 1. no `traverse` at all: generate a dummy try_traverse
-    // 2. `traverse = "manual"`: generate a try_traverse, but not #[derive(Traverse)]
-    // 3. `traverse`: generate a try_traverse, and #[derive(Traverse)]
-    let (maybe_trace_code, derive_trace) = {
-        if class_meta.inner()._has_key("traverse")? {
-            let maybe_trace_code = quote! {
-                impl ::rustpython_vm::object::MaybeTraverse for #ident {
-                    const IS_TRACE: bool = true;
-                    fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
-                        ::rustpython_vm::object::Traverse::traverse(self, tracer_fn);
-                    }
+    // Generate MaybeTraverse impl with both traverse and clear support
+    //
+    // For traverse:
+    // 1. no `traverse` at all: HAS_TRAVERSE = false, try_traverse does nothing
+    // 2. `traverse = "manual"`: HAS_TRAVERSE = true, but no #[derive(Traverse)]
+    // 3. `traverse`: HAS_TRAVERSE = true, and #[derive(Traverse)]
+    //
+    // For clear (tp_clear):
+    // 1. no `clear`: HAS_CLEAR = HAS_TRAVERSE (default: same as traverse)
+    // 2. `clear` or `clear = true`: HAS_CLEAR = true, try_clear calls Traverse::clear
+    // 3. `clear = false`: HAS_CLEAR = false (rare: traverse without clear)
+    let has_traverse = class_meta.inner()._has_key("traverse")?;
+    let has_clear = if class_meta.inner()._has_key("clear")? {
+        // If clear attribute is present, use its value
+        class_meta.inner()._bool("clear")?
+    } else {
+        // If clear attribute is absent, default to same as traverse
+        has_traverse
+    };
+
+    let derive_trace = if has_traverse {
+        // _optional_str returns Err when key exists without value (e.g., `traverse` vs `traverse = "manual"`)
+        // We want to derive Traverse in that case, so we handle Err as Ok(None)
+        let value = class_meta.inner()._optional_str("traverse").ok().flatten();
+        if let Some(s) = value {
+            if !ALLOWED_TRAVERSE_OPTS.contains(&s.as_str()) {
+                bail_span!(
+                    item,
+                    "traverse attribute only accept {ALLOWED_TRAVERSE_OPTS:?} as value or no value at all",
+                );
+            }
+            assert_eq!(s, "manual");
+            quote! {}
+        } else {
+            quote! {#[derive(Traverse)]}
+        }
+    } else {
+        quote! {}
+    };
+
+    let maybe_traverse_code = {
+        let try_traverse_body = if has_traverse {
+            quote! {
+                ::rustpython_vm::object::Traverse::traverse(self, tracer_fn);
+            }
+        } else {
+            quote! {
+                // do nothing
+            }
+        };
+
+        let try_clear_body = if has_clear {
+            quote! {
+                ::rustpython_vm::object::Traverse::clear(self, out);
+            }
+        } else {
+            quote! {
+                // do nothing
+            }
+        };
+
+        quote! {
+            impl ::rustpython_vm::object::MaybeTraverse for #ident {
+                const HAS_TRAVERSE: bool = #has_traverse;
+                const HAS_CLEAR: bool = #has_clear;
+
+                fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
+                    #try_traverse_body
                 }
-            };
-            // if the key `traverse` exist but not as key-value, _optional_str return Err(...)
-            // so we need to check if it is Ok(Some(...))
-            let value = class_meta.inner()._optional_str("traverse");
-            let derive_trace = if let Ok(Some(s)) = value {
-                if !ALLOWED_TRAVERSE_OPTS.contains(&s.as_str()) {
-                    bail_span!(
-                        item,
-                        "traverse attribute only accept {ALLOWED_TRAVERSE_OPTS:?} as value or no value at all",
-                    );
+
+                fn try_clear(&mut self, out: &mut ::std::vec::Vec<::rustpython_vm::PyObjectRef>) {
+                    #try_clear_body
                 }
-                assert_eq!(s, "manual");
-                quote! {}
-            } else {
-                quote! {#[derive(Traverse)]}
-            };
-            (maybe_trace_code, derive_trace)
-        } else {
-            (
-                // a dummy impl, which do nothing
-                // #attrs
-                quote! {
-                    impl ::rustpython_vm::object::MaybeTraverse for #ident {
-                        fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
-                            // do nothing
-                        }
-                    }
-                },
-                quote! {},
-            )
+            }
         }
     };
 
@@ -675,7 +704,7 @@ pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<Tok
     let ret = quote! {
         #derive_trace
         #item
-        #maybe_trace_code
+        #maybe_traverse_code
         #class_def
         #impl_payload
         #empty_impl
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
index 0ee0c2c2e3c..75617d300be 100644
--- a/crates/derive-impl/src/pystructseq.rs
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -606,9 +606,16 @@ pub(crate) fn impl_pystruct_sequence(
 
         // MaybeTraverse - delegate to inner PyTuple
         impl ::rustpython_vm::object::MaybeTraverse for #pytype_ident {
+            const HAS_TRAVERSE: bool = true;
+            const HAS_CLEAR: bool = true;
+
             fn try_traverse(&self, traverse_fn: &mut ::rustpython_vm::object::TraverseFn<'_>) {
                 self.0.try_traverse(traverse_fn)
             }
+
+            fn try_clear(&mut self, out: &mut ::std::vec::Vec<::rustpython_vm::PyObjectRef>) {
+                self.0.try_clear(out)
+            }
         }
 
         // PySubclass for proper inheritance
diff --git a/crates/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
index 6be1fcdf7ad..b09ad9c93fe 100644
--- a/crates/derive-impl/src/util.rs
+++ b/crates/derive-impl/src/util.rs
@@ -372,6 +372,7 @@ impl ItemMeta for ClassItemMeta {
         "ctx",
         "impl",
         "traverse",
+        "clear", // tp_clear
     ];
 
     fn from_inner(inner: ItemMetaInner) -> Self {
diff --git a/crates/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
index d1adb8a066d..fcb51c2ca0e 100644
--- a/crates/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -2,6 +2,7 @@ use super::{
     IterStatus, PositionIterInternal, PyBaseExceptionRef, PyGenericAlias, PyMappingProxy, PySet,
     PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef, set::PySetInner,
 };
+use crate::object::{Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
     TryFromObject, atomic_func,
@@ -29,13 +30,28 @@ use std::sync::LazyLock;
 
 pub type DictContentType = dict_inner::Dict;
 
-#[pyclass(module = false, name = "dict", unhashable = true, traverse)]
+#[pyclass(module = false, name = "dict", unhashable = true, traverse = "manual")]
 #[derive(Default)]
 pub struct PyDict {
     entries: DictContentType,
 }
 pub type PyDictRef = PyRef<PyDict>;
 
+// SAFETY: Traverse properly visits all owned PyObjectRefs
+unsafe impl Traverse for PyDict {
+    fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+        self.entries.traverse(traverse_fn);
+    }
+
+    fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
+        // Pop all entries and collect both keys and values
+        for (key, value) in self.entries.drain_entries() {
+            out.push(key);
+            out.push(value);
+        }
+    }
+}
+
 impl fmt::Debug for PyDict {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // TODO: implement more detailed, non-recursive Debug formatter
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 9297cf07201..632fd867d2e 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -51,6 +51,70 @@ unsafe impl Traverse for PyFunction {
             closure.as_untyped().traverse(tracer_fn);
         }
         self.defaults_and_kwdefaults.traverse(tracer_fn);
+        // Traverse additional fields that may contain references
+        self.type_params.lock().traverse(tracer_fn);
+        self.annotations.lock().traverse(tracer_fn);
+        self.module.lock().traverse(tracer_fn);
+        self.doc.lock().traverse(tracer_fn);
+    }
+
+    fn clear(&mut self, out: &mut Vec<crate::PyObjectRef>) {
+        // Pop closure if present (equivalent to Py_CLEAR(func_closure))
+        if let Some(closure) = self.closure.take() {
+            out.push(closure.into());
+        }
+
+        // Pop defaults and kwdefaults
+        if let Some(mut guard) = self.defaults_and_kwdefaults.try_lock() {
+            if let Some(defaults) = guard.0.take() {
+                out.push(defaults.into());
+            }
+            if let Some(kwdefaults) = guard.1.take() {
+                out.push(kwdefaults.into());
+            }
+        }
+
+        // Clear annotations and annotate (Py_CLEAR)
+        if let Some(mut guard) = self.annotations.try_lock()
+            && let Some(annotations) = guard.take()
+        {
+            out.push(annotations.into());
+        }
+        if let Some(mut guard) = self.annotate.try_lock()
+            && let Some(annotate) = guard.take()
+        {
+            out.push(annotate);
+        }
+
+        // Clear module, doc, and type_params (Py_CLEAR)
+        if let Some(mut guard) = self.module.try_lock() {
+            let old_module =
+                std::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
+            out.push(old_module);
+        }
+        if let Some(mut guard) = self.doc.try_lock() {
+            let old_doc = std::mem::replace(&mut *guard, Context::genesis().none.to_owned().into());
+            out.push(old_doc);
+        }
+        if let Some(mut guard) = self.type_params.try_lock() {
+            let old_type_params =
+                std::mem::replace(&mut *guard, Context::genesis().empty_tuple.to_owned());
+            out.push(old_type_params.into());
+        }
+
+        // Replace name and qualname with empty string to break potential str subclass cycles
+        // name and qualname could be str subclasses, so they could have reference cycles
+        if let Some(mut guard) = self.name.try_lock() {
+            let old_name = std::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
+            out.push(old_name.into());
+        }
+        if let Some(mut guard) = self.qualname.try_lock() {
+            let old_qualname =
+                std::mem::replace(&mut *guard, Context::genesis().empty_str.to_owned());
+            out.push(old_qualname.into());
+        }
+
+        // Note: globals, builtins, code are NOT cleared (required to be non-NULL)
     }
 }
 
diff --git a/crates/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
index 02475ee12b6..84825de7d3d 100644
--- a/crates/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -3,6 +3,7 @@ use crate::atomic_func;
 use crate::common::lock::{
     PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
+use crate::object::{Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
     class::PyClassImpl,
@@ -23,7 +24,7 @@ use crate::{
 use alloc::fmt;
 use core::ops::DerefMut;
 
-#[pyclass(module = false, name = "list", unhashable = true, traverse)]
+#[pyclass(module = false, name = "list", unhashable = true, traverse = "manual")]
 #[derive(Default)]
 pub struct PyList {
     elements: PyRwLock<Vec<PyObjectRef>>,
@@ -50,6 +51,22 @@ impl FromIterator<PyObjectRef> for PyList {
     }
 }
 
+// SAFETY: Traverse properly visits all owned PyObjectRefs
+unsafe impl Traverse for PyList {
+    fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+        self.elements.traverse(traverse_fn);
+    }
+
+    fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
+        // During GC, we use interior mutability to access elements.
+        // This is safe because during GC collection, the object is unreachable
+        // and no other code should be accessing it.
+        if let Some(mut guard) = self.elements.try_write() {
+            out.extend(guard.drain(..));
+        }
+    }
+}
+
 impl PyPayload for PyList {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
index 640778c8cb9..d765847c1ab 100644
--- a/crates/vm/src/builtins/str.rs
+++ b/crates/vm/src/builtins/str.rs
@@ -1924,9 +1924,16 @@ impl fmt::Display for PyUtf8Str {
 }
 
 impl MaybeTraverse for PyUtf8Str {
+    const HAS_TRAVERSE: bool = true;
+    const HAS_CLEAR: bool = false;
+
     fn try_traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
         self.0.try_traverse(traverse_fn);
     }
+
+    fn try_clear(&mut self, _out: &mut Vec<PyObjectRef>) {
+        // No clear needed for PyUtf8Str
+    }
 }
 
 impl PyPayload for PyUtf8Str {
diff --git a/crates/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
index f6eff5b91e5..ba296686c73 100644
--- a/crates/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -3,6 +3,7 @@ use crate::common::{
     hash::{PyHash, PyUHash},
     lock::PyMutex,
 };
+use crate::object::{Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     atomic_func,
@@ -24,7 +25,7 @@ use crate::{
 use alloc::fmt;
 use std::sync::LazyLock;
 
-#[pyclass(module = false, name = "tuple", traverse)]
+#[pyclass(module = false, name = "tuple", traverse = "manual")]
 pub struct PyTuple<R = PyObjectRef> {
     elements: Box<[R]>,
 }
@@ -36,6 +37,19 @@ impl<R> fmt::Debug for PyTuple<R> {
     }
 }
 
+// SAFETY: Traverse properly visits all owned PyObjectRefs
+// Note: Only impl for PyTuple<PyObjectRef> (the default)
+unsafe impl Traverse for PyTuple {
+    fn traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+        self.elements.traverse(traverse_fn);
+    }
+
+    fn clear(&mut self, out: &mut Vec<PyObjectRef>) {
+        let elements = std::mem::take(&mut self.elements);
+        out.extend(elements.into_vec());
+    }
+}
+
 impl PyPayload for PyTuple {
     #[inline]
     fn class(ctx: &Context) -> &'static Py<PyType> {
diff --git a/crates/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
index 1d9fe8403ab..f2a379d99a5 100644
--- a/crates/vm/src/dict_inner.rs
+++ b/crates/vm/src/dict_inner.rs
@@ -724,6 +724,17 @@ impl<T: Clone> Dict<T> {
             + inner.indices.len() * size_of::<i64>()
             + inner.entries.len() * size_of::<DictEntry<T>>()
     }
+
+    /// Pop all entries from the dict, returning (key, value) pairs.
+    /// This is used for circular reference resolution in GC.
+    /// Requires &mut self to avoid lock contention.
+    pub fn drain_entries(&mut self) -> impl Iterator<Item = (PyObjectRef, T)> + '_ {
+        let inner = self.inner.get_mut();
+        inner.used = 0;
+        inner.filled = 0;
+        inner.indices.iter_mut().for_each(|i| *i = IndexEntry::FREE);
+        inner.entries.drain(..).flatten().map(|e| (e.key, e.value))
+    }
 }
 
 type LookupResult = (IndexEntry, IndexIndex);
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index d83be841275..09da89089b9 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -13,6 +13,7 @@ use crate::{
     coroutine::Coro,
     exceptions::ExceptionCtor,
     function::{ArgMapping, Either, FuncArgs},
+    object::{Traverse, TraverseFn},
     protocol::{PyIter, PyIterReturn},
     scope::Scope,
     stdlib::{builtins, typing},
@@ -66,7 +67,7 @@ type Lasti = atomic::AtomicU32;
 #[cfg(not(feature = "threading"))]
 type Lasti = core::cell::Cell<u32>;
 
-#[pyclass(module = false, name = "frame")]
+#[pyclass(module = false, name = "frame", traverse = "manual")]
 pub struct Frame {
     pub code: PyRef<PyCode>,
     pub func_obj: Option<PyObjectRef>,
@@ -97,6 +98,27 @@ impl PyPayload for Frame {
     }
 }
 
+unsafe impl Traverse for FrameState {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.stack.traverse(tracer_fn);
+    }
+}
+
+unsafe impl Traverse for Frame {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.code.traverse(tracer_fn);
+        self.func_obj.traverse(tracer_fn);
+        self.fastlocals.traverse(tracer_fn);
+        self.cells_frees.traverse(tracer_fn);
+        self.locals.traverse(tracer_fn);
+        self.globals.traverse(tracer_fn);
+        self.builtins.traverse(tracer_fn);
+        self.trace.traverse(tracer_fn);
+        self.state.traverse(tracer_fn);
+        self.temporary_refs.traverse(tracer_fn);
+    }
+}
+
 // Running a frame can result in one of the below:
 pub enum ExecutionResult {
     Return(PyObjectRef),
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
index 4e51e296462..c949cae9053 100644
--- a/crates/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -93,7 +93,7 @@ pub(super) unsafe fn debug_obj<T: PyPayload + core::fmt::Debug>(
 }
 
 /// Call `try_trace` on payload
-pub(super) unsafe fn try_trace_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut TraverseFn<'_>) {
+pub(super) unsafe fn try_traverse_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut TraverseFn<'_>) {
     let x = unsafe { &*(x as *const PyObject as *const PyInner<T>) };
     let payload = &x.payload;
     payload.try_traverse(tracer_fn)
diff --git a/crates/vm/src/object/traverse.rs b/crates/vm/src/object/traverse.rs
index 2ce0db41a5e..367076b78e3 100644
--- a/crates/vm/src/object/traverse.rs
+++ b/crates/vm/src/object/traverse.rs
@@ -12,9 +12,13 @@ pub type TraverseFn<'a> = dyn FnMut(&PyObject) + 'a;
 /// Every PyObjectPayload impl `MaybeTrace`, which may or may not be traceable
 pub trait MaybeTraverse {
     /// if is traceable, will be used by vtable to determine
-    const IS_TRACE: bool = false;
+    const HAS_TRAVERSE: bool = false;
+    /// if has clear implementation for circular reference resolution (tp_clear)
+    const HAS_CLEAR: bool = false;
     // if this type is traceable, then call with tracer_fn, default to do nothing
     fn try_traverse(&self, traverse_fn: &mut TraverseFn<'_>);
+    // if this type has clear, extract child refs for circular reference resolution (tp_clear)
+    fn try_clear(&mut self, _out: &mut Vec<PyObjectRef>) {}
 }
 
 /// Type that need traverse it's children should impl [`Traverse`] (not [`MaybeTraverse`])
@@ -28,6 +32,11 @@ pub unsafe trait Traverse {
     ///
     /// - _**DO NOT**_ clone a [`PyObjectRef`] or [`PyRef<T>`] in [`Traverse::traverse()`]
     fn traverse(&self, traverse_fn: &mut TraverseFn<'_>);
+
+    /// Extract all owned child PyObjectRefs for circular reference resolution (tp_clear).
+    /// Called just before object deallocation to break circular references.
+    /// Default implementation does nothing.
+    fn clear(&mut self, _out: &mut Vec<PyObjectRef>) {}
 }
 
 unsafe impl Traverse for PyObjectRef {
diff --git a/crates/vm/src/object/traverse_object.rs b/crates/vm/src/object/traverse_object.rs
index 7a66f0b35f0..840bbd42b39 100644
--- a/crates/vm/src/object/traverse_object.rs
+++ b/crates/vm/src/object/traverse_object.rs
@@ -5,7 +5,7 @@ use crate::{
     PyObject,
     object::{
         Erased, InstanceDict, MaybeTraverse, PyInner, PyObjectPayload, debug_obj, drop_dealloc_obj,
-        try_trace_obj,
+        try_traverse_obj,
     },
 };
 
@@ -25,8 +25,8 @@ impl PyObjVTable {
             drop_dealloc: drop_dealloc_obj::<T>,
             debug: debug_obj::<T>,
             trace: const {
-                if T::IS_TRACE {
-                    Some(try_trace_obj::<T>)
+                if T::HAS_TRAVERSE {
+                    Some(try_traverse_obj::<T>)
                 } else {
                     None
                 }

From 050db4725f4b2257e6e494f345f5d84b4235eba0 Mon Sep 17 00:00:00 2001
From: Jiseok CHOI <jiseok.dev@gmail.com>
Date: Sun, 18 Jan 2026 23:37:47 +0900
Subject: [PATCH 371/418] sqlite3: fix Connection.cursor() factory argument
 handling (#6783)

Fix test_is_instance in CursorFactoryTests by properly handling the
factory argument in Connection.cursor() method. Now the factory can
be passed as both positional and keyword argument, and returns the
correct subclass type instead of always returning PyRef<Cursor>.

- Use FromArgs derive macro with CursorArgs struct for argument parsing
- Return PyObjectRef instead of PyRef<Cursor> to allow subclasses
- Use fast_issubclass to validate returned cursor is a Cursor subclass
- Properly differentiate between 'no argument' and 'None passed'
---
 Lib/test/test_sqlite3/test_factory.py |  2 --
 crates/stdlib/src/sqlite.rs           | 37 ++++++++++++++++++---------
 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/Lib/test/test_sqlite3/test_factory.py b/Lib/test/test_sqlite3/test_factory.py
index c13a7481520..20cff8b585f 100644
--- a/Lib/test/test_sqlite3/test_factory.py
+++ b/Lib/test/test_sqlite3/test_factory.py
@@ -80,8 +80,6 @@ def setUp(self):
     def tearDown(self):
         self.con.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_is_instance(self):
         cur = self.con.cursor()
         self.assertIsInstance(cur, sqlite.Cursor)
diff --git a/crates/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
index 7e0392b1f30..9b7b810b25c 100644
--- a/crates/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -425,6 +425,12 @@ mod _sqlite {
         name: PyStrRef,
     }
 
+    #[derive(FromArgs)]
+    struct CursorArgs {
+        #[pyarg(any, default)]
+        factory: OptionalArg<PyObjectRef>,
+    }
+
     struct CallbackData {
         obj: NonNull<PyObject>,
         vm: *const VirtualMachine,
@@ -1023,22 +1029,29 @@ mod _sqlite {
         #[pymethod]
         fn cursor(
             zelf: PyRef<Self>,
-            factory: OptionalArg<ArgCallable>,
+            args: CursorArgs,
             vm: &VirtualMachine,
-        ) -> PyResult<PyRef<Cursor>> {
+        ) -> PyResult<PyObjectRef> {
             zelf.db_lock(vm).map(drop)?;
 
-            let cursor = if let OptionalArg::Present(factory) = factory {
-                let cursor = factory.invoke((zelf.clone(),), vm)?;
-                let cursor = cursor.downcast::<Cursor>().map_err(|x| {
-                    vm.new_type_error(format!("factory must return a cursor, not {}", x.class()))
-                })?;
-                let _ = unsafe { cursor.row_factory.swap(zelf.row_factory.to_owned()) };
-                cursor
-            } else {
-                let row_factory = zelf.row_factory.to_owned();
-                Cursor::new(zelf, row_factory, vm).into_ref(&vm.ctx)
+            let factory = match args.factory {
+                OptionalArg::Present(f) => f,
+                OptionalArg::Missing => Cursor::class(&vm.ctx).to_owned().into(),
             };
+
+            let cursor = factory.call((zelf.clone(),), vm)?;
+
+            if !cursor.class().fast_issubclass(Cursor::class(&vm.ctx)) {
+                return Err(vm.new_type_error(format!(
+                    "factory must return a cursor, not {}",
+                    cursor.class()
+                )));
+            }
+
+            if let Some(cursor_ref) = cursor.downcast_ref::<Cursor>() {
+                let _ = unsafe { cursor_ref.row_factory.swap(zelf.row_factory.to_owned()) };
+            }
+
             Ok(cursor)
         }
 

From 3a9f02023495261917c918e3832094668d7096b9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Sun, 18 Jan 2026 23:58:39 +0900
Subject: [PATCH 372/418] update test_sys from 3.14.2 (#6781)

* sys.is_remote_debug_enabled, supports_isolated_interpreters

* Update test_sys form Python 3.14.2

---------

Co-authored-by: CPython Devleopers <>
---
 Lib/test/test_sys.py        | 453 ++++++++++++++++++++++++++++++------
 crates/vm/src/stdlib/sys.rs |  12 +-
 2 files changed, 390 insertions(+), 75 deletions(-)

diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index c3a23ffa666..77300fbe0bb 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -7,19 +7,24 @@
 import operator
 import os
 import random
+import socket
 import struct
 import subprocess
 import sys
 import sysconfig
 import test.support
+from io import StringIO
+from unittest import mock
 from test import support
 from test.support import os_helper
 from test.support.script_helper import assert_python_ok, assert_python_failure
+from test.support.socket_helper import find_unused_port
 from test.support import threading_helper
 from test.support import import_helper
 from test.support import force_not_colorized
+from test.support import SHORT_TIMEOUT
 try:
-    from test.support import interpreters
+    from concurrent import interpreters
 except ImportError:
     interpreters = None
 import textwrap
@@ -52,7 +57,7 @@ def test_original_displayhook(self):
             dh(None)
 
         self.assertEqual(out.getvalue(), "")
-        self.assertTrue(not hasattr(builtins, "_"))
+        self.assertNotHasAttr(builtins, "_")
 
         # sys.displayhook() requires arguments
         self.assertRaises(TypeError, dh)
@@ -167,7 +172,7 @@ def test_original_excepthook(self):
             with support.captured_stderr() as err:
                 sys.__excepthook__(*sys.exc_info())
 
-        self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
+        self.assertEndsWith(err.getvalue(), "ValueError: 42\n")
 
         self.assertRaises(TypeError, sys.__excepthook__)
 
@@ -188,7 +193,7 @@ def test_excepthook_bytes_filename(self):
         err = err.getvalue()
         self.assertIn("""  File "b'bytes_filename'", line 123\n""", err)
         self.assertIn("""    text\n""", err)
-        self.assertTrue(err.endswith("SyntaxError: msg\n"))
+        self.assertEndsWith(err, "SyntaxError: msg\n")
 
     def test_excepthook(self):
         with test.support.captured_output("stderr") as stderr:
@@ -206,7 +211,7 @@ class SysModuleTest(unittest.TestCase):
     def tearDown(self):
         test.support.reap_children()
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_exit(self):
         # call with two arguments
         self.assertRaises(TypeError, sys.exit, 42, 42)
@@ -266,8 +271,7 @@ def check_exit_message(code, expected, **env_vars):
             rc, out, err = assert_python_failure('-c', code, **env_vars)
             self.assertEqual(rc, 1)
             self.assertEqual(out, b'')
-            self.assertTrue(err.startswith(expected),
-                "%s doesn't start with %s" % (ascii(err), ascii(expected)))
+            self.assertStartsWith(err, expected)
 
         # test that stderr buffer is flushed before the exit message is written
         # into stderr
@@ -399,36 +403,6 @@ def test_setrecursionlimit_to_depth(self):
         finally:
             sys.setrecursionlimit(old_limit)
 
-    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful if the GIL is disabled")
-    @threading_helper.requires_working_threading()
-    def test_racing_recursion_limit(self):
-        from threading import Thread
-        def something_recursive():
-            def count(n):
-                if n > 0:
-                    return count(n - 1) + 1
-                return 0
-
-            count(50)
-
-        def set_recursion_limit():
-            for limit in range(100, 200):
-                sys.setrecursionlimit(limit)
-
-        threads = []
-        for _ in range(5):
-            threads.append(Thread(target=set_recursion_limit))
-
-        for _ in range(5):
-            threads.append(Thread(target=something_recursive))
-
-        with threading_helper.catch_threading_exception() as cm:
-            with threading_helper.start_threads(threads):
-                pass
-
-            if cm.exc_value:
-                raise cm.exc_value
-
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getwindowsversion(self):
         # Raise SkipTest if sys doesn't have getwindowsversion attribute
@@ -467,7 +441,7 @@ def test_call_tracing(self):
     @unittest.skipUnless(hasattr(sys, "setdlopenflags"),
                          'test needs sys.setdlopenflags()')
     def test_dlopenflags(self):
-        self.assertTrue(hasattr(sys, "getdlopenflags"))
+        self.assertHasAttr(sys, "getdlopenflags")
         self.assertRaises(TypeError, sys.getdlopenflags, 42)
         oldflags = sys.getdlopenflags()
         self.assertRaises(TypeError, sys.setdlopenflags)
@@ -656,8 +630,7 @@ def g456():
             # And the next record must be for g456().
             filename, lineno, funcname, sourceline = stack[i+1]
             self.assertEqual(funcname, "g456")
-            self.assertTrue((sourceline.startswith("if leave_g.wait(") or
-                             sourceline.startswith("g_raised.set()")))
+            self.assertStartsWith(sourceline, ("if leave_g.wait(", "g_raised.set()"))
         finally:
             # Reap the spawned thread.
             leave_g.set()
@@ -757,6 +730,8 @@ def test_attributes(self):
         self.assertIn(sys.float_repr_style, ('short', 'legacy'))
         if not sys.platform.startswith('win'):
             self.assertIsInstance(sys.abiflags, str)
+        else:
+            self.assertFalse(hasattr(sys, 'abiflags'))
 
     def test_thread_info(self):
         info = sys.thread_info
@@ -882,7 +857,7 @@ def test_subinterp_intern_singleton(self):
                     '''))
                 self.assertTrue(sys._is_interned(s))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON needs update for context_aware_warnings
+    @unittest.expectedFailure # TODO: RUSTPYTHON; needs update for context_aware_warnings
     def test_sys_flags(self):
         self.assertTrue(sys.flags)
         attrs = ("debug",
@@ -890,11 +865,10 @@ def test_sys_flags(self):
                  "dont_write_bytecode", "no_user_site", "no_site",
                  "ignore_environment", "verbose", "bytes_warning", "quiet",
                  "hash_randomization", "isolated", "dev_mode", "utf8_mode",
-                 "warn_default_encoding", "safe_path", "int_max_str_digits",
-                 "thread_inherit_context")
+                 "warn_default_encoding", "safe_path", "int_max_str_digits")
         for attr in attrs:
-            self.assertTrue(hasattr(sys.flags, attr), attr)
-            attr_type = bool if attr in ("dev_mode", "safe_path", "thread_inherit_context") else int
+            self.assertHasAttr(sys.flags, attr)
+            attr_type = bool if attr in ("dev_mode", "safe_path") else int
             self.assertEqual(type(getattr(sys.flags, attr)), attr_type, attr)
         self.assertTrue(repr(sys.flags))
         self.assertEqual(len(sys.flags), len(attrs))
@@ -920,9 +894,11 @@ def test_sys_getwindowsversion_no_instantiation(self):
 
     @test.support.cpython_only
     def test_clear_type_cache(self):
-        sys._clear_type_cache()
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r"sys\._clear_type_cache\(\) is deprecated.*"):
+            sys._clear_type_cache()
 
-    @unittest.skip("TODO: RUSTPYTHON; cp424 encoding not supported, causes panic")
+    @unittest.skip('TODO: RUSTPYTHON; cp424 encoding not supported, causes panic')
     @force_not_colorized
     @support.requires_subprocess()
     def test_ioencoding(self):
@@ -1102,10 +1078,11 @@ def test_implementation(self):
 
         levels = {'alpha': 0xA, 'beta': 0xB, 'candidate': 0xC, 'final': 0xF}
 
-        self.assertTrue(hasattr(sys.implementation, 'name'))
-        self.assertTrue(hasattr(sys.implementation, 'version'))
-        self.assertTrue(hasattr(sys.implementation, 'hexversion'))
-        self.assertTrue(hasattr(sys.implementation, 'cache_tag'))
+        self.assertHasAttr(sys.implementation, 'name')
+        self.assertHasAttr(sys.implementation, 'version')
+        self.assertHasAttr(sys.implementation, 'hexversion')
+        self.assertHasAttr(sys.implementation, 'cache_tag')
+        self.assertHasAttr(sys.implementation, 'supports_isolated_interpreters')
 
         version = sys.implementation.version
         self.assertEqual(version[:2], (version.major, version.minor))
@@ -1119,6 +1096,15 @@ def test_implementation(self):
         self.assertEqual(sys.implementation.name,
                          sys.implementation.name.lower())
 
+        # https://peps.python.org/pep-0734
+        sii = sys.implementation.supports_isolated_interpreters
+        self.assertIsInstance(sii, bool)
+        if test.support.check_impl_detail(cpython=True):
+            if test.support.is_emscripten or test.support.is_wasi:
+                self.assertFalse(sii)
+            else:
+                self.assertTrue(sii)
+
     @test.support.cpython_only
     def test_debugmallocstats(self):
         # Test sys._debugmallocstats()
@@ -1129,14 +1115,10 @@ def test_debugmallocstats(self):
         # Output of sys._debugmallocstats() depends on configure flags.
         # The sysconfig vars are not available on Windows.
         if sys.platform != "win32":
-            with_freelists = sysconfig.get_config_var("WITH_FREELISTS")
             with_pymalloc = sysconfig.get_config_var("WITH_PYMALLOC")
-            if with_freelists:
-                self.assertIn(b"free PyDictObjects", err)
+            self.assertIn(b"free PyDictObjects", err)
             if with_pymalloc:
                 self.assertIn(b'Small block threshold', err)
-            if not with_freelists and not with_pymalloc:
-                self.assertFalse(err)
 
         # The function has no parameter
         self.assertRaises(TypeError, sys._debugmallocstats, True)
@@ -1167,18 +1149,20 @@ def test_getallocatedblocks(self):
             # about the underlying implementation: the function might
             # return 0 or something greater.
             self.assertGreaterEqual(a, 0)
+        gc.collect()
+        b = sys.getallocatedblocks()
+        self.assertLessEqual(b, a)
         try:
-            # While we could imagine a Python session where the number of
-            # multiple buffer objects would exceed the sharing of references,
-            # it is unlikely to happen in a normal test run.
-            self.assertLess(a, sys.gettotalrefcount())
+            # The reported blocks will include immortalized strings, but the
+            # total ref count will not. This will sanity check that among all
+            # other objects (those eligible for garbage collection) there
+            # are more references being tracked than allocated blocks.
+            interned_immortal = sys.getunicodeinternedsize(_only_immortal=True)
+            self.assertLess(a - interned_immortal, sys.gettotalrefcount())
         except AttributeError:
             # gettotalrefcount() not available
             pass
         gc.collect()
-        b = sys.getallocatedblocks()
-        self.assertLessEqual(b, a)
-        gc.collect()
         c = sys.getallocatedblocks()
         self.assertIn(c, range(b - 50, b + 50))
 
@@ -1445,7 +1429,7 @@ def __del__(self):
                 else:
                     self.assertIn("ValueError", report)
                     self.assertIn("del is broken", report)
-                self.assertTrue(report.endswith("\n"))
+                self.assertEndsWith(report, "\n")
 
     def test_original_unraisablehook_exception_qualname(self):
         # See bpo-41031, bpo-45083.
@@ -1690,15 +1674,19 @@ class C(object): pass
         # float
         check(float(0), size('d'))
         # sys.floatinfo
-        check(sys.float_info, vsize('') + self.P * len(sys.float_info))
+        check(sys.float_info, self.P + vsize('') + self.P * len(sys.float_info))
         # frame
         def func():
             return sys._getframe()
         x = func()
-        check(x, size('3Pi2c2P7P2ic??2P'))
+        if support.Py_GIL_DISABLED:
+            INTERPRETER_FRAME = '9PihcP'
+        else:
+            INTERPRETER_FRAME = '9PhcP'
+        check(x, size('3PiccPPP' + INTERPRETER_FRAME + 'P'))
         # function
         def func(): pass
-        check(func, size('15Pi'))
+        check(func, size('16Pi'))
         class c():
             @staticmethod
             def foo():
@@ -1712,7 +1700,7 @@ def bar(cls):
             check(bar, size('PP'))
         # generator
         def get_gen(): yield 1
-        check(get_gen(), size('PP4P4c7P2ic??2P'))
+        check(get_gen(), size('6P4c' + INTERPRETER_FRAME + 'P'))
         # iterator
         check(iter('abc'), size('lP'))
         # callable-iterator
@@ -1794,13 +1782,14 @@ def delx(self): del self.__x
         # super
         check(super(int), size('3P'))
         # tuple
-        check((), vsize(''))
-        check((1,2,3), vsize('') + 3*self.P)
+        check((), vsize('') + self.P)
+        check((1,2,3), vsize('') + self.P + 3*self.P)
         # type
         # static type: PyTypeObject
         fmt = 'P2nPI13Pl4Pn9Pn12PIPc'
         s = vsize(fmt)
         check(int, s)
+        typeid = 'n' if support.Py_GIL_DISABLED else ''
         # class
         s = vsize(fmt +                 # PyTypeObject
                   '4P'                  # PyAsyncMethods
@@ -1808,8 +1797,9 @@ def delx(self): del self.__x
                   '3P'                  # PyMappingMethods
                   '10P'                 # PySequenceMethods
                   '2P'                  # PyBufferProcs
-                  '6P'
-                  '1PIP'                 # Specializer cache
+                  '7P'
+                  '1PIP'                # Specializer cache
+                  + typeid              # heap type id (free-threaded only)
                   )
         class newstyleclass(object): pass
         # Separate block for PyDictKeysObject with 8 keys and 5 entries
@@ -1914,8 +1904,10 @@ def test_pythontypes(self):
         # symtable entry
         # XXX
         # sys.flags
-        # FIXME: The +1 will not be necessary once gh-122575 is fixed
-        check(sys.flags, vsize('') + self.P * (1 + len(sys.flags)))
+        # FIXME: The +3 is for the 'gil', 'thread_inherit_context' and
+        # 'context_aware_warnings' flags and will not be necessary once
+        # gh-122575 is fixed
+        check(sys.flags, vsize('') + self.P + self.P * (3 + len(sys.flags)))
 
     def test_asyncgen_hooks(self):
         old = sys.get_asyncgen_hooks()
@@ -1973,5 +1965,318 @@ def write(self, s):
         self.assertEqual(out, b"")
         self.assertEqual(err, b"")
 
+@test.support.support_remote_exec_only
+@test.support.cpython_only
+class TestRemoteExec(unittest.TestCase):
+    def tearDown(self):
+        test.support.reap_children()
+
+    def _run_remote_exec_test(self, script_code, python_args=None, env=None,
+                              prologue='',
+                              script_path=os_helper.TESTFN + '_remote.py'):
+        # Create the script that will be remotely executed
+        self.addCleanup(os_helper.unlink, script_path)
+
+        with open(script_path, 'w') as f:
+            f.write(script_code)
+
+        # Create and run the target process
+        target = os_helper.TESTFN + '_target.py'
+        self.addCleanup(os_helper.unlink, target)
+
+        port = find_unused_port()
+
+        with open(target, 'w') as f:
+            f.write(f'''
+import sys
+import time
+import socket
+
+# Connect to the test process
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+sock.connect(('localhost', {port}))
+
+{prologue}
+
+# Signal that the process is ready
+sock.sendall(b"ready")
+
+print("Target process running...")
+
+# Wait for remote script to be executed
+# (the execution will happen as the following
+# code is processed as soon as the recv call
+# unblocks)
+sock.recv(1024)
+
+# Do a bunch of work to give the remote script time to run
+x = 0
+for i in range(100):
+    x += i
+
+# Write confirmation back
+sock.sendall(b"executed")
+sock.close()
+''')
+
+        # Start the target process and capture its output
+        cmd = [sys.executable]
+        if python_args:
+            cmd.extend(python_args)
+        cmd.append(target)
+
+        # Create a socket server to communicate with the target process
+        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        server_socket.bind(('localhost', port))
+        server_socket.settimeout(SHORT_TIMEOUT)
+        server_socket.listen(1)
+
+        with subprocess.Popen(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE,
+                              env=env,
+                              ) as proc:
+            client_socket = None
+            try:
+                # Accept connection from target process
+                client_socket, _ = server_socket.accept()
+                server_socket.close()
+
+                response = client_socket.recv(1024)
+                self.assertEqual(response, b"ready")
+
+                # Try remote exec on the target process
+                sys.remote_exec(proc.pid, script_path)
+
+                # Signal script to continue
+                client_socket.sendall(b"continue")
+
+                # Wait for execution confirmation
+                response = client_socket.recv(1024)
+                self.assertEqual(response, b"executed")
+
+                # Return output for test verification
+                stdout, stderr = proc.communicate(timeout=10.0)
+                return proc.returncode, stdout, stderr
+            except PermissionError:
+                self.skipTest("Insufficient permissions to execute code in remote process")
+            finally:
+                if client_socket is not None:
+                    client_socket.close()
+                proc.kill()
+                proc.terminate()
+                proc.wait(timeout=SHORT_TIMEOUT)
+
+    def test_remote_exec(self):
+        """Test basic remote exec functionality"""
+        script = 'print("Remote script executed successfully!")'
+        returncode, stdout, stderr = self._run_remote_exec_test(script)
+        # self.assertEqual(returncode, 0)
+        self.assertIn(b"Remote script executed successfully!", stdout)
+        self.assertEqual(stderr, b"")
+
+    def test_remote_exec_bytes(self):
+        script = 'print("Remote script executed successfully!")'
+        script_path = os.fsencode(os_helper.TESTFN) + b'_bytes_remote.py'
+        returncode, stdout, stderr = self._run_remote_exec_test(script,
+                                                    script_path=script_path)
+        self.assertIn(b"Remote script executed successfully!", stdout)
+        self.assertEqual(stderr, b"")
+
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE, 'requires undecodable path')
+    @unittest.skipIf(sys.platform == 'darwin',
+                     'undecodable paths are not supported on macOS')
+    def test_remote_exec_undecodable(self):
+        script = 'print("Remote script executed successfully!")'
+        script_path = os_helper.TESTFN_UNDECODABLE + b'_undecodable_remote.py'
+        for script_path in [script_path, os.fsdecode(script_path)]:
+            returncode, stdout, stderr = self._run_remote_exec_test(script,
+                                                        script_path=script_path)
+            self.assertIn(b"Remote script executed successfully!", stdout)
+            self.assertEqual(stderr, b"")
+
+    def test_remote_exec_with_self_process(self):
+        """Test remote exec with the target process being the same as the test process"""
+
+        code = 'import sys;print("Remote script executed successfully!", file=sys.stderr)'
+        file = os_helper.TESTFN + '_remote_self.py'
+        with open(file, 'w') as f:
+            f.write(code)
+        self.addCleanup(os_helper.unlink, file)
+        with mock.patch('sys.stderr', new_callable=StringIO) as mock_stderr:
+            with mock.patch('sys.stdout', new_callable=StringIO) as mock_stdout:
+                sys.remote_exec(os.getpid(), os.path.abspath(file))
+                print("Done")
+                self.assertEqual(mock_stderr.getvalue(), "Remote script executed successfully!\n")
+                self.assertEqual(mock_stdout.getvalue(), "Done\n")
+
+    def test_remote_exec_raises_audit_event(self):
+        """Test remote exec raises an audit event"""
+        prologue = '''\
+import sys
+def audit_hook(event, arg):
+    print(f"Audit event: {event}, arg: {arg}".encode("ascii", errors="replace"))
+sys.addaudithook(audit_hook)
+'''
+        script = '''
+print("Remote script executed successfully!")
+'''
+        returncode, stdout, stderr = self._run_remote_exec_test(script, prologue=prologue)
+        self.assertEqual(returncode, 0)
+        self.assertIn(b"Remote script executed successfully!", stdout)
+        self.assertIn(b"Audit event: cpython.remote_debugger_script, arg: ", stdout)
+        self.assertEqual(stderr, b"")
+
+    def test_remote_exec_with_exception(self):
+        """Test remote exec with an exception raised in the target process
+
+        The exception should be raised in the main thread of the target process
+        but not crash the target process.
+        """
+        script = '''
+raise Exception("Remote script exception")
+'''
+        returncode, stdout, stderr = self._run_remote_exec_test(script)
+        self.assertEqual(returncode, 0)
+        self.assertIn(b"Remote script exception", stderr)
+        self.assertEqual(stdout.strip(), b"Target process running...")
+
+    def test_new_namespace_for_each_remote_exec(self):
+        """Test that each remote_exec call gets its own namespace."""
+        script = textwrap.dedent(
+            """
+            assert globals() is not __import__("__main__").__dict__
+            print("Remote script executed successfully!")
+            """
+        )
+        returncode, stdout, stderr = self._run_remote_exec_test(script)
+        self.assertEqual(returncode, 0)
+        self.assertEqual(stderr, b"")
+        self.assertIn(b"Remote script executed successfully", stdout)
+
+    def test_remote_exec_disabled_by_env(self):
+        """Test remote exec is disabled when PYTHON_DISABLE_REMOTE_DEBUG is set"""
+        env = os.environ.copy()
+        env['PYTHON_DISABLE_REMOTE_DEBUG'] = '1'
+        with self.assertRaisesRegex(RuntimeError, "Remote debugging is not enabled in the remote process"):
+            self._run_remote_exec_test("print('should not run')", env=env)
+
+    def test_remote_exec_disabled_by_xoption(self):
+        """Test remote exec is disabled with -Xdisable-remote-debug"""
+        with self.assertRaisesRegex(RuntimeError, "Remote debugging is not enabled in the remote process"):
+            self._run_remote_exec_test("print('should not run')", python_args=['-Xdisable-remote-debug'])
+
+    def test_remote_exec_invalid_pid(self):
+        """Test remote exec with invalid process ID"""
+        with self.assertRaises(OSError):
+            sys.remote_exec(99999, "print('should not run')")
+
+    def test_remote_exec_invalid_script(self):
+        """Test remote exec with invalid script type"""
+        with self.assertRaises(TypeError):
+            sys.remote_exec(0, None)
+        with self.assertRaises(TypeError):
+            sys.remote_exec(0, 123)
+
+    def test_remote_exec_syntax_error(self):
+        """Test remote exec with syntax error in script"""
+        script = '''
+this is invalid python code
+'''
+        returncode, stdout, stderr = self._run_remote_exec_test(script)
+        self.assertEqual(returncode, 0)
+        self.assertIn(b"SyntaxError", stderr)
+        self.assertEqual(stdout.strip(), b"Target process running...")
+
+    def test_remote_exec_invalid_script_path(self):
+        """Test remote exec with invalid script path"""
+        with self.assertRaises(OSError):
+            sys.remote_exec(os.getpid(), "invalid_script_path")
+
+    def test_remote_exec_in_process_without_debug_fails_envvar(self):
+        """Test remote exec in a process without remote debugging enabled"""
+        script = os_helper.TESTFN + '_remote.py'
+        self.addCleanup(os_helper.unlink, script)
+        with open(script, 'w') as f:
+            f.write('print("Remote script executed successfully!")')
+        env = os.environ.copy()
+        env['PYTHON_DISABLE_REMOTE_DEBUG'] = '1'
+
+        _, out, err = assert_python_failure('-c', f'import os, sys; sys.remote_exec(os.getpid(), "{script}")', **env)
+        self.assertIn(b"Remote debugging is not enabled", err)
+        self.assertEqual(out, b"")
+
+    def test_remote_exec_in_process_without_debug_fails_xoption(self):
+        """Test remote exec in a process without remote debugging enabled"""
+        script = os_helper.TESTFN + '_remote.py'
+        self.addCleanup(os_helper.unlink, script)
+        with open(script, 'w') as f:
+            f.write('print("Remote script executed successfully!")')
+
+        _, out, err = assert_python_failure('-Xdisable-remote-debug', '-c', f'import os, sys; sys.remote_exec(os.getpid(), "{script}")')
+        self.assertIn(b"Remote debugging is not enabled", err)
+        self.assertEqual(out, b"")
+
+class TestSysJIT(unittest.TestCase):
+
+    def test_jit_is_available(self):
+        available = sys._jit.is_available()
+        script = f"import sys; assert sys._jit.is_available() is {available}"
+        assert_python_ok("-c", script, PYTHON_JIT="0")
+        assert_python_ok("-c", script, PYTHON_JIT="1")
+
+    def test_jit_is_enabled(self):
+        available = sys._jit.is_available()
+        script = "import sys; assert sys._jit.is_enabled() is {enabled}"
+        assert_python_ok("-c", script.format(enabled=False), PYTHON_JIT="0")
+        assert_python_ok("-c", script.format(enabled=available), PYTHON_JIT="1")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_jit_is_active(self):
+        available = sys._jit.is_available()
+        script = textwrap.dedent(
+            """
+            import _testcapi
+            import _testinternalcapi
+            import sys
+
+            def frame_0_interpreter() -> None:
+                assert sys._jit.is_active() is False
+
+            def frame_1_interpreter() -> None:
+                assert sys._jit.is_active() is False
+                frame_0_interpreter()
+                assert sys._jit.is_active() is False
+
+            def frame_2_jit(expected: bool) -> None:
+                # Inlined into the last loop of frame_3_jit:
+                assert sys._jit.is_active() is expected
+                # Insert C frame:
+                _testcapi.pyobject_vectorcall(frame_1_interpreter, None, None)
+                assert sys._jit.is_active() is expected
+
+            def frame_3_jit() -> None:
+                # JITs just before the last loop:
+                for i in range(_testinternalcapi.TIER2_THRESHOLD + 1):
+                    # Careful, doing this in the reverse order breaks tracing:
+                    expected = {enabled} and i == _testinternalcapi.TIER2_THRESHOLD
+                    assert sys._jit.is_active() is expected
+                    frame_2_jit(expected)
+                    assert sys._jit.is_active() is expected
+
+            def frame_4_interpreter() -> None:
+                assert sys._jit.is_active() is False
+                frame_3_jit()
+                assert sys._jit.is_active() is False
+
+            assert sys._jit.is_active() is False
+            frame_4_interpreter()
+            assert sys._jit.is_active() is False
+            """
+        )
+        assert_python_ok("-c", script.format(enabled=False), PYTHON_JIT="0")
+        assert_python_ok("-c", script.format(enabled=available), PYTHON_JIT="1")
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 5446b04c6d5..305e1cfa61d 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -76,8 +76,11 @@ mod sys {
     #[pyattr(name = "_rustpython_debugbuild")]
     const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
 
+    #[cfg(not(windows))]
     #[pyattr(name = "abiflags")]
-    pub(crate) const ABIFLAGS: &str = "t"; // 't' for free-threaded (no GIL)
+    const ABIFLAGS_ATTR: &str = "t"; // 't' for free-threaded (no GIL)
+    // Internal constant used for sysconfigdata_name
+    pub(crate) const ABIFLAGS: &str = "t";
     #[pyattr(name = "api_version")]
     const API_VERSION: u32 = 0x0; // what C api?
     #[pyattr(name = "copyright")]
@@ -527,6 +530,7 @@ mod sys {
             "_multiarch" => ctx.new_str(multiarch()),
             "version" => version_info(vm),
             "hexversion" => ctx.new_int(version::VERSION_HEX),
+            "supports_isolated_interpreters" => ctx.new_bool(false),
         })
     }
 
@@ -628,6 +632,12 @@ mod sys {
         false // RustPython has no GIL (like free-threaded Python)
     }
 
+    /// Return True if remote debugging is enabled, False otherwise.
+    #[pyfunction]
+    const fn is_remote_debug_enabled() -> bool {
+        false // RustPython does not support remote debugging
+    }
+
     #[pyfunction]
     fn exit(code: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
         let code = code.unwrap_or_none(vm);

From ed785e3d868966e2a5f7478632cabd5a630e6934 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 19 Jan 2026 00:04:06 +0900
Subject: [PATCH 373/418] Bump base64 to 3.14.2 (#6776)

---
 Lib/base64.py           | 21 +++++++----
 Lib/test/test_base64.py | 77 ++++++++++++++++++++++++++---------------
 2 files changed, 64 insertions(+), 34 deletions(-)
 mode change 100755 => 100644 Lib/base64.py

diff --git a/Lib/base64.py b/Lib/base64.py
old mode 100755
new mode 100644
index 5a7e790a193..f95132a4274
--- a/Lib/base64.py
+++ b/Lib/base64.py
@@ -1,12 +1,9 @@
-#! /usr/bin/env python3
-
 """Base16, Base32, Base64 (RFC 3548), Base85 and Ascii85 data encodings"""
 
 # Modified 04-Oct-1995 by Jack Jansen to use binascii module
 # Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support
 # Modified 22-May-2007 by Guido van Rossum to use bytes everywhere
 
-import re
 import struct
 import binascii
 
@@ -286,7 +283,7 @@ def b16decode(s, casefold=False):
     s = _bytes_from_decode_data(s)
     if casefold:
         s = s.upper()
-    if re.search(b'[^0-9A-F]', s):
+    if s.translate(None, delete=b'0123456789ABCDEF'):
         raise binascii.Error('Non-base16 digit found')
     return binascii.unhexlify(s)
 
@@ -465,9 +462,12 @@ def b85decode(b):
     # Delay the initialization of tables to not waste memory
     # if the function is never called
     if _b85dec is None:
-        _b85dec = [None] * 256
+        # we don't assign to _b85dec directly to avoid issues when
+        # multiple threads call this function simultaneously
+        b85dec_tmp = [None] * 256
         for i, c in enumerate(_b85alphabet):
-            _b85dec[c] = i
+            b85dec_tmp[c] = i
+        _b85dec = b85dec_tmp
 
     b = _bytes_from_decode_data(b)
     padding = (-len(b)) % 5
@@ -604,7 +604,14 @@ def main():
         with open(args[0], 'rb') as f:
             func(f, sys.stdout.buffer)
     else:
-        func(sys.stdin.buffer, sys.stdout.buffer)
+        if sys.stdin.isatty():
+            # gh-138775: read terminal input data all at once to detect EOF
+            import io
+            data = sys.stdin.buffer.read()
+            buffer = io.BytesIO(data)
+        else:
+            buffer = sys.stdin.buffer
+        func(buffer, sys.stdout.buffer)
 
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_base64.py b/Lib/test/test_base64.py
index 409c8c109e8..a6739124571 100644
--- a/Lib/test/test_base64.py
+++ b/Lib/test/test_base64.py
@@ -1,10 +1,18 @@
-import unittest
 import base64
 import binascii
 import os
+import unittest
 from array import array
+from test.support import cpython_only
 from test.support import os_helper
 from test.support import script_helper
+from test.support.import_helper import ensure_lazy_imports
+
+
+class LazyImportTest(unittest.TestCase):
+    @cpython_only
+    def test_lazy_import(self):
+        ensure_lazy_imports("base64", {"re", "getopt"})
 
 
 class LegacyBase64TestCase(unittest.TestCase):
@@ -200,18 +208,6 @@ def test_b64decode(self):
         self.check_other_types(base64.b64decode, b"YWJj", b"abc")
         self.check_decode_type_errors(base64.b64decode)
 
-        # Test with arbitrary alternative characters
-        tests_altchars = {(b'01a*b$cd', b'*$'): b'\xd3V\xbeo\xf7\x1d',
-                          }
-        for (data, altchars), res in tests_altchars.items():
-            data_str = data.decode('ascii')
-            altchars_str = altchars.decode('ascii')
-
-            eq(base64.b64decode(data, altchars=altchars), res)
-            eq(base64.b64decode(data_str, altchars=altchars), res)
-            eq(base64.b64decode(data, altchars=altchars_str), res)
-            eq(base64.b64decode(data_str, altchars=altchars_str), res)
-
         # Test standard alphabet
         for data, res in tests.items():
             eq(base64.standard_b64decode(data), res)
@@ -232,6 +228,20 @@ def test_b64decode(self):
                                b'\xd3V\xbeo\xf7\x1d')
         self.check_decode_type_errors(base64.urlsafe_b64decode)
 
+    def test_b64decode_altchars(self):
+        # Test with arbitrary alternative characters
+        eq = self.assertEqual
+        res = b'\xd3V\xbeo\xf7\x1d'
+        for altchars in b'*$', b'+/', b'/+', b'+_', b'-+', b'-/', b'/_':
+            data = b'01a%cb%ccd' % tuple(altchars)
+            data_str = data.decode('ascii')
+            altchars_str = altchars.decode('ascii')
+
+            eq(base64.b64decode(data, altchars=altchars), res)
+            eq(base64.b64decode(data_str, altchars=altchars), res)
+            eq(base64.b64decode(data, altchars=altchars_str), res)
+            eq(base64.b64decode(data_str, altchars=altchars_str), res)
+
     def test_b64decode_padding_error(self):
         self.assertRaises(binascii.Error, base64.b64decode, b'abc')
         self.assertRaises(binascii.Error, base64.b64decode, 'abc')
@@ -264,9 +274,12 @@ def test_b64decode_invalid_chars(self):
                 base64.b64decode(bstr.decode('ascii'), validate=True)
 
         # Normal alphabet characters not discarded when alternative given
-        res = b'\xFB\xEF\xBE\xFF\xFF\xFF'
-        self.assertEqual(base64.b64decode(b'++[[//]]', b'[]'), res)
-        self.assertEqual(base64.urlsafe_b64decode(b'++--//__'), res)
+        res = b'\xfb\xef\xff'
+        self.assertEqual(base64.b64decode(b'++//', validate=True), res)
+        self.assertEqual(base64.b64decode(b'++//', '-_', validate=True), res)
+        self.assertEqual(base64.b64decode(b'--__', '-_', validate=True), res)
+        self.assertEqual(base64.urlsafe_b64decode(b'++//'), res)
+        self.assertEqual(base64.urlsafe_b64decode(b'--__'), res)
 
     def test_b32encode(self):
         eq = self.assertEqual
@@ -321,23 +334,33 @@ def test_b32decode_casefold(self):
         self.assertRaises(binascii.Error, base64.b32decode, b'me======')
         self.assertRaises(binascii.Error, base64.b32decode, 'me======')
 
+    def test_b32decode_map01(self):
         # Mapping zero and one
-        eq(base64.b32decode(b'MLO23456'), b'b\xdd\xad\xf3\xbe')
-        eq(base64.b32decode('MLO23456'), b'b\xdd\xad\xf3\xbe')
-
-        map_tests = {(b'M1023456', b'L'): b'b\xdd\xad\xf3\xbe',
-                     (b'M1023456', b'I'): b'b\x1d\xad\xf3\xbe',
-                     }
-        for (data, map01), res in map_tests.items():
-            data_str = data.decode('ascii')
+        eq = self.assertEqual
+        res_L = b'b\xdd\xad\xf3\xbe'
+        res_I = b'b\x1d\xad\xf3\xbe'
+        eq(base64.b32decode(b'MLO23456'), res_L)
+        eq(base64.b32decode('MLO23456'), res_L)
+        eq(base64.b32decode(b'MIO23456'), res_I)
+        eq(base64.b32decode('MIO23456'), res_I)
+        self.assertRaises(binascii.Error, base64.b32decode, b'M1023456')
+        self.assertRaises(binascii.Error, base64.b32decode, b'M1O23456')
+        self.assertRaises(binascii.Error, base64.b32decode, b'ML023456')
+        self.assertRaises(binascii.Error, base64.b32decode, b'MI023456')
+
+        data = b'M1023456'
+        data_str = data.decode('ascii')
+        for map01, res in [(b'L', res_L), (b'I', res_I)]:
             map01_str = map01.decode('ascii')
 
             eq(base64.b32decode(data, map01=map01), res)
             eq(base64.b32decode(data_str, map01=map01), res)
             eq(base64.b32decode(data, map01=map01_str), res)
             eq(base64.b32decode(data_str, map01=map01_str), res)
-            self.assertRaises(binascii.Error, base64.b32decode, data)
-            self.assertRaises(binascii.Error, base64.b32decode, data_str)
+
+            eq(base64.b32decode(b'M1O23456', map01=map01), res)
+            eq(base64.b32decode(b'M%c023456' % map01, map01=map01), res)
+            eq(base64.b32decode(b'M%cO23456' % map01, map01=map01), res)
 
     def test_b32decode_error(self):
         tests = [b'abc', b'ABCDEF==', b'==ABCDEF']
@@ -804,7 +827,7 @@ def test_decode_nonascii_str(self):
             self.assertRaises(ValueError, f, 'with non-ascii \xcb')
 
     def test_ErrorHeritage(self):
-        self.assertTrue(issubclass(binascii.Error, ValueError))
+        self.assertIsSubclass(binascii.Error, ValueError)
 
     def test_RFC4648_test_cases(self):
         # test cases from RFC 4648 section 10

From 0717b53123b8b4ef56f7c0f95c7f41cd6b3a3174 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 19 Jan 2026 00:37:18 +0900
Subject: [PATCH 374/418] Align CallFunctionEx to 3.14 (#6786)

---
 crates/codegen/src/compile.rs                    | 14 ++++++++------
 crates/compiler-core/src/bytecode/instruction.rs | 10 ++++------
 crates/vm/src/frame.rs                           | 12 ++++++------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index c39c11892f9..be7807ec411 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4423,11 +4423,12 @@ impl Compiler {
                 }
 
                 // Build kwargs if needed
-                let has_kwargs = arguments.is_some_and(|args| !args.keywords.is_empty());
-                if has_kwargs {
+                if arguments.is_some_and(|args| !args.keywords.is_empty()) {
                     self.compile_keywords(&arguments.unwrap().keywords)?;
+                } else {
+                    emit!(self, Instruction::PushNull);
                 }
-                emit!(self, Instruction::CallFunctionEx { has_kwargs });
+                emit!(self, Instruction::CallFunctionEx);
             } else {
                 // Simple case: no starred bases, no **kwargs
                 // Compile bases normally
@@ -6961,11 +6962,12 @@ impl Compiler {
             }
 
             // Create an optional map with kw-args:
-            let has_kwargs = !arguments.keywords.is_empty();
-            if has_kwargs {
+            if !arguments.keywords.is_empty() {
                 self.compile_keywords(&arguments.keywords)?;
+            } else {
+                emit!(self, Instruction::PushNull);
             }
-            emit!(self, Instruction::CallFunctionEx { has_kwargs });
+            emit!(self, Instruction::CallFunctionEx);
         } else if !arguments.keywords.is_empty() {
             // No **kwargs in this branch (has_double_star is false),
             // so all keywords have arg.is_some()
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index fe448f4574b..4faf67d273b 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -95,9 +95,7 @@ pub enum Instruction {
     Call {
         nargs: Arg<u32>,
     } = 53,
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    } = 54,
+    CallFunctionEx = 54,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
     } = 55,
@@ -575,8 +573,8 @@ impl InstructionMetadata for Instruction {
             Self::Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
             // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
             Self::CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
-            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
-            Self::CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
+            // CallFunctionEx: always pops kwargs_or_null + args_tuple + self_or_null + callable, pushes result
+            Self::CallFunctionEx => -4 + 1,
             Self::CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
             Self::ConvertValue { .. } => 0,
             Self::FormatSimple => 0,
@@ -880,7 +878,7 @@ impl InstructionMetadata for Instruction {
             Self::BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
             Self::BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
             Self::Call { nargs } => w!(CALL, nargs),
-            Self::CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
+            Self::CallFunctionEx => w!(CALL_FUNCTION_EX),
             Self::CallKw { nargs } => w!(CALL_KW, nargs),
             Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 09da89089b9..55788ee3e4a 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -785,9 +785,9 @@ impl ExecutingFrame<'_> {
                 let args = self.collect_keyword_args(nargs.get(arg));
                 self.execute_call(args, vm)
             }
-            Instruction::CallFunctionEx { has_kwargs } => {
-                // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+            Instruction::CallFunctionEx => {
+                // Stack: [callable, self_or_null, args_tuple, kwargs_or_null]
+                let args = self.collect_ex_args(vm)?;
                 self.execute_call(args, vm)
             }
             Instruction::CallIntrinsic1 { func } => {
@@ -2150,9 +2150,9 @@ impl ExecutingFrame<'_> {
         FuncArgs::with_kwargs_names(args, kwarg_names)
     }
 
-    fn collect_ex_args(&mut self, vm: &VirtualMachine, has_kwargs: bool) -> PyResult<FuncArgs> {
-        let kwargs = if has_kwargs {
-            let kw_obj = self.pop_value();
+    fn collect_ex_args(&mut self, vm: &VirtualMachine) -> PyResult<FuncArgs> {
+        let kwargs_or_null = self.pop_value_opt();
+        let kwargs = if let Some(kw_obj) = kwargs_or_null {
             let mut kwargs = IndexMap::new();
 
             // Use keys() method for all mapping objects to preserve order

From 9b5eefbb7bfa81f895f4c156f0a918104042fc7c Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 19 Jan 2026 00:38:51 +0900
Subject: [PATCH 375/418] Replace _compression with compression and update
 related too (#6788)

---
 Lib/bz2.py                                    |    8 +-
 Lib/compression/__init__.py                   |    0
 Lib/compression/_common/__init__.py           |    0
 .../_common/_streams.py}                      |    2 +-
 Lib/compression/bz2.py                        |    5 +
 Lib/compression/gzip.py                       |    5 +
 Lib/compression/lzma.py                       |    5 +
 Lib/compression/zlib.py                       |    5 +
 Lib/compression/zstd/__init__.py              |  242 ++
 Lib/compression/zstd/_zstdfile.py             |  345 ++
 Lib/gzip.py                                   |   60 +-
 Lib/lzma.py                                   |    8 +-
 Lib/test/test_bz2.py                          |   20 +-
 Lib/test/test_gzip.py                         |   62 +-
 Lib/test/test_lzma.py                         |  205 +-
 Lib/test/test_zlib.py                         |   43 +-
 Lib/test/test_zstd.py                         | 2802 +++++++++++++++++
 17 files changed, 3623 insertions(+), 194 deletions(-)
 create mode 100644 Lib/compression/__init__.py
 create mode 100644 Lib/compression/_common/__init__.py
 rename Lib/{_compression.py => compression/_common/_streams.py} (98%)
 create mode 100644 Lib/compression/bz2.py
 create mode 100644 Lib/compression/gzip.py
 create mode 100644 Lib/compression/lzma.py
 create mode 100644 Lib/compression/zlib.py
 create mode 100644 Lib/compression/zstd/__init__.py
 create mode 100644 Lib/compression/zstd/_zstdfile.py
 create mode 100644 Lib/test/test_zstd.py

diff --git a/Lib/bz2.py b/Lib/bz2.py
index 2420cd01906..eb58f4da596 100644
--- a/Lib/bz2.py
+++ b/Lib/bz2.py
@@ -10,9 +10,9 @@
 __author__ = "Nadeem Vawda <nadeem.vawda@gmail.com>"
 
 from builtins import open as _builtin_open
+from compression._common import _streams
 import io
 import os
-import _compression
 
 from _bz2 import BZ2Compressor, BZ2Decompressor
 
@@ -23,7 +23,7 @@
 _MODE_WRITE    = 3
 
 
-class BZ2File(_compression.BaseStream):
+class BZ2File(_streams.BaseStream):
 
     """A file object providing transparent bzip2 (de)compression.
 
@@ -88,7 +88,7 @@ def __init__(self, filename, mode="r", *, compresslevel=9):
             raise TypeError("filename must be a str, bytes, file or PathLike object")
 
         if self._mode == _MODE_READ:
-            raw = _compression.DecompressReader(self._fp,
+            raw = _streams.DecompressReader(self._fp,
                 BZ2Decompressor, trailing_error=OSError)
             self._buffer = io.BufferedReader(raw)
         else:
@@ -248,7 +248,7 @@ def writelines(self, seq):
 
         Line separators are not added between the written byte strings.
         """
-        return _compression.BaseStream.writelines(self, seq)
+        return _streams.BaseStream.writelines(self, seq)
 
     def seek(self, offset, whence=io.SEEK_SET):
         """Change the file position.
diff --git a/Lib/compression/__init__.py b/Lib/compression/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/Lib/compression/_common/__init__.py b/Lib/compression/_common/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/Lib/_compression.py b/Lib/compression/_common/_streams.py
similarity index 98%
rename from Lib/_compression.py
rename to Lib/compression/_common/_streams.py
index e8b70aa0a3e..9f367d4e304 100644
--- a/Lib/_compression.py
+++ b/Lib/compression/_common/_streams.py
@@ -1,4 +1,4 @@
-"""Internal classes used by the gzip, lzma and bz2 modules"""
+"""Internal classes used by compression modules"""
 
 import io
 import sys
diff --git a/Lib/compression/bz2.py b/Lib/compression/bz2.py
new file mode 100644
index 00000000000..16815d6cd20
--- /dev/null
+++ b/Lib/compression/bz2.py
@@ -0,0 +1,5 @@
+import bz2
+__doc__ = bz2.__doc__
+del bz2
+
+from bz2 import *
diff --git a/Lib/compression/gzip.py b/Lib/compression/gzip.py
new file mode 100644
index 00000000000..552f48f948a
--- /dev/null
+++ b/Lib/compression/gzip.py
@@ -0,0 +1,5 @@
+import gzip
+__doc__ = gzip.__doc__
+del gzip
+
+from gzip import *
diff --git a/Lib/compression/lzma.py b/Lib/compression/lzma.py
new file mode 100644
index 00000000000..b4bc7ccb1db
--- /dev/null
+++ b/Lib/compression/lzma.py
@@ -0,0 +1,5 @@
+import lzma
+__doc__ = lzma.__doc__
+del lzma
+
+from lzma import *
diff --git a/Lib/compression/zlib.py b/Lib/compression/zlib.py
new file mode 100644
index 00000000000..3aa7e2db90e
--- /dev/null
+++ b/Lib/compression/zlib.py
@@ -0,0 +1,5 @@
+import zlib
+__doc__ = zlib.__doc__
+del zlib
+
+from zlib import *
diff --git a/Lib/compression/zstd/__init__.py b/Lib/compression/zstd/__init__.py
new file mode 100644
index 00000000000..84b25914b0a
--- /dev/null
+++ b/Lib/compression/zstd/__init__.py
@@ -0,0 +1,242 @@
+"""Python bindings to the Zstandard (zstd) compression library (RFC-8878)."""
+
+__all__ = (
+    # compression.zstd
+    'COMPRESSION_LEVEL_DEFAULT',
+    'compress',
+    'CompressionParameter',
+    'decompress',
+    'DecompressionParameter',
+    'finalize_dict',
+    'get_frame_info',
+    'Strategy',
+    'train_dict',
+
+    # compression.zstd._zstdfile
+    'open',
+    'ZstdFile',
+
+    # _zstd
+    'get_frame_size',
+    'zstd_version',
+    'zstd_version_info',
+    'ZstdCompressor',
+    'ZstdDecompressor',
+    'ZstdDict',
+    'ZstdError',
+)
+
+import _zstd
+import enum
+from _zstd import (ZstdCompressor, ZstdDecompressor, ZstdDict, ZstdError,
+                   get_frame_size, zstd_version)
+from compression.zstd._zstdfile import ZstdFile, open, _nbytes
+
+# zstd_version_number is (MAJOR * 100 * 100 + MINOR * 100 + RELEASE)
+zstd_version_info = (*divmod(_zstd.zstd_version_number // 100, 100),
+                     _zstd.zstd_version_number % 100)
+"""Version number of the runtime zstd library as a tuple of integers."""
+
+COMPRESSION_LEVEL_DEFAULT = _zstd.ZSTD_CLEVEL_DEFAULT
+"""The default compression level for Zstandard, currently '3'."""
+
+
+class FrameInfo:
+    """Information about a Zstandard frame."""
+
+    __slots__ = 'decompressed_size', 'dictionary_id'
+
+    def __init__(self, decompressed_size, dictionary_id):
+        super().__setattr__('decompressed_size', decompressed_size)
+        super().__setattr__('dictionary_id', dictionary_id)
+
+    def __repr__(self):
+        return (f'FrameInfo(decompressed_size={self.decompressed_size}, '
+                f'dictionary_id={self.dictionary_id})')
+
+    def __setattr__(self, name, _):
+        raise AttributeError(f"can't set attribute {name!r}")
+
+
+def get_frame_info(frame_buffer):
+    """Get Zstandard frame information from a frame header.
+
+    *frame_buffer* is a bytes-like object. It should start from the beginning
+    of a frame, and needs to include at least the frame header (6 to 18 bytes).
+
+    The returned FrameInfo object has two attributes.
+    'decompressed_size' is the size in bytes of the data in the frame when
+    decompressed, or None when the decompressed size is unknown.
+    'dictionary_id' is an int in the range (0, 2**32). The special value 0
+    means that the dictionary ID was not recorded in the frame header,
+    the frame may or may not need a dictionary to be decoded,
+    and the ID of such a dictionary is not specified.
+    """
+    return FrameInfo(*_zstd.get_frame_info(frame_buffer))
+
+
+def train_dict(samples, dict_size):
+    """Return a ZstdDict representing a trained Zstandard dictionary.
+
+    *samples* is an iterable of samples, where a sample is a bytes-like
+    object representing a file.
+
+    *dict_size* is the dictionary's maximum size, in bytes.
+    """
+    if not isinstance(dict_size, int):
+        ds_cls = type(dict_size).__qualname__
+        raise TypeError(f'dict_size must be an int object, not {ds_cls!r}.')
+
+    samples = tuple(samples)
+    chunks = b''.join(samples)
+    chunk_sizes = tuple(_nbytes(sample) for sample in samples)
+    if not chunks:
+        raise ValueError("samples contained no data; can't train dictionary.")
+    dict_content = _zstd.train_dict(chunks, chunk_sizes, dict_size)
+    return ZstdDict(dict_content)
+
+
+def finalize_dict(zstd_dict, /, samples, dict_size, level):
+    """Return a ZstdDict representing a finalized Zstandard dictionary.
+
+    Given a custom content as a basis for dictionary, and a set of samples,
+    finalize *zstd_dict* by adding headers and statistics according to the
+    Zstandard dictionary format.
+
+    You may compose an effective dictionary content by hand, which is used as
+    basis dictionary, and use some samples to finalize a dictionary. The basis
+    dictionary may be a "raw content" dictionary. See *is_raw* in ZstdDict.
+
+    *samples* is an iterable of samples, where a sample is a bytes-like object
+    representing a file.
+    *dict_size* is the dictionary's maximum size, in bytes.
+    *level* is the expected compression level. The statistics for each
+    compression level differ, so tuning the dictionary to the compression level
+    can provide improvements.
+    """
+
+    if not isinstance(zstd_dict, ZstdDict):
+        raise TypeError('zstd_dict argument should be a ZstdDict object.')
+    if not isinstance(dict_size, int):
+        raise TypeError('dict_size argument should be an int object.')
+    if not isinstance(level, int):
+        raise TypeError('level argument should be an int object.')
+
+    samples = tuple(samples)
+    chunks = b''.join(samples)
+    chunk_sizes = tuple(_nbytes(sample) for sample in samples)
+    if not chunks:
+        raise ValueError("The samples are empty content, can't finalize the "
+                         "dictionary.")
+    dict_content = _zstd.finalize_dict(zstd_dict.dict_content, chunks,
+                                       chunk_sizes, dict_size, level)
+    return ZstdDict(dict_content)
+
+
+def compress(data, level=None, options=None, zstd_dict=None):
+    """Return Zstandard compressed *data* as bytes.
+
+    *level* is an int specifying the compression level to use, defaulting to
+    COMPRESSION_LEVEL_DEFAULT ('3').
+    *options* is a dict object that contains advanced compression
+    parameters. See CompressionParameter for more on options.
+    *zstd_dict* is a ZstdDict object, a pre-trained Zstandard dictionary. See
+    the function train_dict for how to train a ZstdDict on sample data.
+
+    For incremental compression, use a ZstdCompressor instead.
+    """
+    comp = ZstdCompressor(level=level, options=options, zstd_dict=zstd_dict)
+    return comp.compress(data, mode=ZstdCompressor.FLUSH_FRAME)
+
+
+def decompress(data, zstd_dict=None, options=None):
+    """Decompress one or more frames of Zstandard compressed *data*.
+
+    *zstd_dict* is a ZstdDict object, a pre-trained Zstandard dictionary. See
+    the function train_dict for how to train a ZstdDict on sample data.
+    *options* is a dict object that contains advanced compression
+    parameters. See DecompressionParameter for more on options.
+
+    For incremental decompression, use a ZstdDecompressor instead.
+    """
+    results = []
+    while True:
+        decomp = ZstdDecompressor(options=options, zstd_dict=zstd_dict)
+        results.append(decomp.decompress(data))
+        if not decomp.eof:
+            raise ZstdError('Compressed data ended before the '
+                            'end-of-stream marker was reached')
+        data = decomp.unused_data
+        if not data:
+            break
+    return b''.join(results)
+
+
+class CompressionParameter(enum.IntEnum):
+    """Compression parameters."""
+
+    compression_level = _zstd.ZSTD_c_compressionLevel
+    window_log = _zstd.ZSTD_c_windowLog
+    hash_log = _zstd.ZSTD_c_hashLog
+    chain_log = _zstd.ZSTD_c_chainLog
+    search_log = _zstd.ZSTD_c_searchLog
+    min_match = _zstd.ZSTD_c_minMatch
+    target_length = _zstd.ZSTD_c_targetLength
+    strategy = _zstd.ZSTD_c_strategy
+
+    enable_long_distance_matching = _zstd.ZSTD_c_enableLongDistanceMatching
+    ldm_hash_log = _zstd.ZSTD_c_ldmHashLog
+    ldm_min_match = _zstd.ZSTD_c_ldmMinMatch
+    ldm_bucket_size_log = _zstd.ZSTD_c_ldmBucketSizeLog
+    ldm_hash_rate_log = _zstd.ZSTD_c_ldmHashRateLog
+
+    content_size_flag = _zstd.ZSTD_c_contentSizeFlag
+    checksum_flag = _zstd.ZSTD_c_checksumFlag
+    dict_id_flag = _zstd.ZSTD_c_dictIDFlag
+
+    nb_workers = _zstd.ZSTD_c_nbWorkers
+    job_size = _zstd.ZSTD_c_jobSize
+    overlap_log = _zstd.ZSTD_c_overlapLog
+
+    def bounds(self):
+        """Return the (lower, upper) int bounds of a compression parameter.
+
+        Both the lower and upper bounds are inclusive.
+        """
+        return _zstd.get_param_bounds(self.value, is_compress=True)
+
+
+class DecompressionParameter(enum.IntEnum):
+    """Decompression parameters."""
+
+    window_log_max = _zstd.ZSTD_d_windowLogMax
+
+    def bounds(self):
+        """Return the (lower, upper) int bounds of a decompression parameter.
+
+        Both the lower and upper bounds are inclusive.
+        """
+        return _zstd.get_param_bounds(self.value, is_compress=False)
+
+
+class Strategy(enum.IntEnum):
+    """Compression strategies, listed from fastest to strongest.
+
+    Note that new strategies might be added in the future.
+    Only the order (from fast to strong) is guaranteed,
+    the numeric value might change.
+    """
+
+    fast = _zstd.ZSTD_fast
+    dfast = _zstd.ZSTD_dfast
+    greedy = _zstd.ZSTD_greedy
+    lazy = _zstd.ZSTD_lazy
+    lazy2 = _zstd.ZSTD_lazy2
+    btlazy2 = _zstd.ZSTD_btlazy2
+    btopt = _zstd.ZSTD_btopt
+    btultra = _zstd.ZSTD_btultra
+    btultra2 = _zstd.ZSTD_btultra2
+
+
+# Check validity of the CompressionParameter & DecompressionParameter types
+_zstd.set_parameter_types(CompressionParameter, DecompressionParameter)
diff --git a/Lib/compression/zstd/_zstdfile.py b/Lib/compression/zstd/_zstdfile.py
new file mode 100644
index 00000000000..d709f5efc65
--- /dev/null
+++ b/Lib/compression/zstd/_zstdfile.py
@@ -0,0 +1,345 @@
+import io
+from os import PathLike
+from _zstd import ZstdCompressor, ZstdDecompressor, ZSTD_DStreamOutSize
+from compression._common import _streams
+
+__all__ = ('ZstdFile', 'open')
+
+_MODE_CLOSED = 0
+_MODE_READ = 1
+_MODE_WRITE = 2
+
+
+def _nbytes(dat, /):
+    if isinstance(dat, (bytes, bytearray)):
+        return len(dat)
+    with memoryview(dat) as mv:
+        return mv.nbytes
+
+
+class ZstdFile(_streams.BaseStream):
+    """A file-like object providing transparent Zstandard (de)compression.
+
+    A ZstdFile can act as a wrapper for an existing file object, or refer
+    directly to a named file on disk.
+
+    ZstdFile provides a *binary* file interface. Data is read and returned as
+    bytes, and may only be written to objects that support the Buffer Protocol.
+    """
+
+    FLUSH_BLOCK = ZstdCompressor.FLUSH_BLOCK
+    FLUSH_FRAME = ZstdCompressor.FLUSH_FRAME
+
+    def __init__(self, file, /, mode='r', *,
+                 level=None, options=None, zstd_dict=None):
+        """Open a Zstandard compressed file in binary mode.
+
+        *file* can be either an file-like object, or a file name to open.
+
+        *mode* can be 'r' for reading (default), 'w' for (over)writing, 'x' for
+        creating exclusively, or 'a' for appending. These can equivalently be
+        given as 'rb', 'wb', 'xb' and 'ab' respectively.
+
+        *level* is an optional int specifying the compression level to use,
+        or COMPRESSION_LEVEL_DEFAULT if not given.
+
+        *options* is an optional dict for advanced compression parameters.
+        See CompressionParameter and DecompressionParameter for the possible
+        options.
+
+        *zstd_dict* is an optional ZstdDict object, a pre-trained Zstandard
+        dictionary. See train_dict() to train ZstdDict on sample data.
+        """
+        self._fp = None
+        self._close_fp = False
+        self._mode = _MODE_CLOSED
+        self._buffer = None
+
+        if not isinstance(mode, str):
+            raise ValueError('mode must be a str')
+        if options is not None and not isinstance(options, dict):
+            raise TypeError('options must be a dict or None')
+        mode = mode.removesuffix('b')  # handle rb, wb, xb, ab
+        if mode == 'r':
+            if level is not None:
+                raise TypeError('level is illegal in read mode')
+            self._mode = _MODE_READ
+        elif mode in {'w', 'a', 'x'}:
+            if level is not None and not isinstance(level, int):
+                raise TypeError('level must be int or None')
+            self._mode = _MODE_WRITE
+            self._compressor = ZstdCompressor(level=level, options=options,
+                                              zstd_dict=zstd_dict)
+            self._pos = 0
+        else:
+            raise ValueError(f'Invalid mode: {mode!r}')
+
+        if isinstance(file, (str, bytes, PathLike)):
+            self._fp = io.open(file, f'{mode}b')
+            self._close_fp = True
+        elif ((mode == 'r' and hasattr(file, 'read'))
+                or (mode != 'r' and hasattr(file, 'write'))):
+            self._fp = file
+        else:
+            raise TypeError('file must be a file-like object '
+                            'or a str, bytes, or PathLike object')
+
+        if self._mode == _MODE_READ:
+            raw = _streams.DecompressReader(
+                self._fp,
+                ZstdDecompressor,
+                zstd_dict=zstd_dict,
+                options=options,
+            )
+            self._buffer = io.BufferedReader(raw)
+
+    def close(self):
+        """Flush and close the file.
+
+        May be called multiple times. Once the file has been closed,
+        any other operation on it will raise ValueError.
+        """
+        if self._fp is None:
+            return
+        try:
+            if self._mode == _MODE_READ:
+                if getattr(self, '_buffer', None):
+                    self._buffer.close()
+                    self._buffer = None
+            elif self._mode == _MODE_WRITE:
+                self.flush(self.FLUSH_FRAME)
+                self._compressor = None
+        finally:
+            self._mode = _MODE_CLOSED
+            try:
+                if self._close_fp:
+                    self._fp.close()
+            finally:
+                self._fp = None
+                self._close_fp = False
+
+    def write(self, data, /):
+        """Write a bytes-like object *data* to the file.
+
+        Returns the number of uncompressed bytes written, which is
+        always the length of data in bytes. Note that due to buffering,
+        the file on disk may not reflect the data written until .flush()
+        or .close() is called.
+        """
+        self._check_can_write()
+
+        length = _nbytes(data)
+
+        compressed = self._compressor.compress(data)
+        self._fp.write(compressed)
+        self._pos += length
+        return length
+
+    def flush(self, mode=FLUSH_BLOCK):
+        """Flush remaining data to the underlying stream.
+
+        The mode argument can be FLUSH_BLOCK or FLUSH_FRAME. Abuse of this
+        method will reduce compression ratio, use it only when necessary.
+
+        If the program is interrupted afterwards, all data can be recovered.
+        To ensure saving to disk, also need to use os.fsync(fd).
+
+        This method does nothing in reading mode.
+        """
+        if self._mode == _MODE_READ:
+            return
+        self._check_not_closed()
+        if mode not in {self.FLUSH_BLOCK, self.FLUSH_FRAME}:
+            raise ValueError('Invalid mode argument, expected either '
+                             'ZstdFile.FLUSH_FRAME or '
+                             'ZstdFile.FLUSH_BLOCK')
+        if self._compressor.last_mode == mode:
+            return
+        # Flush zstd block/frame, and write.
+        data = self._compressor.flush(mode)
+        self._fp.write(data)
+        if hasattr(self._fp, 'flush'):
+            self._fp.flush()
+
+    def read(self, size=-1):
+        """Read up to size uncompressed bytes from the file.
+
+        If size is negative or omitted, read until EOF is reached.
+        Returns b'' if the file is already at EOF.
+        """
+        if size is None:
+            size = -1
+        self._check_can_read()
+        return self._buffer.read(size)
+
+    def read1(self, size=-1):
+        """Read up to size uncompressed bytes, while trying to avoid
+        making multiple reads from the underlying stream. Reads up to a
+        buffer's worth of data if size is negative.
+
+        Returns b'' if the file is at EOF.
+        """
+        self._check_can_read()
+        if size < 0:
+            # Note this should *not* be io.DEFAULT_BUFFER_SIZE.
+            # ZSTD_DStreamOutSize is the minimum amount to read guaranteeing
+            # a full block is read.
+            size = ZSTD_DStreamOutSize
+        return self._buffer.read1(size)
+
+    def readinto(self, b):
+        """Read bytes into b.
+
+        Returns the number of bytes read (0 for EOF).
+        """
+        self._check_can_read()
+        return self._buffer.readinto(b)
+
+    def readinto1(self, b):
+        """Read bytes into b, while trying to avoid making multiple reads
+        from the underlying stream.
+
+        Returns the number of bytes read (0 for EOF).
+        """
+        self._check_can_read()
+        return self._buffer.readinto1(b)
+
+    def readline(self, size=-1):
+        """Read a line of uncompressed bytes from the file.
+
+        The terminating newline (if present) is retained. If size is
+        non-negative, no more than size bytes will be read (in which
+        case the line may be incomplete). Returns b'' if already at EOF.
+        """
+        self._check_can_read()
+        return self._buffer.readline(size)
+
+    def seek(self, offset, whence=io.SEEK_SET):
+        """Change the file position.
+
+        The new position is specified by offset, relative to the
+        position indicated by whence. Possible values for whence are:
+
+            0: start of stream (default): offset must not be negative
+            1: current stream position
+            2: end of stream; offset must not be positive
+
+        Returns the new file position.
+
+        Note that seeking is emulated, so depending on the arguments,
+        this operation may be extremely slow.
+        """
+        self._check_can_read()
+
+        # BufferedReader.seek() checks seekable
+        return self._buffer.seek(offset, whence)
+
+    def peek(self, size=-1):
+        """Return buffered data without advancing the file position.
+
+        Always returns at least one byte of data, unless at EOF.
+        The exact number of bytes returned is unspecified.
+        """
+        # Relies on the undocumented fact that BufferedReader.peek() always
+        # returns at least one byte (except at EOF)
+        self._check_can_read()
+        return self._buffer.peek(size)
+
+    def __next__(self):
+        if ret := self._buffer.readline():
+            return ret
+        raise StopIteration
+
+    def tell(self):
+        """Return the current file position."""
+        self._check_not_closed()
+        if self._mode == _MODE_READ:
+            return self._buffer.tell()
+        elif self._mode == _MODE_WRITE:
+            return self._pos
+
+    def fileno(self):
+        """Return the file descriptor for the underlying file."""
+        self._check_not_closed()
+        return self._fp.fileno()
+
+    @property
+    def name(self):
+        self._check_not_closed()
+        return self._fp.name
+
+    @property
+    def mode(self):
+        return 'wb' if self._mode == _MODE_WRITE else 'rb'
+
+    @property
+    def closed(self):
+        """True if this file is closed."""
+        return self._mode == _MODE_CLOSED
+
+    def seekable(self):
+        """Return whether the file supports seeking."""
+        return self.readable() and self._buffer.seekable()
+
+    def readable(self):
+        """Return whether the file was opened for reading."""
+        self._check_not_closed()
+        return self._mode == _MODE_READ
+
+    def writable(self):
+        """Return whether the file was opened for writing."""
+        self._check_not_closed()
+        return self._mode == _MODE_WRITE
+
+
+def open(file, /, mode='rb', *, level=None, options=None, zstd_dict=None,
+         encoding=None, errors=None, newline=None):
+    """Open a Zstandard compressed file in binary or text mode.
+
+    file can be either a file name (given as a str, bytes, or PathLike object),
+    in which case the named file is opened, or it can be an existing file object
+    to read from or write to.
+
+    The mode parameter can be 'r', 'rb' (default), 'w', 'wb', 'x', 'xb', 'a',
+    'ab' for binary mode, or 'rt', 'wt', 'xt', 'at' for text mode.
+
+    The level, options, and zstd_dict parameters specify the settings the same
+    as ZstdFile.
+
+    When using read mode (decompression), the options parameter is a dict
+    representing advanced decompression options. The level parameter is not
+    supported in this case. When using write mode (compression), only one of
+    level, an int representing the compression level, or options, a dict
+    representing advanced compression options, may be passed. In both modes,
+    zstd_dict is a ZstdDict instance containing a trained Zstandard dictionary.
+
+    For binary mode, this function is equivalent to the ZstdFile constructor:
+    ZstdFile(filename, mode, ...). In this case, the encoding, errors and
+    newline parameters must not be provided.
+
+    For text mode, an ZstdFile object is created, and wrapped in an
+    io.TextIOWrapper instance with the specified encoding, error handling
+    behavior, and line ending(s).
+    """
+
+    text_mode = 't' in mode
+    mode = mode.replace('t', '')
+
+    if text_mode:
+        if 'b' in mode:
+            raise ValueError(f'Invalid mode: {mode!r}')
+    else:
+        if encoding is not None:
+            raise ValueError('Argument "encoding" not supported in binary mode')
+        if errors is not None:
+            raise ValueError('Argument "errors" not supported in binary mode')
+        if newline is not None:
+            raise ValueError('Argument "newline" not supported in binary mode')
+
+    binary_file = ZstdFile(file, mode, level=level, options=options,
+                           zstd_dict=zstd_dict)
+
+    if text_mode:
+        return io.TextIOWrapper(binary_file, encoding, errors, newline)
+    else:
+        return binary_file
diff --git a/Lib/gzip.py b/Lib/gzip.py
index a550c20a7a0..c00f51858de 100644
--- a/Lib/gzip.py
+++ b/Lib/gzip.py
@@ -5,7 +5,6 @@
 
 # based on Andrew Kuchling's minigzip.py distributed with the zlib module
 
-import _compression
 import builtins
 import io
 import os
@@ -14,6 +13,7 @@
 import time
 import weakref
 import zlib
+from compression._common import _streams
 
 __all__ = ["BadGzipFile", "GzipFile", "open", "compress", "decompress"]
 
@@ -144,7 +144,7 @@ def writable(self):
         return True
 
 
-class GzipFile(_compression.BaseStream):
+class GzipFile(_streams.BaseStream):
     """The GzipFile class simulates most of the methods of a file object with
     the exception of the truncate() method.
 
@@ -193,6 +193,11 @@ def __init__(self, filename=None, mode=None,
 
         """
 
+        # Ensure attributes exist at __del__
+        self.mode = None
+        self.fileobj = None
+        self._buffer = None
+
         if mode and ('t' in mode or 'U' in mode):
             raise ValueError("Invalid mode: {!r}".format(mode))
         if mode and 'b' not in mode:
@@ -332,11 +337,15 @@ def _write_raw(self, data):
 
         return length
 
-    def read(self, size=-1):
-        self._check_not_closed()
+    def _check_read(self, caller):
         if self.mode != READ:
             import errno
-            raise OSError(errno.EBADF, "read() on write-only GzipFile object")
+            msg = f"{caller}() on write-only GzipFile object"
+            raise OSError(errno.EBADF, msg)
+
+    def read(self, size=-1):
+        self._check_not_closed()
+        self._check_read("read")
         return self._buffer.read(size)
 
     def read1(self, size=-1):
@@ -344,19 +353,25 @@ def read1(self, size=-1):
 
         Reads up to a buffer's worth of data if size is negative."""
         self._check_not_closed()
-        if self.mode != READ:
-            import errno
-            raise OSError(errno.EBADF, "read1() on write-only GzipFile object")
+        self._check_read("read1")
 
         if size < 0:
             size = io.DEFAULT_BUFFER_SIZE
         return self._buffer.read1(size)
 
+    def readinto(self, b):
+        self._check_not_closed()
+        self._check_read("readinto")
+        return self._buffer.readinto(b)
+
+    def readinto1(self, b):
+        self._check_not_closed()
+        self._check_read("readinto1")
+        return self._buffer.readinto1(b)
+
     def peek(self, n):
         self._check_not_closed()
-        if self.mode != READ:
-            import errno
-            raise OSError(errno.EBADF, "peek() on write-only GzipFile object")
+        self._check_read("peek")
         return self._buffer.peek(n)
 
     @property
@@ -365,7 +380,9 @@ def closed(self):
 
     def close(self):
         fileobj = self.fileobj
-        if fileobj is None or self._buffer.closed:
+        if fileobj is None:
+            return
+        if self._buffer is None or self._buffer.closed:
             return
         try:
             if self.mode == WRITE:
@@ -445,6 +462,13 @@ def readline(self, size=-1):
         self._check_not_closed()
         return self._buffer.readline(size)
 
+    def __del__(self):
+        if self.mode == WRITE and not self.closed:
+            import warnings
+            warnings.warn("unclosed GzipFile",
+                          ResourceWarning, source=self, stacklevel=2)
+
+        super().__del__()
 
 def _read_exact(fp, n):
     '''Read exactly *n* bytes from `fp`
@@ -499,7 +523,7 @@ def _read_gzip_header(fp):
     return last_mtime
 
 
-class _GzipReader(_compression.DecompressReader):
+class _GzipReader(_streams.DecompressReader):
     def __init__(self, fp):
         super().__init__(_PaddedFile(fp), zlib._ZlibDecompressor,
                          wbits=-zlib.MAX_WBITS)
@@ -597,12 +621,12 @@ def _rewind(self):
         self._new_member = True
 
 
-def compress(data, compresslevel=_COMPRESS_LEVEL_BEST, *, mtime=None):
+def compress(data, compresslevel=_COMPRESS_LEVEL_BEST, *, mtime=0):
     """Compress data in one shot and return the compressed string.
 
     compresslevel sets the compression level in range of 0-9.
-    mtime can be used to set the modification time. The modification time is
-    set to the current time by default.
+    mtime can be used to set the modification time.
+    The modification time is set to 0 by default, for reproducibility.
     """
     # Wbits=31 automatically includes a gzip header and trailer.
     gzip_data = zlib.compress(data, level=compresslevel, wbits=31)
@@ -643,7 +667,9 @@ def main():
     from argparse import ArgumentParser
     parser = ArgumentParser(description=
         "A simple command line interface for the gzip module: act like gzip, "
-        "but do not delete the input file.")
+        "but do not delete the input file.",
+        color=True,
+    )
     group = parser.add_mutually_exclusive_group()
     group.add_argument('--fast', action='store_true', help='compress faster')
     group.add_argument('--best', action='store_true', help='compress better')
diff --git a/Lib/lzma.py b/Lib/lzma.py
index c1e3d33deb6..316066d024e 100644
--- a/Lib/lzma.py
+++ b/Lib/lzma.py
@@ -24,9 +24,9 @@
 import builtins
 import io
 import os
+from compression._common import _streams
 from _lzma import *
-from _lzma import _encode_filter_properties, _decode_filter_properties
-import _compression
+from _lzma import _encode_filter_properties, _decode_filter_properties  # noqa: F401
 
 
 # Value 0 no longer used
@@ -35,7 +35,7 @@
 _MODE_WRITE    = 3
 
 
-class LZMAFile(_compression.BaseStream):
+class LZMAFile(_streams.BaseStream):
 
     """A file object providing transparent LZMA (de)compression.
 
@@ -127,7 +127,7 @@ def __init__(self, filename=None, mode="r", *,
             raise TypeError("filename must be a str, bytes, file or PathLike object")
 
         if self._mode == _MODE_READ:
-            raw = _compression.DecompressReader(self._fp, LZMADecompressor,
+            raw = _streams.DecompressReader(self._fp, LZMADecompressor,
                 trailing_error=LZMAError, format=format, filters=filters)
             self._buffer = io.BufferedReader(raw)
 
diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
index 3617eba8e8d..26b5e79d337 100644
--- a/Lib/test/test_bz2.py
+++ b/Lib/test/test_bz2.py
@@ -16,7 +16,7 @@
 from test.support import import_helper
 from test.support import threading_helper
 from test.support.os_helper import unlink, FakePath
-import _compression
+from compression._common import _streams
 import sys
 
 
@@ -126,15 +126,15 @@ def testReadMultiStream(self):
     def testReadMonkeyMultiStream(self):
         # Test BZ2File.read() on a multi-stream archive where a stream
         # boundary coincides with the end of the raw read buffer.
-        buffer_size = _compression.BUFFER_SIZE
-        _compression.BUFFER_SIZE = len(self.DATA)
+        buffer_size = _streams.BUFFER_SIZE
+        _streams.BUFFER_SIZE = len(self.DATA)
         try:
             self.createTempFile(streams=5)
             with BZ2File(self.filename) as bz2f:
                 self.assertRaises(TypeError, bz2f.read, float())
                 self.assertEqual(bz2f.read(), self.TEXT * 5)
         finally:
-            _compression.BUFFER_SIZE = buffer_size
+            _streams.BUFFER_SIZE = buffer_size
 
     def testReadTrailingJunk(self):
         self.createTempFile(suffix=self.BAD_DATA)
@@ -184,7 +184,7 @@ def testPeek(self):
         with BZ2File(self.filename) as bz2f:
             pdata = bz2f.peek()
             self.assertNotEqual(len(pdata), 0)
-            self.assertTrue(self.TEXT.startswith(pdata))
+            self.assertStartsWith(self.TEXT, pdata)
             self.assertEqual(bz2f.read(), self.TEXT)
 
     def testReadInto(self):
@@ -730,8 +730,7 @@ def testOpenBytesFilename(self):
             self.assertEqual(f.read(), self.DATA)
             self.assertEqual(f.name, str_filename)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testOpenPathLikeFilename(self):
         filename = FakePath(self.filename)
         with BZ2File(filename, "wb") as f:
@@ -744,7 +743,7 @@ def testOpenPathLikeFilename(self):
     def testDecompressLimited(self):
         """Decompressed data buffering should be limited"""
         bomb = bz2.compress(b'\0' * int(2e6), compresslevel=9)
-        self.assertLess(len(bomb), _compression.BUFFER_SIZE)
+        self.assertLess(len(bomb), _streams.BUFFER_SIZE)
 
         decomp = BZ2File(BytesIO(bomb))
         self.assertEqual(decomp.read(1), b'\0')
@@ -770,7 +769,7 @@ def testPeekBytesIO(self):
             with BZ2File(bio) as bz2f:
                 pdata = bz2f.peek()
                 self.assertNotEqual(len(pdata), 0)
-                self.assertTrue(self.TEXT.startswith(pdata))
+                self.assertStartsWith(self.TEXT, pdata)
                 self.assertEqual(bz2f.read(), self.TEXT)
 
     def testWriteBytesIO(self):
@@ -1190,8 +1189,7 @@ def test_encoding_error_handler(self):
                 as f:
             self.assertEqual(f.read(), "foobar")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline(self):
         # Test with explicit newline (universal newline mode disabled).
         text = self.TEXT.decode("ascii")
diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py
index b0d9613cdbd..4a8813c4da1 100644
--- a/Lib/test/test_gzip.py
+++ b/Lib/test/test_gzip.py
@@ -9,6 +9,7 @@
 import struct
 import sys
 import unittest
+import warnings
 from subprocess import PIPE, Popen
 from test.support import catch_unraisable_exception
 from test.support import import_helper
@@ -143,6 +144,38 @@ def test_read1(self):
                 self.assertEqual(f.tell(), nread)
         self.assertEqual(b''.join(blocks), data1 * 50)
 
+    def test_readinto(self):
+        # 10MB of uncompressible data to ensure multiple reads
+        large_data = os.urandom(10 * 2**20)
+        with gzip.GzipFile(self.filename, 'wb') as f:
+            f.write(large_data)
+
+        buf = bytearray(len(large_data))
+        with gzip.GzipFile(self.filename, 'r') as f:
+            nbytes = f.readinto(buf)
+        self.assertEqual(nbytes, len(large_data))
+        self.assertEqual(buf, large_data)
+
+    def test_readinto1(self):
+        # 10MB of uncompressible data to ensure multiple reads
+        large_data = os.urandom(10 * 2**20)
+        with gzip.GzipFile(self.filename, 'wb') as f:
+            f.write(large_data)
+
+        nread = 0
+        buf = bytearray(len(large_data))
+        memview = memoryview(buf)  # Simplifies slicing
+        with gzip.GzipFile(self.filename, 'r') as f:
+            for count in range(200):
+                nbytes = f.readinto1(memview[nread:])
+                if not nbytes:
+                    break
+                nread += nbytes
+                self.assertEqual(f.tell(), nread)
+        self.assertEqual(buf, large_data)
+        # readinto1() should require multiple loops
+        self.assertGreater(count, 1)
+
     @bigmemtest(size=_4G, memuse=1)
     def test_read_large(self, size):
         # Read chunk size over UINT_MAX should be supported, despite zlib's
@@ -298,13 +331,13 @@ def test_mode(self):
     def test_1647484(self):
         for mode in ('wb', 'rb'):
             with gzip.GzipFile(self.filename, mode) as f:
-                self.assertTrue(hasattr(f, "name"))
+                self.assertHasAttr(f, "name")
                 self.assertEqual(f.name, self.filename)
 
     def test_paddedfile_getattr(self):
         self.test_write()
         with gzip.GzipFile(self.filename, 'rb') as f:
-            self.assertTrue(hasattr(f.fileobj, "name"))
+            self.assertHasAttr(f.fileobj, "name")
             self.assertEqual(f.fileobj.name, self.filename)
 
     def test_mtime(self):
@@ -312,7 +345,7 @@ def test_mtime(self):
         with gzip.GzipFile(self.filename, 'w', mtime = mtime) as fWrite:
             fWrite.write(data1)
         with gzip.GzipFile(self.filename) as fRead:
-            self.assertTrue(hasattr(fRead, 'mtime'))
+            self.assertHasAttr(fRead, 'mtime')
             self.assertIsNone(fRead.mtime)
             dataRead = fRead.read()
             self.assertEqual(dataRead, data1)
@@ -427,7 +460,7 @@ def test_zero_padded_file(self):
             self.assertEqual(d, data1 * 50, "Incorrect data in file")
 
     def test_gzip_BadGzipFile_exception(self):
-        self.assertTrue(issubclass(gzip.BadGzipFile, OSError))
+        self.assertIsSubclass(gzip.BadGzipFile, OSError)
 
     def test_bad_gzip_file(self):
         with open(self.filename, 'wb') as file:
@@ -715,6 +748,17 @@ def test_compress_mtime(self):
                         f.read(1) # to set mtime attribute
                         self.assertEqual(f.mtime, mtime)
 
+    def test_compress_mtime_default(self):
+        # test for gh-125260
+        datac = gzip.compress(data1, mtime=0)
+        datac2 = gzip.compress(data1)
+        self.assertEqual(datac, datac2)
+        datac3 = gzip.compress(data1, mtime=None)
+        self.assertNotEqual(datac, datac3)
+        with gzip.GzipFile(fileobj=io.BytesIO(datac3), mode="rb") as f:
+            f.read(1) # to set mtime attribute
+            self.assertGreater(f.mtime, 1)
+
     def test_compress_correct_level(self):
         for mtime in (0, 42):
             with self.subTest(mtime=mtime):
@@ -856,9 +900,10 @@ def test_refloop_unraisable(self):
         # fileobj would be closed before the GzipFile as the result of a
         # reference loop. See issue gh-129726
         with catch_unraisable_exception() as cm:
-            gzip.GzipFile(fileobj=io.BytesIO(), mode="w")
-            gc.collect()
-            self.assertIsNone(cm.unraisable)
+            with self.assertWarns(ResourceWarning):
+                gzip.GzipFile(fileobj=io.BytesIO(), mode="w")
+                gc.collect()
+                self.assertIsNone(cm.unraisable)
 
 
 class TestOpen(BaseTest):
@@ -991,8 +1036,7 @@ def test_encoding_error_handler(self):
                 as f:
             self.assertEqual(f.read(), "foobar")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline(self):
         # Test with explicit newline (universal newline mode disabled).
         uncompressed = data1.decode("ascii") * 50
diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
index 4010ef9c340..1bfc9551ce3 100644
--- a/Lib/test/test_lzma.py
+++ b/Lib/test/test_lzma.py
@@ -1,4 +1,3 @@
-import _compression
 import array
 from io import BytesIO, UnsupportedOperation, DEFAULT_BUFFER_SIZE
 import os
@@ -7,6 +6,7 @@
 import sys
 from test import support
 import unittest
+from compression._common import _streams
 
 from test.support import _4G, bigmemtest
 from test.support.import_helper import import_module
@@ -22,8 +22,7 @@ class CompressorDecompressorTestCase(unittest.TestCase):
 
     # Test error cases.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple_bad_args(self):
         self.assertRaises(TypeError, LZMACompressor, [])
         self.assertRaises(TypeError, LZMACompressor, format=3.45)
@@ -64,8 +63,7 @@ def test_simple_bad_args(self):
         lzd.decompress(empty)
         self.assertRaises(EOFError, lzd.decompress, b"quux")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_filter_spec(self):
         self.assertRaises(TypeError, LZMACompressor, filters=[b"wobsite"])
         self.assertRaises(ValueError, LZMACompressor, filters=[{"xyzzy": 3}])
@@ -82,8 +80,7 @@ def test_decompressor_after_eof(self):
         lzd.decompress(COMPRESSED_XZ)
         self.assertRaises(EOFError, lzd.decompress, b"nyan")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_memlimit(self):
         lzd = LZMADecompressor(memlimit=1024)
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
@@ -104,8 +101,7 @@ def _test_decompressor(self, lzd, data, check, unused_data=b""):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, unused_data)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_auto(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
@@ -113,44 +109,37 @@ def test_decompressor_auto(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_xz(self):
         lzd = LZMADecompressor(lzma.FORMAT_XZ)
         self._test_decompressor(lzd, COMPRESSED_XZ, lzma.CHECK_CRC64)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_alone(self):
         lzd = LZMADecompressor(lzma.FORMAT_ALONE)
         self._test_decompressor(lzd, COMPRESSED_ALONE, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_raw_1(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
         self._test_decompressor(lzd, COMPRESSED_RAW_1, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_raw_2(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
         self._test_decompressor(lzd, COMPRESSED_RAW_2, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_raw_3(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
         self._test_decompressor(lzd, COMPRESSED_RAW_3, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_raw_4(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self._test_decompressor(lzd, COMPRESSED_RAW_4, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_chunks(self):
         lzd = LZMADecompressor()
         out = []
@@ -163,8 +152,7 @@ def test_decompressor_chunks(self):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, b"")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_chunks_empty(self):
         lzd = LZMADecompressor()
         out = []
@@ -180,8 +168,7 @@ def test_decompressor_chunks_empty(self):
         self.assertTrue(lzd.eof)
         self.assertEqual(lzd.unused_data, b"")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_chunks_maxsize(self):
         lzd = LZMADecompressor()
         max_length = 100
@@ -273,16 +260,14 @@ def test_decompressor_inputbuf_3(self):
         out.append(lzd.decompress(COMPRESSED_XZ[300:]))
         self.assertEqual(b''.join(out), INPUT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_unused_data(self):
         lzd = LZMADecompressor()
         extra = b"fooblibar"
         self._test_decompressor(lzd, COMPRESSED_XZ + extra, lzma.CHECK_CRC64,
                                 unused_data=extra)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_bad_input(self):
         lzd = LZMADecompressor()
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_RAW_1)
@@ -296,8 +281,7 @@ def test_decompressor_bad_input(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
         self.assertRaises(LZMAError, lzd.decompress, COMPRESSED_XZ)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_bug_28275(self):
         # Test coverage for Issue 28275
         lzd = LZMADecompressor()
@@ -307,32 +291,28 @@ def test_decompressor_bug_28275(self):
 
     # Test that LZMACompressor->LZMADecompressor preserves the input data.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_xz(self):
         lzc = LZMACompressor()
         cdata = lzc.compress(INPUT) + lzc.flush()
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_alone(self):
         lzc = LZMACompressor(lzma.FORMAT_ALONE)
         cdata = lzc.compress(INPUT) + lzc.flush()
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_raw(self):
         lzc = LZMACompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         cdata = lzc.compress(INPUT) + lzc.flush()
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_raw_empty(self):
         lzc = LZMACompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         cdata = lzc.compress(INPUT)
@@ -343,8 +323,7 @@ def test_roundtrip_raw_empty(self):
         lzd = LZMADecompressor(lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self._test_decompressor(lzd, cdata, lzma.CHECK_NONE)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_chunks(self):
         lzc = LZMACompressor()
         cdata = []
@@ -355,8 +334,7 @@ def test_roundtrip_chunks(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, cdata, lzma.CHECK_CRC64)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_empty_chunks(self):
         lzc = LZMACompressor()
         cdata = []
@@ -372,8 +350,7 @@ def test_roundtrip_empty_chunks(self):
 
     # LZMADecompressor intentionally does not handle concatenated streams.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompressor_multistream(self):
         lzd = LZMADecompressor()
         self._test_decompressor(lzd, COMPRESSED_XZ + COMPRESSED_ALONE,
@@ -434,8 +411,7 @@ class CompressDecompressFunctionTestCase(unittest.TestCase):
 
     # Test error cases:
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_args(self):
         self.assertRaises(TypeError, lzma.compress)
         self.assertRaises(TypeError, lzma.compress, [])
@@ -463,24 +439,22 @@ def test_bad_args(self):
             lzma.decompress(b"", format=lzma.FORMAT_XZ, filters=FILTERS_RAW_1)
         with self.assertRaises(ValueError):
             lzma.decompress(
-                b"", format=lzma.FORMAT_ALONE, filters=FILTERS_RAW_1)
+                    b"", format=lzma.FORMAT_ALONE, filters=FILTERS_RAW_1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_memlimit(self):
         with self.assertRaises(LZMAError):
             lzma.decompress(COMPRESSED_XZ, memlimit=1024)
         with self.assertRaises(LZMAError):
             lzma.decompress(
-                COMPRESSED_XZ, format=lzma.FORMAT_XZ, memlimit=1024)
+                    COMPRESSED_XZ, format=lzma.FORMAT_XZ, memlimit=1024)
         with self.assertRaises(LZMAError):
             lzma.decompress(
-                COMPRESSED_ALONE, format=lzma.FORMAT_ALONE, memlimit=1024)
+                    COMPRESSED_ALONE, format=lzma.FORMAT_ALONE, memlimit=1024)
 
     # Test LZMADecompressor on known-good input data.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_good_input(self):
         ddata = lzma.decompress(COMPRESSED_XZ)
         self.assertEqual(ddata, INPUT)
@@ -495,23 +469,22 @@ def test_decompress_good_input(self):
         self.assertEqual(ddata, INPUT)
 
         ddata = lzma.decompress(
-            COMPRESSED_RAW_1, lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
+                COMPRESSED_RAW_1, lzma.FORMAT_RAW, filters=FILTERS_RAW_1)
         self.assertEqual(ddata, INPUT)
 
         ddata = lzma.decompress(
-            COMPRESSED_RAW_2, lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
+                COMPRESSED_RAW_2, lzma.FORMAT_RAW, filters=FILTERS_RAW_2)
         self.assertEqual(ddata, INPUT)
 
         ddata = lzma.decompress(
-            COMPRESSED_RAW_3, lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
+                COMPRESSED_RAW_3, lzma.FORMAT_RAW, filters=FILTERS_RAW_3)
         self.assertEqual(ddata, INPUT)
 
         ddata = lzma.decompress(
-            COMPRESSED_RAW_4, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
+                COMPRESSED_RAW_4, lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
         self.assertEqual(ddata, INPUT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_incomplete_input(self):
         self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_XZ[:128])
         self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_ALONE[:128])
@@ -524,8 +497,7 @@ def test_decompress_incomplete_input(self):
         self.assertRaises(LZMAError, lzma.decompress, COMPRESSED_RAW_4[:128],
                           format=lzma.FORMAT_RAW, filters=FILTERS_RAW_4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_bad_input(self):
         with self.assertRaises(LZMAError):
             lzma.decompress(COMPRESSED_BOGUS)
@@ -541,8 +513,7 @@ def test_decompress_bad_input(self):
 
     # Test that compress()->decompress() preserves the input data.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip(self):
         cdata = lzma.compress(INPUT)
         ddata = lzma.decompress(cdata)
@@ -568,14 +539,12 @@ def test_decompress_multistream(self):
 
     # Test robust handling of non-LZMA data following the compressed stream(s).
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_trailing_junk(self):
         ddata = lzma.decompress(COMPRESSED_XZ + COMPRESSED_BOGUS)
         self.assertEqual(ddata, INPUT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decompress_multistream_trailing_junk(self):
         ddata = lzma.decompress(COMPRESSED_XZ * 3 + COMPRESSED_BOGUS)
         self.assertEqual(ddata, INPUT * 3)
@@ -612,8 +581,7 @@ def test_init(self):
             self.assertIsInstance(f, LZMAFile)
             self.assertEqual(f.mode, "wb")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_with_PathLike_filename(self):
         filename = FakePath(TESTFN)
         with TempFile(filename, COMPRESSED_XZ):
@@ -694,8 +662,7 @@ def test_init_bad_mode(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), "rw")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_bad_check(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", check=b"asd")
@@ -716,6 +683,7 @@ def test_init_bad_check(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), check=lzma.CHECK_UNKNOWN)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_bad_preset(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", preset=4.39)
@@ -723,18 +691,19 @@ def test_init_bad_preset(self):
             LZMAFile(BytesIO(), "w", preset=10)
         with self.assertRaises(LZMAError):
             LZMAFile(BytesIO(), "w", preset=23)
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(ValueError):
             LZMAFile(BytesIO(), "w", preset=-1)
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(ValueError):
             LZMAFile(BytesIO(), "w", preset=-7)
+        with self.assertRaises(OverflowError):
+            LZMAFile(BytesIO(), "w", preset=2**1000)
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", preset="foo")
         # Cannot specify a preset with mode="r".
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(COMPRESSED_XZ), preset=3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_bad_filter_spec(self):
         with self.assertRaises(TypeError):
             LZMAFile(BytesIO(), "w", filters=[b"wobsite"])
@@ -752,8 +721,7 @@ def test_init_bad_filter_spec(self):
             LZMAFile(BytesIO(), "w",
                      filters=[{"id": lzma.FILTER_X86, "foo": 0}])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_with_preset_and_filters(self):
         with self.assertRaises(ValueError):
             LZMAFile(BytesIO(), "w", format=lzma.FORMAT_RAW,
@@ -872,8 +840,7 @@ def test_writable(self):
             f.close()
         self.assertRaises(ValueError, f.writable)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             self.assertEqual(f.read(), INPUT)
@@ -921,8 +888,7 @@ def test_read_10(self):
                 chunks.append(result)
             self.assertEqual(b"".join(chunks), INPUT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_multistream(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ * 5)) as f:
             self.assertEqual(f.read(), INPUT * 5)
@@ -935,22 +901,20 @@ def test_read_multistream(self):
     def test_read_multistream_buffer_size_aligned(self):
         # Test the case where a stream boundary coincides with the end
         # of the raw read buffer.
-        saved_buffer_size = _compression.BUFFER_SIZE
-        _compression.BUFFER_SIZE = len(COMPRESSED_XZ)
+        saved_buffer_size = _streams.BUFFER_SIZE
+        _streams.BUFFER_SIZE = len(COMPRESSED_XZ)
         try:
             with LZMAFile(BytesIO(COMPRESSED_XZ *  5)) as f:
                 self.assertEqual(f.read(), INPUT * 5)
         finally:
-            _compression.BUFFER_SIZE = saved_buffer_size
+            _streams.BUFFER_SIZE = saved_buffer_size
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_trailing_junk(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ + COMPRESSED_BOGUS)) as f:
             self.assertEqual(f.read(), INPUT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_multistream_trailing_junk(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ * 5 + COMPRESSED_BOGUS)) as f:
             self.assertEqual(f.read(), INPUT * 5)
@@ -1056,8 +1020,7 @@ def test_read_bad_args(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             self.assertRaises(TypeError, f.read, float())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_bad_data(self):
         with LZMAFile(BytesIO(COMPRESSED_BOGUS)) as f:
             self.assertRaises(LZMAError, f.read)
@@ -1103,20 +1066,19 @@ def test_peek(self):
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             result = f.peek()
             self.assertGreater(len(result), 0)
-            self.assertTrue(INPUT.startswith(result))
+            self.assertStartsWith(INPUT, result)
             self.assertEqual(f.read(), INPUT)
         with LZMAFile(BytesIO(COMPRESSED_XZ)) as f:
             result = f.peek(10)
             self.assertGreater(len(result), 0)
-            self.assertTrue(INPUT.startswith(result))
+            self.assertStartsWith(INPUT, result)
             self.assertEqual(f.read(), INPUT)
 
     def test_peek_bad_args(self):
         with LZMAFile(BytesIO(), "w") as f:
             self.assertRaises(ValueError, f.peek)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_iterator(self):
         with BytesIO(INPUT) as f:
             lines = f.readlines()
@@ -1148,16 +1110,15 @@ def test_readlines(self):
     def test_decompress_limited(self):
         """Decompressed data buffering should be limited"""
         bomb = lzma.compress(b'\0' * int(2e6), preset=6)
-        self.assertLess(len(bomb), _compression.BUFFER_SIZE)
+        self.assertLess(len(bomb), _streams.BUFFER_SIZE)
 
         decomp = LZMAFile(BytesIO(bomb))
         self.assertEqual(decomp.read(1), b'\0')
         max_decomp = 1 + DEFAULT_BUFFER_SIZE
         self.assertLessEqual(decomp._buffer.raw.tell(), max_decomp,
-                             "Excessive amount of data was decompressed")
+            "Excessive amount of data was decompressed")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write(self):
         with BytesIO() as dst:
             with LZMAFile(dst, "w") as f:
@@ -1426,8 +1387,7 @@ def test_tell_bad_args(self):
         f.close()
         self.assertRaises(ValueError, f.tell)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue21872(self):
         # sometimes decompress data incompletely
 
@@ -1511,8 +1471,7 @@ def test_filename(self):
             with lzma.open(TESTFN, "rb") as f:
                 self.assertEqual(f.read(), INPUT * 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_with_pathlike_filename(self):
         filename = FakePath(TESTFN)
         with TempFile(filename):
@@ -1539,8 +1498,7 @@ def test_bad_params(self):
         with self.assertRaises(ValueError):
             lzma.open(TESTFN, "rb", newline="\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_format_and_filters(self):
         # Test non-default format and filter chain.
         options = {"format": lzma.FORMAT_RAW, "filters": FILTERS_RAW_1}
@@ -1571,8 +1529,7 @@ def test_encoding_error_handler(self):
             with lzma.open(bio, "rt", encoding="ascii", errors="ignore") as f:
                 self.assertEqual(f.read(), "foobar")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline(self):
         # Test with explicit newline (universal newline mode disabled).
         text = INPUT.decode("ascii")
@@ -1597,8 +1554,7 @@ def test_x_mode(self):
 
 class MiscellaneousTestCase(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_is_check_supported(self):
         # CHECK_NONE and CHECK_CRC32 should always be supported,
         # regardless of the options liblzma was compiled with.
@@ -1611,8 +1567,7 @@ def test_is_check_supported(self):
         # This value should not be a valid check ID.
         self.assertFalse(lzma.is_check_supported(lzma.CHECK_UNKNOWN))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__encode_filter_properties(self):
         with self.assertRaises(TypeError):
             lzma._encode_filter_properties(b"not a dict")
@@ -1622,20 +1577,19 @@ def test__encode_filter_properties(self):
             lzma._encode_filter_properties({"id": lzma.FILTER_LZMA2, "junk": 12})
         with self.assertRaises(lzma.LZMAError):
             lzma._encode_filter_properties({"id": lzma.FILTER_DELTA,
-                                            "dist": 9001})
+                                           "dist": 9001})
 
         # Test with parameters used by zipfile module.
         props = lzma._encode_filter_properties({
-            "id": lzma.FILTER_LZMA1,
-            "pb": 2,
-            "lp": 0,
-            "lc": 3,
-            "dict_size": 8 << 20,
-        })
+                "id": lzma.FILTER_LZMA1,
+                "pb": 2,
+                "lp": 0,
+                "lc": 3,
+                "dict_size": 8 << 20,
+            })
         self.assertEqual(props, b"]\x00\x00\x80\x00")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__decode_filter_properties(self):
         with self.assertRaises(TypeError):
             lzma._decode_filter_properties(lzma.FILTER_X86, {"should be": bytes})
@@ -1644,7 +1598,7 @@ def test__decode_filter_properties(self):
 
         # Test with parameters used by zipfile module.
         filterspec = lzma._decode_filter_properties(
-            lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
+                lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
         self.assertEqual(filterspec["id"], lzma.FILTER_LZMA1)
         self.assertEqual(filterspec["pb"], 2)
         self.assertEqual(filterspec["lp"], 0)
@@ -1659,11 +1613,10 @@ def test__decode_filter_properties(self):
             filterspec = lzma._decode_filter_properties(f, b"")
             self.assertEqual(filterspec, {"id": f})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_filter_properties_roundtrip(self):
         spec1 = lzma._decode_filter_properties(
-            lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
+                lzma.FILTER_LZMA1, b"]\x00\x00\x80\x00")
         reencoded = lzma._encode_filter_properties(spec1)
         spec2 = lzma._decode_filter_properties(lzma.FILTER_LZMA1, reencoded)
         self.assertEqual(spec1, spec2)
diff --git a/Lib/test/test_zlib.py b/Lib/test/test_zlib.py
index c9f7b183408..bb1366cb21c 100644
--- a/Lib/test/test_zlib.py
+++ b/Lib/test/test_zlib.py
@@ -3,7 +3,6 @@
 from test.support import import_helper
 import binascii
 import copy
-import os
 import pickle
 import random
 import sys
@@ -13,11 +12,11 @@
 zlib = import_helper.import_module('zlib')
 
 requires_Compress_copy = unittest.skipUnless(
-    hasattr(zlib.compressobj(), "copy"),
-    'requires Compress.copy()')
+        hasattr(zlib.compressobj(), "copy"),
+        'requires Compress.copy()')
 requires_Decompress_copy = unittest.skipUnless(
-    hasattr(zlib.decompressobj(), "copy"),
-    'requires Decompress.copy()')
+        hasattr(zlib.decompressobj(), "copy"),
+        'requires Decompress.copy()')
 
 
 def _zlib_runtime_version_tuple(zlib_version=zlib.ZLIB_RUNTIME_VERSION):
@@ -154,7 +153,7 @@ def test_badcompressobj(self):
         self.assertRaises(ValueError, zlib.compressobj, 1, zlib.DEFLATED, 0)
         # specifying total bits too large causes an error
         self.assertRaises(ValueError,
-                          zlib.compressobj, 1, zlib.DEFLATED, zlib.MAX_WBITS + 1)
+                zlib.compressobj, 1, zlib.DEFLATED, zlib.MAX_WBITS + 1)
 
     def test_baddecompressobj(self):
         # verify failure on building decompress object with bad params
@@ -242,8 +241,8 @@ def test_incomplete_stream(self):
         # A useful error message is given
         x = zlib.compress(HAMLET_SCENE)
         self.assertRaisesRegex(zlib.error,
-                               "Error -5 while decompressing data: incomplete or truncated stream",
-                               zlib.decompress, x[:-1])
+            "Error -5 while decompressing data: incomplete or truncated stream",
+            zlib.decompress, x[:-1])
 
     # Memory use of the following functions takes into account overallocation
 
@@ -377,7 +376,7 @@ def test_decompinc(self, flush=False, source=None, cx=256, dcx=64):
             bufs.append(dco.decompress(combuf[i:i+dcx]))
             self.assertEqual(b'', dco.unconsumed_tail, ########
                              "(A) uct should be b'': not %d long" %
-                             len(dco.unconsumed_tail))
+                                       len(dco.unconsumed_tail))
             self.assertEqual(b'', dco.unused_data)
         if flush:
             bufs.append(dco.flush())
@@ -390,7 +389,7 @@ def test_decompinc(self, flush=False, source=None, cx=256, dcx=64):
                     break
         self.assertEqual(b'', dco.unconsumed_tail, ########
                          "(B) uct should be b'': not %d long" %
-                         len(dco.unconsumed_tail))
+                                       len(dco.unconsumed_tail))
         self.assertEqual(b'', dco.unused_data)
         self.assertEqual(data, b''.join(bufs))
         # Failure means: "decompressobj with init options failed"
@@ -419,7 +418,7 @@ def test_decompimax(self, source=None, cx=256, dcx=64):
             #max_length = 1 + len(cb)//10
             chunk = dco.decompress(cb, dcx)
             self.assertFalse(len(chunk) > dcx,
-                             'chunk too big (%d>%d)' % (len(chunk), dcx))
+                    'chunk too big (%d>%d)' % (len(chunk), dcx))
             bufs.append(chunk)
             cb = dco.unconsumed_tail
         bufs.append(dco.flush())
@@ -444,7 +443,7 @@ def test_decompressmaxlen(self, flush=False):
             max_length = 1 + len(cb)//10
             chunk = dco.decompress(cb, max_length)
             self.assertFalse(len(chunk) > max_length,
-                             'chunk too big (%d>%d)' % (len(chunk),max_length))
+                        'chunk too big (%d>%d)' % (len(chunk),max_length))
             bufs.append(chunk)
             cb = dco.unconsumed_tail
         if flush:
@@ -453,7 +452,7 @@ def test_decompressmaxlen(self, flush=False):
             while chunk:
                 chunk = dco.decompress(b'', max_length)
                 self.assertFalse(len(chunk) > max_length,
-                                 'chunk too big (%d>%d)' % (len(chunk),max_length))
+                            'chunk too big (%d>%d)' % (len(chunk),max_length))
                 bufs.append(chunk)
         self.assertEqual(data, b''.join(bufs), 'Wrong data retrieved')
 
@@ -490,8 +489,7 @@ def test_clear_unconsumed_tail(self):
         ddata += dco.decompress(dco.unconsumed_tail)
         self.assertEqual(dco.unconsumed_tail, b"")
 
-    # TODO: RUSTPYTHON: Z_BLOCK support in flate2
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Z_BLOCK support in flate2
     def test_flushes(self):
         # Test flush() with the various options, using all the
         # different levels in order to provide more variations.
@@ -633,7 +631,7 @@ def test_decompress_unused_data(self):
                         self.assertEqual(dco.unconsumed_tail, b'')
                     else:
                         data += dco.decompress(
-                            dco.unconsumed_tail + x[i : i + step], maxlen)
+                                dco.unconsumed_tail + x[i : i + step], maxlen)
                 data += dco.flush()
                 self.assertTrue(dco.eof)
                 self.assertEqual(data, source)
@@ -811,8 +809,7 @@ def test_large_unconsumed_tail(self, size):
         finally:
             comp = uncomp = data = None
 
-    # TODO: RUSTPYTHON: wbits=0 support in flate2
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; wbits=0 support in flate2
     def test_wbits(self):
         # wbits=0 only supported since zlib v1.2.3.5
         supports_wbits_0 = ZLIB_RUNTIME_VERSION_TUPLE >= (1, 2, 3, 5)
@@ -941,6 +938,7 @@ def choose_lines(source, number, seed=None, generator=random):
        Farewell.
 """
 
+
 class ZlibDecompressorTest(unittest.TestCase):
     # Test adopted from test_bz2.py
     TEXT = HAMLET_SCENE
@@ -1015,7 +1013,7 @@ def testDecompressorChunksMaxsize(self):
         # Feed some input
         len_ = len(self.BIG_DATA) - 64
         out.append(zlibd.decompress(self.BIG_DATA[:len_],
-                                    max_length=max_length))
+                                  max_length=max_length))
         self.assertFalse(zlibd.needs_input)
         self.assertEqual(len(out[-1]), max_length)
 
@@ -1026,7 +1024,7 @@ def testDecompressorChunksMaxsize(self):
 
         # Retrieve more data while providing more input
         out.append(zlibd.decompress(self.BIG_DATA[len_:],
-                                    max_length=max_length))
+                                  max_length=max_length))
         self.assertLessEqual(len(out[-1]), max_length)
 
         # Retrieve remaining uncompressed data
@@ -1046,7 +1044,7 @@ def test_decompressor_inputbuf_1(self):
 
         # Create input buffer and fill it
         self.assertEqual(zlibd.decompress(self.DATA[:100],
-                                          max_length=0), b'')
+                                        max_length=0), b'')
 
         # Retrieve some results, freeing capacity at beginning
         # of input buffer
@@ -1068,7 +1066,7 @@ def test_decompressor_inputbuf_2(self):
 
         # Create input buffer and empty it
         self.assertEqual(zlibd.decompress(self.DATA[:200],
-                                          max_length=0), b'')
+                                        max_length=0), b'')
         out.append(zlibd.decompress(b''))
 
         # Fill buffer with new data
@@ -1112,6 +1110,7 @@ def test_refleaks_in___init__(self):
             zlibd.__init__()
         self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
 
+
 class CustomInt:
     def __index__(self):
         return 100
diff --git a/Lib/test/test_zstd.py b/Lib/test/test_zstd.py
new file mode 100644
index 00000000000..cf618534add
--- /dev/null
+++ b/Lib/test/test_zstd.py
@@ -0,0 +1,2802 @@
+import array
+import gc
+import io
+import pathlib
+import random
+import re
+import os
+import unittest
+import tempfile
+import threading
+
+from test.support.import_helper import import_module
+from test.support import threading_helper
+from test.support import _1M
+from test.support import Py_GIL_DISABLED
+
+_zstd = import_module("_zstd")
+zstd = import_module("compression.zstd")
+
+from compression.zstd import (
+    open,
+    compress,
+    decompress,
+    ZstdCompressor,
+    ZstdDecompressor,
+    ZstdDict,
+    ZstdError,
+    zstd_version,
+    zstd_version_info,
+    COMPRESSION_LEVEL_DEFAULT,
+    get_frame_info,
+    get_frame_size,
+    finalize_dict,
+    train_dict,
+    CompressionParameter,
+    DecompressionParameter,
+    Strategy,
+    ZstdFile,
+)
+
+_1K = 1024
+_130_1K = 130 * _1K
+DICT_SIZE1 = 3*_1K
+
+DAT_130K_D = None
+DAT_130K_C = None
+
+DECOMPRESSED_DAT = None
+COMPRESSED_DAT = None
+
+DECOMPRESSED_100_PLUS_32KB = None
+COMPRESSED_100_PLUS_32KB = None
+
+SKIPPABLE_FRAME = None
+
+THIS_FILE_BYTES = None
+THIS_FILE_STR = None
+COMPRESSED_THIS_FILE = None
+
+COMPRESSED_BOGUS = None
+
+SAMPLES = None
+
+TRAINED_DICT = None
+
+# Cannot be deferred to setup as it is used to check whether or not to skip
+# tests
+try:
+    SUPPORT_MULTITHREADING = CompressionParameter.nb_workers.bounds() != (0, 0)
+except Exception:
+    SUPPORT_MULTITHREADING = False
+
+C_INT_MIN = -(2**31)
+C_INT_MAX = (2**31) - 1
+
+
+def setUpModule():
+    # uncompressed size 130KB, more than a zstd block.
+    # with a frame epilogue, 4 bytes checksum.
+    global DAT_130K_D
+    DAT_130K_D = bytes([random.randint(0, 127) for _ in range(130*_1K)])
+
+    global DAT_130K_C
+    DAT_130K_C = compress(DAT_130K_D, options={CompressionParameter.checksum_flag:1})
+
+    global DECOMPRESSED_DAT
+    DECOMPRESSED_DAT = b'abcdefg123456' * 1000
+
+    global COMPRESSED_DAT
+    COMPRESSED_DAT = compress(DECOMPRESSED_DAT)
+
+    global DECOMPRESSED_100_PLUS_32KB
+    DECOMPRESSED_100_PLUS_32KB = b'a' * (100 + 32*_1K)
+
+    global COMPRESSED_100_PLUS_32KB
+    COMPRESSED_100_PLUS_32KB = compress(DECOMPRESSED_100_PLUS_32KB)
+
+    global SKIPPABLE_FRAME
+    SKIPPABLE_FRAME = (0x184D2A50).to_bytes(4, byteorder='little') + \
+                      (32*_1K).to_bytes(4, byteorder='little') + \
+                      b'a' * (32*_1K)
+
+    global THIS_FILE_BYTES, THIS_FILE_STR
+    with io.open(os.path.abspath(__file__), 'rb') as f:
+        THIS_FILE_BYTES = f.read()
+        THIS_FILE_BYTES = re.sub(rb'\r?\n', rb'\n', THIS_FILE_BYTES)
+        THIS_FILE_STR = THIS_FILE_BYTES.decode('utf-8')
+
+    global COMPRESSED_THIS_FILE
+    COMPRESSED_THIS_FILE = compress(THIS_FILE_BYTES)
+
+    global COMPRESSED_BOGUS
+    COMPRESSED_BOGUS = DECOMPRESSED_DAT
+
+    # dict data
+    words = [b'red', b'green', b'yellow', b'black', b'withe', b'blue',
+             b'lilac', b'purple', b'navy', b'glod', b'silver', b'olive',
+             b'dog', b'cat', b'tiger', b'lion', b'fish', b'bird']
+    lst = []
+    for i in range(300):
+        sample = [b'%s = %d' % (random.choice(words), random.randrange(100))
+                  for j in range(20)]
+        sample = b'\n'.join(sample)
+
+        lst.append(sample)
+    global SAMPLES
+    SAMPLES = lst
+    assert len(SAMPLES) > 10
+
+    global TRAINED_DICT
+    TRAINED_DICT = train_dict(SAMPLES, 3*_1K)
+    assert len(TRAINED_DICT.dict_content) <= 3*_1K
+
+
+class FunctionsTestCase(unittest.TestCase):
+
+    def test_version(self):
+        s = ".".join((str(i) for i in zstd_version_info))
+        self.assertEqual(s, zstd_version)
+
+    def test_compressionLevel_values(self):
+        min, max = CompressionParameter.compression_level.bounds()
+        self.assertIs(type(COMPRESSION_LEVEL_DEFAULT), int)
+        self.assertIs(type(min), int)
+        self.assertIs(type(max), int)
+        self.assertLess(min, max)
+
+    def test_roundtrip_default(self):
+        raw_dat = THIS_FILE_BYTES[: len(THIS_FILE_BYTES) // 6]
+        dat1 = compress(raw_dat)
+        dat2 = decompress(dat1)
+        self.assertEqual(dat2, raw_dat)
+
+    def test_roundtrip_level(self):
+        raw_dat = THIS_FILE_BYTES[: len(THIS_FILE_BYTES) // 6]
+        level_min, level_max = CompressionParameter.compression_level.bounds()
+
+        for level in range(max(-20, level_min), level_max + 1):
+            dat1 = compress(raw_dat, level)
+            dat2 = decompress(dat1)
+            self.assertEqual(dat2, raw_dat)
+
+    def test_get_frame_info(self):
+        # no dict
+        info = get_frame_info(COMPRESSED_100_PLUS_32KB[:20])
+        self.assertEqual(info.decompressed_size, 32 * _1K + 100)
+        self.assertEqual(info.dictionary_id, 0)
+
+        # use dict
+        dat = compress(b"a" * 345, zstd_dict=TRAINED_DICT)
+        info = get_frame_info(dat)
+        self.assertEqual(info.decompressed_size, 345)
+        self.assertEqual(info.dictionary_id, TRAINED_DICT.dict_id)
+
+        with self.assertRaisesRegex(ZstdError, "not less than the frame header"):
+            get_frame_info(b"aaaaaaaaaaaaaa")
+
+    def test_get_frame_size(self):
+        size = get_frame_size(COMPRESSED_100_PLUS_32KB)
+        self.assertEqual(size, len(COMPRESSED_100_PLUS_32KB))
+
+        with self.assertRaisesRegex(ZstdError, "not less than this complete frame"):
+            get_frame_size(b"aaaaaaaaaaaaaa")
+
+    def test_decompress_2x130_1K(self):
+        decompressed_size = get_frame_info(DAT_130K_C).decompressed_size
+        self.assertEqual(decompressed_size, _130_1K)
+
+        dat = decompress(DAT_130K_C + DAT_130K_C)
+        self.assertEqual(len(dat), 2 * _130_1K)
+
+
+class CompressorTestCase(unittest.TestCase):
+
+    def test_simple_compress_bad_args(self):
+        # ZstdCompressor
+        self.assertRaises(TypeError, ZstdCompressor, [])
+        self.assertRaises(TypeError, ZstdCompressor, level=3.14)
+        self.assertRaises(TypeError, ZstdCompressor, level="abc")
+        self.assertRaises(TypeError, ZstdCompressor, options=b"abc")
+
+        self.assertRaises(TypeError, ZstdCompressor, zstd_dict=123)
+        self.assertRaises(TypeError, ZstdCompressor, zstd_dict=b"abcd1234")
+        self.assertRaises(TypeError, ZstdCompressor, zstd_dict={1: 2, 3: 4})
+
+        # valid range for compression level is [-(1<<17), 22]
+        msg = r'illegal compression level {}; the valid range is \[-?\d+, -?\d+\]'
+        with self.assertRaisesRegex(ValueError, msg.format(C_INT_MAX)):
+            ZstdCompressor(C_INT_MAX)
+        with self.assertRaisesRegex(ValueError, msg.format(C_INT_MIN)):
+            ZstdCompressor(C_INT_MIN)
+        msg = r'illegal compression level; the valid range is \[-?\d+, -?\d+\]'
+        with self.assertRaisesRegex(ValueError, msg):
+            ZstdCompressor(level=-(2**1000))
+        with self.assertRaisesRegex(ValueError, msg):
+            ZstdCompressor(level=2**1000)
+
+        with self.assertRaises(ValueError):
+            ZstdCompressor(options={CompressionParameter.window_log: 100})
+        with self.assertRaises(ValueError):
+            ZstdCompressor(options={3333: 100})
+
+        # Method bad arguments
+        zc = ZstdCompressor()
+        self.assertRaises(TypeError, zc.compress)
+        self.assertRaises((TypeError, ValueError), zc.compress, b"foo", b"bar")
+        self.assertRaises(TypeError, zc.compress, "str")
+        self.assertRaises((TypeError, ValueError), zc.flush, b"foo")
+        self.assertRaises(TypeError, zc.flush, b"blah", 1)
+
+        self.assertRaises(ValueError, zc.compress, b'', -1)
+        self.assertRaises(ValueError, zc.compress, b'', 3)
+        self.assertRaises(ValueError, zc.flush, zc.CONTINUE) # 0
+        self.assertRaises(ValueError, zc.flush, 3)
+
+        zc.compress(b'')
+        zc.compress(b'', zc.CONTINUE)
+        zc.compress(b'', zc.FLUSH_BLOCK)
+        zc.compress(b'', zc.FLUSH_FRAME)
+        empty = zc.flush()
+        zc.flush(zc.FLUSH_BLOCK)
+        zc.flush(zc.FLUSH_FRAME)
+
+    def test_compress_parameters(self):
+        d = {CompressionParameter.compression_level : 10,
+
+             CompressionParameter.window_log : 12,
+             CompressionParameter.hash_log : 10,
+             CompressionParameter.chain_log : 12,
+             CompressionParameter.search_log : 12,
+             CompressionParameter.min_match : 4,
+             CompressionParameter.target_length : 12,
+             CompressionParameter.strategy : Strategy.lazy,
+
+             CompressionParameter.enable_long_distance_matching : 1,
+             CompressionParameter.ldm_hash_log : 12,
+             CompressionParameter.ldm_min_match : 11,
+             CompressionParameter.ldm_bucket_size_log : 5,
+             CompressionParameter.ldm_hash_rate_log : 12,
+
+             CompressionParameter.content_size_flag : 1,
+             CompressionParameter.checksum_flag : 1,
+             CompressionParameter.dict_id_flag : 0,
+
+             CompressionParameter.nb_workers : 2 if SUPPORT_MULTITHREADING else 0,
+             CompressionParameter.job_size : 5*_1M if SUPPORT_MULTITHREADING else 0,
+             CompressionParameter.overlap_log : 9 if SUPPORT_MULTITHREADING else 0,
+             }
+        ZstdCompressor(options=d)
+
+        d1 = d.copy()
+        # larger than signed int
+        d1[CompressionParameter.ldm_bucket_size_log] = C_INT_MAX
+        with self.assertRaises(ValueError):
+            ZstdCompressor(options=d1)
+        # smaller than signed int
+        d1[CompressionParameter.ldm_bucket_size_log] = C_INT_MIN
+        with self.assertRaises(ValueError):
+            ZstdCompressor(options=d1)
+
+        # out of bounds compression level
+        level_min, level_max = CompressionParameter.compression_level.bounds()
+        with self.assertRaises(ValueError):
+            compress(b'', level_max+1)
+        with self.assertRaises(ValueError):
+            compress(b'', level_min-1)
+        with self.assertRaises(ValueError):
+            compress(b'', 2**1000)
+        with self.assertRaises(ValueError):
+            compress(b'', -(2**1000))
+        with self.assertRaises(ValueError):
+            compress(b'', options={
+                CompressionParameter.compression_level: level_max+1})
+        with self.assertRaises(ValueError):
+            compress(b'', options={
+                CompressionParameter.compression_level: level_min-1})
+
+        # zstd lib doesn't support MT compression
+        if not SUPPORT_MULTITHREADING:
+            with self.assertRaises(ValueError):
+                ZstdCompressor(options={CompressionParameter.nb_workers:4})
+            with self.assertRaises(ValueError):
+                ZstdCompressor(options={CompressionParameter.job_size:4})
+            with self.assertRaises(ValueError):
+                ZstdCompressor(options={CompressionParameter.overlap_log:4})
+
+        # out of bounds error msg
+        option = {CompressionParameter.window_log:100}
+        with self.assertRaisesRegex(
+            ValueError,
+            "compression parameter 'window_log' received an illegal value 100; "
+            r'the valid range is \[-?\d+, -?\d+\]',
+        ):
+            compress(b'', options=option)
+
+    def test_unknown_compression_parameter(self):
+        KEY = 100001234
+        option = {CompressionParameter.compression_level: 10,
+                  KEY: 200000000}
+        pattern = rf"invalid compression parameter 'unknown parameter \(key {KEY}\)'"
+        with self.assertRaisesRegex(ValueError, pattern):
+            ZstdCompressor(options=option)
+
+    @unittest.skipIf(not SUPPORT_MULTITHREADING,
+                     "zstd build doesn't support multi-threaded compression")
+    def test_zstd_multithread_compress(self):
+        size = 40*_1M
+        b = THIS_FILE_BYTES * (size // len(THIS_FILE_BYTES))
+
+        options = {CompressionParameter.compression_level : 4,
+                   CompressionParameter.nb_workers : 2}
+
+        # compress()
+        dat1 = compress(b, options=options)
+        dat2 = decompress(dat1)
+        self.assertEqual(dat2, b)
+
+        # ZstdCompressor
+        c = ZstdCompressor(options=options)
+        dat1 = c.compress(b, c.CONTINUE)
+        dat2 = c.compress(b, c.FLUSH_BLOCK)
+        dat3 = c.compress(b, c.FLUSH_FRAME)
+        dat4 = decompress(dat1+dat2+dat3)
+        self.assertEqual(dat4, b * 3)
+
+        # ZstdFile
+        with ZstdFile(io.BytesIO(), 'w', options=options) as f:
+            f.write(b)
+
+    def test_compress_flushblock(self):
+        point = len(THIS_FILE_BYTES) // 2
+
+        c = ZstdCompressor()
+        self.assertEqual(c.last_mode, c.FLUSH_FRAME)
+        dat1 = c.compress(THIS_FILE_BYTES[:point])
+        self.assertEqual(c.last_mode, c.CONTINUE)
+        dat1 += c.compress(THIS_FILE_BYTES[point:], c.FLUSH_BLOCK)
+        self.assertEqual(c.last_mode, c.FLUSH_BLOCK)
+        dat2 = c.flush()
+        pattern = "Compressed data ended before the end-of-stream marker"
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(dat1)
+
+        dat3 = decompress(dat1 + dat2)
+
+        self.assertEqual(dat3, THIS_FILE_BYTES)
+
+    def test_compress_flushframe(self):
+        # test compress & decompress
+        point = len(THIS_FILE_BYTES) // 2
+
+        c = ZstdCompressor()
+
+        dat1 = c.compress(THIS_FILE_BYTES[:point])
+        self.assertEqual(c.last_mode, c.CONTINUE)
+
+        dat1 += c.compress(THIS_FILE_BYTES[point:], c.FLUSH_FRAME)
+        self.assertEqual(c.last_mode, c.FLUSH_FRAME)
+
+        nt = get_frame_info(dat1)
+        self.assertEqual(nt.decompressed_size, None) # no content size
+
+        dat2 = decompress(dat1)
+
+        self.assertEqual(dat2, THIS_FILE_BYTES)
+
+        # single .FLUSH_FRAME mode has content size
+        c = ZstdCompressor()
+        dat = c.compress(THIS_FILE_BYTES, mode=c.FLUSH_FRAME)
+        self.assertEqual(c.last_mode, c.FLUSH_FRAME)
+
+        nt = get_frame_info(dat)
+        self.assertEqual(nt.decompressed_size, len(THIS_FILE_BYTES))
+
+    def test_compress_empty(self):
+        # output empty content frame
+        self.assertNotEqual(compress(b''), b'')
+
+        c = ZstdCompressor()
+        self.assertNotEqual(c.compress(b'', c.FLUSH_FRAME), b'')
+
+    def test_set_pledged_input_size(self):
+        DAT = DECOMPRESSED_100_PLUS_32KB
+        CHUNK_SIZE = len(DAT) // 3
+
+        # wrong value
+        c = ZstdCompressor()
+        with self.assertRaisesRegex(ValueError,
+                                    r'should be a positive int less than \d+'):
+            c.set_pledged_input_size(-300)
+        # overflow
+        with self.assertRaisesRegex(ValueError,
+                                    r'should be a positive int less than \d+'):
+            c.set_pledged_input_size(2**64)
+        # ZSTD_CONTENTSIZE_ERROR is invalid
+        with self.assertRaisesRegex(ValueError,
+                                    r'should be a positive int less than \d+'):
+            c.set_pledged_input_size(2**64-2)
+        # ZSTD_CONTENTSIZE_UNKNOWN should use None
+        with self.assertRaisesRegex(ValueError,
+                                    r'should be a positive int less than \d+'):
+            c.set_pledged_input_size(2**64-1)
+
+        # check valid values are settable
+        c.set_pledged_input_size(2**63)
+        c.set_pledged_input_size(2**64-3)
+
+        # check that zero means empty frame
+        c = ZstdCompressor(level=1)
+        c.set_pledged_input_size(0)
+        c.compress(b'')
+        dat = c.flush()
+        ret = get_frame_info(dat)
+        self.assertEqual(ret.decompressed_size, 0)
+
+
+        # wrong mode
+        c = ZstdCompressor(level=1)
+        c.compress(b'123456')
+        self.assertEqual(c.last_mode, c.CONTINUE)
+        with self.assertRaisesRegex(ValueError,
+                                    r'last_mode == FLUSH_FRAME'):
+            c.set_pledged_input_size(300)
+
+        # None value
+        c = ZstdCompressor(level=1)
+        c.set_pledged_input_size(None)
+        dat = c.compress(DAT) + c.flush()
+
+        ret = get_frame_info(dat)
+        self.assertEqual(ret.decompressed_size, None)
+
+        # correct value
+        c = ZstdCompressor(level=1)
+        c.set_pledged_input_size(len(DAT))
+
+        chunks = []
+        posi = 0
+        while posi < len(DAT):
+            dat = c.compress(DAT[posi:posi+CHUNK_SIZE])
+            posi += CHUNK_SIZE
+            chunks.append(dat)
+
+        dat = c.flush()
+        chunks.append(dat)
+        chunks = b''.join(chunks)
+
+        ret = get_frame_info(chunks)
+        self.assertEqual(ret.decompressed_size, len(DAT))
+        self.assertEqual(decompress(chunks), DAT)
+
+        c.set_pledged_input_size(len(DAT)) # the second frame
+        dat = c.compress(DAT) + c.flush()
+
+        ret = get_frame_info(dat)
+        self.assertEqual(ret.decompressed_size, len(DAT))
+        self.assertEqual(decompress(dat), DAT)
+
+        # not enough data
+        c = ZstdCompressor(level=1)
+        c.set_pledged_input_size(len(DAT)+1)
+
+        for start in range(0, len(DAT), CHUNK_SIZE):
+            end = min(start+CHUNK_SIZE, len(DAT))
+            _dat = c.compress(DAT[start:end])
+
+        with self.assertRaises(ZstdError):
+            c.flush()
+
+        # too much data
+        c = ZstdCompressor(level=1)
+        c.set_pledged_input_size(len(DAT))
+
+        for start in range(0, len(DAT), CHUNK_SIZE):
+            end = min(start+CHUNK_SIZE, len(DAT))
+            _dat = c.compress(DAT[start:end])
+
+        with self.assertRaises(ZstdError):
+            c.compress(b'extra', ZstdCompressor.FLUSH_FRAME)
+
+        # content size not set if content_size_flag == 0
+        c = ZstdCompressor(options={CompressionParameter.content_size_flag: 0})
+        c.set_pledged_input_size(10)
+        dat1 = c.compress(b"hello")
+        dat2 = c.compress(b"world")
+        dat3 = c.flush()
+        frame_data = get_frame_info(dat1 + dat2 + dat3)
+        self.assertIsNone(frame_data.decompressed_size)
+
+
+class DecompressorTestCase(unittest.TestCase):
+
+    def test_simple_decompress_bad_args(self):
+        # ZstdDecompressor
+        self.assertRaises(TypeError, ZstdDecompressor, ())
+        self.assertRaises(TypeError, ZstdDecompressor, zstd_dict=123)
+        self.assertRaises(TypeError, ZstdDecompressor, zstd_dict=b'abc')
+        self.assertRaises(TypeError, ZstdDecompressor, zstd_dict={1:2, 3:4})
+
+        self.assertRaises(TypeError, ZstdDecompressor, options=123)
+        self.assertRaises(TypeError, ZstdDecompressor, options='abc')
+        self.assertRaises(TypeError, ZstdDecompressor, options=b'abc')
+
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(options={C_INT_MAX: 100})
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(options={C_INT_MIN: 100})
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(options={0: C_INT_MAX})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={2**1000: 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={-(2**1000): 100})
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(options={0: -(2**1000)})
+
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(options={DecompressionParameter.window_log_max: 100})
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(options={3333: 100})
+
+        empty = compress(b'')
+        lzd = ZstdDecompressor()
+        self.assertRaises(TypeError, lzd.decompress)
+        self.assertRaises(TypeError, lzd.decompress, b"foo", b"bar")
+        self.assertRaises(TypeError, lzd.decompress, "str")
+        lzd.decompress(empty)
+
+    def test_decompress_parameters(self):
+        d = {DecompressionParameter.window_log_max : 15}
+        ZstdDecompressor(options=d)
+
+        d1 = d.copy()
+        # larger than signed int
+        d1[DecompressionParameter.window_log_max] = 2**1000
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(None, d1)
+        # smaller than signed int
+        d1[DecompressionParameter.window_log_max] = -(2**1000)
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor(None, d1)
+
+        d1[DecompressionParameter.window_log_max] = C_INT_MAX
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(None, d1)
+        d1[DecompressionParameter.window_log_max] = C_INT_MIN
+        with self.assertRaises(ValueError):
+            ZstdDecompressor(None, d1)
+
+        # out of bounds error msg
+        options = {DecompressionParameter.window_log_max:100}
+        with self.assertRaisesRegex(
+            ValueError,
+            "decompression parameter 'window_log_max' received an illegal value 100; "
+            r'the valid range is \[-?\d+, -?\d+\]',
+        ):
+            decompress(b'', options=options)
+
+        # out of bounds deecompression parameter
+        options[DecompressionParameter.window_log_max] = C_INT_MAX
+        with self.assertRaises(ValueError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = C_INT_MIN
+        with self.assertRaises(ValueError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = 2**1000
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+        options[DecompressionParameter.window_log_max] = -(2**1000)
+        with self.assertRaises(OverflowError):
+            decompress(b'', options=options)
+
+    def test_unknown_decompression_parameter(self):
+        KEY = 100001234
+        options = {DecompressionParameter.window_log_max: DecompressionParameter.window_log_max.bounds()[1],
+                  KEY: 200000000}
+        pattern = rf"invalid decompression parameter 'unknown parameter \(key {KEY}\)'"
+        with self.assertRaisesRegex(ValueError, pattern):
+            ZstdDecompressor(options=options)
+
+    def test_decompress_epilogue_flags(self):
+        # DAT_130K_C has a 4 bytes checksum at frame epilogue
+
+        # full unlimited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C)
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.needs_input)
+
+        with self.assertRaises(EOFError):
+            dat = d.decompress(b'')
+
+        # full limited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C, _130_1K)
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.needs_input)
+
+        with self.assertRaises(EOFError):
+            dat = d.decompress(b'', 0)
+
+        # [:-4] unlimited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-4])
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.needs_input)
+
+        dat = d.decompress(b'')
+        self.assertEqual(len(dat), 0)
+        self.assertTrue(d.needs_input)
+
+        # [:-4] limited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-4], _130_1K)
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.needs_input)
+
+        dat = d.decompress(b'', 0)
+        self.assertEqual(len(dat), 0)
+        self.assertFalse(d.needs_input)
+
+        # [:-3] unlimited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-3])
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.needs_input)
+
+        dat = d.decompress(b'')
+        self.assertEqual(len(dat), 0)
+        self.assertTrue(d.needs_input)
+
+        # [:-3] limited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-3], _130_1K)
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.needs_input)
+
+        dat = d.decompress(b'', 0)
+        self.assertEqual(len(dat), 0)
+        self.assertFalse(d.needs_input)
+
+        # [:-1] unlimited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-1])
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.needs_input)
+
+        dat = d.decompress(b'')
+        self.assertEqual(len(dat), 0)
+        self.assertTrue(d.needs_input)
+
+        # [:-1] limited
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-1], _130_1K)
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.needs_input)
+
+        dat = d.decompress(b'', 0)
+        self.assertEqual(len(dat), 0)
+        self.assertFalse(d.needs_input)
+
+    def test_decompressor_arg(self):
+        zd = ZstdDict(b'12345678', is_raw=True)
+
+        with self.assertRaises(TypeError):
+            d = ZstdDecompressor(zstd_dict={})
+
+        with self.assertRaises(TypeError):
+            d = ZstdDecompressor(options=zd)
+
+        ZstdDecompressor()
+        ZstdDecompressor(zd, {})
+        ZstdDecompressor(zstd_dict=zd, options={DecompressionParameter.window_log_max:25})
+
+    def test_decompressor_1(self):
+        # empty
+        d = ZstdDecompressor()
+        dat = d.decompress(b'')
+
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+
+        # 130_1K full
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C)
+
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+
+        # 130_1K full, limit output
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C, _130_1K)
+
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+
+        # 130_1K, without 4 bytes checksum
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-4])
+
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+
+        # above, limit output
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C[:-4], _130_1K)
+
+        self.assertEqual(len(dat), _130_1K)
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+
+        # full, unused_data
+        TRAIL = b'89234893abcd'
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT_130K_C + TRAIL, _130_1K)
+
+        self.assertEqual(len(dat), _130_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, TRAIL)
+
+    def test_decompressor_chunks_read_300(self):
+        TRAIL = b'89234893abcd'
+        DAT = DAT_130K_C + TRAIL
+        d = ZstdDecompressor()
+
+        bi = io.BytesIO(DAT)
+        lst = []
+        while True:
+            if d.needs_input:
+                dat = bi.read(300)
+                if not dat:
+                    break
+            else:
+                raise Exception('should not get here')
+
+            ret = d.decompress(dat)
+            lst.append(ret)
+            if d.eof:
+                break
+
+        ret = b''.join(lst)
+
+        self.assertEqual(len(ret), _130_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data + bi.read(), TRAIL)
+
+    def test_decompressor_chunks_read_3(self):
+        TRAIL = b'89234893'
+        DAT = DAT_130K_C + TRAIL
+        d = ZstdDecompressor()
+
+        bi = io.BytesIO(DAT)
+        lst = []
+        while True:
+            if d.needs_input:
+                dat = bi.read(3)
+                if not dat:
+                    break
+            else:
+                dat = b''
+
+            ret = d.decompress(dat, 1)
+            lst.append(ret)
+            if d.eof:
+                break
+
+        ret = b''.join(lst)
+
+        self.assertEqual(len(ret), _130_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data + bi.read(), TRAIL)
+
+
+    def test_decompress_empty(self):
+        with self.assertRaises(ZstdError):
+            decompress(b'')
+
+        d = ZstdDecompressor()
+        self.assertEqual(d.decompress(b''), b'')
+        self.assertFalse(d.eof)
+
+    def test_decompress_empty_content_frame(self):
+        DAT = compress(b'')
+        # decompress
+        self.assertGreaterEqual(len(DAT), 4)
+        self.assertEqual(decompress(DAT), b'')
+
+        with self.assertRaises(ZstdError):
+            decompress(DAT[:-1])
+
+        # ZstdDecompressor
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT)
+        self.assertEqual(dat, b'')
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        d = ZstdDecompressor()
+        dat = d.decompress(DAT[:-1])
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+class DecompressorFlagsTestCase(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        options = {CompressionParameter.checksum_flag:1}
+        c = ZstdCompressor(options=options)
+
+        cls.DECOMPRESSED_42 = b'a'*42
+        cls.FRAME_42 = c.compress(cls.DECOMPRESSED_42, c.FLUSH_FRAME)
+
+        cls.DECOMPRESSED_60 = b'a'*60
+        cls.FRAME_60 = c.compress(cls.DECOMPRESSED_60, c.FLUSH_FRAME)
+
+        cls.FRAME_42_60 = cls.FRAME_42 + cls.FRAME_60
+        cls.DECOMPRESSED_42_60 = cls.DECOMPRESSED_42 + cls.DECOMPRESSED_60
+
+        cls._130_1K = 130*_1K
+
+        c = ZstdCompressor()
+        cls.UNKNOWN_FRAME_42 = c.compress(cls.DECOMPRESSED_42) + c.flush()
+        cls.UNKNOWN_FRAME_60 = c.compress(cls.DECOMPRESSED_60) + c.flush()
+        cls.UNKNOWN_FRAME_42_60 = cls.UNKNOWN_FRAME_42 + cls.UNKNOWN_FRAME_60
+
+        cls.TRAIL = b'12345678abcdefg!@#$%^&*()_+|'
+
+    def test_function_decompress(self):
+
+        self.assertEqual(len(decompress(COMPRESSED_100_PLUS_32KB)), 100+32*_1K)
+
+        # 1 frame
+        self.assertEqual(decompress(self.FRAME_42), self.DECOMPRESSED_42)
+
+        self.assertEqual(decompress(self.UNKNOWN_FRAME_42), self.DECOMPRESSED_42)
+
+        pattern = r"Compressed data ended before the end-of-stream marker"
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(self.FRAME_42[:1])
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(self.FRAME_42[:-4])
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(self.FRAME_42[:-1])
+
+        # 2 frames
+        self.assertEqual(decompress(self.FRAME_42_60), self.DECOMPRESSED_42_60)
+
+        self.assertEqual(decompress(self.UNKNOWN_FRAME_42_60), self.DECOMPRESSED_42_60)
+
+        self.assertEqual(decompress(self.FRAME_42 + self.UNKNOWN_FRAME_60),
+                         self.DECOMPRESSED_42_60)
+
+        self.assertEqual(decompress(self.UNKNOWN_FRAME_42 + self.FRAME_60),
+                         self.DECOMPRESSED_42_60)
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(self.FRAME_42_60[:-4])
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(self.UNKNOWN_FRAME_42_60[:-1])
+
+        # 130_1K
+        self.assertEqual(decompress(DAT_130K_C), DAT_130K_D)
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(DAT_130K_C[:-4])
+
+        with self.assertRaisesRegex(ZstdError, pattern):
+            decompress(DAT_130K_C[:-1])
+
+        # Unknown frame descriptor
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(b'aaaaaaaaa')
+
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(self.FRAME_42 + b'aaaaaaaaa')
+
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(self.UNKNOWN_FRAME_42_60 + b'aaaaaaaaa')
+
+        # doesn't match checksum
+        checksum = DAT_130K_C[-4:]
+        if checksum[0] == 255:
+            wrong_checksum = bytes([254]) + checksum[1:]
+        else:
+            wrong_checksum = bytes([checksum[0]+1]) + checksum[1:]
+
+        dat = DAT_130K_C[:-4] + wrong_checksum
+
+        with self.assertRaisesRegex(ZstdError, "doesn't match checksum"):
+            decompress(dat)
+
+    def test_function_skippable(self):
+        self.assertEqual(decompress(SKIPPABLE_FRAME), b'')
+        self.assertEqual(decompress(SKIPPABLE_FRAME + SKIPPABLE_FRAME), b'')
+
+        # 1 frame + 2 skippable
+        self.assertEqual(len(decompress(SKIPPABLE_FRAME + SKIPPABLE_FRAME + DAT_130K_C)),
+                         self._130_1K)
+
+        self.assertEqual(len(decompress(DAT_130K_C + SKIPPABLE_FRAME + SKIPPABLE_FRAME)),
+                         self._130_1K)
+
+        self.assertEqual(len(decompress(SKIPPABLE_FRAME + DAT_130K_C + SKIPPABLE_FRAME)),
+                         self._130_1K)
+
+        # unknown size
+        self.assertEqual(decompress(SKIPPABLE_FRAME + self.UNKNOWN_FRAME_60),
+                         self.DECOMPRESSED_60)
+
+        self.assertEqual(decompress(self.UNKNOWN_FRAME_60 + SKIPPABLE_FRAME),
+                         self.DECOMPRESSED_60)
+
+        # 2 frames + 1 skippable
+        self.assertEqual(decompress(self.FRAME_42 + SKIPPABLE_FRAME + self.FRAME_60),
+                         self.DECOMPRESSED_42_60)
+
+        self.assertEqual(decompress(SKIPPABLE_FRAME + self.FRAME_42_60),
+                         self.DECOMPRESSED_42_60)
+
+        self.assertEqual(decompress(self.UNKNOWN_FRAME_42_60 + SKIPPABLE_FRAME),
+                         self.DECOMPRESSED_42_60)
+
+        # incomplete
+        with self.assertRaises(ZstdError):
+            decompress(SKIPPABLE_FRAME[:1])
+
+        with self.assertRaises(ZstdError):
+            decompress(SKIPPABLE_FRAME[:-1])
+
+        with self.assertRaises(ZstdError):
+            decompress(self.FRAME_42 + SKIPPABLE_FRAME[:-1])
+
+        # Unknown frame descriptor
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(b'aaaaaaaaa' + SKIPPABLE_FRAME)
+
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(SKIPPABLE_FRAME + b'aaaaaaaaa')
+
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            decompress(SKIPPABLE_FRAME + SKIPPABLE_FRAME + b'aaaaaaaaa')
+
+    def test_decompressor_1(self):
+        # empty 1
+        d = ZstdDecompressor()
+
+        dat = d.decompress(b'')
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(b'', 0)
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(COMPRESSED_100_PLUS_32KB + b'a')
+        self.assertEqual(dat, DECOMPRESSED_100_PLUS_32KB)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'a')
+        self.assertEqual(d.unused_data, b'a') # twice
+
+        # empty 2
+        d = ZstdDecompressor()
+
+        dat = d.decompress(b'', 0)
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(b'')
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(COMPRESSED_100_PLUS_32KB + b'a')
+        self.assertEqual(dat, DECOMPRESSED_100_PLUS_32KB)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'a')
+        self.assertEqual(d.unused_data, b'a') # twice
+
+        # 1 frame
+        d = ZstdDecompressor()
+        dat = d.decompress(self.FRAME_42)
+
+        self.assertEqual(dat, self.DECOMPRESSED_42)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        with self.assertRaises(EOFError):
+            d.decompress(b'')
+
+        # 1 frame, trail
+        d = ZstdDecompressor()
+        dat = d.decompress(self.FRAME_42 + self.TRAIL)
+
+        self.assertEqual(dat, self.DECOMPRESSED_42)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, self.TRAIL)
+        self.assertEqual(d.unused_data, self.TRAIL) # twice
+
+        # 1 frame, 32_1K
+        temp = compress(b'a'*(32*_1K))
+        d = ZstdDecompressor()
+        dat = d.decompress(temp, 32*_1K)
+
+        self.assertEqual(dat, b'a'*(32*_1K))
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        with self.assertRaises(EOFError):
+            d.decompress(b'')
+
+        # 1 frame, 32_1K+100, trail
+        d = ZstdDecompressor()
+        dat = d.decompress(COMPRESSED_100_PLUS_32KB+self.TRAIL, 100) # 100 bytes
+
+        self.assertEqual(len(dat), 100)
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+
+        dat = d.decompress(b'') # 32_1K
+
+        self.assertEqual(len(dat), 32*_1K)
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, self.TRAIL)
+        self.assertEqual(d.unused_data, self.TRAIL) # twice
+
+        with self.assertRaises(EOFError):
+            d.decompress(b'')
+
+        # incomplete 1
+        d = ZstdDecompressor()
+        dat = d.decompress(self.FRAME_60[:1])
+
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # incomplete 2
+        d = ZstdDecompressor()
+
+        dat = d.decompress(self.FRAME_60[:-4])
+        self.assertEqual(dat, self.DECOMPRESSED_60)
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # incomplete 3
+        d = ZstdDecompressor()
+
+        dat = d.decompress(self.FRAME_60[:-1])
+        self.assertEqual(dat, self.DECOMPRESSED_60)
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+
+        # incomplete 4
+        d = ZstdDecompressor()
+
+        dat = d.decompress(self.FRAME_60[:-4], 60)
+        self.assertEqual(dat, self.DECOMPRESSED_60)
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(b'')
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # Unknown frame descriptor
+        d = ZstdDecompressor()
+        with self.assertRaisesRegex(ZstdError, "Unknown frame descriptor"):
+            d.decompress(b'aaaaaaaaa')
+
+    def test_decompressor_skippable(self):
+        # 1 skippable
+        d = ZstdDecompressor()
+        dat = d.decompress(SKIPPABLE_FRAME)
+
+        self.assertEqual(dat, b'')
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # 1 skippable, max_length=0
+        d = ZstdDecompressor()
+        dat = d.decompress(SKIPPABLE_FRAME, 0)
+
+        self.assertEqual(dat, b'')
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # 1 skippable, trail
+        d = ZstdDecompressor()
+        dat = d.decompress(SKIPPABLE_FRAME + self.TRAIL)
+
+        self.assertEqual(dat, b'')
+        self.assertTrue(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, self.TRAIL)
+        self.assertEqual(d.unused_data, self.TRAIL) # twice
+
+        # incomplete
+        d = ZstdDecompressor()
+        dat = d.decompress(SKIPPABLE_FRAME[:-1])
+
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        # incomplete
+        d = ZstdDecompressor()
+        dat = d.decompress(SKIPPABLE_FRAME[:-1], 0)
+
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertFalse(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+        dat = d.decompress(b'')
+
+        self.assertEqual(dat, b'')
+        self.assertFalse(d.eof)
+        self.assertTrue(d.needs_input)
+        self.assertEqual(d.unused_data, b'')
+        self.assertEqual(d.unused_data, b'') # twice
+
+
+
+class ZstdDictTestCase(unittest.TestCase):
+
+    def test_is_raw(self):
+        # must be passed as a keyword argument
+        with self.assertRaises(TypeError):
+            ZstdDict(bytes(8), True)
+
+        # content < 8
+        b = b'1234567'
+        with self.assertRaises(ValueError):
+            ZstdDict(b)
+
+        # content == 8
+        b = b'12345678'
+        zd = ZstdDict(b, is_raw=True)
+        self.assertEqual(zd.dict_id, 0)
+
+        temp = compress(b'aaa12345678', level=3, zstd_dict=zd)
+        self.assertEqual(b'aaa12345678', decompress(temp, zd))
+
+        # is_raw == False
+        b = b'12345678abcd'
+        with self.assertRaises(ValueError):
+            ZstdDict(b)
+
+        # read only attributes
+        with self.assertRaises(AttributeError):
+            zd.dict_content = b
+
+        with self.assertRaises(AttributeError):
+            zd.dict_id = 10000
+
+        # ZstdDict arguments
+        zd = ZstdDict(TRAINED_DICT.dict_content, is_raw=False)
+        self.assertNotEqual(zd.dict_id, 0)
+
+        zd = ZstdDict(TRAINED_DICT.dict_content, is_raw=True)
+        self.assertNotEqual(zd.dict_id, 0) # note this assertion
+
+        with self.assertRaises(TypeError):
+            ZstdDict("12345678abcdef", is_raw=True)
+        with self.assertRaises(TypeError):
+            ZstdDict(TRAINED_DICT)
+
+        # invalid parameter
+        with self.assertRaises(TypeError):
+            ZstdDict(desk333=345)
+
+    def test_invalid_dict(self):
+        DICT_MAGIC = 0xEC30A437.to_bytes(4, byteorder='little')
+        dict_content = DICT_MAGIC + b'abcdefghighlmnopqrstuvwxyz'
+
+        # corrupted
+        zd = ZstdDict(dict_content, is_raw=False)
+        with self.assertRaisesRegex(ZstdError, r'ZSTD_CDict.*?content\.$'):
+            ZstdCompressor(zstd_dict=zd.as_digested_dict)
+        with self.assertRaisesRegex(ZstdError, r'ZSTD_DDict.*?content\.$'):
+            ZstdDecompressor(zd)
+
+        # wrong type
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=[zd, 1])
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=(zd, 1.0))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=(zd,))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=(zd, 1, 2))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=(zd, -1))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdCompressor(zstd_dict=(zd, 3))
+        with self.assertRaises(OverflowError):
+            ZstdCompressor(zstd_dict=(zd, 2**1000))
+        with self.assertRaises(OverflowError):
+            ZstdCompressor(zstd_dict=(zd, -2**1000))
+
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor(zstd_dict=[zd, 1])
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor(zstd_dict=(zd, 1.0))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor((zd,))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor((zd, 1, 2))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor((zd, -1))
+        with self.assertRaisesRegex(TypeError, r'should be a ZstdDict object'):
+            ZstdDecompressor((zd, 3))
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor((zd, 2**1000))
+        with self.assertRaises(OverflowError):
+            ZstdDecompressor((zd, -2**1000))
+
+    def test_train_dict(self):
+        TRAINED_DICT = train_dict(SAMPLES, DICT_SIZE1)
+        ZstdDict(TRAINED_DICT.dict_content, is_raw=False)
+
+        self.assertNotEqual(TRAINED_DICT.dict_id, 0)
+        self.assertGreater(len(TRAINED_DICT.dict_content), 0)
+        self.assertLessEqual(len(TRAINED_DICT.dict_content), DICT_SIZE1)
+        self.assertTrue(re.match(r'^<ZstdDict dict_id=\d+ dict_size=\d+>$', str(TRAINED_DICT)))
+
+        # compress/decompress
+        c = ZstdCompressor(zstd_dict=TRAINED_DICT)
+        for sample in SAMPLES:
+            dat1 = compress(sample, zstd_dict=TRAINED_DICT)
+            dat2 = decompress(dat1, TRAINED_DICT)
+            self.assertEqual(sample, dat2)
+
+            dat1 = c.compress(sample)
+            dat1 += c.flush()
+            dat2 = decompress(dat1, TRAINED_DICT)
+            self.assertEqual(sample, dat2)
+
+    def test_finalize_dict(self):
+        DICT_SIZE2 = 200*_1K
+        C_LEVEL = 6
+
+        try:
+            dic2 = finalize_dict(TRAINED_DICT, SAMPLES, DICT_SIZE2, C_LEVEL)
+        except NotImplementedError:
+            # < v1.4.5 at compile-time, >= v.1.4.5 at run-time
+            return
+
+        self.assertNotEqual(dic2.dict_id, 0)
+        self.assertGreater(len(dic2.dict_content), 0)
+        self.assertLessEqual(len(dic2.dict_content), DICT_SIZE2)
+
+        # compress/decompress
+        c = ZstdCompressor(C_LEVEL, zstd_dict=dic2)
+        for sample in SAMPLES:
+            dat1 = compress(sample, C_LEVEL, zstd_dict=dic2)
+            dat2 = decompress(dat1, dic2)
+            self.assertEqual(sample, dat2)
+
+            dat1 = c.compress(sample)
+            dat1 += c.flush()
+            dat2 = decompress(dat1, dic2)
+            self.assertEqual(sample, dat2)
+
+        # dict mismatch
+        self.assertNotEqual(TRAINED_DICT.dict_id, dic2.dict_id)
+
+        dat1 = compress(SAMPLES[0], zstd_dict=TRAINED_DICT)
+        with self.assertRaises(ZstdError):
+            decompress(dat1, dic2)
+
+    def test_train_dict_arguments(self):
+        with self.assertRaises(ValueError):
+            train_dict([], 100*_1K)
+
+        with self.assertRaises(ValueError):
+            train_dict(SAMPLES, -100)
+
+        with self.assertRaises(ValueError):
+            train_dict(SAMPLES, 0)
+
+    def test_finalize_dict_arguments(self):
+        with self.assertRaises(TypeError):
+            finalize_dict({1:2}, (b'aaa', b'bbb'), 100*_1K, 2)
+
+        with self.assertRaises(ValueError):
+            finalize_dict(TRAINED_DICT, [], 100*_1K, 2)
+
+        with self.assertRaises(ValueError):
+            finalize_dict(TRAINED_DICT, SAMPLES, -100, 2)
+
+        with self.assertRaises(ValueError):
+            finalize_dict(TRAINED_DICT, SAMPLES, 0, 2)
+
+    def test_train_dict_c(self):
+        # argument wrong type
+        with self.assertRaises(TypeError):
+            _zstd.train_dict({}, (), 100)
+        with self.assertRaises(TypeError):
+            _zstd.train_dict(bytearray(), (), 100)
+        with self.assertRaises(TypeError):
+            _zstd.train_dict(b'', 99, 100)
+        with self.assertRaises(TypeError):
+            _zstd.train_dict(b'', [], 100)
+        with self.assertRaises(TypeError):
+            _zstd.train_dict(b'', (), 100.1)
+        with self.assertRaises(TypeError):
+            _zstd.train_dict(b'', (99.1,), 100)
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'abc', (4, -1), 100)
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'abc', (2,), 100)
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'', (99,), 100)
+
+        # size > size_t
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'', (2**1000,), 100)
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'', (-2**1000,), 100)
+
+        # dict_size <= 0
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'', (), 0)
+        with self.assertRaises(ValueError):
+            _zstd.train_dict(b'', (), -1)
+
+        with self.assertRaises(ZstdError):
+            _zstd.train_dict(b'', (), 1)
+
+    def test_finalize_dict_c(self):
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(1, 2, 3, 4, 5)
+
+        # argument wrong type
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict({}, b'', (), 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(bytearray(TRAINED_DICT.dict_content), b'', (), 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, {}, (), 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, bytearray(), (), 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', 99, 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', [], 100, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 100.1, 5)
+        with self.assertRaises(TypeError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 100, 5.1)
+
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'abc', (4, -1), 100, 5)
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'abc', (2,), 100, 5)
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (99,), 100, 5)
+
+        # size > size_t
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (2**1000,), 100, 5)
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (-2**1000,), 100, 5)
+
+        # dict_size <= 0
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 0, 5)
+        with self.assertRaises(ValueError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), -1, 5)
+        with self.assertRaises(OverflowError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 2**1000, 5)
+        with self.assertRaises(OverflowError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), -2**1000, 5)
+
+        with self.assertRaises(OverflowError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 100, 2**1000)
+        with self.assertRaises(OverflowError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 100, -2**1000)
+
+        with self.assertRaises(ZstdError):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content, b'', (), 100, 5)
+
+    def test_train_buffer_protocol_samples(self):
+        def _nbytes(dat):
+            if isinstance(dat, (bytes, bytearray)):
+                return len(dat)
+            return memoryview(dat).nbytes
+
+        # prepare samples
+        chunk_lst = []
+        wrong_size_lst = []
+        correct_size_lst = []
+        for _ in range(300):
+            arr = array.array('Q', [random.randint(0, 20) for i in range(20)])
+            chunk_lst.append(arr)
+            correct_size_lst.append(_nbytes(arr))
+            wrong_size_lst.append(len(arr))
+        concatenation = b''.join(chunk_lst)
+
+        # wrong size list
+        with self.assertRaisesRegex(ValueError,
+                "The samples size tuple doesn't match the concatenation's size"):
+            _zstd.train_dict(concatenation, tuple(wrong_size_lst), 100*_1K)
+
+        # correct size list
+        _zstd.train_dict(concatenation, tuple(correct_size_lst), 3*_1K)
+
+        # wrong size list
+        with self.assertRaisesRegex(ValueError,
+                "The samples size tuple doesn't match the concatenation's size"):
+            _zstd.finalize_dict(TRAINED_DICT.dict_content,
+                                  concatenation, tuple(wrong_size_lst), 300*_1K, 5)
+
+        # correct size list
+        _zstd.finalize_dict(TRAINED_DICT.dict_content,
+                              concatenation, tuple(correct_size_lst), 300*_1K, 5)
+
+    def test_as_prefix(self):
+        # V1
+        V1 = THIS_FILE_BYTES
+        zd = ZstdDict(V1, is_raw=True)
+
+        # V2
+        mid = len(V1) // 2
+        V2 = V1[:mid] + \
+             (b'a' if V1[mid] != int.from_bytes(b'a') else b'b') + \
+             V1[mid+1:]
+
+        # compress
+        dat = compress(V2, zstd_dict=zd.as_prefix)
+        self.assertEqual(get_frame_info(dat).dictionary_id, 0)
+
+        # decompress
+        self.assertEqual(decompress(dat, zd.as_prefix), V2)
+
+        # use wrong prefix
+        zd2 = ZstdDict(SAMPLES[0], is_raw=True)
+        try:
+            decompressed = decompress(dat, zd2.as_prefix)
+        except ZstdError: # expected
+            pass
+        else:
+            self.assertNotEqual(decompressed, V2)
+
+        # read only attribute
+        with self.assertRaises(AttributeError):
+            zd.as_prefix = b'1234'
+
+    def test_as_digested_dict(self):
+        zd = TRAINED_DICT
+
+        # test .as_digested_dict
+        dat = compress(SAMPLES[0], zstd_dict=zd.as_digested_dict)
+        self.assertEqual(decompress(dat, zd.as_digested_dict), SAMPLES[0])
+        with self.assertRaises(AttributeError):
+            zd.as_digested_dict = b'1234'
+
+        # test .as_undigested_dict
+        dat = compress(SAMPLES[0], zstd_dict=zd.as_undigested_dict)
+        self.assertEqual(decompress(dat, zd.as_undigested_dict), SAMPLES[0])
+        with self.assertRaises(AttributeError):
+            zd.as_undigested_dict = b'1234'
+
+    def test_advanced_compression_parameters(self):
+        options = {CompressionParameter.compression_level: 6,
+                  CompressionParameter.window_log: 20,
+                  CompressionParameter.enable_long_distance_matching: 1}
+
+        # automatically select
+        dat = compress(SAMPLES[0], options=options, zstd_dict=TRAINED_DICT)
+        self.assertEqual(decompress(dat, TRAINED_DICT), SAMPLES[0])
+
+        # explicitly select
+        dat = compress(SAMPLES[0], options=options, zstd_dict=TRAINED_DICT.as_digested_dict)
+        self.assertEqual(decompress(dat, TRAINED_DICT), SAMPLES[0])
+
+    def test_len(self):
+        self.assertEqual(len(TRAINED_DICT), len(TRAINED_DICT.dict_content))
+        self.assertIn(str(len(TRAINED_DICT)), str(TRAINED_DICT))
+
+class FileTestCase(unittest.TestCase):
+    def setUp(self):
+        self.DECOMPRESSED_42 = b'a'*42
+        self.FRAME_42 = compress(self.DECOMPRESSED_42)
+
+    def test_init(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            pass
+        with ZstdFile(io.BytesIO(), "w") as f:
+            pass
+        with ZstdFile(io.BytesIO(), "x") as f:
+            pass
+        with ZstdFile(io.BytesIO(), "a") as f:
+            pass
+
+        with ZstdFile(io.BytesIO(), "w", level=12) as f:
+            pass
+        with ZstdFile(io.BytesIO(), "w", options={CompressionParameter.checksum_flag:1}) as f:
+            pass
+        with ZstdFile(io.BytesIO(), "w", options={}) as f:
+            pass
+        with ZstdFile(io.BytesIO(), "w", level=20, zstd_dict=TRAINED_DICT) as f:
+            pass
+
+        with ZstdFile(io.BytesIO(), "r", options={DecompressionParameter.window_log_max:25}) as f:
+            pass
+        with ZstdFile(io.BytesIO(), "r", options={}, zstd_dict=TRAINED_DICT) as f:
+            pass
+
+    def test_init_with_PathLike_filename(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        with ZstdFile(filename, "a") as f:
+            f.write(DECOMPRESSED_100_PLUS_32KB)
+        with ZstdFile(filename) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+
+        with ZstdFile(filename, "a") as f:
+            f.write(DECOMPRESSED_100_PLUS_32KB)
+        with ZstdFile(filename) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB * 2)
+
+        os.remove(filename)
+
+    def test_init_with_filename(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        with ZstdFile(filename) as f:
+            pass
+        with ZstdFile(filename, "w") as f:
+            pass
+        with ZstdFile(filename, "a") as f:
+            pass
+
+        os.remove(filename)
+
+    def test_init_mode(self):
+        bi = io.BytesIO()
+
+        with ZstdFile(bi, "r"):
+            pass
+        with ZstdFile(bi, "rb"):
+            pass
+        with ZstdFile(bi, "w"):
+            pass
+        with ZstdFile(bi, "wb"):
+            pass
+        with ZstdFile(bi, "a"):
+            pass
+        with ZstdFile(bi, "ab"):
+            pass
+
+    def test_init_with_x_mode(self):
+        with tempfile.NamedTemporaryFile() as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        for mode in ("x", "xb"):
+            with ZstdFile(filename, mode):
+                pass
+            with self.assertRaises(FileExistsError):
+                with ZstdFile(filename, mode):
+                    pass
+            os.remove(filename)
+
+    def test_init_bad_mode(self):
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), (3, "x"))
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "xt")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "x+")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rx")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "wx")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rt")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r+")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "wt")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "w+")
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rw")
+
+        with self.assertRaisesRegex(TypeError,
+                                    r"not be a CompressionParameter"):
+            ZstdFile(io.BytesIO(), 'rb',
+                     options={CompressionParameter.compression_level:5})
+        with self.assertRaisesRegex(TypeError,
+                                    r"not be a DecompressionParameter"):
+            ZstdFile(io.BytesIO(), 'wb',
+                     options={DecompressionParameter.window_log_max:21})
+
+        with self.assertRaises(TypeError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r", level=12)
+
+    def test_init_bad_check(self):
+        with self.assertRaises(TypeError):
+            ZstdFile(io.BytesIO(), "w", level='asd')
+        # CHECK_UNKNOWN and anything above CHECK_ID_MAX should be invalid.
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(), "w", options={999:9999})
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(), "w", options={CompressionParameter.window_log:99})
+
+        with self.assertRaises(TypeError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r", options=33)
+
+        with self.assertRaises(OverflowError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
+                             options={DecompressionParameter.window_log_max:2**31})
+
+        with self.assertRaises(ValueError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
+                             options={444:333})
+
+        with self.assertRaises(TypeError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), zstd_dict={1:2})
+
+        with self.assertRaises(TypeError):
+            ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), zstd_dict=b'dict123456')
+
+    def test_init_close_fp(self):
+        # get a temp file name
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            tmp_f.write(DAT_130K_C)
+            filename = tmp_f.name
+
+        with self.assertRaises(TypeError):
+            ZstdFile(filename, options={'a':'b'})
+
+        # for PyPy
+        gc.collect()
+
+        os.remove(filename)
+
+    def test_close(self):
+        with io.BytesIO(COMPRESSED_100_PLUS_32KB) as src:
+            f = ZstdFile(src)
+            f.close()
+            # ZstdFile.close() should not close the underlying file object.
+            self.assertFalse(src.closed)
+            # Try closing an already-closed ZstdFile.
+            f.close()
+            self.assertFalse(src.closed)
+
+        # Test with a real file on disk, opened directly by ZstdFile.
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        f = ZstdFile(filename)
+        fp = f._fp
+        f.close()
+        # Here, ZstdFile.close() *should* close the underlying file object.
+        self.assertTrue(fp.closed)
+        # Try closing an already-closed ZstdFile.
+        f.close()
+
+        os.remove(filename)
+
+    def test_closed(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            self.assertFalse(f.closed)
+            f.read()
+            self.assertFalse(f.closed)
+        finally:
+            f.close()
+        self.assertTrue(f.closed)
+
+        f = ZstdFile(io.BytesIO(), "w")
+        try:
+            self.assertFalse(f.closed)
+        finally:
+            f.close()
+        self.assertTrue(f.closed)
+
+    def test_fileno(self):
+        # 1
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            self.assertRaises(io.UnsupportedOperation, f.fileno)
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.fileno)
+
+        # 2
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        f = ZstdFile(filename)
+        try:
+            self.assertEqual(f.fileno(), f._fp.fileno())
+            self.assertIsInstance(f.fileno(), int)
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.fileno)
+
+        os.remove(filename)
+
+        # 3, no .fileno() method
+        class C:
+            def read(self, size=-1):
+                return b'123'
+        with ZstdFile(C(), 'rb') as f:
+            with self.assertRaisesRegex(AttributeError, r'fileno'):
+                f.fileno()
+
+    def test_name(self):
+        # 1
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            with self.assertRaises(AttributeError):
+                f.name
+        finally:
+            f.close()
+        with self.assertRaises(ValueError):
+            f.name
+
+        # 2
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            filename = pathlib.Path(tmp_f.name)
+
+        f = ZstdFile(filename)
+        try:
+            self.assertEqual(f.name, f._fp.name)
+            self.assertIsInstance(f.name, str)
+        finally:
+            f.close()
+        with self.assertRaises(ValueError):
+            f.name
+
+        os.remove(filename)
+
+        # 3, no .filename property
+        class C:
+            def read(self, size=-1):
+                return b'123'
+        with ZstdFile(C(), 'rb') as f:
+            with self.assertRaisesRegex(AttributeError, r'name'):
+                f.name
+
+    def test_seekable(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            self.assertTrue(f.seekable())
+            f.read()
+            self.assertTrue(f.seekable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.seekable)
+
+        f = ZstdFile(io.BytesIO(), "w")
+        try:
+            self.assertFalse(f.seekable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.seekable)
+
+        src = io.BytesIO(COMPRESSED_100_PLUS_32KB)
+        src.seekable = lambda: False
+        f = ZstdFile(src)
+        try:
+            self.assertFalse(f.seekable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.seekable)
+
+    def test_readable(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            self.assertTrue(f.readable())
+            f.read()
+            self.assertTrue(f.readable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.readable)
+
+        f = ZstdFile(io.BytesIO(), "w")
+        try:
+            self.assertFalse(f.readable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.readable)
+
+    def test_writable(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        try:
+            self.assertFalse(f.writable())
+            f.read()
+            self.assertFalse(f.writable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.writable)
+
+        f = ZstdFile(io.BytesIO(), "w")
+        try:
+            self.assertTrue(f.writable())
+        finally:
+            f.close()
+        self.assertRaises(ValueError, f.writable)
+
+    def test_read_0(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            self.assertEqual(f.read(0), b"")
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB),
+                              options={DecompressionParameter.window_log_max:20}) as f:
+            self.assertEqual(f.read(0), b"")
+
+        # empty file
+        with ZstdFile(io.BytesIO(b'')) as f:
+            self.assertEqual(f.read(0), b"")
+            with self.assertRaises(EOFError):
+                f.read(10)
+
+        with ZstdFile(io.BytesIO(b'')) as f:
+            with self.assertRaises(EOFError):
+                f.read(10)
+
+    def test_read_10(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            chunks = []
+            while True:
+                result = f.read(10)
+                if not result:
+                    break
+                self.assertLessEqual(len(result), 10)
+                chunks.append(result)
+            self.assertEqual(b"".join(chunks), DECOMPRESSED_100_PLUS_32KB)
+
+    def test_read_multistream(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB * 5)) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB * 5)
+
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB + SKIPPABLE_FRAME)) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB + COMPRESSED_DAT)) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB + DECOMPRESSED_DAT)
+
+    def test_read_incomplete(self):
+        with ZstdFile(io.BytesIO(DAT_130K_C[:-200])) as f:
+            self.assertRaises(EOFError, f.read)
+
+        # Trailing data isn't a valid compressed stream
+        with ZstdFile(io.BytesIO(self.FRAME_42 + b'12345')) as f:
+            self.assertRaises(ZstdError, f.read)
+
+        with ZstdFile(io.BytesIO(SKIPPABLE_FRAME + b'12345')) as f:
+            self.assertRaises(ZstdError, f.read)
+
+    def test_read_truncated(self):
+        # Drop stream epilogue: 4 bytes checksum
+        truncated = DAT_130K_C[:-4]
+        with ZstdFile(io.BytesIO(truncated)) as f:
+            self.assertRaises(EOFError, f.read)
+
+        with ZstdFile(io.BytesIO(truncated)) as f:
+            # this is an important test, make sure it doesn't raise EOFError.
+            self.assertEqual(f.read(130*_1K), DAT_130K_D)
+            with self.assertRaises(EOFError):
+                f.read(1)
+
+        # Incomplete header
+        for i in range(1, 20):
+            with ZstdFile(io.BytesIO(truncated[:i])) as f:
+                self.assertRaises(EOFError, f.read, 1)
+
+    def test_read_bad_args(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_DAT))
+        f.close()
+        self.assertRaises(ValueError, f.read)
+        with ZstdFile(io.BytesIO(), "w") as f:
+            self.assertRaises(ValueError, f.read)
+        with ZstdFile(io.BytesIO(COMPRESSED_DAT)) as f:
+            self.assertRaises(TypeError, f.read, float())
+
+    def test_read_bad_data(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_BOGUS)) as f:
+            self.assertRaises(ZstdError, f.read)
+
+    def test_read_exception(self):
+        class C:
+            def read(self, size=-1):
+                raise OSError
+        with ZstdFile(C()) as f:
+            with self.assertRaises(OSError):
+                f.read(10)
+
+    def test_read1(self):
+        with ZstdFile(io.BytesIO(DAT_130K_C)) as f:
+            blocks = []
+            while True:
+                result = f.read1()
+                if not result:
+                    break
+                blocks.append(result)
+            self.assertEqual(b"".join(blocks), DAT_130K_D)
+            self.assertEqual(f.read1(), b"")
+
+    def test_read1_0(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_DAT)) as f:
+            self.assertEqual(f.read1(0), b"")
+
+    def test_read1_10(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_DAT)) as f:
+            blocks = []
+            while True:
+                result = f.read1(10)
+                if not result:
+                    break
+                blocks.append(result)
+            self.assertEqual(b"".join(blocks), DECOMPRESSED_DAT)
+            self.assertEqual(f.read1(), b"")
+
+    def test_read1_multistream(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB * 5)) as f:
+            blocks = []
+            while True:
+                result = f.read1()
+                if not result:
+                    break
+                blocks.append(result)
+            self.assertEqual(b"".join(blocks), DECOMPRESSED_100_PLUS_32KB * 5)
+            self.assertEqual(f.read1(), b"")
+
+    def test_read1_bad_args(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        f.close()
+        self.assertRaises(ValueError, f.read1)
+        with ZstdFile(io.BytesIO(), "w") as f:
+            self.assertRaises(ValueError, f.read1)
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            self.assertRaises(TypeError, f.read1, None)
+
+    def test_readinto(self):
+        arr = array.array("I", range(100))
+        self.assertEqual(len(arr), 100)
+        self.assertEqual(len(arr) * arr.itemsize, 400)
+        ba = bytearray(300)
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            # 0 length output buffer
+            self.assertEqual(f.readinto(ba[0:0]), 0)
+
+            # use correct length for buffer protocol object
+            self.assertEqual(f.readinto(arr), 400)
+            self.assertEqual(arr.tobytes(), DECOMPRESSED_100_PLUS_32KB[:400])
+
+            # normal readinto
+            self.assertEqual(f.readinto(ba), 300)
+            self.assertEqual(ba, DECOMPRESSED_100_PLUS_32KB[400:700])
+
+    def test_peek(self):
+        with ZstdFile(io.BytesIO(DAT_130K_C)) as f:
+            result = f.peek()
+            self.assertGreater(len(result), 0)
+            self.assertTrue(DAT_130K_D.startswith(result))
+            self.assertEqual(f.read(), DAT_130K_D)
+        with ZstdFile(io.BytesIO(DAT_130K_C)) as f:
+            result = f.peek(10)
+            self.assertGreater(len(result), 0)
+            self.assertTrue(DAT_130K_D.startswith(result))
+            self.assertEqual(f.read(), DAT_130K_D)
+
+    def test_peek_bad_args(self):
+        with ZstdFile(io.BytesIO(), "w") as f:
+            self.assertRaises(ValueError, f.peek)
+
+    def test_iterator(self):
+        with io.BytesIO(THIS_FILE_BYTES) as f:
+            lines = f.readlines()
+        compressed = compress(THIS_FILE_BYTES)
+
+        # iter
+        with ZstdFile(io.BytesIO(compressed)) as f:
+            self.assertListEqual(list(iter(f)), lines)
+
+        # readline
+        with ZstdFile(io.BytesIO(compressed)) as f:
+            for line in lines:
+                self.assertEqual(f.readline(), line)
+            self.assertEqual(f.readline(), b'')
+            self.assertEqual(f.readline(), b'')
+
+        # readlines
+        with ZstdFile(io.BytesIO(compressed)) as f:
+            self.assertListEqual(f.readlines(), lines)
+
+    def test_decompress_limited(self):
+        _ZSTD_DStreamInSize = 128*_1K + 3
+
+        bomb = compress(b'\0' * int(2e6), level=10)
+        self.assertLess(len(bomb), _ZSTD_DStreamInSize)
+
+        decomp = ZstdFile(io.BytesIO(bomb))
+        self.assertEqual(decomp.read(1), b'\0')
+
+        # BufferedReader uses 128 KiB buffer in __init__.py
+        max_decomp = 128*_1K
+        self.assertLessEqual(decomp._buffer.raw.tell(), max_decomp,
+            "Excessive amount of data was decompressed")
+
+    def test_write(self):
+        raw_data = THIS_FILE_BYTES[: len(THIS_FILE_BYTES) // 6]
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w") as f:
+                f.write(raw_data)
+
+            comp = ZstdCompressor()
+            expected = comp.compress(raw_data) + comp.flush()
+            self.assertEqual(dst.getvalue(), expected)
+
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w", level=12) as f:
+                f.write(raw_data)
+
+            comp = ZstdCompressor(12)
+            expected = comp.compress(raw_data) + comp.flush()
+            self.assertEqual(dst.getvalue(), expected)
+
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w", options={CompressionParameter.checksum_flag:1}) as f:
+                f.write(raw_data)
+
+            comp = ZstdCompressor(options={CompressionParameter.checksum_flag:1})
+            expected = comp.compress(raw_data) + comp.flush()
+            self.assertEqual(dst.getvalue(), expected)
+
+        with io.BytesIO() as dst:
+            options = {CompressionParameter.compression_level:-5,
+                      CompressionParameter.checksum_flag:1}
+            with ZstdFile(dst, "w",
+                          options=options) as f:
+                f.write(raw_data)
+
+            comp = ZstdCompressor(options=options)
+            expected = comp.compress(raw_data) + comp.flush()
+            self.assertEqual(dst.getvalue(), expected)
+
+    def test_write_empty_frame(self):
+        # .FLUSH_FRAME generates an empty content frame
+        c = ZstdCompressor()
+        self.assertNotEqual(c.flush(c.FLUSH_FRAME), b'')
+        self.assertNotEqual(c.flush(c.FLUSH_FRAME), b'')
+
+        # don't generate empty content frame
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            pass
+        self.assertEqual(bo.getvalue(), b'')
+
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.flush(f.FLUSH_FRAME)
+        self.assertEqual(bo.getvalue(), b'')
+
+        # if .write(b''), generate empty content frame
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.write(b'')
+        self.assertNotEqual(bo.getvalue(), b'')
+
+        # has an empty content frame
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.flush(f.FLUSH_BLOCK)
+        self.assertNotEqual(bo.getvalue(), b'')
+
+    def test_write_empty_block(self):
+        # If no internal data, .FLUSH_BLOCK return b''.
+        c = ZstdCompressor()
+        self.assertEqual(c.flush(c.FLUSH_BLOCK), b'')
+        self.assertNotEqual(c.compress(b'123', c.FLUSH_BLOCK),
+                            b'')
+        self.assertEqual(c.flush(c.FLUSH_BLOCK), b'')
+        self.assertEqual(c.compress(b''), b'')
+        self.assertEqual(c.compress(b''), b'')
+        self.assertEqual(c.flush(c.FLUSH_BLOCK), b'')
+
+        # mode = .last_mode
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.write(b'123')
+            f.flush(f.FLUSH_BLOCK)
+            fp_pos = f._fp.tell()
+            self.assertNotEqual(fp_pos, 0)
+            f.flush(f.FLUSH_BLOCK)
+            self.assertEqual(f._fp.tell(), fp_pos)
+
+        # mode != .last_mode
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.flush(f.FLUSH_BLOCK)
+            self.assertEqual(f._fp.tell(), 0)
+            f.write(b'')
+            f.flush(f.FLUSH_BLOCK)
+            self.assertEqual(f._fp.tell(), 0)
+
+    def test_write_101(self):
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w") as f:
+                for start in range(0, len(THIS_FILE_BYTES), 101):
+                    f.write(THIS_FILE_BYTES[start:start+101])
+
+            comp = ZstdCompressor()
+            expected = comp.compress(THIS_FILE_BYTES) + comp.flush()
+            self.assertEqual(dst.getvalue(), expected)
+
+    def test_write_append(self):
+        def comp(data):
+            comp = ZstdCompressor()
+            return comp.compress(data) + comp.flush()
+
+        part1 = THIS_FILE_BYTES[:_1K]
+        part2 = THIS_FILE_BYTES[_1K:1536]
+        part3 = THIS_FILE_BYTES[1536:]
+        expected = b"".join(comp(x) for x in (part1, part2, part3))
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w") as f:
+                f.write(part1)
+            with ZstdFile(dst, "a") as f:
+                f.write(part2)
+            with ZstdFile(dst, "a") as f:
+                f.write(part3)
+            self.assertEqual(dst.getvalue(), expected)
+
+    def test_write_bad_args(self):
+        f = ZstdFile(io.BytesIO(), "w")
+        f.close()
+        self.assertRaises(ValueError, f.write, b"foo")
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB), "r") as f:
+            self.assertRaises(ValueError, f.write, b"bar")
+        with ZstdFile(io.BytesIO(), "w") as f:
+            self.assertRaises(TypeError, f.write, None)
+            self.assertRaises(TypeError, f.write, "text")
+            self.assertRaises(TypeError, f.write, 789)
+
+    def test_writelines(self):
+        def comp(data):
+            comp = ZstdCompressor()
+            return comp.compress(data) + comp.flush()
+
+        with io.BytesIO(THIS_FILE_BYTES) as f:
+            lines = f.readlines()
+        with io.BytesIO() as dst:
+            with ZstdFile(dst, "w") as f:
+                f.writelines(lines)
+            expected = comp(THIS_FILE_BYTES)
+            self.assertEqual(dst.getvalue(), expected)
+
+    def test_seek_forward(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.seek(555)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[555:])
+
+    def test_seek_forward_across_streams(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB * 2)) as f:
+            f.seek(len(DECOMPRESSED_100_PLUS_32KB) + 123)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[123:])
+
+    def test_seek_forward_relative_to_current(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.read(100)
+            f.seek(1236, 1)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[1336:])
+
+    def test_seek_forward_relative_to_end(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.seek(-555, 2)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[-555:])
+
+    def test_seek_backward(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.read(1001)
+            f.seek(211)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[211:])
+
+    def test_seek_backward_across_streams(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB * 2)) as f:
+            f.read(len(DECOMPRESSED_100_PLUS_32KB) + 333)
+            f.seek(737)
+            self.assertEqual(f.read(),
+              DECOMPRESSED_100_PLUS_32KB[737:] + DECOMPRESSED_100_PLUS_32KB)
+
+    def test_seek_backward_relative_to_end(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.seek(-150, 2)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB[-150:])
+
+    def test_seek_past_end(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.seek(len(DECOMPRESSED_100_PLUS_32KB) + 9001)
+            self.assertEqual(f.tell(), len(DECOMPRESSED_100_PLUS_32KB))
+            self.assertEqual(f.read(), b"")
+
+    def test_seek_past_start(self):
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            f.seek(-88)
+            self.assertEqual(f.tell(), 0)
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+
+    def test_seek_bad_args(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        f.close()
+        self.assertRaises(ValueError, f.seek, 0)
+        with ZstdFile(io.BytesIO(), "w") as f:
+            self.assertRaises(ValueError, f.seek, 0)
+        with ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB)) as f:
+            self.assertRaises(ValueError, f.seek, 0, 3)
+            # io.BufferedReader raises TypeError instead of ValueError
+            self.assertRaises((TypeError, ValueError), f.seek, 9, ())
+            self.assertRaises(TypeError, f.seek, None)
+            self.assertRaises(TypeError, f.seek, b"derp")
+
+    def test_seek_not_seekable(self):
+        class C(io.BytesIO):
+            def seekable(self):
+                return False
+        obj = C(COMPRESSED_100_PLUS_32KB)
+        with ZstdFile(obj, 'r') as f:
+            d = f.read(1)
+            self.assertFalse(f.seekable())
+            with self.assertRaisesRegex(io.UnsupportedOperation,
+                                        'File or stream is not seekable'):
+                f.seek(0)
+            d += f.read()
+            self.assertEqual(d, DECOMPRESSED_100_PLUS_32KB)
+
+    def test_tell(self):
+        with ZstdFile(io.BytesIO(DAT_130K_C)) as f:
+            pos = 0
+            while True:
+                self.assertEqual(f.tell(), pos)
+                result = f.read(random.randint(171, 189))
+                if not result:
+                    break
+                pos += len(result)
+            self.assertEqual(f.tell(), len(DAT_130K_D))
+        with ZstdFile(io.BytesIO(), "w") as f:
+            for pos in range(0, len(DAT_130K_D), 143):
+                self.assertEqual(f.tell(), pos)
+                f.write(DAT_130K_D[pos:pos+143])
+            self.assertEqual(f.tell(), len(DAT_130K_D))
+
+    def test_tell_bad_args(self):
+        f = ZstdFile(io.BytesIO(COMPRESSED_100_PLUS_32KB))
+        f.close()
+        self.assertRaises(ValueError, f.tell)
+
+    def test_file_dict(self):
+        # default
+        bi = io.BytesIO()
+        with ZstdFile(bi, 'w', zstd_dict=TRAINED_DICT) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with ZstdFile(bi, zstd_dict=TRAINED_DICT) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+        # .as_(un)digested_dict
+        bi = io.BytesIO()
+        with ZstdFile(bi, 'w', zstd_dict=TRAINED_DICT.as_digested_dict) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with ZstdFile(bi, zstd_dict=TRAINED_DICT.as_undigested_dict) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+    def test_file_prefix(self):
+        bi = io.BytesIO()
+        with ZstdFile(bi, 'w', zstd_dict=TRAINED_DICT.as_prefix) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with ZstdFile(bi, zstd_dict=TRAINED_DICT.as_prefix) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+    def test_UnsupportedOperation(self):
+        # 1
+        with ZstdFile(io.BytesIO(), 'r') as f:
+            with self.assertRaises(io.UnsupportedOperation):
+                f.write(b'1234')
+
+        # 2
+        class T:
+            def read(self, size):
+                return b'a' * size
+
+        with self.assertRaises(TypeError): # on creation
+            with ZstdFile(T(), 'w') as f:
+                pass
+
+        # 3
+        with ZstdFile(io.BytesIO(), 'w') as f:
+            with self.assertRaises(io.UnsupportedOperation):
+                f.read(100)
+            with self.assertRaises(io.UnsupportedOperation):
+                f.seek(100)
+        self.assertEqual(f.closed, True)
+        with self.assertRaises(ValueError):
+            f.readable()
+        with self.assertRaises(ValueError):
+            f.tell()
+        with self.assertRaises(ValueError):
+            f.read(100)
+
+    def test_read_readinto_readinto1(self):
+        lst = []
+        with ZstdFile(io.BytesIO(COMPRESSED_THIS_FILE*5)) as f:
+            while True:
+                method = random.randint(0, 2)
+                size = random.randint(0, 300)
+
+                if method == 0:
+                    dat = f.read(size)
+                    if not dat and size:
+                        break
+                    lst.append(dat)
+                elif method == 1:
+                    ba = bytearray(size)
+                    read_size = f.readinto(ba)
+                    if read_size == 0 and size:
+                        break
+                    lst.append(bytes(ba[:read_size]))
+                elif method == 2:
+                    ba = bytearray(size)
+                    read_size = f.readinto1(ba)
+                    if read_size == 0 and size:
+                        break
+                    lst.append(bytes(ba[:read_size]))
+        self.assertEqual(b''.join(lst), THIS_FILE_BYTES*5)
+
+    def test_zstdfile_flush(self):
+        # closed
+        f = ZstdFile(io.BytesIO(), 'w')
+        f.close()
+        with self.assertRaises(ValueError):
+            f.flush()
+
+        # read
+        with ZstdFile(io.BytesIO(), 'r') as f:
+            # does nothing for read-only stream
+            f.flush()
+
+        # write
+        DAT = b'abcd'
+        bi = io.BytesIO()
+        with ZstdFile(bi, 'w') as f:
+            self.assertEqual(f.write(DAT), len(DAT))
+            self.assertEqual(f.tell(), len(DAT))
+            self.assertEqual(bi.tell(), 0) # not enough for a block
+
+            self.assertEqual(f.flush(), None)
+            self.assertEqual(f.tell(), len(DAT))
+            self.assertGreater(bi.tell(), 0) # flushed
+
+        # write, no .flush() method
+        class C:
+            def write(self, b):
+                return len(b)
+        with ZstdFile(C(), 'w') as f:
+            self.assertEqual(f.write(DAT), len(DAT))
+            self.assertEqual(f.tell(), len(DAT))
+
+            self.assertEqual(f.flush(), None)
+            self.assertEqual(f.tell(), len(DAT))
+
+    def test_zstdfile_flush_mode(self):
+        self.assertEqual(ZstdFile.FLUSH_BLOCK, ZstdCompressor.FLUSH_BLOCK)
+        self.assertEqual(ZstdFile.FLUSH_FRAME, ZstdCompressor.FLUSH_FRAME)
+        with self.assertRaises(AttributeError):
+            ZstdFile.CONTINUE
+
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            # flush block
+            self.assertEqual(f.write(b'123'), 3)
+            self.assertIsNone(f.flush(f.FLUSH_BLOCK))
+            p1 = bo.tell()
+            # mode == .last_mode, should return
+            self.assertIsNone(f.flush())
+            p2 = bo.tell()
+            self.assertEqual(p1, p2)
+            # flush frame
+            self.assertEqual(f.write(b'456'), 3)
+            self.assertIsNone(f.flush(mode=f.FLUSH_FRAME))
+            # flush frame
+            self.assertEqual(f.write(b'789'), 3)
+            self.assertIsNone(f.flush(f.FLUSH_FRAME))
+            p1 = bo.tell()
+            # mode == .last_mode, should return
+            self.assertIsNone(f.flush(f.FLUSH_FRAME))
+            p2 = bo.tell()
+            self.assertEqual(p1, p2)
+        self.assertEqual(decompress(bo.getvalue()), b'123456789')
+
+        bo = io.BytesIO()
+        with ZstdFile(bo, 'w') as f:
+            f.write(b'123')
+            with self.assertRaisesRegex(ValueError, r'\.FLUSH_.*?\.FLUSH_'):
+                f.flush(ZstdCompressor.CONTINUE)
+            with self.assertRaises(ValueError):
+                f.flush(-1)
+            with self.assertRaises(ValueError):
+                f.flush(123456)
+            with self.assertRaises(TypeError):
+                f.flush(node=ZstdCompressor.CONTINUE)
+            with self.assertRaises((TypeError, ValueError)):
+                f.flush('FLUSH_FRAME')
+            with self.assertRaises(TypeError):
+                f.flush(b'456', f.FLUSH_BLOCK)
+
+    def test_zstdfile_truncate(self):
+        with ZstdFile(io.BytesIO(), 'w') as f:
+            with self.assertRaises(io.UnsupportedOperation):
+                f.truncate(200)
+
+    def test_zstdfile_iter_issue45475(self):
+        lines = [l for l in ZstdFile(io.BytesIO(COMPRESSED_THIS_FILE))]
+        self.assertGreater(len(lines), 0)
+
+    def test_append_new_file(self):
+        with tempfile.NamedTemporaryFile(delete=True) as tmp_f:
+            filename = tmp_f.name
+
+        with ZstdFile(filename, 'a') as f:
+            pass
+        self.assertTrue(os.path.isfile(filename))
+
+        os.remove(filename)
+
+class OpenTestCase(unittest.TestCase):
+
+    def test_binary_modes(self):
+        with open(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rb") as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+        with io.BytesIO() as bio:
+            with open(bio, "wb") as f:
+                f.write(DECOMPRESSED_100_PLUS_32KB)
+            file_data = decompress(bio.getvalue())
+            self.assertEqual(file_data, DECOMPRESSED_100_PLUS_32KB)
+            with open(bio, "ab") as f:
+                f.write(DECOMPRESSED_100_PLUS_32KB)
+            file_data = decompress(bio.getvalue())
+            self.assertEqual(file_data, DECOMPRESSED_100_PLUS_32KB * 2)
+
+    def test_text_modes(self):
+        # empty input
+        with self.assertRaises(EOFError):
+            with open(io.BytesIO(b''), "rt", encoding="utf-8", newline='\n') as reader:
+                for _ in reader:
+                    pass
+
+        # read
+        uncompressed = THIS_FILE_STR.replace(os.linesep, "\n")
+        with open(io.BytesIO(COMPRESSED_THIS_FILE), "rt", encoding="utf-8") as f:
+            self.assertEqual(f.read(), uncompressed)
+
+        with io.BytesIO() as bio:
+            # write
+            with open(bio, "wt", encoding="utf-8") as f:
+                f.write(uncompressed)
+            file_data = decompress(bio.getvalue()).decode("utf-8")
+            self.assertEqual(file_data.replace(os.linesep, "\n"), uncompressed)
+            # append
+            with open(bio, "at", encoding="utf-8") as f:
+                f.write(uncompressed)
+            file_data = decompress(bio.getvalue()).decode("utf-8")
+            self.assertEqual(file_data.replace(os.linesep, "\n"), uncompressed * 2)
+
+    def test_bad_params(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            TESTFN = pathlib.Path(tmp_f.name)
+
+        with self.assertRaises(ValueError):
+            open(TESTFN, "")
+        with self.assertRaises(ValueError):
+            open(TESTFN, "rbt")
+        with self.assertRaises(ValueError):
+            open(TESTFN, "rb", encoding="utf-8")
+        with self.assertRaises(ValueError):
+            open(TESTFN, "rb", errors="ignore")
+        with self.assertRaises(ValueError):
+            open(TESTFN, "rb", newline="\n")
+
+        os.remove(TESTFN)
+
+    def test_option(self):
+        options = {DecompressionParameter.window_log_max:25}
+        with open(io.BytesIO(COMPRESSED_100_PLUS_32KB), "rb", options=options) as f:
+            self.assertEqual(f.read(), DECOMPRESSED_100_PLUS_32KB)
+
+        options = {CompressionParameter.compression_level:12}
+        with io.BytesIO() as bio:
+            with open(bio, "wb", options=options) as f:
+                f.write(DECOMPRESSED_100_PLUS_32KB)
+            file_data = decompress(bio.getvalue())
+            self.assertEqual(file_data, DECOMPRESSED_100_PLUS_32KB)
+
+    def test_encoding(self):
+        uncompressed = THIS_FILE_STR.replace(os.linesep, "\n")
+
+        with io.BytesIO() as bio:
+            with open(bio, "wt", encoding="utf-16-le") as f:
+                f.write(uncompressed)
+            file_data = decompress(bio.getvalue()).decode("utf-16-le")
+            self.assertEqual(file_data.replace(os.linesep, "\n"), uncompressed)
+            bio.seek(0)
+            with open(bio, "rt", encoding="utf-16-le") as f:
+                self.assertEqual(f.read().replace(os.linesep, "\n"), uncompressed)
+
+    def test_encoding_error_handler(self):
+        with io.BytesIO(compress(b"foo\xffbar")) as bio:
+            with open(bio, "rt", encoding="ascii", errors="ignore") as f:
+                self.assertEqual(f.read(), "foobar")
+
+    def test_newline(self):
+        # Test with explicit newline (universal newline mode disabled).
+        text = THIS_FILE_STR.replace(os.linesep, "\n")
+        with io.BytesIO() as bio:
+            with open(bio, "wt", encoding="utf-8", newline="\n") as f:
+                f.write(text)
+            bio.seek(0)
+            with open(bio, "rt", encoding="utf-8", newline="\r") as f:
+                self.assertEqual(f.readlines(), [text])
+
+    def test_x_mode(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_f:
+            TESTFN = pathlib.Path(tmp_f.name)
+
+        for mode in ("x", "xb", "xt"):
+            os.remove(TESTFN)
+
+            if mode == "xt":
+                encoding = "utf-8"
+            else:
+                encoding = None
+            with open(TESTFN, mode, encoding=encoding):
+                pass
+            with self.assertRaises(FileExistsError):
+                with open(TESTFN, mode):
+                    pass
+
+        os.remove(TESTFN)
+
+    def test_open_dict(self):
+        # default
+        bi = io.BytesIO()
+        with open(bi, 'w', zstd_dict=TRAINED_DICT) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with open(bi, zstd_dict=TRAINED_DICT) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+        # .as_(un)digested_dict
+        bi = io.BytesIO()
+        with open(bi, 'w', zstd_dict=TRAINED_DICT.as_digested_dict) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with open(bi, zstd_dict=TRAINED_DICT.as_undigested_dict) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+        # invalid dictionary
+        bi = io.BytesIO()
+        with self.assertRaisesRegex(TypeError, 'zstd_dict'):
+            open(bi, 'w', zstd_dict={1:2, 2:3})
+
+        with self.assertRaisesRegex(TypeError, 'zstd_dict'):
+            open(bi, 'w', zstd_dict=b'1234567890')
+
+    def test_open_prefix(self):
+        bi = io.BytesIO()
+        with open(bi, 'w', zstd_dict=TRAINED_DICT.as_prefix) as f:
+            f.write(SAMPLES[0])
+        bi.seek(0)
+        with open(bi, zstd_dict=TRAINED_DICT.as_prefix) as f:
+            dat = f.read()
+        self.assertEqual(dat, SAMPLES[0])
+
+    def test_buffer_protocol(self):
+        # don't use len() for buffer protocol objects
+        arr = array.array("i", range(1000))
+        LENGTH = len(arr) * arr.itemsize
+
+        with open(io.BytesIO(), "wb") as f:
+            self.assertEqual(f.write(arr), LENGTH)
+            self.assertEqual(f.tell(), LENGTH)
+
+class FreeThreadingMethodTests(unittest.TestCase):
+
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_compress_locking(self):
+        input = b'a'* (16*_1K)
+        num_threads = 8
+
+        # gh-136394: the first output of .compress() includes the frame header
+        # we run the first .compress() call outside of the threaded portion
+        # to make the test order-independent
+
+        comp = ZstdCompressor()
+        parts = [comp.compress(input, ZstdCompressor.FLUSH_BLOCK)]
+        for _ in range(num_threads):
+            res = comp.compress(input, ZstdCompressor.FLUSH_BLOCK)
+            if res:
+                parts.append(res)
+        rest1 = comp.flush()
+        expected = b''.join(parts) + rest1
+
+        comp = ZstdCompressor()
+        output = [comp.compress(input, ZstdCompressor.FLUSH_BLOCK)]
+        def run_method(method, input_data, output_data):
+            res = method(input_data, ZstdCompressor.FLUSH_BLOCK)
+            if res:
+                output_data.append(res)
+        threads = []
+
+        for i in range(num_threads):
+            thread = threading.Thread(target=run_method, args=(comp.compress, input, output))
+
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+        rest2 = comp.flush()
+        self.assertEqual(rest1, rest2)
+        actual = b''.join(output) + rest2
+        self.assertEqual(expected, actual)
+
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_decompress_locking(self):
+        input = compress(b'a'* (16*_1K))
+        num_threads = 8
+        # to ensure we decompress over multiple calls, set maxsize
+        window_size = _1K * 16//num_threads
+
+        decomp = ZstdDecompressor()
+        parts = []
+        for _ in range(num_threads):
+            res = decomp.decompress(input, window_size)
+            if res:
+                parts.append(res)
+        expected = b''.join(parts)
+
+        comp = ZstdDecompressor()
+        output = []
+        def run_method(method, input_data, output_data):
+            res = method(input_data, window_size)
+            if res:
+                output_data.append(res)
+        threads = []
+
+        for i in range(num_threads):
+            thread = threading.Thread(target=run_method, args=(comp.decompress, input, output))
+
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+        actual = b''.join(output)
+        self.assertEqual(expected, actual)
+
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_compress_shared_dict(self):
+        num_threads = 8
+
+        def run_method(b):
+            level = threading.get_ident() % 4
+            # sync threads to increase chance of contention on
+            # capsule storing dictionary levels
+            b.wait()
+            ZstdCompressor(level=level,
+                           zstd_dict=TRAINED_DICT.as_digested_dict)
+            b.wait()
+            ZstdCompressor(level=level,
+                           zstd_dict=TRAINED_DICT.as_undigested_dict)
+            b.wait()
+            ZstdCompressor(level=level,
+                           zstd_dict=TRAINED_DICT.as_prefix)
+        threads = []
+
+        b = threading.Barrier(num_threads)
+        for i in range(num_threads):
+            thread = threading.Thread(target=run_method, args=(b,))
+
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+    @threading_helper.reap_threads
+    @threading_helper.requires_working_threading()
+    def test_decompress_shared_dict(self):
+        num_threads = 8
+
+        def run_method(b):
+            # sync threads to increase chance of contention on
+            # decompression dictionary
+            b.wait()
+            ZstdDecompressor(zstd_dict=TRAINED_DICT.as_digested_dict)
+            b.wait()
+            ZstdDecompressor(zstd_dict=TRAINED_DICT.as_undigested_dict)
+            b.wait()
+            ZstdDecompressor(zstd_dict=TRAINED_DICT.as_prefix)
+        threads = []
+
+        b = threading.Barrier(num_threads)
+        for i in range(num_threads):
+            thread = threading.Thread(target=run_method, args=(b,))
+
+            threads.append(thread)
+
+        with threading_helper.start_threads(threads):
+            pass
+
+
+if __name__ == "__main__":
+    unittest.main()

From 130bb82a43efcd75c1d6f7236c0f6b6b76e40c87 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 19 Jan 2026 02:45:00 +0900
Subject: [PATCH 376/418] LoadClosure as pseudo op (#6789)

---
 Lib/_opcode_metadata.py                       |  2 +-
 Lib/test/test__opcode.py                      |  1 -
 crates/codegen/src/compile.rs                 |  4 +--
 crates/codegen/src/ir.rs                      |  7 +++++
 .../compiler-core/src/bytecode/instruction.rs | 12 ++-----
 crates/stdlib/src/opcode.rs                   |  1 -
 crates/vm/src/frame.rs                        | 31 +++++++++++++------
 7 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 34e73bf31b4..efb5f21e7fb 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -233,7 +233,6 @@
     'INSTRUMENTED_POP_JUMP_IF_NONE': 252,
     'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253,
     'INSTRUMENTED_LINE': 254,
-    'LOAD_CLOSURE': 255,
     'JUMP': 256,
     'JUMP_NO_INTERRUPT': 257,
     'RESERVED_258': 258,
@@ -246,6 +245,7 @@
     'SETUP_FINALLY': 265,
     'SETUP_WITH': 266,
     'STORE_FAST_MAYBE_NULL': 267,
+    'LOAD_CLOSURE': 268,
 }
 
 # CPython 3.13 compatible: opcodes < 44 have no argument
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index 045e010db4c..9d9d7f95f29 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -16,7 +16,6 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertIsInstance(func(op), bool)
                 self.assertEqual(func(op), expected)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Move LoadClosure to psudoes
     def test_invalid_opcodes(self):
         invalid = [-100, -1, 255, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index be7807ec411..a76d2b3446b 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -4074,7 +4074,7 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, Instruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
             }
 
             // Build tuple of closure variables
@@ -4297,7 +4297,7 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
             emit!(self, Instruction::Copy { index: 1_u32 });
             let classcell = self.name("__classcell__");
             emit!(self, Instruction::StoreName(classcell));
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index bb350abeebf..8d0d1f7f73c 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -263,6 +263,13 @@ impl CodeInfo {
                         info.arg = OpArg(encoded);
                         info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
                     }
+                    // LOAD_CLOSURE pseudo → LOAD_FAST (with varnames offset)
+                    PseudoInstruction::LoadClosure(idx) => {
+                        let varnames_len = varname_cache.len() as u32;
+                        let new_idx = varnames_len + idx.get(info.arg);
+                        info.arg = OpArg(new_idx);
+                        info.instr = Instruction::LoadFast(Arg::marker()).into();
+                    }
                     PseudoInstruction::Jump { .. } => {
                         // PseudoInstruction::Jump instructions are handled later
                     }
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 4faf67d273b..37a015ce76d 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -383,8 +383,6 @@ pub enum Instruction {
     InstrumentedPopJumpIfNone = 252,            // Placeholder
     InstrumentedPopJumpIfNotNone = 253,         // Placeholder
     InstrumentedLine = 254,                     // Placeholder
-    // Pseudos (needs to be moved to `PseudoInstruction` enum.
-    LoadClosure(Arg<NameIdx>) = 255, // TODO: Move to pseudos
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -415,9 +413,6 @@ impl TryFrom<u8> for Instruction {
         let instrumented_start = u8::from(Self::InstrumentedResume);
         let instrumented_end = u8::from(Self::InstrumentedLine);
 
-        // TODO: Remove this; This instruction needs to be pseudo
-        let load_closure = u8::from(Self::LoadClosure(Arg::marker()));
-
         // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
         let custom_ops: &[u8] = &[
             u8::from(Self::Break {
@@ -457,7 +452,6 @@ impl TryFrom<u8> for Instruction {
 
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
-            || value == load_closure
             || custom_ops.contains(&value)
             || (specialized_start..=specialized_end).contains(&value)
             || (instrumented_start..=instrumented_end).contains(&value)
@@ -704,7 +698,6 @@ impl InstructionMetadata for Instruction {
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
             Self::PopJumpIfNotNone { .. } => 0,
-            Self::LoadClosure(_) => 1,
             Self::BinaryOpAddFloat => 0,
             Self::BinaryOpAddInt => 0,
             Self::BinaryOpAddUnicode => 0,
@@ -935,7 +928,6 @@ impl InstructionMetadata for Instruction {
             }
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
             Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            Self::LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
             Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
             Self::LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
             Self::LoadFast(idx) => w!(LOAD_FAST, varname = idx),
@@ -1037,6 +1029,7 @@ pub enum PseudoInstruction {
     SetupFinally = 265,       // Placeholder
     SetupWith = 266,          // Placeholder
     StoreFastMaybeNull = 267, // Placeholder
+    LoadClosure(Arg<NameIdx>) = 268,
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
@@ -1057,7 +1050,7 @@ impl TryFrom<u16> for PseudoInstruction {
         let start = u16::from(Self::Jump {
             target: Arg::marker(),
         });
-        let end = u16::from(Self::StoreFastMaybeNull);
+        let end = u16::from(Self::LoadClosure(Arg::marker()));
 
         if (start..=end).contains(&value) {
             Ok(unsafe { mem::transmute::<u16, Self>(value) })
@@ -1093,6 +1086,7 @@ impl InstructionMetadata for PseudoInstruction {
             Self::SetupWith => 0,
             Self::StoreFastMaybeNull => 0,
             Self::Reserved258 => 0,
+            Self::LoadClosure(_) => 1,
         }
     }
 
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index fcde0de36ef..92d5d407aff 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -125,7 +125,6 @@ mod opcode {
                 Ok(AnyInstruction::Real(
                     Instruction::DeleteDeref(_)
                         | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadClosure(_)
                         | Instruction::LoadDeref(_)
                         | Instruction::StoreDeref(_)
                 ))
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 55788ee3e4a..a6ef4c5363b 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "flame")]
+use crate::bytecode::InstructionMetadata;
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{
@@ -137,10 +139,24 @@ impl Frame {
         func_obj: Option<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> Self {
-        let cells_frees = core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
-            .take(code.cellvars.len())
-            .chain(closure.iter().cloned())
-            .collect();
+        let nlocals = code.varnames.len();
+        let num_cells = code.cellvars.len();
+        let nfrees = closure.len();
+
+        let cells_frees: Box<[PyCellRef]> =
+            core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
+                .take(num_cells)
+                .chain(closure.iter().cloned())
+                .collect();
+
+        // Extend fastlocals to include varnames + cellvars + freevars (localsplus)
+        let total_locals = nlocals + num_cells + nfrees;
+        let mut fastlocals_vec: Vec<Option<PyObjectRef>> = vec![None; total_locals];
+
+        // Store cell objects at cellvars and freevars positions
+        for (i, cell) in cells_frees.iter().enumerate() {
+            fastlocals_vec[nlocals + i] = Some(cell.clone().into());
+        }
 
         let state = FrameState {
             stack: BoxVec::new(code.max_stackdepth as usize),
@@ -149,7 +165,7 @@ impl Frame {
         };
 
         Self {
-            fastlocals: PyMutex::new(vec![None; code.varnames.len()].into_boxed_slice()),
+            fastlocals: PyMutex::new(fastlocals_vec.into_boxed_slice()),
             cells_frees,
             locals: scope.locals,
             globals: scope.globals,
@@ -1213,11 +1229,6 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[i.get(arg) as usize].clone();
-                self.push_value(value.into());
-                Ok(None)
-            }
             Instruction::LoadConst { idx } => {
                 self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)

From 00440b179abfd39bdabc5a542aed2231993e15eb Mon Sep 17 00:00:00 2001
From: Jiseok CHOI <jiseok.dev@gmail.com>
Date: Mon, 19 Jan 2026 02:45:47 +0900
Subject: [PATCH 377/418] Update sqlite3 and the tests to CPython 3.14.2
 (#6787)

* Update sqlite3, dbm.sqlite3 and tests to CPython 3.14.2

* Add skip decorators for failing sqlite3 tests

Skip tests that fail due to unimplemented features or behavior differences:
- _iterdump not implemented (test_dump.py)
- Unraisable exception handling not implemented (test_hooks.py, test_userfunctions.py)
- Keyword-only arguments not supported for various methods
- Autocommit behavior differences (test_transactions.py)
- TransactionTests skipped due to timeout parameter type issue
- Various error message differences (test_dbapi.py)
- SQLITE_DBCONFIG constants not implemented
- Row and Connection signature inspection issues

All tests now pass with 95 skipped out of 493 total tests.

* Change @unittest.skip to @unittest.expectedFailure per code review

- Convert @unittest.skip decorators to @unittest.expectedFailure for tests that fail without panic/hang
- Keep @unittest.skip only for TransactionTests class (setUp fails with timeout=0 int type)

* fixup
---
 Lib/sqlite3/__init__.py                     |  15 +-
 Lib/sqlite3/__main__.py                     |  53 +-
 Lib/sqlite3/dbapi2.py                       |  14 +-
 Lib/sqlite3/dump.py                         |  69 +-
 Lib/test/test_dbm_sqlite3.py                |   7 +-
 Lib/test/test_sqlite3/__init__.py           |   5 +-
 Lib/test/test_sqlite3/test_backup.py        |  59 +-
 Lib/test/test_sqlite3/test_cli.py           | 218 ++++---
 Lib/test/test_sqlite3/test_dbapi.py         | 672 ++++++++++++--------
 Lib/test/test_sqlite3/test_dump.py          | 142 ++++-
 Lib/test/test_sqlite3/test_factory.py       | 116 ++--
 Lib/test/test_sqlite3/test_hooks.py         | 117 ++--
 Lib/test/test_sqlite3/test_regression.py    | 141 ++--
 Lib/test/test_sqlite3/test_transactions.py  | 230 ++++++-
 Lib/test/test_sqlite3/test_types.py         |  11 +-
 Lib/test/test_sqlite3/test_userfunctions.py | 235 +++----
 Lib/test/test_sqlite3/util.py               |  89 +++
 17 files changed, 1404 insertions(+), 789 deletions(-)
 create mode 100644 Lib/test/test_sqlite3/util.py

diff --git a/Lib/sqlite3/__init__.py b/Lib/sqlite3/__init__.py
index 927267cf0b9..ed727fae609 100644
--- a/Lib/sqlite3/__init__.py
+++ b/Lib/sqlite3/__init__.py
@@ -22,7 +22,7 @@
 
 """
 The sqlite3 extension module provides a DB-API 2.0 (PEP 249) compliant
-interface to the SQLite library, and requires SQLite 3.7.15 or newer.
+interface to the SQLite library, and requires SQLite 3.15.2 or newer.
 
 To use the module, start by creating a database Connection object:
 
@@ -55,16 +55,3 @@
 """
 
 from sqlite3.dbapi2 import *
-from sqlite3.dbapi2 import (_deprecated_names,
-                            _deprecated_version_info,
-                            _deprecated_version)
-
-
-def __getattr__(name):
-    if name in _deprecated_names:
-        from warnings import warn
-
-        warn(f"{name} is deprecated and will be removed in Python 3.14",
-             DeprecationWarning, stacklevel=2)
-        return globals()[f"_deprecated_{name}"]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/sqlite3/__main__.py b/Lib/sqlite3/__main__.py
index f8a5cca24e5..4ccf292ddf2 100644
--- a/Lib/sqlite3/__main__.py
+++ b/Lib/sqlite3/__main__.py
@@ -46,26 +46,34 @@ def runsource(self, source, filename="<input>", symbol="single"):
         """Override runsource, the core of the InteractiveConsole REPL.
 
         Return True if more input is needed; buffering is done automatically.
-        Return False is input is a complete statement ready for execution.
+        Return False if input is a complete statement ready for execution.
         """
-        match source:
-            case ".version":
-                print(f"{sqlite3.sqlite_version}")
-            case ".help":
-                print("Enter SQL code and press enter.")
-            case ".quit":
-                sys.exit(0)
-            case _:
-                if not sqlite3.complete_statement(source):
-                    return True
-                execute(self._cur, source)
+        if not source or source.isspace():
+            return False
+        if source[0] == ".":
+            match source[1:].strip():
+                case "version":
+                    print(f"{sqlite3.sqlite_version}")
+                case "help":
+                    print("Enter SQL code and press enter.")
+                case "quit":
+                    sys.exit(0)
+                case "":
+                    pass
+                case _ as unknown:
+                    self.write("Error: unknown command or invalid arguments:"
+                               f'  "{unknown}".\n')
+        else:
+            if not sqlite3.complete_statement(source):
+                return True
+            execute(self._cur, source)
         return False
 
 
-def main():
+def main(*args):
     parser = ArgumentParser(
         description="Python sqlite3 CLI",
-        prog="python -m sqlite3",
+        color=True,
     )
     parser.add_argument(
         "filename", type=str, default=":memory:", nargs="?",
@@ -86,7 +94,7 @@ def main():
         version=f"SQLite version {sqlite3.sqlite_version}",
         help="Print underlying SQLite library version",
     )
-    args = parser.parse_args()
+    args = parser.parse_args(*args)
 
     if args.filename == ":memory:":
         db_name = "a transient in-memory database"
@@ -94,12 +102,16 @@ def main():
         db_name = repr(args.filename)
 
     # Prepare REPL banner and prompts.
+    if sys.platform == "win32" and "idlelib.run" not in sys.modules:
+        eofkey = "CTRL-Z"
+    else:
+        eofkey = "CTRL-D"
     banner = dedent(f"""
         sqlite3 shell, running on SQLite version {sqlite3.sqlite_version}
         Connected to {db_name}
 
         Each command will be run using execute() on the cursor.
-        Type ".help" for more information; type ".quit" or CTRL-D to quit.
+        Type ".help" for more information; type ".quit" or {eofkey} to quit.
     """).strip()
     sys.ps1 = "sqlite> "
     sys.ps2 = "    ... "
@@ -112,9 +124,16 @@ def main():
         else:
             # No SQL provided; start the REPL.
             console = SqliteInteractiveConsole(con)
+            try:
+                import readline  # noqa: F401
+            except ImportError:
+                pass
             console.interact(banner, exitmsg="")
     finally:
         con.close()
 
+    sys.exit(0)
+
 
-main()
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/Lib/sqlite3/dbapi2.py b/Lib/sqlite3/dbapi2.py
index 56fc0461e6c..0315760516e 100644
--- a/Lib/sqlite3/dbapi2.py
+++ b/Lib/sqlite3/dbapi2.py
@@ -25,9 +25,6 @@
 import collections.abc
 
 from _sqlite3 import *
-from _sqlite3 import _deprecated_version
-
-_deprecated_names = frozenset({"version", "version_info"})
 
 paramstyle = "qmark"
 
@@ -48,7 +45,7 @@ def TimeFromTicks(ticks):
 def TimestampFromTicks(ticks):
     return Timestamp(*time.localtime(ticks)[:6])
 
-_deprecated_version_info = tuple(map(int, _deprecated_version.split(".")))
+
 sqlite_version_info = tuple([int(x) for x in sqlite_version.split(".")])
 
 Binary = memoryview
@@ -97,12 +94,3 @@ def convert_timestamp(val):
 # Clean up namespace
 
 del(register_adapters_and_converters)
-
-def __getattr__(name):
-    if name in _deprecated_names:
-        from warnings import warn
-
-        warn(f"{name} is deprecated and will be removed in Python 3.14",
-             DeprecationWarning, stacklevel=2)
-        return globals()[f"_deprecated_{name}"]
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/sqlite3/dump.py b/Lib/sqlite3/dump.py
index 07b9da10b92..57e6a3b4f1e 100644
--- a/Lib/sqlite3/dump.py
+++ b/Lib/sqlite3/dump.py
@@ -7,7 +7,15 @@
 # future enhancements, you should normally quote any identifier that
 # is an English language word, even if you do not have to."
 
-def _iterdump(connection):
+def _quote_name(name):
+    return '"{0}"'.format(name.replace('"', '""'))
+
+
+def _quote_value(value):
+    return "'{0}'".format(value.replace("'", "''"))
+
+
+def _iterdump(connection, *, filter=None):
     """
     Returns an iterator to the dump of the database in an SQL text format.
 
@@ -16,64 +24,87 @@ def _iterdump(connection):
     directly but instead called from the Connection method, iterdump().
     """
 
+    writeable_schema = False
     cu = connection.cursor()
+    cu.row_factory = None  # Make sure we get predictable results.
+    # Disable foreign key constraints, if there is any foreign key violation.
+    violations = cu.execute("PRAGMA foreign_key_check").fetchall()
+    if violations:
+        yield('PRAGMA foreign_keys=OFF;')
     yield('BEGIN TRANSACTION;')
 
+    if filter:
+        # Return database objects which match the filter pattern.
+        filter_name_clause = 'AND "name" LIKE ?'
+        params = [filter]
+    else:
+        filter_name_clause = ""
+        params = []
     # sqlite_master table contains the SQL CREATE statements for the database.
-    q = """
+    q = f"""
         SELECT "name", "type", "sql"
         FROM "sqlite_master"
             WHERE "sql" NOT NULL AND
             "type" == 'table'
+            {filter_name_clause}
             ORDER BY "name"
         """
-    schema_res = cu.execute(q)
+    schema_res = cu.execute(q, params)
     sqlite_sequence = []
     for table_name, type, sql in schema_res.fetchall():
         if table_name == 'sqlite_sequence':
-            rows = cu.execute('SELECT * FROM "sqlite_sequence";').fetchall()
+            rows = cu.execute('SELECT * FROM "sqlite_sequence";')
             sqlite_sequence = ['DELETE FROM "sqlite_sequence"']
             sqlite_sequence += [
-                f'INSERT INTO "sqlite_sequence" VALUES(\'{row[0]}\',{row[1]})'
-                for row in rows
+                f'INSERT INTO "sqlite_sequence" VALUES({_quote_value(table_name)},{seq_value})'
+                for table_name, seq_value in rows.fetchall()
             ]
             continue
         elif table_name == 'sqlite_stat1':
             yield('ANALYZE "sqlite_master";')
         elif table_name.startswith('sqlite_'):
             continue
-        # NOTE: Virtual table support not implemented
-        #elif sql.startswith('CREATE VIRTUAL TABLE'):
-        #    qtable = table_name.replace("'", "''")
-        #    yield("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"\
-        #        "VALUES('table','{0}','{0}',0,'{1}');".format(
-        #        qtable,
-        #        sql.replace("''")))
+        elif sql.startswith('CREATE VIRTUAL TABLE'):
+            if not writeable_schema:
+                writeable_schema = True
+                yield('PRAGMA writable_schema=ON;')
+            yield("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
+                  "VALUES('table',{0},{0},0,{1});".format(
+                      _quote_value(table_name),
+                      _quote_value(sql),
+                  ))
         else:
             yield('{0};'.format(sql))
 
         # Build the insert statement for each row of the current table
-        table_name_ident = table_name.replace('"', '""')
-        res = cu.execute('PRAGMA table_info("{0}")'.format(table_name_ident))
+        table_name_ident = _quote_name(table_name)
+        res = cu.execute(f'PRAGMA table_info({table_name_ident})')
         column_names = [str(table_info[1]) for table_info in res.fetchall()]
-        q = """SELECT 'INSERT INTO "{0}" VALUES({1})' FROM "{0}";""".format(
+        q = "SELECT 'INSERT INTO {0} VALUES('{1}')' FROM {0};".format(
             table_name_ident,
-            ",".join("""'||quote("{0}")||'""".format(col.replace('"', '""')) for col in column_names))
+            "','".join(
+                "||quote({0})||".format(_quote_name(col)) for col in column_names
+            )
+        )
         query_res = cu.execute(q)
         for row in query_res:
             yield("{0};".format(row[0]))
 
     # Now when the type is 'index', 'trigger', or 'view'
-    q = """
+    q = f"""
         SELECT "name", "type", "sql"
         FROM "sqlite_master"
             WHERE "sql" NOT NULL AND
             "type" IN ('index', 'trigger', 'view')
+            {filter_name_clause}
         """
-    schema_res = cu.execute(q)
+    schema_res = cu.execute(q, params)
     for name, type, sql in schema_res.fetchall():
         yield('{0};'.format(sql))
 
+    if writeable_schema:
+        yield('PRAGMA writable_schema=OFF;')
+
     # gh-79009: Yield statements concerning the sqlite_sequence table at the
     # end of the transaction.
     for row in sqlite_sequence:
diff --git a/Lib/test/test_dbm_sqlite3.py b/Lib/test/test_dbm_sqlite3.py
index 39eac7a35ec..f367a98865d 100644
--- a/Lib/test/test_dbm_sqlite3.py
+++ b/Lib/test/test_dbm_sqlite3.py
@@ -1,12 +1,11 @@
 import os
 import stat
 import sys
-import test.support
 import unittest
 from contextlib import closing
 from functools import partial
 from pathlib import Path
-from test.support import cpython_only, import_helper, os_helper
+from test.support import import_helper, os_helper
 
 dbm_sqlite3 = import_helper.import_module("dbm.sqlite3")
 # N.B. The test will fail on some platforms without sqlite3
@@ -44,7 +43,7 @@ def test_uri_substitutions(self):
         )
         for path, normalized in dataset:
             with self.subTest(path=path, normalized=normalized):
-                self.assertTrue(_normalize_uri(path).endswith(normalized))
+                self.assertEndsWith(_normalize_uri(path), normalized)
 
     @unittest.skipUnless(sys.platform == "win32", "requires Windows")
     def test_uri_windows(self):
@@ -63,7 +62,7 @@ def test_uri_windows(self):
             with self.subTest(path=path, normalized=normalized):
                 if not Path(path).is_absolute():
                     self.skipTest(f"skipping relative path: {path!r}")
-                self.assertTrue(_normalize_uri(path).endswith(normalized))
+                self.assertEndsWith(_normalize_uri(path), normalized)
 
 
 class ReadOnly(_SQLiteDbmTests):
diff --git a/Lib/test/test_sqlite3/__init__.py b/Lib/test/test_sqlite3/__init__.py
index d777fca82da..78a1e2078a5 100644
--- a/Lib/test/test_sqlite3/__init__.py
+++ b/Lib/test/test_sqlite3/__init__.py
@@ -8,8 +8,7 @@
 
 # Implement the unittest "load tests" protocol.
 def load_tests(*args):
+    if verbose:
+        print(f"test_sqlite3: testing with SQLite version {sqlite3.sqlite_version}")
     pkg_dir = os.path.dirname(__file__)
     return load_package_tests(pkg_dir, *args)
-
-if verbose:
-    print(f"test_sqlite3: testing with SQLite version {sqlite3.sqlite_version}")
diff --git a/Lib/test/test_sqlite3/test_backup.py b/Lib/test/test_sqlite3/test_backup.py
index fb3a83e3b0e..9d31978b1ad 100644
--- a/Lib/test/test_sqlite3/test_backup.py
+++ b/Lib/test/test_sqlite3/test_backup.py
@@ -1,6 +1,8 @@
 import sqlite3 as sqlite
 import unittest
 
+from .util import memory_database
+
 
 class BackupTests(unittest.TestCase):
     def setUp(self):
@@ -32,34 +34,32 @@ def test_bad_target_same_connection(self):
             self.cx.backup(self.cx)
 
     def test_bad_target_closed_connection(self):
-        bck = sqlite.connect(':memory:')
-        bck.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            self.cx.backup(bck)
+        with memory_database() as bck:
+            bck.close()
+            with self.assertRaises(sqlite.ProgrammingError):
+                self.cx.backup(bck)
 
     def test_bad_source_closed_connection(self):
-        bck = sqlite.connect(':memory:')
-        source = sqlite.connect(":memory:")
-        source.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            source.backup(bck)
+        with memory_database() as bck:
+            source = sqlite.connect(":memory:")
+            source.close()
+            with self.assertRaises(sqlite.ProgrammingError):
+                source.backup(bck)
 
     def test_bad_target_in_transaction(self):
-        bck = sqlite.connect(':memory:')
-        bck.execute('CREATE TABLE bar (key INTEGER)')
-        bck.executemany('INSERT INTO bar (key) VALUES (?)', [(3,), (4,)])
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            self.cx.backup(bck)
-        if sqlite.sqlite_version_info < (3, 8, 8):
-            self.assertEqual(str(cm.exception), 'target is in transaction')
+        with memory_database() as bck:
+            bck.execute('CREATE TABLE bar (key INTEGER)')
+            bck.executemany('INSERT INTO bar (key) VALUES (?)', [(3,), (4,)])
+            with self.assertRaises(sqlite.OperationalError) as cm:
+                self.cx.backup(bck)
 
     def test_keyword_only_args(self):
         with self.assertRaises(TypeError):
-            with sqlite.connect(':memory:') as bck:
+            with memory_database() as bck:
                 self.cx.backup(bck, 1)
 
     def test_simple(self):
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck)
             self.verify_backup(bck)
 
@@ -69,7 +69,7 @@ def test_progress(self):
         def progress(status, remaining, total):
             journal.append(status)
 
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, pages=1, progress=progress)
             self.verify_backup(bck)
 
@@ -83,7 +83,7 @@ def test_progress_all_pages_at_once_1(self):
         def progress(status, remaining, total):
             journal.append(remaining)
 
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, progress=progress)
             self.verify_backup(bck)
 
@@ -96,18 +96,17 @@ def test_progress_all_pages_at_once_2(self):
         def progress(status, remaining, total):
             journal.append(remaining)
 
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, pages=-1, progress=progress)
             self.verify_backup(bck)
 
         self.assertEqual(len(journal), 1)
         self.assertEqual(journal[0], 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_callable_progress(self):
         with self.assertRaises(TypeError) as cm:
-            with sqlite.connect(':memory:') as bck:
+            with memory_database() as bck:
                 self.cx.backup(bck, pages=1, progress='bar')
         self.assertEqual(str(cm.exception), 'progress argument must be a callable')
 
@@ -120,7 +119,7 @@ def progress(status, remaining, total):
                 self.cx.commit()
             journal.append(remaining)
 
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, pages=1, progress=progress)
             self.verify_backup(bck)
 
@@ -139,17 +138,17 @@ def progress(status, remaining, total):
             raise SystemError('nearly out of space')
 
         with self.assertRaises(SystemError) as err:
-            with sqlite.connect(':memory:') as bck:
+            with memory_database() as bck:
                 self.cx.backup(bck, progress=progress)
         self.assertEqual(str(err.exception), 'nearly out of space')
 
     def test_database_source_name(self):
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, name='main')
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, name='temp')
         with self.assertRaises(sqlite.OperationalError) as cm:
-            with sqlite.connect(':memory:') as bck:
+            with memory_database() as bck:
                 self.cx.backup(bck, name='non-existing')
         self.assertIn("unknown database", str(cm.exception))
 
@@ -157,7 +156,7 @@ def test_database_source_name(self):
         self.cx.execute('CREATE TABLE attached_db.foo (key INTEGER)')
         self.cx.executemany('INSERT INTO attached_db.foo (key) VALUES (?)', [(3,), (4,)])
         self.cx.commit()
-        with sqlite.connect(':memory:') as bck:
+        with memory_database() as bck:
             self.cx.backup(bck, name='attached_db')
             self.verify_backup(bck)
 
diff --git a/Lib/test/test_sqlite3/test_cli.py b/Lib/test/test_sqlite3/test_cli.py
index 560cd9efc5c..a03d7cbe16b 100644
--- a/Lib/test/test_sqlite3/test_cli.py
+++ b/Lib/test/test_sqlite3/test_cli.py
@@ -1,52 +1,52 @@
 """sqlite3 CLI tests."""
-
-import sqlite3 as sqlite
-import subprocess
-import sys
+import sqlite3
 import unittest
 
-from test.support import SHORT_TIMEOUT#, requires_subprocess
+from sqlite3.__main__ import main as cli
 from test.support.os_helper import TESTFN, unlink
+from test.support import (
+    captured_stdout,
+    captured_stderr,
+    captured_stdin,
+    force_not_colorized,
+)
 
 
-# TODO: RUSTPYTHON
-#@requires_subprocess()
 class CommandLineInterface(unittest.TestCase):
 
     def _do_test(self, *args, expect_success=True):
-        with subprocess.Popen(
-            [sys.executable, "-Xutf8", "-m", "sqlite3", *args],
-            encoding="utf-8",
-            bufsize=0,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        ) as proc:
-            proc.wait()
-            if expect_success == bool(proc.returncode):
-                self.fail("".join(proc.stderr))
-            stdout = proc.stdout.read()
-            stderr = proc.stderr.read()
-            if expect_success:
-                self.assertEqual(stderr, "")
-            else:
-                self.assertEqual(stdout, "")
-            return stdout, stderr
+        with (
+            captured_stdout() as out,
+            captured_stderr() as err,
+            self.assertRaises(SystemExit) as cm
+        ):
+            cli(args)
+        return out.getvalue(), err.getvalue(), cm.exception.code
 
     def expect_success(self, *args):
-        out, _ = self._do_test(*args)
+        out, err, code = self._do_test(*args)
+        self.assertEqual(code, 0,
+                         "\n".join([f"Unexpected failure: {args=}", out, err]))
+        self.assertEqual(err, "")
         return out
 
     def expect_failure(self, *args):
-        _, err = self._do_test(*args, expect_success=False)
+        out, err, code = self._do_test(*args, expect_success=False)
+        self.assertNotEqual(code, 0,
+                            "\n".join([f"Unexpected failure: {args=}", out, err]))
+        self.assertEqual(out, "")
         return err
 
+    @force_not_colorized
     def test_cli_help(self):
         out = self.expect_success("-h")
-        self.assertIn("usage: python -m sqlite3", out)
+        self.assertIn("usage: ", out)
+        self.assertIn(" [-h] [-v] [filename] [sql]", out)
+        self.assertIn("Python sqlite3 CLI", out)
 
     def test_cli_version(self):
         out = self.expect_success("-v")
-        self.assertIn(sqlite.sqlite_version, out)
+        self.assertIn(sqlite3.sqlite_version, out)
 
     def test_cli_execute_sql(self):
         out = self.expect_success(":memory:", "select 1")
@@ -69,88 +69,126 @@ def test_cli_on_disk_db(self):
         self.assertIn("(0,)", out)
 
 
-# TODO: RUSTPYTHON
-#@requires_subprocess()
 class InteractiveSession(unittest.TestCase):
-    TIMEOUT = SHORT_TIMEOUT / 10.
     MEMORY_DB_MSG = "Connected to a transient in-memory database"
     PS1 = "sqlite> "
     PS2 = "... "
 
-    def start_cli(self, *args):
-        return subprocess.Popen(
-            [sys.executable, "-Xutf8", "-m", "sqlite3", *args],
-            encoding="utf-8",
-            bufsize=0,
-            stdin=subprocess.PIPE,
-            # Note: the banner is printed to stderr, the prompt to stdout.
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-
-    def expect_success(self, proc):
-        proc.wait()
-        if proc.returncode:
-            self.fail("".join(proc.stderr))
+    def run_cli(self, *args, commands=()):
+        with (
+            captured_stdin() as stdin,
+            captured_stdout() as stdout,
+            captured_stderr() as stderr,
+            self.assertRaises(SystemExit) as cm
+        ):
+            for cmd in commands:
+                stdin.write(cmd + "\n")
+            stdin.seek(0)
+            cli(args)
+
+        out = stdout.getvalue()
+        err = stderr.getvalue()
+        self.assertEqual(cm.exception.code, 0,
+                         f"Unexpected failure: {args=}\n{out}\n{err}")
+        return out, err
 
     def test_interact(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn(self.PS1, out)
-            self.expect_success(proc)
+        out, err = self.run_cli()
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 1)
+        self.assertEqual(out.count(self.PS2), 0)
 
     def test_interact_quit(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(input=".quit", timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn(self.PS1, out)
-            self.expect_success(proc)
+        out, err = self.run_cli(commands=(".quit",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 1)
+        self.assertEqual(out.count(self.PS2), 0)
 
     def test_interact_version(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(input=".version", timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn(sqlite.sqlite_version, out)
-            self.expect_success(proc)
+        out, err = self.run_cli(commands=(".version",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertIn(sqlite3.sqlite_version + "\n", out)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 0)
+        self.assertIn(sqlite3.sqlite_version, out)
+
+    def test_interact_empty_source(self):
+        out, err = self.run_cli(commands=("", " "))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 3)
+        self.assertEqual(out.count(self.PS2), 0)
+
+    def test_interact_dot_commands_unknown(self):
+        out, err = self.run_cli(commands=(".unknown_command", ))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 0)
+        self.assertIn("Error", err)
+        # test "unknown_command" is pointed out in the error message
+        self.assertIn("unknown_command", err)
+
+    def test_interact_dot_commands_empty(self):
+        out, err = self.run_cli(commands=("."))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 0)
+
+    def test_interact_dot_commands_with_whitespaces(self):
+        out, err = self.run_cli(commands=(".version ", ". version"))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEqual(out.count(sqlite3.sqlite_version + "\n"), 2)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 3)
+        self.assertEqual(out.count(self.PS2), 0)
 
     def test_interact_valid_sql(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(input="select 1;",
-                                        timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn("(1,)", out)
-            self.expect_success(proc)
+        out, err = self.run_cli(commands=("SELECT 1;",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertIn("(1,)\n", out)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 0)
+
+    def test_interact_incomplete_multiline_sql(self):
+        out, err = self.run_cli(commands=("SELECT 1",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertEndsWith(out, self.PS2)
+        self.assertEqual(out.count(self.PS1), 1)
+        self.assertEqual(out.count(self.PS2), 1)
 
     def test_interact_valid_multiline_sql(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(input="select 1\n;",
-                                        timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn(self.PS2, out)
-            self.assertIn("(1,)", out)
-            self.expect_success(proc)
+        out, err = self.run_cli(commands=("SELECT 1\n;",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertIn(self.PS2, out)
+        self.assertIn("(1,)\n", out)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 1)
 
     def test_interact_invalid_sql(self):
-        with self.start_cli() as proc:
-            out, err = proc.communicate(input="sel;", timeout=self.TIMEOUT)
-            self.assertIn(self.MEMORY_DB_MSG, err)
-            self.assertIn("OperationalError (SQLITE_ERROR)", err)
-            self.expect_success(proc)
+        out, err = self.run_cli(commands=("sel;",))
+        self.assertIn(self.MEMORY_DB_MSG, err)
+        self.assertIn("OperationalError (SQLITE_ERROR)", err)
+        self.assertEndsWith(out, self.PS1)
+        self.assertEqual(out.count(self.PS1), 2)
+        self.assertEqual(out.count(self.PS2), 0)
 
     def test_interact_on_disk_file(self):
         self.addCleanup(unlink, TESTFN)
-        with self.start_cli(TESTFN) as proc:
-            out, err = proc.communicate(input="create table t(t);",
-                                        timeout=self.TIMEOUT)
-            self.assertIn(TESTFN, err)
-            self.assertIn(self.PS1, out)
-            self.expect_success(proc)
-        with self.start_cli(TESTFN, "select count(t) from t") as proc:
-            out = proc.stdout.read()
-            err = proc.stderr.read()
-            self.assertIn("(0,)", out)
-            self.expect_success(proc)
+
+        out, err = self.run_cli(TESTFN, commands=("CREATE TABLE t(t);",))
+        self.assertIn(TESTFN, err)
+        self.assertEndsWith(out, self.PS1)
+
+        out, _ = self.run_cli(TESTFN, commands=("SELECT count(t) FROM t;",))
+        self.assertIn("(0,)\n", out)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_sqlite3/test_dbapi.py b/Lib/test/test_sqlite3/test_dbapi.py
index a3ddd660ccb..46f098e4655 100644
--- a/Lib/test/test_sqlite3/test_dbapi.py
+++ b/Lib/test/test_sqlite3/test_dbapi.py
@@ -21,6 +21,7 @@
 # 3. This notice may not be removed or altered from any source distribution.
 
 import contextlib
+import functools
 import os
 import sqlite3 as sqlite
 import subprocess
@@ -28,33 +29,18 @@
 import threading
 import unittest
 import urllib.parse
+import warnings
 
 from test.support import (
-    SHORT_TIMEOUT, check_disallow_instantiation,# requires_subprocess,
-    #is_emscripten, is_wasi
-# TODO: RUSTPYTHON
+    SHORT_TIMEOUT, check_disallow_instantiation, requires_subprocess
 )
-from test.support import threading_helper
-# TODO: RUSTPYTHON
-#from _testcapi import INT_MAX, ULLONG_MAX
+from test.support import gc_collect
+from test.support import threading_helper, import_helper
 from os import SEEK_SET, SEEK_CUR, SEEK_END
 from test.support.os_helper import TESTFN, TESTFN_UNDECODABLE, unlink, temp_dir, FakePath
 
-
-# Helper for temporary memory databases
-def memory_database(*args, **kwargs):
-    cx = sqlite.connect(":memory:", *args, **kwargs)
-    return contextlib.closing(cx)
-
-
-# Temporarily limit a database connection parameter
-@contextlib.contextmanager
-def cx_limit(cx, category=sqlite.SQLITE_LIMIT_SQL_LENGTH, limit=128):
-    try:
-        _prev = cx.setlimit(category, limit)
-        yield limit
-    finally:
-        cx.setlimit(category, _prev)
+from .util import memory_database, cx_limit
+from .util import MemoryDatabaseMixin
 
 
 class ModuleTests(unittest.TestCase):
@@ -62,17 +48,6 @@ def test_api_level(self):
         self.assertEqual(sqlite.apilevel, "2.0",
                          "apilevel is %s, should be 2.0" % sqlite.apilevel)
 
-    def test_deprecated_version(self):
-        msg = "deprecated and will be removed in Python 3.14"
-        for attr in "version", "version_info":
-            with self.subTest(attr=attr):
-                with self.assertWarnsRegex(DeprecationWarning, msg) as cm:
-                    getattr(sqlite, attr)
-                self.assertEqual(cm.filename,  __file__)
-                with self.assertWarnsRegex(DeprecationWarning, msg) as cm:
-                    getattr(sqlite.dbapi2, attr)
-                self.assertEqual(cm.filename,  __file__)
-
     def test_thread_safety(self):
         self.assertIn(sqlite.threadsafety, {0, 1, 3},
                       "threadsafety is %d, should be 0, 1 or 3" %
@@ -84,45 +59,34 @@ def test_param_style(self):
                          sqlite.paramstyle)
 
     def test_warning(self):
-        self.assertTrue(issubclass(sqlite.Warning, Exception),
-                     "Warning is not a subclass of Exception")
+        self.assertIsSubclass(sqlite.Warning, Exception)
 
     def test_error(self):
-        self.assertTrue(issubclass(sqlite.Error, Exception),
-                        "Error is not a subclass of Exception")
+        self.assertIsSubclass(sqlite.Error, Exception)
 
     def test_interface_error(self):
-        self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
-                        "InterfaceError is not a subclass of Error")
+        self.assertIsSubclass(sqlite.InterfaceError, sqlite.Error)
 
     def test_database_error(self):
-        self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
-                        "DatabaseError is not a subclass of Error")
+        self.assertIsSubclass(sqlite.DatabaseError, sqlite.Error)
 
     def test_data_error(self):
-        self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
-                        "DataError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.DataError, sqlite.DatabaseError)
 
     def test_operational_error(self):
-        self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
-                        "OperationalError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.OperationalError, sqlite.DatabaseError)
 
     def test_integrity_error(self):
-        self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
-                        "IntegrityError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.IntegrityError, sqlite.DatabaseError)
 
     def test_internal_error(self):
-        self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
-                        "InternalError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.InternalError, sqlite.DatabaseError)
 
     def test_programming_error(self):
-        self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
-                        "ProgrammingError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.ProgrammingError, sqlite.DatabaseError)
 
     def test_not_supported_error(self):
-        self.assertTrue(issubclass(sqlite.NotSupportedError,
-                                   sqlite.DatabaseError),
-                        "NotSupportedError is not a subclass of DatabaseError")
+        self.assertIsSubclass(sqlite.NotSupportedError, sqlite.DatabaseError)
 
     def test_module_constants(self):
         consts = [
@@ -167,6 +131,7 @@ def test_module_constants(self):
             "SQLITE_INTERNAL",
             "SQLITE_INTERRUPT",
             "SQLITE_IOERR",
+            "SQLITE_LIMIT_WORKER_THREADS",
             "SQLITE_LOCKED",
             "SQLITE_MISMATCH",
             "SQLITE_MISUSE",
@@ -174,6 +139,7 @@ def test_module_constants(self):
             "SQLITE_NOMEM",
             "SQLITE_NOTADB",
             "SQLITE_NOTFOUND",
+            "SQLITE_NOTICE",
             "SQLITE_OK",
             "SQLITE_PERM",
             "SQLITE_PRAGMA",
@@ -181,6 +147,7 @@ def test_module_constants(self):
             "SQLITE_RANGE",
             "SQLITE_READ",
             "SQLITE_READONLY",
+            "SQLITE_RECURSIVE",
             "SQLITE_REINDEX",
             "SQLITE_ROW",
             "SQLITE_SAVEPOINT",
@@ -189,6 +156,7 @@ def test_module_constants(self):
             "SQLITE_TOOBIG",
             "SQLITE_TRANSACTION",
             "SQLITE_UPDATE",
+            "SQLITE_WARNING",
             # Run-time limit categories
             "SQLITE_LIMIT_LENGTH",
             "SQLITE_LIMIT_SQL_LENGTH",
@@ -202,32 +170,43 @@ def test_module_constants(self):
             "SQLITE_LIMIT_VARIABLE_NUMBER",
             "SQLITE_LIMIT_TRIGGER_DEPTH",
         ]
-        if sqlite.sqlite_version_info >= (3, 7, 17):
-            consts += ["SQLITE_NOTICE", "SQLITE_WARNING"]
-        if sqlite.sqlite_version_info >= (3, 8, 3):
-            consts.append("SQLITE_RECURSIVE")
-        if sqlite.sqlite_version_info >= (3, 8, 7):
-            consts.append("SQLITE_LIMIT_WORKER_THREADS")
         consts += ["PARSE_DECLTYPES", "PARSE_COLNAMES"]
         # Extended result codes
         consts += [
             "SQLITE_ABORT_ROLLBACK",
+            "SQLITE_AUTH_USER",
             "SQLITE_BUSY_RECOVERY",
+            "SQLITE_BUSY_SNAPSHOT",
+            "SQLITE_CANTOPEN_CONVPATH",
             "SQLITE_CANTOPEN_FULLPATH",
             "SQLITE_CANTOPEN_ISDIR",
             "SQLITE_CANTOPEN_NOTEMPDIR",
+            "SQLITE_CONSTRAINT_CHECK",
+            "SQLITE_CONSTRAINT_COMMITHOOK",
+            "SQLITE_CONSTRAINT_FOREIGNKEY",
+            "SQLITE_CONSTRAINT_FUNCTION",
+            "SQLITE_CONSTRAINT_NOTNULL",
+            "SQLITE_CONSTRAINT_PRIMARYKEY",
+            "SQLITE_CONSTRAINT_ROWID",
+            "SQLITE_CONSTRAINT_TRIGGER",
+            "SQLITE_CONSTRAINT_UNIQUE",
+            "SQLITE_CONSTRAINT_VTAB",
             "SQLITE_CORRUPT_VTAB",
             "SQLITE_IOERR_ACCESS",
+            "SQLITE_IOERR_AUTH",
             "SQLITE_IOERR_BLOCKED",
             "SQLITE_IOERR_CHECKRESERVEDLOCK",
             "SQLITE_IOERR_CLOSE",
+            "SQLITE_IOERR_CONVPATH",
             "SQLITE_IOERR_DELETE",
             "SQLITE_IOERR_DELETE_NOENT",
             "SQLITE_IOERR_DIR_CLOSE",
             "SQLITE_IOERR_DIR_FSYNC",
             "SQLITE_IOERR_FSTAT",
             "SQLITE_IOERR_FSYNC",
+            "SQLITE_IOERR_GETTEMPPATH",
             "SQLITE_IOERR_LOCK",
+            "SQLITE_IOERR_MMAP",
             "SQLITE_IOERR_NOMEM",
             "SQLITE_IOERR_RDLOCK",
             "SQLITE_IOERR_READ",
@@ -239,50 +218,18 @@ def test_module_constants(self):
             "SQLITE_IOERR_SHORT_READ",
             "SQLITE_IOERR_TRUNCATE",
             "SQLITE_IOERR_UNLOCK",
+            "SQLITE_IOERR_VNODE",
             "SQLITE_IOERR_WRITE",
             "SQLITE_LOCKED_SHAREDCACHE",
+            "SQLITE_NOTICE_RECOVER_ROLLBACK",
+            "SQLITE_NOTICE_RECOVER_WAL",
+            "SQLITE_OK_LOAD_PERMANENTLY",
             "SQLITE_READONLY_CANTLOCK",
+            "SQLITE_READONLY_DBMOVED",
             "SQLITE_READONLY_RECOVERY",
+            "SQLITE_READONLY_ROLLBACK",
+            "SQLITE_WARNING_AUTOINDEX",
         ]
-        if sqlite.sqlite_version_info >= (3, 7, 16):
-            consts += [
-                "SQLITE_CONSTRAINT_CHECK",
-                "SQLITE_CONSTRAINT_COMMITHOOK",
-                "SQLITE_CONSTRAINT_FOREIGNKEY",
-                "SQLITE_CONSTRAINT_FUNCTION",
-                "SQLITE_CONSTRAINT_NOTNULL",
-                "SQLITE_CONSTRAINT_PRIMARYKEY",
-                "SQLITE_CONSTRAINT_TRIGGER",
-                "SQLITE_CONSTRAINT_UNIQUE",
-                "SQLITE_CONSTRAINT_VTAB",
-                "SQLITE_READONLY_ROLLBACK",
-            ]
-        if sqlite.sqlite_version_info >= (3, 7, 17):
-            consts += [
-                "SQLITE_IOERR_MMAP",
-                "SQLITE_NOTICE_RECOVER_ROLLBACK",
-                "SQLITE_NOTICE_RECOVER_WAL",
-            ]
-        if sqlite.sqlite_version_info >= (3, 8, 0):
-            consts += [
-                "SQLITE_BUSY_SNAPSHOT",
-                "SQLITE_IOERR_GETTEMPPATH",
-                "SQLITE_WARNING_AUTOINDEX",
-            ]
-        if sqlite.sqlite_version_info >= (3, 8, 1):
-            consts += ["SQLITE_CANTOPEN_CONVPATH", "SQLITE_IOERR_CONVPATH"]
-        if sqlite.sqlite_version_info >= (3, 8, 2):
-            consts.append("SQLITE_CONSTRAINT_ROWID")
-        if sqlite.sqlite_version_info >= (3, 8, 3):
-            consts.append("SQLITE_READONLY_DBMOVED")
-        if sqlite.sqlite_version_info >= (3, 8, 7):
-            consts.append("SQLITE_AUTH_USER")
-        if sqlite.sqlite_version_info >= (3, 9, 0):
-            consts.append("SQLITE_IOERR_VNODE")
-        if sqlite.sqlite_version_info >= (3, 10, 0):
-            consts.append("SQLITE_IOERR_AUTH")
-        if sqlite.sqlite_version_info >= (3, 14, 1):
-            consts.append("SQLITE_OK_LOAD_PERMANENTLY")
         if sqlite.sqlite_version_info >= (3, 21, 0):
             consts += [
                 "SQLITE_IOERR_BEGIN_ATOMIC",
@@ -316,7 +263,7 @@ def test_module_constants(self):
             consts.append("SQLITE_IOERR_CORRUPTFS")
         for const in consts:
             with self.subTest(const=const):
-                self.assertTrue(hasattr(sqlite, const))
+                self.assertHasAttr(sqlite, const)
 
     def test_error_code_on_exception(self):
         err_msg = "unable to open database file"
@@ -330,10 +277,8 @@ def test_error_code_on_exception(self):
                 sqlite.connect(db)
             e = cm.exception
             self.assertEqual(e.sqlite_errorcode, err_code)
-            self.assertTrue(e.sqlite_errorname.startswith("SQLITE_CANTOPEN"))
+            self.assertStartsWith(e.sqlite_errorname, "SQLITE_CANTOPEN")
 
-    @unittest.skipIf(sqlite.sqlite_version_info <= (3, 7, 16),
-                     "Requires SQLite 3.7.16 or newer")
     def test_extended_error_code_on_exception(self):
         with memory_database() as con:
             with con:
@@ -347,9 +292,9 @@ def test_extended_error_code_on_exception(self):
             self.assertEqual(exc.sqlite_errorname, "SQLITE_CONSTRAINT_CHECK")
 
     def test_disallow_instantiation(self):
-        cx = sqlite.connect(":memory:")
-        check_disallow_instantiation(self, type(cx("select 1")))
-        check_disallow_instantiation(self, sqlite.Blob)
+        with memory_database() as cx:
+            check_disallow_instantiation(self, type(cx("select 1")))
+            check_disallow_instantiation(self, sqlite.Blob)
 
     def test_complete_statement(self):
         self.assertFalse(sqlite.complete_statement("select t"))
@@ -363,6 +308,7 @@ def setUp(self):
         cu = self.cx.cursor()
         cu.execute("create table test(id integer primary key, name text)")
         cu.execute("insert into test(name) values (?)", ("foo",))
+        cu.close()
 
     def tearDown(self):
         self.cx.close()
@@ -418,8 +364,7 @@ def test_use_after_close(self):
             with self.cx:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_exceptions(self):
         # Optional DB-API extension.
         self.assertEqual(self.cx.Warning, sqlite.Warning)
@@ -435,28 +380,28 @@ def test_exceptions(self):
 
     def test_in_transaction(self):
         # Can't use db from setUp because we want to test initial state.
-        cx = sqlite.connect(":memory:")
-        cu = cx.cursor()
-        self.assertEqual(cx.in_transaction, False)
-        cu.execute("create table transactiontest(id integer primary key, name text)")
-        self.assertEqual(cx.in_transaction, False)
-        cu.execute("insert into transactiontest(name) values (?)", ("foo",))
-        self.assertEqual(cx.in_transaction, True)
-        cu.execute("select name from transactiontest where name=?", ["foo"])
-        row = cu.fetchone()
-        self.assertEqual(cx.in_transaction, True)
-        cx.commit()
-        self.assertEqual(cx.in_transaction, False)
-        cu.execute("select name from transactiontest where name=?", ["foo"])
-        row = cu.fetchone()
-        self.assertEqual(cx.in_transaction, False)
+        with memory_database() as cx:
+            cu = cx.cursor()
+            self.assertEqual(cx.in_transaction, False)
+            cu.execute("create table transactiontest(id integer primary key, name text)")
+            self.assertEqual(cx.in_transaction, False)
+            cu.execute("insert into transactiontest(name) values (?)", ("foo",))
+            self.assertEqual(cx.in_transaction, True)
+            cu.execute("select name from transactiontest where name=?", ["foo"])
+            row = cu.fetchone()
+            self.assertEqual(cx.in_transaction, True)
+            cx.commit()
+            self.assertEqual(cx.in_transaction, False)
+            cu.execute("select name from transactiontest where name=?", ["foo"])
+            row = cu.fetchone()
+            self.assertEqual(cx.in_transaction, False)
+            cu.close()
 
     def test_in_transaction_ro(self):
         with self.assertRaises(AttributeError):
             self.cx.in_transaction = True
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_connection_exceptions(self):
         exceptions = [
             "DataError",
@@ -471,14 +416,13 @@ def test_connection_exceptions(self):
         ]
         for exc in exceptions:
             with self.subTest(exc=exc):
-                self.assertTrue(hasattr(self.cx, exc))
+                self.assertHasAttr(self.cx, exc)
                 self.assertIs(getattr(sqlite, exc), getattr(self.cx, exc))
 
     def test_interrupt_on_closed_db(self):
-        cx = sqlite.connect(":memory:")
-        cx.close()
+        self.cx.close()
         with self.assertRaises(sqlite.ProgrammingError):
-            cx.interrupt()
+            self.cx.interrupt()
 
     def test_interrupt(self):
         self.assertIsNone(self.cx.interrupt())
@@ -546,29 +490,29 @@ def test_connection_init_good_isolation_levels(self):
                     self.assertEqual(cx.isolation_level, level)
 
     def test_connection_reinit(self):
-        db = ":memory:"
-        cx = sqlite.connect(db)
-        cx.text_factory = bytes
-        cx.row_factory = sqlite.Row
-        cu = cx.cursor()
-        cu.execute("create table foo (bar)")
-        cu.executemany("insert into foo (bar) values (?)",
-                       ((str(v),) for v in range(4)))
-        cu.execute("select bar from foo")
-
-        rows = [r for r in cu.fetchmany(2)]
-        self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
-        self.assertEqual([r[0] for r in rows], [b"0", b"1"])
-
-        cx.__init__(db)
-        cx.execute("create table foo (bar)")
-        cx.executemany("insert into foo (bar) values (?)",
-                       ((v,) for v in ("a", "b", "c", "d")))
-
-        # This uses the old database, old row factory, but new text factory
-        rows = [r for r in cu.fetchall()]
-        self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
-        self.assertEqual([r[0] for r in rows], ["2", "3"])
+        with memory_database() as cx:
+            cx.text_factory = bytes
+            cx.row_factory = sqlite.Row
+            cu = cx.cursor()
+            cu.execute("create table foo (bar)")
+            cu.executemany("insert into foo (bar) values (?)",
+                           ((str(v),) for v in range(4)))
+            cu.execute("select bar from foo")
+
+            rows = [r for r in cu.fetchmany(2)]
+            self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
+            self.assertEqual([r[0] for r in rows], [b"0", b"1"])
+
+            cx.__init__(":memory:")
+            cx.execute("create table foo (bar)")
+            cx.executemany("insert into foo (bar) values (?)",
+                           ((v,) for v in ("a", "b", "c", "d")))
+
+            # This uses the old database, old row factory, but new text factory
+            rows = [r for r in cu.fetchall()]
+            self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
+            self.assertEqual([r[0] for r in rows], ["2", "3"])
+            cu.close()
 
     def test_connection_bad_reinit(self):
         cx = sqlite.connect(":memory:")
@@ -583,6 +527,58 @@ def test_connection_bad_reinit(self):
                                    cx.executemany, "insert into t values(?)",
                                    ((v,) for v in range(3)))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON SQLITE_DBCONFIG constants not implemented
+    def test_connection_config(self):
+        op = sqlite.SQLITE_DBCONFIG_ENABLE_FKEY
+        with memory_database() as cx:
+            with self.assertRaisesRegex(ValueError, "unknown"):
+                cx.getconfig(-1)
+
+            # Toggle and verify.
+            old = cx.getconfig(op)
+            new = not old
+            cx.setconfig(op, new)
+            self.assertEqual(cx.getconfig(op), new)
+
+            cx.setconfig(op)  # defaults to True
+            self.assertTrue(cx.getconfig(op))
+
+            # Check that foreign key support was actually enabled.
+            with cx:
+                cx.executescript("""
+                    create table t(t integer primary key);
+                    create table u(u, foreign key(u) references t(t));
+                """)
+            with self.assertRaisesRegex(sqlite.IntegrityError, "constraint"):
+                cx.execute("insert into u values(0)")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON deprecation warning not emitted for positional args
+    def test_connect_positional_arguments(self):
+        regex = (
+            r"Passing more than 1 positional argument to sqlite3.connect\(\)"
+            " is deprecated. Parameters 'timeout', 'detect_types', "
+            "'isolation_level', 'check_same_thread', 'factory', "
+            "'cached_statements' and 'uri' will become keyword-only "
+            "parameters in Python 3.15."
+        )
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            cx = sqlite.connect(":memory:", 1.0)
+            cx.close()
+        self.assertEqual(cm.filename, __file__)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON ResourceWarning not emitted
+    def test_connection_resource_warning(self):
+        with self.assertWarns(ResourceWarning):
+            cx = sqlite.connect(":memory:")
+            del cx
+            gc_collect()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON Connection signature inspection not working
+    def test_connection_signature(self):
+        from inspect import signature
+        sig = signature(self.cx)
+        self.assertEqual(str(sig), "(sql, /)")
+
 
 class UninitialisedConnectionTests(unittest.TestCase):
     def setUp(self):
@@ -613,7 +609,6 @@ def test_serialize_deserialize(self):
             with cx:
                 cx.execute("create table t(t)")
             data = cx.serialize()
-            self.assertEqual(len(data), 8192)
 
             # Remove test table, verify that it was removed.
             with cx:
@@ -651,6 +646,14 @@ def test_deserialize_corrupt_database(self):
 class OpenTests(unittest.TestCase):
     _sql = "create table test(id integer)"
 
+    def test_open_with_bytes_path(self):
+        path = os.fsencode(TESTFN)
+        self.addCleanup(unlink, path)
+        self.assertFalse(os.path.exists(path))
+        with contextlib.closing(sqlite.connect(path)) as cx:
+            self.assertTrue(os.path.exists(path))
+            cx.execute(self._sql)
+
     def test_open_with_path_like_object(self):
         """ Checks that we can successfully connect to a database using an object that
             is PathLike, i.e. has __fspath__(). """
@@ -661,15 +664,21 @@ def test_open_with_path_like_object(self):
             self.assertTrue(os.path.exists(path))
             cx.execute(self._sql)
 
+    def get_undecodable_path(self):
+        path = TESTFN_UNDECODABLE
+        if not path:
+            self.skipTest("only works if there are undecodable paths")
+        try:
+            open(path, 'wb').close()
+        except OSError:
+            self.skipTest(f"can't create file with undecodable path {path!r}")
+        unlink(path)
+        return path
+
     @unittest.skipIf(sys.platform == "win32", "skipped on Windows")
-    @unittest.skipIf(sys.platform == "darwin", "skipped on macOS")
-    # TODO: RUSTPYTHON
-    # @unittest.skipIf(is_emscripten or is_wasi, "not supported on Emscripten/WASI")
-    @unittest.skipUnless(TESTFN_UNDECODABLE, "only works if there are undecodable paths")
     def test_open_with_undecodable_path(self):
-        path = TESTFN_UNDECODABLE
+        path = self.get_undecodable_path()
         self.addCleanup(unlink, path)
-        self.assertFalse(os.path.exists(path))
         with contextlib.closing(sqlite.connect(path)) as cx:
             self.assertTrue(os.path.exists(path))
             cx.execute(self._sql)
@@ -709,21 +718,15 @@ def test_open_uri_readonly(self):
                 cx.execute(self._sql)
 
     @unittest.skipIf(sys.platform == "win32", "skipped on Windows")
-    @unittest.skipIf(sys.platform == "darwin", "skipped on macOS")
-    # TODO: RUSTPYTHON
-    # @unittest.skipIf(is_emscripten or is_wasi, "not supported on Emscripten/WASI")
-    @unittest.skipUnless(TESTFN_UNDECODABLE, "only works if there are undecodable paths")
     def test_open_undecodable_uri(self):
-        path = TESTFN_UNDECODABLE
+        path = self.get_undecodable_path()
         self.addCleanup(unlink, path)
         uri = "file:" + urllib.parse.quote(path)
-        self.assertFalse(os.path.exists(path))
         with contextlib.closing(sqlite.connect(uri, uri=True)) as cx:
             self.assertTrue(os.path.exists(path))
             cx.execute(self._sql)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_factory_database_arg(self):
         def factory(database, *args, **kwargs):
             nonlocal database_arg
@@ -872,6 +875,34 @@ def __getitem__(slf, x):
         with self.assertRaises(ZeroDivisionError):
             self.cu.execute("select name from test where name=?", L())
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON mixed named and positional parameters not validated
+    def test_execute_named_param_and_sequence(self):
+        dataset = (
+            ("select :a", (1,)),
+            ("select :a, ?, ?", (1, 2, 3)),
+            ("select ?, :b, ?", (1, 2, 3)),
+            ("select ?, ?, :c", (1, 2, 3)),
+            ("select :a, :b, ?", (1, 2, 3)),
+        )
+        msg = "Binding.*is a named parameter"
+        for query, params in dataset:
+            with self.subTest(query=query, params=params):
+                with self.assertRaisesRegex(sqlite.ProgrammingError, msg) as cm:
+                    self.cu.execute(query, params)
+
+    def test_execute_indexed_nameless_params(self):
+        # See gh-117995: "'?1' is considered a named placeholder"
+        for query, params, expected in (
+            ("select ?1, ?2", (1, 2), (1, 2)),
+            ("select ?2, ?1", (1, 2), (2, 1)),
+        ):
+            with self.subTest(query=query, params=params):
+                with warnings.catch_warnings():
+                    warnings.simplefilter("error", DeprecationWarning)
+                    cu = self.cu.execute(query, params)
+                    actual, = cu.fetchall()
+                    self.assertEqual(actual, expected)
+
     def test_execute_too_many_params(self):
         category = sqlite.SQLITE_LIMIT_VARIABLE_NUMBER
         msg = "too many SQL variables"
@@ -1047,7 +1078,7 @@ def test_array_size(self):
         # now set to 2
         self.cu.arraysize = 2
 
-        # now make the query return 3 rows
+        # now make the query return 2 rows from a table of 3 rows
         self.cu.execute("delete from test")
         self.cu.execute("insert into test(name) values ('A')")
         self.cu.execute("insert into test(name) values ('B')")
@@ -1057,13 +1088,53 @@ def test_array_size(self):
 
         self.assertEqual(len(res), 2)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON arraysize validation not implemented
+    def test_invalid_array_size(self):
+        UINT32_MAX = (1 << 32) - 1
+        setter = functools.partial(setattr, self.cu, 'arraysize')
+
+        self.assertRaises(TypeError, setter, 1.0)
+        self.assertRaises(ValueError, setter, -3)
+        self.assertRaises(OverflowError, setter, UINT32_MAX + 1)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON fetchmany behavior with exhausted cursor differs
     def test_fetchmany(self):
+        # no active SQL statement
+        res = self.cu.fetchmany()
+        self.assertEqual(res, [])
+        res = self.cu.fetchmany(1000)
+        self.assertEqual(res, [])
+
+        # test default parameter
+        self.cu.execute("select name from test")
+        res = self.cu.fetchmany()
+        self.assertEqual(len(res), 1)
+
+        # test when the number of requested rows exceeds the actual count
         self.cu.execute("select name from test")
         res = self.cu.fetchmany(100)
         self.assertEqual(len(res), 1)
         res = self.cu.fetchmany(100)
         self.assertEqual(res, [])
 
+        # test when size = 0
+        self.cu.execute("select name from test")
+        res = self.cu.fetchmany(0)
+        self.assertEqual(res, [])
+        res = self.cu.fetchmany(100)
+        self.assertEqual(len(res), 1)
+        res = self.cu.fetchmany(100)
+        self.assertEqual(res, [])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON fetchmany size validation not implemented
+    def test_invalid_fetchmany(self):
+        UINT32_MAX = (1 << 32) - 1
+        fetchmany = self.cu.fetchmany
+
+        self.assertRaises(TypeError, fetchmany, 1.0)
+        self.assertRaises(ValueError, fetchmany, -3)
+        self.assertRaises(OverflowError, fetchmany, UINT32_MAX + 1)
+
     def test_fetchmany_kw_arg(self):
         """Checks if fetchmany works with keyword arguments"""
         self.cu.execute("select name from test")
@@ -1183,12 +1254,9 @@ def test_blob_seek_and_tell(self):
         self.blob.seek(-10, SEEK_END)
         self.assertEqual(self.blob.tell(), 40)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_seek_error(self):
         msg_oor = "offset out of blob range"
         msg_orig = "'origin' should be os.SEEK_SET, os.SEEK_CUR, or os.SEEK_END"
-        msg_of = "seek offset results in overflow"
 
         dataset = (
             (ValueError, msg_oor, lambda: self.blob.seek(1000)),
@@ -1200,12 +1268,15 @@ def test_blob_seek_error(self):
             with self.subTest(exc=exc, msg=msg, fn=fn):
                 self.assertRaisesRegex(exc, msg, fn)
 
+    def test_blob_seek_overflow_error(self):
         # Force overflow errors
+        msg_of = "seek offset results in overflow"
+        _testcapi = import_helper.import_module("_testcapi")
         self.blob.seek(1, SEEK_SET)
         with self.assertRaisesRegex(OverflowError, msg_of):
-            self.blob.seek(INT_MAX, SEEK_CUR)
+            self.blob.seek(_testcapi.INT_MAX, SEEK_CUR)
         with self.assertRaisesRegex(OverflowError, msg_of):
-            self.blob.seek(INT_MAX, SEEK_END)
+            self.blob.seek(_testcapi.INT_MAX, SEEK_END)
 
     def test_blob_read(self):
         buf = self.blob.read()
@@ -1359,24 +1430,24 @@ def test_blob_mapping_invalid_index_type(self):
         with self.assertRaisesRegex(TypeError, msg):
             self.blob["a"] = b"b"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_get_item_error(self):
         dataset = [len(self.blob), 105, -105]
         for idx in dataset:
             with self.subTest(idx=idx):
                 with self.assertRaisesRegex(IndexError, "index out of range"):
                     self.blob[idx]
-        with self.assertRaisesRegex(IndexError, "cannot fit 'int'"):
-            self.blob[ULLONG_MAX]
 
         # Provoke read error
         self.cx.execute("update test set b='aaaa' where rowid=1")
         with self.assertRaises(sqlite.OperationalError):
             self.blob[0]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_blob_get_item_error_bigint(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        with self.assertRaisesRegex(IndexError, "cannot fit 'int'"):
+            self.blob[_testcapi.ULLONG_MAX]
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_blob_set_item_error(self):
         with self.assertRaisesRegex(TypeError, "cannot be interpreted"):
             self.blob[0] = b"multiple"
@@ -1413,7 +1484,7 @@ def test_blob_sequence_not_supported(self):
             self.blob + self.blob
         with self.assertRaisesRegex(TypeError, "unsupported operand"):
             self.blob * 5
-        with self.assertRaisesRegex(TypeError, "is not iterable"):
+        with self.assertRaisesRegex(TypeError, "is not.+iterable"):
             b"a" in self.blob
 
     def test_blob_context_manager(self):
@@ -1474,9 +1545,16 @@ def test_blob_closed_db_read(self):
                                    "Cannot operate on a closed database",
                                    blob.read)
 
+    def test_blob_32bit_rowid(self):
+        # gh-100370: we should not get an OverflowError for 32-bit rowids
+        with memory_database() as cx:
+            rowid = 2**32
+            cx.execute("create table t(t blob)")
+            cx.execute("insert into t(rowid, t) values (?, zeroblob(1))", (rowid,))
+            cx.blobopen('t', 't', rowid)
 
-# TODO: RUSTPYTHON
-# @threading_helper.requires_working_threading()
+
+@threading_helper.requires_working_threading()
 class ThreadTests(unittest.TestCase):
     def setUp(self):
         self.con = sqlite.connect(":memory:")
@@ -1529,8 +1607,7 @@ def test_check_connection_thread(self):
             with self.subTest(fn=fn):
                 self._run_test(fn)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_check_cursor_thread(self):
         fns = [
             lambda: self.cur.execute("insert into test(name) values('a')"),
@@ -1551,12 +1628,12 @@ def run(con, err):
             except sqlite.Error:
                 err.append("multi-threading not allowed")
 
-        con = sqlite.connect(":memory:", check_same_thread=False)
-        err = []
-        t = threading.Thread(target=run, kwargs={"con": con, "err": err})
-        t.start()
-        t.join()
-        self.assertEqual(len(err), 0, "\n".join(err))
+        with memory_database(check_same_thread=False) as con:
+            err = []
+            t = threading.Thread(target=run, kwargs={"con": con, "err": err})
+            t.start()
+            t.join()
+            self.assertEqual(len(err), 0, "\n".join(err))
 
 
 class ConstructorTests(unittest.TestCase):
@@ -1582,9 +1659,16 @@ def test_binary(self):
         b = sqlite.Binary(b"\0'")
 
 class ExtensionTests(unittest.TestCase):
+    def setUp(self):
+        self.con = sqlite.connect(":memory:")
+        self.cur = self.con.cursor()
+
+    def tearDown(self):
+        self.cur.close()
+        self.con.close()
+
     def test_script_string_sql(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
+        cur = self.cur
         cur.executescript("""
             -- bla bla
             /* a stupid comment */
@@ -1596,40 +1680,40 @@ def test_script_string_sql(self):
         self.assertEqual(res, 5)
 
     def test_script_syntax_error(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
         with self.assertRaises(sqlite.OperationalError):
-            cur.executescript("create table test(x); asdf; create table test2(x)")
+            self.cur.executescript("""
+                CREATE TABLE test(x);
+                asdf;
+                CREATE TABLE test2(x)
+            """)
 
     def test_script_error_normal(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
         with self.assertRaises(sqlite.OperationalError):
-            cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
+            self.cur.executescript("""
+                CREATE TABLE test(sadfsadfdsa);
+                SELECT foo FROM hurz;
+            """)
 
     def test_cursor_executescript_as_bytes(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
         with self.assertRaises(TypeError):
-            cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
+            self.cur.executescript(b"""
+                CREATE TABLE test(foo);
+                INSERT INTO test(foo) VALUES (5);
+            """)
 
     def test_cursor_executescript_with_null_characters(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
         with self.assertRaises(ValueError):
-            cur.executescript("""
-                create table a(i);\0
-                insert into a(i) values (5);
-                """)
+            self.cur.executescript("""
+                CREATE TABLE a(i);\0
+                INSERT INTO a(i) VALUES (5);
+            """)
 
     def test_cursor_executescript_with_surrogates(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
         with self.assertRaises(UnicodeEncodeError):
-            cur.executescript("""
-                create table a(s);
-                insert into a(s) values ('\ud8ff');
-                """)
+            self.cur.executescript("""
+                CREATE TABLE a(s);
+                INSERT INTO a(s) VALUES ('\ud8ff');
+            """)
 
     def test_cursor_executescript_too_large_script(self):
         msg = "query string is too large"
@@ -1639,19 +1723,18 @@ def test_cursor_executescript_too_large_script(self):
                 cx.executescript("select 'too large'".ljust(lim+1))
 
     def test_cursor_executescript_tx_control(self):
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.execute("begin")
         self.assertTrue(con.in_transaction)
         con.executescript("select 1")
         self.assertFalse(con.in_transaction)
 
     def test_connection_execute(self):
-        con = sqlite.connect(":memory:")
-        result = con.execute("select 5").fetchone()[0]
+        result = self.con.execute("select 5").fetchone()[0]
         self.assertEqual(result, 5, "Basic test of Connection.execute")
 
     def test_connection_executemany(self):
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.execute("create table test(foo)")
         con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
         result = con.execute("select foo from test order by foo").fetchall()
@@ -1659,47 +1742,50 @@ def test_connection_executemany(self):
         self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
 
     def test_connection_executescript(self):
-        con = sqlite.connect(":memory:")
-        con.executescript("create table test(foo); insert into test(foo) values (5);")
+        con = self.con
+        con.executescript("""
+            CREATE TABLE test(foo);
+            INSERT INTO test(foo) VALUES (5);
+        """)
         result = con.execute("select foo from test").fetchone()[0]
         self.assertEqual(result, 5, "Basic test of Connection.executescript")
 
+
 class ClosedConTests(unittest.TestCase):
+    def check(self, fn, *args, **kwds):
+        regex = "Cannot operate on a closed database."
+        with self.assertRaisesRegex(sqlite.ProgrammingError, regex):
+            fn(*args, **kwds)
+
+    def setUp(self):
+        self.con = sqlite.connect(":memory:")
+        self.cur = self.con.cursor()
+        self.con.close()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_con_cursor(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            cur = con.cursor()
+        self.check(self.con.cursor)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_con_commit(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.commit()
+        self.check(self.con.commit)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_con_rollback(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.rollback()
+        self.check(self.con.rollback)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_cur_execute(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
-        con.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            cur.execute("select 4")
+        self.check(self.cur.execute, "select 4")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_create_function(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        def f(x): return 17
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.create_function("foo", 1, f)
+        def f(x):
+            return 17
+        self.check(self.con.create_function, "foo", 1, f)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_create_aggregate(self):
-        con = sqlite.connect(":memory:")
-        con.close()
         class Agg:
             def __init__(self):
                 pass
@@ -1707,34 +1793,28 @@ def step(self, x):
                 pass
             def finalize(self):
                 return 17
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.create_aggregate("foo", 1, Agg)
+        self.check(self.con.create_aggregate, "foo", 1, Agg)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_set_authorizer(self):
-        con = sqlite.connect(":memory:")
-        con.close()
         def authorizer(*args):
             return sqlite.DENY
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.set_authorizer(authorizer)
+        self.check(self.con.set_authorizer, authorizer)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_set_progress_callback(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        def progress(): pass
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.set_progress_handler(progress, 100)
+        def progress():
+            pass
+        self.check(self.con.set_progress_handler, progress, 100)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for closed connection
     def test_closed_call(self):
-        con = sqlite.connect(":memory:")
-        con.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            con()
+        self.check(self.con)
+
 
-class ClosedCurTests(unittest.TestCase):
+class ClosedCurTests(MemoryDatabaseMixin, unittest.TestCase):
     def test_closed(self):
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
+        cur = self.cx.cursor()
         cur.close()
 
         for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"):
@@ -1843,14 +1923,14 @@ def test_on_conflict_replace(self):
         self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
 
 
-# TODO: RUSTPYTHON
-# @requires_subprocess()
+@requires_subprocess()
 class MultiprocessTests(unittest.TestCase):
-    CONNECTION_TIMEOUT = SHORT_TIMEOUT / 1000.  # Defaults to 30 ms
+    CONNECTION_TIMEOUT = 0  # Disable the busy timeout.
 
     def tearDown(self):
         unlink(TESTFN)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON multiprocess test fails
     def test_ctx_mgr_rollback_if_commit_failed(self):
         # bpo-27334: ctx manager does not rollback if commit fails
         SCRIPT = f"""if 1:
@@ -1916,5 +1996,71 @@ def wait():
         self.assertEqual(proc.returncode, 0)
 
 
+class RowTests(unittest.TestCase):
+
+    def setUp(self):
+        self.cx = sqlite.connect(":memory:")
+        self.cx.row_factory = sqlite.Row
+
+    def tearDown(self):
+        self.cx.close()
+
+    def test_row_keys(self):
+        cu = self.cx.execute("SELECT 1 as first, 2 as second")
+        row = cu.fetchone()
+        self.assertEqual(row.keys(), ["first", "second"])
+
+    def test_row_length(self):
+        cu = self.cx.execute("SELECT 1, 2, 3")
+        row = cu.fetchone()
+        self.assertEqual(len(row), 3)
+
+    def test_row_getitem(self):
+        cu = self.cx.execute("SELECT 1 as a, 2 as b")
+        row = cu.fetchone()
+        self.assertEqual(row[0], 1)
+        self.assertEqual(row[1], 2)
+        self.assertEqual(row["a"], 1)
+        self.assertEqual(row["b"], 2)
+        for key in "nokey", 4, 1.2:
+            with self.subTest(key=key):
+                with self.assertRaises(IndexError):
+                    row[key]
+
+    def test_row_equality(self):
+        c1 = self.cx.execute("SELECT 1 as a")
+        r1 = c1.fetchone()
+
+        c2 = self.cx.execute("SELECT 1 as a")
+        r2 = c2.fetchone()
+
+        self.assertIsNot(r1, r2)
+        self.assertEqual(r1, r2)
+
+        c3 = self.cx.execute("SELECT 1 as b")
+        r3 = c3.fetchone()
+
+        self.assertNotEqual(r1, r3)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON Row with no description fails
+    def test_row_no_description(self):
+        cu = self.cx.cursor()
+        self.assertIsNone(cu.description)
+
+        row = sqlite.Row(cu, ())
+        self.assertEqual(row.keys(), [])
+        with self.assertRaisesRegex(IndexError, "nokey"):
+            row["nokey"]
+
+    def test_row_is_a_sequence(self):
+        from collections.abc import Sequence
+
+        cu = self.cx.execute("SELECT 1")
+        row = cu.fetchone()
+
+        self.assertIsSubclass(sqlite.Row, Sequence)
+        self.assertIsInstance(row, Sequence)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_sqlite3/test_dump.py b/Lib/test/test_sqlite3/test_dump.py
index ec4a11da8b0..74aacc05c2b 100644
--- a/Lib/test/test_sqlite3/test_dump.py
+++ b/Lib/test/test_sqlite3/test_dump.py
@@ -1,22 +1,18 @@
 # Author: Paul Kippes <kippesp@gmail.com>
 
 import unittest
-import sqlite3 as sqlite
-from .test_dbapi import memory_database
 
+from .util import memory_database
+from .util import MemoryDatabaseMixin
+from .util import requires_virtual_table
 
-# TODO: RUSTPYTHON
-@unittest.expectedFailure
-class DumpTests(unittest.TestCase):
-    def setUp(self):
-        self.cx = sqlite.connect(":memory:")
-        self.cu = self.cx.cursor()
 
-    def tearDown(self):
-        self.cx.close()
+class DumpTests(MemoryDatabaseMixin, unittest.TestCase):
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_table_dump(self):
         expected_sqls = [
+                "PRAGMA foreign_keys=OFF;",
                 """CREATE TABLE "index"("index" blob);"""
                 ,
                 """INSERT INTO "index" VALUES(X'01');"""
@@ -27,7 +23,8 @@ def test_table_dump(self):
                 ,
                 "CREATE TABLE t1(id integer primary key, s1 text, " \
                 "t1_i1 integer not null, i2 integer, unique (s1), " \
-                "constraint t1_idx1 unique (i2));"
+                "constraint t1_idx1 unique (i2), " \
+                "constraint t1_i1_idx1 unique (t1_i1));"
                 ,
                 "INSERT INTO \"t1\" VALUES(1,'foo',10,20);"
                 ,
@@ -37,6 +34,9 @@ def test_table_dump(self):
                 "t2_i2 integer, primary key (id)," \
                 "foreign key(t2_i1) references t1(t1_i1));"
                 ,
+                # Foreign key violation.
+                "INSERT INTO \"t2\" VALUES(1,2,3);"
+                ,
                 "CREATE TRIGGER trigger_1 update of t1_i1 on t1 " \
                 "begin " \
                 "update t2 set t2_i1 = new.t1_i1 where t2_i1 = old.t1_i1; " \
@@ -48,11 +48,87 @@ def test_table_dump(self):
         [self.cu.execute(s) for s in expected_sqls]
         i = self.cx.iterdump()
         actual_sqls = [s for s in i]
-        expected_sqls = ['BEGIN TRANSACTION;'] + expected_sqls + \
-            ['COMMIT;']
+        expected_sqls = [
+            "PRAGMA foreign_keys=OFF;",
+            "BEGIN TRANSACTION;",
+            *expected_sqls[1:],
+            "COMMIT;",
+        ]
         [self.assertEqual(expected_sqls[i], actual_sqls[i])
             for i in range(len(expected_sqls))]
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON iterdump filter parameter not implemented
+    def test_table_dump_filter(self):
+        all_table_sqls = [
+            """CREATE TABLE "some_table_2" ("id_1" INTEGER);""",
+            """INSERT INTO "some_table_2" VALUES(3);""",
+            """INSERT INTO "some_table_2" VALUES(4);""",
+            """CREATE TABLE "test_table_1" ("id_2" INTEGER);""",
+            """INSERT INTO "test_table_1" VALUES(1);""",
+            """INSERT INTO "test_table_1" VALUES(2);""",
+        ]
+        all_views_sqls = [
+            """CREATE VIEW "view_1" AS SELECT * FROM "some_table_2";""",
+            """CREATE VIEW "view_2" AS SELECT * FROM "test_table_1";""",
+        ]
+        # Create database structure.
+        for sql in [*all_table_sqls, *all_views_sqls]:
+            self.cu.execute(sql)
+        # %_table_% matches all tables.
+        dump_sqls = list(self.cx.iterdump(filter="%_table_%"))
+        self.assertEqual(
+            dump_sqls,
+            ["BEGIN TRANSACTION;", *all_table_sqls, "COMMIT;"],
+        )
+        # view_% matches all views.
+        dump_sqls = list(self.cx.iterdump(filter="view_%"))
+        self.assertEqual(
+            dump_sqls,
+            ["BEGIN TRANSACTION;", *all_views_sqls, "COMMIT;"],
+        )
+        # %_1 matches tables and views with the _1 suffix.
+        dump_sqls = list(self.cx.iterdump(filter="%_1"))
+        self.assertEqual(
+            dump_sqls,
+            [
+                "BEGIN TRANSACTION;",
+                """CREATE TABLE "test_table_1" ("id_2" INTEGER);""",
+                """INSERT INTO "test_table_1" VALUES(1);""",
+                """INSERT INTO "test_table_1" VALUES(2);""",
+                """CREATE VIEW "view_1" AS SELECT * FROM "some_table_2";""",
+                "COMMIT;"
+            ],
+        )
+        # some_% matches some_table_2.
+        dump_sqls = list(self.cx.iterdump(filter="some_%"))
+        self.assertEqual(
+            dump_sqls,
+            [
+                "BEGIN TRANSACTION;",
+                """CREATE TABLE "some_table_2" ("id_1" INTEGER);""",
+                """INSERT INTO "some_table_2" VALUES(3);""",
+                """INSERT INTO "some_table_2" VALUES(4);""",
+                "COMMIT;"
+            ],
+        )
+        # Only single object.
+        dump_sqls = list(self.cx.iterdump(filter="view_2"))
+        self.assertEqual(
+            dump_sqls,
+            [
+                "BEGIN TRANSACTION;",
+                """CREATE VIEW "view_2" AS SELECT * FROM "test_table_1";""",
+                "COMMIT;"
+            ],
+        )
+        # % matches all objects.
+        dump_sqls = list(self.cx.iterdump(filter="%"))
+        self.assertEqual(
+            dump_sqls,
+            ["BEGIN TRANSACTION;", *all_table_sqls, *all_views_sqls, "COMMIT;"],
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON _iterdump not implemented
     def test_dump_autoincrement(self):
         expected = [
             'CREATE TABLE "t1" (id integer primary key autoincrement);',
@@ -73,6 +149,7 @@ def test_dump_autoincrement(self):
         actual = [stmt for stmt in self.cx.iterdump()]
         self.assertEqual(expected, actual)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON _iterdump not implemented
     def test_dump_autoincrement_create_new_db(self):
         self.cu.execute("BEGIN TRANSACTION")
         self.cu.execute("CREATE TABLE t1 (id integer primary key autoincrement)")
@@ -98,6 +175,7 @@ def test_dump_autoincrement_create_new_db(self):
                     rows = res.fetchall()
                     self.assertEqual(rows[0][0], seq)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON _iterdump not implemented
     def test_unorderable_row(self):
         # iterdump() should be able to cope with unorderable row types (issue #15545)
         class UnorderableRow:
@@ -119,6 +197,44 @@ def __getitem__(self, index):
         got = list(self.cx.iterdump())
         self.assertEqual(expected, got)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON _iterdump not implemented
+    def test_dump_custom_row_factory(self):
+        # gh-118221: iterdump should be able to cope with custom row factories.
+        def dict_factory(cu, row):
+            fields = [col[0] for col in cu.description]
+            return dict(zip(fields, row))
+
+        self.cx.row_factory = dict_factory
+        CREATE_TABLE = "CREATE TABLE test(t);"
+        expected = ["BEGIN TRANSACTION;", CREATE_TABLE, "COMMIT;"]
+
+        self.cu.execute(CREATE_TABLE)
+        actual = list(self.cx.iterdump())
+        self.assertEqual(expected, actual)
+        self.assertEqual(self.cx.row_factory, dict_factory)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON _iterdump not implemented
+    @requires_virtual_table("fts4")
+    def test_dump_virtual_tables(self):
+        # gh-64662
+        expected = [
+            "BEGIN TRANSACTION;",
+            "PRAGMA writable_schema=ON;",
+            ("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
+             "VALUES('table','test','test',0,'CREATE VIRTUAL TABLE test USING fts4(example)');"),
+            "CREATE TABLE 'test_content'(docid INTEGER PRIMARY KEY, 'c0example');",
+            "CREATE TABLE 'test_docsize'(docid INTEGER PRIMARY KEY, size BLOB);",
+            ("CREATE TABLE 'test_segdir'(level INTEGER,idx INTEGER,start_block INTEGER,"
+             "leaves_end_block INTEGER,end_block INTEGER,root BLOB,PRIMARY KEY(level, idx));"),
+            "CREATE TABLE 'test_segments'(blockid INTEGER PRIMARY KEY, block BLOB);",
+            "CREATE TABLE 'test_stat'(id INTEGER PRIMARY KEY, value BLOB);",
+            "PRAGMA writable_schema=OFF;",
+            "COMMIT;"
+        ]
+        self.cu.execute("CREATE VIRTUAL TABLE test USING fts4(example)")
+        actual = list(self.cx.iterdump())
+        self.assertEqual(expected, actual)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_sqlite3/test_factory.py b/Lib/test/test_sqlite3/test_factory.py
index 20cff8b585f..d19b98b2056 100644
--- a/Lib/test/test_sqlite3/test_factory.py
+++ b/Lib/test/test_sqlite3/test_factory.py
@@ -24,6 +24,9 @@
 import sqlite3 as sqlite
 from collections.abc import Sequence
 
+from .util import memory_database
+from .util import MemoryDatabaseMixin
+
 
 def dict_factory(cursor, row):
     d = {}
@@ -37,6 +40,7 @@ def __init__(self, *args, **kwargs):
         self.row_factory = dict_factory
 
 class ConnectionFactoryTests(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_connection_factories(self):
         class DefectFactory(sqlite.Connection):
             def __init__(self, *args, **kwargs):
@@ -45,13 +49,14 @@ class OkFactory(sqlite.Connection):
             def __init__(self, *args, **kwargs):
                 sqlite.Connection.__init__(self, *args, **kwargs)
 
-        for factory in DefectFactory, OkFactory:
-            with self.subTest(factory=factory):
-                con = sqlite.connect(":memory:", factory=factory)
-                self.assertIsInstance(con, factory)
+        with memory_database(factory=OkFactory) as con:
+            self.assertIsInstance(con, OkFactory)
+        regex = "Base Connection.__init__ not called."
+        with self.assertRaisesRegex(sqlite.ProgrammingError, regex):
+            with memory_database(factory=DefectFactory) as con:
+                self.assertIsInstance(con, DefectFactory)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_connection_factory_relayed_call(self):
         # gh-95132: keyword args must not be passed as positional args
         class Factory(sqlite.Connection):
@@ -59,23 +64,31 @@ def __init__(self, *args, **kwargs):
                 kwargs["isolation_level"] = None
                 super(Factory, self).__init__(*args, **kwargs)
 
-        con = sqlite.connect(":memory:", factory=Factory)
-        self.assertIsNone(con.isolation_level)
-        self.assertIsInstance(con, Factory)
+        with memory_database(factory=Factory) as con:
+            self.assertIsNone(con.isolation_level)
+            self.assertIsInstance(con, Factory)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_connection_factory_as_positional_arg(self):
         class Factory(sqlite.Connection):
             def __init__(self, *args, **kwargs):
                 super(Factory, self).__init__(*args, **kwargs)
 
-        con = sqlite.connect(":memory:", 5.0, 0, None, True, Factory)
-        self.assertIsNone(con.isolation_level)
-        self.assertIsInstance(con, Factory)
+        regex = (
+            r"Passing more than 1 positional argument to _sqlite3.Connection\(\) "
+            r"is deprecated. Parameters 'timeout', 'detect_types', "
+            r"'isolation_level', 'check_same_thread', 'factory', "
+            r"'cached_statements' and 'uri' will become keyword-only "
+            r"parameters in Python 3.15."
+        )
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            with memory_database(5.0, 0, None, True, Factory) as con:
+                self.assertIsNone(con.isolation_level)
+                self.assertIsInstance(con, Factory)
+        self.assertEqual(cm.filename, __file__)
 
 
-class CursorFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
+class CursorFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
 
     def tearDown(self):
         self.con.close()
@@ -96,12 +109,10 @@ def test_invalid_factory(self):
         # invalid callable returning non-cursor
         self.assertRaises(TypeError, self.con.cursor, lambda con: None)
 
-class RowFactoryTestsBackwardsCompat(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+class RowFactoryTestsBackwardsCompat(MemoryDatabaseMixin, unittest.TestCase):
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_is_produced_by_factory(self):
         cur = self.con.cursor(factory=MyCursor)
         cur.execute("select 4+5 as foo")
@@ -109,22 +120,20 @@ def test_is_produced_by_factory(self):
         self.assertIsInstance(row, dict)
         cur.close()
 
-    def tearDown(self):
-        self.con.close()
 
-class RowFactoryTests(unittest.TestCase):
+class RowFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
+
     def setUp(self):
-        self.con = sqlite.connect(":memory:")
+        super().setUp()
+        self.con.row_factory = sqlite.Row
 
     def test_custom_factory(self):
         self.con.row_factory = lambda cur, row: list(row)
         row = self.con.execute("select 1, 2").fetchone()
         self.assertIsInstance(row, list)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sqlite_row_index(self):
-        self.con.row_factory = sqlite.Row
         row = self.con.execute("select 1 as a_1, 2 as b").fetchone()
         self.assertIsInstance(row, sqlite.Row)
 
@@ -154,10 +163,8 @@ def test_sqlite_row_index(self):
         with self.assertRaises(IndexError):
             row[complex()]  # index must be int or string
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sqlite_row_index_unicode(self):
-        self.con.row_factory = sqlite.Row
         row = self.con.execute("select 1 as \xff").fetchone()
         self.assertEqual(row["\xff"], 1)
         with self.assertRaises(IndexError):
@@ -167,7 +174,6 @@ def test_sqlite_row_index_unicode(self):
 
     def test_sqlite_row_slice(self):
         # A sqlite.Row can be sliced like a list.
-        self.con.row_factory = sqlite.Row
         row = self.con.execute("select 1, 2, 3, 4").fetchone()
         self.assertEqual(row[0:0], ())
         self.assertEqual(row[0:1], (1,))
@@ -184,30 +190,32 @@ def test_sqlite_row_slice(self):
         self.assertEqual(row[3:0:-2], (4, 2))
 
     def test_sqlite_row_iter(self):
-        """Checks if the row object is iterable"""
-        self.con.row_factory = sqlite.Row
+        # Checks if the row object is iterable.
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
-        for col in row:
-            pass
+
+        # Is iterable in correct order and produces valid results:
+        items = [col for col in row]
+        self.assertEqual(items, [1, 2])
+
+        # Is iterable the second time:
+        items = [col for col in row]
+        self.assertEqual(items, [1, 2])
 
     def test_sqlite_row_as_tuple(self):
-        """Checks if the row object can be converted to a tuple"""
-        self.con.row_factory = sqlite.Row
+        # Checks if the row object can be converted to a tuple.
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
         t = tuple(row)
         self.assertEqual(t, (row['a'], row['b']))
 
     def test_sqlite_row_as_dict(self):
-        """Checks if the row object can be correctly converted to a dictionary"""
-        self.con.row_factory = sqlite.Row
+        # Checks if the row object can be correctly converted to a dictionary.
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
         d = dict(row)
         self.assertEqual(d["a"], row["a"])
         self.assertEqual(d["b"], row["b"])
 
     def test_sqlite_row_hash_cmp(self):
-        """Checks if the row object compares and hashes correctly"""
-        self.con.row_factory = sqlite.Row
+        # Checks if the row object compares and hashes correctly.
         row_1 = self.con.execute("select 1 as a, 2 as b").fetchone()
         row_2 = self.con.execute("select 1 as a, 2 as b").fetchone()
         row_3 = self.con.execute("select 1 as a, 3 as b").fetchone()
@@ -240,30 +248,29 @@ def test_sqlite_row_hash_cmp(self):
         self.assertEqual(hash(row_1), hash(row_2))
 
     def test_sqlite_row_as_sequence(self):
-        """ Checks if the row object can act like a sequence """
-        self.con.row_factory = sqlite.Row
+        # Checks if the row object can act like a sequence.
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
 
         as_tuple = tuple(row)
         self.assertEqual(list(reversed(row)), list(reversed(as_tuple)))
         self.assertIsInstance(row, Sequence)
 
+    def test_sqlite_row_keys(self):
+        # Checks if the row object can return a list of columns as strings.
+        row = self.con.execute("select 1 as a, 2 as b").fetchone()
+        self.assertEqual(row.keys(), ['a', 'b'])
+
     def test_fake_cursor_class(self):
         # Issue #24257: Incorrect use of PyObject_IsInstance() caused
         # segmentation fault.
         # Issue #27861: Also applies for cursor factory.
         class FakeCursor(str):
             __class__ = sqlite.Cursor
-        self.con.row_factory = sqlite.Row
         self.assertRaises(TypeError, self.con.cursor, FakeCursor)
         self.assertRaises(TypeError, sqlite.Row, FakeCursor(), ())
 
-    def tearDown(self):
-        self.con.close()
 
-class TextFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
+class TextFactoryTests(MemoryDatabaseMixin, unittest.TestCase):
 
     def test_unicode(self):
         austria = "Österreich"
@@ -282,17 +289,19 @@ def test_custom(self):
         austria = "Österreich"
         row = self.con.execute("select ?", (austria,)).fetchone()
         self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
-        self.assertTrue(row[0].endswith("reich"), "column must contain original data")
+        self.assertEndsWith(row[0], "reich", "column must contain original data")
 
-    def tearDown(self):
-        self.con.close()
 
 class TextFactoryTestsWithEmbeddedZeroBytes(unittest.TestCase):
+
     def setUp(self):
         self.con = sqlite.connect(":memory:")
         self.con.execute("create table test (value text)")
         self.con.execute("insert into test (value) values (?)", ("a\x00b",))
 
+    def tearDown(self):
+        self.con.close()
+
     def test_string(self):
         # text_factory defaults to str
         row = self.con.execute("select value from test").fetchone()
@@ -318,9 +327,6 @@ def test_custom(self):
         self.assertIs(type(row[0]), bytes)
         self.assertEqual(row[0], b"a\x00b")
 
-    def tearDown(self):
-        self.con.close()
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_sqlite3/test_hooks.py b/Lib/test/test_sqlite3/test_hooks.py
index 21042b9bf10..c47cfab180d 100644
--- a/Lib/test/test_sqlite3/test_hooks.py
+++ b/Lib/test/test_sqlite3/test_hooks.py
@@ -26,34 +26,31 @@
 
 from test.support.os_helper import TESTFN, unlink
 
-from test.test_sqlite3.test_dbapi import memory_database, cx_limit
-from test.test_sqlite3.test_userfunctions import with_tracebacks
+from .util import memory_database, cx_limit, with_tracebacks
+from .util import MemoryDatabaseMixin
 
 
-class CollationTests(unittest.TestCase):
+class CollationTests(MemoryDatabaseMixin, unittest.TestCase):
+
     def test_create_collation_not_string(self):
-        con = sqlite.connect(":memory:")
         with self.assertRaises(TypeError):
-            con.create_collation(None, lambda x, y: (x > y) - (x < y))
+            self.con.create_collation(None, lambda x, y: (x > y) - (x < y))
 
     def test_create_collation_not_callable(self):
-        con = sqlite.connect(":memory:")
         with self.assertRaises(TypeError) as cm:
-            con.create_collation("X", 42)
+            self.con.create_collation("X", 42)
         self.assertEqual(str(cm.exception), 'parameter must be callable')
 
     def test_create_collation_not_ascii(self):
-        con = sqlite.connect(":memory:")
-        con.create_collation("collä", lambda x, y: (x > y) - (x < y))
+        self.con.create_collation("collä", lambda x, y: (x > y) - (x < y))
 
     def test_create_collation_bad_upper(self):
         class BadUpperStr(str):
             def upper(self):
                 return None
-        con = sqlite.connect(":memory:")
         mycoll = lambda x, y: -((x > y) - (x < y))
-        con.create_collation(BadUpperStr("mycoll"), mycoll)
-        result = con.execute("""
+        self.con.create_collation(BadUpperStr("mycoll"), mycoll)
+        result = self.con.execute("""
             select x from (
             select 'a' as x
             union
@@ -68,8 +65,7 @@ def mycoll(x, y):
             # reverse order
             return -((x > y) - (x < y))
 
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", mycoll)
+        self.con.create_collation("mycoll", mycoll)
         sql = """
             select x from (
             select 'a' as x
@@ -79,21 +75,20 @@ def mycoll(x, y):
             select 'c' as x
             ) order by x collate mycoll
             """
-        result = con.execute(sql).fetchall()
+        result = self.con.execute(sql).fetchall()
         self.assertEqual(result, [('c',), ('b',), ('a',)],
                          msg='the expected order was not returned')
 
-        con.create_collation("mycoll", None)
+        self.con.create_collation("mycoll", None)
         with self.assertRaises(sqlite.OperationalError) as cm:
-            result = con.execute(sql).fetchall()
+            result = self.con.execute(sql).fetchall()
         self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
 
     def test_collation_returns_large_integer(self):
         def mycoll(x, y):
             # reverse order
             return -((x > y) - (x < y)) * 2**32
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", mycoll)
+        self.con.create_collation("mycoll", mycoll)
         sql = """
             select x from (
             select 'a' as x
@@ -103,7 +98,7 @@ def mycoll(x, y):
             select 'c' as x
             ) order by x collate mycoll
             """
-        result = con.execute(sql).fetchall()
+        result = self.con.execute(sql).fetchall()
         self.assertEqual(result, [('c',), ('b',), ('a',)],
                          msg="the expected order was not returned")
 
@@ -112,7 +107,7 @@ def test_collation_register_twice(self):
         Register two different collation functions under the same name.
         Verify that the last one is actually used.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.create_collation("mycoll", lambda x, y: (x > y) - (x < y))
         con.create_collation("mycoll", lambda x, y: -((x > y) - (x < y)))
         result = con.execute("""
@@ -126,25 +121,26 @@ def test_deregister_collation(self):
         Register a collation, then deregister it. Make sure an error is raised if we try
         to use it.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.create_collation("mycoll", lambda x, y: (x > y) - (x < y))
         con.create_collation("mycoll", None)
         with self.assertRaises(sqlite.OperationalError) as cm:
             con.execute("select 'a' as x union select 'b' as x order by x collate mycoll")
         self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
 
-class ProgressTests(unittest.TestCase):
+
+class ProgressTests(MemoryDatabaseMixin, unittest.TestCase):
+
     def test_progress_handler_used(self):
         """
         Test that the progress handler is invoked once it is set.
         """
-        con = sqlite.connect(":memory:")
         progress_calls = []
         def progress():
             progress_calls.append(None)
             return 0
-        con.set_progress_handler(progress, 1)
-        con.execute("""
+        self.con.set_progress_handler(progress, 1)
+        self.con.execute("""
             create table foo(a, b)
             """)
         self.assertTrue(progress_calls)
@@ -153,7 +149,7 @@ def test_opcode_count(self):
         """
         Test that the opcode argument is respected.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         progress_calls = []
         def progress():
             progress_calls.append(None)
@@ -176,11 +172,10 @@ def test_cancel_operation(self):
         """
         Test that returning a non-zero value stops the operation in progress.
         """
-        con = sqlite.connect(":memory:")
         def progress():
             return 1
-        con.set_progress_handler(progress, 1)
-        curs = con.cursor()
+        self.con.set_progress_handler(progress, 1)
+        curs = self.con.cursor()
         self.assertRaises(
             sqlite.OperationalError,
             curs.execute,
@@ -190,7 +185,7 @@ def test_clear_handler(self):
         """
         Test that setting the progress handler to None clears the previously set handler.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         action = 0
         def progress():
             nonlocal action
@@ -201,33 +196,47 @@ def progress():
         con.execute("select 1 union select 2 union select 3").fetchall()
         self.assertEqual(action, 0, "progress handler was not cleared")
 
-    @with_tracebacks(ZeroDivisionError, name="bad_progress")
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @with_tracebacks(ZeroDivisionError, msg_regex="bad_progress")
     def test_error_in_progress_handler(self):
-        con = sqlite.connect(":memory:")
         def bad_progress():
             1 / 0
-        con.set_progress_handler(bad_progress, 1)
+        self.con.set_progress_handler(bad_progress, 1)
         with self.assertRaises(sqlite.OperationalError):
-            con.execute("""
+            self.con.execute("""
                 create table foo(a, b)
                 """)
 
-    @with_tracebacks(ZeroDivisionError, name="bad_progress")
+    @unittest.expectedFailure # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ZeroDivisionError, msg_regex="bad_progress")
     def test_error_in_progress_handler_result(self):
-        con = sqlite.connect(":memory:")
         class BadBool:
             def __bool__(self):
                 1 / 0
         def bad_progress():
             return BadBool()
-        con.set_progress_handler(bad_progress, 1)
+        self.con.set_progress_handler(bad_progress, 1)
         with self.assertRaises(sqlite.OperationalError):
-            con.execute("""
+            self.con.execute("""
                 create table foo(a, b)
                 """)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON keyword-only arguments not supported for set_progress_handler
+    def test_progress_handler_keyword_args(self):
+        regex = (
+            r"Passing keyword argument 'progress_handler' to "
+            r"_sqlite3.Connection.set_progress_handler\(\) is deprecated. "
+            r"Parameter 'progress_handler' will become positional-only in "
+            r"Python 3.15."
+        )
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.set_progress_handler(progress_handler=lambda: None, n=1)
+        self.assertEqual(cm.filename, __file__)
+
+
+class TraceCallbackTests(MemoryDatabaseMixin, unittest.TestCase):
 
-class TraceCallbackTests(unittest.TestCase):
     @contextlib.contextmanager
     def check_stmt_trace(self, cx, expected):
         try:
@@ -242,12 +251,11 @@ def test_trace_callback_used(self):
         """
         Test that the trace callback is invoked once it is set.
         """
-        con = sqlite.connect(":memory:")
         traced_statements = []
         def trace(statement):
             traced_statements.append(statement)
-        con.set_trace_callback(trace)
-        con.execute("create table foo(a, b)")
+        self.con.set_trace_callback(trace)
+        self.con.execute("create table foo(a, b)")
         self.assertTrue(traced_statements)
         self.assertTrue(any("create table foo" in stmt for stmt in traced_statements))
 
@@ -255,7 +263,7 @@ def test_clear_trace_callback(self):
         """
         Test that setting the trace callback to None clears the previously set callback.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         traced_statements = []
         def trace(statement):
             traced_statements.append(statement)
@@ -269,7 +277,7 @@ def test_unicode_content(self):
         Test that the statement can contain unicode literals.
         """
         unicode_value = '\xf6\xe4\xfc\xd6\xc4\xdc\xdf\u20ac'
-        con = sqlite.connect(":memory:")
+        con = self.con
         traced_statements = []
         def trace(statement):
             traced_statements.append(statement)
@@ -317,13 +325,14 @@ def test_trace_expanded_sql(self):
                 cx.execute("create table t(t)")
                 cx.executemany("insert into t values(?)", ((v,) for v in range(3)))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(
         sqlite.DataError,
         regex="Expanded SQL string exceeds the maximum string length"
     )
     def test_trace_too_much_expanded_sql(self):
         # If the expanded string is too large, we'll fall back to the
-        # unexpanded SQL statement (for SQLite 3.14.0 and newer).
+        # unexpanded SQL statement.
         # The resulting string length is limited by the runtime limit
         # SQLITE_LIMIT_LENGTH.
         template = "select 1 as a where a="
@@ -334,8 +343,6 @@ def test_trace_too_much_expanded_sql(self):
 
             unexpanded_query = template + "?"
             expected = [unexpanded_query]
-            if sqlite.sqlite_version_info < (3, 14, 0):
-                expected = []
             with self.check_stmt_trace(cx, expected):
                 cx.execute(unexpanded_query, (bad_param,))
 
@@ -343,12 +350,26 @@ def test_trace_too_much_expanded_sql(self):
             with self.check_stmt_trace(cx, [expanded_query]):
                 cx.execute(unexpanded_query, (ok_param,))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(ZeroDivisionError, regex="division by zero")
     def test_trace_bad_handler(self):
         with memory_database() as cx:
             cx.set_trace_callback(lambda stmt: 5/0)
             cx.execute("select 1")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON keyword-only arguments not supported for set_trace_callback
+    def test_trace_keyword_args(self):
+        regex = (
+            r"Passing keyword argument 'trace_callback' to "
+            r"_sqlite3.Connection.set_trace_callback\(\) is deprecated. "
+            r"Parameter 'trace_callback' will become positional-only in "
+            r"Python 3.15."
+        )
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.set_trace_callback(trace_callback=lambda: None)
+        self.assertEqual(cm.filename, __file__)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_sqlite3/test_regression.py b/Lib/test/test_sqlite3/test_regression.py
index d746be647c6..0ebd6d5e9da 100644
--- a/Lib/test/test_sqlite3/test_regression.py
+++ b/Lib/test/test_sqlite3/test_regression.py
@@ -28,15 +28,12 @@
 
 from test import support
 from unittest.mock import patch
-from test.test_sqlite3.test_dbapi import memory_database, cx_limit
 
+from .util import memory_database, cx_limit
+from .util import MemoryDatabaseMixin
 
-class RegressionTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
 
-    def tearDown(self):
-        self.con.close()
+class RegressionTests(MemoryDatabaseMixin, unittest.TestCase):
 
     def test_pragma_user_version(self):
         # This used to crash pysqlite because this pragma command returns NULL for the column name
@@ -45,28 +42,24 @@ def test_pragma_user_version(self):
 
     def test_pragma_schema_version(self):
         # This still crashed pysqlite <= 2.2.1
-        con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES)
-        try:
+        with memory_database(detect_types=sqlite.PARSE_COLNAMES) as con:
             cur = self.con.cursor()
             cur.execute("pragma schema_version")
-        finally:
-            cur.close()
-            con.close()
 
     def test_statement_reset(self):
         # pysqlite 2.1.0 to 2.2.0 have the problem that not all statements are
         # reset before a rollback, but only those that are still in the
         # statement cache. The others are not accessible from the connection object.
-        con = sqlite.connect(":memory:", cached_statements=5)
-        cursors = [con.cursor() for x in range(5)]
-        cursors[0].execute("create table test(x)")
-        for i in range(10):
-            cursors[0].executemany("insert into test(x) values (?)", [(x,) for x in range(10)])
+        with memory_database(cached_statements=5) as con:
+            cursors = [con.cursor() for x in range(5)]
+            cursors[0].execute("create table test(x)")
+            for i in range(10):
+                cursors[0].executemany("insert into test(x) values (?)", [(x,) for x in range(10)])
 
-        for i in range(5):
-            cursors[i].execute(" " * i + "select x from test")
+            for i in range(5):
+                cursors[i].execute(" " * i + "select x from test")
 
-        con.rollback()
+            con.rollback()
 
     def test_column_name_with_spaces(self):
         cur = self.con.cursor()
@@ -81,17 +74,15 @@ def test_statement_finalization_on_close_db(self):
         # cache when closing the database. statements that were still
         # referenced in cursors weren't closed and could provoke "
         # "OperationalError: Unable to close due to unfinalised statements".
-        con = sqlite.connect(":memory:")
         cursors = []
         # default statement cache size is 100
         for i in range(105):
-            cur = con.cursor()
+            cur = self.con.cursor()
             cursors.append(cur)
             cur.execute("select 1 x union select " + str(i))
-        con.close()
 
     def test_on_conflict_rollback(self):
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.execute("create table foo(x, unique(x) on conflict rollback)")
         con.execute("insert into foo(x) values (1)")
         try:
@@ -126,16 +117,16 @@ def test_type_map_usage(self):
         a statement. This test exhibits the problem.
         """
         SELECT = "select * from foo"
-        con = sqlite.connect(":memory:",detect_types=sqlite.PARSE_DECLTYPES)
-        cur = con.cursor()
-        cur.execute("create table foo(bar timestamp)")
-        with self.assertWarnsRegex(DeprecationWarning, "adapter"):
-            cur.execute("insert into foo(bar) values (?)", (datetime.datetime.now(),))
-        cur.execute(SELECT)
-        cur.execute("drop table foo")
-        cur.execute("create table foo(bar integer)")
-        cur.execute("insert into foo(bar) values (5)")
-        cur.execute(SELECT)
+        with memory_database(detect_types=sqlite.PARSE_DECLTYPES) as con:
+            cur = con.cursor()
+            cur.execute("create table foo(bar timestamp)")
+            with self.assertWarnsRegex(DeprecationWarning, "adapter"):
+                cur.execute("insert into foo(bar) values (?)", (datetime.datetime.now(),))
+            cur.execute(SELECT)
+            cur.execute("drop table foo")
+            cur.execute("create table foo(bar integer)")
+            cur.execute("insert into foo(bar) values (5)")
+            cur.execute(SELECT)
 
     def test_bind_mutating_list(self):
         # Issue41662: Crash when mutate a list of parameters during iteration.
@@ -144,11 +135,11 @@ def __conform__(self, protocol):
                 parameters.clear()
                 return "..."
         parameters = [X(), 0]
-        con = sqlite.connect(":memory:",detect_types=sqlite.PARSE_DECLTYPES)
-        con.execute("create table foo(bar X, baz integer)")
-        # Should not crash
-        with self.assertRaises(IndexError):
-            con.execute("insert into foo(bar, baz) values (?, ?)", parameters)
+        with memory_database(detect_types=sqlite.PARSE_DECLTYPES) as con:
+            con.execute("create table foo(bar X, baz integer)")
+            # Should not crash
+            with self.assertRaises(IndexError):
+                con.execute("insert into foo(bar, baz) values (?, ?)", parameters)
 
     def test_error_msg_decode_error(self):
         # When porting the module to Python 3.0, the error message about
@@ -173,7 +164,7 @@ def upper(self):
             def __del__(self):
                 con.isolation_level = ""
 
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.isolation_level = None
         for level in "", "DEFERRED", "IMMEDIATE", "EXCLUSIVE":
             with self.subTest(level=level):
@@ -204,8 +195,7 @@ class Cursor(sqlite.Cursor):
             def __init__(self, con):
                 pass
 
-        con = sqlite.connect(":memory:")
-        cur = Cursor(con)
+        cur = Cursor(self.con)
         with self.assertRaises(sqlite.ProgrammingError):
             cur.execute("select 4+5").fetchall()
         with self.assertRaisesRegex(sqlite.ProgrammingError,
@@ -238,7 +228,9 @@ def test_auto_commit(self):
         2.5.3 introduced a regression so that these could no longer
         be created.
         """
-        con = sqlite.connect(":memory:", isolation_level=None)
+        with memory_database(isolation_level=None) as con:
+            self.assertIsNone(con.isolation_level)
+            self.assertFalse(con.in_transaction)
 
     def test_pragma_autocommit(self):
         """
@@ -266,7 +258,7 @@ def collation_cb(a, b):
             # Lone surrogate cannot be encoded to the default encoding (utf8)
             "\uDC80", collation_cb)
 
-    @unittest.skip("TODO: RUSTPYTHON deadlock")
+    @unittest.skip('TODO: RUSTPYTHON; recursive cursor use causes lock contention')
     def test_recursive_cursor_use(self):
         """
         http://bugs.python.org/issue10811
@@ -274,9 +266,7 @@ def test_recursive_cursor_use(self):
         Recursively using a cursor, such as when reusing it from a generator led to segfaults.
         Now we catch recursive cursor usage and raise a ProgrammingError.
         """
-        con = sqlite.connect(":memory:")
-
-        cur = con.cursor()
+        cur = self.con.cursor()
         cur.execute("create table a (bar)")
         cur.execute("create table b (baz)")
 
@@ -296,29 +286,31 @@ def test_convert_timestamp_microsecond_padding(self):
         since the microsecond string "456" actually represents "456000".
         """
 
-        con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES)
-        cur = con.cursor()
-        cur.execute("CREATE TABLE t (x TIMESTAMP)")
+        with memory_database(detect_types=sqlite.PARSE_DECLTYPES) as con:
+            cur = con.cursor()
+            cur.execute("CREATE TABLE t (x TIMESTAMP)")
 
-        # Microseconds should be 456000
-        cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.456')")
+            # Microseconds should be 456000
+            cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.456')")
 
-        # Microseconds should be truncated to 123456
-        cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.123456789')")
+            # Microseconds should be truncated to 123456
+            cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.123456789')")
 
-        cur.execute("SELECT * FROM t")
-        with self.assertWarnsRegex(DeprecationWarning, "converter"):
-            values = [x[0] for x in cur.fetchall()]
+            cur.execute("SELECT * FROM t")
+            with self.assertWarnsRegex(DeprecationWarning, "converter"):
+                values = [x[0] for x in cur.fetchall()]
 
-        self.assertEqual(values, [
-            datetime.datetime(2012, 4, 4, 15, 6, 0, 456000),
-            datetime.datetime(2012, 4, 4, 15, 6, 0, 123456),
-        ])
+            self.assertEqual(values, [
+                datetime.datetime(2012, 4, 4, 15, 6, 0, 456000),
+                datetime.datetime(2012, 4, 4, 15, 6, 0, 123456),
+            ])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; error message mismatch
     def test_invalid_isolation_level_type(self):
         # isolation level is a string, not an integer
-        self.assertRaises(TypeError,
-                          sqlite.connect, ":memory:", isolation_level=123)
+        regex = "isolation_level must be str or None"
+        with self.assertRaisesRegex(TypeError, regex):
+            memory_database(isolation_level=123).__enter__()
 
 
     def test_null_character(self):
@@ -334,7 +326,7 @@ def test_null_character(self):
                                        cur.execute, query)
 
     def test_surrogates(self):
-        con = sqlite.connect(":memory:")
+        con = self.con
         self.assertRaises(UnicodeEncodeError, con, "select '\ud8ff'")
         self.assertRaises(UnicodeEncodeError, con, "select '\udcff'")
         cur = con.cursor()
@@ -360,7 +352,7 @@ def test_commit_cursor_reset(self):
         to return rows multiple times when fetched from cursors
         after commit. See issues 10513 and 23129 for details.
         """
-        con = sqlite.connect(":memory:")
+        con = self.con
         con.executescript("""
         create table t(c);
         create table t2(c);
@@ -392,10 +384,9 @@ def test_bpo31770(self):
         """
         def callback(*args):
             pass
-        con = sqlite.connect(":memory:")
-        cur = sqlite.Cursor(con)
+        cur = sqlite.Cursor(self.con)
         ref = weakref.ref(cur, callback)
-        cur.__init__(con)
+        cur.__init__(self.con)
         del cur
         # The interpreter shouldn't crash when ref is collected.
         del ref
@@ -405,8 +396,7 @@ def test_del_isolation_level_segfault(self):
         with self.assertRaises(AttributeError):
             del self.con.isolation_level
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bpo37347(self):
         class Printer:
             def log(self, *args):
@@ -428,6 +418,7 @@ def test_return_empty_bytestring(self):
 
     def test_table_lock_cursor_replace_stmt(self):
         with memory_database() as con:
+            con = self.con
             cur = con.cursor()
             cur.execute("create table t(t)")
             cur.executemany("insert into t values(?)",
@@ -445,10 +436,11 @@ def test_table_lock_cursor_dealloc(self):
             con.commit()
             cur = con.execute("select t from t")
             del cur
+            support.gc_collect()
             con.execute("drop table t")
             con.commit()
 
-    @unittest.skip("TODO: RUSTPYTHON deadlock")
+    @unittest.skip('TODO: RUSTPYTHON; recursive cursor use causes lock contention')
     def test_table_lock_cursor_non_readonly_select(self):
         with memory_database() as con:
             con.execute("create table t(t)")
@@ -461,6 +453,7 @@ def dup(v):
             con.create_function("dup", 1, dup)
             cur = con.execute("select dup(t) from t")
             del cur
+            support.gc_collect()
             con.execute("drop table t")
             con.commit()
 
@@ -476,7 +469,7 @@ def test_executescript_step_through_select(self):
             self.assertEqual(steps, values)
 
 
-@unittest.skip("TODO: RUSTPYTHON deadlock")
+@unittest.skip('TODO: RUSTPYTHON; recursive cursor use causes lock contention')
 class RecursiveUseOfCursors(unittest.TestCase):
     # GH-80254: sqlite3 should not segfault for recursive use of cursors.
     msg = "Recursive use of cursors not allowed"
@@ -496,21 +489,21 @@ def tearDown(self):
     def test_recursive_cursor_init(self):
         conv = lambda x: self.cur.__init__(self.con)
         with patch.dict(sqlite.converters, {"INIT": conv}):
-            self.cur.execute(f'select x as "x [INIT]", x from test')
+            self.cur.execute('select x as "x [INIT]", x from test')
             self.assertRaisesRegex(sqlite.ProgrammingError, self.msg,
                                    self.cur.fetchall)
 
     def test_recursive_cursor_close(self):
         conv = lambda x: self.cur.close()
         with patch.dict(sqlite.converters, {"CLOSE": conv}):
-            self.cur.execute(f'select x as "x [CLOSE]", x from test')
+            self.cur.execute('select x as "x [CLOSE]", x from test')
             self.assertRaisesRegex(sqlite.ProgrammingError, self.msg,
                                    self.cur.fetchall)
 
     def test_recursive_cursor_iter(self):
         conv = lambda x, l=[]: self.cur.fetchone() if l else l.append(None)
         with patch.dict(sqlite.converters, {"ITER": conv}):
-            self.cur.execute(f'select x as "x [ITER]", x from test')
+            self.cur.execute('select x as "x [ITER]", x from test')
             self.assertRaisesRegex(sqlite.ProgrammingError, self.msg,
                                    self.cur.fetchall)
 
diff --git a/Lib/test/test_sqlite3/test_transactions.py b/Lib/test/test_sqlite3/test_transactions.py
index 9c3d19e79bd..f38d042e598 100644
--- a/Lib/test/test_sqlite3/test_transactions.py
+++ b/Lib/test/test_sqlite3/test_transactions.py
@@ -22,22 +22,24 @@
 
 import unittest
 import sqlite3 as sqlite
+from contextlib import contextmanager
 
-from test.support import LOOPBACK_TIMEOUT
 from test.support.os_helper import TESTFN, unlink
+from test.support.script_helper import assert_python_ok
 
-from test.test_sqlite3.test_dbapi import memory_database
-
-
-TIMEOUT = LOOPBACK_TIMEOUT / 10
+from .util import memory_database
+from .util import MemoryDatabaseMixin
 
 
+@unittest.skip("TODO: RUSTPYTHON timeout parameter does not accept int type")
 class TransactionTests(unittest.TestCase):
     def setUp(self):
-        self.con1 = sqlite.connect(TESTFN, timeout=TIMEOUT)
+        # We can disable the busy handlers, since we control
+        # the order of SQLite C API operations.
+        self.con1 = sqlite.connect(TESTFN, timeout=0)
         self.cur1 = self.con1.cursor()
 
-        self.con2 = sqlite.connect(TESTFN, timeout=TIMEOUT)
+        self.con2 = sqlite.connect(TESTFN, timeout=0)
         self.cur2 = self.con2.cursor()
 
     def tearDown(self):
@@ -117,10 +119,8 @@ def test_raise_timeout(self):
             self.cur2.execute("insert into test(i) values (5)")
 
     def test_locking(self):
-        """
-        This tests the improved concurrency with pysqlite 2.3.4. You needed
-        to roll back con2 before you could commit con1.
-        """
+        # This tests the improved concurrency with pysqlite 2.3.4. You needed
+        # to roll back con2 before you could commit con1.
         self.cur1.execute("create table test(i)")
         self.cur1.execute("insert into test(i) values (5)")
         with self.assertRaises(sqlite.OperationalError):
@@ -130,14 +130,14 @@ def test_locking(self):
 
     def test_rollback_cursor_consistency(self):
         """Check that cursors behave correctly after rollback."""
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
-        cur.execute("create table test(x)")
-        cur.execute("insert into test(x) values (5)")
-        cur.execute("select 1 union select 2 union select 3")
+        with memory_database() as con:
+            cur = con.cursor()
+            cur.execute("create table test(x)")
+            cur.execute("insert into test(x) values (5)")
+            cur.execute("select 1 union select 2 union select 3")
 
-        con.rollback()
-        self.assertEqual(cur.fetchall(), [(1,), (2,), (3,)])
+            con.rollback()
+            self.assertEqual(cur.fetchall(), [(1,), (2,), (3,)])
 
     def test_multiple_cursors_and_iternext(self):
         # gh-94028: statements are cleared and reset in cursor iternext.
@@ -216,10 +216,7 @@ def test_no_duplicate_rows_after_rollback_new_query(self):
 
 
 
-class SpecialCommandTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.cur = self.con.cursor()
+class SpecialCommandTests(MemoryDatabaseMixin, unittest.TestCase):
 
     def test_drop_table(self):
         self.cur.execute("create table test(i)")
@@ -231,14 +228,8 @@ def test_pragma(self):
         self.cur.execute("insert into test(i) values (5)")
         self.cur.execute("pragma count_changes=1")
 
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
 
-class TransactionalDDL(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
+class TransactionalDDL(MemoryDatabaseMixin, unittest.TestCase):
 
     def test_ddl_does_not_autostart_transaction(self):
         # For backwards compatibility reasons, DDL statements should not
@@ -266,9 +257,6 @@ def test_transactional_ddl(self):
         with self.assertRaises(sqlite.OperationalError):
             self.con.execute("select * from test")
 
-    def tearDown(self):
-        self.con.close()
-
 
 class IsolationLevelFromInit(unittest.TestCase):
     CREATE = "create table t(t)"
@@ -366,5 +354,183 @@ def test_isolation_level_none(self):
         self.assertEqual(self.traced, [self.QUERY])
 
 
+class AutocommitAttribute(unittest.TestCase):
+    """Test PEP 249-compliant autocommit behaviour."""
+    legacy = sqlite.LEGACY_TRANSACTION_CONTROL
+
+    @contextmanager
+    def check_stmt_trace(self, cx, expected, reset=True):
+        try:
+            traced = []
+            cx.set_trace_callback(lambda stmt: traced.append(stmt))
+            yield
+        finally:
+            self.assertEqual(traced, expected)
+            if reset:
+                cx.set_trace_callback(None)
+
+    def test_autocommit_default(self):
+        with memory_database() as cx:
+            self.assertEqual(cx.autocommit,
+                             sqlite.LEGACY_TRANSACTION_CONTROL)
+
+    def test_autocommit_setget(self):
+        dataset = (
+            True,
+            False,
+            sqlite.LEGACY_TRANSACTION_CONTROL,
+        )
+        for mode in dataset:
+            with self.subTest(mode=mode):
+                with memory_database(autocommit=mode) as cx:
+                    self.assertEqual(cx.autocommit, mode)
+                with memory_database() as cx:
+                    cx.autocommit = mode
+                    self.assertEqual(cx.autocommit, mode)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit validation error messages differ
+    def test_autocommit_setget_invalid(self):
+        msg = "autocommit must be True, False, or.*LEGACY"
+        for mode in "a", 12, (), None:
+            with self.subTest(mode=mode):
+                with self.assertRaisesRegex(ValueError, msg):
+                    sqlite.connect(":memory:", autocommit=mode)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_disabled(self):
+        expected = [
+            "SELECT 1",
+            "COMMIT",
+            "BEGIN",
+            "ROLLBACK",
+            "BEGIN",
+        ]
+        with memory_database(autocommit=False) as cx:
+            self.assertTrue(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected):
+                cx.execute("SELECT 1")
+                cx.commit()
+                cx.rollback()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_disabled_implicit_rollback(self):
+        expected = ["ROLLBACK"]
+        with memory_database(autocommit=False) as cx:
+            self.assertTrue(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected, reset=False):
+                cx.close()
+
+    def test_autocommit_enabled(self):
+        expected = ["CREATE TABLE t(t)", "INSERT INTO t VALUES(1)"]
+        with memory_database(autocommit=True) as cx:
+            self.assertFalse(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected):
+                cx.execute("CREATE TABLE t(t)")
+                cx.execute("INSERT INTO t VALUES(1)")
+                self.assertFalse(cx.in_transaction)
+
+    def test_autocommit_enabled_txn_ctl(self):
+        for op in "commit", "rollback":
+            with self.subTest(op=op):
+                with memory_database(autocommit=True) as cx:
+                    meth = getattr(cx, op)
+                    self.assertFalse(cx.in_transaction)
+                    with self.check_stmt_trace(cx, []):
+                        meth()  # expect this to pass silently
+                        self.assertFalse(cx.in_transaction)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_disabled_then_enabled(self):
+        expected = ["COMMIT"]
+        with memory_database(autocommit=False) as cx:
+            self.assertTrue(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected):
+                cx.autocommit = True  # should commit
+                self.assertFalse(cx.in_transaction)
+
+    def test_autocommit_enabled_then_disabled(self):
+        expected = ["BEGIN"]
+        with memory_database(autocommit=True) as cx:
+            self.assertFalse(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected):
+                cx.autocommit = False  # should begin
+                self.assertTrue(cx.in_transaction)
+
+    def test_autocommit_explicit_then_disabled(self):
+        expected = ["BEGIN DEFERRED"]
+        with memory_database(autocommit=True) as cx:
+            self.assertFalse(cx.in_transaction)
+            with self.check_stmt_trace(cx, expected):
+                cx.execute("BEGIN DEFERRED")
+                cx.autocommit = False  # should now be a no-op
+                self.assertTrue(cx.in_transaction)
+
+    def test_autocommit_enabled_ctx_mgr(self):
+        with memory_database(autocommit=True) as cx:
+            # The context manager is a no-op if autocommit=True
+            with self.check_stmt_trace(cx, []):
+                with cx:
+                    self.assertFalse(cx.in_transaction)
+                self.assertFalse(cx.in_transaction)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_disabled_ctx_mgr(self):
+        expected = ["COMMIT", "BEGIN"]
+        with memory_database(autocommit=False) as cx:
+            with self.check_stmt_trace(cx, expected):
+                with cx:
+                    self.assertTrue(cx.in_transaction)
+                self.assertTrue(cx.in_transaction)
+
+    def test_autocommit_compat_ctx_mgr(self):
+        expected = ["BEGIN ", "INSERT INTO T VALUES(1)", "COMMIT"]
+        with memory_database(autocommit=self.legacy) as cx:
+            cx.execute("create table t(t)")
+            with self.check_stmt_trace(cx, expected):
+                with cx:
+                    self.assertFalse(cx.in_transaction)
+                    cx.execute("INSERT INTO T VALUES(1)")
+                    self.assertTrue(cx.in_transaction)
+                self.assertFalse(cx.in_transaction)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_enabled_executescript(self):
+        expected = ["BEGIN", "SELECT 1"]
+        with memory_database(autocommit=True) as cx:
+            with self.check_stmt_trace(cx, expected):
+                self.assertFalse(cx.in_transaction)
+                cx.execute("BEGIN")
+                cx.executescript("SELECT 1")
+                self.assertTrue(cx.in_transaction)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON autocommit behavior differs
+    def test_autocommit_disabled_executescript(self):
+        expected = ["SELECT 1"]
+        with memory_database(autocommit=False) as cx:
+            with self.check_stmt_trace(cx, expected):
+                self.assertTrue(cx.in_transaction)
+                cx.executescript("SELECT 1")
+                self.assertTrue(cx.in_transaction)
+
+    def test_autocommit_compat_executescript(self):
+        expected = ["BEGIN", "COMMIT", "SELECT 1"]
+        with memory_database(autocommit=self.legacy) as cx:
+            with self.check_stmt_trace(cx, expected):
+                self.assertFalse(cx.in_transaction)
+                cx.execute("BEGIN")
+                cx.executescript("SELECT 1")
+                self.assertFalse(cx.in_transaction)
+
+    def test_autocommit_disabled_implicit_shutdown(self):
+        # The implicit ROLLBACK should not call back into Python during
+        # interpreter tear-down.
+        code = """if 1:
+            import sqlite3
+            cx = sqlite3.connect(":memory:", autocommit=False)
+            cx.set_trace_callback(print)
+        """
+        assert_python_ok("-c", code, PYTHONIOENCODING="utf-8")
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_sqlite3/test_types.py b/Lib/test/test_sqlite3/test_types.py
index 62318823510..66d27d21b8d 100644
--- a/Lib/test/test_sqlite3/test_types.py
+++ b/Lib/test/test_sqlite3/test_types.py
@@ -106,9 +106,9 @@ def test_string_with_surrogates(self):
     @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
     @support.bigmemtest(size=2**31, memuse=4, dry_run=False)
     def test_too_large_string(self, maxsize):
-        with self.assertRaises(sqlite.InterfaceError):
+        with self.assertRaises(sqlite.DataError):
             self.cur.execute("insert into test(s) values (?)", ('x'*(2**31-1),))
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(sqlite.DataError):
             self.cur.execute("insert into test(s) values (?)", ('x'*(2**31),))
         self.cur.execute("select 1 from test")
         row = self.cur.fetchone()
@@ -117,9 +117,9 @@ def test_too_large_string(self, maxsize):
     @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
     @support.bigmemtest(size=2**31, memuse=3, dry_run=False)
     def test_too_large_blob(self, maxsize):
-        with self.assertRaises(sqlite.InterfaceError):
+        with self.assertRaises(sqlite.DataError):
             self.cur.execute("insert into test(s) values (?)", (b'x'*(2**31-1),))
-        with self.assertRaises(OverflowError):
+        with self.assertRaises(sqlite.DataError):
             self.cur.execute("insert into test(s) values (?)", (b'x'*(2**31),))
         self.cur.execute("select 1 from test")
         row = self.cur.fetchone()
@@ -371,7 +371,6 @@ def test_cursor_description_insert(self):
         self.assertIsNone(self.cur.description)
 
 
-@unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "CTEs not supported")
 class CommonTableExpressionTests(unittest.TestCase):
 
     def setUp(self):
@@ -517,7 +516,7 @@ def test_sqlite_timestamp(self):
         self.assertEqual(ts, ts2)
 
     def test_sql_timestamp(self):
-        now = datetime.datetime.utcnow()
+        now = datetime.datetime.now(tz=datetime.UTC)
         self.cur.execute("insert into test(ts) values (current_timestamp)")
         self.cur.execute("select ts from test")
         with self.assertWarnsRegex(DeprecationWarning, "converter"):
diff --git a/Lib/test/test_sqlite3/test_userfunctions.py b/Lib/test/test_sqlite3/test_userfunctions.py
index e8b98a66a57..3fdde4a26cd 100644
--- a/Lib/test/test_sqlite3/test_userfunctions.py
+++ b/Lib/test/test_sqlite3/test_userfunctions.py
@@ -21,55 +21,15 @@
 #    misrepresented as being the original software.
 # 3. This notice may not be removed or altered from any source distribution.
 
-import contextlib
-import functools
-import io
-import re
 import sys
 import unittest
 import sqlite3 as sqlite
 
 from unittest.mock import Mock, patch
-from test.support import bigmemtest, catch_unraisable_exception, gc_collect
-
-from test.test_sqlite3.test_dbapi import cx_limit
-
-
-def with_tracebacks(exc, regex="", name=""):
-    """Convenience decorator for testing callback tracebacks."""
-    def decorator(func):
-        _regex = re.compile(regex) if regex else None
-        @functools.wraps(func)
-        def wrapper(self, *args, **kwargs):
-            with catch_unraisable_exception() as cm:
-                # First, run the test with traceback enabled.
-                with check_tracebacks(self, cm, exc, _regex, name):
-                    func(self, *args, **kwargs)
-
-            # Then run the test with traceback disabled.
-            func(self, *args, **kwargs)
-        return wrapper
-    return decorator
-
-
-@contextlib.contextmanager
-def check_tracebacks(self, cm, exc, regex, obj_name):
-    """Convenience context manager for testing callback tracebacks."""
-    sqlite.enable_callback_tracebacks(True)
-    try:
-        buf = io.StringIO()
-        with contextlib.redirect_stderr(buf):
-            yield
-
-        # TODO: RUSTPYTHON need unraisable exception
-        # self.assertEqual(cm.unraisable.exc_type, exc)
-        # if regex:
-        #     msg = str(cm.unraisable.exc_value)
-        #     self.assertIsNotNone(regex.search(msg))
-        # if obj_name:
-        #     self.assertEqual(cm.unraisable.object.__name__, obj_name)
-    finally:
-        sqlite.enable_callback_tracebacks(False)
+from test.support import bigmemtest, gc_collect
+
+from .util import cx_limit, memory_database
+from .util import with_tracebacks
 
 
 def func_returntext():
@@ -196,7 +156,6 @@ def setUp(self):
         self.con.create_function("returnblob", 0, func_returnblob)
         self.con.create_function("returnlonglong", 0, func_returnlonglong)
         self.con.create_function("returnnan", 0, lambda: float("nan"))
-        self.con.create_function("returntoolargeint", 0, lambda: 1 << 65)
         self.con.create_function("return_noncont_blob", 0,
                                  lambda: memoryview(b"blob")[::2])
         self.con.create_function("raiseexception", 0, func_raiseexception)
@@ -211,8 +170,9 @@ def setUp(self):
     def tearDown(self):
         self.con.close()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for invalid num args
     def test_func_error_on_create(self):
-        with self.assertRaises(sqlite.OperationalError):
+        with self.assertRaisesRegex(sqlite.ProgrammingError, "not -100"):
             self.con.create_function("bla", -100, lambda x: 2*x)
 
     def test_func_too_many_args(self):
@@ -295,12 +255,8 @@ def test_func_return_nan(self):
         cur.execute("select returnnan()")
         self.assertIsNone(cur.fetchone()[0])
 
-    def test_func_return_too_large_int(self):
-        cur = self.con.cursor()
-        self.assertRaisesRegex(sqlite.DataError, "string or blob too big",
-                               self.con.execute, "select returntoolargeint()")
-
-    @with_tracebacks(ZeroDivisionError, name="func_raiseexception")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ZeroDivisionError, msg_regex="func_raiseexception")
     def test_func_exception(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.OperationalError) as cm:
@@ -308,14 +264,16 @@ def test_func_exception(self):
             cur.fetchone()
         self.assertEqual(str(cm.exception), 'user-defined function raised exception')
 
-    @with_tracebacks(MemoryError, name="func_memoryerror")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(MemoryError, msg_regex="func_memoryerror")
     def test_func_memory_error(self):
         cur = self.con.cursor()
         with self.assertRaises(MemoryError):
             cur.execute("select memoryerror()")
             cur.fetchone()
 
-    @with_tracebacks(OverflowError, name="func_overflowerror")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(OverflowError, msg_regex="func_overflowerror")
     def test_func_overflow_error(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.DataError):
@@ -348,6 +306,7 @@ def test_non_contiguous_blob(self):
                                self.con.execute, "select spam(?)",
                                (memoryview(b"blob")[::2],))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(BufferError, regex="buffer.*contiguous")
     def test_return_non_contiguous_blob(self):
         with self.assertRaises(sqlite.OperationalError):
@@ -388,38 +347,22 @@ def append_result(arg):
     # Regarding deterministic functions:
     #
     # Between 3.8.3 and 3.15.0, deterministic functions were only used to
-    # optimize inner loops, so for those versions we can only test if the
-    # sqlite machinery has factored out a call or not. From 3.15.0 and onward,
-    # deterministic functions were permitted in WHERE clauses of partial
-    # indices, which allows testing based on syntax, iso. the query optimizer.
-    @unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "Requires SQLite 3.8.3 or higher")
+    # optimize inner loops. From 3.15.0 and onward, deterministic functions
+    # were permitted in WHERE clauses of partial indices, which allows testing
+    # based on syntax, iso. the query optimizer.
     def test_func_non_deterministic(self):
         mock = Mock(return_value=None)
         self.con.create_function("nondeterministic", 0, mock, deterministic=False)
-        if sqlite.sqlite_version_info < (3, 15, 0):
-            self.con.execute("select nondeterministic() = nondeterministic()")
-            self.assertEqual(mock.call_count, 2)
-        else:
-            with self.assertRaises(sqlite.OperationalError):
-                self.con.execute("create index t on test(t) where nondeterministic() is not null")
+        with self.assertRaises(sqlite.OperationalError):
+            self.con.execute("create index t on test(t) where nondeterministic() is not null")
 
-    @unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "Requires SQLite 3.8.3 or higher")
     def test_func_deterministic(self):
         mock = Mock(return_value=None)
         self.con.create_function("deterministic", 0, mock, deterministic=True)
-        if sqlite.sqlite_version_info < (3, 15, 0):
-            self.con.execute("select deterministic() = deterministic()")
-            self.assertEqual(mock.call_count, 1)
-        else:
-            try:
-                self.con.execute("create index t on test(t) where deterministic() is not null")
-            except sqlite.OperationalError:
-                self.fail("Unexpected failure while creating partial index")
-
-    @unittest.skipIf(sqlite.sqlite_version_info >= (3, 8, 3), "SQLite < 3.8.3 needed")
-    def test_func_deterministic_not_supported(self):
-        with self.assertRaises(sqlite.NotSupportedError):
-            self.con.create_function("deterministic", 0, int, deterministic=True)
+        try:
+            self.con.execute("create index t on test(t) where deterministic() is not null")
+        except sqlite.OperationalError:
+            self.fail("Unexpected failure while creating partial index")
 
     def test_func_deterministic_keyword_only(self):
         with self.assertRaises(TypeError):
@@ -428,29 +371,32 @@ def test_func_deterministic_keyword_only(self):
     def test_function_destructor_via_gc(self):
         # See bpo-44304: The destructor of the user function can
         # crash if is called without the GIL from the gc functions
-        dest = sqlite.connect(':memory:')
         def md5sum(t):
             return
 
-        dest.create_function("md5", 1, md5sum)
-        x = dest("create table lang (name, first_appeared)")
-        del md5sum, dest
+        with memory_database() as dest:
+            dest.create_function("md5", 1, md5sum)
+            x = dest("create table lang (name, first_appeared)")
+            del md5sum, dest
 
-        y = [x]
-        y.append(y)
+            y = [x]
+            y.append(y)
 
-        del x,y
-        gc_collect()
+            del x,y
+            gc_collect()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(OverflowError)
     def test_func_return_too_large_int(self):
         cur = self.con.cursor()
+        msg = "string or blob too big"
         for value in 2**63, -2**63-1, 2**64:
             self.con.create_function("largeint", 0, lambda value=value: value)
-            with self.assertRaises(sqlite.DataError):
+            with self.assertRaisesRegex(sqlite.DataError, msg):
                 cur.execute("select largeint()")
 
-    @with_tracebacks(UnicodeEncodeError, "surrogates not allowed", "chr")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(UnicodeEncodeError, "surrogates not allowed")
     def test_func_return_text_with_surrogates(self):
         cur = self.con.cursor()
         self.con.create_function("pychr", 1, chr)
@@ -482,6 +428,30 @@ def test_func_return_illegal_value(self):
         self.assertRaisesRegex(sqlite.OperationalError, msg,
                                self.con.execute, "select badreturn()")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON deprecation warning not emitted for keyword args
+    def test_func_keyword_args(self):
+        regex = (
+            r"Passing keyword arguments 'name', 'narg' and 'func' to "
+            r"_sqlite3.Connection.create_function\(\) is deprecated. "
+            r"Parameters 'name', 'narg' and 'func' will become "
+            r"positional-only in Python 3.15."
+        )
+
+        def noop():
+            return None
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_function("noop", 0, func=noop)
+        self.assertEqual(cm.filename, __file__)
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_function("noop", narg=0, func=noop)
+        self.assertEqual(cm.filename, __file__)
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_function(name="noop", narg=0, func=noop)
+        self.assertEqual(cm.filename, __file__)
+
 
 class WindowSumInt:
     def __init__(self):
@@ -536,15 +506,20 @@ def setUp(self):
         """
         self.con.create_window_function("sumint", 1, WindowSumInt)
 
+    def tearDown(self):
+        self.cur.close()
+        self.con.close()
+
     def test_win_sum_int(self):
         self.cur.execute(self.query % "sumint")
         self.assertEqual(self.cur.fetchall(), self.expected)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for invalid num args
     def test_win_error_on_create(self):
-        self.assertRaises(sqlite.ProgrammingError,
-                          self.con.create_window_function,
-                          "shouldfail", -100, WindowSumInt)
+        with self.assertRaisesRegex(sqlite.ProgrammingError, "not -100"):
+            self.con.create_window_function("shouldfail", -100, WindowSumInt)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(BadWindow)
     def test_win_exception_in_method(self):
         for meth in "__init__", "step", "value", "inverse":
@@ -557,17 +532,19 @@ def test_win_exception_in_method(self):
                         self.cur.execute(self.query % name)
                         self.cur.fetchall()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(BadWindow)
     def test_win_exception_in_finalize(self):
         # Note: SQLite does not (as of version 3.38.0) propagate finalize
         # callback errors to sqlite3_step(); this implies that OperationalError
         # is _not_ raised.
         with patch.object(WindowSumInt, "finalize", side_effect=BadWindow):
-            name = f"exception_in_finalize"
+            name = "exception_in_finalize"
             self.con.create_window_function(name, 1, WindowSumInt)
             self.cur.execute(self.query % name)
             self.cur.fetchall()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(AttributeError)
     def test_win_missing_method(self):
         class MissingValue:
@@ -599,6 +576,7 @@ def finalize(self): return 42
                     self.cur.execute(self.query % name)
                     self.cur.fetchall()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
     @with_tracebacks(AttributeError)
     def test_win_missing_finalize(self):
         # Note: SQLite does not (as of version 3.38.0) propagate finalize
@@ -656,6 +634,7 @@ def setUp(self):
             """)
         cur.execute("insert into test(t, i, f, n, b) values (?, ?, ?, ?, ?)",
             ("foo", 5, 3.14, None, memoryview(b"blob"),))
+        cur.close()
 
         self.con.create_aggregate("nostep", 1, AggrNoStep)
         self.con.create_aggregate("nofinalize", 1, AggrNoFinalize)
@@ -668,15 +647,15 @@ def setUp(self):
         self.con.create_aggregate("aggtxt", 1, AggrText)
 
     def tearDown(self):
-        #self.cur.close()
-        #self.con.close()
-        pass
+        self.con.close()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs for invalid num args
     def test_aggr_error_on_create(self):
-        with self.assertRaises(sqlite.OperationalError):
+        with self.assertRaisesRegex(sqlite.ProgrammingError, "not -100"):
             self.con.create_function("bla", -100, AggrSum)
 
-    @with_tracebacks(AttributeError, name="AggrNoStep")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(AttributeError, msg_regex="AggrNoStep")
     def test_aggr_no_step(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.OperationalError) as cm:
@@ -691,7 +670,8 @@ def test_aggr_no_finalize(self):
             cur.execute("select nofinalize(t) from test")
             val = cur.fetchone()[0]
 
-    @with_tracebacks(ZeroDivisionError, name="AggrExceptionInInit")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ZeroDivisionError, msg_regex="AggrExceptionInInit")
     def test_aggr_exception_in_init(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.OperationalError) as cm:
@@ -699,7 +679,8 @@ def test_aggr_exception_in_init(self):
             val = cur.fetchone()[0]
         self.assertEqual(str(cm.exception), "user-defined aggregate's '__init__' method raised error")
 
-    @with_tracebacks(ZeroDivisionError, name="AggrExceptionInStep")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ZeroDivisionError, msg_regex="AggrExceptionInStep")
     def test_aggr_exception_in_step(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.OperationalError) as cm:
@@ -707,7 +688,8 @@ def test_aggr_exception_in_step(self):
             val = cur.fetchone()[0]
         self.assertEqual(str(cm.exception), "user-defined aggregate's 'step' method raised error")
 
-    @with_tracebacks(ZeroDivisionError, name="AggrExceptionInFinalize")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ZeroDivisionError, msg_regex="AggrExceptionInFinalize")
     def test_aggr_exception_in_finalize(self):
         cur = self.con.cursor()
         with self.assertRaises(sqlite.OperationalError) as cm:
@@ -772,6 +754,28 @@ def test_aggr_text(self):
                 val = cur.fetchone()[0]
                 self.assertEqual(val, txt)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON keyword-only arguments not supported for create_aggregate
+    def test_agg_keyword_args(self):
+        regex = (
+            r"Passing keyword arguments 'name', 'n_arg' and 'aggregate_class' to "
+            r"_sqlite3.Connection.create_aggregate\(\) is deprecated. "
+            r"Parameters 'name', 'n_arg' and 'aggregate_class' will become "
+            r"positional-only in Python 3.15."
+        )
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_aggregate("test", 1, aggregate_class=AggrText)
+        self.assertEqual(cm.filename, __file__)
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_aggregate("test", n_arg=1, aggregate_class=AggrText)
+        self.assertEqual(cm.filename, __file__)
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.create_aggregate(name="test", n_arg=0,
+                                      aggregate_class=AggrText)
+        self.assertEqual(cm.filename, __file__)
+
 
 class AuthorizerTests(unittest.TestCase):
     @staticmethod
@@ -783,8 +787,6 @@ def authorizer_cb(action, arg1, arg2, dbname, source):
         return sqlite.SQLITE_OK
 
     def setUp(self):
-        # TODO: RUSTPYTHON difference 'prohibited'
-        self.prohibited = 'not authorized'
         self.con = sqlite.connect(":memory:")
         self.con.executescript("""
             create table t1 (c1, c2);
@@ -799,23 +801,38 @@ def setUp(self):
         self.con.set_authorizer(self.authorizer_cb)
 
     def tearDown(self):
-        pass
+        self.con.close()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs
     def test_table_access(self):
         with self.assertRaises(sqlite.DatabaseError) as cm:
             self.con.execute("select * from t2")
-        self.assertIn(self.prohibited, str(cm.exception))
+        self.assertIn('prohibited', str(cm.exception))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON error message differs
     def test_column_access(self):
         with self.assertRaises(sqlite.DatabaseError) as cm:
             self.con.execute("select c2 from t1")
-        self.assertIn(self.prohibited, str(cm.exception))
+        self.assertIn('prohibited', str(cm.exception))
 
     def test_clear_authorizer(self):
         self.con.set_authorizer(None)
         self.con.execute("select * from t2")
         self.con.execute("select c2 from t1")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON keyword-only arguments not supported for set_authorizer
+    def test_authorizer_keyword_args(self):
+        regex = (
+            r"Passing keyword argument 'authorizer_callback' to "
+            r"_sqlite3.Connection.set_authorizer\(\) is deprecated. "
+            r"Parameter 'authorizer_callback' will become positional-only in "
+            r"Python 3.15."
+        )
+
+        with self.assertWarnsRegex(DeprecationWarning, regex) as cm:
+            self.con.set_authorizer(authorizer_callback=lambda: None)
+        self.assertEqual(cm.filename, __file__)
+
 
 class AuthorizerRaiseExceptionTests(AuthorizerTests):
     @staticmethod
@@ -826,11 +843,13 @@ def authorizer_cb(action, arg1, arg2, dbname, source):
             raise ValueError
         return sqlite.SQLITE_OK
 
-    @with_tracebacks(ValueError, name="authorizer_cb")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ValueError, msg_regex="authorizer_cb")
     def test_table_access(self):
         super().test_table_access()
 
-    @with_tracebacks(ValueError, name="authorizer_cb")
+    @unittest.expectedFailure  # TODO: RUSTPYTHON unraisable exception handling not implemented
+    @with_tracebacks(ValueError, msg_regex="authorizer_cb")
     def test_column_access(self):
         super().test_table_access()
 
diff --git a/Lib/test/test_sqlite3/util.py b/Lib/test/test_sqlite3/util.py
new file mode 100644
index 00000000000..cccd062160f
--- /dev/null
+++ b/Lib/test/test_sqlite3/util.py
@@ -0,0 +1,89 @@
+import contextlib
+import functools
+import io
+import re
+import sqlite3
+import test.support
+import unittest
+
+
+# Helper for temporary memory databases
+def memory_database(*args, **kwargs):
+    cx = sqlite3.connect(":memory:", *args, **kwargs)
+    return contextlib.closing(cx)
+
+
+# Temporarily limit a database connection parameter
+@contextlib.contextmanager
+def cx_limit(cx, category=sqlite3.SQLITE_LIMIT_SQL_LENGTH, limit=128):
+    try:
+        _prev = cx.setlimit(category, limit)
+        yield limit
+    finally:
+        cx.setlimit(category, _prev)
+
+
+def with_tracebacks(exc, regex="", name="", msg_regex=""):
+    """Convenience decorator for testing callback tracebacks."""
+    def decorator(func):
+        exc_regex = re.compile(regex) if regex else None
+        _msg_regex = re.compile(msg_regex) if msg_regex else None
+        @functools.wraps(func)
+        def wrapper(self, *args, **kwargs):
+            with test.support.catch_unraisable_exception() as cm:
+                # First, run the test with traceback enabled.
+                with check_tracebacks(self, cm, exc, exc_regex, _msg_regex, name):
+                    func(self, *args, **kwargs)
+
+            # Then run the test with traceback disabled.
+            func(self, *args, **kwargs)
+        return wrapper
+    return decorator
+
+
+@contextlib.contextmanager
+def check_tracebacks(self, cm, exc, exc_regex, msg_regex, obj_name):
+    """Convenience context manager for testing callback tracebacks."""
+    sqlite3.enable_callback_tracebacks(True)
+    try:
+        buf = io.StringIO()
+        with contextlib.redirect_stderr(buf):
+            yield
+
+        self.assertEqual(cm.unraisable.exc_type, exc)
+        if exc_regex:
+            msg = str(cm.unraisable.exc_value)
+            self.assertIsNotNone(exc_regex.search(msg), (exc_regex, msg))
+        if msg_regex:
+            msg = cm.unraisable.err_msg
+            self.assertIsNotNone(msg_regex.search(msg), (msg_regex, msg))
+        if obj_name:
+            self.assertEqual(cm.unraisable.object.__name__, obj_name)
+    finally:
+        sqlite3.enable_callback_tracebacks(False)
+
+
+class MemoryDatabaseMixin:
+
+    def setUp(self):
+        self.con = sqlite3.connect(":memory:")
+        self.cur = self.con.cursor()
+
+    def tearDown(self):
+        self.cur.close()
+        self.con.close()
+
+    @property
+    def cx(self):
+        return self.con
+
+    @property
+    def cu(self):
+        return self.cur
+
+
+def requires_virtual_table(module):
+    with memory_database() as cx:
+        supported = (module,) in list(cx.execute("PRAGMA module_list"))
+        reason = f"Requires {module!r} virtual table support"
+        return unittest.skipUnless(supported, reason)

From 4ab6a45405bf536783a4f382e23bfb8cc635c9f7 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 19 Jan 2026 08:43:25 +0900
Subject: [PATCH 378/418] Use stdlib native modules in benchmarks (#6792)

Change benchmark interpreter from without_stdlib to with_init to load
Rust-optimized native modules like _json, ensuring benchmarks measure
actual optimized performance rather than pure Python fallbacks.

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
---
 Cargo.toml           | 1 +
 benches/execution.rs | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 083358cf749..6c29f67e03b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,6 +54,7 @@ rustyline = { workspace = true }
 [dev-dependencies]
 criterion = { workspace = true }
 pyo3 = { version = "0.27", features = ["auto-initialize"] }
+rustpython-stdlib = { workspace = true }
 
 [[bench]]
 name = "execution"
diff --git a/benches/execution.rs b/benches/execution.rs
index c2239b59d12..bf1bcfcc3db 100644
--- a/benches/execution.rs
+++ b/benches/execution.rs
@@ -24,7 +24,10 @@ fn bench_rustpython_code(b: &mut Bencher, name: &str, source: &str) {
     settings.path_list.push("Lib/".to_string());
     settings.write_bytecode = false;
     settings.user_site_directory = false;
-    Interpreter::without_stdlib(settings).enter(|vm| {
+    Interpreter::with_init(settings, |vm| {
+        vm.add_native_modules(rustpython_stdlib::get_module_inits());
+    })
+    .enter(|vm| {
         // Note: bench_cpython is both compiling and executing the code.
         // As such we compile the code in the benchmark loop as well.
         b.iter(|| {

From 6a064aad3b82cb0c610773222e5b5248e6a76a31 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 19 Jan 2026 10:01:11 +0900
Subject: [PATCH 379/418] Drop for PySSLSocket (#6791)

---
 crates/stdlib/src/ssl.rs | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 6c62a24397b..27d606358a1 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -3503,9 +3503,9 @@ mod _ssl {
             }
 
             // Check if connection has been shut down
-            // After unwrap()/shutdown(), read operations should fail with SSLError
+            // Only block after shutdown is COMPLETED, not during shutdown process
             let shutdown_state = *self.shutdown_state.lock();
-            if shutdown_state != ShutdownState::NotStarted {
+            if shutdown_state == ShutdownState::Completed {
                 return Err(vm
                     .new_os_subtype_error(
                         PySSLError::class(&vm.ctx).to_owned(),
@@ -3677,7 +3677,8 @@ mod _ssl {
             }
 
             // Check shutdown state
-            if *self.shutdown_state.lock() != ShutdownState::NotStarted {
+            // Only block after shutdown is COMPLETED, not during shutdown process
+            if *self.shutdown_state.lock() == ShutdownState::Completed {
                 return Err(vm
                     .new_os_subtype_error(
                         PySSLError::class(&vm.ctx).to_owned(),
@@ -4138,6 +4139,8 @@ mod _ssl {
                         }
                     }
 
+                    // Set shutdown_state first to ensure atomic visibility
+                    // This prevents read/write race conditions during shutdown
                     *self.shutdown_state.lock() = ShutdownState::Completed;
                     *self.connection.lock() = None;
                     return Ok(self.sock.clone());
@@ -4399,6 +4402,21 @@ mod _ssl {
         }
     }
 
+    // Clean up SSL socket resources on drop
+    impl Drop for PySSLSocket {
+        fn drop(&mut self) {
+            // Clear connection state
+            let _ = self.connection.lock().take();
+
+            // Clear pending buffers
+            self.pending_tls_output.lock().clear();
+            *self.write_buffered_len.lock() = 0;
+
+            // Reset shutdown state
+            *self.shutdown_state.lock() = ShutdownState::NotStarted;
+        }
+    }
+
     // MemoryBIO - provides in-memory buffer for SSL/TLS I/O
     #[pyattr]
     #[pyclass(name = "MemoryBIO", module = "ssl")]

From d7a885cea82b39be21b0f847e83cb78e117ff6ca Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Mon, 19 Jan 2026 16:43:20 +0900
Subject: [PATCH 380/418] sys._clear_type_descriptors (#6795)

---
 crates/vm/src/stdlib/sys.rs | 26 ++++++++++++++++++++++++++
 crates/vm/src/vm/context.rs |  1 +
 2 files changed, 27 insertions(+)

diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 305e1cfa61d..6c8a4e4062d 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1215,6 +1215,32 @@ mod sys {
         crate::vm::thread::COROUTINE_ORIGIN_TRACKING_DEPTH.get() as i32
     }
 
+    #[pyfunction]
+    fn _clear_type_descriptors(type_obj: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+        use crate::types::PyTypeFlags;
+
+        // Check if type is immutable
+        if type_obj.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            return Err(vm.new_type_error("argument is immutable".to_owned()));
+        }
+
+        let mut attributes = type_obj.attributes.write();
+
+        // Remove __dict__ descriptor if present
+        attributes.swap_remove(identifier!(vm, __dict__));
+
+        // Remove __weakref__ descriptor if present
+        attributes.swap_remove(identifier!(vm, __weakref__));
+
+        drop(attributes);
+
+        // Update slots to notify subclasses and recalculate cached values
+        type_obj.update_slot::<true>(identifier!(vm, __dict__), &vm.ctx);
+        type_obj.update_slot::<true>(identifier!(vm, __weakref__), &vm.ctx);
+
+        Ok(())
+    }
+
     #[pyfunction]
     fn getswitchinterval(vm: &VirtualMachine) -> f64 {
         // Return the stored switch interval
diff --git a/crates/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
index 9978554bcc4..f4368e91a1d 100644
--- a/crates/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -234,6 +234,7 @@ declare_const_name! {
     __typing_is_unpacked_typevartuple__,
     __typing_prepare_subst__,
     __typing_unpacked_tuple_args__,
+    __weakref__,
     __xor__,
 
     // common names

From 82a8f67c71f99532ce4b4e9735149b536a30030e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 00:34:46 +0900
Subject: [PATCH 381/418] Replace custom opcodes with CPython standard
 sequences (#6794)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Replace custom opcodes with standard sequences

Remove RustPython-specific opcodes (BuildListFromTuples,
BuildMapForCall, BuildSetFromTuples, BuildTupleFromTuples)
and replace their usage with CPython 3.14 standard opcode
sequences:

- BuildListFromTuples → BUILD_LIST + LIST_EXTEND loop
- BuildSetFromTuples → BUILD_SET + SET_UPDATE loop
- BuildTupleFromTuples → BUILD_LIST + LIST_EXTEND + CALL_INTRINSIC_1(ListToTuple)
- BuildMapForCall → DICT_MERGE loop

Implement missing opcodes:
- ListExtend: Extend list with iterable elements
- SetUpdate: Add iterable elements to set
- DictMerge: Merge dict with duplicate key checking

* Auto-generate: generate_opcode_metadata.py

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .cspell.dict/cpython.txt                      |   3 +
 Lib/test/test_compile.py                      |   4 -
 crates/codegen/src/compile.rs                 | 419 ++++++++++++------
 .../compiler-core/src/bytecode/instruction.rs |   6 +-
 crates/vm/src/frame.rs                        |  74 +++-
 5 files changed, 357 insertions(+), 149 deletions(-)

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 2ac19a4fca0..a45760eaf2c 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -34,6 +34,7 @@ IMMUTABLETYPE
 ismine
 Itertool
 keeped
+kwnames
 kwonlyarg
 kwonlyargs
 lasti
@@ -44,6 +45,7 @@ mult
 multibytecodec
 newsemlockobject
 nkwargs
+nkwelts
 noraise
 numer
 orelse
@@ -65,6 +67,7 @@ stackdepth
 stginfo
 stringlib
 structseq
+subkwargs
 subparams
 swappedbytes
 ticketer
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index bbaf3c5c190..629ab19f5d7 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1422,8 +1422,6 @@ def test_dict(self):
     def test_func_args(self):
         self.check_stack_size("f(" + "x, " * self.N + ")")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_func_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("f(" +  ", ".join(kwargs) + ")")
@@ -1433,8 +1431,6 @@ def test_func_kwargs(self):
     def test_meth_args(self):
         self.check_stack_size("o.m(" + "x, " * self.N + ")")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_meth_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("o.m(" +  ", ".join(kwargs) + ")")
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index a76d2b3446b..a72e425e290 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -29,8 +29,8 @@ use rustpython_compiler_core::{
     Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
     bytecode::{
         self, AnyInstruction, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
-        ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
-        PseudoInstruction, UnpackExArgs,
+        ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, IntrinsicFunction1,
+        Invert, OpArg, OpArgType, PseudoInstruction, UnpackExArgs,
     },
 };
 use rustpython_wtf8::Wtf8Buf;
@@ -531,38 +531,115 @@ impl Compiler {
         pushed: u32,
         collection_type: CollectionType,
     ) -> CompileResult<()> {
-        // Use RustPython's existing approach with BuildXFromTuples
-        let (size, unpack) = self.gather_elements(pushed, elts)?;
+        let n = elts.len().to_u32();
+        let seen_star = elts.iter().any(|e| matches!(e, ast::Expr::Starred(_)));
 
-        if unpack {
-            // Has starred elements
+        // Determine collection size threshold for optimization
+        let big = match collection_type {
+            CollectionType::Set => n > 8,
+            _ => n > 4,
+        };
+
+        // If no stars and not too big, compile all elements and build once
+        if !seen_star && !big {
+            for elt in elts {
+                self.compile_expression(elt)?;
+            }
+            let total_size = n + pushed;
             match collection_type {
+                CollectionType::List => {
+                    emit!(self, Instruction::BuildList { size: total_size });
+                }
+                CollectionType::Set => {
+                    emit!(self, Instruction::BuildSet { size: total_size });
+                }
                 CollectionType::Tuple => {
-                    if size > 1 || pushed > 0 {
-                        emit!(self, Instruction::BuildTupleFromTuples { size });
+                    emit!(self, Instruction::BuildTuple { size: total_size });
+                }
+            }
+            return Ok(());
+        }
+
+        // Has stars or too big: use streaming approach
+        let mut sequence_built = false;
+        let mut i = 0u32;
+
+        for elt in elts.iter() {
+            if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = elt {
+                // When we hit first star, build sequence with elements so far
+                if !sequence_built {
+                    match collection_type {
+                        CollectionType::List => {
+                            emit!(self, Instruction::BuildList { size: i + pushed });
+                        }
+                        CollectionType::Set => {
+                            emit!(self, Instruction::BuildSet { size: i + pushed });
+                        }
+                        CollectionType::Tuple => {
+                            emit!(self, Instruction::BuildList { size: i + pushed });
+                        }
                     }
-                    // If size == 1 and pushed == 0, the single tuple is already on the stack
+                    sequence_built = true;
                 }
-                CollectionType::List => {
-                    emit!(self, Instruction::BuildListFromTuples { size });
+
+                // Compile the starred expression and extend
+                self.compile_expression(value)?;
+                match collection_type {
+                    CollectionType::List => {
+                        emit!(self, Instruction::ListExtend { i: 0 });
+                    }
+                    CollectionType::Set => {
+                        emit!(self, Instruction::SetUpdate { i: 0 });
+                    }
+                    CollectionType::Tuple => {
+                        emit!(self, Instruction::ListExtend { i: 0 });
+                    }
                 }
-                CollectionType::Set => {
-                    emit!(self, Instruction::BuildSetFromTuples { size });
+            } else {
+                // Non-starred element
+                self.compile_expression(elt)?;
+
+                if sequence_built {
+                    // Sequence already exists, append to it
+                    match collection_type {
+                        CollectionType::List => {
+                            emit!(self, Instruction::ListAppend { i: 0 });
+                        }
+                        CollectionType::Set => {
+                            emit!(self, Instruction::SetAdd { i: 0 });
+                        }
+                        CollectionType::Tuple => {
+                            emit!(self, Instruction::ListAppend { i: 0 });
+                        }
+                    }
+                } else {
+                    // Still collecting elements before first star
+                    i += 1;
                 }
             }
-        } else {
-            // No starred elements
+        }
+
+        // If we never built sequence (all non-starred), build it now
+        if !sequence_built {
             match collection_type {
-                CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size });
-                }
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size });
+                    emit!(self, Instruction::BuildList { size: i + pushed });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size });
+                    emit!(self, Instruction::BuildSet { size: i + pushed });
+                }
+                CollectionType::Tuple => {
+                    emit!(self, Instruction::BuildTuple { size: i + pushed });
                 }
             }
+        } else if collection_type == CollectionType::Tuple {
+            // For tuples, convert the list to tuple
+            emit!(
+                self,
+                Instruction::CallIntrinsic1 {
+                    func: IntrinsicFunction1::ListToTuple
+                }
+            );
         }
 
         Ok(())
@@ -4400,27 +4477,35 @@ impl Compiler {
                 // Stack has: [__build_class__, NULL, class_func, name]
                 // Need to build: args tuple = (class_func, name, *bases, .generic_base)
 
-                // Compile bases with gather_elements (handles starred)
-                let (size, unpack) = if let Some(arguments) = arguments {
-                    self.gather_elements(2, &arguments.args)? // 2 = class_func + name already on stack
-                } else {
-                    // Just class_func and name (no bases)
-                    (2, false)
-                };
+                // Build a list starting with class_func and name (2 elements already on stack)
+                emit!(self, Instruction::BuildList { size: 2 });
 
-                // Add .generic_base as final base
+                // Add bases to the list
+                if let Some(arguments) = arguments {
+                    for arg in &arguments.args {
+                        if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = arg {
+                            // Starred: compile and extend
+                            self.compile_expression(value)?;
+                            emit!(self, Instruction::ListExtend { i: 0 });
+                        } else {
+                            // Non-starred: compile and append
+                            self.compile_expression(arg)?;
+                            emit!(self, Instruction::ListAppend { i: 0 });
+                        }
+                    }
+                }
+
+                // Add .generic_base as final element
                 emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(self, Instruction::ListAppend { i: 0 });
 
-                // Build args tuple
-                if unpack {
-                    // Starred: gather_elements produced tuples on stack
-                    emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)
-                    emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });
-                } else {
-                    // No starred: individual elements on stack
-                    // size includes class_func + name + bases count, +1 for .generic_base
-                    emit!(self, Instruction::BuildTuple { size: size + 1 });
-                }
+                // Convert list to tuple
+                emit!(
+                    self,
+                    Instruction::CallIntrinsic1 {
+                        func: IntrinsicFunction1::ListToTuple
+                    }
+                );
 
                 // Build kwargs if needed
                 if arguments.is_some_and(|args| !args.keywords.is_empty()) {
@@ -4496,7 +4581,7 @@ impl Compiler {
             self.emit_load_const(ConstantData::Str { value: name.into() });
 
             if let Some(arguments) = arguments {
-                self.compile_call_helper(2, arguments)?;
+                self.codegen_call_helper(2, arguments)?;
             } else {
                 emit!(self, Instruction::Call { nargs: 2 });
             }
@@ -6895,7 +6980,10 @@ impl Compiler {
             }
         }
         if size > 1 {
-            emit!(self, Instruction::BuildMapForCall { size });
+            // Merge all dicts: first dict is accumulator, merge rest into it
+            for _ in 1..size {
+                emit!(self, Instruction::DictMerge { index: 1 });
+            }
         }
         Ok(())
     }
@@ -6918,143 +7006,198 @@ impl Compiler {
                         emit!(self, PseudoInstruction::LoadZeroSuperMethod { idx });
                     }
                 }
-                self.compile_call_helper(0, args)?;
+                self.codegen_call_helper(0, args)?;
             } else {
                 // Normal method call: compile object, then LOAD_ATTR_METHOD
                 // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
                 self.compile_expression(value)?;
                 let idx = self.name(attr.as_str());
                 emit!(self, PseudoInstruction::LoadAttrMethod { idx });
-                self.compile_call_helper(0, args)?;
+                self.codegen_call_helper(0, args)?;
             }
         } else {
             // Regular call: push func, then NULL for self_or_null slot
             // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
             self.compile_expression(func)?;
             emit!(self, Instruction::PushNull);
-            self.compile_call_helper(0, args)?;
+            self.codegen_call_helper(0, args)?;
         }
         Ok(())
     }
 
+    /// Compile subkwargs: emit key-value pairs for BUILD_MAP
+    fn codegen_subkwargs(
+        &mut self,
+        keywords: &[ast::Keyword],
+        begin: usize,
+        end: usize,
+    ) -> CompileResult<()> {
+        let n = end - begin;
+        assert!(n > 0);
+
+        // For large kwargs, use BUILD_MAP(0) + MAP_ADD to avoid stack overflow
+        let big = n * 2 > 8; // STACK_USE_GUIDELINE approximation
+
+        if big {
+            emit!(self, Instruction::BuildMap { size: 0 });
+        }
+
+        for kw in &keywords[begin..end] {
+            // Key first, then value - this is critical!
+            self.emit_load_const(ConstantData::Str {
+                value: kw.arg.as_ref().unwrap().as_str().into(),
+            });
+            self.compile_expression(&kw.value)?;
+
+            if big {
+                emit!(self, Instruction::MapAdd { i: 0 });
+            }
+        }
+
+        if !big {
+            emit!(self, Instruction::BuildMap { size: n.to_u32() });
+        }
+
+        Ok(())
+    }
+
     /// Compile call arguments and emit the appropriate CALL instruction.
-    /// This is shared between compiler_call and compiler_class.
-    fn compile_call_helper(
+    fn codegen_call_helper(
         &mut self,
         additional_positional: u32,
         arguments: &ast::Arguments,
     ) -> CompileResult<()> {
-        let args_count = u32::try_from(arguments.len()).expect("too many arguments");
-        let count = args_count
-            .checked_add(additional_positional)
-            .expect("too many arguments");
+        let nelts = arguments.args.len();
+        let nkwelts = arguments.keywords.len();
 
-        // Normal arguments:
-        let (size, unpack) = self.gather_elements(additional_positional, &arguments.args)?;
+        // Check if we have starred args or **kwargs
+        let has_starred = arguments
+            .args
+            .iter()
+            .any(|arg| matches!(arg, ast::Expr::Starred(_)));
         let has_double_star = arguments.keywords.iter().any(|k| k.arg.is_none());
 
-        if unpack || has_double_star {
-            // Create a tuple with positional args:
-            if unpack {
-                emit!(self, Instruction::BuildTupleFromTuples { size });
-            } else {
-                emit!(self, Instruction::BuildTuple { size });
+        // Check if exceeds stack guideline
+        let too_big = nelts + nkwelts * 2 > 8;
+
+        if !has_starred && !has_double_star && !too_big {
+            // Simple call path: no * or ** args
+            for arg in &arguments.args {
+                self.compile_expression(arg)?;
             }
 
-            // Create an optional map with kw-args:
-            if !arguments.keywords.is_empty() {
-                self.compile_keywords(&arguments.keywords)?;
+            if nkwelts > 0 {
+                // Compile keyword values and build kwnames tuple
+                let mut kwarg_names = Vec::with_capacity(nkwelts);
+                for keyword in &arguments.keywords {
+                    kwarg_names.push(ConstantData::Str {
+                        value: keyword.arg.as_ref().unwrap().as_str().into(),
+                    });
+                    self.compile_expression(&keyword.value)?;
+                }
+
+                self.emit_load_const(ConstantData::Tuple {
+                    elements: kwarg_names,
+                });
+
+                let nargs = additional_positional + nelts.to_u32() + nkwelts.to_u32();
+                emit!(self, Instruction::CallKw { nargs });
             } else {
-                emit!(self, Instruction::PushNull);
+                let nargs = additional_positional + nelts.to_u32();
+                emit!(self, Instruction::Call { nargs });
             }
-            emit!(self, Instruction::CallFunctionEx);
-        } else if !arguments.keywords.is_empty() {
-            // No **kwargs in this branch (has_double_star is false),
-            // so all keywords have arg.is_some()
-            let mut kwarg_names = Vec::with_capacity(arguments.keywords.len());
-            for keyword in &arguments.keywords {
-                let name = keyword
-                    .arg
-                    .as_ref()
-                    .expect("has_double_star is false, so arg must be Some");
-                kwarg_names.push(ConstantData::Str {
-                    value: name.as_str().into(),
-                });
-                self.compile_expression(&keyword.value)?;
+        } else {
+            // ex_call path: has * or ** args
+
+            // Compile positional arguments
+            if additional_positional == 0
+                && nelts == 1
+                && matches!(arguments.args[0], ast::Expr::Starred(_))
+            {
+                // Special case: single starred arg
+                // Even in this case, we need to ensure it's a tuple for CallFunctionEx
+                if let ast::Expr::Starred(ast::ExprStarred { value, .. }) = &arguments.args[0] {
+                    // Check if the value is already a tuple expression
+                    if matches!(value.as_ref(), ast::Expr::Tuple(_)) {
+                        // Tuple literals can be used directly
+                        self.compile_expression(value)?;
+                    } else {
+                        // For all other cases (including variables that might be lists),
+                        // build a list and convert to tuple to ensure correct type
+                        emit!(self, Instruction::BuildList { size: 0 });
+                        self.compile_expression(value)?;
+                        emit!(self, Instruction::ListExtend { i: 0 });
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic1 {
+                                func: IntrinsicFunction1::ListToTuple
+                            }
+                        );
+                    }
+                }
+            } else {
+                // Use starunpack_helper to build a list, then convert to tuple
+                self.starunpack_helper(
+                    &arguments.args,
+                    additional_positional,
+                    CollectionType::List,
+                )?;
+                emit!(
+                    self,
+                    Instruction::CallIntrinsic1 {
+                        func: IntrinsicFunction1::ListToTuple
+                    }
+                );
             }
 
-            self.emit_load_const(ConstantData::Tuple {
-                elements: kwarg_names,
-            });
-            // nargs = positional args + keyword args
-            let positional = additional_positional
-                .checked_add(u32::try_from(arguments.args.len()).expect("too many positional args"))
-                .expect("too many positional args");
-            let keyword_count =
-                u32::try_from(arguments.keywords.len()).expect("too many keyword args");
-            let nargs = positional
-                .checked_add(keyword_count)
-                .expect("too many arguments");
-            emit!(self, Instruction::CallKw { nargs });
-        } else {
-            emit!(self, Instruction::Call { nargs: count });
-        }
+            // Compile keyword arguments
+            if nkwelts > 0 {
+                let mut have_dict = false;
+                let mut nseen = 0usize;
 
-        Ok(())
-    }
+                for (i, keyword) in arguments.keywords.iter().enumerate() {
+                    if keyword.arg.is_none() {
+                        // **kwargs unpacking
+                        if nseen > 0 {
+                            // Pack up preceding keywords using codegen_subkwargs
+                            self.codegen_subkwargs(&arguments.keywords, i - nseen, i)?;
+                            if have_dict {
+                                emit!(self, Instruction::DictMerge { index: 1 });
+                            }
+                            have_dict = true;
+                            nseen = 0;
+                        }
 
-    // Given a vector of expr / star expr generate code which gives either
-    // a list of expressions on the stack, or a list of tuples.
-    fn gather_elements(
-        &mut self,
-        before: u32,
-        elements: &[ast::Expr],
-    ) -> CompileResult<(u32, bool)> {
-        // First determine if we have starred elements:
-        let has_stars = elements.iter().any(|e| matches!(e, ast::Expr::Starred(_)));
-
-        let size = if has_stars {
-            let mut size = 0;
-            let mut iter = elements.iter().peekable();
-            let mut run_size = before;
-
-            loop {
-                if iter
-                    .peek()
-                    .is_none_or(|e| matches!(e, ast::Expr::Starred(_)))
-                {
-                    emit!(self, Instruction::BuildTuple { size: run_size });
-                    run_size = 0;
-                    size += 1;
-                }
+                        if !have_dict {
+                            emit!(self, Instruction::BuildMap { size: 0 });
+                            have_dict = true;
+                        }
 
-                match iter.next() {
-                    Some(ast::Expr::Starred(ast::ExprStarred { value, .. })) => {
-                        self.compile_expression(value)?;
-                        // We need to collect each unpacked element into a
-                        // tuple, since any side-effects during the conversion
-                        // should be made visible before evaluating remaining
-                        // expressions.
-                        emit!(self, Instruction::BuildTupleFromIter);
-                        size += 1;
+                        self.compile_expression(&keyword.value)?;
+                        emit!(self, Instruction::DictMerge { index: 1 });
+                    } else {
+                        nseen += 1;
                     }
-                    Some(element) => {
-                        self.compile_expression(element)?;
-                        run_size += 1;
+                }
+
+                // Pack up any trailing keyword arguments
+                if nseen > 0 {
+                    self.codegen_subkwargs(&arguments.keywords, nkwelts - nseen, nkwelts)?;
+                    if have_dict {
+                        emit!(self, Instruction::DictMerge { index: 1 });
                     }
-                    None => break,
+                    have_dict = true;
                 }
-            }
 
-            size
-        } else {
-            for element in elements {
-                self.compile_expression(element)?;
+                assert!(have_dict);
+            } else {
+                emit!(self, Instruction::PushNull);
             }
-            before + elements.len().to_u32()
-        };
 
-        Ok((size, has_stars))
+            emit!(self, Instruction::CallFunctionEx);
+        }
+
+        Ok(())
     }
 
     fn compile_comprehension_element(&mut self, element: &ast::Expr) -> CompileResult<()> {
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 37a015ce76d..996efe4918e 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -682,18 +682,18 @@ impl InstructionMetadata for Instruction {
             Self::LoadLocals => 0,
             Self::ReturnGenerator => 0,
             Self::StoreSlice => 0,
-            Self::DictMerge { .. } => 0,
+            Self::DictMerge { .. } => -1,
             Self::BuildConstKeyMap { .. } => 0,
             Self::CopyFreeVars { .. } => 0,
             Self::EnterExecutor => 0,
             Self::JumpBackwardNoInterrupt { .. } => 0,
             Self::JumpBackward { .. } => 0,
             Self::JumpForward { .. } => 0,
-            Self::ListExtend { .. } => 0,
+            Self::ListExtend { .. } => -1,
             Self::LoadFastCheck(_) => 0,
             Self::LoadFastLoadFast { .. } => 0,
             Self::LoadFromDictOrGlobals(_) => 0,
-            Self::SetUpdate { .. } => 0,
+            Self::SetUpdate { .. } => -1,
             Self::MakeCell(_) => 0,
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index a6ef4c5363b..6311646c5fc 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -672,7 +672,8 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::BuildList { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let sz = size.get(arg) as usize;
+                let elements = self.pop_multiple(sz).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
@@ -947,6 +948,48 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
+            Instruction::DictMerge { index } => {
+                let source = self.pop_value();
+                let idx = index.get(arg);
+
+                // Get the dict to merge into (same logic as DICT_UPDATE)
+                let dict_ref = if idx <= 1 {
+                    self.top_value()
+                } else {
+                    self.nth_value(idx - 1)
+                };
+
+                let dict: &Py<PyDict> = unsafe { dict_ref.downcast_unchecked_ref() };
+
+                // Check if source is a mapping
+                if vm
+                    .get_method(source.clone(), vm.ctx.intern_str("keys"))
+                    .is_none()
+                {
+                    return Err(vm.new_type_error(format!(
+                        "'{}' object is not a mapping",
+                        source.class().name()
+                    )));
+                }
+
+                // Check for duplicate keys
+                let keys_iter = vm.call_method(&source, "keys", ())?;
+                for key in keys_iter.try_to_value::<Vec<PyObjectRef>>(vm)? {
+                    if key.downcast_ref::<PyStr>().is_none() {
+                        return Err(vm.new_type_error("keywords must be strings".to_owned()));
+                    }
+                    if dict.contains_key(&*key, vm) {
+                        let key_repr = key.repr(vm)?;
+                        return Err(vm.new_type_error(format!(
+                            "got multiple values for keyword argument {}",
+                            key_repr.as_str()
+                        )));
+                    }
+                    let value = vm.call_method(&source, "__getitem__", (key.clone(),))?;
+                    dict.set_item(&*key, value, vm)?;
+                }
+                Ok(None)
+            }
             Instruction::EndAsyncFor => {
                 // END_ASYNC_FOR pops (awaitable, exc) from stack
                 // Stack: [awaitable, exc] -> []
@@ -1184,6 +1227,16 @@ impl ExecutingFrame<'_> {
                 list.append(item);
                 Ok(None)
             }
+            Instruction::ListExtend { i } => {
+                let iterable = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let list: &Py<PyList> = unsafe {
+                    // SAFETY: compiler guarantees correct type
+                    obj.downcast_unchecked_ref()
+                };
+                list.extend(iterable, vm)?;
+                Ok(None)
+            }
             Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
             Instruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
             Instruction::LoadBuildClass => {
@@ -1234,10 +1287,10 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::LoadDeref(i) => {
-                let i = i.get(arg) as usize;
-                let x = self.cells_frees[i]
+                let idx = i.get(arg) as usize;
+                let x = self.cells_frees[idx]
                     .get()
-                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
+                    .ok_or_else(|| self.unbound_cell_exception(idx, vm))?;
                 self.push_value(x);
                 Ok(None)
             }
@@ -1570,6 +1623,19 @@ impl ExecutingFrame<'_> {
                 set.add(item, vm)?;
                 Ok(None)
             }
+            Instruction::SetUpdate { i } => {
+                let iterable = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let set: &Py<PySet> = unsafe {
+                    // SAFETY: compiler guarantees correct type
+                    obj.downcast_unchecked_ref()
+                };
+                let iter = PyIter::try_from_object(vm, iterable)?;
+                while let PyIterReturn::Return(item) = iter.next(vm)? {
+                    set.add(item, vm)?;
+                }
+                Ok(None)
+            }
             Instruction::SetExcInfo => {
                 // Set the current exception to TOS (for except* handlers)
                 // This updates sys.exc_info() so bare 'raise' will reraise the matched exception

From b7f55decbdf607225c5ea134e5e268ec5c4de6c5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Jan 2026 01:06:56 +0900
Subject: [PATCH 382/418] Bump cranelift-jit from 0.127.1 to 0.127.2 (#6800)

Bumps [cranelift-jit](https://github.com/bytecodealliance/wasmtime) from 0.127.1 to 0.127.2.
- [Release notes](https://github.com/bytecodealliance/wasmtime/releases)
- [Changelog](https://github.com/bytecodealliance/wasmtime/blob/main/RELEASES.md)
- [Commits](https://github.com/bytecodealliance/wasmtime/commits)

---
updated-dependencies:
- dependency-name: cranelift-jit
  dependency-version: 0.127.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 64 +++++++++++++++++++++++++++---------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8df208e4aaa..331845ee993 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -711,42 +711,42 @@ dependencies = [
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff9edf1a79ff137b5c9bc74aff5d8467a8bea67722d9f4a2a0dc555504e8dc66"
+checksum = "d958a04d546618ce1e5aa4396cc13acd00fcb233f35c91a387f0842f0cc815dd"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ed408aad286cb6433f3e361268b588566ac138dc0d8cf1c22af822c004250ad"
+checksum = "1df96ea1694da9c09e54b9838837a287e55312666ed0bdd84ba6883f099d35d3"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efddb47bd7fc6fb0fe9387a82c4cf1987b7402fefa694f73be1f3ae2b26663ab"
+checksum = "cb23a65a258700dc1893646806cbec19638a7601e42fba7f2590ed15e069cc34"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2922de888b20fedaff065be5a4044f5c3c13cb1132db8f1f56f7a5c03a768c81"
+checksum = "42b1ed69fc07ec013f50e8dc9ff019a2cc0bcfcb913bfc57783c0b446ef814d2"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d3172ca7ba0bf31cae6dd4dffbfc33e0afe5994eb3ec29608d0ab14bcb674cb"
+checksum = "be0b3ba4d6a80dfcd1988b1bc225a65a4323890a5e1e65653691d489f51fcd16"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -770,9 +770,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2bad8d14320124ea673cb11b7db0176470279b7ec1d0f201f79a7c0213f52f6"
+checksum = "d2957b02290035506bba6bfc4c725ac732fa5a3a2b7186d45c62a5ae230521a4"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
@@ -782,24 +782,24 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c414fe1c62e61d269a928594bd0f10fb6fa707e112b433fc19cc8d5aeaf08fda"
+checksum = "79bfcbc8b59cc4f54771a093baf2fce0fce0d17081f80f5ceeb1e886a215f4da"
 
 [[package]]
 name = "cranelift-control"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fac90ac0e9a0dd900a880ee6b56f36e37ca5017af9f7d1390805dcb6f35e4064"
+checksum = "84b59bcd91bf292dfe8bafb3be8f5bc1eab95e409903b85ce706d665ee415a5e"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c63209c9b060b3048b2cc6483bdba85e93118268d14b3ce1452615e7cb42010"
+checksum = "98532e7e8eea8ae2c9ba8bad5a6f11fa08ea910e97573a34349d68549d913ffc"
 dependencies = [
  "cranelift-bitset",
 ]
@@ -818,15 +818,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "316dd3048717d1ad577d23fb2773671bc4fe633b651bb0d41be79d1a2dd0121b"
+checksum = "f94115221ff3bdeb280b08816886a1a2df71233ac00151ab17c79df1bef712d3"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0c1c762faecc6e30a4ebb8f36ad980a5211afc2e037daf0095983c287f8d0f9"
+checksum = "045e4d491dbe5ef0671ac419c6d5a9fa46433f2198b97f88b17e6d555b43f882"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -844,9 +844,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-module"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d29cd90f94cdc63c56eb7f81813072a654bb9723d9aceb382fad752f9a8e7f8"
+checksum = "e9cf45d101177c3275ae3b12361572bf6bc24c271f82db2610bae8495990311c"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -855,9 +855,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5dc065eb9d570d70360d9eceb5be0faf1e5871aa53973389a4a9d37bf2c748b5"
+checksum = "31b0d0dfd15331fdc5cdd1c4196eb3a291ca842098f7ad733fafa689f6da478f"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -866,9 +866,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a628782eefce8d87340a08f635d19e55e2900a77706f56b75cf73f1efc880a3"
+checksum = "9d74f0410de8bc760d0c4d6892a7da693b5ffc61d6ed02411fe39e3a20aca388"
 
 [[package]]
 name = "crc32fast"
@@ -4329,9 +4329,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-jit-icache-coherence"
-version = "40.0.1"
+version = "40.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b4462e93068c8d73847a9d69c371b9dd8106cf020a736d43cdca519a20703b3"
+checksum = "b5b8980271f6e70f14e48bb6e73aa99b8921fbe8042901e0fb67632fcdde50fc"
 dependencies = [
  "anyhow",
  "cfg-if",
@@ -4341,9 +4341,9 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-internal-math"
-version = "40.0.1"
+version = "40.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50a77e2f3f9009c5af4abb0c2875f64ab5f7c04875b3bcb8a8a120e22cdffe70"
+checksum = "1c598554e38cc33d96ec2411fe11e82fa624c72049b151f0f34363e9eece4864"
 dependencies = [
  "libm",
 ]

From aff85c87ce212884c6ba75b0df9e956ae04457ff Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Jan 2026 01:42:55 +0900
Subject: [PATCH 383/418] Bump junction from 1.3.0 to 1.4.1 (#6801)

Bumps [junction](https://github.com/tesuji/junction) from 1.3.0 to 1.4.1.
- [Release notes](https://github.com/tesuji/junction/releases)
- [Changelog](https://github.com/tesuji/junction/blob/main/CHANGELOG.md)
- [Commits](https://github.com/tesuji/junction/compare/v1.3.0...v1.4.1)

---
updated-dependencies:
- dependency-name: junction
  dependency-version: 1.4.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 6 +++---
 Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 331845ee993..61fed72e35d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1622,12 +1622,12 @@ dependencies = [
 
 [[package]]
 name = "junction"
-version = "1.3.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c52f6e1bf39a7894f618c9d378904a11dbd7e10fe3ec20d1173600e79b1408d8"
+checksum = "642883fdc81cf2da15ee8183fa1d2c7da452414dd41541a0f3e1428069345447"
 dependencies = [
  "scopeguard",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 6c29f67e03b..1ef2dcfb77d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -168,7 +168,7 @@ indexmap = { version = "2.13.0", features = ["std"] }
 insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
-junction = "1.3.0"
+junction = "1.4.1"
 libc = "0.2.180"
 libffi = "5"
 log = "0.4.29"

From e5720232e14892c9920f017273784b330b0a0273 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Jan 2026 01:43:11 +0900
Subject: [PATCH 384/418] Bump chrono from 0.4.42 to 0.4.43 (#6803)

Bumps [chrono](https://github.com/chronotope/chrono) from 0.4.42 to 0.4.43.
- [Release notes](https://github.com/chronotope/chrono/releases)
- [Changelog](https://github.com/chronotope/chrono/blob/main/CHANGELOG.md)
- [Commits](https://github.com/chronotope/chrono/compare/v0.4.42...v0.4.43)

---
updated-dependencies:
- dependency-name: chrono
  dependency-version: 0.4.43
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 61fed72e35d..d41ca4304ab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -491,9 +491,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.42"
+version = "0.4.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
+checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
 dependencies = [
  "iana-time-zone",
  "js-sys",
diff --git a/Cargo.toml b/Cargo.toml
index 1ef2dcfb77d..7471a3becc4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -156,7 +156,7 @@ ascii = "1.1"
 bitflags = "2.9.4"
 bstr = "1"
 cfg-if = "1.0"
-chrono = { version = "0.4.42", default-features = false, features = ["clock", "oldtime", "std"] }
+chrono = { version = "0.4.43", default-features = false, features = ["clock", "oldtime", "std"] }
 constant_time_eq = "0.4"
 criterion = { version = "0.8", features = ["html_reports"] }
 crossbeam-utils = "0.8.21"

From 2da102fab8a8a247f2f67b5e4ebe35fdfd5efbd7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 02:10:19 +0900
Subject: [PATCH 385/418] FromArgs with error_msg (#6804)

---
 crates/derive-impl/src/from_args.rs     | 19 +++++++++++--
 crates/vm/src/builtins/function.rs      |  8 +++---
 crates/vm/src/builtins/interpolation.rs | 36 +++++++++++--------------
 crates/vm/src/builtins/super.rs         |  9 +++----
 4 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/crates/derive-impl/src/from_args.rs b/crates/derive-impl/src/from_args.rs
index 667f887e81c..9f2d0460fb0 100644
--- a/crates/derive-impl/src/from_args.rs
+++ b/crates/derive-impl/src/from_args.rs
@@ -37,6 +37,7 @@ struct ArgAttribute {
     name: Option<String>,
     kind: ParameterKind,
     default: Option<DefaultValue>,
+    error_msg: Option<String>,
 }
 
 impl ArgAttribute {
@@ -63,6 +64,7 @@ impl ArgAttribute {
                         name: None,
                         kind,
                         default: None,
+                        error_msg: None,
                     });
                     return Ok(());
                 };
@@ -94,6 +96,12 @@ impl ArgAttribute {
             }
             let val = meta.value()?.parse::<syn::LitStr>()?;
             self.name = Some(val.value())
+        } else if meta.path.is_ident("error_msg") {
+            if self.error_msg.is_some() {
+                return Err(meta.error("already have an error_msg"));
+            }
+            let val = meta.value()?.parse::<syn::LitStr>()?;
+            self.error_msg = Some(val.value())
         } else {
             return Err(meta.error("Unrecognized pyarg attribute"));
         }
@@ -146,8 +154,15 @@ fn generate_field((i, field): (usize, &Field)) -> Result<TokenStream> {
         .or(name_string)
         .ok_or_else(|| err_span!(field, "field in tuple struct must have name attribute"))?;
 
-    let middle = quote! {
-        .map(|x| ::rustpython_vm::convert::TryFromObject::try_from_object(vm, x)).transpose()?
+    let middle = if let Some(error_msg) = &attr.error_msg {
+        quote! {
+            .map(|x| ::rustpython_vm::convert::TryFromObject::try_from_object(vm, x)
+                .map_err(|_| vm.new_type_error(#error_msg))).transpose()?
+        }
+    } else {
+        quote! {
+            .map(|x| ::rustpython_vm::convert::TryFromObject::try_from_object(vm, x)).transpose()?
+        }
     };
 
     let ending = if let Some(default) = attr.default {
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
index 632fd867d2e..7eb74dec41e 100644
--- a/crates/vm/src/builtins/function.rs
+++ b/crates/vm/src/builtins/function.rs
@@ -855,13 +855,13 @@ pub struct PyFunctionNewArgs {
     code: PyRef<PyCode>,
     #[pyarg(positional)]
     globals: PyDictRef,
-    #[pyarg(any, optional)]
+    #[pyarg(any, optional, error_msg = "arg 3 (name) must be None or string")]
     name: OptionalArg<PyStrRef>,
-    #[pyarg(any, optional)]
+    #[pyarg(any, optional, error_msg = "arg 4 (defaults) must be None or tuple")]
     argdefs: Option<PyTupleRef>,
-    #[pyarg(any, optional)]
+    #[pyarg(any, optional, error_msg = "arg 5 (closure) must be None or tuple")]
     closure: Option<PyTupleRef>,
-    #[pyarg(any, optional)]
+    #[pyarg(any, optional, error_msg = "arg 6 (kwdefaults) must be None or dict")]
     kwdefaults: Option<PyDictRef>,
 }
 
diff --git a/crates/vm/src/builtins/interpolation.rs b/crates/vm/src/builtins/interpolation.rs
index 1d29ad7b49e..d8127c151e3 100644
--- a/crates/vm/src/builtins/interpolation.rs
+++ b/crates/vm/src/builtins/interpolation.rs
@@ -59,26 +59,16 @@ impl Constructor for PyInterpolation {
     type Args = InterpolationArgs;
 
     fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
-        let conversion = match args.conversion {
-            OptionalArg::Present(c) => {
-                if vm.is_none(&c) {
-                    vm.ctx.none()
-                } else {
-                    let s = c.downcast::<PyStr>().map_err(|_| {
-                        vm.new_type_error(
-                            "Interpolation() argument 'conversion' must be str or None",
-                        )
-                    })?;
-                    let s_str = s.as_str();
-                    if s_str.len() != 1 || !matches!(s_str.chars().next(), Some('s' | 'r' | 'a')) {
-                        return Err(vm.new_value_error(
-                            "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'",
-                        ));
-                    }
-                    s.into()
-                }
+        let conversion: PyObjectRef = if let Some(s) = args.conversion {
+            let s_str = s.as_str();
+            if s_str.len() != 1 || !matches!(s_str.chars().next(), Some('s' | 'r' | 'a')) {
+                return Err(vm.new_value_error(
+                    "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'",
+                ));
             }
-            OptionalArg::Missing => vm.ctx.none(),
+            s.into()
+        } else {
+            vm.ctx.none()
         };
 
         let expression = args
@@ -103,8 +93,12 @@ pub struct InterpolationArgs {
     value: PyObjectRef,
     #[pyarg(any, optional)]
     expression: OptionalArg<PyStrRef>,
-    #[pyarg(any, optional)]
-    conversion: OptionalArg<PyObjectRef>,
+    #[pyarg(
+        any,
+        optional,
+        error_msg = "Interpolation() argument 'conversion' must be str or None"
+    )]
+    conversion: Option<PyStrRef>,
     #[pyarg(any, optional)]
     format_spec: OptionalArg<PyStrRef>,
 }
diff --git a/crates/vm/src/builtins/super.rs b/crates/vm/src/builtins/super.rs
index 893509bc6d3..b7bc3004332 100644
--- a/crates/vm/src/builtins/super.rs
+++ b/crates/vm/src/builtins/super.rs
@@ -60,8 +60,8 @@ impl Constructor for PySuper {
 
 #[derive(FromArgs)]
 pub struct InitArgs {
-    #[pyarg(positional, optional)]
-    py_type: OptionalArg<PyObjectRef>,
+    #[pyarg(positional, optional, error_msg = "super() argument 1 must be a type")]
+    py_type: OptionalArg<PyTypeRef>,
     #[pyarg(positional, optional)]
     py_obj: OptionalArg<PyObjectRef>,
 }
@@ -75,10 +75,7 @@ impl Initializer for PySuper {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         // Get the type:
-        let (typ, obj) = if let OptionalArg::Present(ty_obj) = py_type {
-            let ty = ty_obj
-                .downcast::<PyType>()
-                .map_err(|_| vm.new_type_error("super() argument 1 must be a type"))?;
+        let (typ, obj) = if let OptionalArg::Present(ty) = py_type {
             (ty, py_obj.unwrap_or_none(vm))
         } else {
             let frame = vm

From 7d2f284ee619e41866ef231b9daf50d5ea552ed3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Jan 2026 02:16:24 +0900
Subject: [PATCH 386/418] Bump cranelift from 0.127.1 to 0.127.2 (#6802)

Bumps [cranelift](https://github.com/bytecodealliance/wasmtime) from 0.127.1 to 0.127.2.
- [Release notes](https://github.com/bytecodealliance/wasmtime/releases)
- [Changelog](https://github.com/bytecodealliance/wasmtime/blob/main/RELEASES.md)
- [Commits](https://github.com/bytecodealliance/wasmtime/commits)

---
updated-dependencies:
- dependency-name: cranelift
  dependency-version: 0.127.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d41ca4304ab..2c3b35d1a56 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -700,9 +700,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9849e5e1589a1d7b9e8a27cbf55747bd5d262ed72ac06c97d824adfc97a93652"
+checksum = "1068d00586fbabd405dd9c96f3b09256cfebb09b4b65f91ba16990cf9fbb57bc"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -806,9 +806,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.127.1"
+version = "0.127.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e42ad0eeaa7f2c365a06ec50580ff6820f1ef45de1c784e8080f5b24bbe3a634"
+checksum = "1f048c86453f52282e752e1b93ab62b26d5c020d4051cf39d4de0dd8b577689e"
 dependencies = [
  "cranelift-codegen",
  "log",

From b76906a8bf24dc9ca60b3afa96970f3d639c921b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 03:38:40 +0900
Subject: [PATCH 387/418] Add sys._stdlib_dir (#6798)

---
 .../test_importlib/resources/test_files.py    |  5 ++--
 Lib/test/test_sys.py                          |  1 -
 crates/pylib/build.rs                         | 28 +++++++++++++------
 crates/vm/src/getpath.rs                      | 19 +++++++++++++
 crates/vm/src/stdlib/sys.rs                   |  4 +++
 crates/vm/src/vm/setting.rs                   |  2 ++
 src/interpreter.rs                            | 20 ++++++-------
 7 files changed, 57 insertions(+), 22 deletions(-)

diff --git a/Lib/test/test_importlib/resources/test_files.py b/Lib/test/test_importlib/resources/test_files.py
index 1d04cda1a8f..0e9c5c79a1a 100644
--- a/Lib/test/test_importlib/resources/test_files.py
+++ b/Lib/test/test_importlib/resources/test_files.py
@@ -52,7 +52,7 @@ class OpenDiskTests(FilesTests, unittest.TestCase):
     def setUp(self):
         self.data = data01
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON, line ending issue")
     def test_read_bytes(self):
         super().test_read_bytes()
 
@@ -67,10 +67,11 @@ def setUp(self):
 
         self.data = namespacedata01
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON, line ending issue")
     def test_read_bytes(self):
         super().test_read_bytes()
 
+
 class SiteDir:
     def setUp(self):
         self.fixtures = contextlib.ExitStack()
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 77300fbe0bb..47039aa5114 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -1310,7 +1310,6 @@ def test_module_names(self):
         for name in sys.stdlib_module_names:
             self.assertIsInstance(name, str)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_stdlib_dir'
     def test_stdlib_dir(self):
         os = import_helper.import_fresh_module('os')
         marker = getattr(os, '__file__', None)
diff --git a/crates/pylib/build.rs b/crates/pylib/build.rs
index 9b135690f82..f96ef9b477c 100644
--- a/crates/pylib/build.rs
+++ b/crates/pylib/build.rs
@@ -11,15 +11,25 @@ fn main() {
         process_python_libs("./Lib/**/*");
     }
 
-    if cfg!(windows)
-        && let Ok(real_path) = std::fs::read_to_string("Lib")
-    {
-        let canonicalized_path = std::fs::canonicalize(real_path)
-            .expect("failed to resolve RUSTPYTHONPATH during build time");
-        // Strip the extended path prefix (\\?\) that canonicalize adds on Windows
-        let path_str = canonicalized_path.to_str().unwrap();
-        let path_str = path_str.strip_prefix(r"\\?\").unwrap_or(path_str);
-        println!("cargo:rustc-env=win_lib_path={path_str}");
+    if cfg!(windows) {
+        // On Windows, the Lib entry can be either:
+        // 1. A text file containing the relative path (git without symlink support)
+        // 2. A proper symlink (git with symlink support)
+        // We handle both cases to resolve to the actual Lib directory.
+        let lib_path = if let Ok(real_path) = std::fs::read_to_string("Lib") {
+            // Case 1: Text file containing relative path
+            std::path::PathBuf::from(real_path.trim())
+        } else {
+            // Case 2: Symlink or directory - canonicalize directly
+            std::path::PathBuf::from("Lib")
+        };
+
+        if let Ok(canonicalized_path) = std::fs::canonicalize(&lib_path) {
+            // Strip the extended path prefix (\\?\) that canonicalize adds on Windows
+            let path_str = canonicalized_path.to_str().unwrap();
+            let path_str = path_str.strip_prefix(r"\\?\").unwrap_or(path_str);
+            println!("cargo:rustc-env=win_lib_path={path_str}");
+        }
     }
 }
 
diff --git a/crates/vm/src/getpath.rs b/crates/vm/src/getpath.rs
index 011d5336873..31fa0617b45 100644
--- a/crates/vm/src/getpath.rs
+++ b/crates/vm/src/getpath.rs
@@ -174,6 +174,9 @@ pub fn init_path_config(settings: &Settings) -> Paths {
     paths.module_search_paths =
         build_module_search_paths(settings, &paths.prefix, &paths.exec_prefix);
 
+    // Step 9: Calculate stdlib_dir
+    paths.stdlib_dir = calculate_stdlib_dir(&paths.prefix);
+
     paths
 }
 
@@ -301,6 +304,22 @@ fn calculate_base_executable(executable: Option<&PathBuf>, home_dir: &Option<Pat
         .unwrap_or_default()
 }
 
+/// Calculate stdlib_dir (sys._stdlib_dir)
+/// Returns None if the stdlib directory doesn't exist
+fn calculate_stdlib_dir(prefix: &str) -> Option<String> {
+    #[cfg(not(windows))]
+    let stdlib_dir = PathBuf::from(prefix).join(platform::stdlib_subdir());
+
+    #[cfg(windows)]
+    let stdlib_dir = PathBuf::from(prefix).join(platform::STDLIB_SUBDIR);
+
+    if stdlib_dir.is_dir() {
+        Some(stdlib_dir.to_string_lossy().into_owned())
+    } else {
+        None
+    }
+}
+
 /// Build the complete module_search_paths (sys.path)
 fn build_module_search_paths(settings: &Settings, prefix: &str, exec_prefix: &str) -> Vec<String> {
     let mut paths = Vec::new();
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index 6c8a4e4062d..665b0f1f495 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -148,6 +148,10 @@ mod sys {
     fn platlibdir(_vm: &VirtualMachine) -> &'static str {
         option_env!("RUSTPYTHON_PLATLIBDIR").unwrap_or("lib")
     }
+    #[pyattr]
+    fn _stdlib_dir(vm: &VirtualMachine) -> PyObjectRef {
+        vm.state.config.paths.stdlib_dir.clone().to_pyobject(vm)
+    }
 
     // alphabetical order with segments of pyattr and others
 
diff --git a/crates/vm/src/vm/setting.rs b/crates/vm/src/vm/setting.rs
index 06cc35e933f..1a5ef9efa8f 100644
--- a/crates/vm/src/vm/setting.rs
+++ b/crates/vm/src/vm/setting.rs
@@ -16,6 +16,8 @@ pub struct Paths {
     pub exec_prefix: String,
     /// sys.base_exec_prefix
     pub base_exec_prefix: String,
+    /// sys._stdlib_dir
+    pub stdlib_dir: Option<String>,
     /// Computed module_search_paths (complete sys.path)
     pub module_search_paths: Vec<String>,
 }
diff --git a/src/interpreter.rs b/src/interpreter.rs
index 51667e724f1..08d23e78afe 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -113,18 +113,13 @@ pub fn init_stdlib(vm: &mut VirtualMachine) {
 /// Setup frozen standard library (compiled into the binary)
 #[cfg(all(feature = "stdlib", feature = "freeze-stdlib"))]
 fn setup_frozen_stdlib(vm: &mut VirtualMachine) {
+    use rustpython_vm::common::rc::PyRc;
+
     vm.add_frozen(rustpython_pylib::FROZEN_STDLIB);
 
-    // FIXME: Remove this hack once sys._stdlib_dir is properly implemented
-    // or _frozen_importlib doesn't depend on it anymore.
-    assert!(vm.sys_module.get_attr("_stdlib_dir", vm).is_err());
-    vm.sys_module
-        .set_attr(
-            "_stdlib_dir",
-            vm.new_pyobj(rustpython_pylib::LIB_PATH.to_owned()),
-            vm,
-        )
-        .unwrap();
+    // Set stdlib_dir to the frozen stdlib path
+    let state = PyRc::get_mut(&mut vm.state).unwrap();
+    state.config.paths.stdlib_dir = Some(rustpython_pylib::LIB_PATH.to_owned());
 }
 
 /// Setup dynamic standard library loading from filesystem
@@ -135,6 +130,11 @@ fn setup_dynamic_stdlib(vm: &mut VirtualMachine) {
     let state = PyRc::get_mut(&mut vm.state).unwrap();
     let paths = collect_stdlib_paths();
 
+    // Set stdlib_dir to the first stdlib path if available
+    if let Some(first_path) = paths.first() {
+        state.config.paths.stdlib_dir = Some(first_path.clone());
+    }
+
     // Insert at the beginning so stdlib comes before user paths
     for path in paths.into_iter().rev() {
         state.config.paths.module_search_paths.insert(0, path);

From 97167ab1cc467cb9fb82e5f20c63e57939192bff Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 03:52:52 +0900
Subject: [PATCH 388/418] Instruction 3.14 (#6805)

* renumber enum Instruction

* renumber magic

* Update test__opcode from 3.14.2

---------

Co-authored-by: CPython Devleopers <>
---
 Lib/_opcode_metadata.py                       | 458 ++++++-------
 Lib/importlib/_bootstrap_external.py          |   2 +-
 Lib/test/test__opcode.py                      |  17 +-
 Lib/test/test_importlib/test_util.py          |   2 +-
 .../compiler-core/src/bytecode/instruction.rs | 618 +++++++++---------
 crates/vm/src/frame.rs                        |  76 ---
 crates/vm/src/version.rs                      |   2 +-
 7 files changed, 567 insertions(+), 608 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index efb5f21e7fb..3345870e4ec 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -8,231 +8,245 @@
 
 opmap = {
     'CACHE': 0,
-    'BEFORE_ASYNC_WITH': 1,
-    'BEFORE_WITH': 2,
+    'BINARY_SLICE': 1,
+    'BUILD_TEMPLATE': 2,
     'BINARY_OP_INPLACE_ADD_UNICODE': 3,
-    'BINARY_SLICE': 4,
-    'BINARY_SUBSCR': 5,
-    'CHECK_EG_MATCH': 6,
-    'CHECK_EXC_MATCH': 7,
-    'CLEANUP_THROW': 8,
-    'DELETE_SUBSCR': 9,
-    'END_ASYNC_FOR': 10,
-    'END_FOR': 11,
-    'END_SEND': 12,
-    'EXIT_INIT_CHECK': 13,
-    'FORMAT_SIMPLE': 14,
-    'FORMAT_WITH_SPEC': 15,
-    'GET_AITER': 16,
+    'CALL_FUNCTION_EX': 4,
+    'CHECK_EG_MATCH': 5,
+    'CHECK_EXC_MATCH': 6,
+    'CLEANUP_THROW': 7,
+    'DELETE_SUBSCR': 8,
+    'END_FOR': 9,
+    'END_SEND': 10,
+    'EXIT_INIT_CHECK': 11,
+    'FORMAT_SIMPLE': 12,
+    'FORMAT_WITH_SPEC': 13,
+    'GET_AITER': 14,
+    'GET_ANEXT': 15,
+    'GET_ITER': 16,
     'RESERVED': 17,
-    'GET_ANEXT': 18,
-    'GET_ITER': 19,
-    'GET_LEN': 20,
-    'GET_YIELD_FROM_ITER': 21,
-    'INTERPRETER_EXIT': 22,
-    'LOAD_ASSERTION_ERROR': 23,
-    'LOAD_BUILD_CLASS': 24,
-    'LOAD_LOCALS': 25,
-    'MAKE_FUNCTION': 26,
-    'MATCH_KEYS': 27,
-    'MATCH_MAPPING': 28,
-    'MATCH_SEQUENCE': 29,
-    'NOP': 30,
-    'POP_EXCEPT': 31,
-    'POP_TOP': 32,
-    'PUSH_EXC_INFO': 33,
-    'PUSH_NULL': 34,
-    'RETURN_GENERATOR': 35,
-    'RETURN_VALUE': 36,
-    'SETUP_ANNOTATIONS': 37,
-    'STORE_SLICE': 38,
-    'STORE_SUBSCR': 39,
-    'TO_BOOL': 40,
-    'UNARY_INVERT': 41,
-    'UNARY_NEGATIVE': 42,
-    'UNARY_NOT': 43,
-    'WITH_EXCEPT_START': 44,
-    'BINARY_OP': 45,
-    'BUILD_CONST_KEY_MAP': 46,
-    'BUILD_LIST': 47,
-    'BUILD_MAP': 48,
-    'BUILD_SET': 49,
-    'BUILD_SLICE': 50,
-    'BUILD_STRING': 51,
-    'BUILD_TUPLE': 52,
-    'CALL': 53,
-    'CALL_FUNCTION_EX': 54,
-    'CALL_INTRINSIC_1': 55,
-    'CALL_INTRINSIC_2': 56,
-    'CALL_KW': 57,
-    'COMPARE_OP': 58,
-    'CONTAINS_OP': 59,
-    'CONVERT_VALUE': 60,
-    'COPY': 61,
-    'COPY_FREE_VARS': 62,
-    'DELETE_ATTR': 63,
-    'DELETE_DEREF': 64,
-    'DELETE_FAST': 65,
-    'DELETE_GLOBAL': 66,
-    'DELETE_NAME': 67,
-    'DICT_MERGE': 68,
-    'DICT_UPDATE': 69,
-    'ENTER_EXECUTOR': 70,
-    'EXTENDED_ARG': 71,
-    'FOR_ITER': 72,
-    'GET_AWAITABLE': 73,
-    'IMPORT_FROM': 74,
-    'IMPORT_NAME': 75,
-    'IS_OP': 76,
-    'JUMP_BACKWARD': 77,
-    'JUMP_BACKWARD_NO_INTERRUPT': 78,
-    'JUMP_FORWARD': 79,
-    'LIST_APPEND': 80,
-    'LIST_EXTEND': 81,
-    'LOAD_ATTR': 82,
-    'LOAD_CONST': 83,
-    'LOAD_DEREF': 84,
-    'LOAD_FAST': 85,
-    'LOAD_FAST_AND_CLEAR': 86,
-    'LOAD_FAST_CHECK': 87,
-    'LOAD_FAST_LOAD_FAST': 88,
-    'LOAD_FROM_DICT_OR_DEREF': 89,
-    'LOAD_FROM_DICT_OR_GLOBALS': 90,
-    'LOAD_GLOBAL': 91,
-    'LOAD_NAME': 92,
-    'LOAD_SUPER_ATTR': 93,
-    'MAKE_CELL': 94,
-    'MAP_ADD': 95,
-    'MATCH_CLASS': 96,
-    'POP_JUMP_IF_FALSE': 97,
-    'POP_JUMP_IF_NONE': 98,
-    'POP_JUMP_IF_NOT_NONE': 99,
-    'POP_JUMP_IF_TRUE': 100,
-    'RAISE_VARARGS': 101,
-    'RERAISE': 102,
-    'RETURN_CONST': 103,
-    'SEND': 104,
-    'SET_ADD': 105,
-    'SET_FUNCTION_ATTRIBUTE': 106,
-    'SET_UPDATE': 107,
-    'STORE_ATTR': 108,
-    'STORE_DEREF': 109,
-    'STORE_FAST': 110,
-    'STORE_FAST_LOAD_FAST': 111,
-    'STORE_FAST_STORE_FAST': 112,
-    'STORE_GLOBAL': 113,
-    'STORE_NAME': 114,
-    'SWAP': 115,
-    'UNPACK_EX': 116,
-    'UNPACK_SEQUENCE': 117,
-    'YIELD_VALUE': 118,
-    'BREAK': 119,
-    'BUILD_LIST_FROM_TUPLES': 120,
-    'BUILD_MAP_FOR_CALL': 121,
-    'BUILD_SET_FROM_TUPLES': 122,
-    'BUILD_TUPLE_FROM_ITER': 123,
-    'BUILD_TUPLE_FROM_TUPLES': 124,
-    'BUILD_TEMPLATE': 125,
-    'BUILD_INTERPOLATION': 126,
-    'CONTINUE': 128,
-    'JUMP_IF_FALSE_OR_POP': 129,
-    'JUMP_IF_TRUE_OR_POP': 130,
-    'JUMP_IF_NOT_EXC_MATCH': 131,
-    'SET_EXC_INFO': 132,
-    'SUBSCRIPT': 133,
-    'RESUME': 149,
-    'BINARY_OP_ADD_FLOAT': 150,
-    'BINARY_OP_ADD_INT': 151,
-    'BINARY_OP_ADD_UNICODE': 152,
-    'BINARY_OP_MULTIPLY_FLOAT': 153,
-    'BINARY_OP_MULTIPLY_INT': 154,
-    'BINARY_OP_SUBTRACT_FLOAT': 155,
-    'BINARY_OP_SUBTRACT_INT': 156,
-    'BINARY_SUBSCR_DICT': 157,
-    'BINARY_SUBSCR_GETITEM': 158,
-    'BINARY_SUBSCR_LIST_INT': 159,
-    'BINARY_SUBSCR_STR_INT': 160,
-    'BINARY_SUBSCR_TUPLE_INT': 161,
-    'CALL_ALLOC_AND_ENTER_INIT': 162,
-    'CALL_BOUND_METHOD_EXACT_ARGS': 163,
-    'CALL_BOUND_METHOD_GENERAL': 164,
-    'CALL_BUILTIN_CLASS': 165,
-    'CALL_BUILTIN_FAST': 166,
-    'CALL_BUILTIN_FAST_WITH_KEYWORDS': 167,
-    'CALL_BUILTIN_O': 168,
-    'CALL_ISINSTANCE': 169,
-    'CALL_LEN': 170,
-    'CALL_LIST_APPEND': 171,
-    'CALL_METHOD_DESCRIPTOR_FAST': 172,
-    'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS': 173,
-    'CALL_METHOD_DESCRIPTOR_NOARGS': 174,
-    'CALL_METHOD_DESCRIPTOR_O': 175,
-    'CALL_NON_PY_GENERAL': 176,
-    'CALL_PY_EXACT_ARGS': 177,
-    'CALL_PY_GENERAL': 178,
-    'CALL_STR_1': 179,
-    'CALL_TUPLE_1': 180,
-    'CALL_TYPE_1': 181,
-    'COMPARE_OP_FLOAT': 182,
-    'COMPARE_OP_INT': 183,
-    'COMPARE_OP_STR': 184,
-    'CONTAINS_OP_DICT': 185,
-    'CONTAINS_OP_SET': 186,
-    'FOR_ITER_GEN': 187,
-    'FOR_ITER_LIST': 188,
-    'FOR_ITER_RANGE': 189,
-    'FOR_ITER_TUPLE': 190,
-    'LOAD_ATTR_CLASS': 191,
-    'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN': 192,
-    'LOAD_ATTR_INSTANCE_VALUE': 193,
-    'LOAD_ATTR_METHOD_LAZY_DICT': 194,
-    'LOAD_ATTR_METHOD_NO_DICT': 195,
-    'LOAD_ATTR_METHOD_WITH_VALUES': 196,
-    'LOAD_ATTR_MODULE': 197,
-    'LOAD_ATTR_NONDESCRIPTOR_NO_DICT': 198,
-    'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES': 199,
-    'LOAD_ATTR_PROPERTY': 200,
-    'LOAD_ATTR_SLOT': 201,
-    'LOAD_ATTR_WITH_HINT': 202,
-    'LOAD_GLOBAL_BUILTIN': 203,
-    'LOAD_GLOBAL_MODULE': 204,
-    'LOAD_SUPER_ATTR_ATTR': 205,
-    'LOAD_SUPER_ATTR_METHOD': 206,
-    'RESUME_CHECK': 207,
-    'SEND_GEN': 208,
-    'STORE_ATTR_INSTANCE_VALUE': 209,
-    'STORE_ATTR_SLOT': 210,
-    'STORE_ATTR_WITH_HINT': 211,
-    'STORE_SUBSCR_DICT': 212,
-    'STORE_SUBSCR_LIST_INT': 213,
-    'TO_BOOL_ALWAYS_TRUE': 214,
-    'TO_BOOL_BOOL': 215,
-    'TO_BOOL_INT': 216,
-    'TO_BOOL_LIST': 217,
-    'TO_BOOL_NONE': 218,
-    'TO_BOOL_STR': 219,
-    'UNPACK_SEQUENCE_LIST': 220,
-    'UNPACK_SEQUENCE_TUPLE': 221,
-    'UNPACK_SEQUENCE_TWO_TUPLE': 222,
-    'INSTRUMENTED_RESUME': 236,
-    'INSTRUMENTED_END_FOR': 237,
-    'INSTRUMENTED_END_SEND': 238,
-    'INSTRUMENTED_RETURN_VALUE': 239,
-    'INSTRUMENTED_RETURN_CONST': 240,
-    'INSTRUMENTED_YIELD_VALUE': 241,
-    'INSTRUMENTED_LOAD_SUPER_ATTR': 242,
-    'INSTRUMENTED_FOR_ITER': 243,
-    'INSTRUMENTED_CALL': 244,
-    'INSTRUMENTED_CALL_KW': 245,
-    'INSTRUMENTED_CALL_FUNCTION_EX': 246,
-    'INSTRUMENTED_INSTRUCTION': 247,
-    'INSTRUMENTED_JUMP_FORWARD': 248,
-    'INSTRUMENTED_JUMP_BACKWARD': 249,
-    'INSTRUMENTED_POP_JUMP_IF_TRUE': 250,
-    'INSTRUMENTED_POP_JUMP_IF_FALSE': 251,
-    'INSTRUMENTED_POP_JUMP_IF_NONE': 252,
-    'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253,
+    'GET_LEN': 18,
+    'GET_YIELD_FROM_ITER': 19,
+    'INTERPRETER_EXIT': 20,
+    'LOAD_BUILD_CLASS': 21,
+    'LOAD_LOCALS': 22,
+    'MAKE_FUNCTION': 23,
+    'MATCH_KEYS': 24,
+    'MATCH_MAPPING': 25,
+    'MATCH_SEQUENCE': 26,
+    'NOP': 27,
+    'NOT_TAKEN': 28,
+    'POP_EXCEPT': 29,
+    'POP_ITER': 30,
+    'POP_TOP': 31,
+    'PUSH_EXC_INFO': 32,
+    'PUSH_NULL': 33,
+    'RETURN_GENERATOR': 34,
+    'RETURN_VALUE': 35,
+    'SETUP_ANNOTATIONS': 36,
+    'STORE_SLICE': 37,
+    'STORE_SUBSCR': 38,
+    'TO_BOOL': 39,
+    'UNARY_INVERT': 40,
+    'UNARY_NEGATIVE': 41,
+    'UNARY_NOT': 42,
+    'WITH_EXCEPT_START': 43,
+    'BINARY_OP': 44,
+    'BUILD_INTERPOLATION': 45,
+    'BUILD_LIST': 46,
+    'BUILD_MAP': 47,
+    'BUILD_SET': 48,
+    'BUILD_SLICE': 49,
+    'BUILD_STRING': 50,
+    'BUILD_TUPLE': 51,
+    'CALL': 52,
+    'CALL_INTRINSIC_1': 53,
+    'CALL_INTRINSIC_2': 54,
+    'CALL_KW': 55,
+    'COMPARE_OP': 56,
+    'CONTAINS_OP': 57,
+    'CONVERT_VALUE': 58,
+    'COPY': 59,
+    'COPY_FREE_VARS': 60,
+    'DELETE_ATTR': 61,
+    'DELETE_DEREF': 62,
+    'DELETE_FAST': 63,
+    'DELETE_GLOBAL': 64,
+    'DELETE_NAME': 65,
+    'DICT_MERGE': 66,
+    'DICT_UPDATE': 67,
+    'END_ASYNC_FOR': 68,
+    'EXTENDED_ARG': 69,
+    'FOR_ITER': 70,
+    'GET_AWAITABLE': 71,
+    'IMPORT_FROM': 72,
+    'IMPORT_NAME': 73,
+    'IS_OP': 74,
+    'JUMP_BACKWARD': 75,
+    'JUMP_BACKWARD_NO_INTERRUPT': 76,
+    'JUMP_FORWARD': 77,
+    'LIST_APPEND': 78,
+    'LIST_EXTEND': 79,
+    'LOAD_ATTR': 80,
+    'LOAD_COMMON_CONSTANT': 81,
+    'LOAD_CONST': 82,
+    'LOAD_DEREF': 83,
+    'LOAD_FAST': 84,
+    'LOAD_FAST_AND_CLEAR': 85,
+    'LOAD_FAST_BORROW': 86,
+    'LOAD_FAST_BORROW_LOAD_FAST_BORROW': 87,
+    'LOAD_FAST_CHECK': 88,
+    'LOAD_FAST_LOAD_FAST': 89,
+    'LOAD_FROM_DICT_OR_DEREF': 90,
+    'LOAD_FROM_DICT_OR_GLOBALS': 91,
+    'LOAD_GLOBAL': 92,
+    'LOAD_NAME': 93,
+    'LOAD_SMALL_INT': 94,
+    'LOAD_SPECIAL': 95,
+    'LOAD_SUPER_ATTR': 96,
+    'MAKE_CELL': 97,
+    'MAP_ADD': 98,
+    'MATCH_CLASS': 99,
+    'POP_JUMP_IF_FALSE': 100,
+    'POP_JUMP_IF_NONE': 101,
+    'POP_JUMP_IF_NOT_NONE': 102,
+    'POP_JUMP_IF_TRUE': 103,
+    'RAISE_VARARGS': 104,
+    'RERAISE': 105,
+    'SEND': 106,
+    'SET_ADD': 107,
+    'SET_FUNCTION_ATTRIBUTE': 108,
+    'SET_UPDATE': 109,
+    'STORE_ATTR': 110,
+    'STORE_DEREF': 111,
+    'STORE_FAST': 112,
+    'STORE_FAST_LOAD_FAST': 113,
+    'STORE_FAST_STORE_FAST': 114,
+    'STORE_GLOBAL': 115,
+    'STORE_NAME': 116,
+    'SWAP': 117,
+    'UNPACK_EX': 118,
+    'UNPACK_SEQUENCE': 119,
+    'YIELD_VALUE': 120,
+    'RESUME': 128,
+    'BINARY_OP_ADD_FLOAT': 129,
+    'BINARY_OP_ADD_INT': 130,
+    'BINARY_OP_ADD_UNICODE': 131,
+    'BINARY_OP_EXTEND': 132,
+    'BINARY_OP_MULTIPLY_FLOAT': 133,
+    'BINARY_OP_MULTIPLY_INT': 134,
+    'BINARY_SUBSCR_DICT': 135,
+    'BINARY_SUBSCR_GETITEM': 136,
+    'BINARY_SUBSCR_LIST_INT': 137,
+    'BINARY_SUBSCR_LIST_SLICE': 138,
+    'BINARY_SUBSCR_STR_INT': 139,
+    'BINARY_SUBSCR_TUPLE_INT': 140,
+    'BINARY_OP_SUBTRACT_FLOAT': 141,
+    'BINARY_OP_SUBTRACT_INT': 142,
+    'CALL_ALLOC_AND_ENTER_INIT': 143,
+    'CALL_BOUND_METHOD_EXACT_ARGS': 144,
+    'CALL_BOUND_METHOD_GENERAL': 145,
+    'CALL_BUILTIN_CLASS': 146,
+    'CALL_BUILTIN_FAST': 147,
+    'CALL_BUILTIN_FAST_WITH_KEYWORDS': 148,
+    'CALL_BUILTIN_O': 149,
+    'CALL_ISINSTANCE': 150,
+    'CALL_KW_BOUND_METHOD': 151,
+    'CALL_KW_NON_PY': 152,
+    'CALL_KW_PY': 153,
+    'CALL_LEN': 154,
+    'CALL_LIST_APPEND': 155,
+    'CALL_METHOD_DESCRIPTOR_FAST': 156,
+    'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS': 157,
+    'CALL_METHOD_DESCRIPTOR_NOARGS': 158,
+    'CALL_METHOD_DESCRIPTOR_O': 159,
+    'CALL_NON_PY_GENERAL': 160,
+    'CALL_PY_EXACT_ARGS': 161,
+    'CALL_PY_GENERAL': 162,
+    'CALL_STR_1': 163,
+    'CALL_TUPLE_1': 164,
+    'CALL_TYPE_1': 165,
+    'COMPARE_OP_FLOAT': 166,
+    'COMPARE_OP_INT': 167,
+    'COMPARE_OP_STR': 168,
+    'CONTAINS_OP_DICT': 169,
+    'CONTAINS_OP_SET': 170,
+    'FOR_ITER_GEN': 171,
+    'FOR_ITER_LIST': 172,
+    'FOR_ITER_RANGE': 173,
+    'FOR_ITER_TUPLE': 174,
+    'JUMP_BACKWARD_JIT': 175,
+    'JUMP_BACKWARD_NO_JIT': 176,
+    'LOAD_ATTR_CLASS': 177,
+    'LOAD_ATTR_CLASS_WITH_METACLASS_CHECK': 178,
+    'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN': 179,
+    'LOAD_ATTR_INSTANCE_VALUE': 180,
+    'LOAD_ATTR_METHOD_LAZY_DICT': 181,
+    'LOAD_ATTR_METHOD_NO_DICT': 182,
+    'LOAD_ATTR_METHOD_WITH_VALUES': 183,
+    'LOAD_ATTR_MODULE': 184,
+    'LOAD_ATTR_NONDESCRIPTOR_NO_DICT': 185,
+    'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES': 186,
+    'LOAD_ATTR_PROPERTY': 187,
+    'LOAD_ATTR_SLOT': 188,
+    'LOAD_ATTR_WITH_HINT': 189,
+    'LOAD_CONST_IMMORTAL': 190,
+    'LOAD_CONST_MORTAL': 191,
+    'LOAD_GLOBAL_BUILTIN': 192,
+    'LOAD_GLOBAL_MODULE': 193,
+    'LOAD_SUPER_ATTR_ATTR': 194,
+    'LOAD_SUPER_ATTR_METHOD': 195,
+    'RESUME_CHECK': 196,
+    'SEND_GEN': 197,
+    'STORE_ATTR_INSTANCE_VALUE': 198,
+    'STORE_ATTR_SLOT': 199,
+    'STORE_ATTR_WITH_HINT': 200,
+    'STORE_SUBSCR_DICT': 201,
+    'STORE_SUBSCR_LIST_INT': 202,
+    'TO_BOOL_ALWAYS_TRUE': 203,
+    'TO_BOOL_BOOL': 204,
+    'TO_BOOL_INT': 205,
+    'TO_BOOL_LIST': 206,
+    'TO_BOOL_NONE': 207,
+    'TO_BOOL_STR': 208,
+    'UNPACK_SEQUENCE_LIST': 209,
+    'UNPACK_SEQUENCE_TUPLE': 210,
+    'UNPACK_SEQUENCE_TWO_TUPLE': 211,
+    'BEFORE_ASYNC_WITH': 212,
+    'BEFORE_WITH': 213,
+    'BINARY_SUBSCR': 214,
+    'BUILD_CONST_KEY_MAP': 215,
+    'BREAK': 216,
+    'CONTINUE': 217,
+    'JUMP_IF_FALSE_OR_POP': 218,
+    'JUMP_IF_TRUE_OR_POP': 219,
+    'JUMP_IF_NOT_EXC_MATCH': 220,
+    'LOAD_ASSERTION_ERROR': 221,
+    'RETURN_CONST': 222,
+    'SET_EXC_INFO': 223,
+    'SUBSCRIPT': 224,
+    'INSTRUMENTED_END_FOR': 234,
+    'INSTRUMENTED_POP_ITER': 235,
+    'INSTRUMENTED_END_SEND': 236,
+    'INSTRUMENTED_FOR_ITER': 237,
+    'INSTRUMENTED_INSTRUCTION': 238,
+    'INSTRUMENTED_JUMP_FORWARD': 239,
+    'INSTRUMENTED_NOT_TAKEN': 240,
+    'INSTRUMENTED_POP_JUMP_IF_TRUE': 241,
+    'INSTRUMENTED_POP_JUMP_IF_FALSE': 242,
+    'INSTRUMENTED_POP_JUMP_IF_NONE': 243,
+    'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 244,
+    'INSTRUMENTED_RESUME': 245,
+    'INSTRUMENTED_RETURN_VALUE': 246,
+    'INSTRUMENTED_YIELD_VALUE': 247,
+    'INSTRUMENTED_END_ASYNC_FOR': 248,
+    'INSTRUMENTED_LOAD_SUPER_ATTR': 249,
+    'INSTRUMENTED_CALL': 250,
+    'INSTRUMENTED_CALL_KW': 251,
+    'INSTRUMENTED_CALL_FUNCTION_EX': 252,
+    'INSTRUMENTED_JUMP_BACKWARD': 253,
     'INSTRUMENTED_LINE': 254,
+    'ENTER_EXECUTOR': 255,
     'JUMP': 256,
     'JUMP_NO_INTERRUPT': 257,
     'RESERVED_258': 258,
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index ca73eb2fcf7..89ce8c09c94 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -489,7 +489,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (2997).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (2996).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
index 9d9d7f95f29..d533300ac58 100644
--- a/Lib/test/test__opcode.py
+++ b/Lib/test/test__opcode.py
@@ -17,7 +17,7 @@ def check_bool_function_result(self, func, ops, expected):
                 self.assertEqual(func(op), expected)
 
     def test_invalid_opcodes(self):
-        invalid = [-100, -1, 255, 512, 513, 1000]
+        invalid = [-100, -1, 512, 513, 1000]
         self.check_bool_function_result(_opcode.is_valid, invalid, False)
         self.check_bool_function_result(_opcode.has_arg, invalid, False)
         self.check_bool_function_result(_opcode.has_const, invalid, False)
@@ -38,6 +38,14 @@ def test_is_valid(self):
         opcodes = [dis.opmap[opname] for opname in names]
         self.check_bool_function_result(_opcode.is_valid, opcodes, True)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_opmaps(self):
+        def check_roundtrip(name, map):
+            return self.assertEqual(opcode.opname[map[name]], name)
+
+        check_roundtrip('BINARY_OP', opcode.opmap)
+        check_roundtrip('BINARY_OP_ADD_INT', opcode._specialized_opmap)
+
     def test_oplists(self):
         def check_function(self, func, expected):
             for op in [-10, 520]:
@@ -58,8 +66,7 @@ def check_function(self, func, expected):
 class StackEffectTests(unittest.TestCase):
     def test_stack_effect(self):
         self.assertEqual(stack_effect(dis.opmap['POP_TOP']), -1)
-        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 0), -1)
-        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 1), -1)
+        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 2), -1)
         self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 3), -2)
         self.assertRaises(ValueError, stack_effect, 30000)
         # All defined opcodes
@@ -110,7 +117,7 @@ def test_stack_effect_jump(self):
 
 
 class SpecializationStatsTests(unittest.TestCase):
-    @unittest.expectedFailure # TODO: RUSTPYTHON - no specialization stats
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_specialization_stats(self):
         stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
         specialized_opcodes = [
@@ -119,7 +126,7 @@ def test_specialization_stats(self):
             if opcode._inline_cache_entries.get(op, 0)
         ]
         self.assertIn('load_attr', specialized_opcodes)
-        self.assertIn('binary_subscr', specialized_opcodes)
+        self.assertIn('binary_op', specialized_opcodes)
 
         stats = _opcode.get_specialization_stats()
         if stats is not None:
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index bc47159b235..b9ff9a9f9fc 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -636,7 +636,7 @@ def test_magic_number(self):
         # stakeholders such as OS package maintainers must be notified
         # in advance. Such exceptional releases will then require an
         # adjustment to this test case.
-        EXPECTED_MAGIC_NUMBER = 2997
+        EXPECTED_MAGIC_NUMBER = 2996
         actual = int.from_bytes(importlib.util.MAGIC_NUMBER[:2], 'little')
 
         msg = (
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 996efe4918e..41f86dca39b 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -14,375 +14,388 @@ use crate::{
 
 /// A Single bytecode instruction that are executed by the VM.
 ///
-/// Currently aligned with CPython 3.13.
+/// Currently aligned with CPython 3.14.
 ///
 /// ## See also
-/// - [CPython opcode IDs](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Include/opcode_ids.h)
+/// - [CPython opcode IDs](https://github.com/python/cpython/blob/v3.14.2/Include/opcode_ids.h)
 #[derive(Clone, Copy, Debug)]
 #[repr(u8)]
 pub enum Instruction {
-    // ==================== No-argument instructions (opcode < 44) ====================
-    Cache = 0, // Placeholder
-    BeforeAsyncWith = 1,
-    BeforeWith = 2,
+    // No-argument instructions (opcode < HAVE_ARGUMENT=44)
+    Cache = 0,       // Placeholder
+    BinarySlice = 1, // Placeholder
+    BuildTemplate = 2,
     BinaryOpInplaceAddUnicode = 3, // Placeholder
-    BinarySlice = 4,               // Placeholder
-    BinarySubscr = 5,
-    CheckEgMatch = 6,
-    CheckExcMatch = 7,
-    CleanupThrow = 8,
-    DeleteSubscr = 9,
-    EndAsyncFor = 10,
-    EndFor = 11, // Placeholder
-    EndSend = 12,
-    ExitInitCheck = 13, // Placeholder
-    FormatSimple = 14,
-    FormatWithSpec = 15,
-    GetAIter = 16,
+    CallFunctionEx = 4,
+    CheckEgMatch = 5,
+    CheckExcMatch = 6,
+    CleanupThrow = 7,
+    DeleteSubscr = 8,
+    EndFor = 9, // Placeholder
+    EndSend = 10,
+    ExitInitCheck = 11, // Placeholder
+    FormatSimple = 12,
+    FormatWithSpec = 13,
+    GetAIter = 14,
+    GetANext = 15,
+    GetIter = 16,
     Reserved = 17,
-    GetANext = 18,
-    GetIter = 19,
-    GetLen = 20,
-    GetYieldFromIter = 21,
-    InterpreterExit = 22,    // Placeholder
-    LoadAssertionError = 23, // Placeholder
-    LoadBuildClass = 24,
-    LoadLocals = 25, // Placeholder
-    MakeFunction = 26,
-    MatchKeys = 27,
-    MatchMapping = 28,
-    MatchSequence = 29,
-    Nop = 30,
-    PopExcept = 31,
-    PopTop = 32,
-    PushExcInfo = 33,
-    PushNull = 34,
-    ReturnGenerator = 35, // Placeholder
-    ReturnValue = 36,
-    SetupAnnotations = 37,
-    StoreSlice = 38, // Placeholder
-    StoreSubscr = 39,
-    ToBool = 40,
-    UnaryInvert = 41,
-    UnaryNegative = 42,
-    UnaryNot = 43,
-    WithExceptStart = 44,
-    // ==================== With-argument instructions (opcode > 44) ====================
+    GetLen = 18,
+    GetYieldFromIter = 19,
+    InterpreterExit = 20, // Placeholder
+    LoadBuildClass = 21,
+    LoadLocals = 22, // Placeholder
+    MakeFunction = 23,
+    MatchKeys = 24,
+    MatchMapping = 25,
+    MatchSequence = 26,
+    Nop = 27,
+    NotTaken = 28, // Placeholder
+    PopExcept = 29,
+    PopIter = 30, // Placeholder
+    PopTop = 31,
+    PushExcInfo = 32,
+    PushNull = 33,
+    ReturnGenerator = 34, // Placeholder
+    ReturnValue = 35,
+    SetupAnnotations = 36,
+    StoreSlice = 37, // Placeholder
+    StoreSubscr = 38,
+    ToBool = 39,
+    UnaryInvert = 40,
+    UnaryNegative = 41,
+    UnaryNot = 42,
+    WithExceptStart = 43,
+    // CPython 3.14 opcodes with arguments (44-120)
     BinaryOp {
         op: Arg<BinaryOperator>,
+    } = 44,
+    /// Build an Interpolation from value, expression string, and optional format_spec on stack.
+    ///
+    /// oparg encoding: (conversion << 2) | has_format_spec
+    /// - has_format_spec (bit 0): if 1, format_spec is on stack
+    /// - conversion (bits 2+): 0=None, 1=Str, 2=Repr, 3=Ascii
+    ///
+    /// Stack: [value, expression_str, format_spec?] -> [interpolation]
+    BuildInterpolation {
+        oparg: Arg<u32>,
     } = 45,
-    BuildConstKeyMap {
-        size: Arg<u32>,
-    } = 46, // Placeholder
     BuildList {
         size: Arg<u32>,
-    } = 47,
+    } = 46,
     BuildMap {
         size: Arg<u32>,
-    } = 48,
+    } = 47,
     BuildSet {
         size: Arg<u32>,
-    } = 49,
+    } = 48,
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
-    } = 50,
+    } = 49,
     BuildString {
         size: Arg<u32>,
-    } = 51,
+    } = 50,
     BuildTuple {
         size: Arg<u32>,
-    } = 52,
+    } = 51,
     Call {
         nargs: Arg<u32>,
-    } = 53,
-    CallFunctionEx = 54,
+    } = 52,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
-    } = 55,
+    } = 53,
     CallIntrinsic2 {
         func: Arg<IntrinsicFunction2>,
-    } = 56,
+    } = 54,
     CallKw {
         nargs: Arg<u32>,
-    } = 57,
+    } = 55,
     CompareOp {
         op: Arg<ComparisonOperator>,
-    } = 58,
-    ContainsOp(Arg<Invert>) = 59,
+    } = 56,
+    ContainsOp(Arg<Invert>) = 57,
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
-    } = 60,
+    } = 58,
     Copy {
         index: Arg<u32>,
-    } = 61,
+    } = 59,
     CopyFreeVars {
         count: Arg<u32>,
-    } = 62, // Placeholder
+    } = 60, // Placeholder
     DeleteAttr {
         idx: Arg<NameIdx>,
-    } = 63,
-    DeleteDeref(Arg<NameIdx>) = 64,
-    DeleteFast(Arg<NameIdx>) = 65,
-    DeleteGlobal(Arg<NameIdx>) = 66,
-    DeleteName(Arg<NameIdx>) = 67,
+    } = 61,
+    DeleteDeref(Arg<NameIdx>) = 62,
+    DeleteFast(Arg<NameIdx>) = 63,
+    DeleteGlobal(Arg<NameIdx>) = 64,
+    DeleteName(Arg<NameIdx>) = 65,
     DictMerge {
         index: Arg<u32>,
-    } = 68, // Placeholder
+    } = 66,
     DictUpdate {
         index: Arg<u32>,
-    } = 69,
-    EnterExecutor = 70, // Placeholder
-    ExtendedArg = 71,
+    } = 67,
+    EndAsyncFor = 68,
+    ExtendedArg = 69,
     ForIter {
         target: Arg<Label>,
-    } = 72,
-    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
+    } = 70,
+    GetAwaitable = 71, // TODO: Make this instruction to hold an oparg
     ImportFrom {
         idx: Arg<NameIdx>,
-    } = 74,
+    } = 72,
     ImportName {
         idx: Arg<NameIdx>,
-    } = 75,
-    IsOp(Arg<Invert>) = 76,
+    } = 73,
+    IsOp(Arg<Invert>) = 74,
     JumpBackward {
         target: Arg<Label>,
-    } = 77,
+    } = 75,
     JumpBackwardNoInterrupt {
         target: Arg<Label>,
-    } = 78, // Placeholder
+    } = 76, // Placeholder
     JumpForward {
         target: Arg<Label>,
-    } = 79,
+    } = 77,
     ListAppend {
         i: Arg<u32>,
-    } = 80,
+    } = 78,
     ListExtend {
         i: Arg<u32>,
-    } = 81, // Placeholder
+    } = 79,
     LoadAttr {
         idx: Arg<NameIdx>,
-    } = 82,
+    } = 80,
+    LoadCommonConstant {
+        idx: Arg<u32>,
+    } = 81, // Placeholder
     LoadConst {
         idx: Arg<u32>,
-    } = 83,
-    LoadDeref(Arg<NameIdx>) = 84,
-    LoadFast(Arg<NameIdx>) = 85,
-    LoadFastAndClear(Arg<NameIdx>) = 86,
-    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
+    } = 82,
+    LoadDeref(Arg<NameIdx>) = 83,
+    LoadFast(Arg<NameIdx>) = 84,
+    LoadFastAndClear(Arg<NameIdx>) = 85,
+    LoadFastBorrow(Arg<NameIdx>) = 86, // Placeholder
+    LoadFastBorrowLoadFastBorrow {
+        arg: Arg<u32>,
+    } = 87, // Placeholder
+    LoadFastCheck(Arg<NameIdx>) = 88,  // Placeholder
     LoadFastLoadFast {
         arg: Arg<u32>,
-    } = 88, // Placeholder
-    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
-    LoadGlobal(Arg<NameIdx>) = 91,
-    LoadName(Arg<NameIdx>) = 92,
+    } = 89, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 90,
+    LoadFromDictOrGlobals(Arg<NameIdx>) = 91, // Placeholder
+    LoadGlobal(Arg<NameIdx>) = 92,
+    LoadName(Arg<NameIdx>) = 93,
+    LoadSmallInt {
+        idx: Arg<u32>,
+    } = 94, // Placeholder
+    LoadSpecial {
+        arg: Arg<u32>,
+    } = 95, // Placeholder
     LoadSuperAttr {
         arg: Arg<u32>,
-    } = 93,
-    MakeCell(Arg<NameIdx>) = 94, // Placeholder
+    } = 96,
+    MakeCell(Arg<NameIdx>) = 97, // Placeholder
     MapAdd {
         i: Arg<u32>,
-    } = 95,
-    MatchClass(Arg<u32>) = 96,
+    } = 98,
+    MatchClass(Arg<u32>) = 99,
     PopJumpIfFalse {
         target: Arg<Label>,
-    } = 97,
+    } = 100,
     PopJumpIfNone {
         target: Arg<Label>,
-    } = 98, // Placeholder
+    } = 101, // Placeholder
     PopJumpIfNotNone {
         target: Arg<Label>,
-    } = 99, // Placeholder
+    } = 102, // Placeholder
     PopJumpIfTrue {
         target: Arg<Label>,
-    } = 100,
+    } = 103,
     RaiseVarargs {
         kind: Arg<RaiseKind>,
-    } = 101,
+    } = 104,
     Reraise {
         depth: Arg<u32>,
-    } = 102,
-    ReturnConst {
-        idx: Arg<u32>,
-    } = 103,
+    } = 105,
     Send {
         target: Arg<Label>,
-    } = 104,
+    } = 106,
     SetAdd {
         i: Arg<u32>,
-    } = 105,
+    } = 107,
     SetFunctionAttribute {
         attr: Arg<MakeFunctionFlags>,
-    } = 106,
+    } = 108,
     SetUpdate {
         i: Arg<u32>,
-    } = 107, // Placeholder
+    } = 109,
     StoreAttr {
         idx: Arg<NameIdx>,
-    } = 108,
-    StoreDeref(Arg<NameIdx>) = 109,
-    StoreFast(Arg<NameIdx>) = 110,
+    } = 110,
+    StoreDeref(Arg<NameIdx>) = 111,
+    StoreFast(Arg<NameIdx>) = 112,
     StoreFastLoadFast {
         store_idx: Arg<NameIdx>,
         load_idx: Arg<NameIdx>,
-    } = 111,
+    } = 113,
     StoreFastStoreFast {
         arg: Arg<u32>,
-    } = 112, // Placeholder
-    StoreGlobal(Arg<NameIdx>) = 113,
-    StoreName(Arg<NameIdx>) = 114,
+    } = 114, // Placeholder
+    StoreGlobal(Arg<NameIdx>) = 115,
+    StoreName(Arg<NameIdx>) = 116,
     Swap {
         index: Arg<u32>,
-    } = 115,
+    } = 117,
     UnpackEx {
         args: Arg<UnpackExArgs>,
-    } = 116,
+    } = 118,
     UnpackSequence {
         size: Arg<u32>,
-    } = 117,
+    } = 119,
     YieldValue {
         arg: Arg<u32>,
-    } = 118,
-    // ==================== RustPython-only instructions (119-133) ====================
-    // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
-    // So we assign random IDs to these opcodes.
-    Break {
-        target: Arg<Label>,
-    } = 119,
-    BuildListFromTuples {
-        size: Arg<u32>,
     } = 120,
-    BuildMapForCall {
-        size: Arg<u32>,
-    } = 121,
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    } = 122,
-    BuildTupleFromIter = 123,
-    BuildTupleFromTuples {
+    // RustPython-only instructions (212-225)
+    // These either don't exist in CPython 3.14 or are RustPython-specific.
+    BeforeAsyncWith = 212,
+    BeforeWith = 213,
+    BinarySubscr = 214,
+    BuildConstKeyMap {
         size: Arg<u32>,
-    } = 124,
-    /// Build a Template from strings tuple and interpolations tuple on stack.
-    /// Stack: [strings_tuple, interpolations_tuple] -> [template]
-    BuildTemplate = 125,
-    /// Build an Interpolation from value, expression string, and optional format_spec on stack.
-    ///
-    /// oparg encoding: (conversion << 2) | has_format_spec
-    /// - has_format_spec (bit 0): if 1, format_spec is on stack
-    /// - conversion (bits 2+): 0=None, 1=Str, 2=Repr, 3=Ascii
-    ///
-    /// Stack: [value, expression_str, format_spec?] -> [interpolation]
-    BuildInterpolation {
-        oparg: Arg<u32>,
-    } = 126,
+    } = 215, // Placeholder
+    Break {
+        target: Arg<Label>,
+    } = 216,
     Continue {
         target: Arg<Label>,
-    } = 128,
+    } = 217,
     JumpIfFalseOrPop {
         target: Arg<Label>,
-    } = 129,
+    } = 218,
     JumpIfTrueOrPop {
         target: Arg<Label>,
-    } = 130,
-    JumpIfNotExcMatch(Arg<Label>) = 131,
-    SetExcInfo = 132,
-    Subscript = 133,
-    // End of custom instructions
+    } = 219,
+    JumpIfNotExcMatch(Arg<Label>) = 220,
+    LoadAssertionError = 221, // Placeholder
+    ReturnConst {
+        idx: Arg<u32>,
+    } = 222,
+    SetExcInfo = 223,
+    Subscript = 224,
+    // CPython 3.14 RESUME (128)
     Resume {
         arg: Arg<u32>,
-    } = 149,
-    BinaryOpAddFloat = 150,                     // Placeholder
-    BinaryOpAddInt = 151,                       // Placeholder
-    BinaryOpAddUnicode = 152,                   // Placeholder
-    BinaryOpMultiplyFloat = 153,                // Placeholder
-    BinaryOpMultiplyInt = 154,                  // Placeholder
-    BinaryOpSubtractFloat = 155,                // Placeholder
-    BinaryOpSubtractInt = 156,                  // Placeholder
-    BinarySubscrDict = 157,                     // Placeholder
-    BinarySubscrGetitem = 158,                  // Placeholder
-    BinarySubscrListInt = 159,                  // Placeholder
-    BinarySubscrStrInt = 160,                   // Placeholder
-    BinarySubscrTupleInt = 161,                 // Placeholder
-    CallAllocAndEnterInit = 162,                // Placeholder
-    CallBoundMethodExactArgs = 163,             // Placeholder
-    CallBoundMethodGeneral = 164,               // Placeholder
-    CallBuiltinClass = 165,                     // Placeholder
-    CallBuiltinFast = 166,                      // Placeholder
-    CallBuiltinFastWithKeywords = 167,          // Placeholder
-    CallBuiltinO = 168,                         // Placeholder
-    CallIsinstance = 169,                       // Placeholder
-    CallLen = 170,                              // Placeholder
-    CallListAppend = 171,                       // Placeholder
-    CallMethodDescriptorFast = 172,             // Placeholder
-    CallMethodDescriptorFastWithKeywords = 173, // Placeholder
-    CallMethodDescriptorNoargs = 174,           // Placeholder
-    CallMethodDescriptorO = 175,                // Placeholder
-    CallNonPyGeneral = 176,                     // Placeholder
-    CallPyExactArgs = 177,                      // Placeholder
-    CallPyGeneral = 178,                        // Placeholder
-    CallStr1 = 179,                             // Placeholder
-    CallTuple1 = 180,                           // Placeholder
-    CallType1 = 181,                            // Placeholder
-    CompareOpFloat = 182,                       // Placeholder
-    CompareOpInt = 183,                         // Placeholder
-    CompareOpStr = 184,                         // Placeholder
-    ContainsOpDict = 185,                       // Placeholder
-    ContainsOpSet = 186,                        // Placeholder
-    ForIterGen = 187,                           // Placeholder
-    ForIterList = 188,                          // Placeholder
-    ForIterRange = 189,                         // Placeholder
-    ForIterTuple = 190,                         // Placeholder
-    LoadAttrClass = 191,                        // Placeholder
-    LoadAttrGetattributeOverridden = 192,       // Placeholder
-    LoadAttrInstanceValue = 193,                // Placeholder
-    LoadAttrMethodLazyDict = 194,               // Placeholder
-    LoadAttrMethodNoDict = 195,                 // Placeholder
-    LoadAttrMethodWithValues = 196,             // Placeholder
-    LoadAttrModule = 197,                       // Placeholder
-    LoadAttrNondescriptorNoDict = 198,          // Placeholder
-    LoadAttrNondescriptorWithValues = 199,      // Placeholder
-    LoadAttrProperty = 200,                     // Placeholder
-    LoadAttrSlot = 201,                         // Placeholder
-    LoadAttrWithHint = 202,                     // Placeholder
-    LoadGlobalBuiltin = 203,                    // Placeholder
-    LoadGlobalModule = 204,                     // Placeholder
-    LoadSuperAttrAttr = 205,                    // Placeholder
-    LoadSuperAttrMethod = 206,                  // Placeholder
-    ResumeCheck = 207,                          // Placeholder
-    SendGen = 208,                              // Placeholder
-    StoreAttrInstanceValue = 209,               // Placeholder
-    StoreAttrSlot = 210,                        // Placeholder
-    StoreAttrWithHint = 211,                    // Placeholder
-    StoreSubscrDict = 212,                      // Placeholder
-    StoreSubscrListInt = 213,                   // Placeholder
-    ToBoolAlwaysTrue = 214,                     // Placeholder
-    ToBoolBool = 215,                           // Placeholder
-    ToBoolInt = 216,                            // Placeholder
-    ToBoolList = 217,                           // Placeholder
-    ToBoolNone = 218,                           // Placeholder
-    ToBoolStr = 219,                            // Placeholder
-    UnpackSequenceList = 220,                   // Placeholder
-    UnpackSequenceTuple = 221,                  // Placeholder
-    UnpackSequenceTwoTuple = 222,               // Placeholder
-    InstrumentedResume = 236,                   // Placeholder
-    InstrumentedEndFor = 237,                   // Placeholder
-    InstrumentedEndSend = 238,                  // Placeholder
-    InstrumentedReturnValue = 239,              // Placeholder
-    InstrumentedReturnConst = 240,              // Placeholder
-    InstrumentedYieldValue = 241,               // Placeholder
-    InstrumentedLoadSuperAttr = 242,            // Placeholder
-    InstrumentedForIter = 243,                  // Placeholder
-    InstrumentedCall = 244,                     // Placeholder
-    InstrumentedCallKw = 245,                   // Placeholder
-    InstrumentedCallFunctionEx = 246,           // Placeholder
-    InstrumentedInstruction = 247,              // Placeholder
-    InstrumentedJumpForward = 248,              // Placeholder
-    InstrumentedJumpBackward = 249,             // Placeholder
-    InstrumentedPopJumpIfTrue = 250,            // Placeholder
-    InstrumentedPopJumpIfFalse = 251,           // Placeholder
-    InstrumentedPopJumpIfNone = 252,            // Placeholder
-    InstrumentedPopJumpIfNotNone = 253,         // Placeholder
-    InstrumentedLine = 254,                     // Placeholder
+    } = 128,
+    // CPython 3.14 specialized opcodes (129-211)
+    BinaryOpAddFloat = 129,                     // Placeholder
+    BinaryOpAddInt = 130,                       // Placeholder
+    BinaryOpAddUnicode = 131,                   // Placeholder
+    BinaryOpExtend = 132,                       // Placeholder
+    BinaryOpMultiplyFloat = 133,                // Placeholder
+    BinaryOpMultiplyInt = 134,                  // Placeholder
+    BinarySubscrDict = 135,                     // Placeholder
+    BinarySubscrGetitem = 136,                  // Placeholder
+    BinarySubscrListInt = 137,                  // Placeholder
+    BinarySubscrListSlice = 138,                // Placeholder
+    BinarySubscrStrInt = 139,                   // Placeholder
+    BinarySubscrTupleInt = 140,                 // Placeholder
+    BinaryOpSubtractFloat = 141,                // Placeholder
+    BinaryOpSubtractInt = 142,                  // Placeholder
+    CallAllocAndEnterInit = 143,                // Placeholder
+    CallBoundMethodExactArgs = 144,             // Placeholder
+    CallBoundMethodGeneral = 145,               // Placeholder
+    CallBuiltinClass = 146,                     // Placeholder
+    CallBuiltinFast = 147,                      // Placeholder
+    CallBuiltinFastWithKeywords = 148,          // Placeholder
+    CallBuiltinO = 149,                         // Placeholder
+    CallIsinstance = 150,                       // Placeholder
+    CallKwBoundMethod = 151,                    // Placeholder
+    CallKwNonPy = 152,                          // Placeholder
+    CallKwPy = 153,                             // Placeholder
+    CallLen = 154,                              // Placeholder
+    CallListAppend = 155,                       // Placeholder
+    CallMethodDescriptorFast = 156,             // Placeholder
+    CallMethodDescriptorFastWithKeywords = 157, // Placeholder
+    CallMethodDescriptorNoargs = 158,           // Placeholder
+    CallMethodDescriptorO = 159,                // Placeholder
+    CallNonPyGeneral = 160,                     // Placeholder
+    CallPyExactArgs = 161,                      // Placeholder
+    CallPyGeneral = 162,                        // Placeholder
+    CallStr1 = 163,                             // Placeholder
+    CallTuple1 = 164,                           // Placeholder
+    CallType1 = 165,                            // Placeholder
+    CompareOpFloat = 166,                       // Placeholder
+    CompareOpInt = 167,                         // Placeholder
+    CompareOpStr = 168,                         // Placeholder
+    ContainsOpDict = 169,                       // Placeholder
+    ContainsOpSet = 170,                        // Placeholder
+    ForIterGen = 171,                           // Placeholder
+    ForIterList = 172,                          // Placeholder
+    ForIterRange = 173,                         // Placeholder
+    ForIterTuple = 174,                         // Placeholder
+    JumpBackwardJit = 175,                      // Placeholder
+    JumpBackwardNoJit = 176,                    // Placeholder
+    LoadAttrClass = 177,                        // Placeholder
+    LoadAttrClassWithMetaclassCheck = 178,      // Placeholder
+    LoadAttrGetattributeOverridden = 179,       // Placeholder
+    LoadAttrInstanceValue = 180,                // Placeholder
+    LoadAttrMethodLazyDict = 181,               // Placeholder
+    LoadAttrMethodNoDict = 182,                 // Placeholder
+    LoadAttrMethodWithValues = 183,             // Placeholder
+    LoadAttrModule = 184,                       // Placeholder
+    LoadAttrNondescriptorNoDict = 185,          // Placeholder
+    LoadAttrNondescriptorWithValues = 186,      // Placeholder
+    LoadAttrProperty = 187,                     // Placeholder
+    LoadAttrSlot = 188,                         // Placeholder
+    LoadAttrWithHint = 189,                     // Placeholder
+    LoadConstImmortal = 190,                    // Placeholder
+    LoadConstMortal = 191,                      // Placeholder
+    LoadGlobalBuiltin = 192,                    // Placeholder
+    LoadGlobalModule = 193,                     // Placeholder
+    LoadSuperAttrAttr = 194,                    // Placeholder
+    LoadSuperAttrMethod = 195,                  // Placeholder
+    ResumeCheck = 196,                          // Placeholder
+    SendGen = 197,                              // Placeholder
+    StoreAttrInstanceValue = 198,               // Placeholder
+    StoreAttrSlot = 199,                        // Placeholder
+    StoreAttrWithHint = 200,                    // Placeholder
+    StoreSubscrDict = 201,                      // Placeholder
+    StoreSubscrListInt = 202,                   // Placeholder
+    ToBoolAlwaysTrue = 203,                     // Placeholder
+    ToBoolBool = 204,                           // Placeholder
+    ToBoolInt = 205,                            // Placeholder
+    ToBoolList = 206,                           // Placeholder
+    ToBoolNone = 207,                           // Placeholder
+    ToBoolStr = 208,                            // Placeholder
+    UnpackSequenceList = 209,                   // Placeholder
+    UnpackSequenceTuple = 210,                  // Placeholder
+    UnpackSequenceTwoTuple = 211,               // Placeholder
+    // CPython 3.14 instrumented opcodes (234-254)
+    InstrumentedEndFor = 234,           // Placeholder
+    InstrumentedPopIter = 235,          // Placeholder
+    InstrumentedEndSend = 236,          // Placeholder
+    InstrumentedForIter = 237,          // Placeholder
+    InstrumentedInstruction = 238,      // Placeholder
+    InstrumentedJumpForward = 239,      // Placeholder
+    InstrumentedNotTaken = 240,         // Placeholder
+    InstrumentedPopJumpIfTrue = 241,    // Placeholder
+    InstrumentedPopJumpIfFalse = 242,   // Placeholder
+    InstrumentedPopJumpIfNone = 243,    // Placeholder
+    InstrumentedPopJumpIfNotNone = 244, // Placeholder
+    InstrumentedResume = 245,           // Placeholder
+    InstrumentedReturnValue = 246,      // Placeholder
+    InstrumentedYieldValue = 247,       // Placeholder
+    InstrumentedEndAsyncFor = 248,      // Placeholder
+    InstrumentedLoadSuperAttr = 249,    // Placeholder
+    InstrumentedCall = 250,             // Placeholder
+    InstrumentedCallKw = 251,           // Placeholder
+    InstrumentedCallFunctionEx = 252,   // Placeholder
+    InstrumentedJumpBackward = 253,     // Placeholder
+    InstrumentedLine = 254,             // Placeholder
+    EnterExecutor = 255,                // Placeholder
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -400,42 +413,31 @@ impl TryFrom<u8> for Instruction {
 
     #[inline]
     fn try_from(value: u8) -> Result<Self, MarshalError> {
-        // CPython-compatible opcodes (0-118)
+        // CPython-compatible opcodes (0-120)
         let cpython_start = u8::from(Self::Cache);
         let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
 
-        // Resume has a non-contiguous opcode (149)
+        // Resume has a non-contiguous opcode (128)
         let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+        let enter_executor_id = u8::from(Self::EnterExecutor);
 
         let specialized_start = u8::from(Self::BinaryOpAddFloat);
         let specialized_end = u8::from(Self::UnpackSequenceTwoTuple);
 
-        let instrumented_start = u8::from(Self::InstrumentedResume);
+        let instrumented_start = u8::from(Self::InstrumentedEndFor);
         let instrumented_end = u8::from(Self::InstrumentedLine);
 
-        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
+        // RustPython-only opcodes (explicit list to avoid gaps)
         let custom_ops: &[u8] = &[
-            u8::from(Self::Break {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::BuildListFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildMapForCall {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildSetFromTuples {
-                size: Arg::marker(),
-            }),
-            u8::from(Self::BuildTupleFromIter),
-            u8::from(Self::BuildTupleFromTuples {
+            u8::from(Self::BeforeAsyncWith),
+            u8::from(Self::BeforeWith),
+            u8::from(Self::BinarySubscr),
+            u8::from(Self::BuildConstKeyMap {
                 size: Arg::marker(),
             }),
-            u8::from(Self::BuildTemplate),
-            u8::from(Self::BuildInterpolation {
-                oparg: Arg::marker(),
+            u8::from(Self::Break {
+                target: Arg::marker(),
             }),
-            // 127 is unused
             u8::from(Self::Continue {
                 target: Arg::marker(),
             }),
@@ -446,12 +448,15 @@ impl TryFrom<u8> for Instruction {
                 target: Arg::marker(),
             }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
+            u8::from(Self::LoadAssertionError),
+            u8::from(Self::ReturnConst { idx: Arg::marker() }),
             u8::from(Self::SetExcInfo),
             u8::from(Self::Subscript),
         ];
 
         if (cpython_start..=cpython_end).contains(&value)
             || value == resume_id
+            || value == enter_executor_id
             || custom_ops.contains(&value)
             || (specialized_start..=specialized_end).contains(&value)
             || (instrumented_start..=instrumented_end).contains(&value)
@@ -501,9 +506,11 @@ impl InstructionMetadata for Instruction {
     fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
         match self {
             Self::Nop => 0,
+            Self::NotTaken => 0,
             Self::ImportName { .. } => -1,
             Self::ImportFrom { .. } => 1,
             Self::LoadFast(_) => 1,
+            Self::LoadFastBorrow(_) => 1,
             Self::LoadFastAndClear(_) => 1,
             Self::LoadName(_) => 1,
             Self::LoadGlobal(_) => 1,
@@ -524,7 +531,10 @@ impl InstructionMetadata for Instruction {
             Self::LoadAttr { .. } => 0,
             Self::StoreAttr { .. } => -2,
             Self::DeleteAttr { .. } => -1,
+            Self::LoadCommonConstant { .. } => 1,
             Self::LoadConst { .. } => 1,
+            Self::LoadSmallInt { .. } => 1,
+            Self::LoadSpecial { .. } => 0,
             Self::Reserved => 0,
             Self::BinaryOp { .. } => -1,
             Self::CompareOp { .. } => -1,
@@ -556,7 +566,7 @@ impl InstructionMetadata for Instruction {
                 }
             }
             Self::MakeFunction => {
-                // CPython 3.13 style: MakeFunction only pops code object
+                // CPython 3.14 style: MakeFunction only pops code object
                 -1 + 1 // pop code, push function
             }
             Self::SetFunctionAttribute { .. } => {
@@ -615,21 +625,14 @@ impl InstructionMetadata for Instruction {
             }
             Self::BuildString { size } => -(size.get(arg) as i32) + 1,
             Self::BuildTuple { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildTupleFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
             Self::BuildList { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildListFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
             Self::BuildSet { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
-            Self::BuildTupleFromIter => 0,
             Self::BuildMap { size } => {
                 let nargs = size.get(arg) * 2;
                 -(nargs as i32) + 1
             }
-            Self::BuildMapForCall { size } => {
-                let nargs = size.get(arg);
-                -(nargs as i32) + 1
-            }
             Self::DictUpdate { .. } => -1,
+            Self::DictMerge { .. } => -1,
             Self::BuildSlice { argc } => {
                 // push 1
                 // pops either 2/3
@@ -641,7 +644,9 @@ impl InstructionMetadata for Instruction {
                     .get() as i32)
             }
             Self::ListAppend { .. } => -1,
+            Self::ListExtend { .. } => -1,
             Self::SetAdd { .. } => -1,
+            Self::SetUpdate { .. } => -1,
             Self::MapAdd { .. } => -2,
             Self::LoadBuildClass => 1,
             Self::UnpackSequence { size } => -1 + size.get(arg) as i32,
@@ -650,6 +655,7 @@ impl InstructionMetadata for Instruction {
                 -1 + before as i32 + 1 + after as i32
             }
             Self::PopExcept => 0,
+            Self::PopIter => -1,
             Self::GetAwaitable => 0,
             Self::BeforeAsyncWith => 1,
             Self::GetAIter => 0,
@@ -682,18 +688,16 @@ impl InstructionMetadata for Instruction {
             Self::LoadLocals => 0,
             Self::ReturnGenerator => 0,
             Self::StoreSlice => 0,
-            Self::DictMerge { .. } => -1,
             Self::BuildConstKeyMap { .. } => 0,
             Self::CopyFreeVars { .. } => 0,
             Self::EnterExecutor => 0,
             Self::JumpBackwardNoInterrupt { .. } => 0,
             Self::JumpBackward { .. } => 0,
             Self::JumpForward { .. } => 0,
-            Self::ListExtend { .. } => -1,
             Self::LoadFastCheck(_) => 0,
-            Self::LoadFastLoadFast { .. } => 0,
+            Self::LoadFastLoadFast { .. } => 2,
+            Self::LoadFastBorrowLoadFastBorrow { .. } => 2,
             Self::LoadFromDictOrGlobals(_) => 0,
-            Self::SetUpdate { .. } => -1,
             Self::MakeCell(_) => 0,
             Self::StoreFastStoreFast { .. } => 0,
             Self::PopJumpIfNone { .. } => 0,
@@ -701,6 +705,7 @@ impl InstructionMetadata for Instruction {
             Self::BinaryOpAddFloat => 0,
             Self::BinaryOpAddInt => 0,
             Self::BinaryOpAddUnicode => 0,
+            Self::BinaryOpExtend => 0,
             Self::BinaryOpMultiplyFloat => 0,
             Self::BinaryOpMultiplyInt => 0,
             Self::BinaryOpSubtractFloat => 0,
@@ -708,6 +713,7 @@ impl InstructionMetadata for Instruction {
             Self::BinarySubscrDict => 0,
             Self::BinarySubscrGetitem => 0,
             Self::BinarySubscrListInt => 0,
+            Self::BinarySubscrListSlice => 0,
             Self::BinarySubscrStrInt => 0,
             Self::BinarySubscrTupleInt => 0,
             Self::CallAllocAndEnterInit => 0,
@@ -718,6 +724,9 @@ impl InstructionMetadata for Instruction {
             Self::CallBuiltinFastWithKeywords => 0,
             Self::CallBuiltinO => 0,
             Self::CallIsinstance => 0,
+            Self::CallKwBoundMethod => 0,
+            Self::CallKwNonPy => 0,
+            Self::CallKwPy => 0,
             Self::CallLen => 0,
             Self::CallListAppend => 0,
             Self::CallMethodDescriptorFast => 0,
@@ -739,7 +748,10 @@ impl InstructionMetadata for Instruction {
             Self::ForIterList => 0,
             Self::ForIterRange => 0,
             Self::ForIterTuple => 0,
+            Self::JumpBackwardJit => 0,
+            Self::JumpBackwardNoJit => 0,
             Self::LoadAttrClass => 0,
+            Self::LoadAttrClassWithMetaclassCheck => 0,
             Self::LoadAttrGetattributeOverridden => 0,
             Self::LoadAttrInstanceValue => 0,
             Self::LoadAttrMethodLazyDict => 0,
@@ -751,6 +763,8 @@ impl InstructionMetadata for Instruction {
             Self::LoadAttrProperty => 0,
             Self::LoadAttrSlot => 0,
             Self::LoadAttrWithHint => 0,
+            Self::LoadConstImmortal => 0,
+            Self::LoadConstMortal => 0,
             Self::LoadGlobalBuiltin => 0,
             Self::LoadGlobalModule => 0,
             Self::LoadSuperAttrAttr => 0,
@@ -771,24 +785,26 @@ impl InstructionMetadata for Instruction {
             Self::UnpackSequenceList => 0,
             Self::UnpackSequenceTuple => 0,
             Self::UnpackSequenceTwoTuple => 0,
-            Self::InstrumentedResume => 0,
             Self::InstrumentedEndFor => 0,
+            Self::InstrumentedPopIter => -1,
             Self::InstrumentedEndSend => 0,
-            Self::InstrumentedReturnValue => 0,
-            Self::InstrumentedReturnConst => 0,
-            Self::InstrumentedYieldValue => 0,
-            Self::InstrumentedLoadSuperAttr => 0,
             Self::InstrumentedForIter => 0,
-            Self::InstrumentedCall => 0,
-            Self::InstrumentedCallKw => 0,
-            Self::InstrumentedCallFunctionEx => 0,
             Self::InstrumentedInstruction => 0,
             Self::InstrumentedJumpForward => 0,
+            Self::InstrumentedNotTaken => 0,
             Self::InstrumentedJumpBackward => 0,
             Self::InstrumentedPopJumpIfTrue => 0,
             Self::InstrumentedPopJumpIfFalse => 0,
             Self::InstrumentedPopJumpIfNone => 0,
             Self::InstrumentedPopJumpIfNotNone => 0,
+            Self::InstrumentedResume => 0,
+            Self::InstrumentedReturnValue => 0,
+            Self::InstrumentedYieldValue => 0,
+            Self::InstrumentedEndAsyncFor => -2,
+            Self::InstrumentedLoadSuperAttr => 0,
+            Self::InstrumentedCall => 0,
+            Self::InstrumentedCallKw => 0,
+            Self::InstrumentedCallFunctionEx => 0,
             Self::InstrumentedLine => 0,
             // BuildTemplate: pops [strings_tuple, interpolations_tuple], pushes [template]
             Self::BuildTemplate => -1,
@@ -860,16 +876,11 @@ impl InstructionMetadata for Instruction {
             Self::BinarySubscr => w!(BINARY_SUBSCR),
             Self::Break { target } => w!(BREAK, target),
             Self::BuildList { size } => w!(BUILD_LIST, size),
-            Self::BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
             Self::BuildMap { size } => w!(BUILD_MAP, size),
-            Self::BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
             Self::BuildSet { size } => w!(BUILD_SET, size),
-            Self::BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
             Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
             Self::BuildString { size } => w!(BUILD_STRING, size),
             Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
-            Self::BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
-            Self::BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
             Self::Call { nargs } => w!(CALL, nargs),
             Self::CallFunctionEx => w!(CALL_FUNCTION_EX),
             Self::CallKw { nargs } => w!(CALL_KW, nargs),
@@ -889,6 +900,7 @@ impl InstructionMetadata for Instruction {
             Self::DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
             Self::DeleteName(idx) => w!(DELETE_NAME, name = idx),
             Self::DeleteSubscr => w!(DELETE_SUBSCR),
+            Self::DictMerge { index } => w!(DICT_MERGE, index),
             Self::DictUpdate { index } => w!(DICT_UPDATE, index),
             Self::EndAsyncFor => w!(END_ASYNC_FOR),
             Self::EndSend => w!(END_SEND),
@@ -912,6 +924,7 @@ impl InstructionMetadata for Instruction {
             Self::JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
             Self::JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
             Self::ListAppend { i } => w!(LIST_APPEND, i),
+            Self::ListExtend { i } => w!(LIST_EXTEND, i),
             Self::LoadAttr { idx } => {
                 let encoded = idx.get(arg);
                 let (name_idx, is_method) = decode_load_attr_arg(encoded);
@@ -967,6 +980,7 @@ impl InstructionMetadata for Instruction {
             Self::SetExcInfo => w!(SET_EXC_INFO),
             Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
             Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
+            Self::SetUpdate { i } => w!(SET_UPDATE, i),
             Self::StoreAttr { idx } => w!(STORE_ATTR, name = idx),
             Self::StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
             Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 6311646c5fc..ea9177a3d7c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -664,13 +664,6 @@ impl ExecutingFrame<'_> {
                     target: target.get(arg),
                 },
             ),
-            Instruction::BuildListFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
             Instruction::BuildList { size } => {
                 let sz = size.get(arg) as usize;
                 let elements = self.pop_multiple(sz).collect();
@@ -678,22 +671,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            Instruction::BuildMapForCall { size } => {
-                self.execute_build_map_for_call(vm, size.get(arg))
-            }
             Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            Instruction::BuildSetFromTuples { size } => {
-                let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    // SAFETY: trust compiler
-                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
-                    for item in tup.iter() {
-                        set.add(item.clone(), vm)?;
-                    }
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
             Instruction::BuildSet { size } => {
                 let set = PySet::default().into_ref(&vm.ctx);
                 for element in self.pop_multiple(size.get(arg) as usize) {
@@ -721,21 +699,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            Instruction::BuildTupleFromIter => {
-                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
-                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
-                    let list_obj = vm.ctx.new_tuple(elements);
-                    self.push_value(list_obj.into());
-                }
-                Ok(None)
-            }
-            Instruction::BuildTupleFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
             Instruction::BuildTuple { size } => {
                 let elements = self.pop_multiple(size.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
@@ -1938,16 +1901,6 @@ impl ExecutingFrame<'_> {
             })
     }
 
-    unsafe fn flatten_tuples(&mut self, size: usize) -> Vec<PyObjectRef> {
-        let mut elements = Vec::new();
-        for tup in self.pop_multiple(size) {
-            // SAFETY: caller ensures that the elements are tuples
-            let tup = unsafe { tup.downcast_unchecked::<PyTuple>() };
-            elements.extend(tup.iter().cloned());
-        }
-        elements
-    }
-
     #[cfg_attr(feature = "flame-it", flame("Frame"))]
     fn import(&mut self, vm: &VirtualMachine, module_name: Option<&Py<PyStr>>) -> PyResult<()> {
         let module_name = module_name.unwrap_or(vm.ctx.empty_str);
@@ -2155,35 +2108,6 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    fn execute_build_map_for_call(&mut self, vm: &VirtualMachine, size: u32) -> FrameResult {
-        let size = size as usize;
-        let map_obj = vm.ctx.new_dict();
-        for obj in self.pop_multiple(size) {
-            // Use keys() method for all mapping objects to preserve order
-            Self::iterate_mapping_keys(vm, &obj, "keyword argument", |key| {
-                // Check for keyword argument restrictions
-                if key.downcast_ref::<PyStr>().is_none() {
-                    return Err(vm.new_type_error("keywords must be strings"));
-                }
-                if map_obj.contains_key(&*key, vm) {
-                    let key_repr = &key.repr(vm)?;
-                    let msg = format!(
-                        "got multiple values for keyword argument {}",
-                        key_repr.as_str()
-                    );
-                    return Err(vm.new_type_error(msg));
-                }
-
-                let value = obj.get_item(&*key, vm)?;
-                map_obj.set_item(&*key, value, vm)?;
-                Ok(())
-            })?;
-        }
-
-        self.push_value(map_obj.into());
-        Ok(None)
-    }
-
     fn execute_build_slice(
         &mut self,
         vm: &VirtualMachine,
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
index bd42341ef76..a75a6f47de6 100644
--- a/crates/vm/src/version.rs
+++ b/crates/vm/src/version.rs
@@ -129,7 +129,7 @@ pub fn get_git_datetime() -> String {
 }
 
 // Must be aligned to Lib/importlib/_bootstrap_external.py
-pub const PYC_MAGIC_NUMBER: u16 = 2997;
+pub const PYC_MAGIC_NUMBER: u16 = 2996;
 
 // CPython format: magic_number | ('\r' << 16) | ('\n' << 24)
 // This protects against text-mode file reads

From ef2c0a6d9d38feb055fdf5a0c34c57c03eb6263b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 10:37:27 +0900
Subject: [PATCH 389/418] More FromArgs message (#6806)

---
 crates/stdlib/src/faulthandler.rs | 23 ++++-------
 crates/stdlib/src/ssl.rs          | 63 ++++++++++++++++---------------
 2 files changed, 39 insertions(+), 47 deletions(-)

diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
index eba5643b866..35238367f9f 100644
--- a/crates/stdlib/src/faulthandler.rs
+++ b/crates/stdlib/src/faulthandler.rs
@@ -4,8 +4,10 @@ pub(crate) use decl::make_module;
 #[pymodule(name = "faulthandler")]
 mod decl {
     use crate::vm::{
-        PyObjectRef, PyResult, VirtualMachine, builtins::PyFloat, frame::Frame,
-        function::OptionalArg, py_io::Write,
+        PyObjectRef, PyResult, VirtualMachine,
+        frame::Frame,
+        function::{ArgIntoFloat, OptionalArg},
+        py_io::Write,
     };
     use alloc::sync::Arc;
     use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
@@ -762,8 +764,8 @@ mod decl {
     #[derive(FromArgs)]
     #[allow(unused)]
     struct DumpTracebackLaterArgs {
-        #[pyarg(positional)]
-        timeout: PyObjectRef,
+        #[pyarg(positional, error_msg = "timeout must be a number (int or float)")]
+        timeout: ArgIntoFloat,
         #[pyarg(any, default = false)]
         repeat: bool,
         #[pyarg(any, default)]
@@ -774,18 +776,7 @@ mod decl {
 
     #[pyfunction]
     fn dump_traceback_later(args: DumpTracebackLaterArgs, vm: &VirtualMachine) -> PyResult<()> {
-        use num_traits::ToPrimitive;
-        // Convert timeout to f64 (accepting int or float)
-        let timeout: f64 = if let Some(float) = args.timeout.downcast_ref::<PyFloat>() {
-            float.to_f64()
-        } else if let Some(int) = args.timeout.try_index_opt(vm).transpose()? {
-            int.as_bigint()
-                .to_i64()
-                .ok_or_else(|| vm.new_overflow_error("timeout value is too large".to_owned()))?
-                as f64
-        } else {
-            return Err(vm.new_type_error("timeout must be a number (int or float)".to_owned()));
-        };
+        let timeout: f64 = args.timeout.into_float();
 
         if timeout <= 0.0 {
             return Err(vm.new_value_error("timeout must be greater than 0".to_owned()));
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
index 27d606358a1..0ead7244bc7 100644
--- a/crates/stdlib/src/ssl.rs
+++ b/crates/stdlib/src/ssl.rs
@@ -42,7 +42,9 @@ mod _ssl {
             VirtualMachine,
             builtins::{PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType, PyTypeRef},
             convert::IntoPyException,
-            function::{ArgBytesLike, ArgMemoryBuffer, FuncArgs, OptionalArg, PyComparisonValue},
+            function::{
+                ArgBytesLike, ArgMemoryBuffer, Either, FuncArgs, OptionalArg, PyComparisonValue,
+            },
             stdlib::warnings,
             types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
         },
@@ -821,20 +823,20 @@ mod _ssl {
 
     #[derive(FromArgs)]
     struct LoadVerifyLocationsArgs {
-        #[pyarg(any, optional)]
-        cafile: OptionalArg<Option<PyObjectRef>>,
-        #[pyarg(any, optional)]
-        capath: OptionalArg<Option<PyObjectRef>>,
-        #[pyarg(any, optional)]
-        cadata: OptionalArg<PyObjectRef>,
+        #[pyarg(any, optional, error_msg = "path should be a str or bytes")]
+        cafile: OptionalArg<Option<Either<PyStrRef, ArgBytesLike>>>,
+        #[pyarg(any, optional, error_msg = "path should be a str or bytes")]
+        capath: OptionalArg<Option<Either<PyStrRef, ArgBytesLike>>>,
+        #[pyarg(any, optional, error_msg = "cadata should be a str or bytes")]
+        cadata: OptionalArg<Option<Either<PyStrRef, ArgBytesLike>>>,
     }
 
     #[derive(FromArgs)]
     struct LoadCertChainArgs {
-        #[pyarg(any)]
-        certfile: PyObjectRef,
-        #[pyarg(any, optional)]
-        keyfile: OptionalArg<Option<PyObjectRef>>,
+        #[pyarg(any, error_msg = "path should be a str or bytes")]
+        certfile: Either<PyStrRef, ArgBytesLike>,
+        #[pyarg(any, optional, error_msg = "path should be a str or bytes")]
+        keyfile: OptionalArg<Option<Either<PyStrRef, ArgBytesLike>>>,
         #[pyarg(any, optional)]
         password: OptionalArg<PyObjectRef>,
     }
@@ -1229,7 +1231,7 @@ mod _ssl {
             // Check that at least one argument is provided
             let has_cafile = matches!(&args.cafile, OptionalArg::Present(Some(_)));
             let has_capath = matches!(&args.capath, OptionalArg::Present(Some(_)));
-            let has_cadata = matches!(&args.cadata, OptionalArg::Present(obj) if !vm.is_none(obj));
+            let has_cadata = matches!(&args.cadata, OptionalArg::Present(Some(_)));
 
             if !has_cafile && !has_capath && !has_cadata {
                 return Err(
@@ -1250,10 +1252,8 @@ mod _ssl {
                 None
             };
 
-            let cadata_parsed = if let OptionalArg::Present(ref cadata_obj) = args.cadata
-                && !vm.is_none(cadata_obj)
-            {
-                let is_string = PyStrRef::try_from_object(vm, cadata_obj.clone()).is_ok();
+            let cadata_parsed = if let OptionalArg::Present(Some(ref cadata_obj)) = args.cadata {
+                let is_string = matches!(cadata_obj, Either::A(_));
                 let data_vec = self.parse_cadata_arg(cadata_obj, vm)?;
                 Some((data_vec, is_string))
             } else {
@@ -1989,14 +1989,14 @@ mod _ssl {
         // Helper functions (private):
 
         /// Parse path argument (str or bytes) to string
-        fn parse_path_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
-            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
-                Ok(s.as_str().to_owned())
-            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
-                String::from_utf8(b.borrow_buf().to_vec())
-                    .map_err(|_| vm.new_value_error("path contains invalid UTF-8".to_owned()))
-            } else {
-                Err(vm.new_type_error("path should be a str or bytes".to_owned()))
+        fn parse_path_arg(
+            arg: &Either<PyStrRef, ArgBytesLike>,
+            vm: &VirtualMachine,
+        ) -> PyResult<String> {
+            match arg {
+                Either::A(s) => Ok(s.as_str().to_owned()),
+                Either::B(b) => String::from_utf8(b.borrow_buf().to_vec())
+                    .map_err(|_| vm.new_value_error("path contains invalid UTF-8".to_owned())),
             }
         }
 
@@ -2167,13 +2167,14 @@ mod _ssl {
         }
 
         /// Helper: Parse cadata argument (str or bytes)
-        fn parse_cadata_arg(&self, arg: &PyObject, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
-                Ok(s.as_str().as_bytes().to_vec())
-            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
-                Ok(b.borrow_buf().to_vec())
-            } else {
-                Err(vm.new_type_error("cadata should be a str or bytes".to_owned()))
+        fn parse_cadata_arg(
+            &self,
+            arg: &Either<PyStrRef, ArgBytesLike>,
+            _vm: &VirtualMachine,
+        ) -> PyResult<Vec<u8>> {
+            match arg {
+                Either::A(s) => Ok(s.as_str().as_bytes().to_vec()),
+                Either::B(b) => Ok(b.borrow_buf().to_vec()),
             }
         }
 

From 2bbb3d07c6d4580f8513434962a3fafb14d13e4b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Mon, 19 Jan 2026 19:42:45 +0900
Subject: [PATCH 390/418] _abc

---
 crates/vm/src/builtins/mod.rs   |   2 +-
 crates/vm/src/stdlib/_abc.rs    | 498 ++++++++++++++++++++++++++++++++
 crates/vm/src/stdlib/mod.rs     |   2 +
 crates/vm/src/stdlib/typevar.rs |   8 +-
 4 files changed, 506 insertions(+), 4 deletions(-)
 create mode 100644 crates/vm/src/stdlib/_abc.rs

diff --git a/crates/vm/src/builtins/mod.rs b/crates/vm/src/builtins/mod.rs
index c40f09bdef0..e9ca1f8b403 100644
--- a/crates/vm/src/builtins/mod.rs
+++ b/crates/vm/src/builtins/mod.rs
@@ -92,7 +92,7 @@ pub(crate) mod zip;
 pub use zip::PyZip;
 #[path = "union.rs"]
 pub(crate) mod union_;
-pub use union_::PyUnion;
+pub use union_::{PyUnion, make_union};
 pub(crate) mod descriptor;
 
 pub use float::try_to_bigint as try_f64_to_bigint;
diff --git a/crates/vm/src/stdlib/_abc.rs b/crates/vm/src/stdlib/_abc.rs
new file mode 100644
index 00000000000..06b403206c4
--- /dev/null
+++ b/crates/vm/src/stdlib/_abc.rs
@@ -0,0 +1,498 @@
+//! Implementation of the `_abc` module.
+//!
+//! This module provides the C implementation of Abstract Base Classes (ABCs)
+//! as defined in PEP 3119.
+
+pub(crate) use _abc::make_module;
+
+#[pymodule]
+mod _abc {
+    use crate::{
+        AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyFrozenSet, PyList, PySet, PyStr, PyTupleRef, PyTypeRef, PyWeak},
+        common::lock::PyRwLock,
+        convert::ToPyObject,
+        protocol::PyIterReturn,
+        types::Constructor,
+    };
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    // Global invalidation counter
+    static ABC_INVALIDATION_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    fn get_invalidation_counter() -> u64 {
+        ABC_INVALIDATION_COUNTER.load(Ordering::SeqCst)
+    }
+
+    fn increment_invalidation_counter() {
+        ABC_INVALIDATION_COUNTER.fetch_add(1, Ordering::SeqCst);
+    }
+
+    /// Internal state held by ABC machinery.
+    #[pyattr]
+    #[pyclass(name = "_abc_data", module = "_abc")]
+    #[derive(Debug, PyPayload)]
+    struct AbcData {
+        // WeakRef sets for registry and caches
+        registry: PyRwLock<Option<PyRef<PySet>>>,
+        cache: PyRwLock<Option<PyRef<PySet>>>,
+        negative_cache: PyRwLock<Option<PyRef<PySet>>>,
+        negative_cache_version: AtomicU64,
+    }
+
+    #[pyclass(with(Constructor))]
+    impl AbcData {
+        fn new() -> Self {
+            AbcData {
+                registry: PyRwLock::new(None),
+                cache: PyRwLock::new(None),
+                negative_cache: PyRwLock::new(None),
+                negative_cache_version: AtomicU64::new(get_invalidation_counter()),
+            }
+        }
+
+        fn get_cache_version(&self) -> u64 {
+            self.negative_cache_version.load(Ordering::SeqCst)
+        }
+
+        fn set_cache_version(&self, version: u64) {
+            self.negative_cache_version.store(version, Ordering::SeqCst);
+        }
+    }
+
+    impl Constructor for AbcData {
+        type Args = ();
+
+        fn py_new(
+            _cls: &crate::Py<crate::builtins::PyType>,
+            _args: Self::Args,
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(AbcData::new())
+        }
+    }
+
+    /// Get the _abc_impl attribute from an ABC class
+    fn get_impl(cls: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<AbcData>> {
+        let impl_obj = cls.get_attr("_abc_impl", vm)?;
+        impl_obj
+            .downcast::<AbcData>()
+            .map_err(|_| vm.new_type_error("_abc_impl is set to a wrong type".to_owned()))
+    }
+
+    /// Check if obj is in the weak set
+    fn in_weak_set(
+        set_lock: &PyRwLock<Option<PyRef<PySet>>>,
+        obj: &PyObject,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        let set_opt = set_lock.read();
+        let set = match &*set_opt {
+            Some(s) if !s.elements().is_empty() => s.clone(),
+            _ => return Ok(false),
+        };
+        drop(set_opt);
+
+        // Create a weak reference to the object
+        let weak_ref = match obj.downgrade(None, vm) {
+            Ok(w) => w,
+            Err(e) => {
+                // If we can't create a weakref (e.g., TypeError), the object can't be in the set
+                if e.class().is(vm.ctx.exceptions.type_error) {
+                    return Ok(false);
+                }
+                return Err(e);
+            }
+        };
+
+        // Use vm.call_method to call __contains__
+        let weak_ref_obj: PyObjectRef = weak_ref.into();
+        vm.call_method(set.as_ref(), "__contains__", (weak_ref_obj,))?
+            .try_to_bool(vm)
+    }
+
+    /// Add obj to the weak set
+    fn add_to_weak_set(
+        set_lock: &PyRwLock<Option<PyRef<PySet>>>,
+        obj: &PyObject,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let mut set_opt = set_lock.write();
+        let set = match &*set_opt {
+            Some(s) => s.clone(),
+            None => {
+                let new_set = PySet::default().into_ref(&vm.ctx);
+                *set_opt = Some(new_set.clone());
+                new_set
+            }
+        };
+        drop(set_opt);
+
+        // Create a weak reference to the object
+        let weak_ref = obj.downgrade(None, vm)?;
+        set.add(weak_ref.into(), vm)?;
+        Ok(())
+    }
+
+    /// Returns the current ABC cache token.
+    #[pyfunction]
+    fn get_cache_token() -> u64 {
+        get_invalidation_counter()
+    }
+
+    /// Compute set of abstract method names.
+    fn compute_abstract_methods(cls: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+        let mut abstracts = Vec::new();
+
+        // Stage 1: direct abstract methods
+        let ns = cls.get_attr("__dict__", vm)?;
+        let items = vm.call_method(&ns, "items", ())?;
+        let iter = items.get_iter(vm)?;
+
+        loop {
+            match iter.next(vm)? {
+                PyIterReturn::Return(item) => {
+                    let tuple: PyTupleRef = item
+                        .downcast()
+                        .map_err(|_| vm.new_type_error("items() returned non-tuple".to_owned()))?;
+                    let elements = tuple.as_slice();
+                    if elements.len() != 2 {
+                        return Err(vm.new_type_error(
+                            "items() returned item which size is not 2".to_owned(),
+                        ));
+                    }
+                    let key = &elements[0];
+                    let value = &elements[1];
+
+                    // Check if value has __isabstractmethod__ = True
+                    if let Ok(is_abstract) = value.get_attr("__isabstractmethod__", vm) {
+                        if is_abstract.try_to_bool(vm)? {
+                            abstracts.push(key.clone());
+                        }
+                    }
+                }
+                PyIterReturn::StopIteration(_) => break,
+            }
+        }
+
+        // Stage 2: inherited abstract methods
+        let bases: PyTupleRef = cls
+            .get_attr("__bases__", vm)?
+            .downcast()
+            .map_err(|_| vm.new_type_error("__bases__ is not a tuple".to_owned()))?;
+
+        for base in bases.iter() {
+            if let Ok(base_abstracts) = base.get_attr("__abstractmethods__", vm) {
+                let iter = base_abstracts.get_iter(vm)?;
+                loop {
+                    match iter.next(vm)? {
+                        PyIterReturn::Return(key) => {
+                            // Try to get the attribute from cls - key should be a string
+                            if let Some(key_str) = key.downcast_ref::<PyStr>() {
+                                if let Some(value) =
+                                    vm.get_attribute_opt(cls.to_owned(), key_str)?
+                                {
+                                    if let Ok(is_abstract) =
+                                        value.get_attr("__isabstractmethod__", vm)
+                                    {
+                                        if is_abstract.try_to_bool(vm)? {
+                                            abstracts.push(key);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        PyIterReturn::StopIteration(_) => break,
+                    }
+                }
+            }
+        }
+
+        // Set __abstractmethods__
+        let abstracts_set = PyFrozenSet::from_iter(vm, abstracts.into_iter())?;
+        cls.set_attr("__abstractmethods__", abstracts_set.into_pyobject(vm), vm)?;
+
+        Ok(())
+    }
+
+    /// Internal ABC helper for class set-up. Should be never used outside abc module.
+    #[pyfunction]
+    fn _abc_init(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        compute_abstract_methods(&cls, vm)?;
+
+        // Set up inheritance registry
+        let data = AbcData::new();
+        cls.set_attr("_abc_impl", data.to_pyobject(vm), vm)?;
+
+        Ok(())
+    }
+
+    /// Internal ABC helper for subclass registration. Should be never used outside abc module.
+    #[pyfunction]
+    fn _abc_register(
+        cls: PyObjectRef,
+        subclass: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        // Type check
+        if !subclass.class().fast_issubclass(vm.ctx.types.type_type) {
+            return Err(vm.new_type_error("Can only register classes".to_owned()));
+        }
+
+        // Check if already a subclass
+        if subclass.is_subclass(&cls, vm)? {
+            return Ok(subclass);
+        }
+
+        // Check for cycles
+        if cls.is_subclass(&subclass, vm)? {
+            return Err(vm.new_runtime_error("Refusing to create an inheritance cycle".to_owned()));
+        }
+
+        // Add to registry
+        let impl_data = get_impl(&cls, vm)?;
+        add_to_weak_set(&impl_data.registry, &subclass, vm)?;
+
+        // Invalidate negative cache
+        increment_invalidation_counter();
+
+        Ok(subclass)
+    }
+
+    /// Internal ABC helper for instance checks. Should be never used outside abc module.
+    #[pyfunction]
+    fn _abc_instancecheck(
+        cls: PyObjectRef,
+        instance: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        let impl_data = get_impl(&cls, vm)?;
+
+        // Get instance.__class__
+        let subclass = instance.get_attr("__class__", vm)?;
+
+        // Check cache
+        if in_weak_set(&impl_data.cache, &subclass, vm)? {
+            return Ok(vm.ctx.true_value.clone().into());
+        }
+
+        let subtype: PyObjectRef = instance.class().to_owned().into();
+        if subtype.is(&subclass) {
+            let invalidation_counter = get_invalidation_counter();
+            if impl_data.get_cache_version() == invalidation_counter {
+                if in_weak_set(&impl_data.negative_cache, &subclass, vm)? {
+                    return Ok(vm.ctx.false_value.clone().into());
+                }
+            }
+            // Fall back to __subclasscheck__
+            return vm.call_method(&cls, "__subclasscheck__", (subclass,));
+        }
+
+        // Call __subclasscheck__ on subclass
+        let result = vm.call_method(&cls, "__subclasscheck__", (subclass.clone(),))?;
+
+        match result.clone().try_to_bool(vm) {
+            Ok(true) => Ok(result),
+            Ok(false) => {
+                // Also try with subtype
+                vm.call_method(&cls, "__subclasscheck__", (subtype,))
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    /// Check if subclass is in registry (recursive)
+    fn subclasscheck_check_registry(
+        impl_data: &AbcData,
+        subclass: &PyObject,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<bool>> {
+        // Fast path: check if subclass is in weakref directly
+        if in_weak_set(&impl_data.registry, subclass, vm)? {
+            return Ok(Some(true));
+        }
+
+        let registry_opt = impl_data.registry.read();
+        let registry = match &*registry_opt {
+            Some(s) => s.clone(),
+            None => return Ok(None),
+        };
+        drop(registry_opt);
+
+        // Make a local copy to protect against concurrent modifications
+        let registry_copy = PyFrozenSet::from_iter(vm, registry.elements().into_iter())?;
+
+        for weak_ref_obj in registry_copy.elements() {
+            if let Ok(weak_ref) = weak_ref_obj.downcast::<PyWeak>() {
+                if let Some(rkey) = weak_ref.upgrade() {
+                    if subclass.to_owned().is_subclass(&rkey, vm)? {
+                        add_to_weak_set(&impl_data.cache, subclass, vm)?;
+                        return Ok(Some(true));
+                    }
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
+    /// Internal ABC helper for subclass checks. Should be never used outside abc module.
+    #[pyfunction]
+    fn _abc_subclasscheck(
+        cls: PyObjectRef,
+        subclass: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        // Type check
+        if !subclass.class().fast_issubclass(vm.ctx.types.type_type) {
+            return Err(vm.new_type_error("issubclass() arg 1 must be a class".to_owned()));
+        }
+
+        let impl_data = get_impl(&cls, vm)?;
+
+        // 1. Check cache
+        if in_weak_set(&impl_data.cache, &subclass, vm)? {
+            return Ok(true);
+        }
+
+        // 2. Check negative cache; may have to invalidate
+        let invalidation_counter = get_invalidation_counter();
+        if impl_data.get_cache_version() < invalidation_counter {
+            // Invalidate the negative cache
+            // Clone set ref and drop lock before calling into VM to avoid reentrancy
+            let set = impl_data.negative_cache.read().clone();
+            if let Some(ref set) = set {
+                vm.call_method(set.as_ref(), "clear", ())?;
+            }
+            impl_data.set_cache_version(invalidation_counter);
+        } else if in_weak_set(&impl_data.negative_cache, &subclass, vm)? {
+            return Ok(false);
+        }
+
+        // 3. Check the subclass hook
+        let ok = vm.call_method(&cls, "__subclasshook__", (subclass.clone(),))?;
+        if ok.is(&vm.ctx.true_value) {
+            add_to_weak_set(&impl_data.cache, &subclass, vm)?;
+            return Ok(true);
+        }
+        if ok.is(&vm.ctx.false_value) {
+            add_to_weak_set(&impl_data.negative_cache, &subclass, vm)?;
+            return Ok(false);
+        }
+        if !ok.is(&vm.ctx.not_implemented) {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.assertion_error.to_owned(),
+                "__subclasshook__ must return either False, True, or NotImplemented".to_owned(),
+            ));
+        }
+
+        // 4. Check if it's a direct subclass
+        let subclass_type: PyTypeRef = subclass
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type object".to_owned()))?;
+        let cls_type: PyTypeRef = cls
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected a type object".to_owned()))?;
+        if subclass_type.fast_issubclass(&cls_type) {
+            add_to_weak_set(&impl_data.cache, &subclass, vm)?;
+            return Ok(true);
+        }
+
+        // 5. Check if it's a subclass of a registered class (recursive)
+        if let Some(result) = subclasscheck_check_registry(&impl_data, &subclass, vm)? {
+            return Ok(result);
+        }
+
+        // 6. Check if it's a subclass of a subclass (recursive)
+        let subclasses: PyRef<PyList> = vm
+            .call_method(&cls, "__subclasses__", ())?
+            .downcast()
+            .map_err(|_| vm.new_type_error("__subclasses__() must return a list".to_owned()))?;
+
+        for scls in subclasses.borrow_vec().iter() {
+            if subclass.is_subclass(scls, vm)? {
+                add_to_weak_set(&impl_data.cache, &subclass, vm)?;
+                return Ok(true);
+            }
+        }
+
+        // No dice; update negative cache
+        add_to_weak_set(&impl_data.negative_cache, &subclass, vm)?;
+        Ok(false)
+    }
+
+    /// Internal ABC helper for cache and registry debugging.
+    #[pyfunction]
+    fn _get_dump(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let impl_data = get_impl(&cls, vm)?;
+
+        let registry = {
+            let r = impl_data.registry.read();
+            match &*r {
+                Some(s) => {
+                    // Use copy method to get a shallow copy
+                    vm.call_method(s.as_ref(), "copy", ())?
+                }
+                None => PySet::default().to_pyobject(vm),
+            }
+        };
+
+        let cache = {
+            let c = impl_data.cache.read();
+            match &*c {
+                Some(s) => vm.call_method(s.as_ref(), "copy", ())?,
+                None => PySet::default().to_pyobject(vm),
+            }
+        };
+
+        let negative_cache = {
+            let nc = impl_data.negative_cache.read();
+            match &*nc {
+                Some(s) => vm.call_method(s.as_ref(), "copy", ())?,
+                None => PySet::default().to_pyobject(vm),
+            }
+        };
+
+        let version = impl_data.get_cache_version();
+
+        Ok(vm.ctx.new_tuple(vec![
+            registry,
+            cache,
+            negative_cache,
+            vm.ctx.new_int(version).into(),
+        ]))
+    }
+
+    /// Internal ABC helper to reset registry of a given class.
+    #[pyfunction]
+    fn _reset_registry(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let impl_data = get_impl(&cls, vm)?;
+        // Clone set ref and drop lock before calling into VM to avoid reentrancy
+        let set = impl_data.registry.read().clone();
+        if let Some(ref set) = set {
+            vm.call_method(set.as_ref(), "clear", ())?;
+        }
+        Ok(())
+    }
+
+    /// Internal ABC helper to reset both caches of a given class.
+    #[pyfunction]
+    fn _reset_caches(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let impl_data = get_impl(&cls, vm)?;
+
+        // Clone set refs and drop locks before calling into VM to avoid reentrancy
+        let cache = impl_data.cache.read().clone();
+        if let Some(ref set) = cache {
+            vm.call_method(set.as_ref(), "clear", ())?;
+        }
+
+        let negative_cache = impl_data.negative_cache.read().clone();
+        if let Some(ref set) = negative_cache {
+            vm.call_method(set.as_ref(), "clear", ())?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/vm/src/stdlib/mod.rs b/crates/vm/src/stdlib/mod.rs
index e46f333a28b..85c28983d74 100644
--- a/crates/vm/src/stdlib/mod.rs
+++ b/crates/vm/src/stdlib/mod.rs
@@ -1,3 +1,4 @@
+mod _abc;
 #[cfg(feature = "ast")]
 pub(crate) mod ast;
 pub mod atexit;
@@ -87,6 +88,7 @@ pub fn get_module_inits() -> StdlibMap {
     modules! {
         #[cfg(all())]
         {
+            "_abc" => _abc::make_module,
             "atexit" => atexit::make_module,
             "_codecs" => codecs::make_module,
             "_collections" => collections::make_module,
diff --git a/crates/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
index 65249bfd075..5d5b1fc7b35 100644
--- a/crates/vm/src/stdlib/typevar.rs
+++ b/crates/vm/src/stdlib/typevar.rs
@@ -1,7 +1,7 @@
 // spell-checker:ignore typevarobject funcobj
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr},
+    builtins::{PyTuple, PyTupleRef, PyType, PyTypeRef, make_union, pystr::AsPyStr},
     common::lock::PyMutex,
     function::{FuncArgs, IntoFuncArgs, PyComparisonValue},
     protocol::PyNumberMethods,
@@ -250,7 +250,8 @@ impl AsNumber for TypeVar {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             or: Some(|a, b, vm| {
-                _call_typing_func_object(vm, "_make_union", (a.to_owned(), b.to_owned()))
+                let args = PyTuple::new_ref(vec![a.to_owned(), b.to_owned()], &vm.ctx);
+                Ok(make_union(&args, vm))
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
@@ -525,7 +526,8 @@ impl AsNumber for ParamSpec {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             or: Some(|a, b, vm| {
-                _call_typing_func_object(vm, "_make_union", (a.to_owned(), b.to_owned()))
+                let args = PyTuple::new_ref(vec![a.to_owned(), b.to_owned()], &vm.ctx);
+                Ok(make_union(&args, vm))
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };

From bb72418d9ecdbcad22965ef6b6b5b4851d74d3a7 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Mon, 19 Jan 2026 19:02:09 +0900
Subject: [PATCH 391/418] _typing.Union

---
 Lib/copyreg.py                         |   4 +-
 crates/vm/src/builtins/genericalias.rs |   6 +-
 crates/vm/src/builtins/type.rs         |  11 +-
 crates/vm/src/builtins/union.rs        | 285 +++++++++++++++++++++----
 crates/vm/src/stdlib/_abc.rs           |  89 ++++----
 crates/vm/src/stdlib/typevar.rs        |   4 +-
 crates/vm/src/stdlib/typing.rs         |   4 +-
 crates/vm/src/types/slot.rs            |   2 +-
 8 files changed, 294 insertions(+), 111 deletions(-)

diff --git a/Lib/copyreg.py b/Lib/copyreg.py
index 578392409b4..c9da81a6882 100644
--- a/Lib/copyreg.py
+++ b/Lib/copyreg.py
@@ -31,8 +31,8 @@ def pickle_complex(c):
 pickle(complex, pickle_complex, complex)
 
 def pickle_union(obj):
-    import functools, operator
-    return functools.reduce, (operator.or_, obj.__args__)
+    import typing, operator
+    return operator.getitem, (typing.Union, obj.__args__)
 
 pickle(type(int | str), pickle_union)
 
diff --git a/crates/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
index e9150e4c088..21034e08f0e 100644
--- a/crates/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -235,11 +235,11 @@ impl PyGenericAlias {
         Err(vm.new_type_error("issubclass() argument 2 cannot be a parameterized generic"))
     }
 
-    fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         type_::or_(other, zelf, vm)
     }
 
-    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         type_::or_(zelf, other, vm)
     }
 }
@@ -509,7 +509,7 @@ impl AsMapping for PyGenericAlias {
 impl AsNumber for PyGenericAlias {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            or: Some(|a, b, vm| Ok(PyGenericAlias::__or__(a.to_owned(), b.to_owned(), vm))),
+            or: Some(|a, b, vm| PyGenericAlias::__or__(a.to_owned(), b.to_owned(), vm)),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
         &AS_NUMBER
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 829f7d4439a..510c3fb8491 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -20,7 +20,6 @@ use crate::{
         borrow::BorrowedValue,
         lock::{PyRwLock, PyRwLockReadGuard},
     },
-    convert::ToPyResult,
     function::{FuncArgs, KwArgs, OptionalArg, PyMethodDef, PySetterValue},
     object::{Traverse, TraverseFn},
     protocol::{PyIterReturn, PyNumberMethods},
@@ -1038,11 +1037,11 @@ impl PyType {
         )
     }
 
-    pub fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    pub fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         or_(other, zelf, vm)
     }
 
-    pub fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    pub fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         or_(zelf, other, vm)
     }
 
@@ -1850,7 +1849,7 @@ impl Callable for PyType {
 impl AsNumber for PyType {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            or: Some(|a, b, vm| or_(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            or: Some(|a, b, vm| or_(a.to_owned(), b.to_owned(), vm)),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
         &AS_NUMBER
@@ -2013,9 +2012,9 @@ pub(crate) fn call_slot_new(
     slot_new(subtype, args, vm)
 }
 
-pub(crate) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+pub(crate) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     if !union_::is_unionable(zelf.clone(), vm) || !union_::is_unionable(other.clone(), vm) {
-        return vm.ctx.not_implemented();
+        return Ok(vm.ctx.not_implemented());
     }
 
     let tuple = PyTuple::new_ref(vec![zelf, other], &vm.ctx);
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
index b5e12dcb3c8..9856235ecf4 100644
--- a/crates/vm/src/builtins/union.rs
+++ b/crates/vm/src/builtins/union.rs
@@ -2,10 +2,10 @@ use super::{genericalias, type_};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     atomic_func,
-    builtins::{PyFrozenSet, PyGenericAlias, PyStr, PyTuple, PyTupleRef, PyType},
+    builtins::{PyFrozenSet, PySet, PyStr, PyTuple, PyTupleRef, PyType},
     class::PyClassImpl,
     common::hash,
-    convert::{ToPyObject, ToPyResult},
+    convert::ToPyObject,
     function::PyComparisonValue,
     protocol::{PyMappingMethods, PyNumberMethods},
     stdlib::typing::TypeAliasType,
@@ -16,9 +16,13 @@ use std::sync::LazyLock;
 
 const CLS_ATTRS: &[&str] = &["__module__"];
 
-#[pyclass(module = "types", name = "UnionType", traverse)]
+#[pyclass(module = "typing", name = "Union", traverse)]
 pub struct PyUnion {
     args: PyTupleRef,
+    /// Frozenset of hashable args, or None if all args were hashable
+    hashable_args: Option<PyRef<PyFrozenSet>>,
+    /// Tuple of initially unhashable args, or None if all args were hashable
+    unhashable_args: Option<PyTupleRef>,
     parameters: PyTupleRef,
 }
 
@@ -36,9 +40,15 @@ impl PyPayload for PyUnion {
 }
 
 impl PyUnion {
-    pub fn new(args: PyTupleRef, vm: &VirtualMachine) -> Self {
-        let parameters = make_parameters(&args, vm);
-        Self { args, parameters }
+    /// Create a new union from dedup result (internal use)
+    fn from_components(result: UnionComponents, vm: &VirtualMachine) -> PyResult<Self> {
+        let parameters = make_parameters(&result.args, vm)?;
+        Ok(Self {
+            args: result.args,
+            hashable_args: result.hashable_args,
+            unhashable_args: result.unhashable_args,
+            parameters,
+        })
     }
 
     /// Direct access to args field, matching CPython's _Py_union_args
@@ -88,10 +98,25 @@ impl PyUnion {
 }
 
 #[pyclass(
-    flags(BASETYPE),
+    flags(DISALLOW_INSTANTIATION),
     with(Hashable, Comparable, AsMapping, AsNumber, Representable)
 )]
 impl PyUnion {
+    #[pygetset]
+    fn __name__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str("Union").into()
+    }
+
+    #[pygetset]
+    fn __qualname__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str("Union").into()
+    }
+
+    #[pygetset]
+    fn __origin__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.types.union_type.to_owned().into()
+    }
+
     #[pygetset]
     fn __parameters__(&self) -> PyObjectRef {
         self.parameters.clone().into()
@@ -136,17 +161,35 @@ impl PyUnion {
         }
     }
 
-    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         type_::or_(zelf, other, vm)
     }
 
+    #[pymethod]
+    fn __mro_entries__(zelf: PyRef<Self>, _args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_type_error(format!("Cannot subclass {}", zelf.repr(vm)?)))
+    }
+
     #[pyclassmethod]
     fn __class_getitem__(
-        cls: crate::builtins::PyTypeRef,
+        _cls: crate::builtins::PyTypeRef,
         args: PyObjectRef,
         vm: &VirtualMachine,
-    ) -> PyGenericAlias {
-        PyGenericAlias::from_args(cls, args, vm)
+    ) -> PyResult {
+        // Convert args to tuple if not already
+        let args_tuple = if let Some(tuple) = args.downcast_ref::<PyTuple>() {
+            tuple.to_owned()
+        } else {
+            PyTuple::new_ref(vec![args], &vm.ctx)
+        };
+
+        // Check for empty union
+        if args_tuple.is_empty() {
+            return Err(vm.new_type_error("Cannot create empty Union"));
+        }
+
+        // Create union using make_union to properly handle None -> NoneType conversion
+        make_union(&args_tuple, vm)
     }
 }
 
@@ -159,9 +202,10 @@ pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
         || obj.downcast_ref::<TypeAliasType>().is_some()
 }
 
-fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
     let parameters = genericalias::make_parameters(args, vm);
-    dedup_and_flatten_args(&parameters, vm)
+    let result = dedup_and_flatten_args(&parameters, vm)?;
+    Ok(result.args)
 }
 
 fn flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
@@ -180,6 +224,12 @@ fn flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
             flattened_args.extend(pyref.args.iter().cloned());
         } else if vm.is_none(arg) {
             flattened_args.push(vm.ctx.types.none_type.to_owned().into());
+        } else if arg.downcast_ref::<PyStr>().is_some() {
+            // Convert string to ForwardRef
+            match string_to_forwardref(arg.clone(), vm) {
+                Ok(fr) => flattened_args.push(fr),
+                Err(_) => flattened_args.push(arg.clone()),
+            }
         } else {
             flattened_args.push(arg.clone());
         };
@@ -188,31 +238,105 @@ fn flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
     PyTuple::new_ref(flattened_args, &vm.ctx)
 }
 
-fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+fn string_to_forwardref(arg: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Import annotationlib.ForwardRef and create a ForwardRef
+    let annotationlib = vm.import("annotationlib", 0)?;
+    let forwardref_cls = annotationlib.get_attr("ForwardRef", vm)?;
+    forwardref_cls.call((arg,), vm)
+}
+
+/// Components for creating a PyUnion after deduplication
+struct UnionComponents {
+    /// All unique args in order
+    args: PyTupleRef,
+    /// Frozenset of hashable args (for fast equality comparison)
+    hashable_args: Option<PyRef<PyFrozenSet>>,
+    /// Tuple of unhashable args at creation time (for hash error message)
+    unhashable_args: Option<PyTupleRef>,
+}
+
+fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyResult<UnionComponents> {
     let args = flatten_args(args, vm);
 
+    // Use set-based deduplication like CPython:
+    // - For hashable elements: use Python's set semantics (hash + equality)
+    // - For unhashable elements: use equality comparison
+    //
+    // This avoids calling __eq__ when hashes differ, matching CPython behavior
+    // where `int | BadType` doesn't raise even if BadType.__eq__ raises.
+
     let mut new_args: Vec<PyObjectRef> = Vec::with_capacity(args.len());
+
+    // Track hashable elements using a Python set (uses hash + equality)
+    let hashable_set = PySet::default().into_ref(&vm.ctx);
+    let mut hashable_list: Vec<PyObjectRef> = Vec::new();
+    let mut unhashable_list: Vec<PyObjectRef> = Vec::new();
+
     for arg in &*args {
-        if !new_args.iter().any(|param| {
-            param
-                .rich_compare_bool(arg, PyComparisonOp::Eq, vm)
-                .unwrap_or_default()
-        }) {
-            new_args.push(arg.clone());
+        // Try to hash the element first
+        match arg.hash(vm) {
+            Ok(_) => {
+                // Element is hashable - use set for deduplication
+                // Set membership uses hash first, then equality only if hashes match
+                let contains = vm
+                    .call_method(hashable_set.as_ref(), "__contains__", (arg.clone(),))
+                    .and_then(|r| r.try_to_bool(vm))?;
+                if !contains {
+                    hashable_set.add(arg.clone(), vm)?;
+                    hashable_list.push(arg.clone());
+                    new_args.push(arg.clone());
+                }
+            }
+            Err(_) => {
+                // Element is unhashable - use equality comparison
+                let mut is_duplicate = false;
+                for existing in &unhashable_list {
+                    match existing.rich_compare_bool(arg, PyComparisonOp::Eq, vm) {
+                        Ok(true) => {
+                            is_duplicate = true;
+                            break;
+                        }
+                        Ok(false) => continue,
+                        Err(e) => return Err(e),
+                    }
+                }
+                if !is_duplicate {
+                    unhashable_list.push(arg.clone());
+                    new_args.push(arg.clone());
+                }
+            }
         }
     }
 
     new_args.shrink_to_fit();
 
-    PyTuple::new_ref(new_args, &vm.ctx)
+    // Create hashable_args frozenset if there are hashable elements
+    let hashable_args = if !hashable_list.is_empty() {
+        Some(PyFrozenSet::from_iter(vm, hashable_list.into_iter())?.into_ref(&vm.ctx))
+    } else {
+        None
+    };
+
+    // Create unhashable_args tuple if there are unhashable elements
+    let unhashable_args = if !unhashable_list.is_empty() {
+        Some(PyTuple::new_ref(unhashable_list, &vm.ctx))
+    } else {
+        None
+    };
+
+    Ok(UnionComponents {
+        args: PyTuple::new_ref(new_args, &vm.ctx),
+        hashable_args,
+        unhashable_args,
+    })
 }
 
-pub fn make_union(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyObjectRef {
-    let args = dedup_and_flatten_args(args, vm);
-    match args.len() {
-        1 => args[0].to_owned(),
-        _ => PyUnion::new(args, vm).to_pyobject(vm),
-    }
+pub fn make_union(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyResult {
+    let result = dedup_and_flatten_args(args, vm)?;
+    Ok(match result.args.len() {
+        1 => result.args[0].to_owned(),
+        _ => PyUnion::from_components(result, vm)?.to_pyobject(vm),
+    })
 }
 
 impl PyUnion {
@@ -224,14 +348,15 @@ impl PyUnion {
             needle,
             vm,
         )?;
-        let mut res;
+        let res;
         if new_args.is_empty() {
-            res = make_union(&new_args, vm);
+            res = make_union(&new_args, vm)?;
         } else {
-            res = new_args[0].to_owned();
+            let mut tmp = new_args[0].to_owned();
             for arg in new_args.iter().skip(1) {
-                res = vm._or(&res, arg)?;
+                tmp = vm._or(&tmp, arg)?;
             }
+            res = tmp;
         }
 
         Ok(res)
@@ -254,7 +379,7 @@ impl AsMapping for PyUnion {
 impl AsNumber for PyUnion {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            or: Some(|a, b, vm| PyUnion::__or__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            or: Some(|a, b, vm| PyUnion::__or__(a.to_owned(), b.to_owned(), vm)),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
         &AS_NUMBER
@@ -270,15 +395,62 @@ impl Comparable for PyUnion {
     ) -> PyResult<PyComparisonValue> {
         op.eq_only(|| {
             let other = class_or_notimplemented!(Self, other);
-            let a = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
-            let b = PyFrozenSet::from_iter(vm, other.args.into_iter().cloned())?;
-            Ok(PyComparisonValue::Implemented(
-                a.into_pyobject(vm).as_object().rich_compare_bool(
-                    b.into_pyobject(vm).as_object(),
-                    PyComparisonOp::Eq,
-                    vm,
-                )?,
-            ))
+
+            // Check if lengths are equal
+            if zelf.args.len() != other.args.len() {
+                return Ok(PyComparisonValue::Implemented(false));
+            }
+
+            // Fast path: if both unions have all hashable args, compare frozensets directly
+            // Always use Eq here since eq_only handles Ne by negating the result
+            if zelf.unhashable_args.is_none()
+                && other.unhashable_args.is_none()
+                && let (Some(a), Some(b)) = (&zelf.hashable_args, &other.hashable_args)
+            {
+                let eq = a
+                    .as_object()
+                    .rich_compare_bool(b.as_object(), PyComparisonOp::Eq, vm)?;
+                return Ok(PyComparisonValue::Implemented(eq));
+            }
+
+            // Slow path: O(n^2) nested loop comparison for unhashable elements
+            // Check if all elements in zelf.args are in other.args
+            for arg_a in &*zelf.args {
+                let mut found = false;
+                for arg_b in &*other.args {
+                    match arg_a.rich_compare_bool(arg_b, PyComparisonOp::Eq, vm) {
+                        Ok(true) => {
+                            found = true;
+                            break;
+                        }
+                        Ok(false) => continue,
+                        Err(e) => return Err(e), // Propagate comparison errors
+                    }
+                }
+                if !found {
+                    return Ok(PyComparisonValue::Implemented(false));
+                }
+            }
+
+            // Check if all elements in other.args are in zelf.args (for symmetry)
+            for arg_b in &*other.args {
+                let mut found = false;
+                for arg_a in &*zelf.args {
+                    match arg_b.rich_compare_bool(arg_a, PyComparisonOp::Eq, vm) {
+                        Ok(true) => {
+                            found = true;
+                            break;
+                        }
+                        Ok(false) => continue,
+                        Err(e) => return Err(e), // Propagate comparison errors
+                    }
+                }
+                if !found {
+                    return Ok(PyComparisonValue::Implemented(false));
+                }
+            }
+
+            Ok(PyComparisonValue::Implemented(true))
         })
     }
 }
@@ -286,7 +458,36 @@ impl Comparable for PyUnion {
 impl Hashable for PyUnion {
     #[inline]
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        let set = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
+        // If there are any unhashable args from creation time, the union is unhashable
+        if let Some(ref unhashable_args) = zelf.unhashable_args {
+            let n = unhashable_args.len();
+            // Try to hash each previously unhashable arg to get an error
+            for arg in unhashable_args.iter() {
+                arg.hash(vm)?;
+            }
+            // All previously unhashable args somehow became hashable
+            // But still raise an error to maintain consistent hashing
+            return Err(vm.new_type_error(format!(
+                "union contains {} unhashable element{}",
+                n,
+                if n > 1 { "s" } else { "" }
+            )));
+        }
+
+        // If we have a stored frozenset of hashable args, use that
+        if let Some(ref hashable_args) = zelf.hashable_args {
+            return PyFrozenSet::hash(hashable_args, vm);
+        }
+
+        // Fallback: compute hash from args
+        let mut args_to_hash = Vec::new();
+        for arg in &*zelf.args {
+            match arg.hash(vm) {
+                Ok(_) => args_to_hash.push(arg.clone()),
+                Err(e) => return Err(e),
+            }
+        }
+        let set = PyFrozenSet::from_iter(vm, args_to_hash.into_iter())?;
         PyFrozenSet::hash(&set.into_ref(&vm.ctx), vm)
     }
 }
diff --git a/crates/vm/src/stdlib/_abc.rs b/crates/vm/src/stdlib/_abc.rs
index 06b403206c4..ef528d95731 100644
--- a/crates/vm/src/stdlib/_abc.rs
+++ b/crates/vm/src/stdlib/_abc.rs
@@ -149,29 +149,24 @@ mod _abc {
         let items = vm.call_method(&ns, "items", ())?;
         let iter = items.get_iter(vm)?;
 
-        loop {
-            match iter.next(vm)? {
-                PyIterReturn::Return(item) => {
-                    let tuple: PyTupleRef = item
-                        .downcast()
-                        .map_err(|_| vm.new_type_error("items() returned non-tuple".to_owned()))?;
-                    let elements = tuple.as_slice();
-                    if elements.len() != 2 {
-                        return Err(vm.new_type_error(
-                            "items() returned item which size is not 2".to_owned(),
-                        ));
-                    }
-                    let key = &elements[0];
-                    let value = &elements[1];
-
-                    // Check if value has __isabstractmethod__ = True
-                    if let Ok(is_abstract) = value.get_attr("__isabstractmethod__", vm) {
-                        if is_abstract.try_to_bool(vm)? {
-                            abstracts.push(key.clone());
-                        }
-                    }
-                }
-                PyIterReturn::StopIteration(_) => break,
+        while let PyIterReturn::Return(item) = iter.next(vm)? {
+            let tuple: PyTupleRef = item
+                .downcast()
+                .map_err(|_| vm.new_type_error("items() returned non-tuple".to_owned()))?;
+            let elements = tuple.as_slice();
+            if elements.len() != 2 {
+                return Err(
+                    vm.new_type_error("items() returned item which size is not 2".to_owned())
+                );
+            }
+            let key = &elements[0];
+            let value = &elements[1];
+
+            // Check if value has __isabstractmethod__ = True
+            if let Ok(is_abstract) = value.get_attr("__isabstractmethod__", vm)
+                && is_abstract.try_to_bool(vm)?
+            {
+                abstracts.push(key.clone());
             }
         }
 
@@ -184,25 +179,14 @@ mod _abc {
         for base in bases.iter() {
             if let Ok(base_abstracts) = base.get_attr("__abstractmethods__", vm) {
                 let iter = base_abstracts.get_iter(vm)?;
-                loop {
-                    match iter.next(vm)? {
-                        PyIterReturn::Return(key) => {
-                            // Try to get the attribute from cls - key should be a string
-                            if let Some(key_str) = key.downcast_ref::<PyStr>() {
-                                if let Some(value) =
-                                    vm.get_attribute_opt(cls.to_owned(), key_str)?
-                                {
-                                    if let Ok(is_abstract) =
-                                        value.get_attr("__isabstractmethod__", vm)
-                                    {
-                                        if is_abstract.try_to_bool(vm)? {
-                                            abstracts.push(key);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        PyIterReturn::StopIteration(_) => break,
+                while let PyIterReturn::Return(key) = iter.next(vm)? {
+                    // Try to get the attribute from cls - key should be a string
+                    if let Some(key_str) = key.downcast_ref::<PyStr>()
+                        && let Some(value) = vm.get_attribute_opt(cls.to_owned(), key_str)?
+                        && let Ok(is_abstract) = value.get_attr("__isabstractmethod__", vm)
+                        && is_abstract.try_to_bool(vm)?
+                    {
+                        abstracts.push(key);
                     }
                 }
             }
@@ -279,10 +263,10 @@ mod _abc {
         let subtype: PyObjectRef = instance.class().to_owned().into();
         if subtype.is(&subclass) {
             let invalidation_counter = get_invalidation_counter();
-            if impl_data.get_cache_version() == invalidation_counter {
-                if in_weak_set(&impl_data.negative_cache, &subclass, vm)? {
-                    return Ok(vm.ctx.false_value.clone().into());
-                }
+            if impl_data.get_cache_version() == invalidation_counter
+                && in_weak_set(&impl_data.negative_cache, &subclass, vm)?
+            {
+                return Ok(vm.ctx.false_value.clone().into());
             }
             // Fall back to __subclasscheck__
             return vm.call_method(&cls, "__subclasscheck__", (subclass,));
@@ -323,13 +307,12 @@ mod _abc {
         let registry_copy = PyFrozenSet::from_iter(vm, registry.elements().into_iter())?;
 
         for weak_ref_obj in registry_copy.elements() {
-            if let Ok(weak_ref) = weak_ref_obj.downcast::<PyWeak>() {
-                if let Some(rkey) = weak_ref.upgrade() {
-                    if subclass.to_owned().is_subclass(&rkey, vm)? {
-                        add_to_weak_set(&impl_data.cache, subclass, vm)?;
-                        return Ok(Some(true));
-                    }
-                }
+            if let Ok(weak_ref) = weak_ref_obj.downcast::<PyWeak>()
+                && let Some(rkey) = weak_ref.upgrade()
+                && subclass.to_owned().is_subclass(&rkey, vm)?
+            {
+                add_to_weak_set(&impl_data.cache, subclass, vm)?;
+                return Ok(Some(true));
             }
         }
 
diff --git a/crates/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
index 5d5b1fc7b35..e83eaf83555 100644
--- a/crates/vm/src/stdlib/typevar.rs
+++ b/crates/vm/src/stdlib/typevar.rs
@@ -251,7 +251,7 @@ impl AsNumber for TypeVar {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             or: Some(|a, b, vm| {
                 let args = PyTuple::new_ref(vec![a.to_owned(), b.to_owned()], &vm.ctx);
-                Ok(make_union(&args, vm))
+                make_union(&args, vm)
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
@@ -527,7 +527,7 @@ impl AsNumber for ParamSpec {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             or: Some(|a, b, vm| {
                 let args = PyTuple::new_ref(vec![a.to_owned(), b.to_owned()], &vm.ctx);
-                Ok(make_union(&args, vm))
+                make_union(&args, vm)
             }),
             ..PyNumberMethods::NOT_IMPLEMENTED
         };
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs
index f11acce3490..b8048b16d94 100644
--- a/crates/vm/src/stdlib/typing.rs
+++ b/crates/vm/src/stdlib/typing.rs
@@ -28,6 +28,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
         "ParamSpecArgs" => ParamSpecArgs::class(&vm.ctx).to_owned(),
         "ParamSpecKwargs" => ParamSpecKwargs::class(&vm.ctx).to_owned(),
         "Generic" => Generic::class(&vm.ctx).to_owned(),
+        "Union" => vm.ctx.types.union_type.to_owned(),
     });
     module
 }
@@ -37,7 +38,6 @@ pub(crate) mod decl {
     use crate::{
         Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
         builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr, type_},
-        convert::ToPyResult,
         function::{FuncArgs, IntoFuncArgs},
         protocol::PyNumberMethods,
         types::{AsNumber, Constructor, Representable},
@@ -188,7 +188,7 @@ pub(crate) mod decl {
     impl AsNumber for TypeAliasType {
         fn as_number() -> &'static PyNumberMethods {
             static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-                or: Some(|a, b, vm| type_::or_(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+                or: Some(|a, b, vm| type_::or_(a.to_owned(), b.to_owned(), vm)),
                 ..PyNumberMethods::NOT_IMPLEMENTED
             };
             &AS_NUMBER
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index b637bfc40b6..2f45d9dcff1 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -483,7 +483,7 @@ fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
 
 /// Marks a type as unhashable. Similar to PyObject_HashNotImplemented in CPython
 pub fn hash_not_implemented(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
-    Err(vm.new_type_error(format!("unhashable type: {}", zelf.class().name())))
+    Err(vm.new_type_error(format!("unhashable type: '{}'", zelf.class().name())))
 }
 
 fn call_wrapper(zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine) -> PyResult {

From 700b34adeb0ab6cc0ef9b7251ff27d98205b8c7a Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 00:02:23 +0900
Subject: [PATCH 392/418] Hashable for PyMappingProxy

---
 crates/vm/src/builtins/mappingproxy.rs | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
index f7fb64fa6ab..1036dcfdaf9 100644
--- a/crates/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -3,13 +3,14 @@ use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     atomic_func,
     class::PyClassImpl,
+    common::hash,
     convert::ToPyObject,
     function::{ArgMapping, OptionalArg, PyComparisonValue},
     object::{Traverse, TraverseFn},
     protocol::{PyMappingMethods, PyNumberMethods, PySequenceMethods},
     types::{
-        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Iterable, PyComparisonOp,
-        Representable,
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, Iterable,
+        PyComparisonOp, Representable,
     },
 };
 use std::sync::LazyLock;
@@ -83,6 +84,7 @@ impl Constructor for PyMappingProxy {
     Constructor,
     AsSequence,
     Comparable,
+    Hashable,
     AsNumber,
     Representable
 ))]
@@ -215,6 +217,15 @@ impl Comparable for PyMappingProxy {
     }
 }
 
+impl Hashable for PyMappingProxy {
+    #[inline]
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        // Delegate hash to the underlying mapping
+        let obj = zelf.to_object(vm)?;
+        obj.hash(vm)
+    }
+}
+
 impl AsMapping for PyMappingProxy {
     fn as_mapping() -> &'static PyMappingMethods {
         static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {

From a7a823daaadb4f5d36f8843bbaa1977befc57350 Mon Sep 17 00:00:00 2001
From: CPython Developers <>
Date: Mon, 19 Jan 2026 19:04:09 +0900
Subject: [PATCH 393/418] Update typing from v3.14.2

---
 Lib/test/test_typing.py | 1760 +++++++++++++++++++++++----------------
 Lib/typing.py           |  597 +++++++------
 2 files changed, 1349 insertions(+), 1008 deletions(-)

diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index d96a3a6a5d4..3d101c62e12 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -1,3 +1,4 @@
+import annotationlib
 import contextlib
 import collections
 import collections.abc
@@ -5,8 +6,10 @@
 from functools import lru_cache, wraps, reduce
 import gc
 import inspect
+import io
 import itertools
 import operator
+import os
 import pickle
 import re
 import sys
@@ -43,13 +46,19 @@
 import textwrap
 import typing
 import weakref
+import warnings
 import types
 
-from test.support import captured_stderr, cpython_only, infinite_recursion, requires_docstrings, import_helper
-from test.support.testcase import ExtraAssertions
-from test.typinganndata import ann_module695, mod_generics_cache, _typed_dict_helper
+from test.support import (
+    captured_stderr, cpython_only, infinite_recursion, requires_docstrings, import_helper, run_code,
+    EqualToForwardRef,
+)
+from test.typinganndata import (
+    ann_module695, mod_generics_cache, _typed_dict_helper,
+    ann_module, ann_module2, ann_module3, ann_module5, ann_module6, ann_module8
+)
 
-import unittest # XXX: RUSTPYTHON
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 CANNOT_SUBCLASS_TYPE = 'Cannot subclass special typing classes'
@@ -57,7 +66,7 @@
 CANNOT_SUBCLASS_INSTANCE = 'Cannot subclass an instance of %s'
 
 
-class BaseTestCase(TestCase, ExtraAssertions):
+class BaseTestCase(TestCase):
 
     def clear_caches(self):
         for f in typing._cleanups:
@@ -115,18 +124,18 @@ def test_errors(self):
 
     def test_can_subclass(self):
         class Mock(Any): pass
-        self.assertTrue(issubclass(Mock, Any))
+        self.assertIsSubclass(Mock, Any)
         self.assertIsInstance(Mock(), Mock)
 
         class Something: pass
-        self.assertFalse(issubclass(Something, Any))
+        self.assertNotIsSubclass(Something, Any)
         self.assertNotIsInstance(Something(), Mock)
 
         class MockSomething(Something, Mock): pass
-        self.assertTrue(issubclass(MockSomething, Any))
-        self.assertTrue(issubclass(MockSomething, MockSomething))
-        self.assertTrue(issubclass(MockSomething, Something))
-        self.assertTrue(issubclass(MockSomething, Mock))
+        self.assertIsSubclass(MockSomething, Any)
+        self.assertIsSubclass(MockSomething, MockSomething)
+        self.assertIsSubclass(MockSomething, Something)
+        self.assertIsSubclass(MockSomething, Mock)
         ms = MockSomething()
         self.assertIsInstance(ms, MockSomething)
         self.assertIsInstance(ms, Something)
@@ -373,6 +382,7 @@ def test_alias(self):
         self.assertEqual(get_args(alias_2), (LiteralString,))
         self.assertEqual(get_args(alias_3), (LiteralString,))
 
+
 class TypeVarTests(BaseTestCase):
     def test_basic_plain(self):
         T = TypeVar('T')
@@ -467,8 +477,8 @@ def test_or(self):
         self.assertEqual(X | "x", Union[X, "x"])
         self.assertEqual("x" | X, Union["x", X])
         # make sure the order is correct
-        self.assertEqual(get_args(X | "x"), (X, ForwardRef("x")))
-        self.assertEqual(get_args("x" | X), (ForwardRef("x"), X))
+        self.assertEqual(get_args(X | "x"), (X, EqualToForwardRef("x")))
+        self.assertEqual(get_args("x" | X), (EqualToForwardRef("x"), X))
 
     def test_union_constrained(self):
         A = TypeVar('A', str, bytes)
@@ -502,7 +512,7 @@ def test_cannot_instantiate_vars(self):
 
     def test_bound_errors(self):
         with self.assertRaises(TypeError):
-            TypeVar('X', bound=Union)
+            TypeVar('X', bound=Optional)
         with self.assertRaises(TypeError):
             TypeVar('X', str, float, bound=Employee)
         with self.assertRaisesRegex(TypeError,
@@ -542,7 +552,7 @@ def test_var_substitution(self):
     def test_bad_var_substitution(self):
         T = TypeVar('T')
         bad_args = (
-            (), (int, str), Union,
+            (), (int, str), Optional,
             Generic, Generic[T], Protocol, Protocol[T],
             Final, Final[int], ClassVar, ClassVar[int],
         )
@@ -625,7 +635,7 @@ class TypeParameterDefaultsTests(BaseTestCase):
     def test_typevar(self):
         T = TypeVar('T', default=int)
         self.assertEqual(T.__default__, int)
-        self.assertTrue(T.has_default())
+        self.assertIs(T.has_default(), True)
         self.assertIsInstance(T, TypeVar)
 
         class A(Generic[T]): ...
@@ -635,19 +645,19 @@ def test_typevar_none(self):
         U = TypeVar('U')
         U_None = TypeVar('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
-        self.assertFalse(U.has_default())
+        self.assertIs(U.has_default(), False)
         self.assertIs(U_None.__default__, None)
-        self.assertTrue(U_None.has_default())
+        self.assertIs(U_None.has_default(), True)
 
         class X[T]: ...
         T, = X.__type_params__
         self.assertIs(T.__default__, NoDefault)
-        self.assertFalse(T.has_default())
+        self.assertIs(T.has_default(), False)
 
     def test_paramspec(self):
         P = ParamSpec('P', default=(str, int))
         self.assertEqual(P.__default__, (str, int))
-        self.assertTrue(P.has_default())
+        self.assertIs(P.has_default(), True)
         self.assertIsInstance(P, ParamSpec)
 
         class A(Generic[P]): ...
@@ -660,19 +670,19 @@ def test_paramspec_none(self):
         U = ParamSpec('U')
         U_None = ParamSpec('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
-        self.assertFalse(U.has_default())
+        self.assertIs(U.has_default(), False)
         self.assertIs(U_None.__default__, None)
-        self.assertTrue(U_None.has_default())
+        self.assertIs(U_None.has_default(), True)
 
         class X[**P]: ...
         P, = X.__type_params__
         self.assertIs(P.__default__, NoDefault)
-        self.assertFalse(P.has_default())
+        self.assertIs(P.has_default(), False)
 
     def test_typevartuple(self):
         Ts = TypeVarTuple('Ts', default=Unpack[Tuple[str, int]])
         self.assertEqual(Ts.__default__, Unpack[Tuple[str, int]])
-        self.assertTrue(Ts.has_default())
+        self.assertIs(Ts.has_default(), True)
         self.assertIsInstance(Ts, TypeVarTuple)
 
         class A(Generic[Unpack[Ts]]): ...
@@ -754,18 +764,28 @@ class A(Generic[T, P, U]): ...
         self.assertEqual(A[float, [range]].__args__, (float, (range,), float))
         self.assertEqual(A[float, [range], int].__args__, (float, (range,), int))
 
+    def test_paramspec_and_typevar_specialization_2(self):
+        T = TypeVar("T")
+        P = ParamSpec('P', default=...)
+        U = TypeVar("U", default=float)
+        self.assertEqual(P.__default__, ...)
+        class A(Generic[T, P, U]): ...
+        self.assertEqual(A[float].__args__, (float, ..., float))
+        self.assertEqual(A[float, [range]].__args__, (float, (range,), float))
+        self.assertEqual(A[float, [range], int].__args__, (float, (range,), int))
+
     def test_typevartuple_none(self):
         U = TypeVarTuple('U')
         U_None = TypeVarTuple('U_None', default=None)
         self.assertIs(U.__default__, NoDefault)
-        self.assertFalse(U.has_default())
+        self.assertIs(U.has_default(), False)
         self.assertIs(U_None.__default__, None)
-        self.assertTrue(U_None.has_default())
+        self.assertIs(U_None.has_default(), True)
 
         class X[**Ts]: ...
         Ts, = X.__type_params__
         self.assertIs(Ts.__default__, NoDefault)
-        self.assertFalse(Ts.has_default())
+        self.assertIs(Ts.has_default(), False)
 
     def test_no_default_after_non_default(self):
         DefaultStrT = TypeVar('DefaultStrT', default=str)
@@ -966,7 +986,7 @@ class C(Generic[T]): pass
                         )
 
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_two_parameters(self):
         T1 = TypeVar('T1')
         T2 = TypeVar('T2')
@@ -1064,7 +1084,7 @@ class C(Generic[T1, T2, T3]): pass
                             eval(expected_str)
                         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_variadic_parameters(self):
         T1 = TypeVar('T1')
         T2 = TypeVar('T2')
@@ -1168,7 +1188,6 @@ class C(Generic[*Ts]): pass
                         )
 
 
-
 class UnpackTests(BaseTestCase):
 
     def test_accepts_single_type(self):
@@ -1999,11 +2018,11 @@ def test_basics(self):
         self.assertNotEqual(u, Union)
 
     def test_union_isinstance(self):
-        self.assertTrue(isinstance(42, Union[int, str]))
-        self.assertTrue(isinstance('abc', Union[int, str]))
-        self.assertFalse(isinstance(3.14, Union[int, str]))
-        self.assertTrue(isinstance(42, Union[int, list[int]]))
-        self.assertTrue(isinstance(42, Union[int, Any]))
+        self.assertIsInstance(42, Union[int, str])
+        self.assertIsInstance('abc', Union[int, str])
+        self.assertNotIsInstance(3.14, Union[int, str])
+        self.assertIsInstance(42, Union[int, list[int]])
+        self.assertIsInstance(42, Union[int, Any])
 
     def test_union_isinstance_type_error(self):
         with self.assertRaises(TypeError):
@@ -2020,9 +2039,9 @@ def test_union_isinstance_type_error(self):
             isinstance(42, Union[Any, str])
 
     def test_optional_isinstance(self):
-        self.assertTrue(isinstance(42, Optional[int]))
-        self.assertTrue(isinstance(None, Optional[int]))
-        self.assertFalse(isinstance('abc', Optional[int]))
+        self.assertIsInstance(42, Optional[int])
+        self.assertIsInstance(None, Optional[int])
+        self.assertNotIsInstance('abc', Optional[int])
 
     def test_optional_isinstance_type_error(self):
         with self.assertRaises(TypeError):
@@ -2035,20 +2054,16 @@ def test_optional_isinstance_type_error(self):
             isinstance(None, Optional[Any])
 
     def test_union_issubclass(self):
-        self.assertTrue(issubclass(int, Union[int, str]))
-        self.assertTrue(issubclass(str, Union[int, str]))
-        self.assertFalse(issubclass(float, Union[int, str]))
-        self.assertTrue(issubclass(int, Union[int, list[int]]))
-        self.assertTrue(issubclass(int, Union[int, Any]))
-        self.assertFalse(issubclass(int, Union[str, Any]))
-        self.assertTrue(issubclass(int, Union[Any, int]))
-        self.assertFalse(issubclass(int, Union[Any, str]))
+        self.assertIsSubclass(int, Union[int, str])
+        self.assertIsSubclass(str, Union[int, str])
+        self.assertNotIsSubclass(float, Union[int, str])
+        self.assertIsSubclass(int, Union[int, list[int]])
+        self.assertIsSubclass(int, Union[int, Any])
+        self.assertNotIsSubclass(int, Union[str, Any])
+        self.assertIsSubclass(int, Union[Any, int])
+        self.assertNotIsSubclass(int, Union[Any, str])
 
     def test_union_issubclass_type_error(self):
-        with self.assertRaises(TypeError):
-            issubclass(int, Union)
-        with self.assertRaises(TypeError):
-            issubclass(Union, int)
         with self.assertRaises(TypeError):
             issubclass(Union[int, str], int)
         with self.assertRaises(TypeError):
@@ -2059,12 +2074,12 @@ def test_union_issubclass_type_error(self):
             issubclass(int, Union[list[int], str])
 
     def test_optional_issubclass(self):
-        self.assertTrue(issubclass(int, Optional[int]))
-        self.assertTrue(issubclass(type(None), Optional[int]))
-        self.assertFalse(issubclass(str, Optional[int]))
-        self.assertTrue(issubclass(Any, Optional[Any]))
-        self.assertTrue(issubclass(type(None), Optional[Any]))
-        self.assertFalse(issubclass(int, Optional[Any]))
+        self.assertIsSubclass(int, Optional[int])
+        self.assertIsSubclass(type(None), Optional[int])
+        self.assertNotIsSubclass(str, Optional[int])
+        self.assertIsSubclass(Any, Optional[Any])
+        self.assertIsSubclass(type(None), Optional[Any])
+        self.assertNotIsSubclass(int, Optional[Any])
 
     def test_optional_issubclass_type_error(self):
         with self.assertRaises(TypeError):
@@ -2123,41 +2138,40 @@ class B(metaclass=UnhashableMeta): ...
 
         self.assertEqual(Union[A, B].__args__, (A, B))
         union1 = Union[A, B]
-        with self.assertRaises(TypeError):
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
             hash(union1)
 
         union2 = Union[int, B]
-        with self.assertRaises(TypeError):
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
             hash(union2)
 
         union3 = Union[A, int]
-        with self.assertRaises(TypeError):
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
             hash(union3)
 
     def test_repr(self):
-        self.assertEqual(repr(Union), 'typing.Union')
         u = Union[Employee, int]
-        self.assertEqual(repr(u), 'typing.Union[%s.Employee, int]' % __name__)
+        self.assertEqual(repr(u), f'{__name__}.Employee | int')
         u = Union[int, Employee]
-        self.assertEqual(repr(u), 'typing.Union[int, %s.Employee]' % __name__)
+        self.assertEqual(repr(u), f'int | {__name__}.Employee')
         T = TypeVar('T')
         u = Union[T, int][int]
         self.assertEqual(repr(u), repr(int))
         u = Union[List[int], int]
-        self.assertEqual(repr(u), 'typing.Union[typing.List[int], int]')
+        self.assertEqual(repr(u), 'typing.List[int] | int')
         u = Union[list[int], dict[str, float]]
-        self.assertEqual(repr(u), 'typing.Union[list[int], dict[str, float]]')
+        self.assertEqual(repr(u), 'list[int] | dict[str, float]')
         u = Union[int | float]
-        self.assertEqual(repr(u), 'typing.Union[int, float]')
+        self.assertEqual(repr(u), 'int | float')
 
         u = Union[None, str]
-        self.assertEqual(repr(u), 'typing.Optional[str]')
+        self.assertEqual(repr(u), 'None | str')
         u = Union[str, None]
-        self.assertEqual(repr(u), 'typing.Optional[str]')
+        self.assertEqual(repr(u), 'str | None')
         u = Union[None, str, int]
-        self.assertEqual(repr(u), 'typing.Union[NoneType, str, int]')
+        self.assertEqual(repr(u), 'None | str | int')
         u = Optional[str]
-        self.assertEqual(repr(u), 'typing.Optional[str]')
+        self.assertEqual(repr(u), 'str | None')
 
     def test_dir(self):
         dir_items = set(dir(Union[str, int]))
@@ -2169,14 +2183,11 @@ def test_dir(self):
 
     def test_cannot_subclass(self):
         with self.assertRaisesRegex(TypeError,
-                r'Cannot subclass typing\.Union'):
+                r"type 'typing\.Union' is not an acceptable base type"):
             class C(Union):
                 pass
-        with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE):
-            class D(type(Union)):
-                pass
         with self.assertRaisesRegex(TypeError,
-                r'Cannot subclass typing\.Union\[int, str\]'):
+                r'Cannot subclass int \| str'):
             class E(Union[int, str]):
                 pass
 
@@ -2192,8 +2203,8 @@ def test_cannot_instantiate(self):
             type(u)()
 
     def test_union_generalization(self):
-        self.assertFalse(Union[str, typing.Iterable[int]] == str)
-        self.assertFalse(Union[str, typing.Iterable[int]] == typing.Iterable[int])
+        self.assertNotEqual(Union[str, typing.Iterable[int]], str)
+        self.assertNotEqual(Union[str, typing.Iterable[int]], typing.Iterable[int])
         self.assertIn(str, Union[str, typing.Iterable[int]].__args__)
         self.assertIn(typing.Iterable[int], Union[str, typing.Iterable[int]].__args__)
 
@@ -2222,7 +2233,7 @@ def f(x: u): ...
 
     def test_function_repr_union(self):
         def fun() -> int: ...
-        self.assertEqual(repr(Union[fun, int]), 'typing.Union[fun, int]')
+        self.assertEqual(repr(Union[fun, int]), f'{__name__}.{fun.__qualname__} | int')
 
     def test_union_str_pattern(self):
         # Shouldn't crash; see http://bugs.python.org/issue25390
@@ -2270,6 +2281,16 @@ class Ints(enum.IntEnum):
         self.assertEqual(Union[Literal[1], Literal[Ints.B], Literal[True]].__args__,
                          (Literal[1], Literal[Ints.B], Literal[True]))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: types.UnionType[int, str] | float != types.UnionType[int, str, float]
+    def test_allow_non_types_in_or(self):
+        # gh-140348: Test that using | with a Union object allows things that are
+        # not allowed by is_unionable().
+        U1 = Union[int, str]
+        self.assertEqual(U1 | float, Union[int, str, float])
+        self.assertEqual(U1 | "float", Union[int, str, "float"])
+        self.assertEqual(float | U1, Union[float, int, str])
+        self.assertEqual("float" | U1, Union["float", int, str])
+
 
 class TupleTests(BaseTestCase):
 
@@ -2557,7 +2578,7 @@ def test_concatenate(self):
 
     def test_nested_paramspec(self):
         # Since Callable has some special treatment, we want to be sure
-        # that substituion works correctly, see gh-103054
+        # that substitution works correctly, see gh-103054
         Callable = self.Callable
         P = ParamSpec('P')
         P2 = ParamSpec('P2')
@@ -2609,6 +2630,7 @@ def test_errors(self):
         with self.assertRaisesRegex(TypeError, "few arguments for"):
             C1[int]
 
+
 class TypingCallableTests(BaseCallableTests, BaseTestCase):
     Callable = typing.Callable
 
@@ -2786,6 +2808,7 @@ class Coordinate(Protocol):
     x: int
     y: int
 
+
 @runtime_checkable
 class Point(Coordinate, Protocol):
     label: str
@@ -3155,6 +3178,21 @@ def x(self): ...
         with self.assertRaisesRegex(TypeError, only_classes_allowed):
             issubclass(1, BadPG)
 
+    def test_isinstance_against_superproto_doesnt_affect_subproto_instance(self):
+        @runtime_checkable
+        class Base(Protocol):
+            x: int
+
+        @runtime_checkable
+        class Child(Base, Protocol):
+            y: str
+
+        class Capybara:
+            x = 43
+
+        self.assertIsInstance(Capybara(), Base)
+        self.assertNotIsInstance(Capybara(), Child)
+
     def test_implicit_issubclass_between_two_protocols(self):
         @runtime_checkable
         class CallableMembersProto(Protocol):
@@ -3229,7 +3267,7 @@ def meth2(self, x, y): return True
         self.assertIsSubclass(NotAProtocolButAnImplicitSubclass2, CallableMembersProto)
         self.assertIsSubclass(NotAProtocolButAnImplicitSubclass3, CallableMembersProto)
 
-    @unittest.skip('TODO: RUSTPYTHON; (no gc)')
+    @unittest.skip("TODO: RUSTPYTHON; (no gc)")
     def test_isinstance_checks_not_at_whim_of_gc(self):
         self.addCleanup(gc.enable)
         gc.disable()
@@ -3803,7 +3841,6 @@ def __init__(self):
         self.assertNotIsInstance(B(), P)
         self.assertNotIsInstance(C(), P)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; test doesn't include PEP 649 attrs
     def test_non_protocol_subclasses(self):
         class P(Protocol):
             x = 1
@@ -3849,7 +3886,8 @@ def meth(self): pass
 
         acceptable_extra_attrs = {
             '_is_protocol', '_is_runtime_protocol', '__parameters__',
-            '__init__', '__annotations__', '__subclasshook__',
+            '__init__', '__annotations__', '__subclasshook__', '__annotate__',
+            '__annotations_cache__', '__annotate_func__',
         }
         self.assertLessEqual(vars(NonP).keys(), vars(C).keys() | acceptable_extra_attrs)
         self.assertLessEqual(
@@ -4071,8 +4109,8 @@ def test_generic_protocols_repr(self):
 
         class P(Protocol[T, S]): pass
 
-        self.assertTrue(repr(P[T, S]).endswith('P[~T, ~S]'))
-        self.assertTrue(repr(P[int, str]).endswith('P[int, str]'))
+        self.assertEndsWith(repr(P[T, S]), 'P[~T, ~S]')
+        self.assertEndsWith(repr(P[int, str]), 'P[int, str]')
 
     def test_generic_protocols_eq(self):
         T = TypeVar('T')
@@ -4112,12 +4150,12 @@ class PG(Protocol[T]):
             def meth(self):
                 pass
 
-        self.assertTrue(P._is_protocol)
-        self.assertTrue(PR._is_protocol)
-        self.assertTrue(PG._is_protocol)
-        self.assertFalse(P._is_runtime_protocol)
-        self.assertTrue(PR._is_runtime_protocol)
-        self.assertTrue(PG[int]._is_protocol)
+        self.assertIs(P._is_protocol, True)
+        self.assertIs(PR._is_protocol, True)
+        self.assertIs(PG._is_protocol, True)
+        self.assertIs(P._is_runtime_protocol, False)
+        self.assertIs(PR._is_runtime_protocol, True)
+        self.assertIs(PG[int]._is_protocol, True)
         self.assertEqual(typing._get_protocol_attrs(P), {'meth'})
         self.assertEqual(typing._get_protocol_attrs(PR), {'x'})
         self.assertEqual(frozenset(typing._get_protocol_attrs(PG)),
@@ -4173,7 +4211,7 @@ class P(Protocol):
         Alias2 = typing.Union[P, typing.Iterable]
         self.assertEqual(Alias, Alias2)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_protocols_pickleable(self):
         global P, CP  # pickle wants to reference the class by name
         T = TypeVar('T')
@@ -4324,11 +4362,50 @@ def __release_buffer__(self, mv: memoryview) -> None:
         self.assertNotIsSubclass(C, ReleasableBuffer)
         self.assertNotIsInstance(C(), ReleasableBuffer)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'io' has no attribute 'Reader'
+    def test_io_reader_protocol_allowed(self):
+        @runtime_checkable
+        class CustomReader(io.Reader[bytes], Protocol):
+            def close(self): ...
+
+        class A: pass
+        class B:
+            def read(self, sz=-1):
+                return b""
+            def close(self):
+                pass
+
+        self.assertIsSubclass(B, CustomReader)
+        self.assertIsInstance(B(), CustomReader)
+        self.assertNotIsSubclass(A, CustomReader)
+        self.assertNotIsInstance(A(), CustomReader)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: module 'io' has no attribute 'Writer'
+    def test_io_writer_protocol_allowed(self):
+        @runtime_checkable
+        class CustomWriter(io.Writer[bytes], Protocol):
+            def close(self): ...
+
+        class A: pass
+        class B:
+            def write(self, b):
+                pass
+            def close(self):
+                pass
+
+        self.assertIsSubclass(B, CustomWriter)
+        self.assertIsInstance(B(), CustomWriter)
+        self.assertNotIsSubclass(A, CustomWriter)
+        self.assertNotIsInstance(A(), CustomWriter)
+
     def test_builtin_protocol_allowlist(self):
         with self.assertRaises(TypeError):
             class CustomProtocol(TestCase, Protocol):
                 pass
 
+        class CustomPathLikeProtocol(os.PathLike, Protocol):
+            pass
+
         class CustomContextManager(typing.ContextManager, Protocol):
             pass
 
@@ -4542,6 +4619,42 @@ class Commentable(Protocol):
         )
         self.assertIs(type(exc.__cause__), CustomError)
 
+    def test_isinstance_with_deferred_evaluation_of_annotations(self):
+        @runtime_checkable
+        class P(Protocol):
+            def meth(self):
+                ...
+
+        class DeferredClass:
+            x: undefined
+
+        class DeferredClassImplementingP:
+            x: undefined | int
+
+            def __init__(self):
+                self.x = 0
+
+            def meth(self):
+                ...
+
+        # override meth with a non-method attribute to make it part of __annotations__ instead of __dict__
+        class SubProtocol(P, Protocol):
+            meth: undefined
+
+
+        self.assertIsSubclass(SubProtocol, P)
+        self.assertNotIsInstance(DeferredClass(), P)
+        self.assertIsInstance(DeferredClassImplementingP(), P)
+
+    def test_deferred_evaluation_of_annotations(self):
+        class DeferredProto(Protocol):
+            x: DoesNotExist
+        self.assertEqual(get_protocol_members(DeferredProto), {"x"})
+        self.assertEqual(
+            annotationlib.get_annotations(DeferredProto, format=annotationlib.Format.STRING),
+            {'x': 'DoesNotExist'}
+        )
+
 
 class GenericTests(BaseTestCase):
 
@@ -4589,6 +4702,35 @@ class D(Generic[T]): pass
         with self.assertRaises(TypeError):
             D[()]
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_generic_init_subclass_not_called_error(self):
+        notes = ["Note: this exception may have been caused by "
+                 r"'GenericTests.test_generic_init_subclass_not_called_error.<locals>.Base.__init_subclass__' "
+                 "(or the '__init_subclass__' method on a superclass) not calling 'super().__init_subclass__()'"]
+
+        class Base:
+            def __init_subclass__(cls) -> None:
+                # Oops, I forgot super().__init_subclass__()!
+                pass
+
+        with self.subTest():
+            class Sub(Base, Generic[T]):
+                pass
+
+            with self.assertRaises(AttributeError) as cm:
+                Sub[int]
+
+            self.assertEqual(cm.exception.__notes__, notes)
+
+        with self.subTest():
+            class Sub[U](Base):
+                pass
+
+            with self.assertRaises(AttributeError) as cm:
+                Sub[int]
+
+            self.assertEqual(cm.exception.__notes__, notes)
+
     def test_generic_subclass_checks(self):
         for typ in [list[int], List[int],
                     tuple[int, str], Tuple[int, str],
@@ -4660,8 +4802,7 @@ class C(Generic[T]):
         self.assertNotEqual(Z, Y[int])
         self.assertNotEqual(Z, Y[T])
 
-        self.assertTrue(str(Z).endswith(
-            '.C[typing.Tuple[str, int]]'))
+        self.assertEndsWith(str(Z), '.C[typing.Tuple[str, int]]')
 
     def test_new_repr(self):
         T = TypeVar('T')
@@ -4889,12 +5030,12 @@ class A(Generic[T]):
         self.assertNotEqual(typing.FrozenSet[A[str]],
                             typing.FrozenSet[mod_generics_cache.B.A[str]])
 
-        self.assertTrue(repr(Tuple[A[str]]).endswith('<locals>.A[str]]'))
-        self.assertTrue(repr(Tuple[B.A[str]]).endswith('<locals>.B.A[str]]'))
-        self.assertTrue(repr(Tuple[mod_generics_cache.A[str]])
-                        .endswith('mod_generics_cache.A[str]]'))
-        self.assertTrue(repr(Tuple[mod_generics_cache.B.A[str]])
-                        .endswith('mod_generics_cache.B.A[str]]'))
+        self.assertEndsWith(repr(Tuple[A[str]]), '<locals>.A[str]]')
+        self.assertEndsWith(repr(Tuple[B.A[str]]), '<locals>.B.A[str]]')
+        self.assertEndsWith(repr(Tuple[mod_generics_cache.A[str]]),
+                            'mod_generics_cache.A[str]]')
+        self.assertEndsWith(repr(Tuple[mod_generics_cache.B.A[str]]),
+                            'mod_generics_cache.B.A[str]]')
 
     def test_extended_generic_rules_eq(self):
         T = TypeVar('T')
@@ -4915,11 +5056,11 @@ class Derived(Base): ...
     def test_extended_generic_rules_repr(self):
         T = TypeVar('T')
         self.assertEqual(repr(Union[Tuple, Callable]).replace('typing.', ''),
-                         'Union[Tuple, Callable]')
+                         'Tuple | Callable')
         self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
-                         'Union[Tuple, Tuple[int]]')
+                         'Tuple | Tuple[int]')
         self.assertEqual(repr(Callable[..., Optional[T]][int]).replace('typing.', ''),
-                         'Callable[..., Optional[int]]')
+                         'Callable[..., int | None]')
         self.assertEqual(repr(Callable[[], List[T]][int]).replace('typing.', ''),
                          'Callable[[], List[int]]')
 
@@ -4985,7 +5126,7 @@ class C3:
         def f(x: X): ...
         self.assertEqual(
             get_type_hints(f, globals(), locals()),
-            {'x': list[list[ForwardRef('X')]]}
+            {'x': list[list[EqualToForwardRef('X')]]}
         )
 
     def test_pep695_generic_class_with_future_annotations(self):
@@ -5099,9 +5240,9 @@ def __contains__(self, item):
         with self.assertRaises(TypeError):
             issubclass(Tuple[int, ...], typing.Iterable)
 
-    def test_fail_with_bare_union(self):
+    def test_fail_with_special_forms(self):
         with self.assertRaises(TypeError):
-            List[Union]
+            List[Final]
         with self.assertRaises(TypeError):
             Tuple[Optional]
         with self.assertRaises(TypeError):
@@ -5148,7 +5289,7 @@ def test_all_repr_eq_any(self):
                     self.assertNotEqual(repr(base), '')
                     self.assertEqual(base, base)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_pickle(self):
         global C  # pickle wants to reference the class by name
         T = TypeVar('T')
@@ -5205,10 +5346,12 @@ class Node(Generic[T]): ...
                   Tuple[Any, Any], Node[T], Node[int], Node[Any], typing.Iterable[T],
                   typing.Iterable[Any], typing.Iterable[int], typing.Dict[int, str],
                   typing.Dict[T, Any], ClassVar[int], ClassVar[List[T]], Tuple['T', 'T'],
-                  Union['T', int], List['T'], typing.Mapping['T', int]]
-        for t in things + [Any]:
-            self.assertEqual(t, copy(t))
-            self.assertEqual(t, deepcopy(t))
+                  Union['T', int], List['T'], typing.Mapping['T', int],
+                  Union[b"x", b"y"], Any]
+        for t in things:
+            with self.subTest(thing=t):
+                self.assertEqual(t, copy(t))
+                self.assertEqual(t, deepcopy(t))
 
     def test_immutability_by_copy_and_pickle(self):
         # Special forms like Union, Any, etc., generic aliases to containers like List,
@@ -5644,8 +5787,6 @@ def test_subclass_special_form(self):
         for obj in (
             ClassVar[int],
             Final[int],
-            Union[int, float],
-            Optional[int],
             Literal[1, 2],
             Concatenate[int, ParamSpec("P")],
             TypeGuard[int],
@@ -5677,7 +5818,7 @@ class A:
             __parameters__ = (T,)
         # Bare classes should be skipped
         for a in (List, list):
-            for b in (A, int, TypeVar, TypeVarTuple, ParamSpec, types.GenericAlias, types.UnionType):
+            for b in (A, int, TypeVar, TypeVarTuple, ParamSpec, types.GenericAlias, Union):
                 with self.subTest(generic=a, sub=b):
                     with self.assertRaisesRegex(TypeError, '.* is not a generic class'):
                         a[b][str]
@@ -5696,7 +5837,7 @@ class A:
 
         for s in (int, G, A, List, list,
                   TypeVar, TypeVarTuple, ParamSpec,
-                  types.GenericAlias, types.UnionType):
+                  types.GenericAlias, Union):
 
             for t in Tuple, tuple:
                 with self.subTest(tuple=t, sub=s):
@@ -5714,7 +5855,7 @@ class A:
                     with self.assertRaises(TypeError):
                         a[int]
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: ".+__typing_subst__.+tuple.+int.*" does not match "'TypeAliasType' object is not subscriptable"
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: ".+__typing_subst__.+tuple.+int.*" does not match "'TypeAliasType' object is not subscriptable"
     def test_return_non_tuple_while_unpacking(self):
         # GH-138497: GenericAlias objects didn't ensure that __typing_subst__ actually
         # returned a tuple
@@ -5778,6 +5919,7 @@ def test_no_isinstance(self):
         with self.assertRaises(TypeError):
             issubclass(int, ClassVar)
 
+
 class FinalTests(BaseTestCase):
 
     def test_basics(self):
@@ -5834,7 +5976,7 @@ def test_final_unmodified(self):
         def func(x): ...
         self.assertIs(func, final(func))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_dunder_final(self):
         @final
         def func(): ...
@@ -5856,7 +5998,7 @@ def __call__(self, *args, **kwargs):
         @Wrapper
         def wrapped(): ...
         self.assertIsInstance(wrapped, Wrapper)
-        self.assertIs(False, hasattr(wrapped, "__final__"))
+        self.assertNotHasAttr(wrapped, "__final__")
 
         class Meta(type):
             @property
@@ -5868,7 +6010,7 @@ class WithMeta(metaclass=Meta): ...
         # Builtin classes throw TypeError if you try to set an
         # attribute.
         final(int)
-        self.assertIs(False, hasattr(int, "__final__"))
+        self.assertNotHasAttr(int, "__final__")
 
         # Make sure it works with common builtin decorators
         class Methods:
@@ -5949,19 +6091,19 @@ def static_method_bad_order():
         self.assertEqual(Derived.class_method_good_order(), 42)
         self.assertIs(True, Derived.class_method_good_order.__override__)
         self.assertEqual(Derived.class_method_bad_order(), 42)
-        self.assertIs(False, hasattr(Derived.class_method_bad_order, "__override__"))
+        self.assertNotHasAttr(Derived.class_method_bad_order, "__override__")
 
         self.assertEqual(Derived.static_method_good_order(), 42)
         self.assertIs(True, Derived.static_method_good_order.__override__)
         self.assertEqual(Derived.static_method_bad_order(), 42)
-        self.assertIs(False, hasattr(Derived.static_method_bad_order, "__override__"))
+        self.assertNotHasAttr(Derived.static_method_bad_order, "__override__")
 
         # Base object is not changed:
-        self.assertIs(False, hasattr(Base.normal_method, "__override__"))
-        self.assertIs(False, hasattr(Base.class_method_good_order, "__override__"))
-        self.assertIs(False, hasattr(Base.class_method_bad_order, "__override__"))
-        self.assertIs(False, hasattr(Base.static_method_good_order, "__override__"))
-        self.assertIs(False, hasattr(Base.static_method_bad_order, "__override__"))
+        self.assertNotHasAttr(Base.normal_method, "__override__")
+        self.assertNotHasAttr(Base.class_method_good_order, "__override__")
+        self.assertNotHasAttr(Base.class_method_bad_order, "__override__")
+        self.assertNotHasAttr(Base.static_method_good_order, "__override__")
+        self.assertNotHasAttr(Base.static_method_bad_order, "__override__")
 
     def test_property(self):
         class Base:
@@ -5984,10 +6126,10 @@ def wrong(self) -> int:
 
         instance = Child()
         self.assertEqual(instance.correct, 2)
-        self.assertTrue(Child.correct.fget.__override__)
+        self.assertIs(Child.correct.fget.__override__, True)
         self.assertEqual(instance.wrong, 2)
-        self.assertFalse(hasattr(Child.wrong, "__override__"))
-        self.assertFalse(hasattr(Child.wrong.fset, "__override__"))
+        self.assertNotHasAttr(Child.wrong, "__override__")
+        self.assertNotHasAttr(Child.wrong.fset, "__override__")
 
     def test_silent_failure(self):
         class CustomProp:
@@ -6004,7 +6146,7 @@ def some(self):
                 return 1
 
         self.assertEqual(WithOverride.some, 1)
-        self.assertFalse(hasattr(WithOverride.some, "__override__"))
+        self.assertNotHasAttr(WithOverride.some, "__override__")
 
     def test_multiple_decorators(self):
         def with_wraps(f):  # similar to `lru_cache` definition
@@ -6025,9 +6167,9 @@ def on_bottom(self, a: int) -> int:
 
         instance = WithOverride()
         self.assertEqual(instance.on_top(1), 2)
-        self.assertTrue(instance.on_top.__override__)
+        self.assertIs(instance.on_top.__override__, True)
         self.assertEqual(instance.on_bottom(1), 3)
-        self.assertTrue(instance.on_bottom.__override__)
+        self.assertIs(instance.on_bottom.__override__, True)
 
 
 class CastTests(BaseTestCase):
@@ -6065,8 +6207,6 @@ def test_errors(self):
 
 
 # We need this to make sure that `@no_type_check` respects `__module__` attr:
-from test.typinganndata import ann_module8
-
 @no_type_check
 class NoTypeCheck_Outer:
     Inner = ann_module8.NoTypeCheck_Outer.Inner
@@ -6076,474 +6216,168 @@ class NoTypeCheck_WithFunction:
     NoTypeCheck_function = ann_module8.NoTypeCheck_function
 
 
-class ForwardRefTests(BaseTestCase):
-
-    def test_basics(self):
+class NoTypeCheckTests(BaseTestCase):
+    def test_no_type_check(self):
 
-        class Node(Generic[T]):
+        @no_type_check
+        def foo(a: 'whatevers') -> {}:
+            pass
 
-            def __init__(self, label: T):
-                self.label = label
-                self.left = self.right = None
+        th = get_type_hints(foo)
+        self.assertEqual(th, {})
 
-            def add_both(self,
-                         left: 'Optional[Node[T]]',
-                         right: 'Node[T]' = None,
-                         stuff: int = None,
-                         blah=None):
-                self.left = left
-                self.right = right
+    def test_no_type_check_class(self):
 
-            def add_left(self, node: Optional['Node[T]']):
-                self.add_both(node, None)
+        @no_type_check
+        class C:
+            def foo(a: 'whatevers') -> {}:
+                pass
 
-            def add_right(self, node: 'Node[T]' = None):
-                self.add_both(None, node)
+        cth = get_type_hints(C.foo)
+        self.assertEqual(cth, {})
+        ith = get_type_hints(C().foo)
+        self.assertEqual(ith, {})
 
-        t = Node[int]
-        both_hints = get_type_hints(t.add_both, globals(), locals())
-        self.assertEqual(both_hints['left'], Optional[Node[T]])
-        self.assertEqual(both_hints['right'], Node[T])
-        self.assertEqual(both_hints['stuff'], int)
-        self.assertNotIn('blah', both_hints)
+    def test_no_type_check_no_bases(self):
+        class C:
+            def meth(self, x: int): ...
+        @no_type_check
+        class D(C):
+            c = C
 
-        left_hints = get_type_hints(t.add_left, globals(), locals())
-        self.assertEqual(left_hints['node'], Optional[Node[T]])
+        # verify that @no_type_check never affects bases
+        self.assertEqual(get_type_hints(C.meth), {'x': int})
 
-        right_hints = get_type_hints(t.add_right, globals(), locals())
-        self.assertEqual(right_hints['node'], Node[T])
+        # and never child classes:
+        class Child(D):
+            def foo(self, x: int): ...
 
-    def test_forwardref_instance_type_error(self):
-        fr = typing.ForwardRef('int')
-        with self.assertRaises(TypeError):
-            isinstance(42, fr)
+        self.assertEqual(get_type_hints(Child.foo), {'x': int})
 
-    def test_forwardref_subclass_type_error(self):
-        fr = typing.ForwardRef('int')
-        with self.assertRaises(TypeError):
-            issubclass(int, fr)
+    def test_no_type_check_nested_types(self):
+        # See https://bugs.python.org/issue46571
+        class Other:
+            o: int
+        class B:  # Has the same `__name__`` as `A.B` and different `__qualname__`
+            o: int
+        @no_type_check
+        class A:
+            a: int
+            class B:
+                b: int
+                class C:
+                    c: int
+            class D:
+                d: int
 
-    def test_forwardref_only_str_arg(self):
-        with self.assertRaises(TypeError):
-            typing.ForwardRef(1)  # only `str` type is allowed
+            Other = Other
 
-    def test_forward_equality(self):
-        fr = typing.ForwardRef('int')
-        self.assertEqual(fr, typing.ForwardRef('int'))
-        self.assertNotEqual(List['int'], List[int])
-        self.assertNotEqual(fr, typing.ForwardRef('int', module=__name__))
-        frm = typing.ForwardRef('int', module=__name__)
-        self.assertEqual(frm, typing.ForwardRef('int', module=__name__))
-        self.assertNotEqual(frm, typing.ForwardRef('int', module='__other_name__'))
+        for klass in [A, A.B, A.B.C, A.D]:
+            with self.subTest(klass=klass):
+                self.assertIs(klass.__no_type_check__, True)
+                self.assertEqual(get_type_hints(klass), {})
 
-    def test_forward_equality_gth(self):
-        c1 = typing.ForwardRef('C')
-        c1_gth = typing.ForwardRef('C')
-        c2 = typing.ForwardRef('C')
-        c2_gth = typing.ForwardRef('C')
+        for not_modified in [Other, B]:
+            with self.subTest(not_modified=not_modified):
+                with self.assertRaises(AttributeError):
+                    not_modified.__no_type_check__
+                self.assertNotEqual(get_type_hints(not_modified), {})
 
-        class C:
-            pass
-        def foo(a: c1_gth, b: c2_gth):
-            pass
+    def test_no_type_check_class_and_static_methods(self):
+        @no_type_check
+        class Some:
+            @staticmethod
+            def st(x: int) -> int: ...
+            @classmethod
+            def cl(cls, y: int) -> int: ...
 
-        self.assertEqual(get_type_hints(foo, globals(), locals()), {'a': C, 'b': C})
-        self.assertEqual(c1, c2)
-        self.assertEqual(c1, c1_gth)
-        self.assertEqual(c1_gth, c2_gth)
-        self.assertEqual(List[c1], List[c1_gth])
-        self.assertNotEqual(List[c1], List[C])
-        self.assertNotEqual(List[c1_gth], List[C])
-        self.assertEqual(Union[c1, c1_gth], Union[c1])
-        self.assertEqual(Union[c1, c1_gth, int], Union[c1, int])
-
-    def test_forward_equality_hash(self):
-        c1 = typing.ForwardRef('int')
-        c1_gth = typing.ForwardRef('int')
-        c2 = typing.ForwardRef('int')
-        c2_gth = typing.ForwardRef('int')
-
-        def foo(a: c1_gth, b: c2_gth):
-            pass
-        get_type_hints(foo, globals(), locals())
+        self.assertIs(Some.st.__no_type_check__, True)
+        self.assertEqual(get_type_hints(Some.st), {})
+        self.assertIs(Some.cl.__no_type_check__, True)
+        self.assertEqual(get_type_hints(Some.cl), {})
 
-        self.assertEqual(hash(c1), hash(c2))
-        self.assertEqual(hash(c1_gth), hash(c2_gth))
-        self.assertEqual(hash(c1), hash(c1_gth))
+    def test_no_type_check_other_module(self):
+        self.assertIs(NoTypeCheck_Outer.__no_type_check__, True)
+        with self.assertRaises(AttributeError):
+            ann_module8.NoTypeCheck_Outer.__no_type_check__
+        with self.assertRaises(AttributeError):
+            ann_module8.NoTypeCheck_Outer.Inner.__no_type_check__
 
-        c3 = typing.ForwardRef('int', module=__name__)
-        c4 = typing.ForwardRef('int', module='__other_name__')
+        self.assertIs(NoTypeCheck_WithFunction.__no_type_check__, True)
+        with self.assertRaises(AttributeError):
+            ann_module8.NoTypeCheck_function.__no_type_check__
 
-        self.assertNotEqual(hash(c3), hash(c1))
-        self.assertNotEqual(hash(c3), hash(c1_gth))
-        self.assertNotEqual(hash(c3), hash(c4))
-        self.assertEqual(hash(c3), hash(typing.ForwardRef('int', module=__name__)))
+    def test_no_type_check_foreign_functions(self):
+        # We should not modify this function:
+        def some(*args: int) -> int:
+            ...
 
-    def test_forward_equality_namespace(self):
+        @no_type_check
         class A:
-            pass
-        def namespace1():
-            a = typing.ForwardRef('A')
-            def fun(x: a):
-                pass
-            get_type_hints(fun, globals(), locals())
-            return a
+            some_alias = some
+            some_class = classmethod(some)
+            some_static = staticmethod(some)
 
-        def namespace2():
-            a = typing.ForwardRef('A')
+        with self.assertRaises(AttributeError):
+            some.__no_type_check__
+        self.assertEqual(get_type_hints(some), {'args': int, 'return': int})
 
-            class A:
-                pass
-            def fun(x: a):
-                pass
+    def test_no_type_check_lambda(self):
+        @no_type_check
+        class A:
+            # Corner case: `lambda` is both an assignment and a function:
+            bar: Callable[[int], int] = lambda arg: arg
 
-            get_type_hints(fun, globals(), locals())
-            return a
+        self.assertIs(A.bar.__no_type_check__, True)
+        self.assertEqual(get_type_hints(A.bar), {})
 
-        self.assertEqual(namespace1(), namespace1())
-        self.assertNotEqual(namespace1(), namespace2())
+    def test_no_type_check_TypeError(self):
+        # This simply should not fail with
+        # `TypeError: can't set attributes of built-in/extension type 'dict'`
+        no_type_check(dict)
 
-    def test_forward_repr(self):
-        self.assertEqual(repr(List['int']), "typing.List[ForwardRef('int')]")
-        self.assertEqual(repr(List[ForwardRef('int', module='mod')]),
-                         "typing.List[ForwardRef('int', module='mod')]")
+    def test_no_type_check_forward_ref_as_string(self):
+        class C:
+            foo: typing.ClassVar[int] = 7
+        class D:
+            foo: ClassVar[int] = 7
+        class E:
+            foo: 'typing.ClassVar[int]' = 7
+        class F:
+            foo: 'ClassVar[int]' = 7
 
-    def test_union_forward(self):
+        expected_result = {'foo': typing.ClassVar[int]}
+        for clazz in [C, D, E, F]:
+            self.assertEqual(get_type_hints(clazz), expected_result)
 
-        def foo(a: Union['T']):
-            pass
+    def test_meta_no_type_check(self):
+        depr_msg = (
+            "'typing.no_type_check_decorator' is deprecated "
+            "and slated for removal in Python 3.15"
+        )
+        with self.assertWarnsRegex(DeprecationWarning, depr_msg):
+            @no_type_check_decorator
+            def magic_decorator(func):
+                return func
 
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': Union[T]})
+        self.assertEqual(magic_decorator.__name__, 'magic_decorator')
 
-        def foo(a: tuple[ForwardRef('T')] | int):
+        @magic_decorator
+        def foo(a: 'whatevers') -> {}:
             pass
 
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': tuple[T] | int})
+        @magic_decorator
+        class C:
+            def foo(a: 'whatevers') -> {}:
+                pass
 
-    def test_tuple_forward(self):
-
-        def foo(a: Tuple['T']):
-            pass
-
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': Tuple[T]})
-
-        def foo(a: tuple[ForwardRef('T')]):
-            pass
-
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': tuple[T]})
-
-    def test_double_forward(self):
-        def foo(a: 'List[\'int\']'):
-            pass
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': List[int]})
-
-    def test_forward_recursion_actually(self):
-        def namespace1():
-            a = typing.ForwardRef('A')
-            A = a
-            def fun(x: a): pass
-
-            ret = get_type_hints(fun, globals(), locals())
-            return a
-
-        def namespace2():
-            a = typing.ForwardRef('A')
-            A = a
-            def fun(x: a): pass
-
-            ret = get_type_hints(fun, globals(), locals())
-            return a
-
-        def cmp(o1, o2):
-            return o1 == o2
-
-        with infinite_recursion(25):
-            r1 = namespace1()
-            r2 = namespace2()
-            self.assertIsNot(r1, r2)
-            self.assertRaises(RecursionError, cmp, r1, r2)
-
-    def test_union_forward_recursion(self):
-        ValueList = List['Value']
-        Value = Union[str, ValueList]
-
-        class C:
-            foo: List[Value]
-        class D:
-            foo: Union[Value, ValueList]
-        class E:
-            foo: Union[List[Value], ValueList]
-        class F:
-            foo: Union[Value, List[Value], ValueList]
-
-        self.assertEqual(get_type_hints(C, globals(), locals()), get_type_hints(C, globals(), locals()))
-        self.assertEqual(get_type_hints(C, globals(), locals()),
-                         {'foo': List[Union[str, List[Union[str, List['Value']]]]]})
-        self.assertEqual(get_type_hints(D, globals(), locals()),
-                         {'foo': Union[str, List[Union[str, List['Value']]]]})
-        self.assertEqual(get_type_hints(E, globals(), locals()),
-                         {'foo': Union[
-                             List[Union[str, List[Union[str, List['Value']]]]],
-                             List[Union[str, List['Value']]]
-                         ]
-                          })
-        self.assertEqual(get_type_hints(F, globals(), locals()),
-                         {'foo': Union[
-                             str,
-                             List[Union[str, List['Value']]],
-                             List[Union[str, List[Union[str, List['Value']]]]]
-                         ]
-                          })
-
-    def test_callable_forward(self):
-
-        def foo(a: Callable[['T'], 'T']):
-            pass
-
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': Callable[[T], T]})
-
-    def test_callable_with_ellipsis_forward(self):
-
-        def foo(a: 'Callable[..., T]'):
-            pass
-
-        self.assertEqual(get_type_hints(foo, globals(), locals()),
-                         {'a': Callable[..., T]})
-
-    def test_special_forms_forward(self):
-
-        class C:
-            a: Annotated['ClassVar[int]', (3, 5)] = 4
-            b: Annotated['Final[int]', "const"] = 4
-            x: 'ClassVar' = 4
-            y: 'Final' = 4
-
-        class CF:
-            b: List['Final[int]'] = 4
-
-        self.assertEqual(get_type_hints(C, globals())['a'], ClassVar[int])
-        self.assertEqual(get_type_hints(C, globals())['b'], Final[int])
-        self.assertEqual(get_type_hints(C, globals())['x'], ClassVar)
-        self.assertEqual(get_type_hints(C, globals())['y'], Final)
-        with self.assertRaises(TypeError):
-            get_type_hints(CF, globals()),
-
-    def test_syntax_error(self):
-
-        with self.assertRaises(SyntaxError):
-            Generic['/T']
-
-    def test_delayed_syntax_error(self):
-
-        def foo(a: 'Node[T'):
-            pass
-
-        with self.assertRaises(SyntaxError):
-            get_type_hints(foo)
-
-    def test_syntax_error_empty_string(self):
-        for form in [typing.List, typing.Set, typing.Type, typing.Deque]:
-            with self.subTest(form=form):
-                with self.assertRaises(SyntaxError):
-                    form['']
-
-    def test_name_error(self):
-
-        def foo(a: 'Noode[T]'):
-            pass
-
-        with self.assertRaises(NameError):
-            get_type_hints(foo, locals())
-
-    def test_no_type_check(self):
-
-        @no_type_check
-        def foo(a: 'whatevers') -> {}:
-            pass
-
-        th = get_type_hints(foo)
-        self.assertEqual(th, {})
-
-    def test_no_type_check_class(self):
-
-        @no_type_check
-        class C:
-            def foo(a: 'whatevers') -> {}:
-                pass
-
-        cth = get_type_hints(C.foo)
-        self.assertEqual(cth, {})
-        ith = get_type_hints(C().foo)
-        self.assertEqual(ith, {})
-
-    def test_no_type_check_no_bases(self):
-        class C:
-            def meth(self, x: int): ...
-        @no_type_check
-        class D(C):
-            c = C
-
-        # verify that @no_type_check never affects bases
-        self.assertEqual(get_type_hints(C.meth), {'x': int})
-
-        # and never child classes:
-        class Child(D):
-            def foo(self, x: int): ...
-
-        self.assertEqual(get_type_hints(Child.foo), {'x': int})
-
-    def test_no_type_check_nested_types(self):
-        # See https://bugs.python.org/issue46571
-        class Other:
-            o: int
-        class B:  # Has the same `__name__`` as `A.B` and different `__qualname__`
-            o: int
-        @no_type_check
-        class A:
-            a: int
-            class B:
-                b: int
-                class C:
-                    c: int
-            class D:
-                d: int
-
-            Other = Other
-
-        for klass in [A, A.B, A.B.C, A.D]:
-            with self.subTest(klass=klass):
-                self.assertTrue(klass.__no_type_check__)
-                self.assertEqual(get_type_hints(klass), {})
-
-        for not_modified in [Other, B]:
-            with self.subTest(not_modified=not_modified):
-                with self.assertRaises(AttributeError):
-                    not_modified.__no_type_check__
-                self.assertNotEqual(get_type_hints(not_modified), {})
-
-    def test_no_type_check_class_and_static_methods(self):
-        @no_type_check
-        class Some:
-            @staticmethod
-            def st(x: int) -> int: ...
-            @classmethod
-            def cl(cls, y: int) -> int: ...
-
-        self.assertTrue(Some.st.__no_type_check__)
-        self.assertEqual(get_type_hints(Some.st), {})
-        self.assertTrue(Some.cl.__no_type_check__)
-        self.assertEqual(get_type_hints(Some.cl), {})
-
-    def test_no_type_check_other_module(self):
-        self.assertTrue(NoTypeCheck_Outer.__no_type_check__)
-        with self.assertRaises(AttributeError):
-            ann_module8.NoTypeCheck_Outer.__no_type_check__
-        with self.assertRaises(AttributeError):
-            ann_module8.NoTypeCheck_Outer.Inner.__no_type_check__
-
-        self.assertTrue(NoTypeCheck_WithFunction.__no_type_check__)
-        with self.assertRaises(AttributeError):
-            ann_module8.NoTypeCheck_function.__no_type_check__
-
-    def test_no_type_check_foreign_functions(self):
-        # We should not modify this function:
-        def some(*args: int) -> int:
-            ...
-
-        @no_type_check
-        class A:
-            some_alias = some
-            some_class = classmethod(some)
-            some_static = staticmethod(some)
-
-        with self.assertRaises(AttributeError):
-            some.__no_type_check__
-        self.assertEqual(get_type_hints(some), {'args': int, 'return': int})
-
-    def test_no_type_check_lambda(self):
-        @no_type_check
-        class A:
-            # Corner case: `lambda` is both an assignment and a function:
-            bar: Callable[[int], int] = lambda arg: arg
-
-        self.assertTrue(A.bar.__no_type_check__)
-        self.assertEqual(get_type_hints(A.bar), {})
-
-    def test_no_type_check_TypeError(self):
-        # This simply should not fail with
-        # `TypeError: can't set attributes of built-in/extension type 'dict'`
-        no_type_check(dict)
-
-    def test_no_type_check_forward_ref_as_string(self):
-        class C:
-            foo: typing.ClassVar[int] = 7
-        class D:
-            foo: ClassVar[int] = 7
-        class E:
-            foo: 'typing.ClassVar[int]' = 7
-        class F:
-            foo: 'ClassVar[int]' = 7
-
-        expected_result = {'foo': typing.ClassVar[int]}
-        for clazz in [C, D, E, F]:
-            self.assertEqual(get_type_hints(clazz), expected_result)
-
-    def test_meta_no_type_check(self):
-        depr_msg = (
-            "'typing.no_type_check_decorator' is deprecated "
-            "and slated for removal in Python 3.15"
-        )
-        with self.assertWarnsRegex(DeprecationWarning, depr_msg):
-            @no_type_check_decorator
-            def magic_decorator(func):
-                return func
-
-        self.assertEqual(magic_decorator.__name__, 'magic_decorator')
-
-        @magic_decorator
-        def foo(a: 'whatevers') -> {}:
-            pass
-
-        @magic_decorator
-        class C:
-            def foo(a: 'whatevers') -> {}:
-                pass
-
-        self.assertEqual(foo.__name__, 'foo')
-        th = get_type_hints(foo)
-        self.assertEqual(th, {})
-        cth = get_type_hints(C.foo)
-        self.assertEqual(cth, {})
-        ith = get_type_hints(C().foo)
-        self.assertEqual(ith, {})
-
-    def test_default_globals(self):
-        code = ("class C:\n"
-                "    def foo(self, a: 'C') -> 'D': pass\n"
-                "class D:\n"
-                "    def bar(self, b: 'D') -> C: pass\n"
-                )
-        ns = {}
-        exec(code, ns)
-        hints = get_type_hints(ns['C'].foo)
-        self.assertEqual(hints, {'a': ns['C'], 'return': ns['D']})
-
-    def test_final_forward_ref(self):
-        self.assertEqual(gth(Loop, globals())['attr'], Final[Loop])
-        self.assertNotEqual(gth(Loop, globals())['attr'], Final[int])
-        self.assertNotEqual(gth(Loop, globals())['attr'], Final)
-
-    def test_or(self):
-        X = ForwardRef('X')
-        # __or__/__ror__ itself
-        self.assertEqual(X | "x", Union[X, "x"])
-        self.assertEqual("x" | X, Union["x", X])
+        self.assertEqual(foo.__name__, 'foo')
+        th = get_type_hints(foo)
+        self.assertEqual(th, {})
+        cth = get_type_hints(C.foo)
+        self.assertEqual(cth, {})
+        ith = get_type_hints(C().foo)
+        self.assertEqual(ith, {})
 
 
 class InternalsTests(BaseTestCase):
@@ -6581,6 +6415,16 @@ def test_collect_parameters(self):
             typing._collect_parameters
         self.assertEqual(cm.filename, __file__)
 
+    @cpython_only
+    def test_lazy_import(self):
+        import_helper.ensure_lazy_imports("typing", {
+            "warnings",
+            "inspect",
+            "re",
+            "contextlib",
+            "annotationlib",
+        })
+
 
 @lru_cache()
 def cached_func(x, y):
@@ -6687,10 +6531,6 @@ def test_overload_registry_repeated(self):
             self.assertEqual(list(get_overloads(impl)), overloads)
 
 
-from test.typinganndata import (
-    ann_module, ann_module2, ann_module3, ann_module5, ann_module6,
-)
-
 T_a = TypeVar('T_a')
 
 class AwaitableWrapper(typing.Awaitable[T_a]):
@@ -6843,7 +6683,7 @@ def nested(self: 'ForRefExample'):
         pass
 
 
-class GetTypeHintTests(BaseTestCase):
+class GetTypeHintsTests(BaseTestCase):
     def test_get_type_hints_from_various_objects(self):
         # For invalid objects should fail with TypeError (not AttributeError etc).
         with self.assertRaises(TypeError):
@@ -6853,9 +6693,8 @@ def test_get_type_hints_from_various_objects(self):
         with self.assertRaises(TypeError):
             gth(None)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get_type_hints_modules(self):
-        ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
+        ann_module_type_hints = {'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
         self.assertEqual(gth(ann_module), ann_module_type_hints)
         self.assertEqual(gth(ann_module2), {})
         self.assertEqual(gth(ann_module3), {})
@@ -6869,12 +6708,12 @@ def test_get_type_hints_modules_forwardref(self):
                      'default_b': Optional[mod_generics_cache.B]}
         self.assertEqual(gth(mod_generics_cache), mgc_hints)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; test expects outdated result
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + {'x': <class 'int'>}
     def test_get_type_hints_classes(self):
         self.assertEqual(gth(ann_module.C),  # gth will find the right globalns
                          {'y': Optional[ann_module.C]})
         self.assertIsInstance(gth(ann_module.j_class), dict)
-        self.assertEqual(gth(ann_module.M), {'123': 123, 'o': type})
+        self.assertEqual(gth(ann_module.M), {'o': type})
         self.assertEqual(gth(ann_module.D),
                          {'j': str, 'k': str, 'y': Optional[ann_module.C]})
         self.assertEqual(gth(ann_module.Y), {'z': int})
@@ -6905,8 +6744,8 @@ def test_respect_no_type_check(self):
         class NoTpCheck:
             class Inn:
                 def __init__(self, x: 'not a type'): ...
-        self.assertTrue(NoTpCheck.__no_type_check__)
-        self.assertTrue(NoTpCheck.Inn.__init__.__no_type_check__)
+        self.assertIs(NoTpCheck.__no_type_check__, True)
+        self.assertIs(NoTpCheck.Inn.__init__.__no_type_check__, True)
         self.assertEqual(gth(ann_module2.NTC.meth), {})
         class ABase(Generic[T]):
             def meth(x: int): ...
@@ -7052,111 +6891,320 @@ def __iand__(self, other: Const["MySet[T]"]) -> "MySet[T]":
             {'other': MySet[T], 'return': MySet[T]}
         )
 
-    def test_get_type_hints_annotated_with_none_default(self):
-        # See: https://bugs.python.org/issue46195
-        def annotated_with_none_default(x: Annotated[int, 'data'] = None): ...
-        self.assertEqual(
-            get_type_hints(annotated_with_none_default),
-            {'x': int},
-        )
-        self.assertEqual(
-            get_type_hints(annotated_with_none_default, include_extras=True),
-            {'x': Annotated[int, 'data']},
-        )
+    def test_get_type_hints_annotated_with_none_default(self):
+        # See: https://bugs.python.org/issue46195
+        def annotated_with_none_default(x: Annotated[int, 'data'] = None): ...
+        self.assertEqual(
+            get_type_hints(annotated_with_none_default),
+            {'x': int},
+        )
+        self.assertEqual(
+            get_type_hints(annotated_with_none_default, include_extras=True),
+            {'x': Annotated[int, 'data']},
+        )
+
+    def test_get_type_hints_classes_str_annotations(self):
+        class Foo:
+            y = str
+            x: 'y'
+        # This previously raised an error under PEP 563.
+        self.assertEqual(get_type_hints(Foo), {'x': str})
+
+    def test_get_type_hints_bad_module(self):
+        # bpo-41515
+        class BadModule:
+            pass
+        BadModule.__module__ = 'bad' # Something not in sys.modules
+        self.assertNotIn('bad', sys.modules)
+        self.assertEqual(get_type_hints(BadModule), {})
+
+    def test_get_type_hints_annotated_bad_module(self):
+        # See https://bugs.python.org/issue44468
+        class BadBase:
+            foo: tuple
+        class BadType(BadBase):
+            bar: list
+        BadType.__module__ = BadBase.__module__ = 'bad'
+        self.assertNotIn('bad', sys.modules)
+        self.assertEqual(get_type_hints(BadType), {'foo': tuple, 'bar': list})
+
+    def test_forward_ref_and_final(self):
+        # https://bugs.python.org/issue45166
+        hints = get_type_hints(ann_module5)
+        self.assertEqual(hints, {'name': Final[str]})
+
+        hints = get_type_hints(ann_module5.MyClass)
+        self.assertEqual(hints, {'value': Final})
+
+    def test_top_level_class_var(self):
+        # This is not meaningful but we don't raise for it.
+        # https://github.com/python/cpython/issues/133959
+        hints = get_type_hints(ann_module6)
+        self.assertEqual(hints, {'wrong': ClassVar[int]})
+
+    def test_get_type_hints_typeddict(self):
+        self.assertEqual(get_type_hints(TotalMovie), {'title': str, 'year': int})
+        self.assertEqual(get_type_hints(TotalMovie, include_extras=True), {
+            'title': str,
+            'year': NotRequired[int],
+        })
+
+        self.assertEqual(get_type_hints(AnnotatedMovie), {'title': str, 'year': int})
+        self.assertEqual(get_type_hints(AnnotatedMovie, include_extras=True), {
+            'title': Annotated[Required[str], "foobar"],
+            'year': NotRequired[Annotated[int, 2000]],
+        })
+
+        self.assertEqual(get_type_hints(DeeplyAnnotatedMovie), {'title': str, 'year': int})
+        self.assertEqual(get_type_hints(DeeplyAnnotatedMovie, include_extras=True), {
+            'title': Annotated[Required[str], "foobar", "another level"],
+            'year': NotRequired[Annotated[int, 2000]],
+        })
+
+        self.assertEqual(get_type_hints(WeirdlyQuotedMovie), {'title': str, 'year': int})
+        self.assertEqual(get_type_hints(WeirdlyQuotedMovie, include_extras=True), {
+            'title': Annotated[Required[str], "foobar", "another level"],
+            'year': NotRequired[Annotated[int, 2000]],
+        })
+
+        self.assertEqual(get_type_hints(_typed_dict_helper.VeryAnnotated), {'a': int})
+        self.assertEqual(get_type_hints(_typed_dict_helper.VeryAnnotated, include_extras=True), {
+            'a': Annotated[Required[int], "a", "b", "c"]
+        })
+
+        self.assertEqual(get_type_hints(ChildTotalMovie), {"title": str, "year": int})
+        self.assertEqual(get_type_hints(ChildTotalMovie, include_extras=True), {
+            "title": Required[str], "year": NotRequired[int]
+        })
+
+        self.assertEqual(get_type_hints(ChildDeeplyAnnotatedMovie), {"title": str, "year": int})
+        self.assertEqual(get_type_hints(ChildDeeplyAnnotatedMovie, include_extras=True), {
+            "title": Annotated[Required[str], "foobar", "another level"],
+            "year": NotRequired[Annotated[int, 2000]]
+        })
+
+    def test_get_type_hints_collections_abc_callable(self):
+        # https://github.com/python/cpython/issues/91621
+        P = ParamSpec('P')
+        def f(x: collections.abc.Callable[[int], int]): ...
+        def g(x: collections.abc.Callable[..., int]): ...
+        def h(x: collections.abc.Callable[P, int]): ...
+
+        self.assertEqual(get_type_hints(f), {'x': collections.abc.Callable[[int], int]})
+        self.assertEqual(get_type_hints(g), {'x': collections.abc.Callable[..., int]})
+        self.assertEqual(get_type_hints(h), {'x': collections.abc.Callable[P, int]})
+
+    def test_get_type_hints_format(self):
+        class C:
+            x: undefined
+
+        with self.assertRaises(NameError):
+            get_type_hints(C)
+
+        with self.assertRaises(NameError):
+            get_type_hints(C, format=annotationlib.Format.VALUE)
+
+        annos = get_type_hints(C, format=annotationlib.Format.FORWARDREF)
+        self.assertIsInstance(annos, dict)
+        self.assertEqual(list(annos), ['x'])
+        self.assertIsInstance(annos['x'], annotationlib.ForwardRef)
+        self.assertEqual(annos['x'].__arg__, 'undefined')
+
+        self.assertEqual(get_type_hints(C, format=annotationlib.Format.STRING),
+                         {'x': 'undefined'})
+        # Make sure using an int as format also works:
+        self.assertEqual(get_type_hints(C, format=4), {'x': 'undefined'})
+
+    def test_get_type_hints_format_function(self):
+        def func(x: undefined) -> undefined: ...
+
+        # VALUE
+        with self.assertRaises(NameError):
+            get_type_hints(func)
+        with self.assertRaises(NameError):
+            get_type_hints(func, format=annotationlib.Format.VALUE)
+
+        # FORWARDREF
+        self.assertEqual(
+            get_type_hints(func, format=annotationlib.Format.FORWARDREF),
+            {'x': EqualToForwardRef('undefined', owner=func),
+             'return': EqualToForwardRef('undefined', owner=func)},
+        )
+
+        # STRING
+        self.assertEqual(get_type_hints(func, format=annotationlib.Format.STRING),
+                         {'x': 'undefined', 'return': 'undefined'})
+
+    def test_callable_with_ellipsis_forward(self):
+
+        def foo(a: 'Callable[..., T]'):
+            pass
+
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': Callable[..., T]})
+
+    def test_special_forms_no_forward(self):
+        def f(x: ClassVar[int]):
+            pass
+        self.assertEqual(get_type_hints(f), {'x': ClassVar[int]})
+
+    def test_special_forms_forward(self):
+
+        class C:
+            a: Annotated['ClassVar[int]', (3, 5)] = 4
+            b: Annotated['Final[int]', "const"] = 4
+            x: 'ClassVar' = 4
+            y: 'Final' = 4
+
+        class CF:
+            b: List['Final[int]'] = 4
+
+        self.assertEqual(get_type_hints(C, globals())['a'], ClassVar[int])
+        self.assertEqual(get_type_hints(C, globals())['b'], Final[int])
+        self.assertEqual(get_type_hints(C, globals())['x'], ClassVar)
+        self.assertEqual(get_type_hints(C, globals())['y'], Final)
+        lfi = get_type_hints(CF, globals())['b']
+        self.assertIs(get_origin(lfi), list)
+        self.assertEqual(get_args(lfi), (Final[int],))
+
+    def test_union_forward_recursion(self):
+        ValueList = List['Value']
+        Value = Union[str, ValueList]
+
+        class C:
+            foo: List[Value]
+        class D:
+            foo: Union[Value, ValueList]
+        class E:
+            foo: Union[List[Value], ValueList]
+        class F:
+            foo: Union[Value, List[Value], ValueList]
+
+        self.assertEqual(get_type_hints(C, globals(), locals()), get_type_hints(C, globals(), locals()))
+        self.assertEqual(get_type_hints(C, globals(), locals()),
+                         {'foo': List[Union[str, List[Union[str, List['Value']]]]]})
+        self.assertEqual(get_type_hints(D, globals(), locals()),
+                         {'foo': Union[str, List[Union[str, List['Value']]]]})
+        self.assertEqual(get_type_hints(E, globals(), locals()),
+                         {'foo': Union[
+                             List[Union[str, List[Union[str, List['Value']]]]],
+                             List[Union[str, List['Value']]]
+                         ]
+                          })
+        self.assertEqual(get_type_hints(F, globals(), locals()),
+                         {'foo': Union[
+                             str,
+                             List[Union[str, List['Value']]],
+                             List[Union[str, List[Union[str, List['Value']]]]]
+                         ]
+                          })
+
+    def test_tuple_forward(self):
+
+        def foo(a: Tuple['T']):
+            pass
+
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': Tuple[T]})
+
+        def foo(a: tuple[ForwardRef('T')]):
+            pass
+
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': tuple[T]})
+
+    def test_double_forward(self):
+        def foo(a: 'List[\'int\']'):
+            pass
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': List[int]})
+
+    def test_union_forward(self):
 
-    def test_get_type_hints_classes_str_annotations(self):
-        class Foo:
-            y = str
-            x: 'y'
-        # This previously raised an error under PEP 563.
-        self.assertEqual(get_type_hints(Foo), {'x': str})
+        def foo(a: Union['T']):
+            pass
 
-    def test_get_type_hints_bad_module(self):
-        # bpo-41515
-        class BadModule:
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': Union[T]})
+
+        def foo(a: tuple[ForwardRef('T')] | int):
             pass
-        BadModule.__module__ = 'bad' # Something not in sys.modules
-        self.assertNotIn('bad', sys.modules)
-        self.assertEqual(get_type_hints(BadModule), {})
 
-    def test_get_type_hints_annotated_bad_module(self):
-        # See https://bugs.python.org/issue44468
-        class BadBase:
-            foo: tuple
-        class BadType(BadBase):
-            bar: list
-        BadType.__module__ = BadBase.__module__ = 'bad'
-        self.assertNotIn('bad', sys.modules)
-        self.assertEqual(get_type_hints(BadType), {'foo': tuple, 'bar': list})
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': tuple[T] | int})
 
-    def test_forward_ref_and_final(self):
-        # https://bugs.python.org/issue45166
-        hints = get_type_hints(ann_module5)
-        self.assertEqual(hints, {'name': Final[str]})
+    def test_default_globals(self):
+        code = ("class C:\n"
+                "    def foo(self, a: 'C') -> 'D': pass\n"
+                "class D:\n"
+                "    def bar(self, b: 'D') -> C: pass\n"
+                )
+        ns = {}
+        exec(code, ns)
+        hints = get_type_hints(ns['C'].foo)
+        self.assertEqual(hints, {'a': ns['C'], 'return': ns['D']})
 
-        hints = get_type_hints(ann_module5.MyClass)
-        self.assertEqual(hints, {'value': Final})
+    def test_final_forward_ref(self):
+        gth = get_type_hints
+        self.assertEqual(gth(Loop, globals())['attr'], Final[Loop])
+        self.assertNotEqual(gth(Loop, globals())['attr'], Final[int])
+        self.assertNotEqual(gth(Loop, globals())['attr'], Final)
 
-    def test_top_level_class_var(self):
-        # https://bugs.python.org/issue45166
-        with self.assertRaisesRegex(
-            TypeError,
-            r'typing.ClassVar\[int\] is not valid as type argument',
-        ):
-            get_type_hints(ann_module6)
+    def test_name_error(self):
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
-    def test_get_type_hints_typeddict(self):
-        self.assertEqual(get_type_hints(TotalMovie), {'title': str, 'year': int})
-        self.assertEqual(get_type_hints(TotalMovie, include_extras=True), {
-            'title': str,
-            'year': NotRequired[int],
-        })
+        def foo(a: 'Noode[T]'):
+            pass
 
-        self.assertEqual(get_type_hints(AnnotatedMovie), {'title': str, 'year': int})
-        self.assertEqual(get_type_hints(AnnotatedMovie, include_extras=True), {
-            'title': Annotated[Required[str], "foobar"],
-            'year': NotRequired[Annotated[int, 2000]],
-        })
+        with self.assertRaises(NameError):
+            get_type_hints(foo, locals())
 
-        self.assertEqual(get_type_hints(DeeplyAnnotatedMovie), {'title': str, 'year': int})
-        self.assertEqual(get_type_hints(DeeplyAnnotatedMovie, include_extras=True), {
-            'title': Annotated[Required[str], "foobar", "another level"],
-            'year': NotRequired[Annotated[int, 2000]],
-        })
+    def test_basics(self):
 
-        self.assertEqual(get_type_hints(WeirdlyQuotedMovie), {'title': str, 'year': int})
-        self.assertEqual(get_type_hints(WeirdlyQuotedMovie, include_extras=True), {
-            'title': Annotated[Required[str], "foobar", "another level"],
-            'year': NotRequired[Annotated[int, 2000]],
-        })
+        class Node(Generic[T]):
 
-        self.assertEqual(get_type_hints(_typed_dict_helper.VeryAnnotated), {'a': int})
-        self.assertEqual(get_type_hints(_typed_dict_helper.VeryAnnotated, include_extras=True), {
-            'a': Annotated[Required[int], "a", "b", "c"]
-        })
+            def __init__(self, label: T):
+                self.label = label
+                self.left = self.right = None
 
-        self.assertEqual(get_type_hints(ChildTotalMovie), {"title": str, "year": int})
-        self.assertEqual(get_type_hints(ChildTotalMovie, include_extras=True), {
-            "title": Required[str], "year": NotRequired[int]
-        })
+            def add_both(self,
+                         left: 'Optional[Node[T]]',
+                         right: 'Node[T]' = None,
+                         stuff: int = None,
+                         blah=None):
+                self.left = left
+                self.right = right
 
-        self.assertEqual(get_type_hints(ChildDeeplyAnnotatedMovie), {"title": str, "year": int})
-        self.assertEqual(get_type_hints(ChildDeeplyAnnotatedMovie, include_extras=True), {
-            "title": Annotated[Required[str], "foobar", "another level"],
-            "year": NotRequired[Annotated[int, 2000]]
-        })
+            def add_left(self, node: Optional['Node[T]']):
+                self.add_both(node, None)
 
-    def test_get_type_hints_collections_abc_callable(self):
-        # https://github.com/python/cpython/issues/91621
-        P = ParamSpec('P')
-        def f(x: collections.abc.Callable[[int], int]): ...
-        def g(x: collections.abc.Callable[..., int]): ...
-        def h(x: collections.abc.Callable[P, int]): ...
+            def add_right(self, node: 'Node[T]' = None):
+                self.add_both(None, node)
 
-        self.assertEqual(get_type_hints(f), {'x': collections.abc.Callable[[int], int]})
-        self.assertEqual(get_type_hints(g), {'x': collections.abc.Callable[..., int]})
-        self.assertEqual(get_type_hints(h), {'x': collections.abc.Callable[P, int]})
+        t = Node[int]
+        both_hints = get_type_hints(t.add_both, globals(), locals())
+        self.assertEqual(both_hints['left'], Optional[Node[T]])
+        self.assertEqual(both_hints['right'], Node[T])
+        self.assertEqual(both_hints['stuff'], int)
+        self.assertNotIn('blah', both_hints)
+
+        left_hints = get_type_hints(t.add_left, globals(), locals())
+        self.assertEqual(left_hints['node'], Optional[Node[T]])
+
+        right_hints = get_type_hints(t.add_right, globals(), locals())
+        self.assertEqual(right_hints['node'], Node[T])
+
+    def test_stringified_typeddict(self):
+        ns = run_code(
+            """
+            from __future__ import annotations
+            from typing import TypedDict
+            class TD[UniqueT](TypedDict):
+                a: UniqueT
+            """
+        )
+        TD = ns['TD']
+        self.assertEqual(TD.__annotations__, {'a': EqualToForwardRef('UniqueT', owner=TD, module=TD.__module__)})
+        self.assertEqual(get_type_hints(TD), {'a': TD.__type_params__[0]})
 
 
 class GetUtilitiesTestCase(TestCase):
@@ -7181,7 +7229,7 @@ class C(Generic[T]): pass
         self.assertIs(get_origin(Callable), collections.abc.Callable)
         self.assertIs(get_origin(list[int]), list)
         self.assertIs(get_origin(list), None)
-        self.assertIs(get_origin(list | str), types.UnionType)
+        self.assertIs(get_origin(list | str), Union)
         self.assertIs(get_origin(P.args), P)
         self.assertIs(get_origin(P.kwargs), P)
         self.assertIs(get_origin(Required[int]), Required)
@@ -7260,6 +7308,125 @@ class C(Generic[T]): pass
         self.assertEqual(get_args(Unpack[tuple[Unpack[Ts]]]), (tuple[Unpack[Ts]],))
 
 
+class EvaluateForwardRefTests(BaseTestCase):
+    def test_evaluate_forward_ref(self):
+        int_ref = ForwardRef('int')
+        self.assertIs(typing.evaluate_forward_ref(int_ref), int)
+        self.assertIs(
+            typing.evaluate_forward_ref(int_ref, type_params=()),
+            int,
+        )
+        self.assertIs(
+            typing.evaluate_forward_ref(int_ref, format=annotationlib.Format.VALUE),
+            int,
+        )
+        self.assertIs(
+            typing.evaluate_forward_ref(
+                int_ref, format=annotationlib.Format.FORWARDREF,
+            ),
+            int,
+        )
+        self.assertEqual(
+            typing.evaluate_forward_ref(
+                int_ref, format=annotationlib.Format.STRING,
+            ),
+            'int',
+        )
+
+    def test_evaluate_forward_ref_undefined(self):
+        missing = ForwardRef('missing')
+        with self.assertRaises(NameError):
+            typing.evaluate_forward_ref(missing)
+        self.assertIs(
+            typing.evaluate_forward_ref(
+                missing, format=annotationlib.Format.FORWARDREF,
+            ),
+            missing,
+        )
+        self.assertEqual(
+            typing.evaluate_forward_ref(
+                missing, format=annotationlib.Format.STRING,
+            ),
+            "missing",
+        )
+
+    def test_evaluate_forward_ref_nested(self):
+        ref = ForwardRef("int | list['str']")
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref),
+            int | list[str],
+        )
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref, format=annotationlib.Format.FORWARDREF),
+            int | list[str],
+        )
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref, format=annotationlib.Format.STRING),
+            "int | list['str']",
+        )
+
+        why = ForwardRef('"\'str\'"')
+        self.assertIs(typing.evaluate_forward_ref(why), str)
+
+    def test_evaluate_forward_ref_none(self):
+        none_ref = ForwardRef('None')
+        self.assertIs(typing.evaluate_forward_ref(none_ref), None)
+
+    def test_globals(self):
+        A = "str"
+        ref = ForwardRef('list[A]')
+        with self.assertRaises(NameError):
+            typing.evaluate_forward_ref(ref)
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref, globals={'A': A}),
+            list[str],
+        )
+
+    def test_owner(self):
+        ref = ForwardRef("A")
+
+        with self.assertRaises(NameError):
+            typing.evaluate_forward_ref(ref)
+
+        # We default to the globals of `owner`,
+        # so it no longer raises `NameError`
+        self.assertIs(
+            typing.evaluate_forward_ref(ref, owner=Loop), A
+        )
+
+    def test_inherited_owner(self):
+        # owner passed to evaluate_forward_ref
+        ref = ForwardRef("list['A']")
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref, owner=Loop),
+            list[A],
+        )
+
+        # owner set on the ForwardRef
+        ref = ForwardRef("list['A']", owner=Loop)
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref),
+            list[A],
+        )
+
+    def test_partial_evaluation(self):
+        ref = ForwardRef("list[A]")
+        with self.assertRaises(NameError):
+            typing.evaluate_forward_ref(ref)
+
+        self.assertEqual(
+            typing.evaluate_forward_ref(ref, format=annotationlib.Format.FORWARDREF),
+            list[EqualToForwardRef('A')],
+        )
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ImportError: cannot import name 'fwdref_module'
+    def test_with_module(self):
+        from test.typinganndata import fwdref_module
+
+        typing.evaluate_forward_ref(
+            fwdref_module.fw,)
+
+
 class CollectionsAbcTests(BaseTestCase):
 
     def test_hashable(self):
@@ -7987,6 +8154,48 @@ class XMethBad2(NamedTuple):
                 def _source(self):
                     return 'no chance for this as well'
 
+    def test_annotation_type_check(self):
+        # These are rejected by _type_check
+        with self.assertRaises(TypeError):
+            class X(NamedTuple):
+                a: Final
+        with self.assertRaises(TypeError):
+            class Y(NamedTuple):
+                a: (1, 2)
+
+        # Conversion by _type_convert
+        class Z(NamedTuple):
+            a: None
+            b: "str"
+        annos = {'a': type(None), 'b': EqualToForwardRef("str")}
+        self.assertEqual(Z.__annotations__, annos)
+        self.assertEqual(Z.__annotate__(annotationlib.Format.VALUE), annos)
+        self.assertEqual(Z.__annotate__(annotationlib.Format.FORWARDREF), annos)
+        self.assertEqual(Z.__annotate__(annotationlib.Format.STRING), {"a": "None", "b": "str"})
+
+    def test_future_annotations(self):
+        code = """
+        from __future__ import annotations
+        from typing import NamedTuple
+        class X(NamedTuple):
+            a: int
+            b: None
+        """
+        ns = run_code(textwrap.dedent(code))
+        X = ns['X']
+        self.assertEqual(X.__annotations__, {'a': EqualToForwardRef("int"), 'b': EqualToForwardRef("None")})
+
+    def test_deferred_annotations(self):
+        class X(NamedTuple):
+            y: undefined
+
+        self.assertEqual(X._fields, ('y',))
+        with self.assertRaises(NameError):
+            X.__annotations__
+
+        undefined = int
+        self.assertEqual(X.__annotations__, {'y': int})
+
     def test_multiple_inheritance(self):
         class A:
             pass
@@ -8233,7 +8442,7 @@ class Bar(NamedTuple):
         self.assertIsInstance(bar.attr, Vanilla)
         self.assertEqual(bar.attr.name, "attr")
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_setname_raises_the_same_as_on_other_classes(self):
         class CustomException(BaseException): pass
 
@@ -8288,6 +8497,23 @@ class VeryAnnoying(metaclass=Meta): pass
             class Foo(NamedTuple):
                 attr = very_annoying
 
+    def test_super_explicitly_disallowed(self):
+        expected_message = (
+            "uses of super() and __class__ are unsupported "
+            "in methods of NamedTuple subclasses"
+        )
+
+        with self.assertRaises(TypeError, msg=expected_message):
+            class ThisWontWork(NamedTuple):
+                def __repr__(self):
+                    return super().__repr__()
+
+        with self.assertRaises(TypeError, msg=expected_message):
+            class ThisWontWorkEither(NamedTuple):
+                @property
+                def name(self):
+                    return __class__.__name__
+
 
 class TypedDictTests(BaseTestCase):
     def test_basics_functional_syntax(self):
@@ -8302,7 +8528,11 @@ def test_basics_functional_syntax(self):
         self.assertEqual(Emp.__name__, 'Emp')
         self.assertEqual(Emp.__module__, __name__)
         self.assertEqual(Emp.__bases__, (dict,))
-        self.assertEqual(Emp.__annotations__, {'name': str, 'id': int})
+        annos = {'name': str, 'id': int}
+        self.assertEqual(Emp.__annotations__, annos)
+        self.assertEqual(Emp.__annotate__(annotationlib.Format.VALUE), annos)
+        self.assertEqual(Emp.__annotate__(annotationlib.Format.FORWARDREF), annos)
+        self.assertEqual(Emp.__annotate__(annotationlib.Format.STRING), {'name': 'str', 'id': 'int'})
         self.assertEqual(Emp.__total__, True)
         self.assertEqual(Emp.__required_keys__, {'name', 'id'})
         self.assertIsInstance(Emp.__required_keys__, frozenset)
@@ -8501,6 +8731,36 @@ class Child(Base1, Base2):
         self.assertEqual(Child.__required_keys__, frozenset(['a']))
         self.assertEqual(Child.__optional_keys__, frozenset())
 
+    def test_inheritance_pep563(self):
+        def _make_td(future, class_name, annos, base, extra_names=None):
+            lines = []
+            if future:
+                lines.append('from __future__ import annotations')
+            lines.append('from typing import TypedDict')
+            lines.append(f'class {class_name}({base}):')
+            for name, anno in annos.items():
+                lines.append(f'    {name}: {anno}')
+            code = '\n'.join(lines)
+            ns = run_code(code, extra_names)
+            return ns[class_name]
+
+        for base_future in (True, False):
+            for child_future in (True, False):
+                with self.subTest(base_future=base_future, child_future=child_future):
+                    base = _make_td(
+                        base_future, "Base", {"base": "int"}, "TypedDict"
+                    )
+                    self.assertIsNotNone(base.__annotate__)
+                    child = _make_td(
+                        child_future, "Child", {"child": "int"}, "Base", {"Base": base}
+                    )
+                    base_anno = ForwardRef("int", module="builtins", owner=base) if base_future else int
+                    child_anno = ForwardRef("int", module="builtins", owner=child) if child_future else int
+                    self.assertEqual(base.__annotations__, {'base': base_anno})
+                    self.assertEqual(
+                        child.__annotations__, {'child': child_anno, 'base': base_anno}
+                    )
+
     def test_required_notrequired_keys(self):
         self.assertEqual(NontotalMovie.__required_keys__,
                          frozenset({"title"}))
@@ -8649,14 +8909,14 @@ class NewGeneric[T](TypedDict):
         # The TypedDict constructor is not itself a TypedDict
         self.assertIs(is_typeddict(TypedDict), False)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_get_type_hints(self):
         self.assertEqual(
             get_type_hints(Bar),
             {'a': typing.Optional[int], 'b': int}
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_get_type_hints_generic(self):
         self.assertEqual(
             get_type_hints(BarGeneric),
@@ -8681,6 +8941,8 @@ class A[T](TypedDict):
         self.assertEqual(A.__bases__, (Generic, dict))
         self.assertEqual(A.__orig_bases__, (TypedDict, Generic[T]))
         self.assertEqual(A.__mro__, (A, Generic, dict, object))
+        self.assertEqual(A.__annotations__, {'a': T})
+        self.assertEqual(A.__annotate__(annotationlib.Format.STRING), {'a': 'T'})
         self.assertEqual(A.__parameters__, (T,))
         self.assertEqual(A[str].__parameters__, ())
         self.assertEqual(A[str].__args__, (str,))
@@ -8692,6 +8954,8 @@ class A(TypedDict, Generic[T]):
         self.assertEqual(A.__bases__, (Generic, dict))
         self.assertEqual(A.__orig_bases__, (TypedDict, Generic[T]))
         self.assertEqual(A.__mro__, (A, Generic, dict, object))
+        self.assertEqual(A.__annotations__, {'a': T})
+        self.assertEqual(A.__annotate__(annotationlib.Format.STRING), {'a': 'T'})
         self.assertEqual(A.__parameters__, (T,))
         self.assertEqual(A[str].__parameters__, ())
         self.assertEqual(A[str].__args__, (str,))
@@ -8702,6 +8966,8 @@ class A2(Generic[T], TypedDict):
         self.assertEqual(A2.__bases__, (Generic, dict))
         self.assertEqual(A2.__orig_bases__, (Generic[T], TypedDict))
         self.assertEqual(A2.__mro__, (A2, Generic, dict, object))
+        self.assertEqual(A2.__annotations__, {'a': T})
+        self.assertEqual(A2.__annotate__(annotationlib.Format.STRING), {'a': 'T'})
         self.assertEqual(A2.__parameters__, (T,))
         self.assertEqual(A2[str].__parameters__, ())
         self.assertEqual(A2[str].__args__, (str,))
@@ -8712,6 +8978,8 @@ class B(A[KT], total=False):
         self.assertEqual(B.__bases__, (Generic, dict))
         self.assertEqual(B.__orig_bases__, (A[KT],))
         self.assertEqual(B.__mro__, (B, Generic, dict, object))
+        self.assertEqual(B.__annotations__, {'a': T, 'b': KT})
+        self.assertEqual(B.__annotate__(annotationlib.Format.STRING), {'a': 'T', 'b': 'KT'})
         self.assertEqual(B.__parameters__, (KT,))
         self.assertEqual(B.__total__, False)
         self.assertEqual(B.__optional_keys__, frozenset(['b']))
@@ -8736,6 +9004,11 @@ class C(B[int]):
             'b': KT,
             'c': int,
         })
+        self.assertEqual(C.__annotate__(annotationlib.Format.STRING), {
+            'a': 'T',
+            'b': 'KT',
+            'c': 'int',
+        })
         with self.assertRaises(TypeError):
             C[str]
 
@@ -8755,6 +9028,11 @@ class Point3D(Point2DGeneric[T], Generic[T, KT]):
             'b': T,
             'c': KT,
         })
+        self.assertEqual(Point3D.__annotate__(annotationlib.Format.STRING), {
+            'a': 'T',
+            'b': 'T',
+            'c': 'KT',
+        })
         self.assertEqual(Point3D[int, str].__origin__, Point3D)
 
         with self.assertRaises(TypeError):
@@ -8786,10 +9064,15 @@ class WithImplicitAny(B):
             'b': KT,
             'c': int,
         })
+        self.assertEqual(WithImplicitAny.__annotate__(annotationlib.Format.STRING), {
+            'a': 'T',
+            'b': 'KT',
+            'c': 'int',
+        })
         with self.assertRaises(TypeError):
             WithImplicitAny[str]
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_non_generic_subscript(self):
         # For backward compatibility, subscription works
         # on arbitrary TypedDict types.
@@ -8917,7 +9200,7 @@ class Child(Base):
         self.assertEqual(Child.__readonly_keys__, frozenset())
         self.assertEqual(Child.__mutable_keys__, frozenset({'a'}))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_combine_qualifiers(self):
         class AllTheThings(TypedDict):
             a: Annotated[Required[ReadOnly[int]], "why not"]
@@ -8944,6 +9227,54 @@ class AllTheThings(TypedDict):
             },
         )
 
+    def test_annotations(self):
+        # _type_check is applied
+        with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"):
+            class X(TypedDict):
+                a: Final
+
+        # _type_convert is applied
+        class Y(TypedDict):
+            a: None
+            b: "int"
+        fwdref = EqualToForwardRef('int', module=__name__)
+        self.assertEqual(Y.__annotations__, {'a': type(None), 'b': fwdref})
+        self.assertEqual(Y.__annotate__(annotationlib.Format.FORWARDREF), {'a': type(None), 'b': fwdref})
+
+        # _type_check is also applied later
+        class Z(TypedDict):
+            a: undefined
+
+        with self.assertRaises(NameError):
+            Z.__annotations__
+
+        undefined = Final
+        with self.assertRaisesRegex(TypeError, "Plain typing.Final is not valid as type argument"):
+            Z.__annotations__
+
+        undefined = None
+        self.assertEqual(Z.__annotations__, {'a': type(None)})
+
+    def test_deferred_evaluation(self):
+        class A(TypedDict):
+            x: NotRequired[undefined]
+            y: ReadOnly[undefined]
+            z: Required[undefined]
+
+        self.assertEqual(A.__required_keys__, frozenset({'y', 'z'}))
+        self.assertEqual(A.__optional_keys__, frozenset({'x'}))
+        self.assertEqual(A.__readonly_keys__, frozenset({'y'}))
+        self.assertEqual(A.__mutable_keys__, frozenset({'x', 'z'}))
+
+        with self.assertRaises(NameError):
+            A.__annotations__
+
+        self.assertEqual(
+            A.__annotate__(annotationlib.Format.STRING),
+            {'x': 'NotRequired[undefined]', 'y': 'ReadOnly[undefined]',
+             'z': 'Required[undefined]'},
+        )
+
 
 class RequiredTests(BaseTestCase):
 
@@ -9111,7 +9442,7 @@ def test_repr(self):
         self.assertEqual(repr(Match[str]), 'typing.Match[str]')
         self.assertEqual(repr(Match[bytes]), 'typing.Match[bytes]')
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cannot_subclass(self):
         with self.assertRaisesRegex(
             TypeError,
@@ -9588,6 +9919,19 @@ class B(str): ...
         self.assertIs(type(field_c2.__metadata__[0]), float)
         self.assertIs(type(field_c3.__metadata__[0]), bool)
 
+    def test_forwardref_partial_evaluation(self):
+        # Test that Annotated partially evaluates if it contains a ForwardRef
+        # See: https://github.com/python/cpython/issues/137706
+        def f(x: Annotated[undefined, '']): pass
+
+        ann = annotationlib.get_annotations(f, format=annotationlib.Format.FORWARDREF)
+
+        # Test that the attributes are retrievable from the partially evaluated annotation
+        x_ann = ann['x']
+        self.assertIs(get_origin(x_ann), Annotated)
+        self.assertEqual(x_ann.__origin__, EqualToForwardRef('undefined', owner=f))
+        self.assertEqual(x_ann.__metadata__, ('',))
+
 
 class TypeAliasTests(BaseTestCase):
     def test_canonical_usage_with_variable_annotation(self):
@@ -10094,6 +10438,7 @@ def test_var_substitution(self):
         self.assertEqual(C[Concatenate[str, P2]], Concatenate[int, str, P2])
         self.assertEqual(C[...], Concatenate[int, ...])
 
+
 class TypeGuardTests(BaseTestCase):
     def test_basics(self):
         TypeGuard[int]  # OK
@@ -10285,7 +10630,6 @@ def test_special_attrs(self):
             typing.ClassVar: 'ClassVar',
             typing.Concatenate: 'Concatenate',
             typing.Final: 'Final',
-            typing.ForwardRef: 'ForwardRef',
             typing.Literal: 'Literal',
             typing.NewType: 'NewType',
             typing.NoReturn: 'NoReturn',
@@ -10295,9 +10639,8 @@ def test_special_attrs(self):
             typing.TypeGuard: 'TypeGuard',
             typing.TypeIs: 'TypeIs',
             typing.TypeVar: 'TypeVar',
-            typing.Union: 'Union',
             typing.Self: 'Self',
-            # Subscribed special forms
+            # Subscripted special forms
             typing.Annotated[Any, "Annotation"]: 'Annotated',
             typing.Annotated[int, 'Annotation']: 'Annotated',
             typing.ClassVar[Any]: 'ClassVar',
@@ -10306,13 +10649,12 @@ def test_special_attrs(self):
             typing.Literal[Any]: 'Literal',
             typing.Literal[1, 2]: 'Literal',
             typing.Literal[True, 2]: 'Literal',
-            typing.Optional[Any]: 'Optional',
+            typing.Optional[Any]: 'Union',
             typing.TypeGuard[Any]: 'TypeGuard',
             typing.TypeIs[Any]: 'TypeIs',
             typing.Union[Any]: 'Any',
             typing.Union[int, float]: 'Union',
             # Incompatible special forms (tested in test_special_attrs2)
-            # - typing.ForwardRef('set[Any]')
             # - typing.NewType('TypeName', Any)
             # - typing.ParamSpec('SpecialAttrsP')
             # - typing.TypeVar('T')
@@ -10326,23 +10668,14 @@ def test_special_attrs(self):
                 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
                     s = pickle.dumps(cls, proto)
                     loaded = pickle.loads(s)
-                    self.assertIs(cls, loaded)
+                    if isinstance(cls, Union):
+                        self.assertEqual(cls, loaded)
+                    else:
+                        self.assertIs(cls, loaded)
 
     TypeName = typing.NewType('SpecialAttrsTests.TypeName', Any)
 
     def test_special_attrs2(self):
-        # Forward refs provide a different introspection API. __name__ and
-        # __qualname__ make little sense for forward refs as they can store
-        # complex typing expressions.
-        fr = typing.ForwardRef('set[Any]')
-        self.assertFalse(hasattr(fr, '__name__'))
-        self.assertFalse(hasattr(fr, '__qualname__'))
-        self.assertEqual(fr.__module__, 'typing')
-        # Forward refs are currently unpicklable.
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            with self.assertRaises(TypeError):
-                pickle.dumps(fr, proto)
-
         self.assertEqual(SpecialAttrsTests.TypeName.__name__, 'TypeName')
         self.assertEqual(
             SpecialAttrsTests.TypeName.__qualname__,
@@ -10363,7 +10696,7 @@ def test_special_attrs2(self):
         # to the variable name to which it is assigned".  Thus, providing
         # __qualname__ is unnecessary.
         self.assertEqual(SpecialAttrsT.__name__, 'SpecialAttrsT')
-        self.assertFalse(hasattr(SpecialAttrsT, '__qualname__'))
+        self.assertNotHasAttr(SpecialAttrsT, '__qualname__')
         self.assertEqual(SpecialAttrsT.__module__, __name__)
         # Module-level type variables are picklable.
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -10372,7 +10705,7 @@ def test_special_attrs2(self):
             self.assertIs(SpecialAttrsT, loaded)
 
         self.assertEqual(SpecialAttrsP.__name__, 'SpecialAttrsP')
-        self.assertFalse(hasattr(SpecialAttrsP, '__qualname__'))
+        self.assertNotHasAttr(SpecialAttrsP, '__qualname__')
         self.assertEqual(SpecialAttrsP.__module__, __name__)
         # Module-level ParamSpecs are picklable.
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -10521,7 +10854,7 @@ def test_no_call(self):
         with self.assertRaises(TypeError):
             NoDefault()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_no_attributes(self):
         with self.assertRaises(AttributeError):
             NoDefault.foo = 3
@@ -10597,7 +10930,7 @@ class TypeIterationTests(BaseTestCase):
         Annotated[T, ''],
     )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cannot_iterate(self):
         expected_error_regex = "object is not iterable"
         for test_type in self._UNITERABLE_TYPES:
@@ -10615,6 +10948,37 @@ def test_is_not_instance_of_iterable(self):
             self.assertNotIsInstance(type_to_test, collections.abc.Iterable)
 
 
+class UnionGenericAliasTests(BaseTestCase):
+    def test_constructor(self):
+        # Used e.g. in typer, pydantic
+        with self.assertWarns(DeprecationWarning):
+            inst = typing._UnionGenericAlias(typing.Union, (int, str))
+        self.assertEqual(inst, int | str)
+        with self.assertWarns(DeprecationWarning):
+            # name is accepted but ignored
+            inst = typing._UnionGenericAlias(typing.Union, (int, None), name="Optional")
+        self.assertEqual(inst, int | None)
+
+    def test_isinstance(self):
+        # Used e.g. in pydantic
+        with self.assertWarns(DeprecationWarning):
+            self.assertTrue(isinstance(Union[int, str], typing._UnionGenericAlias))
+        with self.assertWarns(DeprecationWarning):
+            self.assertFalse(isinstance(int, typing._UnionGenericAlias))
+
+    def test_eq(self):
+        # type(t) == _UnionGenericAlias is used in vyos
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(Union, typing._UnionGenericAlias)
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(typing._UnionGenericAlias, typing._UnionGenericAlias)
+        with self.assertWarns(DeprecationWarning):
+            self.assertNotEqual(int, typing._UnionGenericAlias)
+
+    def test_hashable(self):
+        self.assertEqual(hash(typing._UnionGenericAlias), hash(Union))
+
+
 def load_tests(loader, tests, pattern):
     import doctest
     tests.addTests(doctest.DocTestSuite(typing))
diff --git a/Lib/typing.py b/Lib/typing.py
index 77caac9eed1..92b78defd11 100644
--- a/Lib/typing.py
+++ b/Lib/typing.py
@@ -27,7 +27,7 @@
 import operator
 import sys
 import types
-from types import WrapperDescriptorType, MethodWrapperType, MethodDescriptorType, GenericAlias
+from types import GenericAlias
 
 from _typing import (
     _idfunc,
@@ -38,6 +38,7 @@
     ParamSpecKwargs,
     TypeAliasType,
     Generic,
+    Union,
     NoDefault,
 )
 
@@ -126,6 +127,7 @@
     'cast',
     'clear_overloads',
     'dataclass_transform',
+    'evaluate_forward_ref',
     'final',
     'get_args',
     'get_origin',
@@ -160,7 +162,6 @@
     'Unpack',
 ]
 
-
 class _LazyAnnotationLib:
     def __getattr__(self, attr):
         global _lazy_annotationlib
@@ -176,7 +177,7 @@ def _type_convert(arg, module=None, *, allow_special_forms=False, owner=None):
     if arg is None:
         return type(None)
     if isinstance(arg, str):
-        return ForwardRef(arg, module=module, is_class=allow_special_forms)
+        return _make_forward_ref(arg, module=module, is_class=allow_special_forms, owner=owner)
     return arg
 
 
@@ -250,21 +251,10 @@ def _type_repr(obj):
     typically enough to uniquely identify a type.  For everything
     else, we fall back on repr(obj).
     """
-    # When changing this function, don't forget about
-    # `_collections_abc._type_repr`, which does the same thing
-    # and must be consistent with this one.
-    if isinstance(obj, type):
-        if obj.__module__ == 'builtins':
-            return obj.__qualname__
-        return f'{obj.__module__}.{obj.__qualname__}'
-    if obj is ...:
-        return '...'
-    if isinstance(obj, types.FunctionType):
-        return obj.__name__
     if isinstance(obj, tuple):
         # Special case for `repr` of types with `ParamSpec`:
         return '[' + ', '.join(_type_repr(t) for t in obj) + ']'
-    return repr(obj)
+    return _lazy_annotationlib.type_repr(obj)
 
 
 def _collect_type_parameters(args, *, enforce_default_ordering: bool = True):
@@ -366,41 +356,11 @@ def _deduplicate(params, *, unhashable_fallback=False):
         if not unhashable_fallback:
             raise
         # Happens for cases like `Annotated[dict, {'x': IntValidator()}]`
-        return _deduplicate_unhashable(params)
-
-def _deduplicate_unhashable(unhashable_params):
-    new_unhashable = []
-    for t in unhashable_params:
-        if t not in new_unhashable:
-            new_unhashable.append(t)
-    return new_unhashable
-
-def _compare_args_orderless(first_args, second_args):
-    first_unhashable = _deduplicate_unhashable(first_args)
-    second_unhashable = _deduplicate_unhashable(second_args)
-    t = list(second_unhashable)
-    try:
-        for elem in first_unhashable:
-            t.remove(elem)
-    except ValueError:
-        return False
-    return not t
-
-def _remove_dups_flatten(parameters):
-    """Internal helper for Union creation and substitution.
-
-    Flatten Unions among parameters, then remove duplicates.
-    """
-    # Flatten out Union[Union[...], ...].
-    params = []
-    for p in parameters:
-        if isinstance(p, (_UnionGenericAlias, types.UnionType)):
-            params.extend(p.__args__)
-        else:
-            params.append(p)
-
-    return tuple(_deduplicate(params, unhashable_fallback=True))
-
+        new_unhashable = []
+        for t in params:
+            if t not in new_unhashable:
+                new_unhashable.append(t)
+        return new_unhashable
 
 def _flatten_literal_params(parameters):
     """Internal helper for Literal creation: flatten Literals among parameters."""
@@ -470,7 +430,8 @@ def __repr__(self):
 _sentinel = _Sentinel()
 
 
-def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=frozenset()):
+def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=frozenset(),
+               format=None, owner=None, parent_fwdref=None, prefer_fwd_module=False):
     """Evaluate all forward references in the given type t.
 
     For use of globalns and localns see the docstring for get_type_hints().
@@ -480,12 +441,30 @@ def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=f
     if type_params is _sentinel:
         _deprecation_warning_for_no_type_params_passed("typing._eval_type")
         type_params = ()
-    if isinstance(t, ForwardRef):
-        return t._evaluate(globalns, localns, type_params, recursive_guard=recursive_guard)
-    if isinstance(t, (_GenericAlias, GenericAlias, types.UnionType)):
+    if isinstance(t, _lazy_annotationlib.ForwardRef):
+        # If the forward_ref has __forward_module__ set, evaluate() infers the globals
+        # from the module, and it will probably pick better than the globals we have here.
+        # We do this only for calls from get_type_hints() (which opts in through the
+        # prefer_fwd_module flag), so that the default behavior remains more straightforward.
+        if prefer_fwd_module and t.__forward_module__ is not None:
+            globalns = None
+            # If there are type params on the owner, we need to add them back, because
+            # annotationlib won't.
+            if owner_type_params := getattr(owner, "__type_params__", None):
+                globalns = getattr(
+                    sys.modules.get(t.__forward_module__, None), "__dict__", None
+                )
+                if globalns is not None:
+                    globalns = dict(globalns)
+                    for type_param in owner_type_params:
+                        globalns[type_param.__name__] = type_param
+        return evaluate_forward_ref(t, globals=globalns, locals=localns,
+                                    type_params=type_params, owner=owner,
+                                    _recursive_guard=recursive_guard, format=format)
+    if isinstance(t, (_GenericAlias, GenericAlias, Union)):
         if isinstance(t, GenericAlias):
             args = tuple(
-                ForwardRef(arg) if isinstance(arg, str) else arg
+                _make_forward_ref(arg, parent_fwdref=parent_fwdref) if isinstance(arg, str) else arg
                 for arg in t.__args__
             )
             is_unpacked = t.__unpacked__
@@ -498,7 +477,8 @@ def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=f
 
         ev_args = tuple(
             _eval_type(
-                a, globalns, localns, type_params, recursive_guard=recursive_guard
+                a, globalns, localns, type_params, recursive_guard=recursive_guard,
+                format=format, owner=owner, prefer_fwd_module=prefer_fwd_module,
             )
             for a in t.__args__
         )
@@ -506,7 +486,7 @@ def _eval_type(t, globalns, localns, type_params=_sentinel, *, recursive_guard=f
             return t
         if isinstance(t, GenericAlias):
             return GenericAlias(t.__origin__, ev_args)
-        if isinstance(t, types.UnionType):
+        if isinstance(t, Union):
             return functools.reduce(operator.or_, ev_args)
         else:
             return t.copy_with(ev_args)
@@ -760,59 +740,6 @@ class FastConnector(Connection):
     item = _type_check(parameters, f'{self} accepts only single type.', allow_special_forms=True)
     return _GenericAlias(self, (item,))
 
-@_SpecialForm
-def Union(self, parameters):
-    """Union type; Union[X, Y] means either X or Y.
-
-    On Python 3.10 and higher, the | operator
-    can also be used to denote unions;
-    X | Y means the same thing to the type checker as Union[X, Y].
-
-    To define a union, use e.g. Union[int, str]. Details:
-    - The arguments must be types and there must be at least one.
-    - None as an argument is a special case and is replaced by
-      type(None).
-    - Unions of unions are flattened, e.g.::
-
-        assert Union[Union[int, str], float] == Union[int, str, float]
-
-    - Unions of a single argument vanish, e.g.::
-
-        assert Union[int] == int  # The constructor actually returns int
-
-    - Redundant arguments are skipped, e.g.::
-
-        assert Union[int, str, int] == Union[int, str]
-
-    - When comparing unions, the argument order is ignored, e.g.::
-
-        assert Union[int, str] == Union[str, int]
-
-    - You cannot subclass or instantiate a union.
-    - You can use Optional[X] as a shorthand for Union[X, None].
-    """
-    if parameters == ():
-        raise TypeError("Cannot take a Union of no types.")
-    if not isinstance(parameters, tuple):
-        parameters = (parameters,)
-    msg = "Union[arg, ...]: each arg must be a type."
-    parameters = tuple(_type_check(p, msg) for p in parameters)
-    parameters = _remove_dups_flatten(parameters)
-    if len(parameters) == 1:
-        return parameters[0]
-    if len(parameters) == 2 and type(None) in parameters:
-        return _UnionGenericAlias(self, parameters, name="Optional")
-    return _UnionGenericAlias(self, parameters)
-
-def _make_union(left, right):
-    """Used from the C implementation of TypeVar.
-
-    TypeVar.__or__ calls this instead of returning types.UnionType
-    because we want to allow unions between TypeVars and strings
-    (forward references).
-    """
-    return Union[left, right]
-
 @_SpecialForm
 def Optional(self, parameters):
     """Optional[X] is equivalent to Union[X, None]."""
@@ -1022,116 +949,85 @@ def run(arg: Child | Unrelated):
     return _GenericAlias(self, (item,))
 
 
-class ForwardRef(_Final, _root=True):
-    """Internal wrapper to hold a forward reference."""
-
-    __slots__ = ('__forward_arg__', '__forward_code__',
-                 '__forward_evaluated__', '__forward_value__',
-                 '__forward_is_argument__', '__forward_is_class__',
-                 '__forward_module__')
-
-    def __init__(self, arg, is_argument=True, module=None, *, is_class=False):
-        if not isinstance(arg, str):
-            raise TypeError(f"Forward reference must be a string -- got {arg!r}")
+def _make_forward_ref(code, *, parent_fwdref=None, **kwargs):
+    if parent_fwdref is not None:
+        if parent_fwdref.__forward_module__ is not None:
+            kwargs['module'] = parent_fwdref.__forward_module__
+        if parent_fwdref.__owner__ is not None:
+            kwargs['owner'] = parent_fwdref.__owner__
+    forward_ref = _lazy_annotationlib.ForwardRef(code, **kwargs)
+    # For compatibility, eagerly compile the forwardref's code.
+    forward_ref.__forward_code__
+    return forward_ref
 
-        # If we do `def f(*args: *Ts)`, then we'll have `arg = '*Ts'`.
-        # Unfortunately, this isn't a valid expression on its own, so we
-        # do the unpacking manually.
-        if arg.startswith('*'):
-            arg_to_compile = f'({arg},)[0]'  # E.g. (*Ts,)[0] or (*tuple[int, int],)[0]
-        else:
-            arg_to_compile = arg
-        try:
-            code = compile(arg_to_compile, '<string>', 'eval')
-        except SyntaxError:
-            raise SyntaxError(f"Forward reference must be an expression -- got {arg!r}")
-
-        self.__forward_arg__ = arg
-        self.__forward_code__ = code
-        self.__forward_evaluated__ = False
-        self.__forward_value__ = None
-        self.__forward_is_argument__ = is_argument
-        self.__forward_is_class__ = is_class
-        self.__forward_module__ = module
-
-    def _evaluate(self, globalns, localns, type_params=_sentinel, *, recursive_guard):
-        if type_params is _sentinel:
-            _deprecation_warning_for_no_type_params_passed("typing.ForwardRef._evaluate")
-            type_params = ()
-        if self.__forward_arg__ in recursive_guard:
-            return self
-        if not self.__forward_evaluated__ or localns is not globalns:
-            if globalns is None and localns is None:
-                globalns = localns = {}
-            elif globalns is None:
-                globalns = localns
-            elif localns is None:
-                localns = globalns
-            if self.__forward_module__ is not None:
-                globalns = getattr(
-                    sys.modules.get(self.__forward_module__, None), '__dict__', globalns
-                )
-
-            # type parameters require some special handling,
-            # as they exist in their own scope
-            # but `eval()` does not have a dedicated parameter for that scope.
-            # For classes, names in type parameter scopes should override
-            # names in the global scope (which here are called `localns`!),
-            # but should in turn be overridden by names in the class scope
-            # (which here are called `globalns`!)
-            if type_params:
-                globalns, localns = dict(globalns), dict(localns)
-                for param in type_params:
-                    param_name = param.__name__
-                    if not self.__forward_is_class__ or param_name not in globalns:
-                        globalns[param_name] = param
-                        localns.pop(param_name, None)
-
-            type_ = _type_check(
-                eval(self.__forward_code__, globalns, localns),
-                "Forward references must evaluate to types.",
-                is_argument=self.__forward_is_argument__,
-                allow_special_forms=self.__forward_is_class__,
-            )
-            self.__forward_value__ = _eval_type(
-                type_,
-                globalns,
-                localns,
-                type_params,
-                recursive_guard=(recursive_guard | {self.__forward_arg__}),
-            )
-            self.__forward_evaluated__ = True
-        return self.__forward_value__
 
-    def __eq__(self, other):
-        if not isinstance(other, ForwardRef):
-            return NotImplemented
-        if self.__forward_evaluated__ and other.__forward_evaluated__:
-            return (self.__forward_arg__ == other.__forward_arg__ and
-                    self.__forward_value__ == other.__forward_value__)
-        return (self.__forward_arg__ == other.__forward_arg__ and
-                self.__forward_module__ == other.__forward_module__)
-
-    def __hash__(self):
-        return hash((self.__forward_arg__, self.__forward_module__))
-
-    def __or__(self, other):
-        return Union[self, other]
-
-    def __ror__(self, other):
-        return Union[other, self]
+def evaluate_forward_ref(
+    forward_ref,
+    *,
+    owner=None,
+    globals=None,
+    locals=None,
+    type_params=None,
+    format=None,
+    _recursive_guard=frozenset(),
+):
+    """Evaluate a forward reference as a type hint.
+
+    This is similar to calling the ForwardRef.evaluate() method,
+    but unlike that method, evaluate_forward_ref() also
+    recursively evaluates forward references nested within the type hint.
+
+    *forward_ref* must be an instance of ForwardRef. *owner*, if given,
+    should be the object that holds the annotations that the forward reference
+    derived from, such as a module, class object, or function. It is used to
+    infer the namespaces to use for looking up names. *globals* and *locals*
+    can also be explicitly given to provide the global and local namespaces.
+    *type_params* is a tuple of type parameters that are in scope when
+    evaluating the forward reference. This parameter should be provided (though
+    it may be an empty tuple) if *owner* is not given and the forward reference
+    does not already have an owner set. *format* specifies the format of the
+    annotation and is a member of the annotationlib.Format enum, defaulting to
+    VALUE.
 
-    def __repr__(self):
-        if self.__forward_module__ is None:
-            module_repr = ''
-        else:
-            module_repr = f', module={self.__forward_module__!r}'
-        return f'ForwardRef({self.__forward_arg__!r}{module_repr})'
+    """
+    if format == _lazy_annotationlib.Format.STRING:
+        return forward_ref.__forward_arg__
+    if forward_ref.__forward_arg__ in _recursive_guard:
+        return forward_ref
+
+    if format is None:
+        format = _lazy_annotationlib.Format.VALUE
+    value = forward_ref.evaluate(globals=globals, locals=locals,
+                                 type_params=type_params, owner=owner, format=format)
+
+    if (isinstance(value, _lazy_annotationlib.ForwardRef)
+            and format == _lazy_annotationlib.Format.FORWARDREF):
+        return value
+
+    if isinstance(value, str):
+        value = _make_forward_ref(value, module=forward_ref.__forward_module__,
+                                  owner=owner or forward_ref.__owner__,
+                                  is_argument=forward_ref.__forward_is_argument__,
+                                  is_class=forward_ref.__forward_is_class__)
+    if owner is None:
+        owner = forward_ref.__owner__
+    return _eval_type(
+        value,
+        globals,
+        locals,
+        type_params,
+        recursive_guard=_recursive_guard | {forward_ref.__forward_arg__},
+        format=format,
+        owner=owner,
+        parent_fwdref=forward_ref,
+    )
 
 
 def _is_unpacked_typevartuple(x: Any) -> bool:
+    # Need to check 'is True' here
+    # See: https://github.com/python/cpython/issues/137706
     return ((not isinstance(x, type)) and
-            getattr(x, '__typing_is_unpacked_typevartuple__', False))
+            getattr(x, '__typing_is_unpacked_typevartuple__', False) is True)
 
 
 def _is_typevar_like(x: Any) -> bool:
@@ -1201,7 +1097,7 @@ def _paramspec_prepare_subst(self, alias, args):
     params = alias.__parameters__
     i = params.index(self)
     if i == len(args) and self.has_default():
-        args = [*args, self.__default__]
+        args = (*args, self.__default__)
     if i >= len(args):
         raise TypeError(f"Too few arguments for {alias}")
     # Special case where Z[[int, str, bool]] == Z[int, str, bool] in PEP 612.
@@ -1246,14 +1142,26 @@ def _generic_class_getitem(cls, args):
                 f"Parameters to {cls.__name__}[...] must all be unique")
     else:
         # Subscripting a regular Generic subclass.
-        for param in cls.__parameters__:
+        try:
+            parameters = cls.__parameters__
+        except AttributeError as e:
+            init_subclass = getattr(cls, '__init_subclass__', None)
+            if init_subclass not in {None, Generic.__init_subclass__}:
+                e.add_note(
+                    f"Note: this exception may have been caused by "
+                    f"{init_subclass.__qualname__!r} (or the "
+                    f"'__init_subclass__' method on a superclass) not "
+                    f"calling 'super().__init_subclass__()'"
+                )
+            raise
+        for param in parameters:
             prepare = getattr(param, '__typing_prepare_subst__', None)
             if prepare is not None:
                 args = prepare(cls, args)
         _check_generic_specialization(cls, args)
 
         new_args = []
-        for param, new_arg in zip(cls.__parameters__, args):
+        for param, new_arg in zip(parameters, args):
             if isinstance(param, TypeVarTuple):
                 new_args.extend(new_arg)
             else:
@@ -1768,45 +1676,41 @@ def __getitem__(self, params):
         return self.copy_with(params)
 
 
-class _UnionGenericAlias(_NotIterable, _GenericAlias, _root=True):
-    def copy_with(self, params):
-        return Union[params]
+class _UnionGenericAliasMeta(type):
+    def __instancecheck__(self, inst: object) -> bool:
+        import warnings
+        warnings._deprecated("_UnionGenericAlias", remove=(3, 17))
+        return isinstance(inst, Union)
+
+    def __subclasscheck__(self, inst: type) -> bool:
+        import warnings
+        warnings._deprecated("_UnionGenericAlias", remove=(3, 17))
+        return issubclass(inst, Union)
 
     def __eq__(self, other):
-        if not isinstance(other, (_UnionGenericAlias, types.UnionType)):
-            return NotImplemented
-        try:  # fast path
-            return set(self.__args__) == set(other.__args__)
-        except TypeError:  # not hashable, slow path
-            return _compare_args_orderless(self.__args__, other.__args__)
+        import warnings
+        warnings._deprecated("_UnionGenericAlias", remove=(3, 17))
+        if other is _UnionGenericAlias or other is Union:
+            return True
+        return NotImplemented
 
     def __hash__(self):
-        return hash(frozenset(self.__args__))
+        return hash(Union)
 
-    def __repr__(self):
-        args = self.__args__
-        if len(args) == 2:
-            if args[0] is type(None):
-                return f'typing.Optional[{_type_repr(args[1])}]'
-            elif args[1] is type(None):
-                return f'typing.Optional[{_type_repr(args[0])}]'
-        return super().__repr__()
 
-    def __instancecheck__(self, obj):
-        for arg in self.__args__:
-            if isinstance(obj, arg):
-                return True
-        return False
+class _UnionGenericAlias(metaclass=_UnionGenericAliasMeta):
+    """Compatibility hack.
 
-    def __subclasscheck__(self, cls):
-        for arg in self.__args__:
-            if issubclass(cls, arg):
-                return True
-        return False
+    A class named _UnionGenericAlias used to be used to implement
+    typing.Union. This class exists to serve as a shim to preserve
+    the meaning of some code that used to use _UnionGenericAlias
+    directly.
 
-    def __reduce__(self):
-        func, (origin, args) = super().__reduce__()
-        return func, (Union, args)
+    """
+    def __new__(cls, self_cls, parameters, /, *, name=None):
+        import warnings
+        warnings._deprecated("_UnionGenericAlias", remove=(3, 17))
+        return Union[parameters]
 
 
 def _value_and_type_iter(parameters):
@@ -1945,7 +1849,13 @@ def _get_protocol_attrs(cls):
     for base in cls.__mro__[:-1]:  # without object
         if base.__name__ in {'Protocol', 'Generic'}:
             continue
-        annotations = getattr(base, '__annotations__', {})
+        try:
+            annotations = base.__annotations__
+        except Exception:
+            # Only go through annotationlib to handle deferred annotations if we need to
+            annotations = _lazy_annotationlib.get_annotations(
+                base, format=_lazy_annotationlib.Format.FORWARDREF
+            )
         for attr in (*base.__dict__, *annotations):
             if not attr.startswith('_abc_') and attr not in EXCLUDED_ATTRIBUTES:
                 attrs.add(attr)
@@ -1998,8 +1908,7 @@ def _allow_reckless_class_checks(depth=2):
     The abc and functools modules indiscriminately call isinstance() and
     issubclass() on the whole MRO of a user class, which may contain protocols.
     """
-    # XXX: RUSTPYTHON; https://github.com/python/cpython/pull/136115
-    return _caller(depth) in {'abc', '_py_abc', 'functools', None}
+    return _caller(depth) in {'abc', 'functools', None}
 
 
 _PROTO_ALLOWLIST = {
@@ -2009,6 +1918,8 @@ def _allow_reckless_class_checks(depth=2):
         'Reversible', 'Buffer',
     ],
     'contextlib': ['AbstractContextManager', 'AbstractAsyncContextManager'],
+    'io': ['Reader', 'Writer'],
+    'os': ['PathLike'],
 }
 
 
@@ -2161,11 +2072,17 @@ def _proto_hook(cls, other):
                 break
 
             # ...or in annotations, if it is a sub-protocol.
-            annotations = getattr(base, '__annotations__', {})
-            if (isinstance(annotations, collections.abc.Mapping) and
-                    attr in annotations and
-                    issubclass(other, Generic) and getattr(other, '_is_protocol', False)):
-                break
+            if issubclass(other, Generic) and getattr(other, "_is_protocol", False):
+                # We avoid the slower path through annotationlib here because in most
+                # cases it should be unnecessary.
+                try:
+                    annos = base.__annotations__
+                except Exception:
+                    annos = _lazy_annotationlib.get_annotations(
+                        base, format=_lazy_annotationlib.Format.FORWARDREF
+                    )
+                if attr in annos:
+                    break
         else:
             return NotImplemented
     return True
@@ -2228,7 +2145,7 @@ class _AnnotatedAlias(_NotIterable, _GenericAlias, _root=True):
     """Runtime representation of an annotated type.
 
     At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
-    with extra annotations. The alias behaves like a normal typing alias.
+    with extra metadata. The alias behaves like a normal typing alias.
     Instantiating is the same as instantiating the underlying type; binding
     it to types is also the same.
 
@@ -2407,12 +2324,8 @@ def greet(name: str) -> None:
     return val
 
 
-_allowed_types = (types.FunctionType, types.BuiltinFunctionType,
-                  types.MethodType, types.ModuleType,
-                  WrapperDescriptorType, MethodWrapperType, MethodDescriptorType)
-
-
-def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
+def get_type_hints(obj, globalns=None, localns=None, include_extras=False,
+                   *, format=None):
     """Return type hints for an object.
 
     This is often the same as obj.__annotations__, but it handles
@@ -2445,17 +2358,21 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
     """
     if getattr(obj, '__no_type_check__', None):
         return {}
+    Format = _lazy_annotationlib.Format
+    if format is None:
+        format = Format.VALUE
     # Classes require a special treatment.
     if isinstance(obj, type):
         hints = {}
         for base in reversed(obj.__mro__):
+            ann = _lazy_annotationlib.get_annotations(base, format=format)
+            if format == Format.STRING:
+                hints.update(ann)
+                continue
             if globalns is None:
                 base_globals = getattr(sys.modules.get(base.__module__, None), '__dict__', {})
             else:
                 base_globals = globalns
-            ann = _lazy_annotationlib.get_annotations(base)
-            if isinstance(ann, types.GetSetDescriptorType):
-                ann = {}
             base_locals = dict(vars(base)) if localns is None else localns
             if localns is None and globalns is None:
                 # This is surprising, but required.  Before Python 3.10,
@@ -2465,14 +2382,33 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
                 # *base_globals* first rather than *base_locals*.
                 # This only affects ForwardRefs.
                 base_globals, base_locals = base_locals, base_globals
+            type_params = base.__type_params__
+            base_globals, base_locals = _add_type_params_to_scope(
+                type_params, base_globals, base_locals, True)
             for name, value in ann.items():
+                if isinstance(value, str):
+                    value = _make_forward_ref(value, is_argument=False, is_class=True)
+                value = _eval_type(value, base_globals, base_locals, (),
+                                   format=format, owner=obj, prefer_fwd_module=True)
                 if value is None:
                     value = type(None)
-                if isinstance(value, str):
-                    value = ForwardRef(value, is_argument=False, is_class=True)
-                value = _eval_type(value, base_globals, base_locals, base.__type_params__)
                 hints[name] = value
-        return hints if include_extras else {k: _strip_annotations(t) for k, t in hints.items()}
+        if include_extras or format == Format.STRING:
+            return hints
+        else:
+            return {k: _strip_annotations(t) for k, t in hints.items()}
+
+    hints = _lazy_annotationlib.get_annotations(obj, format=format)
+    if (
+        not hints
+        and not isinstance(obj, types.ModuleType)
+        and not callable(obj)
+        and not hasattr(obj, '__annotations__')
+        and not hasattr(obj, '__annotate__')
+    ):
+        raise TypeError(f"{obj!r} is not a module, class, or callable.")
+    if format == Format.STRING:
+        return hints
 
     if globalns is None:
         if isinstance(obj, types.ModuleType):
@@ -2487,34 +2423,38 @@ def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
             localns = globalns
     elif localns is None:
         localns = globalns
-    try:
-        hints = _lazy_annotationlib.get_annotations(obj)
-    except TypeError:
-        hints = getattr(obj, '__annotations__', None)
-    if hints is None:
-        # Return empty annotations for something that _could_ have them.
-        if isinstance(obj, _allowed_types):
-            return {}
-        else:
-            raise TypeError('{!r} is not a module, class, method, '
-                            'or function.'.format(obj))
-    hints = dict(hints)
     type_params = getattr(obj, "__type_params__", ())
+    globalns, localns = _add_type_params_to_scope(type_params, globalns, localns, False)
     for name, value in hints.items():
-        if value is None:
-            value = type(None)
         if isinstance(value, str):
             # class-level forward refs were handled above, this must be either
             # a module-level annotation or a function argument annotation
-            value = ForwardRef(
+            value = _make_forward_ref(
                 value,
                 is_argument=not isinstance(obj, types.ModuleType),
                 is_class=False,
             )
-        hints[name] = _eval_type(value, globalns, localns, type_params)
+        value = _eval_type(value, globalns, localns, (), format=format, owner=obj, prefer_fwd_module=True)
+        if value is None:
+            value = type(None)
+        hints[name] = value
     return hints if include_extras else {k: _strip_annotations(t) for k, t in hints.items()}
 
 
+# Add type parameters to the globals and locals scope. This is needed for
+# compatibility.
+def _add_type_params_to_scope(type_params, globalns, localns, is_class):
+    if not type_params:
+        return globalns, localns
+    globalns = dict(globalns)
+    localns = dict(localns)
+    for param in type_params:
+        if not is_class or param.__name__ not in globalns:
+            globalns[param.__name__] = param
+            localns.pop(param.__name__, None)
+    return globalns, localns
+
+
 def _strip_annotations(t):
     """Strip the annotations from a given type."""
     if isinstance(t, _AnnotatedAlias):
@@ -2531,7 +2471,7 @@ def _strip_annotations(t):
         if stripped_args == t.__args__:
             return t
         return GenericAlias(t.__origin__, stripped_args)
-    if isinstance(t, types.UnionType):
+    if isinstance(t, Union):
         stripped_args = tuple(_strip_annotations(a) for a in t.__args__)
         if stripped_args == t.__args__:
             return t
@@ -2565,8 +2505,8 @@ def get_origin(tp):
         return tp.__origin__
     if tp is Generic:
         return Generic
-    if isinstance(tp, types.UnionType):
-        return types.UnionType
+    if isinstance(tp, Union):
+        return Union
     return None
 
 
@@ -2591,7 +2531,7 @@ def get_args(tp):
         if _should_unflatten_callable_args(tp, res):
             res = (list(res[:-1]), res[-1])
         return res
-    if isinstance(tp, types.UnionType):
+    if isinstance(tp, Union):
         return tp.__args__
     return ()
 
@@ -2858,7 +2798,7 @@ class Other(Leaf):  # Error reported by type checker
 Sequence = _alias(collections.abc.Sequence, 1)
 MutableSequence = _alias(collections.abc.MutableSequence, 1)
 ByteString = _DeprecatedGenericAlias(
-    collections.abc.ByteString, 0, removal_version=(3, 14)  # Not generic.
+    collections.abc.ByteString, 0, removal_version=(3, 17)  # Not generic.
 )
 # Tuple accepts variable number of parameters.
 Tuple = _TupleType(tuple, -1, inst=False, name='Tuple')
@@ -2991,16 +2931,27 @@ def __round__(self, ndigits: int = 0) -> T:
         pass
 
 
-def _make_nmtuple(name, types, module, defaults = ()):
-    fields = [n for n, t in types]
-    types = {n: _type_check(t, f"field {n} annotation must be a type")
-             for n, t in types}
+def _make_nmtuple(name, fields, annotate_func, module, defaults = ()):
     nm_tpl = collections.namedtuple(name, fields,
                                     defaults=defaults, module=module)
-    nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = types
+    nm_tpl.__annotate__ = nm_tpl.__new__.__annotate__ = annotate_func
     return nm_tpl
 
 
+def _make_eager_annotate(types):
+    checked_types = {key: _type_check(val, f"field {key} annotation must be a type")
+                     for key, val in types.items()}
+    def annotate(format):
+        match format:
+            case _lazy_annotationlib.Format.VALUE | _lazy_annotationlib.Format.FORWARDREF:
+                return checked_types
+            case _lazy_annotationlib.Format.STRING:
+                return _lazy_annotationlib.annotations_to_string(types)
+            case _:
+                raise NotImplementedError(format)
+    return annotate
+
+
 # attributes prohibited to set in NamedTuple class syntax
 _prohibited = frozenset({'__new__', '__init__', '__slots__', '__getnewargs__',
                          '_fields', '_field_defaults',
@@ -3013,6 +2964,9 @@ def _make_nmtuple(name, types, module, defaults = ()):
 class NamedTupleMeta(type):
     def __new__(cls, typename, bases, ns):
         assert _NamedTuple in bases
+        if "__classcell__" in ns:
+            raise TypeError(
+                "uses of super() and __class__ are unsupported in methods of NamedTuple subclasses")
         for base in bases:
             if base is not _NamedTuple and base is not Generic:
                 raise TypeError(
@@ -3020,13 +2974,30 @@ def __new__(cls, typename, bases, ns):
         bases = tuple(tuple if base is _NamedTuple else base for base in bases)
         if "__annotations__" in ns:
             types = ns["__annotations__"]
-        elif (annotate := _lazy_annotationlib.get_annotate_from_class_namespace(ns)) is not None:
+            field_names = list(types)
+            annotate = _make_eager_annotate(types)
+        elif (original_annotate := _lazy_annotationlib.get_annotate_from_class_namespace(ns)) is not None:
             types = _lazy_annotationlib.call_annotate_function(
-                annotate, _lazy_annotationlib.Format.VALUE)
+                original_annotate, _lazy_annotationlib.Format.FORWARDREF)
+            field_names = list(types)
+
+            # For backward compatibility, type-check all the types at creation time
+            for typ in types.values():
+                _type_check(typ, "field annotation must be a type")
+
+            def annotate(format):
+                annos = _lazy_annotationlib.call_annotate_function(
+                    original_annotate, format)
+                if format != _lazy_annotationlib.Format.STRING:
+                    return {key: _type_check(val, f"field {key} annotation must be a type")
+                            for key, val in annos.items()}
+                return annos
         else:
-            types = {}
+            # Empty NamedTuple
+            field_names = []
+            annotate = lambda format: {}
         default_names = []
-        for field_name in types:
+        for field_name in field_names:
             if field_name in ns:
                 default_names.append(field_name)
             elif default_names:
@@ -3034,7 +3005,7 @@ def __new__(cls, typename, bases, ns):
                                 f"cannot follow default field"
                                 f"{'s' if len(default_names) > 1 else ''} "
                                 f"{', '.join(default_names)}")
-        nm_tpl = _make_nmtuple(typename, types.items(),
+        nm_tpl = _make_nmtuple(typename, field_names, annotate,
                                defaults=[ns[n] for n in default_names],
                                module=ns['__module__'])
         nm_tpl.__bases__ = bases
@@ -3125,7 +3096,11 @@ class Employee(NamedTuple):
         import warnings
         warnings._deprecated(deprecated_thing, message=deprecation_msg, remove=(3, 15))
         fields = kwargs.items()
-    nt = _make_nmtuple(typename, fields, module=_caller())
+    types = {n: _type_check(t, f"field {n} annotation must be a type")
+             for n, t in fields}
+    field_names = [n for n, _ in fields]
+
+    nt = _make_nmtuple(typename, field_names, _make_eager_annotate(types), module=_caller())
     nt.__orig_bases__ = (NamedTuple,)
     return nt
 
@@ -3574,7 +3549,7 @@ def readline(self, limit: int = -1) -> AnyStr:
         pass
 
     @abstractmethod
-    def readlines(self, hint: int = -1) -> List[AnyStr]:
+    def readlines(self, hint: int = -1) -> list[AnyStr]:
         pass
 
     @abstractmethod
@@ -3590,7 +3565,7 @@ def tell(self) -> int:
         pass
 
     @abstractmethod
-    def truncate(self, size: int = None) -> int:
+    def truncate(self, size: int | None = None) -> int:
         pass
 
     @abstractmethod
@@ -3602,11 +3577,11 @@ def write(self, s: AnyStr) -> int:
         pass
 
     @abstractmethod
-    def writelines(self, lines: List[AnyStr]) -> None:
+    def writelines(self, lines: list[AnyStr]) -> None:
         pass
 
     @abstractmethod
-    def __enter__(self) -> 'IO[AnyStr]':
+    def __enter__(self) -> IO[AnyStr]:
         pass
 
     @abstractmethod
@@ -3620,11 +3595,11 @@ class BinaryIO(IO[bytes]):
     __slots__ = ()
 
     @abstractmethod
-    def write(self, s: Union[bytes, bytearray]) -> int:
+    def write(self, s: bytes | bytearray) -> int:
         pass
 
     @abstractmethod
-    def __enter__(self) -> 'BinaryIO':
+    def __enter__(self) -> BinaryIO:
         pass
 
 
@@ -3645,7 +3620,7 @@ def encoding(self) -> str:
 
     @property
     @abstractmethod
-    def errors(self) -> Optional[str]:
+    def errors(self) -> str | None:
         pass
 
     @property
@@ -3659,7 +3634,7 @@ def newlines(self) -> Any:
         pass
 
     @abstractmethod
-    def __enter__(self) -> 'TextIO':
+    def __enter__(self) -> TextIO:
         pass
 
 
@@ -3855,7 +3830,9 @@ def __getattr__(attr):
     Soft-deprecated objects which are costly to create
     are only created on-demand here.
     """
-    if attr in {"Pattern", "Match"}:
+    if attr == "ForwardRef":
+        obj = _lazy_annotationlib.ForwardRef
+    elif attr in {"Pattern", "Match"}:
         import re
         obj = _alias(getattr(re, attr), 1)
     elif attr in {"ContextManager", "AsyncContextManager"}:

From 28230536141d965d1a9f9a0d2e3382cb215541e3 Mon Sep 17 00:00:00 2001
From: CPython Developers <>
Date: Mon, 19 Jan 2026 23:46:44 +0900
Subject: [PATCH 394/418] Update test_types from v3.14.2

---
 .cspell.dict/python-more.txt |   1 +
 Lib/test/test_types.py       | 598 ++++++++++++++++++++++++++++++-----
 2 files changed, 524 insertions(+), 75 deletions(-)

diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index c4a419c5ffe..73b2d620ca6 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -67,6 +67,7 @@ fnctl
 frombytes
 fromhex
 fromunicode
+frozensets
 fset
 fspath
 fstring
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index b57fdf35fb6..3410c7ac206 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -1,19 +1,35 @@
 # Python test set -- part 6, built-in types
 
-from test.support import run_with_locale, cpython_only
+from test.support import (
+    run_with_locale, cpython_only, no_rerun,
+    MISSING_C_DOCSTRINGS, EqualToForwardRef, check_disallow_instantiation,
+)
+from test.support.script_helper import assert_python_ok
+from test.support.import_helper import import_fresh_module
+
 import collections.abc
-from collections import namedtuple
+from collections import namedtuple, UserDict
 import copy
+# XXX: RUSTPYTHON
+try:
+    import _datetime
+except ImportError:
+    _datetime = None
 import gc
 import inspect
 import pickle
 import locale
 import sys
+import textwrap
 import types
 import unittest.mock
 import weakref
 import typing
 
+import unittest  # XXX: RUSTPYTHON; importing to be able to skip tests
+
+c_types = import_fresh_module('types', fresh=['_types'])
+py_types = import_fresh_module('types', blocked=['_types'])
 
 T = typing.TypeVar("T")
 
@@ -29,6 +45,29 @@ def clear_typing_caches():
 
 class TypesTests(unittest.TestCase):
 
+    @unittest.skipUnless(c_types, "TODO: RUSTPYTHON; requires _types module")
+    def test_names(self):
+        c_only_names = {'CapsuleType'}
+        ignored = {'new_class', 'resolve_bases', 'prepare_class',
+                   'get_original_bases', 'DynamicClassAttribute', 'coroutine'}
+
+        for name in c_types.__all__:
+            if name not in c_only_names | ignored:
+                self.assertIs(getattr(c_types, name), getattr(py_types, name))
+
+        all_names = ignored | {
+            'AsyncGeneratorType', 'BuiltinFunctionType', 'BuiltinMethodType',
+            'CapsuleType', 'CellType', 'ClassMethodDescriptorType', 'CodeType',
+            'CoroutineType', 'EllipsisType', 'FrameType', 'FunctionType',
+            'GeneratorType', 'GenericAlias', 'GetSetDescriptorType',
+            'LambdaType', 'MappingProxyType', 'MemberDescriptorType',
+            'MethodDescriptorType', 'MethodType', 'MethodWrapperType',
+            'ModuleType', 'NoneType', 'NotImplementedType', 'SimpleNamespace',
+            'TracebackType', 'UnionType', 'WrapperDescriptorType',
+        }
+        self.assertEqual(all_names, set(c_types.__all__))
+        self.assertEqual(all_names - c_only_names, set(py_types.__all__))
+
     def test_truth_values(self):
         if None: self.fail('None is true instead of false')
         if 0: self.fail('0 is true instead of false')
@@ -226,8 +265,8 @@ def test_type_function(self):
     def test_int__format__(self):
         def test(i, format_spec, result):
             # just make sure we have the unified type for integers
-            assert type(i) == int
-            assert type(format_spec) == str
+            self.assertIs(type(i), int)
+            self.assertIs(type(format_spec), str)
             self.assertEqual(i.__format__(format_spec), result)
 
         test(123456789, 'd', '123456789')
@@ -392,8 +431,8 @@ def test(i, format_spec, result):
         test(123456, "1=20", '11111111111111123456')
         test(123456, "*=20", '**************123456')
 
-    @unittest.expectedFailure
-    @run_with_locale('LC_NUMERIC', 'en_US.UTF8')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_float__format__locale(self):
         # test locale support for __format__ code 'n'
 
@@ -402,7 +441,8 @@ 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'))
 
-    @run_with_locale('LC_NUMERIC', 'en_US.UTF8')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_int__format__locale(self):
         # test locale support for __format__ code 'n' for integers
 
@@ -420,9 +460,6 @@ def test_int__format__locale(self):
             self.assertEqual(len(format(0, rfmt)), len(format(x, rfmt)))
             self.assertEqual(len(format(0, lfmt)), len(format(x, lfmt)))
             self.assertEqual(len(format(0, cfmt)), len(format(x, cfmt)))
-    
-    if sys.platform != "darwin":
-        test_int__format__locale = unittest.expectedFailure(test_int__format__locale)
 
     def test_float__format__(self):
         def test(f, format_spec, result):
@@ -489,8 +526,8 @@ def test(f, format_spec, result):
         # and a number after the decimal.  This is tricky, because
         # a totally empty format specifier means something else.
         # So, just use a sign flag
-        test(1e200, '+g', '+1e+200')
-        test(1e200, '+', '+1e+200')
+        test(1.25e200, '+g', '+1.25e+200')
+        test(1.25e200, '+', '+1.25e+200')
 
         test(1.1e200, '+g', '+1.1e+200')
         test(1.1e200, '+', '+1.1e+200')
@@ -602,8 +639,9 @@ def test_slot_wrapper_types(self):
         self.assertIsInstance(object.__lt__, types.WrapperDescriptorType)
         self.assertIsInstance(int.__lt__, types.WrapperDescriptorType)
 
-    # TODO: RUSTPYTHON No signature found in builtin method __get__ of 'method_descriptor' objects.
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; No signature found in builtin method __get__ of 'method_descriptor' objects.
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
     def test_dunder_get_signature(self):
         sig = inspect.signature(object.__init__.__get__)
         self.assertEqual(list(sig.parameters), ["instance", "owner"])
@@ -627,6 +665,25 @@ def test_method_descriptor_types(self):
         self.assertIsInstance(int.from_bytes, types.BuiltinMethodType)
         self.assertIsInstance(int.__new__, types.BuiltinMethodType)
 
+    def test_method_descriptor_crash(self):
+        # gh-132747: The default __get__() implementation in C was unable
+        # to handle a second argument of None when called from Python
+        import _io
+        import io
+        import _queue
+
+        to_check = [
+            # (method, instance)
+            (_io._TextIOBase.read, io.StringIO()),
+            (_queue.SimpleQueue.put, _queue.SimpleQueue()),
+            (str.capitalize, "nobody expects the spanish inquisition")
+        ]
+
+        for method, instance in to_check:
+            with self.subTest(method=method, instance=instance):
+                bound = method.__get__(instance)
+                self.assertIsInstance(bound, types.BuiltinMethodType)
+
     def test_ellipsis_type(self):
         self.assertIsInstance(Ellipsis, types.EllipsisType)
 
@@ -644,6 +701,29 @@ def test_traceback_and_frame_types(self):
         self.assertIsInstance(exc.__traceback__, types.TracebackType)
         self.assertIsInstance(exc.__traceback__.tb_frame, types.FrameType)
 
+    # XXX: RUSTPYTHON
+    @unittest.skipUnless(_datetime, "requires _datetime module")
+    def test_capsule_type(self):
+        self.assertIsInstance(_datetime.datetime_CAPI, types.CapsuleType)
+
+    def test_call_unbound_crash(self):
+        # GH-131998: The specialized instruction would get tricked into dereferencing
+        # a bound "self" that didn't exist if subsequently called unbound.
+        code = """if True:
+
+        def call(part):
+            [] + ([] + [])
+            part.pop()
+
+        for _ in range(3):
+            call(['a'])
+        try:
+            call(list)
+        except TypeError:
+            pass
+        """
+        assert_python_ok("-c", code)
+
 
 class UnionTests(unittest.TestCase):
 
@@ -706,15 +786,54 @@ def test_or_types_operator(self):
         y = int | bool
         with self.assertRaises(TypeError):
             x < y
-        # Check that we don't crash if typing.Union does not have a tuple in __args__
-        y = typing.Union[str, int]
-        y.__args__ = [str, int]
-        self.assertEqual(x, y)
 
     def test_hash(self):
         self.assertEqual(hash(int | str), hash(str | int))
         self.assertEqual(hash(int | str), hash(typing.Union[int, str]))
 
+    def test_union_of_unhashable(self):
+        class UnhashableMeta(type):
+            __hash__ = None
+
+        class A(metaclass=UnhashableMeta): ...
+        class B(metaclass=UnhashableMeta): ...
+
+        self.assertEqual((A | B).__args__, (A, B))
+        union1 = A | B
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union1)
+
+        union2 = int | B
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union2)
+
+        union3 = A | int
+        with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):
+            hash(union3)
+
+    def test_unhashable_becomes_hashable(self):
+        is_hashable = False
+        class UnhashableMeta(type):
+            def __hash__(self):
+                if is_hashable:
+                    return 1
+                else:
+                    raise TypeError("not hashable")
+
+        class A(metaclass=UnhashableMeta): ...
+        class B(metaclass=UnhashableMeta): ...
+
+        union = A | B
+        self.assertEqual(union.__args__, (A, B))
+
+        with self.assertRaisesRegex(TypeError, "not hashable"):
+            hash(union)
+
+        is_hashable = True
+
+        with self.assertRaisesRegex(TypeError, "union contains 2 unhashable elements"):
+            hash(union)
+
     def test_instancecheck_and_subclasscheck(self):
         for x in (int | str, typing.Union[int, str]):
             with self.subTest(x=x):
@@ -722,15 +841,15 @@ def test_instancecheck_and_subclasscheck(self):
                 self.assertIsInstance(True, x)
                 self.assertIsInstance('a', x)
                 self.assertNotIsInstance(None, x)
-                self.assertTrue(issubclass(int, x))
-                self.assertTrue(issubclass(bool, x))
-                self.assertTrue(issubclass(str, x))
-                self.assertFalse(issubclass(type(None), x))
+                self.assertIsSubclass(int, x)
+                self.assertIsSubclass(bool, x)
+                self.assertIsSubclass(str, x)
+                self.assertNotIsSubclass(type(None), x)
 
         for x in (int | None, typing.Union[int, None]):
             with self.subTest(x=x):
                 self.assertIsInstance(None, x)
-                self.assertTrue(issubclass(type(None), x))
+                self.assertIsSubclass(type(None), x)
 
         for x in (
             int | collections.abc.Mapping,
@@ -739,8 +858,8 @@ def test_instancecheck_and_subclasscheck(self):
             with self.subTest(x=x):
                 self.assertIsInstance({}, x)
                 self.assertNotIsInstance((), x)
-                self.assertTrue(issubclass(dict, x))
-                self.assertFalse(issubclass(list, x))
+                self.assertIsSubclass(dict, x)
+                self.assertNotIsSubclass(list, x)
 
     def test_instancecheck_and_subclasscheck_order(self):
         T = typing.TypeVar('T')
@@ -752,7 +871,7 @@ def test_instancecheck_and_subclasscheck_order(self):
         for x in will_resolve:
             with self.subTest(x=x):
                 self.assertIsInstance(1, x)
-                self.assertTrue(issubclass(int, x))
+                self.assertIsSubclass(int, x)
 
         wont_resolve = (
             T | int,
@@ -785,13 +904,13 @@ class BadMeta(type):
             def __subclasscheck__(cls, sub):
                 1/0
         x = int | BadMeta('A', (), {})
-        self.assertTrue(issubclass(int, x))
+        self.assertIsSubclass(int, x)
         self.assertRaises(ZeroDivisionError, issubclass, list, x)
 
     def test_or_type_operator_with_TypeVar(self):
         TV = typing.TypeVar('T')
-        assert TV | str == typing.Union[TV, str]
-        assert str | TV == typing.Union[str, TV]
+        self.assertEqual(TV | str, typing.Union[TV, str])
+        self.assertEqual(str | TV, typing.Union[str, TV])
         self.assertIs((int | TV)[int], int)
         self.assertIs((TV | int)[int], int)
 
@@ -895,54 +1014,83 @@ def test_or_type_operator_with_forward(self):
         ForwardBefore = 'Forward' | T
         def forward_after(x: ForwardAfter[int]) -> None: ...
         def forward_before(x: ForwardBefore[int]) -> None: ...
-        assert typing.get_args(typing.get_type_hints(forward_after)['x']) == (int, Forward)
-        assert typing.get_args(typing.get_type_hints(forward_before)['x']) == (int, Forward)
+        self.assertEqual(typing.get_args(typing.get_type_hints(forward_after)['x']),
+                         (int, Forward))
+        self.assertEqual(typing.get_args(typing.get_type_hints(forward_before)['x']),
+                         (Forward, int))
 
     def test_or_type_operator_with_Protocol(self):
         class Proto(typing.Protocol):
             def meth(self) -> int:
                 ...
-        assert Proto | str == typing.Union[Proto, str]
+        self.assertEqual(Proto | str, typing.Union[Proto, str])
 
     def test_or_type_operator_with_Alias(self):
-        assert list | str == typing.Union[list, str]
-        assert typing.List | str == typing.Union[typing.List, str]
+        self.assertEqual(list | str, typing.Union[list, str])
+        self.assertEqual(typing.List | str, typing.Union[typing.List, str])
 
     def test_or_type_operator_with_NamedTuple(self):
-        NT=namedtuple('A', ['B', 'C', 'D'])
-        assert NT | str == typing.Union[NT,str]
+        NT = namedtuple('A', ['B', 'C', 'D'])
+        self.assertEqual(NT | str, typing.Union[NT, str])
 
     def test_or_type_operator_with_TypedDict(self):
         class Point2D(typing.TypedDict):
             x: int
             y: int
             label: str
-        assert Point2D | str == typing.Union[Point2D, str]
+        self.assertEqual(Point2D | str, typing.Union[Point2D, str])
 
     def test_or_type_operator_with_NewType(self):
         UserId = typing.NewType('UserId', int)
-        assert UserId | str == typing.Union[UserId, str]
+        self.assertEqual(UserId | str, typing.Union[UserId, str])
 
     def test_or_type_operator_with_IO(self):
-        assert typing.IO | str == typing.Union[typing.IO, str]
+        self.assertEqual(typing.IO | str, typing.Union[typing.IO, str])
 
     def test_or_type_operator_with_SpecialForm(self):
-        assert typing.Any | str == typing.Union[typing.Any, str]
-        assert typing.NoReturn | str == typing.Union[typing.NoReturn, str]
-        assert typing.Optional[int] | str == typing.Union[typing.Optional[int], str]
-        assert typing.Optional[int] | str == typing.Union[int, str, None]
-        assert typing.Union[int, bool] | str == typing.Union[int, bool, str]
+        self.assertEqual(typing.Any | str, typing.Union[typing.Any, str])
+        self.assertEqual(typing.NoReturn | str, typing.Union[typing.NoReturn, str])
+        self.assertEqual(typing.Optional[int] | str, typing.Union[typing.Optional[int], str])
+        self.assertEqual(typing.Optional[int] | str, typing.Union[int, str, None])
+        self.assertEqual(typing.Union[int, bool] | str, typing.Union[int, bool, str])
+
+    def test_or_type_operator_with_Literal(self):
+        Literal = typing.Literal
+        self.assertEqual((Literal[1] | Literal[2]).__args__,
+                         (Literal[1], Literal[2]))
+
+        self.assertEqual((Literal[0] | Literal[False]).__args__,
+                         (Literal[0], Literal[False]))
+        self.assertEqual((Literal[1] | Literal[True]).__args__,
+                         (Literal[1], Literal[True]))
+
+        self.assertEqual(Literal[1] | Literal[1], Literal[1])
+        self.assertEqual(Literal['a'] | Literal['a'], Literal['a'])
+
+        import enum
+        class Ints(enum.IntEnum):
+            A = 0
+            B = 1
+
+        self.assertEqual(Literal[Ints.A] | Literal[Ints.A], Literal[Ints.A])
+        self.assertEqual(Literal[Ints.B] | Literal[Ints.B], Literal[Ints.B])
+
+        self.assertEqual((Literal[Ints.B] | Literal[Ints.A]).__args__,
+                         (Literal[Ints.B], Literal[Ints.A]))
+
+        self.assertEqual((Literal[0] | Literal[Ints.A]).__args__,
+                         (Literal[0], Literal[Ints.A]))
+        self.assertEqual((Literal[1] | Literal[Ints.B]).__args__,
+                         (Literal[1], Literal[Ints.B]))
 
     def test_or_type_repr(self):
-        assert repr(int | str) == "int | str"
-        assert repr((int | str) | list) == "int | str | list"
-        assert repr(int | (str | list)) == "int | str | list"
-        assert repr(int | None) == "int | None"
-        assert repr(int | type(None)) == "int | None"
-        assert repr(int | typing.GenericAlias(list, int)) == "int | list[int]"
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(repr(int | str), "int | str")
+        self.assertEqual(repr((int | str) | list), "int | str | list")
+        self.assertEqual(repr(int | (str | list)), "int | str | list")
+        self.assertEqual(repr(int | None), "int | None")
+        self.assertEqual(repr(int | type(None)), "int | None")
+        self.assertEqual(repr(int | typing.GenericAlias(list, int)), "int | list[int]")
+
     def test_or_type_operator_with_genericalias(self):
         a = list[int]
         b = list[str]
@@ -963,9 +1111,14 @@ def __eq__(self, other):
                 return 1 / 0
 
         bt = BadType('bt', (), {})
+        bt2 = BadType('bt2', (), {})
         # Comparison should fail and errors should propagate out for bad types.
+        union1 = int | bt
+        union2 = int | bt2
+        with self.assertRaises(ZeroDivisionError):
+            union1 == union2
         with self.assertRaises(ZeroDivisionError):
-            list[int] | list[bt]
+            bt | bt2
 
         union_ga = (list[str] | int, collections.abc.Callable[..., str] | int,
                     d | int)
@@ -1008,6 +1161,19 @@ def test_or_type_operator_reference_cycle(self):
         self.assertLessEqual(sys.gettotalrefcount() - before, leeway,
                              msg='Check for union reference leak.')
 
+    def test_instantiation(self):
+        check_disallow_instantiation(self, types.UnionType)
+        self.assertIs(int, types.UnionType[int])
+        self.assertIs(int, types.UnionType[int, int])
+        self.assertEqual(int | str, types.UnionType[int, str])
+
+        for obj in (
+            int | typing.ForwardRef("str"),
+            typing.Union[int, "str"],
+        ):
+            self.assertIsInstance(obj, types.UnionType)
+            self.assertEqual(obj.__args__, (int, EqualToForwardRef("str")))
+
 
 class MappingProxyTests(unittest.TestCase):
     mappingproxy = types.MappingProxyType
@@ -1197,8 +1363,7 @@ def test_copy(self):
         self.assertEqual(view['key1'], 70)
         self.assertEqual(copy['key1'], 27)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_union(self):
         mapping = {'a': 0, 'b': 1, 'c': 2}
         view = self.mappingproxy(mapping)
@@ -1215,6 +1380,16 @@ def test_union(self):
         self.assertDictEqual(mapping, {'a': 0, 'b': 1, 'c': 2})
         self.assertDictEqual(other, {'c': 3, 'p': 0})
 
+    def test_hash(self):
+        class HashableDict(dict):
+            def __hash__(self):
+                return 3844817361
+        view = self.mappingproxy({'a': 1, 'b': 2})
+        self.assertRaises(TypeError, hash, view)
+        mapping = HashableDict({'a': 1, 'b': 2})
+        view = self.mappingproxy(mapping)
+        self.assertEqual(hash(view), hash(mapping))
+
 
 class ClassCreationTests(unittest.TestCase):
 
@@ -1238,7 +1413,7 @@ def test_new_class_basics(self):
 
     def test_new_class_subclass(self):
         C = types.new_class("C", (int,))
-        self.assertTrue(issubclass(C, int))
+        self.assertIsSubclass(C, int)
 
     def test_new_class_meta(self):
         Meta = self.Meta
@@ -1283,7 +1458,7 @@ def func(ns):
                             bases=(int,),
                             kwds=dict(metaclass=Meta, z=2),
                             exec_body=func)
-        self.assertTrue(issubclass(C, int))
+        self.assertIsSubclass(C, int)
         self.assertIsInstance(C, Meta)
         self.assertEqual(C.x, 0)
         self.assertEqual(C.y, 1)
@@ -1362,6 +1537,80 @@ class C: pass
         D = types.new_class('D', (A(), C, B()), {})
         self.assertEqual(D.__bases__, (A1, A2, A3, C, B1, B2))
 
+    def test_get_original_bases(self):
+        T = typing.TypeVar('T')
+        class A: pass
+        class B(typing.Generic[T]): pass
+        class C(B[int]): pass
+        class D(B[str], float): pass
+
+        self.assertEqual(types.get_original_bases(A), (object,))
+        self.assertEqual(types.get_original_bases(B), (typing.Generic[T],))
+        self.assertEqual(types.get_original_bases(C), (B[int],))
+        self.assertEqual(types.get_original_bases(int), (object,))
+        self.assertEqual(types.get_original_bases(D), (B[str], float))
+
+        class E(list[T]): pass
+        class F(list[int]): pass
+
+        self.assertEqual(types.get_original_bases(E), (list[T],))
+        self.assertEqual(types.get_original_bases(F), (list[int],))
+
+        class FirstBase(typing.Generic[T]): pass
+        class SecondBase(typing.Generic[T]): pass
+        class First(FirstBase[int]): pass
+        class Second(SecondBase[int]): pass
+        class G(First, Second): pass
+        self.assertEqual(types.get_original_bases(G), (First, Second))
+
+        class First_(typing.Generic[T]): pass
+        class Second_(typing.Generic[T]): pass
+        class H(First_, Second_): pass
+        self.assertEqual(types.get_original_bases(H), (First_, Second_))
+
+        class ClassBasedNamedTuple(typing.NamedTuple):
+            x: int
+
+        class GenericNamedTuple(typing.NamedTuple, typing.Generic[T]):
+            x: T
+
+        CallBasedNamedTuple = typing.NamedTuple("CallBasedNamedTuple", [("x", int)])
+
+        self.assertIs(
+            types.get_original_bases(ClassBasedNamedTuple)[0], typing.NamedTuple
+        )
+        self.assertEqual(
+            types.get_original_bases(GenericNamedTuple),
+            (typing.NamedTuple, typing.Generic[T])
+        )
+        self.assertIs(
+            types.get_original_bases(CallBasedNamedTuple)[0], typing.NamedTuple
+        )
+
+        class ClassBasedTypedDict(typing.TypedDict):
+            x: int
+
+        class GenericTypedDict(typing.TypedDict, typing.Generic[T]):
+            x: T
+
+        CallBasedTypedDict = typing.TypedDict("CallBasedTypedDict", {"x": int})
+
+        self.assertIs(
+            types.get_original_bases(ClassBasedTypedDict)[0],
+            typing.TypedDict
+        )
+        self.assertEqual(
+            types.get_original_bases(GenericTypedDict),
+            (typing.TypedDict, typing.Generic[T])
+        )
+        self.assertIs(
+            types.get_original_bases(CallBasedTypedDict)[0],
+            typing.TypedDict
+        )
+
+        with self.assertRaisesRegex(TypeError, "Expected an instance of type"):
+            types.get_original_bases(object())
+
     # Many of the following tests are derived from test_descr.py
     def test_prepare_class(self):
         # Basic test of metaclass derivation
@@ -1622,25 +1871,80 @@ class Model(metaclass=ModelBase):
         with self.assertRaises(RuntimeWarning):
             type("SouthPonies", (Model,), {})
 
+    def test_subclass_inherited_slot_update(self):
+        # gh-132284: Make sure slot update still works after fix.
+        # Note that after assignment to D.__getitem__ the actual C slot will
+        # never go back to dict_subscript as it was on class type creation but
+        # rather be set to slot_mp_subscript, unfortunately there is no way to
+        # check that here.
+
+        class D(dict):
+            pass
+
+        d = D({None: None})
+        self.assertIs(d[None], None)
+        D.__getitem__ = lambda self, item: 42
+        self.assertEqual(d[None], 42)
+        D.__getitem__ = dict.__getitem__
+        self.assertIs(d[None], None)
+
+    def test_tuple_subclass_as_bases(self):
+        # gh-132176: it used to crash on using
+        # tuple subclass for as base classes.
+        class TupleSubclass(tuple): pass
+
+        typ = type("typ", TupleSubclass((int, object)), {})
+        self.assertEqual(typ.__bases__, (int, object))
+        self.assertEqual(type(typ.__bases__), TupleSubclass)
+
 
 class SimpleNamespaceTests(unittest.TestCase):
 
     def test_constructor(self):
-        ns1 = types.SimpleNamespace()
-        ns2 = types.SimpleNamespace(x=1, y=2)
-        ns3 = types.SimpleNamespace(**dict(x=1, y=2))
+        def check(ns, expected):
+            self.assertEqual(len(ns.__dict__), len(expected))
+            self.assertEqual(vars(ns), expected)
+            # check order
+            self.assertEqual(list(vars(ns).items()), list(expected.items()))
+            for name in expected:
+                self.assertEqual(getattr(ns, name), expected[name])
+
+        check(types.SimpleNamespace(), {})
+        check(types.SimpleNamespace(x=1, y=2), {'x': 1, 'y': 2})
+        check(types.SimpleNamespace(**dict(x=1, y=2)), {'x': 1, 'y': 2})
+        check(types.SimpleNamespace({'x': 1, 'y': 2}, x=4, z=3),
+              {'x': 4, 'y': 2, 'z': 3})
+        check(types.SimpleNamespace([['x', 1], ['y', 2]], x=4, z=3),
+              {'x': 4, 'y': 2, 'z': 3})
+        check(types.SimpleNamespace(UserDict({'x': 1, 'y': 2}), x=4, z=3),
+              {'x': 4, 'y': 2, 'z': 3})
+        check(types.SimpleNamespace({'x': 1, 'y': 2}), {'x': 1, 'y': 2})
+        check(types.SimpleNamespace([['x', 1], ['y', 2]]), {'x': 1, 'y': 2})
+        check(types.SimpleNamespace([], x=4, z=3), {'x': 4, 'z': 3})
+        check(types.SimpleNamespace({}, x=4, z=3), {'x': 4, 'z': 3})
+        check(types.SimpleNamespace([]), {})
+        check(types.SimpleNamespace({}), {})
 
         with self.assertRaises(TypeError):
-            types.SimpleNamespace(1, 2, 3)
+            types.SimpleNamespace([], [])  # too many positional arguments
         with self.assertRaises(TypeError):
-            types.SimpleNamespace(**{1: 2})
-
-        self.assertEqual(len(ns1.__dict__), 0)
-        self.assertEqual(vars(ns1), {})
-        self.assertEqual(len(ns2.__dict__), 2)
-        self.assertEqual(vars(ns2), {'y': 2, 'x': 1})
-        self.assertEqual(len(ns3.__dict__), 2)
-        self.assertEqual(vars(ns3), {'y': 2, 'x': 1})
+            types.SimpleNamespace(1)  # not a mapping or iterable
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace([1])  # non-iterable
+        with self.assertRaises(ValueError):
+            types.SimpleNamespace([['x']])  # not a pair
+        with self.assertRaises(ValueError):
+            types.SimpleNamespace([['x', 'y', 'z']])
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace(**{1: 2})  # non-string key
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace({1: 2})
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace([[1, 2]])
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace(UserDict({1: 2}))
+        with self.assertRaises(TypeError):
+            types.SimpleNamespace([[[], 2]])  # non-hashable key
 
     def test_unbound(self):
         ns1 = vars(types.SimpleNamespace())
@@ -1797,6 +2101,33 @@ def test_pickle(self):
 
             self.assertEqual(ns, ns_roundtrip, pname)
 
+    def test_replace(self):
+        ns = types.SimpleNamespace(x=11, y=22)
+
+        ns2 = copy.replace(ns)
+        self.assertEqual(ns2, ns)
+        self.assertIsNot(ns2, ns)
+        self.assertIs(type(ns2), types.SimpleNamespace)
+        self.assertEqual(vars(ns2), {'x': 11, 'y': 22})
+        ns2.x = 3
+        self.assertEqual(ns.x, 11)
+        ns.x = 4
+        self.assertEqual(ns2.x, 3)
+
+        self.assertEqual(vars(copy.replace(ns, x=1)), {'x': 1, 'y': 22})
+        self.assertEqual(vars(copy.replace(ns, y=2)), {'x': 4, 'y': 2})
+        self.assertEqual(vars(copy.replace(ns, x=1, y=2)), {'x': 1, 'y': 2})
+
+    def test_replace_subclass(self):
+        class Spam(types.SimpleNamespace):
+            pass
+
+        spam = Spam(ham=8, eggs=9)
+        spam2 = copy.replace(spam, ham=5)
+
+        self.assertIs(type(spam2), Spam)
+        self.assertEqual(vars(spam2), {'ham': 5, 'eggs': 9})
+
     def test_fake_namespace_compare(self):
         # Issue #24257: Incorrect use of PyObject_IsInstance() caused
         # SystemError.
@@ -1841,8 +2172,7 @@ def foo():
         foo = types.coroutine(foo)
         self.assertIs(aw, foo())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_async_def(self):
         # Test that types.coroutine passes 'async def' coroutines
         # without modification
@@ -2076,7 +2406,7 @@ def foo(): return gen
         wrapper = foo()
         wrapper.send(None)
         with self.assertRaisesRegex(Exception, 'ham'):
-            wrapper.throw(Exception, Exception('ham'))
+            wrapper.throw(Exception('ham'))
 
         # decorate foo second time
         foo = types.coroutine(foo)
@@ -2099,8 +2429,7 @@ def foo():
         foo = types.coroutine(foo)
         self.assertIs(foo(), gencoro)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_genfunc(self):
         def gen(): yield
         self.assertIs(types.coroutine(gen), gen)
@@ -2131,5 +2460,124 @@ def coro():
             'close', 'throw'}))
 
 
+class FunctionTests(unittest.TestCase):
+    def test_function_type_defaults(self):
+        def ex(a, /, b, *, c):
+            return a + b + c
+
+        func = types.FunctionType(
+            ex.__code__, {}, "func", (1, 2), None, {'c': 3},
+        )
+
+        self.assertEqual(func(), 6)
+        self.assertEqual(func.__defaults__, (1, 2))
+        self.assertEqual(func.__kwdefaults__, {'c': 3})
+
+        func = types.FunctionType(
+            ex.__code__, {}, "func", None, None, None,
+        )
+        self.assertEqual(func.__defaults__, None)
+        self.assertEqual(func.__kwdefaults__, None)
+
+    def test_function_type_wrong_defaults(self):
+        def ex(a, /, b, *, c):
+            return a + b + c
+
+        with self.assertRaisesRegex(TypeError, 'arg 4'):
+            types.FunctionType(
+                ex.__code__, {}, "func", 1, None, {'c': 3},
+            )
+        with self.assertRaisesRegex(TypeError, 'arg 6'):
+            types.FunctionType(
+                ex.__code__, {}, "func", None, None, 3,
+            )
+
+
+class SubinterpreterTests(unittest.TestCase):
+
+    NUMERIC_METHODS = {
+        '__abs__',
+        '__add__',
+        '__bool__',
+        '__divmod__',
+        '__float__',
+        '__floordiv__',
+        '__index__',
+        '__int__',
+        '__lshift__',
+        '__mod__',
+        '__mul__',
+        '__neg__',
+        '__pos__',
+        '__pow__',
+        '__radd__',
+        '__rdivmod__',
+        '__rfloordiv__',
+        '__rlshift__',
+        '__rmod__',
+        '__rmul__',
+        '__rpow__',
+        '__rrshift__',
+        '__rshift__',
+        '__rsub__',
+        '__rtruediv__',
+        '__sub__',
+        '__truediv__',
+    }
+
+    @classmethod
+    def setUpClass(cls):
+        global interpreters
+        try:
+            from concurrent import interpreters
+        except ModuleNotFoundError:
+            raise unittest.SkipTest('subinterpreters required')
+        from test.support import channels  # noqa: F401
+        cls.create_channel = staticmethod(channels.create)
+
+    @cpython_only
+    @no_rerun('channels (and queues) might have a refleak; see gh-122199')
+    def test_static_types_inherited_slots(self):
+        rch, sch = self.create_channel()
+
+        script = textwrap.dedent("""
+            import test.support
+            results = []
+            for cls in test.support.iter_builtin_types():
+                for attr, _ in test.support.iter_slot_wrappers(cls):
+                    wrapper = getattr(cls, attr)
+                    res = (cls, attr, wrapper)
+                    results.append(res)
+            results = tuple((repr(c), a, repr(w)) for c, a, w in results)
+            sch.send_nowait(results)
+            """)
+        def collate_results(raw):
+            results = {}
+            for cls, attr, wrapper in raw:
+                key = cls, attr
+                assert key not in results, (results, key, wrapper)
+                results[key] = wrapper
+            return results
+
+        exec(script)
+        raw = rch.recv_nowait()
+        main_results = collate_results(raw)
+
+        interp = interpreters.create()
+        interp.exec('from concurrent import interpreters')
+        interp.prepare_main(sch=sch)
+        interp.exec(script)
+        raw = rch.recv_nowait()
+        interp_results = collate_results(raw)
+
+        for key, expected in main_results.items():
+            cls, attr = key
+            with self.subTest(cls=cls, slotattr=attr):
+                actual = interp_results.pop(key)
+                self.assertEqual(actual, expected)
+        self.maxDiff = None
+        self.assertEqual(interp_results, {})
+
+
 if __name__ == '__main__':
     unittest.main()

From 301ff32a59c68486b09acf95947de2ce88c93ed9 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 00:13:51 +0900
Subject: [PATCH 395/418] mark failing test_dataclasses

---
 Lib/test/test_dataclasses/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Lib/test/test_dataclasses/__init__.py b/Lib/test/test_dataclasses/__init__.py
index 3f1e2331bc2..4db73a64e73 100644
--- a/Lib/test/test_dataclasses/__init__.py
+++ b/Lib/test/test_dataclasses/__init__.py
@@ -2311,6 +2311,7 @@ class C:
 
         self.assertDocStrEqual(C.__doc__, "C(x:int=3)")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_docstring_one_field_with_default_none(self):
         @dataclass
         class C:

From 1dceb7533d6e531e1081de2d62c146e057f5d243 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 01:41:35 +0900
Subject: [PATCH 396/418] mark failing tests on test_types

---
 Lib/test/test_functools.py            | 1 +
 Lib/test/test_inspect/test_inspect.py | 2 ++
 Lib/test/test_types.py                | 3 +++
 3 files changed, 6 insertions(+)

diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 047916caf07..bf3e24481ca 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -2922,6 +2922,7 @@ def decorated_classmethod(cls, arg: int) -> str:
             'decorated_classmethod'
         )
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_registrations(self):
         msg_prefix = "Invalid first argument to `register()`: "
         msg_suffix = (
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index 7d037d0554e..655587e7bb4 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -2028,6 +2028,7 @@ def test_pep_695_generics_with_future_annotations_nested_in_function(self):
 
 
 class TestFormatAnnotation(unittest.TestCase):
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_typing_replacement(self):
         from test.typinganndata.ann_module9 import A, ann, ann1
         self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]')
@@ -2040,6 +2041,7 @@ def test_typing_replacement(self):
             'Union[List[testModule.typing.A], int]',
         )
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_formatannotationrelativeto(self):
         from test.typinganndata.ann_module9 import A, ann1
 
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 3410c7ac206..073599e1dd2 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -665,6 +665,7 @@ def test_method_descriptor_types(self):
         self.assertIsInstance(int.from_bytes, types.BuiltinMethodType)
         self.assertIsInstance(int.__new__, types.BuiltinMethodType)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; ModuleNotFoundError: No module named '_queue'
     def test_method_descriptor_crash(self):
         # gh-132747: The default __get__() implementation in C was unable
         # to handle a second argument of None when called from Python
@@ -1888,6 +1889,7 @@ class D(dict):
         D.__getitem__ = dict.__getitem__
         self.assertIs(d[None], None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'tuple'> != <class 'test.test_types.ClassCreationTests.test_tu[41 chars]ass'>
     def test_tuple_subclass_as_bases(self):
         # gh-132176: it used to crash on using
         # tuple subclass for as base classes.
@@ -2493,6 +2495,7 @@ def ex(a, /, b, *, c):
             )
 
 
+@unittest.skip("TODO: RUSTPYTHON; no subinterpreters yet")
 class SubinterpreterTests(unittest.TestCase):
 
     NUMERIC_METHODS = {

From 1740b083b8304bfdcc97d1842586da10b6044937 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 01:57:22 +0900
Subject: [PATCH 397/418] namespace constructor and __replace__

---
 crates/vm/src/builtins/namespace.rs | 63 ++++++++++++++++++++++++++++-
 1 file changed, 61 insertions(+), 2 deletions(-)

diff --git a/crates/vm/src/builtins/namespace.rs b/crates/vm/src/builtins/namespace.rs
index 03969c35e7b..5593854d711 100644
--- a/crates/vm/src/builtins/namespace.rs
+++ b/crates/vm/src/builtins/namespace.rs
@@ -42,15 +42,74 @@ impl PyNamespace {
         );
         result.into_pytuple(vm)
     }
+
+    #[pymethod]
+    fn __replace__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        if !args.args.is_empty() {
+            return Err(vm.new_type_error("__replace__() takes no positional arguments"));
+        }
+
+        // Create a new instance of the same type
+        let cls: PyObjectRef = zelf.class().to_owned().into();
+        let result = cls.call((), vm)?;
+
+        // Copy the current namespace dict to the new instance
+        let src_dict = zelf.dict().unwrap();
+        let dst_dict = result.dict().unwrap();
+        for (key, value) in src_dict {
+            dst_dict.set_item(&*key, value, vm)?;
+        }
+
+        // Update with the provided kwargs
+        for (name, value) in args.kwargs {
+            let name = vm.ctx.new_str(name);
+            result.set_attr(&name, value, vm)?;
+        }
+
+        Ok(result)
+    }
 }
 
 impl Initializer for PyNamespace {
     type Args = FuncArgs;
 
     fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
-        if !args.args.is_empty() {
-            return Err(vm.new_type_error("no positional arguments expected"));
+        // SimpleNamespace accepts 0 or 1 positional argument (a mapping)
+        if args.args.len() > 1 {
+            return Err(vm.new_type_error(format!(
+                "{} expected at most 1 positional argument, got {}",
+                zelf.class().name(),
+                args.args.len()
+            )));
         }
+
+        // If there's a positional argument, treat it as a mapping
+        if let Some(mapping) = args.args.first() {
+            // Convert to dict if not already
+            let dict: PyRef<PyDict> = if let Some(d) = mapping.downcast_ref::<PyDict>() {
+                d.to_owned()
+            } else {
+                // Call dict() on the mapping
+                let dict_type: PyObjectRef = vm.ctx.types.dict_type.to_owned().into();
+                dict_type
+                    .call((mapping.clone(),), vm)?
+                    .downcast()
+                    .map_err(|_| vm.new_type_error("dict() did not return a dict"))?
+            };
+
+            // Validate keys are strings and set attributes
+            for (key, value) in dict.into_iter() {
+                let key_str = key.downcast_ref::<crate::builtins::PyStr>().ok_or_else(|| {
+                    vm.new_type_error(format!(
+                        "keywords must be strings, not '{}'",
+                        key.class().name()
+                    ))
+                })?;
+                zelf.as_object().set_attr(key_str, value, vm)?;
+            }
+        }
+
+        // Apply keyword arguments (these override positional mapping values)
         for (name, value) in args.kwargs {
             let name = vm.ctx.new_str(name);
             zelf.as_object().set_attr(&name, value, vm)?;

From 6f41a9491bb17fabb2413cc25acfb8f659e57e76 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Mon, 19 Jan 2026 18:51:33 +0000
Subject: [PATCH 398/418] Auto-format: cargo fmt --all

---
 crates/vm/src/builtins/namespace.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/crates/vm/src/builtins/namespace.rs b/crates/vm/src/builtins/namespace.rs
index 5593854d711..2cc1693302a 100644
--- a/crates/vm/src/builtins/namespace.rs
+++ b/crates/vm/src/builtins/namespace.rs
@@ -99,12 +99,14 @@ impl Initializer for PyNamespace {
 
             // Validate keys are strings and set attributes
             for (key, value) in dict.into_iter() {
-                let key_str = key.downcast_ref::<crate::builtins::PyStr>().ok_or_else(|| {
-                    vm.new_type_error(format!(
-                        "keywords must be strings, not '{}'",
-                        key.class().name()
-                    ))
-                })?;
+                let key_str = key
+                    .downcast_ref::<crate::builtins::PyStr>()
+                    .ok_or_else(|| {
+                        vm.new_type_error(format!(
+                            "keywords must be strings, not '{}'",
+                            key.class().name()
+                        ))
+                    })?;
                 zelf.as_object().set_attr(key_str, value, vm)?;
             }
         }

From d119c47d2ec3444c81137fa493f0e5b0e59d315e Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Mon, 19 Jan 2026 10:19:47 +0900
Subject: [PATCH 399/418] Remake update_lib

---
 .claude/commands/upgrade-pylib.md             |  49 +-
 scripts/auto_mark_test.py                     | 411 ----------
 scripts/update_lib/__init__.py                |  37 +
 scripts/update_lib/__main__.py                |  84 +++
 scripts/update_lib/auto_mark.py               | 704 ++++++++++++++++++
 scripts/update_lib/copy_lib.py                |  82 ++
 scripts/update_lib/migrate.py                 | 142 ++++
 .../patch_spec.py}                            | 239 ++----
 scripts/update_lib/patches.py                 | 106 +++
 scripts/update_lib/path.py                    |  99 +++
 scripts/update_lib/quick.py                   | 365 +++++++++
 scripts/update_lib/tests/__init__.py          |   0
 scripts/update_lib/tests/test_auto_mark.py    | 593 +++++++++++++++
 scripts/update_lib/tests/test_migrate.py      | 196 +++++
 scripts/update_lib/tests/test_patch_spec.py   | 325 ++++++++
 scripts/update_lib/tests/test_path.py         | 201 +++++
 scripts/update_lib/tests/test_quick.py        | 180 +++++
 17 files changed, 3231 insertions(+), 582 deletions(-)
 delete mode 100644 scripts/auto_mark_test.py
 create mode 100644 scripts/update_lib/__init__.py
 create mode 100644 scripts/update_lib/__main__.py
 create mode 100644 scripts/update_lib/auto_mark.py
 create mode 100644 scripts/update_lib/copy_lib.py
 create mode 100644 scripts/update_lib/migrate.py
 rename scripts/{lib_updater.py => update_lib/patch_spec.py} (60%)
 mode change 100755 => 100644
 create mode 100644 scripts/update_lib/patches.py
 create mode 100644 scripts/update_lib/path.py
 create mode 100644 scripts/update_lib/quick.py
 create mode 100644 scripts/update_lib/tests/__init__.py
 create mode 100644 scripts/update_lib/tests/test_auto_mark.py
 create mode 100644 scripts/update_lib/tests/test_migrate.py
 create mode 100644 scripts/update_lib/tests/test_patch_spec.py
 create mode 100644 scripts/update_lib/tests/test_path.py
 create mode 100644 scripts/update_lib/tests/test_quick.py

diff --git a/.claude/commands/upgrade-pylib.md b/.claude/commands/upgrade-pylib.md
index 02ec7c0d376..67603ce2dfb 100644
--- a/.claude/commands/upgrade-pylib.md
+++ b/.claude/commands/upgrade-pylib.md
@@ -5,6 +5,22 @@ Upgrade a Python standard library module from CPython to RustPython.
 ## Arguments
 - `$ARGUMENTS`: Library name to upgrade (e.g., `inspect`, `asyncio`, `json`)
 
+## Important: Report Tool Issues First
+
+If during the upgrade process you encounter any of the following issues with `scripts/update_lib`:
+- A feature that should be automated but isn't supported
+- A bug or unexpected behavior in the tool
+- Missing functionality that would make the upgrade easier
+
+**STOP the upgrade and report the issue first.** Describe:
+1. What you were trying to do
+  - Library name
+  - The full command executed (e.g. python scripts/update_lib quick cpython/Lib/$ARGUMENTS.py)
+2. What went wrong or what's missing
+3. Expected vs actual behavior
+
+This helps improve the tooling for future upgrades.
+
 ## Steps
 
 1. **Delete existing library in Lib/**
@@ -15,18 +31,14 @@ Upgrade a Python standard library module from CPython to RustPython.
    - If `cpython/Lib/$ARGUMENTS.py` exists, copy it to `Lib/$ARGUMENTS.py`
    - If `cpython/Lib/$ARGUMENTS/` directory exists, copy it to `Lib/$ARGUMENTS/`
 
-3. **Upgrade tests (quick upgrade with lib_updater)**
-   - If `cpython/Lib/test/test_$ARGUMENTS.py` is a single file:
-     - Run: `python3 scripts/lib_updater.py --quick-upgrade cpython/Lib/test/test_$ARGUMENTS.py`
-   - If `cpython/Lib/test/test_$ARGUMENTS/` is a directory:
-     - Run the script for each `.py` file in the directory:
-       ```bash
-       for f in cpython/Lib/test/test_$ARGUMENTS/*.py; do
-           python3 scripts/lib_updater.py --quick-upgrade "$f"
-       done
-       ```
-   - This will update the test files with basic RustPython markers (`@unittest.expectedFailure`, `@unittest.skip`, etc.)
-   - **Handle lib_updater warnings**: If you see warnings like `WARNING: TestCFoo does not exist in remote file`, it means the class structure changed between versions and markers couldn't be transferred automatically. These need to be manually restored in step 4 or added in step 5.
+3. **Upgrade tests (quick upgrade with update_lib)**
+   - Run: `python3 scripts/update_lib quick cpython/Lib/test/test_$ARGUMENTS.py` (single file)
+   - Or: `python3 scripts/update_lib quick cpython/Lib/test/test_$ARGUMENTS/` (directory)
+   - This will:
+     - Patch test files preserving existing RustPython markers
+     - Run tests and auto-mark new test failures (not regressions)
+     - Remove `@unittest.expectedFailure` from tests that now pass
+   - **Handle warnings**: If you see warnings like `WARNING: TestCFoo does not exist in remote file`, it means the class structure changed and markers couldn't be transferred automatically. These need to be manually restored in step 4 or added in step 5.
 
 4. **Review git diff and restore RUSTPYTHON-specific changes**
    - Run `git diff Lib/test/test_$ARGUMENTS` to review all changes
@@ -96,10 +108,19 @@ cjson = import_helper.import_fresh_module('json') #, fresh=['_json'])
 
 ## Notes
 - The cpython/ directory should contain the CPython source that we're syncing from
-- `scripts/lib_updater.py` handles basic patching:
+- `scripts/update_lib` package handles patching and auto-marking:
+  - `quick` - Combined patch + auto-mark (recommended)
+  - `migrate` - Only migrate (patch), no test running
+  - `auto-mark` - Only run tests and mark failures
+  - `copy-lib` - Copy library files (not tests)
+- The patching:
   - Transfers `@unittest.expectedFailure` and `@unittest.skip` decorators with `TODO: RUSTPYTHON` markers
   - Adds `import unittest # XXX: RUSTPYTHON` if needed for the decorators
-  - **Limitation**: If a class was restructured (e.g., method overrides removed), lib_updater will warn and skip those markers
+  - **Limitation**: If a class was restructured (e.g., method overrides removed), update_lib will warn and skip those markers
+- The smart auto-mark:
+  - Marks NEW test failures automatically (tests that didn't exist before)
+  - Does NOT mark regressions (existing tests that now fail) - these are warnings
+  - Removes `@unittest.expectedFailure` from tests that now pass
 - The script does NOT preserve all RustPython-specific changes - you must review `git diff` and restore them
 - Common RustPython markers to look for:
   - `# XXX: RUSTPYTHON` or `# XXX RUSTPYTHON` - Inline comments for code modifications
diff --git a/scripts/auto_mark_test.py b/scripts/auto_mark_test.py
deleted file mode 100644
index 59c7d8a05b0..00000000000
--- a/scripts/auto_mark_test.py
+++ /dev/null
@@ -1,411 +0,0 @@
-"""
-An automated script to mark failures in python test suite.
-It adds @unittest.expectedFailure to the test functions that are failing in RustPython, but not in CPython.
-As well as marking the test with a TODO comment.
-
-Quick Import (recommended):
-    python ./scripts/fix_test.py --quick-import cpython/Lib/test/test_foo.py
-
-    This will:
-    1. Copy cpython/Lib/test/test_foo.py to Lib/test/test_foo.py (if not exists)
-    2. Run the test with RustPython
-    3. Mark failing tests with @unittest.expectedFailure
-
-Manual workflow:
-1. Copy a specific test from the CPython repository to the RustPython repository.
-2. Remove all unexpected failures from the test and skip the tests that hang.
-3. Build RustPython: cargo build --release
-4. Run from the project root:
-   - For single-file tests: python ./scripts/fix_test.py --path ./Lib/test/test_venv.py
-   - For package tests: python ./scripts/fix_test.py --path ./Lib/test/test_inspect/test_inspect.py
-5. Verify: cargo run --release -- -m test test_venv (should pass with expected failures)
-6. Actually fix the tests marked with # TODO: RUSTPYTHON
-"""
-
-import argparse
-import ast
-import re
-import shutil
-import sys
-from pathlib import Path
-
-from lib_updater import (
-    COMMENT,
-    PatchSpec,
-    UtMethod,
-    apply_patches,
-)
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Fix test.")
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--path", type=Path, help="Path to test file")
-    group.add_argument(
-        "--quick-import",
-        type=Path,
-        metavar="PATH",
-        help="Import from path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
-    )
-    parser.add_argument("--force", action="store_true", help="Force modification")
-    parser.add_argument(
-        "--platform", action="store_true", help="Platform specific failure"
-    )
-
-    args = parser.parse_args()
-    return args
-
-
-class Test:
-    name: str = ""
-    path: str = ""
-    result: str = ""
-
-    def __str__(self):
-        return f"Test(name={self.name}, path={self.path}, result={self.result})"
-
-
-class TestResult:
-    tests_result: str = ""
-    tests = []
-    unexpected_successes = []  # Tests that passed but were marked as expectedFailure
-    stdout = ""
-
-    def __str__(self):
-        return f"TestResult(tests_result={self.tests_result},tests={len(self.tests)},unexpected_successes={len(self.unexpected_successes)})"
-
-
-def parse_results(result):
-    lines = result.stdout.splitlines()
-    test_results = TestResult()
-    test_results.tests = []
-    test_results.unexpected_successes = []
-    test_results.stdout = result.stdout
-    in_test_results = False
-    for line in lines:
-        if re.search(r"Run \d+ tests? sequentially", line):
-            in_test_results = True
-        elif line.startswith("-----------"):
-            in_test_results = False
-        if in_test_results and " ... " in line:
-            line = line.strip()
-            # Skip lines that don't look like test results
-            if line.startswith("tests") or line.startswith("["):
-                continue
-            # Parse: "test_name (path) [subtest] ... RESULT"
-            parts = line.split(" ... ")
-            if len(parts) >= 2:
-                test_info = parts[0]
-                result_str = parts[-1].lower()
-                # Only process FAIL or ERROR
-                if result_str not in ("fail", "error"):
-                    continue
-                # Extract test name (first word)
-                first_space = test_info.find(" ")
-                if first_space > 0:
-                    test = Test()
-                    test.name = test_info[:first_space]
-                    # Extract path from (path)
-                    rest = test_info[first_space:].strip()
-                    if rest.startswith("("):
-                        end_paren = rest.find(")")
-                        if end_paren > 0:
-                            test.path = rest[1:end_paren]
-                            test.result = result_str
-                            test_results.tests.append(test)
-        elif "== Tests result: " in line:
-            res = line.split("== Tests result: ")[1]
-            res = res.split(" ")[0]
-            test_results.tests_result = res
-        # Parse: "UNEXPECTED SUCCESS: test_name (path)"
-        elif line.startswith("UNEXPECTED SUCCESS: "):
-            rest = line[len("UNEXPECTED SUCCESS: ") :]
-            # Format: "test_name (path)"
-            first_space = rest.find(" ")
-            if first_space > 0:
-                test = Test()
-                test.name = rest[:first_space]
-                path_part = rest[first_space:].strip()
-                if path_part.startswith("(") and path_part.endswith(")"):
-                    test.path = path_part[1:-1]
-                    test.result = "unexpected_success"
-                    test_results.unexpected_successes.append(test)
-    return test_results
-
-
-def path_to_test(path) -> list[str]:
-    # path format: test.module_name[.submodule].ClassName.test_method
-    # We need [ClassName, test_method] - always the last 2 elements
-    parts = path.split(".")
-    return parts[-2:]  # Get class name and method name
-
-
-def is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
-    """Check if the method body is just 'return super().method_name()'."""
-    if len(func_node.body) != 1:
-        return False
-    stmt = func_node.body[0]
-    if not isinstance(stmt, ast.Return) or stmt.value is None:
-        return False
-    # Check for super().method_name() pattern
-    call = stmt.value
-    if not isinstance(call, ast.Call):
-        return False
-    if not isinstance(call.func, ast.Attribute):
-        return False
-    super_call = call.func.value
-    if not isinstance(super_call, ast.Call):
-        return False
-    if not isinstance(super_call.func, ast.Name) or super_call.func.id != "super":
-        return False
-    return True
-
-
-def build_inheritance_info(tree: ast.Module) -> tuple[dict, dict]:
-    """
-    Build inheritance information from AST.
-
-    Returns:
-        class_bases: dict[str, list[str]] - parent classes for each class (only those defined in the file)
-        class_methods: dict[str, set[str]] - methods directly defined in each class
-    """
-    all_classes = {
-        node.name for node in ast.walk(tree) if isinstance(node, ast.ClassDef)
-    }
-    class_bases = {}
-    class_methods = {}
-
-    for node in ast.walk(tree):
-        if isinstance(node, ast.ClassDef):
-            # Collect only parent classes defined in this file
-            bases = [
-                base.id
-                for base in node.bases
-                if isinstance(base, ast.Name) and base.id in all_classes
-            ]
-            class_bases[node.name] = bases
-
-            # Collect directly defined methods
-            methods = {
-                item.name
-                for item in node.body
-                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
-            }
-            class_methods[node.name] = methods
-
-    return class_bases, class_methods
-
-
-def find_method_definition(
-    class_name: str, method_name: str, class_bases: dict, class_methods: dict
-) -> str | None:
-    """Find the class where a method is actually defined. Traverses inheritance chain (BFS)."""
-    # Check current class first
-    if method_name in class_methods.get(class_name, set()):
-        return class_name
-
-    # Search parent classes
-    visited = set()
-    queue = list(class_bases.get(class_name, []))
-
-    while queue:
-        current = queue.pop(0)
-        if current in visited:
-            continue
-        visited.add(current)
-
-        if method_name in class_methods.get(current, set()):
-            return current
-        queue.extend(class_bases.get(current, []))
-
-    return None
-
-
-def remove_expected_failures(
-    contents: str, tests_to_remove: set[tuple[str, str]]
-) -> str:
-    """Remove @unittest.expectedFailure decorators from tests that now pass."""
-    if not tests_to_remove:
-        return contents
-
-    tree = ast.parse(contents)
-    lines = contents.splitlines()
-    lines_to_remove = set()
-
-    # Build inheritance information
-    class_bases, class_methods = build_inheritance_info(tree)
-
-    # Resolve to actual defining classes
-    resolved_tests = set()
-    for class_name, method_name in tests_to_remove:
-        defining_class = find_method_definition(
-            class_name, method_name, class_bases, class_methods
-        )
-        if defining_class:
-            resolved_tests.add((defining_class, method_name))
-
-    for node in ast.walk(tree):
-        if not isinstance(node, ast.ClassDef):
-            continue
-        class_name = node.name
-        for item in node.body:
-            if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                continue
-            method_name = item.name
-            if (class_name, method_name) not in resolved_tests:
-                continue
-
-            # Check if we should remove the entire method (super() call only)
-            remove_entire_method = is_super_call_only(item)
-
-            if remove_entire_method:
-                # Remove entire method including decorators and any preceding comment
-                first_line = item.lineno - 1  # 0-indexed, def line
-                if item.decorator_list:
-                    first_line = item.decorator_list[0].lineno - 1
-                # Check for TODO comment before first decorator/def
-                if first_line > 0:
-                    prev_line = lines[first_line - 1].strip()
-                    if prev_line.startswith("#") and COMMENT in prev_line:
-                        first_line -= 1
-                # Remove from first_line to end_lineno (inclusive)
-                for i in range(first_line, item.end_lineno):
-                    lines_to_remove.add(i)
-            else:
-                # Only remove the expectedFailure decorator
-                for dec in item.decorator_list:
-                    dec_line = dec.lineno - 1  # 0-indexed
-                    line_content = lines[dec_line]
-
-                    # Check if it's @unittest.expectedFailure
-                    if "expectedFailure" not in line_content:
-                        continue
-
-                    # Check if TODO: RUSTPYTHON is on the same line or the line before
-                    has_comment_on_line = COMMENT in line_content
-                    has_comment_before = (
-                        dec_line > 0
-                        and lines[dec_line - 1].strip().startswith("#")
-                        and COMMENT in lines[dec_line - 1]
-                    )
-
-                    if has_comment_on_line or has_comment_before:
-                        lines_to_remove.add(dec_line)
-                        if has_comment_before:
-                            lines_to_remove.add(dec_line - 1)
-
-    # Remove lines in reverse order to maintain line numbers
-    for line_idx in sorted(lines_to_remove, reverse=True):
-        del lines[line_idx]
-
-    return "\n".join(lines) + "\n" if lines else ""
-
-
-def build_patches(test_parts_set: set[tuple[str, str]]) -> dict:
-    """Convert failing tests to lib_updater patch format."""
-    patches = {}
-    for class_name, method_name in test_parts_set:
-        if class_name not in patches:
-            patches[class_name] = {}
-        patches[class_name][method_name] = [
-            PatchSpec(UtMethod.ExpectedFailure, None, "")
-        ]
-    return patches
-
-
-def run_test(test_name):
-    print(f"Running test: {test_name}")
-    rustpython_location = "./target/release/rustpython"
-    if sys.platform == "win32":
-        rustpython_location += ".exe"
-
-    import subprocess
-
-    result = subprocess.run(
-        [rustpython_location, "-m", "test", "-v", "-u", "all", "--slowest", test_name],
-        capture_output=True,
-        text=True,
-    )
-    return parse_results(result)
-
-
-if __name__ == "__main__":
-    args = parse_args()
-
-    # Handle --quick-import: extract Lib/... path and copy if needed
-    if args.quick_import is not None:
-        # Normalize path separators to forward slashes for cross-platform support
-        src_str = str(args.quick_import).replace("\\", "/")
-        lib_marker = "/Lib/"
-
-        if lib_marker not in src_str:
-            print(
-                f"Error: --quick-import path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_import})"
-            )
-            sys.exit(1)
-
-        idx = src_str.index(lib_marker)
-        lib_path = Path(src_str[idx + 1 :])  # Lib/test/foo.py
-        src_path = args.quick_import
-
-        if not src_path.exists():
-            print(f"Error: Source file not found: {src_path}")
-            sys.exit(1)
-
-        if not lib_path.exists():
-            print(f"Copying: {src_path} -> {lib_path}")
-            lib_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy(src_path, lib_path)
-        else:
-            print(f"File already exists: {lib_path}")
-
-        args.path = lib_path
-
-    test_path = args.path.resolve()
-    if not test_path.exists():
-        print(f"Error: File not found: {test_path}")
-        sys.exit(1)
-    # Detect package tests (e.g., test_ctypes/test_random_things.py)
-    if test_path.parent.name.startswith("test_"):
-        test_name = f"{test_path.parent.name}.{test_path.stem}"
-    else:
-        test_name = test_path.stem
-    tests = run_test(test_name)
-    f = test_path.read_text(encoding="utf-8")
-
-    # Collect failing tests (with deduplication for subtests)
-    failing_tests = set()  # Track (class_name, method_name) to avoid duplicates
-    for test in tests.tests:
-        if test.result == "fail" or test.result == "error":
-            test_parts = path_to_test(test.path)
-            if len(test_parts) == 2:
-                test_key = tuple(test_parts)
-                if test_key not in failing_tests:
-                    failing_tests.add(test_key)
-                    print(f"Marking as failing: {test_parts[0]}.{test_parts[1]}")
-
-    # Collect unexpected successes (tests that now pass but have expectedFailure)
-    unexpected_successes = set()
-    for test in tests.unexpected_successes:
-        test_parts = path_to_test(test.path)
-        if len(test_parts) == 2:
-            test_key = tuple(test_parts)
-            if test_key not in unexpected_successes:
-                unexpected_successes.add(test_key)
-                print(f"Removing expectedFailure: {test_parts[0]}.{test_parts[1]}")
-
-    # Remove expectedFailure from tests that now pass
-    if unexpected_successes:
-        f = remove_expected_failures(f, unexpected_successes)
-
-    # Apply patches for failing tests
-    if failing_tests:
-        patches = build_patches(failing_tests)
-        f = apply_patches(f, patches)
-
-    # Write changes if any modifications were made
-    if failing_tests or unexpected_successes:
-        test_path.write_text(f, encoding="utf-8")
-
-    print(f"Added expectedFailure to {len(failing_tests)} tests")
-    print(f"Removed expectedFailure from {len(unexpected_successes)} tests")
diff --git a/scripts/update_lib/__init__.py b/scripts/update_lib/__init__.py
new file mode 100644
index 00000000000..ccb2628d6a4
--- /dev/null
+++ b/scripts/update_lib/__init__.py
@@ -0,0 +1,37 @@
+"""
+Library for updating Python test files with RustPython-specific patches.
+"""
+
+from .patch_spec import (
+    COMMENT,
+    DEFAULT_INDENT,
+    UT,
+    PatchEntry,
+    Patches,
+    PatchSpec,
+    UtMethod,
+    apply_patches,
+    build_patch_dict,
+    extract_patches,
+    iter_patches,
+    iter_tests,
+    patches_from_json,
+    patches_to_json,
+)
+
+__all__ = [
+    "COMMENT",
+    "DEFAULT_INDENT",
+    "UT",
+    "Patches",
+    "PatchEntry",
+    "PatchSpec",
+    "UtMethod",
+    "apply_patches",
+    "build_patch_dict",
+    "extract_patches",
+    "iter_patches",
+    "iter_tests",
+    "patches_from_json",
+    "patches_to_json",
+]
diff --git a/scripts/update_lib/__main__.py b/scripts/update_lib/__main__.py
new file mode 100644
index 00000000000..f20f41c84e0
--- /dev/null
+++ b/scripts/update_lib/__main__.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+"""
+Update library tools for RustPython.
+
+Usage:
+    python scripts/update_lib quick cpython/Lib/test/test_foo.py
+    python scripts/update_lib copy-lib cpython/Lib/dataclasses.py
+    python scripts/update_lib migrate cpython/Lib/test/test_foo.py
+    python scripts/update_lib patches --from Lib/test/foo.py --to cpython/Lib/test/foo.py
+    python scripts/update_lib auto-mark Lib/test/test_foo.py
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Update library tools for RustPython",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser(
+        "quick",
+        help="Quick update: patch + auto-mark (recommended)",
+        add_help=False,
+    )
+    subparsers.add_parser(
+        "migrate",
+        help="Migrate test file(s) from CPython, preserving RustPython markers",
+        add_help=False,
+    )
+    subparsers.add_parser(
+        "patches",
+        help="Patch management (extract/apply patches between files)",
+        add_help=False,
+    )
+    subparsers.add_parser(
+        "auto-mark",
+        help="Run tests and auto-mark failures with @expectedFailure",
+        add_help=False,
+    )
+    subparsers.add_parser(
+        "copy-lib",
+        help="Copy library file/directory from CPython (delete existing first)",
+        add_help=False,
+    )
+
+    args, remaining = parser.parse_known_args(argv)
+
+    if args.command == "quick":
+        from update_lib.quick import main as quick_main
+
+        return quick_main(remaining)
+
+    if args.command == "copy-lib":
+        from update_lib.copy_lib import main as copy_lib_main
+
+        return copy_lib_main(remaining)
+
+    if args.command == "migrate":
+        from update_lib.migrate import main as migrate_main
+
+        return migrate_main(remaining)
+
+    if args.command == "patches":
+        from update_lib.patches import main as patches_main
+
+        return patches_main(remaining)
+
+    if args.command == "auto-mark":
+        from update_lib.auto_mark import main as auto_mark_main
+
+        return auto_mark_main(remaining)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/update_lib/auto_mark.py b/scripts/update_lib/auto_mark.py
new file mode 100644
index 00000000000..a716acea5ee
--- /dev/null
+++ b/scripts/update_lib/auto_mark.py
@@ -0,0 +1,704 @@
+#!/usr/bin/env python
+"""
+Auto-mark test failures in Python test suite.
+
+This module provides functions to:
+- Run tests with RustPython and parse results
+- Extract test names from test file paths
+- Mark failing tests with @unittest.expectedFailure
+- Remove expectedFailure from tests that now pass
+"""
+
+import ast
+import pathlib
+import re
+import subprocess
+import sys
+from dataclasses import dataclass, field
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from update_lib import COMMENT, PatchSpec, UtMethod, apply_patches
+from update_lib.path import test_name_from_path
+
+
+@dataclass
+class Test:
+    name: str = ""
+    path: str = ""
+    result: str = ""
+    error_message: str = ""
+
+
+@dataclass
+class TestResult:
+    tests_result: str = ""
+    tests: list[Test] = field(default_factory=list)
+    unexpected_successes: list[Test] = field(default_factory=list)
+    stdout: str = ""
+
+
+def run_test(test_name: str, skip_build: bool = False) -> TestResult:
+    """
+    Run a test with RustPython and return parsed results.
+
+    Args:
+        test_name: Test module name (e.g., "test_foo" or "test_ctypes.test_bar")
+        skip_build: If True, use pre-built binary instead of cargo run
+
+    Returns:
+        TestResult with parsed test results
+    """
+    if skip_build:
+        cmd = ["./target/release/rustpython"]
+        if sys.platform == "win32":
+            cmd = ["./target/release/rustpython.exe"]
+    else:
+        cmd = ["cargo", "run", "--release", "--"]
+
+    result = subprocess.run(
+        cmd + ["-m", "test", "-v", "-u", "all", "--slowest", test_name],
+        capture_output=True,
+        text=True,
+    )
+    return parse_results(result)
+
+
+def parse_results(result: subprocess.CompletedProcess) -> TestResult:
+    """Parse subprocess result into TestResult."""
+    lines = result.stdout.splitlines()
+    test_results = TestResult()
+    test_results.stdout = result.stdout
+    in_test_results = False
+
+    for line in lines:
+        if re.search(r"Run \d+ tests? sequentially", line):
+            in_test_results = True
+        elif line.startswith("-----------"):
+            in_test_results = False
+
+        if in_test_results and " ... " in line:
+            line = line.strip()
+            # Skip lines that don't look like test results
+            if line.startswith("tests") or line.startswith("["):
+                continue
+            # Parse: "test_name (path) [subtest] ... RESULT"
+            parts = line.split(" ... ")
+            if len(parts) >= 2:
+                test_info = parts[0]
+                result_str = parts[-1].lower()
+                # Only process FAIL or ERROR
+                if result_str not in ("fail", "error"):
+                    continue
+                # Extract test name (first word)
+                first_space = test_info.find(" ")
+                if first_space > 0:
+                    test = Test()
+                    test.name = test_info[:first_space]
+                    # Extract path from (path)
+                    rest = test_info[first_space:].strip()
+                    if rest.startswith("("):
+                        end_paren = rest.find(")")
+                        if end_paren > 0:
+                            test.path = rest[1:end_paren]
+                            test.result = result_str
+                            test_results.tests.append(test)
+
+        elif "== Tests result: " in line:
+            res = line.split("== Tests result: ")[1]
+            res = res.split(" ")[0]
+            test_results.tests_result = res
+
+        # Parse: "UNEXPECTED SUCCESS: test_name (path)"
+        elif line.startswith("UNEXPECTED SUCCESS: "):
+            rest = line[len("UNEXPECTED SUCCESS: ") :]
+            # Format: "test_name (path)"
+            first_space = rest.find(" ")
+            if first_space > 0:
+                test = Test()
+                test.name = rest[:first_space]
+                path_part = rest[first_space:].strip()
+                if path_part.startswith("(") and path_part.endswith(")"):
+                    test.path = path_part[1:-1]
+                    test.result = "unexpected_success"
+                    test_results.unexpected_successes.append(test)
+
+    # Parse error details to extract error messages
+    _parse_error_details(test_results, lines)
+
+    return test_results
+
+
+def _parse_error_details(test_results: TestResult, lines: list[str]) -> None:
+    """Parse error details section to extract error messages for each test."""
+    # Build a lookup dict for tests by (name, path)
+    test_lookup: dict[tuple[str, str], Test] = {}
+    for test in test_results.tests:
+        test_lookup[(test.name, test.path)] = test
+
+    # Parse error detail blocks
+    # Format:
+    # ======================================================================
+    # FAIL: test_name (path)
+    # ----------------------------------------------------------------------
+    # Traceback (most recent call last):
+    #   ...
+    # AssertionError: message
+    #
+    # ======================================================================
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        # Look for FAIL: or ERROR: header
+        if line.startswith(("FAIL: ", "ERROR: ")):
+            # Parse: "FAIL: test_name (path)" or "ERROR: test_name (path)"
+            header = line.split(": ", 1)[1] if ": " in line else ""
+            first_space = header.find(" ")
+            if first_space > 0:
+                test_name = header[:first_space]
+                path_part = header[first_space:].strip()
+                if path_part.startswith("(") and path_part.endswith(")"):
+                    test_path = path_part[1:-1]
+
+                    # Find the last non-empty line before the next separator or end
+                    error_lines = []
+                    i += 1
+                    # Skip the separator line
+                    if i < len(lines) and lines[i].startswith("-----"):
+                        i += 1
+
+                    # Collect lines until the next separator or end
+                    while i < len(lines):
+                        current = lines[i]
+                        if current.startswith("====="):
+                            break
+                        error_lines.append(current)
+                        i += 1
+
+                    # Find the last non-empty line (the error message)
+                    error_message = ""
+                    for err_line in reversed(error_lines):
+                        stripped = err_line.strip()
+                        if stripped:
+                            error_message = stripped
+                            break
+
+                    # Update the test with the error message
+                    if (test_name, test_path) in test_lookup:
+                        test_lookup[
+                            (test_name, test_path)
+                        ].error_message = error_message
+
+                    continue
+        i += 1
+
+
+def path_to_test_parts(path: str) -> list[str]:
+    """
+    Extract [ClassName, method_name] from test path.
+
+    Args:
+        path: Test path like "test.module_name.ClassName.test_method"
+
+    Returns:
+        [ClassName, method_name] - last 2 elements
+    """
+    parts = path.split(".")
+    return parts[-2:]
+
+
+def build_patches(
+    test_parts_set: set[tuple[str, str]],
+    error_messages: dict[tuple[str, str], str] | None = None,
+) -> dict:
+    """Convert failing tests to patch format."""
+    patches = {}
+    error_messages = error_messages or {}
+    for class_name, method_name in test_parts_set:
+        if class_name not in patches:
+            patches[class_name] = {}
+        reason = error_messages.get((class_name, method_name), "")
+        patches[class_name][method_name] = [
+            PatchSpec(UtMethod.ExpectedFailure, None, reason)
+        ]
+    return patches
+
+
+def _is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if the method body is just 'return super().method_name()'."""
+    if len(func_node.body) != 1:
+        return False
+    stmt = func_node.body[0]
+    if not isinstance(stmt, ast.Return) or stmt.value is None:
+        return False
+    call = stmt.value
+    if not isinstance(call, ast.Call):
+        return False
+    if not isinstance(call.func, ast.Attribute):
+        return False
+    super_call = call.func.value
+    if not isinstance(super_call, ast.Call):
+        return False
+    if not isinstance(super_call.func, ast.Name) or super_call.func.id != "super":
+        return False
+    return True
+
+
+def _build_inheritance_info(tree: ast.Module) -> tuple[dict, dict]:
+    """
+    Build inheritance information from AST.
+
+    Returns:
+        class_bases: dict[str, list[str]] - parent classes for each class
+        class_methods: dict[str, set[str]] - methods directly defined in each class
+    """
+    all_classes = {
+        node.name for node in ast.walk(tree) if isinstance(node, ast.ClassDef)
+    }
+    class_bases = {}
+    class_methods = {}
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            bases = [
+                base.id
+                for base in node.bases
+                if isinstance(base, ast.Name) and base.id in all_classes
+            ]
+            class_bases[node.name] = bases
+            methods = {
+                item.name
+                for item in node.body
+                if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef))
+            }
+            class_methods[node.name] = methods
+
+    return class_bases, class_methods
+
+
+def _find_method_definition(
+    class_name: str, method_name: str, class_bases: dict, class_methods: dict
+) -> str | None:
+    """Find the class where a method is actually defined (BFS)."""
+    if method_name in class_methods.get(class_name, set()):
+        return class_name
+
+    visited = set()
+    queue = list(class_bases.get(class_name, []))
+
+    while queue:
+        current = queue.pop(0)
+        if current in visited:
+            continue
+        visited.add(current)
+
+        if method_name in class_methods.get(current, set()):
+            return current
+        queue.extend(class_bases.get(current, []))
+
+    return None
+
+
+def remove_expected_failures(
+    contents: str, tests_to_remove: set[tuple[str, str]]
+) -> str:
+    """Remove @unittest.expectedFailure decorators from tests that now pass."""
+    if not tests_to_remove:
+        return contents
+
+    tree = ast.parse(contents)
+    lines = contents.splitlines()
+    lines_to_remove = set()
+
+    class_bases, class_methods = _build_inheritance_info(tree)
+
+    resolved_tests = set()
+    for class_name, method_name in tests_to_remove:
+        defining_class = _find_method_definition(
+            class_name, method_name, class_bases, class_methods
+        )
+        if defining_class:
+            resolved_tests.add((defining_class, method_name))
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        class_name = node.name
+        for item in node.body:
+            if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            method_name = item.name
+            if (class_name, method_name) not in resolved_tests:
+                continue
+
+            remove_entire_method = _is_super_call_only(item)
+
+            if remove_entire_method:
+                first_line = item.lineno - 1
+                if item.decorator_list:
+                    first_line = item.decorator_list[0].lineno - 1
+                if first_line > 0:
+                    prev_line = lines[first_line - 1].strip()
+                    if prev_line.startswith("#") and COMMENT in prev_line:
+                        first_line -= 1
+                for i in range(first_line, item.end_lineno):
+                    lines_to_remove.add(i)
+            else:
+                for dec in item.decorator_list:
+                    dec_line = dec.lineno - 1
+                    line_content = lines[dec_line]
+
+                    if "expectedFailure" not in line_content:
+                        continue
+
+                    has_comment_on_line = COMMENT in line_content
+                    has_comment_before = (
+                        dec_line > 0
+                        and lines[dec_line - 1].strip().startswith("#")
+                        and COMMENT in lines[dec_line - 1]
+                    )
+
+                    if has_comment_on_line or has_comment_before:
+                        lines_to_remove.add(dec_line)
+                        if has_comment_before:
+                            lines_to_remove.add(dec_line - 1)
+
+    for line_idx in sorted(lines_to_remove, reverse=True):
+        del lines[line_idx]
+
+    return "\n".join(lines) + "\n" if lines else ""
+
+
+def collect_test_changes(
+    results: TestResult,
+    module_prefix: str | None = None,
+) -> tuple[set[tuple[str, str]], set[tuple[str, str]], dict[tuple[str, str], str]]:
+    """
+    Collect failing tests and unexpected successes from test results.
+
+    Args:
+        results: TestResult from run_test()
+        module_prefix: If set, only collect tests whose path starts with this prefix
+
+    Returns:
+        (failing_tests, unexpected_successes, error_messages)
+        - failing_tests: set of (class_name, method_name) tuples
+        - unexpected_successes: set of (class_name, method_name) tuples
+        - error_messages: dict mapping (class_name, method_name) to error message
+    """
+    failing_tests = set()
+    error_messages: dict[tuple[str, str], str] = {}
+    for test in results.tests:
+        if test.result in ("fail", "error"):
+            if module_prefix and not test.path.startswith(module_prefix):
+                continue
+            test_parts = path_to_test_parts(test.path)
+            if len(test_parts) == 2:
+                key = tuple(test_parts)
+                failing_tests.add(key)
+                if test.error_message:
+                    error_messages[key] = test.error_message
+
+    unexpected_successes = set()
+    for test in results.unexpected_successes:
+        if module_prefix and not test.path.startswith(module_prefix):
+            continue
+        test_parts = path_to_test_parts(test.path)
+        if len(test_parts) == 2:
+            unexpected_successes.add(tuple(test_parts))
+
+    return failing_tests, unexpected_successes, error_messages
+
+
+def apply_test_changes(
+    contents: str,
+    failing_tests: set[tuple[str, str]],
+    unexpected_successes: set[tuple[str, str]],
+    error_messages: dict[tuple[str, str], str] | None = None,
+) -> str:
+    """
+    Apply test changes to content.
+
+    Args:
+        contents: File content
+        failing_tests: Set of (class_name, method_name) to mark as expectedFailure
+        unexpected_successes: Set of (class_name, method_name) to remove expectedFailure
+        error_messages: Dict mapping (class_name, method_name) to error message
+
+    Returns:
+        Modified content
+    """
+    if unexpected_successes:
+        contents = remove_expected_failures(contents, unexpected_successes)
+
+    if failing_tests:
+        patches = build_patches(failing_tests, error_messages)
+        contents = apply_patches(contents, patches)
+
+    return contents
+
+
+def extract_test_methods(contents: str) -> set[tuple[str, str]]:
+    """
+    Extract all test method names from file contents.
+
+    Returns:
+        Set of (class_name, method_name) tuples
+    """
+    import ast
+
+    try:
+        tree = ast.parse(contents)
+    except SyntaxError:
+        return set()
+
+    from update_lib.patch_spec import iter_tests
+
+    return {(cls_node.name, fn_node.name) for cls_node, fn_node in iter_tests(tree)}
+
+
+def auto_mark_file(
+    test_path: pathlib.Path,
+    mark_failure: bool = False,
+    verbose: bool = True,
+    original_methods: set[tuple[str, str]] | None = None,
+    skip_build: bool = False,
+) -> tuple[int, int, int]:
+    """
+    Run tests and auto-mark failures in a test file.
+
+    Args:
+        test_path: Path to the test file
+        mark_failure: If True, add @expectedFailure to ALL failing tests
+        verbose: Print progress messages
+        original_methods: If provided, only auto-mark failures for NEW methods
+                          (methods not in original_methods) even without mark_failure.
+                          Failures in existing methods are treated as regressions.
+
+    Returns:
+        (num_failures_added, num_successes_removed, num_regressions)
+    """
+    test_path = pathlib.Path(test_path).resolve()
+    if not test_path.exists():
+        raise FileNotFoundError(f"File not found: {test_path}")
+
+    test_name = test_name_from_path(test_path)
+    if verbose:
+        print(f"Running test: {test_name}")
+
+    results = run_test(test_name, skip_build=skip_build)
+    contents = test_path.read_text(encoding="utf-8")
+
+    all_failing_tests, unexpected_successes, error_messages = collect_test_changes(
+        results
+    )
+
+    # Determine which failures to mark
+    if mark_failure:
+        failing_tests = all_failing_tests
+    elif original_methods is not None:
+        # Smart mode: only mark NEW test failures (not regressions)
+        current_methods = extract_test_methods(contents)
+        new_methods = current_methods - original_methods
+        failing_tests = {t for t in all_failing_tests if t in new_methods}
+    else:
+        failing_tests = set()
+
+    regressions = all_failing_tests - failing_tests
+
+    if verbose:
+        for class_name, method_name in failing_tests:
+            label = "(new test)" if original_methods is not None else ""
+            err_msg = error_messages.get((class_name, method_name), "")
+            err_hint = f" - {err_msg}" if err_msg else ""
+            print(
+                f"Marking as failing {label}: {class_name}.{method_name}{err_hint}".replace(
+                    "  ", " "
+                )
+            )
+        for class_name, method_name in unexpected_successes:
+            print(f"Removing expectedFailure: {class_name}.{method_name}")
+
+    contents = apply_test_changes(
+        contents, failing_tests, unexpected_successes, error_messages
+    )
+
+    if failing_tests or unexpected_successes:
+        test_path.write_text(contents, encoding="utf-8")
+
+    # Show hints about unmarked failures
+    if verbose:
+        unmarked_failures = all_failing_tests - failing_tests
+        if unmarked_failures:
+            print(
+                f"Hint: {len(unmarked_failures)} failing tests can be marked with --mark-failure; "
+                "but review first and do not blindly mark them all"
+            )
+            for class_name, method_name in sorted(unmarked_failures):
+                err_msg = error_messages.get((class_name, method_name), "")
+                err_hint = f" - {err_msg}" if err_msg else ""
+                print(f"  {class_name}.{method_name}{err_hint}")
+
+    return len(failing_tests), len(unexpected_successes), len(regressions)
+
+
+def auto_mark_directory(
+    test_dir: pathlib.Path,
+    mark_failure: bool = False,
+    verbose: bool = True,
+    original_methods_per_file: dict[pathlib.Path, set[tuple[str, str]]] | None = None,
+    skip_build: bool = False,
+) -> tuple[int, int, int]:
+    """
+    Run tests and auto-mark failures in a test directory.
+
+    Runs the test once for the whole directory, then applies results to each file.
+
+    Args:
+        test_dir: Path to the test directory
+        mark_failure: If True, add @expectedFailure to ALL failing tests
+        verbose: Print progress messages
+        original_methods_per_file: If provided, only auto-mark failures for NEW methods
+                                   even without mark_failure. Dict maps file path to
+                                   set of (class_name, method_name) tuples.
+
+    Returns:
+        (num_failures_added, num_successes_removed, num_regressions)
+    """
+    test_dir = pathlib.Path(test_dir).resolve()
+    if not test_dir.exists():
+        raise FileNotFoundError(f"Directory not found: {test_dir}")
+    if not test_dir.is_dir():
+        raise ValueError(f"Not a directory: {test_dir}")
+
+    test_name = test_name_from_path(test_dir)
+    if verbose:
+        print(f"Running test: {test_name}")
+
+    results = run_test(test_name, skip_build=skip_build)
+
+    total_added = 0
+    total_removed = 0
+    total_regressions = 0
+    all_regressions: list[tuple[str, str, str, str]] = []
+
+    # Get all .py files in directory
+    test_files = sorted(test_dir.glob("**/*.py"))
+
+    for test_file in test_files:
+        # Get module prefix for this file (e.g., "test_inspect.test_inspect")
+        module_prefix = test_name_from_path(test_file)
+        # For __init__.py, the test path doesn't include "__init__"
+        if module_prefix.endswith(".__init__"):
+            module_prefix = module_prefix[:-9]  # Remove ".__init__"
+
+        all_failing_tests, unexpected_successes, error_messages = collect_test_changes(
+            results, module_prefix="test." + module_prefix + "."
+        )
+
+        # Determine which failures to mark
+        if mark_failure:
+            failing_tests = all_failing_tests
+        elif original_methods_per_file is not None:
+            # Smart mode: only mark NEW test failures
+            contents = test_file.read_text(encoding="utf-8")
+            current_methods = extract_test_methods(contents)
+            original_methods = original_methods_per_file.get(test_file, set())
+            new_methods = current_methods - original_methods
+            failing_tests = {t for t in all_failing_tests if t in new_methods}
+        else:
+            failing_tests = set()
+
+        regressions = all_failing_tests - failing_tests
+
+        if failing_tests or unexpected_successes:
+            if verbose:
+                for class_name, method_name in failing_tests:
+                    label = (
+                        "(new test)" if original_methods_per_file is not None else ""
+                    )
+                    err_msg = error_messages.get((class_name, method_name), "")
+                    err_hint = f" - {err_msg}" if err_msg else ""
+                    print(
+                        f"  {test_file.name}: Marking as failing {label}: {class_name}.{method_name}{err_hint}".replace(
+                            "  :", ":"
+                        )
+                    )
+                for class_name, method_name in unexpected_successes:
+                    print(
+                        f"  {test_file.name}: Removing expectedFailure: {class_name}.{method_name}"
+                    )
+
+            contents = test_file.read_text(encoding="utf-8")
+            contents = apply_test_changes(
+                contents, failing_tests, unexpected_successes, error_messages
+            )
+            test_file.write_text(contents, encoding="utf-8")
+
+        # Collect regressions with error messages for later reporting
+        for class_name, method_name in regressions:
+            err_msg = error_messages.get((class_name, method_name), "")
+            all_regressions.append((test_file.name, class_name, method_name, err_msg))
+
+        total_added += len(failing_tests)
+        total_removed += len(unexpected_successes)
+        total_regressions += len(regressions)
+
+    # Show hints about unmarked failures
+    if verbose and total_regressions > 0:
+        print(
+            f"Hint: {total_regressions} failing tests can be marked with --mark-failure; "
+            "but review first and do not blindly mark them all"
+        )
+        for file_name, class_name, method_name, err_msg in sorted(all_regressions):
+            err_hint = f" - {err_msg}" if err_msg else ""
+            print(f"  {file_name}: {class_name}.{method_name}{err_hint}")
+
+    return total_added, total_removed, total_regressions
+
+
+def main(argv: list[str] | None = None) -> int:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "path",
+        type=pathlib.Path,
+        help="Path to test file or directory (e.g., Lib/test/test_foo.py or Lib/test/test_foo/)",
+    )
+    parser.add_argument(
+        "--mark-failure",
+        action="store_true",
+        help="Also add @expectedFailure to failing tests (default: only remove unexpected successes)",
+    )
+    parser.add_argument(
+        "--skip-build",
+        action="store_true",
+        help="Skip cargo build, use pre-built binary",
+    )
+
+    args = parser.parse_args(argv)
+
+    try:
+        if args.path.is_dir():
+            num_added, num_removed, _ = auto_mark_directory(
+                args.path, mark_failure=args.mark_failure, skip_build=args.skip_build
+            )
+        else:
+            num_added, num_removed, _ = auto_mark_file(
+                args.path, mark_failure=args.mark_failure, skip_build=args.skip_build
+            )
+        if args.mark_failure:
+            print(f"Added expectedFailure to {num_added} tests")
+        print(f"Removed expectedFailure from {num_removed} tests")
+        return 0
+    except (FileNotFoundError, ValueError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/update_lib/copy_lib.py b/scripts/update_lib/copy_lib.py
new file mode 100644
index 00000000000..5af0cab85d9
--- /dev/null
+++ b/scripts/update_lib/copy_lib.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+"""
+Copy library files from CPython.
+
+Usage:
+    # Single file
+    python scripts/update_lib copy-lib cpython/Lib/dataclasses.py
+
+    # Directory
+    python scripts/update_lib copy-lib cpython/Lib/json
+"""
+
+import argparse
+import pathlib
+import shutil
+import sys
+
+
+def copy_lib(
+    src_path: pathlib.Path,
+    verbose: bool = True,
+) -> None:
+    """
+    Copy library file or directory from CPython.
+
+    Args:
+        src_path: Source path (e.g., cpython/Lib/dataclasses.py or cpython/Lib/json)
+        verbose: Print progress messages
+    """
+    from update_lib.path import parse_lib_path
+
+    lib_path = parse_lib_path(src_path)
+
+    # Remove existing file/directory
+    if lib_path.exists():
+        if lib_path.is_dir():
+            if verbose:
+                print(f"Removing directory: {lib_path}")
+            shutil.rmtree(lib_path)
+        else:
+            if verbose:
+                print(f"Removing file: {lib_path}")
+            lib_path.unlink()
+
+    # Copy
+    if src_path.is_dir():
+        if verbose:
+            print(f"Copying directory: {src_path} -> {lib_path}")
+        shutil.copytree(src_path, lib_path)
+    else:
+        if verbose:
+            print(f"Copying file: {src_path} -> {lib_path}")
+        lib_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(src_path, lib_path)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "path",
+        type=pathlib.Path,
+        help="Source path containing /Lib/ (e.g., cpython/Lib/dataclasses.py)",
+    )
+
+    args = parser.parse_args(argv)
+
+    try:
+        copy_lib(args.path)
+        return 0
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/update_lib/migrate.py b/scripts/update_lib/migrate.py
new file mode 100644
index 00000000000..d0f049ec117
--- /dev/null
+++ b/scripts/update_lib/migrate.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+"""
+Migrate test file(s) from CPython, preserving RustPython markers.
+
+Usage:
+    python scripts/update_lib migrate cpython/Lib/test/test_foo.py
+
+This will:
+    1. Extract patches from Lib/test/test_foo.py (if exists)
+    2. Apply them to cpython/Lib/test/test_foo.py
+    3. Write result to Lib/test/test_foo.py
+"""
+
+import argparse
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from update_lib.path import parse_lib_path
+
+
+def patch_single_content(
+    src_path: pathlib.Path,
+    lib_path: pathlib.Path,
+) -> str:
+    """
+    Patch content without writing to disk.
+
+    Args:
+        src_path: Source file path (e.g., cpython/Lib/test/foo.py)
+        lib_path: Lib path to extract patches from (e.g., Lib/test/foo.py)
+
+    Returns:
+        The patched content.
+    """
+    from update_lib import apply_patches, extract_patches
+
+    # Extract patches from existing file (if exists)
+    if lib_path.exists():
+        patches = extract_patches(lib_path.read_text())
+    else:
+        patches = {}
+
+    # Apply patches to source content
+    src_content = src_path.read_text()
+    return apply_patches(src_content, patches)
+
+
+def patch_file(
+    src_path: pathlib.Path,
+    lib_path: pathlib.Path | None = None,
+    verbose: bool = True,
+) -> None:
+    """
+    Patch a single file from source to lib.
+
+    Args:
+        src_path: Source file path (e.g., cpython/Lib/test/foo.py)
+        lib_path: Target lib path. If None, derived from src_path.
+        verbose: Print progress messages
+    """
+    if lib_path is None:
+        lib_path = parse_lib_path(src_path)
+
+    if lib_path.exists():
+        if verbose:
+            print(f"Patching: {src_path} -> {lib_path}")
+        content = patch_single_content(src_path, lib_path)
+    else:
+        if verbose:
+            print(f"Copying: {src_path} -> {lib_path}")
+        content = src_path.read_text()
+
+    lib_path.parent.mkdir(parents=True, exist_ok=True)
+    lib_path.write_text(content)
+
+
+def patch_directory(
+    src_dir: pathlib.Path,
+    lib_dir: pathlib.Path | None = None,
+    verbose: bool = True,
+) -> None:
+    """
+    Patch all files in a directory from source to lib.
+
+    Args:
+        src_dir: Source directory path (e.g., cpython/Lib/test/test_foo/)
+        lib_dir: Target lib directory. If None, derived from src_dir.
+        verbose: Print progress messages
+    """
+    if lib_dir is None:
+        lib_dir = parse_lib_path(src_dir)
+
+    src_files = sorted(src_dir.glob("**/*.py"))
+
+    for src_file in src_files:
+        rel_path = src_file.relative_to(src_dir)
+        lib_file = lib_dir / rel_path
+
+        if lib_file.exists():
+            if verbose:
+                print(f"Patching: {src_file} -> {lib_file}")
+            content = patch_single_content(src_file, lib_file)
+        else:
+            if verbose:
+                print(f"Copying: {src_file} -> {lib_file}")
+            content = src_file.read_text()
+
+        lib_file.parent.mkdir(parents=True, exist_ok=True)
+        lib_file.write_text(content)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "path",
+        type=pathlib.Path,
+        help="Source path containing /Lib/ (file or directory)",
+    )
+
+    args = parser.parse_args(argv)
+
+    try:
+        if args.path.is_dir():
+            patch_directory(args.path)
+        else:
+            patch_file(args.path)
+        return 0
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/lib_updater.py b/scripts/update_lib/patch_spec.py
old mode 100755
new mode 100644
similarity index 60%
rename from scripts/lib_updater.py
rename to scripts/update_lib/patch_spec.py
index 712ea7bc838..1f88c06c1f4
--- a/scripts/lib_updater.py
+++ b/scripts/update_lib/patch_spec.py
@@ -1,47 +1,14 @@
-#!/usr/bin/env python
-__doc__ = """
-This tool helps with updating test files from CPython.
+"""
+Low-level module for converting between test files and JSON patches.
 
-Quick Upgrade
--------------
-    ./{fname} --quick-upgrade cpython/Lib/test/test_threading.py
-    ./{fname} --quick-upgrade ../somewhere/Lib/threading.py
+This module handles:
+- Extracting patches from test files (file -> JSON)
+- Applying patches to test files (JSON -> file)
+"""
 
-    Any path containing `/Lib/` will auto-detect the target:
-    -> Extracts patches from Lib/... (auto-detected from path)
-    -> Applies them to the source file
-    -> Writes result to Lib/...
-
-Examples
---------
-To move the patches found in `Lib/test/foo.py` to `~/cpython/Lib/test/foo.py` then write the contents back to `Lib/test/foo.py`
-
->>> ./{fname} --from Lib/test/foo.py --to ~/cpython/Lib/test/foo.py -o Lib/test/foo.py
-
-You can run the same command without `-o` to override the `--from` path:
-
->>> ./{fname} --from Lib/test/foo.py --to ~/cpython/Lib/test/foo.py
-
-To get a baseline of patches, you can alter the patches file with your favorite tool/script/etc and then reapply it with:
-
->>> ./{fname} --from Lib/test/foo.py --show-patches -o my_patches.json
-
-(By default the output is set to print to stdout).
-
-When you want to apply your own patches:
-
->>> ./{fname} -p my_patches.json --to Lib/test/foo.py
-""".format(fname=__import__("os").path.basename(__file__))
-
-
-import argparse
 import ast
 import collections
 import enum
-import json
-import pathlib
-import re
-import sys
 import textwrap
 import typing
 
@@ -115,13 +82,43 @@ def as_ast_node(self) -> ast.Attribute | ast.Call:
 
     def as_decorator(self) -> str:
         unparsed = ast.unparse(self.as_ast_node())
+        # ast.unparse uses single quotes; convert to double quotes for ruff compatibility
+        unparsed = _single_to_double_quotes(unparsed)
 
         if not self.ut_method.has_args():
-            unparsed = f"{unparsed} # {self._reason}"
+            unparsed = f"{unparsed}  # {self._reason}"
 
         return f"@{unparsed}"
 
 
+def _single_to_double_quotes(s: str) -> str:
+    """Convert single-quoted strings to double-quoted strings.
+
+    Falls back to original if conversion breaks the AST equivalence.
+    """
+    import re
+
+    def replace_string(match: re.Match) -> str:
+        content = match.group(1)
+        # Unescape single quotes and escape double quotes
+        content = content.replace("\\'", "'").replace('"', '\\"')
+        return f'"{content}"'
+
+    # Match single-quoted strings (handles escaped single quotes inside)
+    converted = re.sub(r"'((?:[^'\\]|\\.)*)'", replace_string, s)
+
+    # Verify: parse converted and unparse should equal original
+    try:
+        converted_ast = ast.parse(converted, mode="eval")
+        if ast.unparse(converted_ast) == s:
+            return converted
+    except SyntaxError:
+        pass
+
+    # Fall back to original if conversion failed
+    return s
+
+
 class PatchEntry(typing.NamedTuple):
     """
     Stores patch metadata.
@@ -141,9 +138,12 @@ class PatchEntry(typing.NamedTuple):
     spec: PatchSpec
 
     @classmethod
-    def iter_patch_entires(
+    def iter_patch_entries(
         cls, tree: ast.Module, lines: list[str]
     ) -> "Iterator[typing.Self]":
+        import re
+        import sys
+
         for cls_node, fn_node in iter_tests(tree):
             parent_class = cls_node.name
             for dec_node in fn_node.decorator_list:
@@ -224,7 +224,7 @@ def iter_tests(
 def iter_patches(contents: str) -> "Iterator[PatchEntry]":
     lines = contents.splitlines()
     tree = ast.parse(contents)
-    yield from PatchEntry.iter_patch_entires(tree, lines)
+    yield from PatchEntry.iter_patch_entries(tree, lines)
 
 
 def build_patch_dict(it: "Iterator[PatchEntry]") -> Patches:
@@ -235,7 +235,16 @@ def build_patch_dict(it: "Iterator[PatchEntry]") -> Patches:
     return {k: dict(v) for k, v in patches.items()}
 
 
-def iter_patch_lines(tree: ast.Module, patches: Patches) -> "Iterator[tuple[int, str]]":
+def extract_patches(contents: str) -> Patches:
+    """Extract patches from file contents and return as dict."""
+    return build_patch_dict(iter_patches(contents))
+
+
+def _iter_patch_lines(
+    tree: ast.Module, patches: Patches
+) -> "Iterator[tuple[int, str]]":
+    import sys
+
     # Build cache of all classes (for Phase 2 to find classes without methods)
     cache = {}
     for node in tree.body:
@@ -256,7 +265,7 @@ def iter_patch_lines(tree: ast.Module, patches: Patches) -> "Iterator[tuple[int,
         patch_lines = "\n".join(spec.as_decorator() for spec in specs)
         yield (lineno - 1, textwrap.indent(patch_lines, indent))
 
-    # Phase 2: Iterate and mark inhereted tests
+    # Phase 2: Iterate and mark inherited tests
     for cls_name, tests in patches.items():
         lineno = cache.get(cls_name)
         if not lineno:
@@ -273,7 +282,7 @@ def {test_name}(self):
             yield (lineno, textwrap.indent(patch_lines, DEFAULT_INDENT))
 
 
-def has_unittest_import(tree: ast.Module) -> bool:
+def _has_unittest_import(tree: ast.Module) -> bool:
     """Check if 'import unittest' is already present in the file."""
     for node in tree.body:
         if isinstance(node, ast.Import):
@@ -283,7 +292,7 @@ def has_unittest_import(tree: ast.Module) -> bool:
     return False
 
 
-def find_import_insert_line(tree: ast.Module) -> int:
+def _find_import_insert_line(tree: ast.Module) -> int:
     """Find the line number after the last import statement."""
     last_import_line = None
     for node in tree.body:
@@ -294,22 +303,23 @@ def find_import_insert_line(tree: ast.Module) -> int:
 
 
 def apply_patches(contents: str, patches: Patches) -> str:
+    """Apply patches to file contents and return modified contents."""
     tree = ast.parse(contents)
     lines = contents.splitlines()
 
-    modifications = list(iter_patch_lines(tree, patches))
+    modifications = list(_iter_patch_lines(tree, patches))
 
     # If we have modifications and unittest is not imported, add it
-    if modifications and not has_unittest_import(tree):
-        import_line = find_import_insert_line(tree)
+    if modifications and not _has_unittest_import(tree):
+        import_line = _find_import_insert_line(tree)
         modifications.append(
             (
                 import_line,
-                "\nimport unittest # XXX: RUSTPYTHON; importing to be able to skip tests",
+                "\nimport unittest  # XXX: RUSTPYTHON; importing to be able to skip tests",
             )
         )
 
-    # Going in reverse to not distrupt the line offset
+    # Going in reverse to not disrupt the line offset
     for lineno, patch in sorted(modifications, reverse=True):
         lines.insert(lineno, patch)
 
@@ -317,111 +327,26 @@ def apply_patches(contents: str, patches: Patches) -> str:
     return f"{joined}\n"
 
 
-def write_output(data: str, dest: str) -> None:
-    if dest == "-":
-        print(data, end="")
-        return
-
-    with open(dest, "w") as fd:
-        fd.write(data)
-
-
-def build_argparse() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-
-    patches_group = parser.add_mutually_exclusive_group(required=True)
-    patches_group.add_argument(
-        "--quick-upgrade",
-        help="Quick upgrade: path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
-        type=pathlib.Path,
-        metavar="PATH",
-    )
-    patches_group.add_argument(
-        "-p",
-        "--patches",
-        help="File path to file containing patches in a JSON format",
-        type=pathlib.Path,
-    )
-    patches_group.add_argument(
-        "--from",
-        help="File to gather patches from",
-        dest="gather_from",
-        type=pathlib.Path,
-    )
-
-    group = parser.add_mutually_exclusive_group(required=False)
-    group.add_argument(
-        "--to",
-        help="File to apply patches to",
-        type=pathlib.Path,
-    )
-    group.add_argument(
-        "--show-patches", action="store_true", help="Show the patches and exit"
-    )
-
-    parser.add_argument(
-        "-o", "--output", default="-", help="Output file. Set to '-' for stdout"
-    )
-
-    return parser
-
-
-if __name__ == "__main__":
-    parser = build_argparse()
-    args = parser.parse_args()
-
-    # Quick upgrade: auto-fill --from, --to, -o from path
-    if args.quick_upgrade is not None:
-        # Normalize path separators to forward slashes for cross-platform support
-        path_str = str(args.quick_upgrade).replace("\\", "/")
-        lib_marker = "/Lib/"
-
-        if lib_marker not in path_str:
-            parser.error(
-                f"--quick-upgrade path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_upgrade})"
-            )
-
-        idx = path_str.index(lib_marker)
-        lib_path = pathlib.Path(path_str[idx + 1 :])
-
-        args.gather_from = lib_path
-        args.to = args.quick_upgrade
-        if args.output == "-":
-            args.output = str(lib_path)
-
-    # Validate required arguments
-    if args.patches is None and args.gather_from is None:
-        parser.error("--from or --patches is required (or use --quick-upgrade)")
-    if args.to is None and not args.show_patches:
-        parser.error("--to or --show-patches is required")
-
-    if args.patches:
-        patches = {
-            cls_name: {
-                test_name: [
-                    PatchSpec(**spec)._replace(ut_method=UtMethod(spec["ut_method"]))
-                    for spec in specs
-                ]
-                for test_name, specs in tests.items()
-            }
-            for cls_name, tests in json.loads(args.patches.read_text()).items()
+def patches_to_json(patches: Patches) -> dict:
+    """Convert patches to JSON-serializable dict."""
+    return {
+        cls_name: {
+            test_name: [spec._asdict() for spec in specs]
+            for test_name, specs in tests.items()
         }
-    else:
-        patches = build_patch_dict(iter_patches(args.gather_from.read_text()))
-
-    if args.show_patches:
-        patches = {
-            cls_name: {
-                test_name: [spec._asdict() for spec in specs]
-                for test_name, specs in tests.items()
-            }
-            for cls_name, tests in patches.items()
+        for cls_name, tests in patches.items()
+    }
+
+
+def patches_from_json(data: dict) -> Patches:
+    """Convert JSON dict back to Patches."""
+    return {
+        cls_name: {
+            test_name: [
+                PatchSpec(**spec)._replace(ut_method=UtMethod(spec["ut_method"]))
+                for spec in specs
+            ]
+            for test_name, specs in tests.items()
         }
-        output = json.dumps(patches, indent=4) + "\n"
-        write_output(output, args.output)
-        sys.exit(0)
-
-    patched = apply_patches(args.to.read_text(), patches)
-    write_output(patched, args.output)
+        for cls_name, tests in data.items()
+    }
diff --git a/scripts/update_lib/patches.py b/scripts/update_lib/patches.py
new file mode 100644
index 00000000000..67ebf1822b7
--- /dev/null
+++ b/scripts/update_lib/patches.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python
+"""
+Patch management for test files.
+
+Usage:
+    # Extract patches from one file and apply to another
+    python scripts/update_lib patches --from Lib/test/foo.py --to cpython/Lib/test/foo.py
+
+    # Show patches as JSON
+    python scripts/update_lib patches --from Lib/test/foo.py --show-patches
+
+    # Apply patches from JSON file
+    python scripts/update_lib patches -p patches.json --to Lib/test/foo.py
+"""
+
+import argparse
+import json
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+
+def write_output(data: str, dest: str) -> None:
+    if dest == "-":
+        print(data, end="")
+        return
+
+    with open(dest, "w") as fd:
+        fd.write(data)
+
+
+def main(argv: list[str] | None = None) -> int:
+    from update_lib import (
+        apply_patches,
+        extract_patches,
+        patches_from_json,
+        patches_to_json,
+    )
+
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    patches_group = parser.add_mutually_exclusive_group(required=True)
+    patches_group.add_argument(
+        "-p",
+        "--patches",
+        type=pathlib.Path,
+        help="File path to file containing patches in a JSON format",
+    )
+    patches_group.add_argument(
+        "--from",
+        dest="gather_from",
+        type=pathlib.Path,
+        help="File to gather patches from",
+    )
+
+    group = parser.add_mutually_exclusive_group(required=False)
+    group.add_argument(
+        "--to",
+        type=pathlib.Path,
+        help="File to apply patches to",
+    )
+    group.add_argument(
+        "--show-patches",
+        action="store_true",
+        help="Show the patches and exit",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="-",
+        help="Output file. Set to '-' for stdout",
+    )
+
+    args = parser.parse_args(argv)
+
+    # Validate required arguments
+    if args.to is None and not args.show_patches:
+        parser.error("--to or --show-patches is required")
+
+    try:
+        if args.patches:
+            patches = patches_from_json(json.loads(args.patches.read_text()))
+        else:
+            patches = extract_patches(args.gather_from.read_text())
+
+        if args.show_patches:
+            output = json.dumps(patches_to_json(patches), indent=4) + "\n"
+            write_output(output, args.output)
+            return 0
+
+        patched = apply_patches(args.to.read_text(), patches)
+        write_output(patched, args.output)
+        return 0
+
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/update_lib/path.py b/scripts/update_lib/path.py
new file mode 100644
index 00000000000..7a3535fd2ae
--- /dev/null
+++ b/scripts/update_lib/path.py
@@ -0,0 +1,99 @@
+"""
+Path utilities for update_lib.
+
+This module provides functions for:
+- Parsing and converting library paths
+- Detecting test paths vs library paths
+- Extracting test module names from paths
+"""
+
+import pathlib
+
+
+def parse_lib_path(path: pathlib.Path | str) -> pathlib.Path:
+    """
+    Extract the Lib/... portion from a path containing /Lib/.
+
+    Example:
+        parse_lib_path("cpython/Lib/test/foo.py") -> Path("Lib/test/foo.py")
+    """
+    path_str = str(path).replace("\\", "/")
+    lib_marker = "/Lib/"
+
+    if lib_marker not in path_str:
+        raise ValueError(f"Path must contain '/Lib/' or '\\Lib\\' (got: {path})")
+
+    idx = path_str.index(lib_marker)
+    return pathlib.Path(path_str[idx + 1 :])
+
+
+def is_lib_path(path: pathlib.Path) -> bool:
+    """Check if path starts with Lib/"""
+    path_str = str(path).replace("\\", "/")
+    return path_str.startswith("Lib/") or path_str.startswith("./Lib/")
+
+
+def is_test_path(path: pathlib.Path) -> bool:
+    """Check if path is a test path (contains /Lib/test/ or starts with Lib/test/)"""
+    path_str = str(path).replace("\\", "/")
+    return "/Lib/test/" in path_str or path_str.startswith("Lib/test/")
+
+
+def lib_to_test_path(src_path: pathlib.Path) -> pathlib.Path:
+    """
+    Convert library path to test path.
+
+    Examples:
+        cpython/Lib/dataclasses.py -> cpython/Lib/test/test_dataclasses/ (if dir exists)
+        cpython/Lib/typing.py -> cpython/Lib/test/test_typing.py (if file exists)
+        cpython/Lib/json/ -> cpython/Lib/test/test_json/
+        Lib/dataclasses.py -> Lib/test/test_dataclasses/
+    """
+    path_str = str(src_path).replace("\\", "/")
+    lib_marker = "/Lib/"
+
+    if lib_marker in path_str:
+        lib_path = parse_lib_path(src_path)
+        lib_name = lib_path.stem if lib_path.suffix == ".py" else lib_path.name
+        prefix = path_str[: path_str.index(lib_marker)]
+        # Try directory first, then file
+        dir_path = pathlib.Path(f"{prefix}/Lib/test/test_{lib_name}/")
+        if dir_path.exists():
+            return dir_path
+        file_path = pathlib.Path(f"{prefix}/Lib/test/test_{lib_name}.py")
+        if file_path.exists():
+            return file_path
+        # Default to directory (caller will handle non-existence)
+        return dir_path
+    else:
+        # Path starts with Lib/ - extract name directly
+        lib_name = src_path.stem if src_path.suffix == ".py" else src_path.name
+        # Try directory first, then file
+        dir_path = pathlib.Path(f"Lib/test/test_{lib_name}/")
+        if dir_path.exists():
+            return dir_path
+        file_path = pathlib.Path(f"Lib/test/test_{lib_name}.py")
+        if file_path.exists():
+            return file_path
+        return dir_path
+
+
+def get_test_files(path: pathlib.Path) -> list[pathlib.Path]:
+    """Get all .py test files in a path (file or directory)."""
+    if path.is_file():
+        return [path]
+    return sorted(path.glob("**/*.py"))
+
+
+def test_name_from_path(test_path: pathlib.Path) -> str:
+    """
+    Extract test module name from a test file path.
+
+    Examples:
+        Lib/test/test_foo.py -> test_foo
+        Lib/test/test_ctypes/test_bar.py -> test_ctypes.test_bar
+    """
+    test_path = pathlib.Path(test_path)
+    if test_path.parent.name.startswith("test_"):
+        return f"{test_path.parent.name}.{test_path.stem}"
+    return test_path.stem
diff --git a/scripts/update_lib/quick.py b/scripts/update_lib/quick.py
new file mode 100644
index 00000000000..6221fcbc6b2
--- /dev/null
+++ b/scripts/update_lib/quick.py
@@ -0,0 +1,365 @@
+#!/usr/bin/env python
+"""
+Quick update for test files from CPython.
+
+Usage:
+    # Library + test: copy lib, then patch + auto-mark test + commit
+    python scripts/update_lib quick cpython/Lib/dataclasses.py
+
+    # Shortcut: just the module name
+    python scripts/update_lib quick dataclasses
+
+    # Test file: patch + auto-mark
+    python scripts/update_lib quick cpython/Lib/test/test_foo.py
+
+    # Test file: migrate only
+    python scripts/update_lib quick cpython/Lib/test/test_foo.py --no-auto-mark
+
+    # Test file: auto-mark only (Lib/ path implies --no-migrate)
+    python scripts/update_lib quick Lib/test/test_foo.py
+
+    # Directory: patch all + auto-mark all
+    python scripts/update_lib quick cpython/Lib/test/test_dataclasses/
+
+    # Skip git commit
+    python scripts/update_lib quick dataclasses --no-commit
+"""
+
+import argparse
+import pathlib
+import sys
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from update_lib.path import (
+    get_test_files,
+    is_lib_path,
+    is_test_path,
+    lib_to_test_path,
+    parse_lib_path,
+)
+
+
+def collect_original_methods(
+    lib_path: pathlib.Path,
+) -> set[tuple[str, str]] | dict[pathlib.Path, set[tuple[str, str]]] | None:
+    """
+    Collect original test methods from lib path before patching.
+
+    Returns:
+        - For file: set of (class_name, method_name) or None if file doesn't exist
+        - For directory: dict mapping file path to set of methods, or None if dir doesn't exist
+    """
+    from update_lib.auto_mark import extract_test_methods
+
+    if not lib_path.exists():
+        return None
+
+    if lib_path.is_file():
+        return extract_test_methods(lib_path.read_text())
+    else:
+        result = {}
+        for lib_file in get_test_files(lib_path):
+            result[lib_file.resolve()] = extract_test_methods(lib_file.read_text())
+        return result
+
+
+def quick(
+    src_path: pathlib.Path,
+    no_migrate: bool = False,
+    no_auto_mark: bool = False,
+    mark_failure: bool = False,
+    verbose: bool = True,
+    skip_build: bool = False,
+) -> None:
+    """
+    Process a file or directory: migrate + auto-mark.
+
+    Args:
+        src_path: Source path (file or directory)
+        no_migrate: Skip migration step
+        no_auto_mark: Skip auto-mark step
+        mark_failure: Add @expectedFailure to ALL failing tests
+        verbose: Print progress messages
+        skip_build: Skip cargo build, use pre-built binary
+    """
+    from update_lib.auto_mark import auto_mark_directory, auto_mark_file
+    from update_lib.migrate import patch_directory, patch_file
+
+    # Determine lib_path and whether to migrate
+    if is_lib_path(src_path):
+        no_migrate = True
+        lib_path = src_path
+    else:
+        lib_path = parse_lib_path(src_path)
+
+    is_dir = src_path.is_dir()
+
+    # Capture original test methods before migration (for smart auto-mark)
+    original_methods = collect_original_methods(lib_path)
+
+    # Step 1: Migrate
+    if not no_migrate:
+        if is_dir:
+            patch_directory(src_path, lib_path, verbose=verbose)
+        else:
+            patch_file(src_path, lib_path, verbose=verbose)
+
+    # Step 2: Auto-mark
+    if not no_auto_mark:
+        if not lib_path.exists():
+            raise FileNotFoundError(f"Path not found: {lib_path}")
+
+        if is_dir:
+            num_added, num_removed, _ = auto_mark_directory(
+                lib_path,
+                mark_failure=mark_failure,
+                verbose=verbose,
+                original_methods_per_file=original_methods,
+                skip_build=skip_build,
+            )
+        else:
+            num_added, num_removed, _ = auto_mark_file(
+                lib_path,
+                mark_failure=mark_failure,
+                verbose=verbose,
+                original_methods=original_methods,
+                skip_build=skip_build,
+            )
+
+        if verbose:
+            if num_added:
+                print(f"Added expectedFailure to {num_added} tests")
+            print(f"Removed expectedFailure from {num_removed} tests")
+
+
+def get_cpython_dir(src_path: pathlib.Path) -> pathlib.Path:
+    """Extract cpython directory from source path.
+
+    Example:
+        cpython/Lib/dataclasses.py -> cpython
+        /some/path/cpython/Lib/foo.py -> /some/path/cpython
+    """
+    path_str = str(src_path).replace("\\", "/")
+    lib_marker = "/Lib/"
+    if lib_marker in path_str:
+        idx = path_str.index(lib_marker)
+        return pathlib.Path(path_str[:idx])
+    # Shortcut case: assume "cpython"
+    return pathlib.Path("cpython")
+
+
+def get_cpython_version(cpython_dir: pathlib.Path) -> str:
+    """Get CPython version from git tag."""
+    import subprocess
+
+    result = subprocess.run(
+        ["git", "describe", "--tags"],
+        cwd=cpython_dir,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def git_commit(
+    name: str,
+    lib_path: pathlib.Path | None,
+    test_path: pathlib.Path | None,
+    cpython_dir: pathlib.Path,
+    verbose: bool = True,
+) -> bool:
+    """Commit changes with CPython author.
+
+    Args:
+        name: Module name (e.g., "dataclasses")
+        lib_path: Path to library file/directory (or None)
+        test_path: Path to test file/directory (or None)
+        cpython_dir: Path to cpython directory
+        verbose: Print progress messages
+
+    Returns:
+        True if commit was created, False otherwise
+    """
+    import subprocess
+
+    # Stage changes
+    paths_to_add = []
+    if lib_path and lib_path.exists():
+        paths_to_add.append(str(lib_path))
+    if test_path and test_path.exists():
+        paths_to_add.append(str(test_path))
+
+    if not paths_to_add:
+        return False
+
+    version = get_cpython_version(cpython_dir)
+    subprocess.run(["git", "add"] + paths_to_add, check=True)
+
+    # Check if there are staged changes
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--quiet"],
+        capture_output=True,
+    )
+    if result.returncode == 0:
+        if verbose:
+            print("No changes to commit")
+        return False
+
+    # Commit with CPython author
+    message = f"Update {name} from {version}"
+    subprocess.run(
+        [
+            "git",
+            "commit",
+            "--author",
+            "CPython Developers <>",
+            "-m",
+            message,
+        ],
+        check=True,
+    )
+    if verbose:
+        print(f"Committed: {message}")
+    return True
+
+
+def _expand_shortcut(path: pathlib.Path) -> pathlib.Path:
+    """Expand simple name to cpython/Lib path if it exists.
+
+    Examples:
+        dataclasses -> cpython/Lib/dataclasses.py (if exists)
+        json -> cpython/Lib/json/ (if exists)
+        test_types -> cpython/Lib/test/test_types.py (if exists)
+    """
+    # Only expand if it's a simple name (no path separators) and doesn't exist
+    if "/" in str(path) or path.exists():
+        return path
+
+    name = str(path)
+
+    # Test shortcut: test_foo -> cpython/Lib/test/test_foo
+    if name.startswith("test_"):
+        dir_path = pathlib.Path(f"cpython/Lib/test/{name}")
+        if dir_path.exists():
+            return dir_path
+        file_path = pathlib.Path(f"cpython/Lib/test/{name}.py")
+        if file_path.exists():
+            return file_path
+
+    # Library shortcut: foo -> cpython/Lib/foo
+    file_path = pathlib.Path(f"cpython/Lib/{name}.py")
+    if file_path.exists():
+        return file_path
+    dir_path = pathlib.Path(f"cpython/Lib/{name}")
+    if dir_path.exists():
+        return dir_path
+
+    # Return original (will likely fail later with a clear error)
+    return path
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "path",
+        type=pathlib.Path,
+        help="Source path (file or directory)",
+    )
+    parser.add_argument(
+        "--no-copy",
+        action="store_true",
+        help="Skip copy-lib step (implied if path is a test path)",
+    )
+    parser.add_argument(
+        "--no-migrate",
+        action="store_true",
+        help="Skip migration step (implied if path starts with Lib/)",
+    )
+    parser.add_argument(
+        "--no-auto-mark",
+        action="store_true",
+        help="Skip auto-mark step",
+    )
+    parser.add_argument(
+        "--mark-failure",
+        action="store_true",
+        help="Add @expectedFailure to failing tests",
+    )
+    parser.add_argument(
+        "--no-commit",
+        action="store_true",
+        help="Skip git commit step",
+    )
+    parser.add_argument(
+        "--skip-build",
+        action="store_true",
+        help="Skip cargo build, use pre-built binary",
+    )
+
+    args = parser.parse_args(argv)
+
+    try:
+        src_path = args.path
+        no_copy = args.no_copy
+
+        # Shortcut: expand simple name to cpython/Lib path
+        src_path = _expand_shortcut(src_path)
+        original_src = src_path  # Keep for commit
+
+        # Track library path for commit
+        lib_file_path = None
+        test_path = None
+
+        # If it's a library path (not test path), do copy_lib first
+        if not is_test_path(src_path):
+            # Get library destination path for commit
+            lib_file_path = parse_lib_path(src_path)
+
+            if not no_copy:
+                from update_lib.copy_lib import copy_lib
+
+                copy_lib(src_path)
+
+            # Convert to test path
+            src_path = lib_to_test_path(original_src)
+            if not src_path.exists():
+                print(f"Test path does not exist: {src_path}")
+                return 1
+
+        test_path = parse_lib_path(src_path) if not is_lib_path(src_path) else src_path
+
+        # Process the test path
+        quick(
+            src_path,
+            no_migrate=args.no_migrate,
+            no_auto_mark=args.no_auto_mark,
+            mark_failure=args.mark_failure,
+            skip_build=args.skip_build,
+        )
+
+        # Step 3: Git commit
+        if not args.no_commit:
+            # Extract module name from path
+            name = original_src.stem
+            if name == "__init__":
+                name = original_src.parent.name
+
+            cpython_dir = get_cpython_dir(original_src)
+            git_commit(name, lib_file_path, test_path, cpython_dir)
+
+        return 0
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/update_lib/tests/__init__.py b/scripts/update_lib/tests/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/scripts/update_lib/tests/test_auto_mark.py b/scripts/update_lib/tests/test_auto_mark.py
new file mode 100644
index 00000000000..ac357f5ea27
--- /dev/null
+++ b/scripts/update_lib/tests/test_auto_mark.py
@@ -0,0 +1,593 @@
+"""Tests for auto_mark.py - test result parsing and auto-marking."""
+
+import subprocess
+import unittest
+
+from update_lib.auto_mark import (
+    Test,
+    TestResult,
+    apply_test_changes,
+    collect_test_changes,
+    extract_test_methods,
+    parse_results,
+    path_to_test_parts,
+    remove_expected_failures,
+)
+from update_lib.patch_spec import COMMENT
+
+
+class TestParseResults(unittest.TestCase):
+    """Tests for parse_results function."""
+
+    def _make_result(self, stdout: str) -> subprocess.CompletedProcess:
+        """Create a mock CompletedProcess."""
+        return subprocess.CompletedProcess(
+            args=["test"],
+            returncode=0,
+            stdout=stdout,
+            stderr="",
+        )
+
+    def test_parse_failing_test(self):
+        """Test parsing a failing test."""
+        stdout = """
+Run 1 tests sequentially
+test_foo (test.test_example.TestClass) ... FAIL
+-----------
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 1)
+        self.assertEqual(result.tests[0].name, "test_foo")
+        self.assertEqual(result.tests[0].path, "test.test_example.TestClass")
+        self.assertEqual(result.tests[0].result, "fail")
+
+    def test_parse_error_test(self):
+        """Test parsing an error test."""
+        stdout = """
+Run 1 tests sequentially
+test_bar (test.test_example.TestClass) ... ERROR
+-----------
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 1)
+        self.assertEqual(result.tests[0].result, "error")
+
+    def test_parse_ok_test_ignored(self):
+        """Test that passing tests are ignored."""
+        stdout = """
+Run 1 tests sequentially
+test_foo (test.test_example.TestClass) ... ok
+-----------
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 0)
+
+    def test_parse_unexpected_success(self):
+        """Test parsing unexpected success."""
+        stdout = """
+Run 1 tests sequentially
+test_foo (test.test_example.TestClass) ... unexpected success
+-----------
+UNEXPECTED SUCCESS: test_foo (test.test_example.TestClass)
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.unexpected_successes), 1)
+        self.assertEqual(result.unexpected_successes[0].name, "test_foo")
+        self.assertEqual(
+            result.unexpected_successes[0].path, "test.test_example.TestClass"
+        )
+
+    def test_parse_tests_result(self):
+        """Test parsing tests result line."""
+        stdout = """
+== Tests result: FAILURE ==
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(result.tests_result, "FAILURE")
+
+    def test_parse_multiple_tests(self):
+        """Test parsing multiple test results."""
+        stdout = """
+Run 3 tests sequentially
+test_one (test.test_example.TestA) ... FAIL
+test_two (test.test_example.TestA) ... ok
+test_three (test.test_example.TestB) ... ERROR
+-----------
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 2)  # Only FAIL and ERROR
+
+    def test_parse_error_message(self):
+        """Test parsing error message from traceback."""
+        stdout = """
+Run 1 tests sequentially
+test_foo (test.test_example.TestClass) ... FAIL
+-----------
+======================================================================
+FAIL: test_foo (test.test_example.TestClass)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "test.py", line 10, in test_foo
+    self.assertEqual(1, 2)
+AssertionError: 1 != 2
+
+======================================================================
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 1)
+        self.assertEqual(result.tests[0].error_message, "AssertionError: 1 != 2")
+
+    def test_parse_multiple_error_messages(self):
+        """Test parsing multiple error messages."""
+        stdout = """
+Run 2 tests sequentially
+test_foo (test.test_example.TestClass) ... FAIL
+test_bar (test.test_example.TestClass) ... ERROR
+-----------
+======================================================================
+FAIL: test_foo (test.test_example.TestClass)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "test.py", line 10, in test_foo
+    self.assertEqual(1, 2)
+AssertionError: 1 != 2
+
+======================================================================
+ERROR: test_bar (test.test_example.TestClass)
+----------------------------------------------------------------------
+Traceback (most recent call last):
+  File "test.py", line 20, in test_bar
+    raise ValueError("oops")
+ValueError: oops
+
+======================================================================
+"""
+        result = parse_results(self._make_result(stdout))
+        self.assertEqual(len(result.tests), 2)
+        # Find tests by name
+        test_foo = next(t for t in result.tests if t.name == "test_foo")
+        test_bar = next(t for t in result.tests if t.name == "test_bar")
+        self.assertEqual(test_foo.error_message, "AssertionError: 1 != 2")
+        self.assertEqual(test_bar.error_message, "ValueError: oops")
+
+
+class TestPathToTestParts(unittest.TestCase):
+    """Tests for path_to_test_parts function."""
+
+    def test_simple_path(self):
+        """Test extracting parts from simple path."""
+        parts = path_to_test_parts("test.test_foo.TestClass.test_method")
+        self.assertEqual(parts, ["TestClass", "test_method"])
+
+    def test_nested_path(self):
+        """Test extracting parts from nested path."""
+        parts = path_to_test_parts("test.test_foo.test_bar.TestClass.test_method")
+        self.assertEqual(parts, ["TestClass", "test_method"])
+
+
+class TestCollectTestChanges(unittest.TestCase):
+    """Tests for collect_test_changes function."""
+
+    def test_collect_failing_tests(self):
+        """Test collecting failing tests."""
+        results = TestResult()
+        results.tests = [
+            Test(
+                name="test_foo",
+                path="test.test_example.TestClass.test_foo",
+                result="fail",
+            ),
+            Test(
+                name="test_bar",
+                path="test.test_example.TestClass.test_bar",
+                result="error",
+            ),
+        ]
+
+        failing, successes, error_messages = collect_test_changes(results)
+
+        self.assertEqual(len(failing), 2)
+        self.assertIn(("TestClass", "test_foo"), failing)
+        self.assertIn(("TestClass", "test_bar"), failing)
+        self.assertEqual(len(successes), 0)
+
+    def test_collect_unexpected_successes(self):
+        """Test collecting unexpected successes."""
+        results = TestResult()
+        results.unexpected_successes = [
+            Test(
+                name="test_foo",
+                path="test.test_example.TestClass.test_foo",
+                result="unexpected_success",
+            ),
+        ]
+
+        failing, successes, error_messages = collect_test_changes(results)
+
+        self.assertEqual(len(failing), 0)
+        self.assertEqual(len(successes), 1)
+        self.assertIn(("TestClass", "test_foo"), successes)
+
+    def test_collect_with_module_prefix(self):
+        """Test collecting with module prefix filter."""
+        results = TestResult()
+        results.tests = [
+            Test(name="test_foo", path="test_a.TestClass.test_foo", result="fail"),
+            Test(name="test_bar", path="test_b.TestClass.test_bar", result="fail"),
+        ]
+
+        failing, _, _ = collect_test_changes(results, module_prefix="test_a.")
+
+        self.assertEqual(len(failing), 1)
+        self.assertIn(("TestClass", "test_foo"), failing)
+
+    def test_collect_error_messages(self):
+        """Test collecting error messages."""
+        results = TestResult()
+        results.tests = [
+            Test(
+                name="test_foo",
+                path="test.test_example.TestClass.test_foo",
+                result="fail",
+                error_message="AssertionError: 1 != 2",
+            ),
+            Test(
+                name="test_bar",
+                path="test.test_example.TestClass.test_bar",
+                result="error",
+                error_message="",
+            ),
+        ]
+
+        failing, successes, error_messages = collect_test_changes(results)
+
+        self.assertEqual(len(error_messages), 1)
+        self.assertEqual(
+            error_messages[("TestClass", "test_foo")], "AssertionError: 1 != 2"
+        )
+
+    def test_collect_with_test_prefix_in_path(self):
+        """Test collecting with 'test.' prefix in path (like real test output)."""
+        results = TestResult()
+        results.tests = [
+            Test(
+                name="test_foo",
+                path="test.test_dataclasses.TestCase.test_foo",
+                result="fail",
+            ),
+            Test(
+                name="test_bar",
+                path="test.test_other.TestOther.test_bar",
+                result="fail",
+            ),
+        ]
+
+        # Filter with prefix that matches real test module path format
+        failing, _, _ = collect_test_changes(
+            results, module_prefix="test.test_dataclasses."
+        )
+
+        self.assertEqual(len(failing), 1)
+        self.assertIn(("TestCase", "test_foo"), failing)
+
+    def test_collect_init_module_matching(self):
+        """Test that __init__.py tests match without __init__ in path.
+
+        When test results come from a package's __init__.py, the path is like:
+        'test.test_dataclasses.TestCase.test_foo' (no __init__)
+
+        But module_prefix from test_name_from_path would be:
+        'test_dataclasses.__init__'
+
+        So we need to strip '.__init__' and add 'test.' prefix.
+        """
+        results = TestResult()
+        results.tests = [
+            Test(
+                name="test_field_repr",
+                path="test.test_dataclasses.TestCase.test_field_repr",
+                result="fail",
+            ),
+        ]
+
+        # Simulate the corrected prefix (after stripping .__init__ and adding test.)
+        module_prefix = "test_dataclasses.__init__"
+        if module_prefix.endswith(".__init__"):
+            module_prefix = module_prefix[:-9]
+        module_prefix = "test." + module_prefix + "."
+
+        failing, _, _ = collect_test_changes(results, module_prefix=module_prefix)
+
+        self.assertEqual(len(failing), 1)
+        self.assertIn(("TestCase", "test_field_repr"), failing)
+
+
+class TestExtractTestMethods(unittest.TestCase):
+    """Tests for extract_test_methods function."""
+
+    def test_extract_simple(self):
+        """Test extracting test methods from simple class."""
+        code = """
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+
+    def test_two(self):
+        pass
+"""
+        methods = extract_test_methods(code)
+        self.assertEqual(len(methods), 2)
+        self.assertIn(("TestFoo", "test_one"), methods)
+        self.assertIn(("TestFoo", "test_two"), methods)
+
+    def test_extract_multiple_classes(self):
+        """Test extracting from multiple classes."""
+        code = """
+class TestA(unittest.TestCase):
+    def test_a(self):
+        pass
+
+class TestB(unittest.TestCase):
+    def test_b(self):
+        pass
+"""
+        methods = extract_test_methods(code)
+        self.assertEqual(len(methods), 2)
+        self.assertIn(("TestA", "test_a"), methods)
+        self.assertIn(("TestB", "test_b"), methods)
+
+    def test_extract_syntax_error_returns_empty(self):
+        """Test that syntax error returns empty set."""
+        code = "this is not valid python {"
+        methods = extract_test_methods(code)
+        self.assertEqual(methods, set())
+
+
+class TestRemoveExpectedFailures(unittest.TestCase):
+    """Tests for remove_expected_failures function."""
+
+    def test_remove_simple(self):
+        """Test removing simple expectedFailure decorator."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        result = remove_expected_failures(code, {("TestFoo", "test_one")})
+        self.assertNotIn("@unittest.expectedFailure", result)
+        self.assertIn("def test_one(self):", result)
+
+    def test_remove_with_inline_comment(self):
+        """Test removing expectedFailure with inline comment."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_one(self):
+        pass
+"""
+        result = remove_expected_failures(code, {("TestFoo", "test_one")})
+        self.assertNotIn("@unittest.expectedFailure", result)
+
+    def test_remove_super_call_method(self):
+        """Test removing method that just calls super()."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        return super().test_one()
+"""
+        result = remove_expected_failures(code, {("TestFoo", "test_one")})
+        self.assertNotIn("def test_one", result)
+
+    def test_no_removal_without_comment(self):
+        """Test that decorators without COMMENT are not removed."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        result = remove_expected_failures(code, {("TestFoo", "test_one")})
+        # Should still have the decorator
+        self.assertIn("@unittest.expectedFailure", result)
+
+
+class TestApplyTestChanges(unittest.TestCase):
+    """Tests for apply_test_changes function."""
+
+    def test_apply_failing_tests(self):
+        """Test applying expectedFailure to failing tests."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        failing = {("TestFoo", "test_one")}
+        result = apply_test_changes(code, failing, set())
+
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertIn(COMMENT, result)
+
+    def test_apply_removes_unexpected_success(self):
+        """Test removing expectedFailure from unexpected success."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        successes = {("TestFoo", "test_one")}
+        result = apply_test_changes(code, set(), successes)
+
+        self.assertNotIn("@unittest.expectedFailure", result)
+        self.assertIn("def test_one(self):", result)
+
+    def test_apply_both_changes(self):
+        """Test applying both failing tests and removing unexpected successes."""
+        code = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_two(self):
+        pass
+"""
+        failing = {("TestFoo", "test_one")}
+        successes = {("TestFoo", "test_two")}
+        result = apply_test_changes(code, failing, successes)
+
+        # test_one should now have expectedFailure
+        self.assertIn("def test_one(self):", result)
+        # Only one expectedFailure decorator should remain (on test_one)
+        self.assertEqual(result.count("@unittest.expectedFailure"), 1)
+
+    def test_apply_with_error_message(self):
+        """Test applying expectedFailure with error message."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        failing = {("TestFoo", "test_one")}
+        error_messages = {("TestFoo", "test_one"): "AssertionError: 1 != 2"}
+        result = apply_test_changes(code, failing, set(), error_messages)
+
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertIn("AssertionError: 1 != 2", result)
+        self.assertIn(COMMENT, result)
+
+
+class TestSmartAutoMarkFiltering(unittest.TestCase):
+    """Tests for smart auto-mark filtering logic (regression exclusion).
+
+    The smart auto-mark feature:
+    - Marks NEW test failures (tests that didn't exist before)
+    - Does NOT mark regressions (existing tests that now fail)
+    """
+
+    def _filter_failures(
+        self,
+        all_failing_tests: set[tuple[str, str]],
+        original_methods: set[tuple[str, str]],
+        current_methods: set[tuple[str, str]],
+    ) -> tuple[set[tuple[str, str]], set[tuple[str, str]]]:
+        """Simulate the filtering logic from auto_mark_file().
+
+        Returns:
+            (failing_tests_to_mark, regressions)
+        """
+        new_methods = current_methods - original_methods
+        failing_tests = {t for t in all_failing_tests if t in new_methods}
+        regressions = all_failing_tests - failing_tests
+        return failing_tests, regressions
+
+    def test_new_tests_get_marked(self):
+        """Test that new failing tests are marked."""
+        original_methods = {("TestFoo", "test_existing")}
+        current_methods = {("TestFoo", "test_existing"), ("TestFoo", "test_new")}
+        all_failing = {("TestFoo", "test_new")}
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, {("TestFoo", "test_new")})
+        self.assertEqual(regressions, set())
+
+    def test_regressions_not_marked(self):
+        """Test that existing failing tests (regressions) are NOT marked."""
+        original_methods = {("TestFoo", "test_existing")}
+        current_methods = {("TestFoo", "test_existing")}
+        all_failing = {("TestFoo", "test_existing")}
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, set())
+        self.assertEqual(regressions, {("TestFoo", "test_existing")})
+
+    def test_mixed_new_and_regression(self):
+        """Test with both new failures and regressions."""
+        original_methods = {("TestFoo", "test_old1"), ("TestFoo", "test_old2")}
+        current_methods = {
+            ("TestFoo", "test_old1"),
+            ("TestFoo", "test_old2"),
+            ("TestFoo", "test_new1"),
+            ("TestFoo", "test_new2"),
+        }
+        # test_old1 regressed, test_new1 is a new failure
+        all_failing = {("TestFoo", "test_old1"), ("TestFoo", "test_new1")}
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, {("TestFoo", "test_new1")})
+        self.assertEqual(regressions, {("TestFoo", "test_old1")})
+
+    def test_multiple_classes(self):
+        """Test filtering across multiple classes."""
+        original_methods = {("TestA", "test_a"), ("TestB", "test_b")}
+        current_methods = {
+            ("TestA", "test_a"),
+            ("TestA", "test_new_a"),
+            ("TestB", "test_b"),
+            ("TestC", "test_c"),  # entirely new class
+        }
+        all_failing = {
+            ("TestA", "test_a"),  # regression
+            ("TestA", "test_new_a"),  # new
+            ("TestC", "test_c"),  # new (new class)
+        }
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, {("TestA", "test_new_a"), ("TestC", "test_c")})
+        self.assertEqual(regressions, {("TestA", "test_a")})
+
+    def test_all_new_tests(self):
+        """Test when all failing tests are new (no regressions)."""
+        original_methods = set()  # file was new
+        current_methods = {("TestFoo", "test_one"), ("TestFoo", "test_two")}
+        all_failing = {("TestFoo", "test_one"), ("TestFoo", "test_two")}
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, all_failing)
+        self.assertEqual(regressions, set())
+
+    def test_all_regressions(self):
+        """Test when all failing tests are regressions (no new tests)."""
+        original_methods = {("TestFoo", "test_one"), ("TestFoo", "test_two")}
+        current_methods = original_methods.copy()
+        all_failing = {("TestFoo", "test_one")}
+
+        to_mark, regressions = self._filter_failures(
+            all_failing, original_methods, current_methods
+        )
+
+        self.assertEqual(to_mark, set())
+        self.assertEqual(regressions, {("TestFoo", "test_one")})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/update_lib/tests/test_migrate.py b/scripts/update_lib/tests/test_migrate.py
new file mode 100644
index 00000000000..ff93052f6af
--- /dev/null
+++ b/scripts/update_lib/tests/test_migrate.py
@@ -0,0 +1,196 @@
+"""Tests for migrate.py - file migration operations."""
+
+import pathlib
+import tempfile
+import unittest
+
+from update_lib.migrate import (
+    patch_directory,
+    patch_file,
+    patch_single_content,
+)
+from update_lib.patch_spec import COMMENT
+
+
+class TestPatchSingleContent(unittest.TestCase):
+    """Tests for patch_single_content function."""
+
+    def test_patch_with_no_existing_file(self):
+        """Test patching when lib file doesn't exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source file
+            src_path = tmpdir / "src.py"
+            src_path.write_text("""import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+""")
+
+            # Non-existent lib path
+            lib_path = tmpdir / "lib.py"
+
+            result = patch_single_content(src_path, lib_path)
+
+            # Should return source content unchanged
+            self.assertIn("def test_one(self):", result)
+            self.assertNotIn(COMMENT, result)
+
+    def test_patch_with_existing_patches(self):
+        """Test patching preserves existing patches."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source file (new version)
+            src_path = tmpdir / "src.py"
+            src_path.write_text("""import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+
+    def test_two(self):
+        pass
+""")
+
+            # Create lib file with existing patch
+            lib_path = tmpdir / "lib.py"
+            lib_path.write_text(f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+""")
+
+            result = patch_single_content(src_path, lib_path)
+
+            # Should have patch on test_one
+            self.assertIn("@unittest.expectedFailure", result)
+            self.assertIn(COMMENT, result)
+            # Should have test_two from source
+            self.assertIn("def test_two(self):", result)
+
+
+class TestPatchFile(unittest.TestCase):
+    """Tests for patch_file function."""
+
+    def test_patch_file_creates_output(self):
+        """Test that patch_file writes output file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source file
+            src_path = tmpdir / "src.py"
+            src_path.write_text("""import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+""")
+
+            # Output path
+            lib_path = tmpdir / "Lib" / "test.py"
+
+            patch_file(src_path, lib_path, verbose=False)
+
+            # File should exist
+            self.assertTrue(lib_path.exists())
+            content = lib_path.read_text()
+            self.assertIn("def test_one(self):", content)
+
+    def test_patch_file_preserves_patches(self):
+        """Test that patch_file preserves existing patches."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source file
+            src_path = tmpdir / "src.py"
+            src_path.write_text("""import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+""")
+
+            # Create existing lib file with patch
+            lib_path = tmpdir / "lib.py"
+            lib_path.write_text(f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+""")
+
+            patch_file(src_path, lib_path, verbose=False)
+
+            content = lib_path.read_text()
+            self.assertIn("@unittest.expectedFailure", content)
+
+
+class TestPatchDirectory(unittest.TestCase):
+    """Tests for patch_directory function."""
+
+    def test_patch_directory_all_files(self):
+        """Test that patch_directory processes all .py files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source directory with files
+            src_dir = tmpdir / "src"
+            src_dir.mkdir()
+            (src_dir / "test_a.py").write_text("# test_a")
+            (src_dir / "test_b.py").write_text("# test_b")
+            (src_dir / "subdir").mkdir()
+            (src_dir / "subdir" / "test_c.py").write_text("# test_c")
+
+            # Output directory
+            lib_dir = tmpdir / "lib"
+
+            patch_directory(src_dir, lib_dir, verbose=False)
+
+            # All files should exist
+            self.assertTrue((lib_dir / "test_a.py").exists())
+            self.assertTrue((lib_dir / "test_b.py").exists())
+            self.assertTrue((lib_dir / "subdir" / "test_c.py").exists())
+
+    def test_patch_directory_preserves_patches(self):
+        """Test that patch_directory preserves patches in existing files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+
+            # Create source directory
+            src_dir = tmpdir / "src"
+            src_dir.mkdir()
+            (src_dir / "test_a.py").write_text("""import unittest
+
+class TestA(unittest.TestCase):
+    def test_one(self):
+        pass
+""")
+
+            # Create lib directory with patched file
+            lib_dir = tmpdir / "lib"
+            lib_dir.mkdir()
+            (lib_dir / "test_a.py").write_text(f"""import unittest
+
+class TestA(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+""")
+
+            patch_directory(src_dir, lib_dir, verbose=False)
+
+            content = (lib_dir / "test_a.py").read_text()
+            self.assertIn("@unittest.expectedFailure", content)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/update_lib/tests/test_patch_spec.py b/scripts/update_lib/tests/test_patch_spec.py
new file mode 100644
index 00000000000..ec52aa6d284
--- /dev/null
+++ b/scripts/update_lib/tests/test_patch_spec.py
@@ -0,0 +1,325 @@
+"""Tests for patch_spec.py - core patch extraction and application."""
+
+import ast
+import unittest
+
+from update_lib.patch_spec import (
+    COMMENT,
+    PatchSpec,
+    UtMethod,
+    apply_patches,
+    extract_patches,
+    iter_tests,
+)
+
+
+class TestIterTests(unittest.TestCase):
+    """Tests for iter_tests function."""
+
+    def test_iter_tests_simple(self):
+        """Test iterating over test methods in a class."""
+        code = """
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+
+    def test_two(self):
+        pass
+"""
+        tree = ast.parse(code)
+        results = list(iter_tests(tree))
+        self.assertEqual(len(results), 2)
+        self.assertEqual(results[0][0].name, "TestFoo")
+        self.assertEqual(results[0][1].name, "test_one")
+        self.assertEqual(results[1][1].name, "test_two")
+
+    def test_iter_tests_multiple_classes(self):
+        """Test iterating over multiple test classes."""
+        code = """
+class TestFoo(unittest.TestCase):
+    def test_foo(self):
+        pass
+
+class TestBar(unittest.TestCase):
+    def test_bar(self):
+        pass
+"""
+        tree = ast.parse(code)
+        results = list(iter_tests(tree))
+        self.assertEqual(len(results), 2)
+        self.assertEqual(results[0][0].name, "TestFoo")
+        self.assertEqual(results[1][0].name, "TestBar")
+
+    def test_iter_tests_async(self):
+        """Test iterating over async test methods."""
+        code = """
+class TestAsync(unittest.TestCase):
+    async def test_async(self):
+        pass
+"""
+        tree = ast.parse(code)
+        results = list(iter_tests(tree))
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0][1].name, "test_async")
+
+
+class TestExtractPatches(unittest.TestCase):
+    """Tests for extract_patches function."""
+
+    def test_extract_expected_failure(self):
+        """Test extracting @unittest.expectedFailure decorator."""
+        code = f"""
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        patches = extract_patches(code)
+        self.assertIn("TestFoo", patches)
+        self.assertIn("test_one", patches["TestFoo"])
+        specs = patches["TestFoo"]["test_one"]
+        self.assertEqual(len(specs), 1)
+        self.assertEqual(specs[0].ut_method, UtMethod.ExpectedFailure)
+
+    def test_extract_expected_failure_inline_comment(self):
+        """Test extracting expectedFailure with inline comment."""
+        code = f"""
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure  # {COMMENT}
+    def test_one(self):
+        pass
+"""
+        patches = extract_patches(code)
+        self.assertIn("TestFoo", patches)
+        self.assertIn("test_one", patches["TestFoo"])
+
+    def test_extract_skip_with_reason(self):
+        """Test extracting @unittest.skip with reason."""
+        code = f'''
+class TestFoo(unittest.TestCase):
+    @unittest.skip("{COMMENT}; not implemented")
+    def test_one(self):
+        pass
+'''
+        patches = extract_patches(code)
+        self.assertIn("TestFoo", patches)
+        specs = patches["TestFoo"]["test_one"]
+        self.assertEqual(specs[0].ut_method, UtMethod.Skip)
+        self.assertIn("not implemented", specs[0].reason)
+
+    def test_extract_skip_if(self):
+        """Test extracting @unittest.skipIf decorator."""
+        code = f'''
+class TestFoo(unittest.TestCase):
+    @unittest.skipIf(sys.platform == "win32", "{COMMENT}; windows issue")
+    def test_one(self):
+        pass
+'''
+        patches = extract_patches(code)
+        specs = patches["TestFoo"]["test_one"]
+        self.assertEqual(specs[0].ut_method, UtMethod.SkipIf)
+        # ast.unparse normalizes quotes to single quotes
+        self.assertIn("sys.platform", specs[0].cond)
+        self.assertIn("win32", specs[0].cond)
+
+    def test_no_patches_without_comment(self):
+        """Test that decorators without COMMENT are not extracted."""
+        code = """
+class TestFoo(unittest.TestCase):
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        patches = extract_patches(code)
+        self.assertEqual(patches, {})
+
+    def test_multiple_patches_same_method(self):
+        """Test extracting multiple decorators on same method."""
+        code = f'''
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    @unittest.skip("{COMMENT}; reason")
+    def test_one(self):
+        pass
+'''
+        patches = extract_patches(code)
+        specs = patches["TestFoo"]["test_one"]
+        self.assertEqual(len(specs), 2)
+
+
+class TestApplyPatches(unittest.TestCase):
+    """Tests for apply_patches function."""
+
+    def test_apply_expected_failure(self):
+        """Test applying @unittest.expectedFailure."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {"test_one": [PatchSpec(UtMethod.ExpectedFailure, None, "")]}
+        }
+        result = apply_patches(code, patches)
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertIn(COMMENT, result)
+
+    def test_apply_skip_with_reason(self):
+        """Test applying @unittest.skip with reason."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {"test_one": [PatchSpec(UtMethod.Skip, None, "not ready")]}
+        }
+        result = apply_patches(code, patches)
+        self.assertIn("@unittest.skip", result)
+        self.assertIn("not ready", result)
+
+    def test_apply_skip_if(self):
+        """Test applying @unittest.skipIf."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {
+                "test_one": [
+                    PatchSpec(UtMethod.SkipIf, "sys.platform == 'win32'", "windows")
+                ]
+            }
+        }
+        result = apply_patches(code, patches)
+        self.assertIn("@unittest.skipIf", result)
+        self.assertIn('sys.platform == "win32"', result)
+
+    def test_apply_preserves_existing_decorators(self):
+        """Test that existing decorators are preserved."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    @some_decorator
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {"test_one": [PatchSpec(UtMethod.ExpectedFailure, None, "")]}
+        }
+        result = apply_patches(code, patches)
+        self.assertIn("@some_decorator", result)
+        self.assertIn("@unittest.expectedFailure", result)
+
+    def test_apply_inherited_method(self):
+        """Test applying patch to inherited method (creates override)."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    pass
+"""
+        patches = {
+            "TestFoo": {
+                "test_inherited": [PatchSpec(UtMethod.ExpectedFailure, None, "")]
+            }
+        }
+        result = apply_patches(code, patches)
+        self.assertIn("def test_inherited(self):", result)
+        self.assertIn("return super().test_inherited()", result)
+
+    def test_apply_adds_unittest_import(self):
+        """Test that unittest import is added if missing."""
+        code = """import sys
+
+class TestFoo:
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {"test_one": [PatchSpec(UtMethod.ExpectedFailure, None, "")]}
+        }
+        result = apply_patches(code, patches)
+        # Should add unittest import after existing imports
+        self.assertIn("import unittest", result)
+
+    def test_apply_no_duplicate_import(self):
+        """Test that unittest import is not duplicated."""
+        code = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        patches = {
+            "TestFoo": {"test_one": [PatchSpec(UtMethod.ExpectedFailure, None, "")]}
+        }
+        result = apply_patches(code, patches)
+        # Count occurrences of 'import unittest'
+        count = result.count("import unittest")
+        self.assertEqual(count, 1)
+
+
+class TestPatchSpec(unittest.TestCase):
+    """Tests for PatchSpec class."""
+
+    def test_as_decorator_expected_failure(self):
+        """Test generating expectedFailure decorator string."""
+        spec = PatchSpec(UtMethod.ExpectedFailure, None, "reason")
+        decorator = spec.as_decorator()
+        self.assertIn("@unittest.expectedFailure", decorator)
+        self.assertIn(COMMENT, decorator)
+        self.assertIn("reason", decorator)
+
+    def test_as_decorator_skip(self):
+        """Test generating skip decorator string."""
+        spec = PatchSpec(UtMethod.Skip, None, "not ready")
+        decorator = spec.as_decorator()
+        self.assertIn("@unittest.skip", decorator)
+        self.assertIn("not ready", decorator)
+
+    def test_as_decorator_skip_if(self):
+        """Test generating skipIf decorator string."""
+        spec = PatchSpec(UtMethod.SkipIf, "condition", "reason")
+        decorator = spec.as_decorator()
+        self.assertIn("@unittest.skipIf", decorator)
+        self.assertIn("condition", decorator)
+
+
+class TestRoundTrip(unittest.TestCase):
+    """Tests for extract -> apply round trip."""
+
+    def test_round_trip_expected_failure(self):
+        """Test that extracted patches can be re-applied."""
+        original = f"""import unittest
+
+class TestFoo(unittest.TestCase):
+    # {COMMENT}
+    @unittest.expectedFailure
+    def test_one(self):
+        pass
+"""
+        # Extract patches
+        patches = extract_patches(original)
+
+        # Apply to clean code
+        clean = """import unittest
+
+class TestFoo(unittest.TestCase):
+    def test_one(self):
+        pass
+"""
+        result = apply_patches(clean, patches)
+
+        # Should have the decorator
+        self.assertIn("@unittest.expectedFailure", result)
+        self.assertIn(COMMENT, result)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/update_lib/tests/test_path.py b/scripts/update_lib/tests/test_path.py
new file mode 100644
index 00000000000..06d10e2f10b
--- /dev/null
+++ b/scripts/update_lib/tests/test_path.py
@@ -0,0 +1,201 @@
+"""Tests for path.py - path utilities."""
+
+import pathlib
+import tempfile
+import unittest
+
+from update_lib.path import (
+    get_test_files,
+    is_lib_path,
+    is_test_path,
+    lib_to_test_path,
+    parse_lib_path,
+    test_name_from_path,
+)
+
+
+class TestParseLibPath(unittest.TestCase):
+    """Tests for parse_lib_path function."""
+
+    def test_parse_cpython_path(self):
+        """Test parsing cpython/Lib/... path."""
+        result = parse_lib_path("cpython/Lib/test/test_foo.py")
+        self.assertEqual(result, pathlib.Path("Lib/test/test_foo.py"))
+
+    def test_parse_nested_path(self):
+        """Test parsing deeply nested path."""
+        result = parse_lib_path("/home/user/cpython/Lib/test/test_foo/test_bar.py")
+        self.assertEqual(result, pathlib.Path("Lib/test/test_foo/test_bar.py"))
+
+    def test_parse_windows_path(self):
+        """Test parsing Windows-style path."""
+        result = parse_lib_path("C:\\cpython\\Lib\\test\\test_foo.py")
+        self.assertEqual(result, pathlib.Path("Lib/test/test_foo.py"))
+
+    def test_parse_directory(self):
+        """Test parsing directory path."""
+        result = parse_lib_path("cpython/Lib/test/test_json/")
+        self.assertEqual(result, pathlib.Path("Lib/test/test_json/"))
+
+    def test_parse_no_lib_raises(self):
+        """Test that path without /Lib/ raises ValueError."""
+        with self.assertRaises(ValueError) as ctx:
+            parse_lib_path("some/random/path.py")
+        self.assertIn("/Lib/", str(ctx.exception))
+
+
+class TestIsLibPath(unittest.TestCase):
+    """Tests for is_lib_path function."""
+
+    def test_lib_path(self):
+        """Test detecting Lib/ path."""
+        self.assertTrue(is_lib_path(pathlib.Path("Lib/test/test_foo.py")))
+        self.assertTrue(is_lib_path(pathlib.Path("./Lib/test/test_foo.py")))
+
+    def test_cpython_path_not_lib(self):
+        """Test that cpython/Lib/ is not detected as lib path."""
+        self.assertFalse(is_lib_path(pathlib.Path("cpython/Lib/test/test_foo.py")))
+
+    def test_random_path_not_lib(self):
+        """Test that random path is not lib path."""
+        self.assertFalse(is_lib_path(pathlib.Path("some/other/path.py")))
+
+
+class TestIsTestPath(unittest.TestCase):
+    """Tests for is_test_path function."""
+
+    def test_cpython_test_path(self):
+        """Test detecting cpython test path."""
+        self.assertTrue(is_test_path(pathlib.Path("cpython/Lib/test/test_foo.py")))
+
+    def test_lib_test_path(self):
+        """Test detecting Lib/test path."""
+        self.assertTrue(is_test_path(pathlib.Path("Lib/test/test_foo.py")))
+
+    def test_library_path_not_test(self):
+        """Test that library path (not test) is not test path."""
+        self.assertFalse(is_test_path(pathlib.Path("cpython/Lib/dataclasses.py")))
+        self.assertFalse(is_test_path(pathlib.Path("Lib/dataclasses.py")))
+
+
+class TestLibToTestPath(unittest.TestCase):
+    """Tests for lib_to_test_path function."""
+
+    def test_prefers_directory_over_file(self):
+        """Test that directory is preferred when both exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            # Create structure: tmpdir/Lib/foo.py, tmpdir/Lib/test/test_foo/, tmpdir/Lib/test/test_foo.py
+            lib_dir = tmpdir / "Lib"
+            lib_dir.mkdir()
+            (lib_dir / "foo.py").write_text("# lib")
+            test_dir = lib_dir / "test"
+            test_dir.mkdir()
+            (test_dir / "test_foo").mkdir()
+            (test_dir / "test_foo.py").write_text("# test file")
+
+            result = lib_to_test_path(tmpdir / "Lib" / "foo.py")
+            # Should prefer directory
+            self.assertEqual(result, tmpdir / "Lib" / "test" / "test_foo/")
+
+    def test_falls_back_to_file(self):
+        """Test that file is used when directory doesn't exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            # Create structure: tmpdir/Lib/foo.py, tmpdir/Lib/test/test_foo.py (no directory)
+            lib_dir = tmpdir / "Lib"
+            lib_dir.mkdir()
+            (lib_dir / "foo.py").write_text("# lib")
+            test_dir = lib_dir / "test"
+            test_dir.mkdir()
+            (test_dir / "test_foo.py").write_text("# test file")
+
+            result = lib_to_test_path(tmpdir / "Lib" / "foo.py")
+            # Should fall back to file
+            self.assertEqual(result, tmpdir / "Lib" / "test" / "test_foo.py")
+
+    def test_defaults_to_directory_when_neither_exists(self):
+        """Test that directory path is returned when neither exists."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            lib_dir = tmpdir / "Lib"
+            lib_dir.mkdir()
+            (lib_dir / "foo.py").write_text("# lib")
+            test_dir = lib_dir / "test"
+            test_dir.mkdir()
+            # Neither test_foo/ nor test_foo.py exists
+
+            result = lib_to_test_path(tmpdir / "Lib" / "foo.py")
+            # Should default to directory
+            self.assertEqual(result, tmpdir / "Lib" / "test" / "test_foo/")
+
+    def test_lib_path_prefers_directory(self):
+        """Test Lib/ path prefers directory when it exists."""
+        # This test uses actual Lib/ paths, checking current behavior
+        # When neither exists, defaults to directory
+        result = lib_to_test_path(pathlib.Path("Lib/nonexistent_module.py"))
+        self.assertEqual(result, pathlib.Path("Lib/test/test_nonexistent_module/"))
+
+
+class TestGetTestFiles(unittest.TestCase):
+    """Tests for get_test_files function."""
+
+    def test_single_file(self):
+        """Test getting single file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            test_file = tmpdir / "test.py"
+            test_file.write_text("# test")
+
+            files = get_test_files(test_file)
+            self.assertEqual(len(files), 1)
+            self.assertEqual(files[0], test_file)
+
+    def test_directory(self):
+        """Test getting all .py files from directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            (tmpdir / "test_a.py").write_text("# a")
+            (tmpdir / "test_b.py").write_text("# b")
+            (tmpdir / "not_python.txt").write_text("# not python")
+
+            files = get_test_files(tmpdir)
+            self.assertEqual(len(files), 2)
+            names = [f.name for f in files]
+            self.assertIn("test_a.py", names)
+            self.assertIn("test_b.py", names)
+
+    def test_nested_directory(self):
+        """Test getting .py files from nested directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            (tmpdir / "test_a.py").write_text("# a")
+            subdir = tmpdir / "subdir"
+            subdir.mkdir()
+            (subdir / "test_b.py").write_text("# b")
+
+            files = get_test_files(tmpdir)
+            self.assertEqual(len(files), 2)
+
+
+class TestTestNameFromPath(unittest.TestCase):
+    """Tests for test_name_from_path function."""
+
+    def test_simple_test_file(self):
+        """Test extracting name from simple test file."""
+        path = pathlib.Path("Lib/test/test_foo.py")
+        self.assertEqual(test_name_from_path(path), "test_foo")
+
+    def test_nested_test_file(self):
+        """Test extracting name from nested test directory."""
+        path = pathlib.Path("Lib/test/test_ctypes/test_bar.py")
+        self.assertEqual(test_name_from_path(path), "test_ctypes.test_bar")
+
+    def test_test_directory(self):
+        """Test extracting name from test directory."""
+        path = pathlib.Path("Lib/test/test_json")
+        self.assertEqual(test_name_from_path(path), "test_json")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/scripts/update_lib/tests/test_quick.py b/scripts/update_lib/tests/test_quick.py
new file mode 100644
index 00000000000..43f829a9626
--- /dev/null
+++ b/scripts/update_lib/tests/test_quick.py
@@ -0,0 +1,180 @@
+"""Tests for quick.py - quick update functionality."""
+
+import pathlib
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from update_lib.path import lib_to_test_path
+from update_lib.quick import _expand_shortcut, collect_original_methods, get_cpython_dir, git_commit
+
+
+class TestGetCpythonDir(unittest.TestCase):
+    """Tests for get_cpython_dir function."""
+
+    def test_extract_from_full_path(self):
+        """Test extracting cpython dir from full path."""
+        path = pathlib.Path("cpython/Lib/dataclasses.py")
+        result = get_cpython_dir(path)
+        self.assertEqual(result, pathlib.Path("cpython"))
+
+    def test_extract_from_absolute_path(self):
+        """Test extracting cpython dir from absolute path."""
+        path = pathlib.Path("/some/path/cpython/Lib/test/test_foo.py")
+        result = get_cpython_dir(path)
+        self.assertEqual(result, pathlib.Path("/some/path/cpython"))
+
+    def test_shortcut_defaults_to_cpython(self):
+        """Test that shortcut (no /Lib/) defaults to 'cpython'."""
+        path = pathlib.Path("dataclasses")
+        result = get_cpython_dir(path)
+        self.assertEqual(result, pathlib.Path("cpython"))
+
+
+class TestExpandShortcut(unittest.TestCase):
+    """Tests for _expand_shortcut function."""
+
+    def test_expand_shortcut_to_test_path_integration(self):
+        """Test that expanded shortcut works with lib_to_test_path.
+
+        This tests the fix for the bug where args.path was used instead of
+        the expanded src_path when calling lib_to_test_path.
+        """
+        # Simulate the flow in main():
+        # 1. User provides "dataclasses"
+        # 2. _expand_shortcut converts to "cpython/Lib/dataclasses.py"
+        # 3. lib_to_test_path should receive the expanded path, not original
+
+        original_path = pathlib.Path("dataclasses")
+        expanded_path = _expand_shortcut(original_path)
+
+        # If cpython/Lib/dataclasses.py exists, it should be expanded
+        if expanded_path != original_path:
+            # The expanded path should work with lib_to_test_path
+            test_path = lib_to_test_path(expanded_path)
+            # Should return a valid test path, not raise an error
+            self.assertTrue(str(test_path).startswith("cpython/Lib/test/"))
+
+        # The original unexpanded path would fail or give wrong result
+        # This is what the bug was - using args.path instead of src_path
+
+    def test_expand_shortcut_file(self):
+        """Test expanding a simple name to file path."""
+        # This test checks the shortcut works when file exists
+        path = pathlib.Path("dataclasses")
+        result = _expand_shortcut(path)
+
+        expected_file = pathlib.Path("cpython/Lib/dataclasses.py")
+        expected_dir = pathlib.Path("cpython/Lib/dataclasses")
+
+        if expected_file.exists():
+            self.assertEqual(result, expected_file)
+        elif expected_dir.exists():
+            self.assertEqual(result, expected_dir)
+        else:
+            # If neither exists, should return original
+            self.assertEqual(result, path)
+
+    def test_expand_shortcut_already_full_path(self):
+        """Test that full paths are not modified."""
+        path = pathlib.Path("cpython/Lib/dataclasses.py")
+        result = _expand_shortcut(path)
+        self.assertEqual(result, path)
+
+    def test_expand_shortcut_nonexistent(self):
+        """Test that nonexistent names are returned as-is."""
+        path = pathlib.Path("nonexistent_module_xyz")
+        result = _expand_shortcut(path)
+        self.assertEqual(result, path)
+
+
+class TestCollectOriginalMethods(unittest.TestCase):
+    """Tests for collect_original_methods function."""
+
+    def test_collect_from_file(self):
+        """Test collecting methods from single file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            test_file = tmpdir / "test.py"
+            test_file.write_text("""
+class TestFoo:
+    def test_one(self):
+        pass
+
+    def test_two(self):
+        pass
+""")
+
+            methods = collect_original_methods(test_file)
+            self.assertIsInstance(methods, set)
+            self.assertEqual(len(methods), 2)
+            self.assertIn(("TestFoo", "test_one"), methods)
+            self.assertIn(("TestFoo", "test_two"), methods)
+
+    def test_collect_from_directory(self):
+        """Test collecting methods from directory."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = pathlib.Path(tmpdir)
+            (tmpdir / "test_a.py").write_text("""
+class TestA:
+    def test_a(self):
+        pass
+""")
+            (tmpdir / "test_b.py").write_text("""
+class TestB:
+    def test_b(self):
+        pass
+""")
+
+            methods = collect_original_methods(tmpdir)
+            self.assertIsInstance(methods, dict)
+            self.assertEqual(len(methods), 2)
+
+
+class TestGitCommit(unittest.TestCase):
+    """Tests for git_commit function."""
+
+    @patch("subprocess.run")
+    @patch("update_lib.quick.get_cpython_version")
+    def test_none_lib_path_not_added(self, mock_version, mock_run):
+        """Test that None lib_path doesn't add '.' to git."""
+        mock_version.return_value = "v3.14.0"
+        mock_run.return_value.returncode = 1  # Has changes
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = pathlib.Path(tmpdir) / "test.py"
+            test_file.write_text("# test")
+
+            git_commit("test", None, test_file, pathlib.Path("cpython"), verbose=False)
+
+            # Check git add was called with only test_file, not "."
+            add_call = mock_run.call_args_list[0]
+            self.assertIn(str(test_file), add_call[0][0])
+            self.assertNotIn(".", add_call[0][0][2:])  # Skip "git" and "add"
+
+    @patch("subprocess.run")
+    @patch("update_lib.quick.get_cpython_version")
+    def test_none_test_path_not_added(self, mock_version, mock_run):
+        """Test that None test_path doesn't add '.' to git."""
+        mock_version.return_value = "v3.14.0"
+        mock_run.return_value.returncode = 1
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            lib_file = pathlib.Path(tmpdir) / "lib.py"
+            lib_file.write_text("# lib")
+
+            git_commit("lib", lib_file, None, pathlib.Path("cpython"), verbose=False)
+
+            add_call = mock_run.call_args_list[0]
+            self.assertIn(str(lib_file), add_call[0][0])
+            self.assertNotIn(".", add_call[0][0][2:])
+
+    def test_both_none_returns_false(self):
+        """Test that both paths None returns False without git operations."""
+        # No mocking needed - should return early before any subprocess calls
+        result = git_commit("test", None, None, pathlib.Path("cpython"), verbose=False)
+        self.assertFalse(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

From fe6a60ade77a335adec3c90b371767bd4e3b3261 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 19 Jan 2026 21:45:34 +0900
Subject: [PATCH 400/418] Fix error lines extraction

---
 scripts/update_lib/auto_mark.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/update_lib/auto_mark.py b/scripts/update_lib/auto_mark.py
index a716acea5ee..2ff074c0c41 100644
--- a/scripts/update_lib/auto_mark.py
+++ b/scripts/update_lib/auto_mark.py
@@ -170,7 +170,7 @@ def _parse_error_details(test_results: TestResult, lines: list[str]) -> None:
                     # Collect lines until the next separator or end
                     while i < len(lines):
                         current = lines[i]
-                        if current.startswith("====="):
+                        if current.startswith("=====") or current.startswith("-----"):
                             break
                         error_lines.append(current)
                         i += 1

From 876d3f5e80f213bd8b6f3ae406fac9070ea4d46f Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Mon, 19 Jan 2026 21:50:25 +0900
Subject: [PATCH 401/418] Correct testcase

---
 scripts/update_lib/tests/test_auto_mark.py | 32 +++++++++++-----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/scripts/update_lib/tests/test_auto_mark.py b/scripts/update_lib/tests/test_auto_mark.py
index ac357f5ea27..e155b40addd 100644
--- a/scripts/update_lib/tests/test_auto_mark.py
+++ b/scripts/update_lib/tests/test_auto_mark.py
@@ -32,20 +32,20 @@ def test_parse_failing_test(self):
         """Test parsing a failing test."""
         stdout = """
 Run 1 tests sequentially
-test_foo (test.test_example.TestClass) ... FAIL
+test_foo (test.test_example.TestClass.test_foo) ... FAIL
 -----------
 """
         result = parse_results(self._make_result(stdout))
         self.assertEqual(len(result.tests), 1)
         self.assertEqual(result.tests[0].name, "test_foo")
-        self.assertEqual(result.tests[0].path, "test.test_example.TestClass")
+        self.assertEqual(result.tests[0].path, "test.test_example.TestClass.test_foo")
         self.assertEqual(result.tests[0].result, "fail")
 
     def test_parse_error_test(self):
         """Test parsing an error test."""
         stdout = """
 Run 1 tests sequentially
-test_bar (test.test_example.TestClass) ... ERROR
+test_bar (test.test_example.TestClass.test_bar) ... ERROR
 -----------
 """
         result = parse_results(self._make_result(stdout))
@@ -56,7 +56,7 @@ def test_parse_ok_test_ignored(self):
         """Test that passing tests are ignored."""
         stdout = """
 Run 1 tests sequentially
-test_foo (test.test_example.TestClass) ... ok
+test_foo (test.test_example.TestClass.test_foo) ... ok
 -----------
 """
         result = parse_results(self._make_result(stdout))
@@ -66,15 +66,15 @@ def test_parse_unexpected_success(self):
         """Test parsing unexpected success."""
         stdout = """
 Run 1 tests sequentially
-test_foo (test.test_example.TestClass) ... unexpected success
+test_foo (test.test_example.TestClass.test_foo) ... unexpected success
 -----------
-UNEXPECTED SUCCESS: test_foo (test.test_example.TestClass)
+UNEXPECTED SUCCESS: test_foo (test.test_example.TestClass.test_foo)
 """
         result = parse_results(self._make_result(stdout))
         self.assertEqual(len(result.unexpected_successes), 1)
         self.assertEqual(result.unexpected_successes[0].name, "test_foo")
         self.assertEqual(
-            result.unexpected_successes[0].path, "test.test_example.TestClass"
+            result.unexpected_successes[0].path, "test.test_example.TestClass.test_foo"
         )
 
     def test_parse_tests_result(self):
@@ -89,9 +89,9 @@ def test_parse_multiple_tests(self):
         """Test parsing multiple test results."""
         stdout = """
 Run 3 tests sequentially
-test_one (test.test_example.TestA) ... FAIL
-test_two (test.test_example.TestA) ... ok
-test_three (test.test_example.TestB) ... ERROR
+test_one (test.test_example.TestA.test_one) ... FAIL
+test_two (test.test_example.TestA.test_two) ... ok
+test_three (test.test_example.TestB.test_three) ... ERROR
 -----------
 """
         result = parse_results(self._make_result(stdout))
@@ -101,10 +101,10 @@ def test_parse_error_message(self):
         """Test parsing error message from traceback."""
         stdout = """
 Run 1 tests sequentially
-test_foo (test.test_example.TestClass) ... FAIL
+test_foo (test.test_example.TestClass.test_foo) ... FAIL
 -----------
 ======================================================================
-FAIL: test_foo (test.test_example.TestClass)
+FAIL: test_foo (test.test_example.TestClass.test_foo)
 ----------------------------------------------------------------------
 Traceback (most recent call last):
   File "test.py", line 10, in test_foo
@@ -121,11 +121,11 @@ def test_parse_multiple_error_messages(self):
         """Test parsing multiple error messages."""
         stdout = """
 Run 2 tests sequentially
-test_foo (test.test_example.TestClass) ... FAIL
-test_bar (test.test_example.TestClass) ... ERROR
+test_foo (test.test_example.TestClass.test_foo) ... FAIL
+test_bar (test.test_example.TestClass.test_bar) ... ERROR
 -----------
 ======================================================================
-FAIL: test_foo (test.test_example.TestClass)
+FAIL: test_foo (test.test_example.TestClass.test_foo)
 ----------------------------------------------------------------------
 Traceback (most recent call last):
   File "test.py", line 10, in test_foo
@@ -133,7 +133,7 @@ def test_parse_multiple_error_messages(self):
 AssertionError: 1 != 2
 
 ======================================================================
-ERROR: test_bar (test.test_example.TestClass)
+ERROR: test_bar (test.test_example.TestClass.test_bar)
 ----------------------------------------------------------------------
 Traceback (most recent call last):
   File "test.py", line 20, in test_bar

From 41cdc5cd5b7c57885ff2b294e862daa8afd49f03 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Mon, 19 Jan 2026 23:37:46 +0900
Subject: [PATCH 402/418] BooleanOptionalAction

---
 scripts/update_lib/auto_mark.py | 11 ++++----
 scripts/update_lib/quick.py     | 46 ++++++++++++++++++---------------
 2 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/scripts/update_lib/auto_mark.py b/scripts/update_lib/auto_mark.py
index 2ff074c0c41..5a15df365a8 100644
--- a/scripts/update_lib/auto_mark.py
+++ b/scripts/update_lib/auto_mark.py
@@ -675,9 +675,10 @@ def main(argv: list[str] | None = None) -> int:
         help="Also add @expectedFailure to failing tests (default: only remove unexpected successes)",
     )
     parser.add_argument(
-        "--skip-build",
-        action="store_true",
-        help="Skip cargo build, use pre-built binary",
+        "--build",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Build with cargo (default: enabled)",
     )
 
     args = parser.parse_args(argv)
@@ -685,11 +686,11 @@ def main(argv: list[str] | None = None) -> int:
     try:
         if args.path.is_dir():
             num_added, num_removed, _ = auto_mark_directory(
-                args.path, mark_failure=args.mark_failure, skip_build=args.skip_build
+                args.path, mark_failure=args.mark_failure, skip_build=not args.build
             )
         else:
             num_added, num_removed, _ = auto_mark_file(
-                args.path, mark_failure=args.mark_failure, skip_build=args.skip_build
+                args.path, mark_failure=args.mark_failure, skip_build=not args.build
             )
         if args.mark_failure:
             print(f"Added expectedFailure to {num_added} tests")
diff --git a/scripts/update_lib/quick.py b/scripts/update_lib/quick.py
index 6221fcbc6b2..f7d0b6b8683 100644
--- a/scripts/update_lib/quick.py
+++ b/scripts/update_lib/quick.py
@@ -271,19 +271,22 @@ def main(argv: list[str] | None = None) -> int:
         help="Source path (file or directory)",
     )
     parser.add_argument(
-        "--no-copy",
-        action="store_true",
-        help="Skip copy-lib step (implied if path is a test path)",
+        "--copy",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Copy library file (default: enabled, implied disabled if test path)",
     )
     parser.add_argument(
-        "--no-migrate",
-        action="store_true",
-        help="Skip migration step (implied if path starts with Lib/)",
+        "--migrate",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Migrate test file (default: enabled, implied disabled if Lib/ path)",
     )
     parser.add_argument(
-        "--no-auto-mark",
-        action="store_true",
-        help="Skip auto-mark step",
+        "--auto-mark",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Auto-mark test failures (default: enabled)",
     )
     parser.add_argument(
         "--mark-failure",
@@ -291,21 +294,22 @@ def main(argv: list[str] | None = None) -> int:
         help="Add @expectedFailure to failing tests",
     )
     parser.add_argument(
-        "--no-commit",
-        action="store_true",
-        help="Skip git commit step",
+        "--commit",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Create git commit (default: enabled)",
     )
     parser.add_argument(
-        "--skip-build",
-        action="store_true",
-        help="Skip cargo build, use pre-built binary",
+        "--build",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Build with cargo (default: enabled)",
     )
 
     args = parser.parse_args(argv)
 
     try:
         src_path = args.path
-        no_copy = args.no_copy
 
         # Shortcut: expand simple name to cpython/Lib path
         src_path = _expand_shortcut(src_path)
@@ -320,7 +324,7 @@ def main(argv: list[str] | None = None) -> int:
             # Get library destination path for commit
             lib_file_path = parse_lib_path(src_path)
 
-            if not no_copy:
+            if args.copy:
                 from update_lib.copy_lib import copy_lib
 
                 copy_lib(src_path)
@@ -336,14 +340,14 @@ def main(argv: list[str] | None = None) -> int:
         # Process the test path
         quick(
             src_path,
-            no_migrate=args.no_migrate,
-            no_auto_mark=args.no_auto_mark,
+            no_migrate=not args.migrate,
+            no_auto_mark=not args.auto_mark,
             mark_failure=args.mark_failure,
-            skip_build=args.skip_build,
+            skip_build=not args.build,
         )
 
         # Step 3: Git commit
-        if not args.no_commit:
+        if args.commit:
             # Extract module name from path
             name = original_src.stem
             if name == "__init__":

From f1fd1e9121c791c4d3df1e26c0d8f2cc3f3e9337 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Tue, 20 Jan 2026 02:34:12 +0000
Subject: [PATCH 403/418] Auto-format: ruff format

---
 scripts/update_lib/tests/test_quick.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/scripts/update_lib/tests/test_quick.py b/scripts/update_lib/tests/test_quick.py
index 43f829a9626..d4e679e8a16 100644
--- a/scripts/update_lib/tests/test_quick.py
+++ b/scripts/update_lib/tests/test_quick.py
@@ -6,7 +6,12 @@
 from unittest.mock import patch
 
 from update_lib.path import lib_to_test_path
-from update_lib.quick import _expand_shortcut, collect_original_methods, get_cpython_dir, git_commit
+from update_lib.quick import (
+    _expand_shortcut,
+    collect_original_methods,
+    get_cpython_dir,
+    git_commit,
+)
 
 
 class TestGetCpythonDir(unittest.TestCase):

From 6e842cf110a8032589a73e3c3004ead0b8c61604 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 03:10:04 +0900
Subject: [PATCH 404/418] PyPartial::__get__

---
 crates/vm/src/stdlib/functools.rs | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index a59fd48f6b2..53fdb34c42a 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -4,14 +4,14 @@ pub(crate) use _functools::make_module;
 mod _functools {
     use crate::{
         Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyDict, PyGenericAlias, PyTuple, PyTypeRef},
+        builtins::{PyBoundMethod, PyDict, PyGenericAlias, PyTuple, PyTypeRef},
         common::lock::PyRwLock,
         function::{FuncArgs, KwArgs, OptionalArg},
         object::AsObject,
         protocol::PyIter,
         pyclass,
         recursion::ReprGuard,
-        types::{Callable, Constructor, Representable},
+        types::{Callable, Constructor, GetDescriptor, Representable},
     };
     use indexmap::IndexMap;
 
@@ -56,7 +56,10 @@ mod _functools {
         keywords: PyRef<PyDict>,
     }
 
-    #[pyclass(with(Constructor, Callable, Representable), flags(BASETYPE, HAS_DICT))]
+    #[pyclass(
+        with(Constructor, Callable, GetDescriptor, Representable),
+        flags(BASETYPE, HAS_DICT)
+    )]
     impl PyPartial {
         #[pygetset]
         fn func(&self) -> PyObjectRef {
@@ -281,6 +284,21 @@ mod _functools {
         }
     }
 
+    impl GetDescriptor for PyPartial {
+        fn descr_get(
+            zelf: PyObjectRef,
+            obj: Option<PyObjectRef>,
+            _cls: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let obj = match obj {
+                Some(obj) if !vm.is_none(&obj) => obj,
+                _ => return Ok(zelf),
+            };
+            Ok(PyBoundMethod::new(obj, zelf).into_ref(&vm.ctx).into())
+        }
+    }
+
     impl Representable for PyPartial {
         #[inline]
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {

From 25a3d6dde1c18fb926e53905a842947fcdef20b8 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 10:26:23 +0900
Subject: [PATCH 405/418] functools.Placeholder

---
 crates/vm/src/stdlib/functools.rs | 154 ++++++++++++++++++++++++++++--
 1 file changed, 147 insertions(+), 7 deletions(-)

diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index 53fdb34c42a..5adc0fe9690 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -4,7 +4,7 @@ pub(crate) use _functools::make_module;
 mod _functools {
     use crate::{
         Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyBoundMethod, PyDict, PyGenericAlias, PyTuple, PyTypeRef},
+        builtins::{PyBoundMethod, PyDict, PyGenericAlias, PyTuple, PyType, PyTypeRef},
         common::lock::PyRwLock,
         function::{FuncArgs, KwArgs, OptionalArg},
         object::AsObject,
@@ -42,6 +42,72 @@ mod _functools {
         Ok(accumulator)
     }
 
+    // Placeholder singleton for partial arguments
+    // The singleton is stored as _instance on the type class
+    #[pyattr]
+    #[allow(non_snake_case)]
+    fn Placeholder(vm: &VirtualMachine) -> PyObjectRef {
+        let placeholder = PyPlaceholderType.into_pyobject(vm);
+        // Store the singleton on the type class for slot_new to find
+        let typ = placeholder.class();
+        typ.set_attr(vm.ctx.intern_str("_instance"), placeholder.clone());
+        placeholder
+    }
+
+    #[pyattr]
+    #[pyclass(name = "_PlaceholderType", module = "functools")]
+    #[derive(Debug, PyPayload)]
+    pub struct PyPlaceholderType;
+
+    impl Constructor for PyPlaceholderType {
+        type Args = FuncArgs;
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            if !args.args.is_empty() || !args.kwargs.is_empty() {
+                return Err(vm.new_type_error("_PlaceholderType takes no arguments".to_owned()));
+            }
+            // Return the singleton stored on the type class
+            if let Some(instance) = cls.get_attr(vm.ctx.intern_str("_instance")) {
+                return Ok(instance);
+            }
+            // Fallback: create a new instance (shouldn't happen for base type after module init)
+            Ok(PyPlaceholderType.into_pyobject(vm))
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            // This is never called because we override slot_new
+            Ok(PyPlaceholderType)
+        }
+    }
+
+    #[pyclass(with(Constructor, Representable))]
+    impl PyPlaceholderType {
+        #[pymethod]
+        fn __reduce__(&self) -> &'static str {
+            "Placeholder"
+        }
+
+        #[pymethod]
+        fn __init_subclass__(_cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+            Err(vm.new_type_error("cannot subclass '_PlaceholderType'".to_owned()))
+        }
+    }
+
+    impl Representable for PyPlaceholderType {
+        #[inline]
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok("Placeholder".to_owned())
+        }
+    }
+
+    fn is_placeholder(obj: &PyObjectRef) -> bool {
+        &*obj.class().name() == "_PlaceholderType"
+    }
+
+    fn count_placeholders(args: &[PyObjectRef]) -> usize {
+        args.iter().filter(|a| is_placeholder(a)).count()
+    }
+
     #[pyattr]
     #[pyclass(name = "partial", module = "functools")]
     #[derive(Debug, PyPayload)]
@@ -54,6 +120,7 @@ mod _functools {
         func: PyObjectRef,
         args: PyRef<PyTuple>,
         keywords: PyRef<PyDict>,
+        phcount: usize,
     }
 
     #[pyclass(
@@ -160,6 +227,13 @@ mod _functools {
                 }
             };
 
+            // Validate no trailing placeholders
+            let args_slice = args_tuple.as_slice();
+            if !args_slice.is_empty() && is_placeholder(args_slice.last().unwrap()) {
+                return Err(vm.new_type_error("trailing Placeholders are not allowed".to_owned()));
+            }
+            let phcount = count_placeholders(args_slice);
+
             // Actually update the state
             let mut inner = zelf.inner.write();
             inner.func = func.clone();
@@ -168,6 +242,7 @@ mod _functools {
 
             // Handle keywords - keep the original type
             inner.keywords = keywords_dict;
+            inner.phcount = phcount;
 
             // Update __dict__ if provided
             let Some(instance_dict) = zelf.as_object().dict() else {
@@ -221,17 +296,54 @@ mod _functools {
                 return Err(vm.new_type_error("the first argument must be callable"));
             }
 
+            // Check for placeholders in kwargs
+            for (key, value) in &args.kwargs {
+                if is_placeholder(value) {
+                    return Err(vm.new_type_error(format!(
+                        "Placeholder cannot be passed as a keyword argument to partial(). \
+                         Did you mean partial(..., {}=Placeholder, ...)(value)?",
+                        key
+                    )));
+                }
+            }
+
             // Handle nested partial objects
             let (final_func, final_args, final_keywords) =
                 if let Some(partial) = func.downcast_ref::<Self>() {
                     let inner = partial.inner.read();
-                    let mut combined_args = inner.args.as_slice().to_vec();
-                    combined_args.extend_from_slice(args_slice);
-                    (inner.func.clone(), combined_args, inner.keywords.clone())
+                    let stored_args = inner.args.as_slice();
+
+                    // Merge placeholders: replace placeholders in stored_args with new args
+                    let mut merged_args = Vec::with_capacity(stored_args.len() + args_slice.len());
+                    let mut new_args_iter = args_slice.iter();
+
+                    for stored_arg in stored_args {
+                        if is_placeholder(stored_arg) {
+                            // Replace placeholder with next new arg, or keep placeholder
+                            if let Some(new_arg) = new_args_iter.next() {
+                                merged_args.push(new_arg.clone());
+                            } else {
+                                merged_args.push(stored_arg.clone());
+                            }
+                        } else {
+                            merged_args.push(stored_arg.clone());
+                        }
+                    }
+                    // Append remaining new args
+                    merged_args.extend(new_args_iter.cloned());
+
+                    (inner.func.clone(), merged_args, inner.keywords.clone())
                 } else {
                     (func.clone(), args_slice.to_vec(), vm.ctx.new_dict())
                 };
 
+            // Trailing placeholders are not allowed
+            if !final_args.is_empty() && is_placeholder(final_args.last().unwrap()) {
+                return Err(vm.new_type_error("trailing Placeholders are not allowed".to_owned()));
+            }
+
+            let phcount = count_placeholders(&final_args);
+
             // Add new keywords
             for (key, value) in args.kwargs {
                 final_keywords.set_item(vm.ctx.intern_str(key.as_str()), value, vm)?;
@@ -242,6 +354,7 @@ mod _functools {
                     func: final_func,
                     args: vm.ctx.new_tuple(final_args),
                     keywords: final_keywords,
+                    phcount,
                 }),
             })
         }
@@ -252,17 +365,44 @@ mod _functools {
 
         fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             // Clone and release lock before calling Python code to prevent deadlock
-            let (func, stored_args, keywords) = {
+            let (func, stored_args, keywords, phcount) = {
                 let inner = zelf.inner.read();
                 (
                     inner.func.clone(),
                     inner.args.clone(),
                     inner.keywords.clone(),
+                    inner.phcount,
                 )
             };
 
-            let mut combined_args = stored_args.as_slice().to_vec();
-            combined_args.extend_from_slice(&args.args);
+            // Check if we have enough args to fill placeholders
+            if phcount > 0 && args.args.len() < phcount {
+                return Err(vm.new_type_error(format!(
+                    "missing positional arguments in 'partial' call; expected at least {}, got {}",
+                    phcount,
+                    args.args.len()
+                )));
+            }
+
+            // Build combined args, replacing placeholders
+            let mut combined_args = Vec::with_capacity(stored_args.len() + args.args.len());
+            let mut new_args_iter = args.args.iter();
+
+            for stored_arg in stored_args.as_slice() {
+                if is_placeholder(stored_arg) {
+                    // Replace placeholder with next new arg
+                    if let Some(new_arg) = new_args_iter.next() {
+                        combined_args.push(new_arg.clone());
+                    } else {
+                        // This shouldn't happen if phcount check passed
+                        combined_args.push(stored_arg.clone());
+                    }
+                } else {
+                    combined_args.push(stored_arg.clone());
+                }
+            }
+            // Append remaining new args
+            combined_args.extend(new_args_iter.cloned());
 
             // Merge keywords from self.keywords and args.kwargs
             let mut final_kwargs = IndexMap::new();

From c8b1cb8cab1bd63bdde67c6f9445ba758e77c910 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Sun, 18 Jan 2026 22:34:19 +0900
Subject: [PATCH 406/418] Bump re to 3.14.2

---
 Lib/re/__init__.py   |  2 +-
 Lib/re/_compiler.py  | 40 ++++++++++++++++++++----------
 Lib/re/_constants.py |  4 ++-
 Lib/re/_parser.py    | 19 ++------------
 Lib/test/test_re.py  | 59 ++++++++++++++++++++++----------------------
 5 files changed, 63 insertions(+), 61 deletions(-)

diff --git a/Lib/re/__init__.py b/Lib/re/__init__.py
index 7e8abbf6ffe..af2808a77da 100644
--- a/Lib/re/__init__.py
+++ b/Lib/re/__init__.py
@@ -61,7 +61,7 @@
 resulting RE will match the second character.
     \number  Matches the contents of the group of the same number.
     \A       Matches only at the start of the string.
-    \Z       Matches only at the end of the string.
+    \z       Matches only at the end of the string.
     \b       Matches the empty string, but only at the start or end of a word.
     \B       Matches the empty string, but not at the start or end of a word.
     \d       Matches any decimal digit; equivalent to the set [0-9] in
diff --git a/Lib/re/_compiler.py b/Lib/re/_compiler.py
index 1b1aaa7714b..20dd561d1c1 100644
--- a/Lib/re/_compiler.py
+++ b/Lib/re/_compiler.py
@@ -28,6 +28,8 @@
     POSSESSIVE_REPEAT: (POSSESSIVE_REPEAT, SUCCESS, POSSESSIVE_REPEAT_ONE),
 }
 
+_CHARSET_ALL = [(NEGATE, None)]
+
 def _combine_flags(flags, add_flags, del_flags,
                    TYPE_FLAGS=_parser.TYPE_FLAGS):
     if add_flags & TYPE_FLAGS:
@@ -84,17 +86,22 @@ def _compile(code, pattern, flags):
                     code[skip] = _len(code) - skip
         elif op is IN:
             charset, hascased = _optimize_charset(av, iscased, tolower, fixes)
-            if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
-                emit(IN_LOC_IGNORE)
-            elif not hascased:
-                emit(IN)
-            elif not fixes:  # ascii
-                emit(IN_IGNORE)
+            if not charset:
+                emit(FAILURE)
+            elif charset == _CHARSET_ALL:
+                emit(ANY_ALL)
             else:
-                emit(IN_UNI_IGNORE)
-            skip = _len(code); emit(0)
-            _compile_charset(charset, flags, code)
-            code[skip] = _len(code) - skip
+                if flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE:
+                    emit(IN_LOC_IGNORE)
+                elif not hascased:
+                    emit(IN)
+                elif not fixes:  # ascii
+                    emit(IN_IGNORE)
+                else:
+                    emit(IN_UNI_IGNORE)
+                skip = _len(code); emit(0)
+                _compile_charset(charset, flags, code)
+                code[skip] = _len(code) - skip
         elif op is ANY:
             if flags & SRE_FLAG_DOTALL:
                 emit(ANY_ALL)
@@ -277,6 +284,10 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                             charmap[i] = 1
                 elif op is NEGATE:
                     out.append((op, av))
+                elif op is CATEGORY and tail and (CATEGORY, CH_NEGATE[av]) in tail:
+                    # Optimize [\s\S] etc.
+                    out = [] if out else _CHARSET_ALL
+                    return out, False
                 else:
                     tail.append((op, av))
             except IndexError:
@@ -524,13 +535,18 @@ def _compile_info(code, pattern, flags):
     # look for a literal prefix
     prefix = []
     prefix_skip = 0
-    charset = [] # not used
+    charset = None # not used
     if not (flags & SRE_FLAG_IGNORECASE and flags & SRE_FLAG_LOCALE):
         # look for literal prefix
         prefix, prefix_skip, got_all = _get_literal_prefix(pattern, flags)
         # if no prefix, look for charset prefix
         if not prefix:
             charset = _get_charset_prefix(pattern, flags)
+            if charset:
+                charset, hascased = _optimize_charset(charset)
+                assert not hascased
+                if charset == _CHARSET_ALL:
+                    charset = None
 ##     if prefix:
 ##         print("*** PREFIX", prefix, prefix_skip)
 ##     if charset:
@@ -565,8 +581,6 @@ def _compile_info(code, pattern, flags):
         # generate overlap table
         code.extend(_generate_overlap_table(prefix))
     elif charset:
-        charset, hascased = _optimize_charset(charset)
-        assert not hascased
         _compile_charset(charset, flags, code)
     code[skip] = len(code) - skip
 
diff --git a/Lib/re/_constants.py b/Lib/re/_constants.py
index 9c3c294ba44..d6f32302d37 100644
--- a/Lib/re/_constants.py
+++ b/Lib/re/_constants.py
@@ -15,7 +15,7 @@
 
 MAGIC = 20230612
 
-from _sre import MAXREPEAT, MAXGROUPS
+from _sre import MAXREPEAT, MAXGROUPS  # noqa: F401
 
 # SRE standard exception (access as sre.error)
 # should this really be here?
@@ -206,6 +206,8 @@ def _makecodes(*names):
     CATEGORY_NOT_LINEBREAK: CATEGORY_UNI_NOT_LINEBREAK
 }
 
+CH_NEGATE = dict(zip(CHCODES[::2] + CHCODES[1::2], CHCODES[1::2] + CHCODES[::2]))
+
 # flags
 SRE_FLAG_IGNORECASE = 2 # case insensitive
 SRE_FLAG_LOCALE = 4 # honour system locale
diff --git a/Lib/re/_parser.py b/Lib/re/_parser.py
index f3c779340fe..35ab7ede2a7 100644
--- a/Lib/re/_parser.py
+++ b/Lib/re/_parser.py
@@ -49,7 +49,8 @@
     r"\S": (IN, [(CATEGORY, CATEGORY_NOT_SPACE)]),
     r"\w": (IN, [(CATEGORY, CATEGORY_WORD)]),
     r"\W": (IN, [(CATEGORY, CATEGORY_NOT_WORD)]),
-    r"\Z": (AT, AT_END_STRING), # end of string
+    r"\z": (AT, AT_END_STRING), # end of string
+    r"\Z": (AT, AT_END_STRING), # end of string (obsolete)
 }
 
 FLAGS = {
@@ -807,14 +808,6 @@ def _parse(source, state, verbose, nested, first=False):
                             state.grouprefpos[condgroup] = (
                                 source.tell() - len(condname) - 1
                             )
-                        if not (condname.isdecimal() and condname.isascii()):
-                            import warnings
-                            warnings.warn(
-                                "bad character in group name %s at position %d" %
-                                (repr(condname) if source.istext else ascii(condname),
-                                 source.tell() - len(condname) - 1),
-                                DeprecationWarning, stacklevel=nested + 6
-                            )
                     state.checklookbehindgroup(condgroup, source)
                     item_yes = _parse(source, state, verbose, nested + 1)
                     if source.match("|"):
@@ -1038,14 +1031,6 @@ def addgroup(index, pos):
                     if index >= MAXGROUPS:
                         raise s.error("invalid group reference %d" % index,
                                       len(name) + 1)
-                    if not (name.isdecimal() and name.isascii()):
-                        import warnings
-                        warnings.warn(
-                            "bad character in group name %s at position %d" %
-                            (repr(name) if s.istext else ascii(name),
-                             s.tell() - len(name) - 1),
-                            DeprecationWarning, stacklevel=5
-                        )
                 addgroup(index, len(name) + 1)
             elif c == "0":
                 if s.next in OCTDIGITS:
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 04c8ee71a99..8b935dc7f12 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -1,12 +1,11 @@
 from test.support import (gc_collect, bigmemtest, _2G,
                           cpython_only, captured_stdout,
-                          check_disallow_instantiation, is_emscripten, is_wasi,
+                          check_disallow_instantiation, linked_to_musl,
                           warnings_helper, SHORT_TIMEOUT, Stopwatch, requires_resource)
 import locale
 import re
 import string
 import sys
-import time
 import unittest
 import warnings
 from re import Scanner
@@ -14,7 +13,7 @@
 
 # some platforms lack working multiprocessing
 try:
-    import _multiprocessing
+    import _multiprocessing  # noqa: F401
 except ImportError:
     multiprocessing = None
 else:
@@ -621,6 +620,7 @@ def test_re_fullmatch(self):
         self.assertEqual(re.fullmatch(r"a.*?b", "axxb").span(), (0, 4))
         self.assertIsNone(re.fullmatch(r"a+", "ab"))
         self.assertIsNone(re.fullmatch(r"abc$", "abc\n"))
+        self.assertIsNone(re.fullmatch(r"abc\z", "abc\n"))
         self.assertIsNone(re.fullmatch(r"abc\Z", "abc\n"))
         self.assertIsNone(re.fullmatch(r"(?m)abc$", "abc\n"))
         self.assertEqual(re.fullmatch(r"ab(?=c)cd", "abcd").span(), (0, 4))
@@ -806,6 +806,8 @@ def test_special_escapes(self):
         self.assertEqual(re.search(r"\B(b.)\B",
                                    "abc bcd bc abxd", re.ASCII).group(1), "bx")
         self.assertEqual(re.search(r"^abc$", "\nabc\n", re.M).group(0), "abc")
+        self.assertEqual(re.search(r"^\Aabc\z$", "abc", re.M).group(0), "abc")
+        self.assertIsNone(re.search(r"^\Aabc\z$", "\nabc\n", re.M))
         self.assertEqual(re.search(r"^\Aabc\Z$", "abc", re.M).group(0), "abc")
         self.assertIsNone(re.search(r"^\Aabc\Z$", "\nabc\n", re.M))
         self.assertEqual(re.search(br"\b(b.)\b",
@@ -817,6 +819,8 @@ def test_special_escapes(self):
         self.assertEqual(re.search(br"\B(b.)\B",
                                    b"abc bcd bc abxd", re.LOCALE).group(1), b"bx")
         self.assertEqual(re.search(br"^abc$", b"\nabc\n", re.M).group(0), b"abc")
+        self.assertEqual(re.search(br"^\Aabc\z$", b"abc", re.M).group(0), b"abc")
+        self.assertIsNone(re.search(br"^\Aabc\z$", b"\nabc\n", re.M))
         self.assertEqual(re.search(br"^\Aabc\Z$", b"abc", re.M).group(0), b"abc")
         self.assertIsNone(re.search(br"^\Aabc\Z$", b"\nabc\n", re.M))
         self.assertEqual(re.search(r"\d\D\w\W\s\S",
@@ -840,7 +844,7 @@ def test_other_escapes(self):
         self.assertEqual(re.match(r"[\^a]+", 'a^').group(), 'a^')
         self.assertIsNone(re.match(r"[\^a]+", 'b'))
         re.purge()  # for warnings
-        for c in 'ceghijklmopqyzCEFGHIJKLMNOPQRTVXY':
+        for c in 'ceghijklmopqyCEFGHIJKLMNOPQRTVXY':
             with self.subTest(c):
                 self.assertRaises(re.PatternError, re.compile, '\\%c' % c)
         for c in 'ceghijklmopqyzABCEFGHIJKLMNOPQRTVXYZ':
@@ -888,6 +892,8 @@ def test_named_unicode_escapes(self):
         self.checkPatternError(br'\N{LESS-THAN SIGN}', r'bad escape \N', 0)
         self.checkPatternError(br'[\N{LESS-THAN SIGN}]', r'bad escape \N', 1)
 
+    # TODO: RUSTPYTHON; re.search(r"\B", "") now returns a match in CPython 3.14
+    @unittest.expectedFailure
     def test_word_boundaries(self):
         # See http://bugs.python.org/issue10713
         self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), "abc")
@@ -983,18 +989,15 @@ def test_word_boundaries(self):
         self.assertIsNone(re.fullmatch(br".+\B", b"abc", re.LOCALE))
         self.assertIsNone(re.fullmatch(r".+\B", "ью�"))
         self.assertTrue(re.fullmatch(r".+\B", "ью�", re.ASCII))
-        # However, an empty string contains no word boundaries, and also no
-        # non-boundaries.
+        # However, an empty string contains no word boundaries.
         self.assertIsNone(re.search(r"\b", ""))
         self.assertIsNone(re.search(r"\b", "", re.ASCII))
         self.assertIsNone(re.search(br"\b", b""))
         self.assertIsNone(re.search(br"\b", b"", re.LOCALE))
-        # This one is questionable and different from the perlre behaviour,
-        # but describes current behavior.
-        self.assertIsNone(re.search(r"\B", ""))
-        self.assertIsNone(re.search(r"\B", "", re.ASCII))
-        self.assertIsNone(re.search(br"\B", b""))
-        self.assertIsNone(re.search(br"\B", b"", re.LOCALE))
+        self.assertTrue(re.search(r"\B", ""))
+        self.assertTrue(re.search(r"\B", "", re.ASCII))
+        self.assertTrue(re.search(br"\B", b""))
+        self.assertTrue(re.search(br"\B", b"", re.LOCALE))
         # A single word-character string has two boundaries, but no
         # non-boundary gaps.
         self.assertEqual(len(re.findall(r"\b", "a")), 2)
@@ -1423,7 +1426,7 @@ def test_pickling(self):
             newpat = pickle.loads(pickled)
             self.assertEqual(newpat, oldpat)
         # current pickle expects the _compile() reconstructor in re module
-        from re import _compile
+        from re import _compile  # noqa: F401
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_copying(self):
@@ -1755,7 +1758,7 @@ def test_bug_6561(self):
         for x in not_decimal_digits:
             self.assertIsNone(re.match(r'^\d$', x))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON a = array.array(typecode)\n ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)
+    @unittest.expectedFailure # TODO: RUSTPYTHON; a = array.array(typecode)\n ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)
     @warnings_helper.ignore_warnings(category=DeprecationWarning)  # gh-80480 array('u')
     def test_empty_array(self):
         # SF buf 1647541
@@ -2185,10 +2188,9 @@ def test_bug_20998(self):
         self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
 
     @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))\n AssertionError: None is not true
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "musl libc issue on Emscripten/WASI, bpo-46390"
-    )
+    @unittest.skipIf(linked_to_musl(), "musl libc issue, bpo-46390")
+    @unittest.skipIf(sys.platform.startswith("sunos"),
+                     "test doesn't work on Solaris, gh-91214")
     def test_locale_caching(self):
         # Issue #22410
         oldlocale = locale.setlocale(locale.LC_CTYPE)
@@ -2225,10 +2227,9 @@ def check_en_US_utf8(self):
         self.assertIsNone(re.match(b'(?Li)\xc5', b'\xe5'))
         self.assertIsNone(re.match(b'(?Li)\xe5', b'\xc5'))
 
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "musl libc issue on Emscripten/WASI, bpo-46390"
-    )
+    @unittest.skipIf(linked_to_musl(), "musl libc issue, bpo-46390")
+    @unittest.skipIf(sys.platform.startswith("sunos"),
+                     "test doesn't work on Solaris, gh-91214")
     def test_locale_compiled(self):
         oldlocale = locale.setlocale(locale.LC_CTYPE)
         self.addCleanup(locale.setlocale, locale.LC_CTYPE, oldlocale)
@@ -2632,8 +2633,8 @@ def test_findall_atomic_grouping(self):
 
     @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_gh91616(self):
-        self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\Z', "a.txt")) # reproducer
-        self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\Z', "a.txt"))
+        self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\z', "a.txt")) # reproducer
+        self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\z', "a.txt"))
 
     def test_bug_gh100061(self):
         # gh-100061
@@ -2655,7 +2656,7 @@ def test_bug_gh100061(self):
         self.assertEqual(re.match("(?>(?:ab?c){1,3})", "aca").span(), (0, 2))
         self.assertEqual(re.match("(?:ab?c){1,3}+", "aca").span(), (0, 2))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))\n AssertionError: Tuples differ: ('x', 'x') != ('z', 'x')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))\n AssertionError: Tuples differ: ('x', 'x') != ('z', 'x')
     def test_bug_gh101955(self):
         # Possessive quantifier with nested alternative with capture groups
         self.assertEqual(re.match('((x)|y|z)*+', 'xyz').groups(), ('z', 'x'))
@@ -2893,11 +2894,11 @@ def test_long_pattern(self):
         pattern = 'Very %spattern' % ('long ' * 1000)
         r = repr(re.compile(pattern))
         self.assertLess(len(r), 300)
-        self.assertEqual(r[:30], "re.compile('Very long long lon")
+        self.assertStartsWith(r, "re.compile('Very long long lon")
         r = repr(re.compile(pattern, re.I))
         self.assertLess(len(r), 300)
-        self.assertEqual(r[:30], "re.compile('Very long long lon")
-        self.assertEqual(r[-16:], ", re.IGNORECASE)")
+        self.assertStartsWith(r, "re.compile('Very long long lon")
+        self.assertEndsWith(r, ", re.IGNORECASE)")
 
     def test_flags_repr(self):
         self.assertEqual(repr(re.I), "re.IGNORECASE")
@@ -2977,7 +2978,7 @@ def test_deprecated_modules(self):
                 self.assertEqual(mod.__name__, name)
                 self.assertEqual(mod.__package__, '')
                 for attr in deprecated[name]:
-                    self.assertTrue(hasattr(mod, attr))
+                    self.assertHasAttr(mod, attr)
                 del sys.modules[name]
 
     @cpython_only

From 52a854a57a5f7257647a85dcb3968b416a944c9a Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Tue, 20 Jan 2026 14:14:04 +0900
Subject: [PATCH 407/418] Unmark resolved test

---
 Lib/test/test_warnings/__init__.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
index abdf7b32df2..87632821a8e 100644
--- a/Lib/test/test_warnings/__init__.py
+++ b/Lib/test/test_warnings/__init__.py
@@ -241,7 +241,6 @@ def test_once(self):
                                     42)
             self.assertEqual(len(w), 0)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON re.PatternError: bad escape \z at position 15
     def test_filter_module(self):
         MS_WINDOWS = (sys.platform == 'win32')
         with self.module.catch_warnings(record=True) as w:

From f0c3e7d51fdd70d11191e87a0acc508569b7d077 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 16:21:23 +0900
Subject: [PATCH 408/418] Remove SUBSCRIPT, JUMP_IF_{TRUE,FALSE}_OR_POP (#6810)

* Align ForIter behavior (incomplete)

* Romove JUMP_IF_{TRUE,FALSE}_OR_POP, subscript

* Remove LoadAssetionError

* Update snapshot for ForIter behavior change
---
 Lib/_opcode_metadata.py                       |  4 --
 crates/codegen/src/compile.rs                 | 16 +++----
 ...pile__tests__nested_double_async_with.snap |  4 +-
 .../compiler-core/src/bytecode/instruction.rs | 45 ++-----------------
 crates/stdlib/src/opcode.rs                   |  2 -
 crates/vm/src/frame.rs                        | 40 ++---------------
 6 files changed, 17 insertions(+), 94 deletions(-)

diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
index 3345870e4ec..f219132b9c3 100644
--- a/Lib/_opcode_metadata.py
+++ b/Lib/_opcode_metadata.py
@@ -218,13 +218,9 @@
     'BUILD_CONST_KEY_MAP': 215,
     'BREAK': 216,
     'CONTINUE': 217,
-    'JUMP_IF_FALSE_OR_POP': 218,
-    'JUMP_IF_TRUE_OR_POP': 219,
     'JUMP_IF_NOT_EXC_MATCH': 220,
-    'LOAD_ASSERTION_ERROR': 221,
     'RETURN_CONST': 222,
     'SET_EXC_INFO': 223,
-    'SUBSCRIPT': 224,
     'INSTRUMENTED_END_FOR': 234,
     'INSTRUMENTED_POP_ITER': 235,
     'INSTRUMENTED_END_SEND': 236,
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index a72e425e290..93a759c7ff4 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -489,7 +489,7 @@ impl Compiler {
             match ctx {
                 ast::ExprContext::Load => {
                     emit!(self, Instruction::BuildSlice { argc });
-                    emit!(self, Instruction::Subscript);
+                    emit!(self, Instruction::BinarySubscr);
                 }
                 ast::ExprContext::Store => {
                     emit!(self, Instruction::BuildSlice { argc });
@@ -503,7 +503,7 @@ impl Compiler {
 
             // Emit appropriate instruction based on context
             match ctx {
-                ast::ExprContext::Load => emit!(self, Instruction::Subscript),
+                ast::ExprContext::Load => emit!(self, Instruction::BinarySubscr),
                 ast::ExprContext::Store => emit!(self, Instruction::StoreSubscr),
                 ast::ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
                 ast::ExprContext::Invalid => {
@@ -4929,6 +4929,9 @@ impl Compiler {
 
         if is_async {
             emit!(self, Instruction::EndAsyncFor);
+        } else {
+            // Pop the iterator after loop ends
+            emit!(self, Instruction::PopTop);
         }
         self.compile_statements(orelse)?;
 
@@ -5987,14 +5990,9 @@ impl Compiler {
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
-            /*
             emit!(self, Instruction::Copy { index: 1 });
-            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
             emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
             emit!(self, Instruction::PopTop);
-            */
-
-            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
         }
 
         self.compile_expression(last_comparator)?;
@@ -6205,7 +6203,7 @@ impl Compiler {
                 self.compile_expression(slice)?;
                 emit!(self, Instruction::Copy { index: 2_u32 });
                 emit!(self, Instruction::Copy { index: 2_u32 });
-                emit!(self, Instruction::Subscript);
+                emit!(self, Instruction::BinarySubscr);
                 AugAssignKind::Subscript
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
@@ -7367,6 +7365,8 @@ impl Compiler {
             if is_async {
                 emit!(self, Instruction::EndAsyncFor);
                 emit!(self, Instruction::PopTop);
+            } else {
+                emit!(self, Instruction::PopTop);
             }
         }
 
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index c4d2ed83796..eeef8ea4b3f 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -1,5 +1,6 @@
 ---
 source: crates/codegen/src/compile.rs
+assertion_line: 8626
 expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n        with self.subTest(type=type(stop_exc)):\n            try:\n                async with egg():\n                    raise stop_exc\n            except Exception as ex:\n                self.assertIs(ex, stop_exc)\n            else:\n                self.fail(f'{stop_exc} was suppressed')\n\")"
 ---
   3           0 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RESUME               (0)
@@ -140,7 +141,8 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                 126 POP_EXCEPT
                 127 RERAISE              (1)
             >>  128 JUMP_BACKWARD        (11)
-            >>  129 RETURN_CONST         (None)
+            >>  129 POP_TOP
+                130 RETURN_CONST         (None)
 
               1 MAKE_FUNCTION
               2 STORE_NAME           (0, test)
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 41f86dca39b..d8ba8da7a01 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -272,19 +272,11 @@ pub enum Instruction {
     Continue {
         target: Arg<Label>,
     } = 217,
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    } = 218,
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    } = 219,
     JumpIfNotExcMatch(Arg<Label>) = 220,
-    LoadAssertionError = 221, // Placeholder
     ReturnConst {
         idx: Arg<u32>,
     } = 222,
     SetExcInfo = 223,
-    Subscript = 224,
     // CPython 3.14 RESUME (128)
     Resume {
         arg: Arg<u32>,
@@ -441,17 +433,9 @@ impl TryFrom<u8> for Instruction {
             u8::from(Self::Continue {
                 target: Arg::marker(),
             }),
-            u8::from(Self::JumpIfFalseOrPop {
-                target: Arg::marker(),
-            }),
-            u8::from(Self::JumpIfTrueOrPop {
-                target: Arg::marker(),
-            }),
             u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
-            u8::from(Self::LoadAssertionError),
             u8::from(Self::ReturnConst { idx: Arg::marker() }),
             u8::from(Self::SetExcInfo),
-            u8::from(Self::Subscript),
         ];
 
         if (cpython_start..=cpython_end).contains(&value)
@@ -478,8 +462,6 @@ impl InstructionMetadata for Instruction {
             | Self::JumpIfNotExcMatch(l)
             | Self::PopJumpIfTrue { target: l }
             | Self::PopJumpIfFalse { target: l }
-            | Self::JumpIfTrueOrPop { target: l }
-            | Self::JumpIfFalseOrPop { target: l }
             | Self::ForIter { target: l }
             | Self::Break { target: l }
             | Self::Continue { target: l }
@@ -525,7 +507,6 @@ impl InstructionMetadata for Instruction {
             Self::DeleteGlobal(_) => 0,
             Self::DeleteDeref(_) => 0,
             Self::LoadFromDictOrDeref(_) => 1,
-            Self::Subscript => -1,
             Self::StoreSubscr => -3,
             Self::DeleteSubscr => -2,
             Self::LoadAttr { .. } => 0,
@@ -551,20 +532,6 @@ impl InstructionMetadata for Instruction {
             Self::Break { .. } => 0,
             Self::PopJumpIfTrue { .. } => -1,
             Self::PopJumpIfFalse { .. } => -1,
-            Self::JumpIfTrueOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
-            Self::JumpIfFalseOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
             Self::MakeFunction => {
                 // CPython 3.14 style: MakeFunction only pops code object
                 -1 + 1 // pop code, push function
@@ -584,11 +551,9 @@ impl InstructionMetadata for Instruction {
             Self::FormatSimple => 0,
             Self::FormatWithSpec => -1,
             Self::ForIter { .. } => {
-                if jump {
-                    -1
-                } else {
-                    1
-                }
+                // jump=False: push next value (+1)
+                // jump=True: iterator stays on stack, no change (0)
+                if jump { 0 } else { 1 }
             }
             Self::IsOp(_) => -1,
             Self::ContainsOp(_) => -1,
@@ -684,7 +649,6 @@ impl InstructionMetadata for Instruction {
             Self::EndFor => 0,
             Self::ExitInitCheck => 0,
             Self::InterpreterExit => 0,
-            Self::LoadAssertionError => 0,
             Self::LoadLocals => 0,
             Self::ReturnGenerator => 0,
             Self::StoreSlice => 0,
@@ -920,9 +884,7 @@ impl InstructionMetadata for Instruction {
             Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
             Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
             Self::JumpForward { target } => w!(JUMP_FORWARD, target),
-            Self::JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
             Self::JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            Self::JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
             Self::ListAppend { i } => w!(LIST_APPEND, i),
             Self::ListExtend { i } => w!(LIST_EXTEND, i),
             Self::LoadAttr { idx } => {
@@ -994,7 +956,6 @@ impl InstructionMetadata for Instruction {
             Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
             Self::StoreName(idx) => w!(STORE_NAME, name = idx),
             Self::StoreSubscr => w!(STORE_SUBSCR),
-            Self::Subscript => w!(SUBSCRIPT),
             Self::Swap { index } => w!(SWAP, index),
             Self::ToBool => w!(TO_BOOL),
             Self::UnpackEx { args } => w!(UNPACK_EX, args),
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
index 92d5d407aff..87ff871b732 100644
--- a/crates/stdlib/src/opcode.rs
+++ b/crates/stdlib/src/opcode.rs
@@ -107,9 +107,7 @@ mod opcode {
                     Instruction::Break { .. }
                         | Instruction::Continue { .. }
                         | Instruction::ForIter { .. }
-                        | Instruction::JumpIfFalseOrPop { .. }
                         | Instruction::JumpIfNotExcMatch(_)
-                        | Instruction::JumpIfTrueOrPop { .. }
                         | Instruction::PopJumpIfFalse { .. }
                         | Instruction::PopJumpIfTrue { .. }
                         | Instruction::Send { .. }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index ea9177a3d7c..5f9343689a0 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -1139,9 +1139,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            Instruction::JumpIfFalseOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), false)
-            }
             Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -1165,9 +1162,6 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            Instruction::JumpIfTrueOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), true)
-            }
             Instruction::JumpForward { target } => {
                 self.jump(target.get(arg));
                 Ok(None)
@@ -1734,7 +1728,6 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::StoreSubscr => self.execute_store_subscript(vm),
-            Instruction::Subscript => self.execute_subscript(vm),
             Instruction::Swap { index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
@@ -2074,14 +2067,6 @@ impl ExecutingFrame<'_> {
         }
     }
 
-    fn execute_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let b_ref = self.pop_value();
-        let a_ref = self.pop_value();
-        let value = a_ref.get_item(&*b_ref, vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
     fn execute_store_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
         let idx = self.pop_value();
         let obj = self.pop_value();
@@ -2351,23 +2336,6 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    #[inline]
-    fn jump_if_or_pop(
-        &mut self,
-        vm: &VirtualMachine,
-        target: bytecode::Label,
-        flag: bool,
-    ) -> FrameResult {
-        let obj = self.top_value();
-        let value = obj.to_owned().try_to_bool(vm)?;
-        if value == flag {
-            self.jump(target);
-        } else {
-            self.pop_value();
-        }
-        Ok(None)
-    }
-
     /// The top of stack contains the iterator, lets push it forward
     fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
         let top_of_stack = PyIter::new(self.top_value());
@@ -2380,15 +2348,13 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Ok(PyIterReturn::StopIteration(_)) => {
-                // Pop iterator from stack:
-                self.pop_value();
-
-                // End of for loop
+                // CPython 3.14: Do NOT pop iterator here
+                // POP_ITER instruction will handle cleanup after the loop
                 self.jump(target);
                 Ok(None)
             }
             Err(next_error) => {
-                // Pop iterator from stack:
+                // On error, pop iterator and propagate
                 self.pop_value();
                 Err(next_error)
             }

From b472e88caf17d4de82b4950b03c2da70d54949a3 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 13:51:52 +0900
Subject: [PATCH 409/418] classmethod/staticmethod __annotate__

---
 crates/vm/src/builtins/classmethod.rs  | 23 ++++++++++++++++++++++-
 crates/vm/src/builtins/staticmethod.rs | 23 ++++++++++++++++++++++-
 crates/vm/src/builtins/type.rs         | 12 +++++++-----
 3 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/crates/vm/src/builtins/classmethod.rs b/crates/vm/src/builtins/classmethod.rs
index 5b7f9218658..d2f1377be04 100644
--- a/crates/vm/src/builtins/classmethod.rs
+++ b/crates/vm/src/builtins/classmethod.rs
@@ -3,7 +3,7 @@ use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     common::lock::PyMutex,
-    function::FuncArgs,
+    function::{FuncArgs, PySetterValue},
     types::{Constructor, GetDescriptor, Initializer, Representable},
 };
 
@@ -158,6 +158,27 @@ impl PyClassMethod {
         self.callable.lock().get_attr("__annotations__", vm)
     }
 
+    #[pygetset(setter)]
+    fn set___annotations__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(v) => self.callable.lock().set_attr("__annotations__", v, vm),
+            PySetterValue::Delete => Ok(()), // Silently ignore delete like CPython
+        }
+    }
+
+    #[pygetset]
+    fn __annotate__(&self, vm: &VirtualMachine) -> PyResult {
+        self.callable.lock().get_attr("__annotate__", vm)
+    }
+
+    #[pygetset(setter)]
+    fn set___annotate__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(v) => self.callable.lock().set_attr("__annotate__", v, vm),
+            PySetterValue::Delete => Ok(()), // Silently ignore delete like CPython
+        }
+    }
+
     #[pygetset]
     fn __isabstractmethod__(&self, vm: &VirtualMachine) -> PyObjectRef {
         match vm.get_attribute_opt(self.callable.lock().clone(), "__isabstractmethod__") {
diff --git a/crates/vm/src/builtins/staticmethod.rs b/crates/vm/src/builtins/staticmethod.rs
index 5d2474a567c..ac363415a9f 100644
--- a/crates/vm/src/builtins/staticmethod.rs
+++ b/crates/vm/src/builtins/staticmethod.rs
@@ -3,7 +3,7 @@ use crate::{
     Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     common::lock::PyMutex,
-    function::FuncArgs,
+    function::{FuncArgs, PySetterValue},
     types::{Callable, Constructor, GetDescriptor, Initializer, Representable},
 };
 
@@ -121,6 +121,27 @@ impl PyStaticMethod {
         self.callable.lock().get_attr("__annotations__", vm)
     }
 
+    #[pygetset(setter)]
+    fn set___annotations__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(v) => self.callable.lock().set_attr("__annotations__", v, vm),
+            PySetterValue::Delete => Ok(()), // Silently ignore delete like CPython
+        }
+    }
+
+    #[pygetset]
+    fn __annotate__(&self, vm: &VirtualMachine) -> PyResult {
+        self.callable.lock().get_attr("__annotate__", vm)
+    }
+
+    #[pygetset(setter)]
+    fn set___annotate__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(v) => self.callable.lock().set_attr("__annotate__", v, vm),
+            PySetterValue::Delete => Ok(()), // Silently ignore delete like CPython
+        }
+    }
+
     #[pygetset]
     fn __isabstractmethod__(&self, vm: &VirtualMachine) -> PyObjectRef {
         match vm.get_attribute_opt(self.callable.lock().clone(), "__isabstractmethod__") {
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
index 510c3fb8491..3fe396932ce 100644
--- a/crates/vm/src/builtins/type.rs
+++ b/crates/vm/src/builtins/type.rs
@@ -876,11 +876,13 @@ impl PyType {
     }
 
     #[pygetset(setter)]
-    fn set___annotate__(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
-        if value.is_none() {
-            return Err(vm.new_type_error("cannot delete __annotate__ attribute".to_owned()));
-        }
-        let value = value.unwrap();
+    fn set___annotate__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        let value = match value {
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("cannot delete __annotate__ attribute".to_owned()));
+            }
+            PySetterValue::Assign(v) => v,
+        };
 
         if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
             return Err(vm.new_type_error(format!(

From 4d27603cb5772c66e3859350eef3d8bf9ed87636 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 13:04:21 +0900
Subject: [PATCH 410/418] fix functools.reduce

---
 crates/vm/src/stdlib/functools.rs | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/crates/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
index 5adc0fe9690..307f7760f60 100644
--- a/crates/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -6,7 +6,7 @@ mod _functools {
         Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
         builtins::{PyBoundMethod, PyDict, PyGenericAlias, PyTuple, PyType, PyTypeRef},
         common::lock::PyRwLock,
-        function::{FuncArgs, KwArgs, OptionalArg},
+        function::{FuncArgs, KwArgs, OptionalOption},
         object::AsObject,
         protocol::PyIter,
         pyclass,
@@ -15,17 +15,31 @@ mod _functools {
     };
     use indexmap::IndexMap;
 
-    #[pyfunction]
-    fn reduce(
+    #[derive(FromArgs)]
+    struct ReduceArgs {
         function: PyObjectRef,
         iterator: PyIter,
-        start_value: OptionalArg<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
+        #[pyarg(any, optional, name = "initial")]
+        initial: OptionalOption<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn reduce(args: ReduceArgs, vm: &VirtualMachine) -> PyResult {
+        let ReduceArgs {
+            function,
+            iterator,
+            initial,
+        } = args;
         let mut iter = iterator.iter_without_hint(vm)?;
-        let start_value = if let OptionalArg::Present(val) = start_value {
-            val
+        // OptionalOption distinguishes between:
+        // - Missing: no argument provided → use first element from iterator
+        // - Present(None): explicitly passed None → use None as initial value
+        // - Present(Some(v)): passed a value → use that value
+        let start_value = if let Some(val) = initial.into_option() {
+            // initial was provided (could be None or Some value)
+            val.unwrap_or_else(|| vm.ctx.none())
         } else {
+            // initial was not provided at all
             iter.next().transpose()?.ok_or_else(|| {
                 let exc_type = vm.ctx.exceptions.type_error.to_owned();
                 vm.new_exception_msg(

From 40c29f689fb4bb9c4da5d3f4035a1b22c1ff4bcc Mon Sep 17 00:00:00 2001
From: CPython Developers <>
Date: Tue, 20 Jan 2026 03:52:26 +0900
Subject: [PATCH 411/418] Update functools from v3.14.2

---
 Lib/functools.py           | 380 +++++++++++++++++++++++------------
 Lib/test/test_functools.py | 395 ++++++++++++++++++++++++++++++++-----
 2 files changed, 597 insertions(+), 178 deletions(-)

diff --git a/Lib/functools.py b/Lib/functools.py
index 4c1175b815d..df4660eef3f 100644
--- a/Lib/functools.py
+++ b/Lib/functools.py
@@ -6,23 +6,22 @@
 # Written by Nick Coghlan <ncoghlan at gmail.com>,
 # Raymond Hettinger <python at rcn.com>,
 # and �ukasz Langa <lukasz at langa.pl>.
-#   Copyright (C) 2006-2013 Python Software Foundation.
+#   Copyright (C) 2006 Python Software Foundation.
 # See C source code for _functools credits/copyright
 
 __all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES',
            'total_ordering', 'cache', 'cmp_to_key', 'lru_cache', 'reduce',
            'partial', 'partialmethod', 'singledispatch', 'singledispatchmethod',
-           'cached_property']
+           'cached_property', 'Placeholder']
 
 from abc import get_cache_token
 from collections import namedtuple
-# import types, weakref  # Deferred to single_dispatch()
+# import weakref  # Deferred to single_dispatch()
+from operator import itemgetter
 from reprlib import recursive_repr
+from types import GenericAlias, MethodType, MappingProxyType, UnionType
 from _thread import RLock
 
-# Avoid importing types, so we can speedup import time
-GenericAlias = type(list[int])
-
 ################################################################################
 ### update_wrapper() and wraps() decorator
 ################################################################################
@@ -31,7 +30,7 @@
 # wrapper functions that can handle naive introspection
 
 WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
-                       '__annotations__', '__type_params__')
+                       '__annotate__', '__type_params__')
 WRAPPER_UPDATES = ('__dict__',)
 def update_wrapper(wrapper,
                    wrapped,
@@ -237,7 +236,7 @@ def __ge__(self, other):
 
 def reduce(function, sequence, initial=_initial_missing):
     """
-    reduce(function, iterable[, initial], /) -> value
+    reduce(function, iterable, /[, initial]) -> value
 
     Apply a function of two arguments cumulatively to the items of an iterable, from left to right.
 
@@ -265,63 +264,138 @@ def reduce(function, sequence, initial=_initial_missing):
 
     return value
 
-try:
-    from _functools import reduce
-except ImportError:
-    pass
-
 
 ################################################################################
 ### partial() argument application
 ################################################################################
 
-# Purely functional, no descriptor behaviour
-class partial:
-    """New function with partial application of the given arguments
-    and keywords.
+
+class _PlaceholderType:
+    """The type of the Placeholder singleton.
+
+    Used as a placeholder for partial arguments.
     """
+    __instance = None
+    __slots__ = ()
 
-    __slots__ = "func", "args", "keywords", "__dict__", "__weakref__"
+    def __init_subclass__(cls, *args, **kwargs):
+        raise TypeError(f"type '{cls.__name__}' is not an acceptable base type")
 
-    def __new__(cls, func, /, *args, **keywords):
+    def __new__(cls):
+        if cls.__instance is None:
+            cls.__instance = object.__new__(cls)
+        return cls.__instance
+
+    def __repr__(self):
+        return 'Placeholder'
+
+    def __reduce__(self):
+        return 'Placeholder'
+
+Placeholder = _PlaceholderType()
+
+def _partial_prepare_merger(args):
+    if not args:
+        return 0, None
+    nargs = len(args)
+    order = []
+    j = nargs
+    for i, a in enumerate(args):
+        if a is Placeholder:
+            order.append(j)
+            j += 1
+        else:
+            order.append(i)
+    phcount = j - nargs
+    merger = itemgetter(*order) if phcount else None
+    return phcount, merger
+
+def _partial_new(cls, func, /, *args, **keywords):
+    if issubclass(cls, partial):
+        base_cls = partial
         if not callable(func):
             raise TypeError("the first argument must be callable")
+    else:
+        base_cls = partialmethod
+        # func could be a descriptor like classmethod which isn't callable
+        if not callable(func) and not hasattr(func, "__get__"):
+            raise TypeError(f"the first argument {func!r} must be a callable "
+                            "or a descriptor")
+    if args and args[-1] is Placeholder:
+        raise TypeError("trailing Placeholders are not allowed")
+    for value in keywords.values():
+        if value is Placeholder:
+            raise TypeError("Placeholder cannot be passed as a keyword argument")
+    if isinstance(func, base_cls):
+        pto_phcount = func._phcount
+        tot_args = func.args
+        if args:
+            tot_args += args
+            if pto_phcount:
+                # merge args with args of `func` which is `partial`
+                nargs = len(args)
+                if nargs < pto_phcount:
+                    tot_args += (Placeholder,) * (pto_phcount - nargs)
+                tot_args = func._merger(tot_args)
+                if nargs > pto_phcount:
+                    tot_args += args[pto_phcount:]
+            phcount, merger = _partial_prepare_merger(tot_args)
+        else:   # works for both pto_phcount == 0 and != 0
+            phcount, merger = pto_phcount, func._merger
+        keywords = {**func.keywords, **keywords}
+        func = func.func
+    else:
+        tot_args = args
+        phcount, merger = _partial_prepare_merger(tot_args)
+
+    self = object.__new__(cls)
+    self.func = func
+    self.args = tot_args
+    self.keywords = keywords
+    self._phcount = phcount
+    self._merger = merger
+    return self
+
+def _partial_repr(self):
+    cls = type(self)
+    module = cls.__module__
+    qualname = cls.__qualname__
+    args = [repr(self.func)]
+    args.extend(map(repr, self.args))
+    args.extend(f"{k}={v!r}" for k, v in self.keywords.items())
+    return f"{module}.{qualname}({', '.join(args)})"
 
-        if isinstance(func, partial):
-            args = func.args + args
-            keywords = {**func.keywords, **keywords}
-            func = func.func
+# Purely functional, no descriptor behaviour
+class partial:
+    """New function with partial application of the given arguments
+    and keywords.
+    """
 
-        self = super(partial, cls).__new__(cls)
+    __slots__ = ("func", "args", "keywords", "_phcount", "_merger",
+                 "__dict__", "__weakref__")
 
-        self.func = func
-        self.args = args
-        self.keywords = keywords
-        return self
+    __new__ = _partial_new
+    __repr__ = recursive_repr()(_partial_repr)
 
     def __call__(self, /, *args, **keywords):
+        phcount = self._phcount
+        if phcount:
+            try:
+                pto_args = self._merger(self.args + args)
+                args = args[phcount:]
+            except IndexError:
+                raise TypeError("missing positional arguments "
+                                "in 'partial' call; expected "
+                                f"at least {phcount}, got {len(args)}")
+        else:
+            pto_args = self.args
         keywords = {**self.keywords, **keywords}
-        return self.func(*self.args, *args, **keywords)
-
-    @recursive_repr()
-    def __repr__(self):
-        cls = type(self)
-        qualname = cls.__qualname__
-        module = cls.__module__
-        args = [repr(self.func)]
-        args.extend(repr(x) for x in self.args)
-        args.extend(f"{k}={v!r}" for (k, v) in self.keywords.items())
-        return f"{module}.{qualname}({', '.join(args)})"
+        return self.func(*pto_args, *args, **keywords)
 
     def __get__(self, obj, objtype=None):
         if obj is None:
             return self
-        import warnings
-        warnings.warn('functools.partial will be a method descriptor in '
-                      'future Python versions; wrap it in staticmethod() '
-                      'if you want to preserve the old behavior',
-                      FutureWarning, 2)
-        return self
+        return MethodType(self, obj)
 
     def __reduce__(self):
         return type(self), (self.func,), (self.func, self.args,
@@ -338,6 +412,10 @@ def __setstate__(self, state):
            (namespace is not None and not isinstance(namespace, dict))):
             raise TypeError("invalid partial state")
 
+        if args and args[-1] is Placeholder:
+            raise TypeError("trailing Placeholders are not allowed")
+        phcount, merger = _partial_prepare_merger(args)
+
         args = tuple(args) # just in case it's a subclass
         if kwds is None:
             kwds = {}
@@ -350,56 +428,43 @@ def __setstate__(self, state):
         self.func = func
         self.args = args
         self.keywords = kwds
+        self._phcount = phcount
+        self._merger = merger
 
     __class_getitem__ = classmethod(GenericAlias)
 
 
 try:
-    from _functools import partial
+    from _functools import partial, Placeholder, _PlaceholderType
 except ImportError:
     pass
 
 # Descriptor version
-class partialmethod(object):
+class partialmethod:
     """Method descriptor with partial application of the given arguments
     and keywords.
 
     Supports wrapping existing descriptors and handles non-descriptor
     callables as instance methods.
     """
-
-    def __init__(self, func, /, *args, **keywords):
-        if not callable(func) and not hasattr(func, "__get__"):
-            raise TypeError("{!r} is not callable or a descriptor"
-                                 .format(func))
-
-        # func could be a descriptor like classmethod which isn't callable,
-        # so we can't inherit from partial (it verifies func is callable)
-        if isinstance(func, partialmethod):
-            # flattening is mandatory in order to place cls/self before all
-            # other arguments
-            # it's also more efficient since only one function will be called
-            self.func = func.func
-            self.args = func.args + args
-            self.keywords = {**func.keywords, **keywords}
-        else:
-            self.func = func
-            self.args = args
-            self.keywords = keywords
-
-    def __repr__(self):
-        cls = type(self)
-        module = cls.__module__
-        qualname = cls.__qualname__
-        args = [repr(self.func)]
-        args.extend(map(repr, self.args))
-        args.extend(f"{k}={v!r}" for k, v in self.keywords.items())
-        return f"{module}.{qualname}({', '.join(args)})"
+    __new__ = _partial_new
+    __repr__ = _partial_repr
 
     def _make_unbound_method(self):
         def _method(cls_or_self, /, *args, **keywords):
+            phcount = self._phcount
+            if phcount:
+                try:
+                    pto_args = self._merger(self.args + args)
+                    args = args[phcount:]
+                except IndexError:
+                    raise TypeError("missing positional arguments "
+                                    "in 'partialmethod' call; expected "
+                                    f"at least {phcount}, got {len(args)}")
+            else:
+                pto_args = self.args
             keywords = {**self.keywords, **keywords}
-            return self.func(cls_or_self, *self.args, *args, **keywords)
+            return self.func(cls_or_self, *pto_args, *args, **keywords)
         _method.__isabstractmethod__ = self.__isabstractmethod__
         _method.__partialmethod__ = self
         return _method
@@ -407,7 +472,7 @@ def _method(cls_or_self, /, *args, **keywords):
     def __get__(self, obj, cls=None):
         get = getattr(self.func, "__get__", None)
         result = None
-        if get is not None and not isinstance(self.func, partial):
+        if get is not None:
             new_func = get(obj, cls)
             if new_func is not self.func:
                 # Assume __get__ returning something new indicates the
@@ -454,22 +519,6 @@ def _unwrap_partialmethod(func):
 
 _CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize"])
 
-class _HashedSeq(list):
-    """ This class guarantees that hash() will be called no more than once
-        per element.  This is important because the lru_cache() will hash
-        the key multiple times on a cache miss.
-
-    """
-
-    __slots__ = 'hashvalue'
-
-    def __init__(self, tup, hash=hash):
-        self[:] = tup
-        self.hashvalue = hash(tup)
-
-    def __hash__(self):
-        return self.hashvalue
-
 def _make_key(args, kwds, typed,
              kwd_mark = (object(),),
              fasttypes = {int, str},
@@ -499,7 +548,7 @@ def _make_key(args, kwds, typed,
             key += tuple(type(v) for v in kwds.values())
     elif len(key) == 1 and type(key[0]) in fasttypes:
         return key[0]
-    return _HashedSeq(key)
+    return key
 
 def lru_cache(maxsize=128, typed=False):
     """Least-recently-used cache decorator.
@@ -835,7 +884,7 @@ def singledispatch(func):
     # There are many programs that use functools without singledispatch, so we
     # trade-off making singledispatch marginally slower for the benefit of
     # making start-up of such applications slightly faster.
-    import types, weakref
+    import weakref
 
     registry = {}
     dispatch_cache = weakref.WeakKeyDictionary()
@@ -864,16 +913,11 @@ def dispatch(cls):
             dispatch_cache[cls] = impl
         return impl
 
-    def _is_union_type(cls):
-        from typing import get_origin, Union
-        return get_origin(cls) in {Union, types.UnionType}
-
     def _is_valid_dispatch_type(cls):
         if isinstance(cls, type):
             return True
-        from typing import get_args
-        return (_is_union_type(cls) and
-                all(isinstance(arg, type) for arg in get_args(cls)))
+        return (isinstance(cls, UnionType) and
+                all(isinstance(arg, type) for arg in cls.__args__))
 
     def register(cls, func=None):
         """generic_func.register(cls, func) -> func
@@ -891,8 +935,8 @@ def register(cls, func=None):
                     f"Invalid first argument to `register()`. "
                     f"{cls!r} is not a class or union type."
                 )
-            ann = getattr(cls, '__annotations__', {})
-            if not ann:
+            ann = getattr(cls, '__annotate__', None)
+            if ann is None:
                 raise TypeError(
                     f"Invalid first argument to `register()`: {cls!r}. "
                     f"Use either `@register(some_class)` or plain `@register` "
@@ -902,23 +946,27 @@ def register(cls, func=None):
 
             # only import typing if annotation parsing is necessary
             from typing import get_type_hints
-            argname, cls = next(iter(get_type_hints(func).items()))
+            from annotationlib import Format, ForwardRef
+            argname, cls = next(iter(get_type_hints(func, format=Format.FORWARDREF).items()))
             if not _is_valid_dispatch_type(cls):
-                if _is_union_type(cls):
+                if isinstance(cls, UnionType):
                     raise TypeError(
                         f"Invalid annotation for {argname!r}. "
                         f"{cls!r} not all arguments are classes."
                     )
+                elif isinstance(cls, ForwardRef):
+                    raise TypeError(
+                        f"Invalid annotation for {argname!r}. "
+                        f"{cls!r} is an unresolved forward reference."
+                    )
                 else:
                     raise TypeError(
                         f"Invalid annotation for {argname!r}. "
                         f"{cls!r} is not a class."
                     )
 
-        if _is_union_type(cls):
-            from typing import get_args
-
-            for arg in get_args(cls):
+        if isinstance(cls, UnionType):
+            for arg in cls.__args__:
                 registry[arg] = func
         else:
             registry[cls] = func
@@ -937,7 +985,7 @@ def wrapper(*args, **kw):
     registry[object] = func
     wrapper.register = register
     wrapper.dispatch = dispatch
-    wrapper.registry = types.MappingProxyType(registry)
+    wrapper.registry = MappingProxyType(registry)
     wrapper._clear_cache = dispatch_cache.clear
     update_wrapper(wrapper, func)
     return wrapper
@@ -947,8 +995,7 @@ def wrapper(*args, **kw):
 class singledispatchmethod:
     """Single-dispatch generic method descriptor.
 
-    Supports wrapping existing descriptors and handles non-descriptor
-    callables as instance methods.
+    Supports wrapping existing descriptors.
     """
 
     def __init__(self, func):
@@ -966,24 +1013,77 @@ def register(self, cls, method=None):
         return self.dispatcher.register(cls, func=method)
 
     def __get__(self, obj, cls=None):
-        dispatch = self.dispatcher.dispatch
-        funcname = getattr(self.func, '__name__', 'singledispatchmethod method')
-        def _method(*args, **kwargs):
-            if not args:
-                raise TypeError(f'{funcname} requires at least '
-                                '1 positional argument')
-            return dispatch(args[0].__class__).__get__(obj, cls)(*args, **kwargs)
-
-        _method.__isabstractmethod__ = self.__isabstractmethod__
-        _method.register = self.register
-        update_wrapper(_method, self.func)
-
-        return _method
+        return _singledispatchmethod_get(self, obj, cls)
 
     @property
     def __isabstractmethod__(self):
         return getattr(self.func, '__isabstractmethod__', False)
 
+    def __repr__(self):
+        try:
+            name = self.func.__qualname__
+        except AttributeError:
+            try:
+                name = self.func.__name__
+            except AttributeError:
+                name = '?'
+        return f'<single dispatch method descriptor {name}>'
+
+class _singledispatchmethod_get:
+    def __init__(self, unbound, obj, cls):
+        self._unbound = unbound
+        self._dispatch = unbound.dispatcher.dispatch
+        self._obj = obj
+        self._cls = cls
+        # Set instance attributes which cannot be handled in __getattr__()
+        # because they conflict with type descriptors.
+        func = unbound.func
+        try:
+            self.__module__ = func.__module__
+        except AttributeError:
+            pass
+        try:
+            self.__doc__ = func.__doc__
+        except AttributeError:
+            pass
+
+    def __repr__(self):
+        try:
+            name = self.__qualname__
+        except AttributeError:
+            try:
+                name = self.__name__
+            except AttributeError:
+                name = '?'
+        if self._obj is not None:
+            return f'<bound single dispatch method {name} of {self._obj!r}>'
+        else:
+            return f'<single dispatch method {name}>'
+
+    def __call__(self, /, *args, **kwargs):
+        if not args:
+            funcname = getattr(self._unbound.func, '__name__',
+                               'singledispatchmethod method')
+            raise TypeError(f'{funcname} requires at least '
+                            '1 positional argument')
+        return self._dispatch(args[0].__class__).__get__(self._obj, self._cls)(*args, **kwargs)
+
+    def __getattr__(self, name):
+        # Resolve these attributes lazily to speed up creation of
+        # the _singledispatchmethod_get instance.
+        if name not in {'__name__', '__qualname__', '__isabstractmethod__',
+                        '__annotations__', '__type_params__'}:
+            raise AttributeError
+        return getattr(self._unbound.func, name)
+
+    @property
+    def __wrapped__(self):
+        return self._unbound.func
+
+    @property
+    def register(self):
+        return self._unbound.register
+
 
 ################################################################################
 ### cached_property() - property result cached as instance attribute
@@ -1035,3 +1135,31 @@ def __get__(self, instance, owner=None):
         return val
 
     __class_getitem__ = classmethod(GenericAlias)
+
+def _warn_python_reduce_kwargs(py_reduce):
+    @wraps(py_reduce)
+    def wrapper(*args, **kwargs):
+        if 'function' in kwargs or 'sequence' in kwargs:
+            import os
+            import warnings
+            warnings.warn(
+                'Calling functools.reduce with keyword arguments '
+                '"function" or "sequence" '
+                'is deprecated in Python 3.14 and will be '
+                'forbidden in Python 3.16.',
+                DeprecationWarning,
+                skip_file_prefixes=(os.path.dirname(__file__),))
+        return py_reduce(*args, **kwargs)
+    return wrapper
+
+reduce = _warn_python_reduce_kwargs(reduce)
+del _warn_python_reduce_kwargs
+
+# The import of the C accelerated version of reduce() has been moved
+# here due to gh-121676. In Python 3.16, _warn_python_reduce_kwargs()
+# should be removed and the import block should be moved back right
+# after the definition of reduce().
+try:
+    from _functools import reduce
+except ImportError:
+    pass
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index bf3e24481ca..88964fec1e6 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -1,4 +1,5 @@
 import abc
+from annotationlib import Format, get_annotations
 import builtins
 import collections
 import collections.abc
@@ -6,6 +7,7 @@
 from itertools import permutations
 import pickle
 from random import choice
+import re
 import sys
 from test import support
 import threading
@@ -19,8 +21,11 @@
 import contextlib
 from inspect import Signature
 
+from test.support import ALWAYS_EQ
 from test.support import import_helper
 from test.support import threading_helper
+from test.support import cpython_only
+from test.support import EqualToForwardRef
 
 import functools
 
@@ -60,6 +65,14 @@ def __add__(self, other):
 class MyDict(dict):
     pass
 
+class TestImportTime(unittest.TestCase):
+
+    @cpython_only
+    def test_lazy_import(self):
+        import_helper.ensure_lazy_imports(
+            "functools", {"os", "weakref", "typing", "annotationlib", "warnings"}
+        )
+
 
 class TestPartial:
 
@@ -210,6 +223,69 @@ def foo(bar):
         p2.new_attr = 'spam'
         self.assertEqual(p2.new_attr, 'spam')
 
+    def test_placeholders_trailing_raise(self):
+        PH = self.module.Placeholder
+        for args in [(PH,), (0, PH), (0, PH, 1, PH, PH, PH)]:
+            with self.assertRaises(TypeError):
+                self.partial(capture, *args)
+
+    def test_placeholders(self):
+        PH = self.module.Placeholder
+        # 1 Placeholder
+        args = (PH, 0)
+        p = self.partial(capture, *args)
+        actual_args, actual_kwds = p('x')
+        self.assertEqual(actual_args, ('x', 0))
+        self.assertEqual(actual_kwds, {})
+        # 2 Placeholders
+        args = (PH, 0, PH, 1)
+        p = self.partial(capture, *args)
+        with self.assertRaises(TypeError):
+            p('x')
+        actual_args, actual_kwds = p('x', 'y')
+        self.assertEqual(actual_args, ('x', 0, 'y', 1))
+        self.assertEqual(actual_kwds, {})
+        # Checks via `is` and not `eq`
+        # thus ALWAYS_EQ isn't treated as Placeholder
+        p = self.partial(capture, ALWAYS_EQ)
+        actual_args, actual_kwds = p()
+        self.assertEqual(len(actual_args), 1)
+        self.assertIs(actual_args[0], ALWAYS_EQ)
+        self.assertEqual(actual_kwds, {})
+
+    def test_placeholders_optimization(self):
+        PH = self.module.Placeholder
+        p = self.partial(capture, PH, 0)
+        p2 = self.partial(p, PH, 1, 2, 3)
+        self.assertEqual(p2.args, (PH, 0, 1, 2, 3))
+        p3 = self.partial(p2, -1, 4)
+        actual_args, actual_kwds = p3(5)
+        self.assertEqual(actual_args, (-1, 0, 1, 2, 3, 4, 5))
+        self.assertEqual(actual_kwds, {})
+        # inner partial has placeholders and outer partial has no args case
+        p = self.partial(capture, PH, 0)
+        p2 = self.partial(p)
+        self.assertEqual(p2.args, (PH, 0))
+        self.assertEqual(p2(1), ((1, 0), {}))
+
+    def test_placeholders_kw_restriction(self):
+        PH = self.module.Placeholder
+        with self.assertRaisesRegex(TypeError, "Placeholder"):
+            self.partial(capture, a=PH)
+        # Passes, as checks via `is` and not `eq`
+        p = self.partial(capture, a=ALWAYS_EQ)
+        actual_args, actual_kwds = p()
+        self.assertEqual(actual_args, ())
+        self.assertEqual(len(actual_kwds), 1)
+        self.assertIs(actual_kwds['a'], ALWAYS_EQ)
+
+    def test_construct_placeholder_singleton(self):
+        PH = self.module.Placeholder
+        tp = type(PH)
+        self.assertIs(tp(), PH)
+        self.assertRaises(TypeError, tp, 1, 2)
+        self.assertRaises(TypeError, tp, a=1, b=2)
+
     def test_repr(self):
         args = (object(), object())
         args_repr = ', '.join(repr(a) for a in args)
@@ -311,8 +387,26 @@ def test_setstate(self):
         self.assertEqual(f(2), ((2,), {}))
         self.assertEqual(f(), ((), {}))
 
+        # Set State with placeholders
+        PH = self.module.Placeholder
+        f = self.partial(signature)
+        f.__setstate__((capture, (PH, 1), dict(a=10), dict(attr=[])))
+        self.assertEqual(signature(f), (capture, (PH, 1), dict(a=10), dict(attr=[])))
+        msg_regex = re.escape("missing positional arguments in 'partial' call; "
+                              "expected at least 1, got 0")
+        with self.assertRaisesRegex(TypeError, f'^{msg_regex}$') as cm:
+            f()
+        self.assertEqual(f(2), ((2, 1), dict(a=10)))
+
+        # Trailing Placeholder error
+        f = self.partial(signature)
+        msg_regex = re.escape("trailing Placeholders are not allowed")
+        with self.assertRaisesRegex(TypeError, f'^{msg_regex}$') as cm:
+            f.__setstate__((capture, (1, PH), dict(a=10), dict(attr=[])))
+
     def test_setstate_errors(self):
         f = self.partial(signature)
+
         self.assertRaises(TypeError, f.__setstate__, (capture, (), {}))
         self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, {}, None))
         self.assertRaises(TypeError, f.__setstate__, [capture, (), {}, None])
@@ -320,6 +414,8 @@ def test_setstate_errors(self):
         self.assertRaises(TypeError, f.__setstate__, (capture, None, {}, None))
         self.assertRaises(TypeError, f.__setstate__, (capture, [], {}, None))
         self.assertRaises(TypeError, f.__setstate__, (capture, (), [], None))
+        self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, ()))
+        self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, 'test'))
 
     def test_setstate_subclasses(self):
         f = self.partial(signature)
@@ -341,6 +437,8 @@ def test_setstate_subclasses(self):
         self.assertEqual(r, ((1, 2), {}))
         self.assertIs(type(r[0]), tuple)
 
+    @support.skip_if_sanitizer("thread sanitizer crashes in __tsan::FuncEntry", thread=True)
+    @support.skip_emscripten_stack_overflow()
     def test_recursive_pickle(self):
         with replaced_module('functools', self.module):
             f = self.partial(capture)
@@ -395,7 +493,6 @@ def __getitem__(self, key):
         f = self.partial(object)
         self.assertRaises(TypeError, f.__setstate__, BadSequence())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial_as_method(self):
         class A:
             meth = self.partial(capture, 1, a=2)
@@ -406,9 +503,7 @@ class A:
         self.assertEqual(A.meth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
         self.assertEqual(A.cmeth(3, b=4), ((1, A, 3), {'a': 2, 'b': 4}))
         self.assertEqual(A.smeth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
-        with self.assertWarns(FutureWarning) as w:
-            self.assertEqual(a.meth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
-        self.assertEqual(w.filename, __file__)
+        self.assertEqual(a.meth(3, b=4), ((1, a, 3), {'a': 2, 'b': 4}))
         self.assertEqual(a.cmeth(3, b=4), ((1, A, 3), {'a': 2, 'b': 4}))
         self.assertEqual(a.smeth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
 
@@ -465,11 +560,19 @@ def __str__(self):
         self.assertIn('astr', r)
         self.assertIn("['sth']", r)
 
-    def test_repr(self):
-        return super().test_repr()
-
-    def test_recursive_repr(self):
-        return super().test_recursive_repr()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: '_PlaceholderType' object is not iterable
+    def test_placeholders_refcount_smoke(self):
+        PH = self.module.Placeholder
+        # sum supports vector call
+        lst1, start = [], []
+        sum_lists = self.partial(sum, PH, start)
+        for i in range(10):
+            sum_lists([lst1, lst1])
+        # collections.ChainMap initializer does not support vectorcall
+        map1, map2 = {}, {}
+        partial_cm = self.partial(collections.ChainMap, PH, map1)
+        for i in range(10):
+            partial_cm(map2, map2)
 
 
 class TestPartialPy(TestPartial, unittest.TestCase):
@@ -495,6 +598,19 @@ class TestPartialCSubclass(TestPartialC):
 class TestPartialPySubclass(TestPartialPy):
     partial = PyPartialSubclass
 
+    def test_subclass_optimization(self):
+        # `partial` input to `partial` subclass
+        p = py_functools.partial(min, 2)
+        p2 = self.partial(p, 1)
+        self.assertIs(p2.func, min)
+        self.assertEqual(p2(0), 0)
+        # `partial` subclass input to `partial` subclass
+        p = self.partial(min, 2)
+        p2 = self.partial(p, 1)
+        self.assertIs(p2.func, min)
+        self.assertEqual(p2(0), 0)
+
+
 class TestPartialMethod(unittest.TestCase):
 
     class A(object):
@@ -564,11 +680,11 @@ def test_bound_method_introspection(self):
 
     def test_unbound_method_retrieval(self):
         obj = self.A
-        self.assertFalse(hasattr(obj.both, "__self__"))
-        self.assertFalse(hasattr(obj.nested, "__self__"))
-        self.assertFalse(hasattr(obj.over_partial, "__self__"))
-        self.assertFalse(hasattr(obj.static, "__self__"))
-        self.assertFalse(hasattr(self.a.static, "__self__"))
+        self.assertNotHasAttr(obj.both, "__self__")
+        self.assertNotHasAttr(obj.nested, "__self__")
+        self.assertNotHasAttr(obj.over_partial, "__self__")
+        self.assertNotHasAttr(obj.static, "__self__")
+        self.assertNotHasAttr(self.a.static, "__self__")
 
     def test_descriptors(self):
         for obj in [self.A, self.a]:
@@ -632,6 +748,20 @@ def f(a, b, /):
         p = functools.partial(f, 1)
         self.assertEqual(p(2), f(1, 2))
 
+    def test_subclass_optimization(self):
+        class PartialMethodSubclass(functools.partialmethod):
+            pass
+        # `partialmethod` input to `partialmethod` subclass
+        p = functools.partialmethod(min, 2)
+        p2 = PartialMethodSubclass(p, 1)
+        self.assertIs(p2.func, min)
+        self.assertEqual(p2.__get__(0)(), 0)
+        # `partialmethod` subclass input to `partialmethod` subclass
+        p = PartialMethodSubclass(min, 2)
+        p2 = PartialMethodSubclass(p, 1)
+        self.assertIs(p2.func, min)
+        self.assertEqual(p2.__get__(0)(), 0)
+
 
 class TestUpdateWrapper(unittest.TestCase):
 
@@ -696,7 +826,7 @@ def wrapper():
         self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
         self.assertEqual(wrapper.__doc__, None)
         self.assertEqual(wrapper.__annotations__, {})
-        self.assertFalse(hasattr(wrapper, 'attr'))
+        self.assertNotHasAttr(wrapper, 'attr')
 
     def test_selective_update(self):
         def f():
@@ -745,7 +875,7 @@ def wrapper():
             pass
         functools.update_wrapper(wrapper, max)
         self.assertEqual(wrapper.__name__, 'max')
-        self.assertTrue(wrapper.__doc__.startswith('max('))
+        self.assertStartsWith(wrapper.__doc__, 'max(')
         self.assertEqual(wrapper.__annotations__, {})
 
     def test_update_type_wrapper(self):
@@ -756,6 +886,26 @@ def wrapper(*args): pass
         self.assertEqual(wrapper.__annotations__, {})
         self.assertEqual(wrapper.__type_params__, ())
 
+    def test_update_wrapper_annotations(self):
+        def inner(x: int): pass
+        def wrapper(*args): pass
+
+        functools.update_wrapper(wrapper, inner)
+        self.assertEqual(wrapper.__annotations__, {'x': int})
+        self.assertIs(wrapper.__annotate__, inner.__annotate__)
+
+        def with_forward_ref(x: undefined): pass
+        def wrapper(*args): pass
+
+        functools.update_wrapper(wrapper, with_forward_ref)
+
+        self.assertIs(wrapper.__annotate__, with_forward_ref.__annotate__)
+        with self.assertRaises(NameError):
+            wrapper.__annotations__
+
+        undefined = str
+        self.assertEqual(wrapper.__annotations__, {'x': undefined})
+
 
 class TestWraps(TestUpdateWrapper):
 
@@ -795,7 +945,7 @@ def wrapper():
         self.assertEqual(wrapper.__name__, 'wrapper')
         self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
         self.assertEqual(wrapper.__doc__, None)
-        self.assertFalse(hasattr(wrapper, 'attr'))
+        self.assertNotHasAttr(wrapper, 'attr')
 
     def test_selective_update(self):
         def f():
@@ -897,6 +1047,29 @@ def __getitem__(self, i):
         d = {"one": 1, "two": 2, "three": 3}
         self.assertEqual(self.reduce(add, d), "".join(d.keys()))
 
+    # test correctness of keyword usage of `initial` in `reduce`
+    def test_initial_keyword(self):
+        def add(x, y):
+            return x + y
+        self.assertEqual(
+            self.reduce(add, ['a', 'b', 'c'], ''),
+            self.reduce(add, ['a', 'b', 'c'], initial=''),
+        )
+        self.assertEqual(
+            self.reduce(add, [['a', 'c'], [], ['d', 'w']], []),
+            self.reduce(add, [['a', 'c'], [], ['d', 'w']], initial=[]),
+        )
+        self.assertEqual(
+            self.reduce(lambda x, y: x*y, range(2,8), 1),
+            self.reduce(lambda x, y: x*y, range(2,8), initial=1),
+        )
+        self.assertEqual(
+            self.reduce(lambda x, y: x*y, range(2,21), 1),
+            self.reduce(lambda x, y: x*y, range(2,21), initial=1),
+        )
+        self.assertRaises(TypeError, self.reduce, add, [0, 1], initial="")
+        self.assertEqual(self.reduce(42, "", initial="1"), "1") # func is never called with one item
+
 
 @unittest.skipUnless(c_functools, 'requires the C _functools module')
 class TestReduceC(TestReduce, unittest.TestCase):
@@ -907,6 +1080,12 @@ class TestReduceC(TestReduce, unittest.TestCase):
 class TestReducePy(TestReduce, unittest.TestCase):
     reduce = staticmethod(py_functools.reduce)
 
+    def test_reduce_with_kwargs(self):
+        with self.assertWarns(DeprecationWarning):
+            self.reduce(function=lambda x, y: x + y, sequence=[1, 2, 3, 4, 5], initial=1)
+        with self.assertWarns(DeprecationWarning):
+            self.reduce(lambda x, y: x + y, sequence=[1, 2, 3, 4, 5], initial=1)
+
 
 class TestCmpToKey:
 
@@ -1014,35 +1193,35 @@ def test_disallow_instantiation(self):
             self, type(c_functools.cmp_to_key(None))
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_bad_cmp(self):
         return super().test_bad_cmp()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cmp_to_key(self):
         return super().test_cmp_to_key()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cmp_to_key_arguments(self):
         return super().test_cmp_to_key_arguments()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_cmp_to_signature(self):
         return super().test_cmp_to_signature()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_hash(self):
         return super().test_hash()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_obj_field(self):
         return super().test_obj_field()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sort_int(self):
         return super().test_sort_int()
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_sort_int_str(self):
         return super().test_sort_int_str()
 
@@ -1925,7 +2104,6 @@ def f():
             return 1
         self.assertEqual(f.cache_parameters(), {'maxsize': 1000, "typed": True})
 
-    @support.suppress_immortalization()
     def test_lru_cache_weakrefable(self):
         @self.module.lru_cache
         def test_function(x):
@@ -1963,8 +2141,38 @@ def orig(a, /, b, c=True): ...
         self.assertEqual(str(Signature.from_callable(lru.cache_info)), '()')
         self.assertEqual(str(Signature.from_callable(lru.cache_clear)), '()')
 
+    def test_get_annotations(self):
+        def orig(a: int) -> str: ...
+        lru = self.module.lru_cache(1)(orig)
+
+        self.assertEqual(
+            get_annotations(orig), {"a": int, "return": str},
+        )
+        self.assertEqual(
+            get_annotations(lru), {"a": int, "return": str},
+        )
+
+    def test_get_annotations_with_forwardref(self):
+        def orig(a: int) -> nonexistent: ...
+        lru = self.module.lru_cache(1)(orig)
+
+        self.assertEqual(
+            get_annotations(orig, format=Format.FORWARDREF),
+            {"a": int, "return": EqualToForwardRef('nonexistent', owner=orig)},
+        )
+        self.assertEqual(
+            get_annotations(lru, format=Format.FORWARDREF),
+            {"a": int, "return": EqualToForwardRef('nonexistent', owner=lru)},
+        )
+        with self.assertRaises(NameError):
+            get_annotations(orig, format=Format.VALUE)
+        with self.assertRaises(NameError):
+            get_annotations(lru, format=Format.VALUE)
+
     @support.skip_on_s390x
     @unittest.skipIf(support.is_wasi, "WASI has limited C stack")
+    @support.skip_if_sanitizer("requires deep stack", ub=True, thread=True)
+    @support.skip_emscripten_stack_overflow()
     def test_lru_recursion(self):
 
         @self.module.lru_cache
@@ -1973,15 +2181,12 @@ def fib(n):
                 return n
             return fib(n-1) + fib(n-2)
 
-        if not support.Py_DEBUG:
-            depth = support.get_c_recursion_limit()*2//7
-            with support.infinite_recursion():
-                fib(depth)
+        fib(100)
         if self.module == c_functools:
             fib.cache_clear()
             with support.infinite_recursion():
                 with self.assertRaises(RecursionError):
-                    fib(10000)
+                    fib(support.exceeds_recursion_limit())
 
 
 @py_functools.lru_cache()
@@ -2563,15 +2768,15 @@ def _(self, arg):
         a.t(0)
         self.assertEqual(a.arg, "int")
         aa = A()
-        self.assertFalse(hasattr(aa, 'arg'))
+        self.assertNotHasAttr(aa, 'arg')
         a.t('')
         self.assertEqual(a.arg, "str")
         aa = A()
-        self.assertFalse(hasattr(aa, 'arg'))
+        self.assertNotHasAttr(aa, 'arg')
         a.t(0.0)
         self.assertEqual(a.arg, "base")
         aa = A()
-        self.assertFalse(hasattr(aa, 'arg'))
+        self.assertNotHasAttr(aa, 'arg')
 
     def test_staticmethod_register(self):
         class A:
@@ -2806,6 +3011,8 @@ def static_func(arg: int) -> str:
             A().static_func
         ):
             with self.subTest(meth=meth):
+                self.assertEqual(meth.__module__, __name__)
+                self.assertEqual(type(meth).__module__, 'functools')
                 self.assertEqual(meth.__qualname__, prefix + meth.__name__)
                 self.assertEqual(meth.__doc__,
                                  ('My function docstring'
@@ -2820,6 +3027,67 @@ def static_func(arg: int) -> str:
         self.assertEqual(A.static_func.__name__, 'static_func')
         self.assertEqual(A().static_func.__name__, 'static_func')
 
+    def test_method_repr(self):
+        class Callable:
+            def __call__(self, *args):
+                pass
+
+        class CallableWithName:
+            __name__ = 'NOQUALNAME'
+            def __call__(self, *args):
+                pass
+
+        class A:
+            @functools.singledispatchmethod
+            def func(self, arg):
+                pass
+            @functools.singledispatchmethod
+            @classmethod
+            def cls_func(cls, arg):
+                pass
+            @functools.singledispatchmethod
+            @staticmethod
+            def static_func(arg):
+                pass
+            # No __qualname__, only __name__
+            no_qualname = functools.singledispatchmethod(CallableWithName())
+            # No __qualname__, no __name__
+            no_name = functools.singledispatchmethod(Callable())
+
+        self.assertEqual(repr(A.__dict__['func']),
+            f'<single dispatch method descriptor {A.__qualname__}.func>')
+        self.assertEqual(repr(A.__dict__['cls_func']),
+            f'<single dispatch method descriptor {A.__qualname__}.cls_func>')
+        self.assertEqual(repr(A.__dict__['static_func']),
+            f'<single dispatch method descriptor {A.__qualname__}.static_func>')
+        self.assertEqual(repr(A.__dict__['no_qualname']),
+            f'<single dispatch method descriptor NOQUALNAME>')
+        self.assertEqual(repr(A.__dict__['no_name']),
+            f'<single dispatch method descriptor ?>')
+
+        self.assertEqual(repr(A.func),
+            f'<single dispatch method {A.__qualname__}.func>')
+        self.assertEqual(repr(A.cls_func),
+            f'<single dispatch method {A.__qualname__}.cls_func>')
+        self.assertEqual(repr(A.static_func),
+            f'<single dispatch method {A.__qualname__}.static_func>')
+        self.assertEqual(repr(A.no_qualname),
+            f'<single dispatch method NOQUALNAME>')
+        self.assertEqual(repr(A.no_name),
+            f'<single dispatch method ?>')
+
+        a = A()
+        self.assertEqual(repr(a.func),
+            f'<bound single dispatch method {A.__qualname__}.func of {a!r}>')
+        self.assertEqual(repr(a.cls_func),
+            f'<bound single dispatch method {A.__qualname__}.cls_func of {a!r}>')
+        self.assertEqual(repr(a.static_func),
+            f'<bound single dispatch method {A.__qualname__}.static_func of {a!r}>')
+        self.assertEqual(repr(a.no_qualname),
+            f'<bound single dispatch method NOQUALNAME of {a!r}>')
+        self.assertEqual(repr(a.no_name),
+            f'<bound single dispatch method ? of {a!r}>')
+
     def test_double_wrapped_methods(self):
         def classmethod_friendly_decorator(func):
             wrapped = func.__func__
@@ -2836,7 +3104,8 @@ def cls_context_manager(cls, arg: int) -> str:
                 try:
                     yield str(arg)
                 finally:
-                    return 'Done'
+                    pass
+                return 'Done'
 
             @classmethod_friendly_decorator
             @classmethod
@@ -2852,7 +3121,8 @@ def cls_context_manager(cls, arg: int) -> str:
                 try:
                     yield str(arg)
                 finally:
-                    return 'Done'
+                    pass
+                return 'Done'
 
             @functools.singledispatchmethod
             @classmethod_friendly_decorator
@@ -2922,7 +3192,6 @@ def decorated_classmethod(cls, arg: int) -> str:
             'decorated_classmethod'
         )
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_registrations(self):
         msg_prefix = "Invalid first argument to `register()`: "
         msg_suffix = (
@@ -2936,16 +3205,16 @@ def i(arg):
             @i.register(42)
             def _(arg):
                 return "I annotated with a non-type"
-        self.assertTrue(str(exc.exception).startswith(msg_prefix + "42"))
-        self.assertTrue(str(exc.exception).endswith(msg_suffix))
+        self.assertStartsWith(str(exc.exception), msg_prefix + "42")
+        self.assertEndsWith(str(exc.exception), msg_suffix)
         with self.assertRaises(TypeError) as exc:
             @i.register
             def _(arg):
                 return "I forgot to annotate"
-        self.assertTrue(str(exc.exception).startswith(msg_prefix +
+        self.assertStartsWith(str(exc.exception), msg_prefix +
             "<function TestSingleDispatch.test_invalid_registrations.<locals>._"
-        ))
-        self.assertTrue(str(exc.exception).endswith(msg_suffix))
+        )
+        self.assertEndsWith(str(exc.exception), msg_suffix)
 
         with self.assertRaises(TypeError) as exc:
             @i.register
@@ -2955,23 +3224,23 @@ def _(arg: typing.Iterable[str]):
                 # types from `typing`. Instead, annotate with regular types
                 # or ABCs.
                 return "I annotated with a generic collection"
-        self.assertTrue(str(exc.exception).startswith(
+        self.assertStartsWith(str(exc.exception),
             "Invalid annotation for 'arg'."
-        ))
-        self.assertTrue(str(exc.exception).endswith(
+        )
+        self.assertEndsWith(str(exc.exception),
             'typing.Iterable[str] is not a class.'
-        ))
+        )
 
         with self.assertRaises(TypeError) as exc:
             @i.register
             def _(arg: typing.Union[int, typing.Iterable[str]]):
                 return "Invalid Union"
-        self.assertTrue(str(exc.exception).startswith(
+        self.assertStartsWith(str(exc.exception),
             "Invalid annotation for 'arg'."
-        ))
-        self.assertTrue(str(exc.exception).endswith(
-            'typing.Union[int, typing.Iterable[str]] not all arguments are classes.'
-        ))
+        )
+        self.assertEndsWith(str(exc.exception),
+            'int | typing.Iterable[str] not all arguments are classes.'
+        )
 
     def test_invalid_positional_argument(self):
         @functools.singledispatch
@@ -3118,6 +3387,28 @@ def _(arg: typing.List[float] | bytes):
         self.assertEqual(f(""), "default")
         self.assertEqual(f(b""), "default")
 
+    def test_forward_reference(self):
+        @functools.singledispatch
+        def f(arg, arg2=None):
+            return "default"
+
+        @f.register
+        def _(arg: str, arg2: undefined = None):
+            return "forward reference"
+
+        self.assertEqual(f(1), "default")
+        self.assertEqual(f(""), "forward reference")
+
+    def test_unresolved_forward_reference(self):
+        @functools.singledispatch
+        def f(arg):
+            return "default"
+
+        with self.assertRaisesRegex(TypeError, "is an unresolved forward reference"):
+            @f.register
+            def _(arg: undefined):
+                return "forward reference"
+
     def test_method_equal_instances(self):
         # gh-127750: Reference to self was cached
         class A:
@@ -3300,7 +3591,7 @@ class MyClass(metaclass=MyMeta):
         ):
             MyClass.prop
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_reuse_different_names(self):
         """Disallow this case because decorated function a would not be cached."""
         with self.assertRaises(TypeError) as ctx:

From c82da8b887c994ad298729fd64a9e10a79d4cd15 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 14:10:04 +0900
Subject: [PATCH 412/418] mark functools tests

---
 Lib/test/test_functools.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 88964fec1e6..9ab0c8917e8 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -560,7 +560,6 @@ def __str__(self):
         self.assertIn('astr', r)
         self.assertIn("['sth']", r)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: '_PlaceholderType' object is not iterable
     def test_placeholders_refcount_smoke(self):
         PH = self.module.Placeholder
         # sum supports vector call
@@ -1711,6 +1710,7 @@ def f(x):
         f(0, **{})
         self.assertEqual(f.cache_info().hits, 1)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Python lru_cache impl doesn't cache hash like C impl
     def test_lru_hash_only_once(self):
         # To protect against weird reentrancy bugs and to improve
         # efficiency when faced with slow __hash__ methods, the
@@ -2104,6 +2104,7 @@ def f():
             return 1
         self.assertEqual(f.cache_parameters(), {'maxsize': 1000, "typed": True})
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; GC behavior differs from CPython's refcounting
     def test_lru_cache_weakrefable(self):
         @self.module.lru_cache
         def test_function(x):

From ddc5ba0b9800050e45eb0ecfdef04a681f52a6ae Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 16:29:15 +0900
Subject: [PATCH 413/418] cspell phcount

---
 .cspell.dict/cpython.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index a45760eaf2c..698ae734644 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -51,6 +51,7 @@ numer
 orelse
 pathconfig
 patma
+phcount
 platstdlib
 posonlyarg
 posonlyargs

From ff4f7a0e946477dcfdf32a991824134cdf2eeb4d Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 16:29:22 +0900
Subject: [PATCH 414/418] temp inspect patch

---
 Lib/inspect.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Lib/inspect.py b/Lib/inspect.py
index d2a04546959..ed384cf8b6e 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -563,7 +563,8 @@ def isroutine(object):
             or isfunction(object)
             or ismethod(object)
             or ismethoddescriptor(object)
-            or ismethodwrapper(object))
+            or ismethodwrapper(object)
+            or isinstance(object, functools._singledispatchmethod_get))
 
 def isabstract(object):
     """Return true if the object is an abstract base class (ABC)."""

From 479bb7af1acad89b1909904767d7a783e9a58410 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <jeong@youknowone.org>
Date: Tue, 20 Jan 2026 16:29:32 +0900
Subject: [PATCH 415/418] skip weakref crash test

---
 Lib/test/test_weakref.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index c118987411f..f421d745a12 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -2059,6 +2059,7 @@ def test_threaded_weak_key_dict_copy(self):
         # copying should not result in a crash.
         self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, False)
 
+    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (malloc corruption)')
     @threading_helper.requires_working_threading()
     @support.requires_resource('cpu')
     def test_threaded_weak_key_dict_deepcopy(self):
@@ -2066,13 +2067,14 @@ def test_threaded_weak_key_dict_deepcopy(self):
         # copying should not result in a crash.
         self.check_threaded_weak_dict_copy(weakref.WeakKeyDictionary, True)
 
-    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (Exit code -6)')
+    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (malloc corruption)')
     @threading_helper.requires_working_threading()
     def test_threaded_weak_value_dict_copy(self):
         # Issue #35615: Weakref keys or values getting GC'ed during dict
         # copying should not result in a crash.
         self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, False)
 
+    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (malloc corruption)')
     @threading_helper.requires_working_threading()
     @support.requires_resource('cpu')
     def test_threaded_weak_value_dict_deepcopy(self):

From 0cad3cb8b84d77482820ceceb105d054d19440a4 Mon Sep 17 00:00:00 2001
From: Lee Dogeon <dev.moreal@gmail.com>
Date: Tue, 20 Jan 2026 18:02:42 +0900
Subject: [PATCH 416/418] Use empty list as default according to Python.asdl
 (#6812)

* Use empty list as default in ClassDef.{bases,keywords}

* Unmark resolved tests

* Use empty list as default in FunctionDef.type_params

* Use empty list as default in ClassDef.type_params
---
 Lib/test/test_pyclbr.py               |  4 ----
 crates/vm/src/stdlib/ast/statement.rs | 28 +++++++++++++++++++++------
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index ad26fe1dba1..9ac4a6efe00 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -142,8 +142,6 @@ def defined_in(item, module):
                 if defined_in(item, module):
                     self.assertHaskey(dict, name, ignore)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_easy(self):
         self.checkModule('pyclbr')
         # XXX: Metaclasses are not supported
@@ -158,8 +156,6 @@ def test_cases(self):
         # see test.pyclbr_input for the rationale behind the ignored symbols
         self.checkModule('test.pyclbr_input', ignore=['om', 'f'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nested(self):
         mb = pyclbr
         # Set arguments for descriptor creation and _creat_tree call.
diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/ast/statement.rs
index 7716181fc5b..b7bc692dd2e 100644
--- a/crates/vm/src/stdlib/ast/statement.rs
+++ b/crates/vm/src/stdlib/ast/statement.rs
@@ -187,7 +187,9 @@ impl Node for ast::StmtFunctionDef {
         //     .unwrap();
         dict.set_item(
             "type_params",
-            type_params.ast_to_object(vm, source_file),
+            type_params
+                .map(|tp| tp.ast_to_object(vm, source_file))
+                .unwrap_or_else(|| vm.ctx.new_list(vec![]).into()),
             vm,
         )
         .unwrap();
@@ -260,10 +262,22 @@ impl Node for ast::StmtClassDef {
         let dict = node.as_object().dict().unwrap();
         dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
             .unwrap();
-        dict.set_item("bases", bases.ast_to_object(_vm, source_file), _vm)
-            .unwrap();
-        dict.set_item("keywords", keywords.ast_to_object(_vm, source_file), _vm)
-            .unwrap();
+        dict.set_item(
+            "bases",
+            bases
+                .map(|b| b.ast_to_object(_vm, source_file))
+                .unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
+            _vm,
+        )
+        .unwrap();
+        dict.set_item(
+            "keywords",
+            keywords
+                .map(|k| k.ast_to_object(_vm, source_file))
+                .unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
+            _vm,
+        )
+        .unwrap();
         dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
             .unwrap();
         dict.set_item(
@@ -274,7 +288,9 @@ impl Node for ast::StmtClassDef {
         .unwrap();
         dict.set_item(
             "type_params",
-            type_params.ast_to_object(_vm, source_file),
+            type_params
+                .map(|tp| tp.ast_to_object(_vm, source_file))
+                .unwrap_or_else(|| _vm.ctx.new_list(vec![]).into()),
             _vm,
         )
         .unwrap();

From 94ccfb8b1875668de35784aadf69322cbd7d99d8 Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 21:13:28 +0900
Subject: [PATCH 417/418] Prohibit AI PR submit (#6813)

---
 .github/copilot-instructions.md => AGENTS.md | 8 ++++++++
 1 file changed, 8 insertions(+)
 rename .github/copilot-instructions.md => AGENTS.md (95%)

diff --git a/.github/copilot-instructions.md b/AGENTS.md
similarity index 95%
rename from .github/copilot-instructions.md
rename to AGENTS.md
index 35bffdd148f..fa14977953a 100644
--- a/.github/copilot-instructions.md
+++ b/AGENTS.md
@@ -30,6 +30,14 @@ RustPython is a Python 3 interpreter written in Rust, implementing Python 3.14.0
 - `jit/` - Experimental JIT compiler implementation
 - `pylib/` - Python standard library packaging (do not modify this directory directly - its contents are generated automatically)
 
+## AI Agent Rules
+
+**CRITICAL: Git Operations**
+- NEVER create pull requests directly without explicit user permission
+- NEVER push commits to remote without explicit user permission
+- Always ask the user before performing any git operations that affect the remote repository
+- Commits can be created locally when requested, but pushing and PR creation require explicit approval
+
 ## Important Development Notes
 
 ### Running Python Code

From e01f26c1f686bb23b84344d58a8e9fea4c15bf7b Mon Sep 17 00:00:00 2001
From: "Jeong, YunWon" <69878+youknowone@users.noreply.github.com>
Date: Tue, 20 Jan 2026 21:34:34 +0900
Subject: [PATCH 418/418] Update inspect from v3.14.2 (#6815)

* Update inspect from v3.14.2

* temp asyncio.event._set_event_loop_policy

* mark inspect tests

---------

Co-authored-by: CPython Developers <>
---
 Lib/asyncio/events.py                         |   9 +-
 Lib/inspect.py                                | 294 +++----
 Lib/test/test_enum.py                         |   1 +
 .../inspect_deferred_annotations.py           |   2 +
 Lib/test/test_inspect/test_inspect.py         | 733 +++++++-----------
 Lib/test/test_unittest/test_async_case.py     |   1 -
 6 files changed, 409 insertions(+), 631 deletions(-)
 create mode 100644 Lib/test/test_inspect/inspect_deferred_annotations.py

diff --git a/Lib/asyncio/events.py b/Lib/asyncio/events.py
index 3b740b9b905..0d1591e4604 100644
--- a/Lib/asyncio/events.py
+++ b/Lib/asyncio/events.py
@@ -801,7 +801,7 @@ def get_event_loop_policy():
     return _event_loop_policy
 
 
-def set_event_loop_policy(policy):
+def _set_event_loop_policy(policy):
     """Set the current event loop policy.
 
     If policy is None, the default policy is restored."""
@@ -811,6 +811,13 @@ def set_event_loop_policy(policy):
     _event_loop_policy = policy
 
 
+def set_event_loop_policy(policy):
+    """Set the current event loop policy.
+
+    If policy is None, the default policy is restored."""
+    _set_event_loop_policy(policy)
+
+
 def get_event_loop():
     """Return an asyncio event loop.
 
diff --git a/Lib/inspect.py b/Lib/inspect.py
index ed384cf8b6e..385fbc686b6 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -6,9 +6,9 @@
 
 Here are some of the useful functions provided by this module:
 
-    ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
-        isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
-        isroutine() - check object types
+    ismodule(), isclass(), ismethod(), ispackage(), isfunction(),
+        isgeneratorfunction(), isgenerator(), istraceback(), isframe(),
+        iscode(), isbuiltin(), isroutine() - check object types
     getmembers() - get members of an object that satisfy a given condition
 
     getfile(), getsourcefile(), getsource() - find an object's source code
@@ -24,8 +24,6 @@
     stack(), trace() - get info about frames on the stack or in a traceback
 
     signature() - get a Signature object for the callable
-
-    get_annotations() - safely compute an object's annotations
 """
 
 # This module is in the public domain.  No warranties.
@@ -58,6 +56,8 @@
     "CO_OPTIMIZED",
     "CO_VARARGS",
     "CO_VARKEYWORDS",
+    "CO_HAS_DOCSTRING",
+    "CO_METHOD",
     "ClassFoundException",
     "ClosureVars",
     "EndOfBlock",
@@ -130,6 +130,7 @@
     "ismethoddescriptor",
     "ismethodwrapper",
     "ismodule",
+    "ispackage",
     "isroutine",
     "istraceback",
     "markcoroutinefunction",
@@ -142,6 +143,8 @@
 
 
 import abc
+from annotationlib import Format, ForwardRef
+from annotationlib import get_annotations  # re-exported
 import ast
 import dis
 import collections.abc
@@ -173,140 +176,6 @@
 TPFLAGS_IS_ABSTRACT = 1 << 20
 
 
-def get_annotations(obj, *, globals=None, locals=None, eval_str=False):
-    """Compute the annotations dict for an object.
-
-    obj may be a callable, class, or module.
-    Passing in an object of any other type raises TypeError.
-
-    Returns a dict.  get_annotations() returns a new dict every time
-    it's called; calling it twice on the same object will return two
-    different but equivalent dicts.
-
-    This function handles several details for you:
-
-      * If eval_str is true, values of type str will
-        be un-stringized using eval().  This is intended
-        for use with stringized annotations
-        ("from __future__ import annotations").
-      * If obj doesn't have an annotations dict, returns an
-        empty dict.  (Functions and methods always have an
-        annotations dict; classes, modules, and other types of
-        callables may not.)
-      * Ignores inherited annotations on classes.  If a class
-        doesn't have its own annotations dict, returns an empty dict.
-      * All accesses to object members and dict values are done
-        using getattr() and dict.get() for safety.
-      * Always, always, always returns a freshly-created dict.
-
-    eval_str controls whether or not values of type str are replaced
-    with the result of calling eval() on those values:
-
-      * If eval_str is true, eval() is called on values of type str.
-      * If eval_str is false (the default), values of type str are unchanged.
-
-    globals and locals are passed in to eval(); see the documentation
-    for eval() for more information.  If either globals or locals is
-    None, this function may replace that value with a context-specific
-    default, contingent on type(obj):
-
-      * If obj is a module, globals defaults to obj.__dict__.
-      * If obj is a class, globals defaults to
-        sys.modules[obj.__module__].__dict__ and locals
-        defaults to the obj class namespace.
-      * If obj is a callable, globals defaults to obj.__globals__,
-        although if obj is a wrapped function (using
-        functools.update_wrapper()) it is first unwrapped.
-    """
-    if isinstance(obj, type):
-        # class
-        # XXX: RUSTPYTHON
-        # PEP 649: Use descriptor access to get __annotations__
-        # The __annotations__ attribute is now provided via a descriptor
-        # that calls __annotate__ to compute the annotations lazily
-        try:
-            ann = obj.__annotations__
-        except AttributeError:
-            ann = None
-        # Ensure we got this class's own annotations, not inherited
-        if ann is not None:
-            # Check if __annotations__ is in this class's __dict__
-            # or is computed by a descriptor (both are valid)
-            obj_dict = getattr(obj, '__dict__', None)
-            if obj_dict is not None:
-                dict_ann = obj_dict.get('__annotations__', None)
-                # If it's a descriptor or cached dict, use what we got from attribute access
-                # If it's inherited (not in __dict__ at all and no __annotate__), return empty
-                # XXX: RUSTPYTHON - also check __annotate_func__ (PEP 649 descriptor)
-                if dict_ann is None and '__annotate__' not in obj_dict and '__annotations_cache__' not in obj_dict and not hasattr(obj, '__annotate_func__'):
-                    ann = None
-
-        obj_globals = None
-        module_name = getattr(obj, '__module__', None)
-        if module_name:
-            module = sys.modules.get(module_name, None)
-            if module:
-                obj_globals = getattr(module, '__dict__', None)
-        obj_locals = dict(vars(obj))
-        unwrap = obj
-    elif isinstance(obj, types.ModuleType):
-        # module
-        ann = getattr(obj, '__annotations__', None)
-        obj_globals = getattr(obj, '__dict__')
-        obj_locals = None
-        unwrap = None
-    elif callable(obj):
-        # this includes types.Function, types.BuiltinFunctionType,
-        # types.BuiltinMethodType, functools.partial, functools.singledispatch,
-        # "class funclike" from Lib/test/test_inspect... on and on it goes.
-        ann = getattr(obj, '__annotations__', None)
-        obj_globals = getattr(obj, '__globals__', None)
-        obj_locals = None
-        unwrap = obj
-    else:
-        raise TypeError(f"{obj!r} is not a module, class, or callable.")
-
-    if ann is None:
-        return {}
-
-    if not isinstance(ann, dict):
-        raise ValueError(f"{obj!r}.__annotations__ is neither a dict nor None")
-
-    if not ann:
-        return {}
-
-    if not eval_str:
-        return dict(ann)
-
-    if unwrap is not None:
-        while True:
-            if hasattr(unwrap, '__wrapped__'):
-                unwrap = unwrap.__wrapped__
-                continue
-            if isinstance(unwrap, functools.partial):
-                unwrap = unwrap.func
-                continue
-            break
-        if hasattr(unwrap, "__globals__"):
-            obj_globals = unwrap.__globals__
-
-    if globals is None:
-        globals = obj_globals
-    if locals is None:
-        locals = obj_locals or {}
-
-    # "Inject" type parameters into the local namespace
-    # (unless they are shadowed by assignments *in* the local namespace),
-    # as a way of emulating annotation scopes when calling `eval()`
-    if type_params := getattr(obj, "__type_params__", ()):
-        locals = {param.__name__: param for param in type_params} | locals
-
-    return_value = {key:
-        value if not isinstance(value, str) else eval(value, globals, locals)
-        for key, value in ann.items() }
-    return return_value
-
-
 # ----------------------------------------------------------- type-checking
 def ismodule(object):
     """Return true if the object is a module."""
@@ -320,6 +189,10 @@ def ismethod(object):
     """Return true if the object is an instance method."""
     return isinstance(object, types.MethodType)
 
+def ispackage(object):
+    """Return true if the object is a package."""
+    return ismodule(object) and hasattr(object, "__path__")
+
 def ismethoddescriptor(object):
     """Return true if the object is a method descriptor.
 
@@ -338,11 +211,6 @@ def ismethoddescriptor(object):
     if isclass(object) or ismethod(object) or isfunction(object):
         # mutual exclusion
         return False
-    if isinstance(object, functools.partial):
-        # Lie for children.  The addition of partial.__get__
-        # doesn't currently change the partial objects behaviour,
-        # not counting a warning about future changes.
-        return False
     tp = type(object)
     return (hasattr(tp, "__get__")
             and not hasattr(tp, "__set__")
@@ -402,11 +270,16 @@ def isfunction(object):
     Function objects provide these attributes:
         __doc__         documentation string
         __name__        name with which this function was defined
+        __qualname__    qualified name of this function
+        __module__      name of the module the function was defined in or None
         __code__        code object containing compiled function bytecode
         __defaults__    tuple of any default values for arguments
         __globals__     global namespace in which this function was defined
         __annotations__ dict of parameter annotations
-        __kwdefaults__  dict of keyword only parameters with defaults"""
+        __kwdefaults__  dict of keyword only parameters with defaults
+        __dict__        namespace which is supporting arbitrary function attributes
+        __closure__     a tuple of cells or None
+        __type_params__ tuple of type parameters"""
     return isinstance(object, types.FunctionType)
 
 def _has_code_flag(f, flag):
@@ -471,17 +344,18 @@ def isgenerator(object):
     """Return true if the object is a generator.
 
     Generator objects provide these attributes:
-        __iter__        defined to support iteration over container
-        close           raises a new GeneratorExit exception inside the
-                        generator to terminate the iteration
         gi_code         code object
         gi_frame        frame object or possibly None once the generator has
                         been exhausted
         gi_running      set to 1 when generator is executing, 0 otherwise
-        next            return the next item from the container
-        send            resumes the generator and "sends" a value that becomes
+        gi_yieldfrom    object being iterated by yield from or None
+
+        __iter__()      defined to support iteration over container
+        close()         raises a new GeneratorExit exception inside the
+                        generator to terminate the iteration
+        send()          resumes the generator and "sends" a value that becomes
                         the result of the current yield-expression
-        throw           used to raise an exception inside the generator"""
+        throw()         used to raise an exception inside the generator"""
     return isinstance(object, types.GeneratorType)
 
 def iscoroutine(object):
@@ -516,7 +390,11 @@ def isframe(object):
         f_lasti         index of last attempted instruction in bytecode
         f_lineno        current line number in Python source code
         f_locals        local namespace seen by this frame
-        f_trace         tracing function for this frame, or None"""
+        f_trace         tracing function for this frame, or None
+        f_trace_lines   is a tracing event triggered for each source line?
+        f_trace_opcodes are per-opcode events being requested?
+
+        clear()          used to clear all references to local variables"""
     return isinstance(object, types.FrameType)
 
 def iscode(object):
@@ -533,6 +411,7 @@ def iscode(object):
         co_flags            bitmap: 1=optimized | 2=newlocals | 4=*arg | 8=**arg
                             | 16=nested | 32=generator | 64=nofree | 128=coroutine
                             | 256=iterable_coroutine | 512=async_generator
+                            | 0x4000000=has_docstring
         co_freevars         tuple of names of free variables
         co_posonlyargcount  number of positional only arguments
         co_kwonlyargcount   number of keyword only arguments (not including ** arg)
@@ -541,7 +420,12 @@ def iscode(object):
         co_names            tuple of names other than arguments and function locals
         co_nlocals          number of local variables
         co_stacksize        virtual machine stack space required
-        co_varnames         tuple of names of arguments and local variables"""
+        co_varnames         tuple of names of arguments and local variables
+        co_qualname         fully qualified function name
+
+        co_lines()          returns an iterator that yields successive bytecode ranges
+        co_positions()      returns an iterator of source code positions for each bytecode instruction
+        replace()           returns a copy of the code object with a new values"""
     return isinstance(object, types.CodeType)
 
 def isbuiltin(object):
@@ -975,8 +859,7 @@ def getsourcefile(object):
     Return None if no way can be identified to get the source.
     """
     filename = getfile(object)
-    all_bytecode_suffixes = importlib.machinery.DEBUG_BYTECODE_SUFFIXES[:]
-    all_bytecode_suffixes += importlib.machinery.OPTIMIZED_BYTECODE_SUFFIXES[:]
+    all_bytecode_suffixes = importlib.machinery.BYTECODE_SUFFIXES[:]
     if any(filename.endswith(s) for s in all_bytecode_suffixes):
         filename = (os.path.splitext(filename)[0] +
                     importlib.machinery.SOURCE_SUFFIXES[0])
@@ -1452,7 +1335,9 @@ def getargvalues(frame):
     args, varargs, varkw = getargs(frame.f_code)
     return ArgInfo(args, varargs, varkw, frame.f_locals)
 
-def formatannotation(annotation, base_module=None):
+def formatannotation(annotation, base_module=None, *, quote_annotation_strings=True):
+    if not quote_annotation_strings and isinstance(annotation, str):
+        return annotation
     if getattr(annotation, '__module__', None) == 'typing':
         def repl(match):
             text = match.group()
@@ -1464,6 +1349,8 @@ def repl(match):
         if annotation.__module__ in ('builtins', base_module):
             return annotation.__qualname__
         return annotation.__module__+'.'+annotation.__qualname__
+    if isinstance(annotation, ForwardRef):
+        return annotation.__forward_arg__
     return repr(annotation)
 
 def formatannotationrelativeto(object):
@@ -2081,7 +1968,12 @@ def _signature_get_partial(wrapped_sig, partial, extra_args=()):
             if param.kind is _POSITIONAL_ONLY:
                 # If positional-only parameter is bound by partial,
                 # it effectively disappears from the signature
-                new_params.pop(param_name)
+                # However, if it is a Placeholder it is not removed
+                # And also looses default value
+                if arg_value is functools.Placeholder:
+                    new_params[param_name] = param.replace(default=_empty)
+                else:
+                    new_params.pop(param_name)
                 continue
 
             if param.kind is _POSITIONAL_OR_KEYWORD:
@@ -2103,7 +1995,17 @@ def _signature_get_partial(wrapped_sig, partial, extra_args=()):
                     new_params[param_name] = param.replace(default=arg_value)
                 else:
                     # was passed as a positional argument
-                    new_params.pop(param.name)
+                    # Do not pop if it is a Placeholder
+                    #   also change kind to positional only
+                    #   and remove default
+                    if arg_value is functools.Placeholder:
+                        new_param = param.replace(
+                            kind=_POSITIONAL_ONLY,
+                            default=_empty
+                        )
+                        new_params[param_name] = new_param
+                    else:
+                        new_params.pop(param_name)
                     continue
 
             if param.kind is _KEYWORD_ONLY:
@@ -2181,13 +2083,11 @@ def _signature_is_functionlike(obj):
     code = getattr(obj, '__code__', None)
     defaults = getattr(obj, '__defaults__', _void) # Important to use _void ...
     kwdefaults = getattr(obj, '__kwdefaults__', _void) # ... and not None here
-    annotations = getattr(obj, '__annotations__', None)
 
     return (isinstance(code, types.CodeType) and
             isinstance(name, str) and
             (defaults is None or isinstance(defaults, tuple)) and
-            (kwdefaults is None or isinstance(kwdefaults, dict)) and
-            (isinstance(annotations, (dict)) or annotations is None) )
+            (kwdefaults is None or isinstance(kwdefaults, dict)))
 
 
 def _signature_strip_non_python_syntax(signature):
@@ -2404,7 +2304,8 @@ def _signature_from_builtin(cls, func, skip_bound_arg=True):
 
 
 def _signature_from_function(cls, func, skip_bound_arg=True,
-                             globals=None, locals=None, eval_str=False):
+                             globals=None, locals=None, eval_str=False,
+                             *, annotation_format=Format.VALUE):
     """Private helper: constructs Signature for the given python function."""
 
     is_duck_function = False
@@ -2430,7 +2331,8 @@ def _signature_from_function(cls, func, skip_bound_arg=True,
     positional = arg_names[:pos_count]
     keyword_only_count = func_code.co_kwonlyargcount
     keyword_only = arg_names[pos_count:pos_count + keyword_only_count]
-    annotations = get_annotations(func, globals=globals, locals=locals, eval_str=eval_str)
+    annotations = get_annotations(func, globals=globals, locals=locals, eval_str=eval_str,
+                                  format=annotation_format)
     defaults = func.__defaults__
     kwdefaults = func.__kwdefaults__
 
@@ -2513,7 +2415,8 @@ def _signature_from_callable(obj, *,
                              globals=None,
                              locals=None,
                              eval_str=False,
-                             sigcls):
+                             sigcls,
+                             annotation_format=Format.VALUE):
 
     """Private helper function to get signature for arbitrary
     callable objects.
@@ -2525,7 +2428,8 @@ def _signature_from_callable(obj, *,
                                 globals=globals,
                                 locals=locals,
                                 sigcls=sigcls,
-                                eval_str=eval_str)
+                                eval_str=eval_str,
+                                annotation_format=annotation_format)
 
     if not callable(obj):
         raise TypeError('{!r} is not a callable object'.format(obj))
@@ -2558,18 +2462,10 @@ def _signature_from_callable(obj, *,
         pass
     else:
         if sig is not None:
-            # since __text_signature__ is not writable on classes, __signature__
-            # may contain text (or be a callable that returns text);
-            # if so, convert it
-            o_sig = sig
-            if not isinstance(sig, (Signature, str)) and callable(sig):
-                sig = sig()
-            if isinstance(sig, str):
-                sig = _signature_fromstr(sigcls, obj, sig)
             if not isinstance(sig, Signature):
                 raise TypeError(
                     'unexpected object {!r} in __signature__ '
-                    'attribute'.format(o_sig))
+                    'attribute'.format(sig))
             return sig
 
     try:
@@ -2597,6 +2493,11 @@ def _signature_from_callable(obj, *,
                 sig_params = tuple(sig.parameters.values())
                 assert (not sig_params or
                         first_wrapped_param is not sig_params[0])
+                # If there were placeholders set,
+                #   first param is transformed to positional only
+                if partialmethod.args.count(functools.Placeholder):
+                    first_wrapped_param = first_wrapped_param.replace(
+                        kind=Parameter.POSITIONAL_ONLY)
                 new_params = (first_wrapped_param,) + sig_params
                 return sig.replace(parameters=new_params)
 
@@ -2609,7 +2510,8 @@ def _signature_from_callable(obj, *,
         # of a Python function (Cython functions, for instance), then:
         return _signature_from_function(sigcls, obj,
                                         skip_bound_arg=skip_bound_arg,
-                                        globals=globals, locals=locals, eval_str=eval_str)
+                                        globals=globals, locals=locals, eval_str=eval_str,
+                                        annotation_format=annotation_format)
 
     if _signature_is_builtin(obj):
         return _signature_from_builtin(sigcls, obj,
@@ -2862,13 +2764,17 @@ def replace(self, *, name=_void, kind=_void,
         return type(self)(name, kind, default=default, annotation=annotation)
 
     def __str__(self):
+        return self._format()
+
+    def _format(self, *, quote_annotation_strings=True):
         kind = self.kind
         formatted = self._name
 
         # Add annotation and default value
         if self._annotation is not _empty:
-            formatted = '{}: {}'.format(formatted,
-                                       formatannotation(self._annotation))
+            annotation = formatannotation(self._annotation,
+                                          quote_annotation_strings=quote_annotation_strings)
+            formatted = '{}: {}'.format(formatted, annotation)
 
         if self._default is not _empty:
             if self._annotation is not _empty:
@@ -3075,11 +2981,19 @@ def __init__(self, parameters=None, *, return_annotation=_empty,
                 params = OrderedDict()
                 top_kind = _POSITIONAL_ONLY
                 seen_default = False
+                seen_var_parameters = set()
 
                 for param in parameters:
                     kind = param.kind
                     name = param.name
 
+                    if kind in (_VAR_POSITIONAL, _VAR_KEYWORD):
+                        if kind in seen_var_parameters:
+                            msg = f'more than one {kind.description} parameter'
+                            raise ValueError(msg)
+
+                        seen_var_parameters.add(kind)
+
                     if kind < top_kind:
                         msg = (
                             'wrong parameter order: {} parameter before {} '
@@ -3116,11 +3030,13 @@ def __init__(self, parameters=None, *, return_annotation=_empty,
 
     @classmethod
     def from_callable(cls, obj, *,
-                      follow_wrapped=True, globals=None, locals=None, eval_str=False):
+                      follow_wrapped=True, globals=None, locals=None, eval_str=False,
+                      annotation_format=Format.VALUE):
         """Constructs Signature for the given callable object."""
         return _signature_from_callable(obj, sigcls=cls,
                                         follow_wrapper_chains=follow_wrapped,
-                                        globals=globals, locals=locals, eval_str=eval_str)
+                                        globals=globals, locals=locals, eval_str=eval_str,
+                                        annotation_format=annotation_format)
 
     @property
     def parameters(self):
@@ -3338,19 +3254,24 @@ def __repr__(self):
     def __str__(self):
         return self.format()
 
-    def format(self, *, max_width=None):
+    def format(self, *, max_width=None, quote_annotation_strings=True):
         """Create a string representation of the Signature object.
 
         If *max_width* integer is passed,
         signature will try to fit into the *max_width*.
         If signature is longer than *max_width*,
         all parameters will be on separate lines.
+
+        If *quote_annotation_strings* is False, annotations
+        in the signature are displayed without opening and closing quotation
+        marks. This is useful when the signature was created with the
+        STRING format or when ``from __future__ import annotations`` was used.
         """
         result = []
         render_pos_only_separator = False
         render_kw_only_separator = True
         for param in self.parameters.values():
-            formatted = str(param)
+            formatted = param._format(quote_annotation_strings=quote_annotation_strings)
 
             kind = param.kind
 
@@ -3387,16 +3308,19 @@ def format(self, *, max_width=None):
             rendered = '(\n    {}\n)'.format(',\n    '.join(result))
 
         if self.return_annotation is not _empty:
-            anno = formatannotation(self.return_annotation)
+            anno = formatannotation(self.return_annotation,
+                                    quote_annotation_strings=quote_annotation_strings)
             rendered += ' -> {}'.format(anno)
 
         return rendered
 
 
-def signature(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False):
+def signature(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False,
+              annotation_format=Format.VALUE):
     """Get a signature object for the passed callable."""
     return Signature.from_callable(obj, follow_wrapped=follow_wrapped,
-                                   globals=globals, locals=locals, eval_str=eval_str)
+                                   globals=globals, locals=locals, eval_str=eval_str,
+                                   annotation_format=annotation_format)
 
 
 class BufferFlags(enum.IntFlag):
@@ -3426,7 +3350,7 @@ def _main():
     import argparse
     import importlib
 
-    parser = argparse.ArgumentParser()
+    parser = argparse.ArgumentParser(color=True)
     parser.add_argument(
         'object',
          help="The object to be analysed. "
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 21a3b8edd4e..9f09098ebad 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -5186,6 +5186,7 @@ def test_inspect_classify_class_attrs(self):
         if failed:
             self.fail("result does not equal expected, see print above")
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Enum.__signature__ is @classmethod instead of @property
     def test_inspect_signatures(self):
         from inspect import signature, Signature, Parameter
         self.assertEqual(
diff --git a/Lib/test/test_inspect/inspect_deferred_annotations.py b/Lib/test/test_inspect/inspect_deferred_annotations.py
new file mode 100644
index 00000000000..bb59ef1035b
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_deferred_annotations.py
@@ -0,0 +1,2 @@
+def f(x: undefined):
+    pass
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
index 655587e7bb4..28733d13e8a 100644
--- a/Lib/test/test_inspect/test_inspect.py
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -1,3 +1,4 @@
+from annotationlib import Format, ForwardRef
 import asyncio
 import builtins
 import collections
@@ -12,6 +13,8 @@
 import os
 import dis
 from os.path import normcase
+# XXX: RUSTPYTHON
+# import _pickle
 import pickle
 import shutil
 import stat
@@ -21,45 +24,36 @@
 import types
 import tempfile
 import textwrap
-from typing import Unpack
 import unicodedata
 import unittest
 import unittest.mock
 import warnings
 import weakref
 
-# XXX: RUSTPYTHON; skip _pickle tests if _pickle is not available
-try:
-    import _pickle
-except ImportError:
-    _pickle = None
-
 
 try:
     from concurrent.futures import ThreadPoolExecutor
 except ImportError:
     ThreadPoolExecutor = None
 
-from test.support import cpython_only, import_helper, suppress_immortalization
+from test.support import cpython_only, import_helper
 from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ
-# XXX: RUSTPYTHON; test.support is not updated yet
-from test.support.import_helper import DirsOnSysPath #, ready_to_import
+from test.support import run_no_yield_async_fn, EqualToForwardRef
+from test.support.import_helper import DirsOnSysPath, ready_to_import
 from test.support.os_helper import TESTFN, temp_cwd
 from test.support.script_helper import assert_python_ok, assert_python_failure, kill_python
-from test.support import has_subprocess_support, SuppressCrashReport
+from test.support import has_subprocess_support
 from test import support
 
 from test.test_inspect import inspect_fodder as mod
 from test.test_inspect import inspect_fodder2 as mod2
-from test.test_inspect import inspect_stock_annotations
 from test.test_inspect import inspect_stringized_annotations
-from test.test_inspect import inspect_stringized_annotations_2
-from test.test_inspect import inspect_stringized_annotations_pep695
+from test.test_inspect import inspect_deferred_annotations
 
 
 # Functions tested in this suite:
 # ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
-# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,
+# isbuiltin, isroutine, isgenerator, ispackage, isgeneratorfunction, getmembers,
 # getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,
 # getclasstree, getargvalues, formatargvalues, currentframe,
 # stack, trace, ismethoddescriptor, isdatadescriptor, ismethodwrapper
@@ -81,11 +75,6 @@ def revise(filename, *args):
 git = mod.StupidGit()
 
 
-def tearDownModule():
-    if support.has_socket_support:
-        asyncio.set_event_loop_policy(None)
-
-
 def signatures_with_lexicographic_keyword_only_parameters():
     """
     Yields a whole bunch of functions with only keyword-only parameters,
@@ -113,7 +102,7 @@ def unsorted_keyword_only_parameters_fn(*, throw, out, the, baby, with_,
 class IsTestBase(unittest.TestCase):
     predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
                       inspect.isframe, inspect.isfunction, inspect.ismethod,
-                      inspect.ismodule, inspect.istraceback,
+                      inspect.ismodule, inspect.istraceback, inspect.ispackage,
                       inspect.isgenerator, inspect.isgeneratorfunction,
                       inspect.iscoroutine, inspect.iscoroutinefunction,
                       inspect.isasyncgen, inspect.isasyncgenfunction,
@@ -129,12 +118,14 @@ def istest(self, predicate, exp):
                predicate == inspect.iscoroutinefunction) and \
                other == inspect.isfunction:
                 continue
-            self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
+            if predicate == inspect.ispackage and other == inspect.ismodule:
+                self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
+            else:
+                self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test__all__(self):
-        support.check__all__(self, inspect, not_exported=("modulesbyfile",))
+        support.check__all__(self, inspect, not_exported=("modulesbyfile",), extra=("get_annotations",))
 
 def generator_function_example(self):
     for i in range(2):
@@ -185,8 +176,7 @@ def __get__(self, instance, owner):
 
 class TestPredicates(IsTestBase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_excluding_predicates(self):
         global tb
         self.istest(inspect.isbuiltin, 'sys.exit')
@@ -236,10 +226,19 @@ def test_excluding_predicates(self):
         self.assertFalse(inspect.ismethodwrapper(int))
         self.assertFalse(inspect.ismethodwrapper(type("AnyClass", (), {})))
 
+    def test_ispackage(self):
+        self.istest(inspect.ispackage, 'unittest')
+        self.istest(inspect.ispackage, 'importlib')
+        self.assertFalse(inspect.ispackage(inspect))
+        self.assertFalse(inspect.ispackage(mod))
+        self.assertFalse(inspect.ispackage(':)'))
+
+        class FakePackage:
+            __path__ = None
 
+        self.assertFalse(inspect.ispackage(FakePackage()))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_iscoroutine(self):
         async_gen_coro = async_generator_function_example(1)
         gen_coro = gen_coroutine_function_example(1)
@@ -441,7 +440,7 @@ def test_isroutine(self):
         self.assertFalse(inspect.isroutine(int))
         self.assertFalse(inspect.isroutine(type('some_class', (), {})))
         # partial
-        self.assertFalse(inspect.isroutine(functools.partial(mod.spam)))
+        self.assertTrue(inspect.isroutine(functools.partial(mod.spam)))
 
     def test_isroutine_singledispatch(self):
         self.assertTrue(inspect.isroutine(functools.singledispatch(mod.spam)))
@@ -482,8 +481,7 @@ class C(object):
         self.assertIn('a', members)
         self.assertNotIn('b', members)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_isabstract(self):
         from abc import ABCMeta, abstractmethod
 
@@ -506,8 +504,7 @@ def foo(self):
         self.assertFalse(inspect.isabstract(int))
         self.assertFalse(inspect.isabstract(5))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_isabstract_during_init_subclass(self):
         from abc import ABCMeta, abstractmethod
         isabstract_checks = []
@@ -543,8 +540,7 @@ def test_abuse_done(self):
         self.istest(inspect.istraceback, 'git.ex.__traceback__')
         self.istest(inspect.isframe, 'mod.fr')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_stack(self):
         self.assertTrue(len(mod.st) >= 5)
         frame1, frame2, frame3, frame4, *_ = mod.st
@@ -573,8 +569,7 @@ def test_stack(self):
         self.assertIn('inspect.stack()', record.code_context[0])
         self.assertEqual(record.index, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_trace(self):
         self.assertEqual(len(git.tr), 3)
         frame1, frame2, frame3, = git.tr
@@ -597,8 +592,7 @@ def test_frame(self):
         self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
                          '(x=11, y=14)')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_previous_frame(self):
         args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)
         self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f'])
@@ -678,10 +672,9 @@ def test_getfunctions(self):
                                      ('lobbest', mod.lobbest),
                                      ('spam', mod.spam)])
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getdoc(self):
         self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
         self.assertEqual(inspect.getdoc(mod.StupidGit),
@@ -826,12 +819,12 @@ def test_getfile(self):
     def test_getfile_builtin_module(self):
         with self.assertRaises(TypeError) as e:
             inspect.getfile(sys)
-        self.assertTrue(str(e.exception).startswith('<module'))
+        self.assertStartsWith(str(e.exception), '<module')
 
     def test_getfile_builtin_class(self):
         with self.assertRaises(TypeError) as e:
             inspect.getfile(int)
-        self.assertTrue(str(e.exception).startswith('<class'))
+        self.assertStartsWith(str(e.exception), '<class')
 
     def test_getfile_builtin_function_or_method(self):
         with self.assertRaises(TypeError) as e_abs:
@@ -841,7 +834,6 @@ def test_getfile_builtin_function_or_method(self):
             inspect.getfile(list.append)
         self.assertIn('expected, got', str(e_append.exception))
 
-    @suppress_immortalization()
     def test_getfile_class_without_module(self):
         class CM(type):
             @property
@@ -900,8 +892,7 @@ def test_getsource_on_generated_class(self):
         self.assertRaises(OSError, inspect.getsourcelines, A)
         self.assertIsNone(inspect.getcomments(A))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_getsource_on_class_without_firstlineno(self):
         __firstlineno__ = 1
         class C:
@@ -911,8 +902,7 @@ class C:
 class TestGetsourceStdlib(unittest.TestCase):
     # Test Python implementations of the stdlib modules
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_getsource_stdlib_collections_abc(self):
         import collections.abc
         lines, lineno = inspect.getsourcelines(collections.abc.Sequence)
@@ -925,8 +915,7 @@ def test_getsource_stdlib_tomllib(self):
         self.assertRaises(OSError, inspect.getsource, tomllib.TOMLDecodeError)
         self.assertRaises(OSError, inspect.getsourcelines, tomllib.TOMLDecodeError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_getsource_stdlib_abc(self):
         # Pure Python implementation
         abc = import_helper.import_fresh_module('abc', blocked=['_abc'])
@@ -978,8 +967,7 @@ def test_range_traceback_toplevel_frame(self):
 class TestDecorators(GetSourceBase):
     fodderModule = mod2
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_wrapped_decorator(self):
         self.assertSourceEqual(mod2.wrapped, 14, 17)
 
@@ -1180,8 +1168,7 @@ def test_nested_class_definition(self):
         self.assertSourceEqual(mod2.cls183, 183, 188)
         self.assertSourceEqual(mod2.cls183.cls185, 185, 188)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_class_decorator(self):
         self.assertSourceEqual(mod2.cls196, 194, 201)
         self.assertSourceEqual(mod2.cls196.cls200, 198, 201)
@@ -1235,17 +1222,13 @@ def f(self):
                 # This is necessary when the test is run multiple times.
                 sys.modules.pop("inspect_actual")
 
-    @unittest.skipIf(
-        support.is_emscripten or support.is_wasi,
-        "socket.accept is broken"
-    )
     def test_nested_class_definition_inside_async_function(self):
-        import asyncio
-        self.addCleanup(asyncio.set_event_loop_policy, None)
-        self.assertSourceEqual(asyncio.run(mod2.func225()), 226, 227)
+        run = run_no_yield_async_fn
+
+        self.assertSourceEqual(run(mod2.func225), 226, 227)
         self.assertSourceEqual(mod2.cls226, 231, 235)
         self.assertSourceEqual(mod2.cls226.func232, 232, 235)
-        self.assertSourceEqual(asyncio.run(mod2.cls226().func232()), 233, 234)
+        self.assertSourceEqual(run(mod2.cls226().func232), 233, 234)
 
     def test_class_definition_same_name_diff_methods(self):
         self.assertSourceEqual(mod2.cls296, 296, 298)
@@ -1282,8 +1265,7 @@ def test_class(self):
 class TestComplexDecorator(GetSourceBase):
     fodderModule = mod2
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_parens_in_decorator(self):
         self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275)
 
@@ -1395,9 +1377,9 @@ def test(): pass
         spec = inspect.getfullargspec(test)
         self.assertEqual(test.__annotations__, spec.annotations)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; NameError: name '_pickle' is not defined. Did you mean: 'pickle'? Or did you forget to import '_pickle'?
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
-    @unittest.skipIf(_pickle is None, "requires _pickle")
     def test_getfullargspec_builtin_methods(self):
         self.assertFullArgSpecEquals(_pickle.Pickler.dump, ['self', 'obj'])
 
@@ -1456,7 +1438,7 @@ def test_getfullargspec_builtin_func_no_signature(self):
             (dict.__class_getitem__, meth_type_o),
         ]
         try:
-            import _stat
+            import _stat  # noqa: F401
         except ImportError:
             # if the _stat extension is not available, stat.S_IMODE() is
             # implemented in Python, not in C
@@ -1560,8 +1542,7 @@ def m1(self): pass
         self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
         self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_classify_builtin_types(self):
         # Simple sanity check that all built-in types can have their
         # attributes classified.
@@ -1816,232 +1797,24 @@ class C(metaclass=M):
         attrs = [a[0] for a in inspect.getmembers(C)]
         self.assertNotIn('missing', attrs)
 
-    def test_get_annotations_with_stock_annotations(self):
-        def foo(a:int, b:str): pass
-        self.assertEqual(inspect.get_annotations(foo), {'a': int, 'b': str})
-
-        foo.__annotations__ = {'a': 'foo', 'b':'str'}
-        self.assertEqual(inspect.get_annotations(foo), {'a': 'foo', 'b': 'str'})
-
-        self.assertEqual(inspect.get_annotations(foo, eval_str=True, locals=locals()), {'a': foo, 'b': str})
-        self.assertEqual(inspect.get_annotations(foo, eval_str=True, globals=locals()), {'a': foo, 'b': str})
-
-        isa = inspect_stock_annotations
-        self.assertEqual(inspect.get_annotations(isa), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.function), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function2), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function3), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(inspect), {}) # inspect module has no annotations
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
-
-        self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(inspect, eval_str=True), {})
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
-
-        self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(inspect, eval_str=False), {})
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
-
-        def times_three(fn):
-            @functools.wraps(fn)
-            def wrapper(a, b):
-                return fn(a*3, b*3)
-            return wrapper
-
-        wrapped = times_three(isa.function)
-        self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
-        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
-        self.assertEqual(inspect.get_annotations(wrapped), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
-
-    def test_get_annotations_with_stringized_annotations(self):
-        isa = inspect_stringized_annotations
-        self.assertEqual(inspect.get_annotations(isa), {'a': 'int', 'b': 'str'})
-        self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': 'int', 'b': 'str'})
-        self.assertEqual(inspect.get_annotations(isa.function), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(isa.function2), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(isa.function3), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
-
-        self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
-        self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
-
-        self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': 'int', 'b': 'str'})
-        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': 'int', 'b': 'str'})
-        self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
-        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
-        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
-
-        isa2 = inspect_stringized_annotations_2
-        self.assertEqual(inspect.get_annotations(isa2), {})
-        self.assertEqual(inspect.get_annotations(isa2, eval_str=True), {})
-        self.assertEqual(inspect.get_annotations(isa2, eval_str=False), {})
-
-        def times_three(fn):
-            @functools.wraps(fn)
-            def wrapper(a, b):
-                return fn(a*3, b*3)
-            return wrapper
-
-        wrapped = times_three(isa.function)
-        self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
-        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
-        self.assertEqual(inspect.get_annotations(wrapped), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
-        self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
-        self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
-
-        # test that local namespace lookups work
-        self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations), {'x': 'mytype'})
-        self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True), {'x': int})
-
-    def test_pep695_generic_class_with_future_annotations(self):
-        ann_module695 = inspect_stringized_annotations_pep695
-        A_annotations = inspect.get_annotations(ann_module695.A, eval_str=True)
-        A_type_params = ann_module695.A.__type_params__
-        self.assertIs(A_annotations["x"], A_type_params[0])
-        self.assertEqual(A_annotations["y"].__args__[0], Unpack[A_type_params[1]])
-        self.assertIs(A_annotations["z"].__args__[0], A_type_params[2])
-
-    def test_pep695_generic_class_with_future_annotations_and_local_shadowing(self):
-        B_annotations = inspect.get_annotations(
-            inspect_stringized_annotations_pep695.B, eval_str=True
-        )
-        self.assertEqual(B_annotations, {"x": int, "y": str, "z": bytes})
-
-    def test_pep695_generic_class_with_future_annotations_name_clash_with_global_vars(self):
-        ann_module695 = inspect_stringized_annotations_pep695
-        C_annotations = inspect.get_annotations(ann_module695.C, eval_str=True)
-        self.assertEqual(
-            set(C_annotations.values()),
-            set(ann_module695.C.__type_params__)
-        )
-
-    def test_pep_695_generic_function_with_future_annotations(self):
-        ann_module695 = inspect_stringized_annotations_pep695
-        generic_func_annotations = inspect.get_annotations(
-            ann_module695.generic_function, eval_str=True
-        )
-        func_t_params = ann_module695.generic_function.__type_params__
-        self.assertEqual(
-            generic_func_annotations.keys(), {"x", "y", "z", "zz", "return"}
-        )
-        self.assertIs(generic_func_annotations["x"], func_t_params[0])
-        self.assertEqual(generic_func_annotations["y"], Unpack[func_t_params[1]])
-        self.assertIs(generic_func_annotations["z"].__origin__, func_t_params[2])
-        self.assertIs(generic_func_annotations["zz"].__origin__, func_t_params[2])
-
-    def test_pep_695_generic_function_with_future_annotations_name_clash_with_global_vars(self):
-        self.assertEqual(
-            set(
-                inspect.get_annotations(
-                    inspect_stringized_annotations_pep695.generic_function_2,
-                    eval_str=True
-                ).values()
-            ),
-            set(
-                inspect_stringized_annotations_pep695.generic_function_2.__type_params__
-            )
-        )
-
-    def test_pep_695_generic_method_with_future_annotations(self):
-        ann_module695 = inspect_stringized_annotations_pep695
-        generic_method_annotations = inspect.get_annotations(
-            ann_module695.D.generic_method, eval_str=True
-        )
-        params = {
-            param.__name__: param
-            for param in ann_module695.D.generic_method.__type_params__
-        }
-        self.assertEqual(
-            generic_method_annotations,
-            {"x": params["Foo"], "y": params["Bar"], "return": None}
-        )
-
-    def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_vars(self):
-        self.assertEqual(
-            set(
-                inspect.get_annotations(
-                    inspect_stringized_annotations_pep695.D.generic_method_2,
-                    eval_str=True
-                ).values()
-            ),
-            set(
-                inspect_stringized_annotations_pep695.D.generic_method_2.__type_params__
-            )
-        )
-
-    def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_and_local_vars(self):
-        self.assertEqual(
-            inspect.get_annotations(
-                inspect_stringized_annotations_pep695.E, eval_str=True
-            ),
-            {"x": str},
-        )
-
-    def test_pep_695_generics_with_future_annotations_nested_in_function(self):
-        results = inspect_stringized_annotations_pep695.nested()
-
-        self.assertEqual(
-            set(results.F_annotations.values()),
-            set(results.F.__type_params__)
-        )
-        self.assertEqual(
-            set(results.F_meth_annotations.values()),
-            set(results.F.generic_method.__type_params__)
-        )
-        self.assertNotEqual(
-            set(results.F_meth_annotations.values()),
-            set(results.F.__type_params__)
-        )
-        self.assertEqual(
-            set(results.F_meth_annotations.values()).intersection(results.F.__type_params__),
-            set()
-        )
-
-        self.assertEqual(results.G_annotations, {"x": str})
-
-        self.assertEqual(
-            set(results.generic_func_annotations.values()),
-            set(results.generic_func.__type_params__)
-        )
-
 
 class TestFormatAnnotation(unittest.TestCase):
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_typing_replacement(self):
         from test.typinganndata.ann_module9 import A, ann, ann1
-        self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]')
-        self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]')
+        self.assertEqual(inspect.formatannotation(ann), 'List[str] | int')
+        self.assertEqual(inspect.formatannotation(ann1), 'List[testModule.typing.A] | int')
 
         self.assertEqual(inspect.formatannotation(A, 'testModule.typing'), 'A')
         self.assertEqual(inspect.formatannotation(A, 'other'), 'testModule.typing.A')
         self.assertEqual(
             inspect.formatannotation(ann1, 'testModule.typing'),
-            'Union[List[testModule.typing.A], int]',
+            'List[testModule.typing.A] | int',
         )
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_forwardref(self):
+        fwdref = ForwardRef('fwdref')
+        self.assertEqual(inspect.formatannotation(fwdref), 'fwdref')
+
     def test_formatannotationrelativeto(self):
         from test.typinganndata.ann_module9 import A, ann1
 
@@ -2073,7 +1846,7 @@ class B: ...
         # Not an instance of "type":
         self.assertEqual(
             inspect.formatannotationrelativeto(A)(ann1),
-            'Union[List[testModule.typing.A], int]',
+            'List[testModule.typing.A] | int',
         )
 
 
@@ -2170,7 +1943,7 @@ def function():
         self.assertFalse(inspect.ismethoddescriptor(Owner.static_method))
         self.assertFalse(inspect.ismethoddescriptor(function))
         self.assertFalse(inspect.ismethoddescriptor(a_lambda))
-        self.assertFalse(inspect.ismethoddescriptor(functools.partial(function)))
+        self.assertTrue(inspect.ismethoddescriptor(functools.partial(function)))
 
     def test_descriptor_being_a_class(self):
         class MethodDescriptorMeta(type):
@@ -2252,8 +2025,7 @@ def function():
 _global_ref = object()
 class TestGetClosureVars(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_name_resolution(self):
         # Basic test of the 4 different resolution mechanisms
         def f(nonlocal_ref):
@@ -2269,8 +2041,7 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_generator_closure(self):
         def f(nonlocal_ref):
             def g(local_ref):
@@ -2286,8 +2057,7 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_method_closure(self):
         class C:
             def f(self, nonlocal_ref):
@@ -2303,8 +2073,7 @@ def g(local_ref):
                                        builtin_vars, unbound_names)
         self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_attribute_same_name_as_global_var(self):
         class C:
             _global_ref = object()
@@ -2374,24 +2143,21 @@ def _private_globals(self):
         exec(code, ns)
         return ns["f"], ns
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtins_fallback(self):
         f, ns = self._private_globals()
         ns.pop("__builtins__", None)
         expected = inspect.ClosureVars({}, {}, {"print":print}, {"path"})
         self.assertEqual(inspect.getclosurevars(f), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtins_as_dict(self):
         f, ns = self._private_globals()
         ns["__builtins__"] = {"path":1}
         expected = inspect.ClosureVars({}, {}, {"path":1}, {"print"})
         self.assertEqual(inspect.getclosurevars(f), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_builtins_as_module(self):
         f, ns = self._private_globals()
         ns["__builtins__"] = os
@@ -2486,8 +2252,7 @@ def test_varkw_only(self):
         self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)')
         self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_keyword_only(self):
         f = self.makeCallable('a=3, *, c, d=2')
         self.assertEqualCallArgs(f, 'c=3')
@@ -2528,8 +2293,7 @@ def test_multiple_features(self):
                                  '(4,[5,6])]), q=0, **collections.UserDict('
                                  'y=9, z=10)')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_errors(self):
         f0 = self.makeCallable('')
         f1 = self.makeCallable('a, b')
@@ -2956,7 +2720,7 @@ def __getattribute__(self, attr):
 
         self.assertFalse(test.called)
 
-    @suppress_immortalization()
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <class 'test.test_inspect.test_inspect.TestGetattrStatic.test_cache_does_not_cause_classes_to_persist.<locals>.Foo'> is not None
     def test_cache_does_not_cause_classes_to_persist(self):
         # regression test for gh-118013:
         # check that the internal _shadowed_dict cache does not cause
@@ -2984,33 +2748,28 @@ def number_generator():
     def _generatorstate(self):
         return inspect.getgeneratorstate(self.generator)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_created(self):
         self.assertEqual(self._generatorstate(), inspect.GEN_CREATED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_suspended(self):
         next(self.generator)
         self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_exhaustion(self):
         for i in self.generator:
             pass
         self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_immediate_exception(self):
         with self.assertRaises(RuntimeError):
             self.generator.throw(RuntimeError)
         self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_close(self):
         self.generator.close()
         self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
@@ -3039,8 +2798,7 @@ def test_easy_debugging(self):
             self.assertIn(name, repr(state))
             self.assertIn(name, str(state))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_getgeneratorlocals(self):
         def each(lst, a=None):
             b=(1, 2, 3)
@@ -3105,19 +2863,16 @@ def tearDown(self):
     def _coroutinestate(self):
         return inspect.getcoroutinestate(self.coroutine)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_created(self):
         self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_suspended(self):
         self.coroutine.send(None)
         self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_exhaustion(self):
         while True:
             try:
@@ -3127,15 +2882,13 @@ def test_closed_after_exhaustion(self):
 
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_immediate_exception(self):
         with self.assertRaises(RuntimeError):
             self.coroutine.throw(RuntimeError)
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_closed_after_close(self):
         self.coroutine.close()
         self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
@@ -3178,23 +2931,24 @@ async def number_asyncgen():
     async def asyncTearDown(self):
         await self.asyncgen.aclose()
 
+    @classmethod
+    def tearDownClass(cls):
+        asyncio.events._set_event_loop_policy(None)
+
     def _asyncgenstate(self):
         return inspect.getasyncgenstate(self.asyncgen)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_created(self):
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CREATED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     async def test_suspended(self):
         value = await anext(self.asyncgen)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED)
         self.assertEqual(value, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     async def test_closed_after_exhaustion(self):
         countdown = 7
         with self.assertRaises(StopAsyncIteration):
@@ -3203,15 +2957,13 @@ async def test_closed_after_exhaustion(self):
         self.assertEqual(countdown, 1)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     async def test_closed_after_immediate_exception(self):
         with self.assertRaises(RuntimeError):
             await self.asyncgen.athrow(RuntimeError)
         self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     async def test_running(self):
         async def running_check_asyncgen():
             for number in range(5):
@@ -3234,8 +2986,7 @@ def test_easy_debugging(self):
             self.assertIn(name, repr(state))
             self.assertIn(name, str(state))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     async def test_getasyncgenlocals(self):
         async def each(lst, a=None):
             b=(1, 2, 3)
@@ -3317,7 +3068,7 @@ def test(po, /, pk, pkd=100, *args, ko, kod=10, **kwargs):
             pass
 
         sig = inspect.signature(test)
-        self.assertTrue(repr(sig).startswith('<Signature'))
+        self.assertStartsWith(repr(sig), '<Signature')
         self.assertTrue('(po, /, pk' in repr(sig))
 
         # We need two functions, because it is impossible to represent
@@ -3326,7 +3077,7 @@ def test2(pod=42, /):
             pass
 
         sig2 = inspect.signature(test2)
-        self.assertTrue(repr(sig2).startswith('<Signature'))
+        self.assertStartsWith(repr(sig2), '<Signature')
         self.assertTrue('(pod=42, /)' in repr(sig2))
 
         po = sig.parameters['po']
@@ -3382,6 +3133,17 @@ def test2(pod=42, /):
         with self.assertRaisesRegex(ValueError, 'follows default argument'):
             S((pkd, pk))
 
+        second_args = args.replace(name="second_args")
+        with self.assertRaisesRegex(ValueError, 'more than one variadic positional parameter'):
+            S((args, second_args))
+
+        with self.assertRaisesRegex(ValueError, 'more than one variadic positional parameter'):
+            S((args, ko, second_args))
+
+        second_kwargs = kwargs.replace(name="second_kwargs")
+        with self.assertRaisesRegex(ValueError, 'more than one variadic keyword parameter'):
+            S((kwargs, second_kwargs))
+
     def test_signature_object_pickle(self):
         def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass
         foo_partial = functools.partial(foo, a=1)
@@ -3633,7 +3395,7 @@ def test_signature_on_builtins_no_signature(self):
             (dict.__class_getitem__, meth_o),
         ]
         try:
-            import _stat
+            import _stat  # noqa: F401
         except ImportError:
             # if the _stat extension is not available, stat.S_IMODE() is
             # implemented in Python, not in C
@@ -3768,8 +3530,7 @@ def m1d(*args, **kwargs):
                            ('arg2', 1, ..., "positional_or_keyword")),
                           int))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_classmethod(self):
         if not support.MISSING_C_DOCSTRINGS:
             self.assertEqual(self.signature(classmethod),
@@ -3793,8 +3554,7 @@ def foo(cls, arg1, *, arg2=1):
                            ('arg2', 1, ..., "keyword_only")),
                           ...))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_staticmethod(self):
         if not support.MISSING_C_DOCSTRINGS:
             self.assertEqual(self.signature(staticmethod),
@@ -3819,7 +3579,7 @@ def foo(cls, *, arg):
                           ...))
 
     def test_signature_on_partial(self):
-        from functools import partial
+        from functools import partial, Placeholder
 
         def test():
             pass
@@ -3874,6 +3634,25 @@ def test(a, b, *, c, d):
                            ('d', ..., ..., "keyword_only")),
                           ...))
 
+        # With Placeholder
+        self.assertEqual(self.signature(partial(test, Placeholder, 1)),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', ..., ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, Placeholder, 1, c=2)),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', 2, ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        # Ensure unittest.mock.ANY & similar do not get picked up as a Placeholder
+        self.assertEqual(self.signature(partial(test, unittest.mock.ANY, 1, c=2)),
+                         ((('c', 2, ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
         def test(a, *args, b, **kwargs):
             pass
 
@@ -3921,6 +3700,15 @@ def test(a, *args, b, **kwargs):
                            ('kwargs', ..., ..., "var_keyword")),
                           ...))
 
+        # With Placeholder
+        p = partial(test, Placeholder, Placeholder, 1, b=0, test=1)
+        self.assertEqual(self.signature(p),
+                         ((('a', ..., ..., "positional_only"),
+                           ('args', ..., ..., "var_positional"),
+                           ('b', 0, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
         def test(a, b, c:int) -> 42:
             pass
 
@@ -4025,6 +3813,34 @@ def foo(a, b, /, c, d, **kwargs):
                            ('kwargs', ..., ..., 'var_keyword')),
                          ...))
 
+        # Positional only With Placeholder
+        p = partial(foo, Placeholder, 1, c=0, d=1)
+        self.assertEqual(self.signature(p),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', 0, ..., "keyword_only"),
+                           ('d', 1, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        # Optionals Positional With Placeholder
+        def foo(a=0, b=1, /, c=2, d=3):
+            pass
+
+        # Positional
+        p = partial(foo, Placeholder, 1, c=0, d=1)
+        self.assertEqual(self.signature(p),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', 0, ..., "keyword_only"),
+                           ('d', 1, ..., "keyword_only")),
+                          ...))
+
+        # Positional or Keyword - transformed to positional
+        p = partial(foo, Placeholder, 1, Placeholder, 1)
+        self.assertEqual(self.signature(p),
+                         ((('a', ..., ..., "positional_only"),
+                           ('c', ..., ..., "positional_only")),
+                          ...))
+
     def test_signature_on_partialmethod(self):
         from functools import partialmethod
 
@@ -4037,18 +3853,32 @@ def test():
             inspect.signature(Spam.ham)
 
         class Spam:
-            def test(it, a, *, c) -> 'spam':
+            def test(it, a, b, *, c) -> 'spam':
                 pass
             ham = partialmethod(test, c=1)
+            bar = partialmethod(test, functools.Placeholder, 1, c=1)
 
         self.assertEqual(self.signature(Spam.ham, eval_str=False),
                          ((('it', ..., ..., 'positional_or_keyword'),
                            ('a', ..., ..., 'positional_or_keyword'),
+                           ('b', ..., ..., 'positional_or_keyword'),
                            ('c', 1, ..., 'keyword_only')),
                           'spam'))
 
         self.assertEqual(self.signature(Spam().ham, eval_str=False),
                          ((('a', ..., ..., 'positional_or_keyword'),
+                           ('b', ..., ..., 'positional_or_keyword'),
+                           ('c', 1, ..., 'keyword_only')),
+                          'spam'))
+
+        # With Placeholder
+        self.assertEqual(self.signature(Spam.bar, eval_str=False),
+                         ((('it', ..., ..., 'positional_only'),
+                           ('a', ..., ..., 'positional_only'),
+                           ('c', 1, ..., 'keyword_only')),
+                          'spam'))
+        self.assertEqual(self.signature(Spam().bar, eval_str=False),
+                         ((('a', ..., ..., 'positional_only'),
                            ('c', 1, ..., 'keyword_only')),
                           'spam'))
 
@@ -4138,8 +3968,7 @@ def wrapped_foo_call():
                            ('b', ..., ..., "positional_or_keyword")),
                           ...))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_class(self):
         class C:
             def __init__(self, a):
@@ -4205,17 +4034,15 @@ def __init__(self, b):
 
         with self.subTest('partial'):
             class CM(type):
-                __call__ = functools.partial(lambda x, a: (x, a), 2)
+                __call__ = functools.partial(lambda x, a, b: (x, a, b), 2)
             class C(metaclass=CM):
-                def __init__(self, b):
+                def __init__(self, c):
                     pass
 
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(C(1), (2, 1))
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(self.signature(C),
-                                ((('a', ..., ..., "positional_or_keyword"),),
-                                ...))
+            self.assertEqual(C(1), (2, C, 1))
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
 
         with self.subTest('partialmethod'):
             class CM(type):
@@ -4398,8 +4225,7 @@ def __init__(self, b):
             self.assertEqual(self.signature(C.__call__, follow_wrapped=False),
                              varargs_signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_class_with_wrapped_init(self):
         class C:
             @identity_wrapper
@@ -4451,14 +4277,12 @@ class C:
 
         with self.subTest('partial'):
             class C:
-                __init__ = functools.partial(identity_wrapper(lambda x, a: None), 2)
+                __init__ = functools.partial(identity_wrapper(lambda x, a, b: None), 2)
 
-            with self.assertWarns(FutureWarning):
-                C(1)  # does not raise
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(self.signature(C),
-                                ((('a', ..., ..., "positional_or_keyword"),),
-                                ...))
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
 
         with self.subTest('partialmethod'):
             class C:
@@ -4499,8 +4323,7 @@ def __init__(self, a):
                 self.assertEqual(self.signature(C.__new__, follow_wrapped=False),
                                 varargs_signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_class_with_wrapped_new(self):
         with self.subTest('FunctionType'):
             class C:
@@ -4589,8 +4412,6 @@ def __new__(cls, a):
             self.assertEqual(self.signature(C.__new__, follow_wrapped=False),
                              varargs_signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_signature_on_class_with_init(self):
         class C:
             def __init__(self, b):
@@ -4637,14 +4458,12 @@ class C:
 
         with self.subTest('partial'):
             class C:
-                __init__ = functools.partial(lambda x, a: None, 2)
+                __init__ = functools.partial(lambda x, a, b: None, 2)
 
-            with self.assertWarns(FutureWarning):
-                C(1)  # does not raise
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(self.signature(C),
-                                ((('a', ..., ..., "positional_or_keyword"),),
-                                ...))
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
 
         with self.subTest('partialmethod'):
             class C:
@@ -4657,8 +4476,7 @@ def _init(self, x, a):
                             ((('a', ..., ..., "positional_or_keyword"),),
                             ...))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_class_with_new(self):
         with self.subTest('FunctionType'):
             class C:
@@ -4819,9 +4637,9 @@ class D(C): pass
         with self.assertRaisesRegex(ValueError, "callable.*is not supported"):
             self.assertEqual(inspect.signature(D), None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; NameError: name '_pickle' is not defined. Did you mean: 'pickle'? Or did you forget to import '_pickle'?
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
-    @unittest.skipIf(_pickle is None, "requires _pickle")
     def test_signature_on_builtin_class(self):
         expected = ('(file, protocol=None, fix_imports=True, '
                     'buffer_callback=None)')
@@ -4845,8 +4663,7 @@ class P4(P2, metaclass=MetaP):
             pass
         self.assertEqual(str(inspect.signature(P4)), '(foo, bar)')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_callable_objects(self):
         class Foo:
             def __call__(self, a):
@@ -4902,15 +4719,13 @@ class C:
 
         with self.subTest('partial'):
             class C:
-                __call__ = functools.partial(lambda x, a: (x, a), 2)
+                __call__ = functools.partial(lambda x, a, b: (x, a, b), 2)
 
             c = C()
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(c(1), (2, 1))
-            with self.assertWarns(FutureWarning):
-                self.assertEqual(self.signature(c),
-                                ((('a', ..., ..., "positional_or_keyword"),),
-                                ...))
+            self.assertEqual(c(1), (2, c, 1))
+            self.assertEqual(self.signature(C()),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
 
         with self.subTest('partialmethod'):
             class C:
@@ -5176,6 +4991,11 @@ def foo(a: list[str]) -> Tuple[str, float]:
         self.assertEqual(str(inspect.signature(foo)),
                          inspect.signature(foo).format())
 
+        def foo(x: undef):
+            pass
+        sig = inspect.signature(foo, annotation_format=Format.FORWARDREF)
+        self.assertEqual(str(sig), '(x: undef)')
+
     def test_signature_str_positional_only(self):
         P = inspect.Parameter
         S = inspect.Signature
@@ -5265,6 +5085,18 @@ def func(
             expected_multiline,
         )
 
+    def test_signature_format_unquote(self):
+        def func(x: 'int') -> 'str': ...
+
+        self.assertEqual(
+            inspect.signature(func).format(),
+            "(x: 'int') -> 'str'"
+        )
+        self.assertEqual(
+            inspect.signature(func).format(quote_annotation_strings=False),
+            "(x: int) -> str"
+        )
+
     def test_signature_replace_parameters(self):
         def test(a, b) -> 42:
             pass
@@ -5317,8 +5149,7 @@ def test():
         sig = test.__signature__ = inspect.Signature(parameters=(spam_param,))
         self.assertEqual(sig, inspect.signature(test))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_on_mangled_parameters(self):
         class Spam:
             def foo(self, __p1:1=2, *, __p2:2=3):
@@ -5350,9 +5181,9 @@ class foo: pass
         foo_sig = MySignature.from_callable(foo)
         self.assertIsInstance(foo_sig, MySignature)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; NameError: name '_pickle' is not defined. Did you mean: 'pickle'? Or did you forget to import '_pickle'?
     @unittest.skipIf(MISSING_C_DOCSTRINGS,
                      "Signature information for builtins requires docstrings")
-    @unittest.skipIf(_pickle is None, "requires _pickle")
     def test_signature_from_callable_builtin_obj(self):
         class MySignature(inspect.Signature): pass
         sig = MySignature.from_callable(_pickle.Pickler)
@@ -5500,6 +5331,60 @@ def test_signature_eval_str(self):
                             par('b', PORK, annotation=tuple),
                         )))
 
+    def test_signature_annotation_format(self):
+        ida = inspect_deferred_annotations
+        sig = inspect.Signature
+        par = inspect.Parameter
+        PORK = inspect.Parameter.POSITIONAL_OR_KEYWORD
+        for signature_func in (inspect.signature, inspect.Signature.from_callable):
+            with self.subTest(signature_func=signature_func):
+                self.assertEqual(
+                    signature_func(ida.f, annotation_format=Format.STRING),
+                    sig([par("x", PORK, annotation="undefined")])
+                )
+                s1 = signature_func(ida.f, annotation_format=Format.FORWARDREF)
+                s2 = sig([par("x", PORK, annotation=EqualToForwardRef("undefined", owner=ida.f))])
+                #breakpoint()
+                self.assertEqual(
+                    signature_func(ida.f, annotation_format=Format.FORWARDREF),
+                    sig([par("x", PORK, annotation=EqualToForwardRef("undefined", owner=ida.f))])
+                )
+                with self.assertRaisesRegex(NameError, "undefined"):
+                    signature_func(ida.f, annotation_format=Format.VALUE)
+                with self.assertRaisesRegex(NameError, "undefined"):
+                    signature_func(ida.f)
+
+    def test_signature_deferred_annotations(self):
+        def f(x: undef):
+            pass
+
+        class C:
+            x: undef
+
+            def __init__(self, x: undef):
+                self.x = x
+
+        sig = inspect.signature(f, annotation_format=Format.FORWARDREF)
+        self.assertEqual(list(sig.parameters), ['x'])
+        sig = inspect.signature(C, annotation_format=Format.FORWARDREF)
+        self.assertEqual(list(sig.parameters), ['x'])
+
+        class CallableWrapper:
+            def __init__(self, func):
+                self.func = func
+                self.__annotate__ = func.__annotate__
+
+            def __call__(self, *args, **kwargs):
+                return self.func(*args, **kwargs)
+
+            @property
+            def __annotations__(self):
+                return self.__annotate__(Format.VALUE)
+
+        cw = CallableWrapper(f)
+        sig = inspect.signature(cw, annotation_format=Format.FORWARDREF)
+        self.assertEqual(list(sig.parameters), ['args', 'kwargs'])
+
     def test_signature_none_annotation(self):
         class funclike:
             # Has to be callable, and have correct
@@ -5525,38 +5410,6 @@ def foo(): pass
                 self.assertEqual(signature_func(foo), inspect.Signature())
         self.assertEqual(inspect.get_annotations(foo), {})
 
-    def test_signature_as_str(self):
-        self.maxDiff = None
-        class S:
-            __signature__ = '(a, b=2)'
-
-        self.assertEqual(self.signature(S),
-                         ((('a', ..., ..., 'positional_or_keyword'),
-                           ('b', 2, ..., 'positional_or_keyword')),
-                          ...))
-
-    def test_signature_as_callable(self):
-        # __signature__ should be either a staticmethod or a bound classmethod
-        class S:
-            @classmethod
-            def __signature__(cls):
-                return '(a, b=2)'
-
-        self.assertEqual(self.signature(S),
-                         ((('a', ..., ..., 'positional_or_keyword'),
-                           ('b', 2, ..., 'positional_or_keyword')),
-                          ...))
-
-        class S:
-            @staticmethod
-            def __signature__():
-                return '(a, b=2)'
-
-        self.assertEqual(self.signature(S),
-                         ((('a', ..., ..., 'positional_or_keyword'),
-                           ('b', 2, ..., 'positional_or_keyword')),
-                          ...))
-
     def test_signature_on_derived_classes(self):
         # gh-105080: Make sure that signatures are consistent on derived classes
 
@@ -5637,7 +5490,7 @@ def test_signature_parameter_object(self):
         with self.assertRaisesRegex(ValueError, 'cannot have default values'):
             p.replace(kind=inspect.Parameter.VAR_POSITIONAL)
 
-        self.assertTrue(repr(p).startswith('<Parameter'))
+        self.assertStartsWith(repr(p), '<Parameter')
         self.assertTrue('"a=42"' in repr(p))
 
     def test_signature_parameter_hashable(self):
@@ -6011,7 +5864,7 @@ def test_signature_bind_implicit_arg(self):
         # Issue #19611: getcallargs should work with comprehensions
         def make_set():
             return set(z * z for z in range(5))
-        gencomp_code = make_set.__code__.co_consts[1]
+        gencomp_code = make_set.__code__.co_consts[0]
         gencomp_func = types.FunctionType(gencomp_code, {})
 
         iterator = iter(range(5))
@@ -6139,8 +5992,7 @@ def _strip_non_python_syntax(self, input,
         self.assertEqual(computed_clean_signature, clean_signature)
         self.assertEqual(computed_self_parameter, self_parameter)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_signature_strip_non_python_syntax(self):
         self._strip_non_python_syntax(
             "($module, /, path, mode, *, dir_fd=None, " +
@@ -6279,7 +6131,6 @@ def test_builtins_have_signatures(self):
             'bytearray': {'count', 'endswith', 'find', 'hex', 'index', 'rfind', 'rindex', 'startswith'},
             'bytes': {'count', 'endswith', 'find', 'hex', 'index', 'rfind', 'rindex', 'startswith'},
             'dict': {'pop'},
-            'int': {'__round__'},
             'memoryview': {'cast', 'hex'},
             'str': {'count', 'endswith', 'find', 'index', 'maketrans', 'rfind', 'rindex', 'startswith'},
         }
@@ -6343,14 +6194,14 @@ def test_errno_module_has_signatures(self):
 
     def test_faulthandler_module_has_signatures(self):
         import faulthandler
-        unsupported_signature = {'dump_traceback', 'dump_traceback_later', 'enable'}
+        unsupported_signature = {'dump_traceback', 'dump_traceback_later', 'enable', 'dump_c_stack'}
         unsupported_signature |= {name for name in ['register']
                                   if hasattr(faulthandler, name)}
         self._test_module_has_signatures(faulthandler, unsupported_signature=unsupported_signature)
 
     def test_functools_module_has_signatures(self):
-        no_signature = {'reduce'}
-        self._test_module_has_signatures(functools, no_signature)
+        unsupported_signature = {"reduce"}
+        self._test_module_has_signatures(functools, unsupported_signature=unsupported_signature)
 
     def test_gc_module_has_signatures(self):
         import gc
@@ -6384,7 +6235,7 @@ def test_operator_module_has_signatures(self):
     def test_os_module_has_signatures(self):
         unsupported_signature = {'chmod', 'utime'}
         unsupported_signature |= {name for name in
-            ['get_terminal_size', 'posix_spawn', 'posix_spawnp',
+            ['get_terminal_size', 'link', 'posix_spawn', 'posix_spawnp',
              'register_at_fork', 'startfile']
             if hasattr(os, name)}
         self._test_module_has_signatures(os, unsupported_signature=unsupported_signature)
@@ -6445,8 +6296,7 @@ def test_tokenize_module_has_signatures(self):
         import tokenize
         self._test_module_has_signatures(tokenize)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_tracemalloc_module_has_signatures(self):
         import tracemalloc
         self._test_module_has_signatures(tracemalloc)
@@ -6474,8 +6324,7 @@ def test_weakref_module_has_signatures(self):
         no_signature = {'ReferenceType', 'ref'}
         self._test_module_has_signatures(weakref, no_signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_python_function_override_signature(self):
         def func(*args, **kwargs):
             pass
@@ -6506,9 +6355,8 @@ def func(*args, **kwargs):
         with self.assertRaises(ValueError):
             inspect.signature(func)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @support.requires_docstrings
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_base_class_have_text_signature(self):
         # see issue 43118
         from test.typinganndata.ann_module7 import BufferedReader
@@ -6672,8 +6520,6 @@ def assertInspectEqual(self, path, source):
                 inspected_src.splitlines(True)
             )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getsource_reload(self):
         # see issue 1218234
         with ready_to_import('reload_bug', self.src_before) as (name, path):
@@ -6728,9 +6574,8 @@ def run_on_interactive_mode(self, source):
             raise ValueError("Process didn't exit properly.")
         return output
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @unittest.skipIf(not has_subprocess_support, "test requires subprocess")
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getsource(self):
         output = self.run_on_interactive_mode(textwrap.dedent("""\
         def f():
diff --git a/Lib/test/test_unittest/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
index 7b3cb949e4c..b31c877e22e 100644
--- a/Lib/test/test_unittest/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -495,7 +495,6 @@ async def test_demo1(self):
         result = test.run()
         self.assertTrue(result.wasSuccessful())
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; asyncio.events._set_event_loop_policy is not implemented
     def test_loop_factory(self):
         asyncio.events._set_event_loop_policy(None)